TowardsDataScience-博客中文翻译-2016-2018-十四-

TowardsDataScience 博客中文翻译 2016~2018（十四）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

对强化学习或当你不知道该做什么时该做什么的温和介绍

原文：towardsdatascience.com/a-gentle-in…

今天我们要看一组有趣的学习算法，它不需要你在学习的时候知道真相。因此，这是无监督学习和有监督学习的混合。受监督的部分来自于这样一个事实，即你在采取行动后看着后视镜，然后根据你做得有多好来调整自己。这是惊人的强大，因为它可以学习知识表示允许它学习的任何东西。不过有一点需要注意的是，它慢得令人难以忍受。这自然源于没有正确解决方案的概念。无论是在你做决定的时候，还是在你评估决定的时候。你只能说“嘿，考虑到我之前的尝试，这还不算太糟”，但你不能说这是最好的选择。这降低了学习速度。好处是，只要我们能观察到我们在所处环境中行动的后果，我们就能了解任何事情。

如上所述，强化学习可以被认为是一个代理人在一个环境中行动，并作为这些行动的结果接收奖励。原则上，这是一个马尔可夫决策过程(MDP ),它基本上捕捉了你可能想在一个环境中学习的任何东西。从形式上看，MDP 包括

• 一组状态
• 一系列动作
• 一套奖励
• 一组转移概率

这看起来惊人的简单，但实际上是我们所需要的。任务是学习最佳转移概率，使预期的未来总回报最大化。因此，为了继续，我们需要引入一点数学符号。首先，我们需要一个奖励函数 R( s ， a )，它给我们奖励 r ，这来自于在时间 t 在状态 s 采取行动 a 。我们还需要一个转换函数 S( s ， a )，它将给出下一个状态S’。动作和由代理按照一个或多个策略生成。因此，政策函数 P( s )生成一个动作 a ，据其所知，该动作将在未来给出最大回报。

我们要解决的问题——车杆

我们将利用 OpenAI 体育馆中的一个环境，叫做手推车杆子问题。这项任务基本上是学习如何通过控制手推车来平衡杆子。每次我们在环境中行动时，环境都会给我们一个新的状态。这种状态由对应于位置和运动的四个可观测量组成。这个问题之前已经由亚瑟·朱利安尼用张量流说明过。在向您展示实现之前，我们先来看看一个训练有素的代理是如何执行的。

正如你所看到的，它表现得很好，实际上通过实时控制手推车来平衡杆子。你可能会想，嘿，这听起来很容易，我只是生成随机动作，它应该会抵消。嗯，放心吧。下面你可以看到这种方法失败的例子。

所以对于眼前的问题。我们如何对此建模？我们需要制造一个智能体来学习一个能最大化未来回报的策略，对吗？对，所以在任何给定的时间，我们的政策可以选择两个可能的行动之一，即

1. 向左移动
2. 向右移动

如果你以前做过任何建模工作，这听起来应该很熟悉。这基本上是一个伯努利模型，其中概率分布看起来像这样 P(y；p)=p^y(1-p)^{1-y)。一旦我们知道了这一点，接下来的任务就是将 p 建模为当前状态 s 的函数。这可以通过做一个由 s 形包裹的线性模型来实现。更多数学细节请看看我的原帖。

履行

由于人工智能健身房大部分是用 Python 编写的，我们选择了用那种语言。这绝不是我对数据科学的首选语言，我可以给你 10 个有力的论据来说明为什么它不应该是你的，但因为这篇文章是关于机器学习而不是数据科学的，所以我不会扩展我的想法。无论如何，Python 对于机器学习来说是很棒的，这就是我们今天所看到的。所以让我们继续导入 Python3 中我们将需要的库。

import numpy as np
import math
import gym

在此之后，让我们看看初始化我们的环境，并设置一些变量和占位符，我们将需要。

env = gym.make('CartPole-v0')
# Configuration
state = env.reset()
max_episodes = 2000
batch_size = 5
learning_rate = 1
episodes = 0
reward_sum = 0
params = np.random.normal([0,0,0,0], [1,1,1,1])
render = False
# Define place holders for the problem
p, action, reward, dreward = 0, 0, 0, 0 ys, ps, actions, rewards, drewards, gradients = [],[],[],[],[],[]
states = state

除此之外，我们将使用一些需要定义的函数。我确信多种机器学习框架已经实现了它，但是它很容易做到，也很有指导性，所以为什么不去做呢。；)

您将需要的 python 函数

因为我们是在 Python3 中实现的，而 Python3 和 Python2 并不总是简单明了的，所以我与你分享我创建的函数定义，因为它们确实与 Python3 库兼容。尤其是 Numpy，它是 Python 中计算不可或缺的一部分。这些功能大部分都很容易实现和理解。确保你通读了它们并掌握了它们的全部内容。

def discount_rewards(r, gamma=1-0.99):
  df = np.zeros_like(r)
  for t in range(len(r)):
    df[t] = np.npv(gamma, r[t:len(r)])
    return df
def sigmoid(x):
  return 1.0/(1.0+np.exp(-x))
def dsigmoid(x): 
  a=sigmoid(x) return a*(1-a)
def decide(b, x):
  return sigmoid(np.vdot(b, x))
def loglikelihood(y, p):
  return y*np.log(p)+(1-y)*np.log(1-p)
def weighted_loglikelihood(y, p, dr):
  return (y*np.log(p)+(1-y)*np.log(1-p))*dr
def loss(y, p, dr):
  return -weighted_loglikelihood(y, p, dr)
def dloss(y, p, dr, x):
  return np.reshape(dr*( (1-np.array(y))*p - y*(1-np.array(p))),[len(y),1])*x

有了这些功能，我们就可以开始主要的学习循环，这是代理和培训的逻辑发生的地方。这将是最难的部分，所以要慢慢来。

学习循环

while episodes < max_episodes:
  if reward_sum > 190 or render==True: 
    env.render()
    render = True
  p = decide(params, state)
  action = 1 if p > np.random.uniform() else 0
  state, reward, done, _ = env.step(action) reward_sum += reward
  # Add to place holders
  ps.append(p)
  actions.append(action)
  ys.append(action)
  rewards.append(reward)
  # Check if the episode is over and calculate gradients
  if done:
    episodes += 1
    drewards = discount_rewards(rewards)
    drewards -= np.mean(drewards)
    drewards /= np.std(drewards)
    if len(gradients)==0:
      gradients = dloss(ys, ps, drewards, states).mean(axis=0)
    else:
      gradients = np.vstack((gradients, dloss(ys, ps, drewards, states).mean(axis=0)))
    if episodes % batch_size == 0:
      params = params - learning_rate*gradients.mean(axis=0)
      gradients = []
      print("Average reward for episode", reward_sum/batch_size)
      if reward_sum/batch_size >= 200:
        print("Problem solved!")
      reward_sum = 0
    # Reset all
    state = env.reset()
    y, p, action, reward, dreward, g = 0, 0, 0, 0, 0, 0
    ys, ps, actions, rewards, drewards = [],[],[],[],[]
    states = state
  else: 
    states=np.vstack((states, state))env.close()

唷！就在那里，还不算太糟，是吧？我们现在有一个完全工作的强化学习代理，它通过策略梯度学习来学习横竿问题。现在，对于那些了解我的人来说，你知道我总是宣扬考虑所有可能的解决方案，并且与你的数据一致。所以，也许横翻筋斗的问题有不止一种解决方法？确实有。下一节将向您展示这些解决方案在四个参数中的分布。

多重解决方案

因此，我们已经使用我们的学习代理解决了 CartPole 问题，如果您运行它多次，您将看到它收敛到不同的解决方案。我们可以在所有这些不同的解决方案上创建一个分布，这将告知我们由我们的参数化所支持的所有可能模型的解决方案空间。下面给出了曲线图，其中 x 轴是参数值，y 轴是概率密度。

你可以看到 X0 和 X1 应该在 0 左右，而 X2 和 X3 应该在 1 左右。但是如图所示，存在几种其他的解决方案。因此，学习代理自然会考虑到参数应该是什么的不确定性。

结论

我们实现了一个强化学习代理，它在一个以最大化未来回报为目的的环境中工作。我们还在代码中贴现了未来的回报，但在数学中没有包括它。尽管这很简单。能够从自己的错误中学习的概念是非常酷的，它代表了一种学习范式，这种范式既不是有人监督的，也不是无人监督的，而是两者的结合。这种方法的另一个吸引人的地方是，它非常类似于生物从与环境的互动中学习的方式。今天我们解决了翻筋斗，但是这种方法可以用来解决更有趣的问题。

我希望你在阅读这篇文章的时候觉得有趣，并且学到了一些东西。

推理快乐！

原载于doktormike . github . io。

算法公平性讨论的温和介绍

原文：towardsdatascience.com/a-gentle-in…

近年来，机器学习算法已经兴起:在打破了几乎所有可以想象的计算机视觉相关任务的基准之后，机器学习算法现在一直在我们的家里和口袋里。一个不太为人知的事实是，它们最近开始在一些更敏感的领域取代人类决策者，如刑事司法系统和医学测试领域。

当机器学习算法应用于人类时，一个直接的观察结果是，这些算法并不总是表现得“公平”。事实证明，以标准效用最大化目标(例如，最大化训练数据的预测准确性)训练机器学习算法有时会导致算法的行为方式让人类观察者认为不公平，尤其是对某个少数群体。

这种行为有许多潜在的原因。一个自然的怀疑是训练数据本身:机器学习算法本质上是大型计算机器，经过训练可以识别和利用数据中的统计模式。如果作为“基本事实”提供给它们的数据包含一些偏见或历史歧视，机器将会发现这种偏见，并将其纳入未来预测。一个很好的例子是[1]中的工作，其中作者证明了著名的单词嵌入模型 word2vec 实际上包含了隐含的性别偏见。我发现这很麻烦，因为许多应用程序现在使用经过训练的 word2vec 嵌入作为其机器学习管道中的第一个预处理阶段；这意味着这种偏见每天都在传播。

[1] gives a quantitative demonstration that word-embeddings contain gender biases in their geometry

克服这个问题的一种方法是，在假设历史偏差处于自我纠正过程的情况下，不断用“新鲜”数据重新训练机器学习模型。我不知道这是否是完美的解决办法，但有理由抱有希望。我喜欢的一个最近的例子是通过考虑 Getty Image 的库存摄影库中搜索词“女人”的最畅销图像在过去十年中的变化:2007 年最受欢迎的图像是一个躺在床上的裸体女人，而 2017 年最受欢迎的图像是一个独自在岩石小道上徒步旅行的女人。见[7]的整个演变和其他一些很酷的例子。如果你认为库存照片——出现在广告、广告牌、杂志和博客等地方的普通图片——反映了我们社会的任何事情，那么我们显然走在一条积极的道路上。

然而，一个不太令人期待的结果是，即使有完美标记的训练数据，偏见和歧视也可能以多种方式出现。[6]是一篇很棒的博文，讲述了机器学习算法即使有完全无偏的训练数据也可能不公平的各种原因。

最近一个著名的例子是谷歌照片错误地将两个黑人标记为“大猩猩”。显然，这并不是说谷歌用于这项任务的训练数据包含了被标记为“大猩猩”的黑人的例子。但是机器学习算法仍然会出错，在这种情况下，这是一个代价高昂且不公平的错误，因为它只发生在黑人身上，而不是白人。

研究分类中的公平性意味着不仅从准确性的角度，而且从公平性的角度来研究机器学习算法。听起来很简单，对吧？令人惊讶的是，大部分的困难实际上都围绕着如何定义公平的含义。在过去的几年里，许多研究人员定义了不同的算法公平概念。在许多情况下，这些定义在准确性方面有所取舍(也就是说，实现它们意味着必然要在模型的准确性方面付出代价)，但更意想不到的是，这些定义中有许多本身也有取舍。

在本帖中，我们将围绕一个具体的例子来逐步引入不同的算法公平概念:为科技行业过滤简历。具体来说，我们将认为我们的特征空间 X 是一些可以从一个人的简历中计算出来的观察到的特征(例如:姓名、出生年份、地址、性别、编程语言、大学学位和学分等)，如果这个人应该被带去面试，那么输出将是 Y=1，否则是 Y=0。出于这个例子的目的，我们的受保护属性(我们希望保证公平的属性)是性别，我们假设它是可观察的并且是二进制的。

第一站:过程的公平与结果的公平

我们介绍的第一个区别是“有意识的”和“无意识的”方法。“aware”算法将在学习过程中使用关于受保护属性的信息；“无意识”算法不会。

无意识方法背后的动机是，对于受保护的属性来说，公平本质上意味着不考虑它。在简历示例中，这意味着同等对待男性和女性的最佳方式就是不要让算法访问这些信息。

第一个观察结果是，仅仅删除受保护的属性通常是不够的。在大多数实际情况下，受保护的属性实际上被冗余地编码在其余的观察到的特征中；大多数最大似然算法都是复杂的计算机器，能够利用这一事实。例如，我们可能会删除性别特征，却发现我们的分类器非常重视一个人的军龄。为什么？在以色列，女性通常服刑两年，男性服刑三年。这意味着“服役年限”的特征几乎与性别完全相关；使用这个特性的分类器本质上不符合无意识方法。

实践中经常使用的一种快速修复方法是，也删除与受保护属性高度相关(例如，高于某个阈值)的所有其他属性。一个更严谨的方法(本身也是一个非常有趣的工作)是“学习公平表征”(Zemel et al，2013 [2])。它使用机器学习来代替手动设计不传达关于受保护属性的信息的特征列表的过程。

让我们假设我们成功了。完全无视性别的学习方式是我们真正想要的吗？受保护属性所定义的种群之间可能存在固有的差异，这实际上将使这成为不期望的。

在我们的例子中，假设高中主修物理高度预示着申请人未来在科技行业的成功，即使这并不是所需的实际物理知识。因此，这将是我们的分类器在简历中寻找的一个特征。然而，可以说，由于社会学的原因，以色列的年轻女孩比同龄的男孩更不愿意学习物理。这将意味着，通过完全无视性别信息，一种有利于具有物理学背景的申请人的算法给了男性申请人看似不公平的优势。这种现象通常被称为恢复“多数解”(这里的解是指理想候选人的原型)，它自然会伤害少数。在我们的例子中，一名女性候选人可能同样合格，但被算法“遗漏”。

另一方面,“aware”方法——确实使用了性别信息——可以克服这一点，因为它实际上发现了这样一个事实，即学习物理对于男性未来的成功来说是一个比女性更强的信号。

另一种看待意识到和没有意识到的问题的方式是区分过程的公平性和结果的公平性。无意识方法确保了过程的公平性:它强调了这样一个事实，即在学习阶段，算法不会以任何方式根据受保护的属性对个体进行不同的处理。然而，这样做的最终结果，几乎是矛盾的，实际上对受保护和不受保护的子群体不太公平。另一方面，aware 方法使用一个不公平的过程(明确使用性别信息，并为人口中不同部分的人学习不同的分类规则)，但实际上可以达到对少数群体更公平的结果。

第二站:统计平价

为算法公平提出定义的一个自然方法是看看在计算机科学社区之外公平是如何被定义的，并把这些想法公式化为数学定义，我们的算法将遵循这些标准。

美国法律 理论使用了“不同影响”原则:如果一种行为对受保护群体的成员产生了“不成比例的不利”影响，那么这种行为就被认为是非法歧视。“不成比例的不利”通常使用 80%规则来定义。

用于二进制分类任务的不同影响原理的最极端版本(不允许对保护组的成员产生不利影响)的数学等价是统计奇偶校验条件:它本质上均衡了保护组和非保护组的结果。

Statistical Parity: equalize outcomes across the protected and non-protected groups

对统计均等概念及其变体的主要批评(例如允许两个群体之间的某种均等，例如高达 20%)是非常自然的:我们真的想让受保护群体和不受保护群体之间的结果均等吗？

在我们的简历示例中，这将迫使我们接受相同数量的女性和男性。鉴于一名计算机工程师因暗示女性不太适合科技和领导领域的某些角色而被谷歌解雇，最近关于这个问题有了非常公开的辩论。在不深入我对这一具体主张的想法的情况下，很明显，在许多其他任务中，实施统计均等没有什么意义。例如，考虑任何分类任务，其中受保护的属性和输出变量之间存在明确的因果关系，例如:预测某个人在未来十年内是否会生育。自然，在这里实施统计上的平等是可笑的。

步骤 3:扩展到跨组校准的其他概念

我们仍然希望在受保护群体和不受保护群体之间实现某种程度的平等。我们可以均衡算法性能的一些统计数据，而不是均衡结果本身:例如，均衡各组之间的错误率。在这种观点看来，筛选简历的公平算法是让男性求职者和女性求职者犯同样多的错误。

一个有用的分析工具是混淆矩阵:

一个混淆矩阵，也被称为误差矩阵，是一个特定的表格布局，允许可视化监督学习算法的性能

Confusion Table: A cross-tabulation of the actual outcome by the predicted outcome

这就是公平文献可能有点可怕的地方，因为许多定义之间有非常微妙的差异，很容易忘记它们的共同点。[5]做了大量工作，给出了详细的例子，说明如何通过比较受保护和不受保护的矩阵来定义公平性。一些例子:

• 处理平等通过一个分类器实现，该分类器产生两个保护组类别相同的假阴性和假阳性比率(在表中，c/b 或 b/c)。
• 当以已知结果为条件时，实现了条件程序准确性相等，分类器在保护组类别中同样准确。这相当于男女的假阴性率和假阳性率是一样的。

关于混淆矩阵的不可否认的数学事实是，细胞计数之间存在关系——例如，它们必须与观察的总数相加。这意味着不同种类的公平性——所有共享混淆矩阵中的细胞计数——也是相关的。事实上，已经表明有许多权衡。

顾名思义，权衡意味着没有单一的赢家:这是一个零和游戏。治疗平等性的一个小改进和条件使用准确性平等性的一个小改进哪个更好？[5]声称，虽然科学家有责任提出关于权衡的讨论，并可能设计算法，其中权衡被明确表示，并可作为易于调整的转向参数，但最终还是要由利益相关者来确定权衡。

参考

1. 男人对于电脑程序员就像女人对于家庭主妇一样？去偏置单词嵌入
2. 学习公平陈述

3.谷歌员工因多元化争议被解雇考虑采取法律行动

4.通过意识实现公平

5.刑事司法风险评估中的公平性:最新水平

6.大数据有多不公平

7.从性对象到坚韧不拔的女人:库存照片中女人的演变

从线性回归到神经网络的温和旅程

原文：towardsdatascience.com/a-gentle-jo…

一些机器学习和深度学习概念的软介绍。

Credit: Pexels on Pixabay

介绍

深度学习是一个非常时髦的术语。主要原因是，相关技术最近显示出令人难以置信的能力，即使不是最先进的，也能在各种问题上产生非常好的结果，从图像识别到文本翻译。面对这种不断发展的技术，由于数据和计算机能力的增加而成为可能，对于没有入门的人来说，有时很难真正知道“幕后发生了什么”。什么是深度学习？神经网络是如何工作的？

我们希望通过这篇文章，帮助消除与主题相关的大部分困惑或疑问，并为正确的(即使是非常基本的)理解和一些有洞察力的直觉创造空间。

为此，我们将尝试给出一些简单的答案来理解什么是深度学习，尤其是神经网络是如何工作的。我们将利用例子、说明、类比和任何能使理解尽可能容易的东西。我们在这里的目标更多的是让主要的指导方针尽可能的清晰，而不是用一些技术细节来阻碍读者的理解(尽管这可能非常有趣)。特别是，我们将从简单的问题到更困难的问题，以展示神经网络如何自然地(至少在精神上)扩展一些众所周知的技术。显然，在我们的过程中，我们将不得不进行一些简化或省略一些细节。如果在某些方面，它会让更高级的读者感到沮丧，我们提前道歉。

由于本文的目的主要是给读者一个简单的概述和一些直觉，以符合机器学习、深度学习和神经网络的主要思想，因此后面的大部分内容不需要高级的数学背景。

概述

在第一部分，我们给出了机器学习的定义，并用线性回归这个非常基本的例子说明了机器学习技术是如何从数据中提取知识的。

然后，在第二部分中，我们表明问题通常比真正简单的线性回归更难，并且需要一些更高级的机器学习技术。我们介绍了这样一个事实，即具有更好预测能力的更先进的模型，通常是以模型的优化或可解释性的更高难度为代价的，然后简要讨论了这两个问题。

最后，在最后一节中，我们看到对于一些真正复杂的问题，我们可以选择放弃(部分或全部)可解释性来设计具有更好预测能力的模型。我们介绍深度学习，尤其是神经网络。我们展示了在何种意义上神经网络可以被视为我们的初始线性回归例子的自然延伸，并讨论了反向传播算法。

基础机器学习

什么是机器学习？

计算机游戏和人工智能领域的先驱亚瑟·塞缪尔(Arthur Samuel)将机器学习(ML)定义为在没有明确编程的情况下赋予计算机学习能力的研究领域。换句话说，无论我们算法的目的是什么，实现这一目标的规则都不是显式编程的，而是由计算机根据一些有用的数据“学习”(稍后我们将回到这个词)。这是与经典算法的最大区别。

在经典算法中，规则被明确地给予计算机来执行任务。在机器学习算法中，定义一系列可能规则的模型(参数化或未参数化)与一大堆数据和基于这些数据在可能规则中寻找更好规则的策略一起提供给计算机(优化)。在下一段中，我们将在现有的最基本的机器学习模型之一中明确所有这些元素:线性回归。

简单线性回归

线性回归是我们能想到的最简单的机器学习算法的例子之一。让我们看看它完全符合我们上面给出的描述。假设你有一堆关于房子两个属性的数据:面积(用 s 表示)和价格(用 p 表示)。现在，假设您想要一个程序，它以房子的大小作为参数，并返回一个价格，即该房子的估计价格。第一种选择是对规则进行显式编程。在这种情况下，这意味着我们必须明确定义函数 f 使得 p = f(s)。 换句话说，我们必须明确给出价格，作为尺寸的明确函数。然而我们可能不知道这个函数是什么，或者我们可能只有一个模糊的概念。如果是这样的话，我们可以依靠数据以 ML 的方式建立我们的规则。然后，我们首先定义一组(一族)规则:在这个例子中，我们假设一个线性规则表达了价格和大小之间的联系。因此，我们现在已经知道 f 具有形式 f(s)=as+b ，具有 a 和 b 未指定的参数(自由度)，这些参数需要基于可用数据并遵循给定策略来定义。传统上，对于线性回归，这种策略非常简单，包括选择和 b 以最小化真实输出和预测输出之间的误差平方和。这可以在线性回归的情况下分析完成(我们可以找到一个封闭形式的解决方案)。但是我们会看到事情并不总是那么容易。然而，我们可以注意到，在这个例子中，我们有三个提到的部分:一个(参数化的)模型，一些数据和一个优化策略(一种找到最佳参数的方法)。我们将在本文讨论的更高级的方法中再次遇到这个三联体(模型/数据/优化)。

非参数化模型

前面的线性回归的例子是参数化模型的例子，其中和 b 是参数。在本文中，我们将主要讨论这类模型，因为我们想展示向(高度)参数化的神经网络的过渡。然而，人们应该记住，也存在非参数化模型。然而，三联画保持不变。该模型仍然定义了一组可能的函数，并且在该组函数中的选择是基于遵循给定优化策略(大多数情况下是误差最小化)的可用数据进行的。**

高级机器学习

问题往往会变得更难

当然，问题不能总是用线性回归这样简单的方法来解决，在大多数情况下，我们将不得不建立更复杂的模型。有些问题甚至不符合线性回归所建议的具体框架(即:取一些真实的输入，返回一个真实的输出)。然而，无论我们选择哪种方法，我们总能恢复我们潜在的三联模型/数据/优化。

例如，假设您有一些关于客户使用您的某项服务的数据，并且您想要一个工具来根据这些数据预测客户是否会流失。在本例中，要预测的输出不是一个实数值，而是一个二进制值(两类问题)，因此，我们面对的是分类问题，而不是回归问题。然后，输出预测应该是 0 和 1 之间的变动概率，并且具有无界输出的线性回归应该例如通过在线性输出之上应用专用非线性函数而转变成逻辑回归。

另一个例子是考虑一个客户细分问题。假设您有一些关于客户的数据，并且希望展示这些数据中的聚类，以便获得客户细分。这里的问题不再是一个监督的问题。事实上，我们不想学习一些输入和给定输出(监督)之间的映射，而是在未标记的数据(非监督)中寻找一些结构。

即使我们不打算给出每一种机器学习算法的细节，我们也可以给出以下大图:更高级的模型旨在表达数据中更复杂的结构，但这可能是以优化或解释模型的一些困难为代价的。让我们以后讨论这两点。

最佳化

一旦定义了模型，就必须对其进行优化，使其“刚好足以”拟合数据，以捕捉数据中的相关总体结构，同时忽略不相关的特定“噪声”(我们将在后面讨论“过度拟合”的概念)。事实上，正如前面提到的，一个模型定义了一个空间(这个模型的可能“实例”)，我们需要在这个空间中找到关于一个选择的度量的最佳点(一种评估空间中每个点的质量的方法)。该指标通常由误差项定义，惩罚与数据不匹配的模型实例，有时还加入正则化项，惩罚过于复杂和过于接近数据的模型实例。然后，我们可以把我们得到的最优化问题主要分为三类。

