Tensorflow学习总结一

Tensorflow入门

1、基本概念
人工智能 Vs 机器学习 Vs 深度学习
人工智能，就是用机器模拟人的意识和思维。
机器学习，则是实现人工智能的一种方法，是人工智能的子集。
深度学习就是深层次神经网络，是机器学习的一种实现方法，是机器学习的子集。
Tensorflow学习总结一
Tensorflow的特点
用张量表示数据，用计算图搭建神经网络，用会话执行计算图 ，优化线上的权重（参数），得到模型。
张量：张量就是多维数组（列表），用“阶”表示张量的维度
数据类型：Tensorflow 的数据类型有 tf.float32、tf.int32 等
计算图（Graph）：搭建神经网络的计算过程，是承载一个或多个计算节点的一张图，只搭建网络，不运算
会话（Session）：执行计算图中的节点运算，我们用 with 结构实现，语法如下：

with tf.Session() as sess: 
  print sess.run(y)

举例：

import tensorflow as tf           #引入模块 
x = tf.constant([[1.0, 2.0]])     #定义一个 2 阶张量等于[[1.0,2.0]] 
w = tf.constant([[3.0], [4.0]])   #定义一个 2 阶张量等于[[3.0],[4.0]] 
y = tf.matmul(x, w)               #实现 xw 矩阵乘法 
print y                           #打印出结果 
with tf.Session() as sess: 
    print sess.run(y)            #执行会话并打印出执行后的结果

输出结果：

Tensor(“matmul:0”, shape(1,1), dtype=float32)  #运行 Session()会话前只打印出 y是个张量的提示
[[11.]]  #运行 Session()会话后打印出了 y 的结果

2、神经网络相关概念
神经网络的参数：是指神经元线上的权重 w，用变量表示，一般会先随机生成这些参数。生成参数的方法是让w 等于tf.Variable，把生成的方式写在括号里。
神经网络中常用的生成随机数/数组的函数有：

tf.random_normal()            生成正态分布随机数 
tf.truncated_normal()         生成去掉过大偏离点的正态分布随机数 
tf.random_uniform()           生成均匀分布随机数 
tf.zeros                      表示生成全 0 数组        
tf.ones                       表示生成全 1 数组       
tf.fill                       表示生成全定值数组     
tf.constant                  表示生成直接给定值的数组  

如：
w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1))
#表示生成正态分布随机数，形状两行三列，标准差是 2，均值是 0，随机种子是 1
#随机种子相同，生成的随机数相同
w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))，
#表示去掉偏离过大的正态分布，也就是如果随机出来的数据偏离平均值超过两个标准差，这个数据将重新生成
w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32，seed=1),
#表示从一个均匀分布[minval maxval)中随机采样，注意定义域是左闭右开，即包含 minval，不包含 maxval

生成常量：
tf.zeros([3,2],int32)       #表示生成[[0,0],[0,0],[0,0]]；
tf.ones([3,2],int32)        #表示生成[[1,1],[1,1],[1,1]；
tf.fill([3,2],6)            #表示生成[[6,6],[6,6],[6,6]]；
tf.constant([3,2,1])        #表示生成[3,2,1]

神经网络的实现过程：
1、准备数据集，提取特征，作为输入喂给神经网络（Neural Network，NN）
2、搭建 NN 结构，从输入到输出（先搭建计算图，再用会话执行）
（ NN 前向传播算法，计算输出）
3、大量特征数据喂给 NN，迭代优化 NN 参数
（ NN 反向传播算法，优化参数训练模型）
4、使用训练好的模型预测和分类

前向传播 就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出
Tensorflow学习总结一
注意： 神经网络共有几层（或当前是第几层网络）都是指的计算层，输入不是计算层
前向传播过程的 tensorflow 描述：
1、变量初始化、计算图节点运算都要用会话（with 结构）实现

with tf.Session() as sess: 
     sess.run()

