TowardsDataScience 博客中文翻译 2020（五百五十一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

使用 PyTorch 的线性回归示例的梯度下降介绍

原文：https://towardsdatascience.com/introduction-to-gradient-descent-with-linear-regression-example-using-pytorch-dbf7a9540d78?source=collection_archive---------34-----------------------

机器/深度学习中广泛使用的优化方法。

杰里米·毕晓普在 Unsplash 上的照片

介绍

在机器学习中，通常情况下，我们需要找到一个损失函数(或成本函数)的最小值。梯度下降法是一种广泛应用的优化方法。

在这篇文章中，我将通过一些例子讨论梯度下降法，包括使用 PyTorch 的线性回归。

结石

求函数最大值或最小值的一种方法是求斜率为零的点。函数的最大值或最小值将是函数的导数等于零的解。

以这个函数为例:

f(x)= x * * 2–5x+5，图片由作者提供

该函数的导数为:

所以设 f’(x) = 0，我们可以求出 x=2 为解。这意味着函数的斜率在 x=2 时等于零，函数的最小值是 f(2)=1。

这种方法找到了解析解，然而，在实际应用中有时很难将这种方法应用于复杂函数。因此，我们需要数值方法来寻找近似解，梯度下降法就是其中一种方法。

梯度下降

梯度的数学解释可以在这个环节中找到。

对于一维函数 f(x)，梯度表示为 f’(x)。对于多维函数，表示如下。

来自 wiki :如果函数的梯度在 p 点不为零，那么梯度的方向就是函数从 p 开始增加最快的方向，梯度的大小就是那个方向的增加率。

梯度下降试图通过下降到梯度的相反方向来接近函数的最小值。

它迭代地更新参数(这里是 x)来寻找解。所以首先，我们需要一个解的初始猜测(x0)，然后基于初始猜测计算梯度，然后基于计算的梯度更新解(x)。可以用这个公式来解释:

t 是迭代次数，r 是学习率。

所以，首先，我们有一个初始猜测 x0，通过上面的等式，我们可以找到 x1:

然后通过 x1，我们可以找到 x2:

通过多次重复这一过程(历元)，我们应该能够找到参数(x ),其中函数在其最小值。

示例 1:

让我们以前面的函数为例:

并将其应用于梯度下降方程

重新排列:

让我们设定学习率= 0.1，初始猜测值 x0=7。然后，我们可以轻松地更新和计算 x1、x2、x3…以及 f(x1)、f(x2)、f(x3)…

在本例中:

可以看到参数(x)接近 2，函数接近最小值 1。

让我们把它放在图表上:

梯度下降(学习率= 0.1)(图片由作者提供)

如果我们用一个更小的学习率(0.01)呢？

梯度下降(学习率= 0.01)(图片由作者提供)

正如所料，达到最小值需要更多的迭代。

如果我们把学习提高到 0.3，它比 0.1 更快达到最小值。

梯度下降(学习率= 0.3)(图片由作者提供)

如果我们把它进一步提高到 0.7，它就开始超调了。

梯度下降(学习率= 0.7)(图片由作者提供)

如果我们把它增加到 1，它根本达不到最小值。

梯度下降(学习率= 1)(图片由作者提供)

所以学习率对梯度下降非常重要。如果太小，就需要大量的迭代，如果太大，就可能达不到最小值。

现在，我们对梯度下降如何工作有了一个概念，让我们尝试将其应用到一个简单的机器学习模型——线性回归。

示例 2 —线性回归:

线性回归示例

线性回归是一种寻找两个变量之间线性关系的方法。它找到一条线，

描述图中所示的数据点。m 是直线的斜率，c 是截距。任务是找到最符合数据点的直线(m 和 c)。

损失函数

我们使用均方误差(MSE)来度量线和数据点的误差。

它对点和线之间的差的平方和进行平均。

我们可以重新排列等式:

我们想找到 m 和 c，它们给出了 MSE 的最小值。

梯度下降

就像前面的例子，我们需要找到梯度。

然后我们可以用这个等式来更新 m 和 c:

同样，我们需要对 m 和 c 的初始猜测，让我们从 m=0 和 c=0 开始，学习率= 0.0001

#Gradient Descentfor i in range(epochs):
   Y_pred = m*X + c
   d_m = (-2/n) * sum(X * (Y - Y_pred))
   d_c = (-2/n) * sum(Y - Y_pred)
   # Update m
   m = m - r * d_m
   # Update c
   c = c - r * d_c
   mse=(1/n) * sum((Y - m*X + c)**2)

可以基于梯度更新 m 和 c。让我们把它放在图表上。

梯度下降-线性回归例子，学习率= 0.0001。(图片由作者提供)

同样，仔细选择学习率是重要的，如果学习率增加到 0.01，计算将不会收敛。

梯度下降-找不到最佳 m 和 c，学习率= 0.01。(图片由作者提供)

在这个简单的例子中，我们自己通过对函数的求导来计算梯度，这对于更复杂的问题可能会变得困难。幸运的是，PyTorch 提供了一个工具来自动计算几乎任何函数的导数。

Pytorch 方法

让我们定义这条线:

**def** f(x, params):
    m, c= params
    **return** m*x + c

损失函数——均方误差:

**def** mse(preds, targets): **return** ((preds-targets)**2).mean()

再次，我们由 m=0 开始，c=0，这里的 需要 grad() ，这里是用来计算梯度的。

params = torch.zeros(2).requires_grad_()

然后我们可以根据第一个参数预测 y 值，并画出来。

preds = f(X_t, params)

Pytorch 梯度下降-初步猜测。(图片由作者提供)

然后我们可以计算损失:

loss = mse(preds, Y_t)

以及 PyTorch 函数的梯度:

loss.backward()

之后，我们可以检查梯度:

params.grad

它返回一个张量，即梯度:张量([433.6485，18.2594])

然后，我们使用梯度和学习率更新参数:

lr = 1e-4
params.data -= lr * params.grad.data
params.grad = **None**

并使用这些新参数预测 y:

Pytorch 梯度下降—第二纪元(图片由作者提供)

我们需要多次重复这个过程，让我们制作一个函数:

**def** apply_step(params):
  preds = f(X_t, params)
  loss = mse(preds, Y_t)
  loss.backward()
  params.data -= lr * params.grad.data
  params.grad = None
  return pred

然后我们可以跑几个纪元。看起来随着时间的推移，损失在减少。

把它放在图表上

Pytorch 的梯度下降(图片由作者提供)

就是这个！通过使用 PyTorch，我们可以轻松地计算梯度，并为机器和深度学习模型执行梯度下降。

感谢阅读。

图算法简介:Python 中的广度优先搜索算法

原文：https://towardsdatascience.com/introduction-to-graph-algorithm-breadth-first-search-algorithm-in-python-8644b6d31880?source=collection_archive---------17-----------------------

照片由 Unsplash 上的甘帕尼·库马尔拍摄

入门

清晰理解可视化广度优先搜索算法

图表形式的数据存在于许多流行和广泛使用的应用程序中。网络爬虫、计算机网络、关系数据库和社交网络都是很好的例子。图搜索算法对于计算机科学的任何部分都是重要的。同样，这对于许多编码面试来说也是重要和有用的。

有几种不同的图形搜索算法可用。这是最简单的图搜索算法之一，也是许多其他图算法的一种原型。今天我将详细解释广度优先搜索算法，并展示广度优先搜索算法的一个用例。以下是这篇文章的要点:

1. 广度优先搜索算法如何处理视觉效果
2. 用 Python 开发算法
3. 如何用这个算法找到任意节点到源节点的最短路径。
4. 时间复杂度

我们开始吧！

广度优先搜索算法的工作原理

一个图有两个元素。顶点和边。

鉴于，

一个图 G = (V，E)，

其中 V 是顶点，E 是边。

广度优先搜索算法系统地逐层探索边，以发现从给定的源顶点 s 可到达的每个顶点。

以下是广度优先搜索流程的步骤:

1. 有一个起始顶点 s。
2. 用开始顶点 S 作为级别 1 初始化级别集。
3. 探索另一个顶点从开始就可以到达。这些顶点将被视为级别 2。
4. 这样顶点就会一层一层的打开。

以下是这些步骤的直观演示:

这里，我们有六个顶点，u，v，w，x，y，z 和七条边 ux，uv，vx，vy，xy，wy，wz。

将顶点 u 视为源顶点或起始顶点。现在看下图他们是怎么一级一级打开的。

源顶点是 u 是 level 1。我们查一下我们能从 L1 去哪里。从图中可以看出,‘u’有一条直接通向 v 和 x 的路径，所以，它们是 2 级。

现在，我们在节点 x 和 v 中。x 和 v 只能直接访问 y。因此，y 是第 3 层。 从 x 和 v 两方面，我们可以去 u 也。但是我们忽略了已经访问过的节点。

y 只能直接访问 w。所以，w 是第四级。我们也可以从 y 到 v 和 x，但是它们已经被访问过了。所以，我们再也不用担心他们了。

最后 w 可以到 z，z 是 level5。

Python 中的算法

在我们深入算法之前，让我们先做一个邻接表。也就是说，创建一个字典，其中每个节点都是一个键，链接到它的节点都是存储在列表中的值。

例如，节点 u 链接到节点 v 和 x。因此，它将表示为:

'u': ['v', 'x']

这里的“u”是“v”和“x”的父代。

我们还需要对所有其他节点进行同样的操作。邻接表将看起来像这样:

adj = {
    'u': ['v', 'x'],
    'x': ['u', 'v', 'y'],
    'v': ['u', 'x', 'y'],
    'y': ['w'],
    'w': ['y', 'z'],
    'z': ['w']
    }

接下来，我们需要初始化几个变量:

变量来跟踪我们已经访问过的节点，

“级别”变量来跟踪我们当前所处的级别，

“parent”变量来存储节点的父节点。

“traversal_output”来列出经过的节点。

最后，我们将使用一个队列来开发这个算法。Python 有一个内置的队列，我们可以导入并使用它。

from queue import Queue
visited = {}
level = {}
parent = {}
traversal_output = []
queue = Queue()

开始时，将“已访问”字典中的所有节点设置为“False ”,将“父”字典中的所有节点设置为“None ”,并将级别设置为-1。

for node in adj_list.keys():
        visited[node] = False
        parent[node] = None
        level[node] = -1

如图，假设来源是‘u’。首先，使用 visited[s] = True，使用 level 0 并在队列中添加“u”。

s = "u"
visited[s] = True
level[s] = 0
queue.put(s)

循环来了！

在这个阶段，我们需要访问链接到源节点“u”的节点。我们将它列在上面的邻接表中。对于它们中的每一个，将它们设置为已访问，将它们的级别升级为比源节点的级别高一级，将它们的父节点设置为“u”，最后将它们添加到队列中。

然后对它们的子节点重复同样的操作。以下是完整的循环:

while not queue.empty():
    u = queue.get()
    traversal_output.append(u)
    for v in adj_list[u]:
        if not visited[v]:
            visited[v] = True
            parent[v] = u
            level[v] = level[u] + 1
            queue.put(v)
print(traversal_output)
print(visited)
print(level)
print(parent)

输出:

['u', 'v', 'x', 'y', 'w', 'z']
{'u': True, 'x': True, 'v': True, 'y': True, 'w': True, 'z': True}
{'u': 0, 'x': 1, 'v': 1, 'y': 2, 'w': 3, 'z': 4}
{'u': None, 'x': 'u', 'v': 'u', 'y': 'v', 'w': 'y', 'z': 'w'}

Traversal_output 显示我们遍历了所有节点。

对于每个节点，第二行中的 visited 为 true。

在第三行中，我们有所有节点的级别。请对照上面的图片。

在第四行，我们有所有节点的父节点。“u”是源节点。所以,“u”没有父代。

将所有代码组合起来，放入一个函数中:

def Breadth_first_search(adj_list):
    visited = {}
    level = {}
    parent = {}
    traversal_output = []
    queue = Queue()
    for node in adj_list.keys():
        visited[node] = False
        parent[node] = None
        level[node] = -1
    s = "u"
    visited[s] = True
    level[s] = 0
    queue.put(s)
    while not queue.empty():
        u = queue.get()
        traversal_output.append(u)
        for v in adj_list[u]:
            if not visited[v]:
                visited[v] = True
                parent[v] = u
                level[v] = level[u] + 1
                queue.put(v)
    return traversal_output, visited, level, parent

调用这个函数并传递邻接表’ adj '会给你同样的输出。

寻找最短的距离

该算法可用于寻找从源到任何其他节点的最短路径。怎么会？

看，我们知道每个节点的父节点。从任何一个节点，我们通过父节点不断回溯，最终会回到源节点。对吗？

比如说，我想从源节点‘u’找到最短路径‘w’。让我们看看，谁是 w 的父母。是 y。y 的父代是‘v’，然后 v 的父代是‘u’。所以，最短路径是 u，v，y，w。

检查图片，看看你是否认为这是最短的路径。

我们可以从上面定义的函数中找到每个节点的父节点。

traversed, visited, level, parent = Breadth_first_search(adj)

下面是查找最短路径的代码

v = "w"
path = []
while v is not None:
    path.append(v)
    v = parent[v]
path.reverse()
print(path)

输出:

['u', 'v', 'y', 'w']

时间复杂度

我们这里只有两个元素。顶点和边。

注意，小心。我们只访问每个顶点一次。在 for 循环中，我们忽略已经访问过的顶点。假设 V 是顶点的集合。

我们在这里使用了一个无向图。对于无向图，我们可以双向访问。我们可以从“u”到“v ”,也可以从“v”到“u”。在上面的邻接表’ adj '中，你可以看到一个节点可以出现不止一次。我们最多会遍历一条边两次。设 E 是边的集合，在最坏的情况下，它将穿过边 2E 次。Som 最坏情况下的总时间 V+2E。

时间复杂度可以表示为 O(V+E ),因为系数包含在 O 中。

结论

我试图解释，width _ first _ search 算法如何使用视觉效果工作，用 Python 开发了该算法，如何使用 width _ first _ search 算法找到最短路径，以及该算法的时间复杂度。我希望你现在清楚了。

欢迎在推特上关注我，喜欢我的 T2 脸书页面。

更多阅读:

[## 清晰理解深度优先搜索算法及其 Python 实现:图算法

借助清晰的视觉效果进行学习。还要学习人们在深度优先搜索算法中常犯的一个错误

towardsdatascience.com](/clear-understanding-of-depth-first-search-algorithm-and-its-python-implementation-graph-algorithm-3e87d8f1a9ea) [## Numpy 的终极备忘单

对学习也有好处

towardsdatascience.com](/an-ultimate-cheat-sheet-for-numpy-bb1112b0488f) [## 熊猫数据可视化的终极备忘单

熊猫的所有基本视觉类型和一些非常高级的视觉…

towardsdatascience.com](/an-ultimate-cheat-sheet-for-data-visualization-in-pandas-4010e1b16b5c) [## Python 中从头开始的完整异常检测算法:分步指南

基于概率的异常检测算法

towardsdatascience.com](/a-complete-anomaly-detection-algorithm-from-scratch-in-python-step-by-step-guide-e1daf870336e) [## 学习机器学习和深度学习的优质免费课程

顶级大学高质量免费课程的链接

towardsdatascience.com](/great-quality-free-courses-to-learn-machine-learning-and-deep-learning-1029048fd0fc) [## 使用 Lambda、Map、Filter 和 Sorted 进行高效的 Python 编程

使用数字、字符串和字典列表的快乐编程

towardsdatascience.com](/efficient-python-programming-with-lambda-map-filter-and-sorted-cfdf536afc36) [## 置信区间的完整指南，以及 Python 中的示例

对统计学中一个非常流行的参数——置信区间及其计算的深入理解

towardsdatascience.com](/a-complete-guide-to-confidence-interval-and-examples-in-python-ff417c5cb593)

图形挖掘和分析简介

原文：https://towardsdatascience.com/introduction-to-graph-mining-and-analytics-fac18515ea3e?source=collection_archive---------35-----------------------

你好。在这篇文章中，我将分享一些关于图形挖掘和分析的有趣故事/应用。

不是每个人，甚至是数据科学家每天都在处理与图形相关的问题/工具。所以人们可能会问的第一个问题是:什么是图？第二:为什么了解图形分析和算法很重要？第三:图挖掘和分析的一些应用是什么？让我们逐一回答这些问题，如果你想进一步探索图算法，我还会在最后附上一些好的资源。现在，让我们开始吧。

什么是图？

解释简单图形的涂鸦(图片由作者提供)

