Tensorflow笔记之【神经网络的初步搭建】

一、基本概念

基于Tensorflow的神经网络

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

张量——多维数组

参数——神经元线上的权重

计算图——搭建神经网络的计算过程，只搭建不计算

会话——执行计算图中的节点运算

例：矩阵乘法

   

import tensorflow as tf #引入模块
x = tf.constant([[1.0, 2.0]]) #定义一个 2 阶1x2张量等于[[1.0,2.0]]
w = tf.constant([[3.0], [4.0]]) #定义一个 2 阶2x1张量等于[[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)
[[11.]]

---

二、程序实现

张量

0阶张量称作标量，表示一个单独的数，如S=123；

1阶张量称作向量，表示一个一维数组，如V=[1,2,3]；

2阶张量称作矩阵，表示一个二维数组，如M=[[1,2,3],[4,5,6],[7,8,9]]；

以及更高阶张量，如T=[[[...]]]。

数据

建图时使用x = tf.placeholder(tf.float32, shape=(1, 2))占位，之后在会话中喂数据。

数据类型

Tensorflow的数据类型有tf.float32、tf.int32等。

参数

使w=tf.Variable(生成方式)，方式如下表：

（stddev表示标准差，mean表示均值，seed表示随机种子，三者无要求可不写）

生成方法	说明	示例
tf.random_normal( )	生成正态分布随机数	w=tf.Variable(tf.random_normal([2,3],stddev=2, mean=0, seed=1)
tf.truncated_normal( )	生成去掉过大偏离点的正态分布随机数	w=tf.Variable(tf.Truncated_normal([2,3],stddev=2, mean=0, seed=1))
tf.random_uniform( )	生成均匀分布随机数	w=random_uniform(shape=7,minval=0,maxval=1,dtype=tf.int32，seed=1)
tf.zeros( )	生成全0数组	w=tf.zeros([3,2],int32)
tf.ones( )	生成全1数组	w=tf.ones([3,2],int32)
tf.fill( )	生成全定值数组	w=tf.fill([3,2],6)
tf.fill( )	生成直接给定值的数组	w=tf.constant([3,2,1])

前向传播

搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出 。

反向传播

损失函数——计算得到的预测值y与已知答案y_的差距，计算方法有很多，均方误差MSE是比较常用的方法

如：loss=tf.reduce_mean(tf.square(y_-y))

反向传播训练——以减小loss值为优化目标，一般有如下优化方法

优化方法	示例
梯度下降	train_step=tf.train .GradientDescentOptimizer(learning_rate).minimize(loss)
momentum优化器	train_step=tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss)
adam优化器	train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)

学习率——每次参数更新的幅度，过大会震荡不收敛，过小会收敛速度慢，一般选比较小的值，如0.01、0.001。

会话

常用结构

with tf.session() as sess
    init_op=tf. global_variables_init ializer()
    sess_run(init_op)
    STEPS=3000
    for i in range(STEPS):
    start=
    end=
    sess.run(train_step, feed_dict:)

主要任务

变量初始化	init_op = tf.global _variables_initializer() sess.run(init_op)
计算图节点运算	sess.run(y) sess.run(w1) #不需要数据时
喂数据	sess.run(y, feed_dict={x:X[start:end]}) sess.run(loss,feed_dict={x:X,y_:Y} sess.run(train_step,feed_dict={x:X[start:end],y_:Y[start:end]}) #需要数据时，如计算损失或训练

---

三、神经网络的搭建

步骤

0.导入模块，生成模拟数据集	import tensorflow as tf 常量定义 导入或生成数据集
1.前向传播：定义输入、参数和输出	x 输入特征；y_ 正确值；w1参数1；w2 参数2； a 中间层；y 输出层
2.反向传播：定义损失函数、反向传播方法	loss train_step
3.生成会话，训练	with tf.session() as sess

示例代码

#coding:utf-8
#0导入模块，生成模拟数据集。
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455#基于seed产生随机数
rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)#随机数返回32行2列的矩阵 表示32组 体积和重量 作为输入数据集
Y_ = [[int(x0 + x1 < 1)] for (x0, x1) in X]#从X中取出一行 判断后给Y赋值，作为输入数据集的标签
print "X:\n",X
print "Y_:\n",Y_

#1定义神经网络的输入、参数和输出,定义前向传播过程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_= tf.placeholder(tf.float32, shape=(None, 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_mse = tf.reduce_mean(tf.square(y-y_)) 
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#train_step = tf.train.MomentumOptimizer(0.001,0.9).minimize(loss_mse)
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss_mse)

#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
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
        if i % 500 == 0:
            total_loss = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
            print("After %d training step(s), loss_mse on all data is %g" % (i, total_loss))
    # 输出训练后的参数取值。
    print "\n"
    print "w1:\n", sess.run(w1)
    print "w2:\n", sess.run(w2)

#输出
"""
X:
[[ 0.83494319  0.11482951]
 [ 0.66899751  0.46594987]
 [ 0.60181666  0.58838408]
 [ 0.31836656  0.20502072]
 [ 0.87043944  0.02679395]
 [ 0.41539811  0.43938369]
 [ 0.68635684  0.24833404]
 [ 0.97315228  0.68541849]
 [ 0.03081617  0.89479913]
 [ 0.24665715  0.28584862]
 [ 0.31375667  0.47718349]
 [ 0.56689254  0.77079148]
 [ 0.7321604   0.35828963]
 [ 0.15724842  0.94294584]
 [ 0.34933722  0.84634483]
 [ 0.50304053  0.81299619]
 [ 0.23869886  0.9895604 ]
 [ 0.4636501   0.32531094]
 [ 0.36510487  0.97365522]
 [ 0.73350238  0.83833013]
 [ 0.61810158  0.12580353]
 [ 0.59274817  0.18779828]
 [ 0.87150299  0.34679501]
 [ 0.25883219  0.50002932]
 [ 0.75690948  0.83429824]
 [ 0.29316649  0.05646578]
 [ 0.10409134  0.88235166]
 [ 0.06727785  0.57784761]
 [ 0.38492705  0.48384792]
 [ 0.69234428  0.19687348]
 [ 0.42783492  0.73416985]
 [ 0.09696069  0.04883936]]
Y_:
[[1], [0], [0], [1], [1], [1], [1], [0], [1], [1], [1], [0], [0], [0], [0], [0], [0], [1], [0], [0], [1], [1], [0], [1], [0], [1], [1], [1], [1], [1], [0], [1]]
w1:
[[-0.81131822  1.48459876  0.06532937]
 [-2.4427042   0.0992484   0.59122431]]
w2:
[[-0.81131822]
 [ 1.48459876]
 [ 0.06532937]]


After 0 training step(s), loss_mse on all data is 5.13118
After 500 training step(s), loss_mse on all data is 0.429111
After 1000 training step(s), loss_mse on all data is 0.409789
After 1500 training step(s), loss_mse on all data is 0.399923
After 2000 training step(s), loss_mse on all data is 0.394146
After 2500 training step(s), loss_mse on all data is 0.390597


w1:
[[-0.70006633  0.9136318   0.08953571]
 [-2.3402493  -0.14641267  0.58823055]]
w2:
[[-0.06024267]
 [ 0.91956186]
 [-0.0682071 ]]
"""

（整理自网课笔记，课程地址https://www.icourse163.org/course/PKU-1002536002）