TensorFlow框架

基本概念

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

张量(tensor)：多维数组（列表）

阶：张量的维数

维数    阶          名字                例子

0-D      0        标量 scalar        s=123

1-D    1        向量 vector        v=[1,2,3]

2-D    2        矩阵 matrix        m=[[1,2,3],[4,5,6],[7,8,9]]

n-D    3        张量 tensor        t=[[[.........n个

张量可以表示0阶到n阶数组（列表）

数据类型：tf.float32    tf.int32    ....

---

张量加法：

```

import tensorflow as tf

a = tf.constant([1.0 , 2.0])    #constant()代表定义常数

b = tf.constant([3.0 , 4.0])

result = a + b

print(result)

```

#结果显示：Tensor("add:0", shape=(2,), dtype=float32)

                                    |    |          |      |          |

                          节点名  第0个  维    一维    数据类型

                                        输出    度    数组

                                                          长度2

计算图只描述了运算过程，不计算运算结果

---------------------------------------------------------

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

会话（Senssion）：执行计算图中的节点运算。

with tf.Session() as sess:

print(sess.run(y))

参数：即神经元线上的权重W，用变量表示，随机给初值。

w = tf.Variable(tf.random_normal([2,3] , stddev=2 , mean=0 , seed=1))    # tf.Variable() 生成随机数

                              |                          |              |                |              |

                        正态分布      产生2*3矩阵  标准差为2    均值为0  随机种子

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.constant 直接给值    tf.constant([3,2,1]) 生成[3,2,1]

---

神经网络的实现过程：

1、准备数据集，提取特征，作为输入喂给神经网络

2、搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）

      （NN前向传播算法 --> 计算输出）

3、大量特征数据喂给NN，迭代优化NN参数

      （NN反向传播算法 --> 优化参数训练模型）

4、使用训练好的模型预测和分类

--------------------------------------------------------------------------------------

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

eg. 生产一批零件将体积X1和重量X2为特征输入NN，通过NN后输出一个数值。

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

with tf.Session() as sess:

sess.run()

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

init_op = tf.global_variabes_initializer()  #对所有变量初始化（赋初值）

sess.run(init_op)

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

sess.run(y)

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

喂一组数据：

x = tf.placeholder(tf.float32 , shape=(1,2))  #2代表 有两个特征 比如零件有质量和体积两个特征

sess.run(y , feed_dict={x : [[0.5,0.6]]})

喂多组数据：

x = tf.placeholder(tf.float32 , shape=(None,2))

sess.run(y , feed_dict={x : [[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})

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

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

均方误差MSE：

loss = tf.reduce_mean(tf.square(y_-y))

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

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)  #梯度下降

train_step = tf.train.MomentumOptimize(learning_rate).minimize(loss) #Momentum优化器

train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss) #Adam优化器

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

搭建神经网络：准备、前传、后传、迭代

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_initallzer()

sess_run(init_op)

STEPS=3000

for i in range(STEPS):

start=

end=

sess.run(train_step, feed_dict:)

eg:

'''

#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  如果和不小于1  则给Y赋值0     

#Y作为输入数据集的标签（正确答案）  人为给出零件的合格与否 1合格  0不合格

Y = [[int(x0 + x1 < 1)] for (x0,x1) in X]

#上面一行代码类似于下面

#for (x0,x1) in X:

#    if x0+x1<1:

#        Y=1

#    else:

#        Y=0

print("X:\n",X)

print("Y:\n",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))  #[2,3]中 2对应x  3表示隐藏层用3个神经元 

w2 = tf.Variable(tf.random_normal([3,1], stddev=1, seed=1))  #[3,1]中 1对应y  3表示隐藏层用3个神经元

#前向传播过程描述

a = tf.matmul(x, w1)

y = tf.matmul(a, w2)

#2定义损失函数及反向传播方法。

loss = tf.reduce_mean(tf.square(y-y_)) #均方误差

train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)  #梯度下降  学习率0.001

#train_step = tf.train.MomentumOptimize(0.001，0.9).minimize(loss) #Momentum优化器

#train_step = tf.train.AdamOptimizer(0.001).minimize(loss) #Adam优化器

#3生成会话，训练STEPS轮

with tf.Session() as sess:

    init_op = tf.global_variables_initializer() #变量初始化

    sess.run(init_op)

    #输出目前（未经训练）的参数取值

    print("w1:\n",sess.run(w1))

    print("w2:\n",sess.run(w2))

    print("\n")

    #训练模型

    STEPS = 3000 #训练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("After %d training step(s),loss on all data is %g" % (i, total_loss))

    #输出训练后的参数取值 

    print("\n")

    print("w1:\n",sess.run(w1))

    print("w2:\n",sess.run(w2))

'''