图形表示实体及其关系。每个实体由一个节点表示，它们之间的关系由一条边表示。这里每个实体(节点)是一个人，边表示关系有多“密切”(你可以给边加权来反映这一点。例如，在上面的涂鸦中，吉姆、艾米丽和雅各布位于等腰直角三角形的顶点。我们假设两边的权重为 1，斜边的长度为√2。经理汤姆位于斜边的中点，因此与其他所有人的距离相等，都是√2/2。现在，我们可以说，Tom 与他的三个直接下属有相同的“亲密度”，Jim 与 Jacob 和 Emily 有相同的“亲密度”,而 Jacob 和 Emily 自己的关系水平最高。).

现实生活中还有其他图表的例子。社交网络、网页、健康提供者网络等。并且该图可以进一步分为有向图和无向图。有向图意味着存在关于关系的方向，例如网页。无向图意味着实体之间的关系是相互的，例如，友谊网络。

为什么了解图形分析和算法很重要？

一句话，图表分析帮助我们研究互联数据，并帮助揭示模式，尤其是大数据中的社区。图形算法是图形分析中使用的工具。

考虑上面的涂鸦，但在一个更大的社交网络中。我们能找到社区中每个人都互相认识的社区吗(也称为强连接组件)？一旦我们确定了这些社区，我们能找到其中最有影响力的成员吗？到达那个人的最少人数是多少？此外，如果一个新人被添加到图表中，我们可以对这个新成员属于哪个社区进行分类吗？有趣的问题要解决，不是吗？

为了解决上述问题，我们需要引入图算法。例如，为了检测社区，我们需要引入三角形计数和聚类系数，以及标签传播和 Louvain 模块性。为了找到图中从一个成员到另一个成员的最小跳数，我们需要引入最短路径算法。图形算法的细节超出了本文的范围，但是你可以参考下面的参考资料获得更多信息。

图挖掘和分析有哪些应用？

有许多应用程序使用图形分析，我鼓励你自己多读一些。这里我要讲两个应用。一个是 PageRank，另一个是欺诈检测。

PageRank。 PageRank (PR)是谷歌搜索使用的一种算法，用于在其搜索引擎结果中对网页进行排名。我们知道网页是相连的，可以建模为有向图(节点之间的关系有方向)。为什么导演？这种关系不是相互的，因为我在帖子中指出了 neo4j 图书的链接，但他们可能不会指向我的链接。简单来说，PageRank 算法根据有多少网页指向一个网页，以及这些网页的影响力有多大，对该网页进行迭代排序，直到分数收敛。

欺诈检测。 之前我们在一张图中谈到了社区检测。这有助于检测网络中的欺诈行为。异常实体应该表现出不属于任何强连接组件的模式，或者与图中的其他实体具有很高的距离。例如，考虑那些为吸引用户点击而创建的欺诈性网页。它们很可能是“孤岛”,很少被其他网站引用，也很少被其他网站引用。

以上是对图形挖掘和分析的快速介绍。我鼓励你在业余时间读一些书，并欢迎给我任何意见/建议。

一些关于图形分析的好资源