首先，对于非常简单的方法，我们可以面对一个二次型优化问题。这里我们指的是有可能找到我们问题的封闭形式解的情况(我们知道如何用数学方法表达问题的解)。线性回归显然就是这样一种方法。事实上，我们可以获得一个封闭形式的解决方案是非常有吸引力的，但也反映了简单，因此无法捕捉数据中的复杂结构，由模型定义的空间。

Quadratic minimisation with linear derivative. Finding the minimum is straightforward in an analytical way : we just need to find the 0 of a linear function.

那么，优化问题可以是非二次的，而是凸的。非二次优化问题通常不能用解析方法解决，大多数时候需要迭代方法。这些迭代方法背后的主要思想是从空间的给定点开始——由我们的模型描述的空间，其中一个点是模型的一个实例，例如具有特定参数——并通过在每次迭代中选择在我们的空间中的最佳可能方向上迈出一小步(取决于我们如何定义“最佳”的概念)来尝试改进这个解决方案迭代。这些迭代方法可以采取不同的形式，如各种梯度下降变量、EM 算法等，但最终的基本思想是相同的:我们无法找到直接的解决方案，所以我们从给定点开始，一步一步地前进，在每次迭代中朝着改进当前解决方案的方向迈出一小步。关于梯度下降的图示，请参见下图。对于这种迭代方法，空间的凸性是一个非常重要的性质，它确保无论选择什么样的起点，我们都将达到全局最优(我们将获得的模型实例将是关于定义的优化问题的最佳可能实例)。

Convex minimisation. Finding the minimum is not straightforward and require iterative approach (as the derivative is no longer linear). Here, we used gradient descent. However, convexity ensure that iterative approach will reach the global minimum.

最后，由模型定义的空间可以是非凸的，然后我们面临一个非凸优化问题。在这种情况下，非线性将再次影响迭代方法的使用。然而，非凸性使得我们不再确定迭代过程将在整个空间上达到最佳可能点。换句话说，我们获得的最优(模型的实例)高度依赖于我们选择的起点。这显然是我们所能面对的最优化问题的最坏情况，也是一些更先进的模型在表达数据内部复杂结构方面的高能力的一个明显缺陷。

Non-convex minimisation. Finding the minimum require iterative approach (here, gradient descent) but the non-convexity make it possible to reach local minima instead of the global minimum depending on the starting point.

小心过度拟合

一般来说，在机器学习中，当处理优化过程时，我们需要非常小心过度拟合。当模型不仅学习了我们想要的有趣的一般特征，而且还学习了一些特定的不想要的噪声时，我们说模型过度拟合了数据。换句话说，过度拟合是指优化过程导致模型实例过于接近训练数据，因此不能很好地推广到新的未知数据。下图很好地说明了过度拟合现象。

From left to right : underfitting, fitting and overfitting. Over the same set of data we fit polynomial functions of various degrees. We can see that 1 degree polynomial function has not enough freedom while 20 degrees polynomial function has too much.

模型的参数数量和可用于训练的数据数量之间的比率对过度拟合风险有影响。如果与参数的数量相比没有足够的数据，在某种意义上，就有学习不希望的噪声的空间。但是，如果数据的数量足够大，它将具有正则化效果，并将迫使参数仅学习一般特征(见下图)。当拟合神经网络时，参数的数量可能非常多，因此存在过度拟合的风险。

From left to right : fitting of a 5 degrees polynomial function with 10, 30 and 100 points. We can see that more points have a regularisation effect : with 100 points, the fitted curve looks like a 2 degrees polynomial function.

我们应该注意到，正则化参数/约束参数以关注一般特征的另一种方式是引入显式正则化器。我们不会在本文中给出任何细节，但这是机器学习中一个非常重要的概念:误差函数(我们希望优化)通常包含正则化器，以加强对主要期望特征的关注，并减少噪声的潜在影响。

模型可解释性

模型的可解释性是一个不容忽视的大问题，有时是决定选择一个模型而不是另一个模型的决定性因素。

我们所说的模型的“可解释性”是指一旦模型被优化，理解为什么一些输入给出一些输出的能力。让我们以上一节的线性回归为例( p=f(s)=as+b ，以 s 一套房子的大小和 p 其价格)。一旦我们优化了参数 a 和 b ，基于这些数据，我们可以完全解释我们所获得的结果。事实上，我们可以说，为了猜测新房子的价格，我们有一个基础价格 b 货币单位，我们为房子的每个尺寸单位加上 a 货币单位。同样，线性回归的完全可解释性来自于它的过于简单以及建模方面的一些限制。相反，一些模型非常强大，但可解释性差得多(如果有的话)。然而，在模型的性能和它的可解释性之间没有必然的直接联系。例如，已知支持向量机在许多问题上表现良好，并且它们的可解释性也很好。

可解释性的重要性

请注意，随着机器学习在我们的日常生活中占据越来越重要的位置，可解释性问题变得越来越重要，并且在未来会越来越重要。机器学习模型将帮助人类完成一些(可能是重要的)任务(在健康、金融、驾驶等方面)，我们有时希望能够理解模型返回的结果是如何获得的。例如，一个智能键盘在输入信息时会提示下一个最有可能的单词，这个键盘不一定要让人理解:我们只是希望它有效率。然而，预测患者是否存在疾病的模型最好在准确的基础上是可解释的:在这种情况下，我们不仅对结果感兴趣，而且希望理解其背后的“逻辑”，以便让人类确认或不确认诊断。

因此，可解释性是一个非常吸引人的模型特征。然而，有时有必要通过建立一些非常复杂的模型来牺牲一些(如果不是全部)可解释性以获得更大的预测能力:这正是下一节中讨论的神经网络的情况。

深度学习

我们在说什么？

在谷歌上快速搜索会给我们提供以下“深度学习”的定义:“深度学习方法的集合是更广泛的机器学习方法家族的一部分，旨在用高度抽象的数据建模”。在这里，我们应该理解深度学习在于建立非常复杂的模型，用可解释性的容易程度换取预测能力。

神经网络属于深度学习方法。从大的方面来看，它们是高度参数化的复杂函数，我们试图优化(我们寻找最佳参数)以适应我们的数据。如果我们想在极端情况下进行模式化，我们可以说神经网络是线性回归的非常复杂的“进化”,旨在能够对数据中的复杂结构进行建模。

例如，让我们考虑一个回归或分类问题。在这两种情况下，我们都有一些输入，用 (i1，i2，…，in) 表示，我们希望找到这些输入的一个函数，它很好地解释了观察到的相应输出，用 (o1，o2，…，om) 表示。换句话说，就像在我们的线性回归示例中一样，我们正在寻找一个函数 f ，使得 (o1，o2，…，om) 很好地近似为 f(i1，i2，…，in) 。神经网络建模背后的想法是忘记建立主要由人类“塑造”并由机器调整(通过这几个参数，如在我们的线性回归示例中)的轻度参数化函数的想法，而是建立非常灵活的高度参数化函数，该函数对人类来说没有太多先验意义，但将在学习阶段方便地塑造。让我们试着用一个简单的神经网络来说明这一点。

基本前向神经网络

在这一小节中，我们将看看基本的前向神经网络。这将使我们有机会介绍一些关于神经网络的基本术语，并清楚地看到它们如何被视为线性回归的自然延伸。

然后，让我们再次考虑我们的房屋定价示例，但是这一次有 2 个输入可用(让我们将这些输入表示为 i1 和 i2 )，并且没有关于这些输入和我们想要预测的价格之间的关系的特殊知识(表示为 o1 )，除了这种关系是先验的、相当复杂的和非线性的。

所以我们要学习函数 f 使得 f(i1，i2) 是 o1 的一个很好的估计量。然后，我们可以建议以下第一种模式:

其中 w11 和 w12 只是权重/系数(暂时不关心指数)。在继续之前，我们应该注意到，在这里，模型中没有常数项。但是，我们可以通过设置 f1(i1，i2) = w11 * i1 + w12 * i2 + c 来引入此术语。为了简化一些符号，我们不会在下面写这样的常数项，但读者应该记住，它们总是可以添加的(而且大多数情况下都是这样)。 这种模型是多输入的线性回归模型(也称为多线性回归),可表示如下。

“Network” graphical representation of the multilinear regression (model f1)

在这种情况下，模型很容易理解和拟合，但有一个很大的缺点:没有非线性！这显然不尊重我们的非线性假设。为了引入非线性，让我们对前面的模型做一点修改，提出下面的模型。

其中 a(。) 是一个被称为“激活函数”的非线性函数。然后，我们可以注意到w11 * i1+w12 * I2仍然是线性的，但是当我们让这个值通过一个非线性函数时，整体结果不再是线性的，因此，这个模型比之前的模型更接近我们的假设。这个模型可以表示如下。

“Network” graphical representation of the f2 model. If the activation function a is the logistic function, it defines the well known logistic regression model.

请注意，如果我们选择所谓的“逻辑函数”作为激活函数，我们以这种方式定义了一个称为“逻辑回归”的模型，该模型可以适合例如一些二元分类问题(实际上，逻辑函数输出 0 和 1 之间的数字，该数字可以被视为属于两个类别之一的概率)。

然而，即使比多线性模型更好，这种模型仍然过于简单，不能处理输入和输出之间关系的假设的潜在复杂性。我们可以更进一步，通过以下方式丰富模型。首先，我们可以认为数量 a( w11 * i1 + w12 * i2 ) 不再是最终输出，而是我们函数的一个新的中间特征，称为 l1 。第二，我们可以考虑以相同的方式构建几个(在我们的例子中是 3 个)这样的特征，但是可能具有不同的权重和不同的激活函数:L1 = a11(w11 * i1+w12 * I2)、*L2 = a12(w21 * i1+w22 * I2)和L3 = a13(w31 * i1+W32 * I2)*，其中最后，我们可以考虑我们的最终输出是基于这些中间特征用相同的“模板”构建的:a2(v1 * L1+v2 * L2+v3 * L3)。如果我们把所有的部分加起来，我们就会得到:

这里我们应该主要记住的是，是非线性激活函数，而 w 和 v 是权重。在下一张图中，我们以与之前相同的方式给出了该模型的网络图形表示。

“Network” graphical representation of the f3 model. Here we have a neural network with 2 entries, 1 hidden layer with 3 hidden nodes/neurones and 1 output.

最后一个模型是一个基本的前馈神经网络，具有 2 个条目( i1 和 i2 )，1 个具有 3 个隐藏神经元的隐藏层(其输出为 l1 、 l2 和 l3 )，以及 1 个最终输出。我们可以决定在 l 和最终输出之间添加另一个中间“隐藏”层，就像我们在输入和输出之间添加这些 l 一样:这样我们就有了一个具有两个隐藏层的神经网络。或者，我们可以选择保持 1 个隐藏层，但有更多的神经元(例如，5 个而不是 3 个)。因此，我们有不同的方法来丰富/复杂化模型，这将使权重的数量增加。隐藏层的数量、每层神经元的数量(如权重值)和激活函数的性质定义了神经网络，因此也定义了该网络所描述的函数的“模板”。

最后，让我们注意几件重要的事情。首先，在对这些网络进行数学描述的过程中，我们可以(而且我们总是这样做！)用矩阵符号写出前面所有的方程:对于大的架构来说，这使得所有这些更容易阅读。然而，在这里，我们的例子足够小，可以不使用矩阵符号，因此，我们可以避免使用它们，因为读者可能不习惯这些符号。第二，所有的神经网络都不符合上面描述的模板:有不同种类的架构(我们将在下一段中对此说几句)，但前馈神经网络确实是首先要了解的基本架构。第三，一旦定义，模型仍然需要拟合(权重应该根据数据进行调整，以最小化一些误差函数，就像线性回归的情况一样)，这是一个真正难以完成的优化任务。

不同的需求，不同的架构

正如我们在上一段中看到的，神经网络是高度可调的函数模板，通过其参数，需要优化以适应数据。但是根据问题的性质和建模的数据，我们可能需要使用不同种类的模板。这些不同种类的模板被称为不同的“架构”。例如，上面讨论的基本前向神经网络(也称为多层感知器)是第一种基本架构。然而，还有其他几个。在众所周知的架构中，我们可以提到递归神经网络(RNN)——其代表一些序列数据的递归函数，其中在时间 t 的输出取决于在该时间 t 的输入以及在时间 t-1 的先前输出——以及卷积神经网络(CNN)——其代表对输入的数学卷积运算，并且例如在诸如图像识别的一些基于图像的问题中显示出良好的特性。 在所有正在进行的研究工作中，总是会根据要建模的问题设想出更多的架构。显然，我们无法描述所有这些类型的架构(这完全超出了本文的范围)，但这里要记住的最重要的事情是，神经网络的架构应该始终被视为一个可能函数的空间，其中优化网络的参数等同于在这个空间中找到最佳函数(基于优化标准)。因此，选择正确的架构当然很重要，因为如果选择不当，我们将定义一个空间，在这个空间中，即使最好的功能也可能与我们的预期相差甚远。

为什么这是个好主意？

在使神经网络如此有效和受欢迎的原因中，我们可以提到以下三个。首先，许多领域中可用的数据量不断增加，这使得使用这种高度参数化的模型变得合理。请注意，模型的参数也称为“自由度”(该术语不专用于机器学习领域，表示模型中“可调值”或“动作杠杆”的概念)，并且模型中的许多自由度需要大量数据来调整/校准该模型。本着同样的精神，你不能在一个线性方程组中有比方程更多的未知数，你需要在你的网络中有比参数更多的数据(事实上，更多更好)。第二，计算能力总是更强，再加上智能优化技术，使得在具有如此多参数的超大规模模型上进行训练成为可能。在大型模型中，可能有数百万个参数需要优化，而在合理的时间内实现优化过程只需要最低的计算能力。最后，正如我们刚才所说的，优化过程是一项艰巨的任务，毫无疑问，简单而聪明的优化技术，如非常适合基于计算机的优化框架的众所周知的“反向传播”，是神经网络取得成功的主要原因之一。

神经网络很难优化

那么，什么是反向传播呢？在回答这个问题之前，让我们简单讨论一下在处理神经网络时我们需要面对的优化问题。我们在选择的“架构”所描述的函数空间中寻找最佳函数(最小化一些预定义误差度量的参数)。由于构成这种“架构”的非线性激活函数以及由模型定义的参数化函数的整体复杂性，我们面临的最小化问题是非线性和非凸的。

优化问题的非线性需要使用一些如前所述的迭代方法。因此，想法如下:随机设置网络的初始权重(给定一些精心选择的分布)，然后对所有这些参数应用梯度下降方法，以迭代地改善(减少)误差度量。换句话说，这意味着:使用您的数据在网络中向前传递，观察结果，将模型输出结果与实际预期结果进行比较，然后稍微改变网络中的权重，使结果稍微接近真实值(通过梯度下降方法)，并重复此过程，只要我们可以对权重进行“小移动”以改善结果。

让我们举个例子来说明一下。考虑前面介绍的简单前向神经网络(具有 2 个输入、1 个具有 3 个隐藏神经元的隐藏层和 1 个输出)。假设该神经网络的权重在给定时间处于某种状态(见下图)。然后，我们可以为数据集中的每个输入计算当前权重的预测输出。

At the beginning of a step, the neural network has its weights set at some values. We can then compute a forward path for all inputs (i1, i2).

现在，为了进行梯度下降的一步，我们应该独立地问我们自己网络中的每个权重:什么样的行为会降低增加和减少这个权重之间的误差。

让我们强调“独立”的概念:这意味着，对于每一个权重，我们必须定义，假设所有其他权重固定，我们是否需要降低或增加这个权重以减少误差。

这样做，我们在某种意义上给每个权重*赋予了一点“+w”(增加)或“-【𝜶_】w(减少)，其中𝜶_ w 为正，与该权重增加(或减少)多少有关(见下图)前面的量显然是关于每个权重的导数，直到一个符号(导数将指示如何增加误差)。*

Once the forward computations achieved, the error related to each input can be computed. The total error is the sum of the individual errors for each input data. For each weight, we can assign (between parenthesis on the graphic) the opposite sign of the derivative of the total error with respect to this weight. Roughly speaking, for each weight, these values answer the question : if we suppose all the other weights fixed, should we increase or decrease this weight to lower the total error ?

一旦对每个权重都完成了，我们就可以应用梯度下降步骤，并且更新所有标有“+𝜶_w的权重，使得ww↓w+𝜶_w 步长 ，而更新所有标有“ -𝜶_ w 的权重，使得注意 step_size 定义了在每次迭代中改变多少权重，并且可以随着训练时间的推移而演变。一旦达到这一步，我们可以重新开始一个新的迭代，直到权重不能再提高了。***

Finally, we can apply the gradient descent step. We considered in this example a step size of 0.1. The weights are then updated (two examples are detailed in the graphic) and we can then start again, until weights can not be improved anymore.

即使我们不会给出关于它的任何更多细节，我们应该提到，对于大多数迭代优化过程，没有什么可以确保我们以比初始状态更好的网络状态(就误差而言)结束迭代(特别是因为步长可能太大，或者因为我们在假设所有其他权重固定的情况下计算每个权重的更新值，但是我们同时更新所有权重)。

作为“逐层”梯度下降的反向传播

我们刚刚描述了神经网络上的梯度下降过程。然而，为了能够进行这些权重的“微小移动”，我们仍然需要计算误差项相对于网络中每个权重的导数(我们需要知道每个权重是应该增加还是减少一点)。它需要计算由网络表示的函数相对于每个权重的导数。这是一个真正的大任务，除非我们利用网络的分层结构来帮助我们。事实上，正如我们前面提到的，网络通常是分层构建的，这意味着我们面对的是(高度)复合的功能。反向传播算法在于使用这种特定的分层结构来有效地计算导数。为此，我们依赖于这样一个事实，即对于给定层的权重的导数可以表示为两个事物的函数:第一，对于下一层的权重的导数，以及第二，在向前传递期间取神经元的值。网络中导数的这种特殊表达直接来自于合成函数的数学导数()f(g(x))' = f '(g(x)) g '(x)*)。然后，如下进行有效的导数计算。我们从计算正向传递开始(我们提供输入，并运行计算直到输出)。然后，我们以相反的方向返回，首先计算误差相对于最后一层的权重的导数。基于这些计算，我们可以计算相对于前一层的导数，以此类推，回到第一层。换句话说，我们在网络中“反向传播”导数计算。这种算法技术使得优化过程更加容易处理。

局部最小值和过拟合风险

最后，假设通过神经网络的优化过程获得的解的质量在很大程度上受到潜在优化问题的非凸性以及由于模型中大量参数而导致的过拟合风险的影响。

由于优化问题的高度复杂性，迭代方法几乎不可能达到全局最优。所面临的优化问题的非凸性带来了在迭代过程中陷入局部最小值的巨大风险。由于这个原因(也是为了解决计算约束)，也可以使用随机梯度下降(SGD)。SGD 在于不使用整个训练数据集来进行权重更新(通过梯度下降),而是连续使用不同批次的该数据，以便使优化过程有一点噪声，并且由于这种噪声，有机会克服局部最优。这里我们不再进一步讨论随机梯度下降的概念。

此外，在拟合/训练神经网络时，我们必须特别小心过度拟合的风险。为了避免过度拟合，我们可以减少网络参数的数量，获得更多的数据或使用显式正则化器(在损失函数中或通过本文中不讨论的退出过程)。

外卖食品

在这篇谦虚的文章中，我们试图给读者一些关于神经网络是什么的直觉。为此，我们从机器学习的概念及其简单模型转向更具体的深度学习概念，即神经网络。一路上，我们遇到了与机器学习相关的各种概念，如迭代优化、过度拟合风险等。正如我们在导言中提到的，这里的目的根本不是深入探讨问题的每一个部分，而是给出“为什么”、“什么”和“如何”的总体情况。

主要要点如下:

• 机器学习是在没有明确编程的情况下赋予计算机学习能力的研究领域。
• 机器学习依赖于三联模型/数据/优化。
• 在建立更复杂的模型时，主要有两点需要注意:如何优化和如何解释？
• 粗略地说，当使用深度学习和神经网络时，我们通过建立非常复杂的模型来放弃可解释性，以获得更大的预测能力。
• 神经网络所取得的成功主要来自于不断增长的可用数据量和计算能力，以及非常有效的反向传播思想，这种思想使得优化过程更加容易处理。

总之，让我们说神经网络是非常强大的工具。他们已经证明了他们在许多现代问题上表现出色的能力。然而，它们不是能够解决任何问题的神奇工具。这项工作真正聪明的部分仍然在人类手中，他们知道在哪里以及如何以正确的方式使用这些模型。如果因为许多人在该领域引入的解决越来越复杂问题的所有聪明想法而将神经网络简化为“曲线拟合”是令人不快的，那么将它们描述为“神奇工具”也是不准确的，因为这些模型目前覆盖的问题范围明显有限。作为一个正确的平衡，让我们享受伟大的(巨大的！)这些工具在许多领域带来了进步，同时牢记它们目前的局限性……并且不会被可怕的机器人杀手所吓倒。暂时如此。

感谢阅读！

感谢 Baptiste Rocca 和 Benjamin Blanc 阅读草案并提出有益的修改和改进。

欢迎对本文的任何反馈！

与巴蒂斯特·罗卡一起写的其他文章:

** [## 机器学习中不平衡数据集的处理

面对不平衡的班级问题，应该做什么，不应该做什么？

towardsdatascience.com](/handling-imbalanced-datasets-in-machine-learning-7a0e84220f28) [## 理解生成敌对网络(GANs)

一步一步地建立导致 GANs 的推理。

towardsdatascience.com](/understanding-generative-adversarial-networks-gans-cd6e4651a29)**

神经网络里有鬼？

原文：towardsdatascience.com/a-ghost-in-…

An image emerges from images: artwerker.tripod.com/digital-mos…

吉尔伯特·赖尔(Gilbert Ryle)创造了一个著名的比喻，即“机器中的幽灵”，以反驳人类大脑或其相关智能有任何“怪异”之处的观点。他认为笛卡尔的身心二元论是一个简单的分类错误——忽略了精神和心理活动是如何基于大脑的物理工作的——因此，精神的属性可以通过研究大脑来研究。自从赖尔写作以来，神经网络已经成为机器学习的支柱，并在从图像识别到视频游戏的复杂任务中展现出巨大的能力。但是，对于所有的进步，问题仍然是神经网络是否是人脑工作的足够准确的复制，正如人们经常暗示或声称的那样，具有“机器中的幽灵”的外观。由于缺乏简单性，未能理解人类智能的真正复杂程度，整个人工智能领域在过去遭受了巨大的停滞。最近关于人工智能进步的说法有根据吗？或者我们会期待人工智能发展的又一次停滞吗？在这里，我向人工智能领域的行业领导者(Google) DeepMind 寻求帮助，并询问开创性的 AlphaGo 机器背后的算法是否能够提供一条通向普通或类人智能的道路。

哲学家吉尔伯特·赖尔强烈反对笛卡尔的身心二元论。根据 20 世纪早期的科学唯物主义，赖尔认为，假设大脑“不能被分解，它所遵循的规律不是普通工程师所知道的规律”是荒谬的(1949 年，第 21 页)。他指责笛卡尔的二元论是一个简单的“类别错误”，在概念上框定“心灵”的属性是混乱的，好像它们独立于“身体/大脑”的属性。听起来很合理，对吧？

虽然赖尔在他的论点中非常小心，但博学的亚瑟·库斯勒警告说，从笛卡尔的二元论到任何形式的一元论的匆忙。危险在于，头脑可能被认为仅仅是“大脑工作”的隐喻。这种“除此之外什么都没有”的观点否认了鬼魂是需要解释的东西这一隐喻。科斯勒诙谐地说:“当知识精英、思想家和领袖们认为人类只不过是一只发育过度的老鼠时，那么就该感到震惊了”(1967，第 353 页)。

作为两种观点的适度平衡，许多科学家都倾向于“突现唯物主义”。显然，思维根植于大脑的机制中，但是正如哲学家大卫·查默斯所说，想象一个没有思维的大脑是可能的。事实上，是否将思维归因于动物和其他生物一直是实验心理学和动物行为学的一个主要问题，这个问题仍然有些神秘。尽管如此，赖尔的洞察力是广为接受的，头脑被广泛认为是从一些大脑过程的特殊活动中产生的。明确地说，头脑实质上是大脑不可约化的，但却依赖于某种大脑过程。

突现唯物主义的危险在于，许多科学家认为这一解决方案合乎逻辑且令人满意，但它实际上并没有解释任何事情。正如心理学家理查德·格雷戈里(Richard Gregory)所指出的，任何基于某种涌现的理论都必须被视为不完整的:“好理论的作用是消除涌现的表象”(1981，第 87 页)。格雷戈里认为，只有当解释性叙述被混淆时，涌现才会出现。特别是，突现唯物主义混淆了功能性和机械性的解释:“对于理解功能来说，机器是如何组装的，或者如何方便地将其拆开，都是无关紧要的。机器零件和功能单元之间的混淆会产生神秘的幽灵般的出现(1981 年，第 87 页)。

