tensorflow_基础 (上）

末蓝、 2022-03-09 19:58 220阅读 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阶数组（列表)

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

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

y=XW=x1*w1+x2*w2

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

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

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

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

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

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

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

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

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

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

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

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

sess.run(y)

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

#喂一组数据：
    x=tf.placeholder(tf.float32,shape=(1,2))  #1维2特征
    sess.run(y,feed_dict={x:[[0.5,0.6]]})
    
    #喂多组数据：
    x=tf.placeholder(tf.float32,shape=(None,2)) #维数未知，2特征
    sess.run(y,feed_dict={x:[[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})

#coding:utf-8
    #两层简单的神经网络（全连接）
    import tensorflow  as tf 
    
    #定义输入和参数
    x=tf.constant([[0.7,0.5]])
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))  #两行三列随机数矩阵，标准差为1
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    #定义前向传播过程
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    #用会话计算结果
    with tf.Seesion() as sess:
    	init_op=tf.global_variables_initializer()
    	sess.run(init_op)
    	print (sess.run(y))
    
    ...结果为：
    [[3.0904665]]

#coding:utf-8
    #两层简单的神经网络（全连接）
    import tensorflow as tf
    
    #定义输入和参数
    #用placeholder实现输入定义 （sess.run中为一组数据）
    x=tf.placeholder(tf.float32, shape=(1,2))
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    #定义前向传播过程
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    #用会话计算结果
    with.tf.Session() as sess:
    	init_op=tf.global_variables_initializer()
    	sess.run(init_op)
    	print (sess.run(y, feed_dict={x: [[0.7,0.5]]}))
    
    结果为：
    [[3.0904665]]

#coding:utf-8
    #两层简单神经网络（全连接）
    
    import tensorflow as tf
    
    #定义输入和参数
    #用placeholder定义输入（sess.run喂多组数据）
    x=tf.placeholder(tf.float32, shape=(None,2))
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    #定义前向传播过程
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    #调用会话计算结果
    with tf.Session() as sess:
    	init_op=tf.global_variables_initializer()
    	sess.run(init_op)
    	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值为优化目标

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

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

#coding:utf-8
    #导入模块，生成模拟数据集
    import tensorflow as tf
    import numpy as np
    BATCH_SIZE=8
    seed = 23455
    
    #基于seed产生随机数
    rng=np.random.RandomState(seed)
    #随机数返回32行2列的矩阵，表示32组数据，作为输入数据集
    X=rng.rand(32,2)
    #从X这个32行2列的矩阵中 取出一行，判断如果和小于1，给y赋值1，否则，赋值0
    #作为输入数据集的标签（正确答案）
    Y=[[int(x0 + x1 < 1)] for (x0, x1) in X]
    print (X)
    print (Y)
    
    #1定义神经网络的输入，参数和输出，定义前向传播过程。
    x=tf.placeholder(tf.float32, shape=(None, 2))
    y_=tf.placeholder(tf.float32,shape=(None,1))
    
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    a = tf.matmul(x,w1)
    y = tf.matmul(a,w2)
    
    #2定义损失函数及反向传播方法。
    loss = tf.reduce_mean(tf.square(y_- y))
    #train_step= tf.train.GrandientDescentOptimizer(0.001).minimize(loss)
    train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
    #train_step=tf.train.AdamOptimizer(0.001).minimize(loss)
    
    #3生成会话，训练STEP轮
    with tf.Session() as sess:
    	init_op = tf.global_variables_initializer()
    	sess.run(init_op)
    	print (sess.run(w1),sess.run(w2))
    	print ("\n")
    
    #训练模型
    	STEPS = 3000
    	for i in range(STEPS):
    		start = (i*BATCH_SIZE) %32
    		end = start +BATCH_SIZE
    		sess.run(train_step,feed_dict={x: X[start:end], y_: Y[start:end]})
    		if i % 500 == 0 :
    			total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
    			print (i, total_loss)
    
    	print ("\n")
    	print (sess.run(w1),sess.run(w2))
    结果为：
    [[0.83494319 0.11482951]
     [0.66899751 0.46594987]
     [0.60181666 0.58838408]
     [0.31836656 0.20502072]
     [0.87043944 0.02679395]
     [0.41539811 0.43938369]
     [0.68635684 0.24833404]
     [0.97315228 0.68541849]
     [0.03081617 0.89479913]
     [0.24665715 0.28584862]
     [0.31375667 0.47718349]
     [0.56689254 0.77079148]
     [0.7321604  0.35828963]
     [0.15724842 0.94294584]
     [0.34933722 0.84634483]
     [0.50304053 0.81299619]
     [0.23869886 0.9895604 ]
     [0.4636501  0.32531094]
     [0.36510487 0.97365522]
     [0.73350238 0.83833013]
     [0.61810158 0.12580353]
     [0.59274817 0.18779828]
     [0.87150299 0.34679501]
     [0.25883219 0.50002932]
     [0.75690948 0.83429824]
     [0.29316649 0.05646578]
     [0.10409134 0.88235166]
     [0.06727785 0.57784761]
     [0.38492705 0.48384792]
     [0.69234428 0.19687348]
     [0.42783492 0.73416985]
     [0.09696069 0.04883936]]
    [[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]]
    [[-0.8113182   1.4845988   0.06532937]
     [-2.4427042   0.0992484   0.5912243 ]] [[-0.8113182 ]
     [ 1.4845988 ]
     [ 0.06532937]]
    
    
    0 5.1311817
    500 0.3843913
    1000 0.3835917
    1500 0.3835619
    2000 0.38356063
    2500 0.38356057
    
    
    [[-0.61332554  0.8312484   0.07565959]
     [-2.2577715  -0.14481366  0.5678319 ]] [[-0.10432342]
     [ 0.77349013]
     [-0.04419039]]

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

with tf.session() as sess
    	init_op=tf.global_variables_initalizer()
    	sess_run(init_op)
    
    	STEPS=3000
    	for i in range(STEPS):
    				start=
    				end=
    				sess.run(train_step,feed_dict:)