(TigerGraph 在 youtube 上举办的图形大师网络研讨会。

(neo4j 网站上免费赠送的《图形算法》一书。https://neo4j.com/lp/book-graph-algorithms

使用 DeepWalk 介绍图形神经网络

原文：https://towardsdatascience.com/introduction-to-graph-neural-networks-with-deepwalk-f5ac25900772?source=collection_archive---------19-----------------------

让我们通过讨论该领域的开创性工作之一——DeepWalk，来建立对图形神经网络(GNN)的原因和内容的直觉。我们将把它与 word2vec 联系起来，并通过在图上试验现有的实现来结束。

由 Unsplash 的 urielsc26

介绍

图形神经网络是当前的热门话题[1]。这种兴趣肯定是合理的，因为 gnn 都是关于向量空间中图形的潜在表示。将实体表示为向量并不是什么新鲜事。在 NLP 中有许多像 word2vec 和手套嵌入这样的例子，它将一个单词转换成一个向量。使这种表示强大的是(1)这些向量在它们之间结合了相似性的概念，即彼此相似的两个词在向量空间中倾向于更接近(点积很大)，以及(2)它们在不同的下游问题中具有应用，如分类、聚类等。这就是 GNN 有趣的地方，因为有很多方法可以将一个单词或图像嵌入到矢量中，GNN 为图形奠定了基础。在本帖中，我们将讨论这样做的初始和基本方法之一——DeepWalk[2]

图表 101

图形或网络用于表示关系数据，其中主要实体称为节点。节点之间的关系由边来表示。通过添加多种类型的节点、边、边的方向，甚至边的权重，可以使图变得复杂。

图 1:空手道数据集可视化@网络知识库[3]。

图 1 显示了一个图表示例。该图是空手道数据集[4],它表示大学空手道俱乐部成员的社会信息。每个节点代表俱乐部的一个成员，每个边代表俱乐部的两个成员之间的联系。左边的信息栏显示了几个图形属性，如节点数、边数、密度、度数等。网络库[3]包含了许多来自不同领域的网络，并提供了可视化工具和基本统计数据，如上所示。

相似节点的概念

因为矢量嵌入背后的思想是突出相似性，我们将考虑相似节点的一些定义。两个节点可以通过多种方式被称为相似的，例如它们是否具有相似性——入度计数、出度计数、平均度或邻居数量等。一个有趣的概念是考虑节点的邻居，它们共享的邻居越多，它们就越相似。在纯文本中，节点是由它所保持的公司定义的。如果两个节点有非常相似的公司，那就是非常相似。这种通过位置来表示实体的想法并不新鲜。自然语言处理中单词嵌入的基础是基于这样一条格言:“单词由它所保持的上下文来表示”。这两个领域如此相似，很明显，第一直觉是利用 NLP 中的现有技术，通过某种方式将单词上下文的概念转换为节点的邻居，将其移植到图域。一种现有的技术是 word2vec，我们将简要讨论它。

Word2Vec

需要用 word2vec (w2v)走一段弯路，才能完全欣赏和理解 DeepWalk 背后的思想。Word2Vec 是一种将单词表示为向量的单词嵌入技术。每一个向量都可以看作是$R^D$空间中的一个点，其中$D$是每一个向量的维数。需要注意的一点是，这些向量并不是随机分布在向量空间中的。它们遵循一定的属性，相似的单词如猫和虎比完全不相关的单词如*坦克彼此相对更接近。*在向量空间中，这意味着它们的余弦相似性得分更高。与此同时，我们甚至可以观察到像king - man + woman = queen这样的著名类比，这些类比可以通过这些词的表示向量的向量相加来复制。

图 2:向量空间表示单词向量的位置以及它们之间的关系，以展示类比国王-男人+女人=王后

虽然这种表示不是 w2v 所独有的，但它的主要贡献是提供了一个简单而快速的基于神经网络的单词嵌入器。为此，w2v 将训练转化为一个分类问题，其中给定一个单词，网络试图回答哪个单词最有可能在给定单词的上下文中找到。这种技术正式称为 Skip-gram，其中输入是中间词，输出是上下文词。这是通过创建一个 1 层深度神经网络来实现的，其中输入单词以一位热编码格式馈送，输出是 softmax，理想情况下对上下文单词具有较大的值。

图 3: SkipGram 架构(摘自 Lil’Log [7])。它是一个 1 层深度神经网络，输入和输出为一个热编码。输入-隐藏权重矩阵包含单词嵌入。

训练数据是通过在大型文本(可以是文章或小说，甚至是完整的维基百科)的语料库上滑动一个窗口(某个窗口大小)来准备的，对于每个这样的窗口，中间的单词是输入单词，上下文中的剩余单词是输出单词。对于向量空间中的每个输入单词，我们希望上下文单词靠近，而其余的单词远离。并且如果两个输入单词将具有相似的上下文单词，则它们的向量也将接近。这是 Word2Vec 背后的直觉，它通过使用负采样来实现。训练后，我们可以观察到一些有趣的事情——神经网络的输入隐藏层之间的权重现在表示我们想要在单词嵌入中使用的概念，这样，具有相同上下文的单词在向量维度上具有相似的值。并且这些权重被用作单词嵌入。

图 4:来自 Wevi 的 5D 单词嵌入的热图可视化[5]。颜色表示单元格的值。

图 4 中的结果来自一个很酷的交互式 w2v 演示 Wevi [5]的训练 5D 单词嵌入。像(果汁、牛奶、水)和(橘子、苹果)这样显而易见的词有相似的向量(一些维度被同样照亮——红色或蓝色)。感兴趣的读者可以去[7]详细了解建筑学和数学。此外，建议[5]对 word2vec 后面的引擎进行出色的可视化。

深度行走

DeepWalk 采用了和 w2v 相同的训练技术，即跳格训练。但是还有一件重要的事情要做，那就是创建训练数据来捕捉图形中的上下文概念。这是通过随机漫步技术完成的，我们从一个节点开始，随机地去它的一个邻居。我们重复这个过程$L$次，这是随机行走的长度。在这之后，我们重新开始这个过程。如果我们对所有节点都这样做(并且对每个节点做$M$次),我们在某种意义上已经将图形结构转换成类似于用于训练 w2v 的语料库的文本，其中每个单词是一个节点，并且它的上下文定义了它的邻居。

实现 1:作者代码

DeepWalk 的作者在这里提供了一个 python 实现。自述文件中提供了安装详细信息和其他先决条件(windows 用户可能会遇到一些安装和执行问题)。CLI API 公开了几个算法和优化参数，

• input需要包含图形信息的输入文件的路径。一个图可以用几种格式存储，一些著名的(并且被代码支持)是邻接表(node-all_neighbors list)和边表(有边的节点-节点对)。
• number-walks每个节点随机行走的次数。
• representation-size每个节点最终嵌入的维度。也是 skipgram 模型中隐藏层的大小。
• walk-length每次随机漫步的长度。
• window-sizeskip gram 训练中的上下文窗口大小。
• workers优化参数定义为训练生成的独立进程的数量。
• output输出嵌入文件的路径。

作者也提供了示例图，其中之一是我们的空手道俱乐部数据集。它以邻接表的格式存储。

图 5:空手道俱乐部数据集邻接表的前 5 行。节点用数字表示。在每一行中，第一个节点名是中心节点，其余节点是它的邻居(它们有一条边)。

现在让我们读取图形数据并创建节点嵌入，

deepwalk --input example_graphs/karate.adjlist --number-walks 10
--representation-size 64 --walk-length 40 --window-size 5 
--workers 8 --output trained_model/karate.embeddings

这执行了从开始到结束的分析，包括从文件中加载图形，生成随机遍历，最后在遍历数据上训练 skip-gram 模型。通过使用额外的--max-memory-data-size 0参数运行该脚本，该脚本还存储了行走数据，如下所示。

图 6:为空手道俱乐部数据集生成的随机行走语料库的前 5 行。节点用数字表示。每条线代表从第一个节点开始的一次随机行走。当我们设置 walk length = 40 时，每行(walk)有 40 个节点。同样，当我们设置遍历数= 10，总节点数= 34 时，总共生成 10*34=340 个随机遍历。

最后，我们得到包含图中每个节点的矢量嵌入的输出嵌入文件。该文件看起来像，

图 7:节点嵌入输出的前 3 行。第一行是带有节点和嵌入维度统计信息的标题。从第二行开始，第一个数字是节点名，随后的数字是提到的节点的矢量嵌入。

实施 2:空手道俱乐部

新发布的 python 实现——KarateClub[6]提供了一个简单得多的 API。要做同样的一套动作，我们需要做的就是跟着做。

# import libraries
import networkx as nx 
from karateclub import DeepWalk
# load the karate club dataset
G = nx.karate_club_graph()
# load the DeepWalk model and set parameters
dw = DeepWalk(dimensions=64)
# fit the model
dw.fit(G)
# extract embeddings
embedding = dw.get_embedding()

DeepWalk类也扩展了作者的代码所公开的相同参数，并且可以进行调整以进行所需的实验。

图 8:KarateClub[6]中 DeepWalk 实现公开的参数。

实验

为了查看 DeepWalk 的运行情况，我们将选择一个图，并可视化网络以及最终的嵌入。为了更好地理解，我创建了一个由 3 个完整的图组成的并集，每个图都有一些额外的边来连接。

图 9:3 个完整图的并集。我们可以想象 3 个集群，其中节点 0 到 9 属于集群 1；10 到 19 到组 2，20 到 28 到组 3。

现在，我们将创建图的深走嵌入。为此，我们可以使用 KarateClub 包，通过在默认设置下运行 DeepWalk，我们可以获得 128 维的嵌入。为了形象化这一点，我使用了降维技术 PCA，它将 R ⁸的嵌入缩小到 r。我还将在边上绘制嵌入的 128D 热图。

图 10:左图—主成分分析减少了(从 128D 到 2D)图的节点嵌入。右图—原始 128D 嵌入式产品的热图。

在左图中有清楚的节点分离，这表示嵌入的向量空间。这展示了 DeepWalk 如何将图形从力布局可视化转换为向量空间可视化，同时保持一些结构属性。热图还暗示了图形到 3 个聚类的清晰分离。

另一个需要注意的重要事情是，当图形不复杂时，我们也可以使用低维嵌入。这不仅减少了维数，而且改善了优化和收敛，因为在 skip-gram 中有较少的参数要训练。为了证明这一点，我们将创建大小仅为 2 的嵌入。这可以通过设置 DeepWalk 对象dw = DeepWalk(dimensions=2)中的参数来完成。我们将再次想象同样的情节。

图 11:左图:图中的节点嵌入(大小=2)。右图:嵌入的热图。

两个图再次暗示了图中相同数量的集群，并且所有这些仅使用了 1%的先前维度(从 128 到 2，即~1%)。

结论

作为这个类比的答案NLP - word2vec + GraphNeuralNetworks = ?可以说是 DeepWalk(是吗？🙂)，这就引出了两个有趣的点，(1) DeepWalk 在 GNN 的影响可以类比 Word2Vec 在 NLP 的影响。这是真的，因为 DeepWalk 是第一批使用神经网络进行节点嵌入的方法之一。这也是一个很好的例子，说明了来自另一个领域(这里是 NLP)的一些成熟的 SOTA 技术是如何移植到一个完全不同的领域(这里是图)并应用的。这就引出了第二点，(2)正如 DeepWalk 不久前发表的(2014 年——只有 6 年，但却是人工智能研究的一生)，目前，有很多其他技术可以用来以更好的方式完成这项工作，如 Node2Vec，甚至是 GraphSAGE 等图形卷积网络。也就是说，从基于神经网络的 NLP 开始，word2vec 是最好的起点，我认为 DeepWalk 在同样的意义上是基于神经网络的图形分析的良好开端。也是本文的主题。

干杯。

参考

[1]easy AI——GNN 可能是人工智能的未来

[2] DeepWalk — 论文 | 代码

[3] 网络知识库

[4]扎卡里空手道俱乐部—KONECT 项目

[5] Wevi —文字嵌入可视检查器

[6]空手道俱乐部— 论文 | 代号

[7] Lil’Log —学习单词嵌入

图形表示学习简介

原文：https://towardsdatascience.com/introduction-to-graph-representation-learning-a51c963d8d11?source=collection_archive---------24-----------------------

入门

图上机器学习的主要概念和挑战

由延斯·约翰森在 Unsplash 上拍摄的照片

近年来，图形表示学习的受欢迎程度激增。只有几个活跃的研究人员的时代已经成为遥远的过去。今天，我们看到谷歌或 Twitter 等顶级公司在这一领域进行了大量投资。

令人惊讶的是，许多可用的数据可以被建模为图表。以 Reddit 上的在线社交互动为例。我们可以将每个用户表示为一个连接到其他用户的节点。但是，我们如何分析这种数据，甚至应用机器学习呢？

在图形表示学习中，我们旨在回答这些问题。在这篇文章中，我们将看看图形表示学习的主要概念和挑战。

图表基础

从图中创建邻接矩阵。图片作者。

让我们从基础开始，好吗？

我们将图定义为一组顶点，这些顶点之间有连接(边)。有许多类型的图，例如，它们可以是有向的、无向的或无环的。

为了使图形对任何算法都有用，我们需要将它们转换成数字形式。为了实现这一点，我们可以使用邻接、拉普拉斯矩阵或度矩阵，它们提供了图形的方便的矩阵表示。每个顶点和每个连接也可以有一个定义其属性的特征向量。

在[1]中可以找到对图的很好的介绍。一旦你对基础知识相当有信心，学习更高级的概念是有好处的，比如图同构和图着色。

图的特征提取技术

节点级特征的一个例子，即中心性测量。左图说明了特征向量的中心性。右边的例子说明了程度中心性。【来源】

图形特征提取背后的主要思想是以一种更方便的、类似向量的格式来表示关于局部和全局图形结构的信息。我们同样对提取单个顶点的属性信息以及它们之间的连通性感兴趣。

从图中提取的特征可以分为三种类型:节点级、图级和邻域重叠特征。

对于节点级特征，我们的目标是为每个顶点生成一个特征向量。一些最流行的特征提取方法是节点度、中心性方法或聚类系数。为了计算这些特征，我们可以使用来自顶点的最近邻居的信息，或者来自更远的 K 跳邻居的信息。

我们也可以采取更一般的方法，为整个图创建一个特征。它被称为图形级特征。这可以通过邻接矩阵等基本特征来实现，也可以通过 Weisfeiler-Lehman 或 Graphlet 内核等更复杂的迭代方法来实现。

图的最后一种特征提取是邻域重叠特征。它们是专门为提取节点之间的连接信息而设计的。它们可以进一步细分为局部和全局方法。前者描述了两个节点之间的邻域的相似性，而后者描述了某些节点是否属于图中的同一社区(即一组密集聚集的节点)。

你可以在这篇文章中找到对特征提取技术的深入解释。

图上的预测任务

预测顶点的动物类型。图片作者。图标按图标 8

在图上使用机器学习的主要问题是节点是相互连接的。这打破了独立数据点的假设，这迫使我们使用更精细的特征提取技术或新的机器学习模型来处理这个问题。

预测任务在图上的定义也有很大不同。我们可以将其分为 4 种主要类型:节点分类、链接预测、整个图的学习和社区检测。

节点分类的目的是预测图中顶点的属性。链接预测也非常相似，但它预测两个顶点之间的链接(连接)的属性。这些任务被称为半监督学习，因为该图将同时包含训练和测试数据*。*

学习整个图形是最直观的方法。我们将整个图形作为输入，并基于它生成预测。它非常类似于标准的机器学习回归和分类任务。

最后，对于社区检测，我们的目标是识别图中密集的顶点簇。

如果你想了解更多关于图表上的预测任务，请看这里的。

图形神经网络

由 Duvenaud 等人创建的第一个图形神经网络架构之一。它是一种消息传递神经网络。 【来源】

为了重新定义图上的神经网络，我们必须提出全新的深度学习架构[2]。

最简单的架构是消息传递神经网络。在这里，前向过程的一个等效过程是来自顶点邻域的要素的迭代聚合。每个聚合操作都被视为一个层。在 n 次迭代之后，我们使用一个最终的聚合操作将所有信息提取为一个向量/矩阵。

我们也可以在图上定义图卷积神经网络。它们可以分为空间方法和光谱方法。空间方法是最直观的方法:我们定义一个核来对图形进行卷积，类似于 CNN。频谱方法稍微复杂一些:我们考虑傅立叶域中的图形，并集中处理通过图形传播的信号。

生成图模型

这些模型的目的是创建具有所需属性的新图。这里，我们希望模型的输出是一个图[2]。但是我们为什么需要生成图表呢？

首先，我们可以使用这些图表作为机器学习模型的基准数据[2]。例如，如果我们想要检测社区，我们可以创建一个生成图模型，该模型可以创建具有社区的图。通过定义这些模型，我们还可以知道生成图的特定实例的可能性有多大。

鄂尔多斯-雷尼模式就是一个很好的例子。这是一个非常简单的模型，它将两个任意节点之间的连接概率指定为 r. 通过这个参数，我们可以控制生成的图的连接密度。

更复杂的模型包括随机块模型、优先附件和不同的变分自动编码器方法。在2中可以找到对这些模型的详细解释。

几句遗言

图上的机器学习并不简单。我们已经看到，大多数标准的机器学习方法都必须重新定义到图形域中。图形上的特征提取、预测任务与正常的机器学习问题非常不同。我们希望通过创建处理图表数据的新技术，我们可以充分利用图表中的信息，并创建性能更好的模型。

关于我

我是阿姆斯特丹大学的人工智能硕士学生。在我的业余时间，你可以发现我摆弄数据或者调试我的深度学习模型(我发誓这很有效！).我也喜欢徒步旅行:)

如果你想了解我的最新文章和其他有用的内容，以下是我的其他社交媒体资料:

• 领英
• GitHub

参考

[1] 罗宾·j·威尔逊的图论

[2] 林子幸·汉密尔顿的《图形表示学》一书

分层建模简介

原文：https://towardsdatascience.com/introduction-to-hierarchical-modeling-a5c7b2ebb1ca?source=collection_archive---------9-----------------------

使用贝叶斯分层模型对自然聚集的数据建模

此分析中不同组之间的系数分布

介绍

在我们的数据集中发现不完全独立的样本并不罕见。数据集中的样本通常形成聚类或组，在这些聚类或组中共享一些属性。这通常需要在建模时特别注意，以构建可靠的模型，原因有两个。首先，对于像最大似然估计这样的统计分析过程，样本的独立性是一个重要的假设。第二，我们希望在我们的模型中捕捉预测因素对不同群体的影响的变化，这种变化被称为背景效应。

一个常用的例子，我发现足以理解这种情况是学生在学校的表现。在有多个班级学生的学校里，学生的学业表现受到他们个人能力(称为固定效应)和他们所在班级(称为随机效应)的影响。也许被分配到某个班级的老师比其他人教得更好，或者班级中高比例的聪明学生为学生创造了一个竞争环境，让他们表现得更好。

处理这种情况的一种方法是为每个类构建多个模型，称为池。但是这种方法并不总能产生可靠的结果。比如学生很少的班级对应的模型，会很误导人。一个单独的非 pooled 模型可能无法充分拟合数据。我们想在这两个极端之间找到一个折中的中间地带——部分统筹。这就把我们带到了**贝叶斯分层建模，**也称为多级建模。

在这种方法中，参数在不同级别的组中相互嵌套。粗略地说，它给出了未汇集和汇集模型估计的加权平均值。分层建模是贝叶斯推理和统计建模中最强大而简单的技术之一。在这篇文章中，我将用一个实际的例子来介绍这个想法。注意，这篇文章并没有涉及贝叶斯分析的基础。该示例的源代码可以在 GitHub 的笔记本中找到。

数据

用于说明的数据集类似于上面的学生示例，只是我们试图找到来自不同学校的学生的数学成绩。在我们的例子中，我们使用作业完成情况作为预测指标。你可以在这里找到原始数据，在这里找到 csv 版本。

第一眼

绘制学生相对于家庭作业的数学成绩，以及的未拟合的 OLS 回归拟合给了我们这个结果:

具有非 pooled 回归拟合的数据样本

可视化学校层面的数据揭示了一些有趣的模式。我们还绘制了适合每个学校的汇集的回归线和未汇集的回归线，以供参考。为了简单起见，我们使用 OLS 回归。

合并回归的数据样本适合不同的组

该图显示了各组之间关系的变化。我们还注意到，在某些组中，作业完成率较高的少数数据点(可能的异常值)对估计值有很大影响。

层次模型

我们将使用 PyMC3 构建我们的贝叶斯层次模型。我们将在我们的组级参数上构建超优先级，以允许模型在组间共享学生的个人属性。

该模型可以表示为 yᵢ = αⱼᵢ + βⱼᵢxᵢ + εᵢ，

或者用概率符号表示为 y∞n(αⱼ+βⱼx，ε)。

对于这个模型，我们将使用随机斜率β和截距α。这意味着它们将随每组而变化，而不是整个数据的恒定斜率和截距。概率模型的图示如下所示。

本例中使用的分层模型的图形表示

虽然我在这里通过目测样本的总体分布来选择我的先验，但是使用无信息的先验也会导致类似的结果。下面的代码片段定义了所使用的 PyMC3 模型。

with pm.Model() as model:
    # Hyperpriors
    mu_a = pm.Normal('mu_a', mu=40, sigma=50)
    sigma_a = pm.HalfNormal('sigma_a', 50)

    mu_b = pm.Normal('mu_b', mu=0, sigma=10)
    sigma_b = pm.HalfNormal('sigma_b', 5)

    # Intercept
    a = pm.Normal('a', mu=mu_a, sigma=sigma_a, shape=n_schools) # Slope
    b = pm.Normal('b', mu=mu_b, sigma=sigma_b, shape=n_schools)

    # Model error
    eps = pm.HalfCauchy('eps', 5)

    # Model
    y_hat = a[school] + b[school] * homework

    # Likelihood
    y_like = pm.Normal('y_like', mu=y_hat, sigma=eps, observed=math)

我们将使用 NUTS 采样器从后验分布中抽取样本。

with model:
    step = pm.NUTS()
    trace = pm.sample(2000, tune=1000)

对应于每个学校的轨迹图以及斜率和截距的后验分布如下图所示。

分层模型的轨迹图

每组截距和斜率的后验分布

我们可以看到不同学校系数估计值的差异。我们还可以清楚地解释与分布估计相关的不确定性。下面的后验预测回归(灰色)线是从每组估计值的后验分布中取样的，给出了关于数据的模型的更好的图像。

分层模型的后验预测拟合

请注意，显示负斜率的组通常具有更高的不确定性。该模型在群体级别的噪声敏感度和学生级别的全局估计值之间找到了一个折衷点(在 IDs 7472、7930、25456、25642 中很明显)。这意味着我们必须对从这些群体的模型中得出的决定更加谨慎。我们还观察到，随着更多的数据和更小的偏差，贝叶斯模型收敛到该组(ID 62821)的 OLS 模型，如预期的那样。我们还可以通过绘制从mu_a到mu_b的回归线来检查学生级别关系(这里我省略了)。

不同模型的交叉验证将显示层次建模方法的优越性。交叉验证可以在两个级别执行:

1. 在一个小组中找出学生，并根据其预测进行评估。
2. 支持整个团队并评估其预测。请注意，这在池模型中是不可能的。

我在这里不进行验证，因为这里使用的频率主义者和贝叶斯模型不能进行公平(或简单)的比较。但是 CV 可以通过用贝叶斯线性回归代替 OLS 回归并比较它们的模型的均方根偏差(RMSD)来执行。

结论

贝叶斯分层建模可以用自然聚集的数据产生健壮的模型。它们通常允许我们建立简单和可解释的模型，而不是像集成或神经网络这样常用于这种复杂数据的频繁技术。尽管模型中的参数数量增加了，它们也防止了过度拟合。这篇文章仅仅是对层次模型的介绍，其固有的简单性允许我们实现特定于我们的数据的模型的不同变体(例如:添加子组，使用更多的组级预测器)并进行不同类型的分析(例如:寻找级别之间的相关性)。

资源

[## GLM:分级线性回归- PyMC3 3.8 文档

本教程改编自达内·埃尔伯斯和托马斯·威奇的博客文章《两全其美…

docs.pymc.io](https://docs.pymc.io/notebooks/GLM-hierarchical.html) [## pymc 3-pymc 3.8 文档中的(广义)线性和分层线性模型

让我们生成一些斜率已知的数据，截取并拟合一个简单的线性 GLM。glm.linear_component()函数…

docs.pymc.io](https://docs.pymc.io/notebooks/GLM.html) [## 1.9 分层逻辑回归| Stan 用户指南

最简单的多级模型是分层模型，其中数据被分组到不同的类别(或…

mc-stan.org](https://mc-stan.org/docs/2_24/stan-users-guide/hierarchical-logistic-regression.html)

A.Gelman 等人，《贝叶斯数据分析》(2013 年)，第 5 章，CRC 出版社

感谢您的阅读！我将感谢任何关于这个帖子的反馈。

你可以在 Linkedin 上联系我，在 GitHub 上关注我。

Hive 简介

原文：https://towardsdatascience.com/introduction-to-hive-859ba31a5769?source=collection_archive---------20-----------------------

Hive & SQL 编码初学者指南

图像信用—Confusedcoders.com

本文主要关注 Hive、它的特性、用例以及 Hive 查询。因为许多 DML 和 DDL 查询与 SQL 非常相似，所以它可以作为任何 SQL 新手的基础或构建块。

Apache Hive 通常被称为构建在 Apache Hadoop 之上的数据仓库基础设施。最初由脸书开发，用于查询他们每天大约 20TB 的输入数据，目前，程序员使用它对存储在 HDFS (Hadoop 分布式框架系统)等文件系统中的大型数据集进行特别查询和分析，而无需了解 map-reduce 的细节。Hive 最好的部分是查询被 Hive 引擎隐式地转换成高效的链式 map-reduce 作业。

蜂巢的特点:

• 支持不同的存储类型，如纯文本、csv、Apache Hbase 等
• 数据建模，如创建数据库、表格等。
• 易于编码；使用类似 SQL 的查询语言 HiveQL
• ETL 功能，例如提取、转换和将数据加载到表中，以及连接、分区等。
• 包含内置的用户定义函数(UDF ),用于操作日期、字符串和其他数据挖掘工具
• 无论布局如何，非结构化数据都显示为看起来像表格的数据
• 自定义映射器、缩减器和 UDF 的插件功能
• Hadoop 上的增强查询

Hive 的使用案例:

• 文本挖掘 —具有便捷结构的非结构化数据，通过 map-reduce 进行覆盖和分析
• 文档索引 —为多个文档分配标签以便于恢复
• 业务查询 —查询大量历史数据以获得可操作的洞察，例如交易历史、支付历史、客户数据库等。
• 日志处理 —处理各种类型的日志文件，如通话日志、网络日志、机器日志等。

Hive 中的编码

我们将使用一个名为“transaction”的表来了解如何在 Hive 中查询数据。事务表包含属性 id、item 和 sales。

以下是任何编程语言的一些最佳编码实践。

[## 对于数据科学的工作，你的编码技能够好吗？

5 编码嗅探如果你在数据科学行业工作，你必须知道

towardsdatascience.com](/are-your-coding-skills-good-enough-for-a-data-science-job-49af101457aa)

配置单元中的 DDL 命令

DDL 是数据定义语言的简称，它处理数据库模式和描述，说明数据应该如何驻留在数据库中。一些常见的例子有

创建表格

• 创建表—创建表事务(id INT，item STRING，sales FLOAT)；
• 在特定位置存储表格—创建表格事务(id INT，item STRING，sales FLOAT)行格式分隔字段，以“\001”终止，存储为文本文件位置；
• 对表进行分区—创建由(id INT)分区的表事务(id INT，item STRING，sales FLOAT)

翻桌

• 删除表交易记录；

改变表格

• 将表事务重命名为 transaction _ front _ of _ stores
• 添加列—ALTER TABLE transaction ADD COLUMNS(customer _ name STRING)；

显示表格

• 显示表格；

描述表格

• 描述交易记录；
• 描述扩展交易记录；

配置单元中的 DML 命令

DML 是数据操作语言的简称，它处理数据操作，包括最常用的 SQL 语句，如 SELECT、INSERT、UPDATE、DELETE 等。它主要用于存储、修改、检索、删除和更新数据库中的数据。

加载数据

• 从外部文件加载数据——加载数据本地路径“<file_path>”【覆盖】到表；</file_path>
• 将数据本地路径“/documents/datasets/transaction . CSV”[OVERWRITE]加载到表事务中；
• 从单独的表写入数据集—插入覆盖表事务 SELECT id，item，date，volume FROM transaction _ updated

选择指令

select 语句用于从数据库表中提取数据。主要用于查看记录、选择必需的字段元素、获取不同的值以及显示任何筛选、限制或分组操作的结果。

要从事务表中获取所有记录:

从交易记录中选择*；

要从事务表中获取不同的事务 id:

从交易记录中选择不同的 id；

极限语句

与 Select 语句一起使用，限制编码人员希望查看的行数。任何事务数据库都包含大量数据，这意味着选择每一行都会导致更长的处理时间。

SELECT *从交易限额 10；

过滤语句

SELECT * FROM 销售额> 100 的交易；

Group by 语句

Group by 语句用于汇总不同级别的数据。设想一个场景，我们希望按商品计算总销售额。

选择项目，SUM(sales)作为按项目分组的交易中的销售额；

如果我们想过滤掉所有销售额至少为 1000 英镑的商品。

按销售额> 1000 的项目从交易组中选择项目，SUM(sales)作为销售额；

加入配置单元

为了组合和检索多个表中的记录，我们使用了 Hive Join。目前，Hive 支持两个或更多表的内、外、左和右连接。语法类似于我们在 SQL 中使用的语法。在我们看语法之前，让我们了解不同的连接是如何工作的。

配置单元中的不同联接

SELECT A . * FROM transaction A { LEFT | RIGHT | FULL } JOIN transaction _ date B ON(A . ID = B . ID)；

注意事项:

• 配置单元不支持 IN/EXISTS 子查询
• 配置单元不支持不包含相等条件的连接条件
• 可以连接多个表，但要组织好表，使最大的表出现在序列的最后
• 如果对于每个表，在 join 子句中使用了相同的列，则 Hive 会将多个表的连接转换为单个 map/reduce 作业

优化配置单元中的查询

为了优化 hive 中的查询，这里有 5 条你应该知道的经验法则

1. 默认情况下，分组、聚合函数和连接发生在 reducer 中，而过滤操作发生在 mapper 中
2. 使用 hive.map.aggr=true 选项直接在地图任务中执行第一级聚合
3. 根据正在执行的任务类型设置映射器/缩减器的数量。对于筛选条件，请使用 set mapred . mapper . tasks = X；对于聚合操作:设置 mapred . reduce . tasks = Y；
4. 在连接中，序列中的最后一个表通过 reducers 进行流式传输，而其他表则被缓冲。 组织表格，使最大的表格出现在序列的最后
5. 流表和地图连接可用于加速连接任务

想了解更多关于 Python 可视化的知识吗？

[## 数据可视化:用 Python 中的图表说出来

使用 matplotlib、pyplot 和…的 python 可视化最佳实践和概念的完整实践指南

towardsdatascience.com](/data-visualization-say-it-with-charts-in-python-138c77973a56) [## 现代分析的黎明——了解商业智能的一些最新趋势…

基于调查的方法来确定每个数据科学家都应该知道的 BI 工具

towardsdatascience.com](/the-dawn-of-modern-analytics-a-look-into-some-of-the-recent-trends-of-business-intelligence-fc12cdf41cae)

关于作者:高级分析专家和管理顾问，帮助公司通过对组织数据的商业、技术和数学的组合找到各种问题的解决方案。一个数据科学爱好者，在这里分享、学习、贡献；可以和我在 上联系 和 推特；

Hydra.cc 简介:配置数据科学项目的强大框架

原文：https://towardsdatascience.com/introduction-to-hydra-cc-a-powerful-framework-to-configure-your-data-science-projects-ed65713a53c6?source=collection_archive---------31-----------------------

尝试不同的参数和模型，而无需花费数小时来修改代码！

照片由贾斯特斯·门克在 Unsplash 拍摄

动机

玩不同的特征工程方法和机器学习模型很有趣，但在获得好的结果之前，你很可能需要调整你的特征工程方法和调整你的机器学习模型。

例如，在下面的速配数据中，考虑到它们不是重要的特征，你可能想去掉iid, id, idg, wave, career。但是在对数据做了更多的研究之后，你意识到career将是预测两个人是否会有下一次约会的一个重要特征。所以你决定不放弃career专栏。

如果您正在进行硬编码，这意味着将数据直接嵌入到脚本的源代码中，如下所示

并且您的文件很长，您可能需要一段时间来找到指定删除哪些列的代码。如果从一个只包含数据信息的简单文本中修复列，而不使用像这样的其他 python 代码，这不是很好吗？

这时你需要一个配置文件。

什么是配置文件？

配置文件包含定义运行程序的设置的纯文本参数。一个好的做法是避免在 python 脚本中硬编码，而在配置文件中保留与数据相关的所有信息，比如删除哪些列、分类变量**。**

这种做法不仅节省了您在脚本中搜索特定变量的时间，而且使您的脚本更具可重复性。

例如，我可以对完全不同的数据重用这段代码，因为代码中没有指定列名。为了让代码为新数据工作，我需要做的就是修改我的配置文件中的列名！

配置文件的通用语言是 YAML。YAML 是所有编程语言的人性化数据序列化标准。语法易于阅读，几乎与 Python 相似。在这里找到更多关于 YAML 语法的信息。

Hydra.cc 简介

我希望上面的简短解释能帮助你理解配置文件的重要性。但是我们如何访问配置文件中的参数呢？

有一些工具可以读取配置文件，比如 PyYaml ，但是我最喜欢的是 Hydra.cc 。为什么？因为它允许我:

• 无缝更改我在终端中的默认参数
• 在不同的配置组之间切换
• 自动记录结果

让我们了解如何开始使用 hydra.cc，并探索使用这一强大工具的好处。

开始

安装 Hydra.cc

pip install hydra-core --upgrade

让我们从一个具体的例子开始:

例如，如果您有如下所示的配置文件，其中包含关于数据路径、编码、管道类型和目标列的所有特定信息

您需要做的就是将装饰器@hydra.main(config_path='path/to/config.yaml')添加到将使用配置文件的函数中。确保在函数中添加config来访问配置文件。

现在，您可以使用配置文件中的任何参数了！如果你想知道目标的名字，

target: match

你所需要做的就是调用config.target来得到字符串‘匹配’！

请注意，您不需要将单词“match”用引号括起来。如果它是一个单词，YAML 文件会将其视为一个字符串。

简单命令行应用程序

Hydra.cc 允许您在终端中覆盖配置文件中的默认参数。例如，如果您想要将机器学习模型从决策树切换到逻辑回归

您不需要重写配置文件。您可以在运行文件时在终端中键入变量的替代参数

python file.py model=logisticregression

并且模型会切换到 logistic 回归！

更好的是，如果您的配置文件很复杂，Hydra.cc 还允许您通过制表符结束来更容易地访问文件中的参数！你可以在这里找到关于标签完成的细节。

在不同的配置组之间切换

为了保持配置文件的简短和结构化，您可能希望为不同的模型创建不同的文件以及它们的参数，如下所示

您可以在命令行上指定要定型的模型的配置文件

python file.py model=logistic

现在，您可以在不同的模型之间切换，并轻松访问它们的超参数！

自动记录

如果你想记录跑步的结果，记录是很重要的。但是由于设置成本，许多人不使用 Python 日志记录。Hydra.cc 根据一天的情况，自动创建所有结果并保存在“输出”文件夹中

每个日文件夹都是根据小时和分钟来组织的。您将看到与您的运行相关的所有日志，以及用于该运行的配置文件！

如果您碰巧更改了您的配置文件，并且不记得您用来生成某个输出的配置文件是什么样子的，您可以查看当天的文件夹来找出答案！

在这里找到更多关于伐木的信息。

因为在运行 hydra decorator 包装的函数时，您位于输出目录中，所以如果您想要访问父目录中的其他文件，请确保使用utils.to_absolute_path('path/to/file')。

Current working directory  : /Users/khuyentran/dev/hydra/outputs/2019-10-23/10-53-03Original working directory : /Users/khuyentran/dev/hydrato_absolute_path('foo')    : /Users/khuyentran/dev/hydra/footo_absolute_path('/foo')   : /foo

结论

恭喜你！您已经了解了配置文件的重要性以及如何无缝配置您的数据科学项目。我发现，当我将所有与数据相关的信息都放在一个单独的文件中时，会更有条理。我还发现，当我所需要做的就是调用python file.py variable=new_value.时，试验不同的参数会更容易。我希望通过在数据科学实践中结合配置文件和 Hydra.cc，您也能获得同样的好处。

下面是使用 hydra.cc 和 config 文件的示例项目。

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上与我联系。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如

[## 你应该从 Jupyter 笔记本转向脚本的 5 个理由

使用脚本帮助我认识到 Jupyter 笔记本的缺点

towardsdatascience.com](/5-reasons-why-you-should-switch-from-jupyter-notebook-to-scripts-cb3535ba9c95) [## 如何用 Faker 创建假数据

您可以收集数据或创建自己的数据

towardsdatascience.com](/how-to-create-fake-data-with-faker-a835e5b7a9d9) [## 如何使用 HyperDash 远程监控和记录您的机器学习实验

培训需要很长时间才能完成，但你需要去洗手间休息一下…

towardsdatascience.com](/how-to-monitor-and-log-your-machine-learning-experiment-remotely-with-hyperdash-aa7106b15509) [## 如何在数据科学项目中利用 Visual Studio 代码

直到发现一种新的有效方法，我们才意识到我们是多么低效

towardsdatascience.com](/how-to-leverage-visual-studio-code-for-your-data-science-projects-7078b70a72f0) [## 如何在一行代码中跨不同环境共享 Python 对象

为建立与他人分享你的发现的环境而感到沮丧？以下是如何让它变得更简单

towardsdatascience.com](/how-to-share-your-python-objects-across-different-environments-in-one-line-of-code-f30a25e5f50e)

IBM 联邦学习简介:一种在私有数据上训练 ML 模型的协作方法

原文：https://towardsdatascience.com/introduction-to-ibm-federated-learning-a-collaborative-approach-to-train-ml-models-on-private-data-2b4221c3839?source=collection_archive---------42-----------------------

在训练来自不同来源的数据时，如何保证数据的安全？

IBM Research 刚刚在 Github 上发布了 IBM 联邦学习。如果您一直在寻找一种方法，在保持数据私密的同时，利用从多个资源收集的数据来提高模型训练，那么这个框架非常适合您。本文将解释为什么需要联邦学习以及如何开始使用该框架。

照片由晨酿在 Unsplash 拍摄

动机

当训练一个机器学习模型时，我们通常知道你的数据看起来如何，数据的分布和统计。

但是在现实世界中，我们可能会使用不同来源的数据，却不知道这些数据是什么样的。为什么？因为数据安全在不同的企业中很重要。

例如，一个航空联盟想要模拟新冠肺炎最近的事件将如何影响航班延误。在航空联盟中，我们有几家不同的航空公司，它们拥有不同的数据。因为这些航空公司是竞争对手，所以原始数据不能在每个航空公司之间共享。但是航空联盟需要用组合数据来训练模型！

可能还有其他非竞争原因，例如:

• 对于一些企业来说，将数据移动到一个位置可能不切实际或成本高昂，尤其是在数据生成速度很快或数据量很大的情况下。
• 即使在同一家公司，客户数据库也可能位于不同的国家，数据不能被带出这个国家。
• 由于监管和保密的原因，金融公司不能共享交易数据，医疗机构也不能共享患者数据。

那么解决办法是什么呢？这就是我们需要联合学习的时候。

什么是联合学习？

联合学习(FL)是一种训练机器学习模型的方法，不需要与中央实体共享数据集。在联合学习中，模型是在多方之间协作训练的。各方可以保留他们自己的训练数据集，但是仍然能够参与共享的联合学习过程。

从 IBM 数据科学和人工智能会议 4 中检索的图像

各方之间的学习过程通常使用单个集合器。一个汇总者将与各方沟通并整合培训过程的结果。

例如，神经网络的过程可以是:

• 各方对其训练数据运行本地训练过程，与聚合器共享其模型的权重。
• 然后，这些权重将使用融合算法聚合所有各方的权重向量。
• 然后，将合并后的模型发回给各方进行下一轮训练。

联合决策树算法可以在聚合器中增长树，并基于各方的数据集向各方查询(请求)计数信息。

FL 的整个过程都是为了保证在不共享各方原始数据的情况下，从数据集合中创建一个健壮的机器学习模型！

但这是最优的吗？

虽然 FL 不需要集中管理培训数据，但它也带来了一些新的变化，例如:

• **数据集异质性:**分布的差异、各方不同的数据集大小、不同的属性(即一家航空公司的富客户可能比另一家航空公司多)。因此，整个训练数据集没有共同的属性，如预处理方法、微调算法和模型性能评估。
• 隐私:一些联合学习场景要求不同的参与方(或者甚至是聚合方)不能基于在训练过程中交换的消息(例如，权重)得出关于彼此训练数据的见解
• 技能: FL 需要从机器学习到分布式系统再到密码学的不同技能。很难找到具备所有这些技能的员工。

理想情况下，我们希望在没有部署难度的情况下解决上述问题，尽可能避免打开端口等耗时的过程。

幸运的是，IBM Federated Learning框架解决了上述所有挑战，并且能够轻松地将 FL 集成到高效的机器学习工作流中。

了解一个框架的最好方法就是去玩它！我们需要不止一个政党来检验这一点。但是不要担心，我们可以模拟多方试图从不同的机器训练他们的数据的场景！培训的效果如何？敬请期待，静观其变。

IBM 联合学习

下面的步骤可以在 IBM Federated learning Github repo 的设置部分找到

设置

从克隆这个 repo 开始。然后转到创建的文件夹。

安装所有要求。我真的强烈推荐这个项目使用康达装置。

conda create -n <env_name> python=3.6
conda activate <env_name>

通过运行以下命令安装 IBM FL 包:

pip install <IBM_federated_learning_whl_file>

分割样本数据

这个例子解释了如何在 CNN 上运行联合学习，在 MNIST 数据上用 Keras 训练实现。

我们需要不止一个政党来观察 FL 是如何工作的。我们可以使用generate_data.py在任何集成数据集上生成样本数据。例如，我们可以运行:

python examples/generate_data.py -n 2 -d mnist -pp 200

该命令将从 MNIST 数据集中生成各有 200 个数据点的两个交易方。

创建配置文件

要运行 IBM federated learning，您必须拥有聚合器和各方的配置文件。每个配置文件都包含有关各方的信息。您可以使用generate_configs.py脚本生成这些配置文件。

例如，您可以运行:

python examples/generate_configs.py -m keras_classifier -n 2 -d mnist -p examples/data/mnist/random

这个命令将为keras_classifier模型生成配置，假设有两方。-p是当事人数据的路径。

开始学习

现在把你自己放在每个政党和聚合者的位置上。请记住，在现实生活中，各方和聚合者不会看到彼此的屏幕，但他们会在培训过程中进行协调。

启动聚合器

要启动聚合器，请打开一个终端窗口，运行之前设置的 IBM FL 环境。

1. 在终端运行中:

python -m ibmfl.aggregator.aggregator examples/configs/keras_classifier/config_agg.yml

其中提供的路径是聚合器配置文件路径。

2.然后在终端中，键入START，并按回车键。这意味着聚合器开始接受来自其他方的连接。

登记当事人

要注册新的参与方，请为每个参与方打开一个新的终端窗口，运行之前设置的 IBM FL 环境。

1. 在终端运行中:

python -m ibmfl.party.party examples/configs/keras_classifier/config_party0.yml

其中提供的路径是参与方配置文件的路径。

2.在每一方的终端中，键入START并按回车键。这意味着该方开始接受来自聚合器的连接

3.然后在每一方的终端中，键入REGISTER并按回车键。这意味着各方加入 FL 项目

火车

要启动联合培训，请在聚合器终端中键入TRAIN,然后按 enter 键。

同步

要在各方之间同步模型，请键入SYNC

救援

要保存模型，在您的聚合器终端中键入SAVE，并按 enter 键。

瞧啊。现在每个派对的模型都保存到你的文件夹里了。在真实的场景中，每一方将只看到他们的一个模型文件。

现在我们有了可以用于预测的模型！

停止

记住在聚合器终端和当事人终端都键入STOP来结束实验过程。恭喜你！您的团队刚刚完成培训过程，但没有透露您的数据。

预言；预测；预告

假设你是 0 方，要用模型预测你方的测试数据，你需要做的就是加载模型，预测你方的测试数据。

厉害！你的队伍获得 0.81 的 f1 分数。您不仅保护了您的数据，还获得了一个强大的机器学习模型！

但是 FL 车型相比本土车型性能如何？

我将使用来自 IBM 数据科学和人工智能会议 4 的截图来比较两者之间的性能

从 IBM 数据科学和人工智能会议 4 中检索的图像

如您所见，第 1 方本地模型性能的所有指标，包括准确度、f1、精确度和召回率，都高于本地模型性能！通过合并来自其他来源的数据，您可以获得一个更可靠的模型来预测您所在政党的数据。

结论

恭喜你！您刚刚学习了如何在不共享数据的情况下，在数据集的组合上训练机器学习！最重要的是，设置培训不需要高级技能。

您所需要做的就是在您的项目文件中添加一个配置，指定相关的信息，比如连接、数据、模型。然后在终端上使用一些简单的命令行，同时设置和训练各方。

Github 库以及该框架的文献可以在这里找到。您也可以使用 IBM 联邦学习松弛渠道直接联系框架的开发团队。

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上和我联系。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:

[## 我收集了超过 1k 的顶级机器学习 Github 配置文件，这就是我的发现

从 Github 上的顶级机器学习档案中获得见解

towardsdatascience.com](/i-scraped-more-than-1k-top-machine-learning-github-profiles-and-this-is-what-i-found-1ab4fb0c0474) [## Datapane 简介:构建交互式报表的 Python 库

创建精美报告并与您的团队分享分析结果的简单框架

towardsdatascience.com](/introduction-to-datapane-a-python-library-to-build-interactive-reports-4593fd3cb9c8) [## 如何用 Voronoi 图找到最近的医院

给定美国医院的大型数据集，我们如何快速找到最近的医院？

towardsdatascience.com](/how-to-find-the-nearest-hospital-with-voronoi-diagram-63bd6d0b7b75) [## 如何在数据科学项目中利用 Visual Studio 代码

直到发现一种新的有效方法，我们才意识到我们是多么低效

towardsdatascience.com](/how-to-leverage-visual-studio-code-for-your-data-science-projects-7078b70a72f0) [## 如何用支持向量机学习非线性数据集

支持向量机简介及其在非线性数据集上的应用

towardsdatascience.com](/how-to-learn-non-linear-separable-dataset-with-support-vector-machines-a7da21c6d987)

知识图嵌入简介

原文：https://towardsdatascience.com/introduction-to-knowledge-graph-embedding-with-dgl-ke-77ace6fb60ef?source=collection_archive---------10-----------------------

了解知识图嵌入和两个流行的模型，以产生他们与 DGL 柯

作者:赛勒斯·瓦希德，郑达，乔治·卡里皮斯和巴拉吉·卡马科蒂:AWS AI

知识图(KGs)已经成为一种有效的方法来集成不同的数据源，并为搜索等应用程序建模底层关系。在亚马逊，我们用 KGs 来表示产品之间的层级关系；亚马逊音乐和 Prime Video 上的创作者和内容之间的关系；以及 Alexa 问答服务的信息。以嵌入形式从知识仓库中提取的信息用于改进搜索、推荐产品和推断缺失的信息。然而，很难从具有数百万个节点和数十亿条边的图中训练 KG 嵌入。

亚马逊最近推出了 DGL 客，一个用简单的命令行脚本简化这一过程的软件包。使用DGL-克，用户可以比竞争技术快 2-5 倍的速度为非常大的图形生成嵌入。DGL-KE 通过配置硬件、数据采样参数和损失函数，为用户提供了选择用于生成嵌入和优化性能的模型的灵活性。然而，为了有效地使用这个包，理解嵌入是如何工作的以及计算它们的优化是很重要的。这个由两部分组成的博客系列旨在提供这些信息，并让你准备好开始利用DGL-柯。

什么是图表

图形是用来表示事物及其关系的结构。它由两组组成—一组节点(也称为顶点)和一组边(也称为弧)。每条边本身连接一对节点，表明它们之间存在关系。这种关系既可以是无向，例如捕获节点之间的对称关系，也可以是有向，捕获非对称关系。例如，如果一个图被用来模拟社交网络中的人的友谊关系，那么边将是无向的，因为它们被用来指示两个人是朋友；然而，如果该图用于模拟人们在 Twitter 上如何相互关注，那么这些边将是有向的。根据边的方向性，一个图可以是有向的或无向的。

图形可以是同质或异质。在同构图形中，所有节点代表相同类型的实例，所有边代表相同类型的关系。例如，社交网络是由人和他们的联系组成的图，所有人都代表相同的实体类型。相反，在异构图中，节点和边可以是不同的类型。例如，用于对市场中的信息进行编码的图将具有买方、卖方和产品节点，这些节点通过想买、已买、是的客户，以及是销售的边连接。

最后，另一类对知识图特别重要的图是多图。这些图在同一对节点之间可以有多条(有向)边，也可以包含环。这些多重边通常是不同类型的，因此大多数多重图是异构的。注意，不允许这些多条边和自循环的图被称为简单图。

什么是知识图

在之前的市场图示例中，分配给不同节点类型(买方、卖方、产品)和不同关系类型(想买、已经买、是客户的、是销售的)的标签传达了关于特定域的节点和关系代表什么的精确信息(通常称为语义 ) 。一旦该图被填充，它将对我们关于该市场的知识进行编码，因为它涉及到所包括的节点和关系的类型。这样的图是知识图的一个例子。

知识图(KG)是一种有向异构多重图，其节点和关系类型具有特定于领域的语义。KGs 允许我们将知识编码成一种人类可以理解的形式，并且可以进行自动分析和推理。kg 正在成为一种流行的方法，以通过不同类型的关系连接的不同类型的实体的形式来表示不同类型的信息。

使用 kg 时，我们采用了一种不同于图中使用的传统顶点和边的术语。知识图的顶点通常被称为实体，有向边通常被称为三元组，并且被表示为( h，r，t )元组，其中 h 是头部实体， t 是尾部实体， r 是将头部实体与尾部实体相关联的关系。注意，术语关系在这里指的是关系的类型(例如，想要购买、已经购买、是客户的和是销售的之一)。

现在让我们用石膏来考察一个民族和他们生活的世界。

场景:
玛丽和汤姆是兄妹，他们都是 素食者 ，谁 像 土豆和奶酪。玛丽和汤姆都在亚马逊的和工作。乔是汤姆的 同事 的一个小子。让事情变得复杂的是，乔 爱着 玛丽，但我们不知道这种感觉是否得到了回报。

乔 来自 魁北克并以他的家乡菜 Poutine 为傲，这是由 土豆、奶酪和肉汁组成的 。我们还知道，肉汁 以某种形式含有 肉。

乔很兴奋地邀请汤姆共进晚餐，并偷偷地邀请了他的兄弟姐妹玛丽。他的计划从一开始就注定要失败，因为他打算为素食的兄弟姐妹提供他最喜欢的魁北克菜 Poutine。

哦！顺便说一下，一个地理琐事:魁北克 位于 的一个省的同名省 又位于加拿大的* 。*

这个场景中有几个关系没有明确提到，但我们可以简单地从给出的信息中推断出来:

• 玛丽是汤姆的同事。
• 汤姆是玛丽的同事。
• 玛丽是汤姆的妹妹。
• 汤姆是玛丽的哥哥。
• Poutine 有肉。
• Poutine 不是素菜。
• 玛丽和汤姆不吃布丁。
• 布丁是一道加拿大菜。
• 乔是加拿大人。
• 亚马逊是玛丽、汤姆和乔的工作场所。

一些有趣的负面结论对我们来说似乎是直观的，但对机器来说却不是:

• 土豆不喜欢玛丽。
• 加拿大不是来自乔。
• 加拿大不在魁北克*。*
• …
  我们研究的是一个知识图，一组具有不同关系类型的节点:
• 一对一:玛丽是汤姆的兄弟姐妹。
• 1 对 N: Amazon 是 Mary、Tom 和 Joe 的工作场所。
• n 对 1:乔、汤姆和玛丽在亚马逊工作。
• N 对 N:乔、玛丽和汤姆是同事。

对于这些关系，还有其他的分类观点:

• 对称:乔是汤姆的同事，汤姆也是乔的同事。
• 反对称:魁北克位于加拿大意味着加拿大不能位于魁北克。

图 1 显示了一个 KG，它描述了 Mary 的世界。有关如何使用示例的更多信息，请参考嵌入的代码。

知识图嵌入

*知识图嵌入是知识图中实体和关系的低维表示。它们提供了一个可用于推断关系的总体 KG 的概括上下文。在上面想象的玛丽的世界中，嵌入提供了关于玛丽、乔和汤姆之间关系的洞察力。在更大和更密集的 KG 中，嵌入可以提供关于分子属性相互作用的见解，以加速药物发现或聚集游戏网络中骗子的用户行为。

计算知识图嵌入，使其满足某些性质；也就是说，它们遵循给定的 KGE 模型。这些 KGE 模型定义了不同的得分函数，其测量两个实体相对于其在低维嵌入空间中的关系类型的距离。这些得分函数用于训练 KGE 模型，使得通过关系连接的实体彼此靠近，而未连接的实体远离。

有很多流行的 KGE 模型如 TransE 、 TransR 、 RESCAL 、 DistMult 、 ComplEx 、 RotatE ，这些模型定义了不同的得分函数来学习实体和关系嵌入。DGL-柯使得这些实现可以通过命令行脚本中的一个简单的输入参数来实现。在这篇文章中，我们介绍并比较 TransE 和 TransR 这两种常用方法，为读者提供一些关于模型和权衡的直觉

TransE
基于平移的嵌入模型(TransE) 是一种代表性的平移距离模型，它将实体和关系表示为维度 Rd 的相同语义空间中的向量，其中 d 是具有降低维度的目标空间的维度。源空间中的一个事实被表示为一个三元组(h，r，t)，其中 h 是头部的缩写，r 是关系的缩写，t 是尾部的缩写。该关系被解释为平移向量，使得通过关系 r 连接的嵌入实体具有短距离。[3, 4]*

就向量计算而言，这可能意味着向关系添加头部应该接近关系的尾部或 h+r ≈ t。

TransE 执行线性变换，评分函数是以下各项之间的负距离:

**

运输

TransE 不能涵盖非一对一的关系，因为它只了解相似性的一个方面。TransR 通过将关系空间与实体空间分离来解决这个问题，其中 h，t ∈ ℝᵏ和$r ∈ ℝᵈ.语义空间不需要具有相同的维度。在多关系建模中，我们学习每个关系的投影矩阵 M∈ℝᵏˣᵈ，它可以将实体投影到不同的关系语义空间。这些空间中的每一个都捕获了与不同关系相关的实体的不同方面。在这种情况下，使用学习的投影矩阵 Mᵣ作为 hᵣ=hMᵣ和 tᵣ=tM ᵣrespectively.，将具有关系 r 的头节点 h 和尾节点 t 投影到关系空间中图 4 展示了这个投影。

*让我们用一个例子来探讨这个问题。玛丽和汤姆是兄妹兼同事。他们都是素食者。乔也在亚马逊工作，是玛丽和汤姆的同事。TransE 可能最终为 Mary、Tom 和 Joe 学习到非常相似的嵌入，因为他们是同事，但不能识别(不是)兄弟姐妹关系。使用 TransR，我们学习投影矩阵:M_sibling、M_colleague 和 M _ 素食者，它们在学习类似(非)兄弟的关系方面表现得更好。

TransR 中的 score 函数类似于 TransE 中使用的函数，度量 h+r 和 t 之间的欧氏距离，但是距离度量是每个关系空间的。更正式地说:*

*TransR 相对于 TransE 的另一个优势是它能够提取组成规则。提取规则的能力有两个主要好处。它提供了更丰富的信息和更小的存储空间，因为我们可以从其他规则中推断出一些规则。

权衡
TransR 中更具表现力的投影带来的好处增加了模型的复杂性和更高的数据传输率，这对分布式训练产生了不利影响。TransE 要求每个关系有 O( d )个参数，其中 dd 是 TransE 中语义空间的维度，包括实体和关系。由于 TransR 将实体投影到维度为 kk 的关系空间，因此每个关系将需要 O( kd )个参数。根据 k 的大小，这可能会大幅增加参数的数量。在探索 DGL-柯的过程中，我们将检验DGL-柯在显著提高知识嵌入计算效率方面的优势。[5], [7]*

关于在DGL-克中其他实现的详细概述，请查看我们的文档。

下一步是什么？

在这篇博文中，我们介绍了知识图嵌入(kge)的概念，它们是如何工作的，以及生成 kge 的两种流行方法。在我们的下一篇文章中，我们将探索如何加速与DGL-柯的训练。

参考

1. http://semantic-web-journal.net/system/files/swj1167.pdf
2. 孙志清，智，建，和。旋转:通过复杂空间中的关系旋转嵌入知识图。澳大利亚统计局/1902.10197，2019 年。
3. 知识图嵌入:方法与应用综述，毛振东，，李国。DOI 10.1109/TKDE.2017.2754499，IEEE 知识与数据工程汇刊
4. transE: Antoine Bordes、Nicolas Usunier、Alberto Garcia-Duran、JasonWeston 和 Oksana
   Yakhnenko。翻译用于多关系数据建模的嵌入。神经信息处理系统进展 26。2013.
   5。译者:、林、、孙茂松、、。用于知识图完成的学习实体和关系嵌入。2015 年第 29 届 AAAI 人工智能会议论文集。
5. 重新校准:马克西米利安·尼克尔、沃克·特雷斯特普和汉斯·彼得·克里格尔。多关系数据集体学习的三向模型。《第 28 届国际机器学习会议论文集》，ICML，2011 年 11 月。
6. 调查论文:Q. Wang，Z. Mao，B. Wang 和 L. Guo，“知识图嵌入:方法和应用调查”，载于 IEEE 知识与数据工程汇刊，第 29 卷，第 12 期，第 2724-2743 页，2017 年 12 月 1 日。
7. 主持人:杨碧山、赵文涛、、高剑锋和。在知识库中嵌入用于学习和推理的实体和关系。《学习表征国际会议论文集(ICLR)
   2015，2015 年 5 月。
8. 复合:特鲁永，约翰内斯·韦尔布尔，塞巴斯蒂安·里德尔，埃里克·高西尔和纪尧姆·布沙尔。简单链路预测的复杂嵌入。更正，abs/1606.06357，2016。
9. 孙志清，智，建，和。旋转:通过复杂空间中的关系旋转嵌入知识图。澳大利亚统计局/1902.10197，2019 年。

NumPy 线性代数导论

原文：https://towardsdatascience.com/introduction-to-linear-algebra-with-numpy-79adeb7bc060?source=collection_archive---------12-----------------------

带示例的基本概念和操作

张家瑜在 Unsplash 上拍照

数据以许多不同的格式收集，从数字到图像，从类别到声波。然而，我们需要用数字表示的数据，以便能够在计算机上进行分析。机器学习和深度学习模型需要大量数据。它们的性能高度依赖于数据量。因此，我们倾向于收集尽可能多的数据，以便建立一个稳健而准确的模型。随着数据量的增加，用标量完成的操作开始变得低效。我们需要矢量化或矩阵运算来有效地进行计算。这就是线性代数发挥作用的地方。

线性代数是数据科学领域中最重要的课题之一。在这篇文章中，我们将介绍线性代数中的一些基本术语，并使用 Python 的科学计算库 NumPy 进行示例。

线性代数中有不同类型的对象(或结构):

• 标量:单一数字
• Vector:数字数组
• 矩阵:数字的二维数组
• 张量:N 维数组，其中 n > 2

让我们为每个对象创建一个例子。我将跳过“标量”,因为它只是一个数字。我们首先导入 numpy:

import numpy as np

有 4 个元素的向量:

2x4 矩阵:

2x2x4 张量:

就 numpy 表示而言，向量是一维数组，矩阵是二维数组，张量是 n 维数组(n>2):

我们也可以用 numpy 创建更高维的数组，但是这些很难可视化。让我们创建一个四维数组，每个维度的大小为 2。

数组的总大小是每个维度的大小的乘积。T2 的印刷版本:

我们已经介绍了基本结构。现在是时候讨论可以在这些结构上完成的基本操作了。

向量运算

• 当向量与标量相乘时，向量的每个元素都与标量相乘:

• 另一个常见的操作是点积。两个向量的点积是关于位置的元素乘积的和。一个向量的第一个元素乘以第二个向量的第一个元素，依此类推。这些积的和就是点积，可以用 np.dot() 函数来做。

点积是矩阵乘法的重要部分，我们将在本文后面讨论。

• 向量的元素求和与减法是通过标准的数学运算完成的。

矩阵运算

矩阵乘法是线性代数中一种广泛使用的运算。解线性方程组时，矩阵乘法非常方便。在复杂的机器学习和深度学习模型中，许多矩阵乘法都是在幕后进行的。优化算法执行大量矩阵乘法来寻找模型参数。因此，这是一个必须知道的操作。

在我们深入研究矩阵乘法之前，最好先了解矩阵的一些性质。矩阵是一个二维数组。如果两个维度中的元素数量(大小)相同，那么我们就有了一个方阵。

单位矩阵是一个在主对角线上包含 1，在所有其他位置包含 0 的方阵。

我们用行数和列数来定义矩阵的形状。例如，下面的矩阵 A 有 3 行 4 列。索引从零开始，所以我们可以通过 A[0]访问第一行，通过 A[:，0]访问第一列。可以通过传递行索引和列索引来访问特定的元素。例如，A[1，1]给出了第二行第二列的元素。

两个矩阵的矩阵乘法基于一个矩阵的行与另一个矩阵的列的点积。乘积矩阵的每个元素是第一个矩阵中的一行和第二个矩阵中的一列的点积。考虑下面的矩阵 A1 和 A2。A1 的第一行是[2，2]，A2 的第一列是[1，4]。这两个向量的点积是(2x1)+(2x4)=10，这是乘积矩阵在位置[0，0]的元素。A1 的第三行和 A2 的第三列的点积给出了位置[2，2]处的元素，即 12。

因为第一个矩阵的行乘以第二个矩阵的列，所以第一个矩阵的行数必须等于第二个矩阵的列数。如果我们将 mxn 矩阵(m 行，n 列)乘以 nxk 矩阵，则乘积矩阵的形状为 mxk:

因此，矩阵乘法是不可交换的，这意味着我们不能在乘法中交换矩阵的顺序。因此，AB 不等于 BA。

当我们把一个矩阵和它的逆相乘，我们得到单位矩阵。因此，

请注意，不是所有的矩阵都有逆矩阵。对于具有逆矩阵的矩阵，它必须是方阵(即行数等于列数)。然而，并不是所有的方阵都有逆矩阵。

如果一个方阵有一个逆，称为可逆或非奇异。如果一个方阵没有逆矩阵，它就是一个奇异矩阵。非方阵没有逆矩阵。

单位矩阵的一个重要特征是它在相乘时不会改变矩阵。所以，AI = A .我们用 numpy 确认一下:

正如我们所看到的，对于单位矩阵来说，顺序无关紧要。当从右或左相乘时，它不会改变矩阵。因此，矩阵的左逆等于右逆:

矩阵的逆的逆本身是:

求矩阵的逆矩阵有不同的方法。一种方法叫做排除法。这很简单，但我会把它留到另一篇文章中，以免这篇文章太长。

对矩阵的一个基本操作是转置，这意味着交换行和列。可以使用一个字母(T)和 numpy 来完成:

我们已经讨论了线性代数中的一些基本概念。当然，还有更复杂的概念和操作。然而，从基础到高级一步一步地积累知识总是一个好的做法。

感谢您的阅读。如果您有任何反馈，请告诉我。

线性回归简介

原文：https://towardsdatascience.com/introduction-to-linear-regression-141cde7a46b2?source=collection_archive---------21-----------------------

创建线性回归模型之前要采取的步骤。

在我们开始研究线性回归之前，我想强调在开始处理数据之前理解问题的重要性。我们经常看到统计学家开始谈论斜率、分布和其他实际分析，而没有将问题公式化。正如阿尔伯特·爱因斯坦曾经说过的那样，“问题的表述往往比解决问题更重要，而解决问题可能仅仅是数学或实验技巧的问题”。因此，像所有其他数据分析执行一样，我们需要通过与问题专家合作来制定问题，以便了解特定领域的背景、分析的目标、输出的一致性，并进一步将问题整合到统计术语中。

理解数据收集与制定问题同样重要，因为某些收集过程会对数据产生影响，如果不了解收集过程的某些方面，我们可能会在分析结束时得出错误的结论。理解数据收集的最佳实践有:

• 查看数据是否是从设计好的调查中收集的。
• 探索无响应。我们没有得到回复的某些数据可能对问题和我们的分析非常重要。
• 查找是否有任何缺失值或可能的数据错误，并执行健全性检查。
• 如有必要，查看测量单位是如何设置和执行标准化的。
• 看看定性变量如分类变量是如何编码的。

一旦我们明确了我们的问题并理解了数据是如何收集的，我们就可以执行清理和初始数据分析。我们可以简化为:

• 看数值变量的汇总。
• 参见变量的分布
• 寻找可能的相关性
• 探索任何可能的异常值
• 用数据健全性寻找数据错误。
• 确保数据类型正确。

线性回归的使用

回归简单地给出了数据集中两个或多个变量的线性关系。我们有一个因变量(或预测变量)，与自变量(响应变量)有关系。

我们来复习一些例子，看看能否找到变量之间的关系。在回顾这些数据集时，我们还将讨论为了正确使用线性回归，我们需要做出的某些假设或需要满足的某些条件。

我们的第一组数据是关于英国青少年赌博的。

由于我们没有赌博领域的任何物理背景，我们可以创建一个示例问题陈述来指导我们的分析。这可以简单地理解为“为什么英国青少年赌博？”或者“收入或地位对英国青少年的赌博习惯有影响吗？”或者“教育能帮助减少英国青少年的赌博吗？

我们的数据集中没有缺失值。查看汇总统计数据可以给我们一些提示，看是否有任何数据错误。例如，有些人不在赌博上花钱。我认为这是可信的。最低收入为每周 0.6 英镑。这有意义吗？由于我们没有看到任何明显的错误，如“0”收入或“2”性价值，让我们假设做调查的人准确地收集了这些数据。

基于我们之前定义的问题陈述(“收入或地位对英国青少年的赌博习惯有影响吗？例如)，自变量或响应变量“y”为“gamble”。我们可以看到赌博和收入之间有一些线性关系。我们确实看到了语言和地位之间的一些其他相关性，例如，然而，由于我们试图找到一个特定问题的解决方案，我们可以将重点放在赌博反应变量和收入相关变量(预测因素)上。

在我们开始创建回归模型、预测值、误差、截距或斜率之前，我们应该看看作为预测变量的收入和作为响应变量的赌博之间的当前关系是否满足线性回归所需的某些假设和条件。

为了让我们创建线性回归模型，我们需要确保关系是线性的，误差意义是独立的，残差不相互影响，并且它们不遵循特定的模式，收入和赌博之间存在同方差，以便数据看起来不像漏斗和误差分布的正态性，其中观察值主要围绕预测值并且均匀分布。

我发现解释这些假设最简单的方法是通过可视化。以下四张图解释了数据集需要满足线性回归的每个假设。

当我们查看我们的回归线和每个观察值的位置时，我们可以看到存在某种程度的线性，误差彼此不相关，残差没有创建任何看起来像漏斗的模式，并且它们呈正态分布。这意味着，随着我们的独立变量收入增加，赌博支出(我们的依赖反应变量)也会增加。收入和赌博之间有一个明确的正线性关系。

我们不会在本文中进一步扩展我们的分析和创建回归模型，因为这意味着是对线性回归的介绍，但是我们可以以类似的方式探索其他数据集。

让我们来看看另一项研究，我们观察了 97 名患有前列腺癌的男性，他们将接受根治性前列腺切除术。

正如我们所看到的，我们肯定需要理解变量描述，并且必须咨询前列腺相关领域的专业知识，以便完全阐明问题。下面是每个变量的描述；

• lcavol:癌症卷
• 体重:癌症体重
• 年龄:年龄
• lbph:良性前列腺增生量
• svi:精囊侵犯
• lcp:包膜穿透
• 格里森:格里森得分
• pgg45:格里森得分 4 或 5 的百分比
• lpsa:前列腺特异性抗原

让我们假设问题陈述是“男性有哪些特定的属性会导致前列腺癌？”。这些数据来自一项研究，该研究检测了即将接受根治性前列腺切除术的男性的前列腺特异性抗原水平和许多临床指标之间的相关性。这意味着我们的 y 反应变量(因变量)是 lpsa:前列腺特异性抗原。

我们有 97 个观察值，9 个属性。当我们查看最小值和最大值时，我们唯一有疑问的变量是 svi:精囊侵犯和 pgg45:百分比 Gleason 评分 4 或 5。不幸的是，在没有任何医学专业知识的情况下，我们无法确认这些值是否有意义，或者可能是数据错误。因此，我们假设创建这个数据集的统计学家收集了准确的数据。

当我们查看变量之间的相关性时，请记住我们关注的是 lpsa 的定义响应变量，我们看到癌症体积具有最强的相关性。

当我们观察每个观察值在线性线周围的分布时，我们看到了线性、误差的独立性、同方差性和正态性。我们可以坚定地说，lcavol 自变量和 lpsa 因变量之间存在正的线性相关关系。

结论

不管统计分析，我们需要首先制定一个问题陈述，并了解数据的收集。我们可以通过与领域专家、调查员或商业利益相关者的合作来做到这一点。通过遵循数据汇总统计的简单步骤，如数值变量、分布、相关性、异常值、数据错误和数据类型的汇总，我们可以指出数据错误并定义包括线性回归在内的分析方法。为了能够准确地使用线性回归，我们需要确保满足线性回归条件。因为我们不是从研究人员的角度，而是从数据分析师或数据科学家的角度来看数据，所以我们不一定要对每个条件进行每个测试，而是通过查看某些分布图来假设这些条件。

R 中的列表介绍

原文：https://towardsdatascience.com/introduction-to-lists-in-r-ff6469e6ca79?source=collection_archive---------27-----------------------

列表可以包含不同类型的组件。了解如何创建、命名和子集化这些列表。

什么是列表，为什么需要列表？

有几种数据结构可以用来保存数据:

• 向量(一维数组)—向量可以保存数值、字符或逻辑值，但它们的元素必须都是相同的数据类型。
• 矩阵(二维数组)——就像向量元素一样，矩阵可以保存数字、字符或逻辑值；但是，它们的元素必须都是相同的数据类型。
• 数据框(二维对象)——数据框可以保存数字、字符或逻辑值。在一个列中，所有元素必须具有相同的数据类型，但是不同的列可以具有不同的数据类型。
• 列表(超级数据类型)——列表允许不同的对象，如矩阵、向量、数据框和其他列表，以有序的方式聚集在一个名称(列表的名称)下。这些对象不需要以任何方式相关联。因此，你几乎可以在列表中存储任何东西。

创建列表

我们使用函数[**list()**](http://www.rdocumentation.org/packages/base/functions/list) 来构造一个列表:

my_list <- list(comp1, comp2, ...)

list()函数的参数是列表组件(comp1, comp2,...)。它们可以是矩阵、向量、其他列表等。

假设我们想要创建一个列表(my_list)，它包含以下列表组件:my_vector、my_matrix和my_df。

# Vector with numerics from 1 up to 10
my_vector <- 1:10# Matrix with numerics from 1 up to 9
my_matrix <- matrix(1:9, ncol = 3)# First 10 elements of the built-in data frame mtcars
my_df <- mtcars[1:10,]

为了构建这个列表，我们再次使用了list()函数:

# Construct list with these different elements:
my_list <- list(my_vector, my_matrix, my_df)

创建命名列表

给列表中的组件命名可以确保我们不会忘记它们代表什么。我们可以在构建列表的过程中或者之后命名我们的组件。举个例子，

# Name components directly during list construction.
my_list <- list(name1 = your_comp1, 
                name2 = your_comp2)

创建一个包含名为name1、name2等组件的列表。为了在我们创建列表后给它们命名，我们使用了names()函数，就像我们使用 vectors 一样。这将完成我们上面做的同样的事情:

# Use names() function to name list after construction
my_list <- list(your_comp1, your_comp2)
names(my_list) <- c("name1", "name2")

给你试试

给my_list的组件添加名称。对于my_vector、my_matrix和my_df，可以分别使用vec、mat和df的名称。

# Vector with numerics from 1 up to 10
my_vector <- 1:10# Matrix with numerics from 1 up to 9
my_matrix <- matrix(1:9, ncol = 3)# First 10 elements of the built-in data frame mtcars
my_df <- mtcars[1:10,]# Construct list with these different elements:
my_list <- list(my_vector, my_matrix, my_df)

解决办法

# Vector with numerics from 1 up to 10
my_vector <- 1:10# Matrix with numerics from 1 up to 9
my_matrix <- matrix(1:9, ncol = 3)# First 10 elements of the built-in data frame mtcars
my_df <- mtcars[1:10,]# Adapt list() call to give the components names
my_list <- list(my_vector, my_matrix, my_df)
names(my_list) <- c("vec", "mat", "df")# Print out my_list
my_list

给你尝试(2)

为电影“闪灵”创建一个列表，它包含三个组件:

• moviename —带有电影标题的字符串(存储在mov中)
• 演员 —主要演员名字的向量(存储在act中)
• 评论 —包含一些评论的数据帧(存储在rev中)

# Character variable for movie name
mov <- "The Shining"# Vector for the names of the movie actors
act <- c("Jack Nicholson", "Shelley Duvall", "Danny Lloyd", "Scatman Crothers", "Barry Nelson")# Data frame of the movie reviews
scores <- c(4.5, 4.0, 5.0)
sources <- c("IMDb1", "IMDb2", "IMDb3")
comments <- c("Best Horror Film I have Ever Seen", "A truly brilliant and scary film from Stanley Kubrick", "A masterpiece of psychological horror")
rev <- data.frame(scores, sources, comments)

不要忘记相应地命名列表组件(电影名称、演员和评论)。

不要忘记相应地命名列表组件(名称是电影名称、演员和评论)。

解决办法

# Character variable for movie name
mov <- "The Shining"# Vector for the names of the movie actors
act <- c("Jack Nicholson", "Shelley Duvall", "Danny Lloyd", "Scatman Crothers", "Barry Nelson")# Data frame of the movie reviews
scores <- c(4.5, 4.0, 5.0)
sources <- c("IMDb1", "IMDb2", "IMDb3")
comments <- c("Best Horror Film I have Ever Seen", "A truly brilliant and scary film from Stanley Kubrick", "A masterpiece of psychological horror")
rev <- data.frame(scores, sources, comments)# Shining List
shinning_list <- list(moviename = mov, actors = act, reviews = rev)
shinning_list

从列表中选择元素

列表通常由许多元素和组件组成；因此，从其中获取单个元素、多个元素或一个组件并不总是简单的。

选择组件的一种方法是使用组件的编号位置。例如，要选择第一个组件(位置1，我们将使用:

my_list[[1]]

注意，这与向量和矩阵不同，向量和矩阵使用单方括号[]而不是双方括号[[]]。

我们也可以使用组件的名称来代替位置。我们可以使用[[]]或与$一起使用。例如，以下两种情况都将从shining_list中选择reviews组件。

shining_list[["reviews"]]
shining_list$reviews

有时，您希望深入构件并从选定的构件中选择特定的元素。例如，假设我们想要从shining_list的 actors 数组中选择第一个元素。数组actors是第二个组件，因此可以使用shining_list[[2]]来访问它。由于这个组件也被命名，我们可以使用shining_list$actors来获得相同的结果。

因为我们想要从那个组件中选择第一个元素[1]，我们将使用shining_list[[2]][1]或shining_list$actors[1]。

让你试试

给定下面的shining_list，选择actors向量并打印出来。然后从这个向量中选择第二个元素并打印出来。

# Character variable for movie name
mov <- "The Shining"# Vector for the names of the movie actors
act <- c("Jack Nicholson", "Shelley Duvall", "Danny Lloyd", "Scatman Crothers", "Barry Nelson")# Data frame of the movie reviews
scores <- c(4.5, 4.0, 5.0)
sources <- c("IMDb1", "IMDb2", "IMDb3")
comments <- c("Best Horror Film I have Ever Seen", "A truly brilliant and scary film from Stanley Kubrick", "A masterpiece of psychological horror")
rev <- data.frame(scores, sources, comments)# Shining List
shinning_list <- list(moviename = mov, actors = act, reviews = rev)

解决办法

# Print out the vector representing the actors
shining_list$actors# Print the second element of the vector representing the actors
shining_list$actors[2]

挑战:创建另一个列表

这里有一个挑战来检验你所学到的东西！

假设你已经找到了另一部更近的杰克·尼科尔森电影《无间道》的评论。

这部电影的演员是:

• 莱昂纳多·迪卡普里奥
• 马特·达蒙
• 杰克·尼科尔森
• 马克·沃尔伯格
• 维拉·法梅加
• 马丁·辛

以下是评论:

• 会再看一遍——4.61
• 太神奇了！— 5
• 我喜欢——4.81 分
• 最佳电影之一— 5
• 迷人的情节— 4.2

将关于电影的所有信息(如片名、演员和评论)收集到一个变量中会很有用。由于这些数据是不同的类型，我们必须将它们组合在一个列表变量中。

现在，利用上面给出的信息，你要做的是:

• 创建一个名为movie_title的变量，包含电影的标题。
• 创建一个名为movie_actors的向量，包含上面列出的演员的名字。
• 创建两个向量，称为scores和comments，包含来自上面显示的评论的信息。
• 求复习分数的平均值(scores向量)，保存为avg_review。
• 创建一个名为reviews_df的 reviews 数据框架，它结合了scores和comments。
• 创建一个名为departed_list的列表，包含movie_title、movie_actors，评审数据框为reviews_df，平均评审分数为avg_review，并将其打印出来。

解决办法

# Use the given movie information above to define the movie title and movie actors
movie_title <- "The Departed"
movie_actors <- c("Leonardo DiCaprio", "Matt Damon", "Jack Nicholson", "Mark Wahlberg", "Vera Farmiga", "Martin Sheen")# Use the reviews information above to defined defined the comments and scores vectors
scores <- c(4.6, 5, 4.8, 5, 4.2)
comments <- c("I would watch it again", "Amazing!", "I liked it", "One of the best movies", "Fascinating plot")# Save the average of the scores vector as avg_review
avg_review <- mean(scores)# Combine scores and comments into the reviews_df data frame
reviews_df <- data.frame(scores, comments)# Create and print out a list, called departed_list, which contains movie_title, movie_actors, reviews_df, and avg_review
departed_list <- list (movie_title, movie_actors, reviews_df, avg_review)
departed_list

笔记

所有图片，除非特别注明，均归作者所有。横幅图像是使用 Canva 创建的。

机器翻译导论

原文：https://towardsdatascience.com/introduction-to-machine-translation-5613f834e0be?source=collection_archive---------43-----------------------

自然语言处理笔记

自然语言处理专业课程 1 第 3 周笔记

由布鲁诺·沃尔夫在 Unsplash 上拍摄的照片

之前，我们已经介绍过情感分析和向量空间模型。本周我们将学习如何进行机器翻译，但是通过练习如何找到相似的单词向量，我们也将知道如何执行文档搜索，这样我们将一举两得。

要访问我在 Coursera 上关于自然语言处理专业化的所有笔记，请访问关于走向数据科学的自然语言处理系列部分。

转换单词向量

在向量空间模型的帖子中，我们讨论了单词向量以及它们如何捕捉单词的重要属性。由于这一点，我们可以使用这些词向量来对齐两种不同语言的词，以获得一个基本的翻译程序。

机器翻译是从一个单词(句子或文档)开始，将其翻译成另一种语言的任务—参见图 1 。

图 1 :机器翻译的任务是从一种语言翻译成另一种语言。图像中显示的示例显示英语→法语。(图片由作者提供)

如果我们要让一个人来执行这项任务，我们首先要找到一个会说两种语言的人，并让他们创建一个英语和法语单词的大列表(使用图 1 中的例子)，这可能是一项非常耗时的任务。

另一方面，如果我们希望机器执行这项任务，我们首先计算与每种语言相关的单词嵌入，然后检索该语言的一个单词的特定单词嵌入，例如，我们可以检索英语单词 cat，然后想出一种方法将英语单词嵌入转换为在法语单词向量空间中有意义的单词嵌入。有了翻译语言中的这个单词向量(在我们的场景中是法语向量空间),我们将找到与该单词最相似的向量，这些向量将成为我们翻译的候选单词。在我们的示例场景中，我们希望提出单词“chat ”,因为这是 cat 的法语单词— 图 2 提供了对该任务的可视化解释。

图 2 :机器翻译任务的视觉呈现(图片由作者提供)

但是我们如何实现你所说的转变呢？太好了。如果你记得在线性代数中，取矩阵 A(1x2 矩阵)和矩阵 B(2 x2 矩阵)的点积，得到的矩阵 C 将是 1 x2 矩阵。也就是说，我们需要找到一个矩阵， R，，我们可以用它来转换我们的英语单词嵌入， X ，找到想要的法语单词嵌入， Y 。—参见“ 如何乘矩阵 ”来刷新你的记忆。

图 3 :问题陈述的定义(图片由作者提供)

注:为此，我们初始化一个随机矩阵， R ，并执行梯度下降来求解 R ，目标是最小化 XR 和 Y 之间的距离。此外，我们不需要所有英语单词 X 到法语单词 Y 的映射，因为一个子集就足够了。如果模型在子集上做得很好，它也可以用来推断不属于原始训练集 x 的单词。

当然，一旦执行了这个步骤，我们需要找到单词向量的最近邻居，因为转换的英语单词不一定与法语单词向量空间中的任何单词向量相同，但重要的是它在法语单词向量空间中。

在这种情况下，我们应该搜索法语单词，以找到与我们通过转换创建的单词相似的单词。一种方法是使用 K-最近邻算法，我们已经在“ 从头开始算法:K-最近邻 ”系列中广泛讨论了该算法。

[## 从头开始的算法:K-最近邻

从头开始详述和构建 K-NN 算法

towardsdatascience.com](/algorithms-from-scratch-k-nearest-neighbors-fe19b431a57)

您可能还记得 K-Nearest Neighbors 算法中的“对于我们来说，要确定 K 个最接近新实例的记录，我们必须对所有实例进行测量”，这对于找到最接近我们要翻译的单词的实例是不必要的，因为将会有一些向量与我们拥有的单词向量完全不同。因此，我们必须找到一种方法来将向量空间划分为区域，因此我们在区域内进行搜索。

如果我们要将数据组织到区域中，以便我们可以有效地在这些区域中搜索相似的向量，我们必须引入哈希表。哈希表对于任何涉及数据的工作都是有用的工具。

哈希表

我们可以通过一些相似性函数将数据分组到桶中——参见图 4*。*

图 4 :将数据分组到桶中(图片由作者提供)

除了映射到每个桶的形状是单词向量而不是形状之外，将我们的文本数据分组到桶中以便我们在各个区域中执行 K-最近邻居搜索的任务类似于上面的示例。

因此，将我们的单词向量映射到散列值需要我们找到一个称为“散列函数的映射，它将我们的向量映射到散列值，即散列函数(向量)→散列值。

然而，需要注意的是，我们的目标是将相似的词向量放入相同的桶中。为此，我们需要做一些叫做“位置敏感散列”的事情。位置敏感哈希是一种哈希方法，它非常关心基于项目在向量空间中的位置来分配项目。

位置敏感散列法

当在高维空间中实现 K-最近邻时，位置敏感散列是一种非常重要的技术，这主要是因为它降低了寻找 K-最近邻的计算成本。根据维基百科的说法，它可能被定义为一种算法技术，以高概率将相似的输入项散列到相同的“桶”中。

如果我们想知道一些向量是否靠得很近，我们首先用平面划分向量空间，这有助于我们根据向量的位置将它们分成子集。

图 5: 2d 向量空间示例(图片由作者提供)

紫色平面将空间分割成位于其上方或下方的向量。我们突出显示的浅蓝色向量似乎都在紫色平面上方，而灰色向量在(我不知道确切的颜色)深蓝色平面上方。因此，这些平面可以帮助我们根据它们的位置将向量分成散列，方法是在平面的法向量和代表我们数据的向量之间进行点积，这将为我们提供相对于平面的相对位置。

然而，如果我们应该把我们的数据分成可管理的区域，我们可能要使用不止一个平面。对于每个平面，我们可以确定一个向量是在该平面的+侧还是-侧。因此，我们最终会得到多个信号，每个平面一个信号，利用这些信息，我们必须找到一种方法，将所有这些信号组合成一个哈希值，该哈希值将定义向量空间内的一个特定区域。

注 : 什卡·古普塔写了一篇关于地区敏感哈希的精彩文章，我推荐你去看看更全面的解释。

近似最近邻居

我们无法确切知道哪组平面是划分我们的随机平面的最佳方式，因此为了在我们的不确定性中变得更舒适，一种解决方案可能是创建多组随机平面，以便我们可以将向量空间划分成多个独立的哈希表组。

我们现在可以利用不同组的随机平面来帮助我们找到一组好的友好邻域向量或 k-最近邻。

图 6 :随机平面集合；紫色向量表示英语单词向量到法语单词向量的转换。突出显示的颜色表示根据随机平面已经被分配到相同散列桶的向量。(图片由作者提供)

通过将多组随机平面用于位置敏感散列，我们有了一种更健壮的方式来搜索向量空间，以寻找作为最近邻居的潜在候选的一组向量。我们称之为“近似最近邻”，因为我们没有搜索整个向量空间——为了效率，我们牺牲了精度。

搜索文档

有了更快版本的 K-Nearest Neighbors，我们还可以执行各种其他任务，例如文档搜索，它包括在大量文档中搜索与查询相关的文本。

为了将一个文档表示为一个向量，我们可以从获取单词向量的总和开始——参见图 7

图 7 :将文档表示为向量。(图片由作者提供)

要执行这项任务，我们只需为文档和查询创建向量，并应用 KNNeighbors 来查找与我们的查询最相似的文档。

包裹

谢谢你读到这篇文章的结尾。这就结束了自然语言处理专业的课程 1。到目前为止写的所有笔记，请访问自然语言处理笔记 —寻找我在课程 2 上的笔记。

如果你有兴趣开始自己的博客，或者你想在 2021 年认真对待博客，请订阅我的 Youtube 频道，每周更新关于如何开始你的旅程。如果你已经开了一个博客，里面可能还有对你有用的东西，所以我会订阅，这样你就不会错过了！—首个视频将于本周日发布！

[## 库尔蒂斯·派克斯

欣赏您喜爱的视频和音乐，上传原创内容，并在上与朋友、家人和全世界分享这些内容…

www.youtube.com](https://www.youtube.com/channel/UCu6zdBQhvEY5_j-ifHWljYw?view_as=subscriber)

一如既往，让我们在 LinkedIn 上继续对话…

[## Kurtis Pykes -数据科学家-自由职业者，自由职业者| LinkedIn

在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有 3 个工作列在他们的…

www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)

机器翻译导论

原文：https://towardsdatascience.com/introduction-to-machine-translation-9cb0e93e7cb?source=collection_archive---------38-----------------------

从传统的机器学习到先进的深度学习方法

来源:https://pixabay.com/

来源: 我是跟随斯坦福大学关于深度学习的自然语言处理的课程后写的这篇文章。本课程在 YouTube 上有 的介绍，本文的大部分内容都来自于此。

需求: 在深入研究本文之前，我会建议你确保自己了解自然语言处理和深度学习的基础知识。如果你从未听说过解析或者单词嵌入，你可以阅读 这篇教程 。如果你从未听说过神经网络(尤其是递归神经网络)或反向传播，我建议你阅读这篇文章作为介绍。

介绍

我们亲爱的星球被 7000 多种语言所丰富，感谢科技，我们生活在一个越来越全球化的世界。翻译已经成为沟通的支柱，让人们可以建立各种联系。要真正了解翻译的重要性，这里有一个关键数字:2015 年，谷歌翻译每天处理 1000 亿个单词。我们用机器翻译解决的范例如下:

给我们一个源语言(比如法语)和一个目标语言(姑且说英语)。我们的目标是将一个句子从源语言翻译成目标语言。

从数学上来说，我们希望找到给定法语句子 x 的最佳英语句子 y。这可以用概率来表示:

传统机器学习翻译系统

统计机器翻译(SMT) 于 90 年代推出，试图从数据中学习概率模型。

我们可以使用贝叶斯法则分解我们试图求解的方程(见上文):

使用贝叶斯规则的概率公式

• P(x|y)被称为翻译模型，在平行语料库上训练。这个模型知道法语单词或英语单词如何相互翻译。
• P(y)被称为语言模型，在纯英语语料库上训练。语言模型是一个可以预测下一个单词的系统。

法语和英语句子对齐的图示

为了训练翻译模型，我们正在寻找法语和英语表达之间的对齐。这种排列(见图)远非微不足道。一个法语单词可以与一系列英语单词对齐(一对多对齐)，一系列法语单词也可以与一个英语单词对齐(多对一对齐)。经过许多步骤的构建，排列看起来像这样。

等式的另一部分是通过语言模型获得的。对于每一个单词，你在目标语言中都有潜在的候选词。我们使用语言模型来选择听起来不错的候选词。

总结这些 SMT 模型，它们是好的系统，但极其复杂。它们一直使用到 2014 年，需要大量人力来维护。例如，你需要为你想翻译的所有语言建立一个对比表。

2014 年，机器翻译界出现了深度学习。

深度学习拯救世界

神经机器翻译(NMT) 是机器翻译领域的一次革命，主要是因为它使用了单一的神经网络架构。这种架构被称为序列到序列，涉及两个 rnn:一个编码器和一个解码器。

编码器 RNN 将产生源句子的编码，而解码器 RNN 是一个语言模型，根据编码产生目标句子。

一个基于 RNN 的翻译模型的图示

与 SMT 相反，这里我们直接计算 P(y|x):

每一项都是给定到目前为止翻译的单词和源句子 x 的下一个目标单词的概率。与 SMT 相比，这是一个很大的优势，因为这个过程很简单。

消失/爆炸梯度问题

在训练阶段，我们通过反向传播得到梯度。但在实践中，梯度下降并不是很有效，除非我们小心谨慎。问题是，我们需要学习长时间窗口内的依赖性，梯度可能会爆炸或消失。这个著名的问题发生在任何使用基于梯度的优化技术的网络中。更多详情，请参见本课程。

为了解决这个问题，我们可以使用简单的技巧:

• **渐变裁剪:**基本上，我们通过重新缩放来防止渐变爆炸。
• **输入反转:**训练远距离依存关系非常困难，比如输入句子的第一个单词和输出句子的第一个单词之间。我们可以通过颠倒输入句子中单词的顺序来解决这个问题。这个原理用于双向 rnn。
• **身份初始化:**如果你的网络计算身份函数，梯度计算将非常稳定，因为雅可比矩阵就是身份矩阵。这表明，我们可以通过鼓励计算接近恒等函数来保持稳定。有了这个窍门，激活功能都恢复了。

或者，我们也可以改变编码器/解码器 rnn 的架构:

• 长-短时记忆(LSTM):
  它使用 4 个门，旨在使长时间记忆信息变得容易，直到需要为止。阅读这篇文章了解更多关于 LSTM 的信息。
• 门控递归单元(GRU):
  GRU 是 LSTM 的一个更简单的变体，用于解决消失梯度问题。它使用两个门。详见本文。与 LSTM 相比，GRU 的参数更少，因此计算效率更高，需要的数据更少。

GRU 插图— 图像来源

BLEU:评估翻译的分数

一般来说，在机器学习中，评估算法的性能非常简单。然而，当涉及到翻译时，问题要复杂得多。BLEU(双语评估替读)是一种用于评估机器翻译文本质量的算法。它将机器翻译与一个或几个人工翻译进行比较，并计算 0 到 1 之间的相似性得分。完全匹配的得分为 1，而完全不匹配的得分为 0。BLEU 评分是当今最常用的基准指标。尽管这一指标并不完美，但它具有易于解释和计算的优点。

布雷特·乔丹在 Unsplash 上的照片

但是 BLEU score 面临一个主要问题:它是不可微的，因此基于梯度的优化方法不能直接应用。在训练阶段的优化损失和测试阶段的评估标准之间存在不匹配。

神经机器翻译在统计翻译上的五大胜利:

1. 单个神经网络的端到端训练。所有参数都被优化以最小化网络输出的损失函数。
2. 分布式表示允许更好地利用单词和短语的相似性。
3. 更好地利用上下文。
4. 更流畅的文本生成。
5. 需要更少的人工工程。以前，单词和短语在很大程度上是独立翻译的，现在我们将整个输入句子视为一个翻译单元

还有两个缺点

1. 隐藏表示的固定尺寸。编码器的最后一个向量必须捕捉句子的全部含义。这在大句子的情况下可能是个问题。此外，输入的一个单词可能需要更多的关注，因为它对翻译有影响。我们将看到注意力机制如何解决这个问题。
2. **没有零炮翻译。**只有系统在训练阶段发现两种语言之间的翻译，才能进行翻译。这个问题被谷歌的多语言神经机器翻译系统解决了。

注意机制:

我们让模型学习如何为每个输出时间步长生成一个上下文向量，而不是将输入序列编码成一个固定的上下文向量(即。每个单词)。一个评分功能会对编码器 RNN 产生的每个位置进行评分，并指出应该注意的地方。这允许解码器网络**“聚焦”在编码器输出的特定部分**。

注意力显著提高了 NMT 的表现。另一个优点是，由于注意力的分布，它提供了可解释性。

这种架构用于谷歌神经机器翻译系统的核心，或 GNMT:

注意机制图解—来源:https://ai . Google blog . com/2016/09/a-neural-network-for-machine . html

谷歌的多语言神经机器翻译系统

为了解决零镜头翻译问题，GMNMT 引入了一个简单的数据调整，即在原始的神经机器翻译架构中添加一个人工令牌来指示所需的目标语言。

假设我们用 Japanese⇄English 和 Korean⇄English 的例子训练了一个多语言系统，如动画中的蓝色实线所示。我们能在系统从未见过的语言对之间进行翻译吗？这方面的一个例子是朝鲜语和日语之间的翻译，其中 Korean⇄Japanese 的例子不向系统显示。令人印象深刻的是，答案是肯定的。它可以生成合理的 Korean⇄Japanese 译文，尽管从未有人教过它这么做。我们称之为“零镜头”翻译，如动画中黄色虚线所示。

插图零投学习—来源:https://ai . Google blog . com/2016/11/Zero-shot-translation-with-Google . html

结论

机器翻译介绍到此结束，希望你喜欢这篇文章！机器翻译是一个很有意思的领域，绝不是解决了。在我们能够翻译的语言的多样性以及翻译的质量方面仍有改进的余地。

神经网络背后的数学简介

原文：https://towardsdatascience.com/introduction-to-math-behind-neural-networks-e8b60dbbdeba?source=collection_archive---------0-----------------------

由作者使用创建

让我们深入研究神经网络和深度学习背后的数学

今天，通过开源机器学习软件库，如 TensorFlow 、 Keras 或 PyTorch ，我们可以只用几行代码创建一个神经网络，即使结构非常复杂。话虽如此，神经网络背后的数学对我们一些人来说仍然是一个谜，拥有神经网络和深度学习背后的数学知识可以帮助我们理解神经网络内部发生的事情。它也有助于架构选择、深度学习模型的微调、超参数调整和优化。

介绍

很长一段时间，我忽略了理解神经网络和深度学习背后的数学，因为我没有很好的代数或微积分知识。几天前，我决定从头开始，推导神经网络和深度学习背后的方法论和数学，以了解它们如何以及为什么工作。我也决定写这篇文章，对我这样觉得很难理解这些概念的人会有用。

感知器

感知机——由 Frank Rosenblatt 于 1958 年发明，是最简单的神经网络，由 n 个输入、仅一个神经元和一个输出组成，其中 n 是我们数据集的特征数量。通过神经网络传递数据的过程被称为前向传播，在感知器中执行的前向传播在以下三个步骤中解释。

第一步:对于每一次输入，将输入值 xᵢ 与权重 wᵢ 相乘，并将所有相乘后的值相加。权重——代表神经元之间连接的强度，并决定给定输入对神经元输出的影响程度。如果权重 w₁的值大于权重 w₂，则输入 x₁对输出的影响将大于 w₂.

输入和权重的行向量分别为 x = [x₁，x₂，…，xₙ]和 w = [w₁，w₂，…，wₙ】，它们的 点积 由下式给出

因此，总和等于矢量 x 和 w 的点积**

第二步:将偏差 b 加到相乘值的总和上，我们称之为 z 。大多数情况下，偏置(也称为失调)是必需的，它将整个激活函数向左或向右移动，以产生所需的输出值。

步骤 3 :将 z 的值传递给一个非线性激活函数。激活函数——用于将非线性引入神经元的输出，没有激活函数，神经网络将只是一个线性函数。此外，它们对神经网络的学习速度有重大影响。感知器具有二元阶跃函数作为其激活函数。然而，我们将使用 s igmoid — 也称为逻辑函数作为我们的激活函数。

其中 σ 表示 s igmoid 激活函数，正向延拓后得到的输出称为预测值t28】ŷ。

学习算法

学习算法由两部分组成——反向传播和优化。

反向传播:**反向传播，简称误差反向传播，是指计算损失函数相对于权重的梯度的算法。然而，该术语通常用于指代整个学习算法。在感知器中执行的反向传播在以下两个步骤中解释。

步骤 1 :使用损失函数来估计我们离期望的解决方案有多远。通常，回归问题选择均方误差作为损失函数，分类问题选择交叉熵*。让我们来看一个回归问题，它的损失函数是均方误差，它是实际值 (yᵢ)和预测值 ( ŷᵢ)之差的平方。*

为整个训练数据集计算损失函数，并且它们的平均值被称为成本函数* C 。*

为了给我们的感知机找到最佳的权重和偏差，我们需要知道成本函数是如何随着权重和偏差而变化的。这是在梯度* s ( *变化率)的帮助下完成的——一个量如何相对于另一个量变化。在我们的例子中，我们需要找到成本函数相对于权重和偏差的梯度。

让我们使用偏导数计算成本函数 C 相对于权重 wᵢ 的梯度。由于成本函数与权重 wᵢ没有直接关系，我们使用链式法则。

现在我们需要找到以下三个梯度

让我们从 c ost 函数© 相对于预测值* ( ŷ)的梯度开始*

设 y = [y₁，y₂，… yₙ]和 ŷ =[ ŷ₁，ŷ₂，… ŷₙ]为实际值和预测值的行向量。因此，上述等式简化为

现在让我们找出预测值*相对于 *z 的梯度。这会有点长。

z 相对于重量 wᵢ 的倾斜度为

因此我们得到，

偏见呢？—偏置理论上被认为具有恒定值的输入 1 。因此，

优化:**优化是从一组可用选项中选择最佳元素，在我们的例子中，是选择感知器的最佳权重和偏差。让我们选择梯度下降作为我们的优化算法，其改变权重和偏差*，与成本函数相对于相应权重或偏差的梯度的负值成比例。学习率 ( α )是一个超参数，用于控制权重和偏差变化的幅度。*

如下更新权重和偏差，并重复反向传播和梯度下降，直到收敛。

最后的想法

我希望你已经发现这篇文章很有用，并且理解了神经网络和深度学习背后的数学。我在这篇文章中解释了单个神经元的工作。然而，这些基本概念通过一些修改适用于所有类型的神经网络。

R 中矩阵的介绍

原文：https://towardsdatascience.com/introduction-to-matrices-in-r-dc009e3cdbb3?source=collection_archive---------49-----------------------

学习如何创建矩阵，了解如何用它们做基本的计算。

什么是矩阵？

矩阵是排列成固定数量的行和列的相同数据类型(数字、字符或逻辑)元素的集合。二维矩阵仅适用于行和列。

R 中的[**matrix()**](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/matrix)函数创建一个矩阵。考虑下面的例子:

matrix(1:9, byrow=TRUE, nrow = 3)

这将构造一个包含 3 行的矩阵，包含 1 到 9 的数字，按行填充。

在matrix()功能中:

• 第一个参数是 R 将排列到矩阵的行和列中的元素的集合。这里，我们使用了1:9(这个和c(1,2,3,4,5,6,7,8,9)一样(见 R 中的向量)。这是一个可选参数，可以在以后填充。如果我们把它留空，矩阵就不会被填充。
• 参数byrow表示矩阵是按行填充的。如果我们希望矩阵按列填充，我们将这个参数设置为FALSE(即byrow=FALSE)。默认情况下，矩阵由列byrow=FALSE填充。

# Row-wise  # Column-wise
   1 2 3        1 4 7
   4 5 6        2 5 8
   7 8 9        3 6 9

• 第三个参数nrow表示所需的行数。nrows=3表示矩阵应该有三行。

还有其他论点，如:

• ncol表示所需的列数。

从向量创建矩阵

让我们来分析一下《星球大战》系列的票房数字。

下面是三个向量，每个向量定义了前三部《星球大战》电影之一的票房数字。每个向量的第一个元素表示美国票房收入，第二个元素表示非美国票房(来源:维基百科)。

# Box office Star Wars (in millions)
new_hope <- c(460.998, 314.4)
empire_strikes <- c(290.475, 247.900)
return_jedi <- c(309.306, 165.8)

要从这三个向量构建一个矩阵，我们首先需要将这三个向量合并成一个。

box_office <- c(new_hope, empire_strikes, return_jedi)

然后我们使用matrix()函数构建一个矩阵。第一个参数是向量box_office，包含所有票房数字。接下来，我们必须指定nrow=3和byrow=TRUE来构建按行填充 3 行的矩阵(第一列代表美国收入，第二列代表非美国收入)。

star_wars_matrix <- matrix(box_office, byrow=TRUE, nrow=3)

总的来说，代码应该是这样的。

结果矩阵将是一个 3 行乘 2 列的“表格”。

命名矩阵

向矩阵的行和列添加名称通常有助于记住矩阵中存储的内容。它不仅有助于读取数据，还有助于从矩阵中选择某些元素。我们可以通过使用函数colnames()和rownames()来实现这一点。

rownames(my_matrix) <- row_names_vector
colnames(my_matrix) <- col_names_vector

要按区域和标题命名列，需要表示这些名称的向量。

# Vectors region and titles, used for naming
region <- c("US", "non-US")
titles <- c("A New Hope", "The Empire Strikes Back", "Return of the Jedi")

要用region向量命名star_wars_matrix的列，必须使用colnames()。

# Name the columns with region
colnames(star_wars_matrix) <- region

要用titles向量命名star_wars_matrix的行，必须使用rownames()。

# Name the rows with titles
rownames(star_wars_matrix) <- titles

您的代码现在应该像这样:

# Box office Star Wars (in millions)
new_hope <- c(460.998, 314.4)
empire_strikes <- c(290.475, 247.900)
return_jedi <- c(309.306, 165.8)# Construct matrix
star_wars_matrix <- matrix(c(new_home, empire_strikes, return_jedi), nrow = 3, byrow = TRUE)# Vectors region and titles, used for naming
region <- c("US", "non-US")
titles <- c("A New Hope", "The Empire Strikes Back", "Return of the Jedi")# Name the columns with region
colnames(star_wars_matrix) <- region# Name the rows with titles
rownames(star_wars_matrix) <- titles# Print out star_wars_matrix
star_wars_matrix

使用 colnames()和 rownames()函数后，矩阵现在被标记。

备选方案:使用 dimnames 参数

矩阵的dimnames属性可用于命名矩阵的行和列。dimnames属性接受长度为 2 的list,分别给出行名和列名。也就是说，

dimnames = list(row_vector,column_vector)

所以，在构造矩阵时，我们可以直接标记它。

# Construct star_wars_matrix
box_office <- c(460.998, 314.4, 290.475, 247.900, 309.306, 165.8)
star_wars_matrix <- matrix(box_office, nrow = 3, byrow = TRUE, dimnames = list(c("A New Hope", "The Empire Strikes Back", "Return of the Jedi"),c("US, "non-US")))

计算行总计

一部电影的一个重要统计数据是它的全球票房数字。要计算三部《星球大战》电影的总票房收入，你需要确定美国收入和非美国收入的总和。

函数rowSums()计算矩阵每行的总数，并创建一个新的向量:

rowSums(my_matrix)

让你试试

计算三部电影的全球票房数字。

解决办法

# Construct star_wars_matrix
box_office <- c(460.998, 314.4, 290.475, 247.900, 309.306, 165.8)
star_wars_matrix <- matrix(box_office, nrow = 3, byrow = TRUE, dimnames = list(c("A New Hope", "The Empire Strikes Back", "Return of the Jedi"),c("US, "non-US")))# Calculate worldwide box office figures
worldwide_vector <- rowSums(star_wars_matrix)

我们得到每部电影的总票房收入，而不考虑地区。

向矩阵中添加列

您可以使用[cbind()](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/cbind)功能向矩阵添加一列或多列，该功能按列将矩阵和/或向量合并在一起。例如:

big_matrix <- cbind(matrix1, matrix2, vector1, ...)

让你试试

在上一个练习中，您计算了包含三部电影的全球票房收入的向量。然而，这个向量还不是star_wars_matrix的一部分。将此向量作为新列添加到矩阵中，并将结果赋给新矩阵。

解决办法

# Construct star_wars_matrix
box_office <- c(460.998, 314.4, 290.475, 247.900, 309.306, 165.8)
star_wars_matrix <- matrix(box_office, nrow = 3, byrow = TRUE, dimnames = list(c("A New Hope", "The Empire Strikes Back", "Return of the Jedi"),c("US, "non-US")))# Calculate worldwide box office figures
worldwide_vector <- rowSums(star_wars_matrix)# Bind the new variable worldwide_vector as a column to star_wars_matrix
all_wars_matrix <- cbind(star_wars_matrix, worldwide_vector)

all_wars_matrix 现在包括美国收入、非美国收入以及这两项的总和。

添加一行

要添加列，可以使用[**cbind()**](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/cbind)。要添加一行，可以使用[**rbind()**](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/cbind)。rbind()函数接受一系列向量或矩阵参数，并按行组合它们。举个例子，

big_matrix <- rbind(matrix1, matrix2, vector1, ...)

让你试试

就像你用原三部曲的数据创建star_wars_matrix一样，用前传三部曲的类似数据创建第二个矩阵。

然后使用rbind()来合并两个矩阵，首先是原三部曲的数据，然后是前传的数据。

解决办法

# Construct star_wars_matrix
box_office <- c(461.0, 314.4, 290.5, 247.9, 309.3, 165.8)
star_wars_matrix <- matrix(box_office, nrow = 3, byrow = TRUE, dimnames = list(c("A New Hope", "The Empire Strikes Back", "Return of the Jedi"), c("US", "non-US")))# Construct star_wars_matrix2
box_office2 <- c(474.5, 552.5, 310.7, 338.7, 380.3, 468.5)
star_wars_matrix2 <- matrix(box_office2, nrow = 3, byrow = TRUE, dimnames = list(c("The Phantom Menace", "Attack of the Clones", "Revenge of the Sith"), c("US", "non-US")))# Combine both Star Wars trilogies in one matrix
all_wars_matrix <- rbind(star_wars_matrix, star_wars_matrix2)

新的矩阵应该按地区列出原版和前传的收入。

计算列总计

类似于我们如何使用rowSums()来计算每行的总和，我们也可以使用[**colSums()**](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/colSums)来计算矩阵每列的总和。

rowSums(my_matrix)

让你试试

使用之前练习中构建的all_wars_matrix，计算整个传奇在美国和非美国地区的总票房收入。

解决办法

# Total revenue for US and non-US
total_revenue_vector <- colSums(all_wars_matrix)

矩阵元素的选择

与向量类似，方括号[]可用于从矩阵中选择一个或多个元素。因为矩阵是二维的，所以需要逗号来分隔行和列。例如:

• my_matrix[1,2]选择第一行第二列的元素(第 1 行，第 2 列)
• my_matrix[1:3, 2:4]返回包含第 1 行到第 3 行、第 2 列到第 4 列的数据的矩阵。

要选择一行中的所有元素，在列后不需要数字。要选择一列的所有元素，在该列前不需要数字。

• my_matrix[,1]选择第一列的所有元素。
• my_matrix[1,]选择第一行的所有元素。

让你试试

计算所有电影的平均非美国收入(提示:选择all_wars_matrix的整个第二列，并使用mean()函数)。

解决办法

# Select the non-US revenue for all movies
non_us_all <- all_wars_matrix# Average non-US revenue
mean(non_us_all)

我们的平均收入为 3.4797 亿美元。

给你尝试(2)

计算传奇故事前两部电影的平均值。

解决办法

# Select the non-US revenue for the first two movies
non_us_some <- all_wars_matrix[1:2,2]# Average non-US revenue for the first two movies
mean(non_us_some)

前两部电影的平均非美国收入为 2.8115 亿美元。

矩阵运算

标准运算符，如+、-、/、*等。它处理向量，也以元素的方式处理矩阵。

例如，2 * my_matrix将my_matrix的每个元素乘以 2。

也可以将一个矩阵乘以另一个矩阵。例如，my_matrix1 * my_matrix2创建一个矩阵，其中每个元素都是my_matrix1和my_matrix2中相应元素的乘积。

让你试试

假设一张电影票的价格是 5 美元。确定每个地理区域有多少观众去看了每部电影。(提示:简单地用票房数字除以票价就会得到游客数量)。

解决办法

# Estimate the visitors
visitors <- all_wars_matrix / 5

给你尝试(2)

假设票价随着时间的推移而上涨。给出一个票价矩阵，确定所有电影的美国和非美国游客的估计数量。

# Construct ticket_prices_matrix
ticket_prices <- c(5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 4.0, 4.0, 4.5, 4.5, 4.9, 4.9)
ticket_prices_matrix <- matrix(ticket_prices, nrow = 6, byrow = TRUE, dimnames = list(c("A New Hope", "The Empire Strikes Back", "Return of the Jedi","The Phantom Menace", "Attack of the Clones", "Revenge of the Sith"),c("US", "non-US")))

票价矩阵。

解决办法

# Estimated number of visitors
visitors <- all_wars_matrix / ticket_prices_matrix

给你试试(3)

计算美国访问者的平均数量(提示:您需要完成第二个才能尝试)

解决办法

# US visitors (Select the entire first column)
us_visitors <- visitors[,1]# Average number of US visitors
mean(us_visitors)

美国访问者的平均数量可以使用均值函数来确定。

笔记

所有图片，除非特别注明，均归作者所有。横幅图像是使用 Canva 创建的。