格雷戈里承认精神和大脑/身体之间的功能差异，但要求一种涌现机制。他甚至提出了一条前进的道路:“我认为我们可以通过这样的说法来消除机器和化学中幽灵般的出现:当部分被组合成更复杂的……结构时，这些结构彼此之间以及与它们的局部环境有不同的界面，因此当组合时，它们显示出与孤立部分不同的属性，以及与以不同方式组合的部分不同的属性(1981，第 87 页)。在澄清中，格雷戈里并没有把他的协同作用原理作为一种解释本身提出来，而是作为一种方法来帮助在特定系统中发展真正的解释。

目前，对于从大脑/身体中产生精神背后的机制还没有被广泛接受的理论，但是，总的来说，格雷戈里对涌现的批判被用作一个描述性的术语(而不是解释性的术语)仍然非常正确。许多跨科学的系统以数学方式描述，依赖于突现:整体传导性，人群运动，经济市场等等。所有这些系统都有一个经常被忽视的共同点:这些“部分”按照自身利益行事，但却带来一种集体行为，就好像这个群体也有自身利益一样。在经济学中，这种现象被描述为由一只“看不见的手”引导。(看这里伟大的解释和背景；而这里换个角度怀疑经济学中看不见的手的存在——即集体现象的不出现。有趣的是，你可以怀疑集体现象的存在，这加强了看不见的手的解释的无形性的想法。)再说一遍，给它起个名字并不意味着问题解决了，因为通常情况下，引导个体走向集体财产的机制仍然难以捉摸，但也许在未来格雷戈里的挑战会得到解答。(其实作为一个不要脸的塞，这也是我博士希望贡献的一部分。)

所以，我们认为心灵是基于大脑的一些物理机制，但我们也迫切需要一个清晰而具体的解释，来解释一些物理行为是如何导致心灵从大脑/身体中出现的。

