入门tensorflow笔记之tensorflow框架

1.使用tensorflow搭建神经网络时：通常使用张量表示数据，用计算图搭建神经网络，使用会话执行计算图，优化神经网络的参数，得到模型。
张量（tensor）:多维数组（列表） 阶：张量的维数。

张量可以表示0阶到n阶的数组。
tensorflow的数据类型有tf.float32 tf.int32等等。

import tensorflow as tf
a=tf.constant([1.0,2.0])
##定义常量a
b=tf.constant([3.0,4.0])
##定义常量b
result=a+b
print(result)
##打印出来的结果是一个计算图，并没有给出计算的结果
##对应结果的参数的含义：（节点名，第0个输出，维度，一维数组的长度为2，数据类型）

结果如下：

计算图（graph）的定义:
搭建神经网络的计算过程，只搭建，不运算。承载一个或者多个计算节点的一个图。
神经元的基本模型：

例如给出如下式子：

代码如下：

x=tf.constant([[1.0,2.0]])
##一行两列的张量x
w=tf.constant([[3.0],[4.0]])
##两行一列的张量w
y=tf.matmul(x,w)
##实现矩阵乘法
print(y)

结果如下：

结果shape是一行一列的矩阵。
如果要得到计算结果，就要用到会话了。会话（session）:执行计算图中的节点运算。

x=tf.constant([[1.0,2.0]])
##一行两列的张量x
w=tf.constant([[3.0],[4.0]])
##两行一列的张量w
y=tf.matmul(x,w)
##实现矩阵乘法
with tf.Session() as sess:
    print(sess.run(y))
##使用session进行会话操作。

结果：

神经网络的参数：

参数变量w的命令：
w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))
参数含义：
tf.random_normal([2,3]):正态分布，产生2x3的矩阵。
stddev=2:标准差为2
mean=0:均值为0
seed=1:随机种子
除此之外：
tf.truncated_normal()可以替换tf.random_normal()函数。表示去掉过大偏离点的正态分布。如果随机出来的数据偏离平均值超过两个标准差的，这个数据重新生成。
tf.random_uniform():也可以替换tf.random_normal()函数。表示平均分布函数。
也可以生成常量：
tf.zero 生成全零数组
tf.ones 生成全1数组
tf.fill 生成全定值数组
tf.constant 直接给定值。

神经网络的实现过程：
1、准备数据集，提取特征，作为输入喂给神经网络。
2、搭建神经网络结构，从输入到输出，先搭建计算图，再用会话执行。
神经网络前向传播算法->计算输出。反向传播算法->优化参数训练模型。
3、大量特征数据喂给神经网络，迭代优化神经网络参数。
4、使用训练好的模型进行预测和分类。
前向传播：搭建模型的计算过程，使得模型具有推理能力。针对输入给出输出。
例子：生产一批零件将体积x1和重量x2作为特征输入神经网络，通过神经网络后输出一个数值。



变量的初始化、计算图节点原酸都要用到会话实现：
with tf.Session() as sess:
sess.run()
变量初始化：在sess.run函数中用tf.global_variables_initializer()
init_op=tf.global_variable_initializer()
sess.run(init_op)
计算图节点运算：在sess.run函数中写入待运算的节点。
sess.run(y)
用tf.placeholder占位，在sess.run函数中用feed_dict喂数据。
喂一组数据：
x=tf.placeholder(tf.float32,shape=(1,2))
sess.run(y,feed_dict={x:[[0.5,0.6]]}
参数解释：tf.float32是指数据类型，shape中1是指一组数据，2是指两个特征。
使用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]})

##两层简单神经网络（全连接）
import tensorflow as tf
##定义输入和参数
X=tf.constant([[0.7,0.5]])
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))

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]]}))

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]]}))

反向传播:
训练模型参数，在所有的参数上用梯度下降的方法，使得神经网络模型在训练数据上损失函数最小。
损失函数（loss）:预测值（y）与已知的答案（y_）的差距
均方误差MSE:

loss=tf.reduce_mean(tf.sequence(y_-y))
反向传播训练算法：以减小loss值为优化目标。

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

##反向传播
#0导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
##表示一次喂入神经网络的数目
seed=23455

#基于sedd产生随机数
rng=np.random.RandomState(seed)
#随机数返回32行2列的矩阵 表示32组 体积和重量 作为输入数据集
X=rng.rand(32,2)
#从X这个32行2列的矩阵中，取出一行判断如果和小于1  给Y赋值1 
# 如果和不小于1 给Y赋值0
#认为定义合格零件的标准为：把体积和重量小于1的零件是合格的
#作为输入数据集的标签（正确答案）
Y=[[int(x0+x1<1)] for (x0,x1) in X]
#对数据进行标注
print('X',X)
print('Y',Y)

##1.定义神经网络的输入、参数和输出，定义前向传播过程。
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
#标签值就一个元素所以是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.GradientDescentOptimizer(0.001).minimize(loss)
##梯度下降
##train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
##train_step=tf.train.AdadeltaOptimizer(0.001).minimize(loss)

#3生成会话，训练step轮
with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    ##打印出训练前的参数
    print('W1',sess.run(W1))
    print('W2',sess.run(W2))
    print('\n')
    
    #训练模型
    STEPS=3000
    #训练300次
    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:
            #每500次打印一次
            total_loss=sess.run(loss,feed_dict={x:X,y_:Y})
            print("Afetr %d training step ,loss on all data is %g"%(i,total_loss))
    #输出训练后的参数取值
    print("\n")
    print("w1:\n",sess.run(W1))
   

神经网络搭建的八股：准备、前传、反传、迭代。
0准备
import 模块
常量定义
准备数据集

1.前向传播中：定义输入、参数和输出

2.反向传播中：定义损失函数、反向传播方法、loss

3.生成会话，训练step轮