Keras 深度学习入门
图片由皮克斯拜的 Gerd Altmann 提供
Keras 是什么？
Keras 是一个深度学习框架，位于 TensorFlow 等后端框架之上。
为什么要用 Keras？
Keras 是优秀的，因为它允许你以很高的速度实验不同的神经网络！它位于 TensorFlow 等其他优秀框架之上，非常适合有经验的数据科学家和新手！它不需要那么多代码就可以启动并运行！
Keras 为您提供了构建所有类型架构的灵活性；这可以是递归神经网络、卷积神经网络、简单神经网络、深度神经网络等。
有什么区别？
你可能会问自己 Keras 和 TensorFlow 之间有什么区别…让我们来澄清一下！Keras 实际上是集成到 TensorFlow 中的。它是 TensorFlow 后端的包装器(从技术上讲，您可以将 Keras 与各种潜在的后端一起使用)。那是什么意思？在 TensorFlow 中，您可以根据需要拨打任何 Keras 电话。您可以享受 TensorFlow 后端，同时利用 Keras 的简单性。
神经网络最适合处理什么问题？
特征抽出
神经网络和传统机器学习的主要区别是什么？特征提取！传统上，无论是谁在操作机器学习模型，都是在执行与特征提取相关的所有任务。神经网络的不同之处在于，它们非常擅长为你执行这一步。
非结构化数据
当涉及到本质上不是表格并且是非结构化格式的数据时；即音频、视频等。；很难执行特征工程。你方便的神经网络将会在这类任务中表现得更好。
当你不需要解释的时候
当涉及到神经网络时，你对你的模型的结果没有太多的可视性。虽然这可能是好的，但取决于神经网络的应用，这也可能是棘手的。如果你能正确地将一幅图像归类为一匹马，那就太好了！你做到了；你其实不需要知道你的神经网络是怎么算出来的；而对于其他问题，这可能是模型价值的一个关键方面。
神经网络是什么样子的？
你最基本的神经网络将由三个主要层组成:
你的输入层，将由你所有的训练数据组成，
您的隐藏层，这是所有参数加权发生的地方，
最后是你的输出层——你的预测将在这里得到体现！
重量调整
当谈到应用于神经网络隐藏层的权重时，有几个主要因素可以帮助我们优化神经网络以获得正确的权重。其中之一是使用激活函数来确定权重。激活函数有助于网络识别数据中复杂的非线性模式。您可能会发现自己在使用 sigmoid、tanh、relu 和 softmax。
把手弄脏！
您需要从 Keras 导入所需的包。Sequential允许你实例化你的模型，&允许你添加每个层，基础，隐藏，&输出。此外，model.add()调用是我们如何将每一层添加到深度学习网络，直到最终输出层。
from keras.models import Sequential
from keras.layers import Dense# instantiate model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation="relu"))
model.add(Dense(1))
model.summary()
结论
如果你一路走到这里，那么你已经成功地运行了你的第一个神经网络！我希望这个对 Keras 的快速介绍是有益的。如果你想了解更多的其他话题或原则，请告诉我。在那之前，祝数据科学快乐！
用 fastai 构建深度学习项目——从模型训练到部署
用 fastai 开发计算机视觉应用的入门指南
深度学习正在引发许多学科的革命性变化。随着 TensorFlow、PyTorch 和现在的 fastai 等库的出现，领域专家和人工智能爱好者也越来越容易访问它。
以民主化深度学习为使命， fastai 是一家研究机构，致力于帮助每个人，从初级程序员到熟练的深度学习实践者，通过该领域最新研究的最先进模型和技术实现世界级的结果。
目标
这篇博文将带你了解使用 fastai 开发狗分类器的过程。目标是学习如何轻松地开始深度学习模型，并能够使用预先训练的模型，用有限的数据量获得近乎完美的结果。
先决条件
开始的唯一先决条件是你知道如何用 python 编码，并且你熟悉高中数学。
你会学到什么
- 导入库并设置笔记本
- 使用 Microsoft Azure 收集影像数据
- 将下载的数据转换为 DataLoader 对象
- 数据扩充
- 使用模型训练清理数据
- 导出定型模型
- 用你的 Jupyter 笔记本构建一个应用程序
导入库并设置笔记本
在我们开始构建我们的模型之前，我们需要从名为 fastbook 的笔记本集合中导入所需的库和实用函数，该集合旨在介绍使用 fastai 和 PyTorch 的深度学习。
让我们安装 fastbook 包来设置笔记本:
!pip install -Uqq fastbook
import fastbook
fastbook.setup_book()
然后，让我们从 fastbook 包和 fastai vision widgets API 导入所有函数和类:
from fastbook import *
from fastai.vision.widgets import *
使用 Microsoft Azure 收集影像数据
对于大多数类型的项目，你可以从各种数据仓库和网站找到在线数据。为了开发一个狗分类器，我们需要有狗的图像，在互联网上有很多狗的图像。
为了下载这些图片，我们将使用微软 Azure 提供的 Bing 图片搜索 API 。因此，在 Microsoft Azure 上注册一个免费帐户，您将获得价值 200 美元的点数。
转到您的门户网站，使用快速入门创建一个新的认知服务资源。启用 Bing 图像搜索 API，然后从左侧面板中的Keys and Endpoint选项将键复制到您的资源中。
使用检索到的密钥，将这些密钥设置为环境，如下所示:
key = os.environ.get('AZURE_SEARCH_KEY', '<YOUR_KEY>')
现在，fastbook 附带了几个实用函数，如search_images_bing，它返回与您的搜索查询相对应的 URL。我们可以使用帮助功能了解这些功能:
help(fastbook)
您可以查看本帮助指南中的search_image_bing功能。该函数接受您在上面定义的资源和搜索查询的关键字，我们可以使用attrgot方法访问搜索结果的 URL:
results = search_images_bing(key, 'german shepherd dogs')
images = results.attrgot('content_url')
len(images)
我们有 150 个德国牧羊犬图片的网址:
现在，我们可以使用download_url功能下载这些图像。但是让我们首先定义我们想要的狗的类型。在本教程中，我将和三种类型的狗一起工作，德国牧羊犬、黑狗和拉布拉多。
所以，让我们定义一个狗的类型列表:
dog_types = ['german shepherd', 'black', 'labrador']
path = Path('dogs')
然后你需要定义你的图片下载的路径，以及每一类狗的文件夹的语义名称。
if not path.exists():
path.mkdir()
for t in dog_types:
dest = (path/t)
print(dest)
dest.mkdir(exist_ok=True)
results = search_images_bing(key, '{} dog'.format(t))
download_images(dest, urls=results.attrgot('content_url'))
这将创建一个“狗”目录，其中进一步包含每种类型的狗图像的 3 个目录。
之后，我们传递了搜索查询(也就是 dog_type)和搜索函数的键，然后是下载函数，从搜索结果中下载所有的 URL 到它们各自的目的地(dest)目录中。
我们可以使用get_image_file功能检查下载到某个路径的图像:
files = get_image_files(path)
files
验证图像
您还可以检查文件中损坏文件/图像的数量:
corrupt = verify_images(files)
corrupt##output: (#0) []
通过将 unlink 方法映射到损坏文件列表，可以删除所有损坏的文件(如果有):
corrupt.map(Path.unlink);
就这样，我们准备了 379 张狗的图片来训练和验证我们的模型。
将下载的数据转换为 DataLoader 对象
现在，我们需要一种机制来为我们的模型提供数据，fastai 有数据加载器的概念，它存储传递给它的多个数据加载器对象，并使它们作为training和validation集合可用。
现在，要将下载的数据转换成 DataLoader 对象，我们必须提供四样东西:
- 我们正在处理什么样的数据
- 如何获取项目列表
- 如何给这些物品贴标签
- 如何创建验证集
现在，为了创建这些数据加载器对象以及上面提到的信息，fastai 提供了一个称为 数据块 API 的灵活系统。 我们可以使用 API 提供的参数和一系列转换方法来指定数据加载器创建的所有细节:
dogs = DataBlock(
blocks=(ImageBlock, CategoryBlock),
get_items=get_image_files,
splitter=RandomSplitter(valid_pct=0.2, seed=41),
get_y=parent_label,
item_tfms=Resize(128)
)
这里，我们有一堆我们应该理解的论点:
- 块 —指定特征变量(图像)和目标变量(每个图像的类别)
- get_items —检索底层项目，在我们的例子中是图像，我们有
**get_image_files**函数返回该路径中所有图像的列表。 - 拆分器 —按照提供的方法拆分数据；我们使用随机分割，为验证集保留 20%的数据，并指定种子在每次运行时得到相同的分割。
- get_y — 目标变量称为 y；为了创建标签，我们使用了
**parent_label**函数，它获取文件所在文件夹的名称作为标签。 - item_tfms —我们有不同大小的图像，这导致了一个问题，因为我们总是向模型发送一批文件，而不是单个文件；因此，我们需要对这些图像进行预处理，将它们调整到标准大小，然后将它们分组到一个张量中以通过模型。我们在这里使用了
**Resize**转换。
现在，我们有了 DataBlock 对象，需要通过提供数据集的路径将它转换为 DataLoader:
dls = dogs.dataloaders(path)
然后，我们可以使用show_batch方法检查 dataloader 对象中的图像:
dls.valid.show_batch()
数据扩充
我们可以向这些图像添加变换，以创建输入图像的随机变化，这样它们看起来不同，但仍然代表相同的事实。
我们可以旋转、扭曲、翻转或改变图像的亮度/对比度来创造这些变化。我们也有一套标准的增强功能封装在aug_transforms函数中，对于大多数计算机视觉数据集来说都非常适用。
我们现在可以将这些变换应用于整批图像，因为所有图像都具有相同的大小(224 像素，图像分类问题的标准)，现在使用如下:
##adding item transformationsdogs = dogs.new(
item_tfms=RandomResizedCrop(224, min_scale=0.5),
batch_tfms=aug_transforms(mult=2)
)
dls = dogs.dataloaders(path)
dls.train.show_batch(max_n=8, nrows=2, unique=True)
模型训练和数据清理
是时候用这些数量有限的图片来训练模型了。fastai 提供了许多可供使用的架构，这使得使用迁移学习变得非常容易。我们可以使用适用于大多数应用程序/数据集的预训练模型来创建卷积神经网络(CNN)模型。
我们将使用 ResNet 架构，它对于许多数据集和问题来说既快速又准确。**resnet18**中的 18 代表神经网络的层数。我们还使用来自数据加载器的验证集传递度量来测量模型预测的质量。我们使用 error_rate 来说明模型做出错误预测的频率:
model = cnn_learner(dls, resnet18, metrics=error_rate)
model.fine_tune(4)
fine_tune方法类似于其他 ML 库中的fit()方法。现在，为了训练模型，我们需要指定我们想要在每个图像上训练模型的次数(时期)。
这里，我们只训练 4 个时期:
我们还可以使用混淆矩阵将预测可视化并与实际标签进行比较:
interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix()
如你所见，我们只有五个不正确的预测。让我们检查一下最大损失，即数据集中损失最大的图像:
interp.plot_top_losses(6, nrows=3)
你可以看到模型混淆了黑色和拉布拉多。因此，我们可以使用 ImageClassifierCleaner 类将这些图像指定到特定的类别中。
将模型传递给班级，它将打开一个带有直观 GUI 的小部件，用于数据清理。我们可以更改训练集和验证集图像的标签，并查看损失最大的图像。
在将每个图像添加到它们各自正确的类后，我们必须使用以下命令将它们移动到正确的目录:
for idx,cat in cleaner.change():
shutil.move(str(cleaner.fns[idx]), str(path/cat).split('.')[0] +"_fixed.jpg")
导出定型模型
在几轮超参数调整之后，一旦您对您的模型满意了，您就需要保存它，以便我们可以将它部署到服务器上用于生产。
当保存一个模型时，我们拥有对我们有价值的模型架构和训练参数。fastai 提供了用扩展名.pkl将模型保存在 pickle 文件中的export()方法。
model.export()
path = Path()
path.ls(file_exts='.pkl')
然后，我们可以加载模型，并通过向加载的模型传递图像来进行推断:
model_inf = load_learner(path/'export.pkl')
使用这个加载的模型进行推理:
model_inf.predict('dogs/labrador/00000000.jpg')
我们可以从模型数据加载器词汇表中检查标签:
model_inf.dls.vocab
用你的 Jupyter 笔记本构建一个应用程序
下一步是创建一个我们可以与朋友、同事、招聘人员等分享的应用程序。要创建一个应用程序，我们需要添加交互式元素，以便我们可以尝试和测试应用程序的功能，我们需要将它作为一个网页在 web 上提供，包括通过一些框架(如 flask)或简单地使用 Voila 来部署它。
你可以简单地使用 Voila 将这个 Jupyter 笔记本转换成一个独立的应用程序。我在这里没有涉及到它，但是你可以通过我的博客/视频完整地了解它。
[## 使用 Python 和 Voila 构建新冠肺炎分析仪表板
用你的 jupyter 笔记本创建一个具有交互式可视化和灵活性的仪表板。
towardsdatascience.com](/building-covid-19-analysis-dashboard-using-python-and-voila-ee091f65dcbb)
部署
我已经在我的文章中介绍了 ML 模型的部署:
端到端 ML 项目教程系列的第 2 部分
towardsdatascience.com](/deploying-a-trained-ml-model-using-flask-541520b3cbe9)
但是如果你想要另一种简单自由的方式来部署你的 Voila 应用程序，你可以使用 Binder 。按照以下步骤在 Binder 上部署应用程序:
- 将你的笔记本添加到一个 GitHub 库。
- 将该回购的 URL 插入活页夹的 URL 字段。
- 将文件下拉列表改为选择 URL。
- 在“要打开的 URL”字段中，输入
/voila/render/<*name>*.ipynb - 单击右下角的剪贴板按钮复制 URL 并粘贴到安全的地方。
- 单击启动。
这就对了，你的狗分类器是活的！
如果你喜欢看我执行所有这些步骤，这里有这个博客的视频版本:
数据科学与 Harshit
通过这个渠道，我计划推出几个覆盖整个数据科学领域的系列。以下是你应该订阅频道的原因:
- 这些系列将涵盖每个主题和子主题的所有必需/要求的高质量教程，如数据科学的 Python 基础。
- 解释了为什么我们在 ML 和深度学习中这样做的数学和推导。
- 与谷歌、微软、亚马逊等公司的数据科学家和工程师以及大数据驱动型公司的首席执行官的播客。
- 项目和说明实施到目前为止所学的主题。了解新的认证、训练营以及破解这些认证的资源，如谷歌的 TensorFlow 开发者证书考试。
请随时在 Twitter 或 LinkedIn 上与我联系。
深度学习:认识你家的宠物！
深度学习对象检测
想知道宠物的面部识别是如何工作的吗？手机解锁？我会用一种你们也能认出自己宠物的方式来展示这个项目。
(权利:自己的形象)
检查我的 GitHub 库中的源代码。如果遇到任何问题，请给我发电子邮件。
在 GitHub 上注册你自己的个人资料，这是托管代码、管理项目和构建软件的最佳地方…
github.com](https://github.com/miki998)
路标
下面是本文的路线图:
1】简介
2】演示和使用的前提条件
3]示例和结果
4】未来的改进
开始了。
1]简介
如果您不熟悉对象检测，请查看我最近写的一篇关于 Yolo 架构的文章，尽管在那里谈到了 yolov4，在这里使用了 yolov3，但主要概念仍然存在。
[## 更快的实时物体检测:Pytorch 中的 YoloV4
我发现我可爱的猫比以前更快了！
medium.com](https://medium.com/analytics-vidhya/faster-real-time-object-detection-yolov4-in-pytorch-6eef8436ba75)
2]演示和使用的先决条件
系统先决条件与我的 Github 库中的相同。所以继续克隆我的库吧。
git clone [https://github.com/miki998/pet_recognition](https://github.com/miki998/pet_recognition)
一旦你完成了下载，你将不得不获得一些额外的文件，不幸的是，由于其大小，我不能上传到 git。你要问我，我会通过谷歌驱动器与你分享链接。
将它们放在下面的文件夹中。/暗/重。仔细检查你是否符合所有要求，(requirements.txt)。好了，你现在可以走了。
标准运行
假设所有的，如果一切都按顺序，你只需要把你想让模型记住/认出的宠物的图像放进去。然后
python3 train.py -<arguments>
当你简单地运行 python3 train.py 时，参数将被解释。
如果你想添加更多的宠物(如猫或狗)让模型识别，那么就分别训练它们，并以递增的方式(也就是说，一个接一个，你可以添加同一宠物的多个图像)
认出一只宠物
python3 recog.py -<arguments>
当你简单地运行 python3 train.py 时，参数将被解释。
Docker 容器运行(首选方法)
这些命令与前面的命令类似，只需在开始之前执行以下操作(使用您应该预先构建的映像启动一个容器，您可以在存储库中的 README.md 中找到相关说明)
docker run -it -p 9999 --ipc=host <docker-image-name>
注意是您在构建映像时给它起的名字。
3]示例和结果
首先，我们支持的两种宠物(猫和狗)的不同训练检测的一批例子
我们有眼睛检测:
(自己的形象)
身体检测:
(自己的形象)
人脸检测:
(自己的形象)
在对 7 种不同的宠物进行识别模型训练(即 lbph 特征创建和存储)后(我们没有测试出识别的极限，请注意，我们在相似的环境中测试了所有宠物),以下是我的首选宠物！
(自己创建的 gif)
4]未来的改进
我们对有限的一组宠物进行了“某种”实时识别(因为我们将它用于家庭宠物的产品上，这显然限制了我们需要识别的宠物的范围)，通过一些实时技巧，包括不从视频中捕捉所有时间的图像或降低分辨率或使用功率过大的芯片(我不负责这一部分)。我们仍在尝试改进识别部分，因为在数量上有明显的限制(权重的大小至少与宠物的数量成线性增加)，涉及自动人脸标志的其他特征加上大规模微分同胚注册可以帮助标准化人脸，并且找到其他特征也可以有所帮助(即行为，因为我们有身体检测)。在检测部分，可以做大量的事情，例如，用 EfficientDet 和 TensorRT 进行替换，当我们进行第一次人体检测时，通过图像分割进行并行化。
结论
感谢您的阅读，如果您喜欢或发现这篇文章有用，请在 medium 和 GitHub 上关注我的更多项目。
阅读媒体上的陈宸作品。数据驱动投资者主网站作家数学和计算机科学理学士…
medium.com](https://medium.com/@michaelchan_2146)
深度学习研究和如何沉浸其中
所以你有兴趣了解更多关于深度学习的研究，但你还没有机会在研究实验室工作。也许你刚刚完成了一个在线课程或训练营，或者你只是对这个领域的最新发展感到好奇。你从哪里开始？
如果你不确定你是否想专注于阅读研究论文，保持与新研究保持一致的最简单的方法之一是订阅一份时事通讯或邮件列表来整理内容。一些例子是分析调度(针对数据科学文章——较少关注研究，更多关注应用)或机器学习(关注关于人工智能和机器学习的新闻文章)。
如果你更喜欢视觉学习，你可能会对两分钟论文感兴趣，这是一个 YouTube 频道，它将科学研究浓缩成动画短片，展示他们的核心概念。由于媒体的性质，它通常围绕着一个演示，如果你对新研究的应用更感兴趣，这是完美的。
阅读报纸
用批判的眼光看待论文是很重要的。与对该材料更有经验的人讨论论文的内容，可以帮助你抓住细微差别和重点学习的领域。
此外，不要从表面上看论文讨论的内容，而要考虑论文的结构和背景。
- 这个领域最大的未解问题是什么？
- 结果什么时候有用，为什么有用？
- 研究的限制是什么？
- 这些见解可以转移到其他领域吗？
- 为什么有些想法得到了更广泛的传播，而另一些却不了了之？
- 作者在论文中没有讨论什么？
至少在深度学习领域，有些论文更侧重于理论，有些论文更侧重于实现。就你可能想要如何对待自己的兴趣和工作而言，从实现开始可能更容易，因为这些论文的效果更具体。
不管你以前是否读过论文，回忆一下如何阅读论文的过程可能会有所帮助。从阅读导言开始，而不是摘要。通常，摘要会让你对报纸上的真实内容产生偏见。确保你理解了大背景，以及这篇论文如何适应其领域的更大范围。确定背景的要点，以及研究背后的问题，然后找出方法。
在这一点上，你可能想阅读全文，密切关注方法和结果。弄清楚结论和摘要是如何与你在纸上的想法联系起来的，然后弄清楚其他人对此有什么看法。这最后一步是可选的，因为你手头可能不会立即有文献评论，但知道作者的同行是否支持他们的结果是有帮助的。
策划文件
计算机科学最佳论文奖根据各个领域的顶级会议，收集各个研究领域的年度论文。例如，有些论文获得了 AAAI 大学(人工智能)和 ICML 大学(机器学习)的“杰出论文奖”或“杰出论文奖”。
我们喜爱的论文是一个由计算机科学家和研究爱好者组成的社区，他们为计算机科学的所有学科收集顶级论文。该小组主持以城市为基础的分会会议，并就某些论文发表演讲。
费马的图书馆是寻找注释论文的绝佳资源——有点像来自一个论文阅读俱乐部的异步见解。他们专注于所有科学研究领域的论文，尽管他们也有一个按研究领域分类的过去论文列表(包括计算机科学)。最重要的是，他们有一份时事通讯，每周发送一份新的论文，里面有从简单的解释到 gif 的令人敬畏的评论。
蒸馏是一个关于机器学习研究的视觉解释的在线杂志。该出版物旨在以更加透明和可视化的方式交流研究，在论文中嵌入了交互式小部件、代码片段和动画。
令人敬畏的深度学习论文有点过时(上次更新是在两年前)，但它确实列出了 2012 年至 2016 年被引用最多的论文，按学科排序，如卷积神经网络模型、优化技术、对象检测和强化学习。
由 UMass Amherst 教授 Emery Berger 创建的 CS 排名是一个很好的资源，可以查看由出版物和顶级教师排名的研究机构。您可以搜索计算机科学学科，包括人工智能、机器学习、自然语言处理和计算机视觉，以找到每个学科的顶级会议和期刊。
结束语
发表的论文肯定比你能读的要多得多，所以挑战的一部分是确保你读的是你感兴趣的或者可能对你的工作有帮助的论文。如果你已经在某个领域工作了，并且有同事，那就去寻求书面的推荐信。否则，如果有机会参加座谈会和讲座，一定要查看一下发言人名单，他们的见解可能与你的工作一致。
也有可能建立或加入一个读报小组——如果你有一个可以讨论的社区，你总能从报纸中获得更多。
还有什么建议吗？把它们留在下面的评论里吧！
用于研究聚糖介导的宿主-微生物相互作用的深度学习资源
一个关于糖、细菌和人类健康的故事
莎伦·麦卡琴在 Unsplash 上的照片
生物学家非常熟悉 DNA、RNA 和蛋白质——正如我们所知，这三种生物序列使生命成为可能。不太熟悉的(尽管至少同样重要)是多聚糖或复杂碳水化合物。这些各种糖(或技术上称为单糖)的链可以单独存在，例如构成细菌、真菌以及植物细胞的荚膜，或者修饰各种其他生物分子，如蛋白质、脂质或 RNA。与蛋白质物理连接的特定聚糖序列从根本上改变了蛋白质的性质和功能，微调了稳定性、结构和功能。这导致了令人难以置信的复杂相互作用的混杂，进而产生了我们所知的极其复杂的现象，即生命。它确实非常复杂，因为聚糖拥有数百种单糖，相比之下，蛋白质只有区区 20 个氨基酸，DNA 只有 4 个核苷酸。
此外，聚糖不仅是唯一的非线性生物序列(导致分子具有多个分支)，而且是唯一的非模板序列，是通过密切依赖于细胞当前状态的几十种专门酶的相互作用而产生的。所有这些使聚糖成为最多样化的生物序列，也是最动态的序列，能够在没有基因突变的情况下即时调整序列。最重要的是，从炎症到癌症，多聚糖与基本上所有人类疾病都有关联。因此，鉴于这一切，你会认为一个名副其实的研究大军将致力于解开聚糖在生物学各个方面的作用，对吗？结果……不完全是这样。
这是细胞实际上看起来的样子…被聚糖覆盖着。
虽然有一个名为“糖生物学”的研究领域，但与它们的相关性相比，聚糖在生命科学中的突出地位仍然微不足道。尽管深度学习最近彻底改变了对其他复杂生物序列的分析，如蛋白质或 RNA ，但聚糖迄今仍未被机器学习所捕获。其原因主要在于它们的非线性，这阻止了为线性序列开发的标准自然语言处理工具的应用。然而，我们相信，作为最多样和最复杂的生物聚合物，多聚糖将从最先进的深度学习技术中受益最多，这些技术最终可以促进从序列到功能的映射，并允许对糖生物学采取全面的方法。这就是为什么在我们最近发表在杂志细胞宿主&微生物上的工作中，我们开发了第一个多聚糖的语言模型，我们称之为 SweetTalk。
我们工作的概述。doi:10.1016/j . chom . 2020 . 10 . 004
当然，在此之前，我们必须收集数据。我们收集了尽可能多的聚糖序列，并将所有 19，299 个聚糖序列收集在我们自己的数据库 SugarBase 中。当时，SweetTalk 由一个具有长短期记忆(LSTM)单元的双向递归神经网络(RNN)组成。基本上，我们训练 SweetTalk 通过预测前面给出的糖链中的下一个单糖或键(我们定义为糖链)来学习糖链中的序列依赖性。这为我们提供了一个训练有素的多聚糖语言模型，以及我们可以用于可视化目的的每个乙醇字母的学习表示。为了避免聚糖序列的非线性性质，我们通过从聚糖序列中提取“糖字”来处理序列，聚糖序列是由五个字母组成的集合，为 SweetTalk 提供了学习正确的字母之间的上下文关系的机会。在的论文和相关的 预印本中，我们对学习到的聚糖表达进行了大量分析，并开发了聚糖比对算法，但我想在这里重点介绍我们的分类器，所以如果你想了解更多关于聚糖嵌入的信息，请随意阅读论文。
由于我们肠道的整个内层都覆盖着聚糖(粘液中的粘蛋白)，每个细胞表面也都覆盖着聚糖(包括肠道细菌)，我们推断，我们的微生物组(或病原体)和我们之间的相互作用可能为我们的方法提供了一个有前途的应用领域。这一点尤其重要，因为研究表明，一些细菌模仿我们的聚糖来欺骗我们的免疫系统。因此，我们想看看我们能否预测特定的聚糖是否会被人类免疫系统识别。为此，我们在标记了免疫原性的聚糖的较小数据集上微调了我们预先训练的 SweetTalk 模型，并实现了超过 90%的准确率，优于随机森林等其他机器学习方法。这项分析支持了分子模拟的概念，与人类聚糖相似的细菌聚糖具有较低的免疫原性得分。我们还成功训练了准确率接近 90%的分类器，用于纯粹根据聚糖预测常见细菌大肠杆菌菌株的致病性，这清楚地支持了我们的假设，即聚糖可以提供致病性等特性的信息。重要的是，我们甚至可以识别出似乎最能预测致病性的序列基序，再次强烈地指向聚糖的分子模拟。我们做的另一个有趣的观察是，尽管使用了致病性的二元标签，我们的模型预测了致病性的连续性，反映了致病性对环境条件的依赖性，并支持早期关于这一现象的报道。
我们的基准任务&模型 SweetOrigins。doi:10.1016/j . chom . 2020 . 10 . 004
最后，我们解决了与高维数的聚糖序列相比缺乏数据的紧迫问题。虽然我们使用无监督语言模型的迁移学习方案已经改善了模型结果，但我们开始设计一种数据增强方案，以进一步提高以聚糖为中心的机器学习的效率。为此，我们设计了一个多类基准问题，我们称之为 SweetOrigins:预测给定聚糖序列来自哪个分类组。这代表了一系列的困难，从预测四个分类领域中的一个到预测成百上千个物种中的一个。对于我们的数据扩充方法，我们利用了众所周知的用于聚糖序列的模糊符号，括号表示分支。这个明显的缺点允许我们为同一聚糖分子制定不同的括号符号字符串，有效地扩大了我们的序列数量。这使得我们的模型更加健壮，并且确实在我们的基准测试任务中显著提高了性能，对于最困难的任务，绝对精度提高了 6%。
以聚糖为中心的机器学习的数据扩充。doi:10.1016/j . chom . 2020 . 10 . 004
我们预计，我们开发的基准任务可以用于继续改善以聚糖为中心的机器学习，以解决聚糖在其中发挥重要作用的大量潜在应用。类似于以蛋白质为重点的机器学习对蛋白质工程和全新设计蛋白质的设计的影响，我们相信，以聚糖为重点的机器学习可以在不久的将来以类似的效果提升糖工程。
如果你想了解更多，这里有论文和相关 预印本的链接。此外，这里有一些易于理解的新闻文章，介绍哈佛大学 Wyss 生物工程研究所和 Branco Weiss Fellowship-Society in Science 项目的工作。当然，这里是 GitHub 上的代码和我们在 SugarBase 上的数据。如果您对以聚糖为中心的机器学习感兴趣，请随时联系我们！
基于三维贝叶斯卷积神经网络的不确定性深度学习分割
神经网络如何学习概率分布来量化其预测中的不确定性？
我们的贝叶斯卷积神经网络(BCNN)在材料数据集的不确定性量化方面击败了以前的最先进的结果。请注意，BCNN 不确定性地图捕捉连续性和视觉梯度，而 MCDN 不确定性地图是像素化和不可解释的。
论文:【https://arxiv.org/abs/1910.10793】T2
【https://github.com/sandialabs/bcnn】代号:
关键要点:
测量不确定性在常规的深度神经网络中是不可能的，但是对于可解释性和有效性是极其重要的
贝叶斯神经网络学习概率分布而不是点估计，允许它们测量不确定性
我们为 3D 分割设计了第一个成功的贝叶斯卷积神经网络(BCNN)架构
我们的 BCNN 在不确定性量化方面击败了当前最先进的神经网络，同时实现了相同或更好的分割精度
我们的学术论文和完整的开源代码实现可在线获得
简介
C 考虑这个场景:某飞机制造公司为商用飞机生产安全关键的发动机零件。由于必须保证发动机零件能够工作，该公司在长达数月的艰苦过程中验证了每一个零件，他们对零件进行 3D CT 扫描，手工注释数亿个体素，并使用注释扫描来分析零件的缺陷。
丹尼尔·埃勒杜特在 Unsplash 上拍摄的照片
这既不省时也不划算，因此该公司雇佣了一个数据科学家团队来设计一个深度神经网络，该网络使用最先进的体积分割技术自动验证零件。神经网络看似成功，但有一天由神经网络验证的零件在使用过程中莫名其妙地出现故障，导致飞机发动机故障，并导致数百人死亡和公司数十亿美元的损失。
那么是哪里出了问题呢？嗯，深度神经网络以做出准确的预测而闻名，但它们最大的弱点之一是缺乏测量预测中不确定性的能力。因此，深度学习系统没有能力区分 100%认证的部分和勉强合格的部分。
人们可能认为 sigmoid 输出的值可用作不确定性的度量，但这不是真的，因为这些值取决于推断样本是否“接近”训练分布。如果根据远离训练分布的样本(即，其中有缺陷的零件)进行推断，则 sigmoid 输出不能用作模型不确定性的代理。
换句话说，当测试集与训练集“相似”时，深度神经网络的性能最佳；换句话说，测试集中可能存在神经网络不确定的示例，因为没有类似的训练示例。但由于没有“我不知道”的输出可用，有缺陷的零件最终可能会被深度学习系统验证并转移到生产中。
图像分割如何在实践中导致不良预测，以及贝叶斯神经网络生成的不确定性图的分析如何有助于决策。
这个例子说明了深度神经网络中不确定性量化的至关重要性，其研究和开发在过去五年中飞速发展。最近的技术铸造神经网络，通常逐点估计，作为概率或贝叶斯模型。用于此目的的两种最常见的神经网络架构是蒙特卡洛漏失网络(MCDNs)和贝叶斯卷积神经网络(BCNNs)。
mcdns 使用漏失层来近似深高斯过程，虽然易于实现，但是它们的统计可靠性已经被称为 question⁹.BCNNs 使用变分推理来学习给定数据集的权重的后验分布，并且更加难以实现，但是给出了大大改善的不确定性结果。
已经假定，用于大问题的贝叶斯神经网络，包括在 3D 图像分割空间中，由于过高的计算成本而不可行。在这里，我们反驳了这种说法，并首次成功实现了用于体积分割中不确定性量化的 3D BCNN，详细说明了它是如何工作的，并解释了开源代码库的一些部分。
特别地，与 MCDNs 相比，这种新颖的神经网络架构提供了改进的不确定性量化，同时实现了相等或更好的分割精度。通过对电池电极和激光焊接金属的 CT 扫描的实验，我们表明由 BCNN 产生的不确定性图捕获连续性和视觉梯度，使它们可解释为分割的置信区间。
BCNN 概况
虽然大多数神经网络学习其权重的逐点估计，但更严格的观点是，这些估计并没有完全包含权重值中固有的不确定性。相反，在 BCNN 中，每个权重都被隐式描述为(多元)概率分布。
典型与贝叶斯神经网络中的权重表示
将神经网络的权重描述为概率分布有几个结果。首先，它使神经网络具有不确定性；每次我们计算向前传递时，我们必须从每个重量分布中取样，以获得可用于推断的点估计。重复应用这种抽样技术，称为蒙特卡罗抽样，将产生不同的预测，然后可以分析不确定性。第二，它改变了反向传播算法，因为我们不能通过采样操作反向传播(它没有梯度)。在后面的部分中，我们将讨论如何使用 Bayes by Backprop 算法来解决这个问题。最后，这使得神经网络更加难以可靠地训练，尤其是在 3D 中，并且容易受到消失/爆炸梯度的影响。我们使用一种称为组规范化的巧妙的规范化技术来解决这个问题，这也将在后面的部分中详细介绍。
贝叶斯学习
我们如何准确地得到权重的分布？嗯，在一个完美的世界里，我们可以用贝叶斯法则精确地计算它们。为此，我们将从权重的先验分布开始；这是我们对体重分布的“初步猜测”。表示为 p(w) ，一般为标准正态分布。然后，我们将使用我们的数据来计算给定数据集的权重的后验分布，表示为 p(w|D) 。这相当于找到一个 w ，它在给定这些权重的情况下最大化数据集的可能性，表示为 p(D|w) ，我们可以通过贝叶斯规则来执行此计算:
然而，由于在神经网络中发现的极端过度参数化，分母中的积分通常是难以处理的。所以，我们需要学习后验分布，而不是精确地计算它。辛顿、范·camp⁵和 Graves⁴之前的工作提出了变分学习(也称为变分推断)作为一种近似后验分布的方法。变分学习通过变分自由能代价函数 F 的最小化，找到分布 p(w|θ) 的参数 θ ，称为变分分布，通常称为期望下界(ELBO)。
变分自由能由 Kullback-Leibler (KL)散度和负对数似然性之和组成，前者衡量先验分布和变分分布之间的距离，后者衡量模型的拟合优度。布伦德尔等人 将变分自由能损失函数解释为满足简单先验(由 KL 项表示)和满足数据集复杂性(由 NLL 项表示)之间的折衷:
我们训练神经网络的时间越长，我们就越接近最小化这个成本函数，我们的变分分布就越接近真实的后验分布。在实践中，KL 项对神经网络的输出具有正则化效果，以训练集中较低的 NLL 项为代价，防止学习的分布过度拟合。
单重变分自由能损失函数下的训练可视化
该损失函数可通过如下缩放小批量 i 的成本来服从小批量优化，本质上在整个数据集上展开 KL 散度损失:
如果在张量流概率中实现贝叶斯神经网络，下面是变分自由能损失的有效 Python 实现(注意，二进制交叉熵只是否定 NLL):
from tensorflow.keras.losses import binary_crossentropydef vfe_loss(model, dataset_size, batch_size, alpha=1):
"""Defines variational free energy loss.
Sum of KL divergence and binary cross-entropy."""
# KL Divergence should be applied once per epoch only.
kl = sum(model.losses) / (dataset_size / batch_size) def loss(y_true, y_pred):
bce = binary_crossentropy(y_true, y_pred)
return alpha * kl + (1\. / alpha) * bce return loss
贝叶斯学习的挑战
变分贝叶斯学习通常被认为在统计上比例如通过丢失 layers⁹.的近似贝叶斯推断更合理然而，这是以一些计算挑战为代价的。
首先，从分布中采样的随机变量没有梯度，因此贝叶斯神经网络似乎与反向传播不兼容。然而，金马等人 ⁶表明，将随机变量重新参数化为确定性变量进行计算是可能的。作为一个例子，假设从具有平均值 μ 和方差 σ 的正态分布中采样一个权重 w 。那么，有效的重新参数化是 w=μ+σϵ ，其中 ϵ 是从标准正态分布采样的辅助噪声变量。现在，代替采样操作，我们有一个仿射组合，它很容易在反向传播中使用。需要更复杂的计算来有效地缩放该计算；详见金玛的论文。这通常被称为局部重新参数化技巧。
局部重新参数化技巧的可视化，从到。
接下来，贝叶斯学习以前被认为在计算上是不可行的，因为如果使用集成方法训练，需要大量的权重更新。为了解决这个问题，Blundell 等人设计了贝叶斯反推算法。先前的工作集中于训练随机隐藏单元，但是权重比隐藏单元容易多两个数量级，并且 Backprop 的 Bayes 是第一个在神经网络中有效训练概率权重的算法。Bayes by Backprop 通过使用反向传播中计算的梯度来“缩放和移动”后验的变化参数，从而以最小的额外计算更新后验。
由于 3D 训练量可能非常大，我们的批处理大小受到可用 GPU 内存量的限制，导致批处理大小太小，无法进行批处理标准化来准确计算批处理统计数据。因此，我们使用一种由吴和何提出的称为组归一化的技术，该技术将通道组归一化，并且显示出具有与批量大小无关的精确性能。观察到适当的标准化是我们模型收敛的关键因素，因为它有助于避免消失/爆炸梯度；通过调整组标准化图层中使用的组数，我们发现当使用 4 个组时，BCNN 收敛最可靠。
群体规范化的可视化，从到这里。
最后，与概率权重相关的一个挑战是，小批量中的所有样本通常具有相似的采样权重，这限制了大批量的方差减少效果。上面提到的局部重新参数化 trick⁶的一个副作用是，它通过将全局权重不确定性转化为小批量样本中的独立局部噪声，极大地降低了随机采样权重的方差。同样，Wen 等人提出了 Flipout 估计量，该估计量通过对每个样本伪独立地采样权重，根据经验实现了理想的方差减少。一个重要的区别是，本地重新参数化只对全连接网络有效，而 Flipout 可以有效地用于全连接、卷积和递归网络。
BCNN 建筑
O ur 3D BCNN 架构利用 V-Net⁷和 3D U-Net 中常见的编码器-解码器设置，从图像分割文献中提取，3D u-net 是最初分别用于人类前列腺和青蛙肾脏的 3d 分割的深度神经网络。在这种架构中，网络的编码器部分(左)将输入压缩到潜在空间中，而解码器部分(右)将输入的潜在表示解压缩到分段图中。
我们的 BCNN 建筑示意图，包括体积尺寸样本。尺寸为(深度、高度、宽度、通道)。
BCNN 的编码器部分使用典型的 3D 卷积来最大化原始音量和潜在空间之间的信息传输，但是网络的解码器部分使用 3D 贝叶斯卷积层。这些中的每一个都用标准的正态先验来初始化，并采用前述的翻转估计器来近似正向传递期间的分布。请注意黄色的跳过连接，它有助于整个网络的功能转发。我们的实现利用了包含在张量流概率中的贝叶斯层库⁰，其跟踪表示层的后验分布相对于其先验的 KL 散度的损失，并使得计算变化的自由能损失变得简单。
这个 BCNN 架构的实现可以在https://github . com/Sandia labs/bcnn/blob/master/Bayesian _ vnet . py获得。
训练注意事项
在实践中，唱 BCNN 带来了一些难以有效实现的特性。首先，目前不可能保存组合了 Keras 层和 Bayesian 层的模型的架构和权重。相反，必须只保存权重，然后将它们加载到实例化的架构中。当模型被指定为多 GPU 时，情况会变得更糟，这在处理许多 3D 数据集时实际上是必要的。当多 GPU 模型仅保存为权重时，很难重新加载模型，因为神经网络体系结构期望导入单 GPU 权重。一个巧妙的解决方案是通过提取多 GPU 模型中倒数第二层的权重，将多 GPU 权重重新保存为单 GPU。以下代码提供了一个示例:
from tensorflow.keras.utils import multi_gpu_model# Assumes the BCNN architecture is defined in the model file.
from model import bcnndef load_model(input_shape, weights_path, num_gpus):
"""Loads model from .h5 file. If model is
saved as multi-gpu, re-saves it as single-gpu.""" # Loads model as multi-gpu, if possible.
try:
model = bcnn(input_shape)
model = multi_gpu_model(model, gpus=num_gpus) # Converts .h5 file to single-gpu.
model.load_weights(weights_path)
model = model.layers[-2]
model.save_weights(weights_path) except ValueError as e:
pass # Loads single-gpu model.
model = bcnn(input_shape)
model.load_weights(weights_path) # Converts to multi-gpu model if applicable.
if num_gpus > 1:
model = multi_gpu_model(model, gpus=num_gpus) return model
此外，3D 数据集管理可能会变得非常迅速。许多 CT 和 MRI 扫描的尺寸可以是 1000 x 1000 x 1000 甚至更大，这是不可能一次对所有的进行推断的。相反，需要一种“分块”技术，将大量数据分成重叠的数据块，然后输入 BCNN。然后，在组块上训练神经网络，并预测相同大小的组块，可以通过反转组块过程来重建这些组块，以获得完全推断的完整体积。
分块过程包括以一定的重叠比例(称为“步长”)穿过原始体积的滑动矩形棱柱“窗口”。我们必须小心避免一个接一个的错误，我们还需要保存每个块的坐标，以便在重建过程中使用。该算法的输出是一个巨大的 5D 数数组，它包含数据集中的所有组块。此外，有一个 Keras bug ，每当一个 epoch 中的最后一批不能在所有 GPU 之间划分时，它都会导致错误；避免这个错误需要截断数组的末尾。
这个算法的一个实现在这里的“块”方法中:【https://github.com/sandialabs/bcnn/blob/master/dataset.py。
计算 BCNN 预测和不确定性
因为 BCNNs 是不确定的，所以当对一个组块进行多次预测时，人们将获得许多不同的(并且可能非常错误的)预测。为了获得准确的预测以及不确定性图，我们必须对每个块进行多次预测，以获得 sigmoid 值的分布。这被称为蒙特卡罗抽样。这个过程是高度可定制的，但是这里我们将分割表示为所有 sigmoid 值的平均值(对于二进制分割，转换为 0 和 1)，不确定性映射表示为第 20 个和第 80 个百分点之间的差。
关键的是，分块重建过程可能导致输出分割体积中的严重伪像。这是因为神经网络没有足够的空间上下文来有效地预测每个块的边缘；相反，我们丢弃了每个块周围的某个百分比(大约 5%)，以确保我们只保留合理的预测。
这个算法的一个实现在这里的“预测”方法中:https://github.com/sandialabs/bcnn/blob/master/test.py。
验证和结论
BCNN 是体积分割不确定性量化的最新技术；特别是，我们使用锂离子电池石墨电极和激光焊接金属接头的 CT 扫描验证了 BCNN。与先前优越的 MCDN 相比，BCNN 提供了大大改进的不确定性图，同时实现了相等或更好的分割精度。下面是我们论文中的一个样本图像，它突出了 BCNN 不确定性图的连续性和视觉梯度，而 MCDN 生成了一个无法解释的逐点不确定性图。
此外，我们采用了帕夫普 metric⁸，一种最近设计的验证不确定性结果的方法，并发现在编码不确定性和准确性之间的关系时，BCNN 始终并大大优于 MCDN。参见我们在https://arxiv.org/pdf/1910.10793.pdf的论文，深入分析和验证 BCNN 及其相对于 MCDN 的优势，并在https://github.com/sandialabs/bcnn随意使用和分叉开源代码库。虽然我们的新颖贡献是在 3D 空间中，但是我们也为典型的图像分割提供了 2D 实现。
参考
[1]查尔斯·布伦德尔、朱利安·科尔内比斯、科雷·卡武克库奥卢和金奎大·威斯特拉。神经网络中的权重不确定性。2015 年第 32 届机器学习国际会议论文集。【https://arxiv.org/abs/1505.05424
[2]奥兹冈·希切克、艾哈迈德·阿卜杜勒卡迪尔、苏伦·s·连坎普、托马斯·布罗克斯和奥拉夫·龙内贝格。3d u-net:从稀疏注释中学习密集体积分割。2016 年第 19 届国际医学图像计算和计算机辅助介入会议论文集。https://arxiv.org/abs/1606.06650
[3]亚林·加尔和邹斌·格拉马尼。作为贝叶斯近似的辍学:表示深度学习中的模型不确定性。2016 年第 33 届机器学习国际会议论文集。https://arxiv.org/abs/1506.02142
[4]亚历克斯·格雷夫斯。神经网络的实用变分推理。2011 年第 24 届神经信息处理系统进展会议论文集。https://papers . nips . cc/paper/4329-神经网络的实用变分推理
5 杰弗里·e·辛顿和德鲁·范·坎普。通过最小化权重的描述长度来保持神经网络的简单性。《第 16 届学习理论会议论文集》，1993 年。https://www.cs.toronto.edu/~hinton/absps/colt93.html
[6]迪德里克·p·金马、蒂姆·萨利曼斯和马克斯·韦林。变分丢失和局部重新参数化技巧。2015 年第 28 届神经信息处理系统进展会议论文集。https://arxiv.org/abs/1506.02557
[7] Fausto Milletari、Nassir Navab 和 Seyed-Ahmad Ahmadi。V-net:用于体积医学图像分割的全卷积神经网络。2016 年第四届 3D 视觉国际会议论文集。https://arxiv.org/abs/1606.04797
[8]吉什努·穆克霍蒂和亚林·加尔。评估用于语义分割的贝叶斯深度学习方法。arXiv 预印本 1811.12709，2019 年。【https://arxiv.org/abs/1811.12709
[9]伊恩·奥斯本。深度学习中的风险与不确定性:贝叶斯、自助和辍学的危险。《第 29 届神经信息处理系统进展会议论文集:贝叶斯深度学习研讨会》，2016 年。https://pdfs . semantic scholar . org/DDE 4/b95be 20 a 160253 a 6 cc 9 ECD 75492 a 13d 60 c 10 . pdf
[10]达斯汀·特兰、迈克尔·w·杜森伯里、马克·范德维尔克和达尼亚尔·哈夫纳。贝叶斯层:神经网络不确定性的模型。2019.https://arxiv.org/abs/1812.03973
[11]叶明·温、保罗·维科尔、吉米·巴、达斯汀·特雷恩和罗杰·格罗斯 Flipout:小批量的有效伪独立重量扰动。2018 年第六届国际学习表征会议论文集。https://arxiv.org/abs/1803.04386
[12]吴雨欣和明凯·何。群体规范化。2018 年欧洲计算机视觉会议论文集，2018。https://arxiv.org/abs/1803.08494
资金报表
这项工作是在作者在桑迪亚国家实验室实习期间完成的。桑迪亚国家实验室是一个多任务实验室，由霍尼韦尔国际公司的全资子公司桑迪亚国家技术和工程解决方案有限责任公司根据合同 DE-NA0003525 为美国能源部国家核安全局管理和运营。2020 年至 1419 年
深度学习并驾齐驱:Julia v.s. Python
你能说出哪一种是未来的语言吗？
Julia 可能是 Python 最大的威胁。对于各种应用程序来说，Julia 无疑比 Python 更快，几乎和 C 语言一样快。Julia 还提供了多分派和元编程等特性，这些特性让它比 Python 更有优势。
与此同时，Python 被建立，被广泛使用，并拥有各种经过时间考验的包。切换到朱莉娅的问题是一个很难解决的问题。通常答案是令人沮丧的，“看情况”。
为了帮助展示 Julia 并解决是否使用它的问题，我从两种语言中提取了深度学习代码的样本，并将它们串联起来以便于比较。我将在 CIFAR10 数据集上训练 VGG19 模型。
模型
深度学习模型可能非常庞大，通常需要大量的工作来定义，尤其是当它们包含像 ResNet [1]这样的专门层时。我们将使用一个中等大小的模型(没有双关的意思)，VGG19，来进行比较[2]。
Python 中的 vgg 19
我选择 Keras 作为我们的 Python 实现，因为它的轻量级和灵活的设计与 Julia 具有竞争力。
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D , Flattenvgg19 = Sequential()
vgg19.add(Conv2D(input_shape=(224,224,3),filters=64,kernel_size=(3,3),padding="same", activation="relu"))
vgg19.add(Conv2D(filters=64,kernel_size=(3,3),padding="same", activation="relu"))
vgg19.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
vgg19.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
vgg19.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu"))
vgg19.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
vgg19.add(Flatten())model.add(Dense(units=4096,activation="relu"))
vgg19.add(Dense(units=4096,activation="relu"))
vgg19.add(Dense(units=10, activation="softmax"))# Code from [Rohit Thakur](https://github.com/1297rohit) on [GitHub](https://github.com/1297rohit/VGG16-In-Keras)
这里的任务是连接 21 层深度学习机器。Python 很好地处理了这一点。语法简单易懂。虽然.add()函数可能有点难看，但它的作用是显而易见的。此外，代码中很清楚每个模型层做什么。(卷积、合并、扁平化等…)
茱莉亚中的 vgg 19
using Fluxvgg16() = Chain(
Conv((3, 3), 3 => 64, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 64 => 64, relu, pad=(1, 1), stride=(1, 1)),
MaxPool((2,2)),
Conv((3, 3), 64 => 128, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 128 => 128, relu, pad=(1, 1), stride=(1, 1)),
MaxPool((2,2)),
Conv((3, 3), 128 => 256, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 256 => 256, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 256 => 256, relu, pad=(1, 1), stride=(1, 1)),
MaxPool((2,2)),
Conv((3, 3), 256 => 512, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 512 => 512, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 512 => 512, relu, pad=(1, 1), stride=(1, 1)),
MaxPool((2,2)),
Conv((3, 3), 512 => 512, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 512 => 512, relu, pad=(1, 1), stride=(1, 1)),
Conv((3, 3), 512 => 512, relu, pad=(1, 1), stride=(1, 1)),
BatchNorm(512),
MaxPool((2,2)),
flatten,
Dense(512, 4096, relu),
Dropout(0.5),
Dense(4096, 4096, relu),
Dropout(0.5),
Dense(4096, 10),
softmax
)# Code from [Flux Model Zoo on Github](https://github.com/FluxML/model-zoo/blob/master/vision/cifar10/cifar10.jl)
讨论
乍看之下，Julia 看起来没有 Python 那么杂乱。导入语句更简洁，代码更容易阅读。和 Python 一样，每一层做什么都很清楚。Chain类型有点不明确，但是很明显它将各层连接在一起。
需要注意的是没有模型类。事实上，Julia 不是面向对象的，所以每一层都是类型而不是类。这一点值得注意，因为它强调了 Julia 模型是非常轻量级的。这些层中的每一层都是独立定义的，然后链接在一起，没有任何类结构来控制它们如何交互。
然而，在训练巨型模型时，避免一点混乱并不重要。Python 的优势在于它对故障排除和解决 bug 有大量的支持。文档非常好，网上有数百个 VGG19 示例。相比之下，Julia 在网上有五个独特的 VGG19 例子(也许)。
数据处理
对于数据处理，我们将查看通常与 VGG19 相关联的数据集 CIFAR10。
Python 中的数据处理
from keras.datasets import cifar10
from keras.utils import to_categorical(X, Y), (tsX, tsY) = cifar10.load_data() # Use a one-hot-encoding
Y = to_categorical(Y)
tsY = to_categorical(tsY)# Change datatype to float
X = X.astype('float32')
tsX = tsX.astype('float32')
# Scale X and tsX so each entry is between 0 and 1
X = X / 255.0
tsX = tsX / 255.0
为了根据图像数据训练模型，必须将图像转换成正确的格式。只需要几行代码就可以做到这一点。图像和图像标签一起被加载到变量中。为了使分类更容易，标签被转换成一个热点编码格式。这在 Python 中相对简单。
Julia 中的数据处理
using MLDatasets: CIFAR10
using Flux: onehotbatch# Data comes pre-normalized in Julia
trainX, trainY = CIFAR10.traindata(Float64)
testX, testY = CIFAR10.testdata(Float64)# One hot encode labels
trainY = onehotbatch(trainY, 0:9)
testY = onehotbatch(testY, 0:9)
Julia 需要与 Python 相同的图像处理来为训练过程准备图像。这些代码看起来极其相似，而且似乎不支持任何一种语言。
培养
照片由 Zii Miller 在 Unsplash 上拍摄
接下来，我们将查看模型训练循环。
Python 培训
optimizer = SGD(lr=0.001, momentum=0.9)
vgg19.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
history = model.fit(X, Y, epochs=100, batch_size=64, validation_data=(tsX, tsY), verbose=0)
茱莉亚的培训
using Flux: crossentropy, @epochs
using Flux.Data: DataLoadermodel = vgg19()
opt = Momentum(.001, .9)
loss(x, y) = crossentropy(model(x), y)
data = DataLoader(trainX, trainY, batchsize=64)
@epochs 100 Flux.train!(loss, params(model), data, opt)
这里的代码同样冗长，但是不同语言之间的差异显而易见。在 Python 中，model.fit返回包含准确度和损失评估的字典。它也有关键字参数来自动优化过程。朱莉娅更瘦了。训练算法要求用户提供他们自己的损失函数、优化器和包含批量数据的迭代程序以及模型。
Python 实现更加用户友好。培训过程很容易，并产生有用的输出。Julia 对用户的要求更高一些。同时，Julia 更加抽象，允许任何优化器和损失函数。用户可以以任何方式定义损失函数，而无需查阅内置损失函数列表。这种抽象是 Julia 开发人员的典型特征，他们致力于使代码尽可能的抽象和通用。
由于这个原因，Keras 对于实现已知技术和标准模型训练更实用，但使 Flux 更适合于开发新技术。
速度
弗洛里安·斯特丘克在 Unsplash 上拍摄的照片
不幸的是，互联网上没有比较 Flux 和 Keras 的可用基准。有几个资源给了我们一个思路，我们可以使用 TensorFlow 速度作为参考。
一项基准测试发现，在 GPU 和 CPU 上， Flux 几乎不比 TensorFlow 慢。已经证明 Keras 在 GPU 上也比 TensorFlow 稍慢。不幸的是，这并没有给我们一个明确的赢家，但表明两个包的速度是相似的。
上面的 Flux 基准测试是在 Flux 的自动差异软件包进行重大返工之前完成的。新的软件包 Zygote.jl 大大加快了计算速度。在 CPU上的一个更近的通量基准发现改进的通量比 CPU 上的 TensorFlow 更快。这表明 Flux 在 GPU 上也可以更快，但在 CPU 上获胜并不一定意味着在 GPU 上的胜利。同时，这仍然是 Flux 将在 CPU 上击败 Keras 的好证据。
谁赢了？
两种语言在各个领域都表现出色。两者之间的差异很大程度上是口味问题。然而，每种语言都有两个优势。
Python 的边缘
Python 有一个庞大的支持社区，并提供经过时间考验的库。它是可靠和标准的。Python 中的深度学习要普遍得多。使用 Python 进行深度学习的开发者会很好地融入深度学习社区。
朱莉娅的优势
茱莉亚更干净，更抽象。深度学习代码肯定会更快，改进工作正在进行中。朱莉娅有潜力。Python 中的深度学习库要完整得多，没有那么大的发展潜力。Julia 拥有更丰富的基础语言，在未来可能会有许多新的想法和更快的代码。采用 Julia 的开发人员将更接近编程的前沿，但将不得不处理打造自己的道路。
赢家
深度学习很难，需要大量的故障排除。很难达到目前的精确度。正因如此， Python 赢得了这次比较。Julia 中的深度学习没有对深度学习故障排除的强大在线支持。这可能会使编写复杂的深度学习脚本变得非常困难。Julia 对于很多应用都很优秀，但是对于深度学习，我会推荐 Python。
亲自看
medium.com](https://medium.com/swlh/how-julia-uses-multiple-dispatch-to-beat-python-8fab888bb4d8) [## 已经会 Python 了怎么学 Julia
跳到好的方面
towardsdatascience.com](/how-to-learn-julia-when-you-already-know-python-641ed02b3fa7)
参考资料:
[1]，何，，，，，，，【用于图像识别的深度残差学习，2016 .
[2]卡伦·西蒙扬，安德鲁·齐泽曼，用于大规模图像识别的极深度卷积网络，国际学习表征会议，2015
深度学习:用 TensorFlow 解决问题
了解如何解决优化问题，并使用 MNIST 数据集训练您的第一个神经网络！
图片来自 Unsplash
介绍
本文的目标是用 TensorFlow 定义和解决实际用例。为此，我们将解决:
- 最优化问题
- 线性回归问题，我们将调整回归直线到数据集
- 并且我们将结束用 MINST 数据集解决深度学习分类项目的“Hello World”。
优化问题
网飞决定在一栋大楼里放置他们的一张著名海报。营销团队已经决定，广告海报的面积必须达到 600 平方米，上下各 2 米，左右各 4 米。
然而，他们没有被告知该建筑的立面尺寸。我们可以发一封电子邮件给业主，问他，但由于我们知道数学，我们可以很容易地解决它。我们怎样才能知道这座建筑物的尺寸？
按作者分列的数字
该建筑的总面积为:
宽度= 4 + x + 4 = x +8
身高= 2 + y + 2 = y +4
面积=宽度 x 高度= (x + 8)*(y + 4)
并且存在约束: x*y = 600
这允许我们写出一个方程系统:
xy = 600 → x = 600/y
S(y)=(600/y+8)(y+4)= 600+8y+4 * 600/y+32 =632+8y+2400/y
在优化问题中，函数(导数)的斜率信息用于计算其最小值。我们必须使一阶导数等于 0，然后检查二阶导数是否为正。所以，在这种情况下:
S '(y)= 8–2400/y
S’'(y) = 4800/y
s '(y)= 0→0 = 8–2400/y→8 = 2400/y→y = 2400/8 = 300→**y =**sqrt(300)= sqrt(100–3)= sqrt(100)-sqrt(3)= 10-sqrt(3)=17.32(我们舍弃负号，因为它没有物理意义)
在 x 中替换:
**x =**600/10-sqrt(3)= 60/sqrt(3)= 60-sqrt(3)/sqrt(3)-sqrt(3)= 60-sqrt(3)/3 = 20-sqrt(3)=34.64
至于 y = 17.32 -> S’'(y) = 0.9238 > 0，我们找到了最小解。
因此，建筑的尺寸为:
宽度:x + 8 = 42.64 米
高度:y + 4 = 21.32 米
你看到衍生品有多有用了吗？我们只是分析性地解决了这个问题。我们已经能够解决它，因为这是一个简单的问题，但有许多问题，它是非常昂贵的计算来解决他们的分析，所以我们使用数值方法。这些方法之一是梯度下降。
如果我们这次用张量流数值解决这个问题，你觉得怎么样？我们走吧！
import numpy as np
import tensorflow as tfx = tf.Variable(initial_value=tf.random_uniform([1], 34, 35),name=’x’)
y = tf.Variable(initial_value=tf.random_uniform([1], 0., 50.), name=’y’)# Loss function
s = tf.add(tf.add(632.0, tf.multiply(8.0, y)), tf.divide(2400.0, y), ‘s’)opt = tf.train.GradientDescentOptimizer(0.05)
train = opt.minimize(s)sess = tf.Session()init = tf.initialize_all_variables()
sess.run(init)old_solution = 0
tolerance = 1e-4
for step in range(500):
sess.run(train)
solution = sess.run(y)
if np.abs(solution — old_solution) < tolerance:
print(“The solution is y = {}”.format(old_solution))
break
old_solution = solution
if step % 10 == 0:
print(step, “y = “ + str(old_solution), “s = “ + str(sess.run(s)))
我们已经使用梯度下降算法计算出了 y 。当然，我们现在需要计算 x 代入 x = 600/y
x = 600/old_solution[0]
print(x)
这与我们的结果相符，所以它似乎是有效的！让我们画出结果:
import matplotlib.pyplot as plty = np.linspace(0, 400., 500)
s = 632.0 + 8*y + 2400/y
plt.plot(y, s)
print("The function minimum is in {}".format(np.min(s)))
min_s = np.min(s)
s_min_idx = np.nonzero(s==min_s)
y_min = y[s_min_idx]
print("The y value that reaches the minimum is {}".format(y_min[0]))
让我们看看其他例子
在这种情况下，我们希望找到 y = log2(x)函数的最小值。
x = tf.Variable(15, name='x', dtype=tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)init = tf.initialize_all_variables()def optimize():
with tf.Session() as session:
session.run(init)
print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
for step in range(100):
session.run(train)
print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()
我们来策划一下吧！
x_values = np.linspace(0,10,100)
fx = np.log(x_values)**2
plt.plot(x_values, fx)print("The function minimum is in {}".format(np.min(fx)))
min_fx = np.min(fx)
fx_min_idx = np.nonzero(fx==min_fx)
x_min_value = x_values[fx_min_idx]
print("The y value that reaches the minimum is {}".format(x_min_value[0]))
让我们解决一个线性回归问题
让我们看看如何将一条直线调整到一个数据集，这个数据集代表了辛普森一家中每个角色的智力，从拉尔夫·威根到弗林克医生。
让我们绘制智力随年龄的分布图，从 0 到 1 归一化，其中玛吉最小，蒙哥马利·伯恩斯最大:
n_observations = 50
_, ax = plt.subplots(1, 1)
xs = np.linspace(0., 1., n_observations)
ys = 100 * np.sin(xs) + np.random.uniform(0., 50., n_observations)
ax.scatter(xs, ys)
plt.draw()
按作者分列的数字
现在，我们需要两个 tf .占位符，一个在回归算法的入口，另一个在出口。占位符是在执行网络之前不需要赋值的变量。
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
让我们试着优化线性回归的直线。我们需要两个变量，权重(W)和偏差(b)。tf 类型的元素。变量需要初始化，并且其类型在声明后不能更改。我们可以通过“赋值”方法改变它的值。
W = tf.Variable(tf.random_normal([1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')
Y_pred = tf.add(tf.multiply(X, W), b)
现在让我们把成本函数定义为我们的预测值和真实值之间的差值。
loss = tf.reduce_mean(tf.pow(Y_pred - y, 2))
我们现在定义优化方法，我们将使用梯度下降。基本上，它计算每个权重相对于总误差的变化，并更新每个权重，使得总误差在随后的迭代中减小。学习率表示权重更新的突然程度。
learning_rate = 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)**# Definition of the number of iterations and start the initialization using the GPU**
n_epochs = 1000with tf.Session() as sess:
with tf.device("/GPU:0"): **# We initialize now all the defined variables**
sess.run(tf.global_variables_initializer()) **# Start the adjust**
prev_training_loss = 0.0
for epoch_i in range(n_epochs):
for (x, y) in zip(xs, ys):
sess.run(optimizer, feed_dict={X: x, Y: y}) W_, b_, training_loss = sess.run([W, b, loss], feed_dict={X: xs, Y: ys}) **# We print the losses every 20 epochs**
if epoch_i % 20 == 0:
print(training_loss) **# Ending conditions**
if np.abs(prev_training_loss - training_loss) < 0.000001:
print(W_, b_)
break
prev_training_loss = training_loss **# Plot of the result**
plt.scatter(xs, ys)
plt.plot(xs, Y_pred.eval(feed_dict={X: xs}, session=sess))
按作者分列的数字
我们有了！有了这条回归线，我们将能够预测每个辛普森的性格的智力知道年龄。
MNIST 数据集
现在让我们看看如何用逻辑回归对数字图像进行分类。我们将使用深度学习数据集的“Hello world”。
让我们导入相关的库和数据集 MNIST:
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
我们通过用一键编码对标签进行编码来加载数据集(它将每个标签转换为长度= N_CLASSES 的向量，除了指示图像所属的类的索引(包含 1)之外，所有的 0 都是 0)。比如我们有 10 个类(数字从 0 到 9)，标签属于数字 5:label =[0 0 0 1 0 0 0 0 0]。
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)print("Train examples: {}".format(mnist.train.num_examples))
print("Test examples: {}".format(mnist.test.num_examples))
print("Validation examples: {}".format(mnist.validation.num_examples))**# Images are stored in a 2D tensor: images_number x image_pixels_vector
# Labels are stored in a 2D tensor: images_number x classes_number (one-hot)**
print("Images Size train: {}".format(mnist.train.images.shape))
print("Images Size train: {}".format(mnist.train.labels.shape))**# To see the range of the images values**
print("Min value: {}".format(np.min(mnist.train.images)))
print("Max value: {}".format(np.max(mnist.train.images)))**# To see some images we will acess a vector of the dataset and resize it to 28x28**
plt.subplot(131)
plt.imshow(np.reshape(mnist.train.images[0, :], (28, 28)), cmap='gray')
plt.subplot(132)
plt.imshow(np.reshape(mnist.train.images[27500, :], (28, 28)), cmap='gray')
plt.subplot(133)
plt.imshow(np.reshape(mnist.train.images[54999, :], (28, 28)), cmap='gray')
我们已经了解了 MNIST 数据集的一些内容。现在，让我们创建我们的回归变量:
首先，我们为输入数据创建占位符。在这种情况下，输入将是一组大小为 768 的向量(我们将一次传递几个图像到我们的回归器，这样，当它计算梯度时，它将在几个图像中扫描，因此估计将比它只使用一个图像更精确)
n_input = 784 **# Number of data features: number of pixels of the image**
n_output = 10 **# Number of classes: from 0 to 9**
net_input = tf.placeholder(tf.float32, [None, n_input]) **# We create the placeholder**
现在让我们定义回归方程:y = W*x + b
W = tf.Variable(tf.zeros([n_input, n_output]))
b = tf.Variable(tf.zeros([n_output]))
由于输出是多类的，我们需要一个函数返回图像属于每个可能类的概率。例如，如果我们放一个 5 的图像，可能的输出是:[0.05 0.05 0.05 0.05 0.55 0.05 0.05 0.05 0.05 0.05]其概率之和是 1，概率最高的类是 5。
我们应用 softmax 函数来归一化输出概率:
net_output = tf.nn.softmax(tf.matmul(net_input, W) + b)
SoftMax 函数
**# We also need a placeholder for the image label, with which we will compare our prediction And finally, we define our loss function: cross entropy**
y_true = tf.placeholder(tf.float32, [None, n_output])**# We check if our prediction matches the label**
cross_entropy = -tf.reduce_sum(y_true * tf.log(net_output))
idx_prediction = tf.argmax(net_output, 1)
idx_label = tf.argmax(y_true, 1)
correct_prediction = tf.equal(idx_prediction, idx_label)**# We define our measure of accuracy as the number of hits in relation to the number of predicted samples**
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))**# We now indicate that we want to minimize our loss function (the cross entropy) by using the gradient descent algorithm and with a rate of learning = 0.01.**
optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
现在一切都设置好了！让我们执行图表:
from IPython.display import clear_outputwith tf.Session() as sess: sess.run(tf.global_variables_initializer()) **# Let's train the regressor**
batch_size = 10
for sample_i in range(mnist.train.num_examples):
sample_x, sample_y = mnist.train.next_batch(batch_size)
sess.run(optimizer, feed_dict={net_input: sample_x,
y_true: sample_y}) **# Let's check how is performing the regressor**
if sample_i < 50 or sample_i % 200 == 0:
val_acc = sess.run(accuracy, feed_dict={net_input: mnist.validation.images, y_true: mnist.validation.labels})
print("({}/{}) Acc: {}".format(sample_i, mnist.train.num_examples, val_acc))**# Let's show the final accuracy**
print('Teste accuracy: ', sess.run(accuracy, feed_dict={net_input: mnist.test.images, y_true: mnist.test.labels}))
我们刚刚用 TensorFlow 训练了我们的第一个神经元网络！
想一想我们刚刚做了什么。
我们实现了一个逻辑回归，公式为:y = G(Wx + b)，其中 G = softmax()，而不是典型的 G = sigmoid()。
如果你看下图，它定义了感知器(单层神经网络)，你可以看到输出=激活 _ 功能(Wx)。你看到了吗？只差偏了！注意输入是 1？所以权重 w0 没有乘以任何东西。没错。权重 w0 是偏差，用这种符号表示只是为了能够将其实现为矩阵乘法。
所以，我们刚刚实现的是一个感知器
- 批处理大小= 10
- 1 个纪元
- 下降梯度作为优化器
- 和 softmax 作为激活函数。
最后的话
一如既往，我希望你喜欢这篇文章，你已经学会了如何使用 TensorFlow 来解决线性问题，并且你已经成功地训练了你的第一个神经网络！
如果你喜欢这篇帖子，那么你可以看看我在数据科学和机器学习方面的其他帖子。
如果你想了解更多关于机器学习和人工智能的知识 请在 Medium 上关注我，敬请关注我的下一篇帖子！
深度学习跳跃
Maxime Bergeron & Ivan Sergienko，Riskfuel
在这篇简短的笔记中，我们描述了一个跳转单元，它可以用来用一个简单的神经网络拟合阶跃函数。我们的动机来自于经常出现不连续性的定量金融问题。
(图片由作者提供)
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
为什么要跳？
不连续函数在金融工具中是常见的。例如，下图显示了典型的五年期固定利率债券的价格，票面利率为半年。我们设定的票面利率高于贴现率，所以债券的价值保持在票面价值 100 美元以上。如果你不熟悉债券定价，这里有一本很好的入门书。
(图片由作者提供)
为了我们的目的，需要注意的重要事情是在每个息票支付日发生的跳跃。这仅仅是因为钱不可能凭空产生。证券所有者的“财富”在息票前后保持不变。因此，我们有:
息票前价值=息票后价值+息票现金。
在行权日，更复杂的路径依赖型金融衍生品的价值也会出现类似的跃升。这里的一个经典例子是百慕大互换期权，这是一种用于管理抵押贷款提前还款风险的流行工具。百慕大式期权可以在价值可能跃升的预定日期行使。
(图片由作者提供)
为了使事情具体化，我们将把注意力集中在学习具有单一向下跳跃的分段常数函数的子问题上。我们生成的训练数据如上图所示。请读者跟随我们在这个 Jupyter 笔记本中的代码。
Sigmoid 函数
那么我们机器如何学习跳跃呢？这里一个自然的方法是使用一个 s 形*。*然而，在我们的问题中，步骤是尖锐的。息票支付日期左边的所有点都严格位于右边的点之上，这导致了真正的不连续。拟合简单的一维神经网络
(图片由作者提供)
包括夹在两个线性层之间的 s 形激活函数需要初始线性层中的无界系数(权重)。数量无限增长对于数值方法来说总是坏消息，但对于神经网络来说情况更糟。事实上，这导致了臭名昭著的爆炸梯度问题，使最佳参数值几乎不可能学习。我们将不得不通过保持大而有限的权重来进行妥协，从而导致输入的一个区域(就在跳跃附近)难以消除显著的误差。
(图片由作者提供)
我们能做得更好吗？
亥维赛函数
为什么不简单地用…一个跳跃来学习一个跳跃呢？用不连续的激活来代替上面一维网络中的 sigmoid 函数是很有诱惑力的。这里最简单的候选函数是 Heaviside 阶跃函数 H(x) ，对于 x < 0 它等于 0 ，否则等于 1 :
(图片由作者提供)
这是一个显而易见的想法，它会立即导致如下图所示的失败:
(图片由作者提供)
为了理解这里的问题，让我们看看数学。我们的小神经网络对应的损失函数是:
这里， yᵢ 是对应于时间 *tᵢ的训练数据值，*子脚本 w 项是最后一个线性层的权重，子脚本 b 项是来自两个线性层的偏差。敏锐的读者会注意到，在不失一般性的情况下，我们已经将第一个线性层的权重设置为 1 ，剩余的权重和偏差决定了台阶的大小和位置。深度学习所依赖的用于最小化误差函数的梯度下降方法需要使用一阶导数。在这方面，其中一个问题很大:
这里的问题是第二个因素，当 b 和 t 项相互抵消时，这个因素就会爆发。下面的图清楚地说明了这个问题:函数是分段常数！
(图片由作者提供)
虽然实际的最小值是我们期望的，但基于梯度的方法永远达不到它。相反，这一过程陷入了一个小平台。
事实上，这个问题是 sigmoid 函数成为机器学习的主要内容的原因之一。用 sigmoidal 函数代替 Heaviside 函数允许通过梯度下降成功地训练复杂的神经网络，例如多层感知器。
在这一点上，可能会开始觉得我们在兜圈子。s 形函数在拟合急剧跳跃方面用处有限，但它们的引入是为了解决 Heaviside 函数的明显问题。
跳跃单元
下表总结了前面两个部分，并显示了当面临学习锐阶跃函数的任务时，我们对这两个激活函数的喜欢和不喜欢之处:
一个自然的问题是，我们是否可以将这两种功能结合起来，保留我们喜欢的功能，丢弃我们不喜欢的功能。进入跳转单元，如下图所示:
(图片由作者提供)
它由三个线性节点以及平行排列的 sigmoid 和 Heaviside 激活函数组成。为了理解这个单元如何工作，考虑它编码的等式:
为了简化方程，我们省略了 sigmoid 激活之后的线性层中的偏置项，因为它是由 Heaviside 激活之后的线性层的偏置项来解决的。现在让我们看看之前有问题的导数:
由于麻烦的偏差项现在出现在 S(-) 和H(-)的论证中，其梯度在大多数点不再消失，网络能够学习。请注意，在这个过程的最后，我们还希望 sigmoid 激活后的线性层的重量消失，这样只有 Heaviside 贡献保留下来。
(图片由作者提供)
上面的图显示了我们的跳转单元的 MSE 误差作为它的两个关键参数的函数。我们看到，沿着偏置轴的阶跃之间的平台现在是倾斜的，允许基于梯度的算法学习全局最小值。
最后，我们画出结果函数，瞧！
(图片由作者提供)
结论
总之，我们已经展示了如何结合 sigmoidal 和 Heaviside 激活函数的优点和缺点来产生能够通过梯度下降学习不连续阶跃函数的跳跃单元。
我们鼓励读者在这款 Jupiter 笔记本中亲自尝试一下！
在 MacBook 上使用 GPU 进行深度学习
使用 PlaidML 并利用 AMD/Intel GPU 进行深度学习
我有 GPU，我学得很深
作为一名 MacBook Pro 的拥有者，我意识到无法利用其 GPU 进行深度学习的沮丧，考虑到难以置信的质量和纹理，当然还有它的价格。我还记得当我在 MacBook Pro 13 '和 15 '之间选择时，当时我对数据科学一点都不熟悉，我选择 15 '只是因为它有一个独立的 AMD GPU。很快我发现，在机器学习&深度学习方面，额外的一块 GPU 几乎没有带来任何帮助。长期以来，大多数现代机器学习模型只能通过通用 GPU 库 CUDA 来利用 Nvidia GPUs。
然而，现在已经是 2020 年了，今天的事情可能会有点不同: PlaidML 最初是由 Vertex 在 2017 年发布的。AI 旨在带来*“面向每个平台的深度学习”。自从 2018 年被英特尔*收购以及之后的 0.3.3 版本发布以来，你可以利用你的 AMD 和英特尔 GPU 用 Keras 做并行深度学习工作。自今年 1 月 15 日发布 0.7.0 版本以来， PlaidML 为所有主要目标的 GPU & CPU 提供了完整的条带后端。但首先，我们为什么需要用 GPU 做并行计算？
房屋建筑的例子
让我们以建造一所房子为例:如果你独自一人，比方说建造房子可能需要 400 个小时。然而，如果你雇佣一个额外的建筑工人和你一起建造，只需要 200 个小时，因为你把工作分成了一半。同样，你雇佣的工人越多，你就能越快地把房子建好。有一个众所周知的阿姆达尔定律描述了当我们增加更多的处理器(工作者)时，一个程序可以加速到什么程度。
好吧，那么为什么要用 GPU 呢？GPU，也就是众所周知的图形处理单元，显然一开始就不是为做深度学习而设计的。然而，并行计算的本质似乎与图形处理类似:GPU 的内核虽然较弱，但由于其高度并行的结构和内核数量，对于处理大数据块的算法来说，GPU 的内核比 CPU 更高效(GPU 由数百个计算能力较弱的内核组成，而 CPU 通常由 4 到 32 个更强大的内核组成)。由于图形处理和深度学习的内在本质相似(大多数操作可以同时完成，而不是一个接一个)，GPU 成为深度学习和并行计算时自然的首选。
正如我最喜欢的一句来自 Linus Torvalds 的名言所说:
“空谈是廉价的。给我看看代码。”
让我们动手，使用您自己的笔记本电脑，使用您的 GPU 运行一个简单的 CNN 案例！
1.安装和设置 PlaidML 和相关组件
首先，确保你的笔记本电脑有一个工作的 Python3 环境。我建议随时在虚拟环境下运行:
请记住，TensorFlow 下的 Keras 将无法使用 PlaidML。
设置 PlaidML 第 1 部分
首先你会看到一个欢迎页面和一个询问你是否使用实验设备支持的问题。正如它所建议的，使用实验设备会导致性能下降、崩溃和其他问题，您可以键入“n”或什么都不输入，然后返回选择使用默认配置设备。
设置 PlaidML 第 2 部分
现在你得到了一个你可以选择的所有设备的列表。对于我的 Macbook Pro 15’ 2018，以下选项为:
- 我的 CPU
- 我的英特尔 UHD 显卡 630 GPU
- 我的 AMD 镭龙 pro 560x GPU
我选择 3 是因为 AMD 是目前最强大的。
设置 PlaidML 第 3 部分
最后，键入“y”或什么都不输入，然后返回保存设置。现在，您已经完全设置好了，并准备好使用您的 GPU 进行深度学习项目。
2.在时尚 mnist 数据集上构建简单 CNN 分类器的教程:
首先，让我们启动一个 Jupyter 笔记本。(不确定为什么使用 Jupyter 笔记本或如何使用？查看我的上一篇文章了解更多详情)。
您需要按照正确的顺序运行这几行代码，以利用 PlaidML 作为 Keras 后端，否则它将默认使用 TensorFlow。
现在我们导入包并下载时尚数据集。
我们将使用 Keras 序列模型构建一个简单的 CNN(卷积神经网络)并编译它。
现在我们拟合模型并测试准确性。
模型结果
我们训练了一个 CNN 模型，仅用了大约 2 分钟就对时尚数据集进行了 91%的分类。你可能认为这并不令人印象深刻，但是看看与我的笔记本电脑的 CPU 的比较:
结论
从上面的比较中我们可以看到，在我的 MacBook Pro 上使用 GPU 比使用 CPU 运行这个简单的 CNN 代码快大约 15 倍。在 PlaidML 的帮助下，用自己的笔记本电脑做深度学习不再是无法忍受的事情。这个项目的完整脚本可以在我的 github 找到。
截止到今天(2020 年 2 月)， PlaidML 已经支持 Keras 、 ONNX 和 NGraph 。它在 GPU 上运行良好，并且不需要在 Nvidia 硬件上使用 CUDA/cuDNN，同时实现可比的性能。在 PlaidML github 页面上有更多的演示和相关项目。现在你 GPU 可能还不能得到 PlaidML 的完全支持，但是我相信很快 GPU 学习将不再是 Nvidia T21 的特权。
用 PyTorch 深度学习表格数据
这篇文章将通过一个真实的例子为您提供使用 Pytorch 处理表格数据的详细的端到端指南。在本文结束时，您将能够构建您的 Pytorch 模型。
开始前有几件事:
课程:我同时开始了 fast.ai 课程和deep learning . aispecialization(Coursera)。他们给了我关于深度学习的基础知识。伟大的斯坦福 cs231n 也强烈推荐。
看的课程越来越多，非常容易。我认为最重要的是**【动手】**。写代码！开始一个项目或尝试解决一个难题。
T 何数据
我选择从事 Kaggle 的纽约市出租车费用预测工作，该公司的任务是预测乘客的出租车费用。请注意，这是一个回归问题。你可以在这里找到更多细节和完整数据集。
训练数据包含超过 200 万个样本(5.31 GB)。为了最大限度地减少训练时间，我们随机抽取了 100k 个训练样本。
import pandas
import randomfilename = r"C:\Users\User\Desktop\offir\study\computer learning\Kaggle_comp\NYC Taxi\train.csv"n = sum(1 for line in open(filename)) - 1 #number of records in file (excludes header)
s = 100000 #desired sample size
skip = sorted(random.sample(range(1,n+1),n-s)) #the 0-indexed header will not be included in the skip listdf = pandas.read_csv(filename, skiprows=skip)
df.to_csv("temp.csv")
国家政治保卫局。参见 OGPU
我用免费的谷歌实验室写了我的代码。
要使用 GPU:运行时->更改运行时设置->硬件加速器-> GPU。
密码
导入相关库
运行以下命令后，您需要从您的计算机上传 CSV 文件。检查您上传的 CSV 文件是否命名为 sub_train。
也上传测试集
数据预处理
下一步是删除所有小于 0 的票价(它们没有意义)
df_train 现在的长度是 99990。在每个步骤中记录不同数据集的类型和长度非常重要。
堆叠训练集和测试集，使它们经历相同的预处理
目标是预测票价金额。因此，将其从 train_X 数据帧中删除。
而且，我选择了一边训练一边预测价格的 log。解释超出了这篇博客的范围。
特征工程
让我们做一些特征工程。
一个是定义 haverine_distatance 函数，并添加一个 DateTime 列来导出有用的统计信息。你可以在 GitHub 回购 中看到完整的流程。
在这个阶段之后，数据帧看起来像这样:
准备模型
定义分类列和连续列，并且只采用相关的列。
将 cat 类别设为“category”类型，并将其标记为 encoder。
定义分类列的嵌入大小。确定嵌入大小的经验法则是将每列中唯一条目的数量除以 2，但不超过 50。
现在我们来处理连续变量。在规范化它们之前，重要的是在训练集和测试集之间进行划分，以防止数据泄漏。
列车有效分离
在定型集和验证集之间拆分。在这种情况下，验证集占总训练集的 20%。
X_train, X_val, y_train, y_val = train_test_split(X, Y, test_size=0.20, random_state=42,shuffle=**True** )
在这一步之后，重要的是看看不同的形状。
模型
目前，我们的数据存储在熊猫数组中。PyTorch 知道如何与张量合作。以下步骤将把我们的数据转换成正确的类型。跟踪每一步中的数据类型。我添加了当前数据类型的注释。
是时候使用 PyTorch DataLoader 了。我选择的批量是 128，随便玩玩吧。
定义一个表格模型
目标是基于连续列的数量+分类列的数量及其嵌入来定义一个模型。输出将是一个单浮点值，因为它是一个回归任务。
- ps:每层的丢失概率
- emb_drop:提供嵌入丢弃
- emd_szs:元组列表:每个分类变量的大小与一个嵌入大小成对出现
- 连续变量的数量
- out_sz:输出大小
为预测设置 y_range(可选)，并调用模型。请随意使用输入。
该模型如下所示:
定义一个优化器。我选择了学习率为 1e-2 的亚当。学习是你应该调整的第一个超参数。此外，使用学习率有不同的策略(拟合一个周期、余弦等)。这里我使用一个恒定的学习率。
训练和健身
训练你的模型。试着跟踪和理解每一步。使用 set_trace()命令非常有帮助。评估指标是 RMSE。
将输入传递给 fit 函数。在这种情况下，损失函数是 MSEloss。
绘制列车与验证损失图
完成培训部分
在玩了模型和调整了超参数之后，你就达到了满意的程度。只有这样，你才能进入下一步:在测试集上测试你的模型。
测试集
请记住:您的测试必须经历与训练集相同的过程(我们已经这样做了)。接下来的步骤是“准备”接受评估。
分为分类列和连续列，并使它们成为张量。
做一个预测
好吧，你终于做出了预测！恭喜你。
注意，预测现在是一个张量。如果您想将其更改为熊猫数据框，请完成回购中的步骤。接下来，您可以将其导出为 CSV 文件。
如果你在做 Kaggle 比赛，上传到 Kaggle 看看你的分数。
结论
总之，您了解了如何从头开始为表格数据构建 PyTorch 模型。你必须扔掉全部代码，并努力理解每一行。
如果您有任何问题、意见或担忧，请不要忘记通过 Linkedin 与我联系。
开始工作！
参考文献:
- https://towardsdatascience . com/deep-learning-for-table-data-using-py torch-1807 f 2858320
- https://yashuseth . blog/2018/07/22/py torch-neural-network-for-tabular-data-with-category-embedding/
- http://francescopochetti . com/py torch-for-table-data-predicting-NYC-taxi-fares/
深度学习与机器学习
由 Unsplash 上的 Pietro Jeng 拍摄
这些流行语到底是什么意思？而机器和深度学习的区别是什么？
介绍
近年来，机器学习、深度学习和人工智能已经成为热门词汇，在越来越多公司的营销材料和广告中随处可见。但是什么是机器学习和深度学习，它们之间有什么区别？在本文中，我将尝试回答这些问题，并向您展示一些深度和机器学习应用的案例。
什么是机器学习？
机器学习是计算机科学的一部分，它基于数据，用数学模型来表示现实世界的事件或对象。这些模型是用特殊算法构建的，这些算法调整模型的一般结构，使其适合训练数据。根据所解决问题的类型，我们定义了有监督和无监督的机器学习以及机器学习算法。受监督的机器学习专注于创建模型，这些模型能够将我们手头已经拥有的关于数据的知识转移到新数据，在训练阶段建模(训练)算法看不到这些新数据。我们提供了一种算法，该算法具有特征数据以及该算法应该学会从中推断的相应值(所谓的目标变量)。在无监督的机器学习中，我们只为算法提供特征，允许它自己找出它们的结构和/或依赖性。没有指定明确的目标变量。无监督学习的概念一开始可能很难理解，但是看一看下面四个图表中提供的例子应该会让这个想法变得清晰。
图表 1a
图表 1b
图表 1a 给出了一些数据，这些数据用轴 x 和 y 上的两个特征来描述。图表 1b 显示了相同颜色的数据。我们使用 K-means 聚类算法将这些点分组为 3 个簇，并相应地对它们进行着色。这是一个无监督机器学习算法的例子。算法只给出特征，标签(聚类数)要算出来。
图表 2a
图表 2b
图表 2a 显示了一组不同的标记(并相应地着色)数据。我们先验地知道每个数据点所属的组*。我们使用 SVM 算法找到两条直线，这两条直线将向我们展示如何分割数据点以最适合这些组。这种分割并不完美，但这是用直线能做到的最好的了。如果我们想要将一个组分配给一个新的、未标记的数据点，我们只需要检查它在平面上的位置。这是一个由监督的机器学习应用的例子。*
机器学习模型的应用
创建标准的机器学习算法是为了处理表格形式的数据。这意味着，为了使用它们，我们需要某种类型的表，其中的行可以被认为是建模对象的实例(例如，贷款)，而列是这个特定实例的特征(特性)(例如，贷款的月还款额、借款人的月收入)。表 1。是这类数据的一个很短的例子。当然，这并不意味着纯数据本身必须是表格和结构化的。但如果我们想在一些数据集上应用标准的机器学习算法，我们通常必须首先清理、混合并将其转换为表格。在监督学习中，还有一个包含目标值的特殊列(例如，贷款是否违约的信息)。训练算法通过调整模型的参数来尝试使模型的一般结构适合这些数据，以便得到的模型尽可能准确地描述给定数据和目标变量之间的关系。重要的是，该模型不仅很好地符合给定的训练数据，而且还能够进行概括。一般化意味着我们可以使用该模型来推断训练期间没有使用的实例的目标。泛化是一个有用模型的关键特征。构建一个良好概括的模型不是一件容易的事情，通常需要复杂的验证技术和全面的模型测试。
表 1。表格形式的贷款数据
机器学习算法被用于各种应用中。表二。介绍一些可以应用非深度机器学习算法和模型的业务用例，以及对潜在数据、目标变量和选定的适用算法的简短描述。
表二。机器学习用例的例子
深度学习和深度神经网络
深度学习是机器学习的一部分，其中我们使用一种特定类型的模型，称为深度人工神经网络(ann)。自从它们被引入以来，人工神经网络经历了广泛的进化过程，产生了许多亚型，其中一些非常复杂。但是为了介绍它们，最好解释一下它们的一种基本形式——多层感知器(MLP)。
简而言之，MLP 具有顶点(也称为神经元)和边(由称为权重的数字表示)的图形(网络)形式。神经元按层排列，并且连续层中的神经元相互连接。数据通过网络从输入层流向输出层，在神经元和神经元之间的边缘进行转换。一旦一个数据点通过整个网络，输出层在其神经元中包含预测值。每次有一大块训练数据通过网络时，我们都会将预测值与相应的真实值进行比较，并调整模型的参数(权重)以使预测更好。这是通过一种叫做反向传播的算法实现的。经过一定次数的迭代后，如果模型的结构设计得很好，专门用于处理手头的机器学习问题，并且足够的数据已经多次通过网络，我们就可以获得高精度的模型。在实践中，有大量的转换可以应用于神经元，使人工神经网络非常灵活和强大。然而，人工神经网络的强大是有代价的。通常，模型的结构越复杂，将它训练到高精度所需的数据和时间就越多。
图一。一个 4 层人工神经网络的结构，根据三个简单的特征预测一个新闻应用程序的用户下个月是否会流失。为了清楚起见，仅标记了选定(粗体)边的权重，但是每个边都有自己的权重。数据从输入层流向输出层，通过中间的两个隐藏层。在每条边上，输入值乘以边的权重，所得乘积将到达边结束的节点。然后，在隐藏层的每个节点中，来自边缘的输入信号被求和，然后用某种函数进行变换。然后，这些转换的结果被视为下一层的输入。在输出层，传入的数据再次被汇总和转换，产生两个数字形式的结果——用户在下个月离开应用的概率，以及他们不离开的概率。
在更高级类型的神经网络中，各层具有更复杂的结构。它们不仅由 MLPs 中已知的具有单操作神经元的简单密集层组成，还包括更复杂的多操作层，如卷积层和递归层。卷积层主要用于计算机视觉应用。它们由在图像的像素表示上滑动的小型数字阵列组成。像素值乘以这些数字，然后聚合，产生新的、压缩的图像表示。递归层用于建模有序的序列数据，如时间序列或文本。他们对输入的数据应用复杂的多参数转换，试图找出序列项之间的依赖关系。然而，无论网络的类型和结构如何，总有一些(一个或多个)输入和输出层，以及数据在网络中流动的严格定义的路径和方向。
一般来说，深度神经网络是具有多个层的 ann。下图 1、2 和 3 显示了选定深度人工神经网络的架构。它们都是在谷歌开发和培训的，并向公众开放。他们给出了当今使用的高精度深度人工网络有多复杂的想法。
这些网络规模巨大。例如，图 3 中部分显示的 InceptionResNetV2 有 572 层，总共超过 5500 万个参数！它们都是作为图像分类模型开发的(它们为给定的图像分配一个标签，例如“汽车”)，并在 ImageNet 集合的图像上进行训练，该集合包含超过 1400 万个带标签的图像。
图二。NASNetMobile 的结构
图 3。例外结构
图 4。InceptionResNetV2 的一部分(约 25%)的结构
近年来，我们观察到深度学习及其应用的巨大发展。我们的智能手机和应用程序的许多“智能”功能都是这一进步的成果。虽然人工神经网络的想法并不新鲜，但最近的繁荣是一些条件得到满足的结果。首先，我们发现了 GPU 计算的潜力。图形处理单元的架构非常适合并行计算，对高效的深度学习非常有帮助。此外，云计算服务的兴起使得获取高效硬件变得更加容易、更加便宜，并且有可能在更大范围内实现。最后，最新移动设备的计算能力足以应用深度学习模型，从而为 DNN 驱动的功能创造了一个巨大的潜在用户市场。
深度学习模型的应用
深度学习模型通常适用于处理不具有简单行列结构的数据的问题，如图像分类或语言翻译，因为它们擅长处理这些任务处理的非结构化和复杂结构的数据——图像、文本和声音。使用经典的机器学习算法处理这些类型和大小的数据存在问题，并且创建和应用一些深度神经网络来解决这些问题已经在过去几年中在图像识别、语音识别、文本分类和语言翻译领域中引起了巨大的发展。
将深度学习应用于这些问题是可能的，因为 dnn 接受被称为张量的多维数字表作为输入和输出，并可以跟踪它们的元素之间的空间和时间关系。例如，我们可以将图像表示为 3 维张量，其中第一维和第二维表示数字图像的分辨率(图像宽度和高度的大小也分别如此)，第三维表示每个像素的 RGB 颜色编码(因此第三维的大小为 3)。这使得我们不仅可以用张量表示图像的所有信息，还可以保持像素之间的空间关系，这在所谓的卷积层的应用中至关重要，在成功的图像分类和识别网络中至关重要。
神经网络在输入和输出结构上的灵活性也有助于其他任务，如语言翻译。当处理文本数据时，我们向深度神经网络输入单词的数字表示，根据它们在文本中的出现进行排序。每个单词由一百或几百个数字的向量表示，通过计算(通常使用不同的神经网络)使得对应于不同单词的向量之间的关系模拟单词本身的关系。这些被称为嵌入的向量语言表示，一旦被训练，就可以在许多架构中被重用，并且是神经网络语言模型的核心构件。
表 3。包含将深度学习模型应用于现实生活问题的示例。正如你所看到的，深度学习算法处理和解决的问题比标准机器学习技术解决的任务复杂得多，如表 1 所示。然而，重要的是要记住，今天机器学习可以帮助企业的许多用例不需要如此复杂的方法，并且可以通过标准模型更有效地(和更高的准确性)解决。表 3。也给出了有多少不同类型的人工神经网络层的想法，以及有多少不同的有用的架构可以用它们来构建。
表 3。深度学习用例示例
深度学习模型的优势
深度神经网络最令人印象深刻的应用之一是生成式对抗网络(GANs)的兴起。它们是由 Ian Goodfellow 在 2014 年引入的，此后他的想法被纳入到许多工具中，有些工具取得了惊人的结果。GANs 负责应用程序的存在，这些应用程序使我们在照片中看起来更老，变换图像，使它们看起来像是梵高画的，甚至为多个乐器乐队协调旋律。在训练 GAN 的过程中，两个神经网络竞争。生成器网络从随机输入生成输出，而鉴别器则试图区分生成的实例和真实的实例。在训练期间，生成器学习如何成功地“愚弄”鉴别器，并最终能够创建看起来好像是真实的输出。
值得注意的是，尽管训练深度神经网络是一项计算量非常大的任务，并且可能需要很长时间，但应用经过训练的网络来完成特定任务并不是必须的，特别是如果它同时应用于一个或几个案例。事实上，今天我们能够在智能手机的移动应用程序中运行强大的深度神经网络。甚至有一些专门设计的网络架构在应用于移动设备时非常高效(例如图 1 所示的 NASNetMobile)。尽管与现有技术的网络相比，它们的尺寸小得多，但它们仍然能够获得高精度的预测性能。
人工神经网络的另一个非常强大的功能是迁移学习，它能够广泛使用深度学习模型。一旦我们有了一个根据某些数据(或者是我们自己创建的，或者是从公共存储库中下载的)训练的模型，我们就可以在它的全部或部分基础上构建一个解决我们特定用例的模型。例如，我们可以使用在巨大的 ImageNet 数据集上训练的预训练 NASNetLarge 模型，该模型为图像分配标签，在其结构顶部进行一些小的修改，用一组新的标记图像进一步训练它，并使用它来标记一些特定类型的对象(例如，基于树叶图像的树的种类)。迁移学习非常有用，因为通常训练一个深度神经网络来执行一些实际有用的任务需要大量的数据和巨大的计算能力。这通常意味着数百万个带标签的数据实例，以及数百个图形处理单元(GPU)运行数周。并不是每个人都能负担得起或获得这样的资产，这使得从头构建一个高精度的定制解决方案非常困难，比如说，图像分类。幸运的是，一些预训练的模型(特别是用于图像分类的网络和用于语言模型的预训练嵌入矩阵)已经开源，并且可以以易于应用的形式免费获得(例如，作为神经网络 API Keras 中的模型实例)。
如何为您的应用选择和构建正确的机器学习模型
当你想应用机器学习来解决一个商业问题时，你不需要马上决定模型的类型。通常有几种方法可以测试。一开始从最复杂的模型开始往往很诱人，但是从简单的开始，并逐渐增加所应用的模型的复杂性是值得的。更简单的模型通常在设置、计算时间和资源方面更便宜。此外，他们的结果是评估更高级方法的一个很好的基准。拥有这样的基准可以帮助数据科学家评估他们开发模型的方向是否正确。一个额外的优势是可以重复使用一些以前建立的模型，并将它们与新的模型合并，创建一个所谓的集合模型。混合不同类型的模型通常会产生比单独的组合模型更高的性能指标。此外，通过迁移学习，检查是否有一些预先训练的模型可以用于和适应您的业务案例。
无论您使用什么模型，都要确保数据得到正确处理。记住“垃圾进，垃圾出”的规则。如果提供给模型的训练数据质量很低，或者没有被正确地标记和清理，则很可能得到的模型也将表现不佳。还要确保模型——不管它有多复杂——在建模阶段得到了广泛的验证，并在最后测试了它是否能很好地推广到看不见的数据。
更实际的是，确保创建的解决方案可以在可用的基础设施上实现。如果你的企业可以收集更多的数据，用于在未来改进你的模型，那么应该准备一个再培训管道，以确保其易于更新。这种流水线甚至可以被设置成以预定义的时间频率自动地重新训练模型。
最后，不要忘记在将模型部署到产品中之后跟踪它的性能和可用性。业务环境是非常动态的，数据中的一些关系可能会随着时间的推移而改变，并且可能会出现新的现象。它们可以改变你的模型的效率，应该被正确对待。此外，还可以发明新的、功能强大的模型。一方面，它们可以使您的解决方案相对薄弱，但另一方面，给你机会进一步改善您的业务和利用最新的技术。
机器和深度学习模型可以帮助您为您的业务和应用程序构建强大的工具，并为您的客户提供卓越的体验。创建这些“智能”功能需要大量的努力，但潜在的好处是值得的。只要确保您和您的数据科学团队尝试合适的模型并遵循良好的实践，您就将走上正轨，为您的业务和应用提供尖端的机器学习解决方案。
来源:
Keras 是一个高级神经网络 API，用 Python 编写，能够运行在 TensorFlow、CNTK 或…
keras.io](https://keras.io/)
https://en.wikipedia.org/wiki/Unsupervised_learning
https://machinelearningmastery.com/what-is-deep-learning/
【https://developer.nvidia.com/deep-learning
https://arxiv.org/abs/1707.07012
https://scikit-learn.org/stable/modules/tree.html
https://aws.amazon.com/deepcomposer/
https://blog . keras . io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras . html
https://keras.io/examples/imdb_bidirectional_lstm/
https://towards data science . com/how-do-self-driving-cars-see-13054 aee 2503
https://towards data science . com/building-a-next-word-predictor-in-tensor flow-e 7e 681d 4 f 03 f
https://arxiv.org/pdf/1707.07012.pdf
【https://en.wikipedia.org/wiki/Unsupervised_learning
sklearn 软件包—适用于图表 1a、1b、2a、2b
keras 包—用于图像 2、3、4
draw.io —用于图像 1*
深度学习 vs 益智游戏
深度学习是否比古老的强力技术更适合解决流量自由？
我们都经历过。你无聊地玩着手机，有一些时间可以消磨，所以你决定——违背你更好的判断——访问 app store 的游戏部分，看看有什么趋势。你看到一个看起来很有趣的益智应用，但这并不重要，因为你只会玩半个小时，然后删除它并忘记它，对吗？
两个月后，我完成了 2000 多级的免流量，坚持在每一级都获得“完美”评级。这款游戏是自 2012 年发布以来 iOS 和 Android 上最受欢迎的手机游戏之一，它的前提非常简单:在 2D 网格上连接不同颜色的“阀门”，没有两条线相交:
自由流动——你可以从一张截图中很好地理解这个游戏
截图中的关卡看似简单，但确实越来越难。随着关卡的进展，我发现自己想出了一些策略来帮助我更快地解决这些高级关卡(例如，尽可能坚持最外面的未填充边界，避免创建未填充方块的“入口”，等等)。)浏览网络论坛，看到其他玩家都有自己的技术，有些和我的相似，有些不同。这就引出了一个问题——一台计算机，不是通过蛮力，而是通过“经验”,也能学习这些技术吗？
一个人类(你真正的)正在解决一个自由流动的难题
从基础开始:A*
如今的深度学习问题大多归结为决定使用哪种算法。我从搜索开始。即使它本身不是深度学习，它也让我们很好地了解了问题的内在复杂性，并让我们有机会尝试一些更高级的算法可以自己解决的启发式算法。
空间复杂度太大，无法一次解决整个棋盘，所以我从逐颜色递归解决开始(如果给定的路径被“阻塞”，则回溯到上一个颜色)。作为启发，我使用了可靠的曼哈顿距离。我在 4 种尺寸的电路板上测试了我的算法:小型(2x4)、小型(5x5)、中型(8x8)和大型(14x14)。我确保了中型和大型棋盘的颜色比普通棋盘少种种，因为这实际上使谜题变得更加困难，对人类和计算机都是如此(更多可能的路径/选项/状态)。
这在小型电路板上运行良好，但需要相当多的时间。因此，我在下一个状态函数中添加了一些规则，希望强化学习算法能够自己找出这些规则:防止颜色相同的非连续相邻方块或空“入口”:
在我用了 7 年的电脑上的结果更令人鼓舞，但仍需要改进:
我很惭愧地说，我可能花了更多的时间在我的 Tkinter 绘图功能上，而不是实际的人工智能
如果你认为你是第一个这样做的人，你可能错了
在进入强化学习之前，我正在进一步优化我的 A*搜索，这时我发现了 Matt Zucker 的这篇优秀博客文章，他已经为 Flow Free 构建了一个 A求解器(很高兴看到我不是唯一一个痴迷于此的人)，并且更加仔细地考虑了要从他的 A搜索中删除的州。更重要的是，他发现一个只有 6 条规则的简单 SAT 算法胜过了他非常先进的 A*搜索，并且用 SAT 得到了非常好的求解时间(甚至对于 14x14 的电路板也是亚秒)。
到目前为止，我们似乎都得出了同样令人沮丧的结论:对于这种类型的(非对抗性的、封闭的)益智游戏，简单的暴力技术将胜过基本的人工智能算法。
然而，停留在那里是没有用的。毕竟，启动这一探索的问题仍然存在:作为人类玩家，我们在玩了几个级别后，发现了更有效地击败流自由谜题的特定技术。为什么机器不能学习同样的技术？
线索强化学习
我非常兴奋能在 Flow Free 上尝试 Q-learning，因为这才是“人工智能”中的“我”真正开始发挥作用的地方。A*搜索的工作绝不是浪费时间，因为我们可以用它作为 Q 学习代理的状态-动作空间。我们认为状态空间是棋盘上哪些方格被哪种颜色占据，以及哪条路径(颜色)当前是“活动的”的组合。一个动作就是填充该路径的下一个方块。
学习代理在一开始犯了一些基本错误后，很快学会了如何解决小问题(1.5s 内迭代 100 次)——目前看起来不错。然而，在中型板上，在 10，000 次迭代之后仍然没有骰子，这花费了 10 分钟:
不完全是你听到“人工智能”时想到的
为了改善这一点，我开始摆弄那些帮助不大的标准 Q-learning 参数(学习率α、折现率γ、探索/开采率ε)，于是我把注意力转向了奖励函数。除了玩实际的奖励之外，奖励函数本质上还有一个参数可以切换(或者有变得过于规定性的风险，这将违背整个机器学习练习):代理是否会因为解决了一条路径而不是整个谜题而获得奖励。不幸的是，这并没有带来多大的不同。
最后，很明显，该算法在较大的电路板上很难运行，仅仅是因为选项空间太大。与 A*搜索相比，Q-learning 确实在这种情况下有所帮助，因为它做出了更聪明的选择，但是仍然有太多的情况，即使在 10，000 次迭代之后，确切的 Q-learning 代理还没有看到。因此，下一个自然的步骤是:
近似 Q 学习
近似 Q 学习的应用非常吸引人，尤其是在游戏中。这个想法不是让代理在给定的状态下决定最佳行动，而是给它一些直观的特征，它可以在每一步快速计算，与确切的状态(棋盘的配置)无关，并让它决定哪些是最重要的。这可能是像 Pacman 这样的游戏中的游戏规则改变者(例如，根据到最近的小球和最近的幽灵的距离来决定你的下一步行动，而不是针对每个可能的状态的行动)，或者当然是自由流动，其中可能的状态的数量对于精确的 Q 学习来说太多了，以至于没有效果。
权衡的结果是，现在由开发人员来选择“正确的”特性。我将列表缩小到我知道在许多情况下很重要的特征(例如，关闭每条路径的剩余曼哈顿总距离)，以及一些我怀疑很重要(但没有办法证明)的特征，我会让算法找出这些特征。其中包括:
- 关闭每条路径的剩余曼哈顿总距离
- “圈数”
- “盒子”的数量
- 箱中阀门的数量
- 没有阀门的盒子的数量(人们可以从逻辑上证明这种情况永远不会发生——我想看看算法是否能解决这个问题)
- 一条路径是否“靠墙”(即，一条路径是否能粘住另一条相邻的路径)
不幸的是，有了这些特性，Q-learning agent 甚至不能解决小棋盘，即使在改变 Q-learning 参数之后。然而，看到它的运行是一个有趣的练习。例如，该算法给“没有阀门的盒子”附加了一个很大的负权重，这意味着它能够了解到，有一个没有阀门的盒子会导致谜题无法解决。
近似 Q 学习检测更好的游戏策略
也许有了更大的谜题样本，它可以更好地学习实际解决它们，但我很兴奋地看到它实际上选择了什么是重要的。这是人工智能中一个迷人的现象，尤其是在游戏人工智能中非常普遍:即使一个算法不能赢得比赛，它也可以找到帮助人类更好地比赛的技术。
走向监督:卷积神经网络
起初，我对自由流动的监督方法的想法有偏见。首先，它需要一个大样本的解决流量免费游戏，很难在公共互联网上找到。第二，似乎最接近无流匹配的监督方法——神经网络——是一个臭名昭著的黑箱，它将排除练习中最有趣的部分:看到算法学习解决难题的技术。
然而，我在《走向数据科学》杂志上看到了希瓦·维尔马的一篇文章，他在文章中对数独做了一些非常类似的事情:本质上将数独棋盘视为图像，并使用卷积神经网络(CNN)来解决它。作者在数独上取得了很好的结果，这让我重新审视了我最初的保留意见，并尝试了这种无流量的方法。
当然，第一个障碍是获取输入数据；以可解析文本格式解决的自由流谜题比数独谜题更难找到。我一开始发现的最好的方法是查看 Android 应用程序的代码，它有一千多个以文本格式存储的谜题:
CNN 的最初结果令人失望:测试样本中只有 0%的谜题被解决，尽管 CNN 正在学习它应该制作路径，而不仅仅是孤立地填充颜色。
我们需要更多的数据
调整层、时代、内核大小和其他类似的常见问题没有多大帮助。看起来我们又回到了数据科学家最常见的问题上:如果没有足够的数据，世界上最好的算法就什么也不是。我找到的最好的其他数据来源是 www.flowfreesolutions.com，有数以千计的全新谜题的免费解答，但都是图片格式的。
尽管我多次尝试通过各种渠道与他们联系(甚至提供了经济激励)，我还是无法让他们给我发送他们解决方案的可解析文本版本。嗯，这不是一篇没有意义的人工智能文章——当一个人拥有现代图像处理时，谁还需要底层的解决方案矩阵？提示一个子项目来构建一个无流解决方案图像处理器:
sci kit-图像 FTW
利用对称性来增加我们可用的数据
这又产生了几千个数据点，但这仍然不多。但我随后意识到，就 CNN 而言，颜色的确切值并不重要，重要的是颜色不同的事实。因此，我们可以改变周围的颜色，仍然有另一个非冗余数据点。即使 5x5 电路板有多达 6 种不同的颜色，这给我们的 CNN 多达 6 种！=要处理的数据点增加了 720 倍(当然，更大的电路板和更多颜色的组合可供选择):
数学家将从群论中认识对称群 S_n
有朋友指出，这其实是游戏 AI 中常用的增加数据点的方法。有了 720 倍的数据点，我们终于取得了一些进展——在我 7 岁的 GPU 上运行 20 个时期的模型，大约 200，000 个数据点，测试数据的准确率为 12%。请注意，我们在这里使用了一个严格的成功标准:即使电路板差了一个单元，我们也认为这是一次失败。
然而，这里的失败比成功有趣得多。在几乎所有的失败中，**CNN 正确地解决了大部分问题，足以让人类轻松完成。**从这个意义上说，CNN 能够解决文章的原始前提:直观地学习人类的技术:
CNN 的误差分布
结论
- 简单的方法通常更适合解决基于网格的、非对抗性的益智游戏。事实上，随着方法逐渐变得更先进，性能变得更差。
- 然而，尽管更先进的 ML 方法不会很快解决这个难题，但它们确实找到了有趣的见解，并帮助人类找到更好的解决方案——卷积神经网络在这方面做得最好。此外，它们的性能比更传统的解决方案更具扩展性。
- 更好的数据胜过更好的算法。
更进一步:读者和编辑建议
我请一些更有经验的人工智能/人工智能专家(非常感谢马特·祖克、优素福·基鲁兹和马克·萨鲁菲姆)来评论这篇文章，他们建议尝试以下想法来改进 CNN 算法。这可能是第 2 部分文章的主题，或者您可以在 https://github.com/kgaspard/flow-free-ai 的上随意尝试一下(以及本文中详述的方法):
- 改变 CNN 的层数(消融似乎没有帮助)
- 除了使用对称来增加我们的数据点，还使用旋转/反射
- 使用 CNN 预测作为强化学习代理的特征
使用 CIFAR-10 进行深度学习
基于 CNN 的图像分类
神经网络是可编程的模式，有助于解决复杂的问题，并带来最佳的可实现的输出。我们都知道深度学习比机器学习领先一步，它有助于训练神经网络来获得未回答问题的解决方案或改进解决方案！
在本文中，我们将使用 CIFAR-10 数据集实现一个深度学习模型。数据集通常用于深度学习，用于测试图像分类的模型。它有 60，000 幅彩色图像，包括 10 个不同的类别。图像大小为 32×32，数据集包含 50，000 幅训练图像和 10，000 幅测试图像。人们可以在这里找到 CIFAR-10 数据集。
导入数据
深度学习模型需要具有高计算能力的机器。一般建议使用类似 Kaggle 或 Google Collaboratory 的在线 GPU。我已经在谷歌合作实验室实施了该项目。对于这个项目，我们将使用 TensorFlow 和 matplotlib 库。由于数据集是全局使用的，因此可以直接从 TensorFlow 库的 keras 模块导入数据集。
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import cifar10
数据预处理
任何机器学习、深度学习或数据科学项目的第一步都是对数据进行预处理。我们将定义类的名称，数据集分布在这些类上。大小为 32x32 的彩色图像有 10 种不同的类别。一旦我们设置了类名。我们需要标准化图像，以便我们的模型可以更快地训练。彩色图像的像素范围是 0–255。我们将图像的每个像素除以 255，因此像素范围将在 0-1 之间。实际上，我们将把它除以 255.0，因为它是一个浮点运算。对于该模型，我们将使用卷积神经网络(CNN)。
# setting class names
class_names=[‘airplane’,’automobile’,’bird’,’cat’,’deer’,’dog’,’frog’,’horse’,’ship’,’truck’]x_train=x_train/255.0
x_train.shape
x_test=x_test/255.0
x_test.shape
在 shape 的输出中，我们看到 4 个值，例如(50000，32，32，3)。这 4 个值如下:第一个值，即(50，000/10，000)表示图像的数量。第二个和第三个值显示图像大小，即图像高度和宽度。这里的图像大小为 32x32。第四个值显示“3”，它显示 RGB 格式，因为我们使用的图像是彩色图像。
建立 CNN 模型
CNN 模型分三个阶段工作。在第一阶段，卷积层提取图像/数据的特征。在第二阶段，池层减少了图像的维度，因此小的变化不会对模型产生大的变化。简单地说，它防止过度拟合。在第三阶段，展平层将我们的模型转换为一维，并将其提供给完全连接的致密层。这个密集层然后执行图像预测。一个好的模型有多层卷积层和池层。
CNN 架构(图片由作者提供，灵感来自https://debugger cafe . com/convolutionary-neural-network-architectures-and-variants/
在创建神经网络模型时，一般使用两种 API:顺序 API 和功能 API 。顺序 API 允许我们逐层创建模型，并将其添加到顺序类中。顺序 API 的缺点是我们不能用它来创建一个模型，在这个模型中我们想要使用多个输入源并在不同的位置得到输出。为了克服这个缺点，我们使用函数式 API。通过使用功能 API 我们可以创建多个输入和输出模型。但是，在大多数情况下，使用的是顺序 API 。我们将为我们的 CNN 模型使用顺序 API 。
cifar10_model=tf.keras.models.Sequential()
# First Layer
cifar10_model.add(tf.keras.layers.Conv2D(filters=32,kernel_size=3, padding=”same”, activation=”relu”, input_shape=[32,32,3]))
我们使用卷积神经网络，因此我们将使用卷积层。最常用和我们正在使用的层是 Conv2D。Conv2D 表示卷积发生在 2 轴上。它将卷积扩展到三个层次，红色、绿色和蓝色。另一类卷积层是 Conv1D。Conv1D 一般用于“文本”， Conv2D 一般用于“图像”。我想大多数读者都知道什么是卷积以及如何做，但是这个视频将帮助你清楚卷积在 CNN 是如何工作的。
Conv2D 层的参数
第一个参数是 【滤镜】 。号码。滤波器的值表示 CNN 模型和卷积层将从中学习的滤波器的数量。从每个这样的过滤器，卷积层学习一些关于图像，像色调，边界，形状/特征。参数的值应该是 2 的幂。
第二个参数是“”。内核指的是一个过滤器，它将在图像中移动，并使用点积提取零件的特征。内核大小是指过滤器的尺寸(高 x 宽)。内核大小的值通常是奇数，例如 3，5，7…等等。这里我们使用的内核大小为 3，这意味着过滤器大小为 3 x 3。
下一个参数是“”。有两种类型的填充，同样&有效。在有效填充中，图像边界上没有零填充。因此当卷积发生时，会有数据丢失，因为一些特征不能被卷积。在相同的填充中，在图像的所有边界上都填充了一层零，因此没有数据丢失。此外，卷积后图像输出的维数与图像输入的维数相同。上述是这种衬垫命名的原因。因为在初始层中我们不能丢失数据，所以我们使用了相同的填充。
图像和填充(作者提供的图像)
使用深度学习模型的原因是为了解决复杂的功能。为了得到更好的输出，我们需要以过于复杂的方式来拟合模型，因此我们需要使用能够解决模型的非线性复杂性的函数。这是通过使用激活层来完成的。在任何深度学习模型中，最少需要一个具有 激活功能 的层。激活函数的工作是给模型添加非线性。如果我们不添加这一层，模型将是一个简单的线性回归模型，不会达到预期的结果，因为它无法拟合非线性部分。
有 4 个著名的激活功能:
- )Sigmoid 函数:取值范围在 0 到 1 之间。该图是一个陡峭的图，所以即使是很小的变化也能带来很大的不同。它主要用于二元分类，因为当值高于或低于 0.5 时可以很容易地进行划分。
Sigmoid 函数的图形(图片由作者提供，创建于https://www . maths isfun . com/data/function-grapher . PHP # functions)
2.)双曲正切函数:是正切双曲函数的缩写。它是 Sigmoid 函数的衍生函数。这些激活函数背后的数学原理超出了本文的范围，所以我不会跳到这里。该值的范围在-1 到 1 之间。
双曲正切函数图(图片由作者提供，创建于https://keisan.casio.com/exec/system/1223039747?lang=en&charset = utf-8&var _ x = TanH % 28x % 29&ketasu = 14
3.)ReLu 函数:是整流线性单元的缩写。是深度学习最著名的激活。这是著名的，因为它更容易计算，因为数学函数比其他激活函数更容易和简单。
ReLu 函数的图形(图片由作者提供，创建于https://www . maths isfun . com/data/function-grapher . PHP # functions)
4.)SoftMax 函数:SoftMax 函数是 Sigmoid 函数的更多阐明形式。它用于多类分类。该函数计算函数中特定类的概率。因此，该函数的输出值范围在 0 到 1 之间。Sigmoid 函数和 SoftMax 函数的主要区别在于，Sigmoid 函数可用于二分类，而 SoftMax 函数也可用于多分类。
汇集层
*#MaxPoolingLayer
cifar10_model.add(tf.keras.layers.MaxPool2D(pool_size=2,strides=2, padding=’valid’))*
池层用于减小图像的大小，同时保留角色中的重要参数。这样有助于减少模型中的计算量。在执行卷积时，卷积层保留了关于特征的确切位置的信息。因此不太重要的特征也被完美地定位。因此，我们会遇到一个问题，即使是像素或特征的微小变化也会导致模型输出的巨大变化。通过最大池化，我们缩小了所有特性的范围，只考虑最重要的特性。因此，上述问题得以解决。池化有两种方式:平均池化或最大池化。通常使用最大池。
平均池(图片由作者提供，灵感来自https://people . mines Paris . PSL . eu/fabien . moutarde/ES _ machine learning/TP _ conv nets/conv net-notebook . html)
在平均池中，取池大小的平均值。在最大池中，取池大小的最大值。这个概念将从上面和下面的图像中被清除。
Max Pooling(图片由作者提供，灵感来自https://people . mines Paris . PSL . eu/fabien . moutarde/ES _ machine learning/TP _ conv nets/conv net-notebook . html)
池大小是指将取其最大值的过滤器的大小。这里的池大小 2 表示将使用 2x2 的池，在该 2x2 池中，平均值/最大值将成为输出。池将穿过图像。它将根据步幅值移动。
步幅意味着泳池的大小能跳多远。如果步幅为 1，2x2 池将从一列逐渐向右移动到另一列。我使用了 stride 2，这意味着池大小将一次移动两列。我前面用来解释最大池化和平均池化的图像的池大小为 2，步幅= 2。
在池中，我们使用填充“有效”，因为我们准备丢失一些信息。因为池的功能是减少图像的空间维度并减少模型中的计算。
最后一层
*# Flattening Layer
cifar10_model.add(tf.keras.layers.Flatten())*
在卷积层和汇集层的堆叠之后添加了展平层。展平层将 3d 图像矢量转换为 1d。因为在前面提到的层的堆叠之后，添加了最终的完全连接的致密层。现在，密集层要求数据以一维方式传递，因此扁平化层是最重要的。
平整层的工作(图片由作者提供)
*展平一层后，还有一层致密层。致密层是一个完全连接的层，将先前功能的所有输出提供给所有神经元。密集层具有权重 W、偏差 B 和传递给每个元素的激活。*用一种清晰的方式说，它把所有的点连接起来。这一层使用之前提取的所有特征，并完成训练模型的工作。提到的单位显示了模型将要使用的神经元的数量。
*# Droput Layer
cifar10_model.add(Dropout(0.2))
# Adding the first fully connected layer
cifar10_model.add(tf.keras.layers.Dense(units= 128,activation='relu’))*
现在，为了防止过度拟合，增加了一个脱落层。在数据训练期间，一些神经元被随机禁用。传递给神经元的值意味着在一次迭代中想要丢弃的神经元的比例。因此，在训练之后，神经元不会受到其他神经元的权重的很大影响。因此该模型可以更好地推广。
辍学层的工作(图片由作者提供，灵感来自https://people . mines Paris . PSL . eu/fabien . moutarde/ES _ machine learning/TP _ conv nets/conv net-notebook . html
输出层
在输出中，图层根据数据集中的类数量使用单位数量。这里我们用 10，因为有 10 个单位。在输出中，我们使用 SOFTMAX 激活，因为它给出了每个类的概率。
在编制模型时，我们需要考虑损失函数。通常使用两种损失函数，稀疏分类交叉熵(scce)和分类交叉熵(cce)。稀疏分类交叉熵(scce)在类别互斥、类别完全不同时使用。当一个标签或部分可以有多个类别时，使用分类交叉熵。在我们的场景中，类是完全不同的，所以我们使用稀疏分类交叉熵。
我们将使用普遍使用的 Adam 优化器。Adam 是“自适应学习率法”的缩写。这个优化器使用梯度的初始值来适应学习速率。现在使用 Adam 代替 ML 中使用的随机梯度下降，因为它可以在每次迭代后更新权重。
玩了一会儿 epochs 后的最终输出是:
使用这个模型，我能够得到 78%的准确率。因此，在本文中，我们将使用 Google Collaboratory 完成深度学习项目。我们了解卷积神经网络的卷积层和池层中使用的参数。在 CNN 中提取特征后，我们需要一个密集层和一个 dropout 来实现识别图像的这一特征。最后，我们看到了一些损失函数和亚当优化。
您可以在我的 git 资源库中找到完整的代码:https://github.com/aaryaab/CIFAR-10-Image-Classification。
*请随时联系我，电话:【https://www.linkedin.com/in/aarya-brahmane-4b6986128/ *
参考资料:你可以在找到并制作一些有趣的图表
图形图像是我在 Power point 上制作的。
快乐深度学习！
和平！！
用容器进行深度学习。第一部分
照片由 Antoine Petitteville 在 Unsplash 上拍摄
TL；速度三角形定位法(dead reckoning)
容器是在主机计算环境中独立运行的轻量级软件包。使用集装箱化的环境进行研究是有帮助的，因为它们易于使用，可重复，并保持您的主要系统干净。您可以使用 Docker Compose 轻松设置一个功能完整的多容器应用程序。所有需要的脚本都可以在这里找到。
更新 02/2021: 该系列的第二部分可在这里。
为什么是集装箱？
当进行深入研究时，有时很难维持你周围正在发生的事情。大量包含数据的文件，几十个你不用但又不确定能清除它们的库，保存在你主目录中某处的临时文件，应有尽有。虚拟环境有所帮助，但作用不大。您仍然必须管理它们，并且可能会以同样混乱的位置结束，但是环境的数量会成倍增加。在设置我的笔记本电脑以处理深度 NLP 模型时，我想到了创建易于使用且完全一次性的实验环境的方法——容器。它们让我只需一个命令就可以设置带有 Tensorboard 跟踪功能的 Jupyter 笔记本。用另一个命令，我可以把这些都拉下来，而不用担心留在内存或硬盘上的东西。在这篇文章中，我将描述如何在您的系统中设置和部署深度学习的容器，在下一篇文章中，我将展示如何扩展特定任务的基本图像——使用拥抱面部变形器的连体学习。
我使用的堆栈如下:
- Docker 。创建容器的平台和软件。该领域事实上的标准工具。
- PyTorch 带 GPU 支持。我选择的框架，简直太棒了。
- Jupyter 笔记本。支持在浏览器中进行交互式开发的软件。
- 张量板。实验跟踪的良好起点。从那你可以切换到快板 AI 或重量&偏差。
- 抱脸。简单地说，你可以得到基于变压器和其他架构的最先进模型的最佳方式。
容器
如果你不熟悉容器的概念，阅读一些介绍性的文章(例如来自 Docker 或 Google )并浏览覆盖基础知识的教程会是一个好主意。
我们现在将创建两个容器—一个用于 Jupyter Notebook，另一个用于 Tensorboard。我们从 Tensorboard 容器开始，因为它非常小，容易理解。以下是它的完整版本:
*# Use small image with Python pre-installed.*
**FROM** python:3.8-slim-buster
*# Install tensorboard*
**RUN** pip3 install tensorboard
为了运行和操作 Tensorboard，我们不需要任何东西，除了它的包。您现在可以将这个文件保存为tensorboard.Dockerfile，构建容器(docker build -t dl-tensorboard:latest -f tensorboard.Dockerfile .)并使用命令docker run --rm -it dl-tensorboard:latest /bin/bash交互运行它，命令tensorboard将可供运行。但是它不会自己运行，它需要一个存储实验运行数据的目录。我们将在稍后的服务设置阶段处理它。
下一部分是用 Jupyter 笔记本建立一个图像。这里有相当多的细微差别。首先，我们将与深度学习合作，因此我们的容器中需要一个 GPU 支持。幸运的是，NVIDIA 用他们的容器工具包覆盖了我们。经过几个简单的步骤，您就可以随意使用支持 GPU 的 Docker 容器了。NVIDIA 的另一个非常有用的项目是一组安装了 CUDA 的预建图像。几个版本的 Ubuntu 之前，安装 NVIDIA 驱动程序和 CUDA 是一个巨大的痛苦。现在容易多了，但是有了这些图像，你不需要做任何与 CUDA 设置相关的事情，这很酷。
到写这篇文章的时候，PyTorch 已经支持 CUDA 10.2 版本了，所以我们将使用 NVIDIA base image 搭配 CUDA 10.2。此外，NVIDIA 提供了三种风格的图像— base、runtime和devel。我们的选项是runtime，因为包含了 cuDNN。
下一个有趣的点是，我们将执行我们的映像的多阶段构建。这意味着在构建过程中，我们将有一个封装了所有与设置相关的逻辑的基础映像，以及一个根据手头的任务添加收尾工作的最终映像，例如安装额外的包或复制所需的文件。这个逻辑将允许我们在 Docker 缓存中保存一个基础映像，这样就不需要每次添加新的包时都下载 PyTorch。毫无疑问，我们可以通过在 Dockerfile 中现有的行之后添加新的行，并且不打乱已经添加的行的顺序(因为Docker 缓存的工作方式)来实现相同的目的，而不需要多阶段构建，但是这种方法给出了责任分工，易于操作，并且为我们将在下一篇文章中讨论的更多高级场景奠定了基础。
在我们进入 Jupyter 图像的 docker 文件之前，我想澄清几个问题。首先，由于我们使用 NVIDIA CUDA 映像作为基础，我们将需要安装 Python 和一些必需的工具。第二，由于已知问题，不可能在容器中运行笔记本二进制程序。前一段时间，需要在 docker 文件中设置 Tini，如链接中所述。但是现在 Tini 已经内置到 Docker 中，所以不需要任何额外的设置，只需在运行容器时添加--init标志。稍后我们将看到如何将它合并到 Docker compose 中。
最后，我们可以看看 Jupyter 笔记本图像的实际 docker 文件:
*# NVIDIA CUDA image as a base*
*# We also mark this image as "jupyter-base" so we could use it by name*
**FROM** nvidia/cuda:10.2-runtime AS jupyter-base
**WORKDIR** /
*# Install Python and its tools*
**RUN** apt update && apt install -y --no-install-recommends **\
** git **\
** build-essential **\
** python3-dev **\
** python3-pip **\
** python3-setuptools
**RUN** pip3 -q install pip --upgrade
*# Install all basic packages*
**RUN** pip3 install **\
** *# Jupyter itself*
jupyter **\
** *# Numpy and Pandas are required a-priori*
numpy pandas **\
** *# PyTorch with CUDA 10.2 support and Torchvision*
torch torchvision **\
** *# Upgraded version of Tensorboard with more features*
tensorboardX
*# Here we use a base image by its name - "jupyter-base"*
**FROM** jupyter-base
*# Install additional packages*
**RUN** pip3 install **\
** *# Hugging Face Transformers*
transformers **\
** *# Progress bar to track experiments*
barbar
记住之前描述的一切，脚本非常简单——获取 NVIDIA CUDA 映像，安装 Python，安装基本包，使用所有这些作为最终映像的基础，并根据具体问题添加一些额外的包。
服务
创建环境的最后一步是在 Docker Compose 的帮助下，将两个图像组合成完整的多容器应用程序。该工具允许创建一个 YAML 文件，该文件包含构成应用程序的服务的描述。这是一个很好的工具，主要关注单主机部署，这正是我们的用例。撰写本文时 Compose 的一个主要缺点是缺乏 GPU 支持，尽管 Docker 和它的 API 已经实现了这个特性。但是有一个解决方法支持在组合服务中使用 GPU。我已经将集成到最新发布的 Compose 中，并计划维护它，直到 GPU 和其他设备请求得到支持。在这方面，您需要安装 Compose 的这个分支，以便能够运行服务。
让我们看看docker-compose.yml文件:
**version**: "3.8"
**services**:
**tensorboard**:
**image**: dl-tensorboard
**build**:
**context**: ./
**dockerfile**: tensorboard.Dockerfile
**ports**:
- ${TENSORBOARD_PORT}:${TENSORBOARD_PORT}
**volumes**:
- ${ROOT_DIR}:/jupyter
**command**:
[
"tensorboard",
"--logdir=${TENSORBOARD_DIR}",
"--port=${TENSORBOARD_PORT}",
"--bind_all",
]
**jupyter-server**:
**image**: dl-jupyter
**init**: **true**
**build**:
**context**: ./
**dockerfile**: jupyter.Dockerfile
**device_requests**:
- **capabilities**:
- "gpu"
**env_file**: ./.env
**ports**:
- ${JUPYTER_PORT}:${JUPYTER_PORT}
**volumes**:
- ${ROOT_DIR}:/jupyter
**command**:
[
"jupyter",
"notebook",
"--ip=*",
"--port=${JUPYTER_PORT}",
"--allow-root",
"--notebook-dir=${JUPYTER_DIR}",
'--NotebookApp.token=${JUPYTER_TOKEN}'
]
这里有很多东西需要解开。首先，定义了两个服务— tensorboard和jupyter-server。image部分定义了将为服务构建的映像的名称。build部分定义了一个路径，指向将用于构建映像的目录或带有 Dockerfile 的存储库。在ports部分，我们指定主机的哪些端口将暴露给容器。这里事情变得有趣了——我们看到的不是数值，而是环境变量的名称。Docker compose 从一个名为.env的特殊文件中获取这些变量，用户在该文件中列出了在合成过程中必须使用的所有变量。这允许有一个单独的位置来存储不同环境中不同的合成脚本的所有部分。例如，一台机器上用于 Tensorboard 的端口可以被另一台机器占用，这个问题可以通过更改.env文件中TENSORBOARD_PORT变量的值来轻松解决。
对于我们的场景，.env文件如下所示:
ROOT_DIR=/path/to/application/root/directory *# path on the host*
JUPYTER_PORT=42065
JUPYTER_TOKEN=egmd5hashofsomepassword
JUPYTER_DIR=/jupyter/notebooks *# path in the container*
TENSORBOARD_PORT=45175
TENSORBOARD_DIR=/jupyter/runs *# path in the container*
ROOT_DIR是一个目录，将存储我们的应用程序所需的所有信息(笔记本、数据、运行历史)。从docker-compose.yml中的volumes部分可以看到，这个目录作为/jupyter安装到两个容器中，这解释了为什么JUPYTER_DIR和TENSORBOARD_DIR变量都有这个前缀。文件中的其他变量定义了要公开的端口和用于身份验证的 Jupyter Notebook 的令牌。
服务定义的command部分包含一组参数，这些参数组合成一个命令，将在容器启动时执行。为了解决笔记本二进制文件的上述问题，我们为 Jupyter 服务添加了init: true。我们还使用部分env_file将环境变量从.env文件传递到 Jupyter 笔记本的容器中。这是因为我们将在笔记本中使用这些变量，细节将在下一篇文章中介绍。服务定义的最后但并非最不重要的特性是一个device_requests部分。这正是使 GPU 在容器内部可用的解决方法。没有它，你将无法在多容器应用程序中享受顶级 NVIDIA 卡的强大功能。
最后，我们得到工作目录的如下结构:
├── .env *# File with environment variables.*
├── docker-compose.yml *# Compose file with services.*
├── jupyter.Dockerfile *# Dockerfile for the Jupyter image.*
├── tensorboard.Dockerfile *# Dockerfile for the Tensorboard image.*
完成所有设置后，您终于可以在我们的工作目录中运行docker-compose up -d了。在下载了所有基本映像并安装了所有必需的包之后，两个容器都应该启动并运行了。第一次启动需要相当长的时间，但是接下来的会非常快——即使你在最终映像中安装了新的包，所有下载和安装基础包的繁重工作都会被跳过。当你完成工作后，只要运行docker-compose down所有的容器就会消失，让你的系统保持干净，为其他有趣的事情做好准备，比如在 Go 中开发分布式系统或者在 COMSOL 中运行复杂的物理模拟。
结论
在这篇文章中，我们看了一个例子，如何用 Jupyter Notebook、PyTorch 和 Tensorboard 建立一个可用于深度学习研究的容器化环境。在下一篇文章中，我们将深入探讨如何将这种环境用于一个真实的用例——新闻的几个镜头分类的暹罗学习。这篇文章的主要摘录:
- 使用多阶段构建，其中基础映像完成一次性的重要工作，最终映像根据您的需求定制环境。你知道，就像微调。
- Docker Compose 不支持将 GPU 绑定到容器。但如果你真的想，它会的。
利用 NGC 的 docker 容器进行深度学习——英伟达 GPU 云
有一个基本的复制粘贴操作指南
docker 容器:)图片来自 pixabay
不再为深度学习环境的安装而烦恼。不再与 Cuda 版本和 GCC 编译器争斗。欢迎来到码头工人时代。你所需要的只是一个带有最新 Cuda 驱动程序的 Unix 系统。你只需要从 NGC 云下载一个 docker，它包含了你需要的环境和所有的 Cuda 代码。
其实写完这个帖子，发现自己用的越来越多了。由于我的主要工作是对医疗(高度安全)数据进行深度学习，所以我大量使用 dockers。当你必须在没有互联网的服务器上工作时(是的，没有 StackOverflow 这很痛苦)，docker 就是你的救星:)。您在正常环境中准备您的工作环境，然后您/系统管理员将其迁移到服务器。我现在正在探索的一个有趣的优势是用 git 库、手册等来丰富您的环境。我将在这里更新我发现的方法。
这里我们将使用 Python 3 和 TensorFlow 1.9，但也有带有 Pytorch、Caffe、trained model 等的 dockers。
英伟达云图片来自英伟达云网站
获得自己的 Nvidia Docker
转到https://ngc.nvidia.com/catalog/all。选择“容器”标签，查看所有可用的容器。我选择了 TensorFlow 容器:
可以直接从云端使用，用:nvcr.io/nvidia/tensorflow: 19.12-tf2-py3一个 TensorFlow2 docker。或者在您创建帐户并登录后下载它。
要下载 TensorFlow2 docker，请使用 pull 命令:
docker pull nvcr.io/nvidia/tensorflow:20.10-tf2-py3
下载 docker 需要一些时间。
启动 docker 容器
列出所有可用的本地 docker 图像
$ sudo docker images
**docker run --rm -it --runtime=nvidia --net=host -v <local dir>:<destination dir> <Image id>**
例如，对于本地码头，使用:
**docker run --rm -it --runtime=nvidia --net=host -v /my_server_dir/:/naomi** 989143febb16
或者使用 Nvidia cloud 的 docker:
docker run --gpus all -it --rm -v local_dir:container_dir nvcr.io/nvidia/tensorflow:19.12-tf2-py3
其中:
-it表示以交互方式运行--rm完成后会删除容器-v是挂载目录local_dir是您希望从容器内部访问的来自主机系统的目录或文件(绝对路径)。container_dir是您在容器中时的目标目录。举个例子，
比如下面路径中的local_dir是/home/jsmith/data/mnist ，目标目录是:/data/mnist。
-v /home/jsmith/data/mnist:/data/mnist
例子取自:https://ngc.nvidia.com/catalog/containers/nvidia:tensorflow
停止码头集装箱
# list running dockers:
$ docker ps# Find the docker container id, then run:docker kill <container id>
附加到正在运行的 docker 容器
当您想在 docker 中从外部运行一个命令时，您可以使用 exec，它允许您告诉正在运行的 docker 运行一个特定的命令。例如，当您失去管理 docker 的命令行窗口时，您可以使用 exec 在 docker 中运行命令行环境。这样，您可以附加到正在运行的 docker 容器。例如，使用下面的命令在 docker 容器中创建一个 shell。
**docker exec -it <container id> /bin/bash**
将包和数据添加到 Docker 容器中
当您在 docker 容器“内部”时，您是在 linux cmd 空间中。比如可以用 pip 安装 python 包，也可以上传数据。这个选项对于在没有互联网的服务器上处理安全数据的人来说非常有用，就像我在医疗行业一样。这样你就可以准备好你需要的一切，然后提交并传输到你的封闭服务器上。
如果你使用 Nvidia docker 容器，它没有 jupyter。您可以通过以下方式安装它:
**pip install jupyter**
在 docker 容器上运行 Jupyter 笔记本
如果你在一个图形用户界面环境中，像 RDP，你可以很容易地运行 jupyter 笔记本，只需做如下。如果您在服务器上只有 cmd，就像在 mobaxterm 中一样，那么就需要更多的步骤，这些步骤是在前面几节中指定的。
用以下命令启动笔记本:
**jupyter notebook --ip 0.0.0.0 --allow-root**
在您的浏览器中，键入: http:// <服务器 ip > :8888/？令牌= <令牌>。在我们的案例中:
[http://100.200.15.20](http://192.168.15.20/):8888/?token=2a0630188ca7bc5b99d2c5b7923e2a2ebe391bc15a4bc3f1
复制 cmd 中给出的令牌。
如果端口 8888 被占用，或者有其他原因需要绑定端口，ise:
**jupyter-notebook --ip 0.0.0.0 --allow-root --port 5080**
然后使用地址:
[http://100.200.15.20](http://192.168.15.20/):**5080**/?token=2a0630188ca7bc5b99d2c5b7923e2a2ebe391bc15a4bc3f1
或者
[http://](http://192.168.15.20/)**0.0.0.0**:**5080**/?token=2a0630188ca7bc5b99d2c5b7923e2a2ebe391bc15a4bc3f1
使用笔记本安装软件包和其他后端人员非常方便。就用！命令行的开头，并在单独的单元格中运行每个命令行。例如:
! pip install keras
要在 docker 映像中保存您的安装，不要忘记提交 docker。
提交码头工人
提交一个 docker，将为您的所有安装创建一个新的 docker。
docker commit <docker container id> <new docker name>:<docker tag>
例如，使用以下命令提交 docker:
docker commit 9571cb71d812 naomi/brats:version2
将创建一个 docker 映像，运行“docker images”时将如下所示:
Docker —基本摘要
一篇没有复制粘贴的文章有什么价值呢:)
**# run
docker run --rm -it --runtime=nvidia --net=host -v <local dir>:<destination dir> <docker Image id>****# list available dockers
docker images****# list running docker
docker ps****# attach to a running docker
docker exec -it <container id> /bin/bash****# run notebook
jupyter notebook --ip 0.0.0.0 --allow-root****# commit a docker
docker commit <docker container id> <new docker name>**
更多关于使用 dockers 和每个标志的含义的解释可以在这里找到:https://ngc.nvidia.com/catalog/containers/nvidia:tensorflow
下面是一些不太常见但却是必需的场景。
从 Mobaxterm 运行 Jupyter 笔记本
这个想法是在 cmd 上运行 jupyter 命令，并在本地机器上打开笔记本。这需要 ssh 隧道，如下所述:
Windows 端首先，生成 ssh 密钥:https://phoenixnap.com/kb/generate-ssh-key-windows-10，这个过程会在你的本地电脑上创建一个文件。
Mobaxterm 端打开隧道菜单来定义你的隧道。
Mobaxterm ssh 隧道
假设你的远程服务器是 52.522.52.522，你的用户名是naomi，你选择了 1200 作为端口(你可以选择任意一个 antaken 号)，填写下面，保存。
保存并添加您之前创建的 ssh 密钥，在密钥图标中:
为隧道和 ssh 会话添加 ssh 密钥
窗口端在 Powershell 中以管理员身份运行以下命令
**ssh -NL 1200:localhost:1200 naomi@**52.522.52.522
Mobaxterm side 在 Mobaxterm cmd 窗口中运行以下命令:
jupyter notebook — no-browser — port 1200
将您从输出中获得的地址复制到本地 windows 机器上的 chrome 或类似设备中，您就可以在笔记本中工作了:
[http://127.0.0.1:1200/?token=36401f7dada8b4cb5eb2d15b70ac3e4963633e7dd5b922d1](http://127.0.0.1:1250/?token=36401f7dada8b4cb5eb2d15b70ac3e4963633e7dd5b922d1)
重新连接到正在运行的 Jupyter 笔记本
深度学习训练通常需要很长时间。因此，在大多数情况下，当在远程服务器上工作时，连接被关闭，笔记本的令牌丢失。要查找正在运行的笔记本的令牌，请执行以下操作:
# use -mtime -30 to list only notebooks that started in the last 30 days.find `jupyter --runtime-dir` -mtime -30 | grep nbserver | xargs cat
您将看到如下内容:
...
<body><p>
This page should redirect you to Jupyter Notebook. If it doesn't,
<a href="[http://0.0.0.0:8888/tree?token=7caaccce4fb4e670d9053b67c773e93c4a6ceb128fde2f56](http://0.0.0.0:8888/tree?token=7caaccce4fb4e670d9053b67c773e93c4a6ceb128fde2f56)">click here to go to Jupyter</a>.
</p>
...
只需将地址(将 0.0.0.0 更改为您的服务器 IP 或 localhost)复制到您的浏览器，即可重新打开正在运行的笔记本。
用户问题
在 docker 容器中，你是你的王国的国王，你是根用户，我猜这是安装所需要的。即使您没有 root 密码，您编写的文件也会在磁盘上获得 root 所有权。删除您在容器中创建的文件只能通过 root 密码或 docker 来完成。我还没想明白。如有真知灼见，不胜感激。
安装 Docker 引擎
如果您需要安装新的 docker 引擎，请遵循此处的说明。为了方便起见，我将添加推荐方法的简短摘要。
使用存储库安装
对于主机:焦点 Ubuntu 20.04 LTS，版本:20.04。x86_64 / amd64。
# Set up the repository
$ sudo apt-get update
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg-agent \
software-properties-common# Add Docker’s official GPG key:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -# set up the **stable** repository
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"
安装 Docker 引擎
$ sudo apt-get update
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
启动 docker 守护进程
sudo dockerd
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
