案例: 预测酸奶的日销量, 由此可以准备产量, 使得损失小(利润大),假设销量是y , 影响销量的有两个因素x1, x2,
需要预先采集数据,每日的x1,x2和销量y_, 拟造数据集X,Y_, 假设y_=x1+x2,为了更真实加一个噪声(-0.05-0.05)
batch_size=8 #一次喂给神经网络多少数据 seed=23455 #构造数据集 rdm=np.random.RandomState(seed) #基于seed产生随机数 X=rdm.rand(32,2) #32组数据 Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X] #rdm.rand()/10.0 是(0,1)随机数 print('X:\n',X) print('Y_:\n',Y_) #定义神经网络的输入 参数 输出 定义前向传播过程 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) #定义损失函数 后向传播方法 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) #其他方法 #train_step=tf.train.AdamOptimizer(0.001).minimize(loss) #生成会话 训练 with tf.Session() as sess: #用会话计算结果 init_op=tf.global_variables_initializer() sess.run(init_op) print('w1:\n', sess.run(w1)) #输出目前(未经训练的)参数取值 #训练模型 steps=20000 #训练20000次 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]}) #8组数据 if i % 500==0: #每500轮打印一次w1值 print('After %d training steps,w1 is:' %i) print(sess.run(w1),'\n') print('Final w1 is:',sess.run(w1)) 结果显示 w1=[0.98,1.015] 这与Y_=x1+x2一致,预测正确!!
1.loss优化
上述例子中, loss函数是均方和, 但是实际中,预测的销量(即要准备的产量y_) 与真实的销量y 之间的差异导致的损失 取决于 生产成本cost 与销售利润profit,
当预测多了, 损失成本, 预测少了,损失利润,
所以这里要自定义loss, 上述代码不变,只需要修改下loss参数
batch_size=8 #一次喂给神经网络多少数据 seed=23455 cost=1 profit=9 #构造数据集 rdm=np.random.RandomState(seed) #基于seed产生随机数 X=rdm.rand(32,2) #32组数据 Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X] #rdm.rand()/10.0 是(0,1)随机数 print('X:\n',X) print('Y_:\n',Y_) #定义神经网络的输入 参数 输出 定义前向传播过程 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) #定义损失函数 后向传播方法 loss=tf.reduce_sum(tf.where(tf.greater(y,y_),cost*(y-y_),profit*(y_-y)))
#tf.where(tf.greater(y,y_),cost*(y-y_),profit*(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) #生成会话 训练 with tf.Session() as sess: #用会话计算结果 init_op=tf.global_variables_initializer() sess.run(init_op) print('w1:\n', sess.run(w1)) #输出目前(未经训练的)参数取值 #训练模型 steps=20000 #训练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]}) #8组数据 if i % 500==0: #每500轮打印一次结果 print('After %d training steps,w1 is:' %i) print(sess.run(w1),'\n') print('Final w1 is:',sess.run(w1))
得到结果是w1=[1.02,1.04] ,系数都大于1 ,这是由于多预测的损失 少于少预测的损失,结果也往多的方向预测了.要是 cost=9 ,profit=1,
最终得到参数w1=[0.96, 0.97] 都小于1
除了均方和, 自定义loss只要, 还有第三种 交叉熵(cross entropy)的loss,
交叉熵(cross entropy): 表示两个概率分布之间的距离, ce越大,距离也就越大.
交叉熵 ce
ce=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-12,1.0)))
n个分类的n输出
ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
cem=tf.reduce_mean(ce)
2.learning_rate 学习率调整
设置learning_rate=0.2
w=tf.Variable(tf.constant(5,dtype=tf.float32)) loss=tf.square(w+1) #定义损失函数 train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss) with tf.Session() as sess: init_op=tf.global_variables_initializer() sess.run(init_op) for i in range(40): #迭代40次 sess.run(train_step) w_val=sess.run(w) loss_val=sess.run(loss) print('after %d steps, w is %f, loss is %f.'%(i,w_val,loss_val))
若上述learning_rate=0.001, w趋于-1速度很慢, learning_rate=1, w会发散,不会趋于-1
上述learning_rate 不能太大,也不能太小
#学习率 决定参数的更新 learning_rate #根据运行的轮数决定动态更新学习率 learning_rate=LEARNING_RATE_BASE*LEARNING_RATE_DECAY^(global_step/LEARNING_RATE_STEP) #LEARNING_RATE_BASE是学习率初始值 LEARNING_RATE_DECAY是学习衰减率(0,1) #多少轮更新一次学习率,LEARNING_RATE_STEP 一般是总样本数/batch_size global_step=tf.Variable(0,trainable=False) #记录当前共运行了多少轮batch-size learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)
# staircase true 学习率阶梯型衰减, false则为平滑下降的曲线
#根据运行的轮数决定动态更新学习率 LEARNING_RATE_BASE=0.1 #最初学习率 LEARNING_RATE_DECAY=0.9 #学习率衰减率 LEARNING_RATE_STEP=1 # 喂入多少batch_size后更新一次学习率,一般是总样本数/batch_size,这里为了方便为1 global_step=tf.Variable(0,trainable=False) #记录当前共运行了多少轮batch-size #定义指数下降学习率 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=tf.square(w+1) #定义损失函数 train_step=tf.train.GradientDescentOptimizer(learning_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(40): #迭代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 %d steps, global_step is %f,w is %f, loss is %f.' %(i,global_step_val,w_val,loss_val))
结果:
