TowardsDataScience-博客中文翻译-2016-2018-二百一十二-

TowardsDataScience 博客中文翻译 2016~2018（二百一十二）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

谷歌协作的神经网络|机器学习入门

原文：towardsdatascience.com/neural-netw…

谷歌最近推出了内部工具，用于协作编写数据科学代码。这个名为 Google co laboratory(g.co/colab)的项目基于 Jupyter 开源项目，并与 Google Drive 集成在一起。Colaboratory 允许用户在 Jupyter 笔记本上工作，就像在 Google Docs 或电子表格上工作一样简单。

合作实验室

首先，您可以访问联合实验室网站，并注册以收到使用该工具的邀请。确认邮件通常需要一天时间才会进入你的收件箱。CoLaboratory 让你使用谷歌的一个虚拟机来执行你的机器学习任务和制作模型，而不用担心你的计算能力的限制。而且是免费的。

当你第一次打开 colaboratory 时，你会看到一个 Hello，Colaboratory 文件，其中包含一些你可以用它做的事情的基本示例。我建议你尝尝它们。

使用 colaboratory，您可以像在 Jupyter 笔记本上一样编写代码。您编写并执行(Shift + Enter)代码单元格，并在单元格下获得您的输出。

除了写代码之外，这个程序还有几个锦囊妙计。您可以编写以“！”开头的 shell 命令在笔记本里。 例如，!pip install -q keras。 这让你对谷歌允许你使用的虚拟机有相当大的控制权。这些代码片段可以通过点击左上角的小黑按钮(在菜单下)找到。

我写这篇文章的目的是演示如何使用协同实验室来训练神经网络。我们将通过一个例子，在这个例子中，我们在由 UCI 机器学习库提供的乳腺癌威斯康星州数据集上训练一个神经网络。这里的练习相当简单。

这里是我为这篇文章制作的协作笔记本的链接。

深度学习

深度学习是一种机器学习技术，它使用的计算技术在某种程度上模拟了生物神经元的工作。分层排列的神经元网络从输入到输出来回传递信息，直到它调整其权重，以生成特征和目标之间潜在关系的算法。

要了解更多关于神经网络的知识，你可以参考卡洛斯·格雷申森的这篇非常简单的论文。你也可以在 medium 上找到在线资源。

对于那些还不了解神经网络的人，不要担心。这里的想法是一毫米一毫米地进步。继续…

密码

问题: 研究人员获得了乳腺肿块的细针抽吸(FNA)并生成了它的数字化图像。数据集包含描述这些图像中细胞核特征的实例。每个实例都标有两种诊断中的一种:“M”(恶性)或“良性”)。鉴于上述特征，我们的任务是根据这些数据训练一个神经网络来诊断乳腺癌。

当您打开 colaboratory 时，会看到一个新的 untitled.ipynb 文件供您使用。

Google 允许你在他们的服务器上使用一个虚拟的 linux 机器，这样你就可以访问终端来为你的项目安装特定的包。如果您只是在一个代码单元中传递一个!ls命令(记住在任何命令之前加上！)，你会在你的机器里得到一个名为datalab的文件夹。

我们的任务是将我们的数据集放到这台机器上，以便我们的笔记本可以访问它。你可以用..

一旦你的文件在机器上，你可以检查文件是否在那里。 !ls 你应该看到一个datalab目录和你的文件列表中的“breast_cancer_data.csv”。

数据预处理:

现在我们的数据已经在我们的机器上了，让我们使用 pandas 将它导入到项目中。

This is how the Output looks on Colaboratory

现在，分离因变量和自变量。

y 由一个列组成，列中的“M”和“B”分别代表“是”(恶性)和“否”(良性)。这些需要被编码成数学上相关的形式，即‘1’和‘0’。这可以通过标签编码器类来完成。

(当您遇到两类以上的数据时，请使用 OneHotEncoder)

现在我们的数据已经准备好了，让我们把它分成训练集和测试集。我们使用 Scikit-Learn 中的train_test_split类，这使得工作变得非常容易。

参数test_size = 0.2定义了测试集比例。这里，80%的训练和 20%的测试集。继续前进。

Keras Keras是用于构建人工神经网络的高级 API。它使用 Tensorflow 或the no后端进行其幕后操作。要安装 Keras，您必须在计算机上安装 Tensorflow。联合实验室已经在虚拟机上安装了 Tensorflow。如果你想检查你可以使用的安装

!pip show tensorflow

查看您使用的 tensorflow 版本。如果需要，您还可以使用!pip install tensorflow==1.2安装 Tensorflow 的特定版本

或者，如果你喜欢使用 Theano 后端，你可以在这里阅读文档。

安装 Keras:

顺序类和密集类用于指定神经网络的节点、连接和规格。正如上一节所看到的，我们将需要这些来定制我们的学习网络的参数并对它们进行调整。

为了初始化神经网络，我们将创建一个Sequential类的对象。

现在我们需要设计网络。

对于每个隐藏层，我们需要定义三个基本参数— units、kernel_initializer和activation。units参数定义了该层将包含的神经元数量。Kernel_initializer定义神经元将对数据输入进行操作的初始权重(更多信息请参见)。而activation定义了我们选择用于数据的激活函数。 注意:如果这些术语现在让人不知所措，也没关系。随着时间的推移，它们会变得更加清晰。

第一层:

对于第一层，我们放置 16 个神经元，这些神经元具有由 ReLU 激活函数激活的一致初始化的权重。此外，我们将参数input_dim = 30定义为输入层的规范。请注意，我们的数据集中有 30 个要素列。

作弊: 我们是如何决定层中单位的数量的？人们会告诉你这是一门艺术，需要经验和专业知识。对于初学者来说，一个简单的方法是将 X 和 y 中的列总数相加，然后除以 2。(30+1)/2 = 15.5 ~ 16.于是，units = 16。

第二层:第二层与第一层相同，但没有 input_dim 参数。

输出层:由于我们的输出是两个值中的任何一个，我们可以使用一个具有统一初始化权重的单元。然而，这里我们使用 sigmoid 激活函数(关于激活函数的单独文章即将推出)。

拟合: 运行人工神经网络，让 backprop 魔法发生。你应该在合作实验室而不是你自己的机器上看到所有这些加工过程。

这里，batch_size是您希望同时处理的输入数量。而epoch是你所有的数据通过神经网络一次的整个周期。它是这样出现在合作笔记本上的:

做出预测和混淆矩阵。

一旦您训练了您的网络，您就可以在 X_test 集合(我们之前放在一边)上进行预测，以检查您的模型在新数据上的表现如何。在单元格中键入并执行cm来查看它。

混淆矩阵 混淆矩阵，顾名思义，显示了你的模型做出的正确和错误预测的矩阵表示。当您需要单独调查哪些预测与其他预测相混淆时，该矩阵非常方便。这是一个 2×2 的困惑，马迪克斯解释道。

这就是我们的困惑矩阵的样子。[ cm (Shift+Enter)]

这是怎么读的: 70 真阴性， 1 假阳性，1 假阴性， 42 真阳性。很简单。当分类类别的等级增加时，方阵的大小增加。

就像这个例子一样，我们有几乎 100%的准确率。只有两个错误的预测。这一点也不坏。但情况可能并不总是如此。其他时候，你可能需要投入更多的时间，调查你的模型的行为，并提出更好、更复杂的解决方案。如果网络表现不佳，可以进行超参数调整来改进模型。我将很快就这个话题写一整篇文章。

我希望这能帮助您开始使用 Colaboratory。在此找到本教程的笔记本。

注:本文重点介绍 协同 的使用，并举例说明。对于一些读者可能没有理解清楚的概念的详细解释，我表示歉意，并请求您等待更多的文章。

预测精度和速度最佳的神经网络

原文：towardsdatascience.com/neural-netw…

深度神经网络目前被脸书、谷歌、苹果等公司使用。从大量用户生成的数据中进行预测。几个例子是脸书用于人脸识别和文本理解的深度人脸和深度文本系统，或者 Siri 和 Google Now 使用的语音识别系统。在这种类型的应用中，使用既快速又准确地进行预测的神经网络至关重要。这意味着，在设计这些系统时，我们希望调整不同的神经网络参数，以共同最小化两个目标:1)对一些验证数据的预测误差和 2)预测速度**。要调整的参数，也称为设计参数，可以是隐藏层的数量、每层神经元的数量、学习速率、正则化参数等。**

最小化预测误差和预测速度涉及解决多目标优化问题。在这种类型的问题中，一般来说，不存在单一的最优解来共同最小化不同的目标。相反，有一个称为帕累托前沿的最优解集合。

Example of Pareto front. Each point in the plot shows the objective values (f1 and f2) obtained for a particular setting of the design parameters. The points highlighted in blue are in the Pareto front.

帕累托前沿中的点实现了目标之间的最优权衡，也就是说，你不能通过改善一个目标而不损害另一个目标，从帕累托前沿中的一个点移动到另一个任意点。上图显示了两个目标 f1 和 f2 的帕累托前沿示例。图中的每一点都显示了对设计参数的特定选择所获得的目标值。当解决多目标优化问题时，我们感兴趣的是找到映射到 Pareto 前沿点的设计参数值。一旦我们找到了帕累托前沿的点，我们就可以做出决定，选择一个满足我们要求的点。

在神经网络调整问题中，对于设计参数的特定设置的预测误差的评估是计算上昂贵的过程。其原因是，在能够计算验证误差之前，我们必须首先在大量训练数据上训练神经网络。对于大型神经网络和大规模数据集，这个过程可能需要几个小时甚至几天。这意味着，理想情况下，我们希望使用少量的客观评估来找到帕累托前沿。这可以通过使用贝叶斯优化** (BO)技术来完成。这些方法使用模型的预测来有效地搜索昂贵的优化问题的解决方案。在这篇文章中，我将描述如何使用 BO 方法预测熵搜索进行多目标优化**

埃尔南德斯-洛巴托、埃尔南德斯-洛巴托、沙阿和亚当斯。 预测熵搜索多目标贝叶斯优化， ICML，2016。【pdf】留兰香代号

用于在 MNIST 数据集上寻找具有最优预测误差与预测速度的深度神经网络。PESMO 是当前最先进的技术，用于具有昂贵目标函数的多目标优化。关于 BO 方法的更多信息，读者可以参考[1，2]。

寻找能对 MNIST 做出快速准确预测的网络

PESMO 是在 spearmint 工具的 PESM 分支中实现的，可以通过上面显示的链接公开获得。在我们的系统中安装了 PESM 绿薄荷分公司之后，我们必须指定我们想要解决的多目标优化问题。在我们的案例中，我们将调整神经网络中的以下设计参数:

1. 隐藏的层数。
2. 每个隐藏层的神经元数量。
3. 辍学水平。
4. ADAM 优化器使用的学习率[3]。
5. L1 体重处罚。
6. L2 体重处罚。

这些信息在一个名为 config.json 的文件中提供给 spearmint，该文件包含优化问题的详细信息，例如要调整的变量、它们的最大值和最小值、我们将优化多少个目标、如何评估目标等。我们将使用以下 config.json 文件:

{
    "language"        : "PYTHON",
    "random_seed"     : 1,
    "grid_size"       : 1000,
    "max_finished_jobs"       : 100,
    "experiment-name" : "MNIST_neural_networks",
    "moo_use_grid_only_to_solve_problem" : true,
    "moo_grid_size_to_solve_problem" : 1000,
    "pesm_use_grid_only_to_solve_problem" : true,
    "likelihood"      : "GAUSSIAN",
    "acquisition"     : "PESM",
    "pesm_pareto_set_size"      : 50,
    "pesm_not_constrain_predictions"     : false,
    "main_file"       : "evaluate_objectives",
    "variables": {
        "n_neurons": {
            "type": "FLOAT",
            "size":  1,
            "min":  50,
            "max":  500
        }, "n_hidden_layers": {
            "type": "FLOAT",
            "size": 1,
            "min":  1,
            "max":  3
        }, "prob_drop_out": {
            "type": "FLOAT",
            "size": 1,
            "min":  0,
            "max":  0.9
        }, "log_learning_rate": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }, "log_l1_weight_reg": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }, "log_l2_weight_reg": {
            "type": "FLOAT",
            "size": 1,
            "min": -20,
            "max":  0
        }
    },
    "tasks": {
      "error_task" : {
          "type"        : "OBJECTIVE",
          "fit_mean"    : false,
          "transformations"     : [],
          "group"    : 0
      },
      "time_task" : {
          "type"        : "OBJECTIVE",
          "transformations" : [
                {"IgnoreDims" : { "to_ignore" : [ 2, 3, 4, 5 ]   }}
                ],
          "fit_mean"    : false,
          "group"    : 0
      }
    }
}

我将描述这个文件中的几个重要条目。条目 main_file 包含将被调用来评估不同目标的 python 脚本的名称。条目 max_finished_jobs 的值为 100。这表明绿薄荷评估不同的目标 100 次，然后完成。条目变量包含设计参数的描述，以及它们的最大值和最小值。条目任务包含待优化目标的描述。注意，预测时间不依赖于参数丢失、学习率、L1 罚值和 L2 罚值。我们通过在预测时间目标的目标转换中使用条目 IgnoreDims 来通知 spearmint。

下一步是编写评估不同目标的 python 脚本。我们已经告诉 spearmint，这个文件叫做 evaluate_objectives.py ，它包含以下基于 Keras 的代码[4]:

import numpy as np
import time
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import Adam
from keras.utils import np_utils
from keras.regularizers import l1l2, l2, activity_l2

def build_model(params):

    n_hidden_layers = int(np.round(params['n_hidden_layers'][ 0 ]))
    n_neurons = int(np.round(params['n_neurons'][ 0 ]))
    log_l1_weight_reg = params['log_l1_weight_reg'][ 0 ]
    log_l2_weight_reg = params['log_l2_weight_reg'][ 0 ]
    prob_drop_out = \
        float(params['prob_drop_out'][ 0 ].astype('float32'))
    log_l_rate = params['log_learning_rate'][ 0 ]

    model = Sequential()
    model.add(Dense(n_neurons, input_shape = \
        (784,), W_regularizer=l1l2(l1 = np.exp(log_l1_weight_reg), \
        l2 = np.exp(log_l2_weight_reg))))
    model.add(Activation( 'relu'))
    model.add(Dropout(prob_drop_out))
    for i in range(n_hidden_layers - 1):
        model.add(Dense(n_neurons, \
            W_regularizer=l1l2(l1 = np.exp(log_l1_weight_reg), \
            l2 = np.exp(log_l2_weight_reg))))
        model.add(Activation( 'relu'))
        model.add(Dropout(prob_drop_out))
    n_classes = 10
    model.add(Dense(n_classes))
    model.add(Activation( 'softmax'))
    adam = Adam(lr=np.exp(log_l_rate), beta_1=0.9, \
        beta_2=0.999, epsilon=1e-08)
    model.compile(loss='categorical_crossentropy', optimizer=adam)

    return model

def evaluate_error_model(X_train, Y_train, X_test, Y_test, \
    X_val, Y_val, params):

    nb_epoch = 150
    batch_size = 4000
    model = build_model(params)
    model.fit(X_train, Y_train, batch_size = \
        batch_size, nb_epoch=nb_epoch, \
        show_accuracy=True, verbose=2, \
        validation_data=(X_val, Y_val))
    loss, score = model.evaluate(X_val, Y_val, \
        show_accuracy=True, verbose=0)
    print('Val error:', 1.0 - score)
    return np.log((1 - score) / score)

def evaluate_time_model(X_train, Y_train, X_test, Y_test, \
    X_val, Y_val, params):

    nb_epoch = 1
    batch_size = 500
    model = build_model(params)
    start = time.time()
    for i in range(100):
        predictions = \
            model.predict_classes(X_val, \
            batch_size=X_val.shape[ 0 ], verbose=0)
    end = time.time()
    print('Avg. Prediction Time:', (end - start) / 100.0)
    return (end - start) / 100.0

def main(job_id, params):

    nb_classes = 10
    (X_train, y_train), (X_test, y_test) = mnist.load_data()
    X_train = X_train.reshape(60000, 784)
    X_test = X_test.reshape(10000, 784)
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255

    state = np.random.get_state()
    np.random.seed(0)
    suffle = np.random.permutation(60000)
    i_train = suffle[ 0 : 50000 ]
    i_val = suffle[ 50000 : 60000 ]
    np.random.set_state(state)
    X_val = X_train[ i_val, : ]
    y_val = y_train[ i_val ]
    X_train = X_train[ i_train, : ]
    y_train = y_train[ i_train ]

    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_test = np_utils.to_categorical(y_test, nb_classes)
    Y_val = np_utils.to_categorical(y_val, nb_classes)

    evaluation = dict()
    evaluation['error_task'] = \
        evaluate_error_model(X_train, \
        Y_train, X_test, Y_test, X_val, Y_val, params)
    evaluation['time_task'] = \
        evaluate_time_model(X_train, Y_train, X_test, \
        Y_test, X_val, Y_val, params)

    return evaluation

注意，在函数 build_model 中，我们将变量 n_neurons 和 n_hidden_layers 四舍五入为整数**，spearmint 假设它们是连续的。同样，在这个脚本中，函数 evaluate_error_model 返回错误的逻辑值，而不是错误本身。logit 变换扩大了接近零的值的误差变化范围，并允许 spearmint 使用的高斯过程模型更好地描述收集的数据。一旦我们完成了 config.json 和 evaluate_objectives.py 文件的编写，我们将使用 spearmint 来解决优化问题。让我们假设当前工作目录包含文件 config.json 和 evaluate_objectives.py**

$ python /path_to_spearmint_folder/main.py .

其中 path_to_spearmint_folder 是到我们已经安装了 spearmint 的 PESM 分支的文件夹的路径。然后，绿薄荷将评估这两个目标 100 次。在每一次评估之后，留兰香都会提出一个建议，其中包含几个有望位于帕累托前沿的点。一般来说，这些建议的质量随着绿薄荷收集的数据量的增加而提高。因此，一般来说，我们只会对最后一个建议感兴趣。所有的推荐都由 spearmint 存储在一个 mongodb 数据库中。我们可以通过使用 python 脚本extract _ recommendations . py来提取最后一个建议:

import os
import sys
import numpy as np

from spearmint.utils.parsing          import parse_config_file
from spearmint.utils.database.mongodb import MongoDB
from spearmint.tasks.input_space      import InputSpace

def main():

    options         = parse_config_file('.', 'config.json')
    experiment_name = options["experiment-name"]
    input_space     = InputSpace(options["variables"])
    db              = \
        MongoDB(database_address=options['database']['address'])

    i = 0
    recommendation = db.load(experiment_name, \
        'recommendations', {'id' : i + 1})
    while recommendation is not None:
        params_last = \
            input_space.vectorify(recommendation[ 'params' ])
        recommendation = \
            db.load(experiment_name, \
            'recommendations', {'id' : i + 1})
        i += 1

    np.savetxt('pareto_front.txt', params_last, fmt = '%e')

if __name__ == '__main__':
    main()

我们将这个脚本存储在与 config.json 文件相同的文件夹中，并使用

$ python extract_recommendations.py

脚本 extract_recommendations.py 在文件 pareto_front.txt 中存储估计位于 Pareto 前沿的设计参数值。然后，我们可以使用脚本 evaluate_objectives.py 在推荐点评估目标，并选择最符合我们要求的一个。下图显示了 PESMO 和其他现有 BO 方法在 50 次重复优化过程中获得的平均 Pareto 前沿。总的来说，PESMO 能够找到比替代技术在预测精度和预测速度之间具有更好平衡的神经网络。通过可视化帕累托前沿，如图所示，我们还可以做出更好的决定，从帕累托前沿选择哪些点。

Comparison of PESMO with other BO techniques in the task of finding neural networks that make accurate and fast predictions on the MNIST dataset. Each axis represents a different objective and the curves show the Pareto front produced by each method. On average, the Pareto front recommended by PESMO dominates all the others.

分离评估

在前面的例子中，我们总是在相同的输入位置一个接一个地评估两个目标。然而，在实践中，这两个功能可以以分离的方式进行评估，即独立地在不同的位置进行评估。请注意，为了评估验证数据的预测误差，我们必须首先训练神经网络。然而，训练对于评估预测时间不是必需的，这可以使用具有任意权重值的神经网络来完成。这允许我们将这两个目标的评估分离。在这个解耦的设置中，在任何给定的时间，我们可以选择评估预测误差或预测时间。一般来说，考虑这样的具有解耦目标的优化问题可以产生显著的收益，特别是当目标之一的评估是昂贵的并且关于优化问题的解决方案不是非常有用的时候。有趣的是，PESMO 还允许用解耦的目标来解决多目标优化问题。关于解耦函数求值的优化问题的更多细节可以在上面所示的 PESMO 参考文献或[5]中找到。[6]中给出了解耦贝叶斯优化在约束设置中的应用示例。在这项工作中，带约束的预测熵搜索( PESC ) [7]用于优化统计机器翻译系统的准确性，同时确保解码速度超过最小值。

参考

1. Brochu，Eric，Vlad M. Cora 和 Nando De Freitas。关于昂贵成本函数的贝叶斯优化的教程，应用于主动用户建模和分层强化学习， arXiv 预印本 arXiv:1012.2599 (2010)。
2. Shahriari，Bobak 等人将人类带出循环:贝叶斯优化综述，IEEE 会议录104.1(2016):148–175。
3. 金玛，迪德里克和吉米巴。 Adam:一种随机优化的方法。 arXiv 预印本 arXiv:1412.6980 (2014)。
4. keras.io
5. 埃尔南德斯·洛巴托 J. M .、盖尔巴特 M. A .、亚当斯 R. P .、霍夫曼 M. W .和加赫拉马尼 Z. 使用基于信息的搜索进行约束贝叶斯优化的通用框架，《机器学习研究杂志》，(出版中)，2016 年。【pdf】
6. 丹尼尔·贝克、阿德里亚·德·吉斯佩特、贡萨洛·伊格莱西亚斯、奥雷连·韦特和比尔·伯恩。使用贝叶斯优化的统计机器翻译的速度受限调优。 arXiv 预印本 arXiv:1604.05073 (2016)。
7. 埃尔南德斯-洛巴托 J. M .、盖尔巴特 A. M .、霍夫曼 M. W .、亚当斯 r .和加赫拉马尼 Z. 未知约束条件下贝叶斯优化的预测熵搜索，ICML，2015。【【补充素材】【python 代码】

逻辑门的神经表示

原文：towardsdatascience.com/neural-repr…

static.pexels.com/photos/3929…

逻辑门即“与”、“或”、“非”是过去十年来每一项技术突破的组成部分，尤其是在硬件方面。

在这个项目中，我们将使用神经网络的基础知识来表示逻辑门。我用 numpy 创建了一个感知器，它用数据集作为感知器的输入来实现这个逻辑门。

第一部分:逻辑门

首先，我们必须熟悉逻辑门。

逻辑门是 数字电路 的基本构件。大多数逻辑门有两个输入和一个输出。在任何给定的时刻，每个终端都处于两种二进制状态之一:低(0)或高(1)，由不同的电压电平表示。当电路处理数据时，终端的逻辑状态可以经常改变，通常也确实如此。在大多数逻辑门中，低态大约为零伏(0 V)，而高态大约为正五伏(+5 V) 。如 techtarget 所述

最常见逻辑门是与、或、非。如果两个输入都是 1，则逻辑“与”门仅返回 1，否则返回 0；如果所有输入都是 1，则逻辑“或”门返回 1；如果两个输入都是 0，则仅返回 0；最后，逻辑“与”门不返回输入的反相，如果输入是 0，则返回 1；如果输入是 1，则返回 0。为了清楚起见，下图显示了基本门的真值表。

A 列和 B 列是输入，Z 列是输出。因此，对于输入 A = 0，B = 0，输出为 Z = 0。

第二部分:感知器

感知器是神经网络的基本部分。感知器代表人脑中的单个神经元，它由数据集(Xm)、权重(Wm)和激活函数组成，然后将产生输出和偏差。数据集(输入)被转换为一个 n array，然后与另一个保存权重的 n array 进行矩阵相乘。将所有矩阵相乘相加并加上一个偏差将创建净输入函数，然后输出将传递到一个激活函数，该函数将确定神经元是否需要触发输出。用于分类的最常见的激活函数是 sigmoid 函数，这是一个很好的分类函数(虽然 sigmoid 不是神经网络中间层的主要激活函数[ ehem ReLU / Leaky ReLU ],但它仍然广泛用于最终分类。)

上图是 sigmoid 函数的曲线。模型的输出作为“z”传递到 sigmoid 中。简单来说，如果模型(z)的结果是负数，sigmoid 函数返回 0–0.4，如果模型是正数，返回 0.5–1。

3。代码

对于代码，我们将从导入 numpy 开始。Numpy 是一个内置数学函数的库，非常适合做矩阵乘法和科学编程。(在这里了解更多关于 numpy 的信息:【www.numpy.org/】T2)

然后，我们将创建一个感知器函数，它将充当前面显示的图像中的感知器。该函数将接受权重矩阵、偏差和数据集矩阵。“np.dot(x，weight)”矩阵将数据集与来自输入的权重相乘，然后“np.add()”将矩阵乘法的输出与偏差相加。“1/(1+np.exp(-model)”表示激活函数，将模型传递到 sigmoid 函数中。

注意:由于我们这个项目的目标是将感知器表示为逻辑门，我们将对激活函数的输出进行舍入，以使输出仅为 1 或 0，但出于实际目的，舍入输出是一个很大的错误，小数给出的小信息有助于为下一个将处理信息的神经元添加信息。更不用说消失和爆炸梯度，但这是另一个故事

创建感知器后，我们需要为它填充输入。函数 compute 会执行此操作，因为数据集和权重还不是数组，我们将在这里执行此操作。它接受 logictype ( "logic_and "、" logic_or "等)来标记机器正在进行的计算，接受 weightdict，这是一个保存所有权重和偏差的字典，最后接受 dataset 参数

计算函数将为数组中的每个数据集返回感知器函数的结果

下面的要点是逻辑门 AND 和逻辑门 OR 的输出样本。

神经逻辑项目到此结束。需要注意的是，为了引入感知器的基本功能，项目权重是手动设定的，尽管优化将是找到该问题正确权重的最佳答案，因此如果输入变大，神经网络可以正确回答该问题。

要了解更多信息，您可以访问该知识库:https://github . com/fjcamillo/Neural-Representation-of-Logic-Functions/blob/master/Logic . py

神经类型转移:在数据扩充中的应用

原文：towardsdatascience.com/neural-styl…

Different Styles of a Coffee Cup

神经风格转移是一个非常令人兴奋的深度学习应用。由卷积神经网络模型中的一系列卷积层创建的表示可以被解构，使得内容和风格可以分离。这种分离形成了 gram 矩阵，该矩阵可以用作生成器网络的损失函数(从随机向量映射到高度 x 宽度 x 颜色通道输出图像)。这个模型可以用来做一些事情，比如将文森特·范·高夫的艺术风格转化为一张普通的照片。

在我对数据扩充方法的研究中，(寻找人为地将数据添加到小数据集以形成大数据集的方法)，我一直对风格转移如何作为数据扩充方法起作用感兴趣。

风格转移是一种有趣的增强技术。它有点类似于颜色变换，但是，它能够传递纹理和其他各种扭曲，这是经典的颜色过滤器或仿射变换所无法实现的。

有一篇非常有趣的论文，对用于数据扩充的样式转移进行了实验，题目是:

风格扩充:通过风格随机化的数据扩充

作者:菲利普·杰克森、达勒姆大学的阿米尔·阿塔普尔-阿巴戈韦、斯蒂芬·邦纳、托比·布雷肯和博古斯瓦夫·奥巴拉。

本文将风格增强总结为一种“随机化纹理、对比度和颜色，同时保留形状和语义内容”的方法。

“基于图像的数据扩充的最普遍形式包括几何失真，例如随机裁剪、缩放、旋转、翻转、线性强度缩放和弹性变形。虽然这些在教导模型的旋转和比例不变性方面是成功的，但是颜色、纹理和复杂的光照变化呢？”

这是一个非常有前景的数据增强转换，尽管有各种各样的平移不变性和失真，我们仍然希望学习图像的语义内容。因此，我们应用一系列保留标签的转换来提高数据集的质量。

有趣的是，本文讨论的实验实际上并不是从一组风格图像中抽取风格样本，而是多元正态分布。我发现这有点令人困惑，我将坚持用一组不同风格的图片来做我自己的实验。

原始的神经类型转移算法需要大量的计算，因此不是数据扩充的好解决方案。然而，一种称为快速神经风格转移的新风格转移算法的开发极大地加快了进行风格转移所需的时间，“只需通过风格转移网络进行一次正向传递，该网络由风格嵌入参数化。”

此外，本文还重点研究了迁移学习中的领域适应任务。这就是从大型网络中学到的低级特征转化为新问题的地方。这个想法是，风格增强将有助于这个大型网络学习更好的迁移学习功能。根据该论文，“我们的方法通过增加数据将更多的变化引入源域，这可以增强模型的整体鲁棒性，从而更好地推广到许多潜在的目标域，而不需要来自它们的数据”。

结论

总之，我强烈推荐你亲自看看这篇论文，“风格增强:通过风格随机化的数据增强”！风格转移增强是一种非常令人兴奋的数据增强技术，用于学习更多样的不变性和领域转移。我很高兴能尝试一下，看看这是如何发展的。感谢阅读！

CShorten

Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对计算机视觉、深度学习和软件工程感兴趣。

神经类型转移教程-第 1 部分

原文：towardsdatascience.com/neural-styl…

神经风格转移理论

在这篇文章中，你将使用自下而上的方法学习，我们将从神经类型的基础开始。对于初学者，我们将详细介绍它到底是什么，以及它为什么有效。这篇文章是正在进行的系列文章的第一篇，我将与帕万·萨桑卡·阿玛纳曼奇合著。这个系列看不到尽头，我们将努力最终覆盖这个领域的研究，并不断增加新的作品。坚持到底的先决条件是:

1].计算机编程语言

2].基本了解卷积网络的工作原理。如果你对它们不太了解，我们建议这里的这篇文章。

风格转移是什么意思？

在过去的几年中，我们已经看到了大量的应用程序，如 prisma 和其他类似的应用程序，它们以一种看起来像绘画的方式来设计你的照片。为您提供各种美丽的风格，其中一些是著名艺术家的画作，如梵高的《星夜》。试图用语言来解释这个概念可能会很困难。

Figure 1

正如您在图 1 中看到的，有两个输入图像，即内容图像和样式图像，用于生成一个新的图像，称为风格化图像。关于这个图像需要注意的几件事是，它具有与内容图像相同的内容，并且具有与样式图像相似的样式。它看起来很好，我们非常确定它不是通过重叠这两张图像实现的，那么我们如何实现这个想法呢？为了回答这些问题，我们需要后退一步，关注卷积神经网络实际上学习什么？这些卷积层以特征图或内核的形式真正编码是什么，让它们这样做，或者换句话说，当我们输入图像时，CNN 学习什么表示，让我们先试着理解一下。

卷积神经网络最初是为图像分类而创建的，最近已用于各种其他任务，如图像分割、神经风格和其他计算机视觉以及自然语言处理任务。CNN 是深度学习中最容易解释的模型之一，因为我们有能力可视化它们的表示，并理解它们可能在学习什么。

卷积神经网络能提供哪些洞察？

在这一节中，我想分享一些关于 CNN 深层如何表示图像的直觉，以及我们如何使用这种只对模型有意义的计算表示，以利于我们开发神经类型转移。让我们以 VGG16 架构来理解隐藏层中的这种表示。

Figure 2

使用上述架构作为参考，让我们考虑 vgg16 的第一卷积层，它使用 3×3 内核并训练 64 个特征映射，通过将大小为 224×224 的 3 通道图像作为输入来生成 224×224×64 的图像表示。如果你有点困惑，请看下面

Figure 3

让我们假设，在训练这 64 个特征图时，它们可能已经学会了检测简单的模式，例如，当它们看到一条直线或甚至一些其他类型的模式时，一些神经单元会激活，这些模式对人眼来说可能没有任何意义，但对该模型具有巨大的价值。这种对直线或某种模式的“检测”被称为学习特征表示。

现在让我们考虑 vgg16 的第 10 卷积层，其使用具有 512 个特征图的 3×3 内核进行训练，并最终生成 28×28×512 图像表示的输出，只是为了简单起见，让我们假设在该第 10 层中有某些单元被包含像汽车车轮这样的圆圈的图像激活，或者可能有一些被具有类似于三条相交线等的某种图案的图像激活。

Figure 4 Visualizing and understanding convolutional networks

可以肯定的是，CNN 没有学会对图像进行编码，但它实际上学会了对图像表示的内容或图像中可见的内容进行编码，并且由于神经网络固有的非线性性质，我们从浅层到深层，隐藏单元变得能够从给定图像中检测越来越复杂的特征。

这些图像表现如何有助于风格转移？

编码表示本身的这种性质是风格转换的关键，它用于计算生成的图像相对于内容和风格图像之间的损失。当在每类上万幅图像上训练模型时，该模型能够为许多不同的图像生成相似的特征表示，只要它们属于同一类或者具有相似的内容或风格。因此，使用所生成的图像相对于内容和样式图像的特征表示的值的差异来指导迭代是有意义的，通过该迭代，我们产生所生成的图像本身，但是我们如何确保内容图像(C)和所生成的图像(G)在它们的内容而不是样式方面是相似的，而另一方面，我们如何确保所生成的图像仅从样式图像继承相似的样式表示，而不是整个样式图像本身。这可以通过将损失函数分成两部分来解决，一部分是内容损失，另一部分是风格损失，很快我们就会明白它们是如何彼此不同的，以及它们是如何克服我们已经提出的问题的。

损失函数

Figure 5

正如你在上面的等式中所看到的，我们需要计算两件事情来获得整体损失，即内容损失和风格损失，alpha 和 beta 超参数用于为每种类型的损失提供权重，即这些参数可以简单地视为控制我们希望在生成的图像中继承多少内容/风格的旋钮。那么，让我们来了解一下，每个损失项意味着什么。

上面显示的这个损失函数的输入是什么？我们不知道最终的输出会是什么样子。所以监督学习的天真方法可能行不通。答案就在下图中。

Figure 6 - Different Representations used for Content, Style and Generated Image

在每次迭代期间，所有三个图像，即内容图像、样式图像和生成的图像都通过 vgg16 模型。隐藏单元的激活值对特定层的给定图像的特征表示进行编码，作为这些损失函数的输入，用更简单的术语来说，你可以直接认为这是取 VGG16 网络中的层的输出，在层的选择上没有任何硬性规则。这里还要补充一点，最初我们随机初始化生成的图像，如果你看它，它只不过是一个形状与内容图像相同的随机噪声矩阵。在每次迭代中，我们都会改变生成的图像，以尽量减少总损失 l。

**注意:**这里在每个卷积层之后，它的输出通过 relu 作为它的激活函数，你也可以在图 2 中查看每个卷积块被表示为[卷积+ Relu ]

内容丢失

内容损失很容易计算，我们只取其中一层的特征表示，我们考虑 vgg16 的第 7 卷积层。为了计算内容损失，我们通过 vgg16 传递内容图像和生成的图像，并获得这两个图像的第 7 conv 层的激活值(即输出),其具有用于其激活的 Relu，我们将该层的输出一般表示为 relu_3_3，因为它是第三卷积集/块的第三 conv 层的输出(参考图 2 和 6)。最后，我们发现这两个激活矩阵之间的元素减法的 L2 范数，这将有助于通过确保最小化特征表示中的差异来保存生成的图像中的原始内容，该特征表示在逻辑上关注两个图像的内容之间的差异。

把这种损失用数学形式或者一个我们可以计算的方程来表达。假设我们有函数 Content loss，它接受三个参数作为输入，即内容图像 C ，生成的图像 G 以及我们将使用其激活来计算损失的层 L。现在让我们将内容图像的每个激活层表示为a【L】(C)，将生成图像的激活层表示为a【L】(G)。

Figure 7

风格丧失

现在让我们看看样式损失，在计算样式损失时，我们将考虑从模型的浅层到深层的许多卷积层的特征表示。与内容损失不同，我们不能只找到激活单元的差异，我们需要的是一种方法来找到同一层的不同通道之间的这些激活之间的相关性，为此我们需要一种称为 Gram Matrix 的东西。

什么是克矩阵？

我将通过一个示例尝试建立理解 gram 矩阵所需的基础，因此让我们考虑通过 vgg16 传递我们的样式图像，并从第 7 层获取激活值，生成大小为 56x56x256 的特征表示矩阵，您可以参考描述 vgg16 架构的图 2。现在让我们仔细看看这个输出。

Figure 8

在这个三维阵列中，有 256 个通道，每个通道的大小为 56×56。现在让我们假设有一个通道“A ”,当它们遇到包含黑色和棕色条纹的图像部分时，其激活单元可能被激活；然后有一个通道“B ”,当它们遇到类似眼球的东西时，其激活单元可能被激活。

**注:**此处被激活的单元是指通过 relu 后具有相对于零相当大的值。

如果这两个通道‘A’和‘B’对于相同的输入一起激活，则图像很可能包含老虎的脸(因为它有两个高值的通道，这两个通道激活眼球和棕黑色条纹)。现在，如果这两个通道都以高激活值启动，这意味着与通道“A”和“C”之间的相关性相比，它们将具有高相关性，其中通道“C”在看到菱形图案时可能会被激活。因此，为了获得所有这些通道之间的相关性，我们需要计算一种叫做 gram 矩阵的东西，我们将使用 gram 矩阵来测量通道之间的相关程度，这将在以后作为风格本身的度量。现在你可能已经理解了 gram 矩阵的意义，但是要理解我们如何通过下面提到的图片得到上面提到的三维数组的 gram 矩阵。

Figure 9 - Gram Matrix G

现在，您可以看到这个 gram 矩阵的每个元素如何包含所有通道相互之间的相关性度量。接下来，我们如何使用计算出的 Gram 矩阵 G 来计算风格损失。让我们将层 L 的样式图像的 gram 矩阵表示为 GML，将同一层的生成图像的 gram 矩阵表示为 GML。两个 gram 矩阵都是从同一层计算的，因此使用相同数量的通道，使其成为大小为 ch x ch 的矩阵，现在如果我们找到这两个矩阵的平方差之和或元素差的 L2 范数，并尝试将其最小化，那么这将最终导致样式图像的样式和生成的图像之间的差异最小化。想想看，这可能需要一些时间来适应，但当它适应后，你会被它的简单而有效所迷惑。

Figure 10 — Style Loss of single layer L

上式中， N 下标 l 表示图层lM下标 l 表示图层 l 的特征映射/输出的高度*宽度。

在计算风格损失时，我们使用多个激活层，这种情况使我们有可能为不同层提供的每个子损失分配不同的权重。下面的等式，很好地总结了我刚才说的，但是在我们的情况下，或者大多数情况下，人们通常给所有的层相同的权重。

Figure 11

接下来是什么？

向前移动，一旦你有内容和风格的损失，把它们加起来，并使用任何优化程序来执行梯度下降，以改变生成的图像，使其减少每次迭代后的损失。

这差不多总结了，我希望我的解释足以消除你对神经风格基础的任何疑虑。现在你可以深入到 neural style 的代码中，我将检查我的代码的每一行，并正确地剖析它，但是下面提到的伪代码几乎概括了你将要运行和使用的代码的所有内容。

S = Style_img
C = Content_img
G = random_initialization( C.size() )

下面的内容和样式层是原文中建议的常用层，但是你也可以尝试其他层。

# content_layers
C_Lys = [“relu_3_3”]# style_layers
S_Lys   = [“relu_1_2”, “relu_2_2”, “relu_3_3”, “relu_4_3”]alpha = 0.5 # content loss weight
beta  = 0.5 # style loss weightfor i = 1 to no_iteration = 1000:
   Loss = alpha*C_loss(C_Lys, C, G) + beta*S_Loss(S_Lys, S, G)
   minimize(loss).change(G)show_image(G)

这就是神经风格的本质。如果你对本文的任何部分还有疑问或者想要更好的解释，请在下面评论，我会尽我所能尽快回复你。

快乐学习！

链接。到原创神经风格转印纸 Leon A. Gatys 的论文，一种艺术风格的神经算法。

你可以期待接下来的文章在不久的将来被写出来。

Tensorflow 和 pyTorch 的神经类型转移课程:

1. 第一部分神经类型迁移理论
2. 第二部分——神经风格转移的实现
3. 第三部分:快速神经风格转换的实现
4. 第四部分深度照片
5. 第五部分:人脸的神经类型转移理论
6. 第六部分:人脸神经风格转换的实现

感谢您阅读本文！

如果你认为我们是志同道合的人，应该联系，那么你可以在 LinkedIn 上找到我，或者发电子邮件到 vamshikdshetty@gmail.com 找我。如果您有任何想法、问题或反馈，请在下面随意评论，我很乐意收到您的来信。

NeuralFunk -将深度学习与声音设计相结合

原文：towardsdatascience.com/neuralfunk-…

完全用神经网络产生的样本制作轨迹

Cover for NeuralFunk, designed by Nuevo.Studio

很长一段时间以来，我一直想把我对音乐的热情与我在人工智能领域的工作结合起来。但我一直拖着。我觉得在尝试让深度学习参与这个过程之前，我需要首先提高我的音乐制作技能。

但后来在 9 月中旬，我看到在今年的神经信息处理系统 ( NIPS )会议上，将有另一个关于 机器学习促进创意和设计 的研讨会，这可以说是人工智能社区每年最大的事件。艺术品和音乐的提交截止日期是 10 月底。

那件事，以及与 Nao Tokui 在同一时间喝了几杯啤酒的聊天，激励着我最终振作起来，停止使用借口，开始做一些事情。我有大约一个月的时间在研讨会的最后期限前完成一些事情。

结果是 NeuralFunk ，一个完全基于样本的轨迹，其中所有的样本都是由深度神经网络生成的。

它并没有像我最初打算的那样变成一首典型的 Neurofunk 曲目，而是发展成了一首相当独特的曲目。黑暗、混乱、疲惫，几乎让听者窒息，没有时间休息和呼吸。NeuralFunk 就像它产生的方式一样是实验性的。

【更新:NeuralFunk，以及我的另一首作品被 NIPS 工作室接受，你现在也可以在 Spotify 上听它和我的其他歌曲[。]](open.spotify.com/artist/5gsj…)

接下来我想告诉你这个项目是如何产生的，从深度学习和音乐制作的角度。

如果你只对其中一个方面感兴趣，可以跳过其他部分。我还将分享一些代码和生成的示例的链接。

但是在讨论任何细节之前，我想对为此做出贡献的人们表示衷心的感谢。 Alvaro 设计封面图片，Makoto与我分享他的样本库， Nao 在几个场合激励我开始这个项目，最后最重要的是 D.A.V.E. 与我在赛道上的合作(但稍后会有更多)。谢谢你们，你们太棒了！

神经机能障碍的起源

我最初进入电子音乐制作是通过手指打鼓，这仍然是我主要如何定义自己作为一个制作人。所以我最初把深度学习和音乐结合起来的想法其实很不一样。

我不打算制作完整的音轨，甚至不打算制作任何音频。相反，我在考虑现场表演的有趣想法。具体来说，我正在考虑一个系统，它可以确定音频样本之间的相似性，这样我就可以自动将声音替换为其他相似的声音。

举个简单的例子:我可能有一个特殊的军鼓声音，但我想用一个相似但略有不同的声音来代替它。

在一个更具实验性的环境中，我可能想记录我的观众或某个场所的随机声音场景，然后自动从中提取声音来替换我正在使用的实际样本。这样，我就可以从一首完全基于精心制作和人工挑选的样本的曲目逐渐转变为更加有机和随机的曲目，甚至可能与观众互动，这仍然可以保持其原始的声音特征。

除了是一个很酷的性能工具，寻找相似样品的好方法也可以在生产过程中有很大帮助。几乎每个生产者都知道，在不断增长的库中找到完全正确的样本是多么痛苦和耗时的过程，这些样本通常分布在许多随机的目录和嵌套的子目录中。

一年多以前，当我把这个想法告诉 Makoto 的时候，他非常友好地把他的大规模样本库给了我，让我去玩。然而在那个时候，我并没有走得很远。在摆弄了一会儿之后，我又回到了我的老借口上，首先专注于音乐制作本身。

但是现在我终于有了一个很好的理由快速完成一些事情:NIPS 研讨会的最后期限。

然而，我认为我最初的想法是不可能实现的，因为我只有一个月的时间来完成这个项目。深度学习部分不会是一个问题，但为现场表演开发后端和制定一个有趣的例程将需要更多的时间，特别是因为我还没有太多关于 Max for Live (或任何其他可以为此工作的开发环境)的经验。

相反，我决定制作一首歌曲。

我的主要流派是鼓和贝斯。而 Neurofunk 的亚属，鉴于它的名字也是曲目名称的灵感，看起来就像一个完美的匹配。

Neurofunk 通常是鼓和低音的一个黑暗和侵略性的分支。除此之外，它的特点是非常精细和复杂的声音设计，尤其是低音线。最近有一个很好的例子，看看文档一 中的“*LSD”*中 0:44 左右开始的低音。对于更“传统”的神经放克，请查看由 InsideInfo 和mef jus提供的 脉动。

这种复杂的声音设计似乎也符合我使用神经网络的意图。然而，大多数 Neurofunk 制作人严重依赖复杂的波表或 FM 合成来精心塑造他们的声音。完全基于样本可能具有挑战性。此外，Neurofunk 往往非常精确和尖锐。我不确定神经网络方法会给我的声音带来这两种属性。

尽管如此，我还是准备迎接挑战。此外，样本只是起点。

虽然我给自己设置了限制，即每个声音都必须来自神经网络生成的样本，但我没有对可以对它们使用的效果或后期处理设置任何限制，给我留下了很多自由来塑造声音。

在这方面，我认为 NeuralFunk 不同于大多数其他人工智能辅助音乐生成的方法。

在许多情况下，人们要么像在 中演奏 RNN ，让 AI 模型通过 MIDI 生成音符序列，要么使用深度学习来合成特定的乐器，像 NSynth 。

通过深度学习合成所有的声音，然后从中产生一首歌曲，这是我迄今为止从未遇到过的事情，尽管如果我是第一个这样做的人，我会感到非常惊讶。虽然这可能是第一首以这种方式创作的鼓与贝斯音轨。

结果显然不是 AI 做的音乐。但它是使用人工智能作为声音设计和探索创造性表达新方法的工具制作的音乐。

深度学习阶段

有了这个非常粗略的想法，下一步就是要弄清楚使用什么样的网络来实际生成样本。

