系统自动挂起之后把进程全部关了，，，之前写的都没了，这篇就省事一点吧
预测酸奶日销量，y_=x1+x2,加入随机噪声（-0.05~+0.05），默认成本和利润相等：
#预测多或预测少的影响结果一样
#0导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
SEED=23455
rdm=np.random.RandomState(SEED)
X=rdm.rand(32,2)
Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X]#rand生成[0,1]（前闭后开）的随机数，除以10.0再减去0.05得到了[-0.05,0.05]之间的随机数
#1定义神经网络的输入，参数和输出，定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)
#2定义损失函数及反向传播方法。
#定义损失函数为MSE，反向传播方法为梯度下降
loss_mse=tf.reduce_mean(tf.square(y-y_))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#3生成会话，训练STEPS轮
sess=tf.Session()
init_op=tf.global_variables_initializer()
sess.run(init_op)
STEPS=20000
for i in range(STEPS):
start=(i*BATCH_SIZE)%32
end=(i*BATCH_SIZE)%32+BATCH_SIZE
sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
if i%500==0:
print("After %d training steps,w1 is:" %(i))
print(sess.run(w1),"\n")
print("Final w1 is:\n",sess.run(w1))运行结果 ：
After 18500 training steps,w1 is:
[[0.9718707]
[1.0233142]]
After 19000 training steps,w1 is:
[[0.974931 ]
[1.0206276]]
After 19500 training steps,w1 is:
[[0.9777026]
[1.0181949]]
Final w1 is:
[[0.98019385]
[1.0159807 ]]
成本1元，利润9元，模型往多了预测代码：
#酸奶成本1元，酸奶利润9元
#预测少了损失大，故不要预测少，生成的模型会多预测一些
#0导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
SEED=23455
COST=1
PROFIT=9
rdm=np.random.RandomState(SEED)
X=rdm.rand(32,2)
Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X]#rand生成[0,1]（前闭后开）的随机数，除以10.0再减去0.05得到了[-0.05,0.05]之间的随机数
#1定义神经网络的输入，参数和输出，定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)
#2定义损失函数及反向传播方法。
#定义损失函数使得预测少了的损失大，于是模型应该偏向多的方向预测
loss=tf.reduce_sum(tf.where(tf.greater(y,y_),(y-y_)*COST,(y_-y)*PROFIT))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#3生成会话，训练STEPS轮
sess=tf.Session()
init_op=tf.global_variables_initializer()
sess.run(init_op)
STEPS=20000
for i in range(STEPS):
start=(i*BATCH_SIZE)%32
end=(i*BATCH_SIZE)%32+BATCH_SIZE
sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
if i%500==0:
print("After %d training steps,w1 is:" %(i))
print(sess.run(w1),"\n")
print("Final w1 is:\n",sess.run(w1))运行结果：
After 18500 training steps,w1 is:
[[1.0232253]
[1.0443138]]
After 19000 training steps,w1 is:
[[1.0182064]
[1.0474416]]
After 19500 training steps,w1 is:
[[1.0232093]
[1.0445814]]
Final w1 is:
[[1.0225189]
[1.0416598]]
成本9元，利润1元，模型往少了预测：
#酸奶成本9元，酸奶利润1元
#预测多了损失大，故不要预测多，生成的模型会少预测一些
#0导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE=8
SEED=23455
COST=9
PROFIT=1
rdm=np.random.RandomState(SEED)
X=rdm.rand(32,2)
Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X]#rand生成[0,1]（前闭后开）的随机数，除以10.0再减去0.05得到了[-0.05,0.05]之间的随机数
#1定义神经网络的输入，参数和输出，定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))
w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)
#2定义损失函数及反向传播方法。
#定义损失函数使得预测少了的损失大，于是模型应该偏向多的方向预测
loss=tf.reduce_sum(tf.where(tf.greater(y,y_),(y-y_)*COST,(y_-y)*PROFIT))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#3生成会话，训练STEPS轮
sess=tf.Session()
init_op=tf.global_variables_initializer()
sess.run(init_op)
STEPS=20000
for i in range(STEPS):
start=(i*BATCH_SIZE)%32
end=(i*BATCH_SIZE)%32+BATCH_SIZE
sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
if i%500==0:
print("After %d training steps,w1 is:" %(i))
print(sess.run(w1),"\n")
print("Final w1 is:\n",sess.run(w1))运行 结果：
After 18500 training steps,w1 is:
[[0.9599792]
[0.9743824]]
After 19000 training steps,w1 is:
[[0.9630599 ]
[0.97630805]]
After 19500 training steps,w1 is:
[[0.967159 ]
[0.9735418]]
Final w1 is:
[[0.9661967]
[0.9769494]]
造成以上结果的原因：自定义loss值为：loss=tf.reduce_sum(tf.where(tf.greater(y,y_),(y-y_)*COST,(y_-y)*PROFIT))，神经网络的目的是降低loss值，此句是判断y是否大于y_，若是，(y-y_)*COST为真，反之(y_-y)*PROFIT)为真，模型会偏向二者较小的一方预测，借此判断预测值y和标准答案y_的关系。
交叉熵（Cross Entropy）：表示两个概率分布之间的距离。交叉熵越大，两个概率分布距离越远，它们的分布就越相异。
用tensorflow函数表示为：ce=-tf.reduce_mean(y_tf.log(tf.clip_by_value(y,le-12,1.0)))
对y小于le-12时为le-12,大于1时为1,避免出现log 0的情况
softmax函数：
softmax函数应用：在n分类中模型会有n个输出，即Y1,Y2,Y3......Yn，其中Yi表示第i种情况出现的可能性大小，将n个输出经过softmax函数，可得到符合概率分布的分类结果。
在Tensorflow中，一般让模型的输出经过softmax函数，以获得输出分类的概率分布，再与标准答案对比，求出交叉熵，得到损失函数，用如下函数实现：
ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
cem=tf.reduce_mean(ce)
学习率learning_rate：表示了每次参数更新的幅度大小。学习率过大，会导致优化的参数在最小值附近波动，不收敛;学习率过小会导致待优化的参数收敛缓慢。
指数衰减学习率：学习率随着训练轮数变化而动态更新
指数衰减学习率的计算公式：
其中，LEARNING_RATE_STEP为学习率初始值，LEARNING_RATE_DECAY为学习率衰减率，global_step记录了当前训练轮数，为不可训练型参数。学习率learning_rate更新频率为输入数据集总样本数除以每次喂入样本数。若staircase设置为True时，表示global_step/learning rate step取整数，学习率阶梯型衰减，若staircase设置为false时，学习率会是一条平滑下降的曲线。
#设损失函数 loss=(w+1)^2,令w初值是常数5.反向传播就是求最优w，即求最小loss对应的w值
#使用指数衰减的学习率，在迭代初期得到较高的下降速度，可以在较小的训练轮数下取得更有收敛度。
import tensorflow as tf
LEARNING_RATE_BASE=0.1 #最初学习率
LEARNING_RATE_DECAY=0.99#学习率衰减率
LEARNING_RATE_STEP=1 #喂入多少轮BATCH_SIZE之后，更新一次学习率，一般设为：总样本数/BATCH_SIZE
#运行了几轮BATCH_SIZE的计数器，初值给0,设为不被训练
global_step=tf.Variable(0,trainable=False)
#定义指数下降学习率
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,LEARNING_RATE_STEP,LEARNING_RATE_DECAY,staircase=True)
#定义待优化参数，初值给5
w=tf.Variable(tf.constant(5,dtype=tf.float32))
#定义损失函数loss
loss=tf.square(w+1)
#定义反向传播方法
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
#生成会话，训练40轮
sess=tf.Session()
init_op=tf.global_variables_initializer()
sess.run(init_op)
for i in range(40):
sess.run(train_step)
learning_rate_val=sess.run(learning_rate)
global_step_val=sess.run(global_step)
w_val=sess.run(w)
loss_val=sess.run(loss)
print("After %s steps:global_step is %f,w is %f,learning rate is %f,loss is %f"%(i,global_step_val,w_val,learning_rate_val,loss_val))
运行结果：
After 0 steps:global_step is 1.000000,w is 3.800000,learning rate is 0.099000,loss is 23.040001
After 1 steps:global_step is 2.000000,w is 2.849600,learning rate is 0.098010,loss is 14.819419
After 2 steps:global_step is 3.000000,w is 2.095001,learning rate is 0.097030,loss is 9.579033
After 3 steps:global_step is 4.000000,w is 1.494386,learning rate is 0.096060,loss is 6.221960
. . .
. . .
. . .
After 37 steps:global_step is 38.000000,w is -0.994284,learning rate is 0.068255,loss is 0.000033
After 38 steps:global_step is 39.000000,w is -0.995064,learning rate is 0.067573,loss is 0.000024
After 39 steps:global_step is 40.000000,w is -0.995731,learning rate is 0.066897,loss is 0.000018
可以看出，随着训练轮数增加，学习率在不断减小。
滑动平均：记录了一段时间内模型中所有参数w和b各自的平均值。利用滑动平均值可以增强模型的泛化能力（对新鲜样本的适应能力）。
在神经网络中，将MOVING_AVERAGE_DECAY设置为0.99,参数w1设置为0,w1的滑动平均值为设置为0。
开始时，轮数global_step设置为0,参数w1更新为1,则w1的滑动平均值为：
w1滑动平均值min=(0.99,1/10)*0+(1-min(0.99,1/10)*1)=0.9 (影子值初始值等于参数)
当轮数global_step更新为100,参数w1更新为10,则滑动平均值变为：
w1滑动平均值=min(0.99,101/110)*0.9+(1-min(0.99,101/110)*10)=2.328
再次运行，参数更新为2.328,则滑动平均值：
w1滑动平均值=2.956
代码如下：
import tensorflow as tf
#定义变量及滑动平均类
#定义一个32位浮点变量，初始值为0,这个代码就是不断更新参数w1,优化w1参数，滑动平均做了w1的影子
w1=tf.Variable(0,dtype=tf.float32)
#定义num_updates(NN的迭代轮数)，初始值为0,不可被训练
global_step=tf.Variable(0,trainable=False)
#实例化滑动平均类，给衰减率为0.99,当前轮数为global_step
MOVING_AVERAGE_DECAY=0.99
ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
#ema.apply后的括号里是更新列表，每次运行sess.run(ema_op)时，对更新列表中的元素求滑动平均值
#在实际应用中会使tf.trainable_variables()自动将所有待优化的参数汇总为列表
#ema_op=ema.apply([w1])
ema_op=ema.apply(tf.trainable_variables())
#2.查看不同迭代中变量取值变化
sess=tf.Session()
init_op=tf.global_variables_initializer()
sess.run(init_op)
#用ema.avearge(w1)获取w1滑动平均值（要运行多个节点，作为列表中的元素列出，写在sess.run中）
#打印出当前w1和w1滑动平均值
print(sess.run([w1,ema.average(w1)]))
#参数的w1赋值为1
sess.run(tf.assign(w1,1))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
#更新step和w1的值，模拟出100轮迭代后，参数w1变为10
sess.run(tf.assign(global_step,100))
sess.run(tf.assign(w1,10))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
#每次sess.run会更新一次w1的滑动平均值
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))
sess.run(ema_op)
print(sess.run([w1,ema.average(w1)]))运行结果：
[0.0, 0.0]
[1.0, 0.9]
[10.0, 1.6445453]
[10.0, 2.3281732]
[10.0, 2.955868]
[10.0, 3.532206]
[10.0, 4.061389]
[10.0, 4.547275]
[10.0, 4.9934072]正则化缓解过拟合：在损失函数中给每个参数w加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合（不对偏置b使用）
使用正则化后，损失函数变为两项之和：
loss=loss(y与y_)+REGULARIZER*loss(w)
第一项为预测结果与标准答案之间的差距，第二项为正则化计算的结果。
用300个符合正态分布的点X[x0,x1]作为数据集，根据点X[x0,x1]计算生成标注Y_,将数据集标注为红色点和蓝色点。
标注规则为：当x0*x0+x1*x1<2时，y_=1,标注为红色，当x0*x0+x1*x1>2时，y_=0，标注为蓝色。
用有正则化和无正则化两种方法拟合曲线，把红色和蓝色点分开。实际分类时，如果前向传播输出的预测值y接近1则为红色概率越大，接近0为蓝色概率越大，输出的预测值y为0.5是红蓝点的概率分界线。
matplotlib模块：python中的可视化工具模块，实现函数可视化
函数plt.scatter():利用指定颜色实现点（x，y）的可视化
plt.scatter(x坐标，y坐标，c=“颜色”)
plt.show()
收集规定区域所有的网格坐标点：
xx，yy=np.mgrid[起:止:步:长，起:止:步:长]#找到规定区域以步长为分辨率的行列网格坐标点
grid=np.c_[xx.ravel(),yy.ravel()]#收集规定区域内所有的网格坐标点
plt.contour()函数：告知x、y坐标和各点高度，用levels指定高度上的点描上颜色
plt.contour(x轴坐标值，y轴坐标值，该点的高度，levels=[等高线的高度])
plt.show()
#coding:utf-8
#0导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30
seed = 2
#基于seed产生随机数
rdm = np.random.RandomState(seed)
#随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
X = rdm.randn(300,2)
#从X这个300行2列的矩阵中取出一行，判断如果两个坐标的平方和小于2,给Y赋值1,其余赋值0
#作为输入数据集的标签（正确答案）
Y_ = [int(x0*x0+x1*x1<2) for (x0,x1) in X]
#遍历Y中的每个元素，1赋值"red"，其余赋值“blue”，这样可视化时可以直观区分
Y_c =[['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，把第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1,2)
Y_ = np.vstack(Y_).reshape(-1,1)
print(X)
print(Y_)
print(Y_c)
#用plt.scatter画出数据集X各行中第0列元素和第一列元素的点即各行的（x0,x1），用各行Y_c对应的值表示颜色（c是color的缩写）
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.show()
#定义神经网络的输入、输出和参数，定义前向传播过程
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))
return b
x = tf.placeholder(tf.float32,shape=(None,2))
y_ = tf.placeholder(tf.float32,shape=(None,1))
w1 = get_weight([2,11],0.01)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x,w1)+b1)
w2 = get_weight([11,1],0.01)
b2 = get_bias([1])
y = tf.matmul(y1,w2)+b2#输出层不过激活
#定义损失函数
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(0.0001).minimize(loss_mse)
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
STEPS=40000
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%2000==0:
loss_mse_v=sess.run(loss_mse,feed_dict={x:X,y_:Y_})
print("After %d steps,loss is: %f"%(i,loss_mse_v))
#xx在-3到3之间步长为0.01,yy在-3到3之间以步长0.01,生成二维网格坐标点
xx,yy = np.mgrid[-3:3:.01,-3:3:.01]
#将xx，yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
grid = np.c_[xx.ravel(),yy.ravel()]
#将网格坐标点喂入神经网络，probs为输出
probs = sess.run(y,feed_dict={x:grid})
#probs的shape调整成xx的样子
probs = probs.reshape(xx.shape)
print("w1:\n",sess.run(w1))
print("b1:\n",sess.run(b1))
print("w2:\n",sess.run(w2))
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[.5])
plt.show()
#定义反向传播方法：包含正则化
train_step =tf.train.AdamOptimizer(0.0001).minimize(loss_total)
sess=tf.Session()
init_op = tf.global_variables_initializer()
sess.run(init_op)
STEPS=40000
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 %2000==0:
loss_v = sess.run(loss_total,feed_dict={x:X,y_:Y_})
print("After %d steps,loss is: %f"%(i,loss_v))
xx,yy=np.mgrid[-3:3:.01,-3:3:.01]
grid = np.c_[xx.ravel(),yy.ravel()]
probs = sess.run(y,feed_dict={x:grid})
probs = probs.reshape(xx.shape)
print("w1:\n",sess.run(w1))
print("b1:\n",sess.run(b1))
print("w2:\n",sess.run(w2))
print("b3:\n",sess.run(b2))
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[.5])
plt.show()
204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
