人工智能培训

搜索

人工智能的应用:使用Tensorflow和python进行机器学习的随机与小批量训练

[复制链接]
hhtonyhh 发表于 2018-7-22 17:32:30 | 显示全部楼层 |阅读模式
hhtonyhh 2018-7-22 17:32:30 803 0 显示全部楼层
kZ10HETThE6bA2aS.jpg

随机训练一次是对一个随机选择的示例进行训练,而小批量训练则是对整个示例的一部分进行训练。
Mini-batch大小可能取决于你的数据的大小。在后面的教程中,我将向您展示一些选择良好的小批量大小的最佳实践。
注意:我们将使用Tensorflow和python实现和可视化这些培训。让我们从随机训练开始。
随机训练

在这个示例中,我们将从均值1和标准差0.1的正态分布中抽取随机数。然后我们对它进行一个简单的线性运算,即将它乘以一个变量W,然后我们将在输出和目标之间应用一个损失函数(L2范数)在这个例子中我们将它设置为常数10。
#Load our libraries
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()
# We create our data, placeholders and variables
x_val = np.random.normal(1, 0.1, 100) #input values
y_val = np.repeat(10., 100) #target values
# placeholders
x_data = tf.placeholder(shape=[1], dtype=tf.float32)
y_target = tf.placeholder(shape=[1], dtype=tf.float32)
#Variables
w = tf.Variable(0.)
# Add linear function to the computational graph
y_pred = tf.multiply(x_data, w)
# Add a loss function(L2 norm)
loss = tf.square(y_pred - y_target)
# initialize our variables
init = tf.global_variables_initializer()
sess.run(init)
接下来,我们使用优化算法优化损失。优化算法需要知道每次迭代的步骤。该距离由学习率控制。如果我们的学习率太大,我们的算法可能会超过最小值,如果我们的学习率太小,我们的算法可能需要很长时间才能收敛; 这与梯度消失和爆炸问题有关。
在下面的Python代码中,我们将通过循环遍历算法多次训练我们的模型。我们将每20次迭代打印更新的结果。为了训练,我们将使用随机梯度下降训练,通过随机选择输入和目标的值,并将其馈送到图形。
Tensorflow将自动计算损失并更新变量W以最大限度地减少损失。
# Declare an optimizer: here i use gradient descent
my_opt = tf.train.GradientDescentOptimizer(learning_rate=0.02)
#Create the train step
train_step = my_opt.minimize(loss)
n_iterations = 100
loss_stochastic = []
for i in range(n_iterations):
rand_index = np.random.choice(100)
rand_x = [x_val[rand_index]]
rand_y = [y_val[rand_index]]
#Run the graph
sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})
#Print the result after 5 intervals
if(i+1) % 5 == 0:
print('Step #', str(i+1), 'W = ', str(sess.run(W_st)))
temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})
loss_stochastic.append(temp_loss)
print('Loss = ', temp_loss)
....................
#The result for the last six printouts
Step # 75 W = [[0.]]
Loss = [2.2099369]
Step # 80 W = [[0.]]
Loss = [0.31921482]
Step # 85 W = [[0.]]
Loss = [0.51661664]
Step # 90 W = [[0.]]
Loss = [0.00483979]
Step # 95 W = [[0.]]
Loss = [2.0451872]
Step # 100 W = [[0.]]
Loss = [0.07890321]
小批量训练

执行小批量训练遵循与上述相同的步骤,唯一的主要区别是我们将使用批量训练示例而不是一个。在这里,我们选择批量大小。这是一次将多少数据观察结果输入计算图。
接下来我们声明数据,Variables和Placholders。由于批量大小,我们将使它们成为二维的。
第一个维度将保留批量大小,我们现在将其设置为“None”。这里的“None”只是一个占位符,这意味着它可以在以后接受任何维度,而第二维度是特定数据具有的特征/点数。
最后,我们将操作添加到图表中。
注意:操作现在将是矩阵乘法而不是常规乘法,因为我们一次在多个样本上进行矢量化。
请记住,矩阵乘法不是交际的,所以我们必须以正确的顺序将矩阵输入到Tensorflow的 matmul()函数中
Python代码如下:
#Load our libraries
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
sess = tf.Session()
# declare batch size
batch_size = 20
x_vals = np.random.normal(1, 0.1, 100)
y_vals = np.repeat(10., 100)
X_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
Y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
W = tf.Variable(tf.constant(0., shape=[1,1])) #It is good practice to initialize the weight to zero
#Add our simple operation to the computational graph
Y_pred = tf.matmul(X_data, W)
# initialize our variables
init = tf.global_variables_initializer()
sess.run(init)
由于我们正在进行批处理更新,我们的损失函数(本例中为L2范数)将会改变,因为我们必须对批处理中每个数据点的所有L2损失进行平均。我们通过在Tensorflow的reduce_mean()函数中封装正常的L2损失函数来实现这一点:
最后,我们定义了训练循环,并对训练步骤进行迭代以优化算法。在这里,我们将每隔20个时间间隔存储所产生的损失,这样我们就可以将结果与随机训练相比较。
loss = tf.reduce_mean(tf.square(Y_pred - Y_target))
# Declare the optimizer (G.D)
my_opt = tf.train.GradientDescentOptimizer(0.02)
train_step = my_opt.minimize(loss)
loss_batch = []
for i in range(100):
#pick a random 20 data points
rand_index = np.random.choice(100, size=batch_size)
x_batch = np.transpose([x_vals[rand_index]]) # Transpose to the correct shape
y_batch = np.transpose([y_vals[rand_index]])
sess.run(train_step, feed_dict={X_data: x_batch, Y_target:y_batch})
#Print the result after 5 intervals
if(i+1) % 5 == 0:
print('Step #', str(i+1), 'W = ', str(sess.run(W)))
temp_loss = sess.run(loss, feed_dict={X_data: x_batch, Y_target:y_batch})
loss_batch.append(temp_loss)
print('Loss = ', temp_loss)
....................
#The result for the last five printouts.
Step # 80 W = [[9.511334]]
Loss = 2.1000686
Step # 85 W = [[9.578172]]
Loss = 1.021298
Step # 90 W = [[9.592099]]
Loss = 0.54921734
Step # 95 W = [[9.635986]]
Loss = 0.8693684
Step # 100 W = [[9.696052]]
Loss = 0.9552757
为了了解两种训练方法之间的收敛程度如何不同,我们将绘制小批量损失与随机损失的关系。
plt.plot(range(0, 100, 5), loss_batch, 'r--', label='Batch Loss')
plt.plot(range(0, 100, 5), loss_stochastic, 'b-', label='Stochastic Loss')
plt.legend(loc='upper right')
plt.title('Batch training vs Stochastic training')
plt.show()
okg60RPS2x2U6GGW.jpg

从上面的图中,你会发现小批量损失是平滑的,而随机图是很嘈杂的。
通常,随机训练可以轻松避免局部最小值,因为每个输入的随机性,但通常需要较长的时间来收敛,而小批量训练可以快速找到最小值,但如果选择的批量大,则可能需要更多的计算能力。
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则 返回列表 发新帖

hhtonyhh当前离线
新手上路

查看:803 | 回复:0

快速回复 返回顶部 返回列表