1 创建 -> 打开 -> 操作 -> 保存 -> 运行
- 打印当前在哪个目录：pwd（打印的是绝对路径）
- cd系列。打开文件：cd 文件名；cd - 上次所在目录；cd ~ 当前用户的home目录
- 显示文件夹列表：ll（小写L）
- 创建文件夹：mkdir 文件名
- 输入 python进入shell交互界面
- 退出交互：ctr+z
- 打开或创建 .py文件：vim filename.py
- 点击i进入插入模式，可写 .py 文件
- 按ESC返回命令模式。底线模式有 ESC: q 退出vim；ESC: wq 保存更改退出vim；ESC: q！ 不保存更改退出vim || 非底线模式 ESC + ZZ 保存退出
- 运行文件 python filename.py
2 Tensorflow八股
- 基于tensorflow的NN，用张量表示数据：0阶张量，标量；1阶张量，向量；2阶张量，矩阵…
- 计算图：只搭建神经网络计算过程，不运算
- 会话（Session）：执行计算图中的节点运算
- 更改vim的配置文件：vim ~/.vimrc
- 参数：即神经元线上的参数，w，随机给定初始值，偏量，b
前向传播----就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出;
反向传播----训练模型参数，在所有参数上用梯度下降，使 NN 模型在训练数据上的损失函数最小;
损失函数loss----计算得到的预测值 y 与已知答案 y_的差距;
均方误差 MSE----求前向传播计算结果与已知答案之差的平方再求平均，loss_mse = tf.reduce_mean(tf.square(y_ - y)) ；
反向传播训练方法----以减小 loss 值为优化目标，有梯度下降、momentum 优化器、adam 优化器等优化方法；
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
train_step=tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss)
train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)
学习率----决定每次参数更新的幅度；
# coding:UTF-8
# 0,moule
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
# data
rng = np.random.RandomState(SEED)
X = rng.rand(32, 2)
Y_ = [[int(x0 + x1 < 1)] for (x0, x1) in X]
# foward
x = tf.placeholder(tf.float32,shape=(BATCH_SIZE,2))
y_ = tf.placeholder(tf.float32,shape=(BATCH_SIZE,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)
# loss back
loss_mse = tf.reduce_mean(tf.square(y-y_))
train_step = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss_mse)
# Session
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
STEPS = 1000
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 % 100 == 0:print("now %d steps, loss = %g"%(i,sess.run(loss_mse,feed_dict={x:X[start:end],y_:Y_[start:end]})))
print(sess.run(w1))
3 神经网络优化
3.1 引入激活函数
- 神经元模型：用数学公式表示为：?(∑????? + ?)，f 为激活函数。神经网络是以神经元为基本单元构成的。
- 常用的激活函数有 relu、sigmoid、tanh 等
3.2 参数
- 神经网络的复杂度：可用神经网络的层数和神经网络中待优化参数个数表示
- 神经网路的层数：一般不计入输入层，层数 = n 个隐藏层 + 1 个输出层
- 神经网路待优化的参数：神经网络中所有参数 w 的个数 + 所有参数 b 的个数
3.3 优化
（1）loss（损失函数）
均方误差mse
自定义
交叉熵
（2）学习率
import tensorflow as tf
LEARNING_RATE_BASE = 0.1
LEARNING_RATE_DECAY = 0.99
LEARNING_RATE_STEP = 1
global_step = tf.Variable(0, trainable=False) # 记录当前训练轮数
learn_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
decay_steps=LEARNING_RATE_STEP,
decay_rate=LEARNING_RATE_DECAY,
staircase=True)
w = tf.Variable(tf.constant(5, dtype=tf.float32))
loss = tf.square(w + 1)
train_step = tf.train.GradientDescentOptimizer(
learn_rate).minimize(loss, global_step=global_step)
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
for i in range(10):
sess.run(train_step)
learning_rate_val = sess.run(learn_rate)
global_step_val = sess.run(global_step)
w_val = sess.run(w)
loss_val = sess.run(loss)
print(
'After %d steps,w is %f, loss is %f, learning rate is %f, global step val is %f' %
(i, w_val, loss_val, learning_rate_val, global_step_val))
结果：
由结果可以看出，随着训练轮数增加学习率在不断减小
（3）滑动平均
滑动平均追随参数的变化而变化
w = tf.Variable(0,dtype=tf.float32)
global_step = tf.Variable(0,trainable=False)
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
ema_op = ema.apply(tf.trainable_variables())
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
print("initial value:",sess.run([w,ema.average(w)]))
sess.run(tf.assign(global_step,100))
sess.run(tf.assign(w,10))
sess.run(ema_op)
print(sess.run([w,ema.average(w)]))
sess.run(ema_op)
print(sess.run([w, ema.average(w)]))
sess.run(ema_op)
print(sess.run([w, ema.average(w)]))
sess.run(ema_op)
print(sess.run([w, ema.average(w)]))
（4）正则化
(5)神经网络的搭建–模块化搭建神经网络
包含3个函数：生成数据集(generateds.py)、前向传播(forward.py)、反向传播 (backward.py)
- 向前传播（forward.py），从输入到输出，搭建完整的网络结构
def forward(x,regularizer):
#网络结构的设计
#输入x，正则化权重参数regularizer
w=
b=
y=
return y
def get_weight(shape,regularizer):
# 给权重赋值
w=tf.Variable()
tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))
return w
def get_bias(shape):
#偏量设置初值
b=tf.Variable()
return b
- 反向传播(backward.py)：训练网络参数，优化网络参数，提高模型的准确性
def backward():
#
x=tf.palceholder()
y_=tf.placeholder()
y = forward.forward(x, REGULARIZER)
global_step = tf.Variable(0, trainable=False) # 训练的轮数，不可训练型参数
loss =
在训练网络模型时，常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。
#正则化
#首先，计算预测结果与标准答案的损失值
#MSE: y 与 y_的差距
loss_mse)= tf.reduce_mean(tf.square(y-y_))
#交叉熵:
ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
#y 与 y_的差距
cem = tf.reduce_mean(ce)
#自定义:y 与 y_的差距
#其次，总损失值为预测结果与标准答案的损失值加上正则化项
loss = y 与 y_的差距 + tf.add_n(tf.get_collection('losses'))
#指数衰减学习率
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE, global_step,
数据集总样本数 / BATCH_SIZE,
LEARNING_RATE_DECAY,
staircase=True)
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,
global_step=global_step)
#滑动平均
ema = tf.train.ExponentialMovingAverage(
MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name='train')
- 训练参数
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
for i in range(STEPS):
sess.run(train_step, feed_dict={x: ，y_: })
if i % 轮数 == 0:
print
if __name__=='__main__':
backward()
- 生成数据集(generateds.py)(略）
例子：
# generated.py
# coding:utf-8
# generate data
import numpy as np
SEED = 2
def generated():
rdm = np.random.RandomState(SEED)
X = rdm.randn(300, 2)
Y_ = [int(x0 * x0 + x1 * x1 < 2) for (x0, x1) in X]
Y_c = [['red' if y else 'blue'] for y in Y_]
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)
return X, Y_, Y_c
# forward.py
# coding:utf-8
# forward module:3 functions
import tensorflow as tf
def forward(x, regulzrizer):
w1 = get_weight([2, 11], regulzrizer)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
w2 = get_weight([11, 1], regulzrizer)
b2 = get_bias([1])
y = tf.matmul(y1, w2) + b2 # 输出层 不过 激活
return y
def get_weight(shape, regularizer):
w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
tf.add_to_collection(
'losses',
tf.contrib.layers.l2_regularizer(regularizer)(w))
return w
def get_bias(shape):
b = tf.Variable(tf.constant(0.01,shape=shape), dtype=tf.float32)
return b
# backward
# coding:utf-8
# backward
import generated
import forward
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
BATCH_SIZE = 30
STEPS = 10000 # 训练的轮数
LEARNING_RATE_BASE = 0.01
LEARNING_RATE_DECAY = 0.999
REGULARIZER = 0.01 # 正则化权重
def backward():
# 输入值，输出值
x = tf.placeholder(dtype=tf.float32, shape=(None, 2))
y_ = tf.placeholder(dtype=tf.float32, shape=(None, 1))
X, Y_, Y_c = generated.generated()
y = forward.forward(x, REGULARIZER)
# 训练轮数
global_step = tf.Variable(0, trainable=False)
# 动态定义学习率
learn_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
300 / BATCH_SIZE,
LEARNING_RATE_DECAY,
staircase=True)
# 定义损失函数
loss_mse = tf.reduce_mean(tf.square(y - y_))
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
# 训练器
train_step = tf.train.AdamOptimizer(learn_rate).minimize(loss_total)
# 会话
with tf.Session() as sess:
init_op = tf.initialize_all_variables()
sess.run(init_op)
for i in range(STEPS):
start = (i * BATCH_SIZE) % 300
end = start + BATCH_SIZE
sess.run(train_step, feed_dict={
x: X[start:end], y_: Y_[start:end]})
if i % 200 == 0:
loss_total_val = sess.run(loss_total, feed_dict={x: X, y_: Y_})
print('After %d steps,loss is %f' % (i, loss_total_val))
# 网格
xx, yy = np.mgrid[-4:4:0.01, -4:4:0.01]
grid = np.c_[xx.ravel(), yy.ravel()]
probs = sess.run(y, feed_dict={x: grid})
probs = probs.reshape(xx.shape)
plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()
if __name__ == '__main__':
backward()
生成数据点图：
结果图：
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
