TensorFlow +类继承=漂亮的代码
用这种方法深入研究更多的技术模型。
简介:
学习开发深度学习模型并不是一件容易完成的任务——尤其是对于那些可能在该领域没有丰富经验的人来说。当开始学习如何在 TensorFlow 中构建 DL 模型时，工作流程通常如下:
但是，如果部署或更多的技术模型出现，这种构建模型的格式可能会对您的时间造成负担，而不是资产。Python 的面向对象特性很好地发挥了作用，使它更多地属于后者而不是前者。本教程将分解开发更健壮的模型的工作流程。
继承:
当观察上面的gist时，我们可以看到我们初始化了keras.Sequential，它的类类型是tf.keras.Model。通过添加一个层列表作为parameter，我们初始化要调用的层——按顺序——用于向前传递。
我们可以使用所谓的class inheritance来构建张量流模型。通过继承tf.keras.Model类，我们可以将我们自己的层合并到模型中，并从那里构建我们的向前传递。
对于简单分类的例子，比如上面的例子，这样做可能有点复杂*(双关语。考虑到这一点，我仍然会继续上面的模式。如果您理解 tensor flow API 的基础，那么您将能够看到上面要点中的调用如何转化为开发更多面向对象的代码，这是本文的主要目的。*
当继承一个tf.keras.Model类时，有两个主要步骤需要考虑:
- 在
__init__内初始化模型中的必要层。 - 在
call内订购模型的向前传球。
正在初始化类:
对于__init__，我们有 4 个主要步骤。
- 首先，我们引入
super的__init__——在本例中是tf.keras.Model。 - 其次，我们初始化
Flatten层。 - 第三，我们用
128单元初始化Dense层，并激活tf.nn.relu。值得注意的是，当我们在第一个要点中调用激活函数时，我们使用了一个字符串('relu'而不是tf.nn.relu)。)当构建我们自己的模型类时，我们必须从tf.nn模块中调用我们的激活函数。 - 第四，我们用
10单元初始化最后的Dense层。
为了一致性，总是首先初始化super的__init__。这将确保当您在使用中调用该类时，它将作为tf.keras.Model加载。层的初始化顺序无关紧要。
打电话:
当定义call时，我们正在定义模型的正向传递。我们有参数inputs，在拟合时，这些参数将是x_train。因此，在call中，它将类似于第一个要点中的层的排序。然而，与层列表相反——并且依赖于fit来确定向前传递——我们必须明确地确定x首先进入Flatten层——也就是self.flatten,然后将其传递到self.dense1层，最后输出self.dense2层的结果。
结论:
本文应该作为构建更多面向对象代码的通用指南。了解自定义模型的工作流程可以让您在研究中获得更多自由和试验。我希望这篇文章对你有益。
感谢您的阅读。
张量流云:从本地到分布式
TensorFlow Cloud 是一个 python 包，用于使用 Google AI 平台从本地调试无缝过渡到云中的分布式训练。TensorFlow Cloud 有在谷歌云平台(GCP)上运行 API 用于训练模型，有 tuner 用于超参数调优。它通过一个单一功能调用简化了云上的训练模型，并处理所有特定于云的任务，如 VM 实例创建和选择分发策略[1]。
调用后的 run API 将验证和预处理 python 脚本或笔记本，使用云构建或本地 docker 守护进程将其容器化，并将训练作业部署到 AI 平台。可以将相关日志流式传输到日志记录，并使用托管 TensorBoard 监控培训。
运行 API 高层流程
**run**(entry_point=None,
requirements_txt=None,
distribution_strategy='auto',
docker_base_image=None,
chief_config='auto',
worker_config='auto',
worker_count=0,
entry_point_args=None,
stream_logs=False,
docker_image_bucket_name=None,
job_labels=None,
**kwargs)
运行 API 有以下重要参数，这些参数有助于将代码从本地迁移到 AI 平台。[2]
- entry_point: 可选字符串**、** python 脚本或包含训练代码的笔记本。如果未提供 entry_point，则当前 python 脚本或笔记本将被用作 entry_point。例如 train.py 或 train.ipynb
- requirements_txt: 可选字符串**，**附加必需库列表。
- distribution_strategy: 自动或无，默认为自动，将根据主管配置、员工配置和员工人数选择分配策略。
- chief_config: 分布式集群中主要工作者的机器配置。默认:T4_1X
- worker_config: 分布式集群中工作者的机器配置。默认:T4_1X
- worker_count: 分布式集群中的工作线程数。默认值:0
- **entry _ point _ args:**entry _ point 脚本或笔记本的可选参数。默认值:无
- stream_logs: 来自 AI 平台的流日志的布尔标志。
- **docker _ image _ bucket _ name:**可选字符串，指定 docker image 云存储桶名。如果设置了该参数，docker 容器化使用Google Cloud Build完成，否则使用本地 docker 守护进程。
TensorFlow 云培训分发策略
分销策略
运行 API 支持自动和自定义分发策略，上面的流程图显示了自动选择分发策略。所有分布策略都遵循数据并行性，其中模型变量跨设备复制，并使用 all-reduce 策略进行同步。
下图显示了“all reduce 策略(ring all-reduce)的一种可能实现，其中 N 个节点中的每个节点与其两个对等节点通信 2(N-1)次。在此通信期间，节点发送和接收数据缓冲区的块。在前 N-1 次迭代中，接收到的值被添加到节点缓冲区中的值。在第二个 N-1 次迭代中，接收到的值替换保存在节点缓冲区中的值。* [ 5
环环全减策略:图片来自优步·霍罗沃德
**一种设备策略:**无分布式训练，这种策略的典型用途可能是训练代码验证。
**镜像策略:**变量在所有设备上复制，并使用 all-reduce 策略保持同步。如果在策略的构造器参数中没有指定设备，那么它将使用所有可用的 GPU。如果没有找到 GPU，它将使用可用的 CPU。
**多工作者镜像策略:**类似于镜像策略，在所有工作者的每个设备上创建模型中所有变量的副本，并使用 CollectiveOps 的多工作者 all-reduce 实现来保持变量同步。
工作示例
让我们看一个工作示例，通过在 MNIST 数据集上定义一个简单的用于数字分类的 Keras 模型训练代码，保存为 toy_mnist.py [2]
import tensorflow as tf(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()x_train = x_train.reshape((60000, 28 * 28))
x_train = x_train.astype('float32') / 255model = tf.keras.Sequential([
tf.keras.layers.Dense(512, activation='relu', input_shape=(28 * 28,)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])model.compile(loss='sparse_categorical_crossentropy',
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])model.fit(x_train, y_train, epochs=10, batch_size=128)
上面的模型可以通过编写下面的简单脚本在云上运行。
import tensorflow_cloud as tfc
tfc.run(entry_point='**toy_mnist.py**', chief_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X'])
当我们运行上面的脚本时，用 chief_config 作为 T4_4X 机器，没有创建 worker，因为 worker_count 默认为 0，并且低于自动生成的代码以及其他参数，如 chief_config、worker_config，docker registry 被部署到 AI 平台，并且由于 chief config 的加速器数量> 0T4 _ 4X，选择了TF . distribute . mirroredstrategy。用于分发策略的 TensorFlow 使用NCCL(Nvidia Collective communication s Library)作为 GPU 的跨设备通信，并使用 tf.distribute.NcclAllReduce 作为镜像策略。
import os
import tensorflow as tf
os.environ["TF_KERAS_RUNNING_REMOTELY"]="1"
**strategy = tf.distribute.MirroredStrategy()**
tf.distribute.experimental_set_strategy(strategy)
exec(open("toy_mnist.py").read())
下图显示了提交到 AI 平台的作业。
提交的工作细节，谷歌人工智能平台
训练日志和详细信息在堆栈驱动程序日志中提供，如下图所示，也可以通过在 run API 调用中将 stream_logs 设置为 True 来传输到主机。
显示每个历元的交叉熵损失、精确度的日志
还可以使用**tf.keras.models.save_model**将模型保存到 Google 云存储桶，使用[**gcloud ai-platform predict**](https://cloud.google.com/sdk/gcloud/reference/ai-platform/predict)将模型部署到 AI 平台进行在线推理。
关于设置 TensorFlow、TensorFlow-Cloud 和云配置(创建项目和启用 AI 平台等)，请参考参考资料[ 3 ]。
参考
- https://www . tensor flow . org/guide/keras/training _ keras _ models _ on _ cloud
- https://github.com/tensorflow/cloud
- https://github.com/tensorflow/cloud#setup-instructions
- https://www.tensorflow.org/api_docs/python/tf/distribute
- https://eng.uber.com/horovod/
TensorFlow 开发峰会 2020 倒带
作为 4 年一度的 TensorFlow 开发者，Summit 2020 发生在三月。因此，这篇文章旨在让这个美妙的人工智能社区的所有工程师、开发人员、计算机科学家和数据科学家了解在那次峰会上做出的最新更新和公告。
截图来自开发者峰会 2020 YouTube 视频[( CC BY 4.0)]，部分由作者通过 Canva 创作。
“我们选择去月球”
让我带你回到 1962 年 9 月 12 日，美国第 35 任总统约翰·肯尼迪“我们选择去月球”在莱斯大学的演讲。肯尼迪说。“我们选择在这十年登上月球并做其他事情，不是因为它们容易，而是因为它们很难。”
嗯，我认为 TensorFlow 工程团队将这个演讲放在了心上，在收到来自整个社区的大量反馈后，他们开始致力于解决这个难题，即让 TensorFlow 对世界上基本了解计算机工作原理的每个人或那些能够利用 tensor flow platform 等超能力并使世界变得更美好的人来说尽可能简单。
在这方面，TensorFlow 团队去年实现了一个重要的里程碑，推出了 TensorFlow 2.0 ，这使他们朝着打造易于使用的端到端"一体式"平台的目标又迈进了一步。
建立势头:
TensorFlow 2.0 推出时具有以下特性:
- 简化 API
- 默认情况下，使用 Keras 和 Eager execution 轻松构建模型。
- 支持将模型部署到更多设备上(例如 Raspberry Pi )。
- 强大的研究实验(如 Tensorboard.dev )。
因此，在去年发布的 2.0 版本的基础上，TensorFlow 团队发布了最新版本的 TensorFlow 2.2，其增强功能包括:
- 与上一版本相比，性能有所提高。
- 与 TF 生态系统其余部分的兼容性。
因此，所有那些在迁移到 2.0 时遇到困难的用户，不用担心，因为 TF 团队现在已经使整个系统与你最喜欢的库兼容了。简而言之，适用于 1.x 的也适用于 2.x。
3.最后，任何软件都是根据可伸缩性和稳定性来判断的。显然，TF 团队提交了核心库，这证实了他们不会很快做出任何重大改变。因此，核心库更加稳定。
张量流生态系统
截图自开发者峰会 2020 YouTube 视频[( CC BY 4.0)]
自从拥有 6000 万参数的 Alexnet 通过赢得ImageNet challenge ils vrc 2012而普及深度卷积神经网络以来，总的趋势是制造更深更复杂的网络，以实现更高的精度。
同样，为了提高我们对 TensorFlow 2.x 理解的准确性，我们也需要更深入地挖掘。
A.研究用张量流
TensorFlow 中存在大量的库和扩展，如 JAX 、 TF 概率和张量流量子，这加强了对 ML 世界的研究。与其他平台相比，研究人员更喜欢 TensorFlow，因为它具有新的可扩展性，允许在核心执行，并保持类似于 NumPy ，非常 Python 化，并易于与 Python 生态系统的其余部分集成。
然而，在本节中，我将简要地谈谈我最喜欢的一个特性，即引入了一个名为性能分析器的新工具。
来自 TensorFlow ( CC BY 4.0)中“使用分析器优化 TensorFlow 性能”指南部分的截图
TensorBoard 中的这个新工具将在两个方面帮助研究人员:
- 它将在主机(CPU)、设备(GPU)或主机和设备的组合上针对 TF 模型中的各种张量流运算(ops)持续监控 TF 模型性能。
- 它将为研究人员提供深入的调试指导，最终有助于解决性能瓶颈。
最终结果:它将使模型执行得更快。[对每个人都是双赢]
B.生产张量流
TensorFlow 不仅是研究团体的首选，也是医疗保健和汽车等各行业领域无可争议的选择。由于 TensorFlow 为研究人员提供了尽快测试一些新想法的能力，类似地，它也使实业家或生产工程师能够采纳他们的想法，并通过使培训到部署阶段变得无障碍来创造现实世界的影响。
因此，让我们了解更多关于 TensorFlow 2.x 更新和库的信息，以实现我们的端到端 ML 目标。
截图自开发者峰会 2020 YouTube 视频[( CC BY 4.0)]
TensorFlow 和 Keras 的婚姻万岁
使用 Canva 创建图像，图像元素包括来自[【pngriver.com】]、TensorFlow 和 Keras 站点(CC BY 4.0)的来源
包括我在内的整个人工智能界都喜欢使用 Keras ，因为它易于使用，甚至允许它的用户非常快速地构建和训练定制模型，这就是为什么 TensorFlow 团队考虑到我们的需求，致力于将 tf.keras 作为默认的高级 API。
TensorFlow Hub:转移学习爱好者的工具
如果在日常工作中，你从事各种与计算机视觉相关的应用，并且希望在这方面取得更快的进展，你或多或少会使用迁移学习。
(对于非人工智能观众)嗯，迁移学习只不过是一种方法，你可以从公开可用的数据集( MS-COCO ， ImageNet )下载开源权重，这是其他人花了很多周、几个月才弄明白的，并将其用作对你自己的神经网络的非常好的初始化【而不是随机初始化】，以将这些大型公共数据集的知识转移到你自己的问题中。
截图来自 TensorFlow 网站(CC BY 4.0)
因此，现在根据最近的公告，在 TF Hub 中有超过 1000 个模型，文档、代码片段、演示和交互式 Google Colab 都在等待使用。
TensorFlow Extended (TFX):一个端到端的 ML 平台
截图自开发者峰会 2020 YouTube 视频[( CC BY 4.0)]
根据最近的更新，一旦您准备好将您的模型投入生产。 TensorFlow Extended 现在将允许您为您的可扩展、高性能机器学习任务构建生产就绪的[端到端] ML 管道。
TensorFlow 2.1 支持云 TPU
截图自开发者峰会 2020 YouTube 视频[( CC BY 4.0)]
这次更新是特别为 TPU 的情人们准备的。现在，你可以在专门为人工智能工作流设计的定制硬件上训练和部署你的模型和管道，比如 TPU 的。在最新版本中，TensorFlow 已经使用 Keras 针对云 TPU 进行了优化，这意味着您开始使用的相同 API 将帮助您扩展到 TPU 计算的千万亿次浮点运算，这将足以转变您的业务或创造下一个研究突破。
结束了
好了，伙计们，现在我们已经到了这篇文章的结尾。我知道，通过这篇文章，我只能对 TensorFlow Dev Summit 2020 上发布的公告和更新略知一二。
因此，请访问此链接观看 TensorFlow Dev Summit 2020 的所有会议。
感谢您的关注
你利用你的时间阅读我的《T21》作品对我来说意味着整个世界。我完全是这个意思。
此外，如果你愿意，可以在 Medium、LinkedIn 或 Twitter 上关注我！我很乐意。
阅读纳文·曼瓦尼在媒介上的作品。一个机器学习工程师，一个深度学习爱好者|谷歌印度…
medium.com](https://medium.com/@naveenmanwani) [## Naveen Manwani 机器学习工程师 AIMonk Labs Private Ltd | LinkedIn
查看纳文·曼瓦尼在全球最大的职业社区 LinkedIn 上的个人资料。Naveen 有一份工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/naveen-manwani-65491678/) [## 纳文·曼瓦尼
纳文·曼瓦尼的最新推文(@纳文·曼瓦尼 17)。机器学习工程师@ AIMONK Labs Pvt ltd，深…
twitter.com](https://twitter.com/NaveenManwani17)
云上的 Tensorflow 扩展、ML 元数据和 Apache Beam
一个使用 GCP 数据流的实用且独立的示例
tensorflow extended 通过运行tfx template copy taxi $target-dir 提供的完整端到端示例产生了分散在 5 个目录中的 17 个文件。如果你正在寻找一个更小、更简单、自包含的例子，它实际上运行在云上，而不是本地，这就是你正在寻找的。这里还提到了云服务的设置。
图片来自 pexels.com
会涵盖哪些内容
我们将为 Chicago taxi trips csv 数据集生成统计数据和模式，您可以通过运行data目录下的tfx template copy taxi命令找到该数据集。
通过连接到 ML 元数据存储，或者只是从简单的文件/二进制存储中下载工件，可以从 jupyter 笔记本中查看生成的工件，比如数据统计或模式。
文章底部的完整代码示例
使用的服务
- 数据流作为 Apache Beam 管道运行服务
- 存储桶作为简单(但快速)的二进制和文件存储服务
- (可选，但回报递减)云 SQL (MySQL)作为 ML 元数据的后备存储服务
整个管道可以在您的本地机器上运行(或者在不同的云提供商/您的定制 spark 集群上运行)。这是一个可以通过使用更大的数据集来扩展的例子。如果你希望明白这是如何透明地发生的，阅读这篇文章。
执行过程
- 如果在本地运行，代码将不会被序列化或发送到云中(当然)。否则，Beam 将把所有东西发送到一个中转位置(通常是铲斗存储)。查看 cloudpickle，直观了解电子监管是如何完成的。
- 您选择的云运行服务(我们的是数据流)将检查所有提到的资源是否存在并且可访问(例如，管道输出、临时文件存储等)
- 计算实例将被启动，您的管道将在分布式场景中执行，当它仍在运行或完成时，它将显示在作业检查器中。
将
/temp或/tmp用于临时文件，将/staging或/binaries用于暂存目录是一个很好的命名实践。
TFX 管道
Tensorflow Extended 提供了围绕普通旧梁组件的自定义组件包装器。它们在形式上更加联合:工件只是被生产和消费。这意味着它们不会每次都传输所有的数据集，它们只是传递资源定位器字符串。由于分析预处理速度的原因，您的数据集被流式传输，然后以小块的形式保存为tfrecords,以获得最佳性能，充分利用存储桶的快速存储技术。
这就是为什么当你声明定制组件时，你声明了强类型输入和输出通道(工件类型和名称)，它们被映射到光束侧的多个标记输入-输出。你用一个Dict返回这些。请随意查看默认 TFX 组件的源代码，以获得关于这些组件的更多信息
这就是为什么你需要做这样的事情:
example_gen = CsvExampleGen(...)
statistics_gen = StatisticsGen(**examples=example_gen.outputs['examples']**)
你需要了解的另一个 TFX 抽象是 tfx.orchestration.pipeline。通过提供一组组件来形成管道 DAG，管道根数据源(文件系统或桶)和一个可选的元数据存储库(T17)，您将控制权移交给 TFX 的BeamDagRunner。所支持的射束管道执行参数是平台不可知的。以下是数据流的，供参考。
对于它所做的所有事情，我们的管道创建是非常小的
您可以使用带有通配符的模式一次读取多个文件。
这里是我们的数据流执行参数:
云服务设置
我们不需要太多就能运行。只是一个存储桶，要启用的数据流服务，如果你选择使用 ml 元数据，一个云 sql 实例。
- 登录谷歌云控制台
- 创建一个存储桶
- 启用数据流 API
- [可选] 创建一个云 SQL MySQL 实例用于 ML 元数据
- 创建服务帐户，应用正确的权限(云存储桶项目创建、删除、sql 访问)。
不要用自己的个人账号进行云操作。将一些凭证密钥导出为.json文件，以便与GOOGLE_APPLICATION_CREDENTIALS 环境变量一起使用，这样您就有足够的权限将管道部署到数据流。 确保您的服务帐户 拥有足够的角色 来创建新的数据流作业，对云 SQL 实例进行读写，对桶存储进行读写。
6.确保服务可以相互通信(通常在第一次运行管道时进行故障诊断)
如果您的管道使用的不止是 tensorflow 扩展组件，请在
[setup.py](https://beam.apache.org/documentation/sdks/python-pipeline-dependencies/)文件下包含设置运行环境所需的任何内容。更多信息请点击这里。
在云上运行管道并查看结果
你可能会得到
UserWarning: RuntimeParameter is only supported on KubeflowDagRunner currently. warnings.warn(‘RuntimeParameter is only supported on KubeflowDagRunner ‘。现在可以随意忽略这个警告。只有参数化的流水线(模板)才可以用不同的配置运行。您通常将它们存放在存储服务中，并通过 post http 请求作业提交来运行它们。点击此处了解更多信息。
我们用BeamDagRunner().run(<your pipeline object here>)。
*tfx.orchestration*下有不同的滑道。这一个是从 *tfx.orchestration.beam.beam_dag_runner* 下的。
图表时间
你可以看到我们的工作是在云控制台上完成的。在这里，您可以查看指标、日志消息、运行时间、每个工作者的 cpu 利用率。
吞吐量
cpu 利用率
您甚至可以查看不同的自动生成的统计数据(不是以 protobuf 格式保存的数据集统计数据)。
工作统计
生成的工件
让我们进入存储浏览器，检查我们的存储区。
存储桶统计
这些目录用于存放组件之间的二进制文件和数据，临时文件和暂存文件的临时存储。CsvExampleGen 包含直接从逗号分隔值文件生成的 tfrecords。StatisticsGen 和 SchemaGen 只包含一个(或者 2 个，如果您还指定了一个测试集)tfrecord 文件，该文件包含提取的统计数据和生成的模式。我们稍后会用笔记本检查那些。
您可以看到，除了对应于时间线中特定步骤的不同编号的文件夹之外，tfrecords 也是为了提高性能而拆分的。
旁注:这并不适用于非常非常大(TB 级)的数据集，因为这样一来，它们会成倍增加，并在桶中占据大量空间。在这些情况下，使用基于波束生成器的数据集会更有效，这超出了本教程的范围。
如果您使用 ML 元数据服务，没有理由在您的桶中手动查找这些。
人工制品检查
Tensorflow Extended 已经提供了可视化这些默认工件的方法。首先，模式是基于文本的，所以你可以直接打印出来。通过加载扩展，统计数据可以很容易地在 jupyter 笔记本中可视化。
这些数据存储在一个云原生环境中，手动检查这些数据有点棘手，但也很重要。对于此任务，您可以:
- 在 Google Colab 中进行身份验证，并从那里加载文件。(如果您不是项目的所有者或编辑，可能会失败，因为您不应该是所有者或编辑。仅使用服务帐户以获得良好的安全性)
- 启动一个微小的(可能可抢占的)虚拟机，并从那里启动一个笔记本实例(在数据流左侧面板中有一个快捷方式)
- 在本地手动导出数据，并使用本地 jupyter 实例检查它们。(这一点也不方便——最终是一种解决方法)
无论您选择做什么，或者如果您的数据是基于文件还是 ml 元数据形式，我们都可以满足您的需求。
访问普通文件很容易。如果您在一个计算实例/虚拟机/笔记本中，它是存储桶所在的 GCP 项目的一部分，那么您只需使用gs://<bucket name> url 来访问文件，就像访问您的文件系统一样。
- 对于这个模式，它非常简单。这是一个小的协议缓冲区，以文本格式保存。如果您了解模式协议缓冲区的定义，您可以在文本编辑器中检查或更改它。
或者，正确且类型安全的方法是用 python 加载并编辑它。将返回一个类型保存协议缓冲区存根，您可以使用它进行编辑。
同样，对于统计协议缓冲区(这些不是文本可读的)。
结论
现在，您应该能够充分理解 tensorflow 扩展生态系统所提供的功能，以及它的组件如何与 cloud beam runner 和其他公共云服务协作工作。
谢谢你一路看完！
下面是完整的代码示例:
面向完全初学者的 Tensorflow:张量入门
对“张量”及其运算的理解，可以帮助完全初学者从零开始。
图片来自 Pixabay (免费使用)
在这个令人兴奋的人工智能(AI)世界，Tensorflow 如今是一个热门词汇，尤其是在深度学习继续快速加速人工智能进展的情况下。但是对于刚开始使用 Tensorflow 的人来说，这种体验可能会令人害怕，因为漂亮的库的术语和用法可能会让完全的初学者感到困惑。当我刚开始学习 Tensorflow 时，我面临着类似的挑战，希望通过这篇文章简化一些错综复杂的事情。本文需要对 Python 有一个基本的了解，才能对 Tensorflow 有一个更清晰的了解。
张量流是如何工作的？
描述 Tensorflow 的基本(也是最简单的)方式是，它是 Python(可能还有其他编程语言)中一个很酷的库，允许我们创建计算图来开发神经网络模型。组成 Tensorflow 对象的基本元素是一个 张量 ，所有执行的计算都发生在这些张量中。所以从字面上看(用我的话说)，当你开发任何神经网络模型时，这些张量以有序的方式流动，并在评估时产生最终输出。所以是的，了解张量到底是什么以及我们如何使用它们是开始使用 Tensorflow 的第一步。
那么什么是张量呢？
我们都很熟悉编程中的数据类型，对吗？ 1、2、3 等。是整数，带小数点的数字 (1.5，3.141，5.2555 等。)是浮点值，另一个常见的是字符串(比如“Hello。你今天怎么样？”)。当我们把多个元素集合在一起时，我们一般称之为**(例如【1，4，7】)。
列表集合可用于开发如下矩阵:
[[1，4，7]，[5，8，12]，[1，66，88]]
现在，让我们来看看张量——它们基本上是常规矩阵和向量的高维表示/概括。它甚至可以是 1 维矩阵、2 维矩阵、4 维矩阵或 n 维矩阵！所以我们可以有多维数组，而不仅仅是张量中的一个列表。就是这样，这就是张量在最基本的意义上的真正含义。就像我们可以在传统编程中给变量赋值一样，我们也可以在 Tensorflow 中这样做。只是有一种专门的方法来做这件事。类似地，就像你可以在编程中对常规变量(或常数)执行多重操作一样，我们也可以用张量来做。我们可以将张量切片并选择一部分元素，张量有不同的数据类型(整数、浮点、字符串等。)等等。
开始使用 Python 中的 tensor flow
第一步是安装漂亮的库！匹普是你在这里需要的一切。请注意，如果您使用的是 Google Colab(与 Python 中的 Jupyter notebooks 非常相似)，您甚至不需要安装这个库，因为它已经安装好了，可以随时使用。谢谢你，谷歌！
*#Install the tensorflow module (not required in Google Colab, but is needed in your local PC)!pip install tensorflow*
当我们在本文中使用 Colab 时，输出中显示了消息“需求已经满足”。
需求已经满足:tensor flow in/usr/local/lib/python 3.6/dist-packages(2 . 3 . 0)
Tensorflow 目前有一个更老的版本 type 1.x，而最新发布的版本使用的是 2.x，所以我们选择当前的 tensorflow 版本。
*#Here, we would go with the latest (2.x) release of tensorflow by selecting the version#Note: By default, Colab tends to use the 2.x version%tensorflow_version 2.x*
让我们使用黄金关键词 import 来导入 tensorflow 模块！是的，你可以通过简单地打印版本属性来检查你正在使用的库的版本。
*#import the tensorflow moduleimport tensorflow as tf#Display the tensorflow version we are usingprint(tf.version)*
*现在，让我们开始创建张量。我们将在这里为 int，float 和 string 创建一些。注意使用 tf 创建张量的特殊方式。变量属性。这意味着我们正在创建一个具有可变性质的张量，因此我们可以通过执行专门的操作来改变/修改它的值，就像我们在使用变量的常规编程中所做的那样。请注意，虽然我们在传统编程中已经使用了 int、float 和 string 来声明这些数据类型的相应变量，但我们将在 Tensorflow 中使用 tf.int16 (这意味着我们正在定义一个 16 位整数)、 tf.float32 (定义一个 32 位浮点值)和 tf.string 来这样做。注意，我们也可以使用 *tf.float16、tf.int32 等等，这取决于我们想要存储的值的需求。如果你曾经使用过 C++，你应该知道像 int，short int，long long int，float，double 等。用于声明位数更少(或更多)的变量，所以我们在 Tensorflow 中做一些类似的事情。
*#The science (and art) of creating tensorsscalar_val = tf.Variable(123,tf.int16)floating_val = tf.Variable(123.456,tf.float32)string_val = tf.Variable(“hello everyone. Nice to learn tensorflow!”,tf.string)*
而现在，非常容易打印出这些张量的值！
*#Let us display the values (print) these tensorsprint(scalar_val)print(floating_val)print(string_val)*
<tf.variable shape=“()” dtype=“int32,” numpy=“123”></tf.variable>
<tf.variable shape=“()” dtype=“float32,” numpy=“123.456”><tf.variable shape=“()” dtype=“string,” numpy=“b’hello” everyone.=“” nice=“” to=“” learn=“” tensorflow=“”></tf.variable></tf.variable>
我们可以确定张量的形状和等级，就像你可能在学校的数学模块中听到的那样。如果不是，形状只是指张量的每个维度所包含的元素的数量。而秩是张量中嵌套的最深层次。进入一些代码可能会更清楚。
*#The idea behind shape and rank of tensors#Shape: Describes the dimension of the tensor (total elements contained along each dimension)scalar_val_shap = tf.shape(scalar_val)print(scalar_val_shap)floating_val_shap = tf.shape(floating_val)print(floating_val_shap)*
tf。张量([]，shape=(0，)，dtype=int32)
tf。张量([]，shape=(0，)，dtype=int32)
所以我们得到 0 的形状，对吗？这只是意味着这些是标量值，而不是列表或嵌套列表。
*#Now, if we use e.g. lists/nested lists instead of just a “single” scalar valuelist_tensor1 = tf.Variable([1,3,5,6],tf.int16)print(list_tensor1)print(tf.shape(list_tensor1))list_tensor2 = tf.Variable([[1,2,3],[4,5,6]],tf.int16)print(list_tensor2)print(tf.shape(list_tensor2))#how about the rank? It describes the level of nesting within the tensor in simple words.print(tf.rank(list_tensor1))print(tf.rank(list_tensor2))*
你可以看到 list_tensor1 有 4 个元素，所以它的形状是(4，)。注意,( 4，)只不过是(4，1 ),只显示了单个列表中的 4 个元素。接下来，对于 list_tensor2 ，观察(2，3)的形状，表示我们有一个嵌套列表——有 2 个列表，每个列表包含 3 个元素。
<tf.variable shape=“(4,)” dtype=“int32,” numpy=“array([1,”></tf.variable>
tf。张量([4]，shape=(1，)，dtype=int32)
<tf.variable shape=“(2,” dtype=“int32,” numpy=“array([[1,”></tf.variable>
tf。张量([2 ^ 3]，shape=(2，)，dtype=int32)
tf。张量(1，shape=()，dtype=int32)
tf。张量(2，shape=()，dtype=int32)
*类似地，如果你看一下秩，你会看到, *list_tensor1，*的秩为 1，因为我们只有一个列表，这里没有嵌套！现在，对于 *list_tensor2，你可以看到等级为 2，表示我们有一个 2 级嵌套，即一个大列表包含更多的列表。如果它是一个大列表，包含另一个小列表，而那个小列表包含更多更小的列表，我们的排名就会是 3。希望这能让你明白。
tf。张量(1，shape=()，dtype=int32)
tf。张量(2，shape=()，dtype=int32)
我们可以使用 tf.reshape. 来改变张量的形状(当然，直到它在数学上有效为止)。同样，请注意使用 Python 来做这件事的特殊方式。
*#Reshaping tensorsreshaped_list_tensor2 = tf.reshape(list_tensor2,[6])print(reshaped_list_tensor2)list_tensor3 = tf.Variable([[1,2,3,1],[1,9,10,11],[1,5,11,22],[16,17,18,19]],tf.int16)print(list_tensor3)print(tf.rank(list_tensor3))print(tf.shape(list_tensor3))reshaped_list_tensor3 = tf.reshape(list_tensor3,[2,8,1])print(reshaped_list_tensor3)#or like thisreshaped_list_tensor3 = tf.reshape(list_tensor3,[8,2,1])print(reshaped_list_tensor3)#or automatically determine the shape by only giving one dimension!reshaped_list_tensor3 = tf.reshape(list_tensor3,[1,-1])print(reshaped_list_tensor3)*
你会得到下面的输出。它太长了，可能无法阅读，但我猜如果你在这里查看 Colab 笔记本会更清楚。这里发生的基本事情是，如果你在这里为形状指定[6]，tensorflow 将把你的张量重新整形为具有 6 个一维元素(因此它将是一个简单的 1D 列表)。如果你做一个[2，8，1]，它会产生 2 个列表，每个列表有 8 个元素。你也可以做[8，2，1]-创建 8 个列表，每个列表有 2 个元素，就像你看到的那样。如果您不想亲自指定整形的整个尺寸，您也可以简单地使用-1。因此，[1，-1]的整形将整形 list_tensor3 以创建reshaved _ list _ tensor 3，那么 1 list 与？？？是的，16 种元素。因此，请注意，尽管您可以按照自己的意愿使用 reshape，但必须确保 reshape 后的元素总数在整个过程中不会发生变化。
tf。张量([1 2 3 4 5 6]，shape=(6，)，dtype=int32)
<tf.variable shape=“(4,” dtype=“int32,” numpy=“array([[”></tf.variable>
tf。张量(2，shape=()，dtype=int32)
tf。张量([4 ^ 4]，shape=(2，)，dtype=int32)
tf。张量([[1][2][3][1][1][9][10][11]][[1][5][11][22][16][17][18][19]])，shape=(2，8，1)，dtype=int32)
tf。张量([[[1][2]][[3][1]][[1][9]][[10][11]][[1][5]][[11][22]][[16][17]][[18][19]])，shape=(8，2，1)，dtype=int32)
tf。张量([[ 1 2 3 1 1 9 10 11 1 5 11 22 16 17 18 19]]，shape=(1，16)，dtype=int32)
你可以使用特殊命令 tf.ones 或 tf.zeros. 创建一个全是 1(或 0)的张量，然后也可以对它们执行类似的操作。
现在，我们来切片。就像你可以从一个矩阵或者一个 Python 列表中切分和提取一些元素一样，你也可以对张量做同样的事情。请看下面的例子，其中，我们首先创建一个全张量(我的名字是全 1 张量)和另一个全 0 张量。您想要创建的张量的维数在方括号[]内，因此 a [4，4，4，1]创建了一个 4D 张量，而 a [5，5]创建了一个 2D 张量——在最简单的意义上，它有 5 行 5 列(不过是一个矩阵)。
下面显示了这些创建的张量的一些切片操作。这样你就可以从张量中得到你喜欢的元素而不考虑你不喜欢的:-)
*#creating a tensor full of 1s (or 0s)tensor_onefull = tf.ones([4,4,4,1])print(tensor_onefull)tensor_zerofull = tf.zeros([5,5])print(tensor_zerofull)#extracting specific values from tensors (similar to slicing in conventional programming)tensor_sliced_onefull = tensor_onefull[0]print(tensor_sliced_onefull)tensor_sliced_zerofull = tensor_zerofull[0,1]print(tensor_sliced_zerofull)*
这是很好的输出(在 Colab 笔记本中可读性更好)。
tf。张量([[[[1。] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]]] [[[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]]] [[[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]]] [[[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]]]]，shape=(4，4，4，1)，dtype=float32)
tf。张量([[0。0.0.0.0.] [0.0.0.0.0.] [0.0.0.0.0.] [0.0.0.0.0.] [0.0.0.0.0.]]，shape=(5，5)，dtype=float32)
tf。张量([[[1。] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]] [[1.] [1.] [1.] [1.]]]，shape=(4，4，1)，dtype=float32)
tf。张量(0.0，shape=()，dtype=float32)
*#another example from previously created tensorprint(list_tensor3)tf_slicedexampleagain = list_tensor3[0,-2:]print(tf_slicedexampleagain)#selecting multiple rowstf_slicedexampleagain = list_tensor3[1::]print(tf_slicedexampleagain)*
同样，一些很酷的输出(基本但没错，最简单的东西是最酷的)。
<tf.variable shape=“(4,” dtype=“int32,” numpy=“array([[”></tf.variable>
tf。张量([3 1]，shape=(2，)，dtype=int32)
tf。张量([[ 1 9 10 11] [ 1 5 11 22] [16 17 18 19]]，shape=(3，4)，dtype=int32)
你可以在我的 Githubhttps://Github . com/joyjitchatterjee/deep learning-tensor flow-Basics/blob/master/tensor flow _ beginning . ipynb上找到这篇文章的完整的 Colab 笔记本。
仅此而已。希望你喜欢阅读这篇文章。感谢阅读，并为任何错别字/错误道歉。我希望在我的下一篇文章中涉及更多关于 Tensorflow 的内容。
如果你愿意，你可以通过 LinkedIn 联系我，电话是http://linkedin.com/in/joyjitchatterjee/
参考文献
- 张量流文档(https://www.tensorflow.org/guide)
- TensorFlow 2.0 完整教程— Python 神经网络初学者教程(https://www.youtube.com/watch?v=tPYj3fFJGjk&list = ply lya 78 q 4 izualaaoer 3 qwuzkqltzf 7 qk)
- TensorFlow 和深度学习入门(https://medium . com/@ rishit . dagli/get-started-with-tensor flow-and-Deep-Learning-part-1-72c 7d 67 f 99 fc)
网飞电影推荐—使用深度学习
网飞使用深度学习
使用 TensorFlow 构建电影推荐模型
在 Unsplash 上由 Myke Simon 拍摄的照片
在这个由两部分组成的系列中，我们将了解如何使用 TensorFlow 构建电影推荐模型。
medium.com](https://medium.com/analytics-vidhya/tensorflow-for-recommendation-model-part-1-19f6b6dc207d)
让我们从停止的地方继续。在之前的系列文章中，我们使用矩阵分解来学习用户嵌入向量，从而为我们执行推荐。这些用户嵌入表示用户和被称为反馈矩阵的电影矩阵之间的学习特征。现在，让我们了解如何使用深度学习来执行建议。下面附上了谷歌实验室。
第二部分神经 n。
colab.research.google.com](https://colab.research.google.com/drive/11zEddP5TUAVCTkUgFwtFN7LG1z2A85hB#scrollTo=TOF0qSte0ljl&uniqifier=4)
矩阵分解的缺点
在很大程度上，使用 MF 来执行推荐有一些缺点:
- 小特征空间:电影或者用户 id 唯一可以查询的特征。
- 推荐的相关性:由于 MF 讲的是用点积或者欧氏距离，所以把最受欢迎的项目推荐给大家。
卷积神经网络
在神经网络中，CNN 仍然是执行图像分类、图像识别、目标检测等的主要算法。
在神经网络中，卷积神经网络(ConvNets 或 CNN)是进行图像处理的主要类别之一
medium.com](https://medium.com/@RaghavPrabhu/understanding-of-convolutional-neural-network-cnn-deep-learning-99760835f148)
然而，在建议模型中，我们可以着手创建一个简单的 softmax CNN 模型，其中的参数为:
- 输入:用户查询输入和与之相关的条目。
- 输出:用户与物品的交互概率。
在输入空间中，可以添加更多的辅助功能，如手表时间、国家等。这将允许隐藏层中的神经网络学习更多的数据，从而在这些层中建立更多的连接。
激活层
通过定义神经网络的结构，可以增加激活层来进一步捕获更多的隐藏连接，并在隐藏层中形成更好的特征采样。对于本推荐模型，将使用校正线性单位(ReLU)。
在大多数神经网络中，将使用梯度下降算法，其中在误差反向传播期间，需要激活函数作为线性函数。这就是 ReLU 的用武之地。
如果我们看一下左边的图像，我们可以看到函数的方程可以表示为 y=max(0，x)，其中 表示当 x 的值大于 0 时采用 y 的值。这充当线性和非线性函数，其中该函数对于大于零的量是线性的，这意味着它具有线性激活函数的许多期望属性。然而，它是一个非线性函数，因为负值总是输出为零。这就是为什么 ReLu 激活功能大多用在现代 NN 上的原因。
Softmax 作为最后一层
该模型通过 softmax 层将最后一层的输出映射到概率分布。一种函数，将 X 个实数的向量作为输入，并将其归一化为由 X 个概率组成的概率分布，这些概率与输入数的指数成比例。从建议模型的角度来看:
- x 代表用户-特征交互输出的个体概率。这可以是用户接下来将要观看的建议电影
- ***∑(x)***表示该输出在最终层中所有输出上分布的概率
学机器学习？具体来说，尝试深度学习的神经网络？您可能遇到了…
medium.com](https://medium.com/data-science-bootcamp/understand-the-softmax-function-in-minutes-f3a59641e86d)
神经网络中的嵌入
与 MF 模型相比，NN 模型也具有嵌入来表示用户和项目之间的关系。模型学习嵌入，每个项目的 V，j。
然而，查询嵌入是不同的。系统确定从查询特征到嵌入的映射，而不是每个查询学习一个嵌入。因此，由于激活函数(ReLU)的存在，与 MF 模型相比，嵌入现在被概括为非线性函数。
有可能对这些嵌入执行点积来获得最终的概率分数，但是这不是本系列的范围的一部分。
输入数据
现在让我们为创建的 NN 模型定义训练数据。训练数据由查询特征和用户与之交互的项目向量(表示为概率分布)组成。变量或权重表示用户项目特征的相互作用，并且被随机初始化用于训练。
创建数据
输入数据是从 ratings()数据帧和 movies()数据帧创建的。这两个 DF 代表我们必须整理以创建输入数据的基本信息:
List comprehension 在某种程度上被用来创建这个特性，因为它速度更快，而且当内存成为一个问题时，它也是大多数程序员现在使用的东西。
数据批次
至于训练输入数据，使用批处理将数据传播到 softmax 模型中。一个批次的大小是在模型被更新之前处理的样本的数量，当地面真实值和输出被比较用于另一个迭代时。一批 4 个特征将被传播到 NN 模型中。这将是电影 id、年份、类型和标签。因此，每个用户将在神经网络模型中学习这些特定的交互。***TF . data . dataset()***用于初始化批量操作。批量大小至关重要，因为较大的批量大小(有内存限制)将允许神经网络在优化阶段更有效地学习
神经网络训练
一旦输入数据和批次被处理，神经网络训练最终可以开始。创建嵌入()函数来捕获训练数据的特征。softmax 最终层神经网络模型用于输出由 K 个概率组成的概率分布，这些概率与输入数的指数成比例。
最终总结
客观地说，矩阵因式分解经常用在大型稀疏数据环境中，其中可以使用简单点积函数来识别与用户最接近的项目。这在系统中时间和内存受限的情况下特别有用。它更容易扩展，查询更便宜，速度更快。
至于神经网络，可以形成更复杂的关系来理解推荐在模型内部如何工作。神经网络模型捕捉更个性化的偏好，因为输入可以是用户与国家、年龄、观看时间等交互的向量。在某些情况下，神经网络模型更受青睐，因为预测将更加准确，更加面向用户/有偏向，而不是纯粹基于用户和项目之间的点距离。这对于其他用例特别有用，如市场营销或广告定位，其中收集了大量用户数据，NN 可以了解每个用户的潜在偏好。同样通过使用 NN，查询嵌入通常需要在查询时计算；结果，这在计算上可能是昂贵的。
最后
如果您成功地保持了对这一点的关注，如果您对本系列有任何建议，或者有任何尝试使用 NN 的 MF 构建推荐模型的经验，请留下评论。*
普雷姆·库马尔 是一个无私的学习者，对围绕我们的日常数据充满热情。在 LinkedIn 上与我联系当你写信谈论这个故事以及等待的未来发展时，请提及这个故事。
网飞电影推荐—使用协同过滤
我们将了解如何使用 TensorFlow 构建一个电影推荐模型。
什么是推荐模型？
推荐模型，简而言之，是一种算法，旨在根据用户的行为向用户提供最相关和最相关的信息。像网飞和谷歌这样的公司有一个收集数据行为的巨大数据库，能够执行最先进的推荐，以便他们可以向用户显示最相关的内容或服务，以增加参与度。在第 1 部分中，我们将构建一个推荐模型，使用 协同过滤 向用户推荐电影。
笔记本
colab.research.google.com](https://colab.research.google.com/drive/1GV4lg3LRN-ghtAwJbN_Xy9tQmpAEykPY)
协同过滤？
协同过滤处理用户和项目之间的相似性以执行推荐。这意味着算法不断地发现用户之间的关系，并依次进行推荐。算法学习用户之间的嵌入，而不必调整特征。最常见的技术是通过执行矩阵分解来找到构成特定用户兴趣的嵌入或特征。
矩阵分解
矩阵分解是一种嵌入。假设我们有一个用户电影矩阵或反馈矩阵，一个 ᴺᴹ，模型学习分解成:
- A 用户 嵌入向量 U ，其中第 N 行是项目 m 的嵌入
- An 项 嵌入向量 V ，其中 M 行是对项 N 的嵌入
学习嵌入向量，使得通过执行 UVᵀ，可以形成反馈矩阵的近似。
损失函数
为了逼近反馈矩阵，需要一个损失函数。直观的损失函数之一是使用均方误差(MSE)。MSE 计算反馈矩阵 a 和近似 UVᵀ矩阵的差值。简单来说:
其中:
- n 代表用户总数
- Yᵢ 代表反馈矩阵 a
- Yᵢ_bar 代表 UVᵀ的近似矩阵
正则化函数
训练模型最常见的问题之一是 过度拟合。*如果这个特定的异常特征具有大的“幅度”或偏差，那么可以说该模型对于这些特定特征是过度拟合的。为了减少这种情况，我们可以在 MSE 损失中增加一个惩罚项。最常用的模型是套索回归和岭回归*。**
训练机器学习模型的一个主要方面是避免过度拟合。该模型将有一个低…
towardsdatascience.com](/regularization-in-machine-learning-76441ddcf99a)
岭回归(L2)
岭公式
- 取系数的平方、T43、w、。因此，任何大的 w 值都将被扣分，以减少过度拟合。
拉索回归(L1)
套索公式
- 取系数的大小，， w ，。因此，任何大的 w 值都会被扣分，以减少过度拟合。
- 如果你有一个稀疏矩阵，收缩系数和执行特征选择是有用的，这正是我们所需要的。
提出建议
一般来说，步骤*(和功能)*如下:
- 创建一个稀疏张量 : tf。SparseTensor() ，用于随机初始化的和 V 矩阵
- *创建损失函数和优化器:*TF . losses . mean _ squared _ error()，来估计带有正则化惩罚和 SGD 作为优化器的总损失
- 创建模型 : tf。Session() ，初始化超参数、学习率和嵌入
- *列车车型: *tf。Session.run()，学习反馈矩阵的嵌入并返回 v 和 k 作为嵌入向量
- *展示推荐: *df。DataFrame()，显示与被查询用户最近的电影
准备好模型后，让我们尝试计算用户 ID: 500 的推荐值
决赛成绩
我们可以看到，该模型已经学习了用户 500 的嵌入，并且它推荐了用户 ID: 500 可能喜欢的前 5 部电影。
最后
如果您成功地保持了对这一点的关注，如果您对本系列有任何建议，或者有任何尝试使用 NN 的 MF 构建推荐模型的经验，请留下评论。
普雷姆·库马尔 是一个无私的学习者，对我们身边的日常数据充满热情。在LinkedIn上与我联系，当你写信谈论这个故事和等待的未来发展时，提及这个故事。
TensorFlow Lite Android 支持库:简化 Android 上的 ML
介绍新的 TF Lite Android 支持库
Benjamin Sow 在 Unsplash 上拍摄的照片
每个人都喜欢 TensorFlow，当你可以直接在 Android 上运行 TF 模型时就更喜欢了。我们都在 Android 上使用 TensorFlow Lite，我们也有几个 CodeLabs 在上面。使用 Android 上的Interpreter类，我们目前正在应用程序中运行我们的.tflite模型。
但是在那之前我们要做很多事情，对吗？如果我们正在执行图像分类任务，你可能会从相机库中获得一个Bitmap或Image对象，然后我们将其转换为float[][][]或byte[]。然后我们从assets文件夹中加载我们的模型作为MappedByteBuffer。在调用了interpreter.run()之后，我们获得了类概率，我们对其执行argmax()操作，然后最终从labels.txt文件中获得一个标签。
这是我们开发人员遵循的传统方法，没有其他方法。
TensorFlow Lite Android 支持库简介
TensorFlow 团队发布了 TensorFlow Lite Android 支持库来解决预处理的繁琐任务。GitHub 页面给出了他们目标的直觉，
移动应用程序开发人员通常与位图等类型化对象或整数等原语进行交互。然而，运行设备上机器学习模型的 TensorFlow Lite 解释器使用 ByteBuffer 形式的张量，这可能很难调试和操作。TensorFlow Lite Android 支持库旨在帮助处理 TensorFlow Lite 模型的输入和输出，并使 TensorFlow Lite 解释器更易于使用。
首先，我们需要在我们的 Android 项目中做到这一点。还记得build.gradle文件吗？对！我们将把这些依赖关系添加到我们的应用程序级build.gradle文件中，
1.创建输入和输出数组
运行 TFLite 模型的第一步是创建一些数组对象，它可以存储模型的输入以及模型将产生的输出。为了让我们的生活更轻松，减少与float[]对象的斗争，TF 支持库包含了一个[TensorBuffer](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/tensorbuffer/TensorBuffer.java)类，它采用所需数组的形状及其数据类型。
片段 1
注:截至 2020 年 4 月 1 日，仅支持
**DataType.FLOAT32**和**DataType.UINT8**。
您甚至可以通过修改现有的TensorBuffer对象的数据类型来创建一个TensorBuffer对象，
**val** newImage = TensorImage.createFrom( image , DataType.**FLOAT32** )
2.图像操作
如果您正在处理对象检测、图像分类或其他与图像相关的模型，您需要在Bitmap上工作，并调整其大小或使其正常化。我们对此有三个操作，即[ResizeOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/image/ops/ResizeOp.java)、[ResizeWithCropOrPadOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/image/ops/ResizeWithCropOrPadOp.java)和[Rot900p](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/image/ops/Rot90Op.java)。
首先，我们使用[ImageProcessor](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/image/ImageProcessor.java)类定义预处理管道。
问题:什么是双线性和最近邻法？
答:读这个。
接下来，创建一个[TensorImage](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/image/TensorImage.java)对象并处理图像。
3.张量运算
图像阵列的归一化对于几乎所有的模型都是必要的，无论是图像分类模型还是回归模型。对于处理张量，我们有一个[TensorProcessor](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/TensorProcessor.java)。除了[NormalizeOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/ops/NormalizeOp.java)，我们还有[CastOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/ops/CastOp.java)、[QuantizeOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/ops/QuantizeOp.java)和[DequantizeOp](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/ops/DequantizeOp.java)。
问题:什么是正常化？
答:将实际值范围转换为标准值范围的过程，通常为-1 到+1 或 0 到 1。例如，假设某个特征的自然范围是 800 到 6000。通过减法和除法，您可以将这些值规范化到-1 到+1 的范围内。
此外，我们可以通过实现[TensorOperator](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/TensorOperator.java)类来自由构建定制的 ops，如下所示。
4.加载模型和标签
我们可以使用[FileUtil.loadMappedFile()](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/experimental/support/java/src/java/org/tensorflow/lite/support/common/FileUtil.java)方法轻松加载我们的.tflite模型。类似地，我们可以从InputStream或资产文件夹中加载标签。
然后使用Interpreter.run()进行推理，
关于 Android 机器学习的更多资源
仅此而已！
我希望你喜欢新的 TensorFlow Lite Android 支持库。这是一个内部的快速审查，但尝试探索自己。感谢阅读！
TensorFlow 还是 PyTorch？
深度学习网络编程的最佳框架是什么？
UPC Barcelona Tech的一名学生问我为神经网络编程的最佳框架是什么？TensorFlow 还是 PyTorch？。我的回答是:别急，你从哪一个开始，选择哪一个都不重要，重要的是开始， 走吧！
在两种环境中对神经网络进行编程的步骤在机器学习中是相同的:
- 导入所需的库，
- 加载并预处理数据，
- 定义模型，
- 定义优化器和损失函数，
- 训练模型，最后
- 评估模型。
这些步骤可以在任一框架中非常相似地实现。为此，在本出版物中，我们将构建一个神经网络模型，该模型将在 API PyTorch 和 TensorFlow 的 API Keras 中对手写数字进行分类。整个代码可以在 GitHub 上测试和运行它作为一个谷歌笔记本。
1。神经网络编程步骤
a)导入所需的库
在这两个框架中，我们首先需要导入一些 Python 库，并定义一些训练所需的超参数:
import numpy as np
import matplotlib.pyplot as plt epochs = 10
batch_size=64
对于 TensorFlow，您只需要这个库:
import tensorflow as tf
而在 PyTorch 的例子中，这两个:
import torch
import torchvision
b)加载和预处理数据
使用 TensorFlow 加载和准备数据可以通过这两行代码完成:
(x_trainTF_, y_trainTF_), _ = tf.keras.datasets.mnist.load_data() x_trainTF = x_trainTF_.reshape(60000, 784).astype('float32')/255 y_trainTF = tf.keras.utils.to_categorical(y_trainTF_,
num_classes=10)
在 PyTorch 和另外两个人在一起的时候:
xy_trainPT = torchvision.datasets.MNIST(root='./data', train=True, download=True,transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor()])) xy_trainPT_loader = torch.utils.data.DataLoader(xy_trainPT, batch_size=batch_size)
我们可以验证这两个代码已经用库matplotlib.pyplot加载了相同的数据:
print("TensorFlow:")
fig = plt.figure(figsize=(25, 4))
for idx in np.arange(20):
ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])
ax.imshow(x_trainTF_[idx], cmap=plt.cm.binary)
ax.set_title(str(y_trainTF_[idx]))
print("PyTorch:")
fig = plt.figure(figsize=(25, 4))
for idx in np.arange(20):
ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])
ax.imshow(torch.squeeze(image, dim = 0).numpy(),
cmap=plt.cm.binary)
image, label = xy_trainPT [idx]
ax.set_title(str(label))
c)定义模型
为了定义模型，在这两种情况下，都使用了相当相似的语法。在 TensorFlow 的情况下，可以使用以下代码完成:
modelTF = tf.keras.Sequential([ tf.keras.layers.Dense(10,activation='sigmoid',input_shape=(784,)), tf.keras.layers.Dense(10,activation='softmax')
])
在 PyTorch 有这样一个:
modelPT= torch.nn.Sequential(
torch.nn.Linear(784,10),
torch.nn.Sigmoid(),
torch.nn.Linear(10,10),
torch.nn.LogSoftmax(dim=1)
)
d)定义优化器和损失函数
同样，指定优化器和损失函数的方式是完全相同的。使用 TensorFlow，我们可以这样做:
modelTF.compile(
loss="categorical_crossentropy",
optimizer=tf.optimizers.SGD(lr=0.01),
metrics = ['accuracy']
)
而 PyTorch 是这样的:
criterion = torch.nn.NLLLoss()
optimizer = torch.optim.SGD(modelPT.parameters(), lr=0.01)
e)训练模型
谈到培训，我们发现最大的差异。在 TensorFlow 的例子中，我们可以只用这一行代码来完成:
_ = modelTF.fit(x_trainTF, y_trainTF, epochs=epochs,
batch_size=batch_size, verbose = 0)
而在 Pytorch，我们需要像这样更长的东西:
for e in range(epochs):
for images, labels in xy_trainPT_loader:
images = images.view(images.shape[0], -1)
loss = criterion(modelPT(images), labels)
loss.backward()
optimizer.step()
optimizer.zero_grad()
在 PyTorch 中，没有像 Keras 或 Scikit-learn 中的fit()那样的“预制”数据模型调优函数，所以训练循环必须由程序员指定。嗯，在简单性和实用性之间，这里有某种妥协，以便能够做更多定制的事情。
f)评估模型
当我们需要评估模型时，也会发生同样的情况，而在 TensorFlow 中，您只需用测试数据调用方法evaluate():
_, (x_testTF, y_testTF)= tf.keras.datasets.mnist.load_data()
x_testTF = x_testTF.reshape(10000, 784).astype('float32')/255
y_testTF = tf.keras.utils.to_categorical(y_testTF, num_classes=10)
_ , test_accTF = modelTF.evaluate(x_testTF, y_testTF)
print('\nAccuracy del model amb TensorFlow =', test_accTF)TensorFlow model Accuracy = 0.8658999800682068
在 PyTorch 中，再次要求程序员指定评估循环:
xy_testPT = torchvision.datasets.MNIST(root='./data', train=False, download=True,
transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor()]))
xy_test_loaderPT = torch.utils.data.DataLoader(xy_testPT)
correct_count, all_count = 0, 0
for images,labels in xy_test_loaderPT:
for i in range(len(labels)):
img = images[i].view(1, 784)
logps = modelPT(img)
ps = torch.exp(logps)
probab = list(ps.detach().numpy()[0])
pred_label = probab.index(max(probab))
true_label = labels.numpy()[i]
if(true_label == pred_label):
correct_count += 1
all_count += 1
print("\nAccuracy del model amb PyTorch =", (correct_count/all_count))TensorFlow model Accuracy = 0.8657
2。更重要的是他们将会融合！
正如这个简单的例子所示，在 TensorFlow 和 PyTorch 中创建神经网络的方式并没有什么不同，除了程序员实现训练和评估循环的一些细节，以及一些超参数如epochs或batch_size在不同的步骤中指定。
事实上，这两个框架在过去的两年中一直在不断融合，相互学习并采用各自的最佳特性。例如，在几周前发布的 TensorFlow 2.2 的新版本中，训练步骤可以像 PyTorch 一样完成，现在程序员可以通过实现traint_step()来指定循环体的详细内容。所以不要担心选择“错误”的框架，它们会收敛的！最重要的是学习背后的深度学习理念，你在其中一个框架里获得的所有知识，在另一个框架里都会对你有用。
3。产还是研？
然而，很明显，如果你想要的是将解决方案投入生产或在神经网络中进行研究，这是不同的。在这种情况下，选择哪一个的决定很重要。
TensorFlow 是一个非常强大和成熟的 Python 库，具有强大的可视化特性和各种用于高性能模型开发的选项。它具有为生产做好准备的展示选项，以及对 web 和移动平台的自动支持。
另一方面，PyTorch 仍然是一个年轻的框架，但是有一个非常活跃的社区，尤其是在研究领域。门户梯度 如图附图py torch 的兴起和采用研究社区基于主要会议主题(CVPR、ICRL、ICML、NIPS、ACL、ICCV 等)发表的研究论文数量。).
从图中可以看出，2018 年 PyTorch 框架的使用是少数，相比之下，2019 年研究人员对它的使用是压倒性的。所以如果想打造人工智能相关的产品，TensorFlow 是个不错的选择。如果你想做研究，我推荐 PyTorch。
因此，如果你想打造与人工智能相关的产品，TensorFlow 是一个不错的选择。如果你想做研究，我推荐 PyTorch。
4。如有疑问，选择 Kera s
如果不确定，先从 TensorFlow 的 Keras API 开始。PyTorch 的 API 有更多的灵活性和可控性，但是很明显 TensorFlow 的 Keras API 可以更容易上手。如果你正在阅读这篇帖子，我可以假设你正开始深度学习的话题。
此外，您还有我在过去两年中准备的其他出版物中关于 Keras 的额外文档。(一个秘密:我也计划在夏天准备好 PyTorch 的等效文档)。
顺便说一下，Keras 为 2020 年计划了几款“让它更简单”的新产品。这里列出了最近添加或即将推出的一些新功能:
层和预处理 API
到目前为止，我们已经用 NumPy 和 PIL (Python Imaging Library)编写的辅助工具完成了预处理。而且这种外部预处理使得模型的可移植性降低，因为每当有人重用一个已经训练好的模型时，他们都必须重放预处理程序管道。因此，预处理现在可以通过“预处理层”成为模型的一部分。这包括文本标准化、标记化、矢量化、图像标准化、数据扩充等方面。也就是说，这将允许模型接受原始文本或原始图像作为输入。我个人觉得这会很有意思。
Keras 调谐器
这是一个框架，允许您在 Keras 中找到模型的最佳超参数。当你花一些时间在深度学习上工作时，你会看到这解决了模型构建的一个代价高昂的问题，例如细化超参数，以使模型表现最佳。这总是一项非常困难的任务。
AutoKeras
这个项目试图在几行代码中为数据找到一个好的 ML 模型，根据可能模型的空间自动搜索最佳可能模型，并使用 Keras Tuner 查找超参数调整。对于高级用户，AutoKeras 还允许对搜索空间和过程的配置进行更高级别的控制。
云角
我们的愿景是让程序员更容易将代码(在我们的笔记本电脑或 Google Colab 上本地工作的代码)转移到云中，使其能够在云中以最佳和分布式的方式执行代码，而不必担心集群或 Docker 参数。
与 TensorFlow 的集成
与 TFX (TensorFlow Extended，一个管理 ML 生产应用的平台)的更多集成工作正在进行中，并更好地支持将模型导出到 TF Lite(一个用于移动和嵌入式设备的 ML 执行引擎)。毫无疑问，提高对模型生产的支持对于 Keras 中程序员的忠诚度是至关重要的。
5。总而言之
用一个明喻来说，你认为开始编程最好的语言是 C ++还是 Java？嗯……这取决于我们想用它做什么，最重要的是取决于我们有什么工具可以学习。我们可能无法同意，因为我们有一个先入为主的观点，我们很难改变我们对这个问题的答案(PyTorch 和 TensorFlow 的“粉丝”也是如此😉 ).但是我们肯定同意重要的是知道如何编程。事实上，无论我们从一种语言的编程中学到什么，当我们使用另一种语言时，它都会为我们服务，对吗？同样的事情也发生在框架上，重要的是了解深度学习，而不是框架的语法细节，然后我们会将这些知识用于流行的框架或我们当时有更多机会使用的框架。
这篇文章的代码可以从 GitHub 下载
[## TensorFlow vs Pytorch:战斗仍在继续
本周，脸书宣布 PyTorch 1.5 的发布
towardsdatascience.com](/tensorflow-vs-pytorch-the-battle-continues-9dcd34bb47d4)
原文于 2020 年 4 月 19 日 发表于加泰罗尼亚语 https://Torres . ai。
附录 1:对 PyTorch 感兴趣？
初学 PyTorch
towardsdatascience.com](/deep-learning-with-pytorch-a93b09bdae96)
附录二:对 TensorFlow 感兴趣？
[## 卷积神经网络初学者使用 Keras 和 TensorFlow 2
边做边学:包含 GitHub 代码的实用指南
towardsdatascience.com](/convolutional-neural-networks-for-beginners-using-keras-and-tensorflow-2-c578f7b3bf25)
张量流性能分析
在以前的帖子中(这里和这里，我告诉过你我们的团队如何使用亚马逊 SageMaker 和亚马逊 s3 服务来训练我们对大量数据的深度神经网络。
在这篇博客中，我想讨论如何分析在 TensorFlow 中运行的 DNN 训练课程的性能。当谈到 DNN 训练课的“表现”时，人们可能指的是许多不同的事情。在本博客的上下文中，“性能”分析指的是对执行训练的速度(例如，通过每秒迭代次数的训练吞吐量来衡量)的分析，以及会话利用系统资源来实现这一速度的方式。我们将不会提及被训练的模型的性能，其通常通过测试集上的损失或度量评估来测量。性能的另一个衡量标准是训练收敛之前所需的批次数量。这也超出了本博客的范围。
简而言之，如果你想弄清楚为什么你的训练跑得慢，你来对地方了。如果您正在寻找提高 mnist 模型准确性的方法，或者正在寻找使用什么优化器设置来加速收敛，那么您还没有找到。
我们将回顾的例子是用 TensorFlow 编写的，并使用 Amazon SageMaker 服务在云中运行，但是我们将进行的讨论同样适用于任何其他培训环境。
前奏
任何关于你的训练的性能分析的讨论都需要我们清楚目标是什么，或者我们试图优化什么效用函数。您的效用函数可能取决于许多因素，包括您可支配的训练实例的数量、这些实例的成本、您需要训练的模型的数量、项目调度约束等。
为了进行有意义的讨论，我们将做一些简化的假设。我们的目标将是在给定固定训练环境的情况下，最大化训练会话的吞吐量，而不损害最终模型的质量，也不增加收敛所需的训练样本的数量。
如前所述，这个目标包含了一些模糊之处，我们会及时解释。
培训实例
我们的第一个简化假设是，训练是在单个实例/机器上执行的，并且实例类型是固定的。
自然，不同的型号在不同类型的机器上表现不同。在理想的情况下，我们总是能够选择一台对于被训练的模型来说是最优的机器，也就是说，一台所有资源都被充分利用的机器。这样，我们可以避免未被使用的资源成本。不幸的是，在现实世界中，我们通常面临固定数量的实例类型可供选择。例如，Amazon SageMaker 提供了多种多样的实例类型供选择，它们在 GPU 的类型和数量、CPU 的数量、网络属性、内存大小等方面都有所不同。另一方面，人们没有能力自由选择(基于他们的模型的属性)具有特定数量的 CPU、特定的 GPU 和特定的网络带宽的机器。
为了选择最合适的训练实例，必须仔细权衡模型对不同训练实例的适合程度，以及诸如这些实例的成本和可用性以及调度要求等考虑因素。正如我们在本帖中所描述的，这需要对在每种不同的实例类型上训练模型所能达到的最大性能进行全面的分析。
我们将把讨论限制在具有单个 GPU 的实例类型上。具体来说，我们将在配备 NVIDIA V100 Tensor Core GPU 的机器上工作。如果您使用 Amazon SageMaker 服务进行培训，这就是 ml.p3.2xlarge 实例类型。
培训框架
有许多不同的库和框架可用于训练 DNN 模型。和以前一样，固定模型、固定训练算法和固定硬件的训练性能会因不同的软件解决方案而异。正如帖子标题中所强调的，我们的重点将放在 TensorFlow 培训环境上。即使在这种训练环境中，性能也可能取决于许多因素，如框架版本、是否选择高级 API(如 tf.estimator 或 tf.keras.model.fit)或实现自定义训练循环，以及将训练数据输入训练管道的方式。我们在本文中的假设是，训练将在 TensorFlow 2.2 中使用 tf.keras.model.fit() API 执行，数据将使用 tf.dataset APIs 提供。
规则和约束
在没有限制的情况下，加快培训量将是小菜一碟。例如，我们可以简单地减少我们的模型架构的大小，这样培训就会进行。当然，这很可能会扼杀训练的收敛能力，并且所得到的模型预测可能是无用的。显然，我们必须确保我们为加速训练所采取的任何行动都不会损害最终模型的质量。
在我们的讨论中，我们引入了一个额外的约束条件，即我们不希望影响训练收敛所需的总时间，这是通过在收敛之前输入到网络中的训练样本总数来衡量的。换句话说，我们做了一个简化的假设，即我们的模型需要固定数量的训练样本才能收敛，并且我们必须优化的选项不会改变这个固定数量。基于这一假设，给定一个固定的实例和软件环境，我们的目标是优化训练所花费的总时间(以秒为单位)，或者，优化训练吞吐量，以训练循环每秒处理的样本数来衡量。
我们强调这是我们为了简化讨论而引入的人为约束。当然，可能存在这样的情况:模型架构的变化会增加收敛所需的样本数量，同时减少收敛所需的总时间。例如，降低某些变量的位精度可能会增加吞吐量，但也可能需要更多步骤才能收敛。如果训练的总时间减少了，并且最终的模型预测也一样好，那么这将是一个很好的优化。另一个重要的例子是增加批量。增加训练批量是增加产量的基本方法之一。但是，有一些模型的训练质量可能对批量大小很敏感。我们做了一个简化的假设，即这种影响可以忽略不计，并且可以通过调整其他超参数(如学习率)来克服。
计量单位
我们将用来测量吞吐量的单位是训练循环每秒处理的样本的平均数。另一种更常见的吞吐量单位度量是每秒的平均训练迭代次数、每秒的步骤数或每秒的批次数。然而，由于这种测量是基于所选择的(全局)批次大小，因此很难在使用不同批次大小的运行之间进行比较。
要提取此测量值，您可以依赖 TensorFlow 打印的日志(在每个时期结束时)，也可以自行实施测量值(例如，使用自定义 TensorFlow 回调)。
优化策略
我们提高训练吞吐量的主要方法是提高训练实例的资源利用率。理论上，任何未充分利用的资源都是增加吞吐量的潜在机会。然而，实际上，一旦最昂贵和最重要的系统资源 GPU 得到充分利用，并且假设我们对 GPU 操作的性能感到满意，我们将认为我们的任务已经完成。理论上，我们可以考虑将一些训练卸载给 CPU，但是性能增益可能是微不足道的(如果有的话)——当然不值得头痛。未充分利用可能是管道未达到其最大容量的结果(例如，所有资源都没有得到充分利用)。在这种情况下，增加产量相当容易，(例如，简单地增加批量)。如果管道处于最大容量，系统资源的利用不足通常是管道中瓶颈的结果。例如，在等待 CPU 准备训练数据时，GPU 可能处于空闲状态。在这种情况下，我们将尝试通过消除瓶颈来增加吞吐量。例如，我们可以在 CPU 和 GPU 之间引入并行化，这样 GPU 就永远不必等待数据。
一般策略是反复执行以下两个步骤，直到我们对吞吐量感到满意，或者直到 GPU 得到充分利用:
1.概述培训绩效，以确定流程中的瓶颈和未充分利用的资源
2.解决瓶颈并提高资源利用率
请注意，在任何给定的时间，管道中可能有多个瓶颈。CPU 可能在等待从网络接收数据时处于空闲状态，GPU 可能在等待 CPU 准备用于训练的数据时处于空闲状态。此外，在培训的不同阶段可能会出现不同的瓶颈。例如，当我们保存一个检查点时，GPU 可能被充分利用，但仅在迭代期间空闲。这种瓶颈，即使只是周期性的，仍然可能对平均吞吐量产生重大影响，应该加以解决。
为什么性能分析很重要？
这一点现在应该非常清楚了，但有时显而易见的事情需要陈述。我经常遇到对 40%的 GPU 利用率非常满意的开发人员。让我想尖叫。GPU(通常)是你正在使用的最昂贵的资源；如果你对低于 90%的利用率感到满意，那你就是在浪费你(你公司)的钱。更不用说你可能会更快地交付你的产品。
一切都是为了钱。培训资源是昂贵的，如果你没有最大限度地利用它们，你就是在犯反人类罪。
我希望你能确信描述你的训练表现和最大化资源利用的重要性。在下一节中，我们将回顾典型培训渠道中的一些潜在瓶颈。然后，我们将调查一些我们可以用来识别这些瓶颈的工具。
培训渠道和潜在瓶颈
为了便于讨论培训课程中可能出现的瓶颈，我们提供了一个典型的培训流程图。培训分为八个步骤，每个步骤都可能阻碍培训流程。请注意，虽然在此图中训练是在多个 GPU 上执行的，但在本文中，如上所述，我们将假设只有一个 GPU。
样本培训渠道(按作者)
原始数据输入
除非您是自动生成培训数据，否则您可能会从存储中加载它。这可能来自本地磁盘，也可能通过网络来自远程存储位置。在这两种情况下，您使用的系统资源都有可能阻塞管道。如果每个训练样本的原始数据量特别大，如果您的 IO 接口具有高延迟，或者如果您的训练实例的网络带宽很低，您可能会发现您的 CPU 在等待原始数据进入时处于空闲状态。一个经典的例子是，如果你使用“filemode”和 Amazon SageMaker 一起训练。在“文件模式”中，甚至在训练开始之前，所有的训练数据都被下载到本地磁盘。如果你有很多数据，你可能要等一段时间。另一个 Amazon Sagemaker 选项是使用“pipemode”。这允许您将数据直接从 s3 传输到您的输入数据管道中，从而避免训练启动的巨大瓶颈。但是，即使在“管道模式”的情况下，您也很容易遇到资源限制。例如，如果您的实例类型支持高达每秒 10 千兆位的网络 IO，并且每个样本需要 100 兆位的原始数据，则无论您的 GPU 有多快，您都将拥有每秒 100 个训练样本的上限。解决这些问题的方法是减少原始数据，压缩一些数据，或者选择一个具有更高网络 IO 带宽的实例类型。
在我们给出的示例中，限制来自实例的网络 IO 带宽，但也可能来自您可以从 s3 或其他地方获取的数据量的带宽。(附注:如果您在不使用管道模式的情况下从 s3 中提取数据，请确保选择启用了弹性网络适配器的实例类型。)
数据预处理
训练管道的下一步是数据预处理。在这一阶段，通常在 CPU 上执行，原始数据准备好进入训练循环。这可能包括对输入数据应用扩充、插入屏蔽元素、批处理、过滤等等。tensorflow.dataset 函数包括用于在 CPU 内并行处理操作的内置功能(例如 tf.dataset.map 例程中的 num_parallel_calls 参数)，以及用于与 GPU 并行运行 CPU 的内置功能(例如 tf.dataset.prefetch)。然而，如果您在这个阶段运行繁重或内存密集型计算，您可能仍然会发现您的 GPU 空闲，因为它等待数据输入。
更新:请务必查看我的最近的帖子，主题是数据预处理管道中的性能瓶颈。
CPU 到 GPU 的数据传输
在大多数情况下，您的 CPU 和 GPU 使用不同的内存，训练样本需要从 CPU 内存复制到 GPU 内存，然后训练循环才能运行。这也可能导致瓶颈，这取决于数据样本的大小和接口带宽。您应该考虑的一件事是，只要有可能，就推迟转换到更高位表示(tf.cast())或解压缩位掩码(tf.one_hot)，直到数据被复制到 GPU 内存之后。
GPU 向前向后
培训管道的核心是向前和向后管道。这个步骤是在 GPU 上执行的。由于 GPU 是最昂贵的资源，我们希望 GPU 始终保持活跃并处于最佳性能。在大多数情况下，平均吞吐量(以每秒训练的样本数表示)会随着批处理大小的增加而增加，因此我们会尝试将批处理大小增加到 GPU 的内存容量。
显然，这一步的吞吐量是你的模型架构和损失函数的函数。减少计算量的常用方法有很多。这里有一个非常小的例子:
相比密集图层，更喜欢 conv 图层
用一系列具有相同感受野的较小的回旋来代替大的回旋
使用低精度或混合精度变量类型
考虑使用 TensorFlow 本机函数，而不是 tf.py_func
优先选择 tf.where 而不是 tf.cond
研究您的模型和层设置如何影响您的 GPU 性能，例如内存布局(通道优先或最后)和内存对齐(层输入和输出大小、通道数量、卷积滤波器形状等)，并相应地设计您的模型
自定义图优化
另一件要注意的事情是图形操作，它不受 GPU 支持，因此被卸载回 CPU。有时，您可能会发现在训练步骤的中间，GPU 会将数据发送回 CPU 进行处理，并等到处理后的数据返回后再继续计算。不用说，这会降低您的吞吐量。在这种情况下，您应该使用分析工具来查明有问题的操作，并进行必要的调整，以便它们可以在 GPU 上运行。
梯度共享
仅当在多个 GPU 上训练运行分布式训练时，才执行此步骤，无论是在单个训练实例上还是在多个实例上。我们将分布式培训的讨论留到以后的文章中，但是我们会注意到这一步也可能引入瓶颈。在分布式训练期间，每个 GPU 必须从所有其他 GPU 收集梯度。根据分布策略、梯度的数量和大小以及 GPU 之间通信通道的带宽，GPU 在收集梯度时可能会发现自己处于空闲状态。为了解决这些问题，可以降低梯度的位精度、调整通信信道或考虑其他分发策略。
GPU 到 CPU 的数据传输
在训练过程中，GPU 会向 CPU 返回数据。通常，这将包括损失和度量结果，但也可能周期性地包括更多存储器密集型输出张量或模型权重。和以前一样，这种数据传输可能会在训练的某些阶段引入瓶颈，这取决于数据的大小和接口带宽。
模型输出处理
CPU 可能会对从 GPU 接收的输出数据执行一些处理。这个过程通常发生在 TensorFlow 回调中。这些可以用来评估张量，创建图像摘要，收集统计数据，更新学习率等等。这可能会以不同的方式减少培训量:
如果处理是计算或内存密集型的，这可能会成为性能瓶颈。如果处理独立于模型 GPU 状态，您可能想要尝试在一个单独的(非阻塞的)线程中运行。
运行大量回调也可能成为管道的瓶颈。你可能会考虑把它们合并成一个小数字。
如果您的回调在每次迭代中处理输出，您也可能会降低吞吐量。考虑降低处理的频率，或者将处理添加到 GPU 模型图中(例如，使用定制的张量流度量)。
CPU 到存储
在训练期间，CPU 可能会定期将事件文件、日志文件或模型检查点传输到存储。像以前一样，大量的数据加上有限的 IO 带宽可能会导致训练管道中的延迟。即使您小心翼翼地使数据传输无阻塞(例如，使用专用的 CPU 线程)，您也可能使用共享相同有限带宽的网络输入和输出通道(如在 Amazon SageMaker 实例上)。在这种情况下，通过网络输入提供的原始训练数据量可能会下降。
发生这种情况的一种方式是，如果我们将所有的张量流汇总收集在一个事件文件中，该文件在训练过程中不断增长。每次事件文件上传到 s3 时，网络上传输的数据量都会增加。当文件变得非常大时，数据上载会干扰训练。
性能分析工具
现在，我们已经了解了在培训过程中可能会遇到的一些瓶颈，让我们回顾一下您可以使用的一些工具和技术来识别和分析它们。
实例度量
一个好的起点是评估培训实例的资源是如何被利用的。在 Amazon SageMaker 中，这些是作为“实例指标”提供的，显示在培训工作页面的“监控”部分，以及 Amazon SageMaker Studio 中。以下是“培训职务”页面上的一个示例:
实例度量(从 AWS 控制台)
实例指标包括内存利用率、CPU 利用率、网络输入、网络输出、GPU 内存利用率、GPU 利用率和磁盘利用率的图表，其中测量值以五分钟为间隔显示。您可以使用它来确保事情按预期运行，并获得可以改进的高层次指示。(我们称之为“高水平”,因为测量相对较少。)例如，您可以验证您实际上正在 GPU 上运行，并评估您的使用情况。此外，您可以识别不同指标中的异常，例如:
CPU/GPU 利用率下降，这可能表明存在瓶颈
上升的 CPU 内存可能表示内存泄漏
断断续续的网络输入可能表明我们从 s3 获取数据的方式存在问题
如果网络输入达到最大容量(与训练实例属性相比),这可能表示输入管道出现瓶颈
上升的网络输出可能表明我们正在上传一个不断增长的文件，而不是上传小文件
GPU 启动时间的延迟可能表示模型编译时间过长
值得注意的一点是，TensorFlow 的默认行为是占用所有的 GPU 内存。所以不要因为 GPU 内存利用率显示为 100%而过度惊慌(或高兴)。要配置 TensorFlow 只使用它实际需要的内存，您需要应用下面的代码行。
gpus = tf.config.experimental.list_physical_devices('GPU')
**for** gpu **in** gpus:
tf.config.experimental.set_memory_growth(gpu, **True**)
点击“View Instance Metrics”链接会将您带到 CloudWatch 管理控制台，在这里您可以使用度量和图表进行一些操作。例如，您可以放大训练的特定间隔，减少测量间隔(到一分钟)，并在单个图表上显示多个指标。
SageMaker 还允许您在该窗口中包含自己的自定义指标。这些被称为“算法度量”。详情见 SageMaker 文档。例如，您可以将培训吞吐量定义为一个指标，并将其显示在此窗口中。
这种性能分析方法还有许多不足之处。除了度量的不频繁，我们很少收到关于代码的哪些部分需要改进的信息。未充分利用的 GPU 可能源于批量较小或瓶颈。高利用率的 GPU 可能是低效损失函数的结果。获取更多的信息需要更多的大炮。
如果您在自己的训练实例上运行，而不是在 SageMaker 服务中运行，那么您将需要自己使用通用的、现成的系统概要分析器来收集“实例度量”。在 linux 环境中，您可以使用命令行工具，如 nmon、perf、strace、top 和 iotop。如果您使用的是 NVIDIA GPU，您可以使用 nvidia-smi(带-l 标志)。
性能分析器
要更深入地了解训练课程不同阶段的表现，您应该使用性能分析器。不同的开发框架可以使用不同的分析器。TenorFlow 提供了 TensorFlow Profiler 用于分析 tf 模型。您第一次接触性能分析器可能会有点害怕。通常有多个图表，看起来可能超载，而且乍一看似乎令人困惑。如何解释报告的大量数据并不总是一目了然。但是一旦掌握了窍门，分析器在评估资源利用率、识别瓶颈和提高模型性能方面非常有用。
张量流剖面仪
查看 TensorFlow Profiler 指南和 TensorBoard Profiler 教程了解如何使用该分析器。当使用 tf.keras.model.fit()进行训练时，集成分析的最简单方法是使用 TensorBoard Keras 回调，如下所示:
tbc = tf.keras.callbacks.TensorBoard(log_dir='/tmp/tb',
profile_batch='20, 24')
这将捕获迭代 20 到 24 的统计数据，并将它们保存到一个可以在 TensorBoard 中打开和分析的文件中。(间隔的大小会影响捕获的数据量。)
请注意，TensorFlow 分析器回调是有限的，因为它在一系列迭代上运行，而不是在整个训练会话上运行。这意味着，要评估特定的迭代(例如，保存检查点的迭代)或了解性能如何随时间变化，您需要运行不同的分析会话，并在它们之间进行比较。或者，您可以使用更高级的分析 API，这将允许您更自由地收集统计信息。
编程技术
有时候，对你的训练表现有一个好的感觉的最好方法是通过摆弄你的程序来看看不同的变化是如何影响表现的。以下是一些你可以尝试的小例子:
您可以使用不同的批处理大小进行训练，以测试最大 GPU 内存容量并评估对 GPU 利用率的影响。
您可以在不执行训练的情况下对训练数据集进行循环，如这里的所述来测量输入管道的最大吞吐量。
您可以使用生成的数据进行训练，以评估最大 GPU 吞吐量。
您可以添加和删除预处理管道的不同部分，以评估它们对吞吐量的影响。
您可以使用不同的、简单的和复杂的损失函数进行训练，以评估损失函数对吞吐量的影响。
有没有复试都可以训练。
如果您想要评估特定函数的影响，请用简单的虚拟函数替换它们来评估影响。
另一种有用的编程技术是简单地添加打印(例如使用 tf.print())和计时器(例如 tf.timestamp())来评估不同代码块的性能。
信息干扰权衡
信息干扰权衡指的是一个简单的观察，即我们为了提取有意义的性能数据而改变原始管道越多，数据实际上就越没有意义。我们越是增加轮询系统利用率指标的频率，实际的分析活动就越是盖过训练循环的活动，基本上认为捕获的数据是无用的。
找到正确的平衡并不总是那么容易。完整的性能分析策略应该包括不同入侵级别的分析，以便尽可能清楚地了解正在发生的情况。
案例研究
在这一节中，我们将展示一些我们在实践中讨论过的潜在性能问题。请注意，我们将展示的许多例子都是由真实事件激发的；我们在 AWS 培训中遇到的实际问题。对于每个示例，我们将演示如何通过选择和分析一些分析度量来识别性能问题。
我们将使用的模型是深度卷积网络，它学习对输入图像执行像素级分割。我们的基本模型将 CPU 和 GPU 处理并行化，以 64 的批处理大小运行。在这种情况下，训练吞吐量大约是每秒 100 个样本。SageMaker 仪表板报告 GPU 内存利用率为 98%，GPU 利用率在 95%到 100%之间。
从 tf profiler 的 trace_viewer 中也可以看到 GPU 的利用率，我们可以看到 GPU 几乎总是处于活动状态。回想一下，tf 配置文件被配置为运行五个步骤，即步骤 20–24。
tf profiler — trace-viewer(作者使用 TensorBoard)
为了便于比较，我们还将注意到实例度量报告每分钟 14.9 的网络输入和每分钟不到 100 的网络输出。
小批量
为了评估批处理大小对性能的影响，我们将批处理大小减少到 2，保持所有其他模型属性不变。吞吐量一直下降到每秒 40 个样本。对 GPU 利用率和 GPU 内存利用率的影响从“实例指标”中可以立即看到，我们看到了显著的下降，分别下降到 60%和 23%左右。自然，每次迭代花费的时间要少得多，但是 GPU 处于活动状态的时间百分比要低得多。
tf profiler 步骤时间图显示，小批量导致一半以上的时间花费在将内核加载到 GPU 上。
小批量— tf profiler 步进时间图(作者使用 TensorBoard)
trace_viewer 显示，虽然 GPU 保持不受输入的阻碍，但 tf ops 似乎稀疏地分散在每个步骤的计算块中。
小批量— tf profiler 跟踪查看器(作者使用 TensorBoard)
在 TensorFlow 2.3 中，引入了一个新的内存分析器工具，允许您识别 GPU 内存的未充分利用，并获得您是否可以安全地增加训练批量的指示。
网络输入瓶颈
在本例中，我们将人为地在网络输入端引入一个网络瓶颈。为此，我们将删除 10 个输入记录中的 9 个，这样我们需要 10 倍的网络输入数据来维持相同的吞吐量。下面是用于执行此练习的代码:
*# id generator* **def** id_gen():
e = 0
**while** **True**:
**yield** e
e += 1*# enter id to feature dict* **def** add_id_label(f, i):
f['id'] = i
**return** f*# create a dataset of indices and zip it with input dataset* ids = tf.data.Dataset.from_generator(id_gen, tf.int64)
ds = tf.data.Dataset.zip((ds, ids))*# enter id to feature dict* ds = ds.map(add_id_label, num_parallel_calls=tf.data.experimental.autotune)*# filter out every 9 out of 10 records* ds = ds.filter(**lambda** f:
tf.squeeze(tf.equal(tf.math.floormod(f['id'],10),0)))
从实例指标中，我们可以看到网络输入的上限为每分钟 33.4，仅比正常运行(14.9)的两倍多一点，尽管我们需要十倍于此的数据量。吞吐量下降到每秒 22 个样本。不出所料，我们的程序高度依赖输入。tf profiler 报告说，在总的步进时间中，77.8%的时间用于等待数据。
网络瓶颈— tf 分析器步进时间图(作者使用 TensorBoard)
trace_viewer 清楚地显示了 GPU 在等待来自 tf_data_iterator_get_next 操作的数据时，每个步骤的大部分时间都处于空闲状态。
网络瓶颈— tf profiler 跟踪查看器(作者使用 TensorBoard)
过载的预处理管道
TensorFlow 提供了最大化数据处理并行化的方法(如 TensorBoard Profiler 教程所示)，但这并不能免除您优化输入数据处理管道的责任。如果您的数据处理是资源密集型的，它可能会影响模型的性能，您可能需要考虑将一些处理转移到离线状态。如果繁重的操作是 GPU 友好的(例如大型卷积)，您也可以考虑使用实验性的 map_on_gpu 函数在 GPU 上执行操作，(但要记住数据传输的开销)。另一种选择是选择具有更多 CPU 内核的训练实例。
在本例中，我们将通过对输入帧应用滤波器大小为 7x7 的 separable_conv2d 来模拟过载预处理流水线。
吞吐量下降到每秒 25 个样本，最大 GPU 利用率下降到 36%。另一方面，CPU 利用率从 66%跃升至 96%。同样，程序是高度输入绑定的，跟踪查看器显示大量的 GPU 空闲时间。
Preproc 瓶颈— tf profiler 跟踪查看器(作者使用 TensorBoard)
仔细分析 trace-viewer 的 CPU 部分(此处未显示)，可以看出可分离卷积占用了大量计算资源。
CPU GPU 数据接口的瓶颈
在本例中，我们通过将输入帧的大小放大 10 倍，人为地增加了传递给 GPU 的输入数据。在 CPU 端，我们简单地复制输入帧 10 次(使用 tf.tile())。在 GPU 上，我们接收放大的输入帧，但立即丢弃添加的数据。
在这种情况下，吞吐量下降到每秒 84 个样本，瓶颈在跟踪查看器上非常明显。
H2D 瓶颈— tf profiler 跟踪查看器(作者使用 TensorBoard)
注意对于每一步， Stream #20(MemcpyH2D) 的块的大小是如何增长的，以及 GPU 计算是如何保持空闲直到块完成。
GPU 效率低下
在本例中，我们通过在计算损失函数之前对模型的输出应用 11x11 卷积滤波器来模拟低效图表的影响。不出所料，吞吐量略有下降，降至每秒 96 个样本。对图形的影响可以在 tf profiler tensorflow stats 页面上查看，我们看到添加的操作成为 GPU 中最耗时的操作。该表为我们提供了关于最繁重操作的信息，我们可以使用这些信息来提高模型性能。
低效图表-张量流统计(作者使用张量板)
重帖处理
在本例中，我们添加了一个回调函数，通过在每次迭代后创建和存储 64 个随机图像来模拟处理模型输出的分段掩码。我们注意到的第一件事是 TensorFlow 打印了以下警告:
WARNING:tensorflow:Method (on_train_batch_end) is slow compared to the batch update (0.814319). Check your callbacks.
此外，吞吐量下降到每秒 43 个样本，GPU 利用率下降到 46%，tf profiler 报告每个时间步长中只有 47%的 GPU 处于活动状态。在跟踪查看器上可以清楚地看到瓶颈，我们看到 GPU 在每一步的后半部分处于空闲状态。
Postproc 瓶颈— tf profiler 跟踪查看器(作者使用 TensorBoard)
总结
正如我们所展示的，分析和优化您的培训课程表现的能力可以节省大量时间和成本。您的 DNN 开发团队应该具备执行此类分析所需的技能。这种分析应该成为你的团队发展方法的一个组成部分，并融入到你的 DNN 培训生命周期中。您的开发计划应该包括一些细节，比如何时运行性能分析、使用什么工具、运行什么类型的测试、测试的侵入性如何等等。
在这篇文章中，我们几乎没有触及性能分析的表面。毫无疑问，有更多的工具和技术、其他种类的瓶颈和其他方法来从您的培训资源中挤出更多的性能。我们的目标仅仅是向你介绍这个世界，并强调它在你日常训练中的重要性。祝你好运！！
TensorFlow 性能:加载模型
有许多方法可以保存训练好的模型。但是哪种格式加载最快呢？
Kolleen Gladden 在 Unsplash 上拍摄的照片
模型的加载时间有时是一个被忽视的质量。然而，我们不能总是依赖我们的模型在缓存中舒适地等待，我们仍然需要快速预测。在这种情况下选择什么格式？最近我遇到了这个问题，我很惊讶两者之间的差异有多大。我希望以下对我的发现的简要总结会对你有所帮助。
测量环境和模型
我不打算对这个话题做全面的研究。相反，我将向你展示我在装有 Arch Linux 和最新的 TensorFlow 2.2 和 Python 3.8 的笔记本电脑上测得的加载时间。(我也试过 TensorFlow 2.3rc0，结果差不多。)我将为您提供完整的脚本，以便您可以在自己选择的环境中重现这些实验。如果你能在这种情况下与我分享结果，我会很高兴。
我对深度卷积神经网络 (CNN)很感兴趣。我挑选了三个参数数量不同的知名模型——MobileNet V2、 DenseNet201 和 Resnet152 V2 。所有这些都是 tf.keras.applications 模块的一部分，很容易用于迁移学习。
可用选项
TensorFlow 2 支持两种基本格式— SavedModel 和 HDF5 。您可以保存整个模型，也可以只保存模型的重量。在后一种情况下，您必须重新创建模型架构，然后加载保存的权重。(为了详尽起见，您可以只保存架构，但是我们目前对这个选项不感兴趣。我们希望能够做出预测。)在官方文档中有很多信息，详情请参考那里。我觉得在这里重新表述是多余的。
小注意，我将save()方法的include_optimizer参数设置为False.，这对加载时间没有太大影响，但是我们的用例中不需要优化器，所以让我们忽略它。
TensorFlow Lite
除此之外， TensorFlow Lite 不得不提。它有自己的格式。由于精简版是为移动、嵌入式和物联网设备设计的，该模型应该更快。用于预测和加载。尤其是当你用强大的服务器代替我们的智能手机的时候。不幸的是，一切都是有代价的。如这里所解释的:
由于 TensorFlow Lite 操作集小于 TensorFlow 的操作集，因此并非每个模型都是可转换的。即使对于受支持的操作，出于性能原因，有时也需要非常具体的使用模式。我们希望在未来的 TensorFlow Lite 版本中扩展支持的操作集。
结果
要了解模型在参数数量和占用空间方面有多大，请查看下表。
所选模型的大小(参数，MiB)。(*不同的解释者，不等于其余者。)
现在，让我们看看装货时间。我还包括了参数的数量，所以您不需要参考上面的表。在“仅重量一栏中，测量的时间用于重新创建模型和加载保存的重量。
所选模型的加载时间。(*不同的解释者，不等于其余者。)
或者你喜欢图表的话，可以在下面图形化的看到。我省略了 TensorFlow lite，因为数量级是如此不同。
需要解释吗？新的 SavedModel 格式为我们提供了比旧的 HDF5 模型更好的改进。(我一直不喜欢custom_objects这个参数。)不幸的是装载时间非常糟糕。另一方面，TensorFlow lite 在这方面似乎做了很多工作。
我们能优化模型吗？
不直接针对模型尺寸。在官方文档中有不少关于优化的资源。本页面主要关注 TensorFlow Lite，包括模型选择、训练和训练后优化。除此之外，您还可以直接查看适用于标准模型的 TensorFlow 模型优化 Python API 。
您可以使用两种简单的方法:
- 量化:将权重转换为预测减少的类型，
- 修剪:去除无关紧要的权重。
你可以想象，这些方法影响了机器学习循环的许多部分。这包括模型大小，因此也包括加载时间，但主要关注的是预测时间，其副作用是精度可能会降低。
因此，这些技术高度依赖于您问题领域。因此，我不认为我能得出足够一般的结论，对本文有用。你需要尝试。请随意下载我的脚本来测量模型加载时间，并添加您自己的优化模型进行比较。
最后的想法
要记住的关键点很简单，就像博文本身一样。装载时间是一个问题。在你为你的问题选择合适的模型之前，你应该考虑如何使用它。你需要快速启动吗？也许你应该选择 TensorFlow Lite。并选择仅包含受支持操作的模型。有很多，但是如果你忽略了这一部分，最后的惊喜可能不会令人愉快。
希望这篇文章对你有用。请随时评论，批评，提问！谢谢你的关注。
张量流量子:美女与野兽
所以，我们终于来了，在漫长的等待之后，我们将进入一个量子计算的时代。TFQ，张量流之美和量子计算的兽性。
量子计算正在成为 2020 年更近距离观察的技术。我们已经看到了霍尼韦尔、谷歌和其他公司最近的一些公告，值得期待今年会有新的硬件出现。现在，谷歌提出了一个新的机器学习框架，用于以研究为目的的量子计算实验。
来源:https://www.tensorflow.org/quantum/overview
定义量子计算机
1930 年，艾伦·特纳发明了车床。它由无限长的胶带组成，也就是无限长的胶带，再被分成小方块。每个方块可以包含一个符号(1 或 0)，也可以是空白。之后，有一个读/写设备读取这些符号，并相应地向机器发出所有指令。这就是我们的传统计算机过去的工作方式。
在量子翻转机中，有一个微小的差异会造成性能上的巨大差距，即磁带。在量子机器中，磁带以量子状态存在。这意味着磁带上的符号可以是 0 或 1。换句话说**，**这两个符号同时是 0 和 1。虽然普通的图灵机一次只能执行一次计算，但量子图灵机可以一次执行多次计算。
量子计算机不限于两种状态；它们将信息编码为量子位，或量子位，可以叠加存在。
所以这里最重要的是量子位。
量子位代表原子、电子以及它们各自的控制装置，它们一起工作，充当计算机存储器和处理器。因为量子计算机可以同时包含这些多种状态。它有可能比当今最强大的超级计算机强大数百万倍。
量子计算的最新发展
日前， Google AI ，宣布发布 TensorFlow Quantum ，这是一个用于量子机器学习模型快速成型的开源库。他们并不孤单，因为他们得到了滑铁卢大学和大众汽车的帮助。
TensorFlow Quantum 的核心思想是在 TensorFlow 编程模型中交错量子算法和机器学习程序。谷歌将这种方法称为量子机器学习(QML)，并能够通过利用其最近的一些量子计算框架来实现它，如谷歌 Cirq 。
所以这里的主要问题是:
cirq 是什么？
Cirq 是一个为设备调用量子电路的开源框架。cirq 背后的主要思想是提供一个简单的编程模型，抽象出量子计算的基本构件。cirq 的基本结构包含量子位、门、测量算子，当然还有电路，这些都是量子计算所必需的东西。
根据 Google AI:“Cirq 使研究人员能够为特定的量子处理器编写量子算法。Cirq 为用户提供了对量子电路的微调控制，使用本机门指定门的行为，将这些门适当地放置在设备上，并在量子硬件的限制内安排这些门的时序”
因此，cirq 中包含以下关键构建模块:
- **电路:**量子电路的基本形式由这些电路来表示。一个 Cirq 电路被表示为一个矩的集合，其中包括在一些抽象的时间滑动期间可以在量子位上执行的操作。
- Gates: Gates 对量子位集合的抽象操作。
- **时间表和设备:**简单来说，时间表由一组操作和时间表运行设备的描述组成。在量子计算方面，包括了更多关于门的时间和持续时间的详细信息。
张量流量子
TensorFlow Quantum 是一个用于混合量子-经典机器学习的库，开发/构建量子机器学习应用程序。它允许我们构建量子数据集，量子模型。
TFQ 提供了一个模型，抽象了与张量流、Cirq 和计算硬件的交互。栈顶是要处理的数据。经典数据由 TensorFlow 原生处理；TFQ 增加了处理量子数据的能力，包括量子电路和量子算符。堆栈的下一层是 TensorFlow 中的 Keras API。因为 TFQ 的核心原则是与核心 TensorFlow 的本机集成，特别是与 Keras 模型和优化器的集成。在 Keras 模型抽象的下面是我们的量子层和微分器，当与经典张量流层连接时，它支持混合量子-经典自动微分。在这些层和竞争优势之下，TFQ 依赖于 TensorFlow ops，它实例化了数据流图。
来源:https://www.tensorflow.org/quantum/overview
从执行的角度来看，TFQ 遵循以下步骤来训练和建立 QML 模型。
- 准备一个量子数据集:量子数据作为张量加载，指定为 Cirq 中写的量子电路。张量由 TensorFlow 在量子计算机上执行，生成量子数据集。
- **评估量子神经网络模型:**在这一步中，研究人员可以使用 Cirq 构建一个量子神经网络原型，稍后他们会将它嵌入 TensorFlow 计算图中。
- **样本或平均值:**该步骤利用了对涉及步骤(1)和(2)的几次运行求平均值的方法。
- **评估经典神经网络模型:**该步骤使用经典深度神经网络来提取在先前步骤中提取的度量之间的相关性。
- 评估成本函数:类似于传统的机器学习模型，TFQ 使用这个步骤来评估成本函数。如果量子数据被标记，这可以基于模型执行分类任务的准确程度，或者如果任务是无监督的，则基于其他标准。
- 评估梯度&更新参数 —在评估成本函数后，管线中的自由参数应在预期降低成本的方向上更新。
TFQ 代表了该领域最重要的里程碑之一，并且利用了量子和机器学习领域的一些最佳知识产权。关于 TFQ 的更多细节可以在项目网站上找到。
最初发布于https://blog . knol dus . com/tensor flow-quantum-beauty-and-the-beast/
你们认为量子计算的未来会是怎样的？请在评论框中告诉我们…
快乐学习:-)
张量流量子:将机器学习与量子计算结合起来
谷歌开源了其新的量子计算机器学习库，名为 TensorFlow Quantum (TFQ)。
图片来源: Pixabay
介绍
2020 年 3 月 9 日， Google AI ，宣布发布 TensorFlow Quantum (TFQ)，这是一个用于量子机器学习模型快速成型的开源库。他们并不孤单，因为他们得到了滑铁卢大学和大众汽车的帮助。
这个新框架为量子计算(QC)研究人员提供了必要的软件和设计工具，将机器学习的能力和可能性带入量子计算领域。
这是他们在量子计算软件平台中产品的自然发展。2018 年 3 月，谷歌公布了 Cirq ，这是一个用于噪声中等规模量子( NISQ )算法的开源框架。在最基本的层面上，TFQ 将 Cirq 与广受欢迎的深度学习框架 TensorFlow 相集成，并为混合量子经典模型的设计和实现提供了强大的类、数据结构和方法。一方面，它具有与tensor flow API兼容的量子计算抽象，另一方面，它拥有随时可用的高性能量子电路模拟器。
但是它将帮助解决什么样的问题，它关注什么？
我们将很快讨论这个问题。然而，在进一步发展之前，这里有一个惊人的视频，以一种令人难以置信的有趣方式在高层次上介绍了量子计算的核心概念。
TFQ 提供了必要的工具，将量子计算和机器学习研究社区聚集在一起，以控制和模拟自然或人工量子系统。
NISQ:物理科学的新前沿
约翰·普雷斯基尔，加州理工学院理论物理学教授理查德·p·费曼在其颇具影响力的论文“NISQ 时代及以后的量子计算”中指出，“我们现在正处于探索物理科学新前沿的早期阶段，我们可以称之为复杂性前沿或纠缠前沿”。
他继续进一步解释这一点——“现在，人类历史上第一次，我们获得并完善了构建和精确控制许多粒子的非常复杂、高度纠缠的量子状态的工具，这些状态如此复杂，以至于我们无法用最好的数字计算机模拟它们，也无法用现有的理论工具很好地描述它们的特征。这种新兴能力将为新发现打开大门。
近期(不完善的)量子器件
量子计算和/或信息处理系统有着漫长而复杂的历史。今天，在 2020 年，几乎毫无疑问的是，制造必要数量的高质量量子位和量子门的实用方法的商业化还需要几十年的时间。这主要是由于这些系统固有的噪声问题。这种噪声使得量子系统的真正缩放(到更大数量的门)变得极其困难，并且使得量子计算设备变得不稳定和不可靠。
然而，研究人员对近期量子设备的强大用途和可能性越来越感兴趣。这些尺寸适中的设备(50-100 量子位)被称为噪声中等规模量子(NISQ)，主要是为固定应用而设计的，可以忍受伴随它们的噪声缺陷。
从热硅点量子位到离子阱，科学家们正在研究创新的方法来构建更复杂和更强大的…
www.sciencemag.org](https://www.sciencemag.org/features/2019/11/quantum-technology-comes-age)
这类算法和装置提供了模拟和分析从经典计算观点来看难以处理的系统特性的真正可能性。
这听起来很有趣！但是，有哪些这样的系统的例子，它们的工作不可能用经典的计算机/算法来模拟，但是这种 NISQ 技术正好适合呢？
利基但有价值的应用领域
对于量子设备的许多应用，如密码术，噪声造成了严重的限制，并可能导致不可接受的误差水平。NISQ 设备不太可能在短期内用于此类应用。因此，金融和商业安全系统中的人们还不需要担心。就目前而言，像 RSA-128 这样久经考验的算法是安全的。
但是密码学并不是量子计算唯一可能的应用领域。NISQ 设备和算法使得深入探索复杂分子和先进纳米材料的特性成为可能。它们还允许高精度和高保真度模拟极端物理，如粒子-粒子相互作用，或高能原子碰撞。
人们可以想象这些能力可能应用于各种各样的领域…
- 药物发现
- 纳米材料合成
- 基因工程和个性化医疗
- 化学工程和材料科学
- 粒子物理学
- 半导体和电子设备
- 光纤、光子学和高速通信
NISQ 系统的渐进和稳定的进展已经让科学家、研究人员和企业高管对这些应用(以及更多)感到兴奋。然而，需要认识到的是，随着 TFQ 等工具包的发布，所有这些应用现在都可以充分利用深度神经网络的强大机制，并将基础物理与大数据的力量相结合。
这类算法和装置提供了模拟和分析从经典计算观点来看难以处理的系统特性的真正可能性。
TFQ 关注的是什么？
具有近期目标的开源理念
量子计算的前景有着漫长而复杂的历史。然而，越来越多的研究人员呼吁 T2 关注可以在 5 年时间范围内解决的实际问题。TFQ 在一个合适的时机被释放，以利用这一运动和研究势头。
如上所述，TFQ 是围绕 Cirq 构建的，Cirq 是为探索中等规模、高噪声的 QC 架构是否能够解决经典数字计算机器难以解决的实际问题而设计和优化的。尊重开源哲学的传统，Cirq 是在 Apache 2 许可下发布的。未来的开源 QC 框架可以利用并嵌入 Cirq 方法和工具，而没有任何版权限制。
优化量子电路的数据结构
各种电路设计原语、逻辑门的灵活行为和功能描述、对高度优化的时序和布局设计工具的访问，是任何数字设计框架的一些期望特征。
量子逻辑设计在这些方面没有什么不同。像 Cirq 这样的工具正好为研究人员提供了这些。在 Cirq 中，谷歌声称，数据结构已经被优化用于编写和编译大量的量子电路描述，以允许用户从现代 NISQ 架构中获得最大收益。作为一个开源项目，它在不断地发展和添加新的抽象和工具。本地支持本地模拟和与未来量子硬件或云上更大模拟器的轻松集成。
特别关注化学
在谷歌宣布 Cirq 的同时(2018 年)，他们还宣布了 OpenFermion 和 OpenFermion-Cirq 的上市。
Github Repo for OpenFermion-Cirq。
根据这篇谷歌人工智能博客，“OpenFermion 是一个为化学问题开发量子算法的平台，OpenFermion-Cirq 是一个开源库，将量子模拟算法编译到 Cirq ”。
谷歌的量子人工智能团队已经用新的量子算法进行了一段时间的实验，特别是，他们已经探索了开发低复杂度算法的可能性，用于量子化学领域的快速原型制作。OpenFermion 建立在这些进步的基础上，帮助用户将化学问题的细节(例如分子动力学或反应能量学)转化为优化的量子电路。这些电路也可以调整和定制，以运行在特定的硬件(如电子，光子或分子)。
图片来源: Pixabay
数据结构已经针对编写和编译大量量子电路描述进行了优化，以允许用户充分利用现代 NISQ 架构。
量子数据的解开
NISQ 处理器生成的量子力学数据本身就有噪声，并且通常纠缠(在测量之前)。然而，量子 ML 技术的最大效用之一是它们能够应用于这种嘈杂和纠缠的数据，以促进经典信息的提取，这可以用任何数字计算架构来处理。
基于这些技术，TFQ 图书馆促进了强大模型和工作流的开发，这些模型和工作流解开并概括了量子数据中的相关性。一方面，这鼓励研究人员提高新量子架构的质量和复杂性，另一方面，它加快了新量子算法的发展。
图片来源: Pixabay 。
混合量子经典工作流
由于其相当有限的尺寸(即门数)和噪声行为，NISQ 处理器仍然需要与经典处理器在一个紧密的循环中工作，以产生有意义的计算输出。对于 ML 工作负载，这意味着采用与经典深度学习模型紧密耦合的 NISQ 处理器的循环。混合方法至关重要。
现在，在经典 ML 的世界里，TensorFlow 是最受尊敬和广泛使用的平台之一。它支持跨越各种计算硬件的异构和千万亿次计算——CPU、GPU、TPU，甚至 FPGAs 或定制 ASICs。因此，毫不奇怪，Google 选择这个框架来与 Cirq 平台集成，从而将 QC 工具的范围扩展到最广泛的硬件架构。
这是一个奇妙的世界，编译器、调度器和优化器与量子位、量子门、电路和测量算子无缝融合。可以使用标准 Keras 函数来完成受监督的 ML 训练，并且通过标准 TensorFlow Ops 来获得演化成经典概率分布的量子测量的最终结果。
从谷歌的白皮书来看，这是工作流程的样子，
图片来源:https://ai . Google blog . com/2020/03/announcing-tensor flow-quantum-open . html
有关更多详细信息，请参考这篇综合论文，
[## TensorFlow Quantum:量子机器学习的软件框架
我们介绍 TensorFlow Quantum (TFQ)，这是一个开源库，用于混合量子-经典…
arxiv.org](https://arxiv.org/abs/2003.02989)
可以使用标准 Keras 函数来完成受监督的 ML 训练，并且通过标准 TensorFlow Ops 来获得演化成经典概率分布的量子测量的最终结果。
摘要
这是一个激动人心的时刻。
一方面，由于机器学习和人工智能工具和算法辅助下的数据驱动智能的大规模爆炸，科学、技术、商业和社会正处于变革的风口浪尖。
另一方面，物理科学的传统前沿(粒子物理学和宇宙学——对超小和超大的研究)正在让位于对量子设备和信息系统形式的超复杂的研究。
我们只能希望，这两股如此强大而深远的技术潮流的融合，对人类社会和整个地球生命的进步是一个好兆头。
像 TFQ 这样的开源计算平台的发布只是这个旅程中的一小步，但肯定不会是最后一步。
如果您有任何问题或想法要分享，请联系作者在tirthajyoti【AT】Gmail . com。此外，您可以查看作者的 GitHub 资源库中的代码、想法和机器学习和数据科学方面的资源。如果你和我一样，对人工智能/机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
[## Tirthajyoti Sarkar - Sr .首席工程师-半导体、人工智能、机器学习- ON…
通过写作使数据科学/ML 概念易于理解:https://medium.com/@tirthajyoti 开源和有趣…
www.linkedin.com](https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/)
张量流:20 分钟内发现讽刺
从头开始在 TensorFlow 中构建您的第一个 NLP 模型
Joshua Hoehne 在 Unsplash 上拍摄的照片
这是 TensorFlow 中的一个快速自然语言处理(NLP)教程。NLP 是人工智能的一个子领域，涉及通过计算机理解、解释和操纵人类语言。TensorFlow 是 Google 的开源机器学习库。本教程假设对 Python 有中级了解，对机器学习有基本了解，要求 Python 3 配 TensorFlow 2.x，本教程结束后，你将能够训练自己的挖苦检测模型。
我们想建立一个神经网络分类器来检测文本中的讽刺。为此，我们将使用‘rish abh Misra 的新闻标题数据集中的讽刺’。以下代码解析数据集-
# Importing required libraries
import json
import tensorflow as tf
import requests
import numpy as np
import pandas as pd
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences# Get the dataset
srcsm_json = requests.get('[https://storage.googleapis.com/laurencemoroney-blog.appspot.com/sarcasm.json'](https://storage.googleapis.com/laurencemoroney-blog.appspot.com/sarcasm.json'))# Inspecting the data, print 450 characters
print(srcsm_json.text[0:450])>>> [
>>> {"article_link": "https://www.huffingtonpost.com/entry/versace- >>> black-code_us_5861fbefe4b0de3a08f600d5", "headline": "former
>>> versace store clerk sues over secret 'black code' for minority >>> shoppers", "is_sarcastic": 0},
>>> {"article_link": "https://www.huffingtonpost.com/entry/roseanne- >>> revival-review_us_5ab3a497e4b054d118e04365", "headline": "the >>>'roseanne' revival catches up to our thorny political mood, for >>> better and worse", "is_sarcastic": 0},# Separate the json into sentences and labels
sentences = []
labels = []for item in srcsm_json.json():
sentences.append(item['headline'])
labels.append(item['is_sarcastic'])print(pd.DataFrame({'sentence' : sentences[0:10], 'label':labels[0:10]}))>>> sentence label
>>> 0 former versace store clerk sues over secret 'b... 0
>>> 1 the 'roseanne' revival catches up to our thorn... 0
>>> 2 mom starting to fear son's web series closest ... 1
>>> 3 boehner just wants wife to listen, not come up... 1
>>> 4 j.k. rowling wishes snape happy birthday in th... 0
>>> 5 advancing the world's women 0
>>> 6 the fascinating case for eating lab-grown meat 0
>>> 7 this ceo will send your kids to school, if you... 0
>>> 8 top snake handler leaves sinking huckabee camp... 1
>>> 9 friday's morning email: inside trump's presser... 0
我们有了句子的初始数据集和相应的标签 1 或 0，表明该句子是否是讽刺性的。讽刺分类器将使用句子作为输入，并预测标签。在我们开始训练分类器之前，我们需要以计算机可以处理的方式来表示输入数据，即句子。
这是通过标记化和排序的结合来实现的。标记化是一项将字符串分割成多个部分(称为标记)的任务，同时丢弃某些字符，如标点符号。标记化为每个唯一的单词分配一个数字。排序建立在标记化的基础上，将句子表示为一系列数字。
在实践中，我们的分类器可能会遇到它在训练数据中没有见过的单词，在这种情况下，分类器将完全忽略这些单词，从而导致一些信息丢失。为了最大限度地减少信息损失，在标记化过程中，我们分配一个标记来表示所有看不见的(词汇之外的)单词。对于处理可变长度句子的神经网络，我们使用填充。在填充中，我们设置了句子的最大允许长度，所有短于最大长度的句子将被填充以匹配最大长度。相反，所有超过最大长度的句子将被截断以匹配最大长度。以下代码执行标记化和排序-
# Splitting the dataset into Train and Test
training_size = round(len(sentences) * .75)training_sentences = sentences[0:training_size]
testing_sentences = sentences[training_size:]
training_labels = labels[0:training_size]
testing_labels = labels[training_size:]# Setting tokenizer properties
vocab_size = 10000
oov_tok = "<oov>"# Fit the tokenizer on Training data
tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)
tokenizer.fit_on_texts(training_sentences)word_index = tokenizer.word_index# Setting the padding properties
max_length = 100
trunc_type='post'
padding_type='post'# Creating padded sequences from train and test data
training_sequences = tokenizer.texts_to_sequences(training_sentences)
training_padded = pad_sequences(training_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)testing_sequences = tokenizer.texts_to_sequences(testing_sentences)
testing_padded = pad_sequences(testing_sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)
在这个阶段，我们准备根据我们的数据训练一个神经网络，我们有代表句子的数字序列。为了确定序列中的某些内容是否具有讽刺意味，我们使用了嵌入的概念。假设我们用向量来表示单词，比如单词‘good’用(1，0)来表示，与 good 相反的单词‘bad’用(-1，0)来表示。表示积极意义的词将接近(1，0)，而表示消极意义的词将接近(-1，0)。如果我们将这个框架扩展到多个维度，一个句子可以由句子中单词的向量之和来表示。当神经网络分类器学习检测讽刺时，它在这些多维度中学习方向。讽刺的句子会有很强的讽刺方向的成分，其他的句子会有很强的不讽刺方向的成分。随着我们用更多数据训练神经网络分类器，这些方向可能会改变。当我们有一个经过充分训练的神经网络分类器时，它可以对句子中所有单词的向量求和，并预测句子是否是讽刺性的。
最终的神经网络由学习每个单词方向的顶层嵌入组成，下一层是将向量相加的全局平均池，下一层是深度神经网络，最后一层是返回句子讽刺的概率的 sigmoid 层。以下代码训练神经网络-
# Setting the model parameters
embedding_dim = 16model = tf.keras.Sequential([
tf.keras.layers.Embedding(vocab_size, embedding_dim, input_length=max_length),
tf.keras.layers.GlobalAveragePooling1D(),
tf.keras.layers.Dense(24, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])model.summary()>>> Model: "sequential_4"
>>> ________________________________________________________________
>>> Layer (type) Output Shape Param #
>>> ================================================================
>>> embedding_4 (Embedding) (None, 100, 16) 160000
>>> ________________________________________________________________
>>> global_average_pooling1d_4 ( (None, 16) 0
>>> ________________________________________________________________
>>> dense_8 (Dense) (None, 24) 408
>>> ________________________________________________________________
>>> dense_9 (Dense) (None, 1) 25
>>> ================================================================
>>> Total params: 160,433
>>> Trainable params: 160,433
>>> Non-trainable params: 0
>>> ________________________________________________________________ # Converting the lists to numpy arrays for Tensorflow 2.x
training_padded = np.array(training_padded)
training_labels = np.array(training_labels)
testing_padded = np.array(testing_padded)
testing_labels = np.array(testing_labels)# Training the model
num_epochs = 30history = model.fit(training_padded, training_labels, epochs=num_epochs, validation_data=(testing_padded, testing_labels), verbose=2)>>> Train on 20032 samples, validate on 6677 samples
>>> Epoch 1/30
>>> 20032/20032 - 2s - loss: 0.6742 - accuracy: 0.5669 - val_loss: >>> 0.6247 - val_accuracy: 0.6629
>>> Epoch 2/30
>>> 20032/20032 - 1s - loss: 0.4758 - accuracy: 0.8121 - val_loss: >>> 0.4018 - val_accuracy: 0.8278
>>> Epoch 3/30
>>> 20032/20032 - 1s - loss: 0.3293 - accuracy: 0.8686 - val_loss: >>> 0.3708 - val_accuracy: 0.8327
>>> ...
>>> ...
>>> Epoch 29/30
>>> 20032/20032 - 1s - loss: 0.0310 - accuracy: 0.9920 - val_loss: >>> 0.9636 - val_accuracy: 0.8167
>>> Epoch 30/30
>>> 20032/20032 - 1s - loss: 0.0297 - accuracy: 0.9925 - val_loss: >>> 0.9431 - val_accuracy: 0.8131
神经网络能够在训练数据集上实现 99%的准确度，在测试数据集上实现 81%的准确度。
让我们通过使用该模型预测两个新句子来进行最后的健全性检查。
sentence = ["Coworkers At Bathroom Sink Locked In Tense Standoff Over Who Going To Wash Hands Longer",
"Spiking U.S. coronavirus cases could force rationing decisions similar to those made in Italy, China."]
sequences = tokenizer.texts_to_sequences(sentence)
padded = pad_sequences(sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)
print(model.predict(padded))>>>[[0.99985754]
>>> [0.0037319 ]]
该模型预测,“浴室洗手池的同事在谁洗手时间更长的问题上陷入紧张对峙”的概率非常高(几乎为 1 %),而“美国冠状病毒病例激增可能迫使类似意大利和中国做出的配给决定”的概率非常低(几乎为 0 ),这是讽刺。我们可以得出结论，我们的模型正在按预期工作。
本教程基于 YouTube 上 TensorFlow 的“自然语言处理(NLP 零到英雄)”系列。这个教程的 Jupyter 笔记本可以在这里找到。
如果你觉得我们的工作有帮助，请考虑引用
@article{aadityaubhat2020sarcasm-detection,
title={TensorFlow: Sarcasm Detection in 20 mins},
author={Bhat, Aaditya},
journal={Towards Data Science},
year={2020},
url={[https://towardsdatascience.com/create-geo-image-dataset-in-20-minutes-4c893c60b9e6](/tensorflow-sarcasm-detection-in-20-mins-b549311b9e91)}
}
张量流半监督对象检测体系结构
测试整体模型性能时自动标记图像的简单方法。
托拜厄斯·凯勒在 Unsplash 上的照片
目标检测是当今最流行和最常用的计算机视觉方法之一，其目的不仅在于以与最常见的分类问题相同的方式确定是否在图像中找到目标，还在于指出这些感兴趣的目标的位置，这是在多个目标可能同时出现在图像中的情况下的必要方法。
这种方法的挑战之一是创建数据集，一旦需要手动设置图像中所有对象的位置，在大量的观察中花费大量的时间来这样做。
这一过程效率低、成本高、耗时长，主要表现在一些需要在每幅图像中标注几十个物体或者需要专门知识的问题上。
基于此，我创建了 TensorFlow 半监督对象检测架构(TSODA)来交互式地训练对象检测模型，并使用它来基于置信度阈值水平自动标记新图像，将它们聚合到后期的训练过程中。
在本文中，我将向您展示在您的对象检测项目中重现这种方法的必要步骤。有了它，您将能够在测量模型性能的同时自动在图像中创建标签！
目录:
- 措达如何工作
- 示例应用
- 实施
- 结果
- 结论
TSODA 的工作原理
工作类似于任何其他半监督方法，其中使用标记和未标记的数据进行训练，不像最常见的监督方法。
使用手动完成的强标记数据训练初始模型，从这些数据中学习一些特征，然后在未标记数据中创建推断，以将这些新标记的图像聚集到新的训练过程中。
整个想法可以用下图来说明:
(字体:作者)
这个操作一直进行到达到停止标准，或者是执行的次数，或者是没有剩余的未标记数据。
正如我们在模式中看到的，最初配置了 80%的置信度阈值。一旦新图像将被用于新的训练过程，这是一个重要的参数，并且如果不正确地标记，可能产生不期望的噪声，破坏模型性能。
TSODA 的目的是介绍一种简单快速的方法，在你的目标检测项目中使用半监督学习。
示例应用程序
为了举例说明这种方法并测试是否一切正常，我们对 Asirra 数据集的 1，100 幅图像进行了随机抽样，每类样本占 50%。
这些图像被手动标记，以便稍后进行比较，你可以在 Kaggle 上下载相同的数据。
我使用单次多盒探测器(SSD)作为对象检测架构，Inception 作为基础网络，而不是像在原始论文中的 VGG 16。
SSD 和 Inception 在训练速度和准确性之间有很好的权衡，所以我认为这是一个很好的起点，主要是因为在每次迭代中，TSODA 需要保存训练模型的检查点，推断新的图像并加载模型以再次训练它，所以更快的训练有利于更多地迭代并将这些图像聚合到学习中。
测试性能
为了测试 TSODA 的性能，只提供了每个类别的 100 个标记图像来分成训练和测试，同时让 900 个图像作为未标记的，模拟只花很少时间来创建标记数据集的情况。将获得的结果与用所有手动标记的图像训练的模型进行比较。
数据被随机分成 80%的图像用于训练，20%用于测试。
履行
顾名思义，整个架构是使用 TensorFlow 环境完成的，在 2.x 版本中。
这个新的 TF 版本还不完全兼容对象检测，有些部分很难适应，但在接下来的几个月里，这将是所有项目中默认的和更多使用的 TF 版本，这就是为什么我认为调整代码以使用它是重要的。
为了创建 TSODA，新的脚本和文件夹被添加到 TF Model Garden repository 的一个分支中，这样你就可以很容易地克隆和运行你的半监督项目，除了为那些使用 TF 的人提供一个熟悉的结构之外。
你可以克隆我的库来轻松地遵循这些步骤或者修改你的 TF 模型库。
这项工作是在*models/research/object _ detection、*中完成的，在这里您会找到以下文件夹和文件:
- **inference _ from _ model . py😗*该文件将被执行以使用模型来推断新的图像。
- generate _ XML . py和generate _ TF record . py:都将用于创建训练和测试 TF 记录，用于对象检测模型的训练(这些脚本改编自 浣熊数据集 )。**
- test_images 和 train_images 文件夹:有将要使用的 JPG 图像和 XML 文件。
- 未标记 _ 图像 和 标记 _ 图像 文件夹:分别包含所有未标记的图像和算法自动标记的图像，这些图像将被分为训练和测试文件夹以保持比例。
在 utils 文件夹中，我们还有一些东西:
- generate _ xml . py:该脚本负责获取模型推理并生成一个新的 XML，该 XML 将存储在label _ images文件夹中。
- ****visualization _ utils . py:这个文件在代码上也有一些修改，用来捕捉模型推断，并传递给“generateXml”类。
就是这样，这就是你需要在你的存储库中拥有的一切！
准备环境
运行这个项目你不需要任何东西！？****
训练过程是在一个谷歌 Colab 笔记本电脑，所以它的快速和简单的训练你的模型，你真的只需要用你的图像替换我的图像，并选择另一个基本模型，如果你和。
将原始 Colab 笔记本复制到您的 Google Drive 并执行它。
如果你真的想在你的机器上运行 TSODA，在 Jupiter notebook 的开始你会看到安装要求，只要按照它做，但不要忘记也安装 TF 2.x，我建议创建一个虚拟环境。
理解代码
推理 _ 自 _ 模型. py 负责加载在训练中创建的保存 _ 模型. pb 并使用它在未标记图像中进行新的推理。大部分代码是从 colab_tutorials 文件夹中的object _ detection _ tutorial . ipynb获得的。
如果您不想使用 Colab 进行训练，您需要替换文件开头的路径。
该文件中的另一个重要方法是 partition_data ，它负责将推断的图像(将在标签 _ 图像文件夹中)分割成训练和测试，以保持相同的比率。
您可能想做的一个更改是分流比，在我的例子中，我选择了 80/20 的比例，但如果您想要不同的东西，您可以在方法参数中设置它。
visualization_utils.py 是边界框被绘制到图像中的地方，因此我们使用它来获取框的位置、类名、文件名，并将其传递到我们的 XML 生成器中。下面的代码展示了这个过程的大部分:
如果在图像中检测到一个比指定可信度更高的框，则生成 XML。
所有信息到达 generate_xml.py 中，xml 是使用 ElementTree 创建的。
在代码中，有一些注释可以帮助你理解一切是如何工作的。
结果
为了评估模型性能，使用了平均精度(mAP)，如果您对其工作原理有疑问，请查看。
第一个测试是通过 4000 个时期训练一个模型，使用所有强烈标记的图像。
训练持续大约 21 分钟，结果如表 1 所示。
表 2:使用正确标记的所有图像进行训练和测试的地图。(字体:作者)
正如预期的那样，该模型获得了高地图，主要是在较低的 UoI 率。
第二个测试是使用相同的配置完成的，但是 TSODA 只考虑了 100 个带标签的图像。在每次迭代中，该模型由 1000 个时期训练，然后用于推断和创建新的标记图像。结果如图 2 所示。
TSODA 中的模型收敛(font: Author)
整个训练过程用了三十八分钟，比上一次多了十七分钟左右，模型达到了更差的最终图，如表 2 所示:
第一次测试的最终地图。(字体:作者)
如表 3 所示，大多数图像在第一次迭代中被成功注释，在训练中被聚集。这可能意味着最小置信度阈值不够高，因为在前一千次迭代中，模型还没有正确收敛，可能会创建错误的注释。
迭代后剩余的未标记图像的数量(font: Author)。
TSODA 需要更多的时间和历元来提高模型性能并接近原始方法。发生这种情况的原因是，一旦模型需要学习如何概括新模式，在训练集中添加新图像会导致 mAP 丢失，如图 2 所示，其中 mAP 随着新图像的加入而减少，然后在模型学习新特征时再次开始增加。
在图 3 中，有一些图像自动注释的例子。值得注意的是，有些标签没有被很好地标记出来，但是这足以保证给模型提供更多的信息。
自动注释图像的示例。正如所见，如果由人来做，标签可能更适合对象。
考虑到不同的历元增量行为以及更高的置信度阈值，执行了一些新的实验。结果如表 4 所示:
使用第二种配置的结果！(字体:作者)
将置信度阈值设置为 90%可确保在预测中获得正确标签的几率更高，这是模型收敛的一个重要因素。虽然在初始迭代中对 2，500 个时期进行训练，而不是在第一次迭代中只对 1，000 个时期进行训练，因为第一次迭代是大多数图像被标记的地方，所以模型需要学习更多的特征，并且能够击败更高的置信度。在第一次迭代之后，随后的迭代增加 1，500 个历元，直到限制为 8，500 个。这些新配置改善了最终结果。
根据感兴趣对象的种类及其复杂性，TSODA 的性能可能会有所不同。如果通过更多的时期进行训练或者设置更高的置信度阈值，结果可以得到改善，缺点是增加了训练时间。此外，通过迭代的历元增量必须根据问题而改变，以基于未标记图像的数量和阈值来控制模型收敛。
然而，这是一个很好的选择，一旦训练时间比需要人的手动标记时间更便宜，TSODA 的构建方式是，只需少量修改，就可以从头开始训练一个全新的大规模模型。
自动创建的标签也可以在一些图像中手动调整，这可以提高整体性能，并且比手动创建所有标签更快。
结论
所提出的 TSODA 可以在为未标记图像创建新标记方面取得令人满意的结果，达到与强标记训练方法类似的结果，但需要相当少的人力。该解决方案还适用于任何其他 CNN 检测器架构，实施简单快速，有助于数据集创建过程，同时测量物体检测器的整体性能。
参考
关于这个半监督项目的更多细节和背景，请看我的预印本。
Tensorflow 与 Docker 一起使用
张量流框架
如何将 ML 模型部署到生产中？
约瑟夫·巴里恩托斯在 Unsplash 上拍摄的照片
本文将指导您如何构建和训练一个简单的 CNN 模型，然后使用这个训练好的模型作为 Tensorflow 服务的端点。无论您是业余爱好者、ML 工程师、数据科学家还是 DevOps 人员，我相信在本文结束时您将能够部署 ML 模型。
Tensorflow 服务的背景
Tensorflow Serving 是谷歌为生产机器学习系统设计的 API，谷歌和许多大型科技公司广泛使用这种 API。它使得用相同的服务器架构和 API 部署您的模型变得容易。它最适用于张量流模型，但我猜它也可以扩展到其他类型的模型。
图片取自 Packt
上图简要展示了从构建模型到使用 Tensorflow 服务将模型提供给端点的整个过程。为大多数类型的模型提供服务的最佳选择可能是在服务器上运行集中式模型，任何类型的设备(可能是桌面设备、移动设备或嵌入式设备)都可以从该服务器进行请求。然后服务器会为你做推理并返回预测。根据该预测，您可以将其呈现给任何设备。这种架构的一个很大的优点是，假设您有几个客户端访问集中在一个服务器上的端点。每个人都可以访问相同的模型版本，并可以无缝地享受更新的版本，而且通过添加负载平衡器，针对大量请求的扩展变得很容易。如果您将模型部署在每台客户机上，这将变得很困难，因此管理版本和发布新的更新变得很有挑战性。
现在让我们进入工作模式。
我们将训练一个神经网络模型来对服装上的图像进行分类(即 mnist 时尚数据集)，保存训练好的基于 TensorFlow 的模型，并用 Tensorflow 服务它。虽然，更多的焦点将集中在服务模型部分。
您将在下面的 Git 资源库中找到所有代码。Star this repository关注我在 Medium， 我将在未来几周发布更多关于 Tensorflow 算法、ML 模型管道的更新，以及与 AWS 和 Azure 等云服务集成的示例。
如果你在 Google Collab 中运行这些代码，那就很容易了。
此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…
github.com](https://github.com/vjgpt/Tensorflow-Series/tree/master/tensorflow-serving)
import sys
# Confirm that we're using Python 3
assert sys.version_info.major is 3, 'Oops, not running Python 3.'import tensorflow as tf
from tensorflow import keras
import numpy as np
import os
import subprocess
在将数据输入模型之前对数据进行预处理。
# Model Version
VERSION = '00000123' fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()# scale the values to 0.0 to 1.0
train_images = train_images / 255.0
test_images = test_images / 255.0# reshape for feeding into the model
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1)
test_images = test_images.reshape(test_images.shape[0], 28, 28, 1) print('\ntrain_images.shape: {}, of {}'.format(train_images.shape, train_images.dtype))
print('test_images.shape: {}, of {}'.format(test_images.shape, test_images.dtype))
基于时尚 MNIST 数据构建和训练 CNN 模型
model = keras.Sequential([
keras.layers.Conv2D(input_shape=(28,28,1), filters=8, kernel_size=3,
strides=2, activation='relu', name='Conv1'),
keras.layers.Flatten(),
keras.layers.Dense(10, activation=tf.nn.softmax, name='Softmax')
])
model.summary()epochs = 15model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=epochs) test_loss, test_acc = model.evaluate(test_images, test_labels)
print('\nTest accuracy: {}'.format(test_acc))
以 TensorFlow protobuf 格式保存训练好的模型。
saved_model_path = model.save(f"./tmp/{VERSION}", save_format='tf')
使用 SavedModel CLI 检查模型
SavedModel CLI 帮助您检查您的模型并检查模型的SignatureDef's。它为您提供了模型训练所依据的输入张量数据类型和形状的详细信息。因此，您必须以相同的格式向模型提供输入，并获得由SignatureDef's定义的输出。
import subprocesssubprocess.run([f"saved_model_cli show --dir ./tmp/{VERSION}/ --all"],shell=True)# Zipping the model as model.tar.gz
subprocess.run([f"tar cvfz model.tar.gz tmp/{VERSION}/"],shell=True)
我们将在本地机器上提供模型，所以我们需要压缩的模型文件和 JSON 文件，它们将被输入到模型中。
下载压缩的模型文件，这样您就可以在本地机器上部署它(假设您已经在 Google Collab 中运行了全部代码)。
from google.colab import filesfiles.download('model.tar.gz')
创建一个 JSON 文件，该文件将包含模型所需的输入SignatureDef's，然后将被传递到模型端点。
import json# Wrap bitstring in JSON
data = json.dumps({"signature_name": "serving_default", "instances": test_images[0:3].tolist()})json_file = open('predict.json', 'w')
json_file.write(data)
json_file.close()files.download('predict.json')
设置 Docker 环境
从官方网站安装 Docker。
下载的快速链接:
- macOS 的 Docker
- 适用于 Windows 10 Pro 或更高版本的 Docker
让我们从最新的 Tensorflow 服务图像开始
docker pull tensorflow/serving
使用部署在 REST API 端点上的模型运行服务映像。
docker run -p 8501:8501 --mount type=bind,source=/path/to/the/unzipped/model/tmp/,target=/models/fashion_mnist -e MODEL_NAME=fashion_mnist -t tensorflow/serving
现在，您的 docker 容器正在运行 Tensorflow 服务模型服务器，绑定 REST API 端口 8501，并将模型从我们的主机映射到容器中预期的位置。还传递了一个环境变量，这对查询我们的模型很重要。
您可以使用预测 API 查询模型
curl -d ‘{"signature_name": "serving_default", "instances": [[[[0.0], [0.0]…………….[0.0]]]]}’ -X POST http://localhost:8501/v1/models/fashion_mnist:predict
或者您可以在本地机器上运行下面的脚本来获得预测
太棒了，现在您的模型不会在您的本地系统中丢失，但是您可以将您的模型部署到生产中，以便人们可以使用它。
您已经使用本地系统中的 Tensorflow 服务成功创建了一个端点。我将会发布更多的博客来运行相同的和其他几种类型的云服务模式。
如果这对你有帮助，就发微博，让人们部署他们的模型，因为这有点复杂，是机器学习生命周期的关键部分。
Star this repository关注我的 Medium， 我将在未来几周发布更多关于 Tensorflow 算法、ML 模型管道的更新，以及与 AWS 和 Azure 等云服务集成的示例。
在 GitHub 上注册你自己的个人资料，这是托管代码、管理项目和构建软件的最佳地方…
github.com](https://github.com/vjgpt) [## 维杰·古普塔
Vijay Gupta 的最新推文(@vj_guptaaa)。机器学习运营工程师。我主要谈论#技术…
twitter.com](https://twitter.com/vj_guptaaa)
参考
https://www.tensorflow.org/guide/keras/save_and_serialize
https://www . tensor flow . org/tutorials/distribute/save _ and _ load
https://www.tensorflow.org/tfx/serving/api_rest
https://github.com/zalandoresearch/fashion-mnist
TensorFlow vs PyTorch —卷积神经网络(CNN)
CNN 在 TensorFlow 和 PyTorch 中对一个著名数据集的实现及结果比较
在我之前的文章中，我已经给出了一个 简单线性回归 在 TensorFlow 和 PyTorch 框架中的实现，并比较了它们的结果。在本文中，我们将使用两种框架在一个非常著名的时尚 MNIST 数据集上完成卷积神经网络(CNN)的应用，并比较结果。
起源—
让我们简要了解一下框架及其历史。首先， PyTorch 是基于 Torch 库的开源机器学习库。PyTorch 最初是由脸书的人工智能研究实验室(FAIR)开发的。它是免费的开源软件。
另一方面， TensorFlow 由谷歌大脑团队开发，用于谷歌内部研究目的。它广泛用于机器学习应用，如神经网络。它也是免费的开源软件。
为了了解哪种框架更有效、更简单，我们将使用这两种框架构建一个 ConvNet，并对它们进行比较。对于张量流，我们将使用 Keras 库。
问题—
为了比较这两个框架，我们将使用著名的时尚-MNIST 数据集。它是由 60，000 个样本的训练集和 10，000 个样本的测试集组成的 Zalando 文章图像的数据集。每个例子是一个 28×28 的灰度图像，与来自 10 个类别的标签相关联，例如衬衫、包、凉鞋、外套、运动鞋等。我们将使用两种框架构建一个具有 LeNet 通用架构的 CNN 网络，并比较它们的结果。
步骤 1:导入库
第一步，我们将导入 TensorFlow 和 PyTorch 框架所需的库。
导入库
步骤 2:获取和拆分数据集
下一步，我们将获得时尚 MNIST 数据集。由于它是一个非常常见的数据集，两个框架都预加载了一些功能，使我们能够下载并使用数据集。
PyTorch
在 PyTorch 中，内置模块用于加载数据集。由于我们需要张量形式的数据，通过使用torchvision.transforms.ToTensor()将数据转换成张量，并将其赋给变量transforms. ，然后使用torchvision.datasets下载数据。数据相应地被分成训练数据集和测试数据集。
张量流
另一方面，与 PyTorch 版本相比，使用 TensorFlow 从 keras 库中获取数据更加简单。数据集从keras.datasets加载，并相应地分成训练图像和测试图像。
步骤 3:加载数据
在这一步中，我们将把数据加载到训练集和测试集中。此外，我们还将查看图像在两个框架中是如何存储的。
PyTorch
在 PyTorch 中，图像存储在范围 0-1 中，因此图像以黑白显示。使用DataLoader功能将图像加载到 train_loader 和 test_loader 中。此外，还会打印图像的标签。
张量流
另一方面，TensorFlow 存储 0–255 范围内的图像，因此同一图像中存在颜色渐变。TensorFlow 加载数据的方法更简单。
步骤 4:构建模型
在这一步，我们将建立 CNN 模型。为此，我们将构建标准的 LeNet-5 架构，这是一个非常简单的架构，建于 1998 年。下面给出的是 LeNet-5 的架构。
(来源)
PyTorch
在这里，我们使用 PyTorch 框架构建 LeNet-5 架构。它具有 2 个卷积层，每个卷积层之后是平均池层、2 个全连接层和具有 10 个类别的最终输出分类器层，因为最终输出具有 10 个类别的时尚项目。
在这种情况下，通过创建一个特殊的类“NeuralNet”来构建模型，其中我们必须使用 init 方法来定义网络/模型的每一层。将此函数***‘forward’***调用很重要，因为这将覆盖nn.Module中的基本 forward 函数，并允许所有nn.Module功能正常工作。
张量流
另一方面，在 TensorFlow 中构建相同的模型不需要创建类，即使我们使用了Sequential()方法。我们发现，使用 TensorFlow 框架构建相同的模型比直接在 PyTorch 框架中构建相同的模型要简单明了得多。
步骤 5:可视化模型
在这一步中，我们将编译上一步中构建的模型，并设置优化器和损失函数。为此，在两个框架中，我们将使用 Adam 优化器和 分类交叉熵 损失函数，因为数据集中有 2 个以上的类。
PyTorch
在 PyTotch 中，我们首先创建一个在最后一步中构建的’ NeuralNet '模型的实例作为modelpy。然后，我们将优化器和损失函数分配给相应的变量。然后我们通过打印modelpy来可视化模型。
张量流
另一方面，在 TensorFlow 框架中，我们使用了compile() 函数，在该函数中，我们将如上所述定义优化器和损失函数。然后我们使用summary()来查看上面构建的 LeNet-5 架构的层。
步骤 6:训练模型
在这一步中，我们根据训练集中的数据部署为训练而构建的模型。对于这两个框架，我们将为 30 个时期训练模型，并查看结果。
PyTorch
对于 PyTorch，我们必须单独计算所有步骤，包括损失函数、优化器、反向传播和更新循环 的 中的每一步。
张量流
在 TensorFlow 中，时尚 MNIST 是一个二维数组，我们必须将训练数据集整形为张量，并将标签从整数转换为二进制类矩阵。使用fit()函数对模型进行训练，该函数由定义的历元数组成。
第七步:比较结果
在最后一步，我们将比较使用测试集上的框架构建的两个模型的结果。
PyTorch
在 PyTorch 中，输出预测由outputs = modelpy(images)预测。然后计算并显示测试集的准确度。
张量流
在 TensorFlow 中，predict()函数用于预测测试数据集中图像的类别，并计算和显示准确度。
结果
测试集由 1000 幅图像组成，基于 PyTorch 和 TensorFlow 框架构建的模型用于预测测试集图像的类别。
*>>Test Accuracy of the model on the 10000 test images: **89%** with PyTorch>>Test Accuracy of the model on the 10000 test images: **91.34%** with TensorFlow*
从结果中我们看到 TensorFlow 模型的测试集准确率为 91.34% ，比 PyTorch 模型的 89% 略高。
结论
从上面的比较中，我们能够理解使用当今深度学习中使用的两个最流行的框架来构建 CNN 模型。
在我看来，如果你是一个初学者，完全不知道使用哪个框架，我建议你从 TensorFlow 框架开始，因为它更简单，更容易理解。另一方面，PyTorch 更快、更动态，但需要对 Python API 有一点了解。
我附上了我的 GitHub 库，你可以在那里找到比较的完整代码。
* [## MK-gurucharan/tensor flow-vs-py torch-CNN
GitHub 是超过 5000 万开发人员的家园，他们一起工作来托管和审查代码、管理项目和构建…
github.com](https://github.com/mk-gurucharan/TensorFlow-vs-PyTorch-CNN)
请查看我以前的文章，在这篇文章中，我给出了构建简单线性回归模型的两种框架的比较。
[## TensorFlow 与 PyTorch —线性回归
TensorFlow 和 PyTorch 框架中线性回归的实现及其结果的比较
towardsdatascience.com](/tensorflow-vs-pytorch-linear-regression-e07781a83525)
我真的希望我能够很好地比较今天深度学习中使用的两个最流行的框架。在我的下一篇文章中与大家见面。到那时，快乐的机器学习！*
TensorFlow 与 PyTorch —线性回归
TensorFlow 和 PyTorch 框架中线性回归的实现及其结果的比较
如果你是深度学习和神经网络的新手，那么你一定遇到过术语“ TensorFlow ”和“ PyTorch ”。这是在数据科学领域使用的两个流行的深度学习框架。
在本练习中，我将向您展示使用两种框架实现最简单的 神经网络 ( 线性回归 )并比较它们的结果。
起源-
PyTorch 是基于 Torch 库的开源机器学习库。PyTorch 最初是由脸书的人工智能研究实验室(FAIR)开发的。这是一个免费的开源软件。
另一方面， TensorFlow 由谷歌大脑团队开发，用于谷歌内部研究目的。它广泛用于机器学习应用，如神经网络。它也是一个免费的开源软件。
TensorFlow vs PyTorch(图片来自来源
比较两个框架最有效的方法是同时使用它们并分析它们的结果来解决同一个问题。在本练习中，我们将使用 TensorFlow 和 PyTorch 框架执行 线性回归 ，并比较它们的结果。
问题-
在这个练习中，我们将使用一个非常简单的例子。这里给我们一个数字数组， x= [-1.0，0.0，1.0，2.0，3.0，4.0] 和 y= [-3.0，-1.0，1.0，3.0，5.0，7.0] 。这里用到的公式是 y = 2*x -1 ，这是一个线性回归。
x= [-1.0, 0.0, 1.0, 2.0, 3.0, 4.0]
y= [-3.0, -1.0, 1.0, 3.0, 5.0, 7.0]y = 2*x -1
在使用这两个框架训练线性回归模型时，我们将为 x=10 输入一个新值，并查看模型对 y 的预测。
张量流框架-
首先，我们将通过张量流框架。
张量流—线性回归
这是使用 keras 库用 TensorFlow 执行线性回归的代码。让我们仔细检查上面程序中的每个代码块。
第一步，我们将导入库。
import tensorflow as tf
import numpy as np
from tensorflow import keras
在下一步中，我们使用*序列、*设计我们的模型，它是层的线性堆栈。在这个模型中，我们只使用了一层(神经元)。
model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
第二步，我们定义我们的优化器和损失函数来训练我们的神经网络模型。在此，我们使用随机梯度下降( SDG )优化器和均方误差( MSE )作为我们的损失函数。
model.compile(optimizer='sgd', loss='mean_squared_error')
这一步之后，我们用两个变量"【xs】“和” ys "初始化我们的数字。
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)
在最后一步，我们用变量“xs”和“ys”来拟合我们的模型。我们用 500 个历元 训练模型。
model.fit(xs, ys, epochs=500)>>Epoch 500/500
1/1 [==============================] - 0s 1ms/step - loss: 5.1584e-05
在这最后一步，我们预测新的 xs = 10 的值。根据公式，y=2*x-1，对于 xs=10，我们得到一个值 19 。现在让我们看看我们的模型使用 TensorFlow 框架预测创造了什么价值。
print(model.predict([10.0]))>>[[**18.979048**]]
我们看到，使用 TensorFlow 框架设计的线性回归模型，我们得到了接近 19 的值。
PyTorch 框架
现在让我们看看使用 PyTorch 框架设计的线性回归模型。
PyTorch —线性回归
与 TensorFlow 模型相比，线性回归的 PyTorch 应用确实大且复杂。让我们分析模型的每一步。
第一步，我们导入设计线性回归模型所需的库。
import torch
from torch.autograd import Variable
在下一步中，我们将初始化与 TensorFlow 模型中定义的“【xs】”和“ ys ”相同的值。对于 PyTorch 应用程序，我们使用适当的函数将列表转换为张量**。**
**xs = [[-1.0], [0.0], [1.0], [2.0], [3.0], [4.0]]
ys = [[-3.0], [-1.0], [1.0], [3.0], [5.0], [7.0]]
xs = Variable(torch.Tensor(xs))
ys = Variable(torch.Tensor(ys))**
在这之后，我们定义一个类’ LinearRegressionModel '，我们将使用它来定义我们的模型。由于这是一个具有 1 个输入和 1 个输出的简单线性回归，我们使用输入和输出维度都等于 1 的线性模型。最后，我们使用上面定义的类创建一个“ 模型 ”。
****class** **LinearRegressionModel**(torch.nn.Module):
**def** __init__(self):
super(LinearRegressionModel, self).__init__()
self.linear = torch.nn.Linear(1, 1) *# One in and one out*
**def** forward(self, x):
y_pred = self.linear(x)
**return** y_pred
model = LinearRegressionModel()**
接下来，我们选择优化器和损失标准。我们选择了与 TensorFlow 应用程序相同的函数，即优化器的 SDG 函数和损失函数的 MSE 。此外，我们任意地将学习率固定为 0.01。
**criterion = torch.nn.MSELoss(size_average = **False**)
optimizer = torch.optim.SGD(model.parameters(), lr = 0.01)**
我们现在到达我们的训练步骤。在这一阶段，我们为 500 迭代执行三项任务，因为我们将历元值设置为 500。
- 通过传递数据并预测每个 xs 的 ys 值，执行正向传递。
- 使用 MSE 损失函数计算损失。
- 将所有梯度重置为 0，执行反向传播，最终更新权重。
****for** epoch **in** range(500):
*# Forward pass: Compute predicted y by passing*
*# x to the model*
pred_y = model(xs)
*# Compute and print loss*
loss = criterion(pred_y, ys)
*# Zero gradients, perform a backward pass,*
*# and update the weights.*
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('epoch **{}**, loss **{}**'.format(epoch, loss.item()))>>epoch 499, loss 5.151434834260726e-13**
最后，我们使用这个模型预测新的 xs=10 的值。如前所述，我们必须得到一个接近 19 的值。现在让我们看看 PyTorch 模型的输出。
**new_var = Variable(torch.Tensor([[10.0]]))
pred_y = model(new_var)
print(model(new_var).item())>>**18.999998092651367****
我们看到使用 PyTorch 框架构建的线性回归模型也给出了接近 19 的值。
比较-
在可视化从 TensorFlow 和 PyTorch 模型获得的结果时，我们看到 TensorFlow 模型给我们的结果是 18.979048 ，而 PyTorch 模型给我们的结果是18.998092651367。****
张量流模型— 18.979048
PyTorch 型号—18.99998092651367
可以清楚地看到，使用 PyTorch 框架构建的非常简单的神经网络比使用 TensorFlow 框架构建的模型具有更高的精确度。然而，PyTorch 模型本质上更复杂，初学者很难理解。
如果你对深度学习和神经网络完全陌生，我会建议你们从 TensorFlow 框架开始，然后在获得前者的经验后再转向 PyTorch 框架。
我附上了代码的详细版本。ipynb ),供您参考。
** [## MK-gurucharan/tensor flow-vs-py torch-线性回归-
这个库包含使用 TensorFlow 对 Python 中的数组执行线性回归的基本代码…
github.com](https://github.com/mk-gurucharan/TensorFlow-vs-PyTorch-Linear-Regression-/)
我希望我能够使用今天在深度学习中使用的两个最流行的框架来解释和演示简单神经网络(线性回归模型)的实现。到那时，快乐的机器学习！**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