最近，我一直在思考人工神经网络是否能够“幽灵般出现”，拥有我们与思维相关的开放式创造力(第一部分；第二部分回应。一个主要的问题是，大脑不是“设计”来容纳思想的，而是可以在特殊情况下容纳思想，这种特殊情况通常被描述为仅限于人类。当前的动物行为学认为，非人类动物的大脑是“反射共和国”，充满了“指导性”过程，详细说明了动物应该如何对环境做出反应。因此，动物行为在很大程度上是一个由基因决定的本能、可塑性和特定底物学习的故事。然而，人类心理学似乎更具创造性，通常被认为具有“选择性”属性，使大脑成为一种新的遗传信息的宿主——迷因。选择被广泛认为是进化理论中创造力起源的唯一已知机制，而普遍达尔文主义(或进化认识论)认为它的逻辑属性延伸到所有形式的问题解决，包括大脑/思维的问题解决。但是在这种区别之下，指导和选择并不代表一种明确的二分法，因为两种系统都可以用来描述另一种系统:指导可以产生于选择，而选择可以产生于指导。因此，仅从程序的方法来看很难确定计算机是否符合一种解决问题的机制，因此也很难确定一台机器是否能够进行开放式的创造性学习，这是普通或人类智能所需要的。

在缺乏人工智能的明确理论基础的情况下，我被吸引去挖掘并仔细研究机器学习中正在使用的精确方法。在近年来报道的最大成功中，(Google) DeepMind 在深度学习与无监督强化技术的结合方面吸引了最大的关注和兴趣。特别是，在这里，我将快速浏览一下 AlphaGo 的内幕——这台机器现在主宰着古代围棋。正如 DeepMind 在他们的谷歌博客:上发布的那样，AlphaGo 的关键是将巨大的搜索空间缩小到更易于管理的程度。为此，它将最先进的树搜索与两个深度神经网络相结合，每个深度神经网络都包含许多层，这些层具有数百万个类似神经元的连接。一个名为“策略网络”的神经网络预测下一步棋，用于缩小搜索范围，只考虑最有可能获胜的棋。然后，另一个神经网络“价值网络”被用来降低搜索树的深度——估计每个位置的获胜者，以取代一直搜索到游戏结束。”

从这个对架构的简单描述中，让我们问一问，AlphaGo 的机制有多聪明？DeepMind 已经证明，类似的计算架构在一系列性质不同的游戏中具有有效的性能，从射击游戏到赛车游戏。我认为很容易批评这种架构“不太像大脑”，因为它是不同类型的网络和树搜索算法的模块化组合，但如果仿生是 AlphaGo 架构的目标，这只是一种批评。虽然 DeepMind 像其他最近的人工智能初创公司一样，依靠人工智能炒作和生物类比建立起来(例如这里的)，但我不认为复制人脑( sensu Searle 1980 )真的在他们的议程上。我曾在别处论证过，人类类型的智力依赖于感觉，这似乎不是超人能力的目标或要求。在这方面，我认为将人类类型的智能和 AlphaGo 这样的机器可以获得的一般智能的概念分开是合适的。

但是，即使将一般智力作为一个单独的问题来关注，为特定问题定制一个像 AlphaGo ( 见)这样的机器学习“黑匣子”所需的人类专业知识的数量往往被大大低估。有一整套常数定义了网络架构中的修改规则，估计合适的这些常数可能非常棘手。例如，通常有一个折扣因子来衡量未来奖励对当前奖励的重要性，当前奖励需要根据所讨论的特定游戏进行校准，以反映游戏特定的策略要求。有一些渐进神经网络的例子似乎具有一般属性，但这些算法对它们的效用进行实质性评估还为时过早。特别是，还不清楚同一台机器是否可以应用于非常不同种类的游戏。

无论如何，尽管机器学习技术可以说是使机器能够自己学习，但即使是进步的神经网络也不能说是有能力自己“学习如何学习”。这个概念听起来有点拗口，但是这经常被报道为人类教育系统的主要目标，在这种教育系统中，随着学生知识面的扩大，学习的责任逐渐增加，直到他们成为一个有能力的自学成人。这不是一项容易的任务，通常掌握的程度或多或少，并且个体之间的特异性(相对于普遍性)不同。但这种学习需要高度的自我意识，以意识到什么时候某个特定的学习策略值得修改或放弃，以支持另一种选择。没有知觉，我无法想象一台机器如何能达到这种类似人类的一般智能。

也就是说，几乎肯定有方法可以令人满意地复制“学会如何学习”的过程。我的感觉是，这将需要给一个计算机代理附加更多的网络。为了避免策略和价值网络中的进程之间的干扰，A lphaGo 通过在系统架构中将每个网络创建为单独的模块，将这两个网络视为解决不同的问题(还要注意，动作不是由神经网络选择的，而是由树搜索选择的)。如果机器学习的人类艺术可以简化为一组原则，那么很可能将“学习如何学习模块”附加到系统架构中，该架构可以管理如何更新控制学习规则的常数。即使这种艺术不能以一种有意识的方式被还原，神经网络仍然能够以“黑盒”的形式复制这一过程。

但是，同样，随着计算架构变得更加复杂，与生物智能的直接类比将变得越来越弱。作为一名生物学家，我认为智能来自大脑功能完全不同且经常被重新设定用途的机制的结果，而不管代理人是否有知觉 ( 参见)。从这个意义上来说，人工智能的行为导向方法似乎与盲目且不完美的自然选择过程没有根本区别，后者只根据设计的能力来评估设计。从这个意义上来说，我完全相信，对于没有知觉的机器来说，普遍智能是一种真正的可能性。我所说的“一般”是指非特定的任务能力(不是通常定义的类似人类的智能)——就像在渐进神经网络中开始展示的那种智能。当然，一个系统架构对于不同任务的通用性是由程度(而不是种类)决定的，有些架构比其他架构有更广泛的权限。但是，我看不出有什么理由，通过扩展模块化架构来增加跨游戏类型的灵活性，非常通用的能力/智力形式不能成为现实的可能性。

为了捍卫这一立场，我经常遇到关于自然智能和人工智能之间不可逾越的差异的说法，这种差异往往基于以人类为中心的假设(参见我以前关于这一主题的帖子，例如 1 和 2 )。最常见的是，人们从训练数据的规模中听说自然智能和人工智能之间的区别。因为我们人类，事实上还有其他一些动物，能够从低质量和低数量的数据中学习。我认为，这是一个被误解的因素，因为代理人快速学习的能力是在大量非特定背景数据的背景下设定的。虽然机器是在完全无知的情况下接受任务训练的，但生物制剂不会在大脑一片空白的情况下解决问题。年幼的动物通常是天真的，表现出低水平的直觉行为，事实上，人类可能要用一生的时间来获得、发展和磨练他们在特定知识领域的直觉。也许随着进步神经网络的发展，这种普遍智能的壮举可以被复制(因为，毕竟，非人类动物通常被认为是没有知觉的，或者至少具有非常有限的自我意识)。

那么，这给我们留下了什么？正如我在其他地方论证过的，我怀疑随着人工智能体环境的复杂性和与环境的相互作用的增加，基于(必然是渐进式的)基于神经网络的技术的智能体出现一般智能机器的可能性会更大。我认为像感觉这样的生物智能特征似乎不太可能。就我而言，目前对感知(或意识)的生物学基础了解得太少，以至于无法明确感知的精确设计要求(尽管像每个人一样，我也有自己喜欢的理论)。有许多基于感觉的想法，但没有一个达成任何重大共识。因此，类似人类的智能很快出现的可能性似乎很小，因为这将是一个盲目猜测的结果(即超出了目前的非决定性证据)。另一方面，似乎很有可能出现(无意识的)“普通”智能。我的意思是，同一台机器同时获得多种任务能力的可能性几乎是确定的。普遍性的程度还有待观察，但人工和自然代理人的能力之间没有质的区别。因此，我可以很好地想象一些非常通用的解决问题的人工智能确实是非常可能的——尽管我不想猜测时间框架(！)因为现在还为时尚早。

考虑到这一点，对当前技术被扩展以产生通用人工智能是否有乐观的空间？还是我们将面临另一个人工智能的冬天？我认为有合理的乐观空间。围绕像(谷歌)DeepMind 和其他公司的成就的炒作在某种程度上是当之无愧的，因为他们收集了一些令人惊叹的奖杯成就。此外，未来的研究似乎有一些明确的方向，特别是在进步的神经网络中，这增加了当前的兴奋可能会持续到不久的将来，并有更多成功的强烈承诺的想法。但是，我认为，对类人智能的类比可能(也应该！)以避免混乱，并专注于可解决的问题，从而取得可控制的进展。因此，尽管有乐观的空间，但那些将取得巨大进步的领域/方向并不是那些经常向公众报道的领域/方向。这使得公众对人工智能的理解对研究人员来说是一个真正的挑战，并产生了对清晰展示工作的真正需求，而不是用错误的类比来“降低水平”。我对这一点深信不疑，因为人们对人工智能的发展充满了恐惧；如果这些想法能够被公平地交流，那么关于“机器人伦理”的蓬勃发展的猜测将被证明与阿西莫夫的故事一样远离现实。正如(deep mind 的)戴密斯·哈萨比斯所说:“我们离我们担心的事情还远着呢……这更多的是让每个人都跟上速度”。我们应该庆祝一般人工智能的进步，而不是警告或谴责研究人员。而且，如果对监管的呼声被忽视，像渐进式神经网络这样的技术被给予喘息的空间，谁知道也许一些幸运的研究人员甚至会发现潜伏在他们机器中的精神品质的‘幽灵般出现’！

感谢阅读！

今天和明天之间人工智能潜力一瞥(上)

原文：towardsdatascience.com/a-glimpse-i…

4 月 23 日，我很荣幸被 GDG 莫纳斯提尔 (突尼斯)邀请作为演讲人参加 Google Next 2017 扩展活动。我的演讲是关于人工智能的，以下是我想要传达的想法的书面版本。

我敢打赌，当你想到/听到人工智能的时候，你的脑海中会浮现出许多想法！大数据，IBM Watson，Alexa，谷歌自动驾驶汽车，NAO，图灵，谷歌云，但什么是人工智能？是能胜过人类大脑的大脑吗？人工智能如何影响我们的日常生活？AI 背后有哪些技术？

AI 是什么？

回到 1950 年，当计算机科学先驱艾伦·图灵开始思考“如果机器学习会怎样？”。为了制造智能机器，他发明了图灵测试。这项测试改编自一个叫做模仿游戏的维多利亚风格的比赛。当时，艾伦指出了一个许多人不相信或从未想象过的人工智能的可能前景。

仅仅 5 年后，在达特茅斯会议上，约翰·麦卡锡创造了“人工智能”一词，定义为“制造智能机器的科学和工程”。

智能机器，人工智能..在深入挖掘之前，让我们先定义一下智力。

What Intelligence consists of [1]

正如我们所见，智力包括:

1. 处理数据的能力、
2. 学，
3. 解决特殊用途和通用领域的复杂问题，
4. 根据情况进行推理和推断的能力。

这些机器都有这些能力吗？你们中的一些人会说“我想是的！”其他人会反对..而我在这里建议的是，通过查人工智能现在在哪里，一起发现答案！因为没有比真实的事实更有说服力的论据了！

AI 有什么影响？

人工智能在不同的行业都有影响:汽车、电子商务、市场营销、机器人、移动设备等等。毫无疑问，健康是人类最重要的支柱之一。如果一个人的健康状况不佳，他就不可能在技术上取得任何进步。因此，对包括 IBM 和谷歌在内的许多公司来说，在医疗领域投资人工智能是一件大事。

人工智能正在帮助医生更好地探索人体，并处理其复杂性。2017 年 4 月，英国诺丁汉大学的一个团队进行的一项研究证明，医生在使用人工智能时，可以更好地预测病人的心脏病发作风险。这每年可以拯救成千上万的人。

事实是，每年有 1500 万到 2000 万人成为心血管疾病的受害者，包括心脏病发作、中风和动脉阻塞。医生使用一种称为 ACC/AHA 的方法，根据年龄、胆固醇水平和血压等指南来预测心脏病发作的风险。实际上，该方法显示出不是非常有效。人体的复杂性还隐藏着一些不为人知的生物学准则。

幸运的是，正如诺丁汉大学的流行病学家斯蒂芬·翁告诉《科学》杂志的那样。"计算机科学让我们能够探索这些联系."在这个问题上尝试一些机器学习算法，如逻辑回归和神经网络，得到了更好的预测！该算法比 ACC/AHA 方法多 7.6%，导致假阳性减少 1.6%。这意味着，在大约 83，000 份病历的样本量中， 355 条额外的生命本可以被挽救。[2]

人工智能在医学领域的成就不止于此:

1. IBM Watson for oncology 致力于癌症诊断，
2. 谷歌 DeepMind 失明检测:英国有 200 万人患有失明，其中约 36 万人注册为盲人或部分失明。[3]这个研究项目是调查技术如何帮助更好地分析扫描结果，让医生更好地了解眼病。研究团队开发了一种人工智能算法，可以自动识别糖尿病视网膜病变，这是成年人失明的主要原因。“我们能够把谷歌的一些核心东西——对猫、狗和面孔进行分类——应用到另一类问题上，”在谷歌负责该项目的医生和生物医学工程师 Lily Peng 说。
3. 像软银公司开发的用于老年人辅助的罗密欧一样，作为手术和病人助手的机器人。

虽然为了真正帮助开发医疗服务和患者援助，确实还有许多工作要做，但人工智能的影响已经存在，医生们相信与人工智能的合作将是有益的，“我不能强调它的重要性，”加利福尼亚州帕洛阿尔托斯坦福大学的血管外科医生埃尔西·罗斯告诉《科学》，“我真的非常希望医生们开始接受使用人工智能来帮助我们护理患者。”

让我们继续关注与人工智能一起成长的第一个领域:游戏。 这个故事始于计算机通过简单地计算棋盘上所有可能的走法或死记硬背，在国际象棋或危险边缘等游戏中击败人类。

今天，计算机甚至可能具有超前思考和推理的能力！在谷歌的阿尔法围棋赢得 T4 之前，研究人员没有考虑到这些可能性！

2016 年 3 月，世界顶级围棋选手之一李世石(Lee Se-dol)在与 AlphaGo 程序的比赛中只赢了一场。该游戏被认为比国际象棋复杂得多，因为它有更多的移动可能性(> 10170 个合法位置)。因此，它通常需要一种特殊的人类技能:直觉和创造力。DeepMind 的研究人员表示，这种计算能力在游戏之外还有现实世界的前景，特别是在医疗保健和科学领域。

DeepMind 的研究人员表示，这种计算能力在游戏之外还有现实世界的前景，特别是在医疗保健和科学领域。

健康，游戏，还有什么？

Google self-driving car

嗯，人们现在都在谈论不仅能运送我们，还能替我们思考的交通工具！

“谷歌在 2012 年开始测试一辆自动驾驶汽车，从那时起，美国交通部 发布了不同自动化水平的定义 ，谷歌的汽车被列为全自动化的第一级。其他交通方式有 更接近全自动化 ，比如公交车和火车。

人工智能在交通领域的应用领域非常广泛。由于模式识别、系统识别、分类和许多其他人工智能子集，交通运输多年来发生了巨大的演变！

交通状态跟踪、高级驾驶员辅助系统(ADAS) 、驾驶员警报系统(例如睡意检测)已经存在，为驾驶员提供更好的驾驶体验。谷歌、特斯拉、沃尔沃以及许多其他公司都专注于提供道路安全，其方式是“人工智能可以改变我们的情感以及我们与汽车的实际关系”。

好吧，你可能会告诉我:这听起来不错，但我身边没有这些人工智能的应用！“我在美国不是为了看自动驾驶汽车”，“我不是为了在工作中尝试人工智能辅助的医生”，“我不玩游戏！”我不确定 AI 对我生活的影响！

你已经在用 AI 了！又不是科幻！是真的。也许，你只是没有意识到！不管你愿不愿意，人工智能正在影响你日常生活的方方面面。

在网上冲浪时，你正在试验用户行为跟踪。像谷歌、亚马逊、脸书等许多公司都在利用你的偏好、历史、搜索和购买，以便预测你的兴趣，并根据情况锁定你(脸书新闻提要，网站页面右侧/左侧的广告，购买书籍的建议..).所以，通过谷歌搜索，脸书，网飞的电影推荐，亚马逊商店，你会遇到人工智能的方方面面。

人工智能也在你的手机里！Siri、Google Now、Cortana 都是使用人工智能技术的智能助手，旨在帮助你获得问题的答案，或通过语音控制执行操作。例如，你可以说:“今天天气怎么样？”助手会搜索这些信息并把它与你联系起来。

不仅如此，AI 还用于在线客户支持。不是你访问的每个网站都有真人和你交流。在许多情况下，你在和一个初级的人工智能(聊天机器人)交谈。

你看到了吗？AI 无处不在！你的智能手机，你的汽车，你的银行和你的房子也可能！

在这一点上，这个故事开始像一部恐怖电影:谈论所有这些人工智能的影响提出了一些问题..好像有争议吧？直觉，创造力，协助，保存你的数据，可能会拿你的隐私冒险，使用数据训练机器，帮助医生，分心的司机识别，人形机器人，下一步是什么？人工智能是否拥有真正的“智能”(我们在开始时定义的智能)？人工智能会取代我们的工作吗？

未完待续……

原创文章发表在我的网站。

资源:

[1] 人工智能定义，德勤。

[2] 机器学习能否利用常规临床数据提高心血管风险预测？

[3] 谷歌健康领域的 DeepMind 研究。

芝加哥西尼罗河病毒

原文：towardsdatascience.com/a-go-at-kag…

我刚刚学到了一些令人沮丧的教训——作为对卡格尔西尼罗河病毒竞赛的敬意。www.kaggle.com/c/predict-w…。这不是我们有过的最大或最棘手的项目，但它让我很困惑。我的方法过于草率，陷入了竞争的心态，这让我陷入了许多兔子洞，所有这些都是可以避免的。这些都是糟糕的流程和代码混乱的症状。我很高兴我得到了教训，因为我不会让它再次发生！至少这是希望..有了这些经验教训。

• 不要混淆你的笔记本进度。没有什么比从头开始运行单元并失败更糟糕的了，因为一部分 EDA 是在未来的数据帧上执行的
• 制作函数并使其动态化。这不仅允许添加功能，也允许省略功能；允许您操作数据以快速迭代，通常是朝着更好的先前数据集进行多次迭代。
• 保存表现良好的提交数据/模型。 这个数据集仍然是小规模的，可以在几秒钟内重新运行，但没有理由忘记哪些功能让你获得了 0.73 的 Kaggle 分数！
• 确认训练/测试集具有相同的列。 您对测试数据的预测最终取决于它提供的列/值——当然您也可以对其进行特征工程——但是确保您可以将测试集传递到您的训练数据转换函数中是关键。

有了这个数据集，对数据有个概念是相当容易的。我们正在查看芝加哥的一些捕蚊器，以及一些关于它们的位置、捕捉的蚊子类型、日期和一些其他琐碎特征的数据。训练集约为 12k 行；测试约 112k。Kaggle 对提交的内容进行评分的标准是 AUC。更多内容请见下文。

因为我们在看一个分类问题，EDA 之后的第一步实际上是获得基线分数:就准确性而言，最简单的预测会给你多少分。在这种情况下，目标变量是 WnvPresent，由于西尼罗病毒的罕见性质，如果我们猜测一只蚊子没有西尼罗病毒，我们 94.8%的时间都是正确的！这是一个简单但** 关键** 的概念。

我的下一步是向 Kaggle 发送一个示例提交，这样我就可以确认格式。你知道，登上排行榜。有了这个剪刀，我就在那里。

从这里开始，最初的 jupyter 笔记本是这样的。调查分类数据预测西尼罗河的可能性。看看这些数字，找出它们之间的关系。假设。重复一遍。它很乱，我忽略了让它容易重复。第二天我非常后悔。

很明显，很多陷阱都是惯犯。此外，NumMosquitos 特性似乎会使预测变得容易。记住，任何高于 0.0525 的预测西尼罗河的机会都是值得研究的。这是我们的基线谈话。所以这些落在 0.09 以上的陷阱看起来是很好的预测。

捕获的蚊子越多，蚊子数量就越多。

因此，我创建了一个快速而肮脏的虚拟变量函数，将陷阱和块数据放入一些数字中，删除了其他大部分列，然后将我的测试集放入模型中，然后嘎然而止。在我对它进行变换后，会有更多的列。为什么？该死。没想到会这样。你看，我们的课程往往有非常干净的数据。嗯，并不是说这很混乱，但它与我的假设 test.columns = train.columns 不同。测试集中也有新的数据。看不见的陷阱。和一个新物种。这就是大多数额外栏目的来源。

所以，我不完全确定在这种情况下什么是正确的决定。大多数其他学生都在用相反的方法运行，即找出几个最有可能感染西尼罗河病毒的关键特征，然后用它们运行他们的模型。我喜欢快速迭代替代方案，这意味着我需要弄清楚如何手动修复大约 200 个特性列而不是。我能想到的最好的办法是从一开始就连接测试和训练，并重复虚拟预处理。我想，这将确保它们具有相同数量的列，并且我可以将它们从 Id 列中分离出来，Id 列是测试集的数字，NaN 是火车的数字。

这意味着测试集中的新列与可预测性无关。尽管他们不会，除非我们能以某种方式概括他们。比如把陷阱按 10 个一组分组之类的。我也不确定是否使用了年份数据——因为我添加了虚拟值，但是从测试到训练的年份不同。我决定下次再考虑这个问题。

经过一两个小时的忙碌，我提交了下一套，很高兴地发现在 Kaggle 上获得了 70 AUC。AUC 指标在这里也很重要，但要理解它，我们首先需要理解什么是混淆矩阵。

在像西尼罗河病毒这样的二元分类中，有 4 种可能的结果:

• TP —真阳性:WNV 出现，WNV 被预测。
• FP —误报:(第一类错误) WNV 不存在而 WNV 却被预测到了。
• TN——真正的否定:WNV 不在，WNV 没有被预测到。
• FN —假阴性:(第二类错误) WNV 是存在的，但 WNV 却没有被预测到。

这些是我们判断分类器的依据。混淆矩阵有许多最常用的评估指标:

• 准确度= (TP + TN) / (TP + FP + TN + FN)
• 精度= TP / (TP + FP)
• 召回率(TPR)= TP/(TP+FN)-正确预测的阳性数据点占全部阳性数据点的比例。
• 脱落(FPR)= FP/(FP+TN)-被错误预测的负数据点占负数据点总数的比例。

AUROC 或通常称为 AUC，是真阳性率和假阳性率之比的曲线下面积。理想的分类器是 AUC 为 1 的分类器；其中 TPR = 1，而 FPR = 0。AUC 讲述了在我们可以选择的阈值范围内，我们的分类器的 TPR 如何与其 FPR 相关的整体情况。在下面的例子中，TPR 在大约 0.6 FPR 时达到最大值。意思是要正确分类所有的正面事例，我们会错误地把 6/10 的负面事例分类为正面。

The AUROC commonly referred to as the AUC is the ratio of the TPR over the FPR

很好地解释了这一切是如何运作的:www.youtube.com/watch?v=OAl…

我能够添加的一些最好的功能是基于位置和天气的。两者都是在数据中发现更高概率的 WNV 聚类的例子。在地理位置方面，我在奥黑尔机场附近找到了 WVN 的一个热点。通过将距离< 3 英里归类为 1，我能够创建一个二进制列，使样本中存在 WNV 的几率为 0 . 1。

另一种是使用湿球值作为高于某一阈值的二元指标。

最后，我太沉迷于添加和删除功能以及重新训练我的模型，以至于失去了我最初的最好成绩。在我对自己感到相当沮丧之后，我重新构建了许多代码，并且有条不紊地修改了我的解决方案。结果是能够获得更高的分数，并且能够在不失去我的位置的情况下快速迭代。

这个故事的寓意是，获得最快最好的结果不应该以不可复制的数据为代价。你的流程越有条理，你在函数中构建的自由度越大，你就越有能力改变你的数据和模型。

毕业生的观点:解决实际问题

原文：towardsdatascience.com/a-grads-vie…

这是我为 MassMutal 博客写的一篇文章的报告:https://blog . mass mutual . com/post/a-grads-view-solving-real-problems

就在今年 5 月，我从佛蒙特大学和计算故事实验室研究小组毕业，作为一名高级数据科学家在 MassMutual 工作。虽然终身学生(读博生)和在工业界工作有很多不同之处，但重叠部分是巨大的，我已经能够在 MassMutual 安顿下来。

差异

最大的区别是什么定义了价值。机器学习研究的价值在于新的算法和分类精度的边际改进。但是，在商业中，我们的数据科学成果和机器学习算法通过改善客户体验来提供价值。

虽然花费几个月的努力来开发一种改进的算法，并将准确率从 90%提高到 92%会在学术期刊上受到欢迎，但将过程从 50%提高到 90%才是所有收益所在。(相关 : 数据科学与万通)

重叠

事情如此相似的一个最大原因是，MassMutual 的数据科学团队采纳并应用了许多在大学行之有效的实践。我发现，在每周的实验室会议上，在拥有导师结构的同行学习文化中，在类似于期刊论文的项目报告的间隔评审过程中(没有任何粗鲁的评审员)，我很容易感到自在。

再加上计算故事实验室使用机器学习和计算作为工具来研究有趣的问题，这是匹配的。

哪些大学可以学

另一方面，我在 MassMutual 工作的几个月所学到的东西可能对改进研究大有帮助。

我们有一个数据工程团队来支持计算和数据平台(从第一天开始就令人兴奋)，以有助于保持项目进展的方式跟踪我们的工作，在整个团队中遵循一致的编码风格，并确保我们的模型是可复制的。后一部分，用一致的项目结构构建可复制的模型，是我和另一个团队成员 Paul Shearer 最近致力于并实现的工作。

最后，虽然我们的重点是解决业务问题，但这并不是说没有任何科学在进行。我们预测寿命的模型利用了新的方法，我还没有完全理解。我们针对棘手的问题调整实践状态的方法，并使用实验来跟踪我们的模型的结果并改进它们。

我们正在将应用机器学习带到整个公司的各个领域，这是一个令人兴奋的地方！

更多来自 MassMutual…

MassMutual 的研究生项目:如何运作

MassMutual 的数据科学发展计划

生活互助:教训和故事

媒体标签图

原文：towardsdatascience.com/a-graph-of-…

热门帖子涵盖的 5 大主题

正如在之前的一篇文章中所描述的，我收集了 1000 个媒体最受欢迎的故事的数据。这是他们最常见的标签的可视化。我冒昧地将同义标签映射到它们的规范名称。比如“Tech”→“Tech”，还有“Trump”→“Donald Trump”。

节点的大小与标签的使用次数成正比。技术是媒体的宠儿。

连接两个标签的灰线表示它们都在同一个帖子中使用。一对标签之间的线条越粗，它们并排出现的频率就越高。

彩色聚类是一组标签，这些标签内部有密集的连接，而它们之间的连接则比较稀疏。这五个集群总结了流行媒体帖子的主要主题。

• **设计:**设计，UX，网页开发，软件开发，苹果，营销，谷歌，数据科学，灵感，产品设计，网页设计
• **个人发展:**生产力、人生经验、自我提升、创业、商业、教育、书籍、心理学、个人发展、创造力、健康、爱情、生活、创业、人际关系、养育、心理健康、领导力、工作、写作、艺术、文化
• 编程: JavaScript，编程，科学，人工智能，社交媒体，技术，机器学习，React
• **政治:**女权主义，政治，榜单，女性，新闻，幽默，唐纳德·特朗普，旅游，种族主义，黑人问题，历史，新闻，媒体
• **加密货币:**区块链、比特币、以太坊、加密货币、风险投资、经济学

用 R 绘制图形出奇的容易。我创建了一个文档术语矩阵，其中行是文章，列是标签，值为 0 或 1，表示文章是否有标签。它的叉积给出了一个邻接矩阵，这是一个所有帖子中标签共现计数的对称矩阵。r 的 igraph 软件包绘制了这样的邻接矩阵。通过调用 tkplot，可以在 GUI 中交互式地调整节点的布局。

g = graph.adjacency(adjMatrix, mode="upper", weighted=T, diag=F)plot(cluster_leading_eigen(g), g, edge.width=E(g)$weight*.1, 
layout=l, vertex.size=25*counts[-removed]/max(counts[-removed]), vertex.label.family="Arial", edge.color=NULL, vertex.label.color="black", edge.curved=.5)

生活的图示

原文：towardsdatascience.com/a-graphical…

Graphs Plotted with Processing

对我来说，生活由一系列的起起落落、好时光和坏时光，或者快乐和悲伤组成，保持着周期性。除了周期性的波峰和波谷，还有一丝混乱和不确定性。

解释图表

一个周期波或信号本质上是那些每当一个恒定的时间过去时循环回到一个相似的模式的波或信号，该“时间”正式地被称为信号的“周期”。余弦波是一种常见的周期信号，让我们从它开始。

A Cosine Wave

看着余弦波，一个非常普遍的生活模型出现了——线上的驼峰代表生活中的好时光，而下面的驼峰代表不好的时光。

现在，这种模式还有改进的空间。基本上，一个“快乐”的时间框架仍然会有微小的起伏。“悲伤”的时间框架也是如此。这就是生活不可预测性的来源。这可以通过在余弦图上添加一点噪声来实现。

A Cosine with noise added

最后，我们中的一些人往往会在生活的“好”和“坏”部分之间经历快速的转变或变化。

Rapid transitions

而另一些则倾向于具有较慢的过渡。

Slower Transitions

无论一个人对生活的描述是什么，这里要记住的关键一点是，坏时光结束了，好时光几乎马上就来了。暴风雨总是会放晴，为晴朗的天空腾出空间。

本文中的所有图表都是使用 处理 编程语言绘制的。向丹尼尔·希夫曼喊出他关于柏林噪声和图形绘制的精彩教程。

一个很大的陷阱:忽视验证

原文：towardsdatascience.com/a-great-pit…

Photo by Paul on Unsplash

它出现在你的书的第一章，出现在你参加的第一次讲座，或者出现在你看的第一个教程中。这似乎很简单:你不能根据你对用于训练的数据所做的预测来衡量你的预测者的表现。然而，随着管理层不断施加更大的压力，或者您的堆栈需要更长的时间来运行，您开始牺牲验证。整个故事是关于一个非常基本的事情:确认。

什么是验证？

如果你已经知道答案，你可以跳过这一节。如果你不确定，我来大致解释一下。让我们说，你想有一个预测器，在一个特定的任务执行预测。得到预测器后，你会想知道它的表现如何？它是表现很差以至于没用，还是表现很优秀以至于你可以宣布问题解决了？为了测量性能，您需要验证。

为了执行验证，您需要数据。更具体地说，您需要包含您想要预测的信息的数据。我们称这些信息为地面真相。根据维基百科，地面真理被定义为:“直接观察提供的信息” *** 。地面实况通常由人类提供。在我们的过程中，我们相信基础事实是我们想要为我们的数据预测的实际值。

一旦你有了你的预测者和真实的数据，验证的冒险就开始了。如果在你的开发过程中没有真实的数据，这很容易。你只需将预测与实际情况进行比较。但是，这种情况很少见。你很少锁定你的全部数据，不到最后也不会深入研究。在开发预测器时，经常会用到这些数据。您使用一些数据进行训练，检查数据以调整阈值，或者深入数据以了解如何实现良好的预测。在这种情况下，你需要思考如何建立一个稳固有效的验证机制。

我们为什么要进行验证？

这似乎很简单:我们正在进行验证，因为我们想衡量我们的预测性能。但是，我们不要被这种现成的定义所迷惑。我们不只是想衡量业绩。我们想知道我们的预测器在现实生活中是否会做得很好。

让我们建立一个预测任务示例。在这个例子中，我们想知道一个图像中是否有一只猫。在这个任务中，你向预测器提供一幅图像，它会告诉你图像中是否有一只猫。所以根据定义，这是一个二元分类问题。

对于此任务，您可以找到一个数据集或准备自己的数据集。在那之后，你就可以开始开发你的预测器了。但是人们不应该忘记你为什么要开发一个预测器。您不想在数据集中检测猫。你想要一个预测器，当你拿起相机在当地公园给猫拍照时，它能检测到猫。为了验证，你硬盘上的数据集是为了帮助你，这样你就不用一直在你当地的公园里追猫了。但是有了这种安慰，我们经常会忘记真正的目标，而去追求奖励价格:更高的 KPI(关键绩效指标)值！

我们正在进行验证，以便让我们很好地了解我们的预测器在现实生活中的作用。你的 KPI 只是帮你，并不是你的实际目标。在开发预测工具时，我们需要记住这一点。

当你忘记验证的时候

如果您忘记或未能建立有效的验证机制，会发生什么情况？让我给你描述一下这个场景的可能结果。

你在做你的项目。你专注于让你的 KPI 越来越好。你在它上面努力工作。你得到更多的数据，你用不同的方法进行研究，你进行大量的实验。最后，你会得到一个看起来很棒的表演。任务完成！您现在已经准备好展示您的工作并部署它了。

在这一点上，每个人都很高兴。你把它展示给你的团队、管理层或你的同事。如果你幸运的话，有人会发现你犯的错误。如果你幸运的话，有人会告诉你，你没有建立一个有效的验证机制。这还不是最坏的情况。你还是没有部署你的预测器。尽管如此，没有人受到这个错误的影响。你只需要回到草图板，引入一个有效的验证机制。但是如果你运气不好，你会陷入一个糟糕的境地。

在最糟糕的情况下，你部署了你的预测器，它就启动了。过了一段时间，人们开始意识到你开发的预测器表现不好。用户会开始抱怨。每个人都变得困惑。KPI 表明预测器表现非常好。但是为什么用户对性能不满意呢？过了一段时间，你确信有问题。你回到画板，试着调试你的模型。最后，你意识到你的 KPI 显示的是不对的。你的验证机制被破坏了。你太专注于提高 KPI，牺牲了验证。现在你的声誉受损，你需要在混乱开始前迅速想出一个新的模式。

为什么我们会放弃或忘记验证

我们牺牲验证或者忘记完全建立验证有很多原因。我相信这个清单很长。我下面的列表并不完整，但这些是我经常遇到的。

管理层施压

这个问题不是数据科学或验证所特有的。管理层或业务方总是希望快速有结果。他们给团队施加压力，让他们尽快想出一个预测器。随着压力的增加，你开始放弃你的方法的某些方面。你选择放弃的一个方面可能是验证。你知道验证并不好玩。正因为如此，你需要有一个不同的工作流程。除此之外，还需要更长的时间。因为这些，它可能看起来像一个修剪的好地方。

你认为你不需要验证

我相信这是因为忘记了我们为什么要进行验证。不管原因是什么，你可能认为你不需要验证。让我列举几个我遇到的原因:

因为你不使用机器学习。

验证的需要并不是机器学习所特有的。模型的复杂性并不决定验证的必要性。即使你的方法是一个单一的 if 语句，或者一个复杂的机器学习模型，也没关系。你需要被认可。

因为你认为你的方法并不过分。

即使你使用复杂的正则化方法，也不意味着它能完美地工作。过度配合预防措施并不完美。意味着你不能依赖他们，也不能在训练集上衡量他们的表现。

因为你的方法与验证无关。

也许你认为你不需要验证，因为你没有在训练中使用任何数据。然而，你确定你自己没有在你的方法中引入任何偏见吗？这是兔子洞更深的部分。即使你在训练过程中没有使用任何数据，你作为一个人可能已经发展出一种偏向于你所使用的数据的方法。让我使用猫检测示例来阐明这一点:如果您的数据集仅包含深色猫，并且您在开发算法时使用了此信息，则它在您的数据集上的表现将优于在真实生活环境中的表现，在真实生活环境中有不同颜色的猫。

您的跑步/实验花费了很长时间

通常机器学习操作需要很长时间，这不是秘密。即使一次运行没有，你也会因为各种原因想要很多次，比如尝试不同的超参数、方法等。当你的耐心开始消退，云服务器账单开始堆积，最后期限临近；你试着砍掉一些操作。在这一点上，你倾向于切断验证。您可能会开始使用较少的折叠，切换到二次采样，或者更糟:取消验证。

没有借口。您需要验证

不管是什么原因，不管上面是否列出，你都不能没有一个有效的验证机制。验证是预测工作的基础。你可以从不同的方法中选择一种(如交叉验证、二次抽样等。)但是你必须有一个。这是最好的从非常早期的阶段。它可能会随着项目的进行而发展，但是即使在您的第一次运行中，您也必须使用验证。没有有效的验证机制会在项目的后期导致更大的问题。

兔子洞更深:有效验证

当我们再次思考为什么我们需要验证时，情况比仅仅使用现成的验证方法如 K-fold 交叉验证更深入。如果我们想确保在现实生活中获得类似的表现，我们需要更深入地考虑验证。

这个话题超出了这个故事的范围，但是这里有一些值得思考的东西:

• 您的数据是否以一种不明确的方式泄露了实例的标签？
• 数据集是否包含一系列变化？
• 数据是在合成(实验室)环境中收集的，还是真实收集的？
• 你是否通过你自己在你的方法中引入了偏见？

构建卷积神经网络指南

原文：towardsdatascience.com/a-guide-for…

为计算机视觉构建深度网络

想获得灵感？快来加入我的 超级行情快讯 。😎

计算机视觉处于人工智能(AI)进步的最前沿。每天都有新的研究出来，这让我们可以做以前用计算机和人工智能做不到的真正令人惊叹的事情。下图显示了 Mask-RCNN 的结果，这是有史以来为计算机视觉设计的最灵活、最强大的深度网络之一。它能够产生你在下面看到的惊人的分段。

From Mask-RCNN, a state-of-the-art Instance Segmentation network

卷积神经网络(CNN)是我们今天看到的计算机视觉研究中每一个进步背后的驱动力。大多数人从一般意义上知道他们是如何工作的。只需将一堆卷积的东西堆叠成许多层，也许加入一些池，在最后加上一个 softmax，瞧，这就是计算机视觉！

对于一些人来说，有了这种高层次的理解就足以了解正在发生的事情。但是如果你真的想为现实世界的计算机视觉设计一个 CNN，你将需要更多。

你使用哪种预先训练好的网络？你如何修改它来满足你的需求？你的网络应该有 20 层还是 100 层？哪些是最快的？最准确？这些都是在尝试为您的计算机视觉任务选择最佳 CNN 时出现的问题。

让我们来看看你可以用来构建 CNN 的所有构件，不同的权衡，以及如何实际应用它们！

盘旋

卷积运算是 CNN 的核心，如何使用它将是网络性能的一个重要决定因素。在你的 CNN 中使用任何大于 3x3 大小的东西都没有多大意义，例如，避免在你的网络中使用 5x5、7x7 等。已经可重复地表明，最显著的是利用 VGGNet 和 ResNet ，顺序堆叠 3×3 卷积将有效地实现与更大尺寸卷积相同的感受域，同时计算效率更高。

Illustration of how stacking two 3x3 Convolutions will get you a receptive field of 5x5 with 18 parameters (3x3 + 3x3 = 18), while a regular 5x5 Convolution would require 25 parameters to achieve the same thing

1x1 卷积也可用于网络中的某些点，以在用 3x3 进行处理之前降低特征图的维数。ResNets 用下图所示的瓶颈块实现了这一点。我们首先将所有信息压缩到 64 个特征地图中，而不是处理一个巨大的 256 深度的特征地图。一旦它被压缩，我们应用我们的 3×3 卷积；当应用于 64 个要素地图而不是 256 个要素地图时，它的速度要快得多，并且这种处理已经被证明可以获得与常规的 3x3 堆栈相同或更好的结果。最后，在最后，我们使用另一个 1x1 映射回我们原来的 256 大小。

A ResNet bottleneck layer, utilising 1x1 convolutions to reduce feature map dimensionality

至于激活，通常与代码中的卷积相关，一个很好的经验法则是从 ReLU 开始。使用 ReLU 通常会立即得到一些好的结果，而不需要像 eLU、PReLU 或 LeakyReLU 那样进行繁琐的调整。关于哪种激活是最好的，研究界仍有很多争论。但是在实际操作中，差别往往很小，除非你真的需要那额外的 1%,否则用它们做很多实验是不值得的。一旦您确定您的设计与 ReLU 配合得很好，那么如果需要的话，您可以与其他人一起玩，调整他们的参数，尝试并提高最后一点精度。

吸取的教训

• 对于大量的处理，使用 3x3 的堆栈
• 使用 1x1s 来压缩和扩展特征地图，以降低计算成本

联营

CNN 中的池用于特征汇总，而当我们深入网络时进行下采样。当我们到达每个“阶段”的末尾并希望进行下采样时，我们保留空间信息的能力将由于下采样而降低。因此，为了保留我们的信息，我们进行了一些汇总来总结我们所拥有的。最常见的两种池类型是最大值和平均值。

关于最大池还是平均池更好，在研究界仍有很多争论。坦率地说，根据我的经验，这种差别可以忽略不计。也就是说，一个常用的范例是在整个网络中使用最大池来保留最佳要素，并在最后使用平均池来在最后一个密集图层之前获得要素的最终矢量表示，然后将数据传递给 softmax。

An illustration of max pooling

经验教训

• 作为默认选项，在整个网络中使用最大池，在密集层+ softmax 之前的最末端使用全局平均池
• 您可以尝试其他配置/风格，尽管在大多数情况下收益可能很小。

网络深度和结构

网络深度、准确性和速度之间的权衡相当简单。图层越多，总体精度越高，但由于计算量增加，网络运行速度会越慢。总的来说，你可以尝试一下深度，找到最适合你的最佳点。经过一点练习，你可能也能做出一个不错的猜测。需要注意的是，精确度和速度之间的权衡是由收益递减规律决定的，也就是说，我们增加的层数越多，每层给我们的精确度增加的就越少。

至于网络结构，像 ImageNet 这样的标准基准和上面两个漂亮的可视化让我们的工作变得容易多了！对于速度， MobileNet-v2 和深度可分离卷积块应该是默认选项。MobileNets 还有一个额外的优势，那就是它们设计得很好，可以在 CPU 上运行，在某些情况下甚至可以达到实时性！其他网络在 GPU 上的性能看起来与 MobileNets 相似，但在 CPU 上却远远不够。这是一个很大的优势，因为 CPU 计算比 GPU 便宜得多($)。

世界上最精确网络的头衔是不分胜负的: SENet 和 NASNet 在精确度上相差百分之几。如果你只是想进行迁移学习，那就用 NASNet，因为它有一些深度学习库的内置实现，比如 Keras。然而，当从头开始构建时，SENet 和挤压激励模块在实践中更容易编码。对于快速原型，或者在速度和准确性之间取得平衡的东西，一个常规的 ResNet 和剩余块就足够了。

你可能想玩的最后一件事是图像分辨率。越小越快。越大通常以内存消耗和运行时间的平方增加为代价获得更高的精度。

经验教训

• MobileNet-v2 /深度方向可分离卷积和低速度分辨率
• SENet / Squeeze-Excitation 或 NASNet 和高精度分辨率
• 余额的常规 ResNet / Residual 块

数据预处理和扩充

一个经常被遗忘但需要考虑的关键问题是数据准备、预处理和扩充。你并不总是有去做这件事。在对数据进行任何处理之前，您应该首先评估您的应用程序是否会从中受益。

例如，在图像分类中，标准协议是基于训练数据的平均值对图像进行均值归一化。研究文献已经多次证明，均值归一化是一种很好的默认做法。

另一方面，如果你正在进行图像增强，均值归一化实际上会对网络和结果造成相当大的伤害。任何真正与纹理、颜色或外观等非常细微的差异有关的任务，而不是高层次的形状和语义差异，可能会从而不是做任何均值归一化中受益。

另一方面，数据扩充已经被强有力地证明能够持续地提高网络性能，无论是在绝对准确性还是普遍性方面。它在从高级分类到低级增强的所有任务范围内都是如此。

话虽如此，你还是应该考虑应用哪些增强的*。例如，如果您正在为自动驾驶汽车进行图像分割，您并不真的希望汽车颠倒行驶！因此，您可以应用水平翻转，但避免垂直翻转。当您实际训练您的最终网络，或者只是快速查看增强有多大帮助时，使用数据增强是最合适的。在此之前，你只是在试验和原型制作，所以没有必要通过更多的数据来延长你的训练时间。*

经验教训

• 仅在需要时进行预处理，基于您的任务，并使用经过验证的研究作为指导
• 增强几乎总是增加准确性，只要确保您在反射中使用它，并且数据是您实际期望在应用程序中看到的

规范化

当你觉得你过度适应你的训练数据而在测试中表现不佳时，可以使用正则化。当您看到您的训练和测试精度之间的差异非常大时，您可以知道您是否过度拟合，因为您的训练精度比测试精度好得多。

有几个选项可供选择:失落，空间失落，剪切，L1，L2，添加高斯噪声…在研究论文的海洋中还有更多！实际上，dropout 是最容易使用的，因为你通常只需要把它放在几个地方，并调整一个参数。您可以将它放在网络中最后几个密集层之前。如果你觉得自己仍然过度适应，你可以在网络中更早地添加更多，或者调整退出概率。这将缩小你的训练和测试准确性之间的差距。

如果常规辍学失败，你可以和其他人一起玩。像 L1 和 L2，你有更多的调谐选择，所以也许可以校准他们，做一个比辍学更好的正规化工作。在绝大多数情况下，你不需要结合一个以上的正则化技术，即在你的整个网络中只使用一个。

吸取的教训

• 出于实用性和易用性的考虑，默认使用 dropout
• 如果辍学失败，探索一些其他可以定制的课程，如 L1 / L2
• 如果所有的技术都失败了，你的训练和测试数据可能会不匹配

培养

当你最终想要训练你的网络时，有几种优化算法可供选择。许多人说 SGD 在准确性方面给你带来了最好的结果，这在我的经验中是真实的。然而，调整学习率时间表和参数可能是具有挑战性和乏味的。另一方面，使用 Adam、Adagrad 或 Adadelta 之类的自适应学习速率既快速又简单，但您可能无法获得 SGD 的最佳精度。

这里要做的最好的事情是遵循与激活函数相同的“风格”:首先从简单的开始，看看你的设计是否工作良好，然后使用更复杂的东西进行调整和优化。我建议从 Adam 开始，因为根据我的经验，它非常容易使用:只需设置一个不太高的学习率，通常默认为 0.0001，你通常会得到一些非常好的结果！以后你可以从头开始使用 SGD，甚至从 Adam 开始，然后用 SGD 进行微调。事实上，本文发现，从 Adam 切换到 SGD 中训，以最简单的方式达到了最好的准确率！看看报纸上的下图:

至于你的数据，越多越好。唯一要考虑的是你从哪里开始得到收益递减。例如，如果您已经达到 95%的准确率，并且您估计如果您将训练数据翻倍，您可以达到 96%，那么可能是时候真正考虑您是否真的需要这 1%，因为达到这一水平所需的努力和资源相当高。当然，要确保您收集的数据反映了您将在实际应用中看到的情况。否则，无论你使用什么算法，选择不当的数据都不能解决问题。

喜欢学习？

在推特上关注我，我会在那里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上和我联系吧！

建立神经网络结构的有效方法指南——第一部分:用 Hyperas 对密集网络进行超参数选择和调整——MNIST

原文：towardsdatascience.com/a-guide-to-…

介绍

“如果你听从你的直觉，你将永远知道什么是最适合你的”

这是人们在讲授生活时所说的，对生活来说可能是真的，但对训练神经网络来说，这是我所相信的

“相信你的直觉，但也要相信你的逻辑，不要为了弥补一个而忽略另一个”

这源于这样一个事实，即我遇到的许多人在被问到为什么在他们的神经网络架构中选择某些值时，他们通常回答说“嗯，只是直觉和一点点尝试”，这似乎不太合适，因为这不能帮助我们知道我们的模型实际上有多有效，以及是否有任何架构组合可以帮助我们实现更好的概括结果。

因此，通过这个博客，我想分享我在修补深度学习模型时学到的一些旅行和技巧，以及我遵循的一条铺设好的道路，以帮助我实现最佳架构，获得最佳结果

这里显示的所有结果都是我在 appliedaicourse.com 大学 ML/AI 课程中对时尚 MNIST 数据进行的一个案例研究的结果。感谢 AppliedAICourse 团队在撰写本博客时提供的宝贵建议。

更多的数据可以从www.kaggle.com/zalando-res…、github.com/zalandorese…了解。帮助我们开始工作的数据的重要细节如下

-包含 28x28 件衣服的图像 -包含训练集的 60，000 幅图像和测试集的 10，000 幅图像 -我们的任务是将图像分为 10 个不同的类别，如 t 恤/上衣、裤子、套头衫、连衣裙等。

必要的函数库或软件包有:- -tensor flow -Keras -Numpy -Hyperas，Hyperopt

• Matplotlib

您将需要一个 IPython 笔记本来在您的项目中尝试这一点或跟随它。

博客中遵循的程序是从一个基本的基线模型开始，找出我们可以调整的超参数，以及它们对提高我们的架构效率的影响，最后是如何调整超参数，以获得最佳架构，从而实现架构的最佳可能结果。

本文讨论密集网络中的超参数调整，并奠定基础。第二部分进一步学习了这篇文章，并给出了如何训练 CNN 的技巧。请务必在完成这篇文章时也阅读下面的链接。

[## 建立神经网络结构的有效方法指南-第二部分:超参数…

介绍

medium.com](medium.com/@shashank.r…)

超参数是一个可配置的值，在学习过程开始前设置。这些超参数值决定了训练算法的行为以及它如何从数据中学习参数。

选择正确的指标

在我们开始之前，我们需要清楚地了解我们手头的问题，然后选择一个指标来衡量我们的模型和损失函数的性能，我们打算对其进行优化。我们的问题是一个一般的图像分类任务，我们选择精度作为度量，分类交叉熵作为我们的损失函数

稀疏分类交叉熵和分类交叉熵之间的区别在于，当输出不是一次性编码(1，2，3 等)时，使用稀疏分类交叉熵。)和分类交叉熵(当输出是一位热编码时([1，0，0]或[0，1，0])。稀疏分类交叉熵和分类交叉熵可以被认为是对数损失的多类变体。

Distribution of data-points among all classes

从图中可以推断出，数据集是平衡的，因为我们在每个类中都有几乎相同数量的数据点。这种检查对于选择准确性作为度量是必要的。其他选择可以是 F1-score。选择 Log-loss 是因为最小化它不仅有助于最小化不正确的分类，而且确保我们以高概率预测正确的类别。

预处理数据

我们从 keras.datasets 加载数据

from keras.datasets import fashion_mnist
(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()

我们只提供了一个训练和测试集，因为我们还需要一个验证集。我们使用 scikit-learn 的训练-测试拆分将获得的训练数据拆分为 80%训练和 20%验证

from sklearn.model_selection import train_test_split
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=12345)

训练集是模型学习/训练的数据点集，验证集用于比较模型和测试集，以查看我们的模型对未知输入(我们没有训练过的输入)的概括程度

由于我们将首先使用密集的神经网络，因此在将数据输入网络之前，我们需要对数据进行一些预处理。这包括:-

-将列车验证和测试数据的形状从 28x28 格式更改为 784 个值的列表 -标准化我们的输入，使输入值的范围从 0 到 1，而不是从 0 到 255，标准化也可以完成

标准化/规范化输入可以使训练更快，并减少陷入局部最优的机会，因此强烈建议在将数据输入网络进行训练之前进行

X_train = X_train.reshape(48000, 784)
X_val = X_val.reshape(12000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype(‘float32’)
X_val = X_val.astype(‘float32’)
X_test = X_test.astype(‘float32’)
X_train /= 255
X_val /= 255
X_test/= 255

此外，由于我们已经使用了分类交叉熵，我们需要将我们的输出转换为独热编码形式，这可以很容易地做到如下

# np is numpy
nb_classes = 10 
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_val = np_utils.to_categorical(y_val, nb_classes)
Y_test= np_utils.to_categorical(y_test, nb_classes) 

基础模型

首先从一个基本模型开始，然后在每一步中不断尝试改进它，这是一个很好的做法。我们的基线模型将是一个 softmax 分类器，它将像素值列表作为输入，并将输出 class-label

model = Sequential([
 Dense(10,input_shape=(784,),activation=’softmax’)
])
model.compile(optimizer=keras.optimizers.SGD(lr=0.1),
 loss=’categorical_crossentropy’,
 metrics=[‘accuracy’])

对于上述模型，损失和精度值如下所示

Train loss: 0.4080537739445766
Train accuracy: 0.8587291666666667
-------------------------------
Validation loss: 0.4190353289047877
Validation accuracy: 0.8551666666666666
-------------------------------
Test loss: 0.4566255069732666
Test accuracy: 0.8375

为了进一步改进模型，我们需要知道在我们的密集网络中哪些是我们可以调整的超参数，接下来的部分将向您简要介绍超参数以及它们如何影响学习，但在此之前，让我们了解为什么我们需要超参数调整。

需要超参数调整

1. 在偏差和方差之间找到正确的平衡:-在使用密集神经网络训练我们的数据时，很容易实现非常高的精度，但是这些可能不能很好地推广到我们的验证和测试集。此外，如果我们尝试并抑制自己使用深度/复杂的架构，则我们的数据集总是有可能具有低精度，因此我们需要找到推广良好且具有高精度的最佳点。每个超参数都会影响偏差方差。
2. 为了防止我们自己陷入消失/爆炸梯度问题:-反向传播步骤可能涉及许多梯度值的相乘，并且如果梯度值很小(<1) we may suffer from the vanishing gradient problem and if they are large(> 1)，我们可能遭受爆炸梯度问题。我们可以通过在学习率、激活函数和层数的超参数调整时进行必要的调整来避免这一点
3. 遇到鞍点和局部最优:-一些模型可能会陷入梯度接近零的鞍点和局部最小值，因此我们需要调整学习率等超参数，并将优化器更改为 Adam 或 RMSProp，以避免陷入困境并停止进一步学习。

Optimizers on encountering saddle points

4.没有收敛:-众所周知，较大的学习速率可以防止收敛到最小值，如下所示，但同时，如果学习速率太慢，我们可能无法收敛到最小值，因为我们向它迈出了非常小的步伐。为了克服这个问题，我们可以选择 Adam 这样的自适应学习率优化器，或者在优化器中使用 decay。

Effect of learning rate

5.Sigmoid 和 tanh 激活函数问题:-sigmoid 和 tanh 函数在其末端是弯曲的，导致这些点处的梯度非常低，因为即使当应用 sigmoid 激活之前的值显著增加时，应用之后的值也不会增加，因此即使梯度也不会增加很多，从而影响学习。但是 Sigmoid 和 tanh 可能是浅层网络(最多 2 层)的好选择。

6.为了加速学习:-通过获得正确的超参数集，与更复杂且需要更多时间训练的模型相比，我们可以获得更好的结果。

7.所有超参数的无数组合:-超参数的数量和它们可以取的值在深度学习中相当高，因为它们在计算可能的组合时共存，我们可以很容易地达到一个非常大而令人生畏的数字。因此，本文将尝试使用我在训练深度神经架构方面的经验，向您提供一些应对这一问题的提示和技巧。

8.事半功倍:-更多元件和复杂架构并不总是降低损耗、提高精度的最佳选择，相反，要确保充分利用现有架构，并在需要时慢慢增加复杂度和元件。

超参数:密集网络

1. 层数:-必须明智地选择层数，因为很高的层数可能会引入过拟合、消失和爆炸梯度问题等问题，而较低的层数可能会导致模型具有高偏差和低潜力模型。在很大程度上取决于用于训练的数据量
2. 每层隐藏单元的数量:-这些也必须合理选择，以便在高偏差和方差之间找到一个最佳点。再次取决于用于训练的数据大小
3. 激活函数:-这方面的流行选择是 ReLU、Sigmoid & Tanh(仅适用于浅层网络)和 LeakyReLU。一般来说，选择 ReLU/LeakyReLU 做得同样好。Sigmoid/Tanh 可能适用于浅层网络。同一性在回归问题中有帮助。
4. 优化器:-它是模型使用的算法，用于在每次迭代后更新每一层的权重。比较受欢迎的选择是 SGD，RMSProp 和 Adam。SGD 适用于浅层网络，但无法避开鞍点和局部最小值。在这种情况下，RMSProp 可能是更好的选择，AdaDelta/AdaGrad 适用于稀疏数据，而 Adam 是最受欢迎的方法，可用于实现更快的收敛。进一步参考https://towardsdatascience . com/types-of-optimization-algorithms-used-in-neural-networks-and-ways-to-optimization-gradient-95 ae5d 39529 f
5. 学习率:-它负责核心学习特性，并且必须以这样的方式选择，即它不能太高而不能收敛到最小值，也不能太低而不能加速学习过程。建议以 10 的幂尝试，具体为 0.001，0.01，0.1，1。学习率的值在很大程度上取决于所使用的优化器。对于 SGD - 0.1 通常工作良好，而对于 Adam - 0.001/0.01，但建议总是尝试上述范围内的所有值。你也可以使用衰减参数，以减少你的学习与迭代次数，以达到收敛。一般来说，使用 Adam 这样的自适应学习率算法比使用衰减学习率要好。
6. 初始化:-没有发挥很大的作用，因为默认值工作得很好，但仍然首选使用 He-normal/uniform 初始化，同时为 Sigmoid 使用 ReLUs 和 Glorot-normal/uniform(默认为 Glorot-uniform)以获得更好的结果。必须避免使用零或任何恒定值(所有单位相同)的重量初始化
7. 批量大小:-它表示在更新权重矩阵之前向网络显示的模式数量。如果批量较小，模式的重复性会降低，因此权重会到处都是，收敛会变得困难。如果批量很大，学习将变得很慢，因为只有在多次迭代之后批量才会改变。建议根据数据大小以 2 的幂尝试批量大小(以便更好地优化内存)。
8. 时期数:-时期数是整个训练数据显示给模型的次数。它在模型与训练数据的拟合程度上起着重要的作用。大量的历元可能会过度拟合数据，并可能在测试和验证集上产生泛化问题，还可能导致消失和爆发梯度问题。较少的历元数可能会限制模型的潜力。根据您拥有的时间和计算资源尝试不同的值。
9. 漏失:-漏失层的保持概率可以被认为是超参数，其可以作为正则化器来帮助我们找到最佳偏差变化点。这是通过在每次迭代中移除某些连接来实现的，因此隐藏的单元不会太依赖于任何特定的特征。它可以取 0-1 之间的任何值，完全取决于模型过度拟合的程度。
10. L1/L2 正则化:-充当另一个正则化器，其中非常高的权重值被抑制，使得模型不依赖于单个特征。这通常会以增加偏差(即降低精度)为代价来降低方差。当模型继续过度拟合时，甚至在大幅增加压差值后也应使用

简介 Hyperas

现在，我们已经了解了超参数调整的必要性，并了解了在调整我们的密集网络时要考虑的超参数，我们现在继续讨论如何进行调整。

我们有两种选择，一种是 scikit-learn GridSearchCV 方法，可以通过 Keras 中的 scikit-learn API 包装器来使用，这种方法不利用 GPU 加速，因此即使在并行化后也无法实现很高的速度，我们将在这里讨论的另一种方法是 Hyperas，它使我们能够利用 GPU 加速，使您训练模型的速度至少提高 10 倍，也是一种接近超参数调整的简单方法。如果你没有 GPU，选择任何一个选项都会给你几乎相同的速度。

这里使用的 Hyperas 模块是指位于github.com/maxpumperla…的模块。要使用 Hyperas，您首先需要使用 pip 安装包

pip install hyperas

然后，在您的项目中，您将需要添加以下导入语句

from hyperopt import Trials, STATUS_OK, tpe
from hyperas import optim
from hyperas.distributions import choice, uniform

如果遇到任何错误，请参考位于github.com/maxpumperla…的常见问题部分

使用 Hyperas:密集网络

一旦你完成了上面的工作，要进行超参数优化，你需要 3 个代码片段

1. 数据功能

您需要创建一个从源直接加载训练和验证数据的函数，或者如果您已经进行了任何预处理，建议将预处理后的数据存储在 pickle/numpy/hdf5/csv 文件中，并在数据函数中编写代码以从该文件中访问数据。

以这种方式加载数据是必要的，因为 Hyperas 将数据加载函数缓存到 pycache 上，该 py cache 与您的项目位于同一文件夹中，并且它不能访问您在程序中使用的全局变量，因此有了上面的解决方法。

在我的例子中，我直接从数据源加载数据，并重复所有的预处理步骤，如下所示。我还可以在预处理后将训练和验证数据存储到一个 hdf5 文件中，并在数据函数中从那里检索它，无论如何它都会工作，除非我不希望在我的程序中访问任何全局变量的值。

该函数返回 X_train、Y_train、X_val、Y_val，它们是保存训练数据及其对应的类标签以及验证数据及其对应的类标签的变量

def data():
    (X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()
    X_train, X_val, y_train, y_val = train_test_split(X_train,    y_train, test_size=0.2, random_state=12345)
    X_train = X_train.reshape(48000, 784)
    X_val = X_val.reshape(12000, 784)
    X_train = X_train.astype('float32')
    X_val = X_val.astype('float32')
    X_train /= 255
    X_val /= 255
    nb_classes = 10
    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_val = np_utils.to_categorical(y_val, nb_classes)
    return X_train, Y_train, X_val, Y_val

调试提示:-如果您遇到任何与数据函数相关的错误，请尝试在函数的开头再次添加函数或数据函数中使用的包的导入语句

2.模型函数

这是我们定义我们的架构价值的一般框架和我们想要调整的超参数的地方。模型函数包含我们的模型的 Keras 体系结构，用{ { choice([])} }或{ { uniform(，)} }代替我们希望调整的超参数值。用于优化时尚 MNIST 架构的模型函数示例如下所示

def model(X_train, Y_train, X_val, Y_val):

    model = Sequential()
    model.add(Dense({{choice([128, 256, 512, 1024])}}, input_shape=(784,)))
    model.add(Activation({{choice(['relu', 'sigmoid'])}}))
    model.add(Dropout({{uniform(0, 1)}}))
    model.add(Dense({{choice([128, 256, 512, 1024])}}))
    model.add(Activation({{choice(['relu', 'sigmoid'])}}))
    model.add(Dropout({{uniform(0, 1)}}))

    if conditional({{choice(['two', 'three'])}}) == 'three':
        model.add(Dense({{choice([128, 256, 512, 1024])}}))
        model.add(Activation({{choice(['relu', 'sigmoid'])}}))
        model.add(Dropout({{uniform(0, 1)}}))
            model.add(Dense(10))
    model.add(Activation('softmax')) adam = keras.optimizers.Adam(lr={{choice([10**-3, 10**-2, 10**-1])}})
    rmsprop = keras.optimizers.RMSprop(lr={{choice([10**-3, 10**-2, 10**-1])}})
    sgd = keras.optimizers.SGD(lr={{choice([10**-3, 10**-2, 10**-1])}})

    choiceval = {{choice(['adam', 'sgd', 'rmsprop'])}}
    if choiceval == 'adam':
        optim = adam
    elif choiceval == 'rmsprop':
        optim = rmsprop
    else:
        optim = sgd

    model.compile(loss='categorical_crossentropy', metrics=['accuracy'],optimizer=optim) model.fit(X_train, Y_train,
              batch_size={{choice([128,256,512])}},
              nb_epoch=20,
              verbose=2,
              validation_data=(X_val, Y_val))
    score, acc = model.evaluate(X_val, Y_val, verbose=0)
    print('Test accuracy:', acc)
    return {'loss': -acc, 'status': STATUS_OK, 'model': model}

以上说明了我们如何制作一个我们希望我们的模型是什么样子的一般框架，以及我们希望调整的超参数是什么。

model . add(Dense({ { choice([128，256，512，1024])} })-此行用于传达我们希望调整层中隐藏单元的数量，并在 128、256、512 和 1024 中找到最佳匹配。

model . add(Activation({ { choice([' relu '，' sigmoid ')} })-该行用于传达我们希望调整激活函数参数并在 ReLU 和 Sigmoid 之间找到最佳匹配的事实

model . add(Dropout({ { uniform(0，1)} })-这一行用于传达这样一个事实，即我们希望调整保持丢失概率的值，并在 0 和 1 之间的实数范围内找到最佳匹配。

“选择”中包含的值是我们希望用来调整超参数的值,“统一”中包含的范围是我们期望超参数的最佳值所在的实数范围

Hyperas 模块运行许多不同的模型，每次从每个值池中取一个值，通过我们希望调整的所有超参数值的“选择”和“统一”给出。最后，它给出了在验证集上运行时获得最低损失值的值的组合。可以认为是在做类似于 sklearn 中的 RandomSearchCV 的事情。

if conditional({{choice(['two', 'three'])}}) == 'three':
        model.add(Dense({{choice([128, 256, 512, 1024])}}))
        model.add(Activation({{choice(['relu', 'sigmoid'])}}))
        model.add(Dropout({{uniform(0, 1)}}))

上面的代码片段用于调整层数，以了解两层或三层密集网络架构是否是一个好的选择。这里，在迭代期间，从{{choice(['two '，' three'])}}中选择一个值。

if conditional({{choice(['two', 'three'])}}) == 'three':

如果值为“2 ”,则不满足 If 条件中的条件，因此不执行 if 块中的代码，只给我们留下两层架构，或者如果选择的值为“3 ”,则条件满足，并且执行 if 块，给我们一个三层架构来测试当前迭代。

 adam = keras.optimizers.Adam(lr={{choice([10**-3, 10**-2,  10**-1])}})
    rmsprop = keras.optimizers.RMSprop(lr={{choice([10**-3, 10**-2, 10**-1])}})
    sgd = keras.optimizers.SGD(lr={{choice([10**-3, 10**-2, 10**-1])}})

    choiceval = {{choice(['adam', 'sgd', 'rmsprop'])}}
    if choiceval == 'adam':
        optim = adam
    elif choiceval == 'rmsprop':
        optim = rmsprop
    else:
        optim = sgd

上面的代码片段用于调优优化器和学习率。在迭代上述部分时，从每个优化器的学习率的值池中选择一个值，随后从 {{choice(['adam '，' sgd '，' rmsprop'])}} 中选择一个值。如果选择的值是“adam”，则对于当前迭代，Adam 优化器连同从**Adam = keras . optimizer . Adam(lr = { { choice([10 * -3，10*-2，10 * *-1])})**中的值池中选择的学习率被用作模型的优化器，这是下面的 If 块中传达的内容

 if choiceval == 'adam':
        optim = adam
    elif choiceval == 'rmsprop':
        optim = rmsprop
    else:
        optim = sgd

3.执行

X_train, Y_train, X_val, Y_val = data()best_run, best_model = optim.minimize(model=model,
                                      data=data,
                                      algo=tpe.suggest,
                                      max_evals=30,
                                      trials=Trials(),
                                      notebook_name='Fashion_MNIST')

该代码片段将使用数据函数中给出的训练和验证数据，开始对模型函数中给出的框架进行超参数优化。

optim . minimize 函数中的所有值必须保持相同，除了 notebook_name 参数、和 max_evals 参数之外，Notebook _ name 参数用于输入您的 IPython 笔记本的名称，而max _ evals 参数用于输入在为您的架构选择正确的超参数集之前您希望训练的模型的最大数量。该值取决于您拥有的资源和时间，一般来说，30-50 之间的值就足够了。

上述代码片段必须在数据和模型函数之后编写，并将开始执行 Hyperas 模块，该模块将返回 best_model 变量中的最佳模型配置和 best_run 中的最佳超参数集。

可以使用print(best _ model . evaluate(X _ test，Y_test)) 使用测试集中的最佳模型进行预测或者 print(best_run) 了解最佳模型中有哪些参数选择。在执行***print(best _ run)***时，您将得到如下所示的输出

{'Activation': 0, 'Activation_1': 0, 'Activation_2': 0, 'Dense': 3, 'Dense_1': 3, 'Dense_2': 1, 'Dropout': 0.6346993188487943, 'Dropout_1': 0.3471522714859784, 'Dropout_2': 0.42208889978571484, 'batch_size': 1, 'choiceval': 0, 'conditional': 1, 'lr': 0, 'lr_1': 1, 'lr_2': 1}

为了解释上述内容，您需要查看包含运行代码的执行部分时的输出的部分，如下所示。

Output of the execution section and print(best run)

model = Sequential()
model.add(Dense(space['Dense'], input_shape=(784,)))
model.add(Activation(space['Activation']))
model.add(Dropout(space['Dropout']))
model.add(Dense(space['Dense_1']))
model.add(Activation(space['Activation_1']))
model.add(Dropout(space['Dropout_1']))

if conditional(space['conditional']) == 'three':
    model.add(Dense(space['Dense_2']))
    model.add(Activation(space['Activation_2']))
    model.add(Dropout(space['Dropout_2']))model.add(Dense(10))
model.add(Activation('softmax'))
adam = keras.optimizers.Adam(lr=space['lr'])
rmsprop = keras.optimizers.RMSprop(lr=space['lr_1'])
sgd = keras.optimizers.SGD(lr=space['lr_2'])
choiceval = space['choiceval']
if choiceval == 'adam':
     optim = adam
elif choiceval == 'rmsprop':
     optim = rmsprop
else:
     optim = sgd
model.compile(loss='categorical_crossentropy', metrics=['accuracy'],
                 optimizer=optim)
model.fit(X_train, Y_train,batch_size=space['batch_size'], nb_epoch=20, verbose=2, validation_data=(X_val, Y_val))

如图所示，输出包含模型框架，每个空间/值池的名称作为模型函数中的输入给出。要了解所选的确切值，我们可以参考我们在模型函数中任何空间变量位置处提供的空间/值池。

'密集':3 表示对于第一层中隐藏单元的数量，最佳模型使用列表中索引 3 处的值 1024。请注意:-使用的索引值从 0 开始。

' Activation_1':0 表示对于第二层，最佳模型具有 ReLU 作为它的激活函数。

' conditional': 1 表示最佳模型由 3 层组成。

' choiceval':0 表示最佳模型使用 Adam 作为优化器，学习率为 0.001(由 lr:0 给出)。

Dropout_2':0.42…表示隐藏单元的第三层使用 0.42 的 keep-prob 后的丢弃层。

如上所示解码所有参数值后的最佳模型的最终模型配置为

model = Sequential([
    Dense(1024, input_shape=(784,), activation='relu'),
    Dropout(0.63),
    Dense(1024, activation='relu'),
    Dropout(0.35),
    Dense(256, activation='relu'),
    Dropout(0.42),
    Dense(10, activation='softmax')
])

运行 40 个时期的该模型给出以下结果

Train loss: 0.23121074857314428
Train accuracy: 0.9159583333333333
-------------------------------
Validation loss: 0.28158413629730544
Validation accuracy: 0.9024166666666666
-------------------------------
Test loss: 0.3213586136817932
Test accuracy: 0.8871

我们已经实现了 88%的测试准确度，而之前在基线模型中为 83%。这是一个好的开始，但我们将在下一部分使用卷积神经网络继续这一探索。

提示和技巧

1.不要用测试数据代替验证集。始终将手头的数据集分为 3 组:训练、验证和测试。使用 train 来学习数据中的各种模式，使用 validation 来学习超参数的值，并测试模型是否概括良好。

2.确保您在优化时仅针对最重要的超参数进行训练，即，始终尝试减少超参数的数量及其值，我们使用文章中所述的经验法则进行调整。这是因为超参数和它们的值越多，需要训练的模型的数量就越多，以便在优化时实现公正。

例如，在上述情况下，在激活函数的值中，我们没有使用 LeakyReLU，这是因为 LeakyReLU 的性能总是等于或略好于 ReLU。类似地，我没有优化初始化超参数，因为我们知道，如果是重新激活，我们需要使用 He-normal 和 glrot-normal if Sigmoid 作为经验法则。时段数尚未优化，因为我们不希望我们的模型通过设置较大的时段数值来花费很长时间来查找超参数。我们还希望模型能够快速学习，因此时段数设置为 20。在模型选择之后，我们可以运行模型更多的时期。

正如您可能已经观察到的，我们只优化那些对学习有很大影响的组合，如层数、隐藏单元、学习速率等。

3.调试提示:-当您必须在上次执行后更改模型函数时，建议总是删除 pycache 文件夹，因为即使您更改了模型函数，模块也可能使用 pycache 中的旧版本进行优化。如果您仍然面临更新模型函数的问题，请在删除 pycache 后重启您的内核。

pycache 文件夹位于项目运行所在的笔记本所在的文件夹中。

希望这篇文章能帮助你为你的密集网络找到合适的架构，并且你能做出更多的超参数优化模型而不是直觉模型。感谢您的阅读！

参考文献

1. https://towards data science . com/what-is-hyperparameters-and-how-to-tune-the-hyperparameters-in-a-deep-neural-network-d 0604917584 a
2. 【github.com/maxpumperla…
3. https://medium . com/machine-learning-world/neural-networks-for-algorithm-trading-hyperparameters-optimization-CB 2 B4 a 29 b 8 ee
4. https://medium . com/@ jrod thoughts/knowledge-tuning-hyperparameters-in-machine-learning-algorithms-part-I-67a 31 B1 f 7 c 88
5. www.appliedaicourse.com/

建立神经网络体系结构的有效方法指南——第二部分:用 Hyperas 对卷积神经网络进行超参数选择和调整——时尚 MNIST

原文：towardsdatascience.com/a-guide-to-…

介绍

本文是下面链接的文章的延续，该文章涉及超参数优化的需要以及如何使用 Hyperas 对密集神经网络(多层感知器)进行超参数选择和优化

[## 建立神经网络结构的有效方法指南-第一部分:超参数…

介绍

medium.com](medium.com/@shashank.r…)

在当前的文章中，我们将从第一部分停止的地方继续，并尝试解决相同的问题，即使用卷积神经网络(CNN)的时尚 MNIST 数据集的图像分类任务。

为什么是 CNN？

CNN 有几个不同的滤波器/内核，由可训练的参数组成，这些参数可以在给定的图像上进行空间卷积，以检测像边缘和形状这样的特征。这些高数量的滤波器本质上学习通过反向传播基于所学习的权重从图像中捕捉空间特征，并且滤波器的堆叠层可用于从每个后续级别的空间特征中检测复杂的空间形状。因此，他们可以成功地将一个给定的图像浓缩成一个高度抽象的、易于预测的表示。

在密集网络中，我们试图在作为输入给出的像素值中找到模式，例如，如果像素号 25 和 26 大于某个值，则它可能属于某个类以及该类的一些复杂变体。如果我们在图像中的任何地方都可以有对象，而不一定像在 MNIST 或在某种程度上在时尚 MNIST 数据中那样居中，这可能很容易失败。

另一方面，rnn 在数据中寻找序列，并且边缘或形状也可以被认为是像素值的序列，但是问题在于它们只有一个单一的权重矩阵，该矩阵被所有的循环单元使用，这无助于寻找许多空间特征和形状。而 CNN 可以在一层中具有多个内核/过滤器，使它们能够找到许多特征，并在此基础上形成每个后续层的形状。RNNs 将需要很多层和大量的时间来模拟，因为它们只能在一层找到很少的序列。

因此，让我们继续研究卷积网络，看看更深层次的超参数优化版本能有多好，但在此之前，让我们看看卷积神经网络中的额外超参数。

超级参数:CNN

这里我们将讨论 CNN 中的附加参数，请参考第一部分(开头的链接)了解密集层中的超参数，因为它们也是 CNN 架构的一部分。

1. 内核/过滤器大小:过滤器是一个权重矩阵，我们用它对输入进行卷积。卷积上的过滤器可用于测量输入面片与要素的相似程度。特征可以是垂直边缘或拱形，或者任何形状。滤波器矩阵中的权重是在训练数据时导出的。较小的过滤器收集尽可能多的局部信息，较大的过滤器代表更多的全局、高级和代表性信息。如果你认为大量的像素对于网络识别物体是必要的，你将使用大的过滤器(如 11x11 或 9x9)。如果你认为区分物体的是一些小的和局部的特征，你应该使用小的过滤器(3x3 或 5x5)。注意，通常我们使用奇数尺寸的过滤器。
2. 填充:填充通常用于添加零的列和行，以在卷积后保持空间大小不变，这样做可能会提高性能，因为它保留了边界处的信息。Keras 中填充函数的参数为 Same -通过左右均匀填充，输出大小与输入大小相同，但如果要添加的列数为奇数，它会将额外的列添加到右侧。 有效 -输出大小缩小到 **ceil((n+f-1)/s)，其中“n”是输入尺寸，“f”是滤波器大小，“s”是步长。ceil 将小数四舍五入为最接近的整数，**不进行填充。
3. 跨距:通常是在输入权重与过滤器中的权重按元素相乘后，卷积期间水平和垂直遍历输入时希望跳过的像素数。它用于显著减小输入图像尺寸，因为卷积运算后尺寸缩小到 ceil((n+f-1)/s)，其中“n”是输入尺寸，“f”是滤波器尺寸，“s”是步长。ceil 将小数四舍五入为最接近的整数。
4. 通道数:它等于输入的颜色通道数，但在后面的阶段等于我们用于卷积运算的滤波器数。通道数量越多，使用的过滤器数量越多，学习的特征就越多，过拟合的机会就越多，反之亦然。
5. 汇集层参数:汇集层也具有与卷积层相同的参数。最大池通常在所有池选项中使用。目标是对输入表示(图像、隐藏层输出矩阵等)进行下采样。)，通过保持子区域中的最大值(激活的特征)入库来减少其维数。

引入批量标准化:- 通常，在深度神经网络架构中，标准化输入在经过中间层的各种调整后变得过大或过小，同时到达较远的层，这导致影响学习的内部同变量偏移问题。为了解决这一问题，我们添加了批量标准化层，以标准化(均值居中和方差缩放)给予后面层的输入。这一层通常必须在通过包含激活功能的层之后、在脱落层(如果有)之前放置在架构中。sigmoid 激活函数是一个例外，其中您需要在激活前放置批处理规范化图层，以确保在应用函数前值位于 sigmoid 的线性区域内。

构建 CNN 架构的原则/惯例

构建卷积神经网络所遵循的基本原则是在网络的初始阶段保持特征空间的宽和浅，并在接近结束时使其变得更窄和更深

谨记上述原则，我们制定了一些在构建 CNN 架构时需要遵循的惯例来指导您

1.总是从使用更小的过滤器开始是为了收集尽可能多的局部信息，然后逐渐增加过滤器宽度以减少生成的特征空间宽度来表示更全局、更高级和更有代表性的信息

2.遵循该原则，通道的数量在开始时应该是低的，以便它检测低级别特征，这些低级别特征被组合以形成许多复杂的形状(通过增加通道的数量)，这有助于在类别之间进行区分。

增加过滤器的数量以增加特征空间的深度，从而帮助学习更多层次的全局抽象结构。使特征空间变得更深更窄的另一个用途是缩小输入到密集网络的特征空间。

按照惯例，当我们在卷积神经网络架构中逐层前进时，通道数量通常会增加或保持不变

3.对于中等或小尺寸图像的卷积层，使用的一般滤波器大小为 3×3、5×5 和 7×7，对于最大池参数，我们使用步长为 2 的 2×2 或 3×3 滤波器大小。较大的过滤器尺寸和跨度可用于将大图像缩小到中等尺寸，然后进一步遵循所述的惯例。

4.当您觉得图像的边界可能很重要或只是为了帮助延长您的网络架构时，请尝试使用 padding = same，因为即使在卷积操作之后，padding 也会保持尺寸不变，因此您可以执行更多的卷积而不会缩小尺寸。

5.不断添加层，直到你超适合。一旦我们在验证集中达到相当高的准确度，我们就可以使用正则化组件，如 l1/l2 正则化、剔除、批量规范、数据扩充等。为了减少过度拟合

5.始终使用经典网络，如 LeNet、AlexNet、VGG-16、VGG-19 等。作为构建模型架构的灵感。我所说的灵感是指遵循架构中使用的趋势，例如 conv-池-conv-池或 conv-conv-池-conv-conv-池层中的趋势，或通道数量 32–64–128 或 32–32–64–64 的趋势，或过滤器尺寸、最大池参数等的趋势。

构建 CNN 架构

由于上述惯例，CNN 的超参数调谐比密集网络的调谐稍微困难一些。这是因为 Hyperas 使用随机搜索来寻找可能的最佳模型，这反过来可能导致违反一些惯例，为了防止这种情况发生 我们需要设计 CNN 架构，然后在 Hyperas 中微调超参数，以获得我们的最佳模型。

在调谐密集网络时与 Hyperas 一起使用的方法，其中我们为所有超参数给出一个集合 a 值，并让模块决定哪一个是最佳的，对于调谐 CNN 不起作用。这是因为在每一层，由于卷积和最大池化等操作，输入维度减少，因此，如果我们给定步幅、滤波器大小等超参数的值范围。Hyperas 总是有可能选择一个以负维异常结束并在完成前停止的模块。

那么如何构建你问的架构呢？我们开始吧。但在此之前，我想回顾一下，在使用卷积或池层时，我们将输入图像的维数 N 降低到(N-f+1)/s，其中“f”是滤波器大小,“s”是步长，这在处理过程中对我们非常有帮助。

关于如何构建 CNN 架构的第一个示例如下所示，该示例从 LeNet-5 架构中获得灵感

第一步是制作一张包含建筑尺寸、激活形状和大小的表格，如下所示

更多参考请参考 AndrewNg 的视频-【www.youtube.com/watch?v=w2s… = 485s

这里，我们计算每个卷积或池化操作之后的激活形状为 (ceil(N+f-1)/s，ceil(N+f-1)/s，滤波器的数量)，其中填充值为“有效”并且维度为(N，N，滤波器的数量)，其中使用的填充为“相同”，这里“N”是输入维度，“f”是滤波器大小，“s”是步长。激活值通过将激活形状的维度中的所有值相乘来计算。

对于第二阶段，N=28，f=3，s=1，滤波器数量=8，填充有效，因此我们得到激活形状为(28，28，8)。激活值= 28x28x8=6272

对于第三阶段最大池层，我们得到 ceil((28–2+1)/2)= ceil(13.5)= 14，因此维度为(14，14，8)。最后一个维度在使用池层时不会改变。激活值= 14x14x8=1568

对于第四级，N=14，f=5，s=1，滤波器数量=8，填充有效，因此我们得到激活形状为((14–5+1)/2，(14–5+1)/2，16)= (10，10，16)

Flatten 使输入成为一维列表，以便输入到密集层，因此激活形状是(400，1)。激活值= 400x1=400

密集激活形状(64，1)表示在密集层中使用了 64 个隐藏单元。激活值= 64x1=64

这一计算告诉我们，在构建 CNN 架构时，我们是否选择了正确的参数，因为架构绝不能因过度使用高值的步长和滤波器尺寸而以负维度结束

确保您选择的值在激活值中有一个总体下降趋势，并且在激活值中没有任何非常突然的变化，这一点非常重要

接下来，我们将模型架构转换成 keras 代码。

cnn1 = Sequential([
    Conv2D(8, kernel_size=(3, 3), activation='relu',padding='same',input_shape=input_shape),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Conv2D(16, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Flatten(),
    Dense(120, activation='relu'),
    Dense(84, activation='relu'),
    Dense(10, activation='softmax')
])

转换成 keras 代码后，检查转换是否正确，尺寸是否符合您的要求，您可以使用。摘要“输出形状”列为您提供了输出尺寸

使用学习率为 0.001 的 Adam 优化器通常可以很好地处理 CNN，因此我们使用它来训练架构，以获得如下所示的精度值

Train loss: 0.18204240553701917
Train accuracy: 0.932125
-------------------------------
Validation loss: 0.24995902764300507
Validation accuracy: 0.9090833333333334
-------------------------------

我们对更多的 CNN 架构重复相同的过程

接下来，我们使用 Conv 池-Conv 池式架构，每一级的滤波器数量增加一倍。该架构如下所示

转换为 Keras

cnn1 = Sequential([
    Conv2D(32, kernel_size=(3, 3), activation='relu',input_shape=input_shape),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Conv2D(64, kernel_size=(3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Conv2D(128, kernel_size=(3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Flatten(),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

使用学习率为 0.001 的 Adam 优化器，我们训练该架构以获得如下所示的精度值

Train loss: 0.18507329044366877
Train accuracy: 0.9320625
-------------------------------
Validation loss: 0.287726696540912
Validation accuracy: 0.8989166666666667
-------------------------------

最后，我们还训练了一个类似 vgg 的模型，其趋势为 conv-conv-普尔-conv-conv-普尔

转换为 keras

cnn1 = Sequential([
    Conv2D(16, kernel_size=(3, 3), activation='relu',padding='same',input_shape=input_shape),
    Conv2D(16, kernel_size=(3, 3), activation='relu',padding='same'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Conv2D(32, kernel_size=(3, 3), activation='relu'),
    Conv2D(32, kernel_size=(3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(10, activation='softmax')
])

获取精度值

Train loss: 0.05137992699308476
Train accuracy: 0.9810625
-------------------------------
Validation loss: 0.30437974256711703
Validation accuracy: 0.923
-------------------------------

步骤 2-选择您希望进行超参数优化的架构

在所有模型中，找出具有最高验证集分数的模型，将其用作基础架构

在我们的模型中，vgg 类模型在验证集上具有最高的准确性值，因此我们选择如下所示的基础架构

cnn1 = Sequential([
    Conv2D(16, kernel_size=(3, 3), activation='relu',padding='same',input_shape=input_shape),
    Conv2D(16, kernel_size=(3, 3), activation='relu',padding='same'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Conv2D(32, kernel_size=(3, 3), activation='relu'),
    Conv2D(32, kernel_size=(3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(10, activation='softmax')
])

步骤 3-超参数优化

与验证集损失相比，模型中的训练损失非常低，这告诉我们模型过度拟合。因此，我们需要调整超参数，使我们获得低损耗，但不会过度适应这一点，我们将使用 Hyperas。

使用 Hyperas: CNN

我们现在使用 Hyperas 优化超参数，类似于我们在第一部分中所做的。更多详情请参考第一部分

为了优化，我们需要 3 个代码块

1. 数据功能

直接从源加载训练和验证数据的函数，或者如果进行了预处理，建议将预处理后的数据存储在 pickle/numpy/hdf5/csv 文件中，并在数据函数中编写代码以从该文件中访问数据。

def data():
    (X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()
    X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=12345)
    X_train = X_train.astype('float32')
    X_val = X_val.astype('float32')
    X_train /= 255
    X_val /= 255
    nb_classes = 10
    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_val = np_utils.to_categorical(y_val, nb_classes)
    return X_train, Y_train, X_val, Y_val

调试提示:-如果您遇到任何与数据函数相关的错误，请尝试重新运行代码块，或者在函数的开头再次添加函数或数据函数中使用的包的导入语句

2.模型函数

***def model(X_train, Y_train, X_val, Y_val):***

    model = Sequential()
    ***model_choice = {{choice(['one', 'two'])}}
    if model_choice == 'one':***
        model.add(Conv2D(16, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
        model.add(Conv2D(16, kernel_size=3, activation='relu',padding='same'))
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}})) model.add(Conv2D(32, kernel_size=3, activation='relu'))
        model.add(Conv2D(32, kernel_size=3, activation='relu'))
        model.add(BatchNormalization())
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))
    ***elif model_choice == 'two':***
        model.add(Conv2D(32, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
        model.add(Conv2D(32, kernel_size=3, activation='relu',padding='same'))
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}})) model.add(Conv2D(64, kernel_size=3, activation='relu'))
        model.add(Conv2D(64, kernel_size=3, activation='relu'))
        model.add(BatchNormalization())
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))

    model.add(Flatten())
    model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout({{uniform(0, 1)}}))
    choiceval = {{choice(['one', 'two'])}}
    if choiceval == 'two':
        model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
        model.add(BatchNormalization())
        model.add(Dropout({{uniform(0, 1)}}))

    model.add(Dense(10, activation='softmax'))

    adam = keras.optimizers.Adam(lr=0.001)

    model.compile(loss='categorical_crossentropy', metrics=['accuracy'],
                  optimizer=adam) model.fit(X_train, Y_train,
              batch_size=256,
              nb_epoch=15,
              verbose=2,
              validation_data=(X_val, Y_val))
    score, acc = model.evaluate(X_val, Y_val, verbose=0)
    print('Val accuracy:', acc)
    return {'loss': -acc, 'status': STATUS_OK, 'model': model}

**注意 Dropout 层的位置，它位于 Max-Pool 层之后。**以这种方式完成布局，支持在学习时消除对小特征集的高度依赖的丢失定义。如果放置在 Max-Pool 图层之前，则由 Dropout 移除的值可能不会影响 Max-Pool 图层的输出，因为它会从一组值中选取最大值，因此只有在移除最大值后，才能考虑移除要素依赖关系。如上所述的批量标准化层被放置在激活功能被应用之后。

在模型函数中，我们可以选择需要优化的超参数。在上面的代码块中，我们针对

1. 密集网络的隐藏单元数和层数(一层或两层)

 model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout({{uniform(0, 1)}}))
    ***choiceval = {{choice(['one', 'two'])}}
    if choiceval == 'two':***
        model.add(Dense({{choice([256, 512,1024])}}, activation='relu'))
        model.add(BatchNormalization())
        model.add(Dropout({{uniform(0, 1)}}))

“choiceval”的值决定了我们使用双层密集网络还是单层

2.辍学值

model.add(Dropout({{uniform(0, 1)}}))

3.架构中的通道数量

***if model_choice == 'one':***
        model.add(**Conv2D(16**, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
        model.add(**Conv2D(16**, kernel_size=3, activation='relu',padding='same'))
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))
        model.add(**Conv2D(32**, kernel_size=3, activation='relu'))
        model.add(**Conv2D(32**, kernel_size=3, activation='relu'))
        model.add(BatchNormalization())
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))

***elif model_choice == 'two':***
        model.add(**Conv2D(32**, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
        model.add(**Conv2D(32**, kernel_size=3, activation='relu',padding='same'))
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))
        model.add(**Conv2D(64**, kernel_size=3, activation='relu'))
        model.add(**Conv2D(64**, kernel_size=3, activation='relu'))
        model.add(BatchNormalization())
        model.add(MaxPooling2D(pool_size=2,strides=2))
        model.add(Dropout({{uniform(0, 1)}}))

‘model _ choice的值决定了我们选择初始层为 conv(16)-conv(16)-Pool-conv(32)-conv(32)-Pool 还是 conv(32)-conv(32)-Pool-Conv(64)-Conv(64)-Pool 的架构。(括号中的数字代表该层中过滤器的数量。)

3.执行和解释

我们使用上述数据和模型函数开始优化

X_train, Y_train, X_val, Y_val = data()best_run, best_model = optim.minimize(model=model,
                                      data=data,
                                      algo=tpe.suggest,
                                      max_evals=30,
                                      trials=Trials(),
                                      notebook_name='Fashion_MNIST')

在执行上面的代码片段时，我们在输出中得到下面的框架。我们用这个来匹配调整的超参数值。

model = Sequential()
model_choice = space[***'model_choice'***]
if model_choice == 'one'**:**
   model.add(Conv2D(16, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
   model.add(Conv2D(16, kernel_size=3, activation='relu',padding='same'))
   model.add(MaxPooling2D(pool_size=2,strides=2))
   model.add(Dropout(space[***'Dropout'***]))
   model.add(Conv2D(32, kernel_size=3, activation='relu'))
   model.add(Conv2D(32, kernel_size=3, activation='relu'))
   model.add(BatchNormalization())
   model.add(MaxPooling2D(pool_size=2,strides=2))
   model.add(Dropout(space[***'Dropout_1'***]))
elif model_choice == 'two'**:**
   model.add(Conv2D(32, kernel_size=3, activation='relu',padding='same', input_shape=(1,28,28), data_format='channels_first'))
   model.add(Conv2D(32, kernel_size=3, activation='relu',padding='same'))
   model.add(MaxPooling2D(pool_size=2,strides=2))
   model.add(Dropout(space[***'Dropout_2'***]))
   model.add(Conv2D(64, kernel_size=3, activation='relu'))
   model.add(Conv2D(64, kernel_size=3, activation='relu'))
   model.add(BatchNormalization())
   model.add(MaxPooling2D(pool_size=2,strides=2))
   model.add(Dropout(space[**'Dropout_3'**]))

 model.add(Flatten())
 model.add(Dense(space[***'Dense'***], activation='relu'))
 model.add(BatchNormalization())
 model.add(Dropout(space[***'Dropout_4'***]))
 choiceval = space[**'model_choice_1'**]
 if choiceval == 'two':
   model.add(Dense(space[***'Dense_1'***], activation='relu'))
   model.add(BatchNormalization())
   model.add(Dropout(space[***'Dropout_5'***]))
   model.add(Dense(10, activation='softmax'))
adam = keras.optimizers.Adam(lr=0.001)

现在我们需要从 print(best_run)输出中的参数索引中获取我们的值

{'Dense': 1, 'Dense_1': 2, 'Dropout': 0.2799579955710103, 'Dropout_1': 0.8593089514091055, 'Dropout_2': 0.17434082481320767, 'Dropout_3': 0.2839296185815494, 'Dropout_4': 0.7087321230411557, 'Dropout_5': 0.3273210014856124, 'model_choice': 1, 'model_choice_1': 0}

通过将价值与它们在框架中的位置相匹配来解释上述内容，我们得到了最佳的架构

cnn1 = Sequential([
    Conv2D(32, kernel_size=(3, 3), activation='relu',padding='same',input_shape=input_shape),
    Conv2D(32, kernel_size=(3, 3), activation='relu',padding='same'),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Dropout(0.2),
    Conv2D(64, kernel_size=(3, 3), activation='relu'),
    Conv2D(64, kernel_size=(3, 3), activation='relu'),
    BatchNormalization(),
    MaxPooling2D(pool_size=(2, 2),strides=2),
    Dropout(0.3),
    Flatten(),
    Dense(256, activation='relu'),
    BatchNormalization(),
    Dropout(0.7),
    Dense(10, activation='softmax')
])

上述架构的精度和损耗值为

Train loss: 0.14321659112690638
Train accuracy: 0.9463333333333334
-------------------------------
Validation loss: 0.17808779059847196
Validation accuracy: 0.93525
-------------------------------
Test loss: 0.20868439328074456
Test accuracy: 0.9227

因此，我们最终在测试集上获得了 92.27%的准确率，这优于我们优化的密集网络架构，后者在测试集上获得了 88%的准确率。但最重要的是，我们的模型不是过拟合的，因此将很好地推广到看不见的点，不像其他架构可以实现更高的精度，但对训练集过拟合。

我们可以通过使用数据增强技术来进一步提高这种准确性，但我将把它留给您进行实验。

希望这篇文章对您有所帮助，并且您通过这篇文章学会了如何构建一个高效的 CNN 架构。

更多信息请查看 neptune.ai/blog/optuna… 的博客文章

感谢您的阅读！

Connect with the Raven team on Telegram

机器学习和数据科学决策树指南

原文：towardsdatascience.com/a-guide-to-…

想获得灵感？快来加入我的 超级行情快讯 。😎

决策树是一类非常强大的机器学习模型，能够在许多任务中实现高准确性，同时具有高度的可解释性。决策树在 ML 模型领域中的特殊之处在于它们清晰的信息表示。决策树通过训练学习到的“知识”被直接公式化为层次结构。这种结构以一种即使非专家也能容易理解的方式保存和显示知识。

现实生活中的决策树

你可能在自己的生活中使用过决策树来做决定。以关于你这个周末应该做什么活动的决定为例。这可能取决于你是否想和你的朋友出去或者独自度过周末；在这两种情况下，你的决定也取决于天气。如果天气晴朗，你的朋友有空，你可能想踢足球。如果最后下雨，你就去看电影。如果你的朋友根本不出现，那么无论天气如何，你都喜欢玩电子游戏！

这是一个现实生活中决策树的明显例子。我们已经建立了一个树来模拟一组顺序的、 层次的 决策，这些决策最终导致一些最终结果。请注意，我们还选择了相当“高层次”的决策，以保持树小。例如，如果我们为天气设置了许多可能的选项，比如 25 度晴天、25 度雨天、26 度晴天、26 度雨天、27 度晴天…等等，我们的树会很大！确切的温度真的不太相关，我们只是想知道在室外是否可以。

这个概念对于机器学习中的决策树也是一样的。我们希望构建一个包含一组分层决策的树，这些决策最终会给我们一个最终结果，即我们的分类或回归预测。将选择决策，使得树尽可能小，同时以高分类/回归准确度为目标。

机器学习中的决策树

决策树模型是使用 2 个步骤创建的:归纳和修剪。归纳是我们实际构建树的地方，即根据我们的数据设置所有的层次决策界限。由于训练决策树的性质，它们很容易过度拟合。修剪是从决策树中删除不必要的结构的过程，有效地降低了复杂性，以防止过度拟合，并使其更容易解释。

感应

从高层次来看，决策树归纳通过 4 个主要步骤来构建树:

1. 从训练数据集开始，它应该有一些特征变量和分类或回归输出。
2. 确定数据集中分割数据的“最佳特征”；稍后将详细介绍我们如何定义“最佳特性”
3. 将数据分割成包含此最佳特征的可能值的子集。这种分割基本上定义了树上的一个节点，即每个节点都是基于我们数据的某个特征的分割点。
4. 使用步骤 3 中创建的数据子集递归生成新的树节点。我们不断分裂，直到我们达到某一点，在这一点上，我们通过某种措施优化了最大精度，同时最小化了分裂/节点的数量。

第 1 步很简单，只需获取您的数据集！

对于步骤 2，通常使用贪婪算法来选择使用哪个特征和具体的分割，以最小化成本函数。如果我们想一想，在构建决策树时执行分裂相当于划分特征空间。我们将反复尝试不同的拆分点，然后最终选择成本最低的一个。当然，我们可以做一些聪明的事情，比如只在数据集中的值范围内进行拆分。这将使我们避免浪费计算来测试非常差的分割点。

对于回归树，我们可以使用简单的平方误差作为成本函数:

其中 Y 是我们的基本事实，Y-hat 是我们的预测值；我们对数据集中的所有样本求和，以获得总误差。对于分类，我们使用基尼指数函数:

其中 pk 是特定预测节点中类别 k 的训练实例的比例。一个节点应该理想情况下有一个零错误值，这意味着每次分割都 100%输出一个类。这正是我们想要的，因为这样我们就知道，一旦我们到达那个特定的决策节点，无论我们是在决策边界的一边还是另一边，我们的输出到底是什么。

在我们的数据集中每次分割一个类的概念被称为信息增益。看看下面的例子。

如果我们选择一个拆分，其中每个输出都有一个取决于输入数据的混合类，那么我们真的没有得到任何信息；我们不知道某个特定的节点(即特征)是否对我们的数据分类有任何影响！另一方面，如果我们的分割对于每个输出有很高的百分比，那么我们获得了信息，即在特定的特征变量上以特定的方式分割给了我们特定的输出！

现在我们当然可以继续分裂，分裂，分裂，直到我们的树有成千上万的分支…..但是这真的不是一个好主意！我们的决策树会很大，很慢，并且过度适应我们的训练数据集。因此，我们将设置一些预定义的停止标准来停止树的构建。

最常见的停止方法是对分配给每个叶节点的训练样本数量使用最小计数。如果计数小于某个最小值，则分割不被接受，并且该节点被作为最终叶节点。如果我们所有的叶子节点都变成最终节点，训练就停止了。较小的最小计数将为您提供更精细的分割和潜在的更多信息，但也容易使您的训练数据过度拟合。分钟数太大，你可能会过早停下来。因此，最小值通常是基于数据集设置的，取决于每个类中预期有多少个示例。

修剪

由于训练决策树的性质，它们很容易过度拟合。为每个节点的最小实例数设置正确的值是一项挑战。大多数时候，我们可能只是进行一个安全的打赌，并使最小值非常小，导致有许多分裂和一个非常大，复杂的树。关键是，这些分割中的许多将是多余的，对增加我们模型的准确性是不必要的。

树修剪是一种利用分裂冗余来移除的技术，即修剪我们树中不必要的分裂。从高层次来看，修剪将树的一部分从严格和僵化的决策边界压缩到更平滑和更一般化的边界，有效地降低了树的复杂性。决策树的复杂度被定义为树中分裂的数量。

一种简单而高效的剪枝方法是遍历树中的每个节点，并评估删除它对成本函数的影响。如果变化不大，那就修剪掉！

Scikit Learn 中的一个示例

用于分类和回归的决策树在 Scikit Learn 中非常容易使用，内置了一个类！我们将首先加载我们的数据集，并初始化我们的决策树进行分类。跑步训练是一个简单的小程序！

Scikit Learn 还允许我们使用 graphviz 库可视化我们的树。它附带了一些选项，将有助于可视化模型学习到的决策节点和分割，这对理解它是如何工作的非常有用！下面我们将根据特性名称给节点着色，并显示每个节点的类别和特性信息。

您也可以在 Scikit Learn 中为您的决策树模型设置几个参数。以下是一些更有趣的方法，可以尝试使用，并获得更好的结果:

• max_depth: 树的最大深度，在这里我们将停止分割节点。这类似于控制深度神经网络中的最大层数。较低会使你的模型更快，但不准确；更高可以给你准确性，但风险过度拟合，可能会很慢。
• min_samples_split: 分割一个节点所需的最小样本数。我们在上面讨论了决策树的这一方面，以及将其设置为更高的值将如何有助于减轻过度拟合。
• max_features: 寻找最佳分割时要考虑的特征数量。更高意味着潜在的更好的结果，代价是训练时间更长。
• **min _ infinity _ split:**树生长提前停止的阈值。如果节点的杂质高于阈值，则节点将分裂。这可用于权衡防止过度拟合(高值，小树)与高精度(低值，大树)。
• **预排序:**是否对数据进行预排序，以加快拟合中最佳分割的发现。如果我们事先对每个特征的数据进行分类，我们的训练算法将更容易找到好的值进行分割。

实际应用决策树的技巧

这里有一些决策树的优点和缺点，可以帮助您决定它是否是您的问题的正确模型，以及如何有效应用它们的一些提示:

赞成的意见

• **容易理解和解释的。**在每一个节点上，我们都能够看到确切地说我们的模型正在做出什么决定。在实践中，我们将能够充分了解我们的精度和误差来自哪里，模型适合什么类型的数据，以及输出如何受要素值的影响。Scikit learn 的可视化工具是可视化和理解决策树的绝佳选择。
• **需要很少的数据准备。**许多 ML 模型可能需要大量的数据预处理，例如标准化，并且可能需要复杂的正则化方案。另一方面，在调整了一些参数之后，决策树在开箱即用的情况下工作得相当好。
• 使用树进行推理的成本是用于训练树的数据点数量的对数。这是一个巨大的优势，因为这意味着拥有更多的数据并不一定会大大降低我们的推理速度。

缺点

• 由于决策树训练的性质，过度拟合在决策树中很常见。人们经常建议进行某种类型的降维，比如 PCA ，这样树就不必学习这么多特征的分裂
• 出于与过度拟合类似的原因，决策树也容易偏向于在数据集中占多数的类。做一些种类的类平衡总是一个好主意，比如类权重、采样或者专门的损失函数。

喜欢学习？

在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上与我联系！

熊猫和 Matplotlib 数据探索指南

原文：towardsdatascience.com/a-guide-to-…

Photo by Clint McKoy on Unsplash

在最近使用 Pandas 和 Matplotlib 为我正在写的这篇文章制作图表/分析之后。我决定将这本实用指南放在一起，希望它足以让您使用 Pandas 和 MPL 开始并运行自己的数据探索！

本文分为以下几个部分:

基本要求

• 从 CSV 读取数据
• 格式化、清理和过滤数据框
• 分组依据和合并

可视化您的数据

• 绘图功能基础
• Seaborn 小提琴和 lm-plots
• 配对图和热图

身材美学

• 多轴绘图
• 让你的图表看起来不那么科学

基本要求

读取 CSV/Matplotlib 和 Pandas 所需的导入

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
%matplotlib inlinecar_data = pd.read_csv('inbox/CarData-E-class-Tue Jul 03 2018.csv')

Inline 表示将图形显示为单元格输出， read_csv 返回一个数据帧，文件路径相对于您笔记本的文件路径。

格式化、清理和过滤数据帧

通常在处理大量特性时，使用 columns 属性和 head(nRows) 函数查看第一行或所有列的名称会更好。但是，如果我们对分类的值的类型感兴趣，例如模型线，我们可以使用方括号语法访问该列，并使用*。unique()* 检查选项。

print(car_data.columns)
car_data.head(2)

car_data['modelLine'].unique()

很明显，在“特殊设备”的不同变体下输入了同一型号系列的多个版本，因此我们将使用正则表达式将任何包含 se 的内容替换为特殊设备。同样，有些列带有 Nans(不是数字)，所以我们将只删除这些带有dropna(subset =[' model line '])的列。

car_data = car_data.dropna(subset=['modelLine'])
car_data['modelLine'] = car_data['modelLine'].replace(to_replace={'.*SE.*': 'Standard equipment'}, regex=True)

我们还可以通过将模型线的行与一些布尔问题进行比较来过滤掉不需要的值，如“未定义”,这将返回一个与 DataFrame 行具有相同维数的布尔数组，可以再次使用方括号语法进行过滤。

car_data = car_data[(car_data['modelLine'] != 'undefined')]car_data['modelLine'].unique()

This is looking much better!

请注意，pandas 从不改变任何现有数据，因此当我们执行任何改变/过滤时，我们必须手动覆盖我们的旧数据。虽然这看起来有些多余，但这是减少代码中不必要的副作用和错误的非常有效的方法。

接下来，我们还需要更改 firstRegistration 字段(通常应该将其视为 python 日期格式),但是为了方便在以后的文章中对数据执行回归，我们将把它视为数值字段。

考虑到该数据与汽车注册相关，年份确实是我们需要保留的重要组成部分。因此，将它视为数值字段意味着我们可以应用数值舍入、乘法/除法来创建如下所示的注册年份特征列。

car_data['firstRegistration'].head(5)car_data[‘firstRegistrationYear’] = round((car_data[‘firstRegistration’] / 10000),0)
car_data[‘firstRegistrationYear’] .head(5)

Looks like the output we were looking for.

使用分组和合并

分组依据可用于根据数据集中的特定要素构建行组，例如“模型线”分类列。然后，我们可以对各个组执行均值、最小值、最大值、标准差等操作，以帮助描述样本数据。

group_by_modelLine = car_data.groupby(by=['modelLine'])
car_data_avg = group_by_modelLine.mean()
car_data_count = group_by_modelLine.count()

Averages Data

Count Data: Note that this is simply a count of the records for each model Line

如您所见，已经为每条模型线计算了每个数字特征的平均值。Group by 非常通用，也接受 lambda 函数用于更复杂的行/组标记。

接下来，我们将组装一个仅包含相关特征的数据框架，以绘制可用性(或车辆数量)和每辆车平均设备的图表。这个数据框架可以通过传入一个键字典来创建，这些键表示来自现有数据的单列或系列的列和值。这在这里是可行的，因为两个数据框具有相同的行数。或者，我们可以通过索引(模型线)合并两个数据框，并适当地重命名重复列的后缀。

然后，我们将把这两个变量按设备和可用性分类绘制成一个水平条形图。

# Since all the columns in car_data_count are the same, we will use just the first column as the rest yield the same result. iloc allows us to take all the rows and the zeroth column.car_data_count_series = car_data_count.iloc[:,0]features_of_interest = pd.DataFrame({'equipment': car_data_avg['equipment'], 'availability': car_data_count_series})alternative_method = car_data_avg.merge(car_data_count, left_index=True, right_index=True, suffixes=['_avg','_count'])alternative_method[['equipment_avg', 'firstRegistration_count']].sort_values(by=['equipment_avg', 'firstRegistration_count'], ascending=True).plot(kind='barh')

可视化您的数据

熊猫情节功能

熊猫有一个内置的。plot()函数作为 DataFrame 类的一部分。它有几个关键参数:

种类—‘条形’，‘barh’，‘馅饼’，‘散点’，‘kde’等，可以在文档中找到。 颜色 —接受与每个数据系列/列顺序对应的十六进制码数组。 line style—‘实线’，‘虚线’，‘虚线’(仅适用于线图) xlim，ylim —指定将要绘制图形的元组(下限，上限) legend —显示或隐藏 legend 标签的布尔值 —对应于数据帧中列数的列表，此处可为 legend 提供描述性名称

这些很容易使用，我们将使用。plot()在文章的后面。

eaborn lmplots

Seaborn 构建在 matplotlib 之上，以提供更丰富的开箱即用环境。它包括一个简洁的 lmplot 绘图功能，用于快速探索多个变量。使用我们的汽车数据示例，我们希望了解汽车的装备套件和销售价格之间的关联。显然，我们也希望这些数据按模型线进行分段，以便进行同类比较。

import seaborn as sns

传入设备和价格的列标签(x 和 y 轴),后跟实际的数据帧源。使用 col 关键字为每条模型线生成一个单独的地块，并设置 col_wrap 2 以生成一个漂亮的网格。

filtered_class = car_data[car_data['modelLine'] != 'AVANTGARDE']sns.lmplot("equipment", "price", data=filtered_class, hue="gears", fit_reg=False, col='modelLine', col_wrap=2)

正如你所看到的，在图表上添加一个颜色来表示齿轮的数量是非常有意义的，因为这些类型的车往往没有更好的装备，但是更贵。如您所见，我们可以用 3 行代码对数据集进行重要的探索。

Seaborn 小提琴情节

这些图非常适合处理大型连续数据集，同样可以通过索引进行分割。使用我们的汽车数据集，我们可以更好地了解二手车的价格分布。由于车龄会显著影响价格，我们将把第一个登记年份作为 x 轴变量，价格作为 y 轴变量，然后我们可以设置色调来区分不同的车型变量。

from matplotlib.ticker import AutoMinorLocatorfig = plt.figure(figsize=(18,6))LOOKBACK_YEARS = 3
REGISTRATION_YEAR = 2017filtered_years = car_data[car_data['firstRegistrationYear'] > REGISTRATION_YEAR - LOOKBACK_YEARS]ax1 = sns.violinplot('firstRegistrationYear', "price", data=filtered_years, hue='modelLine')ax1.minorticks_on()
ax1.xaxis.set_minor_locator(AutoMinorLocator(2))
ax1.grid(which='minor', axis='x', linewidth=1)

请注意，violin plot 函数返回显示绘图的轴。这允许我们编辑轴的属性。在本例中，我们设置了次要刻度，并使用 AutoMinorLocator 在每个主要间隔之间放置 1 个次要刻度。然后，我用线宽 1 使小网格可见。这是一个巧妙的方法，在每个注册年度都加上一个框。

配对图和关联热图

在具有少量要素(10-15 个)的数据集中，Seaborn Pairplots 可以快速实现对变量之间任何关系的可视化检查。沿着左对角线的图形表示每个特征的分布，而在非对角线上的图形显示变量之间的关系。

sns.pairplot(car_data.loc[:,car_data.dtypes == 'float64'])

(This is only a section, I couldn’t fit all the variables in, but you get the concept.)

同样，我们可以利用 pandas Corr()找到矩阵中每个变量之间的相关性，并使用 Seaborn 的热图函数绘制，指定标签和热图颜色范围。

corr = car_data.loc[:,car_data.dtypes == 'float64'].corr()sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns, cmap=sns.diverging_palette(220, 10, as_cmap=True))

这两个工具结合起来对于快速识别模型的重要特征非常有用。例如，使用热图，我们可以从顶行看到，档位数量和首次注册与价格正相关，而与此同时，milage 可能与价格负相关。到目前为止，这是一个完美的分析工具，但在基础层面上很有用。

图形美学

多轴绘图

以下是我之前关于中国房地产泡沫的文章中的一些数据。我想显示所有城市的建设数据，然后在一个图中按城市层级提供后续细分。

让我们来分解如何创建这样一个数字:

首先，我们定义图形的大小，以提供足够的绘图空间。当用多轴绘图时，我们定义一个网格，轴可以放置在网格上。然后，我们使用 subplot2grid 函数返回位于所需位置(从左上角指定)的轴，该轴具有正确的行/列跨度。

fig = plt.figure(figsize = (15,12))
grid_size = (3,2)
hosts_to_fmt = []# Place A Title On The Figurefig.text(x=0.8, y=0.95, s='Sources: China National Bureau of Statistics',fontproperties=subtitle_font, horizontalalignment='left',color='#524939')# Overlay multiple plots onto the same axis, which spans 1 entire column of the figurelarge_left_ax = plt.subplot2grid(grid_size, (0,0), colspan=1, rowspan=3)

然后，我们可以通过指定绘图函数的 ax 属性，在这个轴上绘图。请注意，尽管绘制到特定的轴上，但使用 secondary_y 参数意味着将创建一个新的轴实例。这对于以后存储格式非常重要。

# Aggregating to series into single data frame for ease of plottingconstruction_statistics = pd.DataFrame({
    'Constructed Floorspace (sq.m, City Avg)':
     china_constructed_units_total,
    'Purchased Units (sq.m, City Avg)':     
     china_under_construction_units_total,
})construction_statistics.plot(ax=large_left_ax,
    legend=True, color=['b', 'r'], title='All Tiers')# Second graph overlayed on the secondary y axislarge_left_ax_secondary = china_years_to_construct_existing_pipeline.plot(
    ax=large_left_ax, label='Years of Backlog', linestyle='dotted',
    legend=True, secondary_y=True, color='g')# Adds the axis for formatting laterhosts_to_fmt.extend([large_left_ax, large_left_ax_secondary])

为了生成城市层级的细分数据，我们再次使用了 subplot2grid，但这一次改变了每个循环的指数，这样三个层级的图表一个在另一个之下。

# For each City Tier overlay a series of graphs on an axis on the right hand column
# Its row position determined by its indexfor index, tier in enumerate(draw_tiers[0:3]):
    tier_axis = plt.subplot2grid(grid_size, (index,1))

    china_constructed_units_tiered[tier].plot(ax=tier_axis,     
     title=tier, color='b', legend=False)

    ax1 = china_under_construction_units_tiered[tier].plot(
     ax=tier_axis,linestyle='dashed', label='Purchased Units 
     (sq.m,City Avg)', title=tier, legend=True, color='r')  

    ax2 =china_property_price_sqmetre_cities_tiered[tier].plot(
     ax=tier_axis, linestyle='dotted', label='Yuan / sq.m', 
     secondary_y=True, legend=True, color='black')

    ax2.set_ylim(0,30000)hosts_to_fmt.extend([ax1,ax2])

好了，现在我们已经生成了正确的布局和绘图数据:

让你的图表看起来不那么科学

在上图的例子中，我选择了类似 ft.com 的造型。首先，我们需要通过 Matplotlib 字体管理器导入字体，并为每个类别创建一个字体属性对象。

import matplotlib.font_manager as fm# Font Importsheading_font = fm.FontProperties(fname='/Users/hugo/Desktop/Playfair_Display/PlayfairDisplay-Regular.ttf', size=22)subtitle_font = fm.FontProperties(
fname='/Users/hugo/Library/Fonts/Roboto-Regular.ttf', size=12)# Color Themescolor_bg = '#FEF1E5'
lighter_highlight = '#FAE6E1'
darker_highlight = '#FBEADC'

接下来，我们将定义一个函数，它将:

• 设置图形背景(使用 set_facecolor)
• 使用指定的标题字体将标题应用于插图。
• 调用紧凑布局功能，更紧凑地利用绘图空间。

接下来，我们将遍历图中的每个轴，并调用一个函数来:

• 禁用除底部脊椎(轴边界)之外的所有脊椎
• 将轴的背景颜色设置得稍暗一些。
• 如果图例存在，禁用图例周围的白色框。
• 将每个轴的标题设置为使用副标题字体。

最后，我们只需要调用我们创建的格式化函数，并传入我们之前收集的图形和轴。

结论

感谢您阅读本教程，希望这有助于您开始使用 Pandas 和 Matplotlib。

一位 HCI 研究员对 AAAI 2018 大会的总结！

原文：towardsdatascience.com/a-hci-resea…

AAAI18 的演讲摘要，涵盖了计算机视觉、机器学习/深度学习(灾难性遗忘)、学习表示、知识图和应用人工智能等主题。

这篇帖子包含我在刚刚结束的人工智能大会( AAAI 2018，路易斯安那州新奥尔良)上参加的会议的笔记。演讲的选择是基于我对人机交互和应用人工智能的兴趣。这些包括人工智能的人类方面，视觉，机器学习/深度学习(灾难性遗忘)，学习表示，知识图和一般的应用人工智能。欢迎反馈，指正(错别字！)和讨论——请联系( @vykthur )) 。对于那些对 AAAI 有兴趣的人来说， David Abel 也写了一份 AAAI 2018 的详细摘要，涵盖了一些我没有参加的会议。 TLDR——我的一些笔记可能缺乏细节。

2 月 3 日星期六

教程—从网络语料库构建知识图—马扬克·凯杰里瓦尔、克雷格·克诺布洛克、佩德罗·策克利[ 幻灯片

本教程概述了使用从网站上搜集的数据创建知识图表的过程，由南加州大学信息科学研究所的研究人员演示。

动机

• 为什么是领域特定知识图(DSKG)？ 人类行为表明我们已经执行了特定领域搜索(DSS。例如，人们去亚马逊上的部分搜索商品，或者去 YouTube 上搜索视频，而不是执行一般的谷歌搜索。
• DSKGs 在回答特定领域的问题方面做得更好。
• DSS >关键字搜索；它编纂了许多文档中的领域知识。
• 人们对国防高级研究计划局赞助的项目越来越感兴趣

知识图构建

• 知识图是一组三元组( H ead， R elationship， T ail)。巴拉克·奥巴马出生在夏威夷。
• 从网站抓取的数据生成知识图可能会很复杂。解决这一问题的手动方法是不可扩展的，因此需要自动化这一过程的系统。从表格、图形、地块图像甚至 excel 文件中提取数据和实体可能会面临特定的挑战。
• 大多数自动化方法包括语法归纳方法，其中系统试图学习爬行数据中的底层结构。这些算法的例子包括 RoadRunner、Disjoint Regex 等。

知识图构建的示例工具。 本教程的最后一部分展示了作者在实验室开发的一些知识图生成工具——Karma 和 DIG 。他们还展示了一个有趣的用例，其中他们构建了一个知识图表来帮助追踪人口贩运。

我的想法:这个教程有助于理解抓取网站的流程。它比我预期的有更多的手动方面(提取的实体需要手动标记，结果可能非常嘈杂)。我还想了解更多关于问答的知识，这在这次演讲中并没有涉及太多。

2 月 4 日星期日

[总统演讲]人类感知人工智能系统的挑战[ 视频，幻灯片

该演讲由 AAAI 主席(Subbarao Kambhampati)主讲，提供了一些关于人类感知人工智能(HAAI)的观点——动机、研究挑战和开放问题。

动机

• 今天的艾对人类有一种奇怪的矛盾心理。
• 但是人工智能可以应用的许多领域都需要人类。智能辅导系统、社交机器人、助手(个人、医疗)以及人机团队。
• 我们应该追求人类感知的人工智能，因为它拓宽了人工智能的范围和前景。

研究挑战和问题

• 人机合作需要对人类建模:让机器人/人工智能代理维护与其交互的人类的精确模型是一个挑战。该模型的准确性对于创建对机器人和人类都优化的计划是必要的。对人-人团队的研究可以为这个问题的解决方案提供信息。
• 机器人/人工智能代理可以通过牺牲它们的最佳模型来满足人类或者提供/请求有助于解决差异的信息(可解释性)来从这些不准确性中恢复。[更多参考见幻灯片。来自代理的可解释性是产生信任的必要条件。
• 伦理挑战——如果/当人工智能代理能够正确地模拟人类，它可能会给他们“说谎”的能力。

我的想法:我发现这个演讲很有趣，因为它有助于提供人工智能规划领域正在进行的工作的概述，以改善人与机器人的互动——努力模拟人类，制定可解释的计划和权衡的观点。

【技术谈】多连体嵌入学习的极低分辨率活动识别**。【** 论文】

Example videos of the HMDB and DogCentric datasets. The upper rows show the original HR videos and the lower rows show the 16x12 extreme low resolution videos used in the paper experiments. The first two videos are from HMDB and the other two videos are from DogCentric. Source

这个演讲(由印第安纳大学的 Michael S. Ryo 主持)介绍了一种神经网络方法来识别低分辨率图像中的活动——低至 16 * 12 像素！！

动机

• 低分辨率处理帮助我们理解远处的活动(远场识别)。例如，视频片段中的背景中正在发生什么(人行走、挥手等)。
• 低分辨率识别提供了隐私(脸很小，变得无法识别)和节省电池的好处。

贡献

• 这项工作贡献了一个新的双流多连体卷积神经网络。在低分辨率 (LR)视频中，源自完全相同场景的两幅图像通常具有完全不同的像素值，这取决于它们的 LR 变换。
• 该方法学习将具有相同内容的 LR 视频映射到相同位置的共享嵌入空间，而不管它们的变换。
• 当在 LR 视频上进行活动识别时，这种映射被用于改进推断。

我的想法:这篇文章提供了一些关于处理低分辨率图像的有趣见解——常规 CNN 需要 200 * 200 的图像！！他们讨论了从多个 LR 到 HR 图像变换学习映射的技术，并利用该知识来提高推理的准确性。我发现这很有趣，因为像这样的方法可以通知在边缘执行人工智能的努力(允许我们使用更小的图像，提高推理速度和电池寿命)。报告的准确性不是很高(37.70%)，他们在运行 Tensorflow 的 Jetson TX2 上实现了 50fps。

【技术演讲】深度神经网络领域扩展的少遗忘学习[ 论文

Source

这篇论文提供了一种方法来处理神经网络中灾难性遗忘的扩展(他们称之为域扩展)。

动机。 域扩展问题，即创建一个在旧域和新域上都工作良好的网络的问题，即使是在仅使用来自新域的数据而不访问来自旧域的数据的监督方式下对其进行训练之后。他们指出了域名扩张面临的两大挑战。

• 首先，即使学习了新域数据而没有看到旧域的数据，旧域上的网络性能也不应降低。
• 第二，DNN 应该能够很好地工作，而不需要事先知道输入数据来自哪个域。

灾难性遗忘的方法

• 微调 Softmax :冻结下层并微调最终的 Softmax 分类器层。该方法将下层作为特征提取器，更新线性分类器以适应新的领域数据。换句话说，特征提取器在新旧领域之间共享，并且该方法似乎保留了旧的领域信息。
• 权重约束方法:在学习新数据时，使用 l2 正则化获得新旧网络之间相似的权重参数。
• 论文提出的模型:使用旧网络的训练权值作为新网络的初始权值，同时最小化两个损失函数。

**我的想法:**我希望了解更多关于灾难性遗忘的知识，这个演讲(以及相关参考资料)对于了解这个主题的研究状况非常有用。我注意到，这里的评估(以及大多数其他论文中的评估)通常使用小型数据集(例如 CIFAR 10)来评估他们的解决方案在新领域中经过培训后的表现。尚不清楚这是否能很好地适应更大的数据集。灾难性遗忘仍然是一个重要的、公开的和 T21 难题。

【用于人体姿态估计的具有注意力调制特征融合的初始网络的级联初始技术】论文

Results of our the paper on the MPII datasets. It is shown that the method is able to handle non-standard poses and resolve ambiguities when body parts are occluded. Source.

动机

• 姿势估计——需要对身体部位的关键点进行精确定位，以分析图像和视频中的行为。它需要多样化的特性:高层次的上下文依赖和低层次的关节细化。
• 定位人体关节很难。由于人体的变形、外观的变化和遮挡，存在一些挑战。
• 现有方法在保留低级特征、自适应地调整不同级别特征的重要性以及模拟人类感知过程方面存在局限性。

贡献。

本文提出了三个新的技术，逐步有效地利用不同层次的特征，以改善人体姿态估计。

• 首先,《盗梦空间》( IOI)模块的设计是为了强调低级功能。
• 其次，提出了一种注意机制来根据上下文调整个体层次的重要性。
• 第三，提出了一个级联网络来顺序定位关节，以加强从独立部分(如头部和躯干)的关节到远程关节(如手腕或脚踝)的消息传递。

**我的想法:**本文提供了关于调整网络以解决特定问题的方法的见解(在这种情况下，对由遮挡和变形引起的姿态估计误差具有鲁棒性)。

【技术讲座】人员再识别的图形对应传递纸

(a) shows misalignment among local patches caused by viewpoint changes. The proposed GCT model can capture the correct semantic matching among patches using patchwise graph matching, as shown in image (b). Source

动机

• 人物再识别(ReID)是将不同的非重叠摄像机视图中具有相同身份的图像关联起来。视频分析、监控等领域的大量应用。
• ReID 很难，因为不同摄像机视图中的外观变化很大，身体遮挡严重，探针组中的许多其他图像相似。空间未对准，其中补丁在不同的视图/帧中具有不同的外观。

贡献

提出了一种用于身份识别的图对应转移(GCT)方法。

• 与现有方法不同，GCT 模型将人物再识别归结为一个 离线 图匹配和 在线 对应转移问题。
• 在训练期间，GCT 模型旨在离线学习，即通过逐块图匹配从具有各种姿态对配置的正训练对中学习一组对应模板。
• 在测试过程中，对于每一对测试样本，他们选择几个具有最相似姿态对配置的训练对作为参考，并将这些参考的对应关系传递给测试对用于特征距离计算。匹配分数是通过合计来自不同参考的距离而得到的。对于每个探测图像，具有最高匹配分数的图库图像是重新识别结果。与现有算法相比，GCT 可以处理由于视角和人类姿态的巨大变化引起的空间错位，这是由于逐片图形匹配的好处。

我的想法:在任务中利用离线知识的有趣方式。他们为具有特定姿态对的图像学习正确的面片对应，并在测试时在具有相似姿态对配置的图像中重用该知识！

【技术讲座】端到端联合视频去雾(EVD)和检测[ 论文

Comparisons of detection results on real-world hazy video sample frames. Note that for the third, fourth and fifth columns, the results are visualized on top of the (intermediate) dehazing results. Source

微软中国研究院的研究人员在创建一个端到端模型方面做了一些工作，该模型既可以去雾，也可以进行下游操作，如对象检测。

动机

• 由于在户外视频监控、交通监控和自动驾驶等领域具有深远的应用价值，去除野外获取的视觉数据中的雾霾一直吸引着人们极大的研究兴趣。
• CNN 已经应用于具有 SOTA 结果的去雾图像(去雾网，AOD 网)。
• 传统统计方法或 CNN 在探索视频去雾方面的努力有限

贡献

• 端到端模型(李等 2017aWang et al. 2016)，直接从模糊输入中回归出清晰图像，无需任何中间步骤。该模型优于多级流水线
• 通过明确考虑在恢复当前帧时如何嵌入相邻视频帧之间的时间一致性，接受视频设置。
• 作者表明，用于视频去雾和视频对象检测的联合优化的流水线比在已经独立去雾的视频流上运行检测的性能更好。除了去雾部分，检测部分还必须考虑时间相干性，以减少闪烁检测结果。

**我的想法:**研究人员确定了一种联合优化管道，有助于提高模糊图像的对象检测精度。这项工作有助于阐明联合优化和端到端模型的效用。

2 月 5 日星期一

【特邀演讲】交互式机器学习【查尔斯·伊斯贝尔和迈克尔·利特曼】

这次演讲由佐治亚理工学院的查尔斯·伊斯贝尔和布朗大学的迈克尔·利特曼主持。这是一个有趣的，引人入胜的(有时很机智)和互动的演示。它以 Charles 关于强化学习(RL)的讨论开始，用户在 RL 中扮演的角色，然后是生动的来回辩论式互动，Michael 向我们介绍了他的研究，该研究告知如何在 RL 中使用人类反馈。以下是一些注意事项:

强化学习(查尔斯·伊斯贝尔)

• 强化学习:假设有一个代理可以与环境交互，并得到一些可以用来修改未来交互的响应。建模为序列马尔可夫模型。允许我们从小数据集中学习。
• 交互式强化学习:利用并从人类身上提取好的数据。
• 我们为什么要信任用户？人民是最终的仲裁者；他们最清楚目标。
• 人类有时是愚蠢的:有时忽略人类的输入(或避免对其进行字面解释)以获得最佳结果是很重要的。考虑一个模拟，其中一个代理可以在一个包含辐射区域的领域中拯救人类。一个简单的“去人类，避免辐射”会导致更少的人类被拯救。此外，人类在某个时间点后会停止提供反馈，之后他们只会提供反馈。例如，成年人不会因为学骑自行车而得到补偿，但孩子会。

交互式机器学习(迈克尔·利特曼)

• 有时候，特工会学错东西。例如，模拟中的一只狗会走进一个花园，这样它就可以因为从花园出来而获得积极的奖励。这表明我们应该重新审视我们使用奖励的方式。
• 反馈应该是一个梯度信号，作为对代理人政策/行为的评论。我们没有把反馈插入代理的奖励系统，而是把它作为一个等式的输入，这个等式模拟代理的行为/政策(优势函数)。这种方法更好地支持收益递减、差异反馈和政策制定。
• 人类并不愚蠢:我们只需要更好地解释人类的输入，以及如何使用它来更新代理参数。我们不能外包我们对人类的理解。人类是一个循环，人工智能研究人员应该更多地与人类行为研究人员合作。

【特邀演讲】【人类人工智能协作】走向人工智能思维理论..Devi Parikh [ 纸张

(a) These montages an agent’s quirks. For a given question, it has the same response to each image in a montage. (b) Human subjects predict the success or failure and output responses of a VQA agent (called Vicki). Source

乔治亚理工学院的 Devi Parikh 做了一个有趣的演讲，她主张进行更多的研究来量化用户对人工智能局限性的理解。

• 我们越来越多地与能够接收图像并理解物体、活动、场景、对话、描述物体等的人工智能代理合作。参见 cloudcv 上的演示( visualChatbo t， VisualQA )。
• 自然语言很重要，因为人类是机器推理的消费者。
• 人类人工智能团队是未来。代理应该有一个很好的人类需求、意图、信念等模型，对用户的想法有一个理论。人类还必须对机器的能力、极限、信念等有所了解——人工智能的思维理论**。**
• 人类如何理解 AI？人类如何逼近神经网络？可解释性努力在多大程度上帮助人类理解 AI 极限？
• 特工都很古怪。 大多数代理不会计数、推理、一致性，也不会查阅外部知识库。不知道 3 离 4 有多近。他们视野有限，语言能力有限，不会推理，看不到世界上的先验知识(例如，香蕉主要是黄色的)，从有偏见的数据集学习，并试图回答所有的问题。
• 特工的古怪是可以预见的。我们要量化这个。她与一名接受过 VQA 训练的代理进行了一项实验(参见视觉问题回答的分层问题-图像共同关注)。给定一幅图像，参与者被要求估计代理是否会正确回答问题。 — 60%的人正确预测了代理人的表现。 —解释模态增加预测…显著图和其他模态导致预测增加。
• 她建议使用监督学习来训练代理，并使用强化学习来微调它们。
• 下一步和一些重要的论文:合作游戏，人类描述一个图像，代理人试图猜测图像。两人分享正确猜测的奖励。关于这项工作的一些论文。-visualdialog.org/ -【HCOMP 2017】通过人机合作游戏评估视觉对话智能体。 -【ICCV 2017】学习合作视觉对话具有深度强化学习的智能体 -【CVPR 2017】视觉对话。

作为一名人机交互研究员，我发现 Devi 的演讲是会议上最有趣的演讲之一。我特别欣赏为开发推进 SOTA 的系统所做的努力(例如 VQA 在她的工作中)以及探索与这些系统相互作用的人为因素的实验。我的感觉是，Devi 的工作为成功结合人工智能和人机交互的研究提供了一个很好的例子。

2 月 6 日星期二

[邀请谈话]公平的问题，辛西娅·德沃克

辛西娅提供了她在差分隐私、算法公平和偏见方面丰富工作的想法。

• 偏见会影响算法的公平性 数据、算法和系统都有偏见，反映了设计者的显性和隐性选择、历史偏见和社会优先考虑。它们不折不扣地形成了价值观的法典化。算法的不公平——从广告到累犯预测——最近在大众媒体上引起了相当大的关注。(德沃克、哈特、皮塔西、莱因戈尔德和泽梅尔，2012 年)。
• 分类中的公平概念 —统计均等:那些接受正(或负)分类的人口统计数据与整个人口的人口统计数据相同的性质 —相似地对待相似的个体:任何两个在特定任务方面相似的个体都应该被相似地分类 —组成对个体和群体公平的影响。

辛西娅最后做了一些笔记

• 教育有两种用途…扶老携幼和传授知识的主要任务。教育越进步，补偿越少。
• 如果人工智能使现有问题复杂化，它的负面影响将变得更加深远。例如，增加面临风险的母亲(她们最需要经济支持)的保险费
• 需要描述数据集“公平性”的指标。

【技术谈】终身学习的选择性经验回放。

来自宾夕法尼亚大学 Grasp 实验室的 David Isele 和 Akansel Cosgun 的演讲。

动机

• 我们通常希望在一个受控的环境中训练一个模型，并希望它在野外有优雅的表现(适应新环境的能力)。
• 在许多情况下，所学习的模型可能不是立即适合的，但是可以代表极好的初始化点。然后，我们可以基于这种初始化来启动某种形式的学习。
• 然而，当我们尝试这种“在线”学习时，灾难性遗忘带来了复杂性。需要支持在线学习而不会遗忘的方法。

贡献

• 这项工作采用了来自生物学的灵感和类比，并建议选择性体验回放。为了对连续学习者有用，经验重放必须被修改以允许适应变化的环境，同时保持过去的经验仍然相关。深度强化神经网络和经验回放见 Mnih 等 2015 。
• 经验回放利用长期和短期记忆。然而，我们不能把所有的经历都保存在记忆中，我们需要策略来选择保存哪一段记忆。
• 这项工作评估了经验选择策略(包括他们的)以及它们如何影响终身学习绩效——惊喜、奖励、最大化覆盖和匹配分布。

我的想法:本文讨论了在终身学习的背景下解决灾难性遗忘的另一种方法。这是一个更有趣的用例(与“离线”模型相比，后者可能不需要在约束条件下频繁“学习”新信息)。期待着在报纸出版时阅读它。

用于跨领域情感分类的分层注意力转移网络

有趣的应用人工智能论文，探索跨领域情感分类的问题。

动机

• 当训练集和测试集存在差异(分布)时，我们通常会观察到准确性的降低。例如，如果我们训练一个模型来检测书籍/小说文本中的情感，如果我们将该模型应用于不同的领域，例如餐馆评论文本，我们会观察到较低的分类性能。考虑一下例子【小说正文**】《一个令人清醒的故事》【餐厅评论正文】“饭后我感到清醒”。 清醒 这个词可能会有不同的情绪(和含义)。**
• 显然，我们需要可扩展的、端到端可训练的方法来改进跨领域分类并解决上面举例说明的问题。

贡献

• 这项工作利用文本的语言特征，识别两种类型的词——中枢和非中枢。支点是传达情感但不随领域变化的词。在大多数领域，厌恶这个词可能是负面的。非中枢:与中枢共现的特定领域词汇。
• 了解中枢和非中枢之间的比对以及它们与分类的关系，然后将这种比对跨多个域进行转移。为了学习这种排列，他们提出了两个层次化的注意力转移网络(HATNs)，它们学习中枢(P-Net)和非中枢(NP-Net)。
• 作者在 5 个不同的领域测试了他们的方法，并显示了从基线开始的准确性的提高。

****我的想法:有趣实用的应用 AI 演示。这项工作也是深入领域的专业知识(在这种情况下是语言学)可以为神经网络架构的设计提供信息的方式的一个例子。有趣的是，随着独立学习正确架构的网络取得更多进展(例如谷歌与 AutoML 合作)，看看他们如何与基于深层领域专业知识的解决方案进行比较将是有趣的。

【技术讲座】从人群中深度学习[ 论文 ]

: Bottleneck structure for a CNN for classification with 4 classes and R annotators. Source

动机

• 深度学习使 SOTA 在各个领域取得了成果，并从标记的数据集中受益。但是对于许多问题，这种数据是不可用的。
• 为了解决这个问题，我们使用了群体，有时我们需要专家群体(例如医学诊断)。虽然这种方法可行，但通常需要从多个具有不同专业水平的嘈杂贡献者那里收集标签。
• 几种可能的聚合策略: ——多数投票(天真地假设所有注释者都是同等可靠的)。 -使用期望最大化(EM)式算法，将公证人及其答案的未知偏差联合建模为一些潜在事实的嘈杂版本

投稿

• 作者提出了一种新颖的人群层**，这使他们能够直接从多个标注者的嘈杂标签中**训练端到端的神经网络，仅使用反向传播。****
• 这种变通的方法不仅避免了 EM 的额外计算开销，而且导致了一个通用的框架，该框架除了分类问题之外还可以进行一般性的推广。
• 从经验上看，所提出的人群层能够自动区分好的和不可靠的注释者，并捕捉他们的个体偏见，从而在来自 Amazon Mechanical Turk 的真实数据中实现新的最先进的结果，用于图像分类、文本回归和命名实体识别

我的想法:异常简单(概念和实现)但有效且有见地的问题解决方案。这些结果也可能对可以被公式化为聚合或投票问题的用例的一般集合有影响。

【技术谈】测量神经网络中的灾难性遗忘 论文

As a network is incrementally trained (solid lines), ideally its performance would match that of a model trained offline with all of the data upfront (dashed line). Experiments show that even methods designed to prevent catastrophic forgetting perform significantly worse than an offline model. Incremental learning is key to many real-world applications because it allows the model to adapt after being deployed. Source

动机

• 一旦网络被训练来完成特定的任务，例如鸟类分类，它就不能容易地被训练来完成新的任务，例如递增地学习识别额外的鸟类或学习完全不同的任务，例如花的识别。当增加新任务时，典型的深度神经网络容易灾难性地忘记以前的任务。
• 然而，增量学习很重要。希望有一种网络能够适应测试中的各种扰动。 —略有变化的已知数据(例如天气、驾驶中的振动等) —新的数据类型(图像和音频) —新的对象类别(例如 MNIST 的新数字)
• 能够逐渐吸收新信息的网络，就像人类如何随着时间的推移形成新的记忆一样，将比每次需要学习新任务时从头开始重新训练模型更有效。
• 已经多次尝试开发减轻灾难性遗忘的方案，但是这些方法没有被直接比较，用于评估它们的测试变化很大，并且这些方法仅在小规模问题上被评估。

贡献

• 作者引入了新的度量和基准来直接比较五种不同的机制，这些机制旨在减轻神经网络中的灾难性遗忘:正则化、集合、预演、双记忆和稀疏编码。
• 指标 稳定性…它对基础知识的记忆有多好 可塑性…它还在学习新材料吗？总体表现…稳定塑性比。
• 对真实世界图像和声音的实验表明，对最佳性能至关重要的机制因增量训练范式和所用数据类型而异，但它们都表明灾难性遗忘问题尚未解决。
• 下一步:作者提出了他们解决灾难性遗忘问题的方法。

我的想法:我非常喜欢这个演示，觉得它很有教育意义，并且相信它们提供的度量、实验和见解有助于我们理解灾难性遗忘问题。该论文还强调了当前灾难性遗忘方法的一些难以处理的性质(例如，稀疏方法导致了40 倍的内存开销)以及为什么它们可能无法用于现实世界的部署。他们还表明，许多这些方法的性能不能很好地推广到更大的数据集。

2 月 7 日星期三

【特邀演讲】我们如何评价斯坦福不良贷款集团 AI — Percy Liang)

Screenshot from Percy’s slide on future directions in crafting test sets.

在这个演讲中，Percy 主张改进我们评估 ML 算法的方式，以确保它们编码有意义的信息(没有廉价的技巧)并且很好地外推到新的发行版。

需要更好的指标

• ML 已经成功了。然而，最大似然算法容易受到(敌对的)干扰，并且会犯人类不会犯的错误。 —阅读理解也容易受到对抗性攻击(小队数据集)。遭受同样的问题。移动互联网。 ——这些问题表明我们正在做错事。我们如何缩小人类和机器之间的差距？ —解决方案… 杰夫·辛顿—胶囊网络？….Yosua bengi 的意识先验？概率编程( Kolter and Wong 2017 )？Hector levesque 2103 …除了小抄，我们还需要更难的 ML/AI 系统测试。 — Winograd 模式。考虑“狗追猫上树”这个例子。 它 在底部等待”。一个算法是否理解我们所说的 it ？ —插值不充分 —外推更难…测试域不同于训练域。我们需要跨领域推断的算法。

关于更难的测试和对立的例子

• 【阅读理解的对抗性例子— EMNLP 2017 】在对抗性的设定下，十六个已发表模型的准确率从平均 75%的 F1 分下降到 36%；当对手被允许添加不合语法的单词序列时，四个模型的平均准确率进一步下降到 7%
• 对对立例子的易感性(例如，对人类来说看起来正常的停车标志，但可以欺骗网络进入错误的分类)可能表明网络在表示停车标志时学到了错误的东西。
• 另一个更好的测试基准的例子:更深入理解常识性故事的语料库和评估框架，ACL 2016 。 该语料库在两个方面是独特的:(1)它捕获了日常事件之间的一组丰富的因果和时间常识关系，以及(2)它是日常生活故事的高质量集合，也可用于故事生成。实验评估表明，许多基于浅层语言理解的基线和最先进的模型都难以在故事完形填空中获得高分。
• Codalab — Percy 的团队创建了 Codalab，作为管理模型和促进可复制计算研究的工具。这有助于他们进行一些基准测试和评估实验。

关于防御对抗性攻击 Percy 提供了一种方法— 针对数据中毒攻击的认证防御

• 为了防止攻击，我们可以尝试创建一个模型性能的上限保证。这是防御方在一系列攻击中最糟糕的防御损失的概念，防御方首先执行异常值删除，然后执行经验风险最小化。
• 创建一个捕捉这个界限的证书，如果我们将它添加到训练目标函数中，它允许更好的防御。

学习评价

• 模特能把负面评价转化成正面评价吗？这可能意味着它已经学到了一些对文本有意义的东西。
• 经验评估仍然是一个好方法。与图灵测试和 Winograd 模式的传统保持一致。
• 如果训练集和测试集具有相同的分布，我们就不能确切地确定我们的网络已经学到了深刻的东西。
• 当一项措施成为目标时，它就不再是一项好的措施。古德哈特定律。

[技术演讲]使用递归神经网络的句子排序和连贯性建模[ 论文

Model Overview: The input set of sentences are represented as vectors using a sentence encoder. At each time step of the model, attention weights are computed for the sentence embeddings based on the current hidden state. The encoder uses the attention probabilities to compute the input for the next time-step and the decoder uses them for prediction. Source

动机

• 如何才能以连贯的方式排列文本？连贯指的是让读者理解和吸收信息的文本属性。他们的缺席限制了理解。**
• 连贯建模:区分连贯和不连贯文本的任务。如果我们能模拟连贯性，那么我们就能完成句子排序这项有价值的任务。
• 案例示例:在多文档摘要中，我们想知道如何从每个不同文档中组合提取的文本来生成连贯的摘要。

贡献

• 作者提出了基于 set-to-sequence 框架的端到端无监督深度学习方法。
• 可视化所学习的句子表示表明，该模型捕捉段落中的高级逻辑结构。

我的想法:提供一些关于一致性建模方法的有趣想法。在学习生成连贯故事、对话或闲聊的 GAN 时，这可能有作为自动鉴别器的应用。

【技术谈】意象如何激发诗歌:用记忆网络从意象中生成中国古典诗歌 。

动机

• 中国古典诗歌结构简洁，节奏优美，内容丰富。中国诗歌最常见的体裁是绝句(四行诗)。
• 目标:给定一幅图像，我们如何生成一首既遵循四行诗的规则，又能描述图像的四行诗。
• 现有的工作有几个局限性——它们表现出主题漂移(系统生成与电子邮件无关的材料)，无法覆盖图像，以及覆盖关键字。

贡献

• 作者提供了一个管道，首先提取关键字和特征(语义)，逐行生成诗歌，整合语义关键字，忽略不重要的信息。
• 注意力层允许模型关注图像的重要部分和前面几行的内容。支持无限数量的关键字。
• 他们开发了一些有趣的评估实验来验证他们的工作。

【技术谈】一个基于知识的神经对话模型 论文

Knowledge-grounded model architecture and evaluation metrics. Source

动机

• 神经网络模型能够生成极其自然的声音对话交互。然而，这些模型还没有证明它们能够以事实信息或基于实体的观点的形式整合内容，这将使它们能够服务于更面向任务的对话应用。如果用户提到一个不在数据集中的实体，就没有办法正确处理它。
• 目标:一个端到端的可训练管道，完全由数据驱动，学习使用数据集中的基础信息进行对话。

贡献

• 提出了一种新颖的、完全数据驱动的、基于知识的神经对话模型，旨在产生更有内容的响应，而无需填充缝隙。
• 将广泛使用的序列对序列(Seq2Seq)方法一般化，根据对话历史和外部“事实”来调节响应，使模型在开放领域设置中通用和适用。将非对话数据注入对话。
• 该方法相对于竞争性 Seq2Seq 基线有显著改善。人类法官发现，模型输出的信息量要大得多。
• 实验:数据收集自 Foursquare，23M 通用域 twitter 会话。基础:与 foursquare 实体的 100 万次 twitter 对话。
• 多任务学习和参数共享解决泛化问题。

【特邀演讲】从朴素物理学到内涵:用语言学习和推理世界——叶筋·崔

这是一个比较有趣的演讲，叶筋从丰富的角度介绍了她在自然语言处理方面的工作。她从她的团队赢得亚马逊 Alexa Alexa 奖开始——创造了一个社交机器人，在 10 分钟内进行自然对话。

入选 Alexa 奖的团队在创造社交机器人方面展开竞争，这些机器人可以就一系列时事和热门话题(如娱乐、体育、政治、技术和时尚)与人类进行连贯而生动的对话。

为了感受一场精心设计的社交机器人对话有多令人满意，我建议看看关于 2017 年 Alexa 奖 结果的 视频。这些机器人可以被中断，在多个域上生成对话，似乎保持上下文等。

上面的幻灯片是叶筋在 AAAI 演讲的浓缩版。

我们的解决方案优于 SOTA！

一件有趣的事情是，在所有的技术讲座中，每一个演讲者都用这句台词来宣告他们的胜利

“我们的解决方案超越了最先进的技术(SOTA)”。(附有这方面的表格)

人工智能的研究进展非常非常快，我想研究人员展示进展的一种客观方式是展示他们报告的性能分数超过之前 SOTA 基准的指标(有时是 0.1 或 0.2)。一些人已经观察到这些比较是如何被操纵的，并在发布过程中产生瑕疵。

另一个有趣的术语是“端到端可训练的”——指的是使用单/联合损失函数训练所有模型的 ML 管道。拥有这样一个端对端可训练的模型，当然胜过 SOTA ，这是既令人向往又时髦的！**

结论

AAAI 2018 是一次组织得非常好的会议，很棒的场地(纽奥良被点亮了)，我学到了很多！更重要的是，它帮助我确定了人工智能中我需要投入更多时间理解的领域和概念。与同事一起展示我在一个用于分析和可视化系外行星数据的认知助手上的工作也很棒。这个项目的视频描述可以在这里找到。

感谢阅读(原来是一篇冗长的帖子！).你可以随时联系 Twitter、Github 或 Linkedin。