还不太确定我想把这个带向什么方向，我再次从脑那里得到了一些灵感。他有一个 iPython 笔记本，用于根据声谱图进行声音分类。我对声音分类不感兴趣，但我认为一些预处理可能会有用，所以我开始尝试一下，将我库中的一些样本转换成光谱图。

这就是项目 NeuralFunk 真正开始的时候，9 月 21 日有了这个阿门突破的声谱图。

在那之后，我决定从实际的神经网络开始，一个好的(也是很明显的)地方是使用一个基本的 WaveNet ，在我的样本库上训练它，看看会有什么结果。

我从收集不同样本目录中的所有样本开始。主要是 Makoto 的样片，还有我的 Maschine 2 库，还有资料片 共振火焰前景阴霾解码形态 (顺便强烈推荐)。我真的很感谢 Native Instruments，因为他们将样本直接作为 wav 文件提供，而不是深埋在软件中。

然后，我将它们全部转换为 16kHz，并对任何超过 10 秒的部分进行了修整。有一些较长的循环和完整的轨道和茎，但我决定忽略这些，除了他们的开始。

最后，我得到了大约 62，000 个样本(尽管我很久以后才发现，我本可以得到更多的样本，因为我的自动搜索只寻找与。wav”和”。aiff”，漏掉了很多变奏像“的。WAV“，”。aif”等)。

接下来，我采用了 Wavenet 的 TensorFlow 实现，并简单地根据该数据对其进行了训练。考虑到数据的巨大差异，我并不期待惊人的结果，但这是一个开始，值得一试。事实上，我最终得到了一些有趣的结果。尽管正如预期的那样，它主要只是(不完全是随机的)噪音。

为了让 Wavenet 有更好的机会了解它应该生成什么数据，我决定添加一个条件网络。

除了音频文件本身，我还为每个文件的前三秒创建并保存了一个声谱图。我最初的计划是添加一个完整的卷积编码器网络，它将与 Wavenet 端到端地进行训练，将频谱图作为附加输入，并将其压缩为条件向量。

不幸的是，至少在我的快速实验中，这被证明是一项太难的任务，Wavenet 只是在频谱编码器可以学习任何有用的东西之前学会了忽略条件向量。这似乎是太强大的解码器阻止编码器学习的许多情况之一。也许通过一些更好的参数调整，这个过程可以工作。但我没有时间进行大范围的参数搜索。

然而，在摆弄 Wavenet 的同时，我仍然没有放弃寻找样本之间相似性的最初想法。我的想法是，我可以使用 Wavenet 来生成大量的随机样本，然后使用相似性搜索来找到与我喜欢的特定参考声音接近的声音。

所以为了让相似性搜索起作用，我还写了一个变分自动编码器(VAE ),它是在相同的光谱图上训练的。我可以简单地通过比较潜在空间中的距离，使用得到的嵌入来进行相似性搜索。

但是这个模型实际上允许我做更多的事情。

我可以使用 VAE 嵌入作为波网的条件向量，而不是用波网端到端地训练编码器，这样会得到更好的结果。Wavenet 现在清楚地利用了条件信息，它的输出具有它所依赖的声音的许多特征。

但除此之外，我可以使用 VAE 解码器本身来重建频谱图，然后使用 Griffin-Lim 算法来映射回音频。

任何关注过我在 AI 上的文章或者看过我演讲的人都知道我真的很喜欢 VAEs。他们可能是我最喜欢的一类模特。从信息论的角度来看，它们不仅在概念上很漂亮，非常优雅，而且用途极其广泛。

在这里，单个模型允许我创建嵌入，我可以用它来调节另一个模型，使我能够进行高级语义搜索，以及实际上自己生成新的声音。

它也很容易训练，只需要几个小时我的 iMac 的 CPU 就可以收敛。这个模型本身也很简单。这实际上是我第一次从零开始写一个反进化网络，所以我很快就把它拼凑了起来，但它似乎很有效。

鉴于时间短暂，我并不真正关心优化。一旦事情有了转机，我就继续前进。我做的任何事情都不严谨。我甚至没有费心将我的数据分成单独的测试或验证集。

我给 VAE 添加的唯一一个稍微花哨的东西是一些正常化流动层的 T2。再说一次，我的实验并不严谨，但是增加几个流动层似乎可以从质量上得到更好的结果。

我做了 64 维的嵌入(没有原因，只是选择了这个数字作为我的第一个测试，它有点工作，我从来没有尝试过其他任何东西)。但是使用 TSNE，我可以把维度减少到二维来可视化。

原始样本没有任何类别标签，所以我使用文件名提取了一些近似的标签，在名称中查找类似“kick”和“sfx”的单词。结果出乎意料的好。这是我选择的八个类别之一的所有样本的可视化。

实际上，我很惊讶这些簇的效果有多好，以及哪些簇与哪些簇相邻(比如拍手、帽子、军鼓过渡)。

我做了另一个可视化，包括所有的样本(也就是文件名中没有匹配标签的样本)。

结果不是很好，但这可能部分是因为我没有时间或耐心摆弄 TSNE 参数，只是拿了我得到的第一个结果；)

更深入地研究一下细节，甚至直接在二维空间进行嵌入，可能会带来一些有趣的见解，但我会把这些留到以后再说。

VAE 的所有代码，以及一些预处理和其他随机位可以在这里找到。

但是如果你对代码感兴趣，请注意。这不是真的要分享。它非常粗糙，评论很差(如果有的话)，很多东西都硬编码到我的音频处理参数和目录结构中。我可能会在某个时候着手处理这个问题，但是现在要意识到它相当的混乱。

我没有分享我的 Wavenet 代码，因为我尝试的所有更复杂的东西实际上都不工作，而且工作的东西实际上只是对原始实现的一个小修改，它允许直接读取和馈入预先计算的嵌入向量。npy”文件，并使用它们进行调节。

样本生成阶段

所有的模型都准备好了，我可以开始制作一些声音了。

首先是 VAE 和格里芬-林的组合。本质上，它给了我三种发声的方法。

最简单的方法是对声谱图进行编码，再次解码，然后重建音频。这个古钢琴样本就是一个例子。我们可以看到，基频得到了很好的保留，但许多其他细节发生了变化。

这个哔哔声是另一个很好的例子。同样，基本频率和整体轮廓被保留，但很多更好的细节被改变或丢失。

第二种方法是实际上结合两个或更多的嵌入，然后解码产生的潜在代码。一个很好的例子，实际上最终形成了一个主要的旋律元素，就是底鼓和声乐音符的结合。

结果是一个相当不错的和声，但在开始时，踢声增加了一些有趣的 subby 攻击，产生了一个不错的 stabby synth 声音。

这是另一个例子，结合三个不同的输入。

生成的样本是一个踢音，就像其中一个输入一样，但是有很多来自踩镲和 tabla 的有趣字符。

最后，我也可以不需要任何输入，直接从潜在空间简单取样。这导致了许多有趣的结果。

其中一些是清晰可辨的声音类型，而另一些则更加随意和实验性，但作为声音效果仍然有用。

我想说的是，在这一点上，我遵循了一个非常清晰和深思熟虑的产生和设计声音的过程。但是考虑到时间有限，我实际做的是编写一个脚本，从 0 到 3 之间随机选择一个数字，然后从我的库中随机选择这么多输入样本，嵌入它们(或者如果输入样本的数量为零，则从潜在空间中采样一个嵌入)，组合它们，并生成最终的音频。

这样我产生了几千个半随机样本。

我做的最后一件小事是，记录我说“Taktile”(我的艺术家名字)和“NeuralFunk”，然后通过 VAE 解码器和 Wavenet 运行这两个样本，以获得基于每个样本的两个样本。

结果并不真正像人声，但它们作为声音效果进入了轨道(例如，第一次下降时的 techy 声音实际上是“Taktile”样本之一)。

我对 Wavenet 采用了几乎完全相同的方法。

在 0 和 3 之间选择一个随机数，随机选择预先计算的条件嵌入的数量(或从高斯分布中随机采样一个)并将它们组合成一个条件向量，然后让 Wavenet 为每个生成 32，000 个样本(2 秒)。

我又一次用这种方法产生了几百个随机的声音片段。

有趣的是，Wavenet 似乎理解条件反射的一般声音特征，但不理解时间信息。由于它不仅训练了单镜头，还训练了完整的循环和节拍，所以它产生了一些非常有趣的输出。

例如，给定一个单一的打击乐声音作为条件，结果有时实际上是由相似类型的打击乐声音组成的完整节拍(例如，如果条件是在小军鼓上，则是小军鼓节拍)。

如果我继续从事这项工作，我可能想尝试的一件事是，不要对整个频谱图进行编码并将其用作全局条件，而是对单个时间片进行编码，然后将其作为局部条件馈入 Wavenet，以便对声音的时间方面进行更多控制。

但是现在，我仍然有很多有趣的样本可以玩。

对于这两个网络来说，似乎很难产生的一件事是崩溃、打开的踩镲声和其他类似铙钹的声音。我没有特意尝试产生这些，但在我的随机样本中，我没有发现令人信服的钹音。

但我想，鉴于其复杂的声音特征，钹一直是对合成器更具挑战性的声音之一。也许这可以成为未来实验的另一个有趣的方向。Wavenet 在这方面似乎更有前景，因为 VAE 解码器(至少我的 hacky 版本)的升级洗去了所需的更精细的细节。

您可以在这里下载所有样本。zip 文件中有两个目录，分别对应于 Wavenet 和 VAE 样本。

对于 VAE，以“random”开头的文件名是基于我的库中随机样本的文件。那些以“sampled”开头的直接从潜在空间采样的代码中解码。对于每个音频文件，我还包括一个输出频谱图的 png，以及输入频谱图(如果有任何输入)。

Wavenet 目录包含对应于四个不同模型的四个子目录。“generated_1”和“generated_2”是无条件模型，而“generated_emb2”和“generated_emb_big2”是条件模型(末尾的数字是指我用来训练它们的批量)。

对于有条件的文件，文件名包含作为条件的原始文件。例如“generated_emb_big2”中的“emb 2 _ 13727—StylusBD08 023 _ 9519—Kick JunkieXL 3 . wav”是以“stylusbd 08 023”和“Kick JunkieXL 3”两个文件为条件的(其他数字指的是我自己的内部索引系统)。这个特殊的文件实际上是一个很好的例子，其中两个简单的踢音的组合，都是一个镜头，导致一个完整的基于踢的节拍。

你可以随意使用这些样本。如果你因此想出了一些很酷的东西，我很想听听！

生产阶段

生成了成千上万个样本后，终于到了开始制作并把它们变成类似音乐的东西的时候了。

事实上，我也在这个月搬到了一个新公寓。虽然因此损失了相当多的时间，但我至少享受到了在一个崭新的(最初)整洁的工作环境中工作的快乐。

虽然我最近开始更多地进入 Ableton Live，但我决定在 Native Instrument 的 Maschine 中做这个项目，因为这仍然是我迄今为止最舒适和熟悉的 DAW。我只是非常偶尔地切换到生活，因为它的惊人的扭曲工具。

最初的生产阶段相当痛苦。即使我有我的 VAE 作为一个相似性搜索工具，它目前的版本有很多缺点，使它对这项任务相当无用。例如，它只考虑样本的开始。但是特别是在 Wavenet 的情况下，文件中常常隐藏着一些有趣的部分。

出于这个原因，我实际上不得不手动浏览所有的样本，找到有趣的声音。这花了我整整两个晚上的时间，每个晚上花几个小时来检查所有的声音，并把我发现的有趣的声音按照声音类型粗略排序，即打击乐、旋律、无人机、SFX 和低音。然后，我进一步检查了鼓组，并根据鼓的声音类型对每个样本进行了颜色编码，例如，红色代表鼓脚，绿色代表小军鼓，等等。

最后，我把所有的踢腿，陷阱和帽子复制到不同的组，这样我可以在以后一起处理它们。

最后，我有了 20 多个不同的组，每个组有 16 个样本，总共有 320 多个我认为有趣的样本。

但是这还不是乏味的预处理的结束…正如我提到的，有趣的声音通常不在样本的开始。我必须进去分离出我真正想要的部分。

即使是简单的鼓声，看起来是从样本的开头开始的，它们也经常会有一些令人讨厌的伪像，我不得不去掉几毫秒。

接下来是非常粗糙的造型。我是想让声音一次性播放(也就是说，一旦被触发就一直播放)还是 ADSR(当声音不再播放时就逐渐消失)？如果是 ADSR，我必须设置攻击、衰减、持续和释放参数。

此外，相当多的样本，尤其是 VAE 产生的样本，有一些令人不快的高频噪声，因此我应用了一些低通滤波器来消除这些噪声。

最后，为了以一致的调子写这首曲子，在这种情况下(主要是)F 小调，我必须通过单独改变音高来调整旋律样本。

有了这些，几个小时后，基本的准备和预处理终于完成了，我可以开始做音乐了。

我做的第一件事就是布置了一个 阿门破 。我想这么做是因为作为一名鼓手和低音制作人，这是用新声音演奏时最自然的事情。但我也想重新采样，这样我就可以把它切碎，然后作为早餐。

结果是一个相当好听的阿门休息(除了最后一个蹩脚的响钹)。对于附带的图像，我认为这将是一个很好的触摸运行原来的“阿门，兄弟”封面通过deep dream；)

点击此处或下图收听。不幸的是，Instagram 嵌入似乎不起作用，所以我只是链接到它。

接下来，我在周一请了一天假，完全专注于这个项目。我早早起床，精神饱满，冲了杯咖啡，坐在办公桌前。然后…

没什么！不管我做了什么，听起来都很糟糕。我试图开始放下一些鼓，但没有得到任何东西听起来很好。然后我想也许可以从一些旋律开始。或者低音。但是无论我从哪里开始，我就是不能得到任何像样的东西。

我早期尝试更多的声音设计，给样本添加滤镜、效果和调制，听起来也很糟糕。

那天中午左右，我感到完全失去了动力，认为这个项目注定要失败。我决定去散步。

我之前已经提到过步行的创造力。这里再次证明了这一点。当我大约一小时后回来，再次坐在我的办公桌前时，神奇的事情发生了。我完全进入了状态，一切似乎都自然而然地走到了一起。

到了晚上，我并没有真正意识到已经过了很长时间，我已经完成了很多声音设计，并且对音轨有了大致的感觉。我还准备了后来成为引子的大部分内容。

在接下来的几天里，我做了很多微调，并在介绍中加入了额外的元素。但是每当我试图超越它时，我又感到被卡住了。

幸运的是，当我告诉我的好友 D.A.V.E. 这个项目的时候，他立刻表示愿意合作。

D.A.V.E .不仅是一个了不起的 DJ 和制作人，他还是一个很棒的老师，他在这首歌上给了我很多帮助。我强烈推荐看看他的东西，他有一些非常酷的教程和其他东西在不久的将来会出现(我们两个之间甚至可能会有更多的合作)。

[## 数字和黑胶唱片专家

D.A.V.E .是 DJ 兼导师。在所有平台和软件上工作。D.A.V.E 教授 DJ 表演的所有方面和…

www.digitalandvinylexpert.com](www.digitalandvinylexpert.com)

因此，在这一点上，已经形成了对赛道的总体想法和感觉，但在其他方面陷入了困境，我将它交给了 D.A.V.E .他立即投入其中，并在第二天向我发送了他的一些想法和想法。

在他加入之前，我特别纠结于介绍之后的结尾。他建议尝试在中场休息时做，几乎给它一种陷阱的感觉，并奠定了一些节拍，我后来建立了。

他还想出了一些 synth 部分，老实说，第一次听我真的觉得有点烦人，但后来我完全喜欢上了，经过一些修改，变成了我最喜欢的元素之一。

这是合作的一个很酷的地方。即使你不总是完全喜欢或同意你的合作者所做的，它也会给你新的想法，帮助你摆脱困境。你可以修改它，让它成为你自己的，最后想出一些你自己做梦也想不到的很酷的东西。

在接下来的几天里，我们来来回回地更新项目。事实上，我们在完全不同的时区(D.A.V.E .在伦敦，我在东京),这对协调工作很有帮助。晚上(我的时间)下班后，我们会通个电话，讨论一下想法，然后我会在赛道上工作几个小时。晚上结束的时候，我会把我最新的版本发给他，第二天早上我起床的时候，他已经给我回复了一些新的想法。

最终，在大约一周的时间里，NeuralFunk 长成现在的样子。这根本不是我在开始这个项目时设想的那种 Neurofunk 曲目，但无论如何它总是意味着在实验方面。

下面是(几乎)最终安排在机械。这绝对是我做过的分组和图案最不同的 Maschine 项目。我糟糕的(或者更确切地说，几乎不存在的)命名方案也无助于这个项目的发展。

有很多事情我想改变或改进，特别是低音和其他低频元素相当混乱，但没有时间了。

所以最后我决定就此结束，尽情享受，尽情享受。要看我现场即兴创作的视频，请点击这里或下面的图片。

总的来说，我认为这个项目非常有趣。老实说，我唯一完全满意的部分是引言，如果有更多的时间，我可能会删除很多东西并重新制作，但考虑到时间限制以及样本本身的实验性质，我认为结果并不太坏。

顺便说一下，这篇文章也是如此。我想尽可能快地把它写下来，并在 NIPS 研讨会的最后期限之前基本上与轨道一起发布，所以它没有经过太多的编辑，并达到我通常写作的目标质量。很抱歉。如果你坚持到这里，谢谢你忍受我的长篇大论！

从现在开始，我可以把它带向很多方向。其中一些我已经在上面提到过了，还有更多的我想到了。

例如，我想改进 VAE 的编码器/解码器架构，从像对待任何其他图像一样对待频谱图的简单(解)卷积网络，到考虑沿两个轴的不同信息的东西。

我还在考虑回到我最初的想法，将相似性搜索(甚至可能是样本生成)集成到一些有趣的现场表演工具中。

但首先，我需要休息一下，补上一些睡眠！

顺便说一下，如果你对我更多的音乐感兴趣，也可以看看我上一首歌，它是用更传统的方式制作的！；)

你觉得这个项目怎么样？知道我下一步该做什么吗？我也很想知道你是否尝试过类似的事情，或者把我的一些想法或样本用在你自己的音乐中。

发挥创造力！

简化的神经网络！

原文：towardsdatascience.com/neuralnetwo…

courtesy- here

你等了多久才实现你的第一个人工神经网络，却找不到正确的资源和简单的解释？嗯，在这里。在阅读这篇文章之前，我建议你先了解一下我上一篇文章中的神经网络，这样接下来的解释就很容易理解了。

在深入研究神经网络之前，我想讨论一下神经网络的一般应用，以便回答这个问题- 在现实生活中，我在哪里可以找到适用的神经网络？

courtesy- here

现实生活中的应用:

courtesy- here

1. 你在哪里听说过预测股票市场价格的机器吗？是的，太酷了，不是吗？由于神经网络确实擅长处理复杂数据并帮助分析这些数据，因此股票预测是神经网络无缝工作的应用之一。此类预测型应用，如资产评估、员工工作表现等。大量使用神经网络。
2. 在图像处理和计算机视觉的应用中，神经网络比传统的灰度转换方法有更好的优势，这是最重要的。图像到文本、图像恢复、图像压缩、模式识别或者最著名的所有对象检测和面部识别，仅仅是几个主要的例子。

courtesy- here

3.生成对抗网络( GAN)是神经网络可以自己生成图像的另一个应用。这对于精确的图像生成和两幅图像的合并是非常有益的。这是神经网络的最新应用，并被广泛研究。

4.语音识别、天气预测、指纹识别、手写识别等。还有其他使用神经网络的小规模应用吗？

5.医疗诊断是一种可以利用神经网络进行重大改进的应用。

你能猜出神经网络在你日常生活中的应用吗？

它被你几乎每天使用的手机和应用程序所使用。这就是——手机摄像头中的自动面部识别是卷积神经网络最常用的例子，脸书的自动面部识别和谷歌照片应用程序中的照片都是基于这些卷积神经网络的典范。这里的应用程序列表可以是无止境的。

现在我们知道神经网络是一个大奖！我相信你现在可能对了解神经网络更感兴趣。

如何着手这个博客……

我想阐述一个正常的人工神经网络背后的理论概念和逻辑，以及实际的实现，这实际上加深了我们对理论的理解。因此，我把整个博客分成了实际实现的部分，它背后的理论和用来实现它的逻辑。它都是一个连续流程的实现的一部分，但只是为了更好地理解和关联而对部分进行了区分。

你知道神经网络的想法实际上是怎么产生的吗？

它的灵感来自于我们人类自己的生物神经网络！该工作完全类似于一层又一层神经元的有效工作，以形成生物神经网络。对于人工神经网络来说，流程和操作质量都是从生物神经网络模拟的，因为我们需要建模的基本原理是模拟人脑从示例中学习的功能，正如我在以前的 博客 中提到的。

我们就这样开始……

我们使用 Tensorflow 库中从 0 到 9 分类手写数字的最著名的 MNIST 数据集来用 Python 实现 ANN 模型。

前提:

Tensorflow 是 Python 中用于神经网络实现的最有效和最有用的库。我更喜欢用 Jupyter 笔记本来实现。但是你可以使用任何你选择的 IDE——Spyder，Sublime Text 3 等等。

在开始程序之前，我们需要安装 Tensorflow。安装非常容易，可以从这里安装。普通台式机可以下载 CPU 版本。

完整的代码和输出截图可以在我的 github 这里找到。随意叉！

理论和术语:

为了理解这一点，我们需要在这里介绍 4 个基本术语:

1. 感知器:它只不过是一个简单的层神经网络，受一个生物神经元的启发，如下图所示。

courtesy-towardsdatascience.com/from-fictio…

2。 **输入:**输入无非是我们要馈给网络的数据。通常定义为 x1，x2，…xn。每个输入都是用于确定输出的样本或独立变量。输入可以是任何形式——文本、图像或整个视频。这里我们有手写数字的图像作为输入。

**3。输出:**输出是为激发激活的相应神经元生成的。

4。 **激活功能:**输入信号经过激活功能后，可以进一步被其他层处理或者直接产生输出。激活功能本质上可以被称为用于处理输入以获得输出的处理单元。它用于根据激活功能的类型将输出映射为 0 到 1 或-1 到 1。有各种类型的激活函数，包括 s 形函数、阶跃函数、指数函数等。

输入象征着生物神经元的树突，树突是神经元将信息从一个神经元传输到另一个神经元的接收器。类似地，根据所定义的功能，其他相似之处如下。

courtesy- here

实现:

Import Dependencies

接下来，我们导入我们的依赖项 Tensorflow 和 MNIST 数据，我们将使用这些数据提前进行训练。

Read data

接下来，我们读取数据集并保存到变量“mnist ”,指定 path 作为第一个参数，one_hot 作为 TRUE。现在你可能会想什么是热点。

应用中使用的逻辑:

对于输入:

本质上，在人工神经网络模型实现中，神经元只不过是保存数值的占位符，就像这里一样，我们在神经元中存储了从 0(黑色)到 1(白色)的灰度值。

这些神经元共同形成黑白图像输入。

courtesy-gfycat.com/gifs/tag/ne…

对于输出:

One_hot 设置为 true，以便在我们获得相应的输出时激活输出节点。

例如，这里我们有 10 个可能结果的总数，因为我们有 0-9 个数字要识别。因此，对于作为输入提供的任何输入图像，对应于由我们的模型识别的每个输出的 10 个神经元中的任何一个都将被点亮。举个例子，

