python深度学习_python深度学习� - CSDN
  • python深度学习,keras之父,中英文双版,非扫描版。
  • Python深度学习》2018中文版(高清) 《Python深度学习》2018中文版(高清) 《Python深度学习》2018中文版(高清)
  • python深度学习——案例讲解

    千次阅读 2019-05-21 09:24:01
    最近在看基于python深度学习,首先是一个入门程序,基于keras框架的手写数字识别。手写数字的数据集由60000张训练数据和10000张测试数据组成。训练结果如下: 由训练结果可以看到,训练数据集的准确率是98.89%,而...

    python深度学习——知识总结与整理

    知识点1:基于keras的手写数字识别
    最近在看基于python的深度学习,首先是一个入门程序,基于keras框架的手写数字识别。手写数字的数据集由60000张训练数据和10000张测试数据组成。这些数据都是一个由8位整数组成的3D张量(当然要想查看数据的属性,可以使用shape/ndim/dtype等属性查看),更确切地说,它是60000个矩阵组成的数组,每个矩阵由28*28个整数组成,每个这样的矩阵都是一个灰度图像,在灰度图像中每一个元素的取值范围都是0~255。
    本文采用两层全连接神经网络进行训练,由训练结果可以看到,训练数据集的准确率是98.89%,而测试数据集的准确率是98.1%,这是因为训练时的过拟合造成的,这在之后的博文中会详细分析。
    在这里插入图片描述
    代码如下,python3.7.3,IDE是pycharm专业版

    '''
    @author: liuyunsheng
    @file: handwriting.py
    @time: 2019/5/16 19:49
    @desc:
    '''
    from keras import models
    import matplotlib.pyplot as plt
    from keras import layers
    from keras.utils import to_categorical
    # 提取数据
    from keras.datasets import mnist
    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
    # 当然你也可以用matplotlib库来显示每一个数据
    digit = train_images[4]
    plt.imshow(digit, cmap=plt.cm.binary)
    plt.show()
    # 搭建神经网络;神经网络的核心组件是层(layer),可以看做是进去一些数据,出来的数据更加有用
    # 下面的神经网络包含两个层,两个全连接层,第二个是一个softmax层,将会返回一个由10个概率值组成的数组
    # 每个概率表示当前数字图像属于10个数字类别中某一个的概率
    network = models.Sequential()
    network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))
    network.add(layers.Dense(10, activation='softmax'))
    # 编译,选择损失函数,优化器和训练以及测试过程中需要监控的指标,本案例只关注精度,即正确分类的图像所占的比例
    network.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy'])
    # 训练之前,需要对数据进行预处理,将其变换为网络要求的形状,并缩放到所有值都在[0,1]之间
    train_images = train_images.reshape((60000, 28 * 28))
    train_images = train_images.astype('float32') / 255
    test_images = test_images.reshape((10000, 28 * 28))
    test_images = test_images.astype('float32') / 255
    # 还需要对标签进行分类编码
    train_labels = to_categorical(train_labels)
    test_labels = to_categorical(test_labels)
    # 训练网络,调用fit方法
    network.fit(train_images, train_labels, epochs=5, batch_size=128)
    # 检查模型在测试集的性能
    test_loss, test_acc = network.evaluate(test_images, test_labels)
    print(test_acc)
    

    使用matplotlib显示其中一个数据:
    在这里插入图片描述
    知识点2:张量运算
    张量其实并不是一个陌生的概念,我们可以将张量理解为矩阵向任意维度的推广。
    1、张量的分类(0维张量(标量)、1维张量(向量)、2维张量(矩阵)、3维张量(空间排列的矩阵))
    2、张量的关键属性(轴的个数–阶,形状,数据类型)
    3、操作张量:即从数组中取值
    4、数据批量的概念:一般地,深度学习中所有数据张量的第一个轴都是样本轴,深度学习模型不会同时处理所有的数据,而是将数据拆分成小批量,因此将数据集的第一个轴称为批量轴或批量维度
    5、张量逐元素运算、广播、张量点积、张量变形都是Python中对数据的基本操作

    知识点3:电影评论划分
    习惯性,先上结论,有个清晰的认知:
    在这里插入图片描述
    问题描述:这个案例使用的是IMDB即互联网电影数据库中的50000条两级分化的电影评论,其中25000条用于训练,25000条用于测试,每个数据集中都包含50%的正面和负面评论
    上代码:

    '''
    @author: liuyunsheng
    @file: InternetMoviesDatabase.py
    @time: 2019/5/17 9:02
    @desc:
    '''
    from keras.datasets import imdb
    import numpy as np
    from keras import models
    from keras import layers
    import matplotlib.pyplot as plt
    from pylab import *
    mpl.rcParams['font.sans-serif'] = ['SimHei']
    # 1、加载数据集(num_words=10000表示仅保留训练中前10000个最常出现的单词)
    # 值得注意的是这些数据是经过预处理的,即每条评论都是由单词索引组成的列表,可以通过train_data[0]等查看
    (train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
    # 将索引的单词列表转化成英文单词
    word_index = imdb.get_word_index()
    reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
    decoded_review = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])
    # 2、准备数据,对列表进行one-hot编码,将其转换为01组成的向量;以及将标签向量化
    def vectorize_sequences(sequences, dimension=10000):
        results = np.zeros((len(sequences), dimension))
        for i, sequence in enumerate(sequences):
            results[i, sequence] = 1.
        return results
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    y_train = np.asarray(train_labels).astype('float32')
    y_test = np.asarray(test_labels).astype('float32')
    
    # 3、构建网络
    # 3.1确定网络需要多少层、每层需要多少隐藏单元
    model = models.Sequential()
    model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
    model.add(layers.Dense(16, activation='relu'))
    model.add(layers.Dense(1, activation='sigmoid'))
    # 3.2选择损失函数和优化器
    model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])
    # 4、为了在训练过程中监控模型在未知数据上的精度,需要将原始训练数据留出10000个样本作为验证集
    x_val = x_train[:10000]
    partial_x_train = x_train[10000:]
    y_val = y_train[:10000]
    partial_y_train = y_train[10000:]
    # 5、训练模型
    history = model.fit(partial_x_train,partial_y_train,epochs=20,batch_size=512,validation_data=(x_val, y_val))
    # 6、绘制训练损失和验证损失
    history_dict = history.history
    loss_values = history_dict['loss']
    val_loss_values = history_dict['val_loss']
    epochs = range(1, len(loss_values) + 1)
    plt.plot(epochs, loss_values, 'bo', label='训练损失')
    plt.plot(epochs, val_loss_values, 'b', label='验证损失')
    plt.title('训练和验证损失')
    plt.xlabel('步长')
    plt.ylabel('损失')
    plt.legend()
    plt.show()
    

    知识点4:新闻类别判定

    问题:对路透社的新闻数据集进行划分,每个新闻都只有一个标签,但是一共有46个互斥的类别
    习惯性的先上结果图,分别是训练精度和验证精度、训练损失和验证损失:
    在这里插入图片描述
    在这里插入图片描述

    代码:

    '''
    @author: liuyunsheng
    @file: news.py
    @time: 2019/5/17 10:39
    @desc: 
    '''
    from keras.datasets import reuters
    import numpy as np
    from keras import models
    from keras import layers
    import matplotlib.pyplot as plt
    # 控制中文显示
    from pylab import *
    mpl.rcParams['font.sans-serif'] = ['SimHei']
    from keras.utils.np_utils import to_categorical
    # 加载数据
    (train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)
    # 将数据解析成英文单词
    word_index = reuters.get_word_index()
    reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
    decoded_newswire = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])
    # 将数据向量化
    def vectorize_sequences(sequences, dimension=10000):
        results = np.zeros((len(sequences), dimension))
        for i, sequence in enumerate(sequences):
            results[i, sequence] = 1.
        return results
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    # 将标签向量化,方法1:自己写函数实现
    # 方法2:当然也可以是用keras内置函数实现操作
    # one_hot_train_labels = to_categorical(train_labels)
    # one_hot_test_labels = to_categorical(test_labels)
    def to_one_hot(labels, dimension=46):
        results = np.zeros((len(labels), dimension))
        for i, label in enumerate(labels):
            results[i, label] = 1.
        return results
    one_hot_train_labels = to_one_hot(train_labels)
    one_hot_test_labels = to_one_hot(test_labels)
    # 构建网络:值得注意的是网络最后一层是大小为46的全连接层,会输出一个46维的向量,每个元素代表不同的输出类别
    model = models.Sequential()
    model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(46, activation='softmax'))
    # 编译模型
    model.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy'])
    # 留出验证集
    x_val = x_train[:1000]
    partial_x_train = x_train[1000:]
    y_val = one_hot_train_labels[:1000]
    partial_y_train = one_hot_train_labels[1000:]
    # 训练模型
    history = model.fit(partial_x_train,partial_y_train,epochs=20,batch_size=512,validation_data=(x_val, y_val))
    # 绘制训练损失和验证损失
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    epochs = range(1, len(loss) + 1)
    plt.plot(epochs, loss, 'bo', label='训练损失')
    plt.plot(epochs, val_loss, 'b', label='验证损失')
    plt.title('训练损失和验证损失')
    plt.xlabel('步长')
    plt.ylabel('损失')
    plt.legend()
    plt.show()
    # 绘制训练精度和验证精度
    plt.clf()
    acc = history.history['acc']
    val_acc = history.history['val_acc']
    plt.plot(epochs, acc, 'bo', label='训练精度')
    plt.plot(epochs, val_acc, 'b', label='验证精度')
    plt.title('训练精度和验证精度')
    plt.xlabel('步长')
    plt.ylabel('精度')
    plt.legend()
    plt.show()
    

    知识点5:波士顿房价预测

    问题描述:预测20 世纪70 年代中期波士顿郊区房屋价格的中位数,已知当时郊区的一些数据点,比如犯罪率、当地房产税率等。BostonHousing的数据点相对较少,只有506个,分为404个训练样本和102个测试样本,输入数据的每个特征(比如犯罪率)都有不同的取值范围。
    预测结果:
    在这里插入图片描述
    代码:

    '''
    @author: liuyunsheng
    @file: BostonHousing.py
    @time: 2019/5/17 12:34
    @desc: 
    '''
    from keras.datasets import boston_housing
    from keras import models
    from keras import layers
    import numpy as np
    import matplotlib.pyplot as plt
    # 加载数据
    (train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()
    # 数据标准化,值得注意的是这里用于测试的数据标准化的均值和标准差也是在训练数据集上面得到的
    mean = train_data.mean(axis=0)
    train_data -= mean
    std = train_data.std(axis=0)
    train_data /= std
    test_data -= mean
    test_data /= std
    # 构建网络
    def build_model():
        model = models.Sequential()
        model.add(layers.Dense(64, activation='relu',
        input_shape=(train_data.shape[1],)))
        model.add(layers.Dense(64, activation='relu'))
        model.add(layers.Dense(1))
        model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
        return model
    k = 4
    num_val_samples = len(train_data) // k
    num_epochs = 100
    all_scores = []
    # 由于数据比较少,因此这里采用K折交叉验证,即将数据划分为K个分区,通常为4或5
    # 实例化K个相同的模型,将每个模型在K-1个分区上训练,在剩下一个分区进行评估
    # 模型的验证分数等于K个验证分数的平均值
    num_epochs = 500
    all_mae_histories = []
    for i in range(k):
        print('processing fold #', i)
        val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
        val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]
        partial_train_data = np.concatenate(
            [train_data[:i * num_val_samples],
             train_data[(i + 1) * num_val_samples:]],
            axis=0)
        partial_train_targets = np.concatenate(
            [train_targets[:i * num_val_samples],
             train_targets[(i + 1) * num_val_samples:]],
            axis=0)
        model = build_model()
        history = model.fit(partial_train_data, partial_train_targets,
                            validation_data=(val_data, val_targets),
                            epochs=num_epochs, batch_size=1, verbose=0)
        mae_history = history.history['val_mean_absolute_error']
        all_mae_histories.append(mae_history)
    average_mae_history = [np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]
    # 绘制验证分数
    plt.plot(range(1, len(average_mae_history) + 1), average_mae_history)
    plt.xlabel('步长')
    plt.ylabel('验证的平均绝对误差MAE')
    plt.show()
    
    展开全文
  • Python深度学习(一)深度学习基础

    千次阅读 2019-04-24 09:17:00
    翻译自Deep Learning With Python(2018) 第一章 深度学习基础:https://www.jianshu.com/p/6c08f4ceab4c 第二章 深度学习的数学构建模块:https://www.jianshu.com/p/ba51e470b736 第三章 神经网络入门:...

    翻译自Deep Learning With Python(2018)
    第一章 深度学习基础:https://www.jianshu.com/p/6c08f4ceab4c
    第二章 深度学习的数学构建模块:https://www.jianshu.com/p/ba51e470b736
    第三章 神经网络入门:https://www.jianshu.com/p/f1332c58ca86
    第四章 机器学习基础:https://www.jianshu.com/p/3e9be53289d6
    附录:在Ubuntu上安装Keras及其依赖:https://www.jianshu.com/p/cfcfec045c5b

    Part I 深度学习基础
    本书1-4章将带你了解一些基本概念:什么是深度学习,它可以用来做什么以及它如何工作。此外,还将让你熟悉使用深度学习解决数据问题的典型工作流程。如果你还没怎么了解深度学习,你需要明确的从part I开始读取,然后再去阅读part 2的实际应用。

    1、什么是深度学习

    本章覆盖

    基础概念的高层次定义
    机器学习发展的时间线
    深度学习崛起流行起来的关键因子以及未来的潜力

    在过去的这些年,人工智能(AI)成为了媒体大肆渲染的对象。机器学习,深度学习以及AI出现在数不胜数的文章中,常常是在一些与技术无关的出版物。我们被许诺拥有智能聊天机器人、自动驾驶汽车和虚拟助手的未来 — 这个未来有时被描绘成阴暗面,有时被描绘成乌托邦,在那里,人类的工作岗位将变得稀缺,大多数经济活动将由机器人或人工智能代理来处理。对于未来或当前的机器学习实践者来说,能够识别噪音中的信号是很重要的,这样你就能从过度炒作的新闻稿中分辨出改变世界的发展。我们的未来岌岌可危,在这个未来,你们将发挥积极作用:在阅读本书后,你将是那些开发AI代理的那些人。所以,让我们处理这些问题:到目前为止,深度学习已经取得的成果。它的成就在哪里?我们接下来应该到哪一步?你相信那些大肆的宣传吗?
    本章提供了关于人工智能,机器学习和深度学习的必要的上下文信息。
    1.1 人工智能,机器学习和深度学习
    首先,我们需要明确定义,当我们提及AI时谈论的是什么。人工智能,机器学习和深度学习是什么?(查看figure 1.1)。它们之间的关联是什么?

    在这里插入图片描述

    1.1.1 人工智能

    人工智能诞生于1950年代,当少部分的计算机科学初期领域的先驱开始探讨计算机是否可以思考–该问题的一个分支我们现在仍在探索:使通常由人类完成的智力任务自动化的努力。因此,人工智能是一个包含机器学习和深度学习的通用领域,但它也包含了更多不涉及任何学习的方法。例如,早期的国际象棋程序只涉及由程序员制定的硬编码规则,不具备机器学习的特性。在相当长的一段时间里,许多专家认为,通过让程序员手工制作一套足够大的明确的规则来操纵知识,可以实现人类水平的人工智能。这种方法被称为符号(symbolic)人工智能,从20世纪50年代到80年代末,它是人工智能的主导范式。它在20世纪80年代专家系统的繁荣时期达到了它的顶峰。
    尽管事实证明,符号AI适用于解决定义明确的逻辑问题,如下棋,但要找出解决更复杂、模糊的问题,对于明确规则却是很难的,比如图像分类、语音识别和语言翻译。一种取代符号人工智能的新方法出现了:机器学习。

    1.1.2 机器学习

    在维多利亚时代的英国,艾达·洛夫莱斯夫人是查尔斯-巴贝奇的朋友和合作者,分析引擎的发明者:第一台通用的机械计算机。虽然具有远见卓识,而且遥遥领先于它的时代,但当分析引擎被设计成一台通用计算机时,它并不意味着它就是一台通用计算机,因为通用计算的概念还没有被发明出来。它仅仅是一种使用机械运算的方法,使数学分析领域的某些计算自动化——因此得名“分析”引擎。1843年,艾达·洛夫莱斯(Ada Lovelace)对这一发明发表了评论:“分析引擎没有任何要发明的东西。”它可以做我们知道的任何事情来命令它执行。它的职责是帮助我们提供我们已经熟悉的东西。
    人工智能先驱艾伦·图灵(Alan Turing)后来在1950年发表的里程碑式论文《计算机器与智能》(Computing Machinery and Intelligence)中引用了这句话,称其为“洛夫莱斯夫人的反对”。图灵在思考通用电脑是否有学习和创新的能力时,引用了艾达·洛夫莱斯的话。
    机器学习产生于这样一个问题:一台计算机能否超越“我们知道如何让它执行的指令”,自己学习如何执行指定的任务?
    电脑能给我们带来惊喜吗?与程序员手工制定数据处理规则不同,计算机能通过查看数据自动学习这些规则吗?
    这个问题为新的编程范式打开了大门。在经典编程中,符号AI的范例,人类根据这些规则输入规则(程序)和要处理的数据,然后得到答案(见图1.2)。通过机器学习,人们输入数据以及从数据中得到的答案,然后得出规则。然后,这些规则可以应用于新数据,以生成原始答案。
    在这里插入图片描述

    机器学习系统是经过训练而不是明确编程的。它提供了许多与任务相关的示例,并在这些示例中找到了统计结构,最终允许系统提出自动化任务的规则。
    例如,如果您希望自动化为度假图片添加标签的任务,您可以提供一个机器学习系统,其中包含许多已经由人类标记的图片示例,系统将学习将特定图片与特定标签关联的统计规则。
    尽管机器学习在上世纪90年代才开始蓬勃发展,但它很快就成为人工智能最受欢迎、最成功的子领域,这一趋势是由更快的硬件和更大的数据集的可用性推动的。机器学习与数理统计紧密相关,但它在几个重要方面与统计学不同。
    与统计学不同的是,机器学习倾向于处理大型复杂的数据集(例如数百万张图像的数据集,每个数据集由数万个像素组成),对于这些数据集,传统的统计分析(如贝叶斯分析)是不切实际的。

    1.1.3 从数据中学习表征(representations)

    要定义深度学习并理解深度学习与其他机器学习方法的区别,首先我们需要了解机器学习算法的作用。我刚刚说过,机器学习通过给出预期的例子,挖掘规则以执行数据处理任务。所以,要做机器学习,我们需要三件事:

    输入数据点 —— 例如,如果任务是语音识别,这些数据点可能是人们说话的声音文件。如果任务是图像标记,它们可以是图片。

    预期输出语音识别任务的样例 —— 这些可能是人为的声音文件的记录。在图像任务中,预期的输出可以是“狗”、“猫”等标记。

    一种衡量算法是否处理得当的方法 —— 为了确定算法的当前输出与期望输出之间的距离,这是必要的。测量作为反馈信号来调整算法的工作方式。这个调整步骤就是我们所说的学习。
    机器学习模型将输入数据转换为有意义的输出,这是一个从已知输入和输出样例中“学习”的过程。因此,机器学习和深度学习的核心问题是对数据进行有意义的转换:换句话说,学习当前输入数据的有用表征,使我们更接近预期输出。在我们继续之前,什么是表征?从本质上讲,它是一种看待数据的不同方式——表示或编码数据。例如,彩色图像可以编码为RGB格式(红绿蓝)或HSV格式(色调饱和值):这是同一数据的两种不同表示形式。有些任务在一种表示中可能比较困难,但在另一种表示中可能比较容易。例如,在RGB格式中,任务“选择图像中的所有红色像素”更简单,而在HSV格式中,任务“使图像不饱和”更简单。机器学习模型都是关于为数据的输入数据转换找到适当的表示,使其更适合于当前的任务,例如分类任务。
    让我们把它具体化。考虑x轴、y轴和一些点,它们在(x, y)系统中的坐标表示,如图1.3所示。
    如你所见,我们有一些白色的点和一些黑色的点。假设我们要开发一种算法,它可以取一个点的坐标(x, y)并输出这个点是黑还是白。在这种情况下:
    输入是点的坐标。
    预期的输出是点的颜色。

    一种方法来衡量我们的算法是否做得很好,例如,点被正确分类的百分比。

    在这里插入图片描述

    这里我们需要的是一个数据的新表示,干净地将白点和黑点分开。在许多其他可能性中,我们可以使用的一种转换是坐标更改,如图1.4所示
    在这里插入图片描述

    在这个新的坐标系中,点的坐标可以说是数据的一种新的表示形式。这是一个好主意!有了这种表示,黑/白分类问题可以用一个简单的规则来表示:“黑点是x > 0,”或“白点是x < 0。”这种新的表示基本上解决了分类问题。
    在本例中,我们手工定义了坐标的变化。但是,如果我们尝试系统地搜索不同的可能的坐标变化,并将正确分类的百分比作为反馈,那么我们将进行机器学习。在机器学习的背景下,学习描述了一个自动搜索过程,以获得更好的表示。
    所有的机器学习算法都是由自动查找这样的转换组成的,这些转换将数据转换成对给定任务更有用的表示形式。这些操作可以是坐标更改(如您刚才看到的那样),也可以是线性投影(可能会破坏信息)、转换、非线性操作(如“选择x > 0这样的所有点”),等等。
    机器学习算法在寻找这些转换方面通常缺乏创造性;他们只是搜索一个预定义的集合操作,称为假设空间。这就是机器学习的技术含义:寻找有用的表示一些输入数据,在预定义的可能性空间内,利用反馈信号来引导。这个简单的想法可以解决非常广泛的智力任务,从语音识别到自动驾驶。
    既然您理解了我们所说的学习的含义,那么让我们来看看是什么让深度学习变得特别。

    1.1.4 深度学习之“深”

    深度学习是机器学习的一个特定子领域:从数据中学习表示的一种新方法,强调学习越来越有意义的表示的连续层(layers)。深度学习并不是指通过这种方法获得的任何更深层次的理解;更确切地说,它代表了连续层表示的思想。有多少层对数据模型有贡献被称为模型的深度。该领域的其他适当名称可能是分层表示学习和层次表示学习。现代深度学习通常涉及数十甚至数百层连续的表示层——它们都是通过接触训练数据而自动学习的。与此同时,机器学习的其他方法倾向于只学习数据的一到两层表示;因此,他们有时被称为浅层学习。
    在深度学习中,这些分层的表示(几乎总是)是通过称为神经网(neural networks)的模型来学习的,这些模型的结构是逐层堆叠在一起的文字层。“神经网络”一词是指神经生物学,但尽管深度学习的一些核心概念部分是通过从我们对大脑的理解中汲取灵感而发展起来的,但深度学习模型并不是大脑的模型。
    没有证据表明大脑实现了任何类似于现代深度学习模型中使用的学习机制。你可能会读到一些流行科学文章,宣称深度学习像大脑一样工作,或者是以大脑为模型的,但事实并非如此。如果这个领域的新手认为深度学习与神经生物学有任何关系,那将是令人困惑和适得其反的;你不需要“像我们大脑一样”的神秘,你也可能忘记你可能读过的关于深度学习和生物学之间的假设联系的任何东西。就我们的目的而言,深度学习是一个从数据中学习表征的数学框架。
    通过深度学习算法学习到的表示(representation)是什么样子的?让我们来看看一个网络如何在几层深度里(参见图1.5)转换一个数字的图像,以识别它是什么数字。
    在这里插入图片描述

    如图1.6所示,网络将数字图像转换为与原始图像越来越不同的表示形式,并提供关于最终结果的越来越多的信息。您可以将深度网络看作是一个多级信息蒸馏操作,其中信息经过连续的过滤器,并逐渐被净化(也就是说,对于某些任务非常有用)。
    在这里插入图片描述

    这就是深度学习的技术含义:多阶段学习数据表示的方法。
    这是一个简单的想法——但是,事实证明,非常简单的机制,如果规模足够大,最终看起来就像魔法一样。

    1.1.15 从三张图中理解深度学习如何工作。

    在这一点上,您知道机器学习是关于将输入(如图像)映射到目标(如标签“cat”),这是通过观察许多输入和目标的样例来完成的。您还知道,深层神经网络通过简单的数据转换(层)的深层序列进行输入到目标的映射,这些数据转换是通过样例来学习的。现在让我们具体看看这种学习是如何发生的。
    层(layer)对其输入数据的操作规范存储在层的权值中(weights),其本质上是一堆数字。在技术术语中,我们可以说由层实现的转换是由其权重参数化的(参见图1.7)。
    (权重有时也被称为层的参数。)在这种情况下,学习意味着为网络中所有层的权重找到一组值,以便网络能够正确地将样例输入映射到相关目标。但问题是:深层神经网络可以包含数千万个参数。

    在这里插入图片描述

    要想控制某样东西 ,首先你需要能够观察它。为了控制神经网络的输出,你需要能够测量这个输出与你期望的有多远。这是网络损失函数的工作,也叫目标函数。损失函数接受网络的预测和真实目标
    (您希望网络输出的内容),并计算距离分数,以了解网络在这个特定示例中的表现(参见图1.8)

    在这里插入图片描述

    深度学习的基本技巧是使用这个分数作为反馈信号,稍微调整权重的值,以降低当前示例的损失分数(参见图1.9)。这种调整是优化器的工作,它实现了所谓的反向传播算法:深度学习的中心算法。下一章将更详细地解释反向传播是如何工作的。
    在这里插入图片描述

    最初,网络的权值被分配为随机值,因此网络仅仅实现一系列随机转换。当然,它的产出远低于理想水平,因此损失分数也很高。但是对于网络过程中的每一个样例,权值都会在正确的方向上做一些调整,损失分数会降低。这是一个训练循环,它重复足够多次(通常是在数千个样例上重复数十次),产生的权重值可以最小化损失函数。损失最小的网络是输出尽可能接近目标的网络:训练过的网络(a trained network)。再一次,这是一个简单的机制,一旦扩展,最终看起来像魔术。

    1.1.6 深度学习取得的成就

    虽然深度学习是机器学习的一个相当古老的分支领域,但它直到2010年代初才开始崭露头角。从那以后的几年里,它在这一领域取得了巨大的进步,在视觉和听觉等感知问题上取得了显著的成果,这些问题涉及到一些技能,这些技能对人类来说似乎是自然和直觉的,但对机器来说却一直是难以捉摸的。
    特别是,深度学习取得了以下的突破,都是在机器学习的历史难点领域

    接近人类级别的图像分类
    接近人类级别的语音识别
    接近人类级别的笔迹转录
    改进机器翻译
    改善语音转换
    现在谷歌和亚马逊Alexa等数字助理
    接近人类级别的自主驾驶
    改善广告目标,使用谷歌,百度和必应
    改进搜索结果在网络上
    回答自然语言问题的能力
    超人的围棋玩法
    我们仍在探索深度学习能做什么。我们已经开始把它应用到机器感知和自然语言理解之外的各种各样的问题上,比如形式推理。如果成功,这可能预示着一个深度学习在科学、软件开发等方面帮助人类的时代。

    1.1.7 要相信短期的炒作

    尽管深度学习近年来取得了显著的成就,但人们对该领域在未来十年能够取得的成就的预期,往往远高于可能达到的水平。虽然一些改变世界的应用程序如自动驾驶汽车已经触手可及,但更多的应用程序可能会在很长一段时间内难以捉摸,比如可信的对话系统、跨任意语言的人级机器翻译以及人级自然语言理解。特别地,关于类似人类智力的讨论不应该太严肃。对短期的高期望风险在于,随着技术无法交付,研究投资将枯竭,在很长一段时间内减缓进展。
    这种情况以前也发生过。过去有两次,人工智能经历了一个极度乐观的周期,接着是失望和怀疑,结果是缺乏资金。它始于20世纪60年代的符号人工智能。在早期,对人工智能的预测很高。马文·明斯基(Marvin Minsky)是这种符号人工智能方法最著名的先驱和支持者之一,他在1967年宣称,“在一代人的时间内……创造‘人工智能’的问题将得到实质性解决。”三年后,在1970年,他做了一个更精确的量化预测:“从3年到8年,我们将拥有一台具有普通人一般智力的机器。在2016年,这样的成就似乎还在遥远的将来——到目前为止,我们还无法预测它会持续多久——但在20世纪60年代和70年代初,一些专家认为它即将到来(今天许多人也是如此)。几年后,由于这些高期望值没有成为现实,研究人员和政府基金开始放弃这一领域,标志着第一个人工智能冬天的开始(指核冬天,因为这是在冷战高峰之后不久)。
    它不会是最后一个。上世纪80年代,一种对符号人工智能(AI)的全新理解——专家系统(expert systems)——开始在大公司中掀起热潮。一些最初的成功故事引发了一波投资浪潮,全球各地的企业都开始了自己的自主创业人工智能部门开发专家系统。1985年前后,公司每年在这项技术上的花费超过10亿美元;但到了上世纪90年代初,事实证明,这些系统的维护成本高昂,难以扩大规模,范围有限,人们的兴趣逐渐减退。第二个人工智能冬天就这样开始了。
    我们可能正在经历人工智能炒作和失望的第三轮——我们仍然处于极度乐观的阶段。最好是降低我们对短期的期望,并确保不太熟悉该领域技术方面的人清楚地知道深度学习能带来什么,不能带来什么。

    1.1.8 AI的前景

    虽然我们可能对人工智能有不切实际的短期预期,但长远来看看起来明亮。我们只是刚刚开始将深度学习应用到许多领域。从医学诊断到数字助理的角度来看,这可能会带来重大的变革。人工智能研究在过去五年以惊人的速度向前发展,很大程度上是由于短期内从未见过的资金水平在人工智能上的投入。但到目前为止,已形成产品和进入我们世界方面的进展相对较少。大多数深度学习的研究成果还没有应用到,或者至少没有应用到所有行业都能解决的所有问题上。你的医生还没有使用人工智能,你的会计师也没有。你可能不会在日常生活中使用人工智能技术。当然,你可以问你的智能手机简单的问题,得到合理的答案,你可以在Amazon.com上得到相当有用的产品推荐,你还可以在上面搜“birthday”立即找到你女儿上个月生日派对的照片。这与此类技术过去的地位相去甚远。但这些工具仍然只是我们日常生活的附件。人工智能还没有转变为我们工作、思考和生活方式的核心。
    现在,似乎很难相信人工智能它会对我们的世界产生巨大的影响,因为它还没有得到广泛的应用——就像1995年一样,人们很难相信未来互联网的影响。那时候,大多数人都不知道互联网对他们有什么影响,也不知道它将如何改变他们的生活。今天的深度学习和人工智能也是如此。但毫无疑问:人工智能正在到来。在不远的将来,人工智能将成为你的助手,甚至是你的朋友;它将回答你的问题,帮助教育你的孩子,并照顾你的健康。它将把你的杂货送到家门口,把你从一个地方送到另一个地方。它将成为你通往一个日益复杂和信息密集的世界的界面。更重要的是,人工智能将帮助整个人类向前发展,通过帮助人类科学家在从基因组学到数学等所有科学领域的突破性新发现。
    在此过程中,我们可能会遇到一些挫折,或许还会迎来一个新的人工智能冬天——就像1998年至1999年互联网行业被过度炒作,并在本世纪初遭遇投资枯竭的崩盘一样。但我们最终会到达那里。人工智能最终将被应用到构成我们社会和日常生活的几乎每一个过程中,就像今天的互联网一样。
    不要相信短期的炒作,但要相信长远的眼光。人工智能要发挥其真正的潜力可能需要一段时间——这是一种尚未有人敢于梦想的潜力——但人工智能正在到来,它将以一种奇妙的方式改变我们的世界。

    1.2 深度学习之前:机器学习的简要历史

    深度学习已经达到了人工智能历史上前所未有的公众关注和行业投资水平,但它并不是第一个成功的机器学习形式。
    可以肯定地说,当今行业中使用的大多数机器学习算法都不是深度学习算法。深度学习并不总是适合这项工作的工具——有时没有足够的数据支持深度学习,有时用不同的算法可以更好地解决这个问题。如果深度学习是你与机器学习的第一次接触,那么你可能会发现自己处于这样一种境地:你所拥有的只是一个深度学习的锤子,而每一个机器学习问题都开始像钉子一样。唯一不落入这个陷阱的方法是熟悉其他方法,并在适当的时候实践它们。
    对经典机器学习方法的详细讨论超出了本书的范围,但我们将简要地回顾一下它们,并描述它们发展的历史背景。这将使我们能够把深度学习放在机器学习的更广泛的背景下,更好地理解深度学习从何而来,以及它为什么重要。

    1.2.1 概率模型

    概率建模是统计学原理在数据分析中的应用。这是最早的机器学习方式之一,至今仍被广泛使用。这类算法中最著名的算法之一是朴素贝叶斯算法。
    朴素贝叶斯是一种基于贝叶斯定理的机器学习分类器,它假设输入数据中的特征都是独立的(一个强的或“朴素的”假设,这就是名称的来源)。这种形式的数据分析比计算机更早出现,而且在第一次计算机实现(很可能可以追溯到20世纪50年代)的几十年前就被手工应用。贝叶斯定理和统计学的基础可以追溯到18世纪,这些就是你开始使用朴素贝叶斯分类器所需要的。
    一个密切相关的模型是逻辑回归(简称logreg),它有时被认为是现代机器学习的“hello world”。不要被它的名字误导了,logreg是一个分类算法而不是回归算法。就像朴素的贝叶斯一样,logreg比计算提前了很长一段时间,但由于其简单和多用途的特性,它至今仍然有用。通常,数据科学家在数据集中首先要做的就是对手头的分类任务有所了解。

    1.2.2 早期神经网络

    神经网络的早期迭代已经完全被这些页面中所涵盖的现代变体所取代,但是了解深度学习是如何产生的是很有帮助的。
    虽然神经网络的核心思想早在20世纪50年代就以玩具的形式被研究过,但这种方法却花了几十年才开始。在很长一段时间里,缺失的部分是训练大型神经网络的有效方法。这在80年代中期发生了变化,当多人独立地重新发现反向传播算法——一种利用梯度下降优化训练参数操作链的方法(在书的后面,我们将精确地定义这些概念),并开始将其应用于神经网络。
    神经网络第一次成功的实际应用是在1989年贝尔公司,当Yann LeCun将早期的卷积神经网络和反向传播的思想结合起来,并将它们应用到手写数字的分类问题上时。由此产生的网络被称为“LeNet”,在20世纪90年代,美国邮政服务公司(United States Postal Service)使用该网络来自动读取邮件信封上的邮编。
    1.2.3 内核模型
    随着神经网络在20世纪90年代开始在研究人员中获得一些尊重,由于这第一次成功,一种机器学习的新方法声名鹊起,并很快将神经网络送回了人们的记忆中:核方法。核方法是一类分类算法,其中最著名的是支持向量机(SVM)。
    SVM的现代公式是由Vladimir开发的。Vapnik和Corinna Cortes于20世纪90年代初在贝尔实验室发表于1995年,尽管Vapnik和Alexey Chervonenkis早在1963.3年就发表了一个更老的线性公式。
    SVMs旨在通过在属于两个不同类别的两组点之间找到好的决策边界(参见图1.10)来解决分类问题。决策边界可以看作是一条线或曲面,将您的训练数据分隔成两个空间,对应于两个类别。要对新数据点进行分类,只需检查它们位于决策边界的哪一边。

    在这里插入图片描述

    SVMs通过两个步骤找到这些边界:

    将数据映射到新的高维表示,其中决策边界可以表示为超平面(如果数据是二维的,如图1.10所示,超平面将是一条直线)。
    一个好的决策边界(一个分离超平面)是通过试图最大化超平面和离分类最近的数据点之间的距离来计算的,这个步骤叫做最大化边界。这使得边界可以很好地推广到训练数据集之外的新样本。
    将数据映射到高维表示(其中分类问题变得更简单)的技术在纸面上可能看起来不错,但在实践中常常难以计算。这就是内核技巧(内核方法以其命名的关键思想)发挥作用的地方。这里是它的要点:在新的表示空间中,找到好的决策超平面,你不需要显式地计算新空间中点的坐标;你只需要计算空间中点对之间的距离,这可以用核函数有效地完成。内核函数是一种计算上易于处理的操作,它将初始空间中的任意两个点映射到目标表示空间中这些点之间的距离,完全绕过了新表示的显式计算。内核函数通常是手工制作的,而不是从数据中学习——在支持向量机的情况下,只学习分离超平面。
    在他们被开发的时候,SVMs在简单的分类问题上表现出了最先进的性能,并且是为数不多的由广泛的理论支持的机器学习方法之一,并且易于进行严肃的数学分析,使他们易于理解和解释。因为这些有用的性质,长期以来,SVMs在该领域非常流行。
    但事实证明,SVMs难以扩展到大型数据集,而且无法为图像分类等感知问题提供良好的结果。因为支持向量机是一种浅层的方法,将支持向量机应用于感知问题需要首先手工提取有用的表示(称为特征工程),这是一个困难且脆弱的步骤。

    1.2.4 决策树,随即森林,以及梯度增强机

    决策树是类似流程图的结构,它允许您对输入数据点进行分类或预测给定输入的输出值(参见图1.11)。它们很容易想象和解释。从数据中学习的决策树在本世纪头十年开始受到大量的研究兴趣,到2010年,决策树往往比内核方法更受青睐。

    在这里插入图片描述

    特别是,随机森林算法引入了一种健壮的、实用的决策树学习方法,它涉及到构建大量的专门决策树,然后集成它们的输出。随机森林适用于各种各样的问题——你可以说,对于任何浅层机器学习任务来说,它们几乎总是第二好的算法。当颇受欢迎的机器学习竞赛网站Kaggle (http://kaggle.com)于2010年上线时,random forests很快就成为了平台上的宠儿——直到2014年梯度提升机取而代之。梯度提升机很像随机森林,是一种基于综合弱预测模型(通常是决策树)的机器学习技术。使用梯度增强,一种通过迭代训练新模型来改进任何机器学习模型的方法,这些新模型专门针对以前模型的缺点。应用到决策树中,梯度提升技术的使用使得模型在大多数情况下都比随机森林表现更好,同时具有相似的特性。
    它可能是当今处理非感知数据最好的算法之一,如果不是最好的话。在Kaggle比赛中,除了深度学习,它也是最常用的技术之一。

    1.2.5 回到神经网络

    大约在2010年,尽管大多数科学界几乎完全回避神经网络,但仍在研究神经网络的许多人开始取得重大突破:多伦多大学的Geoffrey Hinton、蒙特利尔大学的yoshu Bengio、纽约大学的Yann LeCun和瑞士人工智能研究所(IDSIA)等。
    2011年,来自IDSIA的Dan Ciresan开始通过gpu训练的深度神经网络赢得学术图像分类竞赛,这是现代深度学习的第一次实际成功。但转折点出现在2012年,Hinton的小组在每年的大规模图像分类挑战赛ImageNet。ImageNet的挑战在当时是出了名的困难,包括在140万张图像上训练后将高分辨率的彩色图像分成1000个不同的类别。2011年,基于com经典方法的中奖模型准确率排名前五。2011年,基于经典计算机视觉方法的获奖模型的前五名准确率仅为74.3%。然后,在2012年,亚历克斯领导的一个团队Krizhevsky和Geoffrey Hinton的建议能够达到前五名的准确性——重大突破83.6%。自那以后,这种竞争每年都被深度卷积神经网络所主导。到2015年,优胜者的准确率达到96.4%,在ImageNet上的分类任务被认为是一个完全解决的问题。
    自2012年以来,深度卷积神经网络(convnets)成为所有计算机视觉任务的首选算法;更一般地说,它们对所有知觉任务都起作用。在2015年和2016年的主要计算机视觉会议上,几乎不可能找到不以某种形式涉及卷积神经网络的演讲。与此同时,深度学习也在许多其他类型的问题中得到了应用,比如自然语言处理。在广泛的应用程序中,它完全取代了SVMs和决策树。例如,欧洲核子研究中心(CERN)的欧洲核子研究组织(European Organization For Nuclear Research, CERN)多年来一直使用基于决策树的方法分析来自大型强子对撞机(LHC)的ATLAS探测器的粒子数据;但CERN最终转向了基于keras的深层神经网络,因为它们具有更高的性能和在大型数据集上易于训练。

    1.2.6 是什么让深度学习与众不同

    深度学习发展如此之快的主要原因是它在许多问题上提供了更好的表现。但这不是唯一的原因。深度学习也使得解决问题要容易得多,因为它完全自动化了机器学习工作流中最关键的一步:特性工程。
    以前的机器学习技术—浅层学习—只涉及到将输入数据转换成一个或两个连续的表示空间,通常通过简单的转换,如高维非线性投影(SVMs)或决策树。但是,复杂问题所需要的精细表示通常无法用这种技术来实现。因此,人类必须竭尽全力使最初的输入数据更易于通过这些方法进行处理:他们必须手工为他们的数据设计良好的表示层。这就是特征工程。另一方面,深度学习完全自动化了这一步:通过深度学习,你可以一次性学习所有的特性,而不必自己去设计它们。这大大简化了机器学习的工作流程,常常用单一的、简单的、端到端深度学习模型取代复杂的多级管道。
    您可能会问,如果问题的关键是要有多个连续的表示层,那么是否可以重复使用浅层方法来模拟深度学习的效果?在实践中,浅层学习方法的后续应用的回报迅速递减,因为三层模型中的最优第一表示层不是单层或双层模型中的最优第一层。深度学习的革命性之处在于,它允许一个模型同时学习所有层次的表示,而不是连续地(贪婪地,正如它所称的)。通过联合特征学习,当模型调整其内部特征时,所有依赖它的其他特征都会自动适应变化,而不需要人工干预。所有的一切都受到一个反馈信号的监督:模型中的每一个变化都服务于最终目标。这比贪婪地堆叠浅层模型要强大得多,因为它允许通过将复杂的抽象表示分解为一系列中间空间(层)来学习;每个空间都是与前一个空间的简单转换。
    这些是深度学习学习的两个基本特征数据:增量, 一层一层地发展出越来越复杂的表现形式。事实上,这些中间增量表示是共同学习的,每一层都被更新,以满足上面一层和下面一层的表征需求。这两个特性使深度学习比以往的机器学习方法更成功。

    1.2.7 现代机器学习的景象

    了解机器学习算法和工具的现状的一个好方法是查看Kaggle上的机器学习竞赛。由于其高度竞争的环境(一些竞赛有成千上万的参赛者和百万美元的奖金)和广泛的机器学习问题,Kaggle提供了一个现实的方法来评估什么有效,什么无效。那么,什么样的算法能够可靠地赢得比赛呢?顶级参赛者使用什么工具?
    在2016年和2017年,Kaggle被两种方法所主导:梯度提升机和深度学习。具体来说,梯度提升用于有结构化数据可用的问题,而深度学习用于图像分类等感知问题。前者的实践者几乎总是使用优秀的XGBoost库,该库为数据科学中最流行的两种语言Python和R.提供支持。
    为了在今天的应用机器学习中取得成功,你应该最熟悉这两种技术:梯度提升机,用于浅层学习问题;深度学习,用于感知问题。从技术角度讲,这意味着您需要熟悉XGBoost和keras这两个目前在Kaggle竞赛中占主导地位的库。有了这本书,你已经离成功又近了一大步。

    1.3 为什么是深度学习?

    计算机视觉深度学习的两个关键思想——卷积神经网络和反向传播——在1989年已经被充分理解。Long Short-
    Term Memory (LSTM)算法是时间序列深度学习的基础,于1997年开发出来,此后几乎没有什么变化。那么,为什么深度学习在2012年之后才开始流行起来呢?这二十年发生了什么变化?
    总的来说,有三种技术力量推动着机器学习的进步:

    硬件
    数据和基准测试
    算法的进步
    因为这个领域是由实验结果而不是理论指导的,所以算法的进步只有在适当的数据和硬件可用来尝试新想法时才有可能实现(或者像通常情况那样扩大旧想法的规模)。机器学习不是数学或物理,主要的进步可以用笔和纸来完成。这是一门工程学。
    上世纪90年代和本世纪头十年,真正的瓶颈是数据和硬件。但这段时间发生了什么:互联网起飞了,高性能的显卡被开发出来以满足游戏市场的需求。

    1.3.1 硬件

    1990年到2010年间,现成的cpu速度提高了大约5000倍。因此,如今在笔记本电脑上运行小型深度学习模型是可能的,而在25年前,这还很棘手。但在计算机视觉或语音识别中使用的典型深度学习模型需要的计算能力要比笔记本电脑所能提供的能力大几个数量级。在本世纪头十年里,英伟达(NVIDIA)和AMD等公司一直在投资数十亿美元开发快速、大规模的并行芯片(图形处理单元[gpu]),以支持越来越逼真的视频游戏的图形功能——廉价、单用途的超级计算机,旨在实时在屏幕上呈现复杂的3D场景。2007年,英伟达(NVIDIA)推出了CUDA (https://developer.nvidia.com/about-cuda),这是其gpu系列的编程接口,这让科学界受益。在各种高度可并行化的应用程序中,少量的gpu开始取代大量的cpu集群,从物理建模开始。深度神经网络主要由许多小的矩阵乘法组成,也具有高度的并行性;大约在2011年,一些研究人员开始编写CUDA的神经网络实现程序——dan Ciresan4和Alex Krizhevsky5就是其中之一。
    事实是,游戏市场为下一代人工智能应用程序的超级计算提供了补贴。有时候,大事情从游戏开始。如今,NVIDIA TITAN X是一款游戏GPU, 2015年底售价1000美元,单次精度最高可达6.6万亿次,每秒可进行6.6万亿次浮点运算。这比你从一台现代笔记本电脑中得到的要多350倍。
    在泰坦X上,只需要几天时间就可以训练出一种ImageNet模型,这种模型几年前就能在ILSVRC竞赛中获胜。与此同时,大公司在数百个专为深度学习需求而开发的gpu集群上训练深度学习模型,例如NVIDIA Tesla K80。如果没有现代gpu,这些集群的纯粹计算能力是不可能实现的。
    更重要的是,深度学习行业开始超出gpu外,并投资于日益专业化、高效的深度学习芯片。在2016年的年度I/O大会上,谷歌展示了其张量处理单元(张量处理单元,TPU)项目:一种全新的芯片设计,从底层开发出来,运行深度神经网络,据说比顶级gpu快10倍,而且更节能。

    1.3.2 Data

    人工智能有时被称为新工业革命。如果说深度学习是这场革命的蒸汽机,那么数据就是它的煤炭:为我们的智能机器提供动力的原材料,没有这些,一切都不可能。说到数据,除了存储硬件在过去20年里呈指数级增长(遵循摩尔定律),改变游戏规则的是互联网的兴起,使得收集和分发用于机器学习的大型数据集成为可能。如今,大公司使用的是图像数据集、视频数据集和自然语言数据集,这些数据集在没有互联网的情况下是无法收集的。用户生成的图像标签例如,Flickr一直是计算机视觉数据的宝库。YouTube以及维基百科也是自然语言处理的关键数据集。
    如果说有一个数据集是深度学习兴起的催化剂,那就是ImageNet数据集,由140万张图片组成,这些图片已经手工注释了1000个图片类别(每个图片一个类别)。但使ImageNet与众不同的不仅仅是它的大尺寸,还有与之相关的年度竞争。
    正如Kaggle自2010年以来所展示的那样,公开竞赛是一种极好的方式来激励研究人员和工程师突破极限。有共同的基准,研究人员竞争击败,已大大有助于最近的深度学习的崛起。

    1.3.3 Algorithms

    除了硬件和数据,直到本世纪末,我们还没有找到一种可靠的方法来训练深度很深的神经网络。因此,神经网络仍然相当肤浅,只使用一或两层表示;因此,他们无法在更精细的浅层方法如SVMs和随机森林中发光。关键的问题是梯度传播通过深层堆叠层。用于训练神经网络的反馈信号会随着层数的增加而消退。
    这种情况在2009-2010年发生了改变,一些简单但重要的算法改进出现了,从而可以更好地实现梯度传播:

    更好的神经层激活功能
    更好的权重初始化方案,从分层预训练开始,很快就被放弃了
    更好的优化方案,如RMSProp和Adam
    只有当这些改进开始允许有10层或更多层的训练模型时,深度学习才开始闪光。最后,在2014年、2015年和2016年,发现了更先进的帮助梯度传播的方法,如批处理规范化、剩余连接和深度可分离卷积。今天,我们可以从零开始训练数千层的模型。

    1.3.4新一轮投资浪潮

    随着深度学习在2012-2013年成为计算机视觉的新技术,并最终应用于所有感知任务,行业领袖们注意到了这一点。随之而来的是一股远远超过人工智能历史上以往任何时期的行业投资浪潮。
    2011年,在深度学习受到关注之前,人工智能的风险投资总额约为1900万美元,几乎全部用于浅层机器学习方法的实际应用。到2014年,这个数字已经上升到惊人的水平3.94亿美元。在这三年里,数十家创业公司成立,试图利用深度学习的宣传。与此同时,像谷歌,Facebook,百度和微软在内部研究部门的投资金额极有可能让风投资金的流动相形见绌。只有少数数据浮出水面:2013年,谷歌以据说5亿美元的价格收购了深度学习创业公司DeepMind,这是历史上最大的人工智能公司收购案。在2014年,百度在硅谷建立了一个深度学习研究中心,投资了3亿美元。英特尔在2016年的出价超过4亿美元,以获得了神经网络系统的深度学习硬件启动。
    机器学习——尤其是深度学习——已经成为这些科技巨头产品战略的核心。2015年末,谷歌首席执行官桑达尔·皮查伊表示:“机器学习是一种核心的、具有变革性的方式,通过这种方式我们可以重新思考我们是如何做每件事的。”我们深思熟虑地将其应用于我们所有的产品,无论是搜索、广告、YouTube还是播放。我们还处于早期阶段,但你会看到我们——以系统的方式——在所有这些领域应用机器学习。
    在这波投资浪潮的推动下,从事深度学习的人数在短短五年内从几百人上升到数万人,研究进展也达到了狂热的速度。目前没有迹象表明这一趋势会很快放缓。

    1.3.5 深度学习的民主进程

    推动深度学习新面孔流入的关键因素之一是该领域所用工具集的民主化。在早期,做深度学习需要大量的c++和CUDA专业知识,这是很少有人拥有的。现在,基本的Python脚本编写技能足以进行高级的深度学习研究。最引人注目的驱动因素是Theano和tensorflow的开发——这是Python的两种符号性质的tensor操作框架,支持自动区分,极大地简化了新模型的实现——以及模型和用户友好的库(如Keras)的兴起,使得深度学习像操作乐高积木一样简单。在2015年初发布之后,Keras迅速成为了大量新创业公司、研究生和研究人员的深度学习解决方案。

    1.3.6这种情况会持续下去吗?

    深层神经网络有什么特别之处,使它们成为公司投资和研究人员趋之若鹜的“正确”方法吗?或者深度学习只是一种可能不会持续很久的时尚?20年内,我们还会使用深层神经网络吗?
    深度学习有几个特性可以证明它作为一场人工智能革命的地位,而且它将一直存在下去。20年后,我们可能不会再使用神经网络,但无论我们使用什么,都将直接继承现代深度学习及其核心概念。
    这些重要属性大致可分为三类:

    简单-深度学习消除了对特征工程的需求,用简单的、端到端可训练的模型取代了复杂、脆弱、严重依赖工程的管道方式,这些模型通常只使用五六个不同的张量运算来构建。
    可伸缩性-深度学习非常适合在gpu或TPUs,所以它可以充分利用摩尔定律。此外,深度学习模型是通过迭代小批量数据来训练的,允许它们在任意大小的数据集中进行训练。(唯一的瓶颈是可用的并行计算能力,得益于摩尔定律,这是一个快速推进的障碍。)
    多功能性和可重用性——与许多现有的机器学习方法不同,深度学习模型可以在额外的数据上进行训练,而无需从头开始,这使得它们可以持续在线学习——对于非常大的生产模型来说是一个重要的特性。此外,经过训练的深度学习模型是可重构的,因此可以重用:例如,可以将经过训练的深度学习模型用于图像分类,并将其放入视频处理管道中。这使我们可以对以前的工作进行再投资,以应对越来越多地复杂而强大的模型。这也使得深度学习适用于相当小的数据集。
    深度学习只是几年前才成为人们关注的焦点,我们还没有确定它能做什么。随着每个月的过去,我们都在学习新的用例和工程改进,以消除以前的限制。在一场科学革命之后,进步通常遵循一个s形曲线:它开始于一段快速的进步时期,随着研究人员遇到严格的限制,它逐渐稳定下来,然后进一步的改进逐渐增加。2017年的深度学习似乎是“s”型学习的前半部分,在接下来的几年中会有更多的进展。

    链接:https://www.jianshu.com/p/6c08f4ceab4c

    展开全文
  • 现在的人工智能已经呈指数级增长。比如,自动驾驶汽车的时速达数百万英里,IBM...而解决问题的核心就是深度学习。TensorFlow是使用数据流图像进行数值计算的开源软件库。图中的节点代表数学运算,而图的边缘代表在它...

    现在的人工智能已经呈指数级增长。比如,自动驾驶汽车的时速达数百万英里,IBM Watson在诊断病人的情况上比医生更好,AlphaGo击败了世界冠军。这其中,人工智能扮演着关键的角色。

    随着人工智能的进一步发展,人们也提出了更高的要求。希望它们可以解决更加复杂的问题。而解决问题的核心就是深度学习。


    TensorFlow是使用数据流图像进行数值计算的开源软件库。图中的节点代表数学运算,而图的边缘代表在它们之间传递多维数据数组。灵活的体系结构允许您使用单个API将计算部署到桌面、服务器或移动设备中的一个或多个CPU或GPU。TensorFlow最初是由谷歌机器智能研究组织内的Google Brain 的研究人员和工程师开发的,目的是进行机器学习和深度神经网络研究,该系统的通用性足以应用于其他领域。


    它被全球各大公司所使用,包括Airbnb、Ebay、Dropbox、Snapchat、Twitter、优步,SAP、高通、IBM,英特尔,当然还有Google!

    教程:从零开始 使用Python进行深度学习!

    1.深度学习的先决条件:Python中的线性回归

    数据科学:从零开始学习线性回归,并使用Python构建自己的工作程序以进行数据分析。

    本课程将教授您一种在机器学习、数据科学和统计学中使用的一种流行技术:线性回归。它将从根本上做到:解决方案的推导以及现实世界问题的应用。它将向您展示如何在Python中编写自己的线性回归模块。学习资料也可以加下Python扣扣裙:四八三五四六四一六自己下载学习下


    线性回归是您可以学习的最简单的机器学习模型。在第一部分,它将向您展示如何使用一维线性回归来证明莫尔定律是正确的。在下一节中,它将把一维线性回归扩展到任意线性回归——换句话说,它将创建一个可以从多个输入中学习的机器学习模型。

    最后,我们将讨论一些当您执行数据分析时需要注意的实际机器学习问题,例如泛化、过度拟合、训练测试分割等。


    2.深度学习的先决条件:Python中的逻辑回归

    本课程是深度学习和神经网络的入门课程——它涵盖了机器学习、数据科学和统计学中常用的基本技术:逻辑回归。

    本课程为您提供了许多实用示例,以便您可以真正了解如何使用深度学习。在整个课程中,它将通过您开展的课程项目,向您展示如何根据用户数据预测用户行为,比如用户是否在移动设备上,他们查看的产品数量,他们在您的网站上逗留了多久,他们是否是回访者以及他们访问的时间等等。

    课程结束后的另一个项目将向您展示了如何使用深度学习来进行面部表情识别。想象一下,仅仅基于图片就能够预测某人的情绪该多么酷!

    教程:从零开始 使用Python进行深度学习!

    3.Python进行深度学习的完整指南

    本课程将指导您如何使用Google的Tensor Flow框架来创建用于深度学习的人工神经网络。它旨在让您轻松理解Google Tensor Flow框架的复杂性。引导您充分利用Tensor Flow框架的完整指南,同时向您展示深度学习中的最新技术。这样做的目的是平衡理论和实践。同时它还配有大量的练习方便您测试新技能。

    本课程涵盖神经网络基础、张量流基础、人工神经网络、密集连接网络、卷积神经网络、递归神经网络、AutoEncoders、强化学习、OpenAI Gym等。


    4.使用PythonKeras实现从零到深度学习

    本课程旨在提供深度学习的完整介绍。它的目标读者是熟悉Python的初学者和中级程序员和数据科学家,他们希望了解深度学习技术并将其应用于各种问题。

    它将首先回顾深度学习应用以及机器学习工具和技术的概述。然后介绍人工神经网络并解释如何训练它们以解决回归和分类问题。在课程的其余部分中,还将介绍并解释包括完全连接、卷积和递归神经网络在内的几种体系结构,并对每种体系结构解释理论给出大量的示例应用。


    5.深度学习:Python中的卷积神经网络

    这门课程全部是关于如何使用卷积神经网络进行计算机视觉深度学习。这是当前图像分类的最新技术,它们在像MNIST这样的任务中击败了vanilla deep networks。在StreetView House Number(SVHN)数据集中——它使用不同角度的较大彩色图像——因此计算和分类任务的难度都会变得更加严格。但是它将通过卷积神经网络或CNN 来应对挑战。

    此外,它还将向您展示如何构建可应用于音频的卷积滤波器,如回声效应,以及如何为图像效果构建滤波器,如高斯模糊和边缘检测。您还得联系到生物学、讨论卷积神经网络是如何受到动物视觉皮层的启发。


    6.深度学习:Python中的递归神经网络

    在课程的第一部分中,我们将添加时间概念到我们的神经网络。它将向您介绍简单递归单位,也称为Elman单位。

    在本课程的下一部分中,您需要重新审视循环神经网络最流行的应用之一——语言建模。

    神经网络另一个流行的语言应用是词向量或词嵌入。最常见的技术称为Word2Vec,它会告诉您如何使用递归神经网络来创建词向量。

    在接下来的部分中,您将看到及受“吹捧”的LSTM和长期/短期记忆单元,以及更现代、更高效的GRU或门控循环单元。您可以把它们应用于某些实际的问题,例如从维基百科数据中学习语言模型,并将结果可视化为单词嵌入。


    7.深度学习A-Z™:手动式人工神经网络

    在本课程中,您将深入了解人工神经网络,并在实践中应用人工神经网络。理解卷积神经网络,在实践中应用卷积神经网络;理解循环神经网络,在实践中应用循环神经网络;理解自组织映射,在实践中应用自组织映射;理解玻尔兹曼机器,在实践中应用玻尔兹曼机器。

    教程:从零开始 使用Python进行深度学习!

    8. Python中的现代深度学习

    在本课程中,您将了解批量和随机梯度下降。这是两种常用的技术,可以让您在每次迭代时只对一小部分数据进行训练,从而大大加快训练时间。您还将了解动量,这将会有助于通过当地最低标准,并防止您的学习速度过于缓慢。您还将了解如AdaGrad、RMSprop和Adam等自适应学习速率技术,通过它们帮助您加快训练速度。


    9.使用Python进行自然语言处理的深度学习

    在本课程中,您将看到高级NLP.It,它将向您展示word2vec的工作原理。从理论到实施,您会发现它仅仅是您熟悉的技能的应用。nWord2vec很有趣,因为它神奇地将单词映射到一个可以找到类比的矢量空间,例如:king - man = queen - woman,France - Paris = England - London,December - November - July – June。在GLoVe方法中,它也可以找到单词向量,使用了一种称为矩阵分解的技术,这是一种用于反编译系统的流行算法。令人惊讶的是,由GLoVe生成的单词向量与由word2vec生成的单词向量一样好,并且您将更容易看到一些经典的NLP问题。如词类标注和实体命名识别,使用递归神经网络解决它们。您会发现几乎任何问题都可以使用神经网络来解决,但真的不是任何问题都可以。

    最后,您将学习递归神经网络,它将帮助我们解决情感分析中的否定问题。递归神经网络利用了句子具有树状结构的特性。我们终于可以脱离一大堆单词。


    10.人工智能:Python中的强化学习

    当人们谈论人工智能时,他们通常不是指有监督和无监督的机器学习。与我们认为的人工智能所做的事情相比,人们更多指的是像玩象棋和围棋、驾驶汽车、以超人的水平击败视频游戏。(即,强化学习)强化学习因为这些事情而变得流行起来。同时,强化学习开辟了一个全新的“世界”。

    正如您将在本课程中学习的那样,强化学习模式与有监督学习和无监督学习相比,它们彼此不同。强化学习引发了行为心理学和神经科学领域的新的,令人惊异的见解。


    11.数据科学、深度学习和Python机器学习

    如果您有一些编程或脚本经验,本课程将向您介绍真正的数据科学家和机器学习从业人员在本行业使用的技术——并为您迈入这一热门职业道路做好准备。

    每个概念都是用简单的英文介绍的,从而避免了数学符号和术语的混淆。然后使用Python代码进行演示。您可以尝试使用和构建它们,并且可以保留以供将来参考的备注。在这门课程中,您不会重点学习这些算法的学术性、深度性的数学涵盖——重点是对它们的实际理解和应用。最后,您将得到一个最终的项目来应用您学到的知识。

    展开全文
  • 1.1 层:深度学习的基础部件 5层神经网络,8层神经网络,等等 1.2 模型:层构成的网络 深度学习的模型时层构成的有向无环图。最常见的例子就是层的线性堆叠,将单一输入映射为单一输出 1.3 损失函数与优化器:...

    第三章 神经网络入门

    1.神经网络剖析
    1.1 层:深度学习的基础部件
    5层神经网络,8层神经网络,等等

    1.2 模型:层构成的网络
    深度学习的模型时层构成的有向无环图。最常见的例子就是层的线性堆叠,将单一输入映射为单一输出

    1.3 损失函数与优化器:配置学习过程的关键
    损失函数:在训练过程中需要将其最小化,它能够衡量当前任务是否已经完成
    优化器:决定如何基于损失函数对网络进行更新,它执行的是随机梯度下降的某个变体

    2.电影评论分类:二分类问题
    二元分类,或者称为二值分类,可能是应用最广泛的机器学习问题。通过学习本例,你将掌握如何基于文本内容将影评分为正、负二类。

    本文将从互联网电影数据库(IMDB)获取50,000个流行电影影评作为数据集。这里将其分割为25,000个影评的训练集和25,000个影评的测试集。其中每个数据集都包含50%的好评和50%的差评。

    # 导入数据
    from keras.datasets 
    import imdb(train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words = 10000)
    # 查看这两个数据
    train_data[0]train_labels[0]
    # 最长的句子只有10000个单词
    max([max(sequence) for sequence in train_data])
    
    word_index = imdb.get_word_index()
    reverse_word_index = dict([(value,key) for (key,value) in word_index.items()])
    decoded_review = ''.join([reverse_word_index.get(i-3,'?') for i in train_data[0]])
    # print(decoded_review)
    
    ?thisfilmwasjustbrilliantcastinglocationscenerystorydirectioneveryone'sreallysuitedtheparttheyplayedandyoucouldjustimaginebeingthererobert?isanamazingactorandnowthesamebeingdirector?fathercamefromthesamescottishislandasmyselfsoilovedthefacttherewasarealconnectionwiththisfilmthewittyremarksthroughoutthefilmweregreatitwasjustbrilliantsomuchthatiboughtthefilmassoonasitwasreleasedfor?andwouldrecommendittoeveryonetowatchandtheflyfishingwasamazingreallycriedattheenditwassosadandyouknowwhattheysayifyoucryatafilmitmusthavebeengoodandthisdefinitelywasalso?tothetwolittleboy'sthatplayedthe?ofnormanandpaultheywerejustbrilliantchildrenareoftenleftoutofthe?listithinkbecausethestarsthatplaythemallgrownuparesuchabigprofileforthewholefilmbutthesechildrenareamazingandshouldbepraisedforwhattheyhavedonedon'tyouthinkthewholestorywassolovelybecauseitwastrueandwassomeone'slifeafterallthatwassharedwithusall
    
    import numpy as np
    # 将每个句子进行独热编码,形成0,1矩阵
    def vectorize_sequences(sequences,dimension = 10000):
        results = np.zeros((len(sequences),dimension))
        for i,sequence in enumerate(sequences):
            results[i,sequence] = 1.
        return results
    
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    
    # 将标签也进行向量化
    y_train = np.asarray(train_labels).astype('float32')
    y_test = np.asarray(test_labels).astype('float32')
    
    x_train[0]
    
    array([0., 1., 1., ..., 0., 0., 0.])
    
    from keras import models
    from keras import layers
    
    model = models.Sequential()
    model.add(layers.Dense(16,activation = 'relu',input_shape = (10000,)))
    model.add(layers.Dense(16,activation = 'relu'))
    model.add(layers.Dense(1,activation = 'sigmoid'))
    
    # 损失函数为二元交叉熵,三个参数依次为:优化器,损失函数,评价指标
    model.compile(optimizer = 'rmsprop',loss = 'binary_crossentropy',metrics = ['acc'])
    
    # 把训练样本分为训练集和交叉测试集
    x_val = x_train[:10000]
    partial_x_train = x_train[10000:]
    
    y_val = y_train[:10000]
    partial_y_train = y_train[10000:]
    
    
    result = model.fit(partial_x_train,partial_y_train,epochs = 20,batch_size = 512,validation_data = (x_val,y_val))
    
    Train on 15000 samples, validate on 10000 samples
    Epoch 1/20
    15000/15000 [==============================] - 5s 338us/step - loss: 0.5326 - acc: 0.7917 - val_loss: 0.4064 - val_acc: 0.8700
    Epoch 2/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.3258 - acc: 0.8987 - val_loss: 0.3154 - val_acc: 0.8851
    Epoch 3/20
    15000/15000 [==============================] - 3s 232us/step - loss: 0.2357 - acc: 0.9245 - val_loss: 0.2827 - val_acc: 0.8899
    Epoch 4/20
    15000/15000 [==============================] - 3s 233us/step - loss: 0.1866 - acc: 0.9397 - val_loss: 0.2862 - val_acc: 0.8838
    Epoch 5/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.1502 - acc: 0.9521 - val_loss: 0.2768 - val_acc: 0.8887
    Epoch 6/20
    15000/15000 [==============================] - 4s 236us/step - loss: 0.1256 - acc: 0.9615 - val_loss: 0.3118 - val_acc: 0.8800
    Epoch 7/20
    15000/15000 [==============================] - 3s 233us/step - loss: 0.1045 - acc: 0.9687 - val_loss: 0.3120 - val_acc: 0.8837
    Epoch 8/20
    15000/15000 [==============================] - 4s 234us/step - loss: 0.0882 - acc: 0.9730 - val_loss: 0.3211 - val_acc: 0.8817
    Epoch 9/20
    15000/15000 [==============================] - 3s 232us/step - loss: 0.0736 - acc: 0.9792 - val_loss: 0.3548 - val_acc: 0.8819
    Epoch 10/20
    15000/15000 [==============================] - 4s 240us/step - loss: 0.0595 - acc: 0.9851 - val_loss: 0.3971 - val_acc: 0.8744
    Epoch 11/20
    15000/15000 [==============================] - 4s 236us/step - loss: 0.0508 - acc: 0.9863 - val_loss: 0.3904 - val_acc: 0.8782
    Epoch 12/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.0396 - acc: 0.9912 - val_loss: 0.4199 - val_acc: 0.8742
    Epoch 13/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.0335 - acc: 0.9933 - val_loss: 0.4490 - val_acc: 0.8725
    Epoch 14/20
    15000/15000 [==============================] - 4s 244us/step - loss: 0.0278 - acc: 0.9943 - val_loss: 0.4748 - val_acc: 0.8734
    Epoch 15/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.0239 - acc: 0.9947 - val_loss: 0.5067 - val_acc: 0.8704
    Epoch 16/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.0164 - acc: 0.9979 - val_loss: 0.5940 - val_acc: 0.8555
    Epoch 17/20
    15000/15000 [==============================] - 4s 234us/step - loss: 0.0124 - acc: 0.9988 - val_loss: 0.5650 - val_acc: 0.8676
    Epoch 18/20
    15000/15000 [==============================] - 4s 235us/step - loss: 0.0112 - acc: 0.9988 - val_loss: 0.6037 - val_acc: 0.8653
    Epoch 19/20
    15000/15000 [==============================] - 4s 242us/step - loss: 0.0089 - acc: 0.9992 - val_loss: 0.6369 - val_acc: 0.8646
    Epoch 20/20
    15000/15000 [==============================] - 4s 253us/step - loss: 0.0078 - acc: 0.9982 - val_loss: 0.6863 - val_acc: 0.8683
    
    # 绘制训练损失和验证损失
    import matplotlib.pyplot as plt
    history_dict = history.history
    loss_values = history_dict['loss']
    val_loss_values = history_dict['val_loss']
    
    epochs = range(1,len(loss_values) + 1 )
    
    plt.plot(epochs,loss_values,'bo',label = 'Training loss')
    plt.plot(epochs,val_loss_values,'b',label = 'Validation loss')
    
    plt.title('Training and validation loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()
    
    plt.show()
    

    在这里插入图片描述

    # 绘制训练精度和验证精度
    plt.clf() # 清空图像
    acc = history_dict['acc']
    val_acc = history_dict['val_acc']
    
    plt.plot(epochs,acc,'bo',label = 'Training acc')
    plt.plot(epochs,val_acc,'b',label = 'Validation acc')
    
    plt.title('Training and validation acc')
    plt.xlabel('Epochs')
    plt.ylabel('acc')
    plt.legend()
    
    plt.show()
    
    

    在这里插入图片描述

    # 重头开始训练一个模型
    model = models.Sequential()
    model.add(layers.Dense(16,activation = 'relu',input_shape = (10000,)))
    model.add(layers.Dense(16,activation = 'relu'))
    model.add(layers.Dense(1,activation = 'sigmoid'))
    
    model.compile(optimizer = 'rmsprop',loss = 'binary_crossentropy',metrics = ['accuracy'])
    
    model.fit(x_train,y_train,epochs = 4,batch_size = 512)
    
    results = model.evaluate(x_test,y_test)
    
    print(results)
    
    Epoch 1/4
    25000/25000 [==============================] - 12s 478us/step - loss: 0.4383 - acc: 0.8220
    Epoch 2/4
    25000/25000 [==============================] - 4s 172us/step - loss: 0.2485 - acc: 0.9127
    Epoch 3/4
    25000/25000 [==============================] - 4s 153us/step - loss: 0.1965 - acc: 0.9304
    Epoch 4/4
    25000/25000 [==============================] - 4s 147us/step - loss: 0.1659 - acc: 0.9391
    25000/25000 [==============================] - 6s 259us/step
    [0.30140374687194826, 0.88092]
    

    从本实例学到的知识点:

    原始数据集预处理为张量传入神经网络。单词序列编码为二值向量或者其它形式;
    一系列带有relu激活函数的Dense layer能解决广泛的问题,包括情感分类,后续会常用到的;
    二值分类问题(输出两个类别)中,最后的一个Dense layer带有一个sigmoid激活函数和一个单元:网络输出是0到1之间的标量,代表概率值;
    二分类问题中有sigmoid标量输出的,损失函数选择binary_crossentropy损失函数;
    rmsprop优化器对于大部分深度学习模型来说是足够好的选择;
    随着在训练集上表现越来越好,神经网络模型开始过拟合,在新数据上表现越来越差。关注验证集上的监控指标

    3.新闻分类:多分类问题
    在本小节,你将学习构建神经网络,把路透社新闻分为互不相交的46类主题。很明显,这个问题是多分类问题,并且每个数据点都只归为一类,那么该问题属于单标签、多分类;如果每个数据点可以属于多个分类,那么你面对的将是多标签、多分类问题。

    路透社新闻数据集是由路透社1986年发布的短新闻和对应主题的集合,它常被用作文本分类的练手数据集。该数据集有46个不同的新闻主题,在训练集中每个主题包含至少10个新闻。

    from keras.datasets import reuters
    (train_data,train_labels),(test_data,test_labels) = reuters.load_data(num_words = 10000)
    len(train_data)
    train_data[0]
    
    [1,
     2,
     2,
     8,
     43,
     10,
     447,
     5,
     25,
     207,
     270,
     5,
     3095,
     111,
     16,
     369,
     186,
     90,
     67,
     7,
     89,
     5,
     19,
     102,
     6,
     19,
     124,
     15,
     90,
     67,
     84,
     22,
     482,
     26,
     7,
     48,
     4,
     49,
     8,
     864,
     39,
     209,
     154,
     6,
     151,
     6,
     83,
     11,
     15,
     22,
     155,
     11,
     15,
     7,
     48,
     9,
     4579,
     1005,
     504,
     6,
     258,
     6,
     272,
     11,
     15,
     22,
     134,
     44,
     11,
     15,
     16,
     8,
     197,
     1245,
     90,
     67,
     52,
     29,
     209,
     30,
     32,
     132,
     6,
     109,
     15,
     17,
     12]
    
    word_index = reuters.get_word_index()
    # 将单词和索引对调位置
    reverse_word_index = dict([(value,key) for (key,value) in word_index.items()])
    decoded_newswire = ''.join([reverse_word_index.get(i-3,'?') for i in train_data[0]])
    decoded_newswire
    
    '???saidasaresultofitsdecemberacquisitionofspacecoitexpectsearningspersharein1987of115to130dlrspershareupfrom70ctsin1986thecompanysaidpretaxnetshouldrisetonineto10mlndlrsfromsixmlndlrsin1986andrentaloperationrevenuesto19to22mlndlrsfrom125mlndlrsitsaidcashflowpersharethisyearshouldbe250tothreedlrsreuter3'
    
    import numpy as np
    
    # 将训练数据向量化,one-hot编码
    def vectorize_sequences(sequences,dimension = 10000):
        results = np.zeros((len(sequences),dimension))
        for i,sequence in enumerate(sequences):
            results[i,sequence] = 1
        return results
    
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    
    # 对标签也进行向量化,因为有46个标签,所以进行one-hot编码
    def to_one_hot(labels,dimension = 46):
        results = np.zeros((len(labels),dimension))
        for i,label in enumerate(labels):
            results[i,label] = 1
        return results
    
    one_hot_train_labels = to_one_hot(train_labels)
    one_hot_test_labels = to_one_hot(test_labels)
    print(one_hot_train_labels[0])
    
    # 注意,keras可以用内置的方法实现这个操作
    from keras.utils.np_utils import to_categorical
    one_hot_train_labels = to_categorical(train_labels)
    one_hot_test_labels = to_categorical(test_labels)
    print(one_hot_train_labels[0])
    
    [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
     0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
     0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    
    # 开始构建网络
    from keras import models
    from keras import layers
    
    model = models.Sequential()
    model.add(layers.Dense(64,activation = 'relu',input_shape = (10000,)))
    model.add(layers.Dense(64,activation = 'relu'))
    model.add(layers.Dense(46,activation = 'softmax'))
    
    # 指定损失函数的类型,优化器类型等
    model.compile(optimizer = 'rmsprop',loss = 'categorical_crossentropy',metrics = ['accuracy'])
    
    # 将数据分为训练集和交叉验证集
    x_val = x_train[:1000]
    partial_x_train = x_train[1000:]
    
    y_val = one_hot_train_labels[:1000]
    partial_y_train = one_hot_train_labels[1000:]
    
    # 训练模型
    history = model.fit(partial_x_train,partial_y_train,epochs = 20,batch_size = 512,validation_data = (x_val,y_val))
    
    
    Train on 7982 samples, validate on 1000 samples
    Epoch 1/20
    7982/7982 [==============================] - 19s 2ms/step - loss: 2.5507 - acc: 0.5291 - val_loss: 1.6875 - val_acc: 0.6250
    Epoch 2/20
    7982/7982 [==============================] - 1s 148us/step - loss: 1.4181 - acc: 0.6984 - val_loss: 1.2969 - val_acc: 0.7210
    Epoch 3/20
    7982/7982 [==============================] - 1s 152us/step - loss: 1.0661 - acc: 0.7755 - val_loss: 1.1533 - val_acc: 0.7480
    Epoch 4/20
    7982/7982 [==============================] - 1s 156us/step - loss: 0.8420 - acc: 0.8247 - val_loss: 1.0469 - val_acc: 0.7700
    Epoch 5/20
    7982/7982 [==============================] - 1s 151us/step - loss: 0.6770 - acc: 0.8554 - val_loss: 0.9674 - val_acc: 0.7950
    Epoch 6/20
    7982/7982 [==============================] - 1s 151us/step - loss: 0.5370 - acc: 0.8861 - val_loss: 0.9304 - val_acc: 0.7940
    Epoch 7/20
    7982/7982 [==============================] - 1s 153us/step - loss: 0.4330 - acc: 0.9078 - val_loss: 0.8959 - val_acc: 0.8050
    Epoch 8/20
    7982/7982 [==============================] - 1s 152us/step - loss: 0.3485 - acc: 0.9267 - val_loss: 0.8999 - val_acc: 0.8060
    Epoch 9/20
    7982/7982 [==============================] - 1s 153us/step - loss: 0.2943 - acc: 0.9354 - val_loss: 0.8915 - val_acc: 0.8090
    Epoch 10/20
    7982/7982 [==============================] - 1s 153us/step - loss: 0.2422 - acc: 0.9440 - val_loss: 0.8716 - val_acc: 0.8240
    Epoch 11/20
    7982/7982 [==============================] - 1s 152us/step - loss: 0.2070 - acc: 0.9501 - val_loss: 0.8944 - val_acc: 0.8060
    Epoch 12/20
    7982/7982 [==============================] - 1s 150us/step - loss: 0.1906 - acc: 0.9496 - val_loss: 0.9115 - val_acc: 0.8080
    Epoch 13/20
    7982/7982 [==============================] - 1s 151us/step - loss: 0.1652 - acc: 0.9531 - val_loss: 0.9392 - val_acc: 0.8060
    Epoch 14/20
    7982/7982 [==============================] - 1s 151us/step - loss: 0.1525 - acc: 0.9543 - val_loss: 1.0099 - val_acc: 0.7890
    Epoch 15/20
    7982/7982 [==============================] - 1s 154us/step - loss: 0.1425 - acc: 0.9543 - val_loss: 0.9689 - val_acc: 0.8070
    Epoch 16/20
    7982/7982 [==============================] - 1s 153us/step - loss: 0.1294 - acc: 0.9559 - val_loss: 0.9896 - val_acc: 0.8080
    Epoch 17/20
    7982/7982 [==============================] - 1s 158us/step - loss: 0.1215 - acc: 0.9579 - val_loss: 1.0397 - val_acc: 0.7910
    Epoch 18/20
    7982/7982 [==============================] - 1s 154us/step - loss: 0.1196 - acc: 0.9593 - val_loss: 0.9960 - val_acc: 0.8120
    Epoch 19/20
    7982/7982 [==============================] - 1s 148us/step - loss: 0.1192 - acc: 0.9559 - val_loss: 0.9938 - val_acc: 0.8130
    Epoch 20/20
    7982/7982 [==============================] - 1s 151us/step - loss: 0.1095 - acc: 0.9575 - val_loss: 1.0413 - val_acc: 0.7990
    
    import matplotlib.pyplot as plt
    
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    
    
    
    def drawLossAndAcc(x,y1,y2,titles = ''):
        plt.plot(x,y1,'bo',label = 'Train Loss or Accuracy')
        plt.plot(x,y2,'b',label = 'Validation Loss or Accuracy')
        
        plt.title(titles)
        plt.xlabel('Epochs')
        plt.ylabel('Loss or Accuracy')
        plt.legend()
        plt.show()
        
    loss = history.history['loss']
    val_loss = history.history['val_loss']
    epochs = range(1,len(loss)+1)
    drawLossAndAcc(epochs,loss,val_loss,'Loss')
    
    acc = history.history['acc']
    val_acc = history.history['val_acc']
    epochs = range(1,len(acc)+1)
    drawLossAndAcc(epochs,acc,val_acc,'Accuracy')
    

    在这里插入图片描述
    在这里插入图片描述

    # 在第九次左右出现过拟合,重新训练一个网络,让他只迭代9次
    model = models.Sequential()
    model.add(layers.Dense(64,activation = 'relu',input_shape = (10000,)))
    model.add(layers.Dense(64,activation = 'relu'))
    model.add(layers.Dense(46,activation = 'softmax'))
    
    # 指定损失函数的类型,优化器类型等
    model.compile(optimizer = 'rmsprop',loss = 'categorical_crossentropy',metrics = ['accuracy'])
    history = model.fit(partial_x_train,partial_y_train,epochs = 8,batch_size = 512,validation_data = (x_val,y_val))
    results = model.evaluate(x_test,one_hot_test_labels)
    print(results)
    
    Train on 7982 samples, validate on 1000 samples
    Epoch 1/8
    7982/7982 [==============================] - 1s 177us/step - loss: 2.5043 - acc: 0.5459 - val_loss: 1.7318 - val_acc: 0.6320
    Epoch 2/8
    7982/7982 [==============================] - 1s 152us/step - loss: 1.3879 - acc: 0.7038 - val_loss: 1.2876 - val_acc: 0.7170
    Epoch 3/8
    7982/7982 [==============================] - 1s 150us/step - loss: 1.0521 - acc: 0.7712 - val_loss: 1.1364 - val_acc: 0.7540
    Epoch 4/8
    7982/7982 [==============================] - 1s 151us/step - loss: 0.8371 - acc: 0.8216 - val_loss: 1.0412 - val_acc: 0.7950
    Epoch 5/8
    7982/7982 [==============================] - 1s 150us/step - loss: 0.6724 - acc: 0.8596 - val_loss: 0.9815 - val_acc: 0.7930
    Epoch 6/8
    7982/7982 [==============================] - 1s 153us/step - loss: 0.5395 - acc: 0.8890 - val_loss: 0.9516 - val_acc: 0.7920
    Epoch 7/8
    7982/7982 [==============================] - 1s 152us/step - loss: 0.4396 - acc: 0.9083 - val_loss: 0.9023 - val_acc: 0.8110
    Epoch 8/8
    7982/7982 [==============================] - 1s 150us/step - loss: 0.3548 - acc: 0.9246 - val_loss: 0.8841 - val_acc: 0.8140
    2246/2246 [==============================] - 0s 218us/step
    [0.9657114454389999, 0.7845057880676759]
    
    # 在新数据上生成测试结果
    predictions = model.predict(x_test)
    print('预测结果的大小:',predictions[0].shape)
    print('列向量之和:',np.sum(predictions[0]))
    print('最大元素的位置(类别):',np.argmax(predictions[0]))
    
    # 处理标签的另一种方法,将其转换为整数张量
    
    # y_train = np.array(train_labels)
    # y_test = np.array(test_labels)
    # 这样转换时,只需要将损失函数选为sparse_categorical_crossentropy 即可,只是同种方法的不同表示形式
    
    
    预测结果的大小: (46,)
    列向量之和: 1.0000001
    最大元素的位置(类别): 3
    
    # 中间层维度足够大的重要性
    # 输出为46个类别,所以我们中间层的神经元数目不能太小
    # 增大神经元看结果
    # 在第九次左右出现过拟合,重新训练一个网络,让他只迭代9次
    model = models.Sequential()
    model.add(layers.Dense(128,activation = 'relu',input_shape = (10000,)))
    model.add(layers.Dense(128,activation = 'relu'))
    model.add(layers.Dense(128,activation = 'relu'))
    model.add(layers.Dense(46,activation = 'softmax'))
    
    # 指定损失函数的类型,优化器类型等
    model.compile(optimizer = 'rmsprop',loss = 'categorical_crossentropy',metrics = ['accuracy'])
    history = model.fit(partial_x_train,partial_y_train,epochs = 9,batch_size = 512,validation_data = (x_val,y_val))
    results = model.evaluate(x_test,one_hot_test_labels)
    print(results)
    
    Train on 7982 samples, validate on 1000 samples
    Epoch 1/9
    7982/7982 [==============================] - 2s 201us/step - loss: 2.2824 - acc: 0.5410 - val_loss: 1.4298 - val_acc: 0.6840
    Epoch 2/9
    7982/7982 [==============================] - 1s 162us/step - loss: 1.1867 - acc: 0.7340 - val_loss: 1.1448 - val_acc: 0.7600
    Epoch 3/9
    7982/7982 [==============================] - 1s 163us/step - loss: 0.8614 - acc: 0.8089 - val_loss: 1.0324 - val_acc: 0.7670
    Epoch 4/9
    7982/7982 [==============================] - 1s 161us/step - loss: 0.6364 - acc: 0.8576 - val_loss: 0.9332 - val_acc: 0.8110
    Epoch 5/9
    7982/7982 [==============================] - 1s 163us/step - loss: 0.4530 - acc: 0.9050 - val_loss: 0.9022 - val_acc: 0.8140
    Epoch 6/9
    7982/7982 [==============================] - 1s 159us/step - loss: 0.3360 - acc: 0.9270 - val_loss: 0.9570 - val_acc: 0.8050
    Epoch 7/9
    7982/7982 [==============================] - 1s 163us/step - loss: 0.2608 - acc: 0.9420 - val_loss: 1.0241 - val_acc: 0.7850
    Epoch 8/9
    7982/7982 [==============================] - 1s 162us/step - loss: 0.2204 - acc: 0.9476 - val_loss: 0.9642 - val_acc: 0.8090
    Epoch 9/9
    7982/7982 [==============================] - 1s 161us/step - loss: 0.1768 - acc: 0.9528 - val_loss: 1.0295 - val_acc: 0.7900
    2246/2246 [==============================] - 1s 226us/step
    [1.1476774699753773, 0.780498664345151]
    ​
    

    从本例应该学习到的知识点:

    如果你想将数据分为N类,那神经网络模型最后一个Dense layer大小为N;
    在单标签、多分类的问题中,模型输出应该用softmax激活函数,输出N个分类的概率分布;
    分类交叉熵是分类问题合适的损失函数。它最小化模型输出的概率分布和真实label的概率分布之间的距离;
    处理多分类中label的两种方法:
    通过one-hot编码编码label,并使用categorical_crossentropy作为损失函数;
    通过整数张量编码label,并使用sparse_categorical_crossentropy损失函数
    对于数据分类的类别较多的情况,应该避免创建较小的中间layer,导致信息瓶颈。

    4.预测房价:回归问题
    前面两个例子都可以看成是分类问题,它的目标是预测某个输入数据点的单个离散label。常见的另外一类机器学习问题是线性回归,其预测的是一个连续值,而不是离散label。比如,根据气象信息预测明天的气温;根据软件项目计划书预测实现时间。

    注意:不要混淆线性回归和逻辑回归算法。逻辑回归不是回归算法,而是分类算法。
    

    波士顿房价数据集是1970年代中期波士顿郊区的数据样本,包含犯罪率、不动产税税率等。你将用该数据集预测当地房价的中间价。波士顿房价数据集与前面两个例子都不太一样,数据样本点相当少:只有506个,其中404个作为训练样本和102个测试样本。输入数据的每个特征都有不同的scale。例如,一些比例值,取值范围在0和1之间;另一些取值在1到12之间;还有些取值在0到100之间,等等。

    # 波士顿房价预测
    from keras.datasets import boston_housing
    (train_data,train_target),(test_data,test_target) = boston_housing.load_data()
    
    Using TensorFlow backend.
    Downloading data from https://s3.amazonaws.com/keras-datasets/boston_housing.npz
    57344/57026 [==============================] - 0s 5us/step
    
    train_data.shape
    test_data.shape
    train_target
    
    (404, 13)
    (102, 13)
    array([15.2, 42.3, 50. , 21.1, 17.7, 18.5, 11.3, 15.6, 15.6, 14.4, 12.1,
           17.9, 23.1, 19.9, 15.7,  8.8, 50. , 22.5, 24.1, 27.5, 10.9, 30.8,
           32.9, 24. , 18.5, 13.3, 22.9, 34.7, 16.6, 17.5, 22.3, 16.1, 14.9,
           23.1, 34.9, 25. , 13.9, 13.1, 20.4, 20. , 15.2, 24.7, 22.2, 16.7,
           12.7, 15.6, 18.4, 21. , 30.1, 15.1, 18.7,  9.6, 31.5, 24.8, 19.1,
           22. , 14.5, 11. , 32. , 29.4, 20.3, 24.4, 14.6, 19.5, 14.1, 14.3,
           15.6, 10.5,  6.3, 19.3, 19.3, 13.4, 36.4, 17.8, 13.5, 16.5,  8.3,
           14.3, 16. , 13.4, 28.6, 43.5, 20.2, 22. , 23. , 20.7, 12.5, 48.5,
           14.6, 13.4, 23.7, 50. , 21.7, 39.8, 38.7, 22.2, 34.9, 22.5, 31.1,
           28.7, 46. , 41.7, 21. , 26.6, 15. , 24.4, 13.3, 21.2, 11.7, 21.7,
           19.4, 50. , 22.8, 19.7, 24.7, 36.2, 14.2, 18.9, 18.3, 20.6, 24.6,
           18.2,  8.7, 44. , 10.4, 13.2, 21.2, 37. , 30.7, 22.9, 20. , 19.3,
           31.7, 32. , 23.1, 18.8, 10.9, 50. , 19.6,  5. , 14.4, 19.8, 13.8,
           19.6, 23.9, 24.5, 25. , 19.9, 17.2, 24.6, 13.5, 26.6, 21.4, 11.9,
           22.6, 19.6,  8.5, 23.7, 23.1, 22.4, 20.5, 23.6, 18.4, 35.2, 23.1,
           27.9, 20.6, 23.7, 28. , 13.6, 27.1, 23.6, 20.6, 18.2, 21.7, 17.1,
            8.4, 25.3, 13.8, 22.2, 18.4, 20.7, 31.6, 30.5, 20.3,  8.8, 19.2,
           19.4, 23.1, 23. , 14.8, 48.8, 22.6, 33.4, 21.1, 13.6, 32.2, 13.1,
           23.4, 18.9, 23.9, 11.8, 23.3, 22.8, 19.6, 16.7, 13.4, 22.2, 20.4,
           21.8, 26.4, 14.9, 24.1, 23.8, 12.3, 29.1, 21. , 19.5, 23.3, 23.8,
           17.8, 11.5, 21.7, 19.9, 25. , 33.4, 28.5, 21.4, 24.3, 27.5, 33.1,
           16.2, 23.3, 48.3, 22.9, 22.8, 13.1, 12.7, 22.6, 15. , 15.3, 10.5,
           24. , 18.5, 21.7, 19.5, 33.2, 23.2,  5. , 19.1, 12.7, 22.3, 10.2,
           13.9, 16.3, 17. , 20.1, 29.9, 17.2, 37.3, 45.4, 17.8, 23.2, 29. ,
           22. , 18. , 17.4, 34.6, 20.1, 25. , 15.6, 24.8, 28.2, 21.2, 21.4,
           23.8, 31. , 26.2, 17.4, 37.9, 17.5, 20. ,  8.3, 23.9,  8.4, 13.8,
            7.2, 11.7, 17.1, 21.6, 50. , 16.1, 20.4, 20.6, 21.4, 20.6, 36.5,
            8.5, 24.8, 10.8, 21.9, 17.3, 18.9, 36.2, 14.9, 18.2, 33.3, 21.8,
           19.7, 31.6, 24.8, 19.4, 22.8,  7.5, 44.8, 16.8, 18.7, 50. , 50. ,
           19.5, 20.1, 50. , 17.2, 20.8, 19.3, 41.3, 20.4, 20.5, 13.8, 16.5,
           23.9, 20.6, 31.5, 23.3, 16.8, 14. , 33.8, 36.1, 12.8, 18.3, 18.7,
           19.1, 29. , 30.1, 50. , 50. , 22. , 11.9, 37.6, 50. , 22.7, 20.8,
           23.5, 27.9, 50. , 19.3, 23.9, 22.6, 15.2, 21.7, 19.2, 43.8, 20.3,
           33.2, 19.9, 22.5, 32.7, 22. , 17.1, 19. , 15. , 16.1, 25.1, 23.7,
           28.7, 37.2, 22.6, 16.4, 25. , 29.8, 22.1, 17.4, 18.1, 30.3, 17.5,
           24.7, 12.6, 26.5, 28.7, 13.3, 10.4, 24.4, 23. , 20. , 17.8,  7. ,
           11.8, 24.4, 13.8, 19.4, 25.2, 19.4, 19.4, 29.1])
    
    # 数据标准化
    
    mean = train_data.mean(axis = 0)
    print(mean)
    train_data = train_data - mean
    
    std = train_data.std(axis = 0)
    print(std)
    train_data = train_data / std
    
    # 注意,对测试数据也要进行标准化,但是用到的均值和标准差都来源与训练数据
    
    test_data -= mean
    test_data /= std
    
    [ 7.83201886e-18 -1.20915379e-17 -1.42899993e-17 -1.21739802e-16
      4.39692287e-18  7.41980734e-18  1.09923072e-17 -1.09923072e-18
     -2.72059603e-17 -2.08853836e-17  1.26411533e-17 -1.23663456e-18
     -3.29769215e-18]
    [1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
    
    from keras import models
    from keras import layers
    def build_model():
        model = models.Sequential()
        model.add(layers.Dense(64,activation = 'relu',input_shape = (train_data.shape[1],)))
        model.add(layers.Dense(64,activation = 'relu'))
        model.add(layers.Dense(1))  #最后一层是一个线性输出单元,不加任何激活函数,他可以与预测任意范围内的值,加了激活函数,就限制了他的输出范围
        model.compile(optimizer = 'rmsprop',loss = 'mse',metrics = ['mae'])
        return model
    
    
    # 利用k折交叉验证来验证你的方法
    import numpy as np
    
    k = 4
    num_val_samples = len(train_data) // 4
    num_epochs = 100
    all_scores = []
    
    for i in range(k):
        print('processing fold ',i)
        val_data = train_data[i*num_val_samples:(i+1)*num_val_samples]
        val_target = train_target[i*num_val_samples:(i+1)*num_val_samples]
        
        partial_train_data = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis = 0)
        partial_train_target = np.concatenate([train_target[:i*num_val_samples],train_target[(i+1)*num_val_samples:]],axis = 0)
        
        model = build_model()
        model.fit(partial_train_data,partial_train_target,epochs = num_epochs,batch_size = 1,verbose = 0)
        val_mse,val_mae = model.evaluate(val_data,val_target,verbose = 0)
        all_scores.append(val_mae)
    
    processing fold  0
    processing fold  1
    processing fold  2
    processing fold  3
    
    print(all_scores)
    
    [2.059201702032939, 2.192299434454134, 2.8599761736274947, 2.4273995509242066]
    
    # 上一个代码块的结果为预测平均房价与实际房价相差300美元左右
    # 差别太大,训练更长的时间来看一下效果
    num_epochs = 500
    all_mae_histories = []
    for i in range(k):
        print('processing fold',i)
        val_data = train_data[i*num_val_samples:(i+1)*num_val_samples]
        val_target = train_target[i*num_val_samples:(i+1)*num_val_samples]
        
        partial_train_data = np.concatenate([train_data[:i*num_val_samples],train_data[(i+1)*num_val_samples:]],axis = 0)
        partial_train_target = np.concatenate([train_target[:i*num_val_samples],train_target[(i+1)*num_val_samples:]],axis = 0)
        
        model = build_model()
        history = model.fit(partial_train_data,partial_train_target,validation_data = (val_data,val_target),epochs = num_epochs,batch_size = 1,verbose = 0)
        mae_history = history.history['val_mean_absolute_error']
        all_mae_histories.append(mae_history)
    
    processing fold 0
    processing fold 1
    processing fold 2
    processing fold 3
    
    print( len(all_mae_histories))
    # print( all_mae_histories)
    # 4次交叉验证,每次500次迭代。相当于把4次求平均,还是500个数据
    average_mae_history = [np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]
    
    
    import matplotlib.pyplot as plt
    plt.plot(range(1,len(average_mae_history) + 1),average_mae_history)
    plt.xlabel('Epochs')
    plt.ylabel('Validation MAE')
    plt.show()
    

    在这里插入图片描述

    # 纵轴范围很大,看不清这张图,删除前10个点,将每个数据点替换为前面数据点的指数移动平均值,以得到光滑曲线
    def smooth_curve(points,factor = 0.9):
        smoothed_points = []
        for point in points:
            if smoothed_points:
                previous = smoothed_points[-1]
                smoothed_points.append(previous * factor + point *(1-factor))
            else:
                smoothed_points.append(point)
        return smoothed_points
    
    smooth_mae_history = smooth_curve(average_mae_history[10:])
    
    plt.plot(range(1,len(smooth_mae_history) + 1),smooth_mae_history)
    
    plt.xlabel("Epochs")
    plt.ylabel('Validation MAE')
    plt.show()
    

    在这里插入图片描述

    # 重新训练一个模型
    model = build_model()
    # 在所有的训练数据上训练模型
    model.fit(train_data,train_target,epochs = 80,batch_size = 16,verbose = 0)
    test_mse_score,test_mae_score = model.evaluate(test_data,test_target)
    print(test_mae_score)
    
    102/102 [==============================] - 0s 911us/step
    2525.7621256510415
    

    从本例你应该学到以下知识点:

    回归模型的损失函数与分类问题的不同,常用均方差损失函数(MSE)
    相应的,常用的回归模型指标是平均绝对误差(MAE),确切地说,回归模型没有准确度的概念
    输入数据的取值范围不同时,应该在数据预处理阶段将每个特征进行归一化
    当数据样本太少时,可以使用K-fold交叉验证稳定的评估一个模型
    当训练集数据比较少时,倾向于使用小规模神经网络(一般是一到两个隐藏层),避免过拟合

    展开全文
  • 20个有趣的Python深度学习应用程序

    千次阅读 2018-08-16 00:09:14
    来源:大数据技术工程师1.顶级Python深度学习应用程序在这个使用Python的深度学习中,我们将看到使用Python进行深度学习的应用程序。在本文中,我们将讨论Pyt...
  • python深度学习》代码中文注释

    千次阅读 多人点赞 2020-03-31 10:07:13
    python深度学习》由Keras之父、现任Google人工智能研究员的弗朗索瓦•肖莱(François Chollet)执笔,详尽介绍了用Python和Keras进行深度学习的探索实践,包括计算机视觉、自然语言处理、生成式模型等应用。...
  • Python 深度学习

    千次阅读 2018-11-06 11:55:12
    本书由 Keras 之父、现任 Google 人工智能研究员的弗朗索瓦 · 肖莱(Francois Chollet)执笔,详尽介绍了用 Python 和 Keras 进行深度学习的探索实践,包括计算机视觉、自然语言处理、产生式模型等应用。...
  • 我最喜欢的9个 Python深度学习

    万次阅读 2016-07-04 10:31:56
    在这篇文章里,我详细解读了9个我最喜欢的Python深度学习库。 这个名单并不详尽,它只是我在计算机视觉的职业生涯中使用并在某个时间段发现特别有用的一个库的列表。 这其中的一些库我比别人用的多很多,尤其...
  • Python深度学习》随书源码 点击下载
  • 深度解析Python深度学习框架的对比

    千次阅读 2019-03-05 16:08:49
    从PyTorch到Mxnet ,对比这些Python深度学习框架。选择什么深度学习框架一直是开发者非常关心的一个话题,而且深度学习框架之间的「战争」也越来越激烈。过去一段时间,机器之心发过多篇机器学习框架的对比文章,但...
  • Python深度学习 源代码

    千次阅读 2019-07-23 08:37:14
    Python深度学习 Deep Learning with Python [美] 弗朗索瓦·肖莱(Francois Chollet) 链接: https://pan.baidu.com/s/18k8L0xTVfoezEcTht2ZHcQ 提取码: aet7 复制这段内容后打开百度网盘手机App,操作更方便哦 ...
  • 学习深度学习时,我想《Python深度学习》应该是大多数机器学习爱好者必读的书。书最大的优点是框架性,能提供一个“整体视角”,在脑中建立一个完整的地图,知道哪些常用哪些不常用,再据此针对性地查漏补缺就比较...
  • 手把手教你用Python实践深度学习 网盘地址:https://pan.baidu.com/s/183pNoCpUNzu7n82KMolD7A 提取码: 3q7b 备用地址(腾讯微云):https://share.weiyun.com/5yK5a9s 密码:dfnirh 课程共七章,采用最新...
  • 好书推荐计划:Keras之父作品《Python 深度学习

    万次阅读 多人点赞 2018-09-28 11:53:38
    大家好,我禅师的助理兼人工智能排版住手助手条子。可能很多人都不知道我,因为我真的难得露面一次,天天给禅师做底层工作。今天条子终于也熬到这一天!终于也有机会来为大家写文章了...
  • python深度学习实战

    2019-07-10 18:45:36
    学习python而言,最有用的文档是“python库参考手册”,它描述了标准库中的所有模块。在需要获悉一些有关python的事实时,十有八九在这里就能找到。“python库参考手册”(https://docs.python.org/library)可...
  • python深度学习GPU加速方案

    千次阅读 2019-06-01 16:13:08
    深度学习到现在为止没有GPU是万万不行,前面用numpy实现了一个roi pooliing的自定义层,只能说能用,但是速度太慢,所以还没有等网络开始收敛,我自己就受不了了。所以GPU加速是最好是要掌握的,最起码要了解的。 ...
  • 深度学习日益流行的关键因素及其未来潜力 1.1 人工智能、机器学习与深度学习 1.1.1 人工智能 人工智能定义:努力将通过由人类完成的智力任务自动化。 硬编码规则 符号主义人工智能(symbolic AI) 专家系统...
  • Python深度学习中需要几个比较重要的库numpy、pandas。可以直接安装anaconda,安装的同时即可包含这些库。在官网下载即可,并且安装anaconda的时候可以同时安装Python。其中包含工具notebook,一个网页编译环境。 ...
1 2 3 4 5 ... 20
收藏数 146,810
精华内容 58,724
关键字:

python深度学习