用二个缺损的神经互连网练习一遍.

在机器学习中只怕会设有过拟合的难题,表现为在练习集上展现很好,但在测验聚焦表现不比演练聚集的那么好。

图片 1

图中深灰蓝曲线是例行模型,水草绿曲线正是overfitting模型。尽管赤褐曲线很确切的区分了独具的练习多少,可是并未描述数据的全体特点,对新测量检验数据的适应性相当糟糕。

相仿用于解决过拟合的办法有增加权重的惩处机制,举个例子L2正规化,但在本处我们使用tensorflow提供的dropout方法,在教练的时候,
大家随意忽视掉后生可畏都部队分神经元和神经联结 , 使这一个神经网络变得”不完全”.
用几个残缺的神经互连网练习一回.
到第3回再轻松忽视另豆蔻年华对, 变成另二个残缺的神经网络. 有了那个随机 drop
掉的法规, 我们得以想象其实每便演习的时候,
我们都让每一次预测结果都不会借助于当中某有个别特定的神经元. 像l1,
l2正经相像, 过度信任的 W , 也正是教练参数的数值会超级大, l1,
l2会处以这么些大的 参数. Dropout 的做法是从根本上让神经网络没机缘过度重视.

这次大家运用以前sklearn中手写数字作为例子来进行。

加载数据

from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer

digits = load_digits()
X = digits.data
y = digits.target

# 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
y = LabelBinarizer().fit_transform(y)
# 拆分数据集,以总量的30%作为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

添加层

增加层函数如下:

import tensorflow as tf
def add_layer(inputs, in_size, out_size, activation_function=None):
    """
    添加层
    :param inputs: 输入数据
    :param in_size: 输入数据的列数
    :param out_size: 输出数据的列数
    :param activation_function: 激励函数
    :return:
    """

    # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    # 偏置shape为1行out_size列
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    # 建立神经网络线性公式:inputs * Weights + biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
        outputs = Wx_plus_b
    else:
        # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
        outputs = activation_function(Wx_plus_b)
    return outputs

定义placehoder和创立实际的网络布局

# 定义placeholder
# 输入的手写数字大小为8*8单位的数据
xs = tf.placeholder(tf.float32, [None, 8*8])
# 输出值为one hot结构的数据
ys = tf.placeholder(tf.float32, [None, 10])

# 添加层
# 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
# 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)

概念损失函数

# 定义损失函数
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
# 在tensorboard中记录损失函数值
tf.summary.scalar('loss', cross_entropy)
# 用梯度下降优化器进行训练
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

笔录损失函数并运维

sess = tf.Session()
merged = tf.summary.merge_all()
# 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)

init = tf.global_variables_initializer()
sess.run(init)

for i in range(500):
    sess.run(train_step, feed_dict={xs:X_train, ys:y_train})
    if i % 50 == 0:
        # 分别用训练集和测试集数据获得损失函数值
        train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train})
        train_writer.add_summary(train_result, i)

        test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test})
        test_writer.add_summary(test_result, i)

全部代码

from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split

digits = load_digits()
X = digits.data
y = digits.target

# 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
y = LabelBinarizer().fit_transform(y)
# 拆分数据集,以总量的30%作为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

import tensorflow as tf
def add_layer(inputs, in_size, out_size, activation_function=None):
    """
    添加层
    :param inputs: 输入数据
    :param in_size: 输入数据的列数
    :param out_size: 输出数据的列数
    :param activation_function: 激励函数
    :return:
    """

    # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    # 偏置shape为1行out_size列
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    # 建立神经网络线性公式:inputs * Weights + biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
        outputs = Wx_plus_b
    else:
        # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
        outputs = activation_function(Wx_plus_b)
    return outputs

# 定义placeholder
# 输入的手写数字大小为8*8单位的数据
xs = tf.placeholder(tf.float32, [None, 8*8])
# 输出值为one hot结构的数据
ys = tf.placeholder(tf.float32, [None, 10])

# 添加层
# 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
# 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)

# 定义损失函数
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
# 在tensorboard中记录损失函数值
tf.summary.scalar('loss', cross_entropy)
# 用梯度下降优化器进行训练
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

sess = tf.Session()
merged = tf.summary.merge_all()
# 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)

init = tf.global_variables_initializer()
sess.run(init)

for i in range(500):
    sess.run(train_step, feed_dict={xs:X_train, ys:y_train})
    if i % 50 == 0:
        # 分别用训练集和测试集数据获得损失函数值
        train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train})
        train_writer.add_summary(train_result, i)

        test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test})
        test_writer.add_summary(test_result, i)

出口结果

当大家运维了上边的代码后,会在D:/todel/data/tensorflow/目录下生成tensorboard采摘的日记文件,大家得以在充裕目录下输入:
图片 2

末尾在tensorboard中彰显的图样为:
图片 3

