Tensorflow_基础（下）

曾经终败给现在 2022-03-10 15:24 284阅读 0赞

激活函数activation function ：引入激活函数，避免纯线性组合，提高模型的表达力，使模型有更好的区分度

常用的激活函数：tf.nn.relu() / tf.nn.sigmold() / tf.nn.tanh()

NN复杂度：多用NN层数和NN参数个数表示。
层数=隐藏层的层数+1个输出层；
总参数= 总W+总b

神经网络优化：
损失函数loss：
预测值（y）与已知答案（y_）的差距：
NN优化目标：loss最小 :mse (Mean Squared Error）/ 自定义 / ce(Cross Entropy)

均方误差mse：loss_mse=tf.reduce_mean(tf.square(y_-y)

  1. #coding:utf-8
  2. #预测多或少的影响一样
  3. #0导入模块，生成数据集
  4. import tensorflow as tf
  5. import numpy as np
  6. BATCH_SIZE=8
  7. SEED=23455
  9. rdm=np.random.RandomState(SEED)
  10. X=rdm.rand(32,2)
  11. Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X]
  13. #1定义神经网络的输入，参数和输出，定义前向传播过程。
  16. x=tf.placeholder(tf.float32, shape=(None, 2))
  17. y_=tf.placeholder(tf.float32,shape=(None,1))
  18. w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
  19. y=tf.matmul(x,w1)
  21. #2定义损失函数及反向传播过程。
  22. #定义损失函数为MSE,反向传播方法为梯度下降。
  23. loss_mse = tf.reduce_mean(tf.square(y_-y))
  24. train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
  26. #3生成会话，训练STEPS轮：
  27. with tf.Session() as sess:
  28.     init_op = tf.global_variables_initializer()
  29.     sess.run(init_op)
  30.     STEPS=20000
  31.     for i in range(STEPS):
  32.         start=(i*BATCH_SIZE)%32
  33.         end=(i*BATCH_SIZE)%32 + BATCH_SIZE
  34.         sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
  35.         if i % 500 == 0:
  36.             print ("After %d training steps, w1 is :" % (i))
  37.             print ((sess.run(w1)),"\n")
  38.     print ("Final w1 is: \n", sess.run(w1))
  40. 结果：
  41. Final w1 is: 
  42.  [[0.98019385]
  43.  [1.0159807 ]]

自定义损失函数：如预测商品销量，预测多了，损失成本；预测少了，损失利润。若利润与成本不相等，则mse产生的loss无法利益最大化。

  1. loss=tf.reduce_sum(tf.where(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y)))
  2. #tf.where(tf.greater(y,y_)询问  y 是否大于y_,若成立，则取COST(y-y_),不成立取PROFIT(y_-y)
  4. #coding:utf-8
  5. #预测多或少的影响不一样，成本第，利润高
  6. #0导入模块，生成数据集
  7. import tensorflow as tf
  8. import numpy as np
  9. BATCH_SIZE=8
  10. SEED=23455
  11. COST=1
  12. PROFIT=9
  14. rdm=np.random.RandomState(SEED)
  15. X=rdm.rand(32,2)
  16. Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X]
  18. #1定义神经网络的输入，参数和输出，定义前向传播过程。
  21. x=tf.placeholder(tf.float32, shape=(None, 2))
  22. y_=tf.placeholder(tf.float32,shape=(None,1))
  23. w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
  24. y=tf.matmul(x,w1)
  26. #2定义损失函数及反向传播过程。
  27. #定义损失函数为MSE,反向传播方法为梯度下降。
  28. loss_mse = tf.reduce_mean(tf.where(tf.greater(y,y_),(y-y_)*COST,(y_-y)*PROFIT))
  29. train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
  31. #3生成会话，训练STEPS轮：
  32. with tf.Session() as sess:
  33.     init_op = tf.global_variables_initializer()
  34.     sess.run(init_op)
  35.     STEPS=20000
  36.     for i in range(STEPS):
  37.         start=(i*BATCH_SIZE)%32
  38.         end=(i*BATCH_SIZE)%32 + BATCH_SIZE
  39.         sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
  40.         if i % 500 == 0:
  41.             print ("After %d training steps, w1 is :" % (i))
  42.             print ((sess.run(w1)),"\n")
  43.     print ("Final w1 is: \n", sess.run(w1))

