tensorflow学习笔记

1. https://playground.tensorflow.org/      #tensorflow网页版

2. 中文官方文档：http://cwiki.apachecn.org/pages/viewpage.action?pageId=10030122

3. 问题及解决办法

   1. 成功解决Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2
   2. import os
      os.environ[‘TF_CPP_MIN_LOG_LEVEL’] = ‘2’

4. ##查询官方文档：https：//tensorflow.google.cn/

5. 复现别人的算法的过程，重要的是逻辑化（先什么，后什么？）复现CNN、LSTM、Wavenet、Leagun

6. Tensorflow是基于图（Graph）的计算系统。而图的节点则是由操作（Operation）来构成的，而图的各个节点之间则是由张量（Tensor）作为边来连接在一起的。所以Tensorflow的计算过程就是一个Tensor流图。Tensorflow的图则是必须在一个Session中来计算。

7. 张量：可以理解为多维数组；零阶张量就是实数，一阶张量就是一维数组，n阶张量就是n维数组。

8. 张量的三个属性：名字（name）、维度（shape）、类型（type）

• flow：流，直观的表示了张量之间相关计算转化的过程。
• tensorflow运行模型：会话

1. sess=tf.Session( )#创建会话
2. sess.run()  #运行
3. sess.close()  #关闭会话资源

• 所谓过拟合：模型过于复杂之后，它可以很好的“记忆”每一个训练数据中随机噪声的部分而忘记了要去“学习”训练数据中通用的趋势。

1. 正则化：在损失函数中加入刻画模型复杂程度的指标。
2. 一般来说模型复杂度是由权重决定。
3. 刻画模型复杂程度的函数（L1正则化）
4. （L2正则化）：

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

1. 在linux中的shell建立命令：定义虚拟环境：vim ~/.vimrc
2. set ts=4
3. set nu

• 所谓计算图就是搭建神经网络的计算过程， 只搭建，不做运算。
• 会话：session:执行计算图中的节点运算
• 参数：线上的权重W，用变量表示，随机给初始值。
• W=tf.Variable(tf.random（正态分布）_normal([2,3],（产生2X3矩阵）stddev=2,（标准差为2）mean=0,（均值为0）seed=1（随机种子）))
• 第一个神经网络：总结八股

