Tensorflow

处理结构

建立结构-->数据放入里面运行

预测参数

import tensorfow as tf
import numpy as np

#creat data
x_data=np.random.rand(100).astype(np.float32)  
y_data=x_data*0.1+0.3 #使X接近0.1，y接近0.3

搭建结构

#creat tensorflow structure start #
Weights=tf.Variable(tf.random_uniform([1],-1.0,1.0))  #生成一个矩阵，且采用随机变量的形式生成，[1]指的是维度为1，范围是-1.0~1.0。。。。**权重**
biasae=tf.Varible(tf.zero([1]))   #定义一个初始值全是0的**偏置**

y=Weighrs*x+biases #提升y准确度

loss=tf.reduce_mean(tf.square(y-y_data)) #预测值和真实值之间的误差
optimizer=tf.train.GradientDescentOptimizer(0.5) #数字为学习效率
train=optimier.minimize(loss)   #使用优化器训练，进而减小误差

init=tf.intialize_all_variables()  #神经网络相当于一张图，是一个大结构，我们需要先将结构搭建起来，然后再进行。所以在结构运行之前需要先初始化一下。

把结构激活初始化

sess=tf.Session() 
sess.run(init)  #这就相当于一个指针，指向的地方被激活。所以将其指向init初始化的地方激活它，然后初始化以后就可以进行运行了。very important

开始训练神经网络

for steo in range(201): #训练201步
sess.run(train) #指向结构里的train进行训练
if step%20==0: #每隔20步打印一下
print(step,sess.run(Weights),sess.run(biase)) #指向Weights，biase，将此时的这两个打印出来。

Session 会话控制

可以指向神经网络这张图的某一个小结构，然后进行执行这个小结构，可以在此时结合print，将此时这个结构里面的数据进行打印出来

import tensorflow as tf
matrix1=tf.constant([[3,3]]) #建立一个矩阵_一行二列
matrix1=tf.constant([[2],
                                [2]])