2、变量初始化：在 sess.run 函数中用 tf.global_variables_initializer()汇
总所有待优化变量。 init_op = tf.global_variables_initializer()

 sess.run(init_op)

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

sess.run(y)

4、用 tf.placeholder 占位，在 sess.run 函数中用 feed_dict 喂数据
喂一组数据：

x = tf.placeholder(tf.float32, shape=(1, 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]]})

例如：

#coding:utf-8 
import tensorflow as tf 
#定义输入和参数 
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(”y in tf3_3.py is:\n”,sess.run(y,feed_dict={x:[[0.7,0.5]]}) )

反向传播

反向传播： 训练模型参数，在所有参数上用梯度下降，使 NN 模型在训练数据上的损失函数最小。
损失函数（loss）：计算得到的预测值 y 与已知答案 y_的差距。
损失函数的计算有很多方法，均方误差 MSE 是比较常用的方法之一。用 tensorflow 函数表示为：

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

反向传播训练方法：以减小 loss 值为优化目标，有梯度下降、momentum 优化器、adam 优化器等优化方法。这三种优化方法用 tensorflow 的函数可以表示为：

train_step=tf.train.Gradient Descent Optimizer(learning_rate).minimize(loss) 
train_step=tf.train.Momentum Optimizer(learning_rate, momentum).minimize(loss) 
train_step=tf.train.Adam Optimizer(learning_rate).minimize(loss)

三种优化方法区别如下：
①tf.train.Gradient Descent Optimizer()使用随机梯度下降算法，使参数沿着
梯度的反方向，即总损失减小的方向移动，实现更新参数。
②tf.train.Momentum Optimizer()在更新参数时，利用了超参数。
③tf.train.Adam Optimizer()是利用自适应学习率的优化算法，Adam 算法和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。
学习率：决定每次参数更新的幅度。

3、搭建神经网络的八股
神经网络的搭建课分四步完成：准备工作、前向传播、反向传播和循环迭代。

1.导入模块，生成模拟数据集； 
import 
                常量定义 
                生成数据集     
2.前向传播：定义输入、参数和输出 
                 x=        y_= 
                 w1=       w2= 
                 a=        y= 
3. 反向传播：定义损失函数、反向传播方法 
loss= 
train_step= 
4. 生成会话，训练 STEPS 轮 
with tf.session() as sess 
  Init_op=tf. global_variables_initializer() 
  sess_run(init_op) 
  STEPS=3000 
  for i in range(STEPS): 
   start= 
   end= 
   sess.run(train_step, feed_dict:)

举例：随机产生 32 组生产出的零件的体积和重量，训练 3000 轮，每 500 轮输出一次损失函数。下面我们通过源代码进一步理解神经网络的实现过程：

#coding:utf-8
#0、导入模块，生成模拟数据集：
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 = [[int(x0+x1<1)]for(x0,x1)in X]
print("X:\n",X)
print("Y:\n",Y)

#1、定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32,shape =(None,2))
#必须定义类型，shape中None表示不知道一次输入多少个样本，2表示样本的特征（维度）为2
y_ = tf.placeholder(tf.float32,shape =(None,1))  #1：输出的y为一位向量

#初始化w1、w2，注意w1、w2的维度的选择
w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
#w1中，2表示输入样本有两个特征，3表示有三个神经元（节点）
w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
#w2中，3表示3个节点，1表示输出的y_为一维向量

#进行矩阵乘法
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.AdamOptimizer(0.001).minimize(loss)

#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
    for i in range(STEPS):
        start = (i*BATCH_SIZE)%32
        end = start +BATCH_SIZE
        #给x，y_赋值
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]})
        #每隔500步打印训练的损失
        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))

声明：本博客为学习《人工智能实践：Tensorflow笔记》：
https://www.icourse163.org/learn/PKU-1002536002#/learn/content
后总结，非常感谢曹健老师教授，转载请说明出处。

Tensorflow学习总结一

Tensorflow入门

相关推荐