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

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

文本表示和相似性介绍

原文：https://towardsdatascience.com/introduction-to-text-representation-and-similarity-b5dd3fd71737?source=collection_archive---------0-----------------------

机器学习和数据挖掘任务中最基本的就是比较对象的能力。我们必须在聚类、分类、查询和其他方面比较(有时是平均)对象。文本也不例外，在这篇文章中，我想探索文本的不同表示/嵌入以及一些最流行的距离/相似度函数。

首先，我想谈谈我们希望文本表示和距离/相似性函数具有什么样的属性:

1. 相同的文本必须具有相同的表示和零距离(最大相似度)。
2. 当我们有多个文本 t1、t2 和 t3 时，我们希望能够说 t1 比 t3 更类似于 t2。
3. 相似度/距离应该表达文本之间的语义比较，文本长度应该影响不大。

那么让我们开始，考虑这三句话:

s1 = “David loves dogs”
s2 = “Dogs are ok with David”
s3 = “Cats love rain”

现在假设我们想把这些句子分成两组。很明显，句子 1 和句子 2 属于同一组。但是我们如何通过编程来比较它们呢？

为此，我们将定义 2 个函数:1)向量函数，它获取某个句子并返回表示该句子的向量。以及 2)距离函数，其接收两个向量并返回它们如何远离或相似。

最基本的表达句子的方式是使用一组单词。在大多数情况下，我们会希望预处理我们的文本，以减少噪音。预处理可能包括小写、词干、删除停用词等。在我们的例子中，我们将把单词转换成它的基本形式，并去掉无用的单词。所以句子是:

s1 = (“david”, “love”, “dog”)
s2 = (“dog”,”ok”,”david”)
s3 = (“cat”,”love”,”rain”)

比较这些句子，我们可以用 Jaccard 相似度。Jaccard 相似度是两个句子的常用词数量(交集)和总词数量(并集)之间的比例。句子 1 和 2 的并集是(“大卫”、“爱”、“狗”、“好”)，交集是(“大卫”、“狗”)，所以 Jaccard 相似度将是 2/4 = 0.5。

另一方面，句子 1 和 3 之间的 Jaccard 相似度是 1/6 = 0.166，句子 2 和 3 之间的相似度是 0/6 = 0。

虽然这种方法解决了我们的问题，但也有一些缺点。概括这些缺点的最佳方式是表示和距离函数都不是“数学的”，即我们不能进行句子平均，例如，使用其他数学函数操纵距离函数(如求导)。

为了解决这个问题，我们必须用一种更科学的方式来表达我们的句子:向量。

这非常简单:我们将使用语料库中的所有单词(所有句子)构建一个词汇表，每个单词都有一个索引。在我们的示例中，它看起来像这样:

{'cat': 0, 'david': 1, 'dog': 2, 'love': 3, 'ok': 4, 'rain': 5}

我们将把每个句子表示为一个 6 维向量，并在索引中为每个单词存储 1，在其他地方存储 0。以下是我们的句子:

s1 = [0, 1, 1, 1, 0, 0]     
s2 = [0, 1, 1, 0, 1, 0]    
s3 = [1, 0, 0, 1, 0, 1] 

现在，每个句子只是 6 维空间中的一个点(或一个向量)。以下是我们使用主成分分析法在二维空间中将其可视化后的效果:

Sentence 1 and 2 — Blue, Sentence 3 — Red

你可以看到第一句和第二句的观点都比第三句更接近。有很多种方式来表达他们之间的距离。最直观的是“欧几里德距离”(也叫 L2 范数)其中计算这条线:

当然，没必要自己实现；有很多实现(例如 python 中的 numpy.linalg.norm)。

这是欧几里德距离的值:

 ╔══════╦════════╦════════╦════════╗
                 ║      ║   **S1**   ║   **S2**   ║   **S3**   ║  
                 ╠══════╬════════╬════════╬════════╣
                 ║ **S1**   ║    0   ║  1.41  ║    2   ║
                 ╠══════╬════════╬════════╬════════╣
                 ║ **S2**   ║  1.41  ║   0    ║  2.44  ║
                 ╠══════╬════════╬════════╬════════╣
                 ║ **S2**   ║    2   ║  2.44  ║    0   ║
                 ╚══════╩════════╩════════╩════════╝

它看起来不错，但还是有一些缺点。很多时候，文本语义是由某个词出现的次数决定的。例如，如果我们阅读一篇关于“向量”的文章，那么“向量”这个术语会出现很多次。在这种情况下，在我们的文本向量中只使用二进制值将忽略文本的真正语义。最简单的解决方案是将单词出现的次数存储在向量的正确位置。

考虑这些句子:

s1 = “David loves dogs dogs dogs dogs”
s2 = “Dogs are ok with David”
s3 = “Cats love rain”

当然，第一句话在语法上是不正确的，但是我们可以说它是关于狗的。让我们看看相应的向量:

s1 = [0, 1, 5, 1, 0, 0]     
s2 = [0, 1, 1, 0, 1, 0]    
s3 = [1, 0, 0, 1, 0, 1]

这几个向量和前面的唯一区别是，这一次，我们在第一个句子向量的“狗”位置存储 5。

让我们再次使用 PCA 绘制这些向量:

Sentence 1 — Blue, Sentence 2 — Green, Sentence 3 — Red

看看发生了什么；现在，句子 2(绿色)和 3(红色)比 1(蓝色)和 2(绿色)更接近。这对我们非常不利，因为我们不能表达句子的语义。

这个问题最典型的解决方案是，我们可以比较两个向量之间的角度，而不是计算两点之间的距离，例如，这些值:

你可以看到句子 1 和 2 的角度比 1 和 3 或者 2 和 3 更近。实际的相似性度量被称为“余弦相似性，它是两个向量之间角度的余弦。0 的余弦是 1(最相似)，180 的余弦是 0(最不相似)。

这样，我们能够更好地表示文本的语义，以及比较文本对象。

结论

我们看到了表示文本和比较文本对象的不同方法。没有更好或最好的方法，在文本机器学习和数据挖掘相关任务中有许多类型的问题和挑战，我们应该了解并选择适合我们的选项。

还有许多其他的表示和距离/相似性函数，包括 TfIdf 和 Word2Vec，它们是非常常见的文本表示(我希望我会再写一篇文章)。

电报 API 简介

原文：https://towardsdatascience.com/introduction-to-the-telegram-api-b0cd220dbed2?source=collection_archive---------0-----------------------

用程序分析你的电报通话记录

T elegram 是一种即时通讯服务，就像 WhatsApp、Facebook Messenger 和微信一样。近年来，它因为各种原因而广受欢迎:它的非盈利性质、跨平台支持、安全承诺 ，以及它的开放 API。

在这篇文章中，我们将使用 Telethon ，一个用于 Telegram API 的 Python 客户端库，来统计我们每个 Telegram 聊天中的消息数量。

电报 API

“ Telegram has an open API and protocol free for everyone.” — Telegram homepage

Telegram 的 API 中最著名的是它的 Bot API，这是一个基于 HTTP 的 API，供开发人员与 Bot 平台进行交互。Bot API 允许开发者控制电报机器人，例如接收消息和回复其他用户。

除了 Bot API，还有 Telegram API 本身。这是 Telegram 应用程序使用的 API，用于您在 Telegram 上的所有操作。仅举几个例子:查看您的聊天记录、发送和接收消息、更改您的显示图片或创建新群组。通过 Telegram API，你可以用编程的方式做你在 Telegram 应用程序中能做的任何事情。

Telegram API 比 Bot API 复杂得多。您可以使用标准 JSON、表单或查询字符串有效负载通过 HTTP 请求访问 Bot API，而 Telegram API 使用自己的自定义有效负载格式和加密协议。

电报 API

Diagram for MTProto server-client flow

MTProto 是定制的加密方案，支持 Telegram 的安全承诺。它是一种应用层协议，直接写入底层传输流，如 TCP 或 UDP，以及 HTTP。幸运的是，在使用客户端库时，我们不需要直接关心它。另一方面，为了进行 API 调用，我们确实需要理解有效载荷的格式。

类型语言

Telegram API 是基于 RPC 的，因此与 API 的交互包括发送表示函数调用的有效载荷和接收结果。例如，读取一个对话的内容包括用必要的参数调用messages.getMessage函数，并接收一个messages.Messages作为返回。

类型语言或 TL 用于表示 API 使用的类型和函数。TL 模式是可用类型和函数的集合。在 MTProto 中，TL 构造在作为 MTProto 消息的有效载荷嵌入之前将被序列化为二进制形式，但是我们可以将此留给我们将使用的客户端库。

一个 TL 模式的例子(首先声明类型，然后声明函数，函数之间用分隔符隔开):

auth.sentCode#efed51d9 phone_registered:Bool phone_code_hash:string send_call_timeout:int is_password:Bool = auth.SentCode;auth.sentAppCode#e325edcf phone_registered:Bool phone_code_hash:string send_call_timeout:int is_password:Bool = auth.SentCode;---functions---auth.sendCode#768d5f4d phone_number:string sms_type:int api_id:int api_hash:string lang_code:string = auth.SentCode;

使用上述 TL 模式中的函数和类型的 TL 函数调用和结果，以及等效的二进制表示(来自官方文档):

(auth.sendCode "79991234567" 1 32 "test-hash" "en")
=
(auth.sentCode
  phone_registered:(boolFalse)
  phone_code_hash:"2dc02d2cda9e615c84"
)

d16ff372 3939370b 33323139 37363534 00000001 00000020 73657409 61682d74 00006873 e77e812d
=
2215bcbd bc799737 63643212 32643230 39616463 35313665 00343863 e12b7901

TL-模式层

电报 API 使用 TL 模式层进行版本控制；每一层都有一个唯一的 TL 模式。Telegram 网站包含当前的 TL 模式和 https://core.telegram.org/schema的先前层。

看起来是这样，事实证明，虽然 Telegram 网站上最新的 TL-Schema 层是第 23 层，但在撰写本文时，最新的层实际上已经是第 71 层了。你可以在这里找到最新的 TL-Schema。

入门指南

创建电报应用程序

您将需要获得一个api_id和api_hash来与电报 API 交互。请遵循官方文档中的说明:https://core.telegram.org/api/obtaining_api_id。

您必须访问https://my.telegram.org/，使用您的电话号码和确认码登录，确认码将通过电报发送，并在“API 开发工具”下的表格中填写应用标题和简称。之后，你可以在同一个地方找到你的api_id和api_hash。

或者，相同的说明提到您可以使用电报源代码中的样本凭证进行测试。为了方便起见，我将在这里的示例代码中使用我在 GitHub 上的 Telegram 桌面源代码中找到的凭证。

安装天线

我们将使用 Telethon 与 Telegram API 通信。Telethon 是用于 Telegram API 的 Python 3 客户端库(这意味着您必须使用 Python 3 ),它将为我们处理所有特定于协议的任务，因此我们只需要知道使用什么类型和调用什么函数。

您可以使用pip安装 Telethon:

pip install telethon

使用与您的 Python 3 解释器相对应的pip；这可能是pip3代替。(随机:最近 Ubuntu 17.10 发布了，它使用 Python 3 作为默认的 Python 安装。)

创建客户端

在开始与 Telegram API 交互之前，您需要用您的api_id和api_hash创建一个客户端对象，并用您的电话号码对其进行认证。这类似于在新设备上登录 Telegram 你可以把这个客户端想象成另一个 Telegram 应用。

下面是创建和验证客户端对象的一些代码，修改自 Telethon 文档:

from telethon import TelegramClient
from telethon.errors.rpc_errors_401 import SessionPasswordNeededError

# (1) Use your own values here
api_id = 17349
api_hash = '344583e45741c457fe1862106095a5eb'

phone = 'YOUR_NUMBER_HERE'
username = 'username'

# (2) Create the client and connect
client = TelegramClient(username, api_id, api_hash)
client.connect()

# Ensure you're authorized
if not client.is_user_authorized():
    client.send_code_request(phone)
    try:
        client.sign_in(phone, input('Enter the code: '))
    except SessionPasswordNeededError:
        client.sign_in(password=input('Password: '))

me = client.get_me()
print(me)

如前所述，上面的api_id和api_hash来自电报桌面源代码。将您自己的电话号码放入phone变量中。

Telethon 将在其工作目录中创建一个.session文件来保存会话细节，就像你不必在每次关闭和重新打开 Telegram 应用程序时重新验证它们一样。文件名将以username变量开始。如果您想使用多个会话，您可以决定是否要更改它。

如果没有之前的会话，运行此代码将通过电报向您发送授权代码。如果您在电报帐户上启用了两步验证，您还需要输入您的电报密码。认证一次并保存.session文件后，即使您再次运行脚本，您也不必再次重新认证，直到您的会话到期。

如果成功创建并验证了客户机，应该会在控制台上打印出一个代表您自己的对象。它看起来类似于(省略号…表示跳过了一些内容):