product=tf.matmul(matrix1，matrix1）   #矩阵乘法

一种模型——使用Session

sess=tf.Session()
result=sess.run(product)   #每run一样，tensorflow就会执行一下这个结果
print(result)
sess.close()  #有没有其实差不多，有的话会更加整洁和系统一点

另一种模型——mothod 2

with tf.Session as sess:  #以sess命名Session，运行到最后不用管是否采用sess.close()这个语句
        result2=sess.run(product)
        print(result2)     #这两个语句就在with下面了，所以结束这两个语句以后，就无需在意是否将这两个语句进行close了，可以另起一行进行其他语句
balabala~其他语句

Variable 变量

import tensorflow as tf

state=tf.Variable(0，name='counter') #一定要定义一个变量，它才是一个变量.可以给个初始值和命名
#print(state.name)
one=tf.constant(1) #定义一个常量

new_value=tf.add(state+one)
update=tf.assign(state,new_value) #将new_value里面的值赋值到state中，返回以后再进行new_value里面的语法

init=tf.initialize_all_variables()   #如果有定义变量名，一定要有这个语句，这个语句用来将所有变量进行激活。但现在还米有激活，需要下面采用一个session.run（）语句

with tf.Session() as sess:
       sess.run(init)  #定义init后一定要run一下，否则没有意义
    for _in range(3):    #3次循环，每一次都run一下下面那个
          sess.run(update)
          print(sess.run(state))  

Tensorflow ----placeholder 传入值

placeholder是指在每一次运行sess.run的时候，进行一个新的输入。而这个新的输入与feed_dict进行了绑定，通过feed_dict进行输入值的数值确定

import tensorflow as tf

input1=tf.placeholder(tf.float32)  #一般情况而言，我们的输入都是float32的。如果你想要定义这个placeholder的结构，可以在float32后面，[2,1]这样用来定义结构
input2=tf.placeholder(tf.float32)

output=tf.mul(input1,input2)  #两个输入矩阵相乘

with tf.Session() as sess:
       print(sess.run(output，feed_dict={input1:[7.],input2:[2.]}))   #每一次run都输出一个output的值。因为是placeholder需要每一次都传入一个新的值，也是在此时进行一个新input1和新input2的输入。

激励函数 activation function

筛选，保留需要的，或者将值进行改变使更符合要求

def 添加层

我们定义了一个带有激励函数的添加层，可以放在神经网络某个架构里面进行调用这个激活函数

说明如何加入一个神经层，输入函数是什么东西，输出和输入多少个单位，激励函数是什么

import tensorflow as tf

def add_layer(inputs,in_size,out_size,activation=None) #我们要添加一个层，需要一个输入。看我们是否需要激励函数，默认的话，我们可以暂时默认为没有就是一个线性函数。
     Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #定义一个权重，大写开头因为它是矩阵。我们定义了一个权重，行有in_size个，列有out_size个,其中输出为随机变量值，这样要比全是0的话好很多，每一步都会有变化
      biases=tf.Variable(tf.zeros([1,out_size])+0.1)  #因为biases相当于一个列表类的，所以非矩阵因此首字母无需大写。由于全是0的话不太好，所以我们让其全是0.1
      Wx_plus_b=tf.matmul(inouts,Weights)+biases  #前面那个式子相当于一个矩阵的乘法，还未被激活,就先存放在这里,是一个线性方程
      if activation_function is None:  
          outputs=Wx_plus_b   #如果没有激活函数，就让输出继续保持线性关系输出就好。不用激活函数的非线性关系
      else:
           outputs=activation_functon(Wx_plus_b)
      return outputs

建造神经网络

怎样建立神经网络结构，怎样得到预测值并与真实值进行比较，然后不断训练使预测值更接近真实值

定义一个新的层

import tensorflow as tf
importnumpy as np
def add_layer(inputs,in_size,out_size,activation=None) #我们要添加一个层，需要一个输入。看我们是否需要激励函数，默认的话，我们可以暂时默认为没有就是一个线性函数。
     Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #定义一个权重，大写开头因为它是矩阵。我们定义了一个权重，行有in_size个，列有out_size个,其中输出为随机变量值，这样要比全是0的话好很多，每一步都会有变化
      biases=tf.Variable(tf.zeros([1,out_size])+0.1)  #因为biases相当于一个列表类的，所以非矩阵因此首字母无需大写。由于全是0的话不太好，所以我们让其全是0.1
      Wx_plus_b=tf.matmul(inouts,Weights)+biases  #前面那个式子相当于一个矩阵的乘法，还未被激活,就先存放在这里,是一个线性方程
      if activation_function is None:  
          outputs=Wx_plus_b   #如果没有激活函数，就让输出继续保持线性关系输出就好。不用激活函数的非线性关系
      else:
           outputs=activation_functon(Wx_plus_b)
      return outputs

定义数据形式

x_data=np.linspace(-1,1,300)[:,np.newaxis]  #我们说明了x_data的区间是-1~1，且有300个例子。后面的[  ]说明了它的维度
noise=np.random.normal(0,0.5,x_data.shape)  #说明我们的这个线并没有按照规定的正规曲线走，其周围还有很多点，也就是使其更接近真实的。
y_data=np.square(x_data)-0.5+noise  #np.square是指x的平方

接下来需要建立第一层，我们知道前面x_data有1个，所以是输入有一个属性也就有一个输入值；输出有y_data有1个，所以其也是有一个属性。那个中间的那个隐藏层，我们定义有10个。

xs=tf.placeholder(tf.float32,[None,1])  #none指的是开始值是多少都ok
ys=tf.placeholder(tf.float32,[None,1])

#add hidden layer
l1=add_layer(xs,1,10,activation_function=tf.nn.relu) #输入层。。前面定义了一个层了，所以我们这里是这个层的输入层，输入有1个属性，因为隐藏层有10个属性,所以我们定义了一个1,10的层。

#add output layer
prediction=add_layer(l1,10,1,activation_function=None) #10为隐藏层的属性，所以我们就定义了一个10,1的层结构。我猜测这个l1作为输入的原因是因为隐藏层不负其名，可以隐藏不用，所以我们输出层的输入直接就是原输入层的输出。

#the error between prediction and real data 
loss=tf.reduce_mean(tf.reduce_sum(tf.squary(ys-prediction),reduction_indices=[1]))  #一个计算公式，计算误差的

train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)     #怎样对于误差减小进行提升，怎样去学习;每次都是以0.1的效率对误差进行更正和提升，使每次都得到一个更好的结果

