2020 年云上的 Jupyter + Spark 入门
轻松组装由大数据集群支持的笔记本电脑
迪伦·诺尔特在 Unsplash 上的照片
2020 年是利用 Jupyter 和 Spark 集群深入研究大数据的大好时机。所有三大云提供商(Amazon Web Services、Microsoft Azure 和 Google Cloud)都配置了托管服务来运行集群，并预装了 Jupyter 和 Spark。随着大数据的爆炸式增长和低准入门槛(成本和工作量)，了解如何使用机器集群解决大数据问题正成为当今数据科学就业市场的一项必备技能。
在本文中，我将向您展示如何在 Google Cloud Dataproc 上使用 Jupyter 构建 Spark 集群。我们将回顾:
- 在 Dataproc 上配置 Spark 集群设置
- 为 Jupyter 和 Anaconda 配置集群
- 访问 Jupyter 笔记本
在 Dataproc 上配置 Spark 集群设置
Dataproc 是 Google Cloud 的托管服务，用于运行 Apache Spark 和 Apache Hadoop 集群。我们将使用 Dataproc 来创建和管理我们的 Spark 集群。在您的 Google 云平台用户控制台中，导航到 Dataproc 并点击“创建集群”。
您将进入“创建集群”页面，其中包含您的机器集群的设置。在本教程中，我们将对主节点和工作节点使用默认的机器类型 n1-standard-4。如果您想节省一些钱，我建议降级到 n1-standard-2，而不是 n1-standard-1，因为 1 vCPU 机器需要更长的时间来启动。
为 Jupyter 和 Anaconda 配置集群
这就是令人兴奋的地方。几年前，你必须编写一个自定义脚本来安装 Jupyter 和 Anaconda。今天，你可以通过点击几个按钮得到同样的结果。选中“组件网关”下的“启用对 web 界面的访问”并展开“高级选项”。
虽然是可选的，但是设置一个云存储分段存储桶。使用云存储桶可以将您的笔记本电脑保存在云中，并在您下次启动笔记本电脑时可用。
将机器的镜像设置为 1.5 (Debian 10、Hadoop 2.10、Spark 2.4)。根据我的经验，1.3 image 基于 Python 2，不能访问 Python 3 中开发的新工具。
这里最重要的部分是可选组件下的“选择组件”。下图显示了可用的选项。
最后，选中项目访问下的“允许 API 访问所有 Google 云服务”。这将允许您的集群访问其他 Google 云服务，如 BigQuery。
在可选组件中，我们看到了各种可用的组件。默认安装了 Spark(未列出)，我们将选中 Anaconda 和 Jupyter 笔记本，然后单击“Select”保存我们的选择。
回到“cluster settings”菜单，在启动集群之前，我们还有最后一个项目要设置。选中“计划删除”下的“按固定时间计划删除”。此选项确保您的群集在一段设定的时间后自行终止。Dataproc 根据集群保持运行的时间来计费。预设删除时间可以确保当我们忘记手动终止集群时，不会收到任何意外的账单。对于本教程，我们将删除时间设置为 2 小时。
访问 Jupyter 笔记本
就是这样！创建集群大约需要 3 到 10 分钟。一旦群集名称旁边的旋转图标变成绿点复选标记，请单击“web interfaces”选项卡和“Component gateway”下的“Jupyter”。如果 Jupyter 不可用，请确保您已按照上一节中的说明“启用对 web 界面的访问”并选择了可选组件。正如我们所看到的，我们在集群创建过程中选择的任何可选组件都将出现在 web interfaces 选项卡中。
迎接我们的是我们熟悉的 Jupyter 笔记本用户界面。点击“GCS”文件夹访问谷歌云存储桶。我们在该文件夹中上传或创建的任何文件都可以在我们之前在集群创建过程中设置的云桶中使用。
我们的笔记本电脑有 4 种不同的内核。他们都可以进入我们的星火星团。我喜欢使用“Python 3”笔记本，因为它可以访问与 Anaconda 和 PySpark 一起安装的所有数据科学包。
还有维奥拉。你现在有一个运行在 Spark 集群上的 Jupyter 笔记本了！我们可以用下面的代码检查笔记本，以确保所有内容都正确加载。
!scala -version import pandas as pd
import numpy as np
from pyspark.sql import SparkSessionspark = SparkSession.builder \
.appName('Jupyter BigQuery Storage')\
.config('spark.jars', 'gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar') \
.getOrCreate()table = "bigquery-public-data.wikipedia.pageviews_2020"
df = spark.read \
.format("bigquery") \
.option("table", table) \
.load()
df.printSchema()df_agg = df \
.select('wiki', 'views') \
.where("datehour = '2020-03-03'") \
.groupBy('wiki') \
.sum('views')
df_agg.show()
一旦你完成了你的分析，确保删除你的集群，以避免额外的费用！运行本教程中的集群 2 小时大约需要 1 美元。您可以使用Google Cloud Pricing Calculator并选择 Dataproc 服务来估算您的集群的成本。
结束语
随着大数据的兴起，对于数据科学家来说，学习如何在云上使用 Jupyter + Spark 非常重要。这样，我们可以水平扩展我们的计算资源，而不仅仅是垂直扩展。在本教程中，我们在 Google Cloud Dataproc 上构建了一个加载了 Jupyter 和 Anaconda 的 Spark 集群。现在，让我们开始处理大数据吧！
不知道去哪里找大数据练习？查看我以前的一篇文章，关于谷歌公共数据集上可用的万亿字节数据集:用谷歌公共数据集升级。
将 Jupyter 笔记本电脑连接到万亿字节的数据
towardsdatascience.com](/level-up-with-googles-public-datasets-5ffce0893ea0)
开始使用 Microsoft Excel
帮助您开始 Excel 之旅的 10 大命令
贾里德·布拉舍在 Unsplash 上拍摄的照片
对于门外汉来说，学习微软 Excel 的一些*【高级基础】*功能会对他们的生活产生巨大的影响。它可以帮助节省无数小时的手动工作，甚至可以自动化 It 的某些方面。根据行业和办公室的构成，它甚至可以帮助你成为办公室的电脑专家！
Excel 很强大，它做不到的事情很少。在投资银行工作，我每天都要使用 Excel，我很惊讶 Excel 的新毕业生对此知之甚少。我也不是在谈论 VBA；我说的是古老的内置公式。不过，不用担心，因为很快就能赶上。
在这篇博文中，我们将讨论我希望每个人都知道的关于 Excel 的 10 件事！
如何使用 Excel 公式
您需要知道的第一件事是，Excel 希望所有公式都以等号开头。单击任意空白单元格并键入“=”，您会注意到一些内置函数已经可以使用了。
当你读完这篇博客的时候，你会觉得把它们都尝试出来很舒服！
用“&”将单元格连接在一起
我们今天要学的第一件事是“&”符号。它用于将细胞连接在一起。你问我们为什么要这么做？我发现最常见的用法是创建唯一的数据键。如果一个数据集的主键中有多个字段，您可能希望用一个属性来表示它，以使数据集之间的连接和查找更容易。
让我们在实践中看看:
作者图片
使用 VLOOKUP 查找数据
迟早，当您需要根据一组数据中的一个值从另一组数据中检索信息时，这种需求肯定会出现。例如，假设您拥有所有相关信息，您希望能够根据姓名返回一个人的身高。
最简单的方法是使用 VLOOKUP。我们首先需要选择我们希望在查找中使用的值，然后是我们感兴趣的范围(记住查找将发生在第一列)，然后是我们希望返回数据的列，然后是我们希望精确匹配还是近似匹配。
这里有一个例子，你可以清楚地看到发生了什么:
作者图片
你可能已经注意到 VLOOKUP 只支持垂直查找。如果你想进行横向查找，你可以使用 HLOOKUP。
条件求和:SUMIF
另一个内置函数可能比您想象的更有用，它允许您有条件地对值求和。也就是说，根据某些标准，我们可以指定是否要将这些值包含在总数中。
这通过一个例子最容易理解:
作者图片
带小计的算术序列
SUBTOTAL 是一个漂亮的小函数，它使您能够对许多字段执行算术运算。Average、count、max、min、sum、stdev 等都是 SUBTOTAL 可以支持的函数。
这个函数的另一个秘密之处是它只考虑可见的值。换句话说，当您筛选结果集时(ctrl + shift + L，and filter)，分类汇总将只考虑在定义的范围内可见的值。
作者图片
删除重复项
虽然这不是一个内置的函数，但却是一个非常有用的功能。有时您只是想知道哪里有重复的数据，或者您只是想删除它们。这样做的过程不仅简单，而且非常实用。它的 UI 控件使您能够快速轻松地定义组合键。
您可以通过按 alt、A、m 快速调用此功能，或者如果您想使用鼠标，您可以通过典型的 Excel 控件调用此功能。
作者图片
文字分列
顾名思义，该功能使您能够将文本分成几列。当您使用逗号分隔文件(CSV)或其他分隔符时，这可能会很有用。
但是，根据您正在处理的数据类型，您可以使用该控件来发挥创造力。当我在 Excel 中复制粘贴一些内容，并且数字表示为文本时，我经常发现自己在使用这个控件(您可以直观地看出，因为单元格中的值是左对齐的)。这将产生任何查找等问题。因此，快速使用这个带有伪分隔符的控件会重新格式化所有内容(快捷键:alt，a，e)。
作者图片
数据透视表
如果有一件事你带走并记住了，那就是这件事。毫无疑问，数据透视表可能是您可以了解的关于 Excel 的最重要和最有用的东西。它使您能够以各种方式对数据进行切片和切块，以便您可以对您的数据进行总结并获得深刻的见解。
您可以选择如何根据列、行、要包含的数据以及要在聚合中执行的操作来显示数据。下面的例子肯定会帮助你更好地理解(快捷键:alt，n，v)数据透视表，但是我鼓励你深入研究并亲自尝试。没有比亲自尝试更好的学习方法了。
作者图片
学习在 Excel 中应用 If-Then-Else 语句
在分析数据时，有时你需要检查某些条件是否成立。为此，我们可以使用内置的“if”函数。该函数接受三个输入。条件，条件为真时的结果，条件为假时的结果。
根据语句的复杂程度，可以将多个 if 语句组合在一起。让我们进一步探讨这两种可能性。
简单的例子:
作者图片
或者具有更复杂的逻辑:
作者图片
用于数据分析的字符串操作，包括左、右、左
最后，我们要学习的最后一个 Excel 函数(实际上是最后三个)与尝试操作有关。Len 返回一个字符串的字符数，当它与 left 和 right 结合使用时最有用。
左和右接收两个输入。一个字符串和要返回的字符数，从左或右开始计数。然而，有时你只是想排除一个尾随或开始的字符集，这就是 len 出现的地方。
作者图片
结论
有了这些知识，您现在就具备了继续扩展和积累 Excel 知识所需的一切。我强烈推荐这是一项值得的自我投资。无论招聘广告是否要求，它都是大多数工作中必备的技能。
我希望这能对你有所帮助，并激励你继续学习！
MongoDB Atlas 入门:概述和教程
介绍
数据库即服务
近年来，数据库行业经历了许多变化，导致越来越多的人转向数据库即服务(DBaas)模式，而不是本地基础架构。数据库是大多数业务应用的核心，基于云的 DBaaS 服务为用户提供了一个灵活、可扩展的按需平台，无需设置昂贵的物理硬件、安装软件或配置性能。此外，公司正在分析的数据也在发生变化。用户和开发人员现在寻找适应性更强的数据库，以允许他们访问和处理非结构化数据。随之而来的是对按使用付费模式的内存和 NoSQL 数据库的更大需求。
MongoDB，开源数据库背后的公司，试图用 Atlas 来满足这一需求，这是它自己的 DBaaS 产品，为用户提供托管数据库服务。该服务提供按需付费的价格，并允许用户在他们选择的云服务提供商(AWS、Azure 和 GCP)上部署。Atlas 对 MongoDB 来说是成功的，截至 2019 年，它占其总收入的 35%，拥有超过 12，000 名客户。
在这篇文章中，我们将提供一个关于 MongoDB Atlas 的概述，给出一个关于开始使用该平台的教程，并从首次用户的角度分享我们的一般要点。
MongoDB 地图集
概观
MongoDB Atlas 是一个基于云的开源 NoSQL 数据库，它使用带有动态模式的 JSON 文档，作为表数据库的替代方案。Atlas 提供了 MongoDB 的所有功能，同时自动执行数据库管理任务，如数据库配置、基础设施供应、补丁、扩展事件、备份等，让开发人员能够专注于对他们最重要的事情。
MongoDB Atlas 还提供了灵活性和可伸缩性的双重好处。动态模式允许用户在不修改数据的情况下更改其模式，提供了灵活性。而其“自动分片”功能允许用户在一系列实例中进行纵向或横向扩展，应用程序不会停机。
定价
自由层
MongoDB 提供了一个免费层，用户可以用来学习、构建原型和早期部署。这个名为 M0 沙盒的免费版本被限制在 512MB 的存储空间，共享 vCPU 和 RAM，100 个最大连接数，以及一个 M0 集群的限制。
付费层级
Atlas 针对单区域集群的付费计划起价为 0.08 美元/小时，预计费用为 56.94 美元/月。
对于专用集群，MongoDB Atlas 根据您的使用量按小时计费。该速率取决于许多因素，最重要的是您使用的服务器的大小和数量。例如，根据 MongoDB，一个 m40 的 AWS 3 节点副本集使用附带的 80GB 标准块存储全天候运行一个月，成本约为 947 美元。
MongoDB Atlas 入门
MongoDB Atlas 使入门变得容易，注册免费层只需几秒钟。整个过程使用动态 web 界面，引导您完成各种部署选项。它简单、直观，不需要专业知识。下面，我们将详细介绍使用 MongoDB Atlas 开始运行的步骤。
创建 Atlas 帐户
首先，你需要在 MongoDB Atlas 登陆页面上注册一个账户。注册表只需要你提供基本信息，如姓名，电子邮件，公司和为您创建一个密码。不需要信用卡信息。注册后，Atlas 会自动创建一个默认的组织和项目，您可以在其中部署您的第一个集群。
MongoDB Atlas 登录页面(来源——mongodb.com)
部署自由层集群
登录后，系统会提示您选择云提供商和地区来构建您的第一个集群。Atlas 与三大主要云提供商 Amazon AWS、Google Cloud 和 Microsoft Azure 合作。根据您的选择，您可以选择首选数据中心的位置。免费层和区域被标记为免费沙盒版本，创建一个新的集群只需要几分钟。
选择 MongoDB Atlas 集群和云提供商(来源——mongodb.com)
将您的连接 IP 地址列入白名单
然后会提示您设置您的互联网协议(IP)并将您的 IP 地址列入白名单。这一点很重要，因为它确保只有您可以从您的 IP 地址访问云中的集群。您还可以选择允许从任何地方访问，尽管这意味着任何人都可以通过网络访问您的集群。如果您的密码和其他凭据泄露，这将是一个潜在的安全风险。
MongoDB Atlas 白名单 IP 地址提示(来源——mongodb.com)
为集群创建一个 MongoDB 用户
接下来，您需要创建一个 MongoDB 用户来访问您的集群。只需输入新的用户名和密码。然后，您可以选择用户权限，包括管理员权限、读/写权限或只读权限。
创建一个 MongoDB Atlas 用户提示(来源——mongodb.com)
连接到您的群集
现在，您已经创建了一个用户，是时候连接到您的集群了。系统会提示您选择一种连接方法，要么使用您自己的应用程序 MongoShell 连接，要么使用 MongoDB 的 GUI MongoDB Compass 连接。在本例中，我们将使用 MongoDB Compass 进行连接。
连接到 MongoDB Atlas 集群提示(来源-mongodb.com)
下载并打开 MongoDB Compass 后，系统会提示您从剪贴板粘贴一个连接字符串，然后连接到集群。
将连接字符串粘贴到 MongoDB Atlas 集群(来源—mongodb.com)
在集群中插入和查看数据
现在，您已经连接到集群，可以使用数据资源管理器在集群上插入示例数据并与之交互。
Data Explorer 允许您在集群中查看、创建和删除数据库、集合和索引。此外，您可以插入、编辑和删除文档，以及创建和运行聚合管道来处理数据。请注意，Data Explorer 是 Atlas 中的一个特性，它允许您访问和管理集群中的数据，这与 MongoDB Compass 不同，后者是一个用于与 MongoDB 数据库交互的独立 GUI。
首先，您需要将样本数据集加载到集群中。加载后，您可以通过单击 Collections 按钮(或使用 Mongo Shell)在数据浏览器中访问它。数据导入大约需要 5 分钟，操作完成后，您将在集群中看到五个数据库:
- 样本 _airbnb
- 样本 _ 地理空间
- sample_mflix
- 样本 _ 培训
- 样本 _ 天气数据
使用数据浏览器查看和修改您的 MongoDB Atlas 集群中的数据(来源—mongodb.com)
就这样，我们完成了注册 Atlas 帐户的整个过程，部署并连接到您的第一个 Atlas 集群，用样本数据填充您的集群，并使用 Atlas Data Explorer 与数据进行交互。如你所见，开始使用 Atlas 非常简单明了。
摘要
我们发现 MongoDB Atlas 易于使用和适应。注册帐户、部署第一个集群以及连接到集群的过程是无缝的，这在很大程度上要归功于其直观的界面。特别是，我们喜欢 Atlas 包含样本数据，我们可以将这些数据加载到集群中，然后利用 Data Explorer GUI 与数据进行交互。对于更高级的数据分析和可视化，您可以选择使用标准 BI 工具，如 Tableau 或本地解决方案，如 MongoDB Charts 和 Knowi 。
总的来说，它简单的用户界面，以及它的一系列功能，包括自动分片的可扩展性，用于操作任务的内置自动化机制，以及即使对于最苛刻的工作负载也能提供高吞吐量和低延迟的出色性能，难怪有经验的开发人员和新用户都喜欢 MongoDB Atlas。
外卖食品
- 基于云的 DBaaS 具有灵活性、可扩展性和按需性，无需昂贵的物理设置
- MongoDB Atlas 是 MongoDB 自己的基于云、开源、基于 NoSQL 的完全托管 DBaaS 产品
- Atlas 自动执行数据库管理任务，如配置、基础设施供应、补丁、扩展事件、备份等
- Atlas 提供了动态模式的灵活性，而自动分片特性使得跨实例扩展变得容易
- 一个直观的界面使开始使用 Atlas 变得容易。部署和连接第一个集群只需几分钟
- 数据资源管理器是一项非常有用的功能，它允许您以可视化方式与集群中的数据进行交互
- 其简单的用户界面、任务自动化、灵活性、内置复制和按需定价使 MongoDB Atlas 成为开发人员的最爱
印度语 NLP 入门
想超越英语，用自然语言处理(NLP)的真正力量为世界第二人口大国服务？每个人都知道印度是一个非常多元化的国家，是多种语言的家园，但是你知道印度说 780 种语言吗？说到 NLP，是时候超越英语了。这篇文章是写给那些对 NLP 有所了解，并想开始将它用于印度语言的人的。
语言模型
在进入主题之前，我们将浏览一下 NLP 中的一些基本概念和最近的成就。自然语言处理帮助计算机理解人类语言。文本分类、信息抽取、语义分析、问题回答、文本摘要、机器翻译和对话代理是 NLP 的一些应用。
为了让计算机理解人类语言，我们最初需要用数字形式表示单词。然后，机器学习模型可以利用数字表示的单词来完成任何 NLP 任务。传统上，像 One Hot Encoding ， TF-IDF 表示法这样的方法被用来将文本描述为数字。但是传统的方法由于不能捕捉词义而导致稀疏表示。
然后，神经单词嵌入通过解决传统方法中的问题来拯救。 Word2Vec 和 GloVe 是两种最常用的单词嵌入。这些方法提出了密集表示法，意思相似的单词会有相似的表示法。这种方法的一个显著缺点是单词被认为只有一个意思。但是我们知道，一个词可以有多种含义，这取决于它的使用环境。
语言模型——艾的布偶帝国[3]
NLP 通过现代语言模型家族(AI 的木偶帝国)实现了重大飞跃。单词嵌入不再独立于上下文。根据使用的上下文，同一个单词可以有多个数字表示。伯特、埃尔莫、乌尔姆菲特、 GPT-2 是目前比较流行的一些语言模型。最新一代这么好，也有人认为很危险[3]。这些语言模型撰写的新闻甚至被读者评为与《纽约时报》一样可信。
要了解更多关于语言模型的知识，我强烈推荐阅读[2]。
印度语的单词嵌入
现在，我们将通过获取印度语的单词嵌入来深入探讨这个主题。用数字表示单词在任何 NLP 任务中都有作用。我们将使用印度语自然语言工具包(iNLTK) 库。iNLTK 是一个构建在 PyTorch 之上的开源深度学习库，旨在为应用程序开发人员可能需要的印度语的各种 NLP 任务提供开箱即用的支持。ULMFiT 语言模型用于构建 iNLTK [6]。iNLTK 于 2019 年 5 月在 GitHub 上成为趋势，并在 PyPi 上获得了 23，000+的下载量[5]。
我们在这里使用 iNLTK 是因为它简单并且支持许多印度语言。iNLTK 目前支持以下 12 种印度语。请按照此链接安装 iNLTK。
iNLTK 支持的语言[5]
使用 iNLTK，我们可以快速获得用印度语编写的句子的嵌入向量。下面是一个例子，展示了我们如何获得用印地语写的句子的嵌入向量。给定的句子将被分解成记号，每个记号将用一个(400×1)向量来表示。令牌可以是一个单词，也可以是一个子单词。因为记号可以是子词，所以我们也可以为罕见的词得到一个有意义的向量表示。
# Example 1 - Get Embedding Vectorsfrom inltk.inltk import setup
from inltk.inltk import tokenize
from inltk.inltk import get_embedding_vectors'''
Note: You need to run setup('<code-of-language>') when you use a language for the FIRST TIME ONLY.
This will download all the necessary models required to do inference for that language.
'''
setup('hi')example_sent = "बहुत समय से मिले नहीं"# Tokenize the sentence
example_sent_tokens = tokenize(example_sent,'hi')# Get the embedding vector for each token
example_sent_vectors = get_embedding_vectors(example_sent, 'hi')print("Tokens:", example_sent_tokens)
print("Number of vectors:", len(example_sent_vectors))
print("Shape of each vector:", len(example_sent_vectors[0]))
输出:
代币:[‘▁बहुत’，‘▁समय’，‘▁से’，‘▁मिले’，'▁नहीं ']
向量个数:5
每个向量的形状:400
既然我们有了单词 embeddings，许多人可能会想知道这些数字表示有多好？相似的令牌有相似的描述吗？我们可以使用为每种语言提供的可视化来获得所有这些问题的答案。例如，如下图所示，所有与’प्रेम’(爱情)相关的象征物都与爱情、亲情、婚礼等密切相关。
更接近’प्रेम’的标志(爱情)
印度语的多个 NLP 任务
正如我前面所说，用数字表示的自然语言可以被机器学习模型用来完成许多 NLP 任务。除此之外，我们可以立即使用 iNLTK 完成大量的 NLP 任务。例如，我们可以使用 iNLTK 来预测接下来的 n 个单词，获得相似的句子，获得句子编码，识别语言，等等。
在下面的例子中，我们将使用 iNLTK 来预测接下来的 n 个单词，并得到相似的句子。对于类似于泰米尔语的*“自从我们相遇以来已经过了很长时间”的输入，我们得到对下一个‘n’个单词的预测为“并且，由于这个”*。相似句子任务的结果也令人印象深刻。
# Example 2 - Predict Next 'n' Words, Get Similar Sentencesfrom inltk.inltk import setup
from inltk.inltk import predict_next_words
from inltk.inltk import get_similar_sentences'''
Note: You need to run setup('<code-of-language>') when you use a language for the FIRST TIME ONLY.
This will download all the necessary models required to do inference for that language.
'''
setup('ta')example_sent = "உங்களைப் பார்த்து நிறைய நாட்கள் ஆகிவிட்டது"# Predict next 'n' tokens
n = 5
pred_sent = predict_next_words(example_sent, n, 'ta')# Get 'n' similar sentence
n = 2
simi_sent = get_similar_sentences(example_sent, n, 'ta')print("Predicted Words:", pred_sent)
print("Similar Sentences:", simi_sent)
输出:
预测词:உங்களைப்பார்த்துநிறையநாட்கள்ஆகிவிட்டது.மேலும்，இதற்கு காரணமாக
类似句子:[‘உங்களைத்பார்த்துநாட்கள்ஆகிவிட்டது’，‘உங்களைப்பார்த்துஏராளமானநாட்கள்ஆகிவிட்டது’]
就像我说的，在开始的时候，是时候超越英语，用 NLP 的真正力量为大家服务了。最近的许多研究都集中在多语言自然语言处理上。iNLTK 就是这样一个专注于印度语的库。现在，您可以通过添加对新语言的支持、改进现有模型和添加新功能来为 iNLTK 做出贡献。除了 iNLTK，我还会推荐多语模型[7]，Indic NLP [8]。别忘了你刚刚遇到的一切都只是冰山一角。在结束这篇文章之前，我想补充几句话来表达 iNLTK 的创造者的愿景。
我一直希望有类似的东西存在，这将使 NLP 更容易理解，并使其对非英语母语者的好处民主化。iNLTK 是有机增长的，现在，由于它被广泛认可，我认为还有很多事情要做。我对 iNLTK 的愿景是，它应该成为任何使用低资源语言的人的首选库。— Gaurav Arora，iNLTK 的创造者。
参考文献
[1]http://blogs . Reuters . com/India/2013/09/07/India-speaks-780-languages-220-lost-in-last-50-earth-survey/
【2】https://towards data science . com/from-word-embeddings-to-pre-trained-language-models-a-new-age-in-NLP-part-1-7 ed 0 c 7 F3 DFC 5
【3
开始使用开源路线图
入门
关于如何开始为开源项目做贡献的 10 步指南。
开源可能是当今科技界的流行语之一。作为开发人员或数据科学家，您可能以前听说过它。即使你不在一个很深的技术领域，你也有可能听到有人提到开源的话题。
尽管许多人都熟悉开源这个术语，但人们并不总是真的知道这个术语的意思。
那么， 什么是开源呢？
开源是一种软件，其中该软件的源代码在特定的版权许可下发布，供其他人出于任何目的使用、研究、更改和分发该软件——只要它不与版权许可相抵触。
用外行人的话来说，这意味着，当一家公司或一个团队构建一项服务或产品时，他们让其他人能够使用源代码并修改其中的内容。
为开源项目做贡献有很多好处；它可以帮助你提高技能，结识新的志同道合的人，为未来的工作建立一个强大的投资组合。另一个好处是，如果你经常为开源做出贡献，你将在社区中变得众所周知，因此，在某种意义上，你将成为技术影响者。
谁能为开源做贡献？
好吧，任何人！无论你是一个代码新手，还是已经编码一段时间的人，你都可以开始为开源项目做贡献。
在这篇文章中，我将列出我的十步指南——我采取的步骤——来开始开源。你可能已经完成了一些步骤。在这种情况下，跳到你当前所在的步骤。
开启数据科学未来的 10 步路线图
towardsdatascience.com](/a-learning-path-to-becoming-a-data-scientist-56c5c2e8ae3f)
步骤 1:建立对编程的基本理解
这一步是为那些对开源好奇但没有任何技术背景的人准备的。不要担心。如果你愿意投入时间，开始构建软件是没有要求的。
在开始使用开源软件之前，您首先需要检查的是您的基本编程知识。这是您开始构建项目所需的基础。确保你了解你打算在文章中使用的编程语言。
如果你想为 Python 项目做贡献，那么了解 Python 将有助于你理解已经完成的工作，并且对你来说扩展它会更容易。
第二步:熟悉 git。
没有 Git 就拼不出开源。嗯，可以，但是你懂我的意思。Git 是让开源成为现实的工具。Git 是需要掌握的棘手话题之一。
我从事技术工作已经十多年了，但是我还没有遇到一个人能够完全处理 Git 而不需要返回文档。然而，你不需要完全理解 Git 的内部动态来开始使用开源。
哪个好！
你只需要几个命令——比如克隆、推、拉、提交，知道何时以及如何使用它们，然后瞧，你就可以开始了。
什么是版本控制，为什么它很重要？
towardsdatascience.com](/version-control-101-definition-and-benefits-6fd7ad49e5f1)
第三步:学习如何寻找你想要的东西
总的来说，对于技术领域来说，最困难的一个方面是关于任何主题的大量信息。如果你尝试谷歌“数据科学图书馆”，你会被成千上万的关于这个特定主题的文章轰炸。
对于开发人员或数据科学家来说，一项有价值的技能是知道如何有效地寻找他们所寻求的答案，无论他们是在谷歌上搜索，还是在文档或教科书中寻找。
如果你想得到你想要的答案，你需要学会问正确的问题。这项技能将有助于使你的工作更快更有效率。
第四步:阅读你最喜欢的项目的文档
数据科学中使用的大多数众所周知且常用的包都是开源包。像 Matplotlib、Numpy 和 Scipy 这样的包。
阅读这些项目的文档会让你了解这些大项目是如何产生的；它将向您展示开源的力量。它还会让你知道还需要做什么，以及为这些项目做贡献的机会。
此外，阅读他们的文档可以熟悉各种类型的许可证及其区别。这些知识将帮助您理解不同许可的规则和用法，从而知道在您未来的项目中使用什么。
第五步:从非代码贡献开始。
你的第一次投稿可能是最令人生畏的。帮助我克服这一点的是在我开始做编码之前做一些非编码的贡献。
有很多机会可以为非基于代码的开源做出贡献。如果你是一个编程新手，仍然对你的编程技能感到不舒服，或者你没有任何编程技能，但是你想为开源做贡献，我在这里告诉你，你可以！
一些非代码贡献包括:
- 改进文档或将其翻译成另一种语言。
- 在网站或图形界面上工作。
- 推销项目或传播信息。
- 主持会议并指导项目存储库的性能。
第七步:寻找一个初学者友好的项目
许多著名的大型项目都是初学者友好型的，不需要你以前的开源贡献。像 DuckDuckGo 或 Habitica 这样的项目非常欢迎新的贡献者。
你也可以联系你喜欢的包或服务的维护者，问问他们是否欢迎开源初学者的贡献。这些信息也可以在他们的网站和文档中找到。
寻找项目的其他来源有:
第八步:与社区交往。
开源是一个由来自世界各地的开发者组成的社区，他们决定共同努力，创造出令人惊叹的东西。当你为开源项目做贡献时，你基本上证明了你愿意加入这个社区。
与其他开源开发者的社交会让你觉得你是一个社区的一部分，一个会在你需要的时候支持你，给你提供很多机会的社区。
你可以通过不同的方式与社区建立联系；你可以为你正在处理的特定项目使用 slack 频道，比如用于 Django 、 Numpy 的 slack 组，或者一般的 Python 社区 slack。
步骤 9:提交你的第一个代码贡献
这一步是最需要你勇气的一步！但也是最有成就感的一步。一旦你熟悉了 Git 和你想使用的编程语言，你就已经用非编码的方式为项目做出了贡献。您已经为您的第一个代码贡献做好了准备。
从一个简单的特性或 bug 开始，也许是一些不紧急的东西。慢慢来，仔细检查你的代码，好好测试。然后，放手，创建一个拉请求。
你只需要一次成功的贡献就能给你继续贡献的信心。
第十步:建立你的投资组合
当你为项目做贡献时，不要忘记记录你对投资组合的贡献。你的贡献越大，你的投资组合就越稳固。
然而，有时候，这不是关于贡献的数量，而是关于它的质量。这就是为什么我总是建议你慢慢来，写出写得好的代码。说到软件贡献，质量在任何时候都胜过数量。
这里有一些你可以用来建立你的投资组合的网站:
您的应用程序需要什么样的测试？
towardsdatascience.com](/a-brief-introduction-to-software-testing-38499dd4189)
外卖食品
我知道一开始参与开源可能会令人生畏，但是，就像生活中的其他事情一样，克服这种威胁的最好方法就是直接投入进去。
不管你使用/知道什么编程语言，你的知识水平，或者专业领域，总有一个开源项目适合你。
所以，要对自己的能力有信心，寻找让你兴奋的事情，并开始做出贡献。一旦你这样做了，过程就变得容易了，暗示也就消失了。
没有比自己动手做东西更好的方法来提高你的技能了。开源是成为一名更好的开发人员和思想更开放的程序员的最好方法之一。
OpenCV 入门
使用 Python 实现计算机视觉的第一步
不久前，我为一个大学项目训练了一个物体检测模型，但老实说，除了需要许多红牛和漫漫长夜观看我的模型训练之外，我不太记得它了。
我最近对这些话题重新产生了一些兴趣，我决定重新开始，重新学习，但这次我做笔记，分享我的学习成果。
与reiinakano.com/arbitrary-image-stylization-tfjs一起建造
——我想知道是否有一天我们能够使用样式转移将样式从一个数据复制到另一个数据，而不损害其完整性。
OpenCV
OpenCV 是一个开源库，最初由英特尔开发，它充满了支持计算机视觉和机器学习的便捷方法和功能。
在本文中，我将尝试学习如何阅读图像，在 Jupyter 笔记本中显示图像，以及如何检查和更改它的一些属性。
import cv2
import numpy as np
import matplotlib.pyplot as plt
让我们从。imread 加载图片，然后我们可以使用。imshow 在新窗口中显示它。
image = cv2.imread('img.jpg')
cv2.imshow('Some title', image)cv2.waitKey(0)
cv2.destroyAllWindows()
方法。等等还有。销毁所有窗口对于运行代码而不崩溃是必不可少的。第一个命令将告诉 Jupyter 继续运行该程序块，直到某个键被按下，第二个命令将在最后关闭窗口。
我们也可以尝试用 Matplotlib 显示图像。imshow 这样，它将显示在内联，而不是在一个新的窗口中。
image = cv2.imread('img.jpg')
plt.imshow(image)
Matplotlib 显示 BGR 图像
呃，好吧。这看起来很奇怪。颜色全乱了。
OpenCV 以 Numpy 数组的形式加载图像，这些数组有三维的红色、绿色和蓝色。维度通常被称为通道，它们保存从 0 到 255 的值，代表每个像素的颜色强度。
>>> print(type(image))
>>> print(image.shape)<class 'numpy.ndarray'>
(776, 960, 3)
这意味着它是 RGB，对吗？不尽然。这是 BGR，这是同样的事情，但在不同的顺序。
Matplotlib 使用 RGB，这就是为什么我们的图片看起来很奇怪。这不是问题，因为 OpenCV 有一些非常方便的方法来转换颜色。
image = cv2.imread('img.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)plt.imshow(image)
显示 RGB 图像的 Matplotlib。
太酷了，我们用 OpenCV 读取并显示了我们的图像，并且看了一眼如何用 Matplolib 将 GBR 颜色转换成 RGB 来显示它们。
OpenCV 可以处理其他颜色格式，比如 HSV、CMYK 等等。
颜色；色彩；色调
因为我们会重复很多次，所以让我们创建一个用 Matplotlib 绘图的方法。我们可以设置绘图的大小，并删除轴，使它更好。
def show(img):
fig, ax = plt.subplots(1, figsize=(12,8))
ax.axis('off')
plt.imshow(img, cmap='Greys')
注意，我还在。im 显示为“灰色”；当我们绘制 RGB 图像时，该参数将被忽略，但当我们稍后绘制数组的各个维度时，该参数将会很有帮助。现在，让我们试试我们的方法。
image = cv2.imread('img2.jpeg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)show(image)
好了，现在让我们试着把它转换成灰度，然后再转换成 RGB。
image = cv2.imread('img2.jpeg')gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)show(image)
灰度等级
我们可以利用。分割得到单独的颜色数组，然后用. merge 将图片重新组合在一起。这对于修改、检查和过滤我们数组的一个维度是很实用的。
例如，我们可以将数组乘以零来移除它；
img = cv2.imread('img2.jpeg')B, G, R = cv2.split(img)
img = cv2.merge([B*0, G, R*0])img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
show(img)
只有绿色。
我们可以增加或减少颜色的强度，或者用相同的形状建立一个新的 Numpy 数组来替换它，或者你能想到的任何事情。
img = cv2.merge([np.ones_like(B)*255, G, R])img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
show(img)
忧郁增加。
分割和合并的相同概念可以应用于其他格式，例如 HSV 和 HSL。
img = cv2.imread('img2.jpeg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)H, S, V = cv2.split(img)
img = cv2.merge([np.ones_like(H)*30, S+10, V-20])img = cv2.cvtColor(img, cv2.COLOR_HSV2RGB)
show(img)
黄色色调，较高的饱和度，较低的值。
HSV :色相，饱和度，和值。
这种格式对于过滤颜色很方便，因为它与色调一起工作——这意味着，我们可以使用角度范围，而不是必须找出红色、绿色和蓝色之间的组合范围。
我们可以用 Numpy 定义 HSV 的上下边界。应用该方法。过滤这些值，并创建一个掩码。然后我们可以在饱和度下应用这个蒙版。bitwise_and，这将使边界之外的所有内容变为零。
换句话说:我们可以过滤掉一些颜色，把剩下的都变成灰度。
# read img and convert to HSV
img = cv2.imread('img2.jpeg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)# split dimensions
H, S, V = cv2.split(img)# upper and lower boundaries
lower = np.array([80, 0, 0])
upper = np.array([120, 255, 255])# build mask
mask = cv2.inRange(img, lower, upper)# apply mask to saturation
S = cv2.bitwise_and(S, S, mask=mask)# assemble image
img = cv2.merge([H, S, V])# convert to RGB and display
img = cv2.cvtColor(img, cv2.COLOR_HSV2RGB)
show(img)
布鲁斯。
分割图像还可以让我们更容易地检查其组成。
我们可以从 RGB 绘制颜色，从 HSV 绘制饱和度，或者我们想要的任何其他通道。
img = cv2.imread('img2.jpeg')
B, G, R = cv2.split(img)
show(B)img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
H, S, V = cv2.split(img)
show(S)
使用“灰色”色图，数值从白色(低)到黑色(高)。
我们可以通过查看第一张地图来判断蓝色的强度在地面上比在建筑物中更高，我们可以通过饱和度图看到滑板周围的值比图像的其他部分更高。
今天我就讲到这里。我们研究了如何加载和显示图片，如何将数组转换为不同的颜色格式，以及如何访问、修改和过滤维度。
在下一篇文章中，我将尝试探索变换以及如何移动、调整大小、裁剪和旋转图像。
感谢阅读我的文章。我希望你喜欢它。
资源:
OpenCV 阅读图片；
OpenCV 颜色转换；
Matplotlib 显示图像；
OpenCV 对数组的操作；
OpenCV 基本操作；
使用 Python 开始光学字符识别
语言模型设计
对光学字符识别从无到有的直观理解和简要介绍
光学字符识别是通过使用电子或机械设备将二维文本数据转换成机器编码文本的一种形式。二维文本数据可以从各种来源获得，例如 PDF 文件之类的扫描文档、具有以下格式的文本数据的图像。png 或者。jpeg、路标(如交通标志)或任何其他带有任何形式文本数据的图像。光学字符识别有广泛的有趣应用。
我第一次接触到光学字符识别是在我上学的时候，我们的多项选择题(MCQ 的)答案脚本会被这些设备分析。可以从这些答案脚本中提取数据，并根据答案关键字标记答案。嗯，尽管大多数人过去总是抱怨他们得到的结果不是他们想要的。这可能是由于设备的故障/功能不全，或者学生可能有轻微的误导。然而，随着现代技术的发展，光学字符识别被用于各种应用中，并且这些应用更加先进。这些设备的精确度已经大大提高了。
在本文中，我们将介绍光学字符识别的基础知识。然后，我们将继续安装 pytesseract 模块，我们将使用它来执行光学字符识别。最初，在我刚入门的时候，安装对我来说是相当烦人和麻烦的。所以，我会尽量简化安装过程的步骤。然后我们将使用 python 理解 pytesseract 模块中的各种函数。最后，我们将以一段代码来结束本文，这段代码涵盖了光学字符识别以及 google 文本到语音转换模块的使用。
**注意:**最终代码将是使用文本到语音和字符识别的组合代码。这是语言模型设计系列的第二部分。如果你没有关于 gTTS 模块的线索，我强烈建议观众查看下面的链接。在本系列的下一部分，我们将尝试将语音翻译和光学字符识别与深度学习相结合。要按你的喜好顺序观看这个系列，你可以点击链接这里。
[## 如何使用 Python 开始使用 Google 文本到语音转换
从零开始的文本到语音转换简介
towardsdatascience.com](/how-to-get-started-with-google-text-to-speech-using-python-485e43d1d544) 
光学字符识别究竟是如何工作的？
图片由作者根据媒介创作
光学字符识别过程流程如上图所示。发送 API 请求以执行 OCR 操作。输入图像被相应地读取和预处理。文本被格式化并从图像中提取出来。使用经过训练的数据集，计算发送到 OCR 引擎的图像。OCR 引擎会尝试分析图像中的字符，并找到合适的解决方案。一旦引擎完成分析，它将发送数据进行另一步预处理和格式化，以排除任何不必要的项目。一旦这个过程完成，我们将最终获得所需的文本数据。在此之后，可以使用来自图像的转换后的文本数据向用户返回一个 API 响应。
安装:
安装可能有点棘手。但是，我会尽量简化安装步骤，以便您可以尽快开始。第一步很简单，只需使用 pip 命令安装 pytesseract 模块。在命令提示符终端/虚拟环境中键入以下命令—
我们已经成功安装了 pytesseractt 模块，但是当您试图立即运行代码时，您将收到一条错误消息，指出您的系统中没有安装 tesserac 模块。要完成此步骤，请访问此站点。这是 windows 宇宙魔方的官方网站。宇宙魔方 3.05、宇宙魔方 4 和开发版 5.00 Alpha 的 Windows 安装程序可从 UB Mannheim 的宇宙魔方获得。这些包括培训工具。32 位和 64 位安装程序都可用。
选择您喜欢的安装方式，并相应地进行安装。您可以将 pytesseract 模块添加到您的路径中，或者直接使用它。我希望这能解决安装过程中的大部分问题。如果您有任何其他疑问，请随时告诉我。
了解 pytesseract 模块:
Python-tesseract 是 Google 的 Tesseract-OCR 引擎的包装器。它作为 tesseract 的独立调用脚本也很有用，因为它可以读取 Pillow 和 Leptonica 图像库支持的所有图像类型，包括 jpeg、png、gif、bmp、tiff 等。此外，如果用作脚本，Python-tesseract 将打印识别的文本，而不是将其写入文件。
为了更直观地理解这一点，让我们看看下面的简单代码块—
我们导入 pytesseract 模块并指定路径。然后，我们使用 cv2 模块读取图像。最后，我们提取这些图像并返回文本数据。 image_to_string 返回对 image to string 运行的 Tesseract OCR 的结果。有关 tesseract OCR 及其 image_to_string 等功能的更多信息，请访问此处。
代码:
这一部分将包含结合文本到语音和光学字符识别的最终代码片段。我们将使用最近安装的 pytesseract 模块以及 gTTS 和 PIL 等模块。 PIL 代表 python 图像库，将用于加载我们的图像。open-cv 模块 cv2 也可用于读取图像。让我们分三部分来看看整个代码是如何工作的。
1。读取图像—
在这个代码块中，我们导入所需的库，并指定 Tesseract 位置的路径。然后，我们将继续用 cv2 模块读取图像。你也可以使用 PIL 图书馆。该命令将是“Image.open()”。在此步骤之后，我们将使用 OCR 库将图像转换为文本数据，并打印所需的输出。
2。格式化数据—
在下一个代码块中，我们将文本数据格式化为一行。我们基本上是在已经获得的文本数据上执行预处理，然后将其传递到 gTTS 模块用于语音翻译过程。
3。转换成语音—
最后，我们将导入 Google text-to-speech 模块，并将文本数据转换成音频消息的形式。这对于聆听 PDF 格式的文本数据以及图像的有声音频非常有用。如果您对 gTTS 模块有任何困惑，那么可以参考我以前的一篇文章来更好地理解这个概念。
[## 如何使用 Python 开始使用 Google 文本到语音转换
从零开始的文本到语音转换简介
towardsdatascience.com](/how-to-get-started-with-google-text-to-speech-using-python-485e43d1d544) 
照片由爱丽丝·多诺万·劳斯在 Unsplash 上拍摄
结论:
我们已经讲述了光学字符识别的一些概念，直观地了解了 OCR 处理流程是如何工作的。我希望开始使用 python 学习 OCR 技术的安装过程得到了简化，并且所有人都能达到预期的效果。我们理解了 pytesserac 模块的一些功能，并最终编写了一个代码，将 gTTS 和 pytesserac 模块结合起来。
在本主题语言模型设计的下一部分，我们将研究如何使用深度学习技术以及 OCR 和 TTS(文本到语音)来开发一个很酷的项目。
我强烈推荐你们所有人查阅下面的参考资料，以便更好地掌握和学习这些概念。如果您有任何疑问，请告诉我，祝您有美好的一天！
参考资料:
- 光学字符识别综合指南—https://moov.ai/en/blog/optical-character-recognition-ocr/
- 使用 Tesseract、OpenCV 和 Python 进行 OCR 的综合指南—https://nanonets.com/blog/ocr-with-tesseract/
- 使用 Google 的 Tesseract 和 OpenCV 构建您自己的光学字符识别(OCR)系统—https://www . analyticsvidhya . com/blog/2020/05/build-your-own-OCR-Google-tessera CT-OpenCV/
- 免费打造自己的 OCR(光学字符识别)——https://medium . com/@ Bala ajip/Optical-Character-Recognition-99 ABA 2 dad 314
- 光学字符识别—https://en.wikipedia.org/wiki/Optical_character_recognition
熊猫时序功能入门
提高数据分析速度的 3 种技巧
Pandas 具有分析时间序列数据的特殊功能，包括自动日期解析、高级过滤功能和几个特定于日期的绘图功能。
我发现自己几乎每天都在使用这些功能，但我花了很长时间才发现它们:Pandas datetime 的许多功能并不明显，而且我在开始时并没有使用这些功能。
但是使用这些功能很容易，而且无论何时处理时间序列数据，都有助于提高分析速度。
为了帮助你开始，这里有 3 个我最常用的时间序列特征。
1.自动解析时间序列数据
Pandas 可以自动将数据集中的列解析成时间序列数据，而不需要您指定任何正则表达式模式。
假设您正在分析一个数据集，其中前五行如下所示。
带有日期时间字段的示例表
您可以看到列date看起来像一个时间序列，我们将该列中的值转换为 Pandas datetime 类型是有意义的。
要指示 Pandas 转换这些值，在加载数据时使用parse_dates参数。
注意:
parse_dates参数在所有熊猫数据加载函数中都可用，包括read_csv。
>>> import pandas as pd
>>> df = pd.read_csv('[http://bit.ly/30iosS6](http://bit.ly/30iosS6)', parse_dates=['date'])
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 360 entries, 0 to 359
Data columns (total 2 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 dau 360 non-null int64
1 date 360 non-null datetime64[ns]
dtypes: datetime64[ns](1), int64(1)
memory usage: 5.8 KB
注意列date的Dtype是如何变为datetime64[ns]的。您现在可以在date列上使用 Pandas 的所有特殊 datetime 方法。
>>> df.date.dt.day_name()
0 Tuesday
1 Wednesday
2 Thursday
3 Friday
4 Saturday
...
2.过滤时间戳索引
当数据帧的索引是一个datetime类型时，Pandas 提供了方便的过滤方法。
>>> df.set_index('date', inplace=True)
>>> df.index
DatetimeIndex(['2019-01-01', ... ,'2019-12-26'])
例如，您可以通过向 DataFrame 的loc访问器传递一个字符串来选择一个特定的日期。
>>> df.loc['2019-02-01']
dau 554
Name: 2019-02-01 00:00:00, dtype: int64
你也可以使用字符串来选择数据范围，即分割数据帧。
>>> df.loc['2019-02-01':'2019-03-01']
dau
date
2019-02-01 554
2019-02-02 798
...
2019-02-28 569
2019-03-01 599
注意，索引是最后一个值的和。我们使用2019-03-01作为我们选择的范围的结尾，所以标签为2019–03–01的行包含在结果数据帧中。
您甚至可以传入部分字符串来选择特定范围的数据。
>>> df.loc['2019-03']
dau
date
2019-03-01 599
2019-03-02 724
...
2019-03-30 724
2019-03-31 638
3.快速绘制时间序列数据
最后但同样重要的是，您可以使用 Pandas plot函数轻松绘制时间序列数据。
>>> df.plot()
自动生成的日期时间图
注意 Pandas 是如何使用 X 轴的数据帧索引的。
当然，这个图表不是很有帮助。让我们使用一个聚合视图来产生更具可读性的东西。
为此，我们可以使用 DataFrame 的resample方法按月聚合 timeseries 索引。然后，我们将计算每个月的mean,并创建结果的条形图。
>>> df.resample('M').mean().plot.bar()
时序索引的汇总视图
关于如何在 Pandas 中快速生成图表的更多细节，你可以阅读我的文章“用 Pandas 快速绘图”。
使用这些简单的内置函数快速可视化您的数据
towardsdatascience.com](/the-best-pandas-plotting-features-c9789e04a5a0)
感谢阅读！我经常在 Medium 上写关于数据科学和编程技巧的文章，所以请关注我以获得更多类似本文的文章。
R 并行编程入门
在多个 CPU 内核之间分配工作
图片来自 Pixabay
我为什么要看这篇文章？
尽管 R 中有许多关于并行计算的好资料，但很少有人以这样一种任何人都可以入门的基本方式解释这些概念。由于 R 的高级本质和强大的开源开发者社区，并行化基本和更复杂的任务非常简单。如果您熟悉apply系列函数(在数组或列表的索引上应用函数的函数)，只需增加三行代码就可以完成并行化！在本文中，我们将从“应用”功能的并行版本开始，扩展到更灵活的方法，最后通过一个来自财务优化的真实示例。
并行运行"apply" 功能
我们开始吧。假设我们有一个包含四个大向量的列表。对于四个大向量中的每一个，我们都要计算平均值。下面，使用传统的lapply方法计算平均值:
# Generate data
data <- 1:1e9
data_list <- list("1" = data,
"2" = data,
"3" = data,
"4" = data)# Single core
time_benchmark <- system.time(
lapply(data_list, mean)
)
这个计算用了 18.33 秒。用 18 秒来计算四个简单的平均值？我们没有时间了。事实证明，我们不需要这么做。上面执行的四个计算是完全独立的。即它们不相互依赖。第 1 项的含义绝不取决于第 2 项的含义。默认情况下，R 中的大多数功能都运行在一个处理核心上。随着当今大多数系统采用多核处理器，通过简单地将任务划分到多个内核上来减少运行时间的潜力是非常显著的。图书馆parallel帮助我们实现这一目标。下面，使用来自parallel库的lapply ( parLapply)的多核等价物来实现相同的计算:
library(parallel)# Detect the number of available cores and create cluster
cl <- parallel::makeCluster(detectCores())# Run parallel computation
time_parallel <- system.time(
parallel::parLapply(cl,
data_list,
mean)
)# Close cluster
parallel::stopCluster(cl)
这个计算用了 4.99 秒。通过添加三行代码，计算时间几乎减少了 75%！这就是现代多核 CPU 的好处。我使用四核 CPU，在四个核而不是一个核上运行四个计算，速度提高了四倍(嗯，由于计算机科学的原因，我没有足够的智慧来解释这一点)。这是您开始使用 r 中的并行计算所需要的全部内容。如果您只需要 apply 函数，那就自己动手吧。否则，请继续阅读，我们将用一种提供更多灵活性的方法进行更深入的研究。
并行运行循环迭代
比起一个apply 函数，你更喜欢并行一个传统的循环吗？那么foreach库就是你的解决方案。foreach函数的工作方式很像传统的循环，但是除了索引之外，它还需要关于如何构建输出以及在多核循环中应该可以访问哪些库的信息。因为我们的均值计算是使用基 R 函数执行的，所以不需要将任何包传递给foreach。同样，平均值的计算是这样实现的:
library(doParallel)
library(parallel)
library(foreach)# Detect the number of available cores and create cluster
cl <- parallel::makeCluster(detectCores())# Activate cluster for foreach library
doParallel::registerDoParallel(cl)time_foreach <- system.time({
r <- foreach::foreach(i = 1:length(data_list),
.combine = rbind) %dopar% {
mean(data_list[[i]])
}
})
time_foreach[3]# Stop cluster to free up resources
parallel::stopCluster(cl)
在 5.03 秒时，计算时间与parLapply实现的时间没有显著不同。这里重要的是使用了同名库中的foreach函数。它具有与 for 循环类似的功能，但同时在多个内核上执行迭代。这意味着迭代之间不存在依赖性。这里有两个输入被传递给函数；与常规循环一样的索引，以及如何组合输出。rbind将输出绑定为行。foreach提供了很大的灵活性，因为你可以完成几乎与传统循环相同的任务——假设每次迭代的结果之间不存在依赖关系。
并行运行投资组合优化
现在让我们尝试一个更现实的问题。可能很少有人有一个四个向量的列表，并想计算每个向量的平均值。在这一节中，我想说明你刚刚学到的东西在均值计算之外是有用的。具体来说，在我自己的计算金融领域。在计算金融中，经常需要通过运行 10、100 或 1000 次相当大的优化算法来模拟性能。通过适当的简化，这个问题很容易并行处理。
投资组合优化是在给定最大容许风险量的情况下，寻找具有最大预期回报的投资组合的艺术，反之亦然。预期回报通常以平均历史回报给出，风险以历史回报的标准差(或类似的度量)给出。这是一门有缺陷的艺术，因为它假设未来和过去一样。一位智者(苏伦·克尔凯郭尔)曾经说过，生活只能向后理解，但必须向前生活。不幸的是，在量化金融领域也是如此。
投资组合优化不能告诉你应该承担多大的风险。如果你还年轻，正在为退休储蓄，你可能应该承担相当大的风险，因为你不打算很快取出这笔钱，从长期来看，风险投资会获得更好的回报。如果你正在攒钱准备明年买房，那么降低风险是明智之举。高风险和低风险的投资组合都有一个共同点，那就是它们应该是最优的权衡。你希望在一定的风险下获得尽可能多的回报。所有这些最优投资组合都可以在一个名为“有效边界”的图表中可视化，这是我们将在第三部分也是最后一部分构建的。
首先，为了并行化和财务优化，有必要加载库:
# Load parallelisation libraries
library(doParallel)
library(foreach)
library(parallel)# Load finance and optimization libraries
library(PerformanceAnalytics)
library(PortfolioAnalytics)
require(ROI)
require(ROI.plugin.glpk)
require(ROI.plugin.quadprog)
require(quadprog)
您已经熟悉了前三个库。剩下的五个是金融数学和优化的专用库:
PerformanceAnalytics—用于计算绩效和风险指标的函数库PortfolioAnalytics—用于构建和分析金融投资组合的函数库ROI、ROI.plugin.glpk、ROI.plugin.quadprog、quadprog—用于优化的库
从PerformanceAnalytics库中，可以加载包含 13 种工具的财务回报的样本数据集:
# Load sample return data from the PerformanceAnalytics library
lookback <- 120 # lookback in months
returns <- tail(PerformanceAnalytics::edhec, lookback)
我们选择使用过去十年的回报数据来进行投资组合优化，从而假设不久的将来会像过去十年一样。对于投资组合，我们希望只进行长期投资(投资正金额)，完全投资(投资整个预算)投资组合，以最小化风险。最小化的风险度量是 ETL(预期尾部损失/风险条件价值/执行短缺)——一种具有理想财务属性的风险度量。如果你不熟悉这个指标，就假设它相当于收益的标准差。如果投资组合的价值波动很大，风险就大。以下代码创建要优化的投资组合对象:
# Create portfolio object
names_funds <- colnames(returns)
port.obj <- PortfolioAnalytics::portfolio.spec(assets = names_funds)
port.obj <- PortfolioAnalytics::add.constraint(portfolio = port.obj,
type = "full_weight")
port.obj <- PortfolioAnalytics::add.constraint(portfolio = port.obj,
type="long_only")
port.obj <- add.objective(portfolio=port.obj,
type='risk',
name='ETL',
arguments=list(p=0.95))
现在，为了计算有效边界，有必要知道从给定的工具领域构建的投资组合可以实现的最大预期回报和最小风险:
# Define maximum achievable return
ER_assets <- colMeans(returns)
ER_assets_max <- max(ER_assets)# Calculation of return of minimum risk portfolio
weights_ES_min <- PortfolioAnalytics::optimize.portfolio(
R = returns,
portfolio = port.obj,
optimize_method = "ROI",
trace = FALSE)$weights
ER_ES_min <- sum(weights_ES_min * ER_assets)# Vector of return targets
n_portfolios <- 500
return_targets <- seq(ER_ES_min,
ER_assets_max,
length.out = n_portfolios)
最大预期收益很容易找到，它就是回望期内平均收益最大的投资组合。由于分散效应，最小化风险的投资组合稍微复杂一些。我们通过求解优化问题找到投资组合，而无需指定回报目标，并计算该投资组合的预期回报。最后，定义最小值和最大值之间的 500 个等间距返回目标的向量。
对于这种多核优化，将再次使用foreach。然而，计算稍微复杂一些，因此将多核循环中的内容定义为函数是有益的。这使得指定输出等的格式变得简单。该函数定义如下:
# Write optimization function that returns exactly what we need.
optimise <- function(port.obj,
return_target) {
port.obj <- PortfolioAnalytics::add.constraint(
portfolio = port.obj,
type="return",
return_target = return_target)
out <- PortfolioAnalytics::optimize.portfolio(
R = returns,
portfolio = port.obj,
optimize_method = "ROI",
trace = FALSE)
return(c(out$weights, out$objective_measures$ETL))
}
优化功能将目标回报约束添加到我们的投资组合中，确定最佳投资组合，并以向量形式回报工具权重和风险。这是在foreach循环中实现的，与之前一样:
# Activate cluster for foreach library and pass libraries
cl <- parallel::makeCluster(detectCores())
doParallel::registerDoParallel(cl)time_foreach <- system.time({
data_frontier_par <- foreach::foreach(
i = 1:n_portfolios,
.combine = rbind,
.packages = c("PortfolioAnalytics")) %dopar% {
optimise(port.obj, return_targets[i])
}
})parallel::stopCluster(cl)
foreach函数将循环的索引作为输入，如何组合输出和循环中引用的库。定义这三个输入后，只需插入优化函数，500 次优化运行在 1.91 秒内完成。foreach的一个有用特性是，通过将%dopar%改为%do%，它可以被修改为在单核上运行。如果你有一个咄咄逼人的老板，需要一个借口去喝咖啡(或者如果你想对单核的计算时间进行基准测试)，这是一个很好的功能。在单核上，500 次优化运行在 5.05 秒内完成——这一次，并行化并没有使我们的运行时间减少 75%。这是因为将库加载到所有四个核心上需要时间。由此产生的有效边界看起来如下:
每单位风险的最佳回报可能是 3% ETL 左右，但选择哪个投资组合取决于你。沿着边界的所有投资组合都给出了其风险量的最优回报，因此可以被理性的投资者选择。
结论
我希望这篇文章能让你并行运行 R 脚本，从而帮助你加快速度！随着 CPU 性能向更多内核而不是更高频率发展，不利用并行化将是一种浪费。在 R 中，只需在正确的位置添加几行代码，您的计算速度就可以提高数倍。
评论
本文中的代码运行在 Windows 系统上。对于 Linux 或 Mac，考虑用mclapply替换parLapply。可能需要更多的修改。
参考
PyPy 入门
使用 PyPy 启动并运行，PyPy 是使用 JIT 编译的 CPython 的替代方案。
Python 编程语言是一种可以用多种方式实现的接口。一些例子包括使用 C 语言的 CPython，使用 Java 实现的 Jython 等等。
尽管是最流行的，CPython 并不是最快的。PyPy 是另一种 Python 实现，既兼容又快速。PyPy 依赖于实时(JIT)编译，这大大减少了长时间运行操作的执行时间。
在本教程中，将为初学者介绍 PyPy，以突出它与 CPython 的不同之处。我们还将讨论它的优点和局限性。然后我们将看看如何下载并使用 PyPy 来执行一个简单的 Python 脚本。PyPy 支持数百个 Python 库，包括 NumPy 。
具体来说，本教程涵盖以下内容:
- CPython 的快速概述
- PyPy 及其特性介绍
- PyPy 限制
- 在 Ubuntu 上运行 PyPy
- PyPy 与 CPython 的执行时间
让我们开始吧。
由 https://unsplash.com/photos/95YRwf6CNw8克莱门特 H : 改编自 Unsplash
CPython 的快速概述
在讨论 PyPy 之前，了解 CPython 的工作原理是很重要的。我上一篇名为用 Cython 提升 Python 脚本的教程详细介绍了 CPython 的工作原理，但是在这里快速回顾一下要点也无妨。下面你可以看到一个使用 CPython 实现的 Python 脚本的执行管道的可视化。
给定一个 Python .py脚本，首先使用 CPython 编译器将源代码编译成字节码。字节码被生成并保存在扩展名为.pyc的文件中。然后在虚拟环境中使用 CPython 解释器执行字节码。
使用编译器将源代码转换成字节码有很多好处。如果不使用编译器，那么解释器将通过逐行翻译成机器码来直接处理源代码。这样做的缺点是必须应用一些过程来将源代码的每一行翻译成机器代码，并且这些过程将对每一行重复。例如，语法分析将独立于其他行应用于每一行，因此解释器需要花费大量时间来翻译代码。编译器解决了这个问题，因为它能够一次处理所有代码，因此语法分析将只应用一次，而不是应用于每一行代码。因此，编译器生成的字节码很容易解释。注意，编译整个源代码在某些情况下可能没有帮助，我们将在讨论 PyPy 时看到一个明显的例子。
字节码生成后，由运行在虚拟机上的解释器执行。虚拟环境是有益的，因为它将 CPython 字节码与机器隔离开来，从而使 Python 跨平台。
不幸的是，仅仅使用编译器来生成字节码不足以加速 CPython 的执行。解释器的工作原理是每次执行代码时，将代码翻译成机器代码。因此，如果一个行L需要X秒来执行，那么执行它 10 次将会有X*10秒的开销。对于长时间运行的操作，这在执行时间上代价太高。
基于 CPython 的弊端，我们现在来看看 PyPy。
PyPy 及其特性介绍
PyPy 是一个类似于 CPython 的 Python 实现，既兼容又快速。“兼容”意味着 PyPy 与 CPython 兼容，因为您可以在 PyPy 中使用几乎所有的 CPython 语法。有一些兼容性的差异，如这里提到的。PyPy 最强大的优势就是速度。PyPy 比 CPython 快很多；稍后我们将看到 PyPy 执行速度快 7 倍的测试。在某些情况下，它甚至可能比 CPython 快几十倍或几百倍。那么 PyPy 是如何实现它的速度的呢？
速度
PyPy 使用实时(JIT)编译器，能够显著提高 Python 脚本的速度。CPython 中使用的编译类型是超前的(AOT)，这意味着所有的代码在执行之前都会被转换成字节码。JIT 只是在运行时翻译代码，只是在需要的时候。
源代码可能包含根本不执行的代码块，但这些代码块仍在使用 AOT 编译器进行翻译。这导致处理时间变慢。当源代码很大并且包含数千行时，使用 JIT 会有很大的不同。对 AOT 来说，整个源代码都需要翻译，因此需要很多时间。对于 JIT，只执行代码中需要的部分，这样速度会快很多。
PyPy 翻译了一部分代码后，就会被缓存。这意味着代码只被翻译一次，以后再使用。每次执行代码时，CPython 解释器都要重复翻译，这也是它运行缓慢的另一个原因。
容易的
PyPy 不是提升 Python 脚本性能的唯一方法，但却是最简单的方法。例如，Cython 可以用来提高向变量分配 C 类型的速度。问题是 Cython 要求开发人员手动检查源代码并进行优化。这很烦人，而且随着代码大小的增加，复杂性也在增加。当使用 PyPy 时，您只需更快地运行常规 Python 代码，无需任何努力。
无栈
标准 Python 使用 C 栈。这个堆栈存储相互调用的函数序列(递归)。因为堆栈的大小是有限的，所以函数调用的次数也是有限的。
PyPy 使用了无栈 Python ，这是一个不使用 C 栈的 Python 实现。相反，它将函数调用存储在对象旁边的堆中。堆的大小大于栈的大小，因此你可以做更多的函数调用。
无栈 Python 也支持微线程，比普通的 Python 线程要好。在单个无堆栈 Python 线程中，您可以运行数千个任务，称为“小任务”，所有这些任务都在同一个线程上运行。
使用微线程允许运行并发任务。并发意味着两个任务通过共享相同的资源同时工作。一个任务运行一段时间，然后停下来为第二个任务腾出空间。请注意，这与并行不同，并行涉及同时单独运行两个任务。
使用微线程减少了创建的线程数量，从而减少了操作系统管理所有这些线程的开销。因此，通过在两个线程之间交换来加速执行比在两个微线程之间交换更耗时。
使用无堆栈 Python 也为实现延续打开了大门。延续允许我们保存任务的状态，并在以后恢复它以继续它的工作。注意，无栈 Python 与标准 Python 没有什么不同；它只是增加了更多的功能。标准 Python 中可用的一切也将在无堆栈 Python 中可用。
在讨论了 PyPy 的好处之后，我们在下一节讨论它的局限性。
PyPy 限制
虽然您可以在任何机器和任何 CPU 架构上使用 CPython，但是 PyPy 的支持相对有限。
以下是 PyPy ( 来源)支持和维护的 CPU 架构:
- x86 (IA-32)和 x86_64
- ARM 平台(ARMv6 或 ARMv7，带 VFPv3)
- AArch64
- PowerPC 64 位，小端和大端
- 系统 Z (s390x)
PyPy 不能在所有的 Linux 发行版上工作，所以你必须小心使用一个受支持的版本。在不受支持的发行版上运行 PyPy Linux 二进制文件将会返回错误。PyPy 只支持 Python 2 和 Python 3 的一个版本，分别是 PyPy 2.7 和 PyPy 3.6。
如果在 PyPy 中执行的代码是纯 Python，那么 PyPy 提供的速度通常是显而易见的。但是如果代码包含 C 扩展，比如 NumPy，那么 PyPy 实际上可能会增加时间。PyPy 项目正在积极开发中，因此将来可能会为 C 扩展提供更好的支持。
许多流行的 Python 框架都不支持 PyPy，比如 Kivy。Kivy 允许 CPython 在所有平台上运行，包括 Android 和 iOS。这意味着 PyPy 不能在移动设备上运行。
现在我们已经看到了 PyPy 的优点和局限性，让我们来看看如何在 Ubuntu 上运行 PyPy。
在 Ubuntu 上运行 PyPy
您可以在 Mac、Linux 或 Windows 上运行 PyPy，但是我们将讨论在 Ubuntu 上运行它。再次提及 PyPy Linux 二进制文件仅在特定的 Linux 发行版上受支持是非常重要的。您可以在这个页面上查看可用的 PyPy 二进制文件及其支持的发行版。例如，PyPy(Python 2.7 或 Python 3.6)仅支持 Ubuntu 的三个版本:18.04、16.04 和 14.04。如果你有最新版本的 Ubuntu(19.10)，那么你不能在上面运行 PyPy。尝试在不受支持的发行版上运行 PyPy 将返回以下错误:
pypy: error while loading shared libraries ...
我只是简单的用一个虚拟机运行 Ubuntu 18.04。
PyPy 二进制文件以压缩文件的形式出现。你需要做的就是解压你下载的文件。在解压缩的目录中有一个名为bin的文件夹，在其中可以找到 PyPy 可执行文件。我使用的是 Python 3.6，因此这个文件被命名为pypy3。对于 Python 2.7，只是叫pypy。
对于 CPython，如果想从终端运行 Python 3，只需输入命令python3。要运行 PyPy，只需发出命令pypy3。
在终端中输入pypy3命令可能会返回Command 'pypy3' not found消息，如下图所示。原因是 PyPy 的路径没有添加到 path 环境变量中。实际运行的命令是./pypy3，考虑到终端的当前路径在 PyPy 的bin目录中。点.表示当前目录，添加/是为了访问当前目录中的内容。发出./pypy3命令成功运行 Python，如下所示。
现在，您可以像往常一样使用 Python，充分利用 PyPy 的优势。例如，我们可以创建一个简单的 Python 脚本，对 1，000 个数字求和，并使用 PyPy 执行它。代码如下。
nums = range(1000)
sum = 0
for k in nums:
sum = sum + k
print("Sum of 1,000 numbers is : ", sum)
如果这个脚本被命名为test.py，那么您可以简单地使用下面的命令运行它(假设 Python 文件位于 PyPy 的bin文件夹中，这与pypy3命令的位置相同)。
./pypy3 test.py
下图显示了执行前面代码的结果。
PyPy 与 CPython 的执行时间
为了比较 PyPy 和 CPython 对 1，000 个数字求和的运行时间，代码被更改为测量时间，如下所示。
import timet1 = time.time()
nums = range(1000)
sum = 0
for k in nums:
sum = sum + k
print("Sum of 1,000 numbers is : ", sum)
t2 = time.time()
t = t2 - t1
print("Elapsed time is : ", t, " seconds")
与 CPython 的0.0002秒相比，PyPy 的时间接近0.00045秒(我在我的 Core i7-6500U 机器上运行代码@ 2.5GHz)。在这种情况下，与 PyPy 相比，CPython 花费的时间更少，这是意料之中的，因为这个任务实际上不是一个长时间运行的任务。如果代码改为添加 100 万个数字，而不是 1000 个，那么 PyPy 将最终获胜。在这种情况下，Pypy 需要0.00035秒，CPython 需要0.1秒。PyPy 的好处现在很明显。这应该让您了解 CPython 在执行长时间运行的任务时会慢多少。
本文原载于 Paperspace 博客 。你可以在渐变 上免费运行我的教程 的代码。
结论
本教程介绍了 PyPy，这是最快的 Python 实现。PyPy 的主要优点是它的实时(JIT)编译，它提供了对编译后的机器码的缓存以避免再次执行。PyPy 的局限性也得到了强调，主要的一点是它对于纯 Python 代码来说工作得很好，但是对于 C 扩展来说效率不高。
我们还看到了如何在 Ubuntu 上运行 PyPy，并比较了 CPython 和 PyPy 的运行时间，突出了 PyPy 对于长时间运行任务的效率。与此同时，对于短期运行的任务，CPython 仍可能击败 PyPy。在以后的文章中，我们将探索 PyPy、CPython 和 Cython 之间的更多比较。
Python 类入门
Python 中的面向对象编程
在计算机编程中，类是组织数据和函数的一种方便的方式，这样它们以后就易于重用和扩展。在这篇文章中，我们将介绍如何用 python 构建一个基础类。具体来说，我们将讨论实现表示 instagram 用户的类的示例。
我们开始吧！
首先，让我们定义一个代表 Instagram 用户的简单类。最初我们不会包含任何数据(属性)或函数(方法):
class Instagram_User:
pass
在面向对象编程中需要理解的两个重要概念是类和类实例。Instagram 平台的用户可以被视为“Instagram_User”类的一个实例。这里的区别是‘Instagram _ User’类作为创建 insta gram 用户的蓝图，而‘insta gram _ User’类的一个实例可能指的是一个特定的用户。为此，我们可以定义两个 Instagram 用户实例，insta_user_1 和 insta_user_2:
insta_user_1 = Instagram_User()
insta_user_2 = Instagram_User()
这些用户中的每一个都将是他们自己的 Instagram_User 类的唯一实例。我们可以打印这两个对象:
print("User Object 1: ", insta_user_1)
print("User Object 2: ", insta_user_2)
这里我们可以看到每个对象都有一个唯一的内存地址。接下来，我们可以为每个实例创建变量。让我们定义保存每个用户的用户名的实例变量:
insta_user_1.user_name = 'nychef100'
insta_user_2.user_name = 'worldtraveler123'
我们还可以定义每个用户的名称:
insta_user_1.name = 'Jake Cohen'
insta_user_2.name = 'Maria Lopez'
电子邮件地址:
insta_user_1.email = 'jcohen100@gmail.com'
insta_user_2.email = 'mlopez123@gmail.com'
最后，让我们定义一个实例变量，告诉我们每个用户是否有私人帐户:
insta_user_1.private = True
insta_user_2.private = False
现在，每个实例都有对每个用户唯一的属性值。让我们打印用户名:
print(insta_user_1.user_name)
print(insta_user_2.user_name)
理想情况下，我们希望为每个用户自动设置所有这些信息，而不是手动设置这些值。为了获得类的全部好处，我们应该定义一个方法，允许我们用手动定义的值初始化每个用户实例。初始化方法基本上是一个构造函数，将被称为“init ”:
class Instagram_User:
def __init__(self, user_name, name, email, private):
self.user_name = user_name
self.name = name
self.email = email
self.private = private
这里,“self”参数是实例，它允许我们在实例中共享属性信息。例如，当我们写下:
insta_user_1 = Instagram_User('nychef100', 'Jake Cohen', 'jcohen100@gmail.com', True)
insta_user_2 = Instagram_User('worldtraveler123', 'Maria Lopez', 'mlopez123@gmail.com', False)
每种情况下的“self”参数分别是 insta_user_1 和 insta_user_2 对象。如果我们打印电子邮件，我们会看到:
print(insta_user_1.email)
print(insta_user_2.email)
这允许我们用比手工定义属性少得多的代码来定义属性。现在假设我们想要对每个用户的属性执行一些操作。例如，我们可以定义一个方法来告诉我们一个用户是否有一个私人帐户。在我们的方法中，如果’ self.private '为真，我们打印“用户有一个私人帐户”，否则，我们打印“用户有一个公共帐户”:
def isPrivate(self):
if self.private:
print("{} has a Private Account".format(self.name))
else:
print("{} has a Public Account".format(self.name))
完整的脚本应该如下所示:
class Instagram_User:
def __init__(self, user_name, name, email, private):
self.user_name = user_name
self.name = name
self.email = email
self.private = private
def isPrivate(self):
if self.private:
print("{} has a Private Account".format(self.name))
else:
print("{} has a Public Account".format(self.name))
让我们使用 insta_user_1 实例调用该方法:
insta_user_1.isPrivate()
在 insta_user_2 上:
insta_user_2.isPrivate()
如您所见，由于“self”参数被传递给了“init”和“isPrivate”，因此在初始化时，“isPrivate”方法可以完全访问相应实例的属性。
我将在这里停下来，但是您可以随意摆弄代码。例如，您可以尝试定义 Instagram_User 类的几个额外的用户实例。在那里，您可以练习提取实例属性并使用类方法“isPrivate”。一旦你觉得舒服了，我鼓励你定义额外的类方法。一个有趣的方法是显示用户指标，比如关注者数量、用户关注的人数和帖子数量。
结论
总之，在这篇文章中，我们讨论了用 python 定义类的基础。我们展示了如何定义类的实例、初始化实例、访问实例属性以及用方法操作属性。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
PyTorch 入门
关于如何使用 PyTorch 进行数据分析和推断的实践演练。
伊霍尔·马里茨基在 Unsplash 上拍摄的照片
介绍
PyTorch 是目前发展最快的深度学习 Python 框架之一。事实上，这个库最初主要由研究人员使用，以创建新的模型，但由于最近的进步，它也引起了许多公司的兴趣。对该框架感兴趣的一些原因是:
- GPU 优化的张量计算(类似矩阵的数据结构)使用非常类似 Numpy 的接口，以便于采用。
- 使用自动微分的神经网络训练(跟踪发生在张量上的所有操作并自动计算梯度)。
- 动态计算图(使用 PyTorch，不需要像在 Tensorflow 中那样为了运行模型而首先定义整个计算图)。
PyTorch 可以按照文档说明免费安装在任何操作系统上。组成该库的一些主要元素是:
- 自动签名 模块:用于记录在张量上执行的操作，并反向执行这些操作以计算梯度(该属性对于加速神经网络操作和允许 PyTorch 遵循命令式编程范例非常有用)。
- Optim 模块:用于方便地导入和应用各种神经网络训练的优化算法，如 Adam、随机梯度下降等…
- nn 模块:提供一组函数，可以帮助我们快速逐层设计任何类型的神经网络。
示范
在本文中，我将带您通过一个实际的例子来开始使用 PyTorch。本文中使用的所有代码(以及更多！)可以在我的 GitHub 和 Kaggle 账户上使用。对于这个例子，我们将使用澳大利亚Kaggle Rain数据集来预测明天是否会下雨。
导入库
首先，我们需要导入所有必需的库。
数据预处理
对于这个例子，我们将重点使用 RISK_MM 和 Location 指标作为我们的模型特征(图 1)。将数据划分为训练集和测试集后，我们可以将 Numpy 数组转换为 PyTorch 张量，并创建一个训练和测试数据加载器，以便将数据输入到我们的神经网络中。
图 1:简化的数据帧
系统模型化
此时，使用 PyTorch nn 模块，我们就可以设计我们的人工神经网络(ANN)了。在 PyTorch 中，神经网络可以定义为由两个主要函数构成的类: inti() 和 forward() 。
在 inti() 函数中，我们可以设置我们的网络层，而在***【forward()函数中，我们决定如何将我们网络的不同元素堆叠在一起。这样，只需在【forward()***函数中添加打印语句，就可以相对容易地进行调试和试验，以便在任何时间点检查网络的任何部分。
此外，PyTorch 还提供了一个顺序接口，可以使用该接口以类似于使用 Keras Tensorflow API 构建模型的方式来创建模型。
在这个简单的网络中，我们将 50 个特征作为输入，因为我们之前使用 Pandas get_dummies() 功能将输入分类变量转换为虚拟/指示变量。因此，我们的网络将由 50 个输入神经元、20 个神经元的隐藏层和单个神经元的输出层组成。隐藏层的大小当然可以变化，并且可以很容易地添加更多的隐藏层，但是考虑到可用的数据量有限，这可能会导致过度拟合我们的数据的风险。将连续图层堆叠在一起时，我们只需确保一个图层的输出要素数量等于连续图层的输入要素数量。
一旦实例化了我们的模型，我们就可以打印出网络架构。
ANN(
(fc1): Linear(in_features=50, out_features=20, bias=True)
(fc2): Linear(in_features=20, out_features=1, bias=True)
)
神经网络训练
我们现在终于准备好训练我们的模型了。在下面的代码片段中，我们首先将二元交叉熵定义为我们的损失函数，将 Adam 定义为模型参数的优化器。最后，我们创建一个 7 次迭代的训练循环，并存储一些关键的度量参数，如每次迭代的总损失和模型精度。
Epoch: 0, Loss: 294.88, Accuracy: 0.13%
Epoch: 1, Loss: 123.58, Accuracy: 6.31%
Epoch: 2, Loss: 62.27, Accuracy: 28.72%
Epoch: 3, Loss: 35.33, Accuracy: 49.40%
Epoch: 4, Loss: 22.99, Accuracy: 64.99%
Epoch: 5, Loss: 16.80, Accuracy: 71.59%
Epoch: 6, Loss: 13.16, Accuracy: 74.13%
正如图 2 所总结的，我们的模型成功地实现了良好的准确性，而没有过度拟合原始数据的风险(训练损失和准确性都即将达到平稳状态)。还可以通过实现训练/验证分割来训练我们的模型并调整其参数来进一步验证这一点(如本 GitHub 笔记本所示)。
图 2:培训报告
估价
最后，我们现在可以创建第二个循环来针对一些全新的数据测试我们的模型(为了确保我们的模型不再是训练模型，而是仅用于推理，请注意 model.eval() 语句)。
Test Accuracy: 74.66 %
从打印输出可以看出，我们的模型测试精度与我们的最终训练精度非常匹配(74.66 %对 74.13%)。
结论
如果您有兴趣了解 PyTorch 的更多潜力，PyTorch Lighting和 Livelossplot 是两个很棒的软件包，可以帮助您开发、调试和评估您的 py torch 模型。
希望您喜欢这篇文章，感谢您的阅读！
联系人
如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:
R 入门
https://www.r-project.org/logo/、知识共享署名-共享 4.0 国际许可 (CC-BY-SA 4.0)
我学过的第一门编码语言是 R，我很快就学会了，在学习 python 的同时，我的 R 知识绝对对我有帮助。我发现 R 和 python 在法语和意大利语方面很相似——虽然肯定有差异，但它们有很多共同点。为了庆祝 R 4 . 0 . 3 版本(标题惊人地叫“兔子-温尼斯怪胎”)在周六发布，我为 R 编译了一些我最喜欢的资源，以及一些额外的非语言特定但有用的资源。所有这些资源不仅精彩，而且免费！我希望你和我一样觉得它们很有帮助！
首先，我们有 R 本身，可以在 R:统计计算的 R 项目找到。如果你不知道的话，R 是免费的，而且是非常强大的统计和编码软件。要安装，进入 CRAN 页面，选择离你最近的位置。r 适用于所有三个主要系统；Mac、Windows 和 Linux。r 很棒，但是使用它最简单的方法是同时获得…
RStudio ！
RStudio 是一个集成开发环境，简称 IDE。和 R 一样，是免费的。基本上，如果 R 是打字机，RStudio 就是文字处理器。它使生活变得容易得多；使用 RStudio，您可以编辑代码、运行单个代码块、在语法不正确(最常见的错误来源之一)时获得警告、利用软件包(稍后将详细介绍)以及轻松访问帮助页面。可以在这里下载；只需选择“下载 RStudio 桌面”。RStudio 有在线版本，但这些都有相关费用。
Donny Jiang 在 Unsplash 上的照片
继续包装！R 有超过 10，000 个软件包，我可以写多篇文章。开始时，有几个特别有助于展示。
首先是 tidyverse 。即使你从未用过 R，你也可能听说过 tidyverse。这一组核心包是我日常使用的包。tidyr(用于数据清理)、dplyr(用于数据操作)、ggplot2(用于漂亮的可视化)、hms 和 lubridate(用于任何日期或时间数据)等等，将是你开始的基础。这应该是您在 R 和 RStudio 之后的第一次安装。100/10.
漩涡很优秀，因为它教你如何使用 R，在 R 。一旦你加载并打开了这个包，你可以从各种教程中选择，甚至从 GitHub 库下载额外的课程。这是让你熟悉 r 的一个很棒的方法。唯一的警告是，swirl 只在控制台上运行，并且不是非常 RStudio 笔记本友好。我仍然建议在 RStudio 的控制台中使用它，这只是需要注意的一点。如果你刚开始学 R，你需要这个包。
最后两个是相当基本的，但同样有用。 Stats 包含基本的统计功能，而 datasets 有数据集供您在入门时使用。
Hadley Wickham 和 Jennifer Bryan 的书 R Packages 也有助于找到适合你需求的特定软件包，Google 也是如此。说到这里，让我们继续看书吧！
R for Data Science :可视化、建模、转换、整理和导入数据，作者 Garrett Grolemund 和 Hadley Wickham
它有一步一步的问题，以一种非常自然和可理解的方式进行，并且在大多数部分的结尾还有额外的练习。这本书可以教授 r 的基础知识。如果你正在寻找一种传统的方法，这是一个很好的选择——我们在我的大学统计学课程中使用过这本书。
R for Data Science:Exercise Solutions，作者 Jeffrey B. Arnold &供稿
这本书是 R for Data Science 的非正式指南，包含了 R for Data Science 中练习的示例解决方案。这可能非常有帮助，但是，需要注意的是，一些解决方案可能过于复杂，或者使用尚未涉及的策略，如果您正在按顺序学习 R for Data Science 的话。不过，它是免费的，当你真的被难住的时候，它是一个有用的资源。
数据可视化的基础知识:制作信息丰富和引人注目的图表的初级读本，作者克劳斯·威尔基
数据可视化圣经。是优秀的。它很好地分解了数据可视化的基础，并专注于主要原则，同时也解释了可视化的利弊。我每周至少送一次这本书给某人。这是一个相当快速的阅读，并且这本书的在线版本很容易搜索，以找到你想要参考的确切图表或数字。100000/10.我想要一本实体的作为生日礼物。
最后，最后但同样重要的是今天！TidyTuesday 是每周一次的数据科学和可视化挑战赛，它提供了清理、管理和可视化大型数据集的良好实践。当你厌倦了 R datasets 包时，过去的数据集也是很好的资源，因为它是开源的，所以浏览别人的代码，看看他们清理和可视化的方法会很有帮助。
情感分析入门
自然语言处理笔记
自然语言处理专业课程 1 第 1 周笔记
在我的前两个帖子之后，我认为我们有必要开始一条新的道路。我们将一起浏览自然语言处理中的基本概念，作为新手的起步，并提醒长期从业者决定阅读的时间——从情感分析开始。
注:这个系列的帖子将由我从 Coursera 上的自然语言处理专业中摘掉的笔记创建，我添加了额外的东西，因为我认为它很有用。
前两个帖子:
最近，一个特别的话题在我和朋友的讨论中反复出现。品牌的重要性！我…
towardsdatascience.com](/the-importance-of-branding-in-data-science-467b2d2b1e7f) [## 从长远来看，专业化的“数据科学家”将会胜出
成为专家会比成为多面手让你走得更远
towardsdatascience.com](/the-specialized-data-scientist-will-win-in-the-long-run-22c47342aa00)
在我们笔记中给出的例子中，我们打算用逻辑回归模型来拟合我们的特征。我不会深入研究逻辑回归的内部工作原理，但是如果你非常感兴趣，你可以从头开始阅读“ 算法:逻辑回归 ”。
与普遍的看法相反，我在此声明，逻辑回归不是一个分类算法(就其本身而言)…
towardsdatascience.com](/algorithms-from-scratch-logistic-regression-7bacdfd9738e)
情感分析
情感分析的目标是使用自然语言处理和机器学习来解释和分类主观数据。
随着世界变得更加数字化，情绪分析在今天的商业中是一项非常重要的技能，自新冠肺炎以来更是如此。许多企业采用情感分析来检测社会数据，更好地了解他们的品牌声誉，了解他们在数字世界中的客户。
例如，一个企业(或任何人)可能会决定使用情感分析来自动确定关于他们公司(或任何东西)的推文的极性，以便更好地了解他们品牌的声誉；这个任务可以定义为一个监督学习问题，我们将输入特征输入到一个预测模型中，然后得到一个输出。
图 1 :情感分析问题
为了让我们执行情感分析，我们必须首先将我们的文本表示为特征(我们在图 1 中表示为 X)，因为计算机不理解文本，在我们可以使用它来分类文本之前。
那么，**我们如何提取特征呢？**很棒的问题。方法有很多。然而，在我们提取我们的特征并建立逻辑回归模型来分类我们数据的情感之前，我们必须讨论文本预处理。
文本预处理
互联网上的文本通常被定义为非结构化数据——非结构化数据是没有预定义的数据模型或者没有以预定义的方式组织的信息(来源:维基百科)。因此，文本预处理就是将我们的文本组织成预定义的方式或预定义的数据模型。
有各种各样的技术可以用来预处理我们的文本，但是在这篇文章中，我们将主要关注其中的几种；
小写
这可能是最简单的文本预处理形式，我们可以确保所有的文本都是小写的。这种技术适用于许多文本挖掘和自然语言处理任务，当数据集很小时，这种技术非常有用。
图 2 :小写示例
值得注意的是，尽管小写通常是一种标准做法，但在某些情况下，保持大写是很重要的。
词干
当我们“词干”一个词形变化——在语言形态学中，词形变化是一个构词的过程，在这个过程中，一个词被修饰以表达不同的语法范畴，如时态、格、语态、体、人称、数、性别、语气、动物性、确定性(来源: 维基百科 )。例如，who 变成了 who 的——我们把它简化为词根形式。
有许多不同的词干提取算法，但是最常见和最有效的英语词干提取算法是 Porters 算法。
图 3 :用 PorterStemmer 在 Python 中进行词干分析
词干通常对处理稀疏性和/或标准化词汇很有用。
词汇化
词汇化通常是指使用词汇和单词的形态学分析来正确地做事情，通常旨在仅删除屈折词尾，并返回单词的基本形式或字典形式，这被称为词汇(来源:Stanford NLP Group)。
简单地说，词汇化旨在消除词尾变化，并以适当的方式将单词映射到其词根。
图 4 :使用 WordNetLemmatizer 的词汇化示例
注意:不要犯交替使用词干化和词汇化的错误——词汇化会对单词进行词法分析。
停用词
停用词是语言中的常用词。这些词通常被认为是对文本没有任何意义的词(它们不重要)，因此我们要把它们去掉。
图 5:NLTK 中的停用词列表
删除停用词并不总是有效的策略。在某些情况下，移除停用词往往是有用的，例如主题提取，但在各种分类任务中，我们可以通过保留停用词来获得有用的见解。
正常化
在文本可能有很多噪音的环境中，例如 twitter 和文本消息，规范化文本往往是一个重要但被忽视的步骤——我所说的噪音环境是指非正式很常见的地方。当我们规格化文本时，我们将文本转换成标准形式(即 nvm 变成 nevermind)。
图 6: 文本的规范化(来源:Kavita Ganesan—关于 NLP 和机器学习的文本预处理你需要知道的一切
文本规范化与词干化和词条化一样，没有标准的方法。这完全取决于手头的任务，因为我们不会像标准化讲课笔记那样标准化我们的短信(考虑到我们以非标准的方式记笔记)。
噪声去除
噪音会严重干扰我们的文本分析。例如，tweets 通常包含各种各样的特殊字符，当我们做进一步的预处理步骤时，这些字符可能会损害我们的结果。
图 7 :去噪前的词干处理与去噪后的词干处理—原始图片来自卡维塔·加内桑 — 关于自然语言处理和机器学习的文本预处理，你需要知道的一切
有各种形式的噪音要从我们的文本中去除；
- 特殊字符
- 数字
- 超文本标记语言
- 特定领域关键词(例如，RT 表示 Twitter 上的转发)
- 其他(还有很多)
我们移除哪些是领域特定的，哪些被确定为我们手头任务的“噪声”。
注:关于文本预处理的更多内容，我强烈推荐你阅读 Kavita Ganesan 的《 关于自然语言处理和机器学习的文本预处理 》。
特征提取
在将文本传递给逻辑回归模型之前，我们必须首先将文本表示为一个向量。我们有许多方法将文本表示为向量，但是对于我们的任务(情感分析)，我们将看两个向量表示；
- 一个热编码
- 正负频率
一键编码
为了做到这一点，我们必须创造一个词汇。这可以通过从我们的数据中的每一条推文中创建一个独特的单词列表来实现。
图 8 :创建词汇表我们检查每条推文的每个单词，并向词汇表 V 添加单词，前提是该单词不在我们的词汇表中。
为了提取特征，我们提取一条推文，并将其标记为“1 ”,以表明我们词汇表中的单词出现在推文中，如果我们词汇表中的单词没有出现在推文中，则标记为“0 ”,参见图 9。
图 9 :获取一条推文，并显示该推文在被应用一热编码后的特征向量。
由于我们的 tweet 的向量长度为 V(我们数据集中所有唯一的单词)，并且对于我们选择显示的特定 tweet，它们只有 5 个值为 1 的特征(“我讨厌去上学”)，但有许多 0(长度为 V-5)，我们有所谓的稀疏向量表示，简单地说就是我们有大量的零，因此我们占用了不需要的空间来存储零。
如果我们在我们的稀疏表示上训练我们的逻辑回归模型，我们的模型将不得不学习 n + 1(对于偏差)个参数，其中 n 等于我们的词汇的大小 V。随着 V 变得越来越大，我们将面临两个主要问题；
- 训练模型需要很长时间
- 推理时间长
正&负频率
克服稀疏表示问题的一种技术是将向量转换为正负频率计数。更具体地说，给定一个单词，我们想要跟踪该单词在正面类中出现的次数，给定另一个单词，跟踪该单词在负面类中出现的次数。有了这些计数，我们可以提取特征，并将它们用作 Logisitc 回归模型的输入特征。
为了执行正负频率技术，我们必须首先创建一个频率字典——频率字典只是给定目标标签的单词计数的映射。例如，我们有自己的词汇，我们计算一个词在正面推文中出现的次数，我们对负面推文也这样做。
图 10 :单词词典
为了将这转化为一个特征，我们简单地对推文中的每个词取正频率之和，然后取负频率之和——见图 11 。
图 11 :对于每条推文，输入特征将是【偏差，正词频，负词频】。
因此，我们有一个直观的例子，我们将以 tweet“我很难过，我不高”为例(因此Xm=“我很难过，我不高”)。在图 5 中，我们可以看到单词在整个数据集中出现的频率，分为正类和负类，因此我们所要做的就是获取我们的 tweet，并计算每个单词出现的次数——参见图 12 。
图 12 :提取推文“我很难过，我不高”的特征
因此，我们的逻辑回归模型的输入特征将是[1(偏差)，4 (PostiveWordCount)，10 (NegativeWordCount)]。
包裹
通过这篇文章，你现在知道了各种预处理方法和两种提取特征的方法，我们可以将这些特征传递给一个逻辑回归模型。实践今天所学内容的一个好方法是在真实数据上尝试。
让我们继续 LinkedIn 上的对话:
[## Kurtis Pykes -人工智能作家-走向数据科学| LinkedIn
在世界上最大的职业社区 LinkedIn 上查看 Kurtis Pykes 的个人资料。Kurtis 有一个工作列在他们的…
www.linkedin.com](https://www.linkedin.com/in/kurtispykes/)
Python 中的捕捉工具箱入门
SentiNel 应用程序，通常称为 SNAP，是一个适应性很强的开源软件，用于对地球观测卫星数据进行科学探索。
美国地质勘探局在 Unsplash 上拍摄的照片
SNAP 由欧洲航天局(ESA)开发，是一个支持哨兵任务的通用软件平台。它由几个模块组成，可以修改并重新用于地球观测卫星数据的图像处理、建模和可视化。SNAP 不仅可用作哨兵任务(哨兵 1、哨兵 2 和哨兵 3)的研究支持工具，还可用作有效处理大量卫星数据的功能出口，包括来自 Landsat、MODIS 和 RapidEye 等其他任务的各种不同格式的数据。SNAP 的项目页面和各个工具箱可以在 http://step.esa.int找到。
在本文中，我想一步一步地介绍配置 python 安装以使用 SNAP-Python 或“ snappy ”接口的过程。这样做将允许您通过使用 python 脚本自动执行图像处理任务来高效地分析大量卫星数据。
本文将涵盖以下主题:
- 在 Windows 上下载并安装最新的 SNAP 版本(7.0 版)，
- 在快照安装过程期间和之后配置 snappy，
- 建立一个虚拟环境，
- 为 snappy 和配置最佳设置
- 使用 snappy 可视化卫星数据
下载快照工具箱
捕捉由几个工具箱组成。您可以单独安装每个工具箱，也可以安装一体化版本。在本教程中，我们将安装后者。
快照工具箱可以从下面的链接下载:https://step.esa.int/main/download/snap-download/
创建虚拟环境
在你应该在你的系统上安装 SNAP 软件之前，我建议你使用 pip 或者 conda 创建一个虚拟环境。对于本教程，我们将使用 conda。要运行这个命令，您需要在系统上安装 Anaconda 或 Miniconda。
通过在系统的 python 配置命令行工具上执行以下命令，使用 python 2.7 版创建一个名为“snap”的新虚拟环境。
conda create -n snap python=2.7
我们使用 python 2.7 版本的原因是因为 SNAP 软件仅支持 python 2.7、3.3 和 3.4 版本。
注意:如果你使用 pip 来创建一个新的环境，你必须安装 venv 包。点击了解更多关于如何使用 venv 创建虚拟环境的信息。
卡扣安装
接下来，我们可以使用下载的可执行文件开始安装快照软件。
您可以将 python 安装配置为在快照安装期间使用 snappy，方法是选中复选框并提供 python 目录的路径(如下所示)。然而，在本教程中，我们将而不是检查复选框并在 SNAP 安装完成后配置 snappy。
安装过程的其余部分非常简单。第一次启动 SNAP 时，它会进行一些更新。完成后，您就可以开始使用快照软件了。
配置爽快的
snap 安装完成后，我们希望获得虚拟环境“SNAP”所在的目录位置。从这里开始，我们需要以下两条路径:
- 虚拟环境的 Python 可执行路径
- 虚拟环境目录中名为“Lib”的文件夹
打开作为 SNAP 软件一部分安装的 SNAP 命令行工具，并运行以下命令:
snappy-conf {path_to_snap_env}\python.exe {path_to_snap_env}\Lib\
更改可用 RAM 的数量
在我们开始使用 snappy 创建 python 脚本之前，我们需要做一些改变，以确保 snappy 操作符以最高的最优性运行。如果您计划进行一些图像渲染和批处理操作，默认设置会非常慢。如果您想使用 snappy 来自动化繁重的处理任务并处理多个文件，这一点很重要。
转到{ virtual _ env " snap " directory } > Lib > snappy。
打开名为“ snappy.ini”的 snappy 配置文件。
编辑名为" j ava_max_mem" 的参数值，并将其设置为相当于系统 RAM 70–80%的值。
java_max_mem: 26G
在同一个目录中，有一个名为“ jpyconfig.py”的文件。C 更改参数" jvm_maxmem" 如下 :
jvm_maxmem = '26G'
改变磁贴缓存内存
接下来，导航到安装快照软件的位置。默认情况下，它设置为 C:\Program Files\snap。在其中，您会找到名为 etc 的文件夹，其中包含名为*“SNAP . properties”的快照属性文件。编辑文件并更改名为snap . jai . tile cachesize .*的参数，将其设置为等于 java_max_mem 值的 70–80%的值。您输入的数字应该以兆字节为单位。您可能需要启用管理员权限来保存对此文件的更改。
snap.jai.tileCacheSize = 21504
注:此处显示的值适用于 32GB 内存的系统。更改时必须考虑到系统的 RAM。
开始使用 Snappy
因此，对于最后一部分，我们想探索 snappy 是如何工作的，并可视化一些样本数据。在我们开始使用 snappy 之前，我们需要一些数据，在本教程中，我们将使用 snappy 安装预加载的测试数据。
# Import Librariesimport os
import numpy as np
import matplotlib.pyplot as plt
import snappy
from snappy import ProductIO# Set Path to Input Satellite Data# miniconda users
path = r'C:\Users\{User}\miniconda3\envs\snap\Lib\snappy\testdata'# anaconda users
path = r'C:\Users\{User}\anaconda3\envs\snap\Lib\snappy\testdata'filename = 'MER_FRS_L1B_SUBSET.dim'# Read File
df = ProductIO.readProduct(os.path.join(path, filename))# Get the list of Band Names
list(df.getBandNames())# Using "radiance_3" band as an example
band = df.getBand('radiance_3') # Assign Band to a variable
w = df.getSceneRasterWidth() # Get Band Width
h = df.getSceneRasterHeight() # Get Band Height# Create an empty array
band_data = np.zeros(w * h, np.float32)# Populate array with pixel value
band.readPixels(0, 0, w, h, band_data) # Reshape
band_data.shape = h, w# Plot the band
plt.figure(figsize=(18,10))
plt.imshow(band_data, cmap = plt.cm.binary)
plt.show()
“radiance_3”波段图
我还制作了一个视频，展示了我在这篇文章中列出的所有内容。因此，如果对如何在 Python 中安装和配置 SNAP Toolbox 有任何困惑，请务必查看。
附加资源
- Github 页面:【https://github.com/senbox-org
- 为 Python 配置 SNAP:https://senbox . atlassian . net/wiki/spaces/SNAP/pages/50855941/Configure+Python+to+use+the+SNAP-Python+snappy+interface
- 写这篇文章时有用的论坛讨论
下午好，我是一名新的欧空局学员，我想实施 S2-tbx/sen2cor 的一些过程到一个…
forum.step.esa.int](https://forum.step.esa.int/t/snappy-where-to-start/1463/7) [## 使用 python 脚本运行捕捉工具箱的进程
你好，我是 SNAP 工具箱的新用户。我已经在我的 windows 机器上安装了 SNAP 4.0。我目前正在使用快照桌面…
forum.step.esa.int](https://forum.step.esa.int/t/run-processes-of-snap-toolbox-using-python-script/3021/3)
TensorFlow 服务入门
将深度学习模型部署到生产中的简单高效的方法
TensorFlow 服务是 TensorFlow Extended(TFX)的一部分，它使将您的机器学习模型部署到服务器比以往任何时候都更加舒适。在 Google 发布 TensorFlow 服务之前，您的模型必须使用 Docker 部署到生产中。使用 Docker 来部署您的模型是乏味的、耗时的，并且容易出现许多错误。TensorFlow Serving 为我们提供了一个 API，可以使用 HTTP 请求调用该 API 在服务器上运行推理。在这篇博客中，我们将提供一个情感识别模型，并通过它了解 TensorFlow 服务的基础。
PS:我不会在这个博客中解释关于训练情绪识别模型的事情。我只会说为模特服务。你可以在这里找到训练情绪识别模型的要领。您可以在这里找到本地运行模型的存储库。
为什么要为模特服务？
一旦您训练了您的模型，它必须被部署到生产中以便可以使用。可以使用各种方法来部署模型，比如使用 TFlite 在手机上本地部署，使用 TFjs 在网站上部署，创建 docker 容器在云上部署模型，等等。TensorFlow 服务优于其他方法，原因如下。
- 使用 TensorFlow Serving 比使用 Docker 更容易部署您的模型，它可以节省您的时间并防止不必要的错误。
- 与 TFlite 或 TFjs 相比，更容易管理模型的不同版本。
- 当模型被更新时，所有的客户端将使用相同版本的模型，因此结果将是一致的。
- 由于模型将在服务器上运行，您可以使用强大的计算资源，如 GPU 或 TPUs 来更快地运行推理。
- 由于该模型由一个 API 提供服务，因此它可以由 TensorFlow 不支持的不同编程语言使用。
安装张量流服务
TensorFlow 服务可以使用 Docker、apt package installer for Linux 或 pip package manager 进行安装。在这篇博客中，我们将重点介绍如何使用 apt 和 pip 来安装 TensorFlow 服务。
在您的生产环境的终端中运行下面给出的代码，以安装 TensorFlow 服务。您可以使用 apt 软件包安装程序或 pip 软件包管理器。
安装 TensorFlow 服务
建立和服务您的模型。
一旦您训练、测试和验证了您的模型，就该为您的模型服务了。
步骤 1:指定模型的版本号，并使用 tf.keras.models.save_model()函数或 model.save()函数将模型保存到 tmp 目录中。
保存模型
步骤 2:模型将通过 bash 命令提供服务。为了让 bash 命令访问模型目录，需要将模型目录添加到环境中。
向环境中添加模型目录
第 3 步:既然模型已经保存，就可以开始服务了。运行下面给出的 bash 命令来服务模型。
为模型服务
第 4 步:既然已经为您的模型提供了服务，那么您可以使用 tail 命令来检查 server.log 文件。如果您在日志中发现“状态:成功:正常”行，则您的模型已被成功服务。
检查状态:成功:正常日志
使用 HTTP 请求在模型上运行推理
一旦您的模型被提供，就可以通过您定义的端口访问它。你的模型可以在任何地方使用；像 GCE、AWS lambda、AWS EC2、Google Colab、您本地计算机等云计算引擎。请注意，当您将模型部署到生产环境中时，在 Colab 或您的本地计算机上提供它没有多大意义。为了简单起见，我将在 Google Colab 上部署该模型。
您可以使用 HTTP 请求在服务模型上运行推理。发出 HTTP 请求后，服务器会将数据传递给模型，获取响应并将其发送回客户端。API 端点的输入是一个 JSON，其中嵌入了预处理过的图像。您可以使用请求库向 API 发出 HTTP 请求。
在调用 API 之前，必须对输入图像进行预处理。
图像预处理
图像经过预处理后，将图像嵌入到 JSON 中。这个 JSON 对象将是发送到 API 端点的数据。JSON 数据将有两项，“签名名”和“实例”“实例”项将包含列表形式的图像数据。
指定 API 请求的头，告诉端点 JSON 文件正在作为输入传递。使用 POST 方法从 API 端点请求，并将 URL、JSON 数据和头作为参数。API 将返回图像的预测。
来自服务模型的预测
这是模型的输出样本。
输出
结论
TensorFlow 服务使深度学习模型部署到生产中变得前所未有的简单。通过在模型中使用预处理图像的 lambda 层，可以避免对输入图像进行预处理。这使得调用 API 更加容易。
Python 文本分析入门
这是一个实用的循序渐进的教程，面向那些坚持使用 Excel 进行文本分析的数据分析师
因此，显然使用 MS Excel 处理文本数据是一件好事，因为你可以安装插件来创建字数统计和单词云，甚至可以进行情感分析。然而，我真的不知道为什么有人会这样做，如果存在免费的和不那么笨拙的工具——比如 Python。
我在之前的一篇文章中概述过，许多人不愿意学习编码，因为他们认为这很难，并且需要深入的数学知识。两者都不对。如果您可以在 Excel 中编写冗长而笨拙的函数，那么让我向您保证，Python 要简单得多，也更直观。此外，还有各种用于自然语言处理(NLP)的 Python 库，其中有大量的内置函数可以帮你完成繁重的工作。
在本文中，我想从 Python 中文本分析的基础开始。一些 Python 知识是必要的，所以我建议你看看我的前一篇文章，在这篇文章中，我给出了如何开始使用 Python 或 R 进行数据分析的技巧。这篇文章将是一个类似的格式。有大量关于如何开始使用 Python 学习 NLP 的教程和文章，其中一些我将在本文中链接到。但是，我想举一个实用的例子，说明如何处理您在日常工作中可能会遇到的真实文本数据。我想展示如何应用一些简单但强大的文本分析技术，以及如何解决您可能会遇到的问题。
我将从一个笔记本中给出一些代码示例，这个笔记本是我为一个想开始用 Python 进行文本分析的朋友创建的。整本笔记本在这里都有，如果你想翻一遍的话。这不是最令人兴奋的数据集，因为我试图找到一个公共数据集，类似于他在工作中必须分析的数据类型。该数据集包含 2019 年以来的美国铁路事故。
问正确的问题
与你在教程中分析的经过精心清理和格式化的数据集不同，真实世界的数据通常是杂乱和嘈杂的。例如，当导入美国铁路数据时，应该在一列中的事件文本不知何故出现在 15 列中。我不太清楚 MS Excel(已经很多年没用了)，但在 libre office Calc(Ubuntu 自带的开源版本)中，你必须逐行合并列。这对于 20 行已经很繁琐了，更不用说 2000 行了。当然，在 Python 中，你可以将其自动化，最好的数据操作库叫做 pandas (查看这篇中型文章中的介绍)。
在我看来，学习新东西的最好方法就是把手弄脏。当然，您应该花一些时间熟悉基础知识，但是没有人有时间去做所有有用的 Python 库的教程。如果你不知道如何执行某个操作(比如用熊猫合并栏目)——谷歌(或者百度，或者 Yandex……)是你的朋友。我可以向你保证，以前有人问过这个问题，并在 stackoverflow 上得到答案。
对于每个编程新手(或者实际上是任何东西)来说，最难的部分是当他们遇到困难时，为了找到他们正在寻找的答案，制定正确的问题。问正确的问题和谷歌搜索是一项技能，需要练习。因此，在开始的时候，你可能要花更长的时间才能在网上找到答案。但是不要担心——你很快就会掌握必要的词汇和经验。
**问题:**本应在一列中的数据被拆分成多列
**最终目标:**拥有一个包含所有列中数据的新列，并删除多余的列**解决方案:**合并列
**谷歌查询:**合并多列熊猫
谷歌搜索结果
谷歌推荐了几个 stackoverflow 帖子。主要的一个不是最理想的，因为我们有两个以上的列。但是还有一个问题是关于几个栏目的。
这是一个非常简洁的解决方案。为什么？因为它是通用的，并且考虑到了以后可能遇到的其他问题:比如 NaN 值(空单元格)和不同列中的不同数据类型(NaN 的类型是 float )。我在我的虚拟笔记本中一步一步地讲解这个功能。
非文本预处理
鉴于我想把重点放在文本数据上，我将不讨论如何处理丢失的数据。我正在给出一些如何在这个笔记本中估算缺失数值数据的例子(注意:是用 R，不是 Python)。对于铁路事故数据集，我只是检查重复的行并删除它们。我建议你用你的数据做一切必要的事情，让你的生活更轻松。如果您仅对某些列感兴趣，请仅选择这些列并将其存储在数据框中。如果您只对数据的某一部分感兴趣，请选择该部分(例如，只对发生在堪萨斯城的事件感兴趣)。
文本预处理
在这一节中，我想回顾一些重要的 NLP 概念，并展示如何将它们应用于文本数据的代码示例。
停用词移除
停用词是可能不携带任何有价值信息的词，如冠词(、)、连词(、)或命题(、)。你为什么要删除它们？因为发现 “the” 和 “a” 是数据集中最常见的词并不能告诉你太多关于数据的信息。然而，如果最常见的词包括*【损害】和【脱轨】*你已经可以对事故的类型做出某些推断(在美国铁路数据集中)。
NLP Python 库，如 NLTK 通常带有一个内置的停用词表，您可以很容易地导入它。
然而，NLTK 停用词列表只有大约 200 个停用词。我用于文本分析的停用词表包含将近 600 个单词。我把它保存在一个文件中，在那里我删除了撇号(不是 → 不是)，因为我在删除停用词之前删除了标点符号并对文本进行了标记。
请注意，在某些情况下，停用词很重要。例如，识别负面评论或建议。人们会在差评中使用*【不】**【不是】*这样的停用词:“我会 不是 再买这个商品。我看到了 没有 *使用它的好处”。*我在笔记本里寻址否定。
转换成 n-grams
正如您已经在上面的代码片段中看到的，我们需要将文本标记为单个单词，并将它们存储在一个列表中，以便遍历列表并删除停用的单词。单个词被称为一元词，两个词的二元词，三个词的三元词。
当处理一个新的数据集时，我发现提取最常用的词来了解数据是关于什么的很有帮助。您通常希望首先提取最常见的单字，但是提取具有较大 n 的 n 个单字来识别模式也是有用的。然而，你仍然应该至少阅读一些数据点，以便发现潜在的问题。例如，在铁路事故文本中，我注意到一些报告明确指出没有发生T21 损害或有害物质泄漏。然后，我使用二元语法和三元语法来识别否定，并区分损害和有害物质释放发生的事件和没有发生的事件。
NLTK 有内置的二元模型、三元模型和 n 元模型函数。
使用正则表达式删除标点符号
标点在预测文章的意思时并不总是有用的，所以它们经常和停用词一起被删除。去掉标点符号后，剩下的只有字母数字字符。我不会在这里讨论正则表达式——互联网上有很多关于它们的教程。下面是两个正则表达式—一个删除所有标点和数字，另一个在文本中保留数字。
注意，删除标点符号是否是个好主意，完全取决于你的数据。如果您想要提取特定的信息，例如，损害的美元金额，您想要保留美元符号，以便您可以提取随后的金额。另一个例子，保持标点符号是有益的是训练一个垃圾邮件-火腿分类器。垃圾邮件或文本通常包含更多的标点符号，因此可能是一个有用的功能。
引理满足和词干
词干化和词干化都是指将一个单词还原到其词根的过程。区别在于词干可能不是一个实际的单词，而一个词条是一个实际的单词。如果你想避免将同一个单词的不同形式视为不同的单词，例如出轨，出轨，出轨和出轨，这是一个方便的工具。
**词干:**考虑过，正在考虑，考虑→“考虑”
词干:考虑过，正在考虑，考虑→“考虑”
在训练分类器时，我个人从未注意到引理匹配和词干匹配之间的显著差异。不过，建议你自己试试。NLTK 带有许多不同的内置 lemmatisers 和 stemmers，所以只需即插即用。
把所有的放在一起
现在，您应该对 Python 中的文本分析有了足够的了解。让我们通过使用我用 5 个电影评论创建的虚拟数据集来把它们放在一起。笔记本可以在这里找到下载。
Jupyter 笔记本，演示文章中涉及的所有概念
笔记本中的预处理函数是我在博士刚开始时写的，并且在不同的项目中复制粘贴过。如果您在工作中总是处理相同类型的数据，那么很容易编写一些自动化预处理、探索和分析的函数，您可以在每次处理新数据集时复制粘贴这些函数。
我希望这篇文章对您有用，它将帮助您开始使用 Python pandas、NLTK 和任何其他库，这将使您的工作更容易。我将在下一篇文章中介绍一些更高级的 NLP 主题，所以如果您对我应该介绍的内容有任何建议，请告诉我！
[1] Lewis，David D .，et al .(2004)RC v1:文本分类研究的新基准集。机器学习研究杂志5:361–397。
文本矢量化入门
了解自然语言处理(NLP)-Python 中的文本矢量化
Feel free to follow me on Medium :)
最近，我在 DataCamp 上完成了“查尔斯·达尔文的书籍推荐”案例研究。在这个项目中，我们将学习如何实现文本预处理和文本矢量化，如何使用自然语言处理(NLP)构建图书推荐系统，以及检测查尔斯·达尔文的书籍彼此之间的相关程度。
文本矢量化
文本矢量化 是将文本转换成数值表示的过程。以下是一些实现文本矢量化的常用方法:
- 二进制术语频率
- 单词袋(BoW)术语频率
- (L1)标准化术语频率
- (L2)标准化的 TF-IDF
- Word2Vec
在这一节中，我们将使用下面的语料库来介绍文本矢量化中的 5 种流行方法。
corpus = ["This is a brown house. This house is big. The street number is 1.",
"This is a small house. This house has 1 bedroom. The street number is 12.",
"This dog is brown. This dog likes to play.",
"The dog is in the bedroom."]
二进制术语频率
二进制术语频率捕获文档中术语的存在(1)或不存在(0)。对于这一部分，在 TfidfVectorizer 下，我们将二进制参数设置为 true，以便它可以只显示存在(1)或不存在(0)以及范数参数等于 false。
单词袋(BoW)术语频率
单词袋(BoW)术语频率捕获文档中术语的频率。在 TfidfVectorizer 下，我们将二进制参数设置为 false，以便它可以显示项的实际频率，而范数参数等于 none。
(L1)标准化术语频率
(L1)规范化术语频率获取文档中规范化的 BoW 术语频率。在 TfidfVectorizer 下，我们将二进制参数设置为等于 false，这样它就可以显示项的实际频率，范数参数等于 l1 。
(L2)标准化的 TF-IDF
(L2)规范化 TFIDF(术语频率-文档频率倒数)捕获文档中的规范化 TFIDF。以下是计算 TFIDF 的公式。
TFIDF 的公式
在 TfidfVectorizer 下，我们将 binary 参数设置为等于 false，这样它就可以显示项的实际频率，norm 参数等于 l2 。
Word2Vec
Word2Vec 提供了单词的嵌入式表示。Word2Vec 从语料库中所有单词的一种表示开始，并在非常大的数据语料库上训练 NN(具有 1 个隐藏层)。以下是通常用于训练神经网络的两种方法:
- 连续单词包(CBOW) —基于上下文单词窗口预测中心/目标单词的矢量表示
- Skip-Gram (SG) —基于中心/目标词预测上下文词窗口的向量表示
一旦我们有了每个单词的嵌入向量并将其用于 NLP:
- 计算单词向量之间的余弦相似度，使用单词向量的加权平均值创建更高阶的表示，并提供给分类任务
Python 的 spacy 包提供了预先训练好的模型，我们可以用它来看看 w2v 是如何工作的。
import spacy
nlp = spacy.load("en_core_web_md", disable=['parser', 'ner'])# Get w2v representation of the word 'breakfast'
print (nlp('breakfast').vector.size)
nlp('breakfast').vector[:10]# Find cosine similarity between w2v representations of breakfast and universe
nlp('breakfast').similarity(nlp('universe')) # **0.044292555**doc1 = nlp("I like oranges that are sweet.")
doc2 = nlp("I like apples that are sour.")
doc1.similarity(doc2) # **0.962154245**
案例研究:查尔斯·达尔文的书籍推荐
数据
查尔斯·达尔文是世界上最著名的科学家。他还写了许多其他主题广泛的书籍，包括地质学、植物或他的个人生活。在这个项目中，我们将开发一个基于内容的图书推荐系统，它将根据所讨论主题的相似程度来确定哪些图书彼此接近。我们先来看看后面要用的书。
import glob # **glob** is a general term used to define techniques to match specified patterns according to rules related to Unix shell.folder = "datasets/"
files = glob.glob(folder + "*.txt")
files.sort()
文本预处理
作为第一步，我们需要加载每本书的内容，并检查正则表达式，通过删除所有非字母数字字符来简化这个过程。我们称这样的文本集合为语料库。
import re, ostxts = []
titles = []for n in files:
f = open(n, encoding='utf-8-sig')
data = re.sub('**[\W_]+**', ' ', f.read())
txts.append(data)
titles.append(os.path.basename(n).replace('.txt', ''))
[len(t) for t in txts]
然后，为了一致性，我们将参考达尔文最著名的关于物种起源的书来检查其他书的结果。
*for i in range(len(titles)):
if titles[i] == 'OriginofSpecies':
ori = i
print(ori) **# Index = 15***
下一步，我们通过做标记化将语料库转换成一种格式。
*stoplist = set('for a of the and to in to be which some is at that we i who whom show via may my our might as well'.split())txts_lower_case = [i.lower() for i in txts]
txts_split = [i.split() for i in txts]texts = [[word for word in txt if word not in stoplist] for txt in txts_split]
texts[15][0:20]*
对于文本预处理的下一部分，我们使用一个词干化过程，该过程将一个单词的变形形式组合在一起，这样它们就可以作为一个单独的项目进行分析:词干。为了使过程更快，我们将直接从 pickle 文件中加载最终结果，并回顾用于生成它的方法。
*import pickletexts_stem = pickle.load(open('datasets/texts_stem.p', 'rb'))
texts_stem[15][0:20]*
文本矢量化
词袋模型(BoW)
首先，我们需要创建一个包含查尔斯·达尔文著作语料库中所有单词的宇宙，我们称之为字典。然后，使用词干标记和字典，我们将创建词袋模型(BoW ),将我们的书表示为它们包含的与它们各自的出现次数相关联的所有唯一标记的列表。
*from gensim import corporadictionary = corpora.Dictionary(texts_stem)
bows = [dictionary.doc2bow(text) for text in texts_stem]
print(bows[15][:5])*
为了更好地理解这个模型，我们将把它转换成一个数据框架，并显示出“物种起源”这本书最常见的 10 个词干。
*df_bow_origin = pd.DataFrame()df_bow_origin['index'] = [i[0] for i in bows[15] if i]
df_bow_origin['occurrences'] = [i[1] for i in bows[15] if i]
df_bow_origin['token'] = [dictionary[index] for index in df_bow_origin['index']]
df_bow_origin.occurrences.sort_values(ascending=False).head(10)*
TF-IDF 型号
接下来，我们将使用一个 TF-IDF 模型根据每个单词在文本中的出现频率来定义它的重要性。因此，一个单词的高 TF-IDF 分数将指示该单词特定于该文本。
*from gensim.models import TfidfModelmodel = TfidfModel(bows)
model[bows[15]]*
同样，为了更好地理解这个模型，我们将把它转换成一个数据框架，并显示“物种起源”这本书的 10 个最具体的单词。
*df_tfidf = pd.DataFrame()df_tfidf['id'] = [i[0] for i in model[bows[15]]]
df_tfidf['score'] = [i[1] for i in model[bows[15]]]
df_tfidf['token'] = [dictionary[index] for index in df_tfidf['id']]
df_tfidf.score.sort_values(ascending=False).head(10)*
建议
现在我们有了一个 TF-IDF 模型来衡量它们与每本书的具体程度，我们可以衡量书籍之间的相关程度。因此，我们将使用余弦相似度，并将结果可视化为距离矩阵。
*from gensim import similaritiessims = similarities.MatrixSimilarity(model[bows])
sim_df = pd.DataFrame(list(sims))
sim_df.columns = titles
sim_df.index = titles
sim_df*
结论
我们现在有了一个矩阵，其中包含了查尔斯·达尔文的任何两本书之间的所有相似性度量！我们可以使用 barh()来显示一个横条图，其中的书籍与《物种起源》中的最为相似。**
*%matplotlib inline
import matplotlib.pyplot as pltv = sim_df['OriginofSpecies']
v_sorted = v.sort_values()
v_sorted.plot.barh()
plt.xlabel('Similarity')*
然而，我们想更好地了解大局，看看达尔文的书通常是如何相互关联的。为此，我们将把整个相似性矩阵表示为一个树状图，这是显示此类数据的标准工具。
*from scipy.cluster import hierarchyZ = hierarchy.linkage(sim_df, 'ward')
chart = hierarchy.dendrogram(Z, leaf_font_size=8, labels=sim_df.index, orientation="left")*
最后，基于我们之前创建的图表，我们可以得出结论:在物种起源上，“被驯化的动植物的变异与“最相关。”
创建这篇文章的源代码可以在我的 Github 中找到。
关于我
非常感谢您阅读我的文章！大家好，我是雪莉，目前在亚利桑那州立大学攻读商业分析硕士学位。如果您有任何问题，请随时联系我！
*Email me at ***kchen122@asu.edu***and feel free to connect me on [**LinkedIn**](https://www.linkedin.com/in/kuanyinchen-shirley/)!*
谷歌云人工智能平台 TFX 入门—第 1 部分
创建机器学习(ML)模型通常是世界各地许多数据科学家和工程师的核心关注点。然而，他们经常忘记计划一旦模型建成，他们将如何生产。这通常不是他们的错(大多数情况下)，因为大多数情况下，不同的部门负责不同的生产领域，例如，数据科学家团队负责创建模型，开发人员团队负责打包模型以供使用。这通常会导致:
- 模型没有定期更新，因为反馈循环通常是手动的，即收集的数据交给数据科学家团队来评估和更新模型。更新的模型然后被交给开发团队。我见过这样的过程，至少需要几个星期！
- 维护模型的运营成本增加，因为有多个团队负责模型的生命周期。
因此，Google/TensorFlow 的团队意识到，以上是围绕客户想要生产他们的模型的一个共同主题，所以他们创建了 TensorFlow Extended (TFX)。
TFX 是一个平台，它允许用户为他们的 TensorFlow 代码创建端到端的生产规模的 ML 管道。它包括建模、培训、验证、服务推理和管理在线部署。机器学习管道可以使用任何编排工具来构建，如 Apache Airflow、Apache Beam 或 Kubeflow。必须注意的是，本文中的流水线是对 ML 工作流的描述，它们以图表的形式组合，可用于编排和自动化机器学习系统。出于本文的目的，我们将通过 TFX 使用 Kubeflow 管道。
TFX 使用的主要库是:
- TF 数据验证 —用于异常检测
- TF 变换 —用于数据预处理和特征工程
- TF 估计器和 Keras —建立和训练机器学习模型
- TF 模型分析 —模型评估与分析
- TF 服务 —将模型作为 REST APIs 服务
下图显示了在端到端模型中使用的各种 TFX 库，我们将在下一系列文章中详细介绍它们。然而，在这篇文章中，我们将在谷歌云平台上建立一个基础，以了解 TFX 和库伯流的行动。
图片改编自[1]
1.在新的 Kubernetes 集群上建立 AI 平台管道。
我们将假设你们有一个项目与本教程启用计费。
放心吧！本教程保持在免费层的限制，但是，如果你耗尽了免费层的限制，你可能会被收费。如果您想遵循本教程，建议您创建一个新项目。
- 在导航窗格中，找到人工智能菜单下的“AI 平台”，点击管道，如下图所示。
2.点击“新实例，创建一个新集群，如下图所示。您将被引导至 Kubeflow Pipelines 概览页面。
3.在 Kubeflow Pipeline 概览页面上，点击“配置”。
注意:在启用 Kubernetes 引擎 API 时，您可能需要等待几分钟。
- 在“部署 Kubeflow 管道”页面上，选择离您最近的区域。离我最近的区域是“欧洲-西方 2-a”。
- 选中标记为“允许访问以下云 API”的框。
- 然后点击创建集群。这需要在进入下一步之前完成。
4.创建集群后，您可以选择名称空间和实例名称。我将保留我的默认设置。
您应该可以成功地看到您的 Kubernetes 集群中启动了 Kubeflow 管道，如下所示。
现在我们要设置一个云 AI 平台笔记本实例。
2.设置云人工智能笔记本实例。
- 回到主导航菜单，在人工智能菜单下找到“AI 平台”，点击笔记本，如下图所示。
2.继续点击“新实例，选择“ Tensorflow 2.2 - >不带 GPU”。
- 注意:您可以通过单击新笔记本实例表单底部的定制来更改机器。
现在我们可以做的是从我们的人工智能渠道推出一款笔记本电脑。
3.启动入门笔记本
- 我们现在可以点击“管道”按钮，它应该会把我们带到人工智能平台管道页面。然后，我们可以点击“Open Pipelines Dashboard”进入“入门页面”。
2.在“入门页面”上，单击“打开 TF 2.2 笔记本”链接，并选择您已创建的笔记本实例。
您现在可以访问与 Kubeflow 链接的 Jupyter 实验室笔记本，将会打开一个模板笔记本。
在我的下一个系列中，我将使用简单的数据，通过简单的步骤，使用 TFX 管道生产您的模型。对于那些等不及的人，你可以通过谷歌的“使用模板创建一个 TFX 管道”笔记本，它是默认打开的。
玩得开心！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