User(is_self=True … first_name='Jiayu', last_name=None, username='USERNAME', phone='PHONE_NUMBER' …

现在，您可以使用这个客户机对象开始向 Telegram API 发出请求。

使用电报 API

检查 TL 模式

如前所述，使用 Telegram API 包括调用 TL 模式中的可用函数。在这种情况下，我们对messages.GetDialogs函数感兴趣。我们还需要注意函数参数中的相关类型。下面是我们将用来发出这个请求的 TL 模式的一个子集:

messages.dialogs#15ba6c40 dialogs:Vector<Dialog> messages:Vector<Message> chats:Vector<Chat> users:Vector<User> = messages.Dialogs;messages.dialogsSlice#71e094f3 count:int dialogs:Vector<Dialog> messages:Vector<Message> chats:Vector<Chat> users:Vector<User> = messages.Dialogs;---functions---messages.getDialogs#191ba9c5 flags:# exclude_pinned:flags.0?true offset_date:int offset_id:int offset_peer:InputPeer limit:int = messages.Dialogs;

这并不容易理解，但请注意，messages.getDialogs函数将返回一个messages.Dialogs，它是一个抽象类型，用于包含Dialog、Message、Chat和User向量的messages.dialogs或messages.dialogsSlice对象。

使用 Telethon 文档

幸运的是，Telethon 文档给出了关于如何调用这个函数的更多细节。从https://lonamiwebs.github.io/Telethon/index.html，如果您在搜索框中键入getdialogs，您将看到一个名为GetDialogsRequest的方法的结果(TL-Schema 函数由 Telethon 中的*Request对象表示)。

GetDialogsRequest的文档陈述了方法的返回类型以及关于参数的更多细节。当我们想要使用这个对象时,“复制导入到剪贴板”按钮特别有用，就像现在。

https://lonamiwebs.github.io/Telethon/methods/messages/get_dialogs.html

messages.getDialogs函数以及GetDialogsRequest的构造函数接受一个InputPeer类型的offset_peer参数。在 GetDialogsRequest 的文档中，单击InputPeer链接可以看到一个页面，其中描述了获取和返回该类型的构造函数和方法。

https://lonamiwebs.github.io/Telethon/types/input_peer.html

因为我们想创建一个InputPeer对象作为GetDialogsRequest的参数，所以我们对InputPeer的构造函数感兴趣。在这种情况下，我们将使用InputPeerEmpty构造函数。再次点击进入InputPeerEmpty页面，复制它的导入路径来使用它。InputPeerEmpty构造函数没有参数。

提出请求

下面是我们完成的GetDialogsRequest以及如何通过将它传递给我们授权的客户端对象来获得它的结果:

from telethon.tl.functions.messages import GetDialogsRequest
from telethon.tl.types import InputPeerEmpty

get_dialogs = GetDialogsRequest(
    offset_date=None,
    offset_id=0,
    offset_peer=InputPeerEmpty(),
    limit=30,
)dialogs = client(get_dialogs)
print(dialogs)

在我的例子中，我得到了一个包含对话、消息、聊天和用户列表的DialogsSlice对象，正如我们基于 TL-Schema 所期望的:

DialogsSlice(count=204, dialogs=[…], messages=[…], chats=[…], users=[…])

收到一个DialogsSlice而不是Dialogs意味着不是我所有的对话框都被返回，但是count属性告诉我我总共有多少个对话框。如果您的对话少于某个数量，您可能会收到一个Dialogs对象，在这种情况下，您的所有对话都被返回，您拥有的对话的数量就是向量的长度。

术语

Telegram API 使用的术语有时可能会有点混乱，尤其是在缺少类型定义以外的信息的情况下。什么是“对话”、“消息”、“聊天”和“用户”？

• dialogs代表您的对话历史中的对话
• chats代表与您的对话历史中的对话相对应的群组和频道
• messages包含发送给每个对话的最后一条消息，就像您在 Telegram 应用程序的对话列表中看到的那样
• users包含您与之进行一对一聊天的个人用户，或者向您的某个群组发送最后一条消息的人

例如，如果我的聊天记录是我从 Play Store 中的 Telegram 应用程序获取的截图:

dialogs将包含截图中的对话:老海盗，新闻发布室，莫妮卡，吉安娜…

将包含老海盗、新闻发布室和 Meme 工厂的条目。

messages将包含消息“请上车！”来自老海盗，“哇，提得好！”从新闻发布室，一条代表发给莫妮卡的照片的消息，一条代表吉安娜的回复的消息等等。

users将包含自从 Ashley 向新闻发布室发送最后一条消息以来的条目，以及自从他向 Meme 工厂发送最后一条消息以来的 Monika、Jaina、Kate 和 Winston 的条目。

(我还没有通过 Telegram API 处理过秘密聊天，所以我不确定它们是如何处理的。)

计数消息

我们的目标是统计每次对话中的消息数量。要获得一个会话的消息数量，我们可以使用 TL-Schema 中的messages.getHistory函数:

messages.getHistory#afa92846 peer:[InputPeer](https://lonamiwebs.github.io/Telethon/types/input_peer.html) offset_id:[int](https://lonamiwebs.github.io/Telethon/index.html#int) offset_date:[date](https://lonamiwebs.github.io/Telethon/index.html#date) add_offset:[int](https://lonamiwebs.github.io/Telethon/index.html#int) limit:[int](https://lonamiwebs.github.io/Telethon/index.html#int) max_id:[int](https://lonamiwebs.github.io/Telethon/index.html#int) min_id:[int](https://lonamiwebs.github.io/Telethon/index.html#int) = [messages.Messages](https://lonamiwebs.github.io/Telethon/types/messages/messages.html)

按照与前面使用messages.getDialogs类似的过程，我们可以使用GetHistoryRequest来解决如何使用 Telethon 调用它。这将返回一个Messages或MessagesSlice对象，或者包含一个count属性，告诉我们一个对话中有多少条消息，或者一个对话中的所有消息，这样我们就可以计算它包含的消息数。

然而，我们首先必须为我们的GetHistoryRequest构建正确的InputPeer。这一次，我们使用InputPeerEmpty,因为我们想要检索特定对话的消息历史。相反，我们必须根据对话的性质使用InputPeerUser、InputPeerChat或InputPeerChannel构造函数。

操纵响应数据

为了统计每个对话中的消息数量，我们必须为该对话创建一个GetHistoryRequest，并为该对话创建相应的InputPeer。

所有相关的InputPeer构造函数都采用相同的id和access_hash参数，但是根据对话是一对一聊天、群组还是频道，这些值出现在GetDialogsRequest响应的不同位置:

• dialogs:我们希望对其中的消息进行计数的会话列表，包含一个peer值，以及对应于该会话的对等方的类型和id，但不包含access_hash。
• chats:包含id、access_hash以及本集团和频道的标题。
• users:包含我们个人聊天的id、access_hash和名字。

在伪代码中，我们有:

let counts be a mapping from conversations to message countsfor each dialog in dialogs:
    if dialog.peer is a channel:
        channel = corresponding object in chats
        name = channel.title
        id = channel.id
        access_hash = channel.access_hash
        peer = InputPeerChannel(id, access_hash)
    else if dialog.peer is a group:
        group = corresponding object in chats
        name = group.title
        id = group.id
        peer = InputPeerChat(id)
    else if dialog.peer is a user:
        user = corresponding object in users
        name = user.first_name
        id = user.id
        access_hash = user.access_hash
        peer = InputPeerUser(id, access_hash) history = message history for peer
    count = number of messages in history counts[name] = count

转换成 Python 代码(注意上面的dialogs、chats和users是我们的GetDialogsRequest的结果的成员，也称为dialogs):

counts = {}

# create dictionary of ids to users and chats
users = {}
chats = {}

for u in dialogs.users:
    users[u.id] = u

for c in dialogs.chats:
    chats[c.id] = c

for d in dialogs.dialogs:
    peer = d.peer
    if isinstance(peer, PeerChannel):
        id = peer.channel_id
        channel = chats[id]
        access_hash = channel.access_hash
        name = channel.title

        input_peer = InputPeerChannel(id, access_hash)
    elif isinstance(peer, PeerChat):
        id = peer.chat_id
        group = chats[id]
        name = group.title

        input_peer = InputPeerChat(id)
    elif isinstance(peer, PeerUser):
        id = peer.user_id
        user = users[id]
        access_hash = user.access_hash
        name = user.first_name

        input_peer = InputPeerUser(id, access_hash)
    else:
        continue

    get_history = GetHistoryRequest(
        peer=input_peer,
        offset_id=0,
        offset_date=None,
        add_offset=0,
        limit=1,
        max_id=0,
        min_id=0,
    )

    history = client(get_history)
    if isinstance(history, Messages):
        count = len(history.messages)
    else:
        count = history.count

    counts[name] = count

print(counts)

我们的counts对象是一个聊天名称到消息计数的字典。我们可以对它进行排序和漂亮的打印，以查看我们的热门对话:

sorted_counts = sorted(counts.items(), key=lambda x: x[1], reverse=True)
for name, count in sorted_counts:
    print('{}: {}'.format(name, count))

示例输出:

Group chat 1: 10000
Group chat 2: 3003
Channel 1: 2000
Chat 1: 1500
Chat 2: 300

图书馆魔术

Telethon 有一些帮助功能来简化常见操作。实际上，我们可以用其中的两个帮助器方法来完成上面的工作，client.get_dialogs()和client.get_message_history()，取而代之:

from telethon.tl.types import User

_, entities = client.get_dialogs(limit=30)

counts = []
for e in entities:
    if isinstance(e, User):
        name = e.first_name
    else:
        name = e.title

    count, _, _ = client.get_message_history(e, limit=1)
    counts.append((name, count))

message_counts.sort(key=lambda x: x[1], reverse=True)
for name, count in counts:
    print('{}: {}'.format(name, count))

然而，我觉得首先直接调用 Telegram API 方法是一种更好的学习体验，特别是因为没有一个助手方法适用于所有情况。然而，有一些事情使用 helper 方法要简单得多，比如我们如何在开始时认证我们的客户端，或者上传文件之类的动作，否则这些动作会很乏味。

包扎

这个例子的完整代码可以在这里找到一个要点:https://Gist . github . com/yi-Jiayu/7b 34260 cfbfa 6 CB C2 b 4464 edd 41 def 42

使用 Telegram API 可以做更多的事情，尤其是从分析的角度来看。在想到我的一个老项目后，我开始研究这个项目，试图从导出的 WhatsApp 聊天记录中创建数据可视化:https://github.com/yi-jiayu/chat-analytics。

使用 regex 解析通过电子邮件发送的纯文本聊天记录，我可以生成一个类似于 GitHub punch card 存储库图表的图表，显示一周中的哪些时间聊天最活跃:

然而，使用“电子邮件聊天”功能来导出是相当粗糙的，你需要手动导出每个聊天的对话历史，一旦你收到新消息，它就会过时。我并没有继续这个项目，但是我一直认为可以从聊天记录中获得其他见解。

通过编程访问聊天记录，Telegram 聊天可以做更多的事情。像messages.search这样的方法对我来说非常有用。也许是动态生成高峰和低谷对话的统计数据，或者是持续活跃的对话，或者是找到你最喜欢的表情符号或最常见的 n 字母组合？天空是极限(或 API 速率极限，以较低者为准)。

更新

(2017–10–25 09:45 SGT)修改了消息计数以跳过意外对话框

1. ^ 就我个人而言，我不能对 Telegram 的安全性发表评论，只能指出 Telegram 的对话在默认情况下不是端到端加密的，并提到 Telegram 的加密协议是自行开发的，与 Signal Protocol 等更成熟的协议相比，它受到的审查更少。

各种强化学习算法介绍。第一部分(Q-Learning，SARSA，DQN，DDPG)

原文：https://towardsdatascience.com/introduction-to-various-reinforcement-learning-algorithms-i-q-learning-sarsa-dqn-ddpg-72a5e0cb6287?source=collection_archive---------0-----------------------

强化学习(RL)是指一种机器学习方法，在这种方法中，智能体在下一个时间步接收延迟奖励，以评估其先前的行为。它主要用于游戏(如雅达利、马里奥)，性能与人类相当甚至超过人类。最近，随着算法随着神经网络的结合而发展，它能够解决更复杂的任务，例如钟摆问题:

Deep Deterministic Policy Gradient (DDPG) Pendulum OpenAI Gym using Tensorflow

虽然有大量的 RL 算法，但似乎没有对它们中的每一个进行全面的比较。在决定将哪些算法应用于特定任务时，我很难抉择。本文旨在通过简要讨论 RL 设置来解决这个问题，并介绍一些著名的算法。

1.强化学习 101

通常，RL 设置由两个组件组成，代理和环境。

Reinforcement Learning Illustration (https://i.stack.imgur.com/eoeSq.png)

那么环境是指智能体所作用的对象(例如 Atari 游戏中的游戏本身)，而智能体则代表 RL 算法。该环境首先向代理发送一个状态，然后代理根据它的知识采取行动来响应该状态。之后，环境发送一对下一个状态和奖励给代理。代理将使用环境返回的奖励更新其知识，以评估其最后的动作。循环继续，直到环境发送一个终端状态，结束于 epset。

大多数 RL 算法都遵循这种模式。在下面的段落中，我将简要地谈谈 RL 中使用的一些术语，以便于我们在下一节中进行讨论。

定义

1. 动作(A):代理可以采取的所有可能的动作
2. 状态:环境返回的当前情况。
3. 奖励®:从环境中发送回来的对上次行为进行评估的即时回报。
4. 策略(π):代理用来根据当前状态确定下一步行动的策略。
5. 价值(V):相对于短期回报 R. Vπ(s) 贴现的预期长期回报定义为当前状态下的预期长期回报。
6. Q-value 或 action-value (Q): Q-value 类似于 value，除了它需要一个额外的参数，即当前动作 a 。 Qπ(s，a) 指长期返回当前状态 s ，在策略π下采取行动 a 。

无模型 vs .基于模型

该模型代表对环境动态的模拟。即，模型学习从当前状态 s 0 和动作 a 到下一状态 s 1 的转换概率 T(s1|(s0，a)) 。如果成功学习了转移概率，代理将知道在给定当前状态和动作的情况下进入特定状态的可能性有多大。然而，随着状态空间和动作空间的增长，基于模型的算法变得不切实际。

另一方面，无模型算法依靠试错法来更新其知识。因此，它不需要空间来存储所有状态和动作的组合。下一节讨论的所有算法都属于这一类。

保单与非保单

策略上的代理基于其从当前策略导出的当前动作 a 学习该值，而其策略外的对应部分基于从另一个策略获得的动作 a*学习该值。在 Q-learning 中，这样的策略就是贪婪策略。(我们将在 Q-learning 和 SARSA 中详细讨论这一点)

2.各种算法的说明

2.1 Q-学习

Q-Learning 是一种基于著名的贝尔曼方程的非策略、无模型 RL 算法:

Bellman Equation (https://zhuanlan.zhihu.com/p/21378532?refer=intelligentunit)

上式中的 e 指的是期望值，而ƛ指的是折现因子。我们可以把它改写成 Q 值的形式:

Bellman Equation In Q-value Form (https://zhuanlan.zhihu.com/p/21378532?refer=intelligentunit)

用 Q*表示的最佳 Q 值可以表示为:

Optimal Q-value (https://zhuanlan.zhihu.com/p/21378532?refer=intelligentunit)

目标是最大化 Q 值。在深入研究优化 Q 值的方法之前，我想先讨论两种与 Q 学习密切相关的值更新方法。

策略迭代

策略迭代在策略评估和策略改进之间循环。

Policy Iteration (http://blog.csdn.net/songrotek/article/details/51378582)

策略评估使用从上次策略改进中获得的贪婪策略来估计值函数 V。另一方面，策略改进用使每个状态的 V 最大化的动作来更新策略。更新方程基于贝尔曼方程。它不断迭代直到收敛。

Pseudo Code For Policy Iteration (http://blog.csdn.net/songrotek/article/details/51378582)

值迭代

值迭代只包含一个分量。它基于最佳贝尔曼方程更新值函数 V。

Optimal Bellman Equation (http://blog.csdn.net/songrotek/article/details/51378582)

Pseudo Code For Value Iteration (http://blog.csdn.net/songrotek/article/details/51378582)

在迭代收敛之后，通过对所有状态应用 argument-max 函数，直接导出最优策略。

注意，这两种方法需要转移概率 p 的知识，表明它是基于模型的算法。然而，正如我前面提到的，基于模型的算法存在可扩展性问题。那么 Q-learning 是如何解决这个问题的呢？

Q-Learning Update Equation (https://www.quora.com/What-is-the-difference-between-Q-learning-and-SARSA-learning)

α指的是学习率(即我们接近目标的速度)。Q-learning 背后的思想高度依赖于价值迭代。然而，更新等式被替换为上述公式。因此，我们不再需要担心转移概率。

Q-learning Pseudo Code (https://martin-thoma.com/images/2016/07/q-learning.png)

注意，选择下一个动作*a’*来最大化下一个状态的 Q 值，而不是遵循当前策略。因此，Q-learning 属于非政策范畴。

2.2 国家-行动-奖励-国家-行动

SARSA 非常类似于 Q-learning。SARSA 和 Q-learning 之间的关键区别在于，SARSA 是一种基于策略的算法。这意味着 SARSA 基于由当前策略而不是贪婪策略执行的动作来学习 Q 值。

SARSA Update Equation (https://www.quora.com/What-is-the-difference-between-Q-learning-and-SARSA-learning)

动作 a(t+1)是在当前策略下在下一个状态 s(t+1)中执行的动作。

SARSA Pseudo Code (https://martin-thoma.com/images/2016/07/sarsa-lambda.png)

从上面的伪代码中，您可能会注意到执行了两个操作选择，它们总是遵循当前策略。相比之下，Q-learning 对下一个动作没有约束，只要它最大化下一个状态的 Q 值。因此，SARSA 是一个基于策略的算法。

2.3 深 Q 网(DQN)

虽然 Q-learning 是一个非常强大的算法，但它的主要缺点是缺乏通用性。如果您将 Q-learning 视为更新二维数组(动作空间*状态空间)中的数字，实际上，它类似于动态编程。这表明对于 Q 学习代理以前没有见过的状态，它不知道采取哪种动作。换句话说，Q-learning agent 不具备估计未知状态值的能力。为了处理这个问题，DQN 通过引入神经网络摆脱了二维数组。

DQN 利用神经网络来估计 Q 值函数。网络的输入是电流，而输出是每个动作的相应 Q 值。

DQN Atari Example (https://zhuanlan.zhihu.com/p/25239682)

2013 年，DeepMind 将 DQN 应用于雅达利游戏，如上图所示。输入是当前游戏情况的原始图像。它经历了几层，包括卷积层以及全连接层。输出是代理可以采取的每个操作的 Q 值。

问题归结为:我们如何训练网络？

答案是我们根据 Q 学习更新方程来训练网络。回想一下，Q 学习的目标 Q 值是:

Target Q-value (https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)

ϕ相当于状态 s，而𝜽代表神经网络中的参数，这不在我们讨论的范围内。因此，网络的损失函数被定义为目标 Q 值和从网络输出的 Q 值之间的平方误差。

DQN Pseudo Code (https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)

另外两个技巧对训练 DQN 也很重要:

1. 经验回放:由于典型 RL 设置中的训练样本高度相关，数据效率较低，这将导致网络更难收敛。解决样本分布问题的一种方法是采用经验回放。本质上，样本转换被存储，然后从“转换池”中随机选择以更新知识。
2. 分离目标网络:目标 Q 网络与估值的结构相同。每 C 步，根据上面的伪代码，将目标网络重置为另一个。因此，波动变得不那么剧烈，导致更稳定的训练。

2.4 深度确定性政策梯度(DDPG)

虽然 DQN 在更高维度的问题上取得了巨大的成功，比如雅达利游戏，但是动作空间仍然是离散的。然而，许多感兴趣的任务，尤其是物理控制任务，动作空间是连续的。如果你把行动空间划分得太细，你最终会有一个太大的行动空间。例如，假设自由随机系统的程度是 10。对于每个度数，你把空间分成 4 个部分。你最终有 4 个⁰ =1048576 个动作。这么大的行动空间也极难收敛。

DDPG 依靠演员和评论家两个同名元素的演员-评论家架构。参与者用于调整策略功能的参数𝜽，即决定特定状态的最佳动作。

Policy Function (https://zhuanlan.zhihu.com/p/25239682)

一个批评家被用来评估由行动者根据时间差异(TD)误差估计的策略函数。

Temporal Difference Error (http://proceedings.mlr.press/v32/silver14.pdf)

这里，小写的 v 表示参与者已经决定的策略。看起来眼熟吗？是啊！它看起来就像 Q 学习更新方程！TD 学习是一种学习如何根据给定状态的未来值来预测值的方法。Q 学习是用于学习 Q 值的 TD 学习的特定类型。

Actor-critic Architecture (https://arxiv.org/pdf/1509.02971.pdf)

DDPG 还借鉴了 DQN 的经验重演和分众目标网的理念。DDPG 的另一个问题是它很少探索行动。对此的解决方案是在参数空间或动作空间上添加噪声。

Action Noise (left), Parameter Noise (right) (https://blog.openai.com/better-exploration-with-parameter-noise/)

OpenAI 写的这篇文章声称在参数空间上加比在动作空间上加好。一种常用的噪声是奥恩斯坦-乌伦贝克随机过程。

DDPG Pseudo Code (https://arxiv.org/pdf/1509.02971.pdf)

3.结论

我已经讨论了 Q-learning、SARSA、DQN 和 DDPG 的一些基本概念。在下一篇文章中，我将继续讨论其他最新的强化学习算法，包括 NAF、A3C 等。最后，我将简单地比较一下我所讨论的每一种算法。如果你对这篇文章有任何问题，请不要犹豫，在下面留下你的评论，或者在 twitter 上关注我。

各种强化学习算法介绍。第二部分(TRPO、PPO)

原文：https://towardsdatascience.com/introduction-to-various-reinforcement-learning-algorithms-part-ii-trpo-ppo-87f2c5919bb9?source=collection_archive---------3-----------------------

本系列的第一部分 介绍各种强化学习算法。第一部分(Q-Learning，SARSA，DQN，DDPG) ， I 讲述了强化学习(RL)的一些基本概念，并介绍了几种基本的 RL 算法。在本文中，我将继续讨论两种更高级的 RL 算法，这两种算法都是去年刚刚发表的。最后，我将对我所讨论的每种算法做一个简单的比较。

1.入门指南

定义:

• 优势(A): A(s，a) = Q(s，a)- V(s)

优势是许多高级 RL 算法中常用的术语，如 A3C、NAF 和我将要讨论的算法(也许我会为这两种算法写另一篇博文)。为了以一种更直观的方式来看待它，可以把它想成一个动作与特定状态下的平均动作相比有多好。

但是我们为什么需要优势呢？Q 值不够好吗？

我将用这个论坛中发布的一个例子来说明优势的想法。

你玩过一个叫“接球”的游戏吗？在游戏中，水果会从屏幕上方落下。你需要向左或向右移动篮子来抓住它们。

Catch (https://datascience.stackexchange.com/questions/15423/understanding-advantage-functions)

上图是游戏的草图。上面的圆圈代表一种水果，而下面的小矩形是一个篮子。有三个动作，a1、a2 和 a3。显然，最好的动作是 a2，不要动，因为水果会直接掉进篮子里。现在，假设任何行为都没有负回报。在这种情况下，代理人没有选择最优行动的动机，即上面场景中的 a2。为什么？让我们用 Q*(s，a)来表示状态 s 和动作 a 的最佳 Q 值，那么我们将得到:

(https://datascience.stackexchange.com/questions/15423/understanding-advantage-functions)

假设贴现因子𝛾仅略小于 1。我们可以得到

(https://datascience.stackexchange.com/questions/15423/understanding-advantage-functions)

由于没有负回报，r(a3)和 r(a1)都大于或等于 0，暗示 Q*(s，a3)和 Q*(s，a2)差别不大。因此，在这种情况下，代理人对 a2 比对 a3 只有很小的偏好。

为了解决这个问题，我们可以将每个动作的 Q 值与它们的平均值进行比较，这样我们就可以知道一个动作相对于另一个动作有多好。回想一下上一篇博客，一个州的平均 Q 值被定义为 Value (V)。本质上，我们创造了一个名为 advantage 的新操作符，它是通过用该状态的值减去每个动作的 Q 值来定义的。

2.算法图解

2.1 信任区域策略优化(TRPO)

上一篇文章中讨论的深度确定性策略梯度(DDPG)是一个突破，它允许代理在连续空间中执行操作，同时保持下降性能。然而，DDPG 的主要问题是你需要选择一个合适的步长。如果太小，训练进度会极其缓慢。如果它太大，相反，它往往会被噪音淹没，导致悲剧性的表现。回想一下，计算时差(TD)误差的目标如下:

Target for TD error (https://arxiv.org/pdf/1509.02971.pdf)

如果步长选择不当，从网络或函数估计器中导出的目标值 yi 将不会很好，导致更差的样本和更差的价值函数估计。

因此，我们需要一种更新参数的方法来保证政策的改进。也就是说，我们希望预期贴现长期回报η 总是增加。

Expected Discounted Long-term Reward (https://arxiv.org/pdf/1509.02971.pdf)

**警告:**这部分会有无数的数学方程式和公式。如果您对此不满意，可以直接跳到这一部分的末尾。

与 DDPG 类似，TRPO 也属于政策梯度的范畴。它采用了actor-critical架构，但是修改了 actor 的策略参数的更新方式。

对于新政策π’，η(π’)可以看作是政策π’相对于旧政策π’的优势的期望收益。(由于我在键盘上找不到带曲线的π，我将在以下段落中使用π’)

η For New Policy π’ (https://arxiv.org/pdf/1509.02971.pdf)

你可能想知道为什么使用 advantage。直觉上，你可以把它看作是衡量新政策相对于旧政策的平均表现有多好。新政策的η可以改写为以下形式，其中 ⍴ 是打折的就诊频率。

η Rewrite & ⍴ (https://arxiv.org/pdf/1509.02971.pdf)

然而，由于⍴对新政策π’的高度依赖，上述公式很难进行优化。因此，本文介绍了η(π′)，lπ(π′)的一种近似:

Approximation of η (https://arxiv.org/pdf/1509.02971.pdf)

请注意，我们将⍴π替换为⍴π’，假设新旧政策的州访问频率没有太大差异。有了这个等式，我们可以结合众所周知的策略更新方法:

.

CPI (https://arxiv.org/pdf/1509.02971.pdf)

这里π_{old}是当前策略，而π’是使 L_{πold}最大化的策略的自变量 max。然后我们将得到下面的定理(让我们用定理 1 来表示它)。

Theorem 1 (https://arxiv.org/pdf/1509.02971.pdf)

c 表示惩罚系数，而 D^{max}_{KL}表示每个状态的两个参数的最大 KL 散度。KL 散度的概念源于信息论，描述了信息的损失。简单来说，你可以把它看成π和π’这两个参数有多大的不同。

上式暗示，只要右手边的项最大化，预期的长期回报η就单调提高。为什么？让我们把不等式的右边定义为 M_{i}。

(https://arxiv.org/pdf/1509.02971.pdf)

然后我们可以证明下面的不等式。

(https://arxiv.org/pdf/1509.02971.pdf)

第一行可以简单地把 M_{i}的定义代入定理 1 得到。第二条线成立，因为π_{i}和π_{i}之间的 KL 散度为 0。将第一条线和第二条线结合起来，我们将得到第三条线。这表明，只要 M_{i}在每次迭代中最大化，目标函数η总是在改进的。(我认为第三行末尾的最后一个词应该是 Mi 而不是 m。不确定这是否是论文的打印错误)。因此，我们现在试图解决的复杂问题归结为最大化 Mi。即，

Objective Function 1 (https://arxiv.org/pdf/1509.02971.pdf)

下图直观地说明了η与 L 的近似值:

Visual Illustration of The Approximation (https://www.youtube.com/watch?v=xvRrgxcpaHY&t=363s)

在实践中，如果目标函数中包含惩罚系数，步长会很小，导致训练时间很长。因此，对 KL 散度的约束用于允许更大的步长，同时保证稳健的性能。

Objective Function 2 (https://arxiv.org/pdf/1509.02971.pdf)

KL 散度约束施加在状态空间中的每个状态上，其最大值应该小于一个小数值𝜹.不幸的是，它是不可解的，因为有无限多的状态。该论文提出了一种解决方案，该解决方案提供了一种启发式近似，该近似具有状态上的预期 KL 散度，而不是找到最大 KL 散度。

KL Divergence With State Visitation Frequency ⍴ (https://arxiv.org/pdf/1509.02971.pdf)

现在，当我们展开第一行时，目标函数变成如下:

Objective Function 3 (https://arxiv.org/pdf/1509.02971.pdf)

通过用期望代替状态上的σ，用重要抽样估计量代替动作上的σ，如果采用单路径方法，这等同于旧的策略，我们可以将上述重写为:

Final Objective Function (https://arxiv.org/pdf/1509.02971.pdf)

目标函数也称为“替代”目标函数，因为它包含当前策略和下一个策略之间的概率比。TPRO 成功地解决了 DDPG 提出的性能不能单调提高的问题。位于约束内的区域子集称为信赖域。只要政策变化相当小，这个近似值与真实的目标函数就不会有太大的不同。通过选择满足 KL 散度约束的最大化期望的新政策参数，保证了期望长期回报η的下界。这也暗示你不需要太担心 TRPO 的步长。

2.2 近似策略优化(PPO，OpenAI 版本)

虽然 TRPO 已经取得了巨大且持续的高性能，但是它的计算和实现是极其复杂的。在 TRPO 中，对代理目标函数的约束是新旧策略之间的 KL 差异。

Fisher 信息矩阵是 KL 散度的二阶导数，用于近似 KL 项。这导致计算几个二阶矩阵，这需要大量的计算。在 TRPO 论文中，共轭梯度(CG)算法被用于解决约束优化问题，从而不需要显式计算 Fisher 信息矩阵。然而，CG 使得实现更加复杂。

PPO 消除了由约束优化产生的计算，因为它提出了一个剪裁的代理目标函数。

让 rt(𝜽)表示新旧政策之间的比率。用于近似 TRPO 的长期回报η的替代目标函数变成如下。注下标描述了 TRPO 所基于的保守策略迭代(CPI)方法。

TRPO Objective Function (https://arxiv.org/pdf/1707.06347.pdf)

TRPO 的约束思想是不允许政策改变太多。因此，PPO 没有添加约束，而是稍微修改了 TRPO 的目标函数，并对过大的策略更新进行了惩罚。

Clipped Objective Function (https://arxiv.org/pdf/1707.06347.pdf)

在右边你可以看到概率比 rt(𝜽)被限制在[1- 𝜖，1+𝜖].这表明，如果 rt(𝜽)导致目标函数增加到一定程度，其有效性将下降(被修剪)。让我们讨论两种不同的情况:

• 情况 1:当优势ȃt 大于 0 时

如果ȃt 大于 0，则意味着该动作优于该状态下所有动作的平均值。因此，应通过增加 rt(𝜽来鼓励该行动，以便该行动有更高的机会被采纳。由于分母 rt(𝜽)不变，旧政策增加 rt(𝜽)也意味着新政策增加π𝜽(a(s)。也就是说，增加在给定状态下采取行动的机会。然而，由于修剪，rt(𝜽)只会增长到和 1+𝜖.一样多

• 情况 2:当优势ȃt 小于 0 时

相比之下，如果ȃt 小于 0，那么这个动作应该被阻止。因此，rt(𝜽)应该减少。同样，由于修剪，rt(𝜽)只会减少到和 1-𝜖.一样少

Illustration of The Clip (https://arxiv.org/pdf/1707.06347.pdf)

本质上，它限制了新政策与旧政策的差异范围；因此，消除了概率比 rt(𝜽移出区间的动机。

在实践中，损失函数误差和熵加成也应在实施过程中加以考虑，如下所示。然而，我不打算详细介绍它们，因为最具创新性和最重要的部分仍然是裁剪后的目标函数。

PPO Objective Function (https://arxiv.org/pdf/1707.06347.pdf)

比较 L^{CPI}和 L^{CLIP}的目标函数，我们可以看到 L^{CLIP}实际上是前者的一个下界。它还消除了 KL 发散约束。因此，优化该 PPO 目标函数的计算量比 TRPO 少得多。经验上也证明了 PPO 的表现优于 TRPO。事实上，由于其轻便和易于实现，PPO 已经成为 open ai(https://blog.openai.com/openai-baselines-ppo/)的默认 RL 算法。

3.所讨论算法的比较

Various RL Algorithms I Have Discussed

所有讨论的 RL 算法都是无模型的。也就是说，他们都没有试图去估计目标函数。相反，他们基于反复试验来更新他们的知识。在所有这些公司中，只有 SARSA 是在政策上，根据其当前的行动学习价值。从离散的观察空间到连续的观察空间，DQN 是一个巨大的进步，允许代理处理看不见的状态。DDPG 是另一个突破，它使智能体能够执行具有策略梯度的连续动作，将 RL 的应用扩展到更多的任务，如控制。TRPO 改进了 DDPG 的性能，因为它引入了代理目标函数和 KL 散度约束，保证了长期回报不减少。PPO 通过修改代理目标函数进一步优化 TRPO，提高了性能，降低了实现和计算的复杂度。

结论

总之，我介绍了两种更高级的 RL 算法，并对我讨论过的所有 RL 算法进行了比较。然而，在 TRPO 中，数学公式非常复杂。虽然我已经尽力解释了，但我相信对你们中的一些人来说，这可能仍然是令人困惑的。如果您有任何问题，请随时在下面发表评论，或者在推特上关注我。

单词嵌入和 Word2Vec 简介

原文：https://towardsdatascience.com/introduction-to-word-embedding-and-word2vec-652d0c2060fa?source=collection_archive---------0-----------------------

单词嵌入是最流行的文档词汇表示之一。它能够捕捉文档中单词的上下文、语义和句法相似性、与其他单词的关系等。

到底什么是单词嵌入？不严格地说，它们是特定单词的矢量表示。说到这里，接下来是我们如何生成它们？更重要的是，他们如何捕捉上下文？

Word2Vec 是使用浅层神经网络学习单词嵌入的最流行的技术之一。它是由谷歌的托马斯·米科洛夫于 2013 年开发的。

让我们一部分一部分地解决这个问题。

我们为什么需要它们？

考虑下面类似的句子:过得愉快和过得愉快。它们几乎没有什么不同的意思。如果我们构造一个穷举词汇表(姑且称之为 V)，那就有 V = {Have，a，good，great，day}。

现在，让我们为 V 中的每个单词创建一个独热码编码向量。我们的独热码编码向量的长度将等于 V (=5)的大小。除了索引处代表词汇表中相应单词的元素之外，我们将有一个零向量。这个特殊的元素就是。下面的编码可以更好地解释这一点。

Have = [1，0，0，0，0]；a=[0，1，0，0，0]；good=[0，0，1，0，0]；great=[0，0，0，1，0]；day=[0，0，0，0，1](代表转置)

如果我们试图将这些编码可视化，我们可以想象一个 5 维空间，其中每个单词占据一个维度，与其余维度无关(没有沿其他维度的投影)。这意味着“好”和“伟大”就像“天”和“有”一样不同，这是不正确的。

我们的目标是让具有相似上下文的单词占据相近的空间位置。从数学上来说，这些向量之间的角度余弦应该接近 1，即角度接近 0。

Google Images

产生分布式表示的想法来了。直观地说，我们引入了一个单词对另一个单词的一些依赖性。该单词的上下文中的单词将获得这种*依赖性的更大份额。在一个热编码表示中，所有的字都是彼此独立的*，如前所述。

word 2 vec 是如何工作的？

Word2Vec 是一种构建这种嵌入的方法。它可以使用两种方法获得(都涉及神经网络):Skip Gram 和 Common Bag Of Words (CBOW)

CBOW 模型: 该方法以每个单词的上下文为输入，尝试预测上下文对应的单词。考虑我们的例子:祝你有美好的一天。

*让神经网络的输入是单词，*棒极了。注意，这里我们试图使用单个上下文输入单词来预测一个目标单词( d ay ) 。更具体地说，我们使用输入单词的一个热编码，并测量与目标单词的一个热编码相比的输出误差( d ay)。在预测目标词的过程中，我们学习目标词的向量表示。

让我们更深入地看看实际的架构。

CBOW Model

输入或上下文单词是大小为 V 的一个热编码向量。隐藏层包含 N 个神经元，输出也是长度为 V 的向量，其元素是 softmax 值。

让我们把图中的术语对了:
- Wvn 是将输入 x 映射到隐藏层的权重矩阵(VN 维矩阵) - W`nv 是将隐藏层输出映射到最终输出层的权重矩阵(NV 维矩阵)**

我不会涉足数学。我们就能知道发生了什么。

隐藏层神经元只是将输入的加权和复制到下一层。没有类似乙状结肠、tanh 或 ReLU 的激活。唯一的非线性是输出层中的 softmax 计算。

但是，上述模型使用单个上下文单词来预测目标。我们可以使用多个上下文单词来做同样的事情。

Google images

以上模型取 C 上下文单词。当 Wvn 用于计算隐藏层输入时，我们取所有这些 C 上下文单词输入的平均值。

因此，我们已经看到了单词表示是如何使用上下文单词生成的。但是我们还有一种方法可以做到。我们可以使用目标单词(我们想要生成它的表示)来预测上下文，在这个过程中，我们产生表示。另一个变体，称为跳过克模型做这个。

跳格模型:

这看起来像是多上下文 CBOW 模型被翻转了。在某种程度上，这是真的。

我们把目标词输入网络。模型输出 C 个概率分布。这是什么意思？

对于每个上下文位置，我们得到 V 个概率的 C 个概率分布，每个单词一个。

在这两种情况下，网络都使用反向传播来学习。详细的数学可以在这里找到

谁赢了？

两者各有利弊。根据 Mikolov 的说法，Skip Gram 可以很好地处理少量数据，并被发现可以很好地表示罕见的单词。

另一方面，CBOW 更快，对更频繁的单词有更好的表示。

前方有什么？

上面的解释是一个非常基本的解释。它只是让您对什么是单词嵌入以及 Word2Vec 如何工作有一个高层次的概念。

还有很多事情要做。例如，为了提高算法的计算效率，使用了分层 Softmax 和 Skip-Gram 负采样等技巧。所有这些都可以在这里找到。

感谢阅读！我已经开始了我的个人博客，我不打算在媒体上写更多令人惊叹的文章。订阅的帮助空间，支持我的博客

单词嵌入简介

原文：https://towardsdatascience.com/introduction-to-word-embeddings-4cf857b12edc?source=collection_archive---------3-----------------------

什么是单词嵌入？

单词嵌入的一个非常基本的定义是一个单词的实数向量表示。通常，如今，具有相似意思的单词在嵌入空间中会有接近的向量表示(尽管情况并不总是如此)。

当构建单词嵌入空间时，通常目标是捕获该空间中的某种关系，无论是意义、形态、上下文还是某种其他类型的关系。

通过对密集空间中的单词嵌入进行编码，我们可以用一种方式用数字表示单词，这种方式可以在几十或几百维而不是几百万维的向量中捕获它们(就像一次性编码向量)。

许多单词嵌入都是基于 Zellig Harris 的“分布假设”所引入的概念而产生的，这可以归结为一个简单的想法，即彼此靠近使用的单词通常具有相同的含义。

美妙之处在于，不同的单词嵌入是以不同的方式或使用不同的文本语料库来创建的，以映射这种分布关系，因此最终结果是帮助我们完成 NLP 世界中不同下游任务的单词嵌入。

为什么我们使用单词嵌入？

单词不是计算机自然理解的东西。通过将它们编码成数字形式，我们可以应用数学规则并对它们进行矩阵运算。这使得他们在机器学习领域特别令人惊叹。

以深度学习为例。通过以数字形式编码单词，我们可以采用许多深度学习架构，并将它们应用于单词。卷积神经网络已经应用于使用单词嵌入的 NLP 任务，并且已经为许多任务设置了最先进的性能。

更好的是，我们发现我们实际上可以预先训练适用于许多任务的单词嵌入。这是我们将在本文中讨论的许多类型的焦点。因此，人们不必为每个任务、每个语料库学习一组新的嵌入。相反，我们可以学习通用的表示法，然后在不同的任务中使用。

单词嵌入的具体例子

现在，简单的介绍结束了，让我们来简单地看看我们可以用数字表示单词的一些不同的方法(稍后，我将对每种方法进行更复杂的分析，以及如何在下游任务中实际使用它们)。

一键编码(计数矢量化)

我们可以用数字表示单词的最基本的方法之一是通过一键编码方法(有时也称为计数矢量化)。

想法超级简单。创建一个向量，其维数与你的语料库中唯一的单词数一样多。每个唯一的单词都有一个唯一的维度，在该维度上用 1 表示，在其他维度上用 0 表示。

这样的结果？非常巨大和稀疏的向量，完全没有关系信息。如果你没有其他选择，这可能是有用的。但是如果我们需要语义关系信息，我们还有其他选择。

我现在也有一个关于如何在真实文本数据上使用计数矢量化的帖子！如果你感兴趣，可以在这里查看:自然语言处理:用 scikit-learn 计算矢量化

TF-IDF 变换

TF-IDF 矢量与独热码编码矢量相关。然而，它们不仅仅以计数为特征，而是以数字表示为特征，其中单词不仅仅在那里或者不在那里。相反，单词由它们的术语频率乘以它们的逆文档频率来表示。

简单来说，经常出现但随处可见的单词应该被赋予很小的权重或重要性。我们可以认为这是英语中类似于the或and的单词。他们没有提供大量的价值。

然而，如果一个单词出现得很少或很频繁，但只出现在一两个地方，那么这些可能是更重要的单词，应该这样加权。

同样，这也有非常高维度表示的缺点，不能捕捉语义相关性。

共生矩阵

同现矩阵就像它听起来的那样:一个和词汇量一样长和一样宽的巨大矩阵。如果单词一起出现，它们被标记为阳性条目。否则，他们有一个 0。它归结为一个数字表示，simple 提出了“单词是一起出现的吗？如果有，那就数这个。”

我们已经看到什么正在成为一个大问题？超大表示！如果我们认为独热编码是高维的，那么同现是高维的平方。内存中要存储大量数据。

神经概率模型

现在，我们可以开始进入一些神经网络。神经概率模型通过完成一些任务(如建模或分类)来学习嵌入，并且是这些嵌入的其余部分或多或少所基于的。

通常，你清理你的文本，并创建一个热点编码向量。然后，您定义您的表示大小(300 维可能是好的)。从那里，我们初始化嵌入到随机值。这是进入网络的入口点，反向传播用于根据我们的目标任务修改嵌入。

这通常需要大量数据，并且可能非常慢。这里的权衡是，它学习一种嵌入，这种嵌入对于网络被训练的文本数据以及在训练期间共同学习的 NLP 任务是有益的。

word2vec

Word2Vec 是神经概率模型更好的继承者。我们仍然使用统计计算方法从文本语料库中学习，然而，其训练方法比简单的嵌入训练更有效。这或多或少是现今训练嵌入的标准方法。

这也是第一个演示经典矢量算法来创建类比的方法:

有两种主要的学习方法。

连续词袋

该方法通过基于上下文预测当前单词来学习嵌入。上下文由周围的单词决定。

连续跳跃图

这种方法通过预测给定上下文的周围单词来学习嵌入。上下文是当前单词。

这两种学习方法都使用本地单词使用上下文(具有相邻单词的定义窗口)。窗口越大，通过嵌入学习到的主题相似性就越多。强迫一个更小的窗口导致更多的语义、句法和功能相似性被学习。

那么，有什么好处呢？嗯，高质量的嵌入可以非常有效地学习，特别是在与神经概率模型进行比较时。这意味着低空间和低时间复杂度来生成丰富的表示。更重要的是，维度越大，在我们的表现中就有越多的特征。但是，我们仍然可以保持比其他方法低得多的维数。它还允许我们有效地生成十亿个单词的语料库，但包含一堆概括性的内容，并保持较小的维度。

手套

GloVe 是 word2vec 的扩展，而且是一个更好的扩展。有一组用于自然语言处理的经典向量模型擅长捕捉语料库的全局统计数据，如 LSA(矩阵分解)。他们非常擅长全球信息，但他们不能很好地捕捉含义，而且肯定没有内置的很酷的类比功能。

GloVe 的贡献是在语言建模任务中添加了全局统计来生成嵌入。本地上下文没有窗口功能。相反，有一个词-上下文/词共现矩阵，它学习整个语料库的统计数据。

结果呢？比简单的 word2vec 学习更好的嵌入。

快速文本

现在，有了 FastText ，我们进入了一个非常酷的新单词嵌入的世界。FastText 所做的是决定合并子词信息。它通过将所有单词拆分成一个 n 元字符包(通常大小为 3-6)来实现这一点。它会将这些子单词加在一起，以创建一个完整的单词作为最终特征。这个功能真正强大的地方是它允许 FastText 自然地支持词汇表之外的单词！

这很重要，因为在其他方法中，如果系统遇到一个它不认识的单词，它只需将它设置为未知单词。使用 FastText，如果我们只知道单词 navigate，我们就可以给单词 circuit navigate 赋予意义，因为我们对单词 navigate 的语义知识至少可以帮助我们提供更多的语义信息来 circuit navigate，即使它不是我们的系统在训练期间学习的单词。

除此之外，FastText 使用负采样的 skip-gram 目标。所有的子词都是正例，然后从语料库中的词典中随机抽取样本作为负例。这些是 FastText 培训中包含的主要内容。

另一件很酷的事情是，脸书在开发 FastText 的过程中，用 294 种不同的语言发布了预先训练好的 FastText 向量。在我看来，这是一件非常棒的事情，因为它允许开发人员以非常低的成本使用通常没有预先训练的单词向量的语言来制作项目(因为训练他们自己的单词嵌入需要大量的计算资源)。

如果你想看所有 FastText 支持的语言，点击这里查看。

庞加莱嵌入(分层表示)

庞加莱嵌入非常不同，非常有趣，如果你有雄心壮志，你绝对应该给看看论文。他们决定使用双曲几何来捕捉单词的等级属性。通过将它们嵌入到双曲空间中，它们可以使用双曲空间的性质来使用距离来编码相似性，并且使用向量的范数来编码等级关系。

最终结果是需要更少的维度来编码层级信息，他们通过用非常低的维度重新创建 WordNet 来证明这一点，尤其是与其他单词嵌入方案相比。他们强调了这种方法对于像 WordNet 或像计算机网络这样等级森严的数据是非常有用的。看看这一潮流会产生什么样的研究(如果有的话)将会很有趣。

工程与后勤管理局

ELMo 是我个人的最爱。它们是最先进的上下文单词向量。这些表示是从整个句子的函数中生成的，以创建单词级表示。嵌入是在字符级生成的，因此它们可以利用像 FastText 这样的子词单元，并且不会受到词汇表之外的词的影响。

ELMo 被训练成一个双向、两层的 LSTM 语言模型。一个非常有趣的副作用是，它的最终输出实际上是其内层输出的组合。已经发现的是，最低层适合于像词性标注和其他更多语法和功能任务这样的事情，而较高层适合于像词义消歧和其他更高级、更抽象的任务这样的事情。当我们组合这些层时，我们发现我们实际上在开箱即用的下游任务上获得了令人难以置信的高性能。

我脑子里唯一的问题？我们如何减少维数，并扩展到不太流行的语言上的训练，就像我们对 FastText 的训练一样。

概率快速文本

概率快速文本是最近的一篇论文，它试图更好地处理意思不同但拼写相同的单词的问题。以单词 rock 为例。它可能意味着:

• 摇滚乐
• 一块石头
• 来回移动的动作

我们遇到这个词怎么知道自己在说什么？通常情况下，我们不会。当学习一个嵌入时，我们只是把所有的意思混在一起，然后抱最好的希望。这就是为什么像 ELMo 这样使用整个句子作为上下文的东西，在需要区分不同意思时往往表现得更好。

这也是概率快速文本做得很好的地方。不是将单词表示为向量，而是将单词表示为高斯混合模型。现在，我仍然没有真正理解数学，但许多训练模式仍然类似于 FastText，只是我们不是学习向量，而是学习一些概率性的东西。

我非常好奇这种趋势是否会产生未来的研究，因为我认为远离载体是一种非常好奇的方式。

包扎

如果你喜欢读这篇文章，给我留言或者给我的 GoFundMe 捐款来帮助我继续我的 ML 研究！

敬请关注即将推出的更多单词嵌入内容！

最初发表于T5【hunterheidenreich.com】。

人工智能入门指南

原文：https://towardsdatascience.com/introductory-guide-to-artificial-intelligence-11fc04cea042?source=collection_archive---------2-----------------------

本指南的主要目标是为想学习人工智能的人提供关于理论、技术和应用的直觉。它包括简短的描述和解释性文章和讲座的链接。每一部分都包含基本的材料来了解它是如何工作的。在最后一部分，你可以找到额外的书籍，课程，播客和其他材料。你也可以去游乐场玩互动游戏。让我们开始吧！

内容:

1. 起源
2. 先决数学
3. 没有免费的午餐定理
4. 方法和算法
5. 发展
6. 现实世界的应用
7. 额外资源

起源

人工智能诞生于模仿人类智能的尝试中。看看它的简史。目前还不清楚是否有可能模仿人类的思维，但我们肯定可以再造它的一些功能。与此同时，认知科学的整个领域受到了广泛的关注。

与此同时，它在社会上引起了很多关注。机器接管世界的问题有些言过其实，但工作岗位的转移现在是一个真正的问题。看一看人工智能与自然智能来更好地了解计算机在哪些方面优于我们。

从某种意义上说，所有的计算机甚至计算器都代表了一种 AI。正如该领域的创始人之一所说:

“它一工作，就没人再管它叫 AI 了。” ― 约翰·麦卡锡

随着计算机变得越来越快，方法越来越先进，人工智能将变得越来越聪明。最近的研究表明，在未来 5-10 年内，多达 50%的工作岗位受到威胁。不管我们能否完全模拟我们的思维，人工智能都将对我们的生活产生重大影响。

先决数学

事实上，数学不是严格要求的，但是你需要它来更深入地理解这些方法。我建议在深入之前，至少在每个小节中获得基本的直觉。我假设你已经熟悉了学校代数。如果没有，你可以看看这本指南或者在 openstax 上找到免费的高质量教材。

首先值得注意的是，我们都熟悉的古典逻辑不能代表大多数现代技术。由此，你应该理解模糊逻辑的思想。

第二个重要的话题是图表。这个温和的介绍会帮助你理解主要思想。

线性代数

线性代数将概念和运算从普通代数扩展到数的集合。它们通常代表输入、输出和操作参数。我推荐从这本指南开始。

接下来是张量。张量是标量、向量和矩阵对高维对象的概括。这个视频会给你直观的解释这个概念。

可能性

由于我们通常没有关于任何事情的准确信息，我们不得不处理概率。这篇文章解释了非常基础的东西，而这个系列会让你对概率、统计和贝叶斯逻辑有更完整的理解。我建议至少看完这个系列的前三部分。

目标函数

也称为目标函数、成本函数或损失函数。它们代表了我们方法的主要目的。通常目标函数衡量我们的算法完成工作的好坏。此外，通过优化这个函数，我们可以改进我们的算法。

最重要的是均方误差和交叉熵。你可以在这篇文章中找到关于 MSE 和平均绝对误差的描述，在这篇文章中找到关于交叉熵和 Kullback-Leibler 散度的描述。

有时我们不能直接计算目标函数，需要评估算法的性能。但是这些评估服务于相同的目标。

最佳化

在我们建立了目标函数之后，我们需要优化它的参数来提高我们算法的性能。优化的常用方法是梯度下降。你可以在这里找到直觉，在这里找到更详细的描述。

GD 有很多种。其中之一是随机梯度下降，它只需要训练数据的子集来计算每次迭代的损失和梯度。另一类重要的 GD 算法包括动量，它迫使参数在一个共同的方向上移动。

没有免费的午餐定理

我专门用了一个独特的章节来讲述它，因为这个定理传达了一个非常重要的思想:没有普遍有效的人工智能方法。简而言之，这个定理表明，每个问题解决过程对于每个任务都有一些计算成本，并且这些过程中没有一个比其他过程平均更好。虽然这个定理还没有在最一般的情况下得到证明，但实践已经表明了它的重要性。

Some methods may look particularly wonderful, but you still can’t eat them 😃

所以，我们必须为每个问题选择合适的方法。

常用方法和算法

每种方法的主要目的是为特定问题构建一个良好的输入到输出映射模型。此外，它们的组合导致甚至更好的解决方案。并行搜索、堆叠和提升等技术有助于利用简单模型的混合来构建更好的模型。

虽然搜索方法通常只需要问题规范，但大多数深度学习算法需要大量数据。因此，可用数据在方法选择中起着重要作用。

我将按照发展的大致历史顺序来描述主要的技术类别。

经典编程

虽然编程不再被认为是人工智能技术，但这是很多年前的事了。一个单独的程序可以执行简单的输入加法，这看起来不像是一个智力活动。然而，它可能控制机器人的运动并执行复杂的操作。

You heard me right. Even HTML pages are a kind of AI.

这种方法的可解释的和严格的规范允许在一个结构中组合数百甚至数千个不同的程序。然而，这种方法在大多数复杂的现实场景中都失败了。预测复杂系统中所有可能的输入输出组合是极其困难的。

基于规则的专家系统

典型的专家系统由一组 if-then 规则的知识库和一个推理机制组成。这个教程会给你大概的思路。现代知识图一般用于问答和自然语言处理。在这里你可以得到它们的直观解释。虽然这些方法今天仍在使用，但专家系统的受欢迎程度正在稳步下降。

搜索

如果你能定义可能的解决方案，搜索将帮助你找到一个好的。这个演示介绍将会给你常见搜索算法背后的直觉，以及它们是如何应用在游戏开发中的。另外，本教程会提供更正式的描述。尽管表面上很简单，但如果使用得当，这些方法可以在许多领域取得优异的效果。

遗传算法

遗传或进化算法是一种受生物进化启发的搜索。这篇文章将帮助你理解这个想法。

机器学习

一般来说，ML 方法也使用一种搜索，通常是梯度下降，来寻找解决方案。换句话说，他们使用训练示例来学习/拟合参数。实际上有几十种 ML 算法，但大多数都依赖于相同的原理。

回归、支持向量机、朴素贝叶斯和决策树是最受欢迎和使用最广泛的。

剩下的小节将描述机器学习最突出的领域。

概率图形模型

这些模型以图表的形式学习变量之间的统计相关性。这篇文章将提供 PGMs 的一般概念。如今，它们在现实世界的应用中被神经网络积极地取代，但对于复杂系统的分析仍然有用。

深度学习

简而言之，深度学习是 ML 方法的子集，包括许多层的表示。本帖提供总体概述。NN 最漂亮的特性之一就是你可以任意组合堆叠不同的层。组成层的高级描述通常称为网络架构。

神经网络的基本类型:

• 前馈
• 经常性
• 卷积(以及不同类型的卷积

在更专门化的模块中，神经注意力机制在许多应用中显示出巨大的成果。其他即插即用模块，如长短期存储器或这种用于关系推理的模块在架构设计中提供了很大的灵活性。通过这种方式，你可以很容易地用注意力和其他东西创建循环卷积网络。

受限波尔兹曼机器是无监督学习网络的一个流行例子。

一些技术旨在改善神经网络和其他 ML 模型的泛化，这反过来积极地影响准确性。其中最受欢迎的是辍学和批量正常化。

另一类成功的网络是自动编码器。他们最著名的应用——word 2 vec。此外，它们还用于创建文档、知识图实体、图像、基因和许多其他事物的表示。

另一个有趣的例子是生成对抗网络，它可以学习生成令人信服的图像、视频和任何其他类型的数据。

许多其他类型的神经网络在文献中很受欢迎，但实际应用相对较少:自组织映射、波尔兹曼机器、脉冲神经网络、自适应共振网络等。

强化学习

RL 背后的直觉受到行为心理学家的启发，他们观察到动物从奖励中学习如何行为。这导致了寻找能带来最大回报的政策的方法的发展。本帖包含强化学习的概述。

在历史的进程中发展了许多 RL 方法。最先进的技术包括进化策略、深度强化学习、异步优势行动者-批评家(A3C) 等等。

发展

由于大多数现代系统或多或少使用相同的硬件(GPU 和 TPU)，在这一节中，我将重点介绍软件开发。

基础

对于初学者来说，Python 可能是最好的编程语言。对于当前的人工智能方法来说，它是相当通用的，并且与第一种成功的人工智能语言 Lisp 有许多相似之处。Python 有直观的语法和一个巨大的社区，其中有大量的包、教程和培训材料。

我推荐从多伦多大学的这些课程开始:第一部分和第二部分。它们涵盖的主题从编程的基础到 Python 的最佳实践。

数据科学

因为人工智能方法高度依赖数据，所以你需要能够分析和操纵数据。

这个用 Python 和 Pandas 系列的数据分析将帮助你更深入地理解数据集，而这个面向编码人员的数值线性代数课程将帮助你掌握重要的运算。

这些备忘单包含了流行 Python 库的常用函数的描述。编码的时候有那些很方便。

机器学习

我强烈推荐从吴恩达的机器学习课程开始。它涵盖了所有必要的数学和基本方法:线性和逻辑回归，支持向量机，主成分分析，简单的神经网络和其他。本课程中唯一缺少的重要内容是决策树。这个决策树教程和更高级的渐变提升树教程将填补这个空白。

现在你可以更深入了。这个程序员实用深度学习课程教授如何使用最先进的 DL 技术。此外，这个来自伯克利的深度强化学习课程将向你介绍现代 RL 方法。

也有自动设计机器学习模型的方法。但是要得到好的结果，AutoML 需要比手工构建的模型多得多的资源，所以它还没有普及。此外，在进行人工智能项目时，你应该考虑可能的安全问题。

浏览课程和教程是很棒的，但是要真正理解整个过程，你应该获取一些真实世界的数据并使用它。这些资源将帮助您开始:

开源项目

一些有趣的简单例子可供学习:

1. 数据科学 IPython 笔记本 —大量收集 DS、ML、DL 和其他示例
2. TensforFlow 示例 —针对初学者的带示例的 TF 教程
3. Kaggle 内核 —数千台用于 Kaggle 比赛的开放式笔记本

数据集

您可以使用这些开放数据集来训练您使用不同类型数据的技能:

1. Kaggle 数据集 — 700 多个开放数据集
2. 超赞的公共数据集 — 400 多个开放数据集
3. DeepMind 开放数据集—deep mind 研究中使用的独特数据集

现实世界的应用

本节主要是为开发人员提供启发性的演示。你可以看看人工智能系统现在是如何改变世界的，以及在不久的将来哪些方向将特别相关:医学，军事，教育，科学，物理学，经济学以及许多其他领域。

额外资源

除非另有说明，下面列出的一切都是免费的。此外，大多数课程为学生和工人提供付费证书，通常费用约为 50-100 美元。

谷歌永远是你最好的助手。此外， Quora 是一个寻找答案的好地方。例如，这里的人们已经为 AI 的研究提出了很多材料。

书单

1. 人工智能:现代方法作者斯图尔特·拉塞尔和彼得·诺维格(不免费！)—领先的人工智能教材
2. 大卫·l·普尔和艾伦·k·马克沃斯的《人工智能:计算代理的基础》
3. 深度学习书籍(pdf、mobi 和 epub )作者:伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔——最佳 DL 教材
4. 安德森·霍洛维茨的《人工智能行动手册》——以实践为导向的人工智能书籍
5. 神经网络和深度学习迈克尔·尼尔森著——专注于神经网络的书
6. 吴恩达的《机器学习向往》——一本关于如何构建一个生产就绪的 ML 项目的书
7. 马文·明斯基的情感机器(不免费！)—伟大的 AI & CogSci 书籍，由 AI 领域的一位父亲撰写，侧重于理论

你还可以在这个资源库中找到更多关于机器学习的电子书。

在线课程

作为人工智能的第一门课程，我会推荐吴恩达的机器学习和安萨夫·萨莱博-奥乌伊西的人工智能。

1. 彼得·诺维格和巴斯蒂安·特龙的《人工智能导论》
2. 机器学习简介作者凯蒂·马龙和巴斯蒂安·特龙 Python 中的 ML 算法简介
3. 深度学习作者吴恩达——神经网络及其在实际项目中应用的 5 门专业课程
4. Vincent Vanhoucke 和 Arpan Chakraborty 的《深度学习》Python 中的 DL 算法简介
5. 用于机器学习的神经网络作者 Geoffrey hint on——关于神经网络的综合性理论导向课程
6. 杰瑞米·霍华德程序员实用深度学习—面向实践的 DL 课程
7. 杰瑞米·霍华德《程序员的前沿深度学习》—本课程的第二部分，介绍数字图书馆的最新发展
8. 用于视觉识别的卷积神经网络Andrej kar pathy——斯坦福关于卷积网络的讲座(2017 年春季)
9. 深度自然语言处理，牛津 2017 —自然语言处理深度学习综合课程
10. 深度学习暑期学校，蒙特利尔( 2016 ， 2017 ) —许多深度学习主题的讲座
11. Parag Mital 的深度学习与 TensorFlow 的创造性应用——DL 在艺术中的应用课程
12. 自动驾驶汽车的深度学习，麻省理工学院 2017-自动驾驶汽车深度学习实践的入门课程

博客

1. 开放 AI 博客 —关注 AI 安全问题
2. DeepMind 博客——*“解决智能。用它让世界变得更美好。”*是 DeepMind 的座右铭
3. 谷歌研究博客——谷歌研究的最新消息
4. 脸书研究博客——脸书研究的最新消息
5. 微软下一篇博客 —微软技术和研究的最新消息
6. BAIR 博客 —伯克利人工智能研究平台
7. 直觉机器 —深度学习模式、方法论和策略
8. LAB41 博客 —数据分析研究的发现、实验结果和思考
9. 提炼 —最清晰的机器学习研究期刊

频道和播客

1. send ex—各种 Python 教程
2. 深度学习。电视 —简化的深度学习
3. Siraj Raval——寓教于乐
4. 两分钟论文——最新研究的简要概述
5. 人工智能播客——英伟达关于不同主题的播客
6. 本周在机器学习& AI —每周有趣访谈

自省引擎:斯诺登的移动安全解决方案

原文：https://towardsdatascience.com/introspection-engine-snowdens-mobile-security-solution-e680e8ab4092?source=collection_archive---------1-----------------------

爱德华·斯诺登介绍了一种新的移动安全解决方案，并提醒说数据保护可以拯救生命

爱德华·斯诺登可能是一个有争议的人物，但不可否认的是，在 it、网络和移动安全方面，他是一名专家。在成为 NSA 告密者后，他现在住在莫斯科郊区，通过设计网络安全解决方案让自己忙碌起来。在麻省理工学院媒体实验室的活动中，斯诺登与同为黑客的安德鲁·黄(Andrew ‘Bunnie’ Huang)合作，展示了一个可以阻止未经授权的数据访问的智能手机保护套概念。在马萨诸塞州剑桥举行的活动中，斯诺登从俄罗斯通过视频链接讨论了他的产品。

被禁止的研究着眼于伦理方面，与技术、网络和移动安全相关的法律法规，以及这些是否会改善或阻碍社会的健康和可持续发展。由于人工智能、机器学习和数据经常引发社会、道德和法律问题，因此重要的是要研究它们，看看是否有一种解决方案既能造福世界，又能带来创新。

斯诺登和黄表达了他们对移动设备越来越多的未经授权的访问和攻击的担忧，并讨论了他们的产品和研究，将其命名为“硬件自省引擎”。智能手机外壳将能够在无线电信号传输时提醒用户。斯诺登说，即使智能手机用户将他们的设备设置为飞行模式，关闭手机的蜂窝和 WiFi 连接，GPS 仍然会保持活动状态。这款新的外壳状产品可以连接到智能手机，监控发送到内部天线的电信号，警告和阻止未经授权的访问尝试，提供额外的电池电源，并覆盖后置摄像头。然而，该设备仍处于项目阶段，近期还没有大规模生产的明确计划。

这个概念可能听起来像詹姆斯·邦德电影中的情节，但对小工具安全性的担忧正在上升。在马克·扎克伯格最近的一篇帖子中，精明的用户发现这位企业家的 Macbook 前置摄像头和麦克风被胶带覆盖，这在社交媒体上引发了一系列问题。屡获殊荣的网络安全专家格雷厄姆·克莱利随后评论道:“我认为扎克伯格采取这些预防措施是明智的。”

然而，不仅仅是高知名度的人的计算机和移动设备受到威胁。当黑客扫描开放的网络和移动摄像头时，可能出于各种动机，从偷窥到勒索。根据非营利组织数字公民联盟的报告，未经授权的访问问题正在增长，年轻女性被视为主要目标之一。

斯诺登和黄提出智能手机保护套想法的主要原因之一是记者及其材料的脆弱性。斯诺登说:“不幸的是，记者会被他们自己的工具出卖。”早在 2012 年，美国记者玛丽·科尔文在报道叙利亚内战时被杀，一项诉讼称她是在卫星电话通信被事先追踪到她的位置的情况下被暗杀的。

《新闻自由报》称，如果原型被证明是成功的，该组织可能会寻求必要的资金来开发和维护它。这将使记者在生命受到威胁的情况下更加安全。在麻省理工学院的演讲中，斯诺登补充道:“一名优秀的记者在正确的时间出现在正确的地点，可以改变历史。一个优秀的记者可以在选举中左右局势。一个位置合适的记者可以影响一场战争的结果。

考虑到斯诺登项目的敏感性和自愿资助的事实，大规模生产可能是不可能的。移动和网络安全问题仍然令人担忧，但像麻省理工学院媒体实验室禁止研究这样的事件，可以进一步鼓励观众更加谨慎地使用他们的移动设备，并帮助他们了解数据的脆弱性。

主成分背后的直觉

原文：https://towardsdatascience.com/intuition-behind-principal-components-849d3ef9d616?source=collection_archive---------9-----------------------

PCA 一直困扰着我。这是那些我已经记了很多遍，但在我的潜意识中却无法正确理解的概念之一。这是在我完全理解线性代数的细微差别之前。

如果你理解矩阵的特征值、特征向量和协方差，那么你最终会在这篇博客中找到 PCA 的平静。如果这些概念有点生疏，不要担心，你可以在继续之前快速修改它们 这里 和 这里 。

假设我们为 5 个不同的个体测量了 9 个不同的变量/属性，并将数据放入一个 9 乘 5 的矩阵中。

Matrix A : 9x5dimensional

同样假设，我们也对这个数据应用了我们可爱的标准化，因此每一行的平均值为零。所以在上面的矩阵中，均值(行 1)=均值(行 2)…平均值(第 9 行)= 0

让我们称这个矩阵为 A，我在行中有变量/属性，在列中有观察值。

现在在我跳到主成分及其解释之前，首先让我们计算 a 的协方差矩阵。

A 的协方差矩阵将是 S = AAt/(n-1 ),其中 At =矩阵 A 的转置，n 是观测值的数量= 5

现在，为了确保我们对矩阵 S 的维数是正确的，AAt 的维数应该是(9x5)乘以(5x9) = (9x9)

因此，基本上，由于我们已经将变量(m=9)放在行中，所以协方差矩阵的维数将是 9x9。

这是我已经计算过的矩阵 S——

Matrix A : 9x5

Matrix B = At (A transpose) : 5x9

Covariance Matrix S : AAt/(n-1) : 9x9

现在，是时候让事情真正热起来，并计算上述矩阵的一些性质

S 的特征值个数:

首先，看起来 9×9 维矩阵 S 的特征值总数等于 9，然而这不是真的。矩阵 AAt 和 AtA 的特征值个数必须相同(证明 此处 )

因此，AtA 矩阵将具有 5x5 的维度(检查！)并因此将具有最多 5 个非零特征值，矩阵 AAt 也是如此。

然而，矩阵 A 的所有列都不是独立的(记得我们将所有行居中，所以 A 的所有列的总和将为零)，因此，矩阵 AAt 的非零特征值将仅为 4。

即 S 的特征值的数量:4

我们把 A 的 4 个奇异值(奇异值分解)称为:

因此，S 的特征值= A 的信号值的平方=

Eigenvalues of S

上述特征值是直接从矩阵 S 的值通过编程计算出来的。

注意，S 的特征值之和也等于 S ~1756.7 的对角元素之和

Sum of Eigenvalues of S = 1756.7

Sum of diagonals elements of S = 1752.91

现在，让我们也计算矩阵 a 的每一行(属性)的方差。(因为我们对每一行的均值是零，方差只是每个值的平方和除以 4)

Last Column is variance of each row of matrix A

一旦个体方差在这里，我们可以计算:

矩阵 A 的属性总方差=所有属性方差之和= 1753.39

请注意，协方差矩阵 S 的特征值之和几乎与原始数据矩阵 a 的总方差之和相同。这是一个重要的性质。

因此，我们的 4 个特征值涵盖了数据中的所有方差，注意第一个特征值是最大的，然后它继续下降。

矩阵 S 的每个特征值与其特征向量相关联。在我们的例子中，我们有 4 个特征向量

其中每个特征向量相互垂直，并根据它们各自的特征值计算

最大特征值具有特征向量(u1 ),我们称之为第一主分量，因为该主分量能够解释其方向上的最大方差(1753.39 中的 1323.9)

第二大特征值具有特征向量(u2 ),该特征向量也称为第二主分量，并解释了(在其垂直于第一主分量方向上的总共 1753.39 个方差中的 397.2 个方差)

类似地，第三和第四特征向量解释了总方差相对较小的部分，但这是我们停止的地方。如果我们对前两个特征值求和，我们将得到 98%的总方差，仅由两个特征向量解释，这基本上意味着 u1 和 u2 包含关于矩阵 A 中数据的最大信息，因此我们只需要两个向量，而不是 A 的所有列。这也是我们所说的 PCA 中的降维。

上面的例子是有意将 5 维减少到 2 维，然而，很难想象这样的例子

现在让我们举一个更简单的例子，当我们对这个方法有些熟悉的时候，让它永远在我们的脑海中具体化

我们有两个属性年龄和身高为 6 人，如下所示矩阵格式[2x6]，年龄和身高行以零为中心。

Matrix A: 2x6 with Mean(row1) = Mean(row2) = 0

Plotted points in 2-D

二维数据也可以如上所示绘制，X 为年龄，y 为身高

有了矩阵 A 中的数据，我们来计算它的协方差矩阵 S = AAt/(n-1)

回想一下，我们的协方差矩阵是 2x2

现在，我们计算 S 的特征值，可以找到 57 和 3(回想一下，S 的特征值之和是 diagnol = 60 上的元素之和，这意味着到目前为止我们是好的。

现在，我们找到矩阵 A 属性的总方差

所以总方差= 20 + 40 = 60

回想一下矩阵 A 中方差=协方差矩阵 S 的特征值之和= 60

所以，第一个特征值 57 解释了我们数据中 60 个变量中的 57 个。如果我们找到它的特征向量，它就是向量

u1 = [0.6 0.8]

这在理论上可以解释最大方差。

当我们在二维空间中绘制这个向量时，我们会得到红线，它基本上只是二维空间中的点在一维空间中的表示。这里，特征向量 u1 是第一主分量，包含关于矩阵 a 的最大信息。

我希望现在有意义的是如何将一个矩阵简化为一组正交的特征向量，这些特征向量通过它们的特征值来解释总方差的最大分数。并且如果我们有总共 q 个特征向量(或主成分)，那么我们只选择最上面的 r 个特征向量(r

干杯！

卡尔曼滤波器对自动驾驶汽车应用的直觉

原文：https://towardsdatascience.com/intuition-of-kalman-filter-for-self-driving-car-applications-749b356e19db?source=collection_archive---------0-----------------------

这是我关于卡尔曼滤波器的讲稿。这篇笔记试图欣赏和捕捉 Sebastian Trun 在他关于卡尔曼滤波器的讲座中分享的丰富直觉。我还参考了其他一些资料，如为什么你应该使用卡尔曼滤波器教程——口袋妖怪示例

增强直觉是塞巴斯蒂安讲课的特点。这是他天赋的一部分。因此，我个人非常喜欢上他的课。所以我想做笔记来捕捉它们，并确保我完全理解它们。我也希望笔记能使对话的流畅更具体，从而为进一步欣赏直觉提供另一种选择。这也是我理解直觉并确认我是否真正理解直觉的方法。

卡尔曼滤波器是一种通过组合具有不确定性的多个测量或估计源来估计信号的方案。

在自动驾驶汽车的情况下，信号是物体的位置。

首先，主要测量是来自激光雷达或雷达的物体的位置。第二个估计是基于对物体速度的理解对物体运动的预测。

这两个测量/估计源被交替使用，以组合和提高物体位置估计的精度。组合的过程如下:

1. 胡乱猜测物体的位置(初始化)；
2. 使用位置的测量来提高精度(通过测量更新)；
3. 使用运动预测并基于步骤 2 中对象位置的更新估计来进一步预测/改进对象位置的估计(通过独立运动估计预测)；
4. 使用步骤 3 的结果作为对象位置的新估计，从步骤 2 开始重复迭代。

使用步骤 2，可以提高物体位置估计的准确性/确定性，因为测量是相关的观察事件。

使用目标运动预测的步骤 3，独立于目标位置的测量，添加目标的观察值。这将进一步降低步骤 2 中物体位置测量的准确性或可用性的依赖性。

在第 2 步和第 3 步中，测量的确定性和运动预测被建模为高斯分布。高斯分布的平均值是估计值，而方差是测量/预测的确定性的表示。高斯分布很好地代表了一种直觉，即估计值在均值附近具有对称性和高可能性。接近均值的程度就是确定性的程度。

对于步骤 2，基于相关测量的更新估计将是先前平均值的加权平均值，以及新测量的平均值。特别值得注意的是，这是一个交叉加权平均值，以前估计的方差是新测量的权重，而当前测量的方差是以前估计的权重。如果新的测量具有更小的方差，即更确定，这将有利于新的测量。

对于步骤 3，由于它是一个独立的估计，新的均值和方差将是先前估计值(均值、方差)和预测值的总和。虽然这可能不会提高位置的总体估计的确定性，但是它可能有助于添加来自物体位置的独立源的更多信息。当测量不可用或不总是可信时，这将特别有帮助。实际上，这可能有助于提高物体位置估计的准确性。

感谢您的阅读，请纠正和提高我的理解。

对 L1 和 L2 正则化的直觉

原文：https://towardsdatascience.com/intuitions-on-l1-and-l2-regularisation-235f2db4c261?source=collection_archive---------0-----------------------

Photo by rawpixel on Unsplash

解释 L1 和 L2 如何使用梯度下降法

(右跳 此处 跳过引见。)

2020 年 3 月 27 日:在 2-norm 和 p-norm 中的术语中添加了 absolute。感谢 里卡多 N 桑托斯 指出这一点。

O 过度拟合是一种机器学习或统计模型针对特定数据集定制，无法推广到其他数据集时发生的现象。这通常发生在复杂的模型中，比如深度神经网络。

规则化是引入额外信息以防止过度拟合的过程。本文的重点是 L1 和 L2 的正规化。

有很多解释，但老实说，它们有点太抽象了，我可能会忘记它们，并最终访问这些页面，结果又忘记了。在这篇文章中，我将与你分享一些直觉，为什么 L1 和 L2 使用梯度下降进行解释。梯度下降是一种简单的方法，通过使用梯度值的迭代更新来找到“正确的”系数。(这篇文章展示了如何在简单的线性回归中使用梯度下降。)

内容

0. 什么是 L1 和 L2？
1. 模型
2. 损失函数
3. 梯度下降
4. 如何防止过拟合？

我们走吧！

0)什么是 L1 和 L2？

L1 和 L2 的正规化分别归功于 L1 和 L2 规范的一个向量**、T42、w**。这里有一个关于规范的初级读本:

1-norm (also known as L1 norm)

2-norm (also known as L2 norm or Euclidean norm)

p-norm

实现 L1 范数正则化的线性回归模型称为套索回归，实现(平方)L2 范数正则化的线性回归模型称为岭回归。要实现这两个，请注意线性回归模型保持不变:

但是损失函数的计算包括这些正则化项:

Loss function with no regularisation

Loss function with L1 regularisation

Loss function with L2 regularisation

注:严格来说，最后一个方程(岭回归)是一个权重为 平方 L2 范数的损失函数(注意没有平方根)。(感谢Max Pechyonkin强调这一点！)

除了必须最小化真实 y 和预测 ŷ 之间的误差之外，正则化项是优化算法在最小化损失函数时必须“遵守”的“约束”。

1)型号

让我们定义一个模型来看看 L1 和 L2 是如何工作的。为简单起见，我们定义一个简单的线性回归模型 ŷ 与一个独立变量。

在这里，我使用了深度学习约定 w (“权重”)和 b (“偏差”)。

在实践中，简单的线性回归模型不容易过度拟合。正如引言中所提到的，深度学习模型由于其模型的复杂性，更容易受到此类问题的影响。

因此，请注意，本文中使用的表达式很容易扩展到更复杂的模型，而不仅限于线性回归。

2)损失函数

为了证明 L1 和 L2 正则化的效果，让我们使用 3 种不同的损失函数/目标来拟合我们的线性回归模型:

• L
• 腰神经 2
• L2

我们的目标是尽量减少这些不同的损失。

2.1)无正则化的损失函数

我们将损失函数 l 定义为平方误差，其中误差是 y (真实值)和 ŷ (预测值)之差。

让我们假设使用这个损失函数，我们的模型会过度拟合。

2.2)L1 正则化损失函数

基于上述损失函数，添加一个 L1 正则化项，如下所示:

其中调整参数λ0 是手动调整的。让我们称这个损失函数为 L1。注意| w| 处处可微，除了当 w =0 时，如下图。我们以后会需要这个。

2.3)L2 正则化损失函数

类似地，将 L2 正则化项添加到 L 看起来像这样:

这里又，λ0。

3)梯度下降

现在，让我们基于上述*定义的 3 个损失函数，使用梯度下降优化求解线性回归模型。*回想一下，在梯度下降中更新参数 w 如下:

让我们用 L 、 L1 和 L2 w.r.t. w. 的梯度来代替上式中的最后一项

l:

L1:

L2:

4)如何防止过度拟合？

从这里开始，让我们对上面的等式进行以下替换(为了更好的可读性):

• η = 1，
• H = 2x ( wx+b-y )

这给了我们

l:

L1:

L2:

4.1)有无正规化

观察有正则化参数 λ 和没有正则化参数的重量更新之间的差异。以下是一些直觉。

直觉 A:

让我们用等式 0 来说，计算 w-H 给出了导致过拟合的 w 值。然后，直观地，等式{1.1、1.2 和 2}将减少过拟合的机会，因为引入 λ 使我们将从上一句中导致过拟合问题的 w 处移开。

直觉 B:

假设一个过度拟合的模型意味着我们有一个 w 值，它对于我们的模型来说是完美的。“完美”意味着如果我们将数据( x )代入模型，我们的预测 ŷ 将非常非常接近真实的 y 。当然，这很好，但我们不想要完美。为什么？因为这意味着我们的模型只适用于我们训练的数据集。这意味着我们的模型将产生与其他数据集的真实值相差甚远的预测。因此，我们满足于不太完美的，希望我们的模型也能得到与其他数据接近的预测。为此，我们用惩罚项 λ“玷污”等式 0 中的这个完美的 w 。这给了我们等式{1.1，1.2 和 2}。

直觉 C:

注意， H (此处定义为)是依赖于型号( w 和 b )和数据( x 和 y )。仅基于模型和等式 0 中的数据更新权重会导致过度拟合，从而导致泛化能力差。另一方面，在等式{1.1、1.2 和 2}中， w 的最终值不仅受模型和数据的影响，而且还受独立于模型和数据的的预定义参数 λ 的影响。因此，如果我们设置一个合适的值 λ ，我们可以防止过拟合，尽管太大的值会导致模型严重欠拟合。******

直觉 D:

Edden Gerber (谢谢！)提供了一个关于我们的解决方案正在转向的方向的直觉。在评论里看看:https://medium . com/@ edden . gerber/thanks-for-the-article-1003 ad 7478 B2

4.2) L1 对 L2

我们现在将注意力集中到 L1 和 L2，并通过重新排列它们的 λ 和 H 项来重写方程{1.1、1.2 和 2},如下所示:

L1:

L2:

比较上面每个等式的第二项。除了 H 之外， w 的变化取决于 λ 项或 -2 λ w 项，这突出了以下的影响:

1. 电流的符号 w (L1，L2)
2. 电流大小 w (L2)
3. 正则化参数加倍(L2)

使用 L1 的权重更新受第一点的影响，而来自 L2 的权重更新受所有三个点的影响。虽然我只是基于迭代方程更新进行了比较，但请注意，这并不意味着一个比另一个“更好”。

现在，让我们看看下面如何通过当前的 w. 符号获得来自 L1 的正则化效果

4.3) L1 效应向 0 推进(稀疏度)

看看方程 3.1 中的 L1。如果 w 为正，正则化参数λ0 将通过从 w 中减去 λ 来推动 w 为负。相反地，在等式 3.2 中，如果 w 为负，那么 λ 将被加到 w 上，使其变得更小。因此，这具有将 w 推向 0 的效果。

这在一元线性回归模型中当然是无意义的，但将证明它在多元回归模型中“去除”无用变量的能力。你也可以把 L1 想成是减少了模型中特性数量的 T52。这里有一个 L1 试图在多元线性回归模型中“推动”一些变量的任意例子:

那么，在 L1 正则化中，将 w 推向 0 如何帮助过度拟合呢？如上所述，当 w 变为零时，我们通过降低变量重要性来减少特征的数量。在上式中，我们看到 x_2 、 x_4 和 x_5 几乎是“无用”的，因为它们的系数很小，因此我们可以将它们从等式中移除。这反过来降低了模型的复杂性，使得我们的模型更加简单。更简单的模型可以减少过度拟合的机会。

注

虽然 L1 有将权重推向 0 的影响力，而 L2 没有，但这并不意味着由于 L2，权重不能接近 0。

如果你发现文章的任何部分令人困惑，请随意突出显示并留下回复。此外，如果有任何反馈或建议如何改进这篇文章，请在下面留下评论！

参考

常模(数学)(wikipedia.org)

拉索(统计)(wikipedia.org)

套索和山脊正规化【medium.com

特别感谢【任杰】 、丹尼尔 德里克 对本文的观点、建议和修正。也感谢C Gam指出导数中的错误。

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

以梯度推进为研究案例的直观集成学习指南

原文：https://towardsdatascience.com/intuitive-ensemble-learning-guide-with-gradient-boosting-as-a-study-case-9a3bc1ba1e09?source=collection_archive---------8-----------------------

使用单一的机器学习模型可能不总是适合数据。优化其参数也可能于事无补。一种解决方案是将多个模型结合在一起以适应数据。本教程以梯度推进为研究案例，讨论集成学习的重要性。

简介

机器学习(ML)管道中的一个关键步骤是选择适合数据的最佳算法。基于来自数据的一些统计和可视化，ML 工程师将选择最佳算法。让我们将其应用于一个回归示例，其数据如图 1 所示。

Figure 1. Regression input-output simple data.

通过根据图 2 可视化数据，似乎线性回归模型将是合适的。

Figure 2. Data visualization.

一个只有一个输入和一个输出的回归模型将根据图 3 中的等式进行公式化。

Figure 3. Linear regression model

其中 a 和 b 是方程的参数。

因为我们不知道适合数据的最佳参数，所以我们可以从初始值开始。我们可以将 a 设置为 1.0，b 设置为 0.0，并如图 4 所示可视化模型。

Figure 4. Initial regression model.

该模型似乎不符合基于参数初始值的数据。

预计从第一次试验开始，一切可能都不成功。问题是如何在这种情况下提高结果？换句话说，如何最大化分类精度或者最小化回归误差？做那件事有不同的方法。

一个简单的方法是尝试改变先前选择的参数。经过多次试验后，模型将知道最佳参数是 a=2 和 b=1。在这种情况下，模型将符合数据，如图 5 所示。非常好。

Figure 5. Linear regression model

但是在某些情况下，改变模型参数不会使模型符合数据。会有一些错误的预测。假设数据有一个新点(x=2，y=2)。根据图 6，不可能找到使模型完全适合每个数据点的参数。

Figure 6. Impossible to fit the data by changing model parameters.

有人可能会说，拟合 4 个点，缺少一个点是可以接受的。但是，如果有更多的点不符合直线，如图 7 所示，该怎么办呢？因此，模型会做出比正确预测更多的错误预测。没有一条线可以容纳全部数据。该模型对线上各点的预测能力较强，但对其他点的预测能力较弱。

Figure 7. More false predictions.

合奏学习

因为单个回归模型无法拟合全部数据，所以另一种解决方案是使用多个回归模型。每个回归模型都能够很好地拟合一部分数据。所有模型的组合将减少整个数据的总误差，并产生一个通常很强的模型。在一个问题中使用多个模型称为集成学习。使用多个模型的重要性如图 8 所示。图 8(a)显示，预测样本结果时误差很大。根据图 8(b ),当存在多个模型(例如，三个模型)时，它们的结果的平均值将能够做出比以前更准确的预测。

Figure 8. Single vs. multiple models

当应用于图 7 中的前一个问题时，拟合数据的 4 个回归模型的集合如图 9 所示。

Figure 9. Ensemble of 4 regression models

这就留下了另一个问题。如果有多个模型来拟合数据，如何得到单个预测？有两种方法可以组合多个回归模型来返回一个结果。他们是装袋和助推(这是本教程的重点)。

在 bagging 中，每个模型将返回其结果，并且通过汇总所有这些结果将返回最终结果。一种方法是对所有结果进行平均。装袋是并行的，因为所有模型同时工作。

相比之下，增压被认为是连续的，因为一个模型的结果是下一个模型的输入。boosting 的思想是使用弱学习器来拟合数据。因为它是弱的，它将不能正确地拟合数据。这样一个学习者的弱点会被另一个弱学习者所弥补。如果一些弱点仍然存在，那么将使用另一个弱学习者来修复它们。这个链条不断延伸，直到最终从多个弱学习者中产生一个强学习者。

接下来是解释梯度增强是如何工作的。

梯度增强(GB)

下面是基于一个简单示例的梯度增强工作原理:

假设要建立一个回归模型，数据只有一个输出，其中第一个样本有一个输出 15。如图 10 所示。目标是建立一个回归模型，正确预测这样一个样本的输出。

Figure 10

第一个弱模型预测第一个样本的输出是 9，而不是图 11 所示的 15。

Figure 11. Prediction of 9/15 with residual equal to 6.

为了测量预测中的损失量，需要计算其残差。残差是期望输出和预测输出之间的差值。它是根据以下公式计算的:

期望—预测 1 =剩余 1

其中预测 1 和残差 1 分别是第一弱模型的预测输出和残差。

通过用期望输出和预测输出的值代替，残差将是 6:

15–9 = 6

对于预测输出和期望输出之间的残差 1 =6，我们可以创建第二个弱模型，其目标是预测与第一个模型的残差相等的输出。因此，第二种模式将弥补第一种模式的不足。根据下式，两个模型的输出之和等于所需输出:

期望=预测 1 +预测 2(剩余 1)

如果第二弱模型能够正确预测残差 1 ，那么期望输出将等于所有弱模型的预测，如下所示:

期望=预测 1 +预测 2(剩余 1) = 9 + 6 = 15

但是如果第二弱模型未能正确预测残差 1 的值，并且例如仅返回 4，那么第二弱学习器也将具有非零残差，计算如下:

剩余 2 =预测 1 —预测 2 = 6–3 = 3

这如图 12 所示。

Figure 12. Prediction of 3/6 with residual equal to 3.

为了修复第二个弱模型的弱点，将创建第三个弱模型。它的目标是预测第二个弱模型的残差。因此它的目标是 3。因此，我们样本的期望输出将等于所有弱模型的预测，如下所示:

期望=预测 1 +预测 2(剩余 1) +预测 3(剩余 2)

如果第三弱模型预测是 2，即它不能预测第二弱模型的残差，那么对于这样的第三模型将有一个残差等于如下:

剩余 3 =预测 2 —预测 3 = 3–2 = 1

这如图 13 所示。

Figure 13. Prediction of 2/3 with residual equal to 1.

结果，将创建第四弱模型来预测等于 1 的第三弱模型的残差。期望输出将等于所有弱模型的预测，如下所示:

期望=预测 1 +预测 2(剩余 1) +预测 3(剩余 2) +预测 4(剩余 3)

如果第四个弱模型正确地预测了它的目标(即残差 3)，那么使用总共四个弱模型已经达到了期望的输出 15，如图 14 所示。

Figure 14. Prediction of 1/1 with residual equal to 0.

这是梯度推进算法的核心思想。使用前一个模型的残差作为下一个模型的目标。

国标概述

总的来说，梯度推进从一个弱模型开始进行预测。这种模型的目标是问题的期望输出。训练好模型后，计算其残差。如果残差不等于零，则创建另一个弱模型来修复前一个模型的弱点。但是这种新模型的目标不是期望的输出，而是先前模型的残差。也就是说，如果给定样本的期望输出是 T，则第一模型的目标是 T。在对其进行训练之后，对于这样的样本，可能存在 R 的残差。要创建的新模型将把它的目标设置为 R，而不是 t。这是因为新模型填补了以前模型的空白。

梯度推进类似于由多个虚弱的人将一个重金属抬上几级楼梯。没有一个虚弱的人能把这块金属抬上所有的楼梯。每个人只能把它抬起一步。第一个弱的人会把金属抬一步，之后就累了。另一个虚弱的人将把金属再抬一步，以此类推，直到把金属抬上所有的楼梯。

原文可在 LinkedIn 本页面查看:https://www . LinkedIn . com/pulse/intuitive-ensemble-learning-guide-gradient-boosting-study-Ahmed-gad

联系作者:

领英:【https://linkedin.com/in/ahmedfgad

电子邮件:ahmed.f.gad@gmail.com

联结主义时间分类的直观解释

原文：https://towardsdatascience.com/intuitively-understanding-connectionist-temporal-classification-3797e43a86c?source=collection_archive---------0-----------------------

使用连接主义时间分类(CTC)丢失和解码操作的文本识别

如果你想让计算机识别文本，神经网络(NN)是一个很好的选择，因为它们目前优于所有其他方法。这种用例的神经网络通常由提取特征序列的卷积层(CNN) 和通过该序列传播信息的递归层(RNN) 组成。它输出每个序列元素的字符分数，简单地用一个矩阵表示。现在，我们想对这个矩阵做两件事:

1. 训练:计算损失值来训练神经网络
2. 推断:解码矩阵以获得输入图像中包含的文本

这两项任务都由 CTC 操作完成。图 1 示出了手写识别系统的概况。

让我们仔细看看 CTC 操作并讨论它是如何工作的，而不隐藏复杂公式背后基于的巧妙想法。最后，如果您感兴趣的话，我将向您介绍可以找到 Python 代码和(不太复杂的)公式的参考资料。

Fig. 1: Overview of a NN for handwriting recognition.

为什么我们要使用 CTC

当然，我们可以创建具有文本行图像的数据集，然后为图像的每个水平位置指定相应的字符，如图 2 所示。然后，我们可以训练一个神经网络来输出每个水平位置的字符分数。然而，这种天真的解决方案有两个问题:

1. 在字符级别上注释数据集是非常耗时的(也是令人厌烦的)。
2. 我们只得到字符分数，因此需要一些进一步的处理来从中获得最终的文本。单个字符可以跨越多个水平位置，例如，我们可以得到“ttooo ”,因为“o”是一个宽字符，如图 2 所示。我们必须删除所有重复的“t”和“o”。但是如果识别的文本是“too”呢？那么删除所有重复的“o”会得到错误的结果。这个怎么处理？

Fig. 2: Annotation for each horizontal position of the image.

CTC 为我们解决了这两个问题:

1. 我们只需要告诉 CTC 损失函数图像中出现的文本。因此，我们忽略图像中字符的位置和宽度。
2. 不需要对识别的文本进行进一步处理。

反恐委员会如何工作

正如已经讨论过的，我们不想在每个水平位置注释图像(从现在开始我们称之为时间步长)。NN 培训将由 CTC 损失职能部门指导。我们只将神经网络的输出矩阵和相应的地面实况(GT)文本馈送给 CTC 损失函数。但是它如何知道每个字符出现在哪里呢？它不知道。相反，它会尝试图像中 GT 文本的所有可能对齐方式，并计算所有得分的总和。这样，如果比对分数的总和具有高值，则 GT 文本的分数高。

对文本编码

还有如何对重复字符进行编码的问题(还记得我们说过的“too”这个词吗？).它是通过引入伪字符(称为空白，但不要与“真正的”空白(即空白字符)混淆)来解决的。在下文中，这个特殊字符将被表示为“-”。我们使用一个聪明的编码模式来解决重复字符问题:在对文本进行编码时，我们可以在任何位置插入任意多个空格，在解码时这些空格将被删除。但是，我们必须在重复的字符之间插入一个空格，就像在“he ll o”中一样。此外，我们可以随心所欲地重复每个字符。

让我们看一些例子:

• " to" → " - ttttttooo “，或”-t-o-“，或” to "
• “太"→ " - ttttto-o “，或者”-t-o-o-”，或者" to-o “，但是不是"太”

正如您所看到的，这个模式还允许我们轻松地创建相同文本的不同对齐方式，例如“t-o”和“too”以及“-to”都表示相同的文本(“to”)，但是对图像有不同的对齐方式。训练神经网络以输出编码文本(在神经网络输出矩阵中编码)。

损失计算

我们需要计算训练样本(成对的图像和 GT 文本)的损失值来训练神经网络。你已经知道，神经网络输出一个矩阵，其中包含每个字符在每个时间步的分数。图 3 示出了一个极简矩阵:有两个时间步长(t0，t1)和三个字符(“a”、“b”和空白“-”)。对于每个时间步长，字符得分总计为 1。

Fig. 3: Output matrix of NN. The character-probability is color-coded and is also printed next to each matrix entry. Thin lines are paths representing the text “a”, while the thick dashed line is the only path representing the text “”.

此外，您已经知道，损失是通过对 GT 文本的所有可能对齐的所有分数求和来计算的，这样，文本出现在图像中的什么位置并不重要。

一次比对(或文献中通常称之为路径)的分数通过将相应的字符分数相乘来计算。在上面显示的示例中，路径“aa”的得分是 0.4±0.4 = 0.16，而“a-”的得分是 0.4±0.6 = 0.24，而“-a”的得分是 0.6±0.4 = 0.24。为了得到给定 GT 文本的分数，我们对与该文本对应的所有路径的分数求和。让我们假设例子中的 GT 文本是“a”:我们必须计算长度为 2 的所有可能路径(因为矩阵有 2 个时间步长)，它们是:“aa”，“a-”和“-a”。我们已经计算了这些路径的分数，所以我们只需对它们求和，得到 0.4 0.4+0.4 0.6+0.6 0.4=0.64。如果假设 GT 文本为“”，我们看到对应的路径只有一条，即“-”，得出的综合得分为 0.6 0.6=0.36。

我们现在能够计算训练样本的 GT 文本的概率，给定由 NN 产生的输出矩阵。目标是训练 NN，使其输出正确分类的高概率(理想值为 1)。因此，我们最大化训练数据集的正确分类概率的乘积。出于技术原因，我们重新表述为一个等价的问题:最小化训练数据集的损失，其中损失是对数概率的负和。如果您需要单个样本的损失值，只需计算概率，取对数，并在结果前面加一个减号。为了训练 NN，损失相对于 NN 参数(例如卷积核的权重)的梯度被计算并用于更新参数。

解码

当我们有一个训练好的神经网络时，我们通常想用它来识别以前看不见的图像中的文本。或者用更专业的术语来说:我们希望在给定神经网络输出矩阵的情况下计算最可能的文本。你已经知道了一种计算给定文本分数的方法。但这一次，我们没有得到任何文本，事实上，它正是我们要寻找的文本。如果只有很少的时间步长和字符，尝试每一个可能的文本都是可行的，但是对于实际的用例，这是不可行的。

一个简单且非常快速的算法是由两个步骤组成的最佳路径解码:

1. 它通过每个时间步取最可能的字符来计算最佳路径。
2. 它通过首先删除重复字符，然后删除路径中的所有空格来撤消编码。剩下的代表已识别的文本。

图 4 中示出了一个例子。字符为“a”、“b”和“-”(空白)。有 5 个时间步长。让我们将最佳路径解码器应用于这个矩阵:t0 最可能的字符是“a”，这同样适用于 t1 和 t2。空白字符在 t3 时得分最高。最后，“b”最有可能在 t4。这给了我们路径“aaa-b”。我们删除重复的字符，得到“a-b ”,然后我们从剩余的路径中删除任何空白，得到文本“ab ”,我们将它作为识别的文本输出。

Fig. 4: Output matrix of NN. The thick dashed line represents the best path.

当然，最佳路径解码只是一种近似。很容易构造出给出错误结果的例子:如果你解码图 3 中的矩阵，你会得到""作为识别的文本。但是我们已经知道，“”的概率只有 0.36，而“a”的概率是 0.64。然而，近似算法在实际情况下经常给出好的结果。还有更高级的解码器，如波束搜索解码、前缀搜索解码或令牌传递，它们也使用关于语言结构的信息来改善结果。

结论和进一步阅读

首先，我们看了一个简单的神经网络解决方案所产生的问题。然后，我们看到反恐委员会如何能够解决这些问题。然后，我们通过查看 CTC 如何编码文本、如何进行损失计算以及如何解码经过 CTC 训练的神经网络的输出，来研究 CTC 是如何工作的。

例如，当您在 TensorFlow 中调用 ctc_loss 或 ctc_greedy_decoder 之类的函数时，这会让您很好地理解幕后发生的事情。但是，当你想自己实现 CTC 的时候，你需要知道更多的一些细节，尤其是要让它快速运行。Graves 等人[1]介绍了 CTC 操作，文中还展示了所有相关的数学。如果你对如何提高解码感兴趣，可以看看关于波束搜索解码的文章[2][3]。我用 Python 和 C++实现了一些解码器和 loss 函数，你可以在 github [4][5]上找到。最后，如果你想更全面地了解如何识别(手写)文本，可以看看我写的关于如何构建手写文本识别系统的文章[6]。

[1] 原纸包含所有数学
【2】香草束搜索解码
【3】字束搜索解码
【4】Python 实现的解码器
【5】实现的字束搜索解码
【6】文本识别系统

最后，概述一下我的其他媒体文章。

直观理解用于深度学习的卷积

原文：https://towardsdatascience.com/intuitively-understanding-convolutions-for-deep-learning-1f6f42faee1?source=collection_archive---------0-----------------------

探索让它们工作的强大的视觉层次

近年来，强大而通用的深度学习框架的出现，使得在深度学习模型中实现卷积层成为可能这是一项极其简单的任务，通常只需一行代码即可实现。

然而，理解卷积，尤其是第一次理解时，常常会感到有点紧张，因为像内核、过滤器、通道等术语都是相互叠加的。然而，卷积作为一个概念是非常强大和高度可扩展的，在这篇文章中，我们将一步一步地分解卷积运算的机制，将其与标准的全连接网络相关联，并探索它们如何建立强大的视觉层次，使它们成为图像的强大特征提取器。

2D 卷积:手术

2D 卷积本质上是一个相当简单的操作:你从一个核开始，它只是一个小的权重矩阵。这个内核在 2D 输入数据上“滑动”,对它当前所在的输入部分执行元素级乘法，然后将结果相加到单个输出像素中。

A standard convolution[1]

内核对它滑过的每个位置重复这个过程，将 2D 特征矩阵转换成另一个 2D 特征矩阵。输出要素实质上是输入要素的加权和(权重为核本身的值),这些输入要素大致位于输入图层上输出像素的相同位置。

一个输入特性是否属于这个“大致相同的位置”，直接取决于它是否在生成输出的内核区域。这意味着核的大小直接决定了在生成新的输出要素时有多少(或几个)输入要素被组合在一起。

这与完全连接的层形成了鲜明的对比。在上例中，我们有 5×5=25 个输入要素，3×3=9 个输出要素。如果这是一个标准的全连接图层，您将拥有一个 25×9 = 225 个参数的权重矩阵，其中每个输出要素都是每个单个输入要素的的加权和。卷积允许我们只使用 9 个参数对每个输出特征进行这种变换，而不是“查看”每个输入特征，只“查看”来自大致相同位置的输入特征。请务必记下这一点，因为这对我们以后的讨论至关重要。

一些常用的技术

在我们继续之前，绝对有必要了解卷积层中常见的两种技术:填充和步长。

• 填充:如果您看到上面的动画，请注意在滑动过程中，边缘基本上被“修剪掉”，将 5×5 的特征矩阵转换为 3×3 的特征矩阵。边缘上的像素永远不会在内核的中心，因为内核没有任何东西可以延伸到边缘之外。这并不理想，因为我们经常希望输出的大小等于输入。

Same padding[1]

填充做了一些非常聪明的事情来解决这个问题:用额外的“假”像素填充边缘(通常值为 0，因此经常使用术语“零填充”)。这样，滑动时的内核可以允许原始边缘像素位于其中心，同时扩展到边缘以外的伪像素中，产生与输入大小相同的输出。

• 跨越:通常在运行卷积层时，您希望输出比输入小。这在卷积神经网络中是常见的，其中当增加通道数量时，空间维度的大小减小。实现这一点的一种方法是使用池层(例如，取每个 2×2 网格的平均值/最大值，以将每个空间维度减半)。还有一种方法是使用步幅:

A stride 2 convolution[1]

stride 的想法是跳过内核的一些滑动位置。步长为 1 表示以一个像素为间隔选取幻灯片，因此基本上每一张幻灯片都充当标准卷积。步幅为 2 意味着选取相隔 2 个像素的幻灯片，在此过程中每隔一张幻灯片跳过一次，尺寸缩小大约 2 倍，步幅为 3 意味着每隔 2 张幻灯片跳过一次，尺寸缩小大约 3 倍，以此类推。

更现代的网络，如 ResNet 体系结构，完全放弃了其内部层中的池层，而在需要减少其输出大小时，支持步长卷积。

多通道版本

当然，上面的图表只处理图像只有一个输入通道的情况。实际上，大多数输入图像有 3 个通道，这个数字只会随着你进入网络的深度而增加。一般来说，我们很容易把通道看作是图像整体的“视图”,强调某些方面，弱化其他方面。

Most of the time, we deal with RGB images with three channels. (Credit: Andre Mouton)

A filter: A collection of kernels

这就是术语之间的关键区别:然而在单通道情况下，术语滤波器和内核是可互换的，在一般情况下，它们实际上是非常不同的。每个滤波器实际上都是内核、、的集合，对于该层的每个输入通道都有一个内核，并且每个内核都是唯一的。

卷积层中的每个滤波器产生一个且仅一个输出通道，它们的工作方式如下:

滤波器的每个内核在它们各自的输入通道上“滑动”,产生每个内核的处理版本。一些内核可能比其他内核具有更强的权重，以给予某些输入通道比其他通道更多的强调(例如，滤波器可能具有比其他通道具有更强权重的红色内核通道，因此，比其他通道对红色通道特征的差异响应更多)。

每个每通道处理的版本然后被加在一起以形成一个通道。滤波器的每个内核产生每个声道的一个版本，并且滤波器作为一个整体产生一个总输出声道。

最后，还有偏差项。偏置项的工作原理是，每个输出滤波器都有一个偏置项。到目前为止，偏置被添加到输出通道，以产生最终输出通道。

单个滤波器的情况下，任何数量的滤波器的情况都是相同的:每个滤波器使用其自己的不同核集合和标量偏差来处理输入，产生单个输出通道。然后将它们连接在一起，产生总输出，输出通道的数量等于滤波器的数量。然后，通常在将其作为输入传递到另一个卷积层之前应用非线性，然后该卷积层重复该过程。

2D 卷积:直觉

卷积仍然是线性变换

即使放下卷积层的机制，仍然很难将它与标准的前馈网络联系起来，并且它仍然没有解释为什么卷积可以扩展到图像数据，并且对图像数据的处理更好。

假设我们有一个 4×4 的输入，我们想把它转换成 2×2 的网格。如果我们使用前馈网络，我们会将 4×4 输入整形为长度为 16 的向量，并将其通过具有 16 个输入和 4 个输出的密集连接层。人们可以想象一个层的权重矩阵 W :

All in all, some 64 parameters

而且虽然卷积核运算乍一看可能有点奇怪，但它仍然是一个线性变换，有一个等价的变换矩阵。如果我们要对整形后的 4×4 输入使用大小为 3 的核 K 来获得 2×2 输出，则等效变换矩阵将是:

There’s really just 9 parameters here.

(注意:虽然上面的矩阵是一个等价的变换矩阵，但是实际的操作通常被实现为一个非常不同的矩阵乘法[2] )

卷积总体上仍然是线性变换，但同时也是一种截然不同的变换。对于一个有 64 个元素的矩阵，只有 9 个参数可以重复使用几次。每个输出节点只能看到选定数量的输入(内核内部的输入)。没有与任何其他输入的交互，因为它们的权重被设置为 0。

将卷积运算视为权重矩阵上的硬先验是很有用的。在这种情况下，我所说的先验是指预定义的网络参数。例如，当您使用预训练模型进行图像分类时，您使用预训练网络参数作为您的先验，作为您最终密集连接层的特征提取器。

从这个意义上说，两者为何如此高效(与它们的替代品相比)有着直接的直觉。与随机初始化相比，迁移学习的效率提高了几个数量级，因为您只需要优化最终全连接层的参数，这意味着您可以在每个类只有几十个图像的情况下获得出色的性能。

在这里，您不需要优化所有 64 个参数，因为我们将它们中的大多数设置为零(并且它们将保持这种状态)，其余的我们转换为共享参数，结果只有 9 个实际参数需要优化。这种效率很重要，因为当你从 MNIST 的 784 个输入转到现实世界的 224×224×3 图像时，那就超过了 15 万个输入。试图将输入减半为 75，000 个输入的密集层仍然需要超过 10 亿个参数。相比之下，ResNet-50 的整体有大约 2500 万个参数。

因此，将一些参数固定为 0，并绑定参数可以提高效率，但与迁移学习的情况不同，在迁移学习的情况下，我们知道先验是好的，因为它对一组大型图像有效，我们如何知道这个是好的呢？

答案在于先验引导参数学习的特征组合。

位置

在本文前面，我们讨论了:

• 内核仅组合来自小的局部区域的像素来形成输出。也就是说，输出要素仅“看到”小范围局部区域的输入要素。
• 核被全局地应用于整个图像以产生输出矩阵。

因此，随着反向传播从网络的分类节点一路传来，核有了学习权重的有趣任务，以便仅从一组局部输入中产生特征。此外，因为内核本身应用于整个图像，所以内核学习的特征必须足够通用，以来自图像的任何部分。

如果这是任何其他类型的数据，例如应用程序安装的分类数据，这将是一场灾难，因为仅仅因为你的应用程序安装数量和应用程序类型列相邻，并不意味着它们与应用程序安装日期和使用时间有任何共同的“本地共享功能”。当然，这四个可能有一个潜在的更高层次的特征(例如，人们最想要的应用程序)，但这让我们没有理由相信前两个的参数与后两个的参数完全相同。这四个可以有任何(一致的)顺序，仍然有效！

然而，像素总是以一致的顺序出现，并且附近的像素会影响一个像素，例如，如果所有附近的像素都是红色的，则该像素很可能也是红色的。如果存在偏差，这是一个有趣的异常，可以转换为一个特征，所有这些都可以通过将一个像素与其邻居以及其位置上的其他像素进行比较来检测。

这种想法正是许多早期计算机视觉特征提取方法的基础。例如，对于边缘检测，可以使用 Sobel 边缘检测滤波器，这是一种具有固定参数的内核，操作方式与标准单通道卷积类似:

Applying a vertical edge detector kernel

对于不包含边缘的网格(如背景天空)，大多数像素都是相同的值，因此在该点内核的总输出为 0。对于具有垂直边缘的网格，边缘左侧和右侧的像素之间存在差异，内核将该差异计算为非零，从而激活和显示边缘。内核一次只能运行 3×3 个网格，检测局部范围内的异常，但当应用于整个图像时，足以检测全局范围内图像中任何位置的某个特征！

所以我们与深度学习的关键区别是问这个问题:有用的内核能被学习吗？对于在原始像素上操作的早期层，我们可以合理地期待相当低级别特征的特征检测器，如边缘、线等。

深度学习研究有一个完整的分支，专注于使神经网络模型可以解释。由此产生的最强大的工具之一是使用优化[3] 的特征可视化。核心思想很简单:优化图像(通常用随机噪声初始化)以尽可能强地激活滤镜。这确实有直观的意义:如果优化的图像完全充满了边缘，这就是过滤器本身正在寻找并被激活的有力证据。使用这个，我们可以看到学习过的过滤器，结果是惊人的:

Feature visualization for 3 different channels from the 1st convolution layer of GoogLeNet[3]. Notice that while they detect different types of edges, they’re still low-level edge detectors.

Feature Visualization of channel 12 from the 2nd and 3rd convolutions[3]

这里需要注意的一点是*卷积图像是静止图像。*来自图像左上角的小像素网格的输出仍然在左上角。因此，您可以在另一个卷积层(如左边的两个)上运行另一个卷积层，以提取更深层次的特征，我们将这些特征可视化。

然而，无论我们的特征检测器有多深，如果没有任何进一步的改变，它们仍将在图像的非常小的区域上操作。无论你的探测器有多深，你都无法从一个 3×3 的网格中探测到人脸。这就是感受野概念的由来。

感受野

任何 CNN 架构的一个基本设计选择是，从网络的开始到结束，输入大小越来越小，而通道的数量越来越多。如前所述，这通常是通过跨越或合并层来实现的。局部性决定了输出可以看到前一层的哪些输入。感受野决定了整个网络的原始输入的哪个区域是输出可以看到的。

步长卷积的思想是我们只处理相隔固定距离的幻灯片，跳过中间的幻灯片。从不同的角度来看，我们只保持输出相隔固定的距离，并删除其余的[1]。

3×3 convolution, stride 2

然后，我们对输出进行非线性处理，通常，在顶部叠加另一个新的卷积层。这就是事情变得有趣的地方。即使我们将具有相同局部面积的相同大小(3×3)的核应用于步长卷积的输出，该核也将具有更大的有效感受野:

这是因为条纹层的输出仍然表示相同的图像。与其说是裁剪，不如说是调整大小，唯一的问题是输出中的每个像素都是来自原始输入的相同粗略位置的更大区域(其其他像素已被丢弃)的“代表”。因此，当下一层的内核对输出进行操作时，它对从更大区域收集的像素进行操作。

(注意:如果你熟悉扩张回旋，请注意以上是而不是扩张回旋。两者都是增加感受野的方法，但是扩张卷积是单层的，而这发生在步长卷积之后的规则卷积上，其间有非线性)

Feature visualization of channels from each of the major collections of convolution blocks, showing a progressive increase in complexity[3]

感受野的这种扩展允许卷积层将低级特征(线、边缘)组合成高级特征(曲线、纹理)，正如我们在 mixed3a 层中看到的。

接着是池化/跨步层，网络继续为更高层次的特征(零件、模式)创建检测器，正如我们在 mixed4a 中看到的。

与 224×224 的输入相比，网络上图像大小的反复减小导致卷积上的第 5 个块的输入大小仅为 7×7。此时，每个单个像素代表一个 32×32 像素的网格，规模巨大。

与早期的激活意味着检测边缘的图层相比，在这里，在微小的 7×7 网格上的激活是用于非常高级别的特征，例如鸟类。

网络作为一个整体从检测低级特征的少量过滤器(在 GoogLeNet 的情况下为 64 个)发展到非常大量的过滤器(在最后的卷积中为 1024 个)，每个过滤器寻找一个非常具体的高级特征。接下来是最终的合并层，它将每个 7×7 的网格折叠成一个像素，每个通道都是一个特征检测器，其感受域相当于整个图像。

与标准前馈网络相比，这里的输出确实令人惊叹。标准的前馈网络会从图像中每一个像素的组合中产生抽象的特征向量，需要大量的数据来训练。

具有强加于其上的先验的 CNN，通过学习非常低级的特征检测器开始，并且随着其感受域的扩展而跨层，学习将那些低级特征组合成逐渐更高级的特征；不是每一个像素的抽象组合，而是概念的强烈的视觉层次。

通过检测低级别特征，并使用它们来检测更高级别的特征，随着它在视觉层次上的进步，它最终能够检测整个视觉概念，如脸、鸟、树等，这就是为什么它们如此强大，但对图像数据有效。

关于对抗性攻击的最后一点说明

根据 CNN 建立的视觉层级，假设他们的视觉系统与人类相似是相当合理的。它们对真实世界的图像非常好，但它们也失败了，这强烈表明它们的视觉系统不完全像人类。最主要的问题:对抗性例子【4】，经过专门修改来忽悠模型的例子。

To a human, both images are obviously pandas. To the model, not so much.[4]

如果导致模型失败的唯一被篡改的例子是那些甚至人类都会注意到的例子，那么对立的例子就不是问题。问题是，模型很容易受到样本的攻击，这些样本只是被稍微篡改了一下，显然骗不了任何人。这为模型悄无声息地失败打开了大门，这对从无人驾驶汽车到医疗保健的广泛应用来说是非常危险的。

对抗敌对攻击的鲁棒性目前是一个非常活跃的研究领域，是许多论文甚至竞赛的主题，解决方案肯定会改进 CNN 架构，使其变得更安全、更可靠。

结论

CNN 是允许计算机视觉从简单应用扩展到复杂产品和服务的模型，从照片库中的人脸检测到更好的医疗诊断。它们可能是计算机视觉向前发展的关键方法，或者其他一些新的突破可能就在眼前。不管怎样，有一件事是肯定的:它们是惊人的，是当今许多创新应用的核心，并且非常值得深入了解。

参考

1. 深度学习卷积算法指南
2. 用于视觉识别的 CS231n 卷积神经网络—卷积神经网络
3. 特征可视化——神经网络如何建立对图像的理解(注意:这里的特征可视化是由 Lucid 库产生的，这是这篇期刊文章中技术的开源实现)
4. 用对立的例子攻击机器学习

更多资源

1. fast . ai——第三课:改进你的图像分类器
2. Conv 篮网:模块化视角
3. 使用非常少的数据构建强大的图像分类模型

希望你喜欢这篇文章！如果你想保持联系，你可以在 Twitter 这里 找到我。如有疑问，欢迎评论！—我发现它们对我自己的学习过程也很有用。

直观理解变型自动编码器

原文：https://towardsdatascience.com/intuitively-understanding-variational-autoencoders-1bfe67eb5daf?source=collection_archive---------0-----------------------

A Standard Variational Autoencoder

以及为什么它们在创造你自己的文本、艺术甚至音乐时如此有用

与神经网络作为回归器或分类器的更标准用途相反，变分自动编码器(VAEs)是强大的生成模型，现在具有从生成假人脸到制作纯合成音乐的各种应用。

这篇文章将探讨什么是 VAE，为什么它如此有效背后的直觉，以及它作为各种媒体的强大生成工具的用途。

但首先，为什么是维斯？

Exploring a specific variation of input data[1]

当使用创成式模型时，您可以简单地生成一个随机的、新的输出，它看起来类似于训练数据，并且您当然也可以使用 VAEs 来实现这一点。但是更多的时候，你想要改变，或者探索你已经拥有的的数据的变化，而且不仅仅是以随机的方式，而是以期望的、特定的方向。这就是 VAEs 比目前可用的任何其他方法更好的地方。

解码标准自动编码器

自动编码器网络实际上是一对两个相连的网络，一个编码器和一个解码器。编码器网络接收输入，并将其转换为更小、更密集的表示形式，解码器网络可以使用该表示形式将其转换回原始输入。

如果你不熟悉编码器网络，但熟悉卷积神经网络(CNN)，那么你可能已经知道编码器是做什么的了。

The encoder inside of a CNN[a]

任何 CNN 的卷积层接收大图像(例如大小为 299x299x3 的秩 3 张量)，并将其转换为更紧凑、更密集的表示(例如大小为 1000 的秩 1 张量)。然后，全连接分类器网络使用这种密集表示对图像进行分类。

编码器与此类似，它只是一个网络，接收输入并产生一个更小的表示(编码)(T7)，其中包含足够的信息供网络的下一部分将其处理成所需的输出格式。典型地，编码器与网络的其他部分一起被训练，通过反向传播被优化，以产生对于手边的任务特别有用的编码。在 CNN 中，产生的 1000 维编码对分类特别有用。

自动编码器采纳了这一想法，并通过让编码器生成对重建自己的输入特别有用的编码，稍微颠倒了一下。

A standard Autoencoder

整个网络通常作为一个整体来训练。损失函数通常是输出和输入之间的均方误差或交叉熵，称为重构损失，其惩罚网络产生不同于输入的输出。

由于编码(只是中间隐藏层的输出)的单元远少于输入，编码器必须选择丢弃信息。编码器学习在有限的编码中尽可能多地保留相关信息，并智能地丢弃不相关的部分。解码器学习采用编码并正确地将其重构为完整的图像。它们共同构成了一个自动编码器。

标准自动编码器的问题是

标准的自动编码器学会生成紧凑的表示并很好地重建它们的输入，但是除了像去噪自动编码器这样的一些应用之外，它们相当有限。

对于生成来说，自动编码器的基本问题是它们将输入转换到的潜在空间以及它们的编码向量所在的位置可能不连续，或者不允许简单的插值。

Optimizing purely for reconstruction loss

例如，在 MNIST 数据集上训练自动编码器，并可视化来自 2D 潜在空间的编码，揭示了不同簇的形成。这是有意义的，因为每种图像类型的不同编码使解码器更容易解码它们。如果你只是复制相同的图像，这没问题。

但是当你在建立一个生成型模型的时候，你不想准备复制你放进去的同一个形象。您希望从潜在空间中随机取样，或者从连续的潜在空间中生成输入图像的变化。

如果空间具有不连续性(例如，簇之间的间隙),并且您从那里采样/生成变化，解码器将简单地生成不切实际的输出，因为解码器不知道如何处理潜在空间的该区域。在训练期间，它从未看到来自潜在空间区域的编码向量。

可变自动编码器

变分自动编码器(vae)有一个从根本上区别于普通自动编码器的独特属性，正是这个属性使它们对生成式建模如此有用:它们的潜在空间通过设计*、*是连续的，允许简单的随机采样和插值。

它通过做一些乍一看似乎相当令人惊讶的事情来实现这一点:让它的编码器不输出大小为 n、的编码向量，而是输出大小为 n 的两个向量:一个均值向量、μ** 和另一个标准差向量**、σ** 。

Variational Autoencoder

它们形成长度为 n 的随机变量向量的参数，其中第 i 个元素为 μ 和 σ 是第 i 个随机变量的平均值和标准偏差， X i，我们从中进行采样，以获得采样编码，并将其向前传递给解码器:

Stochastically generating encoding vectors

这种随机生成意味着，即使对于相同的输入，虽然平均值和标准偏差保持不变，但实际的编码在每次通过时都会有所不同，这仅仅是因为采样。

直观地说，均值向量控制着输入的编码应该集中在哪里，而标准差控制着“区域”，即编码可以偏离均值多少。由于编码是从“圆”(分布)内的任何地方随机生成的，解码器了解到不仅潜在空间中的单个点引用该类的样本，所有附近的点也引用相同的样本。这允许解码器不仅解码潜在空间中的单个特定编码(使可解码潜在空间不连续)，而且还解码稍微变化的编码，因为解码器在训练期间暴露于相同输入的编码的变化范围。在代码中:

code for sampling mean and stddev

现在，通过改变一个样本的编码，该模型暴露于一定程度的局部变化，从而在局部尺度上，即对于相似的样本，产生平滑的潜在空间。理想情况下，我们希望不太相似的样本之间有重叠，以便在类之间插入*。然而，由于对于向量μ和 σ 可以取什么值没有限制 ，编码器可以学习为不同的类生成非常不同的 μ ，将它们分簇，并最小化 σ ，确保编码本身对于同一样本不会有太大变化(也就是说，解码器的不确定性更小)。这允许解码器有效地重构训练数据。*****

我们理想中想要的是编码，所有的尽可能地彼此接近，同时仍然是不同的，允许平滑的插值，并且能够构造新的样本。

为了迫使这一点，我们将 kull back-lei bler 散度(KL 散度【2】)引入损失函数。两个概率分布之间的 KL 偏离简单地测量了它们彼此偏离的程度。这里最小化 KL 散度意味着优化概率分布参数 (μ 和 σ) 以非常类似于目标分布。

对于 VAEs，KL 损失相当于 X 中的分量XI~N(μI，σ i )与标准常态【3】之间所有 KL 偏差的之和。当μ i = 0，σ i = 1 时最小。

直观上，这种损失促使编码器将所有编码(对于所有类型的输入，例如所有 MNIST 数)均匀地分布在潜在空间的中心周围。如果它试图通过将它们聚集到远离原点的特定区域来“作弊”，它将受到惩罚。

现在，使用纯 KL 损失导致潜在空间，导致编码密集地随机放置在潜在空间的中心附近，很少考虑附近编码之间的相似性。解码器发现不可能从这个空间中解码出任何有意义的东西，原因很简单，因为这里真的没有任何意义。

Optimizing using pure KL divergence loss

*然而，一起优化这两者导致潜在空间的生成，该潜在空间通过聚类在局部尺度上保持附近编码的相似性，然而在*全局上，在潜在空间原点附近非常密集地打包(将轴与原始轴进行比较)。

Optimizing using both reconstruction loss and KL divergence loss

直观上，这是重建损失的群集形成性质和 KL 损失的密集打包性质达到的平衡，形成解码器可以解码的不同群集。这很棒，因为这意味着当随机生成时，如果你从编码向量的相同先验分布中采样一个向量， N ( 0 ， I )，解码器将成功解码它。如果你在插值，簇之间没有突然的间隙，而是解码器可以理解的特征的平滑混合。

The final loss function

向量运算

那么我们实际上是如何产生我们所说的平滑插值的呢？从这里开始，它是潜在空间中简单的向量运算。

Interpolating between samples

例如，如果您希望在两个样本之间的中途生成一个新样本，只需找到它们的均值( μ )向量之间的差，并将该差的一半加到原始样本上，然后简单解码即可。

Adding new features to samples

生成特定特征怎么样，比如在一张脸上生成眼镜？找到两个样本，一个带眼镜，一个不带，从编码器获得它们的编码向量，并保存差异。将这个新的“眼镜”向量添加到任何其他人脸图像中，并对其进行解码。

从这里去哪里？

在变分自动编码器的基础上还可以做很多进一步的改进。事实上，你可以用卷积反卷积编码器-解码器对来取代标准的全连接密集编码器-解码器，比如这个项目【4】，来制作出色的合成人脸照片。

Generating celebrity-lookalike photos

您甚至可以使用 LSTM 编码器-解码器对(使用 seq2seq 架构的修改版本)来训练自动编码器处理顺序的、离散的数据(使用 GANs 等方法是不可能的)，以产生合成文本，甚至在 MIDI 样本之间进行插值，如 Google Brain 的 Magenta 的 music vae【5】:

vae 可以处理各种不同类型的数据，顺序的或非顺序的，连续的或离散的，甚至有标签的或完全无标签的，这使它们成为非常强大的生成工具。我希望你现在理解了 VAEs 是如何工作的，并且你也能够在你自己的生产努力中使用它们。

如果你觉得这篇文章有用，并且相信其他人也会觉得有用，请留下你的掌声！如果你想保持联系，你可以在 Twitter 这里 找到我。

注意事项

[1] 潜在约束:无条件生成模型的条件生成

[2] 库尔贝克-莱布勒分歧解释

[3] 两个单变量高斯函数之间的 KL 散度

【4】深度特征一致变分自动编码器

[5] 分级变分音乐自动编码器

延伸阅读:

• 变型自动编码器
• 教程—什么是变分自动编码器？
• 变型自动编码器教程

实施:

• 在 Keras 中构建自动编码器
• Keras 中的卷积反卷积自动编码器

利用机器学习监测入侵物种

原文：https://towardsdatascience.com/invasive-species-monitoring-using-machine-learning-9a7b29d565f?source=collection_archive---------4-----------------------

Invasive Species Monitoring using Machine Learning

最近，Kaggle 推出了一项竞赛，ka ggle 人面临的挑战是开发算法，以更准确地识别森林和树叶的图像是否包含入侵的绣球花。因此，简而言之，我们可以看着一幅图像，判断它是否有入侵性绣球(class = 0)或没有入侵性绣球(class = 1)。这告诉我们，这是一个分类问题，因为我们的输入是图像，这将是一个计算机视觉问题。

在这里，我将解释我们使用机器学习来解决这个问题的分步步骤。

影像探索

我们有自己的数据集，我们想做的第一件事是看看我们的图像看起来怎么样。为什么要看图像？因为它将帮助我们识别数据集中各种图像的特征、维数，找出图像是否有眩光以及需要采取什么步骤进行预处理。

在查看图像后，我们发现，如果一个人看到来自数据集的图像，并询问绣球花的存在，他将主要根据花和叶子的类型和颜色做出决定。另一件事，我们发现我们的数据集包含较小尺寸的矩形图像。我们的数据集包含 1400 个入侵物种和 867 个非入侵类的图像。

根据以上观察，我们得出以下结论:

1. 我们的数据集很小而且不平衡(3:2)。(当数据集中存在的类不具有相同数量的样本时，该数据集称为不平衡的。)
2. 我们的图像是矩形的；因此，如果我们决定使用卷积神经网络(我们计划使用 CNN)，我们可能需要制作正方形格式的图像。
3. 图像尺寸很小，因此很难识别特征。
4. 数据集中的一些图像对比度较低。

预处理数据集

对比拉伸

由于我们的图像对比度越来越低，我们需要找到一种方法来增强图像的对比度。这对我们来说很重要，因为对比度有助于区分图像的不同特征，而这些特征在低对比度图像中可能无法表现出来。为了实现这一点，我们应用了一种简单的图像增强技术，称为对比度拉伸，顾名思义，它试图通过*“拉伸”*图像包含的亮度值范围来跨越所需的值范围，从而提高图像的对比度。

Contrast Stretching

数据扩充

我们用于训练模型的样本数量较少，由于缺乏训练数据，我们的模型可能无法为测试集提供良好的预测。为了解决这个问题，我们将使用数据扩充，这基本上意味着从现有的训练数据集人工生成数据。数据扩充中的一种流行技术是变换(这包括移位、缩放、旋转、翻转等。).我们将应用垂直翻转从训练集中生成更多样本，这将有助于加强模型。

Data Augmentation using Vertical Flip

填料

我们的图像尺寸很小，如果我们提供它来训练我们的模型，我们可能会失去一些功能。为了解决这个问题，我们需要调整图像的大小。我们的图像是矩形尺寸，因此在图像顶部应用 resize 将导致图像拉伸或扭曲，这将为模型提供错误的特征。最好将图像转换为正方形格式，这可以通过对图像进行切片或在图像周围添加白色或黑色空间(填充)使其成为正方形来实现。切片将导致信息丢失，我们可能会失去一些重要的功能，因此我们将使用填充。

调整大小

正如我前面提到的，图像的尺寸很小，我们将使用线性插值来调整图像的大小。这将有助于网络识别尺寸较小但对分类很重要的特征，例如绣球花的存在。

模型生成

我们使用的是一个的 11 层 与 ReLU 的激活函数。

Convolution Neural Network

我喜欢 CNN 在这里的解释方式。
请点击在 AlexNet 上找到论文。

结果

我们生成的模型在测试数据集上提供了 95%的准确率。在 Github 上找到代码库。

参考文献

对于数据集，请转到 Kaggle 竞赛

与杰鲁巴尔·约翰·卢克和库纳尔·萨卡尔合作撰写。