对于数字 0=[1 0 0 0 0 0 0 0 0 0]，

对于数字 1 =[0 1 0 0 0 0 0 0 0 0 0 0]等等…

其中该阵列包含相应输出神经元的一组二进制值。

所以我们得出结论，

神经网络的第一层总是输入层，而最后一层总是输出层。

理论和术语:

那么处理实际发生的中间层呢？

这些层只不过是隐藏层。这是所有魔法的开始！

人工神经网络是受生物神经网络的启发，生物神经网络由多个神经元组成，它们同时工作并协调为我们的身体执行各种任务。因此，为了更好的性能，我们在人工神经网络中也有多层神经元。我们越深入越好，但是对于一个小的数据集来说，这将是一个问题。

那么如何决定要使用的隐藏层数呢？

可以有任意多的隐藏层，但这也取决于数据集的大小。虽然随着网络变得更深，隐藏层的数量越多越好，但对于较小的数据集，这将降低而不是提高精度。

实施:

我们为我们的模型选择了 3 个隐藏层，500，600，300 分别是该层中的节点总数。

Defining total number of nodes in hidden layers

Defining variables

稍后，我们定义输出类的总数、批量大小和张量(占位符),以变量的形式定义输入 x 和输出 y。

应用中使用的逻辑:

处理隐藏图层:

类似于生物神经元，在 ANN 中，具有特定灰度值的 784 个输入神经元仅触发(触发)下一个隐藏层中的特定神经元，这又会触发下一个隐藏层中的一些模式，并最终触发输出层中的特定模式。网络选择最亮的神经元作为最终输出。

courtesy- here

本质上，隐藏层的作用是将数字分成单独的环和线，形成数字。例如，下面我们看到 9 有一个环和一条线，它们组合在一起形成数字。因此，在不同的层产生特定的图案，这不同于为具有 2 个循环的 8 产生的图案。因此，我们需要更深的网络来识别具有不同特征和巨大图像的更大数据集的关键模式。

courtesy- here

简而言之:

像素— >边缘— >图案— >数字

理论和术语:

现在，我们如何让我们的模型只激发特定模式的特定神经元？

答案是通过使用“权重”和“偏见”。

**5。权重:**权重不过是生物神经元中的轴突。我们在图像中看到的轴突用于将信息从一个神经元传递到另一个神经元。它只不过是连接环节。这是一个非常重要的信息，因为权重决定了要传递的信号的激发和抑制。简单地说，它遵循奖惩方式，即兴奋引起一个神经元激活另一个神经元，反之则抑制。这与神经网络中信息的生物传递是一样的。

**6。偏置:**它可以被视为一个开关，这个开关总是打开的，也就是说它的值总是 1。基本的想法是，人类神经元接受一堆输入并将它们“相加”在一起。如果输入的总和大于某个阈值，那么该神经元将“触发”(产生一个输出到其他神经元)。这个阈值本质上与偏差是一回事。因此，通过这种方式，人工神经网络中的偏差有助于复制真实的人类神经元的行为。

实施:

因此，我们首先为每个隐藏层和输出层定义随机权重和偏差，以确定该层的神经元总数。

Define weights and biases

定义完所有变量后，我们开始使用权重和偏差定义模型和各层的功能。

Activation function

应用中使用的逻辑:

对于该层中的给定模式，我们分配某些正权重来激励/激发神经元，分配负权重来抑制/停止激发神经元。

为了以数学方式计算这些值，我们将输入乘以整个图层的相应权重，最后将其与偏差相加:

加权总和=(权重输入)+偏差*

然后，我们将这个加权和馈送给被称为“RELU”的激活函数，该激活函数被称为整流线性单元。激活的阈值简单地为零。

它计算函数 f ( x )=max(0， x )。这是深度学习中最常用的激活功能，因为它大大加速了训练部分。

理论和术语:

那么“深度学习”这里的学习部分到底在哪里呢？

如果你还记得，我们最初初始化了随机权重和偏差，因为我们在开始时没有意识到它们。

我们的最终目标是最小化预测输出时引起的误差。因此，学习特别意味着以误差最小化的方式来确定这些权重和偏差。这是由优化器完成的。

这里，我们使用 Adam Optimizer 优化我们的模型，以最小化成本。Adam Optimizer 使用随机梯度方法来优化我们的模型。使用不同的方法还有各种其他的优化器。

实施:

定义模型后的最后一部分是定义模型应该如何训练。

我们预测每个输入 x 的输出，然后通过将预测值与数据集中标记的正确值 y 进行比较来确定模型的成本/误差。

Prediction of output

我们定义用于循环的会话，直到达到总的历元数。我们一起批量训练输入并运行优化器。

最后，我们使用“正确的”变量来对照期望值检查预测输出的 one_hot 值。

最后通过计算和打印模型的精度来验证模型的有效性。

最后一行是用输入 x 和输出 y 调用训练函数来启动训练。

应用中使用的逻辑:

我们的模型自己训练多长时间？

该模型保持训练，直到误差达到预定义的阈值，或者通过定义所需的总时期(循环)。

我们可以调整许多参数，如隐藏层数、节点数或使用的优化器等。检查并降低错误率。

本质上，神经网络的工作可以概括为:

Summarizing the process

courtesy- here

唷！这对初学者来说有点难，不是吗？

我知道开始时的感觉:/

但是相信我，一旦我们在练习后彻底掌握了它，一切都会变得很简单。如有任何疑问，请在下面评论。让我知道你对这篇文章的看法，以及你希望我接下来发表的任何话题。

NIPS/NeurIPS 2018:前两次海报会议的最佳*

原文：towardsdatascience.com/neurips-201…

Photo by Rohan Makhecha on Unsplash

NeurIPS 是一个伟大的会议，吸引了机器学习研究几乎每个方面的最新技术。

在会议中，该领域的研究人员当然应该注意一些事情。在我看来，这些东西会把类似的研究文章聚集成这些组。 理解，二。必需品，3。进步，4。大问题/未来

所以，我把所有我认为有影响的事情归为这些类别。这些是 neur IPS 2018 A&B 周二海报会议的海报及其摘要。

1.谅解

甘人生而平等吗？大规模研究

回顾

尽管大量的研究活动产生了许多有趣的 GAN 算法，但仍然很难评估哪些算法的性能优于其他算法。我们对最先进的模型和评估方法进行了中立的、多方面的大规模实证研究。我们发现，通过足够的超参数优化和随机重启，大多数模型都可以达到相似的分数。这表明，除了基本的算法变化之外，更高的计算预算和调整也能带来改进。为了克服当前度量的一些限制，我们还提出了几个数据集，在这些数据集上可以计算精度和召回率。我们的实验结果表明，未来的氮化镓研究应基于更系统和客观的评估程序。最后，我们没有发现任何测试算法始终优于在{ cite good fellow 2014 generate }中介绍的不饱和 GAN 的证据。

卷积神经网络的一个有趣的失败和 CoordConv 解决方案

有意思，时间差不多了

我们已经展示了 CNN 对坐标转换任务建模的奇怪无能，展示了 CoordConv 层形式的简单修复，并给出了表明包括这些层可以在广泛的应用中提高性能的结果。在 GAN 中使用 CoordConv 产生的模式崩溃更少，因为高级空间延迟和像素之间的转换变得更容易学习。在 MNIST 检测上训练的更快的 R-CNN 检测模型显示，当使用 CoordConv 时，IOU 提高了 24%,并且在强化学习(RL)领域中，玩 Atari 游戏的代理从 CoordConv 层的使用中显著受益。

具有稀疏和量化通信的分布式深度学习的线性加速分析

效率

巨大的通信开销已经成为分布式随机梯度下降(SGD)训练深度神经网络的性能瓶颈。先前的工作已经证明了使用梯度稀疏化和量化来降低通信成本的潜力。然而，对于稀疏和量化通信如何影响训练算法的收敛速度，仍然缺乏了解。本文研究了非凸优化的分布式 SGD 在两种减少通信量的策略下的收敛速度:稀疏参数平均和梯度量化。我们证明了如果稀疏化和量化超参数配置得当，可以达到 O (1/√ MK )的收敛速度。我们还提出了一种称为周期量化平均(PQASGD)的策略，在保持 O (1/√ MK )收敛速度的同时，进一步降低了通信开销。我们的评估验证了我们的理论结果，并表明我们的 PQASGD 可以像全通信 SGD 一样快地收敛，而通信数据大小仅为 3 %- 5%。

关于单词嵌入的维度

授权

在本文中，我们提供了一个单词嵌入及其维度的理论理解。受单词嵌入酉不变性的启发，我们提出了一种新的度量单词嵌入不相似性的方法——成对内积损失。使用来自矩阵扰动理论的技术，我们揭示了在单词嵌入的维度选择中的基本偏差-方差权衡。这种偏差-方差的权衡揭示了许多以前无法解释的经验观察，例如最佳维度的存在。此外，揭示了新的见解和发现，如词嵌入何时以及如何对过拟合具有鲁棒性。通过优化 PIP 损失的偏差-方差权衡，我们可以明确地回答用于单词嵌入的维度选择的公开问题。

欺骗计算机视觉和限时人类的对立例子

基本面

机器学习模型容易受到对抗性例子的影响:图像的微小变化可能导致计算机视觉模型出错，例如将校车识别为鸵鸟。然而，人类是否容易犯类似的错误仍然是一个悬而未决的问题。在这里，我们通过利用最近的技术来解决这个问题，这些技术将来自具有已知参数和架构的计算机视觉模型的对立示例转移到具有未知参数和架构的其他模型，并且通过匹配人类视觉系统的初始处理来解决这个问题。我们发现，在计算机视觉模型中强烈传递的对立例子会影响受时间限制的人类观察者所做的分类。

树状皮质微电路近似反向传播算法

洞察

深度学习在过去几年中取得了显著的发展，其中许多都是受神经科学的启发。然而，这些进步背后的主要学习机制——错误反向传播——似乎与神经生物学不一致。在这里，我们介绍了一个多层神经元网络模型，该模型具有简化的树突区室，其中错误驱动的突触可塑性使网络适应全局期望的输出。与以前的工作相比，我们的模型不需要单独的阶段，突触学习是由局部树突预测误差在时间上连续驱动的。这种错误起源于顶端树突，是由于来自外侧中间神经元的预测输入和来自实际自上而下反馈的活动之间的不匹配而发生的。通过使用简单的树突隔室和不同的细胞类型，我们的模型可以代表锥体神经元内的错误和正常活动。我们证明了该模型在回归和分类任务中的学习能力，并分析表明它近似于误差反向传播算法。此外，我们的框架与最近对大脑区域和皮质微电路结构之间学习的观察一致。总的来说，我们介绍了一种关于树突皮层回路学习的新观点，以及大脑如何解决长期存在的突触信用分配问题。

关于神经元容量

新颖的提法

我们将学习机的能力定义为它能够实现的功能数量(或容量)的对数。我们回顾了已知的结果，并得出了新的结果，估计了几种神经元模型的容量:线性和多项式阈值门，带约束权重(二进制权重，正权重)的线性和多项式阈值门，以及 ReLU 神经元。我们还推导了完全递归网络和分层前馈网络的容量估计和界限。

深度生成模型中的偏差和泛化:一项实证研究

真正的理解

在高维设置中，密度估计算法主要依赖于它们的归纳偏差。尽管最近取得了经验上的成功，但深度生成模型的归纳偏见并没有得到很好的理解。在本文中，我们提出了一个框架，通过使用精心设计的训练数据集探索学习算法，来系统地研究图像深度生成模型中的偏差和泛化。通过测量学习分布的属性，我们能够发现有趣的概括模式。我们验证这些模式在数据集、通用模型和架构之间是一致的。

批处理规范化如何帮助优化？

视角

批处理规范化(BatchNorm)是一种广泛采用的技术，能够更快更稳定地训练深度神经网络(DNNs)。尽管 BatchNorm 无处不在，但它有效的确切原因仍然知之甚少。普遍认为，这种有效性源于在训练期间控制层的输入分布的变化，以减少所谓的“内部协变量移位”。在这项工作中，我们证明了层输入的这种分布稳定性与 BatchNorm 的成功几乎没有关系。相反，我们揭示了 BatchNorm 对训练过程的一个更基本的影响:它使优化前景明显更加平滑。这种平滑导致梯度的更具预测性和稳定性的行为，从而允许更快的训练。

基于神经样本的概率群体代码

神经编码

感觉处理通常被描述为实现概率推理:神经元网络在给定感觉输入的情况下，对未观察到的原因计算后验信念。这些信念是如何通过神经反应计算和表示的，这是一个很有争议的问题(Fiser et al. 2010，Pouget et al. 2013)。一个主要的争论是关于神经反应是否代表潜在变量的样本(Hoyer & Hyvarinnen 2003)或其分布的参数(Ma 等人 2006)的问题，并努力区分它们(Grabska-Barwinska 等人 2013)。一个单独的辩论解决了神经反应是否与编码概率成比例相关(Barlow 1969)，或者与这些概率的对数成比例(Jazayeri & Movshon 2006，Ma 等人 2006，Beck 等人 2012)的问题。在这里，我们证明了这些选择——与通常的假设相反——并不是相互排斥的，而且同一个系统可以兼容所有的选择。作为一个主要的分析结果，我们表明，将 V1 区域的神经反应建模为来自图像的线性高斯模型中潜伏期的后验分布的样本，意味着这些神经反应形成了线性概率群体代码(PPC，m a 等人，2006)。特别地，在一些实验者定义的变量如“方向”上的后验分布是指数族的一部分，其具有在基于神经采样的发放率中呈线性的足够统计量。

2.必需品；要素

通过稳健的近似重要性采样更快地训练深度模型

解决方案

理论上，重要性采样通过对训练样本进行优先排序来加速监督学习的随机梯度算法。实际上，计算重要性的成本极大地限制了重要性抽样的影响。我们提出了一种用于随机梯度去噪的鲁棒的近似重要性采样过程(RAIS)。通过使用稳健优化来近似理想的采样分布，RAIS 以大幅降低的开销提供了精确重要性采样的许多好处。根据经验，我们发现 RAIS-新加坡元和标准新加坡元遵循相似的学习曲线，但 RAIS 在这些路径上走得更快，实现了至少 20%的加速，有时甚至更多。

DropMax:自适应变分 Softmax

优雅

我们提出了 DropMax，一个随机版本的 softmax 分类器，它在每次迭代中根据每个实例自适应决定的丢弃概率丢弃非目标类。具体来说，我们在类输出概率上覆盖二进制掩蔽变量，这是通过变分推理输入自适应学习的。这种随机正则化具有从具有不同决策边界的指数级分类器中构建集成分类器的效果。此外，对每个实例上的非目标类的辍学率的学习允许分类器更多地关注针对最混乱的类的分类。我们在多个用于分类的公共数据集上验证了我们的模型，在该数据集上，它获得了比常规 softmax 分类器和其他基线显著提高的准确性。对学习到的丢弃概率的进一步分析表明，我们的模型在执行分类时确实更经常地选择混淆类。

如何开始训练:初始化和架构的效果

效用

我们识别并研究了两种常见的深层网络早期训练失败模式。对于每一种情况，我们都给出了严格的证明，说明在全连接、卷积和剩余架构中，这种情况何时发生以及如何避免。我们证明，第一种失效模式，即爆炸或消失的平均激活长度，可以通过初始化方差为 2/扇入的对称分布的权重来避免，对于 ResNets，可以通过正确缩放剩余模块来避免。我们证明，一旦避免了第一种失效模式，第二种失效模式，即激活长度的指数大方差，就不会出现在剩余网络中。相比之下，对于完全连接的网络，我们证明这种故障模式可能发生，并通过保持层宽度的倒数之和不变来避免。我们从经验上证明了我们的理论结果在预测网络何时能够开始训练方面的有效性。特别是，我们注意到许多流行的初始化不符合我们的标准，而正确的初始化和架构允许训练更深层次的网络。

通过激活样本方差的方差进行正则化

简单而不平凡

规范化技术在支持深度神经网络的高效且通常更有效的训练中起着重要作用。虽然传统的方法显式归一化的激活，我们建议添加一个损失项代替。这个新的损失项鼓励激活的方差保持稳定，而不是从一个随机小批量到下一个随机小批量变化。最后，我们能够将新的正则项与 batchnorm 方法联系起来，这为它提供了正则化的视角。我们的实验表明，对于 CNN 和全连接网络，在准确性上比 batchnorm 技术有所提高。

Mesh-TensorFlow:超级计算机的深度学习

解决方案

批处理分裂(数据并行)是主要的分布式深度神经网络(DNN)训练策略，因为它的普遍适用性及其对单程序多数据(SPMD)编程的适应性。然而，批量分割存在一些问题，包括无法训练非常大的模型(由于内存限制)、高延迟以及小批量时效率低下。所有这些都可以通过更通用的分布策略(模型并行)来解决。不幸的是，有效的模型并行算法往往难以发现、描述和实现，尤其是在大型集群上。我们介绍网格张量流，这是一种用于描述一般分布式张量计算的语言。在数据并行性可以被视为沿着“批处理”维度拆分张量和操作的情况下，在 Mesh-TensorFlow 中，用户可以指定要在多维处理器网格的任何维度上拆分的任何张量维度。一个网格张量流图编译成一个 SPMD 程序，该程序由并行操作和集体通信原语(如 Allreduce)组成。我们使用 Mesh-TensorFlow 来实现变压器序列到序列模型的高效数据并行、模型并行版本。使用多达 512 个核心的 TPU 网格，我们训练了多达 50 亿个参数的变压器模型，超过了 SOTA 在 WMT 的 14 个英语到法语翻译任务和 10 亿词语言建模基准上的结果。Mesh-Tensorflow 在 github.com/tensorflow/…](github.com/tensorflow/…)

结构感知卷积神经网络

现实世界

卷积神经网络(CNN)固有地受制于不变的滤波器，该滤波器只能聚集具有相同拓扑结构的局部输入。这导致 CNN 被允许管理具有欧几里得或网格状结构的数据(例如，图像)，而不是具有非欧几里得或图形结构的数据(例如，交通网络)。为了扩大细胞神经网络的范围，我们开发了结构感知卷积来消除不变性，产生了处理欧几里德和非欧几里德结构化数据的统一机制。在技术上，结构感知卷积中的滤波器被推广到单变量函数，其能够聚集具有不同拓扑结构的局部输入。由于确定一个单变量函数需要无限个参数，我们在函数逼近理论的背景下用编号的可学习参数来参数化这些滤波器。通过用结构感知卷积代替细胞神经网络中的经典卷积，很容易建立结构感知卷积神经网络。在 11 个数据集上的大量实验有力地证明了 SACNNs 在各种机器学习任务上优于当前的模型，包括图像分类和聚类、文本分类、基于骨架的动作识别、分子活动检测和出租车流量预测。

可视化神经网络的损失情况

视角

神经网络训练依赖于我们找到高度非凸损失函数的“好”极小值的能力。众所周知，某些网络架构设计(例如，跳过连接)产生更容易训练的损失函数，并且精心选择的训练参数(批量大小、学习率、优化器)产生更好地概括的最小化器。然而，这些差异的原因，以及它们对潜在损失状况的影响，并没有得到很好的理解。在本文中，我们探讨了神经损失函数的结构，以及损失景观对泛化的影响，使用了一系列可视化方法。首先，我们引入一个简单的“滤波归一化”方法，帮助我们可视化损失函数曲率，并在损失函数之间进行有意义的并排比较。然后，使用各种可视化，我们探索网络架构如何影响损失景观，以及训练参数如何影响最小化器的形状。

用混合块浮点训练 DNNs】

渴望解决

DNNs 的广泛采用催生了无情的计算需求，迫使数据中心运营商采用特定领域的加速器来培训他们。这些加速器通常采用密集的全精度浮点运算，以最大限度地提高单位面积的性能。正在进行的研究工作试图通过用定点运算取代浮点运算来进一步提高性能密度。然而，这些尝试的一个重大障碍是定点的狭窄动态范围，这对于 DNN 训练收敛来说是不够的。我们认为块浮点(BFP)是一种很有前途的替代表示法，因为它具有很宽的动态范围，并且能够用定点逻辑执行大多数 DNN 运算。不幸的是，BFP 单独引入了几个限制，妨碍了它的直接应用。在这篇文章中，我们介绍了 HBFP，一种混合的 BFP-FP 方法，它在 BFP 中执行所有的点积操作，在浮点中执行其他操作。HBFP 提供了两个世界的精华:浮点的高精度和定点的高硬件密度。对于各种型号，我们显示 HBFP 匹配浮点精度，同时支持硬件实施，提供高达 8.5 倍的高吞吐量。

FRAGE:频率不可知的单词表示法

有趣的

连续单词表示(也称为单词嵌入)是在自然语言处理任务中使用的许多基于神经网络的模型中的基本构件。尽管人们普遍认为语义相似的词在嵌入空间中应该彼此靠近，但我们发现在几个任务中学习到的词嵌入偏向于词频:高频词和低频词的嵌入位于嵌入空间的不同子区域，一个稀有词和一个流行词的嵌入即使语义相似也可能彼此远离。这使得学习的单词嵌入无效，特别是对于罕见的单词，因此限制了这些神经网络模型的性能。为了缓解这一问题，本文提出了一种简洁、简单而有效的对抗训练方法来模糊高频词和低频词嵌入之间的界限。我们在四个自然语言处理任务的十个数据集上进行了全面的研究，包括单词相似度、语言建模、机器翻译和文本分类。结果表明，我们在所有任务中都取得了比基线更高的性能。

语音和文本嵌入空间的无监督跨模态对齐

在核心处

最近的研究表明，从不同语言的文本语料库中学习的单词嵌入空间可以在没有任何并行数据监督的情况下对齐。受无监督跨语言单词嵌入成功的启发，本文的目标是在无监督方式下学习语音和文本嵌入空间之间的跨模态对齐。所提出的框架学习单独的语音和文本嵌入空间，并试图通过对抗训练来对齐这两个空间，随后是细化过程。我们展示了如何使用我们的框架来执行口语单词分类和翻译的任务，并且在这两个任务上的实验结果表明，我们的无监督对齐方法的性能与其有监督的方法相当。我们的框架对于为低资源或零资源语言开发自动语音识别(ASR)和语音到文本翻译系统特别有用，这些语言几乎没有用于训练现代监督 ASR 和语音到文本翻译模型的并行音频-文本数据，但占世界上使用的大多数语言。

紧凑广义非局域网络

清洁

非局部模块被设计用于捕获图像和视频中的长程时空依赖性。尽管它表现出了出色的性能，但它缺乏对跨通道位置之间的交互进行建模的机制，而这对于识别细粒度的对象和动作至关重要。为了解决这个限制，我们推广了非局部模块，并且考虑了任意两个通道的位置之间的相关性。该扩展利用了具有泰勒展开的多个核函数的紧凑表示，这使得广义非局部模块成为快速和低复杂度的计算流程。此外，我们在通道组内实现了我们的广义非局部方法以简化优化。实验结果表明，广义非局部模块在细粒度对象识别和视频分类方面都有明显的改进和实用性。代码可在:github.com/KaiyuYue/cg…获得。

3.进步

使用椭圆分布的 Wasserstein 空间概括点嵌入

拉伸