我们开掘,训练集(青蓝的那条曲线卡塔 尔(阿拉伯语:قطر‎损失值要比测验集(深灰蓝的那条曲线卡塔尔国小,那样就存在过拟合的图景。

淹没过拟合

为了消灭过拟合,大家利用dropout方式来张开。
先是设置多个保留可能率的placeholder,那样在运维时能够通过参数来展开设置

# 设置保留概率,即我们要保留的结果所占比例,它作为一个placeholder,在run时传入, 当keep_prob=1的时候,相当于100%保留,也就是dropout没有起作用。
keep_prob = tf.placeholder(tf.float32)

然后在add_layer函数中调用dropout成效:

    # 调用dropout功能
    Wx_plus_b = tf.nn.dropout(Wx_plus_b, keep_prob)

末尾在锻炼时设置保留的概率,但在拿到损失值时用全数的数码来举办获取:

for i in range(500):
    sess.run(train_step, feed_dict={xs:X_train, ys:y_train, keep_prob: 0.7})
    if i % 50 == 0:
        # 分别用训练集和测试集数据获得损失函数值
        train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train, keep_prob:1})
        train_writer.add_summary(train_result, i)

        test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test, keep_prob:1})
        test_writer.add_summary(test_result, i)

像这种类型任何代码为:

from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split

digits = load_digits()
X = digits.data
y = digits.target

# 把数值转换成one hot格式,例如:数字4就会被转换成:[0 0 0 0 1 0 0 0 0 0]
y = LabelBinarizer().fit_transform(y)
# 拆分数据集,以总量的30%作为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

import tensorflow as tf
def add_layer(inputs, in_size, out_size, activation_function=None):
    """
    添加层
    :param inputs: 输入数据
    :param in_size: 输入数据的列数
    :param out_size: 输出数据的列数
    :param activation_function: 激励函数
    :return:
    """

    # 定义权重,初始时使用随机变量,可以简单理解为在进行梯度下降时的随机初始点,这个随机初始点要比0值好,因为如果是0值的话,反复计算就一直是固定在0中,导致可能下降不到其它位置去。
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    # 偏置shape为1行out_size列
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    # 建立神经网络线性公式:inputs * Weights + biases,我们大脑中的神经元的传递基本上也是类似这样的线性公式,这里的权重就是每个神经元传递某信号的强弱系数,偏置值是指这个神经元的原先所拥有的电位高低值
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    # 调用dropout功能
    Wx_plus_b = tf.nn.dropout(Wx_plus_b, keep_prob)

    if activation_function is None:
        # 如果没有设置激活函数,则直接就把当前信号原封不动地传递出去
        outputs = Wx_plus_b
    else:
        # 如果设置了激活函数,则会由此激活函数来对信号进行传递或抑制
        outputs = activation_function(Wx_plus_b)
    return outputs

# 定义placeholder
# 输入的手写数字大小为8*8单位的数据
xs = tf.placeholder(tf.float32, [None, 8*8])
# 输出值为one hot结构的数据
ys = tf.placeholder(tf.float32, [None, 10])
# 设置保留概率,即我们要保留的结果所占比例,它作为一个placeholder,在run时传入, 当keep_prob=1的时候,相当于100%保留,也就是dropout没有起作用。
keep_prob = tf.placeholder(tf.float32)

# 添加层
# 第一层输入为8*8单位的手写输入数字图像,输出设定为100个神经元的层(为了能够看出是overfitting的问题),激活函数一般用tanh比较好
l1 = add_layer(xs, 8*8, 100, activation_function=tf.nn.tanh)
# 输出层因为最终是一个one hot的结构,因此输出的大小为10,激活函数用softmax
prediction = add_layer(l1, 100, 10, activation_function=tf.nn.softmax)

# 定义损失函数
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), axis=1))
# 在tensorboard中记录损失函数值
tf.summary.scalar('loss', cross_entropy)
# 用梯度下降优化器进行训练
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

sess = tf.Session()
merged = tf.summary.merge_all()
# 分别记录训练集的loss和测试集的loss值,目的是为了能够对比训练集和测试集中得拟合情况
train_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/train", sess.graph)
test_writer = tf.summary.FileWriter("D:/todel/data/tensorflow/test", sess.graph)

init = tf.global_variables_initializer()
sess.run(init)

for i in range(500):
    sess.run(train_step, feed_dict={xs:X_train, ys:y_train, keep_prob: 0.7})
    if i % 50 == 0:
        # 分别用训练集和测试集数据获得损失函数值
        train_result = sess.run(merged, feed_dict={xs:X_train, ys: y_train, keep_prob:1})
        train_writer.add_summary(train_result, i)

        test_result = sess.run(merged, feed_dict={xs:X_test, ys: y_test, keep_prob:1})
        test_writer.add_summary(test_result, i)

运转后输出tensorboard图形为(记得把在此之前的文本或目录举办删减并运维tensorboard举办展示图形):
图片 4

那样演练集和测量试验集的损失值就比较临近了。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website