代价函数+拟合+优化器

最新推荐文章于 2024-02-19 15:06:42 发布

lihuaqinqwe

最新推荐文章于 2024-02-19 15:06:42 发布

阅读量603

点赞数 2

分类专栏： Tensorflow学习

Tensorflow学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一.代价函数

1.二次代价函数

（1）定义：

其中，C表示代价函数，x表示样本，y表示实际值，a表示输出值，n表示样本的总数。为简单起见，同样一个样本为例进行说明，此时二次代价函数为：

a=σ(z), z=∑Wj*Xj+b

σ() 是激活函数

（2）假如我们使用梯度下降法(Gradient descent)来调整权值参数的大小，权值w和偏置b的梯度推导如下：

其中，z表示神经元的输入，σ表示激活函数。w和b的梯度跟激活函数的梯度成正比，激活函数的梯度越大，w和b的大小调整得越快，训练收敛得就越快。

（3）假设我们的激活函数是sigmoid函数：

2.交叉熵代价函数（cross-entropy）:

(1)换一个思路，我们不改变激活函数，而是改变代价函数，改用交叉熵代价函数：

其中，C表示代价函数，x表示样本，y表示实际值，a表示输出值，n表示样本的总数。

a=σ(z), z=∑Wj*Xj+b

权值和偏置值的调整与无关,另外，梯度公式中的表示输出值与实际值的误差。所以当误差越大时，梯度就越大，参数w和b的调整就越快，训练的速度也就越快。

如果输出神经元是线性的，那么二次代价函数就是一种合适的选择。如果输出神经元是S型函数，
那么比较适合用交叉熵代价函数。

3.对数释然代价函数（log-likelihood cost）:

对数释然函数常用来作为softmax回归的代价函数，如果输出层神经元是sigmoid函数，可以采用交叉熵代价函数。而深度学习中更普遍的做法是将softmax作为最后一层，此时常用的代价函数是对数释然代价函数。

对数似然代价函数与softmax的组合和交叉熵与sigmoid函数的组合非常相似。对数释然代价函数在二分类时可以化简为交叉熵代价函数的形式。

在Tensorflow中用：
tf.nn.sigmoid_cross_entropy_with_logits()来表示跟sigmoid搭配使用的交叉熵。

tf.nn.softmax_cross_entropy_with_logits()来表示跟softmax搭配使用的交叉熵。

二.拟合

1.拟合（回归）

2.拟合（分类）

3.防止过拟合

（1）增加数据集

（2）正则化方法

（3）dropout

隐藏部分神经元，只让部分神经元进行工作。

4.代码

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 载入数据
mnist = input_data.read_data_sets('F:\Pycharm projection\MNIST_data', one_hot=True)
# 每个批次的大小
batch_size = 100
# 计算一共有多少批次
n_batch = mnist.train.num_examples // batch_size
# print(n_batch)

# 定义3个placehoder
x = tf.placeholder(tf.float32, [None, 784])    # 行与批次有关，一会儿计算之后传入，列是一张是28*28像素
y = tf.placeholder(tf.float32, [None, 10])     # y 是标签0-9包括10类
keep_prob = tf.placeholder(tf.float32)

# 创建一个简单的神经网络
"""
只用到输入层和输出层，不加隐藏层
输入层：784个神经元
输出层：10个标签，就10个神经元
增加中间层
"""
# w1 = tf.Variable(tf.zeros([784,10]))   # 权值
# b1 = tf.Variable(tf.zeros([10]))     # 偏置值
# 使用截断的正太分布（tf.truncated_normal）来进行初始化，标准差（stddev）是0.1
w1 = tf.Variable(tf.truncated_normal([784,2000],stddev= 0.1))
b1 = tf.Variable(tf.zeros([2000])+0.1)
L1 = tf.nn.tanh(tf.matmul(x,w1)+b1)      # 中间层，使用双曲正切函数
L1_drop = tf.nn.dropout(L1,keep_prob)    # L1某一个层神经元的输出，keep_prob设置百分之多少的神经元是工作的。
# 增加隐藏层
w2 = tf.Variable(tf.truncated_normal([2000,2000],stddev= 0.1))
b2 = tf.Variable(tf.zeros([2000])+0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,w2)+b2)      # 中间层，使用双曲正切函数
L2_drop = tf.nn.dropout(L2,keep_prob)    # L1某一个层神经元的输出，keep_prob设置百分之多少的神经元是工作的。

w3 = tf.Variable(tf.truncated_normal([2000,1000],stddev= 0.1))
b3 = tf.Variable(tf.zeros([1000])+0.1)
L3 = tf.nn.tanh(tf.matmul(L2_drop,w3)+b3)      # 中间层，使用双曲正切函数
L3_drop = tf.nn.dropout(L3,keep_prob)    # L1某一个层神经元的输出，keep_prob设置百分之多少的神经元是工作的。

w4 = tf.Variable(tf.truncated_normal([1000,10],stddev= 0.1))
b4 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L3_drop, w4)+b4)   # 预测值，使用sofrmax函数