交叉熵ce（Cross Entropy）：表征两个概率分布之间的距离

  1. ce=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-12,1.0)))

当n分类的n个输出（y1,y2,…yn）通过softmax()函数，便满足了概率分布要求：

  1. ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
  2. cem = tf.reduce_mean(ce)

输出即为当前预测值与标准答案间的差距，也就是损失函数。

学习率learning_rate：每次参数更新的幅度：
w(n+1) = w(n) - learning_rate*grad
更新后的参数 = 当前参数 - 学习率 * 损失函数的梯度
优化参数w,就是要找到某个参数w使得损失函数的梯度最小，从而使损失函数最小。

  1. #coding:utf-8
  2. #设损失函数为 loss = (w+1)^2,令w的初值是5，反向传播就是求最优w,即求最小loss对应的w的值
  3. import tensorflow as tf
  4. #定义待优化参数w初值为5
  5. w=tf.Variable(tf.constant(5,dtype=tf.float32))
  6. #定义损失函数loss
  7. loss=tf.square(w+1)
  8. #定义反向传播方法
  9. train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
  10. #生成会话，训练40轮
  11. with tf.Session() as sess:
  12.     init_op=tf.global_variables_initializer()
  13.     sess.run(init_op)
  14.     for i in range (40):
  15.         sess.run(train_step)
  16.         w_val = sess.run(w)
  17.         loss_val=sess.run(loss)
  18.         print ("After % steps: w is %f, loss is %f." %(i, w_val,loss_val))

学习率设置多少合适 ：学习率过大震荡不收敛，过小收敛速度漫。
指数衰减学习率：

  1. learning_rate=LEARNING_RATE_BASE.LAERNING_RATE_DECAY 
  2. #学习率基数，学习率初始值 学习率衰减率（0，1） ，
  3. global_step/LEARNING_RATE_STEP 多少轮更新一次学习率=样本总数/BATCH_SIZE
  6. global_step=tf.Variable(0,trainable=False)
  7. learning_rate=tf.train.exponential_decay(
  8. LEARNING_RATE_BASE,
  9. global_step,
  10. LEARNING_RATE_STEP,
  11. LEARNING_RATE_DECAY,
  12. staircase=True)
  14. #coding:utf-8
  15. #设损失函数为 loss = (w+1)^2,令w的初值是10，反向传播就是求最优w,即求最小loss对应的w的值
  16. #使用指数衰减的学习率，在迭代初期得到较高的下降渡，可在较小的训练轮数下取得更有收敛度
  18. import tensorflow as tf
  20. LEARNING_RATE_BASE = 0.1 #最初学习率
  21. LEARNING_RATE_DECAY = 0.99 #学习率衰减率
  22. LEARNING_RATE_STEP = 1 #喂入多少轮的BATCH_SIZE后，更新一次学习率，一般设为：样本总数/BATCH_SIZE
  24. #运行了几轮的BATCH_SIZE的计数器，初值给0，设为不被训练
  25. global_step=tf.Variable(0,trainable=False)
  26. #定义指数下降学习率
  27. learning_rate= tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,LEARNING_RATE_STEP,LEARNING_RATE_DECAY,staircase=True)
  28. #定义待优化参数w初值为10
  29. w=tf.Variable(tf.constant(10,dtype=tf.float32))
  30. #定义损失函数loss
  31. loss=tf.square(w+1)
  32. #定义反向传播方法
  33. train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)
  34. #生成会话，训练40轮
  35. with tf.Session() as sess:
  36.     init_op=tf.global_variables_initializer()
  37.     sess.run(init_op)
  38.     for i in range (40):
  39.         sess.run(train_step)
  40.         learning_rate_val=sess.run(learning_rate)
  41.         global_step_val=sess.run(global_step)
  42.         w_val = sess.run(w)
  43.         loss_val=sess.run(loss)
  44.         print ("After % steps:global_step is %f , w is %f,learning_rate is %f, loss is %f." %(i,global_step_val, w_val,learning_rate_val,loss_val))

