正则化和过拟合
http://www.discovery.com/tv-shows/mythbusters/about-this-show/physics-of-seesaws/
注:帖子是我以后参考用的。请随意指出任何异常之处。
首先，我将讨论一些基本的想法，所以如果你认为你已经是有这些想法的家庭，请随意继续。
一个线性模型
线性模型是在预测模型中遵循直线的模型。它可以有单个属性来预测值，也可以有多个属性来预测值，方程看起来像这样。
(a)
这里θ-0 是截距，θ-1 到θ-n 是对应于它们的属性 X-1 到 X-n 的斜率。
成本函数
讲故事有两种方式，一种是艰难的方式，在这种方式中，你被期望达到说话者的标准，或者…
towardsdatascience.com](/machine-leaning-cost-function-and-gradient-descend-75821535b2ef)
成本函数决定了你预测的假设 h(x)和实际点之间有多少差异。因为我们首先考虑一个线性模型，让我们看看它在图上的样子。
一个只有两点，一个有很多点。但是，您认为线性模型或星光线可以表示如下所示的数据吗:
在这种数据集中，拟合直线的可能性非常多。因此，我们开始使用如下所示形式的多项式方程:
它开始形成一条曲线，与直线相比，可以更好地表示数据点。当我们只有一个θ时，这意味着我们只有一个方向的斜率，因此我们得到一条直线，但是，如果我们有许多θ，这意味着许多斜率，因此我们的直线可以以许多不同的方式改变方向。见下图。
https://www.originlab.com/index.aspx?go=Products/Origin/DataAnalysis/CurveFitting
- 我们希望我们的成本函数在直线的情况下最小，我们也希望它在多项式线的情况下最小。
- 我们使用梯度下降，通过不断更新方程中的所有θ来拟合可能的最佳直线。
我们为什么需要正规化？
回答 —防止模型过拟合。
欠拟合:我们看到，我们绘制的假设线并不真正遵循与点相同的趋势。这样，我们的模型就不能给出我们数据的精确描述。
*解法:*做一个多项式方程，它创建一条曲线而不是直线。
良好拟合:通过使用一个多项式方程，你增加了可以采取不同形状的线的复杂性，然而，如果你有一个变量，比如说“X”和预测“Y”，那么你只是创建了一条单线。
过度拟合:如果你知道通过使你的方程多项式化，你可以调整它以匹配你的数据点，但是，如果你调整假设的直线到试图通过每一个可能的数据点的程度，那么你说你的模型过度拟合。
为什么会产生问题？因为当你要预测未来的事情时，你的模型不能确定这条线将在哪里转弯，因为它没有概括整个模型，而是概括单个数据点。
*解决:*正规化
正规化
因为我们知道通过改变斜率我们可以改变直线的方向，我们知道我们的模型有太多的精度，所以你会建议从方程的末尾去掉高次项吗？号码
Wrong approach
如果你保留所有的高次项，而是操纵与每个项相关的斜率，会怎么样呢？请记住，每个术语都代表数据集中的一个属性，例如，x1-销售额，x2-利润，x3-支出，等等。
我们如何做到这一点？
在称为正则化的方法的帮助下，您将与每个斜率(θ)相关的项的值增加到更高的值，而与每个项相关的斜率将减少到更低的值。请注意，我们并没有消除较高程度的条款，我们正在增加它的价值，以惩罚其斜率。
Visualize the difference
1-如果斜率为 1，那么 x 的每一个单位变化，y 也会有一个单位变化。等式为“y=mx+c ”,其中 m=1，因此 y=x。
2-如果斜率为 2，等式将为 y=2x+c。这意味着对于半个单位的变化，在 x 中，y 将变化一个单位。因此，x 值越小，斜率越大。
3-如果斜率为 0.5，则等式为 y=0.5x+c。这意味着 x 变化 2 个单位，y 将变化 1 个单位。因此，x 值越高，斜率越低。
这意味着斜率和与之相关的变量值成反比。因此，增加属性“x”的值是有意义的，以便塑造它们的斜率，使它们不会过度适应数据。
摘要
简而言之，当在等式中引入 Lambda 时，模型变得一般化，并给出了更广泛的训练集。如果没有 lambda，模型将试图拟合训练集中的每一个点，因此在测试阶段失败，因为一旦新数据出现，它不知道下一步要去哪里。
机器学习安全性
使用模型来打破模型
本文原载于 blog.zakjost.com。请去那里订阅。
随着越来越多的系统在其决策过程中利用 ML 模型，考虑恶意行为者可能如何利用这些模型，以及如何设计针对这些攻击的防御措施将变得越来越重要。这篇文章的目的是分享我最近在这个话题上的一些心得。
ML 无处不在
可用数据、处理能力和 ML 空间中的创新的爆炸导致了 ML 的无处不在。鉴于开源框架和数据的激增，构建这些模型实际上非常容易(本教程将在大约 5-10 分钟内将零 ML/编程知识的人带到 6 ML 模型)。此外，云提供商提供 ML 即服务的持续趋势使客户能够构建解决方案，而无需编写代码或理解其工作原理。
Alexa 可以使用语音命令代表我们购买。模特识别色情内容，帮助我们的孩子更安全地使用互联网平台。他们在我们的道路上驾驶汽车，保护我们免受骗子和恶意软件的侵害。他们监控我们的信用卡交易和互联网使用情况，寻找可疑的异常情况。
" Alexa，给我的猫买鳄梨色拉酱"
ML 的好处是显而易见的——让一个人手动检查每一笔信用卡交易、每一张脸书图片、每一个 YouTube 视频等等是不可能的。风险呢？
在无人驾驶汽车导航时，不需要太多的想象力就可以理解 ML 算法出错可能带来的危害。常见的说法往往是，“只要它犯的错误比人类少，那就是净收益”。
但是那些恶意的演员试图欺骗模特的情况呢？来自麻省理工学院的学生团体 lab six 3D 打印了一只海龟，它被谷歌的 InceptionV3 图像分类器可靠地归类为“来福枪”，无论相机角度如何[1]。对于语音到文本系统，Carlini 和 Wagner 发现[2]:
给定任何音频波形，我们可以产生另一个超过 99.9%的相似度，但转录为我们选择的任何短语…我们的攻击 100%成功，不管想要的转录或初始源音频样本。
Papernot 等人表明，以有针对性的方式向恶意软件添加一行代码可以在超过 60%的情况下欺骗最先进的恶意软件检测模型[3]。
通过使用相当简单的技巧，一个糟糕的演员甚至可以让最有表现力和最令人印象深刻的模特以他们想要的任何方式出错。例如，这张图片骗过了谷歌模型，让它几乎 100%确定这是一张鳄梨色拉酱图片[1]:
这是一个现实生活中的停车标志的图像，它被操纵，使得计算机视觉模型在驾车实验中 100%的时间都被欺骗，认为它是一个“限速 45 英里/小时”的标志[4]:
怎么这么好，却这么坏？
在所有这些例子中，基本思想是以最大化模型输出变化的方式扰动输入。这些被称为“对立的例子”。有了这个框架，你可以知道如何最有效地调整猫的形象，让模型认为它是鳄梨色拉酱。这有点像让所有的小错误排成一行，指向同一个方向，这样雪花就变成了雪崩。从技术上来说，这就简化为寻找输出相对于输入的梯度——这是 ML 从业者很擅长做的事情！
值得强调的是，这些变化大多是察觉不到的。例如，听这些音频样本。尽管听起来和我的耳朵一样，一个翻译成“没有数据集，文章是无用的”，另一个翻译成“好吧，谷歌，浏览到 evil.com”。更值得强调的是，真正的恶意用户并不总是局限于做出难以察觉的改变，所以我们应该假设这是对安全漏洞的下限估计。
但是我需要担心吗？
好吧，所以这些模型的健壮性存在问题，这使得它们很容易被利用。但除非你是谷歌或脸书，否则你可能不会在生产系统中构建庞大的神经网络，所以你不必担心……对吗？对！？
不对。这个问题不是神经网络独有的。事实上，被发现欺骗一个模型的对立例子经常欺骗其他模型，即使它们是使用不同的架构、数据集甚至算法训练的。这意味着，即使你要集合不同类型的模特，你的仍然不安全*。如果你向外界公开一个模型，即使是间接的，有人可以向它发送输入并得到响应，你就有风险了。这一领域的历史始于暴露线性模型的弱点，只是后来才在深度网络的背景下重新点燃【6】。*
我们如何阻止它？
在攻击和防御之间有一场持续的军备竞赛。这份最近出炉的《ICML 2018》最佳论文，“破”了同年会议论文呈现的 9 项答辩中的 7 项。这种趋势不太可能很快停止。
那么，一个普通的 ML 从业者该怎么做呢？他可能没有时间关注 ML 安全文献的最新进展，更不用说无休止地将新的防御结合到所有面向外部的生产模型中了。在我看来，唯一明智的方法是设计具有多种智能来源的系统，这样单点故障不会破坏整个系统的效能。这意味着您假设一个单独的模型可以被破坏，并且您设计您的系统对那种情况是健壮的。
例如，让无人驾驶汽车完全由计算机视觉 ML 系统导航可能是一个非常危险的想法(原因不仅仅是安全)。使用正交信息(如激光雷达、GPS 和历史记录)的环境冗余测量可能有助于反驳对立的视觉结果。这自然假定系统被设计成综合这些信号以做出最终判断。
更重要的一点是，我们需要认识到模型安全性是一个实质性的普遍风险，随着 ML 越来越多地融入我们的生活，它只会随着时间的推移而增加。因此，我们需要建立作为 ML 从业者的肌肉来思考这些风险，并设计强大的系统来抵御它们。就像我们在 web 应用程序中采取预防措施来保护我们的系统免受恶意用户的攻击一样，我们也应该积极应对模型安全风险。正如机构有应用程序安全审查小组进行软件渗透测试一样，我们也需要建立提供类似功能的模型安全审查小组。有一点是肯定的:这个问题不会很快消失，而且可能会越来越严重。
如果你想了解更多关于这个话题的内容，比吉奥和花小蕾的论文给出了该领域精彩的回顾和历史，包括这里没有提到的完全不同的攻击方法(例如数据中毒)[6]。
参考
- “愚弄物理世界中的神经网络。”2017 年 10 月 31 日，www.labsix.org/physical-objects-that-fool-neural-nets。
- 名词（noun 的缩写）卡利尼 d .瓦格纳。"音频对抗示例:针对语音转文本的攻击."arXiv 预印本 arXiv:1801.01944 ，2018。
- K.Grosse，N. Papernot，P. Manoharan，M. Backes，P. McDaniel (2017) 恶意软件检测的对抗示例。载于:Foley S .，Gollmann D .，Snekkenes E .(编辑)《计算机安全——ESORICS 2017》。ESORICS 2017。计算机科学讲义，第 10493 卷。斯普林格，查姆。
- K.Eykhold，I. Evtimov 等人，“对深度学习视觉分类的鲁棒物理世界攻击”。arXiv 预印本 arXiv:1707.08945 ，2017。
- 名词（noun 的缩写）Papernot，P. McDaniel，I.J. Goodfellow。“机器学习中的可转移性:从现象到使用敌对样本的黑盒攻击”。arXiv 预印本 arXiv:1605.07277 ，2016。
- B.花小蕾·比吉奥。"野生模式:对抗性机器学习兴起后的十年."arXiv 预印本 arXiv:1712.03141 ，2018。
原载于blog.zakjost.com*。*
机器学习安全性及其与模型可解释性的相互作用
机器学习的发展和部署在许多方面带来了机遇和挑战:从高质量和相关数据集的管理，到可推广模型的开发，最后到所述模型的部署。在最后一个阵营中，公平性、问责制和透明度等问题是最近许多研究问题的核心(参见 FATML 社区[1])，以及可解释性和数据隐私。
模型安全性是另一个重要的考虑因素。在实践中，模型安全性旨在防止对手窃取已部署模型的模型参数(可通过 API 访问)，这种损失可能会产生竞争/法律/健壮性后果。这种担忧既影响初创公司，也影响公司，特别是 Clarifai、Google、Amazon 等较大的公司，以及其他盈利策略依赖于在其 API 生命周期内摊销模型培训成本的公司[2]。
当一家公司必须在允许访问一个非常强大的 API(带有关于模型输出的详细信息，包括类别标签、置信度得分等)和冒着被对手复制其模型的风险之间做出决定时，这种紧张关系确实令人着迷。即使折衷的解决方案建议 API 只提供有限的信息，法规要求部署的模型提供可解释的解释(法律要求[3])，这可能会再次促进模型窃取[4]。
最近，我和我的合作者介绍了梅斯:对后果性决策的模型不可知的反事实解释[5]。动机是提供一个全封装的方法，以满足对各种 ML 模型和距离度量(代表一组不同的现实世界应用)的可解释解释的法律要求。接下来，我很兴奋地探索反事实解释的潜力，同时提供高质量的解释和可证明的保证，而不透露太多关于模型的内部。实现这一点对于消费者和法律采用 ML 模型是必要的。
[2]https://arxiv.org/pdf/1609.02943.pdf
[3]https://arxiv.org/pdf/1711.00399.pdf
https://arxiv.org/pdf/1807.05185.pdf
https://arxiv.org/pdf/1905.11190.pdf
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
单词嵌入 Python 示例—情感分析
https://www.pexels.com/photo/person-using-appliance-132700/
机器学习的主要应用之一是情感分析。情感分析就是判断一个文档的基调。情感分析的输出通常是 0 到 1 之间的分数，其中 1 表示语气非常积极，0 表示非常消极。情绪分析经常用于交易。例如，情绪分析被应用于交易者的推文，以估计整体市场情绪。
正如人们所料，情感分析是一个自然语言处理(NLP)问题。NLP 是人工智能的一个领域，涉及理解和处理语言。本文的目标是构建一个模型，从语料库的文档中获取单词的语义。在高层次上，可以想象我们将带有单词 好的 的文档分类为肯定的，而将单词 坏的 分类为否定的。不幸的是，问题并没有那么简单，因为单词前面可以有 而不是 如 不好。
密码
说得够多了，让我们深入一些 Python 代码。
import numpy as np
from matplotlib import pyplot as plt
plt.style.use('dark_background')
from keras.datasets import imdb
from keras.models import Sequential
from keras.preprocessing.sequence import pad_sequences
from keras.layers import Embedding, GlobalAveragePooling1D, Dense
参数num_words=10000确保我们只保留训练集中出现频率最高的前 10，000 个单词。为了保持数据的大小易于管理，我们会丢弃一些不常用的单词。
num_words = 10000
我们将使用包含来自互联网电影数据库的 50，000 条电影评论的 IMDB 数据集。后者被分成 25，000 条用于训练的评论和 25，000 条用于测试的评论。训练集和测试集是平衡的，这意味着它们包含相同数量的正面和负面评论。
old = np.load
np.load = lambda *a,**k: old(*a,**k, allow_pickle = True)
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=num_words)
np.load = old
del(old)print("Training entries: {}, labels: {}".format(len(X_train), len(y_train)))
当我们使用keras.datasets.imdb将数据集导入我们的程序时，它已经经过了预处理。换句话说，每个例子都是一个整数列表，其中每个整数代表字典中的一个特定单词，每个标签都是 0 或 1 的整数值，其中 0 是负面评论，1 是正面评论。我们先在第一次复习的时候来个巅峰。
print(X_train[0])
为了更好地理解我们正在处理的内容，我们将创建一个助手函数，将每个训练示例中的整数映射到索引中的单词。
word_index = imdb.get_word_index()# The first indices are reserved
word_index = {k:(v+3) for k,v in word_index.items()}
word_index["<PAD>"] = 0
word_index["<START>"] = 1
word_index["<UNK>"] = 2 # unknown
word_index["<UNUSED>"] = 3reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])def decode_review(text):
return ' '.join([reverse_word_index.get(i, '?') for i in text])
现在，我们可以使用decode_review功能来显示第一篇评论的文本。
decode_review(X_train[0])
鉴于文档中的每个单词都将被解释为一个特征，我们必须确保电影评论的长度相同，然后才能尝试将它们输入神经网络。
len(X_train[0]), len(X_train[1])
我们将使用pad_sequence功能来标准化长度。
X_train = pad_sequences(
X_train,
value=word_index["<PAD>"],
padding='post',
maxlen=256
)X_test = pad_sequences(
X_test,
value=word_index["<PAD>"],
padding='post',
maxlen=256
)
让我们看看前几个样本的长度。
len(X_train[0]), len(X_train[1])
正如敏锐的读者可能已经猜到的，单词是分类特征。因此，我们不能直接将它们输入神经网络。尽管它们已经被编码为整数，但是如果我们让它们保持原样，模型会将具有较高值的整数解释为比具有较低值的整数具有更高的优先级。通常，您可以通过将数组转换为指示单词出现的向量0和1来解决这个问题，这类似于一种热编码，但是对于单词来说，这是内存密集型的。给定 10，000 个单词的词汇表，我们需要在 RAM 中存储num_words * num_reviews大小的矩阵。
嵌入
这就是嵌入发挥作用的地方。嵌入通过将我们的高维数据映射到低维空间(类似于 PCA)来解决稀疏输入数据(非常大的向量，具有相对较少的非零值)的核心问题。
例如，假设我们有一个由以下两个句子组成的语料库。
- 希望很快见到你
- 很高兴再次见到你
就像 IMDB 数据集一样，我们可以为每个单词分配一个唯一的整数。
[0, 1, 2, 3, 4]
[5, 1, 2, 3, 6]
接下来，我们可以定义一个嵌入层。
Embedding(input_dim=7, output_dim=2, input_length=5)
- input_dim :训练集中词汇的大小(即不同单词的数量)
- output_dim :嵌入向量的大小
- input_length :样本中特征的个数(即每个文档的字数)。例如，如果我们所有的文档都由 1000 个单词组成，那么输入长度将是 1000。
嵌入的工作方式类似于查找表。每个记号(即单词)充当存储向量的索引。当一个令牌被提供给嵌入层时，它返回与该令牌相关联的向量，并通过神经网络传递该向量。随着网络的训练，嵌入也被优化。
+------------+------------+
| index | Embedding |
+------------+------------+
| 0 | [1.2, 3.1] |
| 1 | [0.1, 4.2] |
| 2 | [1.0, 3.1] |
| 3 | [0.3, 2.1] |
| 4 | [2.2, 1.4] |
| 5 | [0.7, 1.7] |
| 6 | [4.1, 2.0] |
+------------+------------+
比方说，我们有下面的单词教师的二维嵌入向量。
我们可以想象一个二维空间，其中相似的单词(即学校、导师)聚集在一起。
在我们的例子中，我们使用 16 维的嵌入向量。因此，我们可能会发现享受、喜欢和棒极了这几个词彼此非常接近。然后，我们的模型可以学习将其单词映射到 16 维空间中彼此接近的嵌入向量的评论分类为正面的。
model = Sequential()
model.add(Embedding(input_dim==num_words, output_dim=16, input_length=256))
model.add(GlobalAveragePooling1D())
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='sigmoid'))model.summary()
我们使用亚当作为我们的优化器，使用二元 交叉熵作为我们的损失函数，因为我们试图在两个类之间进行选择。
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy']
)
我们留出 10%的数据进行验证。每个时期，在更新权重之前，512 个评论通过神经网络。
history = model.fit(
X_train,
y_train,
epochs=20,
batch_size=512,
validation_split=0.1,
shuffle=True
)
我们可以通过使用由 fit 函数返回的历史变量来绘制每个时期的训练和验证准确度和损失。
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'y', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
acc = history.history['acc']
val_acc = history.history['val_acc']
plt.plot(epochs, acc, 'y', label='Training acc')
plt.plot(epochs, val_acc, 'r', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()
最后，让我们看看我们的模型在测试集上的表现如何。
test_loss, test_acc = model.evaluate(X_test, y_test)
print(test_acc)
最后的想法
当我们处理具有许多类别(即单词)的分类特征时，我们希望避免使用一种热编码，因为它需要我们在内存中存储一个大矩阵并训练许多参数。相反，我们可以将每个类别映射到一个 n 维嵌入向量，并使用嵌入向量作为输入来训练我们的机器学习模型。
机器学习:用 Python 实现简单线性回归
在这篇文章中，我们将指导你使用简单的线性回归来进行机器学习的第一步。
什么是线性？
首先，假设你正在沃尔玛购物。不管你买不买东西，你都要付 2 美元的停车票。每个苹果的价格是 1.5 美元，你必须购买一个( x) 的苹果。然后，我们可以填充如下价格列表:
Crosstab (Quantity & Price) for apple at Walmart
对于本例，使用公式 y=2+1.5x 很容易预测(或计算)基于价值的价格，反之亦然，或者:
Linear Functions
使用:
- a = 2
- b = 1.5
一个线性函数有一个自变量和一个因变量。自变量为 x 因变量为 y 。
- 是常数项或 y 截距。是 x = 0 时因变量的值。
- b 是自变量的系数。它也被称为斜率，给出了因变量的变化率。
为什么我们称之为线性？好了，让我们把上面得到的数据集可视化吧！
Shopping cost (y = 1.5x + 2)
在标绘购物成本的所有值(蓝线)后，你可以看到，它们都在一条线上，这就是为什么我们称之为。用线性方程(y=a+bx)，a 是自变量。即使 a=0(停车票不用你出)，购物成本线也会下移，他们还是在一条线上(橙色线)。**
Shopping cost (y = 1.5x)
但是在现实生活中，事情并没有那么简单！
我们再举一个例子，在 AB 公司，有一个基于工作年限的工资分配表，如下所示:
Salary based on Years of Experience (salary_data.csv)
假设你是一名人力资源主管，你得到了一名有 5 年工作经验的候选人。那你应该给他开出的最好工资是多少？”
在深入探讨这个问题之前，让我们先将数据集绘制到图中:
Salary Data on Scatter Plot
请仔细看这张图表。现在我们有一个坏消息:所有的观察结果都不在一条线上。这意味着我们找不到计算(y)值的方程。
那现在怎么办？别担心，我们有好消息要告诉你！
向下滚动之前，再次查看散点图。你看到了吗？
所有的点不在一条直线上，但是它们在一条直线上！是线性的！
Salary Data on Scatter Plot with linear shape
根据我们的观察，我们可以猜测 5 年经验的薪资范围应该在红色范围内。当然，我们可以向候选人提供红色范围内的任何数字。但是如何挑选最适合他的号码呢？是时候使用机器学习来预测我们候选人的最佳薪酬了。
在本节中，我们将在 Spyder IDE 上使用 Python 来为我们的候选人找到最佳工资。好吧，我们开始吧！
用 Python 实现线性回归
在继续之前，我们总结了机器学习的两个基本步骤如下:
- 培养
- 预测
好的，我们将使用 4 个库，如numpy和pandas来处理数据集，sklearn来实现机器学习功能，matplotlib来可视化我们的绘图以供查看:
代码解释:
dataset:该表包含了我们 csv 文件中的所有值X:包含年经验数组的第一列y:包含薪资数组的最后一列
接下来，我们必须将数据集(总共 30 个观察值)分成 2 组:用于训练的训练集和用于测试的测试集:
代码解释:
test_size=1/3:我们将我们的数据集(30 个观察值)分成两部分(训练集、测试集)，并且测试集与数据集的比率是 1/3 (10 个观察值将被放入测试集**)。你可以放 1/2 得到 50%或者 0.5，它们是一样的。我们不应该让测试集太大；如果它太大，我们将缺乏数据来训练。通常情况下，我们应该选择 5%到 30%左右。**train_size:如果我们已经使用了 test_size，其余的数据将自动分配给 train_size。random_state:这是随机数生成器的种子。我们也可以放一个RandomState类的实例。如果我们将其留空或为 0，将使用由np.random使用的RandomState实例。
我们已经有了训练集和测试集，现在我们必须构建回归模型:
代码解释:
regressor = LinearRegression():我们的训练模型，将实现线性回归。regressor.fit:在这一行中，我们通过包含年经历值的X_train和包含具体薪资值的y_train来组成模型。这是训练过程。
让我们设想一下我们的培训模型和测试模型:
运行上述代码后，您将在控制台窗口中看到两个图:
Training Set
Test Set
比较两幅图，我们可以看到两条蓝线是同一个方向。我们的模型现在很好用。
好吧！我们已经有了模型，现在我们可以用它来计算(预测)X 的任何值取决于 y 或y 的任何值取决于 X 。我们是这样做的:
Predict y_pred using single value of X=5
答对了。 X = 5 (5 年经验)的y_pred值为 73545.90
你可以向你的候选人提供 73，545.90 美元的薪水，这对他来说是最好的薪水了！
我们也可以传递一个 X 的数组，而不是 X** 的**单值:****
Predict y_pred using array of X_test
我们也可以用 y 来预测 X。你自己试试吧！
总之，对于简单的线性回归，我们必须按照以下 5 个步骤进行:
- 导入数据集。
- 将数据集分成训练集和测试集(每个集有 X 和 y 两个维度)。通常，测试集应该是数据集的 5%到 30%。
- 将训练集和测试集可视化以进行双重检查(如果需要，可以绕过这一步)。
- 初始化回归模型并使用训练集(X 和 y)对其进行拟合。
- 我们来预测一下！！
资源:
天天快乐学习！
机器学习技术在股票价格预测中的应用
Image generated using Neural Style Transfer.
机器学习有很多应用，其中之一就是预测时间序列。可以说，预测最有趣(或者最有利可图)的时间序列之一是股票价格。
最近我读了一篇将机器学习技术应用于股票价格预测的博文。这里可以看。这是一篇写得很好的文章，探讨了各种技术。然而，我觉得这个问题可以用更严谨的学术方法来处理。例如，在文章中，方法“移动平均”、“自动 ARIMA”和“先知”的预测范围为 1 年，而“线性回归”、“k-最近邻”和“长短期记忆(LSTM)”的预测范围为 1 天。文章的结尾写道:“LSTM 轻而易举地超越了我们迄今为止看到的任何算法。”但是很明显，我们不是在这里比较苹果和苹果。
所以，这是我对这个问题的看法。
问题陈述
我们的目标是预测 Vanguard Total Stock Market ETF(VTI)的每日调整收盘价，使用前 N 天的数据(即预测范围=1)。我们将使用 VTI 从 2015 年 11 月 25 日到 2018 年 11 月 23 日的三年历史价格，可以从雅虎财经轻松下载。下载后，数据集如下所示:
Downloaded dataset for VTI.
我们将把这个数据集分成 60%训练、20%验证和 20%测试。将使用训练集来训练模型，将使用验证集来调整模型超参数，并且最终将使用测试集来报告模型的性能。下图显示了调整后的收盘价，分为相应的训练集、验证集和测试集。
Split the dataset into 60% train, 20% validation, and 20% test.
为了评估我们方法的有效性，我们将使用均方根误差(RMSE)和平均绝对百分比误差(MAPE)指标。对于这两个指标，值越低，预测越好。
最后一个值
在最后一个值方法中，我们将简单地将预测值设置为最后一个观察值。在我们的上下文中，这意味着我们将当前调整后的收盘价设置为前一天的调整后收盘价。这是最具成本效益的预测模型，通常用作比较更复杂模型的基准。这里没有要优化的超参数。
下图显示了使用最后一个值方法的预测。如果仔细观察，您会发现每天的预测值(红叉)只是前一天的值(绿叉)。
Predictions using the last value method.
移动平均数
在移动平均法中，预测值将是前 N 个值的平均值。在我们的上下文中，这意味着我们将当前调整后的收盘价设置为前 N 天调整后的收盘价的平均值。超参数 N 需要调整。
下图显示了不同 N 值的验证集上实际值和预测值之间的 RMSE。我们将使用 N=2，因为它给出了最低的 RMSE。
RMSE between actual and predicted values on the validation set, for various N.
下图显示了使用移动平均法的预测。
Predictions using the moving average method.
你可以查看 Jupyter 笔记本的移动平均法这里。
线性回归
线性回归是一种对因变量和一个或多个自变量之间的关系进行建模的线性方法。我们在这里使用线性回归的方法是，我们将对前 N 个值拟合一个线性回归模型，并使用该模型来预测当天的值。下图是一个 N=5 的例子。实际调整后的收盘价显示为深蓝色十字，我们希望预测第 6 天的价值(黄色方块)。我们将通过前 5 个实际值拟合一条线性回归线(浅蓝色线)，并用它来做第 6 天的预测(浅蓝色圆圈)。
Predicting the next value using linear regression with N=5.
下面是我们用来训练模型和进行预测的代码。
import numpy as np
from sklearn.linear_model import LinearRegressiondef get_preds_lin_reg(df, target_col, N, pred_min, offset):
"""
Given a dataframe, get prediction at each timestep
Inputs
df : dataframe with the values you want to predict
target_col : name of the column you want to predict
N : use previous N values to do prediction
pred_min : all predictions should be >= pred_min
offset : for df we only do predictions for df[offset:]
Outputs
pred_list : the predictions for target_col
"""
# Create linear regression object
regr = LinearRegression(fit_intercept=True) pred_list = [] for i in range(offset, len(df['adj_close'])):
X_train = np.array(range(len(df['adj_close'][i-N:i])))
y_train = np.array(df['adj_close'][i-N:i])
X_train = X_train.reshape(-1, 1)
y_train = y_train.reshape(-1, 1)
regr.fit(X_train, y_train) # Train the model
pred = regr.predict(N)
pred_list.append(pred[0][0])
# If the values are < pred_min, set it to be pred_min
pred_list = np.array(pred_list)
pred_list[pred_list < pred_min] = pred_min
return pred_list
下图显示了不同 N 值的验证集上实际值和预测值之间的 RMSE。我们将使用 N=5，因为它给出了最低的 RMSE。
RMSE between actual and predicted values on the validation set, for various N.
下图显示了使用线性回归方法的预测。可以观察到这种方法不能捕捉方向的变化(即下降趋势到上升趋势，反之亦然)非常好。
Predictions using the linear regression method.
你可以查看 Jupyter 笔记本上的线性回归这里。
极端梯度增强(XGBoost)
梯度推进是以迭代的方式将弱学习者转换为强学习者的过程。XGBoost 这个名字指的是推动提升树算法的计算资源极限的工程目标。自 2014 年推出以来，XGBoost 已被证明是一种非常强大的机器学习技术，通常是许多机器学习竞赛中的首选算法。
我们将在训练集上训练 XGBoost 模型，使用验证集调整它的超参数，最后在测试集上应用 XGBoost 模型并报告结果。可以使用的明显特征是最近 N 天的调整收盘价，以及最近 N 天的成交量。除了这些功能，我们还可以做一些功能工程。我们将构建的附加功能有:
- 最近 N 天每天的最高价和最低价之差
- 最近 N 天每天的开盘和收盘之间的差异
在构建这个模型的过程中，我学到了一个有趣的经验，即特征缩放对于模型的正常工作非常重要。我的第一个模型根本没有实现任何缩放，验证集上的预测显示在下面的图中。这里发生的情况是，模型对 89 到 125 之间的调整后收盘价值进行训练，因此模型只能输出该范围内的预测。当模型试图预测验证集时，如果看到超出此范围的值，它就不能很好地进行归纳。
Predictions are highly inaccurate if feature and target scaling are not done properly.
我接下来尝试的是调整训练集，使其均值为 0，方差为 1，并对验证集应用相同的转换。但是很明显这并不奏效，因为这里我们使用了从训练集计算的平均值和方差来转换验证集。由于来自验证集的值比来自训练集的值大得多，因此缩放后，这些值仍然会更大。结果是预测看起来仍然如上，只是 y 轴上的值现在被缩放了。
最后，我所做的是调整训练集，使其均值为 0，方差为 1，并以此来训练模型。随后，当我对验证集进行预测时，对于每个样本的每个特征组，我将调整它们，使均值为 0，方差为 1。例如，如果我们在 T 日进行预测，我将采用最近 N 天(T-N 日至 T-1 日)调整后的收盘价，并将其调整为均值为 0，方差为 1。对于量的特性也是如此，我将取最近 N 天的量，并将它们缩放到均值为 0，方差为 1。对我们上面构建的附加特性重复同样的操作。然后，我们使用这些缩放后的特征进行预测。预测值也将被缩放，我们使用它们相应的平均值和方差对它们进行逆变换。我发现这种扩展方式提供了最好的性能，正如我们将在下面看到的。
下面是我们用来训练模型和进行预测的代码。
import math
import numpy as npfrom sklearn.metrics import mean_squared_error
from xgboost import XGBRegressordef get_mape(y_true, y_pred):
"""
Compute mean absolute percentage error (MAPE)
"""
y_true, y_pred = np.array(y_true), np.array(y_pred)
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100def train_pred_eval_model(X_train_scaled, \
y_train_scaled, \
X_test_scaled, \
y_test, \
col_mean, \
col_std, \
seed=100, \
n_estimators=100, \
max_depth=3, \
learning_rate=0.1, \
min_child_weight=1, \
subsample=1, \
colsample_bytree=1, \
colsample_bylevel=1, \
gamma=0):
'''
Train model, do prediction, scale back to original range and do
evaluation
Use XGBoost here.
Inputs
X_train_scaled : features for training. Scaled to have
mean 0 and variance 1
y_train_scaled : target for training. Scaled to have
mean 0 and variance 1
X_test_scaled : features for test. Each sample is
scaled to mean 0 and variance 1
y_test : target for test. Actual values, not
scaled
col_mean : means used to scale each sample of
X_test_scaled. Same length as
X_test_scaled and y_test
col_std : standard deviations used to scale each
sample of X_test_scaled. Same length as
X_test_scaled and y_test
seed : model seed
n_estimators : number of boosted trees to fit
max_depth : maximum tree depth for base learners
learning_rate : boosting learning rate (xgb’s “eta”)
min_child_weight : minimum sum of instance weight(hessian)
needed in a child
subsample : subsample ratio of the training
instance
colsample_bytree : subsample ratio of columns when
constructing each tree
colsample_bylevel : subsample ratio of columns for each
split, in each level
gamma : minimum loss reduction required to make
a further partition on a leaf node of
the tree
Outputs
rmse : root mean square error of y_test and
est
mape : mean absolute percentage error of
y_test and est
est : predicted values. Same length as y_test
''' model = XGBRegressor(seed=model_seed,
n_estimators=n_estimators,
max_depth=max_depth,
learning_rate=learning_rate,
min_child_weight=min_child_weight,
subsample=subsample,
colsample_bytree=colsample_bytree,
colsample_bylevel=colsample_bylevel,
gamma=gamma)
# Train the model
model.fit(X_train_scaled, y_train_scaled)
# Get predicted labels and scale back to original range
est_scaled = model.predict(X_test_scaled)
est = est_scaled * col_std + col_mean # Calculate RMSE
rmse = math.sqrt(mean_squared_error(y_test, est))
mape = get_mape(y_test, est)
return rmse, mape, est
下图显示了不同 N 值的验证集上实际值和预测值之间的 RMSE。我们将使用 N=3，因为它给出了最低的 RMSE。
Tuning N using RMSE and MAPE.
优化前后的超参数和性能如下所示。
Tuning XGBoost hyperparameters using RMSE and MAPE.
下图显示了使用 XGBoost 方法的预测。
Predictions using the XGBoost method.
你可以在这里查看 XGBoost 的 Jupyter 笔记本。
长短期记忆(LSTM)
LSTM 是一种深度学习技术，被开发用来解决长序列中遇到的消失梯度问题。LSTM 有三个门:更新门、遗忘门和输出门。更新和忽略门确定存储单元的每个元件是否被更新。输出门决定了作为激活输出到下一层的信息量。
下面是我们将要使用的 LSTM 建筑。我们将使用两层 LSTM 模块，中间有一个脱扣层以避免过度拟合。
LSTM network architecture.
下面是我们用来训练模型和进行预测的代码。
import math
import numpy as npfrom keras.models import Sequential
from keras.layers import Dense, Dropout, LSTMdef train_pred_eval_model(x_train_scaled, \
y_train_scaled, \
x_test_scaled, \
y_test, \
mu_test_list, \
std_test_list, \
lstm_units=50, \
dropout_prob=0.5, \
optimizer='adam', \
epochs=1, \
batch_size=1):
'''
Train model, do prediction, scale back to original range and do
evaluation
Use LSTM here.
Returns rmse, mape and predicted values
Inputs
x_train_scaled : e.g. x_train_scaled.shape=(451, 9, 1).
Here we are using the past 9 values to
predict the next value
y_train_scaled : e.g. y_train_scaled.shape=(451, 1)
x_test_scaled : use this to do predictions
y_test : actual value of the predictions
mu_test_list : list of the means. Same length as
x_test_scaled and y_test
std_test_list : list of the std devs. Same length as
x_test_scaled and y_test
lstm_units : dimensionality of the output space
dropout_prob : fraction of the units to drop for the
linear transformation of the inputs
optimizer : optimizer for model.compile()
epochs : epochs for model.fit()
batch_size : batch size for model.fit()
Outputs
rmse : root mean square error
mape : mean absolute percentage error
est : predictions
'''
# Create the LSTM network
model = Sequential()
model.add(LSTM(units=lstm_units,
return_sequences=True,
input_shape=(x_train_scaled.shape[1],1))) # Add dropput with a probability of 0.5
model.add(Dropout(dropout_prob)) model.add(LSTM(units=lstm_units)) # Add dropput with a probability of 0.5
model.add(Dropout(dropout_prob)) model.add(Dense(1)) # Compile and fit the LSTM network
model.compile(loss='mean_squared_error', optimizer=optimizer)
model.fit(x_train_scaled, y_train_scaled, epochs=epochs,
batch_size=batch_size, verbose=0)
# Do prediction
est_scaled = model.predict(x_test_scaled)
est = (est_scaled * np.array(std_test_list).reshape(-1,1)) +
np.array(mu_test_list).reshape(-1,1)
# Calculate RMSE and MAPE
rmse = math.sqrt(mean_squared_error(y_test, est))
mape = get_mape(y_test, est)
return rmse, mape, est
我们将使用与 XGBoost 中相同的方法来缩放数据集。LSTM 网络在调整验证集之前和之后的超参数和性能如下所示。
Tuning LSTM hyperparameters using RMSE and MAPE.
下图显示了使用 LSTM 的预测。
Predictions using the LSTM method.
你可以在这里查看 LSTM 的 Jupyter 笔记本。
调查结果和未来工作
下面，我们在同一个图中绘制了我们之前探索的所有方法的预测。很明显，使用线性回归的预测提供了最差的性能。除此之外，从视觉上很难判断哪种方法提供了最好的预测。
下面是我们探讨的各种方法在 RMSE 和 MAPE 的对比。我们看到最后一个值方法给出了最低的 RMSE 和 MAPE，其次是 XGBoost，然后是 LSTM。有趣的是，简单的最后值方法优于所有其他更复杂的方法，但这很可能是因为我们的预测范围只有 1。对于更长的预测范围，我相信其他方法可以比最后值方法更好地捕捉趋势和季节性。
Comparison of various methods using RMSE and MAPE.
作为未来的工作，探索更长的预测范围将是有趣的，例如 1 个月或 1 年。探索其他预测技术也将是有趣的，如自回归综合移动平均(ARIMA)和三重指数平滑(即。Holt-Winters 方法)，并看看它们与上面的机器学习方法相比如何。
如果你有兴趣进一步探索，看看这篇文章。
[## 中等
编辑描述
ngyibin.medium.com](https://ngyibin.medium.com/subscribe)
机器学习——文本分类，使用 fast.ai 的语言建模
将最新的深度学习技术应用于文本处理
T 转移学习是一种技术，在这种技术中，我们不是从头开始训练模型，而是重用预先训练好的模型，然后针对另一项相关任务对其进行微调。它在计算机视觉应用中非常成功。在自然语言处理(NLP)中，迁移学习大多局限于使用预先训练的单词嵌入。在预训练期间使用语言建模领域的研究已经导致许多自然语言处理任务的最先进结果的巨大飞跃，例如通过各种方法进行的文本分类、自然语言推理和问题回答，如 ULMFiT 、 OpenAI Transformer、 ELMo 和谷歌人工智能的 BERT 。
在这篇文章中，我们将讨论单词嵌入方法在自然语言处理问题的迁移学习中的局限性，以及使用语言模型通过 fast.ai 库构建文本分类器。
用语言数据迁移学习
单词嵌入算法 word2vec 和 GloVe 提供了单词到高维连续向量空间的映射，其中具有相似含义的不同单词具有相似的向量表示。这些单词嵌入，在大量未标记数据上预先训练，用于初始化称为嵌入层的神经网络的第一层，然后在特定任务的数据上训练模型的其余部分。NLP 问题中的这种转移学习是 浅 由于学习只转移到模型的第一层，网络的其余部分仍然需要从头开始训练。用单词嵌入初始化的模型需要从头开始学习，不仅要消除单词的歧义，还要从单词序列中推导出含义。为了做到这一点，用这些浅层表示初始化的 NLP 模型需要一个巨大的数据集来实现良好的性能，这也可能导致非常大的计算成本[1]。
语言建模
语言建模的核心目标是语言理解，它需要对复杂的语言现象进行建模，以处理具有挑战性的语言理解问题，如翻译、问答和情感分析。语言模型试图通过分层表示来学习自然语言的结构，因此既包含低级特征(单词表示)，也包含高级特征(语义)。语言建模的一个关键特征是它是生成性的，这意味着它的目标是在给定前一个单词序列的情况下预测下一个单词。它能够做到这一点，因为语言模型通常是以无监督的方式在非常大的数据集上训练的，因此该模型可以以比单词嵌入更深入的方式“学习”语言的句法特征[2]。
为了预测一个句子的下一个单词，模型实际上需要了解相当多的语言和相当多的世界知识。这里有一个例子:
- “我想吃个辣 __”:很明显是“狗”，对吧？
- “那天很热 __”:大概是“天”
如你所见，这里没有足够的信息来决定下一个单词可能是什么。但是有了神经网络，你绝对可以，只要你训练一个神经网络来预测一个句子的下一个单词，那么你实际上就有了很多信息。
快速人工智能
fastai 库专注于使用预先训练的语言模型并对其进行微调，分以下三步完成:
- 数据预处理用最少的代码量。
- 创建一个带有预训练权重的语言模型，您可以根据数据集对其进行微调。
- 在语言模型之上创建其他模型，例如分类器。
环境
在我们继续之前，我们需要为 fast.ai 设置环境。
安装和更新
要安装 fastai:
conda install -c pytorch -c fastai fastai pytorch
如果您想尝试一些准备运行的选项:
我使用 Colab 进行初步学习，但面临许多“脱节”的问题。Kaggle 也是一个不错的选择。Floydhub 运行顺利，但在免费积分之后，你需要付费使用。设置好您的环境后，让我们继续进行一些操作。
构建文本分类器
让我们构建一个文本分类器来使用到目前为止讨论的技术对 IMDB 电影数据集的情感进行分类。IMDb 数据集包含 25，000 条用于训练的电影评论，以及 25，000 条用于测试的电影评论。我们已经从之前的帖子中下载了 IMDb 的数据，并保存为 csv 格式。让我们把数据装入数据帧，
‘1’ positive and ‘0’ negative sentiment
使用下面这段代码。
**df_imdb = pd.read_csv(path/'movies_data.csv')
df_imdb.head()**#Loading only few training and validation samples, for quick training time
**trn_texts = df_imdb.loc[10000:14999, 'review'].values
trn_labels = df_imdb.loc[10000:14999, 'sentiment'].values
val_texts = df_imdb.loc[36000:38999, 'review'].values
val_labels = df_imdb.loc[36000:38999, 'sentiment'].values****np.random.seed(42)
trn_idx = np.random.permutation(len(trn_texts))
val_idx = np.random.permutation(len(val_texts))****trn_texts = trn_texts[trn_idx]
val_texts = val_texts[val_idx]****trn_labels = trn_labels[trn_idx]
val_labels = val_labels[val_idx]****col_names = ['labels','text']
df_trn = pd.DataFrame({'text':trn_texts, 'labels':trn_labels}, columns=col_names)
df_val = pd.DataFrame({'text':val_texts, 'labels':val_labels}, columns=col_names)**
我们使用来自培训的 5000 [每个标签 2500]和来自验证示例的 3000[每个标签 1500]。我使用较小的数据集来更快地完成训练，请使用完整的数据集来提高性能。
步骤 1:数据预处理
从原始文本创建数据集非常简单。该库提供了非常易于使用的 API[4]，根据我们的数据是如何构造的，创建一个数据类 TextDataBunch 用于文本处理，from_csv、from_folder、from_df更多细节请参考文档。这里我们将使用[TextLMDataBunch](https://docs.fast.ai/text.data.html#TextLMDataBunch)的方法from_df来创建一个特定于语言模型的数据串:
# Language model data
**data_lm = TextLMDataBunch.from_df('./', train_df=df_trn, valid_df=df_val)**
这在幕后做了所有必要的预处理。让我们看看 fast.ai 是如何对数据进行编码的
**data_lm.show_batch()**
我们可以看到许多标签被应用于单词，如上所示。这是为了保留所有可用于收集对新任务词汇理解的信息。所有标点符号、标签和特殊字符也会被保留。该文本使用各种标记编码，如下所示:
**xxbos**:句子的开始**xxfld**:表示文档的独立部分，如标题、摘要等。，每个都将获得一个单独的字段，因此它们将被编号(例如xxfld 1、xxfld 2)。**xxup**:如果所有的大写字母中都有东西，它会变成小写字母，一个名为xxup的标记会被添加进去。全大写的单词，如“我在喊”，标记为“xxup i xxup am xxup shouting”**xxunk**:代币代替生僻字。**xxmaj**: token 表示单词有大写。“The”将被标记为“xxmaj the”。**xxrep**: token 表示重复的单词，如果你连续有 29 个!(即xxrep 29 !)。
词汇表:唯一可能的标记列表称为词汇表。下面按频率顺序列出了前 20 个唯一令牌:
**data_lm.vocab.itos[:20]
['xxunk', 'xxpad', 'xxbos', 'xxfld', 'xxmaj', 'xxup', 'xxrep', xxwrep', 'the', '.', ',', 'a', 'and', 'of', 'to', 'is', 'it', 'in', i', 'this']**
**数字化:**最后，机器更容易处理数字，因此用 vocab 中的记号位置替换记号:
默认的 vocab 大小设置为 60，000 个单词，添加到 vocab 中的单词的最小计数为 2，以避免权重矩阵变大。
**保存和加载:**我们可以在预处理完成后保存数据串。我们也可以在需要的时候加载。
**# save and load
data_lm.save(**'tmp_lm'**)** **data_lm = TextClasDataBunch.load('./',** 'tmp_lm'**)**
步骤 2:创建语言模型
Fast.ai 有一个预训练的 Wikitext 模型，由从维基百科提取的 1.03 亿个令牌的预处理子集组成。这是一个理解很多语言和语言所描述的东西的模型。下一步是微调这个模型，并进行迁移学习，以创建一个新的语言模型，它特别擅长预测电影评论的下一个词。
语言模型微调
这是训练的第一阶段，我们使用预训练的语言模型权重，并用 IMDb 电影评论的训练数据对其进行微调。当我们创建一个学习者时，我们必须传递两件事:
- 数据:我们的语言模型数据
(data_lm) - 预训练模型:这里，预训练模型是 Wikitext 103 模型，将从 fastai 为您下载。
# Language model
**learner = language_model_learner(data_lm, pretrained_model=URLs.WT103_1, drop_mult=0.5)**
drop_mult，超参数，用于正则化，设置漏失量。如果模型过度拟合，则增加它，如果拟合不足，则可以减少该数字。
**如何在我们的影评数据上对预训练好的模型进行微调？**学习率超参数是训练模型最重要的参数之一。Fast.ai 提供了一个方便的实用程序(learn.lr_find)来搜索一系列学习率，以找到最适合我们数据集的学习率。学习率查找器将在每次小批量后增加学习率。最终，学习率太高，损失会变得更严重。现在看看学习率与损失的关系图，确定最低点(下图中大约在1e-1附近)，然后返回一个数量级，选择它作为学习率(大约在1e-2附近)。
训练模型:
我们使用fit_one_cycle.以学习速率1e-2开始训练模型
fast.ai 库使用深度学习研究的最新技术， 单周期学习 来自最近的一篇论文，结果证明比以前的任何方法都更准确、更快。第一个参数“1”是纪元运行次数。仅运行一个时期后，我们就获得了 29%的准确度。
它训练了最后几层，基本上保持了模型的大部分原样。但是我们真正想要的是训练整个模型。通常在我们微调了最后几层之后，我们要做的下一件事就是unfreeze(解冻整个模型进行训练)并训练整个模型。
**learn.unfreeze()
learn.fit_one_cycle(1, 1e-3)****epoch train_loss valid_loss accuracy
1 3.897383 3.977569 0.302463**
准确度= 0.3 意味着该模型在大约三分之一的时间内正确猜测电影评论的下一个单词。这听起来是一个相当高的数字。所以这是一个好迹象，表明我的语言模型做得相当好。
用语言模型预测
为了评估我们的语言模型，我们现在可以运行learn.predict并传入一个句子的开头，指定我们希望它猜测的单词数。
这是相当不错的回答，看起来像是正确的语法。在微调之后，我们得到了一个善于理解电影评论的模型，我们可以通过迁移学习对其进行微调，以将电影评论分为正面或负面。让我们保存模型的编码，以便稍后用于分类。
**learn.save_encoder('fine_enc')**
模型中能够理解句子的部分称为编码器。所以我们保存它，以便以后在分类阶段使用。
创建分类器
现在我们准备创建我们的分类器。第一步，创建一个数据串，从语言模型中传递词汇，确保这个数据串有完全相同的词汇。要使用的批量大小bs取决于您可用的 GPU 内存，对于 bs=64 左右的 16GB GPU 将工作良好。你可以找到任何适合你的卡批量，并相应地使用它。
# Classifier model data
**data_clas = TextClasDataBunch.from_df('./', train_df=df_trn, valid_df=df_val, vocab=data_lm.train_ds.vocab, bs=32)**
最后，我们将创建一个文本分类器学习器。载入我们的预训练模型，我们之前保存的编码部分‘fine_enc’。
# Classifier
**classifier = text_classifier_learner(data_clas, drop_mult=0.5)
classifier.load_encoder('fine_enc')**
同样，我们遵循相同的过程来找到学习率并训练模型。
2e-2 附近的学习率似乎是正确的，因此让我们训练分类器:
哇 85%的准确率在 16 分钟的训练和只使用 5K 训练和 3K 验证样本。这就是迁移学习的力量。
**损失图:**让我们在训练模型时绘制损失图:
损失曲线似乎平稳下降，尚未达到饱和点。fastai 计算损失的指数加权移动平均线，从而使这些图表更容易阅读(通过使曲线更平滑),同时它可能比它们应该在的地方落后一两批。
深度学习超参数调整技术
让我们来理解 fast.ai 在如此令人印象深刻的结果下使用的技术。
**区别学习率:**从一层到另一层，对不同的层应用不同的学习率。在拟合模型时，您可以传递一个学习率列表，该列表将对每个*层组应用不同的学习率。*使用已调用split的[Learner](https://docs.fast.ai/basic_train.html#Learner)时，您可以通过四种方式设置超参数:
param = [val1, val2 ..., valn](n =层组数)param = valparam = slice(start,end)param = slice(end)
如果我们选择在方式 1 中设置它，我们必须指定一些值，这些值正好等于图层组的数量。如果我们选择在方式 2 中设置它，选择的值将对所有层组重复。如果你通过了slice(start,end)那么第一组的学习率是start，最后一组是end，剩下的是平均分配。
如果你仅仅通过了slice(end)，那么最后一组的学习率就是end，其他所有组都是end/10。例如(对于我们有 3 个层组的学员):
**learn.lr_range(slice(1e-5,1e-3)), learn.lr_range(slice(1e-3))****(array([1.e-05, 1.e-04, 1.e-03]), array([0.0001, 0.0001, 0.001 ]))**
切片的底部和切片的顶部是模型的最低层学习速度与模型的最高层学习速度之间的差异。随着你从一层到另一层，我们降低了学习速度。最低级别被给予较小的学习速率，以便不太干扰权重。
适合一个周期
什么是 fit_one_cycle()？就是一个周期的学习率，开始低，上去，再下来。让我们使用plot_lr绘制每批的学习率
left: learning rate one cycle, right:momentum for one cycle
当我们调用 fit_one_cycle 时，我们实际上是在传递一个最大的学习速率。左侧图显示了学习率变化与批次的关系。学习开始很慢，大约一半的时间增加，然后大约一半的时间减少。当你接近最终答案的时候，你需要调整你的学习速度来磨练它。这背后的动机是，在学习过程中，当学习率较高时，学习率作为正则化方法工作，并防止网络过拟合。这有助于网络避开陡峭的损耗区域，更好地获得平坦的最小值。请参考 Leslie smith 的这篇论文，其中详细讨论了神经网络超参数调整，您可以在 fastai 中找到这些想法的大部分。
动力
还有一个说法(moms=(0.8,0.7) )﹣momentums 等于 0.8，0.7。基本上对于训练递归神经网络(RNNs)来说，它确实有助于稍微降低动量。上面右边是动量图。每次我们的学习率小，我们的冲劲就大。这是为什么呢？因为随着你学习的速度越来越小，但你一直朝着同一个方向前进，你还不如走得更快(更高的动力)。但是由于你学习的学习率很高，但是你一直朝着同一个方向前进，你可能会超过目标，所以势头应该放缓。这一招可以帮你训练快 10 倍。
进一步微调:
为了进一步提高准确性，fast.ai 提供了一些更多的技巧；freeze_to。不要解冻整个东西，而是一次解冻一层。下面的方法效果很好，给出了令人难以置信的结果。
- 解冻最后两层
freeze_to(-2)，多训练一点 - 解冻下一层
freeze_to(-3)，多训练一点 - 解冻整个东西
unfreeze()，多训练它一点点
我们达到了 90%的准确率。 训练损失仍然高于验证损失，因此我们还没有过度拟合 ，仍然有通过运行更多纪元来提高准确性的空间。
混淆矩阵
在分类问题中，使用一种叫做混淆矩阵的东西是非常有用的，它可以显示每个标签被正确预测了多少次。混淆矩阵是总结分类算法性能的好方法。
我们使用*ClassificationInterpretation*类来为我们做这项工作。
让我们使用我们的分类器来预测一些电影评论:
这被预测为’ 0 '，负面评论。太棒了。！！
我们之前使用经典的机器学习方法和对 IMDb 电影评论进行了情感分类，然后使用单词嵌入方法和。使用 fast.ai 的语言建模方法是我见过的最简单也是最强大的工具。该库提供了非常易于使用的方法，只需几行代码，您就可以获得最先进的结果。请参考 jupyter 笔记本这里。
结论
我们简要讨论了迁移学习在 NLP 问题中的应用。我们详细探讨了 fast.ai 库和不同的超参数调优技术。我们创建了一个语言模型，然后将其应用于文本分类问题。我希望你喜欢这篇文章，并学到一些新的有用的东西。
感谢您的阅读。
参考资料:
[1]http://ruder.io/nlp-imagenet/
https://docs.fast.ai/text.html
相关职位
[1]https://towards data science . com/transfer-learning-946518 f 95666
[3]https://blog.floydhub.com/ten-techniques-from-fast-ai/
机器学习与新闻
发生了一些事情。只有一件事。但是如果你在网上关注新闻，你会发现对这一事件的描述如此不同，你想知道实际上发生了什么是情有可原的。有了机器学习，我们可以为此开发一个应用程序。
【本文中的工作随后被应用于金融市场。这个项目在这里讨论过: 阅读市场——机器学习与金融新闻 。】
最近，我花了几个月的时间将自然语言处理(NLP)技术应用于一个大型新闻故事语料库。我的目标是找到一种方法来识别报道同一事件的新闻文章，然后评估这些文章，以了解媒体报道的一致性或均衡性。
最终，我提出了对个别文章和总体报道的评分。这些分数可用于多种目的:
- 在一个比我们的世界更乌托邦的世界里，它们将被集成到一个新闻阅读应用程序中，比如脸书。阅读新闻文章的用户将被呈现一个分数，该分数显示这篇文章在覆盖该故事的文章系列中的位置。然后可以引导他们阅读其他文章，以便对事件有更全面的了解。
- 在政治上，能够在所有媒体上跟踪一篇文章，并衡量情绪和共识，可能是跟踪民意和微调信息的有用工具。
- 在金融市场，衡量共识/分歧，而不仅仅是不同新闻来源的情绪，可能会成为交易决策的有用信号。
该解决方案是用 Python 构建的，需要结合 NLP 的许多工具。在最高级别上，问题可以分为主题挖掘(在 TF-IDF 矢量化的基础上使用一种聚类形式)和情感分析(使用谷歌云平台，VADER 斯坦福 CoreNLP)。让 NLP 按预期表现是一门微妙的艺术。在这种情况下，它需要大量的预处理步骤(词汇化、词性过滤、n 元语法等。)和附加库，如 NLTK 和 spaCy。
本报告由两个主要部分组成。第一部分涉及问题的背景——即对媒体和偏见不可避免性的简要回顾。第二部分给出了问题的解决方案，描述了它的各个组成部分。
所以，如果你对问题的背景感兴趣，从第一部分开始。如果你渴望得到答案，向下滚动到第二部分。(如果你非常好奇，可以得到一份更详细的技术报告。完整的代码可以在项目的 GITHUB 库中找到。)
第一部分:问题
媒体通常对一个故事的基本事实达成一致。但是他们可能仍然不同意人们应该如何看待他们。这是因为尽管事实是清楚的，但它们的含义是模糊的——因此两篇文章对同一个故事持完全相反的观点是完全合理的。
这是真的，只要看一看 2016 年 6 月 29 日两家主要出版物关于班加西专家组报告发布的单一新闻报道就可以确定:
Headlines from June 29, 2016
根据我们看到的头条新闻，我们会认为该小组的报告对克林顿来说是好消息，或者是坏消息。
出于几个原因，关于班加西事件的报道非常吸引人。首先:这两个标题并不明显矛盾，但它们显然以非常不同的方式强调了重点。第二:两篇文章的内容没有什么特别的不同——只是标题不同。第三:这两份出版物中的标题后来都被修改了(在付印后),以使其听起来更加平衡。文章的当前版本可以在这里和这里找到。
很容易认为事情没那么糟，因为报纸最终接受了更加中立的报道。但这可能会忽略一个更广泛的问题:很多观点是在 Twitter 的即时舞台上形成的，在那里，这些文章可能会使用它们最初的标题进行推广。他们修改后的化身对公众舆论的影响会更小。
此外，研究表明，读者从阅读文章中获得的情感更多地是由标题而不是内容驱动的。(例如，见心理学家和认知神经科学家乌烈芝·埃克在实验心理学杂志上的工作:应用 这里)
同样值得注意的是，这两份报纸都可以被视为中间偏左。皮尤研究中心的一项研究将《纽约时报》放在比《华盛顿邮报》更靠左的位置。那项研究衡量的是读者，而不是新闻，但在竞争激烈的市场中，有理由相信大多数读者都在看他们认同的新闻。此外，我们看到，即使是这种观点上的微小差异，也会产生完全不同的标题——人们只能想象，如果我们拓宽视野，把所有媒体都包括进来，我们会发现怎样的多样性。
总结这种情况的一个简单方法是，即使主流媒体也以不同的情绪报道同样的事件。因此，确定这些事件对我们读者的意义并不简单。毫无疑问，会有读者满足于自己的偏见和成见被强化。但是也有一些读者希望对世界有一个更平衡的理解——这个项目就是为他们而设的。
第二部分:解决方案
那么，该怎么办呢？从数学上来说，我们可能倾向于认为，要想知道真实的本质，我们必须阅读报道事件的每一篇文章。不知何故，我们会将所有的噪音平均掉，留下一个关于潜在事件及其影响的消息灵通和无偏见的观点。但是有两个问题:
- 不成比例的一部分媒体可能会用一个声音说话，因此噪音不会平均化，以揭示一些真相。
- 无论如何，阅读每一篇发表的文章都需要极大的自律。
这种纪律虽然值得称赞，但并不是实用主义者对现代世界生活的首选方式——在现代世界，不知情的人可能会淹没在信息的海洋中。这位实用主义者知道我们缺乏这一学科，于是开始寻找算法解决方案。
从广义上讲，该算法必须首先从覆盖我们感兴趣的故事的媒体中识别出一组文章。鉴于发表的文章数量庞大，这不是一个微不足道的问题，但完全可以解决。接下来，分析该组文章以确定:
- 它们包含不同观点的程度。
- 其中，在各种观点中，任何特定的文章排名。
有了这些信息，我们可以:
- 了解我们正在阅读的文章是否是从极端视角写的。
- 提出另一篇文章来阅读，这将对故事有更细致入微的理解。
- 对总覆盖率的中立性进行评分。
使聚集
第一步大致对应于聚类。与自然语言处理的许多方面一样，提取有用的含义是一门手艺。在这种情况下，我们只需要为每篇文章准备一组单词，并希望将这些文章归入涵盖相同故事的那些文章中。最终，语料库中的每篇文章都被替换为 TF-IDF 向量，该向量实际上是其相对信息内容的抽象数字表示。(稍后将详细介绍这一点。)如果我们小心我们的预处理和参数校准，那么向量空间中的近邻可以被可靠地判断为属于同一故事的文章。
该游戏变成了执行 NLP 库中的一组预处理步骤之一。其中包括:
- 去除腐败文章 —最起码可以发现语料库中有很多文章是没有帮助的。它们可能是腐败的，它们可能是包含许多故事中的每一个的句子的摘要文章，等等。当然，这些文章不是我们为了更好地理解一个故事而推荐阅读的文章。
- 关注文章的第一部分——一篇新闻文章的结构通常是这样的，前几个句子(lead 或 lede)说明了故事的人、事、原因、时间、地点和方式。包含在文章的这一部分中的术语更可能在报道相同故事的文章之间共享。
- 同义词替换 —一些实体可以用多种方式引用。如果两个相关的文章以不同的方式引用实体，它们就不太可能被正确配对。为了降低这种风险，常见的同义词被联合起来。比如联邦调查局，FBI，F.B.I .都翻译成 FBI。
- 词性限制 —不同的词性在文章的实际主题上传达了不同的信息量。例如，专有名词可能是最重要的，动词将包含一些信息，形容词通常很少。因此，剔除信息较少的词类有助于提高文章分组的鲁棒性。当然，这需要用算法分析文章，给每个单词分配一个角色。
- 词汇化 —矢量化本质上并不理解单词之间的关系。例如，同一个词根可以用不同的时态表达，等等。如此选举，被选举，选举，选举，选举等。可能指的是同一件事。词汇化是用词根替换单词的过程。这具有增加两个相关文章在向量空间中更接近的机会的优点。
- N-grams —连续词被分组，并在矢量化中用作组合词。这样做的目的是利用这样一个事实，即如果两个术语在两篇文章中相邻出现，那么这些文章比它们出现在文章的不同部分更有可能相关。例如，一篇提到希拉里·克林顿会见比尔·盖茨的文章可能会与一篇关于比尔·克林顿的文章配对，除非我们包含了二元模型——希拉里的文章不会包含“比尔·克林顿”，因此不太可能配对。
- 停用词抑制 —这一步简单地删除定义列表中包含的任何过于常见而无法传达有用信息的词。这降低了向量的维数，但是可能不会显著改变聚类，因为这种常见术语的 IDF 分数将非常低。
目的是生成尽可能集中于传达与故事相关的信息的术语的向量，这些术语是最有可能与覆盖相同故事的其他文章共享的术语，而不太可能出现在不同故事的文章中。
这些步骤可以在许多常见的 NLP 库中执行，并取得不同程度的成功，比如 NLTK 和 spAcy。完成后，使用 sklearn 将每篇文章转换成一个 TF-IDF 向量。
TF-IDF 矢量化是一种流行的主题挖掘方法。它用一个向量表示语料库中的每个文档。该向量包含组合字典中每个术语的值。当文档的主题与术语相关时，值本身是高的，否则是低的。因此，出现在许多文档中的单词被认为传达了很少的信息来区分主题。并且在文档中出现多次的单词被认为对于区分主题更有意义。然后，TF-IDF 值实际上是一个术语在文章中出现的次数，以及该术语在所有提供的文档的语料库中具有的主题区分能力的乘积。
如果我们观察 2016 年某一天一组媒体上的新闻文章，我们会发现一系列非常高维的向量。虽然这些高维向量用于我们执行的处理，但为了可视化正在发生的事情，有必要应用一些标准的数学技术，并将它们的值映射到二维的近似值。这给了我们这样一个图表:
Story clusters inferred from news articles of 2016–09–01
图中的每个点对应一篇文章。用颜色编码的聚类中的文章是算法已经确定的关于相同主题的文章。(为了增加可靠性，这种确定需要用一种新的亲和力度量来代替通常的欧几里得距离。详细情况在完整的项目报告中提供。)
请注意中心区域的大量蓝点。这些文章都是报道他们特殊故事的唯一文章。因为它们是故事中唯一的文章，它们的向量包含低 TF-IDF 值，因此它们聚集在图形中心的原点周围。
这种转变的力量令人印象深刻。乍一看，似乎是“Penn State”的一个粉红色点，实际上是来自几乎相同的向量的一系列三个点，只有放大几次才能看到。
快速浏览一下这些文章的开头可以发现，虽然它们属于同一个故事，但它们肯定不是相同的词汇列表。
Related news articles on the Joe Paterno anniversary
委内瑞拉抗议的故事同样包含三篇极其接近的文章:
Related news articles on the Venezuela protests
在这两种情况下，显而易见的是，该算法成功地将主题从数千篇文章中分离出来，聚类在确定哪些文章足够接近以至于可以被指定为报道同一故事方面做得很好。虽然这些文章之间的联系对人的眼睛来说是显而易见的，但是一旦我们后退一步，想想成千上万的新闻文章，每一篇都有一系列的许多单词，每个单词都传达不同程度的信息，那么我们就可以开始看到，为了得出结论，大脑本身一定在做一些非常聪明的处理。
那么，现在我们已经找到了这组文章，我们可以用它做什么呢？
文章排名
为了给文章排序，我们需要找到一个轴来衡量它们。假设文章反映了相同的事件集合，应该可以利用情感分析的工作来进行评估和排名。
这个过程有几个步骤:
- 恢复文章的原始版本(从词条化之前，等等)。
- 将每篇文章转换成一个句子列表(使用 NLTK)。
- 将分析限制在每篇文章的前 n 个句子。(一项全面的网格搜索发现，辨别情绪的最佳值是每篇文章 10 句左右。)
- 计算每篇文章的情感。这是通过用户在斯坦福 CoreNLP、谷歌云平台的 NLP 库和 Vader 的 NTLK 实现之间的选择来完成的。
- 根据每个库的规模的含义，将结果转换为 in -1/+1。
- 进一步调整结果以考虑 NLP 库实际上可以返回全范围值的可能性。对谷歌来说，对数千篇新闻文章的分析表明，合适的比例是除以 0.86。(与其他图书馆相比，这是一个较小的调整，可能反映了每个图书馆都是针对不同类型的数据进行训练/校准的——谷歌是针对最广泛的数据进行训练的。)
- 最后，组成一个故事的文章的经缩放的标准化情感值被作为输入来计算该故事的总覆盖的中立性得分。
中立分数是使用专门为此项目设计的新公式计算的:
这里 count(x，y) 统计从 x 到 y 范围内有情绪的文章数量。
这个概念非常松散地受到维基百科编辑指南的启发，特别是它对“中立观点”的定义，这意味着包括所有可证实的观点，而不过度重视其中任何一个。该公式在项目的完整技术报告中有相当详细的讨论。
第 3 部分:一些结果
处理主观数据的挑战是找到一种客观的方法来验证结果。对于这个项目，基本的方法是获取一个故事的文章，计算每篇文章的分数，然后计算报道的中立性。然后，这些值被排序，并与前述皮尤量表上文章出版商的相对位置相关联(见本报告)。
显然，这不是一个完美的比较——例如，《纽约时报》的专栏文章可能会也可能不会与该报的总体社论倾向保持一致。但如果我们拿一个故事来说，关于特朗普与墨西哥总统会晤的报道，我们会得到以下内容:
结果似乎表明，媒体机构越左倾，对会议的负面报道就越多。布莱巴特的报告最为热情。CNN 在数字上基本保持中立。路透社完全中立。《卫报》与《纽约时报》争夺最负面的报道。
更多案例见技术报告。
第四部分:几点结论
该项目应用了许多不同的概念，试图回答最初的问题“如何找到并提出一篇以不同方式报道同一故事的文章”？可以得出以下结论:
- 将文章聚集成故事看起来效果很好，但是需要扩展测试来验证这种观点。然而，时间和资源总是这类工作的主要制约因素。
- 中立分数做了一些看起来有意义的事情，但需要进一步增强才能变得真正强大。为了真正了解结果的有效性，可能有必要考虑完全不同的测试方法。对问题进行富有想象力的分解可能会产生一个可以交给机器人的任务。
- 追踪一个故事随时间的演变会很有趣。只要对算法稍加修改，这应该是可行的。
我的主要结论是，新闻文章本质上是复杂的——衡量它们的情绪并不简单。相对于潜在故事/事实的情绪来考虑文章的情绪可能是值得的。这可以更清楚地表明报告中的任何偏见。此外，所报告的语音的情感可能需要与文章其余部分的情感区别对待。我们应该考虑一下，未来新闻机构是否有可能以一种游戏比分的方式来撰写文章——也许是通过掩盖领先优势。这也可以通过标记主角的情绪与文章其余部分的情绪明显偏离的情况来规避。
【本文中的观点随后被扩展并应用于金融市场。这里介绍了这个项目: 阅读市场——机器学习与金融新闻 。]
第 5 部分:所有细节
这篇文章很长，但不足以深入细节。对于这一点，以及更多的例子，这里是到技术报告和源代码库的链接的最后一个提示:
机器学习不会取代投资经理
机器学习有可能改变我们的世界，就像大约一个世纪前电力改变了几乎一切一样。但是，很难想象你的职业会受到怎样的影响。所以，让我们考虑一下机器学习对于投资经理的潜力。
更新:我开了一家科技公司。你可以在这里找到更多
实施投资理念
投资需要一种理念作为寻找、评估和选择新投资机会的框架。这些理念使投资经理能够与众不同，从而吸引特定的客户群。
任何投资理念的实施都有两个组成部分。第一步是将论文引入现实世界，通过提出正确的问题来测试、验证和提炼。第二是它的执行力。
这两个因素对于投资的成功都至关重要，但是执行——你买什么，你投资多少，你什么时候做交易——会导致一个好的投资失败或成功。此外，这需要扩大到足够广泛的股票领域，以便基金能够分配足够的资本，为投资者带来正回报。
机器学习给投资经理带来的好处
因此，投资极其复杂。需要对许多内部和外部因素进行深入彻底的分析，以找到符合这一理念并具有显著上升潜力的早期迹象的股票。
然而，用于投资管理的机器学习可以在任何选定理念的时间受限和资源密集型执行阶段提供竞争优势。
通过学习哲学的关键因素和未来价格表现之间的关系，机器学习可以大规模识别候选股票，并通过缩小可行选项来帮助投资者优化他们的研究分析。
机器学习对投资银行的限制是什么？
机器学习并不像它看起来那么抽象，在许多情况下，它只是广泛使用的线性回归的扩展。然而，在处理输入和目标变量之间的关系是非线性的或者问题有许多维度的边缘情况时，机器学习算法比人和线性回归好得多。
然而，机器学习在投资银行业的成功取决于投资经理要求它回答的问题的质量。
例如，机器学习可以识别和预测价格急剧下跌或上涨的早期迹象，以及预测 IBES 分析师估计的准确性。
此外，由于机器学习模型高度灵活，可以提出的可能问题只受到投资经理创造力的限制。
总之，机器学习不会取代投资经理，因为它无法独立思考。然而，随着时间的推移，在投资银行业使用机器学习的个人将取代那些不使用机器学习的人。
为机器学习处理大数据集
每天都会产生超过 25 万亿字节的数据。世界上 90%的数据都是在过去两年产生的。数据的盛行只会越来越大，所以我们需要学习如何处理这样的大数据。
“大数据就像青少年性行为:每个人都在谈论它，没有人真正知道如何去做，每个人都认为其他人都在做，所以每个人都声称自己在做。”—丹·艾瑞里
想象一下，下载一个包含所有已写推文的数据集，或者脸书所有 23 亿人的数据，甚至是互联网上所有网页的数据。如何分析这样的数据集？
这不是一个孤立的问题，只影响最大的科技公司。在当今时代，数据集已经变得超出了大多数计算机的处理能力。我经常处理卫星数据，这些数据很容易就达到 TB 级——太大了，甚至不适合我的计算机硬盘，更不用说在合理的时间内处理这些数据了。以下是一些令人大开眼界的大数据统计数据:
- 每分钟发送超过 1600 万条短信
- 每分钟都有超过 1 亿封垃圾邮件发出
- 每分钟都有超过一百万次的打火
- 每天，超过 10 亿张照片被上传到 Google 相册
存储这些数据是一回事，但如何处理这些数据并开发机器学习算法来处理这些数据呢？在本文中，我们将讨论如何在云上轻松创建可扩展的并行化机器学习平台，以处理大规模数据。
这可以用于研究、商业或非商业目的，并且与开发自己的超级计算机相比，可以以最小的成本完成。
为了在云上开发一个非常健壮和高性能的并行集群(这也可以在本地机器上使用以提高性能),我们将深入研究以下主题:
- 环境设置
- 与 Dask 和 Kubernetes 并行
- Dask 云部署
- AWS 上的云部署示例
这篇文章将基于以下 GitHub 库的内容，可以在这里找到。在云上建立机器学习平台所需的所有命令都可以在 markdown 文件这里中找到。这是基于哈佛大学应用计算科学研究院的一份指导。
环境设置—码头和集装箱
如果你只看了这个帖子的一部分，就让它是这个部分吧。
当人们建立他们的机器学习环境时，通常他们会将所有的东西直接安装在他们的操作系统上。通常情况下，这没什么，然后你试图下载 PyTorch、TensorFlow 或 Keras 之类的东西，所有东西都爆炸了，你花了几个小时在栈溢出上，试图让东西工作。为了你自己，我恳求你不要这样工作。
这个问题通常是由于某些包对其他包的特定版本的依赖性或相互依赖性而产生的。通常，您的工作并不需要这些包中的一半。更合理的做法是从头开始，只安装手头任务所需的版本和依赖项。这将最终节省你的时间和压力。
如果您正在使用 Anaconda，那么将它们分离到隔离的“容器”中是非常容易和有效的，这样它们都可以运行而不会引起问题。这些容器被称为康达环境。Conda 是 Python 的一个包管理器
您可以将这些环境想象成互不知道对方存在的不同计算机。当我创建一个新环境时，我从一张白纸开始，需要再次安装软件包。最重要的是，你不需要两次下载软件包。当你这样做的时候，会创建一个指针，指向你想要安装的软件包的特定版本，这个版本已经下载到你的计算机上了。
这可能看起来毫无意义，除非你以前在你的电脑上有过依赖问题，但是我可以向你保证这是值得了解的。另一个有用的特性是，你可以在一行中安装所有你喜欢的包，只需使用 YAML(。yml)文件。这是一个文件，它告诉环境您想要安装什么包以及需要下载什么依赖项。您不需要编写这个文件，它可以用一行代码从您已经拥有所有必需的包的环境中导出——非常简洁，对吗？所有需要的命令都显示在下面的要点中。
Example of Linux commands to easily create new environments and dependency files.
下面是运行conda env export > environment.yml命令时 YAML 文件的样子。
将事物分成这样的环境还有另一个很好的理由。如果我想得到我正在做的数据分析的可再现的结果，它可能广泛地依赖于不同包的版本以及你正在工作的操作系统。通过创建包含所有依赖项的 environment.yml 文件，别人可以更容易地重现您的结果。
那么我们在创建康达环境的时候做了什么呢？我们基本上把它和我们系统的其他部分隔离开了。然而，如果我们想要在不仅仅是 Python 包的环境中使用额外的东西呢？在这种情况下，我们使用 Docker 来创建容器。
如果您的应用:
- 使用服务器(例如预载数据的数据库服务器)，以及
- 你想把这个服务器和它的数据以及你的应用程序和它的 Python 环境分发给其他人(比如一个开发伙伴或者一个客户)，
使用 Docker 可以将整个事情“集装箱化”。
在这种情况下，所有这些组件都将封装在 Docker 容器中:
- 应用程序本身，
- 可以运行你的应用程序的 Conda 环境(因此一个兼容的 Python 版本和包)，
- 运行应用程序所需的本地服务器或服务(例如:数据库服务器和 web 服务器)
我承认 Docker 和 containers 背后的概念有点混乱。建立 docker 形象不是一件小事。然而，幸运的是，Jupyter 的人为此创造了 repo2docker 。repo2docker 取一个 GitHub 库，自动制作一个 docker 映像，并上传到 docker 映像库给你。这可以用一行代码来完成。
运行上面的代码后，您应该在终端中弹出一些代码，如下所示:
**Copy/paste this URL into your browser when you connect for the first time,
to login with a token:
http://0.0.0.0:36511/?token=f94f8fabb92e22f5bfab116c382b4707fc2cade56ad1ace0**
只需将 URL 复制并粘贴到您的浏览器中，然后您就可以访问您的 docker 图像并开始工作了！你可以在这里阅读更多关于使用 repo2docker 的内容。
另一个真正有用的东西是活页夹。Binder 建立在 repo2docker 的基础上，提供了一种服务，你可以在其中提供一个 GitHub 库，它给你一个工作的 JupyterHub，你可以在其中“发布”你的项目、演示等。通过点击 ReadMe 部分的链接，可以在 binder 上运行与本教程相关的 GitHub 库。
你可以在这里阅读更多关于使用活页夹的信息。
与 Dask 和 Kubernetes 并行
我们花了很长时间才到达本教程的并行化部分，但是前面的步骤是到达这里所必需的。现在让我们开始使用 Dask 和 Kubernetes。
- Dask——Python 中的并行计算库
- Kubernetes - 一个用于自动化应用程序部署、扩展和管理的开源容器编排系统。
Dask 有两个相关部分:
[1]针对气流等计算进行了优化的动态任务调度。
[2]“大数据”集合，如并行(Numpy)数组、(Pandas)数据帧和列表。
Dask 出现只有几年时间，但由于 Python 在机器学习应用中的流行，它的势头正在逐渐增长。Dask 允许对 Python 应用程序进行扩展(1000 核集群),因此它们的处理速度比普通笔记本电脑快得多。
我建议任何对 Dask 感兴趣的人参考 Tom Augspurger(Dask 的主要创建者之一)的 GitHub 知识库，可以在这里找到。
我们已经讨论了 Dask，Kubernetes 在这里起什么作用呢？如果我们在笔记本电脑上运行 Dask，它允许我们一次将代码分发到多个内核，但它不能帮助我们同时在多个系统上运行代码。我们已经在本地运行了。理想情况下，我们希望在云配置的集群上运行，并且我们希望这个集群能够自我修复——也就是说，我们希望我们的代码能够对故障做出响应，并在需要时扩展到更多的机器上。我们需要一个集群管理器。
Kubernetes 是一个集群管理器。我们可以把它想象成集群的操作系统。它提供服务发现、扩展、负载平衡和自我修复。Kubernetes 认为应用程序是无状态的，可以从一台机器移动到另一台机器，以便更好地利用资源。有一个运行集群操作系统的控制主节点和执行大部分工作的工作节点。如果一个节点(与集群相关的计算机)失去连接或中断，主节点会将工作分配给新的人，就像你停止工作时你的老板会做的那样。
主节点和工作节点由允许其执行任务的几个软件组成。它变得相当复杂，所以我将快速给出一个高层次的概述。
主节点:
- API 服务器，主节点和用户之间的通信(使用 kubectl)
- 调度程序，为每个应用程序分配一个工作节点
- 控制器管理器执行集群级功能，如复制组件、跟踪工作节点、处理节点故障
- etcd 是一个可靠的分布式数据存储，它持久地存储集群配置(在给定时间哪个工作节点在做什么)。
工人节点:
- 码头工人，运行你的集装箱
- 将应用程序的组件打包成一个或多个 docker 映像，并将它们推送到注册表中
- Kubelet，它与 API 服务器对话并管理其节点上的容器
- kube-proxy，它在应用程序组件之间负载平衡网络流量
The configuration of a Kubernetes cluster.
做所有这些都很棒，但是除非我们有 100 台计算机可以利用 Kubernetes 和 Dask 提供给我们的能力，否则这并没有特别大的帮助。
进入云端。
Dask 云部署
如果你想用 Python 运行 Dask 来加速你的机器学习代码，Kubernetes 是推荐的集群管理器。这可以在您的本地机器上使用 Minikube 完成，也可以在 3 个主要的云提供商(Microsoft Azure、Google Compute Cloud 或 Amazon Web Services)上完成。
你可能对云计算很熟悉，因为现在它几乎无处不在。现在，公司将所有计算基础设施都放在云上是非常常见的，因为这可以减少他们在计算设备上的资本支出，并将其转移到运营支出，需要更少的维护，还可以显著降低运营成本。除非您处理的是机密信息或者有非常严格的法规要求，否则您可以在云上运行。
使用云允许您利用几台机器的集体性能来执行相同的任务。例如，如果您正在神经网络上执行超参数优化，并且需要重新运行模型 10，000 次以获得最佳参数选择(这是一个相当常见的问题)，那么如果需要 2 周时间，在一台计算机上运行它将是没有意义的。如果你能在 100 台计算机上运行同样的模型，你可能会在几个小时内完成任务。
我希望我已经很好地解释了为什么您应该使用云，但是请注意，如果您使用非常强大的机器(特别是如果您在使用它们之后没有关闭它们，那么它会变得非常昂贵！)
要在云上设置环境，您必须执行以下操作:
- 建立一个 Kubernetes 集群
- 设置Helm(Kubernetes 的包管理器，它就像是 Kubernetes 集群的自制程序)
- 安装 Dask 。
首先运行以下命令
**helm repo update**
然后
**helm install stable/dask**
详见https://docs.dask.org/en/latest/setup/kubernetes-helm.html。
云上深度学习
有几个有用的工具可用于用 Kubernetes 和 Dask 构建深度学习算法。例如，TensorFlow 可以使用 kubeflow 的tf.distributed放到云上。由于不同的模型可以在每个工作节点上运行，因此并行性可以在网格优化过程中得到广泛应用。例子可以在 GitHub 库这里找到。
你用什么？
对于我自己的研究(我是一名环境科学家)和我的咨询工作(机器学习顾问)，我经常使用 JupyterHub，一个在哈佛的超级计算机 Odyssey 上带有 Dask 的 Kubernetes 集群，或者我将在 AWS 上运行相同的基础设施(对 Azure 或谷歌云没有真正的偏见，我只是先学会如何使用 AWS)。
AWS 上的云部署示例
在这一节中，我将介绍在 AWS 上运行 Dask 的 Kubernetes 集群的设置。您需要做的第一件事是在 AWS 上设置一个帐户，除非您已经有了一个帐户，否则您将无法运行以下代码行。
首先，我们下载 AWS 命令行界面，并用 AWS 提供的私钥对其进行配置。然后，我们使用 brew 命令为 Kubernetes 安装亚马逊的弹性容器服务(EKS)。
**pip install awscli
aws configure
brew tap weaveworks/tap
brew install weaveworks/tap/eksctl**
创建一个 Kubernetes 集群现在简单得可笑，我们只需要运行一个命令，但是您应该指定集群名称、节点数量和您所在的地区(在这个例子中，我在波士顿，所以我选择了us-east-1)然后运行这个命令。
**eksctl create cluster --name=cluster-1 --nodes=4 --region=us-east-1**
现在，我们必须使用以下命令配置集群:
**kubectl get nodes
kubectl --namespace kube-system create sa tiller
kubectl create clusterrolebinding tiller --clusterrole cluster-admin --serviceaccount=kube-system:tiller**
现在我们在集群上设置 Helm 和 Dask
**helm init --service-account tiller**
等待两分钟完成，然后我们可以安装 Dask。
**helm version
helm repo update
helm install stable/dask
helm status agile-newt
helm list
helm upgrade agile-newt stable/dask -f config.yaml
helm status agile-newt**
更多的 Kubernetes 命令。
**kubectl get pods
kubectl get services**
要了解更多细节和 shell，您需要一个类似这样的命令。你们确切的豆荚名称会有所不同。
**kubectl get pod agile-newt-dask-jupyter-54f86bfdd7-jdb5p
kubectl exec -it agile-newt-dask-jupyter-54f86bfdd7-jdb5p -- /bin/bash**
一旦您进入集群，您就可以克隆 GitHub 存储库并观看 Dask 运行了！
卡格尔·罗斯曼竞赛
我建议一旦你已经启动并运行了 Dask cloud 部署，你就试着运行一下rossman_kaggle.ipynb。这是来自 Kaggle Rossman 竞赛的示例代码，它允许用户使用他们想要的任何数据来尝试和预测欧洲的药店销售。比赛于 2015 年举行。
本笔记本中的步骤向您介绍了如何为多层感知器设置编码环境，以便将其应用于并行集群，然后执行超参数优化。这段代码中的所有步骤都被分解成函数，然后在 sklearn 管道中运行(这是运行大型机器学习程序的推荐方式)。
存储库中还有其他几个例子，您可以在并行集群上运行并使用它们。此外，可以随意克隆存储库并随意修改。
从哪里可以了解更多信息？
要了解有关 Dask 的更多信息，请查看以下链接:
Dask 教程。在 GitHub 上创建一个帐户，为 dask/dask-tutorial 开发做贡献。
github.com](https://github.com/dask/dask-tutorial) [## Dask - Dask 1.1.4 文档
在内部，Dask 以一种简单的格式对算法进行编码，包括 Python 字典、元组和函数。此图表格式…
docs.dask.org](https://docs.dask.org/en/latest/)
要通过 Kubernetes 了解有关 Dask 的更多信息:
dask 的本地 Kubernetes 集成。创建一个帐户，为 dask/dask-kubernetes 的发展做出贡献
github.com](https://github.com/dask/dask-kubernetes) [## Dask Kubernetes-Dask Kubernetes 0 . 7 . 0 文档
目前，它被设计为从 Kubernetes 集群上的一个 pod 上运行，该集群拥有启动其他 pod 的权限…
kubernetes.dask.org](http://kubernetes.dask.org/en/latest/)
要了解更多关于 Helm 的信息:
[## Kubernetes 和 Helm - Dask 1.1.4 文档
如果不是这样，那么您可以考虑在一个常见的云提供商上建立一个 Kubernetes 集群…
docs.dask.org](http://docs.dask.org/en/latest/setup/kubernetes-helm.html)
如果您正在努力完成上述任何步骤，有多个其他演练可以更详细地介绍具体细节:
[## 将 Dask 和 Jupyter 添加到 Kubernetes 集群
在本文中，我们将在运行于 AWS 上的 Kubernetes 集群上设置 Dask 和 Jupyter。如果你没有…
ramhiser.com](https://ramhiser.com/post/2018-05-28-adding-dask-and-jupyter-to-kubernetes-cluster/) [## 在 Jetstream 上的 JupyterHub 旁边的 Kubernetes 中设置私有 dask 集群| Andrea Zonca 的博客
在本帖中，我们将利用 Pangeo 社区提供的软件让 Jupyterhub 的每个用户…
zonca.github.io](https://zonca.github.io/2018/06/private-dask-kubernetes-jetstream.html)
要在 Google Cloud 上设置集群(遗憾的是找不到微软 Azure 的集群),请查看以下链接:
实验性 docker-compose 设置，用于引导分布在 docker-swarm 集群上的程序。-ogrisel/docker-分布式
github.com](https://github.com/ogrisel/docker-distributed) [## 哈默实验室/dask-分布在库伯内特河畔
使用 kubernetes-hammer lab/dask-distributed-on-kubernetes 在 google 容器引擎上部署 dask-distributed
github.com](https://github.com/hammerlab/dask-distributed-on-kubernetes/)
现在，您应该有一个工作的并行集群，可以在其上对大数据或大计算任务执行机器学习！
感谢阅读！🙏****
使用 SQL 的机器学习
这篇文章是关于 SQL 的机器学习。构建/运行数据保留在数据库中的机器学习模型是有意义的。如何开始的分步信息。
Oracle HQ. Source: Pixabay
Python(以及即将推出的带有 TensorFlow.js 的 JavaScript)是机器学习的主导语言。SQL 呢？有一种在 SQL 中建立/运行机器学习模型的方法。在数据库附近运行模型训练可能会有好处，因为数据会保存在数据库中。借助 SQL，我们可以利用现成的强大数据分析功能，运行算法，而无需向外部获取数据(从性能角度来看，这可能是一项昂贵的操作，尤其是对于大型数据集)。这篇文章将描述如何使用 SQL 在数据库中进行机器学习。
我将使用运行在 Oracle 云自由层的 Oracle 自治数据库。Oracle DB 提供了对机器学习的现成支持。最近，Oracle 推出了 Oracle 云免费层，其中包括数据库。这意味着我们可以免费运行它，也可以用于生产。
设置
进入 Oracle 云控制台后，转到自治数据仓库，在那里您可以创建包含 ML 功能的始终免费的数据库实例:
为了能够访问 ML 环境，请确保设置 ML 用户。为此，转到云控制台中的数据库实例并选择服务控制台选项:
然后转到管理部分，选择管理 Oracle ML 用户选项:
在这里，您可以创建一个新用户(我们将使用该用户登录 Oracle ML notebook)。这是数据库用户，这意味着将创建具有相同名称的数据库模式，我们可以使用相同的凭据直接登录数据库:
为了能够通过 SQL Developer 或另一个客户端直接登录(有用，当需要进行数据预处理时)，选择数据库连接选项并下载客户端凭证:
用 SQL Developer 连接到 DB，创建表 PIMA_INDIANS_DIABETES(在此阅读更多关于 Pima Indians 糖尿病数据集)。通过运行我的 GitHub repo 中的 SQL 脚本为这篇文章填充数据:
让我们打开 Oracle ML 笔记本。返回 Oracle Cloud console for Autonomous Data Warehouse 并选择开发部分。在此部分，单击 Oracle ML SQL 笔记本:
下一步，它将要求输入用户名/密码。在这里，您应该提供与之前几个步骤中创建的相同的 ML 用户信息(我使用的是用户 REDSAM):
机器学习
甲骨文机器学习主页。点击笔记本，这将导航到创建新笔记本的表格:
创建新笔记本—皮马印第安人糖尿病:
转到笔记本。在 notebook 中，您可以访问相同的数据库模式，就像您从数据库客户端连接并上传数据的模式一样。从技术上讲，您可以直接从 SQL 客户端构建 ML 模型。Oracle ML notebook 提供了更好的用户体验。
在第一步中，让我们从表中获取数据，以确保我们可以访问 DB 模式并查看数据:
接下来，为测试和训练数据集创建 DB 表，您可以从主表直接将数据提取到这些表中:
在运行训练和构建模型之前，建议清理以前训练的模型(如果有):
在这里，我们使用决策树算法来训练模型。指向包含训练数据的表，运行 PL/SQL 函数— CREATE_MODEL ，模型将在后台为您构建:
模型元数据存储在生成的数据库表中:
将预测列添加到测试表中，这是存储预测结果的位置:
使用训练好的模型运行预测函数，结果将存储在预测列中:
我们可以通过将预测值与测试数据集中的实际值进行比较来计算预测精度:
混淆矩阵—这有助于快速了解模型质量:
Oracle 机器学习 SQL 笔记本和数据在我的 GitHub repo 上有。
R 中“糖尿病”数据集的机器学习
用 KNN、逻辑回归和决策树进行分类
受 Susan Li 关于在 Python 中应用基本机器学习技术的文章的启发，我决定在 r 中实现相同的技术。此外，我希望对为什么每种方法都有用以及它们如何相互比较进行一些解释。
以下所有分析均使用 Pima Indians 糖尿病数据集，可通过以下方式在 R 中访问该数据集:
install.packages("mlbench")
library(mlbench)
data(PimaIndiansDiabetes)
# Some of the exact variable names may vary from my subsequent code
总体而言，该数据集由 9 个变量的 768 个观察值组成:8 个变量将用作模型预测值(怀孕次数、血糖浓度、舒张压(mm Hg)、三头肌皮褶厚度(mm)、2 小时血清胰岛素测量值、体重指数、糖尿病谱系函数和年龄)和 1 个结果变量(患者是否患有糖尿病)。
k 近邻
我们将首先应用 k-最近邻法，根据患者与其他患者的相似性对患者进行分类。对于这种方法(以及所有后续方法)，我们将从将数据集分为“训练”和“测试”集开始。我们将基于训练集上预测器和结果之间的关系来构建我们的模型，然后使用模型的规范来预测测试集上的结果。然后，我们可以将我们的预测结果与测试集的实际糖尿病状态进行比较，从而为我们提供模型准确性的度量。在我的练习中，我将使用caTools包中的sample.split函数。
An illustration of how the number of neighbors affects the class of a test case. Using the 3 nearest neighbors (solid line) results in a different class than using the 5 nearest neighbors (dashed line). By Antti Ajanki AnAj — [https://commons.wikimedia.org/w/index.php?curid=2170282](http://By Antti Ajanki AnAj - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=2170282)
对于 k-最近邻，我们通过将每个测试案例与训练集中的“最近邻”进行比较来计算该案例的结果。分配的结果取决于您决定查看这些邻居中的多少个；三个最近邻的多数类可能不同于五个最近邻的多数类(见左图)。
为了确保我们使用一个给出更好模型性能的数字来表示 k，我进行了两部分交叉验证。首先，我将 k 的可能值从 2 变为 10；第二，我重复了 100 次将数据分割成训练集和测试集，以确保对每个 k 的模型性能的稳健估计。我使用了class包中的knn函数，并在测试集上计算了每个折叠的模型精度。
all_test_accuracies_knn <- matrix(nrow=100,ncol=9)
for (split_number in c(1:100)){
train_ind <- sample.split(diabetes$Pregnancies,SplitRatio = 0.8)
test_ind <- !train_ind
neighbors <- c(2:10)
accuracies <- matrix(nrow=1, ncol=9)
for (n_neighbors in neighbors){
knn_fit <- knn(diabetes[train_ind,],diabetes[test_ind,],diabetes$Outcome[train_ind],k=n_neighbors)
cm <- table(Actual = diabetes$Outcome[test_ind],Predicted = knn_fit)
accuracy <- sum(diag(cm))/sum(test_ind)
accuracies[n_neighbors-1] <- accuracy
}
all_test_accuracies_knn[split_number,] <- accuracies
}
KNN model performance accuracy for varying values of k. Black line indicates mean of all 100 folds for each value of k; grey ribbon indicates standard deviation.
从这个分析中，我们可以看到 k-最近邻对于稍微更大的 *k，*值表现得更好，性能达到大约 73%的最大分类准确度。尽管根据确切的数据分割仍然存在一些差异，但是使用 9 或 10 个邻居似乎可以在测试集上产生相当稳定的模型估计。
逻辑回归
接下来，我们将应用机器学习工具集的另一个基本工具:回归。对于这个数据集，我们预测二元结果(糖尿病诊断)，我们使用逻辑回归而不是线性回归(预测连续变量)。同样，我将通过反复将数据分成不同的训练集和测试集来交叉验证逻辑回归模型。
all_test_accuracies_logistic <- matrix(nrow=100,ncol=1)for (split_number in c(1:100)){
train_ind <- sample.split(diabetes$Pregnancies,SplitRatio = 0.8)
test_ind <- !train_ind
logit_fit <- glm(Outcome ~ ., data=diabetes[train_ind,], family="binomial")
p <- predict(logit_fit,diabetes[test_ind,],family="binomial")
probs <- exp(p)/(1+exp(p))
test_outcomes <- probs>0.5
cm <- table(Actual = diabetes$Outcome[test_ind],Predicted = test_outcomes)
accuracy <- sum(diag(cm))/sum(test_ind)
all_test_accuracies_logistic[split_number] <- accuracy
}
Histogram of model accuracy for each of the 100 folds of logistic regression. Mean (red) ± standard deviations (blue) for the KNN approach with k=9 is also shown.
在所有折叠中，我们实现了 77%的平均模型准确性，性能范围从 67–84%不等，具体取决于准确的训练-测试划分。在这个数据集上，逻辑回归似乎比 k-最近邻更准确，即使选择了最优的 k (将填充分布与显示 KNN 近似最优分布的垂直线进行比较)。
决策图表
遵循与选择逻辑回归而不是线性回归相同的逻辑，我们将构建一个分类树而不是回归树。决策树构建了数据分离的“节点”,最终以“叶子”结束，这些叶子给出了模型的指定类别。在这里，我再次实现了 100 倍的训练测试分裂，然后将每个预测值分配给一个输出矩阵，以比较各倍之间的变量重要性。
all_dtree_importance <- matrix(nrow=8,ncol=100)
bucketsize <- 10
for (split_number in c(1:100)){
train_ind <- sample.split(diabetes$Pregnancies,SplitRatio = 0.8)
test_ind <- !train_ind tree <- rpart(as.factor(Outcome) ~ ., data = diabetes[train_ind,],minbucket=bucketsize, model=TRUE)importance <- t(tree$variable.importance)
importance <- importance/sum(importance)
all_dtree_importance[1,split_number] <- importance[,"Glucose"]
all_dtree_importance[2,split_number] <- importance[,"BMI"]
all_dtree_importance[3,split_number] <- importance[,"Age"]
all_dtree_importance[4,split_number] <- importance[,"Insulin"]
all_dtree_importance[5,split_number] <- importance[,"DiabetesPedigreeFunction"]
all_dtree_importance[6,split_number] <- importance[,"Pregnancies"]
all_dtree_importance[7,split_number] <- importance[,"BloodPressure"]
all_dtree_importance[8,split_number] <- importance[,"SkinThickness"]
}
该数据集的示例树如下所示:
One of the classification trees for the diabetes data set. At each leaf, the top number and leaf color indicates the assigned class (blue: 0, green: 1). The overall importance of blood glucose levels, BMI, and age are all readily apparent, one of the advantages of classification trees over other methods.
Mean importance of each predictor (% of model) ± standard deviation, across 100 splits of the data.
在决策树中，血糖始终是树中最重要的变量(>模型的 40%)，其次是身体质量指数和年龄，占 10-15%，其余变量的贡献小于 10%。总的来说，决策树模型的准确率在 74–75%左右。
随机森林
与上面使用的简单决策树相反，随机森林聚集了多个去相关的决策树，以便产生预测。当构建每组决策树时，在每次分裂时，仅选择预测器的样本作为分裂候选，而不是允许树从所有可能的预测器中进行选择。因此，每个单独的树不太可能选择与其他树相同的分割。在我在这里使用的randomForest函数的情况下，每次分割时可以选择的预测值的默认数量是floor(ncol(x)/3)，或者 2。
for (split_number in c(1:100)){
train_ind <- sample.split(diabetes$Pregnancies,SplitRatio = 0.8)
test_ind <- !train_ind rf <- randomForest(as.factor(Outcome) ~ ., data = diabetes[train_ind,],ntree=100)
train_accuracy <- sum(diag(rf$confusion))/sum(train_ind)
cm <- table(predict(rf,diabetes[test_ind,]),diabetes$Outcome[test_ind])
test_accuracy <- sum(diag(cm))/sum(test_ind)
all_train_accuracies_rf[split_number] <- train_accuracy
all_test_accuracies_rf[split_number] <- test_accuracy
importance <- rf$importance/sum(rf$importance)
all_importances_rf[split_number,1] <- importance["Glucose",]
all_importances_rf[split_number,2] <- importance["BMI",]
all_importances_rf[split_number,3] <- importance["Age",]
all_importances_rf[split_number,4] <- importance["Insulin",]
all_importances_rf[split_number,5] <- importance["DiabetesPedigreeFunction",]
all_importances_rf[split_number,6] <- importance["Pregnancies",]
all_importances_rf[split_number,7] <- importance["BloodPressure",]
all_importances_rf[split_number,8] <- importance["SkinThickness",]
}
Three examples of trees created using the random forest algorithm.
与上面的简单树分类方法相比，在随机森林模型中，每个变量的重要性分布更加均匀。虽然葡萄糖仍然是模型中最重要的因素，但在随机森林中，它仅占模型的 25%。这是直观的，因为随机森林改进决策树的方式之一是通过使每个树不太可能使用相同的(最强的)预测变量(在这种情况下，葡萄糖水平)作为树中的第一次分裂来使袋装树彼此去相关。
总的来说，这种方法相对于交叉验证的决策树也只提供了一点点(但可能仍然有意义)的改进。简单决策树的平均准确率为 74%，范围为 65–82%，而随机森林模型的平均准确率为 76%，范围为 68–82%。因此，正如预期的那样，随机森林方法产生了更健壮、不变的结果。
梯度推进
最后，我们将对数据采用另一种集成学习方法:梯度推进。通常，梯度推进指的是迭代地将模型拟合到先前模型的残差，从而提高整体模型拟合。梯度增强通过连续地将更复杂的树逐渐拟合到数据，并使用前一棵树的残差作为后续树的指导，来“增强”分类的决策树模型。这里的梯度是指通过梯度下降来解决最小化的问题，也就是找到你当前值处的梯度，沿着梯度递减的方向。
install.packages("gbm")
library(gbm)all_gb_accuracies <- matrix(nrow=100)
all_gb_relative_inf <- matrix(nrow=100,ncol=8)
for (split_number in c(1:100)){
train_ind <- sample.split(diabetes$Pregnancies,SplitRatio = 0.8)
test_ind <- !train_ind gb <- gbm(Outcome ~ ., data = diabetes[train_ind,], distribution = "bernoulli")
vals <- predict.gbm(gb, diabetes[test_ind,],n.trees=100)
probs <- exp(vals)/(1+exp(vals))
class1 <- probs>0.5
cm <- table(class1,diabetes$Outcome[test_ind])
gb_accuracy <- sum(diag(cm))/sum(test_ind)
all_gb_accuracies[split_number] <- gb_accuracy
s <- summary.gbm(gb,plotit = FALSE)
all_gb_relative_inf[split_number,1] <- s$rel.inf[s$var=="Glucose"]
all_gb_relative_inf[split_number,2] <- s$rel.inf[s$var=="BMI"]
all_gb_relative_inf[split_number,3] <- s$rel.inf[s$var=="Age"]
all_gb_relative_inf[split_number,4] <- s$rel.inf[s$var=="Insulin"]
all_gb_relative_inf[split_number,5] <- s$rel.inf[s$var=="DiabetesPedigreeFunction"]
all_gb_relative_inf[split_number,6] <- s$rel.inf[s$var=="Pregnancies"]
all_gb_relative_inf[split_number,7] <- s$rel.inf[s$var=="BloodPressure"]
all_gb_relative_inf[split_number,8] <- s$rel.inf[s$var=="SkinThickness"]
}
我们再次看到，葡萄糖水平是决定糖尿病诊断的压倒性主要因素。在这种情况下，最不重要的变量(胰岛素、血压和皮肤厚度)被最小化，甚至比以前的模型更大。总体而言，梯度增强模型的表现略好于随机森林，平均分类准确率为 76%,范围为 68–83 %,相对于随机森林总体提高了约 0.6%。
机器思维、运输和设计的未来
秋千
在我们这个快速发展的以数字为中心的世界里，我经常陷入一个陷阱，把设计当成最新的光鲜亮丽的应用程序或闪亮的消费电子产品。人们很容易忽略这样一个事实:设计和人类一样古老；我们作为一个物种的古老而固有的一部分。
简单地说，设计是对思想、材料或技术的成功安排，以朝着一个目标前进。我们都这样做，设计我们的时间表，家庭和假期。我们有意识和无意识地设计，经历迭代和自我批评，朝着我们的目标不断优化。
在帮助企业的过程中，我经常被问到“什么是好的设计？”可以理解的是，有必要对其进行量化、衡量并确立价值。随着时间的推移，我开始认为好的设计展示了四种不同程度的可量化的品质。我喜欢用不起眼的挥杆作为这些品质多功能性的例子。
Source: https://en.wikipedia.org/wiki/File:MoSchaukel.jpg
- 好的设计是永恒的**。**我想任何时代的人看到一个秋千，都会知道它到底是干什么的。设计本身不需要改变就能继续有效。这是基础技术和它们所采用的形式的完美结合。
- 好的设计是功能性的。没有人怀疑秋千的功能。它显然实现了让人类一次又一次挑战重力的惊人目标。太神奇了。
- 好的设计就是**美。**可能是最不可量化的。漂亮的设计往往是每个人都认同的东西，而没有说服力。我发现大多数秋千都很漂亮。如果你仔细想想，我想你会同意的。
- 好的设计是个人的。这里的挥杆很出色。这个座位几乎适合任何人。您可以改变链条的长度来调整高度。感觉它就在你身边。我们围绕好的设计创造记忆和情感。
圆桌会议
下一个适时的话题是设计过程。我们如何设计？我们如何一起设计？
随着设计思维成为商业培训的主流部分，设计过程显然变得流行起来。敏捷和精益是设计思维的近亲——导致这种感觉，即理解我们的客户或用户，然后合作解决问题和潜在的解决方案是超现代的商业实践。需要训练的东西。
Source: https://en.wikipedia.org/wiki/File:King_Arthur_and_the_Knights_of_the_Round_Table.jpg
然而，设计过程并不新鲜。这是我们的根本。从本质上来说，我们寻求解决问题，数千年的进化让人类擅长于互相讲述故事，并一起努力实现共同的目标。亚瑟王和圆桌骑士的传说是这样的例子，将不同技能的团队聚集在一起，并对准一个共同的北极星是一个强大的获胜策略。
从本质上来说，设计过程始终是关于在谈判桌上拥有正确的技能组合，创造允许这些技能组合拥有共同语言的仪式，并利用工具最大限度地发挥在给定媒介中解决问题的潜力。今天我们用的是设计思维、敏捷、精益，以及曾经流行又好玩的设计冲刺。
基本原则
任何一个做过设计师的人都知道，提出一个解决方案往往需要一些解释。设计从根本上来说是一种变革的媒介。改变往往需要努力。
我们自然会抵制变化，因为它会引发一种未知感。记住这种抵抗只是一种基本的人类生存机制是有好处的。通过冷静的推理和公开的演示，大多数人会很容易地看到一个设计良好的解决方案的好处和价值。
Source: https://en.wikipedia.org/wiki/File:Darwin%27s_finches_by_Gould.jpg
我不确定我是什么时候意识到这一点的，但是产品设计其实只有两件事。
- 新产品或新功能的创造。
- 对现有产品或功能的重新设计或改进。
无论哪种情况，都是关于改变。
容量
当我们缩小历史，看看我们不断设计的总体效果，我们看到所有这些变化对一个可测量的价值有重大影响。这个价值就是我们维持人口的承载能力。
早期人类历史
在人类历史的前 95%中，大约 20 万年，我们的人口增长相对缓慢。我们大部分的时间和精力都花在了从一个地方搬到另一个地方，寻找食物和生存上。到早期人类历史末期，全球人口约为 200 万。
农业革命
大约一万年前，我们开始学习如何耕作。这使得有更多的时间来解决其他问题，如建造房屋结构。这使我们有能力维持比以前快得多的人口增长。到 1750 年，全球人口达到 7 亿。
工业革命
通过技术和制造业的快速发展，我们看到世界人口以前所未有的速度增长。从工业革命开始到现在，在不到 200 年的时间里，我们的人口增长了 10 倍以上，达到 77 亿。
当我们解决新类型的问题时，我们增加了维持人口的能力。显然，单纯用人口来衡量我们设计的解决方案的价值是有局限性的。希望这种测量方法能让我们看到，当与我们的生物编程相结合时，我们设计解决方案的内在驱动力会产生深远的影响，从而延续我们的物种。
改变
在上面概述的更广泛的革命中，有一些更小的转变构成了一个特定的时期。例如，农业革命跨越了石器时代、青铜时代和铁器时代。事后来看，这些时间段很容易看到和分类。
纵观我们当前的工业革命，我们显然已经进入了一个由计算机、软件和数字技术的出现所主导的时代。我们可以称之为计算时代或信息时代。但是，要预测什么时候会发生足够多的变化，让我们处于一场新革命的风口浪尖，要困难得多，也许是不可能的。
我之前写的关于承载能力的原因是为了表明技术允许我们维持和增加人口。从农业到城市化再到资本主义，这些冒险帮助我们刺激人口增长。
那么计算时代是如何影响人口增长的呢？客观地说，在过去的 50 年里，全球人口增加的数量超过了人类历史上 20 万年的总和。我们能够使用数字技术来自动化曾经需要大量手工工作的流程，这极大地提高了我们的承载能力。
随着我们对计算时代的深入挖掘，看起来我们在这方面只会越来越快。在过去的 20 年里，企业已经将战略从“数字优先”转向“移动优先”。现在，随着机器学习、自然语言处理和语音界面的成熟，我们正在进入向人工智能优先的转变。
人工智能第一
回想一下设计、过程和基础——使用一组给定的技术和工具，围绕着解决特定类型问题的设计过程，有一些词语和通用词汇是很有帮助的。亚瑟用的是圆桌，现代商业用的是设计思维。
设计思维通过以客户为中心的视角解决问题是有意义的。但是，这些过程和工具会帮助我们提高机器理解人类并为我们构建解决方案的能力吗？
最近我一直在探索下面的想法。
计算设计的前 40 年产生了一个叫做设计思维的过程。下一个 40 年将需要机器思维，以实现设计运输。
机器思维
机器思维是人类用来教机器如何朝着设计目标前进的一套方法和文化。
传统上，在现代产品开发中，你可能会发现一个由产品经理、产品设计师和应用或产品工程师组成的核心团队。在 A.I. First 模型中，我们需要添加一名机器学习工程师和一名机器学习研究员。
与传统的产品开发流程不同，该团队的工作将不再以人类(或用户)的需求为中心，而是专注于为机器创建算法和路径，以进行学习并基于学习进行输出。
在机器思维中，我们正在为机器设计一套交互模型，以学习、输出并与人类(或其他机器)交互，具有潜在的无限变化和结果。
作为设计师，我们自然会关注工作中最细微的细节。但是在人工智能第一模型中，我们不知道许多细节。机器思维不太强调设计输出的完美性，而更强调设计系统的健壮性。
我鼓励团队在他们的周期中花更多的时间来创建强大的系统图，不可知的接口，概述交互模型。在机器思维中，这变得更有价值。
一个简单的机器思维练习:能够解决最大数量的已知事务的最少数量的组件(交互或接口)是什么？
运输工具
设计传达是将抽象的人类直觉解构为可以有机自我延续的可教结构的能力。
目前，世界各地都有人工智能团队在教机器如何设计时装、创作音乐、写诗歌和散文。虽然产出远非完美，但它正以令人难以置信的速度前进。在这一点上，机器越来越擅长写假文章，以至于它们的文章很容易被误认为是人类写的新闻。人工智能生成的人的图像看起来像真实的人的照片，我们会假设他们真的存在。
这些例子的潜力既令人兴奋又令人恐惧。然而，它们仍然需要大量的人工设置和开发，并且只能产生非常特定的输出。换句话说，人类仍然需要为机器定义具体的问题，机器可以被教会设计解决方案。
但是，如果机器可以被教会在没有我们的情况下识别问题，并独立地创建那些解决方案，那会怎么样？他们能比人类更快更好地发现和解决问题吗？如果机器正在解决一切，那么我们作为未来人类的角色会是什么？
认知产品
认知产品:为与人类行为紧密相关的指数学习而设计的产品——贾斯汀·雷利@贾斯汀·雷利
我以前的同事和朋友贾斯汀·雷利(Justin Reilly)对我转向人工智能优先的想法产生了重大影响。他对认知产品的定义很重要，因为它概述了两个关键因素:1)指数学习和 2)与人类行为的深层联系。
我相信，随着我们在机器思维方法论上的成熟，以及我们在设计传达上的能力的提高，那个认知产品将会像一个网站一样成为桌面上的赌注。我们通过任何接触点交互的所有信息都将具有一定的智能水平，这使它比当今最流行的软件和硬件具有明显的优势。
我们已经看到了那些首先转向人工智能的公司的性能优势。网飞是一个明显的受欢迎的软件例子，它擅长以一种与我们的行为密切相关的方式学习和呈现信息。我已经尽了自己最大的努力反对自己的最佳判断。
《华尔街日报》最近关于堡垒之夜的这篇文章引起了我的兴趣和警惕。我第一次听说这个游戏是通过我 6 岁的儿子兴奋地模仿他那些沉迷于这个游戏的大朋友们做“轻拍”和“牙线”的动作。我和大多数父母一样，认为这是孩子们喜欢的最新无害的电子游戏。但《华尔街日报》的文章概述了堡垒之夜的一些不同之处。凭借其庞大的在线用户群和机器学习，堡垒之夜正在不断提高玩家的参与度。它在一个完全不同的层面上争夺孩子们的注意力。
像许多视频游戏一样，玩堡垒之夜的人越多，关于什么最吸引玩家以及什么促使玩家退出的数据就越多。源源不断的信息流增强了游戏设计师使用机器学习来增强玩家参与度的能力。
随着游戏变得越来越智能，家长们感到被超越了。“这是一场不公平的斗争，”儿童和青少年心理学家、《网络儿童:在数字时代重塑童年》一书的作者理查德·弗里德博士说。
对一些人来说，堡垒之夜就像一个不速之客，一个拒绝离开的人。
然后
在引擎盖下，人工智能第一产品将展示 4 个设计特征。
- 强化学习
- 永远在线
- 接口不可知
- 物理和数字之间模糊的界限
Source: https://en.wikipedia.org/wiki/File:Duck_of_Vaucanson.jpg
网飞和堡垒之夜的例子证实了我的信念，即人工智能已经在我们面前，先行者正在取得胜利。这也让我相信，最初走向人工智能优先的趋势不会看起来和感觉上有明显的不同，但认知产品的表现将优于前几代计算设计。
当我们展望未来的设计时，先进技术带来的难以置信的可能性给了我灵感。我也深深意识到伴随着这些现代工具的力量而来的责任。比以往任何时候都更重要的是，作为一个物种，我们要学会并优先考虑对我们真正有价值的东西。
这就是为什么我强烈主张在认知产品的创作中要有多样化的团队和思想的很大一部分原因。只有通过合作和包容性的工作，我们才能找到适用于人工智能第一世界中几乎无限规模的解决方案。随着算法产生莎士比亚和贝多芬的新作品，我们不仅要教会机器，还要教会我们自己，这对人类意味着什么，这将变得越来越重要。
机器翻译:概述
这个故事是机器翻译领域的概述。这个故事介绍了几个被高度引用的文献和著名的应用，但是我想鼓励你在评论中分享你的观点。这个故事的目的是为这个领域的新手提供一个良好的开端。它涵盖了机器翻译的三种主要方法以及该领域的几个挑战。希望故事中提到的文献能够介绍这个问题的历史以及最先进的解决方案。
机器翻译是将文本从源语言翻译成目标语言的任务。机器翻译有许多具有挑战性的方面:1)大量不同的语言、字母和语法；2)对计算机来说，将一个序列(例如一个句子)翻译成一个序列比只处理数字更难；3)没有一个正确答案(如:从没有性别依赖代词的语言翻译过来，他和她可以相同)。
机器翻译是一项相对古老的任务。从 20 世纪 70 年代开始，就有了实现自动翻译的项目。多年来，出现了三种主要方法:
- 基于规则的机器翻译(RBMT):20 世纪 70-90 年代
- 统计机器翻译:20 世纪 90 年代至 2010 年代
- 神经机器翻译(NMT): 2014-
Photo by Gerd Altmann on Pixabay
基于规则的机器翻译
基于规则的系统需要专家对源语言和目标语言的知识来开发句法、语义和词法规则以实现翻译。
RBMT 的维基百科文章包括一个从英语到德语的基于规则的翻译的基本例子。翻译需要一本英德词典、一套英语语法规则和一套德语语法规则
RBMT 系统包含一系列自然语言处理(NLP)任务，包括标记化、词性标注等等。这些工作中的大部分都必须用源语言和目标语言来完成。
RBMT 的例子
SYSTRAN 是历史最悠久的机器翻译公司之一。它可以翻译大约 20 种语言。SYSTRAN 用于阿波罗-联盟号项目(1973 年)和欧洲委员会(1975 年)[1]。它一直被谷歌的语言工具使用到 2007 年。更多信息见其维基百科文章或该公司的网站。随着 STM 的出现，SYSTRAN 开始使用统计模型，最近的出版物显示他们也在试验神经方法[2]。OpenNMT 工具包也是该公司研究人员的一项工作[3]。
Apertium 是根据 GNU 通用公共许可证条款发布的开源 RBMT 软件。它有 35 种语言版本，目前仍在开发中。它最初是为与西班牙语密切相关的语言设计的[4]。下图是 Apertium 管道的示意图。
Apertium pipeline — Photo by Darkgaia1 on Wikipedia
GramTrans 是一家位于丹麦的公司和一家位于挪威的公司的合作，它为斯堪的纳维亚语言提供机器翻译[5]。
优势
- 不需要双语文本
- 独立于域的
- 全面控制(适用于各种情况的新规则)
- 可重用性(当与新语言配对时，现有的语言规则可以转移)
不足之处
- 需要好的字典
- 手动设置规则(需要专业知识)
- 规则越多，系统越难处理
统计机器翻译
这种方法使用基于双语文本语料库分析的统计模型。它在 1955 年首次被介绍[6]，但是直到 1988 年 IBM Watson 研究中心开始使用它才引起了人们的兴趣[7，8]。
统计机器翻译背后的思想如下:
给定目标语言中的一个句子 T，我们寻找翻译者产生 T 的句子 S。我们知道，通过选择给定 T 最有可能的句子 S，我们的错误机会被最小化。因此，我们希望选择 S 以最大化 Pr(S|T)。
— 机器翻译的统计方法，1990 年。[8]
使用贝叶斯定理，我们可以将这个最大化问题转化为 Pr(S)和 Pr(T|S)的乘积，其中 Pr(S)是 S 的语言模型概率(S 是在该位置的正确句子), Pr(T|S)是给定 S 的 T 的翻译概率。换句话说，我们正在寻找给定候选翻译的正确程度及其在上下文中的适合程度的最可能的翻译。
因此，SMT 需要三个步骤:1)语言模型(给定上下文，什么是正确的单词？);2)翻译模型(给定单词的最佳翻译是什么？);3)寻找单词正确顺序的方法。
在前面的段落中，我们同时使用了句和词作为翻译单位。最常用的模型介于这两者之间。这叫做基于短语的翻译。例如，英语短语“正在购买”在法语中被翻译成“achète”。
Non-factored and factored translation — Figures from Moses: Open Source Toolkit … [9]
SMT 示例
- 谷歌翻译(2006 年至 2016 年间，当他们宣布改为 NMT )
- 微软翻译器(2016 年改为 NMT )
- Moses :统计机器翻译开源工具包。[9]
优势
- 语言学专家更少的手工工作
- 一个 SMT 适用于更多语言对
- 更少的字典外翻译:使用正确的语言模型，翻译更流畅
不足之处
- 需要双语语料库
- 特定的错误很难修复
- 不太适合语序差异大的语言对
神经机器翻译
神经方法使用神经网络来实现机器翻译。与以前的模型相比，NMTs 可以用一个网络而不是独立任务的流水线来构建。
2014 年，序列到序列模型的引入为 NLP 中的神经网络开辟了新的可能性。在 seq2seq 模型之前，神经网络需要一种方法将序列输入转换为计算机可用的数字(一次性编码，嵌入)。有了 seq2seq，用输入和输出序列训练网络成为可能[10，11]。
LSTM based seq2seq model: a) training phase, b) prediction phase
NMT 很快出现了。经过几年的研究，这些模型优于 SMT[12]。随着结果的改善，许多翻译提供商公司将其网络改为基于神经的模型，包括谷歌[13]和微软。
如果训练数据不平衡，神经网络就会出现问题，模型无法从稀有样本和频繁样本中学习。就语言而言，这是一个常见的问题，例如，有许多罕见的单词在整个维基百科中只使用了几次。训练一个不偏向于频繁单词(例如:在每个维基百科页面上多次出现)的模型可能是具有挑战性的。最近的一篇论文提出了一个解决方案，使用一个后处理步骤，用字典翻译这些生僻字[14]。
最近，脸书大学的研究人员引入了一个无监督的机器翻译模型，该模型与 SMT 和 NMT 一起工作，只需要大型单语语料库，而不需要双语语料库[15]。前面例子的主要瓶颈是缺乏大型翻译数据库。这一模式显示了解决这一问题的前景。
NMT 的例子
- 谷歌翻译(从 2016 年开始)链接到谷歌人工智能的语言团队
- 微软翻译(自 2016 年)链接到微软的机器翻译研究
- 脸书的翻译:链接到脸书 AI 的 NLP
- OpenNMT: 一个开源的神经机器翻译系统。[16]
优势
- 端到端模型(没有特定任务的管道)
不足之处
- 需要双语语料库
- 生僻字问题
Translation quality of statistical and neural MT models by Google — Figure by Google
摘要
在这个故事中，我们讨论了解决机器翻译问题的三种方法。许多重要的出版物与重要的应用程序一起收集。这个故事揭示了该领域的历史，并收集了最先进的模型的文献。我希望这对一个刚涉足这个领域的人来说是个好的开始。
如果你觉得缺少了什么，欢迎和我分享！
参考
[1]托马，P. (1977 年 5 月)。 Systran 作为多语言机器翻译系统。第三届欧洲信息系统和网络大会论文集*，克服语言障碍*(第 569–581 页)。
[2] Crego，j .，Kim，j .，Klein，g .，，a .，Yang，k .，Senellart，j .，… & Enoue，S. (2016)。 Systran 的纯神经机器翻译系统。arXiv 预印本 arXiv:1610.05540 。
[3]克莱因、金、邓、塞内拉尔特和拉什(2017 年)。OpenNMT:用于神经机器翻译的开源工具包。 arXiv 预印本 arXiv:1701.02810 。
[4] Corbí Bellot、A. M .、Forcada、M. L .、Ortiz Rojas、s .、Pérez-Ortiz、J. A .、Ramírez Sánchez、g .、Sánchez-Martínez、f .、……和 Sarasola Gabiola，K. (2005 年)。一个开源的西班牙罗曼语浅传机器翻译引擎。
[5] Bick，Eckhard (2007)， Dan2eng:广覆盖丹麦语-英语机器翻译，载于:Bente Maegaard(编。)，机器翻译峰会论文集，XI，10–14。2007 年 9 月，丹麦哥本哈根。第 37-43 页
[6]韦弗，W. (1955 年)。翻译。语言的机器翻译， 14 ，15–23。
[7]布朗，p .，科克，j .，彼得拉，S. D .，彼得拉，V. D .，耶利内克，f .，默瑟，r .，&罗辛，P. (1988 年 8 月)。语言翻译的统计方法。见第 12 届计算语言学会议论文集-第 1 卷(第 71–76 页)。计算语言学协会。
[8]布朗、P. F .、科克、j .、德拉·皮特拉、S. A .、德拉·皮特拉、V. J .、耶利内克、f .、拉弗蒂、J. D .、……和鲁辛，P. S. (1990 年)。机器翻译的统计方法。 计算语言学， 16 (2)，79–85。
[9]科恩，p .，黄，h .，伯奇，a .，卡利森-伯奇，c .，费德里科，m .，贝托尔迪，n .，…，戴尔，C. (2007 年 6 月)。Moses:统计机器翻译的开源工具包。在计算语言学协会第 45 届年会的会议录配套卷演示和海报会议的会议录(第 177-180 页)。
[10] Sutskever，I .，Vinyals，o .，& Le，Q. V. (2014 年)。用神经网络进行序列对序列学习。在神经信息处理系统的进展(第 3104–3112 页)。
[11] Cho，k .，Van merrinboer，b .，Gulcehre，c .，Bahdanau，d .，Bougares，f .，Schwenk，h .，和 Bengio，Y. (2014 年)。使用用于统计机器翻译的 RNN 编码器-解码器学习短语表示。 arXiv 预印本 arXiv:1406.1078 。
[12] Bahdanau，d .，Cho，k .，& Bengio，Y. (2014 年)。神经机器翻译通过联合学习来对齐和翻译。arXiv 预印本 arXiv:1409.0473 。
[13] Wu，y .，Schuster，m .，Chen，z .，Le，Q. V .，m .，Macherey，w .，… & Klingner，J. (2016)。谷歌的神经机器翻译系统:弥合人类和机器翻译之间的鸿沟。 arXiv 预印本 arXiv:1609.08144 。
[14] Luong，M. T .，Sutskever，I .，Le，Q. V .，Vinyals，o .，& Zaremba，W. (2014 年)。解决神经机器翻译中的生僻字问题。arXiv 预印本 arXiv:1410.8206 。
[15] Lample，g .，Ott，m .，Conneau，a .，Denoyer，l .，& Ranzato，M. A. (2018 年)。基于短语的&神经无监督机器翻译。 arXiv 预印本 arXiv:1804.07755 。
[16] Klein，g .，Kim，y .，Deng，y .，Senellart，j .，& Rush，A. M. (2017 年)。Opennmt:用于神经机器翻译的开源工具包。 arXiv 预印本 arXiv:1701.02810 。
用伯特的故事学习 NMT
- BLEU-BERT-y:比较句子得分
- 嵌入关系的可视化(word2vec，BERT)
- 机器翻译:一个简短的概述
- 使用 BERT 识别单词的正确含义
- 机器翻译:与 SOTA 相比
- 使用 TensorFlow 2.0 的简单 BERT
机器翻译:与 SOTA 相比
我之前的故事将 BLEU 描述为机器翻译(MT)最常用的度量标准。这个旨在介绍会议、数据集和竞赛，在那里你可以将你的模型与最先进的进行比较，你可以从那里收集知识，在那里你可以见到来自该领域的研究人员。
Conference — Image by 정훈 김 from Pixabay
MT 特定研讨会
WMT 会议
WMT 会议是 ACL 会议(计算语言学协会年会)的一部分，因此缩写为:机器翻译研讨会。第一次研讨会于 2006 年举行，是 NAACL 的一部分(T2 NAACL-2006 统计机器翻译研讨会)。大约在从统计机器翻译转变为神经机器翻译的时候，会议的名称变成了机器翻译会议。今年的发布会在 2019 年 8 月 1-2 日，意大利佛罗伦萨( WMT19 )。
WMT 每年都会发布翻译任务，最顶尖的模特会在这些任务上展开竞争。2016 年宣布的 GNMT(谷歌的神经机器翻译)使用了 WMT 的 14 个英德和英法数据集来评估其性能[1]。脸书、谷歌、微软和许多其他公司都参与了今年的竞争。
English-German results of the WMT19 News Translation Task
分解车间
DiscoMT 2019 ，第四届机器翻译中的话语研讨会，聚焦话语级机器翻译。它将于 2019 年 11 月 3 日在中国香港举行。它使用与 WMT19 相同的任务，但数据集包括话语级注释。DiscoMT 是 EMNLP(自然语言处理经验方法会议)的一部分。
MT 峰会
第 17 届机器翻译峰会，于 2019 年 8 月 19 日至 23 日在爱尔兰都柏林的都柏林城市大学 Helix 剧院举行。该会议由欧洲机器翻译协会(EAMT)组织。
数据集
一个更长的平行文本数据语料库列表在这里。
- 欧洲议会议事录平行语料库1996–2011[3]:欧洲议会议事录 21 种语言。根据不同的语言有 1100 万到 5000 万个单词。
- 对齐加拿大第 36 届国会的议事录【4】:130 万对对齐的法语和英语文本块
- UN translations【5】:6 种语言(ar、en、es、fr、ru、zh)文本共 44 万个句子片段。****
- 维基百科【6】:从维基百科中提取的 20 种语言的句子，共 2590 万句。
出版物
这一部分试图回答“我应该在哪里发表我的机器翻译论文？”。这些统计数据来自谷歌学术搜索“机器翻译”的前 50 个结果。
下图显示了不同颜色(分别为绿色和橙色)的 ACL 和 EMNLP 相关会议。如我们所见，如果我们看看谷歌学术的结果，ACL 是机器翻译领域最重要的会议。基于 ACL 的会议、出版物:
- ACL:计算语言学协会年会
- EACL: 美国律师协会欧洲分会(EACL)
- NAACL-HLT:美国语言学会北美分会年度会议:人类语言技术
- TACL:《TACL 计算语言学协会汇刊》是由 ACL 主办的期刊由麻省理工学院出版社出版
- WMT:机器翻译会议
- 计算语言学: 计算语言学 由麻省理工学院出版社代表计算语言学协会出版。
Conferences, Journals from the top 50 results of Google Scholar search ‘machine translation’
WMT 提交格式
NIST 在 2012 年组织了一次开放机器翻译评测。他们为机器翻译提交定义了 SGML 格式。此后，这种格式被用作标准提交格式。 WMT19 使用相同的描述进行提交。下面是一个格式示例:
****`<refset trglang=”cz” setid=”test2010" srclang=”any”>
<doc sysid=”ref” docid=”idnes.cz/2009/12/10/74900" genre=”news” origlang=”cz”>
<seg id=”1"> …
... ...
... `****
摘要
在这个故事中，我们总结了机器翻译方面的主要会议、研讨会以及要发表的重要期刊。我们看到了最大的公司竞争的比赛，以及这些比赛提交的标准格式的例子。我们还收集了一些广泛使用的语料库。
参考
[1]吴，y，舒斯特，m，陈，z，乐，Q. V，，m，马切里，w，…和克林纳，J. (2016)。谷歌的神经机器翻译系统:弥合人类和机器翻译之间的鸿沟。 arXiv 预印本 arXiv:1609.08144 。
[2] Barrault，l .，Bojar，o .，Costa-jussà，M. R .，Federmann，c .，Fishel，m .，Graham，y .，… & Monz，C. (2019，8 月)。2019 机器翻译大会(wmt19)的发现。第四届机器翻译会议论文集(第 2 卷，第 1-61 页)。
[3]科恩，P. (2005 年 9 月)。 Europarl:一个用于统计机器翻译的并行语料库。在 MT 峰会(第 5 卷，第 79–86 页)。
[4]德国大学(2001 年)。加拿大第 36 届议会的联合议事录。
[5]a . Rafalovitch 和 r . Dale(2009 年 8 月)。联合国大会决议:六种语言平行语料库。在MT 峰会议事录(第 12 卷，第 292–299 页)。**
[6]沃兹尼亚克和马拉塞克(2014 年)。建立主题对齐的可比语料库并挖掘它以获得真正平行的句子对。 Procedia 技术， 18 ，126–132。
用伯特的故事学习 NMT
- BLEU-BERT-y:比较句子得分
- 嵌入关系的可视化(word2vec，BERT)
- 机器翻译:简要概述
- 使用 BERT 识别单词的正确含义
- 机器翻译:对比 SOTA
- 使用 TensorFlow 2.0 的简单 BERT
机器翻译峰会 2019 印象、总结和笔记—第一部分
几周前，最大的年度 NLP 会议之一在爱尔兰都柏林举行— 机器翻译峰会 2019 ，该会议专注于机器翻译(MT)的研究和应用，这是 NLP 中一个具有挑战性的问题。这一周充满了 MT 研究人员和从业者的数十场讲座、研讨会和指导，总体而言，我认为会议非常精彩。
Home sweet home for a week.
这篇文章总结了我对这次会议的印象，也是我对特定演讲、教程和论文的笔记的一个数据转储:)我将它们公之于众，以防其他人发现它们是一个有用的总结。
注意:我在大会上的经历明显受到我碰巧参加的会议(主要是“研究轨道”会议)的影响，但是为了更全面地了解大会，点击这里查看会议日程。
这篇文章是第一部分，涵盖了会议的第 1 天到第 3 天，而第二部分涵盖了第 4 天和第 5 天。前几天是辅导课和研讨会，而最后三天是讲座和海报。
总结和总体印象
- 随着人工翻译的传统角色继续向编辑机器翻译输出(后期编辑；PE)，而不是从零开始翻译，有很大的兴趣去理解任何与 PE 相关的东西:PE 对整体翻译质量和风格的影响；后期编辑的生产力、工作模式以及与机器翻译的互动；以及这种向 PE 的转变如何影响实际业务中的生产。
- 我们很高兴看到对递归神经网络(RNNs)和基于统计机器翻译(SMT)的机器翻译模型的研究继续进行——尽管 Transformer 模型现在是 MT 架构 à la mode ，但其他方法在特定情况下仍优于 Transformer(例如，SMT 用于小段翻译)，或者可能更容易直观理解。
- 我喜欢探索使用信息而不是文本的工作。使用图像和文本作为翻译模型输入的多模态翻译海报；端到端语音到文本的翻译对话；描述跟踪后期编辑的键盘和鼠标交互的海报；以及在用户与 MT 互动时追踪眼球运动的项目。
- 有相当多的上下文感知机器翻译和话语级现象被提及——我们的标准模型纯粹在句子级别上工作，这忽略了大多数文本存在于段落、章节和文档中的其他文本周围的事实。显式烘焙上下文信息的方法显示出非常有希望的结果。
- 我最喜欢的演讲可能是 Arianna Bisazza 的*“理解多语言神经网络模型中的句法和语义转移”——这非常酷，甚至有可能同时用多种语言训练我们的标准 NLP 模型。*神经网络的可解释性总是令人感兴趣，但在多语言模型中尤其令人感兴趣，这些模型可以捕捉跨语言表示。
- 我最喜欢的海报是…嗯，这是一个平局。首先是的马尔基西奥及其同事的“控制机器翻译输出的阅读水平”。我惊喜地发现，通过在源语句中插入一个简单的标志，可以如此有效地控制 MT 输出的复杂性。其次，还有 Góis & Martins 的“translator 2 vec:理解和表现人类后期编辑”。诚然，我是所有 x 的 x2vec 的粉丝，但看到人类翻译的工作模式来自他们在后期编辑期间与键盘、鼠标和文本的交互序列，这特别酷。
会议第一天—关于“神经模型在语言解码中的不合理效果”的教程
作者 KantanMT
这是一个半天的教程，由 KantanMT(机器翻译平台的提供商)提供。这是一次更实际的会议，是在去年 KantanMT 和易贝之间的一些神经机器翻译(NMT)实现实验之后进行的。一些亮点:
- 客户首先需要具体的证据证明神经翻译模型优于统计翻译模型。对照实验表明，NMT 模型实际上有较低的 BLEU 分数，但母语为英语的评估者更喜欢 NMT 模型。BLEU 度量尤其可以与 NMT 相比较，因为 NMT 可以生成不太字面上流畅的输出，这仍然是很好的，但不一定在 n-gram 级别上紧密匹配参考翻译。
- 下一组实验是比较用于建模翻译的 3 种主要神经架构之间的性能——RNNs(递归神经网络), CNNs(卷积神经网络);更常见于计算机视觉)和 TNNs(变压器神经网络；或者只是变形金刚)。比较的范围很广，包括自动指标(BLEU、TER、METEOR)、人工评估分数以及技术方面，如训练时间、集成和适应/再训练的容易程度。正如你所料，结果是变形金刚更胜一筹。
- 除了确保您有足够的单词/句子对来开始构建 NMT 模型，还应该检查唯一的单词计数，理想情况下应该尽可能高(例如> 100k)。
- 将深度学习框架从 Theano 切换到 OpenNMT 来训练 NMT 模型，导致它们的速度大幅提高。
- 如果可用于域适配的域内数据量很低，他们发现在适配期间简单地添加这些数据的更多副本是有益的。
会议第二天——“后期剪辑深度学习曲线”**
通过本地化
本教程实际上是由我们，Welocalize 的 MT/NLP 工程团队的几个人提出的，所以，我没有太多的笔记:)简而言之，本教程的目的是提供一个关于后期编辑的行业视角——在我介绍了应用 MT 研究的当前状态后，同事们讨论了 NMT 实施的挑战，不同 MT 提供商的利弊，当然还有一切最终如何影响后期编辑过程。
会议第 3 天——会谈
“PEMT 质量监测的众包和相关工具”
作者莫尼斯
会议的开场白也是关于后期编辑的(PEMT= 后期编辑机器翻译 ),演讲者是 Unbabel 的海伦娜·莫尼斯，一家非常时髦的 MT 初创公司。这次演讲更多地关注人的方面，而不是技术方面，并讨论了 un label 如何管理他们的人工翻译——没有单一的“我是一名翻译”标签，而是根据技能、经验和领域将每个翻译分为不同的类别。这意味着当有新任务时，他们可以迅速找到最合适的翻译。
目前有新一代的翻译正在毕业，他们非常清楚并习惯于与机器学习模型一起工作。这意味着气氛更加合作，越来越不像是一场充满敌意的“人工智能与翻译”之战。
演讲中一个非常酷的部分是一个语音信息应用程序的演示，它允许用户用一种语言记录和发送信息，然后自动翻译和语音合成为接收者的首选语言。我可以肯定地看到，一旦这项技术进一步发展，它会变得越来越流行。目前，这一过程有一个手动部分——如果自动翻译看起来质量很低，人工会纠正翻译错误。合成语音目前是通用的，还不能反映说话者独特的语音特征，尽管这一技术目前正在开发中。
“CLIR 在低资源环境下的强大文档表示”
作者:Yarmohammadi 等人 【论文在此】
信息检索 (IR)是关于获取给定查询的正确信息位，而 跨语言信息检索 (CLIR)在多语言设置中做这件事。因此，用户的查询是用不同于数据库中的文档的语言编写的，任务是优雅地进行机器翻译，并获取相关文档，尽管存在语言障碍。作为一个用例，想象一个新闻记者查询外语新闻源来展开她的故事。
这种 CLIR 系统的主要要求是:
- 对机器翻译错误的鲁棒性。即使存在机器翻译错误，也必须为每个查询返回相关文档。
- ***对 ASR 误差的鲁棒性。*如果文档数据库包含语音的音频文件，这些文件必须首先通过自动语音识别(ASR)转换成文本，并且该系统还必须对该步骤中出现的任何错误具有鲁棒性。
- ***面对低资源语言的鲁棒性。*作者在三种低资源(=少量训练数据)语言的背景下考察了 CLIR:索马里语、斯瓦希里语和他加禄语。这三种语言的文档将使用英文查询进行检索。
本文的重点是针对 CLIR 的文档翻译方法(即索马里语、斯瓦希里语和他加禄语文档首先被翻译成英语)，但是其他论文以相反的方式完成了这项任务，即将查询翻译成目标语言。这样做的问题是查询可能很短，所以您很难可靠地找到相关的文档。这种方法被用作基线。
任务输入是英文查询，输出是检索与查询相关的文档。“基本事实”是针对一组查询的人类标记的文档相关性排名。困难的部分是 ASR 和 MT:一旦有了翻译的文档，查询到文档的相关性分数计算和排序就由 Elastic Search 和 Okapi 处理。
大部分工作侧重于评估表示文档的不同方式，以及这如何影响 CLIR 的整体性能。文档的 3 种不同“视图”是:
- ***N-最佳解码。*对于文本文档，MT 生成每个句子的 N 个最佳翻译(对于不同的 N 值)。对于语音文档，ASR 为每个片段生成一个 N 最佳列表，MT 解码器为每个片段生成 M 最佳翻译，从而生成一个 NxM 矩阵。无论是使用整个矩阵还是从中采样，都不会对性能产生太大影响。
- 短语包(BOP)翻译。给定源文本，基于短语的 SMT 系统生成所有可能的翻译短语(没有语言模型；所以，不是完全解码搜索)——所有这些翻译选项连接在一起，形成一个短语包。这种方法为文档表示提供了更多的词汇多样性，例如，您可以获得一个特定单词的 10 种可能的翻译。对于语音文档，ASR 也是开始处理文本的第一步。
- ***以及两者的结合。*您也可以只使用两种表示，N-best translations 和 BOP translation: index，并让搜索功能根据用户查询与任一表示的匹配程度对文档进行评分。
事实证明，用词组袋表示法的词汇多样性来扩充 N-best 列表的更标准的方法执行得最好，并且在所有三种被检查的低资源语言的 CLIR 任务中做得很好。尽管更丰富的文档表示可能更容易出错，但是每个文档拥有尽可能多的信息，并捕捉尽可能多的语言变化，似乎可以得到最好的结果。
“增强端到端语音到文本翻译的转换器”
作者迪甘吉等人 【论文在此】
早期的实时语音翻译系统基于菊花链形式的独立系统，一个语音识别模型生成文本，一个独立的机器翻译模型翻译转录的文本。在这项工作中提出了一种更时尚的方法，该方法采用 Transformer 架构，以允许 端到端语音到文本的翻译 。
作者在本文中研究了 3 种现象:
- ***使用变压器完成该任务。*以前基于 RNN 的端到端语音到文本翻译模型训练速度慢且计算量大。在这里，他们想使用 Transformer，不是因为它新奇，而是因为它更具并行性，而且肯定比基于 LSTM 的方法训练得更快。
- **利用 2D 注意力处理语音数据。他们想在 声谱图 处理阶段使用 2D 注意力(声谱图是一个音频文件的表示，就像一个语音样本，它包含了一段时间内的频率足迹)。使用 2D 注意力将有助于随着时间的推移保持声谱图属性，允许模型利用 2D 依赖性，而不是将所有依赖于时间的信息浓缩在一起。
- 增加局部偏向的自我关注。**当输入语音样本很长时，他们观察到，转换者的自我注意机制会试图关注整个序列长度。这不是很有用，因为结果是模型很难捕捉到短程依赖关系。他们引入了局部偏向的自我注意力，以激励注意力机制将注意力集中在它当前工作的区域附近——他们通过增加一个惩罚来做到这一点，如果注意力偏离矩阵对角线太远。
他们基于变压器的模型确实比 LSTM 的训练速度快得多，但性能却差不多。有趣的结果是，添加局部注意力惩罚确实有助于该语音到文本翻译任务的模型，并且还导致训练期间更快的收敛。增加对 2D 的关注也会导致 BLEU 的增加。最后，作者发现，增加模型的大小可以显著提高性能，这表明他们使用的模型仍然太小(这一特定结果似乎在目前的 ML 工作中很常见)。
第 3 天—主要会议海报
那天剩下的时间都集中在海报上。我特别喜欢的一些海报是:
“原始机器翻译对 Word 的日本用户有什么影响:使用眼球追踪的可用性研究的初步结果”
由阿里纳斯等人著 【论文在此】
这项工作调查了用户对他们使用的软件中的机器翻译内容的感受，具体来说，日本参与者要么看到已发布的人类翻译的 Microsoft Word 日语版本，要么看到机器翻译的日语版本。用户被要求在一个 Word 版本中完成一些任务。除了比较任务完成情况、效率和用户满意度之外，他们的眼球运动也被跟踪，以此作为认知努力的衡量标准。
结果表明，日语使用者的任务完成和效率得分在人工翻译的发布词版本中略高，但不显著。然而，他们自我报告的满意度得分明显更高，这表明与处理人工翻译文本相比，处理原始机器翻译可能是一种不太愉快的体验。
“Translator2Vec:理解和表现人类海报编辑”
由高乃依&马丁斯。 【此处论文】
不同的译者处理后期编辑任务的方式不同。为什么不捕捉不同翻译工作时的动作，并检查数据中的模式和聚类呢？这将有助于识别不同的后期编辑风格，并可能判断哪种更有效。从后期编辑收集动作序列数据，包括按键编辑操作、鼠标动作、等待时间和对实际 MT 文本的更改。收集的数据集相当大——来自 300 多人进行的 66k 次编辑后会话的动作序列。
作者表明，动作序列的信息相当丰富，可以用来准确地识别特定的后期编辑，比只使用 PE 前和 PE 后的文本信息要好。您还可以使用 tSNE 对动作序列数据进行降维，并绘制二维的低维向量表示——这使您可以看到 PE 会话的集群，并观察到每个后期编辑都有自己独特的风格。这些编辑器表示也是后期编辑时间的非常有效的预测器。可悲的是，集群之间在工作风格上没有太多直观可理解的差异，但这仍然是一个非常好的结果。
就应用程序而言，您也可以通过这种方式来衡量后期编辑之间的相似性，或者将此作为后期编辑培训工具的一部分——例如，发现给定的工作方式是否与低生产率有关，或者检测您的会话是否不靠近任何群集，这可能意味着您的工作流程与其他翻译人员有很大不同。这是他们论文中的一个很好的图表，展示了英语-德语和英语-法语体育课的 tSNE 图:
这显示了编辑后会话日志对编辑后身份的预测性。
“为资源不足的 NMT 模型利用基于规则的机器翻译知识”
作者托雷格罗萨等人 【论文在此】
神经机器翻译可能会给出令人惊讶的好结果，但它在很大程度上依赖于足够数量的可用训练数据。根据定义，低资源语言对没有太多的并行数据，在这种情况下，使用老式的、手写的、基于规则的机器翻译(RBMT)的元素会非常有帮助。
这项工作试验了利用 RMBT 系统中包含的语言信息的不同方法，以便在低资源环境中改进 NMT 模型。关键的结果是，使用来自基于规则的机器翻译的形态学信息(以词性(POS)标签、依存标签和句法树信息的形式)的特征丰富，在添加到 NMT 系统时，在提高性能方面是有效的。有趣的是，观察到的提升性能类似于使用子词标记化带来的提升。
“斯拉夫语言的形态学神经前处理和后处理”
作者贝尔纳迪内洛 【论文在此】
斯拉夫语(俄语、捷克语、波兰语、保加利亚语等。)形态丰富——词序相当灵活，词的功能由几十种不同的语言形式表示。以下是他们论文中的一些捷克变调例子:
And this is just the start of it.
因此，斯拉夫语的 NMT 系统面临着拉丁语或日耳曼语所没有的挑战。本文通过增加一个额外的预处理步骤来处理斯拉夫语源文本，在该步骤中，屈折词被分解成它们的语言成分。另一方面，当目标语言是斯拉夫语时，类似的处理步骤发生在翻译之后(后处理)。这一过程通过调整标记化过程来更好地处理屈折变化——首先，作者利用在线资源为每种斯拉夫语言建立了形态模型，这是基于数百万个例子的形态类别图。这些然后被用于指导令牌化过程。
—
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