init=tf.initialize_all_cariable()
sess=tf.Session()
sess.run(init)

for i in range(1000):
  sess.run(train_step,feed_dict={xs:x_data,ys:y_data})  #好处为可以分一步一步训练，可以提高训练效率，不再是一起。
    if i%50==0:   #我们看一下误差是否在得到训练的过程中减小
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))#只要通过placeholder进行运算的，就要feed_dict它们的值

结果可视化plot result

import tensorflow as tf
importnumpy as np
*imoort matplotlib.pyplot as plt*

def add_layer(inputs,in_size,out_size,activation=None) #我们要添加一个层，需要一个输入。看我们是否需要激励函数，默认的话，我们可以暂时默认为没有就是一个线性函数。
     Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #定义一个权重，大写开头因为它是矩阵。我们定义了一个权重，行有in_size个，列有out_size个,其中输出为随机变量值，这样要比全是0的话好很多，每一步都会有变化
      biases=tf.Variable(tf.zeros([1,out_size])+0.1)  #因为biases相当于一个列表类的，所以非矩阵因此首字母无需大写。由于全是0的话不太好，所以我们让其全是0.1
      Wx_plus_b=tf.matmul(inouts,Weights)+biases  #前面那个式子相当于一个矩阵的乘法，还未被激活,就先存放在这里,是一个线性方程
      if activation_function is None:  
          outputs=Wx_plus_b   #如果没有激活函数，就让输出继续保持线性关系输出就好。不用激活函数的非线性关系
      else:
           outputs=activation_functon(Wx_plus_b)
      return outputs

定义数据形式

x_data=np.linspace(-1,1,300)[:,np.newaxis]  #我们说明了x_data的区间是-1~1，且有300个例子。后面的[  ]说明了它的维度
noise=np.random.normal(0,0.5,x_data.shape)  #说明我们的这个线并没有按照规定的正规曲线走，其周围还有很多点，也就是使其更接近真实的。
y_data=np.square(x_data)-0.5+noise  #np.square是指x的平方

接下来需要建立第一层，我们知道前面x_data有1个，所以是输入有一个属性也就有一个输入值；输出有y_data有1个，所以其也是有一个属性。那个中间的那个隐藏层，我们定义有10个。

xs=tf.placeholder(tf.float32,[None,1])  #none指的是开始值是多少都ok
ys=tf.placeholder(tf.float32,[None,1])

l1=add_layer(xs,1,10,activation_function=tf.nn.relu) #输入层。。前面定义了一个层了，所以我们这里是这个层的输入层，输入有1个属性，因为隐藏层有10个属性,所以我们定义了一个1,10的层。
prediction=add_layer(l1,10,1,activation_function=None) #10为隐藏层的属性，所以我们就定义了一个10,1的层结构。我猜测这个l1作为输入的原因是因为隐藏层不负其名，可以隐藏不用，所以我们输出层的输入直接就是原输入层的输出。

loss=tf.reduce_mean(tf.reduce_sum(tf.squary(ys-prediction),reduction_indices=[1]))  #一个计算公式，计算误差的

train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)     #怎样对于误差减小进行提升，怎样去学习;每次都是以0.1的效率对误差进行更正和提升，使每次都得到一个更好的结果

init=tf.initialize_all_cariable()
sess=tf.Session()
sess.run(init)

显示真实数据的图

fig=plt.figure()
as=gif.add_subplot(1,1,1)#连续性画图
as.scatter(x_data,y_data)
plt.ion()  #可以持续进行，持续纠正，是个连续的过程
plt.show()         

