导读：本文第一部分会介绍tensorflow基本的一些概念，流程图，占位符，模型的持久化等；第二部分会结合具体的案例来进行对上述的概念进行综合的理解和教程
part1:
tensorflow初识
tensorflow=tensor(张量，也可以理解为多维数组)+flow(流)
1.1计算图的概念
tensorflow的程序执行通常会分为两个阶段：
第一阶段定义变量和变量之间的运算关系

import tensorflow as tf
a=tf.constant([1.0,2.0],name="a") #定义常量
b=tf.constant([2.0,4.0],name="b")
c=a+b

第二阶段执行计算

sess =tf.Session()
sess.run(c)

计算图可以抽象理解为画板，不特殊指定的话会在默认的画板上画画，不同画板上的图案不会共享

import  tensorflow as tf 
g1=tf.Graph() #生成画板1
with  g1.as_default():
#定义变量,设置初始值为0
   v=tf.get_variable("v",shape=[1],initializer=tf.zeros_initializer) #定义了一只猫的绘制方法

g2=tf.Graph() #生成画板1
with  g2.as_default():
#定义变量,设置初始值为1
   v=tf.get_variable("v",shape=[1],initializer=tf.ones_initializer) #定义了一只狗的会话方法

with tf.Session(graph=g1)  as sess:  #打开画板1
  tf.global_variables_initializer().run()#初始化所有变量,并运行（开始画画）
  with tf.variable_scope(" ",reuse=True):
  #获得画板上的内容
    print(sess.run(tf.get_variable("v"))) #看到一只猫

with tf.Session(graph=g2)  as sess:  #打开画板2
  tf.global_variables_initializer().run()#初始化所有变量,并运行（开始画画）
  with tf.variable_scope(" ",reuse=True):
  #获得画板上的内容
    print(sess.run(tf.get_variable("v"))) #看到一只狗

1.2张量
张量可以理解为n维度数组（临摹的时候画笔的粗细），主要用来对中间结果的引用和获得计算的结果

import tensorflow as tf
a=tf.constant([1.0,2.0],name="a") #定义常量
b=tf.constant([2.0,3.0],name="b")
c=tf.add(a,b,name="add")  #定义c节点的处理步骤
print(c)
#Tensor("add:0",shape(2,),dtype=float32) #这时候并没有进行计算
#一个张量有三个属性
（1）名字属性 "add:0"   -画笔的名称
 （2）维度属性“shape(2,)” -画笔的粗细
（3）类型属性 dtype=float32  --画笔的颜料，不同成分的颜料不能混用

1.3会话session
会话执行的主要是Tensorflow的第二个阶段，根据定义好的流程进行计算
调用session有两种方法，类似正常读取文件的方法

method 1:
#创建会话
sess=tf.Session()
#执行定义好的计算
sess.run()
#关闭会话，释放资源
sess.close()

method 2: 常用自动释放资源
with  tf.Session() as sess:
  sess.run(……)

完整的通过会话计算张量

import tensorflow as tf
a=tf.constant([1.0,2.0],name="a") #定义常量
b=tf.constant([2.0,3.0],name="b")
c=a+b
with tf.Session() as sess: #运行会话得到c的计算结果[3.0,5,0]
  print(c.eval())

#with tf.Session() as sess: 只是进行运算并不会显示
#   sess.run(c)
#with tf.Session() as sess: #计算并打印结果
#   print(sess.run(c))

1.4神经网路参数和变量
神经网路参数是实现神经网路的重要部分，在tensorflow中就是用变量来更新和保存神经网路中的参数，使用变量的时候要给变量指定初始值

#生成初始值为随机正态分布的变量
weights=tf.Variable(tf.random_normal([2,3],stddev=2))
#生成初始值为0的变量
biases=tf.Variable(tf.zeros([3]))
#通过其他变量的初始值来定义变量
w2=tf.Variable(weights.initialized_value()) #生成初始值跟weights一样的变量
w2=tf.Variable(weights.initialized_value()*2)

在tensorflow中，定义变量只是定义了变量的生成过程，变量并没有被赋值，需要通过初始化来对变量进行真正的赋值

