关联规则挖掘
数据
我们将要处理的数据如下所示:
关联规则挖掘的目的是什么？
关联规则挖掘是发现数据模式的方法之一。它发现:
- 一起出现的特征(尺寸)
- “相关”的特征(尺寸)
一个特性的值告诉我们另一个特性的值是什么？比如买纸尿裤的人，很可能会买婴儿爽身粉。或者我们可以这样重新表述:如果(人们购买尿布)，那么(他们购买婴儿爽身粉)。请注意 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 中的关联规则挖掘
关联规则挖掘(也称为关联规则学习)是一种常用技术，用于发现许多变量之间的关联。杂货店、电子商务网站和任何拥有大型事务数据库的人都经常使用它。我们在日常生活中遇到的一个最常见的例子是——当你在他们的网站上订购一些东西时，亚马逊知道你还想买什么。同样的想法也适用于 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)
帮助您更快、更智能购物的算法
回顾在统计训练营中向我介绍的众多概念，有很多东西要写和分享。我选择从关联规则开始，有两个原因。首先，这是我最喜欢学习的概念之一，其次，网上资源有限，很难掌握。
在博客的第一部分，我将介绍一些关键的术语和指标，旨在让读者了解规则中“关联”的含义，以及量化这种关联强度的一些方法。第 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 算法的内容，并找到所有未解问题的答案。
请在评论中告诉我你对这个博客的想法/问题。
尝试实时可视化卷积神经网络
在复制自动驾驶汽车的端到端深度学习方法时，我对网络所看到的东西缺乏可见性感到沮丧。我开发了一个工具来解决这个问题。
模拟器和运行神经网络的 python 脚本通过 websocket 连接进行通信。我决定编写一个小的浏览器应用程序，它也可以通过另一个 websocket 连接到 python 脚本，并收集一些我可以可视化的附加数据。
以下是我能想到的:
右边是我们正在运行的 Udacity 模拟器。左边是我的小 React 应用程序，它将我的神经网络中卷积层的所有输出可视化。
正如你所看到的，它在控制汽车的同时实时运行。这是一次很好的练习，但我怀疑这样做是否有用。目前还不清楚网络是如何基于这些做出决策的。
您可以在此处找到代码:
行为克隆-P3 -行为克隆项目启动文件(P3)
github.com](https://github.com/paramaggarwal/CarND-Behavioral-Cloning-P3)
这篇文章是一项正在进行的工作，其总体目标是获得对神经网络更好的可视性。请在评论中告诉我你的想法，告诉我我还能为这个目标做些什么！
RNNs 中的注意和“可解释性”
我对 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”是一个小分歧，而巨大的分歧可能来自多个核国家的连接方式。鉴于这种复杂性，某种程度上保证思维的连贯性是必不可少的；这些模块中至少有一个将负责检查一致性，并改变输入的显著性。
商业领袖们请注意:你将如何被打乱？
随着“街上”关于从汽车行业到零售的各种市场中断的所有谈论，人们很容易做出反应，改变得太快太快，而不是战略性地做对你的业务线最有利的事情*(据路透社报道，截至 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 传感器将关于发动机健康状况的信号发送到云端，通过一些机器学习和计算，预测性维护算法允许这些发动机在任何实际问题发生之前就被标记为需要维护，允许维护人员在相关机场等待飞机降落，手里有正确的工具来让发动机完全健康，而不占用运行时间。这是一个真实的故事:
这些技术不是科幻小说，也不仅仅是为财大气粗的组织准备的。它们是真正的解决方案，正在帮助当今世界上成千上万的企业通过数字化转型抗击颠覆性的力量。总的来说，信息很清楚，你将如何被打乱取决于你的组织需要多长时间来开发最佳的学习和生产力环境，拥抱大规模云计算和处理，以及利用人工智能和机器学习来做出更好的预测和更智能的行动。
让我们继续对话，分享我们的想法和愿景，帮助相互教育，并思考我们如何才能更好地迎接数字化转型，创造更美好的明天。
请随时在 linkedIn 上给我发消息:【https://www.linkedin.com/in/derekwesleyrussell/
自然语言处理中的注意模型快速介绍
鸣谢:以下是 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:学习反转序列
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 和即时频率变换的音频分类
使用 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 的音频功能
深度学习的学生面临的第一个问题是对 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 中的音频处理
短时傅立叶变换的一种实现
我发现 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 的可能性允许机器学习实践者在计算图中的任何地方执行信号从时域到频域的变换。新工具总是带来新的想法，我们希望这篇文章将成为开发新的深度学习解决方案的新想法的来源。
用于图像分类的增强
分类图像时面临的问题？不要烦恼！增援来了。！
在处理图像数据时遇到的一个问题是图像的不一致性(有些图像太大或太小，有些是矩形而不是正方形，等等)。另一个经常面临的问题是训练集中图像的数量，这经常导致过度拟合。为了处理这些问题，我概述了一种使用增强变换的技术——对训练集中的图像进行变换，以提高模型识别图像不同版本的能力。这增加了模型拥有的信息的广度。它现在变得更适合于从不同对比度、大小、不同角度等图像中识别目标对象。
为了展示增强是如何工作的，我们查看了狗对猫数据集，并利用了深度学习库 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 也可以用来生成不同风格的图像，正如本文中所建议的。这可能会更有效。
除了对图像进行增强之外，看看如何将增强应用于结构化数据以提高性能也是很有趣的，就像它在非结构化数据中所做的那样！让我知道你对此的想法！！
参考
**关于我:**我毕业于 USF 大学数据科学专业，本科学习计算机科学，在构建预测和推荐算法以及为金融和零售客户提供商业见解方面有 2 年的经验。我对将我的机器学习和深度学习知识应用于现实世界问题的机会感到兴奋。请点击这里查看我的其他博客！
领英:https://www.linkedin.com/in/neerja-doshi/
八月版:深度学习
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 中编写时捕获数据，以及轻松使用网络摄像头/图像进行预测。
八月版:当艺术遇上数据科学
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 行代码创建深度学习模型
自动化机器学习是这个城市的新生事物，它会一直存在下去。它帮助我们创造出越来越好的模型，这些模型简单易用，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:
资源:
围绕 pytorch 在视觉、文本、强化学习等方面的一组例子。
github.com](https://github.com/pytorch/examples/blob/master/mnist/main.py)
MNIST 与 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++)
作者:哈什夏尔马，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(张量流)
自动标记堆栈溢出问题
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 找到。我期待听到任何反馈或问题。
参考资料:
自动转录:Python 中的 Google 语音 API 时间偏移
转录音频文件或语音对世界各地的许多公司来说至关重要，正如我们所知，由人类转录的听的古老技术可能会导致致命的错误，并吃掉你的大量资源(人类)。它需要煞费苦心地注意转录每一个被记录的单词，有时，你必须处理多个音频文件。
【多么无聊】 *，*正是 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 图像转换成灰度图像的自动编码器。
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 进行图像校正
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 照片中的噪声去除、图像重建和超分辨率应用。
自动编码器在深度神经网络中至关重要
一个 自动编码器是一个神经网络(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。 主题建模&信息检索
扫一扫
722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