一种新的嵌入框架，它是数值灵活的，并且扩展了 wessserstein 空间中的点嵌入、椭圆嵌入。Wasserstein 椭圆嵌入更直观，并且产生比具有 Kullback-Leibler 散度的高斯嵌入的替代选择在数值上表现更好的工具。本文通过将椭圆嵌入用于可视化、计算词的嵌入以及反映蕴涵或上下级关系来展示椭圆嵌入的优点。

鱼网:图像、区域和像素级预测的多功能支柱

基本面

设计卷积神经网络(CNN)结构以预测不同级别(例如图像级别、区域级别和像素级别)上的对象的基本原理是不同的。通常，专门为图像分类设计的网络结构被直接用作包括检测和分割在内的其他任务的默认主干结构，但是很少有主干结构是在考虑统一为像素级或区域级预测任务设计的网络的优点的情况下设计的，这些预测任务可能需要具有高分辨率的非常深的特征。朝着这个目标，我们设计了一个类似鱼的网络，称为鱼网。在 FishNet 中，所有分辨率的信息都被保留下来，并为最终任务进行优化。此外，我们观察到现有的工作仍然不能直接将梯度信息从深层传播到浅层。我们的设计可以更好的处理这个问题。已经进行了大量的实验来证明鱼网的卓越性能。特别是在 ImageNet-1k 上，FishNet 的精度能够以较少的参数超越 DenseNet 和 ResNet 的性能。渔网被用作 COCO Detection 2018 挑战赛获奖作品的模块之一。该代码可在 github.com/kevin-ssy/F… 的获得。

通过自解释神经网络实现强大的可解释性

没有副作用

最近关于复杂机器学习模型的可解释性的工作主要集中在围绕特定预测估计先前训练的模型的后验解释。自我解释模型的可解释性在学习过程中已经发挥了关键作用，但却很少受到关注。我们提出了一般解释的三个要求——明确性、忠实性和稳定性——并表明现有的方法不能满足它们。作为回应，我们分阶段设计自我解释模型，逐步将线性分类器推广到复杂但在架构上明确的模型。忠实性和稳定性是通过专门为这些模型定制的正则化来实现的。各种基准数据集的实验结果表明，我们的框架为协调模型复杂性和可解释性提供了一个有希望的方向。

关系递归神经网络

革命性

基于记忆的神经网络通过利用长时间记忆信息的能力来模拟时态数据。然而，还不清楚他们是否也有能力用他们记忆的信息进行复杂的关系推理。在这里，我们首先确认我们的直觉，即标准内存架构可能会在大量涉及理解实体连接方式的任务中挣扎，即，涉及关系推理的任务。然后，我们通过使用一种新的内存模块(关系内存核心(RMC))来改善这些缺陷，这种内存模块采用多头点积注意力来允许内存进行交互。最后，我们在一组任务上测试了 RMC，这些任务可能受益于跨顺序信息的更有能力的关系推理，并显示了在 RL 域(BoxWorld & Mini PacMan)、程序评估和语言建模方面的巨大收益，在 WikiText-103、Project Gutenberg 和 GigaWord 数据集上实现了最先进的结果。

基于神经样本的概率人口代码

寻求力量

感觉处理通常被描述为实现概率推理:神经元网络在给定感觉输入的情况下，对未观察到的原因计算后验信念。这些信念是如何通过神经反应计算和表示的，这是一个很有争议的问题(Fiser et al. 2010，Pouget et al. 2013)。一个主要的争论是关于神经反应是否代表潜在变量的样本(Hoyer & Hyvarinnen 2003)或其分布的参数(Ma 等人 2006)的问题，并努力区分它们(Grabska-Barwinska 等人 2013)。一个单独的辩论解决了神经反应是否与编码概率成比例相关(Barlow 1969)，或者与这些概率的对数成比例(Jazayeri & Movshon 2006，Ma 等人 2006，Beck 等人 2012)的问题。在这里，我们证明了这些选择——与通常的假设相反——并不是相互排斥的，而且同一个系统可以兼容所有的选择。作为一个主要的分析结果，我们表明，将 V1 区域的神经反应建模为来自图像的线性高斯模型中潜伏期的后验分布的样本，意味着这些神经反应形成了线性概率群体代码(PPC，m a 等人，2006)。特别地，在一些实验者定义的变量如“方向”上的后验分布是指数族的一部分，其具有在基于神经采样的发放率中呈线性的足够统计量。

神经符号 VQA:从视觉和语言理解中解开推理

包罗万象

我们结合了两个强大的想法:用于视觉识别和语言理解的深度表示学习，以及用于推理的符号程序执行。我们的神经符号视觉问题回答(NS-VQA)系统首先从图像中恢复结构场景表示，并从问题中恢复程序轨迹。然后，它对场景表示执行程序以获得答案。将符号结构作为先验知识提供了三个独特的优势。首先，在符号空间上执行程序对于长程序跟踪更健壮；我们的模型可以更好地解决复杂的推理任务，在 CLEVR 数据集上达到 99.8%的准确率。第二，该模型在数据和内存方面效率更高:它在对少量训练数据进行学习后表现良好；它还可以将图像编码成紧凑的表示形式，比现有的离线问答方法需要更少的存储空间。第三，符号程序执行为推理过程提供了完全的透明性；因此，我们能够解释和诊断每个执行步骤。

用少量样本克隆神经声音

人工需要

语音克隆是个性化语音界面非常需要的功能。我们介绍了一个神经声音克隆系统，它可以学习仅从几个音频样本中合成一个人的声音。我们研究两种方法:说话人适应和说话人编码。说话人自适应基于对多说话人生成模型的微调。说话人编码基于训练单独的模型来直接推断新的说话人嵌入，其将被应用于多说话人生成模型。在语音的自然性和与原说话人的相似性方面，两种方法都可以达到良好的性能，即使有一些克隆音频。虽然说话者自适应可以实现稍微更好的自然性和相似性，但是说话者编码方法的克隆时间和所需的内存明显更少，这使得它更有利于低资源部署。

神经算术逻辑单元

正常

神经网络可以学习表示和操作数字信息，但它们很少在训练期间遇到的数值范围之外进行推广。为了鼓励更系统的数值外推，我们提出了一种架构，将数值表示为线性激活，使用原始算术运算符操纵，由学习门控制。我们称这个模块为神经算术逻辑单元(NALU)，类似于传统处理器中的算术逻辑单元。实验表明，NALU 增强的神经网络可以学习跟踪时间，对数字图像执行算术，将数字语言翻译成实值标量，执行计算机代码，并对图像中的对象进行计数。与传统架构相比，我们在训练期间遇到的数值范围内外都获得了显著更好的概括，通常外推超出训练数值范围的数量级。

4.大问题/未来

在知识图上嵌入逻辑查询

少数民族方法

学习知识图的低维嵌入是一种用于预测实体之间未观察到的或缺失的边的强大方法。然而，该领域的一个公开挑战是开发能够超越简单边缘预测并处理更复杂逻辑查询的技术，这可能涉及多个未观察到的边缘、实体和变量。例如，给定一个不完整的生物学知识图表，我们可能想要预测“什么药物可能针对与 X 和 Y 疾病都相关的蛋白质？”—需要对可能与疾病 X 和 y 相互作用的所有可能蛋白质进行推理的查询。这里，我们介绍了一个框架，以在不完整的知识图上有效地对合取逻辑查询进行预测，这是一个灵活但易于处理的一阶逻辑子集。在我们的方法中，我们在低维空间中嵌入图节点，并在该嵌入空间中将逻辑运算符表示为学习到的几何运算(例如，平移、旋转)。通过在低维嵌入空间内执行逻辑运算，我们的方法实现了与查询变量的数量成线性的时间复杂度，相比之下，基于简单枚举的方法需要指数复杂度。我们在两个对具有数百万关系的真实世界数据集的应用研究中展示了该框架的效用:预测药物-基因-疾病相互作用网络中的逻辑关系，以及来自流行网络论坛的基于图形的社会相互作用表示。

作为多目标优化的多任务学习

整个交易

在多任务学习中，多个任务被联合解决，在它们之间共享归纳偏差。多任务学习本质上是一个多目标的问题，因为不同的任务可能会发生冲突，需要进行权衡。一个常见的折衷方案是优化一个代理目标，使每个任务损失的加权线性组合最小化。但是，这种解决方法仅在任务不竞争时有效，这种情况很少发生。在本文中，我们明确地将多任务学习视为多目标优化，总目标是找到一个帕累托最优解。为此，我们使用在基于梯度的多目标优化文献中开发的算法。这些算法不能直接应用于大规模学习问题，因为它们与梯度的维度和任务的数量的比例很差。因此，我们提出了一个多目标损失的上限，并表明它可以有效地优化。我们进一步证明，在现实的假设下，优化这个上限会产生一个帕累托最优解。我们将我们的方法应用于各种多任务深度学习问题，包括数字分类、场景理解(联合语义分割、实例分割和深度估计)和多标签分类。我们的方法比最近的多任务学习公式或每任务训练产生更高性能的模型。

RenderNet:一个深度卷积网络，用于 3D 形状的可区分渲染

迫在眉睫

传统的计算机图形渲染流水线被设计用于以高性能从 3D 形状程序化地生成 2D 图像。由于离散操作(如可见性计算)导致的不可微性使得很难显式地将渲染参数与结果图像相关联，这给逆向渲染任务带来了巨大的挑战。最近关于可微绘制的工作通过为不可微操作设计代理梯度或者通过近似但可微的渲染器来实现可微性。然而，这些方法在处理遮挡时仍然受到限制，并且局限于特定的渲染效果。我们提出了 RenderNet，一个可区分的渲染卷积网络，它具有一个新颖的投影单元，可以从 3D 形状渲染 2D 图像。空间遮挡和阴影计算在网络中自动编码。我们的实验表明，RenderNet 可以成功地学习实现不同的着色器，并可以用于反向渲染任务，以从单幅图像中估计形状、姿态、光照和纹理。

e-SNLI:带有自然语言解释的自然语言推理

大梦想

为了让机器学习获得广泛的公众采用，模型必须能够为其决策提供可解释的和可靠的解释，并在训练时从人类提供的解释中学习。在这项工作中，我们扩展了斯坦福自然语言推理数据集，增加了一层对蕴涵关系的人类注释的自然语言解释。我们进一步实现模型，将这些解释合并到它们的训练过程中，并在测试时输出它们。我们展示了我们的解释语料库(我们称之为 e-SNLI)如何用于各种目标，例如获得模型决策的完整句子证明，改进通用句子表示和转移到域外 NLI 数据集。因此，我们的数据集为使用自然语言解释开辟了一系列研究方向，既用于改进模型，也用于维护模型的可信度。

用于视觉和语言导航的说话者跟随模型

未来

由自然语言指令引导的导航为指令追随者提出了一个具有挑战性的推理问题。自然语言指令通常只识别一些高级决策和地标，而不是完整的低级运动行为；许多缺失的信息必须基于感知环境来推断。在机器学习设置中，这具有双重挑战性:很难收集足够的注释数据来从头开始学习这个推理过程，并且也很难使用通用序列模型来实现推理过程。在这里，我们描述了一种视觉和语言导航的方法，该方法利用嵌入式扬声器模型解决了这两个问题。我们使用这个说话者模型来(1)合成用于数据扩充的新指令，以及(2)实现语用推理，语用推理评估候选动作序列如何解释指令。这两个步骤都由全景动作空间支持，该空间反映了人类生成的指令的粒度。实验表明，这种方法的所有三个组成部分——说话者驱动的数据增强、语用推理和全景动作空间——都显著提高了基线指令跟随器的性能，在标准基准上比现有的最佳方法的成功率高出一倍以上。

神经代码理解:代码语义的可学习表示

炼金术

随着嵌入在自然语言处理中最近的成功，已经进行了将类似方法应用于代码分析的研究。大多数作品试图直接处理代码或使用句法树表示法，将其视为用自然语言编写的句子。然而，由于诸如函数调用、分支和可互换的语句顺序等结构特征，现有的方法都不足以鲁棒地理解程序语义。在本文中，我们提出了一种新的处理技术来学习代码语义，并将其应用于各种程序分析任务。特别是，我们规定一个健壮的代码分布假设适用于人和机器生成的程序。根据这个假设，我们基于独立于源编程语言的代码的中间表示(IR)来定义嵌入空间 inst2vec。我们为这个 IR 提供了一个新颖的上下文流定义，利用了程序的底层数据流和控制流。然后，我们使用类比和聚类对嵌入进行定性分析，并评估在三个不同的高级任务上学习到的表征。我们表明，即使没有微调，单个 RNN 架构和固定的 inst2vec 嵌入也优于专门的性能预测方法(计算设备映射、最佳线程粗化)；以及来自原始代码(104 个类)的算法分类，其中我们设置了一个新的最先进的状态

海马-内嗅系统结构知识的概括

登月

理解智力的一个中心问题是概括的概念。这使得先前学习的结构被用来解决特殊情况下的新任务。我们从神经科学中获得灵感，特别是已知对归纳很重要的海马-内嗅系统。我们建议，为了概括结构知识，世界结构的表示，即世界中的实体如何相互联系，需要与实体本身的表示分开。我们表明，在这些原则下，嵌入了层次结构和快速 Hebbian 记忆的人工神经网络可以学习记忆的统计和概括结构知识。反映大脑中发现的空间神经元表现出现，表明空间认知是更普遍的组织原则的一个实例。我们进一步统一了许多内嗅细胞类型作为构建转换图的基函数，并表明这些表示有效地利用了记忆。我们实验性地支持模型假设，显示了跨环境的内嗅网格和海马位置细胞之间保存的关系。

你想去哪里？:从行为中推断关于动力学的信念

内部构件

在贝叶斯逆规划和逆强化学习的框架内，从观察到的行为推断意图已经得到了广泛的研究。这些方法推断出一个目标或奖励函数，它能最好地解释被观察主体的行为，通常是一个人类演示者。另一个代理可以使用这个推断的意图来预测、模仿或帮助人类用户。然而，逆向强化学习的一个核心假设是，演示器接近最优。虽然存在次优行为模型，但它们通常假设次优行为是某种随机噪声或已知认知偏差(如时间不一致性)的结果。在本文中，我们采用了另一种方法，将次优行为建模为内部模型错误设定的结果:用户行为可能偏离近优行为的原因是用户对控制行为如何影响环境的规则(动态)有一套不正确的信念。我们的见解是，虽然演示的动作在现实世界中可能是次优的，但就用户的内部动态模型而言，它们实际上可能是接近最优的。通过从观察到的行为中评估这些内在信念，我们得到了一种推断意图的新方法。我们在模拟和 12 名参与者的用户研究中证明，这种方法使我们能够更准确地模拟人类意图，并可用于各种应用，包括在共享自治框架中提供帮助和推断人类偏好。

视觉系统的任务驱动卷积递归模型

大问题/未来

前馈卷积神经网络(CNN)目前是用于对象分类任务(如 ImageNet)的最新技术。此外，它们是灵长类大脑视觉系统中神经元的时间平均响应的定量精确模型。然而，生物视觉系统有两个普遍存在的结构特征，与典型的 CNN 不同:皮质区域内的局部复发，以及从下游区域到上游区域的远程反馈。这里我们探讨了递归在提高分类性能中的作用。我们发现在 ImageNet 任务中，标准形式的递归(普通 RNNs 和 LSTMs)在深度 CNN 中表现不佳。相比之下，结合了旁路和门控两种结构特征的新型细胞能够大幅提高任务的准确性。我们在数以千计的模型架构的自动搜索中扩展了这些设计原则，这些架构识别了对对象识别有用的新的局部循环细胞和远程反馈连接。此外，这些任务优化的神经网络比前馈网络更好地匹配了灵长类动物视觉系统中的神经活动动力学，这表明了大脑的循环连接在执行困难的视觉行为中的作用。

本能:类固醇上的神经进化

原文：towardsdatascience.com/neuro-evolu…

当我第一次实现神经进化时，我实现了 Kenneth O. Stanley 和 Risto Miikkulainen 的论文中描述的算法； 通过扩充拓扑进化神经网络 。我设法让它工作，但当我在更复杂的数据集上测试算法时，问题开始出现。

节点连接偏差的缺乏迫使网络对于简单的问题变得过于庞大和复杂。跟踪所谓的创新数字在计算上非常昂贵。但最重要的是:由于缺少门，该算法永远不会产生任何像我们在 LSTM 的记忆细胞。

我很快开始修改算法，添加偏差和门，删除创新数，但也添加了节点变异其激活函数的选项:这是一个非常强大的工具，因为基因组现在可以针对数据集/环境完全修改自己。

本能算法

我喜欢称我的算法为本能算法。不仅仅是因为这听起来很酷，还因为神经进化在某些环境中发展了神经代理的本能。

本能的本质在于它是独立于理性而存在的。—查尔斯·达尔文

我将仅仅讨论基因组的结构，以及它们应该如何被培育、变异和限制。建立遗传算法取决于你。关于工作示例，请参见我的 Javascript 神经进化库。

另请注意，当算法发生变化时，本文将会更新。例如，我已经计划加入共享权重，这将很快加入。

1 个基因组

如图 1 所示，一个基因组由一组节点和一组连接组成。

(figure 1) Simple example of a genotype and corresponding phenotype

1.1 节点

每个节点都有一个类型。只有三种:input、hidden、output。类型为input的节点总是停留在列表的开头，类型为output的节点将停留在列表的末尾。如果通过突变添加了新节点，它们将总是具有hidden类型。

index 参数没有真正的功能，它只是表示节点被激活的顺序。这是按升序发生的。

每个节点都有一个可修改的偏置和挤压(或:激活功能)。偏见没有固定的范围。为每个新变异的节点随机选择激活函数。

1.2 连接

连接从索引为from的节点连接到索引为to的节点。即使连接引用了索引，它实际上也引用了它所连接的节点。例如，如果索引 2 和 3 上的节点之间存在连接，则该连接总是引用最初在索引 2 和 3 上的节点。

每个连接也有自己的权重和网关。重量没有固定范围。gater参数表示节点基因列表中控制连接的节点的索引，它总是引用该节点，而不管其索引如何。

1.3 激活

激活基因组的方法与其他神经网络完全相同，但我想在这里放一些(类似 JS 的)伪代码以防万一。请记住，自连接是由节点先前的状态而不是节点先前的激活状态相乘的。

FUNCTION ACTIVATE: 
  output = [] FOR EACH node IN genome.nodes:
    IF node.type === 'INPUT':
      node.activation = input[i]
    ELSE:
      // self-connections are handled differently!
      node.state = node.selfconnection.weight * node.state *
        genome.nodes[node.selfconnection.gater].activation +
        node.bias FOR EACH connection IN node.incomingConnections:
        node.state += connection.weight *
          genome.nodes[connection.from].activation * 
          genome.nodes[connection.gater].activation

      node.activation = node.squash(node.state)

      IF node.type === 'OUTPUT':
        output.add(node.activation)

2 交叉

杂交是基因组改进的关键。当两个基因组被选择进行杂交时，它们会产生一个独特的后代。它可能会从两个不太健康的父母那里创造出非常健康的后代。它刺激了群体中新网络拓扑的创建。

一个普遍的法则，导致所有有机生物的进步，也就是，繁殖，变化，让最强的生存，最弱的死亡。——查尔斯·达尔文，物种起源

首先，后代的大小被确定。基因组的大小等于基因组的节点数。如果双亲中的一个比另一个具有更高的适合度，那么大小将与最适合的双亲的大小相同。如果双亲同样合适，则在双亲的尺寸之间随机选择一个尺寸。

IF parent1.fitness > parent2.fitness:
  offspring.size = parent1.size
ELSE IF parent2.fitness > parent1.fitness:
  offspring.size = parent2.size
ELSE:
  offspring.size = randomBetween(parent1.size, parent2.size)

不管哪个父节点更合适，对于每个索引，节点将从每个父节点中统一选择。这样做，直到节点的数量等于先前确定的大小。

当子代的大小大于最小的父代时，将总是选择来自最大父代的节点。

这些规则有两个例外:首先，如果后代的输出节点还没有被选择，那么类型为output的节点可能永远不会被选择。其次，当为后代选择第n个输出节点时，则选择双亲之一的第n个输出节点。

FOR i = 0, i < offspring.size, i++:
  IF i < offspring.size - parents.outputSize:
    // Choose non-output nodes
    IF i > parent1.size - parents.outputSize:
      node = parent2.nodes[i];
    ELSE IF i > parent2.size - parents.outputSize:
      node = parent1.nodes[i]
    ELSE:
      node = SELECT_UNIFORM(parent1.nodes[i], parent2.nodes[i])
  ELSE:
    // Choose output nodes
    node = SELECT_UNIFORM(
      parent1.nodes[parent1.size + i - offspring.size],
      parent1.nodes[parent2.size + i - offspring.size]
    )

  offspring.nodes[i] = node; 

一旦选择了节点，连接被分成两个不同的组:公共和额外连接。当两个父节点具有相同的from和to值时，这是一个普通连接。否则，它就是一个额外的连接，意味着这个连接只存在于父母中的一个。

最有效的方法

公共节点从双亲中统一选择，而不考虑它们的适合度。只有当父母中的一方至少和另一方一样健康时，来自该方的额外基因才会被添加。

3 突变

与整洁的论文不同，我将描述应该用来从基因组中获得最大效率的突变方法。每个描述都附有一些伪代码。

3.1 添加节点突变

拥有一种将节点基因添加到基因组的突变方法是必不可少的。没有这种突变方法，基因组将不会增长，因此在节点被连接饱和后永远不会改善。

当添加新节点时，现有连接将被拆分为两个新连接，新节点位于这两个连接之间。

(figure 2) Example of the add node mutation, a new node between 1 and 2 is added

如果被删除的连接有一个网关，该网关将被转移到两个新连接中的一个。当一个新的节点被插入到一个基因组的基因列表中时，它被放置在原始连接的接收节点(具有索引to的节点)的之前并且从不在具有output类型的任何节点的之后*。*

当一个节点被插入到其他节点之间时，被插入节点之后的所有节点的索引增加 1。因此，现有的连接总是保留在它们最初被分配到的节点之间。

新节点总是被分配一个统一选择的激活函数。

connection = SELECT_UNIFORM(genome.connections)
gater = connection.gaterindex = MIN(connection.to, genome.size - genome.outputSize)
node = new Node()genome.nodes.insert(node, index)
genome.connections.remove(connection)newConnection1 = {
  from: connection.from, 
  to: index, 
  weight: randomNumber(),
  gater: -1
}newConnection2 = {
  from: index, 
  to: connection.to, 
  weight: randomNumber(),
  gater: -1
}IF gater !== -1:
  SELECT_UNIFORM(newConnection1, newConnection2).gater = gatergenome.connections.add(newConnection1)
genome.connections.add(newConnection2)

3.2 添加连接突变

与变异新节点同等重要的是变异新连接。首先，生成存在不存在的连接列表。列表生成后，其中一个生成的连接将被放入基因组的连接基因列表中。

(figure 3) Example of the add connection mutation, a new connection between 1 and 3 is added

来自hidden或output类型节点的连接从不连接到input类型节点，因为input类型节点的激活值不是计算出来的，而是由数据集提供的。创建这些连接会调用不必要的内存。

pairs = []FOR EACH node1 IN genome.nodes:
  FOR EACH node2 IN genome.nodes:
    IF node1.isNotConnectedTo(node2):
      pairs.add([node1, node2])pair = SELECT_UNIFORM(pairs)connection = {
  from: pair[0].index,
  to: pair[1].index,
  weight: random(),
  gater: -1
}genome.connections.add(connection)

3.3 添加门突变

