建立你的第一个 CNN
一种构建卷积神经网络的更好方法
定义
卷积神经网络(CNN)是一种深度神经网络，在图像识别和分类中是有效的。它们接受图像作为输入，通过内核从中提取特征，并预测所需的输出。在 CNN 中，数据的预处理是最少的，并且它们可以自学识别来自不同图像的重要特征。对象检测、对象识别、面部识别、自动驾驶等领域的几乎所有先进网络。以某种方式利用 CNN。
介绍
网上有很多关于从头开始构建 CNN 的教程。尽管它们中的大多数确实提供了高精度，但是它们忽略了内存和参数的大量使用。当谈到在行业中部署模型时，构建网络不仅要达到目标精度，还要优化内存消耗。在本文中，我们将学习如何为物体识别构建一个优化的 CNN。
为了保持正确的期望值，让我们设定一个目标:
目标:上的MNIST 数据集
1。达到 99.4 %的验证准确率
2。模型的总参数数应小于 15k
3。最大历元数= 20
为了实现这个目标，我们将把我们的行动计划分成 4 个迭代。首先，我们将重点构建一个达到目标精度的模型。然后，我们将大幅降低参数，同时保持架构。这种参数的减少会导致精度的下降。为了弥补这一下降，我们将优化模型以满足我们的目标。
为了确保我们的模型在每次迭代中都是一致的，让我们添加一个条件，将每次迭代之间的修改限制为三次。
在我们开始设计网络之前，有几个术语我们应该熟悉——
核心
核是随机分配的权重矩阵，其在图像上被遍历和卷积。一个内核从图像中提取单个特征。
频道
卷积层的输出可以视为一组通道。
例如，1 个灰度图像(NxN) →与 64 个核的卷积(3x3) → 64 个通道((N-2)x(N-2))
感受野
感受野是感觉周围的一个区域，在这个区域内刺激可以影响感觉细胞的电活动。在 CNN 中，这是由通道/内核的单个细胞感知的图像部分。
CNN 的模型结构是通过将焦点保持在感受野上来设计的。通常，网络末端的模型的感受野与对象的大小相似。
卷积块
包含多个*卷积层(3x3)的块。*在每个后续层中，通常增加内核/文件的数量，以确保从图像中提取所有重要特征。
每个卷积层都有一个激活函数(最好是 ReLU，因为它对参数要求很低，这使得反向传播很容易校正权重),它给网络增加了非线性。
过渡块
该块具有逐点(1x1) 卷积以减少通道数量，以及最大池层以减少空间维度或通道大小。这个块的关键作用是过滤掉不相关的特征，限制参数的数量。
现在让我们开始设计网络
目标 1:普通网络
布局架构时首先要考虑的是感受域。在模型的末尾，感受野应该等于物体的大小。完整的架构是围绕这个概念设计的。添加成对的卷积块和过渡块以获得所需的感受野。
注意:过渡块有一个池层，这会导致信息丢失。在网络的末端，信道的大小很小，信息很重要。因此，避免了朝向网络末端的过渡块。
在最后一个卷积块之后，我们使输出变平，并使用 softmax 激活来提供类似概率的分布。
在这个特定的问题中，第一个过渡块在网络中添加得更快，因为背景主要是白色的，不包含太多信息，并且大部分信息位于中心。所以在网络早期使用第一个 maxPool 比较方便。
参数个数:1595316
最佳精度:99.93%(train) Colab 笔记本
目标 2:减少参数
我们的目标是在少于 15k 的参数中实现 99.40%的精度。在本节中，主要重点是减少每个卷积中内核/文件的数量，以便总参数小于 15k，而不会对精度造成太大影响(这将在后面的步骤中通过优化技术来恢复)。
对以前型号的更新:
1。减少 3×3 卷积层中的滤镜
2。减少 1x1 卷积层中的滤波器
即使大幅减少所有层中的参数，总参数仍然超过 15k。
**3。恰好在第一过渡块和输出层的中间添加部分过渡块。**该部分过渡块将仅包括 1x1 卷积，但不包括最大池。
第三步确保只有重要的功能在网络中继续进行，并避免因最大池而可能发生的信息丢失。
参数个数:12490
最佳精度:99.71%(train) Colab 笔记本
目标 3:优化
由于我们已经丢弃了一大块参数，我们需要采用一些优化技术来确保我们的模型不会损害准确性。
对以前型号的更新:
1。添加批量规范化图层。
这有助于标准化数据，并限制网络稍后的规模变化。这固定了层输入的均值和方差，有助于更快的收敛和改进梯度流。
2。选择合适的学习速率
选择最适合网络的 LR(基于实验)
3 .一个验证检查点
精度与历元图并没有严格递增。精度不断波动，因此不能依赖最后一个历元来给出最佳结果。因此，添加了一个验证检查点，用于在每个时期后计算验证数据的准确性。
参数个数:12874
最佳精度:99.28% (val)，99.74%(train) Colab 笔记本
目标 4:过度拟合和进一步优化
请注意，训练和验证准确性之间的差距随着随后的时代而扩大。这说明模型过拟合。为了解决这个问题，我们将在每个 3x3 卷积后添加一个丢弃层。
对以前型号的更新:
1。Add Dropout
Dropout 随机跳过一些连接，强制网络学习其他参数。
2。增加一个 LR 调度器
一旦精度饱和，就需要降低学习率，这样模型才能收敛到更优的最小值，最终导致精度提高。
3。增加批量
大批量有助于更快地训练模型。
注意:批量不能过大。这可能导致损失函数陷入次优局部最小值。
参数个数:12874
最佳精度:99.36% (train)，99.41% (val)，第 19 历元 Colab 笔记本
超出我们的目标
我们已经实现了我们的目标。现在，让我们通过进一步减少每层中的内核数量，在不影响精度的情况下，尝试将我们的模型参数减少到 8k 以下。
参数个数:7602
最佳精度:98.93% (train)，99.44% (val)，第 22 历元 Colab 笔记本
进一步地
- 在稍微硬一点的数据集上实施这种方法，例如 CIFAR10、CIFAR100
- 使用图像增强:最有效的方法之一规范你的网络
- 添加跳过连接:这有助于模型拓宽其感受野范围，学习不同大小的对象。
- 使用循环 LR 加快收敛速度
参考资料:
- MNIST:勒村、扬恩；科琳娜·科尔特斯；克里斯托弗 J.C 伯吉斯。“MNIST 手写数字数据库，Yann LeCun，Corinna Cortes 和 Chris Burges”。检索于 2013 年 8 月 17 日
- 斯利瓦斯塔瓦，尼蒂什&辛顿，杰弗里&克里热夫斯基，亚历克斯&苏茨基弗，伊利亚&萨拉胡季诺夫，鲁斯兰。(2014).退出:防止神经网络过度拟合的简单方法。机器学习研究杂志。15.1929–1958.
在 GCP 建立你的第一个数据仓库
构建数据仓库的步骤是什么？你应该使用什么云技术？如何利用气流来协调你的管道？
这个项目的架构
作为一名数据专业人员，气流已经成为我的工具集的重要组成部分。在我之前的帖子之后，很多人联系我，询问如何开始学习气流。和许多其他事情一样，我相信开始学习一件事情的最好方法是通过实践。
在这个项目中，我们将在谷歌云平台上建立一个数据仓库，帮助回答常见的业务问题，并为仪表盘提供动力。您将直接体验如何构建 DAG 来实现常见的数据工程任务:从数据源提取数据，加载到数据接收器，转换数据并为业务消费建模。
如果你不知道什么是气流或者需要帮助来设置它，看看我以前的帖子。
气流已经存在了一段时间，但最近它获得了很大的牵引力。那么什么是气流呢？你如何使用…
towardsdatascience.com](/getting-started-with-airflow-locally-and-remotely-d068df7fcb4)
为什么选择谷歌云平台？
简短的回答是 BigQuery。虽然市场上有许多数据仓库解决方案，或者作为云提供商的解决方案，或者作为内部部署，但我对 BigQuery 的体验是最愉快的。
费用
首先，定价模式简单明了，无论规模大小都可以承受。您不需要为一个永不停机的实例(向您眨眼、红移)付费，而是每月每 TB 存储花费 20 美元，每次查询时每 TB 扫描花费 5 美元。
假设您的数据集大小为 200GB，这对于结构化数据集来说相当大。你每月只需支付 2 美元的仓储费。就查询成本而言，您也不会花费太多，因为 BigQuery 是一个列数据库，这意味着每次查询时，引擎不会扫描整个表，而是只扫描您选择的列，这取决于您构建数据仓库的方式，这是一个显著的成本节约。粗略估计，您一个月将扫描所有数据大约 50 次，这相当于扫描 10TB，花费您 50 美元。
因此，对于一个规模合理的结构化数据仓库，每月只需 52 美元，相比之下，最便宜的始终在线红移实例每月需要 146 美元。如果最低层的红移不能满足您的需求，那么无论您是否大量使用您的数据仓库，您每月都要支付大约 2，774 美元。对我来说，BigQuery 的按需定价更可取。
易用性
这更多的是个人意见，而不是确凿的事实，但我认为 GCP 比 AWS 更方便用户。在 GCP，从浏览器中维护权限或查询数据等操作通常更加用户友好。此外，BigQuery 会自动进行许多优化，在后台为您加速查询。
商业目标
在着手进行任何数据仓库项目之前，您应该有一个明确定义的、您试图解决的业务问题。对于这个项目，我选择了美国政府提供的 I94 移民数据，以及几个补充数据集。
假设你是美国移民局的数据工程师。你的老板找到你，说目前分析移民模式的方法是手工的，耗时且容易出错。他希望您提出一个解决方案，使分析过程更加简单、快速和可扩展。
该数据仓库将帮助美国官员分析移民模式，以了解是什么因素驱使人们迁移。
数据集
您可以为这个项目选择任何免费的数据源，并遵循。你可以在 Kaggle 或者谷歌数据集搜索上找到很多有用的数据集。以下是这个项目中使用的数据集。
- I94 移民数据:该数据来自美国国家旅游和贸易办公室。
- I94 数据字典:字典伴随着 I94 移民数据
- 世界温度数据:该数据集来自 Kaggle 。
- 美国城市人口统计数据:该数据来自 OpenSoft。你可以在这里阅读更多信息。
- 机场代码表:这是一个简单的机场代码和相应城市的表格。这里来自这里来自。
数据建模
根据原始数据，我们的下一步是为数据仓库设计一个数据模型。数据模型应该与业务目标和您试图回答的问题紧密联系在一起。
我根据星型模式原理设计了以下模型，其中包含一个事实表和七个维度表。
我们数据仓库的数据模型
F_IMMIGRATION_DATA:包含入境信息，如到达日期、离开日期、签证类型、性别、原籍国等。D_TIME:包含日期列的维度D_PORT:包含端口标识和端口名称D_AIRPORT:包含州内的机场D_STATE:包含状态标识和状态名称D_COUNTRY:包含国家标识和国家名称D_WEATHER:包含一个州的平均天气D_CITY_DEMO:包含一个城市的人口统计信息
体系结构
这个项目的架构
我们将跳过从不同数据库中提取数据的步骤，并假设我们在 Google 云存储(GCS)中拥有这个项目的所有数据。
GCS 将作为存储所有原始文件的数据源。然后，数据将被加载到 BigQuery 上的临时表中。ETL 过程将从这些临时表中获取数据，并创建数据仓库表。
Airflow 实例部署在 Google 计算引擎上或本地，以协调我们管道的执行。
以下是使用这些技术的理由:
- 谷歌云存储:充当我们的数据源，纵向可扩展。
- Google Big Query:充当数据仓库、数据集市和 ETL 过程的数据库引擎。BigQuery 是一种无服务器的解决方案，可以高效地处理 Pb 级数据集。
- Apache Airflow:通过发出 CLI 命令将数据加载到 BigQuery 或 SQL 查询中以执行 ETL 过程，从而协调工作流。Airflow 本身不需要处理任何数据，因此允许我们的管道进行扩展。
建立基础设施
要运行这个项目，你应该有一个 GCP 帐户。您可以免费创建一个新的 Google 帐户，并获得 300 美元的点数。与免费学分和免费层，你应该通过这个项目，无需支付任何费用。你可以参考我以前的文章这里在谷歌计算引擎实例上设置气流，并在这里运行我的代码来轻松地为项目创建必要的云资源。
否则，您可以使用 GCP 用户界面创建 GCS bucket、BigQuery 数据集和 BigQuery 表。
- 创建一个关于 GCP 的项目
- 通过添加信用卡启用计费(您有价值 300 美元的免费点数)
- 导航到 IAM 并创建一个服务帐户
- 授予帐户项目所有者。这对于本项目来说很方便，但不建议用于生产系统。你应该把钥匙放在安全的地方。
您可以通过运行以下命令将数据复制到存储桶中:
gsutil cp -r gs://cloud-data-lake-gcp/ gs://{your_bucket_name}
查看我的 GitHub repo 了解更多信息。
数据管道
数据管道
随着所有的设计和设置的方式，我们可以开始与这个项目的实际管道。下面用的代码可以参考我的 GitHub repo。
该项目在谷歌云平台上创建了一个数据湖，主要侧重于建立一个数据仓库和数据…
github.com](https://github.com/tuanchris/cloud-data-lake)
一个DummyOperator start_pipeline 启动流水线，随后是四个加载操作。这些操作将数据从 GCS bucket 加载到 BigQuery 表中。immigration_data被加载为parquet文件，而其他的被格式化为csv。在装载到 BigQuery 后，有检查行的操作。
接下来，管道从 I94 数据字典加载三个主数据对象。然后创建F_IMMIGRATION_DATA表，并检查以确保没有重复。还创建了其他维度表，管道也完成了。
导入气流库
定义新 dag 的第一件事是从 Airflow 导入所需的库。我们应该从 Airflow 导入 DAG，以及您希望使用的任何操作符。您可以阅读 Airflow 文档，了解操作员的工作内容和使用方法。
不同的操作符可以有相同的参数，每次使用操作符时定义所有相同的参数是重复的。这就是为什么您应该定义一个默认的 set 参数，它将被传递给所有的任务。
定义 DAG
接下来要做的是定义一个 DAG。您应该给它一个唯一的名称、开始日期和 schedule_interval。您还可以将上面定义的默认参数传递到 DAG。
可以使用 Airflow 变量传入变量，而不是像我下面这样在 DAG 定义代码中定义。经验法则是，对于经常变化的变量，使用气流变量。否则，您可以不使用标准的 Python 变量。请记住，您不应该定义大量的气流变量；否则，您可能会使气流的元数据数据库过载。
从 GCS 定义加载任务
对于我们的四个数据集，我们将使用GoogleCloudStorageToBigQueryOperator将数据从 GCS 加载到 BigQuery。您可以阅读 Airflow 文档，了解更多关于如何将变量传递给操作符的信息。
在我们的例子中，我们加载 CSV 格式的尺寸文件和 parquet 格式的immigration数据。请注意，对于 CSV 文件，您应该提供一个模式来确保以预期的格式加载数据。对于 parquet 格式，您不需要这样做，因为 parquet 文件已经附带了一个模式。
定义数据检查
在我们将数据加载到 BigQuer 之后，我们应该检查我们之前的任务是否按预期运行。我们可以通过检查表中的行数来验证是否有行存在。根据您的业务需求，您可以在这里实现更复杂的数据质量检查。
创建事实和维度表
在临时数据集中加载并检查了临时数据后，我使用 BigQueryOperator 执行 SQL 查询来转换和加载事实表和 dim 表。
注意，我在查询中传递参数，而不是数据集和表。这使得在开发和生产环境之间切换变得更加容易。查看我在 GitHub repo 中的 SQL 查询，找出我在转换中使用了什么逻辑。
定义任务相关性
最后，我们必须定义任务依赖性，即哪些任务相互依赖。您可以使用>>或<<操作符来实现。您也可以使用列表对多个任务进行分组。
结果
在所有这些步骤之后，您将有一个数据仓库呈现给您的老板。
我们的数据仓库
让我们运行一下我们的数据仓库。让我们看看哪些州的移民人数最多。在我们的数据集中，佛罗里达的移民人数最多，其次是纽约和加利福尼亚。
谁要移民到美国，他们的性别是什么？
打扫
请记住关闭 Airflow 实例/删除未使用的资源，以避免不必要的费用。
摘要
在本文中，我使用 Airflow 作为编排器，完成了在 GCP 设计和部署数据仓库的许多步骤。如您所见，这是一个漫长而复杂的过程，因此我无法在一篇文章中涵盖所有内容。
我希望你能更好地理解数据工程师是做什么的，并能运用这些知识。
快乐学习！
在 DialogFlow 上构建您的第一个 ML 集成聊天机器人！
丹尼尔·科尔派在 Unsplash 上拍摄的照片
您在 Google 的 DialogFlow 上的第一个机器学习集成聊天机器人只需 4 个步骤！
任何机器学习模型都是无用的，除非你把它应用到现实生活中。在 Jupyter 笔记本上运行模型，吹嘘 99.99%的准确率，都于事无补。你需要把它做成一个端到端的应用程序，把它呈现给外界。聊天机器人是一种有趣又简单的方式。
构建聊天机器人从未如此简单。谷歌的 DialogFlow 是一个显而易见的选择，因为它非常简单，快速和免费！在继续之前，先自己试用一下这个应用程序这里！
流动
现在您已经尝试过了，接下来要构建完整的应用程序，我们将讨论以下步骤:
- 你的机器学习模型(这里是 Iris)
- 获取用户输入的对话流聊天机器人
- 部署在任何公共主机上的 Flask 应用程序，用于呈现请求和响应
- 聊天机器人对 flask api 进行的 webhook 调用，用于发送数据和获取结果
- 集成 DialogFlow 和 Telegram
我们将一个接一个地检查每个步骤。让我们先来看看我们的完整应用程序的架构会是什么样子:
建筑
发生了什么事？
因此，用户可以访问 Telegram 聊天机器人，我们将建立在 DialogFlow 上，稍后与 Telegram 集成。对话开始，聊天机器人提示用户输入数据，这些数据是花的尺寸(花瓣长度、花瓣宽度、萼片长度和萼片宽度)。一旦聊天机器人接收到最后一个输入，它将触发对 flask API 的 webhook 调用，该 API 将部署在公共主机上。这个 flask API 由我们的应用程序组成，它将检索 4 个数据点，并将其与我们的机器学习模型相匹配，然后将预测回复给聊天机器人。你可以在我的 Github 找到完整的代码。
现在让我们来看一下每一步！
构建组件
ML 模型
首先，让我们建立一个基本的最大似然模型，该模型采用虹膜尺寸并预测虹膜类型。这里没有火箭科学。只是一个非常基本的模型，它能以相当高的精度呈现结果。下面是快速实现这一点的基本代码。
#Load data
iris = load_iris()
X = iris.data
y = iris.target
#Train test split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42, test_size = 0.25)
#Define and fit to the model
clf = RandomForestClassifier(n_estimators=10)
clf.fit(X_train, y_train)
predicted = clf.predict(X_test)
print(accuracy_score(predicted, y_test))
print(clf.predict(X_test))
#Save the model as Pickle
import pickle
with open(r'rf.pkl','wb') as model_pkl:
pickle.dump(clf, model_pkl, protocol=2)
我们只需加载数据，并使其适合随机森林分类器。不需要清理数据，因为数据集已经非常小了。我不会为了避免复杂性而在这里进行任何优化，因为我们的主要目标不是模型的准确性，而是完整的应用程序。然后只需 pickle 这个模型，之后这个模型、*‘RF . pkl’、*就会被加载到我们的 flask 应用中。
对话流聊天机器人
现在让我们直接进入 DialogFlow 来制作我们的聊天机器人。您也可以使用其他 API 和框架来构建聊天机器人，但 Google 的 DialogFlow 是一个显而易见的选择，因为它简单、免费且构建速度极快！前往 DialogFlow ，用你的谷歌账户登录。然后点击“创建代理”来创建您的聊天机器人。
创建代理
接下来，我们需要创建一个向用户请求数据并进行 webhook 调用的意图。让我们首先编辑默认的欢迎意图，让它要求用户回答“是”或“否”。
现在，只要用户键入“Yes”，DialogFlow 就会调用另一个 intent，要求用户输入并将数据点存储在“Entities”中。这里我们处理简单的随机数，所以我们不需要创建自定义实体。DialogFlow 有默认的实体来处理这样的数据。因此，我们需要为这个意图创建一个“Yes-follow-Intent ”,因为该意图将在用户的肯定回复之后被调用。
点击“添加跟进意向”>“是”。如果您愿意，可以将此意图重命名为其他名称。我将把它重命名为“IrisData”。现在我们需要添加实体，这些实体将保存从用户那里收到的数据。我们将在这里为所有 4 个输入使用默认的 @sys.number 实体。为用户需要的 4 个数据点设置 4 个不同的参数——花瓣长度、花瓣宽度、萼片长度、萼片宽度。确保添加提示，并要求用户单独输入。
添加参数
添加提示
用一些输入来训练模型，以便它知道会发生什么。您现在可以在右侧面板测试聊天机器人，检查它是否相应地运行。
完成后，您需要通过“为此目的启用 webhook 调用”来启用履行。通过这样做，这个特定的意图将对我们部署在公共主机 Heroku 上的应用程序进行 webhook 调用。我们现在需要构建 flask 应用程序，并将其部署在 Heroku 上，然后将 URL 放在左侧的“Fulfillment”选项卡中。
Heroku 上的 Flask 应用程序
我们现在需要构建我们的 flask 应用程序，它从我们的 chatbot 获取 webhook 调用，检索数据，然后适应 ML 模型(rf.pkl ),并将履行文本和预测一起返回给 DialogFlow。下面是代码:
# Importing necessary libraries
import numpy as np
from flask import Flask, request, make_response
import json
import pickle
from flask_cors import cross_origin
# Declaring the flask app
app = Flask(__name__)
#Loading the model from pickle file
model = pickle.load(open('rf.pkl', 'rb'))
# geting and sending response to dialogflow
@app.route('/webhook', methods=['POST'])
@cross_origin()
def webhook():
req = request.get_json(silent=True, force=True)
res = processRequest(req)
res = json.dumps(res, indent=4)
r = make_response(res)
r.headers['Content-Type'] = 'application/json'
return r
一旦完成，我们需要处理来自 DialogFlow 的 JSON 格式的实现请求来检索数据。履行请求看起来像这样:
API 请求格式
所以我们需要进入’ query result ’ > > ’ parameters ’ > > ’ number ‘，’ number1 ‘，’ number2 ‘，’ number4 '。一旦检索到，我们将把这些数据点转储到一个数组中，并将其应用到我们的模型中，从而得到预测。
# processing the request from dialogflow
def processRequest(req):
result = req.get("queryResult")
#Fetching the data points
parameters = result.get("parameters")
Petal_length=parameters.get("number")
Petal_width = parameters.get("number1")
Sepal_length=parameters.get("number2")
Sepal_width=parameters.get("number3")
int_features = [Petal_length,Petal_width,Sepal_length,Sepal_width]
#Dumping the data into an array
final_features = [np.array(int_features)]
#Getting the intent which has fullfilment enabled
intent = result.get("intent").get('displayName')
#Fitting out model with the data points
if (intent=='IrisData'):
prediction = model.predict(final_features)
output = round(prediction[0], 2)
if(output==0):
flowr = 'Setosa'
if(output==1):
flowr = 'Versicolour'
if(output==2):
flowr = 'Virginica'
#Returning back the fullfilment text back to DialogFlow
fulfillmentText= "The Iris type seems to be.. {} !".format(flowr)
#log.write_log(sessionID, "Bot Says: "+fulfillmentText)
return {
"fulfillmentText": fulfillmentText
}
if __name__ == '__main__':
app.run()
一旦完成，我们只需要在公共主机上部署代码。我再次选择了 Heroku，它简单、免费、超级快捷！你只需要添加以下文件到你的新 Github 库:flask 应用程序，模型 pickle 文件，一个 Procfile(这是非常重要的，帮助 Heroku 定位 flask 应用程序)，和一个需求文本文件，告诉 Heroku 要正确运行应用程序需要预装哪些库和版本。
只需在 Github 上创建一个存储库，然后访问 Heroku。创建一个“新应用”,并在那里“连接”你的 Github 库。一旦连接，只需点击部署按钮，你就大功告成了！
将 Github repo 连接到 Heroku 应用程序
Webhook 调用
现在进入最后一步。我们现在需要将部署的应用程序连接到我们的聊天机器人。只需输入部署您的应用程序的 URL，并在其中添加“/webhook”即可。记住上面的 flask 代码，应用程序被路由到“/webhook”。只需转到 DialogFlow 左侧面板的“履行”选项卡，启用“网页挂钩”并添加<your_app>/网页挂钩即可。</your_app>
在 DialogFlow 上启用 Webhook
我们完了。(不要忘记点击保存按钮！)您可以在右侧面板上通过发起聊天来测试 webhook 请求/响应是否工作正常。您应该得到带有预测的实现响应。
与电报集成
到了最后一步。这里没什么要做的，因为将 web 应用程序与 DialogFlow 集成非常容易。我们首先需要去电报那里生成一个虚拟机器人，并生成它的令牌。搜索“机器人父亲”并点击“新机器人”。它会问你机器人的名字。根据需要输入任何名称。然后它会提示您输入用户名。
在你完成之后，你的机器人的一个令牌和一个链接将会在这里生成。只需复制令牌并转到左边的 DialogFlow“集成”面板。在那里启用 Telegram，粘贴您刚刚生成的令牌，然后单击 start。就是这样！现在只需进入电报机器人链接，并尝试应用程序！
使用 Python 和 Newscatcher 构建您的第一条新闻数据管道
新闻捕手
Newscatcher python 包可以让你从 3000 多个主要的在线新闻网站自动收集最新的新闻数据。
当我写这篇文章时，许多人不得不在家工作，有些人在此期间有很多空闲时间。你可以利用这段时间建立你的投资组合，提高你的技能或者开始一个副业。
Newscatcher 包使得新闻文章数据的收集和标准化变得容易，而不需要任何外部依赖。它是在我们开发名为 Newscatcher API 的主要数据即服务产品时构建的。我们是开发者优先的团队，因此，我们尽可能开源，以便编码人员可以免费部分复制我们已经完成的工作。
使用我们的包的方法很简单，你传递网站 URL 作为输入，获取最新的文章作为输出。对于每篇文章，您都有一个 标题、完整的 URL、简短的描述、发表日期、作者 和一些更多的变量。
快速启动
你需要 Python 3.7 以上版本
通过 PyPI 安装软件包:
pip install newscatcher
从包中导入 新闻捕捉器 类:
from newscatcher import Newscatcher
例如，我们想看看nytimes.com的最后一篇文章是什么
你必须传递 URL 的基本形式——没有www.，既没有https://，也没有在 URL 末尾的/。
news_source = Newscatcher(‘nytimes.com’)last_news_list = news_source.news
news _ source . news是 feedparser 的列表。FeedParserDict 。 Feedparser 是一个规范 RSS 提要的 Python 包。在我的另一篇中型文章中，我更详细地解释了什么是 RSS 以及如何使用 feedparser 处理它:
[## 使用 Python 通过 RSS/Atom 提要收集新闻文章
或者如何停止依赖数据提供商
towardsdatascience.com](/collecting-news-articles-through-rss-atom-feeds-using-python-7d9a65b06f70)
需要知道的一件重要事情是每个 RSS/Atom 提要可能有自己的一组属性。尽管 feedparser 在结构化方面做得很好，但是不同的新闻发布者的文章属性可能会有所不同。
对于 nytimes.com 的**，物品属性列表如下:**
article = last_news_list[0]
article.keys()dict_keys(['title', 'title_detail', 'links', 'link', 'id', 'guidislink', 'summary', 'summary_detail', 'published', 'published_parsed', 'tags', 'media_content', 'media_credit', 'credit'])
在上面的代码中，我们获取名为 last_news_list 的列表中的第一篇文章，并检查它的键(每篇文章都是一个字典)。
当我们浏览主要属性时:
print(article.title)Coronavirus Live Updates: New York City Braces for a Deluge of Patients; Costs of Containment Growprint(article.summary)Soldiers in Spain found nursing home patients abandoned. Officials warned that New York was experiencing a virus “attack rate” of five times that elsewhere in the United States. Washington edged closer to a $2 trillion relief package.print(article.link)[https://www.nytimes.com/2020/03/24/world/coronavirus-updates-maps.html](https://www.nytimes.com/2020/03/24/world/coronavirus-updates-maps.html)print(article.published)Tue, 24 Mar 2020 10:35:54 +0000
最有可能的是，你会在所有新闻出版商的文章数据中找到上述所有属性。
**目前，最大的新闻出版商都在 Newscatcher 上。**因此，你可以建立一个端到端的数据项目。此外，您还可以做许多不同的事情，例如:
- 收集新闻文章并将其保存到某种数据库的管道(带重复数据删除)
- +添加一个 NLP 层(例如，命名实体识别)
- +跟踪某个特定的主题
- +刮一篇文章的全文
- +可视化汇总数据
我建议在使用 newscatcher 包时使用以下包/技术:
- Elasticsearch 存储和查询数据
- Newscaper3k python 包自动抓取文章全文
- NLP 的空间
给那些想提高投资组合的人一个小提示。能够向招聘人员展示你有能力做一个端到端的项目会让你的简历脱颖而出。然而，你的工作的商业价值也很重要。因此，试着做一些服务于任何真实案例商业价值的东西。祝你好运。
阅读媒介上 Artem 的作品。固执己见的数据专家。newscatcherapi.com 和 politwire.com 的联合创始人…
medium.com](https://medium.com/@kotartemiy)
如果你想支持我们的团队，你可以通过注册 Newscatcher API 的封闭测试版来帮助我们。我们的 API 允许你搜索过去发布的最相关的新闻。
构建您的第一个随机森林分类器
预测病人的心脏病
图片由来自 Pixabay 的 Gordon Johnson 提供
在本文中，我将指导您使用 scikit-learn 库中的随机森林构建一个简单的分类器。
我们将从从 Kaggle 下载数据集开始，之后，我们将做一些基本的数据清洗，最后，我们将拟合模型并评估它。同时，我们还将创建一个用于评估的基线模型。
这篇文章适合希望了解机器学习项目的基本工作流程并构建他们的第一个分类器的初级数据科学家。
下载并加载数据集
我们将使用这个链接从 Kaggle 下载心脏病数据集。
该数据集包括近 300 名患有或未患有心脏疾病的患者。这就是我们将要预测的。
为此，我们将使用十三种不同的功能:
- 年龄
- 性
- 胸痛类型(4 个值)
- 静息血压
- 血清胆固醇(毫克/分升)
- 空腹血糖> 120 毫克/分升
- 静息心电图结果(值 0，1，2)
- 达到最大心率
- 运动诱发的心绞痛
- oldpeak =运动相对于休息诱发的 ST 段压低
- 运动 ST 段峰值的斜率
- 荧光透视着色的主要血管数量(0-3)
- thal: 3 =正常；6 =修复缺陷；7 =可逆缺陷
现在花点时间熟悉一下这些描述，这样您就能理解每一列代表什么。
下载完数据集并将其放入 Jupyter 笔记本文件所在的文件夹后，您可以使用以下命令加载数据集。
import pandas as pd
df = pd.read_csv('data.csv')
df.head()
这是您将使用的数据框的头部。
数据清理
你发现上面数据框中的问号了吗？看起来这个数据集的作者用它们来表示空值。让我们用真正的 Nones 来代替它们。
df.replace({'?': None}, inplace=True)
现在我们已经完成了，我们可以检查我们的数据集中有多少空值。我们可以用 info()函数来实现。
df.info()
我们可以看到第 10、11 和 12 列有很多空值。*Ca’和‘thal’*实际上几乎是空的，‘slope’只有 104 个条目。缺少的值太多，无法填写，所以让我们删除它们。
df.drop(columns=['slope', 'thal', 'ca'], inplace=True)
其余的列没有或很少缺少值。为了简单起见，我建议删除那些有它们的条目。我们不应该丢失太多数据。
df.dropna(inplace=True)
我们可以从 info()函数的结果中读取的另一个信息是，大多数列都是对象，即使它们看起来有数值。
我怀疑这是由初始数据集中的问号引起的。现在我们已经删除了它们，我们应该能够将对象更改为数值。
为了做到这一点，我们将对整个数据帧使用 pd.to_numeric()函数。对象值应该变成数字，它不应该影响已经编号的值。
df = df.apply(pd.to_numeric)
df.info()
如你所见，我们现在只剩下浮点数和整数。info()函数还确认删除了列’*Ca ‘，’ thal '*和[T2 ‘，’ slope '。
此外，具有空值的行被删除，因此，我们有一个包含 261 个数值变量的数据集。
在我们继续之前，我们还需要做一件事。我注意到最后一列*‘num’*的名称中有一些尾随空格(肉眼看不出来)，所以让我们来看看列名列表。
df.columns
您应该在最后一列*‘num’*中看到尾随空格。让我们通过应用 strip()函数来移除它们。
df.columns = [column.strip() for column in df.columns]
搞定了。
探索性数据分析
我们来做一些基本的数据分析。我们将首先使用直方图来观察变量的分布。
import matplotlib.pyplot as plt
plt.figure(figsize=(10,10))
df.hist()
plt.tight_layout()
我们能立即注意到的是，有些变量不是连续的。实际上，只有五个特征是连续的:'‘年龄’，’ chol ‘，’ oldpeak ‘，’ thalach ‘，’ trestbps’ ，而其他的都是分类变量。
因为我们想在探索中区别对待他们，我们应该把他们分成两组。
continous_features = ['age', 'chol', 'oldpeak', 'thalach', 'trestbps'] non_continous_features = list(set(df.columns) - set(continous_features + ['num']))
完成后，您可以通过在 Jupyter 笔记本单元格中键入变量名来检查它们的值。
continous_features
non_continous_features
现在，我们将检查连续特征在目标变量中有何不同。我们将通过散点图来实现这一点。
import seaborn as sns
df.num = df.num.map({0: 'no', 1: 'yes'})
sns.pairplot(df[continous_features + ['num']], hue='num')
请注意，我们必须将‘num’*变量设为字符串，以便将其用作色调参数。我们是这样做的，将 0 映射为“否”,表示健康的患者，将 1 映射为“是”,表示患有心脏病的患者。
如果你看散点图和 kde，你会发现心脏病患者和健康患者相比有地区模式。
为了探究分类变量，我们将通过使用 describe()函数来查看它们可以取的不同值。
df[non_continous_features].applymap(str).describe()
我们可以看到’ exang ‘，’ fbs’ 和 ‘sex’ 是二进制的(它们只取两个不同的值)。而*‘CP’和‘reste ceg’*分别取四个和三个不同的值。
最后两个是数据集作者编码的有序分类变量。我不确定我们是否应该这样对待它们，或者将它们改为伪编码。这将需要进一步的调查，我们可以在未来改变方法。现在，我们将让它们保持有序。
最后但同样重要的是，我们将探索目标变量。
df.num.value_counts()
我们有 163 名健康患者和 98 名有心脏问题的患者。不是理想的平衡数据集，但对我们的目的来说应该没问题。
创建基线模型
在快速的探索性数据分析之后，我们准备好构建一个初始分类器。我们首先将数据集分为特征和目标变量。
X = df.drop(columns='num')
y = df.num.map({'no': 0, 'yes': 1})
*注意，我必须反转创建 seaborn 图时应用的映射，因此，在创建 y 变量时需要 map()函数。
我们还使用了数据集的所有功能，通过查看我们的快速 EDA，它们似乎都是相关的。
现在，我们将使用 train_test_split()函数将 X 和 y 变量进一步划分为它们的训练和测试对应变量。
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1) X_train.shape, X_test.shape, y_train.shape, y_test.shape
作为上述操作的结果，我们现在应该有四个不同的变量:X_train，X_test，y_train，y_test，它们的尺寸打印在上面。
现在我们将使用 DummyClassifier 构建一个基线。
from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score
dc = DummyClassifier(strategy='most_frequent')
dc.fit(X,y) dc_preds = dc.predict(X)
accuracy_score(y, dc_preds)
如你所见，基线分类器在训练集上给了我们 62%的准确率。我们基线的策略是预测最频繁的类。
看看能不能用随机森林打败它。
随机森林分类器
下面的代码设置了一个随机森林分类器，并使用交叉验证来查看它在不同折叠上的表现。
from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection
import cross_val_score rfc = RandomForestClassifier(n_estimators=100, random_state=1)
cross_val_score(rfc, X, y, cv=5)
如您所见，这些精度通常比我们的虚拟基线高得多。只有最后一次折叠的准确度较低。看起来这最后一个折叠有很难识别的例子。
然而，如果我们取这五个的平均值，我们会得到大约 74%的准确率，这远远高于 62%的基线。
通常，这是一个我们希望使用 GridSearchCV 等工具进一步调整模型参数的阶段，但这不是本教程的一部分。
现在让我们看看模型在测试集上的表现如何。如果你注意到了，我们到目前为止还没有对测试做任何事情。它一直被搁置到现在。
评估模型
我们将从准确性方面检查模型性能开始。
首先，我们将使用整个训练数据来拟合模型，然后我们将在测试部分上调用 accuracy_score()函数。
rfc.fit(X_train, y_train)
accuracy_score(rfc.predict(X_test), y_test)
我们的测试准确率达到了 75%。类似于我们在 74%的训练集上的平均交叉验证准确度计算。
让我们看看虚拟分类器在测试集上的表现如何。
accuracy_score(dc.predict(X_test), y_test)
基线分类器的准确度约为 51%。这实际上比我们的随机森林模型的准确性差得多。
然而，在评估分类器时，我们不应该只看准确性。让我们看看随机森林和基线模型的混淆矩阵。
我们将从使用 scikit-learn 函数计算随机森林的混淆矩阵开始。
from sklearn.metrics import plot_confusion_matrix
plot_confusion_matrix(rfc, X_test, y_test)
事实上，我们做得一点也不差。我们只有五个假阳性，还有八个假阴性。此外，我们预测 26 个有心脏问题的人中有 18 个会有心脏病。
不是很好，但也没那么糟。请注意，我们甚至没有调整模型！
让我们将这个混淆矩阵与为基线模型计算的混淆矩阵进行比较。
from sklearn.metrics import plot_confusion_matrix
plot_confusion_matrix(dc, X_test, y_test)
仔细看看上面的图表。你能看到我们总是预测标签 0 吗？这意味着我们预测所有患者都是健康的！
没错，我们已经设置了虚拟分类器来预测多数类。请注意，对于我们的目的来说，这将是一个可怕的模型，因为我们不会发现任何有心脏问题的患者。
兰登森林做得好多了！实际上，在测试的 26 人中，我们发现了 18 人有心脏问题。
总结
在这篇文章中，你已经学习了如何使用随机森林构建一个基本的分类器。
这是对在数据集上构建模型时使用的主要技术的概述，没有涉及太多的细节。
这是有意的，所以这篇文章不会太长，并且可以作为想要构建他们的第一个分类器的人的起点。
快乐学习！
最初发表于 about datablog . com:2020 年 8 月 13 日打造你的第一个随机森林分类器，。
PS:我正在 Medium 和aboutdatablog.com上写文章，深入浅出地解释基本的数据科学概念。你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入。
下面还有一些你可能喜欢的帖子
* [## 作为一名有抱负的数据科学家，你应该关注的中型作家
我最喜欢的 10 个数据科学博主，让你的学习之旅更轻松。
towardsdatascience.com](/medium-writers-you-should-follow-as-an-aspiring-data-scientist-13d5a7e6c5dc) [## 熊猫概况和探索性数据分析的第一行代码！
了解如何为自动 EDA 安装和使用 pandas profiling
towardsdatascience.com](/pandas-profiling-and-exploratory-data-analysis-with-line-one-of-code-423111991e58) [## Jupyter 笔记本自动完成
数据科学家的最佳生产力工具，如果您还没有使用它，您应该使用它…
towardsdatascience.com](/jupyter-notebook-autocompletion-f291008c66c) [## 9 大 Jupyter 笔记本扩展
改进笔记本电脑功能，提高您的工作效率
towardsdatascience.com](/top-9-jupyter-notebook-extensions-7a5d30269bc8)*
在 R 中构建您的第一个闪亮的 Web 应用程序
作者绘制的图像
数据科学
闪亮教程第 1 集
你想公开你的 R 代码给其他人使用吗？如果您的回答是肯定的，那么这篇文章是为您准备的，因为我将向您展示如何使用 Shiny 包在 R 中构建您的第一个 web 应用程序。
为了补充这篇文章，你也可以观看我在我的 YouTube 频道 Data Professor 上制作的视频用 R 构建你的第一个 Web 应用。
数据科学生命周期
数据科学生命周期从收集数据开始，这些数据将作为数据集和数据科学项目的核心组成部分。接下来，需要清理该数据集，以消除缺失数据和任何异常。顾名思义，探索性数据分析(EDA)将允许我们了解数据集的一般特征，这可以通过执行描述性统计和数据可视化来实现。从 EDA 中获得的见解可以为构建预测模型(例如，分类、回归、聚类、关联分析等)提供起点和思路。).为了完成生命周期，可以将性能最佳的模型部署为应用程序编程接口(API)和 web 应用程序。
数据科学生命周期。(由 Chanin Nantasenamat 绘制)
为什么要构建 Web 应用程序？
所以问题是，你为什么想要构建一个 web 应用程序？这是一个很好的问题！
部署的 web 应用程序提供了一个图形化的前端(用户界面或 UI ),允许用户输入输入参数，后端(服务器)将处理这些参数并将其发送回来，以便在 web 前端上显示。在机器学习的上下文中，将经过训练的机器学习模型部署为 web 应用允许用户通过简单地将输入参数输入到 web 前端上提供的表格中来容易地进行预测，该表格将用作经过训练的机器学习模型的输入特征，其中该模型将进行预测。
所有这些都是通过点击几下鼠标来实现的，因为用户不需要任何编码方面的技术知识来进行这种预测。在本文中，您将学习如何使用 Shiny 包在 R 中制作 web 应用程序。
除了部署机器学习模型，还可以创建 web 应用程序来托管数据驱动的仪表板。这些仪表板可以提供有用的感兴趣的汇总数据，这些数据基本上可以用于实时监控和评估指标和性能。
什么是闪亮的？
在我们进一步讨论之前，也许先简单介绍一下什么是闪亮的。
Shiny 是一个 R 包，可以让你轻松构建交互式 web 应用。使用 Shiny 的好处是，它可以将你的 R 代码扩展到网络上，这将有助于将它的可用性扩展到更广泛的社区中(从单个用户使用到成百上千的用户通过互联网使用)。
除了 Shiny 包提供的功能外，还有几个扩展包补充了 Shiny 的功能，如 shinythemes 、 shinydashboard 、 shinyjs 等。
你能用闪亮建造什么？
这是一个很好的问题！以下是一些开始的想法，我相信你能想出更多的。
- 机器学习驱动的网络应用
- 数据驱动的仪表板
- 数据收集表格
在闪亮画廊还有很多其他的例子。
将 Web 应用程序部署到互联网
在你自己的本地计算机上测试了闪亮的网络应用程序后，你确信它可以工作并准备好发布到互联网上，你可以将它部署到你自己的服务器上，或者通过应用程序托管服务，例如 Shinyapps.io 和 Heroku T21。那么这两者有什么区别呢？
拥有自己的服务器的好处是你可以完全控制电脑，因此你可以随心所欲地安装所有软件、模块和软件包。这样做的缺点是，您需要掌握大量的知识来管理服务器。例如，你可能需要精通 BASH 命令，以便通过服务提供商管理云上的 Ubuntu 服务器，如数字海洋(100 美元免费信用)、Linode、亚马逊网络服务或谷歌云平台。
使用 应用托管服务 的好处是，你不用担心管理服务器。没错，不再需要处理服务器更新，不再需要配置路径和复杂的软件和库编译。这些应用程序托管服务提供商允许你将精力集中在构建应用程序上，就是这样！
闪亮网络应用的结构
闪亮的 web 应用程序由 3 个组件组成:
- 用户界面(ui。r)—UI 是接受用户输入值的前端。
- 服务器功能(Server。R) —服务器是后端，处理这些输入值，最终产生最终显示在网站上的输出结果。
- shinyApp 功能 —将 UI 和服务器组件结合在一起的应用本身。
一个闪亮的 web 应用程序如何工作的示意图。(由 Chanin Nantasenamat 绘制)
闪亮网络应用的代码
现在，有趣的部分来了，让我们看看我们今天将要构建的闪亮的 web 应用程序的代码(如下所示)。
闪亮的 Web 应用程序是如何工作的？
下面的 3 个简单步骤总结了我们使用这个闪亮的 web 应用程序时发生的事情。
运行闪亮的网络应用程序
现在，让我们运行 web 应用程序。
第一步。继续启动你的 RStudio。
***第二步。*点击文件→新建文件→ R 脚本，粘贴上图所示的整块代码，另存为app.R(也可以下载 app。r 档)。
第三步。**点击位于文件面板右上方的运行 App* 按钮(如下图白色圆圈所示)。*
app 截图。r 文件包含 RStudio 中闪亮的 Web 应用程序。
几分钟后，您将看到一个弹出窗口，显示闪亮的 web 应用程序，如下所示。请注意，web 应用程序的输出值为空，因为输入参数仍然为空。
已执行 app 截图。r 文件(点击运行应用程序按钮后)。
让我们在两个输入框(名和姓)中填入值，您将看到输出框(主面板)现在将显示连接在一起的名+姓。例如，我们用“机”作为的名，用“学”作为的姓。在底层，UI 组件接受来自 2 文本框的输入参数，输入名和姓。接下来，我们连接这两个变量以产生一个输出“机器学习”。最后，UI 在主面板(灰色框)上显示这个输出。
输入了输入参数的 web app 截图。
对代码的逐行解释
上面显示的代码已被注释，将代码的主要部分标记如下:
# Load R packages(第 1 行)，# Define UI(第 5 行)，# Define server function(31 行)# Create Shiny object(第三十九行)
现在，我们将在接下来的小节中更深入地讨论上述 4 个部分。
加载 R 包(第 1–3 行)
- 线 2 —装载
shiny包装 - 线 3 —装载
shinythemes包
定义用户界面(第 5–29 行)
- 第 6 行—
fluidPage()函数创建了流畅的页面布局，元素可以通过这种方式缩放以占据浏览器的可用宽度。所有的 UI 元素都包含在fluidPage()函数中。我们使用的第一个输入参数是theme选项，其中我们定义了来自shinythemeR 包的cerulean主题的使用。
(注意:右括号在第 29 行)。 - 第 7 行—
navbarPage()顾名思义，函数创建一个带有顶级导航栏的页面。
第 9 行—web app 的名称定义为“My first app”。
第 10 行 —这里我们使用tabPanel()功能定义选项卡面板。这代表三个选项卡面板中的第一个，因此我们将选项卡面板定义为“Navbar 1”。 - 第 11 行 —这里我们使用了
sidebarPanel()函数(右括号在第 16 行)，以便 web 应用程序可以在 web 应用程序的左侧有一个侧边栏面板，接受用户输入参数。第 12 行 HTML 标签tags$h3用于向侧边栏面板提供“Input:”的子标题标题。
第 13-14 行—textInput()函数用于接受用户以文本字段形式输入的值。textInput()函数中包含的输入参数包括(1)变量名(如txt1或txt2)，(2)显示在文本字段上方的标题(如“Given Name:”和“Surname:”)以及(3)
(注意:右括号在第 28 行)。 - 第 17 行 —这里我们使用了
mainPanel()函数(右括号在第 22 行)。
第 18 行 —使用h1()标签功能显示“Header 1”的标题。
第 20 行 —通过使用h4()标签功能显示“Output1”的子标题*(不是错别字，而是表示标题的层次)。
第 21 行 —显示将输入值(名和姓)组合在一起得到的输出值。* - 第 25–26 行 —其余两个选项卡面板通过
tabPanel()功能显示在这两行上。第一个输入参数是选项卡面板的名称“Navbar 2”或“Navbar 3”，而第二个输入参数是“This panel is intentionally left blank”。因此，在点击这两个选项卡面板时，我们将看到消息“This panel is intentionally left blank”，这是这两个选项卡面板的内容。
定义服务器功能(第 31–37 行)
- 第 32 行——定义服务器，输入和输出变量通过反应性本质上连接在一起(即输入值的变化将立即或反应性地导致输出值的更新)。
- 第 34–36 行 —如上图漫画所示，用户输入的来自
input$txt1和input$txt2( 即分别对应Given Name和Surname)的输入值被赋给output$txtout变量(即处理后的输出值)，该变量将被传回 UI，显示在输出文本框中(第 21 行)。特别是，Given Name和Surname将通过paste()函数组合在一起，输入参数是来自 UI 文本输入的txt1和txt2变量(即第 35 行的input$txt1和input$txt2)
注意第 34–36 行的output$txtout(来自服务器函数)与第 21 行的txtout是同一个变量(来自 UI 函数)。同样，第 13 行和第 14 行上的 txt1 和 txt2(来自 UI 函数)与input$txt1和input$txt2(来自服务器函数)是相同的变量。
创建闪亮的对象(第 39-40 行)
- 第 40 行—
shinyApp()函数将上面定义的 ui 和服务器变量作为输入参数，并将它们融合在一起，以构建我们最终看到的真正闪亮的 web 应用程序。
恭喜你！您现在已经成功地在 R 中创建了您的第一个闪亮的 Web 应用程序！
订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费赠品)!
关于我
我是泰国一所研究型大学的生物信息学副教授和数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我做的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub page )。
数据科学、机器学习、生物信息学、研究和教学是我的激情所在。数据教授 YouTube…
www.youtube.com](https://www.youtube.com/dataprofessor?sub_confirmation=1)
在社交网络上与我联系
YouTube: http://youtube.com/dataprofessor/
LinkedIn:https://www.linkedin.com/company/dataprofessor/
https://www.linkedin.com/company/dataprofessor/
【HTTP://facebook.com/dataprofessor/】
【GitHub:【HTTPS://github.com/dataprofessor/】
Instagram:【HTTPS://www.instagram.com/data*
构建完全可配置的界面，用 Python 在 10 分钟内创建类似 MNIST 的数据集
一步一步的用户友好的 python 界面，从 JSON 配置文件中编写数据集(带代码)
动机
为了一个个人项目，也许是一篇论文(手指交叉)，我需要创建一个类似 MNIST 的数据集。我以为可以对别人有用。因此，我将解释我是如何用 Python 编写这个接口的。( github 库)
本文的目的是能够将自己的界面设计成尽可能的灵活和快速。这个界面将允许我们用鼠标绘制我们的角色**，其他所有事情都将通过配置文件中指定的大量参数自动完成。**
完全可配置
我正在从一个 JSON 文件中寻找一个完全可配置的接口。再也不用摸代码，就是灵活、便捷和可伸缩。我们将在本文中讨论不同的参数，但是所有的参数都包含在我命名为config.json的文件中。你可以随意命名。它允许您更改:
- 我们在上面绘制的图像的尺寸。
- 输出图像的尺寸，以完成数据集**。**
- 每个类别的预期图像数量，首选绘图节奏以及我们输出图像的渲染的存在。
- 包含数据集的文件夹名称，可以为每个类创建子文件夹。
- 我们铅笔的尺寸、强度和褪色…
- 插补方法。
- 命名类的。
存储和公用设施
重要的事情先来。我们需要知道如何组织我们的数据。在文件config.json中，我们有storage部分:
- root (str):数据集的 root 文件夹的路径
- by_class_name (bool):数据集的存储方式
我们所有的图像都将有相同的图案。图像的名称总是以类名开头。然后是下划线，然后是 5 个字符的数字来标识它。所以我们有一个root/(subfolderclass)/name_id.png格式。
您会注意到 id 是递增设置的**。换句话说，你可以看到每个类已经生成了多少图像。然而，作为用户，你可能需要也可能不需要将其他文件放入这些文件夹中，或者有时删除图像或重命名它们。我们将在代码的开头放一小部分，让自动重新排列我们的图像名称。**
在utils.py中我们设置了一些功能:
- get_json :返回 json 文件的**内容，作为 python 字典。**
- check_folder_path :检查文件夹是否存在，否则新建一个。****
- order _ filename _ by _ prefix:按照正确的名称格式对文件重新排序。
设计师
我们想要的是能够用手(鼠标)画出我们的角色。从绘图窗口中，我们想要快速创建数据集。然后我们需要一个class Designer，我们将把它存储在designer.py文件中。为了理解我们为什么需要这个类，让我们仔细看看配置文件中的一些参数:****
- 输入:包含要绘制图像的尺寸和绘图铅笔的粗细(仅用于可视化)。
- 输出:包含输出图像的尺寸，以构成我们的数据集。
- 插值 → 方法 (str 或 str 列表):我们的绘图图像和我们的输出图像的尺寸不一样。所以我们需要一个插值方法来调整图像的大小。然后我们可以选择由 OpenCV 提供的所有插值方法:
INTER_NEAREST、INTER_LINEAR、INTER_AREA、INTER_CUBIC、INTER_LANCZOS4。我们可以精确RANDOM来改变每个图像的插值方法。该参数可以是一个列表:在这种情况下，指定的插值方法有多少个设计器，输入图像就有多少个输出图像。 - 线条→粗细(浮动或浮动列表):输出图像上的铅笔粗细与图像对角线成比例。该参数可以是一个列表:在这种情况下，设计者的数量将和笔的粗细一样多。结果是一个设计矩阵结合了插值方法和指定厚度。
- line → range_value (int 或 int 的列表):像素在绘制时的亮度。在列表的情况下:所画像素的亮度将在指定范围内随机选择。
- 线条→渐变(浮点):线条的边缘的渐变值，渐变为线性。对数值
fading=1没有影响。
注意绘图将由线条组合完成。因此有了draw(self, pt_1, pt2)的角色。所以我们仍然需要用鼠标来控制这一切。
控制器
首先我们需要创建一个class Controller和从配置字典中初始化**。**
在初始化期间，会发生几件事:
- ****提取的所有配置参数。
- ****验证文件夹是否存在，如果不存在，创建它们。
- ****设计器的初始化。
- 按已经完成的类别计算数量的图像**。**
- 创建用于绘图的 OpenCV 窗口和用于可视化的 OpenCV 窗口。
为了创建我们所有的设计师，将有一个设计师矩阵**，其中垂直用于铅笔粗细，而水平用于插值方法。同时我们可以创建一个函数来捕捉绘图窗口上的鼠标事件。只有按下鼠标左键**才能绘图。最后，您可以检索已经绘制的图像数量。****
让我们画画吧
在我们开始绘制之前，让我们来看看process中我们最后的参数建议:
- volume (int):每个类要到达的图像数量。
- 选择 (str):选择下一个要绘制的字符的方式。可以是
RANDOM、CLASSBYCLASS写完一个字再去写其他的，或者ROTATE轮流换不同的类。 - display_output (bool):显示或不显示输出窗口。
现在可以创建一个新的图像来绘制，绘制它，以正确的格式保存(root/(subfolderclass)/name_id.png)。
剩下的就是能够从 OpenCV 窗口中查看所有内容，并且只要没有达到每个类的图像量就运行程序。****
主要的
最后，为了更加方便，我们可以让用户选择使用 shell 中的命令来指定他的配置文件:
python3 main.py -c path/to/the/config/file.json
or
python3 main.py -config path/to/the/config/file.json
知识就是分享。
支持我，一键获得访问 中我所有文章的。****
来源
一切都是自制的，可以免费使用
用 Wolfram Alpha API 和 Python 构建您的下一个项目
实践教程
让我们将 Wolfram Alpha 中的精选数据、自然语言处理、文本到语音转换、绘图渲染等功能应用到您的下一个项目中吧！
任何在某一点上与数学斗争的人都知道 Wolfram Alpha，并且可能因为它解决任何方程、绘制任何函数或可视化逻辑电路的能力而得救。Wolfram Alpha can 然而，做的远不止这些，包括化学、语言学或历史，最重要的是，它可以使用它的公共 API 给你所有的答案。因此，在这篇文章中，我们将探索如何使用它来回答简单的问题，解决数学问题，渲染情节，甚至描述 DNA 序列！
安装
Wolfram Alpha API 是免费的(用于非商业用途)，但是我们仍然需要获得 API key (AppID)来对 API 端点执行查询。为了获得 API 密钥，我们将首先在 https://account.wolfram.com/login/create 的处创建 Wolfram ID。创建帐户后，我们可以导航到developer.wolframalpha.com/portal/myapps，点击注册获得您的第一个 AppID 按钮，填写获得新的 AppID 对话框。之后，我们将看到 API 键，这里称为 AppID ，我们可以使用下面的示例查询来测试它:
上面的代码使用 Wolfram|Alpha 完整结果 API 来找出蚊子的寿命。为此，它向http://api.wolframalpha.com/v2/query发出GET请求，其中包含指定我们的 AppID 进行身份验证的参数、input字段中的问题、格式参数为plaintext(而不是图像)以及最终的输出类型为 JSON(而不是默认的 XML)。
我们以字典的形式遍历结果，寻找感兴趣的字段进行打印。返回的 JSON(或 XML)可能相当复杂，解析它的最简单方法是打印它，并在其中寻找任何有用的字段。上述查询的响应的精简示例如下所示:
做数学
Wolfram Alpha 最有用的部分(在我看来)是解决复杂数学问题的能力。因此，让我们尝试使用 API 来做一些数学计算:
上一节中展示的完整结果 API 不仅仅回答一些奇怪的问题，它还做数学(和几乎所有的事情)。为了让 API 意识到我们想要做数学运算——在本例中——求解方程，我们需要在实际的方程前面加上单词solve。除了输入本身，该查询看起来与上一节中的查询非常相似。添加到这个参数中的一个额外的东西是includepodid参数，它告诉 API 在这种情况下我们只希望在响应中包含Result pod。“但是，pod 是什么？”，你可能会问。
来自 Wolfram Alpha(网站和 API)的每个结果通常包括多个类别的数据。例如，这可以是图表、图像、逐步解决方案或表格。其中的每一个都属于它自己的叫做 pod 的部分，而 pod 又包括子 pod来保存单独的数据。考虑到每个响应有时甚至可能包括 10 个左右的 pod，描述一下我们希望从 API 中得到什么是可取的。为此，可以使用podtitle和更健壮的includepodid参数，如上所示。
因此，上述查询的过滤响应如下所示:
为了进行比较，相同的(但图形)结果，但所有的豆荚看起来像这样:
带有输入、结果、绘图和数字行窗格的结果
Wolfram Alpha 可以成为很好的学习资源，因为它不仅能够显示结果，而且所有的计算步骤和 API 都可以做到这一点。为了获得一个查询的逐步解决方案，我们需要包含另一个名为podstate的参数，它指定 pod 状态变化。这将使用修改后的版本替换原来的 pod，例如，更多位数的十进制数，如圆周率(DecimalApproximation)、扩展的天气数据(更多天/月/年)或在我们的情况下，方程解的步骤:
渲染数学降价
您可以使用 Wolfram Alpha API 的一个巧妙技巧是呈现 MathML。如果你不熟悉 MathML，那么这里有一个快速概述——MathML代表数学标记语言，它是一种基于 XML 的格式，用于在 web 浏览器中呈现类似 LaTeX 的数学表达式。尽管这种格式已经存在很长时间了，但只有 Firefox 才真正支持它，这可能让它看起来像是一个糟糕的选择，但名为 MathJax.js 的 JavaScript 显示引擎使得在任何浏览器中呈现 MathML 成为可能，如果你想在你的 web 应用程序或博客中以 LaTeX 格式显示非常好看的复杂公式，这是一个不错的选择。说完了，我们来查询一下吧！
我们再次使用上一节中的例子，通过逐步求解来查询方程，但是用format=plaintext代替format=mathml，同样用mathml代替所有其他出现的plaintext，例如result = data[0]["mathml"]。上面你可以看到 API 给出的一点 MathML 输出，由于完整的输出非常长，所以它被修剪得很短，但我鼓励你自己尝试运行查询，通过 MathJax.js 传递它，并享受美丽的 LaTeX 数学表达式。
求解布尔代数
Wolfram Alpha 的另一个常见用例是求解布尔代数。与基本方程一样，我们需要做的就是将公式传递给 API，这是我们将得到的结果:
除了我们选择的特定 pod—Input、MinimalForms和TruthDensity之外，上面的查询没有显示任何新内容。在解析这 3 个 pod 中的数据后，我们可以看到输出，其中包括提交的输入公式的更好的形式，它的其他计算形式(CNF，DNF…)以及分数和百分比形式的真实密度。
渲染和下载图
我最喜欢用 Wolfram Alpha 做的事情之一就是渲染复杂的情节。实现这一点甚至不需要太多的代码更改，唯一真正的更改是选择 pod 及其字段:
在这种情况下，我们使用includepodid参数来选择3DPlot和ContourPlot窗格，这些窗格在其img.src字段中保存相应地块图像的 URL。然后可以下载这些图，并以二进制模式写入，生成以下图像:
三维绘图
不仅仅是数学
在这一点上，我认为我们已经看到了足够多的 Wolfram Alpha 和 math 的应用程序。那么，我们还能做什么？举个简单的例子，让我们探索一些 DNA 序列:
我们再次使用相同的 API 端点，但是这次我们提交代表 DNA 序列的字符串。您可能会注意到，我们不需要像前面的solve或plot那样在查询前包含关键字。这次我们没有使用关键字，而是添加了scanner参数，它指定了搜索查询的主题区域，在本例中是Genome。要找到哪个扫描仪将为某个查询返回相关数据，最简单的方法是运行不带scanner参数的查询，并查找每个包含预期数据的 pod 的scanner属性。
DNA 序列显然不是你可以搜索的唯一酷的东西。其他一些有趣的话题可以是历史、化学、交通或音乐——仅举几例。
自然语言(口语)答案
如果只是寻找信息，那么前面例子中的例子和 API 就足够了。然而，如果你想要/需要更自然的回答，那么你可以使用口语结果 API :
对v1/spoken端点的查询非常简单。我们需要传入的只是一个 AppID 和我们在i参数中的问题。这产生了完整句子形式的反应，而不是简单的事实。这在构建智能聊天机器人时非常有用，或者可以作为文本到语音引擎的输入。
使用对话 API 聊天
作为对口语结果 API 的一种扩展，Wolfram Alpha 还提供了对话 API ，允许你提出后续问题，从而与 API 进行对话。所以，让我们试一试，问 Wolfram Alpha 一些问题:
考虑到我们要问多个问题，我们也必须进行多个查询。第一个是针对v1/conversation端点，并在i参数中包含一个问题。我们还用geolocation参数指定我们的位置——这是可选值之一(其他的是ip和units),可以为问题提供上下文。第一个请求与口语结果 API 做的事情差不多，这意味着它以完整句子的形式返回信息。
当我们提出后续问题时，乐趣就开始了。为此，我们进行另一个查询，但是这一次，我们将它发送到作为对第一个查询(host = r["host"])的响应的一部分提供的主机。第一个响应还包括conversationID，我们也必须为 API 传递它，以了解在它之前说了什么。
然后，第二个查询返回与第一个相同类型的结果，这允许我们使用提供的conversationID和host继续询问更多问题。
我想在这里强调的最后一点是，问题和答案是如何很好地流动和使用上下文的。在这个例子中，我们使用了*“离这里有多远？”作为后续问题，没有具体说明【它】或【这里】*到底是什么。这些信息是从前面的问题和geolocation参数中自动推断出来的。
结论
就 Wolfram Alpha 提供的信息而言，这篇文章只是冰山一角。这些 API 不仅仅可以用于数学，我认为它是构建酷机器人、智能设备或基于语音的应用程序的良好起点。即使它不是免费的商业用途，你仍然会每月收到 2000 个请求，这足以启动一些很酷的项目。我建议查看https://products.wolframalpha.com/api/获取每个 API 端点的文档，以及 Wolfram Alpha 登录页面，它显示了所有不同的主题，可能会给你一些关于可以用它构建什么的想法。😉
本文最初发布于martinheinz . dev
使你的 Python 代码可读、有效、简洁和可靠的习惯用法和惯例。
towardsdatascience.com](/writing-more-idiomatic-and-pythonic-code-c22e900eaf83) [## 为您的 GitHub 档案创建一个精彩的自述文件
使用 GitHub 隐藏的新功能— GitHub Profile READMEs，在 GitHub 上展示您的项目和技能！
towardsdatascience.com](/build-a-stunning-readme-for-your-github-profile-9b80434fe5d7) [## 用 Python 从公共 API 抓取新闻和文章
让我们探索纽约时报、卫报、黑客新闻和其他 API，并为您的下一个项目收集一些新闻数据！
towardsdatascience.com](/scraping-news-and-articles-from-public-apis-with-python-be84521d85b9)
用 7 行 Python 代码构建您自己的有声读物
不买有声读物，用 Python 实现文本转语音有声读物
图片由来自 Pixabay 的 Felix Lichtenfeld 拍摄
有声读物是大声朗读的一本书或其他作品的录音或画外音。可用的流行有声读物列表有:
如果你有一本 pdf 格式的有声读物，你就不需要订阅。在本文中，您将知道如何用 7 行 python 代码开发一个基本的有声读物。
安装:
Python 有大量服务于各种目的的库。在本文中，我们将需要两个库( pyttsx3，PyPDF2 )来开发一本有声读物。
您可以从 PyPl 安装这些库，
**pip install PyPDF2
pip install pyttsx3**
在这里阅读 pyttsx3 库的完整文档。
1)阅读 PDF 文件:
Python 有库 PyPDF2 ，它是作为 PDF 工具包构建的。它允许在内存中操作 pdf。该库能够:
- 提取文档信息，如标题、作者等
- 按页面拆分文档
- 按页面合并文档
- 裁剪页面
- 将多页合并成一页
- 加密和解密 PDF 文件
- 还有更多！
我们正在使用这个库将 pdf 文件逐页拆分，读取每页上的文本，并将文本发送到下一层/步骤。
import PyPDF2
pdfReader = PyPDF2.PdfFileReader(open('file.pdf', 'rb'))
2)初始化扬声器:
Python 有一个 pyttsx3 库，能够离线转换文本到语音。我们使用 pypdf2 库从 pdf 文件中读取的文本作为文本到语音转换引擎的输入。
import pyttsx3
speaker = pyttsx3.init()
3)播放有声读物:
使用 PyPDF2 实现从 pdf 文件中逐页提取文本。通过阅读文本并将其提供给 pyttsx3 扬声器引擎，循环浏览每一页。它将从 pdf 页面中大声读出文本。
循环处理 pdf 文件中的每一页，最后停止 pyttsx3 扬声器引擎。
for page_num in range(pdfReader.numPages):
text = pdfReader.getPage(page_num).extractText()
speaker.say(text)
speaker.runAndWait()
speaker.stop()
全面实施:
改变 pyttsx3 扬声器的声音、速率和音量:
你可以调整说话的速度和音量，并根据你的要求将配音从男声改为女声，反之亦然。
速率:
初始化 pyttsx3 库，使用getProperty(‘rate’)获取当前的语速。使用setProperty(‘rate’, x)改变说话速度，其中 x=100 为正常速度(1x)。
# Initialize the speaker
speaker = pyttsx3.init()rate = speaker.getProperty('rate')
print(rate)speaker.setProperty('rate', 125)
声音:
初始化 pyttsx3 库，使用getProperty(‘voice’)获取当前说话者的性别。使用setProperty(‘voice’, voice[x].id)改变说话者的性别，其中 x=0 表示男性，x=1 表示女性。
voices = speaker.getProperty('voices')
print(voices)#changing index, changes voices, 0 for male
speaker.setProperty('voice', voices[0].id)#changing index, changes voices, 1 for female
speaker.setProperty('voice', voices[1].id)
音量:
初始化 pyttsx3 库，并使用getProperty(‘volume’)获取当前卷。使用setProperty(‘volume’, x)改变扬声器的音量。音量范围从 0 到 1，其中 0 是最小音量，1 是最大音量。
volume = engine.getProperty('volume')
print(volume)engine.setProperty('volume',1.0)
将语音保存到音频文件:
使用以下方法将音频输出(有声读物)保存到 mp3 文件。
engine.save_to_file(text, 'audio.mp3')
engine.runAndWait()
结论:
在本文中，我们介绍了一个基本有声读物的实现，它可以使用几行 python 代码阅读整本 pdf 书籍。为了获得更好的音频效果，您还可以调整扬声器库的声音、速率和音量。
有声读物的最终音频效果不是很好，因为文本在馈送到扬声器引擎之前需要一些预处理。
参考资料:
[1] PyPDF2 文档:https://pypi.org/project/PyPDF2/
[2] pyttsx3 文档:https://pyttsx3.readthedocs.io/en/latest/
感谢您的阅读
使用 PyCaret 2.0 在 Power BI 中构建您自己的 AutoML
py caret——Python 中的开源低代码机器学习库
PyCaret 2.0
上周我们已经宣布了 PyCaret 2.0 ，这是一个开源的、Python 中的低代码机器学习库，可以自动化机器学习工作流。它是一个端到端的机器学习和模型管理工具，可以加快机器学习实验周期，帮助数据科学家变得更加高效和多产。
在本帖中，我们展示了一个分步教程，介绍如何使用 PyCaret 在 Power BI 中构建自动化机器学习解决方案，从而允许数据科学家和分析师在没有任何额外许可或软件成本的情况下，向他们的仪表板添加一层机器学习。PyCaret 是一个开源的免费使用的 Python 库，它提供了广泛的功能，可以在 Power BI 中工作。
在本文结束时，您将了解如何在 Power BI 中实现以下内容:
- 设置 Python conda 环境并安装 pycaret==2.0。
- 用 Power BI 链接新创建的 conda 环境。
- 在 Power BI 中构建您的第一个 AutoML 解决方案，并在仪表板上展示性能指标。
- 在 Power BI 中生产/部署您的 AutoML 解决方案。
Microsoft Power BI
Power BI 是一种业务分析解决方案，可让您在整个组织中可视化数据和共享见解，或将它们嵌入到您的应用程序或网站中。在本教程中，我们将通过将 PyCaret 库导入 Power BI 来使用 Power BI Desktop 进行机器学习。
什么是自动机器学习？
自动机器学习(AutoML)是将机器学习的耗时、迭代任务自动化的过程。它允许数据科学家和分析师高效地构建机器学习模型，同时保持模型质量。任何 AutoML 解决方案的最终目标都是基于一些性能标准最终确定最佳模型。
传统的机器学习模型开发过程是资源密集型的，需要大量的领域知识和时间来产生和比较几十个模型。借助自动化机器学习，您可以轻松高效地加快生产就绪型 ML 模型的速度。
【PyCaret 是如何工作的？
PyCaret 是一个用于监督和非监督机器学习的工作流自动化工具。它被组织成六个模块，每个模块都有一组可用于执行某些特定操作的功能。每个函数接受一个输入并返回一个输出，在大多数情况下，这是一个经过训练的机器学习模型。第二版中可用的模块有:
PyCaret 中的所有模块都支持数据准备(超过 25 种基本预处理技术，附带大量未经训练的模型&支持定制模型、自动超参数调整、模型分析和可解释性、自动模型选择、实验日志记录和简单的云部署选项。
https://www.pycaret.org/guide
要了解更多关于 PyCaret 的信息，点击这里阅读我们的官方发布公告。
如果你想开始使用 Python，点击此处查看入门笔记本示例库。
“PyCaret 通过为业务分析师、领域专家、公民数据科学家和经验丰富的数据科学家提供免费、开源和低代码的机器学习解决方案，使机器学习和高级分析的使用民主化”。
开始之前
如果您是第一次使用 Python，安装 Anaconda 发行版是最简单的入门方式。点击这里下载 Python 3.7 或更高版本的 Anaconda 发行版。
https://www.anaconda.com/products/individual
设置环境
在我们开始在 Power BI 中使用 PyCaret 的机器学习功能之前，我们需要创建一个虚拟环境并安装 pycaret。这是一个分为三步的过程:
✅ 步骤 1——创建一个 anaconda 环境
从开始菜单打开 Anaconda 提示符并执行以下代码:
conda create --name **myenv** python=3.7
Anaconda 提示符—创建环境
✅步骤 2 —安装 PyCaret
在 Anaconda 提示符下执行以下代码:
pip install **pycaret==2.0**
安装可能需要 15-20 分钟。如果您在安装时遇到问题，请查看我们的 GitHub 页面，了解已知问题和解决方案。
✅ 第三步——在 Power BI 中设置 Python 目录
创建的虚拟环境必须与 Power BI 链接。这可以使用 Power BI Desktop 中的全局设置来完成(文件→选项→全局→ Python 脚本)。默认情况下，Anaconda 环境安装在以下位置:
C:\Users\ 用户名\ AppData \ Local \ Continuum \ anaconda 3 \ envs \ myenv
文件→选项→全局→ Python 脚本
👉让我们开始吧
设置业务环境
一家保险公司希望通过使用住院时的人口统计和基本患者健康风险指标来更好地预测患者费用，从而改善其现金流预测。
( )数据来源 )
目标
根据数据集中的其他变量，如年龄、性别、体重指数、儿童、吸烟者和地区，训练和选择预测患者费用的最佳回归模型。
👉步骤 1-加载数据集
你可以直接从 GitHub 加载数据集，方法是进入 Power BI Desktop → Get Data → Web
链接到数据集:https://raw . githubusercontent . com/py caret/py caret/master/datasets/insurance . CSV
Power BI 桌面→获取数据→ Web
在超级查询中创建重复数据集:
超级查询→创建重复数据集
👉步骤 2-以 Python 脚本形式运行 AutoML
在 Power Query 中运行以下代码(转换→运行 Python 脚本):
**# import regression module**
from pycaret.regression import ***# init setup**
reg1 = setup(data=dataset, target = 'charges', silent = True, html = False)**# compare models**
best_model = compare_models()**# finalize best model** best = finalize_model(best_model)**# save best model**
save_model(best, 'c:/users/moezs/best-model-power')**# return the performance metrics df** dataset = pull()
超级查询中的脚本
前两行代码用于导入相关模块和初始化设置函数。设置功能执行机器学习中所需的几个必要步骤，例如清除缺失值(如果有的话)、将数据分成训练和测试、设置交叉验证策略、定义度量、执行特定于算法的转换等。
训练多个模型，比较和评估性能指标的神奇函数是 **compare_models。**它根据可以在 compare_models 中定义的’ sort’ 参数返回最佳模型。默认情况下，它对回归用例使用“R2 ”,对分类用例使用“准确性”。
其余的行用于最终确定通过 compare_models 返回的最佳模型，并将其保存为本地目录中的 pickle 文件。最后一行返回数据帧，其中包含模型训练的详细信息及其性能指标。
输出:
Python 脚本的输出
仅用几条线，我们就训练了 20 多个模型，该表显示了基于 10 倍交叉验证的性能指标。
最高性能模型梯度推进回归器将与整个转换管道一起作为 pickle 文件保存在您的本地目录中。稍后可以使用该文件在新数据集上生成预测(请参见下面的步骤 3)。
转换管道和模型保存为 pickle 文件
PyCaret 致力于模块化自动化的想法。因此，如果您有更多的资源和时间进行培训，您可以扩展脚本来执行超参数调整、集成和其他可用的建模技术。请参见下面的示例:
**# import regression module**
from pycaret.regression import ***# init setup**
reg1 = setup(data=dataset, target = 'charges', silent = True, html = False)**# compare models**
top5 = compare_models(n_select = 5)
results = pull()**# tune top5 models** tuned_top5 = [tune_model(i) for i in top5]**# select best model** best = automl()**# save best model**
save_model(best, 'c:/users/moezs/best-model-power')**# return the performance metrics df** dataset = results
我们现在返回了前 5 名的型号，而不是一个最高性能的型号。然后，我们创建了一个列表理解(循环)来调整顶级候选模型的超参数，最后 automl 函数选择一个性能最佳的模型，然后保存为 pickle 文件(注意，这次我们没有使用 finalize_model ，因为 automl 函数返回最终模型)。
样本仪表板
示例仪表板已创建。PBIX 文件上传到这里。
使用 PyCaret AutoML 结果创建的仪表板
👉步骤 3-部署模型以生成预测
一旦我们将最终模型保存为 pickle 文件，我们就可以使用它来预测新数据集的电荷。
加载新数据集
出于演示目的，我们将再次加载相同的数据集，并从数据集中删除“charges”列。在 Power Query 中以 Python 脚本的形式执行以下代码以获得预测结果:
**# load functions from regression module**
from pycaret.regression import load_model, predict_model**# load model in a variable** model = load_model(‘c:/users/moezs/best-model-powerbi’)**# predict charges** dataset = predict_model(model, data=dataset)
输出:
Power 查询中的 predict_model 函数输出
部署电源 BI 服务
当您将包含 Python 脚本的 Power BI 报告发布到服务时，这些脚本也将在您的数据通过本地数据网关刷新时执行。
要实现这一点，您必须确保托管您的个人网关的计算机上也安装了 Python 运行时以及相关的 Python 包。请注意，由多个用户共享的本地数据网关不支持 Python 脚本执行。点击此处阅读更多相关信息。
本教程中使用的 PBIX 文件被上传到这个 GitHub 库:【https://github.com/pycaret/pycaret-powerbi-automl
如果你想了解更多关于 PyCaret 2.0 的信息，请阅读这个公告。
如果您以前使用过 PyCaret，您可能会对当前版本的发行说明感兴趣。
使用 Python 中的这个轻量级工作流自动化库，您可以实现的目标是无限的。如果你觉得这有用，请不要忘记给我们 github 回购⭐️。
要了解更多关于 PyCaret 的信息，请关注我们的 LinkedIn 和 Youtube。
你可能也会感兴趣:
使用 PyCaret 在 Power BI 中进行机器学习
使用 PyCaret 在 Power BI 中构建您的第一个异常检测器
如何使用 PyCaret 在 Power BI 中实现聚类
主题使用 PyCaret 在 Power BI 中建模
重要链接
博客
py caret 2.0 发行说明
用户指南/文档 Github
stack overflow
安装 PyCaret
笔记本教程
贡献于 PyCaret
想了解某个特定模块？
单击下面的链接查看文档和工作示例。
在 Keras 中构建自己的深度学习图像分类模型
从头开始构建自己的深度学习图像分类模型的直观指南
图 1:Pascal-VOC 数据集的分类示例
介绍
图像分类是近年来越来越受欢迎的人工智能领域。它有各种各样的应用:自动驾驶汽车，人脸识别，增强现实，…
在这篇文章中，你将学习如何建立一个深度学习图像分类模型，该模型能够在的 10 个步骤中检测出图像中存在哪些对象。
完整的代码可以在共享的 google collab 中找到，所以你可以在阅读文章的同时轻松地跟着编码。
读完这本指南，你会知道以下事情:
- 如何建立一个为深度学习模型设计的编码环境？
- 如何连接流行的影像分类数据集(Pascal VOC)
- 如何使用 Keras & Tensorflow 的组合创建深度学习卷积神经网络
- 如何使用数据生成器高效地训练深度学习模型
- 如何评估数据生成器的性能
步骤 1:设置环境
请查看谷歌协作获取所需的软件包。
从零开始构建深度学习卷积网络需要巨大的计算能力。普通的笔记本电脑不具备处理这些请求的能力。
幸运的是，谷歌来拯救我们了！他们已经开发了一个在线 python 笔记本，给用户免费的计算能力。
您可以通过在笔记本电脑设置中选择 GPU 选项来启用计算能力功能。
步骤 2:导入数据
我们将使用 Pascal VOC 图像数据集用于我们的深度学习模型。
Pascal VOC 数据集是一个图像数据集，在 Kaggle 上的计算机视觉竞赛中非常受欢迎。
使用 Wget 包下载数据集。这个包获取数据并下载到你当前的工作目录。
import tarfile!wget -nc http://host.robots.ox.ac.uk/pascal/VOC/voc2009/VOCtrainval_11-May-2009.tar
最后一步，打开 tarfile 并提取它。
tf = tarfile.open("/content/VOCtrainval_11-May-2009.tar")tf.extractall()
干得好！现在，您已经成功地加载并提取了数据集。
图 1: VOC 数据集结构
步骤 3:加载数据
当前的数据结构对于构建深度学习卷积模型不是最优的。
因此，需要将数据转换成更可行的格式。
您提取的 Pascal VOC 数据集应该包含以下两个文件夹:
- 注释:该文件夹包含所有关于图像标签的信息。
- JPEGImages:该文件夹包含所有原始图像
创建两个列表:
- 文件名:在这个列表中，你保存所有图片的文件名。例如“2208–001068 . JPEG”
- 分类:在这个列表中，你保存了所有的分类标签。例如“自行车、沙发”
directory_annotations = '/content/VOCdevkit/VOC2009/Annotations'filenames = []
classification = []
遍历注释目录，提取文件名和标签，并将其添加到各自的列表中。
for xml_file in os.listdir(directory_annotations): # Save image for classification and their class label if os.path.isfile(xml_file):
xml_tree = ET.parse(xml_file)
root = xml_tree.getroot()
imgname = root.find('filename').text.strip('.jpg')
labels = []
for obj in root.findall('object'):
label = obj.find('name').text
labels.append(label) filenames.append(imgname)
classification.append(labels)
步骤 4:预处理
在这一步中，您必须对数据进行预处理:
- 在训练和测试集中拆分文件名和它们各自的分类。
label_filenames_temp = os.listdir(directory_annotations)
filenames = []for lbl in label_filenames_temp:
filenames.append(lbl.split('.')[0])filecount = len(filenames)indexes = []for index in range(filecount):
indexes.append(index)training_indexes = indexes[:int(filecount*0.7)]
validation_indexes = indexes[int(filecount*0.7):int(filecount*0.9)]
testing_indexes = indexes[int(filecount*0.9):]
- 输出标签需要转换成数值，因为当输入和输出变量是数字时，深度学习网络表现得更好。
directory_images = '/content/VOCdevkit/VOC2009/JPEGImages'directory_annotations = '/content/VOCdevkit/VOC2009/Annotations'labelnames = preprocessing.LabelEncoder()labelnames.fit(["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"])
- 图像大小调整为 224，224，3 格式。在基于 VGG16 模型架构构建深度学习网络时，文献综述对此提出了建议。(西蒙扬&齐瑟曼，2014 年)
def generate_from_xml(filename):label = np.zeros((20), dtype = 'float32')tree = ET.parse(os.path.join(directory_annotations, filename + ".xml"))raw_image = cv2.imread(os.path.join(directory_images, filename + ".jpg"))res_img = cv2.resize(raw_image, (224,224)) for elems in tree.iter():
if elems.tag == "object":
name = elems.find("name").text
labelnr = labelnames.transform([name])[0]
label[labelnr] = 1return label, res_img
第 5 步:数据生成器
在巨大的数据集上训练模型需要大量的 ram 内存。
如果你像我一样，没有超级计算机，你必须使用数据生成器。
数据生成器将小批量的数据提供给模型。这允许我们在没有大量内存的情况下训练我们的模型。
使用大数据集时，最好使用数据生成器(而不是购买更多的 ram 内存)。数据生成器的细节超出了本文的范围，但是如果您感兴趣的话，可以查看下面的链接。
在下一个代码块中，创建一个 datagenerator 类实例，并调用它两次:
- 一次用于训练集
- 一次用于验证集
步骤 6:创建我们的模型
在此步骤中，您将构建分类卷积神经网络的架构。
模型架构基于流行的 VGG-16 架构。这是一个总共有 13 个卷积层的 CNN(CFR。图 1)。
下面的代码块表明您将按顺序构建模型。这意味着你会一层又一层。
model = Sequential()
你增加两个卷积层。
在卷积层，对图像应用多个滤波器以提取不同的特征。
给出的参数:
-
Input-shape:给定图像的形状应为(224，224，3)。
-
Filters:卷积层将学习的过滤器数量。
-
Kernel_size:指定 2D 卷积窗口的宽度和高度。
-填充:指定“相同”可确保卷积后空间维度相同。
-激活:这更多的是一个方便的论点。这里，我们指定哪个激活函数将在卷积层之后被应用。我们将应用 ReLU 激活功能。稍后将详细介绍。
model.add(Conv2D(input_shape=(224,224,3),filters=64,kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=64,kernel_size=(3,3),padding="same", activation="relu"))
接下来，添加 1 个 maxpool 层。
池用于通过减少前一卷积层输出中的像素数量来降低图像的维数。
- Pool_size= 2，2–>这是一个“矩阵”,它将检查输出并从中获取最大值
-跨距= 2，2–>池矩阵沿 x 和 y 轴移动的增量。
model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
我们继续向我们的深度学习网络添加层。应用如上所述的相同逻辑。
model.add(Conv2D(filters=128, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=128, kernel_size=(3,3),padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=256, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=256, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=256, kernel_size=(3,3),padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(Conv2D(filters=512, kernel_size=(3,3),padding="same", activation="relu"))model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))
现在卷积的基础已经建立了。为了能够产生一个预测，你必须使卷积基的输出变平。
model.add(Flatten())
添加密集层。密集层将卷积基底的输出馈送给它的神经元。
参数:
-单位:神经元的数量
-激活功能:Relu
Relu 激活功能加速了训练，因为梯度计算非常简单(0 或 1)。这也意味着负值不会传递或“激活”到下一层。这使得只有一定数量的神经元被激活，这使得计算变得有趣。
model.add(Dense(units=4096,activation="relu"))model.add(Dense(units=4096,activation="relu"))
您添加了一个 sigmoid 层，以便将前一层的输出转换为概率分布。sigmoid 是多标签分类的理想选择，因此我们使用 sigmoid 代替 softmax 激活。
由 sigmoid 产生的概率是独立的，并且不局限于总和为 1。这在具有多个输出标签的分类中至关重要。
您将单位参数设置为 20，因为我们有 20 个可能的类。
model.add(Dense(units=20, activation="sigmoid"))
步骤 7:损失函数和优化器
在步骤 7 中，您必须编译模型。您使用 RMSprop optimier 来达到全局最小值。你设置学习率为 0.001。
RMSprop ，均方根 prop，是一个未发表的优化算法，但很受机器学习从业者的欢迎。它减少了垂直方向的波动，同时加快了水平方向的学习。这使得我们的模型更快地收敛到全局最小值。与常规梯度下降算法的主要区别在于梯度的计算方式。梯度的计算公式如下图所示。
你设置二元交叉熵损失作为你的损失函数。
建议将此损失函数用于多标签分类，因为属于某个类别的每个元素不应受到另一个类别的决策的影响。
model.compile(optimizer= keras.optimizers.RMSprop(lr=0.001), loss='binary_crossentropy',metrics=['accuracy'])model.summary()
第八步:模型训练
一旦模型性能在保留数据集上停止改善，就可以使用 earlystopping 方法来停止定型。
通过这种方式，您可以在监控过度拟合的同时自动获得完美的时期数。
你给提前停止的人下达指令，寻求验证损失的最小值。
早期停止方法仅在没有检测到进一步改善时停止训练。
但是，最后一个纪元不一定是性能最好的纪元。
因此，您也可以使用模型检查点方法。这将保存在基于验证损失的训练期间观察到的最佳模型。
filepath = "/content/drive/My Drive/MYCNN/CNN1505_v1.h5"earlyStopping = EarlyStopping(monitor='val_loss', verbose=0, mode='min', patience = 4)mcp_save = ModelCheckpoint(filepath, save_best_only=True, monitor='val_loss', mode='min')
现在，你将开始训练我们的深度学习神经网络。我们使用 keras 的 fit 生成器批量加载数据。这是必要的，因为我们的整个训练集不适合我们的内存。
您可以设置以下参数:
- 使用多重处理:是否使用基于进程的线程
- Workers:并行生成批处理的线程数。
history = model.fit_generator(generator=training_generator,
validation_data=val_generator,
use_multiprocessing=True,
workers=6,
epochs = 20,
callbacks=[earlyStopping, mcp_save])
当我们的培训结束后，您可以看到我们的培训和验证结果。绘制了两个指标:
- 模型精度
- 模型损失
步骤 9:验证我们的模型
你可以看到模型很快从第一个时期的巨大训练损失收敛到更低的数字。
这种快速学习速率是由于所选优化器(RMS prop)的性质，它加快了收敛速度。
当该度量在四个时期内没有改进时，训练过程挑选具有最低验证损失的模型。
df = pd.DataFrame(history.history)
print(history.history.keys())# summarize history for accuracyplt.plot(history.history['accuracy'])plt.plot(history.history['val_accuracy'])plt.title('model accuracy')plt.ylabel('accuracy')plt.xlabel('epoch')plt.legend(['train', 'test'], loc='upper left')plt.show()# summarize history for lossplt.plot(history.history['loss'])plt.plot(history.history['val_loss'])plt.title('model loss')plt.ylabel('loss')plt.xlabel('epoch')plt.legend(['train', 'test'], loc='upper left')plt.show()
步骤 10:测试我们的模型性能
在我们的最后一步，我们在看不见的数据(测试集)上测试我们的模型性能。
打造自己的深度学习机器——你需要知道的
深度学习需要大量的计算，所以为了有效地训练深度学习模型，大多数人使用像 AWS 这样的云，或者在他们自己购买的硬件上进行训练。
我决定建立自己的机器，因为我在云上花了很多钱，并希望节省成本。介绍…战争机器！Warmachine 是一台非常有能力的机器，旨在承担从深度学习到强化学习的高级人工智能任务。Warmachine 是使用货架硬件的消费者构建的。
点击下面的链接，在电脑零件挑选处查看 Warmachine 的零件。
编辑描述
pcpartpicker.com](https://pcpartpicker.com/user/learnedvector/saved/#view=f4c8Jx)
在这篇文章中，我将给出如何正确构建人工智能训练机器的技巧。最后，我将讨论构建自己的平台和使用云的优缺点。
如果你想看这个的视频版本，看看这个…
零件
所以 Warmachine 主要是为了解决深度学习和强化学习问题而建立的。我想要一台具有 4 个 GPU 的大量内核的机器，这样我就可以快速迭代训练我的机器学习模型。我的最终目标是最终拥有一台类似于 lambda quad 的机器，但不用支付 Lambda Quad 的价格。
用于 4 GPU RTX 2080 TI 机器的 Lambda Lab Quad
当 Warmachine 完成时，我将花费大约 7000 美元，比 Lambda Labs 便宜 4000 美元！
深度学习装备需要特定的组件，所以比平时更难在网上找到关于如何构建这些东西的可靠资源。让我们来看看你需要知道的所有知识，以构建你自己的深度学习机器。
国家政治保卫局。参见 OGPU
训练深度学习模型的核心是 GPU。GPU 在计算深度学习算法方面速度超快，因为与拥有非常少量复杂计算核心的 CPU 不同，GPU 拥有数百或数千个简单核心，在矩阵乘法方面超高效。GPU 用于深度学习最可靠的品牌是英伟达。大多数深度学习框架完全支持英伟达的 CUDA SDK，这是一个与他们的 GPU 接口的软件库。
当选择一个 GPU 时，为了让你的钱发挥最大的作用，你需要有张量核的东西。张量核是一种执行专门矩阵数学的处理核，使您能够使用半精度或混合精度训练模型。
这允许更有效地使用 GPU 内存，为更大的批量、更快的训练和更大的模型打开了大门。张量核可以在英伟达 RTX GPU 模型中找到。GPU 的内存需求取决于您计划训练的模型类型。
如果你只打算为嵌入式设备训练超小型模型，你可以用内存更少的 GPU。如果你计划训练更大的模型，比如 NLP 领域的 GPT，我会得到尽可能多的内存。
拥有更多的 GPU 内存为…你猜对了…更大的批量，更快的训练，更大的模型。如果你打算做一个多 GPU 设置，你需要使用吹风机式风扇或更昂贵的液冷选项。
你需要吹风机式的风扇，因为它们是为了将热量排出机箱，当你有多个 GPU 运行时，这是必要的。如果您没有鼓风机式风扇，您的系统可能会过热，并可能损坏您的硬件。
对于 Warmachine，我选择了华硕的 Nvidia RTX 2080 TI Turbo。它有 11GB 的 VRam 和鼓风机式风扇，可以在多 GPU 设置上实现更好的加热管理。我计划再买 3 个 GPU 来完成我的设置。
中央处理器
CPU 主要用于深度学习中的数据加载。CPU 上更多的线程意味着您可以并行加载更多的数据，以输入到您的模型中进行训练。如果你在大批量上训练，这是有用的，所以 GPU 不必等待 CPU 太长时间来加载数据。
如果你打算做强化学习问题，CPU 是很重要的，因为大部分计算将在你的学习环境中完成，而这很可能是在 CPU 上完成的。如果你使用强化学习的大型神经网络，那么 GPU 肯定有助于加快训练速度。
如果你只打算只做深度学习，那么确保你的 CPU 兼容你计划拥有的任何数量的 GPU。
选择 CPU 时，问问自己，这些问题…
- 你打算进行强化学习吗？如果你想要更快的训练，那么选择一个在基准测试中表现良好的高端 CPU。
- 你是不是只想做深度学习？然后，您可以使用更便宜的 CPU，但是更多的线程将有助于数据加载。
- 你计划有一个多 GPU 设置吗？然后确保你的 CPU 支持你想要的 GPU 数量。
Warmachine 将用于深度学习和强化学习，因此它配备了一个英特尔 i9–10920 x，它有 12 个内核和 24 个线程。它的时钟速度高达 4.8 GHZ，支持 4 个 GPU。我选择了英特尔，但是阅读了很多使用 AMD 芯片的人的成功故事，这对你的钱来说是一个更大的冲击。英特尔 i9–10920 x 是一款非常强大的 CPU，可以进行深度学习和强化学习，因此非常适合我的需求。
随机存取存储
一个很大的错误是认为你需要具有高时钟频率的最快的 RAM。高 Ram 时钟速度是一个营销噱头，最好的解释是由莱纳斯技术提示。更高的时钟频率在训练期间将显示出微不足道的改善，所以你的钱最好花在别的地方。
真正重要的是 RAM 上的内存量。你应该努力让你的内存至少和你的 GPU 内存一样多。我用的是 corsair 品牌，它的时钟速度为 2666Mhz，内存为 32 GB。当 Warmachine 完成时，我计划将它的内存增加到 128 GB，因为我特别喜欢这样。
母板
选择主板时，确保它有足够的 PCIe 插槽来容纳你想要的 GPU 数量。此外，确保 PCIe 插槽有足够的空间来容纳 GPU。通常，一个 GPU 将占用 2 个 PCIe 插槽的空间。此外，请确保主板与您的 CPU 和 RAM 兼容。
Warmachine 配备了一台华硕 WS X299 SAGE。这款主板支持 4 个 GPU。我唯一希望它有机载 wifi，但我使用以太网电缆连接，所以这不是太大的问题。
储存；储备
如果你想优化你的数据加载速度，你需要更快的存储，如固态硬盘。固态硬盘比标准硬盘更贵，因此为操作系统购买一个较小的固态硬盘，然后购买一个标准硬盘作为长期存储数据和模型的第二个驱动器是非常有用的。
训练的时候可以把感兴趣的数据转移到你的 SSD 上，加快数据加载速度。Warmachine 配备了 NVME 三星 970 Evo，操作系统存储空间为 1 TB。对于第二个驱动器，它有 8TB 存储的希捷 Exos 企业硬盘。
程序存储单元(Program Storage Unit)
对于电源单元，你需要有足够的功率来支持你的整个系统。一个很好的经验法则是将 CPU 和 GPU 所需的功率乘以 110%。
确定您的 PSU 有足够的 PCIe 连接器用于您的系统。Warmachine 配备了一个玫瑰将，1600 瓦 PSU。尽管我现在的设置不需要所有这些，但当它完成时，我会需要这么多，所以我继续购买了它以备将来使用。
冷却
你肯定需要一个 CPU 冷却器。为了降低风扇噪音，可以使用水冷装置。如果你有预算，你也可以看看液体冷却你的 GPU。这将构成一个超级安静的系统。如果你想坚持用空气冷却你的 GPU，确保你有鼓风机式的冷却，如果你计划有一个多 GPU 设置。Warmachine 目前配备了海盗船 H1 15i 专业这是一个 CPU 水冷却器。对于 GPU 来说，这只是股票鼓风机式的。
情况
当你选择一个箱子时，你可以选择任何你想要的东西，只要你的零件合适。我会建议买一个通风良好的箱子，因为我非常谨慎。我去了一个海盗船航空 540 ATX 中塔案件 Warmachine。它有充足的气流，看起来很酷，这和 Lambda 实验室使用的情况一样，为什么不呢？
确保你的零件合适
在装配钻机时，使用 PC 零件拾取器。它有一个功能，它会检查部件兼容性，这样你就不会完全搞砸你的构建。虽然它并不完美，因为它提醒我，我的零件并不适合我的情况，但一切都非常适合，所以在建造时将它用作指南针。
云与您自己的硬件
现在你们很多人可能会好奇，为什么要造我自己的机器？我就不能用云吗？是的，是的，你可以。但是建造你自己的机器也有好处，包括长期的成本节约。
这里有 3 个理由说明为什么建立自己的深度学习平台可能是值得的。
1.节约成本。如果你经常使用你的 GPU 进行训练，那么从长远来看，建造一台机器实际上可以为你省钱！如果你租一辆 v100，那大约是每小时 3 美元或者一个月 2100 美元！你可以用那个价格建造你自己的机器…并且永远保持下去！
2.你自己的硬件其实比云还快。这是因为由于虚拟化，云在实例和 GPU 之间的 IO 很慢。Bizon-Tech 做了一个实验来比较云和你自己的硬件，他们发现你可以买到更便宜的消费硬件。
您可以在这里看到，1080 Ti 接近 V100 的性能
3.拥有自己的钻机就像一台生产力机器，可以做任何你想做的事情。我可以用它在最大设置下玩游戏，为大家制作很酷的视频，并在 chrome 上打开 10 多个标签页！
**奖励点:**这里有一个奖励点。我喜欢不用担心每轮模特训练要花多少钱。我觉得当我必须为每轮训练付费时，我总是不愿意尝试，因为我知道这会让我花钱。我认为拥有自己的机器鼓励我继续尝试，从而帮助我比使用云更快地完善深度学习的艺术。现在有其他免费的 GPU 支持选项，如 Google Colab 或 Kaggle 内核，但你可以训练的时间有限，这缩小了我对模型和要解决的问题的选择。不过，我强烈推荐大多数刚开始深度学习的人使用它们。
结论
原来如此！这是一个关于如何构建自己的深度学习机器的简短指南。如果你想要一份更详细的指南，我推荐你去看看蒂姆·德特默斯指南。当 Warmachine 完成后，它将花费我大约 7k 美元，这仍然比 Lambda Labs 可比的机器 11K 美元便宜！对我来说，这是一个很大的省钱之道，完全值得你自己造一台机器。
✍🏽想要更多内容？查看我的博客https://www.michaelphi.com
📺喜欢看基于项目的视频？查看我的 Youtube ！
🥇注册我的 电子邮件简讯 ，了解最新文章和视频！
用变形金刚构建你自己的机器翻译服务
使用 Transformers 库中可用的最新赫尔辛基 NLP 模型创建标准化的机器翻译服务
企业环境中需要机器翻译。全球公司能够用各种不同的语言与世界各地的人们共享文档、笔记、电子邮件和其他文本，这一点至关重要。
可以说，更重要的是需要在全球化的同时使信息民主化。不管你说什么语言，你都应该和那些主要语言被广泛使用的人一样，可以访问相同的开源出版物、医疗保健信息、工具和知识，比如英语。
我用 powerpoint 做了这个。太恐怖了。
幸运的是，机器翻译已经存在了一段时间——我们中的许多人已经使用谷歌翻译来确认在线内容，或者只是为了听起来聪明和世故。如果你的翻译需要规模，Azure、AWS 和 GCP 有每百万字符 10 美元的可消费 API，支持千个语言对(一个语言对由源语言和目标语言组成)。
在开源领域，已经有大量跨多种语言的机器学习工作，人们早就能够训练自己的机器翻译模型。然而，就建模方法和支持的语言数量而言，大多数方法似乎是不同的(根据我自己天真的评估)。
最近， Huggingface 发布了来自赫尔辛基大学的超过1000 名预先训练好的语言模型。对于任何希望创建自己的 AWS 或 Google translate API 的人来说，这从未如此简单。所以，我想我应该利用别人的辛勤工作。这在功能上相当于“让我们把机器学习包装在一个 flask API 和 docker 映像中”，但是，不管怎样，这很有趣。让我们开始吧。
用变压器进行机器翻译
Huggingface 做了一件令人难以置信的工作，用一个简单的 Python API 为像我这样的复制+粘贴编码者提供了 SOTA(最先进的)模型。要在本地翻译文本，你只需要pip install transformers然后使用下面来自变形金刚文档的片段。
这将下载所需的模型并翻译源文本->目标文本。有了这种格式支持的语言的绝对数量，把它扔进一个 dockerized flask 应用程序并结束它是非常容易的，但是我们确实有一点额外的工作要做…
请随意跟进 git 回购。
下载模型
当您初始化上面的模型时，如果您本地没有所需的文件，transformers 会下载它们。这对于本地使用来说是很棒的，但是在使用 docker 容器时就不是这样了。因为容器存储是短暂的，每次我们退出容器时，我们都会丢失所有的模型，并且需要在下一次重新下载它们。
为了避免这种情况，我们可以单独处理模型下载，并将模型作为一个卷挂载。这也给了我们更多的控制语言，我们希望我们的服务从一开始就支持。Huggingface 保存了 S3 所有必要的文件，所以我们可以将它标准化…
然后创建一个简单的命令行实用程序来下载它们:
酷毙了。现在我们可以用一个命令下载我们需要的模型。以下面的日语->英语为例。
python download_models.py --source ja --target en
默认情况下，这会将它们下载到一个名为data的目录中，所以只需检查以确保该目录存在。
Python 中的动态语言翻译
现在我们有了一个更好的方法来管理我们支持的语言，让我们来看看问题的实质，然后是一个类和相关的方法来管理我们的翻译。
这里我们需要几个函数:
- 翻译给定源语言和目标语言的文本(duh)
- 将我们没有的模型加载并管理到内存中(我使用一个简单的字典)
- 获取支持的语言(我们为此应用下载了哪些语言？)
由于 transformers 的用户友好性，几乎不需要任何时间就可以将这种功能封装到一个轻量级的类中供我们使用。
这个类用我们用来保存模型的路径初始化，并自己处理其余的部分。如果我们收到一个翻译请求，但是我们的内存中没有这个模型，那么load_models就会被调用来把它加载到self.models字典中。这将检查我们data目录以查看我们是否有该模型，并返回一条消息让我们知道我们是否有。
使其成为 API
我们现在需要做的就是将它包装在 flask 中，这样我们就可以对它进行 HTTP 调用。
要使用它，只需运行python app.py，然后调用服务。要检查它是否工作，你可以curl localhost:5000或者使用更复杂的东西，比如 Postman。我在这里使用 flask 服务器，但是您会希望一个生产 web 服务器在任何实际的地方使用它。
用 Docker 图像包装它
现在，我们的应用程序可以与基本 Python 一起工作，我们希望它可以与 Docker 或 docker-compose 一起工作，这样我们就可以根据需要扩展它。我们实际使用的Dockerfile非常简单。我们只需要确保在附加了卷的情况下运行服务，这样它就可以访问数据了。
我通常会使用较小的基本映像，但老实说，我不喜欢调试:
构建和运行命令:
docker build -t machine-translation-service .
docker run -p 5000:5000 -v $(pwd)/data:/app/data -it machine-translation-service
同样，我们可以通过调用服务来测试我们的端点。如果我已经下载了一个像 en -> fr 这样的语言路径，那么我应该能够使用curl进行如下 API 调用:
curl --location --request POST '[http://localhost:5000/translate'](http://localhost:5000/translate') \
--header 'Content-Type: application/json' \
--data-raw '{
"text":"hello",
"source":"en",
"target":"fr"
}'
现在是 docker-compose
我将我的服务包装在一个小 flask API 中，甚至“正确地”使它成为一个 Docker 容器，可以以可复制的方式扩展。但是，我想分享一下这种方法的一些问题。
这些翻译模型相当大(每一个都有 300MB)。即使数据/模型是单独下载的，我们仍然需要在内存中加载我们想要支持的每一个语言对——这对于一个容器来说很快就会失去控制。
因此，为什么不创建一个可配置的映像，我们可以使用 docker-compose 为每个服务创建一个容器呢？这样，每个语言对就有一个服务，并且每个语言对都可以随着需求的增加而单独扩展。然后，我们可以编写一个单独的、公开的 API，将请求传递给网络中的所有容器。
免责声明:在这一点上，我只是开始边走边编，我绝不相信这是最佳的方法——但我想看看我能走多远。
首先，我稍微修改了一下目录。为了验证这一点，您可以探索我创建的 git 上的分支:
proxy的目的是将请求重定向到每个运转起来的机器翻译服务。这将是唯一暴露的端点。我为支持 en - > fr 翻译的服务做了一个快速的docker-compose文件。
每个翻译服务都有相同的 env 变量(我可能只需要做一个.env文件)，相同的命令，以及包含我们模型的相同的卷。可能有一个更好的方法，用yaml自动化或类似的东西来扩展这个，但是我还没有做到。
之后，我只是对我的代理的/translate端点做了一些难看的工作，以便按需构造所请求的服务端点。当用户向这个公开的服务发出请求时，它将向只能从该网络内部到达的其他容器发出另一个请求。
我们所要做的就是构建基础映像。
cd translation_base
docker build -t translation_base
然后启动服务。
docker-compose up
还有吧嗒吧嗒吧嗒。下面是使用 postman 的输出截图。
最后是 Kubernetes
这里不打算深入探讨，但合乎逻辑的下一步是将它带到 kubernetes 进行真实的缩放。一个简单的起点是使用kompose CLI 将 docker-compose 转换成 kubernetes YAML。在 macOS 上:
$brew install kompose
$kompose convertINFO Kubernetes file "translation-proxy-service.yaml" created
INFO Kubernetes file "en-fr-deployment.yaml" created
INFO Kubernetes file "en-fr-claim0-persistentvolumeclaim.yaml" created
INFO Kubernetes file "fr-en-deployment.yaml" created
INFO Kubernetes file "fr-en-claim0-persistentvolumeclaim.yaml" created
INFO Kubernetes file "translation-proxy-deployment.yaml" created
这应该会创建一些将服务和部署扩展到 K8s 所需的 YAML 文件。
下面是 fr-en 服务的示例部署:
一旦配置好 kubernetes 集群，您就可以kubectl apply -f $FILENAME创建您的服务、部署和持久卷声明。
当然，还有更多的工作要做，还有更多的 kubernetes 对象要创建，但我想在这里为任何真正希望扩展类似内容的人提供一个简单的起点。
结论
我希望 Huggingface 继续构建的工具(以及专门的研究人员训练的模型)继续提供智能机器学习的公平途径。开放机器翻译的努力不仅有助于研究领域，而且使全世界能够访问用单一语言编写的极其重要的资源。
我不知道自己托管这些庞大的模型是否比使用 AWS 或谷歌翻译 API 便宜一半，我也没有探索过质量。但这是一个超级有趣的话题，希望能给你提供一些见解，让你知道如何利用唾手可得的数以千计的 SOTA 机器学习模型。
用 Python 从头开始构建自己的神经网络
了解神经网络的基础知识
娜塔莎·康奈尔在 Unsplash 上的照片
有许多 python 库可以用来构建和训练神经网络，如 Tensorflow 和 Keras。但要真正理解神经网络，我们需要了解它的基本结构，并能够建立和训练我们自己的网络。
与常规的机器学习算法相比，神经网络可以更好地学习数据。事实上，神经网络算法可以解释为一堆线性回归，其中每个节点都是一个线性回归的输出。
神经网络包括:
- 一个输入层， x
- 任意数量的隐藏层
- 一个输出层， y`
在下图中，输入层有 3 个节点，下一层(隐藏)有 4 个节点，输出层有 2 个节点。输入层不包括在层数中，因此它是一个 2 层网络。
两层神经网络结构
两层中的每个节点都是一个线性回归的输出。在每一层，在执行线性回归之后，这些值被馈送到激活函数。
神经网络的基本算法应该是这样的。
for n epochs:
1\. forward_propagation() #predicting output
2\. backward_propagation() #updating parameters according to loss
函数名暗示了算法的基本结构。在本文中，我们将建立一个 2 层神经网络。
让我们看看我们将使用的常见命名约定。
Z是线性向前值，即Z = W.X，A是节点激活，即A = sigmoid(Z)。我们将在网络中使用 sigmoid 激活函数。
1.初始化参数
首先，我们初始化神经网络的权重和层大小。
我们将变量定义如下:
[num_samples, n_x]:输入的形状n_x:输入 X 的特征数n_h:隐藏层节点n_y:每个样本的目标值数量
让我们根据输入和输出值以及我们选择的隐藏层大小来初始化层大小。
然后，我们基于层大小初始化权重。
- 在上图中，对于第一层，我们需要定义权重，以便能够计算 4 个
(n_h)线性回归，下一层中的每个节点一个。 - 所以第一层中的权重，
W1应该是(3,4)或(n_x,n_h)(对三个(n_x)输入特征的四个(n_h)线性回归)。
用这个类比，你可以很容易地猜出上面网络中权重W2的形状。
让我们定义初始化权重的函数。
2.正向传播
正向传播由一组线性回归和每层的非线性激活函数组成。
我们将使用 sigmoid 函数作为神经网络的激活函数。
一旦你得到正确的权重，前向传播是非常简单的。
输出= sigmoid((W2 * sigmoid(W1 * X+B1))+B2)
让我们定义我们的前向函数。
正向传播
3.反向传播
这是棘手的部分。反向传播相应地在损失最小化的方向上更新权重参数。我们将使用均方差(MSE) 损失来评估我们的网络。这个计算看起来很复杂，但实际上很简单。
损失函数的加权导数和 sigmoid 导数
这很简单，对吧？现在，让我们定义反向传播的函数。我们将计算梯度，并在向后的步骤中更新权重。
反向传播
4.培养
训练中的一个时期包括一个向前和向后传播步骤。
我们将使用来自sklearn.datasets模块的乳腺癌数据集。该数据集有 30 个特征和 569 个样本，并用隐藏层中的 4 个节点训练我们的网络 1000 个时期。
比较 10 个随机样本的预测值和输出值。
看起来我们的网络工作得非常好！
请注意，预测值与实际值略有不同。这是可取的，因为这意味着模型不会过度拟合，并且会更好地概括。
结论
在我们的神经网络中，我们在激活层使用了 sigmoid 函数。但是，根据问题的类型，还有其他的激活功能可能会有用。事实上，激活函数可以是你选择的任何函数，如果你认为这个函数非常适合我们试图解决的特定问题。但是神经网络中常用的激活函数可以在这里找到。
构建您自己的开放式仪表板来跟踪新冠肺炎
跟踪对您自己的 RaspberryPi 有影响的派生指标
我们生活在一个相对前所未有的时代，因为今天活着的人(除了 1918 年左右的少数人)没有一个在他们生活的任何时候经历过疫情。这意味着，与任何其他情况相比，我们更有理由收集尽可能多的数据，以便做出更明智的决策。其中一部分是通过密切监测新病例、死亡和康复的数量，以及许多重要的指标(病毒扩散率、增长率、死亡率、达到 ICU 满负荷前的估计天数等)。)可以从那些数字中推断出来。
自从疫情开始以来，我已经看到世界各地的工程师和数据科学家做出了令人印象深刻的努力，提供可以帮助解决问题的工具。从 3D 打印的面罩，到 RaspberryPi+Arduino 驱动的呼吸机，到构建快速管道来处理大量基因组数据或计算病毒‘蛋白质’的结构，到构建 API 和仪表板来帮助共享数据，在疫情期间，各种类型的工程师都面临着大量挑战。
我将尝试再写几篇关于工程师和数据科学家如何在此时积极帮助世界的文章，从如何构建一个定制的仪表板开始，该仪表板在可用时自动提取关于传染的新数据，计算任何所需的派生指标，并将数据显示在 Grafana 仪表板上。收集尽可能多的关于这种疫情的准确数据对于有效地抗击它至关重要，同样至关重要的是计算并向最广泛的公众显示正确的衍生指标，以便更好地理解(或评估)政府的决策，或者比较世界上不同政策的不同国家如何产生不同的结果，或者甚至某个国家的病例数在实施某些措施前后如何变化。
我们将使用 PostgreSQL 存储数据(但是任何关系数据库都可以)，使用 Grafana 显示数据，使用 platypush 填充数据并自动更新数据。不久前，我给写了一篇文章，讲述如何用这些工具构建你的定制仪表板，以存储和显示任何类型的数据(从你浴室中的湿度传感器到你一天中的位置)。可以参考一下，了解一下这些工具是如何配合使用的，以及如何入门。
问题 1:数据可用性和质量
新冠肺炎统计的第一个问题是公布数据的可用性和质量。首先，并不是世界上所有的国家都同样努力让尽可能多的人接受检测。第二，并非所有国家在报告所有数字时都具有相同的透明度或可靠性——包括恢复情况、死亡人数和进行检测的次数。在紧急情况下，可用数据的质量远非完美，这是完全可以预料的。虽然我们作为个人对数据的质量没有太多的控制，但我们仍然可以推断出有趣的信息，并根据手头的不完整数据建立模型。例如，可以查看每个人口单位进行测试次数最多的国家的数据，以更好地了解真实的死亡率和住院率。有可能将病毒扩散的时间线与政府采取措施的时间线重叠，以推断这些措施如何影响了疫情的扩散。考虑到该国现有的重症监护室床位数量，可以推断按照目前的增长速度，卫生系统达到满负荷需要多少天。考虑到这些模型是基于不完整的数据，所有这些信息都应该有所保留，但是根据不完整的数据做出的决策总是比没有数据的决策要好。
问题 2:数据可视化
像疫情这样的现象按照相对简单的指数定律传播。一般来说，时间 t 的增长率定义为 t 日确诊病例数与前一日 t-1 确诊病例数之比:
如果增长率保持不变(如果没有采取控制措施，情况大致如此)，那么只需给出初始病例数和增长率，就可以估计第 t 天的病例数:
如果你关注过这一时期的任何新闻，你可能会经常听说另一个数字——R0，也被称为基本再生数。这是每个感染者携带病原体时感染的平均人数。增长率 γ 和 R0 相互关系如下:
其中 w(τ) 为疾病的 世代时间分布 (基本上是描述一个传播链中连续感染之间时间分布的概率密度函数)。如果我们有一个好的分布规律和关于增长率的准确数据，我们可以很好地估计疾病将传播多少，以及在采取一些行动后它的传播如何变化。
虽然数学定律相对简单，但我们很难理解这种现象究竟是如何发生的。在我们的日常经验中，我们非常习惯于涉及线性定律的现象。如果你把某样东西翻倍或减半，那么其他东西可能会翻倍或减半，或者增加/减少 4 倍，等等。对于我们来说，处理指数定律的现象通常更难描绘。这个术语在媒体上经常被滥用，这并没有什么帮助:大多数时候，你听到一个经济体、一个公司或一个行业的“指数增长”，你实际上听到的是一个任意大幅度的线性或多项式增长。
为了描述指数增长的真正含义，假设你的田里长了一些杂草，如果不加限制，它每天都会比前一天扩大一倍(换句话说， γ=2 )。假设这种杂草如果任其自由生长，需要 60 天才能覆盖整个田地。如果你应用上面的公式，你会发现在第 59 天，杂草只覆盖了一半的田地，在第 54 天，杂草只覆盖了大约 1.5%的田地。
指数增长现象的反直觉性意味着，在做决定时，我们不能只依靠我们的本能或共同的经验。这确实需要以正确的方式可视化正确的数据，以了解是否、何时以及如何控制疫情。以正确的方式看待数据也很重要。虽然你正处于指数增长曲线的中间，但仅仅通过观察线性范围内确诊病例的数量，很难判断增长有多“糟糕”。你只会注意到曲线增长了“很多”，但几个小数点的差异意味着在相对较短的时间框架内出现数十万或数百万的新确诊病例。对数标度给出了曲线实际增长多少的更好的图像，但它也能产生一种虚假的保证感。一条持续指数增长的曲线在对数标度上看起来像一条直线，所以你应该记住，一条在对数标度上持续增长甚至一点点的直线通常不是一个好兆头。
许多新的网站和仪表板出现在网络上，以跟踪这种疫情的传播，但尽管它们都在线性和对数标度上显示病例、恢复和死亡的累积数量方面做得相对较好，但它们缺乏一些派生指标的可视化，这些指标将真正有助于更好地掌握问题。例如，随着时间的推移，在某个国家对每单位人口进行了多少次测试，或者在给定的增长率和严重率下 ICU 床位达到满负荷需要多少天，或者死亡率/严重率如何随着被测试人口的比例而变化。这就是为什么我最终决定制作自己的开放式仪表板，以跟踪我希望跟踪的指标，按国家过滤，并且可以根据每个人的需求轻松定制。
问题 3: API 可用性
尽管已经有许多仪表板可以用来跟踪疾病的传播，但大多数仪表板都在后端呈现数据，没有公开任何 API。我个人非常喜欢 Worldometers 提供的数据质量和数量，它提供了许多其他仪表板上没有的数据(如每个国家人口的检测数量，住院病例数量等)。)，但是我前面提到的一些派生指标并不容易获得，另外，也没有为数据提供 API。对于 platypush 集成，我最终选择了 covid19api.com提供的数据，即使它没有提供 Worldometers 上可用的许多指标——我仍然用 Worldometers 上发布的每日数据手动填充数据库中缺失的指标。作为下一步，我计划为 Worldometers 数据开发一个刮刀，如果你知道谁已经完成了这项工作，请让我知道:)，对于那些开发这些仪表板的人，非常感谢你的工作，但也请确保公开一个 API，以便其他开发人员可以轻松地提取数据或将其集成到其他项目中。
设置环境
我们将使用三种工具来设置仪表板:
- PostgreSQL(但是任何其他关系数据库都可以)
- 格拉夫纳
- 鸭嘴兽
仪表板可以在任何电脑上运行，包括 RaspberryPi。如果你想了解更多关于这些解决方案的信息，请参考我之前关于 PostgreSQL+platypush+Grafana 的文章。
我假设您的系统上安装了 PostgreSQL 或另一个 RDBMS，以及 Grafana。如果您的系统上还没有安装 platypush，您可以通过 pip 轻松安装:
pip install platypush
还要安装并启动 Redis，platypush 将使用它作为后端来传递消息。
设置数据库:
initdb -D covid19
然后创建我们将用来管理统计数据的表和触发器:
基本思想是将新的非规范化行转储到tmp_covid19_data表，然后让触发器管理数据的规范化，而视图vcovid19将用于连接和计算我们想要的派生指标。
然后，您可以使用一个利用 platypush Covid19 插件的简单 Python 脚本来填充您想要跟踪的国家的所有历史数据:
最后，配置 Covid19 后端来自动提取您感兴趣的国家的数据，方法是将以下代码行添加到~/.config/platypush/config.yaml:
backend.covid19:
country:
- nl
- it
- us
- es
- gb
- cn
- fr
- ru
每当有这些国家的新数据时，platypush 就会触发一个[Covid19UpdateEvent](https://platypush.readthedocs.io/en/latest/platypush/events/covid19.html)。您可以用钩子捕获这个事件，并将新行存储在数据库中，但是您还可以做其他任何事情——发送通知、SMS 或设置任何类型的自动化。在~/.config/platypush/scripts下创建一个名为covid19.py的脚本(还要确保这个文件夹中有一个__init__.py文件，这样它就会被识别为一个包):
启动platypush服务。既然您已经获得了数据和更新数据的自动化，那么是时候去 Grafana 并创建一些面板来从vcovid19视图中提取和显示数据了。一些示例报告查询:
SELECT
report_date AS "time",
confirmed
FROM vcovid19
WHERE
country = '<country name>' AND
$__timeFilter(report_date)
ORDER BY 1
您可以将这些查询组合在一起，构建您喜欢的仪表板:
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
