在 R 中生成调色板
原文：https://towardsdatascience.com/generating-color-palettes-in-r-64394117a662
从图像生成调色板的 R 包列表
安德鲁·雷德利在 Unsplash 上的照片
https://abhinav-malasi.medium.com/membership
在过去的几个月里，我一直在尝试生成艺术，但我的大部分艺术作品都以灰色为结尾。我从来没有办法让我的作品看起来像你在网上看到的其他艺术家的作品一样漂亮。
所以，我开始从网上使用调色板提取工具。这让我思考，我在 R 本身有这些选项吗？因为从在线编辑器中复制十六进制代码是非常无聊的。我搜索并找到了一些 R 包，它们有能力从图像中提取调色板，并对结果进行充分的控制。
为了展示包的功能，我将使用来自imgpalr包的图像作为参考。为了保持一致，调色板的大小固定为 10。要复制你的作品，别忘了播种。我们开始吧。
帕莱特
作者:安德烈亚·西里洛
一个简单而强大的工具，从图像中提取颜色并创建调色板。颜色提取器使用 k-means 算法。
这个包使用create_palette()来创建调色板。开始工作的基本参数是提供文件路径、调色板的大小以及将变量的类型设置为分类。通过提供亮度和饱和度的临界值参数，可以进行进一步的微调。
提取的调色板(L)，提取的调色板用于使用 ggplot ®绘图。(图片由作者提供)
上述调色板的变体通过将参数filter_on_low_brightness和filter_on_saturation的值设置为FALSE来实现。
提取的变体调色板(L)，用于使用 ggplot ®绘图的变体提取调色板。(图片由作者提供)
甚至连上帝都认可这个方案。
imgpalr
作者:马修·莱昂纳维茨
Imgpalr 还使用 k-means 算法来创建调色板。调色板生成器的image_pal()功能可以更广泛地控制从图像创建调色板。基本参数包括文件路径和要识别的颜色数量。通过设置参数的范围，如saturation、brightness和bw(用于黑白像素)，可以调整生成的调色板。参数type有助于定义顺序的、定性的或发散的调色板。此外，可以使用seq_by参数通过hsv、svh或vhs对连续调色板进行排序。此外，还可以调整 k-means 集群大小参数。
下面的调色板是用默认值生成的。
用默认值生成调色板(L)，调色板用于绘图目的®。(图片由作者提供)
只需改变截止饱和度范围，调色板可以调整如下所示。
通过调整饱和度范围生成的调色板(L)，调色板用于绘图目的®。(图片由作者提供)
colorfindr
作者:大卫·尊巴赫和玛拉·阿威克
该包使用get_colors()函数提取颜色。除了使用基于频率的参数top_n定义调色板的大小。也可以通过使用min_share参数定义颜色共享来创建调色板。min_share参数的取值范围在 0-1 之间。它还包含使用参数exclude_col和exclude_rad从调色板中排除颜色的选项。make_palette()函数创建调色板。它可以选择设置两种流行的聚类技术:k-means 和中位数切割。可以使用参数clust_method设置集群的选择。
使用默认设置生成调色板，并将clust_method参数设置为 kmeans。
使用 k-means 的调色板生成。(图片由作者提供)
这是当clust_method的参数设置为中间切割时生成的调色板。
使用中间切割生成调色板。(图片由作者提供)
边缘调色板
作者:乔尔·卡尔森
该软件包使用中值切割算法从图像中提取主色。image_palette()函数用于提取颜色。像往常一样，参数是图像路径、调色板的颜色数量、choice参数定义了如何选择颜色的函数。
该软件包具有其他与 ggplot2 集成的酷功能。函数scale_color_image()和scale_fill_image()可以直接使用 ggplot2 中生成的调色板。
下面的调色板是使用默认设置生成的，调色板的颜色数设置为 10。
使用默认设置生成的调色板。(图片由作者提供)
下面的图是使用 scale_color_image()和 scale_fill_image()函数生成调色板而生成的。这种变化是通过将choice参数设置为 min 来实现的。
通过将 choice 参数设置为 min 生成的调色板变量。(图片由作者提供)
魔法
作者:rOpenSci
Magick 是 r 中用于图像处理的 goto 包。该包有一个名为image_quantize()的函数，它为我们完成了这个任务，但不是一条简单的路径。Chisato 的博客对此做了很好的解释。
使用的代码:
这些是我发现在 r 中生成个性化调色板非常有用的一些包，我希望这对你们有些人有帮助。
https://abhinav-malasi.medium.com/subscribe
参考
2.https://github.com/leonawicz/imgpalr
3.https://github.com/zumbov2/colorfindr
4.https://cran . r-project . org/web/packages/magick/vignettes/intro . html
5.https://www . r-bloggers . com/2019/01/用图像量化从图像中提取颜色/
可以在 LinkedIn 和Twitter上与我连线，跟随我的数据科学和数据可视化之旅。或者您可以在 Medium 上关注我，了解有关 R 和 ggplot2 包的数据可视化的最新文章。
为回归模型生成置信区间
原文：https://towardsdatascience.com/generating-confidence-intervals-for-regression-models-2dd60026fbce
几种模型无关方法的解释和研究
数据科学家开发回归模型来预测日常工作中的一些连续变量是很常见的。可能不太常见的是，尤其是当我们学习回归方法时，如何为我们的模型的给定预测定义一个置信区间。
当然，有一些模型具有定义此区间的内置方式，并且在处理分类时，大多数模型会输出一个概率，该概率可以帮助我们处理预测的不确定性。
但是如果我们有一个没有内置输出方式的回归模型呢？我们需要一种不可知论的方法来生成回归变量的置信区间，这就是我们在这篇文章中要探索的。
为此，我们将研究论文使用刀切+ [1]的预测推理，该论文解释了生成这些区间的几种方法及其优缺点。我们将回顾主要的方法，并对它们进行编码，以更好地巩固概念。
这篇文章的代码也可以在 Kaggle 和 Github 上找到。
天真的方法
当我们试图生成置信区间时，最先想到的可能是天真的方法。这个想法是使用我们模型的残差来估计我们可以从新的预测中得到多少偏差。
算法如下:
- 在训练集上训练模型
- 计算训练集预测的残差
- 选择残差分布的(1-alpha)分位数
- 从该分位数中减去每个预测的总和，以获得置信区间的极限
人们期望，由于残差的分布是已知的，新的预测应该不会偏离它太多。
然而，这种天真的解决方案是有问题的，因为我们的模型可能会过拟合，即使没有过拟合，大多数时候训练集的误差也会小于测试集的误差，毕竟，这些点是模型已知的。
这可能会导致过于乐观的置信区间。因此，永远不要使用这种方法。
为了更好地理解它，让我们编写这个方法。对于这个方法和帖子上的其他方法，我们将使用糖尿病数据集[2]，可以在商业用途的 sklearn 包中免费获得，也可以在这里找到。我们将应用随机森林回归来创建预测。
首先，让我们导入所需的库:
import numpy as np
import pandas as pdfrom sklearn.datasets import load_diabetes
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, KFold
现在，让我们导入数据集，定义 alpha，并将其分成训练集和测试集:
X, y = load_diabetes(return_X_y=True)
alpha = 0.05
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.1)
我们现在将定义一个函数，该函数将为我们生成结果数据集:
def generate_results_dataset(preds, ci):
df = pd.DataFrame()
df['prediction'] = preds
if ci >= 0:
df['upper'] = preds + ci
df['lower'] = preds - ci
else:
df['upper'] = preds - ci
df['lower'] = preds + ci
return df
该函数接收预测和 CI(残差分布的 1-alpha 分位数),并生成预测的下限和上限。
现在让我们生成简单的方法结果。为此，我们将拟合回归变量并计算训练残差，然后我们将获得测试集的分位数和预测，以使用我们的函数:
rf = RandomForestRegressor(random_state=42)
rf.fit(X_train, y_train)residuals = y_train - rf.predict(X_train)ci = np.quantile(residuals, 1 - alpha)
preds = rf.predict(X_test)df = generate_results_dataset(preds, ci)
人们可以使用 Kaggle 笔记本上的一个功能来可视化预测区间，以及预测值和真实值。
折叠法
刀切法试图克服朴素方法的过度乐观结果。为此，它不使用来自训练集的残差，而是使用来自留一预测的残差。
对于那些不知道的人来说，留一法包括为我们数据集中的每个数据点训练一个模型，在整个数据集上训练它，但一次移除一个样本。
通过这样做，残差是根据留一预测来计算的。如您所见，这是对测试集上每个点的预测，因为每个模型在训练阶段都没有看到该点。
然后，为了预测结果(或置信区间的中间点)，我们在整个训练集上拟合最后一个模型，并使用它来进行预测。
让我们看看这在代码中是什么样子的:
kf = KFold(n_splits=len(y_train)-1, shuffle=True, random_state=42)
res = []
for train_index, test_index in kf.split(X_train):
X_train_, X_test_ = X_train[train_index], X_train[test_index]
y_train_, y_test_ = y_train[train_index], y_train[test_index]
rf.fit(X_train_, y_train_)
res.extend(list(y_test_ - rf.predict(X_test_)))
为此，我们将使用 sklearn 库中的 KFold 类，使用拆分数量等于实例数量减 1，这将为留一法过程生成拆分。
然后，对于每个训练好的模型，我们计算残值并将其保存在一个列表中。
现在，是时候在整个训练集上拟合模型并生成结果了:
rf.fit(X_train, y_train)
ci = np.quantile(res, 1 - alpha)preds = rf.predict(X_test)
df = generate_results_dataset(preds, ci)
这种方法比天真的方法更有效，但是，它仍然存在一些问题:
- 留一法成本很高，在许多应用中可能不可行
- 当我们的回归的维数接近实例数时，这种方法就失去了覆盖面。
这种覆盖范围的丢失很奇怪，不是吗？这种情况背后的直觉是，适合整个训练集的模型比用于生成残差的每个其他模型多使用了一个点。这使得它们不能直接比较。
折叠+方法
Jackknife+方法试图解决由于模型适合整个训练集而导致的 Jackknife 方法的覆盖范围损失。
为此，它将使用所有留一训练模型来生成预测。这样，对区间中点进行预测的模型将与残差相当。
但它将如何做到这一点呢？根据这篇论文，直觉是我们得到了所有模型预测的中间值。然而，如果希望对该预测或多或少地保守，可以使用预测的分位数。
然而，在实践中，请注意，通常情况下，模型不会随着单点的丢失而改变太多其行为，因此分布通常具有很小的方差，这使得该方法产生与重叠法非常相似的结果。这种方法的优点来自于退化的情况，其中一个点可能极大地改变模型。
让我们把它编码起来:
kf = KFold(n_splits=len(y_train)-1, shuffle=True, random_state=42)
res = []
estimators = []
for train_index, test_index in kf.split(X_train):
X_train_, X_test_ = X_train[train_index], X_train[test_index]
y_train_, y_test_ = y_train[train_index], y_train[test_index]
rf.fit(X_train_, y_train_)
estimators.append(rf)
res.extend(list(y_test_ - rf.predict(X_test_)))
这里的代码与我们在刀切法中使用的代码非常相似，但是，这一次我们还保存了用于生成残差的模型。
现在，我们的预测将有所不同，因为我们需要对每个模型进行预测:
y_pred_multi = np.column_stack([e.predict(X_test) for e in estimators])
现在，让我们来计算下限和上限:
ci = np.quantile(res, 1 - alpha)
top = []
bottom = []for i in range(y_pred_multi.shape[0]):
if ci > 0:
top.append(np.quantile(y_pred_multi[i] + ci, 1 - alpha))
bottom.append(np.quantile(y_pred_multi[i] - ci, 1 - alpha))
else:
top.append(np.quantile(y_pred_multi[i] - ci, 1 - alpha))
bottom.append(np.quantile(y_pred_multi[i] + ci, 1 - alpha))
最后，让我们使用中值预测来生成结果:
preds = np.median(y_pred_multi, axis=1)
df = pd.DataFrame()
df['pred'] = preds
df['upper'] = top
df['lower'] = bottom
现在，这种方法没有解决产生置信区间所花费的时间的问题。它只减少了一个拟合过程，但增加了每个模型的预测开销。
CV+方法
CV+方法试图解决生成间隔所需的时间问题。它与 Jackknife+完全相同，但是，它使用 K-Fold 交叉验证，而不是留一法。
论文模拟表明，这种方法比刀切法稍差，但速度更快。实际上，这可能是大多数情况下使用的方法。
它的实现与 Jackknife+相同，我们只需要更改 for 循环以使用小于数据集长度的折叠数:
kf = KFold(n_splits=5, shuffle=True, random_state=42)
这个简单的更改将实现 CV+方法。
结论
这个新工具可能对许多需要为回归模型生成预测区间的数据科学家有用。此外，这些方法在 MAPIE 库上是开源的。
折叠刀+太贵了，用不上。但是，如果您已经在方法上使用了交叉验证，那么您可以应用 CV+方法，而不会有开销或性能损失。
[1]巴伯、里娜&坎迪斯、埃马纽埃尔&拉姆达斯、阿迪亚&蒂布拉尼、瑞安。(2021).用刀切+进行预测推理。统计年鉴。49.486–507.10.1214/20-AOS1965。
[2] Bradley Efron，Trevor Hastie，Iain Johnstone 和 Robert Tibshirani (2004)“最小角度回归”，统计年鉴(附讨论)，407–499
用人的步态生成数字签名
原文：https://towardsdatascience.com/generating-digital-signatures-with-the-gait-of-people-3a66f0c44b7b
用机器学习提高网络安全的创新尝试
早在 2018 年初，我们就预见到了人类手掌和手指上各种点的地标检测的有用性，并解释了我们如何在地标检测的基础上利用机器学习来理解手的各种信号。从那时起，我们已经见证了多种产品利用这个有用的想法来理解手势，主要是通过静态快照。在今天的文章中，我们想向前迈出一步，专注于一个更大的问题，即通过步态检测在短视频中利用人体上的更多标志来识别人。我们相信，随着人体标志检测和更快处理的不断进步，这类应用将占据中心位置。
为什么步态检测很重要？
当新冠肺炎疫情袭击世界的时候，人们不得不戴口罩遮住脸。突然之间，许多面部识别模型只能通过来自额头和眼睛的有限的标志点集来做出决定。一夜之间，通过面部识别生成的数字签名就失效了。我们还看到，随着 3D 打印机的出现，犯罪分子正在生成人脸来模仿他们的目标。更糟糕的是，今天，容易获得的 Deepfake 模型足以让观众相信目标受害者所说的一些陈述。
当今最受欢迎的技术中的所有这些漏洞和缺点将需要探索更新的技术。通过一个人走路的方式生成数字签名可能是一个有希望的开端。
人体标志检测模型
虽然从头开始开发步态检测模型可能是一项非常有趣和充满乐趣的工作，但它需要大量的数据、大量的计算能力和时间，而我们许多人都无法获得这些。因此，我们将努力在已经开展的一些良好工作的基础上再接再厉。作为一名机器学习应用程序开发人员，了解研究领域的所有发展非常重要。通过深度学习模型识别人体各种标志的工作将形成我们架构的基本组成部分。
TensorFlow Hub 为我们提供了许多有学问的模型，这些模型将帮助我们检测人体的地标。由于我们不会调整这些模型，相反，我们更感兴趣的是通过这些模型执行推理，我们甚至可以选择通过切换到 TensorFlow Lite 版本来改善我们的延迟，方法是牺牲一点模型的准确性。在我们的实验中，我们将选择 TensorFlow Hub 中的 MoveNet 模型的 Thunder 变体的 TensorFlow Lite 版本。MoveNet 模型将为我们提供 17 个 X-Y 坐标以及每个关键点的置信度得分。
地标关键点(图片来源: TensorFlow
数据类型
既然我们的人体地标检测模型已经定型，下一步就是关注数据。因为我们的目标是建立一个应用程序，我们将创建一种个人行走的数字签名，我们不太可能有大量的个人数据。在实际场景中，我们可能最多只能获得 6-10 秒的视频记录，我们将不得不继续工作。我们的目标非常类似于说金融机构可以收集最多 1 或 2 个客户的签名样本，而后者在他们那里开立新账户。
深入到我们的问题设置，我们将在视频的每一帧上运行我们的姿势估计模型，以生成图像中地标位置的时间序列数据，如下所示。
左:输入视频，中:检测，右:关键点(作者提供的 GIF)
现在，一个自然的问题出现了，我们如何在仅仅 10 秒钟的记录中描绘出一个人的行走模式。这是我们必须填补空白的关键之处，因为数据远远优于机器学习或深度学习模型。我们将尽可能多地模仿我们能想到的模式。
数据扩充
数据扩充是一种创建人工数据集以补充现有数据不足的技术。新生成的数据模拟了现有数据中模式的缺失部分，从而简化了训练期间 ML 模型的学习过程。我们已经在专门针对图像数据增强的上一篇文章中深入讨论了这个主题。
在我们试图解决的问题中，除了更少的数据量，我们甚至必须意识到这样一个事实，即个人的行走方式可能与我们的参考视频不同，期望个人总是保持类似的风格是不合逻辑的。尽管行走方式发生了变化，但总的来说，他/她身体各部分的运动和协调的整体动态应该在一段时间内(比如说过去几年)保持相当相似。然而，由于不同的情况，行走的缺失部分不同，从而产生不同的风格，我们将通过数据扩充来补充它。
a)快走:
拍摄参考视频时，个人可能不会为其他事情烦恼，但在现实生活中，他/她肯定会很匆忙。当人走得快时，帧之间的点对点过渡将不是平滑和连续的。为了模拟视频中的这种情况，我们可以定期随机跳过几帧。
快走(作者 GIF)
b)慢走:
与快走类似，一个人可能受伤了，或者可能有足够的时间，因此可能走得很慢。要模拟缓慢行走的情况，您需要在现有帧之间插入帧。这个慢速视频中的界标应该从其附近的帧中插入，使得人的运动看起来是连续的，并且在恒定 fps 速率下视频中帧数的增加使得人走得慢。
慢走(作者 GIF)
c)滞手:
很多时候，走路的时候，一个人可能一只手或者两只手拿着一个包。在这种情况下，拿着袋子的手不会移动太多，并且会在小范围内振动。我们通过保持对应于所选手的手腕、肘和肩的界标在小范围内移动来模拟这样的条件。
左:左手停滞，中:右手停滞，右:双手停滞(作者 GIF)
d)仅顶部姿势:
有时，记录目标运动的摄像机可能被安装在更高的高度或怪异的角度，这样它只能捕捉到目标的顶部姿势。我们需要通过向下移动人的标志来模拟这种情况，以便自然地看起来只有顶部姿势是可见的。
顶部姿态可见(GIF 由作者提供)
e)随机噪声:
记录目标运动的相机的另一个问题可能是它已经变旧了，并且其中的帧有故障。也有可能是拍摄对象的光线条件不合适。在这种情况下，一些标志可能随机消失，和/或姿态估计模型已经做出了非常低置信度的预测。这种类型的增强也比其他增强增加了更多的正则化效果，以防止我们的模型过度拟合。
故障关键点(作者提供的 GIF)
一个人可能不得不在中途停下来看看他/她的手机或者做一些其他的活动。在这种情况下，腿会保持静止，但身体的其他部位，如手和头可能会移动一点。
走走停停(作者 GIF)
g)左右行走:
到目前为止，在所有的视频中我们都假设拍摄对象会直线行走在镜头正前方。但是对象可能随机向左或向右移动。
左:向右移动，右:向左移动(作者 GIF)
h)混合组合:
无论录音多短，主题都不需要以一种方式改变他的常规风格。因此，我们必须将上述两个或多个条件组合起来，以串行甚至并行的方式模拟混合风格。
我)想更多的替代方案:
我们的模型只有在接受训练时看到的多样化数据量多，才会有好的表现。虽然上述一系列可供选择的行走方式将为我们的数据集增加多样性，但我们可以想到的提供更多数据扩充的场景类型从来没有硬性限制。
建筑模型
构建分类模型可能听起来很有趣，可以直接对主题进行分类，并将每个主题创建为一个类。但是这种方法有一个很大的缺点。我们正在考虑将这个解决方案扩展到几千个，分类器方法将产生一个大的密集矩阵(最后一层)。更重要的是，尽管我们已经做了所有的数据扩充，但我们仍然真的没有数据可以通过每个类别的表示学习来创建良好的边界。
为了解决上述问题，我们将使用一次性学习。通过一次性学习，我们将能够即时评估新人的视频，甚至无需将他们纳入培训。一次性学习利用相似性函数来比较两个实体彼此相似的程度。
我们的架构将包括[暹罗网络](https://en.wikipedia.org/wiki/Siamese_neural_network#:~:text=A%20Siamese%20neural%20network%20(sometimes,to%20compute%20comparable%20output%20vectors.)。由于我们的数据是基于时间序列的，我们将在暹罗网络中使用递归神经网络(GRU 或 LSTM)。我们将把一个参考视频的地标位置的时间序列数据和测试视频的地标位置的时间序列数据传递到暹罗网络中。然后，单独的潜在表示将通过密集层，以分别基于属于或不属于同一个人的视频来最大化或最小化分数。
高层架构(图片由作者提供)
结果
在我们的实验中，我们通过拍摄人们行走的视频来收集数据。我们甚至修剪了开源数据集中的免费可用的步行视频，我们还收集了几个视频，视频所有者允许我们使用他们的资源进行研究。
这是对一个测试视频的推断结果，该视频被提供给我们训练过的模型。与对象的参考视频的相似性分数显示在括号内。对于所有不正确的参考视频，该模型给出的相似性得分小于 0.5
左:测试输入视频，中:检测，右:带有相似性得分的结果(作者提供的 GIF)
这种方法是最好的吗？
不，一点也不。我们这个实验的全部目的是生成一种新型的数字签名。随着旨在加强安全性的创新技术的每一次进步，伪造者总会找到规避它的方法。目前，在 vid2vid 的帮助下，可以生成复制受害者步态的假视频。然而，结合面部识别的步态分析将是生成个人数字签名的良好机制。然而，我们相信这个实验中展示的简单方法可以形成一个很好的基线模型来推进事情的发展。
结论
在本文中，我们学习了如何在现有解决方案的基础上进行构建。我们利用姿态估计解决方案的优势，通过利用暹罗网络和数据增强来模拟许多可能的行走场景，来定制我们的步态检测。在本文中，我们展示了如何重新设计机器学习解决方案来解决其他用例。
密码
如果你想看看这个实验中使用的代码，你可以在这个 GitHub 库中找到它。
https://github.com/Prasad9/GaitDetection
你也可以看看我们以前的文章，解释高斯混合模型和期望最大化的算法。
生成催眠像素模式
原文：https://towardsdatascience.com/generating-hypnotizing-pixel-patterns-c1ab2a07d104
生成的像素模式。点击放大。图片作者。
一个关于对称、纤维艺术和埃舍尔的故事。
你还记得当你折叠一张纸，剪开它，展开后你会有一个漂亮的星星或雪花图案吗？当你在切割的时候，你没有很高的期望。但是展开后，对称就可以了，让你的纸看起来像魔术一样！重复相同的图案真的很强大，在艺术上做得非常好。在这篇文章中，我将与你分享如何用简单的技巧创造美丽的图案。
自制的“雪花”，我尝试了 20 年，真的很简单，它们看起来不漂亮吗？🤩图片作者。
对称
当某样东西在经过某种变换后保持不变或映射到自身时，称之为对称。下面是两种最常见的对称类型。
反射对称
当您可以通过线中的反射将对象映射到自身时，就会发生反射或线对称。
反射对称的例子，树在水中映射到它们自己。由亚当·伯基特拍摄。
旋转对称
如果您可以将一个对象围绕其中心点旋转 360 度，并且该对象映射到自身两次或更多次，这称为旋转对称。两次或更多，因为一次总是在 360 度完成。物体映射到自身的次数称为旋转对称的次数。你可以查一下序后图中的雪花，它们的旋转对称顺序等于 6。
一种特殊类型的旋转对称被称为点对称，当一个对象围绕其中心点旋转 180 度后映射到自身时，就会发生这种情况。检测点对称很容易:当一个物体上下看起来一样，像大写字母 H 或 N，它是点对称的。
你能认出这张图片中的反射、旋转和点对称吗？照片由巴迪·阿巴斯在 Unsplash 上拍摄
创建像素模式
像素模式被纤维艺术家广泛使用。你可以用它们来编织花边、缝纫和各种编织。你真的经常看到钻石图案，在下面的图片中，你可以发现一些不同形式的钻石。
analuisa gamboa 在 Unsplash 上拍摄的照片
手工创建像素模式需要花费大量时间。如果我们利用计算机的能力为我们工作会怎么样？有了计算机，理论上可以创造所有可能的像素模式！会不会带来新的有趣的模式？我尝试了许多不同的方法来创建模式。它们基于对称和重复的原则。可能性是无穷无尽的，因为它可以玩大小，颜色，以及旋转和重复的方式。
第一步很简单。在这一步中，从 n x n 个像素创建一个矩阵(在第一个例子中低于 6×6)。矩阵中随机填充了 0 和 1。零代表白色，一代表黑色。下面你可以看到一些生成的矩阵。他们没什么特别的，对吧？但是当矩阵被镜像、旋转和复制时会发生什么呢？
5 种不同的 6x6 随机黑白像素模式。在第一张图中，你可以看到从 0 和 1 矩阵到黑白矩阵的转换。
镜子，镜子…
如果我们取一个矩阵，向右镜像，然后向下镜像，然后水平和垂直复制几次结果，结果如下:
我们从左上角的 6x6 矩阵开始。然后向右镜像，向下镜像，复制。我们的第一个图案诞生了！
旋转，重复
而不是镜像(反射对称)，当我们旋转矩阵时会发生什么(旋转对称)？我们可以用不同的方法来做这件事，每种方法都有不同的结果。下面，使用与上图相同的矩阵。旋转给了我们一个完全不同的模式。
矩阵向左旋转了 90 度。你也认得这种图案的花吗？
结合旋转和镜像也是可以的，旋转到另一边。下面一个 gif 用一些不同的方式生成图案。
以不同方式生成模式的示例。
使矩阵对角线对称
除了使用我们的方阵，我们还可以给它们增加一个“对称维度”。我们可以使矩阵对角对称。这给了我们这样的矩阵:
对角线具有反射对称性的 7x7 矩阵。
这给了我们这样的模式:
由 7×7 对角对称矩阵生成的模式。
通过反转颜色创建镶嵌
那埃舍尔呢。我希望你知道这位伟大的艺术家，他创作了最美丽、最迷人的画作。如果没有，那就去看看他的代表作(你不会后悔的)。他的特色镶嵌，在那里他完全用动物填充一个表面(大部分时间)真的很鼓舞人心。
我们能通过反转矩阵的颜色并复制它们来模仿这种效果吗？我尝试了两种不同的方法:水平切换矩阵的颜色，每一行都复制了相同的矩阵，第一行是黑/白，第二行是白/黑，第三行是黑/白，依此类推:
水平切换矩阵的颜色。带着一些幻想，我看到海马在左边，中世纪的军人在右边排成一行。
另一种方法是对角切换颜色，其中每个黑/白矩阵都被其自身的白/黑版本包围:
对角切换矩阵的颜色；我看到左边是飞龙，右边是公鸡。
它远非完美，但这些结果可以用作灵感和绘制自己的镶嵌图的起点。
使用模式
到目前为止，已经有两种模式出现了。一个在麦克拉梅，一个在框架编织。
macramé中使用的图案。图片作者。
使用左侧图案制作的框架编织。图片作者。
其他设置
玩不同数量的颜色、不同颜色的地图和不同大小的矩阵真的很有趣。下面是一些我特别喜欢的图案。正如我前面提到的，可能性是无穷无尽的！在这篇文章中，我只触及了皮毛。
结论
我希望你喜欢这个穿越模式和对称世界的小旅程。有了一些基本的 python(用于创建模式的编程语言)知识，就很容易受到启发，创建令人着迷的像素模式！而如果你没有任何 python 知识，就从剪刀和布开始吧！或者看一段分形的视频，其中的模式无限延续。
如果你想玩 python 代码，请联系我。目前，代码还没有公开。
如果你对我的纤维艺术感兴趣，在 Instagram 上关注我，看看我的作品。我不得不说大部分作品都不是由电脑程序激发的(目前还不是)😉).
感谢阅读！❤
本文是系列文章的第一篇。我以三种不同的方式使用了本文中生成的像素模式。第一种方法是在神经风格转移中回答这个问题:当我们将像素模式与图像和图片结合时会发生什么？我也把它们作为生成性对抗网络的输入。最后，我用它们来训练变分自动编码器，以发现潜在空间，并在生成的模式之间进行插值。点击链接阅读这些文章。(如果没有链接，我还没发表这些文章呢！)
别忘了 订阅 如果你想在我发表新文章时收到电子邮件。
利用 LSTM 神经网络生成新的卡尔纳蒂克音乐模式
卡纳蒂克音乐以一些积木的丰富循环模式为特色——使其成为探索基于人工智能的音乐生成的丰富游乐场。让我们看看 LSTM 是如何创作新的基本作品的
卡尔纳蒂克音乐中的积木
卡纳蒂克音乐是两种印度古典音乐形式之一(另一种是印度斯坦音乐)。与西方古典音乐不同，西方古典音乐中的作品被设定为一个特定的调(例如贝多芬的 C 小调第五交响曲)并且以多种调式为特征；卡尔纳蒂克的音乐作品大多被设定为一种独特的调式，称为 Raga。例如，Raga Sankarabharanam 对应于爱奥尼亚调式(通常称为大调音阶)。
由于这种对特定模式的关注，卡尔纳蒂克音乐以复杂的循环模式为特色，这通常可以被认为是建立在基本模式的基础上，几乎就像是重复片段的等价物。事实上，在卡纳蒂克音乐中，人们最先学到的东西之一就是萨拉里·瓦拉赛(Sarali varas ais)，这是对基本的完整拉格(raga)的修改:
T2 [] S n d p | m g | r S
其中“s r g m p d n S”是组成完整音阶的 8 个音符。例如，如果我们谈论 c 大调音阶中的三卡拉巴拉那，对应的将是“C D E F G A B C”。“|”和“||”表示节拍小节。“||”代表一个周期的结束(这里是 8 拍)，“|”代表一个特征音程。这个简单的上升和下降模式是第一个 Sarali Varisai，还有 13 个变化如下图所示:
Sarali Varisai 的另一个例子是:
S r g m | p d | S r | |
S r g m | p d | n S | |
S n d p | m g | S n | |
S n d p | m g | r S | |
本文的目标是训练一个人工智能模型，从 13 个 Sarali vari sai 中生成一个新的 Sarali Varasai，这些 Sarali vari sai 的长度都是 44 个字符(不包括第一个字符)。
LSTM 神经网络
长短期记忆(LSTM)神经网络被大量用于模拟循环模式和时间相关现象。LSTM 旨在提供长期和短期记忆来模拟序列模式。据报道，LSTM 架构是 20 世纪被引用最多的神经网络。
传统的神经网络在给定某个输入向量的情况下预测输出。例如，MNIST 数据集的特征是从 0 到 9 的数字化手写数字。人们可以开发一个基本的神经网络，以相当不错的精度来预测给定手写数字的数字，而不是在训练模型时看到的数字。
然而，这些神经网络没有对信息的持久性进行建模——这是一个缺点。例如，如果您想预测未来的一些事情，比如一天后的股票市场，如果您仅基于当前特征(相当于一幅图像中的所有像素)进行预测，您将会丢失有价值的信息。天气预报也是如此，甚至只是知道电影中接下来会发生什么。接下来的几分钟不仅仅取决于电影的当前位置，还取决于角色的历史。
这种持久性可以通过递归神经网络(RNNs)来建模。在一个简单的 RNN 中，有神经网络来模拟每一个时间步，其中 2 个输入是系统的先前状态；和一个考虑历史的向量。在下图中，您可以看到，在每一步 t，RNN 都接受一个输入 x_t，以及一个从过去的历史中累积的输入 v。这种模型的一个例子可以是例如一个句子的语言翻译——从英语到法语。在这种情况下，RNN 模型的想法是，不仅当前单词在建模相应的法语单词时有用，而且句子中前面单词的历史也有用。
rnn 的一个主要问题是它们不能处理大序列，这是由于在多次迭代中混合了非常小或非常大的数。LSTMs 通过为每个单元设置一个单独的“门”来克服这种限制，该门可以选择性地让信息通过。这样，他们可以通过忘记中间的一些无关紧要的连接，但同时跟踪一些重要的连接，来处理更长范围的依赖性。
用基本的 LSTM 细胞来模拟依赖于过去历史的循环模式|塞犍陀·维维克
为卡纳蒂克·萨拉里·瓦拉塞一代建立一个 LSTM 模式
首先，我定义了与 14 个不同的 Sarali Varasais 相对应的 14 个字符串，并创建了一个连接除第一个以外的所有字符串的列表(第一个字符串比其余的都小)。
x1=”s r g m | p d | n S || S n d p | m g | r s ||”
x2=”s r s r | s r | g m || s r g m | p d | n S || S n S n | S n | d p || S n d p | m g | r s ||”
x3=”s r g s | r g | s r || s r g m | p d | n S || S n d s | n d | s n || S n d p | m g | r s ||”
x4=”s r g m | s r | g m || s r g m | p d | n s || S n d p | S n | d p || S n d p | m g | r s ||”
x5=”s r g m | p , | s r || s r g m | p d | n S || S n d p | m , | S n || S n d p | m g | r s ||”
x6=”s r g m | p d | s r || s r g m | p d | n S || S n d p | m g | S n || S n d p | m g | r s ||”
x7=”s r g m | p d | n , || s r g m | p d | n S || S n d p | m g | r , || S n d p | m g | r s ||”
x8=”s r g m | p m | g r || s r g m | p d | n S || S n d p | m p | d n || S n d p | m g | r s ||”
x9=”s r g m | p m | d p || s r g m | p d | n S || S n d p | m p | g m || S n d p | m g | r s ||”x10=”s r g m | p , | g m || p , , , | p , | , , || g m p d | n d | p m || g m p g | m g | r s ||”
x11=”S , n d | n , | d p || d , p m | p , | p , || g m p d | n d | p m || g m p g | m g | r s ||”
x12=”S S n d | n n | d p || d d p m | p , | p , || g m p d | n d | p m || g m p g | m g | r s ||”
x13=”s r g r | g , | g m || p m p , | d p | d , || m p d p | d n | d p || m p d p | m g | r s ||”
x14=”s r g m | p , | p , || d d p , | m m | p , || d n S , | S n | d p || S n d p | m g | r s ||”l1=[]
l1.append([i for i in x2.split(" ") if i])
l1.append([i for i in x3.split(" ") if i])
l1.append([i for i in x4.split(" ") if i])
l1.append([i for i in x5.split(" ") if i])
l1.append([i for i in x6.split(" ") if i])
l1.append([i for i in x7.split(" ") if i])
l1.append([i for i in x8.split(" ") if i])
l1.append([i for i in x9.split(" ") if i])
l1.append([i for i in x10.split(" ") if i])
l1.append([i for i in x11.split(" ") if i])
l1.append([i for i in x12.split(" ") if i])
l1.append([i for i in x13.split(" ") if i])
l1.append([i for i in x14.split(" ") if i])
有 11 个不同的音符(’ S ‘，’ r ‘，’ g ‘，’ m ‘，’ p ‘，’ d ‘，’ n ‘，’ S ‘，’ | ‘，’，’ )，其中’ S ‘表示第一个音符的高音版本，’ | ‘和’ || ‘是特征音程，’，'只是一个延长音符的间隔。使用这个信息，我开发了一个热编码，其中 X 的维数是 X= (13，44，11)，对应于 13 个萨拉里变奏，44 个音符组成每个萨拉里变奏(包括音程)，11 对应于一个热编码维数。
y 是向左移动一步的 X；即时间步长 t 处的 Y 与时间步长 t+1 处的 X 相同。因此，游戏现在将预测给定前一个音符的下一个音符(LSTM 也考虑音符的历史)。
for i in range(0,len(l1)):
values = array(l1[i])
onehot_encoded = onehot_encoder.transform(values.reshape(len(values), 1))
X[i,:]=onehot_encoded
values=np.roll(values,-1)
onehot_encoded = onehot_encoder.transform(values.reshape(len(values), 1))
Y[:,i,:]=onehot_encoded
接下来，我们的想法是训练一个 LSTM 模型，根据之前的值(X)来预测后续的音符(Y)。
n_values = 11 # number of music values
reshaper = Reshape((1, n_values))
LSTM_cell = LSTM(n_a, return_state = True)
densor = Dense(n_values, activation=’softmax’)def djmodel(Tx, LSTM_cell, densor, reshaper):
"""
Implement the djmodel composed of Tx LSTM cells where each cell is responsible
for learning the following note based on the previous note and context.
Each cell has the following schema:
[X_{t}, a_{t-1}, c0_{t-1}] -> RESHAPE() -> LSTM() -> DENSE()
Arguments:
Tx -- length of the sequences in the corpus
LSTM_cell -- LSTM layer instance
densor -- Dense layer instance
reshaper -- Reshape layer instance
Returns:
model -- a keras instance model with inputs [X, a0, c0]
"""
# Get the shape of input values
n_values = densor.units
# Get the number of the hidden state vector
n_a = LSTM_cell.units
# Define the input layer and specify the shape
X = Input(shape=(Tx, n_values))
# Define the initial hidden state a0 and initial cell state c0
# using `Input`
a0 = Input(shape=(n_a,), name='a0')
c0 = Input(shape=(n_a,), name='c0')
a = a0
c = c0
outputs = []
# Step 2: Loop over tx
for t in range(Tx):
# Step 2.A: select the "t"th time step vector from X.
x = X[:,t,:]
# Step 2.B: Use reshaper to reshape x to be (1, n_values) (≈1 line)
x = reshaper(x)
#print(x.shape)
# Step 2.C: Perform one step of the LSTM_cell
a, _, c = LSTM_cell(inputs=x, initial_state=[a,c])
# Step 2.D: Apply densor to the hidden state output of LSTM_Cell
out = densor(a)
# Step 2.E: add the output to "outputs"
outputs=outputs+[out]
# Step 3: Create model instance
model = Model(inputs=[X, a0, c0], outputs=outputs)
return modelmodel = djmodel(Tx=44, LSTM_cell=LSTM_cell, densor=densor, reshaper=reshaper)history = model.fit([X, a0, c0], list(Y), epochs=200, verbose = 1)
如你所见，对于 200 个训练时期，损失下降了——这意味着该模型在 Saralivarisai 内更好地理解(并可能复制)模式。
在卡纳蒂克音乐序列上训练 LSTM |塞犍陀·维维克
经过训练后，LSTM 细胞可以用来产生音乐:
def music_inference_model(LSTM_cell, densor, Ty=44):
"""
Uses the trained "LSTM_cell" and "densor" from model() to generate a sequence of values.
Arguments:
LSTM_cell -- the trained "LSTM_cell" from model(), Keras layer object
densor -- the trained "densor" from model(), Keras layer object
Ty -- integer, number of time steps to generate
Returns:
inference_model -- Keras model instance
"""
# Get the shape of input values
n_values = densor.units
# Get the number of the hidden state vector
n_a = LSTM_cell.units
# Define the input of your model with a shape
x0 = Input(shape=(1, n_values))
# Define s0, initial hidden state for the decoder LSTM
a0 = Input(shape=(n_a,), name='a0')
c0 = Input(shape=(n_a,), name='c0')
a = a0
c = c0
x = x0 outputs = []
# Step 2: Loop over Ty and generate a value at every time step
for t in range(Ty):
# Step 2.A: Perform one step of LSTM_cell. Use "x", not "x0" (≈1 line)
a, _, c = LSTM_cell(x, initial_state=[a,c])
# Step 2.B: Apply Dense layer to the hidden state output of the LSTM_cell (≈1 line)
out = densor(a)
# Step 2.C: Append the prediction "out" to "outputs". out.shape = (None, 90) (≈1 line)
outputs.append(out)
#print(out.shape)
# Step 2.D:
# Select the next value according to "out",
# Set "x" to be the one-hot representation of the selected value
# See instructions above.
x = tf.math.argmax(out,axis=-1)
#print(x.shape)
x = tf.one_hot(x,n_values)
# Step 2.E:
# Use RepeatVector(1) to convert x into a tensor with shape=(None, 1, 90)
#print(x.shape)
x = RepeatVector(1)(x)
# Step 3: Create model instance with the correct "inputs" and "outputs" (≈1 line)
inference_model = Model(inputs=[x0, a0, c0], outputs=outputs)
return inference_modelinference_model = music_inference_model(LSTM_cell, densor, Ty = 44)
然后我们可以给推理模型随机初始化的输入:
def predict_and_sample(inference_model, x_initializer = x_initializer, a_initializer = a_initializer,
c_initializer = c_initializer):
"""
Predicts the next value of values using the inference model.
Arguments:
inference_model -- Keras model instance for inference time
x_initializer -- numpy array of shape (1, 1, 90), one-hot vector initializing the values generation
a_initializer -- numpy array of shape (1, n_a), initializing the hidden state of the LSTM_cell
c_initializer -- numpy array of shape (1, n_a), initializing the cell state of the LSTM_cel
Returns:
results -- numpy-array of shape (Ty, 90), matrix of one-hot vectors representing the values generated
indices -- numpy-array of shape (Ty, 1), matrix of indices representing the values generated
"""
n_values = x_initializer.shape[2]
given x_initializer, a_initializer and c_initializer.
pred = inference_model.predict([x_initializer,a_initializer,c_initializer])
# Step 2: Convert "pred" into an np.array() of indices with the maximum probabilities
indices = np.argmax(pred,axis=-1)
# Step 3: Convert indices to one-hot vectors, the shape of the results should be (Ty, n_values)
results = to_categorical(indices, num_classes=n_values)
return results, indicesx_initializer = np.random.rand(1, 1, n_values)
a_initializer = np.random.rand(1, n_a)
c_initializer = np.random.rand(1, n_a)results, indices = predict_and_sample(inference_model, x_initializer, a_initializer, c_initializer)notes=[]
for i in range(0,len(results[:,0])):
inverted = label_encoder.inverse_transform([argmax(results[i, :])])[0]
notes.append(inverted)print(' '.join(e for e in notes))
这是 LSTM 预测的:
d | n S | d p || d d p m | p，| p，|| g m p d | n d | p m || g m p g | m g | r s || S n d
有趣的是，它很好地生成了一个结构良好的 2 行组合，尽管是在一个周期的中间开始的。这可能是因为我们如何通过输入前一个音符来训练 LSTM 细胞——这有效地使用了周期性边界，并使其成为一个循环模型。
通过将“n d”放在前面，我们得到一个新的 Sarali Varisai，如下所示:
S n d d | n S | d p ||
d d p m | p，| p，| |
g m p d | n d | p m | |
g m p g | m g | r S | |
这是我唱这首歌的录音:
结论
在本文中，我将展示如何使用 LSTM——一种经典的递归神经网络架构来生成基本的 Carnatic Saralivarse 模式。由于这些基本模式构成了更复杂的卡尔纳蒂克音乐作品的基础，使用先进的人工智能算法来生成更复杂的作品可能会令人兴奋。
LSTMs 仍然受到递归神经网络固有的顺序性质的困扰——这也使得它们很难并行进行计算。最近，变形金刚席卷了自然语言处理领域。就像在阅读或翻译一个句子时，人们需要注意句子的各个部分一样，变形金刚被设计成使用自我注意来消除重复连接，并提供同时关注多个单词的能力。同样，如果有足够多的数据，变形金刚也可以用来理解和创作新的音乐。
如果你在音乐和 AI 的交汇点有其他想法，欢迎联系！
您可以在这个 GitHub repo 中找到代码:
https://github.com/skandavivek/LSTM-Carnatic-Music-Generation
如果你还不是中会员，想支持我这样的作家，可以通过我的推荐链接随意报名:【https://skanda-vivek.medium.com/membership】
关注我 如果你喜欢这篇文章——我经常在数据科学、音乐、安全和社会的界面上写作。
每周数据透视 订阅此处 ！
参考文献:
利用机器学习生成科学论文标题
汉斯·雷尼尔斯在 Unsplash 拍摄的照片
动手操作笔记本关于一个生成式机器学习模型，它能够创建新的科学论文标题
作为一名研究人员(或者学生，或者两者兼而有之)，我在过去的三年里花了很多时间阅读和研究的论文。
我的领域是机器学习和数据科学，当然这是一个巨大的领域，有很多不同的领域可以覆盖。我注意到一件有趣的事情，即使是最不同的文章也有相似的标题结构:
“某样东西某样东西某样东西某样东西”
当然，有很多反例(机器学习中一篇非常著名的文章叫做“注意力是你所需要的全部”)但这种设置标题的方式确实引人注目，而且具有明确性。
有一个写标题的“公式”的事实给了我一个想法。**让我们建立一个机器学习方法，编造不存在的新标题。**那就这么办吧！
附注:这种方法背后的技术可能很复杂，您可能不熟悉，但实现起来很容易。如果你想了解更多关于它是如何工作的，可以访问这个 网站 **【原代码来源】**或者看看我前段时间写的 这个中等故事 。
1.图书馆
好消息是这个图书馆很有名，你可能很熟悉。坏消息是，我们将使用 Tensorflow (j 只是开玩笑:))
公平地说，Tensorflow 是一个非常强大的库，但安装它并使它按照您想要的方式工作可能会很棘手。所以不要绝望，必要的时候使用 StackOverFlow。
无论如何，这是你需要的:
很简单，对吧？在某一点上，我们将拥有 Tensor.numpy()，这就是为什么您需要 tf.enable_eager_execution()。
注意:启动程序时需要运行 tf.enable_eager_execution()，一定要小心！现在就做！
2.数据集
当然，为了训练我们的机器学习算法来编写新标题，我们需要一堆旧标题来训练它。
我在这里 找到了一个 Arxiv 的书名和文章集 **。**下载并运行以下代码导入您的数据:
注意:这个模型当然是一个小例子，说明你可以用更强大的计算能力做些什么。为此，我使用了一个非常小的模型，只有几行(500)。如果你有足够的计算能力，并且接受你可能要等很久才能得到结果的事实，你可以随意使用更大的模型和更多的数据。
2.1 数据预处理
我们需要做一系列的操作来把这个字符串列表转换成机器可以真正读懂的东西。深入细节并不十分有趣，但简单地说，我们正在做的是向量化我们的文本，这意味着将字符串转换成值列表。
还是那句话，如果你想了解更多关于它是如何工作的，可以访问这个 网站 **【原代码来源】**或者看看我前段时间写的 这个中等故事 。
如果您想跳过这一部分，转到机器学习模型，只需运行此代码并继续:
3.机器学习
我们要用的技术叫做神经网络。具体来说，我们将使用一种称为递归神经网络的神经网络。这个想法是，给定一个特定的输入字符串，网络能够得到最有可能出现的字符串。
很不错吧？
可以使用下面几行代码构建模型:
当然，每个被定义为“机器学习”的算法都需要一些训练。每个训练与某个损失函数配对，在这种情况下，损失函数如下:
完美！现在一切都准备好了，让我们开始训练:
在训练过程中，我们定义的损失函数具有递减值，这很好！对于每个时期，模型存储在某个文件夹中，我们希望使用该文件夹中的最佳模型:
4.结果
虽然你们中的一些人可能喜欢所有关于机器学习的故事和事情，但我坚信你们大多数人是为了最终的结果而来。而且绝对公平！那我们走吧。
要生成新文本，您将需要此函数:
这正是我们所说的:挑选我们输入后更有可能被验证的字符。尽管如此，我们在函数中还有另一个输入，那就是温度。这个值给你产生的文本的“创造性”。换句话说，如果你使用温度=1，你会得到一个非常有创意的文本，尽管它可能没有任何意义。如果使用 temperature=0.1，您将得到一个可能更有意义的文本，但它可能与数据集中已有的文本非常相似。
让我们用 5 种不同的温度和 5 种不同的输入产生 5 种不同的文本:
让我们把它们打印出来！😃
因此，如果我们过滤掉一点，我们会得到以下结果:
“针对图像分割注意力的深度学习”
“深度学习的方法控制上下文”
“面向学习的图像深度强化学习”
“使用 Imagence 进行图形学习的机器学习”
一个新的隆布拉:为数据设置 giog-Prouge Impai”
**我觉得这太棒了。**最后一句纯属扯淡，因为我们设温度= 1。尽管如此，5 次中有 4 次我们有以下标题:
“某样东西某样东西换某样东西”
这正是我所期待的！
4.结论
我已经研究这个生成模型有一段时间了，我可以说它绝对是现象级的。同样，我们可以有比这好得多的结果！如果我们知道我们想要的结果是什么，我们可以尝试清理数据集并稍微更改我们拥有的文本，我们可以使用更多的文本和更强大的模型(例如增加 RNN 单位和图层的数量)。
尽管如此，我相信使用这个管道，您将在文本生成方面取得巨大的成果。
如果你喜欢这篇文章，你想知道更多关于机器学习的知识，或者你只是想问我一些你可以问的问题:
A.在 Linkedin 上关注我，我在那里发布我所有的故事
B .订阅我的 简讯 。这会让你了解新的故事，并给你机会发短信给我，让我收到你所有的更正或疑问。
C .成为 推荐会员 ，这样你就不会有任何“本月最大数量的故事”，你可以阅读我(以及成千上万其他机器学习和数据科学顶级作家)写的任何关于最新可用技术的文章。
再见。😃
从每一篇文本中提取最先进的见解
不需要 OpenAI GPT-3 和类似的工具来为你的自然语言处理任务获得最先进的语义文本洞察。
来源:由作者创作
在这篇文章中，我将展示大型语言模型，如 GPT-3，并不能通过其密集的文本嵌入为许多 NLP(自然语言处理)任务生成最佳的语义文本洞察，以及如何让每个人都可以用广泛可用的硬件生成最先进的嵌入。
密集文本嵌入是编码单词含义的文本的矢量表示。这样，意义相近的词在矢量表示中是相近的。这些嵌入对于复杂的任务非常有用，例如比较文本内容的相似性、语义搜索、释义挖掘等。在过去的几年中，语言模型的规模呈指数增长，由于资源的限制，许多从业者几乎不可能用最新的模型进行实验。我可能有一个解决方案给你😉。
来源:蒸馏伯特，伯特的蒸馏版本:更小、更快、更便宜、更轻——https://arxiv.org/pdf/1910.01108.pdf
问题陈述和前进方向
我们大多数人面临的限制是，我们没有权限或财力部署大型 GPU/TPU 集群来运行大型语言模型，如 T5、MPNet 或 GPT-3。为了克服这些限制并获得最先进的文本嵌入，我在以下两个步骤上花了很多时间，我想与你们分享:
- 基于所有相关语言模型的性能和模型参数的数量对其进行比较和排序，以找到最有效的预训练模型。
- 应用并比较不同的微调技术如何提高预训练模型的性能。
动机
当然，我有自己的理由生成高质量的文本嵌入。我的目标是使用文本嵌入作为我自己的模型的输入，以帮助决定我自己的金融资产选择。由于我收到了很多公开我的模型的请求，我发起了一个名为 PinkLion 的项目。
我设计了 PinkLion，通过提供对潜在预测模型的访问，实现动态投资组合优化和资产分析。这些模型可以访问成千上万只股票、基金/ETF 和加密货币的日常资产数据。
请随意尝试，并分享反馈🙏。(还处于粗略状态) www.pinklion.xyz
1.根据性能和规模对语言模型进行比较和排序
作为第一步，我们必须对现有的语言模型、它们的性能以及它们的规模有一个很好的了解。因此，目标是基于各种基准测试任务比较不同的语言模型，并确定它们相对于其参数数量的表现如何。
模型性能的定义—胶水和强力胶
尽管阅读了大量研究论文，但令人惊讶的是，很少发现跨多个基准任务(如 SentEval [1]、GLUE [2]、SQuAD[3]、RACE [4]或 SWAG [5])的完全透明的模型评估。在进一步研究这个话题后，我得出结论，认为【通用语言理解评测】【2】似乎是最广泛使用的评测语言模型性能的基准。
GLUE 是一个工具和数据集的集合，用于评估一个模型在一组九个自然语言任务中的性能。这九项任务集中在文本相似性和释义、分类和推理领域。
有了这个结论，我开始收集所有相关语言模型的 GLUE 评估结果。尽管 GLUE 被广泛使用，但是仍然很难获得所有相关的分数，尤其是对于较小的模型版本。本文中的所有后续数字都是按照以下顺序从 GLUE 排行榜、模型的研究论文或相应模型的 Github 页面获得的。
对于每个对如何详细组成 GLUE [2] 基准感兴趣的人来说，这里是组成基准的任务名称、缩写、描述和度量。
如果您对详细的粘合任务不感兴趣，请跳到下一节“模型比较和排名”。
- 语言可接受性语料库(CoLA) :判断一个句子的语法是否正确。— 指标:马修相关性
- 斯坦福情感树库(SST-2) : 判断句子是正面情感还是负面情感。——公制: 准确度
- 微软研究院释义语料库(MRPC) :判断两个句子是否是彼此的释义。— 指标:准确性/F1
- 语义文本相似度基准(STS-B) :确定两个句子的相似度，分值从 1 到 5。— 指标:皮尔森相关性/斯皮尔曼相关性
- 问答式自然语言推理(QNLI) :判断问题的答案是否在第二句话中。(这个数据集是从班数据集构建的。)— 度量:准确度
- Quora 问题对(QQP) :判断两个问题是否语义等价。— 指标:准确性/F1
- 多体裁自然语言推理(MNLI) :确定一个句子是否包含、反驳或与一个给定的假设无关。(该数据集有两个版本，一个版本的验证和测试集来自同一个发行版，另一个版本称为不匹配，其中验证和测试使用域外。— 指标:准确度
- 识别文本蕴涵(RTE) :确定一个句子是否包含给定的假设。— 指标:准确度
- Winograd 自然语言推理(WNLI) :判断含有匿名代词的句子和替换了该代词的句子是否包含。(该数据集是从 Winograd 模式挑战数据集构建的。)— 度量:准确度
通过取所有任务的平均值来计算最终的粘合分数。像 MRPC 和 STS-B 这样有两个跟踪指标的任务首先被平均，然后被认为是该任务的单一得分。
模型比较和排序
在定义了我们如何度量模型的性能之后，这里是收集到的不同语言模型家族的见解。下表显示了每个模型的参数数量、模型的内存存储量(这些数字已从 Tensorflow Hub 或相应模型的 Github 页面获得)以及上文所述的粘合分数。最后，**最后一列模型性能/大小比率显示了基于模型的粘合分数及其参数数量计算的比率。**
模型性能/尺寸比=粘合分数/模型参数数量
换句话说，如果一个模型在 GLUE benchmark 上用更少的参数表现得更好，那么这个比率就更高。因此，型号性能/尺寸比栏中的数字越高越好。
从整体来看，很明显，随着模型尺寸的增加，性能/尺寸比迅速降低。因此，模型中每个增加的参数都有很强的收益递减。简单看一下 Google【11】已经公布的 T5 车型家族，这一点就变得非常明显。
最小的 T5 型号 T5-small 拥有 6000 万个参数，粘合分数为 77.4，性能/尺寸比为 1.29。相比之下，最大的 T5 型号 T5–11B 的胶合分数为 90.3，比 T5-small 高 12.9 分。
为了实现 12.9 点或 16.6%的分数增加，模型大小必须从 6000 万个参数增加到 110 亿个参数，即增加了 18300%🤯。
现在你可能想知道为什么 GPT-3 没有出现在上表中。原因是 GPT-3 不是在普通胶水基准上正式评估的，而是在强力胶【6】基准上评估的。
SuperGLUE 是在 image GLUE 之后创建的一个新基准，它具有一组新的更难的语言理解任务。
幸运的是，强力胶排行榜列出了普通胶水基准测试中的 GPT-3 和多个型号(伯特-大号、罗伯塔-大号、T5–11B)。比较伯特-基地和 GPT-3，GPT-3 只有更高的强力胶分数 2.8 分(69.0 → 71.8)。尽管 GPT 3 号的参数是它的 1605 倍。同样，RoBERTa-large 和 T5–11B 的参数比 GPT-3 少，但得分更高，分别为 84.6 和 89.3。
了解到真正的大型模型，如 GPT-3 在强力胶上的表现优于其他模型(罗伯塔-大型和 T5–11B)，我们可以假设 GPT-3 在普通胶水基准上也优于这些模型。
回到我们正常的 GLUE 比较，我们可以看到实现最佳性能/大小比的语言模型家族是 ALBERT (A Lite BERT) 模型。
ALBERT-base 模型实现了的 6.986 ，是所有测试语言模型中最高的比率。高比率可以解释为非常好的胶合分数 83.9，同时是所有测试模型中最小的，只有 1200 万个参数。因此，ALBERT-base 提供了每个部署参数的最佳性能。由于参数数量很少，艾伯特-基和艾伯特-大可以很容易地在 K80 或 P100 GPU 上训练。**
模型比较的结论
当用有限的资源生成密集文本嵌入时，最好考虑的模型族是 ALBERT 族。在所有评估的语言模型中，ALBERT-base 和 ALBERT-large 具有最好的性能/大小比。两者都有 1200 万和 1800 万个参数，胶合分数分别为 83.8 和 85.7。这使得这两种型号成为最小的型号之一，同时提供了与 T5 型号相当的性能，而 T5 型号则大得多。此外，GPT-3 在 SuperGLUE 基准测试中表现不佳，如果下游任务与文本生成无关，则不应该选择它作为模型。完整评价可以在 这里 找到。
在接下来的章节中，我将展示如何使用不同的微调技术来进一步提高 ALBERT-base 的性能。
2.通过应用和比较不同的微调技术来提高预训练模型的性能
在选择了 ALBERT-base 作为我们的语言模型之后，我们现在想要微调一般训练的模型，使它更适合我们自己的应用程序。有许多方法可以微调模型以生成文本嵌入。然而，不同的微调方法会导致非常不同的定性结果。因为比较不同的微调技术需要付出大量的努力，所以我想分享我自己的结果，以便将来其他人更容易理解。
在这一节中，我们将比较三种不同的微调过的 ALBERTs，它们都是用不同的微调技术改变的。这里是不同方法和结果的初步概述。
来源:比较 ALBERT-base 微调架构—全面评估此处 —由作者创建
- 冻结艾伯特:冻结艾伯特由常规预训练艾伯特基础模型组成，该模型被冻结，因此在微调时不会更新其参数。此外，它还有一个可训练的分类头，包括一个 dense 和一个 softmax 分类层。该模型将作为我们的基线基准，因为它将代表 ALBERT-base 在没有重大微调的情况下的表现。
- 经过训练的艾伯特:经过训练的艾伯特和冰冻的艾伯特有着完全一样的架构，然而，所有的组件都是完全可以训练和微调的。这意味着 ALBERT-base 组件和分类头(密集层+ Softmax 层)可以针对分类微调任务完全调整它们的权重。
- ****暹罗阿尔伯特:暹罗阿尔伯特的灵感来自通用暹罗框架【7】，在我们的例子中，它包括三个相同的基于阿尔伯特的网络，这些网络使用共享权重。除了三个子网络之外，还为分类微调任务添加了由 softmax 层表示的分类头。
资料组
为了了解不同的微调方法在现实世界中的比较，我选择了 HuffPost 新闻分类数据集【8】作为文本语料库。该数据集包含 2012 年至 2018 年间从《赫芬顿邮报》收集的 200853 条新闻记录，标题和描述分布在 41 个独特的新闻类别中。因此，这个数据集非常适合于查看我们可以在多大程度上针对分类任务对模型进行微调。这是数据集的一个示例。
来源:赫芬顿邮报新闻分类数据样本——由作者创建
我们微调任务的目标是根据给定的新闻标题预测新闻类别。
数据准备
由于我们希望仅使用新闻标题作为输入来预测新闻类别，因此我们首先希望通过计算和绘制每个新闻标题的字符和字数分布来获得数据集的更好概述。
对于新闻标题的字数，最小字数为 0，最大字数为 44，平均一个新闻标题有 9 个字。然而，从分布情况来看，我们可以得出，由于许多标题有大量的单词，所以平均值被夸大了。
新闻标题的字符计数的分布显示了类似的情况，其中大量标题具有大量字符。对于字符计数，0 是最小计数，320 是最大计数，平均一个标题有 57 个字符。
来源:赫芬顿邮报新闻标题单词和字符的概率分布——由作者创建
为了提高输入数据的质量，我们删除了每个标题少于 10 个单词的所有新闻记录。应用此条件将记录数量从 200853 减少到 189339。****
删除标题少于 10 个单词的所有记录，并应用 80/20 训练和验证数据集拆分后，类别分布如下所示。
来源:赫芬顿邮报训练和验证拆分新闻类别——由作者创建
现在很明显，我们有一个高级别不平衡，与政治是占主导地位的阶级。这种偏差将在训练过程中通过给每个类分配不同的权重来纠正(稍后会有更多的介绍)。
比较微调技术
在对我们的 3 个模型(冰冻艾伯特、训练艾伯特、暹罗艾伯特)进行了训练之后，我们现在能够更详细地查看模型的性能，该训练数据集具有 160682 条对新闻类别进行分类的记录。
以下所有指标均来自验证数据集，该数据集显示，从整体来看， 暹罗阿尔伯特的性能最好，，其次是受过训练的阿尔伯特，然后是冷冻阿尔伯特。
**暹罗阿尔伯特几乎在所有指标上表现最佳
首先比较冻结的艾伯特和训练的艾伯特，前者使用基于艾伯特的网络的未改变的权重，后者由于赫芬顿邮报的训练过程而具有微调的权重，我们已经可以看到显著的性能提升。经过训练的艾伯特的准确率为 58%，F1 得分为 60%，AUC-micro 值为 0.996，而冷冻艾伯特的准确率为 32%，F1 得分为 35%，AUC-micro 值为 0.905。
来源:比较 ALBERT-base 微调指标—全面评估此处 —由作者创建
第二步比较siame ALBERT我们可以看到，siame 版本在几乎所有指标上都优于其他两款车型。暹罗阿尔伯特在验证数据集上的准确率为 63%，几乎是冷冻阿尔伯特准确率的两倍，也高于训练过的阿尔伯特的准确率。综上所述，Siamese ALBERT 的准确率为 63%，F1 分数为 64%，AUC-micro 值为 0.946，略低于训练过的 ALBERT 方法的同等分数。
因为我们最初的目标是创建最好的文本嵌入，这里是由 Siamese ALBERT 生成的嵌入。正如我们所看到的，我们确实为不同的新闻标题类别实现了不同的聚类。暹罗嵌入的一个有趣的特征是，它不仅为不同的类别创建聚类，而且具有类似内容的新闻标题类别，如 T 世界邮报、世界邮报和世界新闻在嵌入空间中彼此靠近。
来源:暹罗阿尔伯特新闻标题嵌入——由作者创建
不同评估步骤和嵌入代的完整代码可在我的Github上获得。****
暹罗阿尔伯特的实现
上面介绍的 Siamese ALBERT 是在硬件受限的情况下产生高质量文本嵌入的最佳方法。因此，我也想分享一下暹罗阿尔伯特是如何工作的，以及如何实现这个网络并重现上面的结果。**
让我们先来看看隐藏在单个连体阿尔伯特盒子后面的架构的高级表示。Siamese ALBERT 由 3 个基于 ALBERT 的子网组成，这些子网相互分担重量。**
暹罗系统的输入是文本标题和新闻类别的三元组。该三元组由来自相同类别的两个标题(例如，类别世界新闻)和来自不同类别的一个标题(例如，类别政治)组成。文本标题通过三个子网络，产生三个输出，这些输出被传递到三元半硬损失函数，该函数试图使两个相似类别的输入更接近，同时试图在嵌入空间内使具有不同类别的第三个输入的输入远离。尽管看起来三元连体结构有 3 个网络，但它只有一个网络为每个子网提供相同的权重。因此，子网彼此共享它们的权重。
三重损失
在 2015 年【9】的 Face Net 研究论文中引入了三重损失，以找到一种可扩展的方法来处理人脸识别等任务，这些任务的特点是类别数量多而每类样本数量少。
来源:三重损失嵌入图—由作者创作
一般来说，三联体损失-连体结构可以用于非常不同的目的，例如文本和图像相似性任务。这可以归因于这样的事实，即它允许直接学习从其输入到紧致欧几里得空间的映射，其中距离直接对应于相似性的度量。换句话说，三重损失最小化锚和正之间的距离，最大化锚和负之间的距离。锚和阳性具有相同的类别，而阴性是从不同的类别中取样的。三重态损失函数由欧拉距离函数表示。
来源:三重损失图解—https://www.tensorflow.org/addons/tutorials/losses_triplet
暹罗阿尔伯特实施
但是在我们迷失在理论之前，让我们从实现开始。一如既往，第一步是加载数据集，在我们的例子中，它是《赫芬顿邮报》的数据集，随后，清理和准备数据，以便可以提供给我们的网络。这些步骤已经在前面的章节中简要描述过，用于数据准备的代码结合完整的实现可以在 这里 找到。
在清理和准备好我们的数据之后，我们加载 ALBERT tokenizer 并设置一个数据生成器函数，以实现一个灵活的实现，将我们的数据批量提供给 siamese 模型。
接下来，我们将从 Tensorflow Hub 加载预训练的 ALBERT-base 模型。在这个例子中，暹罗艾伯特网络采用三个输入(单词 _ id、掩码、类型 _ id)。这些不是之前三重损耗输入的锚、正和负,而是艾伯特模型需要的正常输入。在 3 个并行输入之后，加载的艾伯特基网络被合并到暹罗艾伯特中作为单一层，我们将从其中提取汇集输出权重并将它们馈送到 64 维密集层中。密集层之后是 L2 归一化层，而最后的 L2 层对于训练成功至关重要，否则网络会有不稳定的训练迭代和问题收敛。****
你现在可能想知道:为什么没有 3 个独立的子网络或不同的输入流来为网络提供一个锚定的、积极的和消极的类示例？
事实上，我分享的实现不需要配置由 3 个子网络组成的网络架构。在定义我们网络的损耗函数时，我们使用了 Tensorflow Addons 三重半硬损耗【10】函数实现，它在后台处理这个问题。损失函数确保在我们摄入的批次中找到三元组。这个过程被称为在线学习，并确保只训练(在我们的半硬损失函数的情况下)半硬三元组。
此外，我们定义了一个回调函数来保存我们的训练运行。最后，我们用 model.fit()启动训练运行。这些都是训练一个合理的连体网络所需的步骤。完整的代码可以在 这里 访问。
结论
当面临硬件限制时，ALBERT-base 和 ALBERT-large 是生成高质量文本嵌入的优秀语言模型。这两种模式都拥有目前所有可用的预训练语言网络中最好的性能/规模比之一。GPT-3 不是关于许多语言任务的最先进的模型，因此除了语言生成应用之外，不应该考虑使用它。
使用微调技术来进一步提高模型在各种指标上的性能，与传统的微调方法相比，siamese 架构在性能上有所提高，传统的微调方法只是在预训练网络之后添加微调头。
我希望我的发现可以帮助人们在未来建立自己的项目和产品。
感谢您的阅读！
-简·施密茨
参考资料:
[1] SentEval:句子嵌入评估工具包https://github.com/facebookresearch/SentEval
[2]胶水:通用语言理解评测https://gluebenchmark.com/
****[3]小队:史丹福问答数据集【https://rajpurkar.github.io/SQuAD-explorer/ ****
[4] RACE:来自考试的大规模阅读理解数据集https://arxiv.org/pdf/1704.04683.pdf
[5] SWAG:基于常识推理的大规模对抗性数据集https://arxiv.org/pdf/1808.05326.pdf
[6]强力胶:通用语言理解系统的一个更棘手的基准https://arxiv.org/pdf/1905.00537.pdfhttps://super.gluebenchmark.com/
[7]使用“暹罗”时间延迟神经网络的签名验证https://proceedings . neur IPS . cc/paper/1993/file/288 cc 0 ff 022877 BD 3d f 94 BC 9360 B9 c5d-paper . pdf
[8]米斯拉，里沙卜。(2018).新闻类别数据集。10.13140/rg . 2 . 2 . 20331.18729 .https://www . ka ggle . com/datasets/RMI SRA/news-category-dataset—Misra，Rishabh & Grover，Jigyasa。(2021).为 ML 雕刻数据:机器学习的第一步。
****[9] FaceNet:人脸识别和聚类的统一嵌入【https://arxiv.org/pdf/1503.03832.pdf ****
****[10]tensor flow Addons loss:TripletSemiHardLoss【https://www.tensorflow.org/addons/tutorials/losses_triplet ****
[11]用统一的文本到文本转换器探索迁移学习的极限https://arxiv.org/pdf/1910.10683.pdf
生成合成数据以训练 OCR 学习算法
编码和解释合成数据生成的过程，以提高 OCR 学习算法的准确性
数据扩充的效果。来源:作者。
提高低偏差学习算法性能的最可靠方法之一是在大量数据上对其进行训练。尽管获取额外数据的过程看起来可能是一项昂贵的努力，但存在一种令人着迷的技术，允许机器学习从业者生成潜在的无限量的人工数据: 人工数据合成 。
在本文中，我将展示用于生成合成数据的技术，并将它应用于一个众所周知的光学字符识别问题。
目录:
- 人工数据合成
- MNIST 光学字符识别
- 生成人造图像
- 模型选择和培训
- 评估数据扩充的效果
人工数据合成
人工数据合成是以编程方式生成新数据实例的过程，这些数据实例有效地近似底层真实数据。真实数据可以定义为通过真实生活调查或直接测量收集的数据，而人工数据是作为计算机模拟的结果收集的。基本要求是模拟数据反映原始数据的统计特性。截至目前，人工数据生成并不适合每一个机器学习问题，通常需要一定的创造力和洞察力才能将其应用于特定问题。
这种做法可以分为两种截然不同的变化:
- 从头开始生成数据:我们没有任何数据，我们希望创建一个近似真实数据的训练集
- 从小规模的训练集生成数据:我们已经拥有一些训练数据，但我们希望增加它的规模
在本文中，我将探讨后者，因为我已经可以访问数据集。
人工数据合成的基本原理是多样化的。如介绍中所述，一个目标是增加训练规模，作为提高算法性能的手段。另一方面，可以执行相同的技术来保护敏感数据，例如个人身份信息(PII)或个人健康信息(PHI)。最后，合成数据在那些数据稀缺或收集成本高昂的应用中发挥着重要作用。这方面的一个例子是异常检测或欺诈检测:欺诈交易的样本很少，人为伪造它们可能很方便。
马和人的人造图像。来源:谷歌开发者
合成数据经常被用于开发计算机视觉中的学习模型，因为在一些情况下，用计算机生成的数据训练的算法在现实世界中也是有效的。这方面的一个应用由的这篇研究论文来表示，其中使用动物的 CAD 模型来训练学习模型。在这个谷歌开发者笔记本中提供了一个实际应用，其中一个模型用马和人的人工图像进行训练。
最后但同样重要的是，数据扩充在避免过度拟合方面带来了有益的效果。过度拟合模型意味着算法在处理某种类型的数据时变得非常出色，但是，如果我们要求模型处理稍微不同类型的数据，模型的性能将会迅速下降。解决这个问题的一个简单方法是在学习阶段向模型提供更多不同的数据。
考虑这个简单的二进制分类任务:识别狗和猫。如果在训练数据中，所有示例都表示站立或坐着的猫，则模型可能很难正确分类下蛋猫的图像，如下图所示。
产卵猫。来源: Unisplash
一个简单的解决方案是将训练集中的图像旋转 90 °,使它们看起来像下蛋的猫。以这种方式，学习算法更有可能识别更广泛种类的猫图像的特征。
MNIST 光学字符识别
人工数据在像光学字符识别 (OCR)这样的应用中尤其有益，在这些应用中，训练集的大小在模型的广义准确性中起着重要作用。出于这个原因，我想探索合成数据可以做些什么来提高基于 MNIST 库的学习模型的性能。
光学字符识别是一种能够将印刷或手写字符转换为机器可读文本的技术。许多 OCR 模型的训练基于 MNIST 数据集，这是一个手写数字的大型数据库。它包含 70，000 个 28x28 像素的灰度色图。
在这篇文章中，我开发了一个基于 KNN 分类器算法的简单数字识别学习模型。现在的目标是评估一个更大的训练集如何对模型的准确性有价值。
生成人造图像
考虑到训练集由非常小的图像组成，它可以通过在 4 个主要方向(左、右、上、下)上移动每个图像 1 个像素来扩展。通过这种方式，原始数据集被复制了五份。用于图像数据扩充的其他技术是旋转、剪切、缩放、镜像等等。
第一步是导入数据集并检查数据样本的外观。
# Import the library
from sklearn.datasets import fetch_openml# Import the dataset
mnist = fetch_openml('mnist_784', version = 1)
mnist.keys()# Fetch the data
X = mnist["data"].values
y = mnist["target"].astype(np.uint8).values# Define function to print the images
def print_digit(index):
example = X[index]
example = example.reshape(28,28)
plt.imshow(example, cmap='viridis')
plt.axis('off')# Give a look at some images
print_digit(26)
输出应该如下所示:
在分割了训练集和测试集之后，我定义了数据扩充的函数。它将图像和定义移动方向和幅度的向量作为输入。移动的结果是，图像的一些像素将会是空白的。为了保持图像的原始形状，我们可以定义这些像素的填充方法。默认情况下，它们用 0.0 的浮点数填充。
from sklearn.model_selection import train_test_split
from scipy.ndimage import shift# Split train test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# Define function to shift an image by a given vector
def shift_digit(img, vector, fill_with=0.0):
img = img.reshape(28,28)
img_shifted = shift(img, vector, cval=fill_with)
# Return unrolled image array
return img_shifted.flatten()
我们来看看将原图下移 5 个像素的效果。
shift1 = shift_digit(X[26], (5,0))
plt.imshow(shift1.reshape(28,28), cmap='viridis')
下移图像的效果。来源:作者。
接下来的步骤是获取训练集中的每幅图像，并在 4 个主要方向上移动 1 个像素。测试集保持不变。
# Convert dataset into lists
X_train_augment = list(X_train)
y_train_augment = list(y_train)# Loop through training images and shift them
for (dx, dy) in ((1,0), (0,1), (-1,0), (0,-1)):
for image, label in zip(X_train, y_train):
row_shifted = shift_digit(image, (dx, dy))
# Append shifted image and label
X_train_augment.append(row_shifted)
y_train_augment.append(label)# Convert back to np.array
X_train_augment= np.array(X_train_augment)
y_train_augment= np.array(y_train_augment)
原始训练集包含 56000 个训练样本，扩充后的训练集包含 280000 个样本。
模型选择和培训
为了衡量人工数据合成的好处，我将使用 2 个随机森林分类器分别在原始集和扩充集上训练它们。然后，我将在相同的测试集上比较它们的准确度分数。
由于随机森林分类器的工作原理超出了本文的范围，我建议阅读本介绍性指南。简而言之，随机森林是决策树的集合。为了确保多样性，通常在训练集的不同随机子集上训练树(有或没有替换)。在多数投票后，随机森林考虑每个弱分类器的决定，并输出聚合预测。
对于原始训练集和扩充集，我在相同的参数空间上执行交叉验证。
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV# Initialize the classifier
clf = RandomForestClassifier(random_state=42)# Definte the parameter space
param_space = {'n_estimators': [100, 200], 'min_samples_split': range(2,8,2)}# Find best parameters in the parameter space without augmentation
grid_no_augment = GridSearchCV(clf, param_grid=param_space, scoring="accuracy", n_jobs=-1, cv=5, verbose=4)
grid_no_augment.fit(X_train, y_train)# Find best parameters in the parameter space with augmentation
grid_augment = GridSearchCV(clf, param_grid=param_space, scoring="accuracy", n_jobs=-1, cv=5, verbose=4)
grid_augment.fit(X_train_augment, y_train_augment)
评估数据扩充的效果
现在这两个模型都训练好了，我可以评估它们的准确性了。
from sklearn.metrics import accuracy_score# Get the models
model_no_augment = grid_no_augment.best_estimator_
model_augment = grid_augment.best_estimator_# Evaluate the models accuracies
accuracy_no_augment = accuracy_score(y_test, model_no_augment.predict(X_test))
accuracy_augment = accuracy_score(y_test, model_augment.predict(X_test))
结果显示，未经增强的准确率为 96.8%，而基于增强数据训练的相同模型的准确率为 97.8%。仅通过将训练集中的每幅图像移动 1 个像素，该模型的准确度就提高了整整 1%。原因之一是模型变得不太容易过度适应训练集。
对于最后一个分析，我将计算混淆矩阵，以了解哪些是最常见的分类错误。
混乱矩阵。来源:作者。
可以看出，最常见的错误分类是 9 被错误地归类为 4，2 被归类为 3。
结论
数据扩充被证明是计算机视觉的一种有效技术，因为它允许廉价而简单地提高模型的性能。
尽管如此，重要的是要记住，在某些情况下，数据扩充并不同样有效。一种情况是测试集与原始训练集非常相似。在这种情况下，增加训练集是没有帮助的，因为模型将根据与测试阶段遇到的数据不同的数据进行训练。
用人工智能生成维基百科文章
原文：https://towardsdatascience.com/generating-wikipedia-articles-with-ai-995436c9f95f
播客
Meta AI 研究员 Angela Fan 谈改进维基百科的挑战和重要性
编者按:TDS 播客由杰雷米·哈里斯主持，他是人工智能安全初创公司墨丘利的联合创始人。每周，Jeremie 都会与该领域前沿的研究人员和商业领袖聊天，以解开围绕数据科学、机器学习和人工智能的最紧迫问题。
生成引用良好且准确的维基百科文章一直是一个重要的问题:维基百科基本上已经成为互联网的记录百科全书，数亿人通过它了解世界。
但在过去十年中，维基百科也成为了数据饥渴的文本生成模型的重要训练数据来源。因此，维基百科内容中的任何缺点都有被未来的文本生成工具放大的风险。如果一种类型的主题或人物在维基百科的语料库中长期代表性不足，我们可以期待生成文本模型在其输出中反映甚至放大这种代表性不足。
从这个角度来看，维基百科文章生成的项目远比它看起来的要多——它实际上是为未来的语言生成系统设置场景，并授权人类以更强大的方式引导这些系统。
这就是为什么我想和 Meta AI 研究员 Angela Fan 谈谈，她的最新项目专注于生成可靠、准确和结构化的维基百科文章。在这一集的 TDS 播客中，她和我一起谈论了她的工作、高质量长格式文本生成的意义以及人类/人工智能合作的未来。
以下是我在对话中最喜欢的一些观点:
- 为了生成连贯和结构良好的维基百科文章，Angela 和她的合作者能够使用一个相当普通的基于 transformer 的架构，并做了两处有趣的修改。首先，维基百科的文章需要参考文献，而普通的变形金刚无法生成这些参考文献。因此，Angela 的系统转而查询公共抓取数据集，以找到贯穿生成的文章的主张的支持证据。该系统还使用缓存机制来确保在文章的前面部分中生成的信息可以被模型在生成新的部分时调用。这克服了 transformer 上下文窗口的有限大小，并确保模型总是有相关的信息，即使它来自文章的更早部分。
- 评估生成的文本可能是棘手的，公平地说，没有一个单一的指标能够完全捕捉到人类评估的所有细微差别。出于这个原因，虽然 Angela 和她的合作者确实使用传统的度量标准评估了生成的样本的质量，但他们用人工审查补充了这种分析。为了被人类评论者视为“准确”，一个句子需要事实正确，并且在语气和风格上与其他维基百科文章一致。这是一个很高的标准，但据 Angela 估计，50%的生成句子确实达到了这个标准——虽然这可能还不足以让她的系统推广到更广泛的世界，但它可以有意义地加快人类作家的工作，他们的责任可以从最初的研究转向事实检查。
- 人们常说，语言模型可以使它们的训练数据中的偏见永久化，事实的确如此。但是安吉拉指出，他们经常超越复制这些基础，实际上是放大它们。例如，如果文本语料库中 60%的代词是女性“她”，则很典型地会发现“她”在生成的文本中会被过度表示，因为语言模型通常喜欢“谨慎行事”，生成的文本片段单独来说更能反映训练集，但总的来说会放大现有趋势。
你可以在这里查看安吉拉的作品，或者在推特上关注我。
章节:
- 0:00 介绍
- 1:45 进入 Meta AI 的旅程
- 5:45 过渡到维基百科
- 11:30 文章如何生成
- 18:00 文本质量
- 21:30 准确度指标
- 25:30 出现幻觉的风险
- 30:45 跟上变化
- 36:15 用户界面/UX 问题
- 45:00 性别失衡的技术原因
- 51:00 总结
Python 中使用 Skip-Gram 算法和深度学习从文本数据生成单词嵌入
使用人工神经网络和 Gensim 介绍自然语言处理中的嵌入
莱昂纳多·大久保俊郎在 Unsplash 上的照片
1.介绍
NLP 中最大的挑战是设计一种方法来表示单词的意思。这是一个关键的组成部分，因为不同的人以不同的方式传达相同的信息。例如，“我喜欢这里的食物”和“食物质量似乎不错”。我爱死了！”在一天结束的时候，两个文本都反映了一个由一系列单词或短语代表的想法或思想。在分布语义学中，一个词的含义是由最频繁出现在附近的词给出的。当一个词(w) 出现在一个句子中时，其 上下文 是出现在附近(在固定的窗口大小内)的词的集合或序列。例如，
- “我们可以使用传统的机器 学习 算法来创建驱动程序模型。”
- “建深 学 框架是当务之急。”
- “我们能否使用传统的方法，将学习 转向 提高绩效？”
在 NLP 中，我们可以使用学习的上下文词(例如，(机器，算法)，(深度，框架)，(转移，朝向))来构建学习的向量表示。稍后我们会谈到单词向量。
2.什么是单词嵌入？
在自然语言处理(NLP)中使用单词嵌入来描述如何为文本分析表示单词。通常，这种表示采用实值向量的形式，该向量对单词的含义进行编码，期望在向量空间中彼此更接近的单词将具有相似的含义。在称为单词嵌入的过程中，每个单词被表示为预定向量空间中的实值向量。这种方法被称为深度学习，因为每个单词都被分配给一个向量，向量值就像神经网络一样被学习(Jason Browniee，2017)。
2.1 嵌入的示例
对每个单词采用密集分布的表示对于产生嵌入的方法是必要的。通常具有几十、几百甚至几千维的实值向量代表每个单词。相比之下，稀疏单词表示，如一键编码，需要数千或数百万维。
这是一个简单的例子，展示了两个不同的单词在三维空间中的表现。请注意，向量符号和假设值表示单词“Angel”和“Eugene”
天使= 3i + 4j + 5k，尤金= 2i + 4j + 4k
嵌入的妙处在于它允许我们计算单词的相似度。这里的相似代表语境，不一定代表意义。比如说，如果我们用一个余弦相似度，那么相似度(安吉尔，尤金)=(3 x2+4 x4+5 x4)/(sqrt((3+4+5))x sqrt(2+4+4))= 42/42.42 = 0.99 或者 99% 相似度。您可能想知道为什么这种相似性在 NLP 中很重要。这纯粹是为了让模型将单词上下文化，以便出现在相似上下文中的单词具有相似的含义。为了验证这一点，我们来看看下面的两句话。
- “安吉尔和尤金正在做一个项目提案，并计划明天推出.”
- “Eugene 对模型验证的意见似乎是正确的。安吉尔，你能实现这些改变吗？”
虽然我们在这里看的是两句话，看起来安吉尔和尤金是队友；因此，相似性仍然很高。同样，这不是单词是否有相似的意思，而是它们是否出现在相似的上下文中或共现。
3.基本嵌入模型
3.1 简单概率模型
简单的概率模型可以使用链式规则来计算单词在文本中出现的概率。它可以使用组合关系来识别共现单词并计算它们的概率。下面的例子。
公式 1: 简单概率模型。作者使用 Latex & Jupyter 笔记本创建的图像。
p(天使玩的好)= p(天使)x p(玩|天使)x p(玩的好|天使)。计算这些概率需要计算单词和术语的出现次数。尽管越来越复杂和精确，像这样的直接概率模型还没有达到很好的性能。
3.2 Word2vec
学习单词向量的框架叫做 Word2vec。Word2vec 是一个神经网络，它使用单词“矢量化”来解析文本。它接受文本语料库作为输入，并产生代表语料库中的单词的一组特征向量。将相似的词向量在向量空间中分组在一起是 Word2vec 的目标和好处。Word2Vec 中有两种截然不同的架构:跳格和连续字包 (CBOW)。
假设我们有大量的文本。在固定的词汇表中，每个单词由一个向量表示。我们使用以下逐步方法计算嵌入:
- 浏览文本的每个位置 t ，每个位置都有一个 居中的单词 c
- 语境(或“外界”) 中的词表示为 o
- 使用 c 和 o 的词向量的相似度，计算给定 c 的 o 的可能性。(反之亦然)
- 继续修改单词向量到增加这种可能性
跳过克模型
在跳格模型中，我们试图对给定特定单词的上下文单词(例如，单词窗口大小)进行建模。
例如，如果我们有文本“Angel 踢足球踢得好”，考虑足球作为中心词(假设)，剩余的词成为上下文。窗口大小表示我们想要考虑多少上下文单词。窗口大小示例和使用两个不同示例计算概率的过程。
图 1: 跳格模型示例。图表用两个不同的例子展示了中心词和上下文词的概念。这里 t 表示中心单词的位置，而 t-1 和 t+1 表示上下文单词的位置。作者使用 PowerPoint 创建的图像。
**图二。**说明了 Skip Gram 模型的似然函数。在真实的单词中，训练一种算法来最大化这种可能性，这将导致使用嵌入更准确地表示单词。图片由作者使用 Latex & Jupyter 笔记本创建。
使用 Gensim 生成基于跳格图的嵌入的 3.2.1.1 示例
Gensim 是一个开源框架，使用现代统计机器学习进行无监督的主题建模、文档索引、嵌入创建和其他 NLP 功能。我们将使用 Gensim 中的一些标准文本来创建单词嵌入。
#----------------------------------------Install and import necessary libraries-----------------------------------# !pip install contractionsimport re, string, unicodedata # Import Regex, string and unicodedata.
import contractions # Import contractions library.
from bs4 import BeautifulSoup # Import BeautifulSoup.import numpy as np # Import numpy.
import pandas as pd # Import pandas.
import nltk # Import Natural Language Tool-Kit.# nltk.download('stopwords') # Download Stopwords.
# nltk.download('punkt')
# nltk.download('wordnet')from nltk.corpus import stopwords # Import stopwords.
from nltk.tokenize import word_tokenize, sent_tokenize # Import Tokenizer.
from nltk.stem.wordnet import WordNetLemmatizer # Import Lemmatizer. For removing stem words
import unicodedata # Removing accented characters
from nltk.stem import LancasterStemmerfrom IPython.display import display
这些包对于数据清理和预处理非常有用。
import gensimfrom gensim.models import Word2Vecfrom gensim.test.utils import common_textscommon_texts[['human', 'interface', 'computer'],
['survey', 'user', 'computer', 'system', 'response', 'time'],
['eps', 'user', 'interface', 'system'],
['system', 'human', 'system', 'eps'],
['user', 'response', 'time'],
['trees'],
['graph', 'trees'],
['graph', 'minors', 'trees'],
['graph', 'minors', 'survey']]
在 Word2Vec()中使用 sg=1 创建一个跳格模型。向量大小表示由模型产生的每个单词的嵌入数量。窗口表示窗口大小，即用于生成嵌入的上下文单词的数量。
model = Word2Vec(sentences=common_texts, vector_size=3, window=5, min_count=1, workers=4, sg=1)
model.save(“word2vec.model”)print("Embeddings of a Word computer with 3 as Embedding Dimension")print(model.wv['computer'])print("Embeddings of a Word Tree with 3 as Embedding Dimension")print(model.wv['trees'])print("Embeddings of a Word Graph with 3 as Embedding Dimension")print(model.wv['graph'])Embeddings of a Word computer with 3 as Embedding Dimension
[ 0.19234174 -0.2507943 -0.13124168]
Embeddings of a Word Tree with 3 as Embedding Dimension
[ 0.21529572 0.2990996 -0.16718094]
Embeddings of a Word Graph with 3 as Embedding Dimension
[ 0.3003091 -0.31009832 -0.23722696]
我们现在将这些嵌入转换成一个列表，并使用 matplotlib()创建一个可视化。如果您检查嵌入的值，它们可能没有什么意义，但是当用图形表示时，它们应该看起来彼此更接近。
inter_array=model.wv['human']
comp_array=model.wv['user']
tree_array=model.wv['interface']from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt%matplotlib inline
c=[10,20,30]labels=['human', 'user', 'interface']fig = plt.figure(figsize=(10, 8))
ax = plt.axes(projection ='3d')
# defining all 3 axes
z = [comp_array[2], inter_array[2], tree_array[2]]
x = [comp_array[0], inter_array[0], tree_array[0]]
y = [comp_array[1], inter_array[1], tree_array[1]]
# plotting
ax.scatter(x, y, z, color=['red','green','blue'])ax.text(comp_array[0],comp_array[1],comp_array[2], "human")
ax.text(inter_array[0],inter_array[1],inter_array[2], "user")
ax.text(tree_array[0],tree_array[1],tree_array[2], "interface")ax.legend(loc="lower right")ax.set_title('3D Representation of words - computer, graph, and tree')
plt.show()
**图 3。**使用从 Gensim 生成的嵌入，单词“界面”、“用户”和“人”的三维表示。作者使用 Jupyter 笔记本创建的图像。
3.2.2 连续词袋(CBOW)
在连续词袋(CBOW)模型中，我们试图在给定其周围词(例如，词窗口大小)的情况下对中心词进行建模。
**图 4:**CBOW 模型的例子。与 Skip Gram 类似，CBOW 的可能性函数如上所示。作者使用 Jupyter 笔记本和 Latex 创建的图像。
4.从头开始实现 Skip Gram 模型
我们将使用随机生成的关于梅西和罗纳尔多的数据，并通过训练神经网络模型来尝试和开发单词嵌入(Bujokas，2020)。我们将把嵌入的大小保持为两个，允许我们用 Python 创建一个图，并直观地检查给定上下文中哪些单词是相似的。你可以在这里找到作者生成的样本数据。
4.1 基本 NLP 库
import itertools
import pandas as pd
import numpy as np
import re
import os
from tqdm import tqdm#----------------------Drawing the embeddings in Python
import matplotlib.pyplot as plt#-----------------------Deep learning: ANN to create and train embeddings
from tensorflow.keras.models import Modelfrom tensorflow.keras.layers import Input, Dense
4.2 用户自定义函数:从数据到字典的单词/记号
创建字典的用户定义函数，其中键代表唯一的单词，键值是索引或索引。
def create_unique_word_to_dict(sample):
"""
User defined function that creates a dictionary where the keys represents unique words
and key values are indices or indexes
"""
#-------Extracting all the unique words from our sample text and sorting them alphabetically
#-------set allows us to remove any duplicated words and extract only the unique ones
words_list = list(set(sample))
#-------------Sort applied here
words_list.sort()#------Creating a dictionary for each unique words in the sample text
unique_word_dict_containing_text = {}
for i, word in enumerate(words_list): #------For each word in the document
unique_word_dict_containing_text.update({
word: i
})return unique_word_dict_containing_text
4.3 用户自定义功能:数据清理或文本预处理
这是一个自定义的文本预处理函数。人们可以增强这里使用的停用词列表，以说明更频繁使用的不需要的词。我们使用该功能执行以下操作:
- 删除标点符号
- 删除号码
- 删除空白
- 删除停用词
- 返回清除的文本
def text_preprocessing_custom(sample_text):
#---------------Custome Text Preprocessing created as UDF-----------------------------
#----------------Regular expression for Punctuations------------------
punctuations = r''';:'"\,<>./?*_“~'''
#---------------Stop Words (Custom List)--------------------
stop_words=['i', 'dont', 'we', 'had','and', 'are', 'of', 'a', 'is', 'the', 'in', 'be',\
'will', 'this', 'with', 'if', 'be', 'as', 'to', 'is', 'don\'t']
"""
A method to preproces text
"""
for x in sample_text.lower():
if x in punctuations:
sample_text = sample_text.replace(x, "")#-------------Removing words that have numbers in them using regular expression---------
sample_text = re.sub(r'\w*\d\w*', '', sample_text)#-------------Removing whitespaces---------------------
sample_text = re.sub(r'\s+', ' ', sample_text).strip()# --------Convert to lower case----------------------
sample_text = sample_text.lower()#--------------Converting all our text to a list------------------
sample_text = sample_text.split(' ')#--------------Deleting empty strings---------------------
sample_text = [x for x in sample_text if x!='']# Stopword removal
sample_text = [x for x in sample_text if x not in stop_words]return sample_text
4.4 数据预处理和[中心，上下文]单词生成
牢记 Skip Gram 模型的概念，我们需要创建一个框架，允许我们使用大小为 2 的窗口从文本中识别中心词和上下文词的所有组合。请注意，给定文本中的每个单词(经过预处理后)在一个实例中可以是中心单词，在另一个实例中可以是上下文单词。理想情况下，我们允许文本中的每个单词作为中心单词，然后相应地找到相关的上下文单词。
from scipy import sparsesample = pd.read_csv('Text Football.csv') #-----Reading text datasample = [x for x in sample['Discussion']]print("--"*50)print("Text in the File")print("--"*50)print(sample)
#----------------------------------------Defining the window for context----------------------------------------
window_size = 2
#----------------------------------------Creating empty lists to store texts---------------
word_lists = []
all_text = []#----------------Combines preprocessed texts from the Sample Datafor text in sample:
#----------------------------------------Cleaning the text
text = text_preprocessing_custom(text)
all_text += text#-------------------------Iterating across each word in a text
for i, word in enumerate(text):for ws in range(window_size):if i + 1 + ws < len(text):
word_lists.append([word] + [text[(i + 1 + ws)]])if i - ws - 1 >= 0:
word_lists.append([word] + [text[(i - ws - 1)]])
unique_word_dict = create_unique_word_to_dict(all_text)print("--"*50)
print("Text to Sequence in post cleaning")
print("--"*50)
print(unique_word_dict)
print("--"*50)
print("Text to WordList [main word, context word]")
print("--"*50)
print(word_lists)
图 5: 如何生成中心(主要)和上下文单词的示例。作者使用 Jupyter 笔记本创建的图像。
4.5 为神经网络生成输入和输出数据
我们现在将使用主要单词(中心单词)作为神经网络的输入，使用上下文单词作为输出。输入和输出层之间的深层致密层将学习嵌入。想法是在单个隐藏层内训练一个 2 神经元神经网络，其中在训练模型时学习的权重将反映从数据中学习的嵌入。为了让我们的数据与 Tensorflow 架构兼容，我们对上面生成的主单词和上下文单词列表执行了一次热编码(OHE)。
def create_OHE_data(word_dict, word_lists):#----------------------------------------Defining the number of unique words----------------------------------------
n_unique_words = len(word_dict)#----------------------------------------Getting all the unique words----------------------------------------
words = list(word_dict.keys())#----------------------------------------Creating the X and Y matrices using one hot encoding---------------------------------
X = []
Y = []for i, word_list in tqdm(enumerate(word_lists)):#----------------------------------------Getting Indicies----------------------------------------index_main_word = word_dict.get(word_list[0])
index_context_word = word_dict.get(word_list[1])#----------------------------------------Creating the placeholders
Xrow = np.zeros(n_unique_words)
Yrow = np.zeros(n_unique_words)#----------------------------------------One hot encoding the main word, Input Matrix
Xrow[index_main_word] = 1#----------------------------------------One hot encoding the Y matrix words, Output Matrix
Yrow[index_context_word] = 1#----------------------------------------Appending to the main matrices
X.append(Xrow)
Y.append(Yrow)#------------------------Converting the matrices into a sparse format because the vast majority of the data are 0s
X_Matrix = sparse.csr_matrix(X)
Y_Matrix = sparse.csr_matrix(Y)print("--"*50)
print("Input Data [Showing the First Record]")
print("--"*50)print(X_Matrix.todense()[0])
print(X_Matrix.todense().shape)print("--"*50)
print("Output Data [Showing the first record]")
print("--"*50)print(Y_Matrix.todense()[0])
print(Y_Matrix.todense().shape)
return X_Matrix, Y_MatrixX, Y = create_OHE_data(unique_word_dict, word_lists)
**图 6:**OHE 生成输入输出数据的例子。作者使用 Jupyter 笔记本创建的图像。
4.6 训练神经网络以生成嵌入
下面展示了一个示例架构的外观。
图 7: 示出了用于训练嵌入的双神经元神经网络。作者使用 PowerPoint 开发的图像。
from tensorflow.keras.models import Sequentialdef embedding_model():
model=Sequential()
model.add(Dense(2, input_shape=(X.shape[1],), activation='relu'))
model.add(Dense(units=Y.shape[1], activation='softmax'))
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam')
return modelmodel_embbedding=embedding_model()model_embbedding.summary()#----------------------------------------Optimizing the network weights----------------------------------------
model_embbedding.fit(
x=X.todense(),
y=Y.todense(),
batch_size=64,
epochs=1000,
verbose=0
)#----------------------------------------Obtaining the weights from the neural network----------------------------------------
#----------------------------------------These weights are equivalent to word embeddings--------------------------------------weights = model_embbedding.get_weights()[0] #---embeddings#----------------------------------------Creating Dictionary to Store Embeddings----------------------------------------
embedding_dict = {}
for word in words_list:
embedding_dict.update({
word: weights[unique_word_dict.get(word)]
})
embedding_dict
图 8: 从模型中生成的嵌入示例。作者使用 Jupyter 笔记本创建的图像。
# !pip install ann_visualizerfrom ann_visualizer.visualize import ann_vizann_viz(model_embbedding, view=True, filename='embed.pdf', title='ANN Architecture for embedding')
**图九。**说明了用于生成嵌入的人工神经网络架构。作者使用 Jupyter + ann_visualizer()开发的图片
4.7 直观地表示学习到的嵌入
#----------------------------------------Ploting the embeddings----------------------------------------
plt.figure(figsize=(15, 10))import seaborn as snssns.set(color_codes=True)plt.title("Embeddings")for word in list(unique_word_dict.keys()):
coord = embedding_dict.get(word) #------------------------Extracting Embeddings
plt.scatter(coord[0], coord[1]) #-----------------------Plotting Embeddings
plt.annotate(word, (coord[0], coord[1])) #----------------Annotate tokens
图 9: 从模型中生成的嵌入的可视化表示。作者使用 Jupyter 笔记本创建的图像。
4.8 观察
在足球界，梅西和罗纳尔多经常被全球球迷拿来比较。因此，它们更有可能在数据中同时出现。像“最伟大”、“球员”、“得分”和“得分外”这样的术语经常被用来评论球员的表现。使用随机生成的 12 个文本，我们在上图中捕捉到了这些变化和共现。注意少数停用词没有被删除；因此他们出现在情节中。这可以使用我们的 text_preprocessing_custom()函数来增强。正如前面所反映的，当我们研究数值时，图 8 中的嵌入可能没有多大意义。尽管如此，当绘制时，我们推断在相似上下文中使用的共现单词看起来彼此更接近。
5.结论
Tensorflow 的递归神经网络提供了一个嵌入层，可以在我们训练分类器模型时自动从文本中生成嵌入。这个过程包括使用文本矢量化将单词或句子映射到向量或一组数字。我们的独热向量——稀疏，因为它的大多数条目都是零——被嵌入层转换成密集的嵌入向量(密集，因为维度小得多，并且所有元素都是自然数)。它只需要一个完全连接的层来构成这个嵌入层(张量流，n.d .)。然而，当我们训练分类模型时，训练嵌入是耗时的。在这种情况下，如果我们有大量的数据，生成嵌入的灵活性允许我们减少创建分类模型所涉及的计算时间。嵌入也是比传统方法更好的单词表示，如单词袋和词频-逆文档频率。其他预先训练的模型，如伯特，生物伯特，手套，Edu 伯特等。，为用户提供使用预训练模型生成嵌入的灵活性。
6.参考
- 布约卡斯，E. (2020 年 5 月 30 日)。创建单词嵌入:使用深度学习在 Python 中编码 Word2Vec 算法。从中观网站检索:https://towards data science . com/creating-word-embeddings-coding-the-word 2 vec-algorithm-in-python-using-deep-learning-b 337d 0 ba 17 a 8
- 杰森·布朗尼。(2017 年 10 月 10 日)。什么是文本的单词嵌入？从机器学习大师网站检索:https://machinelementmastery . com/what-are-word-embedding/
- 张量流。(未注明)。基于 RNN 的文本分类。从 TensorFlow 网站检索:https://www . tensor flow . org/text/tutorials/text _ classification _ rnn
关于作者:高级分析专家和管理顾问，帮助公司通过对组织数据的商业、技术和数学的组合找到各种问题的解决方案。一个数据科学爱好者，在这里分享、学习、贡献；可以和我在 上联系 和 推特；
具有深度学习风格转移的合成微生物数据集的生成
生成用于训练深度学习检测器的带注释的合成数据集的有效策略
作者图片。
深度学习模型实现了比传统计算机视觉算法高得多的精确度。当使用传统方法进行图像识别时，特征提取算法是手动调整的，这在许多情况下是一个耗时的过程。相反，在深度卷积网络中，特征工程是自动执行的——网络学习如何自己提取最佳特征图，并在后续卷积中优化内核，以仅保留图像中的相关信息。
所以现在我们不需要花费数周时间来寻找最佳参数。但这是有代价的。为了通过复杂的深度学习模型获得足够的结果，我们需要足够大的数据集。收集和注释大数据集需要大量的时间和财力。此外，贴标过程本身也具有挑战性。合成数据是一种很有前途的替代方法，可以解决缺乏足够大的数据集的问题，并减少与收集此类数据相关的资源和成本[1]。此外，它可能有助于机构共享知识，例如高度专业化领域的数据集，同时保护个人隐私。
我们的目标是识别培养皿上的微生物菌落——这是微生物学中的典型任务。即使对训练有素的专业人员来说，这项任务也很难完成，因为有些菌落容易聚集和重叠，因此非专业人员很难分辨。在这篇文章中，我们将提出一种有效的策略来生成一个由微生物图像组成的带注释的合成数据集，我们已经在自然科学报告杂志【2】上发表了该数据集。然后，生成的数据集用于以完全监督的方式训练深度学习对象检测器。该生成器采用传统的计算机视觉算法以及神经类型的传输方法进行数据扩充。我们表明，该方法能够合成逼真图像的数据集，该数据集可用于训练能够定位、分割和分类五种不同微生物物种的神经网络模型。我们的方法比收集并标记一大组带有注释的真实图像需要更少的资源来获得有用的数据集。
我们表明，从 100 幅真实图像开始，我们可以生成数据来训练一个检测器，该检测器可以获得与同一检测器相当的结果[3]，但要在一个真实的、大几十倍的微生物数据集 [4]上进行训练，该数据集包含超过 7k 幅图像。
生成合成数据集
现在让我们详细描述该方法。目标是生成带有微生物菌落的合成图像，这些图像将在以后用于训练深度学习检测和分割模型。管道如图 1 所示。注意，我们的生成框架的 Python 实现的源代码是公开可用的。
图一。一种合成数据集生成流水线方案。使用传统的计算机视觉算法从真实图像中分割出微生物菌落，然后随机排列在空盘子的碎片上，给出带有精确注释的合成补丁。为了提高生成的数据的真实性，然后使用神经风格转移方法对面片进行风格化。图改编自[2]。
我们从培养皿的标记真实图像开始，使用传统的计算机视觉算法进行菌落分割，包括适当的过滤、CIELab 颜色空间中的阈值处理和基于能量的分割——我们使用强大的 Chan-Vese 算法。为了获得一个平衡的工作数据集，我们从最近推出的琼脂数据集【4】的高分辨率子集中为 5 种微生物物种中的每一种随机选择 20 张图像(总共给出 100 张图像)，这些图像可以根据请求从这个站点免费下载。
第二步，将分割的菌落和菌落簇随机排列在空培养皿的碎片上(我们称之为贴片)。我们从 10 个真实的空盘子图像中随机选择一个片段。我们重复这个步骤很多次，把随后的集群放在随机的地方，确保它们不重叠。与此同时，我们存储了放置在小块上的聚类中每个菌落的位置及其分割掩码，为该小块创建了一个注释字典。我们在图 2 中展示了生成的合成补丁的例子。
图二。在风格化步骤之前具有微生物菌落的合成贴片的实例。图改编自[2]。
正如我们在图 2 中所看到的，在某些情况下，菌落不能很好地与背景融合，它们的颜色与背景颜色不匹配。为了解决这个问题并提高生成数据的真实性，在第三步中，我们使用神经类型转移方法应用数据扩充。我们将风格从作为风格载体的选定实像之一转移到给定的原始面片。我们选择了 20 个具有显著不同光照条件的真实片段，以增加生成的碎片的多样性。风格化步骤后的示例性贴片如图 3 所示。我们使用[5]中介绍的快速有效的深度学习风格化算法。这种方法为我们的原始微生物图像提供了最真实的风格化，而不会引入任何不想要的伪像。
图 3。生成的微生物图像的风格化。五个合成补片(左)使用五个真实图像(上)的样式进行风格化。图改编自[2]。
训练深度学习模型
使用这种方法，我们生成了大约 50k 个补丁，然后进行了风格化处理。所进行的实验背后的想法是使用合成数据训练一个神经网络模型来检测微生物菌落，然后用培养皿上的细菌菌落在真实图像上测试其性能。我们使用我们的合成数据集训练流行的 R-CNN 检测器。图 4 给出了对琼脂数据集的真实斑块进行级联 R-CNN [6]检测器评估的示例。该模型在不同光照条件下检测各种大小的微生物菌落表现得相当好。
自动实例分割是在许多生物医学应用中有用的任务。在面片生成过程中，我们还为每个菌落存储一个像素级的分割掩模。我们使用这些额外的信息来训练深度学习实例分割模型——Mask R-CNN[7]，它扩展了我们已经训练过的 R-CNN 检测器。真实样本的分割结果也呈现在图 4 中。获得的不同微生物菌落类型的实例分割正确地再现了菌落形状。
图四。真实数据上的微生物菌落检测示例(用绿色边框标记)—来自琼脂数据集的不同微生物种类的培养皿片段。例如分割的结果被呈现为颜色分割遮罩。图改编自[2]。
物体检测在微生物学中的主要应用之一是对培养皿上生长的微生物菌落进行自动计数。我们通过将其与标准方法进行比较来验证所提出的合成数据集生成方法，在标准方法中，我们收集大的真实数据集并训练检测器用于菌落识别和计数任务。
我们在使用来自高分辨率琼脂子集的 100 图像生成的 50k 大数据集上训练 R-CNN 检测器(Cascade ),并在与【4】中执行的相同任务中测试微生物菌落计数。结果如图 5(右)所示。结果表明，合成数据集的检测精度和计数误差仅比同一检测器稍差[3]，但在包含超过 7k 真实图像的整个大数据集上进行训练，给出了大约 65k 个面片。同样清楚的是，引入风格转移增强大大提高了检测质量，并且在没有风格化步骤的情况下，结果相当差——参见图 5(左)中的原始数据集的结果，即在没有风格化步骤的情况下获得的结果。
*图 5。对两个不同的合成训练数据集的真实数据进行微生物菌落计数测试:*raw——无风格化(左)和风格化(右)。风格化大大提高了检测性能。在理想的检测中，代表单个培养皿图像的每个黑点应该位于 y = x 黑线上。图改编自[2]。
摘要
我们引入了一种有效的策略来生成培养皿微生物图像的带注释的合成数据集，该数据集可用于以完全监督的方式训练深度学习模型。通过使用传统的计算机视觉技术，辅以深度神经类型转移算法，我们能够建立一个仅提供 100 幅真实图像的微生物数据生成器。与收集和标记包含数千幅真实图像的大型数据集相比，它需要的精力和资源要少得多。
我们证明了该方法在微生物检测和分割中的有效性，但是我们期望该方法具有灵活性和通用性，还可以应用于科学和工业的其他领域来检测各种对象。
参考
[1]https://blogs . NVIDIA . com/blog/2021/06/08/what-is-synthetic-data
[2]j . paw owski，S. Majchrowska 和 T. Golan，具有深度学习风格转移的微生物菌落数据集的生成，科学报告 12，5212 (2022)。https://doi.org/10.1038/s41598-022-09264-z
[3]检测 mAP = 0.416(越大越好)，计数 MAE = 4.49(越小越好)指标，与 mAP = 0.520 和 MAE = 4.31 相比，获得了相同的检测器，但使用琼脂数据集进行了训练[4]。
[4] S. Majchrowska，J. Pawł owski，G. Guł，T. Bonus，A. Hanas，A. Loch，A. Pawlak，J. Roszkowiak，T. Golan 和 Z. Drulis-Kawa，琼脂微生物菌落数据集用于深度学习检测 (2021)。可在 arXiv[arXiv:2108.01234]获得预印本。
[5]，叶春阳，，用于真实感风格传递的高分辨率网络 (2019)。预印本可从 atXiv[arXiv:1904.11617]获得。
[6]蔡志勇和，级联 R-CNN:深入研究高质量目标检测，IEEE/CVF 计算机视觉与模式识别会议，6154–6162(2018)。
[7] K. He，G. Gkioxari，P. Dollár，R. Girshick， Mask R-CNN ，IEEE 计算机视觉国际会议(ICCV)，2980–2988(2017)。
作为精明增长运营计划的一部分，该项目由欧洲区域发展基金下的欧盟基金共同资助。作为国家研究与发展中心的一部分实施的项目:快速通道。
原载于 2022 年 5 月 06 日【https://neurosys.com】。
生成性对抗学习
原文：https://towardsdatascience.com/generative-adversarial-learning-b1d5b4f6b2bc
从生成性到“加对抗性”
由german Kaser在 Unsplash 上拍摄的照片
假设我们有一个真实图像的数据集。比如各种场景下的狮子图片。从这个数据集中，我们希望机器学习生成看起来像真实图像的新图像。
生成对抗网络，简称 GANs，是解决这一问题的一种令人信服的方法。
GAN 包括两个模型，一个发生器和一个鉴别器。生成器生成合成图像。鉴别器被训练来区分真实图像和合成图像。
生成器通过来自鉴别器的反馈进行学习。鉴别器识别它检测到的合成图像中的哪些是假的。发电机显然应该产生更少的能量。因为它们很容易被发现是假货。
发电机和鉴别器在战斗中被锁定。他们试图超越彼此。来回的竞争改善了这两者。
一旦(并且如果)发生器变得足够好以至于鉴别器不能可靠地区分真实图像和合成图像，则该过程停止。比乱猜要好。
让我们从生成开始
为了理解鉴别器所扮演的角色，首先让我们把它排除在外。
假设我们已经在真实图像数据集上训练了一个初始的无监督生成模型。它生成的图像有多真实？如果不够现实，我们如何通过机器学习来改善它？
评估生成器质量的一种自然方法是通过一种典型的模型优度的非监督测量。例如模型与验证集(即训练集的保留子集)的拟合程度。使用最大似然或更简单的标准，如平方和。
在现实环境中，这是不够有效的。
为什么不呢？
现实世界通常是巨大的。训练集是从复杂分布中抽取的微小部分。事实上，所有的实像可能只是宇宙中很小很小的一部分。来自宇宙的随机样本几乎肯定会被检测为赝品。
举个例子。一百万像素的二进制图像。宇宙的大小是“二的百万次方”。拥有十亿张图片的狮子真实图片训练集仍然只是很小的一部分。它们来自一个非常复杂的分布。也就是说，对真正的狮子图像进行表面上的小变形，就能让它看起来不真实。
让我们用一个不同的例子来阐述“表面的小失真”。
假设我们有一个非常大的实际手写 0 和 1 的数据集。说所有 1 的图像都是由直线组成的。假设在这个数据集上训练的生成器的第一个版本生成了许多轮廓弯曲的 1。(也许生成器被数据集中的 0 搞糊涂了。它们是弯曲的。)
我们如何判断发电机还不够好，因为它正在产生弯曲的1？
在验证集上评估我们的模型的适应性可能不会很好。验证集没有任何曲线 1。
这告诉我们以下几点。为了评估生成器的适用性，我们还应该查看它生成的合成图像样本，以及它们与真实图像的关系。
这里有一个来自教育环境的类比。要区分哪些学生已经掌握了某个主题，哪些学生还没有，并不总是那么容易。而不进行测试和评估不同学生的答案，因为它们与正确答案相关。
教育环境中的测试也可以揭示某个学生目前在哪些方面比较薄弱，以指导改进。这里也一样。
走上“正途”
所以我们得出结论，我们应该通过比较生成器生成的合成图像和真实图像来评估生成器的质量。我们究竟如何进行这种比较？
我们使用鉴别分类器。
我们有一组真实图像和一组合成图像。将这两者结合起来就产生了二元分类器的标记数据集。
在该数据集上训练二元分类器，并评估其预测准确性。(如有必要，使用列车测试分割。)
如果分类器比随机预测更好，挑出那些标记为合成的图像，它也预测为合成的。这些是很容易与真货区分开来的假货。使用此反馈重新训练发电机。
在我们的例子中，我们预计鉴别器将揭示生成器正在生成许多曲线 1，这些曲线 1 很容易被预测为合成的。
为什么要有鉴别力鉴别力？
用我们的例子来推理吧。如果我们的分类器能够以某种方式自动学习到一幅有曲线和其他一些区别于 0 的特征的图像不是真实的，那就太好了。
鉴别分类器有相当大的机会学习能够冲洗掉这种类型的假货的特征。生成分类器可能不能。无法学习在两个类之间区分的特征。尤其是不要“图像有曲线和一些其他特征，使其区别于 0”。
线是“弯曲的”是高阶特征。与数据世界相比，高阶特征的世界超级庞大。我们已经注意到，后者是巨大的。生成模型很难找到“正确的”高阶特征，因为它们只能处理模型适应性。鉴于判别学习的使用，判别模型有更好的机会。
菜谱
好了，现在我们有了基本的配方。我们重复以下步骤。
1\. Train the generator.
2\. Generate synthetic images from it.
3\. Train the discriminator on the real+synthetic images.
4\. Identify the regime (if any) in which the generator is weak. Use
this as feedback when going back to step 1.
请注意，训练是分轮进行的，发电机训练和鉴别器训练在一轮中交替进行。
实现这个方法的一种自然方式是由这四个步骤组成的重复管道。每一步的输入和输出都是明确定义的。我们有一些自由来选择它的实现。例如，我们可以为步骤 3 使用任何二元分类器。
增量学习和损失函数
在这一部分，我们以不同的方式来看待培训。从迭代训练和损失函数的角度。这一视角也让我们得以一瞥生殖对抗网络是如何运作的。
生成器和鉴别器都通过来自鉴别器最新实例的反馈来学习。我们首先讨论这种反馈的形式。
设 D ( x )表示鉴别器 D 分配给一个数据 x 的分数。 D ( x )如果 D 认为 x 是假的就为低，如果 x 是真的或者 D 认为是真的就为高。
现在开始发电机 G 的训练。假设鉴别器已经从与真实数据集结合的初始生成器的输出中被训练。
让我们想象重复做下面的事情。
1\. Sample a synthetic image *s* from *G*.
2\. If *D*(*s*) is low, update *G*’s parameters so as to reduce the likelihood that *G* will sample this particular *s* subsequently.
而在第 2 步中，我们说this particular *s* ，我们真正的意思是with the same characteristics as this particular *s*。换句话说，我们希望增量训练能够一般化，不仅降低对这个特定的 s 进行采样的可能性，而且降低对那些具有与这个 s 相似特征的样本进行采样的可能性。
接下来，是鉴别训练。为此，我们假设除了真实图像的数据集之外，我们还有一个来自生成器最新版本的合成图像。让我们把两者结合起来。设 x 表示一个数据，y 表示其标签:真实或合成。现在想象将标记数据集中的每个实例( x ， y )逐一呈现给鉴别器。如果 y 为真，我们寻求更新 D 的参数，以便增加 D ( x )。如果 y 是合成的，我们寻求更新 D 的参数，以便减少 D ( x )。
生成器仅从合成图像上的鉴别器分数中学习。相比之下，鉴别器从鉴别器在真实图像和合成图像上的分数中学习。如果鉴别器学习仅限于从合成图像中学习，那就不好了。它可能会决定给所有的图像分配低分，甚至是真实的图像，这对于在下一轮训练生成器来说是不好的反馈。
模式崩溃
没有什么可以阻止生成器偏爱数据中的某些模式，在极端情况下只有一个模式。考虑我们的数字示例，扩展到 0 到 9。如果生成器难以生成真实的 8，它可以完全放弃生成 8。这个鉴别器只能辨别真假。它无法判断合成图像中是否缺少 8。这些模式甚至没有在真实数据集中标注。
总结
在这篇文章中，我们讨论了在学习生成与给定数据集中的数据非常相似的数据的背景下的生成性对抗学习。
我们从生成学习开始，并解释了为什么它不太可能在这项任务中充分发挥作用。然后，我们在混合中引入了判别学习。
生成器和鉴别器相互竞争。这迫使双方都要改进。
延伸阅读
稳定扩散，梦想融合，制作视频，图像视频，下一步是什么
原文：https://towardsdatascience.com/generative-ai-878909fb7868
生成式人工智能概述
用于文本到图像、文本到 3D 和文本到视频的生成式人工智能
星夜(作者利用稳定扩散)
新一代人工智能还处于萌芽状态，但正在呈指数级增长。自从 OpenAI 首次亮相 GPT-3 和 DALL E 以来，它一直在人工智能领域抢尽风头
2022 年是文本到内容的时代(又名 AIGC)。2022 年 4 月，OpenAI 发布了 DALL E 2，在的论文中描述了关于剪辑和扩散模型。这是第一次从自然语言的文本描述中创造出逼真的图像和艺术。
四个月后，初创公司 StabilityAI 宣布发布 stability Diffusion，这是一款开源的文本到图像生成器，可以在几秒钟内创作出令人惊叹的艺术作品。它可以在消费级 GPU 上运行，速度和质量都有所突破。它如此炙手可热，以至于在 2022 年 10 月 17 日的种子轮中成为了独角兽。
2022 年 9 月 29 日，谷歌宣布 DreamFusion 使用 2D 扩散技术进行文本到 3D 的生成。同一天，Meta 宣布制作一个视频用于没有文本视频数据的文本到视频生成。
不到一周，谷歌似乎回应了 Meta 的视频制作，推出了文本转视频的图片视频。
在过去半年的这段激动人心的旅程中， Midjourney 和 CogVideo 同样重要。Midjourney 是一个独立的研究实验室，提供 Midjourney Bot 来从文本生成图像。CogVideo 是第一个开源的大规模预训练文本转视频模型，拥有 94 亿个参数。
在这里，我将描述他们是如何工作的稳定扩散，文本到 3D，文本到视频。此外，让我们体验一下无需编码的文本到图像的美妙体验，看看接下来会发生什么。
稳定扩散和不稳定扩散
稳定扩散引入了条件潜在扩散模型(LDM ),以实现图像修复和类别条件图像合成的最新技术水平，以及在各种任务上极具竞争力的性能，包括文本到图像合成、无条件图像生成和超分辨率，同时与基于像素的 LDM 相比显著降低了计算要求。该方法可以在不降低质量的前提下，显著提高去噪扩散模型的训练和采样效率。
条件潜在扩散模型通过串联或更一般的交叉注意机制来解释(来源:潜在扩散模型
在释放稳定扩散的同时，StabilityAI 开发了一个基于 AI 的安全分类器，默认启用。它理解几代人的概念和其他因素，以消除用户不想要的输出。但是对于强大的图像生成模型，可以很容易地调整它的参数。
基于稳定的扩散，法师出现在浏览器中生成 NSFW 内容。这是直接和免费使用，没有 NSFW 滤波。
不要混淆。不稳定扩散是一个使用稳定扩散支持 AI 生成 NSFW 内容的社区。毫无疑问，这些模特可以在帕特伦和拥抱脸上找到。
文本转 3D 的 DreamFusion
谷歌和 UCB 共同推出了使用 2D 扩散的文本到 3D 生成的 DreamFusion。
DreamFusion 通过一种新颖的 SDS(分数提取采样)方法和一种新颖的 NeRF(神经辐射场)类渲染引擎，将可扩展的高质量 2D 图像扩散模型转移到 3D 域。DreamFusion 不需要 3D 或多视图训练数据，仅使用预训练的 2D 扩散模型(仅在 2D 图像上训练)来执行 3D 合成。[3]
DreamFusion 演示了从自然语言字幕生成 3D 对象(来源: DreamFusion )
如上所示，场景由针对每个字幕随机初始化并从头开始训练的 NeRF 来表示。NeRF 使用 MLP 参数化体积密度和反照率(颜色)。DreamFusion 从随机相机渲染 NeRF，使用从密度梯度计算的法线以随机照明方向对场景进行着色。阴影揭示了从单个视点看不清楚的几何细节。为了计算参数更新，DreamFusion 扩散渲染并使用(冻结的)条件 Imagen 模型重建渲染，以预测注入的噪声。
尽管 DreamFusion 产生了引人注目的结果，但它仍处于文本到 3D 的早期阶段。当应用于图像采样时，SDS 不是完美的损失函数。因此，在 NeRF 环境中，它经常产生过度饱和和过度平滑的结果，并且缺乏多样性。此外，DreamFusion 使用 64 × 64 Imagen 模型来平衡质量和速度。
为文本到视频制作视频
梅塔(又名脸书)在人工智能进化中从未落后。在 DreamFusion 宣布的同一天，Meta 推出了文本到视频生成的 Make-A-Video。
元制作视频高层架构(来源:制作视频)
根据上面的高层架构，制作视频主要有三层:1)。在文本-图像对上训练的基础 T2I(文本-图像)模型；2).时空卷积和注意力层将网络的构建模块扩展到时间维度；和 3)。时空网络由时空层和 T2V 生成所需的另一个关键元素组成，即用于高帧率生成的帧插值网络。[4]
因此，制作视频是建立在 T2I 模型上的，具有新颖实用的时空模块。它加速了 T2V 模型的训练，而不需要从头开始学习视觉和多模态表示。它不需要成对的文本-视频数据。并且生成的视频继承了广阔性(审美的多样性，奇幻的描绘等。)
谷歌的图像视频
Google 的 Imagen Video 是一个基于视频扩散模型级联的文本条件视频生成系统。
给定文本提示， Imagen Video 使用基本视频生成模型和一系列交错的空间和时间视频超分辨率模型生成高清视频。
它包括七个子模型来执行文本条件视频生成、空间超分辨率和时间超分辨率。整个级联以每秒 24 帧的速度生成 128 帧(~ 5.3 秒)的高清 1280×768(宽×高)视频，约为 1.26 亿像素。
Imagen 视频示例为"一束秋叶落在平静的湖面上，形成文字’ Imagen 视频’。平稳。“生成的视频分辨率为 1280×768，时长 5.3 秒，每秒 24 帧(来源:成像视频)
稳定扩散无代码 AI
如上所述，我们可以看到扩散模型是文本到图像、文本到 3D 和文本到视频的基础。我们用稳定扩散来体验一下。
使用建议文本:亚马逊雨林中的高科技太阳能乌托邦
(作者使用稳定扩散)
正文:动漫女机器人头上长出花朵
(作者使用稳定扩散)
正文:从天空中看到的瑞尼尔山近景
由 DreamStudio 生成(左)与作者拍摄的照片(右)
你可能等不及了。下面是许多不用任何代码就可以尝试的方法。
下一步是什么？
生殖人工智能令人惊叹，发展迅速。当我们还沉浸在文本到图像的真实图像和艺术中时，我们现在正在进入下一个前沿领域:文本到视频和文本到 3D。
但是它是新生的，充满了关于相关性、高保真度、广阔性和效率的挑战。
- 相关性:我们注意到在相同的输入文本下，模型产生不同的(甚至显著不同的)结果，以及一些不相关的结果。在生成艺术的时候，如何用自然语言描述输入的内容似乎成了一门艺术。
- 高保真:来自 DALL-E 2 和稳定扩散的许多逼真图像给我们留下了深刻的印象，但它们都仍然有很大的高保真空间。
- 广阔:广阔是关于审美的多样性，荒诞的描绘，等等。它可以为各种输入提供丰富的结果。
- 效率:生成一张图像需要几秒几分钟。3D 和视频需要更长时间。例如，DreamFusion 使用更小的 64 × 64 Imagen 模型，通过牺牲质量来加快速度。
好消息是，它开启了许多令人兴奋的机会:人工智能工程、基础模型和生成性人工智能应用。
- 人工智能工程:人工智能工程对于实现 MLOps 自动化、提高数据质量、增强 ML 可观察性和自生成应用内容至关重要。
- 基础模型:独立训练和操作很多大型模型，成本很高，变得不现实。最终，它将统一或集成到几个基础模型中。这些大规模模型运行在云中，为上面的不同领域和应用服务。
- 生成式人工智能应用:有了人工智能工程和基础模型，这是一个巨大的应用机会，包括元宇宙和 NFT 空间的数字内容。例如，初创公司 Rosebud 专注于多样化的照片生成。
到 2025 年，生成式人工智能模型将产生 10%的数据。按照目前人工智能进化的速度，我们可以预计未来几年将会发生显著的变化。
参考
- 具有剪辑潜在性的分层文本条件图像生成:https://arxiv.org/abs/2204.06125
- 用潜在扩散模型合成高分辨率图像:https://arxiv.org/abs/2112.10752
- DreamFusion:使用 2D 扩散的文本到 3D:https://arxiv.org/abs/2209.14988
- 制作视频:没有文本-视频数据的文本-视频生成:https://arxiv.org/abs/2209.14792
- Imagen 视频:采用扩散模型的高清视频生成:https://arxiv.org/abs/2210.02303
遗传算法及其在机器学习中的实用性
原文：https://towardsdatascience.com/genetic-algorithm-6aefd897f1ac
GA 是什么，如何用它来训练机器学习模型？
在 Unsplash 上 Sangharsh Lohakare 拍摄的照片
介绍
遗传算法(GA)是一种自然计算算法，是通过复制自然界中存在的现象和行为来尝试解决问题的算法。
文献中有几种自然算法，如粒子群优化算法(PSO)，它试图以数学方式模拟鱼群或鸟群的社会行为，以及蚁群优化算法(ACO)，它试图在模拟蚂蚁移动行为的图中找到最佳路径。
这些类型的算法用于解决优化问题，其中您希望在搜索空间内找到最优值(最大值或最小值，取决于所分析的问题)。研究最多的优化问题之一就是所谓的 旅行商问题 。
在所有的自然计算算法中，最著名的是遗传算法。
概述
Pankaj Patel 在 Unsplash 上拍摄的照片
遗传算法是基于遗传学的概念，其中变换被应用于旨在试图复制诸如突变、自然选择和交叉等事件的数据。
简而言之，遗传算法迭代执行，并具有以下步骤:
- 初始种群的生成
对于每次迭代:
- 子群体(亲本)的选择
- 应用交叉和变异操作产生新的种群(子代)
- 对产生的新群体的评估
- 用新群体替换初始群体
算法将一直运行，直到达到停止条件，通常是最大迭代次数或评估生成的群体时获得的某个值。
重要的是要记住，要正确地执行算法，必须要有一个明确定义的问题要解决，并且要使用评估度量。
概念
Joshua Hoehne 在 Unsplash 上拍摄的照片
为了理解算法，有必要理解它背后的概念。
- 个体:代表问题唯一可能解决方案的群体成员。在数学上，它可以表示为一个值数组，其中数组中的每个值都是一个与所分析问题的响应方程相关联的系数。
- 群体:作为所分析问题答案候选人的一组个体。
- 比武:选择种群中最适个体的方法。它包括比较群体中两个(或更多)个体的结果，并选择获得最佳结果的一个。
- 交换:基因重组的操作，父母的遗传密码结合在一起产生孩子。定义一个(或多个)截止点，其中子代从父代 1 接收从遗传密码的开始到截止点的所有基因，并从父代 2 接收从截止点到遗传密码的结束的所有基因。下图(图 1)显示了一个具有一个截止点的交叉运算示例，其中每个单元格代表一个与响应方程相关的系数。
图 1 —交叉操作示例—作者图片
- **突变:**将基因的值修改为不同于原始值的操作。图 2 显示了一个应用于个体的突变的例子。
图 2——第二个基因的突变操作示例——作者图片
既然已经定义了基本概念，那么让我们来看一个使用遗传算法来解决问题的例子。
这个例子
在机器学习中，一种广泛使用的算法是人工神经网络，它试图模拟人脑的行为进行决策。一种非常简单的网络被称为多层感知器(MLP ),它是由一个输入层、一个或多个中间层和一个输出层组成的网络。
下图(图 3)显示了一个 MLP 前馈神经网络的示例，其中间层包含四个神经元，隐藏层也包含四个神经元，输出层包含一个神经元。
图 3-带有一个隐藏层的前馈神经网络示例-作者图片
网络如何工作的细节不是本文的重点，知道输出 y 是通过使用网络各层和输入数据之间的权重的运算来计算的就足够了。
层权重是向量集，其中每个值对应于与不同层中的神经元之间的链接相关联的权重。目的是优化这些权重，以便网络可以解决问题。
让我们从定义图 3 中描述的 MLP 前馈的类开始。
现在，让我们一步一步地了解算法的功能。第一步是创建初始种群。下面的函数接收所需的个体数量(n_indiv ),并使用 MLPFeedforward 类返回随机初始化的个体总数(神经网络的权重)。
下面的函数执行 GA 的锦标赛步骤，从初始群体中随机选择两个父代，并将两个父代中的最佳父代(具有最大准确度的一个)存储在父代列表中。它接收人口和数据作为参数:特征()X)和标签( y )。
下一步是创建执行交叉和变异操作的函数。该函数的参数是双亲列表、决定是否会发生交叉(cross_thr)和突变(mutation_thr)操作的阈值以及限制操作中基因变化范围的突变限制。
最后，实现了一个包含整个算法的类。它还具有 run 方法，该方法多次执行算法，存储每次运行时获得的精度，并保存生成的最佳 MLP 及其性能。
现在，为了展示该算法，创建了一个具有 4 个特征、10.000 行和 2 个类的通用数据集，将其分为训练和测试数据(70%为训练样本，其余 30%为测试样本)，并使用标准缩放器对其进行标准化。然后，使用 GA_MLPFeedforward 类来展示模型的性能如何随着遗传算法的使用而提高。算法中使用的参数是:
- 人口规模= 50
- 迭代次数= 200
- 交叉阈值= 0.5
- 突变阈值= 0.7
- 突变极限= [-5，5]
重要的是要说，所使用的参数没有优化，参数的优化对算法的结果起着非常重要的作用。
在执行算法之后，绘制了训练数据的精度演变，如下图 4 所示。
图 4——算法准确性的演变——作者提供的图片
最后，评估测试数据时模型的性能如图 5 所示。
测试数据的混淆矩阵和获得的准确度—图片由作者提供
Joshua Hoehne 在 Unsplash 上拍摄的照片
希望这篇文章能够让你快速理解遗传算法，以及如何在机器学习算法的开发中使用它。学习新的技能和做同样事情的方法总是好的。
欢迎任何意见和建议。
请随时通过我的 Linkedin 联系我，并查看我的 GitHub。
遗传算法——一种优化方法
原文：https://towardsdatascience.com/genetic-algorithm-an-optimization-approach-dd60e23261e6
使用遗传算法和 R 语言实现优化的介绍
照片:Unsplash
优化在任何商业领域都是一个非常重要的概念，无论是零售、金融、汽车还是医疗保健。简而言之，优化的目的是通过最小化/最大化损失/成本函数在搜索空间中找到一个点或一组点，这为我们提供了手头问题的最优解决方案。这里，我们试图最小化/最大化目标函数 f(x ),其服从一个/多个约束，例如，
Minimize f(x)
Subject to:
g(x) = 0 (equality constraint)
h(x) <= 0 (inequality constraint)
lb <= x <= ub (lb: lower bound, ub: upper bound)
本文将帮助您了解我们如何使用遗传算法(GA)优化问题陈述，遗传算法是最简单的进化算法(EAs)之一。
什么是遗传算法，它是如何工作的？
进化算法的基本直觉是从群体中选择最好的个体作为父母，要求他们繁殖以延长世代。在这个繁殖过程中，来自父母双方的基因交叉，在某种程度上，一个非遗传的错误发生了，这就是所谓的突变。然后下一代被要求繁殖他们的后代，这个过程继续下去。进化算法受交叉和变异理论的启发，其中交叉用于从群体的遗传信息中创建新的解决方案，而变异用于带来新的信息或保持群体中的多样性，并防止过早收敛以使解决方案更通用。
遗传算法是一种基于遗传和自然选择的生物进化原理的搜索优化技术。它通常用于从搜索空间中找到问题的最优或接近最优的解决方案，否则将花费大量时间来解决这些问题。现在，让我们来谈谈工作算法的基本原理。
作者图片
初始化人口
让我们先了解一下 GA 中人口是什么意思。
*种群(或世代):*它是所有可能解(候选解)的集合，用来发起搜索。遗传算法将迭代多代，直到找到最优解。
*染色体:*它代表群体中存在的一个特定(候选)解。
*基因:*是包含特定染色体的值(等位基因)和位置(基因座)的决策变量的单个元素。
作者图片
第一代随机初始化*(随机初始化)。该算法通常从随机生成的群体开始。群体的大小取决于问题的性质，并由决策变量的大小决定。在所有世代中，种群的规模保持不变。此外，还有另一种选择，使用已知的启发式算法对问题(启发式初始化)*初始化群体，但通常不推荐，因为这可能导致群体具有相似的解和非常小的多样性。
评估体能
适合度函数评估候选解决方案对目标的适合程度。它给每个个体一个适合度分数(概率值),基于这个分数，该个体将被选择用于繁殖。
通常，适应度函数可以被认为是一个目标函数，但是在存在多个目标和约束的复杂问题的情况下，适应度函数可以被不同地设计。
一个适应度函数应该具有以下特征:
适应度函数的计算速度应该足够快。
它必须定量测量给定解决方案的适合程度，或者从给定解决方案中产生的适合个体的程度。
选择父母
父代选择是从群体中识别最适合的解决方案的过程，它复制下一代解决方案。它有助于下一代自然地继承“好”的特征。在第 0 代中，我们没有任何后代，我们从初始群体中选择父母。
这种选择是非常关键的，因为它驱使个体找到更好和更合适的解决方案，从而导致算法的收敛。此外，亲本的关键特征之一应该是在群体中保持良好的多样性。选择亲本有不同的方法(这里看这里看)。
交叉
交叉有助于产生新的后代。由于遗传算法是基于随机的进化算法，从每个亲本携带的基因数量是随机的。来自双亲染色体的某些基因重叠或混合产生新的一代。由于后代是双亲染色体交叉的结果，它继承了双亲的特征。有时后代从父母一方获得一半基因，从另一方获得另一半基因，有时这种百分比会发生变化。
有不同的方法，如单点交叉，双点交叉，均匀交叉。均匀交叉是执行交叉的常用方法。在这里，基因是从亲代染色体中随机选取的。这里，遗传的基因被标记为 1，其他的被标记为 0，这来自于均匀分布(假设这些被称为 unif_value)。现在 unif_value 与每个父染色体的基因值相乘。父代选择和交叉操作重复多次，直到下一代中的解的数量达到 population_size(在所有代中保持相同的群体大小)。
作者图片
突变
突变有助于将新的特征包含到基因中，这基本上保持了种群内的多样性，并防止了过程的过早收敛。变异是遗传算法中与搜索空间的“探索”相关的部分。因此，变异对遗传算法的收敛至关重要，而交叉则不然。
满足标准
当算法达到其收敛时，即它不会产生与上一代明显不同的后代时，算法终止。通常，如果满足以下任一标准，算法就会终止:
如果在接下来的 X 次迭代中群体中没有适应度提高
如果目标函数已经达到最佳值或预定义值
如果已经达到最大代数
为什么选择遗传算法
在传统算法可能无法提供解决方案的大规模问题中，遗传算法(GA)能够“足够快地”提供“足够好”的解决方案。它为解决复杂的优化问题提供了一个通用的框架。以下是使用遗传算法的几个优点:
a)克服了传统优化算法的不足
如果我们能计算任意给定点的梯度，那么函数就是可微的。传统的算法如梯度下降法、牛顿法都是用导数的方法来获得最优解。它从一个随机的点开始，沿着梯度的方向移动，直到我们到达顶点。这种技术是有效的，并且对于我们具有单峰目标函数的线性回归类型的问题非常有效。但是，在现实世界中，我们有一个复杂的问题，有多个峰值和许多谷值(非凸目标函数)。在这里，传统的算法有陷入局部最优的固有趋势。
作者图片
然而，遗传算法不需要目标函数的梯度。它可用于目标函数不连续、不可微、随机或高度非线性的各种优化问题。
这可以很容易地并行化。
c) GA 相当快，在相对较短的计算时间内探索搜索空间。
d)可以包含多个复杂的优化目标
限制
a)如果执行不当，GA 可能不会收敛到最优解
b)可能计算量大，因为适应度函数被重复计算。
c)有时 GA 不允许硬约束，所以需要在目标函数中传递它们作为惩罚。惩罚函数降低不可行解的适应度，使得适应度随着违反的约束的数量或与可行域的距离成比例地降低。
作为用例的几个例子
a)库存优化:这有助于补货决策，从而避免缺货情况并因此导致销售损失。
b)商店空间优化:这可以通过重新安排空间来帮助增加商店的销售额，同时保留一些约束因素。
c)电源优化
实现:R 中的代码片段
# Define the functions:
pred_eval_fun_P <- function(x) {}: # Defining fuction for calculating predicted demand
orig_eval_fun_P <- function(x) {}: # Defining fuction for calculating actual demand
eval_g_ineq1 <- function(x) {}: # Creating 1st constraint
eval_g_ineq2 <- function(x) {}: # Creating 2nd constraint
fitness_P <- function(x) {}: # Creating the objective function and adding penalty as it can't take hard constraint. As example like below:
{
f <- pred_eval_fun_P(x) # maximise f(x)
p <- sqrt(.Machine$double.xmax) # penalty term
pel_int <- abs(eval_g_ineq1(x))
pel_int1 <- abs(eval_g_ineq2(x))
penalty1 <- # define as needed
penalty2 <- # define as needed
f-penalty1-penalty2 # fitness function value
}
lb: # Defining the lower bound
ub: # Defining the upper bound
no_cores <- detectCores() - 1
# Also define starting, max_gen, hard_gen as needed
# Run the optimization:
library(snow)
library(rgenoud)
cl1 <- makeCluster(no_cores, type="SOCK")
clusterExport(cl1, list("fitness_P","lb","ub","pred_eval_fun_P","eval_g_ineq1","eval_g_ineq2","starting","max_gen","hard_gen"))
GA_P1 <- genoud(fitness_P, Domains=cbind(lb,ub), nvars=length(lb), pop.size=100, max=TRUE,wait.generations = 50, max.generations = max_gen, hard.generation.limit=hard_gen, data.type.int=TRUE, cluster = cl1,print.level = 1, solution.tolerance = 0.001)
final_reco <- as.numeric(as.character(GA_P1$par))
stopCluster(cl1)
免责声明:本文中表达的观点是作者以个人身份发表的意见，而非其雇主的意见
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