1. 基于tensorflow的NN：用张量表示数据，用计算图搭建神经网络，用会话执行计算图，优化线上的权重，得到模型。
2. 张量（tensor）：多维数组结张量的维数维数        阶       名字            例子0-D           0         标量scalar   s=1 3 21-D           1          列表向量vector v=[1,3,2]2-D          2            矩阵matrix  m=[[1,3,2],[4,5,6],[7,8,9]]n-D         n           张量tensor  t=[[[…
3. 在Linux操作系统中，vim ~/.vimrc:                                      set ts=4                                      set nu
4. 数据类型：tf.float32    tf.int32  …Import tensorflow as tfa=tf.Variable([1, 100])b=tf.Variable([2, 100])result = a+bprint resultwith tf.session() as sess:print(sess.run(y))显示：Tensor（“add:0”,shape=(2,),dtype=float32）
5. 前向网络参数：即线上的权重W，用变量表示，随机给初值w=tf.Variable(tf.random_normal([2,3],stddev=2,mean=0,seed=1))random_normal   正态分布[2,3]    产生2X3矩阵stddev=2   标准差为2mean=0   均值为0seed=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.onse([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]
6. 圣经网络的实现过程：1.准备数据集，提取特征，作为输入喂给神经网络（NN）2.搭建网络结构，从输入到输出（先搭建计算图，再用会话执行）3.大量特征数据喂给NN，迭代优化NN参数4.使用训练好的模型预测和分类
7. 前向传播：搭建模型，实现推理输入层不算在层内1.变量初始化、计算图节点运算都要用会话实现with tf.Session() as sess:     sess.run()2.变量初始化：在sess.run函数中用tf.global_variables_initializer()init_op =tf.global_variables_initializer()sess.run(init_op)计算图节点运算：在sess.run()函数中用feed_dict 喂数据  代码有中文  ：#coding：utf-8
8. 反向传播：训练模型参数，在所有参数上用梯度下降，使模型NN在训练数据上的损失函数最小。损失函数（loss）,预测值和真实值y_的差距：均方误差MSE：MSE（y_,y）=(y-y2)2/nloss = tf.reduce_mean(tf.sequare(y_-y)）方向传播：减小loss值为优化目标学习率：决定参数每次迭代的幅度train_step = tf.train.GradientOptimizer(learning_rate).minimizer(loss)train_step =tf.train.MomenttumOptimizer(learning_rate).minimizer(loss) #动量法tf.train.AdamOptimizer(learning_rate).minimizer(loss)

• 神经网络模型

1. #文件名字#coding:utf-8import定义常量生成数据集
2. 前向传播：定义输入、参数和输出
3. 反向传播：定义损失函数、反向传播方法

• 损失函数

1. 偏置项：bias
2. 激活函数：relu：f=max(x,0)   tf.nn.relu()sigmoid: f=1/(1+e(-x))   tf.nn.sigmoid()tanh:  f=(1-e(-2x)/(1+e(-2x))   tf.nn.tanh()
3. NN复杂度：多NN层数和NN参数的个数表示层数=隐含层数+1个输出层总参数=总W+总b（每个隐含层和输出层神经元都有一个偏执b）

• 损失函数（ce）的优化

1. 损失函数loss、学习效率learning_rate、滑动平均ema、正则化regularization
2. NN优化目标：loss最小（均方误差）
3. BATCH_SIZE =8  #每次训练的样本数
4. SEED =常数    #保证每次生成的数据集一样
5. 交叉熵：表示两个概率分布之间的距离：（交叉熵越大，两个概率分布之间的距离越远；交叉熵越小，两个概率分布之间的越近）H（y_,y）= -求和y_*logy

• 学习率learning_rate:每次参数更新的幅度w（n+1）=w（n）-learning_rate*损失函数梯度例如：损失函数为loss=（w+1）（w+1）    梯度为：=2W+2
• 正则化缓解过拟合

1. L1正则化
2. L2正则化

• 搭建模块化的神经网络八股

1. 前向神经网络就是搭建网络，设计网络结构（Forward.py）

2. def forward(x,regularizer):w=b=y=return y

3. def  get_weight(shape,regularizer):w=tf.Variable( )tf.add_to_collection(“losses”,tf.contrib.layers.l2_regularizer)(w))return w

4. def get_biass(shape):b=tf.Variable( )return b

• 反向传播就是训练网络，优化网络参数（backward.py）def backward():    x=tf.placeholder(   )    y_=tf.palceholder()    y=forward.forward(x,REGUILARIZER)    golbal_step=tf.Variable(0,trainable=False)    loss=#loss可以是：y和y_的差距=tf.reduce_mean(tf.sequare(y-y_))也可以是：ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))y与y_的差距=tf.reduce_mean(ce)加入正则化后loss=y与y_的差距+tf.add_n(tf.get_collection(“losses”))if name==“main_”:      backward()
• 反向传播就是训练网络，优化网络参数（Backward.py）
• Geoffery Hinton专访：要阅读文献，但是不要太多，绝对不要停止编程。不要停止编程。要有直觉，相信自己的直觉。
• 如何处理训练集：

1. 逻辑回归是一个用于二分类的方法；

2. 训练集是为了干什么？找到权重和偏置。

3. 损失函数又叫误差函数=预测值和真实值只差的平方或者一半

4. 逻辑回归损失函数为：L（y‘，y）=-（ylogy’+（1-y）log（1-y‘））

• 梯度下降法：损失函数向最陡的下坡方向走一步，不断地迭代。直到走到全局最优解或者接近全局最优解的地方。

• 梯度下降法是调整w和b

• CNN

• 参数个数：w个数=前层和后层乘积    b为后层神经元个数

• 红绿蓝三通道信息

• 卷积提取特征的方法

• padding（全零填充）：SAME：输入长/步长（向上取整） ； VALID（不使用填充）（输入长-核长+1）/步长 （向上取整）

• tensorflow中计算卷积：

• tf.nn.conv2d(输入描述，eg。[batch，5,5,1]#分辨率和通道                      卷积核描述，eg.[3,3,1,16] #行列分辨率 通道数 核个数                       核滑动步长，eg.[1,1,1,1]  #行步长 列步长                        padding=‘VALID’)

• 池化用于减少特征数量最大池化可提取图片纹理，均值池化可保留背景特征pool=tf.nn.max_pool(输入描述，eg.[batch,28,28,6]#行列分辨率 通道数pool=tf.nn,avg_pool  池化核描述（仅大小），eg.[1,2,2,1] #行列分辨率                                  池化核滑动步长，eg.[1,2,2,1]#行步长 列步长                                   padding =‘SAME’)

• 经典CNN模型的主要模块：卷积、激活、池化  全连接（借助卷积核（kernel）提取特征，送入全连接网络）

• 经典CNN网络算法：Lenet-5，AIexNet，VGGNet，GoogleNet，ResNet

• 草图绘制流程图

• VGG net 是经典神经网络模型。

• 

• 

• 

• 

• 

• 

• 图灵测试：这种能否判断对方酒精是人还是机器人的思维试验。人工智能是研究用计算机实现人类的智能。AlphaGo采用的蒙特树搜索法（Monte Carbtree search MCTS）和深度卷积神经网络（DCNN）

• 指定Gpu的方法：with  变量名.device(’/gpu:0’)

• tensor 张量：name,  shap, type

• tensorflow三个框架：

  • 数据结构
  • 计算结构
  • 计算会话：计算先初始化初始值，

• 神经网络的额输入是一个行矩阵。

  • weights = tf.Variable(tf.random_nomal([2,3],stddev=2))   #tf.random_nomal([2,3],stddev=2)表示正态分布，平均数是0，标准差stddev是2，通过mean指定平均数。
  • tf.zeros:产生全是0的数组
  • tf.ones:产生全是1的数组
  • tf.fill：产生一个全部为给定数字的数组
  • tf.constant:产生一个给定值的常量

• 偏置设置：

  • biases = tf.Variable(tf.zeros([3])  #生成初始值全是0的长度是3的矩阵

• 初始化所有参数值：init_op = tf.initialize_all_variables()

• 激活函数实现去线性化：

• 损失函数：交叉熵（Cross_entropy)# 刻画两个概率分布的距离

• 循环神经网络的训练过程大致以下过程

  • batch_size=n
  • #每次执行一小部分数据作为当前的训练数据来执行方向传播算法
  • x = tf.placeholder(tf.float32,shape = (batch_size,2), name = ‘x-input’)
  • y_ = tf.placeholder(tf.float32, shape = (batch_size , 1), name = ‘y-input’)
  • #定义损失函数和优化算法
  • loss =
  • train_step = tf.train.AdamOptimizer(0.001).minimize(loss)
  • #训练神经网络
  • with tf.Session() as sess:
    • #参数初始化
    • #迭代更新参数
    • for  i in range(STEPS):
      • #准备batch_size 个训练数据。一般将所有训练数据随机打乱之后在选取可以得到更好的训练结果
      • current_X, current_y = …
      • sess.run(train_step,feed_dict ={x:current_X, y _:current_Y)

• 所谓过拟合问题：就死模型过为复杂之后，它可以很好的“记忆”每个训练数据的噪声的部分而忘记了要去”学习“更多训练数据的趋势。过拟合可能导致参数无法对未知数做出判断。

  • 解决过拟合的办法是正则化(regularization):L1正则化或L2正则化

• tensorboard可视化

  • 启动tensorboard : tensorboard --logdir= /path/to/log

• GPU:

  • 所有的cpu：/cpu:0

  • GPU:/gpu:0,

    • #通过log_device_placement 参数输出每一个运算的设备

    • sess = tf.Session(config = tf.ConfigProto(log_device_placement=True))

    • #指定GPU计算不同的步骤

    • with tf.device(’/gpu:0’)

      • a =
      • b =

    • with tf.device(’/gpu:1)

      • c =a +b

  • 指定GPU

    • import os
    • os.environ[“CUDA_DEVICE_ORFER”] =“PCI_BUS_ID”
    • os.environ[“CUDA_VISIBLE_DEVICES”] = “0, 2”    # -1 表示禁用GPU