拥有一种设置连接基因闸门的突变方法，对于开发复杂的网络来检测多个连续输入之间的模式是必要的。

统一选择一个连接，并将gater值设置为从基因组的节点基因列表中统一选择的节点的索引。

(figure 4) Example of the add gate mutation, connection from 1 to 3 is gated

connection = SELECT_UNIFORM(genome.connections)
connection.gater = selectionUniform(genome.nodes).index

3.4 修改体重突变

统一选择一个连接，并在该连接的权重上加上或减去一个值。我喜欢把修改固定在(-1, 1)的范围内。

(figure 5) Example of the modify weight mutation

connection = SELECT_UNIFORM(genome.connections)
modification = random() * (max - min) + minconnection.weight += modification

3.5 修改偏置突变

统一选择一个节点，并从该节点的偏差中增加或减去一个值。我喜欢修正(-1, 1)的射程。确保不要突变输入节点，因为这对基因组的输出没有影响。

(figure 6) Example of the modify bias mutation

node = SELECT_UNIFORM(genome.nodes) // exclude input nodes
modification = random() * (max - min) + minnode.bias += modification

3.6 修改南瓜突变

最后但肯定不是最不重要的:修改节点基因激活功能的突变方法。就个人而言，我坚持使用以下激活功能列表:

逻辑 ， 双曲正切 ， 恒等式 ， 二进制步长 ，ReLU，软符号， 高斯

如果你寻求更多样的激活功能，我推荐这个列表。

(figure 7) Example of the modify squash mutation

node = SELECT_UNIFORM(genome.nodes)
newSquash = SELECT_UNIFORM(listOfSquashes)node.squash = newSquash

3.7 清除节点突变

随着基因组的增长，它可能表现得更好，但有时它有利于基因组回复已经发生的突变。这也降低了激活基因组的计算成本。

(figure 8) Example of the remove node mutation, node on index 2 is getting removed

首先，input或output类型的节点永远不会被删除。一旦随机选择一个隐藏类型的节点进行删除，就会创建一个带有节点索引的列表，该列表提供到该节点的所有传入连接(不包括自连接)。另一个列表是用所有输出连接的目标节点索引创建的。同时，不是输入和输出连接的-1的gater值被保存。

node = SELECT_UNIFORM(genome.nodes)gaters = [];
sourceNodes = [];FOR EACH connection IN node.incomingConnections:
  IF connection.from !== node.index:
    sourceNodes.add(connection.from)
    IF connection.gater !== -1:
      gaters.add(connection.gater)targetNodes = [];FOR EACH connection IN node.outgoingConnections:
  IF connection.to !== node.index:
    targetNodes.add(connection.to)
    IF connection.gater !== -1:
      gaters.add(connection.gater)

现在sourceNodes阵列中的每个节点索引与targetNodes阵列中的每个节点索引连接(如果尚未连接)。保留了所创建的连接的列表。创建完所有连接后，gaters中的每个选通器都被分配给一个连接，直到没有连接留给选通器。

newConnections = [];FOR EACH source IN sourceNodes:
  FOR EACH target IN targetNodes:
    IF source.notConnectedTo(target):
      connection = {
        from: source,
        to: target,
        weight: random(),
        gater: -1
      }
      newConnections.add(connection)
      genome.connections.add(connection)FOR EACH gater IN gaters:
  IF newConnections.length === 0:
    break;

  randomConnection = SELECT_UNIFORM(newConnections);

  randomConnection.gater = gater
  newConnections.remove(randomConnection)

由被移除的节点选通的每个连接的gater值被设置为-1。最后，从基因组中移除该节点。

FOR EACH connection IN genome.connections:
  IF connection.gater === node.index:
    connection.gater = -1genome.nodes.remove(node)

3.8 移除连接突变

只有当源节点有多个传出连接并且目标节点有多个传入连接时，才能删除连接。这样，所有节点将始终至少有一个传入连接和一个传出连接。

(figure 9) Example ofthe remove connection mutation, connection between 1 and 3 is being removed

connections = [];FOR EACH connection IN genome.connections:
  IF connection.from.hasMultipleOutgoingConnections() AND
     connection.to.hasMultipleIncomingConnections():
    connections.add(connection)connection = SELECT_UNIFORM(connections)
genome.connections.remove(connection)

3.9 移除门突变

先前已经变异的门可能会对基因组的表现造成问题。这种变异方法从随机选择的门控连接中移除门。

(figure 10) Example of the remove gate connection, connection from 1 to 3 is getting ungated

gatedConnections = [];FOR EACH connection IN genome.connections:
  IF connection.gater !== -1:
    gatedConnections.add(connection)connection = SELECT_UNIFORM(gatedConnections)
connection.gater = -1

3.10 其他突变方法

有时将添加连接变异方法拆分成多个其他变异方法是有意义的:添加前馈连接、添加递归连接和添加自连接。这也需要移除前馈连接，移除循环连接和移除自连接。

例如，当数据集没有空间关系(多个样本之间的关系)时，您不希望出现任何重复性突变。

4 个限制因素

就像任何其他训练方法一样，本能算法有可能过度拟合数据集。为了避免过拟合，引入了一个新的全局参数:生长。

growth参数不利于基因组变大，但性能相对较低。通常，growth是十进制数。节点、连接和门的数量乘以growth得到基因组的适应度惩罚。

penalty = (genome.nodes.length + genome.connections.length + genome.gates.length) * growth

用于计算罚金的参数是自由选择的。例如，罚款计算也可以是:

penalty = genome.nodes.length * growth

4.1 示例

一个基因组在某个数据集上有10的适合度。基因组发生了变异。它获得了一个额外的节点。突然，适应度提高到了11。可悲的是，随着以下惩罚的应用，最终适应度降低到9:

fitness = fitness - genome.nodes.length * growth

其growth值为2。因此，如果一个基因组想要达到更高的最终适应度，适应度的增加应该高于2。

神经形态和深度神经网络

原文：towardsdatascience.com/neuromorphi…

免责声明:我在博士期间一直从事模拟和混合信号神经形态微芯片的研究，在最近 10 年里，我转向了深度学习和全数字神经网络。关于我们作品的完整列表，请看 这里 。关于这个主题的一个更老的出版物是 这里是 (来自我们组)。

神经形态神经网络

用于计算神经网络的神经形态或标准数字:哪个更好？这个问题很难回答。标准的数字神经网络是我们在深度学习中看到的那种，它们取得了所有的成功。它们使用 64 位或更低的数字值进行计算，所有这些都在标准数字硬件中。

神经形态系统和硬件有很多种风格，主要源于卡弗·米德的开创性工作(他的书的封面在右边)。他们通常使用每个值 1 位，就像在脉冲神经网络中一样。他们可以用模拟或数字计算单元进行计算。主要思想是神经元是自由运行和独立的单元，由 1 比特脉冲形式的尖峰信号的通信来刺激。神经形态神经元既可以是复杂的数字计数器也可以是简单的模拟积分器。

The Izhikevich neuron circuit, from here

通信是异步且复杂的。此外，使用数字通信更节能、抗噪，如下图所示。

Sarpeshkhar 1998

数字形式的神经形态硬件由 IBM ( TrueNorth )设计，模拟形式由许多研究小组( Boahen 、 Hasler 、我们的实验室等)设计。).最好的系统使用模拟计算和数字通信:

Kwabena Bohaen group

使用传统的数字硬件来模拟神经形态硬件( SpiNNaker )显然是低效的，因为我们正在使用 32 位硬件来模拟 1 位硬件。

神经网络计算

神经网络需要乘加运算。MM 矩阵与 M 向量乘积需要 M 次乘法和加法，或 2M 次运算。他们还通过卷积或人工感受域进行计算，这基本上与矩阵向量乘法相同，只是你为每个输出数据点乘以多个值(过滤器)。

神经形态系统以不同的方式计算相同的运算**，而不是使用 B 位字进行激活和加权，它们使用神经元之间的 1 位尖峰通信。神经元可以在正负线上发送尖峰信号，以激活或多或少与其相连的神经元。神经形态神经元在数字计数器或模拟积分器中整合输入，当达到某个阈值时，它们自己触发另一个尖峰信号，以与其他神经元进行通信。**

**神经元阵列和神经激活:**神经元被组织成阵列，并将激活存储在每个神经元内部的存储器中。这是一个问题，因为神经网络可能很大，需要许多神经元。这使得神经形态微芯片变得很大，因为神经元不能像我们在传统数字系统中那样被重用。如果一个人想要在同一序列中重复使用神经元阵列进行多次计算，那么他必须使用模拟存储器来存储神经激活，或者将它们转换为数字并存储到传统的数字存储器中。**神经形态问题:这两种选择目前都被禁止。**详见下文“模拟与数字存储器”。

计算神经形态阵列中的神经网络层需要将权重值 W 添加到神经元激活中。这很简单:**没有乘法。**数字乘法器每比特使用 L(~ 30–300)个晶体管(下限:每个触发器 12 个晶体管，2 ff，一个 xor 门进行乘法)，而模拟乘法器可能只需要少量晶体管(1 个用于乘法，5–10 个用于偏置电路)来乘以~5 比特(受噪声限制)——这都取决于权重是如何实现的。神经形态计算通过使用少得多的功率赢得了重要的时间。

重量是如何实现的？它们可以是数字的也可以是模拟的。通常它们是数字的，因为模拟存储器在操作期间会褪色，并且每单位重量需要大的电路以避免泄漏。数字重量增加了与其数字值成比例的激活量。

这些砝码存放在哪里？在本地，每个神经元的存储容量是有限的，但是如果这还不够的话，就不得不求助于外部数字存储器。更多信息请见下文“模拟与数字存储器”。

神经形态系统在无时钟设计中使用尖峰信号的异步通信。这允许通过仅在需要时通信而不是在不相关的时钟滴答时通信来节省功率。但这也使系统设计和通信基础设施变得复杂。更多信息请见下面的“系统设计”。

注意:为了从神经元阵列中获取值，我们需要将数字(例如图像中的 8 位像素)转换成脉冲串。这可以通过将强度值转换成脉冲频率来实现。理想情况下，这种转换只在数组的输入数据和输出端执行。

模拟与数字存储器:

神经网络计算需要计算 M*M 矩阵与 M 向量的乘积。m 通常在 128–4096 的范围内。

由于处理器必须按顺序计算多个这样运算，因此它需要交换矩阵，依靠外部存储器进行存储。这需要一个数字存储器，因为数值是数字。

模拟处理器必须将数值从模拟转换成数字，然后再转换回来，以对数字存储器进行操作。每个进出内存的端口都需要一个 AD/DA。这些器件需要以存储器速度工作，通常在 1GHz 的数量级，这是当前转换器的极限，需要非常大的功率。

禁止在每一层来回转换 AD/DA。因此，模拟神经网络将不得不在模拟模式下连续执行多个层，这是有噪声的并且会降低信号质量。这也需要用于多层的硬件，N 层乘 M*M 硬件乘法器块需要可用。这需要大的微芯片硅面积/尺寸。

相比之下，数字硬件可以很容易地从数字存储器中存储和检索，并且硬件可以重复使用，需要更少的微芯片硅面积/尺寸。此外，没有数据转换的开销。

系统设计:

神经形态脉冲网络使用无时钟设计和异步数字设计。很少有工程师受过设计这种系统的训练。

模拟需要更多的专业知识，而可用的工程师却更少。

神经形态系统往往比传统的数字系统 设计起来更加复杂。它们更容易出错，需要更多的设计迭代、非标准工具和微芯片工艺变化。

稀疏性:

一些系统可能在稀疏计算领域更胜一筹，在稀疏计算领域，它们只需要计算其中的一部分，而不是计算整个 2*M 运算。注意:在深度神经网络中，输入不是稀疏的(图像、声音)，但可以通过隐藏层来稀疏化。许多值为零或非常接近，可以高度量化。

让我们假设在前 1-2 层中没有稀疏度，而在一些隐藏层中有高达 100 倍的稀疏度。

传统数字系统和神经形态系统之间没有差异，因为两者都可以执行稀疏运算。我们确实需要支持稀疏矩阵乘法的硬件(目前很多深度学习框架和硬件都没有实现)！

最后注意:

神经形态系统仍然很难设计。为了扩大规模，它们需要模拟存储器或快速低功耗的 AD/DA 转换器，而这些目前还不可用。

但是，如果计算是模拟的，并且通信使用事件间定时，则它们可以节省大量能量。

关于作者

我在硬件和软件方面都有将近 20 年的神经网络经验(一个罕见的组合)。在这里看关于我:媒介、网页、学者、 LinkedIn 等等…

新的试点研究表明，机器学习可以预测暴力学生

原文：towardsdatascience.com/new-pilot-s…

在暴力事件或悲剧发生后，你经常会听到许多关于潜在预防措施的猜测。

以枪击事件为例，人们通常会谈论袭击的迹象或前奏。这本来是可以避免的吗？那些接近攻击者的人看到了他们应该报告的什么？

很多人分享他们对这件事的看法，但这并不一定能揭示现实情况。甚至有可能找到一种可靠的方法来防止这些悲剧吗？

最近的一项研究可能会提供一些答案和一些希望。

有可能预测青少年的暴力行为吗？

当一个孩子遇到麻烦并表现出暴力或攻击的迹象时，很明显，他们需要支持，那些接近他们的人或心理健康专家可能会提供支持。

在任何人获得帮助之前——成年人也是如此——必须有人注意到潜在的问题。不幸的是，这些问题并不总是显而易见。这是一件很容易被忽略的事情，即使是对需要帮助的孩子的父母来说。

那么，答案是什么？我们如何识别或知道某人何时需要帮助？现代技术似乎可以提供一个解决方案。

来自辛辛那提儿童医院医疗中心的研究人员发现，机器学习可以准确地确定校园暴力的风险。

他们发表在 T4 精神病学季刊杂志上的研究指出，这可能和一组儿童精神病学家甚至法医精神病学家一样准确——如果不是更准确的话。

机器学习有什么帮助？

首先值得注意的是，这项研究仅仅表明预测攻击性是可能的。这并不能证明机器学习技术可以防止校园暴力。

需要进一步的研究来确定这一点，但是解决这个问题是研究小组的“下一个目标”

然而，研究人员得出结论，他们可以为问题行为提供更准确的方法，这本身就是一个巨大的发现。

“以前的暴力行为、冲动、学校问题和消极态度与对他人的风险相关，”医学博士德鲁·巴兹曼说。巴兹曼是这项研究的主要作者，也是辛辛那提儿童医院医学中心的儿童法医精神病学家。

这项研究涉及来自 74 所美国学校的 103 名青少年学生，他们表现出行为变化和攻击性。包括在内的许多学生是从精神病门诊或住院诊所和急诊科招募的。

研究小组根据他们开发的风险等级量表将参与者分为两组。他们通过使用从录音中转录的评估来做到这一点。

在直接采访后，研究人员评估了两组人表现出暴力行为的可能性。他们使用机器学习算法分析了他们获得的信息，该算法实现了 91.02%的预测准确率。

当他们还包括参与者的人口统计和社会经济数据时，准确率上升到 91.45%。

合著者赵毅·尼博士是辛辛那提儿童医院生物医学信息学领域的计算科学家，他证实了该系统的准确性。

倪说“仅基于参与者访谈的机器学习算法，在评估风险水平方面几乎与我们研究团队的全面评估一样准确，包括从家长和学校收集信息，审查可用的记录，并在我们开发的两个量表上评分。

这在现实世界中意味着什么？

根据这项研究，机器学习可以预测暴力。但是这对公共安全的未来意味着什么呢？有可能完全防止暴力袭击吗？

真实的答案是我们还不知道。研究人员将进行进一步的研究，看看他们的技术是否有助于完全防止暴力。我们需要等待，然后才能得出任何结论，但这项初步研究表明，机器学习在这一领域可能是有用的。

至于机器学习行业，这项研究提供了证据，表明这是现代社会的另一个领域，这项令人生畏的技术可以改善。

这些发现将进一步支持该行业，并有助于引入该技术的新用途。例如，如果事实证明你可以使用机器学习工具来防止校园枪击事件，那么你可以预测并潜在地阻止哪些其他暴力事件？

时间会证明一切，但很可能不久的将来，机器学习会让我们的生活变得更安全、更美好。

图片由 Pixabay 组成

纽约寻求俳句:从纽约市政府职位描述中产生俳句

原文：towardsdatascience.com/new-york-se…

六年前，纽约市通过了一项法律，要求市政机构公开他们的数据。从那时起，超过 1600 个数据集已经在该市的开放数据门户上可用，并且新的数据不断提供。

开放数据周——纽约市长数据分析办公室在全市范围内开展的活动——是对这一进步的庆祝，并与数据贯穿设计展览同时举行。这次展览的目的是挑战艺术家们使用这些公开的数据来讲述关于这座城市的有见地的有趣的故事。

作为一名土生土长的纽约人、数据科学家和公务员，这个挑战激起了我的兴趣，因为以创造性的新方式使用城市数据是我的工作。

需要 40 万名政府雇员来维持纽约市(美国人口最多的大都会区)的运转。从维护基础设施、提供应急服务，到创造减少浪费、无家可归和犯罪的创新方法，这一切都归结于他们。

因此，对于《设计中的数据》,我想讲述 40 万人在幕后工作的故事，以及他们是如何让我的家乡保持生机和繁荣的。最终，这个概念演变成一个程序，根据市政府工作的职位描述，通过算法生成俳句。

纽约市寻求

这些数据来自纽约市工作数据集。它包含纽约市官方招聘网站上的最新招聘信息。开放数据门户上的大部分数据都是关于城市发生了什么，城市做了什么。这个数据集让我们得以一窥这些事情背后的人和事。

每个职务公告都包含机构、薪资范围和发布日期等信息。对于这个项目，我使用了三栏:公务员职称、职位描述和职位资格。

此外，我使用了一个数据集，其中包含 Jim Kang 的 phonemenon 中单词的音节数。我不得不修改数据，以包括非标准的单词，如机构缩写(即 NYPD，4 个音节和点，3 个音节)。

生成俳句

目标是利用纽约市的工作描述来创作俳句。俳句最初是日本的一种诗歌形式，包含三行，第一行五个音节，第二行七个音节，第三行五个音节。

为了创作一首俳句，我使用了一种定制的马尔可夫链方法。马尔可夫链是一种在给定当前值和当前值之后的值的概率的情况下生成序列的技术。在这种情况下，给定一个单词，接下来可能是什么单词？

第一步是确定这些概率。我按公务员头衔(计算机系统经理、油漆工、土木工程师等)对数据进行了分类。)和首选技能字段中的文本建立了一个单独的数据语料库。然后我把语料库拆分成句子，把句子拆分成单词，统计 A 跟着 b 的次数。

下面的例子显示了计算机系统经理在“数据”后面最常用的词。给定一个这样的表，马尔可夫链将随机选择一个按概率加权的下一个单词。然后，它将得到这个单词，并一次又一次地重复这个过程。

因为我在创作俳句，所以我有严格的音节限制。我只考虑下一个符合音节限制的单词。例如，如果我在第一行(5 个音节)，我当前的单词是“数据”，我不会选择“分析”或“整合”作为下一个单词，因为这会将该行置于 5 个音节之上。

在这个过程中，当在音节限制内没有有效的选择时，生成器有时会将自己写入一个不可能的状态。在这种情况下，它会返回并尝试一个新词，看看它是否会导致一个有效的俳句。

俳句以一种原始的状态出现在这个过程中——全部是小写，没有标点符号，有时它们就是不太好。我发现的最大问题是，因为俳句太短，结果往往是不完整的想法。

马尔可夫链会在一个句子的中间，当它达到音节数时突然停止。我试图通过只使用符合逻辑的结尾词来纠正这一点，但这并不适用于所有情况。

例如，以下两句都以“设计和施工过程”结尾，但只有第一句是完整的句子:

与项目负责人 一起创建设计和 施工流程

和

纽约市 设计部 施工流程

有些结果实际上很有趣:

环境 和环境 和环境。

和

新城市 纽约市:开放的数据， 开放的政府。

通过一个半手工、半自动化的编辑过程，我清理了俳句，以获得像样的结果。最后一篇有 750 多首俳句。

增加观众参与度

我现在有能力创作俳句；但是我应该如何呈现它们呢？我想给一些算法如何工作的见解。为此，我决定展示反复创作的俳句。该算法尝试的每个单词都会显示出来，当遇到失败状态时，它会删除单词并再次尝试。

这是它的样子:

展览组织者 Michelle Ho 建议将这些俳句印在标签上，这样它们就可以作为纪念品带回家，供设计展览的观众参考。

我添加了一个按钮，按下后会生成并打印下一首俳句:

其结果是对该市公务员的一些职责和技能进行了异想天开的互动审视。

以下是一些我最喜欢的:

纽约市 政府是一个加号，但 不是必需的。

财务部正在寻找 一名充满活力的实习生来 发挥团队作用。

确保数据 准确、整洁、及时并 准备好接受审计。

对 干线水和废水 收集系统的深刻认识。

谁想成为 信息 安全人员的一部分？

此文原贴于 数据驱动新闻 。

感谢 Abigail Pope-Brooks 的编辑和反馈。

所有用到的代码和数据都可以在github上找到。杰里米·内曼在他的网站上做着同样毫无意义的事情:http://jeremyneiman.com/

纽约人应该学会与老鼠相处，因为它们不会离开:数据可视化。

原文：towardsdatascience.com/new-yorkers…

一个风和日丽的夜晚，我和丈夫在华盛顿广场公园散步时，注意到一对微笑的年轻游客夫妇带着一个小女孩向我们走来。女孩很可爱，直到她开始尖叫。她一边爬上父亲的身体，一边尖叫着指着一只从公园长椅下跑出来的大老鼠。父母停下了脚步，老鼠也一样。

More rats or more complaints? Probably both: 98,273 rat complaints to NYC 311 from 1/2010 through 7/2017.

我以为老鼠会继续跑，因为只差一只脚就可以到达一个可爱的安全花坛了，但是它纹丝不动。为了帮忙，我跺着脚，朝老鼠走去，这应该能让它立刻动起来。但是那只老鼠坚持住了，直到我靠近得不舒服，它才最终让我们都走了。

18 世纪，老鼠乘坐英国船只来到纽约，然后开始大量繁殖。虽然它们会对健康和 T2 的财产造成威胁，但纽约市喜欢谈论它的老鼠，有时甚至会吹嘘它们。还有披萨鼠，他英勇地检索了一份普通的切片，有近 1000 万的浏览量；雪鼠，被暴风雪挡不住的人；自动扶梯鼠，其无休止的无处可逃很容易理解，以及垃圾鼠，其拖着一整袋垃圾穿过人行道。

纽约的居民区一直在为最糟糕的老鼠问题而竞争。华盛顿高地/因伍德的老鼠最多，或者可能是上西区或者是上西区，特别是靠近中央公园的地方。不，上东区。还是东，但是真的[东哈林](http://East Harlem www.dnainfo.com/new-york/20… Flatbush](www.amny.com/news/nyc-ra…) 。获胜的地区在任何时候都不快乐。尽管由于老鼠在医学研究中的重要性，它是第三个被测序的哺乳动物，但它并不被人类视为邻居。

老鼠似乎在四处活动，热点地区随着季节和城市努力对抗老鼠数量激增而潮起潮落。纽约市的 311 系统接受电话或在线投诉以及关于任何非紧急事件的问题，有一个啮齿类和老鼠子类别的分类报告。

利用纽约市 311 从 2010 年 1 月到 2017 年 7 月的数据，结合美国人口普查数据，我估计纽约市各区和邮政编码的老鼠报告数量为每 10，000 名居民 311 例。根据纽约市 311 系统从 2010 年 1 月到 2017 年 7 月记录的 98，273 次老鼠目击事件，b ehold，下面是 gif 地图，它的美丽掩盖了它背后的痛苦。一些拉链似乎比其他拉链的鼠患情况更严重，并且有一个周期性的模式(在上面的图表中更容易看到),当春天到来时，投诉增加，夏天达到高峰，然后在秋天减少。

这告诉我们当地老鼠数量的多少？混淆数据的因素是，随着时间和空间的推移，居民或多或少可能会报告看到老鼠。自纽约市 311 系统于 2003 年启动以来，随着该系统总体使用量的增加，各主题的投诉和问题平均有所增加。网络(2009 年)、文本(2011 年)和电话应用(2013 年)311 选项让纽约人越来越容易点击和抱怨任何让他们感动的东西。

老鼠一年到头都在繁殖。然而，天气变好后，纽约人会花更多的时间在户外，所以春天和夏天可能会有更多在公园和 T2 游乐场遭遇老鼠的报道。当人们觉得他们没有被倾听时，他们可能会重复报告老鼠，直到他们看到结果，产生一个尖峰。在有很多公寓、合作公寓或配有管理员和门卫的昂贵租赁房的社区，居住者更有可能让有人在现场回应他们的室内鼠患投诉。居民可能会在城市的单户住宅区对付自己的害虫。但是，如果除了 311 之外没有人听投诉，密集的无门卫建筑或无回应房东的社区可能会显示更高的老鼠报告率。此外，垃圾容器的类型(或缺少垃圾容器)因住所类型而异。一大堆暴露在外的垃圾袋等着被捡起来(曼哈顿)比被车道隔开的密封罐能喂更多的老鼠(皇后区)。

为了了解它们的起源、行为和在城市中的迁移模式，福特汉姆大学的科学家们研究了纽约老鼠的群体遗传学。更好的是，纽约市的动物生物学家，博比·科里甘，是害虫管理专业名人堂的成员，倡导人类和老鼠共存的科学方法，并经营啮齿动物学院。市长们制定了一系列策略来对抗老鼠，包括捕鼠器、垃圾控制和生育控制。最近，一项耗资 3200 万美元的多管齐下的计划宣布实施，包括使用干冰来减少老鼠数量。与此同时，老鼠仍然可以向当局告密。这不会有什么坏处。

数据操作，图表和地图 gif 均在 R 中完成。数据操作和数据可视化的代码可以在我的 GitHub 库 中找到。

感谢您的阅读。

我欢迎反馈——您可以“鼓掌”表示赞同，或者如果您有具体的回应或问题，请在此给我发消息。我也有兴趣听听你想在未来的帖子中涉及哪些主题。

阅读更多关于我的作品【jenny-listman.netlify.com】。欢迎随时通过 Twitter@ jblistman或LinkedIn联系我。

数据和图像来源:

1. 纽约市 311 系统的老鼠报告是从纽约市公开数据下载的。在纽约市开放数据上使用了一个过滤器来识别“描述符”=“发现老鼠”https://Data . cityofnewyork . us/Social-Services/311-Service-Requests-from-2010-to-Present/er m2-nwe 9/Data的条目。在 R 中，数据被过滤以移除 2017 年 8 月的条目，因为该月不完整。
2. 由 Ari Lamstein 从 R 包choropethryzip版本 1.5.0 中导入每个纽约市邮政编码的人口规模，并且是对 2012 年人口的估计。github.com/arilamstein…。这些数据基于美国社区调查(ACS) 5 年的估计。他们是由邮政编码列表区，而不是邮政编码。邮编与 ZCTA 的关系可以在美国人口普查网站上找到。www.census.gov/geo/referen…。
3. 纽约老鼠图，由阿基瓦·利斯曼提供。 @akivalistman

新手深度学习指南

原文：towardsdatascience.com/newbies-gui…

当开始 DL 时，慢慢地走

已经有相当多的人问过我如何开始机器学习和深度学习。在这里，我整理了一份我第一次学习机器学习时使用的资源和选择的路径的列表。我会继续更新这篇文章，因为我找到了更多有用的资源。

免费课程

从吴恩达在 Coursera 上的机器学习课程开始。这将教会你机器学习的诀窍，并稍微提高你的线性代数技能。确保你完成了所有的作业，在你完成课程后，你将掌握机器学习的概念，例如；线性回归、逻辑回归、SVM、神经网络和 K-均值聚类。在学习本课程的同时，你还有机会建立一个玩具推荐系统。这会让你大开眼界，让你更有信心进一步进入人工智能和深度学习的领域。但是请注意，还有很多其他重要的概念，本课程无法涵盖。所以，学完这门课后，准备拓宽你的知识面。如果你在完成 ng 博士的课程后非常兴奋，你应该看看他的其他课程，这些课程是 Coursera 上深度学习专业化的一部分。

Fast.ai 提供关于深度学习的免费在线课程，他们在课程中提供两个部分:

• 深度学习第 1 部分:程序员实用深度学习
• 深度学习第二部分:程序员的前沿深度学习

在那些课程之后，你可能已经准备好处理辛顿的用于机器学习的神经网络了。与前面提到的课程相比，Hinton 的课程相对更难，因为讲课内容相当枯燥，而且包含更多的数学概念。如果你觉得你还不能掌握这门课程，不要气馁！把它放一会儿，做数学部分(在下一节描述)，然后回来。这次你一定能攻克这门课程！记住，决心，决心，是的，更多的决心。

数学

深度学习肯定需要你对线性代数、微分学、向量微积分有很强的掌握，这只是其中的几个例子。如果你想快速温习一些初等线性代数并开始编码，强烈推荐 Andrej Karpathy 的黑客神经网络指南。我发现 hadrienj 在深度学习书籍上的笔记非常有用，可以实际了解底层数学概念如何使用 Python (Numpy)工作。如果你喜欢从视频中学习， 3blue1brown 有一个最直观的视频，介绍线性代数、微积分、神经网络和其他有趣的数学主题。在一个基于非卷积的问题上实现你自己的基于 CPU 的反向传播算法也是开始真正理解反向传播如何工作的好地方。

变得严肃

如果你想把你的机器学习知识提高一个档次，并准备认真对待(我指的是研究生水平的认真对待)，那么就投入到加州理工学院教授亚塞尔·阿布-穆斯塔法的从数据中学习吧。做好计算的准备。这可能有点挑战性，但一旦你经历了这一切并完成了你的工作，这绝对是值得的。我相信教科书很难捕捉深度学习的当前状态，因为该领域正在以非常快的速度发展。但是最重要的教科书应该是古德费勒、本吉奥和库维尔的深度学习书籍。它可以在网上免费获得，所以你也可以一章一章地下载，一章一章地学习课本。

报纸，报纸，报纸，该死的，我再也追不上了

是的，深度学习的知识主要来自论文，这些论文的出版速度非常快。Reddit 是一个很好的起点。订阅 /r/machinelearning 和 /r/deeplearning 。不过，我发现机器学习 subreddit 更有用。 ArxivSanity 是查阅与你要找的论文相关的论文的好地方。深度学习看论文的时候有一点很重要，就是做好文献综述。做一篇好的文献综述会让你对事物的发展有一个很好的认识。解决做文献综述的一个方法是安装谷歌学术 Chrome 扩展并搜索你想要查找的论文。您可以通过“相关文章”和“引用者”来跟踪之前的工作以及基于该论文的新工作。阅读论文时要养成的一个好习惯是画出论文中概念的思维导图。

I drew this mind map when I read a paper on few-shot learning [1]— drawn with SimpleMind Lite

思维导图的优势在于，它是一种跟踪论文中出现的概念之间关系的好方法。我发现思维导图对于跟踪相关文献以及它们与我正在阅读的论文之间的关系非常有用。思维导图让我对论文有一个清晰的了解，也是我阅读论文后的一个很好的总结。

我发现 Twitter 对于跟踪机器学习和深度学习研究非常有用。你可以从追随 ML/DL 领域的知名人士开始，然后从那里扩展开来。正如我通常转发关于对抗性机器学习和自动驾驶汽车的研究一样，你也可以在 twitter 上关注我，并将其视为你的供稿。你可以做的是查看我转发的人，查看他们的推文，关注他们圈子里的其他研究人员。一旦你提供了足够的数据，Twitter 还会推荐优秀的人来关注，也就是说，关注了足够多的 ML/DL 研究人员(ML FTW！).

卡格尔

我不能强调 Kaggle 有多有用。我强烈建议尝试一下 Kaggle 比赛，即使你进入前 100 名的机会很小。Kaggle 比赛的价值在于社区。阅读内核并从中吸取好的实践。阅读评论并参与讨论。在那里你会学到很多东西。您将学习人们如何进行探索性数据分析，以及他们如何处理各种缺失数据、扭曲数据等情况。您还将了解人们如何决定为什么选择某些型号而不是其他型号。Kaggle 比赛中有很多知识。

灵感

机器学习的可视化介绍是直观掌握统计学习技术如何用于识别数据中模式的好方法。

谷歌的种子库是获得灵感的绝佳资源！看看例子，跟着文献走。

distilt . pub 是一个交互式学习一些 DL 概念的好地方。我希望蒸馏有比现在更多的文章。

冰山一角

除非你把自己学到的东西付诸实践，否则什么都不重要。ML 和 DL 听起来很神奇，直到你自己实现了整个管道。整个流程包括数据源、数据收集、数据质量评估、数据清洗、数据注释、数据预处理、构建工作流、构建模型、调整模型、评估模型、部署模型和重复模型。这些步骤只是整个 ML/DL 流程中的一些步骤。那些做过全面 DL 工作的人知道尽可能简化整个开发操作是多么重要。不仅整个数据源、收集、注释、清理和评估步骤至少占整个项目的 60%,而且它们可能是项目中最昂贵的部分之一(除了耗电的 GPU！).

总而言之，ML/DL 领域是一个成长中的领域，你必须保持你的耳朵、眼睛和头脑的开阔。不要仅仅因为一篇论文/博客/教程/个人/YouTube 视频说某个新技术在特定数据集上表现很好，就跳到这个新技术上。我见过许多闪亮的新技术来得快去得也快。始终意识到区分信号和噪声是非常重要的！

这篇文章是活生生的事。您的反馈对我很重要。请对我应该添加哪些资源以及您在学习 ML/DL 时发现哪些资源最有帮助发表评论。非常感谢你的阅读！

[1] Triantafillou，e .，Zemel，r .，& Urtasun，R. (2017 年)。通过信息检索镜头进行少量学习。在神经信息处理系统的进展(第 2255-2265 页)。

下一代人工智能驱动的组织——一个警钟！

原文：towardsdatascience.com/next-gen-ai…

在许多决定性的战役中，战线被划定，战略被制定，胜利者出现了。然而，有时，令人遗憾的是，战斗的失败是因为完全的无知——甚至不知道战线在哪里——更可悲的是，自欺欺人。

Forrester 的一份精彩分析报告称，到 2021 年 ，40 家“洞察驱动型公司” 将攫取 1.8 万亿美元——很可能其中一部分将从你的公司市值中剥离。在这份名单中，我们有成立不到 8 年的年轻公司。是什么将它们统一起来？他们对数据和人工智能的痴迷。

概括地说，关于人工智能的采用，组织分为两类:

首先，我们有“空谈者”:有一些组织对他们通常所说的“人工智能计划”犹豫不决——在组织筒仓中采取小的风险规避措施，被官僚机构和少数人纠缠，不幸的是，他们更关注媒体报道而不是实际结果。

然后我们有"实干家":这些是洞察驱动的公司，它们已经将分析人工智能集成(或正在大力集成)到它们的组织结构中。这些组织有一个整体的方法，我想称之为**“人工智能支持的价值链”**。

你是哪一个，你想去哪里？

博客的其余部分是关于如何通过成为“实干家”来赢得 AI 的战斗

1。瞄准人工智能驱动的价值链

三个关于远见者的故事，他们体现了更深入和更广泛地采用人工智能来推动整个组织的真正创新的想法。

Source: stitchfix.com

输入针脚位置。在亚马逊这样的巨头中开始网上服装零售业务？没问题——成立于 2011 年，现在 stitch fix 估值 44 亿美元。怎么做到的？有意识地关注数据和人工智能。

所有零售商从品牌制造商那里得到的标准数据点很少:尺寸等。然而，Stitch Fix 致力于为每件衣服提取多达 80 个属性,如衣领类型、纽扣数量等。他们使用机器学习来估计基于照片的详细的服装尺寸(例如袖子和裤腿轮廓)。当他们向人们匹配(推荐)衣服时，这些数据点给了他们竞争优势(他们每人大约有 75 个数据点)。你喜欢双领衬衫还是木纽扣？没问题——他们会想出办法的。

他们将数据和人工智能应用于整个价值链:从仓库分配、客户与人类造型师的匹配，一直到为新服装项目创造设计。

这个地区的一个典型例子是网飞。电影推荐引擎只是故事的一部分。想想这个:新电视节目的行业成功率是 35%——然而网飞有 70% 。怎么会？《绿色照明》之前,《纸牌屋》的第一部大制作(投资 1 亿美元！)，网飞转向其过去的数据来预测成功率和因素。剩下的就是历史了。网飞甚至对你浏览时显示的海报进行了优化，它使用人工智能进行质量控制(识别低质量的媒体)和优化内容交付(将哪些媒体运送到离你最近的内容交付网络)

Source: earnest.com home page

最后一个故事是关于认真的。2014 年推出的数字贷款机构。他们的业务是以比传统金融机构更低的利率发放贷款，而传统金融机构已经存在了一段时间。怎么会？更全面地承担风险。他们的算法考虑了关于申请人的大约 10 万个数据点，包括非传统的数据点，如教育、职业轨迹等。截至 2017 年 10 月，它已经发放了 100 亿 2B 的学生贷款，并拥有大约 5 亿美元的贷款组合。

**要点:**从大处着眼，从战略角度思考——询问数据&人工智能如何帮助你在价值链的各个方面进行创新。当然，当你执行时，你会优先考虑——然而，这里的关键点是要有一个大的图景在你面前，这样你就可以有效地在整个组织中渗透愿景，并授权愿景的执行。

2。了解炒作之外的可能性的高管赞助商

艾无疑被炒作。用这一领域的杰出领袖迈克尔·乔丹(加州大学伯克利分校教授)的话来说:“今天大多数被称为人工智能的东西，特别是在公共领域，都是过去几十年来被称为机器学习(ML)的东西”。

出自获得计算机科学最高荣誉图灵奖的朱迪亚·珀尔:“深度学习所有令人印象深刻的成就，都不过是曲线拟合而已”。

轻松地说，我在网上读到了这句真实但有趣的俏皮话:几年前人们谈论*“训练他们的人工智能模型】——现在人们谈论“教人工智能系统理解图像”。*

然而，除了这种宣传，今天的现有技术还有很多可能性:帮助更快地识别肿瘤，半自动汽车，个性化营销，识别欺诈——我可以继续下去。只要有历史数据可以学习，我们就有可能通过利用机器学习而受益。

我认为执行发起人应该理解这些界限，这样他们就可以避开炒作，通过开发可能的领域来交付切实的商业价值。进入Katrina Lake——Stich fix 的创始人兼首席执行官。Katrina 试图拉拢网飞数据科学副总裁 Eric Colson 加入 Stich Fix。几次会面后，科尔森得出结论:“桌子对面的人是他的长期老板、网飞创始人雷德·哈斯汀斯的智力克隆”。科尔森说“你给他们一点信息，他们就能描绘出一幅与现实相符的生动画面”。(来源:inc.com)

高管们请注意:花时间与这方面的专家一起了解人工智能的基本原理。这将有助于你避开炒作，并提供切实的价值。

3。整体考虑人工智能:风险&责任

在你的组织中采用 AI & ML 不仅仅是为了一个指标(点击、浏览、销售等)而优化。是的，商业价值是人工智能采用中的一个重要维度——然而，还有其他关键领域需要考虑:管理风险(对你的组织)和责任(对社会)。

一个关于风险的故事:

2018 年 3 月 18 日，晚上 9 点 39 分，15 摄氏度气温:一辆优步自动驾驶汽车在亚利桑那州坦佩市启动自动驾驶模式，车内有一名司机。接下来的 19 分钟它将处于自主模式。

晚上 9 点 58 分: 49 岁的伊莱恩·赫尔茨贝格推着自行车过马路。汽车撞上了伊莱恩，杀死了她。

引用 SFGate 的话:“毫无疑问，激光应该看到她，”硅谷企业家布拉德·邓普顿(Brad Templeton)说，他是谷歌自动驾驶项目的早期顾问。“我知道技术比这更好，所以我确实觉得这一定是优步的失败。”

**结局:**一命呜呼。为了让事情变得更安全，优步暂时关闭了自动驾驶车队(也有很多负面报道)。

**问题:**如果有稳健的训练数据&综合测试过程(在不同光照/天气条件下)，这种情况是否可以避免？我们应该有监控安全驾驶的技术吗？也就是说，在让它上路之前，值得问很多问题吗？

一个关于责任的故事

人们无时无刻不在被谷歌搜索:开会前，求职申请等。拉坦娅·斯威尼的一位同事在谷歌上搜索她，发现了一则广告，上面写着“拉坦娅·斯威尼被捕了？”

Source: https://arxiv.org/pdf/1301.6822.pdf

Latanya Sweeney 是哈佛大学的一名教授，以揭露过去的挑战性问题而闻名，他研究并发现了基于搜索与种族相关的人名的广告投放系统中具有统计意义的歧视。她勇往直前，发表了一篇广受好评的论文。

要点:作为人工智能战略的一部分，组织需要同时考虑风险(治理、风险&合规性)和责任(公平、隐私等)。如果这不是自愿的和直接的，总有一天会在压力下和非常糟糕的情况下完成。我将在接下来的博客中分享更多这方面的信息。

临别赠言

在这篇博客中，我概述了三个方面，我认为这三个方面对于在 2021 年 前获得 1.8 万亿美元的份额是必不可少的:以人工智能驱动的价值链为目标，高管赞助商需要关注炒作之外的可能性，并设计一个整体的人工智能战略——除了商业价值之外，还包括风险&责任

问题是:你是要得到你的那份，还是要被瓜分？一个快速的新闻稿让你高兴还是你愿意投资于人工智能战略的整体方法？你准备好长期坚持了吗？你是实干家吗？

我打算就这个话题发表更深入的想法。我的坐标: LinkedIn ，Twitter&Medium

NFL 球队进攻位置支出与赛季成功

原文：towardsdatascience.com/nfl-team-of…

被标记的数据新闻、数据故事、数据可视化

甚至在 3 月 14 日正式的 NFL 自由球员时期开始之前，就已经有了大量的签约。球队渴望在他们最弱的位置升级他们的名单，目标是更强大的 2018 年运动，甚至是长期的成功。虽然最好的球员倾向于获得更高的合同，但支付最高工资的球队并不总是获得最高的成功。即使下赛季有 1.77 亿美元的上限，球队也支付不起每个人的工资。有影响力的玩家的明智支出仍然是必要的。在下面的报告中，我将分析和报告 2017/2018 赛季球队承诺支付给进攻球员的工资，并了解这种财务承诺与进攻生产之间的关联。

以下是该报告的一些关键要点: ·洛杉矶公羊队是全美橄榄球联盟中进攻最高效的球队，每场比赛得分最高，同时也是五种最便宜的进攻之一。奥克兰突击者队的进攻严重不足，尽管拥有第二高薪的进攻人员，但场均仅得 18 分。 【当根据输赢记录组织球队时，最成功的球队比输赢记录差的球队在跑卫和紧逼端上花费的进攻预算比例更高，而最差的球队比输赢记录好的球队在进攻线员和外接手上花费的比例更高。 2017/2018 赛季 NFL 球队分配给进攻人员散点图:分配的薪资($) vs 场均得分

这种可视化着眼于最近一个赛季，并试图回答以下问题:在进攻上花费最多的球队是否得到了最高分的回报？答案并不总是如此。正如你所看到的，图表沿着 x 轴划分了进攻总工资(根据OverTheCap.com)和每场比赛的平均得分。 低收入&低产出球队:这些球队在进攻支出上低于联盟平均水平，这导致得分低于联盟平均水平，这并不奇怪。这个象限主要由没有接近季后赛席位的球队(丹佛野马队、印第安纳波利斯小马队和克利夫兰·布朗队)组成，但像水牛比尔队和田纳西泰坦队这样的季后赛球队找到了进入季后赛的方法，因为强大的防守表现弥补了令人印象深刻的进攻支出和生产。 工资低但产量高:这个象限由在进攻球员上花费不足(相对于 NFL 球队的平均水平)但场均得分高于中值的球队组成。洛杉矶公羊队以一种巨大的方式完成了任务，在得分上领先联盟，尽管在进攻上的花费比一般球队少得多。 高收入&高产:这个群体是另一个理论上有意义的群体。在进攻上花费更多的球队获得更高的进攻输出。超级碗的参与者，新英格兰爱国者队和费城老鹰队都属于这一组。 高薪但生产不足:为表现不佳的球员超支的球队。这是一个零成员进入季后赛的象限，并且是最近几个赛季令人失望的季后赛球队(绿湾包装工队和奥克兰突击者队)的头条。

2017/2018 NFL 赛季:进攻人员每百万美元花费的得分

这从另一个角度审视了球队在进攻球员上花费预算的效率。这里的新指标在左边的第一列，它简单地除以本赛季每场比赛的平均得分，再除以每支球队的进攻预算(表示为每百万美元分配给进攻人员的得分(每场比赛)。如前所述，洛杉矶公羊队在得分上领先 NFL(每场比赛近 30 分)，同时在进攻上的支出明显低于平均水平(6350 万美元)。公羊队在支出效率方面领先联盟，每场比赛在进攻人员上花费 100 万美元，可以得到 0.47 分。薪资效率第二高的进攻是旧金山 49 人队，每 100 万美元的支出平均每场得 0.44 分，仅 20.69 分，低于场均得分的中位数，但在所有 NFL 球队中，进攻支出最少。这里要注意的是吉米·加罗波洛是在新秀年的最后一年年中被带来的，只首发了少数几场比赛。虽然像我一样的 Niner 球迷希望整个赛季的 Jimmy G 能够大幅提高球队的得分，但他今年早些时候签署的创纪录协议意味着旧金山将不再是足球界最便宜的进攻之一。与此相反的是奥克兰突击者队，他们令人失望的低迷表现导致每场比赛每百万进攻人员的花费只有 0.2 分(不到公羊队 0.47 分的一半)。

球队进攻工资分配到各个进攻位置的比例(近 5 个赛季)

为了这个可视化，我按照胜场数(0–4 胜，5–8 胜，9–12 胜，13–16 胜)将每支球队的过去五个赛季分成四个象限。对于每个象限，这里分析了每个队分配到每个位置的进攻预算的百分比。当看进攻人员时，最成功的球队(13-16 胜)在跑卫和紧逼端的支出上领先所有象限(分别占进攻人员工资的 11.22%和 12.37%)，而这些球队在外接手支出上落后于所有其他象限。过去 5 年中最差的球队在分配给进攻线球员和外接手的工资上领先所有象限(分别为 38.2%和 22.7%)，同时是唯一一个将进攻工资的 20%以下花费在四分卫上的象限(17.5%)。一年赢 5 到 8 场比赛的球队在四分卫身上花的钱最多(进攻工资的 22.65%)。

%的工资总额分配给职位(5 年)

根据过去 5 年的胜利，再次将 NFL 球队划分到相同的象限，这看起来是球队在每个位置上的花费占当年 NFL 总工资帽的比例。从广义上来说，更多的钱导致更多的胜利:13 到 16 个赛季的球队在进攻人员上花费了 NFL 工资帽的 49%(比联盟中位数高出 11.5%)。然而，在研究具体的职位时，结果却不尽相同。是的，当谈到进攻线手(+29.5%)、跑锋(+51.8%)、紧逼端(+61.9%)和外接球手(+19.7%)时，最成功的球队确实比联盟的其他球队花费得多。然而，这个象限在四分卫上的花费比联盟中位数少 9.4%。胜场数在 5-8 场的球队实际上在四分卫上花费最多(比联盟中位数多 19.5%)。

总之，虽然每个球员和每份合同都是独一无二的，但可以肯定的是，为最昂贵的球员花钱将意味着更多的胜利。从最后的图表中可以看出，在进攻球员上花费最多的球队确实有最好的胜率，但在四分卫上的花费比那些错过季后赛的球队少。

感谢您阅读我最新的数据帖子。作为一名产品营销和数据分析专业人士，我对数据支持的讲故事充满热情。这些数据新闻帖子是我将真实数据与我个人的不同兴趣整合起来的方式，这些兴趣包括从旅行和娱乐到经济和社会问题的任何事情。 如果您有任何评论、故事想法或预期的数据项目，请随时发送电子邮件至 dwpwriting <至> gmail < dot > com 或通过 LinkedIn 联系我。

原载于 2018 年 3 月 14 日dwpeterson.com。

NFL——在 NFL 中赢得第一节真的重要吗？

原文：towardsdatascience.com/nfl-which-q…

座右铭:坚强地开始。建立小的胜利。每个季度都要赢。

Bill Maher — Irritable Bowl Syndrome; Directed and Animated by Fraser Davidson

背景

人们会认为阿尔·帕西诺关于足球的方法论在任何给定的周日都是正确的，那就是:足球是一寸一寸赢得的。但是特定的英寸有关系吗？在这种情况下，我们指的是 NFL 比赛中的四或五节。如果一个队每个季度都赢了，显然他们赢得了比赛。有道理，但是，第一节的胜利与游戏结束时的胜利有关联吗？如果一个团队在比赛开始时打得太努力，会不会导致过早过度，从而在真正重要的最后英寸处留下有限的凶猛？球队真的能等那么久才全力以赴吗？或者说提前获胜实际上是为赢得整场比赛定下了基调？幸运的是，有现成的数据来满足我们的渴望！

概观

在本帖中，我们将通过使用 NFL 数据集解决一个完整的机器学习问题。我们的目标如下:

使用提供的 NFL 数据，开发一个模型来评估和预测在第一季度获胜的球队与在整个赛季中获胜的球队之间的相关性。

首先，让我们回顾一下开发此解决方案的基本方法。这是一个监督回归机器学习任务。这意味着我们已经获得了一组具有各种目标的数据(在这种情况下是每个季度的分数)，我们希望训练一个可以学习将功能映射到目标的模型。

我们将使用来自NFL scrapr-data repository的 NFL 数据集，我们的核心数据集是 nfl_season_pbp_dataset 。你也可以直接从我的 GitHub 库下载这个数据集。注意:在我们的评估中只使用了常规赛的数据。

重点提醒:数据科学保持头脑清醒的一个定律: 相关性不代表因果关系 。这是一个常用的统计阶段，用来强调两个变量之间的相关性并不意味着一个导致另一个。

说到这里，让我们开始吧！这里是我的 github 笔记本的链接，了解更多细节&解释。

数据导入和分析

import pandas as pd  # data manipultion librabry
import numpy as np # numerical computation library# Display up to 120 columns of a data frame
pd.set_option('display.max_columns', 120)# Data Visualization
import seaborn as sns
import matplotlib.pyplot as plt 
%matplotlib inline
from matplotlib import style# Internal ipython tool for setting figure size
from IPython.core.pylabtools import figsize

数据接收

# Data Imports
nfl_df = pd.read_csv('nfl_season_pbp.csv')
nfl_df.shape
nfl_df.tail()

Figure 1 — Core NFL Play by Play Dataset

为了理解按季度关联分数差异的目的，我们需要评估分数和其他特征如何影响整个游戏。现在，我们将假设各个季节基本上是相互独立的(我们可以用我们天真的能力来更新我们的假设)。因此，对一个特定游戏的预测仅仅是基于单个游戏的总体数据。因此，对于每个游戏，可以帮助我们解决问题的关键栏包括:

• GameID:指定游戏的 ID
• 季度:游戏的四分之一
• posteam:进攻的队伍
• ScoreDiff:进攻队和防守队的得分之差(offensive.score — def.score)
• ydstogo:第一次进攻的距离
• 码。获得:游戏中获得的码数
• 触地得分:二分制:如果比赛的结果是得分，则为 1，否则为 0
• No_Score_Prob:半场内没有得分的概率
• EPA:考虑到比赛结果，增加了控球队的预期分数
• 拥有球权的队伍获胜的概率增加了

按季度关联所有游戏

接下来，让我们从高水平上看一下每个季度所有比赛的得分差异的相关性。

fig, ax = plt.subplots(figsize=(8,6), dpi = 72)ax.set_title("Average Score Difference by Quarter", fontsize = 18)
ax.set_xlabel('Quarters', fontsize = 15)
ax.set_ylabel('Game Score Differnece (Absolute)', fontsize=15)
plt.xticks(fontsize = 13)
plt.yticks(fontsize = 13)nfl_df.groupby(by=['qtr']).AbsScoreDiff.mean().plot(kind='bar', alpha = 0.9, rot=0)
plt.show()

Figure 2 — Average Game Score by Quarters

在这里，我们可以看到从第一季度到第四季度的得分差异有显著的分布。然而，有趣的是，我们可以看到输赢的分布。是时候讨论一些数据了。

数据处理和处理

如上所述，我们将添加输赢游戏指标。在数据集中，有显示每场比赛得分的列，但是，因为这是一场场比赛的数据，所以没有总的赢/输列。因此，我们将简单地通过列season、GameID获取数据的子集，指示每个主客场球队的独特比赛。然后我们创建一个新的win_loss_df来表示哪支球队赢得或输掉了他们的比赛，然后合并新的列，这样我们就可以在季度级别上表示它。

def lastplay(df):
    # last row of data frame based on groupby filter
    if np.isnan(df.iloc[-1].Home_WP_pre) == False:
        return df.iloc[-1] 
    # last row of data frame second to last row if NA on last
    elif np.isnan(df.iloc[-2].Home_WP_pre) == False:
        return df.iloc[-2]win_loss_df = nfl_df.groupby('GameID').apply(lastplay).groupby(by=['Season','GameID','HomeTeam','AwayTeam']).agg({'Home_WP_pre':lambda x: int(round(x)),                                                                 'Away_WP_pre':lambda x: int(round(x))}).reset_index()win_loss_df = win_loss_df[['GameID','HomeTeam','AwayTeam','Home_WP_pre', 'Away_WP_pre']].rename(columns={'Home_WP_pre':'home_win',                                                                    'Away_WP_pre':'away_win'})

接下来，我们将把win_loss_df合并到NFL中，并使用 lambda 逻辑为 offesne (posteam)上的每个团队设置输赢。我们还将指定两个营业额列(InterceptionThrown、Fumble)，我们希望将其合并为每场比赛的总营业额。

nfl_df = nfl_df.merge(win_loss_df, on=['GameID','HomeTeam','AwayTeam'], how='left')# Create a Team_Win column to indicate a win loss
nfl_df['team_win'] = nfl_df.apply(lambda x: x.home_win if x.HomeTeam == x.posteam else x.away_win, axis=1)# Create a column for total turnovers for potential features
tunrover_list = ['InterceptionThrown', 'Fumble']
nfl_df['Turnover'] = nfl_df[tunrover_list].sum(axis=1)

现在我们已经知道了输赢，我们选择了一手牌，这手牌充满了对评估早期得分差异和赢得比赛/赛季之间的相关性最有影响的列(很快将被称为特征)。为此，我们将利用 groupby 函数。

nfl = nfl_df.groupby(by=['Season','GameID','qtr','HomeTeam','AwayTeam','posteam']).agg({'team_win':'mean','Win_Prob':'mean','Yards.Gained':'sum','Penalty.Yards':'sum','Touchdown':'sum','Turnover':'sum','FirstDown':'count','EPA':'mean','FirstDown':'sum',}).reset_index().rename(columns={'Yards.Gained':'Total_Yards','Penalty.Yards':'Penalty_Yards'})
nfl.tail(3)

Figure 3 — Initial NFL data frame (without box score and categories)

创建盒子分数和类别

接下来，我们将创建一个显示游戏分数和个人游戏成就的方块分数。当回顾初始数据集时，我们被提供了每场比赛的分数以及这些分数的累积。为了恰当地理解每个季度(qt)获胜球队的分布以及该季度对游戏和赛季的影响，我们首先必须有一个列来计算每个季度的总得分，并二进制表示哪个队在该季度获胜。

首先，我们首先创建一个函数来获取季度末的每个分数。下面的函数由一个数据框调用，该数据框是按季度和从进攻队(控球队)和防守队取得最后得分的队的子集。

使用 lambda 逻辑为每个进攻队设定输赢

def scores_per_qt(df):
    # last row of data frame based on groupby filter
    if np.isnan(df.iloc[-1].DefTeamScore) == False:
        return df.iloc[-1] 
   # last row of data frame second to last row if NA on last
   elif np.isnan(df.iloc[-2].DefTeamScore) == False:
        return df.iloc[-2] # last row of data frame

创建一个进攻得分表，用来计算每个队每个季度的总得分。

offensive_score_df = nfl_df.groupby(['GameID','qtr','posteam']).apply(scores_per_qt).groupby(by=['Season','GameID','qtr','posteam']).agg({'PosTeamScore':'mean',                                                                  'DefTeamScore':'mean'}).reset_index()

根据防守球队创建防守得分和进攻得分表。我们这样做是因为，在数据集中有这样的情况，控球队在本节结束时的防守得分不包括在上面的进攻得分表中。

defensive_score_df = nfl_df.groupby(['GameID','qtr','DefensiveTeam','posteam']).apply(scores_per_qt)[['DefTeamScore','PosTeamScore']].reset_index().rename(columns={'DefensiveTeam':'posteam','posteam':'PosDefTeam'})

合并进攻得分表和防守得分表，然后创建一个列来显示每个队在进攻和防守方面的最高得分，以准确捕捉季度末的得分。

score_df = offensive_score_df.merge(defensive_score_df, on=['GameID','qtr','posteam'], how='left')
score_df['PosTeamScore']=score_df[['PosTeamScore_x', 'DefTeamScore_y']].max(axis=1)
score_df['DefTeamScore']=score_df[['DefTeamScore_x', 'PosTeamScore_y']].max(axis=1)
score_df = score_df[['Season','GameID','qtr','posteam','PosTeamScore','DefTeamScore']]

为score_df创建特征，以指示每个季度的得分以及每个季度得分的差异。

score_df['qt_score_diff'] = score_df.PosTeamScore - score_df.DefTeamScore
score_df['qt_score_cumdiff'] = score_df.groupby(['posteam'])['PosTeamScore'].apply(lambda x: x.diff()) 
score_df['Pos_qt_score'] = np.where(score_df.qtr == 1, score_df.PosTeamScore, score_df.qt_score_cumdiff)
score_df = score_df.drop(['qt_score_cumdiff'], axis=1)

转置score_df并指出每支控球球队在比赛中的得分差异，然后与 score_df 合并。将nfl数据框与score_df合并。

# create df2 to indicate the ScoreDiff
df2 = pd.pivot_table(score_df, index = ['GameID','posteam'], columns = ['qtr'], values = 'qt_score_diff').reset_index()
df2 = df2.rename(columns= {1:'ScoreDiff1', 2:'ScoreDiff2', 3:'ScoreDiff3', 4:'ScoreDiff4', 5:'ScoreDiff5'})
score_df = score_df.merge(df2, on=['GameID','posteam'], how='left')nfl = nfl.merge(score_df, on=['Season','GameID','posteam','qtr'], how='left')

Figure 4 — New pbp_df that represents the data used for correlation assessment

勘探数据分析

为了更好地理解数据集中的模式，我们开始使用各种图形模型进行探索。我们将首先使用winners_of_quarters函数创建一个新的数据框，显示一支球队在过去 8 个赛季中实际赢得给定季度的总次数。

def winner_of_quarters(df):
    Score_Diff =['ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff4','ScoreDiff5']
    winner = []
    for score in Score_Diff:
        qt_winner = []
        qt_winner = df[df[score] > 0].groupby(by='team_win_str']).agg({'qt1_won':lambda x: x.sum()/ df['qt1_won'].sum(),'qt2_won':lambda x: x.sum()/ df['qt2_won'].sum(),'qt3_won':lambda x: x.sum()/ df['qt3_won'].sum(),'qt4_won':lambda x: x.sum()/ df['qt4_won'].sum(),'qt5_won':lambda x: x.sum()/ df['qt5_won'].sum()}).reset_index().rename(columns ={ 'team_win_str':'qtr','qt1_won':'Q1','qt2_won':'Q2','qt3_won':'Q3','qt4_won':'Q4','qt5_won':'Q5'})
        qt_winner = qt_winner.T.reset_index()
        qt_winner.columns = qt_winner.iloc[0]
        qt_winner = qt_winner.rename(columns=qt_winner.iloc[0]).drop(qt_winner.index[0])
        qt_winner['qt_won'] = 'qt' + score[-1:]
        winner.append(qt_winner)
    dfs = pd.concat(winner)
    return dfsqt_win_df = winner_of_quarters(nfl)# Create plot
fig = plt.figure(figsize=(15,8))
ax = sns.barplot(x="qtr", y="Win", hue="qt_won", data=qt_win_df);
ax.set(xlabel='Quarters', ylabel = 'Winning Percentage')
plt.show()

Figure 5 — Winning Percentage by Quarter for Winning Teams

上面的柱状图让我们得以一窥在一场游戏的长期运行中赢得某个特定的季度是否重要。图例显示了一个团队赢得的季度的颜色以及他们赢得其他季度的胜率，从中我们可以观察到几个关键趋势。要解读这张图表，最好先看一个例子:让我们来辨别第一季度的赢家。第一季度(Q1)的蓝色条代表所有赢得第一季度(69.7%)的球队。每个随后的蓝条表示当一个队赢得第一节时，该队赢得第二节的 52%，赢得第三节的 51%，赢得第四节的 55%，如果比赛进入加时赛，赢得加时赛的 16%。

季度得分差异(价差)

接下来，我们来看看季度价差。我们可以看到团队之间的差距很大…这也可能是动力的一个标志。这表明，赢得早的团队通常会保持领先。听起来，当一个获胜的团队定下基调时，他们通常会保持领先优势。

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10,5))
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt1_won", data=nfl[nfl.qt_wlt==1], ax=axes[0][0]);
ax.set_title('Q1 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt2_won", data=nfl[nfl.qt_wlt==1], ax=axes[0][1]);
ax.set_title('Q2 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt3_won", data=nfl[nfl.qt_wlt==1], ax=axes[1][0]);
ax.set_title('Q3 Win')
ax = sns.barplot(x="qtr", y="qt_score_diff", hue="qt4_won", data=nfl[nfl.qt_wlt==1], ax=axes[1][1]);
ax.set_title('Q4 Win')
ax.legend()

Figure 6 — Quarter Score Difference

如果球队以触地得分(6 分)或更多赢得第一节比赛，胜率。

g = sns.lmplot('Win_Prob', 'qt_score_diff', col='team_win_str', data=nfl[(nfl.ScoreDiff1 >= 7)],
               markers=".", scatter_kws=dict(color='c'))
g.map(plt.axhline, y=1, color="k", ls=":");

Figure 7 — Top Teams (Top) and Bottom Team (Bottom) winning 1st quarter Statisitcs

特征工程和选择

按季度创建与得分差异相关的潜在特征列表

在特征分析中，我们的目标是理解数据模式，开发主题假设，以及进行反复试验来确定与我们的目标最佳相关的相似特征选择操作符。

皮尔逊相关系数

为了了解第一季度的胜利是否与赢得的比赛相关，或者上半年获得的第一次总得分或第三次得分效率是否对赢得第一季度或比赛起着重要作用，我们需要衡量这些变量之间的关系。这就是皮尔森相关系数发挥作用的地方。这里有一本关于它如何工作的入门书。根据定义，相关性是多个值之间的依赖性的度量。使用皮尔逊相关系数，我们将提供一个变量列表，并测试我们的假设，即在第一和第二季度获胜与赢得比赛之间是否有直接关系。皮尔逊将提供一个介于-1和+1之间的回溯数字。这个度量的意义是这些变量为正的强度程度(接近于+1)。)，负相关(接近–1)或不相关(接近0)。请记住:相关性并不意味着因果关系。

下面，我们将利用皮尔逊相关系数和几列数据来确定 nfl 数据中的某些属性是否与确定哪个季度高度相关

potentialFeatures = ['qt_score_diff','qt_wlt','ScoreDiff4','ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff5', 'qt1_won','qt3_won', 'qt4_won', 'home_away',
'Touchdown','Turnover','Penalty_Yards','Win_Prob','team_win','third_down_conv_rate','fourth_down_conv_rate','Total_Yards','FirstDown','EPA']
nfl_corr = nfl[potentialFeatures].corr()
f,ax = plt.subplots(figsize=(14, 14))
sns.heatmap(nfl_corr, annot=True, linewidths=.5, fmt= '.1f',ax=ax)
nfl_corr

Figure 8 — Potential Feature Correlation Matrix

Figure 9 — Potential Feature Correlation Matrix — Heat Map

选择热门功能并创建一个列表，其中包含人员在“team_win”与列中每一列之间的相关性。

nfl_corr['team_win'].sort_values(ascending=False)

Figure 10 — Top Potential Features

我们确保所选特征的数量和所计算的相关性是相同的(例如，在这种情况下是 21)。接下来的几个单元格显示了一些代码行，它们使用 pandas 绘图函数来创建这些相关值和列名的 2D 图

# create a list containing Pearson's correlation between 'team_win' with each column in cols
correlations = [nfl['team_win'].corr(nfl[f]) for f in potentialFeatures]
len(potentialFeatures), len(correlations)# create a function for plotting a dataframe with string columns and numeric valuesdef plot_dataframe(df, y_label):
    color='coral'
    fig = plt.gcf()
    fig.set_size_inches(20,12)
    plt.ylabel(y_label)

    ax = df.correlation.plot(linewidth=3.3, color=color)
    ax.set_xticks(df.index)
    ax.set_xticklabels(df.attributes, rotation=75); #Notice the ; (remove it and see what happens !)
    plt.show()# create a dataframe suing cols and correlationsdf5 = pd.DataFrame({'attributes': potentialFeatures, 'correlation': correlations})# lets plot above dataframe using the function we createdplot_dataframe(df5, 'Teams overall win percentage')
df5

Figure 11 — Team Overall Winning Percentage correlated with ‘team_win’

构建机器学习模型

现在我们将训练几个机器学习模型，并比较它们的结果。创建要素数据框并删除不必要的要素。

# y includes our labels (wins and losses) and x includes our features
y = nfl.team_win_str
X = nfl[potentialFeatures].drop('team_win', axis=1)# change NAN to 0
where_are_NaNs = np.isnan(X)
X[where_are_NaNs] = 0

使用 sklearn 包及其相关的预处理实用程序来规范化数据。

from sklearn import preprocessingx = X[['qt_score_diff','ScoreDiff1','ScoreDiff2','ScoreDiff3','ScoreDiff5', 'qt3_won', 'qt4_won','EPA',
        'home_away','qt_wlt']].values #returns a numpy array
min_max_scaler = preprocessing.MinMaxScaler()
x_scaled = min_max_scaler.fit_transform(x)
X = pd.DataFrame(x_scaled)from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import f1_score,confusion_matrix
from sklearn.metrics import accuracy_score# split data train 70 % and test 30 %
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)#random forest classifier with n_estimators=10 (default)
clf_rf = RandomForestClassifier(random_state=43)      
clr_rf = clf_rf.fit(X_train,y_train)ac = accuracy_score(y_test,clf_rf.predict(X_test))
print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train,clf_rf.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test,clf_rf.predict(X_test))))
print('Accuracy is: ',ac)cm = confusion_matrix(y_test,clf_rf.predict(X_test))
sns.heatmap(cm,annot=True,fmt="d")

