Este artículo utiliza la regresión logística para ajustar datos bidimensionales como ejemplo para demostrar los pasos básicos de desarrollo de tensorflow.
Ejemplo: Encuentre la ley de y≈2x a partir de un conjunto de datos aparentemente caóticos
Descripción de ejemplo:
Suponga que hay un conjunto de conjuntos de datos cuya relación correspondiente entre xey es y≈2x.
Hay aproximadamente cuatro pasos en el aprendizaje profundo:
(1) Preparar datos
(2) Construir modelo
(3) Entrenamiento iterativo
(4) Usar modelo
3. Entrenamiento iterativo
(1) Modelo de formación
A través del primer paso para aprender el aprendizaje profundo (1) Pasos básicos de desarrollo de TensorFlow: preparar datos y construir un modelo (avance + retroceso) El segundo paso para construir el modelo, el modelo se puede entrenar a través de la iteración .
Nota: las tareas en tensorflow se llevan a cabo a través de la sesión
# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量
# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2
# 启动session
with tf.Session() as sess:
sess.run(init) # 通过sess.进行网络节点的运算
plotdata = {
"batchsize":[],"loss":[]} # 存放批次值和损失值
# 向模型输入数据
for epoch in range(training_epochs):
for (x, y) in zip(train_X, train_Y):
sess.run(optimizer, feed_dict={
X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置
# 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
if epoch % display_step == 0:
loss = sess.run(cost, feed_dict={
X: train_X, Y:train_Y})
print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
if not (loss == "NA" ):
plotdata["batchsize"].append(epoch)
plotdata["loss"].append(loss)
print (" Finished!")
print ("cost=", sess.run(cost, feed_dict={
X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
Los resultados muestran que:
Se puede ver en los resultados anteriores que el costo (la brecha entre el valor predicho generado y el valor real) es cada vez más pequeño, y W yb (dos parámetros) cambian constantemente.
(2) Visualización del modelo de entrenamiento
# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量
# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2
# 启动session
with tf.Session() as sess:
sess.run(init) # 通过sess.进行网络节点的运算
plotdata = {
"batchsize":[],"loss":[]} # 存放批次值和损失值
# 向模型输入数据
for epoch in range(training_epochs):
for (x, y) in zip(train_X, train_Y):
sess.run(optimizer, feed_dict={
X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置
# 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
if epoch % display_step == 0:
loss = sess.run(cost, feed_dict={
X: train_X, Y:train_Y})
print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
if not (loss == "NA" ):
plotdata["batchsize"].append(epoch)
plotdata["loss"].append(loss)
print (" Finished!")
print ("cost=", sess.run(cost, feed_dict={
X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
def moving_average(a,w=10): # 定义moving_average()函数
if len(a) < w:
return a[:]
return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]
#图形显示
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
plt.legend()
plt.show()
plotdata["avgloss"] = moving_average(plotdata["loss"])
plt.figure(1)
plt.subplot(211)
plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
plt.xlabel('Minibatch number')
plt.ylabel('Loss')
plt.title('Minibatch run vs. Training loss')
plt.show()
Los resultados muestran que:
- La línea oblicua que se muestra en la primera imagen es la ecuación lineal de xey formada cuando los parámetros w y b del modelo son constantes, es casi una línea recta con y = 2x.
- En la segunda imagen, se puede ver que el valor de la pérdida ha ido disminuyendo al principio y se ha estabilizado alrededor de la quinta vez.
4. Usa el modelo
Una vez entrenado el modelo, solo necesita pasar un valor de entrada y luego usar sess.run para ejecutar cada nodo en el modelo para usar el modelo.
# 初始化变量
init = tf.global_variables_initializer() # global_variables_initializer（）函数初始化所有变量
# 训练参数
training_epochs = 20 # 设置迭代次数为20次
display_step = 2
# 启动session
with tf.Session() as sess:
sess.run(init) # 通过sess.进行网络节点的运算
plotdata = {
"batchsize":[],"loss":[]} # 存放批次值和损失值
# 向模型输入数据
for epoch in range(training_epochs):
for (x, y) in zip(train_X, train_Y):
sess.run(optimizer, feed_dict={
X: x, Y: y}) # 通过feed机制将真实数据灌到占位符（第二步创建模型时）对应的位置
# 输出显示训练中的详细信息，每执行一次都会将网络结构的节点打印出来
if epoch % display_step == 0:
loss = sess.run(cost, feed_dict={
X: train_X, Y:train_Y})
print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
if not (loss == "NA" ):
plotdata["batchsize"].append(epoch)
plotdata["loss"].append(loss)
print (" Finished!")
print ("cost=", sess.run(cost, feed_dict={
X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
def moving_average(a,w=10): # 定义moving_average()函数
if len(a) < w:
return a[:]
return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]
#图形显示
plt.plot(train_X, train_Y, 'ro', label='Original data')
plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
plt.legend()
plt.show()
plotdata["avgloss"] = moving_average(plotdata["loss"])
plt.figure(1)
plt.subplot(211)
plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
plt.xlabel('Minibatch number')
plt.ylabel('Loss')
plt.title('Minibatch run vs. Training loss')
plt.show()
print ("x=0.2，z=", sess.run(z, feed_dict={
X: 0.2}))
Por ejemplo, la última línea del código anterior es: pasar un 0.2 (feed_dict = {X: 0.2}), y luego usar sess.run para ejecutar el nodo z en el modelo, y luego puede ver el valor que genera .
produce resultado:
