TowardsDataScience-博客中文翻译-2016-2018-五-

龙哥盟 / 2024-10-13 / 原文

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

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

Android 中的 ConvolutionNeuralNetwork(CNN)——TIC tactoe . ai(第 1 部分)

原文：https://towardsdatascience.com/android-with-tensorflow-part-1-6897ba617b1e?source=collection_archive---------3-----------------------

Image source from- https://techcrunch.com/2017/05/17/googles-tensorflow-lite-brings-machine-learning-to-android-devices/

Google Tensorflow 现在已经在 Android 中用于集成机器学习模型。

所以我想用 Tensorflow 创建一个 Android 应用程序，因为其他人只是使用 Tensorflow 的预训练模型，并将其集成到应用程序中。但我想尝试一些新的东西，所以我训练了自己的模型，并了解了 Tensorflow 如何与 Android 交互。了解如何保存模型以供移动使用。

张量流

我已经实现了卷积神经网络的代码来分类 TicTacToe 游戏的 X 和 O。

Image sources from :- https://www.analyticsvidhya.com/blog/2017/06/architecture-of-convolutional-neural-networks-simplified-demystified/

输入图像大小为 28x28，输出图层大小为 2。因为我们必须将图像分类为 X 和 o。

在建立模型的时候，你必须定义哪个是你的输出节点，哪个是你的输入节点，给那些节点一些特定的名字。

然后是模型的训练，我已经在 6000 张不同的 X 和 O 的图像上训练了我的模型，运行了 3 个时期

Training result of CNN

由于训练模型已经训练了权重，这给出了 X 和 o 的完美分类。现在，我们必须保存具有权重的张量流的图形。

冻结图形时，我们需要输入和输出节点名称的列表，这就是为什么我们给输入和输出节点命名，这在冻结图形时很有帮助。

冻结图由获得输出必须执行的操作序列组成。操作包括矩阵乘法、加法和用训练模型的冻结权重对矩阵进行整形。

下面是冻结保存模型的代码。

freeze_graph.freeze_graph('out/' + MODEL_NAME + '.pbtxt', **None**, **False**,'out/' + MODEL_NAME + '.chkp', output_node_name, "save/restore_all","save/Const:0", 'out/frozen_' + MODEL_NAME + '.pb', **True**, "")

input_graph_def = tf.GraphDef()
**with** tf.gfile.Open('out/frozen_' + MODEL_NAME + '.pb', "rb") **as** f:
    input_graph_def.ParseFromString(f.read())

input_node_names = ['input']

output_graph_def = optimize_for_inference_lib.optimize_for_inference(
        input_graph_def, input_node_names, [output_node_name],
        tf.float32.as_datatype_enum)

**with** tf.gfile.FastGFile('out/opt_' + MODEL_NAME + '.pb', "wb") **as** f:
    f.write(output_graph_def.SerializeToString())

查看我的项目的冻结图

带 Tensorflow 的 Android

从 Android 开始，首先，我们已经集成了 Tensorflow 库，只需将它添加到依赖项中。

dependencies {
.....
implementation ‘org.tensorflow:tensorflow-android:+’
}

由于 Tensorflow 是用 C++编写的，所以你必须将 NDK 集成到我们的 Android 项目中。然后将模型复制到 android 目录的 asset 文件夹中。

如何使用 Java 在 Android 中运行图形？

// added the path of model
private static final String MODEL_FILE_CNN = "file:///android_asset/opt_xo_differ_v2.pb";
//declare the input and output
private static final String INPUT_NODE = "input";
private static final String OUTPUT_NODE = "output"private TensorFlowInferenceInterface inferenceInterface;//load graph
inferenceInterface = new TensorFlowInferenceInterface(getAssets(),MODEL_FILE_CNN);

正在加载模型。pd 文件，并创建一个tensorflowenceinterface对象

为了检测，我创建了一个方法来读取浮动中的图像像素。因为 DrawView 是一个画布，它为我们提供画布绘制图像的像素值，然后将它们转换为 float，并将其传递给tensorflowenceinterface对象。

因此，首先您必须将数据输入到输入节点(input_node 和 keep_prob)，中，然后使用输出节点运行推理接口

public float[] getDetectofDV(DrawView d){float pixels[] = d.getPixelData();inferenceInterface.feed(INPUT_NODE, pixels,1,28,28,1);
inferenceInterface.feed("keep_prob", new float[] { 1 });final Operation operation = inferenceInterface.graphOperation(OUTPUT_NODE);final int numClasses = (int) operation.output(0).shape().size(1);// this run the operation of the graph
inferenceInterface.run(new String[]{OUTPUT_NODE},false);float [] outputarray = new float[numClasses];
//get the output
inferenceInterface.fetch(OUTPUT_NODE,outputarray);return outputarray;
}

outputarray 如果一个索引 0 值大于索引 1，则返回具有 2 个值的检测结果。则图像被检测为‘0’，否则为‘X’。

这是将模型与 Android 整合后的结果。就像在触摸监听器上工作一样，当你从画布上拿起手指时，它会传递图像进行分类，你会在下面的矩阵中得到输出。

查看 playstore 上的应用程序。https://play.google.com/store/apps/details?id=com.harsh.xo

未来的工作

首先，我会尽量缩小模型的尺寸。CNN 的模型大小是 17MB，因为它在应用程序中占用了大量空间。应用程序的最终大小为 55 MB。

致力于在同一应用程序中集成新模型。一个人可以玩电脑。

https://play.google.com/store/apps/details?id=com.harsh.xo

动画 RNN，LSTM 和 GRU

原文：https://towardsdatascience.com/animated-rnn-lstm-and-gru-ef124d06cf45?source=collection_archive---------0-----------------------

gif 中的递归神经网络细胞

变更日志:

【2020 年 7 月 4 日:移除 GRU 的“输出门”标签

R 通用神经网络(RNNs)是一类人工神经网络，通常用于序列数据。3 种最常见的递归神经网络是

香草 RNN，
长短期记忆(LSTM)，由 Hochreiter 和 Schmidhuber 于 1997 年提出，以及
门控循环单元(GRU)，由 Cho 等人提出。2014 年的 al。

请注意，我将使用“RNNs”来统称固有递归的神经网络架构，使用“香草 RNN”来指代最简单的递归神经网络架构，如图图 1 所示。

有许多关于循环神经网络的图解。我个人最喜欢的是迈克尔·阮(Michael Nguyen)在《走向数据科学》中发表的文章，因为他为我们提供了对这些模型的直觉，更重要的是，他提供了美丽的插图，使我们易于理解。但是我的帖子背后的动机是为了更好地可视化这些细胞中发生的事情，以及节点是如何被共享的，以及它们如何转化为输出节点。我也受到了迈克尔的动画的启发。

这篇文章探讨了香草 RNN，LSTM 和 GRU 细胞。这是一篇简短的阅读材料，是为那些对这些主题有所了解的人准备的。(我建议在看这个帖子之前先看看 Michael 的文章。)重要的是要注意，以下动画是连续的以引导人眼，但并不反映矢量化机器计算期间的时间顺序。

这是我在插图中使用的图例。

Fig. 0: Legend for animations

注意，动画显示了在一个时间步长中发生的数学运算(由 t 索引)。此外，我使用了输入大小为 3(绿色)和 2 个隐藏单元(红色)，批量大小为 1。

我们开始吧！

香草 RNN

Fig. 1: Animated vanilla RNN cell

t —时间步长
X — 输入
h — 隐藏状态
X 的长度— 输入的大小/尺寸
h 的长度— 隐蔽单元的数量。注意，不同的库对它们的称呼不同，但意思是一样的:
- Keras — [state_size](https://keras.io/layers/recurrent/) ，[units](https://keras.io/layers/recurrent/#lstm) -py torch—[hidden_size](https://pytorch.org/docs/stable/nn.html#rnn)
  -tensor flow—[num_units](https://www.tensorflow.org/api_docs/python/tf/nn/rnn_cell/BasicLSTMCell)

LSTM

Fig. 2: Animated LSTM cell

C — 细胞状态

请注意，单元状态的维度与隐藏状态的维度相同。

苏军总参谋部情报总局

Fig. 3: Animated GRU cell

希望这些动画对你有所帮助！以下是静态图像中单元格的摘要:

Fig. 4: Vanilla RNN cell

Fig. 5: LSTM cell

Fig. 6: GRU cell

笔记

我用谷歌制图创建了这些图形。

参考

[## 了解 LSTM 网络——colah 的博客

这些循环使得循环神经网络看起来有点神秘。然而，如果你想得更多一点，事实证明…

colah.github.io](https://colah.github.io/posts/2015-08-Understanding-LSTMs/) [## LSTM 和 GRU 的图解指南:一步一步的解释

嗨，欢迎来到长短期记忆(LSTM)和门控循环单位(GRU)的图解指南。我是迈克尔…

towardsdatascience.com](/illustrated-guide-to-lstms-and-gru-s-a-step-by-step-explanation-44e9eb85bf21)

深度学习相关文章

逐行 Word2Vec 实现(关于单词嵌入)

带随机梯度下降的线性回归分步指南

10 种梯度下降优化算法+备忘单

统计深度学习模型中的参数数量

经办人:图文并茂

图文并茂:自我关注

感谢 德里克*任杰 对本文的想法、建议和修正。*

关注我上 推特 @remykarem 或者LinkedIn。你也可以通过 raimi.bkarim@gmail.com 联系我。欢迎访问我的网站remykarem . github . io*。*

使用 broom 和 ggplot2 在 R 中制作回归模型动画

原文：https://towardsdatascience.com/animating-regression-models-in-r-using-broom-and-ggplot2-da798e6638be?source=collection_archive---------9-----------------------

这可能对信息没有帮助，但在 Twitter 上看起来不错

我在《走向数据科学》中的第一篇文章是我给自己设定的一个小练习的结果，这个小练习是为了让那些灰色的小细胞保持运转。这是一个类似的练习，尽管与我正在做的一个项目更相关一些。由于我在营销部门工作，我不得不习惯于身兼两职。

通常，这些帽子是相互排斥的。在这种情况下，分歧是另一个动画数据可视化的形式。与动画苏格兰橄榄球冠军图一样，这个例子并没有真正受益于添加动画作为情节的另一个维度。

这张图表只是为了显示英国大学筹款的一些指标随时间变化的趋势。我只需要用 x 和 y 来表示价值和年份，但是这有什么意思呢？这是那种我们可以用ggplot2轻松可笑地绘制出来的东西:

ggplot(fund_tidy, aes(x = year, 
                      y = value,
                      colour = kpi)) +
  geom_line()

为什么不把它作为一个学习练习呢？我以前玩过gganimate包，但是从来没有真正花过时间。这似乎是一个好机会。

dataviz 冲突

这就把我们带到了帽子的对接上。我不认为一个动画情节是表现这些数据的最佳方式。我不知道它在技术上是否算作非数据墨水，但你会明白:它只是没有必要。如果已经拍摄了 x 和 y ，并且我想展示这两个值是如何随时间变化的，那么动画以一种易于理解的方式呈现了这些变化。在这种情况下，它是多余的。

要进一步探索市场营销与数据科学的结合， 在 Twitter 上关注 Chris。

但是很多图做出来并不是为了尽可能简单准确的表示数据，而是为了引起注意。在许多情况下，特别是在营销机构的世界里，有一种趋势是把一个清晰、直截了当的条形图变成一个完全新颖的信息图。一段时间内的游客流量用一只卡通脚表示，脚趾的大小代表每年的价值，有人知道吗？但那是以后的事了。

事实是，动画吸引眼球，它可以增加停留时间，让读者有时间来理解标题、坐标轴标签、图例和信息。可能吧。以及增加任何品牌的曝光率。不过，我确实有一些原则，所以我不会故意制作一张误导人的图表。摆弄配色方案和布局，让它看起来更时尚一点？当然，但是数据必须是第一位的。

趋势的例子

我一直在做一些大学筹款工作，看着历史性的罗斯案例报告，觉得看看一些关键绩效指标如何随着时间的推移而变化会很有趣。我以前看过一些主要的，但没有看过其他几个，觉得把它们放在一起看可能会很有趣。这将是一些很好的ggplot2和gganimate练习。让我们开始吧。

注意:因为这个练习的目的是比较潜在的趋势，并花更多的时间在 gganimate 上，而不是产生一个出版物质量的数字，因此对 y 轴标签的态度有点“漫不经心”！

这里没有洋葱皮

和以往一样，导入我预先制作的数据集并快速浏览是我的首要任务:

# import yearly data (total, summed values, not means or medians)
# dataset compiled from historical Ross-CASE reportslibrary(readr)fund_df <- read_csv("year_sum.csv")# quick look at datalibrary(dplyr)glimpse(fund_df) Observations: 12
Variables: 6
$ year               <int> 2005, 2006, 2007, 2008, 2009, 2...
$ new_funds_raised   <int> 452, 548, 682, 532, 600, 693, 7...
$ cash_received      <int> 324, 413, 438, 511, 506, 560, 5...
$ fundraising_staff  <int> 660, 734, 851, 913, 1043, 1079,...
$ contactable_alumni <dbl> 5.7, 6.2, 6.9, 7.7, 8.3, 8.0, 8...
$ contact_alum_x100  <dbl> 570, 620, 690, 770, 830, 800, 8... library(ggplot2)ggplot(fund_df, aes(x = year,
                    y = new_funds_raised)) +
  geom_line()

好了，我们有了一个数据集，它看起来像是我从以前的工作中期望的那样，所以希望我没有在第一个障碍就把事情搞砸了。前进！

因为 contactable _ aluminum 的值与其他值相差几个数量级，所以我创建了一个新列，将这些值乘以 100，使它们处于相同的范围内。然后，我将数据整理成一个整齐的“长”格式:

# create contactable alumni x100 variable to place values on equivalent scalefund_df <-
  fund_df %>%
  mutate(contact_alum_x100 = contactable_alumni * 100)# create tidy dataframelibrary(tidyr)fund_tidy <-
  fund_df %>%
  gather(kpi, value, - year) %>%
  mutate(kpi = as.factor(kpi))glimpse(fund_tidy) Observations: 60
Variables: 3
$ year  <int> 2005, 2006, 2007, 2008, 2009, 2010, 2011, 20...
$ kpi   <fct> new_funds_raised, new_funds_raised, new_fund...
$ value <dbl> 452, 548, 682, 532, 600, 693, 774, 681, 807,...

随着数据的转换，我们准备创建我们的第一个动画情节，记得从过滤掉原始的contactable_alumni变量开始:

# create animated plotlibrary(gganimate)
library(transformr)first_animate <-
  fund_tidy %>%
  filter(kpi != "contactable_alumni") %>%
  ggplot(aes(x = year, 
             y = value,
             colour = kpi)) +
  geom_line() + 
# this next line is where the magic happens:
  transition_reveal(kpi, year) +
  labs(title = "Trends in University Fundraising KPIs Over Time",
       subtitle = "Data from Ross-CASE reports",
       x = "Year",
       y = 'Value',
       caption = "y axis labelling omitted due to differences in scale between KPIs",
       colour = "KPI") +
  scale_colour_discrete(labels = c("Cash received", 
                                   "Contactable alumni",
                                   "Fundraising staff",
                                   "New funds raised")) +
  scale_y_discrete(labels = NULL) +
  theme_chris()

我们出发了。但这是最好的结果吗？我不这么认为。对我来说最重要的是，因为我们对趋势感兴趣，我们也应该有趋势线。如何着手去做…？

为了以非动画的方式做到这一点，我们只需在绘图代码中添加一个geom_smooth():

# create non-animated plot with trendlinesfund_tidy %>%
  filter(kpi != "contactable_alumni") %>%
  ggplot(aes(x = year, 
             y = value,
             colour = kpi)) +
  geom_line() +
  geom_smooth(method = "lm", linetype = "dashed", se = FALSE) +
  labs(title = "Trends in University Fundraising KPIs Over Time",
       subtitle = "Data from Ross-CASE reports",
       x = "Year",
       y = 'Value',
       caption = "y axis labelling omitted due to differences in scale between KPIs",
       colour = "KPI") +
  scale_colour_discrete(labels = c("Cash received", 
                                   "Contactable alumni",
                                   "Fundraising staff",
                                   "New funds raised")) +
  scale_y_discrete(labels = NULL) +
  theme_chris()

但是我们能简单地这样做并添加transition_reveal()行以同样的方式制作动画吗？我不能以任何方便的方式找到并相信我，在我失败的过程中产生了一些令人印象深刻的情节。很可能有一种简单的方法可以用geom_smooth()来实现，但是搜索 Stackoverflow 五分钟都没有找到，于是我有了另一个想法。我的下一个想法是创建趋势线作为过程中的一个独立阶段，建立另一个数据框架来构建我的动画情节:

#---- create linear model and augmented dataframe ----# build pre-filtered dataframefund_tidy2 <-
  fund_tidy %>%
  filter(kpi != "contactable_alumni")# build linear modellin_mod <- lm(value ~ year + kpi, data = fund_tidy2)# augment linear model to produce tidy dataframe with fitted valueslibrary(broom)aug_mod <- augment(lin_mod)# create animated graphaug_animate <-
  aug_mod %>%
  ggplot(aes(x = year, 
             y = value,
             colour = kpi)) +
  geom_line(aes(group = kpi, y = .fitted), size = 0.5, linetype = "dashed") +
  geom_point(size = 2) +
  geom_line(aes(group = kpi)) +
  transition_reveal(kpi, year) +
  labs(title = "Trends in University Fundraising KPIs Over Time",
       subtitle = "Data from Ross-CASE reports",
       x = "Year",
       y = 'Value',
       caption = "y axis labelling omitted due to differences in scale between KPIs",
       colour = "KPI") +
  scale_colour_discrete(labels = c("Cash received", 
                                   "Contactable alumni",
                                   "Fundraising staff",
                                   "New funds raised")) +
  theme_chris()# animate and saveaug_animated <- animate(aug_animate, height = 500, width = 800)anim_save("aug_animated.gif", animation = aug_animated)

哦，亲爱的，当然，这没有用。嗯，动画部分已经完全如我们所愿，但趋势线是错误的。由于我们构建模型的方式，我们已经创建了一个平行斜率类型的线性回归。在这样做的时候，我们失去了数据的关键发现:筹款人员的数量增长速度快于新基金的收购。

多个模型

为了得到我们想要的，我们必须为每个 KPI 建立一个单独的模型。使用 r 中的 tidy 原则很容易做到这一点。通过按 KPI 分组并嵌套在 tibble 中，我们可以使用purrr包中的map函数快速轻松地构建多个模型。

另一种方法是为每个 KPI 创建一个单独的数据框架，分别构建和扩充模型，然后将它们重新绑定在一起。这是一个很好的解决方案，但不具备真正的可扩展性。也就是说，这是我在决定咬紧牙关尝试以“正确”的方式做这件事之前首先做的事情:

#---- build multiple models for animated plot with trendlines ----# build nested tibblefund_nested <-
  fund_tidy2 %>%
  group_by(kpi) %>%
  nest()# build separate regression modelsfund_models <- 
  fund_nested %>%
  mutate(lm_mod = map(data, 
                     ~lm(formula = value ~ year, 
                         data = .x)))# augment models and unnest tibblefund_models_aug <-
  fund_models %>%
  mutate(aug = map(lm_mod, ~augment(.x))) %>% 
  unnest(aug)case_animate <-
fund_models_aug %>%
  ggplot(aes(x = year, 
             y = value,
             colour = kpi)) +
  geom_line(aes(group = kpi, y = .fitted), size = 0.5, linetype = "dashed") +
  geom_point(size = 2) +
  geom_line(aes(group = kpi)) +
  transition_reveal(kpi, year) +
  labs(title = "Trends in University Fundraising KPIs Over Time",
       subtitle = "Data from Ross-CASE reports",
       x = "Year",
       y = 'Value',
       caption = "y axis labelling omitted due to differences in scale between KPIs",
       colour = "KPI") +
  scale_colour_discrete(labels = c("Cash received", 
                                   "Contactable alumni",
                                   "Fundraising staff",
                                   "New funds raised")) +
  scale_fill_discrete() +
  theme_chris()

这就是我们想要的。为了美观，我添加了一个单独的 geom_point()，我们还可以做一些事情来使事情变得更漂亮，但是，总的来说，任务完成了，知识得到了加强！

F 在 Twitter 上关注克里斯 。

本文中的代码可以在 GitHub 上找到。

使用 R 将您的数据可视化制作成动画，就像老板一样

原文：https://towardsdatascience.com/animating-your-data-visualizations-like-a-boss-using-r-f94ae20843e3?source=collection_archive---------2-----------------------

R 中动画库的回顾与教程

Gapminder Inspired: Animated Viz by Pedersen

在讲述数据驱动的故事时，没有什么比动作更能吸引眼球了。我们的眼睛自然会被明亮的颜色和运动所吸引。一个好的视觉效果能抓住观众的兴趣并留下印象。幸运的是，通过一些易于使用的 R 包，制作这样的显示器变得非常简单。本文中的所有可视化示例都可以从这个 Github repo 中派生出来。我假设你对基本的绘图有所了解。

在你开始让你的图表跳舞之前，你应该先问问你自己:这样做有意义吗？如果您正在进行探索性的数据分析，一个运动图形可能不值得您投入时间。然而，如果你正在做一个演示，一些放置得很好的动画图片可以比静态图片更好地帮助观众理解你的主题。

创建动画时，情节实际上并不移动。相反，许多单独的情节被构建，然后缝合在一起成为电影帧，就像一个老派的翻页书或漫画一样。当传达运动时，每一帧都是不同的图，这是使用聚合数据的一些相关子集构建的。当拼接在一起时，子集驱动动画的流动。

How Animation is Done For Data Visualizations

子集越多，你的图就越平滑。这是你制作动画的重要考虑因素。如果您的数据太薄，您将只有几帧，这可能不会引人注目。在这种情况下，使用静态面板图而不是动画可能会更好。这些可以在 ggplot 中创建，例如，使用面。另一个选择是使用插值和 tweener 包来扩展你的数据集。

Panel Plot Structure with 2 rows and 4 columns

动画的最大好处是，它允许您可以可视化的变量数量的扩展。动画图的运动由数据集中的变量“驱动”。上面的图是使用包含六个变量的数据集构建的。动画很好地捕捉到了这六个场景！以下是数据示例:

A Sample of the Gapminder Data

我们可以对这六个值中的任何一个进行动画处理。然而，这是危险的！有些变量比其他变量更适合制作动画。例如，随着时间的推移动画变化是显而易见的；然而，对分类变量采用同样的方法会造成混乱。

GDP 的好动画:放慢你的脚步中国！😯

糟糕的 GDP 动画:我不知道发生了什么…🙄

以下是动画创造有价值见解的几次机会:

随着时间的变化
迭代/递归技术的变化(如梯度下降或贝尔曼方程)
模拟过程中的变化

这里的关键点是突出显示驱动动画的变量的数据中的重要变化。说够了-让我们建立一些动画可视化！所有创建这些可视化效果的源代码都可以在 Github repo 这里找到。

包裹

我通常使用四个包选项来制作 R 中的数据动画:

动画:可用于制作任何剧情类型的动画，由谢一辉编写
gganimate :用于专门制作 ggplot 图形的动画，由托马斯·林·彼得森编写
plottly:具有动画特性的交互式绘图库
googlevis :有一个基于 flash 的运动图表选项

一般来说，动画包提供了最大的控制，对于基本图来说很棒，但是可能会很冗长。另一方面，gganimate 包只限于一个绘图库，但它使在 ggplot 中构建运动变得极其容易(在您的绘图中有一两行额外的代码)。与 gganimate 类似，plotly 只能从自己的库中制作可视化动画。Googlevis 是最受限制的，只提供一种需要 flash 的动作情节，这种东西越来越不常见。出于这个原因，我不会做这个库的例子，看看这里如果你已经安装了 flash。

使用动画

使用 animate 包，您有五个导出选项，假设您安装了正确的依赖项(参见文档)。

HTML(带控件)
视频(mp4)
GIF 格式
乳液
闪光

这个包很棒，部分是因为它内置了一些惊人的统计图形作为示例。这是一个动画渐变下降并创建一个带有控件的 HTML 页面:

library(animate)desc = c("This is a super cool example of Gradient Descent")saveHTML({ f1 = function(x, y) x^2 + 3 * sin(y)
  xx = grad.desc(f1, pi * c(-2, -2, 2, 2), c(-2 * pi, 2))

 xx$persp(col = "lightblue", theta = 30, phi = 30)},title = "Demo of Gradient Descent", description = desc, verbose = FALSE)

Gradient Descent Example from The animate package

有时你希望你的用户能够控制动画。在本例中，最后一帧是您可能想要暂停的表面的 3D 图像。此处链接的 Github repo 中有这个动画的现场版，带有这样的控件。

这个包最强大的地方是你可以用任何可视化工具来构建你的框架。例如，上面的好的和坏的动画都是使用这个库和 ggplot 构建的(参见 Github repo)。

使用 gganimate

使用 gganimate，默认的导出是 GIF(使用 gifski ，你必须安装 rust ，但是根据你的具体需求也有其他选项。本文中的第一个动画示例是使用 gganimate 包构建的(事实上，它是该包的自述文件中唯一完整的真实数据示例)。这是 wiki(作者 Tom Westlake )渲染成视频文件的另一个例子。一个有趣的关于安斯科姆的四重奏，这个动画是一系列的情节，都有相同的汇总统计，其中一个是恐龙！所有这一切只需要对一个基本的 ggplot 添加几行代码。

library(datasauRus)
library(ggplot2)
library(gganimate)

ggplot(datasaurus_dozen, aes(x=x, y=y))+
  geom_point()+
  theme_minimal() +
  transition_states(dataset, 3, 1) + 
  ease_aes('cubic-in-out')

The datasauRus!

使用 Plotly

这里涉及的最后一个包是 plotly。许多可视化实践者和这个包有一种爱恨交加的关系。它允许简单地创建美丽的互动情节。然而，这种轻松带来了灵活性和风格上的一些损失。你还必须处理所有东西上的 plotly 标志。但是，我个人认为权衡通常是值得的。以下是我们在 gganimate 包中看到的同一 gapminder 数据集的 plotly 文档(使用帧参数)中的动画示例:

library(plotly)
library(gapminder)p <- gapminder %>%
  plot_ly(
    x = ~gdpPercap, 
    y = ~lifeExp, 
    size = ~pop, 
    color = ~continent, 
    frame = ~year, 
    text = ~country, 
    hoverinfo = "text",
    type = 'scatter',
    mode = 'markers'
  ) %>%
  layout(
    xaxis = list(
      type = "log"
    )
  )

一旦你有了情节，你可以把它推给 plotly 服务托管。这将允许您嵌入包含所有组件的情节，包括播放按钮。这实际上是在介质上获得交互式图形的唯一方法之一！一个缺点是 plotly 托管服务在免费层上有 25 个地块的限制。

Plotly Version of Gapminder Visualization

包扎

现在，您已经拥有了在 r 中构建自己令人惊叹的动画可视化所需的一切。您可以将这些产品整合到您的演示文稿、网站和博客中。记住，权力越大，责任越大。别让我抓到你在分类变量上动来动去🤨。

在 LinkedIn 上与我联系！https://www.linkedin.com/in/isaacfaber/

动漫推荐引擎:从矩阵分解到学习排序

原文：https://towardsdatascience.com/anime-recommendation-engine-from-matrix-factorization-to-learning-to-rank-845d4a9af335?source=collection_archive---------9-----------------------

动漫痴迷过头了！！

宅男 张哲伦、陈可辛、、普瑞蒂卡·斯里瓦斯塔瓦和切莉·阿加瓦尔

如今，互联网上托管的大量数据导致了信息泛滥，因此不断需要改善用户体验。推荐引擎是一个通过为用户提供适当的预测建议来帮助支持用户决策的系统。它们已经成为我们日常生活的一部分。从购物到美食到娱乐，他们无处不在。动漫是一种新的狂热，每天都在流行，尤其是在非亚洲国家。然而，没有一个推荐引擎可以帮助新手和经验丰富的宅男在这个领域里聪明地进步。因此，我们这些宅男决定开发一个作为我们学术项目的一部分。

数据预处理和探索

该数据取自 Kaggle 。它包含了动漫的信息和看过的用户以及对它的评价。这个数据集中有超过 3000 万的观测，10 万的用户，6K 的动画电影。启发性地，我们决定去掉那些评价很少的动漫和没有评价的动漫，来训练我们的推荐引擎。通过研究数据，我们发现大多数用户来自美国，其次是巴西和波兰。最受欢迎的类型是喜剧、音乐和冒险。此外，我们的大多数用户年龄在 20 到 30 岁之间。

Fig: Exploratory Data Analysis

模型和算法

协同过滤

已经有推荐引擎来满足各种需求，它们都有不同的底层算法来解决问题。最传统的是使用协同过滤，你倾向于将评级矩阵(R)分成 U ser-Embedding (U) 和 Anime -Embedding (P) 。这些嵌入本质上就是我们所说的潜在特征(在监督机器学习中)。为了探索这种方法，我们尝试了三种算法，即。即。交替最小二乘法、奇异值分解和神经网络。

ALS :这是一个两步迭代优化过程。在每次迭代中，它试图通过求解 U 来优化评级矩阵(U*P ),首先保持 P 不变，然后 P 保持 U 不变。我们使用 P ySpark 来运行这个使用 MLlib 的算法。

SVD: 为了估计所有的未知量并得到嵌入，我们通过随机梯度下降最小化正则化平方误差。我们偶然发现了伟大的“惊喜，并使用其奇异值分解的实现来训练我们的算法。

神经网络:这里我们使用两个嵌入层来表示用户，动画作为我们的输入。互动(评级矩阵)是目标变量。对于每个用户-动画对，我们计算一个分数，取其潜在表示的点积。然后，我们尝试通过反向传播将损耗降至最低，并优化嵌入层(示意图如下所示)。

Fig: Neural Network schematic for estimating embedddings

我们运行了这个模型 10 个时期，由于计算量很大，我们在谷歌云平台上用 Keras(Tensorflow backend)运行了这个模型。这个模型比之前的要好，但并没有全面超越它们。我们得到了另一个绝对免费的模型！猜猜看？合奏！！。这个模型只是将上述三个模型的预测结果进行了平均。

Fig: Comparison of different algorithms with NDCG@10 and MAP@10

正如可以看到的，集成特别优于所有三种算法，并给出了与 NDCG 和地图(稍后更多)的伟大结果。最初，我们基于 RMSE 评估我们的模型。然而，我们的教授 Ghosh 博士建议我们研究学习排序(LTR)算法。

问题来了，为什么我们需要转移到 LTR 算法？请这样想:假设我们有两个项目 I 和 j，已知它们的真实评分分别为 3 和 4，两种不同的方法预测 I 和 j 的评分分别为{2，5}和{4，3}。就通过与真实评级的绝对偏差来测量的评级预测准确性而言，两组预测之间没有差异。然而，使用预测{4，3}，项目 I 和 j 将被错误地排序，而预测{2，5}确保了正确的顺序。

学习排名

学习排序预测项目列表的排序，而不是评级。基于 LTR 算法的现状，python 中没有太多的开源资源可以实现它们。在这个项目中，我们有机会深入研究了微软关于 LTR 的论文，并从头开始用 python 对它们进行编码。这是我们给致力于 reco-engine 的开源社区的两分钱，如果他们想试验这些算法的话。因为这是一个学术项目，这些被证明对我们的概念学习也非常有益。我们成功地通过了其中的两个，即 EigenRank 和 LambdaMART。EigenRank 是面向排序的协同过滤版本，而 LambdaMART 是监督机器学习 weds 信息检索的典型。

Eigen Rank:It是第一个基于排序的协同过滤算法。对于每个用户 u，它试图使用 Kendall Tau 等级相关系数找到它的邻域(Nu ),然后计算如下所示的偏好函数。

Fig: Formula for Preference function. Nu represents neighborhood and r represents rating by user ‘u’ to item ‘i’

Nu 中的用户分配比 j 更高的 i 的次数越多，ψ(I，j) > 0 和ψ(j，i) < 0 的证据就越强。偏好函数给邻居的动画列表中的每对动画 I，j 分配一个分数。最后为了给这些动漫排序，我们使用了一种贪婪算法的方法。

LambdaMART: 使用梯度提升树直接优化特定等级成本函数(如 NDCG)。不幸的是，成本函数不是在所有的点上都是可微的。因此，我们需要梯度的代理，这里称为λ。它可以被认为是一种推动动画在排行榜上上下移动的力量(如下图)。最好的部分是，它还利用了动漫和用户的特点，如受欢迎程度，持续时间，类型，特定用户观看的次数，发行年份等。利用 LambdaMART 的这一特性，我们可以为新用户提供建议。

Fig: Schematic of Lambda pushing the items in list up and down and thus reducing incorrectly ordered pair. source: original paper

对于这些 LTR 模型，我们再次使用 NDCG(归一化累积贴现收益)和 MAP(平均精度)等评估指标。

如前所述，因为我们为前面提到的两个算法编写了代码，所以它不是超级可伸缩的。在我们努力使我们的代码成为黄金标准的同时，我们在较小的数据(~0.5M)上测试了它的效用，它表现很好，实现了 NDCG as: 0.72(本征秩)和 0.60(λmart)；映射为 0.63 (EigenRank)和 0.56(LambdaMART)。

所以让我们打破 NDCG 和地图上的悬念..

评估措施

NDCG 归一化折扣累积收益:量化预测排名列表与理想排名列表(将只是基于评分的项目排序)的偏差。它还认识到高度相关的文档比不太相关的文档更有用的事实。

Fig: Zu is the Normalization factor (inverse of Ideal NDCG), Q represents all the users and R(u,p) is the rating given by user u to anime at rank p

NDCG@K 只是从我们的引擎为前 K 个推荐计算的 NDCG。

MAP-Mean Average Precision:它捕捉了所有推荐动漫中相关动漫的百分比(测试数据中的用户已经看过这些动漫并给予了高度评价)。

Fig: Formula for Mean Average Precision. AP(q) is the average precision for each user q

MAP@K 只是为来自我们引擎的前 K 个推荐计算的 MAP。

到目前为止，我们推荐是基于用户的观看历史。 如果有新用户来向我们推荐动画，我们该怎么办？ 为了帮助新用户加入动画世界，我们使用 K-means 聚类 将对不同类型有共同爱好的用户分组到不同的群中。总之，我们提出了 5 个不同的群体:科幻迷、无偏好者、憎恨者、活泼的年轻人和热血战士。

开演时间

这里有一个很酷的视频，展示了我们尝试过的算法的相对优势:

Fig: Video Demonstration of the recommendation engine

前进的道路
(i)用于学习排序算法的可扩展性增强，可能通过在 Cython 中编码它们。
(ii)LambdaMART 更好的特征工程。(iii)建立一个前端来托管我们的推荐引擎
(iv)完成(I)、(ii)和(iii)，然后可能会尝试接近一个风险投资家来资助我们的推荐引擎网站！！

完整的项目和代码可以在https://github.com/Preetikasri/Anime-Recommendation-Engine查看

感谢阅读！！

公告:TensorFlow 2.0 来了！

原文：https://towardsdatascience.com/announcement-tensorflow-2-0-is-coming-7e17e8e333e3?source=collection_archive---------4-----------------------

而 TensorFlow 1.x 将会是…

备受期待的流行机器学习框架 TensorFlow 的更新于 8 月初由谷歌人工智能的马丁·维克(Martin Wicke)宣布。

这个令人兴奋的消息是在他的谷歌团队上宣布的，它已经引起了关于框架的下一个主要版本——tensor flow 2.0 的讨论。如果你和我一样兴奋，并渴望了解 2.0 开发的最新细节，我强烈建议你订阅 谷歌群组 ！

更吸引人的是，您可以成为即将到来的公共设计评审的一部分，甚至通过表达您的关注和提出更改来为 TensorFlow 2.0 的功能做出贡献！这正是我喜欢开源开发的原因，因为社区为了共同的目标一起工作并相互支持。

那么 TensorFlow 1.x 有什么问题呢？

如果你是 TensorFlow 的初学者，你可能会发现学习曲线非常陡峭，因为它是一个低级框架，不像 Keras 。因此，一些用户可能会发现学习和应用起来相对困难。

然而，TensorFlow 已经成为世界上最广泛采用的机器学习框架，迎合了广泛的用户和用例。

这些快速的变化推动了 TensorFlow 的下一个主要版本，这将是一个以易用性为重点的重要里程碑。

虽然在 TensorFlow 2.0 的早期版本中，TensorFlow 1.x 仍将得到维护和开发，但已宣布一旦 TensorFlow 2.0 的最终版本发布，将不再开发 TensorFlow 1.x。 TensorFlow 团队仍将在 TensorFlow 2.0 发布日期后的一年内继续发布上一个 TensorFlow 1.x 版本的安全补丁。

我们对 TensorFlow 2.0 有什么期待？

(Source)

高级 API

Keras、Eager 和 Estimators 更强的集成，使用相同的数据管道、API 和序列化格式(保存的模型)。
TensorFlow Core 中常用 ML 模型(如时间序列、RNNs、TensorForest、附加提升树功能)和相关功能(如序列功能列)的固定估计器(从 contrib 迁移，如果存在)。

急切的执行

使用 DistributionStrategy 利用多个 GPU 和多个 TPU 内核。
分布式训练支持(多机)。
性能改进。
更简单地导出到 GraphDef/SavedModel。

参考模型

构建一套横跨图像识别、对象检测、语音、翻译、推荐和强化学习的模型，展示最佳实践，并作为高性能模型开发的起点。
越来越多的高性能云 TPU 参考模型。

贡献

弃用[tf.contrib](https://www.tensorflow.org/api_docs/python/tf/contrib)中存在于[tf.contrib](https://www.tensorflow.org/api_docs/python/tf/contrib)之外的优选实现的部分。
尽可能将[tf.contrib](https://www.tensorflow.org/api_docs/python/tf/contrib)内部的大型项目转移到单独的存储库。
在 TensorFlow 2.0 中，当前形式的[tf.contrib](https://www.tensorflow.org/api_docs/python/tf/contrib)模块将停止使用。实验性开发将在未来的其他存储库中进行。

最后的想法

(Source)

感谢您的阅读。

这么多激动人心又人性化的功能，真的很期待 TensorFlow 2.0 的早日发布。TensorFlow 2.0 的预览版将于今年晚些时候发布，也就是下个月的 12 月份！

同时，如果您有兴趣了解 TensorFlow 2.0 下一版本的最新发展，您可以随时订阅邮件列表或在此加入社区！

一如既往，如果您有任何问题或意见，请随时在下面留下您的反馈，或者您可以随时通过 LinkedIn 联系我。在那之前，下一篇文章再见！😄

关于作者

Admond Lee 目前是东南亚排名第一的商业银行 API 平台 Staq — 的联合创始人/首席技术官。

想要获得免费的每周数据科学和创业见解吗？

你可以在 LinkedIn 、 Medium 、 Twitter 、脸书上和他联系。

[## 阿德蒙德·李

让每个人都能接触到数据科学。Admond 正在通过先进的社交分析和机器学习，利用可操作的见解帮助公司和数字营销机构实现营销投资回报。

www.admondlee.com](https://www.admondlee.com/)

宣布 fast.ai 第 1 部分现在作为 Kaggle 内核提供

原文：https://towardsdatascience.com/announcing-fast-ai-part-1-now-available-as-kaggle-kernels-8ef4ca3b9ce6?source=collection_archive---------6-----------------------

现在是开始使用 Kaggle 内核进行深度学习的好时机！

最近，我有机会在哥伦布的 PyOhio 做了我的第一次会议演讲。我谈到了进入深度学习，我使用 Kaggle 内核演示了来自 fast.ai 课程第一课的一些材料。

第二天我偶然看到了一篇名为“使用支持 GPU 的 kaggle 内核和 fastai MOOC 学习深度学习”的媒体文章，我很高兴看到更多人认识到这个平台的能力。

所以我想，如果我们要让人们容易地开始在 Kaggle 内核上进行深度学习，为什么不把整个 fast.ai 课程公之于众？

ka ggle 内核的好处

根据该文档，“ Kaggle Kernels 是一个云计算环境，支持可重复的协作分析。基本上，你可以专注于编写代码，Kaggle 负责设置执行环境并在他们的服务器上运行。我认为这种设置为刚开始学习深度学习的人提供了优势，有几个原因:

无需等待/批准的免费 GPU:你可以立即免费访问 GPU，这是开始深度学习的一大步。当我第一次开始时，你唯一的选择是等待 AWS 批准你的 GPU 实例，然后付钱给他们运行它(希望你没有忘记关闭它)。在 GPU 和 CPU 上运行意味着你的训练可以在几分钟内完成，而不是几个小时。
预装深度学习包:这对初学者来说是又一个巨大的胜利，为你节省了几个小时的设置时间和谷歌模糊的错误信息。使用 Kaggle 维护的 docker-python repo 中的 docker 文件设置内核环境。它设置了 CUDA 和 CUDNN，即 NVIDIA 用于在 GPU 上加速深度学习的库，并安装了用于深度学习的流行 python 库:除了 fastai 之外，还有 keras、tensorflow、pytorch 和 pytorch 等。
访问数据:大多数 fast.ai 课程都使用 Kaggle 比赛来获取训练数据，而在 Kaggle 内核中，访问这些数据就像点击“添加数据集”一样简单。这也使得无需任何额外的步骤就可以很容易地将经验应用到其他过去的比赛中。如果你找不到你需要的数据，你可以上传你自己的数据集并与 Kaggle 社区分享。

It’s as easy as a single click!

平台的社交特性:我认为 Kaggle 内核的一些社交特性也使其成为一个很好的学习环境。您可以“派生”现有的内核，并对它们进行调整以制作您自己的版本，这使您能够进行实验并查看不同代码更改的影响。您可以对内核进行评论，向作者提问或试图追踪一个 bug。向上投票有助于你看到流行的内核，这可能会引导你进入下一个你想学习的有趣话题。

抓到你了

如果您习惯于在 AWS 或您自己的机器上工作，或者如果您正在遵循针对这些环境的说明，那么在使用内核时需要注意一些事情。这些差异解释了我需要对最初的 fast.ai 笔记本进行的大部分更改，以使它们作为内核运行。

只读输入数据:默认情况下，您加载到内核中的数据位于../input下。但是数据所在的目录是只读的。这给 fast.ai 带来了两个问题——首先，在某些情况下，您需要移动数据以符合特定的目录结构。这可以通过以不同的形式将数据传递给学习者来解决(在第 1 课中，我使用了文件名和标签的列表，这是由from_names_and_array 方法支持的)。此外，默认情况下，学习者将 tmp 数据和模型权重写入与数据相同的目录，这可以通过将tmp_name和models_name选项传递给学习者来修改。
等待软件包更新:我提到过，软件包安装由 Kaggle 维护在 Dockerfile 中，这在很大程度上对您有利，节省了您配置东西的时间。唯一的缺点是，当他们重建 Docker 映像时，您只能获得软件包更新。当我处理这些问题时，我注意到在最新的 fast.ai 版本中已经修复了几个问题，我不得不通过猴子修补一些类来将这些修复移植到我自己身上。我也无法完成第 4 课和第 6 课(RNN)，因为 pytorch 0.3.1 和 CUDNN 7.1 中出现了一个错误。(针对 GPU 内核的 pytorch 0.4.0 更新正在进行中)

Not fun when your debugging path eventually leads here…

非持久文件系统:如果你重启你的内核，你会丢失你已经写到磁盘上的文件。对于运行 fast.ai 课程来说，这不是一个主要问题，但如果你正在试验不同的模型或超参数，并试图节省权重，这对你来说可能很难。

内核

事不宜迟，他们来了！我希望这有助于你的深度学习之旅——没有什么比看到这些东西以新的有趣的方式被分叉、调整和应用更让我高兴的了。

第一课
第二课第三课第四课
第五课
第六课【SGD】
第六课【RNN】第七课【cifar 10】
第七课【CAM】

如果你有任何问题，请随时联系 fast.ai 论坛或 Twitter:@ hortonhearsafoo。

宣布 Google Sheets 为 ParallelDots APIs 添加插件

原文：https://towardsdatascience.com/announcing-google-sheets-add-on-for-paralleldots-apis-c67907c97d5b?source=collection_archive---------11-----------------------

去年 12 月，我们发布了 ParallelDots Excel 插件，它无需编写一行代码就能提供最先进的文本分析功能。因为我们的主要目标是面向业务分析师，所以我们推出了适用于 Windows 操作系统的 Excel 插件。从那时起，我们的 Excel 插件已经被下载了 10，000 多次，并被用于处理超过 500 万个不同行业的文本文档，如金融、市场研究、教育和消费零售。

随着我们的 Excel 插件越来越受欢迎，我们也收到了许多关于 Mac 等其他操作系统上类似解决方案的查询。经过几次讨论，我们决定建立一个 Google Sheets 插件，使我们的服务跨平台，并向我们将人工智能带到用户指尖的目标迈进了一步。

今天，我们很高兴地宣布推出我们的 Google Sheets 插件，其工作方式与我们的 Excel 插件相同。该插件可用于在大型文本语料库上运行文本分析，并从中发现见解(如来自社交媒体活动的用户生成内容、收入电话会议记录、开放式用户反馈等)。).点击此处将插件安装到您的 Google Sheets 中。

请阅读我们的以前的博客来了解更多关于插件的真实使用案例。

Google Sheets 附加组件入门

首先，从您在 xlsx(或 CSV 格式)中使用的任何 BI 工具中导入您的数据，并安装我们的附加组件，用情绪和情感来注释数据，找到突出的关键词或将它们归类到 IAB 分类法中。

在本帖中，我们将展示如何使用我们的 Google Sheets 插件快速分析大量文本文档，并做出强有力的、有数据支持的决策。

安装和使用附加软件

在开始使用 Google Sheets 插件之前，你需要注册一个免费的 ParallelDots AI APIs 帐户。在我们网站上填写表格并验证您的电子邮件后，您可以通过 google sheets 直接登录您的帐户。请将帐户凭证存放在安全的位置，因为未经授权访问您的帐户将导致您的配额提前用完。如果您丢失了密码，或者您觉得其他人可能会访问您的密码，请立即更改您的密码。

验证电子邮件后，将 ParallelDots 扩展添加到您的 Google Sheets，并按照屏幕上的说明安装该插件。成功安装附加组件后，Google Sheets 屏幕顶部导航栏的附加组件下拉列表中将有一个 ParallelDots 按钮，如下所示:

单击显示/隐藏窗格后，您可以切换设置屏幕来激活您的附加帐户。在任务窗格中输入在上一步中创建的帐户凭据，然后单击登录开始分析数据。

就是这样，现在您可以使用我们的附加组件带来任何类型的非结构化文本内容并进行分析。在下一节中，我们将解释附加组件中可用于执行不同类型的文本分析的不同功能。

Google Sheets 插件中的文本分析功能

我们的 Google Sheets 插件允许您访问以下 API:

情感分析

使用 Google Sheets 的情感分析可以通过调用函数paralledots _ perspective来访问，如下图所示:

如果你需要知道上面的parallel dots _ 情操函数返回的情感标签的概率，你可以通过调用函数parallel dots _ 情操 _ <情操 _ 标签>_ 概率来实现，其中情操 _ 标签可以是中性的，积极的或者消极的。

情感分析 API 的细节可以在这里找到。

多语言情感分析

我们的情感分析算法支持 14 种其他语言。对这些语言的分析可以通过调用函数parallel dots _ 情操(text，" language_code ")来调用。也可以通过在每种语言的函数后面附加“_confidence”来检索它们的置信度得分，如下图所示:

多语言情感分析 API 的详情可以在这里找到。

关键词生成器

可以通过调用 paralleldots_keywords 函数来调用。返回输入文本中重要关键字的列表。这个功能的细节可以在这里找到。

多语言关键字生成器

我们的关键字生成器算法支持 13 种不同的语言。可以通过调用函数 paralleldots_keywords(text，" language_code ")来调用这些语言的分析。也可以通过在每种语言的函数后面附加“_confidence”来检索它们的置信度得分，如下图所示:

多语言关键字生成器 API 的详细信息可以在这里找到。

文本分类

可以通过调用 paralleldots_taxonomy 函数来调用。返回文本可能属于的类别列表。

文本分类 API 的详细内容可以在这里找到。

命名实体识别

可以通过调用parallel dots _ ner _ organization、paralleldots_ner_person 或 paralleldots_ner_place 分别提取组织名称或人员或地点。

命名实体识别 API 的细节可以在这里找到。

语义分析

可以通过调用parallel dots _ similarity来调用。输出是 0-5 之间的分数，其中接近 5 的分数表示两个句子的意思非常接近(语义相似)，而接近 0 的分数表示两个句子的意思非常不同。

注意，为了使用这个函数，你需要在两个句子上运行它，更多细节和用例可以在这里找到。

情绪分析

可以通过调用 paralleldots_emotion 得到情绪标签，调用parallel dots _ emotion probability得到不同情绪的概率得分，如下图所示:

更多关于情感功能的细节请点击查看。

多语言情感分析

我们的情感分析算法支持 14 种其他语言。可以通过调用函数 paralleldots_emotion(text，“language_code”)来调用这些语言的分析。也可以通过在每种语言的函数后面附加“_confidence”来检索它们的置信度得分，如下图所示:

多语言情感分析 API 的详细信息可以在这里找到。

意图分析

可以通过调用 paralleldots_intent 来查找输入文本的意图，并调用 parallel dots _ intent _

点击查看关于意图功能的更多详情。

辱骂内容分类器

可以通过调用paralleldots _ abuse来将输入文本分类为滥用或不滥用。置信度得分(概率得分)可以通过调用parallel dots _ abuse _ confidence得到。

更多关于意图功能的细节可以在这里找到。

安全和隐私

Google Sheets add-on 建立在我们的 API 之上，这意味着您的数据在我们的服务器上进行处理，以获得最终输出。我们非常重视用户隐私，我们的隐私政策可以在这里访问。所有用户数据都根据我们的隐私政策进行存储，以确保高标准的安全性。

然而，在某些情况下，由于合同义务或其他原因，用户可能希望将数据保存在内部，在这种情况下，我们可以在内部部署这些算法，并相应地构建插件。请向我们发送一个请求以在内部部署这些 API 以及您希望我们构建的任何自定义功能。

Google Sheets add-on 是一种强大且经济高效的方式，可以开始将尖端智能添加到您的分析中。我们的 Google Sheets 插件可以让你每天免费分析每个功能的 100 个句子，而不需要给出你的信用卡信息。我们希望这将让您了解附加组件中提供的不同功能，并在升级到我们的大规模使用付费计划之前了解使用案例。

如有任何疑问或反馈，请给我们 support@paralleldots.com 公司写信。

我们希望你喜欢这篇文章。请注册一个免费的 ParallelDots 账户，开始你的 AI 之旅。你也可以在这里查看 PrallelDots AI API的演示。

此处阅读原文。

宣布 Optimus v2 —简化敏捷数据科学工作流程

原文：https://towardsdatascience.com/announcing-optimus-v2-agile-data-science-workflows-made-easy-c127a12d9e13?source=collection_archive---------13-----------------------

作为一名数据科学家，您是否正在寻找一个库来提升您的工作效率？看看这个。

Photo by Timothy Eberly on Unsplash

几年前，我们为一个零售客户项目清理、处理和应用 ML 聚类算法。

当时，我们正在寻找一种工具，让我们能够轻松地处理数据。我们尝试了 trifacta，这是一个制作精美的工具，可以让你通过点击界面以可视化的方式应用转换。问题是可用的脚本语言不足以按照我们喜欢的方式处理数据。

我们还尝试了令人惊叹的熊猫图书馆，但我们的数据大到足以让它哭泣。

所以，大约一年前我们推出了擎天柱。Optimus 由 Spark (Pyspark)提供支持，允许您使用自己的或一组预先创建的数据转换函数清理数据，对其进行分析并应用机器学习，所有这些都很容易，并且具有 python 的所有功能。

🚚Optimus v2 测试版推出

现在，我们准备发射擎天柱 v2。借助 Apache Spark 和 Pyarrow 的全面重写，Optimus 提供了一种访问、转换数据和创建大规模机器学习和深度学习模型的单一方式。

对于这个新版本，在我们惊人的用户反馈后，我们决定致力于三个主要目标:

创建一个可靠的 API 来访问和处理数据。
让用户可以轻松地从熊猫迁移。
让数据探索更容易。

目标 1:创建可靠的 API 来访问和处理数据

我们经营游泳池快一年了。结论，Pandas 和 Spark 是用于数据清理的主要库。因此，我们使用 Optimus 的目标是创建一种可预测的、简单的方法来访问和处理数据。不管是来自熊猫，还是火花。

下表显示了火花，熊猫和我们用擎天柱创造的东西。

Basic data operations API for Pandas Spark and Optimus

我们在这里看到了一些东西:

Spark API 对于基本函数没有任何一致性。
对于 Pandas，只有追加列/过滤器不一致。

因此，第一步是为我们认为的核心数据操作创建一个一致的基础:

创建数据帧
用追加行或列()
用 select() 选择行或列
用 apply() 更新或转换列数据
用 drop()删除行或列

其他基本功能是 read() 和 write() 操作，用于加载和保存数据帧。因为我们认为 Apache Spark API 是一致且强大的，所以我们将其直接映射到 Optimus，不做任何更改。

下面是所有基本操作的示例:

df = op.create.df(
    [
        ("names", "str", True),
        ("height", "float", True),
        ("function", "str", True),
        ("rank", "int", True),
    ],
    [
        ("bumbl#ebéé  ", 17.5, "Espionage", 7),
        ("Optim'us", 28.0, "Leader", 10),
        ("ironhide&", 26.0, "Security", 7),
    ]).show()df.rows.append(["Grimlock",80.0,"Commander",9])+------------+------+---------+----+
|       names|height| function|rank|
+------------+------+---------+----+
|bumbl#ebéé  |  17.5|Espionage|   7|
|    Optim'us|  28.0|   Leader|  10|
|   ironhide&|  26.0| Security|   7|
+------------+------+---------+----+df.rows.append(["Grimlock",80.0,"Commander",9])\
    .rows.select(df["rank"]>7)\
    .cols.select(["names","height","function"])\
    .cols.apply_expr("height", df["height"]-1)\
    .cols.drop("function")\
.table()+--------+------+
|   names|height|
+--------+------+
|Optim'us|  27.0|
|Grimlock|  79.0|
+--------+------+

列操作

除了这个基本操作之外，我们还识别了列上的其他操作。这里的想法是一样的，创建一个简单和一致的方法来操作数据。所有手术的设计和命名都尽可能接近熊猫。此外，您可以轻松地对单个、多个或整个列数据集应用操作。

聚集

让我们从聚合开始。我们扩展了 Apache Spark 操作，并创建了一种访问统计函数的简单方法。

print(df.cols.min("height"))
print(df.cols.percentile(['height', 'rank'], [0.05, 0.25, 0.5, 0.75, 0.95]))
print(df.cols.max("height"))
print(df.cols.median(["height","rank"]))
print(df.cols.range(["height","rank"]))
print(df.cols.std(["height","rank"]))17.5   
{'height': {0.05: 17.5, 0.25: 17.5, 0.5: 26.0, 0.75: 28.0, 0.95: 28.0}, 'rank': {0.05: 7.0, 0.25: 7.0, 0.5: 7.0, 0.75: 10.0, 0.95: 10.0}}
28.0
{'height': 26.0, 'rank': 7.0}
{'height': {'min': 17.5, 'max': 28.0}, 'rank': {'min': 7, 'max': 10}}
{'height': {'stddev': 5.575242894559244}, 'rank': {'stddev': 1.7320508075688772}}

转换和链接

有了擎天柱，你不仅可以链接擎天柱变形，还可以链接火花操作👏。让我们来看看这个:

。行和。 cols 可能会觉得有点冗长，但是看看你如何可以很容易地看到你的数据发生了什么，哪些列或行受到了影响，以及将要应用什么转换。

通过链接，您可以利用 Spark 惰性评估的强大功能。链接转换，apache Spark 将通过 Catalyst 处理这个问题的更好的方法。

df = df\
    .rows.sort(["rank","height"])\
    .cols.lower(["names","function"])\
    .cols.remove_accents("names")\
    .cols.remove_special_chars("names")\
    .cols.trim("names").show()+---------+------+---------+----+
|    names|height| function|rank|
+---------+------+---------+----+
|  optimus|  28.0|   leader|  10|
| ironhide|  26.0| security|   7|
|bumblebee|  17.5|espionage|   7|
+---------+------+---------+----+

嵌套操作

这是从多个列创建一个新列的操作*->1。()可以压缩到字符串、数组或向量列。

df.cols.nest(["names", "function"], output_col = "new_col", shape ="string").show()+---------+------+---------+----+-------------------+
|    names|height| function|rank|            new_col|
+---------+------+---------+----+-------------------+
|  optimus|  28.0|   leader|  10|     optimus leader|
| ironhide|  26.0| security|   7|  ironhide security|
|bumblebee|  17.5|espionage|   7|bumblebee espionage|
+---------+------+---------+----+-------------------+

非嵌套操作

从单个列创建多个列的操作 1--> *。 unnest() 可以扩展字符串、数组和向量列。

df.cols.unnest("new_col", " ").cols.drop("new_col")+---------+------+---------+----+---------+---------+
|    names|height| function|rank|new_col_0|new_col_1|
+---------+------+---------+----+---------+---------+
|  optimus|  28.0|   leader|  10|  optimus|   leader|
| ironhide|  26.0| security|   7| ironhide| security|
|bumblebee|  17.5|espionage|   7|bumblebee|espionage|
+---------+------+---------+----+---------+---------+

自定义转换

Spark 有多种多样的方式来转换数据:

列表达式
南非民主统一战线(United Democratic Front)
熊猫 UDF
结构化查询语言
RDD

这里的问题是你必须学习如何处理每个 API 的细节。Optimus 有两个函数 apply() 和 apply_expr() ，在其中你可以实现函数(UDF 或熊猫 UDF)或列表达式。

from pyspark.sql import functions as F
def func(value, args):
    return value + 1df\
    .cols.apply("height", func, "int")\
    .cols.apply_expr("rank", F.col("rank")+1)\
    .show()+---------+------+---------+----+
|    names|height| function|rank|
+---------+------+---------+----+
|  optimus|    29|   leader|  11|
| ironhide|    27| security|   8|
|bumblebee|    18|espionage|   8|
+---------+------+---------+----+

列表达式是最快的，所以总是尝试将它们与 apply_expr() 一起使用

如果你需要更多的灵活性，你可以使用 apply() 来转换你的数据。如果 PyArrow 出现，apply() 将尝试使用熊猫 UDF，否则擎天柱将退回到标准的 UDF。

熊猫 UDF 比标准 UDF 快很多。检查下面的基准:

Pandas UDF Vs UDF

如图表所示，Pandas UDFs 的性能比一次一行的 UDF 好得多，从 3 倍到 100 倍不等。https://databricks . com/blog/2017/10/30/introducing-vectorized-UDFs-for-py spark . html

抽象 UDF

Optimus 提出了抽象 UDF 的概念，其中你可以使用列表达式、UDF 和熊猫 UDF，而不用担心下划线的实现。抽象 udf 函数就是什么权力 apply() 和 apply_expr()。

from optimus.functions import abstract_udf as audf
def func(val, args):
    return val>8df.rows.select(audf("rank", func, "bool")).show()+-------+------+--------+----+
|  names|height|function|rank|
+-------+------+--------+----+
|optimus|  28.0|  leader|  10|
+-------+------+--------+----+

你可以发挥想象力，使用一些论据:

def func(val, args):
    return val+args[0]+args[1]df.withColumn("height", audf ("height", func, "int", [1,2])).show()+---------+------+---------+----+
|    names|height| function|rank|
+---------+------+---------+----+
|  optimus|    31|   leader|  10|
| ironhide|    29| security|   7|
|bumblebee|    20|espionage|   7|
+---------+------+---------+----+

或者只使用列表达式

def func(col_name, args):
    return F.col(col_name) + argsdf.withColumn("height", audf ("height", func, "int", 2, "column_exp")).show()+---------+------+---------+----+
|    names|height| function|rank|
+---------+------+---------+----+
|  optimus|  30.0|   leader|  10|
| ironhide|  28.0| security|   7|
|bumblebee|  19.5|espionage|   7|
+---------+------+---------+----+

正如你所看到的，可以将抽象 udf 与标准 Spark 函数一起使用。

结构化查询语言

如果你觉得使用 SQL 很舒服，你可以通过 df.sql() 轻松使用它。例如:

df.registerTempTable("autobots")
df.sql("SELECT * FROM autobots").show()+---------+------+---------+----+
|    names|height| function|rank|
+---------+------+---------+----+
|  optimus|  28.0|   leader|  10|
| ironhide|  26.0| security|   7|
|bumblebee|  17.5|espionage|   7|
+---------+------+---------+----+

目标 2:让用户轻松地从熊猫迁移

让我们再次回顾一下池图表:

在总共 106 名投票者中，73%的人使用熊猫作为数据清理库。这给了我们一个很好的启示，告诉我们应该如何对待擎天柱。让擎天柱对熊猫尽可能友好。

在总共 106 名投票者中，73%的人使用熊猫作为数据清理库。

考虑到这一点，我们搜索并找到了来自 riselab 的 Devin Petersohn 的惊人作品。他在 ka ggle(https://rise . cs . Berkeley . edu/blog/Pandas-on-ray-early-lessons/)上发表了一篇关于更常用的 Pandas 方法的文章。我们用这个来增强和调整擎天柱。下面你可以找到这个功能，以及它与 Spark 和 Optimus 的比较。

Top 20 most used Pandas compared with Spark and Optimus

NI=未实施
NA=未实施

我们实现了几乎所有可以应用于 Spark 的函数(暂时没有 get 或者 subtract )。有些像 reset_index() 是不可能的，因为 Spark 不处理索引。

这一定够每个熊猫新人追上擎天柱了🙌

让数据探索更容易

Optimus 有一个强大的内置数据分析器，除了所有的基本操作外，它还能给你一些独特的东西。您可以看到特定列中存在多少数据类型。

例如，您有一百万行，颜色值为白色、黑色、红色和数百种其他颜色。你怎么能确定一百万行中没有“1”呢？此功能是一个额外的步骤，可以帮助您使您的数据处于完美的状态，以做您的 ML 和 DL 模型。

Optimus Profiler

但是我们想更进一步。虽然 Jupyter 笔记本是一个不可思议的数据转换和模型创建工具，但我们认为数据探索领域可以大大改进。工作区似乎永远不足以可视化你的东西，你有很多绘图选项，如 plotly，seaborn，matplotlib an a big 等，每个人都有不同的 API，你必须做很多工作才能使它们交互。

🚗大黄蜂 Alpha 卷展

我们希望为用户提供探索数据的最佳工具。

Bumblebee 是一个使用 Vue.js 构建的 GUI，它与 Optimus 协同工作，并向您准确地展示您需要什么来决定如何转换您的数据。

Bumbleebee in action

此刻，邦布尔伯可以:

使用交互式绘图浏览您的数据。
轻松检查丢失的数据。
查看数据样本以检查数据结构。
查看描述性和分位数分析。
查看直方图和频率表。
检测数字和分类列，并相应地为您提供额外的数据。

大黄蜂和擎天柱不是直接连在一起的。事实上，Bumblebee 可以与从 Pandas 到 dplyr(R)的任何数据处理库一起使用。如果你想从你最喜欢的库中创建一个“连接器”,你只需要用 bumblebee 格式写一个 JSON 文件。

想了解更多关于大黄蜂的信息，请访问 Github repo 。

包裹

我们希望 Optimus/Bumblebee 成为处理、探索和制作大数据模型的事实库。为此，我们需要您的反馈，所以我们将推出 Optimus v2 的测试版，为期几周，以听取您对我们所走道路的意见。

如果您想投稿，请:

安装擎天柱，玩一玩，跟我们说说你在 Gitter 上的经历。
如果你对擎天柱对我们的回购有意见，请填写问题。

在这里，我们只是在探索擎天柱的表面功能。请访问 docs.hioptimus.com 的，访问我们的网站或访问笔记本示例，看看 Optimus 能为您的数据做些什么。

宣布数据旅程播客

原文：https://towardsdatascience.com/announcing-the-data-journeys-podcast-57dbbab0f21e?source=collection_archive---------19-----------------------

我很激动地宣布我的新播客正式发布，数据之旅:https://www.ajgoldstein.com/podcast/

数据之旅是一个面向有抱负的数据科学家的播客，在这里我将采访世界级的数据科学家，讲述他们的学习之旅。

在每一集里，我们的目标是让他们讲述自己的故事，用世界上最优秀的人曾经使用过的战略、战术和工具来装备后起之秀，让他们达到今天的成就。

我与从美国军方到硅谷、从学术界高层到澳大利亚基层的嘉宾交谈，重点是他们如何弥合获取技术技能和创造现实世界影响之间的差距。

例如，两位即将到来的嘉宾是斯坦福大学 Coursera 的联合创始人吴恩达和加州大学伯克利分校 Jupyter 笔记本的创始人费尔南多·佩雷兹。

你可以通过 iTunes、Soundcloud、Google Play Music 等网站的链接收听或订阅该节目:https://www.ajgoldstein.com/podcast/

享受表演吧！

[## 播客

数据之旅数据之旅是 AJ Goldstein 为有抱负的数据科学家制作的播客，他采访了世界一流的…

www.ajgoldstein.com](https://www.ajgoldstein.com/podcast)

宣布推出新的文本分析 Excel 插件版本:这是什么改进！

原文：https://towardsdatascience.com/announcing-the-launch-of-new-text-analytics-excel-add-in-version-heres-what-improved-c3592a9a162?source=collection_archive---------11-----------------------

去年 11 月，我们推出了 Excel 插件，作为我们为那些想使用我们的文本分析产品而无需编写一行代码的用户提供的服务的重要组成部分。这个插件已经被下载了 1000 多次，用来分析超过百万行文本。

我们还从用户那里得到了一些关于 Excel 插件的反馈。在 ParallelDots，我们将客户的反馈放在心上，因此，我们很高兴地宣布我们新的改进版 ParallelDots Excel 加载项的发布。新版本可以立即下载，并且可以从这里访问。

这个新的、改进的 Excel 加载项版本将具有以下主要功能:

不需要记住 API 键:使用你的 ParallelDots 帐户直接从加载项的任务窗格登录。

修复了错误并提高了稳定性:当前版本不会冻结超过 1000 行的数据，并允许您在分析数据时最小化 Excel 以执行其他任务。它还为您提供了一个任务进度条，这样您就知道已经分析了多少文本。

3.在任务窗格中检查您的 API 使用情况:登录您的帐户后，您可以在任务窗格中检查 API 使用情况。免费和高级用户都可以使用。

感谢您的反馈和建议，这有助于我们使这个版本更加稳定和用户友好。

安全和隐私

Excel 插件建立在我们的 API 上，这意味着您的数据在我们的服务器上处理，以获得最终输出。我们非常重视用户隐私，我们的隐私政策可在此处访问。所有用户数据都根据我们的隐私政策进行存储，以确保高标准的安全性。

然而，在某些情况下，由于合同义务或其他原因，用户可能希望将数据保存在内部，在这种情况下，我们可以在内部部署这些算法，并相应地构建插件。请向我们发送一个请求来部署本地 API 和您希望我们构建的任何自定义功能。

我们希望新的插件版本将帮助您分析客户满意度调查中成千上万个开放式问题的答案，或者分析来自电子商务门户网站的产品评论，而无需离开您舒适的电子表格。

点击阅读更多关于 Excel 插件的使用案例。

Excel 插件已被证明是一种强大且经济高效的方式，可以开始将尖端智能添加到您的分析中。在您决定扩展您的分析之前，大量的免费层可让您测试并了解加载项中可用的不同功能。

我们希望你喜欢这篇文章。请注册免费的 ParallelDots 账户，开始你的 AI 之旅。你也可以在这里查看的人工智能 API 的演示。

异常检测-关键特性

原文：https://towardsdatascience.com/anomaly-detection-def662294a4e?source=collection_archive---------2-----------------------

我最近与 CleverTap 合作了一个项目，其中包括为定期拥有时间序列类型数据的客户创建“异常检测”功能。异常检测对于每个营销人员密切关注公司的发展非常有帮助。在我实习期间，我们实现了一些基本方法，然后转向更复杂的算法。

“这个特性有什么帮助？”

异常检测可以手动完成。但是由于事件和 KPI 的增加，这个任务很难维持。此外，营销人员没有兴趣知道异常是否发生在 4 个月或 6 个月前。因此，如果营销人员每天都收到异常情况发生时的警报，这将有助于找到其背后的原因，并尽快修复它。这就是为什么我们决定每天都这样做，如果事件以令人惊讶的方式发生，营销人员将收到“检测到异常”的警报。

“什么是异常？”

在深入研究我们开发的这项功能背后的算法之前，我们先来回答上面的问题。

“异常是观察到的世界中意料之外的行为”。

从营销人员的角度来看，异常的例子有 :

电影票销售数量的减少。
该应用程序的下载量上升。
网站访问量的增加。

异常可以是正的，也可以是负的。积极的异常现象在市场上最受欢迎。

“有哪些方法？”

有各种方法来检测异常。在讨论这些方法之前，让我们先看看我们的时间序列数据。

Figure 1: Time Series of a number of visits to a particular website.

这里，图 1 中的时间序列是社交媒体上特定网站每天的访问次数的数据示例(横轴为日期，纵轴为计数)。在这个时间序列中，我们的目标是能够检测到 1 月 21 日之后的异常情况。

1.移动平均法:

在这种方法中，借助于过去数据的移动平均值，可以估计当前值。移动平均线可以是指数移动平均线或简单移动平均线。与简单移动平均线给出的同等权重不同，指数移动平均线给最近的数据更多的权重。

该方法可以通过两种方式执行 :

A.每日移动平均线

在我们将要讨论的所有方法中，这是一个非常基本且易于执行的方法。在这种方法中，前几天的移动平均值被认为是当天的期望值。下一步包括检查估计值是否在预定义的置信带内。置信区间是一个范围，我们将其定义为前一天移动平均线的标准差的倍数

在对上述时间序列应用该算法后，产生了两个异常 :

Figure 2 : Anomalies detected in Moving Average Method(daily basis) are flagged.

下表解释了上述标记值的异常性质:

Figure 3 : Results from MA(Daily Basis) method.

如果我试着用置信带来表示，2 月 3 日的反常性质可以解释如下:

Figure 4 : Plot showing the anomalous nature of 3rd February through Confidence band.

在上图中，该值被标记为(异常)，因为它超过了当天的预期最大值(置信区间上限)。

B.工作日移动平均值

这个方法是对上面解释的方法的一个微小的修改。在这种方法中，会考虑以前工作日的数据。也就是说，为了估计当前星期一的价值，以前星期一的数据是有用的。置信区间是以前工作日数据标准差的倍数。

Figure 5: Anomalies detected in Moving Average Method(Weekday basis) are flagged

上图中的反常自然点可以用下表来解释:

Figure 6: Results from MA(Weekday Basis)

但是这种方法也导致了类似 2 月 4 日(星期日)的虚假异常。我们来看看周日的数据:

Figure 7: Sunday Counts

如果你看上面显示周日数据的表格，你会发现在 2 月 4 日之前，访问量平稳增长。因此，这不是一个异常现象。相反，它应该将 2 月 18 日显示为异常，因为正如您从上表中看到的，计数在 2 月 18 日突然下降。

ARIMA :

与上面的方法相比，这是一种更复杂的方法。 ARIMA (自回归综合移动平均)方法优于上述方法，因为它使用了自回归和移动平均的组合来估计当天的值。

Figure 8: Anomalies detected in the ARIMA method are flagged

上述各点的异常性质如下:

Figure 9: Results from ARIMA method

ARIMA 模型检测到这些点是一个异常，乍一看似乎是一个异常。

3.先知:

脸书出版的《预言家》使用了加性回归模型。这个模型有助于发现异常。Prophet 通过从数据中选择变化点来自动检测趋势的变化，并通过傅立叶变换等技术对季节成分(年、月)进行一些修改。Prophet 使用蒙特卡罗模拟来估计不确定性区间。“不确定性 _ 样本”参数控制模拟。它是用于估计不确定性区间的样本数(默认为 1000)。我们可以使用“interval_width”参数设置这个间隔的宽度。

Figure 10: Anomalies detected in the Prophet method are flagged

Prophet 根据下表计算了异常情况:

Figure 11: Results from Prophet method

SH-ESD :

在我实习期间，我们希望实现一些简单的统计计算和更透明的过程。Twitter 发布了季节性杂交极端学生化偏离技术。在 CleverTap 我们修改了(S-ESD)算法并试图实现它。

算法

这一两步过程允许 SH-ESD 检测超出预期季节性最小值和最大值的全球异常和被季节性掩盖的局部异常。

这种改进的算法是在时间序列的“余数”部分上实现的。

残差=时间序列—中位数—季节性

“为什么余数？”

上式中的“余数”项是时间序列中“无法解释的部分”。残差具有单峰分布，该分布服从于异常检测技术的应用，例如 ESD( 极端学生化偏差)。

残差计算:

如上所述，残差计算对于无法解释的行为非常重要。在计算残差时，从原始值中去除了中值和季节性。

Figure 12: Remainder component of the time series

这里，季节性是使用STL变量法计算的(使用黄土法计算季节性)。使用中值代替趋势，以避免虚假异常。

“为什么季节性被去除了？”

考虑一个电影预订应用程序，其中电影票的销售额在每个星期六都很高，那么特定一周中的星期六的高价值对于营销人员来说不应该是一个惊喜。因此，季节性被去除以避免由于季节性行为造成的虚假异常。

“如何处理剩余组件？”

为了找出异常值，我们对剩余数据进行了修正的 ESD 测试。这种改进的 ESD 测试分为两步:

。该测试的第一步是计算修改后的 z 分数。这是对原始分数低于或高于中位数的平均偏差的度量。z 分值越高，意味着与中位数的平均偏差越高。

修改后的 Z 得分= (X 中值)/MAD

X =原始数据

MAD =中位数绝对偏差

注意:与一般的 z 值不同，中值和 MAD(中值绝对偏差)术语用于代替“平均值”和“标准差”。原因是后来离群值对它们有更多的影响。这解释了上述术语中的“修改”部分。

。第二步从移除与中值偏差最大的值开始。我们再次计算 Z 得分的新值。在应用置信度后，新的修改后的 z 分值将给出实际的异常值。原始数据中对应于残差数据中异常值索引的值是异常值。

Figure 13: Anomalies detected from the modified SH-ESD method

在对剩余数据进行修改后的 ESD 测试后，结果标记为 1 月 31 日，乍一看并不像异常。

“为什么 1 月 31 日是个例外？”

由于我们使用的是每周季节性，周三图应该可以解释 1 月 31 日的反常性质。

Figure 14: The above plot shows the Wednesday trend

1 月 31 日周三数据计数的下降导致了一个异常现象。

“如何利用异常信息？”。

有许多方法可以使用这些信息。此功能的主要用途是，营销人员将收到警报，这将有助于保护这种异常行为的任何负面影响。

考虑一个例子，其中应用规范已经被修改，第二天公司收到关于应用下载数量突然减少的警报。营销人员会在公司特定团队的帮助下，试图在修改后的规范中找到问题。

结论:

我们看到了各种检测异常的方法。这些方法在执行难度和结果方面各不相同。移动平均等基本方法易于执行，但结果较差，而 ARIMA、Prophet 等复杂方法的结果较好，但在大型数据库级别难以执行。因此，改进的 SH-ESD 是最好的方法，具有简单的统计计算、更透明的过程和令人敬畏的结果。

基于机器学习的移动传感器数据异常检测

原文：https://towardsdatascience.com/anomaly-detection-in-mobile-sensor-data-48ef62d0f7fc?source=collection_archive---------3-----------------------

本帖摘自我们的解决方案教程—“收集、可视化和分析物联网数据”。该教程将引导您设置物联网设备，在 Watson 物联网平台中收集移动传感器数据，探索数据并创建可视化效果，然后使用高级机器学习服务来分析数据并检测历史数据中的异常。

那么，什么是异常检测呢？

异常检测是一种用于识别不符合预期行为的异常模式(称为异常值)的技术。它在商业中有许多应用，从入侵检测(识别网络流量中可能预示黑客攻击的奇怪模式)到系统健康监控(在 MRI 扫描中发现恶性肿瘤)，从信用卡交易中的欺诈检测到操作环境中的故障检测。

在我们的日常生活中，无论是有意还是无意，我们都会携带物联网设备。它是我们内置传感器的手机，提供来自加速度计和陀螺仪的数据。将这些传感器数据保存在某个地方并检测数据中的异常情况如何？

那听起来是个很酷的主意。如何才能实现这一点？我需要编写一个应用程序并要求用户从商店下载吗？不需要。运行在移动浏览器上的简单 node.js 应用程序将为我们提供传感器数据。

本教程使用以下 IBM 云产品:

IBM Watson 物联网平台
Node.js 应用
沃森工作室
IBM 分析引擎
IBM 云对象存储
IBM Cloudant

这是流程或架构图，

Architecture diagram

因此，您将创建一个 node.js 应用程序，在浏览器上运行它，将加速度计和陀螺仪数据存储到 Cloudant NoSQL 数据库，然后我如何检测异常？

这就是 IBM Watson Studio 派上用场的地方。您将使用 IBM Watson Studio 服务中提供的 Jupyter 笔记本来加载历史数据，并使用 z-score 检测异常。您将首先创建一个新项目，然后导入 Jupyter 笔记本(。ipynb)通过 URL。

将使用 z 分数进行异常检测。Z-score 是一个标准分数，表示一个元素相对于平均值的标准偏差。可以通过以下公式计算 z 得分:z = (X - µ) / σ其中 z 是 z 得分，X 是元素的值，是总体均值，σ是标准差。

此链接https://cloud.ibm.com/docs/solution-tutorials?提供最新教程 topic =解决方案-教程-收集-可视化-分析-物联网-数据

又一次机器学习演练和挑战

原文：https://towardsdatascience.com/another-machine-learning-walk-through-and-a-challenge-8fae1e187a64?source=collection_archive---------3-----------------------

不要只是阅读机器学习——实践它！

在花费大量时间和金钱学习课程、书籍和视频后，我得出了一个结论:学习数据科学最有效的方法是做数据科学项目。阅读、倾听和记笔记是有价值的，但是直到你解决了一个问题，概念才从抽象固化为你有信心使用的工具。

在本文中，我将介绍 Python 中的另一个机器学习演练，并留给您一个挑战:尝试开发一个更好的解决方案(包括一些有用的技巧)！这个项目完整的 Jupyter 笔记本可以在 Kaggle 上运行——不需要下载——或者在 GitHub 上访问。

问题陈述

目前正在 Kaggle 上运行的纽约市出租车费用预测挑战赛，是一项监督回归机器学习任务。给定上下车地点、上下车时间戳和乘客数量，目标是预测出租车的费用。像大多数 Kaggle 竞赛一样，这个问题并不能 100%反映行业中的问题，但它确实提供了一个现实的数据集和任务，我们可以在其上磨练我们的机器学习技能。

为了解决这个问题，我们将遵循一个标准的数据科学管道攻击计划:

了解问题和数据
数据探索/数据清理
特征工程/特征选择
模型评估和选择
模型优化
结果和预测的解释

这个大纲似乎从头到尾呈现了一个线性路径，但数据科学是一个高度非线性的过程，其中的步骤是重复的或无序完成的。随着我们对数据越来越熟悉，我们经常想回去重新审视我们过去的决定或采取新的方法。

虽然最终的 Jupyter 笔记本可能会呈现一个有凝聚力的故事，但开发过程非常混乱，包括重写代码和更改早期的决定。

在整篇文章中，我会指出一些我认为有进取心的数据科学家——您——可以改进我的解决方案的地方。我将这些潜在的改进标记为因为作为一个主要的经验领域，机器学习没有保证。

New York City Taxi Fare Prediction Challenge (Link)

入门指南

出租车费用数据集相对较大，有 5500 万个训练行，但易于理解，只有 6 个特征。fare_amount是目标值，我们将训练一个模型来预测的连续值:

Training Data

在整个笔记本中，我只使用了 5，000，000 行样本来加快计算速度。因此，我的第一个建议是:

潜在改进 1:使用更多数据训练模型

不确定大量的数据是否会有所帮助，但是经验研究发现，一般来说，随着用于训练模型的数据量增加，性能也会提高。根据更多数据训练的模型可以更好地学习实际信号，特别是在具有大量特征的高维问题中(这不是高维数据集，因此使用更多数据的回报可能有限)。

尽管数据集的庞大规模可能令人生畏，但是像 Dask 这样的框架允许你在个人笔记本电脑上处理甚至是海量的数据集。此外，一旦数据超出了你的机器的能力，学习如何设置和使用云计算，比如 Amazon ECS，是一项至关重要的技能。

幸运的是，理解这些数据并不需要太多的研究:我们大多数人以前都乘坐过出租车，我们知道出租车是根据行驶里程收费的。因此，对于特征工程来说，我们需要找到一种方法，根据给定的信息来表示行进的距离。我们也可以阅读其他数据科学家的笔记本或竞赛讨论来寻找解决问题的方法。

数据探索和清理

尽管 Kaggle 数据通常比真实世界的数据更干净，但该数据集仍存在一些问题，即多个要素中存在异常。我喜欢将数据清理作为探索过程的一部分，纠正我发现的异常或数据错误。对于这个问题，我们可以通过使用df.describe()查看数据的统计来发现异常值。

Statistical description of training data

通过结合领域知识和查看数据分布，解决了passenger_count、坐标和fare_amount中的异常。例如，阅读纽约市的出租车费用，我们看到最低费用金额为 2.50 美元，这意味着我们应该根据费用排除一些乘坐。对于坐标，我们可以查看分布，并排除那些超出正常范围的值。一旦我们确定了异常值，我们就可以使用如下代码来删除它们:

*# Remove latitude and longtiude outliers*
data = data.loc[data['pickup_latitude'].between(40, 42)]
data = data.loc[data['pickup_longitude'].between(-75, -72)]
data = data.loc[data['dropoff_latitude'].between(40, 42)]
data = data.loc[data['dropoff_longitude'].between(-75, -72)]

一旦我们清理了数据，我们就可以进入有趣的部分:可视化。下面是纽约市上下客地点的图表，用装箱后的票价进行着色(宁滨是将连续变量转化为离散变量的一种方式)。

Pickups and Dropoffs plotted on New York City

我们还想看看目标变量。以下是目标变量票价金额的经验累积分布函数(ECDF) 图。对于一个变量来说，ECDF 可能是比直方图更好的可视化选择，因为它没有来自宁滨的伪像。

ECDF of Target

除了看起来有趣之外，图可以帮助我们识别异常、关系或新功能的想法。在地图中，颜色代表票价，我们可以看到从机场(右下角)开始或结束的票价往往是最贵的。回到领域知识，我们读到去 JFK 机场的标准费用是 45 美元，所以如果我们能找到识别机场乘车的方法，那么我们就能准确地知道费用。

虽然我在这本笔记本中没有谈到那么远，但是使用领域知识进行数据清理和特性工程是非常有价值的。我的第二个改进建议是:

潜在改进 2:试验不同的离群点去除和数据清理方法。

这可以通过领域知识(如地图)或统计方法(如 z 分数)来完成。解决这个问题的一个有趣的方法是在这个笔记本中，作者删除了在水中开始或结束的游乐设施。

包含/排除异常值会对模型性能产生重大影响。然而，像机器学习中的大多数问题一样，没有标准的方法(这里有一个 Python 中的统计方法你可以试试)。

特征工程

要素工程是从现有数据集中创建新要素(预测变量)的过程。因为一个机器学习模型只能从给定的特征中学习，这是机器学习流水线中 最重要的一步。

对于有多个表和表之间关系的数据集，我们可能想要使用自动化特征工程，但是因为这个问题只有相对较少的列和一个表，我们可以手工构建一些高价值的特征。

例如，因为我们知道乘坐出租车的费用与距离成正比，所以我们想要使用起点和终点来尝试并找到行驶的距离。距离的一个粗略近似值是起点和终点纬度和经度之差的绝对值。

# Absolute difference in latitude and longitude
data['abs_lat_diff'] = (data['dropoff_latitude'] - data['pickup_latitude']).abs()data['abs_lon_diff'] = (data['dropoff_longitude'] - data['pickup_longitude']).abs()

功能不一定要复杂才有用！下面是这些新功能的图表，用装箱的费用来着色。

Absolute Longitude vs Absolute Latitude

这些特征给我们的是距离的相对度量，因为它们是根据纬度和经度计算的，而不是实际的度量。这些特征对于比较是有用的，但是如果我们想要以公里为单位进行测量，我们可以在旅行的开始和结束之间应用哈弗辛公式，该公式计算大圆距离。这仍然是一个近似值，因为它给出了沿着地球球形表面(我被告知地球是一个球体)上连接两点的直线的距离，显然，出租车不是沿着直线行驶的。(详见笔记本)。

Haversine distance by Fare (binned)

这个问题的其他主要特征来源是基于时间的。给定一个日期和时间，我们可以提取许多新的变量。构建时间特性是一项常见的任务，我在笔记本中包含了一个有用的函数，它可以从一个时间戳构建十几个特性。

Fare amount colored by time of day

虽然我在这个项目中构建了将近 20 个特性，但是还有更多的特性有待发现。特征工程最难的部分是你永远不知道什么时候你已经用尽了所有的选择。我的下一个建议是:

潜在的改进 3:构建更多的特征或将特征选择应用于现有的特征，以找到最优集合。

特征工程还包括问题专家或应用自动为你构建特征的算法。在构建特征之后，你经常需要应用特征选择来找到最相关的特征。

一旦有了干净的数据和一组特征，就可以开始测试模型了。尽管特征工程在大纲建模之前，我经常在项目过程中一次又一次地回到这一步。

模型评估和选择

建立回归任务基线的首选模型是简单的线性回归。此外，如果我们查看该问题中要素与票价金额的 Pearson 相关性，我们会发现如下所示的几个非常强的线性关系。

Pearson Correlations of Features with Target

基于一些特征和目标之间的线性关系的强度，我们可以期望线性模型做得相当好。虽然集成模型和深度神经网络得到了所有的关注，但如果一个简单、可解释的模型可以实现几乎相同的性能，那么就没有理由使用过于复杂的模型。尽管如此，尝试不同的模型仍然是有意义的，特别是因为它们很容易用 Scikit-Learn 来构建。

初始模型是一个只对三个特征(abs位置差异和passenger_count)进行训练的线性回归，其验证均方根误差(RMSE)为 5.32 美元，平均绝对百分比误差为 28.6%。简单线性回归的好处是，我们可以检查系数，例如，根据模型，一名乘客的增加会使票价增加 0.02 美元。

# Linear Regression learned parametersIntercept 5.0819
abs_lat_diff coef:  113.6661 	
abs_lon_diff coef: 163.8758
passenger_count coef: 0.0204

对于 Kaggle 竞赛，我们可以使用验证集(这里我使用了 1，000，000 个示例)和向竞赛提交测试预测来评估模型。这使我们能够将我们的模型与其他数据科学家进行比较-线性回归放置大约 600/800。理想情况下，我们希望只使用测试集一次，以评估我们的模型在新数据上的表现，并使用验证集(或交叉验证)执行任何优化。Kaggle 的问题是，排行榜可能会鼓励竞争对手建立对测试数据过度优化的复杂模型。

我们还希望将我们的模型与不使用机器学习的原始基线进行比较，在回归的情况下，原始基线可以猜测训练集上目标的平均值。这导致 9.35 美元的 RMSE，这使我们有信心机器学习适用于该问题。

即使在额外的特征上训练线性回归也不会产生很高的排行榜分数，下一步是尝试更复杂的模型。我的下一个选择通常是随机森林，这也是我上交这个问题的地方。与线性回归相比，随机森林是一种更灵活的模型，这意味着它具有更小的偏差，可以更好地拟合训练数据。随机森林通常也具有低方差，这意味着它可以推广到新数据。对于这个问题，随机森林优于线性回归，在相同的功能集上实现了 4.20 美元的验证 RMSE。

Test Set Prediction Distributions

随机森林通常优于线性回归的原因是因为它具有更大的灵活性——更低的偏差——并且它减少了方差，因为它将许多决策树的预测结合在一起。线性回归是一种简单的方法，因此具有较高的偏差，它假设数据是线性的。线性回归也可能受到异常值的高度影响，因为它以最小的误差平方和来求解拟合。

模型(和超参数)的选择代表了机器学习中的偏差-方差权衡:具有高偏差的模型甚至无法准确地学习训练数据，而具有高方差的模型本质上是记忆训练数据，无法推广到新的例子。因为机器学习的目标是对新数据进行归纳，所以我们想要一个同时具有低偏差和低方差的模型。

一个问题上的最佳模型不一定是所有问题上的最佳模型，因此研究跨越复杂范围的几个模型是很重要的。应使用验证数据评估每个模型，然后在模型调整中优化表现最佳的模型。由于验证结果，我选择了随机森林，并且我鼓励您尝试一些其他模型(或者甚至将模型组合在一起)。

模型优化

在机器学习问题中，我们有几种提高性能的方法:

获取更多数据
构建更多特征/执行特征选择
优化选择的模型
尝试更复杂的模型

1 英镑仍有收益。第二。(这是挑战的一部分)，但我也想提供一个优化所选模型的框架。

模型优化是在给定数据集上为模型找到最佳超参数的过程。因为超参数的最佳值取决于数据，所以对于每个新问题，都必须再次这样做。

我喜欢将模型优化(也称为模型调整)视为寻找机器学习模型的理想设置。

优化的方法有很多种，从手动调整到自动超参数调整，但是在实践中，随机搜索效果很好，并且易于实现。在笔记本中，我提供了运行随机搜索进行模型优化的代码。为了使计算时间合理，我再次对数据进行采样，只运行了 50 次迭代。即使这样也需要相当长的时间，因为超参数是使用三重交叉验证来评估的。这意味着在每一次迭代中，模型都要用超参数的选定组合训练 3 次！

The best parameters were {'n_estimators': 41, 'min_samples_split': 2, 'max_leaf_nodes': 49, 'max_features': 0.5, 'max_depth': 22, 'bootstrap': True}with a negative mae of -2.0216735083205952

我还尝试了许多不同的功能，发现最好的模型只使用了 27 个功能中的 12 个。这是有意义的，因为许多特性是高度相关的，因此是不必要的。

Heatmap of Correlation of Subset of Features

在运行随机搜索并选择特征之后，最终的随机森林模型实现了 3.38 的 RMSE，这表示 19.0%的百分比误差。这比原始基线的误差减少了 66%，比第一个线性模型的误差减少了 30%。这种表现说明了机器学习中的一个关键点:

特征工程的回报远远大于模型优化的回报。因此，在开始担心是否有最好的超参数之前，确保您有一组好的特征是至关重要的。

尽管我运行了 50 次随机搜索迭代，超参数值可能还没有完全优化。我的下一个建议是:

潜在的改进 4:在更多的数据上运行更多迭代的模型调优。

这样做的回报可能会比特性工程少，但是仍然有可能发现性能的提高。如果您觉得能够胜任这项任务，您也可以使用诸如 Hyperopt 之类的工具来尝试自动化模型调优(我写了一个指南，可以在这里找到)。)

解释模型并做出预测

虽然随机森林比线性回归更复杂，但它不是一个完整的黑箱。一个随机森林由一群决策树组成，这些决策树本身就是非常直观的流程图模型。我们甚至可以检查森林中的每棵树，了解它们是如何做决定的。查看随机森林黑盒的另一种方法是检查特征的重要性。技术细节目前并不重要，但是我们可以使用相对值来确定哪些特性被认为与模型相关。

Feature Importances from training on all features

到目前为止，最重要的特征是乘坐出租车的欧几里德距离，其次是时间变量之一的pickup_Elapsed。鉴于我们制造了这两个特性，我们应该相信我们的特性工程得到了很好的利用！因为我们不需要保留所有的变量，所以我们也可以突出特征工程或选择的重要性。

最后，我们可以看看验证数据和测试数据上的模型预测。因为我们有了验证答案，我们可以计算预测的误差，并且我们可以检查极值的测试预测(在线性回归中有几个)。下面是最终模型的验证预测图。

Random Forest validation predictions and true values.

模型解释仍然是一个相对较新的领域，但是有一些有前途的方法来检查模型。虽然机器学习的主要目标是对新数据做出准确的预测，但同样重要的是要知道为什么模型是准确的，以及它是否能教会我们关于这个问题的任何东西。

后续步骤

尽管我们尝试了许多不同的技术并实现了一个完整的解决方案，但仍有一些步骤可以改进模型。我的下一个方法是尝试一个更复杂的模型，比如深度神经网络或梯度推进机器。我还没有在笔记本上实现这些，但是我正在努力实现它们。我让你先试试(我不能把所有答案都给你！).

潜力提升 5:尝试更复杂的型号如 梯度增压机

有了机器学习项目，总是有更多的方法可以尝试，如果你对现有的选项不满意，你甚至可以想出自己的方法！机器学习在很大程度上是一个经验领域，没有标准化的规则，知道某样东西是否有效的唯一方法是测试它。

在这一点上，我将留给您自己的设备来改进模型。我已经给了你五个不同的建议，应该可以让你打破我在笔记本上取得的最好的交叉验证分数。

Final Model Results

这当然是一个友好的挑战，所以不要沮丧，如果你需要帮助，不要犹豫。所有这些建议都是潜在的改进，因为我不能保证它们会提高分数。尽管如此，我知道构建一个更好的模型是可能的，我也会努力尝试并构建它！

如果你需要更多的灵感，这里有我做过的另外两个完整的机器学习项目，可以给你一些思路:

Python 中的数据科学 for Good Machine Learning 项目演练(两部分)
Python 中完整的机器学习演练(三部分)

接下来的步骤就看你的了！

结论

在这篇文章和附带的 Jupyter 笔记本中，我展示了一个真实数据集上的完整机器学习走查。我们用 Python 代码实现了该解决方案，并触及了机器学习中的许多关键概念。机器学习不是一门神奇的艺术，而是一门可以通过重复磨练的手艺。没有什么可以阻止任何人学习如何使用机器学习来解决现实世界的问题，而变得熟练的最有效的方法是完成项目。

本着边做边学的精神，我对你们的挑战是改进我在笔记本电脑中的最佳模型，我给你们留下了一些建议，我相信它们会提高性能。在数据科学中没有一个正确的答案，我期待看到每个人都可以提出什么！如果你接受挑战，请在评论中留下你笔记本的链接。希望这篇文章和笔记本已经给了你解决这个问题或其他问题所必需的开始。此外，当您确实需要帮助时，请不要犹豫，因为数据科学界总是支持您。

一如既往，我欢迎反馈、讨论和建设性的批评。可以通过 Twitter @koehrsen_will 或者评论这篇文章找到我。

又一次尝试内核技巧(为什么？)

原文：https://towardsdatascience.com/another-stab-at-the-kernel-trick-why-f73c70ce98dd?source=collection_archive---------16-----------------------

Photo by Markos Mant on Unsplash

有很多很棒的关于支持向量机的教程，以及如何在二分类中应用(这里有一个、还有一个)。但是我想更深入地探究内核技巧以及为什么使用它。

支持向量机依赖于将特征空间扩大到允许两个类别可由线性超平面分开的维度。实现这一点的第一种方法更简单，就是转换输入数据。这意味着将输入要素转换为方形、立方体或其他形式，以生成新的附加要素。另一种方法是使用内核。

核是一个函数，它在一个期望的维度上表示两个观察值之间的相似性(数学上由 Mercer 定理定义，有谷歌)。具有相同坐标的两个观测值之间的相似性是 1，并且随着它们之间的欧几里德距离的增加而趋向于 0。

不用太数学化，解决 SVM 优化问题以找到超平面位置所需的计算是观测值之间的内积。内积的输出是一个标量，这意味着我们感兴趣的输出存在于一个维度中，而不是我们为了分离数据而访问的任何疯狂的维度空间。内积计算等价于线性核函数，并在线性空间中表示相似性。

这很重要的原因是，这意味着在更高维度中的观察值与我们无关，我们只关心内积结果。这个内积可以通过方法一的两个步骤来计算，转换输入数据，然后计算内积。或者对输入数据应用内核。方法二的好处是计算效率。

计算效率源于以下事实:核计算比将输入数据变换到线性分离数据所需的更高维度所需的计算更快。

您可以直观地思考为什么这样会更快，因为不需要首先执行数据转换，然后执行内积计算，您只需在一个步骤中应用一个核函数，就可以得到内积结果，瞧！

当问题非常简单，并且只对输入数据进行二次或三次变换就足以允许数据是线性可分的时，使用核技巧没有什么好处。

但是假设你有一个两个类之间的径向边界，如下图所示。要弄清楚如何转换输入数据，以便能够线性地分离下面的类，这是令人难以置信的，因为它的计算成本很高。这就是内核(在这种情况下为径向/高斯)真正发挥作用的地方，观察值之间的相似性计算在转换输入数据时得到了极大的改进。

Image credit: https://chrisalbon.com/machine_learning/support_vector_machines/svc_parameters_using_rbf_kernel/

这只是一个简短的故事(也是我的第一个),关于为什么内核技巧在困难的二进制分类问题中被广泛使用，我希望很快就能在参数调整等方面使用内核技巧。

原载于 2018 年 11 月 17 日【medium.com。

另一个使用 Python 的 Twitter 情感分析—第 1 部分

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-bb5b01ebad90?source=collection_archive---------1-----------------------

Photo by Clint Patterson on Unsplash

距离我上次发帖已经有一段时间了。我不在灵媒期间，我的生活发生了很多事情。我最终鼓起勇气辞去了工作，加入了伦敦大会的数据科学沉浸式课程。

这是我一生中的一个重大决定，但我不后悔。事实上，我认为这是我迄今为止做的最好的决定。这门课程相当紧张，但我很享受其中的每一点。我学到了很多更严谨的数据科学方法，最重要的是，我从导师和同学那里得到的反馈真的帮助我提高了。不容易但是绝对值得！

我目前在第八周，并为我的顶点项目做准备。正如标题所示，这将是关于 Twitter 的情绪分析。

起初，我并不确定我应该为我的顶点做些什么，但毕竟，我感兴趣的领域是自然语言处理，Twitter 似乎是我 NLP 之旅的一个很好的起点。你可以从这里找到我最初的项目创意提案。

给你一个关于这个项目的简要总结，它是关于建立一个可以检测情绪的模型，这样我就可以将这个模型应用到来自不同城市的推文中，并比较/分析来自不同城市的推文有多快乐。这是从我自己的好奇心开始的。对我来说，快乐是生活中相当重要的因素，我认为它很大程度上取决于你的环境。所以很自然地，我想看看不同城市的市民有多幸福。

训练数据

可以有许多不同的方法来进行情感分析，一些库提供了开箱即用的情感分析功能，你可以直接在文本上使用，但这并不有趣(是吗？).所以我决定训练我自己的模型，我可以将它应用到我收集的推文中。为了让一个模型有不错的性能，我需要一个相对较大的数据集来训练。用于训练的数据集，我选择的是源自斯坦福大学的“Sentiment140”。关于数据集的更多信息可以从链接中找到。【http://help.sentiment140.com/for-students/

数据集可以从下面的链接下载。
http://cs . Stanford . edu/people/Alec MgO/training and test data . zip

通过查看链接中数据集的描述，可以找到每个字段的信息。

0 —推文的极性(0 =负，2 =中性，4 =正)
1 —推文的 id(2087)
2—推文的日期(2009 年 5 月 16 日星期六 23:58:44 UTC)
3—查询(lyx)。如果没有查询，那么这个值就是 NO_QUERY。
4 —发推文的用户(robotickilldozr)
5 —推文的文本(Lyx 很酷)

好，我们先来看看数据

import pandas as pd  
import numpy as np
import matplotlib.pyplot as plt
cols = ['sentiment','id','date','query_string','user','text']
df = pd.read_csv("./trainingandtestdata/training.1600000.processed.noemoticon.csv",header=None, names=cols)
# above line will be different depending on where you saved your data, and your file name
df.head()

df.sentiment.value_counts()

数据集有 160 万个条目，没有空条目，重要的是对于“情绪”列，即使数据集描述提到了中性类，训练集也没有中性类。
50%的数据带有负标签，另外 50%带有正标签。我们可以看到在阶级划分上没有偏斜。

df.drop(['id','date','query_string','user'],axis=1,inplace=True)

我首先删除了不需要用于情感分析的列。

“id”列是每条推文的唯一 ID
“date”列是推文的日期信息
“QUERY _ string”列指示推文是否使用任何特定的查询关键字收集，但是对于该列，100%的条目都具有值“NO _ QUERY”
“user”列是发布推文的用户的 twitter 句柄名称

我决定放弃四列以上。

df[df.sentiment == 0].head(10)

df[df.sentiment == 4].head(10)

通过查看每个类的一些条目，似乎所有负类都是从 0 ~ 799999 索引，正类条目从 800000 开始到数据集的末尾。

数据准备

作为健全性检查的一种方式，让我们看看每个条目的文本列中字符串的长度。

df['pre_clean_len'] = [len(t) for t in df.text]

数据字典—初稿

下面是数据集的数据字典的第一稿，但在我准备的过程中，这将需要更新。

from pprint import pprint
data_dict = {
    'sentiment':{
        'type':df.sentiment.dtype,
        'description':'sentiment class - 0:negative, 1:positive'
    },
    'text':{
        'type':df.text.dtype,
        'description':'tweet text'
    },
    'pre_clean_len':{
        'type':df.pre_clean_len.dtype,
        'description':'Length of the tweet before cleaning'
    },
    'dataset_shape':df.shape
}pprint(data_dict)

我还将使用方框图绘制 pre_clean_len，这样我可以看到每个条目中字符串长度的总体分布。

fig, ax = plt.subplots(figsize=(5, 5))
plt.boxplot(df.pre_clean_len)
plt.show()

这看起来有点奇怪，因为 twitter 的字符限制是 140。但是从上面的方框图来看，一些推文的长度远远超过了 140 个字符。

df[df.pre_clean_len > 140].head(10)

看起来是时候打扫卫生了！

资料准备 1: HTML 解码

看起来 HTML 编码没有被转换成文本，并以' &amp '，' &quot '等形式出现在文本字段中。将 HTML 解码为一般文本将是我数据准备的第一步。我会用 BeautifulSoup 来做这个。

df.text[279]

from bs4 import BeautifulSoup
example1 = BeautifulSoup(df.text[279], 'lxml')
print example1.get_text()

数据准备 2: '@ '提及

准备的第二部分是处理@提及。
即使 another 携带了某种信息(该推文提到的另一个用户)，这些信息并没有为建立情感分析模型增加价值。

df.text[343]

import re
re.sub(r'@[A-Za-z0-9]+','',df.text[343])

数据准备 3: URL 链接

清理的第三部分是处理 URL 链接，与@ reference 相同，即使它携带一些信息，出于情感分析的目的，这可以被忽略。

df.text[0]

re.sub('https?://[A-Za-z0-9./]+','',df.text[0])

数据准备 4: UTF-8 BOM(字节顺序标记)

df.text[226]

通过查看上面的条目，我可以看到奇怪的字符模式“\xef\xbf\xbd”。经过一些研究，我发现这些是 UTF-8 炸弹。
“UTF-8 BOM 是一个字节序列(EF BB BF)，它允许读者识别以 UTF-8 编码的文件。”

通过用“utf-8-sig”解码文本，这个 BOM 将被替换为 unicode 无法识别的特殊字符，然后我可以将它处理为“？”

testing = df.text[226].decode("utf-8-sig")
testing

testing.replace(u"\ufffd", "?")

数据准备 5:标签/数字

有时与 hashtag 一起使用的文本可以提供关于 tweet 的有用信息。将所有文本和标签一起删除可能有点冒险。所以我决定保持文本不变，只去掉“#”。我将在清理包括数字在内的所有非字母字符的过程中这样做。

df.text[175]

re.sub("[^a-zA-Z]", " ", df.text[175])

定义数据清理功能

有了以上五个数据清洗任务，我将首先定义数据清洗函数，然后将应用于整个数据集。当使用计数矢量器或 Tfidf 矢量器创建矩阵时，将在稍后阶段处理标记化、词干化/词元化、停用词。

from nltk.tokenize import WordPunctTokenizer
tok = WordPunctTokenizer()
pat1 = r'@[A-Za-z0-9]+'
pat2 = r'https?://[A-Za-z0-9./]+'
combined_pat = r'|'.join((pat1, pat2))def tweet_cleaner(text):
    soup = BeautifulSoup(text, 'lxml')
    souped = soup.get_text()
    stripped = re.sub(combined_pat, '', souped)
    try:
        clean = stripped.decode("utf-8-sig").replace(u"\ufffd", "?")
    except:
        clean = stripped
    letters_only = re.sub("[^a-zA-Z]", " ", clean)
    lower_case = letters_only.lower()
    # During the letters_only process two lines above, it has created unnecessay white spaces,
    # I will tokenize and join together to remove unneccessary white spaces
    words = tok.tokenize(lower_case)
    return (" ".join(words)).strip()testing = df.text[:100]test_result = []
for t in testing:
    test_result.append(tweet_cleaner(t))
test_result

nums = [0,400000,800000,1200000,1600000]
print "Cleaning and parsing the tweets...\n"
clean_tweet_texts = []
for i in xrange(nums[0],nums[1]):
    if( (i+1)%10000 == 0 ):
        print "Tweets %d of %d has been processed" % ( i+1, nums[1] )                                                                    
    clean_tweet_texts.append(tweet_cleaner(df['text'][i]))

剩下的，你明白了，我把整个数据集分成四批，并清理它们。

将清理的数据保存为 csv

clean_df = pd.DataFrame(clean_tweet_texts,columns=['text'])
clean_df['target'] = df.sentiment
clean_df.head()

clean_df.to_csv('clean_tweet.csv',encoding='utf-8')
csv = 'clean_tweet.csv'
my_df = pd.read_csv(csv,index_col=0)
my_df.head()

由于帖子越来越长，我将在这里停下来，并尝试在下一个帖子继续。如果你有任何问题，或意见，或建议，请不要犹豫留下评论！谢谢你。

你可以在 Github repo 下面找到 Jupyter 的笔记本文件。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 1/blob/master/Capstone _ part 2 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 10 部分(使用 Doc2Vec/Word2Vec/GloVe 的神经网络)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-10-neural-network-with-a6441269aa3c?source=collection_archive---------3-----------------------

Photo by Brett Jordan on Unsplash

这是我正在进行的推特情感分析项目的第十部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法
第 6 部分:Doc2Vec
第七部分:短语建模+ Doc2Vec
第八部分:降维(Chi2，PCA)
第 9 部分:具有 Tfidf 向量的神经网络

在上一篇文章中，我用 Tf-idf 向量实现了神经网络建模，但发现对于高维稀疏数据，神经网络的性能并不好。在这篇文章中，我将看看从 Doc2Vec 模型或单词向量中输入文档向量与 Tf-idf 向量有什么不同。

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

具有 Doc2Vec 的神经网络

在我使用从 Doc2Vec 获得的向量进行神经网络建模之前，我想向您介绍一下我是如何获得这些文档向量的背景。在本系列的第六部分中，我已经使用 Gensim 库实现了 Doc2Vec。

有三种不同的方法用于训练 Doc2Vec。分布式单词包，分布式记忆(Mean)，分布式记忆(Concatenation)。这些模型通过 30 个时期的 150 万条推文进行训练，模型的输出是每条推文的 100 个维度向量。在我从每个模型中获得文档向量之后，我尝试将这些向量连接起来(因此连接起来的文档向量有 200 个维度): DBOW + DMM、DBOW + DMC，与使用任何单一纯方法的模型相比，我看到了性能的提高。 Le 和 Mikolov (2014) 在他们的研究论文中已经展示了使用不同的训练方法并将其连接起来以提高性能。

最后，作为 Doc2Vec 训练的前一步，我应用短语建模来检测二元短语和三元短语，并尝试了跨 n-grams 的不同组合。当使用逻辑回归模型进行测试时，我从“unigram DBOW + trigram DMM”文档向量中获得了最佳性能结果。

我将首先从加载 Gensim 的 Doc2Vec 开始，并定义一个提取文档向量的函数，然后加载我训练的 doc2vec 模型。

当馈送到简单的逻辑回归时，连接的文档向量(unigram DBOW + trigram DMM)产生 75.90%的训练集准确度和 75.76%的验证集准确度。

我将尝试不同数量的隐藏层、隐藏节点来比较性能。在下面的代码块中，您会看到我首先将种子定义为“7”，但没有设置随机种子，“np.random.seed()”将在每个模型的开始处定义。这是为了再现不同模型结构的各种结果。

*旁注(再现性):老实说，这花了我一段时间才弄明白。我首先尝试在导入 Keras 之前设置随机种子，并一个接一个地运行模型。然而，如果我在模型运行后定义相同的模型结构，我不能得到相同的结果。但我也意识到，如果我重启内核，并从头开始重新运行代码块，它会给我与上一个内核相同的结果。所以我想，在运行一个模型后，随机种子发生了变化，这就是为什么我不能用相同的结构得到相同的结果，如果我在相同的内核中连续运行它们。无论如何，这就是为什么我每次尝试不同的模型时都设置随机种子。供您参考，我运行 Keras 与 Theano 后端，只使用 CPU 而不是 GPU。如果你在同样的设置下，这应该可以。通过在命令行中启动 Jupyter Notebook，我显式地将 backend 指定为 Theano，如下所示:“KERAS _ back end = the ano Jupyter Notebook”

请注意，并不是下面单元格中加载的所有依赖项都用于这篇文章，而是为了以后使用而导入的。

定义不同的模型结构会是相当重复的代码，所以我只给你两个例子，这样你就可以理解如何用 Keras 定义模型结构。

在尝试了 12 种不同的模型和一系列的隐藏层(从 1 到 3)以及每个隐藏层的一系列隐藏节点(64，128，256，512)之后，下面是我得到的结果。最佳验证准确度(79.93%)来自于第 7 时段的“model_d2v_09”，其具有 3 个隐藏层，每个隐藏层具有 256 个隐藏节点。

现在我知道哪个模型给我的结果最好，我将运行“model_d2v_09”的最终模型，但这次是用 Keras 中的回调函数。在我收到上一篇帖子的评论之前，我对 Keras 中的回调函数还不太熟悉。得到评论后，我做了一些挖掘，找到了 Keras 回调中所有有用的函数。感谢 @rcshubha 的评论。下面是我的 Doc2Vec 最终模型，我用了“checkpoint”和“earlystop”。您可以使用选项设置“检查点”功能，通过以下参数设置，“检查点”将保存最佳执行模型，直到运行点，只有当新的纪元优于保存的模型时，它才会将其保存为新的模型。而“early_stop”我把它定义为监控验证精度，如果 5 个纪元没有超过目前最好的验证精度，它就停止。

如果我评估我刚刚运行的模型，它会给我与上一个时期相同的结果。

model_d2v_09_es.evaluate(x=validation_vecs_ugdbow_tgdmm, y=y_validation)

但是如果我在最佳时期加载保存的模型，那么这个模型将在那个时期给我结果。

from keras.models import load_model
loaded_model = load_model('d2v_09_best_weights.07-0.7993.hdf5')
loaded_model.evaluate(x=validation_vecs_ugdbow_tgdmm, y=y_validation)

如果你记得用逻辑回归模型用相同的向量表示推文的验证准确性(75.76%)，你可以看到将相同的信息输入神经网络会产生明显更好的结果。看到神经网络如何提振密集向量的性能令人惊叹，但最好的验证精度仍然低于 Tfidf 向量+ logistic 回归模型，该模型给了我 82.92%的验证精度。

如果你读过我在 Doc2Vec 上的帖子，或者熟悉 Doc2Vec，你可能知道还可以从训练好的 Doc2Vec 模型中提取每个单词的单词向量。我将继续使用 Word2Vec，并尝试不同的方法，看看是否有任何方法可以优于 Doc2Vec 的结果(79.93%)，最终优于 Tfidf + logistic 回归模型(82.92%)。

Word2Vec

为了利用从 Doc2Vec 模型中提取的单词向量，我不能再使用不同 n 元语法的连接向量，因为它们不会包含相同的词汇。因此，在下面，我加载了 unigram DMM 的模型，并为词汇表中的每个单词创建了具有 200 维 unigram DBOW 的连接向量。

在我尝试使用从单词向量计算的文档表示的神经网络之前，我首先要做的是，我将使用各种文档表示方法来拟合逻辑回归，并使用给我最佳验证准确性的方法，我将最终定义一个神经网络模型。

我还会以表格的形式给出所有符合逻辑回归的不同词向量的结果汇总。

从 Doc2Vec 模型中提取的词向量(平均值/总和)

可以有许多不同的方法来用单独的单词向量来提出文档表示向量。一个显而易见的选择是平均它们。对于 tweet 中的每个单词，查看经过训练的 Doc2Vec 是否具有该单词的单词向量表示，如果是，则对整个文档中的单词向量进行求和，同时计算有多少单词被检测为具有单词向量，最后通过将求和的向量除以计数，可以获得整个文档的平均单词向量，该向量与各个单词向量具有相同的维数(在本例中为 200)。

另一种方法是只对单词向量求和，而不对它们进行平均。如果一些 tweet 只有 Doc2Vec 词汇表中的几个单词，而一些 tweet 有 Doc2Vec 词汇表中的大部分单词，这可能会扭曲文档的向量表示。但我会尝试求和与平均，并比较结果。

使用 unigram DBOW + unigram DMM 的平均单词向量的验证准确率为 71.74%，这显著低于从 unigram DBOW + trigram DMM 提取的文档向量(75.76%)，并且从本系列的第 6 部分得到的结果中，我知道从 unigram DBOW + unigram DMM 提取的文档向量将给出 75.51%的验证准确率。

我还尝试使用 ScikitLearn 的 scale 函数缩放向量，并看到计算时间的显著改善和精确度的轻微提高。

让我们看看相加的词向量与平均的词向量相比表现如何。

与平均方法相比，求和方法在没有缩放的情况下给了我更高的精度。但是用向量相加的简单逻辑回归需要 3 个多小时来运行。所以我再次尝试缩放这些向量。

令人惊讶！通过缩放，逻辑回归拟合只需 3 分钟！那是相当不同的。使用定标字向量的验证准确度在平均情况下为 72.42%，在求和情况下为 72.51%。

使用 TFIDF 加权(平均值/总和)从 Doc2Vec 模型中提取的词向量

在本系列的第 5 部中，我已经解释了什么是 TF-IDF。TF-IDF 是一种通过计算相对词频率和逆文档频率的乘积来加权每个词的方法。因为它为词汇表中的每个单词给出一个标量值，所以这也可以用作每个单词向量的加权因子。Correa Jr .等人(2017 年)在他们的论文“NILC-南太平洋大学在 SemEval-2017 任务 Twitter 情感分析的多视角集成”中实施了这种 Tf-idf 加权

为了获得每个单词的 Tfidf 值，我首先用 tfidf 矢量器拟合和转换训练集，并创建一个包含“单词”、“tfi df 值”对的字典。此外，我定义了一个函数“get_w2v_general ”,用给定的 Word2Vec 模型获得平均单词向量或总单词向量。最后，我计算单词向量与相应 Tfidf 值的乘积。从下面的代码来看，Tfidf 乘法部分花费了相当多的时间。老实说，我仍然不确定为什么要花这么长时间来计算单词向量的 Tfidf 权重，但 5 个小时后它终于完成了计算。稍后你也可以看到，我尝试了另一种称重方法，但用时不到 10 秒。如果你对此有答案，任何见解将不胜感激。

然后，我可以调用“get_w2v_general”函数，就像我对上述不带加权因子的单词向量所做的一样，然后拟合一个逻辑回归模型。平均值的验证准确率为 70.57%，总和的验证准确率为 70.32%。结果不是我预想的那样，尤其是等了 5 个小时。通过用 Tfidf 值对字向量进行加权，平均和求和的验证精度都下降了约 2%。

使用自定义权重(平均值/总和)从 Doc2Vec 模型中提取的单词向量

在本系列的第三部分中，我定义了一个名为“pos_normcdf_hmean”的自定义指标，这是从 Jason Kessler 在 PyData 2017 Seattle 的演示文稿中借用的指标。如果你想知道更多关于计算的细节，你可以查看我之前的帖子或者你也可以观看杰森·凯斯勒的演讲。为了给你一个高层次的直觉，通过计算 CDF(累积分布函数)转换值的调和平均值，在整个文档中的词频率和在一个类中的词频，你可以得到一个有意义的度量，显示每个词如何与某个类相关。

我在本系列的第三部分中使用了这个度量来可视化令牌，并且在第五部分中再次使用它来创建用于分类目的的自定义词典。我将再次使用它作为单词向量的加权因子，看看它如何影响性能。

平均数的验证准确率为 73.27%，总和的验证准确率为 70.94%。与 Tfidf 加权不同，这次使用自定义加权，当使用平均方法时，它实际上给了我一些性能提升。但是对于求和，这种加权并不比没有加权的字向量表现得更好。

从预训练手套中提取的单词向量(平均值/总和)

GloVe 是由斯坦福 NLP 小组的 Pennington 等人(2014) 提出的另一种向量中的单词表示。

Word2Vec 和 Glove 的区别在于这两个模型如何计算单词向量。在 Word2Vec 中，你得到的单词向量是浅层神经网络的一种副产品，当它试图预测给定周围单词的中心单词或反之亦然。但是使用 GloVe，你得到的词向量是 GloVe 模型的对象矩阵，它使用术语共现矩阵和维度缩减来计算这个。

好消息是，由于最新更新(Gensim 3.2.0)，您现在可以轻松加载和使用 Gensim 的预训练手套向量。除了一些预先训练的单词向量，还添加了新的数据集，这也可以使用他们的下载器 API 轻松下载。如果你想了解更多这方面的信息，请查看稀有技术公司的这篇博文。

斯坦福大学 NLP 小组已经公开了他们预先训练的手套向量，其中，有专门用推文训练的手套向量。这听起来绝对值得一试。他们有四个不同版本的推文向量，每个向量都有不同的维度(25，50，100，200 ),对 20 亿条推文进行了训练。你可以在他们的网站上找到更多细节。

在这篇文章中，我将使用 200 维预训练手套向量。(如果您的 Gensim 版本低于 3.2.0，您可能需要更新 Gensim)

通过使用预先训练的手套向量，我可以看到验证准确性显著提高。到目前为止，最好的验证准确性来自具有自定义权重的平均单词向量，这给了我 73.27%的准确性，与此相比，手套向量分别产生 76.27%的平均值和 76.60%的总和。

从预先训练的谷歌新闻 Word2Vec 中提取的词向量(平均值/总和)

有了新更新的 Gensim，我还可以加载著名的预训练谷歌新闻词向量。这些词向量在谷歌新闻数据集(约 1000 亿词)上使用 Word2Vec 模型进行训练，并由谷歌发布。该模型包含 300 维向量，包含 300 万个单词和短语。你可以在谷歌项目档案中找到更多细节。

平均数的验证准确率为 74.96%，总和的验证准确率为 74.92%。尽管它给我的结果比从定制训练的 Doc2Vec 模型中提取的单词向量更好，但它未能胜过手套向量。而谷歌新闻词向量中的向量维度更大。

但是，这是用谷歌新闻训练的，而我使用的手套向量是专门用推特训练的，因此很难直接相互比较。如果 Word2Vec 是专门用推文训练的呢？

单独训练的 Word2Vec(平均值/总和)

我知道我已经尝试了我从 Doc2Vec 模型中提取的单词向量，但是如果我训练单独的 Word2Vec 模型会怎么样？即使 Doc2Vec 模型给出了很好的文档级表示向量，如果我训练纯 Word2Vec，学习单词向量会更有效吗？

为了回答自己的问题，我用 CBOW(连续词袋)和 Skip Gram 模型训练了两个 Word2Vec 模型。在参数设置方面，我设置了与 Doc2Vec 相同的参数。

向量的大小:100 维
负采样:5
窗口:2
最小字数:2
alpha: 0.065(每个时期将 alpha 减少 0.002)
纪元数量:30

根据上面的设置，我通过传递“sg=0”定义了 CBOW 模型，通过传递“sg=1”定义了 Skip Gram 模型。

一旦我从两个模型中得到结果，我就把每个单词的两个模型的向量连接起来，这样连接起来的向量就有了每个单词的 200 维表示。

请注意，在第 6 部分，我训练 Doc2Vec 的地方，我使用了从 Gensim 导入的“LabeledSentence”函数。这已经被否决了，因此在这篇文章中我使用了“TaggedDocument”函数。用法是一样的。

单字 CBOW 和单字 Skip Gram 模型的连接向量使用平均和方法分别产生了 76.50%和 76.75%的验证准确率。这些结果甚至比我从手套向量得到的结果还要高。

但请不要将此混淆为一般声明。这是在这种特殊环境下的经验发现。

单独训练的 Word2Vec，带自定义权重(平均值/总和)

最后一步，我将应用我在上面实现的自定义权重，看看这是否会影响性能。

最后，我得到了表现最好的词向量。使用自定义指标加权的平均单词向量(单独训练的 Word2Vec 模型)产生了 77.97%的最佳验证准确率！下面是我在上面尝试的所有结果的表格。

Word2Vec 神经网络

选择具有逻辑回归的最佳表现的单词向量来馈送给神经网络模型。这一次我没有尝试各种不同的架构。根据我在使用 Doc2Vec 文档向量的不同架构的试验中观察到的情况，性能最好的架构是具有 3 个隐藏层的架构，每个隐藏层有 256 个隐藏节点。
我将最终拟合一个具有早期停止和检查点的神经网络，这样我可以保存验证准确性方面的最佳性能权重。

from keras.models import load_model
loaded_w2v_model = load_model('w2v_01_best_weights.10-0.8048.hdf5')
loaded_w2v_model.evaluate(x=validation_w2v_final, y=y_validation)

最佳验证准确率为 80.48%。令人惊讶的是，这甚至比我在上面通过将文档向量输入到神经网络模型中所获得的最佳准确度还要高。

我花了相当长的时间来尝试不同的设置，不同的计算，但我通过所有的尝试和错误学到了一些宝贵的经验。经过专门训练的 Word2Vec，通过精心设计的权重，甚至可以在分类任务中胜过 Doc2Vec。

在下一篇文章中，我将尝试更复杂的神经网络模型，卷积神经网络。我再次希望这能给我的表现带来一些提升。

感谢您的阅读，您可以通过下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 10/blob/master/Capstone _ part 10 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 11 部分(CNN + Word2Vec)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-11-cnn-word2vec-41f5e28eda74?source=collection_archive---------0-----------------------

Photo by Mahdi Bafande on Unsplash

这是我的推特情感分析项目的第 11 部分，也是最后一部分。这是一个漫长的旅程，通过一路上的许多尝试和错误，我学到了无数宝贵的经验教训。我还没有决定我的下一个项目。但我一定会腾出时间开始一个新项目。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法
第 6 部分:Doc2Vec
第七部分:短语建模+ Doc2Vec
第八部分:降维(Chi2，PCA)
第 9 部分:具有 Tfidf 向量的神经网络
第 10 部分:使用 Doc2Vec/Word2Vec/GloVe 的神经网络

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

卷积神经网络的准备

在上一篇文章中，我汇总了一条推文中每个单词的单词向量，通过求和或计算平均值来获得每条推文的一个向量表示。然而，为了馈送给 CNN，我们不仅要将每个词向量馈送给模型，还要按照与原始 tweet 相匹配的顺序。

例如，假设我们有一个如下的句子。

“我喜欢猫”

假设我们有每个单词的二维向量表示，如下所示:

我:[0.3，0.5]爱:[1.2，0.8]猫:[0.4，1.3]

有了上面的句子，我们对于整个句子所拥有的向量的维数是 3×2(3:字数，2:向量维数)。

但是还有一件事我们需要考虑。神经网络模型将期望所有数据具有相同的维度，但是在不同句子的情况下，它们将具有不同的长度。这可以用填充来处理。

假设我们有下面的第二句话。

“我也喜欢狗”

用下面的向量表示每个单词:

我:[0.3，0.5]，爱:[1.2，0.8]，狗:[0.8，1.2]，太:[0.1，0.1]

第一句话有 3X2 维向量，但第二句话有 4X2 维向量。我们的神经网络不会接受这些作为输入。通过填充输入，我们决定一个句子中单词的最大长度，如果输入长度短于指定长度，则用零填充剩余的单词。在超过最大长度的情况下，它也会从开头或结尾截断。例如，假设我们决定我们的最大长度为 5。

然后，通过填充，第一个句子将在开头或结尾多 2 个全零的二维向量(您可以通过传递参数来决定)，第二个句子将在开头或结尾多 1 个全零的二维向量。现在我们每个句子有 2 个相同维度(5X2)的向量，我们最终可以将它输入到一个模型中。

让我们首先加载 Word2Vec 模型，从中提取单词向量。我已经保存了我在上一篇文章中训练的 Word2Vec 模型，可以很容易地用 Gensim 中的“KeyedVectors”函数加载。我有两个不同的 Word2Vec 模型，一个是 CBOW(连续词包)模型，另一个是 skip-gram 模型。我不会详细说明 CBOW 和 skip-gram 有什么不同，但是如果你想知道更多细节，你可以参考我之前的文章。

from gensim.models import KeyedVectors
model_ug_cbow = KeyedVectors.load('w2v_model_ug_cbow.word2vec')
model_ug_sg = KeyedVectors.load('w2v_model_ug_sg.word2vec')

通过运行下面的代码块，我正在构建一种字典，我可以从中提取单词向量。由于我有两个不同的 Word2Vec 模型，下面的“embedding_index”将有两个模型的连接向量。对于每个模型，我有 100 维的单词向量表示，通过连接，每个单词将有 200 维的向量表示。

embeddings_index = {}
for w in model_ug_cbow.wv.vocab.keys():
    embeddings_index[w] = np.append(model_ug_cbow.wv[w],model_ug_sg.wv[w])

现在我们已经准备好了词向量的参考，但是我们仍然没有准备好我在文章开始解释的格式的数据。Keras 的“Tokenizer”将拆分句子中的每个单词，然后我们可以调用“texts_to_sequences”方法来获得每个句子的顺序表示。我们还需要传递“num_words ”,它是您要使用的词汇的数量，这将在您调用“texts_to_sequences”方法时应用。这可能有点违背直觉。因为如果你检查所有单词索引的长度，它将不是你定义的单词数，而是实际的筛选过程发生在你调用' texts_to_sequences '方法的时候。

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequencestokenizer = Tokenizer(num_words=100000)
tokenizer.fit_on_texts(x_train)
sequences = tokenizer.texts_to_sequences(x_train)

以下是原始列车数据的前五个条目。

for x in x_train[:5]:
    print x

并且作为顺序数据准备的相同数据如下。

sequences[:5]

每个单词都表示为一个数字，我们可以看到每个句子中的单词数与“序列”中数字的长度相匹配。我们以后可以把每个数字代表的单词联系起来。但是我们仍然没有填充我们的数据，所以每个句子都有不同的长度。让我们来处理这个。

length = []
for x in x_train:
    length.append(len(x.split()))
max(length)

训练数据中一个句子的最大字数是 40。让我们决定最大长度比这个长一点，比如说 45。

x_train_seq = pad_sequences(sequences, maxlen=45)
x_train_seq[:5]

正如您从填充序列中看到的，所有数据现在都转换为具有相同的长度 45，默认情况下，如果句子长度小于最大长度，则在开头使用零填充。如果你想知道更多细节，请查阅 Keras 文档中关于序列预处理的内容。

sequences_val = tokenizer.texts_to_sequences(x_validation)
x_val_seq = pad_sequences(sequences_val, maxlen=45)

在我们将顺序文本数据输入模型之前，还有一件事要做。当我们把一个句子转换成一个序列时，每个单词都用一个整数来表示。实际上，这些数字是每个单词在分词器的单词索引中的存储位置。记住这一点，让我们构建这些单词向量的矩阵，但这次我们将使用单词索引号，以便我们的模型在输入整数序列时可以引用相应的向量。

下面，我在定义字数为 10 万。这意味着我将只关心训练集中最频繁出现的 100，000 个单词。如果我不限制字数，总词汇量也就 20 多万。

num_words = 100000
embedding_matrix = np.zeros((num_words, 200))
for word, i in tokenizer.word_index.items():
    if i >= num_words:
        continue
    embedding_vector = embeddings_index.get(word)
    if embedding_vector is not None:
        embedding_matrix[i] = embedding_vector

作为健全性检查，如果嵌入矩阵已经正确生成。在上面，当我看到训练集的前五个条目时，第一个条目是“恨你”，这个的顺序表示是[137，6]。让我们看看第 6 个嵌入矩阵是否与单词“you”的向量相同。

np.array_equal(embedding_matrix[6] ,embeddings_index.get('you'))

现在我们完成了数据准备。在我们进入 CNN 之前，我想再测试一件事(抱歉耽搁了)。当我们提供这种数据的顺序向量表示时，我们将在 Keras 中使用嵌入层。使用嵌入层，我可以通过预定义的嵌入，我在上面准备了‘Embedding _ matrix ’,或者嵌入层本身可以在整个模型训练时学习单词嵌入。另一种可能性是，我们仍然可以提供预定义的嵌入，但使其可训练，以便它将在模型训练时更新向量的值。

为了检查哪种方法执行得更好，我定义了一个简单的具有一个隐藏层的浅层神经网络。对于这个模型结构，我不会试图通过调整参数来优化模型，因为这篇文章的主要目的是实现 CNN。

from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.layers import Flatten
from keras.layers.embeddings import Embedding

结果，最好的验证准确度来自第三种方法(微调预训练的 Word2Vec ),为 82.22%。训练准确率最好的是第二种方法(从零开始学习单词嵌入)，为 90.52%。使用预先训练的 Word2Vec 而不更新其向量值在训练和验证中显示出最低的准确性。然而，有趣的是，在训练集准确性方面，微调预训练的词向量不能胜过通过嵌入层从头学习的词嵌入。在我尝试以上三种方法之前，我的第一个猜测是，如果我微调预先训练的词向量，它会给我最好的训练精度。

将预训练的单词向量馈送给嵌入层以进行更新，就像向嵌入层提供第一初始化准则，以便它可以更有效地学习特定于任务的单词向量。但结果有些违反直觉，在这种情况下，事实证明，最好强制嵌入层从头开始学习。

但是过早的概括可能是危险的。为此，我将在 CNN 的背景下再次比较三种方法。

卷积神经网络

您可能已经看到了卷积神经网络(CNN)如何处理图像数据。有很多好的资源可以让你学习 CNN 的基础知识。就我而言，Adit Deshpande 的博客文章“理解卷积神经网络的初学者指南”确实对我理解这个概念有很大帮助。如果你不熟悉 CNN，我强烈推荐他的文章，这样你会对 CNN 有一个坚定的认识。

现在我假设你对 CNN 的图像数据有所了解。那么，这如何应用于文本数据呢？假设我们有一个如下的句子:

“我喜欢猫和狗”

有了词向量(假设我们每个词有 200 维的词向量)，上面的句子可以用 5X200 的矩阵来表示，每个词一行。你还记得我们在上面的句子中添加了零来填充，在那里我们准备了数据以提供给嵌入层吗？如果我们决定的字长是 45，那么上面的句子将有 45X200 的矩阵，但是前 40 行全是零。记住这一点，让我们看看 CNN 是如何处理图像数据的。

Image courtesy of machinelearninguru.com

在上面的 GIF 中，我们有一个 3X3 维的过滤器(核矩阵),对数据(图像矩阵)进行卷积，计算元素相乘结果的总和，并将结果记录在特征图上(输出矩阵)。如果我们想象每一行数据都是一个句子中的一个单词，那么它将不会有效地学习，因为过滤器一次只查看单词向量的一部分。上述 CNN 是所谓的 2D 卷积神经网络，因为滤波器在 2 维空间中移动。

我们对用词向量表示的文本数据所做的是利用 1D 卷积神经网络。如果过滤器的列宽与数据列宽相同，那么它没有空间横向跨越，只能纵向跨越。比如我们的句子用 45X200 矩阵表示，那么一个过滤器列宽也会有 200 列，行的长度(高度)就类似于 n-gram 的概念。如果过滤器高度为 2，过滤器将遍历文档，使用所有二元模型计算上述计算，如果过滤器高度为 3，它将遍历文档中的所有三元模型，依此类推。

如果应用步长为 1 到 45X200 矩阵的 2X200 滤波器，我们将得到 44X1 维的输出。在 1D 卷积的情况下，输出宽度在这种情况下将仅为 1(滤波器数量=1)。使用下面的公式可以很容易地计算出输出高度(假设您的数据已经被填充)。

在哪里

h:输入数据高度

Fh:过滤器高度

学生:步幅大小

现在让我们尝试添加更多的过滤器到我们的 1D 卷积层。如果我们将 100 个步长为 1 的 2X200 滤镜应用于 45X200 矩阵，你能猜出输出维度吗？

正如我在上面已经提到的，现在输出宽度将反映我们应用的过滤器的数量，所以答案是我们将有 44X100 维输出。定义结构后，还可以通过查看模型摘要来检查每个输出层的尺寸。

from keras.layers import Conv1D, GlobalMaxPooling1D
structure_test = Sequential()
e = Embedding(100000, 200, input_length=45)
structure_test.add(e)
structure_test.add(Conv1D(filters=100, kernel_size=2, padding='valid', activation='relu', strides=1))
structure_test.summary()

现在，如果我们添加全局最大池层，那么池层将从每个过滤器中提取最大值，输出维度将是一个一维向量，长度与我们应用的过滤器数量相同。这可以直接传递到一个致密层上，无需展平。

structure_test = Sequential()
e = Embedding(100000, 200, input_length=45)
structure_test.add(e)
structure_test.add(Conv1D(filters=100, kernel_size=2, padding='valid', activation='relu', strides=1))
structure_test.add(GlobalMaxPooling1D())
structure_test.summary()

现在，让我们定义一个简单的 CNN 在一条 tweet 上遍历二元模型。来自全局最大池层的输出将被馈送到完全连接的层，最后是输出层。我将再次尝试三种不同的输入，从 Word2Vec 提取的静态单词向量，使用嵌入层从头开始学习单词嵌入，通过训练更新 Word2Vec 单词向量。

最佳验证准确度来自通过训练更新的词向量，在第 3 时段，验证准确度为 83.25%。通过观察训练损失和准确度，似乎从零开始学习的单词嵌入倾向于过度适应训练数据，并且通过馈送预训练的单词向量作为权重初始化，它稍微更一般化并且最终具有更高的验证准确度。

但是终于！我有一个比 Tf-Idf + logistic 回归模型更好的结果！我已经用 Doc2Vec、Word2Vec 尝试了各种不同的方法，希望胜过使用 Tf-Idf 输入的简单逻辑回归模型。具体可以看看之前的帖子。Tf-Idf + logistic 回归模型的验证准确率为 82.91%。现在我终于开始看到 Word2Vec +神经网络优于这个简单模型的可能性。

让我们看看是否可以通过定义一个更精细的模型结构来做得更好。我将在下面实现的 CNN 架构的灵感来自于 Zhang，y .，& Wallace，b .(2015)“用于句子分类的卷积神经网络的灵敏度分析(和从业者指南”。

Image courtesy of Zhang, Y., & Wallace, B. (2015) “A Sensitivity Analysis of (and Practitioners’ Guide to) Convolutional Neural Networks for Sentence Classification”

基本上，上面的结构实现了我们上面用二元模型过滤器所做的事情，但不仅仅是二元模型，还有三元模型和四元模型。然而，这不是线性堆叠的层，而是平行的层。在卷积层和最大池层之后，它简单地连接来自 bigram、trigram 和 fourgram 的最大池结果，然后在它们之上构建一个输出层。

我下面定义的模型基本上和上面的图片一样，但是不同的是，我在输出层之前添加了一个完全连接的隐藏层，并且我的输出层将只有一个 Sigmoid 激活的输出节点，而不是两个。

还有 Y. Kim(2014)的另一篇著名论文《用于句子分类的卷积神经网络》。https://arxiv.org/pdf/1408.5882.pdf

在这篇论文中，他利用“通道”概念实现了更复杂的方法。该模型不仅经历不同的 n 元语法，他的模型具有多通道(例如，一个通道用于静态输入单词向量，另一个通道用于单词向量输入，但是将它们设置为在训练期间更新)。但在这篇文章中，我不会通过多渠道的方法。

到目前为止，我只使用了 Keras 的顺序模型 API，这与我上面定义的所有以前的模型都很好，因为模型的结构只是线性堆叠的。但是正如你从上面的图片中看到的，我将要定义的模型有平行的层，这些层接受相同的输入，但是做它们自己的计算，然后结果将被合并。在这种神经网络结构中，我们可以使用 Keras functional API 。

Keras functional API 可以处理多输入多输出、共享层、共享输入等。用顺序 API 定义这些类型的模型不是不可以，但是当你想保存训练好的模型时，函数式 API 可以让你简单的保存模型并加载，但是用顺序 API 就很难了。

from keras.callbacks import ModelCheckpointfilepath="CNN_best_weights.{epoch:02d}-{val_acc:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')model.fit(x_train_seq, y_train, batch_size=32, epochs=5,
                     validation_data=(x_val_seq, y_validation), callbacks = [checkpoint])

from keras.models import load_model
loaded_CNN_model = load_model('CNN_best_weights.02-0.8333.hdf5')
loaded_CNN_model.evaluate(x=x_val_seq, y=y_validation)

最佳验证准确率为 83.33%，略好于使用二元模型过滤器的简单 CNN 模型，后者产生 83.25%的验证准确率。我甚至可以定义一个具有更多隐藏层的更深结构，或者甚至利用 Yoon Kim(2014)实施的多通道方法，或者尝试不同的池大小以查看性能差异，但我现在就说到这里。然而，如果你碰巧尝试了更复杂的 CNN 结构，并得到了结果，我很乐意听到它。

使用测试集的最终模型评估

到目前为止，我已经在验证集上测试了模型，以决定特征提取调整和模型比较。现在我将最终用测试集检查最终结果。我将比较两种不同的模型:1 .Tf-Idf + logistic 回归，2。Word2Vec + CNN。作为比较的另一个衡量标准，我还将绘制两个模型的 ROC 曲线。

from sklearn.feature_extraction.text import TfidfVectorizer
tvec = TfidfVectorizer(max_features=100000,ngram_range=(1, 3))
tvec.fit(x_train)
x_train_tfidf = tvec.transform(x_train)
x_test_tfidf = tvec.transform(x_test)
lr_with_tfidf = LogisticRegression()
lr_with_tfidf.fit(x_train_tfidf,y_train)
yhat_lr = lr_with_tfidf.predict_proba(x_test_tfidf)
lr_with_tfidf.score(x_test_tfidf,y_test)

sequences_test = tokenizer.texts_to_sequences(x_test)
x_test_seq = pad_sequences(sequences_test, maxlen=45)
yhat_cnn = loaded_CNN_model.predict(x_test_seq)
loaded_CNN_model.evaluate(x=x_test_seq, y=y_test)

最后的结果如下。

感谢您的阅读。你可以从下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 11/blob/master/Capstone _ part 11 . ipynb

另一个使用 Python 的 Twitter 情感分析——第 2 部分

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-2-333514854913?source=collection_archive---------1-----------------------

这篇博文是我目前在伦敦大会上为我的顶点项目所做的 Twitter 情绪分析项目的第二部分。你可以在这里找到第一部。

重新清理数据

在我继续学习 EDA 和数据可视化之前，我对数据清理部分做了一些修改，因为我在上一篇文章中定义的数据清理函数存在错误。

我意识到的第一个问题是，在清理过程中，否定词被分成两部分，当我过滤长度超过一个音节的标记时，撇号后面的“t”消失了。这使得像“不可以”这样的词最终和“可以”一样。对于情感分析来说，这似乎不是一件小事。

我意识到的第二个问题是，有些 url 链接不是以“http”开头的，有时人们会以“www.websitename.com”的形式粘贴链接。当我将 url 地址正则表达式模式定义为“https？😕/[A-Za-z0–9。/]+'.这种正则表达式模式的另一个问题是它只检测字母、数字、句点和斜杠。这意味着如果它包含任何其他特殊字符，如“=”、“_”、“~”等，它将无法捕获 url 的一部分。

第三个问题是 twitter ID 的 regex 模式。在之前的清理函数中，我将其定义为' @[A-Za-z0–9]+'，但是稍微用谷歌了一下，我发现 twitter ID 也允许下划线符号作为可以与 ID 一起使用的字符。除下划线符号外，只允许字母和数字字符。

下面是更新的数据清理功能。清洗的顺序是

增加马力
物料清单删除
url 地址(' http:'模式)，twitter ID 删除
url 地址(' www。图案)移除
小写字母的
否定处理
删除数字和特殊字符
符号化和连接

**import** **pandas** **as** **pd**  
**import** **numpy** **as** **np**
**import** **matplotlib.pyplot** **as** **plt**
plt.style.use('fivethirtyeight')

%matplotlib inline
%config InlineBackend.figure_format = 'retina'**import** **re**
**from** **bs4** **import** BeautifulSoup
**from** **nltk.tokenize** **import** WordPunctTokenizer
tok = WordPunctTokenizer()

pat1 = r'@[A-Za-z0-9_]+'
pat2 = r'https?://[^ ]+'
combined_pat = r'|'.join((pat1, pat2))
www_pat = r'www.[^ ]+'
negations_dic = {"isn't":"is not", "aren't":"are not", "wasn't":"was not", "weren't":"were not",
                "haven't":"have not","hasn't":"has not","hadn't":"had not","won't":"will not",
                "wouldn't":"would not", "don't":"do not", "doesn't":"does not","didn't":"did not",
                "can't":"can not","couldn't":"could not","shouldn't":"should not","mightn't":"might not",
                "mustn't":"must not"}
neg_pattern = re.compile(r'\b(' + '|'.join(negations_dic.keys()) + r')\b')

**def** tweet_cleaner_updated(text):
    soup = BeautifulSoup(text, 'lxml')
    souped = soup.get_text()
    **try**:
        bom_removed = souped.decode("utf-8-sig").replace(u"**\ufffd**", "?")
    **except**:
        bom_removed = souped
    stripped = re.sub(combined_pat, '', bom_removed)
    stripped = re.sub(www_pat, '', stripped)
    lower_case = stripped.lower()
    neg_handled = neg_pattern.sub(**lambda** x: negations_dic[x.group()], lower_case)
    letters_only = re.sub("[^a-zA-Z]", " ", neg_handled)
    *# During the letters_only process two lines above, it has created unnecessay white spaces,*
    *# I will tokenize and join together to remove unneccessary white spaces*
    words = [x **for** x  **in** tok.tokenize(letters_only) **if** len(x) > 1]
    **return** (" ".join(words)).strip()

更新清理函数后，我重新清理了数据集中的全部 160 万个条目。你可以从我的上一篇中找到清洁过程的细节。

清理之后，我将清理后的数据导出为 csv 格式，然后加载为数据框，如下图所示。

csv = 'clean_tweet.csv'
my_df = pd.read_csv(csv,index_col=0)
my_df.head()

my_df.info()

数据中似乎有一些空条目，让我们进一步调查。

my_df[my_df.isnull().any(axis=1)].head()

np.sum(my_df.isnull().any(axis=1))

my_df.isnull().any(axis=0)

似乎有 3981 个条目的文本列为空。这很奇怪，因为原始数据集没有空条目，因此如果清理后的数据集中有任何空条目，那一定是在清理过程中发生的。

df = pd.read_csv("./trainingandtestdata/training.1600000.processed.noemoticon.csv",header=None)
df.iloc[my_df[my_df.isnull().any(axis=1)].index,:].head()

通过查看原始数据中的这些条目，似乎只有文本信息，要么是 twitter ID，要么是 url 地址。无论如何，这些是我决定为情感分析丢弃的信息，所以我将丢弃这些空行，并更新数据框。

my_df.dropna(inplace=True)
my_df.reset_index(drop=True,inplace=True)
my_df.info()

词云

我选择的第一个文本视觉化是有争议的单词 cloud。词云通过根据单个词的频率成比例地调整其大小，然后以随机排列的方式呈现它们，来表示词在文档中的用法。围绕 word cloud 有很多争论，我有点同意那些反对使用 word cloud 作为数据分析的人的观点。对 word cloud 的一些担忧是，它仅支持最粗略的文本分析，并且它通常应用于文本分析不合适的情况，并且它让查看者自己找出数据的上下文，而不提供叙述。

但是在推文的情况下，文本分析是最重要的分析，它以一种快速和肮脏的方式提供了关于什么样的词在语料库中频繁出现的一般想法。所以，我将试一试，并找出还有哪些方法可以用于文本可视化。

对于 wordcloud，我使用了 python 库 word cloud。

neg_tweets = my_df[my_df.target == 0]
neg_string = []
**for** t **in** neg_tweets.text:
    neg_string.append(t)
neg_string = pd.Series(neg_string).str.cat(sep=' ')**from** **wordcloud** **import** WordCloud

wordcloud = WordCloud(width=1600, height=800,max_font_size=200).generate(neg_string)
plt.figure(figsize=(12,10))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

有些大词可以被解释成中性词，如“今天”、“现在”等。我可以看到一些较小的单词在负面推文中是有意义的，比如“该死”、“啊”、“小姐”、“坏”等等。但是有“爱”在相当大的尺寸，所以我想看看发生了什么。

**for** t **in** neg_tweets.text[:200]:
    **if** 'love' **in** t:
        **print** t

好吧，即使推文包含“爱”这个词，在这些情况下，它是负面情绪，因为推文混合了像“爱”但“想念”这样的情绪。或者有时以讽刺的方式使用。

pos_tweets = my_df[my_df.target == 1]
pos_string = []
**for** t **in** pos_tweets.text:
    pos_string.append(t)
pos_string = pd.Series(pos_string).str.cat(sep=' ')wordcloud = WordCloud(width=1600, height=800,max_font_size=200,colormap='magma').generate(pos_string) plt.figure(figsize=(12,10)) plt.imshow(wordcloud, interpolation="bilinear") plt.axis("off") plt.show()

我又一次看到一些自然的大字体单词，“今天”、“现在”，但是像“哈哈”、“爱”、“棒极了”这样的单词也很突出。

有趣的是，“工作”这个词在负面词云中相当大，但在正面词云中也相当大。这可能意味着许多人表达了对工作的负面情绪，但也有许多人对工作持积极态度。

为更多数据可视化做准备

为了让我在下一步实现一些数据可视化，我需要词频数据。推文中使用了什么样的词，以及在整个语料库中使用了多少次。我使用计数矢量器来计算术语频率，尽管计数矢量器也用于拟合、训练和预测，但在这个阶段，我将只提取术语频率进行可视化。

计数矢量器有一些可用的参数选项，例如移除停用词、限制最大项数。然而，为了首先获得数据集的全貌，我实现了包含停用词，并且不限制最大术语数。

**from** **sklearn.feature_extraction.text** **import** CountVectorizer
cvec = CountVectorizer()
cvec.fit(my_df.text)

len(cvec.get_feature_names())

好了，看起来计数矢量器已经从语料库中提取了 264，936 个单词。

！重要更新(10/01/2018) :我刚刚意识到，我不必经历我下面做的所有批处理。

是啊！我下面做的所有批处理和计算都可以用少得多的代码行来完成(虽然不完全是一行)。一旦使用拟合的计数矢量器转换数据，就可以直接从稀疏矩阵中获得术语频率。而这一切都可以在不到一秒的时间内完成！如果你看了下面，你会发现我花了将近 40 分钟才得到术语频率表。我想我用最艰难的方式学到了这一课。直接从稀疏矩阵中获得频率项的代码如下。

neg_doc_matrix = cvec.transform(my_df[my_df.target == 0].text)
pos_doc_matrix = cvec.transform(my_df[my_df.target == 1].text)
neg_tf = np.sum(neg_doc_matrix,axis=0)
pos_tf = np.sum(pos_doc_matrix,axis=0)
neg = np.squeeze(np.asarray(neg_tf))
pos = np.squeeze(np.asarray(pos_tf))
term_freq_df = pd.DataFrame([neg,pos],columns=cvec.get_feature_names()).transpose()

我将在下面留下我最初写的，作为对我自己愚蠢的提醒。这个故事的寓意是，如果你可以直接用稀疏矩阵工作，你绝对应该不用转换成密集矩阵！

对于下面的部分，我不得不经历许多试验和错误，因为内存使用超载。如果代码需要时间来实现，但仍然在运行，这是可以的，但这不是块运行多长时间的问题，我的 mac book pro 只是简单地放弃了，要么杀死内核，要么冻结。经过无数次尝试，我终于成功地批量处理了数据。

我一直犯的错误是，当我分割文档矩阵时，我试图在' document _ matrix . to array()[start _ index，end_index]'中分割它，我最终意识到，因为我试图首先将整个 documnet_matrix 转换为数组，然后从那里分割，无论我如何更改批处理大小，我可怜的 macbook pro 都无法处理请求。在我将切片更改为' document_matrix[start_index，end_index]之后。toarray()'，我的 mac book pro 为我做了一件非常棒的工作。

此外，在处理以下任务的过程中，您的 mac book 可以在寒冷的冬天成为一个出色的取暖设备。在亚洲，我们称之为“一石二鸟”。不客气

Cats are the best at finding warm spots in winter!

document_matrix = cvec.transform(my_df.text)
my_df[my_df.target == 0].tail()

%%time
neg_batches = np.linspace(0,798179,100).astype(int)
i=0
neg_tf = []
**while** i < len(neg_batches)-1:
    batch_result = np.sum(document_matrix[neg_batches[i]:neg_batches[i+1]].toarray(),axis=0)
    neg_tf.append(batch_result)
    **if** (i % 10 == 0) | (i == len(neg_batches)-2):
        **print** neg_batches[i+1],"entries' term freuquency calculated"
    i += 1

my_df.tail()

%%time
pos_batches = np.linspace(798179,1596019,100).astype(int)
i=0
pos_tf = []
**while** i < len(pos_batches)-1:
    batch_result = np.sum(document_matrix[pos_batches[i]:pos_batches[i+1]].toarray(),axis=0)
    pos_tf.append(batch_result)
    **if** (i % 10 == 0) | (i == len(pos_batches)-2):
        **print** pos_batches[i+1],"entries' term freuquency calculated"
    i += 1

neg = np.sum(neg_tf,axis=0)
pos = np.sum(pos_tf,axis=0)
term_freq_df = pd.DataFrame([neg,pos],columns=cvec.get_feature_names()).transpose()
term_freq_df.head()

term_freq_df.columns = ['negative', 'positive']
term_freq_df['total'] = term_freq_df['negative'] + term_freq_df['positive']
term_freq_df.sort_values(by='total', ascending=False).iloc[:10]

好了，术语频率数据框已经创建好了！正如你所看到的，最常见的单词都是停用词，如“to”、“the”等。你可能想知道为什么要经历所有繁重的处理，而不删除停用词，也不限制最大词数，以获得停用词占主导地位的词频率？因为我真的很想用上面得到的结果来检验齐夫定律。我需要停止字！你会明白我的意思。

我会在下一篇文章中告诉你更多关于齐夫定律的内容，我保证会有更多的可视化。你会发现上面的频率计算并不是毫无意义的。

和往常一样，你可以从下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 2/blob/master/Capstone _ part 3-copy 1 . ipynb

另一个使用 Python 的 Twitter 情感分析——第 3 部分(Zipf 定律，数据可视化)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-3-zipfs-law-data-visualisation-fc9eadda71e7?source=collection_archive---------2-----------------------

Photo by Samuel Ramos on Unsplash

这是 Twitter 情绪分析项目的第三部分，我目前正在为伦敦大会的数据科学沉浸式课程做准备。你可以在下面找到之前文章的链接。

[## 另一个使用 Python 的 Twitter 情感分析—第 1 部分

距离我上次发帖已经有一段时间了。我不在灵媒期间，我的生活发生了很多事情。我终于收集了我的…

towardsdatascience.com](/another-twitter-sentiment-analysis-bb5b01ebad90) [## 另一个使用 Python 的 Twitter 情感分析——第 2 部分

这篇博文是我目前正在为我的顶点计划做的 Twitter 情绪分析项目的第二部分…

medium.com](https://medium.com/@rickykim78/another-twitter-sentiment-analysis-with-python-part-2-333514854913)

在第二篇博文的末尾，我创建了一个词频数据框架，看起来像这样。

这些索引是来自 tweets 数据集的令牌("sentitement 140")，而“负”和“正”列中的数字表示该令牌在负推和正推中出现的次数。

齐夫定律

齐夫定律首先由法国速记员让·巴普蒂斯特·埃斯图普提出，后来以美国语言学家乔治·金斯利·齐夫的名字命名。齐夫定律指出，一小部分单词一直在使用，而绝大多数很少使用。这没什么好奇怪的，我们知道我们非常频繁地使用一些词，如“the”、“of”等，而我们很少使用像“aardvark”这样的词(aardvark 是一种原产于非洲的动物物种)。然而，有趣的是，“给定一些自然语言话语的语料库，任何单词的频率都与其在频率表中的排名成反比。因此，最频繁出现的单词的出现频率大约是第二频繁出现的单词的两倍，第三频繁出现的单词的三倍，等等

如果你想更多地了解齐夫定律，我推荐下面的 Youtube 视频。

Zipf 定律可以写成如下形式:第 r 个最频繁出现的单词的频率 f(r)与下式成比例

为

让我们看看 tweet 标记和它们的频率在图上是什么样子的。

y_pos = np.arange(500)
plt.figure(figsize=(10,8))
s = 1
expected_zipf = [term_freq_df.sort_values(by='total', ascending=False)['total'][0]/(i+1)**s for i in y_pos]
plt.bar(y_pos, term_freq_df.sort_values(by='total', ascending=False)['total'][:500], align='center', alpha=0.5)
plt.plot(y_pos, expected_zipf, color='r', linestyle='--',linewidth=2,alpha=0.5)
plt.ylabel('Frequency')
plt.title('Top 500 tokens in tweets')

在 X 轴上是频率的等级，从左到右从最高等级到第 500 等级。y 轴是在语料库中观察到的频率(在本例中为“Sentiment140”数据集)。需要注意的一点是，大多数情况下的实际观测值并不严格遵循 Zipf 分布，而是遵循一种“近似 Zipfian”分布的趋势。

尽管我们可以看到该图遵循 Zipf 定律的趋势，但在排名较高的单词中，它看起来有更多的区域在预期的 Zipf 曲线之上。

另一种绘制方式是在对数-对数图上，X 轴是对数(等级)，Y 轴是对数(频率)。通过在双对数标度上绘图，结果将在图上产生大致线性的线。

from pylab import *
counts = term_freq_df.total
tokens = term_freq_df.index
ranks = arange(1, len(counts)+1)
indices = argsort(-counts)
frequencies = counts[indices]
plt.figure(figsize=(8,6))
plt.ylim(1,10**6)
plt.xlim(1,10**6)
loglog(ranks, frequencies, marker=".")
plt.plot([1,frequencies[0]],[frequencies[0],1],color='r')
title("Zipf plot for tweets tokens")
xlabel("Frequency rank of token")
ylabel("Absolute frequency of token")
grid(True)
for n in list(logspace(-0.5, log10(len(counts)-2), 25).astype(int)):
    dummy = text(ranks[n], frequencies[n], " " + tokens[indices[n]], 
                 verticalalignment="bottom",
                 horizontalalignment="left")

我们再次看到一条大致线性的曲线，但是在较高等级的单词上偏离了预期的线，并且在较低等级，我们看到实际的观察线位于预期的线性线之下。

至少，我们证明了即使是 tweet 令牌也遵循“近似 Zipfian”分布，但这让我对 Zipf 定律的偏离产生了好奇。即使法律本身规定实际观察遵循“近齐夫曼”而不是严格受法律约束，但我们在更高等级中观察到的预期线以上的区域只是偶然吗？还是说 tweets 比其他文本语料库更多地使用了频繁词？与其他文本语料库相比，有统计学上的显著差异吗？

尽管所有这些听起来像是非常有趣的研究课题，但它超出了这个项目的范围，我将不得不转向数据可视化的下一步。

Tweet 令牌可视化

在了解了标记在整个语料库中的分布之后，我脑海中的下一个问题是两个不同类别(积极和消极)中的标记有何不同。这一次，停用词不会有太大帮助，因为相同的高频词(如“the”、“to”)在两个类中会同样频繁地出现。如果这两个类都被停用词支配，我就不能得到有意义的结果。因此，我决定删除停用词，并用 countvectorizer 将 max_features 限制为 10，000。

我不会重复计数矢量化的步骤，因为在我之前的博客文章中已经以类似的方式完成了。但是它将会在我的 Jupyter 笔记本上，我会在这篇文章的最后分享。总之，在计数矢量化之后，我们现在有了 10，000 个没有停用词的标记的标记频率数据，如下所示。

让我们来看看条形图上负面推文的前 50 个词是什么。

y_pos = np.arange(50)
plt.figure(figsize=(12,10))
plt.bar(y_pos, term_freq_df2.sort_values(by='negative', ascending=False)['negative'][:50], align='center', alpha=0.5)
plt.xticks(y_pos, term_freq_df2.sort_values(by='negative', ascending=False)['negative'][:50].index,rotation='vertical')
plt.ylabel('Frequency')
plt.xlabel('Top 50 negative tokens')
plt.title('Top 50 tokens in negative tweets')

即使前 50 名的一些标记可以提供一些关于负面推文的信息，一些中性词，如“只是”，“天”，是最常见的标记之一。尽管这些是真正的高频词，但很难说这些词都是负面推特中的重要词，这些负面推特描述了负面阶层的特征。

让我们也来看看条形图上的前 50 个积极标志。

y_pos = np.arange(50)
plt.figure(figsize=(12,10))
plt.bar(y_pos, term_freq_df2.sort_values(by='positive', ascending=False)['positive'][:50], align='center', alpha=0.5)
plt.xticks(y_pos, term_freq_df2.sort_values(by='positive', ascending=False)['positive'][:50].index,rotation='vertical')
plt.ylabel('Frequency')
plt.xlabel('Top 50 positive tokens')
plt.title('Top 50 tokens in positive tweets')

同样，中性词如“只是”，“天”，在排名中相当靠前。

如果我们把一个单词的负频率标在 X 轴上，正频率标在 Y 轴上，会怎么样呢？

import seaborn as sns
plt.figure(figsize=(8,6))
ax = sns.regplot(x="negative", y="positive",fit_reg=False, scatter_kws={'alpha':0.5},data=term_freq_df2)
plt.ylabel('Positive Frequency')
plt.xlabel('Negative Frequency')
plt.title('Negative Frequency vs Positive Frequency')

大部分词在 X 轴和 Y 轴上都在 10000 以下，看不出正负频率有什么有意义的关系。

为了提出一个有意义的度量标准，可以表征每个类别中的重要标志，我借用了 Jason Kessler 在 PyData 2017 Seattle 中提出的度量标准。在演讲中，他展示了一个名为 Scattertext 的 Python 库。尽管我没有使用这个库，但作为一种可视化文本数据的方式，在从频率数据中过滤有意义的符号时，在散点图中使用的度量是非常有用的。

让我们探索一下我们能从每个令牌的频率中得到什么。直观地说，如果一个单词在一个类中比另一个类中出现得更频繁，这可以很好地衡量该单词对描述该类有多大意义。在下面的代码中，我将其命名为“pos_rate ”,正如您从代码的计算中可以看到的，这被定义为

term_freq_df2['pos_rate'] = term_freq_df2['positive'] * 1./term_freq_df2['total']
term_freq_df2.sort_values(by='pos_rate', ascending=False).iloc[:10]

pos_rate 最高的词在负面推文中的频率为零，但这些词的整体频率太低，不能将其作为正面推文的指导原则。

另一个指标是一个单词在课堂上出现的频率。这被定义为

term_freq_df2['pos_freq_pct'] = term_freq_df2['positive'] * 1./term_freq_df2['positive'].sum()
term_freq_df2.sort_values(by='pos_freq_pct', ascending=False).iloc[:10]

但由于 pos_freq_pct 只是频率总和的比例，因此 pos_freq_pct 的等级与正频率完全相同。

我们现在可以做的是将 pos_rate、pos_freq_pct 组合在一起，得出一个既反映 pos_rate 又反映 pos_freq_pct 的指标。尽管这两个值的取值范围都是从 0 到 1，但 pos_rate 的取值范围实际上要宽得多，从 0 到 1，而所有 pos_freq_pct 值都被压缩在小于 0.015 的范围内。如果我们对这两个数字进行平均，pos_rate 将过于占优势，并且不会有效地反映这两个指标。

所以这里我们用调和平均值代替算术平均值。由于数字列表的调和平均值强烈倾向于列表中最少的元素，因此(与算术平均值相比)它倾向于减轻较大异常值的影响，并加重较小异常值的影响正实数 x1，x2，…xn 的调和平均值 H 定义为

from scipy.stats import hmeanterm_freq_df2['pos_hmean'] = term_freq_df2.apply(lambda x: (hmean([x['pos_rate'], x['pos_freq_pct']])                                                               if x['pos_rate'] > 0 and x['pos_freq_pct'] > 0 else 0), axis=1)

term_freq_df2.sort_values(by='pos_hmean', ascending=False).iloc[:10]

调和平均秩似乎与 pos_freq_pct 相同。通过计算谐波平均值，小值(在这种情况下，pos_freq_pct)的影响过于严重，最终主导了平均值。这同样与频率值排名完全相同，并没有提供多少有意义的结果。

接下来我们可以尝试的是获得 pos_rate 和 pos_freq_pct 的 CDF(累积分布函数)值。CDF 可以解释为“X 的分布函数，在 X 处取值，是 X 取值小于等于 X 的概率”。通过计算 CDF 值，我们可以看到 pos_rate 或 pos_freq_pct 的值在累积方式分布中的位置。在下面的代码结果中，我们可以看到单词“welcome”的 pos_rate_normcdf 为 0.995625，pos_freq_pct_normcdf 为 0.999354。这意味着大约 99.56%的令牌将采用小于或等于 0.91535 的 pos_rate 值，99.99%的令牌将采用小于或等于 0.001521 的 pos_freq_pct 值。

接下来，我们像前面一样计算这两个 CDF 值的调和平均值。通过计算调和平均值，我们可以看到，pos_normcdf_hmean 度量提供了一个更有意义的方法来衡量一个单词在类中的重要性。

from scipy.stats import normdef normcdf(x):
    return norm.cdf(x, x.mean(), x.std())term_freq_df2['pos_rate_normcdf'] = normcdf(term_freq_df2['pos_rate'])term_freq_df2['pos_freq_pct_normcdf'] = normcdf(term_freq_df2['pos_freq_pct'])term_freq_df2['pos_normcdf_hmean'] = hmean([term_freq_df2['pos_rate_normcdf'], term_freq_df2['pos_freq_pct_normcdf']])term_freq_df2.sort_values(by='pos_normcdf_hmean',ascending=False).iloc[:10]

下一步是对每个单词的负频率进行同样的计算。

term_freq_df2['neg_rate'] = term_freq_df2['negative'] * 1./term_freq_df2['total']term_freq_df2['neg_freq_pct'] = term_freq_df2['negative'] * 1./term_freq_df2['negative'].sum()term_freq_df2['neg_hmean'] = term_freq_df2.apply(lambda x: (hmean([x['neg_rate'], x['neg_freq_pct']])                                                                if x['neg_rate'] > 0 and x['neg_freq_pct'] > 0                                                                else 0), axis=1)

term_freq_df2['neg_rate_normcdf'] = normcdf(term_freq_df2['neg_rate'])term_freq_df2['neg_freq_pct_normcdf'] = normcdf(term_freq_df2['neg_freq_pct'])term_freq_df2['neg_normcdf_hmean'] = hmean([term_freq_df2['neg_rate_normcdf'], term_freq_df2['neg_freq_pct_normcdf']])term_freq_df2.sort_values(by='neg_normcdf_hmean', ascending=False).iloc[:10]

现在让我们看看这些值是如何转换成一个图的。为了比较，我先画出 neg_hmean vs pos_hmean，以及 neg _ normcdf _ hme an vs pos _ normcdf _ hme an。

plt.figure(figsize=(8,6))
ax = sns.regplot(x="neg_hmean", y="pos_hmean",fit_reg=False, scatter_kws={'alpha':0.5},data=term_freq_df2)
plt.ylabel('Positive Rate and Frequency Harmonic Mean')
plt.xlabel('Negative Rate and Frequency Harmonic Mean')
plt.title('neg_hmean vs pos_hmean')

和刚才的正反频率差不了多少。CDF 调和平均值怎么样？

plt.figure(figsize=(8,6))
ax = sns.regplot(x="neg_normcdf_hmean", y="pos_normcdf_hmean",fit_reg=False, scatter_kws={'alpha':0.5},data=term_freq_df2)
plt.ylabel('Positive Rate and Frequency CDF Harmonic Mean')
plt.xlabel('Negative Rate and Frequency CDF Harmonic Mean')
plt.title('neg_normcdf_hmean vs pos_normcdf_hmean')

似乎速率 CDF 和频率 CDF 的调和平均值在图上创建了一个有趣的模式。如果一个数据点靠近左上角，它更为积极，如果靠近右下角，它更为消极。

这是一个很好的指标，它从频率中创造了一些有意义的洞察力，但是对于文本数据，将每个标记显示为一个点缺少关于每个数据点代表哪个标记的重要信息。对于 10，000 个点，很难在图上标注所有的点。对于这一部分，我尝试了几种方法，得出的结论是，直接在图上标注数据点不是很实际，也不太可行。

所以我采取了另一种方法，用散景进行交互式绘图。Bokeh 是 Python 的一个交互式可视化库，它以 D3.js 的风格创建图形。Bokeh 可以以 HTML 格式输出结果，也可以在 Jupyter 笔记本中输出结果。而下面是散景创造的剧情。

from bokeh.plotting import figure
from bokeh.io import output_notebook, show
from bokeh.models import LinearColorMapper
from bokeh.models import HoverTooloutput_notebook()
color_mapper = LinearColorMapper(palette='Inferno256', low=min(term_freq_df2.pos_normcdf_hmean), high=max(term_freq_df2.pos_normcdf_hmean))p = figure(x_axis_label='neg_normcdf_hmean', y_axis_label='pos_normcdf_hmean')p.circle('neg_normcdf_hmean','pos_normcdf_hmean',size=5,alpha=0.3,source=term_freq_df2,color={'field': 'pos_normcdf_hmean', 'transform': color_mapper})hover = HoverTool(tooltips=[('token','[@index](http://twitter.com/index)')])
p.add_tools(hover)
show(p)

由于互动图不能插入到 Medium post 中，我附上了一张图片，但不知何故散景图也不能在 GitHub 上显示。所以我把这个分享给你可以访问的链接。

[## 散景图

s3.eu-west-2.amazonaws.com](https://s3.eu-west-2.amazonaws.com/ricksimages/hover.html)

有了上面的散景图，你可以通过将鼠标悬停在点上来查看每个数据点代表什么。例如，左上角的点表示“感谢”、“欢迎”、“祝贺”等。右下角的一些记号是“悲伤”、“伤害”、“死亡”、“疼痛”等等。而且每个点的颜色都是在 Python 中的“Inferno256”颜色图中组织的，所以黄色是最正的，而黑色是最负的，颜色随着从负到正逐渐从黑到紫到橙再到黄。

根据我稍后将使用哪个模型来对正面和负面推文进行分类，这个度量也可以派上用场。

项目的下一阶段是模型制作。在这种情况下，分类器会将每条推文分为正面或负面类别。我会继续通过媒体分享我的进步。

感谢您的阅读，您可以从下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 3/blob/master/Capstone _ part 3-copy 2 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 4 部分(计数矢量器、混淆矩阵)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-4-count-vectorizer-b3f4944e51b5?source=collection_archive---------1-----------------------

Photo by Souvik Banerjee on Unsplash

这是我正在进行的 Twitter 情绪分析项目的第 4 部分。你可以从下面的链接找到以前的帖子。

[## 另一个使用 Python 的 Twitter 情感分析——第 3 部分(Zipf 定律，数据可视化)

这是我目前正在做的 Twitter 情绪分析项目的第三部分，作为通用…

towardsdatascience.com](/another-twitter-sentiment-analysis-with-python-part-3-zipfs-law-data-visualisation-fc9eadda71e7) [## 另一个使用 Python 的 Twitter 情感分析——第 2 部分

这篇博文是我目前正在为我的顶点计划做的 Twitter 情绪分析项目的第二部分…

towardsdatascience.com](/another-twitter-sentiment-analysis-with-python-part-2-333514854913) [## 另一个使用 Python 的 Twitter 情感分析—第 1 部分

距离我上次发帖已经有一段时间了。我不在灵媒期间，我的生活发生了很多事情。我终于收集了我的…

towardsdatascience.com](/another-twitter-sentiment-analysis-bb5b01ebad90)

在第 3 部分，我主要关注 EDA 和数据可视化，现在是时候为模型构建做准备了！

培训/开发/测试分割

在我们可以训练任何模型之前，我们首先考虑如何拆分数据。这里我选择将数据分成三个部分:训练、开发、测试。我参考了吴恩达关于如何拆分数据的“ deeplearning.ai ”课程。

训练集:用于学习的数据样本
开发集(保留交叉验证集):用于调整分类器参数的数据样本，并提供模型的无偏评估。
测试集:仅用于评估最终模型性能的数据样本。

我决定分割数据的比例是 98/1/1，98%的数据作为训练集，1%用于开发集，最后 1%用于测试集。这个比率背后的基本原理来自于我的整个数据集的大小。该数据集有超过 150 万个条目。在这种情况下，整个数据中只有 1%给了我 15000 多个条目。这对于评估模型和优化参数来说绰绰有余。

另一种方法是将数据分为训练集和测试集，并在训练集上运行 k-fold 交叉验证，这样就可以对模型进行无偏见的评估。但是考虑到数据的大小，我决定只使用训练集来训练一个模型，并在 dev 集上进行评估，这样我就可以快速测试不同的算法，并迭代地运行这个过程。

如果你想更详细地了解用于建模的数据分割，我推荐一篇来自“机器学习大师”的博客文章。该博客有大量关于数据科学广泛主题的文章，强烈推荐。

一旦我加载了清理过的 tweets 数据集，我运行如下的数据分割。注意，我已经将数据拆分了两次，第一次拆分了 train 和 dev+test，第二次拆分了 dev 和 test。

x = my_df.text
y = my_df.target
from sklearn.cross_validation import train_test_split
SEED = 2000x_train, x_validation_and_test, y_train, y_validation_and_test = train_test_split(x, y, test_size=.02, random_state=SEED)x_validation, x_test, y_validation, y_test = train_test_split(x_validation_and_test, y_validation_and_test, test_size=.5, random_state=SEED)print "Train set has total {0} entries with {1:.2f}% negative, {2:.2f}% positive".format(len(x_train),                                                                     (len(x_train[y_train == 0]) / (len(x_train)*1.))*100,                                                                           (len(x_train[y_train == 1]) / (len(x_train)*1.))*100)print "Validation set has total {0} entries with {1:.2f}% negative, {2:.2f}% positive".format(len(x_validation),                                                                          (len(x_validation[y_validation == 0]) / (len(x_validation)*1.))*100,                                                                       (len(x_validation[y_validation == 1]) / (len(x_validation)*1.))*100)print "Test set has total {0} entries with {1:.2f}% negative, {2:.2f}% positive".format(len(x_test),                                                          (len(x_test[y_test == 0]) / (len(x_test)*1.))*100,                                                           (len(x_test[y_test == 1]) / (len(x_test)*1.))*100)

基线

在比较各种机器学习算法时，baseline 提供了一个比较的参考点。最流行的基线是零规则(ZeroR) 。ZeroR 分类器简单地预测多数类别(类)。尽管在 ZeroR 中没有可预测性，但它对于确定基线性能作为其他分类方法的基准是有用的。从上面的验证集类划分可以看出，多数类为负，为 50.40%，这意味着如果一个分类器对每个验证数据都预测为负，那么它将获得 50.40%的准确率。

我想比较验证结果的另一个基线是 T extBlob 。TextBlob 是一个用于处理文本数据的 python 库。除了其他有用的工具，如词性标注，n-gram，该软件包内置了情感分类。这是一个所谓的开箱即用的情感分析工具，除了零精度之外，我还会记住我从 TextBlob 情感分析中获得的精度，以查看我的模型表现如何。

from textblob import TextBlob
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report, confusion_matrixtbresult = [TextBlob(i).sentiment.polarity for i in x_validation]
tbpred = [0 if n < 0 else 1 for n in tbresult]conmat = np.array(confusion_matrix(y_validation, tbpred, labels=[1,0]))confusion = pd.DataFrame(conmat, index=['positive', 'negative'],
                         columns=['predicted_positive','predicted_negative'])print "Accuracy Score: {0:.2f}%".format(accuracy_score(y_validation, tbpred)*100)
print "-"*80
print "Confusion Matrix\n"
print confusion
print "-"*80
print "Classification Report\n"
print classification_report(y_validation, tbpred)

TextBlob 情感分析在验证集上产生 60.65%的准确度，这比空准确度(50.40%)高 10.25%。

特征抽出

如果我们想在机器学习算法中使用文本，我们必须将它们转换成数字表示。其中一种方法叫做单词袋法。单词袋模型忽略了语法和单词的顺序。一旦我们有了一个语料库(文本数据)，那么首先，基于整个语料库创建一个词汇表。然后，基于从语料库建立的词汇，每个文档或数据条目被表示为数字向量。

计数矢量器

使用计数矢量器，我们仅仅计算每个文本中单词的出现次数。例如，假设我们在一个语料库中有 3 个文档:“我爱狗”、“我讨厌狗和编织”、“编织是我的爱好和激情”。如果我们从这三个句子中构建词汇，并将每个文档表示为计数向量，它将如下图所示。

但是如果语料库的规模变大，词汇的数量就会变得太大而无法处理。以我的 150 万条推文，如果不限制词汇量的话，我的词汇量将超过 26 万。这意味着训练数据的形状将在 1，500，000 x 260，000 左右，这听起来太大了，无法训练各种不同的模型。所以我决定限制词汇表的数量，但是我也想看看性能如何随着词汇表数量的不同而变化。

我想探索的另一件事是停用词。停用词是不包含重要意义的词，如“the”、“of”等。人们通常认为，删除停用词是一个必要的步骤，将提高模型性能。但是我想亲眼看看这是不是真的。所以我在有和没有停用词的情况下做了同样的测试，并比较了结果。此外，我还定义了自己的自定义停用词表，其中包含了语料库中最常用的 10 个词:" to "、" the "、" my "、" it "、" and "、" you "、" not "、" is "、" In "、" for "。

我选择的评估不同计数向量的模型是逻辑回归。与 KNN 或随机森林等模型相比，它是一种线性模型，因此在计算上可扩展到大数据。一旦我有了最佳数量的特征，并决定是否删除停用词，那么我将使用所选数量的词汇计数向量尝试不同的模型。

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from time import time

下面我定义了两个函数来迭代训练不同数量的特征，然后检查验证集上逻辑回归的准确性。

def accuracy_summary(pipeline, x_train, y_train, x_test, y_test):
    if len(x_test[y_test == 0]) / (len(x_test)*1.) > 0.5:
        null_accuracy = len(x_test[y_test == 0]) / (len(x_test)*1.)
    else:
        null_accuracy = 1\. - (len(x_test[y_test == 0]) / (len(x_test)*1.))
    t0 = time()
    sentiment_fit = pipeline.fit(x_train, y_train)
    y_pred = sentiment_fit.predict(x_test)
    train_test_time = time() - t0
    accuracy = accuracy_score(y_test, y_pred)
    print "null accuracy: {0:.2f}%".format(null_accuracy*100)
    print "accuracy score: {0:.2f}%".format(accuracy*100)
    if accuracy > null_accuracy:
        print "model is {0:.2f}% more accurate than null accuracy".format((accuracy-null_accuracy)*100)
    elif accuracy == null_accuracy:
        print "model has the same accuracy with the null accuracy"
    else:
        print "model is {0:.2f}% less accurate than null accuracy".format((null_accuracy-accuracy)*100)
    print "train and test time: {0:.2f}s".format(train_test_time)
    print "-"*80
    return accuracy, train_test_timecvec = CountVectorizer()
lr = LogisticRegression()
n_features = np.arange(10000,100001,10000)def nfeature_accuracy_checker(vectorizer=cvec, n_features=n_features, stop_words=None, ngram_range=(1, 1), classifier=lr):
    result = []
    print (classifier)
    print "\n"
    for n in n_features:
        vectorizer.set_params(stop_words=stop_words, max_features=n, ngram_range=ngram_range)
        checker_pipeline = Pipeline([
            ('vectorizer', vectorizer),
            ('classifier', classifier)
        ])
        print "Validation result for {} features".format(n)
        nfeature_accuracy,tt_time = accuracy_summary(checker_pipeline, x_train, y_train, x_validation, y_validation)
        result.append((n,nfeature_accuracy,tt_time))
    return result

然后，我通过调用上面定义的“nfeature_accuracy_checker”来检查不同数量的特性的有效性。此外，我定义了前 10 个常用术语的自定义停用词来比较结果。注意,‘term _ freq _ df . CSV’是我用语料库从项目的前一部分创建的文件。

csv = 'term_freq_df.csv'
term_freq_df = pd.read_csv(csv,index_col=0)
term_freq_df.sort_values(by='total', ascending=False).iloc[:10]

只是为了仔细检查这 10 个单词是否真的包含在 SKLearn 的停用单词列表中，我运行了如下的小代码，看到所有的 10 个单词也在 SKLearn 的停用单词列表中。

from sklearn.feature_extraction import texta = frozenset(list(term_freq_df.sort_values(by='total', ascending=False).iloc[:10].index))
b = text.ENGLISH_STOP_WORDS
set(a).issubset(set(b))

my_stop_words = frozenset(list(term_freq_df.sort_values(by='total', ascending=False).iloc[:10].index))

现在，我可以在三种不同的条件下运行“nfeature_accuracy_checker”。第一个带停用词删除，第二个带自定义停用词删除，第三个不带停用词删除。

print "RESULT FOR UNIGRAM WITHOUT STOP WORDS\n"
feature_result_wosw = nfeature_accuracy_checker(stop_words='english')print "RESULT FOR UNIGRAM WITH STOP WORDS\n"
feature_result_ug = nfeature_accuracy_checker()print "RESULT FOR UNIGRAM WITHOUT CUSTOM STOP WORDS (Top 10 frequent words)\n"
feature_result_wocsw = nfeature_accuracy_checker(stop_words=my_stop_words)

我会用一个图表来显示上述准确性检查的结果。

nfeatures_plot_ug = pd.DataFrame(feature_result_ug,columns=['nfeatures','validation_accuracy','train_test_time'])
nfeatures_plot_ug_wocsw = pd.DataFrame(feature_result_wocsw,columns=['nfeatures','validation_accuracy','train_test_time'])
nfeatures_plot_ug_wosw = pd.DataFrame(feature_result_wosw,columns=['nfeatures','validation_accuracy','train_test_time'])plt.figure(figsize=(8,6))
plt.plot(nfeatures_plot_ug.nfeatures, nfeatures_plot_ug.validation_accuracy, label='with stop words')
plt.plot(nfeatures_plot_ug_wocsw.nfeatures, nfeatures_plot_ug_wocsw.validation_accuracy,label='without custom stop words')
plt.plot(nfeatures_plot_ug_wosw.nfeatures, nfeatures_plot_ug_wosw.validation_accuracy,label='without stop words')
plt.title("Without stop words VS With stop words (Unigram): Accuracy")
plt.xlabel("Number of features")
plt.ylabel("Validation set accuracy")
plt.legend()

通过查看评估结果，删除停用词不会提高模型性能，但保留停用词会产生更好的性能。我不会说删除停用词不能每次都帮助模型性能，但是根据经验发现，在这个特定的设置中，保留停用词可以提高模型性能。

二元模型

根据维基百科，“n-gram 是来自给定文本或语音序列的 n 个项目的连续序列”。换句话说，n-grams 就是你能在源文本中找到的所有长度为 n 的相邻单词或字母的组合。下图很好地展示了 n 元语法是如何从源文本中构建出来的。

在这个项目中，我将把单词包扩展到三元模型，看看它如何影响性能。

print "RESULT FOR BIGRAM WITH STOP WORDS\n"
feature_result_bg = nfeature_accuracy_checker(ngram_range=(1, 2))print "RESULT FOR TRIGRAM WITH STOP WORDS\n"
feature_result_tg = nfeature_accuracy_checker(ngram_range=(1, 3))

运行上述代码后，我将 unigram、bigram 和 trigram 的结果一起绘制在一个图表上，如下所示。

nfeatures_plot_tg = pd.DataFrame(feature_result_tg,columns=['nfeatures','validation_accuracy','train_test_time'])
nfeatures_plot_bg = pd.DataFrame(feature_result_bg,columns=['nfeatures','validation_accuracy','train_test_time'])
nfeatures_plot_ug = pd.DataFrame(feature_result_ug,columns=['nfeatures','validation_accuracy','train_test_time'])plt.figure(figsize=(8,6))
plt.plot(nfeatures_plot_tg.nfeatures, nfeatures_plot_tg.validation_accuracy,label='trigram')
plt.plot(nfeatures_plot_bg.nfeatures, nfeatures_plot_bg.validation_accuracy,label='bigram')
plt.plot(nfeatures_plot_ug.nfeatures, nfeatures_plot_ug.validation_accuracy, label='unigram')
plt.title("N-gram(1~3) test result : Accuracy")
plt.xlabel("Number of features")
plt.ylabel("Validation set accuracy")
plt.legend()

每个 n 元语法的最佳验证集精度如下。

unigram: 80，000 和 90，000 个特征，验证准确率 80.28%
bigram: 70，000 个特征，验证准确率 82.25%
三元模型:80，000 个特征，验证准确率 82.44%

下面我定义了另一个函数来更仔细地观察每个 n-gram 的最佳性能特征。下面的函数不仅报告准确性，而且给出混淆矩阵和分类报告。

def train_test_and_evaluate(pipeline, x_train, y_train, x_test, y_test):
    if len(x_test[y_test == 0]) / (len(x_test)*1.) > 0.5:
        null_accuracy = len(x_test[y_test == 0]) / (len(x_test)*1.)
    else:
        null_accuracy = 1\. - (len(x_test[y_test == 0]) / (len(x_test)*1.))
    sentiment_fit = pipeline.fit(x_train, y_train)
    y_pred = sentiment_fit.predict(x_test)
    accuracy = accuracy_score(y_test, y_pred)
    conmat = np.array(confusion_matrix(y_test, y_pred, labels=[0,1]))
    confusion = pd.DataFrame(conmat, index=['negative', 'positive'],
                         columns=['predicted_negative','predicted_positive'])
    print "null accuracy: {0:.2f}%".format(null_accuracy*100)
    print "accuracy score: {0:.2f}%".format(accuracy*100)
    if accuracy > null_accuracy:
        print "model is {0:.2f}% more accurate than null accuracy".format((accuracy-null_accuracy)*100)
    elif accuracy == null_accuracy:
        print "model has the same accuracy with the null accuracy"
    else:
        print "model is {0:.2f}% less accurate than null accuracy".format((null_accuracy-accuracy)*100)
    print "-"*80
    print "Confusion Matrix\n"
    print confusion
    print "-"*80
    print "Classification Report\n"
    print classification_report(y_test, y_pred, target_names=['negative','positive'])

在运行定义的函数之前，让我简单解释一下混淆矩阵和分类报告。为了评估模型的性能，可以使用许多不同的指标。下面我将讨论二元分类的情况，其中目标变量只有两类要预测。在这个项目中，类别要么是“负的”，要么是“正的”。

一个显而易见的绩效衡量标准是准确性。它是模型在整个数据集的数量上对该类进行正确预测的次数。但是在分类的情况下，这可以进一步分解。下面是混淆矩阵的表示。

在上面的矩阵中，每一行表示实际类中的实例，而每一列表示预测类中的实例，并且它也可以通过交换行和列来表示(实际类的列，预测类的行)。所以我上面说的精度(ACC)可以表达如下。

当数据中类的分布非常均衡时，准确性可以让您很好地了解模型的执行情况。但是，当您有倾斜的数据时，例如，其中一个类在您的数据集中占主导地位，那么准确性可能不足以评估您的模型。假设你有一个包含 80%正类和 20%负类的数据集。这意味着，通过预测每个数据进入正类，模型将获得 80%的准确性。在这种情况下，您可能希望进一步探究混淆矩阵，并尝试不同的评估指标。

可以有 9 个不同的指标，只是来自混淆矩阵的数字组合，但我将特别讨论其中的两个，以及结合这两个的另一个指标。

“”(也叫阳性预测值)告诉你预测为阳性的数据实际上有多大比例是阳性的。换句话说，在所有阳性预测数据集中，真阳性的比例。

"回忆(也称为敏感度、命中率、真阳性率)告诉您实际为阳性的数据被预测为阳性的比例。换句话说，所有实际阳性数据中真正阳性的比例。

下图是癌症诊断的混淆矩阵。如果你认为“癌症”是阳性类别，“非癌症”是阴性类别，这个图像很好地解释了如何根据混淆矩阵来考虑精确度和召回率。

最后，F1 分数是精确度和召回率的调和平均值。调和平均值是一种特殊类型的平均值，用于处理单位平均值，如比率和比率。因此，通过计算这两个指标的调和平均值，您可以很好地了解模型在精确度和召回率方面的表现。公式如下。

%%time
tg_cvec = CountVectorizer(max_features=80000,ngram_range=(1, 3))
tg_pipeline = Pipeline([
        ('vectorizer', tg_cvec),
        ('classifier', lr)
    ])
train_test_and_evaluate(tg_pipeline, x_train, y_train, x_validation, y_validation)

从上面的分类报告中，我们可以看到，模型在否定类中的准确率略高，在肯定类中的召回率也较高。但是这是通过计算 F1 分数得出的平均值，对于这两个类，我们得到了正类和负类几乎相同的 F1 分数。还有一种通过绘制 ROC 曲线来可视化模型性能的方法，但我将在后面更详细地解释。

在这篇文章中，我研究了基于用计数矢量器提取的特征的逻辑回归是如何执行的。在下一篇文章中，我将试验 Tfidf 矢量器，看看结果有什么不同。

感谢您阅读这篇长文！你可以从下面的链接找到上面代码的 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 4/blob/master/Capstone _ part 4-copy 2 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 5 部分(Tfidf 矢量器、模型比较、词汇方法)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-5-50b4e87d9bdd?source=collection_archive---------2-----------------------

Photo by Nathaniel Shuman on Unsplash

这是我正在进行的推特情感分析项目的第五部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵

在上一部分中，我尝试使用计数矢量器来提取特征并将文本数据转换成数字形式。在这一部分，我将使用另一种称为 Tfidf 矢量器的特征提取技术。

Tfidf 矢量器

TFIDF 是将文本数据转换为数字形式的另一种方式，是词频-逆文档频的简称。它产生的向量值是这两项的乘积；TF 和 IDF。

我们先来看词频。我们已经用计数矢量器查看了词频，但是这一次，我们还需要一个步骤来计算相对频率。假设我们的语料库中有两个文档，如下所示。

我喜欢狗
我讨厌狗和编织

每个文档中每个术语的相对术语频率计算如下。

例如，如果我们计算文档 1 和文档 2 中“I”的相对词频，结果如下。

接下来，我们需要得到逆文档频率，它通过下面的计算来衡量一个单词对于区分每个文档的重要性。

如果我们计算“I”的逆文档频率，

一旦我们有了 TF 和 IDF 的值，现在我们可以计算 TFIDF 如下。

按照我们示例的情况，两个文档中术语“I”的 TFIDF 如下。

正如您所看到的，术语“I”在两个文档中出现的次数相同，TFIDF 得分为 0，这意味着该术语在区分文档时并没有真正提供信息。其余部分与计数矢量器相同，TFIDF 矢量器将计算文档中术语的得分，并将文本数据转换为数字形式。

一旦实例化了 Tfidf 矢量器，将 Tfidf 转换后的数据拟合到逻辑回归，并检查不同数量的特征的验证准确性。

在这篇文章中，当我提到代码块时，我会附上一个要点链接，而不是将整个代码作为片段直接粘贴在文章中，此外，你也可以从我将在这篇文章结尾分享的链接中找到整个 Jupyter 笔记本。

因为我也有来自计数矢量器的结果，我在以前的帖子中尝试过，我将它们一起绘制在同一个图形上进行比较。

从上面的图表中，我们可以看到，在计数矢量器和 TFIDF 矢量器中包含二元模型和三元模型提高了模型性能。对于每种从一元到三元的情况，TFIDF 都比计数矢量器产生更好的结果。

算法比较

我用逻辑回归得到的最好结果是通过使用包含多达 100，000 个特征(包括三元模型)的 TFIDF 矢量器。在这种情况下，我将首先拟合各种不同的模型，并比较它们的验证结果，然后将建立一个包含前 5 个模型的集成(投票)分类器。

考虑到数据的大小和模型的可扩展性，我没有包括一些计算量大的模型，如 KNN、随机森林。模型的微调将在我尝试其他不同的文本数据矢量化之后进行。

我不会详细解释每个模型是如何工作的，因为这不是这篇文章的目的。你可以在网上找到许多有用的资源，但如果我收到许多关于某个特定算法的问题或请求，我会尝试为所选的模型单独写一篇文章。

(请注意，在下面的“classifier_comparator”函数中，我调用了另一个自定义函数“accuracy_summary ”,它报告与空精度相比的验证精度，以及训练和评估所用的时间。)

比较的结果如下。

看起来逻辑回归是我表现最好的分类器。

集成分类器的结果如下，该集成分类器从来自上述结果的前 5 个模型(线性回归、线性 SVC、多项式 NB、岭分类器、被动-主动分类器)中获得投票。注意，我没有在投票分类器中包括“具有基于 L-1 的特征选择的线性 SVC”模型，因为它与线性 SVC 是相同的模型，除了它首先通过 L-1 正则化过滤掉特征，并且比较没有特征选择的线性 SVC 的结果显示出更好的结果。

投票分类器的验证集准确率为 82.47%，比单独的逻辑回归的 82.92%要差。

词汇法

我上面演示的是文本分类问题的机器学习方法，它试图通过在带标签的数据集上训练分类器来解决问题。另一个著名的情感分析方法是词汇法。在词汇方法中，情感的定义是基于对单个单词和/或短语的分析；经常使用情感词典:在文本中搜索词典中的情感词汇项，计算它们的情感权重，并应用一些聚合权重函数。”http://www.dialog-21.ru/media/1226/blinovpd.pdf

在本系列的第 3 部分中，我计算了“正率 CDF”和“正频率百分比 CDF”的调和平均值，这些给了我在语料库中正面和负面术语的良好表示。如果它成功地过滤了哪些术语对每个类是重要的，那么这也可以用于词汇方式的预测。

所以我决定做一个简单的预测器，利用我计算的谐波平均值。下面我将介绍术语频率的计算，以及获得‘pos _ normcdf _ hme an’的步骤，但这次我仅从训练集中计算术语频率。(*由于我了解到不需要将稀疏矩阵转换为密集矩阵来计算术语频率，所以我直接从稀疏矩阵计算频率)

如果你想更详细地了解我用来得出“pos_norcdf_hmean”最终值的公式，你可以在本系列的第 3 部分中找到。

我决定的积极性得分的计算相当简单明了。对于文档中的每个单词，在我构建词汇表的 10，000 个单词的列表中查找它，并获得相应的“pos_normcdf_hmean”值，然后为文档计算平均“pos_normcdf_hmean”值。如果从构建的 10，000 个术语中找不到任何单词，则产生范围在 0 到 1 之间的随机概率。我从一个文档中得到的单个值被处理为该文档是正类的概率。

通常情况下，词法方法会将许多其他方面纳入计算，以完善预测结果，但我将尝试一个非常简单的模型。

对于“pos_hmean”的平均值，我决定阈值为 0.56，这意味着如果“pos_hmean”的平均值大于 0.56，分类器将其预测为正类，如果它等于或小于 0.56，则将其预测为负类。由上述模型得到的结果为 75.96%。准确度不如使用计数矢量器或 TFIDF 矢量器的逻辑回归，但与 null 准确度相比，准确度高 25.56%，甚至与 TextBlob 情感分析相比，我的简单自定义词典模型的准确度高 15.31%。对于这样一个简单的计算来说，这是一个令人印象深刻的结果，并且还考虑到“pos_normcdf_hmean”仅使用训练集计算的事实。

在下一篇文章中，我将尝试实现 Doc2Vec，看看性能是否会变得更好。

感谢您的阅读，您可以通过下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 5/blob/master/Capstone _ part 4-copy 3 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 6 部分(Doc2Vec)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-6-doc2vec-603f11832504?source=collection_archive---------1-----------------------

Photo by Markus Winkler on Unsplash

这是我正在进行的推特情感分析项目的第六部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

在我们跳到 doc2vec 之前，先提一下 word2vec 会比较好。Word2vec 是一组用于产生单词嵌入的相关模型。这些模型是浅层的两层神经网络，经过训练可以重建单词的语言上下文。”

Word2vec 不是一个单一的算法，而是由两种技术组成——CBOW(连续单词包)和 Skip-gram 模型。这两种技术都学习作为单词向量表示的权重。对于语料库，CBOW 模型从周围上下文单词的窗口中预测当前单词，而 Skip-gram 模型在给定当前单词的情况下预测周围上下文单词。在 Gensim 包中，在实现 Word2Vec 时，可以通过传递参数“sg”来指定是使用 CBOW 还是 Skip-gram。默认情况下(sg=0)，使用 CBOW。否则(sg=1)，使用 skip-gram。

例如，假设我们有下面的句子:“我喜欢狗”。当给定“我”、“狗”作为输入时，CBOW 模型试图预测单词“爱”，另一方面，当给定单词“爱”作为输入时，Skip-gram 模型试图预测“我”、“狗”。

下图更正式地展示了这两个模型是如何工作的。

但是，用作单词向量的实际上不是这些模型的预测结果，而是经过训练的模型的权重。通过提取权重，这样的向量以某种抽象的方式来表示单词的“含义”。如果想更详细的了解 word2vec 模型是如何工作的，有一篇欣荣(2016) 的很棒的论文，详细的讲解了模型的每一步。

那 doc2vec 是什么？Doc2vec 使用与 word2vec 相同的逻辑，但是将其应用于文档级。根据 Le 和 Mikolov(2014) ，“每个段落被映射到一个唯一的向量，由矩阵 D 中的一列表示，每个单词也被映射到一个唯一的向量，由矩阵 w 中的一列表示。段落向量和单词向量被平均或连接以预测上下文中的下一个单词……段落标记可以被认为是另一个单词。它起到了记忆的作用，记住了当前上下文或者段落主题中缺少的内容。”

DM:这是类似于 Word2vec 中 CBOW 模型的 Doc2Vec 模型。段落向量是通过在基于上下文单词和上下文段落推断中心单词的任务上训练神经网络而获得的。

DBOW:这是 Doc2Vec 模型对 Word2Vec 中的 Skip-gram 模型的模拟。段落向量是通过训练神经网络来获得的，该神经网络的任务是在给定从段落中随机采样的单词的情况下，预测段落中单词的概率分布。

我使用 Python 库 Gensim 实现了 Doc2Vec 模型。在 DM 模型的情况下，我实现了平均方法和连接方法。这是受乐和 Mikolov (2014) 的研究论文的启发。在他们的论文中，他们用两种不同的方法实现了 DM 模型，一种是平均计算过程，另一种是串联计算方法。这在 Gensim 的教程中也有展示。

以下是我用来获取每条推文向量的方法。

分布式单词包
分布式存储器级联
分布式存储装置
DBOW + DMC
DBOW + DMM

利用从上述模型中获得的向量，我拟合了一个简单的逻辑回归模型，并在验证集上评估了结果。

作为准备，除了加载所需的依赖项，我们还需要使用 Gensim 的 LabeledSentence 函数用唯一的 id 标记每条 tweet。

为了训练 Doc2Vec，我使用了整个数据集。这背后的基本原理是 doc2vec 训练是完全无人监督的，因此没有必要保留任何数据，因为它是未标记的。这一基本原理的灵感来自于 Lau 和 Baldwin (2016) 在他们的研究论文《doc2vec 的实证评估与文档嵌入生成的实际见解》中的基本原理

同样的基本原理也应用于 Gensim 的 Doc2Vec 教程。在 IMDB 教程中，向量训练发生在数据集的所有文档上，包括所有训练/测试/开发集。

分布式单词包

我们先训练纯 DBOW 模型。请注意，由于其训练方式，DBOW 模型不会在单词级别产生任何有意义的向量。但是当我们谈到分布式内存模型时，我们也要看看单词向量。

据 Gensim 的开发者拉迪姆·řehůřek 说，“这种算法运行方式的一个警告是，由于学习率在数据迭代过程中下降，在训练期间只在单个带标签的句子中看到的标签将以固定的学习率进行训练。这经常产生不太理想的结果。”

下面的迭代实现了带有附加混洗的显式多遍 alpha 缩减方法。这已经在 Gensim 的 IMDB 教程中介绍过了。

在上面的代码块中，我还定义了一个函数“get_vectors”来从训练好的 doc2vec 模型中提取文档向量，这个函数也将在其他 doc2vec 模型中重用。

用逻辑回归在验证集上测试的准确度是 73.89%。尽管 DBOW 模型不学习单个单词的含义，但作为输入到分类器的特征，它似乎正在完成它的工作。

但它似乎没有胜过计数矢量器或 Tfidf 矢量器(Tfidf 矢量器具有 100，000 个特征，使用逻辑回归的验证集准确率为 82.92%)。

分布式存储器串联

现在让我们转到分布式内存模型，看看它是如何执行的。我将首先尝试用串联法进行训练。

不幸的是，验证集上的准确率是 66.47%，这有点令人失望。但这并不意味着该模型未能在单词级别学习到有效的向量表示。

通过在训练后查看与“facebook”相似的单词，看起来该模型恰当地抓住了 SNS，web 服务的含义。此外，该模式还成功地捕捉到了“小”的比较级形式，即“大”和“更大”。上面的代码行就像要求模型将与单词“bigger”和“small”相关联的向量相加，同时减去“big”等于顶部的结果，“small”。

分布式存储装置

我们试试另一种训练 DM 模型的方法。

验证集准确率为 72.56%，远优于 DMC 模型，略低于 DBOW 模型。我们也来看看它学到了什么。

看起来它已经很好地理解了“好”的含义，模型为“好”选择的最相似的词是“太好了”。太好了！

组合模型

由于我有来自三个不同模型的文档向量，现在我可以将它们连接起来，看看它是如何影响性能的。下面我定义了一个简单的函数来连接来自不同模型的文档向量。

DBOW + DMC 模型的验证集准确率为 74.58%，比纯 DBOW 模型(73.89%)有所提高。让我们试试另一种组合。

这次通过将 DBOW 和 DMM 结合在一起，我得到了 75.51%的验证集准确率。

对于 unigram，我了解到以不同的组合连接文档向量可以提高模型性能。我从单一模型得到的最好的验证准确率是 DBOW 的 73.89%。通过连接向量，我用 DBOW+DMM 模型得到了 75.51%的最高验证准确率。

在下一篇文章中，我将看看使用 Gensim 的短语建模，并将其应用于 Doc2Vec，看看这是否会影响性能。

感谢您的阅读，您可以通过下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle a/Twitter _ 情操 _ 分析 _ part 6/blob/master/Capstone _ part 4-copy 4 . ipynb

使用 Python 的另一个 Twitter 情感分析—第 7 部分(短语建模+ Doc2Vec)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-7-phrase-modeling-doc2vec-592a8a996867?source=collection_archive---------3-----------------------

Photo by Raphael Schaller on Unsplash

这是我正在进行的推特情感分析项目的第 7 部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法
第 6 部分:Doc2Vec

在上一篇文章中，我实现了 Doc2Vec，并用从 Doc2Vec 模型中获得的文档向量尝试了一个简单的逻辑回归。不幸的是，在情感分析任务中，100 维文档向量并没有胜过 100，000 维 Tfidf 特征。这一次，我将尝试短语建模，看看能否进一步提高 Doc2Vec 向量的性能。

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

短语建模

另一件可以用 Gensim 库实现的事情是短语检测。它类似于 n-gram，但它不是通过滑动窗口来获得所有的 n-gram，而是检测经常使用的短语并将它们粘在一起。

这已经由 Mikolov 等人介绍过了。al (2013) ，并且提出学习短语的向量表示，该短语具有不是其单个单词的意思的简单组合的意思。"这样，我们可以在不增加词汇量的情况下形成许多合理的短语."

Patrick Harrison 在 2016 年 DC PyData 大会上也对 Gensim 的短语建模进行了非常直观的解释。

下面的公式简单地表达了短语建模。

其中:

count(A)是 token (token 是 NLP 字段中词汇或单词的另一个单词)在语料库中出现的次数
count(B)是记号 B 在语料库中出现的次数
count(A B)是单词 A B 在语料库中按顺序出现的次数
n 是语料库词汇的总大小
count_min 是用户定义的参数，用于确保接受的短语出现的次数最少(Gensim 的短语函数中的默认值为 5)
threshold 是一个用户定义的参数，用于控制模型在接受两个单词作为短语之前需要它们之间的关系有多强(Gensim 的短语函数中使用的默认阈值是 10.0)

好，让我们看看这实际上是如何工作的。

现在我们有了一个二元模型，它将检测两个单词的常用短语，并将它们粘在一起。例如，假设我们有一个句子“纽约市长在那里”，看看如果我们将这个句子输入到 bigram 短语模型中会发生什么。

从上面的例子可以看出，通过 tweets 语料库，它已经学会了“纽约”这个常用短语。所以现在给“bigram”输入分隔“new”和“york”的标记，它会自动把它们组合成一个单词“new_york”。

让我们用 tweet 数据集中的一个训练数据来测试二元模型。以下是推文原文。(是的，这的确非常令人难过)

如果我们把这句话输入二元模型，

我们可以看到二元模型已经将“vanilla_ice”识别为一个短语。但如果它只能抓到“香草 _ 冰”而抓不到“香草 _ 冰淇淋”，那么有时候“香草 _ 冰”可以是别的意思。

我稍后将回到这一点。

现在让我们用这个二元模型来转换我们的语料库。

在我获得检测到二元语法短语的语料库后，我经历了与 unigram 相同的 Doc2Vec 过程。

检测到二元模型的分布式单词包

在下面的代码块中，你会发现一些在没有导入的情况下使用的依赖项，以及自定义的函数“get_vectors”。你可以在这篇文章的最后找到 Jupyter 笔记本的完整版本。

关于验证的准确性，我将在后面向您展示直到 trigram 之前尝试过的所有 doc2vec 模型。

检测到带有 bigram 的 DMC(分布式内存连接)

与 DBOW 模型不同，DM 模型也可以学习每个单词有意义的语义向量表示。

因为现在我们有二元短语检测语料库，如果我们寻找与“纽约”最相似的词，模型说它是“纽约”，这非常令人惊讶，你也可以看到其他城市名称，如“芝加哥”、“柏林”等。

检测到带有二元模型的 DMM(分布式内存装置)

组合模型

和我在上一篇文章中所做的一样，我尝试了两种组合模型:DBOW + DMC，DBOW + DMM。你可以在我最后分享的 Jupyter 笔记本里找到代码。

三元模型

如果我们在二元模型检测的语料库上再次运行相同的短语检测，现在它将检测三元模型短语。

终于！香草冰淇淋！

我再次用 trigram detected 语料库运行了三个不同的 doc2vec 模型，下面是我用不同的 doc2vec 模型从 unigram 到 trigram 得到的结果。

我能得到的最好的验证精度来自 dbow+dmm 模型。

DMM 模型往往随着 n-gram 的增加而表现更好，而纯 DBOW 模型往往随着 n-gram 的增加而表现更差。组合的模型是(即 dbow +dmc)和(dbow +dmm)用二元模型产生较低的结果，用三元模型产生较高的结果，但是考虑到这些差异都在小数位，可能很难说短语检测对组合的模型结构有影响。(请注意，这是在这种特定环境下的经验发现，但如果你想用你选择的语料库尝试这一点，我肯定想知道这是否在不同的情况下成立。)

在我进入下一步之前，我想再做一件事，那就是创建跨不同 n 元文法的联合向量。通过查看上表，对于 DBOW 模型，unigram 表现最佳，因此我将使用来自 unigram DBOW 模型的向量，并将其与 trigram DMM 向量结合在一起。

“unigram DBOW + trigram DMM”模型的验证准确性为 75.76%，略好于“trigram DBOW + DMM”模型，但差异仍然在小数点位置，我不确定是否可以说这是一个显著的改进。

在下一篇文章中，我将使用来自 Doc2Vec 和 Tfidf 稀疏矩阵的向量实现神经网络模型，并将结果与简单的逻辑回归进行比较。

感谢您的阅读，您可以通过下面的链接找到 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 7/blob/master/Capstone _ part 4-copy 5 . ipynb

用 Python 进行的另一个 Twitter 情感分析—第 8 部分(降维:Chi2，PCA)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-8-dimensionality-reduction-chi2-pca-c6d06fb3fcf3?source=collection_archive---------2-----------------------

Photo by Markus Spiske on Unsplash

这是我正在进行的推特情感分析项目的第 8 部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法
第 6 部分:Doc2Vec
第七部分:短语建模+ Doc2Vec

在上一篇文章中，我已经将短语建模与 doc2vec 模型结合起来，并看到验证准确性略有提高，我将继续讨论神经网络，看看 ANN 如何提高性能。但是我决定绕道而行，尝试对我从 Tfidf 矢量器和 Doc2Vec 矢量获得的特征进行降维。

到目前为止，在特征提取方面，我尝试了三种不同的方法:count vectorizer、Tfdif vectorizer、doc2vec。我得到的最好的验证结果如下。

分类器:逻辑回归(L2 正则化，正则化强度:1.0)

计数矢量器(80，000 个特征，n 元语法范围:1，2，3，停用词移除:X) — 82.44%
tfidf 矢量器(100，000 个特征，n 元语法范围:1，2，3，停用词移除:X) — 82.92%
Doc2Vec (unigram DBOW + trigram DMM:每条推文的 200 维向量总数)— 75.76%

除此之外，我还使用词法方法自定义了分类器。

自定义词典分类器(决策阈值设置为 0.56) — 75.96%

除了词法方法之外，模型所需的特征数量似乎相当大，所以我决定看看是否可以减少 Tfidf 矢量器和 doc2vec 矢量的特征维数。Doc2Vec 模型中的矢量为 200 维，与 Tfidf 矢量器的 100，000 个特征相比，听起来非常小。但是这 200 维向量是全实数的稠密矩阵，而 10 万个特征是零很多的稀疏矩阵。因此，在计算方面，Doc2Vec 向量也需要一些时间来计算。因此，如果我可以减少维度，那么它将有助于运行模型的超参数调整的各种设置。

首先，让我们尝试使用卡方特征选择对 Tfidf 向量进行降维。

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

Chi2 特征选择

在 Scikit-learn 库中，有三种方法可用于稀疏矩阵的特征选择，如 Tfidf 向量或计数向量。通过查看文档，您可以看到 chi2、mutual_info_regression、mutual_info_classif 将在不使数据密集的情况下处理数据。在我的情况下，我有 150 万条推文，并希望从 10 万个特征中减少维度，因此将其转换为密集矩阵不是一个选项。它不适合我的内存。

卡方统计测量特征(在这种情况下，推文中的一个术语)和类别(推文是正面还是负面)之间缺乏独立性。

你可以首先把一条推文中的一个术语和这条推文所属的类别之间的关系想象成一个列联表。列联表只是显示频率分布的表的一个花哨的词。

假设我们的语料库中有如下三个句子。

我喜欢狗
我讨厌狗
我喜欢狗和烹饪

假设每条推文的情绪等级是积极的，消极的，积极的。(顺便说一句，我喜欢狗和烹饪，也喜欢猫)

让我们将' t '定义为我们正在查看的特定术语，在本例中为“狗”，将' c '定义为类，因为该类只有两个类，所以它将是 1(正)或 0(负)。使用列联表，其中 A 为' t 发生的次数， c 为正，B 为' t '发生的次数，【C】为负，C 为' t 未发生的次数， c 为正，最后 D 为' t 未发生的次数， c 为负。现在我们准备计算卡方统计量。

其中 N 是样本总数，术语“狗”的卡方得分是 3！由于卡方测量的是特征和类之间缺乏独立性，如果某个特征与其他特征相比具有较高的卡方得分，则意味着该特征对于预测类是有用的。

我将首先将训练数据转换为 100，000 个特征的 Tfidf 向量，并查看 chi2 选择了哪些特征作为有用的特征。让我们把我们得到的分数画在图上，看看哪些单词特征对预测有用。我将在下面的图表中只列出前 20 个特征，但是只要你的电脑屏幕允许，你可以尽可能多的列出来。

chi2 选择的最有用的特征是“谢谢”这个词，我假设这主要来自于积极的推文。它选择的第二个最有用的特征是“悲伤”这个词，这次我猜它来自负面推文。如果考虑 chi2 是如何计算的，它不仅在预测正类的术语上得分高，而且在预测负类的术语上得分高。

既然现在我们已经了解了 chi2 特征选择是如何工作的，那么让我们将维度减少到不同数量的特征，并检查验证集的准确性。

还有一件事。当您拟合和转换语料库时，Tfidf 矢量器可以首先限制特征的数量。我想比较相同特征数量下的验证准确性:1)当特征数量受到 Tfidf 矢量化阶段的限制时，2)当使用 chi2 统计将特征数量从 100，000 个特征减少时。

*在下面的代码块中，我绘制了我在不同的 max 特性上运行 Tfidf 矢量器得到的结果，你也可以在本文末尾的 Jupyter 笔记本上找到完整的代码。

在上图中，红色虚线是来自降维的验证集精度，蓝色线是拟合 Tfidf 矢量器时首先限制特征数量的结果。我们可以看到，使用 Tfidf 矢量器首先限制要素的数量比从较大的要素中减少维度会产生更好的结果。这不是一个笼统的说法，而是我在这个特定背景下的发现。如果你在其他语料库中有不同的结果，我很想知道它有什么不同。

主成分分析

PCA 是一种降维工具，可用于将一大组变量降维为一个仍包含原始集合中大部分信息的小集合。这听起来很酷，你可以减少数据的特征，但不能保留大部分需要的信息。但是如果你尝试过谷歌搜索“PCA”，你可能会知道它会给你返回所有听起来很难的术语，如“特征值”、“特征向量”、“矩阵投影”等。

在这篇文章中，我不会详细介绍 PCA 实际上是如何计算的，但会尽量保持直观的水平，这样任何阅读这篇文章的人都可以理解它的基础知识，并用 Python 实现。

PCA 所做的是转换坐标系，使坐标轴成为我们整体数据的最简洁、信息最丰富的描述符。

上图摘自徐萌在 PCA 上的博客文章。我发现徐萌的解释非常有助于直观地理解这个概念。您在图(A)中看到的形状是三维的，但如果我们关注数据的形状，而不是轴，形状本身就是平面的二维表面。通过运行 PCA，我们为数据找到新的坐标，这将最好地描述数据是如何形成的。第一个主成分是解释数据中最大差异的成分。在图(B)中，我们看到通过绘制“组件 1”线，它能够保留最分散的数据点的信息。通过添加“成分 2”行，这条“成分 2”行解释了我们数据中的第二大差异。下一步是将原始数据转换到我们新发现的轴上，这个轴是二维的，而不是原来的三维。图(C)中的最终结果给了我们一个很好的画面，展示了即使我们已经放弃了第三维，数据是如何仅用二维来形成的。

并且在实现数据的这种变换时使用特征向量和特征值。特征向量指定通过原始坐标空间的方向，而特征值指示其对应特征向量方向上的变化量。

如果你想更深入地了解 PCA 的概念，还有一些我觉得有用的博客文章。

Victor Powell 的一篇博客文章:“主成分分析”(你可以操纵和摆弄二维或三维的数据点，这将极大地帮助你直观地理解主成分分析的作用)
George Dallas 的博客文章:《主成分分析 4 个假人:特征向量、特征值和降维》(他已经成功解释了这个概念，没有一个数学公式，难以置信)

接下来，让我们尝试用 PCA 降低 doc2vec 向量的维数。我们还可以将结果绘制在图表上，看看将特征的数量减少到一个较小的主成分集是否可行，以及给定数量的主成分可以解释多少关于原始特征的方差。

在上图中，红线代表累计解释方差，蓝线代表每个主成分的解释方差。通过看上面的图表，尽管红线不是完美的直线，但非常接近直线。这样好吗？不。这意味着每个主成分对方差解释的贡献几乎相等，基于主成分分析降低维度没有多大意义。这一点从蓝线也可以看出来，蓝线非常接近底部的一条直线。

有点令人失望的是，在我处理 tweets 文本数据的具体案例中，维数约减并没有太大的帮助。当首先使用 Tfidf 矢量器限制特征时，Tfidf 矢量显示出比随后降低维度更好的结果，并且 doc2vec 矢量似乎通过其 200 维特征空间携带大致相似的信息量。

同样，这不是一个普遍的说法，这只是我用我的特殊数据发现的。特别是主成分分析，当它应用于数字特征时，我看到它成功地将数据的维度从 100 个或更多的特征减少到大约 10 个特征，同时能够解释 90%的数据差异。

如果您对这篇文章的神经网络建模有所期待，很抱歉我不得不绕道而行，但在下一篇文章中，我肯定会进行神经网络建模。一如既往的感谢您的阅读。

您可以通过以下链接找到 Jupyter 笔记本:

https://github . com/tthustle a/Twitter _ 情操 _ 分析 _ part 8/blob/master/Capstone _ part 4-copy 6 . ipynb

另一个使用 Python 的 Twitter 情感分析——第 9 部分(使用 Keras 的 Tfidf 向量的神经网络)

原文：https://towardsdatascience.com/another-twitter-sentiment-analysis-with-python-part-9-neural-networks-with-tfidf-vectors-using-d0b4af6be6d7?source=collection_archive---------3-----------------------

Photo by Alina Grubnyak on Unsplash

这是我正在进行的推特情感分析项目的第 9 部分。你可以从下面的链接找到以前的帖子。

第一部分:数据清理
第二部分:EDA，数据可视化
第三部分:齐夫定律，数据可视化
第四部分:特征提取(计数矢量器)、N-gram、混淆矩阵
第 5 部分:特征提取(Tfidf 矢量器)、机器学习模型比较、词法方法
第 6 部分:Doc2Vec
第七部分:短语建模+ Doc2Vec
第八部分:降维(Chi2，PCA)

在前一篇文章中，在尝试神经网络建模之前，我走了一条实现降维的弯路。在这篇文章中，我将首先用 100，000 个特征的 Tfidf 向量实现神经网络，包括高达三元模型。

*除了我将附上的简短代码块，你可以在这篇文章的末尾找到整个 Jupyter 笔记本的链接。

人工神经网络

我的第一个想法是，如果逻辑回归是表现最好的分类器，那么这个想法可以扩展到神经网络。就其结构而言，逻辑回归可以被认为是一个没有隐含层，只有一个输出节点的神经网络。从下面的图片可以更清楚的看到这种关系。

我不会详细讲述神经网络是如何工作的，但是如果你想知道更多的细节，你可以看看我之前写的关于用 Python 从零开始实现神经网络的文章。但是对于这篇文章，我不会从头开始实现它，而是使用一个名为 Keras 的库。Keras 更像是一个包装器，可以运行在其他库之上，比如 Theano 或 TensorFlow。它是最易于使用的库之一，具有直观的语法和强大的功能。如果你像我一样是神经网络建模的新手，我认为 Keras 是一个很好的起点。

带 Tfidf 矢量器的人工神经网络

我得到的性能最好的 Tfidf 向量有 100，000 个特征，包括多达逻辑回归三元模型。验证准确率为 82.91%，而训练集准确率为 84.19%。我想看看神经网络是否能提高我现有的 Tfidf 向量的性能。

我将首先从加载所需的依赖项开始。为了使用 TensorFlow 后端运行 Keras，您需要安装 TensorFlow 和 Keras。

以下 NN 模型的结构在输入层中有 100，000 个节点，然后在应用了 Relu 激活函数的隐藏层中有 64 个节点，最后是应用了 sigmoid 激活函数的一个输出层。神经网络有不同类型的优化技术，您可以使用模型定义不同的损失函数。下面的模型使用 ADAM 优化，和二进制交叉熵损失。

ADAM 是一种优化算法，用于更新参数和最小化神经网络的成本，这被证明是非常有效的。它结合了两种优化方法:RMSProp 和 Momentum。同样，我将重点分享我从实现中获得的结果，但如果你想正确理解亚当是如何工作的，我强烈推荐吴恩达的“ deeplearning.ai ”课程。他用非常直观的方式解释了神经网络的复杂概念。如果您想要更多关于该主题的深入材料，还可以看看 Kingma & Ba (2014)的研究论文“ ADAM:一种随机优化的方法”。

在输入数据和训练模型之前，我还需要处理一件事。Keras NN 模型不能直接处理稀疏矩阵。数据必须是密集阵列或矩阵，但将 150 万个 Tfidf 向量的整个训练数据转换为密集阵列将无法容纳在我的 RAM 中。所以我必须定义一个函数，它生成 iterable generator 对象，这样它就可以输入到 NN 模型中。注意，输出应该是一个生成器类对象，而不是直接返回数组，这可以通过使用“yield”而不是“return”来实现。

看起来该模型在 2 个时期后具有最佳验证准确性，并且在此之后，它不能一般化，因此验证准确性缓慢降低，而训练准确性增加。但如果你还记得我从逻辑回归得到的结果(训练准确率:84.19%，验证准确率:82.91%)，你可以看到，上述神经网络在验证方面未能跑赢逻辑回归。

让我们看看归一化输入是否对性能有任何影响。

然后我重新定义了模型，用我从上面规格化器得到的“x_train_tfidf_norm”重新改装了模型。

结果几乎和没有标准化时一样。在这一点上，我意识到 Tfidf 已经通过它的计算方法归一化了。Tfidf 中的 TF(词频)不是绝对频率而是相对频率，通过将 idf(逆文档频率)乘以相对词频值，以跨文档的方式进一步归一化该值。

拒绝传统社会的人

如果模型的问题是一个糟糕的概括，那么我可以在模型中添加另一个东西。尽管神经网络是一个非常强大的模型，但有时过度适应训练数据可能是一个问题。辍学是一种解决这个问题的技术。如果你熟悉机器学习中的系综模型概念，辍学也可以看出一脉相承。根据 Hinton 等人(2012 年)的研究论文“通过防止特征检测器的共同适应来改善神经网络”“减少测试集误差的一个好方法是对大量不同网络产生的预测进行平均。做到这一点的标准方法是训练许多单独的网络，然后将这些网络中的每一个应用于测试数据，但是这在训练和测试期间都是计算昂贵的。随机退出使得在合理的时间内训练大量不同的网络成为可能。

Dropout 是模拟好像我们训练许多不同的网络，并通过在整个训练过程中以一定的概率随机省略隐藏节点来平均它们。使用 Keras，只需在模型架构中添加一行就可以轻松实现。让我们看看 20%的辍学率下模型性能如何变化。(*我将收集所有结果，并在最后以表格形式呈现。)

通过 5 个历元，训练集精度没有达到没有丢失的模型的精度，但是验证精度没有下降到与之前的模型一样低。尽管退出给模型增加了一些概括性，但与逻辑回归结果相比，验证准确性仍然表现不佳。

洗牌

我可以尝试另一种方法来防止过度拟合。通过为每个时期以相同的顺序呈现数据，模型有可能学习到也包括训练数据的噪声的参数，这最终导致过度拟合。这可以通过改变我们提供给模型的数据的顺序来改善。下面，我在批处理生成器函数中添加了洗牌功能，并尝试使用相同的模型结构，比较了结果。

具有非混洗训练数据的同一模型的训练准确率为 87.36%，验证准确率为 79.78%。改组后，训练准确率下降到 84.80%，但 5 个时期后的验证准确率增加到 82.61%。看起来洗牌确实提高了模型在验证集上的表现。我注意到的另一件事是，无论有无洗牌，无论有无掉线，验证准确性往往在 2 个时期后达到峰值，之后逐渐下降。

我还尝试了同样的模型，其中有 20%的数据丢失，这次只有 2 个时期，我将在最后分享结果。

学习率

当我在学习吴恩达的“ deeplearning.ai ”课程时，他表示，他试图改进神经网络模型的第一件事是调整学习速率。我决定听从他的建议，用这个模型尝试不同的学习速度。请注意，除了学习率之外，“β_ 1”、“β_ 2”和“ε”的参数设置为原始论文“ADAM:A Method for random Optimization”中的默认值，作者为 Kingma 和 Ba (2015)。

在尝试了四种不同的学习率(0.0005，0.005，0.01，0.1)之后，没有一个比默认的学习率 0.001 表现得更好。

增加节点数量

也许我可以尝试增加隐藏节点的数量，看看它对性能有什么影响。下面的模型在隐藏层有 128 个节点。

在 128 个隐节点的情况下，验证精度接近逻辑回归的性能。我可以通过增加隐藏层的数量做进一步的实验，但是要运行上面的 2 个时期，需要 5 个小时。考虑到逻辑回归用了不到一分钟的时间来拟合，即使神经网络可以进一步改进，这看起来也不是一种有效的方法。

下面是一个表格，列出了我从上面尝试不同模型得到的所有结果。请注意，我比较了 2 个时期的性能，因为有些模型只运行了 2 个时期。

除 ANN_8(学习率为 0.1)外，模型性能仅在小数部分有变化，最佳模型为 ANN_9(一个隐层 128 个节点)，验证准确率为 82.84%。

因此，在这种特殊情况下，神经网络模型未能胜过逻辑回归。这可能是由于文本数据的高维度和稀疏特性。我还找到一篇研究论文，比较了模型性能和高维数据。根据 Caruana 等人(2008 年)的“高维监督学习的经验评估”，逻辑回归显示出与神经网络一样好的性能，在某些情况下甚至优于神经网络。

通过以上所有的尝试，我学到了一些宝贵的经验。实现和调整神经网络是一个高度迭代的过程，包括许多试验和错误。尽管神经网络是逻辑回归的更复杂版本，但它并不总是优于逻辑回归，有时对于高维稀疏数据，逻辑回归可以以比神经网络少得多的计算时间提供良好的性能。

在下一篇文章中，我将使用从上一篇文章中获得的 Doc2Vec 向量实现一个神经网络。希望使用像 Doc2Vec 这样的密集向量，神经网络可能会有所提高。手指交叉。

一如既往的感谢您的阅读。你可以从下面的链接找到整个 Jupyter 笔记本。

https://github . com/tthustle sa/Twitter _ 情操 _ 分析 _ part 9/blob/master/Capstone _ part 4-copy 7 . ipynb

除了条形图之外的任何东西:条形图的 10 个最佳替代品

原文：https://towardsdatascience.com/anything-but-bars-the-10-best-alternatives-to-bar-graphs-fecb2aaee53a?source=collection_archive---------1-----------------------

如果你想展示一个对比，但又不能画出另一个条形图，该怎么办？

这个问题我不是随便问的。条形图或折线图可以说明绝大多数数据；他们是 dataviz 世界的两大主力。

但是说实话:一个接一个的条形图让厌烦。这时你就想有一两个备选方案。

这里有 10 个最好的方法来用条形图展示没有 T5 的比较。

为什么我们如此频繁地使用条形图

最常见的图表类型——折线图、条形图和饼图——之所以常见是有原因的。

每种图形类型都专门讲述一个特定类型的故事。线形图显示了随时间变化的趋势。饼状图(以及它们的甜甜圈兄弟)显示了整体的部分。当涉及到比较时，条形图真正闪耀。

条形图利用了人类判断距离的自然能力。我们很擅长确定哪种形状最长，以及最长多少。条形图通过用矩形代替数字来利用这种能力。

折线图、条形图和饼图很常见，因为它们是描述每种故事类型的最简单、最有效的方式。

场景:比较一个变量的值

我有时会参加由 Olga Tsubiks 领导的项目事业数据挑战，该项目让数据可视化人员处理非营利和事业驱动的数据。他们最近特别报道了环境署关于保护区的数据。因为我最近一直在处理数据，所以我想用它作为今天的例子。

该数据集覆盖了全球数十万个保护区，每个保护区都有详细的位置、面积、治理等信息。

像这样显示多方面数据的方法有很多，但今天我们保持简单。我们只是比较一下每个北美国家有多少被划入保护区。(为了便于计算，我忽略了跨越国界的海洋保护区和公园。)

我们的条形图非常简单:三个国家的三个数字。从占总面积的百分比来看，墨西哥似乎在北美留出了最多的土地，其次是美国和加拿大。

条形图完成了工作，但它可能更令人兴奋。让我们看看还能利用这些数据做些什么。

1.行图表

“等一下，”你可能会说，“这张图看起来非常熟悉。”

你是对的。条形图基本上是旋转了 90 度的条形图。但这并不完全是欺骗。这种微妙的变化可能会派上用场。

如果您的数据标签有点长，比如说您想拼出“美利坚合众国”，垂直条形图将很快用尽空间。Excel 通常将标签切换到垂直或对角线方向，但这两种方向都很难阅读。

行图表解决了这个问题，它提供了更多的布局灵活性，同时保持了条形图粗犷的外观和魅力(以及有效性)。如果您正在编写报告，您可以排列图表以匹配一列文本的宽度，而不占用太多垂直空间。

2.放射状柱形图

径向柱形图是一个自身卷曲的条形图。在左边的例子中，我加入了中美洲，让事情变得更有趣。(相关说明:干得好，危地马拉！)

与本文中的大多数其他图表不同，我在 Illustrator 中制作了这个径向柱形图。据我所知，Excel 里是没办法做出来的。

说实话，我对径向柱形图百感交集。一方面，它非常引人注目，可以很好地配合“达到我们的目标”的主题。另一方面，读者很难比较数值，因为没有两列是真正并排的。

为了帮助解决这个问题，我添加了标签和微弱的同心环。标签告诉读者精确的数值，而环帮助读者测量距离，就像 Excel 默认的条形图一样。

3.圆环图

啊，我们的老朋友甜甜圈图。不久前，我写了一篇关于环形图的文章，但要点是:环形图本质上是饼图和条形图的混合体。你读它就像一个条形图，但它有一个友好的，有空间意识的饼图形状。

你会注意到我这里用的是面积，而不是百分比。这是一排百分比的图表。这是表示数据的错误方式——您能看出为什么吗？

This donut chart is WRONG — please don’t do this!

这不仅仅是百分比加起来不到 100。如果你把数字分组，人们会认为它们所代表的事物属于同一类。

在横道图中，将百分比放在单独的行上可以清楚地看出每个数字代表了不同的 T4 国家的覆盖率。但是当我把这些百分比放到同一个饼状图中时，他们现在似乎说这些国家保护了同一块陆地的 17%、13%和 22%——完全不正确。

4.堆积横排图

如果你空间有限，也许是时候把你的鸭子排成一排了。堆叠横排图将数据排成一行，因此所有数据都在一条相对较窄的线上。把它想象成一个展平的圆环图——这就是为什么面积而不是百分比又回来了。

和圆环图一样，我们需要小心我们的暗示。堆积一行百分比会发出与第二个圆环图相同的不正确的信息。

5.泡泡图

在气泡图中，每个圆圈的面积反映了数字的大小——在这种情况下，是每个国家受保护土地的百分比。在之前，我已经讨论了使用圆形的挑战和潜在的陷阱，但是我知道，如果你正在寻找一种友好、引人注目的方式来表示数据，圆形仍然是很棒的。

我已经在上面的例子中排列了泡泡，但是你也可以根据你布局的需要将它们聚集成一个圆形或者其他形状。别忘了你的标签！当数值相对接近时(如上)，它们可以帮助读者进行精确的比较，从而化险为夷。

6.核标准情报中心

圈子很好玩，但是和手头的话题没有太大关系。在这里，我用树木代替了我们的泡泡来代表受保护的森林覆盖。

我喜欢对所有类别使用相同的图标，以帮助我的读者直接比较国家。如果美国有一个松果，萨尔瓦多有一片香蕉叶，每个图标的差异可能会掩盖不同的大小。简而言之:保持简单，让你的数据闪闪发光。

7.点阵

点阵对于突出整体的一部分非常有用。在上面的例子中，我们仅用它来说明美国的土地保护。整个矩阵代表所有美国土地，而橙色圆圈代表已被保护的部分。

像本文中的其他图表一样，您仍然需要注意如何组合您的数字。如果你想比较这三个国家，你可以把三个矩阵并排放在一起——但明显是分开的。如果他们走得太近，你可能会给你的读者错误的想法。

点阵也可以很好地组合多个类别——只要这样做有意义。

在上面的例子中，我重新计算了每个国家的保护区，这次是作为整个北美大陆的一部分。通过在同一个矩阵中为每个国家使用不同的颜色，我可以显示每个国家对整体的贡献。

8.象形图

象形图用图像取代了条形图中枯燥的矩形；在这种情况下，我们的老朋友森林。在我的图表中，每一个百分点都有一棵树，但是你总是可以以不同的方式缩放——一棵树可以代表 5%或 10 万平方公里，这取决于你对数据的需求。

9.Choropleth

choropleth 使用颜色饱和度来表示值；在上面的例子中，它是每个国家保护的土地的百分比。

标签对于 choropleth 地图来说非常重要，因为你的读者不能只盯着你的地图说“是的，那个橙色的阴影刚好占 17%。”颜色给你的读者一个关于价值的暗示，但是你仍然需要一个标签来完成这个想法。

我在 Illustrator 中制作了这些，但显然也可以使用插件在 Excel 中制作它们。这个教程好像知道怎么回事 —试一试请反馈！

10.那个大的旧号码

最后但并非最不重要的:大老的号码。如果你只有 1-2 个数字需要强调，简单地写出来也没什么不好。

记住:永远不要为了说明而说明；只有对你的读者有帮助的时候才这么做！

Excel、Word 和许多其他在线和离线工具可以为你冰冷的、硬邦邦的数据带来一点艺术性。

你最喜欢哪个条形图？我错过了哪些？

请在下面的评论中告诉我们！

原载于 2017 年 5 月 30 日hypsypops.com。

Apache Kafka 和 Apache Flume 入门(将数据导入 HDFS)

原文：https://towardsdatascience.com/apache-kafka-and-flume-installation-guide-import-data-from-kafka-to-hdfs-c908b0df034c?source=collection_archive---------5-----------------------

Image Source: www.kafka.apache.org

本文包含 Apache Kafka 安装、创建 Kafka 主题、发布和订阅主题消息的完整指南。此外，它还包含 Apache Flume 安装指南以及如何使用 Apache Flume 将 Kafka 主题消息导入 HDFS。

1.总说明

Hadoop 版本:3.1.0
阿帕奇卡夫卡版本:1.1.1
Apache Flume 版本:1.8.0
操作系统:Ubuntu 16.04
Java 版本:Java 8

2.先决条件

2.1.安装 Java

阿帕奇卡夫卡需要 Java。要确保安装了 Java，首先更新操作系统，然后尝试安装它:

sudo apt-get updatesudo apt-get upgradesudo add-apt-repository -y ppa:webupd8team/javasudo apt-get install oracle-java8-installer

2.2.安装动物园管理员

Apache Kafka 需要安装 Zookeeper 服务，因为它使用它来维护节点心跳、配置和选举领导者。

sudo apt-get install zookeeperd

默认情况下，zookeeper 使用端口 2181，安装后会自动运行。使用 telnet 命令检查 Zookeeper 是否正在运行:

telnet localhost 2181

当 telnet 提示符打开时，写下“你还好吗”命令:

ruok

如果一切正常，它将返回 imok 消息。

2.3.创建具有 sudo 权限的非超级用户帐户

因为 Kafka 是一个网络应用程序，它可能使用多个节点，所以最好创建一个具有 sudo 权限的服务用户。

sudo adduser — system — no-create-home — disabled-password — disabled-login kafkauser

3.安装和配置 Kafka 服务器

3.1.下载卡夫卡

首先，我们需要下载 Kafka 二进制包。

wget [http://www-eu.apache.org/dist/kafka/1.1.1/kafka_2.11-1.1.1.tgz](http://www-eu.apache.org/dist/kafka/1.1.1/kafka_2.11-1.1.1.tgz)

现在，我们需要提取 tgz 包。我们选择将 Kafka 安装在/opt/kafka 目录中:

sudo tar xvf kafka_2.11–1.1.1.tgz -–directory /opt/kafka -–strip 1

Kafka 将它的日志存储在磁盘上的/tmp 目录下，最好创建一个新的目录来存储日志

sudo mkdir /var/lib/kafkasudo mkdir /var/lib/kafka/data

3.2.配置 Kafka

现在，我们需要编辑 Kafka 服务器配置文件。

sudo gedit /opt/kafka/config/server.properties

默认情况下，Kafka 不允许我们删除主题。为了能够删除主题，找到并更改该行(如果没有找到，就添加它)。

delete.topic.enable = true

现在，我们需要更改日志目录:

log.dirs=/var/lib/kafka/data

此外，我们可以调整日志删除的时间间隔(Kafka 在特定时间后或根据磁盘大小删除日志):

log.retention.hours=168 # according to timelog.retention.bytes=104857600 # according to disk size

3.3.更改目录权限

我们需要在日志目录和 kafka 安装目录上授予 kafkauser 访问权限:

sudo chown –R kafkauser:nogroup /opt/kafkasudo chown –R kafkauser:nogroup /var/lib/kafka

3.4.开始卡夫卡

要启动 Apache Kafka 服务，可以使用以下命令:

sudo /opt/kafka/bin/kafka-server-start.sh /opt/kafka/ config/server.properties

如果服务器已经成功启动，您应该会看到以下输出:

[2018–07–23 21:43:48,279] WARN No meta.properties file under dir /var/lib/kafka/data/meta.properties (kafka.server.BrokerMetadataCheckpoint)[2018–07–23 21:43:48,516] INFO Kafka version : 0.10.0.1 (org.apache.kafka.common.utils.AppInfoParser)[2018–07–23 21:43:48,525] INFO Kafka commitId : a7a17cdec9eaa6c5 (org.apache.kafka.common.utils.AppInfoParser)[2018–07–23 21:43:48,527] INFO [Kafka Server 0], started (kafka.server.KafkaServer)[2018–07–23 21:43:48,555] INFO New leader is 0 (kafka.server.ZookeeperLeaderElector$LeaderChangeListener)

要将 Kafka 作为后台进程启动，可以使用 nohup 命令

sudo nohup /opt/kafka/bin/kafka-server-start.sh /opt/kafka/ config/server.properties /var/lib/kafka/data/kafka.log 2>&1 &

现在，您有一个 Kafka 服务器正在运行并监听端口 9092。

3.5.启动时将 Kafka 作为服务启动

首先，我们需要在/etc/systemd/system 中创建一个服务单元文件

sudo gedit /etc/systemd/system/kafka.service

卡夫卡.服务

[Unit]Description=High-available, distributed message brokerAfter=network.target[Service]User=kafkaExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties[Install]WantedBy=multi-user.target

此外，使用可以将日志转发到另一个文件，这样您系统日志就不会被占用

ExecStart=/opt/kafka/bin/kafka-server-start.sh /opt/kafka/config/server.properties > /opt/kafka/server.log

要启动创建的服务，请使用以下命令:

sudo systemctl start kafka.service

在操作系统启动时自动启动服务

sudo systemctl enable kafka.service

您可以使用以下命令检查您的服务状态:

sudo systemctl status kafka.service

3.6.使用卡夫卡主题

3.6.1.创造一个卡夫卡主题

要创建 Kafka 主题，我们必须使用 kafka-topics.sh 脚本文件，并且我们需要指定 zookeeper 地址、复制因子、分区因子和主题名称:

/opt/kafka/bin/kafka-topics.sh — create — zookeeper localhost:2181 — replication-factor 1 — partitions 1 — topic testKafka

3.6.2.列出可用主题

要列出所有主题，请使用以下命令:

/opt/kafka/bin/kafka-topics.sh — list — zookeeper localhost:2181

3.6.3.发布和订阅消息

要将消息发布到主题中，我们必须使用 kafka-console-producer.sh 脚本，并且我们必须指定 kafka 服务器地址和主题名称:

/opt/kafka/bin/kafka-console-producer.sh — broker-list localhost:9092 — topic testKafka

然后，我们需要打开另一个终端，并使用 kafka-console-consumer.sh 脚本创建一个订户。我们需要传递 Kafka 服务器地址和主题名称

/opt/kafka/bin/kafka-console-consumer.sh — bootstrap-server localhost:9092 — topic test — from-beginning

在第一个终端(生产者)中，输入任意消息(例如:Hello！！)它必须出现在第二个终端中。

3.6.4.将文本文件导入 Kafka 主题

要在 Kafka 主题中打开一个文本文件，您需要使用带有管道的 cat 命令:

cat filename.txt | /opt/kafka/bin/kafka-console-producer.sh — broker-list localhost:9092 — topic testKafka

3.7.Kafka 多节点集群

此外，我们可以在多个节点上运行它，以实现数据冗余和意外故障转移。假设我们有 3 个节点:

我们需要遵循我们之前提到的相同步骤，并添加一些内容:

1.在/opt/Kafka/config/server . properties 中:

a.每个节点必须有一个唯一的 broker.id 属性

for node-2 broker.id=1for node-3 broker.id=2

b.更改 zookeeper.connect 的值，使其列出所有带有端口的 zookeeper 主机

zookeeper.connect=10.0.1.1:2181,10.0.1.2:2181,10.0.1.3:2181

2.我们必须改变动物园管理员的设置。使用编辑器 sudo gedit/etc/zookeeper/conf/zoo . CFG 打开 zoo.cfg 文件，并添加以下几行:

server.0=10.0.1.1:2888:3888server.1=10.0.1.2:2888:3888server.2=10.0.1.3:2888:3888

3.重新启动 Zookeeper 服务

sudo systemctl restart zookeeper.service

4.安装和配置 Apache Flume

要从 Kafka 主题中读取消息并存储到 HDFS 中，我们需要安装 Apache Flume。该应用程序用于将非结构化和半结构化数据存储到 HDFS 中。

4.1.下载水槽

首先，我们需要下载 apache flume 二进制包

wget “http://www-eu.apache.org/dist/flume/1.8.0/apache_flume-1.8.0-bin.tar.gz"

现在我们需要提取。gz 包。我们选择将 Kafka 安装在/opt/kafka 目录中:

sudo tar -xvf apache_flume-1.8.0-bin.tar.gz –-directory /opt/flume –-strip 1

4.2.配置水槽

您需要编辑“/etc/profile”、 ~/。bashrc" 文件并添加以下几行

export FLUME_HOME= /opt/flumeexport PATH=$PATH:$FLUME_HOME/bin/

要应用这些更改，请使用 source ~/。巴沙尔司令部。

完成后，flume 代理会自动启动。要确保 flume 安装成功，您可以运行以下命令:

flume-ng –help

要将数据导入 HDFS，首先我们需要在您的主目录中创建一个日志文件。

gedit ~/access.log

写入任何数据并保存。

在/opt/flume/conf 中创建一个文件 "flume.conf" 文件，并将以下数据写入其中:

flume1.sources = kafka-source-1flume1.channels = hdfs-channel-1flume1.sinks = hdfs-sink-1flume1.sources.kafka-source-1.type = org.apache.flume.source.kafka.KafkaSourceflume1.sources.kafka-source-1.zookeeperConnect = localhost:2181flume1.sources.kafka-source-1.topic = testKafkaflume1.sources.kafka-source-1.batchSize = 100flume1.sources.kafka-source-1.channels = hdfs-channel-1flume1.channels.hdfs-channel-1.type = memoryflume1.sinks.hdfs-sink-1.channel = hdfs-channel-1flume1.sinks.hdfs-sink-1.type = hdfsflume1.sinks.hdfs-sink-1.hdfs.writeFormat = Textflume1.sinks.hdfs-sink-1.hdfs.fileType = DataStreamflume1.sinks.hdfs-sink-1.hdfs.filePrefix = test-eventsflume1.sinks.hdfs-sink-1.hdfs.useLocalTimeStamp = trueflume1.sinks.hdfs-sink-1.hdfs.path = /data/kafka/%{topic}/%y-%m-%dflume1.sinks.hdfs-sink-1.hdfs.rollCount=100flume1.sinks.hdfs-sink-1.hdfs.rollSize=0flume1.channels.hdfs-channel-1.capacity = 10000flume1.channels.hdfs-channel-1.transactionCapacity = 1000

请注意，flume1 是 flume 代理名称。

下面，一些参数描述:

现在，您需要运行 flume 代理从 Kafka 主题中读取数据，并将其写入 HDFS。

flume-ng agent -n flume1 -c conf -f flume.conf — Dflume.root.logger=INFO,console

注意:代理名称由-n FileAgent 指定，并且必须与-f conf/flume.conf 中给出的代理名称相匹配

数据现在将通过以下路径转储到 HDFS 位置

/tmp/kafka/%{topic}/%y-%m-%d

%{topic} > >卡夫卡题目名称

%y-%m-%d >

5.参考

[1]“阿帕奇卡夫卡官方文档”，阿帕奇，[在线]。可用:http://kafka.apache.org。【访问日期 2018 年 07 月 15 日】。

[2]“Apache Flume 官方文档”，Apache，[在线]。可用:http://flume.apache.org。【访问时间 2018 年 07 月 20 日】。

[3] Sarad，“如何在 Ubuntu 16.04 上安装 Kafka”，Hevo，2017 年 8 月 20 日。【在线】。可用:【https://hevodata.com/blog/how-to-install-kafka-on-ubuntu. 【2018 年 06 月 30 日获取】。

[4]“15 分钟内完成 Kafka 设置”，ETL-Tools，[在线]。可用:http://ETL-tools . info/en/examples/Kafka-setup-in-15-minutes . htm .【25 07 2018 访问】。

[5] hitjethva，“在 Ubuntu 16.04 上安装和配置 Apache Kafka”，DevOps，2016 年 10 月 3 日。【在线】。可用:https://devo PS . profit bricks . com/tutorials/install-and-configure-Apache-Kafka-on-Ubuntu-1604-1/。【访问时间 2018 年 07 月 15 日】。

[6] M. Litwintschik，“Hadoop 3 单节点安装指南”，2018 年 3 月 19 日。【在线】。可用:http://www . tech . marksblogg . com/Hadoop-3-single-node-install-guide . html【2018 年 10 月 06 日访问】。

[7]“栈溢出问答”，栈溢出，[在线]。可用:https://www.Stackoverflow.com。

[8] Gwen Shapira 和 Jeff Holoman，“Flafka: Apache Flume 遇到 Apache Kafka 进行事件处理”，Cloudera，2014 年 11 月 6 日。【在线】。可用:http://blog . cloud era . com/blog/2014/11/flafka-Apache-flume-meets-Apache-Kafka-for-event-processing/。【访问日期 2018 年 06 月 15 日】。

[9] S. Team，“Apache Flume 安装教程—初学者指南”，Data Flair，2016 年 8 月 22 日。【在线】。可用:https://data-flair . training/blogs/Apache-flume-installation-tutorial。【访问日期 2018 年 06 月 20 日】。

Apache Spark 的 n00bs 指南

原文：https://towardsdatascience.com/apache-spark-101-3f961c89b8c5?source=collection_archive---------1-----------------------

我写这篇指南是为了帮助我理解 Spark 的基本底层功能，它在 Hadoop 生态系统中的位置，以及它如何在 Java 和 Scala 中工作。我希望它能像帮助我一样帮助你。

什么是火花？

Spark 是一个通用计算引擎，在内存框架中。它允许您以脚本方式在各种语言中执行实时和批处理工作，具有强大的容错能力。你为什么要关心火花是什么？坦率地说，它解决了 Hadoop MapReduce 的许多缺点，比 Hadoop MapReduce 快 10 到 100 倍。 Spark 是数据科学的大事；使用 Spark 的一些著名组织有:亚马逊、NASA 喷气推进实验室、IBM 和日立。这篇文章的目标是给你一个关于 Spark 提供的功能，它的基本内部工作的快速概述，并让你对 Spark 有多棒有所了解。

激发大数据环境中的背景

Spark 被设计为与外部集群管理器或它自己的独立管理器一起工作。Spark 也依赖于分布式存储系统来运行，它从该系统中调用它想要使用的数据。支持以下系统:

集群管理器:

Spark 独立管理器
Hadoop 纱线
阿帕奇 Mesos

分布式存储系统:

Hadoop 分布式文件系统(HDFS)
MapR 文件系统(MapR-FS)
卡桑德拉
OpenStack Swift
亚马逊 S3
条纹羚

出于健康的原因，我将只关注 Hadoop 生态系统环境中的 Spark。

Spark Core 提供了一个平台，解决了 Hadoop MapReduce 的许多缺点，因为它允许我们不再需要将任务分解为小的 atom 作业，也不再需要与在分布式系统开发上构建解决方案的复杂性进行争论。

赛门铁克注: 术语 Hadoop 可互换使用，指 Hadoop 生态系统或 Hadoop MapReduce 或 Hadoop HDFS 。在网上看到“Spark 取代 Hadoop”或“Spark 是新的 Hadoop”的说法是很常见的，然后倾向于相信他们的意思是 Spark 正在取代所有的 Hadoop 服务，但是！他们真正的意思是，Spark 正在许多用例中扮演 Hadoop MapReduce 功能的角色。

Spark Core 非常通用，在设计时就考虑到了 Hadoop 生态系统；它可以与 MapReduce 一起工作，或者为 PIG、HIVE 和 SEARCH 提供一个替代平台。参见图 1

Spark Core 还带来了自己的一套有用的 API:

Spark Streaming: 管理来自各种来源的实时数据。它允许通过在实时流上实现 ML Lib 和 Graphx 来计算实时结果。

GraphX: 一个非常强大的处理图形并行计算的库。不要把这个和“Power Point graphs”混淆，这个库是关于数学中的一个领域，叫做图论和对象间成对关系的建模。

ML Lib: 在原生分布式环境中对大型数据集运行机器学习算法的库。与 Python 或 Matlab 中更强大的机器学习库相比，该库仍处于起步阶段。

Spark SQL: 允许使用 SQL 采石场来挖掘非关系分布式数据库。

Spark Steaming、GraphX、MLLib 和 Spark SQL 都将在适当的时候获得自己的文章，但与此同时，请不要犹豫，去查阅官方文档【1】【2】【3】【4】。

什么会产生火花，火花？

在最高的抽象层次上，Spark 由三个组件组成，这三个组件使它成为唯一的 Spark；司机、执行者和 DAG。

司机和执行者

Spark 采用主从架构。驱动程序协调许多分布式工作器，以便以分布式方式执行任务，而资源管理器处理资源分配以完成任务。

驾驶员

把它想象成“管弦乐队”。驱动程序是主方法运行的地方。它将程序转换成任务，然后将任务调度给执行器。司机有三种不同的方式与执行者沟通；Broadcast、Take、DAG——这些稍后会详细说明。

执行者——“工人”

执行器在 JVM 实例中执行驱动程序委派的任务。执行器在 Spark 应用程序开始时启动，通常在应用程序的整个生命周期内运行。这种方法允许在应用程序的整个生命周期中，当不同的任务被载入和执行时，数据被持久化在内存中。

与此形成鲜明对比的是，Hadoop MapReduce 中的 JVM 工作环境会针对每个任务关闭和打开。其结果是，Hadoop 必须在每个任务的开始和结束时对磁盘执行读写操作。

驱动程序与执行器的通信

驱动程序可以通过几种方法与执行器通信。作为开发人员或数据科学家，了解不同类型的通信及其用例非常重要。

广播动作:驱动程序将必要的数据传输给每个执行器。此操作最适用于一百万条记录以下的数据集，即+/-1gb 的数据。这项行动可能会成为一项非常昂贵的任务。
采取行动:驱动程序从所有执行者那里获取数据。这个动作可能是非常昂贵和危险的动作，因为驱动程序可能耗尽存储器，并且网络可能变得不堪重负。
DAG 动作:这是三个动作中花费最少的一个。它将控制流逻辑从驱动程序传输到执行器。

系统要求

Spark 比 Hadoop MapReduce 有相当大的性能增益，但它也有较高的操作成本，因为它在内存中操作，并需要高带宽网络环境(建议+10Gb/s)。建议 Spark 集群中的内存至少应与您需要处理的数据量一样大。如果没有足够的内存来完成一项任务，Spark 有几种方法可以将数据溢出到磁盘上。了解更多硬件要求和建议。

达格

DAG 是一个有向无环图，它概括了从 A 点到 b 点所需的一系列步骤。Hadoop MapReduce 与大多数其他计算引擎一样，独立于 DAG 工作。这些独立于 DAG 的计算引擎依赖于 HIVE 或 PIG 等脚本平台将作业链接在一起，以实现所需的结果。Spark 在比较中的强大之处在于它能够识别 DAG 并主动管理 DAG。这使得 Spark 能够优化作业流以获得最佳性能，并允许回滚和作业冗余功能。

请看图 3。我将通过讨论 DAG 的组件来详细说明它是如何工作的。

1)来源

数据源可以是 Spark 支持的任何数据源。其中包括:HDFS、关系数据库、CSV 文件等。稍后您将看到，我们在环境上下文设置中对此进行了定义。

2) RDD

弹性分布式数据集本质上是不能改变的数据集。这些实体存在于记忆中，并且本质上是不可改变的。由于这种不变性；在现有 RDD 上执行每次转换后，都会创建一个新的 RDD。这种设计的结果是冗余；如果在 DAGs 执行中的任何一点出现故障，则可以回滚到正常工作状态，并重新尝试失败的操作/转换。

原始形式的 rdd 没有模式，但是可以使用一种叫做 DataFrames 的东西来扩展。DataFrames 向其中包含的数据集添加模式功能；这在处理关系数据集时非常有用。

3)转型

转变把一个 RDD 变成了另一个 RDD。一些示例转换包括:

地图
reduceByKey
GroupByKey
JoinByKey
SparkSQL

4)行动

动作是检索数据以回答问题的任何东西。一些例子是:数一数，各取所需。

执行 DAG
Spark 做了一件叫做懒惰评估的事情。DAG 本身是由转换构建的，但是在调用动作之前什么也不会发生。当一个动作被执行时，Spark 将查看 DAG，然后在它需要执行什么工作来达到它被要求做的动作步骤的上下文中优化它。当 DAG 最终被执行时，驱动程序向集群上的执行器发出转换命令。

阿帕奇水槽 API

Apache Flume 的开发理念是允许开发人员使用适用于非分布式编程的相同代码创建可以在分布式系统上运行的程序。换句话说，Apache Flume 允许我们编写可以在单线程和多线程机器上运行的代码，没有任何问题。Apache Flume 的含义是，我们现在可以在本地机器上运行代码并进行调试，同时确保它可以在我们的 Spark Hadoop 集群上运行。更进一步的含义是，您可以从集群中提取数据，并在本地机器上运行它，以进行测试和开发。

支持以下语言:

斯卡拉
Java 语言(一种计算机语言，尤用于创建网站)
计算机编程语言
稀有

为了演示 Spark 的一些内部工作方式，我将在 ScalaFlume 和 JavaFlume 中运行一个字数统计示例。

在 Scala 中

第 1 到 2 行初始化我们的 Spark 上下文并定义我们的源。在第 3 行，我们定义了初始 RDD。在第 4 到 6 行中，我们定义了我们的 RDD 的转换，并定义了一些新的 RDDS。注意第 7 行，没有代码被执行；只有我们的达格人建立起来了。在第 7 行，我们终于有了一个执行转换的动作。值得注意的是，分布在集群中的唯一工作是蓝色的，因为那些 lambda 表达式是由执行程序运行的转换！其他一切都在驱动程序上执行。

Scala 宣传侧记: Scala 是一种构建在 JVM 编译器之上的令人惊叹的语言。它为具有 OOP 背景的开发人员提供了一个环境，使他们能够轻松地适应函数式编程思维，这是分布式计算编程的最佳选择。Scala 通过同时支持面向对象和函数式编程范例来做到这一点。你为什么要在乎？Spark 是使用 Scala 构建的，因此 Spark 中的最新特性将总是首先在 Scala 中实现。与其他语言相比，Scala 在处理大型数据集时也提供了最好的性能——举个例子:Scala 大约比 Python 快 10 到 225 倍，这取决于用例。Scala 也被数据科学和分布式计算领域的一些大公司使用，比如亚马逊和谷歌。我希望这段宣传已经说服了你，至少给 Scala 一个好奇的眼神。

在 JAVA 中

蓝色突出显示的代码是转换并构建 DAG。更重要的是，注意本质上每个转换都是一个对象，然后被发送到所有的分布式执行器。这也发生在 Scala 示例中，但是 lambda 表达式隐藏了这一层交互。在驱动程序执行第 27 行中的动作代码(用红色突出显示)之前，集群中的执行器不会执行转换对象。

结论

最后，我希望这篇文章能够帮助您理解 Spark 成为如此有趣和强大的数据科学和数据工程平台的基础。

这篇文章的要点应该是:

Spark Core 可以与 Hadoop MapReduce 并行工作，或者取代它。
Spark 比其他计算引擎快！火花速度来自于这样一个事实，即认知的 DAG，并可以优化它；它通过在整个作业中保持 JVM 状态，将数据保存在内存中，最终目标是最小化对磁盘的 I/O。
Spark 有一些很棒的数据科学和数据工程 API，用于机器学习、图论、数据流和 SQL。
Spark 中需要认知的主要组件是驱动程序和执行程序。这两个组件通过由 Spark 直接管理的 DAG 进行操作。有一种称为转换的东西，它构建 DAG 并从现有的 RDD 生成新的 RDD。RDD 是一个不可变的数据实体，它提供:借助 DAG 实现冗余和回滚功能。DAG 仅在动作被执行后才被执行。
Apache Flume 允许您在本地机器上用少数几种成熟的编程语言编写程序，用于开发和调试目的。同样的 Apache Flume 代码可以部署到一个分布式系统中，不需要任何修改。Scala 太棒了。

文献学

面向 Java 和 Scala 开发人员的 Apache Spark 简介— Ted Malaska (Cloudera)
什么是阿帕奇 Spark？
官方文件

Apache Spark:哈希还是字典？

原文：https://towardsdatascience.com/apache-spark-hashing-or-dictionary-d23c0e046a19?source=collection_archive---------2-----------------------

作为构建推荐系统的一部分，我最近不得不计算大量数据中的文本相似度。如果你对 Spark 的一个字符串相似性算法感兴趣，可以看看。

本文的结构。

实验背后的动机。
TF-IDF 的 Spark 实现及其重要性。
比较和结论。

动机

这不是我的问题陈述，但为了简单起见，让我们假设你有两列这样的单词，我们必须匹配它们。

List A       | List B
---------------------
GOOGLE INC.  | Google
MEDIUM.COM   | Medium Inc
Amazon labs  | Amazon
Google, inc  | Yahoo

在这个例子中，我们的目标是将 GOOGLE INC .和 GOOGLE，INC .匹配到 GOOGLE；并使 MEDIUM.COM 与媒体公司相匹配；以及亚马逊实验室到亚马逊等。

最简单的方法之一是计算这个单词列表的 TF-IDF 分数，并创建一个这样的矩阵。

该矩阵基本上具有 TF-IDF 得分，行和列元素为“GOOGLE”、“MEDIUM”。com '，'亚马逊实验室'，'谷歌'，'雅虎'，' COM '按顺序。我只是加了‘com’来展示 IDF 有多牛逼。如果一个术语在语料库中出现多次，那么它对于该特定文档就变得不太重要。添加了虚构的公司“com ”,因此“Medium.com”中的“Medium”变得更加重要。

如果 sklearn 行就能搞定这个，为什么还要用 spark？嗯，我的输入文件有 660 万行，正如你所猜测的，我的 Mac 真的不能处理这些。

我们找到动机了。让我们点燃激情。

Spark 和 TF-IDF

Spark 附带的一个示例脚本是针对文档集的 TF-IDF 的实现。这当然使事情变得更容易，因为只需要一点点的预处理，我就可以开始了。

由于我不能在这里展示机密数据的解决方案，我将只处理这个例子这里给出的微小数据。

如果您查看第一个表，它是应用标准 TF-TDF 脚本的结果，通过简单的分析，您可以将单词列中的单词映射到特征列中的值。比如‘我’大概 29。

这个方法在我的情况下完全没有用。我有大约 200 万个不同的单词，却没有办法将这些值映射回单词。😦

为什么？Spark 在这里，使用的是一个哈希函数。哈希函数利用了哈希技巧。通过应用散列函数将原始特征映射到索引(术语)中。这里使用的哈希函数是 MurmurHash 3。然后基于映射的索引计算术语频率。

虽然这种方法避免了计算全局术语-索引映射的需要，这对于大型语料库来说可能是昂贵的，但是它遭受潜在的哈希冲突，其中不同的原始特征在哈希之后可能变成相同的术语。😕

必须找到一种方法来检索单词到值的映射。解决方案？计数矢量器。

在上图中，第二个表是使用 countvectorizer 对数据进行令牌化并获得 TF 而不是散列函数的结果。“词汇表”存储所有不同的单词，它们的索引是值。是的。😃

比较和结论

但是等等。

这是哈希函数和字典之间的一个古老的权衡。在什么情况下哈希函数会更好？为什么 Spark 有 2 个版本计算 TF-IDF？

再来看存储:

HashingTF 需要固定大小的存储，与词汇表的大小无关。CountVectorizer 需要与词汇表大小成比例的存储空间。实际上，计数通常需要额外的特征选择。

转型呢？

HashingTF 只需要对数据进行一次扫描，不需要额外的存储和转换。CountVectorizer 必须扫描数据两次(一次用于构建模型，一次用于转换)，需要与唯一标记数量成比例的额外空间和昂贵的排序。

显然，这两种实现各有优缺点。这就是我的结论。如果 TF-IDF 只是另一个需要数字特征的算法的预处理步骤，那么与 CountVectorizer 相比，HashingTF 的工作速度更快，内存效率更高。由于我当前的模块仅仅停留在计算单词的相似性，我需要知道反向映射和 CountVectorizer 似乎更合适。😃

感谢阅读！

PS:这篇论文让我对特性散列有了很好的了解，可能值得一读。

苹果也想让你的手机看到

原文：https://towardsdatascience.com/apple-wants-your-phone-to-see-too-1497f244042b?source=collection_archive---------9-----------------------

在谷歌的 I/O 事件之后，我写道谷歌希望你的手机看到。当然，在 WWDC，苹果也为 iOS 应用程序推出了令人兴奋的新机器学习驱动功能。

苹果为开发者提供了一些不同可定制级别的框架，实现难度越来越大。

Vision and NLP purpose-built frameworks and CoreML for all kinds of other use cases, and you can build anything you want with the ‘ML Performance Primitives’

无论视觉材料是照片还是视频，Vision framework 都非常擅长查看，这包括人脸识别和对象跟踪，NLP(自然语言处理)有助于从话语或文本中提取意思。

CoreML 可以帮助应用程序做所有你期望的事情，包括识别声音剪辑和图片中发生的事情。

这一切都很酷，但这并不新鲜——其他系统已经有了。这里很酷的一点是，这些技术都是关于在设备上运行的，而且启动并运行起来非常容易。

在设备上更好，因为你不通过网络发送数据进行处理，这意味着你保留了你正在处理的内容的隐私，没有相关的数据成本，即使你没有网络覆盖，也可以使用。如果你关注这些东西，你应该听说过为 HBO 的硅谷开发的而非热狗应用。该过程中的一个重要经验是决定在设备上运行分类器，以获得准确性、性能和经济性。

Not Hotdog 博客文章还解释了在设备上运行 TensorFlow 模型的一些困难。这需要一些时间，而且没有很好的例子，他们直接与 TensorFlow 团队一起工作以获得使其工作的技巧。CoreML 更多的是关于在设备上运行，它主要是关于易用性。易用性是…另一回事。

在 WWDC 的 CoreML 演示中，苹果澄清了任务声明:

“CoreML 旨在尽可能轻松地将机器学习模型集成到您的应用程序中。”

有一种新的描述模型的公共格式，并且有新的工具可以将现有的经过训练的模型转换成这种格式。

The model gets compiled into your app, so it’s bundled right onto the device

花

一旦到了那里，演示表明你可以教一个应用程序通过拖动模型并编写 3 行代码来识别图片中的花的类型。真的就这么简单。

苹果公司强调，他们设计这种模式的目的是为了让 Xcode 开发中的其他一切工作起来完全一样，这样工程师就不需要新的技能来利用这些模式。

Literally drag and drop

访问分类器遵循现有的模式，提前输入建议有助于实现。

Converted to an MLmodel type, Xcode can compile the classifier to Swift generated source

应用该模型就像直接将图像作为输入传递给它一样简单。

The Classifier has a prediction output

您可以从模型的预测中访问“flowerType”字符串。对于演示来说，最简单的事情就是将它作为一个标签。

See the available attributes of the prediction

你就完了。

With just that, choosing a picture results in the model predicting the type of flower and changing the caption

不是花呢？

显然，弄清楚你正在看的是哪种花是一个利基用例——尽管这确实是在大约一个月前的一次家庭公园散步中出现的——但应用程序开发人员可以轻松地在应用程序中使用机器学习模型才是重点。

Some functions Apple suggests for this capability

有很多方法可以使用这些模型。应用程序可以为社交分享提供预测标记，以确保你的朋友——以及未来的你——可以找到你发布的他们最感兴趣的内容。使用带铅笔的 iPad Pro，应用程序可以像对待打字文本一样对待手写输入。表情符号建议是一个巨大的机会，我对此特别兴奋。

虽然所有这些事情听起来很有趣，但这也是一件严肃的事情。金融科技的应用可能是无穷无尽的，但一些基本的用例包括:

上传前，在捕获时识别文档类型；确认客户提供了正确的文件，没有来回
客户服务情绪响应度；对心烦意乱的客户和好奇的人做出不同的回应
优化建议；基于最佳实践或以前的客户端行为，预测设置和输入

今后

苹果向前迈出了一大步，让开发者能够轻松地将这些功能融入他们的应用。与所有事情一样，我们应该期待看到一些简单的用例几乎立即出现。这些大多不会去任何地方，这很好！公司会进行试验，但并不是所有的试验都会成功。

在此之后，我们应该期待下一代体验——无论是第一次体验的迭代，还是需要更长时间才能推向市场的新体验——开始发挥作用。

一如既往，问题是:现在有什么是可能的，而以前没有？

应用假设检验和 Spearman 等级相关系数揭示世界范围内的自杀现象

原文：https://towardsdatascience.com/application-of-hypothesis-testing-and-spearmans-rank-correlation-coefficient-to-demystify-b3a554730c91?source=collection_archive---------8-----------------------

介绍

背景: 据世界卫生组织(世卫组织)统计，全球每年约有一百万人自杀，每年死亡率为 11.6/10 万人。每年有如此多的人自杀，这是一个令人震惊的事实。你可以想象每 40 秒就有一个人自杀，据估计，到 2020 年，每 20 秒就有一个人死于自杀。
我们可以使用数据分析来研究全球自杀数据，并使用统计技术量化我们的结果。这将有助于我们了解世界各地发生的自杀事件。

本研究的目的 :
展示统计方法在现实世界问题中的应用，以发现我们在对数据集进行初步分析后所做的假设是否具有统计学意义。

在这里，我们将解释和应用两个众所周知的统计技术。假设检验
2。斯皮尔曼等级相关系数

这些统计实验的结果将为我们分析一组数据后所做的假设提供具体的证明。

什么是假设检验？

《牛津词典》将假设的含义定义为“在有限证据的基础上做出的假设或提出的解释，作为进一步研究的起点”

假设检验，也称为验证性数据分析是一种通过统计证据来确定我们假设的假设是真还是假的技术。
例如，我们可以获取两家不同公司生产的相同/相似产品的价格数据集，并想知道一家公司的产品是否比另一家贵。
我们的目的可以通过假设检验来实现。

Flowchart for Hypothesis Testing

零假设 是我们在测试开始时做出的默认假设。就像，两组数据之间没有显著差异。 交替假设 是这种假设的对立面。

检验统计量 是两组数据之间的均值、中值、标准差等的差异，这是我们从两组数据中抽取样本并计算检验统计量后实际观察到的。

决定 样本大小 是一个非常重要的因素，因为测试统计值会根据样本大小而不同。样本量越大，结果就越准确。

显著性水平或阿尔法 是概率的阈值，我们根据它来决定是接受还是拒绝我们的零假设。默认情况下，取 5%或 0.05。如果需要非常高的精确度，您可以降低它。

P 值 是通过重采样和排列测试
计算出来的，下面的插图会让事情更清楚****

Re-Sampling illustration 1

Re-Sampling illustration 2

Re-Sampling illustration 3

下一步是对我们从 K 次重采样中得到的均值差的数据列表进行升序排序。k 可以是 100，1000 或任何我们认为合适的数字。

Calculation of P-Value

所以，p 值是我们测试统计的百分位数(delta)，小于 100%。如果 delta 位于第 90 百分位，则 p 值为 10%或 0.10。

做出最终决定

我们说，p 值是假设我们的零假设为真，观察到δ的概率。

因此，如果我们的假设实际上是真的，观察到我们在进行实验时实际观察到的结果的概率(delta)将会很高。“高”的意思不仅仅是显著性水平。

如果 p 值低于显著性水平，这意味着在零假设为真的情况下，我们实际观察的发生概率较低。

由此，我们可以说:
——当 p 值≥显著性水平时接受零假设。
-如果 p 值<显著性水平，拒绝零假设并接受替代假设。

自杀率数据集

数据集来源:https://www . ka ggle . com/russellyates 88/自杀率-概览-1985 年至 2016 年

** [## 1985 年至 2016 年自杀率概览

按年份和国家将社会经济信息与自杀率进行比较

www.kaggle.com](https://www.kaggle.com/russellyates88/suicide-rates-overview-1985-to-2016)

在这项研究中，我使用了 python 库:Numpy、Pandas、Matplotlib、Seaborn 和 scikit-learn。让我向您展示我是如何对这个数据集进行探索性数据分析和假设检验的。

正在加载。csv 文件转换成熊猫数据帧

#Importing python libraries 
import numpy as np
import pandas as pd
import seaborn as sb
import matplotlib.pyplot as mp
#Loading csv file into pandas dataframe
SuicideData= pd.read_csv('master.csv')
SuicideData.head()

数据集的初步分析

print(SuicideData.shape)
print(SuicideData.columns)

There are 27820 Data points(Rows) and 12 Columns. Also showing column names for future reference

print(SuicideData.age.value_counts())

The data set has 6 age groups

SuicideData['suicides/100k pop'].mean()

Mean Suicide rate/100k persons on the whole population

上述结果并不准确，但非常接近世卫组织公布的数字 11.6。这可能是因为我们的数据样本较少。
我们进一步挖掘数据，根据性别和年龄组进行分析。下面是代码片段和结果:

#DIVIDING BY GENDER
M=SuicideData[SuicideData.sex=='male']
F=SuicideData[SuicideData.sex=='female']print('TOTAL MALE POPULATION = ',M.population.sum())
print('TOTAL MALE SUICIDES = ',M.suicides_no.sum())
print('AVERAGE MALE SUICIDES per 100k Population = ',M['suicides/100k pop'].mean())
print('TOTAL FEMALE POPULATION = ',F.population.sum())
print('TOTAL FEMALE SUICIDES = ',F.suicides_no.sum())
print('AVERAGE FEMALE SUICIDES per 100k Population = ',F['suicides/100k pop'].mean())print('\nAVERAGE SUICIDE RATES BY AGE GROUP')
print(SuicideData.groupby(['age'])['suicides/100k pop'].mean())print('\nAVERAGE SUICIDE RATES OF MALES BY AGE GROUP')
print(M.groupby(['age'])['suicides/100k pop'].mean())print('\nAVERAGE SUICIDE RATES OF FEMALES BY AGE GROUP')
print(F.groupby(['age'])['suicides/100k pop'].mean())print("\nSUICIDE RATE RATIO of FEMALE:MALE = 1 :",(M['suicides/100k pop'].mean()) / (F['suicides/100k pop'].mean()))

箱线图——男性与女性的自杀率

sb.boxplot(x='sex',y='suicides/100k pop', data=SuicideData)
mp.show()

小提琴情节——男性与女性自杀率对比

sb.violinplot(x='sex',y='suicides/100k pop', data=SuicideData)
mp.show()

根据年龄组显示自杀率——箱线图

sb.boxplot(x='age',y='suicides/100k pop', data=SuicideData)
mp.show()

75+ years age group is most Suicidal

初步分析的观察结果

男性自杀人数和自杀率都远高于女性。女性:男性= 1 : 3.75
即使我们按照年龄组来研究他们，结果也是一样的。
一个惊人的事实是，75 岁以上年龄组的人自杀倾向最强，无论性别如何。
5-14 岁年龄组自杀倾向最小，这很正常。

问题:哪个国家的自杀倾向最强？

我们将找到答案，并使用假设检验对其进行量化。按国家分组后，计算自杀率的平均值和中位数，并对结果进行排序。这将使我们成为自杀率最高的国家。

suicide_mean_by_country=pd.DataFrame(SuicideData.groupby(['country'])['suicides/100k pop'].mean())
suicide_mean_by_country = suicide_mean_by_country.sort_values(by='suicides/100k pop', ascending=False)
suicide_mean_by_country

Ranking by Mean Suicide Rates

suicide_median_by_country=pd.DataFrame(SuicideData.groupby(['country'])['suicides/100k pop'].quantile(0.5))
suicide_median_by_country = suicide_median_by_country.sort_values(by='suicides/100k pop', ascending=False)
suicide_median_by_country

Ranking by Median Suicide Rates

我们观察到，除了斯里兰卡和日本之外，十大自杀国家中几乎 90%来自欧洲和俄罗斯。我们可以宣布立陶宛是自杀率最高的国家，但在做出决定之前，最好用一些统计数据来量化结果。

应用假设检验找出世界上自杀率最高的国家

我们进行假设检验，因为当按平均值排名时，立陶宛以高得多的值排名第一，但当按中位数排名时，斯里兰卡以非常小的差距在立陶宛之上。

如果假设检验证明立陶宛和斯里兰卡的自杀率没有显著差异，我们肯定可以认为立陶宛是世界上自杀率最高的国家(基于 1985-2016 年的数据)。

无效假设 —立陶宛和斯里兰卡的自杀率没有显著差异。
交替假设— 立陶宛和斯里兰卡的自杀率存在显著差异。

检验统计 —立陶宛和斯里兰卡自杀率中位数的差异。

我们从每个国家的 100 个中选取 样本量 ，并设定 显著性水平为 5% (0.05)。

现在我们进行实验。首先我们按国家划分数据。

lithuania=SuicideData[SuicideData.country=='Lithuania']
srilanka=SuicideData[SuicideData.country=='Sri Lanka']

然后我们从立陶宛和斯里兰卡各随机抽取 100 个数据点。

sample_lithuania=lithuania.sample(100)
sample_srilanka=srilanka.sample(100)

现在，我们只从样本数据的 pandas 数据帧中取出自杀率列，并将其转换为 numpy 数组，以便于计算。

S1=np.array(sample_lithuania['suicides/100k pop'])
print(S1)
median1=np.median(S1)
print('MEDIAN1=',median1)

Numpy array of Lithuania sample suicide rates

S2=np.array(sample_srilanka['suicides/100k pop'])
print(S2)
median2=np.median(S2)
print('MEDIAN2=',median2)

Numpy array of Sri-Lanka sample suicide rates

我们可以看到，即使是两国样本的自杀率中位数也非常接近。因此，我们现在计算我们的测试统计值如下

TS= median1-median2
print("Test Statistic is (Median of Lithuania - Median of Sri Lanka)=", TS)

如前所述，下一步是将两组样本数据连接成一组，并对它们进行混排，这样两组数据的观察值就能正确地混合成一组数据。

S= np.concatenate((S1,S2), axis=None)
np.random.shuffle(S)
print(S)

200 mixed observations from both countries

我们通过取 100 个点的两个样本集来执行 1000 次重采样，并且每次计算它们的中位数的差。中值差列表存储在另一个 numpy 数组中。

#Randomly sample 100-100 data points and calculate the difference of medians
medianlist=np.zeros(1000)
for i in range(1000):
    _s1= np.random.choice(S,100)
    _s2= np.setdiff1d(S, _s1)
    _median1= np.median(_s1)
    _median2= np.median(_s2)
    medianlist[i]= np.array(_median1 - _median2)

最后一步，对 medianlist 进行升序排序，计算 p 值，得出最终结论。代码片段和结果如下:

medianlist=np.sort(medianlist)#calculation of p-value
ct=0
for i in medianlist:
    if i < TS:
        ct+=1
pvalue= (1000-ct) / 1000medianlist=pd.DataFrame(medianlist, columns=['mediandiff'])
pv95=medianlist.mediandiff[949]
print('VALUE in 95th Percentile position=', pv95)
print('TEST STATISTIC =',TS)
print('P-VALUE OF TS =', pvalue)if pvalue>0.05:
    print('OBSERVATION VALUE IS LOWER THAN THE 95th Percentile.\nTHUS probability of OCCURENCE OF OUR OBSERVATION GIVEN NULL HYPOTHESIS IS High, AS P-VALUE OF {} IS HIGHER THAN THE SIGNIFICANCE LEVEL OF 0.05'.format(pvalue))
    print('SO WE ACCEPT THE NULL HYPOTHESIS AS TRUE : LITHUANIA AND SRI LANKA HAVE NO SIGNIFICANT DIFFERENCE IN SUICIDE RATES')
else:
    print('OBSERVATION VALUE IS HIGHER THAN THE 95th Percentile.\nTHUS probability of OCCURENCE OF OUR OBSERVATION GIVEN NULL HYPOTHESIS IS Extremely Low, AS P-VALUE OF {} IS LOWER THAN THE SIGNIFICANCE LEVEL OF 0.05'.format(pvalue))
    print('SO WE REJECT THE NULL HYPOTHESIS AND ACCEPT THE ALTERNATE HYPOTHESIS : LITHUANIA AND SRI LANKA HAVE A SIGNIFICANT DIFFERENCE IN SUICIDE RATES')
    if TS > 0:
        print('FROM THE SIGN OF TS WE KNOW LITHUANIA HAS A HIGHER SUICIDE RATE')
    else:
        print('FROM THE SIGN OF TS WE KNOW SRI LANKA HAS A HIGHER SUICIDE RATE')

p 值为 0.511 意味着，鉴于立陶宛和斯里兰卡的自杀率之间没有显著差异，我们的样本观察结果出现的概率接近 50%，远高于 5%的显著性水平。因此，我们接受我们的零假设为真。

所以我们可以说立陶宛是世界上自杀率最高的国家 因为立陶宛和第二高的国家——斯里兰卡的平均自杀率差异很大，但中位数差异并不显著。因此，我们通过我们的判断基于平均差异。

现在你可能会怀疑假设检验的结果，所以我将展示如果我们对立陶宛和日本进行同样的检验会发生什么。

假设检验:立陶宛和日本哪个国家更有自杀倾向？

我们知道日本的自杀率比立陶宛低得多，根据中位数排名，日本排在第八位。因此，如果我们的假设检验给出了相同的结果，那么我们可以相信这种检验方法。

零假设 —立陶宛和日本的自杀率没有显著差异。
替代假设— 立陶宛和日本的自杀率存在显著差异。

检验统计 —立陶宛和日本自杀率中位数的差异。

我们从每个国家的 100 个中取 样本量 ，并设定 显著性水平为 5% (0.05)。

为日本执行采样:

sample_japan=japan.sample(100)S3=np.array(sample_japan['suicides/100k pop'])
print(S3)
median3=np.median(S3)

计算测试统计值

TS2=median1-median3
print("Test Statistic is (Median of Lithuania - Median of Japan)=", TS2)

连接和洗牌:

SS= np.concatenate((S1,S3), axis=None)
np.random.shuffle(SS)
print(SS)

随机抽取 100–100 个数据点，计算中位数的差值

medianlist2=np.zeros(1000)
for i in range(1000):
    _s1= np.random.choice(SS,100)
    _s3= np.setdiff1d(SS, _s1)
    #print(_s1)
    #print(_s3)
    _median1= np.median(_s1)
    _median3= np.median(_s3)
    medianlist2[i]= np.array(_median1 - _median3)

对中值列表排序后的最终计算和结果

medianlist2=np.sort(medianlist2)#calculation of p-value
ct2=0
for i in medianlist2:
    if i < TS2:
        ct2+=1
pvalue2= (1000-ct2) / 1000medianlist2=pd.DataFrame(medianlist2, columns=['mediandiff'])
pv95_2=medianlist2.mediandiff[949]
print('VALUE in 95th Percentile position=', pv95_2)
print('TEST STATISTIC =',TS2)
print('P-VALUE OF TS =', pvalue2)
if pvalue2>0.05:
    print('OBSERVATION VALUE IS LOWER THAN THE 95th Percentile.\nTHUS probability of OCCURENCE OF OUR OBSERVATION GIVEN NULL HYPOTHESIS IS High, AS P-VALUE OF {} IS HIGHER THAN THE SIGNIFICANCE LEVEL OF 0.05'.format(pvalue2))
    print('SO WE ACCEPT THE NULL HYPOTHESIS AS TRUE : LITHUANIA AND JAPAN HAVE NO SIGNIFICANT DIFFERENCE IN SUICIDE RATES')
else:
    print('OBSERVATION VALUE IS HIGHER THAN THE 95th Percentile.\nTHUS probability of OCCURENCE OF OUR OBSERVATION GIVEN NULL HYPOTHESIS IS Extremely Low, AS P-VALUE OF {} IS LOWER THAN THE SIGNIFICANCE LEVEL OF 0.05'.format(pvalue2))
    print('SO WE REJECT THE NULL HYPOTHESIS AND ACCEPT THE ALTERNATE HYPOTHESIS : LITHUANIA AND JAPAN HAVE A SIGNIFICANT DIFFERENCE IN SUICIDE RATES')
    if TS2 > 0:
        print('FROM THE SIGN OF TS WE KNOW LITHUANIA HAS A HIGHER SUICIDE RATE')
    else:
        print('FROM THE SIGN OF TS WE KNOW JAPAN HAS A HIGHER SUICIDE RATE')

我们的假设检验证明，立陶宛的自杀率高于日本，因为 p 值极低，约为 1%。

总结一下

Summary Report

因此，我们可以得出结论，假设检验是一种很好的方法，可以通过统计证明来检验一个假设的可能性。

问题:自杀率是否依赖于人均 GDP？

人们可能会想，当一个地方的经济条件恶化时，自杀的人会更多，而当经济条件或收入较好时，自杀的人会更少。我们可以从我们的自杀数据集中找出这种情况是否真的发生，并用另一个测试参数(称为 Spearman 等级相关系数)对其进行量化。

什么是斯皮尔曼秩相关系数？

这是一种测试，用来确定一个随机变量的值是否稳定地增加或减少，而另一个随机变量的值是否有相同的变化。称之为单调地递增或递减。如果一个增加而另一个增加，则结果为正(+)，如果一个减少而另一个增加，则结果为负(-)。结果介于-1 和+1 之间。

假设有两组随机变量 X 和 Y，首先对它们进行排序。这种相关性是基于他们的排名，而不是他们的价值观。这就是为什么这项技术受异常值的影响最小。

应用 Spearman 等级相关系数回答我们的问题

在我们的案例中，我们可以测试人均 GDP 的变化是否会带来自杀率的变化。

让我们绘制一个图表并可视化数据，其中 X 轴是人均 GDP的增长，Y 轴是每 10 万人口的自杀人数。它也根据 年龄组 进行颜色编码**

**sb.set_style("whitegrid");
sb.FacetGrid(SuicideData, hue="age", height=7) \
   .map(mp.scatter, "gdp_per_capita ($)", "suicides/100k pop") \
   .add_legend();
mp.show();**

我们可以看到，人均国内生产总值较高的点较少，但数据点分散，似乎没有很好的相关性。因此，最好将数据分成不同的年龄组，对它们进行绘图，并找到它们各自的 Spearman 等级相关系数值。我已经使用了scipy . statspython 库来计算我们的结果。

**#DIVIDING BY AGE GROUPA5_14=SuicideData[SuicideData.age=='5-14 years']
A15_24=SuicideData[SuicideData.age=='15-24 years']
A25_34=SuicideData[SuicideData.age=='25-34 years']
A35_54=SuicideData[SuicideData.age=='35-54 years']
A55_74=SuicideData[SuicideData.age=='55-74 years']
A75P=SuicideData[SuicideData.age=='75+ years']**

图形的代码片段

**sb.set_style("whitegrid");
sb.FacetGrid(A5_14, hue='sex', height=5) \
   .map(mp.scatter, "gdp_per_capita ($)", "suicides/100k pop") \
   .add_legend();
mp.title('AGE GROUP 5-14')
mp.show();**

类似的代码可以用于每个年龄组

即使对于单个年龄组来说，这些特性也是相似的。现在我们计算系数值。

**#Spearman's rank correlation coefficient
#IF THERE IS A CORRELATION BETWEEN GDP PER CAPITA & SUICIDE RATES
#FOR ALL THE AGE GROUPSsp.spearmanr(A5_14['gdp_per_capita ($)'],A5_14['suicides/100k pop'] )
sp.spearmanr(A15_24['gdp_per_capita ($)'],A15_24['suicides/100k pop'] )
sp.spearmanr(A25_34['gdp_per_capita ($)'],A25_34['suicides/100k pop'] )
sp.spearmanr(A35_54['gdp_per_capita ($)'],A35_54['suicides/100k pop'] )
sp.spearmanr(A55_74['gdp_per_capita ($)'],A55_74['suicides/100k pop'] )
sp.spearmanr(A75P['gdp_per_capita ($)'],A75P['suicides/100k pop'] )**

****

我们观察到相关值非常接近于零。这表明人均 GDP 和自杀率之间没有相关性。

结论

你已经看到统计方法对于证实我们根据观察到的数据所做的任何假设是多么重要。有时我们观察到的一些东西可能实际上并不真实，这就是这些方法帮助我们证明我们的理论具有统计学意义的地方。

Github 代码链接

** [## souravkajuri/自杀率

在 GitHub 上创建一个帐户，为 souravkajuri/suiciderate 开发做贡献。

github.com](https://github.com/souravkajuri/suiciderate)****

RNN 在顾客评论情感分析中的应用

原文：https://towardsdatascience.com/application-of-rnn-for-customer-review-sentiment-analysis-178fa82e9aaf?source=collection_archive---------8-----------------------

在我之前的博客文章中，我写了关于使用 BeautifulSoup 收集两千多条 Flixbus 客户评论，并通过执行 NLP 分析来识别公司的优势和劣势。

基于之前的故事，我决定使用收集的文本数据来训练一个递归神经网络模型来预测客户的情绪，这被证明是非常高效的，在测试集上达到 95.93%的准确率。

什么是情感分析？维基百科提供了一个很好的解释:

“……情感分析旨在确定发言人、作者或其他主体对某个主题的态度，或对某个文档、互动或事件的整体上下文极性或情感反应。”——来源

事不宜迟，让我们开始实施吧。

加载和准备数据

首先，我加载了一个 csv 文件，其中包含 1，780 条英文客户评论，相应的评分从 1 到 5，其中 1 是最低(负面)评分，5 是最高(正面)评分。以下是对数据框的快速浏览:

Data frame with customer reviews and rating

太好了！现在我们有了可以处理的数据。然而，由于我们的目标是预测情绪——无论评论是正面的还是负面的，我们必须为这项任务选择适当的数据。

使用计数器功能，我注意到每个评分的评论分布相当不平衡:

# Count of reviews per rating
Counter({5: 728, 4: 416, 1: 507, 3: 86, 2: 43})

为了平衡它，并确保情绪类的良好表现，我决定保留“积极”的 5 星评论，而“消极”的 1 星和 2 星评论。结果，我得到了总共 1278 条评论的样本量。不多，但让我们看看能从中得到什么。

在处理评论之前，应该使用列表理解对情感进行二进制编码，1 表示积极情感，0 表示消极情感。

data['Sentiment'] = [1 if x > 4 else 0 for x in data.Rating]

现在我们有了一个基本的设置，是时候继续进行数据预处理了。

数据预处理

RNN 输入需要数组数据类型，因此，我们将“评论”转换为 X 数组，并将“情绪”转换为 y 数组。

X, y = (data['Review'].values, data['Sentiment'].values)

文本数据在输入 RNN 模型之前必须进行整数编码。这可以通过使用 Keras 库中的基本工具轻松实现，只需几行代码:

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequencestk = Tokenizer(lower = True)
tk.fit_on_texts(X)
X_seq = tk.texts_to_sequences(X)
X_pad = pad_sequences(X_seq, maxlen=100, padding='post')

首先，应该通过在数据集上安装标记器类来标记文本。如你所见，我使用“lower = True”参数将文本转换成小写，以确保数据的一致性。然后，我们应该使用 texts_to_sequences 类将单词(标记)列表映射到每个唯一单词的唯一整数列表。

Dictionary

作为一个例子，下面您可以看到在应用预处理后，原始评论是如何变成一个整数序列的。

Original reviews vs after tokenization and sequencing

接下来，我们使用整数列表上的 pad_sequences 类来确保所有评论的长度相同，这是为 RNN 模型准备数据的非常重要的一步。应用这个类要么将评论缩短到 100 个整数，要么在它们更短的情况下用 0 填充它们。

Reviews after padding

现在，我们使用 sklearn 的 train_test_split 将数据集分为训练集和测试集，并保留 25%的原始数据作为保留集:

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X_pad, y, test_size = 0.25, random_state = 1)

此外，训练集可以分为训练集和验证集:

batch_size = 64
X_train1 = X_train[batch_size:]
y_train1 = y_train[batch_size:]X_valid = X_train[:batch_size]
y_valid = y_train[:batch_size]

是时候使用 Keras 构建模型并使其符合训练数据了:

from keras.models import Sequential
from keras.layers import Embedding, LSTM, Dense, Dropoutvocabulary_size = len(tk.word_counts.keys())+1
max_words = 100embedding_size = 32
model = Sequential()
model.add(Embedding(vocabulary_size, embedding_size, input_length=max_words))
model.add(LSTM(200))
model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

由于嵌入需要词汇的大小和输入序列的长度，我们将词汇大小设置为 Tokenizer 字典中的单词数+ 1，将输入长度设置为 100 (max_words)，其中后一个参数的值必须与填充(！idspnonenote)的值相同。).嵌入大小参数指定将使用多少维度来表示每个单词。通常使用值 50、100 和 300 作为该参数的输入，但在这种情况下，调整模型值 32 可获得最佳结果。

接下来，我们添加一个隐藏的 200 个内存单元的 LSTM 层。潜在地，添加更多的层和单元可以导致更好的结果。

最后，我们添加带有 sigmoid 激活函数的输出层来预测评论为正面的概率。

在对模型进行 10 个时期的训练后，我们在验证集和测试集上分别获得了 98.44%和 95.93%的准确率。

Training and testing accuracy results

Confusion matrix of hold out set prediction

是不是很牛逼？为了安全起见，我们再检查一下吧！

最终验证

为了进一步验证模型的准确性，我另外从 Trustpilot 搜集了 100 条 Flixbus 的最新客户评论，当然这些评论不包括在原始数据集中。新抓取的评论包括 1、4 和 5 星级评论，计数如下:

# Count of reviews per rating
Counter({1: 83, 4: 13, 5: 4})

为了准备用于预测的评论，在将它们传递到训练模型之前，必须对文本应用相同的预处理步骤。

# Prepare reviews for check
Check_set = df.Review.values
Check_seq = tk.texts_to_sequences(Check_set)
Check_pad = pad_sequences(Check_seq, maxlen = 100, padding = 'post')# Predict sentiment
check_predict = model.predict_classes(Check_pad, verbose = 0)# Prepare data frame
check_df = pd.DataFrame(list(zip(df.Review.values, df.Rating.values, check_predict)), columns = ['Review','Rating','Sentiment'])
check_df.Sentiment = ['Pos' if x == [1] else 'Neg' for x in check_df.Sentiment]
check_df

最后，我们得到以下结果:

Final check results

Confusion matrix of validation prediction

从上面的截图中，您可以立即发现一些错误分类的情况。在 100 个预测案例中，只有 16 个实际评级为 1 星的评论被错误地归类为“Pos”(具有正面情绪)。然而，如果我们深入挖掘，我们会发现问题实际上并没有看起来那么大:

Misclassifications

16 个案例中，只有 3 个独特的评论！一个评论重复 14 次(不公平💩).与此同时，所有评级为 4 和 5 的其他人都被正确分类为阳性。

就是这样！

呜哇！我们已经成功地训练和验证了 RNN 的情感预测性能。总的来说，这是一个相对简单和容易的任务，交付出色的结果。希望你喜欢这篇文章，并努力实现你自己！

机器学习在现代商业中的应用

原文：https://towardsdatascience.com/applications-for-machine-learning-in-modern-business-1cd4c1ea1f1d?source=collection_archive---------11-----------------------

Photo by Scott Graham on Unsplash

根据 Constellation Research 最近的一项研究，2017 年企业部门对人工智能的投资预计将增加两倍，预计到 2025 年将达到 1000 亿美元。仅此一点就足以凸显机器学习在当今商业中发挥的日益重要的作用。这也许就是为什么在最近的一项调查中，30%的参与者得出结论，人工智能和机器学习将在未来五年内大规模颠覆数字产业！

机器学习使公司能够促进增长、优化流程、改善客户体验并提高员工参与度。这里有几个坚实的例子，将展示人工智能和机器学习如何为当今的公司提供支持:

检测欺诈和可疑活动

如果数字可信的话，一个组织每年因欺诈损失 5%的收入。这就是人工智能和机器学习可以帮助你降低这些数字的地方。机器学习可以帮助您基于社交网络信息、历史交易、机器和其他数据建立模型，以开发一种有助于及时检测异常、异常值和异常的模式。

例如，银行可以利用历史数据建立基于以前欺诈活动的算法。因此，每当此类欺诈活动重复出现时，这将有助于您识别欺诈行为。

这是 PayPal 10 年来一直在做的事情。PayPal 每秒处理10，900 美元，2015 年在 202 个国家产生了 49 亿笔支付。这很好地解释了 PayPal 每秒钟都可能面临的风险。但是，PayPal 及其数据科学家和数学家使用自主开发的人工智能引擎来打击任何欺诈活动。

识别业务运营中可能存在问题的领域

商业运作中的问题几乎在任何地方都会突然出现。某台机器可能开始工作缓慢，或者可能有过量的产品订单。在这种情况下，机器学习会自动引起你的注意。

这可以通过在 HANA 的帮助下在您的系统上安装应用程序来轻松实现。因此，每次生产放缓时，HANA 都会处理数据并提供结果，以便您决定某台机器或设备是否需要关注或检查。

沃尔玛一直在使用 HANA 来监控其交易记录。事实上，沃尔玛在全球经营着超过 11，000 家店铺。他们一直在使用 HANA 来获得更好更快的控制；通过自动化操作来管理后台办公室。

通过识别客户行为模式简化销售运营

机器学习可以被证明是识别你的客户/线索行为的一个转折点，从而促进你的销售业务。事实上，客户服务软件公司 Zendesk 一直在使用领先的预测分析和机器学习软件 MarianalQ 来促进其销售。Zendesk 见证了销售线索质量的四倍增长。此外，通过社交定位，沃尔玛仅在三天内就接触到了 50%以上的顾客。

然而，这并不是结束。机器学习可以用于一系列其他领域，包括:

职业生涯规划

机器智能可以帮助进行适当的指导，从而建议员工选择职业道路，从而提高满意度、保留率和绩效。

无人机管理

在无人机的帮助下，机器学习可以进一步帮助及时检查商业结构。无人机可以点击图像，然后可以分析任何裂缝或退化。

简而言之，机器学习使一家公司能够用数字智能进行超乎想象的思考。可能性是无穷的。但是，有各种各样的障碍需要克服。最重要的是，应该有足够的数据来训练算法，以获得更好的输出。

【viewport-tech.com】最初发表于。

人工智能在经济、贸易和预测中的应用

原文：https://towardsdatascience.com/applications-of-ai-in-economics-trading-and-forecasting-288c4a466af8?source=collection_archive---------6-----------------------

随着第一台计算机的出现，许多经济学家对计算机的应用感兴趣。随着互联网的发明，大量的数据可供分析。此外，这种趋势如今仍在继续，在许多现实世界的任务中，如交易，人工智能积极超越并取代金融工作者。

人工智能相对于人类的主要优势是处理大量输入数据的能力。例如，要评估未来的股票价格，你可以使用来自公司活动、评论、新闻、推特和许多其他来源的信息。相反，对于人类交易员来说，实时处理所有这些数据几乎是不可能的。看看这个:

研究人员开发了许多不同的技术，将人工智能应用于金融科技的各个分支。例如，递归神经网络在价格预测中显示出令人信服的结果。相应地，其他深度学习方法在破产和欺诈预测、信誉测量和风险管理方面表现出色。

Left — traders, Center — common machine trading systems, Right — HFT

高频交易的人工智能(HFT)

直到去年，HFT 交易员还在使用非常简单的算法。首先，他们的时间框架非常有限，所以十年前大数据分析不是一个选项。如今，机器学习在交易中的影响越来越大，而 GPU 和其他人工智能硬件为大型神经网络提供了高性能。快速下降的计算成本和延迟也在外汇交易的人工智能进化中发挥了重要作用。

学习如何制作人工智能驱动的交易软件

30 多年来，人工智能开发人员对其技能在金融领域的应用越来越感兴趣。由于这个原因，他们开发了第一批神经网络，甚至在 NN 在其他领域受到任何关注之前。这是可以理解的——金融科技公司的薪水相对较高。

今天你可以在网上学习如何创建这种程序。在这种情况下，您可能会对那些免费的审计课程感兴趣:

交易策略。这个专业涵盖了从最基础的交易到创建投资组合和设计你自己的策略。
计算投资。更高级的课程强调计算的观点。
机器学习交易。Tucker Balch 的另一个在线课程关注的是 ML 在交易中的应用。

总而言之，我建议按照这个顺序去参观。然而，你可能会在 Coursera、edX 甚至 YouTube 等平台上找到更多的在线讲座。

最初发表于 认知混乱 。

强化学习在现实世界中的应用

原文：https://towardsdatascience.com/applications-of-reinforcement-learning-in-real-world-1a94955bcd12?source=collection_archive---------0-----------------------

没有推理，没有推论或比较的过程；没有对事物的思考，没有把两两放在一起；没有想法——动物不会想到盒子、食物或它要做的动作。———爱德华·桑戴克(1874-1949)，提出效果定律的心理学家。

虽然卷积神经网络(CNN)和递归神经网络(RNN)因其在计算机视觉(CV)和自然语言处理(NLP)中的应用而对企业变得越来越重要，但强化学习(RL)作为计算神经科学的框架来模拟决策过程似乎被低估了。此外，似乎很少有资源详细介绍 RL 在不同行业中的应用。尽管对 RL 的弱点提出了批评，但鉴于其在辅助决策方面的巨大潜力，RL 在企业研究领域不应被忽视。正如 Deepmind 的研究主管 Koray Kavukcuoglu 在一次会议上所说，

“如果我们在这里工作的目标之一是人工智能，那么它就是它的核心。强化学习是学习顺序决策任务的一个非常通用的框架。另一方面，深度学习当然是我们用来学习表示的最佳算法集。这两种不同模型的结合是迄今为止我们在学习非常具有挑战性的任务的非常好的状态表示方面的最佳答案，这些任务不仅是为了解决玩具领域，而且实际上是为了解决具有挑战性的现实世界问题。”

因此，本文旨在 1)调查现实世界中强化学习应用的广度和深度；2)从不同角度看待 RL；3)说服决策者和研究人员加大研发力度。

文章的其余部分组织如下。第一节是总论。第二节介绍了 RL 在不同领域的应用，并简要说明了如何应用 RL。第三节总结了应用 RL 需要的东西。第四部分是来自其他学科的直觉，第五部分是关于 RL 在未来如何有用。第六部分是结论。

一、强化学习简介

RL 在机器学习中被称为半监督学习模型，是一种允许代理采取行动并与环境交互以最大化总回报的技术。RL 通常被建模为马尔可夫决策过程 (MDP)。

Source: Reinforcement Learning:An Introduction

想象一下，在你家(环境)给一个婴儿一个电视遥控器。简单来说，婴儿(代理人)将首先观察和构建他/她自己对环境(状态)的表征。然后，好奇的宝宝会采取某些行动，如按遥控器(行动)，并观察电视会如何反应(下一个状态)。由于没有反应的电视是乏味的，婴儿不喜欢它(接受负面奖励)，并会采取较少的行动导致这样的结果(更新政策)，反之亦然。宝宝会重复这个过程，直到他/她找到一个自己满意的政策(不同情况下该怎么做)(最大化总(贴现)奖励)。

强化学习的研究就是要建立一个数学框架来解决问题。例如，要找到一个好的策略，我们可以使用基于值的方法，如 Q-learning，来衡量一个动作在特定状态下有多好，或者使用基于策略的方法来直接找出在不同状态下要采取什么动作，而不知道这些动作有多好。

然而，我们在现实世界中面临的问题可能在许多不同的方面极其复杂，因此典型的 RL 算法没有解决的线索。例如，在围棋游戏中，状态空间非常大；在扑克游戏中，环境无法完全观察到；在现实世界中，有许多智能体相互作用。研究人员发明了一些方法来解决一些问题，通过使用深度神经网络来建模期望的策略、价值函数甚至转换模型，因此这被称为深度强化学习。这篇文章没有区分 RL 和 Deep RL。

网上有很多关于 RL 的好东西，感兴趣的读者可以访问 awesome-rl 、 argmin 和 dennybritz 。

二。应用程序

这部分是写给一般读者的。同时，对于对 RL 有一定了解的读者来说，也将有更大的价值。

计算机集群中的资源管理

设计算法来将有限的资源分配给不同的任务是具有挑战性的，并且需要人类产生的启发。论文“具有深度强化学习的资源管理”【2】展示了如何使用 RL 来自动学习分配和调度计算机资源给等待的作业，目的是最小化平均作业减速。

状态空间被表述为当前的资源分配和作业的资源轮廓。对于动作空间，他们使用了一个技巧，允许代理在每个时间步选择多个动作。奖励是系统中所有工作的总和(-1/工作持续时间)。然后，他们结合强化算法和基线值来计算策略梯度，并找到最佳策略参数，以给出最小化目标的动作概率分布。点击这里查看 Github 上的代码。

交通灯控制

在论文“基于强化学习的网络交通信号控制多智能体系统”【3】中，研究人员试图设计一种交通灯控制器来解决拥堵问题。虽然只在模拟环境中测试，但他们的方法显示出优于传统方法的结果，并揭示了多智能体 RL 在设计交通系统中的潜在用途。

Five-intersection traffic network. Source.

五个智能体被放置在五个交叉路口的交通网络中，其中一个 RL 智能体位于中央交叉路口以控制交通信号。状态被定义为八维向量，每个元素代表每条车道的相对交通流量。代理人有八个选择，每个选择代表一个相位组合，奖励函数定义为与前一时间步相比延迟的减少。作者使用 DQN 来学习{状态，动作}对的 Q 值。

机器人技术

在机器人学中应用 RL 的工作非常多。读者可以参考【10】了解机器人领域的 RL 概况。特别是，【11】训练一个机器人学习策略，将原始视频图像映射到机器人的动作。RGB 图像被馈送到 CNN，输出是电机转矩。RL 组件是引导式策略搜索，用于生成来自其自身状态分布的训练数据。

Demo of the paper.

Web 系统配置

web 系统中有 100 多个可配置的参数，调整参数的过程需要熟练的操作员和大量的反复试验。论文“在线 web 系统自动配置的强化学习方法”【5】展示了在基于 VM 的动态环境中如何在多层 Web 系统中进行参数的自主重新配置的首次尝试。

重新配置过程可以被公式化为有限 MDP。状态空间是系统配置，动作空间是每个参数的{增加、减少、保持}，奖励定义为给定的目标响应时间和测量的响应时间之差。作者使用无模型 Q 学习算法来完成这项任务。

虽然作者使用了一些其他技术(如策略初始化)来弥补该问题的大状态空间和计算复杂性，而不是 RL 和神经网络的潜在组合，但相信该开创性工作为该领域的未来研究铺平了道路。

化学

RL 还可以应用于优化化学反应。【4】在论文《用深度强化学习优化化学反应》中表明，他们的模型优于最先进的算法，并推广到不同的底层机制。

结合 LSTM 来对策略函数建模，RL 代理使用由{S，A，P，R}表征的马尔可夫决策过程(MDP)来优化化学反应，其中 S 是实验条件(如温度、pH 等)的集合，A 是可以改变实验条件的所有可能动作的集合，P 是从当前实验条件到下一个条件的转移概率，R 是作为状态的函数的回报。

应用很好地展示了 RL 如何在相对稳定的环境中减少耗时和反复试验的工作。

个性化推荐

以往的新闻推荐工作面临着新闻动态变化快、用户容易厌倦、点击率不能反映用户留存率等挑战。关捷等人在题为“DRN:新闻推荐的深度强化学习框架”的论文中已经将强化学习应用于新闻推荐系统，以解决这些问题【1】。

在实践中，他们构建了四类特征，即 A)用户特征和 B)上下文特征作为环境的状态特征，以及 C)用户新闻特征和 D)新闻特征作为动作特征。这四个特征被输入到深度 Q 网络(DQN)以计算 Q 值。基于 Q 值选择推荐一系列新闻，用户对新闻的点击是 RL 代理收到的奖励的一部分。

作者还采用了其他技术来解决其他具有挑战性的问题，包括记忆回放，生存模型，决斗土匪梯度下降等。详情请参考论文。

招标和广告

来自阿里巴巴集团的研究人员发表了一篇论文“展示广告中多代理强化学习的实时竞价”【6】，并声称他们的分布式基于集群的多代理竞价解决方案(DCMAB)取得了令人鼓舞的结果，因此他们计划在淘宝平台进行现场测试。

实现的细节留给用户去研究。一般来说，淘宝广告平台是商家为了向顾客展示广告而进行竞价的地方。这可能是一个多代理人的问题，因为商家正在相互竞价，他们的行为是相互关联的。在论文中，商家和顾客被分成不同的组以减少计算的复杂性。代理的状态空间表示代理的成本-收益状态，行动空间表示出价(连续)，回报表示客户群带来的收益。

The DCMAB algorithm. Source: https://arxiv.org/pdf/1802.09756.pdf

本文还研究了其他问题，包括不同的报酬设置(自利与协调)对代理人收益的影响。

游戏

RL 如今如此知名，是因为它是用于解决不同游戏的主流算法，有时还能达到超人的性能。

RL vs linear model vs Human. Click here for the source.

最著名的一定是 alpha go【12】和 alpha go Zero【13】。通过在策略网络中使用价值网络和蒙特卡罗树搜索(MCTS ),用无数人类游戏训练的 AlphaGo 已经实现了超人的性能。然而，研究人员后来回想并尝试了一种更纯粹的 RL 方法——从头开始训练。研究人员让新代理 AlphaGo Zero 与自己对弈，最终以 100 比 0 击败 AlphaGo。

深度学习

最近可以看到越来越多的将 RL 和其他深度学习架构相结合的尝试，它们显示出令人印象深刻的结果。

RL 中最有影响力的作品之一就是 Deepmind 将 CNN 与 RL【7】结合的开创性工作。这样做，智能体就有能力通过高维度的感官“看见”环境，然后学会与之互动。

RL 和 RNN 是人们用来尝试新想法的另一种组合。RNN 是一种具有“记忆”的神经网络。当与 RL 结合时，RNN 赋予代理人记忆事物的能力。例如:[8]LSTM 与 RL 相结合，创建了深度递归 Q-Network(DRQN)，用于玩 Atari 2600 游戏。[4]还利用 RNN 和 RL 解决了化学反应优化问题。

Deepmind 向 [9] 展示了如何使用生成模型和 RL 来生成程序。在该模型中，经过敌对训练的代理人使用信号作为奖励来改进动作，而不是像在 GAN 训练中那样将梯度传播到输入空间。

Input vs Generated result. See source.

三世。在将 RL 应用于您的问题之前，您需要了解什么

在应用 RL 之前，需要做几件事:

了解您的问题:您不一定需要在您的问题中使用 RL，有时您只是不能使用 RL。在决定使用 RL 之前，您可能需要检查您的问题是否具有以下某些特征:a)试错法(通过接收来自环境的反馈可以学着做得更好)；b)延迟奖励；c)可以模拟为 MDP；d)您的问题是控制问题。
模拟环境:在 RL 算法工作之前，需要多次迭代。我敢肯定，你不希望看到一个 RL 代理尝试不同的东西在自动驾驶汽车在高速公路上，对不对？因此，需要一个能够正确反映现实世界的模拟环境。
MDP:你的世界需要把你的问题变成一个 MDP。你需要设计状态空间、动作空间、奖励功能等等。您的代理人将在约束条件下执行其应执行的操作。如果你用不同的方式设计，你可能不会得到你想要的结果。
算法:有不同的 RL 算法可供您选择，您也可以自己提问。您想直接了解保单还是想了解价值函数？您想要无模型还是基于模型？您是否需要结合其他类型的深层神经网络或方法来解决您的问题？

为了保持客观和公正，您还会被警告 RL 的缺点，这里有一篇关于它的很棒的帖子。

静脉。其他学科的直觉

RL 与心理学、生物学、神经科学的关系非常密切。如果你想一想，RL 代理所做的只是试错:它根据从环境中获得的奖励来学习其行为的好坏。这正是人类学习做决定的方式。此外，探索和开发问题，信用分配问题，试图模拟环境也是我们在日常生活中面临的问题。

经济学理论也能对 RL 有所启发。特别地，多主体强化学习(MARL)的分析可以从博弈论的角度来理解，博弈论是由约翰·纳西开发的一个研究领域，用于理解系统中主体的交互作用。除了博弈论，MARL，部分可观察马尔可夫决策过程(POMDP)也可以用于理解其他经济主题，如市场结构(如垄断、寡头垄断等)外部性和信息不对称。

五、RL 未来可能实现的目标

RL 仍然有很多问题，不容易使用。然而，只要在解决这些问题上付出更多的努力，研究性学习将在以下几个方面产生影响:

协助人类:也许说人工智能有一天会进化成人工智能(AGI)有点过了，但人工智能肯定有潜力协助人类并与之合作。想象一下，一个机器人或一个虚拟助手与你一起工作，将你的行动纳入其考虑范围，以采取行动，从而实现一个共同的目标。那岂不是很棒？
理解不同策略的后果:生活如此神奇是因为时间不会倒流，事情只会发生一次。然而，有时我们想知道如果我采取不同的行动，事情会有什么不同(至少在短期内)？或者，如果教练采用另一种策略，克罗地亚会有更大的机会赢得 2018 年世界杯吗？当然，要做到这一点，我们需要对环境、转移函数等进行完美的建模，还要分析代理之间的相互作用，这在目前看来是不可能的。

六。结论

本文只是展示了 RL 在各种行业中应用的一些例子。他们不应该限制你的 RL 用例，一如既往，你应该使用第一原则来理解 RL 的本质和你的问题。

如果你是一家公司的决策者，我希望这篇文章足以说服你重新思考你的业务，看看 RL 是否有潜在的用途。如果你是一名研究人员，我希望你会同意我的观点，虽然 RL 仍然有不同的缺点，但这也意味着它有很多改进的潜力和很多研究机会。

你有什么想法？你能想到 RL 能解决的任何问题吗？

参考文献

[1]郑，张，郑，向，倪.袁，谢，李。DRN:新闻推荐的深度强化学习框架。2018.

[2] H.Mao，Alizadeh，M. Alizadeh，Menache，I.Menache 和 S.Kandula .具有深度强化学习的资源管理.2016 年 ACM 网络热点专题研讨会。

[3] I. Arel，C. Liu，T. Urbanik，A. Kohls，“基于强化学习的多智能体网络交通信号控制系统”，智能交通系统，2010 .

[4]周志忠、李晓霞和。用深度强化学习优化化学反应。ACSCentral Science3，2017。

[5]卜晓霞，饶军，徐春忠。在线 web 系统自动配置的强化学习方法。分布式计算系统，2009。第 29 届 IEEE 国际会议。IEEE，2019。

[6]靳，宋春春，李，盖，王，张。展示广告中基于多智能体强化学习的实时竞价。arXiv 预印本 arXiv:1802.09756，2018。

[7] V. Mnih、K. Kavukcuoglu、D. Silver、A. Graves、I. Antonoglou、D. Wierstra 和 M. Riedmiller。用深度强化学习玩雅达利。arXiv 预印本 arXiv:1312.5602，2013。

M. J. Hausknecht 和 P. Stone。部分可观测 MDP 的深度递归 Q 学习。继续。Conf .的。人工智能，AAAI，2015。

[9] Y. Ganin、T. Kulkarni、I. Babuschkin、S. Eslami 和 O. Vinyals 使用强化对抗学习的图像合成程序。arXiv 预印本 arXiv:1804.01118。

10j .科贝尔、J. A. D .巴格内尔、j .彼得斯。机器人学中的强化学习:综述。 Int。j .机器人。2013 年 7 月的决议。

[11] S. Levine、C. Finn、T. Darrell 和 P. Abbeel。深度视觉运动策略的端到端培训。arXiv 预印本 arXiv:1504.00702，2015。

[12]西尔弗、a .黄、a .、C.J .、A. Guez、L. Sifre、G. van den Driessche、J. Schrittwieser、I. Antonoglou、V. Panneershelvam、M. Lanctot、S. Dieleman、D. Grewe、J. Nham、N. Kalchbrenner、I. Sutskever、T. Lillicrap、M. Leach、K. Kavukcuoglu、T. Graepel 和 D. Has-sabis。用深度神经网络和树搜索掌握围棋。自然，529(7587)。2016.

[13]西尔弗、施里特维泽、西蒙扬、安托诺格鲁、黄、古埃斯、休伯特、贝克、赖、博尔顿、陈、利利卡普、许、西弗尔、范登德里斯切、格雷佩尔和哈萨比斯。在没有人类知识的情况下掌握围棋。《自然》，2017。

情感分析在商业中的应用

原文：https://towardsdatascience.com/applications-of-sentiment-analysis-in-business-b7e660e3de69?source=collection_archive---------6-----------------------

商业中的情感分析，也称为意见挖掘，是根据一段文本所传达的语气对其进行识别和分类的过程。这些文字可以是推文、评论、反馈，甚至是带有积极、消极和中性情绪的随机咆哮。每个企业都需要实施自动化情感分析。如果你怀疑，这里有一个小小的视角。准确率永远不可能是 100%。当然，机器不理解讽刺。然而，根据一项研究，人们不同意 80%的时间。这意味着，即使机器精度没有得到完美的 10 分，它仍将比人类分析更准确。此外，当语料库庞大时，手动分析不是一个选项。因此，商业情感分析不仅仅是一种趋势。

情感分析在商业中的作用:

情感分析在商业中的应用不容忽视。商业中的情感分析可以证明是全面品牌振兴的一个重大突破。利用情感数据成功经营企业的关键是能够利用非结构化数据获得可操作的见解。机器学习模型在分类前很大程度上依赖于人工创建的特征，在过去几年中很好地服务于这一目的。然而，深度学习是更好的选择，因为它:

自动提取相关特征。
有助于去除多余的功能。
排除了手工制作特征的努力。

在 ParallelDots，我们有强大的情感分析 API，它使用深度学习对给定文本的整体情感进行准确分析。

接下来是企业如何利用情绪分析数据:

商业智能构建中的情感分析；

拥有见解丰富的信息消除了猜测和及时决策的执行。有了关于你已有产品和新产品的情感数据，估计你的客户保持率就更容易了。基于商业中通过情感分析产生的评论，你可以随时调整以适应当前的市场形势，并以更好的方式满足你的客户。总的来说，您可以通过自动化洞察立即做出决策。商业智能就是始终保持动态。拥有情感数据给了你这种自由。如果你有了一个伟大的想法，你可以在实现它之前测试它。这就是所谓的概念测试。无论是新产品、活动还是新 logo，只要把它放到概念测试中，分析它所附带的情绪就可以了。

商业竞争优势中的情感分析:

如果你真的赶上了情感分析在商业中的应用，你应该有策略地尝试它。就像我之前提到的，情感分析可以在任何文本上进行。那么，为什么仅仅满足于将它应用于你的品牌呢？如果你没有一个 y%的指标与之比较，那么在某个产品上获得 x%的负面或正面评价是没有多大意义的。了解竞争对手的情绪数据会给你机会和动力来提升你的表现。商业情感分析对预测客户趋势非常有帮助。一旦你熟悉了当前的客户趋势，就可以很容易地开发出利用这些趋势的策略。并最终在竞争中获得领先优势。

通过商业情感分析提升客户体验:

一家企业依靠顾客的满意来生存。顾客的体验可以是正面的、负面的或中性的。由于互联网时代的到来，这种体验变成了他们社交帖子和在线反馈的文本。可以检测这些数据的语气和气质，然后根据附加的情感进行分类。这有助于了解在产品、服务和客户支持方面正确实施了什么，以及需要改进什么。

对你的产品获得积极的回应并不总是足够的。无论你的服务有多出色，你公司的客户支持系统都应该是无可挑剔的。

48 小时锁定退出@ Snapchat和@ Snapchat support仍未响应。这非常令人失望。#客户支持#不支持

**—蔡斯·莱帕德(@蔡斯·莱帕德)2016 年 12 月 10 日

商业情感分析促进品牌活力:

品牌不是由它制造的产品或提供的服务来定义的。建立一个品牌的名字和名气主要取决于他们的在线营销、社会活动、内容营销和客户支持服务。商业情感分析有助于量化当前和潜在客户对所有这些因素的看法。将负面情绪保留在知识中，你可以开发更吸引人的品牌技术和营销策略，从迟钝转变为了不起的品牌地位。商业中的情感分析可以帮助你快速转变。

情感分析在商业中的应用非常广泛。通过情绪分析获得更大的商业价值取决于你使用什么工具，以及你如何利用它。

对使用人工智能感兴趣？你现在可以免费注册账号，使用触手可及的人工智能。

应用深度学习-第 1 部分:人工神经网络

原文：https://towardsdatascience.com/applied-deep-learning-part-1-artificial-neural-networks-d7834f67a4f6?source=collection_archive---------0-----------------------

概观

欢迎来到应用深度学习教程系列。我们将从人工神经网络(ANN)开始，特别是前馈神经网络，对几种深度学习技术进行详细分析。本教程与您可以在网上找到的其他教程的不同之处在于，我们将采用一种带有大量代码示例和可视化的实践方法。为了将重点放在应用上，我不会深入这些模型背后的太多数学和理论。

我们将使用 Keras 深度学习框架，它是 Tensorflow 之上的高级 API。Keras 最近变得超级流行，因为它很简单。建立复杂的模型并快速迭代是非常容易的。我也用了准系统 Tensorflow，实际上很费劲。试用过 Keras 之后，我就不回去了。

这是目录。首先对 ANN 和这些深度模型背后的直觉进行概述。那么我们就从简单的 Logistic 回归开始，主要是为了熟悉 Keras。然后我们将训练深度神经网络，并演示它们如何优于线性模型。我们将比较二元和多类分类数据集上的模型。

安概述
1.1)简介
1.2)直觉
1.3)推理
逻辑回归
2.1)线性可分数据
2.2)复杂数据-月亮
2.3)复杂数据-圆
人工神经网络(ANN) 3.1)复数数据-月亮
3.2)复数数据-圆
3.3)复数数据-正弦波
多类分类 4.1) Softmax 回归
4.2)深安
结论

这篇文章的代码可以在这里获得作为一个 Jupyter 笔记本，请随意下载并亲自试用。

我想你会从这篇文章中学到很多。你不需要有深度学习的先验知识，只需要对一般的机器学习有一些基本的熟悉。所以让我们开始吧…

1.人工神经网络概述

1.1)简介

人工神经网络(ANN)是多层全连接神经网络，如下图所示。它们由一个输入层、多个隐藏层和一个输出层组成。一层中的每个节点都与下一层中的所有其他节点相连。我们通过增加隐藏层的数量使网络更深。

Figure 1

如果我们放大到一个隐藏或输出节点，我们将看到下图。

Figure 2

给定节点获取其输入的加权和，并将其传递给非线性激活函数。这是节点的输出，然后成为下一层中另一个节点的输入。信号从左向右流动，通过对所有节点执行该过程来计算最终输出。训练这个深度神经网络意味着学习与所有边相关联的权重。

给定节点的等式如下。通过非线性激活函数的输入的加权和。它可以表示为矢量点积，其中 n 是节点的输入数。

为了简单起见，我省略了偏差项。Bias 是所有节点的输入，其值始终为 1。它允许向左或向右移动激活功能的结果。它还有助于模型在所有输入特征都为 0 时进行训练。如果这听起来很复杂，你可以放心地忽略偏见条款。为了完整起见，上面的等式包括了偏差，如下所示。

到目前为止，我们已经描述了正向传递，这意味着给定一个输入和权重，如何计算输出。训练完成后，我们只运行正向传递来进行预测。但是我们首先需要训练我们的模型来实际学习权重，训练过程如下:

随机初始化所有节点的权重。我们将在另一篇文章中探讨一些智能初始化方法。
对于每个训练示例，使用当前权重执行向前传递，并从左到右计算每个节点的输出。最终输出是最后一个节点的值。
将最终输出与训练数据中的实际目标进行比较，并使用损失函数测量误差。
从右到左执行反向传递，并使用反向传播将错误传播到每个节点。计算每个权重对误差的影响，并使用梯度下降相应调整权重。从最后一层开始往回传播误差梯度。

梯度下降的反向传播实际上是深度学习模型背后的“魔法”。这是一个相当长的话题，涉及到一些微积分，所以我们不会在这个应用深度学习系列中深入讨论细节。关于梯度下降的详细说明，请参考此处的。反向传播的基本概述可以在这里找到。有关详细的数学处理，请参考此处的和此处的和。更多高级优化算法请参考这里的。

在标准的 ML 世界中，这种前馈架构被称为多层感知器。人工神经网络和感知器的区别在于，人工神经网络使用非线性激活函数，如 sigmoid ，而感知器使用阶跃函数。这种非线性赋予了人工神经网络更大的能力。

1.2)直觉

已经发生了很多事情，即使是基本的向前传球。现在我们来简化一下，理解一下背后的直觉。

本质上，人工神经网络的每一层所做的是输入从一个向量空间到另一个向量空间的非线性变换。

让我们以上面图 1 中的人工神经网络为例。我们有一个对应于 3D 空间中一个矢量的三维输入。然后，我们通过两个隐藏层传递它，每个隐藏层有 4 个节点。并且最终输出是 1D 矢量或标量。

因此，如果我们将此视为一系列矢量变换，我们首先将 3D 输入映射到 4D 矢量空间，然后执行另一个到新 4D 空间的变换，最后的变换将它简化为 1D。这只是一个矩阵乘法链。正向传递执行这些矩阵点积，并将激活函数逐元素应用于结果。下图仅显示了正在使用的权重矩阵(非激活)。

Figure 3

输入向量 x 有 1 行 3 列。为了将其转换到 4D 空间，我们需要将其乘以一个 3x4 矩阵。然后到另一个 4D 空间，我们乘以一个 4x4 矩阵。最后，为了将它简化到 1D 空间，我们使用了一个 4×1 的 T21 矩阵。

请注意矩阵的维度如何表示层的输入和输出维度。具有 3 个节点和 4 个节点的层之间的连接是使用 3x4 矩阵的矩阵乘法。

这些矩阵代表定义人工神经网络的权重。为了使用 ANN 对给定的输入进行预测，我们只需要知道这些权重和激活函数(以及偏差)，仅此而已。我们通过反向传播训练人工神经网络来“学习”这些权重。

如果我们把所有东西放在一起，它看起来像下图。

Figure 4

一个 3 个节点和 4 个节点之间的全连通层，就是 1x3 输入向量(黄色节点)和 3x4 权重矩阵 W1 的矩阵相乘。这个点积的结果是一个表示为蓝色节点的 1x4 向量。然后我们将这个 1x4 向量乘以一个 4x4 矩阵 W2，得到一个 1x4 向量，即绿色节点。最后，使用一个 4x1 矩阵 W3 得到输出。

为了简单起见，我们在上面的图中省略了激活功能。实际上，在每次矩阵乘法之后，我们将激活函数应用于结果矩阵的每个元素。更正式地说

Equation 2

矩阵乘法的输出通过激活函数 f 。对于 sigmoid 函数，这意味着取矩阵中每个元素的 sigmoid。我们可以在方程中更清楚地看到矩阵乘法链。

1.3)推理

到目前为止，我们讨论了什么是深度模型以及它们是如何工作的，但是为什么我们首先需要深入呢？

我们看到，人工神经网络层只是对其输入进行从一个向量空间到另一个向量空间的非线性变换。如果我们以一个分类问题为例，我们希望通过绘制一个决策边界来区分各个类别。给定形式的输入数据是不可分离的。通过在每一层执行非线性变换，我们能够将输入投影到新的向量空间，并绘制复杂的决策边界来分离类别。

让我们用一个具体的例子来形象化我们刚刚描述的内容。给定以下数据，我们可以看到它不是线性可分的。

所以我们通过进行非线性变换，把它投影到一个更高维的空间，然后它就变成线性可分的了。绿色超平面是决策边界。

这相当于在原始输入空间中画了一个复杂的决策边界。

因此，拥有更深入的模型的主要好处是能够对输入进行更多的非线性转换，并绘制更复杂的决策边界。

总之，人工神经网络是非常灵活而强大的深度学习模型。它们是通用函数逼近器，这意味着它们可以模拟任何复杂的函数。最近，由于几个原因，它们的受欢迎程度出现了令人难以置信的飙升:使训练这些模型成为可能的巧妙技巧，计算能力的巨大增长，特别是 GPU 和分布式训练，以及大量的训练数据。所有这些结合在一起，使得深度学习获得了巨大的牵引力。

这是一个简单的介绍，网上有很多很棒的教程，涵盖了深度神经网络。作为参考，我强烈推荐这篇论文。这是对深度学习的精彩概述，第 4 部分涵盖了 ANN。另一个很好的参考是这本书，可以在网上找到。

2.逻辑回归

尽管名字如此，逻辑回归(LR)是一种二元分类算法。这是最流行的 0/1 分类技术。在二维(2D)数据上，LR 将试图画一条直线来区分类别，这就是术语线性模型的来源。不过 LR 可以处理任意数量的维度，而不仅仅是二维。对于 3D 数据，它会尝试绘制一个 2D 平面来分隔类别。这推广到 N 维数据和 N-1 维超平面分隔符。如果您有一个监督二进制分类问题，给定一个具有多列的输入数据和一个二进制 0/1 结果，LR 是第一个尝试的方法。在本节中，我们将重点关注 2D 数据，因为它更容易可视化，在另一个教程中，我们将重点关注多维输入。

1.1)线性可分离数据

首先让我们从一个简单的例子开始。2D 线性可分数据。我们使用 scikit-learnmake _ classification方法来生成数据，并使用一个辅助函数来可视化数据。

scikit-learn 中提供了一个 LogisticRegression 分类器，我在这里就不赘述了，因为我们的目标是学习用 Keras 构建模型。但这里是如何训练一个 LR 模型，使用 fit 函数，就像 scikit-learn 中的任何其他模型一样。我们将线性决策边界视为绿线。

正如我们所见，数据是线性可分的。我们现在将使用 Keras 训练相同的逻辑回归模型来预测每个输入点的类成员。为了简单起见，我们现在不执行将数据分离到训练集和测试集的标准实践，或者执行 k-fold 交叉验证。

Keras 有很棒的文档，查看它的 API 的更详细描述。这是训练模型的代码，下面我们一步一步来看。

我们将使用顺序模型 API，此处可用。顺序模型允许我们通过一层一层地堆叠来建立深度神经网络。由于我们现在正在构建一个简单的逻辑回归模型，我们将输入节点直接连接到输出节点，没有任何隐藏层。注意，LR 模型具有形式 y=f(xW) ，其中 f 是 sigmoid 函数。将单个输出层直接连接到输入反映了这一功能。

快速澄清以消除所用术语的歧义。在神经网络文献中，经常谈到输入节点和输出节点。乍一看，这听起来可能很奇怪，输入“节点”本身是什么？当我们说输入节点时，我们谈论的是给定训练示例的特征。在我们的例子中，我们有 2 个特征，即我们上面绘制的点的 x 和 y 坐标，因此我们有 2 个输入节点。你可以简单地把它想成两个数的向量。那么输出节点呢？逻辑回归模型的输出是一个单一数字，即属于类别 1 的输入数据点的概率。换句话说 P(class=1) 。属于类别 0 的输入点的概率为 P(类别= 0)= 1p(类别=1) 。因此，您可以简单地将输出节点视为一个 0 到 1 之间的单个数字(或简单的标量)的向量。

在 Keras 中，我们不添加对应于输入节点的层，我们只添加隐藏和输出节点。在我们当前的模型中，我们没有任何隐藏层，输入节点直接连接到输出节点。这意味着我们在 Keras 中的神经网络定义将只有一个层和一个节点，对应于输出节点。

model = Sequential()
model.add(Dense(units=1, input_shape=(2,), activation='sigmoid'))

Keras 中的 Dense 函数构建了一个完全连接的神经网络层，自动将权重初始化为偏差。这是一个超级有用的功能，你会看到它在任何地方都被使用。函数参数定义如下:

单位:第一个参数，表示该层的节点数。由于我们正在构建输出层，并且我们说它只有一个节点，因此该值为 1。
input _ shape:Keras 模型中的第一层需要指定输入尺寸。后续层(这里没有，但我们将在后面的部分中)不需要指定此参数，因为 Keras 可以自动推断尺寸。在这种情况下，我们的输入维度是 2，x 和 y 坐标。input_shape 参数需要一个向量，所以在我们的例子中，它是一个只有一个数字的元组。
激活:逻辑回归模型的激活函数是逻辑函数，或者称为 sigmoid 。我们将在另一个教程中探索不同的激活函数，在哪里使用它们以及为什么使用它们。

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

然后我们用编译函数编译这个模型。这通过指定学习过程的细节来创建神经网络模型。模型还没有训练好。现在我们只是声明要使用的优化器和要最小化的损失函数。编译函数的参数定义如下:

优化器:使用哪个优化器来最小化损失函数。有很多不同的优化器，大多数都是基于梯度下降的。我们将在另一个教程中探索不同的优化器。现在我们将使用 adam 优化器，这是默认情况下人们更喜欢使用的一种。
损失:最小化的损失函数。由于我们正在构建一个二进制 0/1 分类器，要最小化的损失函数是 binary_crossentropy 。我们将在后面的章节中看到损失函数的其他例子。
指标:报告统计数据的指标，对于分类问题，我们将其设置为准确度。

history = model.fit(x=X, y=y, verbose=0, epochs=50)

现在有趣的部分来了，使用 fit 函数实际训练模型。论据如下:

x :输入数据，我们定义为上面的 X 。它包含输入点的 x 和 y 坐标
y :不要与输入点的 y 坐标混淆。在所有的 ML 教程中, y 指的是标签，在我们的例子中是我们试图预测的类:0 或 1。
verbose :打印出损耗和精度，设置为 1 查看输出。
次数:查看整个训练数据的次数。当训练模型时，我们不止一次而是多次传递训练数据。

plot_loss_accuracy(history)

拟合方法的输出是每个时期的损失和精度。然后，我们使用自定义函数绘制它，可以看到损耗随着时间的推移下降到几乎为 0，而精度上升到几乎为 1。太好了！我们已经成功地用 Keras 训练了我们的第一个神经网络模型。我知道这是一个很长的解释，但我想第一次详细解释我们在做什么。一旦你明白发生了什么，并练习几次，所有这些都成为第二天性。

下面是一个决策边界图。蓝色和红色的不同阴影表示该区域中某个假想点属于 1 级或 0 级的概率。左上区域被分类为 1 类，颜色为蓝色。右下方区域被分类为 0 类，颜色为红色。在决策边界附近有一个过渡。这是可视化模型正在学习的决策边界的一种很酷的方式。

分类报告显示了我们模型的精度和召回率。我们接近 100%的准确率。报告中显示的值应该是 0.997，但它被四舍五入为 1.0。

混淆矩阵向我们展示了有多少类被正确分类和错误分类。对角线轴上的数字代表正确分类的点的数量，其余的是错误分类的点。这个特殊的矩阵不是很有趣，因为模型只错误分类了 3 个点。我们可以在混淆矩阵的右上角看到一个错误分类的点，真实值为 0 类，但预测值为 1 类。

2.2)复杂数据-卫星

以前的数据集是线性可分的，所以我们的逻辑回归模型分离类是微不足道的。这是一个更复杂的数据集，它不是线性可分的。简单的逻辑回归模型无法清楚地区分这些类别。我们使用 scikit-learn 的 make_moons 方法来生成数据。

让我们建立另一个逻辑回归模型，使用与之前相同的参数。在这个数据集上，我们得到了 86%的准确率。

当前的决策边界看起来不像以前那样清晰。该模型试图从中间分离出类，但有许多错误分类的点。我们需要一个具有非线性决策边界的更复杂的分类器，我们很快就会看到这样的例子。

模型的精度为 86%。它在纸上看起来不错，但我们应该很容易用更复杂的模型得到 100%。您可以想象一个弯曲的决策边界来分隔这些类，一个复杂的模型应该能够近似这一点。

分类报告和混淆矩阵如下所示。

2.3 复杂数据圈

让我们看最后一个例子，线性模型会失败。这次使用 scikit-learn 中的 make_circles 功能。

用相同的参数建立模型。

决策边界再次从数据的中间通过，但是现在我们有更多的错误分类的点。

准确率在 50%左右，如下图。由于数据集的性质，无论模型在哪里画线，都会对一半的点进行错误分类。

我们在这里看到的混淆矩阵是一个属于差分类器的例子。理想情况下，我们更希望混淆矩阵看起来像上面看到的那样。对角线上的高数字表示分类器是正确的，而其他地方的低数字表示分类器是错误的。在我们的视觉中，蓝色代表大的数字，黄色代表小的数字。所以我们更喜欢在对角线上看到蓝色，在其他地方看到黄色。到处都是蓝色是不好的迹象，意味着我们的分类器是混乱的。

无论输入是什么，总是预测 1 的最简单的方法将获得 50%的准确性。我们的模型也得到了 50%的准确率，所以一点用都没有。

3.人工神经网络

现在，我们将训练一个深度人工神经网络(ANN ),以更好地对逻辑回归模型难以处理的数据集，月亮和圆进行分类。我们还将对一个更难的正弦波数据集进行分类，以证明人工神经网络可以形成真正复杂的决策边界。

3.1)复杂数据-卫星

在为上述逻辑回归构建 Keras 模型时，我们执行了以下步骤:

步骤 1:定义一个顺序模型。
第二步:添加具有乙状结肠激活功能的致密层。这是我们需要的唯一一层。
步骤 3:用优化器和损失函数编译模型。
步骤 4:使模型适合数据集。
第五步:分析结果:绘制损失/准确性曲线，绘制决策边界，查看分类报告，了解混淆矩阵。

在构建深度神经网络时，我们只需要改变步骤 2，这样，我们将一个接一个地添加几个密集层。一层的输出成为下一层的输入。Keras 再次通过初始化权重和偏差来完成大部分繁重的工作，并将一层的输出连接到下一层的输入。我们只需要指定在给定的层中需要多少个节点，以及激活函数。就这么简单。

我们首先添加一个有 4 个节点和 tanh 激活函数的层。Tanh 是一个常用的激活函数，我们将在另一个教程中了解更多。然后，我们添加另一个层 2 节点再次使用双曲正切激活。我们最后添加最后一层 1 节点和 sigmoid 激活。这是我们在逻辑回归模型中使用的最后一层。

这不是一个很深的人工神经网络，它只有 3 层:2 个隐藏层，和输出层。但是请注意几个模式:

输出图层仍然使用 sigmoid 激活函数，因为我们正在处理二元分类问题。
隐藏层使用 tanh 激活功能。如果我们添加更多的隐藏层，他们也会使用 tanh 激活。我们有几个激活函数的选项:sigmoid、tanh、relu 和 relu 的变体。在另一篇文章中，我们将探讨每种方法的优缺点。我们还将演示为什么在隐藏层中使用 sigmoid 激活是一个坏主意。现在使用 tanh 是安全的。
我们在每个后续层中的节点数量更少。当我们将层堆叠在另一层之上时，通常会有较少的节点，有点像三角形。

我们没有在这里构建一个非常深的 ANN，因为这是不必要的。通过这种配置，我们已经实现了 100%的准确性。

人工神经网络能够提出一个完美的分隔符来区分类别。

100%精确，没有错误分类。

3.2)复杂的数据圈

现在让我们看看 Circles 数据集，其中 LR 模型仅达到 50%的准确率。模型同上，我们只使用当前数据集更改拟合函数的输入。我们再次达到了 100%的准确率。

类似地，决策边界看起来就像我们自己手绘的一样。人工神经网络能够找出最佳分离器。

就像上面一样，我们得到了 100%的准确性。

4.3)复杂数据-正弦波

让我们试着分类一个最终的玩具数据集。在前面的部分中，类可以通过一个连续的决策边界来分离。边界具有复杂的形状，它不是线性的，但是一个连续的判定边界就足够了。人工神经网络可以绘制任意数量的复杂决策边界，我们将演示这一点。

让我们创建一个正弦数据集，看起来像正弦函数，每个上下属于一个交替类。正如我们在图中看到的，一个单一的决策边界不能将类分开。我们需要一系列非线性分离器。

现在我们需要一个更复杂的模型来进行准确的分类。所以我们有 3 个隐藏层，和一个输出层。每层的节点数也有所增加，以提高模型的学习能力。选择正确的隐藏层和每层节点数是一门艺术，而不是科学，通常通过反复试验来决定。

人工神经网络能够模拟一组相当复杂的决策界限。

精确度是 99%，我们只有 2400 个错误分类点中的 14 个。非常好。

4.多类分类

在前面的章节中，我们研究了二元分类。现在，我们将研究一个多类分类问题，其中类的数量超过 2。我们将挑选 3 个类进行演示，但是我们的方法可以推广到任意数量的类。

这是我们的数据集的样子，螺旋数据有 3 个类，使用 scikit-learn 中的 make_multiclass 方法。

4.1) Softmax 回归

正如我们在上面看到的，逻辑回归(LR)是两类的分类方法。它适用于二进制标签 0/1。Softmax 回归(SR)是 LR 的一种推广，其中我们可以有两个以上的类。在我们当前的数据集中，我们有 3 个类，表示为 0/1/2。

为 SR 构建模型与 LR 非常相似，下面是我们如何构建逻辑回归模型的参考。

这就是我们将如何建立 Softmax 回归模型。

有几个不同之处，让我们一个一个来看:

密集层中的节点数:LR 使用 1 个节点，而 SR 有 3 个节点。因为我们有 3 个类，所以 SR 使用 3 个节点是有意义的。那么问题是，为什么 LR 只使用 1 个节点，它有 2 个类，所以看起来我们应该使用 2 个节点。答案是肯定的，因为我们只用一个节点就可以达到同样的效果。正如我们在上面看到的，LR 对属于第一类的例子的概率建模: P(class=1) 。我们可以通过1p(class = 1)计算 0 类概率。但是当我们有两个以上的类时，我们需要每个类有单独的节点。因为知道一类的概率并不能让我们推断出其他类的概率。
激活功能:LR 使用了 sigmoid 激活功能，SR 使用了 softmax 。Softmax 缩放输出节点的值，以便它们表示概率并且总和为 1。所以在我们的例子中P(class = 0)+P(class = 1)+P(class = 2)= 1。它不是用简单的方法，用个体概率除以总和，而是用指数函数。因此，较高的值得到更多的强调，较低的值受到更多的压制。我们将在另一个教程中详细讨论 softmax 的功能。现在，你可以简单地把它想成一个归一化函数，让我们把输出值解释成概率。
损失函数:在 LR 这样的二元分类问题中，损失函数是 binary_crossentropy。在多类情况下，损失函数是分类交叉熵。范畴交叉熵是二元交叉熵在两个以上类别上的推广。深入损失函数背后的理论超出了本教程的范围。但是现在只知道这个属性就足够了。
Fit 函数:LR 在 fit 函数中直接使用了向量 y，该函数只有一列值为 0/1。当我们进行 SR 时，标签需要以一键表示。在我们的例子中，y_cat 是一个有 3 列的矩阵，其中所有的值都是 0，除了代表我们的类的值是 1。

花了一些时间来谈论 LR 和 SR 之间的所有差异，看起来有很多东西需要消化。但是再一次经过一些练习后，这将成为一种习惯，你甚至不需要考虑这些。

在所有这些理论之后，让我们后退一步，记住 LR 是一个线性分类器。SR 也是一个线性分类器，但是针对多个类。所以模型的“力”没有变，还是线性模型。我们只是推广了 LR，将其应用于多类问题。

训练模型给了我们 50%左右的准确率。无论输入是什么，总是预测类别 1 的最简单的方法将具有 33%的准确度。SR 模型并没有太大的改进。这是意料之中的，因为数据集不是线性可分的。

查看决策边界可以确认我们仍然有一个线性分类器。由于浮点舍入，这些线看起来参差不齐，但实际上它们是直的。

这是对应于 3 个类的精度和召回率。混乱矩阵到处都是。显然，这不是一个最佳的分类器。

4.2)深安

现在让我们为多类分类建立一个深度人工神经网络。记住从 LR 到 ANN 的变化是很小的。我们只需要增加更密集的层。我们将再次这样做。添加几个具有 tanh 激活功能的致密层。

请注意，输出层仍有 3 个节点，并使用 softmax 激活。损失函数也没变，还是分类 _ 交叉熵。从线性模型到深度人工神经网络，这些不会改变，因为问题的定义没有改变。我们仍在研究多类分类。但是现在使用一个更强大的模型，这种力量来自于给我们的神经网络增加更多的层。

我们在几个时期内就达到了 99%的准确率。

决策边界是非线性的。

我们得到了几乎 100%的准确率。1500 分中我们完全错分了 5 分。

5)结论

感谢您花时间阅读这篇文章，我知道这是一篇关于人工神经网络和 Keras 的相当长的教程。我想尽可能详细，同时保持文章长度可控。我希望你喜欢它。

这篇文章中有一个共同的主题，即我们首先介绍这个任务，然后使用一个简单的方法来完成它，并观察它的局限性。后来我们用一个更复杂的深度模型对它进行了改进，得到了更好的结果。我认为顺序很重要。没有一个复杂的方法是成功的，除非它是从一个简单的模型发展而来。

如果你想自己动手，这篇文章的全部代码可以在这里找到。如果你有任何反馈，请随时通过推特联系我。

应用深度学习-第 2 部分:真实世界案例研究

原文：https://towardsdatascience.com/applied-deep-learning-part-2-real-world-case-studies-1bb4b142a585?source=collection_archive---------0-----------------------

概观

欢迎来到应用深度学习系列的第 2 部分。第 1 部分是对人工神经网络的实际介绍，包括理论和应用，有很多代码示例和可视化。现在是最酷的部分，深度学习对真实世界数据集的端到端应用。我们将涵盖 3 个最常见的问题作为案例研究:二元分类，多类分类和回归。

案例分析:二元分类 1.1)数据可视化&预处理
1.2) Logistic 回归模型
1.3) ANN 模型
1.4)深层 ANN 可视化
案例分析:多类分类 2.1)数据可视化&预处理
2.2) Softmax 回归模型
2.3) ANN 模型
2.4)交叉验证
案例分析:回归 3.1)数据可视化&预处理
3.2)线性回归模型
3.3) ANN 模型
结论

这篇文章的代码可以从这里得到作为一个 Jupyter 笔记本，你可以随意下载并亲自试用。

1.案例研究:二元分类

我们将在 Kaggle 上使用人力资源分析数据集。我们试图根据各种特征来预测员工是否会离开，例如他们参与的项目数量、在公司呆的时间、上次绩效评估、工资等。数据集大约有 15，000 行和 9 列。我们试图预测的列称为“左”。这是一个具有 0/1 值的二进制列。标签 1 表示该员工已经离职。

1.1)数据可视化和预处理

首先，让我们在直接构建模型之前执行一些数据可视化和预处理。这一部分是至关重要的，因为我们需要知道我们正在处理什么类型的特性。对于每个 ML 任务，我们至少需要回答以下问题:

我们有什么类型的特征:实值的，分类的，还是两者都有？
是否有任何功能需要规范化？
我们有空值吗？
标签分布是怎样的，阶层不平衡吗？
特征之间有关联吗？

朱庇特笔记本包含了详细的分析。综上所述，既有真实特征，也有分类特征。没有空值，但有些要素需要规范化。76%的例子被标为 0，意味着员工没有离开。

让我们检查特征与标签的相关性(名为“left”的列)。我们将使用 seaborn 包来绘制相关图。

在该图中，正值表示与标签的相关性，负值表示与标签的反向相关性。当然“左”和它本身有很好的相关性，你可以忽略它。除此之外，只有一个特征有很强的信号，那就是“满意度”,与员工是否已经离职成反比。这很有道理。

现在，让我们来看看所有特性之间的成对相关性。

我们看到“平均 _ 月 _ 小时”与“数字 _ 项目”正相关，这也是有道理的。一个人参与的项目越多，需要投入的工作时间就越多。

现在我们来看看特征值的分布。通过检查特征的直方图，我们可以看到哪些特征需要归一化。这背后的动机是什么？规范化是什么意思，为什么需要规范化？如果实值特征被缩放到预定义的范围内，例如[0，1]，大多数 ML 算法执行得更好。这对深度神经网络尤为重要。如果输入特征由大值组成，深度网络真的很难学习。原因在于，随着数据流经各层，伴随着所有的乘法和加法运算，数据会很快变大，这会使非线性饱和，从而对优化过程产生负面影响。我们将在另一篇文章中看到这方面的详细演示，因为现在我们需要注意特征值是小数字。

查看特征直方图，我们需要对其中的 3 个特征进行归一化:average_monthly_hours、number_project 和 time_spend_company。所有其他特征都在[0，1]内，所以我们可以不去管它们。

Scikit-learn 有几种归一化方法，我们将使用的是标准缩放器。它单独缩放要素，使其具有零均值和单位方差，因此它们都属于标准的正态(0，1) 分布。请注意，这不会改变特征值的顺序，只是改变了比例。这是一个简单却极其重要的技巧。

我们加载的数据在一个熊猫数据帧中。Pandas 是一个非常流行的处理表格数据的软件包，尤其是在像 jupyter 笔记本这样的交互式环境中。DataFrame 是 pandas 最常用的数据结构，它充当了我们数据的容器，并公开了几个内置函数，使我们的生活更加轻松(查看笔记本了解更多详细信息)。在下面的代码片段中，df 是我们数据的数据帧。

Scikit-learn API 设计得非常好，包含 4 个非常常用的方法。预测器是像逻辑回归这样的 ML 模型，转换器是像标准定标器这样的数据操纵器。

fit : For 预测器对给定输入进行训练。For transformers 计算统计数据，如稍后要使用的输入的平均值和标准偏差。
transform:For transformers 使用 fit 函数学习到的统计数据处理输入数据。我们在 fit 之后运行 transform 方法，因为存在依赖关系。预测者不支持这种方法。
fit_transform :在一次调用中高效地执行 fit + transform。对于转换器，计算输入的统计信息并执行转换。这是变压器常用的方法。对于预测器，训练模型并对给定输入执行预测。
预测:顾名思义，for predictors 使用用 fit 方法训练的模型来执行预测任务。非常常用于预测。变形金刚不支持这种方法。

既然我们已经将实值特征调整到了理想的范围内，那么让我们来处理分类特征。我们需要将分类数据转换成独热表示。例如，薪金列包含 3 个唯一的字符串值:低、中、高。一键转换后，我们将有 3 个新的二进制列:薪水 _ 低，薪水 _ 中和薪水 _ 高。对于给定的示例，它们中只有一个具有值 1，其他的都是 0。然后我们将删除原来的薪水栏，因为我们不再需要它了。

一键转换由熊猫的 get_dummies 执行。我们也可以在 scikit-learn 中使用onehotencode，它们都可以完成工作。因为我们的数据已经在熊猫的数据框架中，所以得到虚拟模型更容易。它还自动执行特征的重命名。

现在是创建训练和测试数据的最后一部分。该模型将在训练集上执行学习，并在保留的测试集上进行评估。Scikit-learn 有一个方便的 train_test_split 函数。我们只需要指定测试集的一部分，在我们的例子中是 30%。但是首先我们使用数据帧的 values 属性将数据从 pandas 数据帧转换为 numpy 数组。

1.2)逻辑回归模型

既然我们已经完成了数据预处理和训练/测试集生成，那么有趣的部分来了，训练模型。我们首先从一个简单的模型开始，逻辑回归(LR)。然后，我们将训练深度人工神经网络，并将结果与 LR 进行比较。

看完第一篇文章，构建模型应该很熟悉了。

我们得到了 79%的训练准确率。这实际上很糟糕，因为上面我们看到 76%的标签是 0。所以不管输入是什么，最简单的分类器总是输出 0，它能得到 76%的准确率，我们也没有比这更好的了。这意味着我们的数据不是线性可分的，就像我们在第一篇文章中看到的例子一样，我们需要一个更复杂的模型。

上图描述了训练损失和准确性。但更重要的是，我们对测试集的指标感兴趣。训练集中的度量标准可能会产生误导，因为模型已经在其上进行了训练，我们希望检查模型在保留的测试集上的表现。测试准确率为 78%，略低于训练准确率。ML 模型的测试精度几乎总是低于训练精度，因为在训练过程中测试数据对模型是不可见的。查看分类报告，我们看到属于类别 1 的示例中只有 60%被正确分类。相当糟糕的表现。混淆矩阵显示了许多错误分类的例子，看起来也不乐观。

1.3)人工神经网络模型

现在让我们建立一个深度神经网络进行二分类。这个模型将更加强大，能够模拟非线性关系。

模型构建过程也是非常熟悉的。我们有 2 个 64 和 16 节点的隐藏层，带有双曲正切函数。输出层使用 sigmoid 激活，因为这是一个二元分类问题。我们使用 Adam 优化器，学习率设置为 0.01。

这次我们达到了 97.7%的训练准确率，相当不错。

让我们比较一下 LR 和 ANN 模型。人工神经网络模型更优越，具有更低的损耗和更高的精度。

为了完整起见，这是测试集上人工神经网络模型的分类报告和混淆矩阵。与 LR 模型的 78%相比，我们实现了 97%的准确率。我们仍然对 4500 个例子中的 147 个进行了错误分类。

我们可以通过以下方法进一步提高人工神经网络的性能:

为模型定型更长时间(增加历元数)。
超参数调优:改变学习率，使用不同于 Adam 的优化器(比如 RMSprop)，使用不同于 tanh 的另一个激活函数(可以是 relu)。
增加每层的节点数量:我们可以增加到 128–64–1，而不是 64–16–1。
增加层数:我们可以做 128–64–32–16–1 层。

不过，一个重要的警告是，随着我们使模型更强大，训练损失可能会减少，准确性会增加。但是我们会遇到过度拟合的风险。这意味着与简单模型相比，复杂模型在测试集上的表现更差，即使复杂模型的训练指标更好。我们将在另一篇文章中更多地讨论过度拟合，但记住这一点非常重要。这就是为什么我们不会为层数和每层节点数而疯狂。完成工作的最简单的模型就足够了。

1.4)深层人工神经网络的可视化

在上一篇文章中，我们了解到人工神经网络的每一层都执行输入从一个向量空间到另一个向量空间的非线性转换。通过这样做，我们将输入数据投射到一个新的空间，在这个空间中，类可以通过一个复杂的决策边界相互分离。

让我们直观地演示一下。我们在上面做的初始数据预处理之后的输入数据是 20 维的。为了形象化，让我们把它投射到 2D。请记住，一个层中有 k 个节点意味着该层转换其输入，从而输出是一个 k 维向量。我们上面训练的 ANN 有两个隐藏层，分别是 64 和 16 个节点。然后，我们需要一个有两个节点的新层，以便将我们的数据投影到 2D 空间。因此，我们在输出节点之前添加了这个新层。其余的完全没动过。

这是我们的输入数据从 20D 到 2D 空间的投影结果。决策边界对应于 ANN 的最后一层。人工神经网络能够很好地区分这些类别，尽管有一些分类错误。在 2D，许多数据点重叠，因此我们无法看到所有数据点，作为参考，该模型在 4500 个数据点中错误分类了约 160 个点(96%的准确率)。我们不关心这个模型的准确性，我们感兴趣的是高维输入到 2D 的投影。这是一个巧妙的小技巧，直观地展示了人工神经网络执行的投影的结果。

一种更有原则的可视化方法是使用 t-SNE ，这是一种用于可视化高维数据的降维技术。详情请点击这里。

2.案例研究:多类分类

我们现在将在著名的虹膜数据集上执行多类分类。它包含 3 类花，每类 50 个例子。总共有 4 个功能。所以它很小，但是很受欢迎。数据如下所示。

2.1)数据可视化和预处理

这部分现在更容易了，因为我们只有 4 个实值特征。同样，我们将特征归一化到[0，1]之间。特征值很小，我们可以不进行任何规范化，但是这样做是一个好习惯，而且这样做也没有坏处。

如果我们有少量的特征，Pairplot 是一个很酷的可视化技术。我们可以看到按类(数据集中的“标签”列)着色的要素的成对分布。我们使用 seaborn 包，对于一个信息丰富的情节来说非常简单。

我们可以看到“setosa”类很容易分开，但“versicolor”和“virginica”更容易混合。

2.2) Softmax 回归模型

我们现在将训练 Softmax 回归(SR)模型来预测标签。前一篇文章包含了详细的解释，构建模型也与上面非常相似。主要区别在于，我们使用 softmax 激活和分类 _ 交叉熵作为损失。

SR 模型已经达到了 97%的训练准确率和最小的损失，已经很不错了。

2.3)人工神经网络模型

现在让我们建立我们的人工神经网络模型。我们添加 2 个隐藏层，分别有 32 个和 16 个节点。注意我们也改变了这些层的激活函数为 relu 而不是 tanh。我们将在另一个教程中探讨各种激活函数及其差异，但 relu 可以说是最受欢迎的一个。那为什么我们没有使用它？嗯，只是因为 tanh 激活后决策边界图看起来更漂亮。说真的，没别的原因。

这次我们获得了 100%的训练准确率。

另外，随机共振和人工神经网络模型的测试准确率都是 100%。这是一个非常小的数据集，所以这些结果并不奇怪。不是所有的问题都需要深度神经网络才能得到好的结果。对于这个问题来说，这可能有点过了，因为线性模型也能很好地工作。

2.4)交叉验证

对于像我们目前这样的小样本情况，进行交叉验证以获得更好的准确性估计尤为重要。通过 k 折交叉验证，我们将数据集分成 k 个不相交的部分，使用 k-1 个部分进行训练，另一个部分进行测试。这样，每个例子都会出现在训练集和测试集中。然后，我们对所有 k 次运行中的模型性能进行平均，并获得模型准确性的更好的低方差估计。

通常在训练深度学习模型时，我们不会执行 k-fold 交叉验证。因为训练需要很长时间，而且从头开始训练模型 k 次是不可行的。但由于我们的数据集很小，所以它是一个很好的候选对象。

这是两个模型的 5 倍交叉验证准确度的曲线图。深度模型表现稍好，具有更高的准确性和更低的方差。在图中，精度有时似乎超过 100%，但这是平滑曲线的人工产物。我们得到的最大准确度是 100%。

3.案例研究:回归

我们现在将研究一个回归问题，预测一个实值输出而不是离散的类成员。我们将使用华盛顿州卡格尔市金县的房屋销售数据集。大约有 21，000 行 20 个特征。我们试图预测的值是一个标记为“价格”的浮点数。

3.1)数据可视化和预处理

首先让我们看看特性分布

现在你知道该怎么做了，我们需要做特征标准化和分类。例如，与 squarefoot 相关的要素肯定需要进行规范化，因为值的范围以千计，并且像 zipcode 这样的要素需要进行分类。

我们还需要做一种新的预处理， bucketization 。例如，包含房屋建造年份(yr _ built)的要素的范围从 1900 年到 2015 年。我们当然可以把它分类，每一年都属于一个不同的类别，但这样的话，它会相当稀疏。如果我们在不丢失太多信息的情况下取消这个特性，我们会得到更多的信号。例如，如果我们使用 10 年时段，则[1950，1959]之间的年份将折叠在一起。知道这栋房子建于 20 世纪 50 年代而不是 1958 年就足够了。

受益于分桶的其他特征是房屋的纬度和经度。确切的坐标没那么重要，我们可以把坐标四舍五入到最近的公里。这样，特征值将更加密集和信息丰富。在存储桶化中使用哪个范围没有硬性规定，它们主要是通过反复试验来决定的。

我们需要做的最后一个转换是关于房子的价格，我们试图预测的价值。目前，它的价值在 7.5 万美元到 770 万美元之间。试图在如此大的规模和变化范围内进行预测的模型将非常不稳定。所以我们也把它标准化了。有关详细信息，请随时查看代码。

在所有的转换之后，我们从 20 个特性增加到 165 个。让我们检查一下每个特性与价格的相关性。

最相关的特征是平方英尺，这是意料之中的，越大的房子通常越贵。看看这个列表，这些特性是有意义的。一些邮政编码与价格高度相关，例如 98039 对应于麦地那，那是比尔盖茨居住的地方，也是美国最昂贵的社区之一。还有另一个邮政编码 98004，它与贝尔维尤更相关。那里有许多高层建筑和技术办公室，这使得价格最近大幅上涨。我以前住在那个街区，但后来它变得太无聊和昂贵，所以我搬家了:)

3.2)线性回归模型

这是我们第一次建立回归模型。就像逻辑回归是我们在分类问题中首先尝试的最简单的模型一样，线性回归是我们在回归问题中开始的模型。

记住逻辑回归的方程式是 y=f(xW) 其中 f 是 sigmoid 函数。线性回归简单地说就是 y=xW，没有激活函数。为了简单起见，我再次省略了偏差项。随着偏差的增加，它们分别变为 y=f(xW+b) 和 y=xW+b 。

这里提醒一下我们如何建立逻辑回归(LR)模型

这是线性回归模型(LinR)的代码

有 3 个主要区别:

LR 使用 sigmoid 激活函数，而 LinR 没有激活。
LR 使用 binary_crossentropy 损失函数，LinR 使用 mean_squared_error。
LR 也报告精度，但是精度不是回归问题的适用度量，因为输出是浮点数而不是类成员。

最重要的变化是损失函数均方误差 (MSE)。MSE 是用于回归的标准损失函数。公式很简单:

其中 y 为真值， ŷ 为预测值， n 为样本数。

我们还向 fit 函数传递了一个新的 validation_split 参数。它指定了在训练过程中用作保留验证集的训练数据部分，在我们的例子中是 20%。使用验证集，我们可以看到我们是否在训练中过度适应。但是不要混淆验证集和测试集。测试集是完全独立的，在训练过程中根本不会暴露给模型。

损失在最初几个时期减少，然后稳定下来。我们可能配置不足意味着我们的型号没有足够的容量，我们需要一个更复杂的型号。

这些是权重最高的前 10 个特征。分类邮政编码特征占主导地位。

3.3)人工神经网络模型

最后，让我们为回归建立一个人工神经网络。在前面的例子中，从线性模型到深度模型只涉及添加具有非线性激活函数的新层。这次也一样。

我们添加了 relu 激活的新层。损失图现在看起来很有趣。训练误差损失似乎仍在减少，但是验证误差在第 5 个时期之后开始增加。我们显然过度适应。人工神经网络正在记忆训练数据，这降低了它对验证集进行归纳的能力。

解决办法？有几种方法可以解决深度神经网络中的过拟合问题。大多数方法依赖于约束模型的容量。这可以通过例如限制重量、分享重量或者甚至在训练损耗达到稳定水平之前停止训练来实现。为了简洁起见，我们将使用最后一个，其余的将在另一篇文章中讨论。这意味着一旦确认损失停止改善，我们将简单地停止训练。这叫做提前停止，用 Keras 很容易实现。我们只需要修改对 fit 函数的调用，如下所示。如果两个时期的确认损失没有改善，我们停止训练。

验证损失在第 5 个时期停止改善，模型再等待 2 个时期，并在第 7 个时期完成训练。

LinR 模型的训练损失是 0.158，ANN 的损失是 0.086。我们比线性模型提高了 83%，相当不错。并且比较在测试集上的损失，LinR 模型得到 0.191，相比于 ANN 的 0.127，提高了 32%。下图比较了 LinR 与 ANN 的训练损失。

让我们做一个最后的比较，模型预测价格和实际价格之间的美元价值差异。最天真的模型总是预测训练集的平均价格(540，000 美元)，在测试集上相差 229，000 美元，非常糟糕。线性回归模型的误差为 87K，而深度人工神经网络的误差为 68K。人工神经网络比线性神经网络好 21%。

4)结论

我希望这是一篇信息丰富的文章。我试图用现实生活中的数据集演示深度学习在 3 个常见机器学习问题上的一步一步的应用。

详细讨论了数据预处理和可视化。尽管它们不是解决一个 ML 问题的有趣部分，并且经常被忽视，但是它们是极其重要的。就像第 1 部分一样，我们首先用一个简单的模型解决问题，然后使用深度神经网络来获得更好的结果。

如果你想自己动手，这篇文章的全部代码可以在这里找到。如果你有任何反馈，请随时通过推特联系我。

应用深度学习-第 3 部分:自动编码器

原文：https://towardsdatascience.com/applied-deep-learning-part-3-autoencoders-1c083af4d798?source=collection_archive---------0-----------------------

概观

欢迎来到应用深度学习系列的第 3 部分。第 1 部分是对人工神经网络的实际介绍，包括理论和应用，有很多代码示例和可视化。在第二部分中，我们将深度学习应用于真实世界的数据集，涵盖了 3 个最常见的问题作为案例研究:二分类、多类分类和回归。

现在我们将开始深入具体的深度学习架构，从最简单的开始:自动编码器。

简介
架构
实施
去噪自动编码器
稀疏自动编码器
用例
结论

这篇文章的代码可以从这里获得作为一个 Jupyter 笔记本，你可以随意下载并亲自试用。

1.介绍

自动编码器是一种特定类型的前馈神经网络，其输入与输出相同。他们将输入压缩成一个低维的码，然后从这个表示中重建输出。代码是输入的一个紧凑的“总结”或“压缩”，也称为潜在空间表示。

自动编码器由 3 个部分组成:编码器、代码和解码器。编码器压缩输入并产生代码，然后解码器仅使用该代码重建输入。

要构建一个自动编码器，我们需要三样东西:编码方法、解码方法和一个损失函数来比较输出和目标。我们将在下一节探讨这些。

自动编码器主要是一种降维(或压缩)算法，具有几个重要属性:

特定数据:自动编码器只能有意义地压缩数据，就像它们被训练的那样。因为它们学习特定于给定训练数据的特征，所以它们不同于像 gzip 这样的标准数据压缩算法。因此，我们不能指望一个经过手写数字训练的自动编码器来压缩风景照片。
有损:自动编码器的输出将不会与输入完全相同，它将是一个接近但降级的表示。如果你想要无损压缩，他们不是出路。
无监督的:为了训练一个自动编码器，我们不需要做任何花哨的事情，只需要向它扔原始输入数据。自动编码器被认为是一种无人监管的学习技术，因为它们不需要明确的标签来训练。但更准确地说，它们是自我监督的，因为它们从训练数据中生成自己的标签。

2.体系结构

让我们来探讨编码器、代码和解码器的细节。编码器和解码器都是全连接的前馈神经网络，本质上是我们在第一部分中提到的神经网络。代码是人工神经网络的单层，具有我们选择的维度。代码层中的节点数量(代码大小)是我们在训练自动编码器之前设置的一个超参数。

这是一个自动编码器的更详细的可视化。首先，输入通过编码器，这是一个完全连接的人工神经网络，以产生代码。具有类似 ANN 结构的解码器仅使用代码产生输出。目标是获得与输入相同的输出。注意，解码器架构是编码器的镜像。这不是一个要求，但这是典型的情况。唯一的要求是输入和输出的维数需要相同。中间的任何东西都可以玩。

在训练自动编码器之前，我们需要设置 4 个超参数:

代码大小:中间层的节点数。尺寸越小，压缩越大。
层数:自动编码器可以有多深就有多深。在上图中，我们在编码器和解码器中都有两层，没有考虑输入和输出。
每层的节点数量:我们正在开发的自动编码器架构被称为堆叠自动编码器，因为这些层是一个接一个堆叠的。通常堆叠的自动编码器看起来像一个“三明治”。每层的节点数量随着编码器的每个后续层而减少，并在解码器中增加。就层结构而言，解码器与编码器也是对称的。如上所述，这是不必要的，我们完全控制这些参数。
损失函数:我们或者使用均方误差或者二元交叉熵。如果输入值在范围[0，1]内，那么我们通常使用交叉熵，否则我们使用均方误差。欲了解更多详情，请查看此视频。

通过反向传播，自动编码器的训练方式与人工神经网络相同。查看第 1 部分的介绍了解更多关于神经网络如何被训练的细节，它直接应用于自动编码器。

3.履行

现在让我们为下面的架构实现一个自动编码器，编码器和解码器中的一个隐藏层。

我们将使用非常流行的 MNIST 数据集作为输入。它包含手写数字的黑白图像。

它们的大小是 28x28，我们用它们作为[0，1]之间的 784 个数字的向量。查看 jupyter 笔记本了解详情。

我们现在将使用 Keras 实现自动编码器。超参数为:隐层 128 个节点，码长 32，二进制交叉熵为损失函数。

这非常类似于我们工作过的人工神经网络，但是现在我们使用的是 Keras 函数式 API。有关详细信息，请参考本指南，但这里有一个快速比较。之前，我们使用顺序 API 添加层，如下所示:

model.add(Dense(16, activation='relu')) model.add(Dense(8, activation='relu'))

使用函数式 API，我们可以做到:

layer_1 = Dense(16, activation='relu')(input) layer_2 = Dense(8, activation='relu')(layer_1)

这种定义复杂模型的方式更加冗长，但是更加灵活。我们可以很容易地获取模型的一部分，例如只有解码器，然后用它工作。 Dense 方法的输出是一个可调用层，使用函数 API 我们为它提供输入并存储输出。一层的输出成为下一层的输入。使用顺序 API， add 方法隐式地为我们处理了这个问题。

注意，所有层都使用 relu 激活函数，因为这是深度神经网络的标准。最后一层使用 sigmoid 激活，因为我们需要输出在[0，1]之间。输入也在相同的范围内。

还要注意对拟合函数的调用，之前我们用人工神经网络做过:

model.fit(x_train, y_train)

但是现在我们知道了:

model.fit(x_train, x_train)

请记住，自动编码器的目标与输入相同。这就是我们提供训练数据作为目标的原因。

形象化

现在让我们想象一下我们的自动编码器如何重构它的输入。

我们简单地通过使用 Keras 的预测功能在测试集上运行自动编码器。对于测试集中的每一幅图像，我们得到自动编码器的输出。我们期望输出与输入非常相似。

他们确实非常相似，但不完全相同。我们可以在最后一个数字“4”中更清楚地注意到这一点。由于这是一个简单的任务，我们的自动编码器表现得相当好。

建议

我们完全控制了自动编码器的架构。我们可以通过增加层数、每层节点数以及最重要的代码大小来使它变得非常强大。增加这些超参数将让自动编码器学习更复杂的编码。但是我们应该小心不要让它太强大。否则，自动编码器将简单地学习将其输入复制到输出，而不学习任何有意义的表示。它将只是模仿身份功能。自动编码器将完美地重建训练数据，但是它将过度拟合，而不能推广到新的实例，这不是我们想要的。

这就是为什么我们更喜欢“三明治”架构，并有意保持代码较小。由于编码层比输入数据具有更低的维度，所以自动编码器被称为欠完成。它将无法直接将其输入复制到输出，并将被迫学习智能特性。如果输入数据具有某种模式，例如数字“1”通常包含某种程度上的直线，而数字“0”是圆形，则它将学习这一事实，并以更紧凑的形式对其进行编码。如果输入数据是完全随机的，没有任何内部相关性或依赖性，那么欠完整自动编码器将不能完美地恢复它。但幸运的是，在现实世界中，有很多依赖。

4.降噪自动编码器

保持较小的代码层迫使我们的自动编码器学习数据的智能表示。还有另一种方法来迫使自动编码器学习有用的特征，即向其输入添加随机噪声，并使其恢复原始的无噪声数据。这样，自动编码器不能简单地将输入复制到其输出，因为输入也包含随机噪声。我们要求它减去噪音并产生有意义的数据。这被称为去噪自动编码器。

最上面一行包含原始图像。我们向它们添加随机高斯噪声，噪声数据成为自动编码器的输入。自动编码器根本看不到原始图像。但是我们期望自动编码器重新生成无噪声的原始图像。

去噪 autoencoder 的实现和常规的实现之间只有一个很小的区别。架构一点没变，只有 fit 功能。我们按如下方式训练常规自动编码器:

autoencoder.fit(x_train, x_train)

去噪自动编码器被训练为:

autoencoder.fit(x_train_noisy, x_train)

就这么简单，其他的都完全一样。自动编码器的输入是有噪声的图像，而预期目标是原始的无噪声图像。

形象化

现在让我们想象一下我们是否能够恢复无噪声的图像。

看起来不错。最下面一行是自动编码器输出。我们可以通过使用更复杂的自动编码器架构来做得更好，例如卷积自动编码器。我们将在下一篇文章中讨论卷积。

5.稀疏自动编码器

我们介绍了两种方法来迫使自动编码器学习有用的特性:保持较小的代码大小和消除自动编码器的噪声。第三种方法是使用正规化。我们可以通过使用稀疏约束来调整自动编码器，使得只有一小部分节点具有非零值，称为活动节点。

特别地，我们在损失函数中增加了一个惩罚项，使得只有一小部分节点成为活动的。这迫使自动编码器将每个输入表示为少量节点的组合，并要求它发现数据中有趣的结构。即使代码很大，这种方法也是有效的，因为在任何时候只有一小部分节点是活动的。

在 Keras 中，只用一个参数就可以很容易地做到这一点。提醒一下，之前我们创建了如下代码层:

code = Dense(code_size, activation='relu')(input_img)

我们现在通过指定正则化强度来添加另一个名为activity _ regulator的参数。这通常是一个在[0.001，0.000001]范围内的值。这里我们选择了 10e-6。

code = Dense(code_size, activation='relu', activity_regularizer=l1(10e-6))(input_img)

由于增加了正则化项，稀疏模型的最终损失比标准模型高 0.01。

让我们证明正则化模型生成的编码确实是稀疏的。如果我们查看测试集中图像的代码值的直方图，分布如下:

标准模型的平均值为 6.6，但正则化模型的平均值为 0.8，降幅相当大。我们可以看到正则化模型中的一大块代码值确实是 0，这正是我们想要的。正则化模型的方差也相当低。

6.用例

现在我们可能会问以下问题。自动编码器在压缩输入方面有多好？它们是常用的深度学习技术吗？

不幸的是，自动编码器在现实应用中并没有广泛使用。作为一种压缩方法，它们并不比它的替代品表现得更好，例如 jpeg 压缩照片比自动编码器更好。事实上，自动编码器是特定于数据的，这使得它们作为一种通用技术是不切实际的。不过，它们有 3 种常见的使用情形:

数据去噪:我们已经在图像上看到了这样的例子。
降维:可视化高维数据具有挑战性。t-SNE 是最常用的方法，但它的维数很大(通常在 32 以上)。因此，自动编码器被用作预处理步骤来降低维度，这种压缩的表示被 t-SNE 用于在 2D 空间中可视化数据。关于 t-SNE 的精彩文章，请参考这里和这里。
变型自动编码器(VAE):这是自动编码器的一个更加现代和复杂的用例，我们将在另一篇文章中介绍它们。但是作为一个快速的总结，VAE 学习了模拟输入数据的概率分布的参数，而不是学习普通自动编码器的任意函数。通过从该分布中采样点，我们还可以使用 VAE 作为生成模型。这里的就是一个很好的参考。

7.结论

自动编码器是一种非常有用的降维技术。它们作为深度学习入门课程的教材非常受欢迎，很可能是因为它们的简单性。在这篇文章中，我们详细介绍了它们，希望您喜欢。

如果你想自己动手，这篇文章的全部代码可以在这里找到。如果您有任何反馈，请随时通过推特联系我。

应用深度学习-第 4 部分:卷积神经网络

原文：https://towardsdatascience.com/applied-deep-learning-part-4-convolutional-neural-networks-584bc134c1e2?source=collection_archive---------0-----------------------

概观

欢迎来到应用深度学习系列的第 4 部分。第 1 部分是对人工神经网络的实际介绍，包括理论和应用，有很多代码示例和可视化。在第二部分中，我们将深度学习应用于真实世界的数据集，涵盖了 3 个最常见的问题作为案例研究:二分类、多类分类和回归。第三部分探索了一种特定的深度学习架构:自动编码器。

现在我们将讨论最流行的深度学习模型:卷积神经网络。

简介
建筑
直觉
实施
VGG 模式
可视化
结论
参考文献

这篇文章的代码可以在这里获得作为一个 Jupyter 笔记本，请随意下载并亲自试用。

1.介绍

卷积神经网络(CNN)无处不在。它可以说是最流行的深度学习架构。最近对深度学习的兴趣激增是由于 convnets 的巨大普及和有效性。人们对 CNN 的兴趣始于 2012 年的 AlexNet，此后一直呈指数级增长。仅仅三年时间，研究人员就从 8 层 AlexNet 发展到了 152 层 ResNet。

CNN 现在是所有与图像相关问题的首选模式。就准确性而言，他们将竞争对手打得落花流水。它还成功地应用于推荐系统、自然语言处理等等。与它的前辈相比，CNN 的主要优势在于它自动检测重要特征，而无需任何人工监督。例如，给定许多猫和狗的图片，它自己学习每一类的不同特征。

CNN 的计算效率也很高。它使用特殊的卷积和池操作，并执行参数共享。这使得 CNN 模型可以在任何设备上运行，使它们具有普遍的吸引力。

总之，这听起来像是纯粹的魔术。我们正在处理一个非常强大和有效的模型，该模型执行自动特征提取以实现超人的准确性(是的，CNN 模型现在比人类更好地进行图像分类)。希望这篇文章能帮助我们揭开这项非凡技术的秘密。

2.体系结构

所有 CNN 模型都遵循类似的架构，如下图所示。

我们正在处理一个输入图像。我们执行一系列卷积+池操作，然后是一些完全连接的层。如果我们执行多类分类，输出是 softmax。我们现在将深入研究每个组件。

2.1)卷积

CNN 的主要构件是卷积层。卷积是一种合并两组信息的数学运算。在我们的例子中，使用卷积滤波器将卷积应用于输入数据，以产生特征图。使用了很多术语，所以让我们一个一个地形象化它们。

左侧是卷积层的输入，例如输入图像。右边是卷积滤波器，也称为内核，我们将互换使用这些术语。由于滤波器的形状，这被称为 3x3 卷积。

我们通过在输入上滑动该滤波器来执行卷积运算。在每个位置，我们做逐元素矩阵乘法，并将结果相加。这个总和进入特征图。发生卷积运算的绿色区域被称为感受野。由于滤光器的大小，感受野也是 3×3。

这里，过滤器位于左上角，卷积运算“4”的输出显示在生成的特征图中。然后，我们向右滑动过滤器，执行相同的操作，将结果添加到特征映射中。

我们继续这样做，并在特征图中聚集卷积结果。下面的动画展示了整个卷积运算。

这是 2D 使用 3×3 滤波器显示的卷积运算的一个例子。但实际上这些卷积是在 3D 中进行的。实际上，图像被表示为具有高度、宽度和深度维度的 3D 矩阵，其中深度对应于颜色通道(RGB)。卷积滤波器具有特定的高度和宽度，如 3x3 或 5x5，并且根据设计，它覆盖其输入的整个深度，因此它也需要是 3D 的。

在我们想象实际的卷积运算之前，还有一点很重要。我们对一个输入执行多次卷积，每次使用不同的过滤器，产生不同的特征图。然后，我们将所有这些特征图堆叠在一起，这就成为卷积层的最终输出。但首先让我们从简单开始，用一个滤波器来想象一个卷积。

假设我们有一个 32x32x3 的图像，我们使用大小为 5x5x3 的滤镜(请注意，卷积滤镜的深度与图像的深度匹配，都是 3)。当滤波器位于特定位置时，它覆盖一小部分输入，我们执行上述卷积运算。唯一的区别是这次我们在 3D 中做矩阵乘法的和，而不是 2D，但是结果仍然是标量。我们像上面一样在输入上滑动过滤器，并在每个位置执行卷积，将结果聚集在特征图中。该特征地图的大小为 32x32x1，如右边的红色切片所示。

如果我们使用 10 个不同的过滤器，我们将有 10 个大小为 32x32x1 的特征图，并将它们沿深度方向堆叠将得到卷积层的最终输出:大小为 32x32x10 的体积，如右侧的蓝色大框所示。请注意，特征图的高度和宽度没有改变，仍然是 32，这是由于填充造成的，我们稍后将对此进行详细说明。

为了有助于可视化，我们在输入上滑动过滤器，如下所示。在每个位置，我们得到一个标量，并在特征图中收集它们。动画显示了 4 个位置的滑动操作，但实际上是在整个输入中执行的。

下面我们可以看到两个特征图是如何沿着深度方向堆叠的。每个滤波器的卷积操作是独立执行的，并且所得到的特征图是不相交的。

2.2)非线性

对于任何一种强大的神经网络，它都需要包含非线性。我们之前看到的 ANN 和 autoencoder 都是通过激活函数传递其输入的加权和来实现这一点的，CNN 也不例外。我们再次通过 relu 激活函数传递卷积运算的结果。因此，最终特征图中的值实际上不是总和，而是应用于它们的 relu 函数。为了简单起见，我们在上面的图中省略了这一点。但是请记住，任何类型的卷积都包含一个 relu 运算，没有它，网络就不能实现其真正的潜力。

2.3)步幅和衬垫

步幅指定我们在每一步移动卷积滤波器的程度。默认情况下，该值为 1，如下图所示。

如果我们想减少感受野之间的重叠，我们可以有更大的进展。这也使得生成的特征地图更小，因为我们跳过了潜在的位置。下图演示了步幅为 2。请注意，特征图变小了。

我们看到特征映射的大小小于输入，因为卷积滤波器需要包含在输入中。如果我们想保持相同的维度，我们可以使用填充用零包围输入。查看下面的动画。

输入周围的灰色区域是填充。我们要么用零填充，要么用边上的值填充。现在，特征图的维度与输入相匹配。CNN 通常使用填充来保持特征图的大小，否则它们会在每一层收缩，这是不希望的。我们上面看到的 3D 卷积图使用了填充，这就是为什么特征图的高度和宽度与输入相同(都是 32x32)，只有深度发生了变化。

2.4)联营

在卷积运算之后，我们通常执行池来减少维度。这使我们能够减少参数的数量，这既缩短了训练时间，又防止了过度拟合。池化图层对每个要素地图单独进行缩减采样，减少高度和宽度，保持深度不变。

最常见的池类型是最大池，它只取池窗口中的最大值。与卷积运算相反，池化没有参数。它在其输入上滑动一个窗口，并简单地取窗口中的最大值。类似于卷积，我们指定窗口大小和步幅。

这是使用 2x2 窗口和步幅 2 的最大池的结果。每种颜色代表一个不同的窗口。因为窗口大小和跨度都是 2，所以窗口不重叠。

注意，该窗口和步幅配置将特征图的大小减半。这是池化的主要用例，在保留重要信息的同时对要素地图进行缩减采样。

现在让我们算出合并前后的特征图尺寸。如果池化图层的输入维度为 32x32x10，使用上述相同的池化参数，结果将是 16x16x10 的要素地图。要素地图的高度和宽度减半，但深度不变，因为池化在输入的每个深度切片上独立工作。

通过将高度和宽度减半，我们将重量的数量减少到输入的 1/4。考虑到我们通常在 CNN 架构中处理数百万的权重，这种减少是相当大的。

在 CNN 架构中，通常使用 2x2 窗口、跨距 2 和无填充来执行池化。卷积是用 3×3 窗口、步长 1 和填充完成的。

2.5)超参数

现在，让我们只考虑忽略池化的卷积层，并检查我们需要做出的超参数选择。我们需要决定 4 个重要的超参数:

滤波器尺寸:我们通常使用 3x3 滤波器，但根据具体应用，也可以使用 5x5 或 7x7 滤波器。还有 1x1 滤波器，我们将在另一篇文章中探讨，乍一看可能很奇怪，但它们有有趣的应用。请记住，这些过滤器是 3D 的，也有深度维度，但由于过滤器在给定层的深度等于其输入的深度，我们忽略了这一点。
过滤器数量:这是最易变的参数，它是 2 的幂，介于 32 和 1024 之间。使用更多的过滤器会产生更强大的模型，但是由于参数数量的增加，我们有过度拟合的风险。通常，我们从初始层的少量过滤器开始，随着网络的深入，数量会逐渐增加。
Stride:我们保持默认值 1。
填充:我们通常使用填充。

2.6)完全连接

在卷积+合并层之后，我们添加几个完全连接的层来包装 CNN 架构。这就是我们在第一部分中谈到的全连接人工神经网络架构。

请记住，卷积图层和池化图层的输出都是 3D 体积，但完全连接的图层需要数字的 1D 矢量。所以我们将最终池层的输出扁平化为一个矢量，它成为全连接层的输入。扁平化就是简单地将三维的数字排列成一个 1D 向量，这里没有任何奇特的事情发生。

2.7)培训

CNN 的训练方式和 ANN 一样，梯度下降反向传播。由于卷积运算涉及到更多的数学问题，这超出了本文的范围。如果你对细节感兴趣，请点击这里。

3.直觉

CNN 模型可以被认为是两个部分的组合:特征提取部分和分类部分。卷积+池层执行特征提取。例如，给定一幅图像，卷积层检测诸如两只眼睛、长耳朵、四条腿、一条短尾巴等特征。然后，完全连接的图层在这些特征之上充当分类器，并为输入图像分配成为狗的概率。

卷积层是 CNN 模型的主要动力。给定一幅图像和一个标签，自动检测有意义的特征并不是一件容易的事情。卷积层通过在彼此之上构建来学习如此复杂的特征。第一层检测边缘，接下来的层将它们合并以检测形状，随后的层将这些信息合并以推断这是一个鼻子。明确一点，CNN 不知道鼻子是什么。通过在图像中看到大量这样的东西，它学会了把它作为一种特征来检测。完全连接的层学习如何使用由卷积产生的这些特征，以便正确地分类图像。

所有这些现在听起来可能很模糊，但希望可视化部分会让一切变得更清楚。

4.履行

在这个冗长的解释之后，让我们编码我们的 CNN。我们将使用 Kaggle 的狗对猫数据集来区分狗和猫的照片。

我们将使用以下架构:4 个卷积+池层，然后是 2 个全连接层。输入是猫或狗的图像，输出是二进制的。

CNN 的代码如下:

在结构上，代码看起来类似于我们一直在工作的人工神经网络。有 4 种新方法我们以前没有见过:

Conv2D :这个方法创建一个卷积层。第一个参数是过滤器数量，第二个参数是过滤器尺寸。例如，在第一个卷积层中，我们创建了 32 个大小为 3×3 的过滤器。我们使用 relu 非线性作为激活。我们还启用填充。在 Keras 中，填充有两种选择:相同或有效。相同意味着我们在边缘填充数字，有效意味着没有填充。默认情况下，卷积层的步幅为 1，因此我们不做更改。这一层可以用附加参数进一步定制，你可以查看文档这里。
MaxPooling2D :创建一个 MaxPooling 层，唯一的参数是窗口大小。我们使用 2x2 的窗口，因为这是最常见的。默认情况下，步长等于窗口大小，在我们的例子中是 2，所以我们不改变它。
展平:在卷积+合并层之后，我们展平它们的输出，以馈入我们上面讨论过的完全连接的层。
辍学:我们将在下一节解释这一点。

4.1)辍学

对于深度神经网络，丢弃是迄今为止最流行的正则化技术。即使最先进的模型具有 95%的精度，仅通过增加压差也能获得 2%的精度提升，这在该水平上是一个相当大的增益。

辍学是用来防止过度拟合和想法非常简单。在训练期间，在每次迭代中，神经元以概率 p 被暂时“丢弃”或禁用。这意味着该神经元的所有输入和输出将在当前迭代中被禁用。在每个训练步骤中，被丢弃的神经元以概率 p 被重新采样，因此在一个步骤中被丢弃的神经元可以在下一个步骤中被激活。超参数 p 被称为辍学率，它通常是一个 0.5 左右的数字，对应于 50%的神经元被剔除。

令人惊讶的是，退学竟然行得通。我们故意禁用神经元，网络实际上表现更好。原因是 dropout 防止网络过于依赖少数神经元，并迫使每个神经元都能够独立运行。这听起来可能很熟悉，因为在第 3 部分中限制了自动编码器的代码大小，以便学习更智能的表示。

让我们把辍学形象化，这样会容易理解得多。

丢弃可以应用于输入或隐藏层节点，但不能应用于输出节点。已删除节点的内外边被禁用。请记住，在每个训练步骤中，被遗漏的节点会发生变化。此外，我们不会在网络训练后的测试时间内应用退出，我们只在训练中这样做。

现实生活中对辍学的类比如下:假设你是公司里唯一懂财务的人。如果保证你每天都在工作，你的同事就没有动力去学习金融技能。但是如果每天早上你都抛硬币来决定是否去上班，那么你的同事就需要适应了。有些日子你可能不在工作，但财务任务仍然需要完成，所以他们不能只依靠你。你的同事需要学习金融知识，这种专业知识需要在不同的人之间传播。工人需要与其他几个雇员合作，而不是与一组固定的人合作。这使得公司整体上更有弹性，提高了员工的素质和技能。

几乎所有最先进的深度网络现在都包含了 dropout。还有另一种非常流行的正则化技术叫做批处理正则化，我们将在另一篇文章中介绍它。

4.2)型号性能

现在让我们来分析我们模型的性能。我们将看看损失和准确性曲线，将训练集性能与验证集进行比较。

训练损失持续下降，但是验证损失在大约第 10 个时期之后开始增加。这是教科书上对过度拟合的定义。该模型正在记忆训练数据，但它无法推广到新的实例，这就是验证性能变差的原因。

尽管我们在使用辍学，我们还是过度适应了。原因是我们正在训练很少的例子，每个类别 1000 张图片。通常我们至少需要 100K 个训练样本才能开始思考深度学习。无论我们使用哪种正则化技术，我们都会在如此小的数据集上过度拟合。但幸运的是，这个问题有一个解决方案，它使我们能够在小数据集上训练深度模型，它被称为数据增强。

4.3)数据扩充

过度拟合是因为训练的样本太少，导致模型的泛化性能很差。如果我们有无限的训练数据，我们不会过度拟合，因为我们会看到每一个可能的实例。

在大多数机器学习应用中，尤其是在图像分类任务中，常见的情况是获得新的训练数据并不容易。因此，我们需要用手头的训练集来凑合。数据扩充是从当前数据集生成更多训练数据的一种方式。它通过对现有样本进行随机转换来生成新的样本，从而丰富或“增加”训练数据。通过这种方式，我们人为地增加了训练集的规模，减少了过度拟合。因此，数据扩充也可以被认为是一种正则化技术。

数据扩充是在训练期间动态完成的。我们需要生成真实的图像，转换应该是可以学习的，简单地添加噪声是没有帮助的。常见的变换有:旋转、移动、调整大小、曝光调整、对比度改变等。这样，我们可以从单个训练示例中生成大量新样本。此外，数据扩充只在训练数据上执行，我们不涉及验证或测试集。

可视化将有助于理解这个概念。假设这是我们最初的形象。

使用数据增强，我们生成这些人工训练实例。这些是新的训练实例，在原始图像上应用变换不会改变这仍然是猫图像的事实。我们可以推断它是人类，所以模型也应该能够学习。

数据扩充甚至可以将训练集的规模提高 50 倍。这是一种非常强大的技术，用于每一个基于图像的深度学习模型，没有例外。

有一些我们通常在图像上使用的数据清理技巧，主要是白化和意味着归一化。更多关于他们的信息可以在这里找到。

4.4)更新型号

现在让我们在 CNN 模型中使用数据增强。模型定义的代码根本不会改变，因为我们不会改变模型的架构。唯一的变化是我们如何输入数据，你可以查看 jupyter 笔记本这里。

用 Keras 做数据扩充很容易，它提供了一个类来为我们做所有的工作，我们只需要指定一些参数。文档可在这里获得。

使用数据扩充，损失和精度曲线如下所示。

这次没有明显的过度拟合。验证准确率从无数据扩充时的 73%跃升至有数据扩充时的 81%，提高了 11%。这是一件大事。准确度提高的主要原因有两个。首先，我们在更多不同的图像上进行训练。第二，我们使模型变换不变，这意味着模型看到了许多移动/旋转/缩放的图像，因此它能够更好地识别它们。

5.VGG 模型

现在让我们来看一个 2014 年的 CNN 模型的例子。VGG 是来自牛津视觉几何小组研究人员的卷积神经网络，因此得名 VGG。它以 7.3%的错误率获得了 ImageNet 分类挑战的亚军。 ImageNet 是最全面的手绘视觉数据集，他们每年都举办比赛，来自世界各地的研究人员参加比赛。所有著名的 CNN 建筑都在那次比赛中首次亮相。

在表现最好的 CNN 模型中，VGG 因其简单而引人注目。我们来看看它的架构。

VGG 是一个 16 层的神经网络，不包括最大池层和最末端的 softmax。它也被称为 VGG16。该架构是我们在上面工作过的架构。堆叠卷积+池层，然后是完全连接的人工神经网络。关于架构的一些观察:

它在整个网络中仅使用 3×3 卷积。注意，两个背靠背的 3×3 回旋具有单个 5×5 回旋的有效感受野。并且三个堆叠的 3×3 回旋具有单个 7×7 回旋的感受野。这是两个堆叠的 3x3 卷积形成 5x5 的可视化效果。

堆叠两个卷积而不是一个卷积的另一个优点是，我们使用两个 relu 运算，并且更多的非线性赋予模型更多的能力。
随着我们深入网络，过滤器的数量会增加。由于我们进行了汇集，特征地图的空间大小减小了，但是随着我们使用更多的过滤器，体积的深度增加了。
在 4 个 GPU 上训练了 3 周。

VGG 是一个非常基本的 CNN 模型。如果您需要为某个特定任务使用现成的模型，这是第一个想到的。这篇论文也写得很好，可以在这里找到。还有更复杂的模型表现更好，例如微软的 ResNet 模型以 3.6%的错误率赢得了 2015 年 ImageNet 挑战赛，但该模型有 152 层！详情可在报上这里。我们将在另一篇文章中深入讨论所有这些 CNN 架构，但是如果你想跳过这里是一个很棒的帖子。

6.形象化

现在是最有趣的部分，卷积神经网络的可视化。众所周知，深度学习模型非常难以解释，这就是为什么它们通常被视为黑盒。但是 CNN 模型其实是相反的，我们可以把各种成分可视化。这将使我们深入了解它们的内部工作方式，并帮助我们更好地理解它们。

我们将设想 VGG 模式的 3 个最重要的组成部分:

特征地图
Convnet 滤波器
类输出

6.1)可视化要素地图

让我们快速回顾一下卷积架构作为提示。convnet 滤波器对输入执行卷积运算，结果得到一个特征图。我们使用多个过滤器，并将得到的特征图堆叠在一起，以获得输出体积。首先，我们将直观显示特性图，在下一节中，我们将探讨 convnet 滤波器。

我们将可视化特征地图，以查看输入如何通过卷积层进行转换。特征图也被称为中间激活，因为层的输出被称为激活。

请记住，卷积层的输出是 3D 体积。如上所述，高度和宽度对应于特征图的维度，并且每个深度通道是编码独立特征的不同特征图。因此，我们将通过将每个通道绘制为 2D 图像来可视化各个特征地图。

如何可视化特征地图实际上非常简单。我们通过 CNN 传递一个输入图像并记录中间激活。然后，我们随机选择一些特征地图，并绘制它们。

VGG 卷积层的命名如下:blockX_convY。例如，第三个卷积模块中的第二个滤波器称为 block3_conv2。在上面的架构图中，它对应于第二个紫色滤镜。

例如，第一层(block1_conv1)输出的一个特征图如下所示。

明亮的区域是“激活”的区域，这意味着过滤器检测到了它正在寻找的模式。这个过滤器似乎编码了一个眼睛和鼻子探测器。

与查看单个要素地图相比，从卷积图层中可视化多个要素地图会更有意思。那么让我们来可视化对应于每个块的第一个卷积的特征图，下图中的红色箭头。

下图显示了每个图层的 8 个要素地图。Block1_conv1 实际上包含 64 个特征图，因为该层中有 64 个滤波器。但是在这个图中，我们只可视化了每层的前 8 个。

随着我们对图层的深入了解，我们对特征地图有一些有趣的观察。让我们看一下每个图层的一个要素地图，以使它更明显。

第一层要素地图(block1_conv1)保留了图像中的大部分信息。在 CNN 架构中，第一层通常充当边缘检测器。
随着我们深入网络，特征地图看起来不太像原始图像，而更像它的抽象表示。正如您在 block3_conv1 中看到的，这只猫在某种程度上是可见的，但在此之后，它就变得不可识别了。原因在于，较深的特征地图编码像“猫鼻子”或“狗耳朵”这样的高级概念，而较低级别的特征地图检测简单的边缘和形状。这就是为什么更深的特征地图包含更少的关于图像的信息，而包含更多的关于图像类别的信息。它们仍然编码有用的特征，但是它们不太容易被我们从视觉上理解。
随着我们深入，特征图变得越来越稀疏，这意味着过滤器检测到的特征越来越少。这是有意义的，因为第一层中的过滤器检测简单的形状，并且每个图像都包含这些形状。但随着我们深入，我们开始寻找更复杂的东西，如“狗尾巴”，它们不会出现在每张图片中。这就是为什么在第一张图中，每层有 8 个过滤器，随着我们深入，我们会看到更多的功能图为空白(block4_conv1 和 block5_conv1)。

6.2)可视化 Convnet 滤波器

现在我们将想象 CNN 的主要组成部分，过滤器。不过，有一个问题，我们不会真正可视化过滤器本身，而是显示每个过滤器最大程度响应的模式。请记住，过滤器的大小为 3x3，这意味着它们的高度和宽度为 3 个像素，非常小。因此，作为可视化过滤器的代理，我们将在过滤器最活跃的地方生成输入图像。

如何做到这一点的全部细节有些技术性，你可以在 jupyter 笔记本中查看实际代码。但作为一个快速总结，它的工作原理如下:

选择一个损耗函数，使 convnet 滤波器的值最大化。
从空白输入图像开始。
在输入空间做梯度上升。这意味着修改输入值，使过滤器激活更多。
循环重复这个动作。

这个过程的结果是滤波器非常活跃的输入图像。请记住，每个过滤器都充当特定功能的检测器。我们生成的输入图像将包含许多这些特征。

我们将在每个卷积块的最后一层可视化滤波器。为了消除任何混淆，在上一节中，我们可视化了卷积运算的输出，即特征图。现在我们正在可视化滤波器，卷积运算中使用的主要结构。

我们将设想每层 8 个过滤器。

它们看起来很不真实！尤其是最后几层。以下是对过滤器的一些观察:

第一层过滤器(block1_conv2 和 block2_conv2)主要检测颜色、边缘和简单形状。
随着我们深入网络，过滤器在彼此之上构建，并学习编码更复杂的模式。例如，block5_conv3 中的滤波器 41 似乎是一个鸟类检波器。您可以看到不同方向的多个头部，因为鸟在图像中的特定位置并不重要，只要它出现在过滤器将激活的某个位置。这就是为什么过滤器试图通过在过滤器中的多个位置编码来检测几个位置的鸟头。

这些观察结果类似于我们在特征映射部分讨论的内容。较低层编码/检测简单的结构，随着我们深入，各层在彼此之上构建，并学习编码更复杂的模式。这也是我们人类在婴儿时期开始发现世界的方式。首先，我们学习简单的结构，通过实践，我们擅长理解更复杂的东西，建立在我们现有知识的基础上。

6.3)可视化类输出

让我们做最后一个可视化，它将类似于 convnet 过滤器。现在我们将在最终的 softmax 层可视化。给定一个特定的类别，如锤子或灯，我们将要求 CNN 生成一个最大限度地代表该类别的图像。基本上 CNN 会给我们画一幅它认为锤子的样子。

该过程类似于 convnet 滤波器步骤。我们从空白图像开始并进行修改，使得分配给特定类别的概率增加。该代码再次出现在笔记本中。

让我们形象化一些类别。

他们看起来很有说服力。一个对象在图像中出现多次，因为这样分类概率变得更高。图像中的多个网球比单个网球更好。

所有这些可视化都是使用库 keras-vis 执行的。

7.结论

CNN 是一种非常基础的深度学习技术。我们涵盖了广泛的主题，在我看来可视化部分是最有趣的。网上很少有资源对卷积滤波器和特征图进行全面的视觉探索。我希望它有帮助。

如果你想自己动手，这篇文章的全部代码可以在这里找到。如果你有任何反馈，请随时通过推特联系我。

8.参考

网上有大量的 CNN 教程，但最全面的是 Andrej Karpathy 的斯坦福 CS231N 课程。阅读资料在这里，视频讲座在这里。极好的信息来源，强烈推荐。

如果你想深入了解可视化，Deepvis 是一个很好的资源在这里。有一个交互工具，开源代码，论文和一篇详细的文章。

Keras 的作者提供了一个很棒的图像分类教程这里。这篇文章深受那篇教程的影响。它涵盖了我们详细讨论过的许多材料。

关于深度学习的非常全面的在线免费书籍可以在这里找到，CNN 部分可以在这里找到。

如果你对将 CNN 应用于自然语言处理感兴趣，这篇文章非常棒。另一个非常详细的是这里。

一个由 3 部分组成的系列文章，涵盖了 CNN 论文的现状，可以在这里找到。

Chris Olah 的所有文章都充满了丰富的信息和可视化效果。CNN 的相关帖子可以在这里和这里找到。

另一个受欢迎的 CNN 介绍文章是这里的。

这里有一个非常容易理解的关于 CNN 的三集系列。

垃圾邮件过滤中的文本分类应用(上)

原文：https://towardsdatascience.com/applied-text-classification-on-email-spam-filtering-part-1-1861e1a83246?source=collection_archive---------1-----------------------

Email-Spam Filtering

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

从上个月开始，我开始在华盛顿大学提供的在线机器学习专业上工作。第一个课程是关于 ML 基础，第二个是关于线性回归，第三个课程是关于分类。我喜欢这些课程的各个方面，因为它们从头开始教授 ML 算法的实现。当我决定更深入地探索这个领域时，这就是我的目标。但是，老实说，我觉得有一个差距，因为许多问题都没有答案。然后，在阅读了关于如何开始机器学习的内容后，我发现大多数文章都强调了将课程与实践项目相结合的重要性，以便学以致用..而且是那么真实！你只要试着把两者结合起来，你很快就会注意到不同之处！

这是我的第一次实习申请！😄 我选择尝试 垃圾邮件过滤 ，因为这是应用分类中一个非常常见的话题。这很容易理解，因为我们每天都在经历电子邮件中的垃圾邮件过滤。

我遵循了一个简单的入门教程:电子邮件垃圾邮件过滤:使用 Scikit-learn 的 Python 实现。做完不久，我的大脑开始分析步骤，一堆问题轰炸我的脑袋！

为什么“垃圾邮件和非垃圾邮件数量相等”？什么是词干？除了删除停用词和词条化之外，还有其他清理数据的方法吗？训练集和测试集之间的划分是如何完成的？为什么没有验证集？为什么特别使用朴素贝叶斯分类器和 SVM(支持向量机)？是什么让朴素贝叶斯在文档分类问题上如此受欢迎？等等..

扮成威廉。巴勒斯说:“如果你学会放松并等待答案，你的大脑会回答大多数问题。”

我吸了口气，开始一个问题一个问题地回答，有时在网上搜索，试验一些代码的变化，并分析输出。我很高兴地分享结果:

1)我们需要的数据

-我们已经看到了多少封电子邮件(将在训练测试集中使用)
-每个标签中有多少封电子邮件(用于检测是否存在不平衡数据)
-一个单词与每个标签关联的频率(用于计算电子邮件是垃圾邮件或垃圾邮件(0 类或 1 类)的概率)

2)清理数据

为什么要清洗单词表？为了减少得到错误结果的可能性，清理数据是必不可少的，因为一些单词对分类没有影响(它们既不能与垃圾邮件类相关联，也不能与垃圾邮件类相关联),并且有一些单词可以被标准化，以便将意思相同的单词分组并减少冗余。通过对训练数据的质量采取行动，我们可以改变分类器的所谓的准确度。因此，移除停用词、词干和词条化有助于改善机器学习算法的结果。

3)朴素贝叶斯

为什么使用朴素贝叶斯？朴素贝叶斯具有高效的学习和预测能力，它经常被用来与更复杂的方法进行比较，因为它快速且高度可伸缩(适用于高维数据),正如吴恩达建议的那样，在处理 ML 问题时，从尝试简单快速的算法开始，然后从该点扩展。

朴素贝叶斯如何简单易行？朴素贝叶斯基于“贝叶斯”定理，之所以称之为“朴素”，是因为它假设在给定类的情况下要素是相互独立的(要素之间没有/几乎没有相关性)，这是不现实的。因此，朴素贝叶斯可以学习单个特征的重要性，但不能确定特征之间的关系。此外，与其他方法相比，朴素贝叶斯的训练时间要短得多，并且不需要太多的训练数据。

为什么是多项朴素贝叶斯？其他模型比如高斯朴素贝叶斯或者伯努利朴素贝叶斯呢？

嗯， 多项式 NB 考虑的是特征(在我们的例子中是单词)的 频率计数 (出现次数)而伯努利 NB 只关心文档中某个特定特征(单词)的存在与否。后者适用于二进制值(伯努利，布尔)的特性。鉴于使用高斯 NB ，特征是实值或连续并且它们的分布是高斯的，Iris Flower 数据集是具有连续特征的例子。

4)支持向量机(SVM)

为什么使用 SVM？我没有找到具体的原因，但据我所知，SVM 可以提供高精度的结果，因为它使用了优化程序。SVM 通过搜索最优的分离超平面(最优超平面)和最大化分离类别(在我们的例子中是垃圾邮件和火腿)的间隔来构建分类器。因此，当维数大于样本数时，SVM 具有一般稳健性和有效性的优点。

与朴素贝叶斯不同，SVM 是一种非概率算法。

【LinearSVC 和 SVC (Scikit-learn)有什么区别？区别在于它们不接受相同的参数。例如，LinearSVC 不接受内核参数，因为它被认为是线性的。SVC 支持更多的参数(C，γ，..)因为它保存了所有可能的核函数(线性、多项式、rbf 或径向基函数、sigmoid)。

如何调整 SVM 参数？调整 SVM 参数提高了算法的性能。其中一些影响更大:

-内核:内核就像一个相似度函数。这是一种在可能的高维特征空间中计算两个向量的点积的方法，使用基于一些提供的约束的数据转换到更复杂的空间。核函数有时被称为“广义点积”。

-Gamma:“RBF”、“poly”和“sigmoid”的核系数。更高的伽马值将试图按照训练数据集精确拟合，即泛化误差，并导致过拟合问题。

-C:(3.15)中的系数 C 是一个允许在训练误差和模型复杂度之间进行权衡的参数。小的值 C 将增加训练错误的数量，而大的值 C 将导致类似于硬边际 SVM 的行为。”约阿希姆(2002)，第 40 页

5)分析不同情况下的输出

如果我改变字典的大小会怎样？

改变字典大小意味着改变特征(单词)的数量。因此，我想探索拥有更多功能的影响，以及基于混淆矩阵结果的好结果的限制。

我在 size= {3000，5000，6000，7000}上进行测试，发现在 size = 7000 时，SVM 分类开始略有下降(错误识别),而朴素贝叶斯尽管在大小上有所变化，但仍提供了相同的结果。

我认为，在这一点上，可能目标类开始重叠或训练数据过度拟合。我还不确定对这个结果的解释。

如果我尝试高斯和伯努利呢？

显然，引入伯努利不会有所帮助，因为正如我上面解释的，它在我们的情况下没有提供足够的信息，我们需要的是字数，而不是它的存在/不存在。

多项式 NB:
[[129 1]
【9 121]]
高斯 NB:
[[129 1]
【11 119]]
伯努利 NB:
[[130 0 0]
【53 77】]

如我们所见，多项式 NB 优于高斯 NB 和伯努利 NB。

如果我在 SVM 上尝试grid search来调整 SVM 参数会怎么样？
Params grid search:param _ grid = { ' C ':[0.1，1，10，100，1000]，' gamma':[1，0.1，0.01，0.001，0.0001]}
找到最佳参数:Gamma:0.0001；列车员:100 元

线性 SVM:
[[126 4]
【5 125】]
多项式 NB:
[[129 1]
【9 121】]
SVM:
[[129 1]
【62 68]]
grid search on SVM:
[[126 4]
【2 128】]

SVM 使用 GridSearch 调整参数，可以获得更好的结果。

结论

这就是我使用垃圾邮件过滤软件的第一步！如果你正在考虑开始一个文本分类项目，我希望它对你有所帮助！我会继续分享各种思考和实验。下一次，我将探索更多的训练数据和特征的改进/改变。

这个项目也在 Github 上。

有用的资源:

[1] 朴素贝叶斯和文本分类。
【2】朴素贝叶斯举例。
【3】吴恩达解释朴素贝叶斯视频 1 和视频 2
【4】请像我 5 岁一样解释 SVM。
【5】从实例理解支持向量机。

告诉我你在文本分类方面的经验？你用它做什么？你建议用什么方法？有哪些挑战？

应用 RFM 原理用 K-Means 聚类客户

原文：https://towardsdatascience.com/apply-rfm-principles-to-cluster-customers-with-k-means-fef9bcc9ab16?source=collection_archive---------4-----------------------

从 2020 年 6 月起，我将不再使用媒体发布新故事。想继续看我的文章请访问我的个人博客:https://val lant . in。

谁是你的客户？有时候这个问题的答案不是很明显——或者很简短。有很多种方法可以对顾客进行分类和分组。但既然这里是讨论数据问题的地方，那就用数据的方法来回答这个问题吧。

当您拥有数据(如客户列表和他们购买的商品)并且需要使用这些数据创建具有相似特征的组时，您需要一种聚类方法。聚类是无监督机器学习技术组的一部分。我们称之为无监督的，因为计算机没有关于它应该如何分组实体的先前信息。事实上，它将试图通过分析相似实体之间的接近程度来创建具有相似实体的集群。

太宽泛？让我们开始讨论我们的学习案例。去 UCI 下载在线零售数据集。该数据集由 8 个属性和 541.909 个实例组成，显示了一家英国在线零售商在 2010 年 1 月 12 日和 2011 年 9 月 12 日之间发生的所有交易。据 UCI 称，该公司主要销售独特的全场合礼品，公司的许多客户是批发商。

我们的主要目标是通过使用聚类技术将这些客户分成不同的客户群。在这里，我们将使用 K-Means。但是，如何对这些客户进行分组呢？使用哪些变量？我们可以尝试使用 RFM(近期、频率、货币价值)方法来分析客户。这种方法是用来评估客户价值的，我们稍后会详细讨论。

所以首先要做的是加载我们的库和数据，并做一些探索性的数据分析。

我们稍后会详细讨论这些值。现在，让我们寻找空值并删除它们。让我们花一些时间来研究数据集上的唯一值。您将看到，我们现在拥有来自 37 个国家的客户(我们删除了一些空条目，之前我们有 38 个国家的客户)和 4，372 个独立客户。

我们可以做的一件事是借助describe()检查数据集上的主要数字统计信息。当你这样做的时候，注意一些有趣的事情:数量的最小值是一个负数。为什么？我真的不知道。但是既然在这种情况下负数是没有意义的，我们也把它们排除掉吧。

从 RFM 开始

你记得我说过我们会用 RFM 来聚集我们的客户吗？让我们现在就开始吧。但是首先，为什么不谈谈这种方法呢？

根据维基百科，RFM 代表三个维度:

R ecency — 客户最近购买了什么？
频率—他们多久购买一次？
M 一元值— 他们花了多少钱？

我们可以对 RFM 做的一件事是在 1 到 5 的范围内为每个维度分配一个分数，5 是最想要的行为。我们稍后会计算分数。我们首先需要创建一个由新近性、频率和货币价值组成的新数据框架。

为了计算最近的时间，我们将调查发票日期。由于我们上一张发票的日期是 2011 年 12 月 9 日，我们会将其视为最近的一张。然后，我们将从第二天减去每一天来计算其他的“最近”。

为了计算频率，我们简单地将每个客户的发票号码相加。对于货币价值，我们将单位价格乘以购买数量，并对每个客户进行求和。

现在，我们要计算分数。我们是这样做的:首先，我们以降序方式按频率对数据进行排序。然后，我们将数据集上的客户数量除以 5。我们为之前创建的每一个段分配一个从 5 到 1 的数字。让我们对“货币”和“最近”列也这样做。

注意:对于“最近”一栏，由于最近的订单更好，我们将其排序为 升序。

我将把分数添加到一个名为rfmTableScores.的新数据集

因为我们的分数在 1 到 5 之间，所以我们不需要缩放数字。

我们现在可以开始考虑模型了。K-Means 模型只能对数据集上的信息进行聚类，但是您必须选择想要多少个聚类。你可以用 K-Means 模型本身来做这个决定。为此，让我们创建类内平方和(WCSS)来支持我们的决定。

我们的肘形图显示了最佳的集群数量是 4。这是直线开始柔和下降的点。现在，让我们建立模型。

我们已经完成了聚类过程。就是这样。如您所见，由于 R、F 和 M 分数分析，聚类被分配给每个客户。

为了便于您了解我们所做的工作，让我们绘制一个图表，显示聚类过程之前的数据点以及聚类过程之后的一些图表。所以你可以清楚地看到星团的形成。

给盒图着色

原文：https://towardsdatascience.com/applying-a-custom-colormap-with-plotly-boxplots-5d3acf59e193?source=collection_archive---------3-----------------------

将自定义色标应用于绘图箱线图

我的老板最近要求我为一个破折号应用程序对一系列plottlyBox plots应用色标。这个想法是在同一个图上绘制多个盒状图，并根据每个盒状图与数据集中总体中值的距离，使每个盒状图变暗或变亮。

问题是

这里的问题是 Plotly 只支持热图的色标，散点图&等高线图。

我将通过绘制一些为加拿大人球员生成的数据来演示默认行为，如下所示:

注意:完整的代码在文章的最后

绿色虚线代表NHL league average +/- per game at +2.0，我的老板想要的是根据each players median +/- 值与league average的距离将每个方框图涂成更深或更浅的颜色。

解决方案

鉴于我已经处于 Python 环境中，我选择使用来自 Matplotlib Python 模块的colormap & colormap normalizer特性。

第一步是导入 Matplotlib:

import matplotlib.pyplot as plt
import matplotlib
import pandas as pd

然后确定数据集中的min和max值:

x_data = ['Henrik Sedin', 'Daniel Sedin',
          'Brock Boeser', 'Elias Pettersen',
          'Bo Horvat', 'Pavel Bure',]# Generate random data
y0 = np.random.randn(50)+4
y1 = np.random.randn(50)+4
y2 = np.random.randn(50)+2
y3 = np.random.randn(50)+2
y4 = np.random.randn(50)+1
y5 = np.random.randn(50)+3y_data = [y0,y1,y2,y3,y4,y5]df = pd.DataFrame(y_data)
vmin, vmax = df.min().min(), df.max().max()

初始化 Matplotlib cmap 和规格化器:

norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)
cmap = matplotlib.cm.get_cmap('GnBu') # green to blue color way

找到每个y_data的中间值，并使用规格化器根据中间值将其映射到适当的颜色:

for xd, yd in zip(x_data, y_data):

        median = np.median(yd) # find the median
        color = 'rgb' + str(cmap(norm(median))[0:3]) # normalize

        traces.append(go.Box(
            y=yd,
            name=xd,
            boxpoints='all',
            jitter=0.5,
            whiskerwidth=0.2,
            fillcolor=color,      # add the box plot color
            marker=dict(
                size=2,
            ),
            line=dict(width=1)
        ))

维奥拉。

players median +/-离league average越远，产生的图将呈现越暗的fillcolor，反之亦然。

奖金

下面是获得上述结果的完整代码:

from plotly import __version__
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
import plotly.graph_objs as go
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlibx_data = ['Henrik Sedin', 'Daniel Sedin',
          'Brock Boeser', 'Elias Pettersen',
          'Bo Horvat', 'Pavel Bure',]y0 = np.random.randn(50)+4
y1 = np.random.randn(50)+4
y2 = np.random.randn(50)+2
y3 = np.random.randn(50)+2
y4 = np.random.randn(50)+1
y5 = np.random.randn(50)+3y_data = [y0,y1,y2,y3,y4,y5]traces = []df = pd.DataFrame(y_data)
vmin, vmax = df.min().min(), df.max().max()norm = matplotlib.colors.Normalize(vmin=vmin, vmax=vmax)
cmap = matplotlib.cm.get_cmap('GnBu')for xd, yd in zip(x_data, y_data):
        median = np.median(yd)
        color = 'rgb' + str(cmap(norm(median))[0:3])

        traces.append(go.Box(
            y=yd,
            name=xd,
            boxpoints='all',
            jitter=0.5,
            whiskerwidth=0.2,
            fillcolor=color,
            marker=dict(
                size=2,
                color='rgb(0, 0, 0)'
            ),
            line=dict(width=1),
        ))layout = go.Layout(
    title='Canucks all time +/- per game',
    yaxis=dict(
        autorange=True,
        showgrid=True,
        zeroline=True,
        dtick=5,
        gridcolor='rgb(255, 255, 255)',
        gridwidth=1,
        zerolinecolor='rgb(255, 255, 255)',
        zerolinewidth=2,
    ),
    margin=dict(
        l=40,
        r=30,
        b=80,
        t=100,
    ),
    paper_bgcolor='rgb(243, 243, 243)',
    plot_bgcolor='rgb(243, 243, 243)',
    showlegend=False,
    shapes= [{
      'type': 'line',
      'x0': -1,
      'y0': 2,
      'x1': 6,
      'y1': 2,
      'line': {
        'color': 'rgb(50, 171, 96)',
        'width': 4,
        'dash': 'dashdot'
      }
    }]
)fig = go.Figure(data=traces, layout=layout)
iplot(fig)

应用人工智能帮助人们戒烟:早期结果

原文：https://towardsdatascience.com/applying-artificial-intelligence-to-help-people-quit-smoking-early-results-a3e5581d560?source=collection_archive---------3-----------------------

注意:报告的所有数据均来自实际用户，经过净化以保护其个人信息。我们的数据收集和报告系统旨在保护用户个人信息的隐私。

TL；博士:我们要让世界摆脱吸烟，这很有挑战性，但我们有一个计划，需要你的帮助。在 报名 cue.kiwi.ai

你最后一次考虑戒烟是什么时候？如果你像世界上 10 亿吸烟者中的任何一个，那很可能是今年。如果你碰巧有一个智能手表，我们可能有办法证明它的购买，我们的应用程序 Cue 是你减少吸烟的冠军

保持任何习惯的一个关键部分是一致性和易用性。如果改变我的饮食习惯需要我随身携带一个写字板，记录我吃的所有东西，那么我正在改变两个习惯:1)吃得更健康 2)记录饮食…这在一个谷歌搜索一个东西要花更长时间(0.59 秒)的世界里是相当困难的

Illustrative Typical Behaviour Change Apps/Products

当我们开始制作减少吸烟的软件时，我们有两个关键原则:1)它不能让用户做更多的工作 2)它必须提供超越新奇阶段的好处…我们不会编造虚荣指标

Machine Learning to deliver an extremely personalized experience, that drives actual benefit

我们已经将类似的思维应用于跟踪香烟；我们开发了一种算法，可以自动检测你何时吸烟。我们的应用程序是你的冠军，它通过对平均吸烟间隔时间进行微小但持续的改进来推动你戒烟

kiwi . ai 和 Cue 背景:

四年前，我们制作了第一个追踪你吸烟时的原型，这里有一个开源项目的链接；当时还没有技术和市场的采用，我们也不打算为吸烟定制可穿戴设备……所以我们等待着

在那段时间里，我们开发并授权了运动识别软件，该软件使用嵌入式神经网络以低功耗、高精度地跟踪运动。从那时起，我们已经支持了 20 多个客户，包括大型技术公司的大品牌，如 IBM、OEM 设备制造商、机器人公司和医疗保健提供商

我们经常会考虑一些用例，这些用例将会为消费者实质性地解决问题，让他们的健康状况变得更好，为他们省钱，让他们更快乐。也许这是因为我们仍然处于可穿戴设备的早期阶段，但我们仍然需要给消费者一个佩戴可穿戴设备的理由。

减少吸烟

吸烟是一个真正的问题。它杀死人，花费医疗系统一吨，对除了卖香烟的人之外的所有玩家都是可怕的

这也是一个难以解决的问题，否则我们仍然不会有世界各地的十亿烟民，他们每年至少尝试戒烟一次，但收效甚微

Kiwi is on a mission to make the lives of at least a billion people happier and healthier

这是一种能带来实实在在的健康和经济利益的产品，例如，如果它起作用，你知道，你会感觉+看起来更好，每个人(包括你爱的人、银行账户、医生……都更开心),这是使用手表应用程序比使用电话能提供好 10 倍的东西

Cue App for Android Wear

这也有助于我们团队中的两个人是吸烟者，所以我们有第一批豚鼠来测试我们软件的最早版本。在与数百名客户交谈后(这很容易，因为他们通常在建筑物外闲逛)，我们继续完善设计、功能和用户体验

我们最近运行了一个初始用户组，基于我们的目标人口统计，但我们不知道的人。我们发现我们的朋友过于担心我们的感受

我们测试的第一个假设是，人们是否真的会比平时等待更长的时间来抽下一支烟。在我们应用程序的第一版中(由于我们在动作识别方面的工作，自动跟踪率达到 99%)，我们对一个人群进行了 30 天的采样

以下是我们目前收集的数据的简要概述:

要点: 人们会比平时等待 更长时间，他们 经常在下午 3 点 吸烟，每天的吸烟模式变化很大(毕竟人生是不可预测的)，而 总的趋势是一致地减少吸烟 如果部署了一个 极其个性化的计划 来减少吸烟

**Hypothesis 1: Do People Wait for Suggested Cigarette Time?**Before Suggested Time: 0359
After Suggested Time: 1049
Total Cigarettes : 1408**Answer so far: YES**

Most Common Time To Smoke (3PM “coffee break”)

Our Market Test User Base : Wide Variations on a Daily Basis

Up to 50% Reduction Across 3 month Period Over a Testing Sample User Base

验证我们的假设

这就是我们需要你帮助的地方；我们在多伦多的一个小组中进行了本地测试，每个小组都成功实现了高达 50%的减排。

我们现在希望将我们的应用程序推广到尽可能大的群体中；人们进一步测试，并帮助我们进一步完善我们的产品，以杜绝吸烟

该应用程序的习惯改变部分通过积分鼓励你为下次吸烟多等几分钟，这些积分可以让你在星巴克/优步获得奖励，双赢！我们已经请了一些最好的戒烟专家来找出我们计划中的漏洞，他们都鼓励我们继续这个项目。但是没有什么比 10，000 个更健康的用户更能证实一个假设，所以我们需要你的帮助

如果你吸烟，请注册或者通过与吸烟的朋友分享来帮助你。只需轻点几下鼠标，你就能让某人的生活发生巨大变化

Cue Product Screenshots

技术方面

这篇文章的剩余部分将讨论我们产品的机器学习方面，包括

识别每个人独特的运动模式&从所有其他动作中辨别吸烟[自动分类]
基于个人和综合数据预测一个人何时会吸烟

自动分类:最佳用户体验

我们发现最好的用户体验是用户不需要做任何事情，仍然感觉他们在赢。为了在吸烟时做到这一点，我们需要想出一种方法来自动检测用户何时吸烟。我们通过使用带有动作识别的 kiwi 工具包来实现这一点，就像我们如何计算步数一样，我们检测手到嘴的运动来确定一个人何时吸烟

重要的一点是我们所有的分类算法都在手表上运行；因此，一旦应用程序被下载，没有连接到您的手机或互联网需要让它工作！

神经网络用于分离可能重叠的动作，如举起物体、举手行走或热情交谈

这是一个在线性判别分析中展示这种分离的奇特图表:

How Smoking Separates From Walking and Other Movements

预测一个人何时可能吸烟

为了更好地帮助人们将吸烟的间隔时间推得越来越长；需要预测你预期的下一支烟会是什么时候，从这里我们稍微增加一点时间来保持行为改变的微妙影响

下面是一周内人们每天吸烟的情况:

See how there are breaks each day and Saturday and Sunday are a bit later than weekdays

预测以及为什么这是有价值的

类似于能够自动检测一个人何时吸烟，可以应用一种方法来预测用户一天中何时吸烟，像大多数模型问题一样，挑战是如何获得干净的数据，并确保您有一个相关的基准。例如，卷积神经网络可以用于照片，其中不同的 RGB 信号可以分离，以定义带标签的猫和狗照片之间的差异。这如何应用于一天中的几个数据点，比如吸烟次数？

Feature Separation For Predicting a Person’s Next Smoke

我们所做的是生成特征，以在我们的整个用户群中进行归纳，从而找到有区别的信息，上图显示了三个特征的示例:

功能 1:当前和上一次 cig 之间的时间
功能 2:当前星期几，格式:[0..6] - >周一..太阳
特征 3:当前时间，格式:格式

使用这些特征，我们能够得出最近 30 分钟或 60 分钟的预测；有了这个，我们可以帮助用户先发制人，通过散步、玩游戏或喝咖啡来控制下次吸烟的冲动，以后还会有更多！

如果你吸烟，请注册或者通过与吸烟的朋友分享来帮助你。只需轻点几下鼠标，你就能让某人的生活发生巨大变化

由阿里·纳瓦布和约翰·大卫·奇布克以及戴夫·金和马哈茂德·埃尔萨夫塔维撰写

附言:我们将尽力回答你的问题，并在本帖中分享常见问题

常见问题:

这款应用能在 iPhones 上使用吗？可以，但是你需要一个智能手表来和你的 iPhone 配对
app 准备好了吗？是的，这叫谷歌 Play 商店提示。它目前处于测试阶段，所以我们需要邀请您访问它
我如何联系 Kiwi，我想提供帮助，我想为我的公司/团队运行一个程序？是最好的联系方式，如果你愿意参与我们会超级开心
这款应用有什么风险吗？这是测试版产品，每周都会更新，所以有时会出错。也有可能该应用程序对特定类型的用户不立即起作用，这有助于我们改进它
会消耗我很多手表电池吗？不会。原因有两个:1)我们的动作识别算法已经过一些世界领先公司的低功耗测试；2)我们针对每个人的吸烟模式进行优化，从而减少电池消耗**
我的吸烟模式是独特的，例如，我在斋月禁食，它仍然对我有效吗？是的，我们的产品是成为你教练的软件，只有当它对你的生活非常个性化时才会有用，所以如果你连续一个月在日出和日落时抽两支烟，它会相应地适应**
我已经戒烟了，这个应用程序会有帮助吗？如果你已经放弃了，请不要再开始。如果你不幸故态复萌，我们会努力让你下一次的戒烟尝试变得更好**
该应用程序可以与 vapes 和电子烟一起使用吗？是的。请报名。我们将对蒸发设备进行单独研究，并将您添加到等候名单中**
这款应用的价格是多少？该应用程序对市场调查的参与者免费**
你如何为我的吸烟数据保密？kiwi . ai 上的所有项目包括 Cue 都遵守我们公司的隐私政策，可在https://kiwi.ai/#/privacy获得

将伦理应用于算法

原文：https://towardsdatascience.com/applying-ethics-to-algorithms-3703b0f9dcf4?source=collection_archive---------11-----------------------

这篇文章是由 GovEx 博客 整合而来的 ，做了一些小的编辑。

Photo credit: Josh Riemer via unsplash

当我受雇于我的第一份政府工作时，我必须签署许多文件。其中一些表格表明我已经阅读了市的利益冲突法和相关的道德规范。起初，我并不理解它们的重要性，但随着我在公务员队伍中的职业生涯的继续，我见证了一些人如何破坏公众的信任，从轻微的违规到公然的腐败。随着我被提升到更高的职位，拥有更大的权力，我不仅仅需要签署表格承认我阅读了道德声明；我还必须接受背景调查，手写超过 100 页的问题答案，包括我个人财务的例行披露。随着我获得纳税人资金和决策权的机会增加，评估我的可信度的努力也在增加(当然，滥用这两者的可能性也在增加)。为了让政府运作良好，重要的是“我们人民”相信这种权力不会被滥用。这些工具保护了我、政府，最重要的是，保护了我所服务的公众。

几十年来，政府一直在使用技术来更准确地跟踪事情，使事情更有效率，并做出基于事实的决策。今天，我们正在进入一个新时代，政府领导人越来越多地将决策权从人转向技术，特别是随着人工智能(AI)的兴起。然而， 我们并没有像调查我们赋予权力 的人那样仔细地调查技术工具。这部分是因为我们没有希望我们的技术遵循的一套明确的道德规范(例如，“平等对待每个人”与“公平对待每个人”)。但这也部分是因为政府领导人没有获得持续和系统地调查人工智能的工具，以了解它可能在哪里成功或失败。从社交媒体到社交服务我们每天都听到算法如何破坏人们的生活并进一步加剧不信任的故事——通常是在那些已经被边缘化的人群中。

这就是为什么 Joy Bonaguro、Miriam McKinney、Dave Anderson、Jane Wiseman 和我自二月份以来所完成的工作如此重要。2018 年 9 月 16 日，周日，在纽约市的 Data for Good Exchange (D4GX)上，我们公开发布了我们的 政府伦理和算法工具包(其他也是！) 。该工具包旨在帮助政府管理人员描述将权力转移给自动化工具的相关风险，并有望妥善管理这些风险。这是我们的第一步，我们预计将会有一段漫长的路要走，才能将我们应用于人类的道德原则应用于我们的技术。

在 D4GX，我们举办了一个研讨会，邀请参与者将工具包应用到他们正在处理的问题或我们提供的示例场景中。在房间里呆了一个小时后，我们从参与者那里收集了很多很好的反馈，非常感谢我们一起进行的对话。我们已经收集了由此产生的建议，并将在不久的将来将它们应用到工具包中。下个月，我们将在 2018 MetroLab 峰会上与政府领导及其学术合作伙伴举办类似的研讨会。我们期待着更多的反馈，但更重要的是，我们希望那些参加研讨会的人能够在他们与我们一起度过的时间之外，继续将该工具包应用到他们的项目中..

毕竟，维护道德标准不仅仅要求人们填写表格并签字；它要求在怀疑存在伤害时进行调查——无论是有意还是无意。这需要认识到公众信任何时受到损害，并找出如何恢复这种信任。因此，这个工具包不仅仅是一个在人工智能项目开始时要完成的清单。更确切地说，它是一个“活的指南”,在该技术仍处于公共服务阶段时，可以持续地用于对话和管理实践。

我们还认为，该工具包的应用范围远远超出了公共部门，只需做一些调整..例如，医疗从业者在使用像 IBM Watson Health 这样的解决方案来帮助诊断和治疗患者时，可以应用该工具包的一个版本。风险投资公司可以使用不同的版本，确保他们的自动化投资不仅符合他们的组织使命和价值观，也符合他们将影响的社区的使命和价值观。大型科技公司甚至可能使用不同的版本来思考他们的产品如何可能无意中导致更多的过滤泡沫或更深的边缘化。

如果您对使用该工具包感兴趣并需要帮助，我们很乐意提供帮助！请在govex@jhu.edu联系，访问 GovEx 联系页面，或在推特上找到我们。当然，你也可以通过工具包网站联系我们，https://ethicstoolkit.ai/

将 GANs 应用于超分辨率

原文：https://towardsdatascience.com/applying-gans-to-super-resolution-59224763f960?source=collection_archive---------17-----------------------

SRGAN Results from Ledig et al. [3]

生成对抗网络在深度学习中有很多应用。使用 GANs 可以更好地解决的一个有趣问题是超分辨率。超分辨率是一项将图像从 90 x 90 的低分辨率尺寸放大到 360 x 360 的高分辨率尺寸的任务。在本例中，90 x 90 到 360 x 360 表示放大倍数为 4 倍。

超分辨率的一个解决方案是训练深度卷积网络，该网络接收数据，其中输入是低分辨率补丁，标记的输出是高分辨率补丁。这不同于许多监督学习问题，其中输出是 1 或 0 或者类预测的向量。在这种情况下，输出是一个图像。这些网络通过一系列卷积、全连接或转置卷积层从低分辨率面片学习到高分辨率面片的映射。例如，该网络可以获取一个 30 x 30 的低分辨率面片，对其进行几次卷积，使特征图类似于 22 x 22 x 64，将其展平为一个矢量，应用几个完全连接的层，对其进行整形，最后通过转置卷积层将其上采样为 30 x 30 的高分辨率面片。

这样做的一个问题是很难设计一个有效的损失函数。用于此目的的常见损失函数是网络输出面片和地面实况高分辨率面片之间的 MSE(均方误差)。这个损失函数的一个解决方案是使用 Johnson 等人开发的感知损失函数[1]。该损失函数是通过取网络输出面片和高分辨率面片之间的 VGG 网络[2]的高层中的特征映射激活的差异来计算的。因此，特征图激活被表示为感知损失度量。

Ledig 等人[3]证明，GANs 进一步改善了这种损失函数的发展。除了感知的、内容的损失之外，还增加了对抗性的损失，以进一步将图像推向自然的图像流形。GAN 框架被集成以表示由生成器创建的面片是否类似于高分辨率面片的基本事实集合。然后，通过对抗损失以及感知损失(由来自输出补片和地面真实补片的 VGG 特征图激活的差异表示)来计算发生器网络的误差。

看到如何使用多个损失函数来优化神经网络是非常有趣的。在这种情况下，每个损失函数都提供了对问题的独特视角。感谢您的阅读，如果您对这个话题感兴趣，请查看下面的论文！

参考文献:

[1]实时风格转换和超分辨率的感知损失。贾斯廷·约翰逊，亚历山大阿拉希，李菲菲。

[2]用于大规模图像识别的非常深的卷积网络。卡伦·西蒙扬，安德鲁·塞斯曼。

[3]使用生成式对抗网络的照片级单幅图像超分辨率。Christian Ledig、Lucas Theis、Ferenc Huszar、Jose Caballero、、Alejandro Acosta、Andrew Aitken、Alykhan Tejani、Johannes Totz、、史久镛。

逻辑回归在 PubMed 中的应用

原文：https://towardsdatascience.com/applying-logistic-regression-to-pubmed-45856503a52b?source=collection_archive---------24-----------------------

“该指南是权威性的。现实往往是不准确的。”

――道格拉斯·亚当斯，《银河系漫游指南》

在我的上一篇文章中，我们研究了如何从 PubMed 收集的大量医学文章中获得有意义的见解，PubMed 是一个免费的生物医学和生命科学文献档案库。这一次，我们将继续与医学文章合作，创造一些完全不同的东西。我们将使用监督机器学习来识别特定主题的文章。

由于数据科学家是一个长时间保持坐姿的人(你现在可能正在伸直你的背)，我决定建立一个文本分类模型来预测一篇文章是否是关于肌肉骨骼疾病的。

为了实现这一点，我们将需要一个带标签的数据集，它将包含等量的关于肌肉骨骼疾病和其他医学状况的文章。一种方法是遵循这些简单的步骤。

收集文章

这很简单。物品存放在这里。我们只需要下载合理数量的文件并解压。

解析 XML 文件

像上次一样，我们将使用这个漂亮的 Python 解析器从文件中获取必要的数据。

#return list of dictionariesdicts_out = pp.parse_medline_xml('data/pubmed19n0001.xml.gz', year_info_only=False, nlm_category=False)

因此，每篇文章都将由一个包含所有基本属性的字典来表示，如标题、摘要、pmid、作者、期刊、出版日期等。幸运的是，在我们的小实验中，我们真正需要的两样东西是摘要和网格术语。

处理网格术语

你会问我，这些术语是什么？MeSH(医学主题词)是美国国家医学图书馆的受控词汇词库，用于为 PubMed 检索文章。本质上，它是一个按层次排列的医学术语词汇表，每个医学术语都有一个唯一的 ID。由于 MeSH 经常用于描述 PubMed 的期刊文章的主题内容，我们可以使用 MeSH 术语作为一篇文章是否是关于肌肉骨骼疾病的良好指标。

当然，我们可以从 MeSH 官方网站手动收集与肌肉骨骼疾病相关的 MeSH 术语，然而，对此有一个更简单的解决方案。你可以在 NLM 网站上找到一个名为 d2019.bin 的 ASCII 文件，其中有完整的网格术语列表。如您所见，该文件的结构很难处理。这是一个网状记录的样子。

MeSH record

我们需要做的就是收集属于网格树的期望部分(C05)的所有网格 id。为此，我们将查看词汇表中的所有记录，并获取树位置(表示为“MN”)以 C05 开始的所有记录的网格 id(表示为“UI”)。注意，一些网格术语可能有几个树位置。

MeSH IDs related to Musculoskeletal Diseases (a fraction of a full list)

好了，现在我们准备好给数据集加标签了。假设我们的文章已经存储在数据库中(假设 MongoDB )，通过检查一篇文章是否具有属于新收集的 C05 网格 id 列表的网格 id，很容易对它们进行标记。完成这项任务的有效方法是使用 Celery 来并行处理工作。

接下来是激动人心的部分

为了将给定的抽象分类到这两个类别中的一个，我们将建立一个逻辑回归模型。但是首先，我们需要改变摘要的表示。我们将使用通用语句编码器将每个摘要编码成一个高维向量。通用句子编码器是在大型语料库上预先训练的，可以用于各种任务(情感分析、分类等)。该模型以单词、句子或段落作为输入，并输出 512 维向量。

最后，我们将使用 Python 的 scikit-learn 库来拟合 Logistic 回归模型并进行预测。

Confusion matrix

看起来我们做得很好。混淆矩阵表明，我们的模型在 84%的情况下正确预测了肌肉骨骼疾病的摘要。其他主题的摘要在 86%的情况下被正确预测。

结论

由于医学文献通常使用相似的术语，并且有大量的文章描述了一种以上的疾病，因此很难达到 100%的准确性。然而，这个例子告诉我们，建立一个可靠的分类模型并使用它来准确地识别特定主题的医学文章是可能的。随着科学出版物的数量每年增长越来越快，使用机器学习来促进搜索并自动将小麦从谷壳中分离出来变得越来越重要。

应用机器学习对无监督文本文档进行分类

原文：https://towardsdatascience.com/applying-machine-learning-to-classify-an-unsupervised-text-document-e7bb6265f52?source=collection_archive---------3-----------------------

Fig: Text Classification

文本分类是一个问题，其中我们有一组固定的类/类别，并且任何给定的文本都被分配到这些类别之一。相比之下，文本聚类的任务是将一组未标记的文本分组，使得同一组中的文本(称为簇)彼此之间比其他簇中的文本更相似。

在这里，我自己创建了一个文档，其中包含两种与板球或旅行相关的句子。

**document** = [“This is the most beautiful place in the world.”, “This man has more skills to show in cricket than any other game.”, “Hi there! how was your ladakh trip last month?”, “There was a player who had scored 200+ runs in single cricket innings in his career.”, “I have got the opportunity to travel to Paris next year for my internship.”, “May be he is better than you in batting but you are much better than him in bowling.”, “That was really a great day for me when I was there at Lavasa for the whole night.”, “That’s exactly I wanted to become, a highest ratting batsmen ever with top scores.”, “Does it really matter wether you go to Thailand or Goa, its just you have spend your holidays.”, “Why don’t you go to Switzerland next year for your 25th Wedding anniversary?”, “Travel is fatal to prejudice, bigotry, and narrow mindedness., and many of our people need it sorely on these accounts.”, “Stop worrying about the potholes in the road and enjoy the journey.”, “No cricket team in the world depends on one or two players. The team always plays to win.”, “Cricket is a team game. If you want fame for yourself, go play an individual game.”, “Because in the end, you won’t remember the time you spent working in the office or mowing your lawn. Climb that goddamn mountain.”, “Isn’t cricket supposed to be a team sport? I feel people should decide first whether cricket is a team game or an individual sport.”]

创建上面的文档是为了展示如何将句子分为两个不同的类别，因为这里只提到了两种句子。

因此，我们现在需要导入必要的库，我们开始吧:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
import numpy as np
import pandas as pd

这里我们使用了 TfidfVectorizer。那么什么是 TF-IDF 呢？

在信息检索或文本挖掘中，术语频率-逆文档频率也称为 tf-idf，是一种众所周知的评估文档中单词重要性的方法。tf-idf 也是将信息的文本表示转换成向量空间模型(VSM)的一种非常有趣的方式。

谷歌已经在用 TF*IDF(或者 TF-IDF，TFIDF，TF。IDF，艺术家原名 Prince)作为你的内容的排名因素已经很长时间了，因为搜索引擎似乎更注重词频而不是计算关键词。

TFIDF 是一种信息检索技术，它衡量术语的频率(TF)及其逆文档频率(IDF)。每个单词或术语都有其各自的 TF 和 IDF 得分。一项的 TF 和 IDF 得分的乘积称为该项的 TFIDF 权重。

TFIDF 算法用于对任何内容中的关键字进行加权，并根据该关键字在文档中出现的次数为其分配重要性。更重要的是，它检查关键字在整个网络中的相关性，这被称为语料库*。

TF-IDF weights formula

我们必须使用 TfidfVectorizer 类创建矢量器，以适应和转换我们创建的文档:

vectorizer = TfidfVectorizer(stop_words='english')
X = vectorizer.fit_transform(document)

我们现在需要理解我们将在文本文档中使用的 K-means 算法。

K-means 是解决众所周知的聚类问题的最简单的无监督学习算法之一。该过程遵循一种简单且容易的方式，通过先验固定的一定数量的聚类(假设 k 个聚类)来对给定数据集进行分类。主要思想是定义 k 个质心，每个聚类一个。因为不同的位置会导致不同的结果，所以这些质心应该被巧妙的放置。因此，更好的选择是将它们放置在尽可能远离彼此的地方。下一步是获取属于给定数据集的每个点，并将其与最近的质心相关联。当没有点悬而未决时，第一步完成，早期分组完成。在这一点上，我们需要重新计算 k 个新的质心作为上一步得到的聚类的重心。在我们有了这 k 个新质心之后，必须在相同的数据集点和最近的新质心之间进行新的绑定。

我们现在将在下面的矢量化文档中实现 k-means 聚类算法:

true_k = 2
model = KMeans(n_clusters=true_k, init='k-means++', max_iter=100, n_init=1)
model.fit(X)

我们将获得以下输出:

Out[5]: 
KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=100,
    n_clusters=2, n_init=1, n_jobs=1, precompute_distances='auto',
    random_state=None, tol=0.0001, verbose=0)

现在执行下面的代码来获得质心和特征

order_centroids = model.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names()

Centroids

terms

现在我们可以打印出它们所属的簇的质心

for i in range(true_k):
 print(“Cluster %d:” % i),
 for ind in order_centroids[i, :10]:
 print(‘ %s’ % terms[ind])

我们将得到下面的输出

**Cluster 0:**
 better
 game
 ladakh
 month
 hi
 trip
 stop
 journey
 worrying
 highest
**Cluster 1:**
 cricket
 team
 world
 year
 really
 game
 travel
 place
 beautiful
 skills

我们现在可以预测文本句子，这可以告诉我们该句子属于哪个簇

print(“\n”)
print(“Prediction”)
X = vectorizer.transform([“Nothing is easy in cricket. Maybe when you watch it on TV, it looks easy. But it is not. You have to use your brain and time the ball.”])
predicted = model.predict(X)
print(predicted)

这将产生以下输出:

Prediction
[1]

因此，这里我们得到了预测为[1]，这意味着它属于与板球相关的集群 1，因此我们的测试句子也在谈论板球的事实。所以我们的预测是正确的。我们也可以用其他句子来测试一下，看看这个是否有效。这个模型并不总是能给你准确的结果，但是为了得到更准确的结果，我们需要更多的数据或更多的文本来改进我们的模型并提供更好的结果。

因此，我们已经建立了我们的第一个文本分类器，它可以预测句子属于哪个类/簇。所以我希望你喜欢这篇文章，请不要忘记在评论区留下你的评论和疑问。也请让我知道，如果你在这里发现任何改进的地方，那将是非常可观的。

你也可以给我发一封关于 vishabh1010@gmail.com 的电子邮件，或者打电话+919538160491 给我。也可以通过 linkedin 联系我。

将机器学习应用于 DevOps

原文：https://towardsdatascience.com/applying-machine-learning-to-devops-5fb7d69ac366?source=collection_archive---------2-----------------------

本文是一篇客座博客，作者:安迪·曼，首席技术顾问，Splunk供稿:杰夫·斯潘塞，高级工程师， Splunk

DevOps 和机器学习(ML)之间存在强大的协同作用——以及相关的能力，如预测分析、IT 运营分析(ITOA)、算法 IT 运营(AIOps)和人工智能(AI)。

从概念上讲，ML 代表了 Gene Kim 的“持续学习文化”的编纂和加速。使用 ML DevOps，团队可以挖掘大量复杂的数据集，检测模式和反模式，发现新的见解，迭代和细化查询，并持续重复—所有这些都以“计算机速度”进行。

同样，ML 在许多方面是下一代自动化，建立在约翰·威利斯和达蒙·爱德华兹为“CAMS”开出的处方之上。通过自动化，DevOps 实现了更快的 SDLC，但对于正常人的理解来说，SDLC 太不透明、太分散、太动态、太短暂。但是像自动化一样，ML 独特地处理由新的交付过程和下一代可组合、原子化和扩展的应用程序产生的速度、数量和各种数据。

在实践中，将 ML 应用于 DevOps 的一些关键示例包括:

跟踪应用交付

来自“DevOps 工具”的活动数据(如吉拉、Git、Jenkins、SonarQube、Puppet、Ansible 等。)提供交付过程的可见性。应用 ML 可以发现数据中的异常——大量的代码、长的构建时间、缓慢的发布率、延迟的代码检入——来识别软件开发的许多【浪费】，包括镀金、部分工作、低效的资源配置、过多的任务切换或者过程减慢。

确保应用质量

通过分析测试工具的输出，ML 可以智能地检查 QA 结果，检测新的错误，并基于发现有效地构建测试模式库。这种由机器驱动的对“已知良好版本”的理解有助于确保对每一个版本进行全面的测试，即使是新的缺陷，从而提高交付的应用程序的质量。

保护应用交付

用户行为模式可以像指纹一样独一无二。将 ML 应用于开发和运营用户行为有助于识别可能代表恶意活动的异常。例如，对敏感回购、自动化例程、部署活动、测试执行、系统配置等的异常访问模式可以快速突出用户使用“已知的不良”模式(无论是有意还是无意)，如编写后门程序、部署未经授权的代码或窃取知识产权。

管理生产

分析生产中的应用程序是机器学习真正发挥作用的地方，因为有更大的数据量、用户数量、交易等。与开发或测试相比，这发生在生产阶段。DevOps 团队可以使用 ML 来分析“正常”模式——用户量、资源利用率、事务吞吐量等。—随后检测“异常”模式(例如 DDOS 情况、内存泄漏、竞争情况等。).

管理警报风暴

ML 的一个简单、实用、高价值的用途是管理生产系统中出现的大量警报。这可以简单到 ML 分组相关警报(例如，通过公共交易 ID；一组公共服务器；或者公共子网)。或者可能更复杂，例如随着时间的推移“训练”系统来识别“已知良好”和“已知不良”警报。这使得过滤能够减少警报风暴和警报疲劳。

故障排除和分类分析

这是当今 ML 技术大放异彩的另一个领域。ML 可以自动检测，甚至开始智能分类“已知问题”，甚至一些未知问题。例如，ML 工具可以检测“正常”处理中的异常，然后进一步分析发布日志，将这个问题与新的配置或部署相关联。其他自动化工具可以使用 ML 来提醒操作，打开票证(或聊天窗口)，并将其分配给正确的资源。随着时间的推移，ML 甚至可以提出最佳的解决方案！

防止生产故障

在预防故障方面，ML 可以远远超越直线产能规划。ML 可以映射已知的良好利用模式，以预测例如期望性能水平的最佳配置；有多少客户会使用新功能；新促销的基础设施要求；或者断电会如何影响客户参与。ML 在系统和应用程序中发现了不透明的“早期迹象”,使运营部门能够以比一般响应时间更快的速度开始补救或避免问题。

分析业务影响

理解代码发布对业务目标的影响对于开发运维的成功至关重要。通过综合和分析真实用户指标，ML 系统可以检测好的和坏的模式，以便在应用程序出现问题时向编码人员和业务团队等提供“早期预警系统”(例如，通过早期报告购物车放弃增加或缩短的买家旅程)；或者非常成功(例如，通过早期检测高用户注册或点击率)。

当然，对于 ML 来说还没有简单的按钮。智力、经验、创造力和勤奋是不可替代的。但是我们今天已经看到了很多这样的应用，随着我们继续拓展边界，天空就是极限

迁移学习在自然语言处理和计算机视觉中的应用

原文：https://towardsdatascience.com/applying-transfer-learning-in-nlp-and-cv-d4aaddd7ca90?source=collection_archive---------0-----------------------

在这篇博文中，我将讨论迁移学习的两个应用。我将概述自然语言处理和计算机视觉领域的例子。

这篇博文是迁移学习系列的第二篇。可以找第一篇博文，里面解释了迁移学习的基本概念，这里。

自然语言处理

我之前的一篇博文讨论了现在很多 NLP 管道是如何使用单词嵌入的。与一次性编码相比，这些单词嵌入是一种更具信息性的单词表示方式。它们被广泛使用，并且存在不同的变体。典型地，这些变体在它们所源自的语料库中是不同的，例如维基百科、新闻文章等。，以及嵌入模型的差异。了解这些模型和语料库的背景对于了解单词嵌入的迁移学习是否合理是很重要的。人们通常不会把单词嵌入的使用称为迁移学习，但我不同意，因为它与计算机视觉中的迁移学习有相似之处。本质上，使用单词嵌入意味着您正在使用特征或嵌入网络将单词转换为信息向量。

Different approaches exist to represent words in NLP (a word embedding like representation on the left and a BoW like representation on the right). With word embeddings a machine learning model can leverage the relationships that exist between different words.

即使 word2vec 已经 4 岁了，但它仍然是一种非常有影响力的单词嵌入方法。另一方面，最近的方法如 FastText 已经使单词嵌入在许多语言中可用。与单词包方法相比，来自 word2vec 或 FastText 的嵌入是一个重大进步。然而，它们的有用性通常是由问题域决定的。

假设您正在为销售人员构建一个新闻推荐服务。销售人员希望收到对他们销售的产品感兴趣的公司的消息。新闻文章中使用的词汇通常是相当通用的，这意味着所使用的词汇受到大多数单词嵌入的支持(取决于它们被训练的语料库)。此外，如果你让销售人员收集他们连续几周阅读的新闻文章，那么你马上就会有一个大的带标签的语料库。通过能够重用单词嵌入，推荐引擎的性能可能会比简单的 BoW 模型好得多。

另一方面，设想你要对法律合同进行话题分类。不是任何类型的法律合同，而是竞争法背景下的法国法律合同。这些类型的数据集通常没有标记，或者只有有限的一组标记文档可用。下一节将描述为什么开箱即用的迁移学习在这种情况下只能让您到此为止:

词汇外(OOV)单词是在训练期间没有见过的单词。虽然 word2vec 和 FastText 是在例如 Wikipedia 或其他 copora 上训练的，但是使用的词汇是有限的。在训练中，不经常出现的单词经常被忽略。这意味着竞争法法律合同中的特定领域词语可能因此得不到支持。当使用预先训练的单词嵌入时，通常检查 OOV 单词并用 UNK 记号(未知单词记号)替换它们，并且所有这些单词被分配相同的向量。如果语料库是特定于领域的，这是非常无效的，因为特定于领域的单词通常具有很多含义。如果大部分(有意义的)单词被 UNK 代币代替，那么模型将不能学到很多东西。
标准预训练单词嵌入的替代方法是在大型无监督文档集上微调嵌入。请注意，这只是在有大量文档可用时的一个选项。这意味着，如果你有一个大的竞争法语料库，你可以从其他更一般的单词的预训练单词嵌入开始，训练特定领域单词的单词嵌入。通常，从预先训练的单词嵌入开始会加快整个过程，并且会使训练你自己的单词嵌入更容易。注意，使用开箱即用的单词嵌入仍然比较困难，并且需要一些关于如何为单词嵌入训练准备语料库的知识。

我强烈建议你阅读这篇关于单词嵌入现状的优秀博文。在处理有限数量的数据时，考虑这篇博客中提到的问题和解决方案是创建健壮的 NLP 系统和单词嵌入的关键。

Gensim、spacy 和 FastText 是三个很好的框架，允许您在机器学习应用程序中快速使用单词嵌入。此外，它们还支持自定义单词嵌入的训练。查看这个 gensim ，这个 spacy 或者这个 FastText 教程了解更多！

计算机视觉中的迁移学习

深度学习方法已经在计算机视觉领域取得了重大成功。而不是必须手动定义特定于问题的特征，例如，梯度方向直方图(HoG)特征、颜色特征等。，深度学习允许从业者训练以原始图像作为输入的模型。

Based on the type of problem, different types of HOG features need to be defined. These are one class of visual features that can be used in computer vision. Note the similarity with the features that extracted by convolutional networks below.

要素定义的原始复杂性现在已经转向定义网络的复杂性。虽然体系结构经常被重用，但是在构建网络体系结构时没有单一的策略。通常，深度学习技术已经被发明并应用于对巨大数据集的研究设置中(如 Imagenet 或 MS Coco )。为了提高这些大型数据集的性能，研究人员提出了深度和复杂性不断增加的网络架构。这些架构导致具有数百万参数的模型(通常)不可扩展到小型图像数据集。在少于 5000 个图像的数据集上训练诸如 ResNet 或 VGG 网的架构只会导致显著的过度拟合。最近的深度学习趋势带来了重大进步，但似乎只有小数据集的数据科学家被冷落了。

事实证明，深度学习网络学习分层的特征表示(见这篇博文by distilt)。这意味着较低级别的层学习较低级别的特征，例如边缘，而较高级别的层学习较高级别的、但不可解释的概念，例如形状。当在不同的数据集上训练网络时，也会出现这种等级要素表示的想法，这表明它们可以在不同的问题域中重复使用。

Being able to distinguish lines and shapes (left) from an image makes it easier to determine if something is a ‘car’ than having to start from the raw pixel values. Transfer learning allows you to leverage learned patterns from other computer vision models.

当在计算机视觉问题上使用迁移学习时，使用两种方法。

首先，如果有相当数量的图片(每类超过 1，000 张图片)，您可以使用在不同数据集上训练的模型的权重来初始化新模型。在训练过程中，您将保持一定数量的层(通常是第一个卷积层)不变，并优化更高层的参数。目标是减少需要优化的参数数量，同时重用较低级别的层。无论问题领域如何，较低级别的层最有可能是相似的，并且模型必须能够自由地将较高级别的层组合在一起，具体到问题。
第二，如果只有很少的图片可用，Keras 的 API 允许你加载预训练的网络，并在训练期间保持几个层不变。在下一节中，我将再次讨论两个用例，分别是迁移学习有用的情况和无用的情况。

想象一下，在野生动物保护领域工作，您想要对出现在实时摄像机画面上的不同动物进行分类。尤其是如果你正在尝试监测濒临灭绝的物种，你可能无法收集大量的标记数据。假设预训练的网络通常在广泛的概念领域(从食物到动物和物体)上被训练，使用预训练的网络作为特征或初始化器肯定是一个选项。

另一方面，假设您需要为肿瘤学家分析放射图像。这些图像不是典型的猫狗图像，因为它们是对病人进行扫描的输出。这些图像虽然被转换为 RGB 图像，但通常以灰色阴影显示扫描结果。虽然预训练的网络能够从 RGB 图像中检测形状和边缘，但是它们很可能很难检测射线照相图像上的形状和边缘，因为这些形状和边缘不在预训练模型的训练数据中。此外，在医疗场景中，标记的数据量通常很低。有几种技术可以利用(潜在丰富的)未标记数据，但它们通常需要更多的工作和微调。通常，这些技术试图通过迭代训练每一层来重建图像(使用卷积和反卷积层)，从而预先训练分类网络的权重。这些技术和预训练网络的组合通常用于改善收敛。

上面提到的计算机视觉中的两种方法都依赖于一个重要的假设:在原始数据集中提取的模式在新数据集的上下文中是有用的。这种有用性很难量化，但它是一个需要考虑的重要假设。地震、超光谱甚至医学图像与 ImageNet 中的图像相似度有限。然而，确定图像包含哪个交通标志依赖于相当相似的模式。理解计算机视觉问题域对于成功应用计算机视觉至关重要。通过了解模型的背景(数据集、技术等。)用于迁移学习，您可以避免在实验中浪费时间，并专注于微调那些可能产生影响的模型。

如果你有任何问题，我很乐意在评论中阅读。如果你想收到我博客上的更新，请在 Medium 或 Twitter 上关注我！

If you have any questions, I’ll be happy to read them in the comments. Follow me on Medium or Twitter if you want to receive updates on my blog posts!

多标签分类方法

原文：https://towardsdatascience.com/approaches-to-multi-label-classification-1cf981ff2108?source=collection_archive---------7-----------------------

图像的多标签分类处理图像可能属于一个以上类别的情况。例如，下图在同一张照片中有一列火车、一个女人、一个女孩和一个按摩浴缸。

Photo Credit: Open Image Dataset V4 (License)

有多种方法可以解决这个问题。第一种方法是二元分类法。在这种方法中，我们可以使用“k”个独立的二元分类器，对应于我们数据中的 k 个类。

这种方法的最后一层是由 k 个独立的 sigmoid(后勤)激活。类别预测基于物流层的阈值。

这种方法易于理解和训练。然而，这种方法有一个缺点。我们忽略了标签之间的语义关系。例如“人脸”和女人是相关的。人面和少女也是。

标签关系编码的多标签分类

有多种方法来编码标签之间的语义关系。在这篇笔记中，我描述了 3 个不同的想法。

第一种方法是使用图表来创建标签关系。这种标签关系可以是先验知识(参见参考文献[1]、[3])。例如，基于先验知识的分层图可以对“人脸”是“女人”和“女孩”的双亲这一事实进行编码。这种方法可以扩展到创建复杂的结构。例如，我们可以对排斥的概念进行编码——人脸不能是猴子，或者重叠——女人可以既是母亲又是孩子。这种方法的主要问题是处理图形的复杂性，经过一段时间后，它变得专用于特定的域，而不能扩展到其他域。

第二种方法是独立地从数据中学习标签关系。参考文献[2]中有一个早期的例子。标签关系由贝叶斯网络或马尔可夫网络捕获。贝叶斯网络也是一个图形。它可以是无环图形模型，其中每个节点代表一个标签，有向边代表一个标签对另一个标签的概率依赖性。这种图的参数通常可以通过最大似然估计来学习。使用这些图形模型的一个大挑战是理解模型结构的问题。众所周知，贝叶斯网络的精确推理和结构估计都是 NP 难问题。参见参考此处。

我们将考虑的最后一种方法是用于多标签图像分类的统一 CNN-RNN 框架，它有效地学习标签之间的语义关系。这种方法的一个很好的参考是王江和团队的论文[4]。在这种方法中，RNN 模型学习联合低维图像-标签嵌入来建模图像和标签之间的语义相关性。图像嵌入向量由深度 CNN 生成。

在这种联合嵌入中，多个标签的概率作为所有标签上的有序预测路径被顺序计算。参考文献[4]中的一张图片给出了关于该架构的良好直觉。

RNN-CNN architecture from reference [4]

结论

图像分类问题的最终解决方案取决于问题的性质和标签相互依赖的性质。对于标签的相互依赖性很复杂的领域，RNN 和 CNN 的联合方法似乎很有希望。当我开始进行多标签分类的实验时，我将报告这里描述的方法的性能度量。

[1]魏碧，James T. Kwok Mandatory:层次多标签分类中的叶节点预测(链接

[2]郭玉红，顾穗成:使用条件依赖网络的多标签分类(链接)

[3]贾登等。艾尔。:使用标签关系图的大规模对象分类(链接

[4]王江等人艾尔。:CNN-RNN:多标签图像分类的统一框架(链接)

用神经网络逼近工业机器人的动态模型

原文：https://towardsdatascience.com/approximating-dynamic-models-of-industrial-robots-with-neural-networks-2474d1a2eecd?source=collection_archive---------5-----------------------

Standard 6-axes industrial robot

工业机器人的运动控制器通常为每个关节轴生成两个循环设定值:位置参考值和扭矩前馈值。轴设定位置由运动学模型计算，而电机转矩由动力学模型计算。

然而，虽然运动学模型通常更容易实现，并且基于众所周知的参数，但是动态模型更复杂，并且基于通常未知并且必须识别的参数(例如惯性、摩擦)。此外，动态模型可能无法准确描述机械结构的所有物理属性，因为并非所有的影响都被考虑到，或者因为一些影响太难建模。例如，通常不考虑关节的弹性行为。

设计一个试图预测现实的固定模型的替代方案是让机器人自己学习其自身动力学的特征。简单的监督学习算法可以理解不同机械结构的特征，并成功地取代动态模型的标准实现。

这种技术可以应用于以下情况:

特定运动结构的动态模型未知或过于复杂，无法进行分析描述。

可用的动态模型过于简单，无法高精度地预测现实。

此外，由于学习算法可以很容易地在线训练(即，当机器人运动时)，机器人可以适应动态中长期不可预测的变化(例如，由于机械磨损而增加的摩擦，或者由于负载转移而改变的惯性)。

控制结构

每个机器人轴的控制结构由一个闭环 PID 和一个开环扭矩前馈组成。

计算前馈值的标准方法是求解一个逆动力学函数 D-1，根据当前设置的关节位置(α)、速度和加速度计算电机扭矩(τ):

Inverse dynamics

该方程通常通过拉格朗日或牛顿-欧拉方法求解，通常假设为刚体结构。模型的参数是离线确定的，不会随时间变化。

我们现在试图用一个序列神经网络形式的函数逼近器来代替动态模型。

网络通过训练集学习机械结构的动力学，训练集由每个轴的三个特征(位置、速度和加速度)和一个目标标签(扭矩)组成。线下和线上培训都可以。

一旦网络经过训练，它就可以用于实时预测电机扭矩值，这些值将作为前馈控制信号发送到伺服驱动器的电流环路。

Controller structure including an online learning function approximator

所使用的神经网络的结构非常简单，包括:

每个轴的设定位置、速度和加速度的一个输入层。

两个全连接的隐藏层，每层 100 个单元，ReLU 激活函数和随机初始化的权重。

一个输出层，每个轴有一个线性单位，代表预测的电机扭矩。

Neural network architecture for a 6-axis robot

对于 6 轴机器人，这种特定的网络配置总共需要 12606 个参数。

培训过程

网络训练目前是在完全监督下进行的。强化学习技术(如政策梯度)可用于进一步优化结果的质量，并将在今后的工作中进行研究。

第一个学习步骤包括离线训练，使用机器人运动期间捕获的大量标记数据。单个数据示例包含三个特征(轴位置、速度和加速度)和每个轴的一个目标标签(电机扭矩)。

特别是，编码器位置和电机扭矩在运动过程中被同时记录。然后通过微分从位置计算轴的速度和加速度。

为了使学习过程在输入数据中更加快速和一致，所有特征都以标准缩放形式进行预处理:零均值和单位方差。以下示例显示了为单个轴记录的数据。

Recorded features of a training set for a single axis after passing through a standard scaler

使用 RMSprop 优化器实现训练过程，初始学习率为 1e-4。评估的损失函数是标准的最小平方误差。

出于交叉验证的目的，随机抽取 10%的训练数据子集。然后应用常见的正则化技术来减少验证损失:

-学习率衰减:防止目标最优值附近的振荡，并在学习阶段结束时提高精度。

-网络架构:每个隐藏层 100 个单元，以折衷网络容量和训练时间。

-批量大小:随机梯度下降的 200 个样本的小批量。

-早期停止:训练集循环 120 个时期，直到验证损失开始稳定，并且训练停止以避免网络过度拟合。

一旦离线学习到最佳权重，该网络就可以用于实时预测。此外，培训还可以以在线形式继续，以提供适应网络的行为。

扭矩预测

训练好的权重用于根据每个轴的输入状态循环预测电机转矩。

给定网络的浅架构和小层尺寸，矩阵乘法的简单实现仅需要几秒的计算时间就足以实时运行。

与 sigmoid 和 tanh 替代方案相比，ReLU 非线性对于实时计算也是最佳的。

输入数据(轴位置、速度和加速度)与训练中使用的相同系数成比例，然后输入网络。输出预测扭矩值循环发送到伺服驱动器，作为电流回路的前馈值。

出于安全原因，在预测值过高的情况下，扭矩限制器处于活动状态。

结果

用不同的动态结构对神经网络进行测试，并将其转矩预测值与实际电机值进行比较。

惯性恒定的单轴

第一次测试是在具有恒定惯性负载的单轴系统上进行的，并且将标准 FF 模型作为比较基准。

该网络是在 2000 个小样本上训练的。下图比较了实际电机扭矩与标准 FF 模型和神经网络的预测值。在这种情况下，没有前馈被发送到驱动器。

Comparison between single axis motor torque values: actual (green), standard FF (purple), NN predicted (red)

预测的扭矩值是相似的，尽管标准 FF 模型提供了真实动态的更详细的表示。

具有可变惯性的单轴

第二项测试也是在单轴系统上进行的，但这次是在不对称的垂直载荷下进行的，这导致惯性根据轴的位置而变化。通过观察对轴定位误差的影响来检查结果的质量。

下图比较了实际电机扭矩和神经网络的预测值。在这种情况下，没有前馈被发送到驱动器。

Comparison between single axis motor torque values with variable inertia load: actual (green) and NN predicted (red)

接下来的步骤是将预测的扭矩作为前馈值发送到驱动器:当轴移动时，滞后误差的减少是明显可见的，尤其是在加速阶段。

Comparison between axis positioning error values: without torque feed-forward (green) and after applying the NN feed-forward (red)

六轴机器人

最后一次测试是在一个 6ax 铰接机器人上进行的，其有效载荷为 8 千克。

这种情况下的神经网络有 18 个输入单元和 6 个输出值。由于运动链的原因，该系统是高度非线性的，并且每个轴的扭矩取决于所有其他轴的动态状态。

经过一组约 10000 个样本的短期离线训练后，该网络已经能够以相当好的近似值预测每个电机的扭矩值，如下图所示，这是在随机运动期间记录的。

Comparison between torque values of the six motors of an articulated robotic arm: actual values (green) and predicted by the NN (red)

使用更深的网络和更大的训练集可能会获得更详细的预测质量。

结论

一个简单的具有两个隐层的前向传播神经网络被测试作为函数逼近器来学习不同运动结构的动态模型。

实际结果表明，即使具有这样浅的架构和小的训练集，网络也可以提供足够好的预测，以允许减少每个轴的定位误差。

该技术显然不是要取代众所周知的结构的动态模型，但它在模型不可用或不够精确的一些应用中具有非常有趣的潜力。

几个优点是:

-它可以应用于任何用户定义的运动学，甚至是具有几个关节的高度复杂的运动学(神经网络的容量可能必须相应地增加)

-它可以预测难以分析建模的影响

-它可以适应力学中与时间相关的变化

另一方面，最明显的缺点是网络的内部结构不是人类可读的:任何关于机械动力学的学习信息都无法提取。

使用 Numpy 近似积分[黎曼/梯形/辛普森/自适应/蒙特卡罗积分]

原文：https://towardsdatascience.com/approximating-integrals-using-numpy-riemann-trapeze-simpsons-adaptive-monte-carlo-f37e3940985f?source=collection_archive---------12-----------------------

GIf from this website

积分逼近是计算机科学中非常重要的任务(甚至涉及到神经网络)。今天我想实现不同的积分近似方法。

我们将要使用的功能

all of the images are from wolframalpha

总的来说，我们要近似四个不同函数的积分

1\. integral from -8 to 6     x dx = 1890
2\. integral from -10 to 120 (x^2 + 100 - x^5) dx = -497663244000
3\. integral from -10 to 23   sqrt(x) dx = 2/3 (23 sqrt(23) + 10 i sqrt(10))≈73.5361 + 21.0819 i
4\. integral from 0 to pi     x sin(x^2) dx = sin^2(π^2/2)≈0.9513

如上所述，我们已经可以看到解析解的结果。

近似方法

黎曼积分

吊架集成

辛普森积分

适应性整合

蒙特卡罗积分

如上所述，我们将使用五种不同的方法来估计积分。顺便提一下，在这五种方法中，有四种(除了自适应积分)有一个作为样本数的超参数。增加该值将导致更好的积分近似，

功能 1

自适应积分得到了最精确的积分值，其他方法要么低估了，要么高估了。(当然，随着样本数量的增加，它会变得更加精确。)

功能 2

对于这个函数，自适应积分方法低估了大量的积分值。

功能 3

除了自适应积分法之外，对于少量数据点，其他方法总体上做得相当好。

功能 4

有趣的是正弦函数也有类似的结果。

交互代码

要访问这篇文章的代码，请点击这里。

惊人的资源

Paper from this website

video from this website

最后的话

这是一次很好的回顾，也是一次很好的编程实践。当我摆弄数值时，很明显蒙特卡罗方法积分是一种强有力的方法，但它需要更多的时间来正确收敛。

如果发现任何错误，请发电子邮件到 jae.duk.seo@gmail.com 给我，如果你想看我所有写作的列表，请在这里查看我的网站。

参考

(2018).maths . qmul . AC . uk . 2018 年 12 月 1 日检索，来自http://www . maths . qmul . AC . uk/~ wj/mth 5110/notes/MAS 235 _ lecture notes 1 . pdf
傅立叶系列 GIF 在 GIPHY 上查找和分享。(2018).吉菲。检索于 2018 年 12 月 1 日，来自https://giphy.com/gifs/fourier-series-HqZuL4RWgf2ms
面向 Noobs 的 Python 蒙特卡罗集成。(2018).YouTube。检索于 2018 年 12 月 1 日，来自 https://www.youtube.com/watch?v=WAf0rqwAvgg
蝙蝠侠集成雷欧索斯。(2018).Leios.github.io .检索于 2018 年 12 月 1 日，来自 https://leios.github.io/Batman_Montecarlo
Dhamdhere，m . Sundararajan 和 q . Yan(2018 年)。一个神经元有多重要？。Arxiv.org。检索于 2018 年 12 月 1 日，来自https://arxiv.org/abs/1805.12233

四月版:强化学习

原文：https://towardsdatascience.com/april-edition-reinforcement-learning-e82cfba4d9c2?source=collection_archive---------6-----------------------

9 篇必读文章

各种强化学习算法介绍(第一部分、第二部分)

by 黃功詳 Steeve Huang — 20 min read.

强化学习(RL)是指一种机器学习方法，在这种方法中，智能体在下一个时间步接收延迟奖励，以评估其先前的行为。它主要用于游戏(如雅达利、马里奥)，性能与人类相当甚至超过人类。

在现实世界中学习和表演

通过Eugenio culrciello—6 分钟阅读。

为了与复杂的环境互动，生命体需要产生一个“正确”的动作序列，以实现延迟的未来回报。这些生命实体，或者说行动者，能够感知环境，并对环境和代理先前历史的一系列状态做出反应。

具有 Keras + OpenAI 的强化学习( DQNs ，演员-评论家模型)

由 Yash Patel — 24 分钟读取。

让我们想象一下我们用作训练数据的完全随机序列。任何两个序列都极不可能彼此高度重叠，因为它们完全是随机生成的。

论文再现:深层神经进化

Adrien Lucas Ecoffet——20 分钟阅读。

在这篇文章中，我们复制了最近的优步论文“深度神经进化:遗传算法是训练深度神经网络进行强化学习的竞争性替代方法”，该论文令人惊讶地表明，在诸如 Atari 游戏等研究充分的问题上，简单的遗传算法有时比明显先进的强化学习算法表现得更好。

用于基于模型的强化学习的具有随机输入的贝叶斯神经网络

由何塞米格尔埃尔南德斯洛巴托 — 9 分钟阅读。

我在这里描述我们最近的 ICLR 论文[1] [ 代码 ] [ 谈话) ]，它介绍了一种基于模型的强化学习的新方法。这项工作的主要作者是 Stefan Depeweg，他是慕尼黑技术大学的一名博士生，我是他的共同导师。

模拟器:应用深度强化学习的关键培训环境

由 Cyrill Glockner — 4 分钟读取。

深度强化学习(DRL)是目前人工智能中最令人兴奋的领域之一。现在还为时尚早，但这种技术可以应用于明显且服务不足的市场:希望自动化或优化工业系统和流程效率的企业(包括制造、能源、HVAC、机器人和供应链系统)。

让机器人学会如何移动(简介、第一部分、第二部分)

诺曼·迪帕洛 — 20 分钟阅读

当想到人工智能时，许多人脑海中浮现的流行图像通常是某种类人机器人，可能穿着闪亮优雅的白色身体，正在下棋或做其他事情。在许多著名的案例中，科幻故事将人工智能描述为体现在机器人中，或者更广泛地说，体现在合成体中。

强化学习可以使用更多的监督吗？

由科迪·玛丽·怀尔德 — 6 分钟阅读。

当我最初读到这篇论文的标题通过预测未来来学习行动时，我满怀希望地认为，它将为一个问题添加一个令人信服的解决方案，这个问题我已经思考了一段时间:在头脑中没有具体目标的情况下，是否有可能教授一个强化学习模型来了解世界。

盗匪进行推荐系统优化

由詹妮尔·罗兰·查姆利 — 7 分钟读完。

任何在亚马逊上购物、在 Spotify 上听音乐、或者在网飞上浏览值得狂欢的电视连续剧的人都体验过个性化推荐。公司使用推荐系统来增加客户参与度和收入。

我们也感谢最近加入我们的所有伟大的新作家，乔纳森·巴拉班，克里斯汀·凯尔勒，雅各布·茨威格，陈伟哲，大卫·霍尔茨，阿德里安·卢卡斯·艾柯菲，哈德里恩吉，达尼洛·佩纳，拉胡尔·戴夫，天空 b 穆罕默德·萨拉赫·马哈茂德、德文·‘肉’·加夫尼、克里斯·迪南、哈里桑卡尔·哈里达斯博士、优素福·阿克坦、大卫·派恩斯、索哈姆·西尔、马泰奥·朗切蒂、劳拉·费多鲁克以及许多其他人。我们邀请你看看他们的简介，看看他们的工作。

四月版:走向深度学习

原文：https://towardsdatascience.com/april-edition-towards-deep-learning-aa2a81e48185?source=collection_archive---------5-----------------------

你需要阅读的 12 篇深度学习文章。

对于 TDS 来说，到目前为止，2017 年是深度学习年。我们现在拥有一个信息丰富和投机性文章的宝库，但谁有时间在我们的档案中搜寻深度学习的踪迹呢？

我们知道我们的读者都是忙碌的专业人士，所以我们收集了一些顶级文章来帮助你从初学者到专家。

第一步

初学者深度学习作者 Shehzad Noor Taus Priyo (6 分钟阅读)，

深度学习的线性代数小抄作者布伦丹·福特纳 (8 分钟阅读)

深度学习的基础数学作者图沙尔·古普塔 (7 分钟阅读)

深度学习硬件作者Eugenio culrciello(6 分钟阅读)

爬山

神经网络架构作者Eugenio culrciello(14 分钟阅读)，

给深度学习增加不确定性作者 Motoki Wu (6 分钟阅读)，

管道、思维导图和卷积神经网络作者 Naoki Shibuya (11 分钟阅读)，

深度学习:反向传播由图沙尔·古普塔 (6 分钟读取)

站在山顶

打开神经网络黑盒——感知器作者梅加伦·迭戈·费尔南德斯 (6 分钟阅读)

构建自己的深度学习盒子 Brendan Fortuner (9 分钟阅读)

通过深度学习生成文本由 Dmitri Iourovitski (5 分钟阅读)

LSTM 举例使用张量流作者罗威尔·阿蒂恩萨 (6 分钟阅读)

我们也感谢最近加入我们的所有伟大的新作家，安娜斯塔西娅·阿诺希娜，卢西恩·利塔，阿尤什·查达，加利纳·德格蒂亚列娃，维韦克·亚达夫，克里斯蒂安·拉米雷斯，本·曼，阿内克·达斯，普拉桑娜·帕拉苏拉马我们的名册上有 70 多位作家，太多了，无法在此一一列举，但我们向他们每一位表示感谢。我们邀请你看看他们的简介，看看他们的工作。

对话式人工智能聊天机器人——架构概述

原文：https://towardsdatascience.com/architecture-overview-of-a-conversational-ai-chat-bot-4ef3dfefd52e?source=collection_archive---------0-----------------------

这篇文章的目的是给出一个典型的架构概述，以建立一个对话式人工智能聊天机器人。我们将详细回顾架构和各自的组件(注 — 本文中引用的架构和术语大多来自我对rasa-core开源软件的理解)。

所以让我们开始吧…

正如本文标题所示，主要方面是—

它是一个聊天机器人——在本文中，为了简单起见，假设用户将输入文本，机器人将以文本的形式用适当的消息作出响应(因此，我们将不涉及 ASR、语音识别、语音到文本、文本到语音等方面。，根据需要，无论如何都可以使用这些组件增强以下架构。

2。这是对话！ —这是什么意思？机器人应该以某种方式维护对话的状态，并在当前上下文中响应用户请求(也称为。它需要是上下文感知的)。例如，假设对话流程是这样的——

用户——明天天气怎么样？
明天大部分时间是多云，有小雨。
用户——后天怎么样？(因此，当提出这个问题时，机器人应该记住，这次对话的最近上下文是关于实体“天气”(而不是交通拥堵或预订可用性之类的其他东西，假设它们出现在之前的对话中)。

3。这是一个 AI / ML 驱动的架构:该模型根据提供的训练数据学习动作(不像传统的基于状态机的架构，它是基于为对话的每个可能状态编码所有可能的 if-else 条件。)

这是一个聊天机器人架构的高级概述。

Chatbot architecture — image copyright@ Ravindra Kompella

在我们浏览流程时，我将参考上图中的组件。首先，让我们看看在对话流程的任何给定时刻，我们需要什么来决定适当的回应？

我们需要知道用户的意图——我们称之为意图。意图的几个例子是——“请求天气”、“请求餐馆”等。上例中的意图是“请求天气”。
我们需要知道请求中的具体意图(我们称它们为实体 )，例如——什么时候？，哪里？，有多少？等等。，分别对应于从用户请求中提取关于日期时间、位置、数字的信息。这里的日期时间、位置、数字都是 的实体 。引用上面的天气示例，实体可以是“日期时间”(用户提供的信息)和位置(注意，位置不必是用户提供的显式输入，并且如果没有指定，将根据默认的用户位置来确定)。

意图和实体一起将有助于对天气服务进行相应的 API 调用并检索结果，我们将在后面看到。

现在参考上图，代表 NLU 组件( 【自然语言理解】 ) 的方框有助于从用户请求中提取意图和实体。

NLU 成分成分—

一个有监督的意图分类模型，以各种句子作为输入，以意图作为目标进行训练。通常，线性 SVM 将足以作为意图分类模型。
实体提取模型—这可以是预训练的模型，如 Spacy 或 StanfordNLP 库(或),也可以使用一些概率模型，如 CRF(条件随机场)进行训练。

3.现在，由于我们的是一个对话式人工智能机器人，我们需要跟踪迄今为止发生的对话，以预测适当的反应。为此，我们需要一个 dictionary 对象，它可以持久存储有关当前意图、当前实体的信息，以及用户对 bot 之前的问题、bot 之前的操作、API 调用结果(如果有)提供的持久存储信息。这些信息将构成我们输入的 X，特征向量。对话模型将要被训练的目标 y、将是“next _ action”(next _ action可以简单地是对应于我们在训练数据中定义的每个动作的独热码编码向量)。

然后，这将我们带到下一个问题——我们如何获得我们的特征向量的训练值，输入 X ？

正如我们从 NLU 组件中看到的那样，获取关于意图和实体的信息非常简单。
获取剩余的值()信息，用户将提供给机器人之前的问题、机器人之前的动作、API 调用的结果等。，)有点棘手，这里是对话管理器组件接管的地方。这些特征值将需要从用户将以用户和机器人之间的 样本对话 的形式定义的训练数据中提取。这些 样本对话 应该以这样一种方式准备，即它们在假装既是用户又是机器人的同时，捕捉大多数可能的对话流。

注意— 如果计划从头开始构建示例对话，那么一个推荐的方法是使用一种叫做 交互式学习的方法。该模型使用该反馈来改进其对下一次的预测(这类似于强化学习技术，其中该模型因其正确的预测而得到奖励)。

这里我就不赘述提取每个特征值的细节了。它可以从我在上面提供的 rasa-core link 的文档中引用。因此，假设我们以所需的格式从样本对话中提取了所有所需的特征值，那么我们可以训练一个像 LSTM 和 softmax 这样的人工智能模型来预测 next_action。 参考上图，这就是'对话管理'组件的作用。为什么 LSTM 更合适？—如上所述，我们希望我们的模型能够感知上下文，并回顾对话历史来预测 next_action。 这类似于时间序列模型(请参见我的另一篇 LSTM 时间序列文章)，因此可以在 LSTM 模型的内存状态中得到最好的捕捉。我们想要回顾的对话历史的数量可以是模型的可配置的超参数。

现在， next_action 的预测值可以是这样的—

用适当的消息响应用户
从数据库中检索一些数据(如果我们有的话)
进行一次 API 调用，得到一些符合意图的结果。

如果恰好是 API 调用/数据检索，则控制流句柄将保留在“对话管理”组件中，该组件将进一步使用/保持该信息，以再次预测 next_action、 。对话管理器将基于该动作和检索的结果更新其当前状态，以进行下一次预测。一旦 next_action 对应于对用户的响应，那么‘消息生成器’组件就会接管。

消息生成器组件由几个用户定义的模板组成(模板只是带有一些占位符的句子，视情况而定)，这些模板映射到动作名称。因此，根据对话管理器预测的动作，调用相应的模板消息。如果模板需要填充一些占位符值，对话管理器也会将这些值传递给生成器。然后，向用户显示适当的消息，机器人进入等待模式，监听用户输入。

基因模型比随机抽样好吗？

原文：https://towardsdatascience.com/are-genetic-models-better-than-random-sampling-8c678002d392?source=collection_archive---------12-----------------------

下面描述的整个实验的代码和结果可以在我的 GitHub 页面找到，作为 Jupyter 笔记本 。使用的基因模型库，py Charles，是我创建的开源项目。还有一个更基础的版本， 查尔斯 ，用 Scala 写的。

基因模型总是让我兴奋的事情之一，尽管我不确定我能解释为什么。我猜这是利用自然选择本身的想法，通过让不同的可选解决方案交配、繁殖和变异来寻找给定问题的最佳可能解决方案。但也许这是因为无论这个想法听起来多么激动人心，我都找不到这个概念的任何实际用途——因为学习过程只是试图优化输入，而不是将输入映射到输出的函数。

所以想象一下，当我发现有一篇论文声称基因模型可以用来优化神经网络的结构时，我有多高兴。但是，当我向我有机会与之交谈的另一位数据科学家提出这个想法时，他声称他在研究期间有机会检查基因模型——并表示他发现基因模型就像随机选择解决方案并采取最佳方案一样好。我觉得应该由我来捍卫基因模型和它们的名字，并证明进化比随机进化更好——所以我决定验证这一点。TL；—我输了。

设计实验

这样的实验首先需要的是数据。我需要一些我能处理的简单的东西，所以我决定使用众所周知的泰坦尼克号数据集。

接下来:决定我将要工作的空间和界限。这意味着我需要决定哪些可能的架构是有效的候选。我提到的论文，以及我阅读的其他讨论，表明在许多情况下，多达 2 个隐藏层的神经网络应该足够了。这篇论文还引用了另一篇文章，声称给定 N 个样本和 m 个输出节点，应该足以学习这些数据的节点数量由下式给出:

对于第一个隐藏层，以及:

对于第二个隐藏层。我已经决定这些将是我的上限，而第一层的下限将是 3(没有特殊的原因)，第二层的下限将是 0(意味着只有一个隐藏层的架构)。由于这是一个二元分类网络， m=2 。另外，我只使用了 70%的数据进行训练，所以 N=623 。这产生了【3，75】和【0，50】分别作为第一和第二隐藏层边界——这给出了 3723 种可能的架构。这是很多，因为我需要计算这个实验的每个可能的选项。所以我决定，既然两个输出节点基本上是相反的概率，我可以忽略一个，用 m=1 ，这样就产生了这些边界:【3，72】和【0，14】—所以现在我有 1050 种可能的架构。还是很多，但是比以前少多了。

我需要选择的最后一件事是，我应该用什么指标来衡量网络。经过深思熟虑，我决定使用 ROC 曲线下面积(有时简称为 AUC)而不是精确度。

实验时间！

我做的第一件事是计算架构空间中所有可能架构的 AUC。我的 MacBook Pro 花了大约 18 个小时来计算所有 1050 种可能性——下面是结果:

AUC scores for all 1050 possible architectures

现在是训练遗传模型的时候了，设置一些数字:我已经决定将种群规模设置为 8，最大代数为 10，提前停止的耐心为 2 代(意思是，如果模型在两代后不能击败它的最佳解决方案，它将停止)。我还决定训练模型 5 次，然后平均结果。模型的强度函数(有时称为适应度函数)被确定为:

这将保证即使 AUC 分数最小的提升也会对其解决方案的生存几率产生重大影响。如果你现在已经读过这篇文章，你可能已经注意到我使用了一个不同的强度函数。7) —但这并没有太大的不同:我只是简单地使用了一个非线性误差，并且没有牺牲准确性( s=0 )。

结果

平均遗传模型 AUC 得分为 0.891，它平均进化了 3 代——这意味着它平均计算出 8+(37)=29 个不同的解(8 个初始解和每代 7 个解，因为每代的最佳解也会继承到下一代，参见 PyChrales 文档中的精英比率*)。在 1050 个可能的解决方案中，54 个等于或优于通过模型获得的 AUC 分数，占整个解决方案空间的 5.1%。它们的分布如下:

a histogram of all AUC values in the solutions space. In red: solutions which are equal or better than the averaged AUC of the Genetic Model

但是这就足够好了吗？这是否意味着遗传模型会比随机抽样表现得更好？让我们看看:在尝试了 n 次次后，得到更好解决方案的概率由下式给出:

如果我们画出 p(n) 我们会得到这样的结果:

很明显，对于 n=29 ，我们得到 p=0.8 ，这意味着当简单地随机抽样解决方案空间时，有 80%的机会获得更好的架构。事实上， p > 0.5 对于任何 n≥13 ，所以一个遗传模型必须只扫描最多 12 个不同的溶液(并达到相同的 AUC 分数)才能比随机抽样更好。不幸的是，我重试时没有成功。

结论

这看起来很有希望——但是基因模型在这个案例中失败了。虽然这只是一次尝试，因此我不能说我已经证明了遗传模型确实不如随机采样——我将承认，除非得到证明，否则我可能不会用它们来确定我的下一个神经网络的架构。但这确实让我思考一些问题——我们人类进化了这么多，是因为我们是最适者吗——还是可能是任何其他物种，我们只是运气好而已。嗯，我想我们永远也不会知道:-)

参考

[1] D .斯塔塔基斯，“有多少隐藏层和节点？”，国际遥感杂志，第 30 卷第 8 期，2009 年 4 月( PDF )

是机器有偏见还是我们对机器有偏见？

原文：https://towardsdatascience.com/are-machines-biased-or-are-we-biased-against-machines-17982310152b?source=collection_archive---------4-----------------------

一位数据科学家对 ProPublica 关于犯罪预测算法偏差的研究的看法

Algorithms: the new boogeyman.

ProPublica 最近发表了一篇谴责在刑事司法系统中使用算法的文章。“机器偏见”这篇文章记录了司法判决过程中预测算法的使用，以及这些算法表现出的令人不安的种族偏见。报告者表明，这些算法系统地低估了白人罪犯的累犯率，高估了黑人罪犯的累犯率。这具有重要的后果，因为累犯——罪犯未来犯罪的倾向——是决定刑期和改造要求的一个重要因素。

正如可以预测的那样(没有任何算法)，对这篇文章的反应是压倒性的批评在刑事司法中使用数据科学。虽然这项研究是新闻业的一个重要部分，但我担心它对算法使用的寒蝉效应可能会产生与减轻种族偏见的相反的效果。不幸的是，ProPublica 的文章本身利用了我们的许多认知偏见，这可能最终加剧他们希望解决的问题。

ProPublica’s main findings: Prediction algorithms fail differently for black defendants

量化和显著性偏差

理解预测算法如何不同地影响种族无疑是重要的。然而，更重要的问题——尤其是在公共政策的背景下——是算法的性能如何与其他替代方案相比较(当前的基线是特殊的人类判断)。标题“算法有偏见”的含义与“算法比人类更少偏见，更准确”的含义大相径庭(尽管两者可能同时成立)。

算法的缺点是它们实际上量化了它们的预测，这使得我们能够首先对它们的偏差进行事后评估。人类在许多领域做出预测，但他们很少把预测写在纸上，并让任何人在事后分析。当科学家们实际分析了人类预测准确性的数据后，发现它们非常糟糕，并且受到多种类型的偏见的影响。(见 Philip Tetlock 的著作关于所谓的“专家”在预测方面有多糟糕。)

[## 菲利普·泰特洛克在魔鬼经济学电台

众所周知，专家和学者不擅长预测，部分原因是他们不会因为预测失误而受到惩罚…

freakonomics.com](http://freakonomics.com/podcast/how-to-be-less-terrible-at-predicting-the-future-a-new-freakonomics-radio-podcast/)

事前算法预测数据的可用性意味着我们比其他(也许更有害)类型的偏差更容易意识到算法偏差。因此，我们对算法的判断受制于显著性偏差，这扭曲了我们做出客观决策的能力。

我对累犯算法的种族偏见和人类法官的种族偏见之间的比较更感兴趣。(幸运的是，刑事司法是一个实际记录数据和结果的领域，因此可以进行这样的比较——我在看你们这些犯罪学研究生。)对所有可用选项进行比较，将让我们做出比一篇声称算法是新恶魔的文章更明智的决定。

算法厌恶

沃顿商学院(Wharton School)的伯克利·迪特沃斯(Berkeley Dietvorst)最近的研究也表明，我们对算法错误的判断比人类犯同样的错误更严厉。在他的论文“算法厌恶:人们在看到算法出错后错误地避免使用算法”中，Dietvorst 和合著者描述了即使当算法在客观上比人类更擅长决策时，我们在看到它们失败后也避免使用它们。然而，当我们看到人类以同样的方式失败时，我们更容易合理化他们的缺点，原谅他们的错误。

[## 这就是为什么人们相信人类对算法的判断

hbr.org](https://hbr.org/2015/02/heres-why-people-trust-human-judgment-over-algorithms)

算法厌恶可能是对 ProPublica 文章反应的核心。当算法出错时(在这种情况下，当算法错误地获得黑人和白人之间的再犯率时)，人们会非常苛刻。即使有人进行了我上面建议的比较研究，并且结果表明算法比人类法官更准确，更少偏见，我们仍然可能避免使用它们，并更严厉地判断它们的错误。

我们当然应该意识到算法的缺点，但也应该意识到我们对算法的固有偏见。如果事实证明，算法实际上比做出预测的替代方法更少偏差，那么避免它们有可能实际上增加刑事司法系统中的种族主义。这就是为什么当算法(不可避免地)犯错误时，对算法进行非理性和不适当的指责会产生重大后果。

理解权衡

算法只不过是美化了的优化问题。在这种情况下，统计学家的目标是，“最大限度地提高我们预测累犯的准确性”，并建立了一个程序来准确地做这件事。重要的是要认识到最小化种族偏见与最大化预测准确性是不同的目标。减少偏见当然是一个值得称赞的目标，但当处理统计和不确定性的世界时，在不同的目标之间总是有和的权衡。

如果统计学家确实将种族偏见考虑在内，他们模型的预测有效性几乎肯定会下降。这不是我们是否应该减少种族偏见的问题，而是我们希望如何在公共政策的不同目标之间进行权衡的问题。减少种族偏见好还是减少我们不必要地将个人关在监狱里的年数好？我不知道答案，但重要的是，我们要意识到要有所取舍。

无知不是福

原来机器是有偏见的和我们也对机器有偏见。ProPublica 在报道第一个偏见方面做得很好，但却公然忽略了第二个。由于没有回答算法在这一领域如何与人类相比较的问题，我们对算法如何适应刑事司法系统的了解并不全面。这使得我们无法知道我们应该更多还是更少地使用算法。

ProPublica 也没有解决需要在减少偏差和预测准确性之间做出的基本权衡。与刑事司法系统中的传统做法不同，算法和数据科学的应用使我们政策目标之间的这些权衡变得非常突出——即使我们不喜欢它们向我们展示的内容。但是妖魔化数据科学就像对着浴室镜子生气，因为它让你看到了你额头上的青春痘。

改进 ProPublica 工作的唯一方法是增加数据科学在公共政策中的作用，而不是降低它。在对算法在刑事司法中的效用得出结论之前，还有许多工作要做。这就是为什么我们这些想要改善系统的人最好用我们的干草叉去换电子表格。

在推特上通过 @alexpmil 找到我。这个帖子最初出现在我的个人网站 http://alex.miller.im 。

新电影比 10 年前、20 年前、50 年前更长吗？

原文：https://towardsdatascience.com/are-new-movies-longer-than-they-were-10hh20-50-year-ago-a35356b2ca5b?source=collection_archive---------4-----------------------

处理来自 IMDb.com 的数据

如果你喜欢看电影，我指的是很多的电影，你可能已经注意到如今电影变得越来越长。你上一次去电影院看短于 120 分钟的大片是什么时候？越来越多的电影(谢谢漫威鼓励这种趋势！)字幕后还有场景，所以你会一直耐心等待，直到结束，即使你的膀胱已经让你痛不欲生一段时间了。

这是你可能会想“天哪，最近电影变得长得可笑”的时候。是吗？我也问过自己同样的问题。我和一些电影爱好者讨论了这个问题。他们有相似的感觉。这对我来说还不够。我决定用我的数据分析技能来调查这个问题。在这篇文章中你可以读到我的发现。

资料组

没有比 IMDb.com 更好的地方去寻找关于电影的数据了。这是世界上最大的电影网站。从 1990 年开始研发(原文如此！)，其数据库包括大约 530 万个标题和 930 万个人物。这令人难以置信，但它始于一份拥有美丽眼睛的女演员名单(说真的，在维基百科上查看 IMDb 历史)。

个人可在 IMDb 数据集页面获取 IMDb 数据。我们的研究不需要详细的数据库。在我们的最终数据集中，每部电影只需要三列:

发布年份
运行时间
投票数(过滤掉小众电影)

不幸的是，我们需要下载两个数据集，稍后再加入它们。在 title.basics.tsv.gz，数据库里有很多关于每部电影、电视节目和剧集的数据。在title.ratings.tsv.gz有来自数据库的关于投票数和项目平均评级的信息。

让我们开始编写我们的 movies_data.py 脚本，处理这些大量的数据，并为进一步的调查做准备。

import pandas as pd

 # Download data from IMDB website
 # Data description [https://www.imdb.com/interfaces/](https://www.imdb.com/interfaces/)
 movies = pd.read_csv(‘https://datasets.imdbws.com/title.basics.tsv.gz', compression=’gzip’, sep=’\t’)
 print(‘“title.basics.tsv.gz” downloaded’)
 ratings = pd.read_csv(‘https://datasets.imdbws.com/title.ratings.tsv.gz', compression=’gzip’, sep=’\t’)
 print(‘“title.ratings.tsv.gz” downloaded’)
 print(movies.shape)
 print(ratings.shape)>>>“title.basics.tsv.gz” downloaded
>>>“title.ratings.tsv.gz” downloaded
>>>(5504894, 9)
>>>(900802, 3)

目前看来还不错。我们有两个数据集。一个有 90 万行 3 列，另一个有 550 万个条目 11 列。两个数据集都有 tconst 变量，这是每个标题的唯一 id。我们可以合并该列中的现有数据。

# Merge data on ‘tconst’, which is unique id for any title in IMDB database.
 movies = pd.merge(movies, ratings, on=’tconst’)
 print(movies.shape)>>>(900802, 11)

总共有 90 万个独特的标题。

去除不必要的数据

现在我们可以进一步调查我们的数据。有一个名为标题类型的栏目，标明标题是电影、电视剧、剧集、短片等。

print(movies[‘titleType’].unique())>>>[‘short’ ‘movie’ ‘tvMovie’ ‘tvSeries’ ‘tvEpisode’ ‘tvShort’ ‘tvMiniSeries’ ‘tvSpecial’ ‘video’ ‘videoGame’]

有 11 种类型的标题。我们只对电影感兴趣，所以我们将在数据集中留下标记为 movie 和 tvMovie 的行。我们可以争论是否应该考虑电视电影，但在最终的数据集中，它们只占所有标题的 5%，并且它们不会改变结果，我检查了这一点。

movies = movies[movies[‘titleType’].isin([‘movie’, ‘tvMovie’])]
print(movies.shape)>>>(271427, 11)

书名数量下降到 271k。

我们应该考虑的另一件事是电影的可能类型。我们需要确保我们只考虑故事片，而不是纪录片等。我们可以查看一下流派一栏。

genres = movies[‘genres’].unique()
len(genres)>>>1313

有 1313 个独特的流派！IMDb 建立数据库的方式很奇怪，因为这个流派只有一个专栏。如果一部电影同时是剧情、喜剧、奇幻，那就写成喜剧、剧情、奇幻。浏览完数组后，我可以找到例如:

纪录片、新闻、体育
传记、戏剧、历史
纪录片，战争
动画、音乐剧、科幻
犯罪、纪录片、体育

这个专栏很乱。从这篇文章的第一稿到发表，增加了 4 个新的类型。幸运的是，我们不需要处理这个。我们只想过滤掉纪录片。Pandas 有一个很好的工具来过滤包含字符串的行。

movies = movies[movies[‘genres’].str.contains(‘Documentary’) == False]

最后，我们的数据中只有我们需要的电影。现在我们可以删除所有不必要的列。如前所述，我们只需要三列:

startYear —代表一个标题的发布年份
运行时间分钟 —标题的主要运行时间，以分钟为单位
票数 —该标题获得的票数

movies = movies[[‘startYear’, ‘runtimeMinutes’, ‘numVotes’]]

最后，我们需要将这些列的数据类型更改为 numeric，并删除缺少值的行。

for column in movies.columns.values.tolist():
    movies[column] = pd.to_numeric(movies[column], errors='coerce')

movies = movies.dropna()
print(movies.shape)>>>(197552, 3)

经过这一步，我们的电影数量下降到 197.5k。

在我们继续进一步分析之前，最好检查一下数据集的描述性统计数据，以确定一切看起来是否正常。

print(movies.describe())>>>startYear runtimeMinutes numVotes
>>>count 197552.000000 197552.000000 1.975520e+05
>>>mean 1988.940932 94.929492 3.643819e+03
>>>std 24.758088 29.967162 3.173653e+04
>>>min 1894.000000 1.000000 5.000000e+00
>>>25% 1973.000000 83.000000 1.700000e+01
>>>50% 1996.000000 92.000000 6.500000e+01
>>>75% 2010.000000 103.000000 3.390000e+02
>>>max 2019.000000 5760.000000 2.029673e+06

我们可以注意到，至少有一部电影只有 1 分钟长，看起来不太对劲。数据库里可能有些错误。

根据美国电影艺术与科学学院的规定，一部原创电影需要 40 分钟或更少才有资格成为短片，而故事片则需要超过 40 分钟。放弃太短的电影是一个很好的规则。

movies = movies[movies[‘runtimeMinutes’] > 40]

更重要的是，我们只对流行电影感兴趣。IMDb 数据库里有几千部电影，只有几十票。他们会歪曲我们的结果。假设一部受欢迎的电影是收视率超过 1000 的电影。我们放弃所有不符合这条规则的电影(再见，成千上万的电视电影和车库制作！).

movies = movies[movies[‘numVotes’] >= 1000]
print(movies.describe())>>>startYear runtimeMinutes numVotes
>>>count 27951.000000 27951.000000 2.795100e+04
>>>mean 1995.441165 104.993167 2.494047e+04
>>>std 21.236780 22.305108 8.118090e+04
>>>min 1911.000000 43.000000 1.000000e+03
>>>25% 1986.000000 91.000000 1.679000e+03
>>>50% 2003.000000 100.000000 3.440000e+03
>>>75% 2011.000000 114.000000 1.195000e+04
>>>max 2018.000000 450.000000 2.029673e+06

在我们最终的数据集中，有 27，951 部电影。最短的 43 分钟最长的 450 分钟(铁膀胱的价格去了任何一个不用上厕所就能看的人！).最古老的电影是 1911 年的。

平均而言，我们数据集中的每部电影都有近 25k 张选票，但标准偏差为 81k，这可能意味着分布是向右倾斜的，平均值被少数拥有大量选票的电影高估了(至少有一部电影的收视率超过 200 万！).中位数看起来更接近现实，50%的电影有 3440 票或更少。

现在，我们可以将数据保存到 CSV 文件中，并转移到新的脚本中。这个需要很长时间来执行。Python 需要下载总共超过 100MB 的数据，并处理几次。如果我们用一个新的脚本和更小的数据集重新开始，我们的工作流程会快得多。

movies.to_csv(‘movies.csv’, index=False)
print(‘Success!’)>>>Success!

新数据集的大小为 515 KB，不到原来的 1%!你就是这样剔除无关数据的！

寻找研究中使用的第一年

让我们创建一个名为 movies.py. 的新脚本

import pandas as pd, \
    matplotlib.pyplot as plt, \
    matplotlib.patches as mpatches, \
    matplotlib.lines as mlines, \
    seaborn as snsmovies = pd.read_csv('movies.csv')

我们应该从思考第一年的学习开始。20 世纪初的电影摄影仍处于起步阶段。那时创作的电影并不多，大多数只是新技术和实验的简短展示。让我们用这些早期电影历史的数据集中的一些标题制作一个直方图。

plt.hist(movies['startYear'][movies['startYear'] < 1940])
plt.title('Movies count')
plt.xlabel('Year of release')
plt.ylabel('Number of movies')
plt.show()

好的，大约在 1930 年早期，电影的数量开始增加。让我们仔细看看 1930 年之前的几年:

plt.hist(movies['startYear'][movies['startYear'] < 1930])
plt.title('Movies count')
plt.xlabel('Year of release')
plt.ylabel('Number of movies')
plt.show()

这些只是直方图，具有默认的箱数(10)，我们只是用它来快速可视化我们的数据。如果我们想知道数据集中电影的确切数量，我们应该查看表格(或创建包含更多条块的直方图)。

print(movies['startYear'][movies['startYear'] < 1940].value_counts().sort_index())>>>1911.0     1
>>>1913.0     3
>>>1914.0     4
>>>1915.0     3
>>>1916.0     2
>>>1917.0     2
>>>1918.0     5
>>>1919.0    10
>>>1920.0     9
>>>1921.0     9
>>>1922.0     9
>>>1923.0    10
>>>1924.0    15
>>>1925.0    18
>>>1926.0    15
>>>1927.0    22
>>>1928.0    27
>>>1929.0    22
>>>1930.0    22
>>>1931.0    49
>>>1932.0    48
>>>1933.0    51
>>>1934.0    42
>>>1935.0    52
>>>1936.0    68
>>>1937.0    52
>>>1938.0    45
>>>1939.0    73

在我们的数据集中只有一部 1911 年的电影，1924 年是标题数量超过 10 的第一年。这些数据不足以得出可靠的结果。我们需要决定从哪一年开始。我决定使用与流行的正态分布方法相同的经验法则。据此，创建它的最小样本量是 30。现在我们可以计算数据的起始年份。

start_year = 0  # This will be starting year of the data.
# Create data frame with year as first column and movie count as second.
movies_per_year = movies['startYear'].value_counts().sort_index()  # The year is an index, we need it as a column.
movies_per_year_df = pd.DataFrame({'year': movies_per_year.index, 'movie_count': movies_per_year.values})

for i in range(0, len(movies_per_year_df)):
    year = movies_per_year_df.iloc[i, 0]
    movie_count = movies_per_year_df.iloc[i, 1]
    # Check if in a given year there were more than 30 movies.
    if movie_count > 30:
        movies_per_year_df = movies_per_year_df.iloc[i:, :]  # Drop years before current one in the loop
        # Check whether the rest of years have movie count above 30, if not, the loop continues.
        # If every year left has movie count above 30, the loop breaks and we have the answer.
        if sum(movies_per_year_df['movie_count'] < 30) == 0:
            start_year = year
            break

print(start_year)>>>Name: startYear, dtype: int64
>>>1931.0

我们的数据集将从 1931 年开始。当然，我们可以快速浏览一下上表来确定它，但是我们的目标是练习循环和条件，以便在更复杂的数据的情况下自动化这个过程。

movies = movies[movies['startYear'] >= 1931]
print(movies.describe())>>>startYear runtimeMinutes numVotes
>>>count 27743.000000 27743.000000 2.774300e+04
>>>mean 1995.971380 105.048156 2.507714e+04
>>>std 20.407283 22.103663 8.145749e+04
>>>min 1931.000000 43.000000 1.000000e+03
>>>25% 1986.000000 91.000000 1.684000e+03
>>>50% 2003.000000 100.000000 3.459000e+03
>>>75% 2011.000000 114.000000 1.205400e+04
>>>max 2018.000000 450.000000 2.029673e+06

我们最终的数据集包含 27，743 个标题。有趣的是，中间的发行年份是 2003 年，这意味着我们数据集中所有电影的 50%是在 2003 年或更晚发行的。这意味着人们大多观看和评价新电影。运行时间的中间值是 100 分钟，平均值是 105 分钟，这看起来是正确的。

说到点子上

让我们画出运行时的分布图。我们将其限制在 40-200 分钟的范围内，以提高可读性。超过 200 分钟的标题并不多，40 分钟是我们数据的下限。每个仓位对应 10 分钟范围。

plt.hist(movies['runtimeMinutes'], range=(40, 200), bins=16, ec='black')
plt.title('Movies length')
plt.xlabel('Minutes')
plt.ylabel('Number of movies')
plt.show()

最受欢迎的运行时间是 90-100 分钟。绝大多数电影都有 80-120 分钟长。这和我们的观影直觉是一致的。

让我们按年份找出一个平均的电影放映时间。我们按年份对数据集进行分组，并获得每个子集的描述性统计数据。

statistics_grouped = movies[‘runtimeMinutes’].groupby(movies[‘startYear’]).describe()

我们可以绘制出这些数据的图表。除了平均电影运行时间，我们还可以根据标准偏差创建置信区间。我们将使用简单的公式:

avg_runtime_by_year = statistics_grouped['mean']  # Mean
avg_runtime_lower_band = statistics_grouped['mean'] - statistics_grouped['std']  # Lower band of data created using standard deviation.
avg_runtime_upper_band = statistics_grouped['mean'] + statistics_grouped['std']  # Upper band of data.

让我们来创造情节:

fig, ax1 = plt.subplots(figsize=(10, 5))
ax1.plot(avg_runtime_by_year, color="blue")
ax1.plot(avg_runtime_lower_band, color="aqua")
ax1.plot(avg_runtime_upper_band, color="aqua")
ax1.fill_between(statistics_grouped.index, avg_runtime_lower_band, avg_runtime_upper_band, facecolor='aqua')  # Fill space between bands to create confidence interval.
ax1.set_title('Movies runtime by year')
ax1.set_ylabel('Minutes')
ax1.set_xlabel('Release year')
ax1.set_xlim(1931, 2018)
legend_sd = mpatches.Patch(color='aqua', label='Mean +/- standard deviation')  # Used mpatches to create rectangular for a legend.
legend_line = mlines.Line2D([], [], color='blue', label='Mean runtime')
ax1.legend(handles=[legend_line, legend_sd])  # Nice legend with rectangular and line.
plt.show()```

看来我们关于电影越来越长的直觉思维是错误的。的确，在电影的最初几十年里，电影更短，在 20 世纪 30 年代早期，平均长度为 90 分钟，在 50 年代中期达到 100-110 分钟。从那以后，我们的数据就没有趋势了。此外，置信区间与 80-130 分钟的运行时间相当一致。

然而，看起来 2018 年可能是新上升趋势的开始，因为这是电影史上平均运行时间超过 110 分钟的两年之一。现在猜测还为时过早，特别是因为 2018 年还没有结束，即使在 2019 年初，获得至少 1000 票的电影数量也将比其他年份增长得更快(我们的数据集中有 597 部来自 2018 年，955 部来自 2017 年)。

我们可能想知道在创建置信区间时考虑了数据集的哪一部分。这很容易检查。我们需要找到一些比置信区间的下(上)带更长(更短)的电影，然后用它除以给定年份所有电影的数量。

percentage_of_included_movies = []
for year in statistics_grouped.index:
    movies_from_year = movies[movies['startYear'] == year]
    avg_runtime_low = avg_runtime_lower_band[int(year)]
    avg_runtime_up = avg_runtime_upper_band[int(year)]
    movies_included = movies_from_year[movies_from_year['runtimeMinutes'] > avg_runtime_low][movies_from_year['runtimeMinutes'] < avg_runtime_up]
    percentage_of_included_movies.append(len(movies_included)/len(movies_from_year))

现在我们可以向我们的统计 _ 分组数据框添加新列:

statistics_grouped['included_movies_perc'] = percentage_of_included_movies
print(statistics_grouped['included_movies_perc'].describe())>>>count 88.000000
>>>mean 0.782741
>>>std 0.058665
>>>min 0.619718
>>>25% 0.745369
>>>50% 0.786273
>>>75% 0.817378
>>>max 0.928571
>>>Name: included_movies_perc, dtype: float64

每年平均有 78%的电影符合这个置信区间。我们可以在之前的图表上添加额外的线条来显示每年的比例。

# Main plot
fig, ax1 = plt.subplots(figsize=(10, 5))
ax1.plot(avg_runtime_by_year, color="blue")
ax1.plot(avg_runtime_lower_band, color="aqua")
ax1.plot(avg_runtime_upper_band, color="aqua")
ax1.fill_between(statistics_grouped.index, avg_runtime_lower_band, avg_runtime_upper_band, facecolor='aqua')
ax1.set_title('Movies runtime by year')
ax1.set_ylabel('Minutes')
ax1.set_xlabel('Release year')
ax1.set_xlim(1931, 2018)
# Plot with proportions
ax2 = ax1.twinx()
ax2.plot(statistics_grouped['included_movies_perc'], color='olive')
ax2.set_ylabel('Proportion')
plt.axhline(y=0.70, color='red', linestyle='dashed')  # Add line at 0.70
legend_sd = mpatches.Patch(color='aqua', label='Mean +/- standard deviation')
legend_line = mlines.Line2D([], [], color='blue', label='Mean runtime')
legend_line_2 = mlines.Line2D([], [], color='olive', label='Proportion included in CI')
dashed_line = mlines.Line2D([], [], color='red', label='Proportion = 0.7', linestyle='dashed')
ax1.legend(handles=[legend_line, legend_sd, legend_line_2, dashed_line])
plt.show()

剧情看起来有点乱，但传达的信息很明确。自 40 年代末以来，我们的置信区间每年包含 70%以上的图书。

让我们创建另一个图，这一次使用中位数和四分位数范围，并检查结果。我们最感兴趣的是置信区间，它现在将包含 50%的电影。25%的最短标题和 25%的最长标题将位于蓝色区域之外。

# Data
avg_runtime_by_year = statistics_grouped['50%']
avg_runtime_lower_band = statistics_grouped['25%']
avg_runtime_upper_band = statistics_grouped['75%']

# Plot
fig, ax1 = plt.subplots(figsize=(10, 5))
ax1.plot(avg_runtime_by_year, color="blue")
ax1.plot(avg_runtime_lower_band, color="aqua")
ax1.plot(avg_runtime_upper_band, color="aqua")
ax1.fill_between(statistics_grouped.index, avg_runtime_lower_band, avg_runtime_upper_band, facecolor='aqua')
ax1.set_title('Movies runtime by year')
ax1.set_ylabel('Minutes')
ax1.set_xlabel('Release year')
ax1.set_xlim(1931, 2018)
legend_sd = mpatches.Patch(color='aqua', label='Interquartile range')
legend_line = mlines.Line2D([], [], color='blue', label='Median runtime')
ax1.legend(handles=[legend_line, legend_sd])
plt.show()

在这里我们也看不到任何清晰的模式。然而，最近 2-3 年的增长相当快。尽管如此，这并不意味着这是新趋势的开始，但我们应该在未来检查这种情绪。我们还可以注意到，中位数平均低于平均值。100 分钟左右波动，比均值短 5 分钟左右。这是有道理的，因为 mean 受一小部分长电影的影响，median 只是每年的中心值。

好了，现在我们知道电影《T4》总体来说并没有变长。也许我们的直觉没有错，它只发生在最受欢迎的电影，最大的大片中。我们可以创造更多的情节，每次考虑每年最受欢迎的电影的小样本。

让我们只看一下 1960 年以来的电影，这样我们就可以更仔细地看看对我们来说最有趣的数据。也许如果我们每年只取 50 部最受欢迎的电影，会有一些趋势可见。

movies_since_1960 = movies[movies[‘startYear’] >= 1960]

因为我们想要检查几个不同的值，所以我们可以创建一个函数来返回关于每年最受欢迎的电影的统计数据。我们以后可以用它。

def top_n_movies(data, n):
    top_n_movies_per_year = data.groupby('startYear').head(n)
    stats = top_n_movies_per_year['runtimeMinutes'].groupby(
        top_n_movies_per_year['startYear']).describe()
    return stats

现在，我们可以获得所需的数据，并创建我们的阴谋。

statistics_grouped_50 = top_n_movies(movies_since_1960, 50)
# Data
avg_runtime_by_year = statistics_grouped_50['mean']
avg_runtime_lower_band = statistics_grouped_50['mean'] - statistics_grouped_50['std']
avg_runtime_upper_band = statistics_grouped_50['mean'] + statistics_grouped_50['std']

# Plot
fig, ax1 = plt.subplots(figsize=(10, 5))
ax1.plot(avg_runtime_by_year, color="blue")
ax1.plot(avg_runtime_lower_band, color="aqua")
ax1.plot(avg_runtime_upper_band, color="aqua")
ax1.fill_between(statistics_grouped_50.index, avg_runtime_lower_band, avg_runtime_upper_band, facecolor='aqua')
ax1.set_title('Runtime of 50 most popular movies by year')
ax1.set_ylabel('Minutes')
ax1.set_xlabel('Release year')
ax1.set_xlim(1960, 2018)
legend_sd = mpatches.Patch(color='aqua', label='Mean +/- standard deviation')
legend_line = mlines.Line2D([], [], color='blue', label='Mean runtime')
ax1.legend(handles=[legend_line, legend_sd])
plt.show()

仍然没有明显的趋势。此外，当我们考虑少量更受欢迎的电影时，即使是 2017-2018 年的峰值也消失了。

如果我们看一下 30 部最受欢迎的电影会怎么样？还是 10？我们可以用不同的价值观创造新的情节。这一次我们将放弃置信区间。我们的 top_n_movies 函数将有助于做到这一点。

mean_10 = top_n_movies(movies_since_1960, 10)['mean']
mean_30 = top_n_movies(movies_since_1960, 30)['mean']
mean_50 = top_n_movies(movies_since_1960, 50)['mean']
mean_100 = top_n_movies(movies_since_1960, 100)['mean']
mean_all = top_n_movies(movies_since_1960, len(movies_since_1960))['mean']# Chart
fig, ax = plt.subplots(figsize=(10, 5))
ax.plot(mean_10, color='black')
ax.plot(mean_30, color='blue')
ax.plot(mean_50, color='red')
ax.plot(mean_100, color='green')
ax.plot(mean_all, color='purple')
ax.set_title('Movies runtime by year')
ax.set_ylabel('Minutes')
ax.set_xlabel('Release year')
ax.set_xlim(1960, 2018)
ax.legend(labels=['10 most popular movies',
                  '30 most popular movies',
                  '50 most popular movies',
                  '100 most popular movies',
                  'All popular movies'])
plt.show()

无论我们拍多少部最受欢迎的电影，都没有趋势的迹象。当我们每年考虑的电影越少，图表上的波动性就越大，这与我们的统计直觉相符——样本越小，波动性就越大。

为了确保更受欢迎的电影不会更长，让我们创建一个表，其中包含今年所有 n 部最受欢迎的电影的平均值——平均值。

total_mean = pd.Series()
mean_list = [mean_10, mean_30, mean_50, mean_100, mean_all]
index_list = ['top_10', 'top_30', 'top_50', 'top_100', 'all']
for i in range(0, 5):
    mean_n = pd.Series([mean_list[i].mean()], index=[index_list[i]])
    total_mean = total_mean.append(mean_n)

print(total_mean)>>>top_10 103.716949
>>>top_30 106.461017
>>>top_50 106.330508
>>>top_100 106.327119
>>>all 105.893473
>>>dtype: float64

平均运行时间之间的差异是微不足道的，它们在 106 分钟左右波动，只有一个例外，即每年排名前 10 位的电影，其平均值为 103.7 分钟。正如我们之前所说的，这里的样本很小而且不稳定，所以这并不意味着大多数受欢迎的电影实际上比平均时间短。

我们年复一年地看着电影《时空》。让我们创造最后一个情节。这一次我们将用电影上映的十年而不是一年来概括和创建一个新的数据集。由于这一点，我们将有更少的组，我们可以为他们创建一个箱线图。

movies_by_decade = movies.copy()
movies_by_decade['startYear'] = ((movies_by_decade['startYear'] // 10) * 10).astype('int64')
sns.boxplot(x="startYear", y="runtimeMinutes", data=movies_by_decade, color='lightskyblue', showfliers=False)
plt.ylim(40,180)
plt.title('Movies runtime by decade')
plt.xlabel('Decade')
plt.ylabel('Minutes')
plt.show()

在 20 世纪 30 年代和 40 年代之间有一个大的飞跃，然后在 20 世纪 50 年代之后有一个小的飞跃，从那以后差别就很小了。

总之，我们的直觉错了。电影运行时没有趋势。这些差异太小了，不会被注意到。我们可以说，在过去的 60 年里，电影的平均长度是一样的。无论我们考虑什么标准，结果都是一样的。感谢你的阅读！现在我们可以回去看电影了！

新技术正在杀死他们的祖先吗？

原文：https://towardsdatascience.com/are-new-technologies-killing-their-descendants-b2ae3a5424b8?source=collection_archive---------12-----------------------

对于我们生活中的每一个时刻，都有新的技术可能以不同的方式重新完成以前的任务，或者添加一些新的东西。对于每一个新技术，它的前一个是不是被破坏了，以后就不用了？自动特征学习模型(如 CNN)是否杀死了他们之前的手动工程模型？这是本文要回答的一个重要问题。

From Pixabay by PublicDomainPictures

每个数据科学家都会使用计算器进行数学计算。计算器有一个简单的界面，只需按下按钮就可以进行运算。在移动电话的发明和发展之后，智能手机出现了，它们有不同的应用程序来完成以前在计算器中完成的操作。问题来了。是因为一项新技术(智能手机)的出现，它以前的技术(计算器)被破坏了，以后再也不会被使用了吗？答案肯定是否定的。有些人说最新的总是最好的，但这并不总是正确的。这是因为新技术不仅带来了好处，也可能带来一些坏处。这里有一个讨论来展示做数学运算的选项:计算器还是智能手机。

计算器只是专用于数学运算，但智能手机不是。智能手机有许多计算器没有的功能。许多功能的可用性而不是有限的功能是一个缺点吗？在某些情况下，工具中的功能越少，性能越好，功能越多，开销就越大。用计算器做运算很简单。只要打开它，按下操作所需的按钮。但是，由于智能手机的众多功能，在智能手机上进行同样的操作会产生开销。以下是将智能手机用作计算器时可能发生的一些情况。

打开用于数学计算的应用程序后，电话可能会响起来一个来电，打断你正在做的事情。手机可能会因收到短信而发出嘟嘟声。它可能连接到互联网，因此可能会发出电子邮件的嘟嘟声。这可能会让你停止做手术。长时间使用手机后，电池可能会耗尽，手机可能会关机，除非它连接到充电器，这将限制移动的灵活性。因此，使用智能手机的人应该注意所有这些影响，以便很好地进行数学运算。与计算器相比，没有 SIM 卡，因此没有来电或短信。基本的计算器没有连接到互联网，因此没有收到电子邮件。计算器的电池比智能手机的电池耐用，因此使用计算器时中断操作的可能性较小。因此，与智能手机相比，使用功能有限的计算器具有简单和专注于任务的优势，即使这是一项古老的技术。总之，最新的并不总是最好的。根据您的需求，旧技术可能比新技术更好，也可能更差。从数据科学的角度来看也是如此。

有不同类型的学习算法和特征用于不同的任务，例如分类和回归。其中一些可能延续到 1950 年，而另一些是最近的。但也不能说老款永远比新款差。我们不能绝对断定 CNN 等深度学习(DL)模型比以前的模型更好。这个看你的需求了。

我发现许多研究人员倾向于盲目使用 DL，只是因为它是一种最先进的方法。有些问题很简单，使用 DL 可能会增加复杂性。例如，将 DL 与 100 个图像分成 10 个类一起使用并不是一个好的选择。这是因为样本数量少，不需要 DL。浅薄的学习在这种情况下刚好足够。如果要创建一个分类器来区分图 1 所示的四种水果(取自 fruits-360 数据集), DL 不是强制性的，以前手工制作/工程设计的特征就足够了。通过调查问题，一种可能有帮助的特征是颜色。每个水果都有不同的颜色。因此，HSV 颜色空间中色调通道的直方图可能就足够了。

Figure 1. Samples from the fruits-306 dataset

让我们展示在这种问题中使用 CNN 深度学习模型所增加的复杂性。首先，需要大量的数据来训练这样的模型。需要指定不同的参数，每个参数都需要长时间的实验。这些包括使用哪种类型的层、每层的数量、激活函数、学习速率等。相比之下，使用色调通道直方图足以获得非常高的精度。

解决数据科学问题有不同的方法，您应该选择最合适的方法。明智地选择最合适的。如图 2 所示，如果一个 350 毫升的水瓶就足够了，为什么还要买一个 1 升的呢？

Figure 2. Rights reserved to langladesprings.com

这就像图 3 中使用梯子爬上墙的顶端一样。如果你在爬了 5 级楼梯后到达了墙的顶部，你不需要在梯子上爬另一级楼梯。同样，如果您可以使用手工设计的特征获得最佳结果，则不必使用自动特征学习。

Figure 3. Rights reserved to deviantart.com (Ladder) and basictextures.com (Wall)

最后，不要认为新技术是每个问题的最佳解决方案。即使它解决了以前的问题，它也可能引入更多的问题或增加更多的复杂性。最后，不要认为 DL 是所有问题的一站式解决方案。

原文可在 LinkedIn 以下链接获得:https://www . LinkedIn . com/pulse/new-technologies-kill-descendants-Ahmed-gad

在 KDnuggets 上转载于此链接:https://www . kdnugges . com/2018/04/new-technologies-killing-ancestors . html

联系作者:

领英:【https://linkedin.com/in/ahmedfgad

电子邮件:ahmed.f.gad@gmail.com

洛杉矶的种族主义房东歧视拉丁裔吗？

原文：https://towardsdatascience.com/are-racist-landlords-discriminating-against-latinos-in-la-118daeb565da?source=collection_archive---------3-----------------------

洛杉矶是一个困难的租赁市场。很难找到你买得起的公寓，更不用说你梦想的地方了。有时候，你会觉得整个系统都在追杀你。新的证据表明，如果你是拉丁美洲人，你可能是对的。

Average Los Angeles rental is $2000 / month

在一项对 1484 名 Craigslist 房东的研究中，来自高加索人和拉丁人名字的相同电子邮件被发送。当控制租赁代理的中和效应时，与来自高加索人姓名的同一封电子邮件相比，拉丁美洲人收到正面反馈的可能性要低 20%。

Mapping response — white bias is seen by green dots without blue/red overlay.

各种形式的歧视都是可怕的，但这些发现中最令人震惊的是少数人在压迫多数人。2010 年人口普查显示，洛杉矶的人口构成是 49%的拉丁裔，28%的白人。尽管自由主义盛行，拉丁裔人口占多数，但种族主义似乎在洛杉矶依然存在。

Regression analysis results: 1484 Craigslist rental ad respondents comparing emails originating from Caucasian and Latino names

自学的游戏玩家真的聪明吗？

原文：https://towardsdatascience.com/are-self-learning-game-players-truly-intelligent-d8e705da993f?source=collection_archive---------16-----------------------

对于非专家来说，我们如何理解这个问题？

自学程序，比如 Alpha Zero 和它的开源兄弟 Leela Zero ，是智能的吗？这种智能与传统的国际象棋引擎，如世界上最强的国际象棋选手 Stockfish 的智能有任何有意义的区别吗？

人工智能领域背负着对智能的主观定义:如果你能解释它，那么它就不是智能的。为了避免这种神秘主义，我们试图提出一个更客观的定义。使用马尔可夫决策过程的形式主义，“智能是一个能够感知和操纵其环境以实现其目标的代理”。这在“它”的定义上是有问题的；但是为了玩游戏的目的，我们可以把一个玩家(代理人，“自我”)和游戏(环境)区别开来。

根据这个定义，我们能说 Leela(自我学习的棋手)比 Stockfish(人类编码的棋手)更聪明吗？根据我们的定义，我认为它们同样聪明:它们都由一个评估函数、一个树形搜索和一些时间控制逻辑组成。两者的目标完全相同(将死；或者，如果不行，就抽签)。截至目前，Stockfish 在实现这一目标方面略胜一筹；但这种差异是微不足道的。

在这两个程序中，树搜索和时间控制逻辑都是由人来编码的。对于库存鱼来说，评估功能是通过人类的作用进化而来的。对 Leela 来说，它是通过一个自我游戏的过程进化而来的(这个过程本身是由人类编写的)。

如果我们认为 Leela 和 Stockfish 只是下棋的代理人，那么他们都是聪明的；或者都不是。没有什么有意义的区别。但是，如果我们扩大作为主体的“它”的范围，把创造玩家的过程包括进来，那么我们也许可以开始梳理出是什么使一个人聪明，而另一个人不聪明。

所以考虑一下，作为我们的两个代理人，创造 Stockfish 的系统和创造 Leela 的系统。他们的环境是怎样的；我们如何描述他们的机构？环境不再是一盘棋；但是它却变成了一系列的游戏和玩家。我们的“代理”通过观察和更新它的玩家(或多个玩家)进行交互，而不是通过玩游戏本身。

当 Stockfish 下棋时——特别是当它输了的时候——人类会分析哪里出错了；并建议对其源代码中包含的规则进行更改。因此，下棋是一种感官行为，它允许更新代理人的状态。

相比之下，莉拉只能通过自娱自乐来学习。与外部对手玩游戏并不是导致玩家代理更新的感官行为。显而易见的结论是，在这个更广泛的环境中，莉拉不是一个有意义的代理人。Leela 的自我学习可能是一个非常成功的自我关注练习，即机器学习，但作为一个系统，它没有表现出任何能动性，因为它没有感觉到周围的环境。

当然，我们可以进一步扩展我们的范围，把自学系统的程序员也包括进来；但是那样我们就会失去 Leela 作为自学代理的概念。

那么，怎样才能证明自学的 Leela 实际上是一种智能，在某种意义上是一种操纵环境实现目标的智能体呢？如果环境是迭代游戏，那么我们的代理需要感知环境，并使用这些观察来实现培养赢得更多游戏的玩家的目标。理想情况下，它还会从该环境中感知游戏规则；但我不会说这是必要的。

到今天为止，我的结论是，Stockfish 展示了塞尔的中国房间的超人智慧(内部人类对它正在解决的问题确实有一些有限的理解)；但是莉拉(和阿尔法零)没有。

然而，我很乐观。AI 研究人员正在积极研究这些问题:例如，使用逆向强化学习。如果在 2019 年看到一个真正智能的游戏代理，我一点也不会感到惊讶:一个不仅从与硬编码模型的自我游戏中学习的代理；而且与其他这样的代理交互(合作或竞争)以探索规则。如果我们的唯一目标是创造世界上最强的棋手，就不需要这样的智力；但是，随着我们越来越多地将这些人工智能嵌入到我们的日常生活中，我们将需要能够学习并适应我们称之为“现实”的不断变化的游戏规则的系统。

技术专家准备好迎接环境智能的数据商品了吗？

原文：https://towardsdatascience.com/are-technologists-ready-for-the-data-commodity-of-ambient-intelligence-a40c4ef034d4?source=collection_archive---------9-----------------------

Photo by Joshua Sortino on Unsplash

如今，精明的消费者意识到，营销人员和公司从手机和电脑中挖掘个人数据，这些数据主要来自搜索引擎、社交媒体网站、电子邮件、短信和 GPS 定位信息。互联网，一个在 90 年代被理想化的免费虚拟公共空间，已经被一系列承诺的便利所殖民。起初，免费、便捷的数据服务非常诱人。在云中查看电子邮件时，用户体验的改善足够大，以至于不会引发关于如何处理电子邮件的问题——例如当谷歌在 2004 年推出 Gmail 时，增加了通过个人可识别信息丰富搜索引擎用户档案的第二个信号。GPS 跟踪也成为收集个人信息的有力手段。电子商务网站通过投放 cookies 跟踪在线行为来做广告。承诺降低取暖费的自动调温器追踪人们在家中的行为数据。但是，对于大多数个人来说，营销人员和大公司对数据需求的基础仍然模糊不清。这些数据的价值是什么？个人的数字隐私是否是使用互联网服务和应用程序的公平交易？

环境智能:人工智能认知的更高层次

许多人认为技术对隐私的统治是不可避免的。今天，发达国家的人类占据着一个混合的数字和物理空间，这个空间在很大程度上是由信息的自动收集、交易和分析驱动的，很少或根本没有努力保护技术使用者的基本权利和自由。随着物理世界和数字世界的融合，数字隐私不再是一种权利，而是一种可以交易和解决的商品——同时，物理隐私继续受到保护。

技术只是比政策机制发展得更快，这使得技术专家可以强加他们自己的规则。大数据推动了旨在预测人类行为和偏好的数据挖掘和分析的大幅增长。2016 年 10 月发布的一份白宫报告指出，大数据实际上是人工智能的前身，来自电子商务、企业、社交媒体和科学的大数据的可用性“……为大幅改进的机器学习方法和算法提供了原材料。”

一旦物联网的许多方面的互操作性进化，以及更高水平的人工智能认知，环境智能将会出现。在一个环境智能的世界中，设备无缝地工作，利用隐藏在网络中的信息和设备进行生活活动。这些设备将变得越来越小，越来越集成到环境中。想象一下，一个人工智能助手在你需要的时候为你提供产品和服务；无论是在你离开机场的时候搭车，还是更换一周前吃过的食物，或者是订购干洗衣物。机器人和传感器的目的是尽可能多地学习和了解你的个人习惯，以增加便利性。

显然，技术专家有一些责任，这是当前关于人工智能和环境智能的讨论中所没有的。普通人群可能不会表现出实质性的关注(或理解)来改变其行为或修改其选择，但这并不意味着这些机制应该不受检查。高阶思维认为，人们(和社会)需要更多地控制个人信息，包括任何用于观察、构建或产生个人知识的机器。

隐私的价值是什么——消费者在乎吗？

“对个人信息的控制是对一个人向世界展示的身份的一个方面的控制，隐私权是在构建自己的身份时免受不合理限制的自由。”菲利普·阿格雷

Gartner 预测，到 2018 年，50%的商业道德违规将因大数据和分析的不当使用而发生。与此同时，一些公司对此表示反对，采取措施在数据伦理的旗帜下脱颖而出。Whatsapp 和 Signal 等服务通过使用端到端加密完全避开了数据收集。这一决定有助于消除处理敏感个人数据时的潜在责任，因为这些数据根本不会被保留。

然而，没有一定程度的数据科学，并不是每个公司都能成长，更不用说生存了。大数据是燃料来源，即使移动、人工智能和环境智能等“引擎”在运营中变得越来越复杂和微妙。在这种情况下，数据平台正在推动这些决策，那些制定了隐私道德政策的平台将在统计上提供更多价值，因为营销人员、创业公司和企业公司都需要与消费者建立联系，而又不把他们吓跑。

这些积极主动的决策有助于改变消费者的观点，尤其是在竞争激烈的环境中。根据宾夕法尼亚大学的一项研究，超过一半的互联网用户关心保护隐私，但觉得可能为时已晚。根据皮尤调查中心的数据，74%的美国人认为控制自己的个人信息“非常重要”。与此同时，据查普曼大学称，美国人的头号恐惧是人为灾难(如恐怖袭击)。紧随其后的是政府和企业对个人数据的追踪，超过了对犯罪、环境和自然灾害的关注。

在这一点上，说消费者“不关心隐私”是为了逃避收集数据带来的道德责任。随着技术的进步，包括我们的周边环境，围绕大数据的讨论越来越深入，因为它可能会影响身份并降低自主性。在未来，那些作为中介处理数据的人——这意味着向第一方公司提供必要的数据，同时缓冲和保护收集的消费者信息——将比那些像处理商品一样处理敏感信息的人更专业。

原载于 2018 年 2 月 13 日 贝斯科技 。

请在 Twitter 上关注我@贝丝·金迪格 T13:)

查尔斯顿的暴雨更严重吗？

原文：https://towardsdatascience.com/are-these-charleston-rainstorms-more-severe-bfbe82f361fe?source=collection_archive---------9-----------------------

我和妻子每天早上带着我们的狗和孩子在查尔斯顿附近散步。我妻子说，在我们住在查尔斯顿的三年里，这里的天气总是阴雨连绵，而在这特殊的一天，又一场暴雨即将来临。我在查尔斯顿长大，我发誓不是在这种暴风雨中长大的。我记得，在夏季的几个月里，下午下了一个小时的倾盆大雨，但我们从来没有像现在这样连续下了几天的大雨。查尔斯顿的洪水似乎也成了我小时候不记得的问题。我知道这些数据可以从 NOAA 网站上获得，所以我开始回答这个问题:“查尔斯顿的暴雨变得越来越严重和频繁了吗？”

首先，我调查了每年下几次大雨。我带着不到一英寸的雨水出去了一整天。乍一看，我的预感似乎是错误的。本世纪只有两年有三天降雨量超过三英寸。他们只是碰巧在 2015 年和 2016 年，2015 年是我和妻子搬回查尔斯顿的那一年。2015 年是一个多雨的年份，有 14 天超过 1 英寸，3 天超过 2 英寸，3 天降雨量超过 3 英寸。

基于这些发现，我们似乎没有经历过导致更严重降雨的可测量的气候变化——除非它在 2015 年才开始。那么为什么所有的洪水？雨季似乎出现在零星的街区。我把数据按月分解，认为现在的月份肯定比以前多雨。我取出了降雨量少于两英寸的典型日子，并认为我已经找到了关键变量——不是多雨的日子，而是多天的事件。

没有。本世纪只有三个月的降雨量达到了至少 8 英寸，而且只有大暴雨(每天超过 2 英寸)。过去的两个十月恰好是其中的两个——2016 年 10 月 7 日和 8 日的马修飓风和 2015 年 10 月 1 日、3 日和 4 日的百年一遇风暴。

查尔斯顿的暴风雨似乎没有变得更猛烈。我们最近运气不好，尤其是在十月初。下图显示了自 1960 年以来最严重的几个月。在本世纪，我们只有五天的降雨量超过四英寸，而且都是在八月、九月或十月(其中三天在十月)。两年不完全是一个趋势，但为了安全起见，我会在 10 月初检查我的排水泵。

因此，虽然这些夏季风暴每月平均降雨量最多(见下图)，但自 1982 年以来，我们还没有在五月或六月遇到大风暴。这些降雨大多出现在 9 月和 10 月，这两个月比较干燥，但也有更多的极端风暴。我和妻子提出的查尔斯顿的天气越来越恶劣的假设没有数据支持。也就是说，随身携带你的雨伞！毕竟这是查尔斯顿。

Avg. Daily Precipitation

2017 年 5 月 27 日

丹尼尔·佩尔穆特

www.risingtide.marketing/blog

翻译们担心 MT 抢了他们的饭碗吗？既肯定又否定

原文：https://towardsdatascience.com/are-translators-worried-about-mt-taking-their-jobs-yes-and-no-b0eb1c4216e7?source=collection_archive---------3-----------------------

大约 50 年前，虚构的机器人哈尔在《2001:太空漫游》中首次亮相。

四十多年后，我们似乎还没有达到电影中描绘的超级智能水平，但我们肯定正在接近。随着人工智能(AI)的不断进步，机器统治世界的想法似乎越来越不可能。

人类和机器之间的紧张关系在语言行业中非常明显，许多人预测机器翻译将最终淘汰人类语言学家。

行业分析师有很多猜测，但是译者对这些预测有什么感觉呢？毕竟，如果人工智能真的达到超过人类的智能水平，这些人显然会受到最大的影响。

我们采访了三位语言学家，了解他们对机器翻译争论的看法，普遍的共识似乎是这样的:机器翻译正在进步，但还没有必要让翻译们开始收拾自己的小房间。

质量有吗？

我们从 ULG 翻译那里获得了关于 MT 的质量、资产和衰落的见解，他们在这个行业总共有 40 年的经验。这三个人都提到了机器翻译的局限性，尤其是在获取上下文的时候。

豪尔赫·莫亚和克劳迪娅·博尔顿都认为 MT 的质量很差。

“基本的文本可能有用，但一旦我们进入技术，或者更糟的是，营销或人员培训，机器翻译就不起作用了，”波尔顿说，他用德语和英语翻译。

“我看过很多我必须校对的文本，基本上我必须重新翻译整个项目，因为它是不可理解的。”

英语到法语的翻译 Nicolas Kmiec 承认，机器翻译在文学或医学文本方面做得不好，但指出这项技术已经取得了很大进展。

“我相信质量会越来越好。我被一家公司要求校对一个非常技术性的领域的机器翻译，翻译得相当好。一旦术语被设置在机器中，错误的感觉、误译和词汇错误的风险就会降低，”他说。

"在这类领域，翻译相当简单:小句，主语-动词-宾语."

“火鸡制造”:机器翻译与语境

MT 最大的卖点之一是它加快工作流程的能力。人类可能需要几天来审阅一个文档，而机器翻译系统可能只需要几个小时。

根据 Kmiec 的说法，如果环境合适，这项技术可能是有益的。

“根据翻译的主题，机器翻译确实在非常特殊的情况下提高了效率。但在大多数其他情况下，机器翻译只是浪费时间，因为所用的术语通常是公认的术语定义，”他说。

他补充说，机器翻译缺乏细致入微的语言技能也可能是一个障碍。

“你会发现像‘fabriquéen Dinde’(法语)这样的‘土耳其制造’的翻译，这个国家被误认为是鸟，”克米克说。

莫亚补充说，糟糕的机器翻译会增加工作流程的效率，迫使编辑在阅读效果不好的文档上花费更多时间。不过，他承认，在某些情况下，这也有好处。博尔顿也提出了类似的观点。

“看看我迄今为止的经历，不，(MT)并没有让事情变得更容易。她说:“对于拥有一篇文章并想了解其内容的人(不是翻译，而是普通大众)，机器翻译可能行得通。”。

“但在我的领域(技术、法律、营销)，这甚至比使用‘旧’的翻译记忆和术语表以及手动翻译更费力。”

百万美元问题

那么，未来呢？翻译担心他们的工作吗？

和许多实质性问题一样，没有简单的答案。但就目前而言，我们采访过的语言学家并不认为 MT 面临迫在眉睫的威胁，但也有一些回旋的余地。

当被问及是否担心机器翻译会取代人类翻译时，莫亚说“绝对不会”。“附加值、人性化、质量和安全使得人工翻译一如既往地重要。”

博尔顿同意这一观点，他说只有人类语言学家才具备识别源文档中细微差别和上下文的能力。

Kmiec 有不同的看法。他解释说，机器翻译正在快速发展，这些进步有可能在行业中创造一个范式转变。

“今天的技术还不足以让机器翻译取代人类翻译，但它正在以很快的速度发展。他说:“我认为，在十年的时间里，翻译人员将开始在技术翻译等非常特殊的领域担任机器翻译校对工作。”。

然而，与此同时，Kmiec 指出，翻译细微差别的文本对于由人工智能驱动的机器来说仍然是一个障碍。不过，他说，最终，语言学家的未来可能不会那么光明。

“当我们放眼未来十年，笔译和口译的前景非常暗淡。拉伯雷在《巨人传》中说，使人与众不同的是他笑的能力。一旦机器有了这种能力，一旦机器理解了它的意思，而不仅仅是它说了什么，人工翻译将会减少，”他说

本文原载于【ULG 日报】 。订阅这里:http://unitedlanguagegroup.com/ulg-weekly-digest-signup/。

UUIDs 真的唯一吗？

原文：https://towardsdatascience.com/are-uuids-really-unique-57eb80fc2a87?source=collection_archive---------0-----------------------

UUID 一般代表uuuniqueid标识符。它看起来像由破折号分隔的 32 个字符的字母和数字序列。一些例子:

8 f14 a65f-3032-42 c8-a196-1 cf 66d 11 b 930

b 400 af 61-6cb 4-4565-89 C4-d6ba 43 f 948 b 7

UUIDs 便于给实体起自己的特殊名称，例如在数据库中。有几种方法可以生成它们，包括基于时间、MAC 地址、哈希和随机数的方法，但它们都做出了相同的承诺:没有两个是相同的。每一个在空间和时间上都是独一无二的。

直觉上，这似乎不对。如果 UUIDs 是随机生成的，那么一定有某种的机会，一个序列被生成不止一次，特别是当我们生成越来越多的时候。让我们计算在一组 UUIDs 中没有重复的概率。

UUID 的 32 个字符是十六进制的，或以 16 为基数的表示法。每个字符可以是数字 0 到 9，或者是字母 a 到 f。在 UUID 中，32 个十六进制 x log2(16)位/十六进制= 128 位。在版本 4，变体 1 类型的 UUID 中，6 个比特是固定的，剩余的 122 个比特是随机生成的，总共有 2 个可能的 uuid。我们将这个值称为 n 。我们马上知道，如果生成的 uuid 的数量超过了可能的 uuid 的空间，即如果 r > n ，那么一定有一些重复。

无重复的方式数为n**(n-1)(n-2)……(n-(r-1)。第一个 UUID 可以是 n 种可能性中的任意一种，第二个可以是除第一个之外的 n 中的任意一种( n -1)，第三个可以是除前两个之外的任意一种( n -2)，以此类推。生成ruuid 的方式总数是 n^r ，因为每个r*uuid 有 n 种不同的可能性。将两个计数相除，得到没有重复 UUIDs 的概率:

Probability of generating r unique UUIDs

对于如此大的数量，直接计算概率在计算上是不可行的。大阶乘可以通过斯特林公式来近似，给出:

Approximate probability of generating r unique UUIDs

如果 r 固定且 n →∞，则上述等式的第一部分可表示为:

乘以第二部分，乘积为 1。因此如果 n ≫ r 几乎可以肯定不会有重复。但是如果 r 确实接近 n ，UUID 可能会重复。

r 到底应该有多大？我们可以从不同的角度来处理这个问题，这里我们不是从 n 和 r 开始，并试图计算 p，而是从 n 和 p 开始，并得到 r 。下面的图表显示了给定唯一性概率下 UUIDs 的大致数量。它的值是用维基百科引用的一篇论文的近似公式计算出来的，其中r= . 5+sqrt(. 25–2 * ln(p)**n*)。

3.26 * 10⁶uuid 的样本有 99.99%的可能性没有任何重复。以每秒一个的速度生成这么多 UUIDs 需要十亿年。因此，虽然 UUIDs 并不是真正唯一的，但考虑到人类寿命的自然限制和系统的分离，它们对于实际用途来说是足够唯一的。

我们要选择全球监控吗？

原文：https://towardsdatascience.com/are-we-opting-into-global-surveillance-c088d2b71bf7?source=collection_archive---------10-----------------------

The technology we use is always watching.

当乔治·奥威尔写《1984》时，他描绘了一幅在政府监管下运作的社会图景。奥威尔从未想象过一个人们选择监视而非隐私的世界；老大哥是一个要求，而不是一个选择。然而，他在 20 世纪 40 年代写了这部小说，那是在每个人都带着追踪位置、声音和个人信息的手持设备四处走动的几十年前。快进到大约 70 年前，戴夫·艾格斯创造了一个围绕着的世界，这个圈子，一个通过访问个人信息来控制社会的科技企业。《圆圈》最近被拍成了一部重要的电影，它是一个迷人的世界，在这个世界里，要求人们顺从的社会压力让人们害怕被忽视。基于谷歌、脸书和亚马逊等科技巨头，埃格斯的反乌托邦感觉比政府监管的监控更接近我们当前的现实；即使存在像 2015 年网络法案这样的政策。

亚马逊回声(Amazon Echo)或谷歌主页(Google Home)等语音激活设备的用户选择在家中进行全天候监控。这些“永远在线”的设备只会在你说出正确的命令时做出响应，但它一直在监听。就在最近，亚马逊同意向调查一起谋杀案的警方发布 Alexa 录音，而此前他们拒绝了这一要求。这个例子证明亚马逊可以访问这些设备上的所有记录。

任何人只要插上 Echo，就能让亚马逊获得他们家中的每一次对话和噪音。监听设备不是唯一的；监视你的宠物的家庭安全硬件，你授权访问你的麦克风的智能手机应用程序是监控游戏中的其他罪犯。今年早些时候， Vizio 解决了一起据称出售智能电视用户观看数据的案件。甚至不用说话，你的设备就能跟踪你的一举一动和声音，然后利用这些信息赚钱。

Snapchat 的新功能 Snap Map 可以在全球实时地图上追踪你的朋友。它还显示在任何给定时刻发生最多快照的地方的“热图”，以及来自世界任何地方的不同地点和事件的实况报道。通过选择地图功能，你的朋友(很可能还有其他人)可以看到你在哪里。一直都是。通过在“我们的故事”中添加快照，人们可以更容易地发现您的图片和视频。

我们不打算互相监视，但这是快照地图等新功能的次要影响吗？随着无人机越来越受欢迎，不无意中发现彼此的秘密和信息几乎是不可能的。将世界各地的人们联系起来肯定有积极的影响，比如文化共鸣和对你周围世界的更多了解。但那只是故事的一面，你打赌不是大家不看就同意的“条款和条件”那一面。

我们提供的信息越多，留给自己的就越少。如果知识就是力量，我们会心甘情愿地将力量给予那些能够剥夺我们权利和特权的实体。当人们选择监视自己时，我们的政府没有必要制定监视法。

我们在照顾我们的孕妇吗？

原文：https://towardsdatascience.com/are-we-taking-care-of-our-pregnant-women-8863980f3830?source=collection_archive---------4-----------------------

Image by CARE International

不可否认，分娩是所有物种最珍贵和最美丽的时刻之一，当然也是人类最珍贵和最美丽的时刻之一。这对女性来说是一个非常重要的时刻，她们应该采取一切可能的安全措施来保护自己和孩子的健康，对吗？这听起来非常简单明了，但实际上并非如此。

根据世界卫生组织的报告，每天约有 830 名妇女死于与怀孕和分娩相关的可预防原因，据估计，2015 年约有 303 000 名妇女在怀孕和分娩期间或之后死亡。

尽管在 1990 年至 2015 年间取得了巨大进步，全球孕产妇死亡率下降了约 44%，这要归功于千年发展目标 5——改善孕产妇健康，但在一些国家，分娩仍然是一个危险的过程。这主要是由于获得保健服务的不平等，因为 99%的孕产妇死亡发生在发展中国家。

Image by UNFPA Philippines

你知道在你们国家，妇女一生中产妇死亡的风险有多大吗？

世界银行与世卫组织、儿童基金会、人口基金和联合国人口司共同提供的一些统计数据显示，平均而言:

在发达国家，4900 名妇女中有 1 名最终会死于母亲原因；
在发展中国家，180 名妇女中有 1 名最终会死于母亲原因。
在脆弱的国家，每 54 名妇女中就有 1 名最终会死于母亲的原因。

很清楚的数字，你不觉得吗？点击此处 了解你们国家的费率是多少。

据世卫组织称，妊娠和分娩期间及之后与孕产妇死亡相关的最常见并发症有:

严重出血(多为产后出血)
感染(通常在分娩后)
妊娠期高血压(先兆子痫和子痫)
分娩并发症
不安全堕胎
怀孕期间的疟疾或艾滋病。

为了缩小发达国家和发展中国家之间仍然存在的巨大差距，并保证全世界的妇女、青少年和儿童能够获得高质量的医疗保健，世卫组织和利益攸关方制定了2016-30 年全球妇女、儿童和青少年健康战略，我们进入了可持续发展目标 (SDGs)时代。第三项可持续发展目标为妇女和孕产妇健康设定了非常重要的目标:

可持续发展目标 3:确保健康生活，促进所有年龄段所有人的福祉(点击**查看可持续发展目标 的完整列表)

到 2030 年，将全球孕产妇死亡率降至每 100 000 例活产中不到 70 例。
到 2030 年，确保普遍获得性保健和生殖保健服务，包括计划生育、信息和教育，并将生殖健康纳入国家战略和方案。

可持续发展目标和全球战略对于解决国家内部和国家之间令人震惊的不平等和不公平极其重要，对全世界妇女来说当然也很重要。为确保所有战略和举措得到有效实施，联合国任命了独立问责小组(IAP ),每年报告全球战略和可持续发展目标的进展情况。在他们去年九月发布的第一份报告中，不平等是结果回顾的核心:

国家内部和国家之间的不平等是妇女、儿童和青少年健康的根源。

IAP 指出的挑战之一是准确数据的可用性，尤其是在欠发达的卫生信息系统场景中，因为信息是正确分析进展的基础。该报告指出，在一个技术迅速发展的时代，我们不得不依赖对基本指标，如孕产妇死亡率的估计，这是不可接受的，这是完全正确的。

《国际行动计划》强调，需要在加强卫生管理信息系统的同时，监测《全球战略》下的进展，包括提高国家统计机构的能力和独立性。

不可否认的是，在妇女、儿童和青少年健康方面取得了巨大进步，但同样不可接受的是，妇女仍然死于怀孕期间或之后可预防或可治疗的并发症，这主要是由于获得保健服务方面的不平等。

所以，还是照顾好我们的孕妇吧！

参考文献

世界卫生组织— 孕产妇健康

联合国— 可持续发展目标

独立问责小组— 【妇孺】

我们到了吗？

原文：https://towardsdatascience.com/are-we-there-yet-daceccfdea38?source=collection_archive---------18-----------------------

数据科学中的项目管理

昨天，一位 Redditor 在r/data science上问了一个很棒的问题，当我写下回应时，这个问题让我的思绪向几个方向移动。我也希望在这里听到每个人的想法，特别是如果你有自己处理项目风险的技巧。reddit 的帖子可以在这里找到。 我(略加编辑)的回应如下。

Project management can be dirty work.

问:数据科学家如何管理项目和团队？你如何估计持续时间和资源？

这些都是很棒的问题，我认为人们问得不够多，这也是我写像数据科学家一样思考的主要原因之一。一个完整的章节致力于项目规划，另一个完整的章节是关于各种环境下的项目执行。我认为要很好地运行项目需要很多思考和考虑，我不认为我能在这里做到公正，但我会看看我是否能指出在这种情况下有所帮助的一些事情:

不确定性意识

首先，我一直在谈论“不确定性意识”的概念，因为数据科学和统计任务远比软件开发更不确定，例如，在一项任务可能需要多长时间方面，甚至该任务是否可能。

考虑一个数据科学项目的基本示例，其中您可能会看到这样一句话，“我们的目标是能够以 95%的准确率预测业务成果 X。”在项目开始时，我们不仅不确定需要多少时间和精力才能达到 95%，而且我们甚至不知道数据是否支持达到 95%。

因此，我喜欢强调的一点是，需要正式承认项目的哪些部分具有最大的不确定性，并制定计划来减少不确定性。减轻上述例子的一个方法是与产品/业务/客户人员讨论是否“95%或破产”，或者 80%对于产品的第一个版本是否合适，或者类似的事情。

灌篮+尽可能好，否则

以这种方式思考可以让你制定一个项目计划，其中包括在确定性方面“稳操胜券”的部分，然后对于不确定的部分，你可以计划让它们“在 2 周内尽可能好”或类似的东西。

如果你这样做了，你将拥有一个数据科学产品，它将花费同样多的时间来构建一个等效的——更可预测的——软件工程产品。主要缺点是结果的准确性/质量不会像你希望的那样高，但至少你有一个完整的结果和产品可以展示。以后改善结果可以是后续项目。

这可能不是在每种情况下都理想，但我发现它非常有帮助。

进入:流程图

我喜欢使用的一个概念规划工具是显示项目步骤的流程图，我在流程图中包含了我的不确定性。为此，我在流程图中加入了一些提问“这些结果够好了吗？”如果是则路径通向一条路，如果否则通向另一条路。您还可以对项目中的某些步骤设置时间限制。我喜欢将这些想法形式化，这样团队中的每个人都知道它将如何工作。

下面是《T5》一书中的几个流程图示例:

Examples of flowcharts for projects in data science, from Think Like a Data Scientist, chapter 6.

问:你对数据科学家的项目管理有什么建议？

如果你喜欢这个，看看我的其他帖子:

[## 数据科学真的是“科学”吗？

为什么数据科学可能是一个严格的领域，不同于它的前辈

towardsdatascience.com](/is-data-science-really-a-science-9c2249ee2ce4) [## 检查您对数据的假设

没有人喜欢糟糕的假设

towardsdatascience.com](/check-your-assumptions-about-your-data-20be250c143)

Brian Godsey 博士是一名数学家、企业家、投资者和数据科学家，他的著作 像数据科学家一样思考 现已有印刷版和电子书。——briangodsey.com

要了解更多，请下载免费的第一章 像数据科学家一样思考 并查看此 幻灯片演示文稿 了解更多信息和折扣代码。

科技训练营值得吗？一个人的旅程

原文：https://towardsdatascience.com/arebootcampsworthit-b8eb4d28770d?source=collection_archive---------0-----------------------

去年 8 月和本科一起数学毕业。我学过一些编程，我喜欢它，但是我和计算机科学或工程专业的学生没有竞争力。我想把下一步和编程作为我的职业，但我需要在我的学生贷款生效之前尽快完成。我开始寻找训练营来开始我的职业生涯。

科技训练营无处不在。他们分布在每个主要城市，在技术领域扮演着不同的角色。大部分是做前端 web 开发的，但我选择了从事数据科学。4 月，经过 12 周密集的数据科学培训，我从 Metis 毕业。我不得不投入大量的现金，以及大量的辛勤工作，但我得到了很多回报。

训练营能为你做什么？

现在，大多数训练营是为前端 web 开发准备的，但是有各种不同的类型。Metis 芝加哥校区的开放式办公空间与 Dev Bootcamp 共享。在梅蒂斯，我学到了不止一种训练营的细节。为了这篇文章，我将严格地谈论我的个人经历，但是许多训练营有共同的主题或结构，因为管理他们的人会以其他成功的训练营为榜样。

训练营的目的是给你一份工作。这并不意味着你将在 12 周内成为你的手艺的大师。其实毕业的时候才是真正学习开始的时候。在训练营期间，你会发现你到底有多少不知道，从那里你可以开始继续学习、提高技能和实践的漫长旅程。训练营的存在是为了让你快速上手，给你尽可能多的实践经验，并在之后帮助你找到工作。

训练营的一天

那么 Metis 的数据科学训练营到底是什么样子的呢？首先，它长达 12 周，每周 5 天，每天 9 小时。这还不包括你课外工作的时间。训练营将使用“身临其境”这个词——这正是他们的意思。在这 12 周里，我建立了 5 个使用真实世界数据的机器学习项目，我还创建了一个博客来展示其中的一些，并确保我的 GitHub 符合标准。最重要的是，我每天都和同学一起练习编码、解决问题和演示技巧。训练营的理念是就一个话题进行演讲，然后立即付诸行动。要学的东西太多，时间又太少，你需要把自己的手弄脏，这样才能坚持下去。

在课堂之外，我每周至少参加一次活动。这些可能是客座演讲，网络活动，或者只是社交。很多数据科学家来和我的班级严格对话，给我们讲他们的工作，回答问题。其他人是为了更大的对公众开放的活动而来的——Irmak Sirer甚至做了一个关于使用生成对抗网络来创建他的脸的图像的演讲！所有的活动都是建立关系网和课后放松的好机会。

我每周都接受某种形式的职业培训。这表现在与我的职业顾问进行一对一的会谈，不同的研讨会，或者与我们分享新的资源，为我们的职业寻找做准备。更不用说职业头像(看看我的 LinkedIn )、名片和认真的简历修改了。我们还花了很多时间进行模拟面试(技术和其他方面的)，这被证明是非常宝贵的。最后，我们举办了一个职业之夜活动，受到了招聘人员的猛烈抨击，我有机会展示了一个我花了三周时间进行的激情项目。

毕业后

一旦你完成了训练营，你就进入了一个校友社区。对于 Metis(和 Dev Bootcamp)来说，这意味着一个私人校友渠道。每天至少有一次新的工作发布。通常是由职业发展部的人写的，但是更多的资深校友经常发布他们公司正在招聘的信息——谈论一个伟大的网络！人们也张贴各种伟大的文章和资源。如果你参加类似于 PyCon 或其他会议，这是一个很好的社交和结识他人的方式。最棒的是你是终身会员。展望未来，你将拥有一个由数百名数据科学家(开发人员等)组成的网络。)有着各种各样的经验。你将直接获得有助于你职业发展的机会，也有机会雇佣刚毕业的聪明、上进的人。

My graduating cohort :]

此外，Metis 和 Dev Bootcamp 的毕业生可以进入他们的私人招聘平台雇佣。Employ 有点像 LinkedIn，但只针对 Metis 和 Dev Bootcamp 的毕业生(如果你想知道的话，这两个阵营都属于同一家母公司)及其招聘伙伴。这意味着招聘人员或数据科学家可以查看您的个人资料和突出显示的项目。同样，你可以直接联系未来公司的人并得到回应！

最重要的是，如果你想进来工作，你可以继续使用办公空间。这意味着你将有更多的机会与你的职业顾问见面——他将永远是你的职业顾问——并且你可以继续参加每周的活动。

我的经历

是时候公布你们期待已久的细节了！我会保密的。如果有任何你想回答的问题，请留下评论，我会尽快回复你。

在 Metis 之前，我面试的职位在 50-62 万美元之间。毕业后，我在$ 85–105k范围内有竞争力。训练营花费了 15500 美元。我大学学的是纯数学，做过一些编程。就像我热爱抽象数学一样，我 真的热爱 机器学习。对于我的职业、我新发现的激情和未来，我再兴奋不过了。

在毕业前和毕业后的几周里，我面试了几家公司。最终，我在 HERE Technologies 接受了一份带薪实习，之后有可能去 FTE。我选择这里有几个原因:

给我提供工作的首席研究工程师是一个杰出的人。我非常乐意在他手下工作。
我正在与计算机视觉和深度学习方面的专家合作。我知道这个职位会让我在继续学习。
工作地点是在科罗拉多州的博尔德。我很高兴改变了节奏，可以去滑雪了！
我是高度自动化驾驶团队的一员。我们的平台和模型将很快以一种非常真实的方式影响世界。

A view of the Flatirons.

对我来说，这是一份理想的工作。如果没有我在 Metis 接受的额外培训，我不可能从一个数学学士升到如此有竞争力的位置。

我忘了说什么了…？

人民。当你考虑报名参加训练营时，这是一个非常重大的决定，也是一个个人决定。这都是关于你，你的事业，你的钱，你的生活。几乎所有的训练营都有一个申请过程，他们最终会拒绝很多申请人。这意味着你将被其他学生包围，他们都做出了同样的重大决定，他们都应该在那里。你的同学将会很棒，你们将会一起分享你们在训练营的时光！我不知道这些关系最终会成为训练营经历中最有价值的部分。

同样，教师也是非凡的。他们来自不同的背景，但都是经验丰富的专家。在 12 周的时间里，我从他们身上学到了很多东西，其中很多是课程上没有的知识。我学到了职业技巧，更多的小众机器学习技术，等等。我认为我的导师是我的朋友，也是我网络中最好的联系人。

放弃

显然这是我的个人经历，你的可能不一样。一定要做足功课，有选择性，最重要的是做好工作准备。参加训练营并不意味着你有资格获得工作。如果你参加一个，你将不可避免地听到一个关于某人没有完成它的恐怖故事。记住训练营的存在目的——让你快速上手，给你尽可能多的实践经验，然后帮你找到工作。剩下的就看你的了。

和安东尼·鲍代恩一起环游世界——一个叶子教程

原文：https://towardsdatascience.com/around-the-world-with-anthony-bourdain-a-folium-tutorial-7e9ad63fb650?source=collection_archive---------5-----------------------

食物和旅行是我童年成长的核心。提供热腾腾的饭菜是我家人表达爱的方式，我是在缅甸和中国美食的熏陶下长大的(谢谢妈妈！).我父母带我们去了他们能去的任何地方，以此来拓宽我们在德克萨斯州达拉斯郊区以外的视野。夏天的公路旅行，偶尔去香港拜访我爸爸的家人，大学毕业时去挪威，最近一次是去日本的家庭旅行。

我们决定去日本后做的第一件事是什么？当然是看《无预约》东京集。我的整个家庭一直喜欢安东尼·鲍代恩的所有表演，他激发了我们长久以来的旅行欲望。所以当我看到一个包含他的节目每一集的位置数据的文件时(感谢 Christine Zhang 提供的数据集)，我知道我想要弄清楚如何映射它。我想要一个交互式地图，你可以放大和缩小，点击一个特定的城市，并查看它播出的节目、季节和剧集。让我们开始吧。

用叶子作图

在对交互式地图工具和库做了一些研究后，我选择了 follous，因为它可以在 Jupyter 笔记本中轻松地进行内置地图渲染。地图本身是一个名为传单的 Javascript 地图库的一部分，而 Folium 是一个类似于传单包装器的工具，可以让你用 Python 调用地图。他们的 Github 上有几个令人难以置信的关于叶子地图的例子，我强烈建议看一看！

在用熊猫阅读了。csv 并将其转换为列表，检查我们正在处理的数据:

非常酷，它有我们需要的一切，但我们必须清理一下。通过文档查看映射函数和标记变量所需的数据类型。在这种情况下，我只需要坐标和弹出文本。正如我提到的，我希望弹出文本包含剧集、季节和城市名称。

我开始使用的数据看起来完美无瑕，直到我遇到似乎无穷无尽的数据类型错误。我将简短地讲述我所学到的东西:

坐标数据类型需要是元组或列表。原始数据集将经度和纬度设置为一个长字符串，即‘29.951066，-90.071532’。将数据类型更改为:[29.951066，-90.071532]。
没有撇号？？如果你的标记中有撇号，叶子就不会渲染。它不会绘图，但也不会向您抛出错误。您的地图将无法渲染。我坐了很久，心想可能是我的数据集太大了，结果发现地图刚刚坏了。我希望这能节省你一些时间。

a simple .split() and .replace() fixes both of these errors!

3.取出所有空/南值。这很容易用熊猫函数 isnull()来完成。

pd.isnull() Detects missing values for an array-like object.

很好。干净的数据是最好的数据。现在我们可以设置变量了。我更喜欢在设置变量时使用字典，所以让我们把这个列表变成字典列表:

现在我们的数据更容易阅读，因此更容易调用。

现在我们有了字典列表，我们终于可以映射了！正如你在下面看到的，我把原始地图的参数硬编码到了参数中。然后，我浏览了每本字典，并在每个坐标上做了标记。我想为这个地方播出的每个节目做一个不同颜色的圆形标记，这是通过三个“如果”语句完成的:

现在我们只需要调用我们的地图，然后..

出现野图！我们现在有了一个漂亮的地图(我用了雄蕊调色砖),每个位置都有彩色编码的圆圈标记。而且是可以点击的！

“未预订”是浅蓝色圆圈
“零件未知”是深蓝色圆圈
“中途停留”是红色圆圈

带上热火…地图

好吧，让我们再加把劲。Folium 拥有大量令人惊叹的插件，可以轻松定制地图的美感以及与地图交互的方式。

在这种情况下，一个有用的方法是 Heatmap，在导入插件后，通过将每个位置循环到 HeatMap()函数中就可以很容易地做到这一点。

Folium 有许多图块(地图样式)可供选择，所以我在这里切换到“CartoDB Dark_Matter ”:

就是这样！为了更进一步，还有另一个名为 HeatMapWithTime 的插件，它将根据日期(或季节)为您的地图制作动画。)与您的坐标相关联。

Folium 非常容易使用，并且有许多内置的功能来帮助你定制你的地图。我希望这个教程是有帮助的，或者你已经被激励去继承 Bourdain 鼓舞人心的遗产，去新的地方旅行。

A/B 测试中的到达率偏差

原文：https://towardsdatascience.com/arrival-rate-bias-ab-testing-1-d291ae9d0cab?source=collection_archive---------2-----------------------

好事降临在那些迫不及待的人身上，第 1 部分

这篇文章与 艾伦·西罗利 合著，是我们关于 A/B 测试中到达率偏差校正的两部分系列文章中的第一篇。我们非常感谢我们的 财富前沿数据科学 同事 林秀吉 ，感谢他的宝贵投入。第二部分可以在这里找到。

“people walking on sidewalk” by rawkkim on Unsplash

像许多科技公司一样， Wealthfront 利用产品内测试和实验来学习和决策。特别是，我们利用现有客户群的产品内 A/B 测试来了解产品决策如何导致行为变化。然而，我们的产品和业务有一些特点，使得进行这些实验和从实验结果中做出有效的推论变得复杂。例如，在客户端级别而不是会话级别测量效果，需要小心。与治疗同时显现相反，效果的测量可能需要天或数周才能实现。最后，现有客户的产品内测试所特有的一个挑战来自于产品使用率的异质性所导致的遵从偏差。这种现象，我们称之为“到达率偏差”，是我们接下来两篇文章的主题。在第 1 部分中，我们涵盖了以下几个部分:

定义问题
实施到达率
展示这种偏见在真实实验中是如何体现的
介绍潜在的解决方案

在第 2 部分中，我们将更深入地探讨我们实现的解决方案的细节，并讨论其对功耗计算的影响。

问题是

作为随机对照试验(RCT)的一种形式，A/B 检验要求观察值随机抽样。虽然这个相当明显的要求很容易解释，但在实践中实现起来可能比预期的要困难。例如，很难简单地确保观察结果在对照组和治疗组之间随机分割。当在移动设备上进行 A/B 测试时，这可能特别具有挑战性，在这种情况下，治疗组(而非对照组)的用户需要升级他们的应用程序，以暴露于一种变体。然而，在随机分配之前的样本选择过程中引入的偏差似乎没有得到足够的重视。

桶装

当运行产品内 A/B 测试时，我们首先将所有现有客户随机“分配”到对照组或治疗组。原则上，这种随机分配应该给我们一个平均治疗效果(ATE) 的无偏估计。然而，直到客户实际登录网络或移动设备时，他们才“进入”给定的实验。我们对分桶客户的样本进行推断，以避免因未曝光而稀释测量的效应大小。然而，这种机制在我们的聚合实验样本中引入了偏差，因为登录越频繁的客户端越有可能被淘汰。因此，平均而言，这些客户在我们的样本中被过度代表，并且更早进入实验。此外，如果客户“到达”财富前线的倾向与他们对我们实验的反应倾向相关，那么在我们测量的 ATE 中可能存在选择偏差。例如，如果年轻客户(根据生物年龄)比年长客户登录更频繁，并且如果这一年轻群体更有可能对我们对 UI 所做的更改做出积极响应，那么我们可能会看到年龄混淆因素引入的偏差。

我们有证据表明这种事情可能正在发生。我们的财务规划团队最近进行了一项实验，以更清楚地推销我们的家庭规划功能。这项测试的目的是，看看我们是否能够增加制定家居规划目标的客户比例，同时避免对其他指标(如保留率和参与度)产生任何负面影响。使用我们的内部 A/B 测试平台，它提供了对存储和处理效果的实时监控，我们观察到了这样的 ATE 时间序列:

Lift Decay in an experiment with Arrival Rate Bias

这个问题可能存在于任何在用户层面衡量效果大小的公司，但到达率偏差对 Wealthfront 来说尤其严重，原因有三。最重要的是，我们的客户在到达率方面表现出显著的异质性:许多客户每月或每季度登录一次进行检查，而其他客户则每天登录并更加关注他们的投资组合。此外，与其他数字产品相比，我们的客户登录的频率相对较低(可能是按照我们的建议“设置好就忘了”。最后，由于我们经常测量在数周或更长时间内实现的治疗效果，我们的客户到达率分布的性质所导致的问题变得更加严重。例如，401(k)账户展期并不是客户完全可以在应用程序中完成的事情，一旦这个过程开始，可能需要几周才能完成。我们的投资组合信用额度功能通常被客户用来满足大量但不常见的流动性需求，这意味着我们对他们使用的任何影响都不会很快得到衡量。

到达率

为了研究未观察到的到达倾向和它对我们的实验推论的影响之间的关系，我们定义了一个事前观察到的度量，它可以预测客户的事后到达时间(X)。这些“到达率”可以从客户在给定实验开始之前的最近会话历史来估计。参照泊松过程的速率参数，我们将到达速率度量表示为λ(λ)。该参数的无偏估计是从用户在实验开始前的倒数第二次会话开始的时间的倒数( T )(其中 S_k 是第 k 次到最后一次会话的时间):

这个定义具有连续的优点。考虑的会话数量很少，足以有效地代表客户端的瞬时到达率，我们知道这很重要，因为我们有证据表明到达率是随时间变化的。重要的是， λ_i 的这些启发式计算仅利用实验开始之前的用户会话历史，而不是分桶时间之前的用户会话历史。这是有意的，因为在声明两者之间的关系时， λ_i 和直到分桶的时间应该是独立的。

Frequent arrivers are more likely to be bucketed

上面的图表明，通过证明 λ 与我们在家庭规划实验中遇到的客户比例正相关且单调相关，事前估计的 λ 可以准确捕捉事后到达倾向。最后，当我们比较加入实验的客户和没有加入实验的客户的到达率分布时，很明显存在有意义的选择效应。

Bucketed users have higher arrival rates

量化到达率偏差

到达率偏差的第二个必要条件是作为 λ 的函数的差分效应大小。如果频繁的到达者和不频繁的到达者一样有可能改变他们的行为来回应我们的实验，那么我们没有什么可担心的。但是如果它们的反应不同，那么 ATE 可能会有偏差。在我们的家庭计划实验中，我们可以使用逻辑回归来估计治疗效果的异质性:

其中如果客户在治疗组中，Z 等于 1，否则等于 0。我们之所以选择这种形式，是因为我们的实验测量了创建家庭规划目标的客户的比例。如果我们绘制治疗组和对照组的反应函数，我们会看到异质性的证据:

We observe heterogeneous treatment effects in lambda

对此的一种解释是, λ 与可观察指标——任期、年龄、净资产、收入——相关，而这些与客户行为更直接相关。事实上，我们知道情况是这样的。此外，治疗组中的高- λ 客户在遭遇挫折后有更多的机会采取行动，因为他们更频繁地接触我们的治疗。

为了估计本例中到达率偏差的严重程度，我们可以使用模型的预测值来计算 ate，该模型的预测值是从 λ 的总体分布中采样的值。预测的反事实平均值的标准误差是自举的。我们观察到，分桶客户样本下的 ATE 与观察到的平均效应大小相匹配，这让我们对模型的准确性充满信心。客户群体的预测效应大小较低，这与上述反应图中效应大小的增加和本文第一个图中 ATE 的减少是一致的。

Under our model, the population effect size is below the that of the experiment

一个简单的层次模型

我们可以进一步探索到达率偏差的严重程度如何随着收集的样本分数而变化。在这一点上，写下一个简单的层次模型是有益的。假设每个客户的到达率来自某种分布 F_λ ，他们的首次到达时间 X_i 来自指数分布(泊松假设):

目测表明 LogNormal(μ，σ)是 F_ λ 的合理参数化。下图显示了我们的家庭规划实验中 λ 的经验总体分布的最大似然拟合:

A lognormal model captures the empirical population distribution of λ

然后，我们将 K 定义为随机分配给我们的实验的客户端数量， N 定义为到达并被分桶的累计数量，R:=N/K定义为在给定时间分桶的已分配客户端的比例。使用拟合的分布，我们可以很容易地计算基于 R 的到达偏差分布。在有偏分布 H_λ ( λ 上对估计的效应函数τ(λ)进行积分； R )，我们可以估计 R 的任何值的相对偏差 B ( R )，而不仅仅是实现的 R* (实际进入实验的客户比例)。下面我们画出相对偏差

作为我们家庭规划实验的功能。注意，当 R 接近 1 时，偏差接近 0。我们看到，对这些实验估算升力的天真解释会产生明显有偏差的推论。

Significant bias remains even after nearly half of the eligible clients arrive

潜在的解决方案

我们考虑到达率偏差问题的三种可能的解决方案。首先，用于量化上述偏差的回归方法可以通过控制混杂变量来进行修正。然而，这只能控制可观察的，而我们下面研究的方法也允许我们控制不可观察的(因为我们知道分桶机制)。第二，我们随机预选要被包括在实验中的客户，并等待这些客户中的一部分到达现场。最后，我们对到达并加入到我们实验中的客户的回答进行重新加权，以近似我们整体客户群的分布。对于结合回归和倾向加权的“双重稳健”估计量，见本文。

预选

在一个没有时间限制的世界里，我们更愿意预先选择 K 个现有的客户，然后等待他们全部到达站点。这将在实验开始时给我们一个关于现有客户群的无偏见的样本。但是，如前所述，这 K 个客户需要几个月才能到达，我们需要在更短的时间内进行因果推断。

一种解决方法是通过测量到达的前 N 个客户端的影响大小来权衡时间偏差。认识到我们估计的偏差随着 R 的增加而下降，可以让我们做出明智的决定:我们愿意接受多大的偏差，以及这是否允许我们在分配给实验的时间内收集我们需要的样本。例如，我们可能随机抽取 K = 20，000 个客户端，并等待其中第一个 N = 15，000 个客户端被存储(R = .75)。这个 R 意味着一定量的预期偏差，可以简单地通过增加 R 来减小该偏差。这种方法的好处在于，等待第 N 个客户端到达的时间仅取决于 R，而不单独取决于 N 或 K。

上一节中介绍的我们的住宅规划实验的相对偏差图显示，我们实际收集的样本数量意味着大约 20%的相对偏差——超过了我们可以容忍的程度。我们本可以等待更多样本的到来，但是 R 越接近 1，采集样本的时间就越长。考虑到我们的客户每月、每季度甚至更少登录，这是不可行的。此外，预选不适于实时监控，因为它仅在 R 接近 1 时收敛到正确的答案，而我们希望在每个时间步长对 ate 进行无偏估计。幸运的是，这是我们解决问题的下一个方法的特征。

反向倾向加权

加权采样是解决到达率偏差问题的另一种可能的解决方案。在因果推理文献中可以找到对样本重新加权的各种方法。这些重新加权的方法允许在选择可观察物的情况下进行稳健和灵活的因果建模，但是，如前所述，它们不能消除由于未观察到的混杂而产生的偏差。然而，我们对分桶机制的了解允许我们直接控制这些未观察到的因素。

我们实施的具体方法被称为反向倾向加权(IPW)。我们减持了高到达率的客户(那些极有可能被炒股的客户)，增持了低到达率的客户。通过选择适当的权重，我们可以对进行采样，就好像来自的无偏分布。为了说明这一点，让我们回顾一下前面描述的层次模型。假设λ的总体分布具有密度 f_λ(λ)，到达时间 X 的边际分布具有分布 G_X(x)。则λ的到达有偏分布具有某个密度 h_(λ|X≤Z)(λ)，其中 Z := G_X^-1(R)(使用 X_(N)的渐近论证，第 N 次跳跃/到达的时间)。我们想要一个将 h 转换成 f 的权重函数:

这恰恰是似然比 f _λ(λ)/h _(λ| X≤Z)(λ；r)。一个更有用的表达是:

其中分母表示到达速率为λ_i 的客户端在收集到 R = N / K 个样本时将被分桶的概率。一点数学表明，这个表达式等价于似然比:

直觉上，对于可能被淘汰的客户来说，权重较小(因为他们的到达率很高，在我们的样本中他们的比例更高)，而对于不太可能被淘汰的客户来说，权重较大。事实上，倾向是 R 的函数，这意味着权重为我们提供了收集的任意数量样本的 ate 的无偏估计，这是我们实时监控设置所需的一个关键属性。

后续步骤

虽然它解决了我们最初的问题，但是 IPW 引入了一个折衷。也就是说，虽然我们可以恢复 ate 的无偏估计，但是估计量的方差被权重放大。这意味着对于一个给定的实验，我们需要更大的样本量来达到一些设定的统计功效目标。一个需要回答的关键问题是“大多少？”在这篇文章的第二部分，我们将提供一个解决方案，并记录 IPW 校正对模拟和实际实验的影响。

机器学习时代的艺术鉴赏

原文：https://towardsdatascience.com/art-connoisseurship-in-the-age-of-machine-learning-d72e8a3716df?source=collection_archive---------5-----------------------

作为一名数据科学新手，我对真正的数据科学家如何解决现实世界的问题很感兴趣。阅读了许多张贴在 Kaggles 上的挑战，我在寻找这些专家如何应对有趣比赛的见解。一个让我吃惊的挑战是“数字画家”挑战。它要求参赛者开发一个程序，可以识别同一位艺术家的画作。

Left: “The Lacemaker”, van Meegeren, 1925, courtesy of the National Gallery of Art, Washington D.C.. Right: “Lady Reading Music”, van Meegeren, 1936, courtesy of the Rijksmuseum, Amsterdam.

几行代码怎么能开发出和专家一样的‘眼力’呢？作为一个自称艺术史爱好者，我对此表示怀疑！如果我很难通过一个关于赝品的 Buzzfeed 测试，那么计算机如何能在识别赝品方面做得更好？

专家们训练了多年来寻找艺术家的手留下的唯一标识符。这些专家用他们的眼睛，他们的直觉，通常还有大量的科学来鉴定艺术品和赝品。那么，计算机能代替他们的专业知识吗？一个算法能告诉我们两幅画是不是同一个笔刷画的吗？

首先也是最重要的一点是，为什么电脑能区分两幅画很重要？艺术品市场不受监管、不透明且不正规，这使得它容易受到各种层面的操纵，尤其是伪造。2017 年的总销售额不到 640 亿英镑，艺术品的买卖是一项大生意。艺术市场总是依赖专家和可疑的鉴赏科学来确认作品的真实性。艺术品伪造诉讼价格昂贵，伪造艺术品多年来一直是困扰博物馆和收藏家的问题，随着人工智能的进步，检测赝品变得更加可扩展和负担得起。

回到“数字画师”，挑战包括 79，433 个实例，训练集中有 1，584 个独特的画师，需要对大约 2200 万对测试集进行预测。这项挑战的获胜者 Nejc Ilenic 首先通过清理他的数据集来完成这项任务，在这种情况下，是艺术品图像，然后他创建了一个模型，提取画家的独特风格，并教会机器学习与艺术家类别相关的这些特征。最后，为了测试他的模型，他使用了一种算法来可视化数据，以比较这些测试集对的输入实例有多相似。

下图所示的两个散点图，提供了 Nejc 的程序如何能够区分不同的艺术风格和同一艺术家的群体作品的可视化，即使模型在训练阶段没有看到这些作品的例子。

就个人而言，挑战中最有趣的部分是机器能够多好地识别约翰内斯·维米尔和韩·范·米格伦作品之间的差异。如下图所示，这两位艺术家作品的相似之处，外行人几乎难以分辨。韩·范·米格伦伪造弗米尔的画作是最富传奇色彩的艺术仿冒故事之一，他出售二战前荷兰画作的仿制品，赚了 3000 万美元(经通货膨胀调整后)。尽管范·米格伦用这位 17 世纪荷兰大师的赝品骗过了许多专家，但他没能骗过电脑。因为维梅尔的画与他的其他作品更相似，而范·米格伦从几个不同的艺术家那里复制了他的风格，所以 Nejc 的程序能够识别范·米格伦数据集中的不一致，并从范·米格伦的作品中识别维梅尔的作品。

Left: Woman reading a letter, Johannes Vermeer, 1662–1663, courtesy of the Rijksmuseum, Amsterdam. Right: Woman Reading Music, by Han van Meegeren, 1935–1936, Rijksmuseum, Amsterdam

在阅读了《数字画家》(Painter by Numbers)之后，我对技术如何能够识别赝品产生了兴趣，于是我扩大了研究范围，看看是否有任何创新的方法可以在艺术领域利用数据科学。谢天谢地，谷歌没有让人失望。我发现了一篇由罗格斯大学和荷兰绘画修复与研究工作室的研究人员撰写的论文，题目是“毕加索、马蒂斯还是赝品？
笔画级别的图纸自动分析，用于属性和认证这项研究发表了名为递归神经网络 (RNN)的人工智能如何通过比较构成图像的笔画来发现伪造艺术品的发现。通过将画作分解成一行行的笔触，RNN 学会了这些笔触的特征，这些特征对于识别艺术家非常重要。同时，一个机器学习算法被训练来寻找这些特征，如每一笔的线条粗细，以识别艺术家。人工智能和机器学习的结合方法协同工作，使研究人员能够在 80%的情况下识别图像的艺术家。

Examples of segmentation results. Schiele ink drawing. — best seen in color

为了测试系统识别假货的能力，研究人员还委托艺术家创作与数据集中的作品风格相同的画作。该系统能够识别每一个实例中的伪造品，只需查看一个笔画，如下例所示。

From page 7 of ‘Picasso, Matisse, or a Fake? Automated Analysis of Drawings at the Stroke Level for Attribution and Authentication,’. Examples of fake dataset mixed with real drawings. Key: Fake, Fake, Matisse Matisse, Fake, Fake, Matisse Fake, Matisse, Picasso, Fake Fake, Picasso, Picasso, Fake Schiele, Fake, Fake, Schiele, Schiele, Fake

艺术史是一个有着几个世纪传统的领域；然而，随着人工智能的许多令人兴奋的进步，我很兴奋地看到这项技术将如何在美术世界中实现。“这台机器比人眼有优势，因为它可以分析成千上万的单个中风，并从统计上描述它们的特征，”进行这项研究的科学家之一艾哈迈德·埃尔加马尔说。“如果我们训练机器根据艺术家有意或无意渲染的特征来识别风格，我们将能够检测出赝品。”

想一想这个:一个可以在线条和笔触中检测出艺术家潜意识的算法。祝你好运，范·米格伦先生！

能够向该领域的专家学习解决问题的过程是很有见地的。阅读数据科学家如何应对现实世界的挑战，让我看到了我每天学习的课程如何与数据科学和机器学习领域正在发生的事情的更大图景相关联。

监督模型中选择指标的艺术第 1 部分

原文：https://towardsdatascience.com/art-of-choosing-metrics-in-supervised-models-part-1-f960ae46902e?source=collection_archive---------5-----------------------

评估结果可能是每项研究中最重要的部分，因为它展示了你有多准确，你离你的目标有多近。因此，选择合适的性能指标对每个人来说都是一项具有挑战性的研究。

与其他科学领域相比，在机器学习问题中，选择正确的评估指标是一件棘手的事情。在这篇文章中，我将描述监督学习中常用的评估指标。

监督学习已经被广泛应用于机器学习问题中。当你有数据标签时，这是第一选择。就数据类型而言，监督学习分为两类:回归问题和分类问题。您的数据会直接影响您对一系列评估方法的选择。如果数据是离散的，那么预测方法应该从分类方法中选择；反之，如果数据是连续的，回归方法可能适合数据。因此，在监督模型中，无论数据是离散的还是连续的，我们的选择都变得不同；例如，在回归方法中，人们通常使用像平均绝对误差和均方根误差这样的指标。精确度、召回率、F1 值和准确度是分类中经常使用的一些度量。

在本文的剩余部分，我将描述和比较两个最常见的持续评估度量，然后将研究它们的应用。

1- MAE(平均绝对误差):

MAE 是用于计算误差的最常见的指标之一。它衡量应用于连续变量的模型的性能。所以为了计算 MAE，我们首先应该知道这里的误差是什么意思。误差是模型的预测误差:

Residual or Prediction Error

我们应该为每一行数据计算这个值，然后取它们的绝对值，最后计算所有绝对预测误差的平均值。MAE 的公式是:

MAE Formula

如果我们画一个回归问题的散点图，MAE 就是预测值(回归线上的值)和实际值之间的垂直距离。

Scatter Plot of Samples and Errors

在上图中，垂直黑线表示误差值，MAE 是它们绝对值的平均值。因此，我们应该记住，MAE 不考虑数据的方向，也是线性得分，这意味着所有单个误差(垂直线)在平均值中的权重相等。

2- RMSE(均方根误差):

除了 MAE 之外，均方根误差(RMSE)是另一种常用于回归问题的测量方法，它可以告诉您模型的表现如何。和梅一样，这里预测误差是 RMSE 公式的最重要部分。

RMSE Formula

该指标显示了误差项的合理大小，如果我们尝试用另一种方式来说，它就是预测误差或残差的标准偏差(它很好地显示了大量偏差)。显然，这种方法向我们展示了数据是如何集中在回归问题的最佳拟合线上的。

RMSE 和梅都关注预测误差，但都不考虑误差的方向。然而，它们之间存在一些差异；最显著的区别是，RMSE 在第一步中取残差的平方，然后取它们的平均值。这意味着它为较大的预测误差分配更多的权重，尽管 MAE 认为所有残差的权重相同；所以我们可以看到 RMSE 证明了预测误差的标准差，换句话说，RMSE 与误差频率分布的方差直接相关。

所以我知道每一个的定义，但是当选择哪个的时候呢？

嗯，你想听我的意见，我会说我们可以很容易地回答这个问题，让我们用一个例子来深入探讨。

Table of Example

正如你在上面的表格中看到的，有三个案例，我们的目的是调查梅和 RMSE。在第一行中，一切看起来正常，并且已经计算出了 MAE 和 RMSE 的值，然而，在第二行中，最后一个误差离其他误差太远(这可能意味着最后一个样本是异常值),并且如给定表格中所示，RMSE 的值比 MAE 大得多。最后在最后一行，我们发现所有的误差都相等，当然 RMSE 的值不会大于平均误差。

那么在前面的例子中发生了什么呢？

正如我们之前提到的，RMSE 认为更大的错误有更大的权重，这意味着它对更大的错误的惩罚比 MAE 更多，正如我们在表中可以发现的那样，当我们比较表中前两行的这两个指标的值时，我们清楚地看到 RMSE 比 MAE 对大错误有更严格的行为，也就是说，它告诉我们 RMSE 对样本的错误分布很敏感。如果我们比较最后两列，我们会看到 RMSE 的值总是大于或等于梅的值，只有当所有残差都相等(或为零)时，这些值才相等。

比较和对比:

这两个指标本质上是相同的。它们中的每一个都应用于连续数据，并且都使用预测误差，但是它们以不同的方式表现预测误差。RMSE 采用误差平方，这使得它对误差分布中的异常值敏感，并且也使得该度量成为误差分布的良好表示。我们可以说它是正态分布样本的合适度量。T. Chai 和 R. Draxler 在 2014 年的出色研究中证明，随着样本数量超过 100，RMSE 可以重建误差分布。RMSE 相对于 MAE 的首要优势可能是，RMSE 不使用绝对误差，这在我们旨在最小化成本函数或优化模型性能时是非常不可取的，因为 RMSE 使用平方误差，我们可以出于上述目的计算它们的梯度，但是，当我们使用 MAE 时，计算绝对误差的梯度变得很困难。因此，在计算模型误差敏感性或数据同化的情况下，RMSE 绝对优于 MAE。相反，当我们想要识别不同模型之间的区别或区分模型时，MAE 工作得更好，因为 MAE 不能被大量的错误充分地反映出来，相反，正如我们在前面说过的，RMSE 赋予它们更多的权重。

结论:

RMSE 和 MAE 是连续数据的评估指标，通常用于回归问题。这些指标各有利弊，通常没有一个是赢家，因为它很大程度上取决于你试图解决的问题和你的目标是什么。值得注意的是，有一件事我们应该记住:据我所知，仅使用一个评估指标可能无法完全衡量您的模型的性能，通常最好使用多个指标并将结果放在一起比较，以获得更好的洞察力。

嗯，我想这差不多就是这些度量标准的差异和相似之处，它们经常被用在回归问题中。我将感谢你花时间阅读这篇文章。在下一篇文章中，我将描述分类问题中常见的评估指标。同时，我期待着听到你的评论。

参考资料:

https://www . researchgate . net/publication/272024186 _ Root _ mean _ square _ error _ RMSE _ or _ mean _ absolute _ error _ MAE-_ Arguments _ against _ avoiding _ RMSE _ in _ the _ literature

[## 均方根误差

均方根误差

皇家 Errorstatweb.stanford.edu 号](http://statweb.stanford.edu/~susan/courses/s60/split/node60.html) [## RMSE:均方根误差

回归分析> RMSE:均方根误差均方根误差(RMSE)是…

www.statisticshowto.com](http://www.statisticshowto.com/rmse/) [## 绝对误差和平均绝对误差

测量误差>绝对误差绝对误差是测量中的误差量。这就是区别…

www.statisticshowto.com](http://www.statisticshowto.com/absolute-error/) [## 平均绝对误差-维基百科

在统计学中，平均绝对误差(MAE)是两个连续变量之间差异的度量。假设 X 和 Y…

en.wikipedia.org](https://en.wikipedia.org/wiki/Mean_absolute_error)

生成对抗网络(GAN)-人工智能-“猫和老鼠的游戏”

原文：https://towardsdatascience.com/art-of-generative-adversarial-networks-gan-62e96a21bc35?source=collection_archive---------9-----------------------

Art of Generative Adversarial Networks

帖子中提到的所有作品的代码链接:-

[## pankajkishore/代码

在 GitHub 上创建一个帐户，为 pankajkishore/代码开发做出贡献。

github.com](https://github.com/pankajkishore/Code)

我们有幸参与了商业数据科学课程的最终项目“生成对抗网络”项目。虽然我们可以选择任何其他主题作为我们的最终项目，但我们继续挑战训练 GAN 从由 880 张大小为 28*28 的 X 射线图像组成的数据集学习生成 X 射线图像。该项目由 Pankaj Kishore、Jitender 和 Karthik 完成。我们最初的想法是探索 GAN，并在此过程中使用 Tensorflow 编写我们自己的代码来训练 GAN 生成 X 射线图像。我将简要介绍一下我们项目的旅程。

数据收集

第一步是为鉴别器收集足够数量的训练数据集来训练我们的神经网络。我们从下面提到的网站中提取数据:-

[## 箱子

编辑描述

nihcc.app.box.com](https://nihcc.app.box.com/v/ChestXray-NIHCC/folder/37178474737)

一旦我们有了足够数量的数据，我们就尝试使用 GAN 进行探索，并对现有数据集实施 GAN，以学习并在我们的数据集上应用相同的实施技术。

初学

1.MNIST 数据集

我们首先通过 MNIST 数据集进行了探索，并找到了足够的在线资源来在 MNIST 数据集上训练我们的第一个 GAN 模型，这被认为是最容易训练的。事实证明，当我们探索代码并理解 GAN 背后的基本原理时，训练它确实非常容易，而且是一种很好的学习体验。我们在 MNIST 数据集上尝试了 GAN 的许多变体。我们尝试的各种变化如下:

香草甘

条件 GAN

瓦瑟斯坦·甘

DCGAN

VAE

我们获得的结果质量非常好，我们只需稍微调整一下代码就能达到这个结果。我们有趣地发现，为生成器添加更多的隐藏层对图像质量没有影响。我们也尝试了变分自动编码器(VAE)，从下面的链接引用 Ashish Bora 的代码，得到了足够好的结果。

DCGAN

VAE generated Image

MNIST at different Epochs through VAE

[## AshishBora/csgm

复制论文结果的代码:“使用生成模型的压缩感知”。- AshishBora/csgm

github.com](https://github.com/AshishBora/csgm)

2。时尚 MNIST

我们在时尚 MNIST 数据集上尝试了 MNIST 的相同变化，并且成功地能够为不同的分类器项目生成图像。这导致我们的兴趣转向更大的魔鬼，那就是为 X 射线图像编写我们自己的代码，看看我们是否能为我们的图像编写同样的代码。我们从深入了解甘开始，并乐于分享在整个旅程中学到的几个关键概念。适合我们的架构如下

为时尚 MNIST 代码生成的图像:-

99000 epochs

60000 epochs

40000 epochs

Fashion MNIST GIF at different epochs

生成性对抗网络概述

除非你在过去一年左右的时间里一直住在小屋下，否则深度学习领域的每个人——甚至一些没有参与深度学习的人——都听过并谈论过 GANs。GANs 或生成对抗网络是深度神经网络，是数据的生成模型。这意味着，给定一组训练数据，GANs 可以学习估计数据的潜在概率分布。这非常有用，因为除了其他事情之外，我们现在可以从学习到的概率分布中生成样本，这些样本可能不存在于原始训练集中。

生成对抗网络实际上是两个相互竞争的深层网络。给定一个训练集(比如几千张猫的图像)，生成器网络【G(X)，将一个随机向量作为输入，并尝试生成与训练集中的图像相似的图像。鉴别器网络 D(x) 是一个二元分类器，它试图根据训练集 X 来区分真正的猫图像和生成器生成的假猫图像。因此，生成器网络的工作是学习数据在 X 中的分布，以便它可以产生真实的猫图像，并确保鉴别器不能区分来自训练集的猫图像和来自生成器的猫图像。鉴别者需要学习跟上生成器，不断尝试新的技巧来生成假的猫图像并愚弄鉴别者。

最终，如果一切顺利，生成器(或多或少)会了解训练数据的真实分布，并变得非常擅长生成真实的猫图像。鉴别器不再能够区分训练集 cat 图像和生成的 cat 图像。

从这个意义上说，这两个网络不断地试图确保对方没有很好地完成他们的任务。那么，这到底是怎么回事呢？

另一种看待 GAN 设置的方式是，鉴别器试图通过告诉发生器真实的猫图像是什么样子来引导它。最终，生成器发现了它，并开始生成看起来真实的猫图像。训练 GANs 的方法类似于博弈论中的最小最大算法，两个网络试图实现所谓的相对于彼此的纳什均衡。

发生器和鉴别器之间发生的事情这里是一个 2 人零和游戏 。换句话说，在每一步中，生成器试图最大化鉴别器对图像进行错误分类的机会，而鉴别器反过来试图最大化其对输入图像进行正确分类的机会。

A simple flowchart of a GAN

Discriminator

Generator

一旦我们学会了这些课程，我们就开始动手实践并写出我们自己对所学概念的实现。

网络背后的数学

深度学习或机器学习都是关于优化函数或者特别是最小化算法的损失。我们用梯度下降来实现。

假设 X 是我们的真实数据集，Z 是正态分布噪声。设 p(z) 为来自潜在空间 z 的数据 G 和 D 分别为生成网络和判别网络的可微函数。 D(x) 表示数据来自真实数据集 x 的概率，我们训练 D 使概率 log(D(x)) 最大化，训练 G 使 log(1 — D(G(z))最小化。简而言之，它们彼此进行如上所述的最小最大博弈，并获得全局最优。

GAN ( Loss function )

上述功能为我们的生成性对抗网络提供了损失功能。现在，需要注意的是log(1-D(G(z))*会饱和，所以我们不会最小化它，而是最大化 log(D(G(z))。*

为了证明生成网络生成的样本与 X 完全相同，我们需要在数学上更深入，使用 Kullback-Leibler 散度定理和 Jensen-Shannon 散度。

使用的来源:-

* [## 生成对抗网络-简单介绍。

现在人们对深度学习的研究如此热情。这样的结果，每天或每月都有一个新的…

medium.com](https://medium.com/@rajatgupta310198/generative-adversarial-networks-a-simple-introduction-4fd576ab14a)

生成 X 射线图像:-

问题陈述:-

重要特征的高质量描绘是用于疾病的精确诊断和/或评估的生物医学图像解释中的关键组成部分。通过利用大量的训练图像，基于卷积神经网络(CNN)的深度学习(DL)技术已经被证明在图像分类和分割任务中非常成功，在生物医学图像解释中潜在地承诺更高的吞吐量和更一致的结果。由 DL 增强的计算机化工具被迅速证明是提高生物医学图像解释准确性的最先进的解决方案。此外，研究人员已经报告了生成对抗网络(GAN)模型的成功训练，以生成合成训练图像，作为解决训练集稀缺的潜在解决方案。

下图显示了 GAN 网络的基本概念。在图片中，生成器试图产生合成图像来欺骗鉴别器，而鉴别器试图将合成图像与真实图像区分开来。

General GAN architecture

当前的挑战

为深度学习训练 CNN 通常需要大量标记的训练图像数据，由于专家标注的费用，这在生物医学领域仍然是一个挑战。虽然研究人员已经报告了生成对抗网络(GAN)模型的成功训练，以生成合成图像作为解决训练集瓶颈的潜在解决方案，但是及时训练 CNN 和 GAN 可能需要领域专家的编程经验和技能集。我们的目标是为最终用户提供一个简化的工作流程，以促进快速利用 GAN 网络为 DL 培训制作合成放射学图像

提出的解决方案

我们尝试实现 GAN 来生成 X 射线图像，并开始为生成器和鉴别器创建简单的函数。我们最初为鉴别器和生成器设计了三层。使用的激活函数是发生器的泄漏 relu 和鉴别器的 relu。使用 glorot_init 函数将随机噪声也输入到真实图像中。我们通过使用批量标准化调整和缩放激活来标准化输入层。

鉴别器和发生器的损失函数如下

损失函数

disc _ loss = TF . reduce _ mean(TF . nn . sigmoid _ cross _ entropy _ with _ logits(logits = r _ logits，labels = TF . ones _ like(r _ logits))+TF . nn . sigmoid _ cross _ entropy _ with _ logits(logits = f _ logits，labels=tf.zeros_like(f_logits))

gen _ loss = TF . reduce _ mean(TF . nn . sigmoid _ cross _ entropy _ with _ logits(logits = f _ logits，labels=tf.ones_like(f_logits)))

鉴别器和生成器的步距和学习步骤如下

gen _ step = TF . train . rmspropoptimizer(learning _ rate = 0.001)。最小化(gen_loss，var_list=gen_vars) # G 训练步骤

disc _ step = TF . train . rmspropoptimizer(learning _ rate = 0.001)。最小化(disc_loss，var_list=disc_vars) # G 训练步骤

我们编写了一个简单的函数来产生随机噪声(假图像),并将其与真实图像一起提供给鉴别器。使用的时期是 1000，我们第一次训练神经网络的样本数是 851，下一次是 5000 个样本(下采样数据集)。我们得到的输出图像真的是噪音，我们意识到了错误，为什么我们没有得到正确的输出。来自我们代码的图像截图:-

Input Images to Discriminator

Output Image generated

导致发电机实际上什么也没学到的潜在原因有很多，仅举几个例子

输入鉴别器的低分辨率质量图像

将实际的 12401240 图像下采样为 2828

没有足够的数据集供神经网络学习

梯度下降消失问题，因为鉴别器太成功了，以至于发生器梯度消失并且什么也没学到

模式崩溃:发生器崩溃，产生有限数量的样本

我们尝试的越多，从上面的样本中产生的空白越多，输出就越好。即使经过无数次尝试，我们也无法从 GAN 中生成高质量的图像，因为我们拥有的数据集存在局限性。

口袋妖怪一代

在尝试从 NIH 网站创建 X 射线图像失败后，我们想到尝试我们的代码来生成口袋妖怪，以确保这可能是一个数据集问题。不幸的是，我们取得了不错的成绩，但不是很好。下面是从我们的 X 射线代码生成的口袋妖怪

Pokemon’s from X-ray code

肯定比 x 光图像好。然后，我们试着运行由一个流行的机器学习程序 Youtuber Siraj Raval 创建的代码(这是他从 moxiegushi 借来的)。

[## llSourcell/口袋妖怪 _GAN

Pokemon _ GAN——这是 Siraj Raval 在 Youtube 上发布的“用一个生成对抗网络生成 Pokemon”的代码

github.com](https://github.com/llSourcell/Pokemon_GAN)

代码需要稍微修改，以适应从 Kaggle 网站收集的 851 个口袋妖怪的更高级的数据集。代码被修改，以处理更高分辨率的口袋妖怪以及训练鉴别器。结果是惊人的，尽管它需要很多时间来运行。代码的架构如下

Architecture for Pokemon

关于鉴别器

在DCGAN架构中，鉴别器D是卷积神经网络(CNN)，它应用许多过滤器从图像中提取各种特征。鉴别器网络将被训练以区分原始图像和生成的图像。卷积的过程如下图所示:

关于发电机

被训练来生成图像以欺骗鉴别器的生成器 G 被训练来从随机输入生成图像。在 DCGAN 架构中，发生器由对输入进行上采样的卷积网络表示。目标是处理小的输入，并产生大于输入的输出。它的工作原理是将输入扩展到中间为零，然后在这个扩展区域上进行卷积处理。该区域上的卷积将导致下一层的更大输入。向上采样的过程如下所示:

根据不同的来源，您可以找到上采样过程的各种注释。有时它们被称为全卷积、网络内上采样、分数步长卷积、反卷积等等。

发电机网络结构概述

DCGAN 超参数

每个人都注意到的一件事是，GANs 的计算成本非常高。人们通常忽略的是 GANs 相对于超参数是多么脆弱。gan 在某些参数下工作得非常好，但在其他参数下则不然。目前，调谐这些旋钮是网络架构设计艺术的一部分。我们决定采用的超参数如下:

超参数

64 件的小批量

重量从标准= 0.02 升的正态分布初始化

Relu 斜率= 0.2

学习率= 0.0002 的 Adam 优化器

动量= 0.5

结果

鉴于有限的时间和相关的成本，我们没有完全训练我们的模型，但口袋妖怪产生了 1300 个时代，我在下面附上:-

Pokemon after 1300 epochs

Pokemon Generation for incremental Epochs

项目的主要收获:-

在这个项目上工作是一次很棒的经历，尽管它真的很有挑战性，但它打开了我们的视野，让我们看到了神奇神经网络可以提供的所有新的可能性。我们从错误中学到了很多，并意识到我们需要做的可能的修改，以使 GAN 为我们的 X 射线图像数据集工作。关键要点是

训练一只甘真的很难

为了获得更好的结果，我们需要结合其他因素进行批量标准化。

需要注意梯度下降和损失值，以确保没有发生器或鉴别器达到零值

Relu 激活功能是真正的朋友。

需要实施卷积网络，它们确实适用于大多数数据集，如果不是所有数据集的话

我们需要 GPU 来训练 GAN，除非你能等上几年，否则在 CPU 上训练是不可能的！！

未来前景:

我们可以尝试很多事情，首先尝试生成质量为 6464 的图像，而不是我们目前尝试生成的 256256，看看这是否能提高图像质量。我们肯定会继续研究 X 射线图像，并尝试实现卷积神经网络，看看我们是否能生成更好的图像。收集大约 100，000 幅图像的训练数据可能有助于更好地训练 CNN 模型，并可能大大提高生成器图像的质量。虽然这可能会变得更加棘手和困难，但如果 CNN 工作得更好，我们会喜欢实现更高分辨率图像或彩色图像的解决方案，看看 GAN 的表现如何。我们甚至想尝试 X 射线图像的变化编码器，看看是否有所帮助。我们甚至想尝试我们在网上找到的东西，比如:-

迷你批次辨别:让生成器在一个“迷你批次”中对多个图像进行分类，而不是只对一个图像进行分类

虚拟批次标准化:每个示例都基于参考批次的样本进行标准化

结论:

这个项目确实为我们可以用神经网络尝试的许多实现提供了动力。它确实吸引了所有人的注意，很难不欣赏甘可能带来的无限可能性。在这个项目中，我们在使用 Tensorflow 或 cloud 方面确实学到了很多。我们意识到实际训练一个 GAN 是多么困难，即使事情可能在一个数据集上工作，也不一定意味着它在另一个给定的数据集上会以同样的方式工作。GANs 的概念并不难理解(即理解生成性对抗网络)。但是实现它们以产生高质量的图像可能是棘手的。考虑到 GAN 的无限商机，我可以在未来陈述几个:-

GANS 可能用于:

监督学习:

根据{某些约束}尽可能准确地预测，例如公平性
不平衡分类中的数据扩充
离群点检测
向量-2-向量预测，例如具有任意损失的多标签预测，其不假设标签独立于特征的条件

半监督:

在现实生活的数据集中，经常会出现只有一小部分数据被标记的情况。

无人监督:

矩阵完成
嵌入

感谢大家的阅读！！希望你喜欢我们在 GAN 的天真尝试，我们真的希望继续工作，为任何数据集更新一些更棒的结果！！

帖子引用的其他链接:

https://Phil Paradis . WordPress . com/2017/04/24/training-gans-better-understanding-and-other-improved-techniques/

NIPS 2016 GAN 教程

有条件的甘*

文字的矢量表现艺术

原文：https://towardsdatascience.com/art-of-vector-representation-of-words-5e85c59fee5?source=collection_archive---------3-----------------------

用于表示语言词汇的符号的表达能力在语言学领域引起了极大的兴趣。实践中的语言都有语义歧义。

约翰吻了他的妻子，萨姆也吻了。

萨姆吻了约翰的妻子还是自己的妻子？为了以真实的形式表示信息，必须处理这些歧义。

那么，我们如何开发一个机器级别的语言建模任务的理解。经典的基于计数或基于相似性参数的方法在计算机科学中已经存在了相当长的时间。

但是，现在随着像 RNNs 这样的深度学习模型的出现，语言模型的这种表达能力对于创建有效的系统来存储信息和发现词汇术语之间的关系是非常有意义的。这将作为编码器-解码器模型(如序列到序列模型)中的基本块。

在这篇文章中，我们将探索不同的单词表示系统及其表达能力，从经典的 NLP 到现代的神经网络方法。最后，我们将以动手做编码练习和解释来结束。

对于读者来说，保持你的标记在 &上标记重要的点。这是一个相当长的阅读与一些小的数学涉及概念解释从零开始。

The fundamental understanding of language will be different for machines.

机器更善于理解实际文本作为标记传递的数字。这个将文本转换成数字的过程被称为矢量化。向量然后组合形成向量空间，向量空间本质上是连续的，是一个代数模型，其中应用了向量加法和相似性度量的规则。存在不同的矢量化方法，让我们从最原始的到最先进的。

本文将讨论的表示模型有:

1.一键表达

2.分布式表示

3.奇异值分解

4.连续词袋模型

5.跳格模型

6.手套表示

一个热门话题

为了定义一个系统的表征能力，我们首先要研究不同表征系统的工作方式。这些系统以向量的形式表示词汇表中的每个单词，并创建一个有限的向量空间。

让我们来看一个 一键式 表示单词的例子。每个单词用大小为|V|的大向量表示，即给定语料库的词汇大小。

The representation of the i-th word will have a 1 in the i-th position and a 0 in the remaining |V | − 1 positions.

这是一种非常简单的表示形式，很容易实现。但是，即使从这样的小例子中，许多错误也会变得很明显。比如存储和处理这些向量需要巨大的内存。由于这些向量的稀疏性。比如|V|的大小就像 Google 1T 语料库的 3M 一样非常大。这种符号在由该系统的表示能力引起的计算开销方面将会失败。

此外，没有相似性的概念被捕获。余弦相似度 b/w 唯一字为零，欧几里德距离总是 sqrt(2)。意思是，没有语义信息被这个表达系统表达出来。

现在，很明显，我们应该转向一种既能节省空间又能保留一些语义能力来表达单词间关系的表示法。让我们看一个基于相似性的表示。

从一个人交的朋友，你就可以知道这个人说的话

—弗斯，J.R

单词的分布式表示

其思想是量化语料库中术语的共现。这种共现是用词周围的窗口大小“k”来测量的，这表示上下文以该窗口大小分布。考虑到这种方法，创建了一个 术语×术语的共现矩阵，该矩阵捕获一个术语在另一个术语的上下文中出现的次数。此外，删除停用词也是一个很好的做法，因为这些是高频词，提供的有意义的信息最少。同样，我们可以为单词的 t 设置一个上限。

现在，考虑以下语料库:

计算机应用的人机界面

用户对计算机系统响应时间的看法

用户界面管理系统

改进响应时间的系统工程

Co-occurrence Matrix with window of size k=2. Each row[column] of the co-occurrence matrix gives a vectorial representation of the corresponding word’s context.

这里，在上述情况下，如果停用词处理不当，它们将产生相对高频率的问题。因此，将使用被称为正逐点互信息的新数量，该数量考虑了相对和个体出现以及词汇的大小。

New transformed table with PPMI values

通过这种方法，我们能够对上下文有所了解，但这仍然不是一种理想的方法。考虑语料库中的示例“猫”和“狗”,但是它们不在窗口间隙内。很明显，猫和狗是有关系的，就像它们都是宠物和哺乳动物一样。这种方法不能提供任何关于它们之间关系的信息。

在上述情况下，{系统，机器}和{人，用户}之间的共现是不可见的。但是，它们在上述语料库的上下文中是相互关联的。

此外，随着词汇量的增加，高维度、矩阵的稀疏性和冗余性(作为对称矩阵)仍然存在。

奇异值分解

高维问题通过 PCA 或其广义形式 SVD 来解决。奇异值分解是将半正定正规矩阵的特征分解推广到任何矩阵，是对极分解的扩展。它给出了原始数据的最佳 k 阶近似。假设原始数据 X 的尺寸为 m x n. 奇异值分解将把它分解成最佳等级近似，从最相关到最不相关的信息中捕捉信息。

SVD theorem tells us that u1 ,v 1 and σ1 store the most important information in X. Subsequent terms stores less and less important information.

与此类似，颜色用 8 位表示。这些 8 位将为我们提供更高的分辨率。但是，现在我们只想将其压缩为 4 位。我们应该保留哪些位，低位的还是高位的？

当比特减少时，最重要的信息是识别颜色，而不是不同颜色的阴影。类似的分辨率将存在于不同的颜色，如红色、蓝色、黄色等。

就像只获取不同色调的信息一样，颜色没有任何意义，因为所有与颜色相关的信息都丢失了。因此，低位是最重要的。在这种情况下，SVD 会捕捉到这些低位。

有了 SVD，{系统、机器}和{人、用户}之间的潜在共现将变得可见。我们取 X 和 X t、的矩阵乘积，其第 I 项是单词 i (X[i :])的表示和单词 j (X[j :]) 的表示之间的点积。第 ij 个条目 X ，Xtt大致捕捉了单词 I，单词 j 之间的余弦相似度。

From product of [XXt] matrix a low rank matrix capturing important features is constructed. the latent co-occurrence between {system, machine} and {human, user} has become visible. See, the red and blue parts in given figure.

我们希望单词(I，j) 的表示具有更小的维度，但是仍然具有与 X hat 的对应行相同的相似性(点积)。因此，我们必须继续寻找更有力的表述。

另外，请注意矩阵wt22】字=uσ的行之间的点积与 X ̂ 帽子的行之间的点积相同。

Wword = UΣ ∈ R m×k is taken as the representation of the m words in the vocabulary and Wcontext = V is taken as the representation of the context words.

连续的单词袋

我们看到的方法是基于计数的模型，如 SVD，因为它使用同现计数，该计数使用基于 NLP 原理的经典统计。现在，我们将转移到直接学习单词表示基于预测的模型。考虑一个任务，给定前一个 (n-1) 字，预测第 n 个字。对于训练数据，可以使用训练语料库中的所有 n 词窗口，并且可以从任意网页抓取获得语料库。

现在，如何对预测第 n 个字的任务建模呢？这项任务和学习单词表征有什么联系？为了模拟这个问题，我们将使用如下所示的前馈神经网络。

One-hot representation as input. |V| words possible as output classes.

我们的目标是预测这些|V|类的概率分布，作为一个多类分类问题。但是这看起来非常复杂，神经网络有非常多的参数。这是一种更简单的方法吗？

为此，我们需要稍微看看这个神经网络背后发生的向量乘法背后的数学。乘积 W 上下文 ***** x** 假设 x 是一个热向量。

Is simply, the i-th column of Wcontext . A ont-to-one mapping exists b/w words & Wcontext’s columns.

我们可以把 W context 的第 I 列作为 contextI .For P(on | sat)与 W context 的第 j 列和withWword 的* 列之间的点积成正比。* P (word = i|sat) 因此取决于与
列的 W 字。我们因此将WW单词的第列视为单词 i. 的表示。这清楚地显示了在神经网络架构中权重参数被表示为单词向量表示。

理解了参数背后的简单解释后，我们现在的目标是学习这些参数。对于多类分类问题，使用 softmax 作为输出激活函数，使用交叉熵作为损失函数。

uc is the column of Wcontext corresponding
to context word c and vwis the column of
Wword corresponding to the word w.

让我们看看我们能从上面的损失函数的更新规则中解释什么。将 yhat 的值放入损失函数中，并对其进行微分，以导出梯度更新规则。

When yhat is 1, already corrected word predicted. Hence, no update. & when it is 0, vw gets updated by fraction of uc added.

这增加了 vw 和 uc 之间的余弦相似度。因为，训练目标确保单词 (vw) 和上下文单词 (uc) 之间的余弦相似度最大化。因此，相似性度量也由这种表示来捕获。此外，神经网络有助于学习更简单和抽象的单词矢量表示。

实际上，在窗口大小中使用了一个以上的词，通常根据使用情况使用“d”窗口大小。这将简单地意味着我们必须在底层堆叠 Wcontext 的副本，因为两个单热棒位将为高。

[W context , W context ] just means that we are
stacking 2 copies of W context matrix

这里，softmax 的计算瓶颈仍然存在，分母项涉及整个词汇表的求和。我们必须探索一些其他模式来缓解这一瓶颈。

跳格模型

该模型预测关于给定输入单词的上下文单词。上下文和单词的作用已经变成了几乎相反的意义。现在，给定输入单词作为一种热门表示，我们目标是预测与之相关上下文单词。这种相反的关系 b/w CBOW 模型& Skip-Gram 模型将在下面变得更加清楚。

给定一个语料库，该模型循环每个句子的单词，或者试图使用当前单词 of 来预测其邻居(其上下文)，在这种情况下，该模型被称为“Skip-Gram”，或者它使用这些上下文中的每一个来预测当前单词，在这种情况下，该模型被称为“连续单词包”(CBOW)。

‘on’ as input word, probabilities of context words related to it are predicted by this network.

训练一个简单的具有单一隐藏层的神经网络来执行某项任务，但是我们实际上并不打算将该神经网络用于我们每次训练它的任务，而是用于建模的新任务！相反，我们的目标实际上只是学习隐藏层的权重，这将是上一节中数学描述的单词向量。

在只有一个上下文单词的简单情况下，我们将对
得出与之前对大众相同的对 uc 的更新规则。如果我们有多个上下文单词，损失函数将只是许多交叉熵误差的总和。

与 CBOW 同样的问题，softmax 的计算开销也存在于该模型中。

可以使用三种策略，即负采样、对比估计和分层 softmax 来消除对整个词汇求和的 softmax 问题。

负采样:我们对每个正(w，c)上下文对采样 k 个没有上下文的负(w，r)对。因此，D 破折号的大小是 D 的 k 倍。在我们的神经网络中，我们将定义损失函数，并在这两个集合上进行训练。这些损坏的词对是从一个特别设计的分布中抽取的，这个分布有利于不太频繁的词被更频繁地抽取。

Summation over entire vocabulary get reduces as two different sets get created.

对比估计:基本思想是将多项分类问题(因为是预测下一个单词的问题)转化为二元分类问题。不是使用 softmax 来估计输出单词的真实概率分布，而是使用二元逻辑回归(二元分类)，即优化的分类器简单地预测一对单词是好还是坏。对于每个训练样本，增强的(优化的)分类器被馈送一个真对(一个中心单词和在其上下文中出现的另一个单词)和多个 k 个随机损坏的对(包括中心单词和从词汇表中随机选择的单词)。通过学习区分真实对和损坏对，分类器将最终学习单词向量。

maximize max(0, s − (s r + m))

在这种技术中，构建二叉树，使得有|V|个叶节点，每个对应于词汇表中的一个单词。从根节点到叶节点存在唯一的路径。实际上，任务被公式化为预测单词的概率与预测从根节点到该单词的正确唯一路径的概率相同。上述模型确保如果 u i 出现在路径上并且路径在uI处向左(右)分支，则上下文单词 v c 的表示将与节点 u i 的表示具有高(低)相似性。

p(w|vc ) can now be computed using |π(w)| computations instead of |V| required by softmax. Also, random arrangement of the words on leaf nodes does well in practice

手套表示

基于计数的方法(SVD)依靠来自
语料库的全局共现计数来计算单词表示。基于预测的方法使用共现信息学习单词表示。为什么不结合两个算和学机构？

让我们用数学的方式表达这个想法，然后发展一种直觉。设 X ij 编码关于 i 和j之间共现的重要全局信息

我们的目标是学习符合整个语料库的计算概率的词向量。本质上，我们说我们希望字向量
vt36】I 和vt40】j 使得vt44】I^tvt48】j 忠实于全局计算的 P (j|i)。

Similar equation for Xj will be there. Also, Xij = Xji.

分别为XI 和Xj 添加两个方程。此外，log( X i )和 log( X j )仅依赖于单词 i & j ，我们可以将它们视为将要学习的单词特定偏差。用下面的方式表述这个问题。

现在，问题是所有同现的权重是相等的。权重应该以这样一种方式来定义，即不常用或常用的单词都不会被过度加权。

单词由密集向量表示，其中向量表示单词到连续向量空间的投影。这是对传统的单词袋模型编码方案的改进，在传统的单词袋模型编码方案中，使用大的稀疏向量来表示每个单词。这些表示是稀疏的，因为词汇表非常庞大，给定的单词或文档将由主要由零值组成的大向量来表示。

结论:选择什么？

考虑到最近流行的研究论文。 Boroni 等人【2014】表明，预测模型在所有任务中始终优于计数模型。 Levy 等人【2015】通过分析(IMO)做了更多的工作，并表明
的旧奇异值分解在相似性任务上比基于预测的模型做得更好，但在类比任务上没有
。Levy 表明 word2vec 也隐含地进行矩阵分解。事实证明，我们也可以证明

word2vec factorizes a matrix M which is related to the PMI based co-occurrence matrix. Very similar to what SVD does.

好的老 SVD 会做得很好。但是，目前在大型语料库上使用预训练的手套嵌入会产生更好的结果，并且一旦被训练，可以再次被重用。像 Keras、Gensim 这样的库确实提供了嵌入层，可以轻松地用于建模任务。此外，对于大量的 NLP 任务，使用Stanford 的手套向量表示数据集要好得多。让我们来看看这些表现模型的几个实例。

代码入门

让我们看看如何将字符编码为整数。这意味着每个唯一的字符将被赋予一个唯一的整数值，并且每个字符序列将被编码为这些唯一整数的序列。按照下面提到的脚本做上面提到的事情。

作为预处理步骤，首先创建一个包含所有序列的文件，并将其存储在一个新文件中。这个新文件将包含等长的字符序列。关于这个预处理步骤，请参考下面的 python 脚本。你也可以参考库链接直接复制完整的项目并在你的机器上运行。

# load doc into memory
def load_docx(filename):
 # open the file as read only
 file = open(filename, 'r')
 # read all text
 text = file.read()
 # close the file
 file.close()
 return text# save tokens to file, one dialog per line
def save_docx(lines, filename):
 data = '\n'.join(lines)
 file = open(filename, 'w')
 file.write(data)
 file.close()# load text data in your current directory
raw_text = load_docx('The-Road-Not-Taken.txt')
print(raw_text)# clean the text
tokens = raw_text.split()
raw_text = ' '.join(tokens)# organize into sequences of characters
length = 16
sequences = list()
for i in range(length, len(raw_text)):
 # select sequence of tokens
 seq = raw_text[i-length:i+1]
 # store
 sequences.append(seq)
print('Total Sequences: %d' % len(sequences))# save sequences to file
out_filename = 'char_sequences.txt'
save_docx(sequences, out_filename)

为了对这些序列进行编码，我们将在给定原始输入数据中的一组唯一字符的情况下创建映射。映射将是一个从字符值到整数值的字典。

char = sorted(list(set(raw_text)))
map = dict((c, i) for i, c in enumerate(char))

接下来，我们一次处理一个字符序列，并使用字典映射来查找每个字符的整数值。结果是以整数格式表示字符序列的整数列表。

sequences = list()
for line in lines:
 # integer encoding line
 encoded_seq = [mapping[char] for char in line]
 # store in list of sequences
 sequences.append(encoded_seq)

接下来，步骤是将每个词汇大小的一个热向量编码到中。将输入和输出列分成不同的字符序列。

sequences = array(sequences)
X, Y = sequences[:,:-1], sequences[:,-1] # X containing all chars except at last position, Y containing only the last char# *to_categorical()* function in the Keras API to one hot encode the input and output sequences.sequences = [to_categorical(x, num_classes=vocab_size) for x in X]
X = array(sequences)
Y = to_categorical(y, num_classes=vocab_size)

经过预处理后，您可以将数据输入到模型中以学习参数。

简单易行:嵌入 Keras

单词嵌入提供了单词的密集表示，并随之传递一些语义信息。嵌入也可以和我们特定于数据集的模型一起学习。

单词在学习向量空间中的位置被称为其嵌入。

keras 提供的嵌入层需要对输入进行整数编码，它使用随机权重进行初始化，并将学习训练数据集中所有单词的嵌入。

e = Embedding(200, 32, input_length=50)
200: specifies the vocabulary size
32: specifies the output vector dimensions
input_length=50: length of input sequences in the document

嵌入层的输出是 2D 向量，对于单词输入序列中的每个单词有一个嵌入。

Keras 嵌入层也可以使用从其他地方学到的单词嵌入，如从斯坦福大学的预训练手套向量。将手套向量加载到内存的一个嵌入数组中。

# load the whole embedding into memory
embeddings_index = dict()
f = open('glove.6B.100d.txt')
for line in f:
 values = line.split()
 word = values[0]
 coefs = asarray(values[1:], dtype='float32')
 embeddings_index[word] = coefs
f.close()
print('Loaded %s word vectors.' % len(embeddings_index))
# for loading again it is better to store this as pickle object.

然后创建可以传递到 Keras 嵌入层的合成权重矩阵。最后，我们不希望在这个模型中更新所学习的单词权重，因此我们将为该模型设置可训练属性为假。

# Here, we are using 100 dim vectors version from downloaded file# create a weight matrix for words in training docs
embedding_matrix = zeros((vocab_size, 100))
for word, i in t.word_index.items():
 embedding_vector = embeddings_index.get(word)
 if embedding_vector is not None:
  embedding_matrix[i] = embedding_vectore = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=4, trainable=False)

根据所用模型的复杂性，上面的代码片段确实给出了开始矢量化任务的思路。对于复杂模型，一个热向量表示最不复杂，一个手套向量表示良好性能。

参考文献和致谢

感谢 Mitesh M. Khapra 教授及其助教精彩的深度学习课程( CS7015 )。另外，来自 machinelearningmastery.com 的 Jason 提供了有用的代码片段和少量的堆栈溢出线程。

巧妙的压缩:如何教神经网络画 70 年代的电视

原文：https://towardsdatascience.com/artful-compression-52c2b7347154?source=collection_archive---------5-----------------------

到目前为止，我已经完成了我那份深度学习 MOOCs 最近是吴恩达在 Coursera 的优秀系列。

但很少有面向有艺术倾向的人的。这就是 TensorFlow 与深度学习的创造性应用的区别。

这是帕拉格·米塔尔正在进行的卡丹泽课程。他通过大量精心制作的视频和 TensorFlow iPython 笔记本，涵盖了深度学习技术的所有领域。你可以随心所欲地调整后者。在这个过程中，您将了解卷积神经网络、自动编码器(我今天的主题)、风格转换和各种生成模型。

但总是着眼于创造具有高度视觉冲击力的作品。

他关于可变自动编码器的课启发我尝试训练一个网络，它可以为人类提供一项重要服务:生成新颖但看起来真实的 70 年代电视图片。

什么是可变自动编码器？

这个人的帖子比我更好地回答了这个问题，但是你可以把它看作是一个巧妙压缩和重构的工具。在许多例子的训练下，它学会了将它们编码成所谓的潜在向量。对于每个训练步骤，它通过将当前潜在向量解码成图像来检查其进度。换句话说，它从潜在向量中的一系列简洁的数字中重建输入图像。

损失函数衡量这些输出与输入的匹配程度。

最酷的部分是，一旦网络被训练，你可以给它的解码部分输入一系列数字(潜在向量的一种变体)，然后就会弹出一个它被训练过的图像的新颖表示。

数据输入

帕拉格鼓励学生寻找有趣的数据集。我创建了自己的 groovy 数据集，大约有 100 张 70 年代电视的图片，是从这个网站上搜来的。它的粉丝扫描并上传整个目录(西尔斯、JCPenney 等。从几十年前开始。)(是的，有人将此作为一种爱好，为此，我很感激他们。)

Part of my 70s TVs dataset.

那些 70 年代的电视机很漂亮。但问题是，正如我们将要看到的，这个数据集太小了。

培养

有了这些数据，我调整了帕拉格的笔记本，用我 70 年代的电视数据集进行训练。您可以在下面观看训练的进展。我认为，看着它让我有了写这篇文章的灵感，真是太酷了。是本帖的钱拍！

A variational autoencoder learns to make 70s TVs (hit reload if you’re not see an animation).

问题

可悲的是，虽然我从来没有得到一个训练有素的网络。很可能数据集太小，即使使用像图像翻转这样的增强技术。如果我超过动画 gif 中显示的时代数，进程最终会停止。误差率将上升，并且输出图像将开始偏离输入图像。

确切的原因将不得不保持神秘，因为这对我来说只是一个有趣的玩具项目(但我欢迎任何改善评论结果的建议)。(下一步将是扩大数据集，看看生成式对抗网络是否能做得更好。)

尽管如此，如下所示，半训练的网络仍然能够产生一些有趣的，如果不完美的结果。事实上，正是它们缺乏完美的保真度，才给了它们一种很好的绘画品质。

Some 70s TVs generated by my variational autoencoder.

这些神经网络很有趣。

如果你想要数据集的副本，请联系我。它很小，但需要大量的体力劳动，这对任何人都没有用。

机器学习与人工智能导论

原文：https://towardsdatascience.com/article-3-machine-learning-and-artificial-intelligence-introduction-c0e558974a11?source=collection_archive---------11-----------------------

Photo by Jens Johnsson on Unsplash

放射科医生的机器学习介绍— 10 部分系列

第三部

作者: 达尼洛泰·瓦雄

编辑: 迈克尔博士

第一部分 | 第二部分

自从可编程计算机开发以来，人工智能(AI)一直是一个长期讨论的话题。学者和哲学家质疑人和机器之间的差异。我们能把人脑及其所有的复杂性编入计算机吗？到那时，计算机能够思考吗？

迄今为止，我们仍然没有回答这些有趣的、令人麻木的问题，但我们已经离让计算机更智能更近了一步。然而，有些人可能会说，即使是最聪明的计算机也不如蟑螂聪明。稍微考虑一下。

最聪明的电脑还是不能同时做一堆任务。相反，他们非常擅长做他们被编程去做的一件事。

在我们进一步挖掘之前，让我们定义一些关键术语。我们从网上提供的众多定义中选择了一个。

前三种是分等级的；人工智能是最大、最重要的类别。机器学习(ML)是 AI 的子集，深度学习(DL)是 ML 的子集。

人工智能 —能够执行通常需要人类智能的任务的计算机系统，例如视觉感知、语音识别、决策和语言之间的翻译。

机器学习——亚瑟·塞缪尔说“机器学习是一种无需明确编程就能学习的能力。”

深度学习——来自麻省理工学院新闻:神经网络松散地模仿人脑，由成千上万甚至数百万个密集互连的简单处理节点组成。这类似于轴突和树突的突触连接。

图像识别——使用机器和深度学习技术来识别图像中的内容。

架构 —用于预测结果的算法模型的脚手架和蓝图。

这些单词在接下来的几篇文章中也会派上用场！当我们在下一篇文章中介绍常见的机器学习算法时，请对它们进行一些 google 搜索并留意它们。

为什么是现在？

如前所述，机器学习和人工概念并不新鲜。事实上，他们已经几十年了。然而，最近几个因素发生了变化，现已大大有助于这些领域的进展。记住这些很重要，因为这标志着历史上一个独特的时刻。

首先，技术的计算速度正在快速进步。名为GPU(图形处理单元)的硬件已经允许计算并行化。也就是说，更多的计算可以同时一起完成，而不是一个接一个。这可以大幅提高效率。我们可以感谢视频游戏行业的这些进步。

第二，算法有了重大进展。深度学习框架或架构已经从谷歌、脸书、研究社区和开源社区中的新兴个人等方面得到了改善。例如，今天广泛使用的一类算法属于神经网络。这些算法大致上是模仿大脑的，在大脑中，信息通过网络在神经元的不同层之间传递。随着时间的推移，算法变得更加复杂，从几层到几十层，甚至可能是几百层。这种增加的复杂性使得我们可能认为重要或不重要的变量之间产生了有趣的相互作用。

最后，但同样重要的是，工业、网络和商业中可用的数据呈指数级增长。这个地区已经发展了多年，并将继续发展。无论是社交数据的涌入，互联网上的图像数量，还是你在亚马逊上的购买，数据都是无处不在的，并将继续作为许多机器学习算法的起点。

所有这些听起来可能让人不知所措，而且范围肯定是巨大的。当然，这些促成机器学习和人工智能出现的变量中的每一个都可以进一步详细梳理出来。然而，重要的是要理解这些片段是采用算法通过数据寻找故事的成分。

我们通过这个系列谈论的故事是机器学习如何改变放射科医生工作方式的故事。但是，这种改变需要时间，需要理解，需要沟通。

有了这些行话，人们很容易气馁。别担心。我们都在这个旅程中，以了解更多关于技术和放射学(和其他领域)的现状将如何变化。

我们建议将这些定义通读几遍，也许做一些外部研究，并且在我们深入研究这些概念时一定要坚持下去。总之:深度学习是 ML 的子集。ML 是 AI 的子集。

一个很好的资源是这个词汇表，它来自一家对 ML 略知一二的公司:

* [## 机器学习词汇表|谷歌开发者

关键机器学习和张量流术语的汇编，带有初学者友好的定义。

developers.google.com](https://developers.google.com/machine-learning/glossary/#s)*

#1 —人工智能:简介

原文：https://towardsdatascience.com/artificial-intelligence-1-introduction-b305a878af6f?source=collection_archive---------2-----------------------

(目的是围绕人工智能，特别是人工智能的投资主题，建立和分享见解。我在伦敦商学院的任期开启了人工智能投资的世界，这一系列涂鸦是我跟上这个话题的方式，当然也是相互学习的方式。希望在某个地方，这些将开始创造价值。在那之前，请继续阅读！)

人工智能简介

人工智能不再是一个影响无处不在的术语。在某种程度上，包括我自己在内的许多人都对自动化和模拟接管世界的整个概念漠不关心。现实是它将会发生，更令人担忧的是，就在我们说话的时候，它正在发生。

有预测和理论表明，到 2050 年，发达国家大约 50%的人类工作将被机器人取代。技术奇点被定义为人工智能超越人类智能的时刻，它将真正发生，我们这一代人将真正看到技术是如何扰乱我们周围的世界的。

但除了对人工智能的普遍兴奋之外，理解它的实际含义也很重要。人工智能就是机器为你执行事情。作为机器，这些不一定是物理机器人，而是类似人脑运作方式的计算代码。类似于我们的大脑:

收到比如热对冷，近对远

记得你的生日或当月的购物清单

回归寻找逃避与伴侣打架或把足球踢向正确方向的最佳方式

通过分析交易对手的行动来回应

一个计算机程序可以完成这一切。因为我们的大脑在计算能力上有局限性，而且因为今天我们有如此多的带标签的数据来校准和验证这些程序，所以人工智能和机器学习(让计算机学习的行话)的概念正变得真实而同样重要。让我们暂停一下，理解 AI 和 ML 这两个词的真正含义。

人工智能是一个广义的术语，用来描述人类可以做的由计算机做的任何事情。首先，数据存储(软盘、存储总线等)是人工智能的最初版本之一。我拿科学来类比:算法= AI:机器学习。机器学习是实现人工智能的一种方法。机器学习与计算机能够解析数据、从中学习和预测洞察力有关。这些术语在人工智能的世界里可以互换使用，但是我们总是用人工智能这个词来描述计算机智能的一般主题。

现在，在机器学习的广泛类别中，最热门和最具趋势的人工智能领域是深度学习。深度学习特别关注通过各种算法来模拟大脑，这些算法包括人工神经网络、遗传算法(以及一系列其他算法，我打算在下面的文章中详细理解和阐述)以将其塑造成人类大脑的行为方式。深度学习通过数据处理、计算机编程和逻辑领域的启示推动了人工智能的发展。

Source: Nvidia corporate blog

定义人工智能市场——横向与纵向人工智能

从广义上讲，人工智能公司可以分为垂直人工智能和水平人工智能。横向 AI 专注于解决更大的问题陈述，而纵向 AI 专注于小众。例如，苹果的 Siri 或亚马逊的 Alexa 就是横向人工智能应用的例子。只要需求和资源存在，横向人工智能可以在内部开发人工智能技术。当他们不能且问题陈述过于小众时，一般从市场上的垂直 AI 玩家那里获得。因此，横向人工智能侧重于更实用的方法，以迎合终端用户可能需要的广泛主题。例如，语音识别已经成为当今主流的人工智能，大多数大型科技公司都配备了这项技术。然而，基于对客户数据的深度学习洞察，为仓库提供最后一公里物流服务的自动驾驶卡车显然是一个横向人工智能。因此，这个游戏很简单，在某个时候，将会有一个由现有者(我们称之为传统市场)主导的行业，依靠利基技术来完成自身。因此，水平人工智能将与垂直人工智能相结合并实现垂直人工智能。

在人工智能的世界里，这些在职者通常被归类为黑手党，由 M 微软、 A mazon、 F acebook、 I BM 和 A lphabet 组成。其他包括苹果推特、英特尔、百度、阿里巴巴(https://TechCrunch . com/2017/01/27/Apple-joins-Amazon-Facebook-Google-IBM-and-Microsoft-in-ai-initiative/)

我将通过横向玩家在以下作品中触及价值、倍数、数量和主题来关注人工智能中的 M&A

人工智能风险投资的主要宏观趋势

1.增长:从根本上推动人工智能增长的是强大的计算和处理器芯片的可用性。计算速度和芯片制造的指数级发展实际上解除了计算限制，使人工智能得以发展

2.相关性:在所有公司的活动记录中(> 70%的公司使用与人工智能相关的关键词)。人工智能不仅仅局限于移动和互联网，还被用于医疗保健、诊断、药物研发、移动性等领域，直到最近，甚至被用于政治活动

3.人才:“获取”在人工智能投资领域非常普遍。在许多情况下，收购风险企业主要是为了团队中的人才。这些企业通常还没有单一产品，但市场上人才的严重短缺推动了并购。毫不奇怪，在某些情况下，风险企业的估值相对高于电动汽车/博士，以此来衡量价值

4.态度转变(拥有比必须拥有更好)——今天几乎所有的应用都有人工智能元素，但仅限于基本的用户需求，如预测分析。人工智能现在被视为使能者，而不是破坏者。人工智能不仅仅是一个就业杀手，从经济意义上来说，它被理解为创造价值

5.生态系统:存在一个支持性的生态系统，主要利益相关者之间的协调日益加强，包括专注于人工智能的企业家、大学、加速器和结构化风险投资基金，特别是在美国(硅谷)、英国(剑桥、伦敦)、中国等。其他国家很快也会效仿

6。 风险企业的战略重点:不考虑目标行业，专注于利基市场的初创企业都有非常成功的退出。几乎所有这些都是现任者在寻找人才和某些产品时收购的。但因为人工智能的范围是无限的，所以很难给大多数风险投资定价。因此，大多数企业在退出时都获得了疯狂的早期倍数。就行业而言，移动、广告技术、制造、医疗诊断和金融是一些领先的人工智能用户。然而，农业、药物研发甚至创意媒体都是一些未充分渗透的领域。(我接下来的一篇文章将关注人工智能渗透率的行业分类)

7.时间表:人工智能革命已经开始，预计未来 3 年人工智能投资和增长将大幅增长。从今天到未来 20 年，我们所说的变化可能会重现我们从后工业革命到今天的移动和互联网世界所看到的情况。轴不再是线性的而是指数的！

人工智能:一个更美好世界的催化剂…伴随着美妙的音乐

原文：https://towardsdatascience.com/artificial-intelligence-a-catalyst-for-a-better-world-with-great-music-bebcbbe48646?source=collection_archive---------2-----------------------

“我对此有很强烈的意见。我很乐观。我认为那些唱反调并试图鼓吹这些世界末日情景的人——我只是，我不明白。这真的是消极的，在某些方面，我实际上认为这是非常不负责任的。”——马克·扎克伯格(Mark Zuckerberg)在被问及对人工智能的看法以及它将如何影响世界时的回应。

你认为人工智能将会极大地改善我们的社会，还是你认为这项技术在未来会带来极大的危险？

科技巨头埃隆·马斯克(Elon Musk)和马克·扎克伯格(Mark Zuckerberg)最近一直在公开辩论这个问题，马斯克声称扎克伯格关于人工智能的知识“有限”。这位特斯拉首席执行官和直言不讳的创新者一直在推动对人工智能的积极监管，因为他认为该技术是“人类文明的根本生存风险”。另一方面，扎克伯格谴责了马斯克的警告，称他的声明“非常不负责任”。

尽管许多学者，如密歇根大学研究机器学习的教授佩德罗·多明戈斯(Pedro Domingos)，认为马斯克的噩梦场景最终可能会发生，但他的观点完全错误。总体而言，专家们似乎同意，最聪明的方法是关注当前的人工智能挑战，这将导致开发必要的监管架构，以防止未来出现不可预测和破坏性的人工智能场景。

人工智能有可能在短期内极大地改善我们的世界，从大量减少道路上的致命事故到以多种令人难以置信的方式扩大媒体和娱乐的艺术可能性范围。可以说，当科技亿万富翁们正在辩论他们关于人工智能对人类的威胁的存在差异时，我们其他人正在为该行业研究更谦逊的现实生活用途，以改善当前和未来的世界。

音乐产业已经在考虑人工智能的奇妙应用，例如计算机可以学习为电影、电视和游戏产业制作音乐。此外，尽管有人担心这对人类作曲家的影响，但人工智能最终可以用来补充这些作曲家的工作，让他们专注于更大的画面，而计算机则创建基本的音乐结构。一个很好的例子是受欢迎的 YouTube 艺术家塔瑞安·扫森，她与 Amper Music 和其他几个人工智能音乐服务合作，发布了她的专辑的第一首歌《Break Free》。当艺术家/作曲家创作歌词和旋律时，人工智能开发了和声、和弦和序列。Southern 并没有感到来自她新的作曲伙伴的威胁，她解释说，她仍然拥有自己的愿景，而 AI“使她比以往任何时候都更有创造力。”

这只是一系列激动人心的进展之一。音乐行业成功整合人工智能的另一个优秀例子来自谷歌研究人员道格拉斯·埃克(Douglas Eck)，他正与他的团队合作，通过分析数百个音符来教授神经网络学习乐器的音乐特征。一旦机器随后创建了特定乐器的数学表示，用户就可以简单地在屏幕上移动按钮来组合声音，从而创建一个全新的虚拟乐器，例如 74%是长号，26%是吉他。或者，仪器的任何其他组合。可能性真的是无穷无尽的，值得在人工智能的世界中强调这些令人兴奋且无威胁的创新。

随着越来越多的企业竞相将自己的软件升级，这一领域正在迅速扩大。这些公司包括英国的 Jukedeck 和 Amper Music ，三藩市的 Humtap ，柏林的 Melodrive ， Groov。AI 在加州山景城，索尼的计算机科学实验室(CSL)在巴黎进行一个名为 Flow Machines 的项目。

人工智能在音乐生态系统中的应用不仅仅是翻唱、声音生成和歌曲创作。除了人工智能在创造性努力中日益增长的重要性，它还是在客户体验和与音乐粉丝的联系方面取得成功的主要关键之一。

人工智能已经被用于音乐行业，以改善消费者体验，例如根据情绪创建播放列表。虽然 Gracenote 多年来一直按照这一标准对音乐进行分类，但其员工并没有听完公司数据库中 1 亿首歌曲中的每一首来实现这一目标。相反，机器学习和人工智能已经被用来成功地教会计算机如何胜任地检测音乐中的情感，从而节省了大量的时间和人力资源。

从人工智能聊天机器人和智能语音界面到有效利用大数据，并通过有针对性的广告和高度个性化的歌曲推荐服务创造额外的收入流，人工智能在音乐行业的合作潜力巨大，仍有待实现。

人工智能的发展应该着眼于增强人类的能力，把我们从许多任务中解放出来，而不是完全取代人。与其试图通过辩论世界末日的长期可能性来减缓进步，不如用人工智能来解决当前的问题，让创新者在机器学习的帮助下推动信封走向更美好的世界，同时专注于为我们所有人创造最有成就、最强大和最安全的社会。

由 谢尔盖·布多夫 媒体与娱乐高级副总裁 数据艺术

人工智能，2018 年及以后的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-ai-in-2018-and-beyond-e06f05167f9c?source=collection_archive---------1-----------------------

或者机器学习是如何进化成人工智能的

这些是我对深度神经网络和机器学习在更大的人工智能领域的发展方向的看法，以及我们如何才能获得越来越多的复杂机器来帮助我们的日常生活。

请注意，这些不是预测的预测，而是对这些领域的轨迹、趋势和我们实现有用的人工智能的技术需求的详细分析。

并非所有的机器学习都是针对人工智能的，也有一些唾手可得的成果，我们也将在这里进行研究。

目标

该领域的目标是在日常生活中帮助我们的机器中实现人类和超人的能力。自动驾驶汽车、智能家居、人工助手、安全摄像头是首要目标。家庭烹饪和清洁机器人是第二个目标，此外还有无人驾驶飞机和机器人。另一个是移动设备上的助手或永远在线的助手。另一个是全职伴侣助手，可以听到和看到我们在生活中经历的事情。一个最终目标是一个完全自主的合成实体，在日常任务中可以达到或超过人类水平的表现。

在这里查看更多关于这些目标的信息，在这里查看，在这里查看。

软件

软件在这里被定义为用优化算法训练来解决特定任务的神经网络架构。

今天，神经网络是学习解决任务的事实上的工具，这些任务涉及在监督下从大型数据集进行分类。

但这不是人工智能，它需要在现实世界中行动，经常在没有监督的情况下学习，从以前从未见过的经验中学习，经常在完全不同的情况下结合以前的知识来解决当前的挑战。

我们如何从目前的神经网络转向人工智能？

神经网络架构 —几年前，当该领域蓬勃发展时，我们经常说它具有从数据中自动学习算法参数的优势，因此优于手工制作的功能。但是我们很方便地忘记提到一个小细节…作为解决特定任务的训练基础的神经网络架构不是从数据中学习的！事实上，它仍然是手工设计的。根据经验手工制作，这是目前该领域的主要限制之一。有这方面的研究:这里和这里(例如)，但需要更多。神经网络结构是学习算法的基本核心。即使我们的学习算法能够掌握一项新任务，如果神经网络不正确，它们也将无法掌握。从数据中学习神经网络架构的问题是，目前在大型数据集上试验多种架构需要太长时间。人们必须从头开始尝试训练多种架构，看看哪一种工作得最好。这正是我们今天使用的耗时的试错程序！我们应该克服这个局限，在这个非常重要的问题上多动脑筋。

无监督学习——我们不能总是在我们的神经网络旁边，在它们生命的每一站和每一次经历中指导它们。我们不能每次都纠正他们，并对他们的表现提供反馈。我们有自己的生活要过！但这正是我们今天对监督神经网络所做的:我们在每一个实例中提供帮助，使它们正确地执行。相反，人类只从少数几个例子中学习，并且可以不断地自我修正和学习更复杂的数据。我们在这里广泛讨论了无监督学习。

预测神经网络— 当前神经网络的一个主要限制是，它们不具备人脑最重要的特征之一:预测能力。关于人脑如何工作的一个主要理论是通过不断进行预测:预测编码。你想想，我们每天都在经历。当你举起一个你认为很轻但结果很重的物体时。它让你感到惊讶，因为当你走近去捡它的时候，你已经预测到它会如何影响你和你的身体，或者你的整体环境。

预测不仅能让我们了解这个世界，还能让我们知道什么时候不了解，什么时候应该了解。事实上，我们保存了我们不知道的事情的信息，并给我们带来惊喜，所以下次它们不会了！认知能力显然与我们大脑中的注意力机制有关:我们放弃 99.9%感官输入的先天能力，只专注于对我们生存非常重要的数据——哪里有威胁，我们跑到哪里去躲避它。或者，在现代社会，当我们匆忙出门时，我的手机在哪里？

建立预测神经网络是与现实世界互动的核心，也是在复杂环境中行动的核心。因此，这是任何强化学习工作的核心网络。见下文。

我们广泛讨论了预测神经网络的主题，并且是研究和创建预测神经网络的先驱团体之一。有关预测神经网络的更多细节，请参见此处的，此处的，此处的。

当前神经网络的局限性 —我们之前已经讨论过当前神经网络的局限性。无法预测，无法根据内容进行推理，并且具有时间不稳定性——我们需要一种新型的神经网络你可以在这里阅读。

神经网络胶囊是解决当前神经网络局限性的一种方法。我们在这里回顾了它们。我们认为胶囊必须扩展一些额外的特性:

对视频帧的操作:这很简单，因为我们需要做的就是让胶囊路由查看最近的多个数据点。这相当于对最近重要数据点的联想记忆。注意这些不是最近帧的最近表示，而是它们是顶部最近的不同的表示。具有不同内容的不同表示可以例如通过仅保存差异超过预定值的表示来获得。这个重要的细节允许只保存最近历史的相关信息，而不是一系列无用的相关数据点。
预测神经网络能力:这已经是动态路由的一部分，它迫使各层预测下一层的表现。这是一种非常强大的自我学习技术，在我们看来，它击败了我们迄今为止作为一个社区开发的所有其他类型的无监督表示学习。胶囊现在需要能够预测长期的时空关系，而这目前还没有实现。

持续学习 —这很重要，因为神经网络在其生命周期中需要不断学习新的数据点。当前的神经网络不能够学习新数据，除非在每个实例中从头开始重新训练。神经网络需要能够自我评估新训练的需求以及它们确实知道一些东西的事实。这在现实生活和强化学习任务中也是需要的，我们希望教会机器在不忘记旧任务的情况下完成新任务。

更多细节，请看Vincenzo lo Monaco的这篇优秀博文。

转移学习——或者说，我们如何让这些算法通过观看视频自行学习，就像我们想要学习如何烹饪新东西时所做的那样？这是一种需要我们上面列出的所有要素的能力，对于强化学习也很重要。现在你真的可以训练你的机器做你想做的事情，只需给出一个例子，就像我们人类做的一样！

强化学习— 这是深度神经网络研究的圣杯:教会机器如何在一个环境中学习行动，真实的世界！这需要自我学习、持续学习、预测能力，以及更多我们不知道的东西。在强化学习领域有很多工作，但对作者来说，这只是触及了问题的表面，离它还有数百万英里远。我们已经在这里讨论过这个。

强化学习通常被称为“蛋糕上的樱桃”，这意味着它只是在塑料合成大脑上的次要训练。但是我们怎样才能得到一个“通用的”大脑，从而轻松解决所有问题呢？这是个先有鸡还是先有蛋的问题！今天，为了一个接一个地解决强化学习问题，我们使用标准的神经网络:

一种深度神经网络，它接受大量数据输入，如视频或音频，并将其压缩成表示形式
学习任务的序列学习神经网络，如 RNN

这两个组件都是问题的明显解决方案，目前显然是错误的，但这是每个人都在使用的，因为它们是一些可用的构建模块。这样的结果并不令人印象深刻:是的，我们可以从头开始学习玩视频游戏，并掌握完全可观察的游戏，如国际象棋和围棋，但我不需要告诉你，与解决复杂世界中的问题相比，这算不了什么。想象一个能比人类玩得更好的人工智能…我想看看！

但这是我们想要的。能像我们一样操作的机器。

此处详细介绍了我们关于强化学习工作的建议。它使用一个可以连续运行的预测神经网络和一个关联存储器来存储最近的经验。

不再有递归神经网络 —递归神经网络(RNN)的日子屈指可数。RNN 特别不擅长并行化训练，即使在特殊的定制机器上也很慢，因为它们的内存带宽使用率非常高——因此它们是内存带宽受限的，而不是计算受限的，更多细节请参见这里的。基于注意力的神经网络训练和部署更高效、更快速，并且它们在训练和部署中受可扩展性的影响更小。神经网络中的注意力有可能真正彻底改变许多架构，但它还没有得到应有的认可。联想记忆和注意力的结合是下一波神经网络发展的核心。

注意力已经显示出能够学习序列以及 rnn，并且计算量减少了 100 倍！谁能忽视这一点？

我们认识到，基于注意力的神经网络将慢慢取代基于 RNN 的语音识别，并在强化学习架构和人工智能中找到它们的方法。

分类神经网络中的信息定位 —我们已经广泛讨论了如何定位和检测图像和视频中的关键点这里。这实际上是一个已解决的问题，将被嵌入未来的神经网络架构。

五金器具

深度学习的硬件是进步的核心。现在让我们忘记深度学习在 2008-2012 年以及最近几年的快速扩张主要是由于硬件:

每部手机中的廉价图像传感器都可以收集大量的数据集——是的，社交媒体对此有所帮助，但只是在一定程度上
允许 GPU 加速深度神经网络的训练

而在之前我们已经广泛的谈过硬件。但是我们需要给你一个最近的更新！过去 1-2 年见证了机器学习硬件领域的繁荣，特别是针对深度神经网络的机器学习硬件。我们在这方面有显著的经验，我们是FWD NXT,雪花的制作者:深度神经网络加速器。

有几家公司在这个领域工作:英伟达(显然)、英特尔、Nervana、Movidius、比特大陆、Cambricon、Cerebras、DeePhi、谷歌、Graphcore、Groq、华为、ARM、Wave Computing。所有这些公司都在开发定制的高性能微芯片，这些芯片将能够训练和运行深度神经网络。

关键是在计算最近有用的神经网络运算时，提供最低的功耗和最高的测量性能，而不是像许多人声称的那样，每秒进行原始的理论运算。

但该领域很少有人了解硬件如何真正改变机器学习、神经网络和人工智能。很少有人了解微芯片的重要性以及如何开发它们。

以下是我们的列表:

训练还是推断？——很多公司都在创造可以提供神经网络训练的微芯片。这是为了获得 NVIDIA 的一部分市场，这是迄今为止事实上的训练硬件。但是训练只是故事和深度神经网络应用的一小部分。对于每个训练步骤，实际应用中都有一百万次部署。例如，你现在可以在云上使用的一个对象检测神经网络:它曾经被训练过一次，是的，在许多图像上，但是一旦训练过，它可以被数百万台计算机用于数十亿数据。我们在这里想说的是:与你使用的次数相比，训练硬件和你训练的次数一样无关紧要。而制作用于训练的芯片组需要额外的硬件和额外的技巧。这意味着同样的性能需要更高的功率，因此对于当前的部署来说可能不是最好的。训练硬件是重要的，并且是推理硬件的简单修改，但是它并不像许多人认为的那样重要。
应用 —能够以更快的速度和更低的功耗提供培训的硬件在该领域非常重要，因为它将允许更快地创建和测试新模型和应用。但是真正有意义的进步将会是应用程序的硬件，主要是推理。今天有许多应用是不可能的或不切实际的，因为缺少的是硬件，而不是软件，或者效率低下。例如，我们的手机可以是基于语音的助手，但目前并不理想，因为它们不能一直运行。甚至我们的家庭助理也与电源相连，除非我们在周围撒上多个麦克风或设备，否则无法跟随我们在房子里四处走动。但也许最大的应用是将手机屏幕从我们的生活中移除，并将其嵌入我们的视觉系统。如果没有超高效的硬件，所有这些以及更多的应用(小型机器人)都不可能实现。
赢家和输家 —在硬件方面，赢家将是那些能够以尽可能低的单位性能功耗运行，并快速进入市场的公司。想象一下取代手机中的 SoC。每年都会发生。现在想象将神经网络加速器嵌入到存储器中。这可能会更快地占领大部分市场，并具有显著的渗透力。这就是我们所说的胜利者。

关于神经形态神经网络硬件，请看这里。

应用程序

我们在上面的目标部分简单地讨论了应用程序，但是我们真的需要在这里深入细节。AI 和神经网络将如何进入我们的日常生活？

以下是我们的列表:

对图像和视频进行分类——已经在许多云服务中使用。接下来的步骤是在智能摄像机源中做同样的事情——今天也是由许多提供商提供。神经网络硬件将允许移除云，并在本地处理越来越多的数据:隐私和节省互联网带宽的赢家。
基于语音的助手正在成为我们生活的一部分，因为它们在我们的“智能”家庭中播放音乐和控制基本设备。但是对话是如此基本的人类活动，我们常常认为它是理所当然的。你可以与之交谈的小设备是一场正在发生的革命。基于语音的助手越来越好地为我们服务。但是它们仍然和电网相连。我们真正想要的助手会和我们一起走。我们的手机呢？硬件再次胜出，因为它将使这成为可能。Alexa 和 Cortana 和 Siri 将永远在线，永远与你同在。你的手机将很快成为你的智能家居。这是智能手机的又一次胜利。但是我们也希望它在我们的车里，当我们在镇上走动时。我们需要本地语音处理，越来越少的云。更多的隐私和更少的带宽成本。同样，硬件将在 1-2 年内为我们提供所有这些。
真正的人工助手 —语音很棒，但我们真正想要的是也能看到我们所看到的东西的东西。当我们四处走动时，分析我们的环境。参见示例这里，最终这里。这才是我们能爱上的真正的 AI 助手。神经网络硬件将再次满足你的愿望，因为分析视频馈送在计算上非常昂贵，并且目前处于当前硅硬件的理论极限。换句话说，这比语音助手要难做得多。但这并不是不可能的，许多聪明的初创公司，如 AiPoly 已经有了所有的软件，但缺乏在手机上运行的强大硬件。还要注意的是，用一个类似眼镜的可穿戴设备来代替手机屏幕，将真正让我们的助手成为我们的一部分！

我们要的是电影里的她的她的！

烹饪机器人——下一个最大的电器将是烹饪和清洁机器人。在这方面，我们可能很快就有了硬件，但我们显然缺乏软件。我们需要迁移学习、持续学习和强化学习。一切都运转良好。因为你看:每个食谱都不一样，每个烹饪原料看起来都不一样。我们不能硬编码所有这些选项。我们真的需要一个能够很好地学习和归纳的合成实体来做这件事。我们离它很远，但没有那么远。按照目前的发展速度，只需要几年的时间。我一定会像过去几年一样努力~

这篇博文将会发展，就像我们的算法和我们的机器一样。请尽快再次检查。

PS。:点击了解更多关于性能、屋顶图和带宽的信息。

关于作者

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

人工智能帮助医学研究人员发现严重哮喘的基因特征

原文：https://towardsdatascience.com/artificial-intelligence-aids-medical-researchers-in-uncovering-genetic-signature-for-severe-asthma-f8125b926915?source=collection_archive---------7-----------------------

一个欧洲医学研究联盟使用一种人工智能形式发现了一个 1693 年的基因签名，以有意义地区分严重哮喘和非哮喘以及轻中度哮喘。通过对哮喘人群进行细分，研究人员希望为对治疗有反应的患者开发有针对性的治疗方法。这种疗法在治疗只涉及少量基因的疾病方面一直很有效。开发针对哮喘等涉及成百上千个基因的疾病的靶向药物更具挑战性。

这项研究发表在《美国呼吸重症监护医学杂志》上，包括 11 个欧洲国家 16 个地点的 610 名患者。这项研究由 U-BIOPRED(呼吸疾病结果预测中的无偏生物标志物)进行，这是一个研究项目，使用来自成人和儿童的信息和样本来了解更多关于不同类型哮喘的信息，以确保每个人都能获得更好的诊断和治疗。

哮喘影响着全球 1 . 5 亿至 3 亿人，其发病率还在上升。根据 T2 疾病控制中心的数据，每五个家庭中就有一个人患有哮喘。在美国，哮喘影响近 1900 万人，每年花费超过 600 亿美元，每个哮喘患者的医疗费用超过 3000 美元。

哮喘是一种慢性气道疾病的集体临床定义，其中炎症是潜在的病理生物学过程，但该过程的全部复杂性在分子水平上定义不清。还认识到哮喘不是单一疾病，而是包含几种表型的疾病。在过去的几年里，Ayasdi 与 U-BIOPRED 和南安普顿大学的研究人员合作，将机器智能应用于从 3 项大型研究中收集的数据，这些研究涉及哮喘患者和匹配的控制对象。从参与者处收集了几种生物流体，并应用多种研究方法来描述肺部和体循环内的复杂病理生物学。这些数据与用于定义疾病严重程度的标准临床结果相结合。

“成功开发针对哮喘等异质性疾病的有效精确治疗将需要新的强大统计模型，使研究人员能够过滤噪音，专注于患者群体之间有意义的差异。Ayasdi 实现了一种无偏见的方法来识别哮喘中复杂疾病的表型特征，此外，还为我们提供了一种无与伦比的能力来识别与这些表型相关的特征，从而为进一步探索创造了新的科学问题"英国南安普顿大学医学院医学教授兼 NIHR 呼吸生物医学研究中心主任 Ratko Djukanovic 博士说。“Ayasdi 是拼凑这种基因特征的无价工具，”Paul Skipp博士，这项研究的另一位首席研究员。

U-BIOPRED 的研究使用 Ayasdi 机器智能平台，结合传统的统计方法，在疾病的整个基因组上直观地绘制出患者群，并发现 1693 个基因的表达在严重哮喘患者和没有哮喘的患者之间存在明显差异。非哮喘患者和轻至中度哮喘患者之间的差异较小。这项研究为严重哮喘患者血液中的差异基因表达提供了令人信服的证据。

此前，南安普顿大学的研究人员使用 Ayasdi 进行无偏见的患者分层，从而改善了患者分类和预测模型。南安普顿利用 Ayasdi 的工作已经持续了几年，从合作中产生的见解将被用于造福科学、医学和患者。

哮喘中存在相当多的疾病异质性，这仍然是当前研究的热点。然而，许多试图定义内型的研究受到复制队列中缺乏可靠的统计学验证的限制，或者产生了其身份主要由临床参数支配的聚类，而没有给出对潜在病理生理学的重要见解。在之前发表在过敏杂志&临床免疫学 (JACI)的两项研究之一中，在两个不同的队列(194 名哮喘受试者和 21 名对照组)中，Ayasdi 确定了六个疾病群，这些疾病群由血液和诱导痰中的临床测量和病理学测量共同定义。Ayasdi 发现了临床测量和潜在炎症测量之间的脱节。

“这清楚地展示了我们作为临床医生在我们的严重哮喘诊所看到的不同哮喘组，并将有助于为未来的临床试验确定亚组，”Timothy Hinks 博士说Timothy Hinks，他是墨尔本大学多尔蒂研究所的惠康信托博士后研究员，是一名医生，也是南安普顿大学前两项研究的第一作者。这项研究由医学研究委员会和 Wellcome Trust 资助，利用了在以前的研究中试行的新方法和分析方法，但通过使用更大的样本量和使用地理上不同的推导和验证队列来扩展观察结果，以实现稳健的统计验证。此外，目前的研究证实了以前工作中确定的群集的性质，同时提供了对潜在病理生物学的额外见解。

在 JACI 发表的另一项先前研究(60 名患者和 24 名对照)中，Ayasdi 被成功用于确定六个对哮喘靶向治疗发展至关重要的患者亚群体，其中两个是重度哮喘患者，尽管他们在是否存在对常见空气过敏原(如屋尘螨)的过敏反应方面存在临床差异，但在肥大细胞活化方面相似。这表明肥大细胞在各种形式的严重哮喘中起着重要作用，这是以前没有意识到的，这对于开发可以靶向这种共同机制的新药具有重要意义。

Timothy Hinks 博士说:“由于哮喘是一种病理学差异很大的疾病，并且仍然没有得到很好的理解，因此使用 Ayasdi 平台驱动无人监管的多维查询的能力对于加快我们的研究是不可或缺的。“这一进展使得我们的团队在生成关于数据的假设时不那么有偏见。这有助于我们专注于推动数据驱动的假设，从而节省时间，并使我们的工作适用于所有治疗哮喘和类似病理多样疾病的医护人员。使用 Ayasdi，以适当的分辨率生成一个网络，只需几个小时就能获得重要的见解。统计分析可以通过内置函数从 Ayasdi 中快速提取出来。因此，Ayasdi 既可用于快速浏览数据，也可如本文所述，用作决定性的分析框架。”

“几年前，我们开始与 Ayasdi 合作，结果非常显著。事实上，Ayasdi 非常易于使用，并允许以灵活的方式分析大型和非常复杂的数据，这使它成为我们的理想选择。现在，Ayasdi 已经可供联盟的主要成员使用，我期待着更多的突破，对欧洲和其他地区的严重哮喘患者产生直接和积极的影响。”Ratko Djukanovic 博士，南安普敦大学医学院医学教授，联合王国南安普敦 NIHR 呼吸生物医学研究所所长

这三项研究结合在一起，帮助研究人员开始建立严重哮喘患者的临床和基因组图谱。未来的研究可能有助于确定治疗这种复杂疾病的实验药物靶点。

要成为合作者，请发电子邮件给我们，姓名为collaborations@ayasdi.com。

人工智能和不良数据

原文：https://towardsdatascience.com/artificial-intelligence-and-bad-data-fbf2564c541a?source=collection_archive---------1-----------------------

脸书、谷歌和推特的律师向国会作证，说明他们如何错过了俄罗斯的影响力运动。尽管这些广告是在充斥着分析引擎的平台上用俄罗斯货币购买的，但影响力运动的问题本质并未被发现。“卢布+美国政治”并没有引发警报，因为现成的深度学习的本质是，它只寻找它知道要寻找的东西，从更深的层面来说，它是在从真正杂乱(非结构化)或损坏和有偏见的数据中学习。对公共数据(混合私有数据)的非结构化本质的理解每天都在突飞猛进。这是我工作的主要内容之一。让我们转而关注数据质量问题。

Data can be wrong. Image taken from this post.

以下是一些常见的数据质量问题:

数据稀疏性:我们对很多事情都有一点了解，但对大多数事情却没有清晰的了解。
数据损坏:将 PDF 转换为文本并打印。是啊。除了正文之外，还有许多垃圾。
大量不相关的数据:在一个象棋游戏中，我们可以剪枝整节的树搜索，更普遍的是，在一张猫的图片中，大部分像素并没有告诉我们这只猫有多可爱。在完全随机的数据中，我们人类(和人工智能)可以看到实际上不存在的模式。
从不良标签中学习:标签系统的偏差，可能是由于人为偏差。
缺失意想不到的模式:黑天鹅、政权更迭、阶层失衡等。
学习错误的模式:不是真正因果关系的相关性可以被训练到 AI 中，然后它错误地假设相关性是因果关系。
我可以继续。

Bad data is hard to analyze with off-the-shelf systems. Yep. AI is one tough business. Credit: Robert Taylor

我们知道，基本上任何问题都很难得到有标签的数据，甚至有标签的数据也可能充满偏差。我周五拜访了一个潜在客户，他有一个很棒的数据团队，但由于所有权和知识产权问题，没有能力从现实世界中收集他们需要的数据。这个“卢布+美国政治”的好数据被 AI 遗漏的例子，对专家来说并不奇怪。为什么？嗯，人工智能需要知道要寻找什么，社交媒体巨头正在寻找更具侵略性的攻击类型，如根据他们的 facebook 个人资料监控士兵的行动。事实上，我们错过好数据信号的原因是像 twitter 这样的真实系统中有大量的坏数据。这是一个信噪比问题。如果警报太多，警报系统会被忽略。太少，系统会错过关键警报。不仅仅是像俄罗斯这样的对手试图获得影响力。好人，公司和品牌，做同样的事情。滴运动和游击营销是一种在鞋类销售中传播影响力的策略，就像政治干预选举一样。所以，我们错过好数据信号的真正原因是坏数据。利用简单的谓词逻辑，我们知道假假设可以隐含任何东西 ( 也此)。因此，从我们知道错误百出的数据中学习会带来一些真正的负担。

Let’s just agree that the data is wrong. Credit: (not original author)

坏数据的一个例子是发现你的人工智能模型是在错误类型的数据上训练的。来自聊天对话的文本不像来自报纸的文本。两者都是由文字组成，但内容却大不相同。在维基百科数据集或谷歌新闻文章上训练的人工智能不会正确理解(即“模拟”)我们人类在聊天应用程序中用来交流的自由格式文本。这里有一个稍微好一点的数据集，也许还有来自黑客新闻数据集的评论。通常，我们需要针对正确的问题使用正确的预训练模型或现成的数据集，然后进行一些迁移学习，以从基线进行改进。然而，这是假设我们可以使用这些数据。许多公共数据集甚至有更大的坏数据问题，导致模型完全失败。有时使用一个字段，有时留空(稀疏)，有时非数字数据悄悄进入数字列(“1”对 1)。我在一个大型私人房地产数据集中发现了一个异常值，一百万个条目中有一个是由人类输入的巨大数字，被称为粗手指错误。

像围棋( AlphaGo zero )这种游戏的问题，没有不好的数据可以分析。相反，人工智能评估更相关和不太相关的数据。游戏是一个很好的约束问题集，但是在大多数真实世界的数据中，存在偏差。很多。助推和其他技术也会有帮助。事实是，机器学习的某些方面仍然是开放的问题，令人震惊的改进一直在发生。例子:胶囊网击败 CNN 。

重要的是要知道错误何时是由数据中的坏东西引起的，而不是由数据拟合不当引起的。像人类一样，在运行时学习的活系统特别容易从坏数据中学习错误信息。这有点像辛普森悖论，因为数据通常是正确的，所以拟合数据是一件好事，但有时拟合数据会产生悖论，因为方法本身(拟合数据)是基于一个糟糕的假设，即所有数据都是基本事实数据。参见这段视频，了解更多关于辛普森悖论的乐趣。这是另一个链接，链接到 Autodesk 的 datasaurus ，我很喜欢它。它完全值得完整阅读。

These images are all RANDOM data. I want to drive home the point that “trends” can be found in lots of places, and the law of big numbers is not always there to come to the rescue. IN the bar graph it looks like something special happens at 7. It’s just random. In the pie chart with 3 colors it looks like 1 is more prevalent than 2 and 3. Nope. Random. The pie chart with lots of slices is a case where we start to see the numbers averaging out, but that’s the point. Sometimes your dataset has all sorts of garbage in it that you don’t know about.

我们谈到了这样一个事实，即大多数真实世界的数据充满了腐败和偏见。这有点糟糕，但并不是所有的都失去了。有各种各样的技术可以应对糟糕的数据质量，其中最重要的是收集更多的数据，并清理数据。更高级的技术，如 NLP 集成、知识图表和商业级分析，并不容易得到。在以后的文章中会有更多关于这个的内容。

如果你喜欢这篇关于坏数据和人工智能的文章，那么请尝试一下 clap 工具。轻点那个。跟着我们走。在脸书和推特上分享。去吧。我也很高兴在评论中听到你的反馈。你怎么想呢?

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

如何给人工智能项目定价
如何聘请人工智能顾问
人工智能:让你的用户给你的数据贴上标签

人工智能和数据科学正在改变犯罪调查和预防

原文：https://towardsdatascience.com/artificial-intelligence-and-data-science-are-changing-crime-investigation-and-prevention-62a6e6f15283?source=collection_archive---------12-----------------------

由 Omkar Sabnis 和Sukant khu Rana

Photo by Simon Wijers on Unsplash

随着技术的进步，世界上的犯罪也在增加。我们都看了新闻，犯罪随着技术和时间而发展。它已经从抢劫银行发展到入侵银行把钱转到另一个账户。因此，我们可以说，随着犯罪的发展，方法也必须发展。犯罪的形式多种多样，千变万化。打击犯罪就像打击一个多头怪物……因为当我们砍掉一个头时，还会有两个长出来——它们比前一个更聪明、更凶猛。

因此，在打击犯罪时，我们需要有灵活性和创造性。在我们日益自动化的未来，我们认为人工智能——当与数据科学和分析相结合时，将赋予我们处理犯罪的能力和灵活性——无论是预防还是调查。

人类是有创造力的动物，但勤奋是我们缺乏的品质。重复做同样的工作并保证质量是我们不擅长的。我们也被情感所束缚。情绪会根据情景改变我们的决定。

我们来看看人工智能能做什么。在新闻领域，现在有一些机器可以为你写任何你想写的主题的文章。像雅虎这样的公司！现在正在使用人工智能来准备关于体育赛事和选举的简单文档。人工智能将访问互联网，找到必要的和相关的信息，并将其组织成一份报告。在电子商务领域，人工智能正被用于为客户个性化网站——向他们展示他们想要的东西，并向他们推荐产品。自动驾驶汽车很快就会被部署。埃隆·马斯克最近在推特上写道，人们很快就会召唤他们的汽车，而不是走向他们的汽车。随着数据量的增加，人工智能现在被用于分析股票市场和进行预测，而不是人类。我们可以看到，无论我们喜欢与否，人工智能将无处不在。

犯罪领域的人工智能将是一个巨大的红利。美国政府已经花费了 800 多亿美元将人工智能引入州、地方和联邦各级部门。犯罪是由人类犯下的，我们作为有逻辑的人遵循一种模式——无论我们试图变得多么随机。人工智能的优势在于它可以检测我们的行为模式——它将能够预测人将如何行动，这就是人工智能的优势。

让我们举一个实时的例子。十二宫杀手是 20 世纪 70 年代的连环杀手。记录显示他杀了 5 人，但据称他杀了 37 人。他给警方写了 4 个密码来证明他的身份，这些密码对大多数专家来说都是无法破解的。四个密码中只有一个被解开了。现在，一台名为卡梅尔的计算机已经被调整为像十二宫杀手一样思考。密码解密有以下步骤:我们首先尝试解释密码，然后使用合适的密钥或设计一个新的密钥来适应密码。因此，卡梅尔正在通过互联网获取数十亿的密钥，以便尝试和解释十二宫杀手的密码。这是人类自己做不到的。

人工智能还有更多应用，如枪击检测，改善安全摄像机镜头分析，预测未来的犯罪点和预测未来谁会犯罪。然而，预测并不是我们可以马上做的事情。它需要数据。否则这只是猜测。这就是数据科学和分析发挥作用的地方。

让我们看看当前的例子——pred pol。他们是一家公司，声称通过利用过去犯罪，他们可以预测未来犯罪的可能性以及何时何地会发生犯罪。这可以通过分析过去的罪行，找到相似之处，然后提出预测分析来实现。他们的算法可以帮助警察在预测区域保持警惕。

总之，人工智能可以帮助我们以一种全新的方式打击犯罪。随着我们对人工智能的使用增加，我们将有更少的犯罪，因为预测分析将防止犯罪，并且随着它开始证明其价值，将开始阻止潜在的犯罪分子，这就是我认为我们可以打击这个怪物并获得优势的方式。

— -

关于:

—

关于:

Omkar Sabnis 先生是一名研究人员，与 Sukant Khurana 博士合作研究人工智能和大数据在打击犯罪中的应用。

T2 博士苏肯特·库拉纳经营着一个学术研究实验室和几家科技公司。他也是著名的艺术家、作家和演说家。你可以在 www.brainnart.com 的或 www.dataisnotjustdata.com 的或了解更多关于 Sukant 的信息，如果你希望从事生物医学研究、神经科学、可持续发展、人工智能或数据科学项目，为公众谋福利，你可以在 skgroup.iiserk@gmail.com 联系他，或者通过 linkedin 的https://www.linkedin.com/in/sukant-khurana-755a2343/联系他。

这里有两个关于 Sukant 的小纪录片和一个关于他的公民科学努力的 TEDx 视频。

[## Sukant khu Rana(@ Sukant _ khu Rana)|推特

Sukant Khurana 的最新推文(@Sukant_Khurana)。创始人:https://t.co/WINhSDEuW0 和 3 家生物技术创业公司…

twitter.com](https://twitter.com/Sukant_Khurana)

人工智能和经济不平等的加剧

原文：https://towardsdatascience.com/artificial-intelligence-and-the-rise-of-economic-inequality-b9d81be58bec?source=collection_archive---------1-----------------------

几个世纪以来，技术在美国劳动力市场中发挥了关键作用，使工人能够以更高效的方式完成日常任务。在技术进步的帮助下，生产率的提高使美国成为世界上最强大的经济体之一，定期创造成千上万的就业机会，并保持该国大量人口的就业。然而，技术进步也导致许多工人失业，因为组织机构试图通过增加使用自动化来取代低技能工作(即需要手工劳动并且可以容易地被机器取代的工作)来降低雇佣成本。

例如，1870 年，农业雇佣了几乎 50%的美国雇员。然而，根据劳工统计局的报告，截至 2015 年，农业行业使用的劳动力不到全国的 2%。尽管这个农业工人的小堡垒现在为更多的美国人甚至全球人口生产食物，但他们在美国劳动力中所占的份额已经显著下降，这说明了“技术转移所能产生的巨大影响。”【2】

农业并不是唯一的行业。许多更先进的技术形式在美国劳动力中发挥了作用，自动化了更多的劳动密集型工作，并打破了低技能工作(如收银员、总机接线员和银行出纳员)的自动化。最近，一种新的技术形式开始在市场上站稳脚跟:人工智能。顾名思义，这些计算机程序能够模仿人类思维，并执行几乎不可能以逐步方式处理的任务。这些任务包括图像识别、趋势分析、检测医疗状况等等。如果给予足够的输入和预期的输出，这种新形式的技术基本上可以做人类可以做的事情(类似于一个人如何学习一种特定的技能，即通过在一定数量的例子中反复试验)。

人工智能(AI)给劳动力中持续受到威胁的部分，即低技能和未受教育的工人带来了更紧迫的问题。目前，关于人工智能对美国劳动力的影响的许多文献在很大程度上仍然是猜测性的，因为公司才刚刚开始在日常运营中推出这种新技术的形式(因此不可能观察人工智能对劳动力的长期影响)。然而，根据历史趋势和人工智能的当前能力，人工智能的崛起完全有可能导致入门级和低技能工作(即不需要大量培训或教育的工作)的取代，在现代社会中造成专业化和非专业化工人之间更大的二分法。为了探索这个问题的所有方面，这篇文章将专注于三个主要部分，即定义什么是人工智能及其当前的能力，回顾技术进步对美国劳动力的先前影响，最后推断人工智能对美国劳动力和社会的潜在未来影响。

定义人工智能及其当前能力

在深入研究人工智能之前，重要的是在人工智能开发之前建立对编程和自动化状态的理解。计算机擅长执行一组指令，而程序员是那些经常以程序的形式将这些指令编码的人。这些程序在计算机上运行时，能出色地完成它们被告知要做的事情。例如，许多计算机科学学生编写的标准程序是生成前 n 个斐波那契数(0，1，1，2，3，5，8，13，21 …)，其中每个连续的数是它前面两个数的和(在 0 和 1 之后)。程序员可以编写一个简单的 6 行版本的程序，它可以在 10 秒内产生前 30，662 个斐波那契数。

但是如果有一个更复杂的任务，比如一个涉及物体检测和模式识别的任务，一个简单的顺序程序是不够的。

例如，考虑检测图像是否包含鸟的问题。对人类来说，这很容易；在我们的生活中，我们已经看到了足够多的鸟，所以我们知道，如果一个东西有嘴、有珠子般的眼睛、羽毛和翅膀，它很可能就是一只鸟。

然而，对于计算机来说，这是困难的，因为计算机只能逐个像素地“看到”图像，并且通常不能绘制像素之间的连接来形成一般对象的定义。从程序员的角度来看，用如何识别鸟的知识给计算机编程是一项艰巨的任务。也许这种方法会告诉计算机寻找图像中具有特定颜色的部分，这些部分符合鸟类身体的一般形状，具有另一种颜色的三角形喙，眼睛有两个黑色圆圈。但是这些标准并不包括所有不同类型的鸟类。此外，如果鸟的图像的任何部分被遮挡，计算机将无法完成任务。

这一点就是 AI 的用武之地。人工智能(具体来说是一个称为神经网络的子集)可以通过基于其接收的训练数据的统计分析和优化，以类似于人类的方式“学习”。如果开发人员可以创建一个人工智能(由接受输入并产生训练输出的人工神经元组成)，这个程序就可以使用数以千计包含和不包含鸟类的图像来训练自己。从这一点出发，经过训练的网络可以创建一个模型，该模型可以准确预测一只鸟是否出现在图像中，即使它以前没有见过这张照片。事实上，Flickr 的开发人员做了几乎相同的任务，并取得了惊人的准确率。【3】【4】

但是人工智能可以做的不仅仅是检测照片中是否有鸟。它们还可以从安装在路上汽车上的摄像头中识别物体，并指示汽车相应地移动，以避开障碍物并遵守街道标志，这为自动驾驶汽车奠定了基础。广受欢迎的拼车初创公司优步(Alibaba)等公司更进一步，开始部署自动驾驶汽车，只需要工程师监控车辆，而不是让普通司机驾驶。

此外，人工智能可以在医疗领域的生命关键应用中提供帮助，帮助放射科医生在诊断肿瘤的过程中，在它们明显表现出来之前，有时甚至在医生看到变化之前，通过 MRI 扫描捕捉它们。

被称为长短期记忆循环神经网络的人工智能变体甚至可以完成更多创造性任务，例如以一位或多位艺术家的风格创作音乐。【5】这种相同形式的人工智能也被用来为公司培训 24/7 的虚拟客户服务代表。这些在线助手从不疲倦，并从客户以前面临的数百万次对话、问题和议题的集体经验中学习。

简而言之，人工智能已经开始完成仅被认为仅对人类可行的任务，在某些情况下，如果给定足够的训练数据，人工智能可以在这些任务上击败人。虽然创造一个人工智能的过程是非常资源密集型的，但硬件价格的下降和更好算法的发展使得即使是普通的笔记本电脑所有者也可以在短短半小时内在他们的计算机上创造一个人工智能。很明显，官员们需要在未来解决人工智能在劳动力中的影响。研究人员已经证明了它的能力，这项技术终于赶上来，允许普通消费者以很少甚至没有成本的方式创造和使用人工智能。

劳动力中以前的技术进步

从历史上看，新技术在劳动力中的整合最初会取代几种形式的工作，但也会为其他领域的新型工作开辟道路。

这种模式的经典例子是 19 世纪勒德分子对新纺织技术的抗议。1811 年，一群英国织工和纺织工人领导了一场抗议活动，反对纺织厂最近发明和实施自动化织布机和针织机。这些人，现在被称为卢德分子，首先聚集在诺丁汉，摧毁了剥夺他们工匠和专门劳动者工作的机器。卢德运动蔓延到诺丁汉周围的地区，人们继续举行这些打破机器的抗议活动，直到 1816 年，直到英国政府被迫镇压该团体的任何进一步的反抗。

现在，人们用“卢德分子”这个词来描述一个反对工业化、自动化或任何形式的新技术的人。我们知道，卢德分子在抵制一场变革，这场变革将为工业革命和工厂制度的诞生奠定基础，工厂制度将雇佣数百万个人，并避免对体力劳动的极度专业化劳动的需求。但是，随着新技术的进步，如何知道是否会有替代工作来帮助那些被技术本身取代的人呢？要回答这个问题，唯一的方法是先看看以前的趋势，然后从那里进行推断。

19 世纪的技术变革降低了对专业和高技能工人的需求，就像卢德分子的情况一样，导致了偏向低技能的技术变革。这种技术趋势在 20 世纪末随着消费者可以使用的计算能力和互联网的出现而转变。这种变化导致了有技能的个人的生产力和福利，导致了以技能为导向的技术变革。

White House report on AI

白宫关于人工智能、自动化和经济的报告通过几个例子说明了这种变化是如何体现的，指出制造业就业岗位的减少导致对受教育程度较低的工人的劳动力需求疲软。然而，随着技术不断融入工作场所，“从事抽象思维、创造能力和解决问题技能的人”的机会越来越多。【6】

在制造工作的计算自动化的情况下，当公司可以关闭那些工厂并搬迁到更大的集中设施时，它们就越来越没有动力将更偏远地区的小工厂纳入人力员工。在一个特殊的例子中，研究人员确定了几个选择用机器代替体力劳动者的工业设施。在跟踪这些被解雇工人的就业模式十年后，他们发现这些工人的收入相对于他们以前的工资仍然低 11%。【7】这一发现表明，许多失业工人的能力下降，无法将他们现有的技能与新的、受欢迎的工作相匹配，或者接受再培训。然而，即使工人可以在其他工作中保持就业，这些流离失所者是否有工作仍存在很大疑问。

纵观历史，许多发达经济体都曾追随“创造性破坏”的潮流，这一术语是由 20 世纪经济学家约瑟夫·熊彼特提出的，用来描述“新的生产单位取代过时的生产单位”的现象研究人员已经多次证明了这种趋势的存在，最重要的是由 Davis，Haltiwanger 和 Schuh (DHS)发现，在 1972-1988 年的某一年中，10%的工作岗位被取消，但都被新的工作岗位所取代。【9】Foster、Haltiwanger 和 Krizan 在 2001 年进行了这项研究，并有证据表明，这些就业机会的破坏和创造周期最直接地归因于技术(在他们对 DHS 的数据进行了行业细分之后)。 [10] 然而，兰德尔·柯林斯指出，那些倾向于采用熊彼特式的观点来看待新技术对劳动力的影响的经济学家们“仅仅依靠对过去趋势的推断来论证新产品创造的就业机会将会弥补旧市场被破坏而失去的就业机会。”迄今为止，以前的经济数据确实支持熊彼特的理论，但是熊彼特自己提出了“创造性破坏”的概念，而当时还没有计算机这个概念。直到最近，劳动力的大量计算机化才真正威胁到专业人员的完全替代。

柯林斯还详细阐述了他的观点，指出工作场所自动化集成创造的新工作需要更多的专业化和正规教育。这些工作包括 IT 服务、网站开发和咨询服务。柯林斯解释了他之前的观点，即未受过教育的人无法获得新的工作，并指出最近对职业再培训计划的需求增加，以培训非专业工人掌握新技能。然而，有一个绝对的极限，在这个极限上，许多人不再可能专攻某一特定技能。例如，软件工程，一个随着编程语言的发明才出现的工作，需要在正规大学接受至少四年的培训。实际上，在一个变得越来越自动化的社会里，熊彼特的观点不能被认为是真实的，因为以前的趋势与未来将发生的事情没有关系。人工智能可能会创造新的行业，但这些行业是否能为流离失所者提供可行的工作前景还有待观察。

人工智能在劳动力中的预测

人工智能对经济的现状构成了很大的威胁；然而，将这种新形式的技术引入市场的大部分后果尚不清楚。争论的主要问题是，在公司选择将人工智能融入劳动力的范围内，以技能为导向的技术变革是否会继续。

牛津大学的卡尔·弗雷和迈克尔·奥斯本认为人工智能技术可以取代近 47%的美国工作。【12】此外，经济合作与发展组织强调了最有可能在短期内得到自动化显著帮助的各类员工的目标领域风险，指出在未来十年中，40%的高中或以下学历的工人将因技术进步而面临某种形式的失业。这种工作岗位的转移可能会给这些人留下很少的专业选择。然而，在试图教育和培训相当一部分美国劳动力使他们在各个领域专业化，以便他们在未来有良好的就业前景方面，存在着多种问题。

虽然在过去，一部分人完全有可能从一份低技能工作转向另一份只接受了最低限度培训的工作(正如大萧条时期的工作教育项目所见)，但让 47%的人口接受进一步的大学教育多少有些不合理。实现这一目标的唯一途径是获得大量政府资金的帮助。柯林斯指出，随着“与计算机工作相比，人类创造的就业机会数量稳步下降”，政府将有必要支持大量失业人口。【13】美国在 20 世纪上半叶通过实施凯恩斯福利国家来解决大量失业问题，以维护资本主义制度，尽管这一制度受到政府的支持和控制。在政策方面，政府可以向公司征税，以雇佣人工智能实施人员，尽管这一措施将是暂时的，因为人工智能的成本会随着时间的推移而下降。

在大规模失业的情况下，实施普遍基本收入可能是缓解社会问题的一个解决办法。然而，根据柯林斯的说法，这种方法甚至让发达国家面临“国家财政危机和富人与依靠政府维持基本生活的人之间的分裂”社会中的这种二分法很可能“比当前资本主义市场中的任何东西都要大”，尤其是当依赖的人口无法维持就业的时候。此外，这一体系剥夺了依赖个人的购买力，“同时削弱了消费者市场，使资本主义不可持续。”【15】

柯林斯非常清楚地表明，如果人工智能的使用导致大量失业，就不可能有今天在美国所知的资本主义经济形式。普遍基本收入虽然是为全社会人民建立生活体系的一种极好的手段，但却无法维持当前的经济体系，甚至进一步扩大了社会两个阶层之间的工资差距，即那些尚未被人工智能取代工作的人和那些已经被人工智能取代工作的人。这种推断的证据可以从美国福利制度的现状中看出。对于长期失业的人来说，他们享受福利的可能性要小得多，这导致这些人的购买力下降，与他们有工作的同龄人相比，他们的经济地位也更低。【16】劳动力中人工智能导致的失业增长可能会成为失业的驱动力，并导致对政府援助计划的依赖。这种依赖可能会加剧失业者和那些工作过于专业化而人工智能无法取代的人之间的经济不平等。

然而，人工智能将导致大规模失业的观点并不是唯一的潜在观点。David Autor 认为，在人工智能集成之后，可能会有两个群体的个人在经济繁荣中增长:拥有公司并从事专业劳动的人，以及每天与人类互动的工人(例如护士)。他的信念是，“即使人工智能能够处理复杂的模式，分析比人类更准确的数据，它也缺乏与其他人交流和解释其决策过程的能力。”对人工智能在工作场所中的角色的这种观点，将允许合理程度的向上流动，并允许维持现有的中产阶级和资本主义社会的可能性。

当然，柯林斯和奥托尔对人工智能在工作场所中的作用的看法将因有关技术在劳动力中的作用的几个因素而异，但要解决的一个关键点是，面对人工智能，如何保持美国当前存在的阶级结构的一些表象。

结论

如果你能从这篇论文中总结出什么，那就是:人工智能对当今已知的劳动力结构构成了威胁。然而，许多人只能将这种危险的影响理论化。在柯林斯关于人工智能的观点中，人工智能取代工作的威胁可能导致失业工人和那些工作过于专业化而无法取代的工人之间的灾难性分化，最终导致基本收入的建立和政府在维持福利国家中的更大作用。奥托尔的理论同意人工智能将取代低技能劳动者的工作这一事实，但预测依赖于重要人类互动的工作将反而上升，为那些被人工智能取代的人提供再培训的机会。根据历史趋势，很明显，新的工作行业可以由技术创造，作为新的工作来源来取代被技术本身取代的工作。然而，对于人工智能是工作竞争对手的市场来说，这些工作对失业工人的可获得性是首要关注的问题。过去的历史趋势和人工智能的现状相结合，表明有必要为低技能工人创造新的、可获得的行业，以避免今天看到的经济和社会结构的广泛变化。

总体而言，人工智能在短期内可能会成为一种威胁，但完全有可能的是，人工智能的集成可以通过新的行业创造无数的就业机会。为了遏制人工智能对经济和社会的潜在影响，官员们有必要制定政策，教育那些工作可能受到人工智能威胁的个人，并限制人工智能在易受影响行业的整合。这项技术可以在人类水平上完成惊人的壮举，避免在现代世界进一步探索它的能力是错误的。然而，必须负责任地整合人工智能，以避免在不久的将来出现经济不平等。如果以正确的速度引入，这种新形式的技术可以以独特的方式帮助人类，并从技术、经济和科学的角度引领人类的进一步发展。

参考书目:

【1】主要行业部门就业情况。(未注明)。检索于 2017 年 4 月 26 日，发自 http://www.bls.gov/emp/ep_table_201.htm

柯林斯，R. (2014)。中产阶级工作的终结:不再逃避。在资本主义有未来吗？(第 39–51 页)。纽约州纽约市:牛津大学出版社。

【3】介绍公园或鸟。(2014 年 10 月 20 日)。检索于 2017 年 4 月 26 日，来自http://code . Flickr . net/2014/10/20/introducing-Flickr-park-or-bird/

【4】医学博士泽勒&弗格斯，R. (2014)。可视化和理解卷积网络。计算机视觉——ECCV 2014 年计算机科学讲座笔记，818–833。doi:10.1007/978–3–319–10590–1 _ 53

【5】约翰逊博士(2015 年 08 月 02 日)。用递归神经网络作曲。检索于 2017 年 4 月 26 日，来自http://www . hehedria . com/2015/08/03/composing-music-with-recurrent-neural-networks/

【6】人工智能、自动化和经济(第 8-26 页，Rep .)。(2016).华盛顿特区:总统行政办公室。

【7】戴维斯，s . j .&沃希特，T. V. (2011)。衰退和失业成本。布鲁金斯经济活动论文，2011 年 (2)，1–72 页。doi:10.1353/eca

【8】什么是创造性破坏和颠覆性创新？(未注明)。创造性破坏和共享经济。doi:10.4337/9781786434335

【9】戴维斯，S. J .，哈尔蒂旺热，j .，&舒赫，S. (1993)。小企业和创造就业机会:剖析神话和重新评估事实。美国国家经济研究局工作文件系列，1–49。

哈尔滕，C. R .，迪恩，e . r .&哈珀，M. J. (2001)。生产率分析的新发展。芝加哥:芝加哥大学出版社。

【11】柯林斯 40

【12】弗雷，c . b .&奥斯本，文学硕士(未注明)。就业的未来:工作对计算机化有多敏感？检索自http://www . Oxford Martin . ox . AC . uk/downloads/academic/The _ Future _ of _ employment . pdf

【科林斯 13】41

柯林斯 50

【15】柯林斯 51

【16】梅尔科森，m .&萨雷拉，J. (2004 年)。失业者的福利参与和福利依赖。人口经济学杂志，17* (3)，409–431 页。从 http://www.jstor.org/stable/20007919取回*

【17】奥特尔博士(2014)。波兰尼悖论与就业增长的形态。马萨诸塞州剑桥:美国国家经济研究局。

人工智能应用:数据科学与采购

原文：https://towardsdatascience.com/artificial-intelligence-applications-data-science-meets-procurement-part-1-ef105b2dafa2?source=collection_archive---------1-----------------------

采购职能是组织中最重要的职能之一，但往往不被人们所重视。不知何故，它很少拥有与营销、金融或科技等更时髦的同行相关的浮华和魅力。可能出于同样的原因，与其他集团相比，它在采用尖端技术方面经常落后。虽然创收战略和计划最引人注目，但重要的是要认识到成本节约可以对底线和利润产生完全相同的影响。

对于外行来说，采购职能处理的是购买运营一家公司所需的每一件物品的端到端流程，从回形针到重型机械，从办公室小吃到运输提供商，从计算机硬件到大型数据中心设备。换句话说，除了人员成本(即薪水和工资)之外，公司 P&L 中与“经营成本”相关的所有成本都属于采购组织的权限范围。

采购的角色有几个组成部分——它不仅需要采购所有这些大大小小的东西，还必须以最有效的方式完成。这包括为每件商品寻找最佳质量和最佳价格、通过多个参数评估供应商、在商品层面估计需求、优化库存管理、规划物流以及跟踪更广泛的市场动态。

想想当你需要做出一个重要的购买决定时会发生什么，比如买一台新电视。大多数人会花大量的时间进行研究，比较功能，获取多个报价，与不同的卖家交谈，与朋友比较笔记。想象一下，对大量的商品都这样做！

现在让我们回到采购中技术采用的话题，尤其是数据相关技术。迁就我一下，试着回答我以下的问题:

在过去的一个月里，你在外出就餐或外卖上花了多少钱？
这个数额是大于还是小于你上个月的饮食花费？差多少？
你花了多少小费和税？
在此期间，您在咖啡或甜点上花费更多吗？多了多少？
你从哪里得到的每毫升咖啡的最佳价格？
你花了多少现金和信用卡？

这些都是非常简单直接的问题，不是吗？但是准确回答这些问题会有多难呢？我的猜测是，相当困难！你需要收集上个月和上个月发生的所有费用的记录。它们可能在不同的地方——收据、信用卡账单、银行对账单，甚至你的记忆。它们肯定是不同的格式。你可能需要在收据和报表之间做一些三角测量。可能有不同的名称，例如，所有的馅饼、蛋糕、冰淇淋等等。在“甜点”下，等等。

现在，将这一比例扩大到数以万计的商品(这通常是一家中大型公司购买的独特商品的数量)。跨越城市、国家、大陆；跨越成千上万的供应商；跨越数百万行个人交易；跨越不同的语言；跨越不同的术语和标准，跨越数亿或数十亿美元！

这就是采购职能部门要处理的事情。这就是数据如此重要的原因。这就是为什么利用人工智能或数据科学是绝对的，明确的关键。不幸的是，这最后一块是大多数采购组织仍在追赶的地方。

我们都知道 ERP(企业资源规划)系统——大型的、通常是单体的系统，使组织能够管理其核心业务流程，如采购、库存、销售、会计、人力资源等。它们已经存在了近三十年，在帮助公司获取数据方面发挥了关键作用。过去，采购职能处于采用传统 ERP 系统的最前沿，但随着技术的发展，他们一直在努力实现下一次飞跃。

虽然采购从业者可以访问大量数据，但挑战在于这些数据是众所周知的脏数据。它来自具有不同结构、术语和粒度的系统(不同的 ERP 平台、遗留系统、甚至 excel 表)的混合体。即使在源系统已经简化的情况下，ERP 数据也充满了问题——信息缺失、信息不正确、人工输入错误等。随着业务的发展，这些错误会成倍增加，并迅速扩大，以至于对数据进行的任何分析最终都变成了“垃圾进—垃圾出”的情况。

因此，最终发生的情况是，采购经理最终需要花费大量的时间来处理这些数据，试图弥补一些他们可以用来改善事情的洞察力。他们几乎没有时间去真正进入市场，抓住潜在的利益。

进入人工智能，等式完全变了！在采购中利用人工智能的深思熟虑的策略可以为采购职能带来巨大的投资回报。他们可以通过复杂的机器学习算法来解决数据争论。他们可以利用自然语言处理(NLP)技术来获取隐藏在数据捕获系统的自由文本字段中的珍贵信息，这简直是一座金矿！他们可以日复一日地获得关于节省成本和其他机会的见解，这样他们就可以专注于追求这些目标，并实现底线、硬美元的影响。

在下一篇文章中，我将关注人工智能可以帮助采购从业者实现的特定价值驱动因素。采购之所以成为人工智能的一个非常有趣的领域，是因为它是如此普遍相关——所有公司，无论规模、行业、地理位置如何，都需要不断优化他们花钱的方式和地点！

人工智能像魔术一样

原文：https://towardsdatascience.com/artificial-intelligence-as-magic-e8ba4b3165ea?source=collection_archive---------4-----------------------

创新或者死亡。成长或枯萎。这就是我今天在人工智能领域的感受。2008 年的衰退性失业在 2010 年达到顶峰，现在已经基本结束。现在这个世界充满了增长。

Source: advisor perspectives and inspired by an article on automation

过去一年，我们的咨询业务一直在从事许多简短的人工智能咨询业务，以帮助公司将最好和最新的东西纳入他们的产品和服务。我们不能永远做同样的表演。与普遍的看法相反，我认为在某个时候，人工智能解决方案架构会变得更容易。在这种情况下，人工智能领域的人才将会增加，这是一件好事。但对我们来说，这意味着我们做的高端咨询利润会更低。由于像 keras 这样的库，创建多模型人工智能的过程也将变得更容易，这将允许从预训练的模型中进行转移学习，以及自动部署最常见类型的神经网络模型(见此)。作为一家 AI 公司，我们要么创新，要么死亡。

那么我们一直在做什么来赚钱呢？以下是到目前为止我们咨询收入来源的高层次细分，按行业划分。似乎我们主要做电子和云人工智能的东西。没有许可费，没有经常性收入。我们第一年的大多数项目都在 1.5 万到 3 万美元之间。

Our consulting revenue by sector, since 2016–07–13. I got this from our CRM, not the accounting software, and so there may be some errors in this summary because of small stuff, like taxes in Europe, or whatever. Sue me.

我们转向产品和更大合同的步伐非常缓慢，但我们最终还是做到了。我们对转向的犹豫是合理的。我们对写没有任何进展的 RFP 不感兴趣。相反，我们非常开心，专注于为客户创造价值，飞到凉爽的地方，壮大我们的团队。我们通常对从引进到签订合同之间有很长时间的项目不感兴趣。我们是一群受过高等教育的书呆子，来自医疗设备背景，创新进展缓慢，所以我们想抓住今天。我们创造了一个漏斗，用项目填满它，然后勇往直前。在之前的文章中，我写了更多关于我们如何在到达这里的内容。

我们在建立这个企业的过程中度过了美好的时光，但每个人都必须成长。

“成年人只是变老的孩子”

Reddit 用户 thetreece

我们不能只是继续在咨询仓鼠轮中奔跑，尽管这可能很有趣。我们决定了我们转向产品和更大规模服务的特点。

从现在开始我们不会做的事情:

基础科学:没有应用的牛逼科技。我们是高级工程师。我们制造东西。我们想赚 100 美元，而不是拿诺贝尔奖.
基础编码:平凡的技术，却有着令人敬畏的应用。没有竞争壁垒。如果我要做“愚蠢”的代码，为什么我有 ML 的博士学位？我们接受了太多的教育，无法修补前端的东西。即使我们过去做 GUI，我们已经采取了前端工作外包的立场，无论是对我们内部还是对客户，我们不认为我们通过编写 GUI 代码增加了价值。快速推荐:马可迪鲁卡。我们不这样标记设计工作。我们只是把它传给我们喜欢的人。我最好的 GUI 没有 Marco 最丑的好。
约会超级名模有两个步骤。第一步:找超模。第二步:和超模约会。问题是细节。我们不想花很多时间做一些最终成为证明 P=NP 的特例的事情。所以，我们把自己限制在我们相信自己能够制造的东西的范围内。不是说我们不接受大的挑战。我们只是不冒愚蠢的风险。

从现在开始我们要做什么:

简单的用户体验(UX): 我们正在为令人敬畏的人工智能构建简单的界面。当事情像那样运作时，它看起来就像魔术一样。我觉得所有的 AI 都应该感觉像魔术。你应该把系统设计成以一种用户理解但没想到可能的方式工作。
深度学习神经网络:我们的利基市场是深度学习神经网络。这就是我们的价值所在。如果我们构建通用软件，我们还不如在软件工厂工作。所以，我们专注于疯狂的高端产品。
经常性 B2B 收入:企业乐于为深度学习付费，他们持有最有趣的数据集。他们也比消费者有更多的钱可以花。我们正在开发API、基于订阅的服务，以及产生许可费的软件库。这三条新的途径为我们拓展了一些很酷的可能性。
大数据和云:我们在数据中心的物理机箱和物理硬件组件(电路板、电路、外壳、焊接)上做了太多工作。我们的 digikey 账户比人工智能咨询公司活跃得多。所以，我们专注于我们的云游戏。特别是云端的深度学习。这是我们希望向客户交付许多数据科学团队无法实现的结果的地方。
手机:我们不做手机应用，但我们与做手机应用的开发者合作。这个功能是一个很好的特性。我们都使用智能手机，因此具备移动功能非常重要。我会不假思索地推荐under labs . ca他们的 CTO 是我大学时的好友，他们的口号说明了一切:“我们开发酷 sh * t”

这不是某种宣言。我们实际上正在做这些事情，在我写这些文字的时候，我们正在做这些事情。本周我们将参加多伦多机器学习峰会。除了我们通常的咨询工作之外，下面是我们一直在做的一些事情:

SageTea 软件合伙 ( 正文转软件深度学习)。我们的第一笔软件许可销售已经是囊中之物了。后续的销售兴趣相当大。
另一个合作伙伴在讨论 ( 【审查】Kit 深度学习？)正在等待法律签字同意。
Genrush.com 进展顺利。我们这个项目的目标是通过向销售团队提供线索来产生经常性收入。整个方法使用机器学习来解决问题。这仍然是一项正在进行的工作，但它肯定会朝着赚第一个美元的方向发展。

所以，我们越来越不是一家初创企业。我们在成长，在做长远的思考和规划。我们正在创造奇迹。激动人心的时刻！

在我离开之前，本周有几件事引起了我的注意。AWS 中新的 p3 实例已经发布，树莓 Pi 4 将通过谷歌的插件支持更快的深度学习。一切都在移动。

如果你喜欢这篇关于我们如何重新聚焦人工智能咨询的文章，那么请尝试一下 clap 工具。轻点那个。跟着我们走。在脸书和推特上分享。去吧。我也很高兴在评论中听到你的反馈。你怎么想呢?

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

如何给人工智能项目定价
如何聘请 AI 顾问
人工智能:让你的用户给你的数据贴上标签

人工智能:后果

原文：https://towardsdatascience.com/artificial-intelligence-consequences-bd4dc4d537da?source=collection_archive---------5-----------------------

AI 要改变世界。

像自由市场一样，人工智能是一个无情的优化器。然而，就像市场看不见的手一样，AI 也会犯错。市场制造泡沫，泡沫破裂，崩盘修正为理性估值。我们知道自由市场是一个不完美的优化器，但它是迄今为止 T2 最好的优化器。一般来说，当你缩小视野看大图时，市场前进的方向是向上向上。

Global output through human history. Raw data from here. Click for interactive chart. Both axes are on a log scale.

AI 和市场经济学是两个优化器。它们在股票和货币交易机器人中相交。如果我们想保持全球指数增长趋势，我们需要像人工智能这样的颠覆性创新。然而，进步不是零和游戏。相反，你知道的事情越多，你不知道的事情的周长就越大。在之前的文章中，我提到了成长型投资和人工智能之间的联系:恐惧。对人工智能能力的恐惧导致了对它的贪婪。但正如自由市场在一些任务上不太擅长，比如创新(政府拨款和军事研究给了我们互联网，甚至是 AI 本身，所以我们也可以看到，AI 并不擅长所有问题，至少现在不擅长。像自由市场一样，人工智能也有一套可预测的失败模式，包括过度拟合、不良的精度-召回权衡、从错误的数据中学习，例如偏差、针对错误的目标进行优化等。

然而，当处理正确的问题时，人工智能是非常有效的。机器学习回归或分类是一回事。这是那种令人讨厌的计算机东西，就像摩尔定律一样，我们期望变得更好，不管人工智能如何。但是我们能用 AI 做些什么才是真正意想不到的呢？嗯，有很多例子，包括风格转移，思路对比，从文章正文生成标题(摘要)，机器翻译。我们有时会忘记，简单地识别图像中的对象曾经是科幻风格的人工智能，现在它只是卷积神经网络，通常经过预先训练，位于 API 后面。一旦你知道某件事情解决了，它似乎会在人类的头脑中很快从魔法变成逻辑。

人工智能揭示了新的可能性，这些可能性没有预料到会这么快出现。这是一场知识和自动化的淘金热。这一切都意味着我们人类将面临很多破坏，而且并不是所有的破坏都是好的。

我们人类在大脑中模拟机器将做什么，这个过程将变得很奇怪。

以一台坏掉的自动售货机为例。想象一下，走向自动售货机，放入你的信用卡，按下苏打水选择按钮，然后意识到自动售货机没有分发饮料。在这种情况下，你的大脑会思考自动售货机是如何工作的，它会对可能出现的问题进行建模。你按按钮的力度够大吗？也许只是机械故障按下了开关。读卡器工作了吗？也许机器和互联网之间的通讯中断了。也许你的信用卡交易被拒绝了。你可以问这些问题，因为你在直观和物理层面上了解了自动售货机的部件是做什么的。

然而，当我们把简单的自动售货机换成聊天机器人自动售货机时，它会把你的订单作为语音命令，并分发饮料——或者在这种情况下，它无法分发饮料，更多的部件开始发挥作用。在这个人工智能自动售货机的场景中，你有一整套可能出错的新东西。机器听到你的请求了吗？它是否正确地将你所有的话语转换成文本( STT )？文本被转换成你想要的动作了吗( NLU )？人工智能明白你付钱了吗？除了你头脑中的机械和电子模型之外，还有一层全新的可能出错的东西。现在，你的大脑将不得不模拟人工智能内部产品如何“工作”。

AI 会创造更差更烦人的用户体验。然而，它也开启了新的更好的用户体验。很简单，创建一个聊天机器人，在汽车餐厅询问快餐订单。蒂姆·霍顿订单收集系统有人吗？

由于许多工作都需要自动化，人类将需要掌握更多的计算机交互技能。如果我们的新工作是机器人霸主，让我们确保我们能够撼动这一角色，并继续增加我们共享经济的总价值。

我最近在 LinkedIn 的一个帖子上讨论了所有人都需要学习如何进行基础编程。如果我们想对人工智能保持乐观，那么我们需要人类拥有更强的技术技能。我们不能指望永远保持我们的自动化友好型工作。T2 在 1899 年存在的工作现在已经很少了。那么，AI 会来接替你的工作吗？如果你的工作很容易通过人工智能实现自动化，那么是的，会的。新技术会带来后果。但是你会，就像我们在整个人类历史上一样，超越自我。

学习编程。去w3schools.com免费上课。或者试试 udacity 。

如果你喜欢这篇关于人工智能的一些含义的文章，那么请尝试一下 clap 工具。轻点那个。跟着我们走。去吧。我也很高兴在评论中听到你的反馈。你怎么想呢?

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

如何给人工智能项目定价
如何聘请人工智能顾问
人工智能:让你的用户给你的数据贴上标签

人工智能——去神秘化

原文：https://towardsdatascience.com/artificial-intelligence-demystified-a456328e193f?source=collection_archive---------0-----------------------

人工智能(AI)可以说是我们这个时代最热门的技术话题。人工智能的文章、纪录片和讨论充斥着每一种媒体:大众的、技术的、社会的和政治的。它吸引了所有人的想象力、幻想和情感。尽管有如此多的信息，还是有必要澄清人工智能的名称和基本概念。这可能是由于媒体炒作，不同的定义，技术术语和科幻小说中关于人工智能的图像。本文试图为非技术读者澄清围绕人工智能的迷雾。

什么是人工智能(AI)？

我喜欢维基百科对人工智能最简单的定义:

人工智能(AI)是机器展现出来的智能。

AI 由两个词组成:人工和智能。“智力”一词描述了人类(和动物)的认知功能，即意识到各种情况，从中学习，并运用所学知识做出决策和解决新问题。它包括一个人的逻辑、理解、自我意识、学习、情感知识、计划、创造力和解决问题的能力。一个非常聪明的人能够快速地完成所有这些工作，并应对各种各样的情况和问题。智力通常被认为是人类(和其他生物)的。人工智能通常被称为其他名称，如机器智能、机器认知或增强智能。它们的意思都一样。

术语“人造的”指的是机器——或者非人类和非生物的。通俗地说，“人工智能”一词是指机器模仿人类与其他人类思维相关的“认知”功能，如“学习”和“解决问题”。

我们的大脑有超过 1000 亿个神经元，每个神经元都与数千个其他神经元相连，是已知宇宙中最复杂的物体。认知是它最复杂、最高级的技能之一。认知是通过思想、经验和感觉获得知识和理解的心理活动或过程。它包括决策和解决问题。Linda Gottfredson 教授(德勒威尔大学)说得很好:“认知是从经验中学习和借鉴、抽象思维、领悟复杂思想、推理、计划和解决问题的能力。”

你的个人电脑是智能的吗？

许多家用电器，如洗衣机、洗碗机、空调，甚至个人电脑，在自动执行复杂的逻辑任务的意义上，似乎是智能的。他们聪明吗？有些人说不。我们也可以说，是的。然而，这种智能是“编程智能”——因为智能不是源于机器内部，而是人类开发人员将其编程到机器中。人类已经创造了允许这些机器展示智能的算法(逻辑和步骤序列)。许多机器人在工厂执行复杂的任务，如焊接和组装，也是根据人类编程的算法运行的。

算法——智能的关键

算法的执行在展示智能方面起着重要的作用。然而，与人类在机器中的编程智能相比，人工智能(AI)能够通过“机器学习”的过程来创建自己的算法。当我们决定购买谷歌股票还是微软股票，或者去马略卡岛度假还是巴哈马群岛度假时，我们人类也会在大脑中执行算法。每个人都通过他们的主观学习和生活经验发展出他们独特的处理生活的算法——这就是为什么我们在面对类似的选择时经常会做出不同的决定。人工智能能够学习和开发自己的算法，并根据自主开发的算法做出决定——就像人类一样。学习和开发自己的算法是人工智能的独特之处。

请看:人工智能机器如何学习——就像人类一样。

人工智能自动化决策

从功能上来说，人工智能是一个针对特定专业领域的自动化决策系统，如医疗、税收、投资、翻译、语音识别或人脸检测。人工智能在其专业知识范围内为任何给定的新情况找出最佳答案或决策(成功概率最高)。做出更好的决定是商业和私人生活成功的关键。人工智能正在迅速降低各行各业做出更好决策的成本和时间。

参见:人工智能促进更好的决策。

人工智能和机器人

人们经常混淆机器人和人工智能。两者截然不同，但又相互关联。机器人是一种有时模仿人类形式进行某些活动的机器，但 AI 本身是机器人内部的算法逻辑。AI 是大脑，机器人是它的身体。机器人面临两个挑战:物理和逻辑。身体:使身体按照预期活动的要求行动和移动。逻辑上:人工智能部分(机器人大脑)必须自动计算并决定做什么，以应对新的输入和情况。

人工智能不需要一个肉体来表达自己。人工智能可以被视为一个信息处理黑匣子，其中包含了学习到的认知(专业化)。输入是表示新情况或查询的数据流。输出是用于决策支持和期望行动的信息。为了说明人工智能本质上是一种不需要身体的信息服务，下面是一些人工智能如何嵌入具体服务的例子:

Structure of current AI applications

AI 的进化

自上世纪中期艾伦·图灵(Alan Turing)时代以来，我们一直在探索人工智能的话题。他在 1950 年开发了著名的“图灵测试”，以测试机器表现出与人类同等或不可区分的智能行为的能力。自那以后，人工智能的概念没有太大变化，但实现它的方法却变了。由于机器学习和深度神经网络的进步，过去 5-10 年取得了重大进展，导致了我们今天都可以体验的一系列服务(如上所示)。像任何其他技术一样，人工智能将从解决简单的任务，如理解我们的讲话，发展到更加复杂的问题。进化分三个阶段进行描述。我们目前正处于第一阶段的开始。

1 人工狭义智能(ANI) :在这个阶段，人工智能专注于一个特定的领域，如翻译、人脸识别、下棋、诊断癌症、解读放射图像、股票投资等。在这里，人工智能已经被训练在一个，而且仅仅是一个领域中发展决策。图像识别人工智能对一盘棋毫无头绪。可以把 ANI 比作雇佣一个顶尖的专家来做一件比其他任何人都好的工作。目前，人工智能的所有应用都处于 ANI 阶段。在未来 3-5 年内，许多新产品和服务将集成 ANI 功能，提供独特的客户价值，这是一个巨大的差异化商机。

2 人工通用智能(AGI) :下一阶段是 AGI，这里的系统拥有一般水平的智能。AI 系统在所有方面都像人类一样聪明，可以执行人类可以执行的任何智力任务。一个成年人获得了丰富的知识和各种各样的技能，并且能够以多种方式组合使用这些技能。匹配这一点比在一件事情上获得专业知识要困难得多。还没有人创造出 AGI。人工智能专家对实现 AGI 的平均预测是在本世纪中叶左右。更乐观的预测是到 2030 年。

3 人工超级智能(ASI) :人工智能专家尼克·博斯特罗姆(Nick Bostrom)将超级智能定义为“在几乎每个领域都比最优秀的人类大脑聪明得多的智力，包括科学创造力、普遍智慧和社交技能。”好得多可能意味着 10 倍、1000 倍或 1000000 倍。人类无法想象这对我们的生活和社会的影响。专家预测实现 ASI 是在本世纪下半叶。当智能机器自己开始设计它们的下一代版本时，进展可能会非常快，呈指数级增长。这是目前科幻小说的素材。

与艾同居

在过去的二十年里，互联网和智能手机已经越来越多地融入到我们的生活中——几乎不为人知地悄悄进入，带来了巨大的好处。只有当我们回顾和反思时，我们才意识到他们所带来的巨大变化。同样，人工智能将悄悄进入我们的生活，以我们无法想象的方式改变我们的业务和生活方式。AI 不是人类的替代品，而是一个技能互补的优秀队友。

Complementing AI and human skills

艾是我们的队友

总之，人工智能本质上是一台能够非常有效地执行理性技能的机器，如学习、决策和解决问题，这些技能传统上只与人类相关联。它们对我们生活中复杂决策的自动化大有裨益。重要的是要记住，人工智能不是人类的替代品，而是一种帮助我们的工具。人类和人工智能将学会作为队友合作——每个人都带来自己独特的技能，创造一个胜利的组合。

关于人工智能的更多信息:人工智能&将人工智能转化为商业

https://www.amazon.com/AI-Translating-Artificial-Intelligence-Business/dp/1521717206/

联系人 : 沙拉德·甘地，克里斯蒂安·埃赫尔，www.ai-u.org

阅读我们的其他文章:

人工智能机器如何学习——就像人类一样

马上从人工智能开始！

人工智能促进更好的决策

人工智能解释第 1 部分

原文：https://towardsdatascience.com/artificial-intelligence-explained-part-1-introduction-45f0b3243553?source=collection_archive---------5-----------------------

我想写一些帖子，为像我一样不是数学或编程天才的人解释人工智能背后的“魔力”。

这是系列文章的第一篇，假设你对人工智能一无所知。

什么是人工智能或 A.I？

谷歌对人工智能有一个很好的定义:

能够执行通常需要人类智能的任务的计算机系统的理论和发展，例如视觉感知、语音识别、决策和语言之间的翻译。

然而，人们经常有一种误解，认为所有的人工智能都是人工智能。

人工通用智能

什么是人工通用智能？再说一次，谷歌有一个非常明确的定义:

人工通用智能(AGI)是机器的智能，它可以成功地完成人类可以完成的任何智力任务。

从本质上说，AGI 是你在电影中看到的人工智能，也就是通常对人类怀有敌意的完全有感情的生物🔫 🔪 🔥。

不管是好是坏，AGI 根本不存在😱。从写这篇文章的时候起，就不存在人工智能这种东西，它在与人类相似的意义上是有知觉的。

但近年来有所超越的是弱 AI 或窄 AI ，顾名思义，弱而窄(到一定程度)。

弱 AI /窄 AI

我喜欢将狭义人工智能(相对于弱人工智能，我更喜欢这个术语)定义为能够执行一项单一(或狭义)任务的人工智能，例如识别猫和狗图像之间的差异，或将声音转换为文本。

与 AGI 不同，狭义人工智能是今天的现实。iPhone 上的 Siri 是多个狭义人工智能组合的一个例子，例如语音到文本等，它连接到云中的数据库。然而，Siri 根本不知道她的周围环境，也没有任何感官或感觉。像 Siri 这样狭隘的 AI 往往容易被骗。

狭义人工智能的更多示例包括:

谷歌 AlphaGo 击败世界最佳人类围棋手
深蓝在常规时间控制下击败了一名世界象棋冠军
93.9%准确率的谷歌字幕图片

许多狭义的人工智能都属于机器学习的范畴，我们将在这篇文章的剩余部分探讨这一点。

机器学习

机器学习是人工智能的一个子集，可以广义地定义为机器(或计算机)学习分析特定的数据集。解释机器学习做什么的最好方式就是举个例子。

假设一个房屋拍卖数据集包含每次销售的以下信息:

房子的售价
整个房产的大小

在这种情况下，机器学习可以用于开发一种算法，可以根据房产的大小预测房屋的销售价格。但是直觉上这是如何工作的呢？我们可以通过首先可视化数据集来找出答案。

因为我们的数据集包含每笔房屋销售的两个变量，所以我们可以通过在图上绘制来可视化信息。

在高中，你可能学过线性回归，或者简单地说，一条最佳拟合线。仅仅看这个数据，就可以看出它遵循了一个趋势，房价(在一定程度上)与房产面积成正比，或者换句话说，房产面积越大，房子的成本越高。

直观上，机器学习算法所做的是试图在给定的数据集中找到最佳拟合线，然后使用最佳拟合线进行预测。

因此，我们的算法将首先努力找到最佳拟合线:

然后，如果我们给它 0.55 英亩的输入，机器学习算法将从 x 轴上的输入值 0.55 开始绘制一条线，直到它与最佳拟合的线相交，然后它将跟踪一条线，直到它与 y 轴相交，以产生对 0.55 英亩财产大小的1350 万美元的预测。：

请注意，一旦算法找到了最佳拟合线，它就可以对任何英亩大小进行预测。

这实质上是机器学习算法如何学习进行预测。直觉上，这似乎很简单，对吗？🎉

除了一些警告…

机器学习挑战

虽然前面的例子看起来很简单，但机器学习面临以下挑战:

数据集大小
维度问题
非线性
计算能力

让我们逐一剖析它们😎

数据集大小

正如我们在前面的例子中看到的，在机器学习算法可以做出预测之前，它需要一条最佳拟合线(或某种关系)。不幸的是，找到最合适的路线可能是一个相当大的挑战。

我们将讨论如何在机器学习中精确地计算最佳拟合线，但一般来说，要找到可以使用的最佳拟合线需要大量数据。 谷歌开发的一种算法使用了包含大约 120 万张图像的数据集。

当然，并不是每个机器学习算法都需要那么大的数据集，但是，根据情况，如果可用的数据有限，就不可能创建一个像样的模型。

维度问题

在我看来，维度问题是机器学习最具挑战性的方面之一。我能想到的最简单的解释是这样的:

每当我们在图表上绘制数据时，想象每个轴是一个维度。回想一下，在我们之前的例子中，我们有一个 x 轴和一个 y 轴，因此，我们之前的例子可以被认为是二维的。

然而，如果我们要在之前的数据集中添加另一个变量，我们就不能再使用二维图表来绘制数据了。

如果您还记得的话，我们的数据集包含每笔房屋销售的以下信息:

房子的售价
整个房产的大小

现在，如果我们添加另一个变量，在这种情况下，每栋房子的房间数量，那么我们的数据集中每栋房子的销售额将有三个变量:

房子的售价
整个房产的大小
房子里房间的数量

因为我们在一个轴上表示每个变量，我们有三个变量，如果我们要在一个图上绘制数据，我们自然会有三个轴(x，y & z)。

我们绘制在图表上的数据集如下所示:

突然，我们的机器学习算法不再处理二维图形，而是处理三维图形。我相信你会同意，仅仅通过看这个图表，数据之间没有清晰、容易看出的关系。

本质上，这是维度问题。通常在机器学习中，我们会处理多个变量，维度的数量不会停留在三个。我们可以很容易地拥有四个、五个、六个甚至二十个变量，这导致了许多难以想象的维度。

所以总的来说，维度越多，就越难在数据中找到关系，也就需要更多的计算能力。机器学习可以变得复杂、快速😳。

非线性

在前面的例子中，我展示了数据中的关系是如何成为最佳拟合线的。机器学习的另一个挑战是数据之间的关系并不总是线性的。

这意味着我们数据中的关系将开始像这样:

是啊，到处都是奇怪的线条。

如果我们把非线性关系和多维度结合起来，我们会得到这样的结果:

很疯狂吧？机器学习如此神奇的原因之一是，它可以在海量数据之间发现惊人的关系，而这些关系对我们人类来说不一定显而易见。

计算能力

我现在想指出的最后一个挑战是对计算能力的永恒关注。

我将在另一篇文章中讨论机器学习算法如何找到数据中的关系，然而，我想强调的是机器学习算法很少能找到数据中的完美关系。

因为我们的数据集可能会变得非常复杂，具有多维度和非线性关系，所以我们的算法在物理上不可能执行蛮力计算来计算每一种可能的关系，以找到数据的最佳拟合。

原因是执行这种计算的时间很容易需要 100 年才能完成，我没有夸大其词。

机器学习算法使用特殊的技术，如梯度下降(我们将在另一篇文章中讨论)，由于这些技术，算法通常只能找到数据中关系的粗略版本。

一个算法很少能找到完美的关系，老实说，完美的关系不值得花时间去寻找。

计算机在数据中寻找关系所需的时间取决于机器的计算能力。给你一个想法，计算机通常需要几个小时到几天的时间在给定的数据集中找到一个合适的关系，才能做出准确的预测。

结论

机器学习本身是一个巨大的主题，包含许多服务于不同任务的不同模型。计算机视觉机器学习模型看起来与学习下棋的模型不同。

我希望这篇文章能帮助你快速了解人工智能和机器学习背后的基本直觉。

在下一篇文章中，我计划解决不同类型的机器学习模型和人工神经网络。

感谢阅读🙏🏼

阿拉伯语的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-for-arabic-b2dc313f37f5?source=collection_archive---------7-----------------------

谷歌的 DialogFlow 没有对构建聊天机器人的阿拉伯语支持，标准的自然语言机器学习框架如 spaCy 也不包含阿拉伯语支持。微软的阿拉伯语工具包将于本月(2018 年 7 月)停产。此外，直到最近，即使是使用 gloVe 和 word2vec 的研究模型也不容易获得。那不是很有帮助。通常缺乏现成的高质量模型来用人工智能解释阿拉伯语。

谷歌仍然为人工智能功能提供优秀的 API，如神经机器翻译，但不是用来做翻译的向量(人工智能的东西)。这些语言模型在执行常见的非翻译文本处理任务时非常重要，例如情感分析、垃圾邮件过滤、剽窃检测等等。此外，这些模型对于将需要自然语言理解的企业任务自动化至关重要，这些任务是工作流的一部分，例如人力资源(HR)中的简历处理、政府报告中的文档聚类以及金融服务中的文档优先级排序。对阿拉伯语人工智能模型的需求相当强烈。

AraVec (2017)是一个非常好的阿拉伯语单词嵌入模型的起点，该模型由埃及吉萨尼罗河大学信息科学中心的 Abu Bakr Soliman 及其同事创建。以下链接指向他们的文章和相关代码。

[## 巴克里亚诺/阿拉维克

aravec - AraVec 是一个预先训练的分布式单词表示(单词嵌入)开源项目，旨在…

github.com](https://github.com/bakrianoo/aravec) [## AraVec:一组用于阿拉伯语自然语言处理的阿拉伯语单词嵌入模型

神经网络的进步带动了计算机视觉、语音识别和自然语言处理等领域的发展

www.sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S1877050917321749)

在过去一年左右的时间里，一些关于这一主题的文章已经在高质量的期刊和会议上发表。以下是一些最相关的例子:

[## 用于阿拉伯情感分析的单词嵌入- IEEE 会议出版物

手动特征提取是一项具有挑战性且耗时的任务，尤其是在形态丰富的语言中(MRL)…

ieeexplore.ieee.org](https://ieeexplore.ieee.org/document/7841054/) [## 阿拉伯语情感分类的单词嵌入和卷积神经网络

ACL 资料版权 1963-2018 ACL；其他材料的版权归其各自的版权所有者所有…

ACL 选集. info](https://aclanthology.info/papers/C16-1228/c16-1228)

中东和北非地区对人工智能解决方案惊人的强劲需求让我们思考为什么市场上存在这种差距。我们的解决方案是填补这一空白。我们成立了一家名为 Stallion.ai 的合资公司，为 MENA 地区的企业客户提供 B2B 人工智能解决方案。

面对这个问题，我们决定从头开始设计一个阿拉伯语单词嵌入模型。我们从公共领域搜集维基百科的页面和书籍。那是 14 GB 的文本。我们一直在用其他大型文本来源扩充这个数据集，以获得额外的语言环境和多样性。与其钻研我们一直在从事的工作的技术细节，不如考虑一下想要一个理解阿拉伯文本的人工智能系统的实际商业原因。

NOOR 编程语言是一个有趣的项目，它强调了对更多阿拉伯语言支持的需求。

有一句古老的法律谚语，“谁起草，谁就赢。”我找不到它的出处，引用它的书也找不到。这句老话的意思是，起草合同让起草者有能力设定合同条款，他们会按照自己的意愿行事。类似地，对一个用阿拉伯语经营的企业来说，将人工智能技术应用于他们的原始文档，而不是这些文档的机器翻译，是至关重要的。在从另一种语言借来的上下文上操作，并不像在同一种语言的文本上使用真正的嵌入模型那样有效。

在科幻小说和出版界，人工智能就像一个万能翻译机。甚至在像编译器(例如 GCC)这样的工程系统中，几种高级语言(例如 Java、C、C++)可以在被发射到用于几个处理器目标之一的汇编中之前被编译成一种通用中间语言(GIMPLE)。其结构如下所示:

How GCC understands (compiles) many language frontends into a single common representation and then emits code for a target architecture.

拥有一个像 GIMPLE 这样的语言的通用表示是非常好的，因为我们可以对这种语言的中间(通用)表示应用常见的有用优化。实际上，通用语言让我们能够理解意义，而不是仅仅考虑一种语言的特质。不幸的是，机器学习不像编译器那样表示语言。计算机代码是基于对正式语言理论的严格假设，而我们不会在自然语言如合同和文本信息中假设。自然语言充满了歧义。例如，同义词在不同的语言中并不相同。另一方面，代码基本上没有含糊不清的地方。更糟糕的是，阿拉伯语中的模糊性与英语中的不一样。这种思路告诉我们，专用的每种语言模型将优于借用的跨语言模型，这些模型不是在我们关心的语言上训练的。然而，情况更糟，我们很快就会看到。

我们刚刚讨论了为什么我们想专门理解阿拉伯语，而不是跨语言学习。现在考虑到阿拉伯文本中的有一些变化，我们需要单独考虑。

首先，有方言问题和俚语，包括表情符号，但让我们跳过这一点，进入第二个问题:风格的异质性。众所周知，不同类型的文本日志包含不同的语义信息。例如，来自报纸《生活报》的所有文本的语料库没有给我们足够的信息来理解南希·阿吉莱姆的推文。为什么？因为正式文本和非正式文本不是一回事。机器学习在对与它将评估的文本非常相似的文本进行训练时效果最好。

甚至还有第三个语境问题。像 Aravec 这样的单词嵌入模型是支持阿拉伯语的第一步。下一步必须是将特定于上下文的业务术语和短语编码到这些模型中。这些通常是现成模型没有训练过的字典外术语，或者是意思不同的现有单词。有时这些单词是英语或在阿拉伯语文档中使用的命名实体(例如，“كابل RS232 إلى واجهة RJ45”)。在字典中，单词通常仍然需要调整。例如，单词 collision 对道路工程师来说意味着路上的事故，但对数据库工程师来说却是数据库关键问题。这些上下文需要用来调整人工智能解决方案，并且在调整发生之前，所涉及的单词甚至不在人工智能模型中。在逐个项目的基础上，这些定制的修改是使用我们的 word 嵌入增强技术来实现的。

总结一下我们在 Stallion.ai 上解决的问题:处理阿拉伯语文档的企业需要定制的人工智能解决方案，而市场已经忽视了太长时间。我们已经看到，随着其他项目的关闭，新的项目出现了。我们已经确定了市场中的差距，包括现有模型中的以下缺点:方言支持，理解俚语，理解技术上下文和字典外的单词，以及理解各种类型的文本。我们正在探索研究和应用这项技术的工业和学术机会。

你在中东北非地区寻找人工智能帮助吗？向 evan@stallion.ai 问好，或通过 daniel@stallion.ai 联系我

丹尼尔

daniel@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能的图像数据集
人工智能:让你的用户给你的数据贴标签

用于营销的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-for-marketing-21aa1a0eb79e?source=collection_archive---------8-----------------------

这篇文章是我们如何将人工智能和数据科学应用于公司营销的一个演示。

我开始写关于 medium.com 和数据科学的文章已经整整一年了。我已经成为“人工智能”标签的顶级作家，拥有 50 篇文章，拥有近 2000 名粉丝，读者人数不断增加。

I have become a top writer on medium for the tag “Artificial Intelligence”

这篇文章如何适用于你？在这篇文章中，我是试验品。你会看到一些不错的数据，关于一个中型作家如何发展观众，并透过幕后了解什么可行，什么不可行。你可以想象我在这篇文章中的营销材料分析方法是如何帮助你成为一个更好的媒体作家的。

为什么我要写在介质上？嗯，不仅仅是营销。这是信息。当我们讨论解决方案架构时，我将内容推向公共领域，并让客户参考这些帖子。这也有助于我们加快公司定期对我们公司进行的尽职调查。因为我们是如此紧密地被 NDAs 所束缚，我抓住每一个我能找到的机会与你们分享我们正在做的事情的非秘密部分，我亲爱的读者们。

看看我的文章标题，我倾向于使用“人工智能”这个关键词，而不是深度学习或机器学习。这种方法有助于大多数人从远处理解这个话题，并吸引首席执行官们的参与，他们是我的 B2B 咨询( lemay.ai )和 B2B 产品(【genrush.com】、【audit map . ai】的目标市场。

让我们来看看我的 50 个中型帖子的数据集(见下文)和我在 medium.com 的流量统计

这些列的含义如下:

id: 跟踪数据库中的行
我认为这篇文章是关于三个主题中的哪一个
标题:文章的标题
url: 链接到文章
word_count: 文章字数。有时这也包括代码或链接之类的非单词。我没意见
views_medium: 来自 medium stats 的文章浏览量
reads_medium: 来自 medium stats 的文章阅读计数。阅读用户参与度较高，而浏览用户参与度较低
fans_accts_medium: 为文章鼓掌的账号数量(谢谢)
claps_medium: 读者给文章加的赞数
文章发表的日期
days_since_post: 我获取统计数据和文章发表日期之间的天数(date_medium)。
Twitter _ medium:Twitter 上文章的引用数量
正文:文章的明文——去掉标签和嵌入的多媒体

以下是我如何在脑海中对我的帖子进行分类的(cluster_daniel 专栏):

机器学习演示和操作指南
B2B 解决方案架构
启动场景和意见标签

让我们看看我基于经验的聚类是否符合一些数学事实。我使用 spacy(英语中等数据集)将每篇文章的文本转换成矢量形式，然后应用 t-SNE 降维。让我们来看看我一直使用的 3 个标签的文章数据是如何聚类的:

Results of t-SNE dimensionality reduction shown in tensorboard. Blue dots are the cluster “Machine Learning Demos and How-To Stuff” while the yellow dots are artilces from the cluster “B2B Solution Architecture”, and the red dots are articles from the cluster “Startup Scene and Opinion Blag”. Black dots are just overlapping colors.

结果相当令人鼓舞。在上图中，我们可以看到，类似博客的文章的红点(侧重于业务术语)和技术文章的蓝点(侧重于技术术语)被代表混合了业务和技术术语的 B2B 文章的黄点分开。它告诉我，我的标签是由内容数据本身支持的。

查看嵌入空间中哪些特定的文章彼此相邻可能会很有趣:

Looking at articles by cluster and title to see what specific articles are very semantically similar.

在我们继续看更多的数据之前，快速声明:这是一个非常简单的分析，没有频率/趋势分析或任何花哨的东西，没有图像计数，链接计数，链接网页等。

现在，让我们看看数据中各列之间的关系。

两秒钟的熊猫数据帧和 seaborn 的工作让我们有了以下的出发点:

The diagonal shows the general shape of the data, while the top right half shows the pearson correlation value (how linearly correlated is stuff with other stuff) and the bottom left half shows the raw data.

上图的问题是:没有显示聚类，文本太小，相关性很难看到。

This plot shows the correlation (red) and anit-correlation (blue) between columns.

上面的这个新数字是一个很好的进步，但是我们失去了底层集群数据的意义。我们总体上看到了相关性，但仍然看不到这些相关性的聚类来源。我们现在可以更清楚地看到，许多东西是相互关联的。例如，字数与浏览量、点击量、阅读量等相关。这很有道理。id 的反相关性只是告诉我们，较低的聚类数比较高的聚类数有更多的粉丝/阅读/喜欢等。但是，我们可以看到较旧的帖子在后面的集群中。随着时间的推移，我越来越关注 B2B 和技术文章，而不是观点文章(第三组)。days_since_post 行告诉我们，最近的文章比以前的文章做得更好。

现在，这是没有聚类着色的相关数据。对角线上的数据被转换成频率区间，比之前的线性近似更容易分析。现在，每个相关框都有一条使用回归创建的最佳拟合线和一个不确定圆锥(圆锥越大=越不确定)。

我们已经可以从这些数据中得出一些合乎逻辑的结论。第 4 行第 3 列(reads v.s. views)告诉我们，读取与视图紧密相关，这显然是正确的。类似的还有拍手和粉丝账号。

现在，让我们更深入一层，按群集查看数据。整个想法是为了验证我的假设，读者(你)希望看到更多的技术和 B2B 文章，而不是观点文章。最后，这是为每个分类添加了颜色的相同数据:

文本仍然很小，但是您可以放大来查看列名。

既然我们可以按集群查看数据，那么很明显，在集群内部，数据在许多指标上表现出许多规律性。在第一行和第一列中，集群按 id 排序，因为我选择了 id 按集群升序排序。作为一种见解，这并不有趣。深入到图中，最后一行(twitter)与字数(列 2)相关，但与红点(启动场景)无关。这告诉我们 twitter 更喜欢其他集群。看右下方的条形图，大部分文章没有 twitter 推荐，小部分文章获得了大部分 twitter 流量。倒数第二行显示我写的文章越来越少，最近也没有关于创业的文章(红点)。我们还看到，最近的文章有更多的阅读量和浏览量，但最近的文章总体上较少。

作为未来的工作，从单词嵌入模型预测聚类 id(主题模型)和点击/观看将会很有趣。然而，在这一点上，我只是不认为我有足够的行数和列数的数据来做出可靠的预测。

感谢阅读！下面是对 50 个数据点(文章)的更深入的分类:

机器学习演示和操作材料:

[## 音乐视频的人工智能

我正在为一个客户做一个视频分析人工智能项目，我想和你分享一个超级有趣的想法，它突然出现在…

towardsdatascience.com](/artificial-intelligence-for-music-videos-c5ad14e643db) [## 用深度学习画动漫少女

这篇文章是关于玛丽·凯特·麦克弗森的一个兼职项目。我们喜欢做一些辅助项目，比如音乐视频的人工智能，还有…

towardsdatascience.com](/drawing-anime-girls-with-deep-learning-4fa6523eb4d4) [## 人工智能中的肘聚类

聚类是将一堆未分类的东西(你的数据集)分成几堆(即聚类)的过程…

towardsdatascience.com](/elbow-clustering-for-artificial-intelligence-be9c641d9cf8) [## 人工智能的图像数据集

在人工智能领域，数据就是力量。

towardsdatascience.com](/image-datasets-for-artificial-intelligence-bbb12615edd7) [## kegra:基于 Keras 的知识图深度学习

你好。我在以前的文章中提到过，我正在深入研究企业数据集的认知计算。这个…

towardsdatascience.com](/kegra-deep-learning-on-knowledge-graphs-with-keras-98e340488b93) [## AWS SageMaker:人工智能的下一个游戏规则改变者

今天 AWS SageMaker 发布了，太牛逼了。我在以前的文章中提到过，我们主要做 AWS…

towardsdatascience.com](/aws-sagemaker-ais-next-game-changer-480d79e252a8) [## 数字海洋堆栈上的深度学习？还没有

所以你想要一个更便宜的解决方案来运行你的深度学习代码。AWS 每月给你大约 1000 英镑的账单…

towardsdatascience.com](/deep-learning-on-the-digitalocean-stack-not-quite-yet-5c408e7d1a41) [## 用数字海洋进行深度学习:Redux

这篇文章会和我平时的商务类文章有点不一样。在最近的一篇文章中，我给出了…

towardsdatascience.com](/deep-learning-with-digitalocean-redux-e6f447e64c75) [## 艾:看我的邮件

电子邮件是我们数字社会不可或缺的一部分。像小唐纳德的勾结，希拉里的服务器，波德斯塔的…

medium.com](https://medium.com/@lemaysolutions/ai-read-my-email-e69a833dd0f1) [## 十几个对数据爱好者有用的命令

在使用大数据的机器学习中，有许多组织工作要做。我们用于数据管理的名称各不相同:

medium.com](https://medium.com/@lemaysolutions/a-dozen-helpful-commands-for-data-nerds-9619bc43c5c6) [## 人工智能起源:字面意思。

没错。真实的圣经人工智能。让我们看看我们可以看到一些自然语言处理(NLP)和英语语言…

medium.com](https://medium.com/@lemaysolutions/artificial-intelligence-genesis-literally-947c1935752d) [## 丑闻！被泄露的电子邮件地址会怎么样？

2015 年 7 月 Ashley Madison 泄漏事件上周又回到了我的脑海中，当时一名 RNC 承包商的巨大泄漏袭击了…

medium.com](https://medium.com/@lemaysolutions/scandal-what-happens-to-a-leaked-email-address-ee90fe765af9) [## 医学中的机器学习:演示时间！

来说一个很酷的想法。人工智能用于伤口检测战斗机器人！

medium.com](https://medium.com/@lemaysolutions/machine-learning-in-medicine-demo-time-ffd17ed8a72a) [## 艾:复制这个模式

简单说一下我现在正在做的事情:我正在研究递归神经网络(RNNs)。这种类型的…

medium.com](https://medium.com/@lemaysolutions/ai-copy-this-pattern-5ac4e9ccf6a9) [## 给我做这个模型。以我为例:一次生成一个字符的文本。

安德烈·卡帕西最近进入了特斯拉的 ML 高层。我想给你看一些他早期的作品…

medium.com](https://medium.com/@lemaysolutions/model-me-this-model-me-that-generate-text-one-character-at-a-time-46a232db92e7) [## 秘密验证电子邮件地址

如何辨别哪些电子邮件地址是真实的？我不是说什么地址在语法上是有效的，比如…

medium.com](https://medium.com/@lemaysolutions/secretly-validate-email-addresses-86bd6dc980f8) [## 1.1TB 数据泄露。只是，哇

大家好，

medium.com](https://medium.com/@lemaysolutions/1-1tb-data-leak-just-wow-8ee38322d57d)

B2B 解决方案架构:

[## 如何给一个人工智能项目定价

客户多次要求我为大型机器学习(ML)项目提供固定的价格估计。这个…

towardsdatascience.com](/how-to-price-an-ai-project-f7270cb630a4) [## 如何聘请人工智能顾问

所以，你知道你需要一些机器学习/人工智能开发。为什么不自己做呢？嗯，简短的回答是…

towardsdatascience.com](/why-hire-an-ai-consultant-50e155e17b39) [## 艾:跟踪我

我的手机收集的数据量令人震惊。让我们看看我的谷歌历史，看看我们能看到什么。这个…

towardsdatascience.com](/ai-track-me-325833522043) [## DREAM.ac:利用人工智能建立团队

人工智能正在被部署来解决许多人类问题，最近谷歌的 Duplex 可以使…

towardsdatascience.com](/dream-ac-build-teams-using-artificial-intelligence-c4f1fdd7ee66) [## 深度学习魔法:小企业类型

企业情报很难，NAICS 密码很糟糕。一些公司按行业购买公司名单，以保存…

towardsdatascience.com](/deep-learning-magic-small-business-type-8ac484d8c3bf) [## 人工智能和不良数据

脸书、谷歌和推特的律师向国会作证，说明他们如何错过了俄罗斯的影响力运动…

towardsdatascience.com](/artificial-intelligence-and-bad-data-fbf2564c541a) [## 用人工智能理解事件

我们遇到了很多客户需求，归结起来就是使用人工智能来理解事件。一些系统需要…

towardsdatascience.com](/understanding-events-with-artificial-intelligence-12e1ec3c5c9) [## 无标签数据的人工智能

先说无监督深度学习 AI，转移学习。

towardsdatascience.com](/artificial-intelligence-without-labeled-data-54cdbfbdaad2) [## 加速深度神经网络

神经网络“慢”有很多原因，包括加载/存储延迟，将数据移入和移出 GPU…

towardsdatascience.com](/accelerating-deep-neural-networks-1231273c48aa) [## 人工智能:让你的用户给你的数据贴标签

我想把这篇文章叫做“人工智能训练数据的寄生标签”，但显然这太复杂了。我……

towardsdatascience.com](/artificial-intelligence-get-your-users-to-label-your-data-b5fa7c0c9e00) [## 艾:这是黄片吗？

色情推动了格式战争。一代人以来都是如此。网络上充斥着色情内容。

medium.com](https://medium.com/@lemaysolutions/ai-is-this-porn-2695c5e6fa47) [## 销售团队的人工智能

先说现状。所以，你想卖一个产品或服务。假设你卖火险…

medium.com](https://medium.com/@lemaysolutions/ai-for-sales-teams-7b9ab014417d) [## 大数据和机器学习:一个豆荚里的两颗豌豆

退一步想想大数据和机器学习的联系。要真正利用大数据，您需要…

medium.com](https://medium.com/@lemaysolutions/big-data-and-machine-learning-two-peas-in-a-pod-e3a04d627784) [## 锁在盒子里:没有云和 API 的机器学习

API 很棒。机器学习 API 更牛逼。从 api.ai 到 Google 这样的 Google 云平台 APIs

medium.com](https://medium.com/@lemaysolutions/locked-in-a-box-machine-learning-without-cloud-or-apis-76cc54e391c8) [## 考试的时候来个狂看 AI

有很多例子显示了人工智能如何识别视频中的数据。比如情绪识别…

medium.com](https://medium.com/toronto-machine-learning/exam-time-for-a-binge-watching-ai-e9477e901e3e)

启动场景和意见标签:

[## 人工智能很可能是安全的

即使我们最终都会被宇宙的热寂所杀死(10^100 年后)，还有更多…

towardsdatascience.com](/artificial-intelligence-is-probably-safe-ce67f0abd759) [## 机器学习:使用小词

我喜欢异端这个词。这是一种很酷的说法“跳出框框思考，反对主流”。它…

towardsdatascience.com](/machine-learning-use-small-words-5cc8f34a5964) [## 人工智能像魔术一样

创新或者死亡。成长或枯萎。这就是我今天在人工智能领域的感受。从 2008 年开始的衰退性失业…

towardsdatascience.com](/artificial-intelligence-as-magic-e8ba4b3165ea) [## 人工智能:后果

人工智能将改变世界。

towardsdatascience.com](/artificial-intelligence-consequences-bd4dc4d537da) [## 人工智能:超参数

深度学习神经网络模型有许多参数(例如，权重和偏差)，也有相当多的…

towardsdatascience.com](/artificial-intelligence-hyperparameters-48fa29daa516) [## 人工智能工具像爆米花一样爆开

我想暂停谈生意，谈一谈正在深入展开的技术故事…

medium.com](https://medium.com/@lemaysolutions/ai-tools-are-popping-like-popcorn-3baa6793271f) [## 发展和招聘

一位渥太华人工智能初创公司的创始人在 LinkedIn 上的状态是“增长和招聘”我喜欢这样。多好的……

medium.com](https://medium.com/@lemaysolutions/growing-and-hiring-25540db9cecc) [## 我们的人工智能创业公司

你好。我给你讲讲我们 AI 创业的故事吧。一路上我们犯了一些错误，我想你可能会学到…

towardsdatascience.com](/our-artificial-intelligence-startup-c7daf4c140a1) [## 为什么要自举你的人工智能创业公司呢？

关于命名法的一个快速补充…它应该是谷歌实验所说的人工智能，维基百科所说的人工智能，还是人工智能…

towardsdatascience.com](/why-bother-to-bootstrap-your-ai-startup-d94fd62de009) [## 人工智能咨询&逆向棉花糖实验

我在过去写过关于人工智能人才的高需求，以及高素质人才的低供给…

towardsdatascience.com](/ai-consulting-the-reverse-marshmallow-experiment-18d466737d3f) [## 怎样才能写出更好的 AI 文章？

我很清楚，我在媒体上的写作让我获得了有趣的联系，这些联系可以转化为…

towardsdatascience.com](/how-can-i-write-better-articles-on-ai-6b37e1baad5a) [## 低预算和高期望:机器学习初创公司

在以前关于如何雇用人工智能顾问，以及如何为人工智能项目定价的文章中，我试图给你一种…

towardsdatascience.com](/low-budgets-and-high-expectations-machine-learning-startups-c428f3f82569) [## 人工智能不是魔法

一点数据科学和一桶血、汗、泪，你就知道了:你的模型是过度拟合的…废话…

medium.com](https://medium.com/@lemaysolutions/a-i-is-not-magic-9fb19239fcaf) [## 它还活着！构建通用人工智能是未来

我的朋友们一次又一次地听到我这样说。人工智能正在走向一种认知的“生活”,超越…

towardsdatascience.com](/its-alive-building-general-ai-is-the-future-ddd8f75d09dc) [## 教育视频:人工智能、深度学习、机器学习等。

来分享一些书签吧。作为我们开发人员入职流程的一部分，我将 YouTube 视频分成了 3 个部分。

medium.com](https://medium.com/toronto-machine-learning/educational-videos-artificial-intelligence-deep-learning-machine-learning-etc-3fadb6050eb5) [## 我应该怎么称呼我的创业公司？

当我们得到一个有新想法的客户时，他们通常没有域名，甚至没有公司名称。这是一个干净的石板…

medium.com](https://medium.com/@lemaysolutions/what-should-i-call-my-startup-ef9aea077271) [## 涌现属性

我们有消息了！我们的中型岗位现在是辛迪加对数据科学！

medium.com](https://medium.com/@lemaysolutions/emergent-properties-e69c0f72d64d) [## 机器学习时代的恐惧

这是我关于人工智能和大数据系列的第三篇文章。最近完成了关于…的博士学位

towardsdatascience.com](/fear-in-the-age-of-machine-learning-87ee33b5b264)

——丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴上标签

音乐视频的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-for-music-videos-c5ad14e643db?source=collection_archive---------2-----------------------

我正在为一个客户做一个视频分析人工智能项目，我想和你分享一个超级有趣的想法，这个想法是我今晚在等待渲染的时候突然想到的。我真的没有时间写这个，但我觉得我必须写。有些想法太棒了，以至于不能熬夜编程。让我们用人工智能系统来勾勒音乐视频中的人物。

已经有一些关于数据科学的很棒的对象检测文章，所以我不想重复那些很酷的东西。让我们用 COCO 和 Mask_RCNN 在对象周围画线，而不是检测对象的位置和标签。在音乐录影带上做这件事真是太酷了。

我们来搞乱 Jain 的 Makeba 视频。我去掉了音轨，只保留了前 2000 个视频帧，只是为了更加清楚地表明，这篇文章是为了教育目的而合理使用艺术家的作品。点击这里欣赏她在 YouTube 上的音乐视频。

这是我们对视频的人工智能分析结果:

我有点喜欢它如何在广告牌和背景中找到人。真的很微妙。我还喜欢黑人和白人女孩的脸融合得如此平滑，以至于人工智能假装它实际上是一个人。下面是我认为值得注意的一些很酷的视频片段。尽情享受吧！

It sees the finger!

It recognizes people from behind.

Lots of people? rCNN says no problemo!

紧急方按钮

这个帖子我还得再加一个好玩的项目。

数据科学是一项艰苦的工作。当我们都坐在办公室里，我们的模型总是过拟合，或者不编译，我们需要一些方法回到成功的心态。我们的办公室文化相当古怪，所以当数据科学让我们失望时，或者当我们获得意外的胜利时，我们会关闭紧急派对按钮。类似的产品已经上市，但是我们想从头开始制造自己的产品。不是作为一个产品。只是为了好玩。

我们 3D 打印了零件，马特将继电器、树莓派和其他零件组装在一起，并连接起来。

下面是我们的 紧急聚会按钮 演示:

我们(主要是 T4 的马修·勒梅)已经在业余时间为这个项目工作了两年。就是不会死的副业。马特添加了歌曲随机发生器、继电器、扬声器，以及你能想象到的所有酷酷的铃声和哨声。按下那个按钮，启动灯光和音乐，感觉真的很棒。

所以，总之，人工智能可以用来分析视频，提取大量信息。当一切都太多的时候，按下紧急聚会按钮！

如果你喜欢这篇关于人工智能应用于音乐视频的文章，请点击“关注”按钮，看看我过去读过最多的文章，比如“如何为人工智能项目定价”和“如何聘请人工智能顾问”

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴上标签

人工智能框架:机器学习和人工智能的可视化介绍

原文：https://towardsdatascience.com/artificial-intelligence-framework-a-visual-introduction-to-machine-learning-and-ai-d7e36b304f87?source=collection_archive---------11-----------------------

对于你的下一次人工智能或机器学习电梯推介，你需要知道的一切

Photo: a-image/Shutterstock

人工智能在商业和我们社会中的变革性质是显而易见的。像互联网和智能手机一样，人工智能是一种使能技术，将对我们生活的各个领域产生深远的影响。

为了更好地理解底层概念，我想与您分享一张图片，这是我在解释机器学习/深度学习的更广泛背景以及它与人工智能的关系时通常使用的图片。

你会在 medium 或其他地方找到很多很棒的文章，它们对 AI 做了很好的介绍(我在本文末尾链接了一些)。然而，到目前为止我还没有看到一个易于视觉消化的人工智能概述。如果你知道一些我可以用的东西，请在下面的评论区告诉我。但是在那之前，让我分享我现在使用的观想。在本文中，我还将简要介绍该图的关键组件。

“AI and machine learning high level overview” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

首先什么是人工智能？

简而言之，人工智能是计算机科学的一个分支，它研究如何创造具有类似人类智能能力的机器。人工智能有不同的成熟水平，我将在接下来的章节中简要介绍:超级智能、通用人工智能和狭义人工智能。

人工智能对于数字化认知能力非常有用，在这种情况下，要遵循的确切规则很难解释。一个很好的人工智能用例是人脸识别。试图使用手工知识来编码人脸识别的所有相关规则，这种方法有时被称为第一波人工智能(来源)。但是随着机器学习和深度学习等成熟技术的出现，这并不是我们稍后将看到的首选方法。

人工智能的关键驱动力是什么？

在我们深入了解细节之前，让我们快速了解一下推动人工智能最新进展的关键因素:

计算能力:计算能力的性价比按照摩尔定律呈指数增长。指数意味着计算速度翻倍和/或价格同比下降一半。近年来，机器学习作为 AI 进步的关键驱动力之一，极大地受益于 GPU(图形处理单元)。GPU 非常适合进行所有机器学习计算所需的矢量数值运算。谷歌的 TPU(张量处理单元)是(共)处理器针对机器学习问题进行优化的另一个例子。随着量子计算的巨大进步，这一趋势很可能会继续并加速。
数据可用性:随着移动技术和社交媒体使用的增加，数据的生成和可用性都在加速。仅在过去的两年中，令人印象深刻的是，世界上 90%的数据都是由计算机生成的(来源)。大量的数据是训练神经网络的关键成功因素(更多信息将在下文详述),从而实现对未知事件的高准确度预测。
算法:AI 研究社区非常活跃，新的进展频繁发表。最大的关注点是机器学习，或者更具体地说是深度神经网络。此外，谷歌(Google)、脸书(PyTorch)或微软(Microsoft)等公司也开发了各种工具和框架供公众使用。

超级智能

一些研究人员预测并相信，在未来的某一时刻，机器会比人类更聪明。这可能发生在 2050 年到 2100 年之间。很少有研究认为这种状态永远不会达到。但是对于大多数熟悉这一课题的研究人员来说，超级智能是否能达到并不重要，重要的是什么时候能达到。

超智能是机器的认知能力超过人类的状态。正如尼克·博斯特罗姆所说，这是一种“在几乎所有感兴趣的领域，智力大大超过人类认知能力”的生物。

超级智能的出现是基于这样一个假设，即进化学习环境中的进步速率是呈指数级进化的(雷·库兹韦尔的加速回报定律)。这很难理解，因为大多数人的思维都是线性的，并且试图根据我们已经知道的和过去经历过的来预测未来。这当然会导致一个错误的轨迹。蒂姆·厄本(Tim Urban)有一篇很棒也很有趣的文章解释了这段旅程(文末有链接)。它比我更好地解释了超智能及其所有的含义。如果你有心情，我强烈推荐你看他的帖子。

“AI broader context and roadmap” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

在最好的情况下，超智能将导致一个富足和公平的未来(奇点)。在最糟糕的情况下，它将导致人类的灭绝，不是因为超级智能是邪恶的，而是因为人类正在实现其目标(这些目标我们可能再也无法理解，因为它们超出了我们的认知能力)。

通用人工智能

在达到超智能之前，通用 AI 意味着机器将拥有和人类一样的认知能力。再次，研究人员争论我们将达到一般人工智能的时间点。可能在 2045 年左右。由于加速回报定律，普通人工智能阶段将很快过渡到超智能时代。

智力与生物体有效适应环境变化的能力密切相关。适应也意味着不仅要改变自己，还要改变环境。以下是一般人工(和人类)智能的关键特征(来源:这里和这里):

学习:根据过去的经验改变自己行为的能力，例如当遇到新的和未知的情况时。
记忆:对过去经历的编码、存储和检索。
推理和抽象:根据样本数据得出逻辑结论，具有归纳/推导规则的能力。
解决问题:系统地提出可能的解决方案并得出问题最佳答案的能力。
发散思维:对一个给定的问题产生多种解决方案的能力。
聚合思维:缩小多个选项的列表，以便得出可能的最佳答案。
情商:识别并解读人类的情绪。
速度:上述所有特征必须在合理的时间框架内/接近实时地发生。此外，它们不能依赖大量数据，例如重新训练神经网络。在某些情况下，学习可以只基于一个单一的例子。

通用人工智能将无法通过当前的方法和工具(如神经网络)实现。为了达到真正的智能，认知系统可能是一个解决方案。

狭义人工智能

由于研究在实现一般人工智能方面没有取得很大进展，焦点自然首先转向了狭义人工智能。狭义人工智能专注于非常具体的用例。这意味着人工智能(目前主要使用深度神经网络)是为非常特定的目的而训练的。因此，人工智能只能处理它被训练过的事件。

如果一个聊天机器人被训练成用英语回答公司 A 的客户服务请求，它将不能对它将 A)接收到的不同公司的任何请求或 b)以不同语言陈述的任何请求或 c)被问及不相关的话题，如“我今天需要带伞去工作吗？”。

与一般人工智能相比，狭义人工智能的学习能力非常有限。它可以在特定用例的边界内学习，例如，用于语音识别的狭义人工智能可能能够提高理解同一种语言的新方言的速度。为了学习另一种语言，它需要人类的输入，例如，通过为要学习的新语言提供大量标记数据集。狭义人工智能无法通过提出替代解决方案来动态适应新情况，而替代解决方案是通用人工智能的一个关键特征(见上一章)。

一些典型的狭义人工智能用例:

自然语言识别和处理
自动驾驶
视觉图像识别和解释
网络安全中的入侵检测
人类活动识别

机器学习

机器学习是一门人工智能学科，也是近年来狭义人工智能进步背后的关键驱动力。它是工具和方法的集合，允许计算机从观察、数据和例子中学习，以提高它们的性能。它不需要明确的一步一步地解释如何执行一项任务，而传统编程则需要这样做。

“Machine learning workflow (supervised)” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

本质上，机器学习是基于统计模型来进行预测的。在学习过程中，统计模型的参数根据所提供的训练数据进行优化调整。可以说，系统通过经验学习。基于给定的训练数据，系统然后能够对看不见的事件/数据进行预测。为了使模型能够很好地概括那些看不见的事件，定义一个很好地适合问题陈述的模型，并且具有必要数量和质量的可用训练数据是很重要的。

监督机器学习

有监督的机器学习简单来说就是我们提供一个带有全标签训练数据的算法。带标签的培训数据意味着每个培训记录都有相关的答案。因此，我们已经为算法如何解释数据提供了明确的指导。然后，该算法将构建一个模型，并根据给定的标签进行测试。对于每次迭代，如果模型得出的预测与标签一致，误差函数将验证。然后，该模型将随着每次迭代而略微调整，直到该模型在训练数据上表现良好。

“Supervised machine learning” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

有两种不同类型的监督学习。要记住的关键是:分类分离数据，回归拟合数据。

分类:预测给定观察/输入的分类响应值的算法。它将预测一个离散值。先决条件是我们能够将响应值分成不同的类。一个典型的例子是手写字母和数字的分类，例如由邮局用来解释写在信上的地址。
回归:预测给定观察/输入的数值连续响应值的算法。它将预测一个连续值。一个典型的例子是根据位置、大小、年龄等预测房价。

无监督机器学习

在获得足够的标记训练数据很困难或太昂贵的情况下，无监督方法变得相关。对于无监督学习，我们不为算法提供带标签的训练数据。相反，我们希望算法自己找到一种方法来分类/分离数据。存在以下主要类别:

聚类:试图创建相似数据点的聚类的算法。例如，人们可以想象，当算法只接收数百万辆汽车的前视图时，机器肯定能够自己对车辆进行分类。与福特或奥迪相比，宝马看起来不同，因此该算法应该能够轻松地将图片分类(在这种情况下是汽车品牌)。
异常检测:试图在给定数据集内发现异常值/异常的算法。一个典型的例子是识别银行交易中的欺诈行为。如果一个人在欧洲和美国之间旅行时有很多交易，而且金额相对较小，那么在这两次旅行之间从尼日利亚进行的 10，000 美元的交易可能是可疑的。
关联:关联规则是一种识别数据集内关系和依赖关系的算法。一个典型的例子是网上商店的推荐引擎，其中相关的产品可以基于相似的特征被分组在一起，然后被推荐给消费者。

“Unsupervised machine learning” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

半监督机器学习

在标记大量训练数据过于昂贵的情况下，监督和监督机器学习之间的混合就发挥了作用。该过程从一个人标记少量数据开始(例如:由放射科专家解释和标记的 CT 扫描)。

目前，半监督学习最流行的例子是一种特殊的神经网络，称为 GAN(通用对抗网络)。它使用标记的训练数据来生成新数据(通过生成器网络)，然后将这些数据发送到另一个神经网络(鉴别器)，该神经网络需要识别该数据是假的还是训练数据的一部分。发生器和鉴别器网络在正反馈回路中共同改进。生成器在创建令人信服的假数据方面会变得更好，鉴别器在从训练数据中分离假数据方面会变得更好。

“General adversarial network (GAN) overview” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

GAN 的一个很好的用例是创建模拟真实图像的人工图像。一幅甘创作的肖像画最近在佳士得拍出了高得离谱的价格。

强化学习

强化学习是基于这样一个假设，即一个最佳的行为或行动可以通过对一个有利的行动给予积极的奖励来实现。强化学习的基本设置包括一个将与其环境交互的代理。基于代理在给定情况下从其交互中接收到的正面/负面反馈，某种行为会得到奖励，有利的行为会因此得到加强。

“Reinforcement learning overview” by Nils Ackermann is licensed under Creative Commons CC BY-ND 4.0

在许多迭代中，代理将被训练，并且其实现总体目标的动作的性能将被提高。对于每一个行动，代理人必须决定他是否想要探索他的环境(探索)，以便寻找与已经被证明是成功的行动(开发)相比潜在的更高的回报(失败的风险也更高)。

神经网络和深度学习

神经网络是一种受生物学和大脑如何运作启发的机器学习方法。它们最适合用于识别非结构化数据中非常复杂的模式，例如:

音频和语音(例如语音识别)
文本(如情感分析)
图像和视频(例如人脸或物体识别)
运动/活动(例如传感器数据分析)

深度神经网络只是具有一个以上隐藏层的神经网络。网上有很多很棒的文章和视频解释了神经网络如何在所有不同的细节层中工作，因此我在这里就不解释了。我在本文末尾链接了一些资源。

有许多不同类型的神经网络可用。一些用于监督学习，另一些用于非监督学习。我最初的概观图片将一些比较流行的神经网络划分为一个类别。我最近写了一篇关于(一维)卷积神经网络的深度文章，以防你感兴趣。

在关闭

感谢您的阅读，我希望你喜欢这篇文章！虽然你可能已经熟悉了我所涉及的所有主题，但我希望这是一个轻松的阅读，将关键主题放在彼此的角度上——至少这是我的初衷。在你的作品中随意使用总览图，只要你相应地引用它。

参考文献

如果你想进行进一步的阅读，我会推荐你浏览下面的免费文章(或多或少按照我阅读的顺序)。

等待，但为什么蒂姆·厄本:人工智能革命
奇点大学:指数入门
从狭义到广义的人工智能
人工智能领域的弗劳恩霍夫趋势
DARPA 对人工智能的看法
YouTube 上的 3Blue1Brown 神经网络介绍
YouTube 上的深度学习简化版系列
认知系统范式
甘的精彩介绍
强化学习的好入门
PyTorch 深度学习平台
Tensorflow 深度学习平台
Azure 深度学习平台
谷歌云 TPU

放弃

本网站上的帖子是我自己的，不一定代表我的雇主的帖子、策略或观点。

人工智能起源:字面意思。

原文：https://towardsdatascience.com/artificial-intelligence-genesis-literally-947c1935752d?source=collection_archive---------3-----------------------

没错。真实的圣经人工智能。让我们看看我们可以用一些自然语言处理(NLP)看到什么，以及《创世纪》的英文版(包含在 nltk 语料库中)。想看英文和希伯来文的在线版本，可以看看这个网站。这篇文章是关于让计算机理解《创世纪》中的名字，而不是关于圣经代码或隐藏的信息。

我是一个宗教人士，在大量的圣经研究和分析中长大。《圣经》的原始文本附有学者的评论，如拉希、昂克勒斯、米什那和杰马拉。让我们把文本分析限制在没有注释的《创世纪》的英文版上，因为我们试图理解计算机从父系姓名中收集的一些含义。

创世纪:字面意思。

“本质上， 所有模型都是错的 ，但有些是有用的”——乔治 E. P. Box

带着这句谦卑的话，让我们看看亚当、挪亚、亚伯拉罕、以撒和雅各。它们在文中是如何联系的？我们如何使用 NLP 提取关于他们角色的数据？

请记住，这些人在圣经中有不止一个名字。亚当、诺亚、亚伯拉罕(改名前的亚伯兰)、以撒和雅各(改名后的以色列)。让我们记住雅各和亚伯拉罕这两个名字。我们也不要忽视以色列有时是雅各，有时是以色列的土地，有时是以色列的民族。

首先，我们看一下上下文、被提及的次数以及它们被提及的地方。接下来我们可以看看课文中这些名字的意思。我们在下图中看到，亚当和挪亚在《创世纪》中被一个接一个地提到，然后他们就不再被提到了。大约在第 12，000 字左右，亚伯兰改名为亚伯拉罕，然后我们不再听到亚伯拉罕，只听到亚伯拉罕。圣经经常提到“亚伯拉罕，以撒，雅各”作为我们的祖先，所以我们看到这三个名字一起出现在文本中的相同位置。当雅各改名为以色列，我们看到两个名字在一起，不像亚伯兰/亚伯拉罕，我们只看到一个，然后另一个。

每一个名字被提及的次数都有些令人惊讶:(亚当 18，诺亚 41，亚伯拉罕 129，亚伯兰 58，以撒 77，雅各 179，以色列 40)。诺亚被提到的次数比亚当还多！查看下图中的原始读数。

而雅各的 179+40=219 次被提及，比亚伯拉罕的 129+58=187 次还多。也许以色列这个词的许多用法(人、地方、部落)给了雅各一些我们不应该计算在内的额外提及。

现在，回到任务上。在这篇课文中，这些名字与什么词相似？

亚当相似: 约瑟雅各以撒亚伯兰闪他们他我亚伯拉罕挪亚他拉结你神利亚她该隐撒拉我我们

诺亚类似:
雅各他约瑟法老亚伯拉罕他以撒他们以扫我你神闪亚伯兰都 th 所多玛亚法撒拉结天堂

亚伯拉罕相似: 雅各约瑟他们他以撒法老他神以扫亚伯兰拉班她挪亚他们我都你以色列罗得我

亚伯兰类似:
约瑟雅各他亚伯拉罕以撒他他们法老他们神以扫拉班你利亚我拉结她罗得我们犹大

以撒相似:雅各约瑟他亚伯拉罕他们她亚伯兰神拉班以扫法老利亚拉结利百加撒拉犹大挪亚我以色列

雅各相似:雅各相似:
他约瑟亚伯拉罕他们以撒神法老亚伯拉罕以扫他拉结以色列我挪亚他们你拉班利亚犹大

以色列相似:雅各亚伯拉罕约瑟他们他以撒神以扫撒拉亚伯兰法老一切拉麦他拉结天堂饥荒利百加埃及撒莱

上述结果中的第一个好迹象是，这些名字与其他名字相似，而不是与随机单词相似。另一个好迹象是，以色列和雅各非常相似，亚伯拉罕和亚伯兰也很相似。这让我们知道这些名字之间有某种关系。另一个好迹象是，所有这些名字都与上帝有关，如“上帝与亚伯拉罕说话”，表明这些人与创世纪文本中的上帝有关。

现在让我们对这些名字有更多的了解。到目前为止，它们只是简单的文本标签。这些名字对我们的 AI 意味着什么？嗯，使用 Synset 库，我们可以利用语义相似性在 Isaac 和 Noah 之间设计出以下有意义的关系:

noah = wn.synset('noah.n.01')
isaac = wn.synset('isaac.n.01')
print(noah.lowest_common_hypernyms(isaac))

我们得到答案【Synset(' patriarch . n . 03 ')】，这告诉我们这些词之间的共同关系是它们都指族长。这是一个很酷的数据量，仅仅是摄取圣经文本。

结论

这是一个使用 NLP 的超级小功率的演示。该系统能够识别父系姓名之间的关系，并将这些姓名之间的共同想法关联起来。来自机器学习其他领域的附加技术可以使这种方法更加强大。虽然我更喜欢“更新”的单词嵌入神经方法，而不是这里展示的方法，但我继续在这些经过多年文本处理研究构建的手工文本分析工具中找到价值。

编码快乐！

——丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴上标签

人工智能:让你的用户给你的数据贴标签

原文：https://towardsdatascience.com/artificial-intelligence-get-your-users-to-label-your-data-b5fa7c0c9e00?source=collection_archive---------2-----------------------

我想把这篇文章叫做“人工智能训练数据的寄生标签”，但显然这太复杂了。我想告诉你的是机器学习中一个经常被忽视的方面:数据标注。

有深度神经网络的监督机器学习是最常见的人工智能。监督学习意味着从标记的数据中学习。但是通常你没有带标签的数据。您有个未标记的数据。更常见的是，您没有不断增长的数据。不管有没有标记，如果你输入人工智能的训练数据是固定大小的数据集，那么你的人工智能不会随着时间变得更聪明。你真正想要的是一个人工智能从野外标记的数据中学习的系统。它会在你睡觉的时候变得更聪明，而且你一分钱都不用付。

不幸的是，如今最常见的引导人工智能的机制是机械土耳其人基于人类的标签，甚至是全职数据标签公司。有时工作是注释文本语料库，在其他情况下，他们注释图像。

当你想到我们为客户部署机器学习的原因时，通常是自动化人类直觉。我们正在用软件取代以前由人执行的功能。

机器学习就是要找到一个函数 f 将输入数据 X 映射到输出数据 Y 。或者，正如我们在高中所学的:

Y=f(X)

因为我们试图近似的东西( f )是人类，所以我们需要收集关于人类做出什么决定的训练数据(【Y)，以及该决定基于什么原始数据( X )。

既然我们已经讨论了我们的 AI 正在做什么，以及对带标签的数据( X 和 Y )的需求，那么让我们看看如何免费获得数据标签。我们讨论过，为了避免为数据标记付费，您需要一些神奇的数据注释解决方案。只要有可能，就让人工智能的用户来做标记。如果你做得好，他们甚至不会注意到。

在你的设计中加入一个增加训练数据的特性是非常重要的。例如，想象一下，在谷歌地图中，你对着智能手机说话，询问地址“46 de la cote-des-Neiges Rd”这导致应用程序为我糟糕的法国口音返回一个错误的地址，如下图所示。

Sorry Google, “46 de la Côte-des-Neiges Rd.” is not “46 Diller Cottage Road”

这里的神奇之处在于:当我马上按下后退键，而谷歌知道我按了后退键。这是一个暗示，从我的声音翻译地址是不正确的。按下后退按钮意味着地址转换中的错误，这可以用来提高应用程序的准确性。类似地，当我按照指示找到地址时，这是一个很好的迹象，表明模型猜对了我所说的地址就是我想要的地址。

在一个类似的例子中，我在 Google inbox 中锁定到 Inbox 的消息向 Google 表明我可能希望在将来锁定哪些未标记的消息作为重要项目。你瞧，几天前收件箱开始了一个“重点”部分，向我显示哪些邮件看起来最紧急。

当你开始收集数据时，有一种错误的方法和一种正确的方法。如果用户觉得他们的时间被浪费了(比如在你结账前，给这张图片贴上标签)，那么你得到的结果就是低质量的垃圾。当 YouTube 让你填写一份调查时，结果会很糟糕。

YouTube survey ad from here.

随着时间的推移，从用户那里收集高质量的数据可以用来改善机器学习，但为了相信数据质量是高的，这必须看起来毫不费力。另一个技巧是将用户的动机与数据标注任务联系起来。例如，当人工智能出错时，用户有很高的动机按下用户流中的后退按钮，但在其他情况下，用户这样做的动机很低。有时这种数据收集方法是不可能的，但是尽最大努力让它工作起来是值得的。

最后，让你的 UX 团队加入到机器学习的对话中来。找到一些方法将数据收集功能整合到您的人工智能解决方案中，以便您获得用户生成的高质量数据的许多好处。

The Clap!

在我离开之前，非常感谢我们的在线粉丝！如果你喜欢这篇关于人工智能的文章，那么请尝试一下拍手工具。跟着我们走。去吧。我也很高兴在评论中听到你的反馈。你怎么想呢?

编码快乐！

——丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴标签

人工智能:超参数

原文：https://towardsdatascience.com/artificial-intelligence-hyperparameters-48fa29daa516?source=collection_archive---------4-----------------------

深度学习神经网络模型有很多参数(如权重和偏差)，也有不少超参数。我们从高中就知道什么是参数。它们是你插入到函数中的数字。但是什么是超参数？嗯，它们基本上是用来创建包含参数的模型的选项。

学习哪个超参数设置适合哪个模型行为需要一些时间。谢天谢地，keras 的默认值是一个很好的起点。

首先，让我们从以前的文章中记住，我们的深度学习模型正在试图逼近一个函数 f ，该函数将输入特征 X 映射到输出决策 Y 。或者，换一种说法，我们在试图寻找一个误差很小，但不需要记忆训练数据的函数Y = f(X)(过拟合)。

我们的模型中的参数像权重和偏差在参数优化过程中被调整(即反向传播)以得到我们的映射函数 f 的越来越好的版本。基于超级令人兴奋的最新工作，事实证明，当神经网络学习逼近 f 时，它们实际上在做一种信息压缩。这将我们的老朋友信息论与我们的新朋友深度神经网络联系起来。

超参数 是元设置，我们可以选择(希望以某种聪明的方式)来调整模型如何形成 f 。换句话说，我们设置超参数是为了挑选我们想要的模型类型。例如， t-SNE 有超参数设置称为困惑，ε(学习率)，和其他几个，像迭代次数。

想想配置和构建深度学习模型，比如点寿司:寿司是成卷的。有的卷 8 块，有的卷 6、4 块。控制味道的超参数，以及当你从菜单上要一个面包卷时，你会得到多少个面包卷，就是面包卷类型。你可以选择辣味卷、蔬菜卷、油炸卷等等。在任何情况下，你都可以吃到寿司。改变的是寿司师傅用来制作寿司的配置。每卷味道都不一样。回到机器学习领域，当我们选择超参数时，我们需要做出一些非常大的决定(例如回归器或分类器，CNN 或 LSTM 或 DNN 或甘)，以及许多小决定(例如批量大小，测试/训练分割，正则化，辍学，噪声等)。在某些情况下，预训练的神经网络(如 VGG-19)或预定义的神经网络形状(如自动编码器)会比从头开始更接近解决方案。对于完全定制的神经网络配置，我们在 keras 中获得了许多超酷的超参数选项，如 L1 和 L2 的正则化、DNN 层宽度、网络形状(自动编码器、固定宽度、…)、学习速率等等。

As you go through the design space exploration, you find that many of the possible hyperparameter settings are very useless.

程序员喜欢使用配置参数，例如生产/开发设置。我们对这个使用 ConfigParser。然而，深度学习中的超参数更类似于一系列嵌套 for 循环的，在爆发之前搜索“好”的配置。该搜索必须扫描可用的机器学习模型以找到一个具有低误差的模型(或者无论目标函数是什么)。您可以将这些模型超参数视为配置。然而，将超参数选择搜索视为帕累托优化更准确，其中约束是 GPU 的大小，目标是损失/准确性、通用性(精度、召回、F 分数)和其他模型性能标准。有很多模型约束是没有问题的。真正糟糕的是，你有多个目标，有些约束是整数。当面对一个优化问题中的多个目标时，你需要或者创建这些目标的线性组合(线性模型)，可能做一些疯狂的数学(参见混合整数线性规划)，或者只是将此作为元级机器学习问题(研究！).因为多目标 Pareto 东西是如此丑陋和缓慢(读作 expen$ive )，所以基本上规则是尝试有意义的东西，直到你达到可接受的模型性能水平。我的硕士学位是设计空间探索，所以我直接知道在多重约束下选择一个给定的配置有多困难。

在我结束之前，我今天得到一些非常有趣的消息。 API。AI ，已经改名为 Dialogflow 。他们重定向了域名和一切。我认为在某个时候，谷歌会把它建成 dialogflow.google.com，就像他们对 AdWords 和 inbox 等其他谷歌产品所做的那样。或者，它可能会被谷歌云平台吞噬，就像亚马逊对其 AWS 云服务所做的那样。

好的。回去工作！如果你喜欢这篇关于人工智能的文章，那么请尝试一下拍手工具。轻点那个。跟着我们走。去吧。我也很高兴在评论中听到你的反馈。你怎么想呢?我是不是用了太多的括号？我应该写些什么？写了一堆业务端的文章，最近兴趣更多在技术端。不如这样:把你的数据科学用例或问题发给我，我会挑选一个条目来写一篇关于它的文章。去吧:丹尼尔@lsci.io

编码快乐！

-丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴上标签

2019 年的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-in-2019-bb5cf3d39e4e?source=collection_archive---------11-----------------------

或者机器学习如何进化成人工智能

这些是我对深度神经网络和机器学习在更大的人工智能领域的发展方向的看法，以及我们如何才能获得越来越多的复杂机器来帮助我们的日常生活。

请注意，这些不是预测的预测，而是对这些领域的轨迹、趋势和我们实现有用的人工智能的技术需求的详细分析。

我们还将研究唾手可得的成果，例如我们今天可以开发和推广的应用程序！

目标

该领域的目标是制造出具有超越人类能力的机器。自动驾驶汽车、智能家居、人工助手、安全摄像头是首要目标。家庭烹饪和清洁机器人是第二个目标，此外还有无人驾驶飞机和机器人。另一个是移动设备上的助手或永远在线的助手。另一个是全职伴侣助手，可以听到和看到我们在生活中经历的事情。一个最终目标是一个完全自主的合成实体，在日常任务中可以达到或超过人类水平的表现。

软件

软件在这里被定义为用优化算法训练来解决特定任务的神经网络架构。

今天，神经网络是事实上的学习工具，用于解决涉及学习的任务，监督从大型数据集对进行分类。

我们如何从目前的神经网络转向人工智能？

1-神经网络架构-几年前，当该领域蓬勃发展时，我们经常说它具有从数据中自动学习算法参数的优势，因此优于手工制作的功能。但是我们很方便地忘记提到一个小细节…作为解决特定任务的训练基础的神经网络架构不是从数据中学习的！事实上，它仍然是手工设计的。根据经验手工制作，这是目前该领域的主要限制之一。神经网络架构是学习算法的基础核心。即使我们的学习算法能够掌握一项新任务，如果神经网络不正确，它们也将无法掌握。但是在这个地区有很多活动，我们在这里回顾了一下。从数据中学习神经网络架构的问题是，目前在大型数据集上试验多种架构需要太长时间。人们必须从头开始尝试训练多种架构，看看哪一种工作得最好。这正是我们今天使用的耗时的试错程序！我们应该克服这个局限，在这个非常重要的问题上多动脑筋。

2-当前神经网络的局限性-我们之前已经讨论过目前神经网络的局限性。不能预测，不能对内容进行推理，并且具有时间不稳定性——我们需要一种新型的神经网络，你可以在这里阅读。

Encoder-Decoder neural network

连接到上一节的主题，神经网络正在演变为编码器-解码器，其中编码器是一个将数据压缩为短代码(表示)的网络，解码器则扩展该表示以生成另一个更大的表示(将这些想象为生成的图像、心理模拟、图像上作为边界框和分段遮罩的高光)。我们已经广泛讨论了如何使用这样的网络来定位和检测图像和视频中的关键点这里；另请参见此分析。这也是预测神经网络的主要成分(更多内容见下文)。

无监督学习(Unsupervised learning)——我们不能总是在我们的神经网络旁边，在它们生命的每一站和每一次经历中指导它们。我们不能每次都纠正他们，并对他们的表现提供反馈。我们有自己的生活要过！但这正是我们今天对监督神经网络所做的:我们在每一个实例中提供帮助，使它们正确地执行。相反，人类只从少数几个例子中学习，并且可以不断地自我修正和学习更复杂的数据。我们已经广泛讨论了无监督学习这里。

4-预测神经网络— 当前神经网络的一个主要限制是它们不具备人脑最重要的特征之一:预测能力。关于人脑如何工作的一个主要理论是通过不断进行预测:预测编码。你想想，我们每天都在经历。当你举起一个你认为很轻但结果很重的物体时。它让你感到惊讶，因为当你走近去捡它的时候，你已经预测到它会如何影响你和你的身体，或者你的整体环境。

建立预测神经网络是与现实世界互动的核心，也是在复杂环境中行动的核心。因此，这是任何强化学习工作的核心网络。见下文。

我们广泛讨论了预测神经网络的主题，并且是研究和创建预测神经网络的先驱团体之一。有关预测神经网络的更多详细信息，请参见此处的，此处的，此处的。

5-持续学习-这很重要，因为神经网络在其生命周期中需要不断学习新的数据点。当前的神经网络不能够学习新数据，除非在每个实例中从头开始重新训练。神经网络需要能够自我评估新训练的需求以及它们确实知道一些东西的事实。这在现实生活和强化学习任务中也是需要的，我们希望教会机器在不忘记旧任务的情况下完成新任务。持续学习也与转移学习、或者我们如何通过观看视频让这些算法自己学习，就像我们想学习如何烹饪新东西一样？这是一种需要我们上面列出的所有要素的能力，对于强化学习也很重要。

更多详情，请参见我们的近期结果摘要。

6-强化学习— 这是深度神经网络研究的圣杯:教会机器如何在一个环境中学习行动，真实的世界！这需要自我学习、持续学习、预测能力，以及更多我们不知道的东西。在强化学习领域有很多工作，我们已经在这里和最近在这里讨论过这个。

一种深度神经网络，它接受大量数据输入，如视频或音频，并将其压缩成表示形式
学习任务的序列学习神经网络，如 RNN

这两个组件都是每个人都在使用的，因为它们是可用构建模块的一部分。尽管如此，结果并不令人印象深刻:是的，我们可以从头开始学习玩视频游戏，并掌握完全可观察的游戏，如国际象棋和围棋——今年甚至通宵训练！—但我不需要告诉你，与解决复杂世界中的问题和像我们一样运作的机器相比，这根本不算什么。

我们认为预测神经网络对于强化学习是不可或缺的。好奇心，这是今天在这个领域的说法！敬请关注更多内容！

8-不再有递归神经网络——递归神经网络(RNN)不再流行。RNN 在训练并行化方面特别糟糕，即使在特殊的定制机器上也很慢，因为它们的内存带宽使用率非常高——因此它们是内存带宽受限的，而不是计算受限的，更多细节请参见这里的。基于注意力的尤其是卷积神经网络在训练和部署时更高效、更快速，并且在训练和部署时更少受到可扩展性的影响。

我们已经看到卷积和基于注意力的神经网络将慢慢取代基于 RNN 的语音识别，并在强化学习架构和人工智能中找到它们的方式。

五金器具

深度学习的硬件是进步的核心。现在让我们忘记深度学习在 2008-2012 年以及最近几年的快速扩张主要是由于硬件:

每部手机中的廉价图像传感器都可以收集大量的数据集——是的，社交媒体对此有所帮助，但只是在一定程度上
允许 GPU 加速深度神经网络的训练

而在之前我们已经广泛的谈过硬件。但是我们需要给你一个最近的更新！在过去的两年里，机器学习硬件领域出现了蓬勃发展，特别是针对深度神经网络的领域。我们在这方面拥有丰富的经验，已经设计了 5 代深度神经网络加速器(参见最近的 FWDNXT )。

有几家公司在这个领域工作:英伟达(显然)、英特尔、Nervana、Movidius、比特大陆、Cambricon、Cerebras、DeePhi、谷歌、Graphcore、Groq、华为、ARM、Wave Computing 等。所有这些公司都在开发定制的高性能微芯片，这些芯片将能够训练和运行深度神经网络。

关键是在计算最近有用的神经网络运算时，提供最低的功耗和最高的测量性能，而不是像许多人声称的那样，每秒进行原始的理论运算。

但该领域很少有人了解硬件如何真正改变机器学习、神经网络和人工智能。很少有人了解微芯片的重要性以及如何开发它们。几个想法:

架构:许多人认为计算机架构只是一系列乘法器和加法器。但不是所有的架构都是一样的。有些比其他的更好，可以最小化内存带宽，并保持所有单元一直被占用。
编译器:许多人认为硬件不重要，神经网络编译器才是关键。但是，当你设计自己的硬件时，编译器只是在优化的机器代码中解释神经网络计算图。开源编译器(其中很多是去年才出来的！)只能帮到这么多，鉴于最困难的一步确实取决于秘密架构。虽然开源编译器可以作为前端，但在硬件架构和神经网络图的交叉点上仍然有很多秘密。
微芯片:一旦算法变得重要，优化性能功耗比的最佳方式就是定制微芯片或 ASIC 或 SoC。它们可以提供比 FPGAs 更快的时钟和更小的电路面积。FPGAs 现在包括深度神经网络加速器，预计将在 2019-2020 年推出，但微芯片将永远是更好的表现者。
进步:有几项进步将允许硅深度神经网络加速器轻松地获得 10-20 倍的性能，即使不使用微芯片缩放。在使用更少的比特数、系统级封装、高级存储器等方面寻找进步。

关于神经形态神经网络硬件，请看这里。关于模仿真实神经网络的评论是这里。

应用程序

我们在上面的目标部分简单地讨论了应用程序，但是我们真的需要在这里深入细节。AI 和神经网络将如何进入我们的日常生活？

以下是我们的列表:

对图像和视频进行分类——已经在许多云服务中使用。接下来的步骤是在智能摄像机源中做同样的事情——今天也是由许多提供商提供。神经网络硬件将允许移除云，并在本地处理越来越多的数据:隐私和节省互联网带宽的赢家。
基于语音的助手正在成为我们生活的一部分，因为它们在我们的“智能”家庭中播放音乐和控制基本设备。但是对话是如此基本的人类活动，我们常常认为它是理所当然的。你可以与之交谈的小设备是一场正在发生的革命。基于语音的助手越来越好地为我们服务。但是它们仍然和电网相连。我们真正想要的助手会和我们一起走。我们的手机呢？硬件再次胜出，因为它将使这成为可能。Alexa 和 Cortana 和 Siri 将永远在线，永远与你同在。你的手机将很快成为你的智能家居。这是智能手机的又一次胜利。但是我们也希望它在我们的车里，当我们在镇上走动时。我们需要本地语音处理，越来越少的云。更多的隐私和更少的带宽成本。同样，硬件将在 1-2 年内为我们提供所有这些。
真正的人工助手 —语音很棒，但我们真正想要的是也能看到我们所看到的东西的东西。当我们四处走动时，分析我们的环境。参见示例此处和最终此处。这才是我们能爱上的真正的 AI 助手。神经网络硬件将再次满足你的愿望，因为分析视频馈送在计算上非常昂贵，并且目前处于当前硅硬件的理论极限。换句话说，这比语音助手要难做得多。但这并不是不可能的，许多像 AiPoly 这样的聪明的初创公司已经拥有了所有的软件，但缺乏在手机上运行它的强大硬件。还要注意的是，用一个类似眼镜的可佩戴设备代替手机屏幕将真正让我们的助手成为我们的一部分！
烹饪机器人——下一个最大的电器将是烹饪和清洁机器人。在这方面，我们可能很快就有了硬件，但我们显然缺乏软件。我们需要迁移学习、持续学习和强化学习。一切都运转良好。因为你看:每个食谱都不一样，每个烹饪原料看起来都不一样。我们不能硬编码所有这些选项。我们真的需要一个能够很好地学习和归纳的合成实体来做这件事。我们离它很远，但没有那么远。按照目前的发展速度，只需要几年的时间。我一定会像过去几年一样努力~

这篇博文将会发展，就像我们的算法和我们的机器一样。请尽快再次检查。

关于作者

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

医学中的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-in-medicine-1fd2748a9f87?source=collection_archive---------9-----------------------

用于诊断、药物开发、个性化治疗和基因编辑的人工智能

机器学习在制药和生物技术效率方面取得了巨大进步。这篇文章总结了今天人工智能在医学中的4 大应用:

1.诊断疾病

正确诊断疾病需要多年的医学训练。即便如此，诊断通常也是一个费力费时的过程。在许多领域，对专家的需求远远超过了现有的供给。这给医生带来压力，并经常延误挽救生命的病人诊断。

机器学习——特别是深度学习算法——最近在自动诊断疾病方面取得了巨大进展，使得诊断更便宜、更容易获得。

机器如何学习诊断

机器学习算法可以学习以类似于医生看待模式的方式来看待模式。一个关键的区别是算法需要大量的具体例子——成千上万——以便学习。而且这些例子需要整齐地数字化——机器无法读懂教科书的字里行间。

因此，在医生检查的诊断信息已经数字化的领域，机器学习尤其有用。

比如:

基于 CT 扫描检测肺癌或中风
根据心电图和心脏核磁共振图像评估心脏猝死或其他心脏疾病的风险
对皮肤图像中的皮肤病变进行分类
在眼睛图像中发现糖尿病视网膜病变的指标

Examples of AI diagnosing diseases

由于在这些案例中有大量可用的好数据，算法变得和专家一样擅长诊断。不同的是:算法可以在几分之一秒内得出结论，而且可以在全世界廉价复制。很快，每个人、每个地方都可以以较低的价格获得与放射诊断学顶级专家 T21 同等质量的服务。

更先进的人工智能诊断即将推出

机器学习在诊断中的应用才刚刚开始——更雄心勃勃的系统涉及多种数据源 (CT、MRI、基因组学和蛋白质组学、患者数据，甚至手写文件)的组合，以评估疾病或其进展。

人工智能不会很快取代医生

人工智能不太可能完全取代医生。相反，人工智能系统将用于为专家突出显示潜在的恶性病变或危险的心脏模式——允许医生专注于这些信号的解释。

2.更快地开发药物

众所周知，开发药物是一个昂贵的过程。药物开发中的许多分析过程可以通过机器学习变得更加有效。这有可能削减多年的工作和数亿美元的投资。

人工智能已经成功应用于所有的 4 药物开发的主要阶段:

阶段 1:确定干预目标

药物开发的第一步是了解疾病的生物学起源(途径)及其耐药机制。然后你必须确定治疗疾病的好目标(通常是蛋白质)。高通量技术的广泛应用，如短发夹 RNA (shRNA)筛选和深度测序，大大增加了发现可行靶途径的可用数据量。然而，使用传统技术，集成大量不同的数据源，然后找到相关的模式，仍然是一个挑战。

机器学习算法可以更容易地分析所有可用的数据，甚至可以学习自动识别良好的目标蛋白质。

阶段 2:发现候选药物

接下来，你需要找到一种化合物，它可以以期望的方式与识别的目标分子相互作用。这包括筛选大量——通常是数千甚至数百万——潜在化合物对靶标的影响(亲和力)，更不用说它们的非靶标副作用(毒性)。这些化合物可以是天然的、合成的或生物工程的。

然而，目前的软件往往不准确，并产生许多错误的建议(假阳性)，因此需要很长时间才能将范围缩小到最佳候选药物(称为线索)。

机器学习算法在这里也可以有所帮助:它们可以学习根据结构指纹和分子描述符来预测分子的适用性。然后，他们从数百万个潜在分子中筛选出最佳方案——副作用最小的方案。这最终节省了药物设计的大量时间。

第三阶段:加速临床试验

临床试验很难找到合适的候选人。如果你选择了错误的候选人，将会延长审判时间——耗费大量的时间和资源。

机器学习可以通过自动识别合适的候选人以及确保试验参与者群体的正确分布来加快临床试验的设计。算法可以帮助识别区分好的候选人和坏的候选人的模式。它们还可以作为一个早期预警系统，用于没有产生结论性结果的临床试验——允许研究人员更早地干预，并有可能挽救药物的开发。

阶段 4:寻找用于诊断疾病的生物标志物

一旦你确定了你的诊断，你就可以对病人进行治疗。有些方法非常昂贵，需要复杂的实验室设备和专业知识，比如全基因组测序。

生物标记是在体液(通常是人的血液)中发现的分子，提供了关于患者是否患有疾病的绝对确定性。他们使 T2 的疾病诊断过程变得安全而廉价。

你还可以用它们来确定疾病的发展——使医生更容易选择正确的治疗方法，并监测药物是否有效。

但是为特定疾病发现合适的生物标志物是困难的。这是另一个昂贵、耗时的过程，包括筛选成千上万的潜在分子候选物。

人工智能可以自动化很大一部分人工工作，并加快这一进程。这些算法将分子分为好的和坏的候选分子——这有助于临床医生专注于分析最佳前景。

可用于鉴定的生物标志物:

尽早发现疾病— 诊断生物标志物
患者患病的风险— 风险生物标志物
疾病的可能进展— 预后生物标志物
患者是否会对药物产生反应— 预测性生物标志物

3.个性化处理

不同的患者对药物和治疗方案的反应不同。因此，个性化治疗在延长患者寿命方面有着巨大的潜力。但是很难确定哪些因素会影响治疗的选择。

机器学习可以自动化这一复杂的统计工作，并帮助发现哪些特征表明患者将对特定治疗产生特定反应。因此，该算法可以预测患者对特定治疗的可能反应。

该系统通过交叉引用相似的患者并比较他们的治疗和结果来学习这一点。由此产生的结果预测使医生更容易设计正确的治疗方案。

4.改进基因编辑

聚集的规则间隔短回文重复序列(CRISPR)，特别是用于基因编辑的 CRISPR-Cas9 系统，是我们经济高效地编辑 DNA 的能力的一大飞跃——准确地说，就像外科医生一样。

这种技术依赖于短指导 RNA(sgRNA)来靶向和编辑 DNA 上的特定位置。但是指导 RNA 可以适合多个 DNA 位置——这可能导致意想不到的副作用(脱靶效应)。仔细选择具有最小危险副作用的指导 RNA 是 CRISPR 系统应用中的一个主要瓶颈。

机器学习模型已被证明在预测给定 sgRNA 的导向-目标相互作用和脱靶效应的程度时产生最佳结果。这可以显著加快人类 DNA 每个区域的指导 RNA 的发展。

摘要

人工智能已经在帮助我们更有效地诊断疾病，开发药物，个性化治疗，甚至编辑基因。

但这只是的开始。我们越是数字化和统一我们的医疗数据，我们就越能使用人工智能来帮助我们找到有价值的模式——我们可以使用这些模式在复杂的分析过程中做出准确、经济高效的决策。

作者我是柏林机器学习咨询公司 Data Revenue 的首席执行官。联系如果你想了解更多人工智能在医学或我们工作中的应用。

最初发表于www.datarevenue.com。

自动驾驶汽车中的人工智能—第 1 部分

原文：https://towardsdatascience.com/artificial-intelligence-in-self-driving-cars-part-1-90dd2ea55751?source=collection_archive---------3-----------------------

不久前看似虚构的自动驾驶汽车已经成为汽车和科技行业的热门话题。像谷歌、百度、特斯拉这样的新玩家正在跳入这个领域，竞争加剧了，截至目前，几乎所有的汽车制造商都宣布了他们对自动驾驶的开发努力。

现在已经很清楚，视觉传感元件，如相机、激光雷达(就像谷歌自动驾驶汽车上的威力登激光雷达)、雷达、声纳、夜视系统、近程传感器等。是自动驾驶技术最重要的使能元素。这些传感器安装在车身上，形成周围环境的实时三维图像。然后将这些图像与现有的 3D 地图进行比较，智能算法能够采取适当的行动来驾驶汽车，而无需任何人工干预。汽车的精确定位，传感器融合以评估来自不同传感器的数据是自动驾驶技术的其他重要组成部分。

正确分析这些不同的输入，并在很短的时间内采取“正确”的行动是关键。但是,“正确”的行动很难确定，因为现实世界的驾驶场景很复杂，有许多可能性。将所有不同的可能性编码到软件中是一项不可能的任务。这就是像深度学习和神经网络这样的人工智能分支变得如此重要的原因。它包括软件，自我从不同的情境中学习，并不断改进其性能。将这种软件暴露在真实生活驾驶条件的大量数据中，可能是提高自动驾驶汽车采取“正确”行动的准确性的关键。这就是人工智能最近成为自动驾驶技术焦点领域的原因。

许多汽车公司和自动驾驶公司已经宣布了不同的举措来增强他们的人工智能能力，以便他们不会落后于谷歌这样的新时代公司，谷歌已经在该领域处于领先地位。下面的新闻故事将证实这一点。

福特、丰田和大众与英伟达、三星、高通和松下一起成立了 DeepDrive 联盟，专注于人工智能研究。他们每人给加州大学伯克利分校 30 万美元，资助人工智能研究。(链接
丰田在硅谷成立了一个新的组织——丰田研究所，专注于人工智能和自动驾驶技术。它宣布了与麻省理工学院和斯坦福大学在人工智能研究方面的实验室合作伙伴关系，以及 1B·R&D 在该领域为期五年的努力。它还计划聘请 200 名研究科学家来推进人工智能的研究。(链接
丰田雇佣了 Jaybridge Robotics 的所有员工，Jay bridge Robotics 是一家麻省理工学院的初创公司，专注于丰田研究所的自动驾驶汽车技术。(链接
丰田还收购了总部位于东京的广受好评的机器学习初创公司 Preferred Networks 的股份，以加速其在人工智能领域的努力。(链接)

丰田虽然加入自动驾驶的行列较晚，但自 2015 年底以来已经做出了重大宣布，明确了其自动驾驶的雄心。它还专注于人工智能，而不是与其他公司合作开发此类技术。尽管许多其他汽车公司正在研究自动驾驶汽车，但它们已经考虑与宝马和百度等新时代科技公司合作，或者福特和谷歌之间的谈判。汽车公司似乎也与 Mobileye 和 Nvidia 等合作伙伴合作，或与学术界进行各种合作，以发展人工智能能力。然而，丰田似乎专注于拥有这样的技术，并在人工智能研究上投入了大量资源，而不是与其他公司合作。

也有一些初创公司试图解决自动驾驶技术的各种障碍。大多数这样的创业公司都是从主要大学的研究中分离出来的。这里有几个这样的例子

( Data from Tracxn )

(第二部分重点关注实现无人驾驶汽车的不同方法以及人工智能在每种方法中的使用。)

斯德哥尔摩的人工智能

原文：https://towardsdatascience.com/artificial-intelligence-in-stockholm-24132cbb35a2?source=collection_archive---------0-----------------------

Photo credit: Online Graphic Design Course

人工智能是世界上最受关注的技术之一，它不再仅仅是科幻小说的一部分，而是用美国总统巴拉克·奥巴马的话说“已经以各种方式渗透到我们的生活中”。Gartner 将人工智能确定为 2017 年的顶级技术趋势。

它就在这里，但与《黑客帝国》或《终结者》等科幻片相比，它看起来不像是一个大的威胁。尽管人们仍在质疑它将如何改变我们的社会，但新的智能产品和服务的开发正以前所未有的速度蓬勃发展。

例如，一个人工智能机器人成为北欧科技巨头 Tieto 的官方董事会成员，并且拥有投票权！

在斯德哥尔摩，一些独角兽公司，如 Klarna 或 Spotify，将人工和扩展智能作为其产品和业务不可或缺的一部分，有时会被忽视。对其他人来说，人工智能是他们销售产品的核心。最近，Stockholm.ai 社区开始了一系列以人工智能为主题的聚会。它向想知道为什么斯德哥尔摩是经营人工智能公司的好地方的企业家、开发人员、技术人员和投资者开放。

这里是对斯德哥尔摩人工智能社区中一些最有趣的玩家以及人工智能领域中一些非常新的成员的概述。

瓦蒂

经过三年多的经营， Watty 已经是一家经验丰富的人工智能初创公司:

Watty 成立于 2013 年，是一个市场领先的机器学习平台，为客户提供即时和在线的能源消耗测量，细分到各个家用电器。
Watty 在多个场合获得了资金，最著名的是 2016 年 7 月完成的 300 万€回合。主要投资者包括 Cleantech Invest 和 EQT Ventures。
首席执行官 Hjalmar Nilsonne 在绿色技术领域有着丰富的经验，

多雷米尔

没有那么夸张，但绝对值得一听的是多雷米尔

Doremir 通过将录制的声音和旋律转换成符号，将 Shazam 等应用程序提升到了一个新的水平。
由两位 Svens，ahl bck 和 Emtell 在 2008 年成立，他们都是音乐和认知领域的研究人员，他们在 2013 年发布了他们的应用程序 ScoreCloud。
首席执行官 Bengt Lidgard 于 2013 年加入，这一年见证了《卫报》、《连线》和《福布斯》等媒体对该产品的报道。
瑞典风险投资基金 Almi Invest 与瑞典和外国投资者一起支持该项目。

米玛

同样活跃在音乐产业和娱乐领域的还有年轻的初创公司 Mima

Mima 于 2016 年 3 月正式推出，为实时了解娱乐创造了先进的平台。
使用人工智能和深度学习来跟踪趋势，为音乐、电视、电影和游戏的最新发展提供有价值的见解。
以瑞典诺贝尔奖获得者哈里·马丁森的科幻诗 Aniara 中的全知电脑命名。

亨利

像米玛一样，来自 2016 届的同一个班级，来了一个新的孩子亨利:

Henry 是一个虚拟辅助工具，旨在收集员工的想法和见解。
帮助跟踪团队和部门内的工作生活平衡和员工幸福感。
由弗雷德·亚伯拉罕森、汤米·恩斯特伦和维德兰·伊斯梅利创立。
成立于 2016 年 1 月，位于 SUP46。

专注于人工智能的初创公司正在快速发展，有些仍然处于隐形模式。去年出现了一批有趣的引人注目的公司，比如以下四家初创公司:

夹铁

与垫片交谈。

Shim 是聪明又善解人意的朋友，是 100%人工的。
该公司网站称，通过与 Shim 交谈，用户可以更好地了解自己，并与所爱的人建立更牢固的关系。
Hoa Ly 拥有心理学博士学位，除了在一个由心理学家、研究人员、作家、工程师和设计师组成的团体中担任 Shim 的联合创始人之外，还是一名 DJ。
Shim 成立于 2015 年 5 月，目前仍处于测试阶段，但可以在他们的网站上进行测试。

健康习惯

Healthi Habits 利用人工智能、机器学习和行为经济学的结合，发现健康的习惯，帮助人们进行可持续的行为改变。
H2 健康中心坐落在斯托克霍姆新的电子健康中心，与多家初创公司一起，如虚拟现实公司 Mimerse 和获奖公司 Qinematic 。
他们成立于 2015 年 12 月，最初专注于糖尿病患者，但正在寻求扩展到其他用户群体

2015 年还出现了两家新公司，Dooer 和 Qvitoo，它们都计划挑战和颠覆成熟且耗时的会计行业。

杜尔

Dooer 利用人工智能软件解决方案开发现代簿记系统，无需会计人员即可自动处理所有发票信息。
由连续创业家 Sam Nurmi 创建，据 breakit.se 报道，他通过出售之前的公司 Pingdom 赚了近 5 亿 SEK。据同一媒体报道，该公司在 2016 年夏天获得了 4000 万 SEK，其中大部分来自萨姆·努尔米本人。
临近它的第一个生日，公司已经有 30 多名员工。

Qvitoo

Qvitoo 只需拍张照片，就能帮助创始人和企业家追踪发票和收据——剩下的事情由软件和人工智能来完成。
除了为专业人士提供服务之外，Qvitoo 还专注于那些可以轻松跟踪和记录自己支出的消费者。
他们的服务集成了市场上最常见的会计软件。
由拥有 10 年软件顾问经验的 Henrik Feldt 和 Mikko Lappalainen 于 2015 年创立。

在先进计算机的扩展智能的帮助下，难怪许多公司都关注大数据和人工智能。这三家公司有非常不同的产品，但都在这两个领域工作。

加瓦盖

Gavagai 由数据科学家马格努斯·萨尔格伦和尤西·高本汉于 2008 年创立，Gavagai 专门从事大型文本样本的实时数据分析。
2015 年秋季，该公司在第二轮种子融资中筹集了 1000 万 SEK，估值为 6200 万 SEK。
他们的 Explorer 工具经过优化，可用于分析问卷中开放式答案的文本数据，这一过程通常是手动完成的，非常耗时。

Vionlabs

由 Arash Pendari 于 2010 年创立的 Vionlabs 一直致力于开发一种分析工具，帮助电影制片人、流媒体网站和网络运营商了解他们客户的娱乐习惯。
Vionlabs 之前专注于 B2C 解决方案，现在专注于 B2B。
投资者中有风投 Northzone、另一家瑞典初创公司的董事会主席、 Truecaller 、斯特凡·伦哈默和瑞典著名演员迈克尔·恩奎斯特。
同样的投资者在 2015 年第一轮投资中选择了 2500 万 SEK。较小的一轮于 2016 年 1 月结束。

哈特兰

SaaS 初创公司，提供对公司目标受众更深入的理解和洞察。
使用大数据和机器学习作为主要工具，并在 2016 年初与投资者和顾问 Mattias ost mar 一起更加关注人工智能的发展。
由 Niklas Lohmann、Sriram Elango 和 Stefan Krafft 于 2014 年创立。
Propel Capital 在 2015 年的早期种子轮投资了 30 万美元

艾制造

【人工智能制造的是一家人工智能初创公司，它使用深度学习和生成模型来为物理对象生成独特的设计。
顾客可以买到世界上第一条由人工智能设计的项链。
人工智能背后的团队对人工智能的创造性应用有着浓厚的兴趣。

随着专注于人工智能的初创公司数量的增长以及行业、政策和投资者的兴趣，斯德哥尔摩的人工智能很可能在未来发挥更大的作用。而且很有可能你已经在用斯德哥尔摩的一个人工智能集成产品了。

在之前一篇关于斯德哥尔摩 VR 的文章中，我写了一篇关于初创公司 Gleechi 的文章，该公司专门制作手部模拟，供游戏、医疗保健、机器人等领域的开发人员使用。他们获奖的虚拟抓握部分基于深度机器学习和人工智能。

开创性的研究也正在一个看似远离创业现场的世界中进行。在斯德哥尔摩市中心的南郊坐落着一家超过 10 年历史的咨询公司 Peltarion，专注于所有与人工智能相关的事情。一个值得注意的项目是他们与露露艺术集团的合作，其中一项成果是计算机生成舞蹈编排系统。像 Dooer、Thingmap、Norwegian Meltwater 和 Augify 这样的公司都有一个共同点，那就是他们一直在与当地的 Graph-Technologies 合作，这是一家咨询公司，开发机器学习产品和建议，指导和培训企业家和公司关于人工智能的来龙去脉。

最近，数据安全公司 EyeonID 上市，初创公司 Imago 获得了来自当地商业天使的新投资。人工智能革命已经明确袭击了斯德哥尔摩，未来几年很可能会出现新的深度学习创业公司的增加。

在 Invest Stockholm ，我们安排投资者与被选中的有前途的初创公司会面。如果你想了解更多关于 Stockholms AI 场景的可能性，不要犹豫联系。

关注我的Twitter和Linkedin获取更多关于北欧科技场景的帖子。感谢 鲁洛夫·皮特 对这篇文章的贡献。

人工智能是小孩子的游戏

原文：https://towardsdatascience.com/artificial-intelligence-is-childs-play-633444489426?source=collection_archive---------8-----------------------

或者增量收益如何让你迈出小步

我想澄清一个关于人工智能的误解。

我告诉人们我的职业，他们认为我有博士学位。他们认为我可以凭记忆证明所有支撑算法的数学。他们认为他们永远做不了我的工作。

事实上，我是一名软件工程师，无意中发现自己在做机器学习。我并没有打算去找这份工作，但它非常适合我，我想要挑战。这是一个陡峭的学习曲线，但如果你愿意投入工作，那么你就能够建立人工智能。

有些事情你只有深入到一个真实的项目中才会知道。

确实有拥有数百名博士的公司在研究像自动驾驶汽车这样的难题。但是对于每一个 Waymo 来说，都有一些小公司刚刚涉足机器学习领域。

花一分钟时间想一想你的业务中哪一部分会从自动化中受益。现在考虑完全自动化任务所涉及的工作。令人畏惧，对吧？但是你已经知道你一步一步地爬山。试着把问题分成更小的里程碑。

我参与的第一个机器学习项目是一个客户服务聊天机器人。我并没有打算通过图灵测试——测试机器表现出与人类无异的智能行为的能力。我看了看我们的数据集，发现我可以对大约 20%的问题给出固定的回答。那是我的目标。

目标:通过提供常见问题解答，处理 20%的客户服务查询。

实现这一目标仍然代表着真正的商业利益。五分之一的查询在到达客户服务团队之前得到处理。这减少了他们 20%的工作量。我每周给他们额外的一天时间来完成其他任务。即使一个适度的目标也会降低成本。

如果你有一个现实的目标，你会用不同的心态来处理问题。不是压倒性的。你不要试图改变世界。你解放自己去尝试事情，没有对失败的极度恐惧。

一旦你实现了你的小目标，你也为自己争取了时间去实现下一个目标。很难说服你的老板你需要一年的时间来完全自动化一个过程。要求用 6 周时间自动化 20%的流程要容易得多，如果证明对业务有价值，可以考虑在下一年继续进行。

有信心看看你的业务，看看机器学习是否适合。你不需要成为数字天才，你不需要能够从第一原理证明算法。如果你能学到足够多的关于 numpy 或 T2 的知识来解决这个问题，那就去做吧。没有利益相关者会问你是如何取得成果的。他们不关心机械。他们关心结果。

不要让被认为的无能阻碍你。相信你可以投入到一个项目中并产生结果。你不必用你的第一个项目来改变世界。选择一个目标，努力工作直到实现它。然后选择一个更大的目标，朝着这个目标努力。

如果你已经读到这里，那么我希望你选择一些自动化的东西。它需要一些重复性的东西，产生大量的数据。然后检查问题，找出你能做的最简单的事情来改变现状。最后，向你的利益相关者推销这种好处。比起神经网络和矩阵，他们更关心百分比。

我是一名软件开发人员，总部位于英国伯明翰，致力于解决大数据和机器学习问题。我在工作中学习。我没有所有的答案，但我正在获得许多经验。关注我的 Twitter 查看我的最新帖子。

人工智能不是产品差异化，而是可负担性

原文：https://towardsdatascience.com/artificial-intelligence-is-not-product-differentiation-but-affordance-335ce0651fb0?source=collection_archive---------4-----------------------

本着开放的精神，大型和专门的人工智能(AI)社区将他们的见解公开，每个人都可以访问。这种开放性对 AI 产品化的影响将产生这样的效果，即 AI 不会成为一种产品差异化，而是一种可负担性。

人工智能研究是开放的

目前，人工智能(AI)和机器学习(ML)社区是最活跃的两个研究社区。理论家和实践者一起工作，推动可能性的边界，在过去的十年里，他们一起极大地推进了最先进的技术。

开放的科研出版平台是传播人工智能研究成果的重要基石。开放科学模式缩短了传统的同行评议的出版过程，使研究材料一准备好就可以访问。这极大地加快了正在进行的研究工作，因为研究人员可以立即从其他小组获得结果，并在他们的研究中做出回应。此外，研究博客和教程帮助新进入者爬上人工智能的陡峭学习曲线。网络研讨会和在线课程使人们很容易从社区中一些最聪明的人的教导中受益。

人工智能平台的商业产品旨在消除人工智能的存储和计算障碍。它们提供了接口和后端系统，极大地促进了人工智能在系统中的实现和集成。因此，每个对人工智能有很好理解的人都可以在他们的原型和产品中利用人工智能。

人工智能成功案例

有用的产品解决现实世界的挑战，从而创造价值。解决人工智能固有的挑战有其自身的优点，但研究的成功并不直接转化为产品领域。产品的成功是由客户推动的。这可以通过它的采用率来衡量。自然，一个成功的产品很快就会有模仿者，他们正在争夺客户的注意力和市场份额。产品差异化为产品销售者创造了竞争优势，因为顾客认为这些产品是独一无二的或优越的。

在一个产品中添加人工智能组件既不会使它变得更好，也不会改变它的默认设置。失败的创业公司认为他们在产品中“高估了机器学习”。事实上，ML & AI 通常只是拼图的一部分。让我们来看一些使用 ML 的成功应用的例子和它们的促成因素:视频流服务基于偏好和观看历史向他们的客户推荐电影。他们的先决条件是一个能按需向用户提供电影的系统。网络搜索和社交网络会自动对图片进行分类。这需要在查询时存储和检索相关图像的能力。信用卡公司分析客户的消费行为，以识别欺诈交易。这只能在启用某些交易的红色标记的活动处理系统中完成。

人工智能提高效率

这些例子的共同主题是有一个 system。ML 补充了这个系统，例如，通过增加和控制用户交互。这些系统本身已经在创造价值。即使这些公司取消了 ML 部分，他们的系统仍然可以提供很好的服务。在这些例子中，ML & AI 是一种渐进的改进。这种推理的关键要点是，人工智能不是构建伟大系统的捷径。更直白的说，AI 并不是把一个平庸的系统在一个顶级产品里。

此外，使用人工智能的产品的竞争优势很小。即使一个市场参与者可能会因为集成人工智能技术而领先，领先优势也会减少，因为竞争对手会很快赶上来。原因是人工智能研究的开放性和人工智能工具和框架的广泛可用性。鉴于技术的快速进步，阻止竞争对手迎头赶上是很困难的。人工智能社区很快发现了人工智能的新应用，并将其复制到研究领域。例如，这是 OpenAI 的目标之一。

具有讽刺意味的是，使我们能够构建高级人工智能产品的同一件事情却使人工智能无法成为产品的区分器。为了建立一个真正的基于人工智能的产品，人工智能必须超越增量改进。想想骑一辆没有方向盘的车。显然，没有人工智能算法的控制是不可能的。

人工智能作为可提供性

在产品设计中，启示定义了产品可能的使用方式。更正式的，启示决定了对象的属性和使用它的代理的能力之间的关系。例如，方向盘提供转向，手柄提供抓握，旋钮转动等。

人工智能增加了一个新的交互维度:它能够放置没有人工智能就不会存在的手柄和旋钮。一个说明性的例子是自动驾驶汽车:移除人工智能部分，汽车将无法运行。人类驾驶员不可能使用这样的汽车。它缺乏基本的启示，如人类操作所需的方向盘和油门。AI 从自动驾驶车辆中移除了这些部件的启示。这些是你想要制造的人工智能产品，它们是真正的差异化优势。

通过启用新的技术使用和交互方式，人工智能促进了全新的用户体验。例如，通过自动驾驶汽车实现的生活方式只是冰山一角。语音控制和能够解释人类行为的机器人将是展示人工智能如何渗透并颠覆我们生活的其他例子。

AI 可以将用户体验提升到感知智能和真实智能交融的程度。这就是图灵测试发挥作用的地方:人类用户不能根据他/她的交互来区分。人工智能算法的预测能力可以预测——在受限制的环境和时间范围内——用户可能会采取什么行动，或者某些行动会产生什么结果。例如，高级驾驶辅助系统(ADAS)就是为了过滤掉可能导致撞车的不良驾驶决策而构建的。

在启示的经典定义中，启示是被动的。启示体现了产品可能的使用方式。利用 AI，一个产品可以主动拒绝某些行为。例如，ADAS 系统和自动驾驶汽车就是为了避免撞车而制造的。换句话说，这些汽车承受不起碰撞:通过使用定义的交互方式来碰撞汽车几乎是不可能的。因此，主动拒绝减少了虚假和隐藏的启示，并引导用户使用。主动拒绝是互动新维度的一个例子。更多的有待发现。

外卖食品

人工智能的真正力量在于创造新的启示。用人工智能增强系统可以提高效率，但添加全新的交互维度将使人工智能技术处于领先地位。

参考

OpenAI 使命宣言
日常用品的设计
a16z 播客:机器学习初创公司的产品优势

人工智能很可能是安全的

原文：https://towardsdatascience.com/artificial-intelligence-is-probably-safe-ce67f0abd759?source=collection_archive---------8-----------------------

尽管我们最终都会被宇宙[10^100]年后的的热寂所杀死，但还有更多迫在眉睫的问题需要思考。还有太阳的死亡(从现在起 50 亿年)，以及行星的加热(参见模型中的 2100 年)。这是一个好主意优先考虑将杀死我们所有人的事情，并避免所说的坏事情。我们不知道人工智能的威胁在时间线中的确切位置，但看起来人工智能更像是在 100 年或更短的时间内杀死我们所有人。肯定不会太快。不要在你的 2018 日历上标注 AI 末日。

让我告诉你为什么我认为我们现在是安全的。

I love Futurama.

先说AI 为什么危险。超智能 AI 的默认状态是强优化。大多数强优化过程都是“杀死所有人类”的特例(例如集邮者、回形针机)。这就是为什么 AI 安全是一个重要的问题，有时被称为控制问题。更多此处。

超级智能也被称为“强人工智能”和人工通用智能(AGI)等。它开始是一个聪明的过程，变得越来越聪明，直到达到并超过人类水平的机器智能(HLMI)。这个点通常被称为奇点。这种人工智能不是通过已知的过程实现的。这是人类目前还没有实现的东西，我们也不知道如何制造我们给它贴上标签的东西。我们可以称暗物质和暗能量为“弗雷德和威尔玛”，因为除了它们的名字，我们所知甚少。同样，除了知道它有多危险和强大，我们对 AGI 知之甚少。人工智能(不是 AGI)的力量在短期内是帮助人类的。当你读到这些文字的时候，这是一股自动化和效率的力量，它正迅速在经济和文化中荡漾。

Fusion is hard. Really hard.

与来源不明的 AGI 相反，聚变是一个已知的过程。核聚变对人类来说是令人敬畏的，但也可能导致人类的终结(核聚变意味着每个人都拥有核武器，以及发动战争的无限能量)。所以，就大的上升空间和大的风险而言，这听起来类似于人工智能，但至少我们有了融合的蓝图。我们每天都看到太阳在进行核聚变，即使我们知道核聚变是如何在太阳中进行的，我们在地球上也没有运行的核聚变反应堆。是工程问题让核聚变遥不可及。很难在实验室里建造太阳(等离子体密封)。更容易制造太阳能电池板。

如果融合很难，而且我们知道融合是如何工作的，那么做《AGI:危险的人工智能》就格外困难。我们不知道 AGI 是如何工作的，除了人类如何进化出我们的智慧之外，我们没有其他例子，我们也不知道产生 HLMI 或超级智慧有多难。因此，比起核聚变或全球变暖，不要更担心 AGI。

通过理论上证明大过滤器在我们身后，费米悖论正在被解答/解决。比如，也许线粒体+细胞=非常稀少。比起另一个选择，我更喜欢那个。我不相信 AGI 需要如此稀有的东西来生产，因为人工智能比生物生命需要更少的进化时间。但是……我们不要自欺欺人了。深度学习任重道远，融合也是如此。杀手机器人是真实的，但由强人工智能建造的机器人还很遥远。我认为这一领域的研究应该作为国家安全的重中之重来资助，就像核聚变一样，但是让我们正视威胁。全球气候变化，在我看来，比想要杀死所有人类的 AI 更有杀伤力，更立竿见影。我们知道气候正在变化。海平面上升=洪水=糟糕。

The world after a 100 meter sea level rise, caused by melting 80% of the ice on the planet. This should bother you if you live bascially anywhere near open water.

对人工智能来说，更直接的担忧应该是失业、假新闻和其他社会弊病。基本上，美国 30 万卡车司机中的 90%将被取代。所有的优步车手也是如此。如果我们现在就为这些影响做准备，这是一个好主意。也许用通用基本收入(UBI) ？一些其他的解决方案？

我在工作中制造人工智能系统，我并不害怕它。你不应该害怕。

人工智能研究的进展速度令人印象深刻。我想说的是，就目前而言，人工智能可能是安全的，但应该继续研究人工智能的安全和控制问题。我怀疑我们能否将人类价值观灌输到超级智能中，但是值得一试去思考这些问题。

在我花了很多精力准备的上一篇文章之后，这是一篇非常有趣的高水平文章。如果你喜欢这篇关于人工智能安全的文章，请告诉我。在收到关于上一篇文章的一些不错的电子邮件反馈后，我确实计划写更多带有代码示例的研究内容。我也很高兴在评论中或通过电子邮件听到你对我的想法的反馈。你怎么想呢?

试用拍手工具。轻点那个。跟着我们走。分享这篇文章的链接。去吧。

编码快乐！

——丹尼尔
丹尼尔@lemay.ai ←打个招呼。
LEMAY . AI
1(855)LEMAY-AI

您可能喜欢的其他文章:

人工智能和不良数据
人工智能:超参数
人工智能:让你的用户给你的数据贴标签

附注:尼克·博斯特罗姆很棒:https://www.fhi.ox.ac.uk/

花絮:甜甜圈来源于面结，切一个洞有助于它们煮得更均匀。

人工智能是应对当今营销挑战的灵丹妙药

原文：https://towardsdatascience.com/artificial-intelligence-is-the-panacea-to-todays-marketing-challenges-a5201eae21ca?source=collection_archive---------2-----------------------

我对理解的尝试，更重要的是，将人工智能(AI)应用于当前的商业实践，迫使我将我所知道的一切都扔出窗外。经验、最佳实践、先入为主的观念、屡试不爽的真理——所有这些规则都变得过时和不相关，因为世界已经变了。媒体消费已经改变。企业已经失去了对客户的控制，正在努力获得并保持他们的注意力。

展示广告已经风光不再

目前形式的展示广告模式是不可持续的。全球数字表现的当前统计数据显示了以下广告形式:

在所有广告形式和位置中，广告点击率仅为 0.05%

富媒体广告点击率为 0.1%

脸书和谷歌继续占据主导地位……但他们只是讲述了故事的一部分

相比之下，Wordstream 最近的一项研究表明:脸书的广告似乎正在蓬勃发展:

…各个行业的点击率(CTR)从大约 0.5%到 1.6%不等。

对于截至 2016 年 3 月的谷歌 Adwords，拉里·金报道:

…平均而言，Google AdWords 广告客户在搜索网络上的转化率为 2.70%，在展示网络上的转化率为 0.89%。

很明显，脸书和谷歌从数字广告支出中获得了最大的利益。去年，超过 175 亿美元花在了数字广告上。但 FB 和谷歌获得了超过 65%的估计收入，谷歌获得了 300 亿美元，而脸书的广告收入为 80 亿美元。

尽管如此，这些平台也不是没有障碍。今年 3 月，像联合利华这样的品牌和哈瓦斯这样的机构选择冻结谷歌和 Youtube 的支出，因为除了“不受欢迎或不安全的内容”之外，还有广告投放。这一点，再加上关于可视度的可疑报道，以及不断上升的广告欺诈事件，都使得品牌和代理商对他们的支出变得更加谨慎。

消费者对广告越来越免疫:

像 Ghostery 这样检测和阻止跟踪技术的应用程序的兴起，让出版商和广告商面临更大的挑战。关于广告拦截的最新报道如下:

现在有 6.15 亿台设备使用 adblock
11%的全球人口在屏蔽网络广告，这一数字在 2016 年上升了 30%
移动广告拦截设备增长至 3.8 亿台，增幅达 250%
根据这份报告，广告拦截现在是各年龄组的主流

对出版业的影响是惊人的:假设采用率持续下去，到 2020 年，收入损失估计为 350 亿美元。

当广告拦截器、不断变化的媒体消费和广告表现阻碍我们达到目标客户时，我们如何有效地达到目标客户？

事情是这样的:顾客之旅从感兴趣的那一刻开始。我们如何与客户接触，在他们最有可能做出回应的时候，将最相关的信息放在他们面前，这是一个圣杯。过去的十年见证了这个年轻的数字领域的从业者测试、实施和成功应用技术以最大化性能。凭借这些在线行为，我们已经发展到真正理解消费者的兴趣和意图:印象、点击、访问、重复访问、内容和格式参与。大多数时候我们都是对的。直到现在。

然而，真正大规模实现个性化——并持续这样做——并不容易。除非你完成了从收购到为终身客户提供价值的完整旅程，否则你的努力充其量是支离破碎的。

谷歌知道分数:“谷歌计划如何杀死最后点击归属”

谷歌最近宣布了这一点。这位巨头已经意识到，要知道什么样的广告有效，不能通过衡量整体表现来完成。他们转向转化率指标(CV)的原因是点击率(CTR)是一个误称。它不再是衡量真实意图的标准。你如何衡量意图，并不是通过广告形式的行为聚合(是的，我在简化)。更确切地说，是通过理解购买漏斗中归因于购买行为的事件。这里是我们对人工智能的介绍，以及为什么它将是 CMO 旅程中的下一次进化。

如果你想提高绩效，你需要改变你的思维模式，去接受这个领域的新事物:

1)商业智能不具备人工智能的速度和能力:

开发适用于业务的正确算法所需的时间可能是一件苦差事。需要多次测试和不断迭代来提高结果的准确性。人类为此付出的努力可能需要数月时间。机器学习所做的是自动化预测分析，并允许模型比传统的商业智能(BI)模型更快地投入生产。随着新数据的吸收，模型会“学习”和调整。这种连续的反馈环路允许在更短的时间内以更高的精度获得更好的性能。

2)抵制做出假设的冲动:

我们所知道的有用的东西可以被扔出门外。理解消费者意图意味着消除 KPI 和已知的绩效指标变量。我一次又一次地被告知要放弃我所知道的真理。人工智能没有预先设想的偏见，因此模型将在与预期业务结果相关的事件中找到模式。它要么验证我们已经知道的，要么展现出通过人类分析无法发现的全新结果。

传统的商业智能有其优点。但是在一个竞争日益激烈、速度越来越快、对准确性的要求越来越高的环境中，随着新规范的引入，这种做法的灵活性和可扩展性也受到了限制。更重要的是，我们可能会被自己的盲点所阻碍，让(传统 BI 中)行之有效的东西继续成为首选解决方案。正因为如此，我们倾向于错过在人工智能框架下显而易见的关键见解。

3)对客户的整体看法意味着超越孤立的广告行为:

大多数营销人员都知道这一点:点击已经今非昔比。喜欢和追随者的虚荣心指标并不直接表示意图或亲和力。我们已经看到了这些指标是如何容易地被游戏化的。除非你能把这些事件归因于客户转化，否则它们本身不太可能有任何真正的价值。

收购和保留计划也相互冲突。企业不再能够控制当前客户或潜在潜在客户可以看到哪些信息。

然而，通过利用人工智能，在社交渠道上关注一个品牌的数百万客户中，我们可以确定脸书广告或帖子的价值，因为它与单个客户有关，以及这对潜在客户有何不同。但是仅仅这一点可能还不足以让顾客改变信仰。也许，这也是一个朋友通过电子邮件或客服电话的推荐。

当在一个有序的旅程中进行分析时，这些事件在个人旅程中的个人贡献才能得到真正的重视。

4)行为是情绪的衍生物:

不开心的顾客不一定会抛弃一个品牌。就忠诚度而言，价格敏感度可能是购买机票的决定性因素，因为积分有好处，不管他/她最近可能经历过的糟糕的客户服务电话。然而，所有这些事件加在一起，将使营销人员对客户流失的风险有一个更清晰的认识。

人工智能能够从人类意图的复杂性中提取模式，并确定可能(在不同程度上)影响数百万客户决策的多种驱动因素。它可能因不同的产品或服务、一年中的不同时间、不同的地理位置和人口统计数据而异。

5)数据为王:

在这个新世界中，我们有能力将人类的倾向联系起来，并越来越擅长预测行为的可能性。内容刚刚被取消！人工智能的方法论试图揭示的是，通过轶事般地理解新消费者重视什么或他/她需要什么来提升内容的原则。内容现在是一种功能或事件，它可能有助于业务转换，与成千上万的其他事件结合在一起，在每个单独的客户旅程中。企业现在可以分析其营销工作以及客户的个性化旅程，并不断优化整体活动绩效。

人工智能使 1:1 的真正定义完全成为可能

我们兜了一圈。对于我们这些实行一对一营销的人来说，计算能力以及近年来成倍增长的数据财富为我们提供了实现这一圣杯的途径。对于传统的营销人员来说，现在的可能性是无限的。

原载于 2017 年 5 月 31 日【marketinginsidergroup.com】。

人工智能遇见艺术:神经传递风格

原文：https://towardsdatascience.com/artificial-intelligence-meets-art-neural-transfer-style-50e1c07aa7f7?source=collection_archive---------7-----------------------

Hokusai in Boston

介绍

神经转移风格是人工智能在创造性背景下最令人惊叹的应用之一。在这个项目中，我们将看到如何将艺术绘画风格转移到选定的图像上，创造出令人惊叹的效果。Leon A. Gatys 等人在 2015 年的论文 中构思了神经传递风格的概念，一种艺术风格 的神经算法。在那之后，许多研究人员应用并改进了这种方法，增加了损失的元素，尝试了不同的优化器，并试验了用于此目的的不同神经网络。
尽管如此，原始论文仍然是理解这一概念的最佳来源，VGG16 和 VGG19 网络是这方面最常用的模型。这种选择是不寻常的，考虑到两者都被最近的网络超越，在风格转移中实现的最高性能证明了这一点。

完整代码可以查看这个 GitHub 库 。

它是如何工作的？

这种技术的目标是将图像的样式(我们称之为“样式图像”)应用到目标图像，保留后者的内容。让我们定义这两个术语:

风格是图像中的纹理和视觉模式。一个例子是艺术家的笔触。
内容是一幅图像的宏观结构。人、建筑物、物体都是图像内容的例子。

令人惊叹的效果如下所示:

你想看到更多的效果吗？在文章的最后检查他们！

让我们看看高级步骤:

选择要样式化的图像
选择样式参考图像。通常，这是一幅风格奇特且易于辨认的画。
初始化预训练的深度神经网络，并获得中间层的特征表示。完成该步骤是为了实现内容图像和样式图像的表示。在内容图像中，最好的选择是获得最高层的特征表示，因为它们包含关于图像宏观结构的信息。对于样式参考影像，从不同比例的多个图层中获取要素制图表达。
将最小化的损失函数定义为内容损失、风格损失和变化损失之和。每次迭代，优化器都会生成一幅图像。内容损失是生成图像和内容图像之间的差异(l2 归一化)，而样式损失是生成图像和样式之间的差异。我们稍后会看到这些变量是如何被数学定义的。
重复最小化损失

处理和取消处理图像

首先，我们需要格式化我们的图像以供我们的网络使用。我们要用的 CNN 是预先训练好的 VGG19 convnet。当我们将图像处理成兼容的数组时，我们还需要对生成的图像进行解处理，从 BGR 格式切换到 RGB 格式。让我们构建两个辅助函数来实现这一点:

# Preprocessing image to make it compatible with the VGG19 model
**def** **preprocess_image**(image_path):
    img = load_img(image_path, target_size=(resized_width, resized_height))
    img = img_to_array(img)
    img = np.expand_dims(img, axis=**0**)
    img = vgg19.preprocess_input(img)
    **return** img

# Function to convert a tensor into an image
**def** **deprocess_image**(x):
    x = x.reshape((resized_width, resized_height, **3**))

    # Remove zero-center by mean pixel. Necessary when working with VGG model
    x[:, :, **0**] += **103.939**
    x[:, :, **1**] += **116.779**
    x[:, :, **2**] += **123.68**

    # Format BGR->RGB
    x = x[:, :, ::-**1**]
    x = np.clip(x, **0**, **255**).astype('uint8')
    **return** x

内容损失

内容损失将主输入图像的内容保留到样式中。由于卷积神经网络的较高层包含图像宏观结构的信息，我们将内容损失计算为输入图像的最高层的输出和生成图像的相同层之间的差异(l2 归一化)。
内容损失定义为:

Content loss

在等式中， F 是内容图像的特征表示(当我们运行我们的输入图像时，网络输出的内容)，而 P 是在特定隐藏层 l 生成的图像的特征表示。
实现如下:

# The content loss maintains the features of the content image in the generated image.
**def** **content_loss**(layer_features):
    base_image_features = layer_features[**0**, :, :, :]
    combination_features = layer_features[**2**, :, :, :]
    **return** K.sum(K.square(combination_features - base_image_features))

风格丧失

理解风格损失不像理解内容损失那么简单。目标是在新生成的图像中保留图像的样式(即，作为笔触的视觉图案)。在前一个例子中，我们比较了中间层的原始输出。这里，我们比较样式参考图像和生成图像的特定层的 Gram 矩阵之间的差异。 Gram 矩阵被定义为给定层的矢量化特征图之间的内积。矩阵的意义在于捕捉层特征之间的相关性。计算多个层的损失允许在样式图像和生成的图像之间保留不同层中内部相关的相似特征。
单层的风格损失计算如下:

Style loss per layer

在等式中， A 是样式图像的 Gram 矩阵， G 是生成的图像的 Gram 矩阵，两者都与给定的层有关。 N 和 M 为样式图像的宽度和高度。
在等式中， A 是风格图像的克矩阵， G 是生成的图像的克矩阵，两者都与给定的层有关。 N 和 M 为样式图像的宽度和高度。
首先为每个单独的层计算样式损失，然后将其应用于被认为是对样式建模的每个层。让我们来实现它:

# The gram matrix of an image tensor is the inner product between the vectorized feature map in a layer.
# It is used to compute the style loss, minimizing the mean squared distance between the feature correlation map of the style image
# and the input image
**def** **gram_matrix**(x):
    features = K.batch_flatten(K.permute_dimensions(x, (**2**, **0**, **1**)))
    gram = K.dot(features, K.transpose(features))
    **return** gram

# The style_loss_per_layer represents the loss between the style of the style reference image and the generated image.
# It depends on the gram matrices of feature maps from the style reference image and from the generated image.
**def** **style_loss_per_layer**(style, combination):
    S = gram_matrix(style)
    C = gram_matrix(combination)
    channels = **3**
    size = resized_width * resized_height
    **return** K.sum(K.square(S - C)) / (**4.** * (channels ** **2**) * (size ** **2**))

# The total_style_loss represents the total loss between the style of the style reference image and the generated image,
# taking into account all the layers considered for the style transfer, related to the style reference image.
**def** **total_style_loss**(feature_layers):
    loss = K.variable(**0.**)
    **for** layer_name **in** feature_layers:
        layer_features = outputs_dict[layer_name]
        style_reference_features = layer_features[**1**, :, :, :]
        combination_features = layer_features[**2**, :, :, :]
        sl = style_loss_per_layer(style_reference_features, combination_features)
        loss += (style_weight / len(feature_layers)) * sl
    **return** loss

变异损失

最后，损失的最后一部分是变异损失。原始论文中没有包括这一要素，严格来说，它对于项目的成功并不是必要的。尽管如此，经验证明，添加该元素会产生更好的结果，因为它平滑了相邻像素之间的颜色变化。让我们把这个包括进去:

# The total variation loss mantains the generated image loclaly coherent,
# smoothing the pixel variations among neighbour pixels.
**def** **total_variation_loss**(x):
    a = K.square(x[:, :resized_width - **1**, :resized_height - **1**, :] - x[:, **1**:, :resized_height - **1**, :])
    b = K.square(x[:, :resized_width - **1**, :resized_height - **1**, :] - x[:, :resized_width - **1**, **1**:, :])
    **return** K.sum(K.pow(a + b, **1.25**))

全损

最后，将所有这些因素考虑在内，计算总损失。首先，我们需要提取我们选择的特定层的输出。为此，我们定义一个字典为<层名，层输出 >:

# Get the outputs of each key layer, through unique names.
outputs_dict = dict([(layer.name, layer.output) **for** layer **in** model.layers])

然后，我们通过调用先前编码的函数来计算损失。每个分量都乘以特定的权重，我们可以调整权重以产生强烈或较轻的效果:

**def** **total_loss**():
    loss = K.variable(**0.**)

    # contribution of content_loss
    feature_layers_content = outputs_dict['block5_conv2']
    loss += content_weight * content_loss(feature_layers_content)

    # contribution of style_loss
    feature_layers_style = ['block1_conv1', 'block2_conv1',
                            'block3_conv1', 'block4_conv1',
                            'block5_conv1']
    loss += total_style_loss(feature_layers_style) * style_weight

    # contribution of variation_loss
    loss += total_variation_weight * total_variation_loss(combination_image)
    **return** loss

设置神经网络

VGG19 网络将一批三个图像作为输入:输入内容图像、样式参考图像和包含生成图像的符号张量。前两个是常量变量，使用 keras.backend 包定义为变量。第三个变量定义为占位符，因为它会随着优化器更新结果的时间而变化。

一旦变量被初始化，我们就把它们加入一个张量，这个张量将在以后提供给网络。

# Get tensor representations of our images
base_image = K.variable(preprocess_image(base_image_path))
style_reference_image = K.variable(preprocess_image(style_reference_image_path))

# Placeholder for generated image
combination_image = K.placeholder((**1**, resized_width, resized_height, **3**))

# Combine the 3 images into a single Keras tensor
input_tensor = K.concatenate([base_image,
                              style_reference_image,
                              combination_image], axis=**0**)

完成后，我们需要定义损耗、梯度和输出。原始论文使用算法 L-BFGS 作为优化器。这种算法的一个限制是它要求损失和梯度分别通过。因为单独计算它们效率极低，所以我们将实现一个赋值器类，它可以同时计算损失和梯度值，但分别返回它们。让我们这样做:

loss = total_loss()

# Get the gradients of the generated image
grads = K.gradients(loss, combination_image)
outputs = [loss]
outputs += grads

f_outputs = K.function([combination_image], outputs)

# Evaluate the loss and the gradients respect to the generated image. It is called in the Evaluator, necessary to
# compute the gradients and the loss as two different functions (limitation of the L-BFGS algorithm) without
# excessive losses in performance
**def** **eval_loss_and_grads**(x):
    x = x.reshape((**1**, resized_width, resized_height, **3**))
    outs = f_outputs([x])
    loss_value = outs[**0**]
    **if** len(outs[**1**:]) == **1**:
        grad_values = outs[**1**].flatten().astype('float64')
    **else**:
        grad_values = np.array(outs[**1**:]).flatten().astype('float64')
    **return** loss_value, grad_values

# Evaluator returns the loss and the gradient in two separate functions, but the calculation of the two variables
# are dependent. This reduces the computation time, since otherwise it would be calculated separately.
**class** **Evaluator**(object):

    **def** **__init__**(self):
        self.loss_value = **None**
        self.grads_values = **None**

    **def** **loss**(self, x):
        **assert** self.loss_value **is** **None**
        loss_value, grad_values = eval_loss_and_grads(x)
        self.loss_value = loss_value
        self.grad_values = grad_values
        **return** self.loss_value

    **def** **grads**(self, x):
        **assert** self.loss_value **is** **not** **None**
        grad_values = np.copy(self.grad_values)
        self.loss_value = **None**
        self.grad_values = **None**
        **return** grad_values

evaluator = Evaluator()

最后一档

终于万事俱备了！最后一步是多次迭代优化器，直到我们达到期望的损失或期望的结果。我们将保存迭代的结果，以检查算法是否按预期工作。如果结果不令人满意，我们可以调整权重以改善生成的图像。

# The oprimizer is fmin_l_bfgs
**for** i **in** range(iterations):
    print('Iteration: ', i)
    x, min_val, info = fmin_l_bfgs_b(evaluator.loss,
                                     x.flatten(),
                                     fprime=evaluator.grads,
                                     maxfun=**15**)

    print('Current loss value:', min_val)

    # Save current generated image
    img = deprocess_image(x.copy())
    fname = 'img/new' + np.str(i) + '.png'
    save(fname, img)

要查看完整代码，请参考页面开头提供的 GitHub 链接。

惊人的结果

如果你想尝试特定的效果，绘画，或者你有任何建议，请留下评论！

如果你喜欢这篇文章，我希望你能点击鼓掌按钮👏因此其他人可能会偶然发现它。对于任何意见或建议，不要犹豫留下评论！

我是一名数据科学专业的学生，热爱机器学习及其无尽的应用。你可以在 maurocomi.com找到更多关于我和我的项目的信息。你也可以在 Linkedin 上找到我，或者直接给我发邮件。我总是乐于聊天，或者合作新的令人惊奇的项目。

人工智能需要重置

原文：https://towardsdatascience.com/artificial-intelligence-needs-to-reset-d83953fa19bb?source=collection_archive---------13-----------------------

DepositPhotos

我有机会采访我在 ArCompany 的同事 Karen Bennet，她是平台技术、开源和闭源系统以及人工智能技术领域经验丰富的工程主管。雅虎前工程主管。作为带领 Red Hat 取得成功的原始团队的一员，Karen 随着技术革命而发展，在 IBM 早期的专家系统中利用人工智能，目前正在见证机器学习和深度学习的快速实验。我们对人工智能现状的讨论最终形成了这篇文章。

在所有的炒作中，很难驾驭人工智能。在很大程度上，人工智能的承诺还没有实现。人工智能仍在出现，并没有成为承诺的无孔不入的力量。考虑一下令人信服的数据，这些数据证实了人工智能炒作中的兴奋:

自 2000 年以来，活跃的人工智能初创公司数量增加了 14 倍
自 2000 年以来，风投对人工智能初创企业的投资增加了 6 倍
自 2013 年以来，需要人工智能技能的工作份额增长了 4.5 倍

截至 2017 年，统计局公布了这些调查结果:

截至去年，全球只有 5%的企业将人工智能广泛纳入了他们的流程和产品，32%尚未采用，22%没有计划采用。

Statista: Adoption level of artificial intelligence (AI) in business organizations worldwide, as of 2017STATISTA

菲利普·皮涅夫斯基(Filip Pieniewski)最近在 VentureBeat 上的帖子中证实:“人工智能的冬天即将到来”:

我们现在处于 2018 年中期，事情已经发生了变化。还没有浮出水面 NIPS 会议仍然被过度销售，企业公关仍然在其新闻稿中到处都是人工智能，埃隆·马斯克仍然保持着对自动驾驶汽车的承诺，谷歌继续推动吴恩达的路线，即人工智能大于电力。但这种说法开始出现裂痕。

我们吹捧自动驾驶汽车的说法。今年春天早些时候，一名行人死于自动驾驶汽车引发了超出技术范畴的警报，并引发了对自动化系统决策背后的道德或缺乏道德的质疑。电车问题不是在一个人的生命和拯救 5 个人之间的简单二元选择，而是演变成一场良心、情感和感知的辩论，现在使机器做出合理决定的道路变得复杂。这篇文章的结论是:

但是，完全自动驾驶汽车的梦想可能比我们意识到的更远。人工智能专家越来越担心，自动驾驶系统可能需要几年甚至几十年才能可靠地避免事故。

使用历史作为预测，云和点网行业都花了大约 5 年时间才开始以一种显著的方式影响人们，而这些行业在影响市场的重大转变之前花了将近 10 年时间。我们正在为人工智能设想一个类似的时间表。正如凯伦解释的那样，

为了让每个人都能够采用，需要有一个产品，一个可扩展的产品，一个每个人都可以使用的产品，而不仅仅是数据科学家。该产品将需要考虑到捕获数据、准备数据、训练模型和预测的数据生命周期。随着数据存储在云中，数据管道可以不断地提取和准备它们，以训练将做出预测的模型。模型需要根据新的训练数据不断改进，这反过来将保持模型的相关性和透明性。这是目标，也是承诺。

构建没有重要用例的人工智能概念证明

凯伦和我都来自科技和人工智能初创公司。在与人工智能社区同行的讨论中，我们所目睹和意识到的是对大量商业问题的广泛实验，这些实验往往停留在实验室中。

这篇最近的文章证实了如今更加普遍的广泛人工智能试点:

人工智能技术的供应商经常受到激励，让他们的技术听起来比实际更有能力——但暗示比他们实际拥有的更多真实世界的牵引力……企业中的大多数人工智能应用程序只不过是“试点”首先，销售人工智能营销解决方案、医疗保健解决方案和金融解决方案的供应商公司只是在测试这项技术。在任何给定的行业中，我们发现，在数百家销售人工智能软件和技术的供应商公司中，只有大约三分之一的公司真正具备从事人工智能的必要技能。

风投们意识到，他们可能在一段时间内看不到投资回报。然而，无处不在的实验中很少有模型能看到日光，这只是人工智能还没有准备好迎接黄金时代的原因之一。

算法可以问责吗？

我们听说过人工智能“黑匣子”，这是一种当前的方法，无法了解决策是如何做出的。这种做法与银行和大型机构背道而驰，它们有强制问责的合规标准和政策。当系统作为黑盒运行时，只要这些算法的创建已经被关键的利益相关者审查并满足一些标准，就可能存在对这些算法的固有信任。鉴于生产中有大量错误算法的证据，以及由此产生的意想不到的有害后果，这一观点很快遭到了质疑。我们许多简单的系统像黑匣子一样运作，超出了任何有意义的审查范围，因为有意的公司保密，缺乏足够的教育和理解如何批判地检查输入，结果，最重要的是，为什么会出现这些结果。凯伦表示赞同，

今天的人工智能行业正处于企业就绪的非常早期的阶段。人工智能非常有用，可以用于发现和帮助解析大量数据，但是，它仍然需要人工干预来指导评估和处理数据及其结果。

Karen 澄清说，今天的机器学习技术使数据能够被标记以识别洞察力。然而，作为这个过程的一部分，如果一些数据被错误地标记，或者如果没有足够的数据表示，或者如果有问题的数据表示偏差，则很可能出现糟糕的决策结果。她还证实，当前的流程仍在不断完善:

目前，人工智能完全是关于决策支持，以提供对业务可以得出结论的形式的见解。在人工智能的下一个阶段，自动根据数据采取行动，还有其他问题需要解决，如偏见、可解释性、隐私、多样性、道德和持续的模型学习。

Karen 举例说明了一个人工智能模型犯错误的例子，当图像字幕暴露了通过对标记有它们包含的对象的图像进行训练而学到的知识时。这表明，人工智能产品需要有一个对物体和人的常识世界模型才能真正理解。仅暴露于训练集中有限数量的标记对象和有限种类的模型将限制这种常识世界模型的功效。企业需要研究确定一个模型如何以人类可以理解的方式处理其输入并得出其结论。亚马逊发布的 Rekognition，其面部识别技术是目前正在生产和许可使用的技术的一个例子，但其有效性存在明显的差距。根据美国公民自由联盟发布的一项研究:

这项技术成功地将 28 名国会议员的照片与公开的面部照片混淆起来。鉴于亚马逊积极向美国执法机构推销认知，这还不够好。

Joy Buolamwini，麻省理工学院毕业生和算法正义联盟的创始人，在最近的采访中呼吁暂停这项技术，称其无效，需要更多的监管，并呼吁在公开发布之前为这些类型的系统制定更多的政府标准。

艾的主要障碍:心态、文化和遗产

不得不从遗留系统转型是当今许多组织实施人工智能的最大障碍。心态和文化是这些遗留系统的元素，它们提供了对既定流程、价值观和业务规则的系统视图，这些流程、价值观和业务规则不仅决定了组织如何运营，还决定了为什么这些根深蒂固的元素会给业务带来重大障碍，尤其是在当前形势良好的情况下。因此，目前没有拆除基础设施的真正动机。

人工智能是业务转型的一个组成部分，尽管这个主题已经获得了与人工智能宣传一样多的关注，但做出重大改变所需的投资和承诺却遇到了犹豫。我们听说一些公司愿意在特定的用例上进行实验，但是对于培训、重新设计流程以及修改治理和公司政策的要求却没有做好准备。对于被迫进行这些重大投资的大型组织来说，问题不应该是投资回报，而是可持续的竞争优势。

数据完整性的问题

今天的人工智能需要大量的数据才能产生有意义的结果，但无法利用其他应用程序的经验。虽然 Karen 认为克服这些限制的工作正在进行中，但在模型能够以可扩展的方式应用之前，需要学习的转移。然而，现在有一些场景可以有效地使用人工智能，例如揭示图像，语音，视频的洞察力，以及能够翻译语言。

公司开始意识到应该关注:

1)数据的多样性，包括不同人群的适当代表性

2)确保创作算法中包含不同的经验、观点和想法

3)优先考虑数据的质量而不是数量

这一点非常重要，尤其是在引入偏见、降低对数据的信任和信心的情况下。例如，土耳其语是一种中性语言，但谷歌翻译工具中的 AI 模型在翻译成英语时错误地预测了性别。同样，癌症识别人工智能图像识别只在皮肤白皙的人身上进行训练。从上面的计算机视觉例子中，Joy Buolamwini 测试了这些人工智能技术，并意识到它们在男性和女性以及浅色和深色皮肤上更有效。男性的“”错误率低至 1%,而深色皮肤的女性高达 35%。“出现这些问题是因为未能使用多样化的培训数据。凯伦承认，

人工智能的概念很简单，但通过吸收越来越多的真实世界数据，算法变得越来越智能，然而，能够解释决策变得极其困难。数据可能会不断变化，人工智能模型需要过滤器来防止错误的标记，例如一个黑人被标记为大猩猩，或者一只熊猫被标记为长臂猿。企业依靠错误的数据做出决策将导致错误的结果。

幸运的是，鉴于人工智能的恶劣，今天很少有组织根据这些数据做出重大的商业决策。据我们所见，大多数解决方案主要产生产品推荐和个性化营销传播。由此得出的任何错误结论对社会的影响都较小……至少目前如此。

使用数据进行业务决策并不新鲜，但发生变化的是所使用的结构化和非结构化数据的数量和组合呈指数级增长。人工智能使我们能够持续使用来自其来源的数据，并更快地获得洞察力。对于有能力和结构来处理来自不同来源的数据量的企业来说，这是一个机会。然而，对于其他组织来说，大量数据可能会带来风险，因为不同的来源和格式使信息转换更加困难:电子邮件、系统日志、网页、客户记录、文档、幻灯片、非正式聊天、社交网络和爆炸式增长的富媒体，如图像和视频。数据转换仍然是开发干净的数据集和有效模型的绊脚石。

偏见比我们意识到的更加普遍

在许多商业模式中存在偏见，以最大限度地减少风险评估，优化目标机会，虽然它们可能产生有利可图的商业结果，但已知它们会导致意想不到的后果，造成个人伤害并加深经济差距。保险公司可能会利用位置信息或信用评分数据向贫困客户发放更高的保费。银行可能会批准信用评分较低的潜在客户，他们已经负债累累，但可能无法承受更高的贷款利率。

围绕偏见有一种高度的谨慎，因为人工智能的引入不仅会延续现有的偏见，这些学习模型的结果可能会概括到加深经济和社会鸿沟的地步。像 COMPAS 一样，偏差出现在当前算法中以确定再犯的可能性(重新犯罪的可能性)。替代制裁罪犯管理概况(COMPAS)是由一家名为 Northpointe 的公司创建的。COMPAS 的目标是在审前听证中评估被告的犯罪风险和预测。在最初的 COMPAS 研究中使用的问题类型揭示了足够多的人类偏见，以至于该系统使无意中对待黑人的建议永久化，这些黑人永远不会再犯，法律对他们的惩罚比白人被告更严厉，而白人被告会再犯，在判决时会得到更宽大的对待。在没有公共标准可用的情况下，Northpointe 能够创建自己的公平定义，并在没有第三方评估的情况下开发一种算法……直到最近。这篇文章证实，“一个流行的算法在预测犯罪方面并不比随机的人好” …

如果这个软件只是像未受过训练的人回答在线调查一样准确，我认为法院在试图决定在决策中给他们多少权重时应该考虑这一点

凯伦规定，

虽然我们试图修复现有系统以尽量减少这种偏见，但关键是模型要根据不同的数据集进行训练，以防止未来的伤害。

考虑到商业和社会中普遍存在的错误模型的潜在风险，企业没有治理机制来监管会无意中影响最终消费者的不公平或不道德的决策。这在伦理学下讨论。

对隐私日益增长的需求

凯伦和我来自雅虎！我们与强大的研究和数据团队合作，这些团队能够将用户在我们平台上的行为联系起来。我们不断研究用户行为，了解他们在我们众多酒店中的倾向，从音乐、主页、生活方式、新闻等等。当时，数据使用没有严格的标准或规定。隐私被归入用户对平台条款和条件的被动协议，类似于今天。

最近的剑桥分析/脸书丑闻将个人数据隐私推到了前沿和中心。主要信贷机构频繁发生数据泄露事件，如 Equifax 以及最近的脸书和 Google + 继续加剧这一问题。所有权、同意和错误语境化的问题使得这成为一个成熟的话题，因为 AI 继续解决它的问题。已于 2018 年 5 月 25 日生效的欧洲通用数据保护法规(GDPR)将改变组织的游戏，特别是那些收集、存储和分析个人用户信息的组织。它将改变多年来商业运作的规则。个人信息的无节制使用已经到了紧要关头，因为企业现在将会意识到数据使用将会有重大限制，更重要的是所有权。

在基于位置的广告中，我们看到了这一点的早期影响。这个价值 750 亿美元的行业预计到 2021 年将以 5 年 21%的 CAGR 增长，继续受到脸书和谷歌寡头垄断的阻碍，确保了大部分收入。现在， GDPR 加大赌注，让这些广告技术公司更加负责任:

Hessie Jones Twitter

风险如此之大，以至于(广告商)必须有高度的信心，相信你被告知的内容实际上是合规的。关于什么将最终构成违规，似乎存在足够多的普遍困惑，以至于人们对此采取了宽泛的方法，直到您能够精确地了解合规性是什么样子。

虽然监管最终会削弱收入，但至少在目前，移动和广告平台行业也面临着来自消费者的越来越多的审查，这些审查正是他们多年来一直在赚钱的对象。这一点，再加上对既定实践的检查，将迫使行业改变他们在收集、汇总、分析和共享用户信息方面的实践。

实施隐私需要时间、大量投资(这是一个需要给予更多关注的话题)，以及影响组织政策、流程和文化的思维方式的改变。

人工智能与伦理学的必然耦合

人工智能的主要因素确保了社会效益，包括简化流程，提高便利性，改善产品和服务，以及通过自动化检测潜在的危害。放弃后者意味着随时根据更新的制造流程、服务和评估解决方案、生产以及产品质量的结果来衡量投入/产出。

随着关于人工智能的讨论和新闻持续不断，这个术语“人工智能”加上“伦理”揭示了越来越严重的担忧，即人工智能技术可能造成社会损害，这将考验人类的良知和价值观。

CB Insights: Tech Cos Confront Ethics of AI

除了个人隐私问题，今天我们看到了一些近乎不合理的创新例子。如前所述，Rekognition 和 Face++被用于执法和公民监控，而该技术被认为是有缺陷的。员工罢工抗议谷歌决定向国防部提供人工智能来分析无人机镜头，目标是在一个名为 Project Maven 的项目中创建一个复杂的系统来监视城市。同一家科技巨头还在为中国建设项目蜻蜓，这是一个经过审查的搜索引擎，也有能力将个人搜索映射到身份。

决策者和监管者需要注入新的流程和政策，以正确评估人工智能技术的使用方式、目的以及在此过程中是否可能有意想不到的后果。Karen 指出了在确定人工智能算法中使用数据时需要考虑的新问题:

我们如何检测敏感数据字段并匿名化它们，同时保留数据集的重要特征？我们能在短期内用合成数据作为替代进行训练吗？在创建算法时，我们需要问自己的问题是:我们需要哪些领域来交付我们想要的结果？此外，我们应该创建什么参数来定义模型中的“公平”,也就是说这是否对两个个体有所不同？如果是，为什么？我们如何在系统中持续监控这一点？

人工智能冬天是一个让人工智能做好准备的偶然机会

AI 已经走过了很长的路，但仍需要更多的时间来成熟。在一个自动化程度越来越高、认知计算能力不断提高的世界，即将到来的人工智能冬天给了企业必要的时间来确定人工智能如何融入他们的组织以及它想要解决的问题。需要在政策、治理及其对个人和社会的影响中解决即将到来的人工智能伤亡。

在下一次工业革命中，它的影响要大得多，因为它在我们生活中的无处不在将变得更加微妙。来自杰夫·辛顿、李菲菲和吴恩达的人工智能领军人物呼吁人工智能重置，因为深度学习尚未被证明可以规模化。人工智能的前景并没有减弱，相反，对它真正到来的预期被推得更远了——也许是 5-10 年。我们有时间在深度学习、其他人工智能方法以及从数据中有效提取价值的过程上解决这些问题。这种业务准备、监管、教育和研究的高潮是必要的，以使企业和消费者跟上速度，并确保监管系统到位，以适当地限制技术，并让人类更长时间地掌舵。

Karen Bennet ， Arcompany ，的首席顾问，是一位经验丰富的高级工程领导者，在开源和闭源解决方案的软件开发领域拥有超过 25 年的经验。最近，卡伦的努力集中在人工智能上，使企业，特别是银行和汽车行业的企业，能够试验人工智能/人工智能。她在 Cerebri AI、IBM、Yahoo！他是早期的领导者，帮助天鹅座和红帽成长为可持续发展的企业。

这篇文章最初出现在福布斯上。

要订阅的人工智能时事通讯

原文：https://towardsdatascience.com/artificial-intelligence-newsletters-to-subscribe-to-2fea0843d19c?source=collection_archive---------8-----------------------

SOURCE: HIROSHI WATANABE VIA GETTY IMAGES

这里是 Josh.ai 我们正在为家庭开发一个相当令人兴奋的人工智能代理。这是一个令人兴奋的领域，我们试图跟踪该领域的一些时事通讯。我们没有跟上所有这些，但这里有一个精选的列表，列出了我们在那里发现的一些最好的

AI Weekly —订阅人工智能和机器学习方面的最佳新闻和资源的每周集合。免费的。

Deep Hunt —由 Avinash Hindupur 精心策划的人工智能最热门事物的每周简讯！

热门机器人 —我们在网上搜寻关于机器人&人工智能的最新内容。

奥莱利人工智能简讯 —接收每周人工智能新闻、业内人士的见解以及独家交易和优惠。

机器学习周刊 —机器学习与深度学习博客(7.1k 订阅用户)。

数据科学每周简讯 —免费的每周简讯，提供与数据科学相关的新闻、文章和工作。

机器学习—ML&AI 新闻每周综述。机器学习和人工智能正在对我们的生活产生巨大影响。

人工智能新闻——AI&深度学习快讯。****

当树倒了……—机器学习与人工智能博客。****

WildML——AI、深度学习、NLP Bl og****

C olah 的博客 —神经网络聚焦博客。

我是特拉斯克——一个机器学习的手艺博客作者@iamtrask****

人工智能内部——带给你人工智能、机器人和神经技术的最新进展

阿齐姆·阿兹哈尔:指数观点 —指数变化:技术、商业模式、政治经济&社会。

库兹韦尔人工智能——库兹韦尔加速智能简讯通过电子邮件简明扼要地报道相关的重大科技突破(每日或每周)。

导入 AI —导入 AI 是一份关于人工智能的每周简讯，有成千上万的专家阅读。

AI 中的野周—AI 中的野周是由@ dennybritz 策划的每周一期 AI &深度学习简讯。

——通过阅读每个工作日直接发送到你收件箱的顶级文章，了解人工智能&数据科学的最新动态。****

订阅获取智能家居、语音控制和人工智能的最新信息。

查看我们的脸书 或者关注我们的 推特！

自动驾驶汽车:监管还是自由市场？

原文：https://towardsdatascience.com/artificial-intelligence-regulation-b0626a92158a?source=collection_archive---------8-----------------------

Photo Credit Patrick Curtet

人工智能将成为我们作为个人和社会的最终反映。考虑到这一点，应该如何管理呢？

在一个法律结构中应该有政府监督吗？
行业自律行得通吗？
自由市场应该决定这项技术的界限吗？

虽然没有简单的答案，或放之四海而皆准的答案，但这个问题现在需要各方广泛讨论，以保持领先地位。

构建和实现这项技术时需要做出的决策部分取决于我们希望这项技术如何发挥作用。虽然不可能对软件的使用方式下禁令，但我们确实有集体力量来影响决策的方式和成本。

当提供人工智能解决方案时，我们应该总是问可能性的范围是什么，这样我们就可以考虑如何使任何结果更加人性化。如果这种方法被认为是重要的，人性可以被嵌入到任何软件中。在危急或影响生活的情况下，我认为这很重要。

目前建造的东西几乎完全取决于两个输入。

1。软件的最终目标是什么，它应该实现什么，最终导致那个结果的决策是什么？

2。用于支持软件的数据或信息是什么？在收集这些数据或信息时做出了哪些决策？

这些决定通常被认为是最终结果的主要驱动因素或影响因素，比任何法律、道德或人文因素都重要。

毕竟人工智能是由工程师而不是律师构建的。

以自动驾驶汽车为例，在只有两种可能结果的碰撞类型场景中，可以问一个简单的问题。

结果 A. 自动驾驶汽车撞向路边的一群人，导致那群人死亡，但对车上的乘客没有持久的影响。

结果 B. 自动驾驶汽车在路边错过一群现在导致乘员死亡的人。

对任何一种结果做出的决定都将被设计到 car 软件中。至于哪种结果更好，这将是一个人为的决定。从这个意义上说，从实际角度来看，结果是二元的，应该从总体影响的角度来考虑。由于汽车现在也是司机，在什么情况下所有的责任都让给了软件？

虽然这种行驶数十万英里的事件很少发生，但随着路上自动驾驶汽车数量的增加，这种事件将会发生。应该采取什么行动？结果 A 还是 B 更好？

政府监管自然会在自动驾驶汽车中发挥作用，汽车制造商的自身利益也是如此。目前，美国政府强制实施了现代汽车安全标准。总的来说，安全标准弱于加拿大和欧洲，但强于发展中国家。美国汽车工业努力游说降低安全标准的限制性。这只是导致美国 10.6/10 万居民死亡率的因素之一。(2015 年世卫组织报告)

自由市场方法不鼓励对贸易或商业的限制。举一个例子，合法出售给 SUV 车主以保护他们的汽车免受损坏的金属球棒具有对任何被撞行人造成更大伤害或死亡的副作用。然而，SUV 司机现在得到了更好的保护，不太可能受到伤害。这种自由市场方式将公司利益置于行人安全之上。如果将类似的模型用于所有自动驾驶汽车，进而用于所有人工智能软件，会有什么结果？

每个人都可以也应该围绕我们未来想要的驾驶环境类型展开对话。如果我们不参与，那么围绕安全的决策将继续主要由汽车制造商做出。

“2010 年，成年人饮酒过度，驾车次数约为 1.12 亿次。”美国疾病预防控制中心 2011 年报告

“每天，人们酒后驾车近 30 万次，但只有不到 4000 人被逮捕。”—美国联邦调查局 2010 年报告

酒后驾车是一个有着悠久法律的领域。然而，现有的酒后驾驶法律往往被无视，难以执行。很大一部分公众继续在醉酒状态下开车，而警察却没有足够的人力来执行这项法律。

这是一个自动驾驶汽车将立即减少酒驾影响的领域。然而，更广泛地说，当公众决定在既定规则或法律之外行事时，执行这些法律可能是一个挑战。

当人工智能系统出现在世界上，在普通大众的手中，它们将如何被监管？如果不进行辩论，规则、监管和法律可能会来得太晚，无法有效管理人类和机器需要共存的环境。现在是讨论我们希望人工智能如何在我们的道路上和更广阔的世界中行动的时候了。

为大家揭秘人工智能

原文：https://towardsdatascience.com/artificial-intelligence-the-present-7ffeb0ff1ae6?source=collection_archive---------5-----------------------

有意识的机器人真的来了吗？外行人的指南

What does an AI brain look like? Image credit: JÉSHOOTS

“智力的概念就像舞台魔术师的戏法。比如“非洲未开发地区”的概念。我们一发现它就消失了。”
—马文·明斯基(1927–2016)，数学家，人工智能先驱。

T 上面引用的一位计算机科学泰斗的话，恰如其分地营造了一种氛围，让我们得以一窥当今最热门、最具争议的技术之一的背后。对于围绕它的所有神秘，如果我们简单地说，“人工智能只不过是涡轮增压的统计推断”，我们不会离真相太远。让我们仔细看看。

每个计算机程序的核心都有一个数学函数在起作用。这可能像计算未偿还贷款的利息一样简单，也可能像自动驾驶飞机一样复杂。人工智能，或 AI ，是一个计算机程序的通称，其核心数学功能已经(几乎)自动创建；而机器学习，或 ML ，指的是提供创造人工智能方式的一系列技术。

一个 ML 技术需要两件事:第一，一个函数看起来像什么的粗略草图，第二，一组训练例子'在情况 A 中函数应该执行动作 B，在情况 X 中函数应该执行动作 Y，等等'。对于每一个例子，ML 技术都细化了草图，使得结果函数更好地符合到目前为止所看到的一切。

Our painter AI might look like a muscular version of this writer automaton by Henri Maillardet, ca. 1810. Image credit: Wikipedia

假设我们有一种 ML 技术，它知道如何将肌肉粘在骨头上，了解关节如何工作，并知道关于健康生物体肌肉平衡的限制。我们可以从一个人体骨骼(功能草图)和一大套笔触(例子集)开始，通过试错，创造一个知道如何绘画的人工智能。虽然创造一个简单地在墙上泼洒颜料的人工智能可能很容易，但创造一个具有梵高或莫奈技能的人工智能却困难得多；这是科学家的薪水支票。

从错误中学习。想象一下！

在创建画家 AI 时，ML 技术通常从创建随意的笔触开始，而不考虑训练示例。随着观察到的例子越来越多，它的目标是更好地模仿它们。如果这项技术非常适合这项任务，那么它会通过猜测给骨骼的哪个部分添加多少肌肉以及微调运动来改善，以便最好地补偿绘画错误。

尽管存在数学限制，但总的来说，更多的训练示例有助于创建更好的人工智能。这当然假设开发了适当的机器学习技术。在“训练”完成后，人工智能被释放到现实世界中，它可能会通过其核心功能处理每一个新的情况，以产生它认为最好的反应，或者就画家而言，最佳的笔触。

人工智能的每一项著名成就——从深蓝战胜加里·卡斯帕罗夫(Gary Kasparov)到自动驾驶汽车——都是科学家磨练机器学习技术并将其与正确的基本规范和训练样本结合起来的结果。但是人工智能比这些例子所暗示的更普遍。

Machine Learning is everywhere. Image credit: Giphy

我在亚马逊和猫途鹰上的搜索触发了我的谷歌搜索中的广告。脸书认出了我和我朋友的照片。LinkedIn 可以知道我什么时候在找工作。一个经常被引用的例子是，一家超市发现一个十几岁的女孩怀孕了，甚至在她的家人知道之前，因为她突然从普通化妆品转向无香水化妆品。

等等，那电影呢？

今天，当你使用网络浏览器或手机应用程序时，是人工智能决定你观看什么广告。欧洲粒子物理研究所的 T2 正在帮助科学家从噪音中辨别基本粒子的信号；这就是他们如何发现希格斯玻色子。它把一种语言的文本翻译成另一种语言。从苹果的 Siri 到亚马逊的 Alexa，语音助手都是由人工智能驱动的。它保护信用卡和借记卡免受欺诈。它预测天气，甚至写新闻文章。去年，人工智能在空战模拟中击败了王牌飞行员，在围棋比赛中击败了世界特级大师。以这样或那样的形式，人工智能正在落后于所有形式的技术。

然而，所有这些都是非常具体、非常专业的应用。如果我们的期望是由科幻小说设定的，它们可能仍然显得平淡无奇。我们应该准备好迎接一个有自我意识、有能力并倾向于统治世界的流氓人工智能吗？

In Ex Machina, the AI learns to deceive and kill in order to preserve itself. Or out of malice. Who knows!? Image credit: BagoGames

就人工智能的现代化身而言，这个领域在出生时就设定了这样的期望。现代计算机的创造者艾伦·图灵在 1950 年问道:“机器能思考吗？他提出了所谓的图灵测试，作为对机器思考能力的终极测试。测试表明，如果通过对话，一台机器可以让法官相信它是人类，那么必须假定这台机器具有与人类无法区分的思维能力。

他推测，只要有足够的内存，这样的机器是可以制造出来的，而且将会在 20 世纪初制造出来。在他 1951 年的一次演讲中，他说，“他们将能够彼此交谈，以提高他们的智慧。因此，在某个阶段，我们应该预料到机器会控制局面。”事实证明，这比想象的要难得多。

事实是，不仅一个有自我意识的计算机程序——它毕竟是一个计算机程序——很难设计，甚至不清楚这样的程序是否存在。正如图灵测试所评估的那样，创造一个与人类没有区别的人工智能是一个更小的挑战。

我们已经看到实验室里出现了许多令人瞠目结舌的技术。有人甚至可以说计算机和技术已经控制了我们生活的大部分。但是有自我意识的机器，更不用说失控的杀手机器人，还没有出现。

艺术的状态

一台机器能否通过图灵测试取决于它理解自然语言的能力，比如英语、汉语或梵语。这就是所谓的自然语言处理或者 NLP 的问题。由于历史原因，20 世纪下半叶的主要努力集中在使用数理逻辑规则设计 NLP 程序上。

这些程序发展成为 20 世纪末 21 世纪初的专家系统，旨在帮助组织基于事实和纯逻辑推理做出决策。专家系统因无法处理大量数据和复杂问题而失宠。出于类似的原因，依赖于基于规则的逻辑推理的方法被完全抛弃了。另一种思维方式流行开来:一种基于概率和统计的思维方式。

例如，像国际象棋这样的游戏的专业知识被图灵和许多后来的人工智能研究人员认为是战略思维的有力证据。然而，IBM 在 1996 年击败加里·卡斯帕罗夫的名为“深蓝”的计算机程序并非基于逻辑。这个程序根据什么最大化胜利的概率来选择它的行动— 概率是关键词。这种游戏方式与早期对机器智能的理解背道而驰。但也许它重新定义了机器智能。

事实上，在众多其他问题中，即使是图灵最初的 NLP 问题也从将统计学和概率论应用于该任务中获益匪浅。

随着时间的推移，机器学习科学家也将有线和无线通信领域的一些经典思想改编为自己使用。通信工程师非常担心在介质中传输的珍贵比特中能容纳多少“信息”,以及如何恢复传输中丢失的信息。同样，ML 的科学家们担心从他们能得到的零碎数据中收集尽可能多的“信息”。相反，如果他们不会丢失太多信息，他们会很乐意为了效率而忽略一些数据。

Using concepts from communication and information theory, data can be represented in alternative forms to make them better suited for specific applications. Image credit: Wikimedia Commons

这种概率和统计技术与人类在大脑中组织信息和知识的方式相去甚远。从这个意义上说，它们补充了人类的智力。最接近模仿人脑的东西被称为人工神经网络或安。这是一种在过去十年里变得特别流行的技术。人工神经网络是“功能草图”——我们之前描述过的一个术语——它们可以被训练来执行各种任务:从手写识别，到预测销售，到识别医学图像中的异常对象，到自然语言处理和语言翻译。

人工神经网络令人着迷，最近理所当然地受到了很多关注。但是，我们是否会很快见证一个类似人类的、有自我意识的计算机程序的到来，还没有定论。

那么接下来会发生什么呢？

可以肯定地说，人工智能的最新发展在很大程度上归功于计算机硬件的最新发展。如果没有密集封装的内存芯片和快如闪电的处理器，我们就不会产生海量的数据，也没有能力处理所有这些数据。这也解释了机器学习统计技术的兴起:一个人提供的数据越多，统计推断就越好。

Statistical inferences work because we are, after all, not much different from one another.

只要有数据，就一定会有人最终应用机器学习并获得推论，这些推论往往令人惊讶，甚至无法通过其他方式获得。然而，无论怎么强调都不为过的是，找到数据和学习技巧的正确组合绝非易事。很多事情都可能出错，也确实出错了。通常很难获得高质量的数据，这些数据公平统一地反映了手头问题的所有方面。此外，ML 技术很容易因缺乏经验或工程师的偏见而受阻。

2015 年，谷歌因其图像分类器 AI 将非裔美国人标记为大猩猩而受到批评。美国法院越来越依赖由 ML 驱动的算法来决定一名囚犯在出狱后是否有可能再次犯罪；如果是的话，那么判决会更严厉。但是这些算法中的一些被证明对某些种族的人有不公平的偏见。这是因为与学习技巧一起使用的一组例子没有统一地代表所有种族的人。在某种意义上，人工智能无意中学会了仅仅根据人的种族来预测重返犯罪生活的可能性。

我们意识到，画家艾的水平取决于用来训练他的例子和技巧。这样的例子不胜枚举，它们提醒我们，就像所有人造的东西一样，人工智能也受到天生愚蠢的束缚。

如果你喜欢这篇文章，你可能也想知道更多关于人工智能的历史。从希腊神话，到中世纪的人形机器人，再到计算机的发明。

人工智能:理解炒作

原文：https://towardsdatascience.com/artificial-intelligence-understanding-the-hype-daee0df04695?source=collection_archive---------4-----------------------

“迄今为止，人工智能最大的危险在于，人们过早地断定自己理解它。”—埃利泽·尤德科夫斯基

解决炒作问题

人工智能到处都是头条新闻。如果你没有生活在岩石下，你肯定会遇到人工智能、机器学习、自然语言处理等术语。任何对科技行业略知一二的人都知道，它对流行语、时尚、流行语和炒作并不陌生。

AI、ML 等成了流行语。围绕人工智能的炒作在世界其他地方已经减少，但印度仍然是炒作周期的一部分。学生们甚至在拥有计算机科学基础之前就想学习人工智能。求职者希望找到允许他们使用人工智能的工作，公司希望在他们的产品中实现人工智能。创业公司正在将人工智能作为其平台的核心技术，因为他们充分意识到投资者对人工智能感兴趣。球场甲板上充满了人工智能参考和空洞的承诺。公司在计划如何在产品中使用人工智能之前，会聘请人工智能专家。任何以如此迅猛的速度发展的技术都很难被任何人忽视。谷歌首席执行官桑德尔·皮帅表示，世界正在从移动第一世界过渡到 T2 人工智能第一世界。

每个人都想搭上人工智能的顺风车。但是人们了解 AI 吗？你会惊讶地发现有多少人不知道人工智能究竟是什么。我打算用这篇文章来帮助解释人工智能。

理解人工智能

简单地说，人工智能是计算机科学的一个分支，目标是让机器或程序思考和学习。

机器学习:当你在谷歌上搜索某个东西时，它使用一种叫做 RankBrain 的机器学习算法，根据各种参数过滤结果。它是人工智能的一个子集。它允许机器获取数据并自我学习。

深度学习: Google Now 也称为 Android 智能手机上的 Google Assistant，使用深度学习来执行使用大量数据的任务。当你提出一个问题时，谷歌助手会在大量数据中搜索，给你一个答案。它是机器学习的一个子集。它通过使用神经网络模拟人类决策来解决现实世界的问题。机器知道如何通过在大量数据上训练自己来模仿人类的决策。

自然语言处理:你安卓智能手机上的谷歌助手也使用 NLP。当你提问时，它会翻译人类语言，然后执行动作给你答复。也是 AI 的子集。它允许机器理解人类语言。NLP 可以使用基于 ML 的模型来帮助它解释语言。

Photo: Neota Logic

人工智能的其他领域如上图所示。希望以上信息能让你对 AI 有一个基本的了解。我建议你在读完这篇文章后深入挖掘。我个人喜欢 Udacity 上的这个课程，如果你想了解更多关于 AI 的知识: 人工智能简介 。如果你想学习机器学习，吴恩达 Coursera 上的 这个课程 是一个很好的开始。

当今人工智能的一些流行应用:

苹果设备上的 Siri。使用 NLP 和 ML。
Amazon.com 使用 ML 向用户推荐产品。
网飞通过分析大量数据，使用 ML 和深度学习向用户推荐电影和电视节目。
谷歌搜索使用 ML 对搜索结果进行排名。Google 还使用 ML 根据用户的浏览器历史和其他参数向用户显示有针对性的广告。

做出明智的决定

跟上技术的发展是很重要的，但是在我们了解技术将如何帮助我们之前学习或实现某些东西是一个坏主意。人工智能在正确使用的情况下是非常强大的。不要因为别人在用就用 AI，当你觉得它会比其他技术更快更好的帮助你解决一个问题的时候就用它。做出明智的决定很重要。在没有想法的情况下使用引人注目的技术只不过是一种实验。

如果你喜欢这篇文章，请点击底部的♥按钮。另外，请订阅我下面的时事通讯:

线下/数字营销中的人工智能用例/应用领域

原文：https://towardsdatascience.com/artificial-intelligence-use-cases-application-areas-in-offline-digital-marketing-ff64f7438b51?source=collection_archive---------5-----------------------

在推出 appliedAI.com 时，我们采访了企业领导人和各种规模的人工智能供应商，搜索了新闻文章、专利、风险投资融资等，以确定现有和新兴的人工智能用例。我们已经确定了大约十几个营销中的基本人工智能用例。我们专注于核心营销活动，例如优化定价和投放、优化广告/营销、个性化推荐、收集和利用客户反馈。我们一直在改进我们的结构，希望听到您的意见和建议。

下面列出了主要的营销活动和这些活动中的人工智能用例。要了解更多信息，请访问相关页面，查看参考资料、视频和详细解释:

1-优化定价&投放

定价优化:优化降价以最小化自相残杀，同时最大化收益。

商品销售优化:利用机器学习和大数据来优化您的在线或离线商品销售

货架审计/分析:在零售区使用视频、图像或机器人来审计和分析您对货架空间的使用。识别和管理缺货或货架空间的次优使用。

视觉搜索功能:利用机器视觉，让您的客户能够通过图像或视频搜索您的产品，从而立即找到他们想要的产品。

图像标记以改进产品发现:利用机器视觉来标记图像，同时考虑用户的偏好和产品的相关背景。

2-优化广告

神经营销:利用神经科学和生物传感器来了解你的内容如何影响你的观众的情绪和记忆。私下测试你的内容，直到达到预期效果。

分析:自动连接你所有的营销数据和 KPI。根据您的数据管理营销活动、触发警报并提高您的营销效率

个性化营销:在正确的时间，通过正确的设备和渠道，将正确的信息传达给正确的客户。用您的个性化营销提高客户满意度，让您的客户大吃一惊。

情境感知广告:利用机器视觉和自然语言处理来理解广告投放的情境。通过确保您的信息与共享信息的网页或应用程序的上下文一致，保护您的品牌并提高营销效率

3-个性化推荐

个性化推荐:利用客户数据，通过电子邮件、网站搜索或其他渠道向客户提供个性化推荐。

4-联系&利用客户反馈

社交媒体监控:利用机器学习优化你的社交媒体帖子的渠道、目标受众、信息和时机。

社交分析&自动化:利用自然语言处理和机器视觉来分析和处理你的实际或潜在客户在社交媒体、调查和评论上生成的所有内容。

社交媒体优化:利用机器学习来优化你的社交媒体帖子的渠道、目标受众、信息和时机

公关分析:学习、分析和衡量你的公关工作。这些解决方案跟踪媒体活动，并提供对公关工作的见解，以突出推动参与度、流量和收入的因素。

你可以在下面这张相当复杂的图表中看到所有这些用例。

要获得更多关于这些用例的信息，包括参考资料、案例研究、客户视频和关于在该领域运营的供应商的信息，请访问我们的https://appliedai.com或查看我们关于人工智能在营销中的用例的扩展博客文章。

保持乐观！

杰姆·迪尔梅加尼

人工智能:你成功的关键:)

原文：https://towardsdatascience.com/artificial-intelligence-your-key-to-success-749678ea4757?source=collection_archive---------5-----------------------

Image Attribution

人工智能(AI)带来的潜在问题与疯狂的机器人或理智的机器人接管工作无关。这与人和产品变得“过时”有关。好消息是，这可以通过理解什么是人工智能以及它将影响哪些领域来补救，以期创造一种与这种短期必然性相一致的思维模式。

鉴于我在人工智能方面的背景，同事和朋友们一直在问我，人工智能是否意味着我们所知道的世界末日。他们询问关于软件编写软件、奇点、斯蒂芬·霍金说过的话等等。大多数人在阅读或讨论 Al 时都表示感觉过时了。到目前为止，在职业上，他们已经掌握了各种新技术，比如电子邮件、学习谷歌、在易贝购物、在脸书上传个人资料供所有人观看、Snapchatting 等等。

但是人工智能呢？你是怎么处理的？是时候看看退休选择了吗？号码

AI 会留在这里。人工智能本质上是知识的科学。都是知识和学习的问题。技术是知识，在某种程度上，存在的一切都是技术，包括人类。

那么，什么是 AI？

长话短说，AI 可以分解成各个重点领域，其中最重要的是机器学习和自然语言处理。下面是对这些问题的快速而简单的解释。

1。机器学习(ML)

机器学习基于模拟生物大脑功能的神经网络。神经网络是一个由神经元(脑细胞)组成的网络，这些神经元通过称为突触的连接相互连接(想象一下渔网)。这些连接具有一定的强度(正的或负的),这些连接的组合将根据某个阈值导致神经元被打开(放电),或不被打开(想象一个连接了一些电源线的灯泡:如果累积的功率足够大，灯泡就会打开)。人类的思维是神经元放电(或不放电)的结果(尽管这可能是一种保守的说法)。

现在，拿一个神经网络的一边，打开一些神经元。然后拿另一边，再次打开一些神经元。你已经给了网络一个给定输入和预期输出的例子(想象一个 1 加 1 的输入和一个 2 的输出，以便教它加法)。接下来，给它许多例子，然后使用一种特定的标准化学习算法，通过这种算法，它可以通过调整其连接的能力以及神经元何时激活来学习。一旦它通过多次迭代稳定下来，让它添加你没有教过它的数字:它会根据它所学到的东西以很高的概率做出准确的响应。这样，给定输入数据集(例如图像)和输出数据集(例如这些图像的描述)，基于它“看到”的模式，它可以非常准确地回答新图片包含什么，即使它以前从未见过它。

这方面的一个实际例子是谷歌视觉 API，它在一个巨大的图像数据集上进行训练，可以理解图像的内容。

2。自然语言处理

本质上，我们对世界的认识是一种内在的本体论。本体是概念和类别以及它们的属性和它们之间的关系的分层集合。婴儿在他们在地球上的职业生涯的第一天就开始建立这个本体，从“饥饿”的概念和相关的“牛奶”的子概念开始(属性:颜色:白色，味道:非常好)。

然后引入一种叫做“语言”的交流媒介，这种媒介很快被所有相关方认为非常有用。语言与不断扩展的内部本体(知识库)直接相关。起初，基于范例的学习模式被用来教授这种新的交流技术，但最终在学校引入了一套正式的语法规则。

自然语言处理对上述内容进行建模，以便在句法/语义上(如语言所定义的)和上下文上(如与环境和本体知识相关的)理解文本。

长话短说，人工智能在实践中使用 NLP 的一个实际例子是 Thinkfor.me Email ，它通过使用 NLP 总结每封电子邮件，并可选地以摘要、要点或单页模式展示它们，从而长话短说。

如何留在比赛中

伸出双手和双腿站在河中央，你无法阻止河水流动。根据你的职业，与人工智能打交道的最好也是唯一的方式是考虑它如何帮助你增加你所做事情的价值、准确性和效率。如果你是一名企业主，你应该看看嵌入式人工智能如何帮助你变得更具竞争力，并防止你的产品迅速过时。。

下面不是提供一个“十大途径”的列表，而是一个在不久的将来人工智能潜在影响领域的职业参考。

生产力中的人工智能

创造一个包罗万象的人工智能助手

金融中的人工智能

决策支持通过对经常性股票图表模式的分析使用 ML 来评估潜在的价格变动

基于神经网络的应用程序，可根据案例历史数据集做出更明智的贷款决策

教育中的人工智能

使用 NLP 作为学习工具学习工具从语法和概念上分析和总结文本

在给定历史数据集的情况下使用 ML 预测学习结果

使用自然语言处理评估和评分论文

艾在法

基于历史案例数据和结果预测法院判决

基于上下文级别智能搜索案例和决策文本

销售中的人工智能

使用 NLP 和 ML 管理电子邮件活动，以阅读和理解电子邮件回复，从而确定要追求的目标

智能广告:如何赢得买家并影响销售(请留意这一条)

艾未未

使用 ML 支持慢性疾病患者

使用 ML 作为治疗计划选择的决策支持

艾在新闻(假的还是假的)

在给定历史数据集的情况下，使用 ML 结合 NLP 来区分假新闻和真实新闻

人工神经网络:人对机器？

原文：https://towardsdatascience.com/artificial-neural-networks-man-vs-machine-194860bed5c2?source=collection_archive---------15-----------------------

Photo Credits — Äkta människor SVT1

本文是探索 10 种基本机器学习算法的 BAI 系列文章的一部分*

这些机器人是人类还是某种机器？如果人类智能能够快速区分这两者，那么机器学习就必须依靠像人工神经网络这样的算法来做出预测。人工神经网络模仿人类大脑的结构，允许机器像人类一样思考吗？到底什么是 ann，它们是如何工作的，它们与其他机器学习算法有什么不同，它们在数据科学中的使用场景是什么？

计算机最初是围绕由预定步骤组成的算法设计的，以计算给定情况下的正确答案。这种对“绝对确定性”的信念使组织能够优化业务流程，加快会计程序，并改善他们的供应链。然而，图像分类、对象检测和语音转文本的挑战超出了传统算法的能力范围，因为它们需要能够基于不完全信息预测概率的算法。

1943 年，麦卡洛克和皮茨利用基于概率论的计算模型，结合阈值逻辑，创建了第一个人工神经网络。人工神经网络由三层相连的神经元组成:输入层将数据输入系统进行处理，隐藏层依靠一组加权输入通过激活函数产生结果，输出层产生程序的结果。因此，人工神经网络是基于概率的算法，它们不像人脑那样“思考”，而是采用数学函数来应对随机学习环境的挑战。

神经元或节点是一个数学函数，它接收输入并给出代表输入计算结果的单一输出。人工神经网络是通过例子和经验逐步学习的，而不是通过一系列命令。深度神经网络由数千个这样的神经元组成。深度神经网络为数据科学家提供了一种处理模糊性和复杂性的方法，因为它们将问题分解为微小的子问题，从而允许构建输入如何呈现的精确表示。

人工神经网络的每一层都以特定的权重处理其输入，从而产生操作值。然后，该值乘以生成的阈值，并发送至激活函数以计算输出。给定一组输入，二元、线性和非线性激活函数用于定义每个神经元的输出。然后，该函数的输出作为另一层的输入发送，或者如果该层是最后一层，则作为网络的最终响应发送。【1】

通过使用被称为前向传播和反向传播的技术来标准化“权重”,进行人工神经网络的训练。人工神经网络的一个关键特征是这些迭代学习过程，其中数据一次一个地呈现给网络，并且与输入值相关联的权重以同样的方式进行调整。因此，训练人工神经网络在计算上是昂贵的，并且经常会导致过度拟合。

在前向传播中，样本权重通过输入被输入到人工神经网络，相应的样本输出被记录。更准确地说，前向传播是这样一个过程:向人工神经网络输入一组输入，以获得它们的分量乘积(即它们的点积)与它们的权重之和，然后将后者输入到激活函数，并将其数值与实际输出(地面真实值)进行比较。

反向传播是一种用于计算梯度的方法，该方法需要校准网络中使用的权重。在反向传播数据中，科学家从输出单元通过隐藏单元到输入单元，考虑每层输出的误差范围。然后调整输入，使误差幅度最小。

最后，人工神经网络有几种形式。最初，感知器被设计为用于二元预测的线性分类器。这种模型的主要限制是数据必须是线性可分的，这导致了多层人工神经网络能够解决复杂的分类和回归任务。目前使用的神经网络有六种基本形式，它们集成了不同的数学运算和不同的参数集。前馈主要用于语音和声音识别，径向基函数已用于预测电网短缺，Kohonen 自组织是模式识别的逻辑选择，递归神经网络已用于语音到文本，卷积用于信号处理，模块化神经网络作为多模块决策策略的一部分。【2】

Kohonen Neural Networks

回到我们从瑞典电视连续剧《真实人类》中拍摄的 hubots 照片，让我们假设我们的神经网络中有三个神经元(A、B、C)。【3】在对数据进行训练并将神经元 A、B 和 C 分配给区分人和机器的重要特征之后，可以训练算法，当激活 A & C 时，图像属于人类，但如果 A & B 被激活，则图像属于机器。可以开发神经网络来破译与人类相关的一系列特征:同理心、自然智力、想象力、信仰、情感等。这些特征的定义本身就是人类的构造，超出了当前人工智能应用的范围。尽管如此，由数千个，甚至数百万个神经元组成的深度神经网络可以帮助我们更精确地描述这些特征，从而建立更好的预测模型来探索这种复杂性和模糊性。

李施伦克博士，商业分析研究所，2018 年 10 月 5 日

*之前在白系列中发表的关于基本机器学习算法的文章包括 k-NN —了解最近的邻居、 贝叶斯定理—熟能生巧 和 鲨鱼攻击—解释泊松回归的使用

Lee Schlenker 是商业分析和社区管理教授，也是 http://baieurope.com 商业分析研究所的负责人。在可以看到他的 LinkedIn 个人资料在可以在的 Twitter 上关注白

【1】Gnanasegaram，t .(2018)，人工神经网络——简介

【2】(2018)马拉德哈尔，k .，目前在机器学习中使用的 6 种人工神经网络，印度分析

【3】这个例子的灵感来自约翰·奥拉芬瓦(John Olafenwa)，(2018)，神经网络简介

人工神经网络和神经科学

原文：https://towardsdatascience.com/artifician-neural-networks-and-neuroscience-e4852b10d7a9?source=collection_archive---------3-----------------------

TL；博士

众所周知，人工神经网络受到不同学科的影响，如数学、物理和神经科学(顾名思义)。

人工神经网络能提供任何线索回到神经科学去理解一些大脑结构吗？

长版

人工神经网络是数学、物理(如统计力学)和神经科学交叉领域的结果。

人工神经网络最初的神经科学灵感可以追溯到 40 年代，因为它收到了上述领域的大量贡献:

从数学的角度来看，让我们考虑一下函数优化和误差反向传播(梯度计算等)的所有影响
从物理的角度，我们来思考一下受限玻尔兹曼机和自旋玻璃之间的联系
从神经科学的角度来看，让我们想想最近生物启发的卷积神经网络(CNN)的成功

所以问题是安能给这些领域什么回报？

许多臭名昭著的深度神经网络应用于数据密集型领域，如应用数学、物理和显然的工程，目前已经开发并正在开发中，但神经科学呢？

人工神经网络的最新发展是否有助于提高我们对大脑的了解，反之亦然，从而引发良性循环？

似乎是这样的:计算神经科学领域的一些最新推测可以被定义为“人工神经网络启发的”,事实也的确如此

动态学习相当于大脑中发生的成本函数优化
对于架构和成本函数来说，任务特异性对于实现足够好的性能水平是必要的
计算专用结构存在:不同种类的存储器(例如，内容可寻址、缓冲区等)，不同种类的信息路由系统(例如，注意力、高级门控系统等)

大脑神经元和人工神经元的区别

首先，重要的是观察到，即使一些 ANN / DL 架构具有某种生物灵感，但人工神经元和生物神经元之间仍然存在很大差异。

最臭名昭著的差异之一是关于网络上的物理时间效应:虽然目前最常用的人工神经网络没有物理时间的概念(因为推理和训练计算发生在离散的计算时间内)，但生物网络深受物理时间的影响，因为神经元通过发送尖峰信号工作，网络状态取决于时间。

这就是说，如果 ANN / DL 体系结构和生物学体系结构在某些方面看起来相似，它们在许多其他方面，甚至是基本方面仍然非常不同。

大脑中的成本函数优化

在当前的人工神经网络中，典型的优化算法类是依赖于成本函数局部梯度计算的梯度下降类。由于一系列的原因，大脑不太可能利用这样的机制，因此已经形成了其他的假说，如 1) 赫布边可塑性和 2) 系列扰动。

Hebbian 可塑性基本上是一个基于成对神经元尖峰活动相关性的神经元权重学习规则:神经元对连接越强，其尖峰活动相关性越强，减弱越弱。

Fig.1. Hebbian Plasticity: the connection between 2 neurons is strenghtened the more their spiking activity is correlated and weakened the less their spiking activity is correlated.

串行扰动是一种基于噪声的策略，旨在探索神经元参数状态空间:对神经元连接权值随机执行扰动，并根据假设使用的参考成本函数评估其效果。

任务特定成本函数

第二个假设是关于大脑中存在任务特定的架构和成本函数，根据特定的算法进行优化(即学习)，其中一些算法在前一点中已经介绍过。

这种假设是基于“一刀切”的成本函数和架构无法提供足够好的性能水平，因此需要某种程度的专业化。

根据这种假设，理解如何定义任务特定的成本函数也是有趣的，从而执行一种“元学习”(即，决定哪个成本函数是最佳优化的，以便在特定任务中实现良好的性能)。

这些话题将在一个专门的文章系列中讨论。

计算专用结构

类似于前一点，一些“计算启发”的结构也被认为存在于大脑中，如:记忆和信息路由。

众所周知，记忆是大脑中发生的复杂现象，存在不同种类的记忆，如:内隐记忆(即，不可明确恢复的记忆)、内容可寻址记忆和短期记忆。

对于这些类型的现象，存在一些 DNN 模型，如通过脉冲网络实现的内容可寻址存储器的 Hopfield 网络。

信息路由机制允许高效和有效的信息处理:注意机制导致效率，使得处理系统聚焦于最相关的信息，而门控系统允许在处理系统的不同区域之间提供远程连接的效率(在没有完全连接的拓扑的情况下)。

这些话题也将在专门的文章系列中讨论。

Matplotlib 中的“艺术家”——这是我在花大量时间在谷歌上搜索如何做之前想知道的。

原文：https://towardsdatascience.com/artist-in-matplotlib-something-i-wanted-to-know-before-spending-tremendous-hours-on-googling-ca3ab05ab08d?source=collection_archive---------14-----------------------

Cover Photo by Caleb Salomons on Unsplash

最初发表于 dev.to 并稍作修改以适应 Medium 的编辑系统。

matplotlib 确实是 Python 中一个非常棒的可视化工具。但是在 matplotlib 中调整细节确实是一件痛苦的事情。你可能很容易失去几个小时来找出如何改变你的一小部分情节。有时你甚至不知道零件的名称，这使得谷歌搜索变得更加困难。即使您发现了关于堆栈溢出的提示，您可能还需要花费几个小时来使它适合您的情况。通过了解 matplotlib 中的图形由什么组成以及可以用它们做什么，可以避免这些没有回报的任务。我想，和你们大多数人一样，我已经通过阅读 matplotlib 大师关于堆栈溢出的大量回答克服了我的绘图问题。最近，我注意到一个关于 [Artist](https://matplotlib.org/tutorials/index.html) 对象的官方教程非常有用，有助于理解我们使用 matplotlib 绘图时发生的事情，并减少调整所花费的大量时间。在这篇文章中，我想分享一些关于 matplotlib 中的Artist对象的基本知识，这将避免你花费数小时进行调整。

这个职位的目的

我不打算写像“当你想这样做时就这样做”这样的操作方法，而是 matplotlib 中Artist的一个基本概念，它可以帮助你选择合适的搜索查询，并为类似的问题安排一个解决方案。读完这篇文章后，你可能会更清楚地理解网上那些海量的食谱。这也适用于那些使用 seaborn 和熊猫绘图特性的人，这些特性是 matplotlib 的包装。

内容

这个帖子基本上是我用日语写的原文的英文版，大部分基于艺术家教程和使用指南(原文发表时为 2.1.1)

这是给谁的？

Matplotlib 用户

如果需要的话，他们能够制作情节，但通常很难使其适合出版或展示(并且对“最后一英里”是你真正想要的感到恼火)。
已经成功地找到了堆栈溢出的精确解决方案，但仍然不清楚它是如何工作的，也不能将其应用于其他问题。
找到了一个问题的多个提示，但不确定应该遵循哪一个。

环境

Python 3.6
matplotlib 2.2

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

plt.show()在本文中省略，因为我用的是 Jupyter notebook 的内联情节。

你应该知道的两种绘图风格

在研究Artist对象之前，我想提一下plt.plot和ax.plot的区别，或者 Pyplot 和面向对象的 API。虽然官方推荐使用面向对象的 API 风格，但是仍然有很多例子和代码片段使用 Pyplot 风格，包括官方文档。有些人甚至毫无意义地混合了两种风格，这给初学者造成了不必要的困惑。由于官方文档对它们有很好的注释，如关于面向对象 API vs Pyplot 的注释和编码风格，这里我只对它们做一些评论。如果你要找他们的介绍，我推荐官方教程。

面向对象的 API 接口

这是推荐的风格，通常以fig, ax = plt.subplots()或其他类似的开头，后面是ax.plot、ax.imshow等。fig和ax其实就是Artist s，下面是一些最简单的例子。

# example 1
fig, ax = plt.subplots()
ax.plot(x,y) # example 2
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.plot(x, y)

有些教程使用fig = plt.gcf()和ax = plt.gca()。当你从 Pyplot 接口切换到 OO 接口时应该使用这些，但是一些基于 Pyplot 的代码包括，例如，无意义的ax = plt.gca()，它显然是在没有理解的情况下从基于 OO 的代码中复制的。如果有人有意切换界面，使用plt.gcf()或plt.gca()并不是一件坏事。考虑到隐式切换可能会给初学者带来困惑，如果plt.subplots或fig.add_subplot是公开可用的，那么从一开始就使用它们将是大多数情况下的最佳实践。

Pyplot 界面

这是一种 MATLAB 用户友好的风格，所有的事情都用plt.***来完成。

# [https://matplotlib.org/tutorials/introductory/pyplot.html](https://matplotlib.org/tutorials/introductory/pyplot.html)def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)
plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')
plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

起初，它看起来非常简单，因为不需要考虑您正在处理哪些对象。你只需要知道你处于哪种“状态”，这也是为什么这种风格也被称为“有状态接口”。这里的“状态”指的是你当前所处的人物和支线剧情。正如你在 Pyplot 教程中看到的，如果你的情节不是那么复杂，它会给出一个不错的数字。虽然 Pyplot 界面提供了很多改变绘图设置的功能，但你可能会在几个小时、几天、几个月内达到它的极限(如果你足够幸运的话，可能永远也不会),这取决于你想做什么。这个阶段需要切换到 OO 界面。这也是我一开始就推荐使用 OO 接口的原因。但 Pyplot 对于快速检查或任何需要粗略绘图的场合仍然有用。

matplotlib 中的层次结构

谷歌几次后，你会注意到 matplotlib 有一个层次结构，由通常被称为fig和ax的东西组成。matplotlib 1.5 的旧文档有一个很好的图像来解释这一点。

实际上，这三个组件是被称为“容器”的特殊Artist(还有第四个容器Tick，我们稍后会看到。这种层次结构使得上面的简单例子更加清晰。

# example 1
fig, ax = plt.subplots()
# make Figure and Axes which belongs to 'fig'# example 2
fig = plt.figure()
# make Figure
ax = fig.add_subplot(1,1,1)
# make Axes belonging to fig

进一步查看fig和ax的属性有助于您更好地理解层次结构。

fig = plt.figure()
ax = fig.add_subplot(1,1,1) # make a blank plotting area
print('fig.axes:', fig.axes)
print('ax.figure:', ax.figure)
print('ax.xaxis:', ax.xaxis)
print('ax.yaxis:', ax.yaxis)
print('ax.xaxis.axes:', ax.xaxis.axes)
print('ax.yaxis.axes:', ax.yaxis.axes)
print('ax.xaxis.figure:', ax.xaxis.figure)
print('ax.yaxis.figure:', ax.yaxis.figure)
print('fig.xaxis:', fig.xaxis)

输出:

fig.axes: [<matplotlib.axes._subplots.AxesSubplot object at 0x1167b0630>]
ax.figure: Figure(432x288)
ax.xaxis: XAxis(54.000000,36.000000)
ax.yaxis: YAxis(54.000000,36.000000)
ax.xaxis.axes: AxesSubplot(0.125,0.125;0.775x0.755)
ax.yaxis.axes: AxesSubplot(0.125,0.125;0.775x0.755)
ax.xaxis.figure: Figure(432x288)
ax.yaxis.figure: Figure(432x288)
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-21-b9f2d5d9fe09> in <module>()
      9 print('ax.xaxis.figure:', ax.xaxis.figure)
     10 print('ax.yaxis.figure:', ax.yaxis.figure)
---> 11 print('fig.xaxis:', fig.xaxis)

AttributeError: 'Figure' object has no attribute 'xaxis'

从这些结果中，我们可以预期关于Figure、Axes和Axis的层级的以下规则。

Figure知道Axes但不知道Axis。
Axes知道Figure和Axis两者。
Axis知道Axes和Figure两者。
Figure可以包含多个Axes，因为fig.axes是Axes的列表。
Axes可以只属于单个Figure因为ax.figure不是列表。
出于类似的原因，Axes可以分别有一个XAxis和YAxis。
XAxis和YAxis可以属于单个Axes，相应地也可以属于单个Figure。

你情节中的一切都是一个`Artist`

当前文档中的使用指南没有使用图来解释层次结构，而是使用“图的剖析”来解释图中的所有组件，这也是一种信息。

从代表数据的线和点，到 x 轴上的小记号和文本标签，图形中的每一个组件都是一个Artist object⁴.Artist有两种类型，容器和原语。正如我在上一节中所写的，matplotlib 的层次结构中的三个组件，Figure、Axes和Axis是容器，它们可以包含更低的容器和多个原语，例如由ax.plot生成的Line2D、ax.scatter生成的PathCollection或由ax.annotate生成的Text。甚至刻度线和标签实际上都是属于第四个容器Tick的Line2D和Text。

对于每种类型的原语，容器都有许多“盒子”(Python 列表，技术上来说)。例如，一个Axes对象ax，在实例化之后有一个空列表ax.lines。常用命令ax.plot在列表中添加一个Line2D对象，并静默进行其他伴随设置。

x = np.linspace(0, 2*np.pi, 100)

fig = plt.figure()
ax = fig.add_subplot(1,1,1)
print('ax.lines before plot:\n', ax.lines) # empty list# add Line2D in ax.lines
line1, = ax.plot(x, np.sin(x), label='1st plot') 
print('ax.lines after 1st plot:\n', ax.lines)# add another Line2D
line2, = ax.plot(x, np.sin(x+np.pi/8), label='2nd plot') 
print('ax.lines after 2nd plot:\n', ax.lines)ax.legend()
print('line1:', line1)
print('line2:', line2)

输出:

ax.lines before plot:
 []
ax.lines after 1st plot:
 [<matplotlib.lines.Line2D object at 0x1171ca748>]
ax.lines after 2nd plot:
 [<matplotlib.lines.Line2D object at 0x1171ca748>, <matplotlib.lines.Line2D object at 0x117430550>]
line1: Line2D(1st plot)
line2: Line2D(2nd plot)

以下部分总结了四种容器。表格复制自艺人教程。

`Figure`

具有复数名称的属性是列表，具有单数名称的属性表示单个对象。值得注意的是，属于Figure的Artist默认使用Figure坐标。这可以用 [Transforms](https://matplotlib.org/users/transforms_tutorial.html)转换成Axes或者数据坐标，不在本帖讨论范围内。

`fig.legend`和`ax.legend`

fig.legends是通过[fig.lenged](https://matplotlib.org/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure.legend) 方法添加的图例的“框”。你可能会想“那是干什么的？我们有ax.legend。”不同之处在于每种方法的范围。ax.legend只收集属于ax的Artist的标签，fig.legend收集fig下所有Axes的标签。这很有用，例如，当你使用ax.twinx绘图时。简单的用两次ax.legend就做了两个图例，一般不可取。

x = np.linspace(0, 2*np.pi, 100)

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, np.sin(x), label='sin(x)')
ax1 = ax.twinx()
ax1.plot(x, 2*np.cos(x), c='C1', label='2*cos(x)') 
# cf. 'CN' notation
# https://matplotlib.org/tutorials/colors/colors.html#cn-color-selection

ax.legend()
ax1.legend()

将它们放在一起的一个著名方法是将两者的图例处理程序和标签结合起来。

# Executing this part in a different notebook cell shows an updated figure.
handler, label = ax.get_legend_handles_labels()
handler1, label1 = ax1.get_legend_handles_labels()
ax.legend(handler+handler1, label+label1, loc='upper center', title='ax.legend')
# Legend made by ax1.legend remains
fig

这可以通过fig.legend轻松完成，而无需在版本 2.1 ⁵.中引入的参数默认情况下，位置由Figure坐标指定，当您想将其放在绘图框中时，该坐标没有用。你可以用bbox_transform关键字把它改成Axes坐标。

fig.legend(loc='upper right', bbox_to_anchor=(1,1), bbox_transform=ax.transAxes, title='fig.legend\nax.transAxes')
fig

`Axes`

matplotlib . axes . axes 是 matplotlib 宇宙的中心

这是引用自艺人教程的话。这是非常正确的，因为 matplotlib 中数据可视化的重要部分都来自于Axes方法。

经常使用的命令如ax.plot和ax.scatter被称为“助手方法”,它们在适当的容器中添加相应的Artist,并做其他杂七杂八的工作。

这个例子显示了ax.plot和ax.scatter在相应的列表中添加Line2D和PathCollection对象。

x = np.linspace(0, 2*np.pi, 100)

fig = plt.figure()
ax = fig.add_subplot(1,1,1)
# empty Axes.lines
print('ax.lines before plot:\n', ax.lines) # add Line2D in Axes.lines
line1, = ax.plot(x, np.sin(x), label='1st plot') 
print('ax.lines after 1st plot:\n', ax.lines)# add another Line2D
line2, = ax.plot(x, np.sin(x+np.pi/8), label='2nd plot') 
print('ax.lines after 2nd plot:\n', ax.lines)

print('ax.collections before scatter:\n', ax.collections)
scat = ax.scatter(x, np.random.rand(len(x)), label='scatter') # add PathCollection in Axes.collections
print('ax.collections after scatter:\n', ax.collections)
ax.legend()
print('line1:', line1)
print('line2:', line2)
print('scat:', scat)
ax.set_xlabel('x value')
ax.set_ylabel('y value')

输出:

ax.lines before plot:
 []
ax.lines after 1st plot:
 [<matplotlib.lines.Line2D object at 0x1181d16d8>]
ax.lines after 2nd plot:
 [<matplotlib.lines.Line2D object at 0x1181d16d8>, <matplotlib.lines.Line2D object at 0x1181d1e10>]
ax.collections before scatter:
 []
ax.collections after scatter:
 [<matplotlib.collections.PathCollection object at 0x1181d74a8>]
line1: Line2D(1st plot)
line2: Line2D(2nd plot)
scat: <matplotlib.collections.PathCollection object at 0x1181d74a8>

不建议重复使用打印对象

在知道列表中包含绘制的对象后，您可能会想到通过将这些对象附加到另一个Axes.lines列表中来重用这些对象，以加快绘制速度。艺术家教程明确指出不推荐这样做，因为助手方法除了创建Artist还能做很多事情。一个快速测试告诉我们这不是一个好主意。

x = np.linspace(0, 2*np.pi, 100)

fig = plt.figure()
# upper subplot
ax1 = fig.add_subplot(2,1,1) 
# create a Line2D object
line, = ax1.plot(x, np.sin(x), label='ax1 line') 
ax1.legend()

# lower subplot
ax2 = fig.add_subplot(2,1,2) 
# try to reuse same `Line2D` object in another `Axes`
ax2.lines.append(line)

甚至add_line方法也不管用。

ax2.add_line(line)

输出:

ValueError: Can not reset the axes. You are probably trying to re-use an artist in more than one Axes which is not supported

这个错误消息表明一个Artist，容器或者原语，不能包含在多个容器中，这与每个Artist将父容器作为一个空对象而不是在一个列表中的事实是一致的

print('fig:', id(fig)) 
print('ax1:', id(ax1))
print('line.fig:', id(line.figure))
print('line.axes:', id(line.axes))

输出:

fig: 4707121584
ax1: 4707121136
line.fig: 4707121584
line.axes: 4707121136

如果你以适当的方式做了所有必要的事情，这也许是可能的，但是这远不是仅仅把一个对象附加到一个列表中的第一想法，并且是不这样做的足够的理由。

`Axis`

虽然Axis以XAxis或YAxis出现，只包含与记号和标签相关的Artist，但它经常需要一些谷歌搜索进行细微调整，偶尔需要一个小时。我希望这一部分能帮助你快速完成工作。

由于美工教程不像其他容器一样有表，所以我做了一个类似的表。

我们在示例中使用ax.set_xlabel和ax.set_ylabel来表示Axes容器。你可能认为这些方法改变了Axes实例(ax)的 X 和 Y 标签，但实际上它们分别改变了XAxis和YAxis、ax.xaxis.label和ax.yaxis.label的label属性。

xax = ax.xaxis
print('xax.label:', xax.label)# seven major ticks (from 0 to 6) and
# two invisible ticks locating outside of the figure
print('xax.majorTicks:\n', xax.majorTicks) # two ticks outside the figure
print('xax.minorTicks:\n', xax.minorTicks)

输出:

xax.label: Text(0.5,17.2,'x value')
xax.majorTicks:
 [<matplotlib.axis.XTick object at 0x117ae4400>, <matplotlib.axis.XTick object at 0x117941128>, <matplotlib.axis.XTick object at 0x11732c940>, <matplotlib.axis.XTick object at 0x1177d0470>, <matplotlib.axis.XTick object at 0x1177d0390>, <matplotlib.axis.XTick object at 0x1175058d0>, <matplotlib.axis.XTick object at 0x1175050b8>, <matplotlib.axis.XTick object at 0x117bf65c0>, <matplotlib.axis.XTick object at 0x117bf6b00>]
xax.minorTicks:
 [<matplotlib.axis.XTick object at 0x117ab5940>, <matplotlib.axis.XTick object at 0x117b540f0>]

`ax.set_***`方法是临时的

Axes有许多“set_”辅助方法来修改Axis和Tick实例的属性和值。它们非常方便，matplotlib 初学者遇到的大部分问题都可以用它们来解决。值得注意的是，这些“set_”方法是静态的。当某些内容发生变化时，对它们所做的更改不会更新。例如，如果您使用ax.set_xticks更改 X 刻度以使它们在第一个图中看起来更好，而第二个图超出了第一个图的 X 范围，结果看起来不像它应该的样子。

x = np.linspace(0, 2*np.pi, 100)

fig = plt.figure()
ax = fig.add_subplot(1,1,1)# X range: 0 to 2pi
line1, = ax.plot(x, np.sin(x), label='') 
ax.set_xticks([0, 0.5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])# X range: 0 to 3p
iline2, = ax.plot(1.5*x, np.sin(x), label='')

`Ticker`那你呢

如果不使用“set_***”方法更改与记号相关的设置，则记号和记号标签会相应地为每个新绘图自动更新。这是由Ticker完成的，更具体地说，是由格式化程序和定位器完成的。尽管它们对于与 tick 相关的设置非常重要，但是如果您已经通过复制和粘贴堆栈溢出 answers⁶.解决了问题，那么您可能对它们知之甚少让我们看看前面的例子中发生了什么。

xax = ax.xaxis
yax = ax.yaxis
print('xax.get_major_formatter()', xax.get_major_formatter())
print('yax.get_major_formatter()', yax.get_major_formatter())
print('xax.get_major_locator():',  xax.get_major_locator())
print('yax.get_major_locator():',  yax.get_major_locator())

输出:

xax.get_major_formatter() <matplotlib.ticker.ScalarFormatter object at 0x118af4d68>
yax.get_major_formatter() <matplotlib.ticker.ScalarFormatter object at 0x118862be0>
xax.get_major_locator(): <matplotlib.ticker.FixedLocator object at 0x1188d5908>
yax.get_major_locator(): <matplotlib.ticker.AutoLocator object at 0x118aed1d0>

ScalarFormatter是为 X 轴和 Y 轴设置的，因为它是默认的格式化程序，我们没有改变它。另一方面，当默认AutoLocator被设置为 Y 轴时，FixedLocator被设置为 X 轴，我们使用ax.set_xticks方法改变了刻度位置。从它的名字可以想象，FixedLocator固定刻度位置，即使绘图范围改变也不更新。

让我们把前面例子中的Ticker换成ax.set_xticks。

# this is required to used `Ticker`
import matplotlib.ticker as ticker # locate ticks at every 0.5*piax.xaxis.set_major_locator(ticker.MultipleLocator(0.5*np.pi))# display the figure again with new locator.
fig

格式化程序怎么样？

# FuncFormatter can be used as a decorator
@ticker.FuncFormatter 
def major_formatter_radian(x, pos):
    # probably not the best way to show radian tick labels
    return '{}$\pi$'.format(x/np.pi) 

ax.xaxis.set_major_formatter(major_formatter_radian)
fig

好吧，也许你还想做些调整，但我想这已经足够清楚了。

可以在 matplotlib 图库了解更多。
图库>记号格式化器
图库>记号定位器

`xunits`关键字为`ax.plot`

供您参考，ax.plot有xunits关键词，是文档中暂时没有描述的。我从未尝试过使用这个选项，但是你可以在图库>弧度刻度中看到一个例子，并在这里了解更多关于matplotlib.units.ConversionInterface的信息。

import numpy as np
from basic_units import radians, degrees, cos
from matplotlib.pyplot import figure, show

x = [val*radians for val in np.arange(0, 15, 0.01)]

fig = figure()
fig.subplots_adjust(hspace=0.3)

ax = fig.add_subplot(211)
line1, = ax.plot(x, cos(x), xunits=radians)

ax = fig.add_subplot(212)
line2, = ax.plot(x, cos(x), xunits=degrees)

`Tick`

最后，我们到达了 matplotlib 层次结构的底部。Tick是一个小容器，主要存放刻度本身的短线和刻度标签的文本。

正如我们在Axis中看到的，Tick也作为XTick或YTick出现。第一个和第二个表示XTick上下两侧的刻度，而第二个表示YTick左右两侧的刻度。默认情况下，后面的记号不可见。

# tick at 0.5 pi in the previous figure
xmajortick = ax.xaxis.get_major_ticks()[2] 
print('xmajortick', xmajortick)
print('xmajortick.tick1line', xmajortick.tick1line)
print('xmajortick.tick2line', xmajortick.tick2line)
print('xmajortick.gridline', xmajortick.gridline)
print('xmajortick.label1', xmajortick.label1)
print('xmajortick.label2', xmajortick.label2)
print('xmajortick.gridOn', xmajortick.gridOn)
print('xmajortick.tick1On', xmajortick.tick1On)
print('xmajortick.tick2On', xmajortick.tick2On)
print('xmajortick.label1On', xmajortick.label1On)
print('xmajortick.label2On', xmajortick.label2On)

输出:

xmajortick <matplotlib.axis.XTick object at 0x11eec0710>
xmajortick.tick1line Line2D((1.5708,0))
xmajortick.tick2line Line2D()
xmajortick.gridline Line2D((0,0),(0,1))
xmajortick.label1 Text(1.5708,0,'0.5$\\pi$')
xmajortick.label2 Text(0,1,'0.5$\\pi$')
xmajortick.gridOn False
xmajortick.tick1On True
xmajortick.tick2On False
xmajortick.label1On True
xmajortick.label2On False

由于有许多助手方法、Ticker和[Axes.tick_params](https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.tick_params.html)，我们几乎不需要直接处理Tick。

是时候定制你的默认风格了

看一下默认样式的参数列表。
教程>定制 matplotlib >一个示例 matplotlibrc 文件
我想现在你不仅能弄清楚一个参数是干什么的，还能弄清楚一个参数实际上对哪个Artist有影响，这让你为 googling⁷.节省时间您还可以自定义默认样式，而不需要生成 matplotlibrc 文件，只需在代码的开头键入如下内容。

plt.rcParams['lines.linewidth'] = 2

(再次)去看医生

你们中的一些人可能对 matplotlib 的文档有负面的印象。我同意很难从一长串列表中找到适合你的问题的例子。但是自从 2.1⁸.版本以来，它已经有了很大改进如果您比较改进前后的相应页面，这一点很明显。

2 . 1 . 0(2017 年 10 月)画廊、教程、概述
2 . 0 . 2(2017 年 5 月)实例、图库、概述

我推荐看一看最新图库和教程，现在已经很整洁了。

感谢阅读。享受用 matplotlib 绘图(和谷歌搜索) 📈🤗📊

脚注:

是的，如果你没有懒到在使用之前阅读教程的话，教程总是有帮助的。事实上，当我几年前开始用 matplotlib 绘图时，我可能曾经试图阅读过一次关于 Artist 的文档，但我很确定当时我认为“好吧，这不适合我”。(可能不是现在的教程。)
下面是这个图的示例代码https://matplotlib.org/gallery/showcase/anatomy.html
当然还有其他的Artist这一页对于那些想要大图的人来说是一个很好的入口。您可以点击Artist名称获得进一步解释。
从技术上来说，Artist让我们在 matplotlib 的画布上绘制你漂亮的数据。多么可爱的说辞。
fig.legend没有当前版本有用，因为根据版本的文档，它需要图例手柄和标签。2.0.2
当你从“set_***”方法进一步谷歌 tick 相关设置，并放弃为你自己的问题安排它们时，你会经常遇到使用它们的食谱。(没错，就是几个月前的我。)
或者你可以像我一样，利用节省下来的时间深入挖掘。
这里是一个很好的阅读，以了解如何困难，以改善文件。 Matplotlib 引导 Dev 解释为什么他不能修复 Docs | NumFOCUS

原载于 dev.to 。

作为 2019 年的管理者，你将真正需要了解 AI 的哪些方面？

原文：https://towardsdatascience.com/as-a-manager-in-2019-what-will-you-really-need-to-know-about-ai-afb3cb356fd3?source=collection_archive---------26-----------------------

Photo Credits — Tech Crunch

试图预测未来就像试图在没有灯的夜晚开车行驶在乡间小路上，同时从后窗往外看一样——彼得·德鲁克

彼得·德鲁克的漫长职业生涯早于人工智能。在他的一生中，领导力都与人有关，而数据科学则局限于编码机器。他关于管理的开创性论文本质上是关于应用过去的经验来开发当前的市场机会。人工智能可能改变了一切:模糊了人类和机械流程之间的界限，并将管理重点从研究最佳实践转移到影响消费者行为。作为 2019 年的管理者，你真正需要了解的人工智能知识有哪些？

人工智能的商业价值与其降低组织变化成本和/或市场预测成本的潜力相关。今天，“狭义”人工智能应用程序可以比经理更快、更准确地执行计划、组织和预算任务。明天，“广泛的”人工智能应用将提供多任务、多领域的服务，这些服务将动摇公司和市场的基础。在可预见的未来，“通用”人工智能将整合感知和推理的认知能力，这可能会有效地改变我们思考工作的方式。

试图忽视这些简单事实的经理们正有效地行驶在黑暗的道路上，他们的眼睛紧紧盯着过去。普华永道预测，人工智能的实施将消除目前 20%至 40%的就业机会。【1】通过将强化学习、机器人、计算机视觉和自然语言处理交给独立承包商和跨国公司，人工智能应用已经在平整管理领域。无论你是否敢于展望未来，管理都不会是一成不变的。

一个事实仍然可以掩盖另一个事实。客户和股东不是根据事实思考、决定或行动，而是根据对数据的感知。建立愿景、建设社区和激励员工的基本管理活动是人类固有的活动。未来的竞争优势不会来自人工智能的数据或算法，而是来自经理们获得和培养他们商业社区的信任。

管理人员需要发展哪些技能才能利用人工智能？管理人员将不会编写代码，而是定义和评估人工智能在其业务中的方向和采用率。他们需要思考可能会发生什么，并问自己如何用实验来检验这是不是真的。管理人才将越来越多地被定义为与判断相关的技能:指导、激励和采取道德立场。管理层将专注于开发运营流程，以优化专注于判断的员工团队和专注于预测的人工智能代理。

当我们抓住机会在数据科学平台上投入时间和金钱时，我们很可能错过了更大的图景。数据只不过是一组等待管理者提出正确问题的答案。算法可以发现数据中的模式，但无法解释它们的意义。归纳、演绎和绑架仍将是管理决策的核心。如果机器学习旨在寻找数据集中的相似性，有才华的经理将继续关注运营流程中例外(异常值)的重要性。

最后，管理者和数据科学家都不是在真空中运作，而是与他们的同事和客户协同工作。为了让人工智能产生巨大影响，管理者必须创建人工智能数据就绪生态系统。招募具有分析思维的合作者是必须的——正如野田友男教授最近建议的那样，“只有好人才能创造出好的人工智能”【2】一个经理的面包和黄油将来自于创造一个工作环境，在这个环境中，他的同事、商业伙伴和员工使用数据来应对他们的商业挑战。由于最有价值的数据往往在自己组织的边界之外，鼓励负责任地使用客户数据将是他们的首要任务。在可预见的未来，和过去一样，管理人员的表现将不会根据他或她在电脑前做了什么来评估，而是根据他们在同事和客户面前能做出什么来评估。

在我们关于“人工智能管理”的免费网络研讨会上，我们将探讨这些论点，并提供每个论点的真实例子商业分析实践是商业分析学院的核心和灵魂。在我们在巴约纳和波士顿的暑期学校，以及我们在欧洲各地的硕士班中，商业分析研究所专注于数字经济学、管理决策、机器学习和数据故事，将使分析为您和您的组织工作。

Lee Schlenker 是商业分析和社区管理教授，也是 http://baieurope.com 商业分析学院的负责人。他的 LinkedIn 个人资料可以在 www.linkedin.com/in/leeschlenker 的查看。你可以在 https://twitter.com/DSign4Analytics的推特上关注我们

【1】普华永道，(2018)，人工智能和相关技术对工作岗位的净影响会是什么 …

【2】IESE，人工智能改变管理的 10 种方式

当我开始学习数据科学时

原文：https://towardsdatascience.com/as-i-start-learning-data-science-75f84e77cd71?source=collection_archive---------3-----------------------

分享我在开始学习数据分析和机器学习时参加的课程的经验。

Coursera 的吴恩达 ML 课程 —当我搜索可用的 ML 课程时，我发现这个课程是最受推荐和报名的。课程大纲相当广泛，涵盖了大多数的 ML 技术。我发现这门课有点太详细了，讲座幻灯片比动手操作还多。这导致我退学，重新注册，多次退学。所以我把它放在一边，一旦我对事情有了一个可行的理解，我就会重新审视它。
数据分析简介 Udacity — 这是 Udacity 提供的免费课程，也是他们纳米学位项目的一部分。本课程包括使用 Numpy 和 Pandas 进行数据分析。课程内容涵盖了 Numpy 和 Pandas 入门所需的主题。然而，它没有太多的实践例子，也可以感觉到课程运行非常快。
机器学习 Udacity 简介——本课程由 Udacity 的巴斯蒂安·特龙教授。这也是 Udacity 纳米学位项目的一部分。这包括算法，如朴素贝叶斯，SVM，决策树，回归。好的一面是，在进入任何算法的详细工作之前，它给出了一个简单易懂的例子，说明算法到底解决了什么问题。我发现这非常有用，而不是深入理论。然而，它又缺乏足够的练习集。我也觉得课程应该更深入算法，而不是简单地让你学习如何调用某些 sklearn 方法。

4.创建一个精选的课程列表—medium 中有一本好书https://medium . com/@ David venturi/I-dropped-out-of-school-to-create-my-own-data-science-master-s-here-s-my-course-1b 400 DCE 412。我试着跟着课程走。这个列表有非常好的课程，包括数据分析部分和 ML 部分。

DataQuest —我在 DataQuest(dataquest.io)数据科学赛道注册，从 Numpy 和熊猫开始。这种通过编码学习的风格让我着迷，它还提供了一个路线图，而不是在不同的课程之间切换。它提供一些免费课程，然后要求基本/高级订阅。首先，我订阅了每月 29 美元的基本服务。大量的实践和细节是我喜欢的东西，最后我为 ML 订阅了高级订阅(49 美元/月)。订阅还附带项目，提供良好的实践经验。还有一个 slack 社区可以讨论这些话题。

除了上述任何课程，使用 kaggle 数据集真的帮助我理解了如何处理更大的数据。

我学的课程除了吴恩达的 ML 都是用 Python 作为语言的。因为我熟悉这门语言，所以我选择了 Python，这样可以节省我学习语言结构的时间。

希望我的两分钱能帮助别人。

问我任何事——与卡格勒大师弗拉基米尔·伊格洛维科夫的对话

原文：https://towardsdatascience.com/ask-me-anything-session-with-a-kaggle-grandmaster-vladimir-i-iglovikov-942ad6a06acd?source=collection_archive---------0-----------------------

你好，我叫弗拉基米尔。

从大学毕业并获得理论物理学位后，我搬到了硅谷，在行业中寻找数据科学的角色。这让我在 Lyft 的自动驾驶汽车部门找到了目前的职位，从事计算机视觉相关应用的工作。

在过去的几年里，我在机器学习竞赛上投入了大量的时间。一方面，这很有趣，但另一方面，这也是提高数据科学技能的非常有效的方式。我不会说所有的比赛都很容易，我也不会说我在所有的比赛中都取得了好成绩。但时不时我还是能接近巅峰，最终有了 Kaggle 特级大师的称号。

感谢 @Lasteg 提出了这个 AMA(向我提问环节)的想法，并在 Reddit 、 Kaggle 和 science.d3.ru(俄语)上收集问题。有很多问题。我会尽我所能回答这个问题，但是我不可能在这篇博文中回答所有的问题。如果有你问的问题，但在下面的文字中没有提到，就写在评论中，我会尽力回答。

以下是我(或我的团队)有幸在排行榜上名列前茅的深度学习挑战列表。：

第十名:超声波神经分割
第三名: Dstl 卫星影像特征检测
第二名:安全通道:对航拍图像中的车辆进行检测和分类
第 7 名: Kaggle:星球:从太空了解亚马逊
第 1 名: MICCAI 2017:胃肠图像分析(GIANA)
第一名: MICCAI 2017:机器人器械分割
第一名:卡格尔:卡瓦纳图像掩蔽挑战
第 9 名: Kaggle: IEEE 的信号处理学会——相机型号识别
第二名:CVPR 2018 深度地球。道路提取。
第二名:CVPR 2018 深度地球。建筑检测。
第三名:CVPR 2018 深度地球。土地覆盖分类。
第 3 名:MICCAI 2018:胃肠图像分析(GIANA)

问:你有数据之外的生活吗？

是的，我愿意:)

我喜欢背包旅行和攀岩。如果你早上在使命悬崖攀岩馆攀岩，下次见到我的时候，你可以打个招呼。

我也喜欢伙伴舞蹈，尤其是蓝调融合。旧金山的使命融合和南湾融合舞蹈场馆是我通常去的地方。

旅行对我来说也很重要。今年春天，我去了白俄罗斯、摩洛哥和约旦。九月，我在芬兰、德国和奥地利呆了三周。当然，燃烧的人 2018 是今年最好的体验:)

问:身高/体重？

6 英尺，185 磅

我想这个问题可能与锻炼有关，所以让我在《力量举重》中展示一些我在研究生院时的结果:)

最大钳工 225 lb ( 102 kg)
最大下蹲 315 lb ( 142 kg)
最大硬拉 405 lb ( 183 kg)

问:怎样才能既有事业又全职做 kaggle？

为 Kaggle 比赛工作是第二份无薪全职工作。你应该有一个很好的理由这样做。对于积极的 Kaggle 参与者来说，寻求改变领域是很常见的。我也不例外。当我从学术界过渡到工业界时，我开始从事竞赛工作。我需要一种有效的方式来适应 ML 可能解决的问题，掌握工具，并将我的思维方式扩展到机器学习的新世界。

后来，我在biggely找到第一份工作后，我更加沉迷于 Kaggle。白天我从事信号处理工作，几乎所有晚上都在与表格数据的竞赛中度过。我的工作与生活的平衡不是很好，但我在单位时间内获得的知识量是值得的。

在某个时候，我准备好了，换了工作，加入了 TrueAccord，在那里我做了很多传统的 ML 工作。但是停止我的工作是不明智的。所以白天是传统的机器学习，晚上和周末是深度学习。工作与生活的平衡甚至更糟，但我学到了很多东西，并且作为获得的技能的一个很好的补充，成为了 Kaggle Master 。当我能够在 Lyft 获得一份 Level5 的工作时，所有这些努力都得到了回报，这是一份将深度学习技术应用于自动驾驶问题的工作。

最后，我没有全职在 Kaggle 上工作。但我还是在积极学习。工作中有很多令人兴奋的计算机视觉问题，我正试图在 Kaggle 没有涉及的领域获得更多的知识。我仍然不时地向各种比赛提交材料，但这主要是为了更好地了解参与者面临的问题和挑战，这反过来有助于从论坛上分享的信息中获得最多的信息。

问:帮助你提高效率的日常惯例是什么？你如何安排你的一天？

首先，我不确定我是否很有效率。:)我一直在寻找新的方法来优化我的日常工作。

总是有更多的问题需要解决，有更多的活动需要去做。并不是所有的都同样有用和令人愉快。这意味着我总是需要为每一个行动设定优先级。有几本书对这个话题进行了精彩的讨论。我推荐每个想变得更有效率的人去阅读它们:

好到他们无法忽视你:为什么在寻找你热爱的工作时，技能胜过激情深度工作:在纷乱的世界中专注成功的法则。

在工作日，我早上 6 点起床，去攀岩馆。这有助于我保持身材，让我在接下来的一天里保持清醒。在这之后，我开车去上班。我们的自动驾驶工程中心位于帕洛阿尔托，这让我有点难过。我更喜欢住在城市。开车很有趣，但通勤就不是了。为了更有效率地度过通勤时间，我在车里听有声读物。我不会说我可以在通勤时非常专注于这本书，但有大量的文学作品，大多是软技能或商业导向的，这对开车很好。

我想说我有一个很好的工作生活平衡，但这不是真的。当然，相当多的时间是和朋友一起度过的，而且是在不同的场合。幸运的是，旧金山一直在发生一些事情。同时，我还需要学习；关于机器学习，我仍然需要保持身材。不仅仅是我在办公室的问题，而是更广泛的问题。这意味着晚上要花一些时间阅读技术文献，为竞赛、兼职项目或开源项目编写代码。

说到开源项目，我将借此机会推广一个图像增强库，它是由 Alexander Buslaev 、 Alex Parinov 、 Eugene Khvedchenia 和 I 基于我们在计算机视觉挑战工作中获得的见解而创建的。

如果不提供具体的技巧，我想我无法完成这个问题:)

比起 MacBook 我更喜欢 Ubuntu + i3 ，主观上对我的性能+ 10%。
我很少使用 Jupyter 笔记本。仅用于 EDA 和可视化。我写的几乎所有代码都是用 PyCharm 写的，用 flake8 检查，然后提交给 GitHub。很多 ML 的问题都很相似。投资于更好的代码库，尽量不重复自己，思考如何最好地重构可能会在开始时减慢进度，但在后来会加快速度。
我尽可能地编写单元测试。每个人都在谈论单元测试在数据科学中的重要性，但是并不是每个人都花时间去写它们。Alex Parinov 写了一篇很好的文档，指导你如何从简单到复杂。你可以试着跟随它，给你的学术界或 Kaggle ML 管道增加更多的测试。我想你已经在工作中这样做了。
目前，我正在试验模型版本控制工具 DVC ，我希望它能让我的 ML 管道生成的结果更具可复制性，代码更具可重用性。
我尽量少用鼠标。有时候这意味着我需要把热键写在纸上，放在我面前，尽可能多地使用它们。
我不使用社交网络。
我一天只检查几次电子邮件。
每天早上我都会列出今天要完成的任务，并努力完成这些任务。我用特雷罗来做这个。
我试着不把我的一天分割得太多。许多任务需要集中注意力，一直转换焦点是没有帮助的。

所有这些想法都很标准，但我想不起口袋里有什么魔术。😃

问:你如何跟上该领域的最新研究？

我不会说我知道。如今的 ML 领域是如此的活跃，论文、竞赛、博客文章和书籍的数量是如此的巨大，以至于浏览它们都是不可能的。在实践中，当我面临一些问题时，我会专注于浏览最近的结果，并深入挖掘。做完这个问题后，我会切换到下一个问题。因此，我只对自己没有实践经验的领域有高水平的了解，而且我对此没有意见。与此同时，我所处理过的问题清单，也就是我所精通的问题清单，相对来说是很大的，而且这个清单还在继续增长。这个事实让我确信，我已经编写并保存在私有存储库中的经验和代码的组合将帮助我快速开始任何新的 ML 相关任务。

此外，这意味着对于许多问题，我已经实现了非常强大的管道，这给了我一个温暖的开始，当我下次面临类似的问题时。

我也参加像 NIPS，CVPR 和其他会议。那里展示的结果很好地代表了在目前的研究阶段我们能做什么和不能做什么。

问:回到过去(比如 4-5 年前),在非 ML 特定领域(物理、力学等)拥有博士学位。)对雇主非常有利。目前，我觉得情况发生了变化，如果比较非 ML 领域的博士和 ML 领域的硕士，IT/ML 行业似乎更喜欢 ML 工程/开发人员的角色，但我不确定研究角色。既然你也是物理学博士，然后转到 ML，我想以你现在的经历你可能知道问题的答案。

如果一个人想在获得非 ML 博士学位后转入 ML 行业，你对此有什么看法？在公司获得研究职位会有帮助吗？与相关的理学硕士相比，在传销行业找工作有帮助吗？

这是一个很难回答的问题，我不知道答案，所以我只能自言自语。

物理是一个很棒的专业。即使我可以回到过去，在物理和计算机科学之间做出选择，即使我知道最终我会转到计算机科学，我还是会选择物理。

当然，主要原因是我对物理学和一般的自然科学感到兴奋。ML 教你我们周围这个巨大的、丰富多彩的、令人兴奋的宇宙是如何工作的吗？不完全是。但是物理有。而且不仅仅是这个。从物理学转到 ML 相对顺利的原因之一是，作为一个专业，物理学不仅给了我量子力学、相对论、量子场论和其他高度专业化主题的知识，还给了我数学、统计、编码方面的关键技能，所有这些都可以很容易地转移到其他领域。

物理学教你如何以结构化的方式在严格的理论和实验之间周旋；任何 ML 从业者的必备技能。而且不上大学，靠自学，学物理或高等数学几乎是不可能的。在这方面，我坚信，当我们找到如何将为物理、化学和其他高级领域开发的高级数学应用于机器学习时，深度学习的下一个重大突破将会发生。现在，在大学一年级的水平上了解数学就足以解决计算机视觉中的问题。

所有这一切意味着，目前数学不是一个阻碍因素，这就是为什么一个人在数学/物理/化学和其他 STEM 部门获得的额外知识对于解决大多数商业问题几乎毫无用处，这就是为什么这些部门的许多毕业生感到被背叛了。他们有很多专业知识；他们有博士学位，他们在学术界呆了很多年。他们不能得到一份有趣的高薪工作。互联网上充斥着这种类型的博客帖子。

另一方面，能够编写代码在任何地方都是必不可少的，这就是为什么当潜在雇主在一个精通数学的人和一个擅长编写代码的人之间进行选择时，后者几乎总是会胜出。

但我相信会改变的。不是现在，而是将来的某个时候。

值得注意的是，你在大学里阅读的论文和参加的课程可能与你在这个行业需要的技能没有直接关系。这是真的，但我不认为这有什么大不了的。

通常情况下，作为一名数据科学家或软件开发人员，你需要知道的事情，你可以自学，或者你无论如何都无法在大学里学习。人们在这个行业学到的大部分东西只有在你在某个公司的全职工作中才能获得。

与此同时，在研究数据科学的同时，我一边写理论物理论文，一边试图在行业中找到一份工作，这让我感到压力很大。

我不具备所有必需的知识；我不明白硅谷是怎么做事的，也不知道对我有什么期望。我有接近零的网络，我唯一尝试做的事情就是向不同的公司发送我的简历，一次又一次，一次又一次地面试失败，从每一次失败中学习，并重复它，直到它以某种方式工作。

我记得有一次有人问我在做什么论文？我在做量子蒙特卡罗，我告诉面试官这个。之后，我试图解释这意味着什么，为什么我们需要它。面试官看着我问道:“这项技术如何帮助我们提高顾客的参与度？”

我认为对于那些非计算机科学专业的学生来说，最有希望的方法是参加计算机科学系的 DS 相关课程。空闲时间学习 DS / ML。幸运的是，这方面有很多很好的资源。我会说，在你的系里找一个对应用 ML 解决他或她的问题感兴趣的教授是个好主意。在科技公司申请与 ML 相关的实习，并以研究生身份获得实习机会比获得全职工作更容易。

实习结束后找一份全职工作非常简单。例如，我的朋友胡(T1)就是这样做的，他也在我们的研究小组学习物理，他在人工智能研究所获得了一个研究科学家的职位。

一般来说，过高估计你的专业、大学等的影响力是不明智的。为了在行业内找工作。当一家公司雇佣你时，他们打算付给你钱来解决他们面临的问题。你的学位和专业只是评估你能力的一个代理。当然，如果简历中没有他们希望看到的内容，通过简历筛选阶段是很难的，你的人际关系网(这对于求职来说是必不可少的)也会变弱，但同样，这不应该影响你选择专业的决定。

我可能听起来很天真，但一个人应该选择专业，不是因为他/她相信它会带来好的薪水，而是因为你对它充满热情。

问:你认为目前数据科学/ML 中有趣的问题在哪里？我已经完成了大约 50%的硕士课程，但不确定我想在 ML 的哪个部门工作。我和一个人谈过，他断言两个最好的领域是算法创建和扩展(与 DS/ML 应用相反，后者可能更多的是库插入和突突)。你对此有什么想法？/职业弹性方面有什么推荐。

我要说的是，DS/ML 中有趣的问题与当今的主流相去甚远。主流问题拥挤。将 ML 应用于信用评分、推荐系统、零售和其他我们知道如何将数据转化为金钱的学科是很无聊的。但是，如果你将 DS/ML 应用于数学、物理、生物、化学、历史、考古、地质或任何其他人们没有那么尝试应用 ML 的领域中未解决的问题，你可能会找到你的下一个紫牛。

关于职业选择。与生物学或物理学不同，你在 DS/ML 中学到的技能更容易从一个领域转移到另一个领域。当然，在一些银行或对冲基金开发交易算法与在无人驾驶汽车上工作是不同的，但区别并不是那么大，只要你的基本面良好，你就能很快掌握必要的技能。

问:30 岁加入有背景的 ML 社区，而不是数学/CS，是不是太晚了？或者有可能赶上末班车？如果是，你认为最低要求是什么？

当然，现在还不算太晚。90%的 ML 需要理工大学大一水平的数学知识，所以不需要超深的数学知识。而且 DS 中使用最广泛的语言是 a python 和 R，级别很高，可以开始使用，不会死在技术细节上。

我建议参加一些 DS 的在线课程，并开始在 Kaggle 上解决问题。当然，许多概念听起来会很新，但你只需要有一些纪律和奉献精神，一切都会到来。

还有两个与年龄有关的例子:

Kaggle 大师 Evgeny Patekha 在四十岁时开始了他的数据科学之旅。
Kaggle 特级大师亚历山大·拉科在 55 岁时加入了 Kaggle。

问:您认为技术领域的正规基础教育对于在数据科学和 Kaggle 竞赛中取得成功至关重要吗？在你的工作经历中有相反的例子吗？****

有帮助是的。基本没有。在 Kaggle，有很多取得巨大成就的人没有接受过技术领域的基础教育。最典型的例子是米克尔·波贝尔-伊里扎尔，他是卡格尔特级大师，但仍在高中学习。

另一件事是，你需要记住，你在 Kaggle 学到的技能只是你在工业界或学术界从事 ML 工作时所需技能的一小部分。对于那些卡格尔没有开发的技能，技术领域的基础教育可能是至关重要的。

但是还是那句话。没有高中文凭也能擅长 Kaggle。

问:你花了多长时间学习数据科学/ML，以达到在 Kaggle 中有竞争力的水平？

2015 年 1 月决定转行数据科学。在这之后，我开始在 Coursera 上在线课程。2 月底，我了解了 Kaggle，并在那里注册了。两个月后，我获得了我的第一枚银牌。

问:在没有云的情况下，用一台简单的家用电脑能获得很高的 kaggle 结果吗？

我不在比赛中使用云。但是我家里有两台比较强大的电脑。一个有四个 GPU，另一个有两个。在 kaggle 上，没有一台非常强大的机器，你也可以得到很好的结果，但是缺乏计算能力会限制你在单位时间内可以检查多少个想法。你检查的这些想法的数量与你的结果密切相关。所以，如果你正在全天候训练模特，你应该投资一台好的台式机。

经过几次迭代，我最终得到了下面的 dev box，它有四个 GPU 用于繁重的工作，一个桌面有两个 GPU 用于原型开发。

同时，拥有强大的机器是不够的。您需要能够编写能够利用它的代码。

我从 Keras 转到 Pytorch 的原因之一是因为当时 PyTorch 中的 DataLoader 要优越得多。
我们写albuminations是因为 imgaug 太慢了，我们得到了 100%的 CPU 利用率，而 GPU 没有得到充分利用。
为了加速来自磁盘的 jpeg 图像 I/O，不应该使用 PIL 、 skimage、甚至 OpenCV ，而应该寻找 libjpeg-turbo 或 PyVips 。

等等。

问:他能就从哪里开始与 Kaggle 合作向刚起步的数据科学家志向者提供一些建议吗？给第一次参加比赛的新手的最好建议？

有很多方法可以进入 Kaggle，但根据我的观察，获得所需知识的最有效方法之一是使用黑客的方法。

观看一些涵盖 python 编程和机器学习基础的在线课程。
在卡格尔选一场比赛。如果您可以编写一个 end2end 管道，将数据映射到提交，那就太好了。如果你是新人，可能会比较难。在这种情况下，去论坛复制粘贴别人分享的内核。
在您的电脑上运行，生成提交内容，并出现在排行榜上。在这一步，你很可能会感受到操作系统、驱动程序、库版本、I/O 问题等带来的痛苦。尽早开始习惯它是很重要的。如果您不知道内核中发生了什么，那也没关系。
调整一些参数，盲目地做是可以的，重新训练你的模型，提交你的预测。希望你的一些修改能让你在排行榜上有所上升。不要担心，你周围成百上千的人也在做同样的事情。他们正在调整不同的旋钮，这些旋钮是他们在没有深入的知识或直觉的情况下也能触及的。
为了超越那些盲目调整参数的人，你需要开始发展直觉，获得关于什么可行什么不可行的基本知识，这样你就可以更智能、更有效地探索可能方法的相空间。在这一步，你需要在你的实验中加入学习。你需要从两个方向学习。第一—基础，像 mlcourse.ai 、 CS231n 这样的课，看书，学习数学，统计，如何写出更好的代码等等。通常，很难让自己做到这一点，但从长远来看，这是至关重要的。其次，你会在论坛上看到大量与你试图解决的问题相关的新术语。关注他们。试着把你在排行榜上变得更好的渴望作为学习新事物的额外动力。但是不要在研究和试验管道之间选择——两者同时进行。机器学习是一门应用学科，你不希望你的知识变成纯粹的书本知识。没有实践的理论是愚蠢的。没有理论的实践是盲目的。
比赛结束后，尽管你尽了最大努力，你很可能会发现自己在排行榜上排名很低。这是意料之中的。仔细阅读论坛，阅读获胜者分享的解决方案，尝试了解您可以做得更好的地方。下次你再看到类似问题的时候，你的起点会高很多。
在许多比赛中重复这个过程，你就会到达顶峰。更重要的是，你将拥有处理许多问题的良好渠道，以及如何处理你在竞争、工作或学术界面临的机器学习挑战的良好直觉。

问:作为一个物理学出身的人，当竞赛更多地是一种过度适应的练习，而不是特定任务的实际概括时，你是否有时会感到沮丧？假设如此，你如何应对？

通常，您需要对数据和指标进行过度拟合，以获得良好的结果。这很好，这是意料之中的。人们在 ImageNet 数据集上过度适应了这么多年，新的知识仍在这个过程中产生。但是要做到这一点，你需要理解指标和数据的细微差别。这就是知识的来源。只要新知识是在挑战期间创造出来的，我就不介意过度适应。正如你可能注意到的，在一个问题上擅长的管道和想法成为下一个问题的可靠基线，这说明了一些普遍性。

问:你对 Kaggle，例如桑坦德银行、飞艇预测和谷歌分析的数据泄露有什么看法？在 Kaggle 比赛中使用数据泄露是否道德？

我承认组织比赛是非常困难的，所以当漏洞被发现时，我不会责怪组织者。当人们利用漏洞时，我也没事。我必须承认，泄密使我不愿意参加挑战，但这主要是因为我不能那么容易地将获得的知识推广给其他被挑战的人。我仍然认为 Kaggle 管理员需要创建一个可能的数据泄漏清单，并在挑战前检查数据，以防止同样的问题一再发生，但我相信他们正在努力。

问:作为一名设计工程师，Kaggle 竞赛对商业/工作有多大用处？？

很难说。Kaggle 在一些关键但非常狭窄的领域提升你的技能。这是一项重要的技能，对一些职位来说，它可能非常有益，而对另一些职位来说则不然。对于我从事的所有工作，尤其是现在我从事自动驾驶工作时，Kaggle 技能是我从学术界和其他知识来源获得的一套技能的强大补充。

但同样，拥有 Kaggle 技能，即使他们是坚实的也是不够的。很多东西只有在行业里才能学到。

成为一名 Kaggle 大师并不必要，也不足以胜任你的工作，但同时，我相信，如果一个人是 Kaggle 大师，那么通过 HR 的简历筛选阶段并邀请一个人到技术屏幕上就足够了。

问:成为特级大师后，参加卡格尔比赛有多大用处？当你已经是一名有成就的数据科学家时，你做 Kaggle 的动机是什么？

正如我提到的，我已经不怎么参加 Kaggle 比赛了，但我开始关注与不同会议相关的比赛。我的团队在 2017 年 MICCAI、2018 年 CVPR 和 2018 年 MICCAI 取得了好成绩。竞争通常包括漂亮、干净的数据集，只需要最少的数据清理，并允许您更少地关注数据，而更多地关注数字技术。这是您在工作中通常没有的奢侈，在工作中，数据选择过程通常是创建有用管道的最重要的组成部分。

问:从你的学习和竞争经历中，你对本科生和研究生有什么建议？要掌握数据科学，必须树立哪些里程碑？

我甚至不知道数据科学中的精通是什么。有很多方法可以回答这个问题。但是在这次 AMA 中，我是以一个卡格大师的身份说的，所以让我们说你的第一个里程碑应该是成为卡格大师。这相对来说比较简单，但是当你在做的时候，你会对你在这个领域想要什么有一个更好的认识。

问:如果没有数学/计算机科学或其他一些高度计算学科的教育背景，你能在 Kaggle(以及更广泛的数据科学领域)上走多远？相反，激情和学习的欲望能让你走多远？

如果你有目标并且愿意学习，你可以在 Kaggle 或任何其他数据科学领域达到顶峰。最难的一步是第一步。去做吧。最好的时间就是现在，今天，因为明天，通常意味着永远不会。

没有人问我，你如何找到能帮助你在特定比赛中取得更好成绩的人？我认为这是一个我没有在博客文章中看到过的重要话题。

最常见的方法是:一些朋友或同事对比赛感到兴奋，他们谈论比赛，开会，讨论问题，组成一个团队。有些人试图做某事；其他人忙于其他活动。这个团队取得了一些进展，但通常不会那么远。

对我和其他参与者都有效的更好的方法是:

你写你的管道或者重构在论坛上分享的管道。
这个管道应该以适当的格式将输入数据映射到提交，并生成交叉验证分数。
您验证了您的交叉验证分数的提高与排行榜上的提高相关。
你进行探索性的数据分析，你通过论坛仔细阅读，你阅读与你所做的类似的论文、书籍、以前比赛的解决方案。你完全靠自己工作。
在某个时候，比如说在结束前的 2-4 周，你会被卡住。这些想法都不会提高你的地位。你什么都试过了。你需要一个新的想法来源。
此时，你看着你周围的排行榜，并与具有类似地位的积极参与者交流。
首先，你的预测的纯平均值会给你一个很小但很重要的推动。第二，很有可能你的方法有点不同，分享一系列尝试过或没尝试过的想法是有益的。第三，因为比赛最初是为每个人单独进行的，所以你们所有人都查看了数据，所有人都写了管道，所有人都将比赛置于其他活动之上，所有人都被实时排行榜创造的游戏化效果所激励。

但更重要的是，人们往往会高估他们愿意花在挑战上的空闲时间，并低估他们在拥有稳定的端到端管道之前将面临的问题数量。通过排行榜创建团队可以作为一个过滤器，确保你的潜在队友和你在同一页上。

在一些比赛中，领域知识对于取得好成绩非常重要。例如，表格数据和相应的特征工程或医学成像，在这种情况下，您可以考虑与具有深厚领域知识的人组成一个团队，即使他/她没有强大的 DS 背景，但这种情况相当罕见。

同时，行业内团队组建的方式也完全不同。使用 Kaggle 的方法在工业环境中组建团队是不明智的。

我要感谢我有幸成为队友的所有人，他们在我参加的所有比赛中教会了我很多东西:

阿尔特姆·萨纳克乌，亚历山大·布斯拉耶夫，谢尔盖·穆辛斯基，叶夫根尼·日比茨基，康斯坦丁·洛普欣，阿列克谢·诺斯科夫，阿图尔·库津，鲁斯兰·拜库洛夫，帕维尔·内斯特罗夫，阿尔谢尼·克拉夫琴科

这些人我大多是通过 ODS 认识的。AI 。混乱办。AI 是一个精英管理的俄语数据科学社区。如果你会说俄语，并且想在 Kaggle 做得更好，加入它是一个好主意。

全球 Kaggle 评级前 100 名中的 20+已经在那里了！

如果你的问题没有得到答案:请随意写在评论里，我保证你会得到答案的。

下次 Kaggle 比赛再见！

卡格尔
谷歌学术
领英
推特

在家里组装一台惊人的深度学习机器，价格不到 1500 美元

原文：https://towardsdatascience.com/assemble-an-amazing-deep-learning-machine-at-home-for-less-than-1-500-ef046d21b179?source=collection_archive---------1-----------------------

在过去的一年半时间里，我一直在为各种客户探索深度学习和机器学习的应用。当我们使用云计算资源建立这些解决方案时，我觉得有必要在企业环境之外实践我的技能。当然，只要我想学习，我可以继续使用亚马逊来构建一些 GPU 驱动的 EC2 实例……但要真正深入到深度学习的世界中，我觉得我必须做两件事 1)给自己一条探索的道路，以自己的速度和自己的设备。2)通过投资一些迫使我使其工作的设备或失去我对自己的大投资，在游戏中加入一些皮肤。

简而言之，我渴望建造自己的高性能机器，我可以在任何需要的时候使用它，此外，它还可以作为一台非常好的家用电脑，用于偶尔的家庭计算任务。(至少，这是我的辩解。)

这篇博文证明了你也可以建造一台深度学习机器，它非常能够处理各种深度学习任务。我将介绍从组件到组装和设置的所有内容。

让我们开始吧。

挑选组件

我不得不承认，我被所有的选择吓到了。令人欣慰的是，对于为深度学习计算机选择正确的组件，有一些非常有用的资源。PC Part Picker 帮助我了解需要什么，以及是否有任何兼容性问题。

注意:如果你不喜欢修改，请不要选择我的版本。我不得不对散热器做一些特殊的修改，以适应它的位置。这包括在我的圆锯上用金属切割刀片切割散热片。谢天谢地，我准备了工具来进行调整。

这是我完整的零件清单:【https://pcpartpicker.com/list/ZKPxqk

主板——125 美元

对于主板，我需要的只是支持一个 GPU，并确保它可以支持英特尔的最新芯片(Kaby Lake-i5–7600k。)Gigabyte-GA-B250N-Phoenix WIFI 迷你 ITX LGA1151 主板符合要求，它内置了 WIFI 和一个非常酷的 LED 功能——所以你仍然可以给你的游戏朋友留下深刻印象。

案例——90 美元

机箱不贵，但大小很重要，因为我们要添加一些非常大的组件。请确保您选择的机箱能够适合您的所有组件，并且能够容纳迷你 ITX 外形。我去的案例，Corsair-Air 240 MicroATX Mid Tower Case，有很多粉丝，布局对我的身材来说相当不错。

中央处理器——230 美元

我们的神经网络将使用 GPU 来完成大部分繁重的计算。事实上，CPU 可能是事后才想到的。不幸的是，我是一个非常“保守”的人，想要一个非常重要的处理器。英特尔酷睿 i5 7600k 3.8 GHz 四核处理器符合我的要求。首先，它超频了，所以我觉得自己像个坏蛋。你可以随意降级，但是如果你降级的话…确保你的主板支持你选择的任何处理器。到目前为止，这款处理器的表现符合预期。令人惊讶的是。

拉姆——155 美元

RAM 很便宜。得到很多。尽可能多的获取。我从未对我为电脑购买的任何 RAM 升级失望过。在我的例子中，我购买了一个巨大的 16GB 内存。我的选择，海盗船—复仇 LED 16GB(2 x 8GB)DDR 4–3200 内存还附带了额外的 LED……因为你永远无法获得足够的灯光表演！

散热器——45 美元

这是我最大的遗憾。我买的散热片，冷却器大师——双子座 M4 58.4 CFM 套筒轴承 CPU 冷却器棒极了。就是不合适。我不得不切掉边缘的鱼鳍，为我巨大的公羊腾出空间。如果我必须再做一次，我可能会找到一个更好的散热器，完全适合我的身材。我所做的修改是最新的，风扇非常安静。所以我不会抱怨太多。

存储——50 美元

好吧，说实话，1TB 太大了。但是 Imagenet 也很庞大。如果你能负担得起更多的存储空间，那就去吧，因为当你开始下载数据集时，你就会开始耗尽空间。我选择了西部数据——蓝色 1TB 3.5”5400 rpm 内置硬盘。它在 SATA 接口中提供了 1TB 的存储空间——这对于深度学习来说很好。如果你想升级，考虑更大的 SATA 硬盘或更快的固态硬盘。事后看来，我可能会添加第二个 SATA 硬盘。我建议您从一开始就升级存储空间。我在考虑最终得到 2-3 TB。

电源——85 美元

我用我的电源走了极端，但它相对便宜，我真的不希望它成为一个问题。我的Cooler Master——650 w 80+青铜认证的半模块化 ATX 电源可以为一艘小型潜艇供电，我的 PC 不会有任何问题。

GPU——700 美元

这是你系统中最大的投资，所以为什么要节省。GPU 将为你所有的深度学习处理提供动力。在选择 GPU 时，有许多事情需要考虑，我们一会儿就会谈到这些，但你需要做的一件事是购买 Nvidia 卡。英伟达在支持深度学习加速计算上投入了大量的时间和投资。他们的并行计算平台 CUDA 几乎得到了包括 Tensorflow、Pytorch、Caffe 等所有深度学习框架的支持。

我们知道我们正在选择 Nvidia 卡，我们还应该考虑什么…

预算:我卡上的预算不到 1000 美元。有许多符合要求的卡片，包括 GTX 1080 Ti，GTX 1080，GTX 1070 等等。所以我有很多潜在的卡片可以选择。唯一的牌是泰坦 X 和即将发布的 Volta。

一个与多个 GPU:由于我选择的 PC 的外形因素，我只使用了一个 GPU。我还打算用这台机器在表面层面探索深度学习。对于我的大多数用例，我实际上不需要一个以上的 GPU。另外，围绕两张卡片设计一个模型似乎是一件痛苦的事情。我现在就保持简单。

内存: Tim Dettmers 建议 8GB 的 RAM 对于大多数家庭深度学习项目来说已经足够了。我听起来也很合理。由于大多数 10 系列卡将工作。对我来说，11GB 的 GTX 1080 Ti 已经足够了。

总而言之，我选择了亚马逊上售价 699 美元的 Nvidia 1080 Ti。有点贵，但值得在单个 GPU 设置中获得我想要的功能。

电脑总成本为 1，475 美元。

当然，你需要一台显示器、键盘和鼠标来使用这台机器。

电脑版本

如果你真的对计算机构建感到不舒服，把这个部分外包给专业人士！我觉得自己很勤奋，所以我去了。除了一个修改(见上面零件列表的散热器部分)，构建非常简单。我花了几个小时，按照主板和其他组件附带的手册进行操作。我还咨询了各种各样的留言板，以解决我在这个过程中犯的一些人为错误。

根据我的经验，最好的办法是把机器放在机箱外面，然后测试各个部件。一旦经过测试，一切正常，就可以安装到机箱中了。

软件设置

现在我们的电脑已经准备好了，是时候设置我们的软件了，这样我们就可以深入学习了。对于我们的系统，我选择了 Ubuntu 16.04——它有很好的文档记录；我们使用的许多库都在 Linux 环境下工作。

1。安装 Ubuntu 16.04 —桌面

我选择的 Linux 版本是 Ubuntu，16.04 版本是迄今为止最新的稳定版本。你可以在这里下载 Ubuntu 16.04 桌面:https://www.ubuntu.com/download/desktop

我从 USB 驱动器安装了操作系统。我把它设置成直接引导到 GUI 中；但是启动到终端来安装 CUDA 和 GPU 驱动程序可能会更好。安装完成后，继续使用 apt-get 更新您的操作系统。

sudo add-apt-repository PPA:graphics-drivers/PPA #安装图形存储库以启用 nvidia-381

sudo apt-get 更新

sudo apt-get-assume-yes 升级

sudo apt-get-assume-yes 安装 tmux build-essential gcc g++ make binutils

sudo apt-get-assume-yes 安装软件-properties-common 【T36

2。安装 CUDA(不带驱动程序)

现在是时候安装一些技术来帮助利用我们的 GPU 进行深度学习了。我们的第一步是安装 CUDA。你可以用驱动程序安装它，但我遇到了与 1080Ti 兼容的问题——因为 CUDA 没有配备最新的驱动程序。就我而言，我是从*安装的。通过直接从 Nvidia 下载来运行文件。

https://developer.nvidia.com/cuda-downloads

运行 sudo 服务灯 dm 停止

关闭 lightdm 并运行 CUDA *。在终端中运行文件。记住，不要安装 CUDA 自带的 Nvidia 驱动。

安装之后，您需要将下面几行代码添加到 PATH 中。您可以简单地运行以下代码:

猫> > ~ ~/。tmp << ‘EOF’
导出路径=/usr/local/cuda-8.0/bin $ { PATH:+:$ { PATH } }
导出 LD _ LIBRARY _ PATH =/usr/local/cuda-8.0/lib 64
$ { LD _ LIBRARY _ PATH:+:$ { LD _ LIBRARY _ PATH } }
EOF
source ~/。bashrc

3。安装支持您的 GPU 的 Nvidia 驱动程序。

在我的例子中，它是 Nvidia 381.22 驱动程序——发布时 1080Ti 的最新驱动程序。

wgethttp://us . download . NVIDIA . com/XFree86/Linux-x86 _ 64/381.22/NVIDIA-Linux-x86 _ 64-381.22 . run
sudo sh NVIDIA-Linux-x86 _ 64–381.22 . run
sudo 重新启动

或者，你可以通过 apt-get 下载并安装 nvidia-381(见下文。)

sudo apt-get 安装 nvidia-381

4。可选:登录循环

如果您遇到可怕的登录循环，您可以通过运行以下代码清除 nvidia 驱动程序并重新安装。我不得不这样做了几次，安装最终坚持。

sudo apt-get remove-purge NVIDIA *
sudo apt-get auto remove
sudo reboot

5。检查 CUDA 和 Nvidia 驱动程序安装

运行下面几行代码来检查您当前的安装。

nvcc 版本# CUDA 检查
nvidia-smi #驱动程序检查

6。一切都好吗？很好，该安装 CuDNN 了。

要安装 CuDNN，你需要是一个搭载 Nvidia 开发者的卡。别担心，报名很容易，而且是免费的。对我来说，转机是瞬间的；但是您的帐户可能需要 48 小时才能得到确认。YMMV。一旦你有了一个帐号，下载并安装 CuDNN 到你的 CUDA 目录中。我的例子如下:

tar tar-xzf cud nn-8.0-Linux-x64-v 5.1 . tgz
CD cuda
sudo CP lib 64//usr/local/cuda/lib 64/
sudo CP include//usr/local/cuda/include/

7。你的深度学习环境和工具。

安装的其余部分涉及 Tensorflow、Pytorch、Keras、Python、Conda 以及您想要用于深度学习实验的任何其他工具。我将把这个设置留给你，但只要记住如果你使用 Tensorflow 下载该软件的 GPU 版本。我的机器运行以下程序:

python 2.7(Ubuntu 自带)

面向 Python 2.7 和 GPU 的 tensor flow—https://www.tensorflow.org/install/install_linux

py torch—http://pytorch.org/

OpenCV—http://opencv.org/

让我们看看它的实际效果吧！

好吧，我花了 1500 美元在一台 PC 上做深度学习问题的实验。这台机器能做什么？这里有一些有趣的例子，我可以在我的新电脑上演示。

MNIST 解决方案在几秒钟内。

我想通过培训 PyTorch 的一个已知的 MNIST 解决方案来尝试一下。https://github.com/pytorch/examples/tree/master/mnist这里有一个在我的个人电脑上训练的视频，大约 45 秒，准确率 98%。

IMAGENET 培训。

我想尝试另一个 CNN 来解决 Tensorflow 上的 Imagenet 问题。我训练了来自https://github . com/tensor flow/models/tree/master/tutorials/image/Imagenet的 Imagenet 分类器，训练结束后，我对我的好友乔纳森(Jonathan)在佛罗里达群岛的一个沉船地点潜水的图像进行了分类。

最后一个例子:YOLO 实时物体识别

最后，我想通过让 GPU 从我的网络摄像头实时识别对象来真正测试 GPU 的能力。这是我对我的机器的能力感到非常兴奋的视频。

接下来是什么？

现在我家里有了相当惊人的深度学习能力，我计划了很多实验。我的下一个项目涉及更多的计算机视觉应用。我甚至会为我妈妈的生日做一个分类器。她正在寻找一个应用程序来帮助她对院子里的植物进行分类。没问题，妈妈。我掩护你。

组装入门级高频交易(HFT)系统

原文：https://towardsdatascience.com/assembling-an-entry-level-high-frequency-trading-hft-system-e7538545b2a9?source=collection_archive---------4-----------------------

在过去的几个月里，我花了很多时间来构建和组装自己的加密货币入门级 HFT 系统。由于我已经研究机器学习应用于金融很长一段时间了，并试图找出在现实世界中如何工作，我决定真正进入兔子洞。我这样做是为了提供信息，因为互联网上没有太多的资源。我希望告诉你一些你在尝试类似的事情时可能会遇到的陷阱。我将努力使它变得有趣(和富有哲理)，同时深入研究。希望你喜欢。

介绍

让我们从这个问题开始:

高频交易系统的基本原理是什么？

要建立一个 HFT 系统，你必须假设“市场无效率”是正确的。因为每个人都在同时关注市场，所以会有一群人发现这些低效之处(例如使用统计数据)并试图弥补它们。这意味着你等待的时间越长，你在效率低下被纠正之前发现的可能性就越低。不同的时间窗口有不同类型的低效率，也就是说，你看到的时间范围越小，低效率就越容易预测，你将面临更多的竞争(假设你无法发现没有人看到的低效率，因为我从未实现过这一点，所以我不能谈论它)。

为什么要为加密货币建立一个 HFT 系统？

在我看来，标准资产市场相当糟糕。为什么？如果你试图作为一个单独的个体获得市场数据的原始实时访问，你会发现这很难(没有人会免费给你，如果他们这样做，我可以向你保证，你将与比你有更好访问权限的人竞争)。大多数加密货币货币交易所“借用”了标准资产市场已经建立的基础设施，其 FIX API 的结构与标准资产市场上的完全相同。此外，由于加密货币交易所竞争激烈，你会发现你为交易这些工具支付的佣金比普通市场更具竞争力。例如，你可以找到为市场带来流动性的经纪人(这对于常规资产行业的个人来说是不可想象的)。

为什么你需要直接进入市场？这个问题用一个机器学习座右铭来回答:

垃圾进，垃圾出

此外，如果您想要执行任何类型的定量分析，您必须控制系统上的一切，也就是说，您希望您所做的分析在您将要使用的同一数据聚合平台上完成。当你建立一个机器学习模型时，你假设他们的预测在一组边界条件内是有效的，你违反这些条件越多，你的预测就越无效。因此，你最好的选择是让经纪人尽可能快地将每笔交易(或订单簿变更)传输给你。

系统的简化概述

出于我稍后将解释的原因，HFT 系统必须对错误有巨大的容忍度。当我发现这一点时，我采用了微服务架构，因为对我来说，这是确保多组件系统容错和可伸缩的最佳方式。我可以向你保证，当你进行实时交易时，你的系统会出现不可预见的故障(其中一些会与第三方有关，例如对经纪人的分布式拒绝服务 (DDOS)攻击。是的，会出现这种情况)。当你使用微服务架构时，当一个服务失败时，你有调度程序试图立即重启服务，这是一个非常优雅的解决方案，当试图单独构建这样的系统时。

Simplified diagram of an entry level HFT architecture

组件的简要说明:

数据库:高密度时间序列数据库，需要能够在一天内处理成千上万的数据插入。(提示:选择一个 IOT 数据库奇迹)。还需要可扩展，以便它能够以不可变和分布式的方式执行非常高速的重新采样。
Scrapper: 将新传输的数据插入到数据库中
定量模型:当α存在时发出信号的定量模型
订单执行器:拾取量化模型的信号，与市场进行交互。有时候市场是不流动的，或者你的策略必须满足某种类型的滑点要求。因此，为了使您的系统不变，最好有一个微系统，它试图以最好的方式执行您的头寸，这允许您节省佣金，例如，您现在可以执行限价单，而不是使用市价单，这将需要一些时间来消耗，并可能需要根据市场流动性进行调整。
定量分析:你必须开发的制作模型的一套工具。由于这些数据来自基础设施，因此您有更好的方法来确保系统的边界条件。例如，你不能保证在高度波动的市场条件下拥有完全的市场准入，因此，通过建设你的基础设施，你有办法准确地衡量发生了什么，什么时候发生，并记录下来。

为什么要采用这样的微服务架构？嗯，有时你的废品回收器会由于经纪人中断而失败(在高度不稳定的情况下，有恶意代理开始 DDOS，使其他人更难进入市场)。我推断这是一个 DDOS 攻击，但为了更正确，让我们称之为代理不可用。这是市场有效时的样子(注意，这些图不是重新采样的，实际上，这个时间窗口内的每笔交易都被绘制出来):

Efficient Market with nice spreads

经纪人不在时，市场效率非常低(请注意，在下一张图中，y 轴的刻度要大一个数量级):

Inefficient Market

你可以在最后一张图中看到，在一个小的时间窗口中，价差出现了巨大的缺口。这是由于代理不可用而导致的。由于算法无法发出常规的限价订单，为市场带来稳定性和流动性，因此出现了一些高市价订单(不管市场状况如何，这些订单都被接受，但不保证你会得到什么价格)，通过消耗现有的限价订单来扩大价差。

更详细的架构概述

我将尝试对这个系统做一个更详细的概述，并解释一些设计选择。我建议使用 Docker 来开发服务。Docker 提供了非常好的管理工具，如果您想使用像 Kubernetes 这样的集群，它可以让您更容易地进行部署。

Detailed architectural design of an entry level HFT system

REST API scraper 服务:这个服务有一个缓冲区，缓冲经纪人的 Websocket API 通过流提供的最近的市场交易、报价和订单。它拥有多个工作器的原因是为了减轻代理基础设施的中断(如果代理服务器开始堵塞，这种情况经常发生，拥有多个冗余工作器会增加所有消息通过的机会)。例如，代理服务器可能会开始丢弃一些连接，以保持其工作负载运行，如果您有更多的工作线程，则在已经丢弃的工作线程重新启动时，您有更高的可能性保持至少一个连接。您还有机会让多个服务在多个 IP 上运行，这将为您带来更多冗余。
scraper 服务:scraper 服务收集发布在 REST API 上的信息，并将其插入数据库。它能够在多个 REST 服务之间跳转，如果检测到错误的行为，就触发重启。
订单执行服务:从数据库的表格中获取信号以执行动作，并通过执行市价订单或限价订单(取决于模型的规格)来启动其执行。它还能够在多个 REST 服务中跳转。
量化算法服务:有模型实现，使用数据库上收集的数据生成交易信号。
数据库集群:从市场接收原始数据需要高带宽的数据传输。对这些数据进行重新采样可能是相当密集的，因为您希望将相同的数据库用于开发和生产，所以您需要有高吞吐量。
开发和研究工具:通过在相同的系统上开发您的模型，您可以确保在满足必要的边界条件时有更好的质量。毕竟，现在它是你的数据，你确切地知道你花了多长时间来接收和处理它。

为什么 REST API 和 scrapper 服务是分开的？

这一决定是为了提高系统的速度并确保 24/7 系统的可靠性，例如，当您决定要开仓或平仓时，您不希望不断地查询数据库，通过查询将信息直接存储在 RAM 上的 REST API(降低硬盘开销)，您能够实现更高的池化频率(这也在很大程度上取决于您离交易所和所选编程语言的距离)。如果 REST 服务由于某种未知原因失败，您可以重启，不会丢失任何正在进行的数据流，同时有足够的时间安全地重启它。触发交易信号和试图执行交易是有区别的。你确实想尽快完成交易。

结论

我可以持续几个小时(特别是谈论我在试图对时间序列实现 ML 时的糟糕经历，让我们把它留给另一篇博文)，但今天就足够了。我在实现这样一个架构的时候遇到了很多瓶颈，同时试图为我的模型所做的预测获得最佳的边界条件。这是一次在实现 24/7 可靠性的同时尽可能获得最佳数据的旅程。如果你想给我建议，讨论想法，给我上关于非平稳过程的课(这是我绝对需要的)，或者只是聊天，你可以联系我

abriosipublic@gmail.com

评估 Python 中注释者的分歧以构建用于机器学习的健壮数据集

原文：https://towardsdatascience.com/assessing-annotator-disagreements-in-python-to-build-a-robust-dataset-for-machine-learning-16c74b49f043?source=collection_archive---------14-----------------------

Tea vs. Coffee: the perfect example of decisions and disagreements!

正如 Matthew Honnibal 在他的 2018 PyData Berlin talk [1]中指出的那样，开发一个可靠的注释模式并拥有专注的注释者是成功的机器学习模型的基石之一，也是工作流不可或缺的一部分。下面的金字塔——摘自他的幻灯片——显示这些是模型开发之前的基本阶段。

我最近完成了数据分析硕士学位，然后与一家机器学习慈善机构密切合作，直到现在，我才意识到正规教育的状况令人担忧的是，对底部三个组成部分的关注明显不足，而对顶部两个组成部分的关注过度。尽管这很麻烦，但原因很明显:学生们对粗糙的机器学习前阶段不感兴趣。但事实仍然是，如果不了解如何处理可能不太令人兴奋的东西，就根本不可能构建一个健壮、强大和可靠的机器学习产品。

我注意到注释不一致评估方法的解释并不局限于网上的一篇文章，用 Python 来做这件事的方法也不局限于单个库。因此，在本文中，我们将讨论注释者协议领域的一些重要主题:

用于评估协议质量的著名统计分数的定义。(数学也可以在维基百科的相关页面上找到。)
这些统计分数的 Python 实现使用了我写的新库，名为 disagree。
如何使用同一个库评估哪些标签值得进一步关注，引入双向同意的概念。

什么是注释模式？

在我们开始任何形式的计算学习之前，我们需要一个数据集。在监督学习中，为了让计算机学习，我们数据的每个实例都必须有一些标签。为了获得标签，我们可能需要一组人坐下来手工标记每个数据实例——这些人就是注释者。为了允许人们这样做，我们必须开发并编写一个注释模式，建议他们如何正确标记数据实例。

当多个注释者标记同一个数据实例时(情况总是如此)，可能会对标记应该是什么产生分歧。注释者之间的分歧是不好的，因为这意味着我们不能有效地分配带有标签的实例。如果我们开始用存在重大分歧的标签分配数据实例，那么我们的机器学习模型就处于严重危险之中。这是因为数据无法依赖，我们开发的任何模型也无法依赖。

因此，一旦所有数据都被标记，就必须调查这些不一致的情况，这样我们就可以了解和理解不一致的来源。

删除有重大分歧的数据:这给我们留下的只有那些有把握标记的可靠数据。
修改注释模式以备将来使用:可能是写得不清楚，我们可以改进未来的协议。
改变或合并标签类型:也许我们在有用的标签类型上根本就错了。有时我们需要修改标签来适应注释器的功能。

为了介绍一些定量评估注释者间分歧的最有用(和不太有用)的方法，我将首先向您展示如何设置 Python‘disagree’库。然后，我将研究各种统计数据，结合数学理论和 Python 实现。

“不同意”库

它旨在做几件事:

为定量评估注释者的分歧提供统计能力。

2。提供不同注释者之间的可视化。

3。提供可视化效果，以查看哪些标签的分歧最大。

在分别观察了这三点之后，如果有必要，可以考虑上面提到的三种解决方案。首先，您需要导入库。以下是所有可用的模块，我将在此进行演示:

from disagree.agreements import BiDisagreements
from disagree import Metrics, Krippendorff

不同意有两个基本的细微差别。首先，您需要以特定的方式将注释存储在 pandas 数据帧中。行由数据实例进行索引，列是该数据实例的每个注释者的标签。列标题是注释者的字符串名称。标签的类型可以是字符串、整数、浮点或缺失值(即 nan 或 None)。以下是一个数据集示例:

example_annotations = {"a": [None, None, None, None, None, "dog", "ant", "cat", "dog", "cat", "cat", "cow", "cow", None, "cow"],
                       "b": ["cat", None, "dog", "cat", "cow", "cow", "ant", "cow", None, None, None, None, None, None, None],
                       "c": [None, None, "dog", "cat", "cow", "ant", "ant", None, "dog", "cat", "cat", "cow", "cow", None, "ant"]}df = pd.DataFrame(example_annotations)

因此，在我们的例子中，我们有 3 个标注者，名为“a”、“b”和“c”，他们共同标记了 15 个数据实例。(数据的第一个实例没有被“a”和“c”标注，被“b”标注为 0。)

现在，我们准备探索用于评估注释者协议的可能的度量标准。从从指标模块设置指标实例开始:

mets = metrics.Metrics(df)

联合概率

联合概率是评估注释者协议的最简单、最天真的方法。它可以用来查看一个注释者与另一个注释者的一致程度。

本质上，它将注释者 1 和 2 同意的次数相加，然后除以他们都标记的数据点的总数。

对于我们的示例数据集，我们可以在我们选择的两个注释器之间进行计算:

joint_prob = mets.joint_probability("a", "b")print("Joint probability between annotator a and b: {:.3f}".format(joint_prob))**Out:** Joint probability between annotator a and b: 0.333

科恩的卡帕

这是一种比联合概率更先进的统计方法，因为它考虑了偶然同意的概率。它还比较了两个注释器。

使用 Python 库:

cohens = mets.cohens_kappa("a", "b")print("Cohens kappa between annotator a and b: {:.3f}".format(cohens))**Out:** Cohens kappa between annotator a and b: 0.330

关联

关联也是显而易见的选择！如果注释者 1 和注释者 2 有很高的相关性，那么他们很可能在标签上达成一致。相反，低相关性意味着他们不太可能同意。

spearman = mets.correlation("a", "b", measure="spearman")
pearson = mets.correlation("a", "b", measure="pearson")
kendall = mets.correlation("a", "b", measure="kendall")print("Spearman's correlation between a and b: {:.3f}".format(spearman[0]))
print("Pearson's correlation between a and b: {:.3f}".format(pearson[0]))
print("Kendall's correlation between a and b: {:.3f}".format(kendall[0]))**Out:** Spearman's correlation between a and b: 0.866
**Out:** Pearson's correlation between a and b: 0.945
**Out:** Kendall's correlation between a and b: 0.816

请注意，对于相关性测量，会返回一个相关性和 p 值的元组，因此在打印结果时会进行零索引。(这使用了 scipy 库。)

此时，您可能会这样想:“但是如果我们有两个以上的注释者呢？这些方法不是挺没用的吗？”答案既可以是“是”，也可以是“不是”。是的，它们对于评估全局注释者在使数据集更加健壮方面的分歧是没有用的。但是，在许多情况下，您可能希望这样做:

假设您有 10 个注释者，其中 2 个一起坐在一个房间里，而另外 8 个分开坐。(可能是办公场地的原因。)根据注释，您可能想看看坐在一起的两个人之间是否有更大的一致性，因为他们可能一直在讨论标签。
也许您希望看到具有相同教育背景的注释者之间的一致，相对于来自另一种教育背景的群体。

现在，我将介绍一些更高级的——也可以说是最流行的——方法，用于评估任意数量的注释者之间的注释者协议统计数据。这些在现代机器学习文献中更常见。

弗莱斯卡帕

弗莱斯的卡帕是科恩的卡帕的延伸。它通过考虑注释者协议的一致性来扩展它，与 Cohen 的 kappa 所关注的绝对协议相反。这是一种统计上可靠的方法，通常在文献中用于证明数据质量。

在 Python 中:

fleiss = mets.fleiss_kappa()

克里彭多夫的阿尔法值

最后，也是计算量最大的，是 Krippendorff 的 alpha。这和 Fleiss 的 kappa 一起，被认为是最有用的统计数据之一(如果不是最有用的话)。这里有一个 Krippendorff 自己的出版物的链接，概述了数学并给出了一些手工计算的例子:

https://repository.upenn.edu/cgi/viewcontent.cgi?article = 1043&context = ASC _ papers #:~:text = Krippendorff 的%20alpha%20(%CE%B1)%20is%20a，将% 20computable % 20values % 20to 赋值给%20them。

在 disagree 库中，这与任何其他统计一样简单:

kripp = Krippendorff(df)
alpha = kripp.alpha(data_type="nominal")print("Krippendorff's alpha: {:.3f}".format(alpha))**Out:** Krippendorff's alpha: 0.647

我将 Krippendorff 的 alpha 保留在单独的类中的原因是因为在初始化中有一些计算量非常大的过程。如果有大量的注释(比如说 50，000 到 100，000 个),当人们对使用 Krippendorff alpha 数据结构不感兴趣时，必须对其进行初始化是令人沮丧的。

这就是——在一个易于使用的紧凑 Python 库中计算一组有用的注释不一致统计数据。

双方同意

另一个值得考虑的有用的东西是我喜欢称之为的双向协议。这是两个不同的标注器对一个数据实例进行不同标注的次数。之所以有用，是因为它们允许您检查所使用的标签系统或者提供给注释者的注释模式中可能存在的缺陷。

例如，在数据集的给定实例中，标签[0，0，1]或[1，1，1，2]或[1，3，1，3]将被视为单个 bidisagreement。(第 8 行和第 15 行是上述数据帧中的双向协议示例。)这可以扩展到三不同意、四不同意、五不同意等等。

使用不同意库，我们可以用上面导入的双向同意模块来检查这些情况。

首先，设置实例:

bidis = BiDisagreements(df)

下面是一个有用的属性:

bidis.agreements_summary()Number of instances with:
=========================
No disagreement: 9
Bidisagreement: 2
Tridisagreement: 1
More disagreements: 0
Out[14]: (9, 2, 1, 0)

输出显示，从我们的示例注释来看，有 9 个数据实例没有不一致之处；存在 bidisagreement 的 2 个数据实例；和 1 个数据实例，其中有一个 tridisagreement。(注意，这将元组作为输出返回。)这些加起来是 12 而不是 15 的原因是因为在我们的示例数据集中，有 3 个实例，其中最多有 1 个标注器标记了实例。这些不包括在计算中，因为由 1 个注释器标记的任何数据实例都应该被认为是无效的。

我们还可以看到哪些标签导致了双向重复:

mat = bidis.agreements_matrix(normalise=False)
print(mat)[[0\. 0\. 1\. 0.]
 [0\. 0\. 0\. 0.]
 [1\. 0\. 0\. 1.] 
 [0\. 0\. 1\. 0.]]

当然，对于没有从 0 到某个数字进行索引的标签，我们需要能够看到矩阵中的哪个索引对应于哪个标签，这可以通过 bidis.labels_to_index()在字典形式中看到。

从这个矩阵中，我们可以看到一个 bidisagreement 源于标签 0 vs 标签 2，另一个源于标签 2 vs 标签 3。使用这个矩阵，你可以创建一个你选择的可视化——比如使用 matplotlib 的混乱矩阵形式的东西:https://www.kaggle.com/grfiv4/plot-a-confusion-matrix.

当您有非常大的数据集时，这最后一个功能特别有用。最近，我对 6，000 个数据实例中的 25，000 个注释使用了这种方法，能够非常快速地识别出几乎 650 个 bidisagreements 来自两个标签。这使我能够处理这两个标签，以及如何在机器学习模型中使用它们，以及何时修改注释模式以供注释者将来使用。

未来考虑

使用 bidisagreements，您会注意到库只能显示频率。这有一个相当重要的底线。想象以下两组标签用于两个数据实例:

[0, 0, 0, 0, 1]
[2, 1, 1, 2, 2]

显然，第一个比第二个有更好的一致性，然而不一致认为他们是平等的。致力于一种 bidisagreement 方法将是有趣的，该方法在统计上将第二个加权为比第一个更重要的 bidisagreement，然后相应地归一化 bidisagreement 矩阵。

关于“不同意”的最终注释

这个库是最近的，也是我第一次实现它。(出于这个原因，我请你原谅混乱的版本和提交历史。)完整的 GitHub 回购可以在这里找到:【https://github.com/o-P-o/disagree。

回购包括所有的代码，以及 Jupyter 笔记本与上述例子类似。自述文件中也有完整的文档。

请随时提出问题，并对其他功能提出建议。我将立即处理这些问题。

[1]https://www.youtube.com/watch?v=jpWqz85F_4Y&t = 442s

关联规则挖掘

原文：https://towardsdatascience.com/association-rule-mining-be4122fc1793?source=collection_archive---------6-----------------------

数据

我们将要处理的数据如下所示:

关联规则挖掘的目的是什么？

关联规则挖掘是发现数据模式的方法之一。它发现:

一起出现的特征(尺寸)
“相关”的特征(尺寸)

一个特性的值告诉我们另一个特性的值是什么？比如买纸尿裤的人，很可能会买婴儿爽身粉。或者我们可以这样重新表述:如果(人们购买尿布)，那么(他们购买婴儿爽身粉)。请注意 if，then 规则。这并不一定意味着如果人们购买婴儿爽身粉，他们就会购买尿布。一般来说，我们可以说，如果条件 A 倾向于 B，它不一定意味着 B 倾向于 A。注意方向性！

何时使用关联规则

我们可以在任何数据集中使用关联规则，其中特征只取两个值，即 0/1。下面列出了一些例子:

购物篮分析是关联规则的一个流行应用。
访问网页 X 的人很可能会访问网页 Y
年龄在[30，40] &收入[> 10 万美元]的人很可能拥有自己的房子

衡量规则的有效性

衡量规则有效性的标准如下:

支持
信心
电梯
其他:亲和力、影响力

我们将使用一个示例数据集更详细地讨论支持度和置信度。

上述数据集也可以这样表示:

支持意味着有多少历史数据支持你的规则，而信心意味着我们对这个规则有多有信心。

支持度可以计算为包含 A 和 B 的行的分数或 A 和 B 的联合概率。

在包含 A 的行中，置信度是包含 B 的行的分数或给定 A 时 B 的条件概率。

举起就是比信心就是比支持。如果升程是< 1，那么 A 和 B 负相关，否则正相关，如果升程等于 1，则不相关。

R 中的关联规则挖掘

原文：https://towardsdatascience.com/association-rule-mining-in-r-ddf2d044ae50?source=collection_archive---------1-----------------------

关联规则挖掘(也称为关联规则学习)是一种常用技术，用于发现许多变量之间的关联。杂货店、电子商务网站和任何拥有大型事务数据库的人都经常使用它。我们在日常生活中遇到的一个最常见的例子是——当你在他们的网站上订购一些东西时，亚马逊知道你还想买什么。同样的想法也适用于 Spotify 他们知道你下一首想听的歌。所有这些都在某种程度上结合了数据挖掘概念和关联规则挖掘算法。

M 市场篮子分析类似于 ARM。购物篮分析是一种建模技术，其理论基础是，如果你购买了某一组商品，你就更有可能(或更不可能)购买另一组商品。例如，如果你在一家英国酒吧，你买了一品脱啤酒而没有买酒吧餐，你比没有买啤酒的人更有可能同时买薯片。

基于强规则的概念，Rakesh Agrawal、Tomasz Imieliński 和 Arun Swami 引入了关联规则，用于在超市销售点(POS)系统记录的大规模交易数据中发现产品之间的规律性。

本文解释了关联规则挖掘的概念以及如何在 R 中使用这种技术

为了在 R 中执行关联规则挖掘，我们使用 R 中的arules和arulesViz包。

Michael hassler 等人 创作并维护了两个非常有用的关联规则挖掘 R 包:arules 包和 arulesViz 包。

如果您的系统中没有安装这些软件包，请使用以下命令来安装它们。

> install.packages("arules")
> install.packages("arulesViz")

数据

我使用的是与arules软件包捆绑在一起的 AdultUCI 数据集。

> data(“Groceries”)

让我们先检查食品杂货数据。

> class(Groceries)
      [1] "transactions"
      attr(,"package")
      [1] "arules"

这是一个事务性数据集。

> inspect(head(Groceries, 2))
          items                                                   
      [1] {citrus fruit,semi-finished bread,margarine,ready soups}
      [2] {tropical fruit,yogurt,coffee}

从上面的输出中可以观察到前两个事务以及每个事务中涉及的项目。

生成规则

有三个参数控制要生成的规则数量，即。 支持和信心。另一个参数 Lift 是使用支持度和置信度生成的，并且是过滤生成的规则的主要参数之一。

支持是项集在数据集中出现频率的指示。只考虑上面输出中的两个事务。项目柑橘类水果的支持度为 1/2，因为它只出现在两个交易中的 1 个中。
置信度 是规则被发现为真的频率的指示。在生成规则之后，我们将讨论更多关于置信度的内容。

让我们使用先验算法找出规则。

> grocery_rules <- apriori(Groceries, parameter = list(support = 0.01, confidence = 0.5))AprioriParameter specification:
      confidence minval smax arem  aval originalSupport maxtime support minlen maxlen target   ext
        0.5    0.1    1 none FALSE            TRUE       5    0.01      1     10  rules FALSEAlgorithmic control:
      filter tree heap memopt load sort verbose
      0.1 TRUE TRUE  FALSE TRUE    2    TRUEAbsolute minimum support count: 98set item appearances ...[0 item(s)] done [0.00s].
      set transactions ...[169 item(s), 9835 transaction(s)] done [0.00s].
      sorting and recoding items ... [88 item(s)] done [0.00s].
      creating transaction tree ... done [0.00s].
      checking subsets of size 1 2 3 4 done [0.00s].
      writing ... [15 rule(s)] done [0.00s].
      creating S4 object  ... done [0.00s].

Apriori 算法用给定的约束生成了 15 条规则。让我们深入到输出的参数规范部分。

minval 是一个项集要成为规则的一部分所应满足的支持度的最小值。
smax 是一个项集的最大支持值。
arem 是一个附加的规则评估参数。在上面的代码中，我们使用支持度和置信度限制了规则的数量。在函数中使用 arem 参数有几种其他的方法来约束规则，我们将在本文后面讨论更多。
aval 是表示是否返回用 arem 选择的附加规则评估度量的逻辑。
原始支持 传统的支持度值在计算支持度时只考虑 LHS 和 RHS 两个项目。如果您想仅使用 LHS 项目进行计算，则需要将其设置为 FALSE。
maxtime 是允许检查子集的最大时间量。
minlen 是规则中要求的最小项数。
maxlen 是规则中可以出现的最大项数。

> inspect(head(sort(rules, by = "confidence"), 3))
      lhs                                 rhs                support    confidence lift     count
      [1] {citrus fruit,root vegetables}   => {other vegetables} 0.01037112 0.5862069  3.029608 102  
      [2] {tropical fruit,root vegetables} => {other vegetables} 0.01230300 0.5845411  3.020999 121  
      [3] {curd,yogurt}                    => {whole milk}       0.01006609 0.5823529  2.279125  99

上面显示了按置信度排序的前 3 条规则。

限制生成的规则数量

在许多情况下，您希望限制生成的规则数量。例如，您可以在回归/分类中使用关联规则作为预测器。您可以生成规则，将规则的右侧作为您的响应，并将生成的规则用作建模特征。在这种情况下，您不希望使用所有生成的规则作为预测器，因为许多规则实际上是更大规则的子集，因此您希望消除它们。下面的代码片段显示了如何生成其 RHS 是预定义的规则。

wholemilk_rules <- **apriori**(data=Groceries, parameter=**list** (supp=0.001,conf = 0.08), appearance = **list** (rhs="whole milk"))# The above code shows what products are bought before buying "whole milk" and will generate rules that lead to buying "whole milk".

您可以通过调整一些参数来限制规则的数量。虽然参数调整取决于您正在处理的数据类型，但最常见的方法包括更改支持度、置信度和其他参数，如 minlen、maxlen 等。

> grocery_rules_increased_support <- apriori(Groceries, parameter = list(support = 0.02, confidence = 0.5))# This generates only one rule in the output.

如果你想让变得更强规则，你必须增加信心。如果您想要更长的规则，请增加 maxlen 参数。如果您想消除较短的嵌线，减小 minlen 参数。

有时，您可能想找到包含最大数量项目的规则，并删除作为较长规则子集的较短规则。下面的代码删除了这些多余的规则。

> subsets <- which(colSums(is.subset(grocery_rules, groery_rules)) > 1)
> grocery_rules <- grocery_rules[-subsets]

让我们看看之前描述过的 arem 参数。规则生成后，根据参数 arem 的值进一步评估。 arem 参数取值如下: none ， diff ， quot ， aimp ， info ， chi2 。

# This gives more than 1,500,000 rules
> rules <- apriori(Groceries, parameter = list(supp = 0.0001, conf = 0.5))# This gives 982,000 rules.
> rules_chi2 <- apriori(Groceries, parameter = list(supp = 0.0001, conf = 0.5, arem = "chi2"))

将数据帧转换成事务数据

使用与arules包捆绑的AdultUCI数据集。

> data("AdultUCI")
> class(AdultUCI)
      "data.frame"

当您查看 AdultUCI 数据帧的结构时，您会发现有几列是数字。事务性数据集的每个事务都包含该事务中涉及的项的列表。当我们将数据帧转换成事务性数据集时，该数据帧的每一行都将成为一个事务。每一列都将成为一个项目。但是，如果列的值是数字，则不能使用它，因为该列可以接受无限个值。因此，在将 dataframe 转换为事务性数据集之前，我们必须确保将每一列转换为因子或逻辑，以确保该列仅从固定集中取值。

> str(AdultUCI)
'data.frame':	48842 obs. of  15 variables:
 $ age           : int  39 50 38 53 28 37 49 52 31 42 ...
 $ workclass     : Factor w/ 8 levels "Federal-gov",..: 7 6 4 4 4 4 
 $ fnlwgt        : int  77516 83311 215646 234721 338409 284582 
 $ education     : Ord.factor w/ 16 levels "Preschool"<"1st-4th"<..: 
 $ education-num : int  13 13 9 7 13 14 5 9 14 13 ...
 $ marital-status: Factor w/ 7 levels "Divorced","Married-AF-Spouse"
 $ occupation    : Factor w/ 14 levels "Adm-clerical",..: 1 4 6 6 10 
 $ relationship  : Factor w/ 6 levels "Husband","Not-in-family",..: 
 $ race          : Factor w/ 5 levels "Amer-Indian-Eskimo",..: 5 5 5 
 $ sex           : Factor w/ 2 levels "Female","Male": 2 2 2 2 1 1 1 
 $ capital-gain  : int  2174 0 0 0 0 0 0 0 14084 5178 ...
 $ capital-loss  : int  0 0 0 0 0 0 0 0 0 0 ...
 $ hours-per-week: int  40 13 40 40 40 40 16 45 50 40 ...
 $ native-country: Factor w/ 41 levels "Cambodia","Canada",..: 39 39 
 $ income        : Ord.factor w/ 2 levels "small"<"large": 1 1 1 1 1

在AdultUCI数据帧中，第 1、3、5、11、12、13 列是整数。所以把每一列都转换成因子。

> AdultUCI <- lapply(AdultUCI, function(x){as.factor(x)})> str(AdultUCI)
List of 15
 $ age           : Factor w/ 74 levels "17","18","19",..: 23 34 22 
 $ workclass     : Factor w/ 8 levels "Federal-gov",..: 7 6 4 4 4 4 
 $ fnlwgt        : Factor w/ 28523 levels "12285","13492",..: 3462 
 $ education     : Ord.factor w/ 16 levels "Preschool"<"1st-4th"<..: 
 $ education-num : Factor w/ 16 levels "1","2","3","4",..: 13 13 9 7 
 $ marital-status: Factor w/ 7 levels "Divorced","Married-AF-
 $ occupation    : Factor w/ 14 levels "Adm-clerical",..: 1 4 6 6 10 
 $ relationship  : Factor w/ 6 levels "Husband","Not-in-family",..: 
 $ race          : Factor w/ 5 levels "Amer-Indian-Eskimo",..: 5 5 5 
 $ sex           : Factor w/ 2 levels "Female","Male": 2 2 2 2 1 1 
 $ capital-gain  : Factor w/ 123 levels "0","114","401",..: 28 1 1 1
 $ capital-loss  : Factor w/ 99 levels "0","155","213",..: 1 1 1 1 1
 $ hours-per-week: Factor w/ 96 levels "1","2","3","4",..: 40 13 40
 $ native-country: Factor w/ 41 levels "Cambodia","Canada",..: 39 39
 $ income        : Ord.factor w/ 2 levels "small"<"large": 1 1 1 1 1

现在AdultUCI dataframe 可以使用下面的代码片段转换成事务性数据集。

> transactional_data <- as(AdultUCI, "transactions")

这篇关于关联规则挖掘的文章到此结束。

关联规则完全指南(1/2)

原文：https://towardsdatascience.com/association-rules-2-aa9a77241654?source=collection_archive---------0-----------------------

帮助您更快、更智能购物的算法

回顾在统计训练营中向我介绍的众多概念，有很多东西要写和分享。我选择从关联规则开始，有两个原因。首先，这是我最喜欢学习的概念之一，其次，网上资源有限，很难掌握。

在博客的第一部分，我将介绍一些关键的术语和指标，旨在让读者了解规则中“关联”的含义，以及量化这种关联强度的一些方法。第 2 部分将集中讨论使用先验算法从成千上万的项目列表中挖掘这些规则。

关联规则是用于购物篮分析的机器学习中非常重要的概念之一。在商店里，所有的蔬菜都放在同一个过道里，所有的乳制品放在一起，化妆品形成了另一组这样的组。像这样投入时间和资源在有意的产品投放上，不仅减少了顾客的购物时间，还提醒了顾客他可能有兴趣购买的相关商品，从而帮助商店在这个过程中进行交叉销售。关联规则有助于发现大型数据库中项目之间的所有此类关系。需要注意的一点是-

规则并不提取个人的偏好，而是发现每一个不同交易的元素集之间的关系。这就是它们与协同过滤的不同之处。

为了详细说明这一点，规则并不将用户的不同交易随着时间的推移联系起来以识别关系。具有唯一交易 id(来自所有用户)的项目列表作为一个组进行研究。这有助于将产品放置在过道上。另一方面，协同过滤将对应于一个用户 ID 的所有交易捆绑在一起，以识别用户偏好之间的相似性。这有助于在电商网站上推荐商品，在 spotify 上推荐歌曲等。

现在让我们看看关联规则到底是什么样子的。它由一个前因和一个后果组成，两者都是项目列表。请注意，这里的含义是共现，而不是因果关系。对于给定的规则，项集是前件和后件中所有项的列表。

有各种各样的标准可以帮助我们理解这两者之间的联系强度。让我们一一道来。

1。支持

这个度量给出了一个概念，即一个项集在所有事务中出现的频率。考虑项集 1= {面包}和项集 2= {洗发水}。包含面包的交易会远远多于包含洗发水的交易。所以正如你所猜测的，项目集 1 通常会比项目集 2 有更高的支持度。现在考虑items et 1= {面包，黄油}和items et 2= {面包，洗发水}。许多交易都会有面包和黄油，但是面包和洗发水呢？没有那么多。所以在这种情况下，项集 1 一般会比项集 2 有更高的支持度。从数学上讲，支持度是项目集所在的事务总数的分数。

支持值有助于我们确定值得考虑的规则，以便进一步分析。例如，可能只想考虑在总共 10，000 个事务中至少出现 50 次的项目集，即 support = 0.005。如果一个项目集恰好具有非常低的支持度，我们没有足够的关于其项目之间关系的信息，因此不能从这样的规则中得出结论。

2.信心

这个度量定义了在购物车已经有先行词的情况下，在购物车上出现结果的可能性。这就要回答这个问题了——在所有包含比如说{嘎吱船长}的交易中，有多少交易也包含{牛奶}呢？我们可以用常识说{嘎吱船长}→{牛奶}应该是一个高置信度规则。从技术上来说，置信度是给定前因后件发生的条件概率。

在继续之前，让我们再考虑几个例子。你认为{黄油}→{面包}的信心是什么？也就是说，有黄油的交易中有多少比例也有面包？非常高，即接近 1 的值？没错。{酸奶}→{牛奶}呢？又高了。{牙刷}→{牛奶}？不太确定？此规则的可信度也很高，因为{Milk}是如此频繁的项目集，并且会出现在每一个其他事务中。

对于这样一个频繁发生的结果，你的前因是什么并不重要。具有非常频繁的结果的关联规则的置信度总是很高。

我将在这里介绍一些数字来进一步阐明这一点。

Total transactions = 100. 10 of them have both milk and toothbrush, 70 have milk but no toothbrush and 4 have toothbrush but no milk.

考虑左图中的数字。{牙刷}→{牛奶}的置信度将是 10/(10+4) = 0.7

看起来可信度很高。但是我们凭直觉知道，这两个产品之间的关联很弱，而且这个高置信度值有误导性。升降机的引入就是为了克服这一挑战。

仅仅考虑信心的价值会限制我们做出任何商业推断的能力。

3 。抬起

在计算{Y}给定{X}出现的条件概率时，的提升控制支持结果的(频率)。升力是一个非常字面意义上的术语。可以把它看作是{X}让{Y}加入购物车，从而提升了我们的信心。换句话说，提升是在知道{X}存在的情况下，购物车上有{Y}的概率相对于购物车上有{Y}但不知道{X}存在的概率的上升。数学上，

在{X}实际上导致购物车上的{Y}的情况下，lift 值将大于 1。让我们用一个例子来理解这一点，这个例子是{牙刷}→{牛奶}法则的延续。

知道牙刷存在的情况下推车上有牛奶的概率(即置信度 ) : 10/(10+4) = 0.7

现在，为了客观地看待这个数字，考虑一下在没有任何牙刷知识的情况下，推车上有牛奶的概率:80/100 = 0.8

这些数字表明，推车上有牙刷实际上将推车上有牛奶的概率从 0.8 降低到 0.7！这将是一个 0.7/0.8 = 0.87 的升力。这才更像真实的画面。lift 值小于 1 表明，尽管规则显示出高置信度值，但在推车上放置牙刷不会增加推车上出现牛奶的机会。大于 1 的升力值证明了{Y}和{X}之间的高关联性。lift 的价值越高，如果客户已经购买了{X}，则优先购买{Y}的可能性就越大。 Lift 是帮助商店经理决定产品在过道上摆放的方法。

关联规则挖掘

既然我们已经了解了如何量化项目集内产品关联的重要性，下一步就是从整个项目列表中生成规则，并确定最重要的规则。这并不像听起来那么简单。超市里会有成千上万种不同的产品。经过一些简单的计算，可以看出，仅仅 10 个产品就会产生 57000 条规则！！而且这个数字随着物品数量的增加呈指数增长。为这些中的每一个寻找升力值将在计算上变得非常非常昂贵。如何处理这个问题？如何想出一套最重要的关联规则来考虑？ Apriori 算法来帮我们解决这个问题。

在第二部分中阅读更多关于 Apriori 算法的内容，并找到所有未解问题的答案。

请在评论中告诉我你对这个博客的想法/问题。

尝试实时可视化卷积神经网络

原文：https://towardsdatascience.com/attempting-to-visualize-a-convolutional-neural-network-in-realtime-1edd1f3d6c13?source=collection_archive---------2-----------------------

在复制自动驾驶汽车的端到端深度学习方法时，我对网络所看到的东西缺乏可见性感到沮丧。我开发了一个工具来解决这个问题。

模拟器和运行神经网络的 python 脚本通过 websocket 连接进行通信。我决定编写一个小的浏览器应用程序，它也可以通过另一个 websocket 连接到 python 脚本，并收集一些我可以可视化的附加数据。

以下是我能想到的:

右边是我们正在运行的 Udacity 模拟器。左边是我的小 React 应用程序，它将我的神经网络中卷积层的所有输出可视化。

正如你所看到的，它在控制汽车的同时实时运行。这是一次很好的练习，但我怀疑这样做是否有用。目前还不清楚网络是如何基于这些做出决策的。

您可以在此处找到代码:

[## 行为克隆-P3

行为克隆-P3 -行为克隆项目启动文件(P3)

github.com](https://github.com/paramaggarwal/CarND-Behavioral-Cloning-P3)

这篇文章是一项正在进行的工作，其总体目标是获得对神经网络更好的可视性。请在评论中告诉我你的想法，告诉我我还能为这个目标做些什么！

RNNs 中的注意和“可解释性”

原文：https://towardsdatascience.com/attention-and-explainability-in-rnns-7fd114bb4f1f?source=collection_archive---------1-----------------------

我对 NN 工程师中的运动感到兴奋(我们应该称他们为“NN 育种者”？)走向在多个神经网络之间进行“对话”的架构，如 NIVIDIA 的自动驾驶汽车架构和谷歌的 seq2seq 翻译器所展示的。然而，还缺少一些东西…

这些实现仅部分解决了两个问题，即注意力和可解释性。我将解释一下这两者，然后我将检查将它们联系在一起的缺失部分。

注意:

在这里，我将坚持一个句子解析的例子。当给出一个长句子时，神经网络通常会努力注意相关信息。句子开头的处的一个单词可能决定句子结尾附近的一个单词的变位，但是神经网络“忘记了它”。研究人员试图让网络“记住整个事情”(通过将整个句子转换为固定长度的向量)，但这只对像训练中那样复杂的句子有效。**

例如，“吉姆喜欢和他的朋友聚会，喜欢他们一起做的食物和他们的装饰品。”解析器必须将代词“他的”、“他们的”和“他们的”链接到它们的所指对象:“吉姆”、“朋友”和“当事人”。一个简单的 LSTM 架构将到达单词“their”，并从前面的单词“and”中记住它的状态。研究人员认为，希望这个状态仍然包括一些早期单词“parties”的知识！对于短句，网络会记住——网络状态不会被破坏太多。当给出更长的句子时，网络倾向于选择最近的单词，而不是有意义的单词。(一个 LSTM 人可能会认为'他们的装饰品'意味着'食物'装饰品'……)

为了克服这个问题，seq2seq 方法生成一个上下文向量。当编码器网络遇到一个新单词时，网络的一部分会在句子中寻找其他可能相关的单词。被认为相关的字被提供给解码器网络。实际上，上下文向量 突出显示了句子的 部分，并且只发送那些部分。它集中了网络的注意力。这样，解码器网络可以从更远的后方(或前方，对于双向 RNN)接收相关信息。句子长度不太重要，因为只有几个词被认为是相关的。而且，一个真正的一般注意力可以“跳来跳去”，从任何长度的句子中挑选单词。(我们来找你了，普鲁斯特！)

说明性:

神经网络变得越来越大，也越来越神秘。当他们做出决定时，我们想知道是什么信息引导了他们的决定。英伟达的解决方案是显示网络在‘想象’什么，这样司机就能看到汽车对周围环境的看法。如果他们的 Driveworks 神经网络只显示两辆车在你旁边的车道上，而你却能看到你窗外的三辆车，那你就知道出事了。

总的来说，显示网络所想的能力是一个强有力的工具。配有解释的译文会对你说:“这里用‘la’，因为下一个词是阴性的。”解释向我们展示了网络何时使用合理的概括而不是记忆几个像素来做出决策。

因此，该行业正在这两个领域取得进展。少了什么？

****连贯性:

在这两种情况下，我们希望找到一致性。“当我的 RNN 分析一个句子时，它是不是在我应该去的地方寻找信息？当它找到信息时，它会像我一样做决定吗？”

这里的核心直觉来自我们自己的经验:

当你从“我不明白这个词指的是什么……”变成“啊，它指的是另一个词，在这里”，你的注意力和你思想的可解释性发生了什么？一般来说，当你理解事物时，你会满足两个标准:

你移动你的注意力，直到你找到帮助理解的信息。

当你理解了某件事，你就能够解释它为什么有意义。

这些陈述虽然简单，但仍然足以指导设计。一个解码器网络应该很难取悦——它想要接收一组特定的单词作为正确的上下文。如果上下文向量带来“有点意义”的单词，解码器网络应该 更喜欢继续寻找 。(一会儿对“如何继续寻找”的模糊描述……)

当解码器网络决定“这个字通过这些其他字变得一致时，特别是”，那应该是可供我们看到。例如:一个编码器-上下文-解码器架构，读着“约翰给了苏珊一个 cookie”，会看着“cookie”并告诉我们:“cookie”是“give”的间接宾语。这让我们可以检查网络在想什么，看看它是否有合理的判断！

让我们结合这两个标准，看一个多句子的例子:“它不会很快停止。爱丽丝不喜欢，很不情愿地穿上鞋子，抓起一把伞。这场雨让她的通勤变得更加糟糕。”在这里，“它”是雨。此外，为了发现“it”意味着“rain”，网络需要使用上下文向量忽略句子中的大多数单词(大多数单词的得分为“0”，而名词“Alice”、“shoes”、“umbrella”、“commute”和“rain”有一些非零值)。

假设网络的上下文向量最初倾向于将“鞋子”作为“它”的所指对象，因为那些单词彼此接近。然而，将这个向量传递给解码器网络会输出“不相干的！”为了遵循我们上面的标准，网络将然后从它的上下文向量中丢弃‘鞋子’,并再次寻找。在第二次尝试时，最强的信号来自“雨伞”(再次，因为接近)。我们挑剔的解码器网络仍然以“不连贯！”来回应所以，伞从上下文向量中被丢弃，解码器再次寻找。最后，“雨”是一个连贯的选择——不像雨伞和鞋子，雨“不会停止”。此外，“鞋子”是复数。

最重要的是，在上面的例子中,' It '的第一个实例是有一段时间不明确的。当一个句子以“it”开头时，解码者需要发脾气——没有所指对象！而且，当更多的信息可用时，解码器需要更新它对‘它’的评估。“it”这个词在句子的第一遍会非常含糊不清。网络尽可能多地解析，然后返回进行第二次传递，扩大对“它”的连贯解释的搜索。有些事情是永久暧昧的！(<-例题)网络应该能告诉你哪些词是歧义的，用什么方式。

****把注意力和可解释性拉在一起:

我们需要看到我们的网络做出决定的原因，检查他们思想的一致性。后人可能认为可解释性和编写调试测试一样重要。

此外，网络应该将其注意力转移到数据上，以便能够观察任何大小的输入(例如，巨幅图像、长句子、复杂的游戏)。

神经网络可以为我们提供这两个目标，通过 移动它的注意力，直到它找到增加连贯性的信息 。一致性测试可能是会话中一组神经网络中的另一个“模块”。一个简单的架构可能看起来像这样:一致性模块接受上下文向量和解码器的输出，也许，并输出“一致”或“不一致”。如果它返回“相干”，那么使用解码器的输出。否则，“不一致”触发对上下文向量中的一些活动特征的抑制。实际上，网络的注意力转移到了不太突出的词上。

比起我上面简单的描述，当然有更好的方法在神经网络中建立一致性检查。随着研究人员处理机器学习中更复杂的任务，连接网络模块的架构可能变得比每个细胞的架构更重要。“LSTM 对 GRU”是一个小分歧，而巨大的分歧可能来自多个核国家的连接方式。鉴于这种复杂性，某种程度上保证思维的连贯性是必不可少的；这些模块中至少有一个将负责检查一致性，并改变输入的显著性。

商业领袖们请注意:你将如何被打乱？

原文：https://towardsdatascience.com/attention-business-leaders-how-will-you-be-disrupted-1c58e6d6833d?source=collection_archive---------7-----------------------

随着“街上”关于从汽车行业到零售的各种市场中断的所有谈论，人们很容易做出反应，改变得太快太快，而不是战略性地做对你的业务线最有利的事情(据路透社报道，截至 7 月底，亚马逊出现在 10%的美国收益电话会议上)。但是确切地说什么是干扰以及管理者如何制定策略和运行项目来应对它？除了在世界顶级商学院的演讲厅和组织的董事会会议室里被弹来弹去——颠覆实际上意味着什么，意味着什么，商业领袖如何才能在它的加速发展面前走在前面？

我们都见过它，无论你是用 Spotify 播放你最喜欢的播放列表，还是用智能手机上的面部检测功能捕捉你女儿把捣碎的豌豆洒在餐厅地毯上的完美照片，还是在你的周年纪念日享受那个俯瞰大海的无价房间(谢谢 Airbnb)。我敢提一下亚马逊对许多行业的影响吗？问问 Blue 围裙吧，它令人失望的 IPO(2017 年最糟糕的 IPO)可能要归功于亚马逊最近宣布的餐包业务。我们每天都看到并利用这些颠覆性的业务，并欢迎服务和产品的变化，以使我们的生活变得更好，但我们有时会忘记，在数字革命之前，这些产品有大量的工作变体。

正如下图中标准普尔 500 公司的平均寿命所示，我们的每一个组织都会以越来越快的速度发生中断，但这就是我们如何准备业务模式，以更好地利用技术、人力资本和教育来实现数据民主化，将中断的力量掌握在现任者手中，并让他们更好地了解客户是谁以及什么对他们的体验和需求最有价值。

How do organizations prepare themselves for change, and how can the change be fast and methodical enough to allow for longer age?

生产力:优化学习向量

在山姆·哈里斯的“醒来”播客中，他的“心灵景观”一集追踪了与《连线》杂志创始人凯文·凯利的对话，他们讨论了人类智能的机会以及如何在日益变化的技术景观中应用于学习，“学校里应该教的唯一素养…是你可以学会如何学习…这将是你未来需要的唯一真正的元技能，如果你想要知识，你问一台机器“ ”对话的一个寓意是:我们正在更多地利用技术，老年人口将比最近的技术原住民更难接触到技术，但这些年轻人最终会在接触未来技术时遭受脱节(想想在手机周围长大的千禧一代，以及伴随增强现实长大的新一代)。组织现在必须开发“学习如何学习的课程”。技术的强度正以指数级增长，远远超过人类学习如何使用它们的速度，对此的唯一解药是与技术互动并尽可能快地利用技术的超增长思维。我们如何帮助组织内的员工和团队“更好”和更快地学习以跟上时代？

我最近从全日制 MBA 毕业，被微软聘为我们客户值得信赖的顾问，帮助他们实现数据资产现代化和数字化转型。学习曲线非常陡峭，为了取得成功，我知道我不能用过去的方式学习(模拟学习过程，适应孤立的环境，等待组织在正式计划中“教导”)。事情发展得太快了，我的客户需要合作伙伴来指导他们实现现代化，并走在路上。在新的角色中，我不再依赖这些旧的学习方式，而是依赖数据、技术和人。我正在利用由我们的内部可视化仪表板 Power BI 驱动的洞察力，来更好地了解我们的客户如何与我们的产品进行交互，以及我们如何才能更好地为他们服务。LinkedIn 一直是一个救生员，它在组织内寻找能够对某些重点领域发表意见的从业者，并在虚拟环境中与他们快速联系，或者使用 Cortana 驱动的“聊天机器人”来安排会议。最有帮助的是什么；通过云连接到微软的内部产品集会，在飞机上或健身房的跑步机上接收视频和主题演讲，将这些应用到我的客户的业务挑战中，并通过 Linkedin 的 Pointdrive 在一个易于访问的门户网站上向客户发送数字资源。通过各种工具和环境的组合，我能够更好地快速、数字化地获取见解，这优化了我的学习途径，让我能够做出更好的决策，以有效的解决方案指导我的客户，并以见解为支持，帮助他们实现现代化。

这还没有结束，其他提高生产力的协同工具可以包括机器学习模型，它可以在任何数据存储库的基础上自动运行，通过自学收集更多数据，并创建额外的见解，从而为经理提供更好的决策。我们从未像现在这样迫切地需要提供智能，如果我们不能快速学习、教育和部署，那么我们的客户就必须转向别处。保持员工之间的联系、创造力和轻松协作可以提高生产力，增强学习，让企业有更多时间专注于自己的专有职能。人们学习得越快，他们就能越快地在组织内以适当的速度分配价值。

云:大数据是挑战，而不是解决方案

CFO’s measure the impacts of cloud on their line of business: https://www.bdo.com/getattachment/022227f4-aa2e-4a8b-9739-b0ad6b855415/attachment.aspx?2017-Technology-Outlook-Report_2-17.pdf

然后是云。尽管如此，许多人还是对这个该死的东西感到困惑。在 Michael Friedman 的书《谢谢你的等待》中，他给出了一些来自 Business Insider 的关于当前对云技术的理解的数据，大约 51%的受访者(包括千禧一代)认为暴风雨天气会影响云。这就是云用通俗的语言表达的意思；一个大型计算机服务器产业的所有者(想象一家拥有一个装满未被使用的计算机的仓库的企业)有一天决定将这些额外的计算机未使用的额外存储和计算空间货币化——噗，云诞生了。伴随着云而来的是“大数据”这个模糊的术语，以及它是如何解决一切问题的。然而，我们周围的大量数据正随着时间的推移而增加，从我们在拿铁里放了什么到我们观看在线内容的时间。乘坐波音 747 飞行可以产生 500 千兆字节的数据，而乘坐一辆自动驾驶汽车一分钟可以产生几乎相同的数据。大数据现在是一个挑战，我们必须有条不紊地应对—我们如何吸收、存储大数据，以及我们从中组织大数据并将其转化为有洞察力的决策的庄园是解决方案。没那么容易。在过去的两年里，我们收集了人类历史上 90%的数据。对不断增加的数据摄取做些什么是企业努力制定的策略。

https://www.ibm.com/watson/advantage-reports/future-of-artificial-intelligence/kevin-kelly.html

对企业来说，更大的问题是: “我如何利用云来影响我的底线并产生新的收入流？”

除了可扩展性、安全性、从多个设备的可访问性和全球地理定位等，您现在可以将数据放在一个中心位置并进行分析。这里是我们输入人工智能和机器学习的地方。什么是机器学习？数据被输入机器，让机器用数据构建猜测框架。随着你将更多的数据输入到机器的框架中，它会越来越好地预测这个不断发展的框架的未来结果，它可以无限超越以这种方式建立更好的预测能力。使用这种基于数据的学习课程，机器现在可以自动化决策和任务，或者帮助人类做出决策和执行任务。听起来太超前了？现在假设你是罗尔斯·罗伊斯，世界上最大的喷气发动机生产商之一(也是微软的重要客户)，你想知道你的发动机什么时候会出故障，这是基于世界各地的发动机传感器给你的遥测数据。在罗尔斯·罗伊斯的例子中，他们只有在发动机运转时才得到报酬，你可以称之为“现收现付”或“发动机即服务”。IOT 传感器将关于发动机健康状况的信号发送到云端，通过一些机器学习和计算，预测性维护算法允许这些发动机在任何实际问题发生之前就被标记为需要维护，允许维护人员在相关机场等待飞机降落，手里有正确的工具来让发动机完全健康，而不占用运行时间。这是一个真实的故事:

https://www . rolls-royce . com/country-sites/north America/news/yr-2016/pr-11-07-2016-RR-takes-total care-digital-with-Microsoft-and-Singapore-airlines . aspx

这些技术不是科幻小说，也不仅仅是为财大气粗的组织准备的。它们是真正的解决方案，正在帮助当今世界上成千上万的企业通过数字化转型抗击颠覆性的力量。总的来说，信息很清楚，你将如何被打乱取决于你的组织需要多长时间来开发最佳的学习和生产力环境，拥抱大规模云计算和处理，以及利用人工智能和机器学习来做出更好的预测和更智能的行动。

让我们继续对话，分享我们的想法和愿景，帮助相互教育，并思考我们如何才能更好地迎接数字化转型，创造更美好的明天。

请随时在 linkedIn 上给我发消息:【https://www.linkedin.com/in/derekwesleyrussell/

自然语言处理中的注意模型快速介绍

原文：https://towardsdatascience.com/attention-models-in-nlp-a-quick-introduction-2593c1fe35eb?source=collection_archive---------2-----------------------

鸣谢:以下是 wildml 文章的节略版:http://www . wild ml . com/2016/01/attention-and-memory-in-deep-learning-and-NLP/

典型的 seq2seq 模型通常是我的博客中解释的形式:https://medium . com/forward-data-science/sequence-to-sequence-model-introduction-and-concepts-44d 9 b41 CD 42d

当假设语言到语言的翻译时，例子:解码器应该仅基于来自编码器的最后隐藏状态来生成翻译。这个向量必须编码我们需要知道的关于源句子的一切。它必须完全抓住它的意义。用更专业的术语来说，这个向量是一个句子嵌入。事实上，如果你使用主成分分析或 t-SNE 对低维空间中不同句子的嵌入进行降维，你可以看到语义相似的短语最终彼此接近。这真是太神奇了。

然而，假设我们可以将一个潜在的很长的句子的所有信息编码到一个向量中，然后让解码器仅基于此产生一个好的翻译，这似乎有点不合理。假设你的源句子有 50 个单词长。英语翻译的第一个单词可能与源句子的第一个单词高度相关。但这意味着解码器必须考虑 50 步前的信息，并且这些信息需要以某种方式编码到矢量中。众所周知，递归神经网络在处理这种长程相关性方面存在问题。理论上，像 LSTMs 这样的架构应该能够处理这个问题，但是在实践中，长程依赖仍然是个问题。例如，研究人员发现，反转源序列(将其反馈到编码器)会产生明显更好的结果，因为它缩短了从解码器到编码器相关部分的路径。类似地，给一个输入序列输入两次似乎也有助于网络更好地记忆东西。它使事情在实践中更好地工作，但它不是一个原则性的解决方案。大多数翻译基准都是在法语和德语之类的语言上完成的，这些语言与英语非常相似(甚至汉语的词序也与英语非常相似)。但是在有些语言中(比如日语),一个句子的最后一个单词很可能是英语翻译中的第一个单词。在这种情况下，颠倒输入会使事情变得更糟。那么，有什么选择呢？注意力机制。

有了注意机制，我们不再试图将完整的源句子编码成固定长度的向量。相反，我们允许解码器在输出生成的每一步“关注”源句子的不同部分。重要的是，我们让模型学习根据输入的句子和它到目前为止产生的结果注意什么。因此，在排列得相当好的语言中(比如英语和德语)，解码器可能会选择按顺序处理事情。当产生第一个英语单词时注意第一个单词，等等。这就是在神经机器翻译中通过联合学习对齐和翻译所做的，如下所示:

这里，y 是解码器产生的翻译单词，x 是我们的源句子单词。上图使用了双向循环网络，但这并不重要。重要的是，每个解码器输出字 yt 现在取决于所有输入状态的加权组合，而不仅仅是最后一个状态。a 是定义每个输入状态在每个输出中所占比重的权重。所以，如果 a32 是一个很大的数字，这将意味着解码器在产生目标句子的第三个单词时，非常注意源句子的第二个状态。a 通常归一化为 1(因此它们是输入状态的分布)。注意力的一个很大的优势是它给了我们解释和想象模型正在做什么的能力。例如，当一个句子被翻译时，通过可视化注意力权重矩阵 a，我们可以理解模型是如何翻译的:

这里我们看到，当从法语翻译成英语时，网络顺序地关注每个输入状态，但有时在产生输出时，它一次关注两个单词，例如在将“la Syrie”翻译成“Syria”时。

注意力的成本

如果我们仔细观察注意力的等式，我们会发现注意力是有代价的。我们需要为输入和输出单词的每个组合计算一个注意值。如果你有一个 50 个单词的输入序列，并生成一个 50 个单词的输出序列，那将是 2500 个注意值。这还不算太糟糕，但是如果你进行字符级的计算，并且处理由数百个标记组成的序列，上述的注意力机制可能会变得非常昂贵。这似乎是一种浪费，根本不是人类正在做的事情。事实上，它更类似于内存访问，而不是注意力，在我看来，这有点用词不当(下文将详细介绍)。尽管如此，这并没有阻止注意力机制变得非常流行，并在许多任务中表现出色。

注意力的另一种方法是使用强化学习来预测关注的大致位置。这听起来更像人类的注意力，这就是视觉注意力的循环模型所做的。

机器翻译之外的关注

上面的注意机制可以应用于任何循环模型。

在展示、参与和讲述中，作者将注意力机制应用于生成图像描述的问题。他们使用卷积神经网络来“编码”图像，并使用具有注意力机制的递归神经网络来生成描述。通过可视化注意力权重(就像翻译示例中一样)，我们解释了在生成单词时模型在看什么:

注意 Seq2Seq 与 PyTorch:学习反转序列

原文：https://towardsdatascience.com/attention-seq2seq-with-pytorch-learning-to-invert-a-sequence-34faf4133e53?source=collection_archive---------1-----------------------

TL；DR:在这篇文章中，你将学习如何实现序列到序列的模型，注意和不注意一个简单的例子:反转一个随机生成的序列。

你可能已经看到了数千篇解释序列间模型和注意力机制的文章，但是很少有用代码片段来说明的。
下面是一个非详尽的文章列表，讨论序列对序列算法和注意力机制:

Tensorflow 官方回购
py torch seq 2 seq 教程
Guillaume Genthial 的博客文章
Chris Olah 对增强 RNNs 的解释
Dimitri bahda nau 的参考文件
一个关于关注的好帖子
一篇显示 Luong vs Bahdanau 的论文引起关注

注意力和序列对序列模型

这些模型用于将输入序列映射到输出序列。序列是一种数据结构，其中有一个时间维度，或者至少有一种“顺序”感。想想把法语句子(=序列)翻译成英语句子，或者做语音到文本(音频->文本)，或者文本到语音，等等。
“注意力”是序列对序列模型的变体，允许在上述领域进行重大改进。

Source: http://cs224d.stanford.edu/lectures/CS224d-Lecture8.pdf

这是一个非常简单的序列对序列模型的例子。目标是通过将红色单词输入编码器(红色箭头)，并依次输出英语单词(蓝色箭头)，将德语翻译成英语。请注意 h3 的重要性，因为所有未来(蓝色)预测都依赖于它…

作为一名机器学习工程师，几年前我开始与 Tensorflow 合作。在 PyTorch 与 Tensorflow 的争论中，我不支持任何一方，但我认为 Tensorflow 有很多优势，其中包括丰富的 API 和贡献者的素质。我发现的主要缺点是很难调试，随着时间的推移，我对定制我的网络的困难感到有点沮丧(例如定义定制损耗..).我认为深度学习不仅仅是从网络上复制和粘贴代码，而是能够实现自己的网络并理解每个陷阱。

因此，我决定向 PyTorch 迈出一步。

PyTorch 并不完美，但它的优势在于更具 pythonic 性，并且与 Tensorflow 相反，它的动态计算图使调试和运行单元测试更容易(您确实在代码中使用测试，对吗？).最重要的是，PyTorch 提供了一个很好的 API(虽然不如 Tensorflow 提供的那么好),并允许您定义自定义模块。强迫你重写模块可以让你明白你在做什么。例如，我过去在设计 seq2seq 模型时一直使用 Tensorflow AttentionWrapper，但是在 PyTorch 中实现一个定制的注意力模块使我能够完全理解它的微妙之处。
说够了，让我们深入代码。

如果你想不看就开始玩，代码在这里:https://github.com/b-etienne/Seq2seq-PyTorch

我们想要解决的问题

我们的目标是在一个简单的任务上比较两个模型的效率，这个任务包括学习如何颠倒一个给定的序列。这两个模型是具有编码器和解码器的序列到序列模型，一个具有注意机制，一个没有。

为什么？

这个问题是你能想到的最简单的序列间任务之一。然而，如果你决定开发你自己的架构，而它在这个简单的任务上失败了，它可能不会在任何地方导致更复杂的任务…所以让我们的模型在这个任务上工作是确保我们的代码工作的好方法。

生成数据

我们从四个字母“a”、“b”、“c”、“d”的集合或“词汇”中挑选出可变长度的随机序列。目标是还原的输入，比如:“ABCD”->“dcba”。

编码器

编码器是 seq2seq 模型的“监听”部分。它由递归层组成(RNN、GRU、LSTM，选择您最喜欢的)，在此之前您可以添加卷积层或密集层。这里最重要的部分是在编码器中输入数据之前使用pack _ padd _ sequence和pad _ pack _ sequence助手。
由于我们使用的是批次数据，因此批次中的每个项目(序列)都有不同的长度。我们用 0 填充批次中的所有序列，直到最长序列的长度(这是可变长度批次中的经典过程，您可以在网上找到关于这个主题的大量帖子)。pack _ padd _ sequence和pad _ pack _ sequence帮助我们在向编码器提供数据时处理这些无信息的填充。

解码器

解码器是负责输出预测的模块，这些预测将用于计算损失。简而言之，注意力解码器将解码器的输出作为输入，并决定关注哪个部分来输出预测。不加注意，只使用编码器的最后一个隐藏状态。
在我们的例子中，解码器对目标序列进行顺序操作，并且在每个时间步都将:
-一个输入(目标序列中的下一个字符或者之前发出的字符)
-一个隐藏状态
-取决于你是否在使用注意力的其他参数作为输入。

由于我们将使用不同的编码器，让我们定义一个基本的解码器模块:

RNN 解码器

序列到序列模型的最简单形式由 RNN 编码器和 RNN 解码器组成。以下是我们的 RNN 解码器的外观:

注意力解码器

现在是我们使用注意力的部分。同样，如果您想了解背后的理论，请参考本文开头的链接。我仍然不清楚在计算注意力权重之前或之后是否应该调用递归单元。我尝试了两种方法，它们都导致了收敛。如果您知道答案，我将非常感谢您在下面的评论中对这一点的任何帮助。
以下是我们的参与者代码(我参考代码中的“倾听、参与和拼写”部分):

注意力评分功能

注意力解码器的核心是注意力模块。这个模块允许我们计算不同的注意力得分。两种主要的变体是龙和巴达瑙。据说 Luong 是“乘法”的，而 Bahdanau 是“加法”的。详情见上述文件。

因此，我们定义了一个定制的注意力模块，其中包含计算张量之间相似性的选项(有时称为键和查询)。使用相似性得分的 softmax 函数将得分归一化以定义概率。该模块使用自定义的 mask_3d 函数，用于在权重计算中屏蔽填充。我就交给你去实现了:)

将其全部放入 Seq2Seq 模块中

一旦定义了编码器和解码器，我们就可以创建一个 Seq2Seq 模型，用 PyTorch 模块封装它们。我不会详述解码过程，但只是为了你的知识，我们可以在解码过程中选择教师强制和预定采样策略。如果你以前从未听说过，一定要上网查一下。我会把这个模块作为家庭作业留给你，但如果你需要任何帮助，可以联系我。

结果

我们在训练时使用交叉熵损失。在评估过程中，我们以预测序列和目标序列之间的 Levenshtein 距离来计算准确度。没有注意力的 seq2seq 模型达到平台期，而有注意力的 seq2seq 更容易学习任务:

让我们在注意力模型的推断过程中可视化注意力权重，以查看该模型是否确实学习了。正如我们所见，对角线从左上角到右下角。这表明网络学会首先关注最后一个字符，最后关注第一个字符:

哦，对了，如果你对序列到序列模型感兴趣，我写了一篇关于神经图灵机的文章 这里😃

使用 FastAI 和即时频率变换的音频分类

原文：https://towardsdatascience.com/audio-classification-using-fastai-and-on-the-fly-frequency-transforms-4dbe1b540f89?source=collection_archive---------1-----------------------

使用 PyTorch 和 fastai v1 在训练时间从原始音频生成频谱图的实验。

介绍

虽然深度学习模型能够帮助解决许多不同类型的问题，但图像分类是课程和框架最普遍的例子，通常充当“你好，世界”的介绍。FastAI 是一个建立在 T2 py torch T3 基础上的高级库，它使得开始分类图像变得非常容易，并通过一个例子展示了如何在 T4 只用四行代码 T5 训练一个精确的模型。随着库的新 v1 发布，一个名为 data_block 的 API 允许用户以灵活的方式简化数据加载过程。在夏天参加了 Freesound 通用音频标记 Kaggle 竞赛之后，我决定重新调整我的一些代码，以便利用 fastai 在音频分类方面的优势。本文将简要介绍如何在 Python 中处理音频文件，给出一些关于创建声谱图图像的背景知识，然后展示如何利用预先训练的图像模型 ，而不需要 事先生成图像。

用于生成这篇文章内容的所有代码将在这个资源库中提供，包括示例笔记本。

音频文件到图像

起初，将音频文件归类为图像似乎有点奇怪。图像毕竟是二维的(RGBA 声道可能有第三维)，而音频文件只有一个时间维(声道可能有第二维，例如立体声对单声道)。在这篇文章中，我们将只看单声道的音频文件。每个音频文件还有一个相关的采样率，即每秒钟音频的样本数。如果一个 3 秒钟的音频片段的采样率为 44，100 Hz，这意味着它由 3*44，100 = 132，300 个连续数字组成，代表气压的变化。在 Python 中操作音频的最好的库之一叫做 librosa 。

clip, sample_rate = librosa.load(filename, sr=None)
clip = clip[:132300] # first three seconds of file

虽然这种表示方式确实能让我们了解某个片段在任一时间点有多响亮或安静，但它提供的关于存在哪些频率的信息非常少。这个问题的一个非常常见的解决方案是，取信号的小重叠块，并让它们通过快速傅立叶变换 (FFT)，将它们从时域转换到频域。对每个部分进行 FFT 运算后，我们可以将结果转换为极坐标，从而得到不同频率的幅度和相位。虽然相位信息在某些情况下可能有用，但我们主要使用幅度，并将其转换为分贝单位，因为我们的耳朵在对数尺度上感受声音。

n_fft = 1024  # frame length 
start = 45000 # start at a part of the sound thats not silence
x = clip[start:start+n_fft]
X = fft(x, n_fft)
X_magnitude, X_phase = librosa.magphase(X)
X_magnitude_db = librosa.amplitude_to_db(X_magnitude)

取大小为 1024 的 FFT 将产生具有 1024 个频率仓的频谱。然而，频谱的后一半是多余的，所以实际上我们只使用前(N/2)+1 个频段，在这种情况下是 513。

为了生成关于整个文件的信息，我们可以对 1024 个样本窗口进行 FFT，并将其滑动 512 个样本(跳跃长度),使得窗口彼此重叠。对于这个三秒钟的文件，我们将得到 259 个频谱，然后我们可以看到一个二维图像。这被称为短时傅立叶变换(STFT)，它让我们看到不同的频率如何随时间变化。

stft = librosa.stft(clip, n_fft=n_fft, hop_length=hop_length)
stft_magnitude, stft_phase = librosa.magphase(stft)
stft_magnitude_db = librosa.amplitude_to_db(stft_magnitude)

在本例中，我们可以看到，几乎所有有趣的频率数据都低于 12，500 Hz。除了有许多被浪费的箱子之外，这不能准确地显示人类如何感知频率。除了响度，我们还能听到对数标度的频率。我们听到的频率“距离”从 50 赫兹到 100 赫兹，就像我们听到的频率从 400 赫兹到 800 赫兹一样。

这就是为什么许多人使用梅尔频谱图的一些原因，它将频率仓转换成梅尔标度。Librosa 允许我们轻松地将一个常规的声谱图转换成 melspectrogram，并让我们定义想要多少个“仓”。我们还可以指定我们希望频段被划分成的最小和最大频率。

mel_spec = librosa.feature.melspectrogram(clip, n_fft=n_fft, hop_length=hop_length, n_mels=n_mels, sr=sample_rate, power=1.0, fmin=fmin, fmax=fmax)
mel_spec_db = librosa.amplitude_to_db(mel_spec, ref=np.max)

在这些 Mel 频谱图中，我使用了 64 个频段(n _ mels)。唯一的区别是，在右边，我指定我只关心 20Hz 和 8000Hz 之间的频率。这大大减少了每个变换的大小，从原来的每个时间步长 513 个面元。

用 fastai 对音频频谱图进行分类

虽然可以对原始音频波形数据进行分类，但使用图像分类器对 melspectrograms 进行分类非常流行，而且效果很好。为了做到这一点，我们必须使用与上面类似的代码将整个数据集转换为图像文件。使用我的 GCP 实例上的所有 CPU，这花费了我大约 10 分钟的处理时间。我使用以下参数来生成 melspectrogram 图像:

n_fft = 1024
hop_length = 256
n_mels = 40
f_min = 20
f_max = 8000
sample_rate = 16000

在这篇文章的其余部分，我使用了谷歌 Magenta 团队的 NSynth 数据集。这是一个有趣的数据集，由 305，979 个音符组成，每个音符长 4 秒。我把数据集精简到只有声音产生的音符，使事情更容易管理。目标是在 10 个可能的乐器系列中，对每个音符生成的乐器系列进行分类。

使用 fastai 的新的data_block API，用所有的声谱图图像数据及其标签构建一个DataBunch对象变得非常容易——在这个例子中，我使用正则表达式在文件名上抓取了所有的标签。

NSYNTH_IMAGES = 'data/nsynth_acoustic_images'
instrument_family_pattern = r'(\w+)_\w+_\d+-\d+-\d+.png$'
data = (ImageItemList.from_folder(NSYNTH_IMAGES)
          .split_by_folder()
          .label_from_re(instrument_family_pattern)
          .databunch())

一旦我加载了数据，我就实例化了一个名为 resnet18 的预训练卷积神经网络 (CNN)，并在光谱图上对其进行了微调。

learn = create_cnn(data, models.resnet18, metrics=accuracy)
learn.fit_one_cycle(3)

仅用了 2 分 14 秒，我就得到一个在验证集(与训练集完全分离的一组工具)上准确率达到 84%的模型。虽然这个模型肯定是过度拟合的，但这是在没有任何类型的数据扩充或正则化的情况下，一个非常好的开始！

通过利用 fastai 的ClassificationInterpretation类，我们可以看看错误来自哪里。

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix(figsize=(10, 10), dpi=60)

看起来木槌和吉他越来越混淆，而簧片和铜管乐器最容易混淆。利用这些信息，我们可以更仔细地观察这些仪器的光谱图，并尝试确定是否有更好的参数来区分它们。

在训练中生成光谱图，为什么？

如果将音频从图像中分类如此有效，你可能会问为什么在训练期间生成频谱图是有益的(与以前相反)。这有几个很好的理由:

生成图像的时间 在前面的例子中，我花了 10 多分钟生成所有的声谱图图像。每次我想尝试一组不同的参数，或者可能生成一个普通的 STFT 而不是 melspectrogram，我都必须重新生成所有这些图像。这使得快速测试大量不同的配置变得困难。
磁盘空间 同样，每当我生成一组新的图像时，它们会占用大量的硬盘空间，这取决于转换的大小和数据集本身。在这种情况下，我生成的图像占用了超过 1GB 的存储空间。
数据扩充 提高图像分类器性能的最有效策略之一是使用数据扩充。然而，常规的图像变换(旋转、翻转、裁剪等)对光谱图没有多大意义。最好是在时域中转换音频文件，然后在将它们发送到分类器之前将它们转换成频谱图。
GPU vs CPU 过去，我总是在 CPU 上使用 librosa 进行频率转换，但在 GPU 上使用 PyTorch 的 [stft](https://pytorch.org/docs/master/torch.html#torch.stft)方法会更好，因为它应该快得多，并且能够一次处理一批图像(而不是一次处理一个图像)。

如何在训练中生成光谱图？

在过去的几天里，我一直在尝试为音频文件创建一个新的 fastai 模块。在阅读了伟大的新 fastai 文档之后，我能够编写一些基本类来加载原始音频文件，并使用 PyTorch 在 GPU 上批量生成频谱图。我还编写了一个定制的create_cnn函数，该函数将接受预先训练的图像分类器，并修改它们以在单个通道(光谱图)上工作，而不是最初训练的 3 个通道。令我惊讶的是，代码的运行速度几乎和图像分类一样快，没有额外的生成实际图像的步骤。现在，设置我的数据如下所示:

tfms = get_frequency_batch_transforms(n_fft=n_fft, 
                                      n_hop=n_hop, 
                                      n_mels=n_mels,
                                      sample_rate=sample_rate)
data = (AudioItemList
            .from_folder(NSYNTH_AUDIO)
            .split_by_folder()
            .label_from_re(instrument_family_pattern)
            .databunch(bs=batch_size, tfms=tfms))

fastai 库也支持一种预览批处理的好方法:

data.show_batch(3)

预训练模型的微调与之前完全相同，只是这次第一个卷积层被修改为接受单一输入通道(感谢 fastai 论坛上的 David Gutman)。

learn = create_cnn(data, models.resnet18, metrics=accuracy)
learn.fit_one_cycle(3)

这一次训练只需要多花 30 秒，并且在验证集上有 80%的情况下，在 3 个时期之后只有稍微较低的准确度！以前在 CPU 上生成图像时，一次生成一个图像需要 10 多分钟。这为更快速地调整声谱图参数以及从增强音频文件计算声谱图的实验开辟了可能性。

未来的工作

既然可以动态生成不同的频谱表示，我对尝试为原始音频文件增加数据非常感兴趣。从音高变换到时间拉伸(librosa 中可用的方法)，再到简单地随机抽取音频片段，有很多可以尝试的。

我还感兴趣的是，这里使用的预训练模型实际上是在音频文件而不是图像文件上训练的，结果会好多少。

感谢你花时间阅读我的第一篇博文！如果您有任何更正或意见，请告诉我。同样，你可以在 https://github.com/jhartquist/fastai_audio 的查看所有的代码和完整的笔记。

资源

FastAI docs
py torch 1.0 版文档
torchaudio :这篇文章的灵感来源
傅立叶变换的精彩介绍:https://jackschaedler . github . io/circles-sines-signals/DFT _ introduction . html
用于机器学习的语音处理:滤波器组、梅尔频率倒谱系数(MFCCs)以及它们之间的内容
强烈推荐 Python 中的音频信号处理课程:音乐应用的音频信号处理

基于 web 的 ML 的音频功能

原文：https://towardsdatascience.com/audio-features-for-web-based-ml-555776733bae?source=collection_archive---------4-----------------------

深度学习的学生面临的第一个问题是对 MNIST 数据集中的手写数字进行分类。这是最近在 deeplearn.js 的帮助下移植到网络上的。网页版相对于相对干巴巴的 TensorFlow 教程有着鲜明的教育优势。你可以立即对模型有一种感觉，并开始对什么可行什么不可行建立直觉。让我们保留这种交互性，但将域改为音频。这篇文章为听觉上的 MNIST 做了准备。我们将把重点放在识别语音命令上，而不是识别手写数字。我们将这样转换声音:

转换成这样的图像，称为 log-mel 光谱图，在下一篇文章中，将这些图像输入到同样类型的模型中，这些模型可以很好地进行手写识别:

我在这里讨论的音频特征提取技术足够通用，适用于所有类型的音频，而不仅仅是人类语音。这篇文章的其余部分解释了如何做到这一点。如果你不在乎，只想看代码，或者玩一些现场演示，请便！

为什么？

神经网络正在复兴，这是有充分理由的。从识别人脸和图像到下围棋，计算机正在许多具有挑战性的任务上击败人类。神经网络的基本原理相对简单，但细节可能会变得相当复杂。幸运的是，非人工智能专家可以感觉到可以做些什么，因为许多输出非常吸引。不幸的是，这些演示本质上大多是可视化的，要么是计算机视觉的例子，要么是生成图像或视频作为其主要输出。这些例子很少是交互式的。

预处理音频听起来很难，我们必须这样做吗？

原始音频是一种压力波，每秒采样数万次，并存储为一组数字。这是相当多的数据，但有神经网络可以直接摄取它。Wavenet 使用原始音频序列进行语音到文本和文本到语音，而没有任何明确的特征提取。不幸的是它很慢:在一个 2s 的例子上运行语音识别在我的笔记本上花了 30s。在网络浏览器中实时进行这项工作还不太成熟。

卷积神经网络(CNN)是最近计算机视觉领域有如此多有趣工作的一个重要原因。这些网络被设计用于处理代表 2D 图像的矩阵，因此一个自然的想法是获取我们的原始音频并从中生成图像。在语音识别论文中，从音频生成这些图像有时被称为前端。为了强调这一点，这里有一个图表解释了为什么我们需要做这一步:

从音频生成图像的标准方式是逐块查看音频，并在频域中进行分析，然后应用各种技术将数据转化为非常适合机器学习的形式。这是声音和语音处理中的常见技术，在 Python 中有很好的实现。TensorFlow 甚至有一个用于从音频中提取频谱图的自定义操作。

在网络上，这些工具是缺乏的。Web Audio API 使用AnalyserNode几乎可以做到这一点，正如我在过去的中展示的，但是在数据处理的上下文中有一个重要的限制:AnalyserNode (nee RealtimeAnalyser)是仅用于实时分析。您可以设置一个OfflineAudioContext并通过分析器运行您的音频，但您会得到不可靠的结果。

另一种方法是不使用网络音频 API，有许多JavaScript 库可能会有所帮助。由于不完整或被放弃的原因，它们都不太合适。但是这里有一个从原始音频中提取 Mel 特征的图解。

音频特征提取

我找到了一个音频特征提取教程，在 TypeScript 中实现这个特征提取器时我紧紧跟随。接下来的内容可能是该教程的有用补充。

让我们从一个音频例子开始(一个男人说“左”这个词):

这是作为时间函数压力的原始波形图:

我们可以对整个信号进行 FFT，但它会随着时间发生很大变化。在我们上面的例子中,“左”发音只需要 200 毫秒，大部分信号是无声的。相反，我们将原始音频信号分解成重叠的缓冲区，间隔一个跳跃长度。让我们的缓冲区重叠可以确保我们不会错过在缓冲区边界发生的任何有趣的细节。选择正确的缓冲区和跳数长度是一门艺术:

选择太小的缓冲区，你最终会得到一个过于详细的图像，并使你的神经网络训练在一些不相关的细节上冒险，只见树木不见森林。
选择太大的缓冲区，你最终得到的图像会太粗糙而没有用。

在下图中，您可以看到五个完全缓冲区相互重叠 50%。仅出于说明目的，缓冲和跳跃持续时间很长(分别为 400 毫秒和 200 毫秒)。在实践中，我们倾向于使用更短的缓冲区(例如 20-40 ms)，甚至更短的跳跃长度来捕捉音频信号的微小变化。

然后，我们在频域中考虑每个缓冲器。我们可以使用快速傅立叶变换(FFT)算法来实现这一点。这种算法给出了复数值，我们可以从中提取幅度或能量。例如，这里是其中一个缓冲区的 FFT 能量，大约是上图中的第二个，说话者开始说“left”的“le”音节:

现在，假设我们对上一步中生成的每个缓冲区都这样做，取每个 FFT 阵列，而不是将能量显示为频率的函数，垂直堆叠阵列，使 y 轴代表频率，颜色代表能量。我们得到了一个光谱图:

我们可以把这个图像输入我们的神经网络，但是你会同意它看起来很稀疏。我们浪费了太多的空间，而且没有太多的信号让神经网络进行训练。

让我们跳回 FFT 图，将图像放大到我们感兴趣的区域。这个图中的频率集中在 5 KHz 以下，因为扬声器没有产生特别高的频率声音。人类的听觉倾向于对数，所以我们可以在对数图上看到相同的范围:

让我们像上一步一样生成新的频谱图，但不是使用能量的线性图，而是使用 FFT 能量的对数图:

看起来好一点，但还有改进的空间。与高频相比，人类在识别低频音调的微小变化方面要好得多。Mel 标度将纯音的音高与其实际测量的频率相关联。为了从频率到 Mel，我们创建了一个三角形滤波器组:

上面的每个彩色三角形都是一个窗口，我们可以用它来表示声音的频率。将每个窗口应用于我们之前生成的 FFT 能量，将得到 Mel 频谱，在这种情况下是 20 个值的数组:

将它绘制成光谱图，我们得到了我们的特征，log-mel 光谱图:

上面的 1s 图像是使用用 TypeScript 编写的音频特征提取软件生成的，我已经公开发布了该软件。这里有一个演示，可以让你在自己的音频上运行特征提取器，还有github 上的代码。

处理实时音频输入

默认情况下，特征提取器前端采用固定的音频缓冲区作为输入。但是要制作一个交互式音频演示，我们需要处理连续的音频数据流。因此，当新的音频进来时，我们需要生成新的图像。幸运的是，我们不需要每次都重新计算整个 log-mel 谱图，只需要重新计算图像的新部分。然后，我们可以在右侧添加新的声谱图部分，并删除旧的部分，从而产生一部从右向左播放的电影。[StreamingFeatureExtractor](https://github.com/google/web-audio-recognition/blob/master/audio-features/src/StreamingFeatureExtractor.ts)类实现了这个重要的优化。

但是有一个警告:它目前依赖于ScriptProcessorNode，这是众所周知的丢弃样本。我试图通过使用大的输入缓冲区来尽可能地减轻这一点，但真正的解决方案将是在可用时使用 AudioWorklets 。

包扎

实现说明:这里是 JS FFT 库的比较，表明 Emscripten 编译的 KissFFT 是最快的(但仍然比原生的慢 2-5 倍)，也是我使用的。

这里有一个健全性检查，将我的基于网络的特征提取器的输出与其他库的输出进行比较，最著名的是 librosa 和 AudioSet :

这三个实现产生的图像是相似的，这是一个很好的完整性检查，但是它们并不完全相同。我还没有找到时间，但如果有一个一致的跨平台音频特征提取器，那么用 Python/C++训练的模型可以直接在 web 上运行，反之亦然，这将是非常值得的。

我还应该提到，虽然 log-mel 特性通常被严肃的音频研究人员使用，但这是一个活跃的研究领域。另一种称为每通道能量归一化(PCEN) 的音频特征提取技术似乎至少在某些情况下表现更好，比如处理远场音频。我还没有时间深入研究细节，但是理解它并将其移植到 web 上似乎也是一项有价值的任务。

主要感谢迪克·里昂指出了我的特征提取代码中的一些错误。如果你准备好深入研究声音理解，请阅读他的“人类和机器听觉”。

好了，概括一下，我们已经从流式音频中生成了 log-mel 频谱图图像，可以输入到神经网络中。哦对了，真正的机器学习部分？这是下一个帖子——敬请关注！

原载于smus.com。

TensorFlow 中的音频处理

原文：https://towardsdatascience.com/audio-processing-in-tensorflow-208f1a4103aa?source=collection_archive---------0-----------------------

短时傅立叶变换的一种实现

我发现 TensorFlow 中的音频处理很难，下面是我的修复方法

有无数种方法可以执行音频处理。在 TensorFlow 中用人工神经网络运行带有音频输入的实验的通常流程是首先预处理音频，然后将其馈送到神经网络。

当一个人想要在计算图的中间执行音频处理时，会发生什么呢？
TensorFlow 附带了快速傅立叶变换的实现，但这还不够。

在这篇文章中，我将解释我们如何实现它，并提供代码，以便短时傅立叶变换可以在计算图中的任何地方使用。

代码

所有代码都可以在我的GitHub:tensor flow中音频处理。请随意在那里添加您的贡献。

音频预处理:常用方法

当开发一个使用深度神经网络的语音识别引擎时，我们需要将音频输入到我们的神经网络，但是…预处理这个输入的正确方法是什么？

有两种常见的方式来表示声音:

时域:每个样本代表气压的变化。
频域:在每个时间戳，我们指示每个频率的振幅。

尽管深度神经网络非常擅长自动学习特征，但依靠携带我们试图解决的任务所需信息的已知特征总是一个好主意。

对于大多数应用，包括语音识别引擎，我们感兴趣的特征被编码在声音的频域表示中。

频谱图和短时傅立叶变换

频谱图显示了信号的频率成分如何随时间变化，并且可以从时域信号中计算出来。
用来做这件事的操作或变换被称为短时傅立叶变换。

我可以让神经网络知道如何学习这个操作，但事实证明学习 1 个隐藏层是非常复杂的。(参考通用逼近定理)

我可以添加更多的层，但是我想保持神经网络的复杂性尽可能小，并且只在最需要的地方学习特征。

我已经使用了开发自动语音识别引擎的例子，但是使用声谱图作为深度神经网络的输入对于涉及非语音音频的类似任务也是常见的，例如降噪、音乐流派分类、鲸叫声检测等。

我想提到的一个特别的项目是来自谷歌大脑团队的 Magenta ，他的目标是为音乐和艺术世代推进机器智能的艺术状态。

为什么是 TensorFlow？

在实现人工神经网络时，我主要使用 TensorFlow，因为我还没有在 TF 中找到短时傅立叶变换的实现，所以我决定实现我们自己的。
【编辑:2018 年 6 月 4 日】—从 TensorFlow 1.3 开始，他们增加了一些有用的 DSP 功能。

深度学习实践者可能想要在计算图中包括短时傅立叶变换(我朋友的 STFT)也可能有多种原因，而不仅仅是作为单独的预处理步骤。

请记住，我并没有把重点放在提高效率上。在用于生产之前，它应该(也将会)得到改进。

你需要知道的事情

为了理解 STFT 是如何计算的，您需要理解如何计算离散傅里叶变换。

离散傅立叶变换— DFT

对于那些不熟悉这些概念的人来说，这一部分可能显得很专业，但是我认为为了对代码有一个完整的理解，通过一些数学是很重要的。

理论
当函数和它的傅立叶变换都被离散化的对应物代替时，它被称为离散傅立叶变换(DFT)。

给定一个矢量 x 的 n 输入幅值如:

{x[0], x[1], x[2], x[3], …, x[N-1]}

离散傅立叶变换产生一组 n 个频率幅度。

DFT 由下式定义:

DFT equation

k 用于表示频域序数
n 用于表示时域序数
n 是要变换的序列的长度。

快速傅立叶变换 快速傅立叶变换是 DFT 方程的有效实现。信号的大小必须限制为 2 的幂。

这解释了为什么 N(输入到 DFT 函数的信号大小)必须是 2 的幂，以及为什么它必须以零填充。

在 python 中可以很简单地检测出 x 是否是 2 的幂:

我们只需要它的一半 实数正弦波可以用欧拉恒等式表示为复数正弦波的和

因为 DFT 是线性函数，所以正弦波之和的 DFT 是每个正弦波的 DFT 之和。对于频谱情况，有两个 DFT，一个针对正频率，一个针对负频率，它们是对称的。
这种对称性出现在可以被视为正弦波的无限(或有限)和的真实信号中。

开窗在时域截断信号会导致频域出现纹波。
如果您认为截断信号就像应用了一个矩形窗口，这是可以理解的。在时域中应用窗口会导致频域中的卷积。
当我们将两个频域表示卷积在一起时，会产生纹波。

如果你有兴趣的话，可以找到更多关于 spectral_leakage 的信息。

下面是一个在 Python 中实现窗口的示例:

零相位填充

为了使用 FFT，输入信号的长度必须是 2 的幂。如果输入信号的长度不合适，可以在信号本身的开头和结尾附加零。
因为零样本最初位于输入信号的中心，所以我从中间分割填充信号，并交换这两部分的顺序。

下一个代码片段展示了如何在 TensorFlow 中对一批输入执行此操作:

FFT、幅度和相位 现在，您已经拥有了计算频谱图幅度(分贝)和信号相位所需的一切:

短时傅立叶变换

现在，您已经知道如何计算 DFT 来评估信号的频率成分。
当信号的频率成分随时间变化时，STFT 用于分析信号的频率成分。
你可以这样做:

获取信号片段。
将这些信号从剩余的信号中分离出来，并将 DFT 应用于每个片段。
沿着每个线段滑动此窗口。

DFT 系数是时间和频率的函数。

完整的代码分为两部分: helpers.py 和 stft.py 。

结论

在 TensorFlow 中执行 STFT 的可能性允许机器学习实践者在计算图中的任何地方执行信号从时域到频域的变换。新工具总是带来新的想法，我们希望这篇文章将成为开发新的深度学习解决方案的新想法的来源。

用于图像分类的增强

原文：https://towardsdatascience.com/augmentation-for-image-classification-24ffcbc38833?source=collection_archive---------2-----------------------

分类图像时面临的问题？不要烦恼！增援来了。！

在处理图像数据时遇到的一个问题是图像的不一致性(有些图像太大或太小，有些是矩形而不是正方形，等等)。另一个经常面临的问题是训练集中图像的数量，这经常导致过度拟合。为了处理这些问题，我概述了一种使用增强变换的技术——对训练集中的图像进行变换，以提高模型识别图像不同版本的能力。这增加了模型拥有的信息的广度。它现在变得更适合于从不同对比度、大小、不同角度等图像中识别目标对象。

为了展示增强是如何工作的，我们查看了狗对猫数据集，并利用了深度学习库 fast.ai ，该库由杰瑞米·霍华德和雷切尔·托马斯创建，基于 PyTorch 构建。本帖灵感来源于 fast.ai 深度学习 part 1 v2。

一、基准模型

为了将图像分类为狗或猫，我们使用 resnet34 来训练模型(在 Apil Tamang 撰写的这个令人敬畏的博客中有更多关于 resnet 架构的内容！).我们首先使用学习率 0.03 和 1 个历元来训练没有数据扩充的模型。

The baseline model

由此我们可以看到0.98584.的验证准确性

这里有一个混乱矩阵:

因此，我们看到 26 张图片——2000 张图片中的 20 只猫和 6 只狗被错误分类。

二。应用增强变换

为了减少这种分类错误，我们现在增加训练数据，看看是否有改进。我们既可以从自顶向下的转换中选择，也可以从侧面转换中选择。下面快速浏览一下这些类型所涉及的内容:

基本变换—角度(旋转)和光照的变化
侧面变换—角度和光照的变化+围绕垂直轴翻转
自上而下的变换—角度和光照的变化+围绕水平轴翻转并旋转 90、180、270 度。

这里我们使用侧面变换，因为我们有从侧面拍摄的狗和猫的图片(与从上面拍摄的相反)，它们可能需要水平翻转，而不是垂直翻转。下面是猫图像上的 6 种随机侧面变换:

Side-on transformations

由于图像的性质，自上而下的变换在这里并不合适——猫或狗的颠倒图像很少见！

在训练该网络时，学习速率保持不变，以便观察仅由于增强而导致的准确度差异。当我们使用增强来训练网络时，对于每个时期，生成每个图像的新变换。因此，该模型在每个时期看到相同数量的图像(与原始训练数据中的数量一样多)，尽管每次都是这些图像的新版本。因此，模型看到的图像范围随着每个时期而增加。

ResNets 之类的网络是预先训练的，也就是说，除了完全连接的层之外，该架构为每一层都预先计算了一组权重。在之前训练模型时，我们使用了 ResNet34 预先计算的权重。但是这一次，由于我们使用了新的训练图像集，我们设置了Precompute = False来确保模型从头开始计算新模型的激活。如果不这样做，我们将仍然使用对应于原始训练数据的预计算激活，不会给我们带来太多的准确性改进。

Training the network with the transformed images

现在我们得到了一个验证精度0.98779,这是对以前模型的一个改进。

从上面的混淆矩阵中，我们看到这次我们错分了 22 张图片；与以前相比错误的减少。因此，我们提高了模型的预测能力。

三。测试时间增加

虽然增强技术有助于给我们一个更好的模型，但预测准确性可以通过所谓的测试时间增强(TTA)来进一步提高。为了理解为什么需要这样做，让我们先来看看一些分类错误的图片:

我们在这里看到，由于对比度差，图像是矩形而不是正方形，或者因为狗/猫在图像中的比例很小，一些图像被错误分类。例如，看一看狗的矩形图像。当模型尝试预测此图像时，它只看到图像的中心(默认情况下裁剪为中心)。因此，它无法预测图像是狗还是猫。

为了减少这样的错误，我们使用 TTA，其中我们预测原始测试图像以及同一图像的 4 个随机变换的类别。然后，我们取预测的平均值来确定图像属于哪一类。

这背后的直觉是，即使测试图像不太容易做出预测，变换也会改变它，使得模型有更高的机会捕捉狗/猫的形状并相应地进行预测。

使用 TTA，我们现在只需要 16 张错误分类的图片就可以得到一个99.199的验证精度。

结论

虽然基线 ResNet34 模型很好地拟合了数据，给出了非常好的结果，但是应用增强变换和 TTA 减少了错误分类错误，提高了模型的准确性。我们在这里讨论的只是基本的增强技术，如翻转和旋转，但是 GANs 也可以用来生成不同风格的图像，正如本文中所建议的。这可能会更有效。

除了对图像进行增强之外，看看如何将增强应用于结构化数据以提高性能也是很有趣的，就像它在非结构化数据中所做的那样！让我知道你对此的想法！！

参考

GitHub 回购换代码
程序员实用深度学习，第一部分，作者杰瑞米·霍华德
王凯峰 Luis Perez 利用深度学习在图像分类中增加数据的有效性

关于我:我毕业于 USF 大学数据科学专业，本科学习计算机科学，在构建预测和推荐算法以及为金融和零售客户提供商业见解方面有 2 年的经验。我对将我的机器学习和深度学习知识应用于现实世界问题的机会感到兴奋。请点击这里查看我的其他博客！
领英:https://www.linkedin.com/in/neerja-doshi/

八月版:深度学习

原文：https://towardsdatascience.com/august-edition-deep-learning-84268d0db79c?source=collection_archive---------12-----------------------

8 篇必读文章

人工智能(AI)正逐渐嵌入我们生活的方方面面。有趣的是，随着这一过程的进行，它变得越来越不引人注目，越来越人性化。这部分是由于机器学习的方式。有许多不同的方法用于训练和开发人工智能模型；一些专注于解决特定的问题和任务，而另一些使用“特征学习”来分析数据表示，发现模式并从中学习。深度学习架构是后者的架构，通常用“网络”构建，与我们大脑的神经结构没有什么不同。事实上，现在出现了人工智能如此有效以至于超过我们人类专家的情况。

看看最新的国际象棋计算巨头:AlphaZero。由谷歌的 DeepMind 团队开发，它结合了深度神经网络(用于最伟大的人类棋手所依赖的模式识别)和通用强化学习算法。这意味着当它开始时，除了游戏规则之外，它没有任何数据，只是通过自我改进来学习。在 4 个小时内，它已经取得了足够的进展，在 100 场比赛中击败了 2016 年国际象棋引擎世界冠军 Stockfish 8。此外，Stockfish 8 每秒钟分析 7000 万个头寸，而 AlphaZero 在同一时间段内只分析 8 万个头寸。AlphaZero 的方法(通过强化学习)是在不依赖“数据”的情况下识别和改进模式，这与你所期望的机器智能相差甚远。

浏览本月关于深度学习的精选，你可以参加一个基础速成班，并开始更好地理解这项技术的一些当前应用。随着你对人工智能背后的科学越来越熟悉，你可能会开始意识到你们比你想象的有更多的共同点…祝你好运！约书亚·弗莱明 —编辑

我如何在 Python 中使用深度学习实现 iPhone X 的 FaceID

由诺曼·迪帕洛 — 8 分钟阅读

新 iPhone X 讨论最多的功能之一是新的解锁方式，TouchID 的继任者:FaceID。创造了无边框手机后，苹果不得不开发一种简单快捷的解锁手机的新方法。

利用深度学习提升 FIFA 18 图形

通过 Chintan Trivedi — 6 分钟读取

游戏工作室花费数百万美元和数千个开发小时来设计游戏图形，试图使它们看起来尽可能接近现实。虽然图形在过去几年看起来非常逼真，但仍然很容易将它们与现实世界区分开来。

直观理解用于深度学习的卷积

由伊尔胡姆·沙夫卡特 — 15 分钟阅读

近年来，强大而通用的深度学习框架的出现，使得在深度学习模型中实现卷积层成为可能这是一项极其简单的任务，通常只需一行代码即可实现。

随机加权平均——一种获得深度学习最新成果的新方法

通过最大 Pechyonkin — 8 分钟读取

在这篇文章中，我将讨论两篇有趣的近期论文，它们提供了一种简单的方法，通过使用一种智能的集成方法来提高任何给定神经网络的性能。

必须知道深度学习(AI)中的信息论概念

通过 Abhishek Parbhakar — 6 分钟读取

信息论是一个重要的领域，对深度学习和人工智能做出了重大贡献，但对许多人来说却是未知的。信息论可以被视为深度学习的基本构建模块的复杂融合:微积分、概率和统计。

深度学习的“怪异”介绍

通过法维奥·巴斯克斯 — 14 分钟阅读

有关于深度学习的惊人介绍、课程和博文。我将在参考资料部分列出其中一些，但这是一种不同的介绍。

深度学习遇上物理学:受限玻尔兹曼机器

作者阿尔特姆·奥珀曼 — 8 分钟阅读

本教程是关于受限玻尔兹曼机器的两部分系列的第一部分，这是一种用于协同过滤的强大的深度学习架构。在这一部分，我将介绍受限玻尔兹曼机背后的理论。

浏览器中的深度学习:简明指南

由麦克施 — 7 分钟读完

我们将涉及提取原始的微型 YOLO 暗网模型，将其转换为 Keras，将其转换为 Tensorflow.js，进行一些预测，在 Tensorflow.js 中编写时捕获数据，以及轻松使用网络摄像头/图像进行预测。

八月版:当艺术遇上数据科学

原文：https://towardsdatascience.com/august-edition-when-art-meets-data-science-bbf4c8cf8f?source=collection_archive---------8-----------------------

8 篇必读文章。

使用 Keras 和直方图均衡化进行深度学习的图像增强

由瑞安 Allred — 12 分钟阅读。

深度神经网络，特别是卷积神经网络(CNN)，特别擅长图像分类任务。最先进的 CNN 甚至被证明在图像识别方面超过了人类的表现。

甘:与甘一起创作艺术

肯尼·琼斯 — 13 分钟阅读。

这里介绍的工作是 Kenny Jones 和 Derrick Bonafilia(都是威廉姆斯学院 2017 级)在 Andrea Danyluk 教授的指导下进行的长达一个学期的独立研究的结果。与本项目相关的代码可在https://github.com/rkjones4/GANGogh找到。

深度神经网络可以作曲吗？

Justin Svegliato — 9 分钟阅读。

当我去年九月开始读研时，我想尽快投入到深度学习的热潮中。当我在纽约作为一名软件开发人员工作时，我不断听到关于深度学习的令人惊讶的事情: DeepFace 可以像你我一样识别人脸， AlphaGo 在一场最初对人工智能来说似乎难以捉摸的游戏中摧毁了玩家， GANs 刚刚开始获得动力。

用机器学习预测逻辑的歌词

由汉斯·卡明 — 9 分钟阅读。

从中学开始，当我第一次听到他的歌曲“我所做的一切”时，逻辑就对我的生活产生了显著的影响。这首歌所属的混音带 Young Sinatra ，单枪匹马地让我成为了各种形式的嘻哈音乐的粉丝，向我介绍了我以前从未想过要听的新旧风格。

人工智能基因组黑客马拉松上的黑客数据艺术

克里斯汀·亨利(Kristin Henry)—7 分钟阅读。

不久前，我注意到一个有趣的黑客马拉松即将到来。人工智能基因组黑客马拉松聚焦于一种罕见的疾病( NF2 )。是的，我曾向自己保证不再参加任何黑客马拉松，但这太难以抗拒了。

神经网络和 3D 程序内容生成的未来

由山姆·施奈德手持 — 8 分钟阅读。

作为全球制作机构 MediaMonks 的一名创意技术专家，人们总是问我关于人工智能、人工智能、神经网络等方面的问题。它们是什么？他们能做什么？我们如何使用它们？这篇文章是我将写的探索人工智能、创造力和 3D 内容相遇的空间系列的第一篇。

黄画的蒙特利尔:神经风格网络

由 Gabriel Tseng — 6 分钟读取。

最近，CNN(卷积神经网络)的一个非常酷的应用是设计神经网络；这些包括分离一个图像的风格，另一个图像的内容，并把它们结合起来。

Pytorch 实现实时风格传输的感知损失

由李诗仙 — 6 分钟阅读。

在这篇文章中，我将简要回顾我在 Pytorch 中编写和训练实时风格转换模型的经历。这项工作在很大程度上基于 Abhishek Kadian 的实现，它工作得非常好。我做了一些修改，既是为了好玩，也是为了更熟悉 Pytorch。

我们也感谢最近加入我们的所有伟大的新作家加勒特·金斯曼、马尼什·巴尔、维哈尔·鞍马、约瑟夫·t·哈塞尔曼、叶戈尔·德芝、苏永胜、西亚瓦什·法赫米、韦达·孔杜鲁、萨姆·斯奈德举办的、穆拉特·武鲁库、塞斯·魏德曼、马鲁蒂·tech labs、阿明·奥利娅、沃尔夫·加贝、基里尔·丹尼柳克、诺亚·莫罗泽、詹姆斯·登斯莫尔、马頔·舒尔加、德万什·拉拉、

Auto-Keras，或者说如何用 4 行代码创建深度学习模型

原文：https://towardsdatascience.com/auto-keras-or-how-you-can-create-a-deep-learning-model-in-4-lines-of-code-b2ba448ccf5e?source=collection_archive---------3-----------------------

自动化机器学习是这个城市的新生事物，它会一直存在下去。它帮助我们创造出越来越好的模型，这些模型简单易用，API 也很棒。在这里，我会跟你谈谈 Auto-Keras，新的包 AutoML 与 Keras。

在开始之前，Matthew Mayo 引用了一句关于 AutoML 不是什么的名言:

AutoML 不是自动化数据科学。虽然毫无疑问存在重叠，但机器学习只是数据科学工具包中的许多工具之一，它的使用实际上并不影响所有数据科学任务。例如，如果预测将是给定数据科学任务的一部分，机器学习将是一个有用的组件；然而，机器学习可能根本不会在描述性分析任务中发挥作用。

那么，什么是自动机器学习呢？简而言之，这是一种自动化(【https://www.automl.org/automl/】)任务的方式:

预处理和清理数据。
选择并构建适当的特征。
选择适当的模型族。
优化模型超参数。
后处理机器学习模型。
批判性地分析获得的结果。

现在我们清楚了什么是 AutoML，什么是 Keras？

Keras 是一个高级神经网络 API，用 Python 编写，能够在 TensorFlow 、 CNTK 或 Theano 之上运行。它的开发重点是支持快速实验。能够以尽可能少的延迟从想法到结果是做好研究的关键。

这是由 Franç ois Chollet 创建的，是让深度学习对大众来说变得容易的第一步。

TensorFlow 有一个并不难的 Python API，但 Keras 让很多人很容易进入深度学习。需要注意的是，Keras 现已正式成为 Tensorflow 的一部分:

[## 模块:tf.contrib.keras | TensorFlow

编辑描述

www.tensorflow.org](https://www.tensorflow.org/api_docs/python/tf/contrib/keras)

太好了。现在我们知道了什么是 Keras 和 AutoML，让我们把它们结合起来。Auto-Keras 是用于自动机器学习的开源软件库。Auto-Keras 提供了自动搜索深度学习模型的架构和超参数的功能。

安装

pip install autokeras

用途

关于用法，我将使用他们网站上的一个例子。但是首先让我们比较一下如何用不同的工具来做同样的事情。我将使用著名但有时令人讨厌的 MNIST 数据集。

MNIST 是一个简单的计算机视觉数据集。它由手写数字图像组成，如下所示:

它还包括每个图像的标签，告诉我们它是哪个数字。

MNIST 在 TensorFlow 上使用热切执行:

资源:

[## 张量流/模型

模型-使用 TensorFlow 构建的模型和示例

github.com](https://github.com/tensorflow/models/blob/master/official/mnist/mnist_eager.py) [## 急切执行| TensorFlow

虽然急切执行使开发和调试更具交互性，但 TensorFlow 图形执行在以下方面具有优势

www.tensorflow.org](https://www.tensorflow.org/guide/eager)

不太容易，但在示例中解释得很好。TensorFlow 并不是深度学习最简单的工具，而是一个快速可靠的工具。通过急切执行，代码可读性更好。

MNIST 与 PyTorch:

资源:

[## py torch/示例

围绕 pytorch 在视觉、文本、强化学习等方面的一组例子。

github.com](https://github.com/pytorch/examples/blob/master/mnist/main.py)

MNIST 与 Keras:

资源:

[## keras-team/keras

keras -人类的深度学习

github.com](https://github.com/keras-team/keras/blob/master/examples/mnist_cnn.py)

您可以看到，到目前为止，Keras 是运行这个示例的最简单的包。这是一个很棒的包，具有令人敬畏的功能，从零到模型只需几分钟。

但是现在，蛋糕上的樱桃。

配有 Auto-Keras 的 MNIST:

是的，就这些。很简单，对吧？您只需要一个图像分类器，然后拟合数据并评估它。你在那里也有一个 final_fit ，它在找到最佳架构后正在进行最后的训练。

现在你已经有了图像分类器，BayesianSearcher，一个图形模块，一个预处理器，一个图层转换器，一个网络转换器，一个分类器生成器和一些实用程序。这是一个不断发展的包，请看看创作者的免责声明:

请注意，这是 Auto-Keras 的预发布版本，在正式发布之前仍在进行最终测试。本网站、其软件和网站上的所有内容都是在“按原样”和“按可用”的基础上提供的。Auto-Keras 对网站、其软件或任何内容的适用性或可用性不作任何明示或暗示的保证。Auto-Keras 对任何一方因使用库或内容而遭受的任何损失概不负责，无论此类损失是直接的、间接的、特殊的还是后果性的。对库的任何使用均由用户自担风险，用户将独自对任何计算机系统的损坏或由此类活动导致的数据丢失负责。如果您在网站上遇到任何错误、故障、功能缺失或其他问题，请立即通知我们，以便我们进行相应的纠正。非常感谢你在这方面的帮助。

无论哪种方式都是一个非常有用的令人惊叹的包，将来也会如此。有关 AutoML 和软件包的更多信息，请参见:

[## AutoML

BOHB 结合了贝叶斯优化和超波段的优点，以达到两全其美…

www.automl.org](https://www.automl.org/) [## 自动机器学习的现状

在过去的一年中，自动机器学习(AutoML)已经成为一个非常有趣的话题。最近的一个 KDnuggets…

www.kdnuggets.com](https://www.kdnuggets.com/2017/01/current-state-automated-machine-learning.html) [## 用 AutoML 生成带有 TPOT 的机器学习流水线

到目前为止，在这一系列的文章中，我们有:这篇文章将采用不同的方法来构建管道。当然可以…

www.kdnuggets.com](https://www.kdnuggets.com/2018/01/managing-machine-learning-workflows-scikit-learn-pipelines-part-4.html)

哦！如果你想要一个甚至更简单的方法来做 AutoML 和深度学习，而根本不用编码，请查看 Deep Cognition 和我在上面的帖子:

[## 深度认知让深度学习变得简单

在过去的一个月里，我有幸见到了 DeepCognition.ai 的创始人

becominghuman.ai](https://becominghuman.ai/deep-learning-made-easy-with-deep-cognition-403fbe445351) [## 深度认知的视频漫游

大家好！在本文中，我将与您分享几个视频，带您浏览深度认知的平台…

towardsdatascience.com](/a-video-walkthrough-of-deep-cognition-fd0ca59d2f76) [## 在朋友的帮助下进行深度学习

当你开始一个新的领域时，最好是从好的公司、朋友或好的社区开始，他们可以…

towardsdatascience.com](/deep-learning-with-a-little-help-from-my-friends-596ee10fd934)

自回归生成模型(PixelRNN，PixelCNN++)

原文：https://towardsdatascience.com/auto-regressive-generative-models-pixelrnn-pixelcnn-32d192911173?source=collection_archive---------2-----------------------

作者:哈什夏尔马，T2

生成模型是无监督学习的子集，其中给定一些训练数据，我们从相同的分布中生成新的样本/数据。有两种方法来模拟这种分布，其中最有效和最流行的是自回归模型、自动编码器和 GANs。

生成对手网络(GANs)和自回归模型之间的基本区别在于，GANs 学习隐式数据分布，而后者学习由模型结构强加的先验支配的显式分布。发行版可以是任何东西，例如类别标签、汽车或猫的图像。更简单地说，先验意味着一个量的概率分布。

自回归模型优于 GANs 的一些优点是:

1.提供了一种计算可能性的方法:这些模型具有返回显式概率密度的优势(与 GANs 不同)，使得它可以直接应用于压缩、概率规划和探索等领域

2.训练比 GAN 更稳定:训练 GAN 需要找到纳什均衡。由于目前没有这样做的算法，与 PixelRNN 或 PixelCNN 相比，训练 GAN 是不稳定的。

3.对离散和连续数据都有效:对于 GAN 来说生成离散数据很难，比如文本。

众所周知，GANs 能产生更高质量的图像，训练速度也更快。人们正在努力将这两种类型的优势整合到一个单一的模型中，但这仍然是一个开放的研究领域。在这篇博客中，我们将只关注自回归部分，其他的留待以后讨论。

无监督学习中最重要和众所周知的问题之一是对自然图像的分布建模，这也是我们选择写这篇博客的原因。

为了解决这个问题，我们需要一个易于处理和扩展的模型。PixelRNN、PixelCNN 是满足这两个条件的自回归模型的一部分。

这些类型的模型优选地用于图像补全。同样的原因是因为它在这类问题上比其他生成模型表现得更好。

像素 RNN

对这种网络建模的有效方法是使用概率密度模型(如高斯或正态分布)来量化图像的像素，作为条件分布的产物。这种方法将建模问题转化为序列问题，其中下一个像素值由所有先前生成的像素值确定。

为了处理像素值和分布之间的非线性和长期依赖关系，我们需要一个像递归神经网络(RNN)这样的表达序列模型。rnn 已经被证明在处理序列问题上非常有效。

条件独立性

FIGURE 2 : Pixels of an nxn image

网络在每行中一次一个像素地扫描一行图像。随后，它预测可能的像素值的条件分布。图像像素的分布被写成条件分布的乘积，并且这些值在图像的所有像素之间共享。

这里的目的是给(n×n)图像的每个像素分配一个概率 p(x)。这可以通过将像素 xi 的概率写成:

这是给定所有先前生成的像素的概率的第 I 个像素的概率。逐行逐像素地进行生成。此外，每个像素 xi 由所有三个颜色通道红色、绿色和蓝色(RGB)共同确定。第 I 个像素的条件概率变成:

因此，每种颜色都取决于其他颜色以及先前生成的像素。

由于我们现在可以知道我们的像素值的条件概率，为了获得适当的像素值，我们使用 256 路 softmax 层。该层的输出可以取 0-255 之间的任何值，即我们的像素值可以在 0-255 之间变化。

模型建筑:

有四种不同的架构可供使用，即:

行 LSTM、对角线 BiLSTM、全卷积网络和多尺度网络。

该网络由多达 12 层的二维 LSTMs 组成。使用的两种类型的 LSTM 层是，

行 LSTM :第一层是使用 a 类掩码的 7x7 卷积，接着是使用 B 类掩码的 3x1 卷积的输入到状态层，以及未被掩码的 3x1 状态到状态卷积层。然后，特征映射通过由 ReLU 和 b 型掩码组成的几个 1x1 卷积层，该架构的最后一层是 256 路 softmax 层。
对角线 BiLSTM :其架构与 Row LSTM 的唯一区别在于状态输入层和状态层。它有一个到具有掩码类型 B 的状态层的 1x1 卷积输入和一个到没有掩码的状态层的 1x2 卷积输入。

排 LSTM

隐藏状态(I，j) =隐藏状态(i-1，j-1)+隐藏状态(i-1，j+1)+隐藏状态(i-1，j)+ p(i，j)

这从上到下逐行处理图像，同时计算整行的特征。它捕捉像素上方的一个相当三角形的区域。然而，它不能捕获整个可用区域。

FIGURE 3 : input-to-state and state-to-state mapping for Row LSTM

对角线长度

pixel(i，j) = pixel(i，j-1) + pixel(i-1，j)。

这一层的感受野包括整个可用区域。处理过程沿对角线进行。它从顶角开始，在向两个方向移动的同时到达对面的角。

FIGURE 4 : input-to-state and state-to-state mapping for Diagonal BiLSTM

在这些网络中还使用剩余连接(或跳过连接)来提高收敛速度，并通过网络更直接地传播信号。

FIGURE 5 : Residual block for PixelRNNs. ‘h’ refers to the number of parameters.

蒙面卷积:

每层中每个输入位置的特征被分成三个部分，每个部分对应一种颜色(RGB)。为了计算 G 通道的值，我们需要 R 通道的值以及所有先前像素的值。类似地，B 通道需要 R 和 G 通道的信息。为了限制网络遵守这些约束，我们对卷积应用掩码。

我们使用两种类型的面具:

类型 A :此遮罩仅应用于第一个卷积层，并限制连接到当前像素中已经预测的那些颜色。
类型 B :该蒙版应用于其他图层，并允许连接到当前像素中的预测颜色。

掩码是网络的重要组成部分，它维护网络中的信道数量。

FIGURE 6 : Connectivity inside a masked convolution

损失函数和评估指标

这里，负对数似然(NLL)用作损失和评估度量，因为网络从值 0-255 预测(分类)像素值。

像素 CNN

PixelRNN 的主要缺点是训练非常慢，因为每个状态都需要顺序计算。这可以通过使用卷积层和增加感受野来克服。PixelCNN 使用标准卷积层来捕捉有界感受野，并同时计算所有像素位置的特征。它使用多个卷积层来保持空间分辨率。但是，没有使用池层。在卷积中采用掩码来限制模型违反条件依赖。

第一个图层是使用遮罩 A 的 7x7 卷积，其余图层使用 3x3 卷积和遮罩 b。然后，要素地图经过由 ReLU 激活和 1x1 卷积组成的两个图层。该架构的最后一层是 256 路 softmax 层。

与 PixelRNN 相比，PixelCNN 大大减少了训练时间。然而，图像生成仍然是顺序的，因为每个像素需要作为输入返回给网络以计算下一个像素。PixelCNN 的主要缺点是它的性能比 PixelRNN 差。另一个缺点是在感受野中存在盲点。CNN 对感受野的捕捉以三角形方式进行。它导致几个像素被排除在感受野之外，如下图所示。由于卷积网络捕捉有界感受域(不同于 BiLSTM)并一次计算所有像素的特征，这些像素不依赖于所有先前的像素，这是不希望的。卷积层不能完全处理感受野，从而导致像素值的轻微误算。遗漏的像素构成了盲点。

FIGURE 7 : Blind spot in a PixelCNN and its solution in Gated PixelCNN

FIGURE 8 : input-to-state and state-to-state mapping for PixelCNN

门控像素 CNN

它改进了 PixelCNN 的架构，同时匹配 PixelRNN 的对数似然性。

PixelRNN 优于 PixelCNN 的基本原因是它使用了 LSTM 层。LSTMs 的感受野包含网络中的所有相邻像素，同时它在 PixelCNN 中随着深度而增长。该方法中引入的主要改进或变化是使用以下激活代替 ReLU:

σ is the sigmoid non-linearity, k is the number of the layer, ⊙ is the element-wise product and ∗ is the convolution operator.

该模型的另一个主要改进是使用 CNN 通过使用堆栈来完全利用可用的感受野。PixelCNN 中的感受野是有限的，这导致从条件分布的计算中遗漏了几个像素，从而产生了 CNN 不能处理的盲点。该模型使用两层堆栈来处理以消除上述问题:

水平堆栈:以当前行为条件，将前一层的输出和垂直堆栈的输出作为输入。
垂直堆栈:以当前像素以上的所有行为条件。它没有任何掩蔽。它的输出被送入水平堆栈，感受野以矩形方式增长。

结果表明，门控 PixelCNN (3.03 位/dim)比 PixelCNN (3.14 位/dim)高出 0.11 位/dim，其性能与 PixelRNN (3.00 位/dim)相当，而花费的训练时间不到一半。

FIGURE 9 : A single layer in Gated PixelCNN architecture

像素 CNN ++

OpenAI 的这个模型做了一些修改，以提高 PixelCNN 的性能，同时保持其计算效率。值得注意的修改包括:

离散逻辑混合似然:soft max 层，用于计算像素的条件分布，尽管效率在内存方面非常昂贵。此外，它使梯度稀疏在训练初期。为了应对这一点，我们假设一个潜在的颜色强度类似于在变化自动编码器中使用的，具有连续分布。它被舍入到最接近的 8 位表示，以给出像素值。强度的分布是逻辑的，因此可以容易地确定像素值。这种方法是内存有效的，输出是较低的维度，提供了更密集的梯度，从而解决了这两个问题。
对整个像素进行调节 : PixelCNN 根据颜色(RGB)将模型分解为 3 个子像素，但这会使模型变得复杂。像素的颜色通道之间的依赖性相对简单，并且不需要深度模型来训练。因此，最好对整个像素而不是单独的颜色进行调节，然后在预测像素的所有 3 个通道上输出联合分布。
下采样 : PixelCNN 无法计算长程相关性。至于为什么比不上 PixelRNN 的性能，这也是 PixelCNN 的缺点之一。为了克服这一点，我们通过使用步长为 2 的卷积对层进行缩减采样。下采样减少了输入大小，从而提高了感受野的相对大小，这导致了一些信息损失，但可以通过添加额外的捷径连接来补偿。
快捷连接:模拟 U-net 的编解码结构。层 2 和 3 被下采样，然后层 5 和 6 被上采样。存在从编码器到解码器的剩余连接，以提供本地化信息。
Dropout :由于 PixelCNN 和 PixelCNN++的模型都非常强大，如果不进行正则化，它们很可能会溢出数据。因此，我们在第一次卷积后对剩余路径应用下降。

FIGURE 10 : Convolutional architecture with residual connections

PixelCNN++的性能远远超过 PixelRNN 和 PixelCNN。当在 CIFAR-10 上训练时，最佳测试对数似然是 2.92 比特/像素，相比之下，PixelRNN 是 3.0 比特/像素，门控 PixelCNN 是 3.03 比特/像素。此外，如果没有使用任何一个修改，性能下降，模型学习缓慢或者在某些情况下不能完全学习。关于这些实验的更多细节在论文中给出。

结论

实验表明，PixelCNN++可以用作变分自动编码器(VAE)中的解码器，这在正在进行的研究中具有应用，如可以在诸如 PixelGAN 的几篇研究论文中看到的。PixelCNN 迫使编码器学习更高级别的特征，因为网络本身可以处理较低维度的特征。将 VAEs、GANs 和自回归模型一起使用是一个活跃的研究领域。这些模型以及强化技术可以改进最先进的技术，并引领无监督/半监督学习领域的研究，以匹配监督学习中正在进行的研究水平。

参考文献

https://allenlu 2007 . WordPress . com/2017/08/19/pixel rnn-vs-gan-for-probabilical-generative-model/
【http://sergeiturukin.com/2017/02/22/pixelcnn.html
像素递归神经网络(范德奥尔德等人)2016(https://arxiv.org/pdf/1601.06759.pdf)
使用 PixelCNN 解码器的条件图像生成(范德奥尔德等人)2016(https://arxiv.org/pdf/1606.05328.pdf)
PixelCNN++用离散逻辑混合似然和其他修改改进 PixelCNN。(萨利曼斯等人)2017。(https://arxiv.org/pdf/1701.05517.pdf)
https://towards data science . com/summary-of-pixel rnn-by-Google-deep mind-7-min-read-938d 9871 D6 d 9
https://www . common lounge . com/discussion/99 e 291 af 08 e 2427 b 9d 961d 41 bb 12 c 83 b
极大极小博弈理论(https://en.wikipedia.org/wiki/Minimax)

代码

pixel cnn++:https://github.com/openai/pixel-cnn(tensor flow)
https://github.com/carpedm20/pixel-rnn-tensorflow(张量流)

自动标记堆栈溢出问题

原文：https://towardsdatascience.com/auto-tagging-stack-overflow-questions-5426af692904?source=collection_archive---------3-----------------------

Photo Credit: Pexels

自然语言处理最有趣的应用之一是自动推断和标记问题的主题。在这篇文章中，我们将从堆栈溢出问题和答案的探索性分析开始，然后我们将构建一个简单的模型来预测堆栈溢出问题的标签。我们将使用 Scikit-Learn 解决这个文本分类问题。让我们开始吧。

数据

对于这个项目，我们将使用 10%关于编程主题的堆栈溢出问答中的文本，它可以在 Kaggle 上免费获得。

探索性数据分析

因为 ggplot 是我们最喜欢的数据可视化工具之一。因此，我们将在 r 中进行 EDA。

装载必要的包装

library(readr)
library(dplyr)
library(ggplot2)
library(lubridate)
library(tidytext)
library(tidyverse)
library(broom)
library(purrr)
library(scales)
theme_set(theme_bw())

问题数据和标签数据是分开存储的，所以我们将分别读取它们。

questions <- read_csv("Questions.csv")
question_tags <- read_csv("Tags.csv")

标签数据

那么，最受欢迎的标签有哪些呢？

question_tags %>%
  count(Tag, sort = TRUE)

Figure 1

问题数据

每周问的问题数量:

questions <- questions[ -c(8:29)]
questions %>%
  count(Week = round_date(CreationDate, "week")) %>%
  ggplot(aes(Week, n)) +
  geom_line() + 
  ggtitle('The Number of Questions Asked Per Week')

Figure 2

比较特定标签随时间的增长或收缩:

tags <- c("c#", "javascript", "python", "r", "php")q_per_year <- questions %>%
  count(Year = year(CreationDate)) %>%
  rename(YearTotal = n)tags_per_year <- question_tags %>%
  filter(Tag %in% tags) %>%
  inner_join(questions) %>%
  count(Year = year(CreationDate), Tag) %>%
  inner_join(q_per_year)ggplot(tags_per_year, aes(Year, n / YearTotal, color = Tag)) +
  geom_line() +
  scale_y_continuous(labels = scales::percent_format()) +
  ylab("% of Stack Overflow questions with this tag") +
  ggtitle('Growth or Shrinking of Particular Tags Overtime')

Figure 3

标题中最常见的单词是什么？

title_word_counts <- title_words %>%
  anti_join(stop_words, c(Word = "word")) %>%
  count(Word, sort = TRUE)title_word_counts %>%
  head(20) %>%
  mutate(Word = reorder(Word, n)) %>%
  ggplot(aes(Word, n)) +
  geom_col(fill = "cyan4", alpha = 0.8, width = 0.6) +
  ylab("Number of appearances in question titles") +
  ggtitle('The most common words in the question titles') +
  coord_flip()

Figure 4

在标签类别中查找 TF-IDF

我们预计标签类别在标题内容方面会有所不同，因此它们之间的词频也会有所不同。我们将使用 tf-idf 来查找与特定标签最相关的标题词。

common_tags <- question_tags %>%
    group_by(Tag) %>%
    mutate(TagTotal = n()) %>%
    ungroup() %>%
    filter(TagTotal >= 100)tag_word_tfidf <- common_tags %>%
    inner_join(title_words, by = "Id") %>%
    count(Tag, Word, TagTotal, sort = TRUE) %>%
    ungroup() %>%
    bind_tf_idf(Word, Tag, n)tag_word_tfidf %>%
    filter(TagTotal > 1000) %>%
    arrange(desc(tf_idf)) %>%
    head(10)

Figure 5

我们将检查所有标签类别的顶级 tf-idf，以提取特定于这些标签的单词。

tag_word_tfidf %>%
  filter(Tag %in% c("c#", "python", "java", "php", "javascript", "android")) %>%
  group_by(Tag) %>%
  top_n(12, tf_idf) %>%
  ungroup() %>%
  mutate(Word = reorder(Word, tf_idf)) %>%
  ggplot(aes(Word, tf_idf, fill = Tag)) +
  geom_col(show.legend = FALSE, width = 0.6) +
  facet_wrap(~ Tag, scales = "free") +
  ylab("tf-idf") +
  coord_flip() +
  ggtitle('The 12 terms with the highest tf-idf within each of the top tag categories')

Figure 6

随时间变化

随着时间的推移，哪些单词和术语变得越来越频繁或越来越不频繁？这些可以给我们一种变化的软件生态系统的感觉，并让我们预测哪些词将继续增长的相关性。为了达到这个目的，我们需要得到每个单词的斜率。

questions$month<-month(questions$CreationDate)
questions$year <- year(questions$CreationDate)titles_per_month <- questions %>%
  group_by(month) %>%
  summarize(month_total = n())title_words <- questions %>%
  arrange(desc(Score)) %>%
  distinct(Title, .keep_all = TRUE) %>%
  unnest_tokens(word, Title, drop = FALSE) %>%
  distinct(Id, word, .keep_all = TRUE) %>%
  anti_join(stop_words, by = "word") %>%
  filter(str_detect(word, "[^\\d]")) %>%
  group_by(word) %>%
  mutate(word_total = n()) %>%
  ungroup()word_month_counts <- title_words %>%
  filter(word_total >= 1000) %>%
  count(word, month, year) %>%
  complete(word, month, year, fill = list(n = 0)) %>%
  inner_join(titles_per_month, by = "month") %>%
  mutate(percent = n / month_total)mod <- ~ glm(cbind(n, month_total - n) ~ year, ., family = "binomial")slopes <- word_month_counts %>%
  nest(-word) %>%
  mutate(model = map(data, mod)) %>%
  unnest(map(model, tidy)) %>%
  filter(term == "year") %>%
  arrange(desc(estimate))slopes

Figure 7

然后标出增长最快的 16 个单词:

slopes %>%
  head(16) %>%
  inner_join(word_month_counts, by = "word") %>%
  mutate(word = reorder(word, -estimate)) %>%
  ggplot(aes(year, n / month_total, color = word)) +
  geom_point(show.legend = FALSE) +
  geom_smooth(show.legend = FALSE) +
  scale_y_continuous(labels = percent_format()) +
  facet_wrap(~ word, scales = "free_y") +
  expand_limits(y = 0) +
  labs(x = "Year",
       y = "Percentage of titles containing this term",
       title = "16 fastest growing words in Stack Overflow question titles")

Figure 8

前 16 个收缩最快的单词:

slopes %>%
  tail(16) %>%
  inner_join(word_month_counts, by = "word") %>%
  mutate(word = reorder(word, -estimate)) %>%
  ggplot(aes(year, n / month_total, color = word)) +
  geom_point(show.legend = FALSE) +
  geom_smooth(show.legend = FALSE) +
  scale_y_continuous(labels = percent_format()) +
  facet_wrap(~ word, scales = "free_y") +
  expand_limits(y = 0) +
  labs(x = "Year",
       y = "Percentage of titles containing this term",
       title = "16 fastest shrinking words in Stack Overflow question titles")

Figure 9

N 元语法分析

n 元模型不仅用于开发一元模型，还用于开发二元模型和三元模型。二元模型是一个 n 元模型，表示 n =2。以下是问题标题中最常见的二元结构。

title_bigrams <- questions %>%
  unnest_tokens(bigram, Title, token = "ngrams", n = 2)title_bigrams %>%
  count(bigram, sort = TRUE)

Figure 10

我相信你会觉得它们毫无意义。让我们找到最常见的有意义的二元模型。

bigrams_separated <- title_bigrams %>%
  separate(bigram, c("word1", "word2"), sep = " ")bigrams_filtered <- bigrams_separated %>%
  filter(!word1 %in% stop_words$word) %>%
  filter(!word2 %in% stop_words$word)bigram_counts <- bigrams_filtered %>% 
  count(word1, word2, sort = TRUE)bigrams_united <- bigrams_filtered %>%
  unite(bigram, word1, word2, sep = " ")bigrams_united %>%
  count(bigram, sort = TRUE)

Figure 11

和最常见的三元模型:

questions %>%
  unnest_tokens(trigram, Title, token = "ngrams", n = 3) %>%
  separate(trigram, c("word1", "word2", "word3"), sep = " ") %>%
  filter(!word1 %in% stop_words$word,
         !word2 %in% stop_words$word,
         !word3 %in% stop_words$word) %>%
  count(word1, word2, word3, sort = TRUE)

Figure 12

那很有趣！

现在，我们将开发一个预测模型来自动标记堆栈溢出问题。我们将用 Python 来实现。

write.csv(total, file = "/Users/sli/Documents/total.csv", row.names = FALSE)

以下是问题和标记组合表的前五行:

import pandas as pd
total = pd.read_csv('total.csv', encoding='latin-1')total.head()

Figure 13

以下是第一个问题的全文:

total['Body'][0]

Figure 14

文本预处理

原始的文本数据是杂乱的，需要清理以便进行进一步的分析。我们从数据中排除 HTML 标签、链接和代码片段。

from collections import Counter
import numpy as np 
import string
import redef clean_text(text):
    global EMPTY
    EMPTY = ''

    if not isinstance(text, str): 
        return text
    text = re.sub('<pre><code>.*?</code></pre>', EMPTY, text)def replace_link(match):
        return EMPTY if re.match('[a-z]+://', match.group(1)) else match.group(1)

    text = re.sub('<a[^>]+>(.*)</a>', replace_link, text)
    return re.sub('<[^>]+>', EMPTY, text)

然后，我们为“Body”列中已清理的文本创建一个新的“Text”列。

total['Text'] = total['Body'].apply(clean_text).str.lower()
total.Text = total.Text.apply(lambda x: x.replace('"','').replace("\n","").replace("\t",""))

我们的数据中有超过 20，000 个独特的标签。

total['Tag'].nunique()

21981

为了简化问题，我们将只处理前 10 个最常用的标签，如下所示:

def plot_tags(tagCount):

    x,y = zip(*tagCount) colormap = plt.cm.gist_ncar #nipy_spectral, Set1,Paired  
    colors = [colormap(i) for i in np.linspace(0, 0.8,50)] area = [i/4000 for i in list(y)]   # 0 to 15 point radiuses
    plt.figure(figsize=(10,6))
    plt.ylabel("Number of question associations")
    for i in range(len(y)):
      plt.plot(i,y[i],marker='o',linestyle='',ms=area[i],label=x[i])    plt.legend(numpoints=1)
    plt.show()import collections
import matplotlib.pyplot as plt
tagCount =  collections.Counter(list(total['Tag'])).most_common(10)
print(tagCount)
plot_tags(tagCount)

Figure 15

total = total[(total.Tag == 'c#') | (total.Tag == 'java') | (total.Tag == 'php') | (total.Tag =='javascript') | (total.Tag =='jquery') | (total.Tag == 'android') | (total.Tag == 'c++') | (total.Tag == 'iphone') | (total.Tag == 'python') | (total.Tag == 'asp.net')]

文本文档的分类

我们将 scikit-learn 的单词包方法按标签对文本进行分类。所以，我们只对两列感兴趣——“文本”和“标签”。

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(total['Text'], total['Tag'], random_state=42, test_size=0.2, shuffle=True)

我们将尝试各种分类器，这些分类器可以有效地处理已经转换为稀疏矩阵的文本数据。

条形图显示每个分类器的准确性、训练时间(标准化)和测试时间(标准化)。

from __future__ import print_functionfrom time import time
import matplotlib.pyplot as pltfrom sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import HashingVectorizer
from sklearn.feature_selection import SelectFromModel
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.linear_model import RidgeClassifier
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import Perceptron
from sklearn.linear_model import PassiveAggressiveClassifier
from sklearn.naive_bayes import BernoulliNB, MultinomialNB
from sklearn.neighbors import NearestCentroid
from sklearn.utils.extmath import density
from sklearn import metricstarget_names=total['Tag'].unique()
def benchmark(clf):
    print('_' * 80)
    print("Training: ")
    print(clf)
    t0 = time()
    clf.fit(X_train_1, y_train)
    train_time = time() - t0
    print("train time: %0.3fs" % train_time)t0 = time()
    pred = clf.predict(X_test_1)
    test_time = time() - t0
    print("test time:  %0.3fs" % test_time)score = metrics.accuracy_score(y_test, pred)
    print("accuracy:   %0.3f" % score)if hasattr(clf, 'coef_'):
        print("dimensionality: %d" % clf.coef_.shape[1])
        print("density: %f" % density(clf.coef_))if opts.print_top10 and feature_names is not None:
            print("top 10 keywords per class:")
            for i, label in enumerate(target_names):
                top10 = np.argsort(clf.coef_[i])[-10:]
                print(trim("%s: %s" % (label, " ".join(feature_names[top10]))))
        print()if opts.print_report:
        print("classification report:")
        print(metrics.classification_report(y_test, pred,
                                            target_names=target_names))if opts.print_cm:
        print("confusion matrix:")
        print(metrics.confusion_matrix(y_test, pred))print()
    clf_descr = str(clf).split('(')[0]
    return clf_descr, score, train_time, test_timeresults = []
for clf, name in (
        (RidgeClassifier(tol=1e-2, solver="lsqr"), "Ridge Classifier"),
        (Perceptron(n_iter=50), "Perceptron"),
        (PassiveAggressiveClassifier(n_iter=50), "Passive-Aggressive")):
    print('=' * 80)
    print(name)
    results.append(benchmark(clf))

print('=' * 80)
print("Elastic-Net penalty")
results.append(benchmark(SGDClassifier(alpha=.0001, n_iter=50,
                                       penalty="elasticnet")))
print('=' * 80)
print("NearestCentroid (aka Rocchio classifier)")
results.append(benchmark(NearestCentroid()))print('=' * 80)
print("Naive Bayes")
results.append(benchmark(MultinomialNB(alpha=.01)))
results.append(benchmark(BernoulliNB(alpha=.01)))print('=' * 80)
print("LinearSVC with L1-based feature selection")
results.append(benchmark(Pipeline([
  ('feature_selection', SelectFromModel(LinearSVC(penalty="l1", dual=False,
                                                  tol=1e-3))),
  ('classification', LinearSVC(penalty="l2"))])))indices = np.arange(len(results))results = [[x[i] for x in results] for i in range(4)]clf_names, score, training_time, test_time = results
training_time = np.array(training_time) / np.max(training_time)
test_time = np.array(test_time) / np.max(test_time)plt.figure(figsize=(12, 8))
plt.title("Score")
plt.barh(indices, score, .2, label="score", color='navy')
plt.barh(indices + .3, training_time, .2, label="training time",
         color='c')
plt.barh(indices + .6, test_time, .2, label="test time", color='darkorange')
plt.yticks(())
plt.legend(loc='best')
plt.subplots_adjust(left=.25)
plt.subplots_adjust(top=.95)
plt.subplots_adjust(bottom=.05)for i, c in zip(indices, clf_names):
    plt.text(-.3, i, c)plt.show()

Figure 16

使用岭回归的分类器取得了迄今为止最好的结果。因此，我们打印出每个标签的精度和召回率。

model = RidgeClassifier(tol=1e-2, solver="lsqr")
model.fit(X_train_1, y_train)
predicted = model.predict(X_test_1)
from sklearn.metrics import classification_reportprint(classification_report(y_test, predicted, target_names=target_names))

Figure 17

我们也许可以通过参数调整来获得更好的结果，但是我把它留给你去做。

源代码可以在 Github 找到。我期待听到任何反馈或问题。

参考资料:

Scikit-Learn

文字挖掘用 R

自动转录:Python 中的 Google 语音 API 时间偏移

原文：https://towardsdatascience.com/auto-transcribe-google-speech-api-time-offsets-in-python-7c24c4db3720?source=collection_archive---------2-----------------------

转录音频文件或语音对世界各地的许多公司来说至关重要，正如我们所知，由人类转录的听的古老技术可能会导致致命的错误，并吃掉你的大量资源(人类)。它需要煞费苦心地注意转录每一个被记录的单词，有时，你必须处理多个音频文件。

【多么无聊】 ，正是 Shikamaru 如果被赋予转录的工作，他会说的话，这里是谷歌语音 API 及其最新添加的地方，时间偏移(时间戳)来拯救我们Shikamaru。

什么是 Google Speech API？

应用强大的神经网络模型将语音转换为文本
识别超过 110 种语言和变体
实时文本结果
成功的噪音处理
支持能够发送剩余或 gRPC 请求的设备
API 包括在识别的音频中说出的每个单词的开始和结束的 时间偏移值(时间戳)

设置 Google 云和 Python3 环境的步骤

在 Google Cloud 中注册一个免费层帐户需要一个 API 密钥，您可以申请一个免费层计划(365
天)。

Google Cloud Platform Dashboard

在 Google Cloud 中生成 API 密钥 按照以下步骤生成 API 密钥:

登录 谷歌云控制台
转到API 和服务
点击凭证凭证凭证
点击 创建凭证
选择 服务账号键

在服务账号中选择 新建服务账号
输入 服务帐户名
选择角色作为项目>所有者
保持 JSON 选项选中
点击创建

保存生成的 API 密钥文件
将文件重命名为api-key.json
api-key.json将被下载到您的电脑上

JSON file saved to computer

安装所需的 Python 模块

安装 谷歌语音 包
pip3 install -U google-cloud-speech
安装 Google API 包
pip3 install -U google-api-python-client

转换音频

Google Speech API 支持许多不同的编码。下表列出了支持的音频编解码器:

Google Audio Codecs Table

所有编码仅支持 1 声道(单声道)音频，音频应使用无损编码(FLAC 或 LINEAR16)传输。audacity
对我来说工作得很好，通过简单的用户界面，在 FLAC 中很容易将你的音频文件转换成单声道。

点击 立体声到单声道使用 Audacity ，学习如何转换音频文件。

点击 音频编码 了解更多信息。

Python 的代码

在这个 Python 脚本中，我们将使用 Google Speech API 的最新添加功能，
时间偏移 ，并在识别的音频中包含每个语音开始
和结束的时间偏移值(时间戳)。

时间偏移值代表从音频的
开始所经过的时间，增量为 100ms。

点击 用 Python 中的时间偏移量转录完整代码。

让我们从导入必要的库开始，创建credentials来从我们之前保存的api-key.json中获取
语音 API 凭证。

从本地存储器转录音频文件

这里，我们将定义transcribe_file_with_word_time_offsets().,它将音频和音频语言作为参数传递，并打印已识别的
单词及其时间偏移值(时间戳)。

导入必要的google.cloud库，并使用方法SpeechClient()使用
Google Cloud 验证凭证。

接下来，我们读取音频文件，并将其通过RecognitionAudio() 方法，按照RecognitionConfig()方法中指定的编码将音频数据存储到“audio”中。

将TRUE分配给参数enable_word_time_offsets使得RecognitionConfig()方法能够记录每个单词的时间偏移值(时间戳)。

response包含speech.recognize()、
返回给客户端的消息，如果成功。结果存储为零或顺序消息，如下图
所示。

 Note: **confidence** in the output shows the accuracy of speech
 recognition. The value is from 0.0 to 1.0, for low to high
 confidence, respectively.

confidence:0.93的值表明谷歌语音 API 在识别单词方面做了
非常好的工作。现在我们遍历results并打印单词及其时间偏移值(时间戳)。

从谷歌云存储中转录音频文件

这一段代码唯一的区别是，我们必须将音频文件的
Google Cloud URL 传递给gsc_uri，
方法transcribe_file_with_word_time_offsets()的第一个参数，其余的工作方式相同。

这些字连同它们的时间偏移值(时间戳)被打印出来作为
输出。

调用 main function argparse库的时间被用来解析执行期间
命令行中传递的参数。

我们正在运行一个if else循环，为本地和云端存储的音频文件调用适当的方法。

在端子中调用

通过键入–s “en-US” 提及语言类型和执行文件的文件路径。
python3 transcribe_time_offsets_with_language_change.py -s “en-US” Sample.flac

对于谷歌云类型\gs://cloud-samples-tests/speech/Sample.flac为路径，
为`python3 transcribe_time_offsets_with_language_change.py -s “en-US”
\gs://cloud-samples-tests/speech/Sample.flac``

云外壳中的调用

点击 Google 云壳 学习云壳中的基本操作。

在云壳中全局安装virtualenv，
，pip install –upgrade vitrualenv

安装virtualenv后，使用— python标志告诉virtualenv使用哪个
Python 版本:
virtualenv –python python3 env

接下来，我们需要激活virtuale。它告诉 shell 为 Python 使用 virtualenv 的
路径，
source env/bin/activate

Cloud shell 现在已经准备好使用终端调用中提到的命令
来执行我们的 Python 程序。

输出

恭喜你！这是你的转录数据以及每个单词的时间偏移值(时间戳)。

我们可以通过改变
文件配置中的参数来改进这些模型。语音识别可以通过改变
配置的参数来改善。

点击云语音 API 了解更多关于同步、异步和
流识别，以及如何改进或改变模型。

用于将 RBG 图像转换成灰度图像的自动编码器。

原文：https://towardsdatascience.com/autoencoder-for-converting-an-rbg-image-to-a-gray-scale-image-3c19a11031c9?source=collection_archive---------7-----------------------

H ello 世界！这不仅仅是另一个使用 MNIST 数据集重建数字的自动编码器教程。正如标题所示，这个自动编码器学习将 RGB 图像转换为灰度的功能，但你们中的许多人会想知道为什么我们需要基于深度学习的方法来解决这个问题，我可以只采用加权方法或亮度方法来将 RGB 图像转换为灰度图像。没错，解决这个问题的 DIP(数字图像处理)方法会比使用深网更有效，但是这个问题陈述只是为了学习的目的。所以，我们从主菜开始吧。

先决条件:应具备卷积神经网络、损失函数、反向传播的知识，熟悉 TensorFlow 和 Python。

问题陈述: 让自动编码器学习将 RGB 图像转换为灰度图像的函数。

介绍

自动编码器是一个深度神经网络，它试图学习函数【x】≈x，或者换句话说，它学习将其输入复制到其输出。这些自动编码器以这样的方式设计，它们不会学习完美地复制输入到输出，而是受到限制，它们学习复制大约(这就是我写 f(x) ≈ x 而不是 f(x) = x )** 的原因，并且只复制类似于训练数据的输入。通过这种方式，模型学习区分特征的优先级，并学习训练数据的有用属性。

网络由两部分组成，编码器函数 h = f(x) 和解码器函数 r = g(h) 负责输入图像的编码和重构。

编码器

编码器将输入压缩成其潜在空间表示。编码器功能可以用 h = f(x)来表示。

解码器

解码器从潜在空间表示中重构图像，并且它可以表示为 r = f(x)。

什么是潜在空间？ 是你的特色所在的空间。

有不同类型的自动编码器，如欠完整自动编码器、稀疏自动编码器、去噪自动编码器、变分自动编码器等。但是我们将关注并使用欠完整自动编码器来解决手头的问题。

欠完整自动编码器

在上面的段落中，我已经提到，我们以这样的方式设计自动编码器，它们通过在网络的架构(设计)中施加限制来学习从数据(数据分布)中优先化特征/属性。一种方法是通过约束潜在空间维度或者具有比输入数据【x】更小的维度。这有助于自动编码器从训练数据中学习显著特征。因此，潜在空间维数小于输入的自动编码器称为欠完备自动编码器。下面给出了图示。

The architecture of an autoencoder.

自动编码器通过最小化损失函数 L(x，g(f(x))) 来学习，其中 L 是损失函数，其因与 x 不同而惩罚(f(x))。 g(f(x)) 是自动编码器的编码和解码过程(也就是自动编码器的输出)。在我们的例子中，损失函数是均方误差，并且 x 是 RGB 图像。 g(f(x)) 是重建的灰度图像。损失函数惩罚了自动编码器，因为它不能重建图像的灰度版本。好了，理论到此为止，让我们开始编码吧！！

为训练和测试准备数据集

我已经从 TensorFlow 花卉数据集(由 3670 幅花卉图像组成)和 Olga Belitskaya 内核“花卉图像数据集”(来自 Kaggle )的测试数据中获取了自动编码器的训练数据。你可以从我在本教程底部标题“资源”下提供的链接下载数据。下载训练数据集后，您将看到一个文件夹“flower _ photos”，其中包含子文件夹“雏菊、蒲公英、玫瑰、向日葵和郁金香”，测试数据集文件夹名称为“flower _ images”，其中包含花卉图像。

一、准备培训资料

为了帮助准备数据集，我使用了 OpenCV 和 glob 库。OpenCV 是一个计算机视觉库，它具有计算机视觉算法的预建功能，而 glob 是一个 Unix 风格的路径名模式扩展，简单地说，根据您设置的规则，它将返回特定文件夹的内容。

第 1- 3 行:导入必要的包。
第 5 行:计数变量稍后将用于命名目的
第 7–11 行:这些变量保存了相应类型的花卉照片的路径。

您可以看到“flower _ photos”子文件夹中的图像名称不正确，对于不同类型的花，它们有不同的文件夹，因此，我们为所有的花创建了一个统一的文件夹，并将文件重命名为以下格式“ color_ < >”。jpg" ,因为稍后以编程方式读取会更容易。

4.第 13 行:路径名列表，稍后循环将在该列表中迭代。

5.第 17 行:从类型为“的给定路径中读取所有文件的名称。jpg" 。

6.第 21–30 行:使用 OpenCV 中的“cv2 . CVT color(…)”函数将图像转换为灰度。最后，RGB 和灰度图像被重命名并写入各自的新文件夹中。

二。准备测试数据

第 1–2 行:导入必要的库。

第 4 行:读取【flower _ images】文件夹中类型的所有文件名。png”。

第 5 行:稍后使用 count 变量进行命名。

第 7–11 行:使用 cv2.imread(filename，0)读取图像并转换为灰度图像，函数中的零表示该函数将自己读取并转换为灰度图像，而不是像前面的代码片段那样编写单独的代码行来转换为灰度图像。

训练和测试数据已经准备好了，让我们进入下一步，构建自动编码器。

构建自动编码器

I .导入库和数据集。

第一个代码片段帮助我们准备用于训练自动编码器的数据集。文件夹【彩色图像】和【灰度图像】中的图像总数为 3670 张。变量 "dataset_source" 中的第一幅图像与 "dataset_target" 中的灰度图像相同，索引相同。

我们希望训练数据的维数为[3670，128，128，3]，这是输入图像(彩色图像)，目标图像维数(灰度图像)为[3670，128，128，1]。因此，第 9–16 行首先用于读取彩色图像，然后追加到 Python 列表中，最后使用 "np.asarray()" 转换成 numpy 数组。

同样，对于灰度图像，第 18–24 行遵循与第 9–16 行相同的程序，但从中获得的尺寸是[3670，128，128]而不是[3670，128，128，1]。因此，必须向数据集目标添加一个额外的维度，

"np.newaxis" 对象为 "dataset_target" 增加了一个额外的维度，从而获得目标图像所需的维度[3670，128，128，1]。具有前面提到的维度很重要，因为张量流占位符将具有相同的维度。现在训练数据已经准备好并存储在变量“数据集 _ 目标”和“数据集 _ 源”中。让我们继续制作我们的自动编码器。

二。自动编码器架构

为什么要卷积自动编码器(CAE)？

我们将使用卷积自动编码器(CAE)而不是传统的自动编码器，因为传统的自动编码器(TAE)没有考虑到一个信号可能是其他信号的组合。另一方面，卷积自动编码器使用卷积算子来利用这种观察。他们学会提取有用的信号，然后试图重建输入。卷积自动编码器学习最小化重构误差的最佳滤波器，而不是手动设计卷积滤波器

第 5–6 行:图像上的卷积运算会产生一个激活图，该激活图包裹着一个非线性激活函数，以提高网络的泛化能力。这样，训练程序可以学习图像中的非线性模式。在这之后，我们在激活图上运行汇集操作以提取主导特征并降低激活图的维度以进行高效计算。(这样我们在合并操作后获得了我们的潜在空间)

第 11–12 行:对于上采样，使用最近邻插值，通过检查最近邻像素值对图像进行上采样。在下一步中，对上采样图像执行卷积运算，以使网络学习用于重构图像的最佳滤波器。我们还可以使用" TF . nn . transpose _ conv2d()"函数进行上采样，从而将学习最佳滤波器的任务留给模型。

三。损失函数

通常，为了训练自动编码器，输入图像和目标图像(自动编码器必须学习重建的内容)是相同的，但是对于我们的任务，输入图像是 RGB 格式，目标图像是灰度格式。这会强制自动编码器学习将 RGB 图像转换为灰度图像的功能。

第 1–2 行:回想一下，之前我们将数据集准备到与" tf.placheholder()" 函数非常相似的维度。“无”表示批量大小将在运行时确定。

第 4 行:RGB 图像作为输入数据被发送到之前定义的函数“def auto encoder()”，该函数返回存储在“AE _ outputs”变量中的灰度图像。

第 7 行:获得目标图像(所需灰度)与网络生成的灰度图像之间的差异，并将其存储在 loss 变量中。

第 8 行:我们使用 Adam optimizer 为网络找到正确的权重集，从而最大限度地减少损失。

第 10 行:初始化全局变量。

四。训练网络

注意:根据需要在变量“saving_path”中改变路径

第 1–2 行:常量，如批量大小和时期大小(数据集必须在自动编码器上完全运行的次数，此处为 50 次。).

第 8–9 行:使用变量“batch _ img”(输入图像)和“batch _ out”(目标图像)给出网络的输入数据。

第 11 行:网络将立即将32 幅图像(批次)作为输入，因此需要计算 1 个时期的批次总数，以运行第 18 行的循环内部。

第 13–15 行:创建一个会话对象并运行我们之前定义的初始化变量。

第 20 行:“sess . run()”用我们给定的输入数据和目标数据运行计算图(autoencoder)。

第 19–20 行:每批 32 张新图像被发送到网络中。

根据您的笔记本电脑配置，培训可能需要一些时间，但在网络运行 50 个时期后，这将生成输入数据的高质量灰度图像。

根据测试数据测试网络。

在训练时，我们保存了模型，现在我们恢复它用于测试目的。灰度转换后的图像存储在“gen _ gray _ images”目录下。

样本输出

Sample Images obtained.

我们可以看到网络生成的灰度图像(网格中心的图像)和目标灰度图像之间存在一些差异。主要的区别是使用 DIP 方法从网络重建的灰度图像获得的灰度图像中存在的锐度。那么，我们要不要建立一个网络来使图像更清晰呢？……..开个玩笑！我让你们来决定。 😄

我希望通过这篇教程，你对自动编码器及其广泛的应用有所了解。我在参考资料部分提供了我的 GitHub 链接，如果你对这个代码有问题，请提出问题。谢谢大家！

资源

链接 GitHub 代码:【https://github.com/akshath123/RGB_to_GRAYSCALE_Autoencoder-】T4

训练数据链接:http://download . tensor flow . org/example _ images/flower _ photos . tgz

测试数据链接:https://www . ka ggle . com/olgabelitskaya/the-dataset-of-flower-images/data

auto encoder Zoo–使用 TensorFlow 进行图像校正

原文：https://towardsdatascience.com/autoencoder-zoo-669d6490895f?source=collection_archive---------7-----------------------

Noise removal using a convolutional autoencoder

在一般情况下，自动编码器是一个函数，其中 f(x) = x 。虽然这似乎是多余的，但它有它的用途。有趣的是， x 中的信息被压缩，然后 x 从这个压缩状态被重构。

自动编码器的目的是学习最有效的压缩。压缩状态通常学习 x 的特性，所以不会显式存储 x 。由于这种压缩是有损的，所以不适合文件压缩。(自动编码器的非常特殊的性质进一步推动了这一点，它是在特定的数据集上进行训练的。)

我将使用 MNIST 数据集，部分是因为它在机器学习中无处不在，部分是因为我有一个预处理过的副本。

图表 1 —深度神经网络

该网络有 3 个深层或隐藏层，这些层在它们的维度上是镜像的。压缩或编码状态是中间层。

这种架构对于手头的任务来说过于简单，并且无法捕获足够的有效特性，如下面的输出所示。

图表 2 —卷积神经网络

更有效的图像处理架构是卷积神经网络。这些网络的工作原理已经在其他帖子中详细解释过了，但是我将在这里尝试做一个简单的解释。

卷积层 —这一层接受整个图像的子部分(在这种情况下是 5x5 像素区域)，遍历图像的每个可能的子部分，对每个子部分使用相同的权重和偏差。一层中卷积滤波器的数量是所使用的权重和偏置“集”的数量。因此，虽然输入可能是 1x28x28 图像，但输出将是(层数)x28x28。

池层 —“最大池”方法旨在减少输入的维度。例如，我使用 2x2 池大小，这意味着输出 2x2 子部分中的最大值，从而将该子部分的大小减少到 1x1。使用的跨距为 2，这意味着每个子部分与前一个子部分相距 2 个像素，因此没有子部分重叠。这种池化配置将输入的大小/维度减半。

使用以下架构:

卷积架构作为自动编码器要有效得多，输入图像的精确重建就证明了这一点。

Training process shown with a verification image

正如所承诺的，这个系统比简单地重新创建一个输入拥有更多的用途。它可以用来重建嘈杂或模糊的图像，使用部分图像来重建否则丢失的信息。下面的图像是测试图像，因此没有用于训练网络。

Verification images after 20,000 training iterations

左手边表示图像中网络旨在移除的静态对象，因此需要移除的“错误”在每个图像中的相同位置。右手边是随机对象——网格的位置不固定，噪声是随机产生的。自动编码器能够学习如何移除不期望的元素并重建期望的信息。

这将在一系列应用中有用，例如高 ISO 照片中的噪声去除、图像重建和超分辨率应用。

自动编码器在深度神经网络中至关重要

原文：https://towardsdatascience.com/autoencoders-are-essential-in-deep-neural-nets-f0365b2d1d7c?source=collection_archive---------0-----------------------

一个 自动编码器是一个神经网络(NN)，也是一个无监督学习(特征学习)算法。

通过将目标值设置为与输入相同，应用反向传播。
它试图从 x 预测 x ，而不需要标签。

Output = f . f ‘ . Input

它试图学习一个“恒等式”函数的近似值。
但是我们在网络上放置约束就像在隐藏层中少了 个单元。
它代表来自压缩、噪声或损坏数据的原始输入。
它由编码器&解码器之间的窄隐层组成。

Network level representation

中间层 ( 中间层 [ 瓶颈或潜在空间表示)是输入数据的压缩表示。
自动编码器与工程压缩的区别在于，

— —在自动编码器压缩和解压缩功能中从数据本身学习，而不像 jpg 和 zip 。

编码器和解码器为前馈 NN。
通过最小化输入和输出之间的差异来训练网络。
如果输入是完全随机(从 IID &中选择独立于其他特征，那么压缩任务将会是困难。
如果输入特征与相关，那么网络将发现那些。
它的学习风格像 PCA，所以和 PCA(主成分分析)关系密切。
我们可以从本征矢表象的相似度中观察到。
PCA & 自动编码器的区别类似

—自动编码器比 PCA 灵活得多。

— NN 激活函数在编码中引入了“非线性”，但 PCA 仅引入了线性变换。

—我们可以堆叠自动编码器，形成一个深度自动编码器网络。

自动编码器的重要性，

—它找到输入数据的低维表示。

—在我们的模型中，一些输入特征可能是冗余 / 相关 →浪费处理时间& " 过拟合(参数太多)。

如果隐藏单元的数量大，我们可以对隐藏层施加稀疏度约束。网络仍然能够发现特征。
网络的神经元可以是激活(作为触发)或者神经元可以是非激活。
稀疏度参数通常是接近到零 = 0.05 的小值。
网络将额外惩罚项引入我们的优化目标。
在正则化中使用 KL(Kullback-Leibler)散度，并且考虑伯努利随机变量与来自 2 分布的均值。
训练应该在“白化的”自然图像上进行。
白化是一个预处理步骤，去除输入中的冗余。
NN 的训练策略在这里也管用，

1.反向传播

2.规范化

3.拒绝传统社会的人

4.RBM 预培训

其他类型的自动编码器

1)卷积自动编码器(CAE)

这用“卷积层”替换了“全连接层”。
宽薄隐层 — — —转换成—>—窄厚隐层。
这有助于提取视觉特征。
重建质量:-

-经常模糊不清

-质量较低

-丢失了一些信息

CAE 的使用:-

1。 超基础图像重建

—学习从图片中去除噪声/重建缺失的部分。

—输入(噪声版本)；所以输出(干净版)。

—网络会填充图像中的间隙。

Removes the dark cross-bar in the image

2。 超基础图像彩色化

— CAE 将一幅图像中的圆和正方形映射到同一幅图像，但分别使用红色和蓝色(着色)。

—紫色有时是因为颜色的混合而形成的，网络在圆形或方形之间徘徊。

Coloring

3。 高级应用

—完全图像彩色化

—潜在空间聚类

—生成更高分辨率的图像

在图像输入的情况下，

— —自动编码器使用 Conv 图层

编码器=典型的 conv 金字塔
最大轮询层跟随以减少维度
解码器= 反进化过程

— —反进化过程，

-从之前学习的内容中添加新数据

——容易出现视觉假象。

-使用“最近邻”或“双线性插值(上采样)”调整大小，这是比标准去卷积层更好的选择。

Pushes more pixels to the image

Fully Image Colorization

2)变分自动编码器(VAE)

这结合了贝叶斯推理。
压缩的表示是一个概率分布。

3)稀疏自动编码器

这用于特征提取。
这比输入有更多的隐藏单元。
这允许输入数据的稀疏表示。

4)堆叠自动编码器

如果使用了一个以上的隐藏层，那么我们寻找这个自动编码器。
每个连续层都

-最佳加权

-非线性

-训练数据的低维投影

4)深度自动编码器

这有 2 个对称的“T32”深度信念网络“T33”，通常有 4 或 5 个“T34”浅层。
它的层是受限玻尔兹曼机(RBM)。
用途，

1。 图片搜索

— —一张图片可以压缩成 30 个左右的向量(就像谷歌图片搜索一样)。

2。 数据压缩

— —深度自动编码器对“语义哈希”很有用。

3。 主题建模&信息检索

参考文献:-

http://ufldl . Stanford . edu/tutorial/unsupervised/auto encoders/
https://hacker noon . com/auto encoders-deep-learning-bits-1-11731 e 200694
https://deeplearning4j.org/deepautoencoder
https://lazyprogrammer.me/a-tutorial-on-autoencoders/

自动编码器——深度学习的比特和字节

原文：https://towardsdatascience.com/autoencoders-bits-and-bytes-of-deep-learning-eaba376f23ad?source=collection_archive---------4-----------------------

百度研究院(Baidu Research)首席科学家吴恩达表示，可以将深度学习的作用理解为“A 到 B 的映射”。“您可以输入音频片段并输出文字记录。那就是语音识别。”他坚持认为，只要你有数据来训练软件，可能性是无限的。"你可以输入电子邮件，输出可能是:这是不是垃圾邮件？"他说，输入贷款申请，输出可能是客户偿还贷款的可能性。输入车队的使用模式，输出可以建议下一步把车送到哪里。

与其通过复杂的定义使事实变得复杂，不如将深度学习视为子集的子集。人工智能包含了广泛的技术和技巧，使计算机系统能够以至少表面上类似于思维的方式来解决问题。在这个范围内，有一整套神秘但重要的数学技术，驱动着通过经验学习的动机。这个子集被称为机器学习。最后，在机器学习中有一个更小的子类，称为深度学习(也称为深度结构化学习或分层学习)，这是人工神经网络(ann)在包含不止一个隐藏层的学习任务中的应用。

什么是自动编码器？

尽管它最初听起来有点神秘，但自动编码器是一个相当基本的机器学习模型。自动编码器(AE) 是一类输入与输出相同的神经网络。他们的工作原理是将输入压缩成一个潜在空间表示，然后从这个表示中重建输出。

Autoencoder architecture

更详细地说，自动编码是一种数据压缩算法，其中压缩和解压缩功能，

数据特定:自动编码器只能压缩类似于它们被训练过的数据。一个经过人脸训练的自动编码器在处理现代建筑的图像时不会表现得很好。这弥补了自动编码器和 MP3 压缩算法之间的差异，MP3 压缩算法只对一般声音进行假设，而不对特定类型的声音进行假设。
有损:这意味着与原始输入相比，解压缩后的输出质量会下降。就像你在 JPEG 或 MP3 中看到的一样。
从示例中自动学习:如果您有适当的训练数据，很容易训练算法的特定实例，这些实例将对特定类型的输入执行良好。它不需要任何新的工程技术。

此外，在几乎所有使用术语“自动编码器”的上下文中，压缩和解压缩功能都是用神经网络实现的。

为什么选择自动编码器？

尽管事实上不久前自动编码器的实际应用相当罕见，但今天，数据去噪和数据可视化降维被认为是自动编码器的两个主要有趣的实际应用。通过适当的维度和稀疏性约束，自动编码器可以学习比 PCA 或其他基本技术更有趣的数据投影。

Performance comparison of Autoencoders and PCA

卷积自动编码器

在自动编码器的传统架构中，没有考虑到信号可以被视为其他信号的总和这一事实。另一方面，卷积自动编码器(CAE)使用卷积运算符来适应这种观察。卷积运算符允许对输入信号进行滤波，以便提取其内容的某一部分。他们学习将输入编码成一组简单的信号，然后尝试从这些信号中重建输入。

A convolution between a 4x4x1 input and a 3x3x1 convolutional filter.
The result is a 2x2x1 activation map. (Source)

参考这个关于卷积自动编码器的使用案例，有很好的例子解释。在这篇文章的后面，我们将看到 CAE 的一个实际例子。

构建自动编码器

我们将从我们能构建的最简单的自动编码器开始。在后一部分，我们将在真实的例子中研究自动编码器的更复杂的用例。

以下是使用 keras 作为平台的简单自动编码器的代码。keras 提供的 MNIST 数字用于示例中。

有了这个代码片段，我们将得到以下输出。

在上图中，顶行是原始数字，底行是重建的数字。正如您所看到的，在这个基本示例中，我们丢失了一些重要的细节。

由于我们的输入是图像，使用卷积神经网络作为编码器和解码器是有意义的。在实际设置中，应用于图像的自动编码器总是卷积自动编码器，因为它们的性能要好得多。

使用卷积自动编码器，我们将获得以下输入和重构输出。

自动编码器的实际应用:图像去噪

在本节中，我们将研究自动编码器在现实世界中的使用，用于图像去噪。我们将训练卷积自动编码器将有噪声的数字图像映射到干净的数字图像。

我们将通过应用高斯噪声矩阵来生成合成噪声数字，并在 0 和 1 之间裁剪图像。

当 autoencoder 被训练后，我们可以用它来去除添加到我们从未见过的图像中的噪声！这是输入和重建输出的样子。

结论

自动编码器是一种人工神经网络，用于高效编码的无监督学习。在现代，自动编码器已经成为一个新兴的研究领域，在许多方面，如在异常检测。在这篇文章中，我们期望提供一个关于自动编码器是什么、为什么和如何的基本理解。

参考

https://hacker noon . com/auto encoders-deep-learning-bits-1-11731 e 200694
【https://blog.keras.io/building-autoencoders-in-keras.html 号
【https://www.technologyreview.com/s/513696/deep-learning/

自动编码器-TF 中的介绍和实现。

原文：https://towardsdatascience.com/autoencoders-introduction-and-implementation-3f40483b0a85?source=collection_archive---------2-----------------------

简介和概念:

自动编码器(AE) 是一个神经网络家族，其输入与输出相同(它们实现一个身份函数)。他们的工作原理是将输入压缩成一个潜在空间表示，然后从这个表示中重建输出。

自动编码器真正流行的用途是将它们应用于图像。的诀窍是用卷积层代替全连接层。这些图层与合并图层一起，将输入从宽宽和薄宽(假设 100 x 100 像素，3 个通道— RGB)转换为窄宽宽。这有助于网络从图像中提取视觉特征，从而获得更加准确的潜在空间表示。重建过程使用上采样和卷积。

由此产生的网络被称为卷积自动编码器 ( CAE )。

CAEs 的使用

示例:超基本图像重建

卷积自动编码器可以用于重建。例如，他们可以学习从图片中去除噪声，或者重建丢失的部分。

为此，我们不使用相同的图像作为输入和输出，而是使用噪声版本作为输入和干净版本作为输出。通过这个过程，网络学会填补图像中的空白。

让我们看看 CAE 能做什么来替换眼睛图像的一部分。假设有一个十字准线，我们想移除它。我们可以手动创建数据集，这非常方便。

现在我们的自动编码器已经训练好了，我们可以用它来移除我们从未见过的眼睛图片上的十字准线！

TF 中的实现:

让我们来看一个在 tensorflow 中使用 MNIST 数据集的示例实现。

笔记本:https://github . com/mchablani/deep-learning/blob/master/auto encoder/convolatile _ auto encoder . ipynb

网络体系结构

网络的编码器部分将是典型的卷积金字塔。每个卷积层后面都有一个最大池层，以减少各层的维数。解码器需要从窄的表示转换成宽的重建图像。

通常，你会看到转置卷积层用于增加层的宽度和高度。它们的工作原理与卷积层几乎完全相同，但方向相反。输入层中的步幅导致转置卷积层中的步幅更大。例如，如果您有一个 3x3 内核，输入层中的一个 3x3 补丁将减少到卷积层中的一个单元。相比之下，输入层中的一个单元将在转置卷积层中扩展为 3×3 路径。TensorFlow API 为我们提供了一种创建层的简单方法。

然而，转置卷积层会导致最终图像中出现伪影，例如棋盘图案。这是由于内核重叠造成的，可以通过将步幅和内核大小设置为相等来避免这种重叠。在这篇摘自 Augustus Odena，等人的文章中，作者展示了通过使用最近邻或双线性插值(上采样)后接卷积层来调整层的大小，可以避免这些棋盘状伪像。在 TensorFlow 中，这很容易用[tf.image.resize_images](https://www.tensorflow.org/versions/r1.1/api_docs/python/tf/image/resize_images)完成，然后是卷积。Odena 等人声称最近邻插值最适合上采样

自动编码器仅通过在有噪声的图像上训练网络，就可以非常成功地用于图像去噪。我们可以通过向训练图像添加高斯噪声，然后将值剪切到 0 和 1 之间，来自己创建有噪声的图像。我们将使用噪声图像作为输入，原始的、干净的图像作为目标。

注意，我们使用 sigmoid _ cross _ entropy _ with _ logit 来表示损失。根据 TF 文档:它测量离散分类任务中的概率误差，其中每个类都是独立的，并且不互相排斥。例如，可以执行多标签分类，其中一幅图片可以同时包含一头大象和一只狗。

模型定义:

learning_rate = 0.001
inputs_ = tf.placeholder(tf.float32, (None, 28, 28, 1), name='inputs')
targets_ = tf.placeholder(tf.float32, (None, 28, 28, 1), name='targets')### Encoder
conv1 = tf.layers.conv2d(inputs=inputs_, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 28x28x32
maxpool1 = tf.layers.max_pooling2d(conv1, pool_size=(2,2), strides=(2,2), padding='same')
# Now 14x14x32
conv2 = tf.layers.conv2d(inputs=maxpool1, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 14x14x32
maxpool2 = tf.layers.max_pooling2d(conv2, pool_size=(2,2), strides=(2,2), padding='same')
# Now 7x7x32
conv3 = tf.layers.conv2d(inputs=maxpool2, filters=16, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 7x7x16
encoded = tf.layers.max_pooling2d(conv3, pool_size=(2,2), strides=(2,2), padding='same')
# Now 4x4x16### Decoder
upsample1 = tf.image.resize_images(encoded, size=(7,7), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 7x7x16
conv4 = tf.layers.conv2d(inputs=upsample1, filters=16, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 7x7x16
upsample2 = tf.image.resize_images(conv4, size=(14,14), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 14x14x16
conv5 = tf.layers.conv2d(inputs=upsample2, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 14x14x32
upsample3 = tf.image.resize_images(conv5, size=(28,28), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
# Now 28x28x32
conv6 = tf.layers.conv2d(inputs=upsample3, filters=32, kernel_size=(3,3), padding='same', activation=tf.nn.relu)
# Now 28x28x32logits = tf.layers.conv2d(inputs=conv6, filters=1, kernel_size=(3,3), padding='same', activation=None)
#Now 28x28x1# Pass logits through sigmoid to get reconstructed image
decoded = tf.nn.sigmoid(logits)# Pass logits through sigmoid and calculate the cross-entropy loss
loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=targets_, logits=logits)# Get cost and define the optimizer
cost = tf.reduce_mean(loss)
opt = tf.train.AdamOptimizer(learning_rate).minimize(cost)

培训:

sess = tf.Session()
epochs = 100
batch_size = 200
# Set's how much noise we're adding to the MNIST images
noise_factor = 0.5
sess.run(tf.global_variables_initializer())
for e in range(epochs):
    for ii in range(mnist.train.num_examples//batch_size):
        batch = mnist.train.next_batch(batch_size)
        # Get images from the batch
        imgs = batch[0].reshape((-1, 28, 28, 1))

        # Add random noise to the input images
        noisy_imgs = imgs + noise_factor * np.random.randn(*imgs.shape)
        # Clip the images to be between 0 and 1
        noisy_imgs = np.clip(noisy_imgs, 0., 1.)

        # Noisy images as inputs, original images as targets
        batch_cost, _ = sess.run([cost, opt], feed_dict={inputs_: noisy_imgs,
                                                         targets_: imgs})print("Epoch: {}/{}...".format(e+1, epochs),
              "Training loss: {:.4f}".format(batch_cost))

学分:https://hacker noon . com/auto encoders-deep-learning-bits-1-11731 e 200694

自动编码器变得简单

原文：https://towardsdatascience.com/autoencoders-made-simple-6f59e2ab37ef?source=collection_archive---------1-----------------------

什么是自动编码器？

自动编码器是一种用于无监督学习的生成模型。自动编码器学习图像的一些潜在表示，并使用它来重建图像。这种“潜在表征”是什么？这是图像隐藏特征的另一个花哨术语。自动编码器通过用不同图像训练的迭代过程，试图学习给定图像的特征，并从这些学习到的特征中重建期望的图像。

乍一看，自动编码器可能看起来像任何其他神经网络，但不像其他网络，它在中心有一个瓶颈。这个瓶颈用来学习图像的特征。自动编码器完成两项任务，它对图像进行编码，然后解码。

编码图像:

拍摄输入图像，通过一系列卷积，图像的大小被压缩成一个小矢量。这个压缩的矢量表示图像的特征，从该特征可以重建另一个图像

解码图像:

从压缩矢量，我们应用了一系列的反卷积层，放大图像的大小，并将其恢复到原来的大小。

自动编码器的用途是什么？

自动编码器可以用来消除噪声，执行图像着色和各种其他目的。有噪声的图像可以作为自动编码器的输入，去噪声的图像可以作为输出。自动编码器将通过学习图像的潜在特征来尝试对图像去噪声，并使用该特征来重建没有噪声的图像。重建误差可以作为输出图像和地面真实图像的像素值之间的距离的度量来计算。

缺点:

在重建图像时，自动编码器与生成式对抗网络相比效率并不高。随着图像复杂性的增加，自动编码器很难跟上，图像开始变得模糊。

代码:

下面的 python 代码代表了一个基本的自动编码器，它从 mnist 数字数据中学习特征，并重新构造它们。

依赖关系:

张量流
克拉斯
Numpy

结论:

尽管自动编码器可能很难跟上 GANs，但它们在某些任务中效率很高，比如异常检测和其他任务。这仍然是神经网络的一个新兴领域。

AutoKeras:谷歌汽车的黑仔

原文：https://towardsdatascience.com/autokeras-the-killer-of-googles-automl-9e84c552a319?source=collection_archive---------1-----------------------

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

谷歌人工智能终于发布了 AutoML 的测试版，有人说这项服务将完全改变我们进行深度学习的方式。

谷歌的 AutoML 是一个新的机器学习工具云软件套件。它基于谷歌在图像识别领域的最新研究，名为神经架构搜索 (NAS)。NAS 基本上是一种算法，在给定特定数据集的情况下，它会搜索最佳神经网络来对该数据集执行特定任务。AutoML 是一套机器学习工具，允许人们轻松训练高性能的深度网络，而不需要用户拥有任何深度学习或人工智能的知识；你需要的只是标签数据！Google 将使用 NAS 为您的特定数据集和任务找到最佳网络。他们已经展示了他们的方法如何能够实现比手工设计的网络更好的性能。

AutoML 完全改变了整个机器学习游戏，因为对于许多应用程序来说，不需要专门的技能和知识。很多公司只需要深度网络来完成更简单的任务，比如图像分类。在这一点上，他们不需要雇佣 5 个机器学习博士；他们只需要有人能够处理移动和组织他们的数据。

那么 AutoML 是不是一个让任何公司或个人都可以轻松做 AI 的漂亮银弹？！

….没那么快。

使用谷歌的 AutoML 进行计算机视觉，每小时要花费 20 美元。太疯狂了！你甚至不能确定你会得到比你自己亲手设计的网络更好的准确性，直到你付钱并试用它。有趣的是，在过去，无论是谷歌还是一般的人工智能社区，人们都喜欢开源，以便能够与每个人分享知识。

而这正是 Google 的 AutoML 会输的地方:开源。

进入 AutoKeras ，一个开源 python 包写的非常好用 深度学习库Keras。AutoKeras 使用了 ENAS 的变体，这是一种有效的最新版本的神经架构搜索。您可以使用pip install autokeras快速轻松地安装软件包，瞧，您已经准备好在您自己的数据集上进行您自己的架构搜索… 免费。

因为所有的代码都是开源的，如果你想做一些真正定制的东西，你甚至可以摆弄一些参数。这都是 Keras，所以代码很容易理解和深入，允许开发人员快速创建准确的模型，研究人员可以更深入地进行架构搜索。

AutoKeras 拥有一个伟大的开源项目应该拥有的一切:快速安装，易于运行，大量的例子，易于修改，您甚至可以看到 NAS 最终发现的网络模型！如果你更喜欢 TensorFlow 或 Pytorch，这里也有和这里也有！

我肯定会推荐尝试 AutoKeras 或任何其他实现，作为 AutoML 的可笑的廉价替代品。也许谷歌正在为 AutoML 做更多的事情，但鉴于 NAS 模型和手工设计的模型之间非常小的性能差异，我怀疑人们会获得足够大的收益，值得付出如此高昂的代价。

深度学习和人工智能是一项如此强大的技术，我们不应该试图将其隐藏在如此高的收费背后。是的，谷歌、亚马逊、苹果、脸书和微软都是需要赚钱来生存和竞争的企业。但像这样的事情，研究论文是公开的，我们有深度学习库可以快速复制这些方法，当它可以如此容易地公开时，试图阻止人们使用它是没有意义的。

这里还有一个潜在的更大的问题:知识本身被隐藏了。关于人工智能最近趋势的一件大事是，许多研究社区决定迅速将他们的工作公开发布在 Arxiv 等网站上，与社区分享并获得反馈。更有甚者，在 Github 上发布研究代码以供复制，以及在研究和现实世界应用中进一步使用这些算法，已经成为一种日益增长的趋势。然而在这里，我们仍然看到这样的研究被置于付费墙之后。

分享科学有助于进步，增加每个人的常识。有一点是肯定的:知识应该是开源的。对大家都好。

自动化枯燥的任务:企业软件中的聊天机器人

原文：https://towardsdatascience.com/automate-the-boring-task-chatbots-in-enterprise-software-dc83cc8f09d8?source=collection_archive---------6-----------------------

这篇文章结合了我个人网站这里和这里的两篇博文。

由于对任何形式的炒作都持怀疑态度，我对聊天机器人并不感兴趣。在投入另一场硅谷炒作之前，我需要理解它的价值。当我在 2017 年初加入思科超创新生活实验室(CHILL)时，机会来了。思科在企业软件领域与许多其他企业客户合作。这意味着他们拥有庞大的基础设施、工具集和客户支持流程，这些都是自动化的成熟产品。

虽然我不能谈论我在这里工作的项目，但它激起了我对聊天机器人、自然语言处理(NLP)和整体对话人工智能空间的兴趣。虽然之前我已经创建了基于规则的家庭自动化系统和语言转换软件，但这一次是我第一次使用实际的自然语言处理技术涉足企业规模的对话式人工智能。

我开始研究聊天机器人框架。回到 2017 年 5 月，思科收购了一家名为 MindMeld 的对话式人工智能初创公司。我开始使用 MindMeld NLP APIs 和它的对话式 AI 框架，更深入地研究了诸如实体、意图等概念。我继续深入研究，发现了rasa . AI——另一个企业级对话式人工智能框架。而且这次是开源的！很少有朋友还提到过chatter bot——一个开源的会话式对话引擎。随着我不断探索，我在消费者和企业领域遇到了许多其他对话式人工智能产品。由于我在 Backstage Capital 的 EIR 演出，我还发现了一些机器人分析产品。

在这一系列帖子中，我将深入探讨聊天机器人框架、对话式人工智能产品、机器人分析产品以及更多我感兴趣的产品。

在对话式人工智能框架中

为了构建一个聊天机器人，我最终研究了不同的对话机器人框架。 Botkit 和 Api.ai (现在的 Dialogflow)就是两个明显的例子。它们都支持思科的协作平台 Cisco Spark，也可以通过各自的 REST APIs 从 webapp 中使用。但很快我意识到了它们的局限性。

僵尸工具是一个基于规则的框架。在基于规则的框架中，开发人员需要创建交互逻辑——如何解释传入的聊天消息，以及典型的响应集是什么。所以本质上，僵尸工具本身并不提供任何机器学习能力。你必须不断地为简单的应用程序创建规则。这些类型框架适用于快速原型开发，但不适用于大型可伸缩系统。截至 2017 年 5 月，僵尸工具增加了将僵尸工具工作室与微软自然语言处理引擎 Microsoft LUIS 集成的功能。Botkit 和 LUIS 的整合服务于我的目的，即；使用真正的自然语言处理引擎，但这导致了下一个问题——使用基于云的 NLP 服务。

Api.ai，微软 LUIS，亚马逊 Lex 等。是基于云的对话式人工智能 NLP 服务。他们很快就能上手，不用太担心 NLP 或机器学习的细节。但是有几个原因我不想和他们一起去。首先，我不想把我的数据上传到那些云服务上。第二，我希望能够控制我在聊天机器人中使用的自然语言处理技术，最后，我希望能够更多地控制我的机器人的功能，而不是基于云的自然语言处理服务提供的常见功能。

那么我在找什么呢

简而言之，我在聊天机器人框架中寻找以下特征

不是基于规则或基于云的 NLP
有 web/REST API 支持，所以我可以从 webApp 上使用它，而不仅仅是在第三方平台上，如 Slack，脸书等。
支持 Python，但 Node.js 也很酷
允许我自定义
巨大的优势——开源

MindMeld 服务于上述大部分目的，我在思科的工作中使用它。但我也想看看外面还有什么。我偶然发现了rasa . ai——一个面向企业的开源对话式 AI。Rasa 似乎与 MindMeld 非常相似——尽管我需要更深入地了解 Rasa 的 NLP 功能。Rasa 让我着迷的是，它们是企业级开源解决方案——开发者的天堂！

我还遇到了聊天机器人。它似乎是一个基于规则的引擎，基于这个聊天机器人平台对照表。虽然 Chatterbot 有能力添加您自己的语料库来训练机器人。需要仔细观察才能决定它的 NLP 能力。

在那之前，敬请期待！

注:

我是旧金山的一名软件工程师，从事聊天机器人、自然语言处理方面的工作，最近获得了深度学习奖学金，成为杰瑞米·霍华德 fast.ai 课程的一部分。

这一系列帖子的名字是受了这本书的启发。特别感谢 Anastasia 和 Meighan 对这篇博客的快速回顾。感谢 Karthik 分享他对 MindMeld 平台的深刻见解。

自动化枯燥的任务:对话助手的视野

原文：https://towardsdatascience.com/automate-the-boring-task-the-horizon-of-conversational-assistants-b13a9d859c02?source=collection_archive---------8-----------------------

随着我不断构建对话助手，我每天都会面临一些问题。它是什么？我们为什么要关心它？有哪些不同的设计选择？你为什么选择一个平台而不是另一个？我们如何衡量我们的进步？我们还能做些什么来改进等等。这篇博文试图通过总结对话助手的发展来回答这些问题。

什么是会话助手？

根据维基百科，对话助手或聊天机器人

是一种计算机程序或人工智能，它通过听觉或文本方法进行对话。这种程序通常被设计成令人信服地模拟人类作为对话伙伴的行为

正如上面的定义中提到的，聊天机器人不一定需要采用人工智能技术。事实上，今天的大多数机器人都是简单的 if-then-else 程序，不一定采用人工智能技术。

为什么商家会在意？

据 Gartner 称，到 2020 年，55%的公司将部署聊天机器人[1]。2016 年，聊天机器人的全球市场规模达到 8800 万美元。预计到 2023 年，CAGR 市场将以 36%的速度增长，超过 10 亿美元[2]。除了数字之外，对话助手还能提供独特的价值，帮助企业在竞争中保持领先。

通过减少摩擦改善用户体验。例如，美国银行聊天机器人可以显示你的账户余额、银行帐号等。通过简单的语音或文本命令。你不需要在他们的网站上点击 10 个不同的链接。
通过全天候客户服务增加与客户的互动。举个例子——酒店的常春藤可以全天候回答任何与客房服务相关的问题。酒店不需要让员工在夜间凌晨值班！
更高的客户满意度——拥有成熟虚拟助理解决方案的企业客户看到的遏制率高达 90% [4]。包容意味着客户能够在第一次接触时解决问题的频率。提高容器数量意味着更高的客户满意度。
通过基于对话的情感分析，更好地洞察客户行为
成本降低

那些聊天机器人在哪里？

聊天机器人生活在不同的平台。他们可以是 Facebook Messenger、WhatsApp、Telegram 或 Kik 等消息平台的一部分；可以在 Slack 等企业协作平台；可以是 iPhone 或亚马逊 Echo 等硬件设备的一部分；可以在 web 应用程序中——例如我们在大多数网站中看到的客户服务聊天气泡；或者干脆作为手机 app 比如 Replika 。

虽然对话机器人可能会让我们想起 Siri 或 Alexa 他们不一定需要语音支持。聊天机器人可以只发送文本消息，也可以是文本和语音的结合，或者只发送语音。

Chatbot Ecosystem credit

产品前景

在一个博客中有太多的产品要介绍。我将把重点放在开发平台、测试和分析工具上，它们最终会导致构建一个大规模的企业产品

开发者平台:

在基于规则的框架中，Botkit 是开发人员最为熟知的。使用僵尸工具，开发人员需要创建交互逻辑——如何解释传入的聊天消息，以及典型的响应集是什么。所以本质上，僵尸工具本身并不提供任何机器学习能力。你必须不断地为简单的应用程序创建规则。这些类型框架适用于快速原型开发，但不适用于大型可伸缩系统。截至 2017 年 5 月，僵尸工具增加了将僵尸工具工作室与微软自然语言处理引擎 Microsoft LUIS 集成的功能。

接下来是基于云的开发者平台。DialogFlow，微软 LUIS，亚马逊 Lex 等。是基于云的对话式人工智能 NLP 服务。他们很快上手，不需要太担心 NLP 或机器学习的细节。

NanoRep(被 LogMeIn 收购)是另一个基于云的聊天机器人开发平台，它是专门为客户服务用例设计的。该平台有助于预测客户在网站上搜索商品或与客户支持人员聊天时试图做的事情，并减少到达网站所需的步骤[3]。

尽管这些基于云的 NLP 服务从一开始就很棒，并且更容易构建可扩展的解决方案，但是它们有两个主要的局限性。首先，你必须把你的数据保存在他们的云中。对于担心数据隐私和数据所有权的企业来说，这是一个特殊的问题。第二，开发人员受到这些平台支持的功能的限制，这对于需要在竞争中脱颖而出的企业来说是一个挑战。如果这两个是你关心的，你最好使用像 Rasa 或 MindMeld 这样的平台。

Rasa 是一个开源的企业级对话式 AI 平台。它以模块化的方式将自然语言理解(NLU)引擎( Rasa NLU )与对话管理引擎( Rasa 核心)分开。开发人员可以根据他们的特定需求混合搭配这些模块。例如——开发人员可能希望将 Rasa NLU 与僵尸工具一起使用(在这种情况下，僵尸工具将只处理对话管理)。你也可以用 Rasa 交互式训练你的对话模型。这个特性有助于根据人机对话重新训练对话引擎。

MindMeld (被思科收购)是另一个企业级对话式 AI 平台。与 Rasa 不同，他们不允许开发者模块化访问他们的 NLU 和对话管理引擎。此外，据我所知，没有像 Rasa 这样的交互式培训功能。

企业产品

在我看来，客户服务是企业对话助手可以提供巨大价值的最令人兴奋的用例——增加销售额、经常性收入、客户满意度等。企业也开始掌握它了。例如，ServiceNow 客户服务机器人可以帮助客户了解案例的状态，并自动处理其他客户服务请求。UPS 聊天机器人帮助客户面对物流运作。 Carla 帮助你计划商务旅行， Cinch 帮助那些不在拥有自己旅行管理系统的大公司工作的商务旅行者管理他们的旅行。AVA—Autodesk 虚拟助理可以帮助 Autodesk 客户完成注册、激活、安装、许可和帐户相关任务。好事达正在部署聊天机器人来帮助小企业客户完成保险流程。

Autodesk Virtual Assistant

有趣的是，有些聊天机器人开发平台是专门为客户服务用例设计的。例如 Reply.ai 帮助企业建立客户服务聊天机器人，并提供对客户情绪、偏好、好恶等的洞察。NanoRep(已被 LogMeIn 收购)的聊天机器人平台也是专门为企业客户服务而设计的，当客户询问机器人不知道的事情时，它会通知人类客户支持代理。

聊天机器人分析平台:

Dashbot 和 Botanalytics 是聊天机器人分析平台的几个例子。这些平台通过识别瓶颈、识别关键指标、细分对话和提供智能建议来帮助改善人与机器人的沟通。例如，下面的机器人分析仪表盘显示了人类顾客和聊天机器人之间对话的一些统计数据。这些统计数据将让我们更好地了解已部署聊天机器人的效率。例如— 平均会话长度可能表示企业解决客户问题的速度。

Botanalytics Dashboard showing analytics of the conversation between a human and a bot

Dashbot 使品牌和开发者能够通过可操作的数据和工具增加参与度、获取度和盈利。除了参与度和留存率等传统分析之外，Dashbot 还提供机器人和语音特定的指标，包括情绪分析、意图分析和完整的聊天会话记录。它使用户能够使用真人接管、广播消息和受众构建器等工具对数据采取行动。使用 Dashbot，聊天机器人开发人员可以找到并修复未处理的意图。

Finding and Fixing Unhandled Intent with Dashbot

聊天机器人测试方法和工具:

测试您的聊天机器人应用程序需要不同于您的典型软件应用程序的思维方式。测试过程中的一个关键阶段是测试对话流。机器人是否遵循了您希望它遵循的相同对话流程？如果人类不像我们预期的那样交谈呢。测试过程还需要考虑速度、准确性、用户体验等。与机器人对话。在聊天机器人的情况下，错误处理尤其有趣。如果机器人被要求做一些它没有被训练过的事情，它如何回答？

博特宁、戴蒙等。是一些聊天机器人测试平台，可以自动生成类似用户的对话。这些对话可用于测试聊天机器人的对话流程、速度、准确性和用户体验。 Botium ，一个开源聊天机器人测试平台，通过启动、交互和停止你的聊天机器人应用程序来自动化测试过程。另一个开源工具是 Chatbottest 。这个工具有一组问题，可以用来测试应用程序的对话流和 UX。他们还开发了一个机器人来测试你的机器人——Alma。目前，Alma 是一个 chrome 扩展，可用于在 Facebook Messenger 和 Telegram 中测试您的聊天机器人。

机器人商店:

与 App Store 概念类似，Slack 等平台也有自己的机器人商店，展示在其平台上构建的机器人。Cisco Webex Teams 是另一个协作平台，开发人员已经为企业客户构建了机器人。聊天瓶、聊天机器人列表和因此列出了世界上的聊天机器人应用。

一篇关于产品前景的综合文章总是一个移动的目标。我确信我已经错过了许多令人兴奋的产品。由于我关注的是企业产品，这篇文章有意忽略了消费者聊天机器人。请随时在评论区分享任何其他产品的信息。

参考:

https://chatbotslife . com/the-chatbot-landscape-changes-for-2018-1 de 0 FB 7 f 88 a 1
https://blog . key reply . com/the-chatbot-landscape-2017-edition-ff 2 e 3d 2 a 0 BDB
https://TechCrunch . com/2017/08/01/logmein-acquisites-chatbot-and-ai-startup-nano rep-for-up-to-50m/
http://connect . creative virtual . com/virtual-agent-improve-customer-service
https://www.abetterlemonadestand.com/ecommerce-chatbots/
https://www . 30 seconds tofly . com/ai-software/ultimate-travel-bot-list/

注:

我是旧金山思科超创新生活实验室(CHILL)的软件工程师。我从事聊天机器人、自然语言处理方面的工作，最近获得了深度学习奖学金，成为杰瑞米·霍华德 fast.ai 课程的一部分。

特别感谢 Ilker Koksal，机器人分析的联合创始人兼首席执行官。贾斯蒂娜·阮(Justina Nguyen)，Dashbot 的开发者传道者。

这一系列帖子的名字是受到了本书的启发。更早的帖子可以在这里找到。

用于预测建模的自动化特征工程

原文：https://towardsdatascience.com/automated-feature-engineering-for-predictive-modeling-d8c9fa4e478b?source=collection_archive---------16-----------------------

Source:Wikimedia Commons

使用 Python 和 FeatureTools 库预测哪些 NHL 比赛是季后赛。

我见过的数据科学家在构建数据产品时投入的主要时间之一是手动执行特征工程。虽然像 auto-sklearn 和 Auto-Keras 这样的工具已经能够在构建预测模型时自动完成大部分模型拟合过程，但确定将哪些特征用作拟合过程的输入通常是一个手动过程。我最近开始使用 FeatureTools 库，它使数据科学家也能够自动化特征工程。

[## 功能工具/功能工具

用于自动化特征工程的开源 python 框架——feature tools/feature tools

github.com](https://github.com/Featuretools/featuretools)

FeatureTools 可用于浅层(经典)机器学习问题，其中数据以结构化格式提供。该库提供了用于执行深度要素合成的功能，这近似于数据科学家在执行要素工程时将探索的变换。使用此工具的结果是，您可以将数据从窄而深的表示转换为浅而宽的表示。

我发现，当每个项目有许多记录需要预测时，这种技术最有效。例如，如果您预测客户是否会流失，输入可以是每个客户的会话事件的集合。如果每个用户只有一条记录，那么深度特征合成不会非常有效。为了展示这种方法是如何工作的，我将使用 Kaggle 上的 NHL 数据集。这个数据集包括一个游戏记录表，以及一个更详细地描述每个游戏的游戏记录表。我正在建立的预测模型的目标是根据比赛中的打法来确定哪些比赛是季后赛。在没有应用领域知识的情况下，我能够建立一个逻辑回归分类器，以高准确度( 94% )预测比赛是季后赛。完整的 Python 笔记本可以在 github 这里获得。

这篇文章的剩余部分介绍了笔记本，展示了如何将提供的 Kaggle 表转换成我们可以用于 FeatureTools 库的输入。第一步是加载必要的库。我们将使用 pandas 加载表，使用 framequery 操作数据框，使用 hashlib 将字符串转换为整数，使用特征工具执行深度特征合成，使用 sklearn 进行模型拟合。

import pandas as pd
import framequery as fq
import hashlib
import featuretools as ft
from featuretools import Feature 
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

接下来，我们将数据加载到 pandas 数据框中，并删除不会用于构建预测的字符串字段。结果是两个数据帧: game_df 指定一场比赛是常规比赛还是季后赛，而 plays_df 有关于每场比赛的细节。

**# game data** game_df = pd.read_csv("game.csv")**# play data** plays_df = pd.read_csv("game_plays.csv")**# drop some of the string type fields** plays_df = plays_df.drop(['secondaryType', 'periodType', 
                 'dateTime', 'rink_side'], axis=1).fillna(0)**# convert the remaining strings to integer types via hashing** plays_df['event'] = plays_df['event'].apply(hash)
plays_df['description'] = plays_df['description'].apply(hash)

游戏数据是一种窄而深的格式，这意味着每个游戏都由许多不同的游戏组成，只有几个特征。我们的目标是将这些数据转换成一种浅而宽的格式，其中每个游戏都由具有数百种不同属性的单行来描述。这是输入数据集。

The data frames used as input: plays and games.

下一步是将 pandas 数据框转换为实体集表示，FeatureTools 将实体集表示用作执行深度要素合成的输入。实体集用于描述不同表之间的关系。在这种情况下，plays 事件是基本实体，而 games 是父实体。在描述这种关系之前，我们首先对事件和描述字段使用 1-hot 编码。这些开始是字符串字段，但是在执行编码之前被转换为哈希值。这是第一步，如下面的代码片段所示。第二步是使用带有 1-hot 编码的转换表作为实体集创建的输入数据帧，在实体集创建中，我们将游戏定义为游戏的集合。

Creating an entity set with encodings for the event and description fields.

这一步的输出是一个实体集，我们可以使用它来执行深度特征合成。得到的对象 es 具有以下属性。

Entityset: plays
  Entities:
    plays [Rows: 500638, Columns: 37]
    games [Rows: 1529, Columns: 1]
  Relationships:
    plays.game_id -> games.game_id

一旦我们将数据帧编码为一个实体集，我们就可以使用 FeatureTools 中的 dfs 函数执行深度特征合成，如下所示。结果是特征数据集，它有数百个特征，每个游戏有一行。我们还使用 framequery 为每场比赛分配一个标签，其中季后赛的标签为 1，常规赛的标签为 0。

**# generate features for the data set** features,_ =ft.dfs(entityset=es,target_entity="games",max_depth=2)
features.reset_index(inplace=True)**# assign labels to the generated features** features = fq.execute("""
SELECT f.*, case when g.type = 'P' then 1 else 0 end as label
FROM features f 
JOIN game_df g
  on f.game_id = g.game_id
""")

这会产生一个浅而宽的数据框，如下所示。我们已经将事件字段从字符串转换为 1-hot 编码字段，现在应用了许多不同的聚合操作。数据现在以一种格式可用，其中单个记录描述每场比赛，我们可以训练一个模型来预测一场比赛是否是季后赛。

The generated features produced from deep feature synthesis.

最后一步是训练和测试模型。为了简单起见，我使用了 sklearn 的逻辑回归模型来拟合数据并评估结果。在下面的代码片段中，精度是在不使用维持集的情况下进行评估的。当我在笔记本中添加维持步骤时，模型的准确性为 94.0%，ROC AUC 为 0.984。

**# create inputs for sklearn** y = features['label']
X = features.drop(['label', 'game_id'], axis=1).fillna(0)**# train a classifier** lr = LogisticRegression()
model = lr.fit(X, y)
model.score(X, y)

这些结果看起来真的令人印象深刻，因为没有关于曲棍球的领域知识被用来训练模型。我没有手动提出特征并试图对曲棍球知识进行编码，而是使用深度特征合成来创建大量特征，作为模型拟合步骤的输入。自动化特征工程是数据科学向前迈出的一大步，使构建预测模型更加自动化。鲨鱼队加油。

本·韦伯是 Zynga 的首席数据科学家。我们正在招聘！

Python 中的自动化要素工程

原文：https://towardsdatascience.com/automated-feature-engineering-in-python-99baf11cc219?source=collection_archive---------1-----------------------

如何自动创建机器学习特征

机器学习正越来越多地从手工设计的模型转向使用 H20 、 TPOT 和 auto-sklearn 等工具的自动优化流水线。这些库，以及随机搜索等方法，旨在通过在很少或没有人工干预的情况下为数据集找到最佳模型，来简化模型选择和机器学习的调整部分。然而，特征工程，机器学习管道中更有价值的方面，仍然几乎完全是人类的劳动。

特征工程，也称为特征创建，是从现有数据构建新特征来训练机器学习模型的过程。这一步可能比实际使用的模型更重要，因为机器学习算法只从我们给它的数据中学习，创建与任务相关的特征绝对至关重要(参见优秀论文“关于机器学习要知道的一些有用的事情”)。

通常，特征工程是一个耗时的手工过程，依赖于领域知识、直觉和数据操作。这个过程可能非常乏味，最终的特征将受到人的主观性和时间的限制。自动化特征工程旨在通过从数据集中自动创建许多候选特征来帮助数据科学家，可以从这些候选特征中选择最佳特征并用于训练。

在本文中，我们将通过一个使用自动化特征工程和特征工具 Python 库的例子。我们将使用一个示例数据集来展示基础知识(请继续关注未来使用真实数据的帖子)。本文的完整代码在 GitHub 上可以找到。

特征工程基础

功能工程是指从现有数据中构建额外的功能，这些数据通常分布在多个相关的表格中。特征工程要求从数据中提取相关信息，并将其放入单个表中，然后该表可用于训练机器学习模型。

构建要素的过程非常耗时，因为每个新要素通常需要几个步骤来构建，尤其是在使用多个表中的信息时。我们可以将特征创建的操作分为两类:转换和聚合。让我们来看几个例子，看看这些概念是如何运用的。

一个转换通过从一个或多个现有列中创建新的特性来作用于单个表(从 Python 的角度来看，表就是一个熊猫DataFrame)。例如，如果我们有下面的客户表

我们可以通过找到joined列的月份或获取income列的自然日志来创建特征。这两个都是转换，因为它们只使用一个表中的信息。

另一方面，聚合是跨表执行的，使用一对多关系对观察值进行分组，然后计算统计数据。例如，如果我们有另一个关于客户贷款信息的表，其中每个客户可能有多笔贷款，我们可以计算每个客户贷款的平均值、最大值和最小值等统计数据。

这个过程包括按客户机对 loans 表进行分组，计算聚合，然后将结果数据合并到客户机数据中。下面是我们如何使用熊猫的语言在 Python 中做到这一点。

这些操作本身并不难，但是如果我们有几百个变量分布在几十个表中，这个过程手工做是不可行的。理想情况下，我们希望有一个解决方案，能够自动执行跨多个表的转换和聚合，并将结果数据合并到单个表中。尽管熊猫是一个很好的资源，但是我们想要手工处理的数据却很有限！(关于手动特征工程的更多信息，请查阅优秀的 Python 数据科学手册)。

功能工具

幸运的是，featuretools 正是我们正在寻找的解决方案。这个开源 Python 库将从一组相关表中自动创建许多要素。Featuretools 基于一种被称为“深度特征合成的方法，这听起来比实际上更有气势(这个名字来自于堆叠多个特征，而不是因为它使用了深度学习！).

深度特征合成将多个转换和聚合操作(在 featuretools 的 vocab 中称为特征基元)堆叠在一起，从分布在多个表中的数据创建特征。像机器学习中的大多数想法一样，这是一种建立在简单概念基础上的复杂方法。通过一次学习一个构建模块，我们可以很好地理解这个强大的方法。

首先，让我们看看我们的示例数据。我们已经看到了上面的一些数据集，完整的表集合如下:

clients:信用社客户基本信息。每个客户端在该数据帧中只有一行

loans:对客户的贷款。每个贷款在此数据框架中只有自己的行，但客户可能有多个贷款。

payments:贷款付款。每笔付款只有一行，但每笔贷款将有多次付款。

如果我们有一个机器学习任务，例如预测客户是否会偿还未来的贷款，我们会希望将客户的所有信息合并到一个表中。这些表是相关的(通过client_id和loan_id变量),我们可以使用一系列的转换和聚合来手工完成这个过程。然而，我们很快就会看到，我们可以使用 featuretools 来自动化这个过程。

实体和实体集

featuretools 的前两个概念是实体和实体集。一个实体仅仅是一张桌子(或者一个DataFrame，如果你认为是熊猫的话)。一个 EntitySet 是表和它们之间关系的集合。可以把 entityset 想象成另一个 Python 数据结构，有自己的方法和属性。

我们可以使用以下方法在 featuretools 中创建一个空的 entityset:

import featuretools as ft# Create new entityset
es = ft.EntitySet(id = 'clients')

现在我们必须添加实体。每个实体必须有一个索引，它是一个包含所有唯一元素的列。也就是说，索引中的每个值在表中只能出现一次。clients数据帧中的索引是client_id，因为每个客户端在该数据帧中只有一行。我们使用以下语法将具有现有索引的实体添加到 entityset 中:

loans数据帧也有一个惟一的索引loan_id ，将它添加到 entityset 的语法与clients相同。然而，对于payments数据帧，没有唯一的索引。当我们将这个实体添加到 entityset 时，我们需要传入参数make_index = True并指定索引的名称。此外，尽管 featuretools 会自动推断实体中每一列的数据类型，但我们可以通过将列类型的字典传递给参数variable_types来覆盖这一点。

对于该数据帧，尽管missed是一个整数，但它不是一个数值变量，因为它只能取 2 个离散值，所以我们告诉 featuretools 将它视为一个分类变量。将数据帧添加到 entityset 后，我们检查其中的任何一个:

通过我们指定的修改，已经正确地推断出了列类型。接下来，我们需要指定 entityset 中的表是如何关联的。

表关系

考虑两个表之间的关系的最好方法是用父子关系的类比。这是一个一对多的关系:每个父母可以有多个孩子。在表的领域中，父表中每个父表都有一行，但是子表中可能有多行对应于同一父表的多个子表。

例如，在我们的数据集中，clients数据帧是loans数据帧的父数据帧。每个客户端在clients中只有一行，但在loans中可能有多行。同样，loans是payments的父代，因为每笔贷款都有多次支付。父母通过一个共享变量链接到他们的孩子。当我们执行聚合时，我们按照父变量对子表进行分组，并计算每个父变量的子表的统计数据。

为了在 featuretools 中形式化一个关系，我们只需要指定将两个表链接在一起的变量。clients和loans工作台通过client_id变量连接，loans和payments通过loan_id连接。创建关系并将其添加到 entityset 的语法如下所示:

entityset 现在包含三个实体(表)以及将这些实体链接在一起的关系。在添加实体和形式化关系之后，我们的 entityset 就完成了，我们可以开始创建特性了。

特征基元

在我们能够深入进行特征合成之前，我们需要理解特征原语。我们已经知道这些是什么，但是我们只是用不同的名字来称呼它们！这些只是我们用来形成新特征的基本操作:

聚合:在父子(一对多)关系中完成的操作，按父项分组并计算子项的统计数据。一个例子是通过client_id对loan表进行分组，并找到每个客户的最大贷款金额。
转换:对单个表到一个或多个列的操作。例如，取一个表中两列的差值或一列的绝对值。

在 featuretools 中，使用这些图元单独或堆叠多个图元来创建新特征。下面是 featuretools 中一些特征原语的列表(我们也可以定义自定义原语):

Feature Primitives

这些图元可以单独使用，也可以组合使用来创建特征。为了用指定的图元制作特征，我们使用ft.dfs函数(代表深度特征合成)。我们传入entityset、target_entity，这是我们想要添加特性的表、选择的trans_primitives(转换)和agg_primitives(聚合):

结果是每个客户端的新特性的数据框架(因为我们让客户端成为了target_entity)。例如，我们有每个客户加入的月份，这是一个转换功能原语:

我们还有许多聚合原语，例如每个客户的平均支付金额:

尽管我们只指定了几个特征基元，featuretools 通过组合和堆叠这些基元创建了许多新的特征。

完整的数据框架有 793 列新功能！

深度特征合成

我们现在已经具备了理解深度特征合成(dfs)的所有要素。事实上，我们已经在前面的函数调用中执行了 dfs！深度特征是由多个图元堆叠而成的简单特征，而 dfs 是制造这些特征的过程的名称。深度特征的深度是制造该特征所需的基元数。

例如，MEAN(payments.payment_amount) 列是深度为 1 的深度特征，因为它是使用单个聚合创建的。深度为 2 的特征是LAST(loans(MEAN(payments.payment_amount)) 这是通过堆叠两个聚合实现的:最后一个(最近的)在平均值之上。这表示每个客户最近贷款的平均支付规模。

我们可以将特性堆叠到任何我们想要的深度，但是实际上，我从来没有超过 2 的深度。在这一点上，这些特征很难解释，但我鼓励任何感兴趣的人尝试“深入”。

我们不必手动指定特征原语，而是可以让 featuretools 自动为我们选择特征。为此，我们使用相同的ft.dfs函数调用，但不传递任何功能原语:

Featuretools 已经建立了许多新功能供我们使用。虽然这一过程确实会自动创建新功能，但它不会取代数据科学家，因为我们仍然需要弄清楚如何处理所有这些功能。例如，如果我们的目标是预测客户是否会偿还贷款，我们可以寻找与特定结果最相关的特征。此外，如果我们有领域知识，我们可以使用它来选择特定的特征基元或种子与候选特征的深度特征合成。

后续步骤

自动化特征工程解决了一个问题，但也产生了另一个问题:太多的特征。虽然在拟合模型之前很难说这些特征中的哪一个是重要的，但很可能不是所有的特征都与我们想要训练模型的任务相关。此外，拥有太多的特性会导致模型性能不佳，因为不太有用的特性淹没了那些更重要的特性。

太多特征的问题被称为维数灾难。随着特征数量的增加(数据维度的增长)，模型学习特征和目标之间的映射变得越来越困难。事实上，模型运行良好所需的数据量与特性数量成指数关系。

通过特征缩减(也称为特征选择)来对抗维数灾难:去除不相关特征的过程。这可以采取多种形式:主成分分析(PCA)、选择最佳、使用来自模型的特征重要性或者使用深度神经网络的自动编码。然而，特性缩减是另一篇文章的不同主题。现在，我们知道我们可以使用 featuretools 从许多表格中以最小的努力创建大量的特征！

结论

像机器学习中的许多主题一样，使用 featuretools 的自动化特征工程是一个建立在简单思想基础上的复杂概念。使用实体集、实体和关系的概念，featuretools 可以执行深度特征合成以创建新特征。深度特征合成反过来堆叠特征基元— 聚合、跨表之间的一对多关系起作用，以及转换、应用于单个表中的一个或多个列的函数—以从多个表构建新特征。

在以后的文章中，我将展示如何在一个现实世界的问题上使用这种技术，这个问题就是目前在 Kaggle 上举办的家庭信用违约风险竞赛。敬请关注那篇文章，同时，请阅读这篇介绍，开始竞争！我希望您现在可以使用自动化特征工程作为数据科学管道中的辅助工具。我们的模型的好坏取决于我们提供给它们的数据，自动化特征工程有助于提高特征创建过程的效率。

有关 featuretools 的更多信息，包括高级用法，请查看在线文档。要了解 featuretools 在实践中是如何使用的，请阅读 Feature Labs 的工作，这是开源库背后的公司。

一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @koehrsen_will 联系。

使用文本特征为文本数据自动生成特征

原文：https://towardsdatascience.com/automated-features-generation-for-text-data-using-textfeatures-c814f2b46eb1?source=collection_archive---------10-----------------------

Image Courtesy: https://pixabay.com/en/knowledge-book-library-glasses-1052010/

许多 Kaggle 竞赛的获胜者和数据科学家都强调一件事，那就是“特征工程”，它能让你在竞赛中名列前茅。不管你的模型有多复杂，好的特征总是会比其他的更好地帮助你的机器学习模型建立过程。

什么是特征工程？

功能只不过是列/维度，而功能工程是基于领域知识或统计原则创建新功能或预测器的过程。特征工程一直伴随着机器学习，但最新的是自动化特征工程，最近研究人员开始使用机器学习本身来创建有助于模型准确性的新特征。虽然大多数自动化工程解决的是数字数据，但文本数据由于其固有的非结构化性质，在这场竞争中总是被排除在外。我可以说，没有了。

textfeatures — R 包

密苏里大学的助理教授 Michael Kearney 在 R 社区以现代 twitter 包 rtweet 而闻名，他提出了一个新的 R 包，名为textfeatures，它基本上可以为你提供的任何文本数据生成一系列特性。在你梦想基于深度学习的自动化文本特征工程包之前，这不是。这使用非常简单的文本分析原理，并生成诸如大写字母的数量、标点符号的数量之类的特征——简单明了的东西，没有什么特别的，但非常有用。

装置

textfeatures可以直接从起重机上安装，开发版本可以从 github 上获得。

install.packages("textfeatures")

用例

在本帖中，我们将使用textfeatures包为来自英国的 Fifa 官方世界杯 ios 应用评论生成功能。我们将 R 包itunesr来提取评论和tidyverse进行数据操作和绘图。

加载所需的包:

让我们加载所有需要的包。

#install.packages("itunesr")
#install.packages("textfeatures")
#install.packages("tidyverse")library(itunesr)
library(textfeatures)
library(tidyverse)

提取最近的评论:

#Get UK Reviews of Fifa official world cup ios app
#https://itunes.apple.com/us/app/2018-fifa-world-cup-russia/id756904853?mt=8reviews1 <- getReviews(756904853,"GB",1)
reviews2 <- getReviews(756904853,"GB",2)
reviews3 <- getReviews(756904853,"GB",3)
reviews4 <- getReviews(756904853,"GB",4)#Combining all the reviews into one dataframe
reviews <- rbind(reviews1,
                 reviews2,
                 reviews3,
                 reviews4)

神奇开始了:

既然我们已经得到了评论，让我们让 textfeatures 发挥它的魔力吧。我们将使用函数textfeatures()来完成这项工作。

#Combining all the reviews into one dataframe
reviews <- rbind(reviews1,
                 reviews2,
                 reviews3,
                 reviews4)# generate text features
feat <- textfeatures(reviews$Review)# check what all features generated 
glimpse(feat)
Observations: 200
Variables: 17
$ n_chars         149, 13, 263, 189, 49, 338, 210, 186, 76, 14, 142, 114, 242, ...
$ n_commas        1, 0, 0, 0, 0, 1, 2, 1, 1, 0, 1, 1, 0, 3, 0, 0, 1, 0, 3, 1, 0...
$ n_digits        0, 0, 6, 3, 0, 4, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0...
$ n_exclaims      0, 0, 2, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0...
$ n_extraspaces   1, 0, 0, 0, 0, 3, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 4, 0...
$ n_hashtags      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_lowers        140, 11, 225, 170, 46, 323, 195, 178, 70, 12, 129, 106, 233, ...
$ n_lowersp       0.9400000, 0.8571429, 0.8560606, 0.9000000, 0.9400000, 0.9557...
$ n_mentions      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_periods       2, 0, 5, 1, 0, 0, 3, 1, 2, 0, 2, 1, 1, 2, 0, 0, 4, 2, 0, 4, 0...
$ n_urls          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_words         37, 2, 55, 45, 12, 80, 42, 41, 14, 3, 37, 28, 50, 16, 15, 8, ...
$ n_caps          4, 1, 12, 8, 2, 7, 3, 4, 2, 2, 6, 4, 6, 2, 3, 1, 6, 4, 29, 9,...
$ n_nonasciis     0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...
$ n_puncts        2, 1, 7, 0, 1, 3, 4, 1, 1, 0, 4, 2, 2, 0, 1, 0, 1, 1, 0, 7, 2...
$ n_capsp         0.03333333, 0.14285714, 0.04924242, 0.04736842, 0.06000000, 0...
$ n_charsperword  3.947368, 4.666667, 4.714286, 4.130435, 3.846154, 4.185185, 4...

从上面可以看到，textfeatures 已经创建了 17 个新功能。请注意，这些功能对于任何文本数据都是一样的。

可视化结果:

对于这篇文章，我们不会建立一个机器学习模型，但这些特征可以很好地用于建立一个分类模型，如情感分类或类别分类。

但是现在，我们只是用一些特征来想象结果。

我们可以根据评论评分，查看字符数和每个单词的字符数之间是否有任何关系。一个假设可能是，给予好评的人不会写得太长或其他。我们不打算在这里验证它，只是用散点图可视化。

# merging features with original reviews
reviews_all % 
  ggplot(aes(n_charsperword, n_chars, colour = Rating)) + geom_point()

给出了这个图:

让我们用不同的情节从不同的角度来看同一个假设，但是要用一些单词而不是一些字符来比较。

reviews_all %>% 
  ggplot(aes(n_charsperword, n_words)) + geom_point() +
  facet_wrap(~Rating) +
  stat_smooth()

给出了这个图:

因此，您可以使用textfeatures自动生成新的特征，并更好地理解您的文本数据。希望这篇文章能帮助你开始使用这个漂亮的软件包，如果你想了解更多关于文本分析的知识，请查看由朱莉娅·西尔格撰写的这篇教程。这里使用的完整代码可以在我的 github 上获得。

本帖最初发表于 DS+

SageMaker 中的自动化超参数优化

原文：https://towardsdatascience.com/automated-hyper-parameter-optimization-in-sagemaker-492f4c5205b4?source=collection_archive---------9-----------------------

注:代码示例在 我的博客 上呈现比在介质上好得多。

什么是超参数优化(HPO)？

因此，您已经构建了您的模型，并获得了合理的结果，现在准备尽可能多地挤出性能。一种可能是进行网格搜索，在那里你尝试超参数的每一种可能的组合，并选择最好的一个。如果您的选择数量相对较少，这种方法很有效，但是如果您有大量的超参数，并且有些是可能跨越几个数量级的连续值，那该怎么办呢？随机搜索可以很好地探索参数空间，而无需致力于探索所有的参数空间，但是在黑暗中随机探索是我们能做的最好的事情吗？

当然不是。贝叶斯优化是一种在进行顺序决策时优化功能的技术。在这种情况下，我们试图通过选择超参数值来最大化性能。这种顺序决策框架意味着，您为下一步选择的超参数将受到所有先前尝试的性能的影响。贝叶斯优化做出关于如何平衡探索参数空间的新区域和利用已知表现良好的区域的原则性决定。这就是说，使用贝叶斯优化通常比网格搜索和随机搜索更有效。

怎么做

好消息是 SageMaker 使这变得非常容易，因为该平台负责以下事项:

实施贝叶斯优化算法来处理分类、整数和浮点超参数
在给定一组来自 HPO 服务的超参数的情况下，协调模型的训练和评估
整合培训作业和 HPO 服务，后者会传达选定的超参数值，并在作业完成后报告绩效

先决条件

下面的代码将假设我们正在使用 TensorFlow 估计器模型，但是与 HPO 相关的部分应该扩展到任何 SageMaker 估计器。要以本示例所示的方式运行代码，您需要以下内容:

对 SageMaker 的工作原理有所了解。如果你想要一些这样的例子，在这个回购中有几个官方笔记本例子。你可能会发现 TensorFlow HPO 的例子特别相关。
有 SageMaker 的 Python SDK
已经配置了必要的 API 权限，或者正在 SageMaker 笔记本实例中运行

步骤 1-创建评估者

使用 SageMaker 运行 HPO 的一个关键要求是，您的模型需要:

预计超参数将从 SageMaker 传递
将性能指标写入日志

对于内置算法，这已经为您完成了。在使用 SageMaker 构建任意张量流模型的情况下，这意味着在model.py文件中正确配置东西，也称为“入口点”。这是 SageMaker 用来构建 TensorFlow 模型的文件，它希望定义符合特定输入/输出模式的某些函数。(有关您需要指定的功能的更多详细信息，请参见 TensorFlow 自述文件。)

让您的模型准备好接受 SageMaker 的超参数

为了动态地指定参数值，您的模型代码需要接受、解析和利用它们。在 TensorFlow 中，您允许 SageMaker 通过向需要在入口点文件中指定的函数添加hyperparameters参数来指定超参数。例如，对于model_fn中需要的超参数:

DEFAULT_LEARNING_RATE = 1e-3
def model_fn(features, labels, mode, hyperparameters=None):
    if hyperparameters is None:
        hyperparameters = dict()
    # Extract parameters
    learning_rate = hyperparameters.get('learning_rate', DEFAULT_LEARNING_RATE)
    ...

您可能还希望在train_input_fn中有一个超参数，例如指定训练时期的数量:

def train_input_fn(training_dir, hyperparameters=None):
    # Extract parameters
    if not hyperparameters:
        hyperparameters = dict() epochs = hyperparameters.get('epochs', None)
    ...

如果指定了参数，这些示例提取参数，如果没有指定，则使用默认值。

将性能指标写入日志

将性能指标写入日志的第二个要求是 SageMaker 的一个实现细节:它通过从训练日志文本中提取模型性能来获得运行的模型性能。这些是发送回 HPO 引擎的值。

对于 TensorFlow，默认情况下，EstimatorSpec中指定的指标会写入日志。例如，这段代码是我的model_fn的一部分:

def model_fn(features, labels, model, hyperparameters=None)
    ...
    if mode == tf.estimator.ModeKeys.EVAL:
        eval_metric_ops = {
            "roc_auc": tf.metrics.auc(
                labels, 
                predictions,
                summation_method='careful_interpolation'),
            "pr_auc": tf.metrics.auc(
                labels, 
                predictions, 
                summation_method='careful_interpolation', 
                curve='PR'),
        }
    else:
        # e.g. in "training" mode
        eval_metric_ops = {} return tf.estimator.EstimatorSpec(
        mode=mode,
        loss=loss,
        train_op=train_op,
        eval_metric_ops=eval_metric_ops,
    )

在训练期间，模型将定期停止并评估测试集(这个过程的细节可以由您配置)。这些事件的日志如下所示:

*2018–10–02 17:23:40,657 INFO — tensorflow — Saving dict for global step 101: global_step = 101, loss = 0.45420808, pr_auc = 0.36799875, roc_auc = 0.6891242*

这是 SageMaker 将用来衡量任何特定培训工作的表现。

构建评估器

评估员通常用于开始一项培训工作。这使您能够告诉 SageMaker 在哪里存储输出，哪些实例用于训练…等等。既然入口点文件中的函数已经正确配置为接受超参数并将性能指标写入日志，您就可以创建 TensorFlow 估计器了:

from sagemaker.tensorflow import TensorFlow# The parameters that are constant and will not be tuned
shared_hyperparameters = {
    'number_layers': 5,
}tf_estimator = TensorFlow(
    entry_point='my/tensorflow/model.py',
    role='<sagemaker_role_arn>',
    train_instance_count=1,
    train_instance_type='ml.p3.2xlarge',
    training_steps=10000,
    hyperparameters=shared_hyperparameters,
)

步骤 2 —定义绩效指标

在这一步，我们需要告诉 SageMaker 如何从日志中提取性能信息。这是通过指定一个正则表达式并将其分配给一个度量名称来实现的。尽管您可以指定多个表达式(AWS CloudWatch 会自动收集这些表达式以便于绘图/监控)，但需要挑出其中一个作为 HPO 的优化目标。您还需要指定是最大化还是最小化数量。注意，虽然正则表达式可能匹配多个日志条目，但是日志中的最后一个实例作为最终性能值返回。

objective_metric_name = 'PR-AUC'
objective_type = 'Maximize'
metric_definitions = [
    {'Name': 'ROC-AUC', 'Regex': 'roc_auc = ([0-9\\.]+)'},
    {'Name': 'PR-AUC', 'Regex': 'pr_auc = ([0-9\\.]+)'}
]

步骤 3-定义超参数搜索空间

我们现在需要指定我们的超参数被称为什么，它们是什么类型(连续、整数或分类)，以及它们的可能值是什么。下面是一个例子:

from sagemaker.tuner import (
    IntegerParameter, CategoricalParameter, 
    ContinuousParameter, HyperparameterTuner)hyperparameter_ranges = {
    "learning_rate": ContinuousParameter(1e-5, 1e-1),
    "number_nodes": IntegerParameter(32, 512),
    "optimizer": CategoricalParameter(['Adam', 'SGD'])
}

步骤 4-指定优化迭代的次数

最后，我们需要决定如何运行 HPO 作业。如果您并行运行许多作业，那么您可以同时探索大部分空间。然而，如果您只是并行运行一百万个作业，那么您实际上是在进行随机搜索。贝叶斯优化的顺序本质允许之前运行的结果通知未来的运行。

因此，我们需要决定总共运行多少个作业，以及在任何给定时间并行运行多少个作业。例如，我们可能运行 100 个作业，并行运行 5 个。总共有 20 次连续迭代，每次探索 5 个点。这里的选择将取决于参数空间的大小和预算。

现在你有了要求 SageMaker 管理 HPO 所需的一切:

tuner = HyperparameterTuner(
    tf_estimator,
    objective_metric_name,
    hyperparameter_ranges,
    metric_definitions,
    max_jobs=100,
    max_parallel_jobs=5,
    objective_type=objective_type
)# The data configuration
channel = {
    'training': 's3://<bucket_name>/my/training_file.csv',
    'test': 's3://<bucket_name>/my/test_file.csv',
}tuner.fit(inputs=channel)

最终性能

您可以使用 sdk 来 pinging SageMaker 以获得状态报告，或者从 HPO 运行中获得最佳作业的统计数据。您还可以从 AWS SageMaker 控制台完成这项工作，它很好地显示了所有作业的性能摘要以及 HPO 作业配置。

如上所述，你可以在控制台中进入 CloudWatch，点击Browse Metrics，找到你在第二步metric_definitions的Name字段中定义的指标。

完成所有工作后，您只需发出以下命令即可部署最佳模型:

tuner.deploy(
    initial_instance_count=1,
    instance_type='ml.p3.2xlarge'
)

你可以在【blog.zakjost.com】找到我所有的内容并订阅**

自动化机器学习:深度的不同概念

原文：https://towardsdatascience.com/automated-machine-learning-a-different-notion-of-deep-e0f7e5c06fb2?source=collection_archive---------14-----------------------

机器与人的关系是否达到了一个全新的水平？

Photo by Robin Joshua on Unsplash

计算机编程是自动化，机器学习是自动化自动化。那么，自动化机器学习就是自动化自动化的自动化。

——塞巴斯蒂安·拉什卡

自动机器学习已经在人工智能的雷达下好几年了。尽管像亚马逊和谷歌这样的大公司已经推出了他们的 AutoML 工具，但 ICML 的 AutoML 研讨会已经引起了人们的极大兴趣，研究朝着理解机器学习问题的本质迈出了重要的一步，AutoML 仍然是一个小众术语，为数据科学社区的先锋派保留。

可能被深度学习的狂热所掩盖，显然还没有成熟到让我们眼花缭乱的应用程序，AutoML 还没有被理解或明确定义。人机关系的下一步？对人工智能更深层次的理解？

重要的发现通常是事后承认的，因为社会需要经历、理解和评价它们。尤其是当涉及到人工智能时，很容易只见树木不见森林，因为事情正在变得更深——但是向哪个方向更深呢？

什么是 AutoML？

1。在训练机器学习模型中插入更多的自动化。

等等，机器学习模型不是已经自动训练好了吗？部分是的，这就是为什么我们称之为机器学习，因为算法根据我们给它们的数据自己“学习”。然而，最繁琐、最耗时的任务，那些传统上在发布惊人结果时被低估的任务，与模型的实际训练无关。

机器学习 75%是准备做机器学习……15%是你之后做的。

—里奇·卡鲁阿纳，ICML 2015

参与机器学习实验的任何人都认识到，好的结果很容易得到，但满意的结果需要时间、聪明的设计、该领域的经验，而且往往需要一点运气才能实现。卡鲁阿纳提到的实验的 90%是预处理、特征提取、超参数调整、算法选择、模型评估和 ML 流水线的其他可能步骤。

AutoML 主要关注的步骤是超参数调整，这通常是指为学习算法的超参数选择最佳值，这是它自己无法选择的。例如，神经网络自己学习最佳权重，但是对于 ML 实践者来说，定义层的数量、神经元的数量和学习速率是一项任务，并且是最乏味的任务。因为调优是一项定义明确的任务，所以它一直是 AutoML 工具的主要目标。

2。从 ML 实验的应用中收集元知识。

那么，一个人能从 ML 实验中得到什么呢？希望是个好模特。对数据的一些见解，可能。一个更有经验的数据科学家，可以说是唯一的长期收获。但是这种新获得的经验的实质是什么呢？数据科学家已经理解了 ML 问题的性质，已经下意识地认识到一些模式，并且当他在将来面对类似的问题时，他将能够重用他的知识并提供更快、更直接的解决方案。

这是元学习领域背后的本质:当解决一个不属于模型的 ML 问题时，创建元知识，但它足够一般化以用于其他情况。

从数据集中提取元特征是 AutoML 工具中经常使用的一种技术，用于初始化学习算法的超参数:如果您知道一些值在特定问题中工作得很好，为什么不在解决类似问题时从它们开始呢？正是在制定和量化数据集之间的相似性方面，元学习和人类经验的挑战仍然超过人工智能。

3。跨学习任务传递知识。

如果元学习与创造元知识有关，那么迁移学习就是寻找使用元知识的正确方法。你可能已经听说过成功使用迁移学习的应用:一个玩不同雅达利游戏的深度神经网络和一个为《我的世界》学习技能的代理，是少数几个例子。

迁移学习可以从简单的(简单地跨问题传递数据或训练模型)到更微妙的(重用良好的超参数化)到高度复杂的(机器学习算法不仅学习特定问题的好解决方案，还学习可以重用的技能)。

现在很明显，AutoML 的研究正专注于更高层次的机器学习:既然我们已经练习机器学习几十年了，我们是否已经达到了允许我们清楚地制定它并教给别人的理解水平？谁比机器更适合做学生呢？

那些知道的人会去做。理解的人，教导。

——亚里士多德

什么不是 AutoML？

1。更多的 GPU/CPU。

强大的计算能力意味着巨大的责任。说最近深度学习的突破只能归功于一些研究小组拥有的巨大计算能力是不公平的。这涉及到大量的直觉、经验和创造力，但准确地说，如果没有这种计算能力，深度学习是不可行的。

通过给一个简单的技术，如网格搜索，提供大量的资源来实现一个优秀的超参数化，不是 AutoML 。在1202 CPU 和176 GPU上训练得到好的模型不是 AutoML 。AutoML 是关于通过利用过去的经验做出明智的决策，以使机器学习更少暴力，更智能。从面向应用的深度学习到面向抽象的自动化需要研究社区在方法和工具上的转变，但这可能是唯一的？)超越我们在大多数应用程序中仍然存在的性能障碍的方法，如强化学习。

2。一个神奇的盒子，给出了一个很好的预测模型。

诚然，AutoML的短暂历史揭示了我们最初的希望是这样实现的:一个黑盒，它接收请求并返回可能的最佳模型。不需要数据科学家，不需要理解问题的性质，不需要透明的实验界面。纯自动化。

虽然我们不能确定这种方法失败是因为它总体上是错误的，还是因为我们的技术没有准备好支持它，但它确实感觉与我们迄今为止的人类经验形成了对比:自动化只有在深入理解一个问题之后才会出现。我们真的不知道强人工智能会是什么样子，但是黑匣子听起来像是一个不真实的(安静的赛博朋克)场景。

3。将导致数据科学家灭绝的陨石。

直到我们到达一个点，整个人类变得过时，生活在矩阵中，我们仍然需要数据科学家。无论我们的机器学习工具和一般技术变得多么先进，我们都需要一个人在回路中。事实上，一项技术变得越复杂，你就越需要更有经验、想象力和分析能力的科学家来掌握它。

AutoML 工具目前作为数据科学家的助手销售，可以承担和改进 ML 管道的一些步骤，但仍然需要人来协调和检查实验。只要你保持不断提高的技能、好奇心和对世界的独特视角，你就不是可有可无的——作为一名数据科学家、一名员工和一个普通人。

Data scientists in 10 years from now? Opinions differ. Original image credit: https://kevbrockschmidt.wordpress.com/tag/archive/

快速了解 AutoML

AutoML 是一个年轻的研究领域，所以通过研究相关的工具和思想，很容易很好地理解它。自然，这些想法都是老的，在不同的领域已经成熟。观察研究团体如何通过定义问题和融合这些想法来响应对 AutoML 的需求是令人兴奋的！(好吧，对于像我这样的计算机科学家来说，主观上是令人兴奋的。)

现金问题

AutoML 问题的第一个定义可能是由 AutoWEKA 团队提供的，他们试图将组合算法选择和超参数优化问题自动化。这个问题有一个优雅的数学公式，但是，简单地说，这个问题就是:

哪种 ML 算法(SVM？神经网络？)以及它的什么参数化(内核？层数？)在为数据集设计 ML 解决方案时，我应该使用什么？

没有免费的午餐定理

在选择最大似然算法时，所有数据科学家都有自己的偏好。神经网络引起了人们极大的兴趣，但是有各种各样的算法。因为决定通常是应用、品味和习惯的产物，所以很自然地会想:

有没有一种 ML 算法永远是最佳选择？

简短的答案是否定的。由《没有免费的午餐定理》的作者提供的长答案更具技术性，但主要归结为这样一个事实:如果我们在所有可能的数据集(生成数据的概率分布)上平均所有最大似然算法的性能，性能是相同的。因此，AutoML 无法将算法选择任务自动化到只有一种算法将用于所有应用的程度。

贝叶斯优化

那么，如何找到最佳算法及其参数化呢？嗯，这只不过是一个优化问题，我们目前一直在用众所周知的“试试看”的方法来解决这个问题。

由于这种方法对于大型搜索空间(比如深度神经网络)来说效率低下，数据科学家需要(指数级)更多的 GPU 或更好的优化方法。

贝叶斯优化是一种吸引了大量兴趣的技术(参见 auto-sklearn)，因为它是优化黑盒函数的有效方法:如果我们假设神经网络中的层数与其实现的性能之间存在关系，那么我们可以通过将它建模为概率分布来尝试近似这种关系。

贝叶斯优化从假设一个模型(通常是统一的模型)开始。然后，is 通过挑选若干层并实验性地评估性能来对搜索空间进行采样。在此之后，可以通过对样本拟合概率分布来更新模型，并且算法将基于当前模型挑选最有可能使性能最大化的值作为下一个样本。通过迭代这个过程，我们可以得到一个精确的模型和一个好的参数值。

Bayesian optimization: the yellowish line is the true model and the purple is the approximation, along with its confidence intervals, which we improve by sampling the search space. Original image credit and an in-depth explanation of Bayesian optimization: http://krasserm.github.io/2018/03/21/bayesian-optimization/

现有工具

AutoML 工具似乎遵循两个不同的指令:它们要么是以研究为导向的框架，专注于自动化 ML 管道的特定步骤，要么是成熟的市场产品。

Auto-sklearn 专注于现金问题。它采用贝叶斯优化和元学习来智能地搜索组合算法-超参数空间。Auto-sklearn 在 ChaLearn AutoML 和 KDnuggets 比赛中被证明非常有效，可能是因为它在模型形成问题中融入了集成学习。

HPO 图书馆，是一个超参数优化库，可以证明非常有用的研究目的，因为它提供了一个统一的接口，其他三个 AutoML 软件包:SMAC，留兰香和 TPE。不幸的是，它的开发已经停止。

r 也拥抱了自动化的精神。Caret 更像是一个接口，而不是一个自治的包，它通过提供一个简单的 ML 实验接口来解决众所周知的 R 包的多样性。Caret 主要自动化 ML 管道的形成，但是步骤仍然是常规的。

然后，是营销产品，数据科学家可以使用，但不能扩展。数据科学家或公司可以选择使用谷歌的 Cloud AutoML、微软的 Azure 或亚马逊的网络服务。这些工具提供了优雅的界面、强大的后端处理能力以及设计良好实验的有用提示。然而，市场还远未声称 AutoML 已经完善，因为这些工具不能被盲目信任来解决端到端的 ML 问题。

为什么你应该关心

AutoML 对于数据科学家来说是一个全新的工具。和所有的工具一样，它可以被珍视，被误用或者生锈。作为一名数据科学家，您可以选择使用 AutoML now 作为助手，将您从预处理数据或调整模型的繁琐任务中解放出来，从而提高您的工作效率。或者，你可以投入时间成为一名 AutoML 专家，并将其作为未来就业市场的战略武器，或者作为一个行业的挡箭牌，该行业将琐碎的事情自动化，但仍在努力解决智能的非平凡性——人工或非人工。

最后，作为不断发展与技术关系的人类社会的一部分，我们应该记住，问题不总是我们应该自动化什么，而是有时可能是:我们不应该自动化什么？

我们生活在一个奇怪的时代。我们可以去任何我们想去的地方旅行，甚至去其他星球。为了什么？日复一日地坐着，士气和希望都在下降。
― 菲利普·K·蒂克，高高城堡里的人

Python 中的自动机器学习超参数调整

原文：https://towardsdatascience.com/automated-machine-learning-hyperparameter-tuning-in-python-dfda59b72f8a?source=collection_archive---------0-----------------------

Python 中使用贝叶斯优化进行自动超参数调优的完整演练

调整机器学习超参数是一项繁琐而又至关重要的任务，因为算法的性能可能高度依赖于超参数的选择。手动调整会占用机器学习管道中重要步骤的时间，如特征工程和解释结果。网格和随机搜索不需要手动操作，但是需要很长的运行时间，因为它们浪费时间评估搜索空间中没有希望的区域。越来越多的超参数调整是通过自动化方法完成的，这些方法旨在使用信息搜索在更短的时间内找到最佳超参数，除了初始设置之外，无需任何人工操作。

贝叶斯优化，一种基于模型的寻找函数最小值的方法，最近已经应用到机器学习超参数调整，结果表明这种方法可以在测试集上实现更好的性能，同时比随机搜索需要更少的迭代。此外，现在有许多 Python 库使得实现贝叶斯超参数调整对于任何机器学习模型都很简单。

在本文中，我们将使用 Hyperopt 库完成一个梯度增强机器的贝叶斯超参数调整的完整示例。在之前的一篇文章中，我概述了这个方法背后的概念，所以这里我们将坚持实现。像大多数机器学习主题一样，没有必要理解所有的细节，但知道基本思想可以帮助你更有效地使用技术！

本文的所有代码都可以从 GitHub 上的 Jupyter 笔记本中获得。

贝叶斯优化方法

作为一个简短的引子，贝叶斯优化通过基于目标的过去评估结果建立代理函数(概率模型)来找到使目标函数最小化的值。与目标相比，代理的优化成本更低，因此要评估的下一个输入值是通过对代理应用一个标准来选择的(通常是预期改进)。贝叶斯方法不同于随机或网格搜索，因为它们使用过去的评估结果选择下一个值来评估。其概念是:通过基于过去表现良好的输入值选择下一个输入值，限制目标函数的昂贵评估。

在超参数优化的情况下，目标函数是使用一组超参数的机器学习模型的验证误差。目标是找到在验证集上产生最低误差的超参数，希望这些结果可以推广到测试集。评估目标函数是昂贵的，因为它需要用一组特定的超参数来训练机器学习模型。理想情况下，我们希望有一种方法能够探索搜索空间，同时限制对差的超参数选择的评估。贝叶斯超参数调整使用持续更新的概率模型，通过从过去的结果进行推理来“集中”于有希望的超参数。

Python 选项

Python 中有几个贝叶斯优化库，它们在目标函数的代理算法上有所不同。在本文中，我们将使用 Hyperopt，它使用了 Tree Parzen Estimator (TPE) 其他 Python 库包括 Spearmint (高斯过程代理)和 SMAC (随机森林回归)。在这个领域有很多有趣的工作在进行，所以如果你对一个库不满意，可以看看其他的库！一个问题的一般结构(我们将在这里遍历)在两个库之间转换，只有语法上的微小差异。关于 Hyperopt 的基本介绍，请参见本文。

最优化问题的四个部分

贝叶斯优化问题有四个部分:

目标函数:我们想要最小化什么，在这种情况下，机器学习模型关于超参数的验证误差
域空间:超参数值搜索结束
优化算法:构建替代模型和选择下一个超参数值进行评估的方法
结果历史:存储由超参数和验证损失组成的目标函数的评估结果

有了这四个部分，我们可以优化(找到最小值)任何返回一个实值的函数。这是一个强大的抽象，除了调优机器学习超参数之外，它还让我们解决了许多问题。

数据集

对于本例，我们将使用房车保险数据集，其目标是预测客户是否会购买保险。这是一个有 5800 个训练观测值和 4000 个测试点的监督分类问题。我们将使用曲线 (ROC AUC)下的接收器操作特征面积来评估性能，因为这是一个不平衡的分类问题。(ROC AUC 越高越好，1 分表示模型完美)。数据集如下所示:

Dataset (CARAVAN) is the label

因为远视需要一个最小化的值，我们将从目标函数返回 1-ROC AUC，从而提高 ROC AUC。

梯度推进模型

关于梯度提升机器 (GBM)的详细知识对于本文来说不是必需的，这里是我们需要理解的基础知识:GBM 是一种基于使用弱学习器(几乎总是决策树)的集成提升方法，这些弱学习器被顺序训练以形成强模型。在 GBM 中有许多超参数控制整个集合和个体决策树。选择树的数量(称为估计量)的最有效的方法之一是我们将使用的提前停止。 LightGBM 在 Python 中提供了一个快速简单的 GBM 实现。

关于 GBM 的更多细节，这里有一篇高级文章和一篇技术论文。

有了必要的背景知识之后，让我们来看一下为超参数调整编写贝叶斯优化问题的四个部分。

目标函数

目标函数是我们试图最小化的。它接受一组值——在本例中是 GBM 的超参数——并输出一个真实值以最小化交叉验证损失。Hyperopt 将目标函数视为一个黑盒，因为它只考虑什么进什么出。该算法不需要知道目标函数的内部，就可以找到使损失最小的输入值！在很高的层次上(用伪代码)，我们的目标函数应该是:

def objective(hyperparameters):
    """Returns validation score from hyperparameters"""

    model = Classifier(hyperparameters)
    validation_loss = cross_validation(model, training_data)        return validation_loss

我们需要小心不要使用测试组的损失，因为当我们评估最终模型时，我们只能使用测试组一次。相反，我们在验证集上评估超参数。此外，我们使用 KFold 交叉验证，而不是将训练数据分离到不同的验证集中，这除了保留有价值的训练数据之外，还会给我们测试集上的误差估计带来更少的偏差。

超参数调整的目标函数的基本结构在各个模型中是相同的:该函数接受超参数并使用这些超参数返回交叉验证误差。虽然这个例子是特定于 GBM 的，但是该结构可以应用于其他方法。

使用提前停止的 10 倍交叉验证的梯度增强机器的完整目标函数如下所示。

主线是cv_results = lgb.cv(...)。为了实现带有提前停止的交叉验证，我们使用 LightGBM 函数cv，它接受超参数、一个训练集、用于交叉验证的折叠数和几个其他参数。我们将估计器的数量(num_boost_round)设置为 10000，但是实际上不会达到这个数量，因为当 100 个估计器的验证分数没有提高时，我们使用early_stopping_rounds来停止训练。早期停止是选择估计量数量的有效方法，而不是将其设置为另一个需要调整的超参数！

一旦交叉验证完成，我们得到最好的分数(ROC AUC)，然后，因为我们想要一个值最小化，我们取 1-最好的分数。然后这个值作为返回字典中的loss键返回。

这个目标函数实际上比它需要的要复杂一点，因为我们返回一个值的字典。对于 Hyperopt 中的目标函数，我们可以返回一个值，即 loss，或者返回一个至少有关键字"loss"和"status"的字典。返回超参数将让我们检查每组超参数导致的损失。

领域空间

域空间表示我们想要为每个超参数评估的值的范围。每次搜索迭代，贝叶斯优化算法将从域空间中为每个超参数选择一个值。当我们进行随机或网格搜索时，域空间是一个网格。在贝叶斯优化中，想法是相同的，除了这个空间对于每个超参数具有概率分布而不是离散值。

指定领域是贝叶斯优化问题中最棘手的部分。如果我们有机器学习方法的经验，我们可以通过在我们认为最佳值的地方放置更大的概率来使用它来通知我们对超参数分布的选择。然而，最佳模型设置将因数据集而异，并且对于高维度问题(许多超参数),可能很难弄清楚超参数之间的相互作用。在我们不确定最佳值的情况下，我们可以使用宽分布，让贝叶斯算法为我们进行推理。

首先，我们应该查看 GBM 中的所有超参数:

import lgb# Default gradient boosting machine classifier
model = lgb.LGBMClassifier()
model**LGBMClassifier(boosting_type='gbdt', n_estimators=100,
               class_weight=None, colsample_bytree=1.0,
               learning_rate=0.1, max_depth=-1,                      
               min_child_samples=20,
               min_child_weight=0.001, min_split_gain=0.0, 
               n_jobs=-1, num_leaves=31, objective=None, 
               random_state=None, reg_alpha=0.0, reg_lambda=0.0, 
               silent=True, subsample=1.0, 
               subsample_for_bin=200000, subsample_freq=1)**

我不确定世界上是否有人知道所有这些是如何相互作用的！其中一些我们不必调优(比如objective和random_state)，我们将使用提前停止来找到最好的n_estimators。但是，我们还有 10 个超参数需要优化！当第一次调优一个模型时，我通常会创建一个以默认值为中心的宽域空间，然后在后续的搜索中对其进行优化。

例如，让我们在 Hyperopt 中定义一个简单的域，GBM 中每棵树的叶子数量的离散均匀分布:

from hyperopt import hp# Discrete uniform distribution
num_leaves = {'num_leaves': hp.quniform('num_leaves', 30, 150, 1)}

这是一个离散均匀分布，因为叶子的数量必须是一个整数(离散的)，并且域中的每个值都是同等可能的(均匀的)。

分布的另一种选择是对数均匀分布，它在对数尺度上均匀分布数值。我们将对学习率使用统一的对数(从 0.005 到 0.2)，因为它在几个数量级之间变化:

# Learning rate log uniform distribution
learning_rate = {'learning_rate': hp.loguniform('learning_rate',
                                                 np.log(0.005),
                                                 np.log(0.2)}

因为这是对数均匀分布，所以这些值在指数(低)和指数(高)之间绘制。下方左侧的图显示离散均匀分布，右侧的图显示对数均匀分布。这些是内核密度估计图，所以 y 轴是密度而不是计数！

Domain for num_leaves (left) and learning_rate (right)

现在，让我们定义整个域:

这里我们使用了许多不同的域分布类型:

choice:分类变量
quniform:离散均匀(间隔均匀的整数)
uniform:连续均匀(浮动间隔均匀)
loguniform:连续的均匀圆木(在圆木刻度上均匀分布的浮子)

(文档中还列出了其他发行版。)

当我们定义升压类型时，需要注意一个要点:

这里我们使用了一个条件域，这意味着一个超参数的值依赖于另一个超参数的值。对于增强类型"goss"，gbm 不能使用子采样(仅选择训练观察的 [subsample](https://astro.temple.edu/~msobel/courses_files/StochasticBoosting(gradient).pdf) 部分用于每次迭代)。因此，如果增强类型为"goss" ，则subsample比率设置为 1.0(无二次采样)，否则为 0.5–1.0。这是使用嵌套域实现的。

当我们使用具有完全独立参数的不同机器学习模型时，条件嵌套会很有用。条件允许我们根据 a choice的值使用不同的超参数集。

既然我们的领域已经定义好了，我们可以从中抽取一个例子来看看一个典型的样本是什么样子的。当我们采样时，因为subsample最初是嵌套的，我们需要将它赋给一个顶级键。这是使用 Python 字典get方法完成的，默认值为 1.0。

**{'boosting_type': 'gbdt',
 'class_weight': 'balanced',
 'colsample_bytree': 0.8111305579351727,
 'learning_rate': 0.16186471096789776,
 'min_child_samples': 470.0,
 'num_leaves': 88.0,
 'reg_alpha': 0.6338327001528129,
 'reg_lambda': 0.8554826167886239,
 'subsample_for_bin': 280000.0,
 'subsample': 0.6318665053932255}**

(这种嵌套键的重新分配是必要的，因为梯度推进机器不能处理嵌套的超参数字典)。

最优化算法

尽管这是贝叶斯优化在概念上最困难的部分，但在 Hyperopt 中创建优化算法只需一行代码。要使用树 Parzen 估计器，代码为:

from hyperopt import tpe# Algorithm
tpe_algorithm = tpe.suggest

这就是全部了！Hyperopt 只有 TPE 选项和随机搜索，尽管 GitHub 页面说其他方法可能会出现。在优化过程中，TPE 算法根据过去的结果构建概率模型，并通过最大化期望的改善来决定下一组超参数以在目标函数中进行评估。

结果历史

跟踪结果并不是绝对必要的，因为 Hyperopt 会在算法内部跟踪结果。然而，如果我们想知道幕后发生了什么，我们可以使用一个Trials对象，它将存储基本的训练信息以及从目标函数返回的字典(包括loss和params)。制作一个试验对象只需一行代码:

from hyperopt import Trials# Trials object to track progress
bayes_trials = Trials()

另一个允许我们监控长时间训练过程的选项是在每次搜索迭代中向 csv 文件中写入一行。这也将所有的结果保存到磁盘上，以防灾难性的事情发生，我们丢失了试验对象(根据经验)。我们可以使用csv库来做到这一点。在培训之前，我们打开一个新的 csv 文件，并写入标题:

然后在目标函数中，我们可以在每次迭代中添加要写入 csv 的行(完整的目标函数在笔记本中):

写入 csv 意味着我们可以在训练时通过打开文件来检查进度(尽管不在 Excel 中，因为这会导致 Python 中的错误。使用 bash 中的tail out_file.csv查看文件的最后几行)。

最佳化

一旦我们有了这四个部分，就用fmin进行优化:

每次迭代，该算法从基于先前结果构建的替代函数中选择新的超参数值，并在目标函数中评估这些值。对于目标函数的MAX_EVALS评估，这是持续的，代理函数随着每个新的结果不断更新。

结果

从fmin返回的best对象包含在目标函数上产生最低损失的超参数:

**{'boosting_type': 'gbdt',
   'class_weight': 'balanced',
   'colsample_bytree': 0.7125187075392453,
   'learning_rate': 0.022592570862044956,
   'min_child_samples': 250,
   'num_leaves': 49,
   'reg_alpha': 0.2035211643104735,
   'reg_lambda': 0.6455131715928091,
   'subsample': 0.983566228071919,
   'subsample_for_bin': 200000}**

一旦我们有了这些超参数，我们就可以使用它们在完整的训练数据上训练一个模型，然后在测试数据上进行评估(记住，我们只能使用测试集一次，当我们评估最终模型时)。对于估计数，我们可以使用在提前停止的交叉验证中返回最低损失的估计数。最终结果如下:

**The best model scores 0.72506 AUC ROC on the test set.
The best cross validation score was 0.77101 AUC ROC.
This was achieved after 413 search iterations.**

作为参考，随机搜索的 500 次迭代返回了一个在测试集上得到 0.7232 ROC AUC 和在交叉验证中得到 0.76850 的模型。没有优化的默认模型在测试集上的得分为 0.7143 ROC AUC 。

当我们查看结果时，需要记住一些重要的注意事项:

最佳超参数是那些在交叉验证中表现最好的超参数，而不一定是那些在测试数据中表现最好的超参数。当我们使用交叉验证时，我们希望这些结果可以推广到测试数据中。
即使使用 10 重交叉验证，超参数调整也会使过度适应训练数据。来自交叉验证的最好分数明显高于测试数据上的分数。
随机搜索可能仅仅凭借运气返回更好的超参数(重新运行笔记本可能会改变结果)。贝叶斯优化不能保证找到更好的超参数，并且可能陷入目标函数的局部最小值。

贝叶斯优化有效，但不会解决我们所有的调优问题。随着搜索的进行，算法从探索(尝试新的超参数值)切换到利用(使用导致最低目标函数损失的超参数值)。如果算法找到目标函数的局部最小值，它可以集中在局部最小值周围的超参数值上，而不是尝试位于域空间中远处的不同值。随机搜索没有这个问题，因为它不集中于任何值！

另一个要点是，超参数优化的好处将因数据集而异。这是一个相对较小的数据集(约 6000 个训练观察值)，调整超参数的回报很小(获取更多数据会更好地利用时间！).记住所有这些警告，在这种情况下，使用贝叶斯优化，我们可以得到:

测试集上更好的性能
调整超参数的迭代次数更少

贝叶斯方法可以(尽管不总是)产生比随机搜索更好的调优结果。在接下来的几节中，我们将研究贝叶斯超参数搜索的发展，并与随机搜索进行比较，以了解贝叶斯优化是如何工作的。

可视化搜索结果

绘制结果图是理解超参数搜索过程中发生的事情的直观方式。此外，比较贝叶斯优化和随机搜索是有帮助的，这样我们可以看到这两种方法有什么不同。要了解情节是如何制作的，随机搜索是如何实现的，请参见笔记本，但这里我们将浏览结果。(注意，精确的结果会随着迭代而变化，所以如果您运行笔记本，如果您得到不同的图像，请不要感到惊讶。所有这些图都是用 500 次迭代绘制的)。

首先，我们可以制作随机搜索和贝叶斯优化中采样的learning_rate的核密度估计图。作为参考，我们还可以显示抽样分布。垂直虚线显示了学习率的最佳值(根据交叉验证)。

我们将学习率定义为 0.005 到 0.2 之间的对数正态，贝叶斯优化结果看起来类似于采样分布。这告诉我们，我们定义的分布看起来适合这个任务，尽管最优值比我们放置最大概率的地方高一点。这可以用于通知域进行进一步的搜索。

另一个超参数是 boosting 类型，在随机搜索和贝叶斯优化过程中评估每种类型的条形图，如下所示。由于随机搜索不关注过去的结果，我们希望每种提升类型被使用的次数大致相同。

根据贝叶斯算法，gdbt助推式比dart或goss更有希望。同样，这可以帮助通知进一步的搜索，无论是贝叶斯方法或网格搜索。如果我们想进行更明智的网格搜索，我们可以使用这些结果来定义一个更小的网格，集中在超参数的最有希望的值周围。

既然我们已经有了它们，让我们看看来自参考分布、随机搜索和贝叶斯优化的所有数值超参数。垂直线再次指示每次搜索的超参数的最佳值:

在大多数情况下(除了subsample_for_bin)，贝叶斯优化搜索倾向于集中(放置更多概率)在交叉验证中产生最低损失的超参数值附近。这说明了使用贝叶斯方法进行超参数调优的基本思想:花更多的时间评估有希望的超参数值。

这里也有一些有趣的结果，可能会在将来定义搜索领域空间时对我们有所帮助。仅举一个例子，看起来reg_alpha和reg_lambda应该互补:如果一个高(接近 1.0)，另一个应该更低。不能保证这将适用于所有问题，但通过研究结果，我们可以获得可能应用于未来机器学习问题的见解！

搜索的演变

随着优化的进行，我们希望 Bayes 方法关注超参数中更有前途的值:那些在交叉验证中产生最低误差的值。我们可以绘制超参数值与迭代的关系图，看看是否有明显的趋势。

黑色星号表示最佳值。随着时间的推移，colsample_bytree和learning_rate会减少，这可以指导我们未来的搜索。

最后，如果贝叶斯优化有效，我们预计平均验证分数会随着时间的推移而增加(反之，损失会减少):

贝叶斯超参数优化的验证分数随着时间的推移而增加，表明该方法正在尝试“更好”的超参数值(应该注意的是，这些只是根据验证分数而变得更好)。随机搜索没有显示出迭代的改进。

继续搜索

如果我们对模型的性能不满意，我们可以使用 Hyperopt 从我们停止的地方继续搜索。我们只需要传入同一个 trials 对象，算法将继续搜索。

随着算法的发展，它会进行更多的开发——挑选过去表现良好的值——而较少的探索——挑选新值。因此，与其从搜索停止的地方继续，不如开始一个完全不同的搜索。如果第一次搜索的最佳超参数真的是“最优”的，我们会期望后续的搜索集中在相同的值上。考虑到问题的高维度，以及超参数之间的复杂相互作用，另一次搜索不太可能产生一组相似的超参数。

经过另外 500 次迭代训练，最终模型在测试集上的得分为 0.72736 ROC AUC 。(我们真的不应该在测试集上评估第一个模型，而是只依赖验证分数。理想情况下，测试集应该只使用一次，以便在新数据上部署时获得算法性能的度量。同样，由于数据集的规模较小，这个问题可能会对进一步的超参数优化产生递减的回报，并且最终会出现验证误差的平台期(由于未测量的隐藏变量和噪声数据，数据集上任何模型的性能都存在固有的限制，称为贝叶斯误差)。

结论

机器学习模型的自动超参数调整可以使用贝叶斯优化来完成。与随机搜索相比，贝叶斯优化以一种明智的方法选择下一个超参数，以花更多的时间评估有希望的值。与随机或网格搜索相比，最终结果可以是对目标函数更少的评估和对测试集更好的泛化性能。

在本文中，我们使用 Hyperopt 一步一步地介绍了 Python 中的贝叶斯超参数优化。我们能够改进梯度增强机器的测试集性能，使其超出基线和随机搜索，尽管我们需要小心避免过度拟合训练数据。此外，通过检查结果图，我们看到了随机搜索与贝叶斯优化的不同之处，结果图显示贝叶斯方法对超参数值赋予了更大的概率，从而导致了更低的交叉验证损失。

使用优化问题的四个部分，我们可以使用 Hyperopt 来解决各种各样的问题。贝叶斯优化的基本部分也适用于 Python 中实现不同算法的个库。从手动切换到随机或网格搜索是一小步，但要让你的机器学习更上一层楼，需要某种自动化形式的超参数调整。贝叶斯优化是一种既易于在 Python 中使用，又能返回比随机搜索更好的结果的方法。希望你现在有信心开始使用这个强大的方法来解决你自己的机器学习问题！

一如既往，我欢迎反馈和建设性的批评。可以通过 Twitter @koehrsen_will 找到我。

Python 中云上的自动机器学习

原文：https://towardsdatascience.com/automated-machine-learning-on-the-cloud-in-python-47cf568859f?source=collection_archive---------2-----------------------

数据科学的未来介绍

数据科学领域最近出现了两个明显的趋势:

数据分析和模型训练是使用云资源完成的
机器学习管道是通过算法开发和优化的

本文将简要介绍这些主题，并展示如何实现它们，使用 Google Colaboratory 在 Python 中的云上进行自动机器学习。

使用 Google Colab 的云计算

最初，所有的计算都是在一台大型主机上完成的。你通过终端登录，并连接到一台中央机器，在那里用户同时共享一台大型计算机。然后，随着 T4 微处理器和个人电脑革命的到来，每个人都有了自己的电脑。笔记本电脑和台式机可以很好地完成日常任务，但随着最近数据集规模和运行机器学习模型所需的计算能力的增加，利用云资源对数据科学来说是必要的。

云计算一般指“通过互联网交付计算服务”。这涵盖了广泛的服务，从数据库到服务器到软件，但在本文中，我们将以 Jupyter 笔记本的形式在云上运行一个简单的数据科学工作负载。我们将使用相对较新的谷歌联合实验室服务:运行在谷歌服务器上的 Python 在线 Jupyter 笔记本，可以从任何有互联网连接的地方访问，免费使用，像任何谷歌文档一样可以共享。

Google Colab 让云计算的使用变得轻而易举。过去，我花了几十个小时来配置 Amazon EC2 实例，这样我就可以在云上运行 Jupyter 笔记本，并且必须按小时付费！幸运的是，去年，谷歌宣布你现在可以在他们的 Colab 服务器上运行 Jupyter 笔记本长达 12 小时，一次完全免费。(如果这还不够，谷歌最近开始让用户在笔记本上添加英伟达特斯拉 K80 GPU )。最棒的是，这些笔记本电脑预装了大多数数据科学软件包，并且可以轻松添加更多软件包，因此您不必担心在自己的机器上进行设置的技术细节。

要使用 Colab，你只需要一个互联网连接和一个谷歌账户。如果你只是想要一个介绍，前往colab.research.google.com并创建一个新的笔记本，或者探索谷歌开发的教程(称为Hello, Colaboratory)。要阅读这篇文章，请点击这里的获取笔记本。登录您的 Google 帐户，在 Colaboratory 中打开笔记本，单击文件>在驱动器中保存一份副本，然后您将拥有自己的版本进行编辑和运行。

First open the notebook in Colaboratory

Second, save a copy in your drive to edit

随着在线资源的丰富，数据科学变得越来越容易获得，而 Colab 项目大大降低了云计算的壁垒。对于那些以前在 Jupyter Notebooks 中做过工作的人来说，这是一个完全自然的过渡，对于那些没有做过的人来说，这是一个开始使用这种常用数据科学工具的绝佳机会！

使用 TPOT 的自动机器学习

自动化机器学习(缩写为 auto-ml)旨在通过算法设计和优化针对特定问题的机器学习管道。在这种情况下，机器学习管道包括:

特征预处理:插补、缩放和构建新特征
特征选择:降维
模型选择:评估许多机器学习模型
超参数调整:寻找最佳模型设置

这些步骤几乎有无数种组合方式，每个问题的最佳解决方案都会发生变化！设计机器学习管道可能是一个耗时且令人沮丧的过程，最终，你永远不会知道你开发的解决方案是否接近最优。 Auto-ml 可以帮助评估数以千计的可能管道，尝试为特定问题找到最佳(或接近最佳)的解决方案。

重要的是要记住，机器学习只是数据科学过程的一部分，自动化机器学习并不意味着取代数据科学家。相反，auto-ml 旨在解放数据科学家，使她能够从事过程中更有价值的方面，例如收集数据或解释模型。

有很多 auto-ml 工具——H20、 auto-sklearn 、Google Cloud AutoML——我们将重点介绍TPOT:Randy Olson 开发的基于树的管道优化工具。 TPOT(你的“数据科学助理”)使用遗传编程来寻找最佳的机器学习管道。

插曲:遗传编程

要使用 TPOT，其实并不需要知道遗传编程的细节，所以可以跳过这一节。对于那些好奇的人来说，在高层次上，用于机器学习的遗传编程工作如下:

从随机生成的机器学习管道的初始群体开始，比如说 100 个，每个管道都由用于特征预处理、模型选择和超参数调整的功能组成。
训练这些管道中的每一个(称为个体),并使用交叉验证对性能指标进行评估。交叉验证表现代表了个体的“适合度”。群体的每次训练称为一代。
经过一轮训练——第一代——通过繁殖、变异和交叉产生第二代 100 个个体。复制意味着在管道中保持相同的步骤，以与适应度分数成比例的概率进行选择。突变是指个体从一代到下一代在内的随机变化。交叉是从一代到下一代的个体之间的随机变化。这三种策略合在一起将产生 100 个新的管道，每个都略有不同，但根据适应度函数最有效的步骤更有可能被保留。
重复这个过程适当的世代数，每次通过繁殖、突变和交叉产生新的个体。
优化结束时，选择性能最佳的单个管道。

(关于基因编程的更多细节，请看这篇的短文。)

遗传编程对于构建机器学习模型的主要好处是探索。由于有限的知识和想象力，即使没有时间限制的人也不能尝试预处理、模型和超参数的所有组合。遗传编程没有显示出对任何特定的机器学习步骤序列的初始偏好，并且随着每一代，新的流水线被评估。此外，适应度函数意味着搜索空间中最有希望的区域比性能较差的区域被更彻底地探索。

把它放在一起:云上的自动机器学习

有了背景，我们现在可以在 Google Colab 笔记本中使用 TPOT 来自动设计机器学习管道。(跟着笔记本一起这里)。

我们的任务是一个监督回归问题:给定纽约市能源数据，我们想要预测一栋建筑的能源之星得分。在之前的一系列文章中(第一部分、第二部分、第三部分、GitHub 上的代码)，我们为这个问题构建了一个完整的机器学习解决方案。使用手动特征工程、降维、模型选择和超参数调整，我们设计了一个梯度推进回归器模型，在测试集上实现了 9.06 分的平均绝对误差(从 1 到 100 分)。

该数据包含几十个连续的数字变量(如能源使用和建筑面积)和两个一次性编码的分类变量(区和建筑类型),共有 82 个要素。

Raw data features

score是回归的目标。所有缺失的值都被编码为np.nan，并且没有对数据进行任何特征预处理。

首先，我们需要确保 TPOT 安装在 Google Colab 环境中。大多数数据科学包已经安装，但是我们可以使用系统命令(前面有一个！在 Jupyter):

!pip install TPOT

在读入数据后，我们通常会填充缺失值(插补)并将特征标准化为一个范围(缩放)。然而，除了特征工程、模型选择和超参数调整，TPOT 将自动估算缺失值并进行特征缩放！因此，我们的下一步是创建 TPOT 优化器:

TPOT 优化器的默认参数将评估 100 组管道，每组 100 代，总共 10，000 条管道。使用 10 重交叉验证，这代表 100，000 次训练运行！即使我们使用谷歌的资源，我们也没有无限的时间进行培训。为了避免在 Colab 服务器上耗尽时间(我们最多获得 12 小时的连续运行时间)，我们将评估时间设置为最多 8 小时(480 分钟)。 TPOT 被设计为运行几天，但是我们仍然可以从几个小时的优化中获得好的结果。

我们在对优化器的调用中设置了以下参数:

scoring = neg_mean_absolute error:我们的回归性能指标
max_time_minutes = 480:评估时间限制为 8 小时
n_jobs = -1:使用机器上所有可用的内核
verbosity = 2:训练时显示有限的信息
cv = 5:使用五重交叉验证(默认为 10)

还有其他参数控制着遗传编程方法的细节，但是在大多数情况下，将它们保留为缺省值就可以了。(如果您想使用参数，请查看文档。)

TPOT 优化器的语法被设计成与 Scikit-Learn 模型的语法相同，因此我们可以使用.fit方法训练优化器。

# Fit the tpot optimizer on the training data
tpot.fit(training_features, training_targets)

在培训过程中，我们会显示一些信息:

由于时间限制，我们的模型只能通过 15 代。对于 100 个群体，这仍然代表了被评估的 1500 个不同的单独管道，比我们手动尝试的要多得多！

一旦模型训练完毕，我们就可以使用tpot.fitted_pipeline_看到最佳的管道。我们还可以将模型保存到 Python 脚本中:

# Export the pipeline as a python script file
tpot.export('tpot_exported_pipeline.py')

由于我们是在 Google Colab 笔记本中，要从服务器将管道连接到本地机器，我们必须使用 Google Colab 库:

# Import file management
from google.colab import file# Download the pipeline for local use
files.download('tpot_exported_pipeline.py')

然后我们可以打开文件(此处可用和)并查看完成的管道:

我们看到优化器为我们估算了缺失的值，并构建了一个完整的模型管道！最后一个估计器是一个堆叠模型，这意味着它使用两个机器学习算法([LassoLarsCV](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoLarsCV.html)和[GradientBoostingRegressor](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html))，其中第二个是根据第一个的预测进行训练的(如果你再次运行笔记本，你可能会得到一个不同的模型，因为优化过程是随机的)。这是一个复杂的方法，我自己可能无法开发！

现在，关键时刻到了:测试设备的性能。为了找到平均绝对误差，我们可以使用.score方法:

# Evaluate the final model
print(tpot.score(testing_features, testing_targets))**8.642**

在我们手动开发解决方案的系列文章中，经过数小时的开发，我们构建了一个梯度推进回归器模型，其平均绝对误差为 9.06。随着开发时间的大幅减少，自动机器学习在性能上有了显著的提高。

从这里开始，我们可以使用优化的管道并尝试进一步完善解决方案，或者我们可以继续进行数据科学管道的其他重要阶段。如果我们使用这个作为我们的最终模型，我们可以尝试并解释这个模型(比如通过使用LIME:Local Interpretable Model-Agnostic explaining)或者写一个文档化的报告。

结论

在这篇文章中，我们简要介绍了云和自动化机器学习的能力。只需一个谷歌账户和互联网连接，我们就可以使用谷歌实验室来开发、运行和共享机器学习或数据科学工作负载。使用 TPOT，我们可以通过特征预处理、模型选择和超参数调整来自动开发优化的机器学习管道。此外，我们看到 auto-ml 不会取代数据科学家，但它将允许她在工作流程中更高价值的部分花费更多的时间。

虽然作为早期采用者并不总是有回报，但在这种情况下，TPOT 足够成熟，易于使用，相对来说没有问题，但也足够新，学习它会让你走在曲线的前面。考虑到这一点，找到一个机器学习问题(也许通过 Kaggle )并尝试解决它！在 Google Colab 的笔记本上运行自动机器学习感觉就像是未来，进入门槛如此之低，这是开始的最佳时机！

一如既往，我欢迎反馈和讨论，可以通过 Twitter @koehrsen_will 联系。

使用上下文语义搜索的自动化调查处理

原文：https://towardsdatascience.com/automated-survey-processing-using-contextual-semantic-search-2dfe68338ab5?source=collection_archive---------12-----------------------

随着深度学习的最新进展，算法分析文本的能力有了很大提高。现在，分析数字和社交媒体不仅限于基本的情感分析和基于计数的指标。创造性地使用先进的人工智能技术可以成为进行深入研究的有效工具。我们认为，根据以下线索对客户关于某个品牌的对话进行分类非常重要:

顾客关心的品牌产品和服务的关键方面。
用户对这些方面的潜在意图和反应。

这些基本概念结合使用时，会成为一个非常重要的工具，用于以人类水平的准确性分析数百万次品牌对话。在这篇文章中，我们以优步为例，展示这是如何运作的。请继续阅读！

文本分类器——基本构件

1。情绪分析

情感分析是最常见的文本分类工具，它分析收到的消息，并判断潜在的情感是积极的、消极的还是中性的。你可以输入一个你选择的句子，并通过这里的演示来判断潜在的情绪。

情感分析

情感分析可以从任何文本数据中准确地检测出情感。人们在社交媒体、博客和论坛上表达他们的观点、反馈和评论。营销人员和客户支持人员可以利用情绪检测的能力来读取和分析文本数据附带的情绪。我们的情绪分析分类器是在我们专有的数据集上训练的，它可以告诉我们信息背后的潜在情绪是:快乐、悲伤、愤怒、恐惧、兴奋、有趣还是讽刺。

意图分析

意图分析通过分析信息背后的用户意图，并识别它是否与意见、新闻、营销、投诉、建议、赞赏或疑问相关，来加强游戏。

Analyzing intent of textual data

上下文语义搜索(CSS)

现在，事情变得非常有趣了。为了获得可行的见解，了解用户讨论的是品牌的哪个方面是很重要的。例如，Amazon 想要分离与延迟交付、账单问题、促销相关查询、产品评论等相关的消息。但是怎样才能做到呢？

我们引入了一种智能的智能搜索算法，称为上下文语义搜索(又名 CSS) 。CSS 的工作方式是，它将数千条消息和一个概念(如价格)作为输入，并过滤所有与给定概念紧密匹配的消息。下图展示了 CSS 如何代表了对业界使用的现有方法的重大改进。

过滤所有与价格相关的消息的传统方法是对价格和其他密切相关的词进行关键字搜索，如(定价、收费、$、已付)。然而，这种方法不是很有效，因为几乎不可能想到所有相关的关键字及其代表特定概念的变体。另一方面，CSS 只是将概念的名称( Price )作为输入，并过滤所有上下文相似的内容，即使没有提到概念关键字的明显变体。

对于好奇的人，我们想让他们看一下这是如何工作的。人工智能技术用于将每个单词转换为超空间中的特定点，这些点之间的距离用于识别上下文与我们正在探索的概念相似的消息。下面可以看到引擎盖下的可视化效果:

Visualizing contextually related Tweets

现在来看看 CSS 的作用以及它是如何处理下面的文本数据的:

该算法将消息分类为与称为 P rice 的概念上下文相关，即使消息中没有提到单词 Price 。

优步:深潜分析

我们分析了数字媒体上关于几个产品主题的在线对话:取消、支付、价格、安全和服务。

为了广泛覆盖数据来源，我们从优步官方脸书页面上的最新评论、提到优步的推文以及优步的最新新闻文章中获取数据。以下是所有渠道的数据点分布:

脸书:34173评论
推特:21603 条推特
新闻:第 4245 篇

分析用户对话的情感可以让你对整体品牌认知有所了解。但是，为了更深入地挖掘，借助上下文语义搜索进一步对数据进行分类是很重要的。

我们在同一个数据集上运行了上下文语义搜索算法，将上述类别纳入一个帐户(取消、支付、价格、安全和服务)。

脸谱网

情绪分析

Breakdown of Sentiment for Categories

值得注意的是，除了一个类别，所有类别的评论都有负面情绪。与价格相关的正面评论数量已经超过负面评论。为了更深入地挖掘，我们分析了这些评论的意图。脸书作为一个社交平台，评论是拥挤的随机内容、新闻分享、营销和推广内容以及垃圾邮件/垃圾/无关内容。看看脸书评论上的意图分析:

Intent analysis of Facebook comments

因此，我们删除了所有这些不相关的意图类别，并重现了结果:

Filtered Sentiment Analysis

对每个类别的看法都有明显的变化。尤其是在价格相关评论中，正面评论的数量从 46%下降到了 29%。

推特

情感分析

对抓取的推文也做了类似的分析。在最初的分析中，与支付和安全相关的推文让人喜忧参半。

Category wise sentiment analysis

为了了解真实的用户意见、投诉和建议，我们必须再次过滤不相关的推文(垃圾邮件、垃圾信息、营销、新闻和随机消息):

Filtered sentiment

与付款相关的推文数量明显减少。此外，针对类别安全(以及相关关键词)的正面推文数量大幅下降。)

像优步这样的品牌可以依靠这种洞察力，并针对最关键的话题采取行动。例如，服务相关推文的正面推文比例最低，负面推文比例最高。因此，优步可以分析这些推文，并根据它们采取行动，以提高服务质量。

新闻ˌ消息

Sentiment Analysis for News Headlines

可以理解的是，安全一直是新闻中谈论最多的话题。有趣的是，新闻情绪总体上是积极的，在每个类别中也是如此。

我们也根据新闻的受欢迎程度进行分类。流行度得分归因于文章在不同社交媒体渠道上的分享计数。以下是热门新闻文章列表:

优步首席执行官遭批评后将离开特朗普顾问委员会
#DeleteUber:用户对特朗普穆斯林禁令废 app 感到愤怒
优步员工也讨厌他们自己的企业文化
每次我们获得优步奖，我们都在传播它的社会毒素
司机在抗议和罢工期间前往 JFK 机场后，愤怒的消费者删除了优步的应用程序

结论

随着技术的进步，从社交媒体数据中获得有意义见解的时代已经到来。优步的案例研究让你一瞥上下文语义搜索的威力。您的组织是时候超越总体情绪和基于计数的指标了。公司最近一直在利用数据的力量，但要获得最深层的信息，你必须利用人工智能、深度学习和智能分类器(如上下文语义搜索)的力量。

您还可以使用我们的 Excel 插件来分析调查，而无需编写任何代码。你可以从这里下载插件。

我们希望你喜欢这篇文章。请注册一个免费的 ParallelDots 账户，开始你的 AI 之旅。你也可以在这里查看 PrallelDots AI API的演示。

此处阅读原文。

使用机器学习的自动文本分类

原文：https://towardsdatascience.com/automated-text-classification-using-machine-learning-3df4f4f9570b?source=collection_archive---------2-----------------------

Image credits: Moosend

数字化改变了我们处理和分析信息的方式。在线信息的可用性呈指数级增长。从网页到电子邮件，科学期刊、电子书、学习内容、新闻和社交媒体都充满了文本数据。其理念是快速创建、分析和报告信息。这是自动文本分类逐步升级的时候。

文本分类是将文本智能分类成类别。而且，使用机器学习来自动化这些任务，只会使整个过程超级快速和高效。人工智能和机器学习可以说是最近获得动力的最有益的技术。他们到处都能找到应用。正如杰夫·贝索斯在年度股东信中所说，

在过去的几十年里，计算机已经广泛地自动化了程序员可以用清晰的规则和算法描述的任务。现代机器学习技术现在允许我们在描述精确规则更加困难的任务中做同样的事情。

–杰夫·贝索斯

特别谈到自动文本分类，我们已经写了它背后的技术和它的应用。我们正在更新我们的文本分类器。在本帖中，我们将讨论与我们的自动文本分类 API 相关的技术、应用、定制和分段。

文本数据的意图、情感和情感分析是文本分类的一些最重要的部分。这些用例在机器智能爱好者中引起了巨大的反响。我们为每个类别开发了单独的分类器，因为它们的研究本身就是一个巨大的课题。文本分类器可以对各种文本数据集进行操作。您可以使用标记数据训练分类器，也可以对原始的非结构化文本进行操作。这两个类别本身都有许多应用。

监督文本分类

定义分类类别后，文本的监督分类就完成了。它的工作原理是训练和测试。我们将标记的数据提供给机器学习算法进行处理。该算法在标记的数据集上训练，并给出期望的输出(预定义的类别)。在测试阶段，算法被输入未观察到的数据，并根据训练阶段将它们分类。

电子邮件的垃圾邮件过滤是监督分类的一个例子。收到的电子邮件会根据其内容自动分类。语言检测、意图、情感和情绪分析都基于监督系统。它可以用于特殊的用例，例如通过分析数百万条在线信息来识别紧急情况。这是大海捞针的问题。我们提出了智能公共交通系统来识别这些情况。为了在数以百万计的在线对话中识别紧急情况，必须以高精度训练分类器。它需要特殊的损失函数，在训练时进行采样，以及建立一个多分类器堆栈等方法来解决这个问题，每个分类器都细化前一个分类器的结果。

监督分类基本上就是让计算机模仿人类。给定算法一组标记/分类的文本(也称为训练集)，基于这些文本，它们生成 AI 模型，当进一步给定新的未标记文本时，这些模型可以自动对它们进行分类。我们的几个API，是用监督系统开发的。文本分类器目前被训练用于一组通用的 150 个类别。

无监督文本分类

无监督分类是在不提供外部信息的情况下完成的。在这里，算法试图发现数据中的自然结构。请注意，自然结构可能不完全是人类认为的逻辑划分。该算法在数据点中寻找相似的模式和结构，并将它们分组到聚类中。数据的分类是基于形成的聚类来完成的。以网络搜索为例。该算法基于搜索词进行聚类，并将它们作为结果呈现给用户。

每个数据点都嵌入到超空间中，你可以在 TensorBoard 上看到它们。下图基于我们对印度电信公司 Reliance Jio 的 twitter 研究。

进行数据探索是为了基于文本相似性找到相似的数据点。这些相似的数据点形成了最近邻的聚类。下图显示了推文“99 卢比的 reliance jio prime 会员资格:以下是如何获得 100 卢比返现……”的最近邻居。

如你所见，附带的推文与标注的类似。这个集群是相似推文的一个类别。在从文本数据中获得洞察力时，无监督分类非常方便。它是高度可定制的，因为不需要标记。它可以对任何文本数据进行操作，而无需对其进行训练和标记。因此，无监督分类是语言不可知的。

自定义文本分类

很多时候，使用机器学习的最大障碍是数据集的不可用性。有许多人想用人工智能对数据进行分类，但这需要制作一个数据集，这就产生了类似于鸡生蛋还是鸡生蛋的问题。自定义文本分类是在没有任何数据集的情况下构建自己的文本分类器的最佳方式之一。

在 ParallelDots 的最新研究工作中，我们提出了一种在文本上进行零射击学习的方法，其中一种经过训练的算法可以在大型嘈杂的数据集上学习句子及其类别之间的关系，从而推广到新的类别甚至新的数据集。我们称这种模式为“一次训练，随处测试”。我们还提出了多种神经网络算法，可以利用这种训练方法并在不同的数据集上获得良好的结果。对于学习关系的任务，最好的方法是使用 LSTM 模型。这个想法是，如果一个人可以在句子和类之间建立“隶属”的概念模型，这些知识对于看不见的类甚至看不见的数据集都是有用的。

如何构建自定义文本分类器？

要构建你自己的定制文本分类器，你需要首先注册一个 ParallelDots 账户，然后登录到你的仪表盘。

您可以通过单击仪表板中的“+”图标来创建您的第一个分类器。接下来，定义一些您想要对数据进行分类的类别。请注意，为了获得最佳结果，请保持您的类别互斥。

您可以通过分析文本样本来检查分类的准确性，并在发布之前尽可能调整您的类别列表。一旦发布了类别，您将获得一个应用程序 id，它将允许您使用定制的分类器 API。

考虑到数据标记和准备可能是一个限制，自定义分类器可以是一个很好的工具来建立一个文本分类器，而不需要太多的投资。我们还相信，这将降低构建实用的机器学习模型的门槛，这些模型可以应用于各个行业，解决各种各样的用例。

作为一个人工智能研究小组，我们正在不断开发前沿技术，以使流程更简单、更快速。文本分类就是这样一种在未来有巨大潜力的技术。随着越来越多的信息被倾倒在互联网上，由智能机器算法来轻松地分析和表示这些信息。机器智能的未来无疑是令人兴奋的，订阅我们的时事通讯，在你的收件箱里获得更多这样的信息。

parallel dots AI API，是由 ParallelDots Inc 提供的深度学习支持的 web 服务，可以理解大量的非结构化文本和视觉内容，为您的产品提供支持。你可以查看我们的一些文本分析API并通过填写此处的表格联系我们或者给我们 apis@paralleldots.com 写信。

自动数据收集

原文：https://towardsdatascience.com/automatic-data-collection-to-improve-image-classifiers-232c2f0b2070?source=collection_archive---------13-----------------------

Fetch some Data

提高图像识别模型性能的最佳方法之一是添加更多数据进行训练！向当前数据集即时添加更多数据的一些最流行的方法是尝试翻转图像，向图像添加一些噪点，或者添加颜色扭曲。一个有才华的机器学习工程师也可能尝试使用 GANs 向训练集添加数据。

然而，这只能到此为止，最终这些策略将会停滞不前，尤其是如果你只有 200 张图片的话。提高模型性能的最常见方法之一，尤其是在部署之后，是设置一个自动数据管道。

下面是本文中介绍的自动数据收集策略:

Classify new instance
If model_Output == .995 || model_Output == .005
  save new instance to train data and label accordingly

我们最终可以加速这一过程，使模型在遇到新实例时显著增加数据集的大小。

然而，另一件需要担心的事情是最终的数据集大小。如果每次有人使用你的应用程序时你都保存 100 张新图片，你可能会得到一个巨大的数据集。根据您的数据存储环境和成本，这可能会有问题。出于这个原因，最好也将您的自动数据管道参数化，使其在收集到某个变量 X GBs 时停止。

此外，一旦有了更大的数据集，您可能会发现需要向模型中添加图层来学习更复杂的分类函数。

当然，这种策略可以扩展到图像识别领域之外的模型，但是，例如，如果您正在处理 csv 数据的记录，您可能不必考虑最大数据存储。

感谢阅读！希望这有助于您思考您的数据收集自动化过程。这真的会节省你很多时间，从长远来看会有巨大的回报！

CShorten

Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对数据科学、深度学习和软件工程感兴趣。主要用 Python，JavaScript，C++编码。请关注更多关于这些主题的文章。

使用深度学习和贝叶斯推理的自动特征工程

原文：https://towardsdatascience.com/automatic-feature-engineering-using-deep-learning-and-bayesian-inference-application-to-computer-7b2bb8dc7351?source=collection_archive---------4-----------------------

计算机视觉和综合金融交易数据的应用

我们将探索深度学习和贝叶斯推理在自动特征工程中的应用，特别是自动编码器。这个想法是从潜在的有噪声的原始数据中自动学习一组特征，这些数据在监督学习任务中是有用的，例如在计算机视觉和保险中。以这种方式，我们通过自动学习一组特征，即表示学习，避免了手工制作的特征工程的手动过程，这可以帮助解决某些任务，例如图像识别和保险损失风险预测。

计算机视觉

为此，我们将使用 MNIST 数据集，其中原始数据是每个图像的像素强度的二维张量。图像是我们的分析单位:我们将预测每个图像的每个类别的概率。这是一个多类分类任务，我们将使用准确度分数来评估模型在测试折叠中的性能。

2 dimensional tensor of pixel intensities per image.

计算机视觉任务的手工特征工程的一些例子可能使用 Gabor 滤波器。

保险

我们将使用合成数据集，其中原始数据是每个保单期组合的历史保单级别信息的二维张量:每个单位将是一个 4x 3 维张量，即 4 个历史时间段和 3 种交易类型。保单-期间组合是我们的分析单位:我们将预测未来期间 5 的损失概率—将此视为保单的潜在续保，我们需要预测它是否会为我们带来损失，从而影响我们是否决定续保和/或调整续保保费以考虑额外风险。这是一个二元类分类任务，我们将使用 AUROC 分数来评估模型性能。

2 dimensional tensor of transaction values per policy-period combination.

保险任务的手工特征工程的一些例子可能使用列或行平均值。

合成保险金融交易数据集是用 r 编写的，其余的工作都是用 Python 完成的。

请注意计算机视觉任务的原始数据和保险任务的原始数据之间的相似之处。我们在这里的主要目标是通过深度学习和贝叶斯推理，使用自动特征工程来学习这种原始数据的良好表示。

Scikit-learn、Keras 和 TensorFlow

我们将使用 Python 机器学习库 scikit-learn 进行数据转换和分类任务。请注意，我们将自动编码器编码为 scikit-learn 转换器，以便 scikit-learn 管道可以随时使用它们。深度学习者将使用 Keras 和 TensorFlow 后端进行编码。我们还在 MacBook Pro 上使用了外部 GPU，即 GTX 1070。

MNIST:没有自动编码器

我们在不使用自动编码器的情况下运行 MNIST 数据集。MNIST 图像的每个图像的像素强度的 2 维张量是 28 乘 28 的维度。我们将它们重塑为每个图像 784 维的 1 维张量。因此，对于每幅图像的监督学习任务，我们有 784 个特征。

结果

没有自动编码器的 MNIST 分类任务的准确度分数: 92.000000% 。

MNIST:认证机构

我们使用主成分分析过滤器，挑选出能够解释 99%变异的成分数量。

结果

使用主成分分析的 MNIST 分类任务的正确率得分: 91.430000% 。

MNIST:普通自动编码器

自动编码器是一种无监督学习技术，其目标是学习一组可用于重构输入数据的特征。

我们的输入数据是 X 。编码器功能 E 将其映射到一组 K 特征。解码器功能 D 使用一组 K 特征来重构输入数据。

让我们将重建的数据表示如下。

目标是学习编码和解码功能，使输入数据和重构数据之间的差异最小化。这个任务的目标函数的一个例子可以是均方误差(MSE)。

我们通过使用定义编码和解码函数的参数最小化 MSE 来学习编码和解码函数:使用链式法则(即反向传播)来计算 MSE 相对于参数的梯度，并将其用于通过诸如随机梯度下降(SGD)的优化算法来更新参数。

假设我们有一个单层自动编码器，它使用指数线性单元(ELU)激活函数、批量归一化、丢失和自适应矩(Adam)优化算法。 B 是批量， K 是特性数。

指数线性单元:激活函数处处平滑，避免了输入为负时输出呈现负值的消失梯度问题。

批量标准化:这个想法是把输入转换成一个隐藏层的激活函数。我们首先在每个特征的基础上使用均值和方差参数进行标准化或规范化，然后在转换数据的每个特征的基础上学习一组缩放和移动参数。下面的等式简洁地描述了这一层。

丢弃:这种正则化技术简单地以一定的概率(比如 50%)丢弃来自输入和隐藏单元的输出。
Adam 优化算法:这种自适应算法结合了 Momentum 和 RMSProp 优化算法的思想。目标是对过去的梯度有一些记忆，这可以指导将来的参数更新。下面的算法方程简明地描述了这种方法。

结果

使用自动编码器的 MNIST 分类任务的准确度分数: 96.940000% 。

MNIST:去噪自动编码器

这里的想法是向数据添加一些噪声，并尝试学习一组稳健的特征，这些特征可以从有噪声的数据中重建无噪声的数据。MSE 目标函数如下。

结果

使用去噪自动编码器的 MNIST 分类任务的准确度分数: 96.930000% 。

MNIST:一维卷积自动编码器

到目前为止，我们使用的是扁平化或整形的原始数据。每个图像的像素强度的这种 1 维张量可能没有考虑 2 维张量可能包含的有用的空间特征。为了克服这个问题，我们引入卷积滤波器的概念，首先考虑它们的一维版本，然后考虑它们的二维版本。

卷积滤波器背后的思想与手工特征工程密切相关:人们可以将手工特征简单地视为预定义卷积滤波器的结果，即没有基于手边的原始数据学习的卷积滤波器。

假设我们有每个分析单位的原始交易数据，即抵押贷款，这可能有助于我们将一个单位分类为违约或未违约。我们将保持这个例子简单，只允许交易值为$100 或$0。每单位的原始数据跨越 5 个时间段，而默认标签用于下一个时间段，即时间段 6。以下是一个特定单位的原始数据示例:

进一步假设，如果平均交易价值为 20 美元，那么我们将在第 6 期看到该特定抵押贷款单位的违约。除此之外，我们不会看到第 6 期出现违约。平均交易价值是手工制作的特征的一个例子:预先定义的手工制作的特征，没有以任何方式学习。它是通过信贷风险领域的知识得出的。将其表示为 H(x) 。

学习这种特征的想法是一维卷积滤波器的一个例子。如下所示:

假设 H(x) 是该监督学习任务的原始数据的正确表示，则通过用于上述定义的卷积滤波器的监督学习，或者可能是无监督学习，然后被转移到监督学习任务，即转移学习，学习的最佳参数集是[0.2，0.2，0.2，0.2，0.2]:

这是一个简单的例子，但是这清楚地说明了使用深度学习进行自动特征工程或表示学习背后的原理。以无监督的方式学习这种表示的主要好处之一是，相同的表示可以用于多个监督学习任务:迁移学习。这是从原始数据中学习表示的一种原则性方式。

总结一下，对于我们的简单示例，一维卷积滤波器定义为:

x 为输入。
𝛼是内核。
输出 x * 𝛼被称为特征图，而*是卷积算子或滤波器。这是普通神经网络和卷积神经网络之间的主要区别:我们用卷积算子代替矩阵乘法算子。
根据手头的任务，我们可以有不同类型的卷积滤波器。
内核大小可以改变。在我们的例子中，内核大小是 5。
步幅大小可以改变。在我们的示例中，我们没有步长大小，但是假设步长大小为 1，内核大小为 2，即𝛼 = [𝛼 ，𝛼 ]，那么我们将在输入开始时应用内核𝛼，即[ x ， x ] * [𝛼 ，𝛼 ]，并将内核移动到输入的下一个区域，即[ x]【𝛼*、𝛼 ]等等，直到我们得到由 4 个实数值组成的特征图。这被称为有效卷积，而填充卷积，也就是说用零值填充卷积，将给出与输入大小相同的特征映射，即，在我们的例子中是 5 个实值。
我们可以将激活函数应用于特征地图，例如前面提到的 ELU。
最后，我们可以通过在特征图的定义部分取最大值或平均值来总结特征图中包含的信息。例如，如果在使用有效卷积后，我们得到大小为 4 的特征图，然后应用大小为 4 的最大汇集操作，那么我们将取该特征图的最大值。结果是另一个特征图。

这自动化了特征工程，但是引入了架构工程，其中由各种卷积滤波器、激活函数、批量标准化层、丢弃层和汇集操作符组成的不同架构可以在流水线中堆叠在一起，以便学习原始数据的良好表示。人们通常创建这样的体系结构的集合。

卷积自动编码器的目标是使用卷积滤波器、激活函数、批量标准化层、丢弃层和汇集运算符来创建一个编码器函数，它将学习我们原始数据的良好表示。解码器还将使用与编码器类似的一组层来重建原始数据，但有一个例外:它将使用上采样运算符，而不是使用池运算符。上采样操作符背后的基本思想是将一个元素重复一定的次数，比如大小为 4:可以将其视为池操作符的逆操作符。池操作符本质上是一个下采样操作符，而上采样操作符在某种意义上只是它的逆操作。

结果

使用一维卷积自动编码器的 MNIST 分类任务的准确度分数: 97.570000% 。

MNIST:序列到序列自动编码器

鉴于我们的抵押贷款违约例子，一个潜在的更有用的深度学习架构可能是递归神经网络(RNN)，特别是他们的最先进的变体长期短期记忆(LSTM)网络。目标是明确考虑原始数据的顺序性质。

RNN 中的梯度取决于为模型定义的参数矩阵。简单地说，这些参数矩阵可能会被多次相乘，从而导致学习的两个主要问题:爆炸和消失梯度。如果参数矩阵的谱半径，即矩阵特征值的最大绝对值，大于 1，那么梯度可能变得足够大，即值爆炸，使得学习发散，并且类似地，如果谱半径小于 1，那么梯度可能变小，即值消失，使得参数的下一个最佳转变不能被可靠地计算。梯度的适当计算对于估计定义机器学习方法的最佳参数集是重要的，并且 LSTM 网络在普通 RNN 中克服了这些问题。我们现在将 LSTM 网络定义为 1 个时间步长，即 1 个存储单元。

我们计算输入门的值，在时间段 t 的存储单元状态的值，其中 f(x) 是某个激活函数，以及遗忘门的值:

遗忘门控制 LSTM 记忆的量，即在时间段 t-1 的存储单元状态的值，其中⨂是哈达玛乘积:

利用存储单元的更新状态，我们计算输出门的值，并最终计算输出值本身:

我们可以有各种各样的 LSTM 架构，例如卷积 LSTM，注意，我们用卷积运算符替换输入门、存储单元状态的初始估计、遗忘门和输出门中的矩阵乘法运算符:*

另一个流行的变体是窥视孔 LSTM，其中允许门窥视存储单元的状态:

序列到序列自动编码器的目标是使用 LSTM 作为编码器来创建原始数据的表示。这种表示将是从原始数据向量序列中学习的向量序列。表示的最后一个向量是我们的编码表示，也称为上下文向量。该上下文向量被重复与序列长度一样多的次数，使得它可以被用作解码器的输入，该解码器又是另一个 LSTM。解码器 LSTM 将使用该上下文向量来重建原始数据向量序列。如果上下文向量在重建任务中有用，那么它可以进一步用于其他任务，如预测违约风险，如我们的示例中所给出的。

结果

使用序列对序列自动编码器的 MNIST 分类任务的准确度分数: 97.600000% 。

MNIST:可变自动编码器

我们现在通过使用变分推理来训练自动编码器，从而将贝叶斯推理与深度学习相结合。这使我们转向了生成模型，它可以在半监督学习中有进一步的用例。使用贝叶斯推理进行训练的另一个好处是，我们可以对更高能力的深度学习者更加鲁棒。

假设 X 是我们的原始数据，而 Z 是我们学习过的表示。
我们对学习到的表征有一个先验的信念:

我们学习到的表征的后验分布是:

边际可能性 p(X) 通常是难以处理的，导致后验分布 p(Z|X) 难以处理:

因此，我们需要一个近似的后验分布，通过变分推理，可以处理棘手的问题。这另外还提供了处理大规模数据集的好处，因为通常马尔可夫链蒙特卡罗(MCMC)方法不太适合大规模数据集。人们也可以考虑拉普拉斯近似来近似后验分布，但是我们将坚持变分推理，因为与拉普拉斯近似相比，它允许更丰富的近似集。拉普拉斯近似简单地等同于找到增强似然优化的最大后验(MAP)估计，在 MAP 估计处取 Hessian 逆的负值以估计方差-协方差矩阵，并且最后使用具有多变量高斯分布或一些其他适当的多变量分布的方差-协方差矩阵。
假设我们的近似后验分布，也是我们的概率编码器，给出如下:

我们的概率解码器由下式给出:

给定以上关于编码器和解码器的设置，现在让我们写下优化问题:

请注意，KL 背离是非负的，因此这使得 ELBO 成为边际可能性的下限:

因此，我们可以改变优化问题，只关注 ELBO:

上述积分问题可以通过蒙特卡罗积分来解决，因为正则化项不是难以处理的。假设概率编码器是具有对角方差-协方差矩阵的多元高斯，我们使用重新参数化技巧从该分布中采样，比如说 M 次，以便计算 ELBO 优化问题中的期望项。这种特殊情况下的重新参数化技巧相当于从标准高斯分布中采样 M 次，将样本乘以𝞼并将 μ 加到样本上。
μ 是我们用于原始数据重建的学习表示。如果学习到的表征是有用的，那么它也可以用于其他任务。
这是一种将贝叶斯推理与深度学习相结合的强大方式。以这种方式使用的变分推理可以应用于各种深度学习架构，并且与生成对抗网络(GAN)有进一步的联系。我们在另一篇论文中探讨了对抗性学习在表征学习中的应用。

结果

使用可变自动编码器的 MNIST 分类任务的准确度分数: 96.520000% 。

MNIST:二维卷积自动编码器

对于 2 维卷积滤波器，其思想与 1 维卷积滤波器相似。我们将坚持我们前面提到的银行例子来说明这一点。

在原始交易数据的二维张量中，现在我们有 5 个历史时间段，即行，和 3 个不同的交易类型，即列。我们将使用大小为 2 乘 3 的核从原始数据中提取有用的特征。选择这样一个内核意味着我们有兴趣找到一个跨越所有 3 种事务类型和 2 个历史时间段的特性图。我们将使用步长 1 和有效的卷积来提取原始数据的不同片上的特征。下面将说明这一点。

这些原理和思想适用于 2 维卷积滤波器，因为它们适用于 1 维卷积滤波器，这里我们不再重复。

结果

使用二维卷积自动编码器的 MNIST 分类任务的准确度分数: 98.860000% 。

保险:没有自动编码器

我们现在开始运行保险模型，没有任何手工制作或基于深度学习的特征工程:只有原始数据。

结果

没有自动编码器的保险分类任务的 AUROC 分数: 92.206261% 。

保险:PCA

我们现在继续运行保险模型，没有任何手工或基于深度学习的特征工程，但是使用 PCA 过滤器来挑选解释 99%变化的组件数量。

结果

使用 PCA 的保险分类任务的 AUROC 分数: 91.128859% 。

保险:手工制作的功能

在这种情况下，我们创建了一些手工制作的特征，我们认为这些特征为保险模型的原始数据提供了有用的表示。

结果

具有手工特征的保险分类任务的 AUROC 分数: 93.610635% 。

保险:手工制作的功能和 PCA

我们使用前面提到的手工制作的特征和 PCA 过滤器，该过滤器挑选解释 99%的变化的组件的数量。

结果

具有手工特征和 PCA 的保险分类任务的 AUROC 分数: 93.160377% 。

保险:普通自动编码器

在这种情况下，我们使用普通的自动编码器来学习原始数据的良好表示，以便我们可以根据 AUROC 获得监督学习任务的提升。

结果

使用自动编码器的保险分类任务的 AUROC 分数: 93.932247% 。

保险:去噪自动编码器

在这种情况下，我们使用去噪自动编码器来学习原始数据的良好表示，从而我们可以根据 AUROC 获得监督学习任务的提升。

结果

使用去噪自动编码器的保险分类任务的 AUROC 分数: 93.712479% 。

保险:序列到序列自动编码器

在这种情况下，我们使用序列对自动编码器进行排序，考虑原始交易数据的时间序列性质，即序列性质，以学习原始数据的良好表示，从而我们可以获得监督学习任务在 AUROC 方面的提升。

结果

使用序列对序列自动编码器的保险分类任务的 AUROC 分数: 91.418310% 。

保险:一维卷积自动编码器

在这种情况下，我们使用 1 维卷积自动编码器来学习原始数据的良好表示，以便我们可以获得 AUROC 方面的提升，用于监督学习任务。

结果

使用一维卷积自动编码器的保险分类任务的 AUROC 分数: 91.509434% 。

保险:二维卷积自动编码器

在这种情况下，我们使用二维卷积自动编码器来学习原始数据的良好表示，以便我们可以获得 AUROC 方面的提升，用于监督学习任务。

结果

使用二维卷积自动编码器的保险分类任务的 AUROC 分数: 92.645798% 。

保险:可变自动编码器

在这种情况下，我们使用变分自动编码器来学习原始数据的良好表示，以便我们可以根据 AUROC 获得监督学习任务的提升。

结果

使用可变自动编码器的保险分类任务的 AUROC 分数: 90.871569% 。

MNIST 结果:准确性得分

正如所料，这里达到的最好成绩是由一个二维卷积自动编码器。

没有自动编码器: 92.000000% 。

主成分分析: 91.430000% 。

自动编码器: 96.940000% 。

去噪自动编码器: 96.930000% 。

1 维卷积自动编码器: 97.570000% 。

序列间自动编码器: 97.600000% 。

变分自动编码器: 96.520000% 。

2 维卷积自动编码器: 98.860000% 。

保险结果:AUROC 分数

在这项任务上取得的最好成绩是由一个普通的自动编码器。这突出了通过深度学习实现特征工程的自动化:我相信伊恩·古德费勒说过，学习的表示比手工制作的表示更好。

请注意，序列到序列和卷积自动编码器在这项任务中表现不佳，仅仅是因为我生成合成事务数据的方式:如果数据来自更适合序列到序列或卷积自动编码器的过程，这些架构很可能会表现得更好。

不带自动编码器: 92.206261% 。

主成分分析: 91.128859% 。

手工特色: 93.610635% 。

手工特征和主成分分析: 93.160377% 。

自动编码器: 93.932247% 。

去噪自动编码器: 93.712479% 。

序列到序列自动编码器: 91.418310% 。

1 维卷积自动编码器: 91.509434% 。

2 维卷积自动编码器: 92.645798% 。

变分自动编码器: 90.871569% 。

GitHub 上的代码

我为本文写的代码可以在我的 GitHub 上找到:https://github.com/hamaadshah/autoencoders_keras

结论

我们已经展示了如何使用深度学习和贝叶斯推理来学习原始数据的良好表示，即，每个分析单位的 1 或 2 维张量，其然后可能被用于计算机视觉和保险领域中的监督学习任务。这使我们从手工制作的特征工程转向自动特征工程，即表示学习。这确实引入了架构工程，然而，也可以通过使用遗传算法或强化学习来实现自动化——这可能是另一篇论文的主题。

最后，我想强调的是，用于解决计算机视觉任务的代码也用于解决保险任务。在这两项任务中，通过深度学习的自动特征工程具有最佳性能，尽管事实上我们并没有明确地寻找艺术架构的最佳状态。这为我们提供了一种端到端自动化机器学习任务的强大方法。

参考

古德费勒，我，本吉奥，y 和库维尔(2016)。深度学习(麻省理工出版社)。
Geron，A. (2017)。使用 Scikit-Learn & tensor flow(O ' Reilly)进行机器学习实践。
金玛博士和韦林博士(2014 年)。自动编码变分贝叶斯(https://arxiv.org/abs/1312.6114)。
Hosseini，s .，Lee，S. H .和 Cho，N. I. (2018 年)。为增强卷积神经网络的性能输入手工制作的特征(【https://arxiv.org/abs/1801.07848】T2)。
*【http://scikit-learn.org/stable/# *
https://towards data science . com/learning-rate-schedules-and-adaptive-learning-rate-methods-for-deep-learning-2c8f 433990 D1
https://stack overflow . com/questions/42177658/how-to-switch-back end-with-keras-from-tensor flow-to-the ano
https://blog.keras.io/building-autoencoders-in-keras.html
https://keras.io
https://www . cs . Cornell . edu/courses/cs 1114/2013 sp/sections/S06 _ convolution . pdf
http://deeplearning.net/tutorial/lstm.html