# 二次代价函数
# loss = tf.reduce_mean(tf.square(y-prediction))
# 对数释然代价函数(交叉熵)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# 定义一个梯度下降发来训练优化器
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 给出学习率0.2

# 初始化变量
init =tf.global_variables_initializer()

"""
模型训练好之后，要测试下，模型的准确率
定义求准确率的方法
"""
# 结果存在一个布尔型列表中
# argmax返回一维张量中最大值所在的位置
correct_prediction = tf.equal(tf.argmax(y, 1),tf.argmax(prediction, 1))
# 求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # cast作用把布尔型转成32位的float

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(11):
        for batch in range(n_batch):
            # 获得一个批次（100张图片），它的大小100；图片数据保存在 ：batch_xs,标签保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:1.0})   # keep_prob=1.0 表示所有的神经元都工作
        # 训练一个周期之后测试一下准确率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images, y:mnist.train.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Train accuracy"+str(train_acc))

keep_prob=1.0 代码所有神经元都工作运行结果：

Iter0 Testing accuracy0.8628 Train accuracy0.8719818
Iter1 Testing accuracy0.9579 Train accuracy0.97296363
Iter2 Testing accuracy0.9622 Train accuracy0.9818909
Iter3 Testing accuracy0.9664 Train accuracy0.98636365
Iter4 Testing accuracy0.9679 Train accuracy0.9886182
Iter5 Testing accuracy0.9694 Train accuracy0.9900182
Iter6 Testing accuracy0.9703 Train accuracy0.9910909
Iter7 Testing accuracy0.9712 Train accuracy0.99183637
Iter8 Testing accuracy0.9709 Train accuracy0.99243635
Iter9 Testing accuracy0.972 Train accuracy0.9928909

Iter10 Testing accuracy0.9706 Train accuracy0.9932727

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(11):
        for batch in range(n_batch):
            # 获得一个批次（100张图片），它的大小100；图片数据保存在 ：batch_xs,标签保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:0.7})   # keep_prob=1.0 表示所有的神经元都工作
        # 训练一个周期之后测试一下准确率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        train_acc = sess.run(accuracy,feed_dict={x:mnist.train.images, y:mnist.train.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Train accuracy"+str(train_acc))

keep_prob=0.7,有70%的神经元工作，运行结果：

Iter0 Testing accuracy0.9158 Train accuracy0.9109455
Iter1 Testing accuracy0.9295 Train accuracy0.92716366
Iter2 Testing accuracy0.9344 Train accuracy0.9339455
Iter3 Testing accuracy0.9408 Train accuracy0.94078183
Iter4 Testing accuracy0.9434 Train accuracy0.9437818
Iter5 Testing accuracy0.9472 Train accuracy0.9490727
Iter6 Testing accuracy0.9507 Train accuracy0.9518545
Iter7 Testing accuracy0.9528 Train accuracy0.95467275
Iter8 Testing accuracy0.9526 Train accuracy0.95476365
Iter9 Testing accuracy0.9552 Train accuracy0.95885456

Iter10 Testing accuracy0.9576 Train accuracy0.9608

5.可以选择不同的优化器

# # 定义一个梯度下降发来训练优化器
# train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 给出学习率0.2

train_step = tf.train.AdamOptimizer(1e-2).minimize(loss)  # 1e-2代表10的负2次方

Iter0 Testing accuracy0.098 Train accuracy0.09898182
Iter1 Testing accuracy0.098 Train accuracy0.09898182
Iter2 Testing accuracy0.098 Train accuracy0.09898182
Iter3 Testing accuracy0.098 Train accuracy0.09898182
Iter4 Testing accuracy0.098 Train accuracy0.09898182
Iter5 Testing accuracy0.098 Train accuracy0.09898182
Iter6 Testing accuracy0.098 Train accuracy0.09898182
Iter7 Testing accuracy0.098 Train accuracy0.09898182
Iter8 Testing accuracy0.098 Train accuracy0.09898182
Iter9 Testing accuracy0.098 Train accuracy0.09898182

Iter10 Testing accuracy0.098 Train accuracy0.09898182

6.学习效率：随迭代次数学习效率减小

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 载入数据
mnist = input_data.read_data_sets('F:\Pycharm projection\MNIST_data', one_hot=True)
# 每个批次的大小
batch_size = 100
# 计算一共有多少批次
n_batch = mnist.train.num_examples // batch_size
# print(n_batch)