for i in range(1000):
  sess.run(train_step,feed_dict={xs:x_data,ys:y_data})  #好处为可以分一步一步训练，可以提高训练效率，不再是一起。
    if i%50==0:   #我们看一下误差是否在得到训练的过程中减小
       # print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))
        try:
             ax.lines.remove(lines[0]) #将第一个线给抹除掉#如果第一次没有画这条线，直接抹除可能会报错，所以此处用了一个‘try’
        except Exception:
              pass  #然后再抹除，再继续画新的线
        prediction_value=swss.sun(prediction,feed_dict={xs:x_data,ys:y_data})  #因为prediction和xs有关，所以需要将后面的那一长串同时写入
      lines=as.plot(x_data,prediction_value,'-r',lw=5) #将预测值的图用实线画出来而不是用点。
     
      plt.pause(0.1)

优化器optimizer

每次使用一批数据，不仅可以加速训练，还可以更精准

Tensorboard 可视化好助手

自行处理名字，run后会自动加框架，形成一个流程图
以下为神经整体网络层

import tensorflow as tf

def add_layer(inputs,in_size,out_size,activation=None) #我们要添加一个层，需要一个输入。看我们是否需要激励函数，默认的话，我们可以暂时默认为没有就是一个线性函数。
 *with tf.name_scope('layer'):*
     *with tf.name_scope('weights'):     
 Weights=tf.Variable(tf.random_normal([in_size,out_size]),name='W')  #定义一个权重，大写开头因为它是矩阵。我们定义了一个权重，行有in_size个，列有out_size个,其中输出为随机变量值，这样要比全是0的话好很多，每一步都会有变化
with tf.name_scope('biases'):
      biases=tf.Variable(tf.zeros([1,out_size])+0.1)  #因为biases相当于一个列表类的，所以非矩阵因此首字母无需大写。由于全是0的话不太好，所以我们让其全是0.1
with tf.name_scope('Wx_plus_b'):
      Wx_plus_b=tf.matmul(inouts,Weights)+biases  #前面那个式子相当于一个矩阵的乘法，还未被激活,就先存放在这里,是一个线性方程
      if activation_function is None:  
          outputs=Wx_plus_b   #如果没有激活函数，就让输出继续保持线性关系输出就好。不用激活函数的非线性关系
      else:
           outputs=activation_functon(Wx_plus_b)
      return outputs

定义数据形式

x_data=np.linspace(-1,1,300)[:,np.newaxis]  #我们说明了x_data的区间是-1~1，且有300个例子。后面的[  ]说明了它的维度
noise=np.random.normal(0,0.5,x_data.shape)  #说明我们的这个线并没有按照规定的正规曲线走，其周围还有很多点，也就是使其更接近真实的。
y_data=np.square(x_data)-0.5+noise  #np.square是指x的平方

接下来需要建立第一层，我们知道前面x_data有1个，所以是输入有一个属性也就有一个输入值；输出有y_data有1个，所以其也是有一个属性。那个中间的那个隐藏层，我们定义有10个。

input

#define placeholder for inputs to network
with tf.name_scope('inputs'):
xs=tf.placeholder(tf.float32,[None,1],*name='x_input'*)  #none指的是开始值是多少都ok
ys=tf.placeholder(tf.float32,[None,1],*name='y_input'*)

#add hidden layer
l1=add_layer(xs,1,10,activation_function=tf.nn.relu) #输入层。。前面定义了一个层了，所以我们这里是这个层的输入层，输入有1个属性，因为隐藏层有10个属性,所以我们定义了一个1,10的层。

#add output layer
prediction=add_layer(l1,10,1,activation_function=None) #10为隐藏层的属性，所以我们就定义了一个10,1的层结构。我猜测这个l1作为输入的原因是因为隐藏层不负其名，可以隐藏不用，所以我们输出层的输入直接就是原输入层的输出。