import tensorflow as tf
w1=tf.Variable(tf.random_normal([2,3],stddev=2,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=2,seed=1))
x=tf.constant([[0.7,0.9]])
a=tf.matmul(x,w1)
y=tf.matmul(a,w2)
with  tf.Session() as sess:
  sess.run(w1.initializer) #初始化w1
  sess.run(w2.initializer) #初始化w2
#当变量过多时候可以用下面的方式替换
  #init_op=tf.global_variables_initializer() #获得所有变量
  ###tf.global_variables() #获得存在的所有变量
  #sess.run(init_op)
  print(sess.run(y))

我们提到了张量和变量，张量是一种存放数据的结构，变量的输出结果就是张量，可以理解为变量是一种特殊的张量;与张量一样变量也有三个属性
名字，维度，类型，其中维度可以进行修改（通常不会修改），类型一旦指定就不能修改（默认为tf.flaot64）

import tensorflow as tf
w1=tf.Variable(tf.random_normal([2,3],stddev=2,seed=1),name='w1')
#数据类型错误
w2=tf.Variable(tf.random_normal([2,3],stddev=2,seed=1),dtype=tf.float64,name='w2')
w1.assign(w2)   #只是定义关系并没有执行
#维度错误
w2=tf.Variable(tf.random_normal([2,2],stddev=2,seed=1),name='w2')
tf.assign(w1,w2)  #会报维度不匹配的错误
tf.assign(w1,w2,validate_shape=False)  #允许更改维度，会被正常执行

part2:
神经网络训练过程和简单实现

2.1神经网络算法示意图

神经网络反向传播优化.png

2.2一些新的名词

batch_size:由于神经网络一次训练是选取部分数据进行训练的，需要指定这部分数据的大小（一次训练多少行的数据）
数据量小的时候是可以一次性使用全部数据，数据量大的时候这样会造成内存溢出
steps or train_steps:表示训练轮数
tf.placeholder() #定义输入数据的格式，类似函数的形参
learning_rate #学习率

2.3定义完整神经网络参数

神经网络的训练大致分为下面三个步骤
1.定义神经网络的结构和前项传播算法的输出结果
2.定义损失函数和选择反向传播算法
3.定义会话，并在训练数据上不断优化反向传播算法

import tensorflow as tf 
from numpy.random import RandomState
import matplotlib.pyplot as plt 
#定义训练数据的大小
batch_size=8
#定义神经网络参数
w1=tf.Variable(tf.random_normal([2,3],stddev=2,seed=1),name='w1')
w1=tf.Variable(tf.random_normal([3,1],stddev=2,seed=1),name='w2')
#定义神经网络接收参数的格式
x=tf.placeholder(tf.float32,shape=(None,2),name='x-input') #定义输入形参，两列
y_=tf.placeholder(tf.float32,shape=(None,1),name='y-input') #定义输出形参，一列
#定义向前传播的算法过程
a=tf.matmul(x,w1)
y=tf.matmul(y,w2)
y=tf.sigmod(y)
#定义损失函数和反向传播算法
cross_entropy=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-10,1.0))+(1-y_)*tf.log(tf.clip_by_value(1-y,1e-10,1.0))) #分类算法常用的损失函数
    #反向传播算法
train_step=tf.train.AdamOptimizer(0.001).minimize(cross_entropy)
#生成自定义数据集大大小
rdm=RandomState(1)
dateset_size=128
X=rdm.rand(dateset_size,2) #生成128行两列矩阵
y=[[int(x1+x2)] for (x1,x2) in X] #数据示意见下图
with  tf.Session() as sess:
#初始化并运行所有变量
  init_op=tf.global_variables_initializer()
  sess.run(init_op)
#设定训练轮数
STEPS=5000
for i in range(STEPS):
  start =(i*batch_size)%dataset_size
  end=min(start+batch_size,dataset_size)
  #输入参数，执行训练流程
  sess.run(train_step,feed_dict=feed_dict{x:X[start:end],y_:Y[start:end]})
  #每隔一段时间，计算所有数据的交叉熵
  if  i%1000==0:
    total_cross_entropy=sess.run(cross_entropy,feed_dict={x:X,y_:Y})
    print("经过%s次训练现在的误差是%"%(i,total_cross_entropy))

生成数据示意图.png