精华内容
下载资源
问答
  • 2018-12-18 10:01:29
    from keras.datasets import boston_housing
    from keras import models
    from keras import layers
    
    (X_train, y_train), (X_test, y_test) = boston_housing.load_data()#加载数据
    
    #对数据进行标准化预处理,方便神经网络更好的学习
    mean = X_train.mean(axis=0)
    X_train -= mean
    std = X_train.std(axis=0)
    X_train /= std
    X_test -= mean
    X_test /= std
    
    #构建神经网络模型
    def build_model():
        #这里使用Sequential模型
        model = models.Sequential()
        #进行层的搭建,注意第二层往后没有输入形状(input_shape),它可以自动推导出输入的形状等于上一层输出的形状
        model.add(layers.Dense(64, activation='relu',input_shape=(X_train.shape[1],)))
        model.add(layers.Dense(64, activation='relu'))
        model.add(layers.Dense(1))
        #编译网络
        model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
        return model
    
    num_epochs = 100
    model = build_model()
    model.fit(X_train, y_train,epochs=num_epochs, batch_size=1, verbose=0)
    predicts = model.predict(X_test)

        在实际操作中可以用自己的数据进行测试,最终预测出的predicts,可以利用回归评价指标和y_test进行模型效果的评价。

    更多相关内容
  • 主要介绍了利用keras使用神经网络预测销量操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 利用Keras构建神经网络在空气质量预测中的应用.pdf
  • 利用基于tensorflow2的keras框架,搭建CNN卷积神经网络模型,对手写数字识别数据集mnist进行分类,网络规模小,训练精度高。网络包括三个卷积层,两个池化层和全连接层,在测试集上实现了99%左右的识别率。
  • 利用tf.keras构建神经网络分类模型2.1 导入相应的库2.2 数据读取与展示2.3 数据归一化2.4 构建模型2.5 模型的编译与训练2.6 绘制训练曲线2.7 增加回调函数 1. tf.keras简介 keras是什么: 基于python的高级神经网络...
  • 上一篇博客的主要内容是利用tf.keras构建了一个由四层神经网络构成的分类模型,并进行了训练,本篇博客的内容是同样利用keras来构建一个回来解决回归问题(房价预测)的神经网络模型。 1. 导入相应的库 与第上一篇...
  • 神经网络是一个非常奇妙的结构,它的数学原理虽然相对简单,但是能做的事情却不少,数学家已经证明,具有2层(输入层除外)和非线性激活函数的神经网络,只要在这些层中有足够多的神经元,就可以近似任何函数。...

    神经网络有着一个非常奇妙的结构,它的数学原理虽然相对简单,但是能做的事情却不少,数学家已经证明,具有2层(输入层除外)和非线性激活函数的神经网络,只要在这些层中有足够多的神经元,就可以近似任何函数(严格的说法是,激活函数使用了非线性sigmoid函数的感知机).

    那么,如果只有两层就够了,为什么人们现在还在使用更深层次的网络呢? 仅仅因为虽然这两层网络“能够”学习任何东西,这并不意味着它们很容易优化。在实践中,如果网络的产能过剩,他们就有能力提供足够好的解决方案,即使网络本身没有尽可能地优化。

    本片文章就是针对这个规则的实践和验证,我们用两层网络,去近似模拟各种非线性函数,事不宜迟,我们开始。

    正弦函数

    首先生成正弦函数的样本数据

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    
    SAMPLES=1000
    np.random.seed(1337)
    x_values=np.random.uniform(low=0,high=2*math.pi,size=SAMPLES)
    np.random.shuffle(x_values)
    y_values=np.sin(x_values)
    y_values+=0.1*np.random.randn(*y_values.shape)
    
    TRAIN_SPLIT=int(0.6*SAMPLES)
    TEST_SPLIT=int(0.2*SAMPLES+TRAIN_SPLIT)
    
    x_train, x_test, x_validate=np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
    y_train, y_test, y_validate=np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
    
    assert(x_train.size+x_test.size+x_validate.size)==SAMPLES
    assert(y_train.size+y_test.size+y_validate.size)==SAMPLES
    
    plt.plot(x_train, y_train, 'r.', label="Train")
    plt.plot(x_test, y_test, 'g.', label="Test")
    plt.plot(x_validate, y_validate, 'b.', label="Validate")
    
    plt.legend()
    plt.show()
    

    运行结果,查看样本数据:

    定义模型结构

    from tensorflow import keras
    
    model = keras.Sequential()
    model.add(keras.layers.Dense(16,activation=tf.nn.relu, input_shape=(1,)))
    model.add(keras.layers.Dense(1))
    model.compile(optimizer='rmsprop',loss='mse',metrics=['mae'])
    model.summary()

    模型摘要信息:

    其中输入层有 16 个神经元,共 2 层连接,所以全部的连接数为 16x2=32,每一个神经元都有一个 bias,网络总共有 17 个 bias。输入的 16,以及输出的 1。所以总的参数为 32+17=49,它的俄网络模型是这个样子的:

    y=\begin{bmatrix} w'_0 & w'_1& \cdots & w'_{15} \end{bmatrix}\cdot Relu\bigg( \begin{bmatrix} w_0\\ w_1\\ \vdots \\ w_{15} \end{bmatrix}\cdot x +\begin{bmatrix} b_0\\ b_1\\ \vdots \\ b_{15} \end{bmatrix} \bigg )

    训练模型:

    history=model.fit(x_train,y_train,epochs=1000,batch_size=16,validation_data=(x_validate,y_validate))
    

    利用 keras 的 fit() 方法能够很好的训练。下面就一些参数做一下最基本的解释:

    x_train, y_train 表示最基本的训练数据。

    epochs 训练的周期,一般来说,周期越长,训练越精确,但是,一般来说,训练的时间到一定阶段,训练精度不会有很大差别。在这种清况下,一般要考虑去优化模型了。

    batch_size 用于往网络中一次送入多少数据,如果值为 1,我们每一次会更新 weight 和 bias,并且会估计网络预测的损失,为下一次的运行做更精确的估计。越小的值,会带来很大的计算量,占用更多的计算资源。如果我们把值定要 600,一次性可以计算出更多的数据,但是会降低模型的精度。所以最好的方式是把值设置为 16 或者是 32。这个值的选择,实际上精度与时间花费权衡的结果。

    我们分析一下训练过程的收敛情况:

    loss=history.history['loss']
    val_loss=history.history['val_loss']
    epochs=range(1,len(loss)+1)
    plt.plot(epochs,loss,'g.',label='traning loss')
    plt.plot(epochs,val_loss,'b.',label='validation loss')
    plt.xlabel('epochs')
    plt.ylabel('loss')
    plt.legend()
    plt.show()

    根据compile参数metrics,history包含不同的内容。比如,当某一次metrics=['accuracy']时,history字典类型,包含val_loss,val_acc,loss,acc四个key值。

    该图显示了每个时期的损失(或模型的预测与实际数据之间的差异)。有几种计算损失的方法,我们使用的方法是均方误差。对于训练和验证数据有明显的损失值。

    我们可以看到,损失的数量在前面迅速减少,然后趋于平稳。这意味着该模型正在改进并产生更准确的预测!

    我们的目标是在模型不再改善或训练损失小于验证损失 (Validation Loss) 时停止训练,这意味着该模型已经学会了很好地预测训练数据,也不需要新的数据来提高精度。

    我们最关心的,当然是训练的结果了,图形化表示:

    predictions = model.predict(x_train)
    plt.clf()
    plt.title('Traing data predicted vs actual values')
    plt.plot(x_test,y_test,'b.', label='Actual')
    plt.plot(x_train,predictions,'r.', label='Predicted')
    plt.legend()
    plt.show()

    二次函数:

    将sin函数换为二次函数

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    
    SAMPLES=1000
    np.random.seed(1337)
    x_values=np.random.uniform(low=0,high=2*math.pi,size=SAMPLES)
    np.random.shuffle(x_values)
    #y_values=np.sin(x_values)
    y_values=x_values*x_values
    y_values+=0.1*np.random.randn(*y_values.shape)
    
    TRAIN_SPLIT=int(0.6*SAMPLES)
    TEST_SPLIT=int(0.2*SAMPLES+TRAIN_SPLIT)
    
    x_train, x_test, x_validate=np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
    y_train, y_test, y_validate=np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
    
    assert(x_train.size+x_test.size+x_validate.size)==SAMPLES
    assert(y_train.size+y_test.size+y_validate.size)==SAMPLES
    
    plt.plot(x_train, y_train, 'r.', label="Train")
    plt.plot(x_test, y_test, 'g.', label="Test")
    plt.plot(x_validate, y_validate, 'b.', label="Validate")
    
    plt.legend()
    plt.show()
    

     训练效果要比正弦好很多,训练代码不变:

    验证推理:

    三次函数

    y=x^3+1

     代码段:

    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    
    SAMPLES=2000
    np.random.seed(1337)
    x_values=np.random.uniform(low=0,high=2*math.pi,size=SAMPLES)
    np.random.shuffle(x_values)
    #y_values=np.sin(x_values)
    y_values=x_values*x_values*x_values + 1
    y_values+=0.1*np.random.randn(*y_values.shape)
    
    TRAIN_SPLIT=int(0.6*SAMPLES)
    TEST_SPLIT=int(0.2*SAMPLES+TRAIN_SPLIT)
    
    x_train, x_test, x_validate=np.split(x_values, [TRAIN_SPLIT, TEST_SPLIT])
    y_train, y_test, y_validate=np.split(y_values, [TRAIN_SPLIT, TEST_SPLIT])
    
    assert(x_train.size+x_test.size+x_validate.size)==SAMPLES
    assert(y_train.size+y_test.size+y_validate.size)==SAMPLES
    
    plt.plot(x_train, y_train, 'r.', label="Train")
    plt.plot(x_test, y_test, 'g.', label="Test")
    plt.plot(x_validate, y_validate, 'b.', label="Validate")
    
    plt.legend()
    plt.show()
    

    用sigmoid激活函数替代relu

    我们把原来用的relu激活函数换乘sigmoid函数看会不会改善,仅仅修改修改一行即可实现

    from tensorflow import keras
     
    model = keras.Sequential()
    model.add(keras.layers.Dense(16,activation=tf.nn.sigmoid, input_shape=(1,)))
    model.add(keras.layers.Dense(1))
    model.compile(optimizer='rmsprop',loss='mse',metrics=['mae'])
    model.summary()
    model.fit(x_train,y_train,epochs=1000,batch_size=16,validation_data=(x_validate,y_validate))

    训练结果如下,如果只看训练结果,使用sigmoid训练出来的结果要好很多。

     看一下实际的推理波形:

    根据训练的数据推理得到输出图形可以看出,使用sigmoid后确实好很多。

    对三次函数的拟合,sigmoid也要明显优于relu激活函数。

    稍微复杂一些的函数拟合

    y_values=np.sin(x_values)**2

    训练:

     拟合效果:

    还是非常不错。

    总结:

    上面我们用搭建的简易神经网络拟合了三种非线性函数,分别是正弦函数,二次函数和三次函数,发现效果都还不错,测试数据很好的拟合了函数的形状。

    很有意思的一点是,对于不同的函数拟合过程,在程序中,我们只变换了函数的数值解析式,而并没有改变网络的结构,也就是说,我们用了同一个网络结构,仅仅重新训练改变训练参数,就可以拟合完全不一样的函数图形,相当于网络吃什么数据,给什么样模态的结果。这个特点给算法的应用部署带来了方便,因为我们不需要频繁更换网络结构。

    算法的上限是由网络结构定义的,下限则是数据训练决定的,这有点像我们人类,我们生来带一个不可编辑的大脑,必须承认每个人的天分是有差异的,就好比算法和网络本身是有优劣的,后天的充足数据训练(相当于我们上学读书的学习阶段),虽然无法突破天分的天花板,但可以最大限度的发挥我们在天分框架下的能力。但如果你不好好接受训练(少壮不努力),那么本来你可以做好的事情,可能也做不好了(老大徒伤悲).


    结束!

    展开全文
  • 利用Keras高级神经网络实现商品销量的预测.pdf
  • 模型由架构、矩阵权重和参数组长 Keras介绍 Keras文档 Keras于2015年首次发布,它被设计为一种接口,可用于使用神经网络进行快速实验。因此,他依赖于TensorFlow或者Theano来运行深度学习操作。Keras以其用户友好...

    TensorFlow介绍


    TensorFlow中文官网

    TensorFlow最初由Google开发,它最初定义为描述机器学习算法的接口,以及执行该算法的实现。

    TensorFlow的主要预期目标是简化机器学习解决方案在各种平台上的部署,如计算机CPU、计算机GPU、移动设备以及最近的浏览器中的部署。最重要的是,TensorFlow提供了许多有用的功能来创建机器学习模型并大规模运行他们。TensorFlow它专注于易用性,并能保持良好的性能。

    TensorFlow既可供初学者使用,也可供专家使用。TensorFlow API具有不同级别的复杂度,从而使初学者可以从简单的API开始,同时也可以让专家创建非常复杂的模型。

    TensorFlow主要架构


    TensorFlow架构具有多个抽象层级。我们首先介绍底层,然后逐渐通往最上层。

    大多数深度学习计算都是用C++编码的。为了再GPU上进行计算,TensorFlow使用了由NVIDIA开发的库CUDA。这就是想要利用GPU功能就需要安装CUDA,以及不能使用其他硬件制造商GPU的原因。


    然后,Python底层API封装了C++源代码。当调用TensorFlow的Python方法时,通常会在后台调用C++代码。这个封装层使用户可以更快的工作,因为Python被认为更易于使用并且不需要编译。该Python封装器可以创建非常基本的运算,例如矩阵乘法和加法。


    最上层是高级API,由Keras评估器API两个组件组成。KerasTensorFlow的一个用户、模块化且可扩展的封装器,评估器API包含多个预制组件,可以让你轻松的构建机器学习模型。你可以将他们视为模块化或者组件


    在深度学习中,模型通常是指经过数据训练的神经网络。模型由架构、矩阵权重和参数组长

    Keras介绍


    Keras文档

    Keras于2015年首次发布,它被设计为一种接口,可用于使用神经网络进行快速实验。因此,他依赖于TensorFlow或者Theano来运行深度学习操作。Keras以其用户友好著称,是初学者的首选库。TensorFlow完全集成了Keras,这意味着无需安装TensorFlow以外的任何库就可以使用它。我们将依赖tf.keras而不是Keras的独立版本。这两个版本之间有一些细微的差异,例如与TensorFlow的其他模块的兼容性以及模型的保存方式。因此,读者确保使用正确的版本,具体方法如下:

    • 在代码中,导入tf.keras而不是keras
    • 浏览TensorFlow网站上的tf.keras文档,而不是keras.io文档。
    • 在使用外部Keras库时,请确保他们与tf.keras兼容。
    • 某些保存的模型在Keras版本之间可不能兼容。

    这两个版本在可预见的未来将继续共存,而tf.kerasTensorFlow集成将越来越密切。为了说明Keras的强大功能和简单性,我们将使用该库实现一个简单的神经网络。

    展开全文
  • Keras深度学习实战(2)——使用Keras构建神经网络

    千次阅读 多人点赞 2021-09-02 21:14:30
    Keras 是用 Python 编写的高级神经网络 API,它的核心思想在于实现快速实验,该库提供了很多实用工具,可以简化构建复杂神经网络的过程。在本节中,我们将使用 Keras 库构建神经网络,感受 Keras 快速模型构建的特性...

    0 前言

    《神经网络基础》中,我们学习了如何从零开始构建了一个神经网络,更具体的说,我们编写了执行正向传播和反向向传播的函数。 在本节中,我们将使用 Keras 库构建神经网络,该库提供了很多实用工具,可以简化构建复杂神经网络的过程。

    1. Keras 简介与安装

    Keras 是用 Python 编写的高级神经网络 API,它的核心思想在于实现快速实验,它能够在 TensorFlowCNTKTheano 之上运行,因此为了使用 Keras 首先需要安装 TensorFlowCNTKTheano 库作为后端。本文使用 Tensorflow,因此需要首先使用如下命令安装 Tensorflow:

    $ pip install tensorflow-gpu
    

    最好安装与 GPU 兼容的版本,因为当神经网络在 GPU 上训练时,它们的运行速度会大大提高。更加详细的安装教程可以参考《tensorflow-gpu安装》
    完成 tensorflow 的安装后,可以按以下方式安装 keras

    $ pip install keras
    

    2. Keras 构建神经网络初体验

    在本部分中,学习如何使用 Keras 创建神经网络模型,我们使用与《神经网络基础》中相同的简单数据集,将模型定义如下:

    • 输入连接到具有三个节点的隐藏层
    • 隐藏层连接到输出,输出层有一个节点
    1. 定义数据集,导入相关库:
    import keras
    import numpy as np
    x = np.array([[1], [2], [3], [7]])
    y = np.array([[3], [6], [9], [21]])
    
    1. 实例化一个可以顺序计算的神经网络模型,可以在其中堆叠添加多个网络层,计算过程按网络层的堆叠顺序进行。Sequential 方法能够构建顺序计算模型:
    model = keras.models.Sequential()
    
    1. 向模型添加一个 Dense 层(全连接层)。Dense 层用于模型中各个层之间的全连接(上一层的每个节点与本层的每个节点间都有连接),Dense 层的工作方式与我们在《神经网络基础》中相同使用的隐藏层完全相同。在以下代码中,我们将输入层连接到隐藏层:
    model.add(Dense(3, activation='relu', input_shape=(1,)))
    

    在使用前面的代码初始化的 Dense 层中,需要确保为模型提供输入形状(由于这是第一个全连接层,因此需要指定模型期望的接受的数据形状)。隐藏层中有三个节点,并且在隐藏层中使用的激活函数是 ReLU 函数。

    1. 将隐藏层连接到输出层:
    model.add(keras.layers.Dense(1, activation='linear'))
    

    在此 Dense 层中,我们无需指定输入形状,因为模型可以从上一层推断出输入形状。输出层具有一个节点,并使用线性激活函数。

    可以将模型概要信息 (model summary) 可视化输出:

    model.summary()
    

    可以看到模型概要信息如下所示:

    Model: "sequential"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    dense (Dense)                (None, 3)                 6         
    _________________________________________________________________
    dense_1 (Dense)              (None, 1)                 4         
    =================================================================
    Total params: 10
    Trainable params: 10
    Non-trainable params: 0
    _________________________________________________________________
    

    从模型概要信息可以看到,从输入层到隐藏层的连接中总共有六个参数(三个权重和三个偏置项),另外,使用三个权重和一个偏置项将隐藏层连接到输出层。

    1. 编译模型。首先,需要定义损失函数和优化器,以及优化器相对应的学习率:
    from keras.optimizers import SGD
    sgd = SGD(lr=0.01)
    

    上述代码指定优化器是随机梯度下降,学习率为 0.01。将预定义的优化器及其相应的学习率、损失函数作为参数传递给 compile 方法编译模型:

    model.compile(optimizer=sgd,loss='mean_squared_error')
    
    1. 拟合模型。更新权重,以优化模型:
    model.fit(x, y, epochs=1, batch_size = 4, verbose=1)
    

    fit 方法需要接收一个输入 x 和相应的实际值 yepochs 代表训练数据集的次数,batch_size 代表每次更新权重的迭代中训练的数据量大小,verbose 指定训练过程中的输出信息,可以包含有关训练和测试数据集上损失值以及模型训练的进度等信息。

    1. 提取权重值。权重值的相关信息是通过调用模型的 weights 属性获得的:
    model.weights
    

    获得的权重相关信息如下:

    [<tf.Variable 'dense/kernel:0' shape=(1, 3) dtype=float32, numpy=array([[1.1533519 , 1.2411805 , 0.39152434]], dtype=float32)>,
    <tf.Variable 'dense/bias:0' shape=(3,) dtype=float32, numpy=array([ 0.03425962, -0.05432956, -0.1607531 ], dtype=float32)>, 
    <tf.Variable 'dense_1/kernel:0' shape=(3, 1) dtype=float32, numpy=array([[1.2210085 ], [1.2086679 ],[0.21541257]], dtype=float32)>, 
    <tf.Variable 'dense_1/bias:0' shape=(1,) dtype=float32, numpy=array([0.09131978], dtype=float32)>]
    

    从前面的输出中,可以看到首先打印的权重属于 dense_1 层中的三个权重和三个偏置项,然后是 dense_2 层的三个权重和一个偏置项。其中包括权重的尺寸、数据类型以及参数的具体值等。我们也可以仅提取这些权重的值:

    print(model.get_weights())
    

    权重以数组列表的形式显示,其中每个数组对应于 model.weights 输出中的相应项:

    [array([[1.1533519 , 1.2411805 , 0.39152434]], dtype=float32), array([ 0.03425962, -0.05432956, -0.1607531 ], dtype=float32), array([[1.2210085 ],
           [1.2086679 ],
           [0.21541257]], dtype=float32), array([0.09131978], dtype=float32)]
    
    1. 使用 predict 方法来预测一组新输入的输出:
    x1 = [[5], [6]]
    output = model.predict(x1)
    print(output)
    

    x1 是保存新测试集值的变量,我们需要为其预测输出值。与 fit 方法类似,predict 方法接受数组作为其输入。代码的输出如下:

    [[14.996691]
     [17.989458]]
    

    当训练多个 epoch 时,网络的输出将与预期的输出 (15, 18) 十分接近。

    3. 训练香草神经网络

    我们已经学习了神经网络的基础概念,同时也了解了如何使用 keras 库构建神经网络模型,本节我们将更进一步,通过实现一个实用模型来一窥神经网络的强大性能。

    3.1 香草神经网络与 MNIST 数据集介绍

    通过在输入和输出之间堆叠多个全连接层的网络称为多层感知机,有时会被通俗的称之为香草神经网络(即原始神经网络)。为了了解如何训练香草神经网络,我们将训练模型预测 MNIST 数据集中的数字标签,MNIST 数据集是十分常用的数据集,数据集由来自 250 个不同人手写的数字构成,其中训练集包含 60000 张图片,测试集包含 10000 张图片,每个图片都有其标签,图片大小为 28*28

    3.2 训练神经网络步骤回顾

    训练神经网络的步骤可以总结如下:

    • 导入相关的库和数据集
    • 预处理标签数据(将它们转换为独热编码),以便可以利用标签数据执行优化:
      • 最小化分类交叉熵损失
    • 创建训练和测试数据集:
      • 基于训练数据集创建模型
      • 训练时,模型不使用测试数据集:因此,测试数据集的准确性能够衡量模型在正式使用时的性能表现情况,因为投入使用后,模型会遇到训练时不曾见到的数据
    • 初始化模型
    • 定义模型架构:
      • 指定隐藏层数
      • 指定隐藏层中的节点数
      • 指定要在隐藏层中执行的激活函数
      • 指定要最小化的损失函数
      • 指定将损失函数降至最低的优化器
    • 拟合模型:
      • 设定批大小 (batch size) 以更新权重
      • 设定回合 (epoch) 数
    • 测试模型:
      • 使用测试集验证模型,否则需要将数据集拆分为训练集和验证集——将数据集的最后x%视为测试数据
      • 计算测试数据集的准确率和损失值
    • 检查在每个 epoch 内损失值和准确率的变化情况,有利于训练时了解模型情况

    在下一节中,使用以上训练流程,利用 Keras 建立神经网络模型。

    3.3 使用 Keras 构建神经网络模型

    1. 导入相关的包和数据集,并可视化数据集以了解数据情况:
    from keras.datasets import mnist
    import numpy as np
    from keras.models import Sequential
    from keras.layers import Dense, Dropout
    from keras.utils import np_utils
    import matplotlib.pyplot as plt
    
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    

    在前面的代码中,导入相关的 Keras 方法和 MNIST 数据集。

    1. MNIST 数据集中图像的形状为 28 x 28,绘制数据集中的一些图像,以更好的了解数据集:
    plt.subplot(221)
    plt.imshow(x_train[0], cmap='gray')
    plt.subplot(222)
    plt.imshow(x_train[1], cmap='gray')
    plt.subplot(223)
    plt.imshow(x_test[0], cmap='gray')
    plt.subplot(224)
    plt.imshow(x_test[1], cmap='gray')
    plt.show()
    

    下图显示了以上代码的输出:

    MNIST数据集

    1. 展平 28 x 28 图像,以便将输入变换为一维的 784 个像素值,并将其馈送至 Dense 层中。此外,需要将标签变换为独热编码。此步骤是数据集准备过程中的关键:
    num_pixels = x_train.shape[1] * x_train.shape[2]
    x_train = x_train.reshape(-1, num_pixels).astype('float32')
    x_test = x_test.reshape(-1, num_pixels).astype('float32')
    

    在上示代码中,使用 reshape 方法对输入数据集进行形状变换,np.reshape() 将给定形状的数组转换为不同的形状。在此示例中,x_train 数组具有 x_train.shape[0] 个数据点(图像),每个图像中都有 x_train.shape[1] 行和 x_train.shape[2] 列, 我们将其形状变换为具有 x_train.shape[0] 个数据,每个数据具有 x_train.shape [1] * x_train.shape[2] 个值的数组。
    接下来,我们将标签数据编码为独热向量:

    y_train = np_utils.to_categorical(y_train)
    y_test = np_utils.to_categorical(y_test)
    num_classes = y_test.shape[1]
    

    我们简单了解下独热编码的工作原理。假设有一数据集的可能标签为 {apple,orange,banana,lemon,pear},如果我们将相应的标签转换为独热编码,则如下所示:

    类别索引0索引1索引2索引3索引4
    apple10000
    orange01000
    banana00100
    lemon00010
    pear00001

    每个独热向量含有 n n n 个数值,其中 n n n 为可能的标签数,且仅有标签对应的索引处的值为 1 外,其他所有值均为 0。如上所示,apple 的独热编码可以表示为 [1, 0, 0, 0, 0]。在 Keras 中,使用 to_categorical 方法执行标签的独热编码,该方法找出数据集中唯一标签的数量,然后将标签转换为独热向量。

    1. 用具有 1000 个节点的隐藏层构建神经网络:
    model = Sequential()
    model.add(Dense(1000, input_dim=num_pixels, activation='relu'))
    model.add(Dense(num_classes,  activation='softmax'))
    

    输入具有 28×28=784 个值,这些值与隐藏层中的 1000 个节点单元相连,指定激活函数为 ReLU。最后,隐藏层连接到具有 num_classes=10 个值的输出 (有十个可能的图像标签,因此 to_categorical 方法创建的独热向量有 10 列),在输出的之前使用 softmax 激活函数,以便获得图像的类别概率。

    1. 上述模型架构信息可视化如下所示:
    model.summary()
    

    架构信息输出如下:

    Model: "sequential"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    dense (Dense)                (None, 1000)              785000    
    _________________________________________________________________
    dense_1 (Dense)              (None, 10)                10010     
    =================================================================
    Total params: 795,010
    Trainable params: 795,010
    Non-trainable params: 0
    _________________________________________________________________
    

    在上述体系结构中,第一层的参数数量为 785000,因为 784 个输入单元连接到 1000 个隐藏层单元,因此在隐藏层中包括 784 * 1000 权重值加 1000 个偏置值,总共 785000 个参数。类似地,输出层有10个输出,分别连接到 1000 个隐藏层,从而产生 1000 * 10 个权重和 10 个偏置(总共 10010 个参数)。输出层有 10 个节点单位,因为输出中有 10 个可能的标签,输出层为我们提供了给定输入图像的属于每个类别的概率值,例如第一节点单元表示图像属于 0 的概率,第二个单元表示图像属于 1 的概率,以此类推。

    1. 编译模型如下:
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
    

    因为目标值是包含多个类别的独热编码矢量,所以损失函数是多分类交叉熵损失。此外,我们使用 Adam 优化器来最小化损失函数,在训练模型时,监测准确率 (accuracy,可以简写为 acc) 指标。

    1. 拟合模型,如下所示:
    history = model.fit(x_train, y_train,
                        validation_data=(x_test, y_test),
                        epochs=50,
                        batch_size=64,
                        verbose=1)
    

    上述代码中,我们指定了模型要拟合的输入 (x_train) 和输出 (y_train);指定测试数据集的输入和输出,模型将不会使用测试数据集来训练权重,但是,它可以用于观察训练数据集和测试数据集之间的损失值和准确率有何不同。

    1. 提取不同epoch的训练和测试损失以及准确率指标:
    history_dict = history.history
    loss_values = history_dict['loss']
    val_loss_values = history_dict['val_loss']
    acc_values = history_dict['acc']
    val_acc_values = history_dict['val_acc']
    epochs = range(1, len(val_loss_values) + 1)
    

    在拟合模型时,history 变量会在训练和测试数据集的每个 epoch 中存储与模型相对应的准确率和损失值,我们将这些值提取存储在列表中,以便绘制在训练数据集和测试数据集中准确率和损失的变化。

    1. 可视化不同 epoch 的训练和测试损失以及准确性:
    plt.subplot(211)
    plt.plot(epochs, loss_values, marker='x', label='Traing loss')
    plt.plot(epochs, val_loss_values, marker='o', label='Test loss')
    plt.title('Training and test loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    
    plt.subplot(212)
    plt.plot(epochs, acc_values, marker='x', label='Training accuracy')
    plt.plot(epochs, val_acc_values, marker='o', label='Test accuracy')
    plt.title('Training and test accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.show()
    

    前面的代码运行输入如下图所示,其中第一幅图显示了随着 epoch 数的增加训练和测试的损失值,第二幅图显示了随着 epoch 数的增加训练和测试的准确率:

    模型训练性能监测

    最终模型的准确率约为 97%

    1. 此外,我们也可以手动计算最终模型在测试集上的准确率:
    preds = model.predict(x_test)
    correct = 0
    for i in range(len(x_test)):
        pred = np.argmax(preds[i], axis=0)
        act = np.argmax(y_test[i], axis=0)
        if (pred == act):
            correct += 1
        else:
            continue
    accuracy = correct / len(x_test)
    print('Test accuracy: {:.4f}%'.format(accuracy*100))
    

    在以上代码中,使用模型的 predict 方法计算给定输入(此处为 x_test )的预测输出值。然后,我们循环所有测试集的预测结果,使用 argmax 计算具有最高概率值的索引。同时,对测试数据集的真实标签值执行相同的操作。在测试数据集的预测值和真实值中,最高概率值的索引相同表示预测正确,在测试数据集中正确预测的数量除以测试数据集的数据总量即为模型的准确率。

    3.4 关键步骤总结

    训练原始神经网络代码中执行的关键步骤如下:

    • 展平输入数据集,使用 reshape 方法将每个像素视为一个输入层的节点变量
    • 对标签值进行独热编码,使用 np_utils 中的 to_categorical 方法将标签转换为独热向量
    • 使用 Sequential 堆叠网络层来构建具有隐藏层的神经网络
    • 使用 model.compile 方法对神经网络进行了编译,以最大程度地减少多分类交叉熵损失
    • 使用 model.fit 方法根据训练数据集拟合模型
    • 提取了存储在 history 中的所有 epoch 的训练和测试的损失和准确率
    • 使用 model.predict 方法输出测试数据集中图片对应每个类别的概率
    • 遍历了测试数据集中的所有图像,根据概率值最高索引确定图片类别
    • 最后,计算了准确率(预测类别与图像的实际类别相匹配的个数)

    小结

    在本文中,我们使用 keras 库构建了简单的神经网络模型以了解 keras 库的基本用法,然后进一步构建了原始神经网络用于识别 MNIST 手写数字数据集,对于模型训练的流程和其中的关键步骤进行了详细的总结和介绍。

    系列链接

    Keras深度学习实战(1)——神经网络基础与模型训练过程详解
    Keras深度学习实战(3)——神经网络性能优化技术
    Keras深度学习实战(4)——深度学习中常用激活函数和损失函数详解
    Keras深度学习实战(5)——批归一化详解
    Keras深度学习实战(6)——深度学习过拟合问题及解决方法
    Keras深度学习实战(7)——卷积神经网络详解与实现

    展开全文
  • 利用Keras,在神经网络中实现正则化

    千次阅读 2020-04-12 15:37:04
    正则项在优化过程中层的参数或层的激活值添加惩罚项,这些惩罚项将与损失函数一起作为网络的最终优化目标 惩罚项基于层进行惩罚,目前惩罚项的接口与层有关,但Dense, Conv1D, Conv2D, Conv3D具有共同的接口。...
  • tushare API提供了股票交易数据,直接利用API爬取近十年股票数据。对K线图、移动平均线和MADC可视化。用keras搭建LSTM神经网络模型,2010-2019年日收盘价做训练数据,对2020年收盘价进行预测。
  • 神经网络八股的六步法搭建一、import导入相关包二、train、test训练集、测试集获取三、Sequential搭建网络结构四、compile配置训练方法五、fit执行训练过程六、summary打印网络结构和参数统计完整代码 一、import...
  • Keras 是一个用 Python 编写的高级神经网络 API,它能够以TensorFlow,CNTK, 或者Theano作为后端运行。Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果,是做好研究的关键。 如果你在...
  • 教你如何用Keras搭建分类神经网络

    万次阅读 2021-11-12 14:02:11
    摘要:本文主要通过Keras实现了一个分类学习的案例,并详细介绍了MNIST手写体识别数据集。
  • 使用keras快速搭建神经网络,只需“六步”20行代码
  • keras神经网络模型的保存与加载

    千次阅读 2019-10-25 10:36:29
    一旦你利用Keras完成了训练,你可以将你的网络保存在HDF5里面。 今天毛利灭了它 只需要导入from keras.models import model_from_json就是这么简单 基于Iris数据集 from sklearn import datasets import numpy as np...
  • Keras搭建卷积神经网络

    万次阅读 多人点赞 2019-01-28 12:00:47
    本文我们将学习使用Keras一步一步搭建一个卷积神经网络。具体来说,我们将使用卷积神经网络对手写数字(MNIST数据集)进行识别,并达到99%以上的正确率。 我们还将介绍Colaboratory——一个免费的Jupyter notebook...
  • 如何使用keras快速搭建神经网络模型前言一、keras是什么?二、MLP/ANN使用步骤1.引入库2.读入数据3.配置模型4.画曲线5.求MSE总结 前言 提示:这里可以添加本文要记录的大概内容: 随着人工智能的不断发展,机器学习...
  • Keras搭建卷积神经网络1.卷积Conv2D2.批标准化BN(Batch Normalization)3.激活Activation4.池化Pool2D5.舍弃Dropout总结 卷积就是特征提取器,就是CBAPD。 1.卷积Conv2D TensorFlow给出了计算卷积的函数: tf....
  • 分成两种情况,一种是公开的训练好的模型,下载后可以使用的,另一种是自己训练的模型,需要保存下来,...利用ResNet50网络进行ImageNet分类 from keras.applications.resnet50 import ResNet50 from keras.prepr...
  • Recurrent Shop:利用Keras构建复杂的递归神经网络的框架
  • 本文将探索Keras框架下的深度神经网络知识,主要介绍了利用Keras构建深度神经网络的步骤及其结构。Keras的安装在此未提及(读者可在网络上很容易找到)。 目录深度神经网络之Keras(一)——从Keras开始一、输入数据...
  • 使用Keras搭建一个神经网络的步骤如下: 第一步:选择模型 Keras有两种类型的模型,序贯模型(Sequential)和函数式模型(Model),函数式模型应用更为广泛,序贯模型是函数式模型的一种特殊情况。 a)序贯模型...
  • 掌握Keras构建卷积神经网络的主要步骤。 理解卷积操作。 操作内容: 修改如下代码,对cifar10数据库,调整网络结构为LeNet,优化算法及其学习率,批量大小batch_size,迭代的代数epoch,分析相应的结果。 要修改...
  • tensorflow.keras搭建神经网络六步法

    千次阅读 2020-05-31 21:03:25
    tensorflow.keras搭建神经网络六步法 第一步,import相关模块,如: import tensorflow as tf 第二步,指定输入网络的训练集和标签集,例如训练用的输入x_train和标签y_train,以及测试用的输入x_test和标签y_test...
  • 神经网络是一种性能强大的学习算法,其灵感来自大脑的运作方式。类似于神经元在大脑中彼此连接的方式,神经网络获取输入后,通过某些函数在网络中进行传递输入信息,连接在其后的一些神经元会被激活,从而产生输出。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,598
精华内容 5,839
关键字:

利用keras神经网络