Figure 13 — Confusion matrix on Random Forest Classifier

准确率为 94.8%，从混淆矩阵中可以看出，我们做了一些错误的预测。现在让我们看看其他特征选择方法，以找到更好的结果。

支持向量机

from sklearn.svm import SVC
svc = SVC()
svc.fit(X_train, y_train)
print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train, svc.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test, svc.predict(X_test))))**Accuracy on training set: 0.938
Accuracy on test set: 0.938**

与随机森林相比，SVM 的精确度较低。

逻辑回归

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
logreg.fit(X_train, y_train)
Y_pred = logreg.predict(X_test)print("Accuracy on training set: {:.3f}".format(accuracy_score(y_train,logreg.predict(X_train))))
print("Accuracy on test set: {:.3f}".format(accuracy_score(y_test,logreg.predict(X_test))))**Accuracy on training set: 0.938
Accuracy on test set: 0.939**

与随机森林相比，逻辑回归的准确性较低。看来我们要随机森林了。

基于精度、召回率和特征重要性的随机森林模型评估

为了评估我们的模型，我们将利用精度和召回来更好地理解模型性能。从高层次来看，精度是正面预测的性能度量，而召回是数据集的整个正面部分的性能度量。

from sklearn.metrics import classification_report
print(classification_report(y_test,clf_rf_2.predict(x_test_2)))

Figure 14 — Precision and Recall Score for Random Forest

通过选择随机森林，我们可以计算模型使用的每个特征属性的相对重要性。这些重要性值用于理解所选特征的等级。下面我们列出了 5 大特点。

def plot_feature_importances(model):
    plt.figure(figsize=(10,5))
    n_features = len(model.feature_importances_)
    plt.barh(range(n_features), model.feature_importances_, align='center')
    plt.yticks(np.arange(n_features), feature_labels)
    plt.xlabel("Feature importance")
    plt.ylabel("Feature")
    plt.ylim(-1, n_features)plot_feature_importances(clf_rf_2)

Figure 15 — Feature Importance from Random Forest

根据我们的随机森林模型，上面显示了影响一个团队是否获胜的最重要的特征，并且看起来第一季度的得分差异在相关性和预测中起着重要作用。

最后，我们每个季度单独运行模型，并生成功能性能和功能重要性分数。

Figure 16 — Feature Performance and Importance based on discrete quarter perdictions

有趣的是，随着季度的进展，我们可以看到第一次得分的重要性降低，相反，qt_score_diff 增加，这是季度得分的点差。

摘要

这是一个有趣的分析，这篇文章并不是要得出第一季度的胜利不重要的结论，但是正如我们所看到的，在第一季度的胜利和整个赛季的胜利之间有很强的相关性。

创建这篇文章的源代码可以在这里找到。如果您有任何问题或反馈，请告诉我。