# 定义3个placehoder
x = tf.placeholder(tf.float32, [None, 784])    # 行与批次有关，一会儿计算之后传入，列是一张是28*28像素
y = tf.placeholder(tf.float32, [None, 10])     # y 是标签0-9包括10类
keep_prob = tf.placeholder(tf.float32)
lr = tf.Variable(0.001,dtype=tf.float32)  # 初始学习效率0.001，后面的可以改变
# 创建一个简单的神经网络
"""
只用到输入层和输出层，不加隐藏层
输入层：784个神经元
输出层：10个标签，就10个神经元
增加中间层
"""
# w1 = tf.Variable(tf.zeros([784,10]))   # 权值
# b1 = tf.Variable(tf.zeros([10]))     # 偏置值
# 使用截断的正太分布（tf.truncated_normal）来进行初始化，标准差（stddev）是0.1
w1 = tf.Variable(tf.truncated_normal([784,500],stddev= 0.1))
b1 = tf.Variable(tf.zeros([500])+0.1)
L1 = tf.nn.tanh(tf.matmul(x,w1)+b1)      # 中间层，使用双曲正切函数
L1_drop = tf.nn.dropout(L1,keep_prob)    # L1某一个层神经元的输出，keep_prob设置百分之多少的神经元是工作的。
# 增加隐藏层
w2 = tf.Variable(tf.truncated_normal([500,300],stddev= 0.1))
b2 = tf.Variable(tf.zeros([300])+0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,w2)+b2)      # 中间层，使用双曲正切函数
L2_drop = tf.nn.dropout(L2,keep_prob)    # L1某一个层神经元的输出，keep_prob设置百分之多少的神经元是工作的。

w3 = tf.Variable(tf.truncated_normal([300,10],stddev= 0.1))
b3 = tf.Variable(tf.zeros([10])+0.1)
prediction = tf.nn.softmax(tf.matmul(L2_drop, w3)+b3)   # 预测值，使用sofrmax函数

# 二次代价函数
# loss = tf.reduce_mean(tf.square(y-prediction))
# 对数释然代价函数(交叉熵)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
# # 定义一个梯度下降发来训练优化器
# train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)   # 给出学习率0.2

train_step = tf.train.AdamOptimizer(lr).minimize(loss)  # 1e-2代表10的负2次方

# 初始化变量
init =tf.global_variables_initializer()

"""
模型训练好之后，要测试下，模型的准确率
定义求准确率的方法
"""
# 结果存在一个布尔型列表中
# argmax返回一维张量中最大值所在的位置
correct_prediction = tf.equal(tf.argmax(y, 1),tf.argmax(prediction, 1))
# 求准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # cast作用把布尔型转成32位的float

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(51):
        sess.run(tf.assign(lr,0.001*(0.95**epoch)))   # 0.95**epoch 代表迭代几次就0.95的几次方 *0.001  赋给lr
        for batch in range(n_batch):
            # 获得一个批次（100张图片），它的大小100；图片数据保存在 ：batch_xs,标签保存在：batch_ys
            batch_xs,batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_xs, y:batch_ys,keep_prob:1.0})   # keep_prob=1.0 表示所有的神经元都工作
        learning_rate = sess.run(lr)
        # 训练一个周期之后测试一下准确率
        test_acc = sess.run(accuracy,feed_dict={x:mnist.test.images, y:mnist.test.labels,keep_prob:1.0})
        print("Iter"+str(epoch),"Testing accuracy"+str(test_acc),"Learning Rate"+str(learning_rate))

Iter0 Testing accuracy0.9543 Learning Rate0.001
Iter1 Testing accuracy0.96 Learning Rate0.00095
Iter2 Testing accuracy0.9672 Learning Rate0.0009025
Iter3 Testing accuracy0.9711 Learning Rate0.000857375
Iter4 Testing accuracy0.9723 Learning Rate0.00081450626
Iter5 Testing accuracy0.9746 Learning Rate0.0007737809
Iter6 Testing accuracy0.9743 Learning Rate0.0007350919
Iter7 Testing accuracy0.9776 Learning Rate0.0006983373
Iter8 Testing accuracy0.9777 Learning Rate0.0006634204
Iter9 Testing accuracy0.9783 Learning Rate0.0006302494
Iter10 Testing accuracy0.978 Learning Rate0.0005987369
Iter11 Testing accuracy0.9785 Learning Rate0.0005688001
Iter12 Testing accuracy0.9783 Learning Rate0.0005403601
Iter13 Testing accuracy0.9809 Learning Rate0.0005133421
Iter14 Testing accuracy0.9811 Learning Rate0.000487675
Iter15 Testing accuracy0.9781 Learning Rate0.00046329122

三.优化器（Optimizer）:
tf.train.GradientDescentOptimizer

tf.train.AdadeltaOptimizer

tf.train.AdagradOptimizer

tf.train.AdagradDAOptimizer

tf.train.MomentumOptimizer

tf.train.AdamOptimizer

tf.train.FtrlOptimizer

tf.train.ProximalGradientDescentOptimizer

tf.train.ProximalAdagradOptimizer

tf.train.RMSPropOptimizer

lihuaqinqwe

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
代价函数+拟合+优化器

一.代价函数1.二次代价函数（1）定义：其中，C表示代价函数，x表示样本，y表示实际值，a表示输出值，n表示样本的总数。为简单起见，同样一个样本为例进行说明，此时二次代价函数为：a=σ(z), z=∑Wj*Xj+b σ() 是激活函数（2）假如我们使用梯度下降法(Gradient descent)来调整权值参数的大小，权值w和偏置b的梯度推导如下：其中...
复制链接

扫一扫