Tensorflow笔记：搭建神经网络

• 基本概念

1.Tensorflow的加法

import tensorflow as tf
a = tf.constant([1.0, 2.0])
b = tf.constant([3.0, 4.0])
result = a + b
print(result)

打印出这句话：Tensor("add:0", shape=(2, ), dtype=float32)，意思是result是一个名称为add:0的张量，shape=(2, )表示一位数组长度为2，dtype=float32表示数据类型为浮点型。

2.计算图

import tensorflow as tf
x = tf.constant([[1.0, 2.0]])
w = tf.constant([[3.0], [4.0]])
y = tf.matmul(x, w)
print(y)

打印出这句话：Tensor("matmul:0", shape(1, 1), dtype=float32)，可以看出print的结果显示y是一个张量，只搭建承载计算过程的计算图，并没有运算。

3.会话

import tensorflow as tf
x = tf.constant([[1.0, 2.0]])
w = tf.constant([[3.0], [4.0]])
y = tf.matmul(x, w)
print(y)
with tf.Session() as sess:
    print(sess.run(y))

打印结果如下：

Tensor("matmul:0", shape(1, 1), dtype=float32)

[[11. ]]

可以看到，运行Session()会话前只打印出y是个张量的提示，运行Session()会话后打印出了y的结果1.0×3.0+2.0×4.0=11.0。

• 神经网络的参数

常用的生成随机数/数组的函数：

tf.random_normal()  生成正态分布随机数

tf.truncated_normal()  生成去掉过大偏离点的正态分布随机数

tf.random_uniform()  生成均匀分布随机数

tf.zeros  生成全0数组

tf.ones  生成全1数组

tf.fill  生成全定值数组

tf.constant  生成直接给定值的数组

• 神经网络的搭建

实现过程：

1.准备数据集，提取特征，作为输入喂给神经网络

2.搭建NN结构，从输入到输出（先搭建计算图，再用会话执行）

（NN前向传播算法计算输出）

3.大量特征数据喂给NN，迭代优化NN参数

（NN反向传播算法优化参数训练模型）

4.使用训练好的模型预测和分类

• 前向传播

1.用placeholder实现输入定义（sess.run中喂入一组数据）的情况

import tensorflow as tf

# 用tf.placeholder占位，在sess.run函数中用feed_dict喂数据
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结构）实现
with tf.Session() as sess:
        # 变量初始化：在sess.run函数中用tf.global_variables_initializer()汇总所有待优化变量
	init_op = tf.global_variables_initializer()
        # 计算图节点运算：在sess.run函数中写入待运算的节点
	sess.run(init_op)
	print("y in tf3_4.py is:\n",sess.run(y, feed_dict={x: [[0.7,0.5]]}))

2.用placeholder实现输入定义（sess.run中喂入多组数据）的情况

import tensorflow as tf

# 定义输入和参数
x = tf.placeholder(tf.float32, shape=(None, 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("the result of tf3_5.py is :\n",sess.run(y, feed_dict={x: [[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]}))
	print("W1:\n",sess.run(W1))
	print("W2:\n",sess.run(W2))

• 反向传播

反向传播：训练模型参数，在所有参数上用梯度下降，使NN模型在训练数据上的损失函数最小。

损失函数（loss）：计算得到的预测值y与已知答案y_的差距。

反向传播训练方法：以减小loss值为优化目标，有梯度下降、momentum优化器、adam优化器等优化方法。

学习率：决定每次参数更新的幅度。

• 搭建神经网络的八股

0.导入模块，生成模拟数据集：

import

常量定义

生成数据集

1.前向传播：定义输入、参数和输出：

x=   y=

w1=   w2=

a=   y=

2.反向传播：定义损失函数、反向传播方法：

loss=

train_step=

3.生成对话，训练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))
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 = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(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
		sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
		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))

由神经网络的实现结果，我们可以看出，总共训练3000轮，每轮从X的数据集和Y的标签中抽取相对应的从start开始到end结束个特征值和标签，喂入神经网络，用sess.run求出loss，每500轮打印一次loss值。经过3000轮后，我们打印出最终训练好的参数w1、w2。

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


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

学习地址：https://www.icourse163.org/course/PKU-1002536002