滑动平均ema（影子值）：记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。针对所有参数：w 和 b
（像是个参数加了影子，参数变化，影子慢慢追随）

影子 = 衰减率 + 影子 +（1 - 衰减率）+ 参数 影子缓存相随

衰减率 = min { MOVING_AVGRAGE_DECAY ，（1+轮数）/（10+轮数）}

  1. MOVING_AVERAGE_DECAY为0.99，轮数global_step为0，w1的滑动平均值为0，参数w1更新为1则：
  2. w1滑动平均值=min(0.99,1/10)*0+(1-min(0.99,1/10)*1=0.9
  3. 轮数global_step为100时，参数w1更新为10则：
  4. w1滑动平均值=min(0.99,101/110)*0.9+(1-min(0.99,101/110)*10=0.826+0.818=1.644
  5. 再次运行
  6. w1滑动平均值=min(0.99,101/110)*1.644+(1-min(0.99,101/110)*10=2,328
  7. 再次运行
  8. w1滑动平均值=2.956
  10. ema = tf.train.ExponentialMovingAverage(
  11.     衰减率MOVING_AVERAGE_DECAY,
  12.     当前轮数global_step)
  13. ema_op = ema.apply([])
  14. ema_op = ema.apply(tf.trainable_variables()) #
  15. with tf.control_dependencies([train_step,ema_op]):
  16.     train_op=tf.no.op(name='train')
  17. ema.average(参数名) #查看某参数的滑动平均值
  19. #coding:utf-8
  20. import tensorflow as tf
  22. #0定义变量及滑动平均类
  23. #定义一个3位浮点变量，初始值为0.0 这个代码就是不断更新w1参数，优化w1参数，滑动平均做了个w1的影子
  24. w1 = tf.Variable(0, dtype=tf.float32)
  25. #定义num_update（NN的迭代次数），初始值为0，不可被优化（训练），这个参数不训练。
  26. global_step = tf.Variable(0,trainable=False)
  27. #实例化滑动平局类，给删减率0.99,当前轮数global.step
  28. MOVING_AVERAGE_DECAY = 0.99
  29. ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
  30. #ems.apply后的括号例是更新列表，每次运行sess.run(eam_op)时，对更新列表中的元素求滑动平均值
  31. #在实际应用中会使用tf.trainable_variables()自动将所有带训练的参数汇总为列表
  32. #ema_op = ema.apply([w1])
  33. ema_op = ema.apply(tf.trainable_variables())
  35. #查看不同迭代中变量取值的变化
  36. with tf.Session() as sess:
  37.     #初始化
  38.     init_op = tf.global_variables_initializer()
  39.     sess.run(init_op)
  40.     #用ema.average(w1)获取w1滑动平均值 （要运行多个节点，作为列表中的元素列出，写在sess.run中）
  41.     #打印出当前参数w1和w1的滑动平均值。
  42.     print (sess.run([w1,ema.average(w1)]))
  44.     #参数w1的值赋为1.
  45.     sess.run(tf.assign(w1,1))
  46.     sess.run(ema_op)
  47.     print (sess.run([w1,ema.average(w1)]))
  49.     #更新step和w1的值，模拟出100轮迭代后，参数w1变为10
  50.     sess.run(tf.assign(global_step, 100))
  51.     sess.run(tf.assign(w1,10))
  53.     sess.run(ema_op)
  54.     print (sess.run([w1,ema.average(w1)]))
  56.     #每次sess.run 后会更新呢一次w1的滑动平均值
  57.     sess.run(ema_op)
  58.     print (sess.run([w1,ema.average(w1)]))
  60.     sess.run(ema_op)
  61.     print (sess.run([w1,ema.average(w1)]))
  63.     sess.run(ema_op)
  64.     print (sess.run([w1,ema.average(w1)]))
  66.     sess.run(ema_op)
  67.     print (sess.run([w1,ema.average(w1)]))
  69.     sess.run(ema_op)
  70.     print (sess.run([w1,ema.average(w1)]))
  72.     sess.run(ema_op)
  73.     print (sess.run([w1,ema.average(w1)]))

正则化regularization：缓解过拟合
正则化在损失函数中引入模型复杂度指标，利用给w加权，弱化了训练数据的噪声

  1. loss = loss (y与 y_)+REGULARIZER*loss(w)
  2. loss为模型中所有参数的损失函数，如均方误差，交叉熵等
  3. 超参数    REGULARIZER给出参数w在总loss中的比例，即正则化的权重
  4. w是需要 正则化的参数
  6. loss(w) = tf.contrib.layers.l1_regularizer(REGULARIZER)(w) #对所有参数的绝对值求和
  7. loss(w) = tf.contrib.layers.l2_regualrizer(REGULARIZER)(w)#对所有参数的平方的绝对值求和
  8. tf.add_to_collection('losser',tf.contreb.layerss.l2_regularizer(regularizer)(w))
  9. loss = cem +tf.add_n(tf.get_collection('losser'))
  11. import matplotlib,pyplot as plt 
  12. plt.scatter(x坐标，y坐标，c="颜色")
  13. plt.show()
  15. xx,yy = np.mgrid[起止：步长；起止：步长)                 grid = np.c_[xx.ravel(),yy.ravel()]
  16. probs = sess.run(y,feed_dict={x:grid})
  17. probs = probs.reshape(xx.shape)
  19. plt.contour(x轴坐标值，y坐标值，该店的高度，levels=[等高线的高度])
  20. plt.show()
  22. #coding:utf-8
  23. #0导入模块生成模拟数据集
  24. import tensorflow as tf
  25. import numpy as np
  26. import matplotlib.pyplot as plt
  27. BATCH_SIZE = 30
  28. seed = 2
  30. #基于seed产生随机数
  31. rdm = np.random.RandomState(seed)
  33. #随机数返回300行2列，表示300组坐标点， (X0,X1) 作为输入数据集
  34. X=rdm.randn(300,2)
  36. #从X这个300行2列的矩阵中取出一行，判断如果2个坐标的平方和小于2，给Y赋值1，其余赋值0
  37. #作为输入数据集的标签（正确答案）
  38. Y_= [int(x0*x0 + x1*x1 < 2) for (x0,x1 ) in X ]
  40. #遍历Y中的每个元素，1赋值red，其余赋值 blue,这样可视化显示时，人可以直观区分
  41. Y_c = [['red' if y else 'blue'] for y in Y_]
  43. #对数据集X和标签Y进行shape整理，第一个元素为-1表示，第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理成n行1列
  44. X = np.vstack(X).reshape(-1,2)
  45. Y_ = np.vstack(Y_).reshape(-1,1)
  46. print (X)
  47. print (Y_)
  48. print (Y_c)
  50. #用plt.scatter画出数据集x各行中第0列元素和第1列元素的点即各行 （x0,x1） ， 用各行Y_c对应的值表示颜色
  51. plt.scatter(X[:,0],X[:,1], c=np.squeeze(Y_c))
  52. plt.show()
  54. #定义神经网络的输入，参数和输出，定义前向传播过程
  55. def get_weight(shape, regularizer):
  56.     w=tf.Variable(tf.random_normal(shape), dtype=tf.float32)
  57.     tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
  58.     return w
  60. def get_bias(shape):
  61.     b=tf.Variable(tf.constant(0.01, shape=shape))
  62.     return b
  64. x=tf.placeholder(tf.float32, shape=(None, 2))
  65. y_=tf.placeholder(tf.float32, shape=(None, 1))
  67. w1 = get_weight([2,11],0.01)
  68. b1 = get_bias([11])
  69. y1 = tf.nn.relu(tf.matmul(x,w1) + b1)
  71. w2 = get_weight([11,1],0.01)
  72. b2 = get_bias([1])
  73. y = tf.matmul(y1, w2) + b2#输出层不过激活
  75. #定义损失函数
  76. loss_mse = tf.reduce_mean(tf.square(y-y_))
  77. loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
  79. #定义方向传播方法：不含正则化
  80. train_step=tf.train.AdadeltaOptimizer(0.0001).minimize(loss_mse)
  82. with tf.Session() as sess:
  83.     init_op = tf.global_variables_initializer()
  84.     sess.run(init_op)
  85.     STEPS = 40000
  86.     for i in range(STEPS):
  87.         start = (i*BATCH_SIZE)%300
  88.         end = start + BATCH_SIZE
  89.         sess.run(train_step,feed_dict={x:X[start:end], y_:Y_[start:end]})
  90.         if i % 2000 == 0:
  91.             loss_mse_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
  92.             print ("After %d steps , loss is: %f" % (i,loss_mse_v))
  94.         #xx在-3到3之间以步长0.01,yy在-3到3之间以步长0.01，生成二维网格坐标点
  95.         xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
  96.         #将xx,yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
  97.         grid = np.c_[xx.ravel(), yy.ravel()]
  98.         #将网格坐标点喂入神经网络，probs为输出
  99.         probs=sess.run(y, feed_dict={x:grid})
  100.         #prob的shape调整成xx的样子
  101.         probs=probs.reshape(xx.shape)
  102.         print ("w1:\n",sess.run(w1))
  103.         print ("b1:\n",sess.run(b1))
  104.         print ("w2:\n",sess.run(w2))
  105.         print ("b2:\n",sess.run(b2))
  107. plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
  108. plt.contour(xx,yy,probs,levels=[.5])
  109. plt.show()

搭建模块化的神经网络八股：
前线传播即搭建网络，设计网络结果（forward.py）

  1. def forwardd(x, regularizer):  //定义了前向传播过程
  2.     w = 
  3.     b = 
  4.     y = 
  5.     return y
  7. def get_weight(shape,regularizer): //给w赋初值，把每个layers的正则化损失加到总损失中
  8.     w = tf.Variable(   )
  9.     tf.add_to_collection("losses",tf.contrib.layers.l2_regualrizer(regularizer)(w))
  10.     return w
  12. def get_bias(shape): //与参数b有关，某层中b的个数
  13.     b = tf.Vraiable(   )
  14.     return b
  16. def backward(    ):
  17.     x = tf.placeholder(          )
  18.     y_ =tf.placeholder(      )
  19.     global_step = tf.Variable(0,trainable=False)
  20.     loss //loss可以是y与y_的差距=tf.reduce_mean(tf.square(y-y_)) 也可以是
  21.             ce=tf.nn.square_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
  22.             y与y_的差距 = tf.reduce_mean(ce)
  23.             加入正则化后：loss=y与y_的差距 + tf.add_n(tf.get_collection("losses"))
  25. learning_rate = tf.train.exponential_decay( // 指数衰减学习率
  26.     LEARNING_RATE_BASE,
  27.     global_step,
  28.     数据采集样本总数/BATCH_SIZE,
  29.     LEARNING_RATE_DECAY,
  30.     staircase=True)
  31.     train_step=tf.train.GradinetDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
  34. ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step) //滑动平均
  35. ema_op=ema.apply(tf.trainable_variable())
  36. with tf.control_depandencies([train_step,ema_op]);
  37.     train_op = tf.no_op(name="train")
  40. with tf.Sessin() as sess:
  41.     init_op = tf.global_variables_initializer()
  42.     sess.run(init_op)
  44.     for i in range(STEPS):
  45.         sess.run(train_step,feed_dict={x:,y_:})
  46.         if i % 轮数 ==0：
  47.             print
  49. if __name__== '__main__''
  50.     backward()

#generateds

  1. import numpy as np
  2. import matplotlib.pyplot as plt
  3. seed = 2
  5. def generateds():
  6.     rdm = np.random.RandomState(seed)
  7.     X=rdm.randn(300,2)
  8.     Y_=[int(x0*x0 +x1*x1<2) for (x0, x1) in X ]
  9.     Y_c = [['red' if y else 'blue'] for y in Y_]
  10.     X=np.vstack(X).reshape(-1,2)
  11.     Y_=np.vstack(Y_).reshape(-1,1)
  13.     return X, Y_, Y_c

#forward

  1. import tensorflow as tf
  3. def get_weight(shape, regularizer):
  4.     w = tf.Variable(tf.random_normal(shape),dtype=tf.float32)
  5.     tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
  6.     return w
  8. def get_bias(shape):
  9.     b=tf.Variable(tf.constant(0.01,shape=shape))
  10.     return b
  12. def forward(x, regularizer):
  14.     w1 = get_weight([2,11],regularizer)
  15.     b1 = get_bias([11])
  16.     y1 = tf.nn.relu(tf.matmul(x,w1)+b1)
  18.     w2 = get_weight([11,1],regularizer)
  19.     b2 = get_bias([1])
  20.     y = tf.matmul(y1,w2) + b2 #输出层不过激活
  22.     return y

#backward

  1. import tensorflow as tf
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. import forward
  5. import generateds
  7. STEPS=40000
  8. BATCH_SIZE=30
  9. LEARNING_RATE_BASE=0.001
  10. LEARNING_RATE_DECAY=0.999
  11. REGULARIZER = 0.01
  13. def backward():
  14.     x = tf.placeholder(tf.float32, shape=(None,2))
  15.     y_ = tf.placeholder(tf.float32,shape=(None,1))
  17.     X, Y_, Y_c = generateds.generateds()
  18.     y = forward.forward(x,REGULARIZER)
  19.     global_step = tf.Variable(0,trainable = False)
  20.     learning_rate = tf.train.exponential_decay(
  21.             LEARNING_RATE_BASE,
  22.             global_step,
  23.             300/BATCH_SIZE,
  24.             LEARNING_RATE_DECAY,
  25.             staircase=True)
  27.     #定义损失函数
  28.     loss_mse = tf.reduce_mean(tf.square(y-y_))
  29.     loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
  30.     train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)
  32.     with tf.Session() as sess:
  33.         init_op=tf.global_variables_initializer()
  34.         sess.run(init_op)
  35.         for i in range (STEPS):
  36.             start = (i*BATCH_SIZE)%300
  37.             end=start+BATCH_SIZE
  38.             sess.run(train_step,feed_dict={x:X[start:end] , y_:Y_[start:end]})
  39.             if i % 2000 == 0:
  40.                 loss_v =sess.run(loss_total,feed_dict={x:X,y_:Y_ })
  41.                 print ("After %d steps, loss is: %f" % (i,loss_v))
  43.         xx, yy = np.mgrid[-3:3:.01,-3:3:.01 ]
  44.         grid =np.c_[xx.ravel(),yy.ravel()]
  45.         probs = sess.run(y,feed_dict={x:grid})
  46.         probs = probs.reshape(xx.shape)
  48.     plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
  49.     plt.contour(xx,yy, probs,levels=[.5])
  50.     plt.show()
  52. if __name__ == '__main__':
  53.     backward()

发表评论

表情：
评论列表 （有 0 条评论，284人围观）

还没有评论，来说两句吧...

相关阅读

    相关 TensorFlow基础

    深度学习在模式识别方向，尤其是在图像、声音、语音、语言和时间序列数据上表现出色。运用深度学习，你可以对数据进行分类、预测、聚类以及特征提取。2015年11月，谷歌发布了Tens

    偏执的太偏执、偏执的太偏执、/ 0 赞/ 72 阅读

    相关 TensorFlow：基础概念

    首先祝自己生日快乐！！ 趁着大学最后的一点时间学习一点新的东西，希望自己能坚持下去。 这里记录一点这几天学习中记录下的一些概念以及注意点。 基础概念 计算图（g

    以你之姓@以你之姓@/ 0 赞/ 318 阅读

    相关 Tensorflow基础

    一、基础概念 TensorFlow是一种采用数据流图（data flow graphs），用于数值计算的开源软件库。其中 Tensor 代表传递的数据为张量（多维数组），

    红太狼红太狼/ 0 赞/ 341 阅读