https://www.bilibili.com/video/av22530538/?p=16
#lesson16 损失函数
lesson16 损失函数
#1943年McCulloch Pittls神经元模型
#x（n）-------->f ---->F(x(n)w(n)+b)
# 激活函数 偏置项bias
#激活函数activation function
#rule sigmold tanh
#tf.nn,rule() tf.nn,sigmold() tf.nn,tanh
#NN复杂度：多用NN层数和NN参数的个数表示
#层数=隐藏层的层数+1个输出层
#总参数 = 总w+总b
#3*4+4 + 4*2 +2 =26
# 第一层 第2层
#损失函数loss、学习率learning_rate,滑动平均ema、正则化regularization
#损失函数（loss）:预测值（y）与已知答案（y_）的差距
#NN优化目标：loss最小=》1、mse（Mean Squared Error）2\自定义 3、ce(Cross Entropy)
#均方误差mse：MSE(y_,y) = (y-y_)^2求和/n
#loss_mse = tf.reduce_mean(tf.square(y_-y))
#预测酸奶日销量y。x1，x2是影响日销量的因素。
#建模前，应预先采集的数据有：每日x1，x2和销量y_(即已知答案，最佳情况：产量=销量)
#捏造数据集X，Y_:y_=x1+x2 噪声：-0.05～+0.05 拟合可以预测销量的函数
#预测多或预测少的影响一样
#导入模块，生成数据集
import numpy as np
import tensorflow as tf
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]
#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)
#2定义损失函数及反向传播方法。
#定义损失函数为MSE，反向传播方法为梯度下降。
loss = tf.reduce_mean(tf.square(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.AdadeltaOptimizer(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 = 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]})
if i%500 == 0:
#total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
print("After %d trainig steps:" % (i))
print("\n",sess.run(w1))
print("final w1 is:\n",sess.run(w1))
#在本代码中#2中尝试其他反向传播方法，看对收敛速度的影响，After 0 trainig steps:
('\n', array([[-0.80974597],
[ 1.4852903 ]], dtype=float32))
After 500 trainig steps:
('\n', array([[-0.46074435],
[ 1.641878 ]], dtype=float32))
After 1000 trainig steps:
('\n', array([[-0.21939856],
[ 1.6984766 ]], dtype=float32))
After 1500 trainig steps:
('\n', array([[-0.04415595],
[ 1.7003176 ]], dtype=float32))
After 2000 trainig steps:
('\n', array([[0.08942621],
[1.673328 ]], dtype=float32))
After 2500 trainig steps:
('\n', array([[0.19583555],
[1.6322677 ]], dtype=float32))
After 3000 trainig steps:
('\n', array([[0.28375748],
[1.5854434 ]], dtype=float32))
After 3500 trainig steps:
('\n', array([[0.35848638],
[1.5374472 ]], dtype=float32))
After 4000 trainig steps:
('\n', array([[0.42332518],
[1.4907393 ]], dtype=float32))
After 4500 trainig steps:
('\n', array([[0.48040026],
[1.4465574 ]], dtype=float32))
After 5000 trainig steps:
('\n', array([[0.53113604],
[1.4054536 ]], dtype=float32))
After 5500 trainig steps:
('\n', array([[0.5765325],
[1.3675941]], dtype=float32))
After 6000 trainig steps:
('\n', array([[0.61732584],
[1.3329403 ]], dtype=float32))
After 6500 trainig steps:
('\n', array([[0.6540846],
[1.3013426]], dtype=float32))
After 7000 trainig steps:
('\n', array([[0.6872685],
[1.272602 ]], dtype=float32))
After 7500 trainig steps:
('\n', array([[0.71725976],
[1.2465005 ]], dtype=float32))
After 8000 trainig steps:
('\n', array([[0.7443861],
[1.2228197]], dtype=float32))
After 8500 trainig steps:
('\n', array([[0.7689324],
[1.2013483]], dtype=float32))
After 9000 trainig steps:
('\n', array([[0.79115134],
[1.1818889 ]], dtype=float32))
After 9500 trainig steps:
('\n', array([[0.811267 ],
[1.1642567]], dtype=float32))
After 10000 trainig steps:
('\n', array([[0.8294814],
[1.1482829]], dtype=float32))
After 10500 trainig steps:
('\n', array([[0.84597576],
[1.1338125 ]], dtype=float32))
After 11000 trainig steps:
('\n', array([[0.8609128],
[1.1207061]], dtype=float32))
After 11500 trainig steps:
('\n', array([[0.87444043],
[1.1088346 ]], dtype=float32))
After 12000 trainig steps:
('\n', array([[0.88669145],
[1.0980824 ]], dtype=float32))
After 12500 trainig steps:
('\n', array([[0.8977863],
[1.0883439]], dtype=float32))
After 13000 trainig steps:
('\n', array([[0.9078348],
[1.0795243]], dtype=float32))
After 13500 trainig steps:
('\n', array([[0.91693527],
[1.0715363 ]], dtype=float32))
After 14000 trainig steps:
('\n', array([[0.92517716],
[1.0643018 ]], dtype=float32))
After 14500 trainig steps:
('\n', array([[0.93264157],
[1.0577497 ]], dtype=float32))
After 15000 trainig steps:
('\n', array([[0.9394023],
[1.0518153]], dtype=float32))
After 15500 trainig steps:
('\n', array([[0.9455251],
[1.0464406]], dtype=float32))
After 16000 trainig steps:
('\n', array([[0.95107025],
[1.0415728 ]], dtype=float32))
After 16500 trainig steps:
('\n', array([[0.9560928],
[1.037164 ]], dtype=float32))
After 17000 trainig steps:
('\n', array([[0.96064115],
[1.0331714 ]], dtype=float32))
After 17500 trainig steps:
('\n', array([[0.96476096],
[1.0295546 ]], dtype=float32))
After 18000 trainig steps:
('\n', array([[0.9684917],
[1.0262802]], dtype=float32))
After 18500 trainig steps:
('\n', array([[0.9718707],
[1.0233142]], dtype=float32))
After 19000 trainig steps:
('\n', array([[0.974931 ],
[1.0206276]], dtype=float32))
After 19500 trainig steps:
('\n', array([[0.9777026],
[1.0181949]], dtype=float32))
('final w1 is:\n', array([[0.98019385],
[1.0159807 ]], dtype=float32))自定义损失函数：
#自定义损失函数：
3#如预测商品销量，预测多了，损失成本，预测少了，损失利润
#若利润 不等于成本 ，测mse产生的loss无法利益最大化。
#自定义损失函数 loss(y_,y) = f(y_,y)求和
# y_标准答案的 y预测答案
# 数据集的 计算出的
#f(y_,y) = PROFIT *(y_-y) y<y_ 预测的y少了，损失利润（PROFIT）
# COST*（y-y_） y>=y_ 预测的y多了，损失成本（COST）
#loss = tf.reduce_sum(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y)))
# y>y_ ? 真 假
#如：预测酸奶销量，酸奶成本（COST）1元，酸奶利润（PROFIT）9元。
#预测少了损失利润9元，大于预测多了损失成本1元
#预测少了损失大，希望生成的预测函数往多了预测。
#自定义
#酸奶成本1元，酸奶利润9元
#预测少了损失大，故不要预测少，故生成的模型会多预测一些
#预测多或预测少的影响一样
#导入模块，生成数据集
import numpy as np
import tensorflow as tf
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]
#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)
#2定义损失函数及反向传播方法。
#定义损失函数使的预测少了的损失大，于是模型应该偏向多的方向预测
#loss = tf.reduce_mean(tf.square(y_ - y))
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)
#train_step = tf.train.MomentumOptimizer(0.001,0.9).minimize(loss)
#train_step = tf.train.AdadeltaOptimizer(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 = 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]})
if i%500 == 0:
#total_loss = sess.run(loss, feed_dict={x: X, y_: Y})
print("After %d trainig steps:" % (i))
print("\n",sess.run(w1))
print("final w1 is:\n",sess.run(w1))
#在本代码中#2中尝试其他反向传播方法，看对收敛速度的影响，After 0 trainig steps:
('\n', array([[-0.762993 ],
[ 1.5095658]], dtype=float32))
After 500 trainig steps:
('\n', array([[1.0235443],
[1.0463386]], dtype=float32))
After 1000 trainig steps:
('\n', array([[1.0174844],
[1.0406483]], dtype=float32))
After 1500 trainig steps:
('\n', array([[1.0211805],
[1.0472497]], dtype=float32))
After 2000 trainig steps:
('\n', array([[1.0179386],
[1.0412899]], dtype=float32))
After 2500 trainig steps:
('\n', array([[1.0205938],
[1.0390677]], dtype=float32))
After 3000 trainig steps:
('\n', array([[1.0242898],
[1.0456691]], dtype=float32))
After 3500 trainig steps:
('\n', array([[1.01823 ],
[1.0399789]], dtype=float32))
After 4000 trainig steps:
('\n', array([[1.021926 ],
[1.0465802]], dtype=float32))
After 4500 trainig steps:
('\n', array([[1.0245812],
[1.044358 ]], dtype=float32))
After 5000 trainig steps:
('\n', array([[1.0185213],
[1.0386678]], dtype=float32))
After 5500 trainig steps:
('\n', array([[1.0245652],
[1.0446368]], dtype=float32))
After 6000 trainig steps:
('\n', array([[1.0185053],
[1.0389466]], dtype=float32))
After 6500 trainig steps:
('\n', array([[1.0222014],
[1.045548 ]], dtype=float32))
After 7000 trainig steps:
('\n', array([[1.0161415],
[1.0398577]], dtype=float32))
After 7500 trainig steps:
('\n', array([[1.0198376],
[1.0464591]], dtype=float32))
After 8000 trainig steps:
('\n', array([[1.0224928],
[1.0442369]], dtype=float32))
After 8500 trainig steps:
('\n', array([[1.0174738],
[1.0473702]], dtype=float32))
After 9000 trainig steps:
('\n', array([[1.0222716],
[1.0383747]], dtype=float32))
After 9500 trainig steps:
('\n', array([[1.0172527],
[1.041508 ]], dtype=float32))
After 10000 trainig steps:
('\n', array([[1.0199078],
[1.0392858]], dtype=float32))
After 10500 trainig steps:
('\n', array([[1.0236039],
[1.0458871]], dtype=float32))
After 11000 trainig steps:
('\n', array([[1.017544 ],
[1.0401969]], dtype=float32))
After 11500 trainig steps:
('\n', array([[1.0212401],
[1.0467982]], dtype=float32))
After 12000 trainig steps:
('\n', array([[1.0238953],
[1.044576 ]], dtype=float32))
After 12500 trainig steps:
('\n', array([[1.0178354],
[1.0388858]], dtype=float32))
After 13000 trainig steps:
('\n', array([[1.0215315],
[1.0454872]], dtype=float32))
After 13500 trainig steps:
('\n', array([[1.0154716],
[1.039797 ]], dtype=float32))
After 14000 trainig steps:
('\n', array([[1.0191677],
[1.0463983]], dtype=float32))
After 14500 trainig steps:
('\n', array([[1.0162914],
[1.0427582]], dtype=float32))
After 15000 trainig steps:
('\n', array([[1.0189465],
[1.040536 ]], dtype=float32))
After 15500 trainig steps:
('\n', array([[1.0216017],
[1.0383139]], dtype=float32))
After 16000 trainig steps:
('\n', array([[1.0252978],
[1.0449152]], dtype=float32))
After 16500 trainig steps:
('\n', array([[1.0192379],
[1.039225 ]], dtype=float32))
After 17000 trainig steps:
('\n', array([[1.022934 ],
[1.0458263]], dtype=float32))
After 17500 trainig steps:
('\n', array([[1.0168741],
[1.0401361]], dtype=float32))
After 18000 trainig steps:
('\n', array([[1.0205702],
[1.0467374]], dtype=float32))
After 18500 trainig steps:
('\n', array([[1.0232253],
[1.0445153]], dtype=float32))
After 19000 trainig steps:
('\n', array([[1.0171654],
[1.038825 ]], dtype=float32))
After 19500 trainig steps:
('\n', array([[1.0208615],
[1.0454264]], dtype=float32))
('final w1 is:\n', array([[1.020171 ],
[1.0425103]], dtype=float32))
#交叉熵ce（Cross Entropy）:表征两个概率分布之间的距离
#H(y_,y) = - y_*logy求和
#eg：二分类 已知答案y_=(1,0) 预测y1=(0.6,0.4) y2=(0.8,0.2) 那个更接近标准答案？
#H1((1,0),(0.6,0.4))=-(1*log0.6 + 0* log0.4) = -(0.22 + 0) =0.222
#H2((1,0),(0.8,0.2))=-(1*log0.8 + 0* log0.2) = -(-0.097+0) = 0.097
#所有y2预测更准
#ce = -tf.reduce_mean(y_*tg.log(t.clip_by_value(y,1e-12,1.0)))
# y小于1e-12为1e-12 大于1.0为1.0
#当n分类的n个输出(y1,y2,... yn)通过softmax()函数，便满足了概率分布要求：
#ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
#cem = tf.reduce_mean(ce)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
