F#降临节日历——圣诞节分类器
如何使用 F#和 ML 创建图像分类器？网
作为对硅谷和 Jìan-Yáng 的应用程序的赞美，该应用程序可以检测图片中是否包含热狗，我决定实现自己的版本，加入圣诞元素。
Silicon Valley — Hot Dog / Not Hot Dog
我想看看我是否能使用 F#创建一个二进制图像分类器，它能识别一个图像是否包含圣诞老人。
GitHub 上有这方面的代码。
数据采集
为了获得用于训练和评估模型的图像，我使用了 Bing 图像搜索 API 。
该 API 有助于查询图像，并返回一个 JSON 响应，该响应包括图像元数据和下载它们的 URL。
我使用了 F#数据 Http 实用程序来查询 API 和下载图像。我还使用了 JSON 类型提供者来处理 API 响应。
我总共下载了 1540 张图片——770 张有圣诞老人，770 张没有。
在收集没有圣诞老人的图片时，我搜索了包含可能引起混淆的特征的图片，如“留胡子的老人”和“圣诞精灵”。
下载后，我手动清理了数据集，确保没有图像被错误地标注。
我创建了两个 tsv 文件(train-images.tsv 和test-images.tsv)，使用 80-20 分割对数据集进行分区。
每个文件都包含图像的相对路径及其标签(santaclaus 或notsantaclaus)。
F#脚本1DownloadImageSearchResults.fsx、2DownloadImages.fsx和3CreateImageTsv.fsx记录了查询 Bing 图像搜索 API、下载图像以及标记和划分数据的过程。
ML。网
为了创建分类器，我使用了微软新的机器学习库，ML.NET。
它仍处于早期开发阶段(0.7.0 ),所以功能有限，但很高兴看到机器学习在 F#中变得更容易使用。网！
张量流
我希望使用神经网络作为图像分类器，当通读 ML.NET 文档时，我很兴奋地看到它支持 TensorFlow。然而，目前该库仅支持评估预训练模型。
因此，我不能使用 ML.NET 来训练我自己的 TensorFlow 模型，但我可以使用预训练模型的输出作为更传统的机器学习算法的输入。
盗梦空间-第三版
Inception-v3 是在 ImageNet 数据集上训练的卷积神经网络。该网络有 48 层，并试图将图像分类到 ImageNet 中定义的 1000 个类别中的一个。
使用 Netron ，可以查看训练好的模型的结构。这里不能贴全网图片(它有 48 层！)但是对于这个任务，相关部分在网络的输出层。
Inception-v3 Softmax2 Function
上图中的Softmax2节点是一个激活函数，它根据 1000 个类获取图像的最终表示，并将其转换为概率分布。
它为每个类别分配一个小数概率，这样我们就可以确定哪个类别最有可能是图像的类别。
在我的图像分类器中，我可以使用 Inception-v3 模型，将输入输入到Softmax2节点(softmax2_pre_activation)，并将其用作 model 算法的图像特征。
Model 模式
该模型在[Program.fs](https://github.com/williamtetlow/ChristmasClassifier/blob/master/ChristmasClassifierConsoleApp/Program.fs)中定义
dataLoader指定了输入数据的模式。
Input Data Schema
然后使用dataLoader加载训练和测试数据视图。
Load Training and Test Data
dataPipeline指定应该应用于输入 tsv 的变换。
因为这是一个二进制分类，所以我使用了一个自定义映射来将这两个类转换成布尔值— santaclaus = true和notsantaclaus = false。
Transform Input Data
然后，我使用modelBuilder来描述图像如何加载、预处理和用于训练模型的管道。
管道使用输入 tsv 中定义的相对路径加载图像，调整它们的大小，使它们都具有相同的大小，然后提取像素信息，以便可以将它们传递到 Inception-v3 模型中。
Image Loading and Preprocessing
使用[TensorFlowEstimator](https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.transforms.tensorflowestimator?view=ml-dotnet)，流水线加载预训练的 Inception-v3 模型，并输入从之前阶段提取的像素。
我想使用Softmax2节点的输入来获取我将在 ML.NET 使用的算法的特征。因此，TensorFlowEstimator 的输出是softmax2_pre_activation。
TensorFlow Estimator using Inception-v3
最后一级将 TensorFlowEstimator 的输出传递到来自 ML.NET 的[StochasticDualCoordinateAscentBinaryClassifier](https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.legacy.trainers.stochasticdualcoordinateascentbinaryclassifier?view=ml-dotnet)中，这是一种用于线性二进制分类的算法。
Stochastic Dual Coordinate Ascent Binary Classifier
用modelBuilder定义模型后，使用训练数据对其进行训练。
Training the Model
模型只花了几分钟训练。
我用了测试数据和 ML。[BinaryClassifierEvaluator](https://docs.microsoft.com/en-us/dotnet/api/microsoft.ml.runtime.data.binaryclassifierevaluator?view=ml-dotnet)内置网络，用于评估模型性能。
在测试集上，该模型给出了 96.08%的准确率
Model Metrics
这是一个非常好的结果，尤其是对于相对较小的数据集！
为了提高准确性，我可以增加数据集的大小，例如操纵图像的方向和缩放。
我还可以研究调整当前算法参数或使用另一种算法是否会返回更好的结果。
该项目的下一步是添加功能，将训练好的模型加载到应用程序中进行预测，这将在另一篇文章中演示(圣诞节前)。
但希望我已经展示了 F#中的机器学习变得越来越容易！
参考
https://github . com/dot net/machine learning/blob/master/docs/code/mlnet cookbook . MD
https://github.com/dotnet/machinelearning/issues/581
https://github . com/dot net/machine learning-samples/tree/master/samples/fs harp
F#为勉强连接的人设计的笔记本电脑
对于很少上网的人来说。
最初发布于:https://devstufwithjpada . com/f-notebooks-for-the-barely-connected/
虽然 Azure notebooks 可能是在 Jupyter 笔记本上进行 F#数据科学实验的最快和最简单的方法，但这只在你总是在线的情况下才有效。如果你在一个第三世界国家(像我一样)，只有断断续续的互联网连接怎么办？你如何在 Jupyter 笔记本上使用 F#?
我们有一个解决方案。但是当然，你需要先上网。之后，您可以随时离线，但仍然可以在您最喜欢的 Jupyter 笔记本上使用您喜欢的 F#进行工作。
码头工人来救援了
F#背后的人已经想到了这一点，并为在 Docker 中运行 F#笔记本的构建了一个 Dockerfile 。
过程的成本
这里发生了什么事？首先，IfSharp 回购被克隆。然后我们进入 IfSharp 目录。然后我们建造…
asciinema.org](https://asciinema.org/a/AGdxx2ROXS20smWMbH809rgFu)
那么我们如何做到这一点呢？
- 首先， IfSharp repo 克隆。
- 然后我们进入
IfSharp目录。 - 然后我们用
docker build -t ifsharp:3.0.0-alpha .从Dockerfile构建 Docker 映像 - 然后，我们使用
docker run -d -v your_local_notebooks_dir:/notebooks -p your_port:8888 ifsharp:3.0.0-alpha运行映像。更改端口和笔记本位置。 - 之后，我们使用
docker ps来查看运行的容器。我们复制正在运行的容器的 id。 - 我们用
docker exec -it the-container-id /bin/bash打开运行容器内的 bash shell。用我们复制的容器 id 替换“the-container-id”。 - 运行
jupyter notebook list查看运行中的笔记本。将令牌复制到 URL 的?token=部分之后。 - 在
localhost中打开笔记本，粘贴令牌以访问笔记本。
打开笔记本后，我们看到了这个:
Jupyter Authentication Page
这是我们粘贴之前复制的令牌的位置。将其粘贴在顶部并按下Log in。
恭喜你！您现在可以像这样创建 F#笔记本:
Some F# code I wrote on the local F# Jupyter notebook.
现在，即使离线，你也可以在 Jupyter 笔记本上做 F#实验！耶！
使用 GANs 的人脸属性操作
添加面部属性，如胡须，小胡子，性别变化等。由于所涉及的复杂性，在图像编辑中是一项具有挑战性的任务。像生成式广告串行网络这样的现代深度学习算法有助于解决这个问题，而不需要人工编辑。
进场
我们的目标是根据给定的属性值修改人脸图像。我们建议学习相应的残差图像，而不是处理整个图像，残差图像被定义为处理前后图像之间的差异。
在这里，您可以看到由变换网络 G0 和 G1 生成的残差图像，它与原始图像相加以获得输出。
这种方法的动机是面部属性操作通常只需要适度修改特定于属性的面部区域，而其他部分保持不变。
图像变换网络
给定 x0 =具有负属性值的人脸图像和 x1 =具有正属性值的人脸图像，学习网络 G0 和 G1 应用操作变换以产生残差图像 r0 和 r1 。
然后将残差图像添加到输入图像中作为最终输出。
输出=输入+残差。
区别网络
判别网络是一个三类分类器，它将图像从不同类别中分类出来:
- 从 G0 和 G1 生成的图像(变换图像)，
- 具有正属性标签的图像(真实图像)，
- 以及带有负属性标签的图像(实像)。
给定已知属性标签 0 和标签 1 的实像 x0 和 x1 ，我们将变换后的图像视为标签为 2 的额外类别。
双重学习
双重学习的机制可以看作是一个两人的交流游戏。
对于给定的具有负属性值的图像 x0，我们通过 G0 传递它。获得的图像然后被馈送到 G1 。由于 G0 和 G1 分别是原始任务和双重任务，来自 G1 的输出预期具有与 x0 相同的属性值。类似的过程也适用于 x1。
产生的图像 G1(G0(x0)) = x0
产生的图像 G1(G0(x1)) = x1
双重学习的有效性在于
1)从两个生成器生成的图像增加了训练样本的数量。
2)在双重学习阶段，G1(G0(x0))和 G0(G1(x1))的地面真实图像是已知的，这简化了两个生成器的训练。
参考
学习残差图像进行人脸属性操作—https://arxiv.org/abs/1612.05363
面向初学者的人脸检测
Multiple face detection in an image
在过去的几年里，人脸识别被认为是图像分析领域最有前途的应用之一。人脸检测可以考虑人脸识别操作的实质部分。根据其强度将计算资源集中在图像中包含人脸的部分。图片中的人脸检测方法是复杂的，因为人脸之间存在可变性，例如姿势、表情、位置和方向、肤色、眼镜或胡须的存在、相机增益的差异、光照条件和图像分辨率。
目标检测是计算机技术的一种，它与图像处理和计算机视觉相结合，它与检测目标的实例如人脸、建筑物、树木、汽车等相互作用。人脸检测算法的主要目的是确定图像中是否有人脸。
近年来，在人脸识别和人脸检测领域提出了许多研究工作，以使其更加先进和准确，但 Viola-Jones 推出的实时人脸检测器使这一领域发生了一场革命，它能够以高精度实时检测人脸。
人脸检测是人脸识别的首要步骤，用于检测图像中的人脸。它是目标检测的一部分，可用于许多领域，如安全、生物计量、执法、娱乐、个人安全等。
它用于实时检测人脸，以监视和跟踪人或物体。它被广泛应用于相机中，以识别移动相机和 DSLR 相机中的多个画面。脸书还使用人脸检测算法来检测图像中的人脸并进行识别。
人脸检测方法:-
Yan，Kriegman 和 Ahuja 提出了人脸检测方法的分类。这些方法分为四类，人脸检测算法可以属于两类或更多类。这些类别如下-
Different types of Face Detection Methods
1。知识型:-
基于知识的方法依赖于规则集，并且它基于人类的知识来检测人脸。一张脸必须有一个鼻子、眼睛和嘴巴，它们之间的距离和位置一定。这些方法的最大问题是难以建立一套合适的规则。如果规则太笼统或太详细，可能会有许多误报。这种方法本身是不够的，并且不能在多幅图像中找到许多人脸。
2。基于特征:-
基于特征的方法是通过提取人脸的结构特征来定位人脸。它首先被训练为分类器，然后用于区分面部和非面部区域。这个想法是为了克服我们对面孔的本能认识的局限性。这种方法分为几个步骤，甚至许多人的照片，他们报告的成功率为 94%。
3。模板匹配:-
模板匹配方法使用预定义或参数化的人脸模板，通过模板和输入图像之间的相关性来定位或检测人脸。人脸可以分为眼睛、面部轮廓、鼻子和嘴巴。此外，通过使用边缘检测方法，可以由边缘建立人脸模型。这种方法实现起来很简单，但是对于人脸检测来说是不够的。然而，已经提出了可变形模板来处理这些问题。
Template Matching
4。基于外观:-
基于外观的方法依赖于一组代表性的训练人脸图像来找出人脸模型。基于外观的方法优于其他表现方式。一般来说，基于外观的方法依赖于来自统计分析和机器学习的技术来寻找人脸图像的相关特征。这种方法也用于人脸识别的特征提取。
基于外观的模型进一步划分为用于面部检测的子方法，如下所述
4.1 .基于特征脸:-
用于人脸识别的基于特征脸的算法，是一种使用主成分分析有效表示人脸的方法。
4.2 .基于分配:-
像 PCA 和 Fisher 判别式这样的算法可以用来定义表示面部模式的子空间。有一个经过训练的分类器，它从背景图像模式中正确地识别目标模式类的实例。
4.3 .神经网络:-
许多检测问题，如物体检测、人脸检测、情感检测和人脸识别等。已经被神经网络成功地解决了。
4.4 .支持向量机:-
支持向量机是线性分类器，可以最大化决策超平面和训练集中的样本之间的差距。Osuna 等人首先将该分类器应用于人脸检测。
4.5 .稀疏网络的风选:-
他们定义了两个线性单元或目标节点的稀疏网络；一个代表人脸图案，另一个代表非人脸图案。它耗时少，效率高。
4.6 .朴素贝叶斯分类器:-
他们通过计算一系列模式在训练图像中出现的频率，计算出一张脸出现在照片中的概率。分类器捕获人脸的局部外观和位置的联合统计。
4.7 .隐马尔可夫模型:-
模型的状态是面部特征，通常被描述为像素带。HMM 通常与其他方法一起用于构建检测算法。
4.8 .信息论方法:-
马尔可夫随机场(MRF)可以用于人脸模式和相关特征。马尔可夫过程使用 Kullback-Leibler 散度来最大化类别之间的区分。因此，该方法可用于人脸检测。
4.9 .归纳学习:-
这种方法已经被用于检测人脸。像 Quinlan 的 C4.5 或 Mitchell 的 FIND-S 这样的算法用于此目的。
人脸检测的工作原理
检测人脸的技术有很多，借助这些技术，我们可以以更高的准确率识别人脸。这些技术对于人脸检测有着几乎相同的步骤，如 OpenCV、神经网络、Matlab 等。面部检测工作就像检测图像中多个面部一样。我们在 OpenCV 上进行人脸检测，人脸检测的操作步骤如下-
首先，通过提供图像的位置来导入图像。然后将图片从 RGB 转换为灰度，因为在灰度中很容易检测到人脸。
Converting RGB image to Grayscale
之后，使用图像处理，如果需要的话，对图像进行尺寸调整、裁剪、模糊和锐化。下一步是图像分割，用于轮廓检测或分割单幅图像中的多个对象，以便分类器可以快速检测图片中的对象和人脸。
下一步是使用由 Voila 和 Jones 提出的 Haar-Like 特征算法进行人脸检测。这种算法用于在帧或图像中寻找人脸的位置。所有人脸都具有人脸的一些普遍属性，如眼睛区域比其相邻像素暗，鼻子区域比眼睛区域亮。
Haar-like features for face detection
借助于边缘检测、线检测、用于检测眼睛、鼻子、嘴等的中心检测，haar-like 算法也用于图像中对象的特征选择或特征提取。图中。它用于选择图像中的基本特征，并提取这些特征用于人脸检测。
下一步是给出 x，y，w，h 的坐标，这在图片中形成一个矩形框来显示人脸的位置，或者我们可以说是显示图像中感兴趣的区域。在此之后，它可以在感兴趣的检测人脸的区域制作一个矩形框。还有许多其他检测技术一起用于检测，例如微笑检测、眼睛检测、眨眼检测等。
Successfully detect the face in an image
如何实时运行人脸检测器(网络摄像头):-
运行代码的要求- Python，OpenCV，网络摄像头，Numpy。
***#import libraries*** import cv2
import numpy as np**#import classifier for face and eye detection**
face_classifier = cv2.CascadeClassifier(‘Haarcascades/haarcascade_frontalface_default.xml’)***# Import Classifier for Face and Eye Detection*** face_classifier = cv2.CascadeClassifier(‘Haarcascades/haarcascade_frontalface_default.xml’)
eye_classifier = cv2.CascadeClassifier (‘Haarcascades/haarcascade_eye.xml’)
def face_detector (img, size=0.5):***# Convert Image to Grayscale*** gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)
faces = face_classifier.detectMultiScale (gray, 1.3, 5)
If faces is ():
return img***# Given coordinates to detect face and eyes location from ROI*** for (x, y, w, h) in faces
x = x — 100
w = w + 100
y = y — 100
h = h + 100
cv2.rectangle (img, (x, y), (x+w, y+h), (255, 0, 0), 2)
roi_gray = gray[y: y+h, x: x+w]
roi_color = img[y: y+h, x: x+w]
eyes = eye_classifier.detectMultiScale (roi_gray)
for (ex, ey, ew, eh) in eyes:
cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,0,255),2)
roi_color = cv2.flip (roi_color, 1)
return roi_color***# Webcam setup for Face Detection*** cap = cv2.VideoCapture (0)
while True:
ret, frame = cap.read ()
cv2.imshow (‘Our Face Extractor’, face_detector (frame))
if cv2.waitKey (1) == 13: #13 is the Enter Key
break***# When everything done, release the capture*** cap.release ()
cv2.destroyAllWindows ()
这个博客是为那些想通过学习什么是人脸检测，它的类型，以及它是如何工作的来开始他们在计算机视觉或人工智能领域的事业的初学者准备的。
人脸检测神经网络是什么样子的？
在我的上一篇文章中，我探索了多任务级联卷积网络(MTCNN)模型，用它来通过我的网络摄像头检测人脸。在这篇文章中，我将研究神经网络的结构。
MTCNN 模型由 3 个独立的网络组成:P 网、R 网和 O 网:
Image 1: MTCNN Structure // Source
对于我们传入的每个图像，网络都会创建一个图像金字塔:也就是说，它会创建该图像的多个不同大小的副本。
Image 2: Image Pyramid // Source
在 P-Net 中，对于每个缩放的图像，一个 12×12 的内核在图像中运行，以搜索人脸。在下图中，红色方块代表内核，它缓慢地在图像中上下移动，搜索人脸。
Image 3: 12x12 kernel in the top right corner. After scanning this corner, it shifts sideways (or downwards) by 1 pixel, and continues doing that until it has gone through the entire image.
在这些 12x12 内核的每一个中，3 个卷积与 3x3 内核一起运行(如果你不知道卷积是什么，请查看我的另一篇文章或本网站)。在每一个卷积层之后，一个预层被执行(当你把每一个负像素乘以一个特定的数字‘alpha’。“α”将通过训练来确定)。此外，maxpool 层放在第一个 prelu 层之后(maxpool 每隔一个像素取出一个像素，只留下附近最大的像素)。
Image 4: Max-pool // Source
在第三卷积层之后，网络分裂成两层。来自第三层的激活被传递到两个单独的卷积层，以及其中一个卷积层之后的 softmax 层(softmax 为每个结果分配十进制概率，并且概率总计为 1。在这种情况下，它输出两个概率:在该区域中有是人脸的概率和有不是人脸的概率)。
Image 5: P-Net
卷积 4–1 输出一个面在每个边界框中的概率，卷积 4–2 输出边界框的坐标。
看一看 mtcnn.py 会给你展示 P-Net 的结构:
class PNet(Network):def _config(self):layer_factory = LayerFactory(self)layer_factory.new_feed(name='data', layer_shape=(None, None, None, 3))layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=10, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu1')layer_factory.new_max_pool(name='pool1', kernel_size=(2, 2), stride_size=(2, 2))layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=16, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu2')layer_factory.new_conv(name='conv3', kernel_size=(3, 3), channels_output=32, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu3')layer_factory.new_conv(name='conv4-1', kernel_size=(1, 1), channels_output=2, stride_size=(1, 1), relu=False)layer_factory.new_softmax(name='prob1', axis=3)layer_factory.new_conv(name='conv4-2', kernel_size=(1, 1), channels_output=4, stride_size=(1, 1),input_layer_name='prelu3', relu=False)
R-Net 具有类似的结构，但是具有更多的层。它以 P-网包围盒作为其输入，并改进其坐标。
Image 6: R-Net
类似地，R-Net 最终分成两层，给出两个输出:新边界框的坐标和机器对每个边界框的置信度。同样，mtcnn.py 包括 R-Net 的结构:
class RNet(Network):def _config(self):layer_factory = LayerFactory(self)layer_factory.new_feed(name='data', layer_shape=(None, 24, 24, 3))layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=28, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu1')layer_factory.new_max_pool(name='pool1', kernel_size=(3, 3), stride_size=(2, 2))layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=48, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu2')layer_factory.new_max_pool(name='pool2', kernel_size=(3, 3), stride_size=(2, 2), padding='VALID')layer_factory.new_conv(name='conv3', kernel_size=(2, 2), channels_output=64, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu3')layer_factory.new_fully_connected(name='fc1', output_count=128, relu=False) layer_factory.new_prelu(name='prelu4')layer_factory.new_fully_connected(name='fc2-1', output_count=2, relu=False) layer_factory.new_softmax(name='prob1', axis=1)layer_factory.new_fully_connected(name='fc2-2', output_count=4, relu=False, input_layer_name='prelu4')
最后，O-Net 将 R-Net 包围盒作为输入，并记下面部标志的坐标。
Image 7: O-Net
O-Net 最终分成 3 层，给出 3 种不同的输出:人脸在框中的概率、边界框的坐标和面部标志的坐标(眼睛、鼻子和嘴的位置)。以下是 O-Net 的代码:
class ONet(Network):def _config(self):layer_factory = LayerFactory(self)layer_factory.new_feed(name='data', layer_shape=(None, 48, 48, 3))layer_factory.new_conv(name='conv1', kernel_size=(3, 3), channels_output=32, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu1')layer_factory.new_max_pool(name='pool1', kernel_size=(3, 3), stride_size=(2, 2))layer_factory.new_conv(name='conv2', kernel_size=(3, 3), channels_output=64, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu2')layer_factory.new_max_pool(name='pool2', kernel_size=(3, 3), stride_size=(2, 2), padding='VALID')layer_factory.new_conv(name='conv3', kernel_size=(3, 3), channels_output=64, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu3')layer_factory.new_max_pool(name='pool3', kernel_size=(2, 2), stride_size=(2, 2))layer_factory.new_conv(name='conv4', kernel_size=(2, 2), channels_output=128, stride_size=(1, 1),padding='VALID', relu=False)layer_factory.new_prelu(name='prelu4')layer_factory.new_fully_connected(name='fc1', output_count=256, relu=False)layer_factory.new_prelu(name='prelu5')layer_factory.new_fully_connected(name='fc2-1', output_count=2, relu=False)layer_factory.new_softmax(name='prob1', axis=1)layer_factory.new_fully_connected(name='fc2-2', output_count=4, relu=False, input_layer_name='prelu5')layer_factory.new_fully_connected(name='fc2-3', output_count=10, relu=False, input_layer_name='prelu5')
注意，P-Net、R-Net 和 O-Net 的所有代码都导入了一个名为“LayerFactory”的类。本质上，LayerFactory 是一个类，由该模型的制作者创建，用于生成具有特定设置的层。有关更多信息，您可以查看 layer_factory.py。
点击此处阅读实现 MTCNN 模型！
点击此处阅读 MTCNN 模式如何运作！
点击此处下载 MTCNN 论文和资源:
Github 下载:【https://github.com/ipazc/mtcnn
研究文章:http://arxiv.org/abs/1604.02878
面向初学者的人脸识别
ace 识别是一种识别技术，用于检测其图像保存在数据集中的个人的面部。尽管其他身份识别方法可能更准确，但人脸识别一直是研究的一个重要焦点，因为它的非干涉性质，因为它是人们进行个人身份识别的简便方法。
人脸识别方法:-
人脸识别有以下几种不同的方法
1。几何基础/模板基础:-
人脸识别算法分为基于几何或基于模板的算法。基于模板的方法可以使用统计工具来构建，如 SVM[支持向量机]、PCA[主成分分析]、LDA[线性判别分析]、核方法或迹变换。基于几何特征的方法分析局部面部特征及其几何关系。它也被称为基于特征的方法。
2。零碎/整体:-
元素之间的关系或功能的连接与整个面部没有经历到的数量，许多研究人员遵循这种方法，试图推导出最相关的特征。一些方法试图使用眼睛、特征的组合等等。一些隐马尔可夫模型方法也属于这一类，特征处理在人脸识别中非常有名。
3。基于外观/基于模型:-
基于外观的方法显示关于几幅图像的人脸。被认为是高维向量的图像。这种技术通常用于从图像分割中导出特征空间。与训练集比较的样本图像。另一方面，基于模型的方法试图对人脸建模。对模型实现的新样本和用于识别图像的模型参数。
基于外观的方法可以分为线性或非线性。Ex- PCA、LDA、IDA 用于直接方法，而核 PCA 用于非线性方法。另一方面，在基于模型的方法可以归类为 2D 或三维弹性束图匹配使用。
4。基于模板/统计/神经网络:-
4.1 .模板匹配:-
在模板匹配中，模式由样本、模型、像素、纹理等表示。识别函数通常是相关性或距离度量。
4.2 .统计方法:-
在统计学方法中，用特征表示的模式。判别函数中的识别函数。每个图像都代表了三维特征。因此，目标是选择和应用正确的统计工具进行提取和分析。
用于人脸识别的统计工具有很多。这些分析工具用在两个或多个组或分类方法中。这些工具如下-
4.2.1 .主成分分析【PCA】:-
使用和引用最多的统计方法之一是主成分分析。数学过程通过提取多维数据的主成分来执行维度缩减。
Dimension reduction from 3D to 2D image
T5 4 . 2 . 2 .离散余弦变换【DCT】:-
它表示关于不同振荡频率的余弦函数和的一系列数据点。离散余弦变换基于傅立叶离散变换，因此，通过压缩变化，它可以用于变换图像，并允许有效的维数减少。
4.2.3 .线性判别分析【LDA】:-
LDA 广泛用于寻找特征的线性组合，同时保持类的可分性。与 PCA 不同，LDA 试图对级别之间的差异进行建模。对于每个级别，LDA 获得多个投影向量的差值。
PCA vs LDA
4.2.4 .局部保持投影【LPP】:-
他和代代木介绍了 LPP。它是保持局部结构和设计的 PCA 的最佳替代方案。模式识别算法通常搜索最近的模式或邻居。因此，维护 LLP 质量的地方可以加快认识。
4.2.5.Gabor 小波:-
在这种算法中，它表明来自哺乳动物大脑视觉皮层的神经生理学数据证据表明，视觉皮层中的简单细胞可以视为一族自相似的 2D Gabor 小波。Daugman 提出的 Gabor 函数是局部空间带通滤波器，其实现了 2D 空间和 2D 傅立叶域中信息的联合分辨率的理论极限。
Gabor Wavelet in different magnitude
4.2.6 .独立分量分析【ICA】:-
ICA 旨在将数据转换为统计上独立的数据点的线性组合。因此，其目标是提供独立而非不相关的图像表示。ICA 是 PCA 替代方案，它给出了更强大的数据表示。这是一种判别分析准则，可用于增强 PCA。
4.2.7 .内核主成分分析:-
Scholkopf 等人介绍了使用核函数来执行非线性 PCA。其基本方法是对输入应用非线性映射，然后在得到的特征子空间中求解线性 PCA。
4.3 .神经网络:-
神经网络继续使用模式识别和分类。Kohonen 是第一个证明神经元网络可以用来识别对齐和标准化的面孔的人。存在使用神经网络执行特征提取的方法。有很多方法可以结合 PCA 或 LCA 等工具，组成混合分类器用于人脸识别。这些如具有附加偏差前馈神经网络、具有 PCA 的自组织映射和具有多层感知的卷积神经网络等。这些可以提高模型的效率。
Deep Neural Network for Face Recognition
4.3.1 .具有 Gabor 滤波器的神经网络:-
该算法通过使用反向传播算法实现多层感知器来实现人脸识别。首先，有一个预处理步骤。每幅图像在对比度和光照阶段进行标准化。然后，通过 Gabor 滤波器处理每幅图像。伽柏滤波器有五个方向参数和三个空间频率，因此有 15 个伽柏波长。
Neural Networks with Gabor filters
4.3.2 .神经网络和隐马尔可夫模型:-
隐马尔可夫模型是一种用于人脸识别的统计工具。它们与神经网络一起使用。它在训练伪 2D HMM 的神经网络中生成。这个 2D HMM 过程的输入是 ANN 的输出，它为算法提供适当的维数缩减。
4.3.3 .模糊神经网络:-
用于人脸识别的模糊神经网络于 2009 年推出。这是一个使用多层感知器的人脸识别系统。这种方法背后的概念是捕捉非线性流形中的决策面，这是一个简单的 MLP 很难完成的任务。使用 Gabor 波长变换获得特征向量。
Fuzzy Neural Network
人脸识别的工作原理
人脸识别有很多种方法。这里我们使用 OpenCV 进行人脸识别。在人脸识别中，首先对图像进行预处理，然后训练人脸识别器来识别人脸。教完识别器后，我们测试识别器看看结果。OpenCV 人脸识别器有以下三种类型
1。特征脸人脸识别器
EigenFaces 人脸识别器将所有字符的所有训练图像视为一个复合体，并尝试推断其组成部分。这些成分是必要的和有帮助的(抓住最大变化/改变的部分),并丢弃图像的其余部分，这样它不仅从训练数据中提取必要的元素，而且通过拒绝不太重要的片段来节省存储器。
2。鱼脸识别器
Fisherfaces 算法不是获得代表所有人的所有面部的有用特征，而是移除区分一个人和其他人的有价值的特征。一个人的这种特征并不支配其他人，你有区别一个人和其他人的特征。
3。局部二元模式直方图
我们知道本征脸和鱼脸都受光线影响，在现实生活中也是如此；我们不能保证完美的光线条件。LBPH 人脸识别器是克服这一缺点的改进。这个想法不是找到图像的局部特征。LBPH 算法试图找到图像的局部结构，它是通过将每个像素与其相邻像素进行比较来实现的。
如何运行人脸识别:-
**#import OpenCV module**
import cv2
import os
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline**#function to detect face**
def detect_face (img):**#convert the test image to gray image**
gray = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)**#load OpenCV face detector**
face_cas = cv2.CascadeClassifier ('-File name.xml-')
faces = face_cas.detectMultiScale (gray, scaleFactor=1.3, minNeighbors=4);**#if no faces are detected then return image**
if (len (faces) == 0):
return None, None**#extract the face**
faces [0]=(x, y, w, h)**#return only the face part**
return gray[y: y+w, x: x+h], faces [0]**#this function will read all persons' training images, detect face #from each image
#and will return two lists of exactly same size, one list** def prepare_training_data(data_folder_path):**#------STEP-1--------
#get the directories (one directory for each subject) in data folder** dirs = os.listdir(data_folder_path)
faces = []
labels = []
for dir_name in dirs:**#our subject directories start with letter 's' so
#ignore any non-relevant directories if any** if not dir_name.startswith("s"):
continue;**#------STEP-2--------
#extract label number of subject from dir_name
#format of dir name = slabel
#, so removing letter 's' from dir_name will give us label** label = int(dir_name.replace("s", ""))**#build path of directory containin images for current subject subject
#sample subject_dir_path = "training-data/s1"** subject_dir_path = data_folder_path + "/" + dir_name**#get the images names that are inside the given subject directory** subject_images_names = os.listdir(subject_dir_path)**#------STEP-3--------
#go through each image name, read image,
#detect face and add face to list of faces** for image_name in subject_images_names:**#ignore system files like .DS_Store** if image_name.startswith("."):
continue;**#build image path
#sample image path = training-data/s1/1.pgm** image_path = subject_dir_path + "/" + image_name**#read image** image = cv2.imread(image_path)**#display an image window to show the image** cv2.imshow("Training on image...", image)
cv2.waitKey(100)**#detect face** face, rect = detect_face(image)**#------STEP-4--------
#we will ignore faces that are not detected** if face is not None:**#add face to list of faces** faces.append(face)**#add label for this face** labels.append(label)
cv2.destroyAllWindows()
cv2.waitKey(1)
cv2.destroyAllWindows()
return faces, labels**#let's first prepare our training data
#data will be in two lists of same size
#one list will contain all the faces
#and other list will contain respective labels for each face** print("Preparing data...")
faces, labels = prepare_training_data("training-data")
print("Data prepared")**#print total faces and labels** print("Total faces: ", len(faces))
print("Total labels: ", len(labels))**#create our LBPH face recognizer** face_recognizer = cv2.face.createLBPHFaceRecognizer()**#train our face recognizer of our training faces** face_recognizer.train(faces, np.array(labels))**#function to draw rectangle on image
#according to given (x, y) coordinates and
#given width and heigh** def draw_rectangle(img, rect):
(x, y, w, h) = rect
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)**#function to draw text on give image starting from
#passed (x, y) coordinates.** def draw_text(img, text, x, y):
cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0), 2)**#this function recognizes the person in image passed
#and draws a rectangle around detected face with name of the subject** def predict(test_img):**#make a copy of the image as we don't want to chang original image** img = test_img.copy()**#detect face from the image** face, rect = detect_face(img)**#predict the image using our face recognizer** label= face_recognizer.predict(face)**#get name of respective label returned by face recognizer** label_text = subjects[label]**#draw a rectangle around face detected** draw_rectangle(img, rect)**#draw name of predicted person** draw_text(img, label_text, rect[0], rect[1]-5)
return img**#load test images** test_img1 = cv2.imread("test-data/test1.jpg")
test_img2 = cv2.imread("test-data/test2.jpg")**#perform a prediction** predicted_img1 = predict(test_img1)
predicted_img2 = predict(test_img2)
print("Prediction complete")**#create a figure of 2 plots (one for each test image)** f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))**#display test image1 result** ax1.imshow(cv2.cvtColor(predicted_img1, cv2.COLOR_BGR2RGB))**#display test image2 result** ax2.imshow(cv2.cvtColor(predicted_img2, cv2.COLOR_BGR2RGB))**#display both images** cv2.imshow("Tom cruise test", predicted_img1)
cv2.imshow("Shahrukh Khan test", predicted_img2)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.waitKey(1)
cv2.destroyAllWindows()
这个博客是为那些想通过学习什么是人脸识别，它的类型以及它是如何工作的来开始他们在计算机视觉或人工智能领域的载体的初学者而写的。
人脸识别:理解 LBPH 算法
人类每天都在自动进行人脸识别，几乎不费吹灰之力。
虽然这听起来对我们来说是一个非常简单的任务，但对计算机来说却是一个复杂的任务，因为它有许多变量会影响方法的准确性，例如:光照变化、低分辨率、遮挡等。
在计算机科学中，人脸识别基本上是根据人脸图像识别一个人的任务。在过去的二十年里，它变得非常流行，主要是因为新方法的发展和当前视频/摄像机的高质量。
注意人脸识别不同于人脸检测:
- 人脸检测:它的目的是找到图像中的人脸(位置和大小)，并可能提取它们以供人脸识别算法使用。
- 面部识别:面部图像已经被提取、裁剪、调整大小并通常转换为灰度，面部识别算法负责寻找最能描述图像的特征。
面部识别系统基本上可以在两种模式下运行:
- 面部图像的验证或认证:基本上是将输入的面部图像与要求认证的用户相关的面部图像进行比较。基本上就是 1x1 的对比。
- 身份识别或面部识别:它主要将输入的面部图像与数据集中的所有面部图像进行比较，目的是找到与该面部相匹配的用户。基本上是 1xN 的对比。
有不同类型的人脸识别算法，例如:
- (1991)
- 【LBPH】(1996)****
- (1997)
- 【尺度不变特征变换】 (1999)
- 【加速健壮特性】 (冲浪) (2006)
每种方法都有不同的方法来提取图像信息并执行与输入图像的匹配。然而，特征面和鱼面方法以及 SIFT 和 SURF 方法具有类似的方法。
今天我们要讨论一种最古老(不是最古老)也是最流行的人脸识别算法:局部二值模式直方图(LBPH) 。
目标
这篇文章的目的是尽可能简单地解释 LBPH ，一步一步地展示这个方法。
由于这是一种比较简单的人脸识别算法，我想每个人都可以理解它，没有大的困难。
介绍
局部二进制模式 (LBP)是一个简单但非常有效的纹理算子，它通过对每个像素的邻域进行阈值处理来标记图像的像素，并将结果视为二进制数。
它在 1994 年首次被描述(LBP ),并且已经被发现是纹理分类的强大特征。已经进一步确定，当 LBP 与方向梯度直方图(HOG)描述符结合时，它在一些数据集上显著提高了检测性能。
使用 LBP 结合直方图，我们可以用简单的数据向量来表示人脸图像。
因为 LBP 是视觉描述符，所以它也可以用于面部识别任务，正如在下面的逐步解释中可以看到的。
注:你可以在这里阅读更多关于 LBPH:http://www.scholarpedia.org/article/Local_Binary_Patterns
循序渐进
现在，我们对人脸识别和 LBPH 有了更多的了解，让我们更进一步，看看算法的步骤:
- 参数:LBPH 使用 4 个参数:
- 半径:半径用于构建圆形局部二值模式，代表中心像素周围的半径。它通常设置为 1。
- 邻居:构建圆形局部二值模式的样本点数。请记住:包含的样本点越多，计算成本就越高。通常设置为 8。
- 网格 X :水平方向的单元格个数。单元越多，网格越细，得到的特征向量的维度越高。通常设置为 8。
- 网格 Y :垂直方向的单元格个数。单元越多，网格越细，得到的特征向量的维度越高。通常设置为 8。
现在不用担心参数，看完后面的步骤你就明白了。
2。 训练算法:首先，我们需要训练算法。为此，我们需要使用一个包含我们想要识别的人的面部图像的数据集。我们还需要为每张图像设置一个 ID(它可能是一个数字或人名)，因此算法将使用这些信息来识别输入图像并给你一个输出。同一个人的图像必须有相同的 ID。训练集已经构建好了，让我们看看 LBPH 的计算步骤。
3。应用 LBP 操作:LBPH 的第一个计算步骤是创建一个中间图像，通过突出面部特征，以更好的方式描述原始图像。为此，该算法使用滑动窗口的概念，基于参数半径和邻居。****
下图显示了此过程:
根据上面的图片，让我们把它分成几个小步骤，这样我们就可以很容易地理解它:
- 假设我们有一张灰度的面部图像。
- 我们可以得到这个图像的一部分，作为一个 3x3 像素的窗口。
- 也可以表示为包含每个像素(0~255)强度的 3x3 矩阵。
- 然后，我们需要取矩阵的中心值作为阈值。
- 该值将用于定义来自 8 个邻居的新值。
- 对于中心值(阈值)的每个邻居，我们设置一个新的二进制值。我们将等于或高于阈值的值设置为 1，将低于阈值的值设置为 0。
- 现在，矩阵将只包含二进制值(忽略中心值)。我们需要将矩阵中每个位置的每个二进制值逐行连接成一个新的二进制值(例如 10001101)。注意:一些作者使用其他方法连接二进制值(例如顺时针方向)，但最终结果将是相同的。
- 然后，我们将这个二进制值转换为十进制值，并将其设置为矩阵的中心值，这实际上是原始图像的一个像素。
- 在这个过程(LBP 过程)的最后，我们有一个新的图像，它更好地代表了原始图像的特征。
- 注:LBP 程序被扩展为使用不同数量的半径和邻居，它被称为圆形 LBP。
可以通过使用双线性插值来完成。如果某个数据点在像素之间，它将使用最近的 4 个像素(2x2)的值来估计新数据点的值。
4。提取直方图:现在，使用上一步生成的图像，我们可以使用网格 X 和网格 Y 参数将图像分成多个网格，如下图所示:****
根据上面的图像，我们可以提取每个区域的直方图如下:
- 由于我们有一个灰度图像，每个直方图(来自每个网格)将只包含 256 个位置(0~255 ),代表每个像素强度的出现。
- 然后，我们需要连接每个直方图来创建一个新的更大的直方图。假设我们有 8×8 的网格，在最终的直方图中我们将有 8×8×256 = 16.384 个位置。最终的直方图表示图像原始图像的特征。
LBPH 算法差不多就是这样。
5。执行面部识别:在这个步骤中，算法已经被训练。创建的每个直方图用于表示来自训练数据集的每个图像。因此，给定一个输入图像，我们对这个新图像再次执行这些步骤，并创建一个代表该图像的直方图。
- 因此，要找到与输入图像匹配的图像，我们只需比较两个直方图，并返回直方图最接近的图像。
- 我们可以使用各种方法来比较直方图(计算两个直方图之间的距离)，例如:欧氏距离、卡方、绝对值等。在本例中，我们可以根据以下公式使用欧几里德距离(这是众所周知的):
- 因此，算法输出是直方图最接近的图像的 ID。该算法还应返回计算出的距离，该距离可用作’置信度’度量。注意:不要被“置信度”这个名称所迷惑，因为置信度越低越好，因为这意味着两个直方图之间的距离越近。
- 然后，我们可以使用阈值和“置信度”来自动估计算法是否正确识别了图像。我们可以假设该算法已经成功识别了置信度是否低于定义的阈值。
结论
- LBPH 是最简单的人脸识别算法之一。
- 它可以表示图像中的局部特征。
- 有可能获得很大的成果(主要是在可控的环境下)。
- 它对单调的灰度变换是鲁棒的。
- 由 OpenCV 库(开源计算机视觉库)提供。
LBPH 算法
我正在用 Go 编程语言实现 LBPH 算法。项目可在 Github 上获得，并在 MIT 许可 下发布，因此请随意为该项目做出贡献(欢迎任何贡献)。
链接到项目:https://github.com/kelvins/lbph
注:结论中提到的 LBPH 也是由 OpenCV 库 提供的。OpenCV 库可以被许多编程语言使用(例如 C++、Python、Ruby、Matlab)。
如果你喜欢这个故事，请鼓掌。这激励我写更多关于人脸识别的故事。
参考
- 阿霍宁、蒂莫、阿卜杜努尔·哈迪德和马蒂·皮蒂凯宁。局部二值模式人脸描述:应用于人脸识别。IEEE 模式分析与机器智能汇刊 28.12(2006):2037–2041。
- 奥哈拉、提莫、马蒂·皮蒂凯宁和托皮·马恩帕。多分辨率灰度和旋转不变纹理分类与局部二值模式。IEEE 模式分析与机器智能汇刊 24.7(2002):971–987。
- 阿霍宁、蒂莫、阿卜杜勒努尔·哈迪德和马蒂·皮蒂凯宁。用局部二值模式进行人脸识别。计算机视觉-eccv 2004(2004):469–481。
- LBPH OpenCV:https://docs . OpenCV . org/2.4/modules/contrib/doc/facerec/facerec _ tutorial . html # local-binary-patterns-histograms
- 本地二进制模式:http://www.scholarpedia.org/article/Local_Binary_Patterns
我看起来像布拉德·皮特吗？
我们来问一个深度学习模型
Face recognition with deep learning
在另一篇文章中，我查看了数据准备来从图像中提取一张脸，并将其对齐，这样不管脸的旋转，面部特征总是对齐在中心。
在这篇文章中，我将准备一些我自己和布拉德·皮特的照片。目标将是在这些图像上训练一个深度学习模型，看看当呈现新图像时，它是否能检测出我们之间的差异。
这有点像第二十二条军规。如果一切顺利的话，模特将会成功地认出我或者布拉德·皮特。另一方面，如果它可以轻松做到这一点，这可能意味着我看起来一点也不像布拉德·皮特！
深度学习——它是什么？
机器学习和深度学习是相当超载的术语。他们被认为是不需要太多努力就能轻松解决任何问题的灵丹妙药。然而，事情并不总是这么简单。为了建立一个模型，你需要了解你在找什么，有什么参数，有多少训练数据，它有多可靠等等。
深度学习是一种专注于神经网络的机器学习。那就是编程和建立一个受人脑启发的模型。亚当·盖特基有一篇很棒的文章，他会比我更好地解释神经网络。
对于这篇文章，深度学习将用于产生称为嵌入的点(稍后解释)。这些点描述了面部的图像。在我们的例子中，给定两组人的图像，它的目标是确保它产生的点(嵌入)对于同一个人的面部非常相似，但是对于另一个人的面部非常不同。
- 确保为布拉德·皮特的脸的图像产生的所有点是相似的。
- 确保为我的脸部图像生成的所有点都是相似的。
- 确保为布拉德·皮特的图像生成的点与为我的脸的图像生成的点尽可能不同。
这将允许我们训练一个分类模型来区分两组图像。
建立一些训练数据
第一步是获得更多的数据。我不想花太多时间去挖掘和下载图片，所以我最初用 3 张布拉德的图片和 3 张我自己的图片来验证这个概念。
我通过我在上一篇文章中写的face_skew.py python 应用程序运行每张图片。这给了我总共 6 个对齐的图像。
我将这些图像存储在一个名为 aligned_faces 的文件夹中，每个图像都有自己的子目录。
./aligned_faces/me/ ./aligned_faces/bradp/
建筑嵌入
现在我已经准备好了数据，是时候构建嵌入了。
请记住，这些嵌入是由神经网络产生的一组 128 个点。这些点对于相同的人脸是相似的，而对于其他人的人脸是不同的。128 点嵌入过程是从谷歌的一些研究中发展出来的。建立一个深度学习模型来做到这一点非常耗时，并且需要一些强大的显卡。为了克服这一点，我使用了来自 Openface 的预训练模型。
他们提供了一些帮助代码以及帮助我生成嵌入的模型。你需要确保你已经用 sklearn 和 pandas 库安装了 Python，同时还安装了 Dlib 、 OpenCV 和 open face(https://github . com/cmusatyalab/open face)。
一旦你安装了所有这些，进入 Openface 的基本目录，然后进入一个名为batch-recognise的文件夹。
在这里，我运行以下命令来为我对齐的面构建嵌入。
./main.lua -outDir ~/facerecognition/embeddings/ -data ~/facerecognition/aligned_faces/
在outDir中，这应该产生 2 个文件:labels.csv和reps.csv。它们分别包含输入图像的图像路径和每个图像的一行 128 个点。
成功了！我已经用深度学习模型运行了我的图像，并产生了一些输出
在处理机器学习应用时，你可能会注意到一个趋势。大部分工作是在数据准备和将数据转换成机器可读的格式。在我们的例子中，它获取图像数据并将其转换成数字表示。在分类文本数据进行情感分析之前，我们必须做同样的事情。
一旦完成，剩下的就是构建一个简单的分类器来进行“识别”。
识别面孔——我看起来像布拉德·皮特吗？
如果您想要更高级的方法来完成这一步，您可以训练自己的分类模型来对嵌入进行分类。然而，在 Openface 目录中，他们友好地提供了一个使用支持向量机算法的示例 python 分类器。
从 Openface 基本目录，进入名为demos的目录。
为了训练分类器，我运行了以下内容:
$ python classifier.py train ~/facerecognition/embeddings
现在，在您的嵌入文件中，您应该有一个 pickle 文件，其中包含您生成的 SVM。
为了测试它，我简单地获得了两个额外的图像，它们不同于我用来训练模型的图像。一张是我的，另一张是布拉德·皮特的。
我对它们进行了测试，得到了以下结果:
$ python classifier.py infer ~/facerecognition/embeddings/classifier.pkl /media/sf_Shared/test_image_me.jpg === /media/sf_Shared/test_image_me.jpg === Predict me with 0.86 confidence. $ python classifier.py infer ~/facerecognition/embeddings/classifier.pkl /media/sf_Shared/test_image_bradp.jpeg === /media/sf_Shared/test_image_bradp.jpeg === Predict bradp with 0.73 confidence.
包裹
总之，不幸的是，即使只有 3 张图片的训练数据集，**这个模型也能很容易地区分我和布拉德·皮特！**我真的应该看到它的到来。
然而，它似乎只对小样本数据有效。这是一个很好的介绍，让我开始理解深度学习的力量及其工作原理。尽管只是复制粘贴命令，但阅读这个主题的内容是很重要的，至少可以对模型的工作原理有所了解。
在未来，我将试图从头开始建立自己的深度学习模型。
face 2 face——模仿德国总理面部表情的 Pix2Pix 演示
受吉恩·科岗工作室的启发，我制作了自己的 face2face 演示，可以在 2017 年德国总理发表新年演讲时将我的网络摄像头图像翻译成她的样子。它还不完美，因为这个模型还有一个问题，例如，学习德国国旗的位置。然而，这个模特已经很好地模仿了她的面部表情，考虑到我在这个项目上的有限时间，我对结果很满意。
这就是了😃
Face2face demo with the original video input.
这也是另一个版本，它把我的面部标志作为输入。
Face2face demo with the detected facial landmarks.
如果你有兴趣创建自己的演示或者只是自己运行它， Github repositor y 包含了你需要的一切。当然，你应该继续阅读！😁
动机
几周前，我参加了在柏林艺术博物馆举行的吉恩·科岗关于 pix2pix 和深度生成模型的研讨会。在那里，他展示了几个利用生成模型的艺术项目。他展示的其中一个项目是他自己的，他使用面部追踪器创建了一个能够模仿特朗普的生成模型:
这种演示真的让我耳目一新，因为我在工作中通常不会接触这类项目。在这次研讨会后，我决定创建自己的项目，类似于 Gene 用面部追踪器做的项目，但用的是不同的人。
生成培训数据
我要做的第一件事是创建数据集。为此，我使用了 Dlib 的姿势估计器，它可以检测一张脸上的 68 个标志(嘴、眉毛、眼睛等……)以及 OpenCV 来处理视频文件:
- 检测面部标志是两个阶段的过程。首先，使用面部检测器来检测面部，然后对检测到的面部应用姿态估计器。
- 姿势估计器是论文的一个实现:一毫秒人脸对齐与回归树集合由瓦希德·卡泽米和约瑟芬·苏利文于 2014 年在 CVPR 发表
- 我遇到的一个问题是，在我第一次实现时，面部标志检测器非常滞后(非常低的每秒帧数-fps)。我发现输入框太大了。将帧的大小缩小到四分之一会大大提高 fps。在 Satya Mallick 的另一篇博客文章中，他也建议跳过帧，但我没有这样做，因为 fps 现在已经足够好了。但是，我可以在以后尝试这种方法来进一步提高性能。
- 我在 YouTube 上查找了几个潜在的视频，我可以用它们来创建从采访到名人演讲的数据。最后，我决定用安格拉·默克尔(德国总理)的 2017 年新年致辞。这个视频特别适合，因为相机的位置是静态的，所以我可以用她的脸和背景的相同位置得到很多图像。
One sample of the training data.
训练模型
幸运的是，在研讨会上，Gene 还指出了一些现有的生成模型的代码库，如 pix2pix。所以我不需要做很多研究。对于模型的训练，我使用了 Daniel Hesse 令人惊奇的 pix2pix TensorFlow (TF) 实现，这是有据可查的。丹尼尔也在他自己的博客上对 pix2pix 做了很好的介绍。如果你没看过，你应该看看！*剧透:*还利用了 hello kitty！🐱
备注:
-
pix2pix 的最初实现实际上在 Torch 中，但我更喜欢 TensorFlow。
-
此外，如果你不知道 pix2pix 是什么或者一般的生成模型，你可以考虑 PCA 或自动编码器，它们的主要目标是重建。不过，与这些模型的主要区别在于，生成模型中的“重建”在生成输出数据时会涉及一些随机性。例如，如果您已经了解自动编码器的基本知识，那么variable auto encoder是一个易于理解的生成模型。
-
Gene 也在为 Pix2Pix 编写教程。我认为它还没有完成，但在他的页面上你可以找到很多其他的展示案例，例如贾斯帕·范·洛宁的神经城也很酷。
-
我发现的另一个很酷的应用是 Arthur Juliani 做的，他用 pix2pix 在 TensorFlow 中翻拍经典电影。这是我从他的文章中截取的电影后窗的一个经过重新制作的短片:
Top: input video. Middle: pix2pix output. Bottom: original remastered version.
因此，在我克隆了 Daniel 的 repo 并用他的助手脚本处理数据后，主要的挑战是实际的训练本身，因为训练模型可能需要 1-8 个小时，这取决于 GPU 和实际设置，如时期数、图像等…关于 CPU 的培训马上被排除，因为这可能需要几个小时。和往常一样，由于我家里没有带 GPU 的机器(我知道是时候投资这样的 machine^^了)，我不得不依赖云服务。
Pix2Pix model graph in TensorFlow.
通常，我的第一选择是 AWS 和它的 G2 实例，但是这次我使用了 FloydHub 来代替。我必须承认，这很酷。我在《黑客新闻》上读到过，想尝试一下。好的一面是，目前当你在那里注册一个账户，你将获得 100 小时的免费 GPU，这是相当可怕的。他们也有一个非常好的 CLI 工具，比起 GUI 我更喜欢它(但是他们也有一个)。训练包含一个命令行的模型也非常容易。到目前为止，我唯一的批评是，在培训结束后，你不能像在 AWS 上那样 ssh 到容器中。有时候，你只需要改变一件事，而不需要重新上传所有的文件，如果你的文件很大，这尤其令人讨厌。不管怎样，从另一方面来说，你省钱了，但是总有好处和坏处。
然后，我终于对我生成的 400 张图片进行了实际的训练。就此而言，320 用于训练，其余用于验证。而且我用不同的历元数(5*，200，400)对模型进行了训练。训练时间因设置而异，从 6 分钟到 7 小时以上不等。
*这更多是出于测试目的。在低位，安格拉·默克尔生成的输出非常像素化和模糊，但你已经可以很好地看到她的表情轮廓。
这是我做的一个实验的一些结果(纪元 200)。如您所见，鉴别器和生成器的学习过程非常嘈杂:
Plot for the discriminator and generator loss.
如果我们查看不同步骤的输出摘要，我们可以看到这可能是由标志引起的:
Output summary for different steps.
增加时期的数量有助于减少一点点的像素化，但是旗帜的问题仍然存在。
Detected facial landmarks and the generated output for epoch 400.
有趣的是，我注意到，根据我旋转头部的方式，旗子的位置也会发生变化。我想为了提高我的成绩，我可能需要用更多的数据来训练它。
为模型服务
训练完模型后，是时候在此基础上用 OpenCV 构建应用程序了。最大的挑战实际上是如何在应用程序中集成这个模型，因为 Daniel 的实现并不真正适合这个。他的实现对于训练来说是高度优化的，例如他使用队列读入数据。这对训练真的很好，但我在为模特服务时没有看到这种必要性。此外，如您所知，在 TF 中保存模型时，会创建很多文件，如检查点、图本身的权重和元数据。但是在生产中，我们不需要任何这些元数据文件，因为我们只是希望我们的模型和它的权重很好地打包在一个文件中(如果你想知道如何做到这一点， Morgan Giraud 写了一个关于这个的很好的教程)。因此，我不得不做了相当多的逆向工程，使它更适用于应用程序。
**注:**从 TF 1.0 开始，我们也可以使用[tf.saved_model](https://www.tensorflow.org/api_docs/python/tf/saved_model)保存模型。这是使用 TensorFlow 服务时的首选方式。但是，这种方法也会创建多个文件。通常，您会得到一个包含模型的图形定义的save_model.pb和一个保存其权重的variables文件夹。
如果你喜欢这个职位给我一个❤️.这是我第一个将深度学习用于艺术的项目。我还有一些想法想要解决。敬请关注。在 Medium Dat Tran 或 twitter @datitran 上关注我，了解我的最新作品。
脸书研究中心刚刚发表了一篇关于学习层级表征的精彩论文
学习分层表示的庞加莱嵌入
Arxiv 链接:https://arxiv.org/abs/1705.08039
在初步阅读后，我的一位教授说:
这个想法很有趣，结果好得令人难以置信。
这是我给很多人看结果时他们的反应。
首先，我将向你展示我在 WordNet 的一部分上得到的结果，这样上面的不可行性图片就淡化了一点:
WordNet embeddings for Mammal (only three levels)
我只用过三级:
- 黑色一号在 0 级
- 红色的在第一层
- 绿色的在第二层。
我觉得结果不错。
在我以前的一篇文章中，跨语言单词嵌入是什么？，我解释了单词嵌入。它们可以用于不同的任务，如信息检索、情感分析和无数其他任务。
类似地，我们可以嵌入图，并有像 node2vec 这样的方法，潜在空间嵌入可以帮助我们表示图，并随后进行社区检测和链接预测。
让我们从最初的 node2vec 论文开始研究这个问题→
在 node2vec 中，我们学习了节点到低维特征空间的映射，该映射最大化了保存节点的网络邻域的可能性。
像 word2vec 嵌入一样，我们可以使用 node2vec 嵌入来预测新的链接。假设我们有一个社交网络的数据，现在当我们嵌入节点时，通过一些距离度量，我们看到两个节点(用户)有一个小的距离，然后我们可以建议用户成为社交网络上的朋友。可能发生这种情况的一种情况是，当用户 2 是社交网络的新用户，并且获得与用户 1 相似的朋友时，给定重叠的朋友(图中的边)，用户 2 和用户 1 彼此认识的机会增加。
node2vec 嵌入有两个主要方面:
能够学习将来自相同网络社区的节点紧密嵌入在一起的表示，以及学习共享相似角色的节点具有相似嵌入的表示
Source: Google Images
现在考虑表示分层数据的情况，分层数据的结构像树一样
基于直觉，我们可以把它比作双曲线。
根居中，叶向外展开。
Source: Google Images
这一事实被报纸所利用:
为了利用这种结构特性来学习更有效的表示，我们建议不在欧几里得空间中而是在双曲空间中计算嵌入，即具有恒定负曲率的空间。非正式地，双曲空间可以被认为是树的连续版本，因此它自然地被装备来建模分层结构。
他们使用庞加莱球模型作为双曲空间的模型，因为它非常适合基于梯度的优化，因此也适合反向传播。
当然，当你谈论一个不同的空间时，距离的度量是不同的。在庞加莱球模型的情况下，两点u和v之间的双曲线距离由下式给出:
Source: Original paper
其中||x||是欧几里德范数。如果你看到维基百科给出的公式，你可能会注意到1已经取代了|r|，因为作者只取了一个半径为1的球。
现在，为了训练模型，我们基于这个距离创建一个优化函数，类似于 Mikolov 等人使用的负采样。
Source: Original paper
然后反向传播我们的方法来更新嵌入。
∇e =(∂l(θ)/∂d(θ,x))*(∂d(θ,x)/∂d(θ)
第一部分已经知道了，他们已经给出了第二部分的公式:
Source: Original Paper
他们使用了一个小技巧，这样在更新后嵌入的内容不会比模型大。为此他们部署了以下投影:
Source: Original Paper
然后，它们通过以下规则更新嵌入:
Source: Original Paper
结果
这是最有趣的部分
Source: Original Paper
我们可以看到，该模型在 5 维空间中实现的效果优于欧几里德模型在 200 维空间中实现的效果。
我希望你对结果感到敬畏。
TL；博士
他们使用双曲空间来嵌入分层数据的节点，并取得了一些超级棒的结果。
你可以在 twitter 上关注我，地址是 @nishantiam ，我在 github 上的地址是 @nishnik 。
脸书，告诉我该怎么做！
在围绕侵犯隐私和#deleteFacebook 运动的丑闻中，我发现自己感到兴奋，而不是不安。
Mirror mirror on the wall
我相信真理和意义——只是我还没能识别它们。这就是为什么十几岁的时候，我梦想成为一名物理学家，提出一个描述一切事物的公式。我已经放弃了这个想法。)当围绕大数据的讨论让我从艺术转向 IT 和数据科学时，我对自己的能力产生了怀疑。大数据的承诺是，我们可以知道一切，即使我们可能永远也不会理解它。
多年后，我们在这里用数据销售产品，寻找爱人，赢得选举。数据就是力量。而大权力是可怕的。因此，我们努力限制这种权力，声明数据应该受到保护，并将隐私视为一项基本人权。
(我的祖父母更关心食物和其他东西。)
Google n-gram
当我们不知道这种力量为谁服务的时候，或者有时我们太了解它的时候，这种力量就特别可怕。如果你不是付费的顾客，那么你可能就是产品。当谈到脸书时，我认为不应该是这样。可以为用户提供真正的价值，从而使个人成为客户——挑战将是设计最好的以用户为中心的数据产品。
作为又一个困惑的千禧一代，我真的需要一些见解。我已经知道我会在霍格沃茨的哪个房间，哪个性别，哪个城市角色和死去的天才，但是我发现这些信息很难应用到现实生活的决定中。你为什么不给我一些更有说服力的证据？是的，我会为此付出代价。(我的意思是，我曾经付钱给一位名叫劳拉的在线占星家，她在自己的网站上使用漫画。有满月折扣或 smth。# no regets)
大数据可以成为更好地了解自我和个人成长的工具。没有人比像脸书这样的大型互联网公司更适合提供这种服务，这些公司已经收集个人数据十多年了。所以不用感谢你的“下载数据”按钮。我宁愿你以对我有利的方式使用我的数据，如果你搞砸了，就去找下一个提供商。
脸书的开源强化学习平台——深度探索
脸书决定开源他们创建的平台，以解决他们正在研究的规模的端到端强化学习问题。所以我当然要试试这个。)让我们一起来看看他们是如何安装的，以及您自己应该做些什么来让它工作。
我开始创建一个全新的 Ubuntu 18.10 安装
还测试并验证了在 Linux 的 Windows 子系统上工作
安装 Anaconda
让我们从安装 Anaconda 开始，这很容易通过导航到位于https://conda.io/docs/user-guide/install/index.html的文档来完成，然后我们可以找到到 Linux 安装程序https://www.anaconda.com/download/#linux的链接，这将为我们提供安装程序脚本:https://repo . Anaconda . com/archive/Anaconda 3-5 . 3 . 0-Linux-x86 _ 64 . sh .
我们可以通过运行以下命令来下载并运行它:
curl https://repo.anaconda.com/archive/Anaconda3-5.3.0-Linux-x86_64.sh -o conda.sh
bash conda.sh
然后按照安装程序的步骤安装 Anaconda
完成后，通过以下方式将 conda 安装添加到您的PATH变量:
echo 'export PATH="$PATH":/home/<YOUR_USER>/anaconda3/bin' >> ~/.bashrc
. ~/.bashrc
注意:对于 Python 3 版本，anaconda 的默认安装是/home/ubuntu/anaconda3
为我们的 Horizon 安装配置 Anaconda
脸书地平线需要几个特定软件的通道，我们可以很容易地将它们添加到 anaconda 中:
conda config --add channels conda-forge # ONNX/tensorboardX
conda config --add channels pytorch
安装 Horizon
要深入了解如何安装 Horizon，请查看 Git repo:https://github . com/Facebook research/Horizon/blob/master/docs/installation . MD
git clone https://github.com/facebookresearch/Horizon.git
cd Horizon/
conda install `cat docker/requirements.txt` # wait till it solved the environment, then select y
source activate base # Activate the base conda environmentpip install onnx # Install ONNX
export JAVA_HOME="$(dirname $(dirname -- `which conda`))" # Set JAVA_HOME to anaconda installation
cd # Go back to root# Install Spark 2.3.1
wget http://www-eu.apache.org/dist/spark/spark-2.3.1/spark-2.3.1-bin-hadoop2.7.tgz
tar -xzf spark-2.3.1-bin-hadoop2.7.tgz
sudo mv spark-2.3.1-bin-hadoop2.7 /usr/local/sparkexport PATH=$PATH:/usr/local/spark/bin # add to PATH so we can find spark-submit# Install OpenAI Gym
pip install "gym[classic_control,box2d,atari]"# Build Thrift Classes
cd Horizon/
thrift --gen py --out . ml/rl/thrift/core.thrift# Build Horizon
pip install -e . # we use "-e" for "ephemral package" which will instantly reflect changes in the package
地平线(全球概览)
介绍
Horizon 是一个端到端平台，其中*“包括模拟环境的工作流，以及用于预处理、培训和导出生产模型的分布式平台。”*——(消息来源)
从阅读文件中，我们可以了解到该平台是基于以下考虑而创建的:
- 高效处理大型数据集的能力
- 能够自动高效地预处理数据
- 竞争算法性能
- 发布前的算法性能评估
- 服务于生产的柔性模型
- 平台可靠性
这听起来对我来说太棒了，所以让我们从如何利用这个平台开始，然后我们可以更深入地了解它的工作原理。
对于强化学习中用到的一些术语，可以随时查看我之前的 博文 了解一下。
入门指南
开始使用 Horizon 就像检查他们编写的用法文档一样简单。这包括以下步骤
- 创建培训数据
- 将数据转换为时间线格式
- 创建标准化参数
- 训练模型
- 评估模型
地平线—批量 RL(深潜)
现在，我们知道了 Horizon 平台的总体概念，让我们按照使用文档中所写的那样运行不同的步骤，并深入了解它们，发现幕后发生的事情。让我们从创建训练数据开始。
1.创建培训数据
我们的使用文档列出了我们应该通过以下命令创建训练数据:
# Create a directory where we will put the training data
mkdir cartpole_discrete# Generate training data
python ml/rl/test/gym/run_gym.py -p ml/rl/test/gym/discrete_dqn_cartpole_v0_100_eps.json -f cartpole_discrete/training_data.json
但是这实际上是做什么的呢？打开位于ml/rl/test/gym/中的run_gym.py文件，在main()方法中向我们展示了以下内容:
def main(args):
parser = argparse.ArgumentParser(
description="Train a RL net to play in an OpenAI Gym environment."
)
parser.add_argument("-p", "--parameters", help="Path to JSON parameters file.")
这向我们展示了当运行命令python ml/rl/test/gym/run_gym.py时，我们能够在控制台中看到我们的脚本的使用情况，运行该命令会导致:
Traceback (most recent call last):
File "ml/rl/test/gym/run_gym.py", line 611, in <module>
+ " [-s <score_bar>] [-g <gpu_id>] [-l <log_level>] [-f <filename>]"
Exception: Usage: python run_gym.py -p <parameters_file> [-s <score_bar>] [-g <gpu_id>] [-l <log_level>] [-f <filename>]
向我们解释，如果我们给出由我们的-p参数定义的参数文件，它将加载这个 JSON 文件并将其加载到一个名为params的变量中，而如果我们添加-f参数，我们将能够将收集的样本作为一个 RLDataSet 保存到提供的文件中。
main()方法
main 方法现在将继续做几件事情:
# Load our parameters from the json
with open(args.parameters, "r") as f:
params = json.load(f)# Initialize a dataset variable of type `RLDataset` if the `file_path` parameter is set
# `file_path`: If set, save all collected samples as an RLDataset to this file.
dataset = RLDataset(args.file_path) if args.file_path else None# Call the method `run_gym` with the parameters and arguments provided
reward_history, timestep_history, trainer, predictor = run_gym(
params, args.score_bar, args.gpu_id, dataset, args.start_saving_from_episode
)# Save our dataset if provided through the -f parameter
if dataset:
dataset.save()# Save the results to a csv if the `results_file_path` parameter is set
if args.results_file_path:
write_lists_to_csv(args.results_file_path, reward_history, timestep_history)# Return our reward history
return reward_history
运行使用文档python ml/rl/test/gym/run_gym.py -p ml/rl/test/gym/discrete_dqn_cartpole_v0_100_eps.json -f cartpole_discrete/training_data.json中显示的命令后，我们可以在由-f参数定义的training_data.json文件中看到以下结构。
{
"ds": "2019-01-01",
"mdp_id": "0",
"sequence_number": 10,
"state_features": {
"0": -0.032091656679586175,
"1": -0.016310561477682117,
"2": -0.01312794549150956,
"3": -0.04438365281404494
},
"action": "1",
"reward": 1.0,
"action_probability": 1.0,
"possible_actions": [
"0",
"1"
],
"metrics": {
"reward": 1.0
}
}
RLDataset 类
这是由-f参数生成的，它将以RLDataset类提供的格式将结果保存到提供的文件中。检查位于ml/rl/training/rl_dataset.py的这个类向我们显示:
"""
Holds a collection of RL samples in the "pre-timeline" format.:param file_path: String Load/save the dataset from/to this file.
"""# === LINES REMOVED ===self.rows.append(
{
"ds": "2019-01-01", # Fix ds for simplicity in open source examples
"mdp_id": str(mdp_id),
"sequence_number": int(sequence_number),
"state_features": state_features,
"action": action,
"reward": reward,
"action_probability": action_probability,
"possible_actions": possible_actions,
"metrics": {"reward": reward},
}
run_gym()方法
现在我们可以看到这些行被创建并保存在内存中的RLDataset类中。但是实际上是什么在使用它并填充它呢？让我们先来看看我们的run_gym()方法的总体情况:
env_type = params["env"]# Initialize the OpenAI Gym Environment
env = OpenAIGymEnvironment(
env_type,
rl_parameters.epsilon,
rl_parameters.softmax_policy,
rl_parameters.gamma,
)
replay_buffer = OpenAIGymMemoryPool(params["max_replay_memory_size"])
model_type = params["model_type"]use_gpu = gpu_id != USE_CPU# Use the "training" {} parameters and "model_type": "<MODEL>" model_type
# to create a trainer as the ones listed in /ml/rl/training/*_trainer.py
# The model_type is defined in /ml/rl/test/gym/open_ai_gym_environment.py
trainer = create_trainer(params["model_type"], params, rl_parameters, use_gpu, env)# Create a GymDQNPredictor based on the ModelType and Trainer above
# This is located in /ml/rl/test/gym/gym_predictor.py
predictor = create_predictor(trainer, model_type, use_gpu)c2_device = core.DeviceOption(
caffe2_pb2.CUDA if use_gpu else caffe2_pb2.CPU, int(gpu_id)
)# Train using SGD (stochastic gradient descent)
# This just passess the parameters given towards a method called train_gym_online_rl which will train our algorithm
return train_sgd(
c2_device,
env,
replay_buffer,
model_type,
trainer,
predictor,
"{} test run".format(env_type),
score_bar,
**params["run_details"],
save_timesteps_to_dataset=save_timesteps_to_dataset,
start_saving_from_episode=start_saving_from_episode,
)
run_gym方法似乎在使用我们从 JSON 文件中加载的参数来初始化 OpenAI Gym 环境。因此，让我们打开一个 JSON 文件，运行一个快速的cat ml/rl/test/gym/discrete_dqn_cartpole_v0_100_eps.json向我们展示:
{
"env": "CartPole-v0",
"model_type": "pytorch_discrete_dqn",
"max_replay_memory_size": 10000,
"use_gpu": false,
"rl": {
"gamma": 0.99,
"target_update_rate": 0.2,
"reward_burnin": 1,
"maxq_learning": 1,
"epsilon": 1,
"temperature": 0.35,
"softmax_policy": 0
},
"rainbow": {
"double_q_learning": false,
"dueling_architecture": false
},
"training": {
"layers": [
-1,
128,
64,
-1
],
"activations": [
"relu",
"relu",
"linear"
],
"minibatch_size": 64,
"learning_rate": 0.001,
"optimizer": "ADAM",
"lr_decay": 0.999,
"use_noisy_linear_layers": false
},
"run_details": {
"num_episodes": 100,
"max_steps": 200,
"train_every_ts": 1,
"train_after_ts": 1,
"test_every_ts": 2000,
"test_after_ts": 1,
"num_train_batches": 1,
"avg_over_num_episodes": 100
}
}
其中显示了Environment、Epsilon、Softmax Policy和Gamma parameters都用于启动OpenAIGymEnvironment，其余参数传递给训练器。接下来，run_gym方法还将初始化一个 replay_buffer，创建训练器和预测器。此后它将运行train_sgd方法。
既然我们现在知道了我们的run_gym()方法，让我们进一步看看我们的dataset变量是如何进一步传递的:
run_gym()将获取由main()方法传递的方法作为save_timesteps_to_dataset参数run_gym()将把它传递给train_sgd()方法train_sgd()将它传递给train_gym_online_rl()方法。
train_gym_online_rl()方法
现在定义了这个参数后，train_gym_online_rl()方法将通过RLDataset类中定义的insert()方法保存几个变量:
记住
*RLDataset*类是在文件中定义的:*ml/rl/training/rl_dataset.py**insert*方法定义为:*RLDataset::insert(mdp_id, sequence_number, state, action, reward, terminal, possible_actions, time_diff, action_probability)*
来源: run_gym.py#L208
来源变量来自run_gym.py输出变量类型描述 i mdp_id string情节(例如游戏的整个播放过程)的唯一 ID EP _ time steps-1 sequence _ numberinteger定义 mdp(例如事件的时间戳)状态中状态的排序。action_to_log 动作string选择的动作名称奖励奖励float此状态下的奖励/动作终端终端bool未使用可能的动作可能的动作list<string>此状态下所有可能的动作列表。请注意，所采取的行动必须出现在此列表中。1.0 action_probability float如果策略是随机的，则采取此操作的概率，否则为空。请注意，我们强烈鼓励使用随机策略，而不是在每个时间步选择最佳行动。这种探索将改善评价，并最终导致更好地了解政策。1 time_diff integer未 Ised？ds string这个数据集的唯一 ID
我们的run_gym.py现在将运行-p文件(例如ml/rl/test/gym/discrete_dqn_cartpole_v0_100_eps.json)中指定的一定数量的剧集，其中它将(当它能够)使用train_gym_online_rl()方法来:
- 获取可能的操作
- 采取行动(基于它是否是离散行动类型)
- 浏览健身房环境并检索
next_state、reward和terminal变量 - 基于
gym_env.policy变量中的policy定义要采取的 next_action - 增加获得的奖励
- 将观察到的行为插入重放缓冲区
- 每个
train_every_ts从replay_buffer上取下num_train_batches并用这些训练trainer - 注意:这个训练器是在
[create_trainer()](https://github.com/facebookresearch/Horizon/blob/bbea36948bd409f03ec449be4539bd6bd9006418/ml/rl/test/gym/run_gym.py#L208)方法中创建的，该方法将创建一个 DDPGTrainer、SACTrainer、ParametericDQNTrainer 或 DQNTrainer - 每个
test_every_ts记录我们的模型在logger、avg_reward_history和timestep_history的表现 - 记录剧集结束的时间
2.将我们的训练数据转换为时间线格式
在第 2 步中，我们将转换之前以以下格式保存的培训数据:
*{
"ds": "2019-01-01",
"mdp_id": "0",
"sequence_number": 10,
"state_features": {
"0": -0.032091656679586175,
"1": -0.016310561477682117,
"2": -0.01312794549150956,
"3": -0.04438365281404494
},
"action": "1",
"reward": 1.0,
"action_probability": 1.0,
"possible_actions": [
"0",
"1"
],
"metrics": {
"reward": 1.0
}
}*
对于他们所谓的timeline格式，这是一种给定一个表(state，action，mdp_id，sequence_number，reward，possible_next_actions)返回强化学习所需的表(mdp_id，state_features，action，reward，next_state_features，next_action，sequence_number，sequence_number_ordinal，time_diff，possible_next_actions)的格式，在 Timeline.scala 中定义，我们可以表示为:
这将执行一个 Spark 作业，通过 Hive 运行一个查询，并将结果返回到一个不同的文件中。
*# Build timeline package (only need to do this first time)
mvn -f preprocessing/pom.xml clean package# Clear last run's spark data (in case of interruption)
rm -Rf spark-warehouse derby.log metastore_db preprocessing/spark-warehouse preprocessing/metastore_db preprocessing/derby.log# Run timelime on pre-timeline data
/usr/local/spark/bin/spark-submit \
--class com.facebook.spark.rl.Preprocessor preprocessing/target/rl-preprocessing-1.1.jar \
"`cat ml/rl/workflow/sample_configs/discrete_action/timeline.json`"# Merge output data to single file
mkdir training_data
mv cartpole_discrete_timeline/part* training_data/cartpole_training_data.json# Remove the output data folder
rm -Rf cartpole_discrete_timeline*
执行之后，我们现在可以通过运行head -n1 training_data/cartpole_training_data.json来查看创建的文件:
*{
"mdp_id": "31",
"sequence_number": 5,
"propensity": 1.0,
"state_features": {
"0": -0.029825548651835395,
"1": 0.19730168855281788,
"2": 0.013065490574540607,
"3": -0.29148843030554333
},
"action": 0,
"reward": 1.0,
"next_state_features": {
"0": -0.02587951488077904,
"1": 0.0019959027899765502,
"2": 0.00723572196842974,
"3": 0.005286388581067669
},
"time_diff": 1,
"possible_next_actions": [1, 1],
"metrics": {
"reward": 1.0
}
}*
有趣的是，Spark 引擎将允许我们利用完全由 CPU 操作运行的分布式集群。GPU 操作将在稍后阶段进行。允许我们完全利用 HDFS 上的一个集群和纯粹用于 GPU 计算的一个集群。
3.正常化
为了减少噪音和更快地训练我们的神经网络，我们使用了“标准化”。Horizon 包含一个工具，该工具可自动分析训练数据集，并为每个要素确定最佳变换函数和相应的归一化参数。
要运行它，可以使用以下命令:
*python ml/rl/workflow/create_normalization_metadata.py -p ml/rl/workflow/sample_configs/discrete_action/dqn_example.json*
打开/ml/rl/workflow/sample_configs/discrete_action/dqn_example.json文件，我们可以看到一个类似的配置文件被传递给我们的健身房环境的主函数:
*{
"training_data_path": "training_data/cartpole_training_data.json",
"state_norm_data_path": "training_data/state_features_norm.json",
"model_output_path": "outputs/",
"use_gpu": true,
"use_all_avail_gpus": true,
"norm_params": {
"output_dir": "training_data/",
"cols_to_norm": [
"state_features"
],
"num_samples": 1000
},
"actions": [
"0",
"1"
],
"epochs": 100,
"rl": {
"gamma": 0.99,
"target_update_rate": 0.2,
"reward_burnin": 1,
"maxq_learning": 1,
"epsilon": 0.2,
"temperature": 0.35,
"softmax_policy": 0
},
"rainbow": {
"double_q_learning": true,
"dueling_architecture": false
},
"training": {
"layers": [-1,
128,
64, -1
],
"activations": [
"relu",
"relu",
"linear"
],
"minibatch_size": 256,
"learning_rate": 0.001,
"optimizer": "ADAM",
"lr_decay": 0.999,
"warm_start_model_path": null,
"l2_decay": 0,
"use_noisy_linear_layers": false
},
"in_training_cpe": null
}*
因此，让我们打开ml/rl/workflow/create_normalization_metadata.py文件，在这里我们可以立即看到它的 main 方法以一个名为create_norm_table的函数开始。
create_norm_table()方法将接受参数(上面的 json)并利用norm_params、training_data_path、cols_to_norm和output_dir配置来创建规范化表。
这个规范化表是通过检查要规范化的列(在上面的 json 中是列state_features)构建的，它将通过get_norm_metadata()函数获取元数据。该函数将开始从我们的数据集中读取数据，并开始对要素及其值进行采样。一旦它收集到足够的样本(如norm_params["num_samples]配置所定义的)，它将继续。
4.训练模型
由于现在一切都经过预处理，数据也标准化了，我们准备开始训练我们的模型。为此，我们可以运行以下命令:
*python ml/rl/workflow/dqn_workflow.py -p ml/rl/workflow/sample_configs/discrete_action/dqn_example.json*
它将利用 dqn_workflow.py 文件选择正确的教练来训练它的模型。运行此命令将导致:
*INFO:__main__:CPE evaluation took 0.23067665100097656 seconds.
INFO:__main__:Training finished. Processed ~3961 examples / s.
INFO:ml.rl.workflow.helpers:Saving PyTorch trainer to outputs/trainer_1543773299.pt
INFO:ml.rl.workflow.helpers:Saving Caffe2 predictor to outputs/predictor_1543773299.c2
INFO:ml.rl.caffe_utils:INPUT BLOB: input.1\. OUTPUT BLOB:11
INFO:ml.rl.training.dqn_predictor:Generated ONNX predict net:
INFO:ml.rl.training.dqn_predictor:name: "torch-jit-export_predict"
op {
input: "input.1"
input: "1"
input: "2"
output: "7"
name: ""
type: "FC"
}
op {
input: "7"
output: "8"
name: ""
type: "Relu"
}
op {
input: "8"
input: "3"
input: "4"
output: "9"
name: ""
type: "FC"
}
op {
input: "9"
output: "10"
name: ""
type: "Relu"
}
op {
input: "10"
input: "5"
input: "6"
output: "11"
name: ""
type: "FC"
}
device_option {
device_type: 0
device_id: 0
}
external_input: "input.1"
external_input: "1"
external_input: "2"
external_input: "3"
external_input: "4"
external_input: "5"
external_input: "6"
external_output: "11"INFO:ml.rl.preprocessing.preprocessor_net:Processed split (0, 4) for feature type CONTINUOUS
INFO:ml.rl.preprocessing.preprocessor_net:input# 0: preprocessor_net.py:287:Where_output0*
5.评估模型
模型是训练出来的，但是我们怎么测试呢？这可以通过附带的 cartpole 实验评估脚本来完成:
*python ml/rl/test/workflow/eval_cartpole.py -m outputs/predictor_<number>.c2def main(model_path):
predictor = DQNPredictor.load(model_path, "minidb", int_features=False) env = OpenAIGymEnvironment(gymenv=ENV) avg_rewards, avg_discounted_rewards = env.run_ep_n_times(
AVG_OVER_NUM_EPS, predictor, test=True
) logger.info(
"Achieved an average reward score of {} over {} evaluations.".format(
avg_rewards, AVG_OVER_NUM_EPS
)
) def parse_args(args):
if len(args) != 3:
raise Exception("Usage: python <file.py> -m <parameters_file>") parser = argparse.ArgumentParser(description="Read command line parameters.")
parser.add_argument("-m", "--model", help="Path to Caffe2 model.")
args = parser.parse_args(args[1:])
return args.model*
这将使用给定的模型运行我们的健身房环境，并以对数线的形式返回 x 评估的奖励分数。
这方面的一个例子是:
*INFO:__main__:Achieved an average reward score of 9.34 over 100 evaluations.*
6.通过 Tensorboard 可视化
现在，最后一步是通过 Tensorboard 可视化一切，我们可以这样开始:
*tensorboard --logdir outputs/*
这将产生一个绑定到 https://localhost:6006 的进程。
渲染我们训练过的模型
一旦我们训练了我们的模型，我们就能够通过 Tensorboard 可视化它。然而，我们也希望能够在评估模型的同时查看模型的运行情况。为了能够从这开始，首先安装先决条件+依赖项，如下所示:如何在 Windows 上用 Javascript 运行 open ai Gym。
我们现在要做的另一件事是更改eval_cartpole.py文件，并在run_ep_n_times()方法中添加render=True，使其看起来像这样:
*avg_rewards, avg_discounted_rewards = env.run_ep_n_times(
AVG_OVER_NUM_EPS, predictor, test=True, render=True
)*
当我们现在通过以下方式重新推出评估工具时:
*python ml/rl/test/workflow/eval_cartpole.py -m outputs/predictor_<number>.c2*
我们将能够看到我们的流程产生:
faced:使用深度学习的 CPU 实时人脸检测
在没有 GPU 的情况下，有可能实现具有实时性能的对象检测模型吗？ faced是一个概念证明，可以为 CPU 上运行于实时 的单个类对象(在本例中为人脸)构建自定义对象检测模型。
有什么问题？
在许多情况下，需要进行单个类对象检测。这意味着我们想要检测图像中属于特定类别的所有对象的位置。例如，我们可以为人脸识别系统检测人脸，或者为行人跟踪检测人。
此外，大多数时候我们希望实时运行这些模型**。**为了实现这一点，我们有一个以速率 x 提供样本的图像馈送，我们需要一个模型以小于速率 x 运行每个样本。然后，一旦图像可用，我们就可以对其进行处理。
如今，解决这一任务(以及计算机视觉中的许多其他任务)最容易获得和使用的解决方案是对先前训练的模型执行(在大型数据集上训练的一般标准模型，如在 Tensorflow Hub 或 TF 对象检测 API 中找到的数据集)
有许多经过训练的对象检测架构(例如 FasterRCNN、SSD 或 YOLO)在运行于 GPU 上的实时性能内实现了令人印象深刻的准确性。
Extracted from SSD paper here
GPU 很贵，但在训练阶段是必须的。然而，据推断用专用 GPU 来实现实时性能是不可行的。如果没有 GPU，所有通用对象检测模型(如上所述)都无法实时运行。
那么，如何重新审视单类对象的对象检测问题，以达到实时性能但在 CPU 上？
主要观点:简单的任务需要较少的可学习的特征
上面提到的所有架构都是为检测多个对象类而设计的(在 COCO 或 PASCAL VOC 数据集上训练)。为了能够将每个边界框分类到其适当的类别，这些架构需要大量的特征提取。这意味着大量的可学习参数，大量的过滤器，大量的层。换句话说，这个网络很大。
如果我们定义更简单的任务(而不是多类包围盒分类)，那么我们可以认为网络需要学习更少的特征来执行任务。检测图像中的人脸显然比检测汽车、人、交通标志和狗(都在同一模型内)更简单。深度学习模型为了识别人脸(或任何单个类对象)所需的特征量将少于同时检测几十个类所需的特征量。执行第一项任务所需的信息少于后一项任务。
单一类别对象检测模型将需要较少的可学习特征。参数越少意味着网络会越小。较小的网络运行速度更快，因为它需要更少的计算。
那么，问题是:在保持准确性的情况下，我们可以在 CPU 上实现多小的实时性能？
这是faced的主要概念:建立尽可能小的网络，在保持准确性的同时(希望)在 CPU 中实时运行。
建筑
faced是两个神经网络的集合，都是使用 Tensorflow 实现的。
主网络
faced主建筑大量基于 YOLO 的建筑。基本上，它是一个完全卷积的网络(FCN ),通过一系列卷积层和池层(不涉及其他层类型)运行 288x288 输入图像。
卷积层负责提取空间感知特征。汇集层增加了后续卷积层的感受域。
该架构的输出是一个 9x9 的网格(相对于 YOLO 的 13x13 网格)。每个网格单元负责预测该单元内是否有人脸(相对于 YOLO，每个单元可以检测多达 5 个不同的对象)。
每个网格单元有 5 个关联值。第一个是包含面部中心的单元的概率 p 。另外 4 个值是被检测人脸的( x_center，y_center，width，height) (相对于单元格)。
Main architecture
确切的架构定义如下:
- 2x[288 x288 图像上的 8 个过滤卷积层]
- 最大池(288x288 到 144x144 功能图)
- 2x[144 x144 特征图上的 16 个过滤卷积层]
- 最大池(144x144 到 72x72 功能图)
- 2x[72x 72 特征图上的 32 个过滤卷积层]
- 最大池(72x72 到 36x36 功能图)
- 2x[36x 36 特征图上的 64 个过滤卷积层]
- 最大池(36x36 到 18x18 功能图)
- 2x[18x 18 特征图上的 128 过滤卷积层]
- 最大池(18x18 到 9x9 功能图)
- 4x[9x 9 特征图上的 192 滤波卷积层]
- 5 在 9x9 特征图上过滤卷积层，以形成最终网格
所有激活功能都是leaky_relu。
faced has6993517 个参数。YOLOv2 有 51，000，657 个参数。它的大小是 YOLO 大小的 13%!
辅助网络
( x_center，y_center，width，height) 主网络的输出不如预期的准确。因此，实现了一个小的 CNN 网络，将包含人脸的小图像(用主架构输出裁剪)作为输入，并输出人脸的地面真实边界框的回归。
The network takes a crop containing a face and predicts the correct bounding box
它唯一的任务是补充和改进主架构的输出坐标。
该网络的具体架构无关紧要。
资料组
两个网络都是在宽脸数据集上训练的。
WIDER FACE multiple scenarios
“更宽的人脸数据集是人脸检测基准数据集[…]。我们选择了 32，203 张图像，并标记了 393，703 张在比例、姿态和遮挡方面具有高度可变性的人脸，如样本图像中所描绘的那样。”
培养
训练是在 Nvidia Titan XP GPU 上进行的。培训时间大约花了 20 个小时。使用批量标准化技术来帮助收敛，并使用漏失(40%比率)作为正则化方法来避免过拟合。
推理和非最大抑制
当使用faced进行推理时，首先将图像尺寸调整为 288x288，以便输入网络。该图像位于 FCN 下方，给出了上面描述的 9x9 网格输出。
每个单元格有一个包含图像的概率 p 。通过可配置的阈值过滤单元格(即仅保留具有 p > t 的单元格)。对于那些保留的单元格，使用单元格的( x_center，y_center，width，height)定位人脸。
在某些情况下，多个细胞可以竞争同一张脸。让我们假设一个面部中心位于 4 个细胞相交的精确位置。这 4 个单元可能具有高的 p (在单元内包含面中心的概率)。如果我们保留所有的单元并投影每个单元的面坐标，那么我们将会看到相同的面周围有 4 个相似的边界框。这个问题是通过一种叫做 非最大抑制 的技术解决的。结果如下图所示:
Non max suppression example.
表演
faced在推论上能够达到以下速度:
考虑到 YOLOv2 在 i5 2015 MBP 上甚至不能达到 1FPS，这已经很不错了。
结果
来看看成果吧！
**
faced on images
现在我们来看一下faced和 Haar Cascades 的对比，Haar Cascades 是一种不使用深度学习的计算机视觉传统方法。这两种方法在相似的速度性能下运行。faced显示出显著的更高的准确性。
**
Haar Cascade [left] vs faced [right]
如何使用 faced？
faced是一个非常简单的程序，既可以嵌入 Python 代码，也可以作为命令行程序使用。
请访问 github repo 获取更多说明:
🚀 😏使用深度学习的近实时 CPU 人脸检测- iitzco/faced
github.com](https://github.com/iitzco/faced)
*喜欢这个项目？*在项目的回购上留下⭐！
结论
faced是一个概念证明，在这些模型对您的问题来说是多余的并且涉及到性能问题的场景中，您不需要总是依赖通用训练模型。不要高估花时间设计专门针对你的问题的定制神经网络架构的能力。这些特定的网络将是比一般网络更好的解决方案。*
使用人工智能的面部情感检测:用例
不同的公司已经广泛使用情绪分析来衡量消费者在数字世界中对其产品或品牌的情绪。然而，在离线世界中，用户也与零售店、陈列室等中的品牌和产品进行交互。并且在这种设置下自动测量用户反应的解决方案仍然是一项具有挑战性的任务。使用人工智能从面部表情进行情感检测可以成为自动测量消费者对其内容和品牌的参与度的可行替代方法。
在 ParallelDots ，我们结合了心理学、人类表情和人工智能科学，自动识别每个人脸上的不同情绪。我们的面部情绪检测算法可以实时识别七种不同类型的情绪状态。
在本帖中，我们将讨论如何使用这样的技术来有效地解决各种现实世界的用例。
1.让汽车更加安全和个性化
世界各地的汽车制造商越来越注重让汽车更加个性化，让我们驾驶起来更加安全。在追求构建更多智能汽车功能的过程中，制造商使用人工智能来帮助他们理解人类情感是有意义的。使用面部情绪检测的智能汽车可以在司机昏昏欲睡时提醒他。
美国交通部声称，大约 95%的致命交通事故都是由驾驶失误造成的。面部情绪检测可以发现困倦之前面部微表情的微妙变化，并向司机发送个性化警报，要求他停下来喝杯咖啡，改变音乐或温度。
2.面试中的面部情绪检测
候选人和面试官的互动容易受到多种判断和主观性的影响。这种主观性使得很难确定候选人的个性是否适合这份工作。识别候选人想说什么是我们力所不及的，因为有多层的语言解释、认知偏差和介于其间的语境。这就是人工智能的用武之地，它可以测量候选人的面部表情，以捕捉他们的情绪，并进一步评估他们的性格特征。
值得注意的是，联合利华已经开始将这项技术纳入他们的招聘流程。有了这项技术，招聘人员将能够知道，比如说，被面试者的总体信心水平，并决定这个候选人是否能够在面对客户的工作中表现出色。同样，通过测量候选人在回答过程中的情绪变化，并将其与该领域的大量可用知识相关联，可以发现候选人是否诚实地回答了所有问题。
员工的士气也可以通过这项技术在工作中保持和记录互动来感知。作为一种人力资源工具，它不仅可以帮助设计招聘策略，还可以帮助设计人力资源政策，使员工发挥最佳绩效。
3.视频游戏测试
电子游戏是针对特定的目标受众而设计的。每个视频游戏都旨在唤起用户的特定行为和情绪。在测试阶段，用户被要求在给定的时间内玩游戏，他们的反馈被整合到最终产品中。使用面部情绪检测可以帮助了解用户在玩游戏时的实时情绪，而无需手动分析整个视频。
这种产品反馈可以通过分析用户的实时反馈并检测他的面部情绪来获得。虽然沮丧和愤怒的感觉在高级视频游戏中很常见，但利用面部情绪检测将有助于了解在游戏中的什么时候体验了哪些情绪。也有可能是在游戏过程中观察到了一些意想不到的或者不良的情绪。从体验过游戏的用户那里获取反馈可能是低效的。这是因为通常很难用语言来表达一段经历。此外，用户可能不记得他们在游戏的不同部分到底经历了什么。面部情绪检测是一种超越口头或书面反馈并欣赏用户体验的实用方法。当反馈以这种形式出现时，就用户体验而言，它变得真正无干扰。同时，这样的反馈比其他形式更可靠。
4.市场调查
传统上，市场研究公司采用口头方法，如调查，来发现消费者的需求。然而，这种方法假设消费者可以口头表达他们的偏好，并且所陈述的偏好对应于可能不总是正确的未来行为。
市场研究行业的另一种流行方法是采用行为方法，在与品牌或产品互动时观察用户的反应。这种方法被认为比口头方法更客观。行为方法使用用户与产品互动的视频，然后人工分析这些视频，观察用户的反应和情绪。然而，随着样本量的增加，这种技术会很快变得非常耗费人力。面部情绪识别可以通过允许市场研究公司自动测量每时每刻的面部表情(面部编码)并汇总结果来拯救人类。
用技术检测情绪是一项具有挑战性的任务，但机器学习算法已经显示出巨大的前景。使用 ParallelDots 的面部情绪检测 API，客户可以实时处理图像和视频，以监控视频馈送或自动进行视频分析，从而节省成本并改善用户的生活。这种 API 的定价基于一种现收现付的模式，允许您在扩大规模之前测试该技术。
面部情绪检测只是视觉智能自动分析视频和图像的一部分。点击此处查看图片中的面部表情。
点击此处了解更多关于病毒检测 API 的不同使用案例，可用于增强图像质量。
我们希望你喜欢这篇文章。请注册一个免费的 ParallelDots 账户，开始你的 AI 之旅。你也可以在这里查看 parallel dots API的演示。
此处阅读原文。
教程:使用深度学习和 OpenCV(面部标志检测)的自拍滤镜
这是一个关于如何构建一个 python 应用程序的教程，该应用程序可以通过找到面部关键点(15 个独特的点)在检测到的脸上放置各种太阳镜(我称它们为“自拍过滤器”)。这些关键点标记了面部的重要区域——眼睛、嘴角、鼻子等。
项目描述
OpenCV 经常在实践中与其他机器学习和深度学习库一起使用，以产生有趣的结果。在 Keras 中使用卷积神经网络(CNN)和 OpenCV——我建立了几个自拍过滤器(非常无聊的)。
面部关键点可用于各种机器学习应用，从面部和情感识别到商业应用，如 Snapchat 推广的图像过滤器。
您可以在此访问完整的项目代码:
[## acl21/Selfie_Filters_OpenCV
更新]:我将不再关注与回购相关的问题或邮件，因为我目前非常忙…
github.com](https://github.com/acl21/Selfie_Filters_OpenCV)
工作示例
代码要求
代码在 Python 版本中，使用 OpenCV 和 Keras 库。
跟随这篇中帖在 Python 3 中安装 OpenCV 和 Keras。
数据描述
Kaggle 上的这个数据集允许我们训练一个模型，在给定一张有脸的图像的情况下检测面部关键点。
它是由蒙特利尔大学的 Yoshua Bengio 博士提供的。
数据集中的每个数据点包含按顺序的图像的空间分隔的像素值，并且数据点的最后 30 个值表示面上关键点的 15 对坐标。
所以我们只需要训练一个 CNN 模型来解决一个经典的深度学习回归问题。点击查看回归问题的损失函数列表。
代码解释
步骤 1:训练卷积神经网络模型
1.1 定义模型
为了方便起见，我们首先在一个单独的 python 文件中定义模型架构—my _ CNN _ model . py
我们编写一个创建网络架构的方法。
1.2 编译、保存、适配和加载
我们现在编写方法来编译、保存、拟合和加载模型
1.3 模型构建器(包装器)
我们现在编写一个模型构建器，它加载数据并调用上述方法。
第二步:初始化东西
我们现在创建一个新的 python 文件— shades.py ，我们在其中编写代码来读取网络摄像头输入，检测人脸，使用我们构建的 CNN 模型，等等。
步骤 3:检测输入中的人脸
一旦您开始从网络摄像头读取输入，使用我们之前初始化的级联分类器对象检测输入中的人脸。
步骤 4:创建过滤器开关触发器
在这里，我使用了一个蓝色的瓶盖作为过滤器开关。为了检测蓝帽，我们编写代码来寻找图像中的蓝色轮廓。我们传递我们在步骤 2 中定义的 blueLower 和blue upperHSV 范围。
一旦我们创建了 blueMask ，即应该在视频中找到蓝色的东西，我们使用 OpenCV 的***cv2 . find contours()***方法来找到轮廓。
上面的代码检查框架中是否有轮廓(蓝色瓶盖),一旦发现，它检查轮廓的中心是否接触到我们在这一步中创建的“下一个过滤器”按钮。如果被触摸，我们更改过滤器(将 过滤器索引 增加 1)
步骤 5:使用模型检测面部关键点
我们使用之前初始化的面部层叠来定位帧中的面部。然后，我们对每一张脸进行循环，以预测面部关键点。
在我们将检测到的人脸传递给模型之前，我们有必要对输入进行归一化，因为归一化的图像是我们的模型所训练的图像，将其大小调整为 96 x 96 图像，因为这是我们的模型所期望的。上面的代码也是如此。
第六步:使用面部关键点在脸上添加阴影
一旦我们检测到面部关键点，我们就可以用它们来做各种很酷的事情。例如，您可以使用鼻子关键点来添加小胡子，嘴唇关键点来添加颜色，等等。
这里，我们使用了 4 个关键点来配置脸部阴影的宽度和高度。并且，face _ resized _ color有阴影并贴图回 帧 和face _ resized _ color 2有关键点并贴图回 帧 2 。然后我们把它们都展示出来。
最后，我们只是清理东西。
您可以在此访问完整的项目代码:
[## acl21/Selfie_Filters_OpenCV
更新]:我将不再关注与回购相关的问题或邮件，因为我目前非常忙…
github.com](https://github.com/acl21/Selfie_Filters_OpenCV)
执行
1。下载数据
从这里下载数据，并把它放在项目目录中名为‘data’的文件夹中。确保“数据”文件夹包含— training.csv 和 test.csv
2。建立 CNN 模型
> python model_builder.py
这将调用my _ CNN _ model . py，因此请确保您的项目目录中有该文件。
4。运行引擎文件
> python shades.py
5。抓起一个蓝色瓶盖
玩得开心点。
结论
在本教程中，我们建立了一个深度卷积神经网络模型，对面部关键点数据进行训练。然后，我们使用该模型来预测在输入网络摄像头数据中检测到的面部的面部关键点。我们还使用轮廓创建了一个开关，它允许我们通过手势迭代其他过滤器。我鼓励您调整模型架构，亲自看看它是如何影响关键点检测的。
这个数据只有 15 个关键点，还有其他几个数据集在面部标注了超过 30 个关键点。
Awesome right?
- 面部特征检测改善了面部识别
- 男性/女性区别
- 面部表情区分
- 头部姿态估计
- 面部变形
- 虚拟改造
- 面部置换
希望这个教程是有趣的。谢谢你阅读它。
活也让别人活！
答
使用 Dlib + python 绘制面部地图(地标)
在照片或视频中识别人脸非常酷，但这不足以创建强大的应用程序，我们需要更多关于人脸的信息，如位置，嘴是张开还是闭合，眼睛是睁开还是闭合，抬头等等。在这篇文章中，我将(以一种快速而客观的方式)向你展示 Dlib，一个能够给你 68 分(landkmarks)的人脸库。
什么是 Dlib？
这是一个具有预训练模型的地标面部检测器，dlib 用于估计 68 个坐标(x，y)的位置，这些坐标映射了一个人脸上的面部点，如下图所示。
这些点是从使用了 iBUG300-W 数据集的预训练模型中确定的。
给我看看代码！
在这个“Hello World”中，我们将使用:
- numpy
- opencv
- 伊穆蒂尔斯
在本教程中，我将用 dlib 编写一个简单的例子。我们正在识别和绘制图像上的人脸点，在以后的文章中，我会详细介绍这个漂亮的库的使用。
正在安装依赖项。
pip install numpy opencv-python dlib imutils
从我们将要处理的图像捕获开始，我们将使用 OpenCV 在一个“无限”循环中捕获图像的网络摄像头，从而给人一种观看视频的感觉。
运行您的脚本，并确保您的网络摄像头的图像被捕获(它会为您打开一个窗口，显示网络摄像头的图像)。
拿到照片后，让我们来创造奇迹吧。
**提醒:**我们正在使用已经训练好的模型，我们将需要下载文件 shape _ predictor _ 68 _ face _ landmarks . dat，你可以在这里找到它。
之后，只需运行脚本，您就可以在 Dlib 中运行“hello_world ”,在以后的文章中，我将详细介绍如何提取图像中人脸的更多信息。
所有代码都在我的 github 上。
TKS。
面部识别和对抗性攻击
面部识别系统已经成为主流技术。最近，苹果和三星都推出了具有面部识别功能的手机。上周，美国运输安全管理局启动了一项名为的试点项目，允许美国公民基于面部识别作为主要验证系统快速通过机场。中国在使用面部识别进行身份认证方面处于世界领先地位。《经济学家》杂志估计，数百万中国人已经在智能手机上刷脸授权支付。随着使用面部识别进行身份验证的想法变得越来越流行，攻击这种系统的想法也越来越流行。
由于深度神经网络(DNNs)的使用，今天的面部识别系统非常接近人类的表现。DNN 的一个弱点是对抗性攻击。
什么是对抗性攻击？
对抗性攻击试图误导网络来预测错误的类别。开创性的论文(赛格迪等。艾尔。2014 arXiv:1312.6199v4)展示了人眼察觉不到的看似微小的扰动如何扰乱神经网络的例子。
All Images to the right are classified as Ostrich. (IC: https://arxiv.org/pdf/1312.6199.pdf))
在上述示例中，DNN 能够成功识别左侧面板图像中的物体。然而，如果引入了精心选择的扰动(中图)，则新图像(右图)被错误分类。扰动非常小，以至于左面板和右面板用肉眼看起来完全一样。
如果一个人试图用别人的护照进入一个国家，他只需要稍微改变一下他的面部特征，DNN 的面部识别系统就会让他通过。
为什么世界级的 dnn 那么容易被忽悠？
首先让我确认以上结果不是来自低精度的低容量神经网络。即使是最复杂的模型也容易受到这种攻击。这里引用的论文使用了 2014 年的 GoogLeNet，从那时起，这些测试在其他 dnn 上重复进行。
如果模型和他们得到的一样好，那么深度学习模型更容易受到这种攻击吗？RBF 网络等一些模型不太容易受到对抗性攻击 (Goodfellow et al 2016，arXiv:1412.6572)。但是 RBF 网络的召回率要低得多。RBF 网络为了更高的精度牺牲了大量的召回率。在 DNS 的情况下，对抗性的例子是足够普遍的。伊恩·古德费勒(Goodfellow et al 2016，arXiv:1412.6572)已经向展示了对于大多数 dnn 来说，找到对立的例子是可能的。这意味着，即使有一个训练有素的系统，一个坚定的黑客总是可以找到敌对的例子来欺骗面部识别系统。并且对立的例子对于人眼来说是绝对无法察觉的，这使得冒充的威胁变得非常真实。
我们如何产生一个对立的例子？
在面部识别的背景下，我们希望我们的对立示例能够成功建立两项任务——
- 躲闪——主体避免被面部识别系统识别。
- 模仿——受术者模仿他人。
在这两个任务中，转换应该是可行的，例如，化浓妆或戴面具是行不通的，因为这种转换在真实情况下会引起注意。
马哈茂德·谢里夫等人。艾尔。(谢里夫等人。al 2015) ( 论文)使用了一种优化方法来进行躲闪和模仿。为了躲避，他们优化
其中“r”是应用于图像的扰动。使用这种技术，他们能够成功地避开预先训练的 DNN。
Small Imperceptible Changes Lead to successful Dodging (IC: https://www.cs.cmu.edu/~sbhagava/papers/face-rec-ccs16.pdf))
在上面的例子中，左边的图像被正确分类，但是中间的图像没有。如右图所示，这两幅图像仅有小的扰动。
使用类似的技术，作者展示了一个非常可信的模仿。DNN 非常自信地成功认出了瑞茜·威瑟斯彭和拉塞尔·克罗。但同一网络将戴眼镜的里斯(中间部分)归类为拉塞尔。
Reese Witherspoon (left) wearing glasses (middle) impersonating Russel Crowe (Right) (IC: https://www.cs.cmu.edu/~sbhagava/papers/face-rec-ccs16.pdf))
我们如何防止这种攻击？
在这一点上，让我提醒一下，这些想法中有许多还不够实际。当 DNN 权重已知时，最好的对抗生成器工作。然而，对于我们只能访问响应的黑盒人脸识别系统，这样的攻击并不奏效。然而，识别系统和攻击每天都在变得更好。
生成对抗网络(GANs)可以通过使 DNNs 对对抗示例更健壮来很好地防御对抗攻击。虽然关于这个主题的研究还远未完成，但似乎创建高容量网络 ( Madry 等人 2017，arXiv:1706.06083)并使用 GAN 生成的示例进行训练，可以帮助创建对敌对图像鲁棒的面部识别系统。另一种方法是使用一种完全不同的网络，称为胶囊网络，Geoffrey Hinton 在题为“卷积神经网络有什么问题？”(YouTube 链接——https://www.youtube.com/watch?v=rTawFwUvnLE)
在过去的几年里，我们在 DNN 和面部识别系统领域取得了长足的进步。现在，随着面部识别成为主流，我们将看到从身份验证到监控的众多应用。新的想法可能伴随着未知的挑战。诸如躲避和冒充之类的攻击将会越来越频繁和复杂。但是，我确信我们将通过人类的聪明才智和一点技术来克服这些挑战。
原载于 2017 年 11 月 16 日e4c5blog.wordpress.com。
使用深度学习的面部识别
卷积神经网络允许我们从图像中提取广泛的特征。事实证明，我们也可以将这种特征提取的想法用于人脸识别！这就是我们在本教程中要探索的，使用深度 conv 网进行人脸识别。注:这是人脸 识别 (即实际告知是谁的脸) 不是 只是检测(即识别一张图片中的人脸)。
如果你不知道什么是深度学习(或者什么是神经网络)，请阅读我的帖子初学者的深度学习。如果你想尝试一个使用卷积神经网络进行图像分类的基础教程，你可以尝试这个教程。请记住，本教程假设您有基本的编程经验(最好是 Python)，并且您了解深度学习和神经网络的基本思想。
我们将要使用的人脸识别方法相当简单。这里的关键是让一个深度神经网络产生一串描述一张脸的数字(称为人脸编码)。当您传入同一个人的两个不同图像时，网络应该为这两个图像返回相似的输出(即更接近的数字)，而当您传入两个不同人的图像时，网络应该为这两个图像返回非常不同的输出。这意味着需要训练神经网络来自动识别面部的不同特征，并基于此计算数字。神经网络的输出可以被认为是特定人脸的标识符——如果你传入同一个人的不同图像，神经网络的输出将非常相似/接近，而如果你传入不同人的图像，输出将非常不同。
谢天谢地，我们不必经历训练或建立自己的神经网络的麻烦。我们可以通过我们可以使用的 dlib 访问一个经过训练的模型。它确实做了我们需要它做的事情——当我们传入某人的面部图像时，它输出一串数字(面部编码);比较来自不同图像的人脸编码将告诉我们某人的脸是否与我们有图像的任何人相匹配。以下是我们将采取的步骤:
- 检测/识别图像中的人脸(使用人脸检测模型)——为了简单起见，本教程将只使用包含一个人脸/人的图像，而不是更多/更少
- 预测面部姿态/ 界标(针对步骤 1 中识别的面部)
- 使用来自步骤 2 的数据和实际图像，计算面部编码(描述面部的数字)
- 比较已知人脸的人脸编码和测试图像中的人脸编码，判断照片中的人是谁
希望你对这将如何工作有一个基本的概念(当然上面的描述是非常简化的)。现在是时候开始建设了！
准备图像
首先，创建一个项目文件夹(只是一个保存代码和图片的文件夹)。对我来说它叫做face_recognition，但是你可以随便叫它什么。在该文件夹中，创建另一个名为images的文件夹。这是一个文件夹，将保存您要对其运行人脸识别的不同人的图像。从脸书下载一些你朋友的图片(每人一张)，将图片重新命名为你朋友的名字(如taus.jpg或john.jpg，并将它们全部保存在你刚刚创建的这个images文件夹中。需要记住的一件重要事情是:请确保所有这些图像中只有一张脸(即它们不能是组图)，并且它们都是 JPEG 格式，文件名以.jpg结尾。
接下来，在您的项目文件夹中创建另一个文件夹(对我来说是face_recognition文件夹)，并将其命名为test。该文件夹将包含您在images文件夹中存储的同一个人的不同的图像。再次，确保每张照片只有一个人在里面。在test文件夹中，您可以随意命名图像文件，并且您可以拥有每个人的多张照片(因为我们将对test文件夹中的所有照片运行人脸识别)。
安装依赖项
这个项目最重要的依赖项是 Python 2.7 和 pip。您可以使用 Anaconda 2(这只是一个预打包了 pip 的 Python 发行版)通过点击链接来安装这两个版本(如果您还没有安装的话)。注意:请 确保Anaconda 2被 添加到您的PATH中，并注册为您的系统 Python 2.7(安装过程中会有提示；只需按“是”或勾选复选框)。
如果您已经完成了 Anaconda 2 的设置，或者您已经预先在机器上安装了 Python 2.7 和 pip，那么您可以继续安装 dlib (我们将使用的机器学习库)和其他依赖项。为此，请在终端(Mac OS 或 Linux)或命令提示符(Windows)中键入以下命令:
pip install --user numpy scipy dlib
如果您是 Mac 或 Linux 用户，并且在使用上述命令时遇到问题，请尝试以下命令:
sudo pip install --user numpy scipy dlib
如果上述过程对您不起作用，您可能需要手动下载、编译和安装 dlib 及其 Python API。为此，你必须读一些关于 http://dlib.net/的书。不幸的是，这超出了这篇博文的范围，因此我不会在这里讨论。
你需要做的最后一件事是下载预先训练好的人脸识别模型。你需要两种型号。一个模型预测一张脸的形状/姿势(基本上给你形状在图像中如何定位的数字)。另一个模型，获取人脸并给你人脸编码(基本上是描述那个特定人的脸的数字)。以下是关于如何下载、提取和准备它们的说明:
- 从这个链接下载
dlib_face_recognition_resnet_model_v1.dat.bz2，从这个链接下载shape_predictor_68_face_landmarks.dat.bz2 - 一旦下载了这两个文件，就需要解压它们(它们以 bz2 格式压缩)。在 Windows 上，您可以使用 Easy 7-zip 来完成此操作。在 Mac 或 Linux 上，您应该能够双击文件并提取它们。如果这不起作用，只需在您的终端中输入这两个文件:
bzip2 **{PATH_TO_FILE}** --decompress(用您试图提取的文件的实际路径替换{PATH_TO_FILE}；对我来说，命令应该是bzip2 ~/Downloads/dlib_face_recognition_resnet_model_v1.dat.bz2 --decompress和bzip2 ~/Downloads/shape_predictor_68_face_landmarks.dat.bz2 --decompress。 - 一旦你提取它们，你应该有两个名为
dlib_face_recognition_resnet_model_v1.dat和shape_predictor_68_face_landmarks.dat的文件。将这两个文件复制到您的项目文件夹中(对我来说，这是我为这个项目创建的face_recognition文件夹)。
代码！
现在，你已经设置好了一切，在一个文本编辑器(最好是 Atom 或 Sublime Text )中打开你的项目文件夹(我称之为face_recognition)。在名为recognize.py的文件夹中创建一个新文件。这是我们将添加代码来匹配你的朋友的脸。注意，这个过程有两个主要部分:首先，在images文件夹中加载已知人脸的人脸编码；完成后，从存储在test文件夹中的人脸/图像中获取人脸编码，并将它们与我们所有已知的人脸一一匹配。我们将逐步完成这一部分。如果您想看到它运行，您可以将该部分中的所有代码一个接一个地复制粘贴到您的文件中(即，按照下面列出的相同顺序合并所有单独的代码部分)。仔细阅读每个代码块中的注释，了解它的作用。
第 1 部分:初始化和设置— 在这里，我们导入所需的库，并设置人脸识别所需的对象/参数。
import dlib
import scipy.misc
import numpy as np
import os# Get Face Detector from dlib
# This allows us to detect faces in images
face_detector = dlib.get_frontal_face_detector()# Get Pose Predictor from dlib
# This allows us to detect landmark points in faces and understand the pose/angle of the face
shape_predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')# Get the face recognition model
# This is what gives us the face encodings (numbers that identify the face of a particular person)
face_recognition_model = dlib.face_recognition_model_v1('dlib_face_recognition_resnet_model_v1.dat')# This is the tolerance for face comparisons
# The lower the number - the stricter the comparison
# To avoid false matches, use lower value
# To avoid false negatives (i.e. faces of the same person doesn't match), use higher value
# 0.5-0.6 works well
TOLERANCE = 0.6
第 2 部分:从图像中获取人脸编码— 这里我们编写一个函数，它将获取一个图像文件名，并为我们提供该图像的人脸编码。
# This function will take an image and return its face encodings using the neural network
def get_face_encodings(path_to_image):
# Load image using scipy
image = scipy.misc.imread(path_to_image) # Detect faces using the face detector
detected_faces = face_detector(image, 1) # Get pose/landmarks of those faces
# Will be used as an input to the function that computes face encodings
# This allows the neural network to be able to produce similar numbers for faces of the same people, regardless of camera angle and/or face positioning in the image
shapes_faces = [shape_predictor(image, face) for face in detected_faces] # For every face detected, compute the face encodings
return [np.array(face_recognition_model.compute_face_descriptor(image, face_pose, 1)) for face_pose in shapes_faces]
第 3a 部分:比较人脸— 我们在这里编写一个函数，它将给定的人脸编码与一系列已知的人脸编码进行比较。它将返回一个布尔值(真/假)数组，指示是否存在匹配。
# This function takes a list of known faces
def compare_face_encodings(known_faces, face):
# Finds the difference between each known face and the given face (that we are comparing)
# Calculate norm for the differences with each known face
# Return an array with True/Face values based on whether or not a known face matched with the given face
# A match occurs when the (norm) difference between a known face and the given face is less than or equal to the TOLERANCE value
return (np.linalg.norm(known_faces - face, axis=1) <= TOLERANCE)
第 3b 部分:查找匹配— 这里我们编写了一个函数，它将接受一个已知人脸编码列表、一个人名列表(对应于已知人脸编码列表)和一个要查找匹配的人脸。它将调用 3a 中的函数，并返回与给定人脸匹配的人的姓名。
# This function returns the name of the person whose image matches with the given face (or 'Not Found')
# known_faces is a list of face encodings
# names is a list of the names of people (in the same order as the face encodings - to match the name with an encoding)
# face is the face we are looking for
def find_match(known_faces, names, face):
# Call compare_face_encodings to get a list of True/False values indicating whether or not there's a match
matches = compare_face_encodings(known_faces, face) # Return the name of the first match
count = 0
for match in matches:
if match:
return names[count]
count += 1 # Return not found if no match found
return 'Not Found'
至此，我们拥有了运行程序所需的函数。是时候编写应用程序的最后一部分了(我将把它分成两个独立的部分)。
第 4a 部分:获取 images 文件夹中所有人脸的人脸编码
# Get path to all the known images
# Filtering on .jpg extension - so this will only work with JPEG images ending with .jpg
image_filenames = filter(lambda x: x.endswith('.jpg'), os.listdir('images/'))# Sort in alphabetical order
image_filenames = sorted(image_filenames)# Get full paths to images
paths_to_images = ['images/' + x for x in image_filenames]# List of face encodings we have
face_encodings = []# Loop over images to get the encoding one by one
for path_to_image in paths_to_images:
# Get face encodings from the image
face_encodings_in_image = get_face_encodings(path_to_image) # Make sure there's exactly one face in the image
if len(face_encodings_in_image) != 1:
print("Please change image: " + path_to_image + " - it has " + str(len(face_encodings_in_image)) + " faces; it can only have one")
exit() # Append the face encoding found in that image to the list of face encodings we have
face_encodings.append(get_face_encodings(path_to_image)[0])
部分 4b:将 test 文件夹中的每张图像与已知人脸进行匹配(逐个)
# Get path to all the test images
# Filtering on .jpg extension - so this will only work with JPEG images ending with .jpg
test_filenames = filter(lambda x: x.endswith('.jpg'), os.listdir('test/'))# Get full paths to test images
paths_to_test_images = ['test/' + x for x in test_filenames]# Get list of names of people by eliminating the .JPG extension from image filenames
names = [x[:-4] for x in image_filenames]# Iterate over test images to find match one by one
for path_to_image in paths_to_test_images:
# Get face encodings from the test image
face_encodings_in_image = get_face_encodings(path_to_image) # Make sure there's exactly one face in the image
if len(face_encodings_in_image) != 1:
print("Please change image: " + path_to_image + " - it has " + str(len(face_encodings_in_image)) + " faces; it can only have one")
exit() # Find match for the face encoding found in this test image
match = find_match(face_encodings, names, face_encodings_in_image[0]) # Print the path of test image and the corresponding match
print(path_to_image, match)
就是这样！一旦你将第 1 部分到第 4b 部分的所有代码复制粘贴到recognize.py文件中(一个接一个——按照我写它们的顺序),你应该能够使用你的终端(Mac OS 或者 Linux)或者命令提示符(Windows)通过输入这些命令来运行它(用你的项目文件夹的完整路径替换**{PROJECT_FOLDER_PATH}**;对我来说是/Users/taus/face_recognition):
cd **{PROJECT_FOLDER_PATH}** python recognize.py
这将为您提供类似如下的输出:
('test/1.jpg', 'Shihab')
('test/2.jpg', 'Not Found')
('test/3.jpg', 'Taus')
('test/4.jpg', 'Mifrah')
('test/5.jpg', 'Mubin')
文件名旁边的名称显示与给定人脸匹配的人的姓名。请注意，这可能并不适用于所有图像。为了获得此代码的最佳性能，请尝试使用人脸清晰可见的图像。当然，还有其他方法可以使它准确(比如通过实际修改我们的代码来检查多个图像或者使用抖动，等等)。)但这只是为了让你对人脸识别的工作原理有一个基本的了解。
这篇文章的灵感来自于亚当·盖特基(Adam Geitgey)的博客文章(T3)和(T4)关于人脸识别的 Github 报告(T5)。此外，我们正在使用 dlib 网站上提供的一些预先训练好的模型——所以向他们致敬，让他们可以公开访问。我的主要目标是介绍和解释人脸识别的基本深度学习解决方案。当然，有更简单的方法来做同样的事情，但我认为我应该使用 dlib 来一部分一部分地(详细地)做这件事，这样你就能真正理解不同的运动部件。还有其他运行人脸识别的方法(非深度学习)，请随意研究它们。这种方法很酷的一点是，你可以用每个人/对象的一两张图像来运行它(假设该模型在实际区分两张脸方面做得很好)。
不管怎样，我希望你喜欢这篇文章。请随意发表评论。
基于事实的人工智能。知识图的改进
我的公司 Viev(2022 10 13:now Fact engine:www . Fact engine . ai)生产基于事实的建模软件 Boston(FBM)。我们认为，基于事实的建模将在下一波对话式用户界面(CUI)、语音用户界面(VUI)和人工智能(AI)中产生影响。
Cui 和 vui 在相对较短的时间内变得流行起来。苹果 Siri VUI 的推出预示着苹果、微软、谷歌和亚马逊之间在各自的计算机操作系统和智能扬声器中生产 VUI 的竞赛的开始，我提供的这类产品是自引入面向对象编程和关系数据库以来在信息产业中从未见过的[1]。竞争似乎很激烈，就实用性而言，vui 正迅速变得更加智能。这些技术被认为很快会在家用电器甚至汽车中变得普遍[2][3][15]。
在研究和应用方面，聊天机器人形式的 Cui 也处于快速增长的领域。脸书的 Messenger 应用程序和微软的 Skype 中的聊天机器人已经有了相当大的发展，据报道仅在 Messenger 平台上就有超过 100，000 个聊天机器人[16]。据报道，早期的消费者体验令人失望[16]。然而，似乎至少有一家企业报告其 chatbot 实施的月收入超过 100 万美元[16]，并且不断有关于其成功应用的报告即将发布[14]。我个人对聊天机器人的分析让我觉得缺失的元素是对对话语境的深刻理解和自然的对话流程。
所有 Cui/vui 的基本前提是，人们交谈和使用自然语言比用其他形式交流要容易得多。举例来说，我最近购买了一部基于 Android 的手机，现在很少通过连续按下虚拟按钮来打电话或发送短信，而是我只是对着手机说话，它就知道我想做什么。要给某人发短信，我只需简单地说，“好的，谷歌，给彼得发个短信”。谷歌助手用自然语言问我想说什么。我的语音信息被转换成文本。Google Assistant 问我是否愿意发送该消息。回答，“发送”，谷歌助手尽职尽责地发送短信。所有这些都不需要按我手机上的任何一个按钮。难以置信，除了因为这种技术现在如此之好，它是可信的。我觉得这项技术会一直存在下去。随着时间的推移，我觉得这项技术只会变得越来越好，甚至更容易使用，越来越成为那些接触到这项技术的人日常生活的一部分。
对于那些作为消费者非常熟悉该技术的人，尤其是开发该技术的人来说，这样的例子将很快变得不起眼。即使在今天，我仍然认为，因为这种技术是如此容易获得和令人满意，它不仅已经成为一种产品的区别特征，而且还是一种预期的技术。我相信消费者对 CUIs/VUIs 的需求将推动人工智能的快速采用，并且在很大程度上，已经做到了。
从计算机时代开始，人类就在思考用自然语言与机器对话的能力，甚至通过机器用自然语言对话的能力(即图灵测试)来判断机器的智能。最近一篇有趣的文章重申了这一观点，并旨在巩固’会话认知’作为人工智能的基准[5]。
图灵测试在人工智能领域如此普遍，以至于它催生了一年一度的罗布纳奖(Loebner Prize ),当评委们根本无法区分他们是在与机器对话还是与另一个人对话时，这项比赛就会结束。
如果我们认为人类提供了智能的最终基准，那么用这个基准来评判人工智能似乎是自然和公平的。
然而，当今 Cui 和 vui 的相对迅速崛起，只是表面上，并没有反映出为使这些技术可用而进行的长期研究和开发。从消费者的角度来看，这种技术相对较新，但从研究的角度来看，它是几十年研究的累积成果。
但这是我们感兴趣的研究的未来。技术领先在哪里？最佳技术将采用何种外形规格？这些是我将在这里提出的问题，并提供一个前进的方向。
如果我们接受所有 Cui 和 vui 代表某种形式的人工智能和不同程度的实际智能，那么我们可以将我们的讨论限制在谈论一般的人工智能。这一点，尤其是如果我们接受会话认知作为我们讨论中的价值基准的话。也就是说，我们不是在谈论关于计算机视觉或诸如此类的人工智能，而是那些管理与人对话的人工智能。
对人工智能的研究大体上有两个主流，一个是算法，另一个是基于我称之为直觉的。第一种是确定性的，在这种情况下，我们可以窥视人工智能的工作方式，并根据它的推理得出问题的答案；第二个问题的结构如此复杂，以至于我们可能永远不知道它是如何推导出解决方案的，只知道它确实(正确或错误地)[7][8]。
我在确定性人工智能中包括那些不仅包含某种描述的知识库，而且包含一组逻辑规则和算法的人工智能，这两者对于对人工智能的工作感兴趣的外部观察者来说是完全透明的。默认情况下，我包括所有那些对一阶逻辑(FOL)有算法感知的人工智能系统。这样的人工智能很少被媒体报道，如果有一个通用术语来代表它们，我也想不起来。
我在直觉人工智能中包括那些人工智能内部工作如此复杂的问题，以至于准确确定一个答案是如何得出的可能是耗时的，以至于更容易接受人工智能要么产生要么不产生想要的结果。这并不是说一个人不能在人工智能中分解一个事务的内部工作，而是说它会如此复杂以至于期望有人去尝试是不合理的。这些类型的人工智能确实有可识别的名称，如神经网络和那些结合了深度学习和机器学习的人工智能。为了简单起见，在这里我将它们都归入神经网络这个术语。
一个对这两种类型的人工智能漫不经心和因果关系的观察者很可能会说，神经网络的内部工作方式当然是众所周知的，否则它们是如何建立起来的。不过，更详细地说，这里我们只考虑令人生畏的复杂性，即分析一个适当复杂的基于神经网络的人工智能采取什么步骤来得出一个单一的答案。当然，有了无限的时间和资源，人们可以分析任何事情，然而，似乎我们只是根据神经网络的数据模型是否返回有利的结果来接受或拒绝神经网络。如果结果是有利的，我们可能不太倾向于分析为什么，每次迭代的问题解决。
例如，当谷歌发布一篇论文，宣布他们基于 AlphaZero 神经网络的人工智能在国际象棋的自动化游戏中取得“突破”时，世界级的玩家称这一结果是显著的[9]。其他人评论了“直觉”是如何与确定性游戏相抗衡的[10]。据我所知，没有人准确分析过 AlphaZero 的每一步棋是如何做出决定的。
在这方面，确定性人工智能和随机人工智能之间的区别是明显的。
对在线文献的粗略搜索很容易表明，目前在人工智能中解决确定性和随机系统的组合以产生更智能的整体方面有很多活动。
如果我们重新将我们的讨论集中在那些与人交谈的人工智能上，以及它们将如何模仿人类的话语能力，那么看看你自己的内心并思考人类需要多少能力来产生演讲和回答外部世界的问题是合理的，这是基于应用逻辑而不是依靠训练有素的思维路径。
例如，用合适的“嗨”来回应“你好”的问候可能在大脑的神经路径中根深蒂固，以至于很容易推断出这些功能是在神经网络人工智能中训练出来的。
更重要的是构建一个神经网络来思考“我今天需要一把伞吗？”、“外面下雨了”、“好的，是的，你今天需要一把伞”和扩展了这种能力，以提供需要遍历数十或数百个条件谓词才能得到合适结果的问题的答案。
这并不是说神经网络不能处理需要某种形式的谓词逻辑的问题，而是说无论人工智能如何处理自然语言的分析，如果人工智能在对话中具有适当的智能，它将需要与数据相关联的丰富语义信息的数据，包括合并了谓词逻辑的某种表达的数据。
一切都与数据有关
我最近在一篇关于艾的文章中强调了一句话，内容是:
人工智能方法大致有三个部分:产生数据、解释数据和对数据做出判断
我们到达这篇文章的核心，并讨论为什么我相信一些描述的基于事实的建模将是未来掌握对话认知的人工智能的核心，以及我个人将如何使用该方法来改进 Google 的知识图。
在他们的核心，每个人工智能都依赖于数据。正是语义信息在基于事实的模型中的丰富嵌入，包括一阶逻辑谓词的表达，使得基于事实的建模成为一种有吸引力的产品，以一种可以存储、分析和判断的方式来定义数据的结构。
从这一点开始，我们不再考虑如何对数据做出(确定性的或随机的)决策，而是关注什么是数据，包括存储为数据的逻辑谓词。
基于事实的建模
基于事实的建模是概念建模的一种形式，它捕捉作为“事实”呈现的信息结构。事实可以写成“人‘巴拉克·奥巴马’身高‘1.85’米”的形式，事实类型从该形式中捕获结构，“人身高(以米为单位)”。“人”可以被分析为一种实体类型。
我们将“高度(以米为单位)”表示为一种特殊类型的实体类型，表示单位度量值。然而，通常值是作为值类型来分析的，而“人‘巴拉克·奥巴马’的名字是‘巴拉克’”会将姓名表示为值类型。
在一种被称为对象-角色建模 (ORM)的基于事实的建模中，上述信息在概念上被捕获在下图中:
基于事实的建模和 ORM 与其他更简单的概念建模语言(例如，实体关系图和 UML 类图)的区别在于，ORM 在语义上丰富了它在事实类型中捕获的关于事实的信息。在相应的事实类型中捕获用自然语言重建事实的完整信息。
当考虑连接的对象类型(人、身高)时，“…是…高”谓词读数(上图)允许其事实类型推断为“人是身高(米)高”，样本人口/数据允许我们推断“巴拉克·奥巴马是 1.85 米高”这一事实。
ORM 允许我们用自然语言查询一个模型，并提出类似这样的问题:“巴拉克·奥巴马身高 1.85 米吗？”，相对容易，因为随模型一起捕获了丰富的语义信息。
同一个概念模型的实体关系图所能捕获的信息量是有限的，如下所示:
在所示类型的 ERD 中，没有捕获关于每个实体属性(例如，Person Height)对的底层谓词的额外语义信息。例如，使用那种类型的 ER 图，我们不知道身高是以米为单位的，并且我们没有额外的信息来形成自然语言中的“巴拉克·奥巴马身高 1.85 米”这一事实。
我觉得实体关系图和 UML 图有它们的位置，然而我们在这里寻求的是如何捕捉丰富的语义信息来创建一个具有对话认知的 AI。我觉得为了做到这一点，我们不仅需要捕获数据，还需要关于将数据绑定在一起的底层谓词的信息。
观察力敏锐的读者可能会思考图表在实现数据方面有什么价值。在这里，我们认识到，以图形(如 ORM 图)表示的基于事实的模型在数据存储级别上实现了有效的知识图形。让我们进一步检查基于事实的建模的效用。
如果我们在模型中加入一组有身高的人是活着的人的子集(例如，火化后的人当然没有我们通常理解的“身高”)，那么我们的例子就变成了需要谓词逻辑的例子。在 ORM 中，子集约束表示如下:
用问题“巴拉克·奥巴马有多高？”，应该回“巴拉克·奥巴马身高 1.85 米”。质疑“巴拉克·奥巴马身高 1 米 85 吗？”应回，“是”。但是用“拿破仑·波拿巴有 1.69 米高吗？”来询问同样型号的智能人工智能应该回敬，“不，因为拿破仑·波拿巴已经不在人世了”。
NB 如果我们接受 ORM 只迎合开放世界语义，并且不记录某人活着并不一定意味着他们不活着，我们至少可以通过在实践中采用封闭世界语义来迎合相同的结果。或者干脆修改模型，反映一个人可能没死，有身高。
拥有语义丰富的数据加上逻辑谓词，允许人工智能使用自然语言中作为问题提出的语义查询来探索底层模型[12]。如何实现这一点是当前研究的主题，然而，研究和开发的环境扫描表明，如果要实现语义查询，就需要在数据存储内或数据存储上有语义知识，这一概念几乎没有阻力[11]。
展望未来的知识图谱
如果我们接受对话认知包括回答人工智能提出的问题的能力，那么我们可以检查现实世界中实现这种人工智能的尝试。
谷歌搜索有一个功能叫“知识图”(微软的 Bing 实现了类似的东西)，指的是底层技术。知识图是收集的关于各种感兴趣的主题的知识的集合；出于兴趣，‘名人’。知识图大概被概念化并存储为数据图。然而，我们知道数据的来源(T0)以一种更相关的方式(T3)存储(T2)。对我们来说，谷歌如何将收集到的数据存储到知识图中并不重要，重要的是它存储了什么*。*
例如，我们知道知识图表捕捉关于名人及其身高的信息。
让这些信息有些用处的是，你可以在谷歌上搜索“巴拉克·奥巴马有多高？”并且返回 1.85 米的合适结果。因为关于巴拉克·奥巴马的信息存储在知识图中，所以在搜索结果页面上会显示一个关于巴拉克·奥巴马的额外信息框。这样的搜索结果如下所示。
如果我们在谷歌上搜索“巴拉克·奥巴马身高 1.85 米吗？”我们分析的问题就变得很明显了。不显示知识图信息(如下)。如果我们期待一个确认，“是”，我们在写这篇文章的时候运气不好，伴随着我们对艺术水平的失望。
如果我们在谷歌上搜索“拿破仑有多高？”这个问题会变得更加复杂。一个搜索结果(至少在我的 iPad 上)显示了知识图谱信息，可能表明拿破仑还活着！(下图)需要进一步挖掘，点击“报价和概览”按钮来揭示死亡日期。显然，拿破仑仍然有 1.69 米高。可能发生，但是在这里我们寻找一个用自然语言提供的结果，来回答用自然语言提出的问题。
因此，我们知道，在 2018 年的前几个月，知识图不包含合适的谓词逻辑规则，这些规则允许我们在与实现价值对话认知的人工智能对话时找到合适的智能问答水平。
有些人可能会认为知识图表并不代表对话认知的尝试，但如果是这样，为什么要回答一个问题，“巴拉克·奥巴马有多高？”，一点都没有？人们已经在会话认知方面做了一些尝试。公平地说，微软的必应搜索引擎也好不到哪里去。“当今的技术水平”根本不能反映这种潜力。
需要改变什么？
我的感觉是，我们正处于分析和实施对话认知的早期阶段。我感觉用不了多久 Google/Bing 搜索就会返回“拿破仑没有 1.69 米高，因为他已经不在人世了”这样的答案。在我看来非常清楚的是，在当前的竞争环境下，如果微软必应返回这样的结果，毫无疑问，谷歌将很快效仿，反之亦然。当那发生时，我会第一个从椅子上摔下来；似乎不可避免。
我们需要一个支持语义查询和对话认知的架构。
会话认知的架构
现在你可能已经看到我的论文了。语义查询需要一个语义数据存储，其中数据和关于该数据的丰富语义信息都存储在一个逻辑数据存储中，包括一阶逻辑的条件谓词。为了实现对话式的价值认知，语义数据存储需要能够解析自然语言谓词以及底层数据的逻辑约束。
该架构最简单的形式如下图所示:
目前开发语义数据存储(SDS)的研究正在进行中。例如，波尔扎诺自由大学的“知识表示数据库研究中心”致力于开发他们所谓的知识表示数据库(KRDB)。
基于事实的建模，如对象-角色建模，是 SDS 的天然选择。事实类型读数可能包括“反向读数”；其中“零件在仓库的储箱中”，例如，有补充读数，“仓库在储箱中存储零件”和“储箱在仓库中存放零件”。更简单的事实建模形式只存储一个读数，甚至试图截断谓词，如“Person isFriendOf Person”。我不相信这种简单的谓词表示的价值。
我觉得重要的是，如何存储自然语言中的完整谓词(作为图形、关系或数据层次)并不重要，因为如果我们采用基于事实的建模的元模型来存储谓词的语义，当涉及到数据库时，基于事实的建模是实现不可知的。
同样重要的是，可以在 SDS 上进行两种形式的查询，一种是对数据的语义查询，另一种是对丰富语义数据的语义分析查询(SAQ ),它定义并管理底层数据，以便于语义查询。SAQ 返回逻辑谓词，帮助人工智能细化语义查询和结果。
例如，语义查询“Bin '1 ‘是否在仓库’主仓库’中存储零件’ 456 '？”在它的执行中，可能需要通过基于事实的模型上的语义分析查询的解决方案，即初始查询涉及事实类型“Bin stores Part in Warehouse”及其底层数据。类似的 saq 可以解决这个问题，“哪个零件存储在仓库‘主仓库’的哪个箱中？”通过首先识别存储数据的适当谓词，返回满足请求的数据列表。
因为使用解析和自然语言处理的组合来解决这样的查询需要算法体操，所以实现这样的技术不是一件容易的事，但是我很清楚，如果不存储事实类型、事实类型读数和以谓词逻辑表示的条件规则，智能对话认知的目标将无法实现。我们的第一个目标是在 AI 底层的数据模型中存储适当的谓词。
实现语义数据存储的目标并不新鲜([13])，在我看来，这种数据库在人工智能领域的最终发展和流行是不可避免的。
一个开放的研究领域是如何最好地让人工智能更新其 SDS 的语义层。在我看来，如果我们要发展人工通用智能，这个要求是不可或缺的。
Viev 正在开发工具来帮助构建语义数据存储的语义层，我们将与人工智能社区合作，帮助实现对话式认知。
感谢您的阅读。我希望这篇文章对你有所帮助。如果时间允许，我将提供更多关于基于事实的建模和对象角色建模的信息。
— — — — — — — — — — — — — — — —
参考
- 沃勒顿，m .，“语音战争:Siri vs. Alexa vs. Google Assistant”，【www.cnet.com】T2，https://www . CNET . com/news/Voice-wars-Siri-vs-Alexa-vs-Google-Assistant/，2018 年 2 月 24 日访问
- Westlake，“智能家居和联网汽车——语音激活”，www.gearbrain.com，2018 年 2 月 24 日访问
- “市场上创新的语音控制设备”，www.globalme.com，https://www . global me . net/blog/best-Voice-Controlled-Devices-Market，于 2018 年 2 月 24 日访问
- “图灵测试”，www.wikipedia.org，https://en.wikipedia.org/wiki/Turing_test，于 2008 年 2 月 25 日访问
- Perez，c .，“对话式认知:人工通用智能的新衡量标准”，www.medium.com，https://medium . com/intuition machine/conversation-Cognition-A-New-approach-to-agi-95486 FFE 581 f，于 2018 年 2 月 25 日获取
- “罗布纳奖”，www.wikipedia.org，https://en.wikipedia.org/wiki/Loebner_Prize，于 2018 年 2 月 25 日获得
- Rankin K .，“人工智能核心的黑暗秘密”，《麻省理工技术评论》，https://www . Technology Review . com/s/604087/The-Dark-Secret-at-The-Heart-of-AI/，于 2018 年 2 月 23 日查阅
- Perez，c .，“深度学习是非平衡信息动力学”，www.medium.com，https://medium . com/intuition machine/Deep-Learning-is-Non-balanced-Information-Dynamics-b 00 baa 16 b 135，2018 年 2 月 25 日访问
- “AlphaZero:来自顶级 GMs，Stockfish 作者的反应”，www.chess.com，https://www . chess . com/news/view/alpha zero-Reactions-From-Top-GMs-stock fish-Author，于 2018 年 2 月 25 日访问
- 佩雷斯，c .，“AlphaZero:直觉如何摧毁逻辑”，www.medium.com，https://medium . com/Intuition machine/alpha zero-How-Intuition-disrupted-Logic-66a 4841 e 6810，于 2018 年 2 月 25 日访问
- 林琳，王宏，王敏，“实例语义查询”，谷歌研究，
- “语义查询”，www.wikipedia.org，https://en.wikipedia.org/wiki/Semantic_query，2018-02-25 访问
- 日期，C.J .，“约束和谓词:简要教程(第一部分)”，www.brcommunity.com，http://www.brcommunity.com/articles.php?id=b065a
- 案例研究:一个房地产机器人如何在 10 天内卖出 3 套公寓。，www.medium.com
- “语音助手正在使智能手机变得多余”，《二元地区杂志》，https://then extweb . com/syndication/2018/02/24/Voice-assistants-making-smart phone-redundant/
- Mai，m .,“从阴郁到迷人:Facebook Messenger 聊天机器人的演变”，《福布斯》，
https://www . Forbes . com/sites/mariyayao/2017/10/12/From-droom-To-Glam-The-Evolution-Of-Facebook-Messenger-Chatbots/# 3b 3869263 Abd，于 2018 年 2 月 25 日查阅
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
