tensorflow_基础 (上）

末蓝、 2022-03-09 19:58 290阅读 0赞

1.张量，计算图，会话

基于Tnesorflow的NN,用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。

张量（tensor) :多维数组（列表) 阶：张量的维数；
维数：0-D / 1-D / 2-D /n-D
阶： 0 / 1 / 2 / n
名字：标量scalar / 向量vector / 矩阵matrix / 张量tensor
例子：s=123, / v=[1,2,3] / m=[[1,2,3],[4,5,6],[7,8,9]] / t=[[[…n个
张量可以表示0阶到n阶数组（列表)

  1. import tensorflow as tf
  2. a=tf.constant([1.0,2.0])  #定义常数
  3. b=tf.constant([3.0,4.0])
  4. result=a+b
  5. print (result)
  7. 显示Tensor("add:0",shape=(2,),dtype=float32)
  8. //节点名add,第0个输出； 维度shape,一维数组长度为2； 数据类型为float32

计算图（Graph)：搭建神经网络的计算过程，只搭建，不运算。

y=XW=x1w1+x2w2

  1. import tensorflow as tf
  2. x=tf.constant([[1.0,2.0]])
  3. w=tf.constant([[3.0] , [4.0]])
  4. y=tf.matmul(x,w)
  5. print (y)
  7. 显示Tensor(*matmul:0*,shape(1,1),dtype=float32)

会话(Seesion)：执行计算图中的节点运算。

  1. import tensorflow as tf
  2. x=tf.constant([[1.0,2.0]])
  3. y=tf.constant([[3.0],[4.0]])
  4. y=tf.matmul(x,w)
  5. print (y)
  6. with tf.Session() as sess:
  7.     print sess.run(y)
  9. 结果：
  10. Tensor("MatMul_1:0", shape=(1, 1), dtype=float32)
  11. [[11.]]

参数：即权重 w ，用变量表示，随机给初值。

  1. w=tf.Variable(ts.random_normal([2,3], stddev=2, mean=0, seed= 1))
  3. //random_normal正态分布 ，产生2*3的矩阵，标准差为2，均值为0，随机种子为1
  4. //tf.truncated_normal() 去掉过大偏离点的正态分布，如果生成数据超过平均值两个标准差，则重新生成
  5. //tf.random_uniform() 平均分布。
  6. //tf.zeros 全0数组  tf.zeros([3,2],int32)生成[[0,0],[0,0],[0,0]]
  7. //tf.ones 全1数组  tf.ones([3,2],int32)生成[[1,1],[1,1],[1,1]]
  8. //tf.fill全定值数组 tf.fill([3,2],6)生成 [[6,6],[6,6],[6,6]]
  9. //tf.cnostant直接给值 tf.constant([3,2,1])生成[3,2,1]

神经网络实现过程：
1.准备数据集，提取特征，作为输入喂给神经网络
2.搭建NN结构，从输入到输出：（先搭建计算图，再用会话执行）
（NN前向传播算法===>计算输出）
3.大量特征数据喂给NN，迭代优化NN参数
（NN反向传播算法===>优化参数训练模型）
4.使用训练好的模型预测和分类。

前向传播：搭建模型，实现推理（以全连接网络为例）

变量初始化，计算图节点运算，都要用到会话（with结构实现）

  1. with.tf.Session() as sess:
  2.     sess.run()

变量初始化：在sess.run()函数中用tf.global_variable_initalizer()

  1. init_op=tf.global_variable_initlizer()
  2. sess.run(init_op)

计算图节点运算：在sess.run函数中写入待运算的节点

  1. sess.run(y)

用tf.placeholder占位，在sess.run函数中用feed_dict喂数据：

  1. #喂一组数据：
  2. x=tf.placeholder(tf.float32,shape=(1,2))  #1维2特征
  3. sess.run(y,feed_dict={x:[[0.5,0.6]]})
  5. #喂多组数据：
  6. x=tf.placeholder(tf.float32,shape=(None,2)) #维数未知，2特征
  7. sess.run(y,feed_dict={x:[[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})
  9. #coding:utf-8
  10. #两层简单的神经网络（全连接）
  11. import tensorflow  as tf 
  13. #定义输入和参数
  14. x=tf.constant([[0.7,0.5]])
  15. w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))  #两行三列随机数矩阵，标准差为1
  16. w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  18. #定义前向传播过程
  19. a=tf.matmul(x,w1)
  20. y=tf.matmul(a,w2)
  22. #用会话计算结果
  23. with tf.Seesion() as sess:
  24.     init_op=tf.global_variables_initializer()
  25.     sess.run(init_op)
  26.     print (sess.run(y))
  28. ...结果为：
  29. [[3.0904665]]
  31. #coding:utf-8
  32. #两层简单的神经网络（全连接）
  33. import tensorflow as tf
  35. #定义输入和参数
  36. #用placeholder实现输入定义 （sess.run中为一组数据）
  37. x=tf.placeholder(tf.float32, shape=(1,2))
  38. w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  39. w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  41. #定义前向传播过程
  42. a=tf.matmul(x,w1)
  43. y=tf.matmul(a,w2)
  45. #用会话计算结果
  46. with.tf.Session() as sess:
  47.     init_op=tf.global_variables_initializer()
  48.     sess.run(init_op)
  49.     print (sess.run(y, feed_dict={x: [[0.7,0.5]]}))
  51. 结果为：
  52. [[3.0904665]]
  54. #coding:utf-8
  55. #两层简单神经网络（全连接）
  57. import tensorflow as tf
  59. #定义输入和参数
  60. #用placeholder定义输入（sess.run喂多组数据）
  61. x=tf.placeholder(tf.float32, shape=(None,2))
  62. w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  63. w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  65. #定义前向传播过程
  66. a=tf.matmul(x,w1)
  67. y=tf.matmul(a,w2)
  69. #调用会话计算结果
  70. with tf.Session() as sess:
  71.     init_op=tf.global_variables_initializer()
  72.     sess.run(init_op)
  73.     print (sess.run(y, feed_dict={x: [[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]} , sess.run(w1),sess.run(w2))

反向传播：训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小。

损失函数（loss)：预测值（y）与已知答案（y_）的差距

均方误差MSE: loss= tf.reduce_mean(tf.squaree(y_- y))

反向传播训练方法：以减小loss值为优化目标

  1. train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
  2. train_step=tf.train.MomentumOptimizer(learning_rate,momentum).minimize(loss)
  3. train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)

学习率：决定参数每次更新的幅度

  1. #coding:utf-8
  2. #导入模块，生成模拟数据集
  3. import tensorflow as tf
  4. import numpy as np
  5. BATCH_SIZE=8
  6. seed = 23455
  8. #基于seed产生随机数
  9. rng=np.random.RandomState(seed)
  10. #随机数返回32行2列的矩阵，表示32组数据，作为输入数据集
  11. X=rng.rand(32,2)
  12. #从X这个32行2列的矩阵中 取出一行，判断如果和小于1，给y赋值1，否则，赋值0
  13. #作为输入数据集的标签（正确答案）
  14. Y=[[int(x0 + x1 < 1)] for (x0, x1) in X]
  15. print (X)
  16. print (Y)
  18. #1定义神经网络的输入，参数和输出，定义前向传播过程。
  19. x=tf.placeholder(tf.float32, shape=(None, 2))
  20. y_=tf.placeholder(tf.float32,shape=(None,1))
  22. w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  23. w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  25. a = tf.matmul(x,w1)
  26. y = tf.matmul(a,w2)
  28. #2定义损失函数及反向传播方法。
  29. loss = tf.reduce_mean(tf.square(y_- y))
  30. #train_step= tf.train.GrandientDescentOptimizer(0.001).minimize(loss)
  31. train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
  32. #train_step=tf.train.AdamOptimizer(0.001).minimize(loss)
  34. #3生成会话，训练STEP轮
  35. with tf.Session() as sess:
  36.     init_op = tf.global_variables_initializer()
  37.     sess.run(init_op)
  38.     print (sess.run(w1),sess.run(w2))
  39.     print ("\n")
  41. #训练模型
  42.     STEPS = 3000
  43.     for i in range(STEPS):
  44.         start = (i*BATCH_SIZE) %32
  45.         end = start +BATCH_SIZE
  46.         sess.run(train_step,feed_dict={x: X[start:end], y_: Y[start:end]})
  47.         if i % 500 == 0 :
  48.             total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
  49.             print (i, total_loss)
  51.     print ("\n")
  52.     print (sess.run(w1),sess.run(w2))
  53. 结果为：
  54. [[0.83494319 0.11482951]
  55.  [0.66899751 0.46594987]
  56.  [0.60181666 0.58838408]
  57.  [0.31836656 0.20502072]
  58.  [0.87043944 0.02679395]
  59.  [0.41539811 0.43938369]
  60.  [0.68635684 0.24833404]
  61.  [0.97315228 0.68541849]
  62.  [0.03081617 0.89479913]
  63.  [0.24665715 0.28584862]
  64.  [0.31375667 0.47718349]
  65.  [0.56689254 0.77079148]
  66.  [0.7321604  0.35828963]
  67.  [0.15724842 0.94294584]
  68.  [0.34933722 0.84634483]
  69.  [0.50304053 0.81299619]
  70.  [0.23869886 0.9895604 ]
  71.  [0.4636501  0.32531094]
  72.  [0.36510487 0.97365522]
  73.  [0.73350238 0.83833013]
  74.  [0.61810158 0.12580353]
  75.  [0.59274817 0.18779828]
  76.  [0.87150299 0.34679501]
  77.  [0.25883219 0.50002932]
  78.  [0.75690948 0.83429824]
  79.  [0.29316649 0.05646578]
  80.  [0.10409134 0.88235166]
  81.  [0.06727785 0.57784761]
  82.  [0.38492705 0.48384792]
  83.  [0.69234428 0.19687348]
  84.  [0.42783492 0.73416985]
  85.  [0.09696069 0.04883936]]
  86. [[1], [0], [0], [1], [1], [1], [1], [0], [1], [1], [1], [0], [0], [0], [0], [0], [0], [1], [0], [0], [1], [1], [0], [1], [0], [1], [1], [1], [1], [1], [0], [1]]
  87. [[-0.8113182   1.4845988   0.06532937]
  88.  [-2.4427042   0.0992484   0.5912243 ]] [[-0.8113182 ]
  89.  [ 1.4845988 ]
  90.  [ 0.06532937]]
  93. 0 5.1311817
  94. 500 0.3843913
  95. 1000 0.3835917
  96. 1500 0.3835619
  97. 2000 0.38356063
  98. 2500 0.38356057
  101. [[-0.61332554  0.8312484   0.07565959]
  102.  [-2.2577715  -0.14481366  0.5678319 ]] [[-0.10432342]
  103.  [ 0.77349013]
  104.  [-0.04419039]]

搭建神经网络八股：准别，前传，反传，迭代
0 准备： import / 常量定义 / 生成数据集
1 前向传播： 定义输入，参数和输出 x=/y_=/ w1=/w2= /a=/y=
2 反向传播： 定义损失函数，反向传播方法 loss= / train_step=
3 生成会话，训练STEPS轮

  1. with tf.session() as sess
  2.     init_op=tf.global_variables_initalizer()
  3.     sess_run(init_op)
  5.     STEPS=3000
  6.     for i in range(STEPS):
  7.                 start=
  8.                 end=
  9.                 sess.run(train_step,feed_dict:)

发表评论

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

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

相关阅读

    相关 TensorFlow基础

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

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

    相关 TensorFlow：基础概念

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

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

    相关 tensorflow_基础 (上）

    1.张量，计算图，会话 基于Tnesorflow的NN,用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重（参数），得到模型。 张量（tensor) :

    末蓝、末蓝、/ 0 赞/ 291 阅读

    相关 Tensorflow基础

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

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