#the error between prediction and real data 
with tf.name_scope('loss'):
loss=tf.reduce_mean(tf.reduce_sum(tf.squary(ys-prediction),reduction_indices=[1]))  #一个计算公式，计算误差的
with tf.name_scope('train'):   #train也可以在图像中显示出来，将其当做一个框架
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)     #怎样对于误差减小进行提升，怎样去学习;每次都是以0.1的效率对误差进行更正和提升，使每次都得到一个更好的结果

sess=tf.Session()
writer=tf.train.SummaryWriter("logs/",sess.graph)  #因为框架生成以后，显示只会在文件夹中，所以我们要将其定义到一个文件夹里，显示以后再看
sess.run(init)

for i in range(1000):
  sess.run(train_step,feed_dict={xs:x_data,ys:y_data})  #好处为可以分一步一步训练，可以提高训练效率，不再是一起。
    if i%50==0:   #我们看一下误差是否在得到训练的过程中减小
        print(sess.run(loss,feed_dict={xs:x_data,ys:y_data}))#只要通过placeholder进行运算的，就要feed_dict它们的值

Classification 分类学习

分类的问题：将其看到的一类的分成一类

import tensorflow.examples.tutorial.mnist import input_data   #将数据导入
#number 1 to 10 data
mnist=input_data.read_data_seta('MNIST_data',one_hot=Ture)  #数据包要在网上下载，你运行好以后会自动下载到你的这个文件中

def add_layer(inputs,in_size,out_size,activation=None) #我们要添加一个层，需要一个输入。看我们是否需要激励函数，默认的话，我们可以暂时默认为没有就是一个线性函数。
     Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #定义一个权重，大写开头因为它是矩阵。我们定义了一个权重，行有in_size个，列有out_size个,其中输出为随机变量值，这样要比全是0的话好很多，每一步都会有变化
      biases=tf.Variable(tf.zeros([1,out_size])+0.1)  #因为biases相当于一个列表类的，所以非矩阵因此首字母无需大写。由于全是0的话不太好，所以我们让其全是0.1
      Wx_plus_b=tf.matmul(inouts,Weights)+biases  #前面那个式子相当于一个矩阵的乘法，还未被激活,就先存放在这里,是一个线性方程
      if activation_function is None:  
          outputs=Wx_plus_b   #如果没有激活函数，就让输出继续保持线性关系输出就好。不用激活函数的非线性关系
      else:
           outputs=activation_functon(Wx_plus_b)
      return outputs

def compute_accuracy(v_xs,v_ys): #输入输出值
    global prediction  #定义预测值为全局变量
    y_pre=sess.run(prediction,feed_dict={xs:v_xs}) #将后面的值赋值给prediction，选用最大的预测值最为y_pre
         correct_prediction=tf.equal(tf.argmax(y_pre,1),tf.argmax(w_ys,1))  #比较最大的预测值和真实值，看看是否对。
     
accuracy=tf.reduce_mean(tf.cast(sorrect_prediction,tf.float32))  #对比有多少是准确的，概率是多少
     result=sess.run(accuracy,feed_dict={xs:v_xs,ys:v_ys})
     return result  #输出的result是个百分比，百分比越高就越准确

#define placeholder for inputs to network
xs=tf.placeholder(tf.float32.[None,784]) #28*28=784像素点
ys=tf.placeholder(tf.float32.[None,10])  #y有10个输出

#add output layer
prediction=add_layer(xs,784,10,activation_function=tf.nn.softmax)  #输入为xs,像素点有784个,输出了10个

#the error between prediction and real data
cross_entropy=tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indics=[1])) #loss。作为损失函数，算法比较复杂。但作为分类问题，一般优化选择softmax的时候，所搭配的损失函数就是cross_entropy
train_step=tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
sess=tf.Session()
sess.run(tf.intialize_all_variables())

for i in range(1000):
    batch_xs,batch_ys=mnist.train.next_batch(100)  #从MNIST中调用100个数据进行学习，这样学习效率更快
    sess.run(train_step,feed_dict={xs:baych_xs,ys:batch_ys})  #进行误差计算和优化
    if i%50==0:
        print()  #test和train的数据不一样，最好分开定义，不然会有细微误差存在。