TowardsDataScience-博客中文翻译-2019-二十九-

龙哥盟 / 2024-10-13 / 原文

TowardsDataScience 博客中文翻译 2019（二十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

增强现实和虚拟现实入门

原文：https://towardsdatascience.com/getting-started-with-augmented-and-virtual-reality-a51446661c3?source=collection_archive---------12-----------------------

用实例介绍不同类型的增强现实和虚拟现实。

(Source: https://fsmedia.imgix.net/7b/5e/73/1d/0b6f/4146/9e58/67b0faf61bf5/ready-player-one-tech-might-already-be-here.jpeg?rect=0%2C0%2C2632%2C1314&auto=format%2Ccompress&dpr=2&w=650)

增强现实

增强现实是一种技术，它将你周围的世界融入其中，并在其上添加虚拟内容，使其看起来就像在现实世界中一样。

— Zappar [1]

增强现实(AR)背后的主要思想是将虚拟物体和信息实时叠加在现实世界环境中，以使用户体验更具沉浸感[2]。

增强现实的一些常用应用示例有:

培养医学生
军事训练
博彩
博物馆/艺术画廊之旅

Figure 1: Augmented Reality in action [3]

增强现实的使用预计将在未来几年内增加，谷歌和苹果等公司已经开发了诸如 ARCore 和 ARKit 等工具，使开发者更容易分别为 Play Store 和 App Store 创建 AR 应用。

如今，人工智能通常被集成到 AR 和 VR 应用中，以优化客户体验(例如，计算机视觉)。

有不同类型的增强现实应用，这些是[4]:

基于标记的增强现实 =利用摄像机和虚拟标记(如 QR 码)，在摄像机识别标记时激活一些 AR 组件。
无标记增强现实 =使用嵌入在设备(如智能手机)中的 GPS、加速度计和数字罗盘，根据用户位置提供增强现实内容。例如，这可以用于使绘图系统更具交互性。
基于投影的增强现实 =光被发送到现实世界的物体上，以创建用户可以与之交互的用户界面(通过检查投影区域如何被这种交互改变来检测用户与表面的交互)。
基于叠加的增强现实 =这种类型的增强现实使用对象识别来部分或完全改变对象的视图。例如，宜家构思了一个应用程序，让用户在他们的房子里放置虚拟的宜家家具，以帮助他们决定购买哪件家具。

增强现实可以用于许多不同的环境和应用中。例如，今年夏天我决定创建一张个人 AR 名片，因为这将是我在南安普顿大学学习的最后一年。

这个 AR 应用程序是使用杰罗姆·艾蒂安制作的 Javascript 库 AR.js 创建的。

如果你对开发自己的 AR 应用感兴趣，也可以使用 Unity Vuforia 或 A-Frame(如本文末尾的实际例子所示)。

虚拟现实

有时，术语增强现实(AR)和虚拟现实(VR)会被错误地混淆。两者的主要区别在于，VR 创建了一个完全人工的环境，用户可以完全沉浸在其中，而 AR 旨在使用人工效果来增强我们的现实世界环境。

为了体验 VR，通常使用诸如头戴式显示器(HMDs)和输入设备之类的设备。

头戴式显示器 =包含安装在用户眼前的显示器的设备(在某些情况下也可以使用智能手机)。
输入设备 =数据手套、跟踪板、操纵杆。

Figure 2: Virtual Reality Accessories [5]

虚拟现实有三种主要类型6:

非沉浸式模拟 =只有一些用户传感器被刺激(用户仍然意识到虚拟模拟之外的现实)。
半沉浸式模拟 =用户部分但不完全沉浸在虚拟环境中(如飞行模拟)。
完全沉浸式模拟 =使用头盔显示器和输入设备等配件刺激用户的所有感官。

示范

现在，我将带您通过一个实用的介绍，了解如何使用 A-Frame 创建一个简单的 AR 应用程序。我在这个例子中使用的所有代码都可以在我的 GitHub 和 CodePen 账户中找到，供你使用。

A-Frame 是一个基于 HTML 的 web 框架，用于创建 VR 应用程序。它支持各种各样的 VR 头戴设备，如 GerVR、CardBoard、Oculus Go，也可用于 AR 应用。

A-Frame 文档提供了各种各样的例子来帮助您入门，有些例子可以在这里找到。

为了开始使用 A-Frame，我们可以使用 CopePen 作为在线编辑器(或任何其他 web 开发编辑器),以便实时测试我们的代码。

首先，我们需要在我们的 HTML 脚本中加载 A 帧库。

<script src="[https://aframe.io/releases/0.9.0/aframe.min.js](https://aframe.io/releases/0.9.0/aframe.min.js)"> </script>

在这个例子中，我将创建一个交互式图片，我们可以在虚拟环境中旋转 360 度。

为此，我将下面的代码分为 5 个主要部分:

加载本例所需的所有库/依赖项。
加载要使用的图像并对其进行预处理以适应虚拟环境。
向图像添加动画。
添加欢迎用户使用应用程序的文本横幅。
启用相机和鼠标光标交互以增加与虚拟环境的交互性。

因此，创建了以下动画:

如果你有兴趣自己测试这个应用程序，只要在你的智能手机上浏览时打开这个 CodePen 链接！

联系人

如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:

领英
个人博客
个人网站
中等轮廓
GitHub
卡格尔

文献学

[1]增强现实，Zappar。访问时间:https://www.zappar.com/augmented-reality/

[2]增强现实如何工作，HowStuffWorks，KEVIN BONSOR & NATHAN CHANDLER。访问地点:【https://computer.howstuffworks.com/augmented-reality.htm

[3]增强现实可以推动汽车品牌价值的三种方式，blippar。访问:https://www . blippar . com/blog/2018/10/24/3-ways-augmented-reality-can-drive-value-for-auto-brands

[4]现实技术，理解
增强现实(AR)技术的终极指南。访问时间:https://www.realitytechnologies.com/augmented-reality/

[5] Oculus Rift 的亲身体验。游戏告密者——本·里维斯。访问:https://www . game informer . com/gdc-2019/2019/03/20/oculus-rift-s-hands-on-impressions

6现实技术，理解
虚拟现实(VR)技术的终极指南。访问地点:https://www.realitytechnologies.com/virtual-reality/

使用 Jupyter 笔记本、PySpark 和 Docker 开始数据分析

原文：https://towardsdatascience.com/getting-started-with-data-analytics-using-jupyter-notebooks-pyspark-and-docker-57c1aaab2408?source=collection_archive---------9-----------------------

Audio Introduction

毫无疑问，大数据分析，数据科学，人工智能 (AI)，以及机器学习 (ML)，人工智能的一个子类，在过去几年里都经历了巨大的受欢迎程度。在营销炒作的背后，这些技术正在对我们现代生活的许多方面产生重大影响。由于其受欢迎程度和潜在的好处，商业企业、学术机构和公共部门正在争相开发硬件和软件解决方案，以降低进入门槛，提高 ML 和数据科学家和工程师的速度。

(courtesy Google Trends and Plotly)

许多开源软件项目也降低了进入这些技术的门槛。应对这一挑战的开源项目的一个很好的例子是 Jupyter 项目。类似于 Apache Zeppelin 和新开源的网飞的 Polynote ， Jupyter Notebooks 支持数据驱动、交互式和协作式数据分析。

这篇文章将展示使用 Jupyter Docker 栈创建一个容器化的数据分析环境。这个特殊的环境将适合学习和开发使用 Python、Scala 和 R 编程语言的 Apache Spark 应用程序。我们将重点介绍 Python 和 Spark，使用 PySpark。

特色技术

以下技术是这篇文章的重点。

Jupyter 笔记本

根据项目 Jupyter,Jupyter Notebook，以前被称为 IPython Notebook ，是一个开源的网络应用程序，允许用户创建和共享包含实时代码、等式、可视化和叙述性文本的文档。用途包括数据清理和转换、数值模拟、统计建模、数据可视化、机器学习等等。Jupyter 这个词是Julia、Python 和 R 的松散缩写，但是今天，Jupyter 支持许多编程语言。

在过去的 3-5 年里，人们对 Jupyter 笔记本电脑的兴趣急剧增长，这在一定程度上是由主要的云提供商 AWS、Google Cloud 和 Azure 推动的。亚马逊 Sagemaker 、亚马逊 EMR (Elastic MapReduce)、谷歌云 Dataproc 、谷歌 Colab (Collaboratory)、以及微软 Azure 笔记本都与 Jupyter 笔记本直接集成，用于大数据分析和机器学习。

(courtesy Google Trends and Plotly)

Jupyter Docker 堆栈

为了能够快速方便地访问 Jupyter 笔记本，Project Jupyter 创建了 Jupyter Docker 堆栈。这些堆栈是包含 Jupyter 应用程序以及相关技术的现成 Docker 映像。目前，Jupyter Docker 堆栈专注于各种专业，包括 r-notebook 、 scipy-notebook 、 tensorflow-notebook 、 datascience-notebook 、 pyspark-notebook ，以及本文的主题 all-spark-notebook 。该堆栈包括各种各样的知名软件包来扩展它们的功能，如 scikit-learn 、 pandas 、 Matplotlib 、 Bokeh 、 NumPy 和 Facets 。

阿帕奇火花

据 Apache 报道，Spark 是一个用于大规模数据处理的统一分析引擎。Spark 于 2009 年作为一个研究项目在加州大学伯克利分校 AMPLab 开始，于 2010 年初开源，并于 2013 年转移到阿帕奇软件基金会。查看任何主要职业网站上的帖子都会证实，Spark 被知名的现代企业广泛使用，如网飞、Adobe、Capital One、洛克希德·马丁、捷蓝航空、Visa 和 Databricks。在这篇文章发表的时候，仅在美国，LinkedIn 就有大约 35000 个职位列表引用了 Apache Spark。

凭借比 Hadoop 快 100 倍的速度， Apache Spark 使用最先进的 DAG ( 有向非循环图)调度器、查询优化器和物理执行引擎，实现了静态、批处理和流数据的高性能。Spark 的多语言编程模型允许用户用 Scala、Java、Python、R 和 SQL 快速编写应用程序。Spark 包括 Spark SQL ( 数据帧和数据集)、MLlib ( 机器学习)、GraphX ( 图形处理)和 DStreams ( Spark 流)的库。您可以使用 Spark 的独立集群模式、 Apache Hadoop YARN 、 Mesos 或 Kubernetes 来运行 Spark。

PySpark

Spark Python API， PySpark ，向 Python 公开了 Spark 编程模型。PySpark 构建在 Spark 的 Java API 之上，使用 Py4J 。据 Apache 报道，Py4J 作为 Python 和 Java 之间的桥梁，使得运行在 Python 解释器中的 Python 程序能够动态访问 Java 虚拟机(JVM)中的 Java 对象。数据在 Python 中处理，在 JVM 中缓存和混洗。

码头工人

据 Docker 称，他们的技术让开发人员和 IT 人员能够自由构建、管理和保护关键业务应用，而无需担心技术或基础设施的局限。在这篇文章中，我使用的是 macOS 的当前稳定版本Docker DesktopCommunity version，截止到 2020 年 3 月。

码头工人群

Docker 的当前版本包括 Kubernetes 和 Swarm orchestrator，用于部署和管理容器。在这个演示中，我们将选择 Swarm。根据 Docker 的说法，Docker 引擎中嵌入的集群管理和编排功能是使用 swarmkit 构建的。Swarmkit 是一个独立的项目，它实现了 Docker 的编排层，并直接在 Docker 中使用。

一种数据库系统

PostgreSQL 是一个强大的开源对象关系数据库系统。根据他们的网站， PostgreSQL 提供了许多功能，旨在帮助开发人员构建应用程序，帮助管理员保护数据完整性和构建容错环境，并帮助管理无论大小的数据集。

示范

在本次演示中，我们将探索 Spark Jupyter Docker 堆栈的功能，以提供有效的数据分析开发环境。我们将探索一些日常用途，包括执行 Python 脚本、提交 PySpark 作业、使用 Jupyter 笔记本，以及从不同的文件格式和数据库中读取和写入数据。我们将使用最新的jupyter/all-spark-notebook Docker 图像。这个镜像包括 Python、R 和 Scala 对 Apache Spark 的支持，使用 Apache Toree 。

体系结构

如下所示，我们将部署一个 Docker 栈到一个单节点 Docker 群。堆栈由一个Jupyter All-Spark-Notebook、PostgreSQL(Alpine Linux 版本 12)和 Adminer 容器组成。Docker 栈将有两个本地目录绑定到容器中。GitHub 项目中的文件将通过一个绑定目录与 Jupyter 应用程序容器共享。我们的 PostgreSQL 数据也将通过一个绑定挂载的目录持久化。这允许我们将数据持久化到临时容器之外。如果重新启动或重新创建容器，数据将保留在本地。

源代码

这篇文章的所有源代码可以在 GitHub 上找到。使用以下命令克隆项目。注意这篇文章使用了v2分支。

git clone \ 
  --branch v2 --single-branch --depth 1 --no-tags \
  [https://github.com/garystafford/pyspark-setup-demo.git](https://github.com/garystafford/pyspark-setup-demo.git)

源代码示例显示为 GitHub Gists ，在某些移动和社交媒体浏览器上可能无法正确显示。

部署 Docker 堆栈

首先，创建$HOME/data/postgres目录来存储 PostgreSQL 数据文件。

mkdir -p ~/data/postgres

这个目录将被绑定到 PostgreSQL 容器中的 stack.yml 文件$HOME/data/postgres:/var/lib/postgresql/data的第 41 行。环境变量HOME假设您在 Linux 或 macOS 上工作，它相当于 Windows 上的HOMEPATH。

Jupyter 容器的工作目录设置在 stack.yml 文件的第 15 行，working_dir: /home/$USER/work。本地绑定挂载的工作目录是$PWD/work。这个路径被绑定到 Jupyter 容器中的工作目录，在 stack.yml 文件的第 29 行，$PWD/work:/home/$USER/work。PWD环境变量假设您在 Linux 或 macOS 上工作(在 Windows 上是CD)。

默认情况下，Jupyter 容器中的用户是jovyan。我们将使用我们自己的本地主机的用户帐户覆盖该用户，如 Docker 堆栈文件NB_USER: $USER的第 21 行所示。我们将使用主机的USER环境变量值(相当于 Windows 上的USERNAME)。还有另外的选项用于配置 Jupyter 容器。Docker 堆栈文件( gist )的第 17–22 行使用了其中的几个选项。

jupyter/all-spark-notebook Docker 映像很大，大约 5 GB。根据您的互联网连接，如果这是您第一次提取此图像，堆栈可能需要几分钟才能进入运行状态。虽然没有要求，但我通常会提前提取 Docker 图像。

docker pull jupyter/all-spark-notebook:latest
docker pull postgres:12-alpine
docker pull adminer:latest

假设您在本地开发机器上安装了最新版本的 docker，并以 swarm 模式运行，那么从项目的根目录运行下面的 Docker 命令就很容易了。

docker stack deploy -c stack.yml jupyter

Docker 栈由一个新的覆盖网络jupyter_demo-net和三个容器组成。要确认堆栈部署成功，请运行以下 docker 命令。

docker stack ps jupyter --no-trunc

要访问 Jupyter 笔记本应用程序，您需要获得 Jupyter URL 和访问令牌。Jupyter URL 和访问令牌被输出到 Jupyter 容器日志中，可以使用以下命令访问该日志。

docker logs $(docker ps | grep jupyter_spark | awk '{print $NF}')

您应该观察到类似如下的日志输出。检索完整的 URL，例如http://127.0.0.1:8888/?token=f78cbe...，以访问 Jupyter 基于 web 的用户界面。

从 Jupyter dashboard 登录页面，您应该可以看到项目的work/目录中的所有文件。注意您可以从仪表板创建的文件类型，包括 Python 3、R 和 Scala(使用 Apache Toree 或 spylon-kernal )笔记本和文本。您也可以打开 Jupyter 终端或从下拉菜单创建新文件夹。在这篇文章发表时(2020 年 3 月)，最新的jupyter/all-spark-notebook Docker 镜像运行 Spark 2.4.5、Scala 2.11.12、Python 3.7.6 和 OpenJDK 64 位服务器 VM、Java 1.8.0 更新 242。

引导环境

项目中包括一个引导脚本， bootstrap_jupyter.sh 。该脚本将使用 pip 、Python 包安装程序和一个 requirement.txt 文件来安装所需的 Python 包。bootstrap 脚本还安装最新的 PostgreSQL 驱动程序 JAR，配置 Apache Log4j 以减少提交 Spark 作业时的日志冗长性，并安装 htop 。虽然这些任务也可以从 Jupyter 终端或 Jupyter 笔记本中完成，但使用引导脚本可以确保您每次启动 Jupyter Docker 堆栈时都有一个一致的工作环境。根据需要在引导脚本中添加或删除项目( 要点 )。

就这样，我们的新 Jupyter 环境已经准备好开始探索了。

运行 Python 脚本

在新的 Jupyter 环境中，我们可以执行的最简单的任务之一就是运行 Python 脚本。不用担心在您自己的开发机器上安装和维护正确的 Python 版本和多个 Python 包，我们可以在 Jupyter 容器中运行 Python 脚本。在这篇帖子更新的时候，最新的jupyter/all-spark-notebook Docker 镜像运行 Python 3.7.3 和 Conda 4.7.12。让我们从一个简单的 Python 脚本开始， 01_simple_script.py 。

在 Jupyter 终端窗口中，使用以下命令运行脚本。

python3 01_simple_script.py

您应该观察到以下输出。

Kaggle 数据集

为了探索 Jupyter 和 PySpark 的更多特性，我们将使用 Kaggle 的公开数据集。 Kaggle 是一个优秀的开源资源，用于大数据和 ML 项目的数据集。他们的口号是“ka ggle 是做数据科学项目的地方。”在这个演示中，我们将使用 Kaggle 的面包店数据集中的事务。数据集以单个 CSV 格式文件的形式提供。项目中还包含一个副本。

“面包店交易”数据集包含 21，294 行，4 列数据。虽然肯定不是大数据，但数据集足够大，足以测试 Spark Jupyter Docker 堆栈功能。该数据由 2016 年 10 月 30 日至 2017 年 04 月 09 日之间 21，294 种烘焙食品的 9，531 笔客户交易组成( 要点 )。

提交 Spark 作业

我们并不局限于 Jupyter 笔记本来与 Spark 互动。我们也可以从 Jupyter 终端直接向 Spark 提交脚本。这是 Spark 在生产中使用的典型方式，用于对大型数据集执行分析，通常定期使用工具，如 Apache Airflow 。使用 Spark，您可以从一个或多个数据源加载数据。在对数据执行操作和转换之后，数据被持久化到数据存储，例如文件或数据库，或者被传送到另一个系统以供进一步处理。

该项目包括一个简单的 Python PySpark ETL 脚本， 02_pyspark_job.py 。ETL 脚本将 CSV 文件中的原始 Kaggle Bakery 数据集加载到内存中的 Spark 数据帧中。然后，该脚本执行一个简单的 Spark SQL 查询，计算每种烘焙食品的销售总量，并按降序排序。最后，脚本将查询结果写入一个新的 CSV 文件output/items-sold.csv。

使用以下命令直接从 Jupyter 终端运行脚本。

python3 02_pyspark_job.py

Spark 作业的输出示例如下所示。

通常，您会使用spark-submit命令提交Spark 作业。使用 Jupyter 终端运行以下命令。

$SPARK_HOME/bin/spark-submit 02_pyspark_job.py

下面，我们看到了来自spark-submit命令的输出。在输出中打印结果只是为了演示的目的。通常，Spark 作业以非交互方式提交，结果直接保存到数据存储或传送到另一个系统。

使用以下命令，我们可以查看由 spark 作业创建的结果 CVS 文件。

ls -alh output/items-sold.csv/
head -5 output/items-sold.csv/*.csv

spark 作业创建的文件示例如下所示。我们应该已经发现咖啡是最常销售的烘焙食品，销售量为 5471 件，其次是面包，销售量为 3325 件。

与数据库交互

为了展示 Jupyter 处理数据库的灵活性，PostgreSQL 是 Docker 栈的一部分。我们可以从 Jupyter 容器向 PostgreSQL 实例读写数据，该实例运行在一个单独的容器中。首先，我们将运行一个用 Python 编写的 SQL 脚本，在一个新的数据库表中创建我们的数据库模式和一些测试数据。为此，我们将使用 psycopg2 ，这是 Python 的 PostgreSQL 数据库适配器包，我们之前使用引导脚本将其安装到 Jupyter 容器中。Python 脚本 03_load_sql.py 将针对 Postgresql 容器实例执行一组包含在 SQL 文件 bakery.sql 中的 SQL 语句。

SQL 文件， bakery.sql 。

要执行该脚本，请运行以下命令。

python3 03_load_sql.py

如果成功，应该会产生以下输出。

管理员

为了确认 SQL 脚本的成功，使用 Adminer 。Adminer ( 原名 phpMinAdmin )是一个用 PHP 编写的全功能数据库管理工具。Adminer 本身可以识别 PostgreSQL、MySQL、SQLite 和 MongoDB 等数据库引擎。当前版本为 4 . 7 . 6(2020 年 3 月)。

Adminer 应该在本地主机端口 8080 上可用。如下所示，密码凭证位于 stack.yml 文件中。服务器名称postgres是 PostgreSQL Docker 容器的名称。这是 Jupyter 容器将用来与 PostgreSQL 容器通信的域名。

用 Adminer 连接到新的bakery数据库，我们应该会看到transactions表。

该表应该包含 21，293 行，每行有 5 列数据。

pgAdmin

另一个与 PostgreSQL 交互的绝佳选择是 pgAdmin 4。这是我最喜欢的 PostgreSQL 管理工具。虽然局限于 PostgreSQL，但在我看来，pgAdmin 的用户界面和管理能力要优于 Adminer。为了简洁起见，我选择不在本文中包含 pgAdmin。Docker 堆栈还包含一个 pgAdmin 容器，这个容器已经被注释掉了。要使用 pgAdmin，只需取消对容器的注释，然后重新运行 Docker stack deploy 命令。pgAdmin 应该在本地主机端口 81 上可用。pgAdmin 登录凭证在 Docker 堆栈文件中。

开发 Jupyter 笔记本电脑

Jupyter Docker 堆栈容器的真正功能是 Jupyter 笔记本。根据 Jupyter 项目，该笔记本将基于控制台的方法以全新的方式扩展到交互式计算，提供了一个基于网络的应用程序，适用于捕捉整个计算过程，包括开发、记录和执行代码，以及交流结果。笔记本文档包含交互式会话的输入和输出，以及伴随代码但不用于执行的附加文本。

为了探索 Jupyter 笔记本的功能，该项目包括两个简单的 Jupyter 笔记本。第一批笔记本， 04_notebook.ipynb ，演示了典型的 PySpark 函数，例如从 CSV 文件和 PostgreSQL 数据库加载数据，使用 Spark SQL 执行基本数据分析，包括使用 PySpark 用户定义函数 (UDF)，使用 BokehJS 绘制数据，最后将数据保存回数据库，以及快速高效的 Apache Parquet 文件格式。下面我们看到几个笔记本电池展示了这些功能。

Markdown for Notebook Documentation

Read CSV-Format Files into Spark DataFrame

Load Data from PostgreSQL into Spark DataFrame

Perform Spark SQL Query including use of UDF

Plot Spark SQL Query Results using BokehJS

IDE 集成

回想一下，包含该项目的 GitHub 源代码的工作目录被绑定到 Jupyter 容器中。因此，你也可以在你喜欢的 IDE 中编辑任何文件，包括笔记本，比如 JetBrains PyCharm 和Microsoft Visual Studio Code。PyCharm 内置了对 Jupyter 笔记本的语言支持，如下所示。

PyCharm 2019.2.5 (Professional Edition)

使用 Python 扩展的 Visual Studio 代码也是如此。

Visual Studio Code Version: 1.40.2

使用附加包

正如在简介中提到的，Jupyter Docker 栈是现成的，有各种各样的 Python 包来扩展它们的功能。为了演示这些包的使用，该项目包含第二个 Jupyter 笔记本文档， 05_notebook.ipynb 。这款笔记本使用了 SciPy ，众所周知的用于数学、科学和工程的 Python 包、 NumPy ，众所周知的用于科学计算的 Python 包以及 Plotly Python 图形库。虽然 NumPy 和 SciPy 包含在 Jupyter Docker 映像中，但引导脚本使用 pip 来安装所需的 Plotly 包。类似于上一个笔记本中展示的散景，我们可以使用这些库来创建丰富的交互式数据可视化。

Plotly

要在笔记本中使用 Plotly ，您首先需要注册一个免费帐户，并获得用户名和 API 密钥。为了确保我们不会意外地在笔记本中保存敏感的 Plotly 凭证，我们使用了 python-dotenv 。这个 Python 包从一个.env文件中读取键/值对，使它们作为环境变量对我们的笔记本可用。从 Jupyter 终端修改并运行以下两个命令来创建.env文件，并设置 Plotly 用户名和 API 密钥凭证。注意，.env文件是.gitignore文件的一部分，不会被提交回 git，这可能会影响凭证。

echo "PLOTLY_USERNAME=your-username" >> .env
echo "PLOTLY_API_KEY=your-api-key" >> .env

如下所示，我们使用 Plotly 构建了一个每日烘焙食品销售的条形图。该图表使用 SciPy 和 NumPy 构建了一个线性拟合(回归)，并为面包店数据绘制了一条最佳拟合线，并覆盖了竖线。该图表还使用 SciPy 的 Savitzky-Golay 过滤器绘制了第二条线，展示了我们面包店数据的平滑情况。

Plotly 还提供 Chart Studio 在线图表制作工具。Plotly 将 Chart Studio 描述为世界上最现代化的企业数据可视化解决方案。我们可以使用免费版的图表工作室云来增强、风格化和分享我们的数据可视化。

Jupyter 笔记本浏览器

笔记本也可以用 nbviewer 查看，这是 Project Jupyter 下的一个开源项目。由于 Rackspace 的托管，nbviewer 实例是一项免费服务。

使用下面的 nbviewer，我们可以看到 04_notebook.ipynb 笔记本中一个单元格的输出。使用 nbviewer 查看此笔记本，此处。

监控 Spark 作业

Jupyter Docker 容器公开了 Spark 的监视和仪器 web 用户界面。我们可以详细查看每个已完成的 Spark 工作。

我们可以查看 Spark 作业每个阶段的细节，包括 DAG(有向无环图)的可视化，Spark 使用 DAG 调度程序将 DAG 构造为作业执行计划的一部分。

我们还可以回顾作为 Spark 工作阶段一部分的每个事件的任务组成和发生时间。

我们还可以使用 Spark 接口来检查和确认运行时环境配置，包括 Java、Scala 和 Spark 的版本，以及 Java 类路径上可用的包。

局部火花性能

在本地开发系统的 Jupyter Docker 容器内的单节点上运行 Spark 并不能替代真正的 Spark 集群，这是一种生产级的多节点 Spark 集群，运行在裸机或健壮的虚拟化硬件上，并通过 Hadoop YARN 、 Apache Mesos 或 Kubernetes 进行管理。在我看来，您应该只调整 Docker 资源限制，以支持运行小型探索性工作负载的可接受的 Spark 性能水平。在生产级、多节点 Spark 集群上处理大数据和执行需要复杂计算的任务的需求是不现实的。

我们可以使用下面的 docker stats 命令来检查容器的 CPU 和内存指标。

docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}"

下面，我们看到来自 Docker 栈的三个容器的统计数据显示很少或没有活动。

将这些统计数据与下面显示的数据进行比较，这些数据是在笔记本电脑读写数据和执行 Spark SQL 查询时记录的。CPU 和内存输出显示峰值，但都在可接受的范围内。

Linux 进程监视器

检查容器性能指标的另一个选项是 top ，它预先安装在我们的 Jupyter 容器中。例如，从 Jupyter 终端执行下面的top命令，按照 CPU 使用率对进程进行排序。

top -o %CPU

我们应该观察 Jupyter 容器中运行的每个进程的单独性能。

比top更上一层楼的是 htop ，一个用于 Unix 的交互式进程查看器。它由引导脚本安装在容器中。例如，我们可以从 Jupyter 终端执行htop命令，按照 CPU %使用率对进程进行排序。

htop --sort-key PERCENT_CPU

使用htop，观察单个 CPU 的活动。这里，htop窗口左上角的四个 CPU 是分配给 Docker 的 CPU。我们深入了解了 Spark 使用多个 CPU 的方式，以及其他性能指标，如内存和交换。

假设您的开发机器是健壮的，如果需要的话，很容易向 Docker 分配和释放额外的计算资源。注意不要给 Docker 分配过多的资源，这会使您的主机无法为其他应用程序提供可用的计算资源。

笔记本扩展

有许多方法可以扩展 Jupyter Docker 堆栈。一个流行的选项是 jupyter-contrib-nbextensions。根据他们网站的说法，jupyter-contrib-nbextensions软件包包含了一系列社区贡献的非官方扩展，为 Jupyter 笔记本增加了功能。这些扩展大部分是用 JavaScript 编写的，并且会被本地加载到您的浏览器中。可以通过使用内置的 Jupyter 命令，或者更方便地通过使用Jupyter _ nb extensions _ configurator服务器扩展来启用已安装的笔记本扩展。

该项目包含一个备用 Docker 堆栈文件， stack-nbext.yml 。堆栈使用一个替代的 Docker 映像garystafford/all-spark-notebook-nbext:latest，这个Docker 文件构建它，使用jupyter/all-spark-notebook:latest映像作为基础映像。替代图像添加在jupyter-contrib-nbextensions和jupyter_nbextensions_configurator包中。由于 Jupyter 需要在部署完nbextensions后重启，所以不能在运行的jupyter/all-spark-notebook容器中重启。

使用这个备用堆栈，在下面的 Jupyter 容器中，我们可以看到相当大的可用扩展列表。我最喜欢的一些扩展包括“拼写检查”、“代码折叠”、“代码漂亮”、“执行时间”、“目录”和“切换所有行号”。

下面，我们看到 04_notebook.ipynb 的菜单栏中新增了五个扩展图标。您还可以观察到已经应用到笔记本的扩展，包括目录、代码折叠、执行时间和行号。拼写检查和漂亮的代码扩展也被应用。

结论

在这篇简短的帖子中，我们看到了使用 Jupyter notebooks、Python、Spark 和 PySpark 开始学习和执行数据分析是多么容易，这都要归功于 Jupyter Docker 堆栈。我们可以使用相同的堆栈来学习和执行使用 Scala 和 r 的机器学习。扩展堆栈的功能非常简单，只需用一组不同的工具将这个 Jupyter 映像换成另一个，并向堆栈中添加额外的容器，如 MySQL、MongoDB、RabbitMQ、Apache Kafka 和 Apache Cassandra。

本帖表达的所有观点都是我个人的，不一定代表我现在或过去的雇主及其客户的观点。

开始深度强化学习可能会很难，这里有一种方法来框定它

原文：https://towardsdatascience.com/getting-started-with-deep-reinforcement-learning-can-be-a-beast-heres-a-way-to-frame-it-7063c3e1c584?source=collection_archive---------24-----------------------

很多关于 DRL 的初级读本可能会令人困惑，而且是不必要的高水平。有一种更简单的方式开始你的旅程。

Q-learning at work. Source: NASA at Unsplash

幻想小说中有一个很好的比喻，适用于学习计算机科学、人工智能和机器学习。通常，奇幻小说的“魔法使用者”会充当知识的守门人，使得每一个教程对那些想要学习魔法的人来说都变得不必要的复杂。这是打算为自己囤积这种知识和力量。我不是想把每个计算机系的教授都说成是邪恶的巫师，但是…开个玩笑，我只是觉得教计算机科学真的真的很难——尤其是如果你一开始就不想当老师的话。我不是专家，但我想让所有这些概念更容易理解。因此，下面是如何在你的脑海中构建深度强化学习的方法。

理解和学习编程的最好方法是设想一个项目，并找出如何完成它。这意味着拼凑出你需要使用什么样的工具来完成它，以及如何使用这些工具。在本例中，我创建了一个名为 Marco 的虚构角色。Marco 非常擅长“魔法语言”(即 Python)，了解如何使用其他人为自己的目的(即包)而制作的咒语，并开始能够概括“魔法世界”(计算)的工作方式。和所有优秀的巫师一样，马可是懒 AF。他的目标是创造一个没有知觉的代理人，可以替他做所有的家务。但是他有一个主要的问题——创造咒语需要一段时间！他已经研究他的自动化代理有一段时间了，并且已经意识到拥有一个没有感情的管家意味着他必须亲自为每一个环境中的每一个动作创造一个独特的咒语。马尔科没有时间，他只是想要一个简单的答案，他认为魔法应该让事情变得更容易！马可希望他的仆人能够借鉴马可自己的人类经验，但他不想只是创造另一个人类。他希望代理能够在一个下午内掌握他所知道的一切，甚至更多。马可利用他的技能——他记得他可以创造迷你世界，在那里他可以控制一切！包括时间。尽管马可在现实世界中没有足够的力量来影响时间，但他可以在这个迷你世界中做到。但这对他没有帮助，对吗？他需要能够在现实世界中使用他的代理人，拥有一个仅限于他的虚拟世界的代理人是没有用的。Marco 花了一上午的时间思考，想出了一个解决方案！如果他把代理人的“思想”放入假世界以获得经验，然后把训练过的思想取出来，放回他的仆人体内，那会怎么样？他会得到他想要的！

Marco 刚刚确定了强化学习的基础，这是人工智能的一个子集。在这个虚构的世界中，魔法取代了编程，马可意识到，为了创造一个能完成高级任务的自动化生物，他需要它来获得经验。但是获得经验花了马可二十四年，他仍然不知道一切！他没时间等那个。他需要大规模地复制体验过程。因此，他找到了一个变通办法——制造一个他控制所有变量的虚拟世界，设置变量以模仿真实世界，但有一些变化(例如，一个虚拟的秒=一个虚拟的小时/天/年)，并将大脑放入虚拟世界。一旦它学得和马可一样多，或者比马可更多，他就把它拿出来，他就有了一个现成的代理愿意并且有能力为他做会计工作！现在，我们已经对 Marco 的工作有所了解，让我们放弃这个神奇的比喻，进入我刚才描述的一些更真实的应用。

在接下来的三个部分中，我想涵盖深度强化学习的主要方面。首先是模型构建。有四个主要方面需要理解:

目标
世界
行动
奖励

这些因素几乎是你建立深度强化学习模型所需要的全部。我将很快逐一介绍，但在开始之前，我想交流一个关于数据的重要话题。

马尔科很容易做到——有了魔法，他所要做的就是使用某种可用的神秘能量来创造他的虚拟世界，并认真思考他想要创造什么。对于我们这些真实世界的人来说，我们有不同的参数。数据最重要。有三种类型的数据:数值型，分类型，两者都有！数字数据是最容易处理的——计算机可以通过数学运算快速发现模式。分类数据有点复杂。你如何开始与计算机交流，两个不同的物体之间有质的区别？你怎么能抽象这个呢？数字。特征工程是深度强化学习的一个重要组成部分，许多人工智能“魔法”就是这样发生的。我们只是使用一些特定用途的方法将找到的所有东西转换成数字。特性工程非常重要，所以我会在后面的一整篇文章中讨论这个问题。需要理解的重要一点是，一切最终都将由数字来表示，这就是计算机如何识别模式的。

考虑到这一点，我们来谈谈目标。这是可变的，可以变得非常复杂。看看自动驾驶汽车就知道了。你的目标可以是从 A 点到 B 点，但也需要不破坏汽车，不出马路，以一定速度行驶，不撞到行人，保证乘客安全等。等等。目标函数是任何深度学习模型中最重要的部分，也是它变得复杂的部分原因。所以让我们从简单的东西开始:房子里的温度计。目标很简单:当人们在家时，保持室内温度在华氏 70 度。然后，困难的部分变成了定义国家(即世界)。

状态空间就是虚拟世界。你可以创造和探索三种类型的世界。最简单和最容易使用的是基于模型的强化学习。MB-RL 适用于游戏，尤其是像国际象棋这种规则不变的游戏。“模型”就是游戏规则。它只能发生在一个特殊的环境中——(即棋盘)。棋盘上能发生的事情是有限的(对于人类来说，仍然有令人讨厌的大量可能性)，这也是为什么这是最容易使用的方法。学习曲线提醒:教授们会提出一个叫做“样本效率”的概念，让你感到困惑，这涉及到很多数学知识。为了避免过于深入决策树和修剪，只需知道有一种数学方法可以模拟职业象棋或围棋选手如何“感觉”一步好棋，然后计算机会做得更好。计算机不必计划出可能发生的每一种排列，这一事实使它变得“高效”。下一步是基于价值的强化学习。VB-RL 试图通过称为“开关策略”的概念来估计状态的质量。基本上，VB-RL 猜测它的行为对世界和它的目标是好是坏。偏离策略意味着代理不断尝试重新评估其方法。这是“样本效率低下”，因为模型在真正能够做任何有用的事情之前需要大量的样本。他们不会直接学习行动的策略，他们会学习一个行动过程有多好，并尝试在行动中最大化它。偶尔，他们会抛硬币来尝试新事物。在策略上意味着代理人将不断改变他们的方法给定一个场景，以确定他们的行动是否是好的。确定什么是最佳回报的最著名的算法之一(我马上会谈到这个)被称为 Q-learning(以 Q 命名，是对动作的抽象)。现在，让我们继续行动:

操作步骤可能会更熟悉—它只是一个 if 函数。一个动作表示，如果满足某些条件，那么程序将做一些事情。Q-learning 是一种状态-动作函数(即，它涉及状态和动作类的变量)，试图最大化其回报。奖励有助于产生输出(等一下，我将在这之后讨论奖励)。Q-learning 是一种算法，它基本上是这样说的:使用任何策略来猜测一个使未来回报最大化的 Q(即一个动作)。这与你一开始给出的策略无关。Q 算法有点难以理解，但最好以编程方式来考虑。这基本上是一个 for-if-loop，即在你初始化世界后，代表世界中的一个状态和动作，执行动作，测量回报，并更新 q。如果你还没有达到最佳状态，继续做这个，否则，终止循环。

最后，奖励功能:它可以得到超级 wonky。有时候，特别是如果你的数据都是数字，这真的很容易确定。你有一个变量，x，你只要试着让它尽可能的高。在现实世界中，经常会涉及更多的变量，并且它们都相互影响(也就是为什么它是一个函数)。许多人喜欢谈论眼镜蛇效应。《眼镜蛇效应》讲述了印度政府的一项政策，新德里试图鼓励人们为了金钱而引进毒蛇。人们立即开始饲养这些危险的蛇来利用这个系统。你不想训练你的系统采用比问题更糟糕的解决方案。这是一个边缘案例——你的系统的后果希望不是可怕的——但是这个确切的场景可以被抽象为简单地代表你不想从 DRL 模型中得到的所有负面结果。一个更好的例子可能是一个机器人手臂，它正在被训练将积木放在彼此的顶部。代码的作者认为让“奖励”成为距离的度量是一个好主意——尽可能远地放置立方体(作者认为机器人手臂会一直伸出来，并将立方体线性地放置在彼此之上)。机器人最终学会了如何尽可能用力地将东西扔向墙壁。奖励是一项复杂的任务，通常不像简单地最大化变量的单位那么容易。当我写这篇文章时，我意识到我有点跑题了，所以我想在以后的文章中更深入地讨论奖励。

这是深度强化学习背后的基础——这一切都是关于创建一个世界，制作一个代理，给它一组它可以采取的行动，并教它最大化任意奖励，以获得经验和什么行动会导致什么结果的想法。这是一个迷人的想法，希望我能很好地传达它的基本内容。如果你有任何问题，让我知道！

fast.ai 入门

原文：https://towardsdatascience.com/getting-started-with-fast-ai-350914ee65d2?source=collection_archive---------22-----------------------

我对 fast.ai 优秀的《程序员实用深度学习》第一课的体验

在过去的六个月里，我一直在努力从一所大学的兼职数学教师转变为一名数据科学家(或者可能是一名机器学习工程师)，我旅程的下一站是通过 fast.ai 的优秀的“程序员实用深度学习”课程。我实际上在五月份尝试了这门课程，但在第二课中陷入了困境，当时我们应该生产一个模型并制作一个 web 应用程序。我还觉得我的理解没有进步，可能是因为我还不相信自上而下学习的力量。我读了克里斯汀·麦克莱维·佩恩的一条推文，说她在做 fast.ai 之前已经在 Coursera 上做了吴恩达的深度学习专业化。一切都很顺利，在夏天完成了五门专业课程后，我很高兴能回到 fast.ai。

Photo by Crew on Unsplash

我正在完全重新开始，5 月份第一次开始时我没有做笔记，但遵循 fast.ai 联合创始人雷切尔·托马斯和其他人的建议，我正在写“我上周需要阅读的博客”。我首先计划使用 Medium，然后认为在 GitHub 页面上使用 Jupyter 笔记本可能会教我更多有用的技能，并通过使用终端彻底迷失了方向。反正我需要学习使用终端，但是我可以边写博客边学，而不是等到学会了再写博客，发表总比不发表好。

当我开始这门课程时，我会听从 fast.ai 的联合创始人兼课程讲师杰瑞米·霍华德的建议，从头到尾看一遍讲座，然后一边看一边翻阅相应的笔记本。我看完第一课后的第一个任务是设置一个 GPU，我选择了使用谷歌云平台。课程为此提供了详细的说明，对我来说几乎完美无缺，只有一个例外:当我试图通过我的终端连接到我的实例时，我得到一个错误:

因此，我在谷歌上搜索错误信息+“fast.ai”，并在 fast . ai 论坛上找到一个帖子，其中有解决我问题的说明。

现在，我们来看第一课的笔记本！我试图在每件事上都按下 Shift+Enter 键和试图理解每一个细节之间找到平衡。我想我选择的平衡是阅读所有的东西并确保它有意义，但不是试图记住代码。作为一名数学教师，我知道记忆符号感觉像是在学习，但这是一种错误的进步感。相反，我假设当我在我的个人项目中实践这些代码时，它会在我的头脑中固化。

一切对我来说都有意义，直到 resnet50 部分，当我们运行学习率查找器时，我们得到了这个图表:

Figure 1: learning rate finder graph

看着上面的图表，我觉得最佳学习速率(验证损失最低的速率)应该在 1e-2 和 1e-1 之间，但接下来当我们对下面的代码进行微调时，我们将学习速率设置在 1e-6 和 1e-4 之间。

但是默认学习率为 1e-3 的验证损失和错误率相当低:分别为 0.18 和 0.06(见下图)。

Figure 2: results of fitting one cycle with the default learning rate

我并不真的期望提高这些，但为了巩固我对学习率查找器图表的理解，我将重新运行学习率查找器，将学习率设置在 1e-2 和 1e-1 之间，只是为了看看是否有什么变化。

有些事情改变了，而且不是变得更好！比较下图和上图:我的验证损失高达 7319，我的错误率是 0.97！

Figure 3: results of fitting one cycle with a learning rate range of 1e-2 to1e-1

很明显，我对学习率查找器生成的图表有一些误解。我会回去再看一遍那一课。好的，杰里米指的是选择一个在损失开始变得更糟之前结束的范围，回到学习率查找表，我看到它在 1e-1 左右开始变得更糟，这是我设定的范围的终点。看起来 1e-4 到 1e-2 的范围可能行得通？1e-3 的默认比率，之前给我们带来了很好的结果，当然是在这个范围内。

我将用 1e-4 到 1e-2 的范围再试一次:

不，仍然不好，虽然至少这次它从纪元 0 改进到纪元 1，不像以前的尝试:

Figure 4: results of fitting one cycle with a learning rate range of 1e-4 to 1e-2

我将不再摆弄学习率查找器，显然我仍然不太明白其中的细微差别，因为 Jeremy 说我们将在第 2 课中了解更多。我继续前进，其他一切都很顺利，很有意义。

当我在五月第一次完成第一课时，我试着不看第二课而做第二课的笔记，这似乎是在维基的底部建议的。维基没有明确说在试用笔记本之前不要看第二课，但为什么第一课的链接会在维基上？可能对于经验比较丰富的人来说？

总之，继续第二课:对怀孕测试结果进行分类！

第二课(续):深度学习能比鸽子表现得更好吗？

第三课:一万种行不通的方法

第四课:预测服务员的小费

第五课:但是泡菜去哪了？

第六课:每个人都想成为一只猫

我是加州大学东湾分校的数学讲师，也是一名有抱负的数据科学家。在 LinkedIn 上和我联系，或者在 Twitter 上打招呼。

感谢 Vera Chernova 关于在介质上嵌入 Jupyter 代码的说明！

Python 地理数据科学入门—第 2 部分

原文：https://towardsdatascience.com/getting-started-with-geographic-data-science-in-python-part-2-f9e2b1d8abd7?source=collection_archive---------16-----------------------

教程、真实世界项目和练习

Photo by Milada Vigerova on Unsplash

这是 Python 地理数据科学入门系列文章的第二篇。您将学习如何用 Python 阅读、操作和分析地理数据。本系列中的文章按顺序排列，第一篇文章奠定基础，第二篇文章介绍中级和高级地理数据科学主题。第三部分涵盖了一个相关的真实世界的项目，总结巩固你的学习。

第一篇文章可以在这里看到。

[## 通过真实世界的项目和练习掌握地理数据科学

真实世界项目和练习

真实世界项目& Exercisestowardsdatascience.com](/master-geographic-data-science-with-real-world-projects-exercises-96ac1ad14e63)

本教程的学习目标是:
1。了解地理数据框架和地理系列
2。执行表连接和空间连接
3。执行缓冲区和叠加分析

1.地理数据框架和地理系列

让我们阅读国家和引用数据集。

加载数据后，我们得到的是一个带有地理几何图形的表格。除了在 pandas 或简单的 excel 中进行典型的表格数据分析之外，地理几何允许我们执行空间操作。

数据框架与地理数据框架。

地理数据框架是一种包含地理系列的表格数据结构。地理数据框架最重要的属性是，它始终有一个 GeoSeries 列保存特殊状态。该地理系列被称为地理数据框架的“几何”。当将空间方法应用于地理数据框架(或调用类似区域的空间属性)时，此命令将始终作用于“几何”列。

如果有多个列，则有一个数据框或地理数据框。如果其中一列是几何列，那么它被称为 GeoeDataFrame 。否则，如果任何列不是几何列，则它是一个数据帧。同样，一列意味着您拥有 Series 或 Geoseries 数据类型。如果唯一的列是几何列，那么它被称为 Geoseries 。让我们看一个每种数据类型的例子。我们从数据帧开始。

我们这里只有两列，并且没有一列是几何列，因此，该数据的类型将是 dataframe，type 函数的输出是pandas . core . frame . data frame。如果我们的表中碰巧有任何几何列，那么它将是如下所示的地理数据框架。

类似地，Geoseries 是指我们只有一个几何列，而 series 数据类型是指这一列不是几何列，如下所示。

这将分别产生pandas . core . series . series和geo pandas . geo series . geo series。

使用 GeoDataFrame/GeoSeries，您可以执行地理处理任务。到目前为止我们看到的还不多，包括.plot()。另一个例子是得到多边形的圆心。让我们得到每个国家的质心，并绘制它。

这是这个图的样子，每个点代表这个国家的中心。

country centroid

练习 1.1:创建所有多边形几何(国家)的并集。提示使用(。一元并集)

练习 1.2:计算每个国家的面积。提示使用(。面积)

2.表连接与空间连接

表连接是经典的查询操作，例如，我们有两个单独的表，共享一列。在这种情况下，您可以执行一个表连接，使用共享列连接两个表。另一方面，空间连接与地理操作相关，例如，通过位置连接每个城市及其国家。我们将在下面看到这两个例子。

我们可以根据它们共享的列名连接/合并这两个表。这是纯粹的熊猫行动，不涉及任何地理操作。

但是，在空间连接中，合并需要地理操作。我们将执行一个空间连接的示例。我们想根据它们的位置连接下面两个表。例如，哪个国家包含哪个城市，或者哪个城市在哪个国家内。我们将使用 Geopandas 函数.sjoin()进行空间连接，并显示 5 行样本。

从下表可以看出，每个城市都根据地理位置与其对应的国家相匹配。我们使用了 op=within，它获取国家多边形内的城市点。这里我们也可以使用 intersect。此外，我们可以使用 op=contain 并找出包含城市点的国家。

spatial joined table

3.缓冲分析

缓冲区分析是一项重要的地理处理任务。它被广泛应用于许多领域，以获得一个点周围的距离。在这个例子中，我们将首先在瑞典得到一个城市，然后在它周围做一个缓冲区。这里有一件棘手的事情，你需要知道你使用哪一个 CRS/投影来得到你想要的正确输出。如果您的数据没有投影到使用米的投影中，则输出不会以米为单位。这是地理数据领域的一个经典错误。我已经使用这个资源来找出瑞典有哪些以米为单位的 CRS。

[## EPSG 投影-空间参考

主页|上传您自己的参考资料|列出用户提供的参考资料|列出所有参考资料

spatialreference.org](http://spatialreference.org/ref/epsg/sweref99-tm/)

我们在这里使用 3 种不同的缓冲距离，100，200 和 500 在一个点，斯德哥尔摩市。然后我们画出结果来展示缓冲的概念。

buffer Stockholm city example

练习 3.1:创建所有城市的缓冲区。尝试不同的投影和不同的距离。

覆盖物

我们有时需要从不同的数据类型(如点、线和面)中创建新的要素。集合操作或覆盖在这里起着重要的作用。我们将使用相同的数据集，但我们可以使用 Geopandas 中内置的数据集读取机制，而不是从解压缩的文件夹中读取。这个例子来自 Geopandas 文档。

我们可以对数据进行子集划分，只选择非洲。

Africa

为了说明叠加功能，请考虑以下情况:希望使用非洲地理数据框架和首都地理数据框架来识别每个国家的“核心”部分(定义为距离首都 500 公里以内的区域)。

要仅选择首都 500 公里范围内的国家部分，我们将“如何”选项指定为“相交”，这将在这两个图层重叠的地方创建一组新的面:

Africa core overlay

改变“如何”选项允许不同类型的覆盖操作。例如，如果我们对远离首都的国家部分(外围)感兴趣，我们将计算两者之间的差异。

结论

本教程讲述了使用 Geopandas 在地理数据中执行的一些地理处理任务。首先，我们研究了数据框架和地理数据框架之间的差异，然后探索了空间连接。我们还进行了缓冲区分析和叠加分析。在下一个教程中，我们将在项目中应用我们在这一部分和前面部分所学的知识。

该代码可从以下 GitHub 存储库中获得:

[## 沙卡姆/GDS

地理数据科学教程系列。在 GitHub 上创建一个帐户，为 shakasom/GDS 的发展做出贡献。

github.com](https://github.com/shakasom/GDS)

您也可以直接从以下链接运行 Google Collaboraty Jupyter 笔记本:

[## 沙卡姆/GDS

地理数据科学教程系列。在 GitHub 上创建一个帐户，为 shakasom/GDS 的发展做出贡献。

github.com](https://github.com/shakasom/GDS/blob/master/Part2_Geoprocessing.ipynb)

Python 地理数据科学入门—第 3 部分

原文：https://towardsdatascience.com/getting-started-with-geographic-data-science-in-python-part-3-ddf55130840b?source=collection_archive---------13-----------------------

案例研究/项目演练

Photo by Markus Spiske on Unsplash

这是 Python 地理数据科学入门系列文章的第三篇。您将学习如何用 Python 阅读、操作和分析地理数据。第三部分，也就是本文，涵盖了一个相关的真实世界项目，旨在巩固你的学习成果。

本系列的文章可在此处获得:

[## 通过真实世界的项目和练习掌握地理数据科学

真实世界项目和练习

真实世界项目& Exercisestowardsdatascience.com](/master-geographic-data-science-with-real-world-projects-exercises-96ac1ad14e63) [## Python 地理数据科学入门—第 2 部分

教程、真实世界项目和练习

towardsdatascience.com](/getting-started-with-geographic-data-science-in-python-part-2-f9e2b1d8abd7)

本案例研究的学习目标是:
1 .对真实世界数据集项目
2 应用空间操作。空间连接和管理地理数据。
3。探索性空间数据分析(ESDA)

项目设置

在这个项目中，我们将使用两个数据集:一个按年龄分类的人口数据集和来自瑞典统计局的学龄前数据集。因为我们处理的是学龄前儿童，所以我们将关注 0 至 5 岁的儿童。根据欧盟统计局最近的统计数据，瑞典被认为是欧洲第三大婴儿制造国。在这个项目中，我们将分析 5 岁以下人口的地理分布以及幼儿园的分布。

人口数据集以低级别分类格式(投票区域)出现，每个区域有 700 到 2700 人口。另一方面，幼儿园数据集是坐标点格式，包含全国幼儿园的地址。在对两个数据集进行简短的探索性数据分析后，我们将执行预处理和空间连接地理处理任务来合并两个数据集。这是统计每个地区幼儿园数量的路线图。

包含空间操作:使用空间连接来确定哪些幼儿园位于面区域内，或者换句话说，哪些人口区域包含幼儿园点。
按规模分组到每个地区的幼儿园总数。
将按数据框分组与人口数据集合并。

最后，我们将进行探索性空间数据分析(ESDA ),调查不同地区的幼儿园的空间分布。

让我们首先将两个数据集读入 Geopandas。我们首先需要从 dropbox 链接访问数据集，并将其解压缩。

通过查看人口数据集的前几行，值得注意的是该数据集的几何是一个多边形。每个区域都有一个独特的代码(【Deso】)和一堆其他属性。 Age0_5 代表每个地区 0 到 5 岁的儿童数量。总人口存储在 Tot_pop 列中。

Population dataset

另一方面，幼儿园有存储每个学校坐标的点几何。学校名称以及地址、城市和邮政编码作为列出现在这个数据集中。

Preschools dataset.

在下一节中，我们将进一步了解这两个数据集的某些方面。

探索性数据分析

在开始地理处理任务之前，让我们分析数据集以总结主要特征。在预处理和建模之前探索数据集可以帮助您更好地掌握数据集。我们从总共有 5985 行和 32 列的人口数据集开始。让我们用.describe()方法做一个描述性统计的总结。这是人口数据集描述统计的输出。

Descriptive statistics of the population dataset

下图显示了人口数据集中 Age0_5 列的分布。

正如你从下面的分布图中看到的，它向右倾斜，右边有一条长尾巴。

distribution plot of children between age 0–5

由于我们正在处理地理数据，我们也可以可视化地图。在本例中，我们将构建一个 0 至 5 岁儿童的 Choropleth 图。首先，我们需要通过计算age 0 _ 5/Tot _ pop来计算该区域的子密度，从而创建一个新的age 05 _ density列。

输出地图通过颜色显示每个区域的儿童数量。

Choropleth Map

这张地图清楚地显示了这些地区儿童的分布情况。在北部，儿童密度很低，而在东部、西部和南部，儿童密度很高。

最后，让我们在 choropleth 地图上叠加幼儿园，看看学校的分布。

输出地图通过颜色和学龄前数据集的叠加显示每个区域的儿童数量。

Choropleth map and Preschools

相当乱。我们无法确切知道每个地区有多少所幼儿园。这就是空间连接和地理处理任务派上用场的地方。在下一节中，我们将执行几个预处理任务来获取每个区域内的幼儿园数量。

空间连接

统计每个地区的幼儿园数量。该流程包含以下内容:

使用空间连接来确定面区域内的幼儿园。
按规模分组到每个地区的幼儿园总数。
将按数据框分组与人口数据集合并。

以下代码用于执行空间连接并创建一个新的地理数据框，其中包含每个区域中学校的数量。

因此，如果我们现在查看merged _ population数据集的前几行，我们会注意到我们有一个额外的列prefessional _ count，其中存储了每个地区的学龄前儿童人数。

spatial join — preschool counts

现在我们可以并排检查年龄密度的分布图，以及基于学龄前儿童数量的新分布图。

Left choropleth map of preschool counts. Right Choropleth map of Age 0–5

然而，我们无法对这两种完全不同的特征进行有意义的比较。正如你所看到的，学龄前儿童的数量在 0-10 之间，而年龄密度在 0-24 之间变化。在统计学中，就像我们之前执行的 EDA 一样，我们假设数据集中的观测值是独立的，但是，对于地理数据集，存在很强的空间依赖性。想想瓦尔多·托布勒的地理第一定律:

“一切事物都与其他事物相关，但近的事物比远的事物更相关。”

因此，在下一节中，我们将更深入地挖掘并执行探索性的空间数据分析。

探索性空间数据分析(ESDA)

空间统计和探索性空间数据分析(ESDA)是非常广泛的。在本节中，我们将只查看空间关联的局部指示符(LISA ),以检测该数据集中的空间自相关，并探索邻近位置的特征及其相关性。这可以帮助我们研究和理解空间分布和结构，以及检测这些数据中的空间自相关。

为了更仔细地查看这些空间统计数据，我们首先读取县数据集，将我们的数据分成瑞典人口最多的两个城市(斯德哥尔摩和哥德堡)的子集，然后与我们预处理的人口数据集合并。

我们将使用 Pysal 和 Splot 库进行空间自相关。这是权重的设置和变换。我们将 prefessional _ count 作为 y 变量，并执行 Queen weights 转换。然后，我们使用权重创建一个空间滞后列(y_lag ),以获得不同多边形基于其地理区域的相似性。

现在我们可以计算 Moran 的 I local 来检测聚类和离群值。

让我们画出两个城市的莫兰 I。

上面代码的输出如下所示的两个散点图。斯德哥尔摩具有负的空间自相关，而哥德堡市具有正的空间自相关。

Moran’s I Local Scatterplot

这些图还将点划分为四个象限，以将局部空间自相关的类型指定为四种类型:高-高、低-低、高-低、低-高。右上象限显示 HH，左下象限显示 LL，左上象限显示 LH，左下象限显示 HL。用地图可以清楚地看到这一点，所以让我们把它放到地图上。

下面两张地图清楚地显示了这些地区不同的集群。在斯德哥尔摩，HH 空间聚类不是集中在一个地方，而在哥德堡，我们有大量具有 HH 值的相邻区域。

Local Indicator of Spatial Association (LISA)

这描绘了一个比我们开始的 choropleth 图更清晰的画面，可以给你一个不同的空间集群位于何处的清晰指示。

结论

该项目演示了使用 Python 执行地理数据的地理处理任务。我们首先执行探索性数据分析(EDA ),然后执行空间连接并创建新数据集。在最后一部分，我们讲述了探索性空间数据分析(ESDA ),以更深入地了解地理数据集及其空间分布。

该代码可从以下 GitHub 存储库中获得:

[## 沙卡姆/GDS

地理数据科学教程系列。在 GitHub 上创建一个帐户，为 shakasom/GDS 的发展做出贡献。

github.com](https://github.com/shakasom/GDS)

您也可以直接从以下链接运行 Google Collaboraty Jupyter 笔记本:

[## 谷歌联合实验室

编辑描述

colab.research.google.com](https://colab.research.google.com/drive/17-LykLsQI930f1W4eoOlBvteJme0tbQk)

地理空间作品入门

原文：https://towardsdatascience.com/getting-started-with-geospatial-works-1f7b47955438?source=collection_archive---------9-----------------------

使用本指南开始您的地理空间世界之旅

Location of the Active Volcanoes in the United States

地理信息系统的应用只受到使用它的人的想象力的限制

——杰克·丹格蒙德

地理空间数据？那是什么？

地理空间这个术语相对较新，自 20 世纪 80 年代以来越来越流行。包含地理内容的数据被归类为地理空间数据。这包括坐标、邮政编码、城市或地址。但仅有坐标不足以理解整个数据集。必须有一些关于坐标符号，例如，坐标所代表的位置的名称。我们称之为属性数据。

还是不确定？看看下面的数据。

VOLCANX020 : NAME        : LOCATION      : LATITUDE   :  LONGITUDE
   509     : Baker       : US-Washington : 48.7767982 : -121.8109970
   511     : GlacierPeak : US-Washington : 48.1118011 : -121.1110001
   513     : Rainier     : US-Washington : 46.8698006 : -121.7509995
   515     : St.Helens   : US-Washington : 46.1997986 : -122.1809998

在这里，火山的数量和名称是属性数据，位置、纬度和经度是地理空间数据。例子让事情变得简单一千倍，不是吗？

GIS 中的数据类型

正如我们已经讨论过的，GIS 数据可以主要分为两类-空间参考数据和属性数据。空间参考数据可进一步分为两种不同的类型-矢量和栅格。我们来挖掘一下什么是矢量和栅格数据类型。

矢量数据

向量数据由存储为(x，y)坐标对的单个点组成。这些点还可以按特定顺序连接以创建线，或者连接成闭合环以创建面。让我们了解所有三种不同的类型——点、线(或弧)和多边形。

点数据通常用于表示独立的数据点和不相邻的(彼此不相邻)特征。为了表示点数据，我们可以使用半径和不同的颜色来区分各个要素。例如，指出火山(本文的横幅图片)，定位特定城市的政府办公室、学校和购物中心。

Active volcanoes in the US (Github)

线数据当然是用来表示线状特征的。这些特征都有起点和终点。我们通常使用实线而不是虚线，或者颜色的组合，甚至线条的粗细来区分不同的特征。主要的例子是道路、河流或地铁线路。

Source

多边形数据用于表示湖泊、城市甚至森林的边界。这些特征是二维的，可用于测量所需地理特征的面积。下图显示了美国的失业情况，完美地描述了多边形数据。

The unemployment rate in the US (city-wise)

矢量数据的格式

矢量数据和栅格数据具有不同的文件格式。对于任何 GIS 分析人员来说，处理一个未知的 GIS 文件都是非常困难的，因此最好了解一下您将要处理的文件格式的类型。有一些常见的和不常见的格式，让我们了解一下它们是什么，它们是如何工作的。

Esri Shapefile
文件类型 —。shp，。dbf，。shx，。到目前为止，最常见的地理空间文件是 shapefile。它被所有商业和开源组织广泛接受。不仅仅是被接受，它已经成为行业标准。您将需要制作 shapefile 所必需的所有三个文件。您可以使用其他文件格式来创建 shapefile，但这些格式是可选的，不是强制性的。
地理 JavaScript 对象符号
文件类型 —。geojson，。json
描述 —俗称 GeoJSON，是基于 web 的制图最常用的格式。它将坐标以文本形式存储在 JSON 表格中，包括矢量点、线、多边形以及表格信息。GeoJSON 将信息(读取对象)存储在花括号{}中，与 GML 相比，它没有那么复杂，我们将在几分钟后了解它。
地理标记语言
文件类型 —。gml
描述 — GML 类似 GeoJSON。它以文本的形式存储信息(或特征),可以在任何文本编辑器中轻松更新。此外，每个要素都有一个属性列表-点、线、曲线和多边形。然而，正如我们所讨论的，GML 是复杂的，因为它为相同数量的信息产生更多的数据。
谷歌锁眼标记语言
文件类型 —。kml，。kmz
描述 —这种格式基于 XML，主要用于 Google Earth 的开发。它最初是由 Keyhole Inc .开发的，后来被谷歌收购。KMZ (KML 压缩)取代 KML 成为谷歌地球的默认地理空间格式，因为它是 KML 文件的压缩版本。

栅格数据

另一种类型是栅格数据，用于表示表面。它是基于单元的数据，由组织成列和行(或网格)的单元(或像素)矩阵组成，其中每个单元代表信息。简单来说，数码照片是栅格数据的一个例子，其中每个像素值代表一种特定的颜色。栅格数据的其他示例包括航空照片、数字高程模型，甚至是扫描地图。

Image source

栅格数据的格式

栅格数据也有特定的文件类型。因为它们是由网格组成的，所以在大多数情况下，它们是规则的空间和正方形的，但并不总是这样。以下是其中的一些。

GeoTIFF
文件类型 —。tif，。tiff，。ovr
描述 —对于 GIS 和卫星遥感应用，GeoTIFF 已经成为行业标准。如上所述，它总共由三个文件组成，但可能会附带其他文件:。tfw，。xml 和。补助的
ERDAS Imagine
文件类型 —。img
描述 —是 Hexagon geospatial 开发的专有文件格式。这些文件通常用于栅格数据，以存储单波段和多波段的卫星数据。想象一下，文件使用一种分层格式来存储文件的基本信息。
IDRISI 光栅
文件类型 —。rst，。rdc
描述-IDRISI 将 RST 与所有栅格图层相关联，栅格图层由实数、整数和字节形式的数字矩阵像元值组成。RDC(光栅文档文件)是 RST 文件的配套文本文件。

数据源

我们现在知道地理空间作品中有什么类型的文件。但是我们从哪里得到它们呢？我们必须从可靠的来源获取数据，这样我们获取的数据文件就不会有不常见的格式。

[Esri 开放数据](https://hub.arcgis.com/search)数据类型-电子表格、KML、shapefile、GeoJSON 等。这就像一个隐藏的免费 GIS 数据宝藏，拥有来自 4000 多个组织的超过 67300 个开放数据集。在某些情况下，你可能不得不把你的下载合并成一个。但是，尽管付出了努力，这个单一的来源是你找到你想要的东西的最好机会。
自然地球数据数据类型—文化、物理和栅格(底图)数据。它很好地满足了制图师的需求。在大范围内，所有关键的文化和物理矢量 GIS 数据都可供您使用。最棒的是。它属于公共领域。这意味着您有权以任何方式修改数据供您使用。
USGD 地球探索者数据类型—遥感数据
对于观测地球、寻求遥感数据的人来说，这是你唯一的归宿。它有一个用户友好的界面，让您可以访问最大的航空和卫星图像数据库之一。除此之外，它甚至有一个批量下载应用程序，以防万一你需要它。
NASA 的社会经济数据和应用中心 数据类型—社会经济数据
SEDAC 是关于人类与环境的互动。它拥有广泛的数据，包括(但不限于)农业、灾害、健康、人口、可持续性、贫困和水。
UNEP 环境数据浏览器
数据类型—淡水、人口、森林、气候、排放。
它包含 500 多个变量，但由于接口的原因，浏览 GIS 数据有点困难。如果你去那里，你可以过滤“地理空间数据集”并下载数据。
DIVA-GIS
数据类型—国家、全球级别数据
DIVA-GIS 是一款用于制图和地理数据分析的免费计算机程序。但是在数据页面上，你会发现一个很好的数据集列表，从全球气候到物种出现数据。

可视化工具

包装

在专用分析包的帮助下，我们可以轻松地可视化小型和大型数据。即使您没有处理软件包的经验，也只需要很少的学习时间。所以别担心，开始吧。

geo plot
geo plot 是一个高级 python 地理空间可视化库。它是对cartopy和matplotlib(另外两个伟大的可视化库)的扩展，使得映射变得容易。
叶子
叶子建立在 python 的数据角力优势和leaflet.js库的可视化/映射优势之上。它有大量来自 OpenStreetMap、Mapbox 和 Stamen 的内置 tilesets。此外，它支持图像和视频，以及 GeoJSON 和 TopoJSON 叠加。
geo pandas
geo pandas 从根本上说是一个开源项目，使使用 python 处理地理空间数据变得更加容易。然而；它扩展了对地图的支持，使用 Geopandas 创建基本地图就像在公园里散步一样。点击了解更多。
PySAL
PySAL 是一个开源的跨平台库，专为地理空间数据科学设计，重点是矢量数据。它支持高级应用程序的开发，如空间聚类和异常值检测、探索性时空数据分析等。
rworldmap和rworldxtra
使用 r 绘制地理空间数据同样容易。rworldmap 支持绘制国家级和网格化用户数据集，而 rworldxtra 提供源自自然地球数据的高分辨率矢量国家边界。****

开源软件

有了这些免费的 GIS 软件，你就可以像使用专有的 GIS 软件一样完成工作。

PostGISPostGIS 是 PostgreSQL 对象关系数据库的开源空间数据库扩展器。它支持地理对象，允许在 SQL 中运行位置查询。大多数软件产品使用 PostGIS 作为数据库后端，包括下面列出的 QGIS 和 GrassGIS。
QGIS
QGIS 满载着触手可及的隐藏宝石。您可以自动化地图制作、处理大规模地理空间数据以及生成制图图像。我们还需要什么？最新版本(QGIS 3)带有一套全新的制图、3D 和分析工具。
GrassGIS
地理资源分析支持系统是一个应用广泛的 GIS 软件套件。它提供地理空间数据管理和分析、图像处理、地图制作、空间建模和可视化等功能。
优步大学的可视化团队正在创建行业级开源框架来加速大数据。主要有四种套装可用——甲板、亮度、反应贴图和反应视觉。开普勒是用 deck.gl 构建的，利用 WebGL 更快更高效地渲染大数据。

尾注

如果没有合适的资源，学习新的东西有时会是一项乏味的任务。这就是为什么我们决定把这些碎片放在一起，并创建一个最终的文章，让你开始地理空间工作。我们很想知道该指南是否对您有所帮助——尤其是在地理空间工作入门方面。

关于 Locale :我们从一个个人问题开始 Locale。作为处理地理空间数据的数据科学家，现有的分析产品在我们的日常工作流程中毫无用处。因此，我们必须为我们的日常工作流程构建自己的工具。

然后，我们意识到全球的数据科学家面临着类似的问题。因此，企业正在努力利用他们的位置数据来提高运营效率。我们打算一劳永逸地解决这种痛苦。因此，我们完全从零开始构建一个工具来处理大规模的实时地理空间数据。在这里了解更多。

如果你想更多地了解我们的工作，请通过 aditi@locale.ai 向我们发送电子邮件，提出你的所有问题。如果你对同样的问题产生共鸣，并希望做出贡献，我们也在为不同的角色招聘。

感谢 Aditi 帮我完成这篇文章。

Git 和 GitHub 入门:完全初学者指南

原文：https://towardsdatascience.com/getting-started-with-git-and-github-6fcd0f2d4ac6?source=collection_archive---------0-----------------------

Git 和 GitHub 基础知识，供好奇和完全困惑的人使用(以及为您的第一个开源项目做出贡献的最简单的方法！)

Photo by James Bold on Unsplash

想开始使用 Git 和 GitHub 吗？你需要与团队合作吗？你正在做一个项目吗？你最近有没有发现，如果你希望有人认真对待你的技术，你非常需要上 GitHub？

……你真的只想为你的 第一个开源项目 做贡献吗？

这是给你的！

Photo by Greyson Joralemon on Unsplash

Git 完全可以轻松上手。如果你阅读速度很快(注册和安装不会花太多时间)，你可以在 GitHub 上运行 10 分钟。

如果您一直阅读本文，您可以练习克隆一个现有的存储库、创建一个分支、进行更改以及创建一个拉请求。在这个过程中，您可能还会学习如何找到您的终端，如何使用终端命令，以及如何编辑 markdown(。md)文件！

如果你做到了这一切，恭喜你！

你将促成你的 第一个开源项目—GitHub 欢迎墙 ！(如果你想直接进入开源贡献部分，向下滚动直到你点击名为“让我们开始吧！”)

这篇文章将帮助您掌握基本知识。当然，如果你想像专业人士一样使用 Git 和 GitHub，还有很多东西要学。您可以超越这些介绍性信息！不过，我们将在下一次讨论下一级的内容。

我们开始吧！

Git 是什么？GitHub 是什么？

Git 是现在从开发人员到设计人员，几乎每个人都选择的版本控制技术。GitHub 是目前使用最多的社交代码托管平台。这是一个可以玩耍和实验的地方。在这里，您可以找到(并体验)最令人难以置信的开源信息、新兴技术、特性和设计。这是一个学习和参与的地方。您可以在那里保存工作或学习用的代码，也可以获取一些想要进一步探索的代码。你甚至可以直接从你的存储库中免费托管网站！(如果你想知道怎么做，看看这篇文章！)

Photo by Jamie Haughton on Unsplash

使用 Git 和 GitHub 的方法有很多，但是 GitHub 的入门并不一定要非常困难。你不需要成为某种编码大师或什么的。你甚至可以在 GitHub 网站上做最重要的事情！

也就是说，找到你的终端并对它感到一点点舒适是个好主意。终端命令让事情变得更快！我一定会告诉你如何开始使用 GitHub 网站。我还将向您展示一些终端命令，您可能希望使用它们来使您的生活稍微好一点。

每当您在本文中看到包含这些标记的命令:< >，您都想删除这些标记并用您自己的信息替换它们之间的内容。

假设你看到类似于git add <filename>的东西。这意味着，例如，如果您想要将名为“hello_world.py”的文件添加到 GitHub 存储库中，您可以键入git add hello_world.py。

我会在这里给你很多解释，但这些都是你真正需要知道的终端命令:

git clone
git status
git add
git commit -m “ “
git push

就是这样！那些是大的！如果你掌握了这些，你就可以开始了。你可以立即开始你的项目！

Photo by Delaney Dawson on Unsplash

我们还会谈到

git init
git branch
git merge
git checkout

你可能会和其他人一起工作，或者你可能想做些改变，并在真正提交之前测试一下。上面的命令是您开始协作所需要的。

git help

如果你刚刚开始，这也是非常有用的！我们也会讨论这个问题。

(如果你在 Mac 上，你已经有一个终端了！您可以通过点击屏幕右上角的放大镜图标并搜索单词“terminal”来搜索它)

第一步:注册和安装！

去 GitHub 注册一个账号。你可以就此打住，GitHub 会工作得很好。不过，如果你还没有安装 Git 的话，安装 Git 是个好主意。没有它，您完全可以开始工作，但是如果您想在本地计算机上工作，那么您需要安装 Git。你可以下载它或者通过你的包管理器安装它。

现在去你的终端向 Git 自我介绍吧！要为您计算机上的每个存储库设置您的用户名，请键入

git config --global user.name "<your_name_here>"

引用中用自己的名字替换“”。您可以使用任何您想要的名称或句柄。如果您只想为一个存储库命名，请省略“全局”一词

现在你可以告诉 Git 你的邮箱了，确保这是你注册 GitHub 时用的同一个邮箱

git config --global user.email "<[your_email@email.com](mailto:your_email@emal.com)>"

保持电子邮件的私密性很容易，你可以在本文中找到这些说明。你只需要在你的 GitHub 账户里勾选两个框。

现在您已经准备好开始在您的计算机上使用 Git 了！

Photo by Matty Adame on Unsplash

首先，您可以在 GitHub 网站上创建一个新的存储库，或者执行git init从您的项目目录创建一个新的存储库。

存储库由三棵树组成。首先是工作目录，它保存实际的文件。第二个是索引或暂存区。然后是头，它指向你最后一次提交。

我已经习惯了终端(选项 1)

以下是从终端开始的方法:

如果您有一个项目目录，只需转到您的终端，在您的项目目录中运行命令

git init

如果希望用项目目录中的所有文件初始化项目，请运行

git init .

囊括一切。

假设您的项目有一个名为“new_project”的文件夹您可以在终端窗口中找到该文件夹，并通过运行以下命令向其中添加一个本地存储库

cd new_project
git init

现在您的项目目录中有了一个名为.git的新隐藏目录。这是 Git 存储所需内容的地方，这样它就可以跟踪您的项目。现在，您可以使用以下命令将文件逐个添加到临时区域

git add <filename_one>

或者跑

git add .

将所有文件添加到临时区域。您可以使用命令提交这些更改

git commit -m "<add a commit message here>"

如果你对你的改变感到满意，你可以跑步

git push

推动你的改变。您可以随时通过运行以下命令来检查您是否有要完成的更改

git status

如果您进行了一些更改，您可以使用一次更新上的文件

git add <filename>

或者

git add --all

然后用你的提交信息提交它们，并推动它们通过。

就是这样！现在，您可以初始化一个存储库，提交文件，提交更改，并将它们推送到主分支。

如果你已经明白了这一点，只需向下滚动到“学习与他人合作”继续学习分支和协作！

Photo by Jonathan Daniels on Unsplash

我不知道你刚才说什么(选项 2)

我将假设任何对选项 2 感兴趣的人对所有这些都是全新的，并且可能有一个装满文件的文件夹(或者你计划有一个)想要放在 GitHub 上，但是你不知道如何做。

让我们实现它吧！

假设您想要创建一个新的存储库。(你大概有吧！这就是你的项目所在的地方。如果您不打算创建一个新的存储库，您可能想要克隆一个现有的存储库。我们接下来会谈到这一点，但这就是你获取其他人的项目和信息的方式，而这些正是你工作或所学课程所需要的。)

您的资源库是您组织项目的地方。您可以保存文件夹、文件、图像、视频、电子表格、Jupyter 笔记本、数据集以及项目需要的任何其他东西。在使用 Git 之前，您必须为您的项目初始化一个存储库，并设置它以便 Git 管理它。你可以在 GitHub 网站上这样做。

包含一个关于你的项目信息的自述文件是个聪明的主意。您可以在创建存储库的同时，通过单击复选框来创建一个。

转到 GitHub 网站，在右上角查看，点击+号，然后点击“新建存储库”
命名存储库，并添加快速描述。
决定您是希望它成为公共存储库还是私有存储库
如果要包含自述文件，请单击“用自述文件初始化此存储库”。(我绝对推荐这样做！这是人们在查看你的存储库时首先要看的东西。这也是一个放置信息的好地方，你需要这些信息来理解或运行这个项目。)

New repository

Creating your new repository

如果你愿意，你完全可以从这一点开始工作！您可以直接从 GitHub 网站上的存储库中上传文件、编辑文件等等。然而，您可能不仅仅满足于这个选项。

有两种方法可以对项目进行更改。你可以在电脑上修改你的文件/笔记本，也可以直接在 GitHub 上修改。

假设您想对 GitHub 上的自述文件进行一些修改。

首先，去你的仓库。
单击文件名以显示该文件(例如，单击“README.md”转到自述文件)。
单击文件右上角的铅笔图标，进行一些更改。
在框中写一条简短的消息，描述您所做的更改(如果需要，还可以写一段较长的描述)。
单击“提交更改”按钮。

Editing your file on GitHub

Committing your changes

现在已经对新存储库中的自述文件进行了更改！(我想快速地将您的注意力吸引到上图中您可以勾选的小按钮上，它将允许您为这个提交创建一个新的分支，并启动一个拉请求。这个我们以后再说！)

很简单，对吧？

我更喜欢在我的本地计算机上处理文件，而不是试图让 GitHub 网站上的所有东西都工作，所以让我们现在就开始吧。

给我那个项目！

您可能想要克隆新的存储库，以便可以在本地计算机上使用它，或者您可能有一个想要克隆的现有存储库。(这可能是你在一个项目或课程中需要做的事情。)

为了克隆一个库到你的电脑上，去 GitHub 网站上的库，点击绿色的大按钮“克隆或下载”(如果您不能处理它，您可以直接在那里下载存储库并跳过终端的内容。但我相信你，所以继续前进！)确保上面写着“和 HTTPS 一起克隆”现在单击剪贴板图标，将其复制并粘贴到您的剪贴板上(或者突出显示该链接并复制它)。

Clone or download a repository

现在，您将打开您的终端并到达您希望存储库着陆的地方。例如，你可以输入

cd Desktop

放到桌面上。然后在那里克隆您的存储库，使其易于查找。要克隆存储库，您可以键入

git clone <that_thing_you_just_copied>

简单！(不要忘记将< >标记之间的信息更改为您刚刚复制的那串字母和数字！另外，确保删除了< >。)

如果你以前没有在终端中移动过，你可以用cd命令慢慢移动，直到你到达你想去的地方。例如，打开你的终端，输入ls，列出你下一步可能去的地方。你可能会看到“桌面”列表，你只需输入cd Desktop就可以进入你的桌面。然后您可以运行上面的git clone命令将您的存储库克隆到您的桌面上。

您可能会看到一些用户名，而不是像“桌面”这样的选项在这种情况下，您需要在看到“桌面”之前选择一个用户，因此选择带有cd <user>的用户(用用户名替换<user>，然后再次键入ls以查看您的选择。你现在很有可能会看到“桌面”。如果您看到列出的桌面，您将输入cd Desktop。现在继续进行 git 克隆吧！

如果你想在终端中后退一步，只需输入cd ..

现在你有了一个新的 GitHub 库，你可以在你的桌面上使用它了！该命令将存储库的完整副本拉入到您的系统中，您可以在系统中对其进行操作、进行更改、暂存更改、提交更改，然后将更改推回 GitHub。

如果你不想的话，你不需要把存储库放在你的桌面上。你可以在任何地方克隆它。您甚至可以在打开终端后立即运行git clone命令。不过，我要说的是，如果你不太习惯在电脑上导航，把你的项目放在你能看到的桌面上并不是一个坏主意…

如果你想独自玩一个项目，你可以在 GitHub 网站上派生它，而不是克隆它。在屏幕右上角附近查找“fork”按钮，然后单击它。这将在您的存储库中创建一个存储库副本，供您自己使用，而无需对原始版本做任何修改。

现在是时候给你的项目添加一些文件了！

Photo by Nadim Merrikh on Unsplash

这就是我们将要做的:

git status
git add
git commit -m " "
git push

没什么好担心的！

我想你可能有一些文件想放在新的存储库中。继续，找到您的文件，并将其拖放到您在桌面上创建的存储库的新文件夹中，就像您通常会将任何一组文件移动到文件夹中一样。

现在，检查你的项目的状态！

转到您的终端，进入存储库的文件夹。那就跑

git status

看看是否一切都是最新的。(如果你只是把一些文件拖到你的项目文件夹里，那肯定不是！)要将您的一个文件添加到存储库中，您应该运行

git add <fileneame>

否则，您可以用

git add --all

以至

git add .

这些是你提议的改变。你可以对全新的文件和已经存在但有一些改变的文件做同样的事情。你实际上还没有添加任何东西。你带来了新的文件和变化，引起了 Git 的注意。

要提交更改，您将通过运行以下命令来启动该过程

git commit -m “<commit message>”

您正在将更改提交到头部，而不是远程存储库。(确保你用自己的信息替换掉引号中的信息。)在您做出更改之后，您可以使用“commit”命令拍摄存储库的“快照”。您将使用-m 在该“快照”上包含一条消息。

当你保存一个改变时，这叫做提交。当您提交时，您将包含一条关于您更改了什么和/或为什么更改的消息。这是让别人知道你改变了什么以及为什么改变的好方法。

现在，您的更改位于本地工作副本的头部。要将更改发送到您的远程存储库，运行

git push

将您的更改直接推送到您的存储库中。如果您在本地计算机上工作，并且希望您的提交也在线可见，那么您可以使用 git push 命令将更改推送到 git hub。

您可以通过运行git status命令随时查看是否一切都是最新的！

所以现在你有了一个 GitHub 库，你知道如何添加文件和修改！

恭喜恭喜！！！

学习与他人合作

协作是 GitHub 上游戏的名字！

Photo by Quinten de Graaf on Unsplash

GitHub 流

假设你有一个正在进行的项目，你可能在任何时候都有很多不同的想法和特性。有些功能可能已经准备好了，但有些可能还没有。也许你和其他人一起工作，他们都在做他们自己的事情。这就是分支的用武之地！

分支是一个独立的空间，你可以在那里尝试新的想法。如果您更改了分支上的某些内容，它不会影响主分支，直到您希望它这样做。这意味着你可以在那个分支上做任何你想做的事情，直到你决定是时候合并它了。

唯一能永久改变事物的分支是主分支。如果您不希望您的更改立即部署，那么在一个单独的分支上进行您的更改，并在准备好的时候将它们合并到主分支中。

如果您与其他人一起工作并希望自己进行更改，或者如果您自己工作并希望在不影响主分支的情况下进行更改，您需要一个单独的分支。您可以随时创建新的分支。

在您的终端中创建一个名为“new_feature”的分支并使用

git checkout -b new_feature

一旦创建了分支，就可以对该分支进行更改。这让你很容易看到你改变了什么，为什么要改变。每次提交更改时，您都会添加一条消息来描述您所做的工作。

再来说说结账！

git checkout

允许您签出当前不在其中的存储库。您可以通过以下方式查看主分支机构

git checkout master

或者查看“新功能”分支

git checkout new_feature

当您完成一个分支时，您可以将所有的更改合并回去，这样每个人都可以看到它们。

git merge new_feature

会将您对“new_feature”分支所做的所有更改添加到主文件中。

为了创建上游分支以便您可以推送您的更改并将远程分支设置为上游分支，您将通过运行

git push --set-upstream origin new_feature

在您做出一些更改并决定喜欢它们之后，您可以打开一个拉取请求。如果你在一个团队中，这时团队中的其他人可以开始检查你的更改并进行讨论。你可以在任何时候提出一个拉取请求，无论是让别人查看你的最终修改，还是因为你遇到了困难而寻求帮助。

嗯……什么？我可以在网站上做吗？

你可以！

GIF via GIPHY

一种方法是简单地选中我们之前在编辑自述文件时提到的那个按钮。超级容易！

您还可以随时在网站上创建一个新的分支，方法是转到您的存储库，单击屏幕左中间附近的下拉菜单“Branch: master”，键入一个分支名称，然后选择“Create branch”链接(或按键盘上的 enter 键)。现在你有两个看起来一样的分支了！这是一个进行更改和测试的好地方，在您想让它们影响主分支之前。

Creating a branch

如果您正在处理一个单独的分支，您的更改只会影响该分支。

如果您对您的更改感到满意，并且想要将您的更改合并到主分支，您可以打开一个拉请求。这就是如果你在一个团队中，你将如何提出你的改变，并请某人审阅它们，或者将你的贡献合并到他们的分支中。

您可以在提交后立即打开一个拉请求，即使您还没有完成代码。如果你觉得更舒服的话，你可以在网站上这样做。如果您已经对您的分支做了一些更改，并且您想要合并它们，您可以

单击屏幕顶部中央附近的“拉取请求”选项卡
点击绿色的“新拉动请求”按钮
转到“示例比较”框，选择要与原始分支进行比较的分支。
仔细检查你的修改，确保它们确实是你想要提交的。
然后点击绿色的“创建拉动式请求”按钮。给它一个标题，并写一个简短的描述你的变化。然后点击“创建拉动式请求！”

New pull request

Create pull request

现在，如果这是您的存储库，您可以通过单击绿色的“Merge pull request”按钮将更改合并到 master 中来合并您的 pull 请求。单击“确认合并”，然后在紫色框中的“删除分支”按钮将您的分支合并后删除该分支。

如果你正在为一个项目做贡献，团队中的人(或评审者)可能会有问题或评论。如果你需要改变什么，现在正是时候！如果一切顺利，他们可以从分支部署变更，以便在您合并之前进行最终测试。并且您可以部署您的更改以在生产中验证它们。

如果您的更改已经过验证，那么您可以继续将您的代码合并到主分支中。“拉”请求将保存您所做更改的记录，这意味着您可以随时查看它们，以了解所做的更改和决策。

更新和合并

如果你在你的电脑上工作，想要最新版本的库，你可以用git pull命令从 GitHub 下载修改。要将本地存储库更新为最新的提交，请运行

git pull

在您的工作目录中。

要将另一个分支合并到活动分支中，请使用

git merge <branch_name>

Git 将尝试自动合并更改，但这并不总是可能的。可能会产生冲突。如果是这样，您需要手动合并冲突。更改后，您可以将其标记为与git add <filename>合并。在将更改与合并之前，您可以预览它们

git diff <source_branch> <target_branch>

您可以使用以下命令切换回主分支

git checkout master

您将进行更改，然后在完成后删除该分支

git branch -d new_feature

这个分支对其他任何人都不可用，除非您使用

git push origin <branch>

其他有用的命令

首先，这是我最喜欢的 GitHub 小抄。查看所有最有用的 Git 命令！

如果运行，您可以看到存储库的提交历史

git log

您可以查看一个人的提交

git log --author=<name>

您可以查看已更改但尚未登台的内容

git diff

需要帮助记住应该运行什么命令吗？尝试

git help

查看 21 个最常用的命令。您也可以键入类似这样的内容

git help clone

弄清楚如何使用像“克隆”这样的特定命令

我们开始吧！

Photo by Mervyn Chan on Unsplash

为什么不留下你的印记，欢迎每一个来这里学习 Git 和 GitHub 的人呢？我们将创建一个简单的欢迎墙，上面有每个想要尝试 Git 和 GitHub 并为他们的第一个开源项目做出贡献的人的笔记。

你可以在欢迎墙上添加任何你想要的东西，只要你保持它的温暖和鼓励。添加注释，添加图像，无论什么。以任何让你开心的方式让我们的小世界变得更好。(如果你是一个多虑者(我看你是❤️)，我在自述文件中有一个预先写好的信息，你可以复制并粘贴。)

在 GitHub 网站上或者通过运行

git clone [https://github.com/bonn0062/github_welcome_wall.git](https://github.com/bonn0062/github_welcome_wall.git)

创建一个新的分支，在“welcome_wall.md”文件中添加一个欢迎和鼓励的思想。您可以在网站上这样做，但是我真的鼓励您尝试将存储库克隆到您的计算机上，用您最喜欢的文本编辑器打开文件，并在那里添加您的消息。就是好学！
创建一个拉取请求。
写一个简短的注释来描述您的更改，然后单击绿色按钮来创建您的拉动式请求。

就是这样！如果它是一个不错的信息、思想、图像或想法，我会合并你的请求，你将成功地为一个开源项目做出贡献。

恭喜你！！！你做到了！

GIF via GIPHY

一如既往，如果你用这些信息做了什么了不起的事情，我很乐意听听！在回复区留言或随时在 Twitter 上联系。

感谢阅读！

如果你想接触或者找到更多很酷的文章，请到内容简约来和我一起吧！

掌握 Git 和 GitHub 的基础知识

原文：https://towardsdatascience.com/getting-started-with-git-github-6235f5ae3a0b?source=collection_archive---------18-----------------------

Photo by Max Duzij on Unsplash

软件工程

开始使用 Git & GitHub 所需要知道的一切

Prod 已关闭！这次又是什么？我们编写的测试用例涵盖了我们能想象到的所有用例——在我们昨天更新服务后，它们都通过了。如果我们能够回到过去，调查我们代码最近的所有变化，看看哪里出错了！这就是 Git 要解决的类型的问题。

在本文中，我将向您展示如何使用 Git 来跟踪项目中文件的历史，以便您能够在项目中出现 bug 时进行诊断。

Git 和 GitHub 有什么区别？

GitHub 是一个允许用户托管文件的网络应用程序，有点像 DropBox 或 Google Drive——但它是为托管 Git 库而设计的。 Git 是一个命令行工具，主要由程序员用来管理软件项目的版本管理(历史)。每个项目都存在于一个保留所有变更历史的 Git 仓库中。

1.安装 Git

通过下面的链接，你可以点击页面顶部你正在使用的操作系统来安装 Git。在你安装了 Git 之后，如果你在 Windows 上，进入你的命令提示符，或者如果你在 MacOS 或 Linux 上，进入你的终端。键入“git”并按回车键。如果你看到任何关于 Git 的信息，说明你安装正确！如果您得到“找不到命令”——尝试卸载并重新安装 git，或者重新配置您的环境变量。

[## 下载

Git 带有内置的 GUI 工具(git-gui，gitk ),但是有几个第三方工具供用户寻找一个…

git-scm.com](https://git-scm.com/downloads)

2.创建 GitHub 帐户

下面的链接会带你去 GitHub。在那里，您可以使用您的电子邮件地址设置一个帐户。

[## 一起打造更好的软件

GitHub 汇集了世界上最大的开发人员社区来发现、共享和构建更好的软件。来自…

github.com](https://github.com/)

3.创建您的第一个存储库

在 GitHub 的任何页面上，当您登录时，您会在右上角工具栏中的个人资料图片旁边看到一个白色加号。单击加号将显示一个下拉菜单，您应该在其中选择:“新存储库”。在那里，您应该将存储库命名为“Master _ Git _ And _ GitHub _ Basics _ Article”——考虑到它们不允许在名称中使用空格。您不需要添加描述，并且可以启用默认的“公共”访问。对于本课，您不应该选中“用自述文件初始化”复选框，最后，您不需要添加一个. gitignore 文件或一个许可证 —因此您可以单击底部的“创建存储库按钮。

接下来的页面会有很多微小的吓人的文字。在此页面上，您需要担心的唯一信息是顶部标有“快速设置”的蓝色阴影框。在蓝色的“快速设置”框内，确保选择了“ HTTPS ”，而不是“宋承宪”。在菜单的最左侧有一个剪贴板图标按钮，您可以选择它将您需要的 URL 地址复制到您的计算机上。

在您的终端或 git bash 中，使用“ cd directory_name ”命令转到您想要放置存储库的目录。然后运行下面的命令( 用你从 GitHub 复制的 URL 替换我的 URL):

**git clone** [**https://github.com/ClairvoyantCoding/Master_Git_And_GitHub_Basics_Article.git**](https://github.com/ClairvoyantCoding/Master_Git_And_GitHub_Basics_Article.git)

Cloning the repository and then changing directory into the repository (Image by author)

运行该命令应该会在运行该命令的目录中创建一个空文件夹。你可以认为克隆一个库就像下载it — 但是更多。它还会下载对这些文件所做的所有更改的历史记录。让我们在命令提示符或终端中运行命令"CD Master _ Git _ And _ GitHub _ Basics _ Article"进入我们刚刚克隆的新存储库。现在我们已经在存储库中了，我们可以使用以下命令来获取存储库的状态:

**git status**

git status 命令将向我们展示自上次提交以来对我们的库所做的所有更改。对我们来说，它会说:

Checking the status of our repository using “git status” (Image by author)

注意:如果您的 Git Bash/Terminal/Command 提示符没有显示相同的配色方案和绿色的“(main #)”消息，不要担心。我将 Git Bash 配置文件配置为给我这些额外的颜色和消息。

所有这些告诉我们的是，我们还没有任何历史，因为我们没有任何提交。您可能想知道“branch main 上的是什么意思——但是我们将在下一篇文章中解决这个问题。现在我们将添加一些历史。

4.创建我们的第一个提交

在 Git 仓库中，我们在提交中记录历史。正如我们在 git status 输出中看到的，我们目前没有提交。为了创建一个提交，我们需要在我们的存储库中做一些更改。在文件资源管理器或 finder 窗口中创建一个新文件，并将其拖到存储库目录中。我的文件将只是没有内容的“ file.txt ”。现在，如果我返回到我的命令提示符或终端并运行" git status "，我将看到我的新文件:

Using the “touch” command to create a file and running “git status” to see the changes to the repository (Image by author)

现在你可以看到 git status 在向我们展示我们的变化时是多么有用。您会注意到 file.txt 文件列在未跟踪文件中。记住 Git 想要跟踪存储库中发生的所有变更——但是我们必须告诉它要跟踪哪些文件。为了使这一点更明显，让我们添加第二个名为 file2.txt 的文件，这样我们可以看到当我们跟踪一个文件而不跟踪另一个文件时会发生什么。在将第二个文件添加到存储库中并验证它在您运行" git status 时显示为未跟踪之后，我们将学习下一个 Git 命令:

**git add file.txt**

我们使用“git add”选择要跟踪的文件。请注意，我们只选择了第一个文件。现在，当我们运行 git status 时，我们得到了输出:

Creating file2.txt, adding file.txt so it’s ready to commit, and checking the status of the repository (Image by author)

请注意， file.txt 列在新标题下:“待提交的变更”，而 file2.txt 仍列在“未跟踪”下。请记住，我们并没有通过添加文件来跟踪任何东西——我们只是在提交时选择了要跟踪的文件。既然我们已经选择了要添加到提交中的更改，我们可以使用以下内容创建项目中的第一个提交:

**git commit -m "adding file.txt"**

该命令将创建我们的提交，并显示消息:“正在添加 file.txt ”。每一个提交都必须有一个消息来描述发生了什么变化，这样在未来就可以很容易地浏览我们的历史。让我们看看我们的提交命令的输出:

Commiting the file.txt we added in the previous step (Image by author)

这告诉我们，我们添加了一个新的提交，即“根提交”，因为这是第一个提交。未来提交将不会是“根提交”。我们的提交有消息“添加了 file.txt ”，它只包含一个文件更改，我们在那里创建了“ file.txt ”。最后，我们将学习另一个命令，该命令将按降序列出我们存储库中的所有提交:

**git log**

该命令输出:

Using git log to see all of our previous commits (Image by author)

只列出了一个提交，因为我们只有一个，它还告诉我们每个提交的作者、日期和消息。

5.推动你的改变

一旦您提交了您的更改——没有人能够在您的 GitHub 个人资料上看到它们，除非您使用以下命令推送您的代码:

**git push**

Pushing your changes from your local machine to your GitHub repository (Image by author)

现在，您的更改已经上传到您的 GitHub，供所有人查看。去看看！

See the file.txt file we pushed from our local repository to our GitHub online repository (Image by author)

注意， file2.txt 不在这里，因为我们没有选择提交它。我们可以点击屏幕中间工具栏最左边的“ 1 commit ”来查看我们所有的提交，就像 git log 向我们展示的那样。

6.现在怎么办？

现在你知道如何使用 git 命令了:克隆，状态，添加，提交，日志，以及推送。现在，您可以用新的变更不断更新您的存储库。 git 添加您更改的文件以选择它们为提交的。然后提交一条描述你做了什么的消息，然后将推送到 GitHub 让其他人看到。请继续关注下一个教程，在那里我们将学习所有关于使用 git 分支在我们的软件项目中与其他开发者合作的内容。

在这里找到本文使用的 GitHub 库

要学习更高级的 Git & GitHub 概念，你可以在这里阅读我的第二篇 Git & GitHub 文章

感谢阅读！我很乐意听到你的反馈或回答任何关于我的文章的问题，所以请在下面评论。

Google BigQuery 机器学习入门——泰坦尼克号数据集

原文：https://towardsdatascience.com/getting-started-with-google-bigquerys-machine-learning-titanic-dataset-ab7294efb863?source=collection_archive---------9-----------------------

W 虽然还在测试阶段，biqquery ML已经从去年年中开始发售；然而，直到最近，我才开始使用这个基于谷歌云的机器学习产品。作为一名非数据科学家，我的第一印象——有什么不喜欢的？毕竟，对于任何一个分析师来说，从基于 web 的 SQL 编辑器中舒适地运行 ML 模型的能力是梦想成真。这个平台不仅消除了学习编程语言的需要，无论是Python还是SAS；它还通过利用现有的 BigQuery 数据源简化了数据工程过程，而不必将外部数据引入到您的模型中。实际上，该产品消除了进入这一令人垂涎的数据科学专业的许多障碍，并通过允许任何具有足够的 SQL 知识的分析师运行线性和逻辑回归模型，而不必投资昂贵的硬件，例如通常需要支持可扩展 ML 项目的多核GPU。下图很好地展示了平台的功能:****

BigQuery ML demo from Google AI Blog

许多有抱负的数据科学学生转向值得信赖的 泰坦尼克号:机器从灾难中学习 来自最受欢迎的 Kaggle 竞赛的数据集来练习使用二进制分类模型。事实上，对于一个初学者来说，二元分类模型是一个相当容易掌握的概念:你的任务是简单地预测某个事件是否会发生；或者某个条件将评估为真还是假。对于这个问题，任何人都能够理解这样一个概念，即预测一名特定的泰坦尼克号乘客是否能在有史以来最具纪念意义的沉船事故中幸存下来:这里只有两种可能性。要跟进，你只需登录现有的 Kaggle 帐户或创建一个新的帐户，并下载所有三个文件提供。使用 Kaggle 网站(谷歌早在 2017 年就收购了)和 BigQuery 平台(谷歌的另一款产品)的讽刺意味并没有在我身上消失。让我们使用示例数据集和一个工作中的 BigQuery 实例来深入研究这个问题。**

我们可以应用不同的分析框架来确定需要哪些步骤来完成手头的任务。对我有效的方法通常包括以下内容，让我们在机器学习过程中采用它:

了解你的数据
争论你的数据
执行分析

不言而喻，理解我们在这里试图完成的是什么是理所当然的。与你可能面临的任何业务问题类似，我们必须准确理解这项工作的目标是什么:选择相关因素来帮助我们准确预测某个乘客是否能在泰坦尼克号失事中幸存。

第一步——探索泰坦尼克号数据集

A .定义数据

首先，让我们看看 Kaggle 为我们提供的数据。我们可以将三个 CSV 文件:训练和测试数据集，以及性别 _ 提交作为可供我们分析的三个数据库表。我们将使用训练集来建立我们的机器学习模型，同时我们将在测试集上运行模型来预测结果(沉船的存活率。)提交表可以作为一个模板，我们可以通过将结果提交给 Kaggle 进行评分来测试我们预测的准确性。根据数据字典，在我们的训练表中有相当多的字段，我们可以在预测存活率的解决方案中考虑这些字段:****

**passengerid—分配给每位乘客的唯一 ID；

**幸存——幸存标志，其中 1 的值表示乘客幸存， 0 表示遇难乘客——这代表我们试图预测的目标值；

Pclass —旅客的车票等级，也可以解释为社会经济地位的代理: 1 代表头等车票/上层市民， 2 代表二等车票/中层，而 3 代表三等车票持有者/下层市民；

姓名 —乘客姓名；

性别 —乘客的性别，请记住，为了建立模型，我们需要将这种字符串类型的记录转换为数字数据类型；

年龄 —乘客的年龄(年)；

SibSp —一起旅行的兄弟姐妹/配偶人数；

Parch —一起旅行的父母/子女人数；

车票 —旅客的车票号码；

票价 —乘客票价，该乘客为其车票支付了多少钱；

**客舱—分配给乘客的客舱号；

**已装船—装船港( C =瑟堡， Q =皇后镇， S =南安普顿)

B .确定丢失了什么

我们可以从查看数据集中缺失的**值开始。当处理像我们这样的小数据集时，快速抽查通常就足够了。事实上，只要浏览记录，我们就可以确定只有三个字段缺少值:年龄、船舱和上船。为了量化丢失值的影响，让我们对这些数据运行第一个 SQL 查询:******

似乎五分之一的记录缺少年龄值，而四分之三的舱室记录找不到，891 个记录中只有两个缺少登船标志:****

请注意，我在查询中使用了标准 SQL ，并将我们的训练数据导入到保存在 BigQuery 实例中的 dataset_Titanic 数据集内的 prj-titanic 项目的 tbl_train 表中。**

实际上，不是所有可用的变量(或我们应该选择在模型中使用它们的特征)都应该在任何给定的预测模型中使用；在泰坦尼克号数据集的情况下，我们可以从有史以来票房第二高的电影**中回忆起 妇女和儿童优先 政策对妇女和儿童有利，他们在使用救生艇方面享有优先权。头等舱乘客似乎是下一个受青睐的群体。让我们研究我们的数据，看看事实上性别、年龄和阶级是否可以很好地预测乘客的存活率。**

C .哪些数据是相关的？

下面的快速查询验证了上述关于性别维度的假设。根据提供的数据，女性几乎是 4(！)比男性更有可能在这次事故中幸存下来:

**********

Survival rate by gender

请注意，上面的图表来自无缝的 BigQuery 和 DataStudio 集成；来自谷歌的真正端到端探索性数据分析解决方案。

当查询存活率的 Pclass 变量时，我们还可以确认乘客类别实际上应该是我们模型的特征/预测值之一:

Survival rate by passenger class

当涉及到可视化数据时，使用分类数据比使用连续数据类型的值要容易得多。在我们绘制年龄变量的结果之前，让我们对不同年龄段的乘客进行分类。你可能会想到更好的解决方案，但我个人会使用五个年龄组:

儿童-13 岁以下

少年-13 至 18 岁之间

青壮年 -年龄在 19 至 35 岁之间

成年- 36 至 55 岁年龄段

老年公民——55 岁以上。

当我们运行新的查询时，很明显，儿童的存活率确实比其他年龄组高得多。青少年占据了第二的位置:

**********

Survival rate by Age category

自然，很难想象诸如姓名、乘客 ID 、车票等类似的字段可能与生存有任何关系，然而其他不太直观的字段实际上可能是有帮助的。如果我们按开始的类别来看存活率，会发生什么？忽略两个显示 100%存活率的缺失记录，瑟堡在存活率方面从其他两个港口中脱颖而出，皇后镇比南安普顿更受欢迎:

Survival rate by port of embarkation

步骤 2—数据清理

A .处理缺失值

完成 EDA 过程后，是时候让我们参与一些基本的数据争论任务了。假设我们热衷于使用上面讨论的所有四个字段:年龄、*性别、p 类和已着手，我们需要考虑 177 缺失年龄*值和 2 已着手值。**

让我们根据我们所知道的关于乘客的一切来推断出装货港。最简单的解决方案是根据乘客的登机点来查看乘客的分布情况，南安普敦代表了所有乘客的 72% :

Number of passengers by port of embarkation

此外，我们可以考虑使用 PClass 信息来查看大多数头等票持有者是否从特定的港口出发。在以下查询的帮助下，我们可以确定 59% 的乘客也是从南安普顿出发的:

完成该任务的另一种方法是查看舱室信息是否可用于填充这些缺失值。经过一些基本的搜索我们可以得知舱字段的第一个字母指的是甲板，这自然与乘客等级值高度相关。在我们的例子中， B 恰好代表长廊(不要与上层长廊混淆)甲板。看看这个甲板上已知的装载港口的乘客分布，这是一个公平的掷硬币决定，大约一半的人( 51.11% 准确地说)从南安普顿开始他们的旅程，剩下的一半来自瑟堡。

总结以上所有发现，让我们大胆地(经过计算)假设缺失的上船值应该被赋值为 S 【南安普顿】的值。]处理 177 缺失的年龄值并不简单，部分原因是这个样本的大小，部分原因是数据集中缺少可靠的预测因子。我们也许可以通过查看乘客的名字来解读他们的头衔，并做出可靠的假设，即所有已婚乘客(夫人等)肯定不是孩子。除了查看数据中的平均值或众数，放大他们的实际年龄会变得更加困难。让我们简化我们的生活，在这里采取简单的方法:让我们忽略所有缺少年龄值的记录，希望有足够大的剩余数据集用于我们的预测模型。

B .为模型准备数据

说到模型，它们不能很好地处理文本/字符串数据类型，我们需要将所有这些字段转换成数值。例如，对于性别字段，我们或许可以将值 1 分配给所有男性，将值 0 分配给所有女性。****

转到头等舱领域，我们可以从之前的观察中回忆起，头等舱的乘客比二等舱的乘客更有可能存活。然而，如果我们仅使用 1 和 2 的名义值用于各自的票等级，这种关系将被错误地解释为二等票乘客比一等票持有者更有可能死亡 两倍于 。我们可以通过创建三个字段(每个乘客等级一个)并相应地标记记录来扩展这种关系。头等票持有者将在 PClass1_Flg 字段中具有值真(读:1)，并且对于 PClass2_Flg 和 PClass3_Flg 列具有值假(读:0):****

我们将对年龄类别字段应用类似的原则，并根据乘客年龄组创建五个新字段来标记记录。**

第三步——运行我们的机器学习泰坦尼克号模型

A .创建我们的模型

我们终于完成了所有的准备工作，准备进入项目的最后阶段。为了演示创建我们的模型是多么容易，让我们遵循下面的 BigQuery ML 语法，并运行我们的第一个基于单一特征的逻辑回归模型——性别:

******CREATE OR REPLACE MODEL `ModelName`
      OPTIONS (model_type = 'logistic_reg') AS 
SELECT field(s) FROM TableName******

Who knew that it only takes a couple of lines of SQL code to create a Machine Learning model?

B .评估模型结果

评估我们的模型只需要一行代码，结果看起来相当有希望

******SELECT * FROM ml.evaluate(model `ModelName`)******

运行我们的模型

关键时刻到了，让我们对照测试数据运行我们的模型，让我们创建一个包含模型结果的表格:**

SQL Code for the table containing model predictions

处理单个功能/专栏并不困难，但是我们从 EDA 中回忆起，性别似乎是生存的最佳预测因素。是时候将这个表格保存为 CSV 格式，并制作我们的 Kaggle submission 。这个相当轻松的练习产生了 76.55% 的准确率，使我们在所有 Kaggle 参赛者中名列前茅 74% 。不需要太多的分析能力就可以看出，这个分数实际上是与其他 1，481 名竞赛参与者共享的，因此，实际上，我们处于前 60% ！从这里开始肯定有成长的空间，但对于第一次尝试来说不会太寒酸。

Kaggle ranking for the first submission

D .实验和优化

测试和迭代绝对是这里的精神。我们可以通过使符合我们的需求来进一步试验这个模型，可以改变学习率、设置正则化、限制迭代次数等等。所有这些参数都可以在模型语句的选项部分找到。**

此外，我们可以尝试通过改变所使用的特征来提高我们的模型的准确性；让我们使用这种方法。我非常难过地意识到，通过添加额外的特征(年龄类别、乘客级别和装载港口)，模型的准确性实际上下降了:

Another less successful Kaggle submission

我们应该可以做得更好，对吗？如果我们考虑到这样一个事实，即家庭成员呆在一起互相帮助可能会有更好的生存机会。幸运的是，我们可以加上一起旅行的父母/孩子的数量( parch )和兄弟姐妹/配偶的数量( sibsp )来计算家庭的总人数。这有助于了解根据我们之前的 EDA，这两个字段中没有缺失值。还请注意，独自旅行的乘客在任一字段中都会有 0 值。让我们建立一个新的、更全面的、更准确的模型:

这种策略是正确的，我们略微提高了我们提交的准确性到 77% ，并向上移动了 1476 位，绕过了所有使用性别作为唯一预测指标的人。我们现在只与 583 家竞争对手分享我们的位置，实际上使我们进入了前 54% ！

我不确定我们可以达到什么样的实际准确度水平，(排行榜上所有 95%以上的分数看起来都很可疑)，但要记住的一点是，模型的类型可能在这里发挥作用，也许随机森林可以产生比分类更好的结果？尽管如此，要提高我们的分数，还有很多工作要做。

如果你正在寻找接下来的步骤，谷歌确实为两者提供了 BigQuery ML 入门指南:数据分析师和数据科学家赛道。祝你的机器学习之旅好运！请分享你的想法和使用的方法，如果你在你的结果中更成功的话！

2019 年 3 月 31 日编辑——感谢 Felipe Hoffa 提供的非常翔实的评论，我了解到我上面使用的一些代码实际上是多余的；事实上，BigQuery 让事情变得更加简单。

替换此代码:

****CREATE OR REPLACE MODEL `xxx.xx`
OPTIONS (model_type='logistic_reg') AS
SELECT Survived AS label,
CASE WHEN Sex = 'male' THEN 1 ELSE 0 END AS Gender****

有了这句话:

****CREATE OR REPLACE MODEL `xxx.xx`
OPTIONS (model_type='logistic_reg') AS
SELECT Survived AS label,
Sex****

如果你想学习更多的 BigQuery 和 BigQuery ML 技巧和诀窍，请阅读 Felipe 的精彩文章和他到目前为止分享的所有其他文章。

附注抱歉，菲利普，旧习难改:我把你的例子中的前导逗号换成了我的尾随逗号。

Google Colab 入门

原文：https://towardsdatascience.com/getting-started-with-google-colab-f2fff97f594c?source=collection_archive---------0-----------------------

为沮丧和困惑的人准备的简单教程

Photo by FuYong Hua on Unsplash

你知道它就在那里。你知道在某个地方有免费的 GPU，就像一个胖胖的，多汁的，成熟的黑莓挂在稍微够不着的树枝上。

美丽的闪电般的速度只为你等待。

想知道到底如何让它工作？你来对地方了！

Photo by Breno Machado on Unsplash

对于任何还不知道的人来说，谷歌已经做了有史以来最酷的事情，它提供了基于支持免费 GPU 的 Jupyter 笔记本的免费云服务。这不仅是一个提高你的编码技能的伟大工具，而且它还允许任何人使用流行的库来开发深度学习应用程序，如 PyTorch 、 TensorFlow 、 Keras、和 OpenCV。

Colab 提供 GPU，而且完全免费。说真的！

当然，这是有限度的。(当然，具体细节可以在他们的常见问题页面上找到。)支持 Python 2.7 和 3.6 ，但还不支持 R 或 Scala 。你的会话和大小是有限制的，但是如果你有创造力并且不介意偶尔重新上传你的文件，你肯定可以绕过它…

Colab 是从提高 Python 编码技能到使用深度学习库的理想选择，比如 PyTorch 、 Keras 、 TensorFlow 和 OpenCV 。你可以在 Colab 中创建笔记本，上传笔记本，存储笔记本，共享笔记本，安装你的 Google Drive 并使用你存储在那里的任何东西，导入你最喜欢的目录，上传你的个人 Jupyter 笔记本，直接从 GitHub 上传笔记本，上传 Kaggle 文件，下载你的笔记本，以及做你想做的任何事情。

太牛逼了。

第一次在 Google Colab 中工作完全是惊人的简单，但是也有一些小的挑战！如果你对 Jupyter 笔记本有所了解的话，你可以使用 Google Colab，但是有一些小的区别可以让你在自由的 GPU 上自由飞翔和坐在电脑前用头撞墙…

Photo by Gabriel Matula on Unsplash

这篇文章是写给那些困惑、沮丧、只想让这件事成功的人的！

设置您的驱动器

为你的笔记本创建一个文件夹

(从技术上讲，如果你想开始在 Colab 中工作，这一步并不是完全必要的。然而，由于 Colab 是在您的驱动器之外工作的，所以指定您想要工作的文件夹并不是一个坏主意。你可以去你的 Google Drive 点击“新建”,然后创建一个新文件夹。我之所以提到这一点，是因为我的谷歌硬盘上令人尴尬地散落着看起来像一百万个零散的 Colab 笔记本，现在我不得不处理这些。)

如果你愿意，当你已经在你的 Google Drive 中的时候，你可以创建一个新的 Colab 笔记本。只需点击“新建”，将菜单下拉至“更多”，然后选择“合作实验室”

否则，你可以直接去谷歌实验室。

游戏开始。

您可以通过单击笔记本的名称并更改它，或者通过将“文件”菜单下拉到“重命名”来重命名您的笔记本

设置您的免费 GPU

想用 GPU？就像进入“运行时”下拉菜单，选择“更改运行时类型”，在硬件加速器下拉菜单中选择 GPU 一样简单！

获取编码！

如果您愿意，现在就可以轻松地开始运行代码！你可以走了！

让它变得更好

想要安装您的 Google Drive 吗？使用:

from google.colab import drive
drive.mount('/content/gdrive')

然后你会看到一个链接，点击它，允许访问，复制弹出的代码，粘贴到框中，点击回车，你就可以开始了！如果你没有在左边的边框中看到你的驱动器，只需点击“刷新”,它就会显示出来。

(运行单元，单击链接，复制页面上的代码，将其粘贴到框中，按 enter 键，当您成功安装驱动器时，您会看到这一点):

现在，您可以在屏幕的左侧看到您的驱动器！(您可能需要点击“刷新”)此外，您可以通过以下方式随时找到您的驱动器

!ls "/content/gdrive/My Drive/"

如果您想下载一个共享的 zip 文件链接，您可以使用:

!wget 
!unzip

例如:

!wget -cq [https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip](https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip)
!unzip -qq flower_data.zip

这将在几秒钟内为您提供 Udacity 的花卉数据集！

如果你上传的是小文件，你可以用一些简单的代码直接上传。然而，如果你愿意，如果你不想运行一些简单的代码来获取一个本地文件，你也可以只去屏幕的左侧，并点击“上传文件”。

谷歌 Colab 在几乎每个层面上都非常容易使用，尤其是如果你对 Jupyter 笔记本非常熟悉的话。然而，抓取一些大文件并让几个特定的目录工作确实让我犯了一两分钟的错误。

我在另一篇文章中介绍了开始使用 Google Colab 中的 Kaggle，所以如果你对此感兴趣，请查看一下！

导入库

进口是相当标准的，除了少数例外。

在大多数情况下，你可以像在其他笔记本上一样运行import来导入你的库。

PyTorch 不一样！在运行任何其他 Torch 导入之前，您需要运行

更新！(01/29) Colab 现在支持原生 PyTorch！！！你不需要运行下面的代码，但是我把它留在这里，以防有人有任何问题！

# [http://pytorch.org/](http://pytorch.org/)
from os.path import exists
from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag
platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())
cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\.\([0-9]*\)\.\([0-9]*\)$/cu\1\2/'
accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'!pip install -q [http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl](http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl) torchvision
import torch

然后你可以继续进口。如果你试图简单地运行import torch，你会得到一个错误信息。我真的建议点击弹出的非常有用的链接。如果你这样做，你会得到代码的权利，你可以只点击“安装火炬”将其导入到您的笔记本电脑。代码会在你屏幕的左侧弹出，然后点击“插入”

不能用 import 语句简单地导入您想要的其他东西？尝试 pip 安装！请注意，Google Colab 希望在大多数命令前有一个感叹号。

!pip install -q keras
import keras

或者:

!pip3 install torch torchvision

并且:

!apt-get install

也有用！

我确实发现枕头可能有点问题，但是你可以通过跑步来解决

import PIL
print(PIL.PILLOW_VERSION)

如果你得到低于 5.3 的任何东西，进入“运行时”下拉菜单，重启运行时，并再次运行单元。你应该可以走了！

通过将“文件”拖放到“新 Python 3 笔记本”，可以很容易地创建一个新笔记本。如果你想打开某个特定的东西，把“文件”菜单下拉到“打开笔记本…”

然后你会看到一个类似这样的屏幕:

如你所见，你可以打开一个最近的文件，来自你的 Google Drive 的文件，GitHub 文件，你也可以在那里上传一个笔记本。

GitHub 选项很棒！您可以轻松地按组织或用户进行搜索来查找文件。如果您没有看到您要找的内容，请尝试检查存储库下拉菜单！

永远储蓄

保存您的工作很简单！你可以做好 ol 的“command-s”或者下拉“File”菜单来保存。您可以通过拖放“文件”->“在驱动器中保存副本”来创建笔记本的副本你也可以通过“文件”->“下载”来下载你的工作簿。ipyb”或“下载. py”

这至少应该足以让您在 Colab 上运行，并利用那个可爱的免费 GPU！请让我知道，如果你遇到任何其他的新手问题，我也许可以帮助你。如果可以的话，我很乐意帮助你！

如果你想接触或找到更多酷的文章，请来和我一起在内容简约！

如果你是数据科学、机器学习和人工智能的新手，你可能想看看 NumPy 的终极初学者指南！

[## NumPy 初学者终极指南

开始使用 NumPy 需要知道的一切

towardsdatascience.com](/the-ultimate-beginners-guide-to-numpy-f5a2f99aef54)

或者你可能对其中的一个感兴趣！

如何毫不费力地用 GitHub 页面免费创建一个网站(即使你不知道自己在做什么)
数据清理和预处理完全入门指南
WTF 是图像分类？
深度学习简介:为新手和新手征服神经网络
如何构建准确率大于 97%的图像分类器

或者也许你想知道如何让你自己的帖子被注意到！

[## 如何撰写和发表引人注目的文章

创建内容的简单技巧，易于查找，阅读起来令人兴奋

medium.com](https://medium.com/swlh/how-to-write-and-publish-articles-that-get-noticed-60e9701daed4)

Photo by Sarah Cervantes on Unsplash

感谢阅读！❤️

使用 Flow 开始使用 H2O

原文：https://towardsdatascience.com/getting-started-with-h2o-using-flow-b560b5d969b8?source=collection_archive---------13-----------------------

看看 H2O 的开源 UI，它将代码执行、文本、情节和富媒体结合在一个文档中。

[](http://Image by PublicDomainPictures from Pixabay)

数据收集很容易。做决定很难。

今天，我们可以访问海量的数据，这些数据每天都在增加。这主要是由于数据收集能力的激增和存储这些收集的数据的计算能力的增加。然而，收集数据是一回事，理解数据完全是另一回事。从数据中获得洞察力应该是快速和容易的，并且获得的结果应该是容易解释和说明的。H2O 提供了一个单一的平台，通过更快更好的预测建模，使评分和建模成为可能。

【H2O】是一个分布式可扩展机器学习的内存平台。顺便说一句，H2O 既是产品的名字，也是产品背后的公司( H2O.ai )的名字。它是完全开源的，使用大家熟悉的接口，比如 R、Python、Scala、Java、JSON，甚至还有一个 web 接口。H2O 的最新版本被称为 H2O-3，它可以与 Spark 和 Hadoop 等多种大数据技术无缝合作。还有，H2O 支持很多常用的机器学习算法，比如 GBM 、随机森林、深度神经网络、 Word2Vec 、堆叠集成等等。

High-Level architecture of H2O

请随意查看我的文章，标题为 与 H2O 一起民主化机器学习 ，这篇文章概述了 H2O 及其安装和使用。

H2O 流

H2O 流 是 H2O 的独立接口。我们可以使用浏览器指向本地主机，然后直接与 H2O 引擎通信，而不必处理 Python 或 R 或任何其他语言。它是一个很棒的工具，可以通过一个简单的 web 界面，使用 H2O 所有可用的优秀算法快速建立数据模型，无需任何编程。人们可以很容易地运行神经网络，GBM，GLM，K-means，朴素贝叶斯等。只需点击几下。

Flow 是 H2O 的一个基于网络的界面，是新用户入门和学习 H2O 提供的所有可用功能和算法的好方法。

Flow 可以被认为是用于探索性数据分析和机器学习的GUI++REPL+讲故事环境的混合体，具有异步、可重写的记录/回放功能。这里有一份关于 H2O 流量的优秀的 用户指南 供阅读更多相关内容。

设置

H2O 在 Java 上运行，这是它工作的先决条件。H2O 使用 Java 7 或更高版本，你可以在 Java 下载页面获得。

从这个链接下载 H2O，并遵循下面定义的步骤。

Installing H2O

安装运行后，将浏览器指向http://localhost:54321进入流程界面。

连接

如果你用过 Jupyter Notebook，Flow 的界面会显得很熟悉。就像在 Jupyter 笔记本里一样，Flow 也有两种单元格模式:编辑和命令。访问此链接了解更多关于单元模式的信息。

Flow Interface

工作

Flow 将命令作为一系列可执行单元发送给 H2O。可以对单元格进行修改、重新排列或保存到库中。在 Flow 中，我们可以在文本单元格和可执行单元格之间切换，我们可以键入或让 H2O 生成一个可编程运行并在用户之间共享的 CoffeeScrip t。要执行单元格，点击CTRL+ENTER 或使用工具栏中的Run 图标。

现在让我们在 Flow UI 中使用 H2O 来处理一个机器学习问题，并仔细看看它的各种功能。

使用 H2O 预测客户流失

预测客户流失是客户关系管理(CRM)领域的一个众所周知的问题，也是现代营销策略的一个关键要素。留住客户对组织来说非常重要，我们将看到 H2O 如何通过快速创建预测模型，然后利用这些见解来提高客户忠诚度，从而在数据科学管道中发挥重要作用。

使用的数据集属于 2009 KDD 杯挑战赛。这也可以在流程界面的Examples > Browse installed packs > examples > KDDCup 2009_Churn.flow 下访问。或者，使用以下链接分别访问培训和验证数据:

训练数据
验证数据

这是我们将用来执行训练和预测的流程管道。

Machine Learning Pipeline

1.导入/上传数据

在自动完成搜索输入字段中输入文件路径，然后按 Enter 键。从搜索结果中选择文件，并点击Add All 链接进行确认。我们也可以上传一个本地文件，或者直接提到数据集的 url。

让我们看看如何将训练数据导入到流接口中。

解析数据

下一步是解析导入的数据。我们可以选择解析器的类型，但大多数情况下，H2O 会自动为我们找出答案。在解析设置页面中，我们可以选择列名和列类型。对于 churn 列，让我们将数据类型从 numeric 改为 enum ，它代表分类变量。Churn 列是响应列，因此在模型构建过程中，该列将自动扩展为虚拟变量。

接下来，当您点击parse按钮时，数据被解析并转换成.hex格式。

也可以通过点击相应的列来可视化每个标签数据。让我们想象一下流失列及其各种分布。

建筑模型

在我们继续模型构建过程之前，需要做两件重要的事情:

输入缺失数据

点击Data选项卡下的估算选项，选择数据集所选列的估算标准。

将数据拆分为训练集和测试集。

通过指定分割比率来实现分割数据，并相应地创建训练和测试帧。点击数据下拉菜单，选择分割框。

建立一个 GBM 模型

一旦您完成了对数据的探索，您就可以开始构建将投入生产的预测模型。点击Model选项卡，Flow 弹出所有可用算法的列表。H2O 支持各种各样的算法，从 GLM 到 GBM 到 AutoML 到深度学习。以下是完整的列表:

为了这篇文章，我们将构建一个通用助推机 (GBM)，这是一种前向学习的集成方法。选择数据集和响应列，并将所有其他选项保留为默认值，然后构建模型。

查看模型

我们还可以查看模型结果，这有助于我们快速判断模型的表现。我们得到了评分历史、ROC 曲线、变量重要性和许多其他相关信息，这些信息对判断我们模型的性能非常有帮助。

验证数据的预测

在我们构建并调整了模型的参数以获得一些合适的指标之后，我们就可以对我们的验证数据集进行预测了。将验证数据集导入流程界面，并点击分数>预测选项卡，进行必要的预测。

生产模型

数据科学家的最终目标不仅是构建一个健壮的模型，而且是一个可以轻松投入生产的模型。H2O 允许您将您构建的模型转换成一个普通的旧 Java 对象或优化的模型对象。H2O 生成的 MOJO 和 POJO 模型旨在易于嵌入到任何 Java 环境中。因此，如果有一个用于监控客户流失的内部应用程序，我们可以轻松快速地导出一个普通旧 Java 对象(POJO) ，并进一步将其传递给开发人员，以将其集成到他们现有的应用程序中。这样，我们的预测模型可以成为我们业务流程的一部分。

结论

流程的独特之处在于，用户可以通过点击整个工作流程。然而，这种点击机制还会生成一个 CoffeeScript，可以对其进行编辑和修改，并可以保存为笔记本进行共享。因此，一直以来，我们不会盲目地点击并运行，但我们知道每一个被执行的单元格背后的代码。

关于 H2O 的进一步阅读:

H2O 流程文件
戴伦·库克与 H2O 的实用机器学习
Coursera 上 H2O 的实用机器学习

互联网数据分析入门:流量分析

原文：https://towardsdatascience.com/getting-started-with-internet-data-analysis-traffic-analysis-594144ba2b52?source=collection_archive---------29-----------------------

数据分析的本质其实就是做数据对比分析。没有数据对比，往往很难用单一指标统计来发挥数据的价值。在本帖中，我将以互联网行业为背景进行数据业务分析，希望分享一些我在流量分析方面的经验。

比如我们计算公司 2018 年 1 月 29 日的同比流量。可以直接对比 2017 年 1 月 29 日的流量吗？仔细看这两个日期，会发现 2018 年 1 月 29 日是星期一，2017 年 1 月 29 日是星期天。对于很多行业的公司来说，非工作日和工作日的数据往往差别很大。这个时候，直接从日期层面去比较它们是没有意义的。选取 2017 年 1 月 30 日周一的流量数据进行对比可能更有价值。

简而言之，在互联网流量数据分析方面，有四种通用的数据分析方法。

比较和分析流量模式，调整不同时间段的企业服务和促销活动。
对比分析结构和比例，指导目标群体的营销。
对比分析异常情况，发现问题及时调整策略。
比较和跟踪活动流程的变化，总结活动的经验，以便进行后续有针对性的调整。

接下来，我们使用 FineReport 创建流量数据分析模板。然后，我们试着对数据做一些比较分析。

1.用户视图的每周分布

对于互联网公司来说，流量数据往往与工作周有关。对此，我们可以宏观计算一下周一到周日的平台总流量数据。首先，我们仔细观察工作日和非工作日的数据。我们发现周末的流量高于工作日的流量，这是互联网行业的普遍现象。

Made with FineReport

明确了用户流量的周分布后，我们就有了大致的推广方向。周末的用户群更大，所以相对于工作日，我们可以在周末投入更多的推广活动来引导新用户，维持老用户的活跃度。

然后我们思考下一步:我们如何安排工作日和周末的活动推广时间？

我们可以分析工作日和周末的用户流量趋势，我们在特定时间段进行推广，这样就可以用更低的成本获得更多的用户流入。

我们先来统计一下每个工作日的流量时间分布。我们用 FineReport 做出如下流量分布图。可以看出，工作日的流量主要集中在每天的 9:00、13:00、20:00。所以在得到用户流量规律后，我们就可以在用户活动高峰期多做产品推广，达到成本最低，吸引流量最多。

Made with FineReport

与工作日不同，周末的交通高峰在 10 点以后开始。针对周末用户流量分布的特点，互联网公司应该延迟推广时间。

Made with FineReport

2.推广渠道流量分配

互联网行业的推广渠道主要分为三种:线上渠道、线下渠道、新媒体。比较和分析每个渠道对企业的价值，制定有针对性的营销策略。

Made with FineReport

如上图所示，由于推广渠道是多层次的，我们用 FineReport 的多层饼状图来统计数据。从下图的数据可以看出，一级渠道的主要战力来自于新媒体营销。如今，像脸书和推特这样的社交媒体拥有广泛的受众和庞大的用户群。公司需要在这些渠道中投入大量的推广费用。

其次，线上渠道的效果也不容忽视。也是做好搜索引擎优化(SEO)的重要一环。相比线上渠道和新媒体营销，线下渠道需要更多的资金、时间、人力成本，受众相对较少，所以这类活动往往是针对核心粉丝而办的。

Made with FineReport

3.月度指标趋势对比

在分析月度指标的数据之前，我们先简单介绍一下互联网营销的一些常用指标:

页面视图
访问
唯一访客

我们用以上三个基本指标来衡量流量数据量。此外，平均访问深度(总浏览量/访问量)、平均在站时间(总在站时间/总浏览量)、跳出率(跳出率/访问量)都可以用来衡量流量指标的优劣。

Made with FineReport

分析上图中的流量指标可以发现，10 月份是 2017 年的流量高峰，应该和公司在节假日做的促销活动有关。浏览量、点击量和访问量分别为 4941、1290 和 2182。通过计算我们得到的跳出率为 59.12%，明显低于其他时间段的跳出率。所以可以借鉴 10 月份的促销活动。

Made with FineReport

最后，我们分析用户的访问深度(跳出率=跳出率/访问量)。我们使用 FineReport 分析企业不同时间段的 VIP 用户、老用户、新用户的统计数据。

总体来看，VIP 用户的访问深度略高于老用户和新用户，但并不太明显，说明 VIP 群体的活跃度还有待提高。同时，老用户的访问深度和新用户几乎一样。公司显然需要在用户活跃度的运营上投入更多。建议结合忠诚度较高的老用户和 VIP 用户，构建平台生态圈。并且可以对老用户和 VIP 用户实行一些优惠政策，比如有针对性的商品折扣，基于用户画像的优惠商品推送等。

好了，以上都是我的一些流量分析经验。我将继续分享互联网运营中的转化、消费和留存技巧。欢迎大家交流互联网数据分析方法。

您可能也会对…感兴趣

开始数据分析师的职业生涯需要学习哪些数据分析工具？

初学者财务报表分析指南

4 数据地图在商业分析中的应用

原载于 2019 年 7 月 16 日http://www.finereport.com。

Kaggle 入门

原文：https://towardsdatascience.com/getting-started-with-kaggle-f9138b35ae18?source=collection_archive---------15-----------------------

介绍

Kaggle 是一个了不起的社区，让有抱负的数据科学家和机器学习实践者聚集在一起，在竞争环境中解决数据科学相关的问题。许多统计学家和数据科学家在一个友好的社区中竞争，目标是为预测和分析数据集生成最佳模型。任何拥有数据集和需要解决问题的公司都可以从 Kagglers 中受益。Kaggle 不仅为数据科学项目提供了专业的设置，还为新人开发了一个学习和实践数据科学和机器学习技能的环境。

这个博客将作为对 Kaggle 平台的介绍，并简要介绍加入比赛、参与讨论、创建内核和排名的过程。

Kaggle 级数系统

Kaggle 有一个排名系统，可以帮助数据科学家跟踪他们的进展和表现。奖牌是为完成的某些活动而颁发的。当一个卡格勒获得足够多的勋章在升级系统中上升一级时，他们就会升级！

Kaggle 排名可以来自三个不同的“专业类别”:竞赛、内核和讨论。

三类各有五个等级:新手、贡献者、高手、高手、特级大师。Kaggle 的大部分用户被认为是“新手”，这实质上意味着他们没有与社区互动，没有运行任何脚本或提交任何比赛。新手级别以上的每个用户都提交过数据，并使用数据集进行预测和分析。

给聪明人一句话，向 Kaggle 上的每个人学习，尤其是那些排名较高的人！Kaggle 取得巨大成功的原因之一是其学习友好的环境和学习新技能的便利性。观看关于数据科学技术的视频教程是一个很好的开始，但是没有什么比通读一位经验丰富的数据科学家的内核和解释，然后在自己的模型中使用您学到的技能更有价值的了。

讨论板

讨论板是一个提问、回答问题和与社区互动的好地方。总有一些人贴出我们可以借鉴的伟大问题的答案。还有一个“入门”论坛，供想要学习 Kaggle 平台背后的基础知识的新 ka ggler 们使用。Kaggle 在讨论板中提供了六个独特的论坛，每个论坛都有不同的目的。

数据集

你需要任何种类的数据用于 T2 科学项目。Kaggle 在其“数据集”选项卡中提供了大量可用的数据集。截至这篇博客发表时，已经有超过 17，730 个公开的数据集。可以通过多个过滤器对数据集进行排序，以准确找到您要查找的内容。一旦你找到你想要的数据集，你只需点击它，然后点击“下载”将数据下载到你的机器上。

开始你的第一场比赛！

在 Kaggle 的“竞赛”标签下，有许多你可以参加的竞赛。这就像“数据集”选项卡，在这里您可以单击竞争对手并为您的模型下载数据。有一些比赛是专为初学者设计的，目的是让他们进入并学习 Kaggle 和数据科学的基础知识。其中一个初学者友好竞赛是著名的 MNSIT 数据集，我们将在其中创建一个模型，该模型将对手写数字进行分类，并根据测试数据进行预测。这篇博文将使用 MNIST 数据集，也将向竞赛提交预测。我们需要做的第一件事是查看我们的数据，并开始考虑建立我们的模型。首先，我们可以启动一个新的内核。

核心

根据 Kaggle 的文档，内核是云计算环境，支持可重复和协作的分析。内核允许 Kaggler 在浏览器中创建和运行代码，而不需要在他们的机器上下载 Python 和包。Kaggle 提供的一种内核是笔记本。如果你熟悉 Jupyter 笔记本，那么你熟悉 Kaggle 的笔记本，因为它们是一回事！

我们需要创建我们的内核，为此，我们可以点击“创建内核”并选择“笔记本”选项，在 Jupyter 笔记本中进行分析。笔记本打开后，你会注意到一些预先写好的代码，称为“启动代码”。Starter 代码将导入一些公共库，并将打印数据文件夹中的目录。对于这个博客，我们将删除起始代码，自己编写我们的导入。在第一个笔记本单元格中，我们将为我们的项目编写所有必要的导入，并将打印出我们下载的“digit_data”文件夹中的所有内容。

import matplotlib.pyplot **as** plt
import seaborn **as** sns
import numpy **as** np
import pandas **as** pd
import os**print**(os**.**listdir('digit_data'))

输出:

['test.csv', 'train.csv', 'sample_submission.csv']

下一步包括将我们的数据加载到笔记本中。请注意，我们的数据文件夹为我们提供了一个训练和测试文件。我们可以使用 pandas，一个数据分析 Python 库，将 CSV 文件读入我们的训练和测试数据帧。

train **=** pd**.**read_csv('digit_data/train.csv')
test **=** pd**.**read_csv('digit_data/test.csv')

一旦我们加载了我们的数据，我们将想要了解数据是什么。为了对我们的数据集中的内容有一个简要的概述，我们可以使用 panda 的.head()方法来打印出我们的数据集的头，或者顶部。我们可以将显示的行数设置为 5。

train**.**head(5)

5 rows × 785 columns

我们必须对训练数据做的第一件事是将它分成输入，或 X(特征)和输出(y)。通过查看我们的数据，我们可以看到输出(y)是“标签”列。这意味着我们的 X 数据将是除“标签”列之外的每一列，而 y 数据将只是“标签”列。要分开它们，我们可以使用 pandas 的.drop()方法，并给出我们想要删除的列的名称。为了让熊猫知道我们想要删除一个列，我们将“axis”设置为 1。

在分割我们的训练数据后，我们可以打印出目前为止所有东西的形状。在打印形状之后，我们还可以打印测试和训练数据中的样本。训练数据的形状将会是(42000，784)。这意味着有 42000 行，784 列。每行代表数据中的一个数字。每列代表图像的一个像素值。我们在 MNIST 数据集中的图像应该具有 28x28 (28 x 28 = 784)的形状。每个图像被展平成一行。

x_train **=** train**.**drop('label', axis**=**1)
y_train **=** train['label']**.**astype('int32')**print**('x_train shape: ', x_train**.**shape)
**print**('y_train shape: ', y_train**.**shape)
**print**('test shape: ', test**.**shape)
**print**('\nsamples in test: ', test**.**shape[0])
**print**('samples in train: ', x_train**.**shape[0])

输出:

x_train shape:  (42000, 784)
y_train shape:  (42000,)
test shape:  (28000, 784)samples in test:  28000
samples in train:  42000

让我们找出每个数字有多少个样本。据我们所知，我们的数据可能是不平衡的，一些数字可能比其他数字显示得更多。这可能会妨碍我们的训练！为了检查我们训练的每个数字有多少个样本，我们可以再次使用 pandas 并在 y 训练集上使用value_counts()方法。

**print**('Number of Examples Per Digit:\n', y_train**.**value_counts())

输出:

Number of Examples Per Digit:
1    4684
7    4401
3    4351
9    4188
2    4177
6    4137
0    4132
4    4072
8    4063
5    3795
Name: label, dtype: int64

另一个令人惊叹的高级 Python 库是 Seaborn，它在数据科学中被大量用于可视化。Seaborn 是一个数据可视化库，它在很大程度上基于 matplotlib，但众所周知它可以制作更有吸引力的图形。由于我们喜欢吸引力，我们将与 Seaborn 合作，可视化我们在训练集中有多少每个数字的样本。在可视化了数据中的平衡并使用 pandas 查看了样本的准确数量后，我们可以自信地说我们的数据非常平衡，没有数字被过度表示。

sns**.**countplot(y_train)

MNIST 数据集中的每个手写数字都包含 RGB 值在 0–255 之间的像素。为了标准化这个范围的值，我们可以将每个像素值除以 255。这将使每个像素值更接近(在 0-1 范围内)，并使我们的神经网络更容易学习。例如，RGB 值 56 将变成. 219，RGB 值 230 将变成. 901。

然后，我们可以对 x_train 和测试集中的值进行整形。我们希望对它们进行整形，首先是样本数，然后如前所述，每个数字的尺寸为(28x28x1)或 28 行、28 列和 1 个颜色通道，因为图像没有颜色。

x_train **/=** 255.0
test **/=** 255.0x_train **=** x_train**.**values**.**reshape(x_train**.**shape[0], 28, 28, 1)
test **=** test**.**values**.**reshape(test**.**shape[0], 28, 28, 1)

现在我们可以打印训练和测试数据的最终形状。

**print**('x_train shape: ', x_train**.**shape)
**print**('y_train shape: ', y_train**.**shape)
**print**('test shape: ', test**.**shape)

输出:

x_train shape:  (42000, 28, 28, 1)
y_train shape:  (42000,)
test shape:  (28000, 28, 28, 1)

要查看 MNIST 数据集包含的内容，我们可以使用 matplotlib 中的 pyplot 并显示八幅图像。图像将来自训练集(x_train ),在每个图像之上，我们可以将子情节标题设置为相应的输出(y_train)。

plt**.**figure(figsize**=**(12,10))**for** img **in** range(10):
    plt**.**subplot(5, 5, img**+**1)
    plt**.**imshow(x_train[img]**.**reshape((28, 28)), cmap**=**'binary_r')
    plt**.**axis('off')
    plt**.**title('Label: ' **+** y_train[img]**.**astype('str'))plt**.**show()

现在我们可以开始创建我们的模型了。为了对每个数字进行分类，我们将使用卷积神经网络。幸运的是，Keras 是一个高级 Python 神经网络库，提供了一个简单快捷的资源来建立深度学习模型。我们将不得不导入 Keras，顺序模型和在 CNN 中使用的必要层。

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D
from keras.utils import to_categoricalfrom sklearn.model_selection import train_test_split

我们可以使用 Keras' to_categorical()函数将我们的类向量转换成一个二进制类矩阵。我们在 y_train 的班级被标注为 1，2，3，4 等。to_categorical()将创建一个列数与类别数相同的矩阵，其中 1 表示“是”，0 表示“否”。Keras 的文档给出了一个直观的例子。你可以在这里查看 Keras 的文件或者看下面的例子:

# Consider an array of 5 labels out of a set of 3 classes {0, 1, 2}:
> labels
array([0, 2, 1, 2, 0])
# `to_categorical` converts this into a matrix with as many
# columns as there are classes. The number of rows
# stays the same.
> to_categorical(labels)
array([[ 1.,  0.,  0.],
       [ 0.,  0.,  1.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.],
       [ 1.,  0.,  0.]], dtype=float32)

一旦完成，我们的数据就可以进行训练了！我们可以将数据分成训练集和测试集，然后开始训练我们的模型。

y_train **=** to_categorical(y_train, 10)
x_train, x_test, y_train, y_test **=** train_test_split(x_train, y_train, test_size **=** 0.1, random_state**=**1)

现在，我们可以创建我们的 CNN 模型，这多亏了 Keras，非常容易。我们将需要使用二维卷积层、最大池层和密集层，它们是完全连接的层。我们也将使用 dropout 和 flatten。展平我们的数据从卷积层和池层获得结果矩阵，并将其“展平”成一个长的输入数据向量(列)。我们的输出层将使用带有 10 个输出节点的 softmax 激活函数(数据中的类的数量)。

model **=** Sequential()
model**.**add(Conv2D(32, kernel_size**=**(3, 3), activation**=**'relu', input_shape**=**(28,28,1)))
model**.**add(Conv2D(64, (3, 3), activation**=**'relu'))model**.**add(MaxPooling2D(pool_size**=**(2, 2)))model**.**add(Dropout(0.25))model**.**add(Conv2D(64, (3, 3), activation**=**'relu'))
model**.**add(Conv2D(128, (3, 3), activation**=**'relu'))model**.**add(Dropout(0.25))model**.**add(Flatten())
model**.**add(Dense(128, activation**=**'relu'))
model**.**add(Dropout(0.5))
model**.**add(Dense(10, activation**=**'softmax'))

在我们训练模型之前，我们必须首先定义损失函数、优化器以及评估模型的指标。

model**.**compile(loss**=**'categorical_crossentropy', optimizer**=**'Adadelta', metrics**=**['accuracy'])

现在我们终于可以训练我们的模型了！我们将给.fit()函数我们的训练数据，并让它运行 12 个时期或迭代。

model**.**fit(x_train, y_train, batch_size**=**128, epochs**=**12, verbose**=**1,
          validation_data**=**(x_test, y_test))

输出:

Train on 37800 samples, validate on 4200 samples
Epoch 1/12
37800/37800 [==============================] - 144s 4ms/step - loss: 0.3357 - acc: 0.8946 - val_loss: 0.1302 - val_acc: 0.9610
Epoch 2/12
37800/37800 [==============================] - 154s 4ms/step - loss: 0.0894 - acc: 0.9738 - val_loss: 0.0518 - val_acc: 0.9848
Epoch 3/12
37800/37800 [==============================] - 145s 4ms/step - loss: 0.0623 - acc: 0.9818 - val_loss: 0.0398 - val_acc: 0.9879
Epoch 4/12
37800/37800 [==============================] - 142s 4ms/step - loss: 0.0481 - acc: 0.9858 - val_loss: 0.0426 - val_acc: 0.9860
Epoch 5/12
37800/37800 [==============================] - 145s 4ms/step - loss: 0.0398 - acc: 0.9872 - val_loss: 0.0358 - val_acc: 0.9898
Epoch 6/12
37800/37800 [==============================] - 134s 4ms/step - loss: 0.0350 - acc: 0.9891 - val_loss: 0.0305 - val_acc: 0.9907
Epoch 7/12
37800/37800 [==============================] - 144s 4ms/step - loss: 0.0302 - acc: 0.9911 - val_loss: 0.0275 - val_acc: 0.9917
Epoch 8/12
37800/37800 [==============================] - 133s 4ms/step - loss: 0.0269 - acc: 0.9918 - val_loss: 0.0292 - val_acc: 0.9910
Epoch 9/12
37800/37800 [==============================] - 140s 4ms/step - loss: 0.0225 - acc: 0.9929 - val_loss: 0.0400 - val_acc: 0.9886
Epoch 10/12
37800/37800 [==============================] - 132s 3ms/step - loss: 0.0215 - acc: 0.9933 - val_loss: 0.0330 - val_acc: 0.9914
Epoch 11/12
37800/37800 [==============================] - 133s 4ms/step - loss: 0.0191 - acc: 0.9938 - val_loss: 0.0304 - val_acc: 0.9910
Epoch 12/12
37800/37800 [==============================] - 155s 4ms/step - loss: 0.0183 - acc: 0.9943 - val_loss: 0.0314 - val_acc: 0.9921<keras.callbacks.History at 0x1a30906ac8>

看起来我们的模特干得不错！我们可以对模型进行评估，并获得训练集和测试集的损失和准确性。一旦我们收到损失和准确性，我们可以打印出来，并四舍五入为简单。

loss, accuracy **=** model**.**evaluate(x_test, y_test, verbose**=**0)
train_stat **=** model**.**evaluate(x_train, y_train, verbose**=**0)**print**('Train Loss:     ', round(train_stat[0], 5))
**print**('Train Accuracy: ', round(train_stat[1]*****100, 4), '%')
**print**('Test Loss:      ', round(loss, 5))
**print**('Test Accuracy:  ', round(accuracy*****100, 4), '%')

输出:

Train Loss:      0.00551
Train Accuracy:  99.8413 %
Test Loss:       0.03136
Test Accuracy:   99.2143 %

由于我们的模型经过了训练，并且已经证明相当准确，我们可以开始进行预测。我们将使用 Keras' .predict()方法来预测 x_test 数据中每个数字的输出。

predictions **=** model**.**predict(x_test)

因为我们正在 Kaggle 中为一个比赛创建一个内核，我们将需要创建一个新的包含我们预测的 CSV 文件。这个文件将是我们提交给比赛，一旦它被创建，我们就完成了比赛！

results **=** np**.**argmax(predictions, axis **=** 1)results **=** pd**.**Series(results, name**=**"Label")submission **=** pd**.**concat([pd**.**Series(range(1,28001),name **=** "ImageId"),results],axis **=** 1)submission**.**to_csv("submission.csv", index**=**False)

Kaggler 提供了一个很好的平台来学习和应用你所获得的知识和技能到真实的比赛和数据集中。有大量的数据集可供选择，每场比赛都有一个非常友好的社区来帮助你。我会推荐报名 Kaggle，试试看！

自然语言处理(NLP)入门—预处理、单词嵌入、文本分类等等！

原文：https://towardsdatascience.com/getting-started-with-natural-language-processing-nlp-2c482420cc05?source=collection_archive---------8-----------------------

使用简单的 Python 库

source

如今自然语言处理领域发生了太多的事情(GRUs、LSTMs、XLNet、BERT 等等！).弄清楚从哪里开始可能会令人困惑。本文讨论了自然语言处理的基础知识，包括数据清理、规范化、编码、情感分析和一个简单的文本分类器，它使用了基本而强大的 Python 库。这往往是潜入复杂的深度学习模型之前的第一步。

数据清理和规范化

根据问题的性质，这一步可能需要，也可能不需要。如果我们的模型试图最大程度地学习语言，那么最好使用其原始格式的数据，事实上，现代深度学习技术建议不要删除停用词、表情符号或小写字母，因为它们提供了额外的上下文。然而，如果你试图基于某些单词的出现进行趋势分析或分类(就像在一个单词袋模型中)，这有助于执行这个步骤。这里我想强调几个常见的预处理步骤:

去除标点:在尝试训练一个机器学习模型时，通过去除标点有助于减少过拟合(比如！、*等。).但是，注意不要去掉一些重要的东西，比如问号(？)有助于认识问题。
移除表情符号:有时人们会将表情符号附加在不带空格的单词上(例如:you❤)，这样就很难理解这些单词。移除表情符号有助于解决这种情况。同样，在删除这些表情符号时要小心，因为表情符号实际上可能对情感分析和主题分类等任务非常有用。
删除停用词:对于数据探索和趋势分析这样的任务，看到“the”、“and”、“of”等常用词可能不是很有用。这个sklearn包实际上有一个常用英语停用词的集合，我们可以用它来移除这些停用词。
使所有文本小写:这是规范化文本最简单的方法。(毕竟，BeTTer和better确实有相同的语义含义)
词干化:另一种规范化的方法是用词根形式替换派生的词(例如:‘posting’，‘posted’，‘posts’都用‘post’替换)。为了阻止单词，我们使用由nltk.提供的[PorterStemmer](https://tartarus.org/martin/PorterStemmer/) util
提取/移除标签和提及:标签和提及对于识别数据趋势非常有用。这有助于将它们从你的文本中提取出来，并分别进行分析。

这里有一个简单的函数来执行上述任务:

词汇向量——它们是什么？

机器学习算法只能处理固定长度的数字输入，也就是说，它们不能接受字符串输入来处理文本数据！这就是单词向量的用武之地，我们用固定长度的向量来表示每个单词。然后使用单个单词向量对句子进行编码。

一键编码:

这是最简单的单词编码方式。它假设一个单词包表示法，其中每个单词被视为一个独立的实体，单词关系被忽略(例如，job和occupation被视为完全独立的单词，尽管它们实际上具有相同的含义)。该方法包括从整个语料库中创建不同单词的词汇表，该词汇表的长度是每个单词向量的长度。每个向量在单词向量中都有一个指定的索引，该索引被标记为1，而其他的被标记为0以表示特定的单词。

例如:

这里的词汇表由 9 个不同的单词组成，这些单词可以被编码成长度为 9 的向量。单词向量表示有going:【1，0，0，0，0，0，0，0】good:【0，1，0，0，0，0，0，0，0】等等..

使用这种表示，文本Tomorrow will be a good day可以编码成:[0，1，1，0，1，1，0，1，0]。注意单词will是如何被忽略的，因为它根本不存在于词汇表中。拥有一个好的和广泛的词汇是使这个模型工作良好的必要条件。还要注意单词关系(出现的顺序，语义关系)在这个表示中是如何被完全忽略的。

Word2Vec 单词嵌入:

这种单词编码方法(通常称为单词嵌入)考虑了上下文。例如，我们可以预期单词king和royal比parrot 和honey具有更小的空间距离。Word2vec 使用浅层两层神经网络来执行特定任务(基于所使用的方法)，并为每个单词学习隐藏层的权重。这些学习的隐藏层权重被用作我们的最终单词向量。可以阅读原文深入了解这些词向量是如何获得的。但是在高层次上，这是使用 Word2Vec 获得基于上下文的单词向量的两种常用方法:

CBOW(连续字袋):

source : https://arxiv.org/pdf/1301.3781.pdf

CBOW 模型架构试图基于源上下文单词(周围单词)来预测当前目标单词(中心单词)。

Skip — Gram 模型:

source: https://arxiv.org/pdf/1301.3781.pdf

Skip-gram 模型体系结构试图实现与 CBOW 模型相反的功能。它试图在给定目标单词(中心单词)的情况下预测源上下文单词(周围的单词)。

在这两种情况下，窗口大小(每边考虑的周围单词的数量)都是一个超参数。

手套:

Glove 与 Word2vec 非常相似，但与 Word2vec 不同，Glove 利用了单词的全局共现，而不仅仅是局部上下文，这使得它在某些方面更加强大。还是那句话，通读原文可以更好的理解。

单词嵌入——我如何使用它们？

既然我们对什么是单词嵌入以及为什么它们有用有了一个大致的概念，那么让我们来谈谈如何利用它们。

使用预先训练的单词向量:

有许多公开可用的不同向量长度的预训练词向量，如 Glove 、 fasttext 等。这些已经在大规模语料库(维基百科，twitter 和常见的爬行数据集)上进行训练，可以下载并用于在我们的语料库中编码单词。

示例:使用词向量相似度找到与给定文档最相似的文档

问题陈述:

给定一组属于不同主题的文档(训练集)，当给定一个新文档时，我们能从原始集中找到与之最相似的文档吗？

方法:

将预先训练好的单词向量文件加载到字典中，以单词为键，以其向量表示为值。
通过对特定文档中存在的单词的单词向量进行平均，找到训练集中每个文档的质心向量(忽略不属于词汇表的单词)
找到新文档的质心，从训练集中挑选其质心最接近新文档质心的文档(使用合适的相似性度量，如欧几里德距离、余弦相似性等。)

代码:

以下是一些辅助函数加载手套字典，找到质心，并找到质心之间的距离:

从头开始生成单词向量的训练:

如果您想为您的特定语料库找到单词向量，您可以使用gensim包进行训练。

举例:

代码:

输出:

在上面的例子中，我刚刚使用了来自维基百科页面的两行文字。训练非常快速和简单，所有你需要输入的是单词列表、你需要的单词向量的大小、窗口大小(要考虑的周围单词的数量)以及要被认为是词汇表的一部分的单词的最小出现次数。检查词汇、获取向量以及查看语料库中最常见的单词都很容易。当然，从头开始训练可能不会总是产生与预训练一样好的结果，但它对于涉及看起来与预训练中使用的数据集非常不同的数据的问题是有益的。

数据探索

带有文本数据的 EDA 不像表格或数字数据那样简单。然而，有一些库可以使这些任务变得更容易。在本文的其余部分，我使用了来自 Kaggle 的以下数据集:

[## 有毒评论分类挑战

识别和分类有毒的在线评论

www.kaggle.com](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge/data)

使用空间探索:

Spacy 是一个非常强大的 NLP 库，有多种用途。它可以用于命名实体识别，识别一个词所属的词性，甚至给出词的向量和情感。

代码:

输出:

来自spacy的nlp函数将每个单词转换成一个具有各种属性的令牌，就像上面例子中提到的那样。

Wordcloud:

单词云是一种简单而有趣的方式，可以直观地显示各种单词在我们的语料库中出现的频率。让我们以评论数据中出现频率最高的名词为例:

代码:

输出:

article, talk, and page are the most frequently occurring nouns

情感分析

在自然语言处理中，一个非常常见的任务是识别一个特定的评论或一段文本是积极的还是消极的。vaderSentiment包提供了一种快速简单的方法来实现这一点:

代码:

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
sentiment_analyzer = SentimentIntensityAnalyzer()def get_sentiment_score(text):
    return sentiment_analyzer.polarity_scores(text)['compound']

输出:

The sentiment score for a toxic comment seems to be close to -1 whereas a non-toxic one has a score greater than 0 as expected

文本分类

对于分类，我用过的最简单的库之一是fasttext。它由脸书于 2016 年发布，使用了这种线性技术，既可以将单词向量组合成代表文本的向量，也可以计算分类标准。它只需要很少的时间训练，并给出了最常见的文本分类问题体面的结果。它可以用来提出一个基线模型。你可以阅读原文来更好的理解fasttext分类器背后的机制。

这是我如何使用[fasttext](https://fasttext.cc/docs/en/supervised-tutorial.html)来分类有毒和无毒评论:

[## 有毒评论分类器

使用 jovian.ml 共享](https://jovian.ml/aakanksha-ns/toxic-comments)

我们已经触及了大部分基础知识，但是当然，NLP 还有很多内容。然而，这篇文章是一个很好的起点，希望对初学者有所帮助，因为这些是我刚开始时学到的第一件事！

自然语言处理入门:美国航空公司情感分析

原文：https://towardsdatascience.com/getting-started-with-natural-language-processing-us-airline-sentiment-analysis-24f9d8f7500d?source=collection_archive---------19-----------------------

部分

自然语言处理简介
数据集探索
自然语言处理
培养
超参数优化
未来学习的资源

自然语言处理简介

自然语言处理(NLP)是机器学习的一个子领域，涉及处理和分析自然语言数据，通常以文本或音频的形式。NLP 中的一些常见挑战包括语音识别、文本生成和情感分析，而一些部署 NLP 模型的高调产品包括苹果的 Siri、亚马逊的 Alexa 和许多可能会在线互动的聊天机器人。

为了开始学习 NLP 并介绍该领域的一些核心概念，我们将使用流行的 Twitter 美国航空公司情绪数据集建立一个模型，试图预测与美国航空公司相关的推文的情绪(积极、中立或消极)。

代码片段将包含在这篇文章中，但是对于完全可复制的笔记本和脚本，请在其 Comet project 页面上查看与该项目相关的所有笔记本和脚本。

数据集探索

让我们从导入一些库开始。确保安装慧星用于实验管理、可视化、代码跟踪和超参数优化。

# Comet
from comet_ml import Experiment

几个标准包:pandas，numpy，matplotlib 等。

# Standard packages
import os
import pickle
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Nltk 用于自然语言处理功能:

# nltk
import nltk
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem.snowball import SnowballStemmer

机器学习模型的 Sklearn 和 keras :

# sklearn for preprocessing and machine learning modelsfrom sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import accuracy_score
from sklearn.utils import shuffle
from sklearn.preprocessing import OneHotEncoder
from sklearn.feature_extraction.text import TfidfVectorizer# Keras for neural networks
from keras.models import Sequential
from keras.layers import Dense, Dropout, BatchNormalization, Flatten
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
from keras.utils import to_categorical
from keras.callbacks import EarlyStopping

现在我们将加载数据:

raw_df = pd.read_csv('twitter-airline-sentiment/Tweets.csv')

让我们检查数据帧的形状:

raw_df.shape()
>>> (14640, 15)

所以我们有 14640 个样本(推文)，每个样本有 15 个特征。让我们来看看这个数据集包含哪些要素。

raw_df.columns

'tweet_id'、'airline_sentiment'、'airline_sentiment_confidence'、'negativereason'、'negativereason_confidence'、'airline'、'airline_sentiment_gold'、'name'、'negativereason_gold'、'retweet_count'、'text'、'tweet_coord'、'tweet_created'、'tweet_location'、'user_timezone'

让我们也来看看每个航空公司的航空公司情绪(代码可以在彗星上找到):

# Create a Comet experiment to start tracking our workexperiment = Experiment(
    api_key='<HIDDEN>', 
    project_name='nlp-airline', 
    workspace='demo')experiment.add_tag('plotting')airlines= ['US Airways', 
           'United', 
           'American', 
           'Southwest', 
           'Delta', 
           'Virgin America']**for** i **in** airlines: indices = airlines.index(i)
     new_df=raw_df[raw_df['airline']==i]
     count=new_df['airline_sentiment'].value_counts()
     experiment.log_metric('{} negative'.format(i), count[0])
     experiment.log_metric('{} neutral'.format(i), count[1])
     experiment.log_metric('{} positive'.format(i), count[2])
experiment.end()

每家航空公司的负面推文都比中性或正面推文多，维珍美国航空公司在所有美国航空公司中获得了最平衡的正面、中性和负面传播。虽然在这篇文章中我们将重点放在特定于 NLP 的分析上，但是也有更深入的特性工程和探索性数据分析的极好来源。Kaggle 内核这里的和这里的在分析与情绪相关的受众和推文长度等特征时特别有指导意义。

让我们创建一个只有tweet_id、text和airline_sentiment特性的新数据帧。

df = raw_df[['tweet_id', 'text', 'airline_sentiment']]

现在让我们来看看一些推文本身。数据是什么样的？

df['text'][1]> "[@VirginAmerica](http://twitter.com/VirginAmerica) plus you've added commercials to the experience... tacky."df['text'][750]> "[@united](http://twitter.com/united) you are offering us 8 rooms for 32 people #FAIL"df['text'][5800]> "[@SouthwestAir](http://twitter.com/SouthwestAir) Your #Android Wi-Fi experience is terrible! $8 is a ripoff! I can't get to [@NASCAR](http://twitter.com/NASCAR) or MRN for [@DISupdates](http://twitter.com/DISupdates) #BudweiserDuels"

接下来，我们将执行一些标准的 NLP 预处理技术，为训练准备好数据集。

自然语言处理

为了构建自然语言处理模型，必须进行一些基本的文本预处理步骤，以便将文本从人类语言转换成机器可读的格式，以便进一步处理。这里我们将介绍一些标准实践:标记化、停用词移除和词干化。你可以参考这篇文章来学习额外的文本预处理技术。

标记化

给定一个字符序列和一个已定义的文档单元，标记化就是将它分割成称为标记的离散片段的任务。在分割文本的过程中，标记化通常还包括丢弃某些字符，比如标点符号。

将记号简单地认为是单词是简单的(并且经常是有用的),但是为了更好地理解 NLP 记号化的特定术语，斯坦福大学 NLP 小组的概述非常有用。

NLTK 库有一个内置的标记器，我们将使用它来标记美国航空公司的推文。

from nltk.tokenize import word_tokenizedef tokenize(sentence):
    tokenized_sentence = word_tokenize(sentence)
    return tokenized_sentence

停用词删除

有时，可能对确定文档的语义质量没有什么价值的常用词被完全排除在词汇表之外。这些被称为停止字。确定停用词列表的一般策略是根据收集频率(每个术语在文档中出现的总次数)对术语进行排序，然后过滤出最频繁的术语作为停用词列表——根据语义内容进行手动过滤。

NLTK 有一个标准的停用词表，我们将在这里采用。

from nltk.corpus import stopwords
class PreProcessor:
    def __init__(self, df, column_name):
        self.stopwords = set(stopwords.words('english')) def remove_stopwords(self, sentence):
        filtered_sentence = []
        for w in sentence:
            if ((w not in self.stopwords) and 
                (len(w) > 1) and 
                (w[:2] != '//') and 
                (w != 'https')):
                filtered_sentence.append(w)
        return filtered_sentenceStemming

出于语法目的，文档使用不同形式的单词(看，看，看，看，看),这些单词在许多情况下具有非常相似的语义特征。词干化是一个粗略的过程，通过这个过程，一个单词的变体或相关形式被简化(词干化)为一个常见的基本形式。因为词干化是从单词中移除前缀或后缀字母，所以输出可能是也可能不是属于语言语料库的单词。词汇化是一个更精确的过程，通过这个过程，单词被适当地简化为它们所来自的基本单词。

示例:

词干 :汽车，汽车，汽车的，汽车的’变成汽车

单义化 : am，are is 成为 be

词干化单句 :“男孩的汽车是不同颜色的”变成了“男孩的汽车是不同颜色的”

最常见的英文文本词干算法是【波特算法】(TO DO)。 Snowball ，一种用于词干算法的语言，由 Porter 在 2001 年开发，是其 SnowballStemmer 的 NLTK 实现的基础，我们将在这里使用它。

from nltk.stem.snowball import SnowballStemmer
class PreProcessor:

    def __init__(self, df, column_name):
        self.stemmer = SnowballStemmer('english') def stem(self, sentence):
        return [self.stemmer.stem(word) for word in sentence]

这些预处理步骤的代码可以在 Comet 上找到。

接下来，我们将创建一个预处理器对象，包含每个步骤的方法，并在我们的数据框的text列上运行它，以对 tweets 进行分词、词干提取和删除停用词。

preprocessor = PreProcessor(df, 'text')
df['cleaned text'] = preprocessor.full_preprocess()

现在，我们将把数据分成训练集、验证集和测试集。

df = shuffle(df, random_state=seed)*# Keep 1000 samples of the data as test set*test_set = df[:1000]*# Get training and validation data*X_train, X_val, y_train, y_val = train_test_split(df['cleaned_text'][1000:], df['airline_sentiment'][1000:], test_size=0.2, random_state=seed)*# Get sentiment labels for test set*y_test = test_set['airline_sentiment']

既然我们已经将数据分成了训练集、验证集和测试集，我们将对它们进行 TF-IDF 矢量化处理

TF-IDF 矢量化

TFIDF，或词频——逆文档频率，是一种数字统计，反映了一个词对集合或语料库中的文档有多重要。它通常用于产生与单词相关联的权重，这些权重在信息检索或文本挖掘的搜索中是有用的。单词的 tf-idf 值与单词在文档中出现的次数成比例地增加，并被包含该单词的语料库中的文档数量所抵消。这种偏移有助于调整某些词通常出现得更频繁的事实(想想看，如果没有偏移，像' a '，' the '，' to '这样的停用词可能会有非常高的 tf-idf 值)。

Source: https://becominghuman.ai/word-vectorizing-and-statistical-meaning-of-tf-idf-d45f3142be63

我们将使用 scikit-learn 实现的 TfidfVectorizer ，它将一组原始文档(我们的 twitter 数据集)转换成一个 TF-IDF 特性矩阵。

vectorizer = TfidVectorizer()
X_train = vectorizer.fit_transform(X_train)
X_val = vectorizer.transform(X_val)
X_test = vectorizer.transform(test_set['cleaned_text'])

培养

我们准备开始训练我们的模型。我们要做的第一件事是创建一个彗星实验对象:

experiment = Experiment(api_key='your-personal-key', project_name='nlp-airline', workspace='demo')

接下来，我们将使用 keras 构建一个光梯度增强分类器(LGBM) 、一个 XGBoost 分类器和一个相对简单的神经网络，并比较这些模型的性能。通常，如果不进行测试，很难判断哪种架构的性能最好。Comet 的项目级视图有助于轻松比较不同实验的执行情况，并让您轻松地从模型选择转移到模型调整。

LGBM

# sklearn's Gradient Boosting Classifier (GBM)gbm = GradientBoostingClassifier(n_estimators=200, max_depth=6, random_state=seed)gbm.fit(X_train, y_train)# Check resultstrain_pred = gbm.predict(X_train)val_pred = gbm.predict(X_val)val_accuracy = round(accuracy_score(y_val,val_pred), 4)train_accuracy = round(accuracy_score(y_train, train_pred), 4)# log to cometexperiment.log_metric('val_acc', val_accuracy)experiment.log_metric('Accuracy', train_accuracy)XGBOOST

XGBoost

xgb_params = {'objective' : 'multi:softmax',
    'eval_metric' : 'mlogloss', 'eta' : 0.1, 'max_depth' : 6, 'num_class' : 3, 'lambda' : 0.8, 'estimators' : 200, 'seed' : seed}target_train = y_train.astype('category').cat.codestarget_val = y_val.astype('category').cat.codes# Transform data into a matrix so that we can use XGBoostd_train = xgb.DMatrix(X_train, label = target_train)d_val = xgb.DMatrix(X_val, label = target_val)# Fit XGBoostwatchlist = [(d_train, 'train'), (d_val, 'validation')]bst = xgb.train(xgb_params, d_train, 400, watchlist, early_stopping_rounds = 50, verbose_eval = 0)# Check results for XGBoosttrain_pred = bst.predict(d_train)val_pred = bst.predict(d_val)experiment.log_metric('val_acc', round(accuracy_score(target_val, val_pred)*100, 4))experiment.log_metric('Accuracy', round(accuracy_score(target_train, train_pred)*100, 4))

神经网络

*# Generator so we can easily feed batches of data to the neural network***def** **batch_generator**(X, y, batch_size, shuffle):
    number_of_batches = X.shape[0]/batch_size
    counter = 0
    sample_index = np.arange(X.shape[0])

    **if** shuffle:
        np.random.shuffle(sample_index)
    **while** True:
        batch_index = sample_index[batch_size*counter:batch_size*(counter+1)]
        X_batch = X[batch_index,:].toarray()
        y_batch = y[batch_index]
        counter += 1 **yield** X_batch, y_batch
        **if** (counter == number_of_batches):
            **if** shuffle:
                np.random.shuffle(sample_index)
            counter = 0*# Initialize sklearn's one-hot encoder class*onehot_encoder = OneHotEncoder(sparse=False)
integer_encoded_train = np.array(y_train).reshape(len(y_train), 1)
onehot_encoded_train = onehot_encoder.fit_transform(integer_encoded_train)
integer_encoded_val = np.array(y_val).reshape(len(y_val), 1)
onehot_encoded_val = onehot_encoder.fit_transform(integer_encoded_val)
experiment.add_tag('NN')*# Neural network architecture*initializer = keras.initializers.he_normal(seed=seed)
activation = keras.activations.elu
optimizer = keras.optimizers.Adam(lr=0.0002, beta_1=0.9, beta_2=0.999, epsilon=1e-8)
es = EarlyStopping(monitor='val_acc', mode='max', verbose=1, patience=4)*# Build model architecture*model = Sequential()
model.add(Dense(20, activation=activation, kernel_initializer=initializer, input_dim=X_train.shape[1]))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax', kernel_initializer=initializer))
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])*# Hyperparameters*epochs = 15
batch_size = 32*# Fit the model using the batch_generator*hist = model.fit_generator(generator=batch_generator(X_train, onehot_encoded_train, batch_size=batch_size, shuffle=True), epochs=epochs, validation_data=(X_val, onehot_encoded_val), steps_per_epoch=X_train.shape[0]/batch_size, callbacks=[es])

使用 Comet 的 project view 比较我们的模型，我们可以看到我们的神经网络模型比 XGBoost 和 LGBM 实验表现出了相当大的优势。

Comet Experiment List View

现在让我们选择神经网络架构，并对其进行微调。注意，因为我们已经存储了我们所有的实验——包括我们现在不打算使用的 XGBoost 和 LGBM 运行——如果我们决定在未来重新访问这些架构，我们所要做的就是在 Comet 项目页面中查看这些实验，我们将能够立即重现它们。

超参数优化

既然我们已经从 XGBoost、LGBM 和神经网络的简单 keras 实现的初始搜索中选择了我们的架构，我们将需要进行超参数优化来微调我们的模型。对于复杂的建模任务来说，超参数优化可能是一个极其困难、计算量大且缓慢的过程。Comet 已经建立了一个优化服务，可以为你进行这种搜索。只需传入您想要扫描超参数空间的算法、要搜索的超参数和范围，以及最小化或最大化的度量，Comet 可以为您处理建模过程的这一部分。

from comet_ml import Optimizer
config = {
    "algorithm": "bayes",
    "parameters": {
        "batch_size": {"type": "integer", "min": 16, "max": 128},
        "dropout": {"type": "float", "min": 0.1, "max": 0.5},
        "lr": {"type": "float", "min": 0.0001, "max": 0.001},
    },
    "spec": {
        "metric": "loss",
        "objective": "minimize",
    },
}
opt = Optimizer(config, api_key="<HIDDEN>", project_name="nlp-airline", workspace="demo")
for experiment in opt.get_experiments():
    experiment.add_tag('LR-Optimizer') # Neural network architecture initializer = keras.initializers.he_normal(seed=seed)   
    activation = keras.activations.elu
    optimizer = keras.optimizers.Adam(
         lr=experiment.get_parameter("lr"), 
         beta_1=0.99, 
         beta_2=0.999, 
         epsilon=1e-8) es = EarlyStopping(monitor='val_acc', 
                       mode='max', 
                       verbose=1, 
                       patience=4)
    batch_size = experiment.get_parameter("batch_size") # Build model architecture model = Sequential(# Build model like above)
    score = model.evaluate(X_test, onehot_encoded_val, verbose=0)
    logging.info("Score %s", score)

运行我们的优化后，很容易选择能够产生最高精度、最低损耗或您想要优化的任何性能的超参数配置。这里我们保持优化问题相当简单:我们只搜索 epoch、batch_size 和 dropout。下面显示的平行坐标图是 Comet 的另一个固有特性，它提供了我们的优化器遍历的底层超参数空间的有用可视化:

Comet Visualizations Dashboard

让我们运行另一次优化扫描，这次包括要测试的一系列学习率。

Comet Visualizations Dashboard

我们再次看到产生更高val_acc值的潜在超参数空间的区域。

比方说，现在我们想比较两款更好的型号的性能，以保持微调。只需从您的列表中选择两个实验并单击Diff按钮，Comet 将允许您直观地检查每个代码和超参数的变化，以及两个实验的并排可视化。

Comet Experiment Diff View

从这里，您可以继续您的模型建设。微调我们从架构比较和参数优化扫描中抽出的一个模型，或者回到起点，将新架构与我们的基线模型进行比较。你所有的工作都保存在你的彗星项目空间。

未来学习的资源

有关 NLP 的其他学习资源，请查看 fastai 的新的 NLP 课程或由 Hugging Face 发布的这篇博客文章，其中涵盖了 NLP 中一些最好的最新论文和趋势。

多亏了道格拉斯·布兰克。

10 分钟内开始使用 neo4j

原文：https://towardsdatascience.com/getting-started-with-neo4j-in-10-minutes-94788d99cc2b?source=collection_archive---------7-----------------------

在本文中，我们将使用 neo4j 创建第一个图形数据库。

安装 neo4j 后，我们将探索创建数据库的两种方法:

手动键入密码查询
使用 Excel 公式生成密码查询。如果您从 Excel 文件开始，这将非常有用

在深入研究代码之前，我们先来了解一下什么是 neo4j，以及为什么了解这项技术很重要。

neo4j 是什么？

Screenshot of neo4j browser (source: neo4j website)

简单来说，neo4j 就是图形数据库的 mySQL。它提供了一个图形数据库管理系统、一种查询数据库的语言、一个密码和一个带有 neo4j 浏览器的可视化界面。

Neo4j 是一个开源项目，由一家私人公司维护。它有一个免费版本，我们将在这里使用。注意，我不工作，也不接受他们的任何东西。

对我来说，neo4j 的主要优势在于:

免费版本非常适合原型制作。我从来不需要高级版本
neo4j 浏览器给了你很多自定义可视化的自由。它可以被非数据科学家使用
与 SQL 非常相似的语言 CYPHER 允许简单和复杂的查询，以获得您想要的结果。掌握所有的概念需要一些时间，但经过一些练习后，它会变得强大
LOAD CSV 函数，它简化了从 CSV 文件创建图形的任务

另一件很棒的事情是脚本语言中有多种可用的 API，比如 Python。但是这将在另一篇文章中介绍。

一.设置 neo4j

下载并安装 neo4j 桌面

You have to fill the form to download neo4j

2.安装完成后，点击“我的项目”下的“新建图形”，然后“创建一个本地图形”。记下图形的名称和密码。

3.运行数据库，点击“播放”标志。

Now open the neo4j browser with the new graph you created. A bar at the top will appear and you’ll type queries there

二。创建您的 neo4j 图形数据库

假设你的数据是关于人和组织的。人是一种“节点”,而组织是另一种。它们可以通过特定的关系连接在一起。就像有人在一家公司工作过，有人是这家公司的董事长，或者一家公司是另一家公司的母公司。

1.在 neo4j 浏览器中编写密码查询

CYPHER 是一种灵活的语言，你可以同时创建节点、关系甚至两者。

让我们从简单直观的方式开始:创建节点，然后创建关系。

使用以下语法创建一个节点:
CREATE ( x: LABEL {属性名称:属性值})

其中 x :是节点的变量名，你可以随便叫它。当您重用它时，例如使用 RETURN x 在查询末尾绘制节点时，这很有用。
LABEL :是节点的标签。在我们的例子中，我们有两个标签:组织和个人

例如

创建(p:Org { Name:" super robotics Limited " })

点击回车键，您将得到一个确认(或一个错误)，表明节点已经创建。在我的例子中，它起作用了，正如“添加了 1 个标签，创建了 1 个节点…”

顺便说一下，通过运行上面的查询，我们隐式地创建了一个名为 Org 的标签。

让我们创建一个担任该组织主席的人，并将他与该组织相关联。

创建(p: Person { Name: "Patrick Moon" })

然后

MATCH (p:Person)，(o:Org)
其中 p.Name = "Patrick Moon "和 o . Name = " super robotics Limited "
CREATE(p)-【r:主席】- > (o)
RETURN p，r，o

Adding the RETURN at the end of the query will plot the newly created relationship. Note that neo4j has a color coding that differentiates labels automatically.

现在我们有点明白 CYPHER 是如何工作的了:要么你创建一些新的东西，然后从 create 开始，要么你试图在图中找到现有的东西，然后从 MATCH 开始。节点在括号()中，关系在方括号[]中，属性在花括号{}中。

注意 : 2 个查询如果把图搞砸了对从头开始重新开始很有用:删除所有节点和关系: match (n)-[r]-() delete n，r 删除所有节点:match(n)Delete n
_ _ _ _ _ _ _

好了，现在让我们假设我们有一个 Excel，其中有 100 多人链接到组织，我们不想写 100 次相同的查询。让我们用 Excel 中的老方法来做吧。

2.使用 Excel 公式从 Excel 粘贴密码查询

在这个例子中，我从维基百科的文章中复制并粘贴了著名公司首席执行官名单的数据。

我们希望为每一行创建一个查询，同时创建:

公司的一个节点
CEO 的一个节点
两者之间的关系

让我们开始吧:

= " CREATE(:PERSON { Name:" " & B2 & " " " })-[:CEO { Since:" " & D2 & " " "，备注:" " " & E2 & " " " }]-->(:ORG { Name:" " & A2 & " " })"

注意，我删除了节点(p 和 o)和关系(r)中的第一个变量。这是因为我们将同时向 neo4j 发送 184 个创建查询，所以我们需要确保它理解每个节点(p 或 o)和关系(r)都不同于上面一行创建的节点。

一旦您复制并粘贴了所有行的公式，您将得到如下结果:

现在让我们将创建的公式复制并粘贴到 neo4j 中。显示图表中的所有节点

匹配返回

结论

在本文中，我们已经完成了安装 neo4j 和创建您的第一个图表的初始步骤，大概花了 10-15 分钟吧？相当简单。

下一步

在图表中搜索有趣的模式…

使用 PyTorch 框架开始使用 NLP

原文：https://towardsdatascience.com/getting-started-with-nlp-using-the-pytorch-framework-72e7b17b8717?source=collection_archive---------17-----------------------

PyTorch 是最流行的深度学习框架之一，它基于 Python，由脸书支持。

在本文中，我们将研究 PyTorch 提供的帮助自然语言处理(NLP)的类。

PyTorch 中有 6 个类可用于使用递归层的 NLP 相关任务:

torch.nn.RNN
火炬. nn.LSTM
火炬网
火炬
火炬. nn.LSTMCell
火炬. nn .格鲁塞尔

理解这些类、它们的参数、它们的输入和输出是开始在 Pytorch 中为自然语言处理(NLP)构建自己的神经网络的关键。

如果你已经开始了你的 NLP 之旅，很可能你已经遇到了类似的图表(如果没有，我们建议你看看克里斯·奥拉的这篇精彩的、经常被引用的文章——了解 LSTM 网络):

来源—【http://colah.github.io/posts/2015-08-Understanding-LSTMs/

教师使用这种展开图向学生提供这种神经网络的递归结构的简单易懂的解释。从这些漂亮的、展开的图表和直观的解释到 Pytorch API 可能被证明是具有挑战性的。

来源—https://pytorch.org/docs/stable/nn.html#recurrent-layers

因此，在本文中，我们旨在通过以清晰和描述性的方式解释 PyTorch 中相关类的参数、输入和输出来弥补这一差距。

Pytorch 基本上有两个等级的类来构建循环网络:

多层类— nn。新泽西州 RNN。GRU·安迪。LSTM这些类的对象能够表示深度双向递归神经网络(或者，如类名所示，它们的一个或多个进化架构——门控递归单元(GRU)或长短期记忆(LSTM)网络)。
细胞水平类— nn。新罕布什尔州 RNNCell。格鲁塞尔和 nn。LSTMCell这些类的对象只能代表一个单元格(同样，一个简单的 RNN 或 LSTM 或 GRU 单元格)，它可以处理一个时间步长的输入数据。(记住，这些细胞没有 cuDNN 优化，因此没有任何融合操作，等等。)

同一级别的所有类共享相同的 API。因此，理解上述两个层次中任何一个类的参数、输入和输出就足够了。

为了使解释简单，我们将使用最简单的类——torch . nn . rnn 和 torch.nn.RNNCell

火炬. nn.RNN:

我们将使用下图来解释 API —

来源——【http://colah.github.io/posts/2015-08-Understanding-LSTMs/

参数:

input_size —输入 x 中期望特征的数量

这表示向量 x[i]的维数(即上图中从 x[0]到 x[t]的任何向量)。请注意，这很容易与序列长度混淆，序列长度是我们在如上展开 RNN 后得到的细胞总数。

hidden_size —处于隐藏状态的特征数量 h

这表示向量 h[i]的维数(即上图中从 h[0]到 h[t]的任何向量)。总的来说，在确定网络的权重矩阵的形状时，隐藏大小和输入大小是必要的和充分的。

层数 —循环层数。例如，设置 num _ layers =将意味着将两个 RNN 堆叠在一起以形成堆叠的 RNN，其中第二 RNN 接收第一 RNN 的输出并计算最终结果。默认值:1

此参数用于构建深度 rnn，如下所示:

这里，红色单元代表输入，绿色块代表 RNN 单元，蓝色块代表输出

所以对于上图，我们将 num_layers 参数设置为 3。

非线性 —要使用的非线性。可以是“tanh”或“relu”。默认值:“tanh”

这是不言自明的。

偏差-如果为假，则该层不使用偏差权重 b_ih 和 b_hh。默认值:真

在深度学习社区，一些人发现去除/使用偏见不会影响模型的性能。因此这个布尔参数。

batch_first —如果为真，则输入和输出张量提供为(batch，seq，feature)。默认值:False
dropout —如果非零，在除最后一层之外的每个 RNN 层的输出上引入一个丢弃层，丢弃概率等于 dropout。默认值:0

该参数用于控制 RNN 体系结构中的退出正则化方法。

双向 —如果为真，则成为双向 RNN。默认值:False

创建双向 RNN 非常简单，只需将该参数设置为 True！

因此，要在 PyTorch 中制作 RNN，我们需要向该类传递两个强制参数——input _ size 和 hidden_size。

一旦我们创建了一个对象，我们就可以用相关的输入“调用”该对象，它就会返回输出。

输入:

我们需要向对象传递 2 个输入——input 和 h_0:

输入 —这是一个形状张量(序列长度，批次，输入大小)。为了处理可变长度的输入，我们将较短的输入序列打包。详见torch . nn . utils . rnn . pack _ padded _ sequence()或torch . nn . utils . rnn . pack _ sequence()。
h_0 —这是一个形状张量(num_layers * num_directions，batch，hidden_size)。对于双向 RNNs，num_directions 为 2，否则为 1。这个张量包含批处理中每个元素的初始隐藏状态。

输出:

以类似的方式，对象向 us 返回 2 个输出——output 和 h_n:

输出 —这是一个形状为(序列长度，批次，数量方向隐藏尺寸)的张量。*它包含来自 RNN 最后一层的输出特征(h_k ),对于每个 k
h_n —这是一个大小为(num_layers * num_directions，batch，hidden_size)的张量。它包含 k = seq_len 的隐藏状态。

如前所述，torch.nn.GRU 和 torch.nn.LSTM 具有相同的 API，也就是说，它们接受相同的参数集，接受相同格式的输入并以相同格式返回。

torch.nn.RNNCell:

因为这仅代表 RNN 的单个单元格，所以它仅接受 4 个参数，所有这些参数的含义与它们在 torch.nn.RNN 中的含义相同。

参数:

input_size —输入 x 中预期特征的数量
hidden_size —处于隐藏状态的特征数量 h
偏差 —如果为假，则该层不使用偏差权重 b_ih 和 b_hh。默认值:真
非线性 —要使用的非线性。可以是“tanh”或“relu”。默认值:“tanh”

再说一次，因为这只是 RNN 的一个细胞，输入和输出维度要简单得多——

输入(输入，隐藏):

输入 —这是一个包含输入特征的形状张量(batch，input_size)。
hidden——这是一个形状张量(batch，hidden_size ),包含批处理中每个元素的初始隐藏状态。

输出:

h’—这是一个形状张量(batch，hidden_size)，它为我们提供了下一个时间步的隐藏状态。

这是关于自然语言处理(NLP)py torch 框架的入门知识。如果你正在寻找关于什么是可能的和你能构建什么的想法，请查看使用 RNNs 和 CNN 的自然语言处理的深度学习。

原载于 2019 年 3 月 19 日【blog.exxactcorp.com。

NumPy 入门

原文：https://towardsdatascience.com/getting-started-with-numpy-59b22df56729?source=collection_archive---------10-----------------------

NumPy 代表NumericalPython它是 Python 中的一个核心 科学计算 库。它提供了高效的 多维数组对象 和各种操作来处理这些数组对象。

在这篇文章中，你将了解到
1。安装数字
2。在 NumPy
3 中创建数组。NumPy 数组上的基本操作

安装 Numpy

Mac 和 Linux 用户可以通过 pip 命令安装 NumPy:

pip install numpy

2.因为 windows 没有像 linux 或 mac 那样的包管理器，所以你可以从这里下载 NumPy。一旦你下载了合适的。从链接的 whl 文件中，打开命令提示符。导航到下载的目录。whl 文件。最后，使用以下命令安装它:

pip install name_of_the_file.whl

注意:如果您正在使用 Anaconda，您不需要安装 NumPy，因为它已经与 Anaconda 一起安装了。然而，您可以通过命令在 Anaconda 中安装任何包/库:

conda install name_of_the_package
# conda install numpy

要在我们的程序中使用 Numpy 库，你只需要导入它。

import numpy as np

NumPy 中的数组简介

NumPy 数组是 同质网格 的值。数组的维数在 NumPy 中称为轴。轴数称为秩。给出数组沿每个维度的大小的非负整数元组称为其 形状。例如，考虑下面的 2D 阵列。

[[11, 9, 114]
 [6, 0, -2]]

这个数组有两个轴。长度 2 的第一轴和长度 3 的第二轴。
秩=轴数= 2。
形状可以表示为:(2，3)。

在 NumPy 中创建数组

要创建一个数组，可以使用数组numpy 的方法。

*# Creating 1D array
a = np.array([1, 2, 3])# Creating 2D array
b = np.array([[1,2,3],[4,5,6]])*

创建 NumPy 数组的函数:

*a = np.zeros((2,2))     # Create an array of all zerosb = np.ones((1,2))      # Create an array of all onespi = 3.14
c = np.full((2,2), pi)  # Create a constant array of pid = np.eye(3)           # Creates a 3x3 identity matrixe = np.random.random((2,2))  # Create an array of random values*

为了创建数字序列，NumPy 提供了一个类似于 range 的函数，它返回数组而不是列表。

arange :返回给定区间内间隔均匀的值。步长是指定的。
linspace :返回给定间隔内间隔均匀的值。num 返回元素的数量。

*A = np.arange(0, 30, 5)   # Creates [ 0, 5, 10, 15, 20, 25]B = np.linspace(1, 15, 3) # Creates [ 1.0,  8.0, 15.0]*

你可以用重塑的方法重塑一个数组。考虑一个形状为(a1，a2，a3，…，an)的数组。我们可以改变它的形状并将其转换成另一个形状为(b1，b2，b3，…..，bM)。

唯一的条件是:()a1 * a2 * a3… aN) = (b1 b2 * b3 … bM )**
即两个数组中的元素数量必须相同。*

访问数组元素:切片

就像 Python 列表一样，NumPy 数组也可以切片。由于数组可能是多维的，因此必须为数组的每个维度指定一个切片。例如

*a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])*

这将创建一个如下所示的数组

*[[1  2  3  4]
 [5  6  7  8]
 [9 10 11 12]]*

现在让我们假设你想从中访问元素。

*# Accessing an element
b = a[rowIndex, colIndex]# Accessing a block of elements together
c = a[start_row_index:end_row_index, start_col_index:end_col_index]*

注 1:Python 中的 Index 从 0 开始。
注 2: 每当我们将元素块指定为start _ row _ index:end_row_index时，它就意味着
【start _ row _ index，end _ row _ index】

NumPy 数组上的基本操作

基本算术运算

*# Create a dummy array for operations
a = np.array([1, 2, 5, 3])# Add 3 to every element
a += 3# Subtract 5 from every element
a -= 5# Multiply each element by 7
a *= 7# Divide each element by 6
a /= 6# Squaring each element
a **= 2# Taking transpose
a = a.T*

其他一些有用的功能

*# Create a dummy array
arr = np.array([[1, 5, 6], [4, 7, 2], [3, 1, 9]])# maximum element of array
print(arr.max())# row-wise maximum elements
arr.max(axis=1)# column wise minimum elements
arr.min(axis=0)# sum of all array elements
arr.sum()# sum of each row
arr.sum(axis=1)# cumulative sum along each row
arr.cumsum(axis=1)*

两个 NumPy 数组上的操作

*a = np.array([[1, 2], [3, 4]])b = np.array([[4, 3], [2, 1]])print(a+b)      # [[5, 5], [5, 5]]print(a-b)      # [[-3, -1], [1, 3]]print(a*b)      # [[4, 6], [6, 4]]print(a.dot(b)) # [[8, 5], [20, 13]]*

NumPy 提供了很多数学函数，比如 sin，cos，exp 等。这些函数也对数组进行元素操作，产生一个数组作为输出。

*a = np.array([0, np.pi/2, np.pi])print(a)print(np.sin(arr))     *# sin of each element*print(np.cos(arr))     *# cosine of each element*print(np.sqrt(arr))     *# square root of each element*print(np.exp(arr))     *# exponentials of each element*print(np.log(arr))     *# log of each element*print(np.sum(arr))     *# Sum of elements*print(np.std(arr))     *# standard deviation**

NumPy 中的排序数组

*a = np.array([[1, 4, 2], [3, 4, 6], [0, -1, 5]])# array elements in sorted order
print(np.sort(a, axis=None))# sort array row wise
print(np.sort(a, axis=1))*

这就是 NumPy 的故事。我们已经讨论了很多重要的概念。我希望它能让你明白很多。

Nvidia Jetson Nano 入门和安装 Tensorflow GPU

原文：https://towardsdatascience.com/getting-started-with-nvidia-jetson-nano-and-installing-tensorflow-gpu-ad4a3da8ed26?source=collection_archive---------11-----------------------

作为 Nsemble.ai 的部署工程师，我致力于研究和交付基于云和 IOT 的机器学习和深度学习解决方案。在 IOT 设备上部署对象检测模型是一项繁琐的任务。甚至高端深度学习模型在 Raspberry pi 等基本设备上的处理速度也很慢。我研究了一段时间，得到了这个惊人的设备适合生产准备所谓的英伟达杰特森纳米。它的图形体验令人惊叹，也很划算(99 美元)。这种物联网设备非常适合部署繁重的深度学习模型。

这是一个简单的博客，用于开始使用 Nvidia Jetson Nano IOT 设备(设备概述和操作系统安装)，然后安装 tensorflow 的 GPU 版本。

介绍

NVIDIA Jetson Nano 开发者套件是一款面向开发者、学习者和开发者的小型人工智能电脑。在遵循这个简短的指南之后，你将准备好开始构建实用的人工智能应用程序、酷酷的人工智能机器人等等。

Nvidia Jeston Nano newly opened

准备安装

入门项目

microSD 卡

Jetson Nano 开发套件使用 microSD 卡作为启动设备和主存储。对于你的项目来说，拥有一张足够大且足够快的卡是很重要的；推荐的最低容量是 16GB 的 UHS-1 卡。

请参阅以下说明，用操作系统和软件刷新您的 microSD 卡。

微型 USB 电源

您需要使用优质电源为开发套件供电，该电源可以在开发套件的微型 USB 端口提供 5V⎓2A。并非每个额定为“5V⎓2A”的电源都会这样做。

可选项目

无线网络适配器

Jetson Nano 开发套件包括一个千兆以太网端口，但也支持许多常见的 USB 无线网络适配器，例如 Edimax EW-7811Un。

将图像写入 microSD 卡

要准备您的 microSD 卡，您需要一台能够通过内置 SD 卡插槽或适配器连接互联网并读写 SD 卡的计算机。

下载 Jetson Nano Developer Kit SD 卡映像，并记下它保存在电脑上的位置。
根据您使用的计算机类型，按照以下说明将图像写入您的 microSD 卡。

使用 SD 协会的 SD 存储卡格式化程序格式化您的 microSD 卡。

SD Formatter

下载、安装并启动用于 Windows 的 SD 存储卡格式器。
选择卡驱动器
选择“快速格式化”
将“卷标”留空
单击“格式化”开始格式化，并在警告对话框中单击“是”

使用 Etcher 将 Jetson Nano Developer Kit SD 卡映像写入您的 microSD 卡

下载、安装并启动蚀刻机。

Etcher overview

Etcher 用于使 sd 卡可使用 nvidia 开发商为 jetson nano 提供的 ready to go ubuntu desktop 提供的操作系统启动

单击“选择图像”并选择之前下载的压缩图像文件。
如果尚未插入 microSD 卡，请将其插入。

如果 windows 用这样的对话框提示您，请单击“取消”:

4.单击“选择驱动器”并选择正确的设备。

5.点击“闪！”如果您的 microSD 卡通过 USB3 连接，Etcher 大约需要 10 分钟来写入和验证图像。

6.Etcher 完成后，Windows 可能会让您知道它不知道如何读取 SD 卡。只需点击取消，取出 microSD 卡。

Click cancel

设置和首次引导

设置步骤

展开纸架，放入显影盒中。
将显影组件放在纸架顶部。
将 microSD 卡(已写入系统映像)插入 Jetson Nano 模块底部的插槽中

4.打开电脑显示器的电源并连接。

5.连接 USB 键盘和鼠标。

6.连接您的微型 USB 电源(5V⎓2A).Jetson Nano 开发套件将自动通电并启动。nvidia 一启动，显示器上的第一个输出就会是这样的。

第一次开机

一旦开发套件通电，Micro-USB 连接器旁边的绿色 LED 就会亮起。当您第一次启动时，Jetson Nano 开发工具包将带您完成一些初始设置，包括:

审查并接受英伟达捷成软件 EULA 公司
选择系统语言、键盘布局和时区
创建用户名、密码和计算机名
登录

登录后

您将看到这个屏幕。恭喜你！

Ubuntu Desktop as soon as system boots up on Nvidia Jetson Nano

故障排除

力量

如果您无法启动您的 Jetson Nano 开发工具包，问题可能出在您的 USB 电源上。请使用像这个一样的优质电源。

同样重要的是，要有优质的电源线将电源连接到开发套件:

最好使用永久连接电源线的电源。
较短的电缆会降低电压。

显示

不支持 HDMI 转 DVI 适配器。请使用支持 HDMI 或 DP 输入的显示器。

在 Nvidia Jetson Nano 上安装 tensor flow GPU

我之所以包括这一步，是因为在这个设备上安装 GPU 版本非常容易。

打开终端并输入以下命令:

安装依赖项:

sudo apt-get install python3-pip libhdf5-serial-dev hdf5-tools

安装 tensorflow-gpu 库

sudo pip3 install --pre --extra-index-url [https://developer.download.nvidia.com/compute/redist/jp/v42](https://developer.download.nvidia.com/compute/redist/jp/v42) tensorflow-gpu

如果出现 HTTP 404 Not found 错误，请尝试以下命令

pip3 安装—pre—extra-index-URLhttps://developer.download.nvidia.com/compute/redist/jp/v42tensor flow-GPU

Plot.ly 入门

原文：https://towardsdatascience.com/getting-started-with-plot-ly-3c73706a837c?source=collection_archive---------4-----------------------

Source: Bailey Zindel on Unsplash

Python 中强大可视化的引导式演练

作者:爱丽丝·李和伊桑·戴伊

Matplotlib 还行，Seaborn 很棒，但是 Plot.ly？这是一个全新的水平。Plot.ly 通过提供完全交互性的选项和许多编辑工具，提供了比一般图形更多的功能。与其他产品不同的是，它可以选择在离线和在线模式下显示图形，它还配备了一个强大的 API，当设置完成后，它将无缝地在 web 浏览器中显示图形，并能够保存本地副本。你将遇到的唯一的挫折之一是处理许多选项来找出你想要用于你的情节的工具。

概观

我们将从在 Python 中设置 plot.ly 的基础开始。在那之后，我们将从一些基本的可视化开始，从典型的盒须图到 choropleth 图，以及沿途的代码分解。我们在本指南中使用 Zillow Economics 数据集进行了所有可视化，该数据集包含 1996 年至 2017 年按位置汇总的各种住房指标的时间序列数据。如果你对这篇文章的完整代码感兴趣，可以查看下面的 GitHub 链接；否则，用于创建可视化效果的所有代码都将包含在每个可视化效果中。

我们的希望是，到最后，您将对 plotly API 如何工作有一个基本的直觉，并且对您可以应用于自己的项目的通用框架有一个感觉。你可以在这里找到一个指向 plotly cheatsheet 的链接，如果你对用于可视化的任何参数有兴趣，你可以使用help()函数访问文档。关于所有类型的图和参数的更多细节，这里的是关于 Plotly 的 Python 开源图形库的更多信息的链接。

安装

Plotly 是一个运行在 JSON 上的平台，JSON 是一种以字典格式将参数传递给 plotly API 的格式。我们可以使用plot.ly包在 python 中访问这个 API。要安装软件包，打开终端并输入$ pip install plotly或$ sudo pip install plotly。

Plotly 的图表是使用在线网络服务托管的，因此您首先需要在线设置一个免费帐户来存储您的图表。要检索您的个人 API 密钥，请点击此处的链接:https://plot.ly/settings/api#/。一旦你这样做了，你就可以用set_credential_files()函数开始设置 plotly，如下所示。

import plotlyplotly.tools.set_credentials_file(username=’YourAccountName’, api_key=’YourAPIKey’)``

在线和离线绘图

在 plotly 上显示可视化效果时，绘图和数据都会保存到您的 plotly 帐户中。无需在云中购买更多空间，您最多可以在云中存储 25 个图，但这些图像可以轻松地存储在本地，并在为更多空间腾出空间时删除。

有两种主要的方法来显示 plotly 图。如果您正在使用 Jupyter Notebook 或其他交互式 python 环境(扩展名为.ipynb的文件)，py.iplot()函数会在单元格下方的输出中显示绘图。另一方面，py.plot()返回一个可以保存的 url，并且也使用默认的 web 浏览器打开。

Plotly 离线模式也使您能够在本地保存图形。要离线绘图，您可以使用plotly.offline.plot()或plotly.offline.iplot()。同样，iplot()功能用于 Jupyter 笔记本，并将在笔记本内显示图形。plot()创建一个保存在本地的 HTML 页面，以便在网络浏览器中打开。

基本结构

正如我们之前提到的，所有 plot.ly 可视化都是使用 Json 结构创建的，Json 结构是要使用 API 修改的参数列表，因此本质上您将看到参数和通用结构来制作每个绘图，如果您学习了其中一个，您可以制作其余的。

import plotly.plotly as py
import plotly.graph_objs as go

import plotly.plotly as py:具有与 plotly 服务器通信的功能

import plotly.graph_objs as go:具有生成图形对象的功能。这是一个有用的模块，用于调用帮助来查看作为对象参数的所有属性。对象也有不同的有用方法，如 update 方法，可用于更新 plot 对象以向其添加更多信息。

广义结构

graph_objs类包含几个结构，这些结构在 plot.ly 中创建的可视化中是一致的，与类型无关。

我们从trace开始，它可以被认为是一个单独的层，包含数据和数据应该如何绘制的规范(即线条、标记、图表类型)。下面是 trace 结构的一个示例:

trace1 = {
  "x": ["2017-09-30", "2017-10-31", "2017-11-30", ...], 
  "y": [327900.0, 329100.0, 331300.0, ...], 
  "line": {
    "color": "#385965", 
    "width": 1.5
  }, 
  "mode": "lines", 
  "name": "Hawaii", 
  "type": "scatter", 
}

如您所见，trace是要绘制的数据的参数字典，以及关于颜色和线型的信息。

我们可以通过将它们附加到一个列表来编译几个跟踪，我们称之为data。列表中轨迹的顺序决定了它们在最终绘图上的放置顺序。通常，数据应该是这样的:

 data = [trace1, trace2, trace3, trace4]

layout = go.Layout():该对象用于数据的布局，包括数据的外观和可变特性，如标题、轴标题、字体和间距。就像trace一样，是字典的字典。

layout = {
  "showlegend": True, 
  "title": {"text": "Zillow Home Value Index for Top 5 States"}, 
  "xaxis": {
    "rangeslider": {"visible": True}, 
    "title": {"text": "Year from 1996 to 2017"}, 
    "zeroline": False
  }, 
  "yaxis": {
    "title": {"text": "ZHVI BottomTier"}, 
    "zeroline": False
  }
}

我们最终可以使用go.Figure()函数来编译数据和布局，它最终会被传递给我们选择的绘图函数。

fig = go.Figure(data = data, layout = layout)

条形图

go.Bar()创建一个条形图类型的图。在go.Layout()函数中，我们可以指定重要的信息，比如barmode = “group”，它将每年不同的条形图组合在一起，x 和 y 轴的标签，以及完整图表的标题。

线条图

go.Scatter()实例化散点图类型的痕迹，与条形图或其他形式相反。

我们可以使用 mode 参数更改标记的模式。即使我们使用的是散点图，我们也可以生成散点图，在散点图上创建线条和标记(点)。

mode = “lines+markers”

时间序列线图

在这里，我们添加了一个范围滑块，使用rangeslider参数调整可以包含在主图中的数据域。

我们还传递了一个颜色字典，其中包含每个州的唯一颜色。为此，我们使用了 seaborn color_palette()函数，指定了颜色范围，以及分布中需要的离散值的数量。因为 plot.ly 不接受 RGB 元组，我们可以使用as_hex()函数将输出转换为十六进制代码。

多重散点图

为了创建这个布局，我们使用make_subplots()函数创建子情节，并使用append_trace()函数将轨迹添加到网格上的特定位置，而不是将轨迹附加到单个字典。

等值区域图

有了 choropleth，我们可以使用 figure factory 类走捷径，它包含一组函数来轻松绘制更复杂的图形，如地理地图。

import plotly.figure_factory as ff

从ff.create_choropleth()函数中，我们传递一组FIPS值，或特定于每个县、市或州的地理标识码，其中values(ZHVI _ 底层)对应于要分配给该地区的数据。

最后的想法

正如上面不同类型图表的例子所描述的，Plot.ly 是一个强大的工具，可以为广泛的受众开发视觉愉悦和易于理解的情节。它有许多好处，包括可以广泛地访问离线和在线模式，并且包含可以在笔记本和网络浏览器中显示生成的图形的功能。由于在交互性方面的额外优势，Plotly 是 Matplotlib 和 Seaborn 的一个很好的替代品，并且可以增强演示的效果。

如果您有任何问题，请告诉我们！

Polynote 入门:网飞的数据科学笔记本

原文：https://towardsdatascience.com/getting-started-with-polynote-netflixs-data-science-notebooks-47fa01eae156?source=collection_archive---------10-----------------------

Source: https://polynote.org/

图沙尔·卡普尔😦https://www.tusharck.com/)

2019 年 10 月 23 日，网飞宣布开源推出 Polynote:一款新的多语言笔记本，这是他们开发的内部基于 JVM 的 ML 平台笔记本，现在向公众发布。它具有一些迄今为止您在笔记本 ide 中缺少的革命性功能，特别是对于数据科学家和机器学习研究人员来说，它通过一流的 Scala 支持、Apache Spark 集成、多语言互操作性(包括 Scala、Python 和 SQL)为他们提供了以前不存在的工具和灵活性。自动完成功能在顶部添加了樱桃。以下是帮助您设置和运行带有 Apache Spark 配置的笔记本的步骤。

设置 Polynote 笔记本 IDE 的步骤(Mac/Linux)

下载以下内容:

多项式:https://github.com/polynote/polynote/releases
阿帕奇火花:https://spark.apache.org/downloads.html
Java(根据您的操作系统选择):https://www . Oracle . com/tech network/Java/javase/downloads/JDK 8-downloads-2133151 . html

2.打开终端并转到下载位置:

cd Users/user_name/Downloads

3.解压缩 tar 文件:

tar -zxvpf polynote-dist.tar.gz
cd polynote

4.解压缩 Apache Spark 文件(您可能需要根据 Spark 版本更改文件名):

tar -zxvpf spark-2.4.4-bin-hadoop2.7.tgz
cd polynote

5.现在，您需要设置一些环境变量以使 polynote 正常运行，请设置以下变量:

注 :

将用户名更改为您的用户
将 JAVA_HOME path 变量中的 jdk1.8.0_191.jdk 修改为您系统中安装的版本。要检查版本，您可以在终端上运行java -version。

**export** **JAVA_HOME**=/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/**export** **SPARK_HOME**=/Users/user_name/Downloads/spark-2.4.4-bin-hadoop2.7**export PATH**="$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin"

6.检查 spark-submit 是否工作，在您的终端中键入 spark-submit ，然后您应该会看到类似这样的内容。

Usage: spark-submit [options] <app jar | python file | R file> [app arguments]Usage: spark-submit --kill [submission ID] --master [spark://...]Usage: spark-submit --status [submission ID] --master [spark://...]Usage: spark-submit run-example [options] example-class [example args]
...
...

7.您还需要安装一些 python 依赖项:

pip3 install jep jedi pyspark virtualenv

注意 :如果你在 Mac 上得到一个“无效活动开发者路径”的错误，你需要通过运行下面的命令来安装 xcode 开发者工具。然后之后就可以安装上面的依赖项了。

xcode-select --install

8.在 polynote 目录下运行以下命令，在浏览器上启动笔记本 IDE(与 Google Chrome 配合使用效果最佳)

./polynote

9.打开谷歌浏览器，复制粘贴以下网址:

[http://127.0.0.1:8192/](http://127.0.0.1:8192/)

您的 Polynote 笔记本 IDE 现在应该已经启动并运行，应该会看到如下内容:

Polynote welcome page

制作您的第一个 polynote 笔记本并设置 spark 配置

单击左侧窗格中的加号图标创建一个笔记本。

2.在弹出的对话框中输入您的 polynote 笔记本的名称，然后按 ok。

3.点击 配置&依赖 就在你的笔记本名称上方。

4.在这里为笔记本设置 Spark 配置，点击 保存&重启 。

spark.driver.userClasspathFirst: truespark.executor.userClasspathFirst: truespark.master: local[*]

5.添加一个新单元格，添加以下代码，然后按 shift enter 键:

**val** scalaDF = spark.createDataFrame(List((8, **"bat"**),
(64, **"mouse"**),
(-27, **"horse"**)))

6.要可视化您的数据帧，运行以下代码并按下图形图标。

scalaDF

7.将打开一个弹出框，您可以在其中设置指标和轴，以可视化您的数据框架，如下所示:

Sample Graph

8.要在 python 中使用数据帧，请执行以下操作:

添加一个新的单元格，将该单元格的语言从 Scala 更改为 Python，并运行以下代码:

**from** pyspark.sql **import** DataFramepythonDF = DataFrame(scalaDF, sqlContext) # sqlContext is provided by PolynotepandaDF = pythonDF.toPandas()pandaDF

您可以从下面的 git URL 查看 polynote 笔记本。

https://github . com/tusharck/polynotebook-sample/blob/master/first _ polynotebook . ipynb

也可以查看下面关于混合编程语言的 polynote 文档:

https://polynote . org/docs/03-mixing-programming-languages . html

AWS EMR 上的 PySpark 入门

原文：https://towardsdatascience.com/getting-started-with-pyspark-on-amazon-emr-c85154b6b921?source=collection_archive---------1-----------------------

使用 Spark on AWS 大规模处理数据的分步指南

带有 PySpark 和 AWS EMR 的数据管道是一个多部分系列。这是第 1 部分，共 2 部分。如果您正在寻找如何将数据管道作为产品工作来运行的指导，请查看第 2 部分。

AWS EMR 上的 PySpark 入门(本文)
在 AWS EMR 上使用 PySpark 处理生产数据 (接下来)

动机

如果您在过去十年中一直关注业务和技术趋势，您可能会意识到组织生成的数据量已经激增。企业渴望使用所有这些数据来获得洞察力和改进流程；然而，“大数据”意味着巨大的挑战。

必须发明全新的技术来处理越来越大的数据集。这些新技术包括云计算服务提供商的产品，如亚马逊网络服务(AWS)和开源的大规模数据处理引擎，如 Apache Spark。随着生成的数据量持续飙升，能够使用这些“大数据”工具的有抱负的数据科学家将在市场中脱颖而出。

我们开始吧

在本指南中，我将教您如何在 Amazon EMR 集群上开始使用 PySpark 处理数据。本教程面向熟悉 Python，但刚开始使用 Spark 的当前和有抱负的数据科学家。

Spark 非常适合处理大型数据集，用于探索性数据分析和特征工程等日常数据科学任务。它还可以用于大规模实现许多流行的机器学习算法。

我们今天要讲的内容

Spark、亚马逊 S3 和 EMR 概述
在 Amazon EMR 上创建集群
通过 Jupyter 笔记本连接到我们的集群
从亚马逊 S3 加载数据

大数据工具概述

火花

在文档中，“Apache Spark 是一个用于大规模数据处理的统一分析引擎。”Spark 的引擎允许您在分布式集群上并行处理大型数据处理任务。Spark 集群包含一个充当中央协调器的主节点和几个处理主节点分配的任务的工作节点。

在本指南中，我们将使用 Python，但是 Spark 开发人员也可以使用 Scala 或 Java。模块包含 Pandas 和 SQL 用户熟悉的语法。pyspark.ml模块可以用来实现很多流行的机器学习模型。

Spark 使用懒惰评估，这意味着它不做任何工作，直到你要求一个结果。通过这种方式，引擎可以决定执行 DAG(有向无环图-或您指定的操作列表)的最佳方式。当我定义一个操作时— new_df = df.filter(df.user_action == 'ClickAddToCart') — Spark 将该操作添加到我的 DAG 中，但不执行。一旦我请求一个结果— new_df.collect() — Spark 就会执行我的过滤器和我指定的任何其他操作。

在我们继续之前有一个小提示: 使用分布式云技术可能会令人沮丧。首先，您可能会发现 Spark 错误消息难以理解，难以调试。我鼓励你坚持下去！阅读错误。了解哪些部分信息丰富，然后谷歌一下。我不能保证你最终会停止敲键盘，但会变得更容易。如果没有学习曲线，这就不是一个让你与众不同的好方法！

亚马逊 S3

亚马逊 S3 (简单存储服务)是一种简单且相对便宜的安全存储大量数据的方式。典型的 Spark 工作流是从 S3 存储桶或其他源读取数据，执行一些转换，并将处理后的数据写回另一个 S3 存储桶。

亚马逊电子病历

亚马逊 EMR (Elastic Map Reduce)是一个大数据平台，将多个节点同步到一个可扩展的集群中，可以处理大量数据。如上所述，我们将作业提交给集群的主节点，它会计算出运行作业的最佳方式。然后，主节点相应地将任务分配给工作节点。

在 Amazon EMR 上设置您的环境

首先，创建一个 AWS 帐户并登录控制台。我建议现在花时间创建一个 IAM 用户并删除你的根访问键。

更新:我已经创建了一个 AWS 快速设置指南 引导您如何创建 IAM 用户和角色，创建一个 S3 桶，并配置 AWS CLI。

在本教程中，我将使用美国西部地区(俄勒冈州)。您可以通过右上方的下拉菜单更改您所在的地区:

关于 AWS 费用的警告:你需要提供一张信用卡来创建你的账户。 为了保持成本最低，不要忘记在使用完 EMR 集群后终止它 。对于本指南，我们将使用 m5.xlarge 实例，在撰写本文时，每小时的成本为 0.192 美元。此外，在亚马逊 S3 上托管数据每月会收取少量费用——这一费用会随着你托管的数据量而增加。为避免持续成本，请在使用后删除存储桶。

在亚马逊 S3 上存储配置文件

为了在集群的所有节点上安装有用的包，我们需要创建文件emr_bootstrap.sh并将其添加到 S3 上的 bucket 中。

#!/bin/bash
sudo pip install -U \
    matplotlib \
    pandas

使用控制台中的“查找服务”搜索框搜索 S3，导航至该城市:

点击“创建存储桶”，填写“存储桶名称”字段，点击“创建”:

点击“上传”、“添加文件”，打开您创建的文件emr_bootstrap.sh。点击“上传”上传文件。

创建密钥对文件

从控制台主页导航到 EC2:

选择“密钥对”

单击“创建密钥对”，然后输入名称并单击“创建”。

你的文件emr-key.pem应该会自动下载。把它存放在一个你会记住的目录里。我把我的.pem文件放在~/.ssh里。确保这个文件不要放在你的 GitHub repos 或任何其他公共场所，以保证你的 AWS 资源更加安全。

在 Amazon EMR 上创建集群

从您的控制台导航到 EMR，单击“创建集群”，然后“转到高级选项”。

进行以下选择，从“版本”下拉列表中选择最新版本并选中“Spark”，然后单击“下一步”。

选择“us-west-2a 中的默认”选项“EC2 子网”下拉列表，将您的实例类型更改为 m5.xlarge 以使用最新一代的通用实例，然后单击“下一步”。

命名您的集群，添加emr_bootstrap.sh作为引导操作，然后单击“Next”。你的引导动作的脚本位置将是你在教程前面上传emr_bootstrap.sh的 S3 文件路径。您的引导操作将在集群中的每个节点上安装您指定的软件包。

选择您之前创建的密钥对，然后单击“创建集群”。您的集群将需要几分钟的时间来启动，但是一旦它进入“等待”状态，您就可以进入下一步了——使用 Jupyter 笔记本连接到您的集群。

使用 Jupyter 笔记本连接到您的集群

导航至左侧面板中的“笔记本”。点击“创建笔记本”并按照以下步骤操作。

命名您的笔记本并选择您刚刚创建的集群。

一旦你的笔记本“准备好”，点击“打开”。您现在已经准备好开始在云上运行 Spark 了！

连接到 S3 上的数据源

在笔记本的第一个单元格中，导入您要使用的包。例如:

from pyspark.sql import functions as F

您应该得到以下输出:

注意:SparkSession 在笔记本中被自动定义为spark —您必须在创建脚本作为 Spark 作业提交时自己定义。

接下来，让我们从 S3 导入一些数据。我们将使用亚马逊在公共桶中提供的数据。让我们看看亚马逊客户评论数据集。具体来说，我们来看看书评:

input_bucket = 's3://amazon-reviews-pds'
input_path = '/parquet/product_category=Books/*.parquet'
df = spark.read.parquet(input_bucket + input_path)df.show()

input_path中的/*.parquet语法告诉 Spark 读取s3://amazon-reviews-pds/parquet/product_category=Books/桶目录中的所有.parquet文件。

我将很快推出一个关于 PySpark DataFrame API 的数据争论的教程，但是现在，请查看 DataCamp 的这个优秀的备忘单开始吧。

下一个

一旦你在 Jupyter 笔记本上测试了你的 PySpark 代码，把它移到一个脚本中，然后用 Spark 和 AWS 命令行界面创建一个生产数据处理工作流。然后，你准备好安排你的气流火花工作。

保持联系

感谢您的阅读！请让我知道你是否喜欢这篇文章，或者你是否有任何批评。如果这篇指南对你有用，一定要关注我，这样你就不会错过我以后的任何文章。

如果你在一个数据项目上需要帮助或者想打声招呼，在LinkedIn上联系并给我发消息。干杯！

R 编程入门

原文：https://towardsdatascience.com/getting-started-with-r-programming-2f15e9256c9?source=collection_archive---------8-----------------------

使用数据科学中第二常用的编程语言 R 进行端到端的数据分析。

(Source: https://hackernoon.com/5-free-r-programming-courses-for-data-scientists-and-ml-programmers-5732cb9e10)

介绍

r 是一种专注于统计和图形分析的编程语言。因此，它通常用于统计推断、数据分析和机器学习。r 是目前数据科学就业市场上最受欢迎的编程语言之一(图 1)。

Figure 1: Most Requested programming languages for Data Science in 2019 [1]

R 可从r-project.org安装，R 最常用的集成开发环境(IDE)之一当然是 RStudio 。

有两种主要类型的包(库)可用于向 R 添加功能:基本包和分布式包。安装 R 时会附带基础包，分布式包可以使用 CRAN 免费下载。

一旦安装了 R，我们就可以开始做一些数据分析了！

示范

在本例中，我将带您浏览对手机价格分类数据集的端到端分析，以预测手机的价格范围。我在这次演示中使用的代码在我的 GitHub 和 Kaggle 账户上都有。

导入库

首先，我们需要导入所有必需的库。

可以使用install . packages()命令在 R 中安装软件包，然后使用 library() 命令加载。在这种情况下，我决定先安装 PACMAN(软件包管理工具)，然后用它来安装和加载所有其他软件包。PACMAN 使加载库更容易，因为它可以在一行代码中安装和加载所有必要的库。

导入的包用于添加以下功能:

dplyr: 数据处理与分析。
ggplot2: 数据可视化。
里约:数据导入导出。
gridExtra: 制作可以在页面上自由排列的图形对象。
比例尺:用于缩放图中的数据。
ggcorrplot: 到在后台使用 ggplot2 可视化相关矩阵。
脱字符:用于训练和绘制分类和回归模型。
e1071: 包含执行机器学习算法的函数，如支持向量机、朴素贝叶斯等…

数据预处理

我们现在可以继续加载数据集，显示它的前 5 列(图 2)并打印每个特性的主要特征的摘要(图 3)。在 R 中，我们可以使用 < - 操作符创建新的对象。

Figure 2: Dataset Head

summary 函数为我们提供了数据集中每个要素的简要统计描述。根据所考虑特征的性质，将提供不同的统计数据:

数值特征:均值、中位数、众数、极差、四分位数。
因子特征:频率。
因子和数字特征的混合:缺失值的数量。
人物特征:长班之长。

Factors 是 R 中使用的一种数据对象，用于将数据(例如整数或字符串)分类并存储为级别。例如，它们可用于一个特征的热编码或创建条形图(我们将在后面看到)。因此，当处理具有很少唯一值的列时，它们特别有用。

Figure 3: Dataset Summary

最后，我们现在可以使用下面的代码检查我们的数据集是否包含任何非数字(NaNs)值。

从图 4 中我们可以看到，没有发现缺失的数字。

Figure 4: Percentage of NaNs in each feature

数据可视化

我们现在可以通过绘制数据集的关联矩阵来开始我们的数据可视化(图 5)。

Figure 5: Correlation Matrix

接下来，我们可以开始使用条形图和箱线图分析单个特征。在创建这些图之前，我们需要首先将考虑的特征从数值转换为因子(这允许我们将数据分箱，然后绘制分箱后的数据)。

我们现在可以通过将它们存储在三个不同的变量(p1，p2，p3)中来创建三个条形图，然后将它们添加到grid . arrange()中来创建一个子图。在这种情况下，我决定检查蓝牙，双卡和 4G 功能。正如我们从图 6 中看到的那样，该数据集中考虑的手机中，略多的手机不支持蓝牙，是双卡，支持 4G。

Figure 6: Bar Plot Analysis

这些图是使用 R ggplot2 库创建的。当调用 ggplot() 函数时，我们创建一个坐标系，我们可以在其上添加图层[2]。

我们给 ggplot() 函数的第一个参数是我们将要使用的数据集，而第二个参数是一个美学函数，我们在其中定义我们想要绘制的变量。然后，我们可以继续添加其他参数，如定义所需的几何函数(如柱状图、散点图、箱线图、直方图等)，添加绘图主题、轴限制、标签等…

进一步分析，我们现在可以使用 prop.table() 函数计算不同案例之间差异的精确百分比。从结果输出(图 7)中我们可以看到，50.5%的考虑移动设备不支持蓝牙，50.9%是双卡，52.1%有 4G。

Figure 7: Classes Distribution Percentage

我们现在可以继续使用之前使用的相同技术创建 3 个不同的盒状图。在这种情况下，我决定研究更多的电池电量、手机重量和 RAM(随机存取存储器)如何影响手机价格。在这个数据集中，我们得到的不是实际的手机价格，而是一个价格范围，表示价格有多高(从 0 到 3 的四个不同级别)。

结果总结在图 8 中。增加电池功率和 RAM 会导致价格上涨。相反，更贵的手机似乎总体上更轻。在 RAM 与价格范围图中，有趣的是记录了总体分布中的一些异常值。

Figure 8: Box Plot Analysis

最后，我们现在将检查前置和主摄像头的百万像素摄像头质量分布(图 9)。有趣的是，前置摄像头分布似乎遵循指数衰减分布，而主摄像头大致遵循均匀分布。如果你有兴趣了解更多关于概率分布的信息，你可以在这里找到更多信息。

Figure 9: Histogram Analysis

机器学习

为了执行我们的机器学习分析，我们需要首先将我们的因素变量转换为数字形式，然后将我们的数据集划分为训练集和测试集(75:25 的比率)。最后，我们将训练集和测试集分成特征和标签( price_range )。

现在是时候训练我们的机器学习模型了。在这个例子中，我决定使用支持向量机(SVM) 作为我们的多类分类器。使用 R summary() 我们可以检查我们训练好的模型的参数(图 10)。

Figure 10: Machine Learning Model Summary

最后，我们现在可以测试我们的模型，在测试集上做一些预测。使用 Rconfusion matrix()函数，我们就可以得到我们的模型准确性的完整报告(图 11)。在这种情况下，记录的准确度为 96.6%。

Figure 11: Model Accuracy Report

我希望你喜欢这篇文章，谢谢你的阅读！

联系人

如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:

领英
个人博客
个人网站
中等轮廓
GitHub
卡格尔

文献学

[1]2019 年哪些语言对数据科学家很重要？Quora。访问:https://www . quora . com/2019 年哪些语言对数据科学家很重要

[2] R 代表数据科学，Garrett Grolemund 和 Hadley Wickham。访问网址:https://www . bio inform . io/site/WP-content/uploads/2018/09/rdata science . pdf

Python 随机优化入门

原文：https://towardsdatascience.com/getting-started-with-randomized-optimization-in-python-f7df46babff0?source=collection_archive---------11-----------------------

如何用 Python 的 mlrose 包使用随机化优化算法解决简单的优化问题

mlrose 提供实现一些最流行的随机化和搜索算法的功能，并将它们应用于一系列不同的优化问题领域。

在本教程中，我们将讨论什么是优化问题，并逐步通过一个例子来说明如何使用 mlrose 来解决它们。这是三个系列教程中的第一个。第二部分可以在这里找到，第三部分可以在这里找到。

什么是优化问题？

Russell 和 Norvig (2010) 将优化问题定义为“目标是根据目标函数找到最佳状态”的问题

“国家”的含义取决于问题的背景。状态的一些例子是:

机器学习模型中使用的权重，例如神经网络；
在国际象棋棋盘上放置棋子；
在一个国家的地图上的所有城市的游览中所访问的城市的顺序；
为世界地图上的国家选择的颜色。

对我们来说，重要的是状态可以用数字来表示，理想情况下是一个一维数组(或向量)。

“最佳”的含义是由数学公式或函数(称为目标函数、适应度函数、成本函数或损失函数)定义的，我们希望最大化或最小化它。该函数接受一个状态数组作为输入，并返回一个“适合度”值作为输出。

输出适应值允许我们将输入的状态与我们可能考虑的其他状态进行比较。在这种情况下，状态数组的元素可以被认为是函数的变量(或参数)。

因此，优化问题可以简单地认为是一个数学函数，我们希望通过选择每个参数的最佳值来最大化/最小化它。

例子

五维一最大优化问题涉及找到使适应度(x)=x0+x1+x2+x3+x4最大化的状态向量 x = [ x0，x1，x2，x3，x3，x4 。

如果 x 的每个元素只能取值 0 或 1，那么这个问题的解就是x=【1，1，1，1，1】。当 x 设为等于这个最优值时，适应度(x) = 5，它可以取的最大值。

为什么使用随机优化？

对于上面给出的一个最大值的例子，即使解决方案不是立即显而易见的，也有可能计算所有可能的状态向量的适应值， x ，然后选择这些向量中的最佳向量。

然而，对于更复杂的问题，这不能总是在合理的时间内完成。随机化优化克服了这个问题。

随机化优化算法通常从初始“最佳”状态向量(或多个状态向量的群体)开始，然后随机生成新的状态向量(通常是当前“最佳”状态的邻居)。

如果新状态比当前的“最佳”状态更好，则新向量成为新的“最佳”状态向量。

重复该过程，直到不再可能找到比当前“最佳”状态更好的状态向量，或者如果在预先指定的尝试次数内找不到更好的状态向量。

不保证随机优化算法将找到给定优化问题的最优解(例如，该算法可能找到适应度函数的局部最大值，而不是全局最大值)。

然而，如果在算法的每一步进行足够多的尝试来寻找更好的状态，那么算法将返回问题的“好”解决方案。

在搜索优化问题的最优解所花费的时间和最终找到的解的质量之间存在权衡。

用 mlrose 解决优化问题

使用 mlrose 解决优化问题包括三个简单的步骤:

定义一个适应度函数对象。
定义一个优化问题对象。
选择并运行随机优化算法。

为了说明这些步骤中的每一个，我们将通过 8 皇后优化问题的例子来工作，如下所述:

例如:8-皇后

在国际象棋中，皇后是棋盘上最有力的棋子。它可以攻击同一行、同一列或同一对角线上的任何棋子。在 8 皇后问题中，给你一个 8 x 8 的棋盘，上面有 8 个皇后(没有其他棋子),目的是将皇后放在棋盘上，这样它们就不会互相攻击。

显然，在这个问题的最佳解决方案中，棋盘的每一列都有一个皇后。所以我们只需要确定每个皇后的行位置，我们可以将这个问题的状态向量定义为 x = [ x0，x1，x2，x3，x4，x5，x6，x7 ，其中 x i 表示皇后在 i 列中的行位置(对于 i = 0，1，…，7)。

因此，下图中的棋盘可以用状态向量 x = [6，1，7，5，0，2，3，4]来描述，其中假设棋盘的左下角位于第 0 列和第 0 行。

这不是 8 皇后问题的最佳解决方案，因为列 5、6 和 7 中的三个皇后正在对角地攻击彼此，列 2 和 6 中的皇后也是如此。

在开始这个例子之前，您需要导入 mlrose 和 Numpy Python 包。

import mlrose
import numpy as np

定义一个适应度函数对象

解决任何优化问题的第一步是定义适应度函数。这是我们最终想要最大化或最小化的函数，并且可以用来评估给定状态向量的适合度， x 。

在 8 皇后问题的上下文中，我们的目标是找到一个不存在攻击皇后对的状态向量。因此，我们可以将我们的适应度函数定义为评估给定状态的攻击皇后对的数量，并尝试最小化该函数。

mlrose 包含一系列常见优化问题的预定义适应度函数类，包括 N 皇后问题家族(8 皇后是其中一员)。预定义的Queens()类包括上述(8-)皇后适应度函数的实现。

我们可以为这个类初始化一个适应性函数对象，如下所示:

fitness = mlrose.Queens()

或者，我们可以把 8 皇后问题看作是一个目标是找到一个状态向量的问题，在这个状态向量中，所有的皇后对不会互相攻击。在这种情况下，我们可以将我们的适应度函数定义为评估给定状态的非攻击皇后对的数量，并尝试最大化该函数。

8-Queens 健身函数的定义不同于 mlrose 的预定义Queens()类所使用的定义，因此要使用它，我们需要创建一个自定义健身函数。这可以通过首先用形式为fitness_fn(state, **kwargs)的签名定义一个适应度函数来完成，然后使用 mlrose 的CustomFitness()类来创建一个适应度函数对象，如下所示:

定义一个优化问题对象

一旦我们创建了一个适应度函数对象，我们就可以使用它作为优化问题对象的输入。在 mlrose 中，优化问题对象被用来包含我们试图解决的优化问题的所有重要信息。

mlrose 提供了定义三种优化问题对象的类:

DiscreteOpt():用于描述离散状态优化问题。离散状态优化问题是状态向量的每个元素只能取一组离散的值。在 mlrose 中，这些值被假定为 0 到( max_val -1)范围内的整数，其中 max_val 在初始化时定义。
ContinuousOpt():用于描述连续状态的优化问题。连续状态优化问题类似于离散状态优化问题，除了状态向量中的每个值可以取在初始化时指定的 min_val 和 max_val 之间的连续范围内的任何值。
TSPOpt():用于描述旅行推销员(或旅游)优化问题。旅行销售人员优化问题不同于前两种问题类型，因为我们知道最优状态向量的元素是整数 0 到( n -1)，其中 n 是状态向量的长度，我们的目标是找到这些整数的最优排序。

8 皇后问题是离散状态优化问题的一个例子，因为状态向量的每个元素必须取 0 到 7 范围内的整数值。

为了初始化离散状态优化问题对象，需要指定问题长度(即状态向量的长度，在本例中为 8)； max_val ，如上定义(也是 8)；在前一步骤中创建的适应度函数对象；以及该问题是最大化还是最小化问题。

对于这个例子，我们将使用上面定义的两个适应度函数对象中的第一个，所以我们想解决一个最小化问题。

problem = mlrose.DiscreteOpt(length = 8, fitness_fn = fitness,
                             maximize = False, max_val = 8)

然而，如果我们选择使用第二个(自定义)适应度函数对象，我们将处理一个最大化问题，因此，在上面的代码中，我们必须将最大化参数设置为真而不是假(此外还要更改适应度 _fn 参数的值)。

选择并运行随机优化算法

现在我们已经定义了一个优化问题对象，我们准备解决我们的优化问题。mlrose 包括(随机重启)爬山、随机爬山(也称为随机爬山)、模拟退火、遗传算法和 MIMIC(互信息最大化输入聚类)随机优化算法的实现。

对于离散状态和旅行推销员优化问题，我们可以选择这些算法中的任何一个。但是，在 MIMIC 的情况下，不支持连续状态问题。

对于我们的例子，假设我们希望使用模拟退火。要实现这个算法，除了定义一个优化问题对象，还必须定义一个调度对象(指定模拟退火温度参数如何随时间变化)；算法在每一步寻找“更好”状态的尝试次数(max _ attempts)；以及算法总体上应该运行的最大迭代次数( max_iters )。如果需要，我们还可以指定算法的开始状态( init_state )。

为了指定时间表对象， mlrose 包括预定义的几何、算术和指数衰减的衰减时间表类，以及一个用于定义您自己的衰减时间表的类，其定义方式类似于我们创建定制适应度函数对象的方式。

假设我们希望使用指数衰减时间表(具有默认参数设置)；在每个算法步骤中，最多尝试 10 次以找到“更好”的状态；将我们自己限制在算法的最多 1000 次迭代；并且从初始状态 x = [0，1，2，3，4，5，6，7]开始。这可以使用下面的代码来完成。

给定提供给它的参数值以及该状态的适合度值，该算法返回它能找到的最佳状态。

The best state found is:  [6 4 7 3 6 2 5 1]The fitness at the best state is:  2.0

运行这段代码为我们提供了 8 皇后问题的一个好的解决方案，但不是最优的解决方案。该算法找到的解决方案如下图所示:

解状态的适应度值为 2，表示棋盘上还有两对进攻皇后(0 列和 3 列的皇后；和第 6 排的两个皇后)。理想情况下，我们希望我们的解决方案的适应值为 0。

我们可以通过调整算法的参数来尝试改进我们的解决方案。算法的任何参数都可以调整。然而，在这种情况下，让我们只关注调整 max_attempts 参数，并将其从 10 增加到 100。

这一次当我们运行我们的代码时，我们得到一个适应度值为 0 的解，表明棋盘上没有一个皇后在互相攻击。

The best state found is:  [4 1 3 5 7 2 0 6]The fitness at the best state is:  0.0

这可以从下面得到证实:

摘要

在本教程中，我们定义了优化问题的含义，并通过一个简单的例子说明了如何使用 mlrose 来解决这些问题。这就是解决大多数优化问题所需的全部内容。

然而，有一种类型的问题我们到目前为止只是简单地涉及了一下:旅行销售人员优化问题。在本教程的第 2 部分，我们将通过一个例子来说明如何使用 mlrose 来解决这类问题。你可以在这里找到第二部分。

要了解更多关于 mlrose 的信息，请访问这个包的 GitHub 资源库，这里有。

Genevieve Hayes 博士是数据科学家、教育家、人工智能和分析专家，供职于Genevieve Hayes Consulting。你可以在LinkedIn或者Twitter上关注她。她还是 价值驱动数据科学 的主持人，这是一个每月两次的播客，面向寻求最大化其数据和数据团队价值的企业。

想要发掘企业数据的价值，但不知道从哪里开始？下载免费的数据科学项目发现指南。T50**

系统概况

TensorRec 是一个用于构建推荐系统的 Python 包。TensorRec 推荐系统消耗三条输入数据:用户特征、项目特征和交互。基于用户/项目特征，系统将预测推荐哪些项目。在拟合模型时使用相互作用:将预测与相互作用进行比较，并计算损失/惩罚，系统学习减少损失/惩罚。

当我们制作系统原型时，我们将处理三个主要问题:我们如何处理交互，我们如何处理特征，以及我们如何构造推荐器本身。

交互数据

对于这个例子，我们将使用 MovieLens 数据集。该数据集包含电影的 1-5 星评级、关于这些电影的元数据以及用户应用于电影的标签。对于我们的第一个原型，我们将关注评级，但我们稍后将返回到其他元数据。

原始形式的评级如下所示:

userId, movieId, rating, timestamp
1,      1,       4.0,    964982703
1,      3,       4.0,    964981247
1,      6,       4.0,    964982224
1,      47,      5.0,    964983815
1,      50,      5.0,    964982931
1,      70,      3.0,    964982400
...

每行代表一个等级:一个用户对一部电影的看法。我们将使用这些评分作为我们的互动。我们训练这个系统的第一步是接收和格式化这些交互数据。首先，我们读入收视率的 CSV 文件。

在这一点上，我们将通过洗牌和分割评级来将评级分为训练和测试集。我们的原型将在训练集上进行训练，我们将使用测试集来评估它们的成功。像这样随机分割训练集/测试集是不成熟的，并且有更严格的模型评估技术，但是对于这个例子来说是快速和清晰的。

接下来，我们将这些评级重新组织到一个稀疏矩阵中。在这个矩阵中，每行代表一个用户，每列代表一部电影。这个矩阵中的第[ i，j 个值是用户 i 与电影 j 的交互。

协作过滤器原型

协作过滤器是一种算法，它可以学习哪些用户有相似的品味，并根据相似用户的喜好向用户推荐商品。一种常见的方法是通过矩阵分解。在矩阵分解中，我们必须学习两个矩阵(用户表示和项目表示),当它们相乘时，近似交互:

From Wikipedia

在这种情况下， W 的行是用户表示， H 的列是项目表示， V 中的值是交互。需要学习 W 和 H 以产生v的最佳近似值

W 的宽度和 H 的高度是相同的——这个共享尺寸被称为“组件数量”具有更多组件的模型正在学习更复杂的用户和项目表示，但这可能会导致过度拟合训练数据。总的来说，我们希望将大量信息压缩到小的表示中。出于这个原因，在我们的原型中，我任意选择使用 5 个组件。当进一步构建原型时，我们应该尝试增加和减少组件的数量，并警惕过度拟合。

如果只给出单位矩阵作为用户/项目特征，TensorRec 将默认执行矩阵分解。这些单位矩阵通常被称为“指示器特征”

我们现在已经创建了两个指标特征矩阵，构建了一个包含 5 个组件的简单协作过滤器模型，并对模型进行了拟合！

接下来，当然，我们将想看看模型的表现如何。

为了做到这一点，我们将查看一个名为“K 处召回”的指标。Recall@K 表示，对于普通用户来说，他们的测试项目在预测排名中排在前 K 的百分比。换句话说，如果我们的 recall@10 值为 0.06，那么我喜欢的某部电影就有 6%的机会进入我的十大推荐。

Recall@K 对于许多推荐系统来说是一个很好的指标，因为它模拟了推荐产品的行为:如果一个电影网站只向我展示我的前 10 个推荐，那么他们的算法将希望有效地将我喜欢的电影放入我的前 10 个推荐中。

在计算召回之前，我们要决定哪些交互应该算作“喜欢”在这种情况下，我选择使用所有评分至少为 4.0 的评分作为“喜欢”，并忽略其他评分。

太好了！让我们来看看结果:

Matrix factorization collaborative filter:
Recall at 10: Train: 0.0008 Test: 0.0010

…不太好。这些结果告诉我们，在测试集电影中，喜欢的电影进入前 10 名的几率只有 0.1%。这个推荐系统是无效的，我们会想办法改进它。

损失图

配置 TensorRec 系统的一种方法是改变损耗图。损失图包含预测和交互，并计算系统在学习时试图减少的惩罚(损失)。

默认情况下，TensorRec 使用 RMSE(均方根误差)作为损失图。这意味着 TensorRec 正试图精确地估计交互的值:如果我给一部电影打 4.5 分，TensorRec 正试图产生一个精确的 4.5 分的预测分数。

这很直观，但它并不符合推荐系统在许多产品中的工作方式:一个电影网站不需要准确预测我的评级，它只需要能够将我喜欢的电影排在我不喜欢的电影之上。由于这个原因，许多系统通过“学习排序”来运行。我们可以通过使用称为 WMRB 的损耗图来使 TensorRec 系统以这种方式工作。

WMRB，代表“加权边际-等级批量”，的工作原理是随机抽取用户没有互动过的项目样本，并将他们的预测与用户喜欢的项目进行比较。随着时间的推移，这将用户喜欢的项目推到排名的顶部。

我们可以告诉 TensorRec 使用 WMRB，方法是在构建模型时指定它，并在拟合模型时指定样本批次的大小。在这种情况下，我们希望只训练正面评级(≥4.0)的模型，因此 WMRB 会将这些评级推到顶部。

让我们来看看结果:

WMRB matrix factorization collaborative filter:
Recall at 10: Train: 0.1098 Test: 0.0776

好多了！我们已经从一个喜欢的项目进入前 10 名的 0.1%的机会一直到 7.76%的机会。这是一个右损失函数有多大影响力的例子。TensorRec 允许您指定和定制自己的损失图，您可以在这里看到更多示例损失图。

添加元数据要素

为了继续实验，我们应该尽量利用其他可用的数据。在 MovieLens 示例中，我们可以使用电影元数据，比如电影的类型，来丰富推荐内容。

原始格式的电影元数据文件如下所示:

movieId, title,                    genres
1,       Toy Story (1995),         Adventure|Animation|Children|C...
2,       Jumanji (1995),           Adventure|Children|Fantasy
3,       Grumpier Old Men (1995),  Comedy|Romance
4,       Waiting to Exhale (1995), Comedy|Drama|Romance
...

首先，我们要读取这些数据，将电影映射到我们的内部 id，并跟踪每部电影的类型。然后我们将使用 Scikit 的 multilabel binary izer对流派标签进行二进制化。二值化的输出将成为我们新的推荐系统的特征。

运行该程序将打印出原始元数据和二进制类型的示例:

Raw metadata example:
['movieId', 'title', 'genres']
[0, 'Toy Story (1995)', ['Adventure', 'Animation', 'Children', 'Comedy', 'Fantasy']]Binarized genres example for movie Toy Story (1995):
[0 0 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0]

基于内容的推荐

既然我们已经有了关于我们的项目的元数据，我们可以尝试的一件事就是仅仅基于项目元数据进行推荐。

为此，我们将配置一个 TensorRec 模型，对项目特征使用传递表示图。对我们来说，这意味着项目表示将与传入的项目特征相同(只是电影类型)，并且用户表示将反映用户有多喜欢该特定类型。

太好了！让我们来看看结果:

Content-based recommender:
Recall at 10: Train: 0.0471 Test: 0.0130

它没有排名协作过滤器好，但召回率为 1.3%，比我们的第一个协作过滤器有效得多。

这个系统有一个主要的弱点:仅仅是流派本身并不能很好的描述，也不能提供足够的信息来做出明智的推荐。如果我们有更多的描述性元数据(更多的标签、演员、子流派等)，我们可能会在这个基于内容的推荐系统上取得更大的成功。

另一方面，该系统有一个主要优点:通过仅依赖元数据特征，而不使用指示符特征，我们可以推荐在训练模型时不存在的电影。类似地，如果我们有有价值的用户元数据，我们可以避免使用用户指示器功能，并为从未与电影互动过的用户做出预测。这被称为“冷启动”推荐。

混合模型

我们知道我们的排名协作过滤器给了我们最好的结果，但似乎使用电影元数据也有一些价值。让我们将这两者结合起来:我们将使用指示器特性来获得协作过滤器的优势，我们还将使用内容特性来利用元数据。像这样结合了协同过滤和基于内容的推荐的系统被称为“混合”模型。

为此，我们将两组特征叠加在一起:

太好了！让我们来看看结果:

Hybrid recommender:
Recall at 10: Train: 0.1196 Test: 0.0794

凭借 7.94%的召回率，这是我们迄今为止最强的推荐系统。与纯协作过滤器 7.76%的结果相比，差异并不明显，但仍然是一个进步。如果我们使用比流派更多的元数据，我们可能会看到更大的影响。

提出建议

我们有一个经过训练的模型，现在我们可以使用这个模型为我们的用户提供建议。我们通过将用户的特征向量和所有项目特征传递给predict_rank()并检查结果排名来做到这一点:

这个代码片段将为用户 432 打印出前 10 个推荐。我选择用户 432 是因为我熟悉他们评价过的电影，所以我觉得我可以站在他们的立场上判断他们的推荐。我们应该注意，用户 432 已经评级的电影仍将被包括在内——如果我们想要过滤掉这些电影，我们将需要通过后处理步骤来完成。

让我们看看用户 432 的训练数据，看看他们喜欢什么类型的电影:

User 432 liked:
Usual Suspects, The (1995)
Pulp Fiction (1994)
Silence of the Lambs, The (1991)
Reservoir Dogs (1992)
Shawshank Redemption, The (1994)
Kill Bill: Vol. 1 (2003)
Social Network, The (2010)
Trainspotting (1996)
Arrival (2016)
My Big Fat Greek Wedding (2002)

一些犯罪，一些黑色喜剧，和一个著名的爱塔伦蒂诺。让我们看看用户 432 对我们混合模型的建议:

User 432 recommendations:
Seven (a.k.a. Se7en) (1995)
Usual Suspects, The (1995)
Pulp Fiction (1994)
Silence of the Lambs, The (1991)
Fargo (1996)
American Beauty (1999)
Fight Club (1999)
Shawshank Redemption, The (1994)
Departed, The (2006)
Memento (2000)

更多带有明显黑色喜剧倾向的犯罪电影！这看起来一目了然，但让我们检查用户 432 的测试电影:

User 432's held-out movies:
Fargo (1996)
American History X (1998)
Fight Club (1999)
Dark Knight Rises, The (2012)

《法戈》和《搏击俱乐部》都符合用户 432 的推荐——这是一个很好的结果！对于这个特定用户，我们实现了 50%的召回率。

前进

为了继续完善我们的推荐系统，我们应该试验更多的表示、预测和损失图，为系统提供更多的元数据，以不同的方式设计这些元数据功能，以不同的方式管理交互/反馈数据，并优化系统的各种超参数。

我最近有机会拜访了 T2，讨论了设计和部署推荐系统时的许多设计选择。你可以在这里找到这次演讲的视频。

如果您有任何问题，请在这里提问或打开 GitHub 问题。

强化学习入门，开放 AI 健身房

原文：https://towardsdatascience.com/getting-started-with-reinforcement-learning-and-open-ai-gym-c289aca874f?source=collection_archive---------2-----------------------

使用 Q-learning 解决山地汽车环境。

这是强化学习和开放 AI 健身房系列文章的第三篇。第一部可以在这里找到，而第二部可以在这里找到。

介绍

强化学习(RL)是机器学习的一个分支，它通过与反馈可能延迟的环境进行交互来处理学习。

虽然 RL 是一个非常强大的工具，已经成功地应用于从优化化学反应到教计算机玩视频游戏的各种问题，但由于缺乏有趣和具有挑战性的实验环境，它在历史上一直很难开始。

这就是 OpenAI 健身房的用武之地。

OpenAI Gym 是一个 Python 包，包含一系列 RL 环境，从简单的“玩具”环境到更具挑战性的环境，包括模拟机器人环境和 Atari 视频游戏环境。

它的开发目标是成为 RL 研究的标准化环境和基准。

在本文中，我们将使用 OpenAI Gym 山地汽车环境来演示如何开始使用这个令人兴奋的工具，并展示如何使用 Q-learning 来解决这个问题。

本教程假设您的计算机上已经安装了 OpenAI Gym。如果你还没有这样做，安装说明可以在这里找到 Windows，在这里找到 Mac 或 Linux。

山地汽车问题

The OpenAI Gym Mountain Car environment

在 OpenAI 健身房网站上，对山地车问题描述如下:

汽车在一维轨道上，定位在两座“山”之间。目标是开车上右边的山；然而，这辆车的引擎不够强劲，不足以单程爬上这座山。所以，成功的唯一方法就是来回开车造势。

汽车在任何时间点的状态都由一个包含其水平位置和速度的向量给出。汽车在两山之间的山谷底部(大约在-0.5 的位置)静止不动地开始每一集，当汽车到达旗子(位置> 0.5)或移动 200 次后，该集结束。

在每次移动时，汽车有三个可用的动作:向左推、向右推或什么都不做，每次移动(包括什么都不做)都要罚 1 个单位。这意味着，除非他们能在不到 200 步的时间内找到爬山的方法，否则他们总的“奖励”将是-200 个单位。

从这个环境开始，按如下方式导入并初始化它:

import gym
env = gym.make(‘MountainCar-v0’)
env.reset()

探索环境

一旦导入了山地汽车环境，下一步就是探索它。所有 RL 环境都有一个状态空间(即环境中所有可能状态的集合)和一个动作空间(即环境中可以采取的所有动作的集合)。

您可以使用以下方式查看这些空间的大小:

> print(‘State space: ‘, env.observation_space)
State space: Box(2,)> print(‘Action space: ‘, env.action_space)
Action space: Discrete(3)

这告诉我们，状态空间表示一个 2 维的盒子，所以每个状态观察是 2 个(浮点)值的向量，并且动作空间包括三个离散的动作(这是我们已经知道的)。

默认情况下，这三个动作由整数 0、1 和 2 表示。但是，我们不知道状态向量的元素可以取什么值。这可以通过以下方法找到:

> print(env.observation_space.low)
[-1.2  -0.07]>print(env.observation_space.high)
[0.6  0.07]

由此我们可以看出，状态向量的第一个元素(代表小车的位置)可以取-1.2 到 0.6 范围内的任何值，而第二个元素(代表小车的速度)可以取-0.07 到 0.07 范围内的任何值。

当我们在本系列的第一篇文章中介绍 Q-learning 算法时，我们说过，只要每个状态-动作对被访问足够多的次数，它就能保证收敛。然而，在这种情况下，我们处理的是一个连续的状态空间，这意味着有无限多的状态-行动对，因此不可能满足这一条件。

解决这个问题的一种方法是使用深度 Q 网络(dqn)。DQNs 通过使用深度神经网络作为 Q 函数的近似器，将深度学习与 Q 学习结合起来。dqn 已经成功应用于开发能够玩 Atari 视频游戏的人工智能。

然而，对于像山地车问题这样简单的问题，这可能有点矫枉过正。

另一种方法是将状态空间离散化。一种简单的方法是将状态向量的第一个元素四舍五入到最接近的 0.1，将第二个元素四舍五入到最接近的 0.01，然后(为了方便起见)将第一个元素乘以 10，将第二个元素乘以 100。

这将状态-动作对的数量减少到 855 个，这使得满足 Q 学习收敛所需的条件成为可能。

q-学习回顾

在本系列的第一篇文章中，我们详细介绍了 Q-learning 算法。在执行该算法时，我们假设了一维状态空间，因此我们的目标是找到最优的 Q 表， Q ( s ， a )。

在这个问题中，由于我们处理的是二维状态空间，我们用 Q ( s1 ， s2 ， a )代替了 Q ( s ， a )，但除此之外，Q 学习算法基本保持不变。

概括地说，算法如下:

初始化 Q ( s1 、 s2 、 a )，将所有元素设置为小随机值；
观察当前状态，( s1 ，S2)；
根据探索策略，选择要采取的行动，a；
采取行动 a 并观察产生的奖励 r ，以及环境的新状态(S1’，S2’)；
根据更新规则更新 Q ( s1 、 s2 、 a ):

Q'(s1，s2，a) = (1 — w)Q(s1，s2，a) + w(r+dQ(s1 '，s2 '，argmax a' Q(s1 '，s2 '，a '))*

其中 w 为学习率 d 为折现率；

6.重复步骤 2–5，直到收敛。

开放式健身房的 Q-Learning

要在开放人工智能健身房实施 Q-learning，我们需要观察当前状态的方法；采取行动并观察行动的结果。这些可以按如下方式完成。

重置环境时，会返回环境的初始状态:

> print(env.reset())
array([-0.50926558, 0\. ])

要采取行动(例如， a = 2)，必须使用step()方法通过该行动“向前推进”环境。这将返回一个 4-ple，给出新的状态，奖励，一个布尔值，指示该情节是否已经终止(由于目标已经达到或 200 步已经过去)，以及任何附加信息(对于这个问题，它总是为空)。

> print(env.step(2))
(array([-0.50837305, 0.00089253]), -1.0, False, {})

如果我们假设一个ε-贪婪的探索策略，其中ε在总集数上线性衰减到指定的最小值(min_eps)，我们可以将上述所有内容与上一节中的算法放在一起，并产生以下用于实现 Q-学习的函数。

出于跟踪目的，该函数返回一个列表，其中包含 100 集每集的平均总奖励。它还使用env.render()方法可视化了最后 10 集的山地车运动。

环境只在最后 10 集可视化，而不是所有集，因为可视化环境会显著增加代码运行时间。

假设我们假设学习率为 0.2，贴现率为 0.9，初始ε值为 0.8，最小ε值为 0。如果我们运行 500 集的算法，在这些集的结尾，汽车已经开始明白它需要来回摇摆以获得爬山所必需的动量，但只能做到大约一半。

然而，如果我们将剧集数量增加一个数量级至 5000 集，到 5000 集结束时，汽车几乎每次都能完美地爬山。

Success!

绘制 5000 集的平均奖励与集数的关系图，我们可以看到，最初，平均奖励相当平稳，一旦达到最大 200 次移动，每次运行就终止。这是算法的探索阶段。

然而，在最后的 1000 集里，该算法采用了它通过探索学到的东西，并利用它来增加平均奖励，随着汽车学习爬山，这集现在以不到 200 个动作结束。

这个开发阶段是唯一可能的，因为给了算法足够的时间来探索环境，这就是为什么当算法只运行 500 集时，汽车不能爬山。

摘要

在本文中，我们展示了 RL 如何用于解决 OpenAI Gym 山地车问题。为了解决这个问题，有必要对我们的状态空间进行离散化，并对 Q-learning 算法进行一些小的修改，但是除此之外，所使用的技术与本系列第一篇文章中用于解决简单网格世界问题的技术相同。

但这只是 Open AI Gym 中可供用户使用的众多环境之一。对于有兴趣尝试自己在本文中学到的技能的读者，我建议尝试其他任何经典控制问题(此处提供),然后继续讨论 2D 盒子问题。

通过不断修改和构建 Q-learning 算法，应该有可能解决 OpenAI Gym 用户可用的任何环境。然而，和所有事情一样，第一步是学习基础知识。这就是我们今天成功做到的。

想了解更多关于价值驱动的数据科学的信息吗？ 加入我的邮件列表，让我的最新文章和建议直接发送到你的收件箱。

如何使用 Saturn Cloud 轻松创建、发布甚至共享云托管的 Jupyter 笔记本

原文：https://towardsdatascience.com/getting-started-with-saturn-cloud-jupyter-notebooks-b3f509a500ef?source=collection_archive---------8-----------------------

用土星云以闪电般的速度在 Jupyter 笔记本上创建、运行和协作的完全初学者指南

Image by Mary Gorobchenko from Pixabay

很难不爱 土星云 。

Saturn Cloud on YouTube

我最近开始使用一个名为土星云的托管 Jupyter 服务，它很神奇。

土星云让生活变得简单。

有了土星云，运行云托管的 Jupyter 笔记本变得异常容易。你点击几个按钮，你就完全设置好了。您可以创建、运行、发布甚至共享 Jupyter 笔记本了。你甚至可以与其他人合作！对于数据科学家来说，在他们的 Jupyter 笔记本上使用基于云的计算可能是最简单的方法。这是我发现的唯一能让你立即(而且毫无痛苦地)做到的方法！)发布并与全世界分享您的笔记本。

如果你想确切地看到设置土星云并共享你的笔记本有多快多轻松，向下滚动到“设置土星云”

Image by Peter Mill from Pixabay

数据科学环境正在发生变化。无论你是经验丰富的专业人士还是在校学生，分享你的工作变得越来越重要。几乎不费吹灰之力就能在笔记本上发布和协作，这太棒了！

没有其他简单的方法可以让您的团队共享笔记本进行协作。(至少在没有雇人安装的情况下不会...)如果你刚出校门，这是一个很大的坎！对于那些已经雇佣了昂贵的数据科学家的公司来说，这也是一个问题，他们需要专注于数据，而不是试图找到某种解决方法。有了土星云，就简单得可笑了。

Jupyter 笔记本

Jupyter 笔记本是最好的之一(免费！)工具，帮助您获得在大量数据相关领域高效工作所需的技能。它们是数据科学、机器学习、深度学习、人工智能等的理想工具。它们不仅可以保存代码，还可以保存丰富的文本元素，比如图像、图形、链接等等。这使得他们成为一个完美的地方，把分析，你的结果，以及正在发生的事情的描述。

还有大约一百万种方法可以定制您的 Jupyter 笔记本，让它变得令人惊叹…

** [## 技巧、窍门、诀窍和魔法:如何毫不费力地优化您的 Jupyter 笔记本电脑

让 Jupyter 笔记本变得更好、更快、更强、更光滑、更棒的完整初学者指南

towardsdatascience.com](/how-to-effortlessly-optimize-jupyter-notebooks-e864162a06ee)

如果你不熟悉 Jupyter 笔记本，一旦你知道你在做什么，使用它们会非常简单。开始使用 Anaconda 和 Jupyter 笔记本可能会有一些小问题，但是一旦你设置好了，就可以轻松使用它们，并且定制它们非常有趣。

如果您在设置时遇到问题，您可能想看看这篇文章:

[## 如何在 Mac 上成功安装 Anaconda(并让它实际工作)

正确安装 Anaconda 和修复可怕的“找不到 conda 命令”错误的快速而简单的指南

towardsdatascience.com](/how-to-successfully-install-anaconda-on-a-mac-and-actually-get-it-to-work-53ce18025f97)

尽管它们很容易使用，但要启动并运行云托管服务通常很困难。有很多人已经完全陷入了试图让他们的笔记本电脑运行云提供商的困境。

这就是土星云出现的地方！

土星云

如果你能弄清楚如何在亚马逊上订购东西，你就能在土星云上建立起来。

首先也是最重要的，土星云是由几个非常不可思议的人领导的:

雨果·史是蟒蛇的联合创始人。他在金融部门的数据科学领域工作了 5 年( JP 摩根、都铎投资公司和 Teza Technologies )。他还花了 5 年时间在 Enthought 和 Anaconda 开发数据科学工具。
塞巴斯蒂安·梅蒂是 Resolute.ai 的联合创始人。他在管理咨询方面有丰富的经验，他了解业务问题、战略和增长。

(你可以在这里找到相关信息。)

我很幸运能花一点时间和他们交谈，我可以告诉你，他们是一些非常不可思议的人。

完全披露:我有机会与他们交谈的原因是因为我为土星云做了一点工作(并得到了他们的报酬)。另一方面，这意味着我已经了解了他们是一个多么伟大的团队，我也有机会了解他们所提供的东西！

有一些服务提供云托管的 Jupyter 笔记本，如谷歌云和亚马逊 SageMaker 。这些都是很好的选择！但是它们并不总是那么容易使用。已经有很多关于让你的 Jupyter 笔记本在 Azure 、 Google Cloud 和 SageMaker 上运行的文章。当你阅读文章时，你可以看到一些平台肯定比其他平台更容易。如果你想把事情做好，通常需要很多步骤。

另一方面，建立土星云几乎毫不费力。

Image by Bolanu Teslaru Andrei from Pixabay

土星云是简单的，免费的，每个人都可以使用，完全不费力。

建立土星云

土星云的建立再简单不过了。你只需点击几个按钮就能让一切正常工作。大约需要两分钟。

如果你能弄清楚如何在亚马逊上订购东西，你就能在土星云上建立起来。

你可以在这里找到官方文档，但是你需要做的就是注册，然后你就会被放到你的仪表盘上。你将命名你的 Jupyter，选择你需要多少磁盘空间，你想要多少 ram/CPU/GPU，然后点击“创建”

您可能会在一分钟内启动并运行！

如果你是那种做完后忘记按停止键的人，确保你设置了自动关机，这样你就可以避免不必要的费用！

现在，您将看到一个指向您的 Jupyter 笔记本的链接和一个指向您的 Jupyter 实验室的链接。如果您想直接进入笔记本并开始使用，只需点击 Jupyter 笔记本的链接。您将看到一个启动 Jupyter 的播放按钮，一个停止 Jupyter 运行的停止按钮，一个修改服务器的编辑按钮，以及一个删除 Jupyter 的垃圾桶图标。

如果愿意，您甚至可以定制您的 Python 和 Linux 环境。如果您想在主目录中创建新环境，请查看高级选项。

就是这样！你被陷害了！

点击“去 Jupyter 笔记本”，建立一些不可思议的东西！

发布和共享

如果你想分享你的笔记本，这是难以置信的简单。你可以在这里找到详情。你只需要在你的 Jupyter 实验室里打开一个终端。

运行下面这行简单的代码，将“笔记本”替换为您的文件夹或笔记本的名称:

publish ~/notebooks

重新加载“如何发布”页面，您将在屏幕上看到已发布笔记本的名称。单击您的笔记本名称以配置其发布方式。您可能需要更改标题或添加描述。你肯定要决定笔记本是否保密，是否要让别人匿名执行你的笔记本。(这些执行的计算费用将记入您的账户。)一切都清晰得令人难以置信，所以不用担心会有惊喜！

Reload the page and click on your notebook

Make some changes if you feel like it!

现在你有一个发布的笔记本，看起来很棒！

与世界分享！

头过来自己看看！

有了土星云，你就拥有了 Jupyter 笔记本的所有优势，难以置信的速度，你甚至可以发布和分享你的作品。如果您厌倦了免费选项的缺点，并且您希望能够现在就开始并专注于您的数据，而不是跳过一堆圈，请看看土星云。

你还在等什么？

Image by Alexandr Ivanov from Pixabay

感谢阅读！像往常一样，如果你用这些信息做了什么惊人的事情，请在下面的评论中让大家知道，或者随时在 LinkedIn @annebonnerdata 上联系。

当然了，

开始使用 TabPy

原文：https://towardsdatascience.com/getting-started-with-tabpy-268f1da881cd?source=collection_archive---------5-----------------------

集成 Tableau 和 Python 的介绍

在任何领域，保持弹性和适应性，勤奋地接触新的工具和想法都是至关重要的。在像数据科学这样年轻的领域，自学和接受新的挑战变得越来越重要。当我进入数据科学训练营的最后一个月时，我回想起我在课程开始时看到的下图。

https://towardsdatascience.com/the-most-in-demand-skills-for-data-scientists-4a4a8db896db

Jeff Hale 浏览了几个职位列表网站，列出了数据科学职位招聘中最常见的技术技能。虽然我的训练营已经涵盖了大量的这些技能，但该计划不可能详尽地介绍与数据科学相关的技能。对于我没有学到的技能，仅仅因为它们没有在项目中介绍，并不意味着它们在我的职业生涯中不会有用。如果他们真的出现了，我想确保我准备好最好地利用现有的资源和我现有的知识来发展对这些技能的全面理解。

在这篇博客中，我决定深入其中一个我们在训练营中没有涉及到的相关概念。我之前听说过几次 Tableau，但是我从来没有用过。我了解它作为数据可视化工具的功能，可以轻松连接到多个数据源，并允许用户构建仪表板，但除此之外我知道的不多，所以我决定进行调查。一旦我下载了免费试用版(【https://www.tableau.com/products/trial】T2)，我就导入了一个 CSV 文件，这个文件是我在最近的项目中使用的，使用的数据来自詹姆斯·勒杜。这个文件包含了大量关于咖啡豆及其质量的数据。一旦导入了文件，我就可以在 Tableau 的一个表中查看数据，如下所示。

导入这个数据集后，我惊喜地发现，用以用户为中心的界面创建数据可视化非常简单。数据集功能列在工作簿的左侧，并且自动生成与每个豆的原产地相关联的地理坐标。我可以简单地将下面列出的度量拖到一个标有“列”和“行”的区域来生成可视化。

为了创建下面的热图，我将“纬度”和“经度”标签拖到“列”和“行”条目中，如下所示。

为了创建下面的散点图，我简单地将“香气”和“回味”字段拖到“列”和“行”条目中。接下来，我单击“香气”和“回味”标签右侧的箭头，选择标准偏差作为要显示的测量单位。

在创建了热图、散点图和其他一些基本的可视化之后，我对如何将 Python 和 Tableau 集成在一起感到好奇。我发现使用 API Tableau Python Server(tabby)可以很容易地实现这一点，它支持 Python 代码的远程执行。

用 TabPy 连接 Tableau

为了集成 TabPy 和 Tableau，我克隆了下面的 Github 库。

[## 表格/标签

动态执行 Python 代码并在 Tableau 可视化中显示结果-Tableau/tabby

github.com](https://github.com/tableau/TabPy)

接下来，使用存储库上的指令和这里的指令，我遵循以下步骤:

1.通过在命令行中键入以下命令来安装 tabby-server。

pip install tabpy-server

2.在克隆的存储库中，转到路径 tabpy-server/tabpy_server。

3.运行文件 tabpy.py。为了运行这个文件，我需要将文件common/config . py . template改为 common/config.py.

4.打开 Tableau 工作簿。按照路径帮助>设置和性能>管理外部服务连接到在 Tableau 上选择外部服务连接。

使用 TabPy 在 Tableau 中运行 Python

此时，连接被设置为在 Tableau 工作簿中运行 Python 代码。这可以通过填写计算字段来完成。

计算字段遵循以下示例中的常规格式。

https://github.com/tableau/TabPy

https://github.com/tableau/TabPy/blob/master/TableauConfiguration.md

函数可以以 SCRIPT_REAL、SCRIPT_INT、SCRIPT_STR、SCRIPT_BOOL 开头，代表函数返回类型。在引号内，输入被称为 _arg1、_arg2、…、_argN。右引号后面是逗号和参数定义。据 Tableau 网站上的一个社区帖子称，这些都是表格计算，所以必须聚合，比如 SUM()、MAX()、MIN()、ATTR()。

后续步骤

这篇博客文章仅仅提供了一个关于 Tableau 和 TabPy 的概述。还有很多其他功能。Tableau 可以连接到其他数据源，并可以创建不断更新的实时仪表板。我只是想了解如何将 Python 整合到 Tableau 中，当然还有其他方法可以整合 Python。下面的链接包括描述如何使用 Tableau 的其他资源以及合并 Python 的更高级方法，如机器学习模型。我计划利用这些资源继续我对 Tableau 的探索，并希望进一步提高我整合 Python 和 Tableau 知识的能力。

[## 用 TabPy 构建高级分析应用程序

回到 11 月，我们引入了 TabPy，使得在 Tableau 计算字段中使用 Python 脚本成为可能。当你…

www.tableau.com](https://www.tableau.com/about/blog/2017/1/building-advanced-analytics-applications-tabpy-64916) [## Tableau 和 Python 集成|Tableau 社区论坛

必须了解表格计算，包括了解维度和度量如何影响…

community.tableau.com](https://community.tableau.com/docs/DOC-10856) [## 使用 Tableau 实现数据可视化

作为数据分析师，我们的目标是以这样一种方式整理我们数据的洞察力，使每个看到它们的人都能够…

www.datacamp.com](https://www.datacamp.com/community/tutorials/data-visualisation-tableau) [## Tableau 培训和教程

学习你在做深入的数据准备和分析吗？负责给别人创作内容？如果你有画面…

www.tableau.com](https://www.tableau.com/learn/training?qt-training_tabs=1#qt-training_tabs)

TensorFlow.js 入门

原文：https://towardsdatascience.com/getting-started-with-tensorflow-js-d74c7085fc0b?source=collection_archive---------20-----------------------

学习 TensorFlow.js 的基本构建模块，并在浏览器中使用 JavaScript 构建您的第一个(简单)模型

TL；DR 通过 TensorFlow.js 了解机器学习的基础知识-张量、基本可视化和训练一个将千克转换为磅的简单模型

那么这个东西 TensorFlow.js 是什么？

TensorFlow.js 是一个用 JavaScript 开发和训练 ML 模型，并在浏览器或 Node.js 上部署的库

出于我们的目的，TensorFlow.js 将允许您建立机器学习模型(特别是深度神经网络)，您可以轻松地与现有或新的 web 应用程序集成。想想您的 ReactJs、Vue 或 Angular 应用程序通过机器学习模型的力量得到了增强。

在浏览器中运行本教程的完整源代码:

[## 入门-tensorflow-js - CodeSandbox

浏览器中 TensorFlow.js 基础教程。包括张量，可视化与 tfjs-vis 和建立一个…

codesandbox.io](https://codesandbox.io/s/getting-started-tensorflow-js-3182j?fontsize=14)

张量

张量是 TensorFlow 的主要构件。它们是 n 维数据容器。你可以把它们想象成 PHP、JavaScript 等语言中的多维数组。这意味着你可以用张量作为标量，向量和矩阵值，因为它们是这些的推广。

每个张量包含以下属性

rank -尺寸数量
shape -每个尺寸的大小
dtype -数值的数据类型

让我们从创建第一个张量开始:

检查它的等级:

这证实了你的张量是一维的。让我们检查一下形状:

[3]

具有 3 个值的一维。但是你怎么能看到这个东西的内容呢？

Tensor {kept: false, isDisposedInternal: false …}

不是你所期望的，对吗？张量是自定义对象，有一个输出其值的 print() 方法:

Tensor
    [1, 2, 3]

当然，这些值不一定只是数字。您可以创建字符串的张量:

您可以使用 tensor2d() 创建矩阵(或二维张量):

[2, 3]

当我们开始开发模型时，有一些实用的方法会很方便。先说 ones() :

Tensor
    [[1, 1, 1],
     [1, 1, 1],
     [1, 1, 1]]

您可以使用 reshape() 来改变张量的维度:

Tensor
    [[1, 2, 3],
     [4, 5, 6]]

张量数学

您可以使用 add() 进行元素相加:

Tensor
    [5, 7, 9]

和 dot() 来计算两个张量的点积:

Tensor
    [[9, 12],
     [9, 12]]

最后，我们来看看转置():

Tensor
    [[1, 3],
     [2, 4]]

您可以将转置视为输入张量的翻转轴版本。

看看所有的算术运算

使用 tfjs-vis 进行可视化

tfjs-vis 是一个小型的浏览器可视化库，旨在与 TensorFlow.js 一起使用。

让我们从创建一个简单的条形图开始。以下是我们的数据:

现在，让我们使用条形图()来呈现数据:

请注意，我们向渲染器提供了一个 DOM 元素作为图表的容器，当您想要将图表嵌入到应用程序中时，这可能会很方便。

让我们看看直方图()并创建一个示例图表:

这两个图表的 API 非常一致。让我们做一个散点图:

看看完整的 tfjs-vis API

训练你的第一个模型

是时候将你学到的东西付诸实践，并建立你的第一个模型。为了使它更真实，我们将尝试近似计算千克到磅的转换，它由以下函数描述:

让我们用它来准备数据并创建 2000 个训练示例:

我们将使用一种叫做监督学习的机器学习方式。简而言之，我们需要为我们的模型提供 2 个数组——X 是训练特征(千克)，y 是训练标签(相应的磅)。

TensorFlow.js 允许您使用 sequential() 构建分层模型。我们将非常简单:1 层，输入大小为 1，1 个学习参数:

并教它把千克换算成磅:

你的模型需要一个指标来知道做得有多好。在我们的例子中，这就是均方误差(MSE) 。一旦你知道了如何测量误差，你就需要知道如何利用数据最小化误差。在我们的例子中，这就是亚当优化器。

最后，我们使用这些数据为 100 个时期(我们的模型看到数据的次数)训练我们的模型，并请求洗牌。为什么洗牌？我们不希望我们的模型学习数据的排序，只是不同例子之间的关系。

训练完成后(可能需要一些时间)，您可以使用您的模型来预测 10 公斤对应的磅数:

10 kg to lbs: 22.481597900390625

看起来不错，对吧？

结论

祝贺你完成了机器学习理解之旅的第一部分。您了解了:

张量:n 维数据容器
tfjs-vis:与 TensorFlow.js 集成的可视化库
使用简单模型从千克预测磅

在浏览器中运行本教程的完整源代码:

[## 入门-tensor flow-js-code sandbox

浏览器中 TensorFlow.js 基础教程。包括张量，可视化与 tfjs-vis 和建立一个…

codesandbox.io](https://codesandbox.io/s/getting-started-tensorflow-js-3182j?fontsize=14)

我希望这篇教程只是让你渴望了解机器学习和 JavaScript 的可能性。准备好下一个了吗？

最初发表于https://www.curiousily.com。

建立机器学习模型(特别是深度神经网络)，可以轻松地与现有或新的 web 应用程序集成。想想您的 ReactJs、Vue 或 Angular 应用程序通过机器学习模型的强大功能得到了增强:

[## JavaScript 黑客的深度学习

建立机器学习模型(特别是深度神经网络)，您可以轻松地与现有或新的网络集成…

leanpub.com](https://leanpub.com/deep-learning-for-javascript-hackers)

通过使用 Python 从头构建机器学习模型、工具和概念，加深对它们的理解

[## 从零开始实践机器学习

“我不能创造的东西，我不理解”——理查德·费曼这本书将引导你走向更深的…

leanpub.com](https://leanpub.com/hmls)

Yelp API 入门

原文：https://towardsdatascience.com/getting-started-with-the-yelp-api-ac30915a77ae?source=collection_archive---------25-----------------------

面向小型企业的数据科学

构建一种算法来帮助小企业利用 Yelp 数据。

这篇文章是我们探索小企业如何利用 Yelp 数据更好地了解他们在当地市场的地位的系列文章之一。在深入研究事实之前，我想先告诉你一些这个项目的灵感和目标。当然，如果你只是对技术部分感兴趣，你可以在这里跳到它。

灵感

我在 2012 年搬到纽约市，在过去的七年里，我已经看到一些我最喜欢的当地企业倒闭。大牌品牌开始缓慢但稳步地进入。当然，我们可以整天谈论规模经济和租金上涨，但钱包的力量也允许大公司以小公司无法做到的方式利用大量数据。是我们开始缩小这一差距的时候了。

通过这个系列，我们将对阿斯托里亚我最喜欢的墨西哥餐馆之一进行分析:查诺酒吧。

邻近地区

与纽约市其他更著名的街区不同，阿斯托里亚保持着独特的身份，有着一系列当地美食。毫无疑问，它得益于作为这个城市最多样化的区的邻居。但这也意味着每家餐馆都有众多的竞争对手，这让任何一家本地餐馆都更难脱颖而出。事实上，在 Yelp 上快速搜索阿斯托里亚的墨西哥餐馆会得到 24 页的结果。

目标

我们的目标很简单:确定感兴趣的业务的前五到十名竞争对手，然后使用自然语言处理和情感分析来确定公司做得好的地方和需要改进的地方。要做到这一点，需要大量的数据科学技术，我们将在本系列的每一部分逐一介绍。这些包括但不限于:

使用 Yelp API 访问数据
k 均值聚类
网页抓取
情感分析/自然语言处理
监督机器学习
神经网络

现在，你可能会问自己，一个不精通这种类型的分析的小企业应该如何实现所有这些？最终，我们希望将它部署在一个干净的模块中，只需要一些基本的输入:

公司名称(如 Yelp 上显示的):查诺酒吧
地点(邮编或城市，St): 纽约州阿斯托里亚
搜索词(潜在客户可能用来在 Yelp 上找到该企业的任何短语或短语组合):墨西哥餐厅酒吧

不多说了，让我们开始构建并使用 Yelp API 进行设置。

Yelp API

认证令牌

首先:如果你想使用 Yelp API 访问数据，Yelp 需要能够验证你的身份。这是通过生成一个访问令牌来完成的。如果您还没有 Yelp 帐户，您需要创建一个。点击上面的链接，您应该会看到一个如下所示的页面:

为每个独立的项目创建一个具有不同的应用名称的新令牌是一个好主意。必填字段包括:

应用名称
工业
联系电子邮件
描述

不需要过多考虑这些，只需要尽你所能地填写，同意条款和条件(别担心，我检查过了，没有 human 厘泊条款)，然后为机器人确认你不是机器人。在下一页，您将获得一个客户端 ID 和令牌。

你会注意到我把自己的令牌模糊掉了，那是因为你不想和别人分享你的令牌。如果有恶意的人得到了你的令牌，他们可能会使用它来暂停你的帐户，甚至更糟。换句话说:

理想情况下，您会希望将这些保存为环境变量。关于这个主题的更多详细信息，这篇文章是个很好的起点。

现在，您可以将这些硬编码到您的 Jupyter 笔记本中，如下所示:

client_id = your_unique_client_id
api_key = your_unique_api_key

给 Yelp 打电话

现在我们已经解决了这个问题，我们可以开始调用 Yelp API 来获取新数据了。在我们的例子中，我们想要搜索纽约阿斯托里亚的墨西哥餐馆&酒吧，并将结果保存到 dataframe 中。第一步是通过命令行安装 Yelp API。

pip install yelpapi

安装 API 后，您现在可以将它加载到任何 Jupyter 笔记本电脑中:

from yelpapi import YelpAPIyelp_api = YelpAPI(api_key)

很简单！现在，对 Yelp API 的请求需要三个部分:

搜索词:标准 Yelp 搜索中使用的搜索词。
位置:城市、街道或邮政编码
搜索限制:您想要多少个结果(最多 50 个)？

我们想在纽约的阿斯托里亚找到墨西哥餐馆&酒吧，所以我们将所需数据传递给一个搜索查询，如下所示:

term = 'Mexican restaurant bar'
location = 'Astoria, NY'
search_limit = 50response = yelp_api.search_query(term = term,
                                 location = location,
                                 limit = search_limit)type(response)--------------OUTPUT:
dict

如你所见，我们将搜索结果保存到一个响应变量中，它是一个字典。

将结果保存到数据框架

通过进一步的检查，我们会发现这个字典有三个键:

商业
总数
地区

出于我们的目的，我们对业务数据感兴趣。随着进一步的评估，你会发现这个键中的数据是一个字典列表，每个字典代表一个不同的业务，所有的字典都有相同的键。这允许我们将键列表设置为列名，并将值用作 dataframe 中的数据。我们可以用几行代码来实现这一点:

cols = list(response['businesses'][0].keys())
data = pd.DataFrame(columns=cols)for biz in response['businesses']:
    data = data.append(biz, ignore_index=True)data.head()

瞧啊。我们有一个数据框架，其中包含了我们在使用传统 Yelp 搜索时通常会看到的所有信息，但其格式可以用于分析。

结论

正如您所看到的，使用 Yelp API 访问数据非常简单和方便。在下一篇文章中，我们将看看分类标签，并使用 K-Means 聚类来找出哪些餐厅与 Chano's Cantina 最相似。我们将这些视为最直接的竞争对手，以便进行更深入的分析。

有关 Yelp API 更广泛功能的更多信息，请查看文档。

Python 可视化入门

原文：https://towardsdatascience.com/getting-started-with-visualizations-in-python-945d92b85823?source=collection_archive---------28-----------------------

Photo by M. B. M. on Unsplash

想象任何事情都会让我们有更好的理解，对事情有一个整体的了解，无论是你公司每月的营业额，不断上升的温度，甚至是你可以跑得比其他人都快的紧张局势，相信我，后一种情况很有效。

艺术的目的不是表现事物的外表，而是表现其内在的意义。
—亚里斯多德

可视化是一门艺术，它不仅仅是更好地呈现数据，而是实际上描绘出隐藏在数据深处的趋势、模式和其他迹象，光盯着数据是看不出来的。

这是任何想要从事数据科学的人都需要掌握的关键艺术之一，没有它，你将是不完整的，你的任务，你的任务将是不完整的，尤其是当你去找某人解释，为什么会发生这种情况？

让我们来看看一些最常见的情节；

先沉住气。

难道我们不应该先看看这里需要什么来策划吗？

有如此多的开源库可供您使用，实际上需要做的是将要做的事情。

现在别跟我开玩笑了！

显然，你需要一台笔记本电脑和 Jupyter 笔记本，也许还需要一些 Python 基础知识。

让我们现在开始吧。

线形图:

折线图或折线图是一种图表，它将信息显示为由直线段连接的一系列数据点，称为“标记”。

这更像是一个散点图，只是中间有线条，它用于显示与正在进行或移动的因素相关的数据点。L

让我们用一个例子来观察这一点；

该数据代表股票在某一天的价值。

这里的索引包含了查询的日期，我们有一个单独的列用于不同的公司，在本例中是 IBM 和 Apple。

空谈不值钱。给我看看代码！

使用 Plotly 时要记住的事情。首先，您需要创建如下跟踪:

trace0 = go.Scatter(
    x= <List of values on x-axis>,
    y= <List of values on y-axis>,
    name= <Trace Name>
)

这将创建一个分散的对象，通常被称为跟踪。

一些智慧即将到来，你可以做出任何数量的这些，并在同一个情节中表现出来。

第二，布局，

layout = go.Layout(    
    title=go.layout.Title(        
        text= <Heading for your plot>
    ),
    xaxis=go.layout.XAxis(
        title=go.layout.xaxis.Title(
            text= <X-Axis Name>
        )
    ),
    yaxis=go.layout.YAxis(
        title=go.layout.yaxis.Title(
            text= <Y-Axis Name>
        )
    )
)

plot ly . graph _ objs . graph _ objs . layout提供了各种即兴创作和排列情节的方法，可以是颜色、字体，通常是任何东西。

太好了！这是上面代码的线图输出

W 如果我想用 Matplotlib 代替 Plotly 呢？

非常欢迎你！

而这就给了我们下面的剧情。

直方图:

直方图是数字数据分布的精确表示。它是对连续变量的概率分布的估计。

抓住你了。首先，不要把它和条形图联系起来。

-直方图与条形图非常不同，因为条形图涉及两个变量，而直方图只涉及一个变量。

让我们来看看泰坦尼克号的数据集。

直方图有助于我们做出推论，比如如果我是一个有年龄的女孩，我活下来的概率是多少。

不，我不想成为一个女孩，我只是不想像杰克那样死去。

假设你得到了这个，让我们冲向代码。

Plotly 提供了不同的类，当输入数据时，可以产生惊人的结果， plotly.figure_factory 就是其中之一。

fig = ff.create_distplot(hist_data, #Used for finding distribution
                         group_labels, #Labels of the classes used
                         bin_size=1.5, #Width of the bin
                         colors = ['#393E46', '#2BCDC1'], 
                         show_rug=False)

看起来简单，输出花式！

看到这里，我们可以很容易地提供前一个问题的答案，如果我是一个年龄在 18 岁到 35 岁之间的女孩，我很可能会幸存下来，因为我们可以看到，女性的生存密度在 18 岁到 35 岁之间最高。罗斯活下来的证据之一，如果我们为男性设计，我们肯定会知道为什么杰克没有。

那不是很容易吗！

现在你们就像，

好吧，我会给你的。

箱线图:

这是一种通过四分位数图形化描述数字数据组的方法。

这家伙捕捉了很多信息，我是说很多。

它很好地显示了分布情况，即数据中的值如何分布。

它们是基于五个数字摘要(“最小值”、“第一个四分位数(Q1)”、“中值”、“第三个四分位数(第三季度)”和“最大值”)显示数据分布的标准化方式，这在一个图中包含了大量信息。

空谈不值钱！不用提醒我，我知道。

我们会考虑同样的泰坦尼克号的数据，但我们会考虑票价，而不是年龄。

类似于线图，我们有plotly . graph objs . graph obj . Box，我们可以用它来传递值，它会将其转换为盒图 obj。

trace0 = go.Box(
    x = train.loc[(train['Sex']=='female'), 'Fare'].dropna().values,
    name = "Female"
)

虽然你们很聪明，但盒子图更聪明。

看到这里，我们可以推断出，大多数男性乘客都是廉价旅行，而大多数女性乘客都有昂贵的机票，而且大多是高级别的。

现在泰坦尼克号对我来说是有意义的，杰克和罗斯在一起的原因，也是他没能活下来的原因。

数据说话。

喜欢吗？喜欢吗？讨厌吗？给我写封信，我很想探索一下。

Weka 3 入门 GUI 上的机器学习

原文：https://towardsdatascience.com/getting-started-with-weka-3-machine-learning-on-gui-7c58ab684513?source=collection_archive---------5-----------------------

Weka Splash Screen

使用 Weka 构建机器学习模型的分步指南

eka 是一种不会飞的强壮的棕色鸟。名字读作T3 这个，鸟的声音读作T7 这个。它是美丽的新西兰岛上特有的，但这不是我们在本文中讨论的。在这篇文章中，我想向您介绍用于机器学习的 Weka 软件。WEKA 是 Waikato 环境的缩写，用于知识分析。它是由新西兰怀卡托大学开发的。它是一个开源的 Java 软件，拥有一组用于数据挖掘和数据探索任务的机器学习算法。这是一个非常强大的工具，用于理解和可视化本地机器上的机器学习算法。它包含用于数据准备、分类、回归、聚类和可视化的工具。

使用案例:

如果您刚刚开始学习机器学习和算法，那么 WEKA 是入门和探索不同算法的最佳工具，以了解哪一种算法最适合您的问题。
有时您有一个分类问题，但您不知道哪种算法可以解决它并获得最佳的精确结果。WEKA 是一种简单的方法，可以将许多不同的算法应用于您的数据，并查看哪一种算法会给出最好的结果。

安装:

安装软件非常简单，你只需要先安装 Java 8，然后从这里下载适合你的平台的可执行文件。

安装后，导航到包管理器，开始安装任何学习方案和工具

GUI Chooser — Weka

我将安装和演示的第一个包是 Auto-Weka 。Auto-weka 是 weka 的 AutoML 实现。对于给定的分类或回归任务，它会自动找到具有最佳超参数设置的最佳模型。

安装完成后，您需要重启软件来加载库，然后我们就可以开始了。

注意:有一个已知问题。为了通过 OSX 上的 WEKA GUI 使用 Auto-WEKA，WEKA 必须从命令行运行，而不是从 Mac 应用程序运行。例如:

CD/Applications/WEKA-3–8–1-Oracle-JVM . app/Contents/Java/

java -jar weka.jar

加载数据集:

Weka 还提供了一些数据集，你可以用它们来做实验。现在，让我们加载第一个数据集，并对其进行一些探索。在这个例子中，我将使用虹膜数据集。对于 Mac OSX，点击“浏览器”→“打开文件”→/Volumes/WEKA-3–8–3/WEKA-3–8–3/data。

加载数据集后，您可以看到 weka 会自动显示属性的一些统计数据(在左侧窗口中列出)，当您选择一个要素时，它会显示该特定要素的类分布。

您也可以点击“可视化全部”，可视化与所有其他功能相关的类别分布。

培训:

现在。让我们训练一个实际的分类器。Weka 附带了许多可以立即使用的分类器。当您选择“分类”选项卡时，您可以看到一些分组的分类算法:

以下是每个组的摘要:

贝叶斯:一组使用贝叶斯定理的分类算法，比如朴素贝叶斯、朴素贝叶斯多项式。
函数:一组回归函数，如线性回归、逻辑回归等。
懒惰:懒惰学习算法，比如局部加权学习(LWL)和 k 近邻。
meta:AdaBoost、Bagging 等一套降低方差的集成方法和降维算法。
misc :比如 SerializedClassifier，可以用来加载预先训练好的模型进行预测。
规则:基于规则的算法，比如 ZeroR。
树:包含决策树算法，如决策树桩和随机森林。

现在，让我们首先使用随机森林分类器对虹膜数据集进行分类。随机森林是一种集成学习算法，可用于分类、回归和其他任务。它的工作原理是在训练时构建大量的决策树并输出预测的类。为了在 Weka 中使用 RF，从树组中选择随机森林。一旦选择了随机森林算法，它将自动加载默认的超参数集。您可以通过单击显示在分类器旁边的命令来自定义超参数。

至于评估训练，我将使用 15 k 倍交叉验证，然后我们准备好训练。虹膜数据集非常小，因此训练时间将在几分之一秒内。它将生成培训的输出摘要，如下所示:

您可以看到混淆矩阵、ROC 面积、精确度、召回率等指标。

我应该用什么算法来解决我的问题？

一般来说，很难知道哪种算法最适合你要解决的问题。一旦你缩小了问题的范围(多类分类、回归、二元分类)，你就可以开始尝试一套算法来处理这个范围的问题。在此过程中，您可能会发现可以提取数据中隐藏结构的算法。

Weka 是实现这一点的一个非常好的工具，因为你可以在算法之间快速切换，并在数据集的一部分上训练它们，然后比较结果，而不必编写太多代码。一旦您确定了算法，您就可以开始实现对您的数据最有效的算法的生产级别。因此，您可以使用更智能的方式，为您的数据自动选择正确的算法和正确的超参数。这种聪明的方式叫做: AutoML 。

使用 AutoML (Auto-Weka):

Auto-WEKA 是 WEKA 的 AutoML 实现包。它的使用非常像任何其他 WEKA 分类器。将数据集加载到 Weka 后，可以使用 Auto-Weka 自动确定最佳 WEKA 模型及其超参数。它通过使用 [SMAC 工具](http://www.cs.ubc. ca/labs/beta/Projects/SMAC/)智能地探索分类器和参数的空间来做到这一点。

Auto-WEKA 只有几个选项可以调整。大多数情况下，只有两个选项是相关的:

时间限制:Auto-WEKA 确定最佳分类器和配置所需的时间(分钟)。如果您不能在默认时间(15 分钟)内获得好的结果，您可以将此旋钮调到更高的值
memLimit: 运行分类器的内存限制，以兆字节为单位。如果您有一个非常大的数据集，您应该增加这个值。Auto-WEKA 运行时，它将在状态栏中提供迄今为止评估的配置数量和最佳配置的估计误差，如下所示:

并行运行:并行执行的运行次数。

时间限制结束后，auto-weka 过程将停止，并显示数据集的最佳配置。现在，让我们探索一下 Auto-Weka 的一些结果。下面是 Auto-Weka 输出的摘要:

它说最好的分类器是逻辑模型树算法(LMT ),上面指定的超参数是“自变量”。您可以使用 LMT 分类器的文档来解释这些参数。以下是每个参数的含义:

-C 在所有节点使用交叉验证进行升压
-P 用概率上的误差代替误分类误差作为停止判据。
-M 3 将一个节点可拆分的最小实例数设置为 3。
-W 0 为 LogitBoost 的重量微调设置 beta。0 表示不进行重量调整。

你也可以看到 Auto-Weka 证明了 LMT 会给出比随机森林更好的结果。LMT 有 96%的正确分类实例，而 RF 有 94%, LMT 的错误分类实例较少，为 4 %,而 RF 为 6%。这是一个很小的差异，但它会对较大的数据集产生巨大的影响。

总结:

这篇文章是一个快速入门指南，介绍如何使用 Weka 通过 GUI 在数据集上探索和训练机器学习算法，而无需编写任何代码。收集一些对数据的见解，甚至学习一种新的算法或知道哪种算法最适合你的数据集，都是非常有用的。

为新手在黑客马拉松上完成任务

原文：https://towardsdatascience.com/getting-stuff-done-at-hackathons-for-rookies-a676dc4641be?source=collection_archive---------26-----------------------

我非常喜欢我的第一次黑客马拉松(你可以从以前的帖子中了解我关于 scope 的经历)。通过 BetaNYC，有机会参加所有能力的移动黑客马拉松，这是 2019 年更大的全国公民黑客日的一部分。

我是“可靠访问地铁”团队的成员，与运输中心和纽约平等访问联合会合作，我们的提示是这样的:

我们想要探究电梯和自动扶梯故障的原因，并以阐明模式和洞察解决方案的方式呈现数据。

如果你要去参加你的第一次黑客马拉松，请记住一些来自一个二年级黑客马拉松的事情，我会在我做的工作之间做这些事情。

评估你的团队

立即开始编码很有诱惑力，但是如果你马上投入进去，你将永远不会有作为一个团队取得成功所必需的专注。大家都是技术吗？每个人都用同一种语言写作吗？你的背景是什么？大家对什么感兴趣？

了解手头的问题

对我们来说，这个问题比一个下午的工作所能解决的要大得多。我们的团队中有两位非技术主题专家，来自 TransitCenter 的 Colin 和来自 United for Equal Access NY 的 Dustin，他们帮助引导了围绕我们的提示的对话。

MTA 在其季度交通和公共汽车委员会会议上发布 PDF。每份报告都有数百页长，但我们关注的是利用率低于 85%的电梯和自动扶梯的报告。埋在这份 491 页的 2019 年 Q2 报告是第 380-384 页的表格。

每一排被分配到一部电梯或自动扶梯，每一部电梯或自动扶梯都在地铁站，其可用性为季度的%,以及注释。评论是报告中最有问题的部分。以下是哈德逊站 ES622 号自动扶梯的评论示例:

自动扶梯于 2019 年 4 月 15 日至 2019 年 4 月 24 日停止运行，以维修和调整 combstop 和碰撞安全装置。由于电线松动，控制器也进行了维修。洒水系统失灵了，引发了洪水。水被抽出来了，喷水系统也修好了；自动扶梯经过测试后重新投入使用。由于安全检查和相关维修工作，自动扶梯于 2019 年 5 月 17 日至 2019 年 5 月 23 日停止运行。调整了 combstop 安全装置，更换并调整了左侧扶手链；自动扶梯经过测试后重新投入使用。

在此期间，有两次停机，每次停机都有多种原因导致停机，并且需要采取多种措施来修复。该信息在其他任何地方都不可用，所以我们的目标是从 PDF 中提取表格。

接受任务

使这些信息可用的第一步是从 PDF 中提取，从那里我们可以开始从评论中分离出每个事件。

有人被指派去确定电梯和自动扶梯故障的所有类型的原因以及如何修理它们，有人被指派去尝试构建脚本来解释不同类型的问题和修理。许多人接受任务，寻找不同的方法将 PDF 表格转换成可操作的数据库。

低下头，做些工作

你已经得到了你的任务，你知道它将如何发挥更大的作用，现在是时候做一些工作了。在我的例子中，我要从 pdf 创建 csv 文件。

Here’s the first page of the PDF I needed to convert

为了让一切快速运行，我使用了 PyPDF2 来读取 PDF。我最初打算使用更复杂的东西来读取文件，但是当我开始编码时，我只有不到四个小时的工作时间来完成一些功能。

PyPDF2 提取了文本并揭示了文件格式的一些问题。这里有一个例子:

‘ES235’,
 ’34 St-Herald Sq ‘,
 ‘BDFM84.34%’,
 ‘The escalator was out of service from 12/4/18 to 12/11/18 due to worn out handrail and countershaft chains ‘,
 ‘as well as defective brake assemblies. The countershaft assembly and chain were replaced and adjusted. ‘,
 ‘The right handrail chain was adjusted. The main brakes were replaced and adjusted as well as a controller ‘,
 ‘’,
 ‘relay; the escalator was tested and returned to service. The escalator was out multiple times due to the ‘,
 ‘’,
 ‘activation of various safety devices. Those safety devices were tested and adjusted as needed.’,

换行符是硬编码的，地铁线和百分比在同一条线上，评论中有一堆额外的换行符，没有解释原因。很乱，但这是我们能做的。

休息一下，吃点零食

记住你和其他人一起参加活动。参加社交活动，如果有食物，你应该去吃一顿饭，并和房间里的其他人联系。这些都是认识人的好方法。

问问周围

如果你独自做项目的一部分，你可能会和一群做类似工作的人坐在一起，在这次黑客马拉松中，有几个人朝着相同的目标工作。我碰巧坐在我熨斗学校的同学 Jen McKaig 旁边，能够谈论我们遇到的一些问题非常有帮助。

让我们来看看我的函数在哪里:

def convert_transit_pdf_to_csv(pdf, start, end):

    '''
    Input is a PDF file in the local directory, the first page
    of the PDF and the last page of the PDF. The function adjusts
    the first page to account for zero-based numbering. It will
    output a csv file back into the directory.

    There are a few issues with the code as-written. If an escalator
    or elevator is avialable 0.00% of the time, it will add an 
    additional digit or character to the availability column. There 
    is one other issue I've encountered where the subway lines
    aren't formatted properly.

    The comments will occaisonaly cut off and a fix for that is the 
    first priority once this code is re-visited.
    '''page_range = list(range(start - 1,end))pdfFileObj = open(pdf, 'rb')pdfReader = PyPDF2.PdfFileReader(pdfFileObj)lines = []
    availability = []
    units = []
    stations = []
    conditions = []condition = ''for page in page_range:
        pageObj = pdfReader.getPage(page) 
        current_page = pageObj.extractText().split('\n')**# the last two lines of each page are the page identifiers, so it's the current page without the last two lines**
for i in range(len(current_page[:-2])):

**# removes some titles that would otherwise be caught
**            if not re.match(string = current_page[i], pattern = '.* THAN 85% AVAILABILITY'):
                if len(current_page[i]) > 1:# this is less than ideal and occasionally cuts off the last line
# of a comment if it's under 40 characters. This was about as quick
# and dirty as it comes.
                    if len(current_page[i]) > 40:
                        condition += current_page[i]**# this would be [-6:] if all availabilities were above 10%,
# but some are available 0.00% of the time** if re.match(string = current_page[i][-5:], pattern = '\d\.\d{2}\%'):
                        availability.append(current_page[i][-6:])
                        lines.append(current_page[i][:-6])**# identifies the elevator or escalator unit**
                    if re.match(string = current_page[i], pattern = 'E[LS]\d{3}'):
                        units.append(current_page[i])
                        stations.append(current_page[i + 1])
                        if len(condition) > 1:
                            conditions.append(condition)
                            condition = ''**# specifically looks for the end of the page and ends the 'condition'**
                if i == len(current_page[:-2]) - 1:
                    conditions.append(condition)
                    condition = ''
    df_stations = pd.DataFrame(
        {'units': units,
         'stations': stations,
         'lines' : lines,
         'availability' : availability,
         'condition': conditions
        })df_stations.to_csv(pdf + ' converted.csv')

你可以在我的 Github 知识库上看到关于 beta NYC Mobility for All Abilities hackathon的最新更新。

获得相关性和协方差的基础知识

原文：https://towardsdatascience.com/getting-the-basics-of-correlation-covariance-c8fc110b90b4?source=collection_archive---------3-----------------------

相关性是广泛使用的统计概念之一。这篇博文试图回答什么是相关性，为什么它如此有用，相关性和协方差有什么关系，以及计算相关性的一些方法。

什么是相关性？

相关性，决定一个变量如何相对于另一个变量移动/变化的统计技术。它给了我们关于这两个变量的相关程度的概念。这是一种双变量分析方法，描述了不同变量之间的关联。在大多数商业活动中，用一个主题与其他主题的关系来表达这个主题是很有用的。

例如:如果在产品营销上花很多钱，销售额可能会增加。

它为什么有用？

1.如果两个变量密切相关，那么我们可以从一个变量预测另一个变量。

2.相关性在确定其他变量所依赖的重要变量方面起着至关重要的作用。

3.它被用作各种建模技术的基础。

4.适当的相关性分析有助于更好地理解数据。

5.相关性有助于理解因果关系(如果有的话)。

相关性和协方差的关系

在深入研究相关性之前，让我们先了解一下协方差。

协方差:前缀‘Co’定义某种联合动作，方差指的是变化或变动。所以它说，两个变量是相关的，基于这些变量，如何改变彼此的关系。

但是等等，协方差和相关性一样吗？

因为协方差和相关性有相同的含义，所以相关性比协方差更进一步，也告诉我们关系的强度。

两者都可以是正面的，也可以是负面的。如果一个增加另一个也增加，协方差为正，如果一个增加另一个减少，协方差为负。

协方差计算如下

Covariance formula

变量 x 的 Xᵢ=观测点

所有观察值的 x̅=平均值(x)

变量 y 的 Yᵢ=观测点

ȳ =所有观察值的平均值(y)

n=观察次数

解码协方差公式:两个变量 x 和 y 之间的协方差是每一项与其各自均值的差的乘积之和除以数据集中的项数减一..

通过一个简单的示例数据获得更好的理解:

以下数据显示了相应温度下的客户数量。

Example to understand correlation and covariance

首先找出两个变量的平均值，用各自的平均值减去每一项，然后按如下方式相乘

x 的平均值，x̅=(97+86+89+84+94+74)/6 = 524/6 = 87.333

y 的平均值，ȳ=(14+11+9+9+15+7)/6 = 65/6 = 10.833

COV ( x，y)= 112.33/(6–1)= 112.33/5 = 22.46

温度和顾客之间的协方差是 22.46。因为协方差是正的，所以温度和顾客数量有正的关系。随着温度的升高，顾客的数量也在增加。

但是这里没有关于这种关系有多强的信息，这就是相关性出现的原因。

相关系数是指任何相关测量方法的结果。

这里，样本相关系数计算如下

Correlation formula

COV ( x，y ) =变量的协方差 x 和y
σx=变量的样本标准差x
σy=变量的样本标准差 y

COV(x，y) = 22.46

σx = 331.28/5=66.25= 8.13

σy = 48.78/5=9.75=3.1

相关性= 22.46/(8.13 x 3.1)= 22.46/25.20 = 0.8

0.8 表示温度和客户数量之间的相关性强度非常强。

样本相关系数可以用来估计总体相关系数。

存在不同的方法来计算两个对象之间的相关系数。一些方法是:

1。 皮尔逊相关系数

它捕捉两个连续变量之间线性关联的强度和方向。它试图通过两个变量的数据点绘制最佳拟合线。皮尔逊相关系数表明这些数据点离最佳拟合线有多远。只有当一个变量的变化与另一个变量的变化成比例时，这种关系才是线性的。

皮尔逊相关系数计算方法为

r =皮尔逊相关系数

n =观察次数
∑xy = x 和 y 值乘积之和
∑x = x 值之和
∑y = y 值之和
∑x2 = x 值的平方和
∑y2 = y 值的平方和

斯皮尔曼相关系数

它试图确定存在于两个顺序或连续变量之间的单调关系的强度和方向。在单调关系中，两个变量会一起变化，但不会以恒定的速率变化。它是根据变量的排序值而不是原始数据计算出来的。

单调和非单调关系如下所示:

Spearman rank correlation coefficient

ρ= Spearman 等级相关系数
di=相应变量等级之间的差异
n=观察次数

比较:皮尔逊和斯皮尔曼相关系数

Pearson 和 Spearman 相关系数可以取-1 到 1 之间的值。

(i) 如果一个变量以一致的速率随另一个变量增加，则皮尔逊系数将为 1，这产生一条完美的线。在这种情况下，斯皮尔曼系数也是 1。

(ii) 如果一个变量随着另一个变量增加，但不是以一致的比率增加，那么皮尔逊系数将是正的，但小于 1。在这种情况下，斯皮尔曼系数仍然是 1。

(iii) 如果关系是随机的，那么两个系数都将接近 0。

(iv) 如果变量之间的关系是一条完美的直线，但关系是递减的，那么两个系数都是-1。

(v) 如果两个变量之间的关系是一个变量减少，而另一个变量增加，但比率不一致，则皮尔逊系数将为负，但大于-1。在这种情况下，斯皮尔曼系数为-1。

什么时候用什么？

皮尔逊相关描述线性关系，斯皮尔曼相关描述单调关系。散点图将有助于可视化数据，并了解应该使用哪个相关系数。另一种方法是同时应用这两种方法并检查哪种方法执行得好。例如，如果结果显示 spearman 相关系数大于 Pearson 系数，这意味着我们的数据具有单调关系，而不是线性的。

此外，相关性并不意味着因果关系。这里看为什么为什么。

更多阅读:

https://365 data science . com/协方差-线性相关系数/#close
https://www.wallstreetmojo.com/correlation-vs-covariance/

感谢阅读！

从阅读书籍中获得最大收益——以“专业的方式”阅读

原文：https://towardsdatascience.com/getting-the-most-out-of-reading-books-reading-the-professional-way-6a65ab7c831e?source=collection_archive---------26-----------------------

注:此文最初发布于martinheinz . dev

阅读书籍，无论是关于编程、软件开发还是其他方面的书籍，都是获取某一领域知识的最佳途径之一。然而，人们经常快速浏览书籍，注意力不集中，最终记不住或很快忘记他们刚刚学到的东西。但是有更好的方法。

专业的读书方式

我在学校从来没有真正注意过，尤其是在高中的斯洛伐克语课上，但有一件事我记得很清楚，那就是我们的老师告诉我们的阅读书籍的方式“专业方式”。她告诉我们，当她阅读书籍(主要是诗歌和其他东西)时，她会从每几行或每一段中做笔记。当时我唯一的想法是:“哇，这么浪费时间读诗，真是有些敬业啊……”(开个玩笑)。

后来，当我开始学习计算机科学并阅读了相当多的书籍和文章时，我意识到按照高中老师告诉我们的方式开始记笔记可能是个好主意。从那以后，我写了很多笔记，养成了一些好习惯，并对整个过程进行了【优化】，所以让我告诉你如何有效地阅读书籍【专业方式】。但是首先，为什么写笔记真的有好处呢？

为什么呢？

做笔记有益原因有很多，有些很明显，有些不太明显。所以，现在开始:

集中注意力——阅读时，你可能会走神，读了几段后，你会意识到自己不知道刚刚读了什么。如果你做笔记，你会被迫思考你正在读的东西，否则你就不能做笔记
多记——思考、写作，并试着把你对刚读过的东西的想法用连贯的句子表达出来，这将有助于你从中记起更多的东西
保持记录——如果你正确地写了笔记，那么你可以用它们来记录你读了哪些书/文章，或者你读到哪里了——它就像书上的一个标记，如果你读了很多，从一本书跳到另一本书，这很有帮助
笔记本身——嗯，做笔记最明显的优势就是笔记。无论你刚刚读了什么，你都会得到摘要，当有一天你需要它的时候，你会很高兴你真的写下了一些东西。

做这件事的最好方法

现在，我可能已经说服你开始记笔记了，我想分享一些习惯和方法，让它对你来说尽可能的简单和有用。

不要复制粘贴书本上的句子——自己写或者最好重新措辞，这样你就容易理解了
章节注释基于书籍/文章的章节，这样以后更容易找到具体的部分
使用要点——你不需要整段文字，你只需要回忆起你在一本书上读到的内容或者在哪里可以找到更多的信息，有时关键词就足够了
使用版本控制软件——这是最重要的一个——为你的笔记创建一个存储库，并根据流派或类型(书籍或文章)将它们归类到目录中，这样你就可以在任何地方访问它们，并可以跟踪你在什么时候读了什么，读了多少
使用有意义的提交消息——如果你决定使用 GitHub 或其他版本控制软件，那么我强烈建议你花时间编写好的提交消息。我一般用“第 X 章(第 X.Y，X.Z 节)”这样的格式(见下图)。
——使用 markdown——如果你要阅读任何编程书籍，那么都会有代码，而编写包含代码的文本的最简单方法无疑是 markdown。另外，当你在 GitHub 中打开它时，它会被很好地格式化。
养成一个习惯——一开始可能会很烦人，会让你慢下来，但随着时间的推移，它会变得越来越自然，你会变得更有效率，所以坚持下去。

Example of commits

结论

在这里，我主要写了阅读书籍或文章时做笔记，但这真的适用于你做的所有学习。阅读书籍、文章时写笔记，阅读你从未使用过的图书馆文件时也要写笔记，例如建立数据库或新网站时。迟早(实际上这可能一直发生在我们所有人身上)你会想:“我读到的这个东西是什么…？”或“我已经做过一次了……但是我不记得怎么做了……”。拥有好的笔记可以给你很大的帮助，所以下次你打开某本书或文章时，只要打开你最喜欢的文本编辑器，创建 Book Name.md 就可以了。

掌握解析树

原文：https://towardsdatascience.com/getting-to-grips-with-parse-trees-6e19e7cd3c3c?source=collection_archive---------18-----------------------

对 NLP 有用。没那么复杂。

Source: Anni Roenkae for Pexels

虽然我们按顺序读、写、说，但实际上单词是按层次排列的。随着我们掌握了母语，这种等级制度就成了我们的第二天性，以至于我们很少需要停下来思考哪些单词应该放在哪里才能构成一个完整的句子。

解析树是在树形图中显式可视化这种层次的一种方式。

直到几年前，许多自然语言处理(NLP)都涉及到将句子解析成这样的图形并对其进行处理。例如，人们可以将树分成不同的结构类型；或者操纵一棵树来形成新的树，新的树可能对应于也可能不对应于具有相邻语义属性的新句子。

对一些人来说，足够的计算能力和深度神经网络的出现使所有这些努力都变得多余:如果一个词的完整上下文由其邻居决定，让你的网络处理足够的文本数据就足够了。

嗯，也许吧。然后，也许你有很多句子碰巧有相似的结构，简单地把它们分开会很有用。为了以防万一，解析树是一个很好的工具。

我们先从小事做起

让我们从一个微小的句子开始。我们将使用 spaCy 解析器对其进行解析，并以三种不同的方式呈现结果，以帮助将解析树结构上下文化。

第一个是句子中单词的有序列表，以及每个单词所扮演的角色。

第二个是相同的信息，展示了解析树在空间中的可视化方式。

第三张是同一棵树的稍微不同的插图，从上到下读起来很容易。

下面是关于解析树需要注意的四件事:
1 .句子中的每个单词都是图表中的一个节点。我们所说的词实际上是指“句法词”，称为标记。例如， She 的可以写成一个单词，但是表示“她是”，所以 She 将是一个令牌，的将是第二个令牌，在它自己的节点中。

2.该树有一个根节点，树的其余部分从该节点流出。这是一个句子的主要动词。

3.如箭头所示，边缘是有方向的。如果一条边从一个节点到另一个节点，第一个节点是“父节点”，第二个节点是“子节点”。在解析树中，每个节点(根节点除外)都有一个父节点，并且可以有零个或多个子节点

4.每个节点都有一个标签。每条边都有单独的标签。这是两套不同的标签。

你可能对节点上的标签很熟悉，它们表示词性(词性):动词、名词、形容词等。
这个清单比你想象的要长(稍后会有更多)。这里还有几个，完整的名单可以在这里找到。

边缘的东西呢？

它们被称为句法依赖标签，显然，有些是通用的(确切地说是 37 个)，而有些是语言依赖的。你可以在 spaCy 文档中找到一个完整列表，但是你真正需要做的是:a .识别它们是什么，b .理解它们有助于导航树，以及 c .记住那些碰巧对你有用的。

例如， nsubj 将是一个显而易见的答案，因为这通常是句子的主语。另一个流行的是 amod ，这是一个形容词修饰语。在我们的例子中，这位女士驾驶的不是任何旧钢琴，而是一种特殊的钢琴——一架希腊钢琴。

细化词性标注

假设我们的句子改成“她驾驶希腊钢琴”。词性标注完全相同——drives 和 drives 都是动词。需要一个更精确的系统来区分这两者。

嗯，完整的 POS 标记系统确实适应这种区别。以下是不同标签的列表；正如你所料，它比以前长了很多。再说一次，我不可能记住哪怕是一半，所以我把它保存在一个文档中作为参考。

为了区分简化的标记(它可能告诉你一个令牌是一个动词，但不是它的时态)和完整版本，spaCy 调用第一个 POS 和第二个标记。您的解析树可以显示标记的完整标记。在其文档中，spaCy 列出了标签及其相应的位置，这很有帮助。

短语和子树

让我们看看当我们把“她”改成更具体的东西时会发生什么。句子的主语现在从一个单词变成了包含几个单词的名词短语。因此， nsubj 边指向“Queen ”,并从那里流出一个子树。

The subtree for the sentence’s subject

要知道子树在哪里开始，在哪里结束，我们可以在句子中寻找属于这个子树的最右边和最左边的标记，并获取它们之间的所有内容:

现在，看看下面这个新句子。尽管这个句子和我们之前的句子没有一个单词相同，我们还是觉得这两个句子有很大的相似之处。例如，在这里我们可以看到主题子树在语法上是相同的:

快速回顾

解析树是表示句子的方向树:标记是节点，边是单词之间的语法关系，源于句子的主要动词。这意味着每个令牌都可以通过从根开始的单一路径到达。

树表示明确了句子的层次性质，因此句子中较小的句法单元对应于子树。

节点和边都用两组不同的标签进行了标注。重要的是不要陷入这些标签的字母汤。请记住，它们可以用来导航树。这为基于规则的分析提供了坚实的基础，尤其是与正则表达式结合使用时。

摘要

在 2019 年 spaCy IRL 活动的主题演讲中，NLP 研究员兼艾伦人工智能研究所研究主任 Yoav Goldberg 概括地描绘了用于分析文本的技术。

他补充说，大多数应用自然语言处理仍然使用基于规则的系统，而不是来自学术界的最新研究。基于规则的系统的优点是需要的数据更少，更透明，更容易调试。

然而，他们确实需要更多的语言知识。

基于规则的系统远非完美，NLP 的未来可能会将规则与机器学习和深度学习技术结合起来。

最终，我们的目标是让 NLP 不仅高效，而且让更容易(或者至少更容易)。这意味着降低专业知识的前期要求。不仅仅是机器学习，语言学也是如此。

我认为这篇文章有助于做到这一点。

了解 Mel 光谱图

原文：https://towardsdatascience.com/getting-to-know-the-mel-spectrogram-31bca3e2d9d0?source=collection_archive---------1-----------------------

如果你想像 Neo 一样了解 Mel 光谱图，请阅读这篇短文！(也许不是全部，但至少有一点)

对于 TL；博士和全部代码，去这里。

几天前发生在我脑子里的一次真实对话

我:嗨梅尔声谱图，我可以叫你梅尔吗？
梅尔:确定。

我:谢谢。梅尔，我们第一次见面时，你对我来说是个谜。
梅尔:真的吗？击球手出局了吗

我:你由两个概念组成，它们的全部目的是使抽象的概念对人类来说是可理解的——梅尔标度和光谱图——然而你自己对我这个人类来说很难理解。梅尔:这种片面的讲话有什么意义吗？

我:你知道更困扰我的是什么吗？我听说你是 DSP (数字信号处理)领域的 buzzz ，但是我在网上很少找到关于你的直观信息。梅尔:我应该为你感到难过吗？

我:所以无论如何，我不想让你被误解，所以我决定写你。
梅尔:啧啧。这其实挺好的。希望现在有更多的人理解我。

我:很乐意，我的朋友。我想我们可以谈谈你的核心元素是什么，然后用 python 上的librosa包展示一些好看的招数。梅尔:哦，太棒了！我爱 librosa！它可以用一行代码生成我！

我:太好了！让我们在这篇文章中用这首美丽的鲸鱼歌曲作为我们的玩具例子吧！你怎么想呢?梅尔:你知道你在自言自语，对吗？

声谱图

视觉化声音是一种恍惚的概念。有一些迷人的方法可以做到这一点，也有更多的数学方法，我们将在这篇文章中探索。

Photo credit: Chelsea Davis. See more of this beautiful artwork here.

当我们谈论声音时，我们通常谈论一系列不同压力强度的振动，所以想象声音有点像想象空气波。**

但这只是这首复杂而丰富的鲸鱼歌曲的二维表现！
声音的另一种数学表示是傅立叶变换。不需要太多的细节(观看这个教育视频以获得易于理解的解释)，傅立叶变换是一种功能，它将时域中的信号作为输入，并将其分解为频率输出。

让我们以一个短时窗为例，看看应用傅立叶变换会得到什么。

现在让我们把完整的鲸歌分成几个时间窗口，并在每个时间窗口上应用傅立叶变换。

哇，这里看不到什么，是吗？这是因为人类听到的大多数声音都集中在非常小的频率和振幅范围内。

让我们做另一个小调整——将 y 轴(频率)转换为对数标度，将“颜色”轴(振幅)转换为分贝，这是振幅的对数标度。

这就是我们所说的声谱图！

熔融标度

让我们暂时忘记所有这些可爱的形象化，谈谈数学。从数学上来说，Mel 标度是频率标度的一些非线性变换的结果。这种 Mel 标度被构造成使得在 Mel 标度上彼此距离相等的声音，对于人类来说也是“声音”,因为它们彼此距离相等。
与 Hz 标度相反，500 和 1000 Hz 之间的差异很明显，而 7500 和 8000 Hz 之间的差异几乎不明显。

幸运的是，有人为我们计算了这个非线性转换，我们需要做的就是使用 librosa 中的适当命令来应用它。

没错。就是这样。但是这给了我们什么呢？
使用重叠的三角形滤波器，将 Hz 标度划分为仓，并将每个仓转换为 Mel 标度中的相应仓。

现在这个给了我们什么？
现在，我们可以获取一个时间窗口的振幅，计算与mel的点积以执行转换，并在这个新的频率范围内获得声音的可视化。**

嗯，还是没什么意义，他？好吧，让我们总结一下，看看我们会得到什么。

梅尔光谱图

我们现在知道什么是声谱图，也知道什么是梅尔标度，所以梅尔声谱图是一个声谱图，相当令人惊讶的是，它以梅尔标度为其 y 轴。

这就是如何用一行代码生成 Mel 光谱图，并使用另外 3 行代码很好地显示它:

概述

Mel 谱图是以下管道的结果:

分离到窗口:用大小为n_fft=2048的窗口对输入进行采样，每次进行大小为hop_length=512的跳跃来采样下一个窗口。
对每个窗口进行 FFT (快速傅立叶变换)，从时域变换到频域。
生成 Mel 标度:取整个频谱，并将其分成n_mels=128均匀间隔的频率。
我们所说的均匀分布是什么意思？不是通过频率维度上的距离，而是人耳听到的距离。
生成谱图:对于每个窗口，将信号的幅度分解成其分量，对应 mel 标度中的频率。

未完待续…

现在我们知道了梅尔光谱图和尼奥，我们要用它做什么？

好吧，那是另一个帖子…

与此同时，你有没有利用 Mel 光谱图做一些疯狂的项目？请在评论中分享！

通过 3 个简单的步骤获取天气数据

原文：https://towardsdatascience.com/getting-weather-data-in-3-easy-steps-8dc10cc5c859?source=collection_archive---------5-----------------------

Photo by Max LaRochelle on Unsplash

继续我们的数据收集之旅，这次我们将看看如何收集天气数据。天气数据的应用是无穷无尽的，从独立的天气预报应用到天气分析只是更大目标的一个组成部分的项目。

在我的团队帮助俄亥俄州辛辛那提市改善其紧急医疗响应系统的项目中，我个人发现需要访问天气数据。我的团队需要使用每日天气数据作为模型中的预测器，来预测整个城市的应急响应水平。

我们将从最可靠的来源获得天气数据， NOAA (美国国家海洋和大气管理局)。

既然我现在住在美丽的加州长滩，让我们通过尝试回答以下问题来引导我们的探索:

【2015 年以来，长滩的日平均气温变化如何？

我们开始吧！

1.向 NOAA 请求访问令牌

为了从 NOAA 请求数据，我们将需要请求一个访问令牌，它基本上确认我们是请求数据的可信来源。导航至请求令牌网站。

Request an Access Token from NOAA

填写一个电子邮件地址，您很快就会收到一封包含您的访问令牌的电子邮件。把它存放在安全的地方，保持私密。否则，其他人可能会代表你向 NOAA 提出请求，而你不一定希望这样。

2.确定要访问哪个气象站

下一件你可能想做的事情是找出从哪个气象站收集数据。找到该电台最简单的方法是导航到查找电台网站

根据您的首选位置、数据集首选项(选择每日概要获取每日数据)、时间范围(您选择的范围越长，越少的站将拥有完整的数据)和数据类别(我们只关心手头任务的气温)。

页面右侧的地图将自动更新可用的电台。

对于这个应用程序，我们将选择长滩机场站。请务必记下电台 ID。对我们来说就是 GHCND:USW00023129。

3.抢数据！

现在我们有了访问令牌，并且知道了我们希望访问的站点的 ID，剩下要做的就是向 NOAA 请求数据。我们将使用 Python 的请求库来完成这个任务。

首先让我们用 Python 导入所需的库。

为了向 NOAA 请求数据，我们需要使用 NOAA 的 API (应用程序编程接口)，它基本上只是与 NOAA 通信以请求数据的特定语言。

让我们来看一下 NOAA API 请求的结构。

基本请求如下所示:

https://www.ncdc.noaa.gov/cdo-web/api/v2/data?

在问号后面，'？'，我们将需要把所有的选项指定确切的数据，我们正在寻找。这些将包括:

datasetid ，对我们来说就是 GHCND (全球历史气候网络日报)。
datatypeid ，这是我们要寻找的变量列表。对我们来说，那将是平均气温
限制，指定响应中包含的最大项数。默认是 25，最大是 1000 ，这是我们要设置的。
stationid ，指定我们想要哪个(些)站的数据。我们的站号是 GHCND:USW00023129
开始日期 和 结束日期 ，指定我们希望从中获取数据的日期范围。我们将每年调用一次 API，因为 1000 个项目对于我们从 2015 年到现在的整个 3.5 年的日期范围来说是不够的。

总之，我们对 2015 年所有数据的第一个请求如下:

【https://www.ncdc.noaa.gov/cdo-web/api/v2/data? datasetid = GH CND&data typeid = TAVG&limit = 1000&station id = GH CND:usw 00023129&start date = 2015-01-01&end date = 2015-12-31

让我们看看进行 API 调用的代码:

现在是将收集的数据存储为数据帧的代码:

由生成的数据帧制成的图表如下所示:

好看！因此，我们成功地请求、处理并报告了自 2015 年 1 月以来加州长滩的日平均气温。

事实上，NOAA API 内置了更多的选项。查看完整文档。我认为浏览 NOAA API 的一个完整的具体用例是一个好的开始。

~数据采集快乐！😃

整理您的数据

原文：https://towardsdatascience.com/getting-your-data-straight-96ea6295867a?source=collection_archive---------24-----------------------

经理和企业主指南。

“大数据”现在风靡一时。这是多年来在“热门词汇前 40 名”中排名靠前的词汇之一，但有很好的理由:数据正迅速成为一种新的资产类别，因此也应该如此对待。此外，代替 2018 年最近的数据丑闻(脸书、MyHeritage、Aadhaar)，越来越明显的是，需要在数据质量和数据安全方面达成更大的共识。

幸运的是，存在与实物资产管理、质量和风险相关的完整知识体系——其中的每一个现在都可以被利用和调整，以帮助管理我们更难以捉摸的朋友:数据——以及从中收集的信息。

大量涌入的数据

在整个人类历史中，超过 90%的数据都是在过去的两年中产生的——这种惊人的快速发展没有显示出放缓的迹象；据《经济学人》报道，到 2020 年，每人每秒将产生近 2MB 的数据。

当观察财富 500 强公司的领导层时，大约五分之三的领导者认为，未能成为数据驱动很可能导致过时。因此，分析公司数据将成为保持竞争力的核心，这已成为常识。

两层

需要理解的是，世界正日益分为两层——物理层和数字层；我们也越来越多地与物理层的代理交互，而不是像过去那样直接与它交互。在资产管理(AM)行业，当与大公司打交道时尤其如此——每个公司都拥有大量有价值的实物资产。

我们非常熟悉的物理层是实际的物理世界。它是你的基础设施、工厂、机器和设备——当然，还有你的员工；50 年前，你需要直接管理——通过观察和指挥链。

数字层由数据和信息组成。它是你的 It 和财务系统，你的协议和机器数据，你的网络和社交媒体；它是一个数字足迹，包含物理层可以提供的所有信息——随着数字化和超连通性的发展，这一层也在增长。

The World is Being Divided into Two Layers (CREDIT: Grahame Fogel, Gaussian Engineering, 2018)

物理层的管理代理数量众多，可以是您的 SCADA 系统、您的物联网管理门户、您的 ERP 系统和商业智能仪表板等等。

但是，重要的是要认识到，所有这些代理(通过它们来管理物理层)都依赖于您的数据。整理数据极其重要，因为有了坏数据，你与物理世界的联系就会动摇，组织很容易陷入混乱和无序。在这个领域中，决策是基于通常不正确的信息做出的，而决策本身会导致行动，这些行动会通过一个复杂的、官僚的电话故障游戏过滤掉。

产业的碰撞

现在是上述各层提供整个行业碰撞和融合的背景的时候。行业颠覆大体上是关键技术和消费者行为演变的结果——这种行为通常是技术格局变化的结果。从广义上来说，关键技术颠覆在以前局限于自己领域的行业之间创造了融合节点。

最先经历这种融合的行业是科技、媒体和电信:我们现在已经习惯于通过电信公司观看电影和电视剧，通过科技公司购买书籍和音乐。

如今，新一轮行业融合正变得越来越明显。在这里的高斯，我们相信这是两个，最值得注意的:

医疗保健、消费品、保险
公用事业、建筑空间、交通和电信的融合

The Next Wave of Industry Collision (Credit: Author on Canva)

在南非，我们已经看到第一波浪潮在我们面前展开，Discovery 和 Momentum(两家当地保险提供商)开始利用各种智能设备来监控客户的健康并将数据与他们的产品联系起来。

第二波浪潮是我们 Gaussian 最感兴趣的——这一波浪潮将推动“智能城市”的普及；是实物资产真正与无形资产相遇的浪潮；在这一浪潮中，公用事业公司开始重新思考并转变其运营，以利用实时数据；这是断电管理、分布式电源和高级资产管理的浪潮。所有这些都是通过使用数据实现的。

所以这个数据最好是对的。

孤岛式数据集成的可怕之处

我们最近参与了一个煤矿项目；我们被要求分析他们的数据，并帮助他们做出更好的决策。我们发现该矿从各种来源收集数据，并将其存储在不同的地方:

他们的财务数据存储在 SAP(他们的企业资源规划或 ERP 系统)中
他们的交易数据存储在他们的计算机化维护管理系统(CMMS)中
他们的石油分析结果存储在各种 Excel 电子表格中
他们的主数据存储在一个独立的、自托管的数据库中
他们的安全事故数据存储在安全事故应用程序中

整合这个数据，类似于美国人、意大利人、法国人、西班牙人、瑞典人；每个人都有不同的有价值的知识；坐下来试着玩琐碎的追求。他们都说不同的语言。协作很难。

Siloed Data Can Prove an Immense Challenge for Organizations Wishing to Make Use of Data Analytics (Credit: Author on Canva)

同样，集成来自各种来源的数据是乏味的、耗时的，有时甚至是完全不可能的！经常会有大量重复的信息；每个源以不同的名称或不同的格式引用事物(员工、资产、日期);很多数据最终都没有被使用。

如果上述情景听起来和你自己的公司非常相似，你并不孤单！这是(不幸的)许多大中型组织的情况；确保数据质量并非易事。

ISO 8000 是数据质量和交换的全球标准，为这类问题提供了解决方案。

标准的重要性

标准是建立规范和程序的已发布文档，它们有助于描述提高兼容性和互操作性的协议。大多数标准都是为在合同中使用而设计的，所以做生意的人可以确保他们“在同一页上”，可以这么说。

当一项标准在全球范围内被采用时，它有助于大大降低成本并促进国际贸易——然而，要想有机会在全球范围内被采用，标准本身必须具有一定的质量。标准的质量主要取决于两个因素，即:

开发它的领域专家的专业知识和声誉
用于建立共识的过程

可能最大和最著名的标准组织是国际标准化组织或 ISO 这是一个独立的非政府组织，由 163 个国家标准机构组成。正如他们在自己的网站上提到的，ISO 成立的初衷是回答一个基本问题:“做这件事的最佳方式是什么？”。

ISO 从更明显的东西开始，如重量和其他测量方法，但在过去的 50 年里发展成为一个标准家族，涵盖了从我们穿的衣服到我们视频聊天的 Wi-Fi 网络的一切。

但是我们最感兴趣的标准——也是最高管理层应该感兴趣的标准——是 ISO 的一套管理系统标准。这些标准提供了清晰的定义，组织应该用这些方法来管理业务的相互关联的部分，以实现他们的目标。有几种 ISO 管理体系标准，其中几种列举如下:

ISO 45001 |职业健康和安全管理
ISO 14001 |环境管理
ISO 9001 |质量管理
ISO 55000 |资产管理
ISO 8000–61|数据质量管理
ISO 31000 |风险管理

当我们聚焦于数据时，ISO 8000——数据质量和交换的标准——是最相关的。通过实施这些文档中的原则，组织可以确保持续维护高质量的可移植数据，这些数据独立于应用程序，并且对制定战略和运营决策非常有用。

对综合管理系统的需求

有趣的是——也值得考虑的是——随着行业的合并和新行业的出现，这些标准之间的界限变得越来越模糊。除此之外，上述管理标准其实极其相似。这些标准中的每一个都共享一个 计划-执行-检查-行动 结构，并具有类似的要求，例如:

记录系统
控制文件和记录
培养
内部审计
纠正/预防措施
管理评审

这里的要点是: 组织需要整合一个 集成管理系统，首先允许制定数据驱动的决策，包括运营决策和战略决策。

There is an Increasing Need for a Data-Driven, Integrated Management System (Credit: Author on Canva)

一体化管理体系的好处怎么强调也不过分。您的组织将体验到更高的效率、有效性和成本降低；同时最大限度地减少因需要多次年度审计而造成的干扰。IMS 允许管理团队依靠一个系统来实现他们组织的目标；它允许他们将他们的系统和流程整合在一起，并确保他们作为一个具有统一目标的单一单位工作。

未来属于能适应的人；变形者、早期采用者和创意者；那些能够创建组织，将所有这些东西集合在一起并统一起来的人。但最重要的是，未来属于那些为未来做打算的人。

我们将很快发布一个由 6 部分组成的博客系列，详细介绍开发一个数据驱动的集成管理系统的过程。保持关注@ 高斯工程、资产和数据管理专家。

使用 TensorFlow 2.0 和 Keras API

原文：https://towardsdatascience.com/getting-your-hands-dirty-with-tensorflow-2-0-and-keras-api-cc8579eb0915?source=collection_archive---------12-----------------------

深入研究使用 TensorFlow 2.0 和 Keras API 创建回归模型的技术细节。在 TensorFlow 2.0 中，Keras 自带 TensorFlow 库。API 得到了简化，使用起来更加方便。

Source: Pixabay

TensorFlow 2.0 内部打包了 Keras，没有必要将 Keras 作为单独的模块导入(虽然如果需要也可以这样做)。TensorFlow 2.0 API 进行了简化和改进。这对我们——机器学习开发者来说是个好消息。

现在，您可以这样从 TensorFlow 导入 Keras:

from tensorflow import feature_column
from tensorflow import keras
from tensorflow.keras import layersprint(tf.__version__)
2.0.0

我正在使用 tf.data 输入管道来编码分类列，Keras API 与 tf.data 配合得很好。tf.data 的一个主要优势是它充当了数据和模型之间的桥梁。无需自己转换数据，只需定义转换规则，转换后的数据将自动应用于训练。

数据从 CSV 文件提取到 Pandas 数据帧:

column_names = ['report_id','report_params','day_part','exec_time']
raw_dataframe = pd.read_csv('report_exec_times.csv')
dataframe = raw_dataframe.copy()dataframe.head()

report_params 的列值各不相同，我们需要对该列进行规范化(使值处于相似的范围内):

eps=0.001 # 0 => 0.1¢
dataframe['report_params'] = np.log(dataframe.pop('report_params')+eps)

我使用一个实用的方法(这个方法取自 TensorFlow 教程)从熊猫数据帧创建 tf.data 数据集:

def df_to_dataset(dataframe, shuffle=True, batch_size=32):
  dataframe = dataframe.copy()
  labels = dataframe.pop('exec_time')
  ds = tf.data.Dataset.from_tensor_slices((dict(dataframe), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(dataframe))
  ds = ds.batch(batch_size)
  return ds

接下来，我们需要为分类列编码定义数据映射。我用的是 TensorFlow 词汇列表函数，包括所有唯一值的映射(如果值很多，用嵌入 API 会更好)。两列被编码— 报告 _id 和日 _ 部分:

feature_columns = []feature_columns.append(feature_column.numeric_column('report_params'))report_id = feature_column.categorical_column_with_vocabulary_list('report_id', ['1', '2', '3', '4', '5'])
report_id_one_hot = feature_column.indicator_column(report_id)
feature_columns.append(report_id_one_hot)day_part = feature_column.categorical_column_with_vocabulary_list('day_part', ['1', '2', '3'])
day_part_one_hot = feature_column.indicator_column(day_part)
feature_columns.append(day_part_one_hot)

使用 TensorFlow 编码在数组外创建 Keras 密集要素图层。我们将在 Keras 模型构建期间使用该层来定义模型训练特征:

feature_layer = tf.keras.layers.DenseFeatures(feature_columns)

我们已经完成了功能。接下来，在实用函数的帮助下，将 Pandas dataframe 转换为 tf.data:

batch_size = 32
train_ds = df_to_dataset(train, batch_size=batch_size)
val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)
test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)

定义 Keras 顺序模型时使用密集特征层(无需将特征数组传递到 fit 函数中):

def build_model(feature_layer):
  model = keras.Sequential([
    feature_layer,
    layers.Dense(16, activation='relu'),
    layers.Dense(16, activation='relu'),
    layers.Dense(1)
  ]) optimizer = keras.optimizers.RMSprop(0.001) model.compile(loss='mse',
                optimizer=optimizer,
                metrics=['mae', 'mse'])
  return model

通过 model.fit 功能执行训练。我们使用 tf.data 输入管道来通过训练和验证集:

history = model.fit(train_ds,
              validation_data=val_ds,
              epochs=EPOCHS,
              callbacks=[early_stop])

令人惊叹的是，数据编码发生在幕后，基于为要素图层定义的规则。

如何用 tf.data 和 feature 图层运行 model.predict 函数？很简单。

用输入数据构建熊猫数据框架:

headers = ['report_id', 'report_params', 'day_part']
dataframe_input = pd.DataFrame([[1, 15, 3]],
                                columns=headers, 
                                dtype=float,
                                index=['input'])

将 report_params 值转换为与训练时相同的比例:

eps=0.001 # 0 => 0.1¢
dataframe_input['report_params'] = np.log(dataframe_input.pop('report_params')+eps)

从 Pandas 数据帧创建 tf.data 输入管道:

input_ds = tf.data.Dataset.from_tensor_slices(dict(dataframe_input))
input_ds = input_ds.batch(1)

运行模型预测功能:

res = model.predict(input_ds)
print(res)

资源:

带有示例数据的源代码可以在我的 GitHub repo 上获得

尽情享受吧！

基尼指数与信息熵

原文：https://towardsdatascience.com/gini-index-vs-information-entropy-7a7e4fed3fcb?source=collection_archive---------1-----------------------

关于杂质测量和信息增益，您需要了解的一切

Source

简介:

对数据科学家来说，杂质/信息增益的度量，尤其是基尼指数和熵，是有趣且实用的概念。下面我们将通过简单易懂的例子来深入探讨这些概念。

背景:

决策树根据目标变量的纯度递归分割特征。该算法旨在找到最具预测性特征的最佳点，以便将 1 个数据集分成 2 个数据集。这两个新数据集的目标变量将比原始数据集的更纯。

然而，“纯粹”是这里的关键词。这个词到底是什么意思？在一般意义上,“纯洁”可以被认为是一个群体的同质化程度。但是同质性可能意味着不同的东西，这取决于你的决策树运行在哪个数学主干上。决策树的决策的两个最受欢迎的支柱是基尼指数和信息熵。

下面这三个例子应该能让大家明白这一点:

如果我们有 4 个红色口香糖球和 0 个蓝色口香糖球，那么这 4 个口香糖球就是 100%纯的。

如果我们有 2 个红色和 2 个蓝色，那么这个组是 100%不纯的。

如果我们有 3 个红色和 1 个蓝色，如果我们分别使用基尼系数或熵，则该组的纯度为 75%或 81%。

为什么这很重要？根据使用的杂质测量，树分类结果可能会有所不同。这可能对您的模型产生很小(有时很大)的影响。

基尼指数直觉:

让我们从基尼指数开始，因为它更容易理解。根据维基百科，目标是“测量从集合中随机选择的元素被错误标记的频率”[1]。

为了形象化，让我们回到口香糖的例子。如果我们决定任意将 4 个口香糖球都标记为红色，其中一个口香糖球被错误标记的频率是多少？

4 红色和 0 蓝色:

杂质测量值为 0，因为我们永远不会错误地标记这里的 4 个红色口香糖球中的任何一个。如果我们任意选择将所有的球标为“蓝色”，那么我们的指数仍然是 0，因为我们总是错误地给口香糖球标上标签。

无论你选择哪个阶层的概率，基尼系数总是一样的，因为在上面的公式中，基尼系数总是等于 0。

基尼系数为 0 是最纯粹的分数。

2 红 2 蓝:

杂质测量值为 0.5，因为我们有一半时间会错误地给口香糖球贴上错误的标签。因为该指数用于二元目标变量(0，1)，0.5 的基尼指数是最不纯粹的分数。一半是一种类型，一半是另一种类型。将基尼系数除以 0.5，有助于直观理解该系数代表什么。0.5/0.5 = 1，意味着分组尽可能不纯(在只有 2 个结果的组中)。

3 红色和 1 蓝色:

这里的杂质测量值是 0.375。为了更直观的理解，如果我们将此除以 0.5，我们将得到 0.75，这是错误/正确标记的概率。

熵直觉:

由于等式中的对数，熵的计算量更大。像基尼一样，基本思想是通过目标变量来衡量一个群体的无序程度。这种方法不是利用简单的概率，而是采用概率的对数基数 2(然而，只要你是一致的，你可以使用任何对数基数)。熵方程使用对数，因为它有许多有利的性质。主要优点是它提供的附加性能。这些麻省理工学院的讲座笔记将有助于更清楚地掌握这个概念(pg8) [2]。

让我们用同样的口香糖场景来想象熵是如何工作的:

4 红色和 0 蓝色:

不出所料，熵的杂质测量值也是 0。这是使用信息熵的最大纯度分数。

2 个红色和 2 个蓝色:

此处的杂质测量值为 1，因为这是可获得的最大杂质。

3 红色和 1 蓝色:

这里的纯度/杂质测量值是 0.811，比基尼系数差一点。

形象化

让我们用 python 中的一些代码来可视化基尼和熵曲线:

基尼系数:

下面我们制作一个函数来自动计算基尼系数。

#Gini Function
#a and b are the quantities of each class
def gini(a,b):
    a1 = (a/(a+b))**2
    b1 = (b/(a+b))**2
    return 1 - (a1 + b1)

与我们的口香糖主题保持一致，让我们做一个循环，计算任何可以想象的红色和蓝色口香糖彩车组合的基尼系数，加到 4。我们将对上述基尼函数进行 10，000 次迭代，以便稍后绘制基尼曲线。

#Blank lists
gini_list = []
blue_list = []
red_list = []
blue_prob_list = []#Looping Gini function on random blue and red float amounts
for x in range (10000):
 blue = random.uniform(0, 4)
 red = abs(4-blue)
 a = gini(red,blue)
 b = blue/(blue+red)
 gini_list.append(a)
 blue_list.append(blue)
 red_list.append(red)
 blue_prob_list.append(b)#Dataframe of amount of blue, red, Probability of blue, and gini score
df = pd.DataFrame({“Blue”: blue_list, “Red”: red_list,”Gini Score”: gini_list, “Probability of Blue”: blue_prob_list})
df = df[[‘Red’, ‘Blue’, ‘Probability of Blue’, ‘Gini Score’]]
df

数据帧的开头在下面。其他 9994 行装不下。

现在我们将绘制我们的曲线:

plt.scatter(blue_prob_list,gini_list)
plt.xlabel(‘Probability of Blue Gumball %’)
plt.ylabel(‘Gini’)
plt.title(‘Gini Curve’)

熵:

#Gini Function
#a and b are the quantities of each class. Base is the log base input.
def entropy(base,a,b):
    try:
        var =  abs(((a)/(a+b)) * log(((a)/(a+b)),base)) - (((b)/(a+b)) * log(((b)/(a+b)),base))
        return var
    except (ValueError):
        return 0#Blank lists
ent_list = []
blue_list = []
red_list = []
blue_prob_list = []#Loop with log base 2
for x in range (10000):
    blue = random.uniform(0, 4)
    red = abs(4-blue)
    a = entropy(2,red,blue)
    b = blue/(blue+red)
    ent_list.append(a)
    blue_list.append(blue)
    red_list.append(red)
    blue_prob_list.append(b)df = pd.DataFrame({"Blue": blue_list, "Red": red_list,"Entropy": ent_list, "Probability of Blue": blue_prob_list})
df = df[['Red', 'Blue', 'Probability of Blue', 'Entropy']]
df

对比:

基尼是蓝色的，熵是橙色的。在下一节中，您将看到这些差异是如何在信息增益中体现出来的！

信息增益

信息增益是杂质如此重要的原因。一旦我们获得了数据集的杂质，我们就可以看到当我们沿着树向下并测量节点的杂质时获得了多少信息。

Source [3]

在下面的例子中，我们通过一个特定的属性(比如口香糖的大小)来分割口香糖偏好。它给出了父/子节点关系:

基尼系数信息增益(根据上面的等式)

#Defining Gini info gain function:def gini_info_gain(pa,pb,c1a,c1b,c2a,c2b):
    return (gini(pa,pb))-((((c1a+c1b)/(pa+pb))*gini(c1a,c1b)) + (((c2a+c2b)/(pa+pb))*gini(c2a,c2b)))#Running Functiongini_info_gain(22,13,18,2,4,11)

= 0.196 基尼信息增益

0.196/0.467 = 41.97%的增益

熵信息增益(来自上面的等式)

#Defining Entropy info gain function:def entropy_info_gain(base,pa,pb,c1a,c1b,c2a,c2b):
    return (entropy(base,pa,pb))-((((c1a+c1b)/(pa+pb))*entropy(base,c1a,c1b)) + (((c2a+c2b)/(pa+pb))*entropy(base,c2a,c2b)))#Running Functionentropy_info_gain(2,22,13,18,2,4,11)

= 0.325 熵信息增益

0.325/0.952 = 34.14%的增益

对于这个例子，基尼具有更高的信息增益测量。

最终要点:

基尼的最大杂质是 0.5，最大纯度是 0
熵的最大杂质是 1，最大纯度是 0
不同的决策树算法利用不同的杂质度量:CART 使用 GiniID3 和 C4.5 使用熵。在您的模型中使用决策树/随机森林之前，这是值得研究的。

*本出版物中的所有代码都可以在我的 github 上找到这里

来源:

[1]https://en . Wikipedia . org/wiki/Decision _ tree _ learning # Gini _ infinity

[2]http://web.mit.edu/6.02/www/f2011/handouts/2.pdf

[3]f . Provost 和 t . Fawcett(2013 年)。商业数据科学:你需要了解的数据挖掘和数据分析思维。加利福尼亚州科隆:奥赖利。

考虑通过我的推荐链接加入 Medium:https://andrewhershy.medium.com/membership

如果您觉得这很有帮助，请订阅。如果你喜欢我的内容，请查看其他几个项目:

随机森林是否优于 Logistic 回归？(一比较)

Excel vs SQL:概念上的比较

用 Python 中的逻辑回归预测癌症

利用数学和 Python 优化你的投资

从头开始计算 R 平方(使用 python)

Python 中的字云:综合示例

Git 基础

原文：https://towardsdatascience.com/git-basics-ec81696be4e6?source=collection_archive---------27-----------------------

Photo by Yancy Min on Unsplash

Git 被用作版本控制软件——用于维护软件的多个版本。

但是现在，它的用途远不止于此——与他人协作、代码版本控制、共享、将代码从本地机器部署到临时服务器，即“将代码部署到云”等等。

Git 是做什么的？

假设从代码的第一个版本开始，Git 不仅允许我们访问我们代码的最新版本，而且所有添加/删除的代码行都被跟踪，我们知道我们项目的所有历史。
Git 非常擅长在不同的人之间同步代码。Git 将代码存储在一个远程服务器中，因此我们的合作伙伴可以访问相同的代码。当多人对代码进行更改时，Git 会保留一个更新的代码版本，该版本合并了所有更改，因此团队中的每个人都在同一页面上。
Git 非常擅长测试代码。在对代码进行修改和测试以查看其工作情况时，Git 允许我们维护代码的原始副本。我们可以在测试完新代码后恢复它，或者如果对新代码满意，用原来的代码替换它。因此，Git 在允许恢复到旧版本的代码方面做得很好。

Git 与之通信的远程服务器是什么？

Git 与托管存储库(保存所有代码和跟踪变更的中央存储位置)的远程服务器通信。许多 Git 托管站点包括 Github、Bitbucket、Gitlab、Beanstalk 等，它们用于在互联网上存储 Git 存储库，以便进行软件开发版本控制。我们可以将我们的存储库“推”到远程服务器，这样我们的合作者和互联网上的其他人也可以看到并参与这些项目。同样，我们可以“克隆”我们想要工作的项目的存储库。

Git 命令

存储库的 url 托管在 Github/Bitbucket 或任何其他远程服务器上——我们希望将它下载到我们的计算机上
git add <filename>:这个文件是我们下次保存存储库副本时想要跟踪的文件。请记住，我们必须位于包含要添加的文件的目录中。
git add *:添加所有未保存的文件，这显然比 git 添加单个文件要快。然而，将添加和提交分开使我们能够控制我们的存储库，并使我们能够指定我们想要跟踪的变更。
git commit -m "message":这个命令只是保存对存储库所做的更改。-m 代表方法。该消息应该描述我们在“提交”中所做的任何更改。这非常有用，因为我们可以返回到描述一系列变化的消息列表。
git status:告诉我们我们的知识库中当前正在发生什么

我们如何将我们在本地所做的任何更改发送到托管站点？

将代码从我们的电脑上传到储存在互联网上的知识库中。结果，主机端，例如 GitHub，现在能够跟踪它了。
git pull:该命令用于在本地计算机上下载最新版本的存储库。

合并冲突——Git 将尝试合并所有的更改。但是，当对一个特定文件的相同行进行了多次更改时，可能会出现冲突，这会导致我们试图运行git pull时出现冲突。在这种情况下，因为合并不能发生，所以拉不能发生。出现一条消息，显示“自动合并失败。您需要解决冲突，然后提交结果。”在决定要保留哪些修改后，必须进行修改。

git log:显示所有提交的历史记录。每个提交都可以通过唯一的提交哈希来区分。
git reset --hard <commit hash>:将存储库重置回提交哈希指定的版本。
git reset --hard origin/master : origin/master表示存储库的版本，它是我们从中获得它的存储库的来源。

注意:对我们计算机上的存储库所做的任何更改都不会影响主机站点上正在进行的在线操作，除非我们对它进行了那些更改。

暂时就这样吧！点击此处获取更多 Git ！

饭桶

原文：https://towardsdatascience.com/git-for-noobs-7a846ce98c9a?source=collection_archive---------6-----------------------

Git:什么，为什么，怎么做。

每个参与计算机科学/软件/编程世界的人无疑都听说过 Git 。但是我们真的知道 Git 是什么吗，以及我们为什么要使用它吗？它的基本理念是什么？Git、 Github 、 GitLab 和其他类似 Bitbucket 的平台有什么区别？

如果你想学习所有这些东西，请继续阅读。我们将讨论 Git 的历史、它的目的和理念，然后在构建一个真实项目的同时，更深入地了解它的主要功能和特性。

不要感到不知所措，在这篇文章结束时，你会完全理解什么是 git，为什么它在软件开发中如此重要，以及你如何利用它为我们服务。让我们继续吧！

介绍

Logo of git

Git 是世界上最流行的版本控制系统(VCS)。

什么是 VCS？非常简单:VCS 是一个软件，它帮助管理随着时间的推移对特定代码所做的更改。

如果您有一个名为 CatImageDetector.py 的文本文档，并且您一直在对其进行更改，如果使用得当，VCS 将跟踪这些更改，这样，如果您想返回到与您编辑的上一个版本不同的版本(例如，因为代码不再正常工作)，您可以轻松地做到这一点。

上一段有一些值得强调的内容:像 Git 这样的 VCS 被认为是为了跟上变化并存储文本文档。它们不是用来存储数据的；为此，我们有许多其他平台。因此，有时他们很难跟上 Jupyter 笔记本等格式的变化。

Git 背后的理念与通常的本地文档重写形成对比，我们做所有的事情——我们编辑一个文档，但只能看到它的最后一张图片——如果我们想回到以前的版本，我们可能做不到。

这种系统(VCS)在和不同的人一起工作时也非常有价值。假设你和另外两个同事一起做一个项目:你们都在修改相同的文档，并且希望这种协作尽可能有效。正如我们将在后面看到的，Git 允许您以尽可能好的方式做到这一点(如果遵循某些准则的话)。

我认为，这两点是 Git T1 背后的主要思想:允许用户管理他们的软件项目，以便在每一个期望的变更后备份代码，并保护项目免受团队协作时可能出现的一些不一致的影响。

Git 也有一些特殊性，使它更加引人注目，比如它的分布式特性，它是跟踪文档不同版本的方式(使用 Deltasδ:相邻版本之间的变化)，它的性能或者它的安全性，但是这些问题将在后面讨论，或者超出了本文的范围。

让我们继续，简单看看 Git 是如何诞生的。

Git 的历史

Logos of Linux and git

Git 的历史与 Linux 的历史紧密相连。Linux 操作系统内核的起源——来自世界各地的开发人员都在为这个项目做贡献——要求存在一个有效的版本控制系统，让每个人都能以有序和系统的方式工作。

2005 年，这些开发人员在工作中使用的 VCSBitKeeper从免费变成了收费，因此寻找新 VCS 的竞赛开始了，最好是一个分布式的。

这个项目的首席开发人员 Linus Torvalds 过了一段时间后决定，如果他找不到适合未来任务的完美 VCS，他就自己造一个。git 就是这样诞生的。

您可能想知道 git 实际上代表什么。这个答案起初并不明显，一旦我们知道了它，并且知道了它被创造出来的目的之后，它就变得明显了。 GIT 代表“全球信息跟踪者”。

酷吧？好吧，让我们更专业一点。

Git 基础——使用组

如前所述，Git 的优点之一是它有效地允许我们与来自世界各地的人们一起工作。然而，为了这种合作的成功，我们不能只是以我们认为合适的方式使用 git，并希望我们的同事理解我们所做的，并相应地推动他们的行动；必须遵循一些指导方针。

但是首先，在定义这些准则之前，让我们描述一下 git 的一些基本元素:存储库和分支。

存储库和分支

一个存储库，尽管它的名字很长，最好理解为一个文件夹，就像我们电脑中的文件夹一样，我们正在处理的所有元素都存储在那里。

在同一个项目中工作的人将从同一个存储库中进行修改、上传文档和下载文档。

分支是促进自组织和协作工作的工具。项目通常从称为主分支的初始分支开始，并从那里构建多个其他分支，形成树状结构。

Repositories tree-like structure

为什么要这样做？想象一下，你正在和 4 到 5 个不同的人一起做一个项目，他们和你一样修改相同的脚本，但是实现不同的功能。如果你们都不断地上传对主分支上相同内容的修改，一切很快就会变得混乱。相反，每个人都应该在他们自己的分支上工作，在那个分支上实现变更，并且当所有的事情都在他们自己的分支上完美地工作时，这些变更应该被小心地合并。

指南和 Git-Flow

现在我们知道了什么是(存储库的简称)和分支，让我们看看正确使用它们的指导方针。上一段的描述只是一个简单的例子来说明什么是分支，但是使用它们不仅仅是为每个开发人员/特性创建一个分支，然后将它们组合在一起那么简单。

我们已经谈到了主分支，说它是任何项目的根或主要分支，但是我们没有给予它应有的重要性。主分支是存储项目的最新工作或生产代码的分支，只应在上传将要实际使用的经过全面测试的代码时使用。这里上传的任何东西都应该可以投入生产了。

如果我们不能触及主要分支，那么我们如何构建代码呢？简单:我们创建另一个分支，通常称为 develop，，这是我们实际开发代码的地方，也是我们不断进行更改的地方。

等等，当上述情况发生时会发生什么，例如，我们有许多人在同一代码库的不同功能上工作？你可能会猜到答案:我们从 develop 分支出分支，并在那里工作，一旦我们完成工作，就将更改上传到 develop，并检查与其他开发人员的代码没有冲突。

Image from: https://nvie.com/posts/a-successful-git-branching-model/

然而，当只有少数开发人员接触开发分支上的相同代码时，可能没有必要从它创建多个分支。此外，有时我们可能希望从存储库中的某个点开始创建一个分支，以便从那里为产品的不同版本或发布开发新的特性。

当来自开发的代码已经被测试、测试、再测试，是的，再测试，然后我们可以上传变更到我们的主分支。

最普遍接受的方法是通过所谓的Git-Flow**完成，您可以在这里找到:**

** [## 一个成功的 Git 分支模型

在这篇文章中，我将展示我为自己的一些项目(包括工作和私人项目)介绍的开发模型…

nvie.com](https://nvie.com/posts/a-successful-git-branching-model/)

现在我们知道了如何有效地处理分支，让我们简单地看一下主要的 git 命令，然后展示一个实际的例子。

Git 命令

我不打算描述所有的 git 命令及其输出，只是为了能够使用 git 来管理项目的代码，您 100%需要了解并熟悉的命令。

status: git status该命令显示您的存储库的当前状态，说明哪些文件已经被修改，哪些文件已经被添加或提交。
branch : git branch返回我们存储库的分支，突出显示我们当前正在处理的分支。

Output of the git branch command

add: git add document.py告诉 git 您想要在下一次提交中包含在 document.py 中所做的更改。

Returns of the git status command before and after adding a file

commit:git commit -m "message"commit 命令基本上记录了您所做的更改，并将其添加(使用之前的命令)到您的本地存储库中。commit 命令有一条消息，通常描述已进行的更改以及通过 commit 上传的更改。

Output of the commit command

我们在文章中提到了 git 的分布式本质，这是它最早的特性之一，但我们并没有真正描述这意味着什么。它被称为分布式,因为每个 git 工作目录都包含一个完整的存储库，其中包含该树的完整历史。

您通常有一个远程存储库(可以配置),从中上传和下载代码，但是 git 的性质并不要求您这样做。

push: git push该命令将您在本地 repo 中所做的更改(通过提交)发送到您已经配置的远程存储库。

Output of the push command

拉:拉是推的兄弟命令。它将远程存储库下载到您的本地机器上。

最后，我们将看到允许我们使用分支的命令:

checkout: git checkout branch就是我们如何从我们所在的分支切换到另一个分支。分支是这个命令是我们想要切换到的分支。checkout 命令也可以用来创建新的分支。使用命令git checkout -b newly_created_branch我们创建一个新的分支并切换到它。

Switching from master to develop

合并: git merge branchToMergeFrom 我一直在说上传，但实际上合并两个分支的词是合并。这意味着将您在一个分支中所做的更改移动到您所在的分支。通常的做法是这样的:想象我们想把我们的变更从开发变成主控。首先，如果我们在开发中，我们必须签出到主节点，然后git merge develop将我们的开发分支中所做的更改传递到我们的主节点分支。请记住，只有当代码已经可以使用并经过测试时，才可以这样做。

Merging from develop to master

这些是使用 git 时需要知道的主要命令。现在您已经了解了它们，让我们探索一下 git 和使用它的各种服务之间的区别！

Git vs GitHub 和其他平台

什么是 GitHub，GitLab，BitBucket，Azure repos 等等？他们和 git 是什么关系？

git and GitHub

我们在这篇文章中多次提到，git 的关键特征之一是它的去中心化特性。这意味着一组用户在他们的本地机器上有 git，知道其他用户的 IP 地址，并使用其对应的凭证建立 HTTP 或 SSH 隧道，一切都可以从他们的伙伴的本地机器推送或向他们的伙伴的本地机器拉取回购。

然而，对于商品来说，如果我们只使用 git 来管理协作，那将会是建立一个远程服务器，让每个人从那里进行推和拉。这难道不会使 git 集中化吗？嗯，从技术上来说不是，因为这个远程服务器不会构成网络的单点故障:如果代码在远程服务器上，这意味着它已经在用户的本地机器上，因此我们可以从那里恢复它。

像 Github、GitLab、或 Bitbucket 这样的服务提供的只是一种高效、有组织、简单的方式来做到这一点，同时还增加了额外的功能，如拉请求和一个闪亮的基于 web 的用户界面。在这种情况下， Git(一个 VCS)是被各种基于 c 语言的服务使用的工具，比如 Github 。Git 是一个管理源代码的开源工具，而 Github 是一个在线服务，git 用户可以通过连接上传或下载资源。Git 是核心，GitHub 和其他服务提供了围绕它的层。

为了让你的代码进入 GitHub，看看这里。最后，让我们看一个简单快捷的例子，展示如何使用 git 来管理 Github 上的一些代码及其工作流。

使用 Github 的 Git 示例

好了，现在我们已经涵盖了所有的理论，让我们来看看一个非常简单的 Github 使用示例。许多现代的 ide，如 Sublime Text、Visual Studio 或 Pycharm，都内置了 git 插件，这样我们就可以轻松地将代码上传到我们之前提到的某个平台上。在我们的例子中，我们将使用 Pycharm。

首先，我们将创建一个新项目，并为它指定我们想要的名称: Git_for_Noobs。然后，在名为 Git_for_medium.py 的脚本中，我们将编写以下代码:

print("Hello Medium!")

保存它，然后继续添加到我们的本地 git repo，并使用消息"First commit of the Git _ for _ Noobs repo "进行第一次提交，如下面的视频所示。

git add and then commit

但是，如果我们现在尝试推送到远程回购，它会给我们一个错误，因为我们还没有配置。首先，我们需要进入项目的 VCS 选项，并创建一个 GitHub 存储库。一旦我们完成了这些，工具可能会为我们推送第一次提交，如果我们正在使用 GitHub，我们会看到一个新的存储库已经创建，如下图所示。

Repository Git_for_Noobs with our first commit

Content for the Git_for_medium.py file

好了，现在我们已经创建了我们的回购并上传了我们的第一个文件，让我们创建一个新的分支并做一些更改。首先，让我们变得更加外向一些，将代码改为如下所示:

print("Hello Internet!")

之后，让我们使用git checkout -b develop创建一个名为 develop 的新分支(默认情况下，当创建一个新的 repo 时，第一个分支将被称为 master ),并将我们的文件 Git_for_medium.py 添加到其中。

Creating a new branch called develop and adding it

最后，让我们提交这些更改，然后将它们推送到 GitHub。

Commit and push

如您所见，push 命令给了我们一个错误，因为我们在远程 repo 中没有一个名为 develop 的分支(它只是在本地创建的)，并且它不知道将我们的代码放在哪里。使用- git--set-upstream origin develop我们告诉它将更改推送到 GitHub repo 中一个新的分支，名为 develop。让我们来看看变化吧！

We now have two branches, master and develop.

现在我们有两个分支，master 和 develop，它们都有不同的代码，因为我们的第二个提交只被推送到 develop 而不是 master。

Contents of the develop and master branches

让我们对我们的脚本做最后的修改，并推动它发展。现在我们已经完全进入外向模式，想和每个人打个招呼。这段代码现在将成为编程社区中最著名的一句话:

print("Hello world!")

现在，一如既往，我们按照这个顺序添加、提交和推送。

add, commit and push changes in our file

在下图中，我们可以看到 develop 分支中代码的最后一种格式(顶部)，以及我们对 repo 所做的所有提交，独立于它们所在的分支(底部)。

Last change to our Git_for_medium.py on develop and all the history of commits to our repo

作为最后一步，让世界知道我们现在是一个更加外向的人，并且更新我们在开发分支中所做的改变以掌握。这可以通过checkout命令(移动到母版)完成，然后合并开发，如下图所示。

Merging from develop to master

在内部，合并工作就像任何其他提交一样，所以在这之后我们还必须使用git push推送我们的远程回购。现在，如果我们看一下主分支，我们有与开发分支相同的代码！酷吧？

Last state of our Master branch after the merge

结论

Git 是一个非常有用的软件开发工具。我们已经看到了它的用途，它不应该用于什么，它的哲学，起源以及与使用它的服务的区别。

更多类似这样的帖子请在 Medium 上关注我，敬请关注！

就这些，我希望你喜欢这个帖子。请随时在 LinkedIn 上与我联系，或者在 Twitter 上关注我。还有，你可以看看我在数据科学和机器学习上的帖子这里。好好读！

额外资源

如果你想了解更多一点，澄清你从这篇文章中学到的东西，或者深入这个主题，我在这里留下了一些信息，我认为可能会很有用。

什么是 git Atlassian 教程

[## 什么是 Git:使用本指南成为 Git 专家| Atlassian Git 教程

到目前为止，当今世界上使用最广泛的现代版本控制系统是 Git。Git 是一个成熟的、积极的…

www.atlassian.com](https://www.atlassian.com/git/tutorials/what-is-git)

Git 工作流 Atlassian 教程

[## Git 工作流| Atlassian Git 教程

Git 工作流是如何使用 Git 以一致且高效的方式完成工作的诀窍或建议…

www.atlassian.com](https://www.atlassian.com/git/tutorials/comparing-workflows)

关于如何使用 git 在团队中工作的博客文章

[## 如何在团队中工作:版本控制和 git

不知道命令做什么就停止记忆命令！

blog.hipolabs.com](https://blog.hipolabs.com/how-to-work-in-a-team-version-control-and-git-923dfec2ac3b)

关于 git 和 github 区别的博文

[## Git vs. GitHub:两者有什么区别？

Git 和 GitHub 一样吗？肯定不是。自从微软……以来，Git 和 GitHub 的比较越来越频繁

www.theserverside.com](https://www.theserverside.com/video/Git-vs-GitHub-What-is-the-difference-between-them)

在 h 上发布如何开始使用 git

[## Git -安装 Git

在开始使用 Git 之前，您必须让它在您的计算机上可用。即使已经安装了，也是…

git-scm.com](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)

Youtube 视频:“学会 git:基本概念”

尽情享受，有任何疑问随时联系我！**

20 分钟后准备好！

原文：https://towardsdatascience.com/git-ready-in-20-minutes-d11699a0aea2?source=collection_archive---------9-----------------------

当我开始我的数据科学之旅时，一位密友兼导师建议我熟悉 git。这似乎是一种干扰，但我想，“这是一个版本控制系统。我肯定能在 2-3 天内学会，并回到 Python 的美丽世界。”我大错特错了。我离开 Python 两天的短暂旅行变成了三个月的假期。我当然不后悔花费的时间，因为不可否认学习 git 的重要性。git 对于每个程序员的重要性已经在几个优秀的博客中有很好的描述，我在这里不打算重复了。

对于像我这样没有编程背景的初学者来说，一开始可能看起来有些吓人。在花了大量时间试图理解 git 的底层概念和内部结构之后，我意识到它真的没有尽头。然而，它可以分阶段学习。如果你从来没有使用过 git，并且一直把它放在后面，我强烈建议你至少开始使用它。它并不像看起来那么复杂，您可以随时随地学习更多功能。到本文结束时，您将对 git 的功能有一个大致的了解，用 GitHub 创建了一个帐户，采取了安全措施，创建了一个存储库，并检入了一些代码——所有这些都有望在 20 分钟内完成！

让我们从几个关键概念开始。

吉特

Git 是一个版本控制系统；分布式的。版本控制系统(VCS)记录关于代码文件的变更内容、变更时间、变更地点和变更人的信息。与其他 VCS 不同，git 是“分布式”的，即。，它不是由中央服务器管理的。Git 以快照的形式存储数据。当您保存一个文件的状态(在 git 术语中称为 commit)时，git 获取文件的一系列快照，并为它分配一个惟一的 40 个字符的键。在下一次提交期间，它会再次拍摄一系列快照。如果进行了任何更改，将生成一个新的密钥。如果没有，则使用相同的键引用该文件。因此，在其核心，git 只不过是一个键值数据存储。

git 的核心是一个 键值 数据存储。持久化地图。

GitHub

Git 协议由几个服务提供商托管，例如 GitHub、Bitbucket 和 Codebase。GitHub——最近被微软收购，是最流行的 git 托管平台之一。现在你知道为什么不能互换使用术语 git 和 GitHub 了。

储存库

git 存储库是与项目相关的所有文件和文件夹的集合。简单地说，存储库就像一个包含文件夹、子文件夹和文件的目录。GitHub 允许你创建无限数量的公共和私有库。顾名思义，公共存储库是公开的，可以查看和复制；而用户可以展示对其私有储存库的访问控制。

SSH 密钥

SSH 或安全 Shell 允许使用加密技术在主机和客户端之间建立安全连接。SSH 密钥的生成本质上是公钥-私钥对的生成。使用安全 Shell 身份验证的动机是大大增强双方(在本例中是您的计算机和 GitHub)之间信息传输的安全性。为了更好的理解 SSH 协议，请参考 ssh.com的

命令行界面

CLI 允许您通过命令与计算机进行交互。与使用鼠标点击图形图标的图形用户界面(GUI)不同，使用 CLI 的交互更快、更可靠，并允许高级操作。如果您以前从未使用过终端，现在是时候开始了。这个阶段只需要几个命令。如果您熟悉使用 CLI，请随意跳过这一部分。打开终端窗口，键入以下命令以了解如何在文件夹和文件中导航。在光标处键入命令，然后按 Return 键执行命令。

ls

列出目录的内容。您的目录可能包含文件和文件夹。一旦您键入“ls”并按下 return 键，所有内容都会列出来。

ls –a

列出内容，包括隐藏的文件和文件夹。

cd <folder_name>

cd 代表“更改目录”。键入您希望导航到的文件夹/目录的名称(不要键入<>)。如果目标文件夹不在当前目录中，您需要键入目标文件夹的完整路径。或者使用命令 cd..

cd ..

在目录中向上导航一步。

pwd

打印当前目录的路径

clear

清除所有以前命令的屏幕

cp <source/filename> <destination>

cp 代表复制。要将文件从一个位置复制到另一个位置，请使用上述格式。

这就足够开始了。我在这里假设您使用的是基于 MacOS 或 Unix 的系统。您熟悉基本的终端命令，并且能够导航到所需的目录。

创建 GitHub 账户

通过注册使用 GitHub 创建一个帐户。现阶段可以选择免费计划。验证电子邮件地址将引导您进入主页。

生成 SSH 密钥

如果愿意，您可以在 GitHub 中使用现有的 SSH 密钥，在这种情况下，您可以直接进入下一步——添加 SSH 密钥。要生成新的 SSH 密钥，请转到终端，执行命令**ssh-keygen**。将提示“正在生成公钥/私钥对”的消息。只需点击返回接受默认位置和文件名。如果。ssh 目录不存在，系统会为您创建一个。出现提示时，输入并重新输入密码。执行命令**ls –a** 列出名为. ssh 的隐藏文件夹。ssh 通过**ls** 命令。将列出三个文件，其中 id_rsa 包含私钥， id_rsa.pub 包含公钥。通过执行命令 **cat id_rsa.pub**在屏幕上显示公钥，并从终端窗口复制密钥。

添加 SSH 密钥

在线访问您的 GitHub 帐户。单击个人资料图标旁边的下拉菜单。点击设置并导航至 SSH 和 GPG 键。单击新建 SSH 密钥按钮，添加一个标题(例如:id_rsa.pub)并粘贴从终端窗口复制的公钥。请注意，您不应该共享您的私钥。现在您已经启用了 SSH 访问来安全地管理 GitHub 的 git 操作。

Add new SSH key on GitHub

创建存储库

导航到 GitHub 主页。在左侧面板中，单击链接到创建新存储库。为您的存储库指定一个名称，例如:“my-python-notebooks”，并提供一行描述。选择 Public ，Initialize Repository with a ReadMe，点击 Create Repository 按钮。

Create a repository on GitHub

克隆你的仓库

您刚刚在 GitHub 上创建的存储库位于一个远程位置。为了能够在离线模式下使用它，您需要克隆存储库。这使您能够在本地计算机上创建存储库的副本，并在两个位置之间进行同步。在 GitHub 上，在资源库名称下，点击 Clone 或 download。在使用 SSH 克隆部分，复制存储库的克隆 URL。

Clone your repository

转到终端，将工作目录更改为要保存克隆存储库的目录。键入**git clone**，然后粘贴你之前复制的网址并点击回车键。GitHub 上的资源库现在已经克隆到您的计算机上了。

git 添加

现在，您的本地计算机中已经有了存储库，您可以将任意数量的文件夹和/或文件复制到其中。例如:使用cp命令复制一个现有的 Jupyter 笔记本 filename.ipynb 。一旦在本地存储库中有了 filename.ipynb，就执行**git add <filename.ipynb>**。git add 命令拍摄文件快照，为版本控制做准备。请注意，此文件尚未“版本化”。此步骤为提交“暂存”文件。

git 提交

要提交转移文件，请执行以下命令:

git commit –m“The file contains basic Python datatypes.”

引号内的注释是关于文件内容或用户所做修改的描述性消息。此步骤将文件快照永久记录在版本历史记录中。

git 推送

执行git push命令将提交上传到 GitHub。现在，您可以刷新浏览器，并确认 GitHub 上的存储库中的文件版本。

恭喜你！！！

您已经成功地创建了第一个存储库，并签入了要由 git 跟踪的文件。

下一步是什么？

我建议您扎实地创建存储库，添加和/或编辑更多文件，并提交修改。接下来，您应该能够在本地计算机上的现有目录中启动 git 跟踪。此外，理解分支、合并、拉请求和部署的概念。这些过程是在与开发团队协作的同时实现的。

数据科学家的 GIT 存储和分支

原文：https://towardsdatascience.com/git-stashing-and-branching-for-data-scientists-21ef6e0fb68?source=collection_archive---------34-----------------------

数据科学项目中的连续过程

Photo by Kristopher Roller on Unsplash

数据科学家，分析数据，做预处理，建立模型，测试模型，部署模型。但是在所有这些步骤中，肯定应该用 R 或 Python 编程。通常一个人或一组人在同一个项目上工作，这需要整合，这样每个人都应该在同一页上。为了进行这种集成，版本控制成为大多数数据科学家使用 GIT 作为版本控制的一种方式。

在这篇文章中，我将关注我们在 GIT 上面临的主要挑战。它们主要是存储和分支。

隐藏

让我们假设您正在构建一个模型，并且收到了另一个变更请求。您需要快速保存当前的变更，并在其他变更请求工作完成后将它们应用到存储库中。

为了做到这一点，GIT 提供了一个有用的命令 git stash ，它允许你保存你的更改并返回到干净的工作目录。

创建一个仓库

假设您已经完成了数据预处理，并且想要临时保存您的更改并返回到工作目录。下面的命令将帮助你做到这一点。

git stash “preprocessing done”

列出所有藏匿处

您刚刚创建了一个仓库，如果您想查看所有现有的仓库，可以使用下面的命令。

git stash list

输出

stash@{0}: preprocessing done
stash@{1}: get the data

最新的存储将在顶部，索引为 0。

应用存储

到目前为止，您已经创建了 stash，并假设您已经完成了新的工作或者收到了变更请求。现在您必须取回您保存的更改，这可以通过应用创建的存储来完成。

git stash apply stash@{0}

这将应用更改，但存储不会从列表中删除。为此，我们必须使用下面的命令。

git stash drop stash@{0}

分支

数据科学家永远不会以构建单一模型而告终，而是继续尝试其他预处理技术或算法。因此，为了不干扰现有的分支，我们去创建分支。当工作是实验性的或者添加新的特性来封装变更时，我们创建分支。

在这里，我将指导您如何从现有的分支创建一个分支，删除一个分支，列出所有分支以及合并分支。

列出所有分支

在我们开始创建和删除分支之前，让我们尝试用下面的命令列出所有现有的分支。

git branch -a

-a 指定我们希望看到本地系统和远程存储库中的所有分支。

从主控形状创建分支

要从主服务器创建本地分支，可以使用以下命令。

git checkout -b new-branch master

您可以添加、修改、删除任何文件并提交更改。

git add <filename> git commit -m “New features created”

如果您想将这个分支推到远程，可以使用下面的命令。

git push origin new-branch

合并分支

到目前为止，我们已经创建了新的分支，假设我们已经在新的分支中实现了一些特性。下一个任务是将这个分支合并到主分支中。我们可以使用下面的命令来实现这一点。

git checkout master 
git merge new-branch

结帐主，指定您正在切换到主分支

稍后您可以将这些更改推送到存储库中。

删除本地和远程分支

数据科学项目包含许多功能和变更请求。我们不断地创造我们想要的分支，它们会堆积起来。为了摆脱它们，我们需要删除它们。

删除一个本地分支

git branch -d <branch name>

使用上面的命令，分支将在您的本地系统中被删除，但不会在远程系统中被删除。

删除一个远程分支

git push <remote name> :<branch name>

上述命令将删除存储库中的分支。

N 注意:我从主节点获取了创建或合并分支，但是它可以是任何现有的分支。

希望你喜欢它！！敬请期待！！！请对任何疑问或建议发表评论！！！

git——版本控制系统

原文：https://towardsdatascience.com/git-version-control-system-666a1ffd85d3?source=collection_archive---------11-----------------------

你为什么需要版本控制软件——你做了一些东西，现在你想在它被破坏或删除之前把它保存在某个地方，这样你就可以从你停止的地方继续工作。

有道理吗？

好了，我们再深入一点，我对做个人网站很感兴趣。我研究了它的代码，花了几天时间。但是我的系统不支持挂起，或者硬盘可能已经崩溃，或者我错误地修改了我的代码，我无法返回到以前的状态。

这种事过去也发生在我身上，令人沮丧。

这就是 Git 的用武之地，它通过跟踪你当前的项目和你所做的所有修改，而不是在你的系统上用不同的名字保存每一个版本，把你从所有的麻烦和挫折中解救出来。

有很多软件可以跟踪你的工作，但是这里我们只讨论 Git。Git 是一个版本控制软件，它跟踪对代码的修改。

因为每个公司都需要它，所以你的简历上会多一项技能。我猜这是有道理的？

好吧！也许你对它不满意。也许你喜欢把每个文件都保存在本地。

我再给你一个答案然后就说得通了。

现在，我正计划与我的朋友合作，为我的网站有许多技能，这将有利于网站，为此，我需要更多的人。但是把它放在本地会让工作有点困难。因为每次你们都应该一起工作，而不是远程工作。

Git 可用于合并来自不同用户的已有版本的新版本，并清楚地了解在哪里以及由谁进行了哪些更改。

饭桶

Git 是一个分布式版本控制系统，每个用户都可以对他们系统上的整个存储库进行修改。它使用命令行，通过 git，可以很容易地来回撤销更改，并精确解释所做的更改。它具有以下能力:

跟踪变化，即同一文件的不同版本。
它还记录了项目中存在的所有文件。
比较和分析不同的代码并给出详细的解释。

现在你知道为什么 Git 但是如何使用它了吧？

开始在 Git 环境中工作的基本步骤是拥有一个本地存储库和一个远程存储库。

本地存储库:本地存储库是您在本地计算机上创建的路径或目录，它是一个工作目录。您在这个私有的存储库中编写代码，直到您将它推送到远程存储库中。

远程存储库:远程存储库是一个公共目录，或者是一个托管您的网站的公共平台，如 Github 或 Bitbucket。使用 Git，可以很容易地将一段代码或整个项目推到远程目录。

现在你的朋友也可以做出改变了。😃

Cloud Repositories: Github, Bitbucket, Gitlab

安装指南

现在是时候将它安装到您的系统上了。请看看这个链接来安装它。-> 安装指南

关键概念

让我们试着理解这里的一些关键术语:

版本控制系统:该工具维护不同版本的代码。也称为源代码管理器。
提交:当您进行更改时，在将更改发送到临时区域/临时索引并随后发送到远程存储库之前，这些更改应该保存在本地存储库中。这将您的代码保存到 Git 中。如果你想了解更多关于提交的信息，请点击链接 git commit 。
签出:当存储库中的内容被复制到工作目录时。
SHA(安全哈希算法):给每个提交一个唯一的 ID。
分支:当你偏离了发展主线，继续做工作而不弄乱发展主线的时候。

配置 Git

使用 cd 命令，您可以转到您的工作目录，并为您的本地和远程存储库设置用户凭证。这些凭证用于将代码推送到远程存储库中。

使用此命令，您可以输入用户名和用户电子邮件 id。

使用 $ git config -l ，您可以检查所做的更改是否得到了反映。

Git 上的本地存储库

首先，存储库应该存在于本地系统中。这个存储库将用于存储当前项目，它可以在以后被推送到 GitHub 上。我们使用命令行来探索存储库。使用命令 cd，转到路径并使用 mkdir 命令创建一个目录。

git init :一旦创建了目录，使用 git init 命令初始化它。git init 命令创建了一个新的 git 存储库，现在是主分支。存储库是一个版本控制系统，用于存储源代码和其他开发项目。

您可以通过简单地复制文件夹或使用命令行将代码文件或任何文本文件保存到该路径。

使用 git branch 命令“git branch -m master oldmaster”。您也可以更改主分支。

git 状态:使用 git 状态很容易看到存储库中所做的更改。比方说，我使用 git status 命令向 git 显示的分支添加了一个新文件。使用此命令可以看到所做的任何更改。这并不意味着已经做出并存储了更改。

3。git add: 所做的更改应该在提交之前添加。使用 git add 命令将代码或任何文件添加到临时区域。

为了一次添加多个文件，我们使用命令 git add -A. 将本地存储库中所有修改过的文件移动到暂存区。

4。 git commit: 用于将文件从暂存区存储到存储库中。

在本地克隆存储库

您可能希望在 GitHub 或任何远程环境中现有的存储库上工作。可以使用 git clone 命令克隆这个存储库，并将其存储在本地系统上以进一步增强代码。克隆存储库的命令是现有存储库>的 git clone < path。

克隆存储库时，请记住命令行并不指向另一个存储库。

查看提交历史的命令

在处理代码时，您可能希望回滚所做的更改，或者对代码进行任何更改，以查看以前所做的更改。有命令可以查看过去发生了什么变化。

git log :查看在存储库上进行的所有提交。我们使用 git log 命令。在命令中添加 SHA 键，我们可以看到一个特定的提交，后面跟着其他提交。为了只检查作为变更描述的一行，使用命令 git — oneline 。

2。git — stat :这个命令用于查看被修改的文件，以及添加或删除了多少行代码。

3。git log -p: 查看所做的实际更改，即可以使用该命令显示添加或删除的行。p 代表补丁。

在所有这些命令中，您都可以传递 SHA 键，这在查看特定提交时会很有用。

GitHub 上的远程存储库

可以使用 Git 将代码推送到 GitHub。为此，应该在 GitHub 上做个交代。其次，应该在 GitHub 上创建一个新的存储库，方法是单击“+”然后单击“New Repository”按钮。

一旦你点击了新的存储库，它将引导你到一个页面，在那里你给出了你正在工作的项目的细节。回购的名称和描述。如果你不想分享你的回购，你可以选择私人选项。如果您愿意，以后可以更改它。

创建存储库后，它会将您转到下一页，您可以在这里选择是创建新的 repo，然后将代码推送到远程，还是将代码推送到现有的存储库中。

如果您已经在本地创建了 repo，那么您可以使用 SSH 将代码推送到 GitHub。

将主分支推送到 GitHub

因为我们已经在本地创建了 repo，所以我们将代码直接推送到 GitHub repo。当进行修改时，你将需要 GitHub 帐户的凭证。

—关于分支的更多信息—

创建新分支

不要直接对主分支进行更改，应该习惯在不同的分支中进行更改。但是，如果新的更改不起作用，您可以返回到以前的提交，但是在组织中这会导致业务损失。

相反，最好是在一个新的分支中工作，测试所做的更改，然后将其转移到生产环境中。

使用命令git branch添加一个指向主节点的分支。但是如果要对一个现在不是主节点的提交进行修改，那么使用git branchSHA。 SHA 告诉您在哪个提交之后应该放置新分支。

使用git check out命令，我们将主分支移动到一个名为 branch-name 的新分支。现在，您可以通过使用与我们对旧的主分支所做的相似的步骤来添加和提交对这个分支的更改。然后将您的分支推送到远程存储库:git Push-u origin****

如果成功，使用git merge将代码与旧的主分支合并。但是在运行 merge 命令之前，您需要使用 git checkout 命令切换回原来的主分支。

还可以使用 git 命令重命名、删除、比较分支:

重命名:git branch-m
删除:git branch-d
比较分支:git diff

结论

Git 是免费和开源的。它易于使用，速度更快。它允许你在云上运行你的代码，并跟踪所有以前对项目的修改，即完整的变更历史。每次提交都包含作者的姓名、提交的描述、提交的时间戳和前一次提交的 SHA1 散列。

Git 在团队在偏远地区工作的情况下非常有用。因为任何个人都可以进行更改，只要授予对远程存储库的访问权限。

您可以将本地存储库与任何远程存储库(如 GitHub、GitLab、Bitbucket 等)链接起来。

带有机器学习的 Github 自动完成

原文：https://towardsdatascience.com/github-autocompletion-with-machine-learning-a833cb90983e?source=collection_archive---------16-----------------------

作者óscar d . Lara Yejas和 Ankit Jha

作为数据科学家，软件开发是更贴近我们的领域之一，因为毕竟我们是各种帮助我们构建模型的软件包和框架的狂热用户。

GitHub 是支持软件开发生命周期的关键技术之一，包括跟踪缺陷、任务、故事、提交等等。在一个大型的开发组织中，可能会有多个团队(即小队)承担特定的职责，例如性能小队、安装小队、 UX 小队和文档小队等。当创建一个新的工作条目时，这会带来挑战，因为用户可能不知道一个任务或者缺陷应该被分配给哪个团队，或者谁应该是它的所有者。但是机器学习能有帮助吗？答案是是的，特别是，如果我们有一些来自 GitHub 库的历史数据。

问题陈述

我们在本文中试图解决的问题是:我们是否可以创建一个 ML 模型，根据 GitHub 工作项的标题和其他特征来建议团队和所有者？

工具

在本文中，我们将使用 R 编程语言。需要以下 R 包:

suppressWarnings({
    **library**(tm)
    **library**(zoo)
    **library**(SnowballC)
    **library**(wordcloud)
    **library**(plotly)    
    **library**(rword2vec)
    **library**(text2vec)
    **library**("reshape")
    **library**(nnet)
    **library**(randomForest)
})

数据集

GitHub 提供了不同的工作项特征，如 id 、标题、类型、严重性、小队、作者、状态、日期等。标题将是我们的主要数据源，因为它总是需要的，并且可能具有最高的相关性；不难想象，比如工作项标题为“尝试部署 Docker 实例时安装程序失败”的话，很可能应该分配给安装程序小队。或者，一个标题，如“特征 XYZ 的文档丢失”，表明该工作项可能被分配给文档团队。下面是 GitHub 数据集的一个例子。

# Load the dataset from a CSV file
workItems <- **read.csv**('../github-data.csv')# Show the dataset
**show**(workItems)

Table 1: Sample GitHub dataset

注意，无论是小队还是受让人(即主人)，都是地面真相，在历史资料中给出。这意味着，我们可以把它当作一个分类问题。现在，由于工作项标题是以自由文本的形式给出的，所以可以使用一些自然语言处理技术来获得一些特性。

自然语言处理(NLP)基础知识

让我们介绍一些 NLP 术语:

我们的数据集(工作条目标题的集合)将被称为语料库。
每个工作项标题都是一个文档。
语料库中所有不同单词的集合就是词典。

从自由文本中提取特征的一个非常简单的方法是计算词频 (TF)，即计算字典中的每个单词在每个文档中出现的次数。出现的次数越高，这个词的相关性就越强。这产生了一个文档-术语矩阵(DTM) ，每个文档有一行，列数与字典中的单词数一样多。该矩阵的位置【T10(I，j)】表示单词 j 在标题 i 中出现的次数。

您可以立即看到，得到的特征集将非常稀疏(即，具有大量零值)，因为字典中可能有数千个单词，但每个文档(即，标题)将只包含几十个单词。

TF 的一个常见问题是诸如“the”、“a”、“in”等词。倾向于非常频繁地出现，然而它们可能并不相关。这就是为什么 TF-IDF 通过将一个单词除以它在整个语料库中的频率函数，从而将该单词在文档中的频率归一化。这样，最相关的单词将是出现在文档中但在整个语料库中不常见的单词。

数据监管

现在，在应用任何 NLP 技术之前，需要进行一些文本处理。这包括删除停用词(例如，介词、冠词等。)、大小写、标点符号和词干，这是指将词形变化/派生的单词简化为它们的基本或词根形式。下面的代码执行所需的文本预处理:

preprocess <- **function**(text) {
    corpus <- VCorpus(VectorSource(tolower(text)))
    corpus <- tm_map(corpus, PlainTextDocument)
    corpus <- tm_map(corpus, removePunctuation)
    corpus <- tm_map(corpus, removeWords, stopwords('english'))
    corpus <- tm_map(corpus, stemDocument)
    data.frame(text=unlist(sapply(corpus, `[`, "content")),
        stringsAsFactors=F)
}curatedText <- preprocess(workItems$TITLE)

Table 2: Results of text curation after removing stop words, punctuation, and case, as well as stemming the documents.

特征提取

以下代码将通过将 TF-IDF 应用于我们的策划文本来创建功能。生成的 DTM 在字典中每个单词都有一列。

# Create a tokenizer
it <- itoken(curatedText$text, progressbar = **FALSE**)# Create a vectorizer
v <- create_vocabulary(it)  %>%
    prune_vocabulary(doc_proportion_max = 0.1, term_count_min = 5)vectorizer <- vocab_vectorizer(v)# Create a document term matrix (DTM)
dtmCorpus <- create_dtm(it, vectorizer)
tfidf <- TfIdf$new()
dtm_tfidf <- fit_transform(dtmCorpus, tfidf)
featuresTFIDF <- as.data.frame(as.matrix(dtm_tfidf))# Add prefix to column names since there could be names starting 
# with numbers
colnames(featuresTFIDF) <- paste0("word_", colnames(featuresTFIDF))# Append the squad and type to the feature set for classification
featureSet <- cbind(featuresTFIDF, 
                    "SQUAD"=workItems$SQUAD, 
                    "TYPE"=workItemsCurated$TYPE)

Feature set example.

现在我们有了一个特性集，其中每行是一个工作项，每列是它的 TF-IDF 分数。我们也有工作项目的类型(例如，任务或者缺陷)和基本事实(例如，团队)。

文本分类

接下来，我们将为训练集和测试集创建拆分:

random <- runif(nrow(featureSet))train <- featureSet[random > 0.2, ]
trainRaw <- workItemsFiltered[random > 0.2, ]test <- featureSet[random < 0.2, ]
testRaw <- workItemsFiltered[random < 0.2, ]

随机森林

r 提供了 randomForest 包，它允许训练一个随机森林分类器，如下所示:

# Train a Random Forest model
> model <- randomForest(SQUAD ~ ., train, ntree = 500)# Compute predictions
> predictions <- predict(model, test)# Compute overall accuracy
> sum(predictions == test$SQUAD) / length(predictions)
[1] 0.59375

音符准确度低于 60%,这在大多数情况下是非常糟糕的。然而，仅仅根据标题来预测一个工作项目应该被分配到哪个组是一项非常具有挑战性的任务，即使对人类来说也是如此。因此，让我们为用户提供两到三个关于给定工作项的最可能团队的建议。

为此，让我们使用由 randomForest 提供的每个单独类的概率。我们需要做的就是对这些概率进行排序，并选择具有最高值的类。下面的代码正是这样做的:

# A function for ranking numbers
ranks <- function(d) {
            data.frame(t(apply(-d, 1, rank, ties.method='min')))
         }# Score the Random Forest model and return probabilities
rfProbs <- predict(model, test, type="prob")# Compute probability ranks
probRanks <- ranks(rfProbs)cbind("Title" = testRaw$TITLE, 
      probRanks, 
      "SQUAD" = testRaw$SQUAD,  
      "PRED" = predictions)rfSquadsPreds <- as.data.frame(t(apply(probRanks,
                               MARGIN=1, 
                               FUN=function(x) 
                                       names(head(sort(x,      
                                       decreasing=F), 3)))))# Compute accuracy of any of the two recommendations to be correct
> sum(rfSquadsPreds$V1 == rfSquadsPreds$SQUAD | 
    rfSquadsPreds$V2 == rfSquadsPreds$SQUAD) / nrow(rfSquadsPreds)
[1] 0.76# Compute accuracy of any of the three recommendations to be correct
> sum(rfSquadsPreds$V1 == rfSquadsPreds$SQUAD | 
    rfSquadsPreds$V2 == rfSquadsPreds$SQUAD |
    rfSquadsPreds$V3 == rfSquadsPreds$SQUAD) / nrow(rfSquadsPreds)[1] 0.87

请注意，有两个建议，其中任何一个正确的概率是 76%，而有三个建议，这个概率变成 87%，这使得模型更加有用。

其他算法

我们还探讨了逻辑回归、XGBoost、Glove 和 RNNs/LSTMs。然而，结果并不比随机森林好多少。

特征重要性

Feature importance (Given by XGBoost)

部署

为了将这个模型投入生产，我们首先需要导出(1)模型本身和(2)TF-IDF 转换。前者将用于评分，而后者将提取用于训练的相同特征(即单词)。

导出资产

# Save TF-IDF transformations
saveRDS(vectorizer, "../docker/R/vectorizer.rds")
saveRDS(dtmCorpus,"../docker/R/dtmCorpus_training_data.rds")# Save DTM
saveRDS(model, "squad_prediction_rf.rds")

码头工和管道工

Docker 是一个非常有用的工具，可以将我们的资产转化为容器化的应用程序。这将帮助我们在任何地方发布、构建和运行应用程序。

对于大多数软件服务来说，API 端点是消费预测模型的最佳方式。我们探索了像 OpenCPU 和 plumbr 这样的选项。Plumber 看起来更简单，但却非常强大，可以流畅地读取 CSV 文件和运行分析，因此它是我们的选择。

Plumber 的代码风格(即使用 decorators)也更加直观，这使得管理端点 URL、HTTP 头和响应有效负载变得更加容易。

docker 文件示例如下:

FROM trestletech/plumber# Install required packages
RUN apt-get install -y libxml2-dev# Install the randomForest package
RUN R -e ‘install.packages(c(“tm”,”text2vec”,
          ”plotly”,”randomForest”,”SnowballC”))’# Copy model and scoring script
RUN mkdir /model
WORKDIR /model# plumb and run server
EXPOSE 8000ENTRYPOINT [“R”, “-e”, \“pr <- 
    plumber::plumb(‘/model/squad_prediction_score.R’);         
    pr$run(host=’0.0.0.0', port=8000)”]

评分文件 squad_prediction_score 的一个片段。R 如下图:

x <- c(“tm”,”text2vec”,”plotly”,”randomForest”,”SnowballC”)
lapply(x, require, character.only = TRUE)# Load tf-idf
vectorizer = readRDS(“/model/vectorizer.rds”)dtmCorpus_training_data = 
readRDS(“/model/dtmCorpus_training_data.rds”)tfidf = TfIdf$new()tfidf$fit_transform(dtmCorpus_training_data)# Load the model
squad_prediction_rf <- readRDS(“/model/squad_prediction_rf.rds”)#* @param df data frame of variables
#* @serializer unboxedJSON
#* @post /score
score <- function(req, df) {
    curatedText <- preprocess(df$TITLE)
    df$CURATED_TITLE <- curatedText$text
    featureSet <- feature_extraction(df)
    rfProbs <- predict(squad_prediction_rf, featureSet,type=”prob”)
    probRanks <- ranks(rfProbs)
    rfSquadsPreds <- as.data.frame(t(apply(probRanks, MARGIN=1,  
        FUN=function(x) names(head(sort(x, decreasing=F), 3))))) result <- list(“1” = rfSquadsPreds$V1, 
                   “2” = rfSquadsPreds$V2, 
                   “3” = rfSquadsPreds$V3)
    result
}#* @param df data frame of variables
#* @post /train
train <- function(req, df) {
    ...
}preprocess <- function(text) {
    ...
}feature_extraction <- function(df) {
    ...
}

现在，要针对您自己的存储库运行该模型，您只需要构建您自己的 docker 映像并点击端点:

docker build -t squad_pred_image .
docker run — rm -p 8000:8000 squad_pred_image

一旦 docker 映像准备就绪，示例 API 调用将如下所示:

curl -X POST \
    [http://localhost:8000/score](http://localhost:8000/score) \
    -H ‘Content-Type: application/json’ \
    -H ‘cache-control: no-cache’ \
    -d ‘{
        “df”: [{
            “ID”: “4808”,
            “TITLE”: “Data virtualization keeps running out of 
             memory”,
            “TYPE”: “type: Defect”
        }]
    }’

API 调用输出示例如下:

{
    “1”: “squad.core”,
    “2”: “squad.performance”,
    “3”: “squad.dv”
}

自己试试

您是否希望使用 GitHub 帮助您的开发组织提高工作效率？用你自己的数据集试试我们的代码。让我们知道你的结果。

关于作者

scar D. Lara Yejas 是高级数据科学家，也是 IBM 机器学习中心的创始人之一。他与世界上一些最大的企业密切合作，将 ML 应用于他们的特定用例，包括医疗保健、金融、制造、政府和零售。他还为 IBM 大数据产品组合做出了贡献，特别是在大规模机器学习领域，是 Apache Spark 和 Apache SystemML 的贡献者。

scar 拥有南佛罗里达大学的计算机科学和工程博士学位。他是《人类活动识别:使用可穿戴传感器和智能手机》一书的作者，并发表了大量关于大数据、机器学习、以人为中心的传感和组合优化的研究/技术论文。

Ankit Jha 是一名从事 IBM Cloud Private For Data platform 的数据科学家。他也是平台的可维护性团队的一员，使用 ML 技术进行日志收集和分析。Ankit 是一位经验丰富的软件专业人士，他还拥有辛辛那提大学的分析硕士学位。

使用 GitHub API 的 GitHub 用户洞察—数据收集和分析

原文：https://towardsdatascience.com/github-user-insights-using-github-api-data-collection-and-analysis-5b7dca1ab214?source=collection_archive---------8-----------------------

探索 GitHub API

Photo by Yancy Min on Unsplash

当我使用 GitHub 页面时，我决定在上面放一些关于我的 GitHub 项目的统计数据。因此，我决定使用 GitHub 自己的 API 来获得洞察力。因为这对其他人可能也有用，所以我决定将它作为一个项目创建并发布在 GitHub 上。查看下面的存储库:

https://github.com/kb22/GitHub-User-Insights-using-API

这个项目有两个部分:

数据收集——我使用 GitHub 的 API，使用我的凭证获取我的存储库和一些关于它们的关键信息。
数据分析——利用上面收集的数据，我从数据中得出一些见解。

您也可以将该项目用于您自己的数据收集。

将您的凭证添加到文件credentials.json中。如果您的用户名是userABC，密码是passXYZ，那么 json 文件应该是这样的:

{ 
  "username": "userABC",
  "password": "passXYZ"
}

一旦对 json 文件进行了更改，保存该文件。然后，只需运行文件get_github_data.py从您的个人资料中获取数据，并将其保存到文件repos_info.csv和commits_info.csv。使用以下命令运行 Python 文件:

python get_github_data.py

数据收集

导入库和凭据

我首先将我的凭证保存在credentials.json文件中。

在读取凭证文件后，我使用用户名和密码创建了用于 GitHub API 认证的authentication变量。在访问我们自己的帐户时进行身份验证允许我们每小时打 5000 个电话。

用户信息

我将使用https://api.github.com/users/<USERNAME> API 为我的帐户获取数据。

回应中有几个关键。从 json 中，我将提取用户信息，如name、location、email、bio、public_repos和public gists。我还会将一些 URL 放在手边，包括repos_url、gists_url和blog。

在撰写本文时，我有 36 个公共存储库和 208 个公共 gists。

仓库

我现在将使用repos_url来获取所有的存储库。然而，该 url 将每批的最大存储库数量限制在 30 个。因此，我必须处理它。

我调用端点，如果返回的存储库数量是 30，这意味着可能有更多的存储库，我应该检查下一页。我在 API 中添加了一个名为page的参数，其值设置为 2，3，4…基于我所指的页面。如果返回的存储库小于 30，这意味着没有更多的存储库，我结束循环。

因为我有 36 个存储库，所以我能够在两个 API 调用中获取它们并将结果保存在repos_data中。

为了获得更多的信息，我不得不看一下回复。所以，我检查了第一个存储库信息。

正如我们所看到的，每个存储库都有很多信息。

我决定为每个存储库选择以下内容:
1。id:存储库的唯一 id。
2。名称:存储库的名称。
3。描述:存储库的描述。
4。created_at:首次创建存储库的时间和日期。
5。updated_at:上次更新存储库的时间和日期。
6。登录:存储库所有者的用户名。
7。许可证:许可证类型(如果有)。
8。has_wiki:一个布尔值，表示存储库是否有 wiki 文档。
9。forks_count:存储库的总分叉数。
10。open_issues_count:存储库中打开的问题总数。
11。stargazers_count:储存库中的恒星总数。
12。watchers_count:监视存储库的用户总数。
13。url:存储库的 url。
14。commits_url:存储库中所有提交的 url。15。languages_url:存储库中所有语言的 url。

对于提交 url，我删除了大括号内的结束值(包括大括号)。我自己从存储库 url 创建了 languages_url。

数据框架repos_df现在有了我需要的所有存储库信息。然而，我想更进一步，决定提取这里的所有语言，并将其附加到 dataframe 中。

每个存储库的语言可以有多个值，所以我决定以逗号分隔列表的形式组合所有语言。

完成后，我将数据帧保存到一个文件repos_info.csv。

承诺

我还可以访问每个存储库的提交 url。我决定可以收集每个存储库的提交，并将它们保存到自己的文件中。

就像 repositories API 一样，commits API 也被限制为一次调用只能提交 30 次。因此，使用与使用page参数相同的技术，我检索了所有提交。我看了一下 json 的回复。

对于每次提交，我保存了 git 提交所属的存储库 Id、提交的 sha 值、提交的日期和提交的消息。

我将 dataframe 数据保存到文件commits_info.csv。

数据分析

既然有了完整的数据，我决定从这些数据中得出一些见解。

基本分析

我注意到我有 36 个存储库和 408 个提交(T2)。然后我决定用describe()的方法来看一看分叉、观察者、问题和星星。我注意到以下几点:

我的最大分叉数是 67，最小分叉数是 0。
观察者的数量和星星的数量是成正比的。
我没有在任何存储库中报告过问题。

我还观察到我用过的两个最常见的提交消息是 Update README.md 和 Initial commit。看来有时我确实倾向于在 GitHub 上更新自述文件，并使用它的默认消息作为提交消息。

每个存储库的提交

接下来，我想看看提交是如何在我的各种存储库中分配的。我根据存储库 id 组合了两个数据集(repos 和 commits ),并创建了一个图。

Commits per repository

从上面的图中，我们可以清楚地看到我在 IEEE MyEvent App 中获得了最大提交量，这是一个用于事件管理的 Android 应用。第二个最受关注的存储库是与 IBM 的应用数据科学顶点课程相关的存储库，名为 Coursera_Capstone。

年度分析

从开始做项目，推到 GitHub，已经很久了。我在 2018 年和 2019 年工作得最多，希望在年度分析中看到同样的情况。

Commits in each year

尽管现在才六月，我已经完成了今年最大的承诺。第二名是 2016 年。当时我正在攻读计算机科学学士学位，我已经开始从事自己的项目，因此提交的数量很高。我预计在 2018 年的年会有更多的提交，但是我开始的比较晚，所以可能提交的总数会比较少。

现在让我们来分解一下 2019 年，看看我在那里是如何进步的。

2019 年月度分析

我把一年分成几个月，并把数据可视化在柱状图上。

Commits in each month of 2019

似乎我在三月达到了最大提交量。六月还有 6 天，但它已经占据了第二的位置。T21 最少的犯罪发生在一月份。

让我们进一步分解 2019 年 3 月。

2019 年 3 月每日分析

让我们看看三月份的提交历史。

Commits in March, 2019

我在 2019 年 3 月 2 日进行了最大次数的提交。

最流行的语言

随着我对数据科学兴趣的增长，我使用 Python 参与了许多项目。因此，Python 将是最占优势的语言。

Language distribution amongst all repositories

我使用过各种语言，包括 HTML、CSS、C++、Java 等等。不过最常见的还是 Jupyter 笔记本。我在 Jupyter 笔记本中的代码是用 Python 3 编写的，因此 Python 是我所有项目中最常用的语言。

结论

在本文中，我讨论了为我的个人资料收集 GitHub 数据的步骤，然后使用这些数据得出见解。

希望你喜欢这个。请分享你的想法、观点和建议。我很乐意收到你的来信。

误差在十亿年左右

原文：https://towardsdatascience.com/give-or-take-a-billion-years-32fb9305ca86?source=collection_archive---------20-----------------------

根据来自星系物理学公共数据库 Leda 的数据，对宇宙的年龄进行 DIY 估计。

作为搭建交易平台、*的一部分，我在自学数据科学。我的女儿劳拉正在做一个关于哈勃定律的项目，所以我们想利用这个机会出去玩玩。劳拉做了她的报告，我做了一个* Jupyter 笔记本 旁边生成了 图像 并练习了我公认的非常初级的数据科学技能。

你将从阅读中获得的是:

好的星系数据集
方程式使用
单位使用
代码用于生成结果和图像

我们从奥斯陆大学的天体物理学家彼得·劳尔森那里得到了很多帮助，并从 Reddit 帖子和 R 代码中获得了灵感。

请注意，这是实际可执行 Jupyter 笔记本的镜像，可用 这里用 。

下面我们将使用来自星系物理学数据库的数据，来验证哈勃定律:**

换句话说，一个星系的距离和它相对于我们的速度之间存在线性关系——或者说它遵循正常线性方程的结构:

有了这些知识，我们可以计算出宇宙的年龄

获取数据

询问

以下查询被传递到达乐数据库接口:

***SELECT objname, v3k, mod0 WHERE (objtype='G') AND (v3k>3000) AND (v3k<30000) AND (mod0 IS NOT NULL) AND (v3k IS NOT NULL)***

我们正在剔除不是星系的物体，(objtype='G ')，速度非常低(v3k > 3000)的物体，因为它们的局部速度和旋转扭曲了结果，速度非常高的物体(v3k < 30000) because the light we are getting from them only reflects their velocities in the early universe when the accelleration was significantly different.

***import pandas as pdimport numpy as np
from numpy import log10,sqrtimport matplotlib.pyplot as pltfrom astropy import units as u
from astropy.cosmology import Planck15
import astropy.constants as ccfrom scipy.optimize import curve_fit***

The results were saved in a text file called, 【 locally and then loaded into a pandas dataframe in Python.

***# Load Leda data
df = pd.read_csv('leda.txt')***

The first five lines look like this:

***df.head()***

Tidy the data

***# Remove empty column at the end
df = df.iloc[:,0:3]# Remove rows with missing values
df = df.dropna()# Remove whitespace from the headers
df = df.rename(columns=lambda x: x.strip())# Rename the objname column to galaxy
df = df.rename(columns={'objname':'galaxy'})# Display a sample of the dataframe
df.head()***

Luminosity Based Distance

Convert the magnitude ( 【 ) to 光度-距离秒差距:

***df['dl_mpc'] = 10**((df['mod0']+5)/5) / 1000000
df.head()***

物理距离

光度距离没有考虑光子从光源到我们身边时，速度差异和重力效应所造成的红移和时间膨胀。

为了得到合适的距离，我们首先需要红移因子， 𝑧 ，它是通过将速度除以光速(cc.c)得到的:

***df[‘z’] = df[‘v3k’] / cc.c***

然后我们用红移因子 1+ 𝑧 除光度距离 𝑑𝑙 :

***df['d_mpc'] = df['dl_mpc'] / (1+df['z'])***

导出整齐的数据集

***# Save to file
df.to_csv('galaxies.csv')***

最佳线性拟合

***def lin(x, a):
    return a * xcoeff, cov= curve_fit(lin, df['d_mpc'], df['v3k'])# The slope of the best linear fit 
a = coeff[0]
a***

结果:

***66.59753735677145***

宇宙的年龄

秒

***# Convert a from mpc based to km based
a_km = a / 1000000 / 30856775814913.67
age_sec = (1/a_km)
age_sec = age_sec
age_sec***

结果:

***4.6333208463264954e+17***

年

***# Age of the universe in years
age_year = age_sec / (60*60*24*365)
"{:,}".format(int(age_year))***

结果:

***'14,692,164,023'***

容忍

共方差

***cov[0][0]***

结果:

***0.20239139101111292***

𝑅^2

***# Residual sum of squares (ss_tot)
residuals = df['v3k'] - lin(df['d_mpc'], coeff)
ss_res = np.sum(residuals**2)# Total sum of squares (ss_tot)
ss_tot = np.sum((df['v3k']-np.mean(df['v3k']))**2)# R squared
r_squared = 1 - (ss_res / ss_tot)
r_squared***

结果:

***0.7590999713188041***

情节

***# Store the distance in mpc in an array
x = df['d_mpc'].values# Store the velocity in km/s in an array
y = df['v3k'].values # v3k# Least Square Best Fit line
f = lambda x: a * x# Initialize plot and subplot
fig2 = plt.figure(figsize=(25,20))
g2 = fig2.add_subplot(1, 1, 1)# Set background color to black
g2.set_facecolor((0, 0, 0))# Plot dataset
g2.scatter(df['d_mpc'], df['v3k'], c='yellow', s=5)# Plot best fit line
g2.plot(x,f(x), c="white", label="fit line", linewidth=0.2)# Add labels
g2.set_title('Speed / Distance')  
g2.set_xlabel('Distance from Earth in mpc')  
g2.set_ylabel('Speed relative to Earth in km/s')# Show plot
plt.show()***

结论

与科学界的共识相反，劳拉和我发现宇宙已经有 147 亿岁了。

相差十亿年😬

链接

Leda——星系物理学数据库
维基百科上的宇宙年龄
Reddit 帖子
Python 代码的 Jupyter 笔记本
笔记本 PDF
Gihub 知识库

给你的关键词搜索一些语义上的爱！

原文：https://towardsdatascience.com/give-some-semantic-love-to-your-keyword-search-c35f16df2ee?source=collection_archive---------25-----------------------

Image source: https://ebiquity.umbc.edu

起初，搜索引擎 (Google，Bing，Yahoo 等。)是词汇:搜索引擎寻找与查询词匹配的字面，而不理解查询的意思，只返回包含精确查询的链接。但是，随着机器学习和自然语言理解领域的新技术(NLU)的出现，很快就发现语义搜索是前进的方向。

语义搜索是一种搜索技术，它不仅基于关键字返回结果，而且在获取相关结果时还会考虑上下文含义和用户的意图。

随着 2013 年蜂鸟更新，谷歌彻底改变了搜索引擎优化(SEO)流程。他们将重点从关键词搜索转移到理解上下文含义和用户意图的搜索，使用收集的搜索数据和 NLU 的概念，如词性标注、命名实体识别、单词嵌入等，扩展他们已经令人印象深刻的知识图。

虽然所有这些真的很令人兴奋，但我想写这篇博客的原因是为了展示两种简单的方法来为关键字搜索添加语义。我不会谈论知识图，仅仅是因为它是一个完全不同的概念，因此超出了本文的范围。

在这个练习中，我们将使用百万新闻标题数据集。标题已经被清理过了，所以除了将标题分成单词标记和删除停用词之外，不需要任何文本预处理。我已经创建了一个 50，000 个标题的小样本，我将它存储在 sample_data.parquet 中，我将使用它来节省计算时间，但是可以随意使用整个数据集。

样本数据集如下所示:

我想谈的两种方法是—

余弦相似性
平滑逆频率

余弦相似性

从数学上来说，余弦相似度是内积空间的两个非零向量之间相似度的度量，度量它们之间角度的余弦。0 的余弦为 1，对于区间(0，π] 弧度中的任意角度都小于 1。因此，这是对方向和而非大小的判断:具有相同方向的两个向量的余弦相似度为 1，相对于彼此成 90°方向的两个向量的相似度为 0，而完全相反的两个向量的相似度为-1，与它们的大小无关。

这种方法相当简单。我们将首先在数据集中创建每个标题的嵌入，然后，找到搜索标题和标题嵌入之间的余弦相似性，以找到相似的标题。对于预训练的单词嵌入模型，我们将使用fast text crawl-300d-2M-子单词，并使用我最近遇到的一个新模块 pymagnitude 加载它。如果你还没听说过可塑性的大小，我强烈推荐你在这里看看。它们提供了一个高度优化的库来读取和查询单词嵌入，即使模型非常大，并且它们支持几乎所有预训练的模型，包括 ELMo 。

现在我们已经加载了模型，是时候为数据集中的每个标题创建嵌入了。

text2vec 函数获取标题词标记，在预训练的模型中找到这些标记，并添加对找到的标记的嵌入。它还记录有多少单词被找到，然后被用于平均出最终的标题嵌入。我们做一个平均，因为标题和搜索标题将是可变长度的，这种方法在稍后阶段给出两者之间更好的成对比较。 get_docs_embedding 函数只返回所有标题嵌入的列表。

在我们开始看到结果之前，我们将添加一个名为 get_relevant_words 的函数。该功能将让我们提取在搜索的标题和匹配的标题之间匹配的语义相关的关键词。该函数从搜索的标题和我们正在查找相似性的标题中创建唯一的标记，并使用词对之间的余弦相似性来查找相关的词。

厉害！现在所有的部分都已经准备好了，让我们创建一个名为 semantic_search_cossim 的最终函数。这个函数将把搜索的标题、标题的嵌入、嵌入模型和返回的结果数作为输入，并返回一个带有结果的数据帧。我们开始吧。

以下是一些搜索及其结果:

如上所述，结果是很有希望的。这种方法通常被认为是一种基线方法，可以在此基础上进行改进以获得更好的结果。

平滑逆频率

如在第一种方法中所做的，取嵌入在句子中的单词的平均值，倾向于给予语义上完全不相关的单词太多的权重。平滑逆频试图用两种方式解决这个问题:

加权:像 TF-IDF 一样，SIF 对句子中嵌入的单词进行加权平均。每个单词嵌入都由a/(a + p(w))加权，其中a是通常设置为0.001的参数，p(w)是该单词在参考语料库中的估计频率。
公共成分去除:接下来，SIF 为一组句子计算结果嵌入的主成分。然后，它从这些句子中减去嵌入在它们的第一主成分上的投影。这应该移除与语义上不太相关的频率和语法相关的变化。

我们来直观的看一下。根据a/(a + p(w)),,出现频率高的单词的权重较低，因为p(w)对于这些单词来说较大。我们通过移除我们生成的句子嵌入的第一主成分并从每个单独的句子嵌入中减去它来进一步增强句子嵌入。因此，由于 PCA 中的第一个成分是具有最大方差的成分，因此来自杂散字的大多数变化通过该操作被平滑。你可以从上面链接的文章中读到更多，但是现在，我们将使用 SIF 在我们的数据集上进行语义搜索。

我们将使用具有 SIF 优化实现的 fse 库。该库已经由 Oliver Brochers 开发，你可以在这里阅读它的实现。对他大吼一声！

注意: fse 与 gensim 库一起工作，因为两者使用相同的 cython 实现。同样，对于这种方法，我们不会删除停用词，因为 SIF 会自己处理常用词。对于文本处理，我们只是将标题分割成空间上的单词标记。

我用的是 glove.42B.300d ，可以从这里下载。

功能 glove_to_w2v 将手套模型转换成 gensim 模型，然后与 fse 兼容。这个函数只需要调用一次。函数 init_model 加载并返回新转换的模型。

一旦我们加载了模型，我们将所有的标题分割成空间上的单词标记，并调用 fse 的 IndexedList 函数。

IndexedList 函数给出了下面的输出——每个标题都被标记化，并分配了一个索引号。

(['drug', 'test', 'records', 'destroyed', 'landis'], 0)
(['grains', 'council', 'awaits', 'awb', 'restructure', 'details'], 1)
(['plan', 'to', 'move', 'year', '7', 'to', 'high', 'school'], 2)
(['teen', 'jailed', 'over', 'after', 'boy', 'brain', 'damaged'], 3)
(['awb', 'drops', 'plan', 'to', 'boost', 'directors', 'pay'], 4)

这样，我们就可以训练我们的 SIF 模型了。一旦完成训练，您可以使用 pickle 保存模型，然后只需加载 SIF 模型并进行搜索。在此之后，除非有新的数据集进入，否则不需要上面提到的任何步骤。

这里的最后一个函数是 semantic_search_sif ，它将搜索到的标题、sif 模型、数据、预训练的嵌入模型、索引标题作为输入，并返回一个数据帧作为输出。注意 SIF 模型的相似逐句功能。该函数的输出是一个包含元素的元组(<句子>、<句子的索引>、<相似度得分>)。例如

(['anchina', 'attack'], 41199, 0.7434917688369751)

这就是为什么我们考虑索引 1、2，因为它们分别代表标题的索引和相对于被搜索标题的相似性得分。

SIF 模型的结果如下:

结论

在这篇博客中，我们研究了什么是语义搜索，以及可以用来实现语义搜索的几种基本方法。现在，关键字搜索已经成为过去，每个搜索引擎都应该足够聪明，能够理解用户查询的上下文，并相应地返回结果。自然语言理解刚刚开始展示它的力量，不可思议的事情还在后头。

成为一名数据记者，给自己一个优势

原文：https://towardsdatascience.com/give-yourself-an-edge-by-becoming-a-data-journalist-c19c05c05d0e?source=collection_archive---------28-----------------------

Photo by Web Hosting on Unsplash

当你试图在网上搜索如何成为一名数据科学家时，会弹出许多项目，如数据科学、数据分析、商业分析等热门数据科学项目的名称。事实上，在线数据科学相关课程泛滥成灾。

然而，如果你已经在媒体行业工作，并希望进一步发展你的职业生涯，学习如何成为一名数据记者听起来更有吸引力。

为什么我决定成为一名数据记者

我在威斯康星大学麦迪逊分校主修传播艺术。但我想不通困扰大多数学生的问题:毕业后该做什么？
有这么多不同的机会可以考虑，我不知道该选择什么。

#1:在硅谷一家科技公司的工作经历

毕业后，我在硅谷做了一年的质量保证专家，以 NDA 的名义在库比蒂诺的一家财富 100 强公司进行桌面和移动应用软件测试。我通过定制的错误跟踪软件从用户体验中收集数据，以确保产品的质量，同时与其他测试人员、制作人员和开发人员合作。然而，我总是渴望得到一份与媒体相关的工作，尽管我热爱我的工作和我出色的同事。

#2:付不起我的房租

旧金山是众所周知的薪水最高的城市。

Image: Bloomberg, May 20, 2019

但是最高工资只针对 工程师 ，租金设置为 工程师工资。 而且说真的，比纽约市的房租还要贵。

Image: MarketWatch, May 22, 2016

我再也付不起在湾区的房租了(一间工作室每月大约 3500 美元)。当时我意识到，如果我想继续存钱，我必须找到一份与编码相关的工作。我还发现，与技术相关的工作增加了高薪留在美国的机会。

此外，我的公司教了我一些编程，他们建议我学习另一种编程语言，如 Python、Java 或 C 语言。我的同事已经工作了三年多，已经熟悉了至少一种编程语言。有时候在公司工作也要用终端，但当时听起来没什么意思。

#3:仍然想和媒体一起工作，但是作为一名“精通技术”的记者

这就是为什么我决定成为一名数据记者，用媒体的背景知识分析数据，根据分析的数据制作图表，通过媒体渠道展示见解。我认识到，美国许多与技术相关的工作仍然需要更多的人，媒体行业也需要更多的人。所以，我决定学习数据分析/数据科学和可视化。

我从专家那里学到了什么，我现在学到了什么？

我在 LinkedIn 上搜索了数据科学家的简介，以检查我必须学习哪些技能。我给著名的数据科学家发了消息和问题，他们中的一些人回答了问题。此外，我还可以从媒体中获得关于数据科学领域的非常有用的信息，我最喜欢的是 Adam Thomas 关于数据新闻的文章。他在文章中介绍了这样一个伟大的环节'datajournalism.com'。

人们还分享了他们获得数据科学家工作的经验或技巧。从他们的文章中，我意识到我的期望(DS =世界上最性感的工作)和现实(我要学的真正的东西比如 Python，SQL，机器学习等等)不匹配。这就是为什么我经常阅读这个领域的书籍。我全心全意地推荐彭凯莉的文章，它帮助我建立了一个强大的心态，因为这真的很重要。

现在我知道我至少要学习 Python、R、SQL 等一门编程语言，甚至线性代数等数学。为了可视化，我必须学习 Tableau、熊猫或 MATLAB/Seaborn。事实上，我目前正在学习和使用 Python，MySQL，Tableau，Pandas 和 MATLAB。是的，这真的很难。但是每个人都知道入门——学习软件的用户界面——是最难的部分。现在，我越来越熟悉使用这些技能，而且变得越来越有趣。

对于想在数据相关领域开始职业生涯的新手，我希望这篇文章有助于你了解这个领域。我会继续写我的经验、项目和关于数据科学的想法。

在 Expedia 面试了 60 名候选人后，给出了一些数据科学面试的技巧

原文：https://towardsdatascience.com/giving-some-tips-for-data-science-interviews-after-interviewing-60-candidates-at-expedia-395fff7e073b?source=collection_archive---------5-----------------------

Courtesy of www.superdatascience.com

在过去的一年里，我面试了很多人申请 Expedia 集团的数据科学职位，从初级到高级，有些是硕士/博士研究生，有些来自其他公司(如微软、亚马逊、Spotify、Twitter)，我想在这里分享我的经验，以便对申请数据科学职位的人有用，并就可能遇到的问题给你们一些提示。

面试候选人帮助我认识了具有广泛背景和技能的人，从 CS/ECE、统计/数学到土木/机械工程，我有机会与几位杰出的人交谈。

在我进入更多细节之前，我想提一下，近年来“数据科学家”有了更好的名字，如“机器学习科学家”和“应用科学家”。虽然在一些公司，这些职位所指的任务/技能略有不同，但对大多数公司来说，这三个头衔或多或少指的是同一件事。所以在这篇文章中，我所说的“数据科学”指的是上面所有的标题。

虽然每个人都有他/她自己独特的一套技能，可用于解决一些问题，但大多数公司都希望数据科学候选人具备一套基本技能，我将把这些技能分为以下几类，然后详细讨论。根据公司和职位级别的不同，您可能会从以下一个或多个项目中得到问题，因此您可能希望提高您在这些方面的背景知识:

关于你的简历和以前作品的问题
通用机器学习(和深度学习)知识
普通统计和数学知识
编程和软件工程技能
统计建模技巧
计算机视觉、自然语言处理和定价主题
沟通和表达技巧
行为问题
系统设计技巧(视职位级别而定)
管理和领导技能(取决于职位级别)

1。关于你的简历和以前作品的问题

你的简历在面试中会被问到的问题中起着至关重要的作用。所以，确保你对简历中提到的任何东西都足够熟悉，从课程和研究项目到编程语言。像“告诉我更多关于你自己和你的背景”，或者“告诉我你在你现在的公司的工作”这样的一般性问题很常见，但是你也会得到关于你简历的更详细的问题。

例如，如果你在简历中提到几个以前与 NLP 相关的项目，你应该对 NLP 主题有很好的理解，并且很有可能会得到一些关于 NLP 的技术问题，以评估你在这方面的技术深度。因此，如果你在一个项目上做了一些合作，但对工作贡献很小，我建议你让自己更熟悉那个项目的技术方面。

或者，如果你提到 Python 或 Scala 是你最喜欢的编程语言，请确保你了解这些语言的细节(至少了解数据科学职位所需的程度)，以及每种语言中的一些机器学习相关的库。我看到许多候选人在简历中提到 Scala/Python，但是当我问他们一个关于这些语言的简单问题时，他们对此一无所知，这将给我一个负面的信号。如果你对这些语言的经验非常有限，最好诚实地告诉面试官这一点，我相信大多数面试官不会因为你没有足够经验的事情来评判你。

2。通用机器学习(和深度学习)知识

虽然不同公司的数据科学工作可能涉及广泛的问题和技能(包括数据提取和预处理，运行 SQL 查询，简单的数据分析，到深度学习，NLP 和计算机视觉)，机器学习是一个基本概念，是当今大多数顶级公司对“数据科学候选人”的期望。因此，如果你申请的是数据科学职位，请确保你对以下机器学习概念有很好的理解。像“统计学习的要素”[1]和“模式识别和机器学习”[2]这样的书对这些主题很有用。

监督和非监督算法
经典分类算法，如 SVM、逻辑回归、决策树、随机森林、XGboost
经典回归算法:线性回归、LASSO、随机森林、前馈神经网络、XGboost
聚类算法，如 K 均值和谱聚类
降维技术，如 PCA、LDA 和自动编码器。
偏差-方差权衡
过拟合以及如何避免过拟合(例如正则化、特征选择、丢失(对于神经网络))
著名的深度学习模型，如卷积神经网络(CNN)、递归神经网络(RNN)和 LSTMs、自动编码器、残差架构、序列到序列模型、GANs
评估指标，如分类准确度、精确度、召回率、F1 值、均方误差、平均绝对偏差
流行的损失函数，如交叉熵、MSE、三重损失、对抗性损失、利润最大化损失等
反向传播
也许还有强化学习和深度 Q 学习(更多研究型岗位)
线下和线上(A/B)指标对比？

上面列出的项目涵盖了一些与数据科学职位相关的高级机器学习概念，但您也可能会被问及一些关于上述主题的更详细的问题，例如，您可能会被问到:

SVM 和逻辑回归分类的比较
生成模型和判别模型之间的差异
消失渐变问题背后的根本原因以及避免该问题的一些常见做法
批量梯度下降时使用动量的优势

3。普通统计和数学知识

今天的许多数据科学家曾经是统计学家和分析人员，许多 ML 模型只是(重新标记的)统计学习模型(如线性回归、岭回归、LASSO、logistic 回归)。所以毫不奇怪，许多面试官喜欢问一些关于统计或数学的问题。

对于统计和概率，如果你熟悉以下概念会更好:

模型的偏差和方差以及如何计算
从分布中抽样
置信分数和给定置信分数所需的样本数量
均值、方差、相关性(统计意义上和经验意义上)
随机过程，随机漫步(金融公司数据科学职位)
如何求某事件的概率
P 值
R 平方(决定系数)解释

对于数学问题，您可能会被问到以下主题的问题:

一些需要思考的脑筋急转弯问题
如何计算特定损失函数的梯度
关于损失函数或优化算法的一些详细问题

4。编程和软件工程技能

任何数据科学家都需要进行某种程度的编程。在初创公司(员工人数较少)，数据科学家可能需要自己做大量的软件工程工作，例如数据提取和清理，以及模型部署。相比之下，在较大的公司中，有其他人负责数据工程和模型部署，数据科学家主要处理特定产品的培训和测试模型。作为一名数据科学家，你还需要了解数据工程角色所需的一些术语和任务，比如 ETL(提取、转换、加载)。在这里，我将介绍数据科学家使用的一些最广泛的编程语言、库和软件。

像 Gayle Laakmann McDowell [3]写的《破解编码面试》这样的书对准备软件工程和算法问题非常有帮助。也有一些很棒网站，它们有很好的软件工程问题数据库，比如 leetcode、hackerrank 和 geeksforgeeks。

4.1 编程语言

在编程语言方面、 Python、、 SQL 、 R 似乎是人们使用最多的语言，但我也见过有人使用其他语言如 Java、【c++】、 Matlab (虽然不是编程语言)。

4.2 有用的 Python 库

在这里，我将提到一些与数据科学职位最相关的 Python 包:

对于机器学习和数值计算， Scikit-learn、XGboost、LIB-SVM、Numpy、Scipy 是应用最广泛的软件包。
深度学习方面， Tensorflow，PyTorch，Keras 应用广泛。
对于数据可视化来说， Matplotlib、Seaborn、ggplot 是最受欢迎的(尽管还有很多其他有用的包)。
对于计算机视觉来说， OpenCV 和 PIL 都很有用。
对于 NLP 来说， NLTK、GENSIM、Spacy、Torchtext 等包都很棒。
对于处理数据库， Pandas，PySpark 是 Python 中两个比较流行的库，我个人觉得很有用。

4.3 云服务

根据您要处理的数据规模，您可能需要在云服务上运行代码，如 AWS、Azure 或 Google Cloud。因此，有一些在云中运行代码的经验可能是一个额外的收获。您肯定不需要了解所有不同的云服务，但是对 AWS 中的 EC2 之类的计算服务有所了解会更好。

一些公司也可能在 AWS 或 Azure 的基础上使用其他大数据服务，如 Databricks 和 Qubole，但我不认为需要有使用它们的经验，因为这些非常容易学习。

4.4 部署工具

在您为一个任务训练了您的模型(例如一个推荐系统，或者一个审核模型)之后，理论上您希望在生产中使用它。因此，有人(可能是您，或者您正在工作的工程团队)需要将您的模型部署到生产环境中。为此，熟悉 Python 中的 Docker 和 Flask 可能会有所帮助。如果您想在 AWS 等云服务上部署您的模型，熟悉 Sagemaker 可能会有所帮助。我个人并不认为熟悉部署工具是入门级数据科学职位的必要条件。

5。统计建模技巧

作为一名数据科学家，你需要为各种产品/问题建立数学和 ML 模型，因此你可能会在面试中遇到一些建模问题。这些问题通常与公司的领域有关。目标是看你是否能把概念上的知识应用到一个具体的问题上。您可能会遇到的一些示例问题包括:

你会如何建立一个机器学习模型来检测我们网站上的欺诈交易？
你会如何建立一个机器学习模型来向我们的客户推荐个性化的商品？
你将如何构建一个模型来检测我们网站上的虚假产品评论？
如何使用 ML 模型检测有害评论/推文？
你会如何建立一个模型来预测我们产品的价格？
你会如何建立一个模型来自动标记社交网络中用户上传的图片？
运行 A/B 测试时的在线指标？

根据您的回答，您还可能会得到一些后续问题，如您需要的数据类型、您将如何评估您的模型，或者如何随着时间的推移改进您的模型。如果你想了解更多的问题，像 https://medium.com/acing-ai/acing-ai-interviews/这样的网站很有用。

这里重要的是你的思维过程和你看到为一个产品建立一个 ML 模型的不同方面的能力。你绝对不需要给出最好或最花哨的答案；只要你对问题的高层次理解是合理的，你就是好的。

6.关于计算机视觉、NLP 和定价主题的问题

根据你所申请的团队的产品重点，你也可能会得到一些关于计算机视觉、NLP 或定价的问题。所以在面试之前，一定要对你申请的团队做一些研究，更好地了解他们的关注点。一些面试官可能会问你非常高级的 NLP 或视觉概念，而其他一些面试官可能会问更具挑战性的问题。

以下是一些你可能会遇到的与 NLP 相关的问题:

什么是词干化和词汇化？
什么是包话？TF-IDF 怎么样？
你如何发现两个单词之间的距离？有哪些著名的字符串距离度量？
什么是命名实体识别，您如何评价 NER 系统的性能？
如何训练 CRF 模型进行词性标注？
什么是公报功能，它们何时有用？
你会如何构建一个神经机器翻译模型？你如何评价它的性能？
word 2 vec 相比经典的一键编码有哪些优势？
你会如何建立一个问答系统？
你如何在一组文档中发现潜在的主题？
你如何看待顾客评论的情绪(极性)？
关于正则表达式的一些问题

这里有几个你可能会遇到的计算机视觉问题:

你如何将网站上的图片分成不同的类别(如电子产品、服装等)。)?
如何构建一个模型来自动标记图像中的不同人脸？
如何检测图像/视频的质量并过滤掉模糊的部分？
什么是超分辨率，您如何评价超分辨率模型的性能？
如何检测图像中的不同物体？
您如何检测图像中的文本区域？
你会如何创建一个自动图像标记系统？

以下是您可能会遇到的一些与定价相关的问题:

如何将用户分为活跃组和非活跃组？
如何设计亚马逊商品的折扣算法？
在有限的营销预算下，你如何设计一个竞价系统？
你如何为优步开发一个动态定价算法，以确保乘客总能收到快速方便的提货服务？
如何设计个性化的定价算法(虽然有些国家可能不允许)？
假设您为亚马逊商品开发了一个新的定价服务。在 A/B 测试中，要跟踪的最佳指标是什么？
假设你可以在你的平台/网站上展示一些广告。你如何开发一个广告评分或广告排名服务，使用户点击最大化？如果想收益最大化呢？
你如何决定在你的网站上向用户显示广告的最佳数量？
你如何估计客户的终身价值？

7 .。沟通和表达技巧

数据科学职位通常涉及大量的沟通和演示。这可能是为了与产品经理讨论一个新项目，或者向你的团队展示你的模型。因此，能够与其他人(包括技术人员和非技术人员)交流你的工作和想法是非常重要的。

有时你可能需要以非常专业的方式向你的同事或经理传达你的发现，而有时你可能需要说服产品经理你的模型对他们有用，而不需要太多的专业知识。

面试官通常不需要问你一个具体的问题来评估你的沟通和表达能力，他们可以在面试过程中很好地了解这些技能。我的建议是:

试着首先给面试官一个你的解决方案的高层次描述，然后进入细节。通过这样做，你可以得到一个反馈，如果你的高层次方法是正确的。
你可以明确地问面试官你的答案是否是他们想要的。如果结果不是他们感兴趣的，他们可以为你澄清问题，并给你一些建议。
尝试将一个建模问题分解成几个部分，然后分别关注每个部分。对于许多 ML 建模问题，您可以将它们分解为相关的数据提取、数据清理、特征提取、预测建模、评估和可能的改进。

8.行为问题

有些人可能还会在面试时问一些行为方面的问题。这些问题可以从你过去的工作经历(为了了解你是否具备工作所需的技能)到你的个人兴趣。这些问题也可以关注你过去是如何处理各种工作情况的。你对这些问题的回答可以揭示你的技能、能力和个性。下面是一些可能会问你的问题:

你更喜欢哪种职位，是涉及研究和 R&D 开发的职位，还是更喜欢将现有模型应用于公司内部数据并围绕它构建数据驱动的解决方案的职位？
你喜欢单独工作，还是与一群人合作解决同一个问题？
举一个你实现的目标的例子，告诉我你是如何实现的，你面临的挑战是什么？
举例说明一个你没有达到的目标，以及你是如何处理的？
告诉我，如果你需要交付一个模型来满足产品的最后期限，你会如何在压力下工作？

9。系统设计技能(取决于职位级别)

根据你所申请职位的级别，你还可能会得到一些系统设计面试(SDI)的问题，这些问题大多是关于“设计大型分布式系统”的问题。

由于缺乏开发大规模系统的足够经验，以及没有标准答案的设计问题的开放性，这些问题可能具有挑战性。

我不会在这里谈论太多关于 SDI 的问题，因为这不是这篇文章的重点，但是我会提供一些示例问题，以及一些有用的资源，如果你想在这方面得到更多的实践。

以下是一些系统设计问题示例:

你会如何设计像 Youtube 或网飞这样的视频流媒体服务？
你会如何设计 Facebook Messenger 或 WhatsApp？
你会如何为客户服务设计聊天机器人？
设计 Quara 还是 Reddit？
设计 Snapchat 这样的 app？
你会如何设计像 Dropbox 或 Google Drive 或 Google Photos 这样的全球存储和共享服务？
你会如何设计像 Twitter 或脸书这样的服务？
你会如何为谷歌或 Expedia 设计一个预输入系统？

以下是面试设计问题的一些有用资源:

https://github.com/checkcheckzz/system-design-interview
http://blog . gain lo . co/index . PHP/category/system-design-interview-questions/
https://hacker noon . com/top-10-system-design-interview-questions-for-software-engineers-8561290 f 0444

10。管理和领导技能(取决于职位级别)

如果你申请数据科学经理职位(有时甚至是高级或主要职位)，面试官将需要评估你的管理和领导技能，并了解你以前的管理经验。

这位候选人的理想背景是在机器学习和预测建模等领域拥有强大的理论背景，以及良好的软件工程技能。要成为一个有效的领导者，候选人还需要有很好的沟通技巧，以及良好的规划技巧，能够以一种考虑到构建数据驱动产品所带来的许多风险的方式进行优先排序和规划。

我不打算深入探讨管理技能，但我会在这里提供一些示例问题:

你管理过的最大的团队是什么，你面临的挑战是什么？
假设你的团队已经建立了一个在测试集上达到 90%准确率的模型。为了决定模型性能是否可靠，需要知道什么？
讨论一个可以影响我们公司的数据驱动型产品
当你想为你的团队雇人时，你会考虑什么？
你会如何吸引顶尖人才加入你的团队？
你认为一名数据科学家必备的技能是什么？
什么是大数据，您熟悉大数据架构吗？
你如何在工作中保持最新状态？
你如何判断与另一个团队的合作是否成功？

在这篇文章中，我试图提供一些提示，以及一些你在 DS 面试中可能会遇到的高层次问题。鉴于数据科学角色的范围不断扩大，当然有一些主题和问题没有在这里讨论。但是我试图涵盖一些对于数据科学面试来说很重要的一般性话题。

我最后的建议是对你申请的团队/公司做更多的研究，更好地了解他们正在解决的问题。然后，您可以将主要精力放在准备与该团队相关的主题上。

参考

[1]https://web.stanford.edu/~hastie/ElemStatLearn/

[2]https://www . Microsoft . com/en-us/research/uploads/prod/2006/01/Bishop-Pattern-Recognition-and-Machine-Learning-2006 . pdf

http://www.crackingthecodinginterview.com/

滑向基于模型

原文：https://towardsdatascience.com/gliding-into-model-based-94aaf077d381?source=collection_archive---------21-----------------------

逻辑直观的解释

由于术语和复杂的数学公式，强化学习(RL)对于该领域的新手来说可能是一个令人畏惧的领域。然而，其背后的原理比最初想象的更直观。让我们想象 RL 是一个新的尚未发行的塞尔达游戏，发生在遥远的未来，2119 年。

林克在 2119 年的任务是从里顿豪斯那里拯救人类，这是一个位于 2019 年的秘密机构，拥有强大的人工智能和时间机器。因为里顿豪斯是邪恶的，他们设计了一个在 2119 年毁灭人类的计划，并及时派遣他们的特工去完成任务。

游戏开始时，林克降落在一个荒凉的小岛上，他必须在那里找到人类文明的第一个迹象，并警告他们里顿豪斯的特工即将到来。当他降落在一座塔的顶部时，一位年长的智者出现并送给他一个滑翔伞作为礼物。林克现在的任务是滑翔伞，并找到一个人类文明的城镇，以警告他们里顿豪斯。

林克是一个电脑外星人，可以在他的大脑中安装任何软件。他不知道如何玩滑翔伞。在 Ritten-House 的代理到达那里之前，你的目标是编写一个程序来教 Link 滑翔伞和所有的技巧，他尽可能快地到达人类文明，并尽可能避免 Ritten-House。你的计划是在里顿豪斯的特工来阻止他之前把这个模拟发送给林克，这样他就会知道如何保护自己。

你的计划是在未来通过光波向你发送这个程序。

为了设计这个程序，你需要知道一种叫做强化学习的东西。在强化学习中，有一个代理正在与环境交互。

我们基于称为马尔可夫决策过程 (MDP)的数学框架，对代理与环境的交互进行建模。每个代理从状态“X”开始，在每个时间步采取一个动作“A”，得到奖励“R”，并进入下一个状态“Xt+1”，重复这个循环，直到代理达到目标状态“X`”。

现在，在你正在制作的模拟中，Link 作为滑翔伞是一个在天空中处于初始状态 X 的代理。在每个时间步，Link 从一组可能的动作中采取一个动作。在这里，向左或向右操纵他的风筝被认为是他可能的行动，他去了天空中一个新的状态或新的地方。他的目标是降落在目标州 x `，这是未来的几个州，在那里他可以找到人类文明。

在每一个时间步，基于他采取的每一个动作，他将在空间中处于不同的位置。例如，如果他把他的风筝转向右边，他会在一个不同的地方，当他把他的风筝转向左边。

然而，并非所有这些可能的行动都是同样有利的。他的目标是找到一系列最佳行动来实现他的目标。

这意味着你想让林克选择一条最有效的路线去接近人类。为了做到这一点，我们最好使用基于模型的方法。在基于模型的方法中，为了采取最优的行动，Link 还需要预测理想的未来状态，因此可以选择到达那里的最佳路线。

当 Link 在滑翔伞飞行时，他想知道他应该如何操纵他的风筝以便不坠落(即，找到最佳动作)。但是，他也想避开敌人并降落在最佳位置，如城镇所在的位置(即，预测下一个最佳状态)。

对未来状态的预测以及在哪里着陆才是正确的，这反过来会影响林克在当前时刻如何操纵他的风筝。你想根据他对未来状态的预测找到最佳行动。

林克可以预测敌人会在某个地点，为了避开敌人，他应该把风筝转向其他方向。

对未来状态的预测解释了环境是如何变化的。环境相对于当前状态和动作的这种变化被描述为一个函数，我们将这个函数称为模型。

你的目标是教林克学习这个模型。

模型的输入是当前状态 x 和动作 u 、，目标是预测未来状态 x t+1 。我们可以这样写:x t+1 =f(xt，ut)

我们称选择行动顺序直到剧集结束的过程为策略。直觉上，政策意味着林克如何在每一个时间点选择最佳方式来驾驶他的风筝，直到他最终到达城镇拯救人类。我们可以用下面的符号来描述策略:ut= лθ(xt)。这意味着在每个状态 xt，策略лθ告诉 Link 最佳动作 ut 是什么。

成本或奖励函数

我们使用成本函数或回报函数来寻找最优策略，或者换句话说，轨迹上的最优行动。根据不同的设置，我们使用成本或回报函数。

请注意，奖励只是成本函数的负值。我们试图最小化成本或最大化回报。在这个设置中，我们使用一个成本函数 c(xt，ut)。

寻找最佳行动与预测未来状态有什么关系？换句话说，最优策略与模型有什么关系？

在回答这个问题之前，我想让你想象一个世界，在这个世界里，这些功能中只有一个起作用。

你认为会发生什么？

第一种情况，模型能够预测下一个状态，但不能采取好的行动。

这里绿色是最佳的未来状态，模型有绿色和红色的预测。

这意味着，即使林克能够预测未来状态，他知道敌人在哪里，但他不能根据他对未来状态的了解采取好的行动。他不知道如何驾驶他的滑翔伞，并且向里顿豪斯坠落或消失，因为他不知道如何驾驶他的风筝。

现在，想象相反的场景，林克能够采取好的行动，并且是滑翔伞专家，但是他不能预测他的行动将带他去哪里。他知道如何驾驶他的风筝，但是他不知道去哪里。这也可能让他陷入困境。

这意味着他对未来没有任何预测。他可能会花很多时间根据他当前的情况和需要采取行动，而不是根据对未来状态的预测，也可能会随机搜索整个区域，直到他找到有人居住的城镇。这类似于许多无模型环境。预测使林克成为一个聪明的人，他能预测自己行为的后果，并根据这些预测做出决定。这也是理性的人类会做的。

再次以滑翔伞为例，林克能够在给定的时刻控制他的风筝不落下，但是他不记得敌人在哪里，结果，他不断地遇到他们，结果，他不清楚环境如何变化，他不能确切地知道哪个方向会把他带到城镇。

林克不仅需要知道如何驾驶他的风筝，还需要预测他应该去哪里，并根据他的预测驾驶他的风筝。现在，你可能对这两个函数为什么相关有了更好的直觉。

让我们从数学角度更详细地阐述这一点。

这是总损失的计算公式，我们正努力使其最小化。注意，这个损失由两个函数组成。

1.代价函数:c(xt，ut)。

2.，我们的模型~转移函数:f(xt-1，ut-1)

代替 c(xt，ut)中的 xt，我们可以把 x 写成它之前状态和它动作的转移函数。c(f(xt-1，ut-1)，ut)。我们可以将上述公式改写如下:

因为我们有一系列的步骤，所以我们试图将每一步的成本降到最低。因此，总损失是每个时间步的成本总和。

这直观地意味着，林克想要在任何时刻采取好的行动，而且是针对整个领域，直到他接触到人类。

该模型的承诺基于我们如何基于转移函数 f(xt，ut)找到预测未来状态 x t+1 的最优策略лθ之间的关系。

因此，现在我们要优化整个序列的总损失函数，包括两个函数:每个时间步的成本函数和转移函数。我们希望找到一种优化技术，使这两个函数的损失最小化。我们可以使用线性或非线性优化。我们可以使用神经网络来最小化总成本函数。

如果我们的环境是可区分的，我们可以通过反向传播进行优化。为了计算总损失，我们需要下列导数:

这部分就是我们所说的模型。我们想了解关于状态和动作的模型:

这部分是我们的成本。我们想了解状态和行为的成本:

世界模型

到目前为止，您已经了解了基于模型的方法，我们可以使用基于模型的方法之一——世界模型——作为 Link 模拟软件背后的核心机制。

这里，MD-RNN 类似于用于预测未来状态的转移函数 x t+1 =f(xt，ut)。然而，它只是与我们所学的略有不同。MD-RNN 增加了自己的隐藏状态来预测未来状态和 ht+1。

你可能还记得，之前我们讨论过根据设置，我们使用成本或回报函数。世界模型使用奖励而不是成本函数。这里，控制器网络充当奖励函数，其目标是找到在整个推广过程中最大化累积奖励的策略。控制器的输入是 zt 和 ht，输出是 at 的最优动作。ht 是控制器网络用来预测最佳动作的附加变量。我鼓励你自己阅读《世界模型》。

谢谢你救了林克·❤

Apache Spark 3.0 一瞥[早期访问]

原文：https://towardsdatascience.com/glimpse-into-spark-3-0-early-access-c1854327d6c?source=collection_archive---------14-----------------------

图沙尔·卡普尔😦【https://www.tusharck.com/】T2

Apache 继续保持强势地位，展示了其针对大数据科学的 Spark 3.0 预览版。根据预告， Spark 即将推出几大重要功能。

你可以从这个链接下载预览版:https://archive.apache.org/dist/spark/spark-3.0.0-preview/

让我们看看它的一些主要功能，这些功能为其大数据统一分析的目标注入了活力。

火花图:密码脚本&属性图

Spark 3.0 中加入了流行的图查询语言 Cypher，它通过属性图模型 a directed multigraph 进行耦合。图形查询将遵循与 SparkSQL 相似的原则，它自己的催化剂为数据帧提供完全支持。

点击查看 Databricks 在 Spark 3.0 图形 API 上的会话。

Python 3，Scala 2.12 和 JDK 11

Spark 3.0 有望完全迁移到 Python3。
Scala 版本升级到 2.12。
它将全力支持 JDK 11 号。

深度学习:增加 GPU 支持

这是每个数据工程师和科学家都在寻找的东西，而 Spark 3.0 符合他们的期望。带 NVIDIA 的 Spark 3.0 提供 GPU 加速，可以跨多个 GPU 运行。它支持 AMD、Intel 和 Nvidia 等异构 GPU。对于 Kubernetes，它提供了执行程序 pod 级别的 GPU 隔离。除此之外，我们还得到了:

熊猫 UDF 的 GPU 加速。
您可以指定 RDD 操作中的 GPU 数量。
为了轻松指定深度学习环境，有 YARN 和 Docker 支持推出带 GPU 的 Spark 3.0。

日志丢失:支持

您还可以设置您的指标的物流损耗。

val evaluator = new MulticlassClassificationEvaluator() .setMetricName("**logLoss**")

二进制文件

您可以使用二进制文件作为 spark 数据帧的数据源，但是，现在不允许二进制的写操作。我们可以期待在未来的版本中。

val df = spark.read.format(**BINARY_FILE**).load(dir.getPath)

库伯内特斯

现在，在最新 Kubernetes 版本的支持下，您将能够通过 Kubernetes 托管集群。它在运行时提供 spark-submit 变化的 web-hooks 配置修改窗格。它还改进了 Kubernetes 的动态分配。此外，我们得到:

支持 GPU 调度。
Kubernetes 后端的 spark.authenticate secret 支持。
Kubernetes 资源管理器现在支持 Kerberos 身份验证协议。

考拉:熊猫的星火尺度

考拉是 Apache Spark 上的熊猫 API，它使数据工程师和科学家在与大数据交互时更有效率。随着 3.0 功能发布，考拉现在可以扩展到分布式环境，而不需要单独读取 Spark 3.0 数据帧，这与以前的单节点环境不同。

import databricks.koalas as ks
import pandas as pd

pdf = pd.DataFrame({'x':range(3), 'y':['a','b','b'], 'z':['a','b','b']})

# Create a Koalas DataFrame from pandas DataFrame
df = ks.from_pandas(pdf)

# Rename the columns
df.columns = ['x', 'y', 'z1']

# Do some operations in place:
df['x2'] = df.x * df.x

以上例子摘自考拉吉特回购。

卡夫卡流:包括磁头

现在你可以在Kafkastreaming(git)中读取标题了。

val df = spark .readStream .format("kafka") .option("kafka.bootstrap.servers", "host1:port1,host2:port2") .option("subscribe", "topic1")
**.option("includeHeaders", "true")**
.load()df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)", **"headers"**) .as[(String, String, Map)]

纱线特征

纱线还获得了一组新特征，主要是:

Spark 3.0 框架现在可以自动发现集群或系统上的 GPU。
可以调度 GPU。

你可以在这里查看 YARN 的 GPU 配置:https://Hadoop . Apache . org/docs/r 3 . 1 . 0/Hadoop-YARN/Hadoop-YARN-site/using GPU . html

分析缓存数据

现在您可以分析 Spark 3.0 中的缓存数据，这是 Spark ( git )最想要的特性之一。

withTempView("cachedQuery") {
  sql("""CACHE TABLE cachedQuery AS
          |  SELECT c0, avg(c1) AS v1, avg(c2) AS v2
          |  FROM (SELECT id % 3 AS c0, id % 5 AS c1, 2 AS c2 FROM range(1, 30))
          |  GROUP BY c0
       """.stripMargin)
**// Analyzes one column in the cached logical plan**
sql("**ANALYZE** TABLE cachedQuery COMPUTE STATISTICS FOR COLUMNS v1") **// Analyzes two more columns**
sql("**ANALYZE** TABLE cachedQuery COMPUTE STATISTICS FOR COLUMNS c0, v2")

动态分区剪枝

它通过在散列连接中重用维度表广播结果，在运行时提供优化的执行。这有助于 Spark 3.0 更有效地处理基于星型模式的查询，从而消除了 ETL 非规范化表的需要。

点击查看 Databricks 关于 Apache Spark 中动态分区修剪的会话。

三角洲湖

Delta Lake 是一个开源存储层，为 Apache Spark 3.0 带来了 ACID 事务，并且由于其易于实施和升级到任何现有 Spark 应用程序，它为数据湖带来了可靠性。

参见三角洲湖泊快速启动:【https://docs.databricks.com/delta/quick-start.html

发展中地区的全球变暖和疟疾:Python 中的分析

原文：https://towardsdatascience.com/global-warming-and-malaria-in-developing-regions-an-analysis-in-python-69a9ba52f83a?source=collection_archive---------15-----------------------

Photo by Pixabay on Pexels

气候变化预计会对尼日利亚、海地和也门等发展中国家产生不利影响。这些影响包括因昆虫和害虫增加造成的食物短缺、人口迁移和疾病传播。世界卫生组织将气候变化描述为疾病的威胁倍增器:

它应对现有的威胁——无论是霍乱爆发、寨卡病毒向新地理区域的传播，还是干旱带来的严重营养不良——并增强这些威胁。风险是熟悉的，但它们的影响在频率和严重性上被放大了。气候变化会扩大传染病的分布，特别是由蚊子和其他媒介传播的疾病，并引发其他疾病的出现。尼帕病毒和汉坦病毒作为人类病原体的出现被追溯到极端天气事件，这些事件迫使动物宿主离开它们的生态位并入侵人类住区。

有很好的历史证据表明气候条件和传染病之间的联系。具体而言，疟疾是一种病媒传播的疾病，预计将受到全球变暖的显著影响。

在之前的一篇文章中，我们研究了气候变化如何影响水稻和小麦等作物的产量。在本帖中，我们将对由数据中心提供的公共气候变化数据和由ourworldindata.org提供的全球疟疾死亡数据进行简单的探索性分析。

我们从导入 python 库 Pandas 开始:

import pandas as pd

我们要查看的第一个数据集是年度全球气温数据。我们可以将数据读入 dataframe 并打印前五行:

df_global_temp = pd.read_csv("annual_temp.csv")
print(df_global_temp.head())

接下来，我们可以过滤我们的数据，以便我们只获得与 NASA GISTEMP 源相对应的记录:

df_global_temp = df_global_temp[df_global_temp['Source'] == 'GISTEMP'].reset_index()[["Source", "Year", "Mean"]]
print(df_global_temp.head())

接下来，我们可以绘制年平均温度与时间的关系图。接下来，我们导入 python 可视化软件包“seaborn ”,并绘制时间序列的线图:

import seaborn as sns
sns.set()
sns.lineplot(df_global_temp['Year'], df_global_temp['Mean'])
plt.ylabel("Mean")
plt.title("Average Global Mean Temperature")

接下来我们可以看看 ourworldindata.org 提供的每 1000 人中疟疾的平均发病率。让我们将“incidence-of-malaria.csv”数据读入一个数据帧，并查看前五行:

pd.set_option('display.max_columns', None)
df_malaria = pd.read_csv("incidence-of-malaria.csv")
print(df_malaria.head())

我们还可以观察一组独特的区域:

from collections import Counter
print(set(df_malaria['Entity'].values))
print("NUMBER OF REGIONS: ", len(set(df_malaria['Entity'].values)))

数据集仅包括每个区域 4 个点，共有 127 个区域。每个地区的数据都不多，所以任何分析都应该持保留态度。知道发展中地区更容易遭受气候变化带来的风险，缩小我们的范围将是有益的。《时代》杂志称，尼日尼亚、海地、也门、菲律宾和斐济将面临气候变化带来的最严重后果。

考虑到这一点，我们可以从尼日利亚的疟疾发病率开始:

df_malaria = pd.read_csv("incidence-of-malaria.csv")
df_malaria = df_malaria[df_malaria['Entity']=='Nigeria'].reset_index()[["Entity", "Code", "Year", 'Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)']]
print(df_malaria.head())

接下来我们可以绘制 2000 年至 2015 年尼日利亚的疟疾发病率:

sns.lineplot(df_malaria['Year'], df_malaria['Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)'])
plt.ylabel("Malaria incidents in Nigeria (per 1,000 population at risk)")
plt.title("Malaria incidents in Nigeria")

接下来，我们可以叠加全球年平均气温(为清晰起见，以 100 为因子)和尼日利亚的疟疾发病率:

df_global_temp = df_global_temp[df_global_temp['Year'] <= 2015]
sns.set()
sns.lineplot(df_global_temp['Year'], df_global_temp['Mean']*100)
plt.ylabel("Mean")
sns.lineplot(df_malaria['Year'], df_malaria['Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)'])
plt.ylabel("Malaria Incidence (Orange)/Global Mean Temperature Scaled by 100 (Blue)")
plt.title("Malaria Incidence in Nigeria and Global Mean Temperature")

虽然我们可以看到随着平均气温的上升，疟疾发病率的下降开始趋于平稳，但气候变暖与疟疾发病率平稳之间的联系并不令人信服。

我们也可以看看海地:

df_malaria = df_malaria[df_malaria['Entity']=='Haiti'].reset_index()[["Entity", "Code", "Year", 'Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)']]
print(df_malaria.head())

sns.set()
sns.lineplot(df_malaria['Year'], df_malaria['Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)'])
plt.ylabel("Malaria Incidence in Haiti (per 1,000 population at risk)")
plt.title("Malaria Incidence in Haiti")

海地的数据更不令人信服。我们可以叠加温度和疟疾数据:

df_global_temp = df_global_temp[df_global_temp['Year'] <= 2015]
sns.set()
sns.lineplot(df_global_temp['Year'], df_global_temp['Mean']*100)
plt.ylabel("Mean")
sns.lineplot(df_malaria['Year'], df_malaria['Incidence of malaria (per 1,000 population at risk) (per 1,000 population at risk)'])
plt.ylabel("Malaria Incidence in Haiti (per 1,000 population at risk)/Global Mean Temperature Scaled by 100 (Blue)")
plt.title("Malaria Incidence in Haiti and Global Mean Temperature")

在这一点上，从数据中得出任何结论都需要更详尽的分析。我们将在这里结束我们的分析，但请随意查看其他地区的疟疾发病率以及 datahub 上提供的一些其他气候变化数据。这篇文章中的数据集和代码可以在 GitHub 上找到。感谢您的阅读！

使用 char ngram 语言模型构建 Gmail 风格的智能撰写

原文：https://towardsdatascience.com/gmail-style-smart-compose-using-char-n-gram-language-models-a73c09550447?source=collection_archive---------6-----------------------

“OpenAI 构建了一个非常好的语言模型，发布它被认为太危险了”——Techcrunch

Image Source: Open AI’s GPT-2 (SoTA Language Model)

让我们从头开始构建一个简单而强大的语言模型，并将其用于文本生成。

如果你是一名 Gmail 用户，现在你应该已经体验过智能撰写功能(甚至可能不知道你实际上正在使用它)。这是新的自动补全句子功能，将电子邮件的工作效率提升到一个令人兴奋的新水平。是在 Google I/O 2018 发布的。对于那些没有使用过智能合成的人来说，我们首先将它与传统的预测文本和自动完成功能进行对比。

内容:

智能作曲比你想象的要聪明
语言模型，RNNs 和 Seq2Seq 建模
实验
演示

智能作曲比你想象的要聪明

我们每天都在进行大量基于文本的交流。今天，大多数网络和移动应用程序都有很好的功能来提高工作效率。例如， Whatsapp 提供预测文本，而谷歌搜索 会在你输入时自动完成趋势搜索。总的来说，两者都提供了简单的基于模型的前缀搜索，即用户输入的文本被用作前缀来预测用户可能想要输入的下一个单词(在 Whatsapp 的情况下)或用户的搜索意图(在谷歌搜索的情况下)。如果你认为 smart compose 是预测文本和自动完成的漂亮扩展，你不会错，但它还有更多。差异是细微的。如下图所示。

Whatsapp 预测文本

正如你所看到的，Whatsapp 会预测下一个可能的单词，并向你展示前三种可能性。虽然它是基于模型的，但它只预测下一个单词(一元词)或最多下一个单词对(二元词)，但仅此而已。但是公平地说，这对于 messenger 的情况来说已经足够好了。

Whatsapp predictive text

谷歌自动完成

query autocomplete(如下所示)也是一个基于模型的解决方案，它考虑到了到目前为止键入的搜索短语，并对趋势搜索运行前缀搜索。(我掩饰了许多复杂的细节，但对于这篇文章的范围来说，这已经足够了)

Google Search Autocomplete

智能作曲

单词级别的预测文本很棒，但它们只适合用户输入短时出现的情况。但是对于电子邮件，用户需要在多封邮件中一次性输入大量文本。因此，用户需要输入的内容越少，用户体验和工作效率就越高。此外，在电子邮件中，如果你仔细看，我们最终会重复很多句子，从问候到基本的客套话到结束语(它们是程序员害怕的胶水代码(或锅炉板代码)。

这就是 smart compose 的与众不同之处，它是一个真正的生产力提升工具。它不仅使用当前文本，还使用主题和上一条消息(如果用户正在回复)来为您完成句子。如果你仔细观察，你会发现不同的补全是在不同的层次上完成的——有些补全是在两三个单词之后完成的，而有些是在几个字符之后完成的。

How smart compose saved me at least 25 keystrokes in one email. (Watch out how the To and Subject line are factored into the prediction)

动机

NMT(神经机器翻译)已经成为解释序列到序列模型(Seq2Seq 模型)的典型用例。虽然这并没有错，但依姆霍·NMT 并没有公正地对待 Seq2Seq 范式所能提供的所有魔力。此外，机器翻译还不是一个很好解决的问题(至少在撰写本文时是这样)。但看看智能电子邮件回复(Kannan 等人，2016 年)和智能撰写(gmail)，它们是非常实用的解决方案，效果非常好。因此，我认为构建一个智能合成的实验原型可以对 Seq2Seq 模型提供一个全新的视角。

在进入技术细节之前，一个友好的提醒:这篇文章的其余部分假设对 Seq2Seq 模型，编码器-解码器架构，递归神经网络(RNNs 和它的表弟 LSTM，GRU)有基本的理解。但话虽如此，我保证尽可能简单地传达这一点，所以请耐心等待(可能会去喝一杯)

语言模型、RNNs 和 Seq2Seq 建模

语言模型:直觉

语言模型(LM)的现代体现是 NLP 作为一个领域发展的一个重要里程碑。所以，我们先从了解一个 LM 背后的直觉开始。

Image Source: Sebastian Ruder (http://ruder.io/a-review-of-the-recent-history-of-nlp/)

LMs 学习文本语料库的表示，类似于嵌入了的单词，但是更好。我这么说是什么意思？简而言之，LM 的目标是分解文本语料库，并为文本序列分配概率，通常一次一个单词。(但也有其他变种)。

那么，这是如何工作的呢？对于我们语料库中的文本序列“狗对着陌生人吠叫”，基于单词的 LM 使用概率链规则一次一个单词地估计 P(狗对着陌生人吠叫))的概率。它从第一个单词(“the”)的概率开始，接着是给出第一个单词(“the”)的第二个单词(“dog”)的概率，然后是给出第一个&第二个单词的第三个单词的概率，依此类推。从数学上来说，LM 估计如下:

具体地说，LM 估计如下，其中 n 是单词的数量。

LMs 有许多不同的用例。其中之一是，一个 LM 可以告诉一个文本序列对于一个给定的语料库有多可能。例如，一个文本序列 P("一只没有翅膀的狗倒着飞)将产生一个非常低的概率，除非文本语料库来自一些虚构小说。但是这个用例对我们来说没那么有趣。更有趣的是，LMs 非常适合序列生成(在本例中是文本生成)

我们可以让一个 LM 生成一个任意长度的随机序列，带或者不带前缀(有时也称为种子或者提示)。前缀或提示可以是任何东西，一个单词或另一个任意长度的序列。例如，我们可以用一个单词提示一个 LM 生成一个随机的句子，或者我们可以用一个句子提示一个 LM 生成一个句子或一个段落。给定任意长度序列作为输入，生成任意长度序列的特例称为 条件生成， 作为输出以输入为条件。这就是为什么这个范例被称为 Seq2Seq 建模。机器翻译是条件生成的典型例子，因为它很容易将观点传递给读者。因此，下面显示的是经典 Seq2Seq 模型的布局，其中 x1，x2…xn 是输入序列， y1，y2..ym 为输出序列。(<开始>和<结束>是教师强制分隔符)

Layout of an RNN based Conditioned Generator

2.因此，如果你将这些点联系起来，Gmail 智能撰写只不过是一个“条件生成”，其输入序列=当前电子邮件+主题行+前一封电子邮件(如果你正在回复)，输出序列=预测的句子完成。(我鼓励你在这里停下来，试着在 gmail 中写一封邮件，看看条件生成是如何工作的)。下图显示了一种可能的智能合成模型架构

Conditioned generation in Smart Compose

好的，这些与 RNNs 和编码器-解码器架构有什么关系，它们之间有什么联系？让我们一次看一个

LMs 和 RNNs 有什么关系？ LMs 并不新鲜。过去，人们一直使用马尔可夫模型来学习 LM。但是它不是最好的选择，因为它有很多缺点，细节不在本文讨论范围之内。因此，长话短说 RNNs 作为 goto 架构出现，以进行序列建模，从而进行 LM，因为它们有望克服马尔可夫模型的缺点。尤其是 RNNs 可以无视马尔可夫限制并考虑长程相关性的事实。
【RNNs 和条件生成是如何关联的？下图显示了 RNNs 提供的几种不同的 Seq2Seq 造型风格。如果您将上面的条件发生器布局与这些图像进行比较，您会发现多对多 (n:m) 风格(即输入序列长度不等于输出序列长度)与条件发生器完全相同。(在这篇文章的上下文中，我们将考虑基于 RNN 的条件发生器，但还有更高级的架构，如 变压器 来实现条件发生器)

3。调理发生器和编码器-解码器是如何关联的？条件发生器只是编码器-解码器架构的另一个名称，而发生器、条件发生器是来自 NLP 文献的术语。事实上，术语“条件发生器”解释了该架构的功能，术语“编码器-解码器”只是简单地命名了该架构中的组件。

现在我们已经很好地把所有的事情联系在一起了。让我们想想如何实现这样一个有条件的生成器。

实验

合成数据集创建

电子邮件是混合了一些特定信息的通用文本序列的语料库。为这个用例提取和准备训练数据集可能会很棘手。以下是两大原因:

问候或开场白可以是“嗨，丽塔，你好吗？”我们不想学习“Rita”这个名字，但我们应该能够帮助写出开场白或问候语。
电话号码、位置、地址甚至银行账号等私人信息都可能是信息的一部分。因此，在创建训练数据集时，必须小心识别和排除敏感信息。事实上，为了防止在预测中泄露敏感或不相关的信息，在预测质量上妥协是可以的。此外，严重的违法行为可能会引发法律问题。

我使用安然公司的电子邮件数据集作为来源，为这个实验提取和准备了一些电子邮件。尽管如此，从电子邮件语料库中提取训练数据集还没有一个好的解决方案。所以如果你想玩玩，就发挥创造力。但是请记住，公平和隐私是最重要的。

在安然数据集中，整个电子邮件内容(收件人、主题、正文..)在一个 CSV 字段中。这里的是将那些字段拆分的代码链接，如果你想节省一些时间的话。

实施细节

Sample of some short messages used in this experiment.

上面列出的是可能带有或不带有主题的电子邮件的一小部分示例。需要注意几件重要的事情:

第一，如果你查看我展示的 gmail 如何完成句子的例子，你会发现预测实际上并不是等你完成一个完整的单词。如果你开始输入 【叫我 wi】它就会预测到 “有问题的话” 。所以我们可能需要一个比单词级更细粒度的 LM，因此我选择在 char ngram 级构建。实现这一点的一种方法是准备数据集，如下所示:

二、主题文本作为数据准备的一部分被添加(前缀)到邮件正文中，所以单个培训记录=主题文本(如果有的话)+消息文本

同样，这纯粹是出于实验目的，因为对于大型语料库，这种类型的数据准备会非常占用内存，因为一个文本序列会变成多个带有字符 ngram 前缀的序列。

那么，一个 char ngram 级 LM 如何改变我们的编码器-解码器架构呢？不会，架构是一样的，但是它训练的方式变了(如下所示)。

Char n-gram conditioning for generation (shown in red)

要点:运行良好的架构选择是 BiLSTM 编码器和LSTM 解码器。为了简单起见，我用 Python 写了这个。我还构建了一个简单的 HTML 应用程序和一个 REST 端点来演示模型如何工作(或者它是否可用)。我的还没有在任何地方托管应用程序，所以你现在可以查看演示(如下)。但是我会尽快更新演示的链接。

代码

链接到 LM 代码(笔记本)
链接到安然电子邮件数据集准备代码(要点)

未来工作和可能的延期

理解以上 LM 的困惑。
添加注意机制。
用变压器替换 LSTMs。
尝试更长的消息和提示。

演示

现在交给你了，

生成具有不同粒度提示的文本序列的能力非常强大。我们能从这里去哪里？我们能不能不仅仅着眼于提高生产率？为医生打造智能处方创作功能？面向律师的智能合同创作功能。看到了吗？可能性是无限的。我希望我已经调整了你的主动性，所以继续扩展这个想法，建立一个伟大的解决方案。我很想听听你会如何扩展这个想法。

参考和启示

[1] Jason B r ownlee，如何用 Keras 在 Python 中开发基于单词的神经语言模型

[2] TF 团队，原创 Tensorflow NMT 教程

[3]塞巴斯蒂安·鲁德，自然语言处理的神经历史回顾

[4]打开 AI，GPT-II 根据种子提示生成随机文本

[5] Yoav Goldbe r g， NLP 图书

我欢迎反馈和建设性的批评。你可以在 Twitter @prithivida 上找到我，或者你可以在这里留言。

读研还是找工作？有抱负的数据科学家的困境

原文：https://towardsdatascience.com/go-to-grad-school-or-get-a-job-the-dilemma-of-aspiring-data-scientists-cfe8be2c17bf?source=collection_archive---------20-----------------------

我是如何做出这个决定的，我学到了什么

Photo by Vasily Koloda on Unsplash

进退两难

当我大学的最后一个学期开始时，一种平静的恐慌笼罩着我。当五月到来，我正式毕业时，我不知道我要做什么。我只知道我想成为一名数据科学家。我要完成的方式对我来说一点也不清楚。这段时间很多人问我要做什么。我默认的答案是我要去读研究生。这似乎给真正的成年人留下了深刻的印象，并且很好地掩盖了我的困惑。快进到五月底。我最后一次走出校园，直接投入到我作为数据科学家的新工作中。

帮你做决定

对我来说，决定做全职工作而不是去读研并不容易。我假设如果你正在读这篇文章，你正面临，或将面临同样的决定。我来给你一个快速剧透:这不是一篇论证你为什么不应该读研的文章。我不认为我做的决定对每个人都是普遍正确的。对你来说，正确的决定取决于你的喜好和能力。

所以如果我不告诉你该做什么决定，这篇文章的意义是什么？当我试图为自己做这个决定时，我收到了很多建议。大多数人只是告诉我他们认为我应该选择哪一个。不过，我收到的最有用的建议来自少数几个给我提问题让我思考的人。他们帮助我根据自己的情况做出正确的决定。根据我的经验，我想分享我收到的最有用的建议，以帮助你做出正确的决定。

想想你想要什么

这似乎是显而易见的，但这是我纠结了一段时间的事情。当我花些时间思考什么能让我快乐时，我意识到我其实并不想去读研。我把它看作是通向数据科学职业生涯的一种手段，而这正是我真正想要的。花时间思考这个问题帮助我认识到研究生院不应该是我的第一选择。

你需要问问自己为什么考虑读研。有很多很好的理由可以解释为什么读研会是你最想做的事情。例如，如果你真的喜欢学习，想发展更多的技能，或者喜欢做研究，那么读研可能是你比工作更想要的。你也可能像我一样，对职业比对学术更感兴趣。一旦你弄清楚你真正想要的是什么，你就可以开始优先考虑你的选择。

想想什么是可以接受的

一旦你知道自己真正想要的是什么，就该想想自己能接受什么了。例如，我决定数据科学工作是我的首要任务，但攻读计算机科学硕士学位也是一个可以接受的选择。我还决定，我不认为一份分析工作或一个商业硕士学位会让我快乐。我决定哪些选项对我来说是可接受的，哪些不是。

你需要考虑同样的事情。你现在应该知道自己真正想要什么了。想想所有你认为是好的选择。我会考虑不同类型的工作和学位。你可能会想到硕士学位和博士学位。也可能是你感兴趣的学校的级别。不过最终，你应该有一个能让你开心的可接受结果的列表和一个不可接受结果的列表。现在我们可以列出可接受的结果，并做一些事情。

确保你有所有的选择

我唯一想说的是，每个人都应该同时申请工作和研究生院。在这一点上，你应该有一个能让你开心的事情的清单。尽你所能应用到所有符合这一类别的事物上！

对于一份工作或一个学术项目来说，无论你是多么完美的候选人，你都有可能被拒绝。没有一个人工运行过程是完美的，你必须为其后果做好准备。

你必须做好准备，不要让你的第一、第二甚至第三选择落空，尤其是如果你想成为明星的话。所以，确保你有让你开心的选择，如果你没有得到你的第一选择。

我决定只对某种类型的工作感兴趣。如果我不能得到我想要的工作，我会对研究生院更感兴趣，以便能够得到那份工作。我最终申请了 7 份工作和 8 个研究生项目。通过扩大我的关系网，当我做出决定的时候，我有了很多选择。

做决定

希望此时这个决定对你来说很容易。你已经收到了邀请和接受，现在你只需要选择一个你已经知道会让你最快乐的。在实践中并不总是这么容易，分析瘫痪是真实的。我给你的最后一条建议是，和你最亲近的人谈谈什么让你最快乐。无论你最终是读研还是工作，确保你正在做的事情让你开心，并推动你朝着目标前进。

Prophet & R 中基于目标的预测

原文：https://towardsdatascience.com/goal-based-forecasting-in-prophet-r-b79900c64ca6?source=collection_archive---------14-----------------------

通过生成达到特定目标的预测来指导业务团队。

预测工具无处不在。但是，令人惊讶的是，很难弄清楚如何调整模型化的预测，以满足业务团队经常要求的目标或指标！

通过一些历史数据，您可以使用预测工具来预测未来的特定指标(例如，活跃用户数量、收入、售出的产品、出生的婴儿)。好的预测工具会将季节性(基于一周中的几天或一年中的几个月的波动)、总体增长、假期和其他变量考虑在内，以建立更合理、更可靠的预测模型。

然而，企业设定“目标”和“指标”我们如何构建符合这些目标和指标的预测？让我们假设我们是 Tuckersoft 的数据科学家，我们刚刚建立了一个预测，预测 1985 年 7 月将售出 15000 份 Nohzdyve 。因为我们是伟大的数据科学家，我们还提供了 7 月份每天的预计销售额(例如，“7 月 3 日，我们预计销售 472 份”)，这些日常销售额考虑了季节性、增长和假期。

Nohzdyve. Took me a while to realize it’s pronounced “nosedive.” 🤦🏻‍♂️

但是塔库尔先生已经给他的销售团队定下了 1985 年 7 月销售 18，000 份的目标。现在，我们如何“更新”预测以符合目标？最简单的方法是:取预计数字和目标数字之间的差值，并在我们感兴趣的日期范围内平均分配。所以我们拿 3000 本，除以 31 天，告诉 Thakur 先生我们每天需要多卖 97 本才能达到目标。

然而，我们现在忽略了季节性和所有其他进入我们预测模型的很酷的东西！也许我们倾向于在周末有更高的销售额，我们不指望在独立日(7 月 4 日)卖出任何东西。将每天的预测销售额加 97 并没有考虑这些因素。我们想改变我们的预测，现在预测销量为 18，000 份，同时仍然考虑季节性和其他可变性。然后，销售团队可以根据调整后的基于目标的预测来衡量每日进度。

使用 Prophet

Prophet 是脸书开发的一款伟大的时间序列预测工具，有 R 和 Python 版本。我认为它是预测工具中的罗恩·波佩尔——你只需设置它，然后忘记它！

Set it and forget it! 🎉

使用 Prophet，只需几行 R 代码就可以创建预测:

就是这样！Prophet 通过分解趋势、季节性和节假日来生成预测，这是分析师容易理解的想法。可以通过在prophet()调用中设置参数来调整模型，并且可以使用一个列出日期的holidays数据框架来考虑假期。使用 Prophet 函数调用很容易生成按年、周、日显示趋势和季节性的漂亮图表。趋势变化点是自动计算的，但也可以手动插入或在过度拟合/欠拟合的情况下进一步指定。点击这里查看更多关于先知特征的讨论。

在 Prophet 中建立基于目标的预测模型

但是如何得到一个匹配一个预设目标或指标的预测呢？这就是predictive_samples()的作用。该函数从“后验预测分布”中生成(默认)1，000 个样本每个样本都是基于历史数据和 Prophet 模型的略有不同的预测。你只需找到最接近你的目标的样本，这个样本代表了一个可能的、合理的实现目标的途径，将季节性和节假日因素考虑在内。

通过这种方式，我们的预测并没有真正得到调整，而是利用计算增强/采样功能产生数百或数千个预测，直到我们找到一个最能代表实现目标的新预测。

例如:洛杉矶地铁自行车共享乘车

这里做个例子。我已经创建了一个从洛杉矶地铁自行车共享网站下载的每日骑行数据的 CSV，从 2016 年 7 月 7 日(发布)到 2018 年 9 月 29 日(可用的最新数据)。

原始的&清理过的数据文件，以及汇编文件和生成 Prophet 预测的 R 脚本都可以在 Github 上获得。

我们得到了这张图表:

Historical data for Los Angeles Metro Bike Share 🚲

我们可以看到一些年度季节性，在夏季的几个月里，乘坐次数更多。还有一个趋势转折点，游乐设施似乎真的起飞了。周季节性呢？检查的一种方法是查看工作日和周末:

🚴‍♀ Weekdays vs. Weekends 🚴

2017 年，周末的乘客量低于平日，但这一趋势在 2018 年发生了变化，大致相当。这是 Prophet 通过分解整体趋势和每日、每周和每年的季节性，开箱即用，很好地处理的事情。

我调用历史数据上的prophet()来生成先知模型，然后调用predict()来使用该先知模型预测到 2019 年 9 月 1 日的每日乘车次数。在本例中，我通过将 changepoint 参数从默认值 0.05 减少到 0.01 来降低趋势的灵活性:

According to this model, we’ll have 1,272 rides on September 1, 2019

这个先知模型为 2018 年 9 月 29 日至 2019 年 9 月 1 日之间的每一天生成了预测，预测 2019 年 9 月 1 日将有 1272 次乘坐。为了了解 Prophet 如何分解趋势和季节性，prophet_plot_components()生成了以下图表:

📈 📉 Components of a Prophet model.

多年来非常线性的趋势，周末较低的乘客量，夏末较高的乘客量——所有这些都进入了模型，并在计算每日乘客量预测时进行了加权。

目标:1500 次乘坐

但销售团队希望到 2019 年 9 月 1 日达到 1500 次乘坐。有了这个目标，我们每天的乘客量应该是怎样的呢？

使用相同的 Prophet 模型运行predictive_samples()从后验预测分布返回 1000 个样本(作为列),行数与您预测的天数一样多。如上所述，它们中的每一个都是可能的、可信的预测。我查看了对应于 2019 年 9 月 1 日的行，然后在 1000 列(样本)中找到了最接近 1500 次乘坐的单元格。包含该单元格的列是我要提供给销售团队的调整后的基于目标的预测！

下面的红点显示了为了在 2019 年 9 月 1 日达到 1，500 次乘坐，我们希望实现的调整后的日乘坐量。

The red dots 🔴 show the adjusted daily ridership we want to achieve to meet our Sep. 1, 2019 target.

这是放大的版本:

Zoomed In: The red dots 🔴 show the adjusted daily ridership we want to achieve to meet our Sep. 1, 2019 target.

你会看到一些调整后的每日客流量预测低于 Prophet 模型的原始预测。这只是生成的 1，000 个样本中的一个，因此模型将产生一些极端的数据点。然而，调整后的乘客量预测比最初的预测平均每天多 13 次。每天调整后的预测将考虑季节性和节假日，以产生更可靠、更可信的每日预测。

为了防止销售团队使用低于原始预测值的数据点，可以将原始和调整后的客流量预测值合并在一起，这样，在任何特定日期，如果原始客流量预测值高于调整后的预测值，您将保留原始值，反之亦然。这产生了我(刚刚决定)称之为“高目标”的预测——销售团队可以瞄准的雄心勃勃的东西。

Three projections! 📈 Original, adjusted, and a “high target” projection.

“高目标”预测是用更极端的个体数据点处理调整预测的一种方式，但我相信这里可以使用许多不同的方法！月度目标也很容易实现——只需根据与您感兴趣的月份相对应的行对predictive_samples()结果进行子集划分，对 1000 列(样本)中的每一列的行间日值进行求和，并找到最接近目标值的一列。

这是一个使用基本 Prophet 模型的简单例子，但是随着底层 Prophet 模型通过设置附加参数得到更好的调整，predictive_samples()的使用变得更加强大。总的来说，Prophet 是一个令人印象深刻的简单预测工具，它具有强大的功能，允许您提取符合特定目标的基于目标的预测，这是业务团队经常要求的可交付成果！

有没有其他方法可以产生基于目标的预测？请在下面分享。

注:这篇帖子的灵感来自于我在这期 Github**中问的这个写得很笨拙的问题——感谢Ben Letham为我指出了正确的方向！所有 R 脚本(使用tid yverse代码)、数据、图表均可在my Github repo获取。

数据科学家的目标设定

原文：https://towardsdatascience.com/goal-setting-for-data-scientists-b2ca1a3d96a1?source=collection_archive---------16-----------------------

设定和实现职业目标的框架

设定目标，尤其是在 12 月底左右，是反思和思考你希望在新的一年里从职业生涯中获得什么的好方法。在本文中，我们将讨论一个框架，供数据科学家用来实现他们的职业目标。

由于数据科学是一个跨学科的领域，您设定的目标类型将会非常多样。划分不同类型目标的一个好方法是分成以下三类:技术、行为和职业。

对于技术目标，您可能希望提高对某些技术或编程语言的理解。行为目标可能关注你的表达和说服技巧。最后，职业目标可以集中在实现职业里程碑上，比如升职或找到一份新工作。

专注于你能控制的事情

不管你设定什么类型的目标，重要的是你设定的目标在你的控制范围内。与其设定一个外部目标，比如升职，不如设定在你控制范围内的内部目标。例如，早点来帮忙做别人不想做的工作。

下面，您可以看到一些外部目标被重组为三个阶段的内部目标的例子:

设定内部目标的好处之一是，如果你没有实现外部目标(因为你控制范围内或控制范围外的原因)，你仍然会因为完成了你控制范围内的事情而有成就感。

对你设定的目标要明智

SMART(具体、可衡量、可实现、相关和基于时间)框架源于 20 世纪 80 年代的管理文献，用于设定目标和目的，已在整个商业和自我发展社区得到普遍使用。这个框架确保你设定的目标是你力所能及的，你可以随着时间的推移进行跟踪和衡量。

设定 SMART 目标时，您应该考虑以下问题:

我想完成什么？
通过/失败的标准是什么？
我将如何衡量我的进步？
根据我的技能水平和经验，这个目标合适吗？
我有必要的时间和资源来完成这件事吗？
我的退出标准是什么？
我希望在什么时候完成这个目标？

让自己负起责任

为了确保符合你的目标，与朋友或教练分享你的目标是有用的，他们可以让你保持在正确的轨道上。你可能会有一个每周的检查，包括一个电话，甚至一个总结你进步的短信。

对于那些想对没有达到目标的人进行经济处罚的人来说，还有无数的工具可以利用。例如， Beeminder ，允许用户设定目标，这些目标要么是自我报告的，要么是与一些外部数据源相关联的(比如 RescueTime ，它跟踪在线花费的时间)。因此，如果你想设定一个每月发表两篇数据科学文章的目标，你可以使用 Beeminder 作为一种对自己没有达到目标进行经济处罚的方式。

你可以使用的另一个工具是 Stickk ，它类似于 Beeminder，增加了一个功能，即每当你未能达到目标时，你可以选择向一个反慈善机构捐款(即，如果你是利物浦球迷，你的反慈善机构可能是曼联球迷俱乐部)。

随着我们进入 2020 年，我鼓励你们考虑为每个类别(技术、行为和专业)设定至少一个目标。在设定这些目标时，确保设定明智的内部目标，并有办法让自己承担责任，无论是通过社会惩罚还是经济惩罚。

设定目标不值得

原文：https://towardsdatascience.com/goal-setting-isnt-worth-it-9ee937c021ab?source=collection_archive---------14-----------------------

工程和数据科学工作不会从 SMART 目标、OKRs 或类似的管理偏好中受益。

The goal of making baskets isn’t what makes you good at making baskets.

我不相信目标设定。在我的职业生涯中，我偶尔会被迫设定目标，这总是来自于希望给旧流程注入新生命的高管或经理。我做过 SMART 目标。我做过 OKRs。我做过 KPI。我都不喜欢。

我不喜欢在工作场所设定目标——特别是在数据科学和工程这样的创造性工作中——因为我一直发现它无效，我经常发现它是有害的，我总是发现它带来的麻烦多于它的价值，我从来没有看到它为我提供我实际需要的信息来实现结果。就我而言，设定目标基本上是失败的。还有一种更好的方法(我会在帖子的最后谈到这一点)。

目标设定是无效的

不难发现堆积如山的研究表明，设定目标对取得结果是有效的。我不知道该研究机构的任何研究是以证明这些说法的方式进行的。任何“设定目标取得成果”的变体都是一种因果主张。因果主张需要(至少)两件事:对主张的支持，以及缺乏对任何似是而非的替代解释的支持。

James Clear 提出了一个非常合理的替代解释。我用他的一个例子:假设你是一个运动队，你想赢得一个冠军。假设你设定了一个目标，要在某个日期之前赢得冠军。现在，让我们假设你为了朝着你的目标前进而做了很多改变:你招募新球员，雇佣和管理助理教练，安排和进行练习，甚至获得竞争对手比赛的旧录音并加以研究。

所有这些事情都是系统:你承诺定期做的特定行为。如果你建立了这些系统，并且坚持下去，你就增加了赢得冠军的机会。如果你也设定了夺冠的目标，你实际夺冠的几率并没有改变。这些制度是实现目标所必需的。实际上，设定目标，甚至衡量实现目标的进度，都不是。

可信的替代解释。目标研究没有解决这个问题。因此，目标研究不支持目标设定取得结果的说法。

设定目标会带来隐性成本

几年前，几所主要商学院的研究人员发表了一篇关于设定目标的危险的工作论文。他们的论文并没有证明目标设定不起作用——我引用它是因为它讲述了几个说明性的故事(我在这里引用了所有这些故事):

“20 世纪 90 年代初……西尔斯对其汽车维修人员实行 147 美元/小时的销售限额。这一特定的、具有挑战性的目标促使员工超额完成工作，并在全公司范围内完成不必要的维修...最终，西尔斯董事长爱德华·布伦南承认，目标设定促使西尔斯员工欺骗顾客。
“在 20 世纪 90 年代末，具体的、具有挑战性的目标推动了能源贸易公司安然在财务上的迅速成功……安然的激励制度[包括]‘根据销售额向销售人员支付佣金，并让他设定所售商品的价格。’即使在安然公司的最后几天，安然公司的高管们也因为达到了特定的收入目标而获得了巨额奖金……通过关注收入而不是利润，安然公司的高管们把公司逼入了困境。"
20 世纪 60 年代末，福特汽车公司的市场份额被销售小型节能汽车的外国竞争对手夺走。首席执行官李·艾柯卡宣布了一个具体的、具有挑战性的目标，即生产一款“低于 2000 英镑、低于 2000 美元”的新车，并于 1970 年上市。这个目标，加上紧张的最后期限，意味着许多管理层签署了未执行的安全检查，以加快汽车的开发——福特平托。调查显示，在福特最终发现[一个安全]隐患后，高管们仍然致力于他们的目标，而不是修复有缺陷的设计，计算出与平托火灾(涉及 53 人死亡和多人受伤)相关的诉讼成本将低于修复设计的成本。在这种情况下，具体的、具有挑战性的目标(上市速度、燃油效率和成本)得以实现，但代价是其他重要特性(安全、道德行为和公司声誉)没有得到明确规定。”

我很喜欢作者的总结论点:

目标设定的有益效果被夸大了，而由目标设定引起的系统性伤害在很大程度上被忽视了……管理者……需要将目标设定概念化为处方药，需要谨慎用药，考虑有害的副作用，并密切监督，而不是将目标设定作为一种良性的、非处方的激励措施。

换句话说，设定目标是一种试图取得结果的脆弱方式。目标不仅对于达到预期结果是不必要的(因为它们不做系统没有做过的事情)，而且它们还创造了激励，使得达到不想要的结果变得容易。

设定目标比它的价值更麻烦

当我提出上述观点时，我经常会得到这样的回应:“嗯，是的，如果你在如何设定目标上很愚蠢，那么你就有麻烦了。当你把目标做对了，它就会发挥作用。”

说起来很容易。

看一看一个如何做好“正确”的例子:

目标需要在一般和特殊之间保持适当的平衡，但是没有明确的方法来判断平衡在哪里。
衡量目标进展的指标需要有明确的定义，人们需要访问这些指标，并且这些指标需要经常更新。所有这些都假设测量系统的存在(对销售团队来说是一个好的假设，但对几乎所有其他人来说是一个坏的假设)。
你必须清楚地定义不同团队的目标之间的关系，但是没有明确的方法来说明如何得到这些定义。
你必须能够认识到，什么时候一个目标会以扼杀创新为代价来提高生产率，这样你就可以避免在这些情况下过于规范的 okr。同样，没有明确的方法来识别这些情况。

当误用工具如此容易时，可能是时候考虑问题是工具本身，而不是用户。以既有意义又无害的方式设定目标所花费的时间是不值得的。我花在定义、实施和衡量目标进展上的时间，并没有花在创造真正有价值的东西上。

我认为，当您考虑到在工程项目中有意义地、明确地度量向最终状态的进展所必需的工具数量时，这一点尤其正确。如果你的目标是某个销售数字，那么工具已经建立起来了。如果你的目标更加模糊，而且通常是这样，那么建立一种有效的方法来衡量它通常会花费比实际完成目标更多的时间和资源。

目标设定不会产生可操作的信息

让我们回到一个运动队的类比。假设你设定了赢得总冠军的目标，让我们忽略这样一个事实:你已经建立了各种各样的系统，这些系统会让你朝着目标前进，而你根本不需要在第一时间设定目标。现在，让我们假设你到达了你想要赢得冠军的日期。假设你输了。

因为没有达到目标，你现在应该做什么？你的行为应该如何改变？让我们倒过来说，你真的赢了，你达到了你的目标。同样的问题:因此，什么？

你是否完成了目标，除了告诉你你是否完成了目标之外，没有任何意义。如果你已经建立了一个系统来引导你走向一个期望的未来状态，你就已经知道你需要做什么了。带有可衡量的进度标记的明确目标不会告诉你接下来的步骤。它们不包含任何能让你更快或更有效地达到你想要的未来状态的信息。

我发现前谷歌产品负责人的这篇文章很有见地。他引用了保罗·格拉厄姆的“制造者的时间表，管理者的时间表”。决策者(工程师、数据科学家)的工作表现是通过他们构建的东西来衡量的。经理的工作表现是通过他们召开的会议来衡量的。这两者都是必要的功能(尽管开发者有时不愿意承认，但会议是将构建的东西协调和结合在一起的粘合剂)。

在谈到他在谷歌使用 OKRs 的经历时，这篇文章的作者说:

我们认为自己是一家由制造商(我们的工程师)创建和驱动的公司，但不知何故，我们适应了经理计划的节奏，这种节奏模仿了会计周期，而不是事情实际上是如何建立的。“季度目标？”为什么三个月是构建特性的合适时间，为什么不是两个月或四个月？还有一个有趣的“季度最后一周”推送，试图发布你在大约 90 天前承诺的所有功能。

在商业环境中，大多数目标设定对管理者的好处大于制定者。如果一个制造商需要证明他们的价值，他们可以指出他们已经建立的东西。管理的本质是有一套不太明确的成就，而目标成就是证明管理价值的一种方式。这就像根据学生的考试成绩来评估老师的价值——同样有效。但是因为成就(或没有)或目标没有告诉我们下一步该做什么，这是我们所能希望的最好结果:目标没有告诉我们任何事情，除了他们自己。

以我的经验来看，目标设定往往是管理不力的避难所。目标设定允许组织假装得到的结果比实际情况更简单、更可预测。这种假想的代价是，制造者和管理者都花费了过多的时间来管理这种幻觉，更糟糕的是，他们甚至没有从中获得可操作的信息。

取而代之做什么

我发现下面的过程很有效:

定义一个期望的未来状态，如果你愿意，就把它称为一个目标。问问你自己:“在下一个季度(或一周或一年)结束之前，我希望这个项目(或产品或公司)的什么是真实的？”
定义阻止你走向这个未来最终状态的障碍——不是阻止你完成它的事情，而是阻止你将推向它的事情。测量方向比测量距离要简单得多，而且通常更有效。
定义减少障碍的任务。根据你认为什么对障碍最有影响，以及什么任务是完成其他任务所必需的，对这些任务进行优先排序。
在时间和资源允许的情况下，按照优先顺序处理任务。如果你正在完成任务，你正在向你的目标前进，因为你已经定义了任务如何减轻阻碍你向目标前进的障碍。

这是不是类似于定目标，OKRs 之类的东西？是啊，它是。但这集中在“我想去哪里？”以及“是什么让我走向那个地方？”而不是“我能承诺完成什么？”以及“我能衡量什么？”它要求我们建立系统而不考虑目标，不鼓励反生产行为，只需要很少的时间就能做得相当好，在每一步都产生可操作的信息。这是一个小小的视角转变，它会对工作满意度和结果产生很大的影响。

从 R 到 Python —线性回归诊断图

原文：https://towardsdatascience.com/going-from-r-to-python-linear-regression-diagnostic-plots-144d1c4aa5a?source=collection_archive---------12-----------------------

Symbols taken from wikipedia.

作为一个已经过渡到 Python 的长期 R 用户，我最怀念 R 的一件事是轻松地为线性回归生成诊断图。有一些关于如何在 Python 中进行线性回归分析的很好的资源(参见这里的例子)，但是我还没有找到一个关于生成诊断图的直观资源，我从 r。

我决定为在 r 中使用 plot(lm) 命令时出现的四个图构建一些包装函数。这些图是:

残差与拟合值
正常 Q-Q 图
标准化残差与拟合值
标准化残差与杠杆

第一步是进行回归。因为这篇文章是关于 R 怀旧的，所以我决定使用一个经典的 R 数据集:mtcars。它相对较小，具有有趣的动态，并且具有明确的连续数据。通过安装 pydataset 模块，可以非常容易地将这个数据集导入 python。虽然该模块自 2016 年以来一直没有更新，但 mtcars 数据集来自 1974 年，因此我们想要的数据是可用的。以下是我将在本文中使用的模块:

现在，让我们导入 mtcars 数据帧并查看它。

可以通过以下命令访问该数据集的文档:

data('mtcars', show_doc = True)

我特别感兴趣的是使用气缸数量(cyl)和汽车重量(wt)预测每加仑英里数(mpg)。我假设 mpg 会随着 cyl 和 wt 下降。statsmodels 公式 API 使用与 R lm 函数相同的公式接口。请注意，在 python 中，您首先需要创建一个模型，然后拟合该模型，而不是在 r 中创建和拟合模型的一步过程。

重要的是，statsmodels 公式 API 自动将截距包含到回归中。原始 statsmodels 接口不会这样做，因此请相应地调整您的代码。

该模型解释的差异量相当高(R^2 = 0.83)，并且 cyl 和 wt 都是负的和显著的，支持我最初的假设。在这个 OLS 输出中有很多东西要解开，但是在这篇文章中，我不会探究所有的输出，也不会讨论统计意义/非意义。这篇文章是关于构建异常值检测和假设检验图，这在 base R 中很常见。

这些数据符合 OLS 模型的假设吗？让我们开始策划吧！

首先，让我们检查残差中是否存在与拟合值相关的结构。这个情节相对容易创作。这里的计划是从拟合模型中提取残差和拟合值，计算通过这些点的 lowess 平滑线，然后绘制。注释是残差的最大绝对值的前三个指数。

在这种情况下，残差中可能有轻微的非线性结构，可能值得测试其他模型。菲亚特 128、丰田卡罗拉和丰田科罗纳可能是数据集中的离群值，但值得进一步探索。

残差服从正态分布吗？为了测试这一点，我们需要第二个图，一个分位数-分位数(Q-Q)图，其理论分位数由正态分布创建。Statsmodels 有一个 qqplot 函数，但是很难注释和定制成一个基本的 R 样式图形。不用担心，构建 Q-Q 图相对简单。

我们可以从 stats.probplot()函数中提取理论分位数。我在这里使用了内部学生化残差，因为第三和第四个图形需要它们，但是如果您愿意，也可以使用原始残差。然后，我们将绘制学生化残差与理论分位数的关系图，并添加一条 1:1 的直线进行直观比较。注释是学生化残差中绝对值最大的三个点。

在这里，我们可以看到残差通常都遵循 1:1 线，表明它们可能来自正态分布。虽然难以阅读(就像在 base R 中一样，ah the memories ),但菲亚特 128、丰田卡罗拉和克莱斯勒 Imperial 在学生化残差中表现突出，并且似乎也偏离了理论分位数线。

现在我们可以用标度-位置图来检验同质假设。基数 R 绘制了“标准化残差”与拟合值的平方根。“标准化残差”有点模糊，所以在网上搜索后，发现“标准化残差”实际上是内部学生化残差。如上所述，从拟合模型中提取内部学生化残差非常简单。之后，我们将得到它们绝对值的平方根，然后绘制变换后的残差与拟合值的关系图。如果图中的散布在拟合值的整个范围内是一致的，那么我们可以有把握地假设数据符合同质假设。我已经注释了平方根变换学生化残差的三个最大值。

在这种情况下，洛斯平滑器似乎有上升趋势。这可能是异方差的表现。如果我去掉克莱斯勒帝国点，这种异方差可能会更严重，所以这个假设在我们的模型中可能会被违反。

最后，我构建了残差与杠杆图。响应变量也是内部学生化残差。这里的 x 轴是杠杆，通过 OLS 帽矩阵的对角线确定。这里棘手的部分是添加厨师距离的线条(见这里关于如何在 seaborn 构建这些情节)。注释是具有最大绝对值的前三个学生化残差。

该图中有一些证据表明，克莱斯勒帝国对该车型有着非同寻常的巨大影响。这是有意义的，因为它是拟合值的可能范围的最小边缘处的异常值。

如果您对自己创建这些诊断图感兴趣，我创建了一个简单的模块(OLSplots.py)来复制上面显示的图。我在我的 github 库上托管了这个模块和 Jupyter 笔记本来进行这个分析。

一些准则:

如果您对回归使用测试训练分割，则应该在测试模型之前，对已训练的回归模型运行诊断图。
当前的模块不能处理在 sklearn 中完成的回归，但是它们应该相对容易在以后的阶段被合并。
OLSplots.py 模块目前没有内置的错误消息，所以您需要自己进行调试。也就是说，如果你将一个拟合的 OLS 模型从 statsmodel 传递给任何函数，它都应该工作正常。
文本注释是用于构建 OLS 模型的熊猫数据框架的索引值，因此它们也适用于数值。

感谢阅读。暂时就这样吧！

进一步阅读

https://towards data science . com/linear-regression-on-Boston-housing-dataset-f 409 b 7 E4 a 155
https://github.com/iamaziz/PyDataset
https://emredjan . github . io/blog/2017/07/11/emiling-r-plots-in-python/
https://data.library.virginia.edu/diagnostic-plots/
https://stats . stack exchange . com/questions/52522/standardized-residuals-in-RS-lm-output

使用 OpenFaaS 和 Golang 实现无服务器——构建优化的模板

原文：https://towardsdatascience.com/going-serverless-with-openfaas-and-golang-building-optimized-templates-730991084443?source=collection_archive---------25-----------------------

注:这最初发布在martinheinz . dev

在上一篇关于 OpenFaaS 函数的博文中，我们探索了我们可以用 OpenFaaS 做什么——我们在 Golang 中创建了我们的第一个 OpenFaaS 函数，我们为它编写了单元测试，用 Travis 设置了 CI/CD，用 Taskfile 自动化了常见任务。现在，是时候深入一点了。

在这篇博文中，我们将探讨如何构建定制模板，优化它们，从它们构建函数，最后，我们还将把 Go 模块合并到我们的新模板中。所以，让我们开始吧！

TL；博士:这篇文章的完整源代码，包括文档可以在这里找到:https://github.com/MartinHeinz/openfaas-templates

深入了解模板

如果我们想要构建自定义模板，那么我们首先需要了解它们是如何工作的。让我们首先看看模板由哪些文件组成:

模板清单——template.yml是一个描述模板本身的文件，因此 OpenFaaS 知道如何从中创建和部署功能。在该文件中，您可以找到诸如language、必需的packages或fprocess等信息
Entrypoint——接下来，为了使函数能够工作，我们需要一些文件(entry point ),这些文件要么监听 HTTP 请求，要么读取 STDIO 并将这些请求转发给函数本身。这个入口点文件是什么，取决于语言，所以可以有main.go、index.py、index.js等。
handler——现在，我们有了一个入口点，它将请求传递给我们的函数，我们需要以某种方式处理它。为此，我们有handler.{go,js,py...}来做实际的工作，并从函数返回响应
依赖性——大多数时候，你的函数会用到一些包。这些可以用语言特定的方式指定，例如使用package.json表示 JavaScript 或者使用go.mod表示 Golang
Dockerfile -最后，为了将所有这些文件打包成一个函数，我们有了Dockerfile，它构建、测试并创建最终的 runner 映像，该映像可以部署到 OpenFaaS 。

现在我们知道了函数由什么组成，它实际上是如何工作的？ OpenFaaS 模板有两个版本——经典 ( watchdog)和新 beta ( of-watchdog)模板。它们都是通过创建微小的 Golang webserver 来运行的，webserver 整理 API 网关上接受的 HTTP 请求，然后将请求转发给被调用的函数。这就是相似之处，现在让我们看看不同之处:

watchdog : 经典模板通过为每个请求派生一个流程来操作。一旦您的流程被分叉，看门狗通过stdin传入 HTTP 请求，并通过stdout读取 HTTP 响应。

of-watchdog:另一方面，当 watchdog 启动时，新模板派生出一个进程，然后我们将任何传入 watchdog 的请求转发到容器内的 HTTP 端口。

以上图片摘自 OpenFaaS 架构文档—https://docs.openfaas.com/architecture/watchdog/

如果你想更深入地了解watchdog(旧的和新的)是如何工作的，那么去这里或者这里

创建模板

首先，模板有特定的文件/目录结构，这是我们需要遵循的，看起来是这样的:

使用上面的结构——template目录是所有模板驻留的地方。在其中，我们有一个名为my-template的模板，里面是它工作所必需的文件——所有这些我们已经在前一节中描述过了。这是一个非常小的例子，我们将会添加更多的文件。

结构到此为止，现在我觉得终于到了创建模板的时候了，先从【经典 *watchdog* 风格】模板开始吧。我们可以通过从官方模板商店复制一个来创建一个。考虑到这是 Golang 模板的指南，我就拿基本的go模板(这里复制是多余的，你可以在这里看到最新版本的模板)。

当我们把它复制到template文件夹时，我们应该检查它是否真的工作，对吗？所以让我们来建造它:

看起来不错，现在让我们部署功能，好吗？

就这样，我们创建了自己的模板(嗯，我们真的只是从官方商店借来的)并部署了从中获得的功能。然而，整个过程感觉相当笨拙，因为我们不得不使用相当多的命令来运行它，并直接调用docker命令，而不是例如faas-cli build和faas-cli push。在下一篇博文中，我们将用任务文件和几个脚本来简化这个过程。现在，让我们优化一下现有的模板...

我们可以改进什么？

上一节的经典模板非常好，但是有一些问题:

无 Go 模块:该模板不使用 1.11 中引入的 Golang 模块系统，这意味着必须使用不实用且过时的依赖管理。
非最佳 *Dockerfile* : Dockerfile这个模板有相当多的不必要的层，使其构建缓慢，并且很少比所需的厚。
*of-watchdog* 更快:如上所述，是经典模板，所以不用of-watchdog。因此，我们可以通过切换到of-watchdog并使用 HTTP 模式来提高它的性能。

所以，让我们来解决这些问题吧！

注: 这里提一下，OpenFaaS 社区已经在这些模板上做了很多工作。经典的是遗留模板，你应该使用中间件或它的 http 版本，并可能应用下面介绍的调整和更改。

其中一些问题可以通过在这里使用openfaas-incubator/golang-http-template来解决，但是我们可以把它推得更远一点，所以让我们从这里的中取出golang-http并在此基础上构建。

在这里，我将向您展示我使用这个作为基础创建的最终Dockerfile，我将带您了解所有的变化及其背后的基本原理:

注:您可以在 这里中查看 *Dockerfile*

我们从 2 个FROM命令开始，因为我们既需要 Golang image 来构建函数，也需要watchdog binary。接下来，我们打开 Go 模块并禁用 CGO ，这将允许我们调用这里不需要的 C 代码。下面的代码将git安装到构建映像中，因为我们需要它在构建期间下载 Golang 包。在接下来的 2 行中，我们复制watchdog二进制文件并使其可执行。现在是时候构建我们的函数二进制代码了——我们首先将源代码复制到/go/src/handler,然后对其运行 2 个命令—test和 build 。对于测试，我们使用模板中包含的test.sh脚本。让我们看看它能做什么:

注:您可以在 这里中查看 *test.sh* 文件

首先，它从function目录中收集测试目标，这是我们的源代码。然后它对这些目标文件运行go test，如果测试通过，那么就该检查格式并寻找代码中的可疑结构，这就是gofmt和go vet的作用。那时——在测试成功通过之后——回到Dockerfile——我们构建名为handler的二进制文件。

Dockerfile的最后部分是亚军的形象。在这里，我们运行的命令真的开始变得重要了。我们希望减少对RUN、COPY和ADD的所有调用，因为这些调用会创建额外的图层，并会使最终图像膨胀。因此，首先我们使用单个RUN命令添加 CA，添加名为app的用户，函数将在该用户下运行并移动到它的主目录。接下来我们COPY将所有需要的文件从构建器镜像到 runner 目录，函数将从该目录在单层中运行，这包括 Golang 二进制、watchdog二进制和函数目录中的所有内容。最后，我们设置我们的用户，设置环境变量，并将watchdog二进制文件设置为默认启动命令。

现在，我们已经解决了Dockerfile,我们可以看看源代码了。为了简单起见，我只使用了前面提到的 golang-http 中的main.go和handler.go，因为在模板代码方面没有太多变化。但是缺少的是一些单元测试模板，所以让我们看看我们能做些什么...

测试时间

如果你读过我以前的任何一篇文章，你就已经知道接下来会发生什么了——单元测试。模板可以包含任何代码——包括测试，所以我认为添加简单的测试模板来测试您的功能是合适的。这是一个测试例子:

该测试位于紧挨着handler.go的handler_test.go文件中。该测试涵盖了在进行 HTTP 请求/响应时所期望的基本检查，即状态代码检查和响应验证。因此，首先我们使用handler.Response创建期望值，接下来我们向由Handle函数表示的函数发出请求，传递我们的请求，最后我们对照期望值检查它的响应。

将这一切结合在一起

我们终于有了模板所需的所有源代码，但是我们还不能完全使用它。我们缺少构建函数所需的template.yml。这是:

这里没什么好说的。我们指定语言、将作为fprocess运行的二进制文件和简单的欢迎消息。我们也可以在这里包括build_options和packages，但在这种情况下，这是不必要的。

接下来我们需要完成的是模板的依赖关系，考虑到我们正在使用 Go 模块，我们需要做的就是在main.go旁边创建go.mod文件，如下所示

然后运行go mod tidy，这将用我们所有的依赖项(openfaas-incubator/go-function-sdk和stretchr/testify)填充文件

现在唯一要做的就是构建、推动和部署它:

结论

就这样，我们创建了自定义模板，可以用来构建和部署 OpenFaaS 函数。也就是说，剩下的事情不多了…在下一篇博文中，我们将构建个人模板库，在那里我们可以放置所有的自定义模板，然后添加模板的自动验证并将其包含在 CI/CD 管道中，最后我们将简化所有与使用 Taskfile 构建和运行模板相关的任务，就像我们在上一篇博文中对函数所做的那样。如果你想先睹为快，请看我的库这里，如果你喜欢这些类型的帖子，可以随意留下反馈或者直接启动库。😉

使用 OpenFaaS 和 Golang 实现无服务器——终极设置和工作流程

原文：https://towardsdatascience.com/going-serverless-with-openfaas-and-golang-the-ultimate-setup-and-workflow-52a4a85a7951?source=collection_archive---------20-----------------------

注:此文最初发布于martinheinz . dev

无服务器应用已经流行了一段时间，一些有趣且有用的平台/工具/框架正在出现。其中之一是 OpenFaaS ，它是开源功能的服务工具，用于开发云原生无服务器应用。

在这篇博文中，我想向你展示如何设置(IMHO)开发 OpenFaaS 函数的理想项目和工作流程，以及如何使用 Golang 创建你的第一个函数。

注意:这篇文章的完整源代码可以在这里找到:【https://github.com/MartinHeinz/openfaas-functions】T21

为什么选择 OpenFaaS

你可能会问，为什么——在所有像 AWS Lambda 、 Google Cloud Run 、open whish等框架中。—我会选择 OpenFaaS 吗？嗯，对我来说有几个原因:

无供应商锁定 —我选择 OpenFaaS 而不是其他选择的一个重要原因是，我不会被供应商锁定。但是，为什么它如此重要呢？这很重要，因为在某些时候，你可能会决定，你想要转移到其他平台，甚至完全远离无服务器，这是你无法用像 AWS Lambda 这样的工具真正做到的，这迫使你使用 AWS。
云原生 —下一个优势是它运行在云环境中，比如 Kubernetes 、 OpenShift 或者 k3s (在本教程中使用)。我认为这是一个优势，因为现在构建小型 Kubernetes 集群非常便宜、快速和简单，在其中部署 OpenFaaS 也很简单，正如您将在下面看到的。
任何语言 — OpenFaaS 都能够使用任何运行时，这要归功于所有函数都在 Docker 容器中运行这一事实。您甚至可以构建自己的模板，并以此为基础构建您的函数。
性能—open FAAS的另一个好处是它的性能，更具体地说——或者换句话说——空闲时将 pods 扩展到零的能力，以及具有更低延迟、缓存和持久连接的基于 HTTP(beta)的模板(你将在下一篇博客文章中看到)。

安装

要开始构建一些很酷的功能，我们首先需要安装一些工具。以下是它们的列表和说明:

k3s —为了运行这些功能，我们需要一个云环境，并且考虑到我们将使用本地机器，我们应该尽可能选择最轻量级的选项，这里我将使用 Ranchers k3s (或者您也可以使用类)。要安装，请使用以下命令:
OpenFaaS —如前所述， OpenFaaS 是一个云原生平台，所以我们需要把它放到我们的云环境中( k3s ):
为了能够与部署的 OpenFaaS 进行交互，我们还需要它的 CLI:
任务文件——最后，我们的设置使用任务文件——代替Make——来自动化常见任务。要安装它，您需要运行:

第一功能

现在我们已经准备好了所有的工具，让我们构建我们的第一个 OpenFaaS 函数。在我们实际进行任何编码之前，我们需要提取模板，在此基础上我们将构建函数:

上面，我们可以看到我们感兴趣的一个模板——go模板。让我们用它来创建函数:

从输出中，我们可以看到创建了哪些文件— handler.go和first-func.yml。第一个包含负责处理传入请求的函数，另一个是描述函数的 YAML 堆栈文件——它包含像图像名称、处理程序路径、语言等信息。也有更多的值可以指定，你可以在这里找到。你可能注意到我们还指定了prefix标志——我们需要它，以便能够将我们构建的函数的映像推送到远程存储库，在本例中是 Docker Hub 并且prefix是 Docker Hub 用户名。当我们部署该功能时，OpenFaaS 将使用远程注册表中的这个映像。

我将把摆弄代码和实现酷功能的工作留给你，我将只构建、推送和部署 Hello World 函数:

就这样，我们在 k3s 上的 OpenFaaS 中运行我们的函数。我们可以在 UI 和命令行中查看它。对于 UI 视图，您可以导航到OPENFAAS_URL(应该是 http://127.0.0.1:31112 )，对于 shell，您可以运行以下命令来显示和调用该函数:

我认为，这很简单，我们可以在此基础上进行构建。在下一篇博文中，我们将探讨如何利用更新的(beta) of-watchdog模板，以及如何使用 Go 模块构建我们自己的模板库，包括我们的优化模板。你可以在我的模板库这里先睹为快。

单元测试

看起来我们已经完成了，但是我们还缺少一样东西——单元测试。

要编写我们的单元测试，我们只需在handler.go旁边创建handler_test.go文件，并将这个测试放在那里:

您可能已经注意到，go test命令是在 Docker 构建过程中运行的，所以我们运行测试所需要的只是像以前一样构建函数:

你可能认为测试像这种无服务器功能的小代码片段是多余的，但是你不应该仅仅因为代码简单或简短就忽视测试，如果可能的话，一切都应该被测试。

通过任务文件变得简单

在这篇文章的开始，我要求您安装任务文件，但是我们实际上还没有使用它，所以让我们改变它，使工作流更简单，并使用我已经为您创建的任务文件目标来创建、构建、部署或调试功能:

第一步—使用某个模板创建具有指定名称的函数:

该任务在后台为您下载模板，创建函数，然后将文件添加到 git staging 区域。

接下来，让我们来构建它:

没什么特别的，它只是构建函数，但是您也可以继续，在一个命令中构建、推送和部署函数:

现在，为了检查一切是否按预期工作，让我们检查日志:

这将给出 Kubernetes 部署对象的描述以及如下所示的功能日志:

如果日志还不够，您可以使用以下命令调试该函数:

这将在 Docker 中本地运行该功能，并将终端连接到watchdog进程日志。现在，这个函数已经在您的机器上运行了，您可以使用cURL来调用它:

要查看Taskfile.yml中发生的事情或查看更详细的文档，请查看我的知识库中的Taskfile.yml这里的和README.md 这里的。

最简单的 CI/CD

我们需要设置的最后一件事是 CI/CD 管道，我们可以使用最后一个任务文件目标来完成，我在上一节中省略了这个目标——task verify——这个命令下载faas-cli(如果机器上没有的话)，并使用存储在functions目录中的 YAMLs 在存储库中构建每个函数:

要获得完整的代码清单，请查看存储库中的文件，特别是这里的.travis.yml 和这里的verify.sh。

结论

正如你从这篇文章中看到的，开始开发无服务器应用程序真的很容易，考虑到无服务器不再只是炒作，这些技术已经相当成熟，我希望你能尝试一下。如果你想从这篇文章中看到更多的细节和完整的源代码，请查看我的知识库这里，如果你有一些建议/改进/问题，请随时提交问题或开始讨论。🙂

如前所述——在下一篇博文中，我们将看看如何建立自己的模板库，创建自定义模板，并使用它来创建更好的功能。

数据科学的良好编码实践

原文：https://towardsdatascience.com/good-coding-practices-for-data-science-e9237783784c?source=collection_archive---------9-----------------------

虽然数据科学不是直接源于计算机科学的领域，但机器学习和人工智能的兴起已经使编码成为数据科学不可或缺的一部分。

虽然数据科学项目更具实验性，不像软件项目那样定义良好，但遵循一些好的编码原则有助于提高效率和扩大数据科学项目。

这里有一些我尝试遵循的好的编码实践:

代码组织

我确保我的所有代码不是放在一个文件中，而是分散在多个文件中。我通常将我的代码分成以下 4 个主要部分。

a .规范文件

在我的大多数项目中，我倾向于将规范文件作为 YAML 或 JSON，在那里我可以指定要设置的各种参数来运行代码。有了这些规范，我可以在不改变代码的情况下以不同的方式使用代码。比方说，我为一个国家建立了一个模型。如果我在规范文件中指定了一个国家变量，而不是在我的代码中硬编码这个国家变量，我可以通过修改规范在不同的国家使用这个代码。

b .实用程序

如果我的部分代码足够通用，可以跨多个项目使用，我会将它们放在名为“实用程序”的单独文件中，这样我就可以跨多个项目使用它们，并最大限度地减少重复工作。

c .核心功能

当涉及到核心逻辑的代码时，我再次尝试不把它们都放在一个文件中，而是把它们分散在多个文件中。例如，每个数据科学项目都有一个数据提取部分、数据探索部分、建模部分等等。我确保这些片段被分离到多个文件中。

d.主可执行文件

最后，我运行了一个单独的文件(通常称为 main.py ),它应该会执行整个代码。我试图在这个文件中使用最少的逻辑。这个文件的目的是让人们理解代码和代码流的不同部分的相互依赖性，而不是代码的详细逻辑。

文档

在我所有的项目中，我试图维护一个 Readme 页面，当我的代码发生变化时，它会定期更新。自述文件页面提供了代码的目标、安装和使用说明、代码架构和高级文件结构。

虽然自述文件是专注于代码的文档，但我维护了一个单独的文档来解释统计数据和机器学习逻辑。这样做的目的是帮助其他数据科学家理解我的逻辑和算法。

虽然文档似乎是一项平凡的任务，但它不仅仅是帮助别人，它还帮助我更清楚地了解我的代码。

正在评论

我通常在每个文件的顶部添加关于代码的高级注释。除了给读者一个文件的概述，这帮助我更好地组织我的文件。

对于我拥有的每一个方法，我都会写下关于方法目标的注释，它所带的参数和它返回的内容。这又一次帮助我将代码分割成合适的方法。

除了这些高级注释，如果我的代码中有任何复杂的逻辑，我会尝试编写一些高级注释。

命名惯例

我见过的大多数数据科学代码都有被命名为 x，y，z 等的变量和函数。这大概源于大部分数据科学家都是数学和统计学出身。这些命名约定使得代码对于试图理解它的人来说非常深奥。

当我写代码的时候，我会花一些时间为我的方法、类、变量等想一些最直观的名字。我还确保了我为这些代码元素使用的词性和字母大小写的一致性。例如，我尝试用小写动词表示方法，用骆驼格名词表示类等等。

事实上，好的命名约定减少了对注释和文档的需求。

版本控制

良好编码的最佳实践之一是维护版本控制。维护版本控制系统有很多好处。您可以在多人之间无缝协作，切换回旧版本的代码，在不影响旧版本的情况下向代码中添加新的更改/特性等。如果你以前没有使用过 Git ，创建一个 Github 账户，然后开始上传你的项目。它是免费的，可以让你很好地理解版本控制系统。

鉴于数据科学项目涉及持续的实验和编辑，版本控制变得更加重要。假设您开发了一个模型，后来在模型中添加了一个新特性。如果您将这些保存为代码的两个版本，这将很容易让您比较这两个模型的性能。

自动化测试

虽然数据科学可能不像软件世界那样需要详尽的自动化测试用例来验证代码的健全性，但是用测试用例来验证数据的细微差别是一个非常好的实践。

在我的项目中，我使用 unittest 包来进行自动化测试，以验证代码不同部分的功能，更重要的是检查潜在数据异常的处理，如空值、缺失值、异常值等。

虽然好的编码实践可以确保模块的健壮性，但是编写好的代码需要花费大量的时间和精力。并非所有项目都证明了这一点。如果你正在做一个要在一周内交付的分析，你就没有时间美化你的代码。

因此，我倾向于将每个项目分为 3 个阶段:POC、MVP 和生产，如下所述:

POC 是我想得到一个解决方案来证明建模的可行性的地方
MVP 是解决方案足够健壮可以使用的地方(附加特性和模型调整)
生产是解决方案完全自动化和部署的地方。

如果我处于 POC 阶段，我不会花太多时间清理我的代码，但是一旦我进入 MVP 阶段，我会确保我的代码遵循良好的编码实践。

如果您觉得在您的数据科学实践中有任何其他实践，请随时在下面发表评论！干杯。

从优秀到卓越——如何成为世界上排名前 5%的开发者！

原文：https://towardsdatascience.com/good-to-great-how-to-become-the-top-5-developer-in-the-world-be0fe50ef9c7?source=collection_archive---------9-----------------------

每年，Stack Overflow 都会为我们提供许多关于他们年度开发者调查的有趣见解。你将对市场上最需要的编程语言、高薪职位等等有一个很好的了解。

在 Graphext ，我们也总是对调查结果非常感兴趣，但今年我们想尝试自己寻找见解。由于 Stack Overflow 发布了他们的调查数据，我们可以使用不同的方法简单地运行我们自己的分析。通过根据调查对象提供的所有答案创建聚类，我们将找到典型的、更详细的开发人员概况。

因此，今天我们将向您展示我们如何从这一点:

对此:

为了给我们的分析增添一点趣味，在开始我们的概要分析之前，我们问自己以下问题:

谁是收入最高的 5%的开发者？

将 88883 名调查对象按照回答了大多数问题的人进行筛选，我们最终得到 52545 人。从这些数据中，我们选择了年薪(美元)列的 95%分位数，我们的项目最终有大约 2600 名受访者。所有这些人的最低年收入为 573，108 美元，我们想了解这些人是谁。

重要提示 : Stack Overflow 使用总薪酬、货币、汇率以及薪酬是按周、按月还是按年计算的信息来计算美元年薪。因此，每个项目收费很高的顾问很容易获得超过 200 万英镑的虚拟年薪。

1.通用网络

在将我们的数据集输入到 Graphext 之后，我们得到了上面这张漂亮的图表。有几个颜色独特的开发人员群体已经可以识别，只需点击一下，我们就可以找到这些人的主要特征。

在下文中，我们将向您展示解释配置文件的主要变量。每个变量的值按提升排序，这意味着:

想象一下，在 VBA 整个人口计划中只有很少的人(6%)。当我们对我们的人口进行筛选时，VBA 不太可能成为最重要的编程语言。但是如果它的比例增加到——比如说——12 %,它对于选择的重要性就加倍了，因此我们说它是那个人的一个重要特征。

另一方面:如果 50%的人用 Java 编程，但在我们的集群中只有 30%的人这样做，那么这个特性就没有其他特性重要，即使它是最常用的编程语言。

简介#1:拥有学士学位的美国人

关键事实

工作之外的一些学习
数据和业务分析师、数据库管理员、设计师、QA、桌面应用程序、..
学士和副学士学位
在大公司工作
重要语言:VBA、C#、F#、PHP、SQL、..
在决定是否接受一份工作时，他们会寻找灵活的时间表、公司文化和远程工作选择

概要#2:德国 DevOps 和后端开发

关键事实

DevOps，后端开发，开发。对于游戏和图形，..
硕士学位、专业学位
对自己的职业不太满意
相信开源软件的质量
重要语言:Rust，Scala，Erlang，Java，..
他们在决定是否接受一份工作时，会考虑公司的多样性、职业发展和财务表现

简介 3:拥有博士和硕士学位的英国人

关键事实

高管、移动开发人员、开发人员、后端、前端、全栈、系统管理员，..
硕士和博士学位
几乎所有的都使用 MacOS
他们平均工作不到 40 小时
重要语言:Dart、WebAssembly、Clojure、Ruby、JavaScript
在决定是否接受一份工作时，他们会寻找多样性、公司文化和行业

结论和建议

尽管这些简介差别很大，但我们可以为你进入前 5%提取一些指导方针。

在美国，你不需要硕士学位，获得学士学位后马上开始工作。而在德国和英国，攻读硕士和博士的传统途径更为普遍。
学习 Rust 或 WebAssembly 这样的小众语言会让你获得竞争优势，让你在市场上更有需求。
公司文化和公司的多样性是前 5%的人在决定工作机会时经常提到的标准。选择一个适合你的工作场所似乎是成功的关键。
对你的职业选择持开放态度。作为 DevOps 或全栈开发人员，以及设计师或开发人员 QA，你可以赚很多钱

当然，还有更多的集群和洞见有待发现，这就是为什么我们让您可以访问这个项目。通过点击这个链接，你可以进入这个项目，开始你的探索之旅。

如果您想了解更多信息，请点击这里向我们索取演示，或者参加我们 6 月 19 日的网络研讨会。

谷歌人工智能和半监督学习的发展

原文：https://towardsdatascience.com/google-ai-and-developments-in-semi-supervised-learning-5b1a4ad29d67?source=collection_archive---------24-----------------------

Photo by @kerber

对人工智能领域意味着什么？

谷歌可以说是人工智能领域的领跑者之一。因此，努力了解他们的最新进展是很有意义的。昨天，在 7 月 10 日的 Google AI 博客上，两位研究人员谢启哲和 Thang Luong 写了一篇文章，标题是 用无监督数据增强推进半监督学习 。我打算尽我所能理解这篇文章，并解释他们的发现可能导致的一些后果。

在他们的介绍中，他们谈到了半监督学习中的无声革命。我不得不检查来源，我很有兴趣地看到他们提到了谷歌首席科学家 Vincent Vanhoucke 在 2019 年 5 月 15 日写的一篇文章。

接下来的三天我会看三个问题。

第一天:谷歌如何成为人工智能领域的领跑者？

第二天:无监督数据增强的半监督学习(SSL)取得了哪些进展？为什么它对人工智能领域很重要？

第三天:SSL 中静悄悄的革命是如何改变行业的？

今天是我从谷歌开始的第一天。

Google 如何成为 AI 领域的领跑者？

谷歌如何开始的故事似乎经常被提及，以至于有些人会说它不需要被提及，所以我会尽我所能保持简短。从车库到谷歌总部，他们首先建立了一个搜索引擎，使用链接来确定各个页面的重要性。这家公司被称为 Backrub，因为该程序分析网络的“反向链接”,以了解一个网站有多重要，以及它与其他什么网站相关。

用算法逆向确保网站的分类是正确的，这是谷歌的第一个创新 PageRank 。它通过计算一个页面链接的数量和质量来粗略估计网站的重要性。潜在的假设是，更重要的网站可能会从其他网站收到更多的链接。这可能是谷歌使用的最著名的算法，但它不是创始人发明的。事实上，谷歌的创始人在他们的原始论文中引用了加菲尔德、马尔基奥里和克莱恩伯格。

Mathematical PageRanks for a simple network, expressed as percentages. (Google uses a logarithmic scale.) Page C has a higher PageRank than Page E, even though there are fewer links to C; the one link to C comes from an important page and hence is of high value. If web surfers who start on a random page have an 85% likelihood of choosing a random link from the page they are currently visiting, and a 15% likelihood of jumping to a page chosen at random from the entire web, they will reach Page E 8.1% of the time. (The 15% likelihood of jumping to an arbitrary page corresponds to a damping factor of 85%.) Without damping, all web surfers would eventually end up on Pages A, B, or C, and all other pages would have PageRank zero. In the presence of damping, Page A effectively links to all pages in the web, even though it has no outgoing links of its own.

谷歌于 1998 年 9 月 4 日在美国加利福尼亚州门洛帕克成立。在他们发射的几十年前，在另一个向后看的领域，反向传播，已经有了一些发展。连续反向传播的基础是由 Henry J. Kelley 在 1960 年和 Arthur E. Bryson 在 1961 年使用动态规划(使用最优子结构在图中寻找最短路径)的原理推导出来的。

随着进步，我们似乎不得不回顾过去，以弄清前进的方向，或者下一个岔路口。

我一直对到达感兴趣，对进入一个空间感兴趣，甚至对回头看你在哪里感兴趣。

詹姆士·特瑞尔

反向传播 ，误差的 反向传播 的简称，是一种利用梯度下降进行人工神经网络监督学习的算法。给定人工神经网络和误差函数，该方法计算误差函数相对于神经网络权重的梯度。

最近，在 1986 年，通过大卫·鲁梅尔哈特、杰弗里·欣顿、罗纳德·j·威廉姆斯和詹姆斯·麦克莱兰的工作，重新引入了反向传播。就图像分类而言，这在后来被证明对图像搜索很重要。尤其是当后来谷歌成长为最受欢迎的搜索引擎，并推出图片搜索时:

因此，我们的联合创始人拉里·佩奇和谢尔盖·布林——像所有其他成功的发明家一样——不断迭代。他们从图像开始。毕竟，人们想要的不仅仅是文本。这一点在 2000 年格莱美颁奖典礼后变得更加明显，詹妮弗·洛佩兹穿着一件绿色礼服，吸引了全世界的目光。当时，这是我们见过的最流行的搜索查询。但是我们没有确定的方法让用户得到他们想要的:詹妮弗·洛佩兹穿着那条裙子。谷歌图片搜索诞生了。
——谷歌前首席执行官 Eric Schmidt 引自《石英》杂志 2015 年 4 月。

2001 年 7 月 Google Image 推出时，该网站提供了 2 . 5 亿张图片。

从搜索引擎的角度来看，网络本质上是数十亿页文字的集合体，以及连接这些文字的超链接。谷歌的重大突破之一是有效地链接这些单词，通过单词在页面上的出现来衡量相关性，以及指向该页面的超链接的数量，或其受欢迎程度[……]现在，大多数图像搜索引擎依赖关键词，或链接到照片的描述性文本，以检索与网络冲浪者的关键词查询匹配的结果列表。然而，如果照片或图像缺乏足够的描述，这种方法可能不可靠。

斯蒂芬妮·奥尔森，CNET 2006 年

到 2010 年，谷歌图片的数量已经超过 100 亿张。当时可能很清楚，他们必须做些什么。那就是谷歌大脑。

Google Brain 是 Google 的一个深度学习人工智能研究团队。谷歌大脑成立于 2010 年代初，将开放式机器学习研究与系统工程和谷歌规模的计算资源相结合。它始于谷歌研究员杰夫·迪恩、谷歌研究员格雷格·科拉多和斯坦福大学教授吴恩达之间的合作。

21 世纪初，当我在斯坦福大学时，我的博士生亚当·科茨(Adam Coates)带着一张图表来到我的办公室，这张图表显示，输入神经网络的数据越多，神经网络的表现就越好。我们开始寻找我们能找到的最大的计算机。这一发现，以及利用分布式计算扩大神经网络的想法，导致了 2011 年谷歌大脑的诞生。从那以后，深度学习取得了巨大的进步，因为我们收集了更多的数据，并创造了强大的计算机来使其工作。
——吴恩达引自 WIPO 技术趋势 2019:人工智能(第 9 页)。

深度学习热潮始于 2012 年的一篇论文，该论文以主要作者亚历克斯·克里兹夫斯基的名字命名，被称为“亚历克斯网”。多伦多大学撰写这篇论文的三位研究人员(包括 Geoffrey Hinton 和 Ilya Sutskever)参加了 ImageNet 竞赛，将图像分为一千个类别。AlexNet 通过使用深度神经网络实现了前所未有的准确性，该网络有八个可训练层和 65 万个神经元。

他们能够在如此多的数据上训练如此庞大的网络，因为他们知道如何利用消费级 GPU，这是为大规模并行处理而设计的。这证明了更好的算法、更多的训练数据和更强的计算能力的重要性。

2012 年，谷歌创建的一个神经网络学会了识别 YouTube 视频中的人类和猫——而从未被告知如何描述它们。它自学以 74.8%的准确率检测猫科动物，以 81.7%的准确率检测人脸
- 通过谷歌 探索机器学习

2013 年，杰弗里·辛顿加入了谷歌大脑。AlexNet 在 2012 年获胜两年后，谷歌带着一个甚至更深层次的神经网络参加了比赛，并获得了最高奖项。该公司已经开始雇佣顶级机器学习专家，并收购专注于人工智能领域的公司。用于识别图像的一个流行版本是卷积神经网络(CNN)。

Shared by Jefkine in Deepgrid

Typical CNN Architecture

通过输入数据，你可以对不同的图像进行分类。该公司还拥有无与伦比的访问大型数据集的能力。2013 年的一篇论文描述了谷歌如何使用深度神经网络来识别谷歌街景拍摄的数千万张图像中的地址号码。

Are.na on classification

DeepMind(深度学习，以 4 亿美元收购)的 2014 年收购就是一个著名的例子，从而保持了神经网络设计的前沿。该公司已经创建了一个学习玩游戏的神经网络以及一个神经图灵机(可以像图灵机一样访问外部存储器)。该公司在 2016 年成为头条新闻，此前其 AlphaGo 程序在五局比赛中击败了世界冠军人类职业围棋选手 Lee Sedol。

2016 年，谷歌创造了一种定制芯片，称为张量处理单元，专门用于加速神经网络使用的操作。TensorFlow 与 Tensor AI 芯片相结合的机器系统现在对所有人免费。谷歌首席执行官桑德尔·皮帅提到，谷歌正在从“移动优先”向“人工智能优先”转变。

Google CEO Sundar Pichai speaks during the Google I/O Developers Conference on May 7, 2019 — Photo from Ars Technica.

你可以看到 CNN 的几个层次，以及用概念激活向量进行的定量测试 ( TCAV )这是一种新的可解释性方法，可以了解你的神经网络模型使用什么信号进行预测

今年(2019)6 月我写了一篇名为人工智能领域的专利的文章。谷歌并不是人工智能领域拥有最多专利的公司之一。事实上，排名靠前的公司从大到小依次是:IBM(8290 家)、微软(5930 家)、东芝(5223 家)、三星(5102 家)和 NEC(4406 家)。我的文章参考了世界知识产权组织(WIPO)报告 技术趋势 2019:人工智能 。另一方面

“……Alphabet(包括谷歌、DeepMind、Waymo 和 X Development)在申请的发明数量方面排名第十，总共有 3，814 项，在收购人工智能公司方面排名第一《世界知识产权组织 2019 年技术趋势:人工智能》(第 16 页)

从编程的角度来看，谷歌仍在向后看，以继续前进。然而，由于其二十多年来专注于分类的运营，以及其围绕新技术建立包容性网络的方式，以及其收购，我可以公平地解释为什么谷歌目前是人工智能领域的领跑者之一。

这是第 500 天的第 39 天。

我知道这是一个玩笑，正如你所理解的，我可能无法在接下来的几天里完全回答我在这篇文章中概述的问题，但是一如既往地，我当然希望你在旅程中坚持和我在一起。

什么是#500daysofAI？
我正在挑战自己，用#500daysofAI 写下并思考未来 500 天的人工智能话题。一起学习是最大的快乐，所以如果你觉得一篇文章引起了共鸣，请给我反馈。

Google BigQuery SQL 日期和时间备忘单

原文：https://towardsdatascience.com/google-bigquery-sql-dates-and-times-cheat-sheet-805b5502c7f0?source=collection_archive---------4-----------------------

常见 BigQuery 日期和时间表达式的备忘单

Photo by Sonja Langford on Unsplash

我今天早上刚刚开始做一个时间序列预测项目。与大多数数据科学任务一样，这个项目的第一步是首先收集数据。这意味着 Google BigQuery 中的 SQL 查询相对简单。我又一次发现自己在谷歌上搜索如何从时间戳中提取年份，并在文档中滚动以找到正确的函数，然后意识到我需要在某个地方写下来。我把它写在博客上，这样我就有东西可以参考，希望这也能帮助其他人。请注意，所有表达式都基于标准 SQL。

日期

日期部分

下列表达式中可以使用的所有日期部分的列表:

DAYOFWEEK (returns 1-7 Sunday is 1)
DAY
DAYOFYEAR (0-365)
WEEK (week of year 0-53, week begins on Sunday)
WEEK(<chosen weekday>) (week of year begins on your chosen day e.g. SUNDAY)
ISOWEEK (ISO 8601 week number, week begins on Monday)
MONTH
QUARTER (1-4)
YEAR (ISO 8601 year number)

提取日期部分

EXTRACT(part FROM date_expression)Example: EXTRACT(YEAR FROM 2019-04-01)Output: 2019

从整数构造一个日期

DATE(year, month, day)Example: DATE(2019, 04, 01)Output: 2019-04-01

从日期中加减

DATE_ADD(date_expression, INTERVAL INT64_expr date_part)Example: DATE_ADD('2019-04-01', INTERVAL 1 DAY)Output: 2019-04-02DATE_SUB(date_expression, INTERVAL INT64_expr date_part)Example: DATE_SUB('2019-04-01', INTERVAL 1 DAY)Output: 2019-03-31Example use case - dynamic dates:where my_date between DATE_SUB(current_date, INTERVAL 7 DAY) and DATE_SUB(current_date, INTERVAL 1 DAY)

两个日期之间的差异

DATE_DIFF(date_expression, date_expression, date_part)Example: DATE_DIFF(2019-02-02, 2019-02-01, DAY)Output: 1

指定日期的粒度

DATE_TRUNC(date_expression, date_part)Example: DATE_TRUNC(2019-04-12, WEEK)Output: 2019-04-07

英国泰晤士报(1785 年创刊)

时间部分

MICROSECOND
MILLISECOND
SECOND
MINUTE
HOUR

从整数构造一个日期时间对象

DATETIME(year, month, day, hour, minute, second)
DATETIME(date_expression, time_expression)
DATETIME(timestamp_expression [, timezone])Example: DATETIME(2019, 04, 01, 11, 55, 00)Output: 2019-04-01 11:55:00

加减时间

DATETIME_ADD(datetime_expression, INTERVAL INT64_expr part)Example: DATETIME_ADD('2019-04-01 11:55:00', INTERVAL 1 MINUTE)Output: 2019-04-01 11:56:00DATETIME_SUB(datetime_expression, INTERVAL INT64_expr part)Example: DATETIME_SUB('2019-04-01 11:55:00', INTERVAL 1 MINUTE)Output: 2019-04-01 11:54:00

两次之间的差异

DATETIME_DIFF(datetime_expression, datetime_expression, part)Example: DATETIME_DIFF('2019-04-01 11:56:00', '2019-04-01 11:55:00', MINUTE)Output: 1

指定时间的粒度

DATETIME_TRUNC(datetime_expression, part)Example: DATETIME_TRUNC('2019-04-01 11:55:00', HOUR)Output: 2019-04-01 11:00:00

这绝不是 BigQuery 中日期和时间表达式的详尽指南。它只是作为我最常用的快速参考。如需更全面的指南，请参阅谷歌大查询文档。

牛津大学的艾丹·戈麦斯谈在谷歌工作和对普通智能的追求

原文：https://towardsdatascience.com/google-brains-aidan-gomez-on-oxford-google-and-general-intelligence-2ce4a19ba5da?source=collection_archive---------25-----------------------

Aidan Gomez 是谷歌大脑的机器学习研究员，牛津大学的博士生。

他曾与 Geoff Hinton 和 Jeff Dean 合作过最先进的深度学习项目，也是 FOR.ai 的创始人，该项目致力于通过国际项目合作帮助年轻研究人员学习前沿的机器学习技术。

我们与 Aidan 坐下来讨论了机器学习社区的开放性和可访问性，有抱负的数据科学家和机器学习研究人员如何打入该领域，以及人工通用智能道路上的障碍。

您可以在 Twitter 上关注 Aidan，地址为 @AidanNGomez ，并收听我们下面的聊天内容:

谷歌云:一个简单到令人惊叹的平台

原文：https://towardsdatascience.com/google-cloud-an-easy-way-to-an-amazing-platform-1dc97c00ab9b?source=collection_archive---------12-----------------------

云是关于你如何计算，而不是你在哪里计算。— Paul Maritz，VMware 和 Pivotal 前首席执行官

免费免费使用您的谷歌云帐户的最佳描述方式..👽

为什么是云？

Telescope Desktop HD Wallpaper

所以你最终决定进入深度学习游戏，只是意识到在你的笔记本电脑上训练你的深度学习模型需要亿万年，因为要么你没有 GPU，所以你必须在 CPU 上训练你的模型，要么你甚至更不幸，只能用 AMD。不管怎样，我知道那种感觉，真的很糟糕😞

 Get your game on already, AMD!

现在最基本的问题！！什么是云计算？

Dad: What are clouds made of in IT? — nixCraft

在云计算中，建设和维护数据中心的资本投资被作为云“提供商”提供的弹性、类似公用事业的服务(包括存储、计算、网络、数据处理和分析、应用程序开发、机器学习，甚至完全托管的服务)来消费 IT 资源所取代。

谷歌云平台 300 美元免费积分——为深度学习学生提供难以置信的优惠:

朋友们好！😍

如果你是一名机器学习工程师/深度学习工程师/开发人员，还没有注册 GCP 帐户，你可以在这里从你的任何 gmail 帐户启用 GCP，并获得第一年 300 美元的免费点数(12 个月免费 wow gpu)。这个信用足够好，几乎 1000 小时的英伟达特斯拉 K80 图形处理器或英伟达特斯拉 P100 图形处理器！！

在我们开始之前

 # --BIG REMINDER: Make sure you stop your instances-

当你完成时，不要忘记停止你的实例(通过点击显示你的实例的页面顶部的停止按钮)，否则你将耗尽信用，这将是令人伤心的。😩

如果您正确遵循下面的说明，您应该能够重新启动实例，并且下载的软件仍然可用。

CS231n Stanford: Google Cloud Tutorial

创建和配置您的帐户:

如果你没有 Google cloud 账户，可以通过访问 Google Cloud 主页并点击计算来创建一个。当你进入下一页时，点击蓝色的免费试用按钮。如果您没有登录 gmail，您将会看到如下所示的页面。登录您的 gmail 帐户或创建一个新帐户如果您没有帐户，请填写所有必要的卡详细信息(您可以使用任何信用卡或借记卡(不包括 SBI)作为支付方式)。

在第一个选项中单击相应的“是”或“否”按钮，在阅读完所需的协议后，在第二个选项中选择“是”。按蓝色的同意并继续按钮进入下一页，输入所需信息(您的姓名、帐单地址和信用卡信息)。记住选择“个人”作为“账户类型”:

A dummy account 😘

输入所需信息后，请按蓝色的“开始我的免费试用”按钮。你会看到这样一个页面:Tan Tadha da dha👐— —现在你在你的谷歌云平台里了！！点击左上角以蓝色显示的谷歌云平台，它将带你进入主仪表盘:

 Dashboard will looks like

重要提示:

一些最近注册了 GCP 的用户，可以在开始他们的项目时看到这个错误:

 “Quota ‘GPUS_ALL_REGIONS’ exceeded. Limit: 0.0 globally."

请前往Dashboard-> IAM & admin -> Quotas - >搜索以下额度GPUs (all region)。

在情况限制，为这是 0，你需要通过点击Edit Quotas请求谷歌增加到 1 或任何你需要的值。

创建虚拟实例:

启动一个虚拟实例:-: Compute Engine-> VM Instances-> Create。

这将带你到一个页面，看起来像下面的截图。

(NOTE: Please carefully read the instructions in addition to looking at the screenshots. The instructions tell you generally what values I prefer to fill in :)).

Create your VM Instance

名称:xyz - >区:us-central-1-c - >(点击自定义)CPU &内存大小:4 - > GPU : 1 -Nvidia Tesla P100 or K80(价格适中)- >点击change启动盘，选择ubuntu 16.04为默认，100 GB disk size - >勾选，选择允许 HTTP 流量和允许 HTTPS 流量- >最后按Create。

太棒了。您已经成功创建了您的VM instance -它将被永久固定，包含内部和外部 IP 地址(从这里您的 gpu 开始计算您的点数)。见下图截图

Instance is ready 😃

几个命令行中最重要但最令人恐慌的设置:😁

现在设置您的谷歌云平台:

生成一个 VM 实例后→点击 SSH 附近的一个key作为圈出- > open in browser window - >一个 google Active Cloud Shell！！

“Google cloud shell”

以下是一系列命令行:用于设置你的谷歌云账户

$curl -O https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_9.0.176-1_amd64.debsudo dpkg -i cuda-repo-ubuntu1604_9.0.176-1_amd64.deb$ sudo apt-get update
$ sudo apt-get install cuda-9-0$ sudo nvidia-smi -pm 1 
$ nvidia-smi $ wget "https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7_7.0.4.31 1+cuda9.0_amd64.deb" $ sudo dpkg -i libcudnn7_7.0.4.31-1+cuda9.0_amd64.deb $ echo 'export CUDA_HOME=/usr/local/cuda' >> ~/.bashrc
$ echo 'export PATH=$PATH:$CUDA_HOME/bin' >> ~/.bashrc
$ echo 'export LD_LIBRARY_PATH=/usr/local/cuda/extras/CUPTI/lib64:$LD_LIBRARY_PATH' >> ~/.bashrcsource ~/.bashrc $ sudo apt-get install python3-dev $ python3-pip libcupti-dev
$ sudo pip3 install tensorflow-gpu # this applies to all GPUs
$ sudo nvidia-smi -pm 1 $ python3import tensorflow as tf with tf.device('/cpu:0'):    
 a_c = tf.constant([1.0, 2.0, 3.0, 4.0], shape=[1, 3],name='a-cpu')   
 b_c = tf.constant([1.0, 2.0, 3.0, 4.0], shape=[3, 1], name='b-cpu')
 c_c = tf.matmul(a_c, b_c, name='c-cpu')

with tf.device('/gpu:0'):    
 a_g = tf.constant([1.0, 2.0, 3.0, 4.0], shape=[1, 3], name='a-gpu')
 b_g = tf.constant([1.0, 2.0, 3.0, 4.0], shape=[3, 1], name='b-gpu') 
 c_g = tf.matmul(a_g, b_g, name='c-gpu') with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:       print (sess.run(c_c))   
   print (sess.run(c_g)) 
print ('DONE!')

现在简单的说就是把每一个命令行复制粘贴到谷歌云终端，你会发现我们已经在他们的服务器上了，网速，流畅度都比你的本地机器好得多。

从最后两行开始，我已经在 google-cloud 中安装了“tensorflow-gpu ”,并在终端中进行了测试。

为了进一步的测试，我包含了从这段代码到我的 github 库的链接: github : [gpu_mnist_speedcheck.py](https://github.com/tarahb2103/Google-Cloud-An-Easy-Way-to-an-Amazing-Platform/blob/master/gpu/gpu_mnist_speedcheck.py):只要把代码复制到你的 gcp 引擎的终端，然后按 enter - tadha da🎉—现在你会发现，与本地机器相比，培训大约是 15 倍。

注意:在这里你可以安装所有需要的库(比如 pytorch，mxnet 等。)你的深度学习项目想要什么就有什么。在完成您的培训模块后，请按 SSH 附近的Stop(在 3 个点上)来停止您的实例，以确保您的学分持续更长时间。

 Thank You Everyone  See you soon!

用于医学图像分类的谷歌云自动视觉

原文：https://towardsdatascience.com/google-cloud-automl-vision-for-medical-image-classification-76dfbf12a77e?source=collection_archive---------3-----------------------

使用胸部 X 射线图像的肺炎检测

The normal chest X-ray (left panel) shows clear lungs without any areas of abnormal opacification in the image. Bacterial pneumonia (middle) typically exhibits a focal lobar consolidation, in this case in the right upper lobe (white arrows), whereas viral pneumonia (right) manifests with a more diffuse “interstitial” pattern in both lungs. (Source: Kermany, D. S., Goldbaum M., et al. 2018. Identifying Medical Diagnoses and Treatable Diseases by Image-Based Deep Learning. Cell. https://www.cell.com/cell/fulltext/S0092-8674(18)30154-5)

Google Cloud AutoML Vision 简化了图像识别用例的自定义视觉模型的创建。在引擎盖下使用神经架构搜索和转移学习的概念来寻找最佳网络架构和使模型的损失函数最小化的最佳超参数配置。本文使用 Google Cloud AutoML Vision 开发了一个端到端的医学图像分类模型，用于使用胸部 X 射线图像进行肺炎检测。

关于数据集

数据集包含:

5232 张儿童胸部 x 光照片。
其中 3883 张是细菌性(2538 张)和病毒性(1345 张)肺炎的样本。
1349 个样本是健康的肺部 x 光图像。

数据集托管在 Kaggle 上，可通过胸部 x 光图像(肺炎)访问。

第 1 部分:在 GCP 上实现 AutoML 云愿景

(1).去云端控制台:https://cloud.google.com/

Google Cloud Homepage

(2).通过单击 GCP 仪表盘左上角的三点划线打开 Cloud AutoML Vision。选择人工智能产品部分下的视觉。

Open AutoML Vision

(3).选择自动视觉下的图像分类。

Image Classification under AutoML Vision

(4).设置项目 API、权限和云存储桶，以存储用于建模和其他资产的图像文件。

Setup Project APIs and Permissions

(5).询问时，从下拉列表中选择您的 GCP 帐单项目。现在我们准备创建一个数据集，用于在 AutoML 上构建定制分类模型。在将原始数据集从 Kaggle 下载到云存储并准备好用于 AutoML 建模的数据后，我们将返回这里。

在这种情况下，自动创建的桶被称为:g s://ekabasandbox-vcm 。

第 2 部分:将数据集下载到 Google 云存储中

(1).激活云外壳(红色圆圈中)以启动临时 VM 实例来存放从 Kaggle 下载的数据集，将其解压缩并上传到存储桶。

Activate Cloud Shell

(2).安装 Kaggle 命令行界面。这个工具将允许我们从 Kaggle 下载数据集。运行以下代码:

sudo pip install kaggle

但是，请注意，云外壳实例是短暂的，当会话结束时，它不会保存系统范围内的更改。此外，如果数据集特别大，还有其他选择，例如启动计算虚拟机，下载数据集，解压缩，然后上传到云存储。可以设计其他高级数据管道，将数据输入 GCP 进行分析/机器学习。

(3).下载 Kaggle API 令牌密钥，使 Kaggle CLI 能够针对 Kaggle 进行身份验证/授权，以下载所需的数据集。

登录您的 Kaggle 帐户。
转到:https://www . ka ggle . com/[ka ggle _ 用户名]/帐户
点击:创建新的 API 令牌。

Create API Token

将令牌下载到您的本地机器，并将其上传到云 shell。

将上传的.json键移动到目录.kaggle中。使用下面的代码:

mv kaggle.json .kaggle/kaggle.json

(4).从 Kaggle 下载数据集到 Google 云存储。

kaggle datasets download paultimothymooney/chest-xray-pneumonia

(5).解压缩下载的数据集

unzip chest-xray-pneumonia.zip
unzip chest_xray.zip

(6).将数据集从临时云外壳实例移动到创建的云存储桶。在此插入您的存储桶名称。

gsutil -m cp -r chest_xray gs://**ekabasandbox-vcm**/chest_xray/

第 3 部分:为建模准备数据集

(1).在谷歌云 AI 平台上推出 Jupyter 笔记本。

Notebooks of GCP AI Platform

(2).创建新的笔记本实例。

Start a new JupyterLab instance

(3).选择实例名称并创建。

Choose an instance name and create

(4).打开 JupyterLab

Open JupyterLab

(5).在使用 AutoML Cloud Vision 构建自定义图像识别模型之前，必须以特定格式准备数据集:

对于训练，支持 JPEG、PNG、WEBP、GIF、BMP、TIFF 和 ICO 图像格式，每个图像的最大大小为 30mb。
为了便于推断，JPEG、PNG 和 GIF 图像格式受支持，每张图像的最大大小为 1.5mb。
最好将每个图像类别放入图像文件夹内的包含子文件夹中。例如，
(图像目录)>(图像类别 1-子目录)——(图像类别 n-子目录)
接下来，创建一个指向图像路径及其相应标签的 CSV。AutoML 使用 CSV 文件指向训练图像及其标签的位置。CSV 文件放在包含图像文件的同一个 GCS 存储桶中。使用配置 AutoML Vision 时自动创建的存储桶。在我们的例子中，这个桶被命名为 gs:// ekabasandbox-vcm 。

(6).从 Github 克隆预处理脚本。点击标有( 1) 的红色圆圈图标，输入 Github URLhttps://Github . com/dvdbisong/automl-medical-image-classification，克隆带有预处理代码的 repo。

Clone preprocessing script

(7).运行笔记本preprocessing.ipynb中的所有单元格，创建包含图像路径和标签的 CSV 文件，并将该文件上传到云存储。务必更改bucket_name的参数。

Run notebook cells

第 4 部分:使用云自动视觉建模

(1).从 AutoML Vision 仪表板中单击“新建数据集”。

Create New Dataset

(2).填写数据集名称，并从 AutoML 创建的云存储桶中选择 CSV 文件。

Create Dataset

(3).现在，如果您看到错误消息“找到重复的文件”,您可以退出。据我所知，从文件名来看，情况并非如此。

Cloud AutoML Processed Images

(4).点击列车，如上图红色所示，启动 Cloud AutoML 建模。

Start AutoML Training

(5).选择模型的托管方式和培训预算。

Select training parameters

(6).模型训练完成后，单击“评估”查看模型的性能指标。

Evaluate model performance

(7).评估性能指标(精确度、召回率和混淆矩阵)。

Evaluation page. Left: Precision and Recall score. Right: Confusion matrix and precision, recall graphs

第 5 部分:测试模型

(1).点击预测标签来测试模型。

Predict model

(2).这里有一个测试的例子。该图像是胸部 x 射线扫描，并未用于训练模型。阅读本文的医学专家可以验证模型预测的准确性。

Model test

自定义图像识别模型也作为 REST 或 Python API 公开，用于集成到软件应用程序中，作为推断的预测服务。

第六部分:结论

本文提供了一个通过利用 Google 云平台 AutoML vision 为定制用例设计强大的 Vision 模型的演练。此外，模型托管在云上，作为预测服务进行推理。这是一种强大的机制，可以在决定是否继续进行更细粒度和/或手动调整的建模工作之前，快速原型化和构建图像分类或对象检测用例。有了这个，我相信它将作为一个模板，适用于你关心的视力问题。此外，确保删除不再需要的模型和数据集，这将节省云成本。

本文节选自 Apress (Springer Nature)出版的《在 Google 云平台上构建机器学习和深度学习模型》一书。

面向大数据的谷歌云服务

原文：https://towardsdatascience.com/google-cloud-services-for-big-data-b9a657877ae2?source=collection_archive---------7-----------------------

在本文中，我们将回顾谷歌云服务，它可以帮助您构建伟大的大数据应用程序。

谷歌云平台提供了很多不同的服务，这些服务涵盖了数据和大数据应用的所有流行需求。所有这些服务都与其他谷歌云产品集成在一起，它们各有利弊。在本文中，我们将回顾 GCP 可以为数据和大数据应用提供哪些服务，这些服务有哪些作用，有哪些优势和局限性，每种服务的定价策略是什么，以及有哪些替代方案。

云发布订阅

Cloud PubSub 是一个消息队列代理，允许应用程序可靠、快速、异步地交换消息。基于发布-订阅模式。

Visualization of PubSub workflow

下图描述了 PubSub 的基本流程。发布者应用程序将消息发布到发布订阅主题；该主题向发布订阅发送消息；订阅存储消息；订阅者应用程序从订阅中读取消息。

利益

高可靠性通信层
大容量

局限性:

一封邮件的最大大小是 10 MB
10 MB 是一个请求的最大大小，这意味着如果我们需要为每个请求发送 10 条消息，每条消息的平均最大大小将是 1 MB。
最大属性值大小为 1 MB

定价策略:

您需要为传输的每 GB 数据付费。

类似物和替代品:

阿帕奇卡夫卡
兔子 q
亚马逊 SQS
Azure 服务总线
还有很多其他的开源消息代理

谷歌云物联网核心

Design of Cloud IoT Core

云物联网核心是一个物联网设备注册表。该服务允许将设备连接到谷歌云平台，从设备接收消息，并向设备发送消息。为了从设备接收消息，物联网核心使用 Google PubSub。

好处:

MQTT 和 HTTPS 传输协议
安全的设备连接和管理

定价策略:

您需要为通过这项服务传输的数据量付费。

类似物和替代品:

AWS 物联网核心
Azure 物联网

云数据探测器

Cloud Dataproc 是在 Google Cloud 中运行 Apache Spark 和 Apache Hadoop 的一种更快、更简单、更具成本效益的方式。Cloud Dataproc 是一个云原生解决方案，涵盖了与部署和管理 Spark 或 Hadoop 集群相关的所有操作。简单地说，使用 Dataproc，您可以创建一个实例集群，动态地改变集群的大小，配置它，并在那里运行 MapReduce 作业。

好处:

非常快速的部署
一个完全托管的服务，这意味着你只需要正确的代码，没有操作工作
动态调整集群的大小
自动缩放

局限性:

无法选择所用框架的特定版本
为了省钱，您不能暂停/停止数据处理集群，只能删除集群。这可以通过 Cloud Composer 来实现
您不能选择集群管理器，只能选择 YARN

定价策略:

您为每个使用的实例支付一些额外的费用。集群工作时，GCP 按分钟计费。

类似物和替代品:

在虚拟机上设置集群
亚马逊电子病历
Azure 高清洞察

云数据流

The place of Cloud Dataflow in a Big Data application

云数据流是一种托管服务，用于开发和执行广泛的数据处理模式，包括 ETL、批处理、流处理等。数据流用于构建数据管道。该服务基于 Apache Beam，支持 Python 和 Java 作业。

好处:

将批处理和流式处理与单个 API 相结合
非常快速的部署
一个完全托管的服务，没有运营工作
动态工作再平衡
自动缩放

局限性:

基于单一解决方案，因此继承了 Apache Beam 的所有限制
串流引擎中单个元素值的最大大小为 100 Mb

定价策略:

基于云数据流的实际使用，云数据流作业按每秒计费。

类似物和替代品:

在虚拟机上设置集群，并通过内置的 runner 运行 Apache Beam
据我所知，其他云提供商没有类似的产品

谷歌云数据准备

This is what the interface of Dataprep looks like

Dataprep 是一个可视化、探索和准备数据的工具。您可以构建管道来为不同的存储 ETL 您的数据。并在简单易懂的网络界面上完成。

例如，您可以使用 Dataprep 构建 ETL 管道，从 GCS 中提取原始数据，清理这些数据，转换成所需的视图，并将数据加载到 BigQuery 中。此外，您还可以安排每天/每周/等等的作业来运行新原始数据的管道。

好处:

简化 ETL 管道的构建
提供清晰有用的网络界面
为数据工程师自动化大量手工工作
内置调度程序
为了执行 ETL 工作，Dataprep 使用 Google Dataflow

局限性:

仅适用于 BigQuery 和 GCS

定价策略:

对于数据存储，您需要为数据存储付费。为了执行 ETL 作业，你需要为谷歌数据流付费。

云作曲家

Cloud Composer 是管理数据处理的工作流编排服务。Cloud Composer 是 Apache Airflow 的云接口。Composer 允许自动执行 ETL 作业，例如，可以创建 Dataproc 集群，对提取的数据执行转换(通过 Dataproc PySpark 作业)，将结果上传到 BigQuery，然后关闭 Dataproc 集群。

利益

填补了其他 GCP 解决方案的空白，比如 Dataproc
继承了阿帕奇气流的所有优势

局限性:

在公共 IP 地址上提供气流 web 用户界面
继承了阿帕奇气流的所有限制

定价策略:

您只需为部署了 Composer 的资源付费。但是编写器将被部署到 3 个实例。

类似物和替代品:

定制部署的阿帕奇气流
其他编排开源解决方案

BigQuery

Example of integration BigQuery into a data processing solution with different front-end integrations

BigQuery 是一个数据仓库。

BigQuery 允许我们存储和查询海量数据集，高达数百 Pb。BigQuery 的结构是关系数据库非常熟悉的，它有表结构，使用 SQL，也支持批处理和流写入数据库，与所有 GCP 服务集成，包括数据流，Apache Spark，Apache Hadoop 等。它最适合用于交互式排队和离线分析。

好处:

巨大的容量，高达数百 Pb
结构化查询语言
批处理和流式写入
支持复杂查询
内置 ML(简单——目前很愚蠢)
无服务器
共享数据集-您可以在不同的项目之间共享数据集
全球位置
所有流行的数据处理工具都有 BigQuery 接口

局限性:

不支持事务，但是谁需要 OLAP 解决方案中的转换
该行的最大大小是 10Mb

定价策略:

您需要为存储的信息(每 Gb)和执行的查询分别付费。

对于已执行的查询，您可以选择两种支付模式中的一种，要么为每个已处理的 TB 付费，要么支付稳定的月费用。这取决于你的喜好。

类似物和替代品:

亚马逊红移
天蓝色宇宙数据库

云大表

谷歌云 BigTable 是谷歌的 NoSQL 大数据数据库服务。这是支持许多核心谷歌服务的同一个数据库，包括搜索、分析、地图和 Gmail。Bigtable 旨在以一致的低延迟和高吞吐量处理大量工作负载，因此它是运营和分析应用程序的绝佳选择，包括物联网、用户分析和金融数据分析。

基于 Apache HBase 的云 Bigtable。

这个数据库有非常大的容量，如果你有超过万亿字节的数据，建议使用。BigTable 最适合时序数据，物联网数据。

利益

在 1Tb 或更多数据上具有良好的性能
无需停机即可调整集群大小
难以置信的可扩展性
Apache HBase 的支持 API

局限性:

在小于 300 Gb 的数据上性能非常差
不适合实时
不支持酸性操作
单个值的最大大小为 100 Mb
一行中所有值的最大大小为 256 Mb
每个节点的硬盘最大容量为 8 Tb
群集中最少 3 个节点

定价策略:

BigTable 非常昂贵。您需要为节点(每个节点每小时最低 0.65 美元)和存储容量(每月每 TB 最低 26 美元)付费

类似物和替代品:

定制部署的 Apache HBase

云存储

Description of different options of GCS

GCS 是文件的 blob 存储。您可以在那里存储任意数量、任意大小的文件。

好处:

适用于所有流行编程语言和操作系统的良好 API
不可变文件
文件的版本
适合任何大小的文件
适合任何数量的文件
等等

定价策略:

GCS 有几个定价计划。在标准计划中，您需要为 1Gb 的存储数据付费。

类似物和替代品:

亚马逊 S3
Azure Blob 存储

其他谷歌云服务:

还有几个服务，我不得不提到。

谷歌云计算引擎为虚拟机提供任何性能容量。
Google CloudSQL 是一个托管 MySQL 和 PostgreSQL 数据库的云原生解决方案。内置纵向和横向扩展、防火墙、加密、备份以及使用云解决方案的其他优势。有万亿字节的容量。支持困难的查询和交易
Google Cloud Spanner 是一个完全托管的、可扩展的关系数据库服务。支持 SQL 查询，自动复制，事务。它有十亿字节的容量。最适合大规模数据库应用程序，这种应用程序存储的数据超过数 TB。这是一个 OLTP 数据库。
Google StackDriver 正在监控 Google 服务和基础设施，以及托管在 GCP 的应用程序。
云数据实验室是一种可视化和探索数据的方式。该服务提供了一种云本地方式来托管 Python Jupiter 笔记本。
Google Cloud AutoML 和 Google AI 平台允许以最小的努力训练和托管高质量的定制机器学习模型。

结论

现在，您已经熟悉了 GCP 提供的主要数据服务。这些知识可以帮助您构建良好的数据解决方案。当然，云不是万能的，如果你使用云的方式不对，它会影响你每月的基础设施账单。

因此，非常仔细地构建您的提案的架构，并根据您的需求选择必要的服务，以达到所需的业务目标。探索每个特定案例的所有优点和局限性。关心成本。当然，还要记住解决方案的可伸缩性、可靠性和可维护性。

有用的链接:

如果您想了解更多信息，可以查看以下内容:

谷歌大数据产品https://cloud.google.com/products/big-data/
谷歌大数据解决方案https://cloud.google.com/solutions/big-data/
QwikLabs 上的数据工程实验室:https://www.qwiklabs.com/quests/25
Coursera 上的谷歌数据工程课程:https://www . Coursera . org/professional-certificates/GCP-Data-Engineering # courses
大数据架构示例https://gcp.solutions/workload/Big%20Data

在 Google 联合实验室上运行 Python 脚本的快速指南

原文：https://towardsdatascience.com/google-colab-59ad8510eb7e?source=collection_archive---------8-----------------------

今天就开始用免费的 GPU 训练你的神经网络吧

Photo by Christopher Gower on Unsplash

如果你正在寻找一种交互式的方式来运行你的 Python 脚本，比方说你想和几个朋友一起开始一个机器学习项目，不要再犹豫了——Google Colab 是最适合你的解决方案。你可以在线工作，把你的代码保存在本地的谷歌硬盘上，它允许你

使用免费的 GPU(和 TPU)运行您的脚本！)
利用预装的 Python 库和 Jupyter 笔记本特性
在任何你想去的地方工作，它就在云上
与同事共享代码和协作

简言之，

Google Colab = Jupyter 笔记本+免费 GPU

与大多数(如果不是全部)替代方案相比，它的界面可以说是更干净的。我想出了一些代码片段，供你掌握 Google Colab。当您需要一些现成的代码来解决 Colab 上的常见问题时，我希望这成为一篇必不可少的文章。

基础

启用 GPU/TPU 加速

进入‘运行时’>‘更改运行时类型’>‘硬件加速器’，选择‘GPU’或‘TPU’。您可以通过以下方式检查 GPU 是否已启用

import tensorflow as tf
device_name = tf.test.gpu_device_name()
if device_name != '/device:GPU:0':
  raise SystemError('GPU device not found')

如果 GPU 未启用，将会引发错误。请注意，您最多只能连续运行 12 小时的会话，并且环境不会跨会话持续存在。

运行单元

SHIFT + ENTER

执行 Bash 命令

只需在前面加一个!，例如:

!ls '/content/gdrive/My Drive/Colab Notebooks/'

让我们检查他们正在使用的操作系统、处理器和 RAM 的信息:

!cat /proc/version
!cat /proc/cpuinfo
!cat /proc/meminfo

Linux，不出意外。

文件

访问 Google Drive 上的文件

使用以下脚本:

from google.colab import drive
drive.mount('/content/gdrive')

然后，您将被要求登录您的谷歌帐户，并复制一个授权码。 点击链接，复制代码，粘贴代码。

Go to this URL in a browser: [https://accounts.google.com/signin/oauth/.](https://accounts.google.com/signin/oauth/identifier?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&as=kh_zwwnAjZxRR9c036hjvA&nosignup=1&approval_state=!ChRkUmNrRGNkbHRZc3YwMjVPZU9ydRIfQTNkNU9vUnBieTBSY0t0V0xtY192ZHJvOHJ0aWh4WQ%E2%88%99APNbktkAAAAAXEiHtWgCVch04PQ_PvopPgfrZKdEK4lI&oauthgdpr=1&oauthriskyscope=1&xsrfsig=ChkAeAh8T59BFeu89K-KwgpUkeRD7fzyWfJYEg5hcHByb3ZhbF9zdGF0ZRILZGVzdGluYXRpb24SBXNvYWN1Eg9vYXV0aHJpc2t5c2NvcGU&flowName=GeneralOAuthFlow)..
Enter your authorization code:
 ·········· 
Mounted at /content/gdrive

上传文件

你可以简单地将文件手动上传到你的 Google Drive，并使用上面的代码访问它们。或者，您可以使用以下代码:

from google.colab import files
uploaded = files.upload()

运行可执行文件

将可执行文件复制到/usr/local/bin，给自己执行的权限。

!cp /content/gdrive/My\ Drive/Colab\ Notebooks/<FILE> /usr/local/bin
!chmod 755 /usr/local/bin/<FILE>

图书馆

安装库

在 bash 命令中使用pip:

!pip install <PACKAGE_NAME>

或者conda:

!wget -c [https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh](https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh)
!chmod +x Anaconda3-5.1.0-Linux-x86_64.sh
!bash ./Anaconda3-5.1.0-Linux-x86_64.sh -b -f -p /usr/local
!conda install -q -y --prefix /usr/local -c conda-forge <PACKAGE_NAME>import sys
sys.path.append('/usr/local/lib/python3.6/site-packages/')

机器学习

张量板

使用ngrok:

# Run Tensorboard in the background
LOGDIR = '/tmp/log'
get_ipython().system_raw(
    'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'
    .format(LOGDIR)
)# Use ngrok to tunnel traffic to localhost
! wget [https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip](https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip)
! unzip ngrok-stable-linux-amd64.zip
get_ipython().system_raw('./ngrok http 6006 &')# Retrieve public url
! curl -s [http://localhost:4040/api/tunnels](http://localhost:4040/api/tunnels) | python3 -c \
    "import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"

你会得到一个类似这样的超链接:

[https://d5b842b9.ngrok.io](https://d5b842b9.ngrok.io/)

您可以通过链接访问您的 Tensorboard！

我的许多项目都是使用 Google Colab 开发的。查看以下文章了解更多信息。

[## 我希望我能早点知道的 5 个 Python 特性

超越 lambda、map 和 filter 的 Python 技巧

towardsdatascience.com](/5-python-features-i-wish-i-had-known-earlier-bc16e4a13bf4) [## 使用交互式地图和动画可视化伦敦的自行车移动性

探索 Python 中的数据可视化工具

towardsdatascience.com](/visualizing-bike-mobility-in-london-using-interactive-maps-for-absolute-beginners-3b9f55ccb59) [## 绝对初学者使用 XArray 处理 NetCDF 文件

探索 Python 中与气候相关的数据操作工具

towardsdatascience.com](/handling-netcdf-files-using-xarray-for-absolute-beginners-111a8ab4463f)

感谢您的阅读！

原载于我的博客edenau . github . io。

Google Colab:类固醇上的 Jupyter 实验室(完美的深度学习)

原文：https://towardsdatascience.com/google-colab-jupyter-lab-on-steroids-perfect-for-deep-learning-cdddc174d77a?source=collection_archive---------13-----------------------

加上可爱的动画柯基犬和猫在你的笔记本上

Corgis and Cats on Google Colab

躲在付费墙后面？点击此处阅读带我朋友链接的文章。

我正在做一个深度学习项目，需要在几周内完成。不幸的是，我可怜的 MacBook 很难处理我所有的项目数据和我在 Jupyter 实验室生成的复杂模型，这延误了我的整个项目。

Google Colaboratory，更广为人知的名字是 Google Colab ，是一个免费的“类似于 Jupyter 实验室”的环境，你猜对了，是由 Google 提供支持的。而且它有很多优点，会让你的下一个机器学习项目更快。

自从我将我的项目迁移到 Google Drive + Google Colab 环境中，我一直在加快速度。Google Colab 提供了一个免费的特斯拉 K80 GPU 在云上运行。这是我的新小秘密，我将与你分享。

优势

注意:如果你不关心所有的功能优势，你想知道的只是如何让柯基犬和猫出现，请转到选择的末尾。

它使用 Python 2 和 3 执行所有 Jupyter Notebook 执行的任务和代码。
它是代码的谷歌文档。不同的团队成员可以实时共享和编辑笔记本，添加评论，查看版本历史，并返回到以前的版本，就像在谷歌文档中一样。
不再有蟒蛇。它完全基于云，不需要任何主要设置或安装。如果您想要使用的库不在 Colab 上，就像往常一样 pip 它。安装在虚拟环境中。
选择硬件加速器。在 GPU 或 TPU 上根据您的需要运行您的笔记本。
代码片段集成:一个预收费的代码库，可以尝试几种特定的解决方案。(如相机激活、可视化、集成等。).这在学习机器学习的时候特别好。
不再疯狂滚动。目录始终可见。
个性化。添加您自己的快捷键、夜间/灯光/自适应模式和字体。
游乐场模式。点击两下，你就可以打开一个不会被保存的新笔记本，并在不影响原有代码的情况下尝试不同的代码选项。

柯基犬和猫模式。换成这个模式，全速编码，看看会发生什么。

*fast speed

集成

表格。类似于 Google Forms，这个功能相当新。它支持带类型检查的多种类型的字段，包括滑块、日期选择器、输入字段和允许输入的下拉菜单，就在笔记本中。
栈溢出。只需突出显示您有问题的代码，然后将其堆叠起来。
GitHub 上的代码要点(你的代码截图)。
GitHub。不再有 git 添加、提交、推送…

不足之处

一个大的:不离线运行。
当虚拟机关闭时，没有从 Google Drive 装载就导入到环境中的数据集将会丢失。

你怎么看待 Google Colab？如果你愿意尝试，请在评论中告诉我！

Google Colab——您在云上的 Python 工作空间

原文：https://towardsdatascience.com/google-colab-your-python-workspace-on-cloud-c3aed424de0d?source=collection_archive---------16-----------------------

了解 Google Colab

Photo by Kaitlyn Baker on Unsplash

今天我换了一个新的机器来开发。虽然有一个学习曲线来适应新机器，但我仍然可以继续我的项目，并通过 Google Colab 继续我的在线课程。这实际上就像登录我的谷歌账户一样简单，我已经准备好了。

因此，我决定分享我的见解，为什么我觉得 Google Colab 如此有用，以及帮助我更有效地使用它的命令。

Google Colab 是什么？

Google Colab introductory notebook

Google Colab，也称为 Colaboratory，是一个由 Google 提供和支持的 Jupyter 环境，可以选择与 CPU、GPU 甚至 TPU 一起工作。它就像任何其他的 Jupyter 笔记本一样，我们可以用 Python 编写代码，并以 markdown 的形式编写描述，以及所有其他的 Jupyter 功能等等。

顶部包括保存笔记本、将笔记本共享到 GitHub 库、更改运行时环境、运行单元等所有控件。底部分为左面板，包括目录和文件，右边是完整的功能笔记本。

为什么选择 Google Colab？

Photo by freestocks.org on Unsplash

虽然有很多原因可以解释为什么人们更喜欢使用 Google Colab 这样的服务来工作，但以下是它对我有用的原因:

GitHub 集成:虽然笔记本保存在我们的 Google drive 中，但我更愿意分享一些笔记本，作为他们自己的 GitHub 存储库的一部分。Google Colab 允许在链接我们的 GitHub 配置文件后直接共享到任何存储库。
零设置时间:要开始使用 Google Colab，你只需进入https://colab.research.google.com/并从弹出菜单中选择NEW PYTHON 3 NOTEBOOK。
平台独立性:由于 Jupyter 笔记本可以直接从浏览器访问，我们可以使用任何机器，Mac、Windows、Linux 等。它会完全一样的工作。
免费资源可用性:深度学习的训练模型需要大量的能力，因此，并非所有的笔记本电脑和台式机都配备了这种能力。Google Colab 提供对 GPU 的免费访问，我们可以利用它来完成深度学习任务。

探索 Google Colab

现在我们已经了解了 Google Colab 是什么，以及它为每个人带来了多少好处，让我们来探索几个关键的重要方面。这些确实帮助我提高了工作效率，让我的工作更容易理解。

快速键盘快捷键

在细胞间移动很容易。你只需要使用键盘上的UP和DOWN箭头键。要开始编辑单元格，只需按下Enter。要退出编辑单元格，只需按下Esc。

已经有一些预定义的键盘快捷键可供您使用。一些最基本的包括运行单元格的Shift + Enter、Ctrl + M Y将单元格转换为代码单元格、Ctrl + M M将单元格转换为文本单元格等等。你可以通过Tools > Keyboard shortcuts...获得完整的列表，你可以根据自己的喜好定制和更改快捷方式。

除了预定义的快捷方式，我还根据自己的需要定制了另外两个快捷方式。由于处理单元格的快捷方式以Ctrl + M的组合开始，我决定在配置自己的快捷方式时保持不变。为了创建新的代码单元，我创建了快捷键Ctrl + M C。为了创建新的文本单元格，我创建了快捷键Ctrl + M T。

存在类似的快捷方式，也可以使用Command Key为 Mac 进行配置。

加载数据集

Google Colab 允许我们通过多种方式访问我们的数据集。

上传数据集 在左侧面板，选择Files标题。选择选项Upload并选择数据集文件。

dataset.csv uploaded and being read through pandas

但是，这些文件在运行时刷新时会被删除，所以如果运行时由于某种原因没有完成任务就崩溃了，您将不得不再次上传它们。

从 Google drive 加载数据集 其次，我们可以导入已经保存在 Google drive 中的数据集。这是有益的，因为如果笔记本崩溃，我们不需要再次上传数据集。

要安装 Google drive，我们使用以下代码:

运行这段代码时，会提供一个链接，允许我们登录到我们的帐户，并提供一个授权令牌，需要在提供的空间中输入该令牌才能工作。这使我们能够使用/content/drive中的My Drive文件夹访问 Google drive 的内容。

Loading dataset from Google drive

保存到 GitHub 存储库

对我来说，最吸引人和最有用的特性之一是 Google Colab 和 GitHub 之间的集成。我更喜欢在 Jupyter 笔记本上工作，并将我的工作保存到我的帐户中的特定 GitHub 存储库中。Google Colab 使整个过程变得简单易用。

从File菜单中，我们选择Save a copy in GitHub...选项。它会打开一个链接我们的 GitHub 帐户的屏幕，这是一个一次性的过程，之后，我们会看到另一个弹出窗口。我们可以选择存储库、分支、文件名和提交消息。就这么简单！！

Save notebook to GitHub

我们还可以在 GitHub 资源库中添加一个指向该笔记本的链接，这样任何人在 GitHub 上查看该笔记本都可以快速进入工作状态。

Open in Colab option in the notebook saved via Google Colab

更改运行时类型

如果你曾经处理过深度学习模型，你就会理解 GPU 在提高训练速度方面可以发挥的作用。Google Colab 提供了为我们添加 GPU/TPU 的选项，完全免费。这使得我们能够以更高的速度训练我们的深度学习模型。

从Runtime菜单中，选择Change runtime type。在硬件加速器下，我们可以选择None继续使用 CPU，或者根据需要将运行时间改为GPU或TPU。

Select between various hardware acceleration options

单击SAVE后，运行时将会刷新，您会注意到在右上角会出现CONNECTING，表示我们现在正在激活新的运行时类型。

共享 Colab 笔记本

另一个重要特征是与世界分享我们的工作。Google Colab 右上角的共享选项允许我们选择一个电子邮件地址列表来共享笔记本，或者只是获得一个可共享的链接。

Sharing the notebook

结论

Google Colab 是一个很好的方式来跟上你的工作，并随时随地访问它。它有许多功能，如创建简单的快捷方式，共享和保存笔记本等。

探索 GitHub API

towardsdatascience.com](/github-user-insights-using-github-api-data-collection-and-analysis-5b7dca1ab214) [## 在 Kaggle 上使用 CNN 进行深度学习以识别疟疾细胞

医学领域的深度学习

towardsdatascience.com](/deep-learning-to-identify-malaria-cells-using-cnn-on-kaggle-b9a987f55ea5) [## 让我们使用 LDA 构建一个文章推荐器

基于搜索查询推荐文章

towardsdatascience.com](/lets-build-an-article-recommender-using-lda-f22d71b7143e) [## 使用 Flask、Flask RESTPlus 和 Swagger UI 处理 API

Flask 和 Flask-RESTPlus 简介

towardsdatascience.com](/working-with-apis-using-flask-flask-restplus-and-swagger-ui-7cf447deda7f)

请分享你的想法、观点和建议。我很乐意收到你的来信。

Google Coral Edge TPU 主板与 NVIDIA Jetson Nano 开发主板—硬件比较

原文：https://towardsdatascience.com/google-coral-edge-tpu-board-vs-nvidia-jetson-nano-dev-board-hardware-comparison-31660a8bda88?source=collection_archive---------2-----------------------

NVidia 和 Google 最近都发布了针对 EdgeAI 的开发板，并以一定的价格吸引了开发者、制造商和爱好者。两个开发板主要用于推理，但支持有限的迁移学习再培训。边缘 TPU 使用重量印记技术支持转移学习训练。这两个开发套件都包含一个 SOM(模块上系统),连接到一个开发板，开发板上有各种连接器，如 USB、以太网、microSD 插槽等。这是两个开发套件的硬件比较，这两个套件可以用作单板计算机(SBC)而不是 Edge TPUu 盘。如果你不想阅读整篇文章，在我看来，Coral Edge 开发套件的性价比略高，因为它包括 Wifi 和蓝牙等基本外设，但 Jetson Nano 具有更好的软件支持(INT8 和 FP16 推理)。

珊瑚缘 TPU 发展局

整个套件的尺寸为-88 毫米 x 60 毫米 x 22 毫米，而 SOM 的尺寸仅为-48 毫米 x 40 毫米 x 5 毫米。因此人们还可以设计自己不同外形的基板，并连接到 SOM。该板只带有一个 u-boot 引导加载程序，以后人们可以像 Mendel linux 一样加载一个映像。几个例子/教程这里。此处提供了电路板的预培训模型。

Coral SOM 上的恩智浦 iMXM 处理器还配有 Vivante GC7000 lite 图形 GPU，它能用于图形以外的其他用途吗？详细规格—https://coral.withgoogle.com/docs/dev-board/datasheet/

在这里购买—https://coral.withgoogle.com/products/dev-board

Image from — https://coral.withgoogle.com/products/dev-board/

Edge TPU SOM 现在售价 114.99 美元，只有 Edge TPU(不含恩智浦处理器)作为迷你 PCIe 、 M.2 A+E 键和 M.2 B+M 键出售，每个售价 34.99 美元。

Edge TPU SOM — Source

Edge TPU Mini PCIe card — Source

不久，Edge TPU 将作为可焊接在板上的 MCM(多芯片模块)上市，MCM 包含 Edge TPU 芯片和用于电源管理的 PMIC(电源管理集成电路)。Edge TPU 可以以 2 TOPS/watt 执行 4 TOPS。

Edge TPU MCM — Source

NVIDIA Jetson Nano 开发套件

像这里的珊瑚板一样，也有一个 SOM 连接到基板上。Jetson SOM 稍大一些，为 69.6 毫米 x 45 毫米。该板采用基于 Ubuntu 18.04 的环境。根据 NVidia 文档 Nano 可以做到 472 GFLOPs(每秒千兆次浮点运算)并支持 5W 和 10W 功耗模式。

详细规格—https://www . NVIDIA . com/en-us/autonomous-machines/embedded-systems/jetson-nano/

在此购买—https://www . NVIDIA . com/en-us/autonomous-machines/embedded-systems/jetson-nano/

NVidia Jetson Dev kit — https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-nano/

Jetson SOM — https://blog.hackster.io/introducing-the-nvidia-jetson-nano-aaa9738ef3ff

比较

下面是两种主板硬件特性的比较

Coral Edge 主板未来将提供 2GB 和 4GB RAM 选项。

表演

Nvidia 提供了 Jetson Nano 与其他 SBC 的一些性能比较，如 Raspberry Pi 3、Google Coral Edge TPU 板—https://devblogs.nvidia.com/jetson-nano-ai-computing/

Data from — https://devblogs.nvidia.com/jetson-nano-ai-computing/

在上述结果中，Jetson Nano 使用了 FP16 precision。

上面给出的 Coral Edge TPU 板的结果很少，因为它不能运行未使用训练后量化或量化感知训练为 Edge TPU 编译的预训练模型。谷歌提供了一些相对于桌面 CPU 的对比(64 位英特尔至强黄金 6154 CPU @ 3.00GHz) 性能以及使用嵌入式 CPU 时的四核 Cortex-A53 @ 1.5GHz)

Edge TPU Benchmark — Source

更多结果在这里—https://github.com/jolibrain/dd_performances

还有https://www.phoronix.com/scan.php?page=article&item = NVIDIA-jetson-nano&num = 3

结论

在我看来，珊瑚边 TPU 开发局更好，因为以下原因—

1.售价 149 美元的 Coral dev board 比 Jetson Nano(99 美元)略贵，但它支持 wifi 和蓝牙，而 Jetson Nano 则需要购买外部 Wifi 加密狗。

2.此外，coral 板上的恩智浦 iMX8 SOC 包括一个视频处理单元和一个 Vivante GC700 lite GPU，可用于传统的图像和视频处理。它还有一个 Cortex-M4F 低功耗微控制器，可用于与温度传感器、环境光传感器等其他传感器通信。更多传感器点击此处—http://light sensors . blogspot . com/2014/09/collection-of-variable-sensors . html

Jetson 也有视频编码器和解码器单元。此外，Jetson Nano 对其他深度学习框架有更好的支持，如 Pytorch 、MXNet。它还支持 NVidia TensorRT 加速器库进行 FP16 推理和 INT8 推理。Edge TPU 板仅支持 8 位量化 Tensorflow lite 模型，您必须使用量化感知训练。

我对边缘应用的深度学习感兴趣，我在 NLP ，计算机视觉和可扩展系统方面有经验，如果你正在招聘，你可以在这里联系我。

附加有用链接

[## 如何自制深度学习加速器芯片！

目前，全世界有 100 多家公司在制造 ASIC(专用集成电路)

towardsdatascience.com](/how-to-make-your-own-deep-learning-accelerator-chip-1ff69b78ece4) [## 机器学习边缘设备:基准报告| Tryolabs 博客

人类正在产生和收集比以往更多的数据。我们的口袋里有便于创作的设备…

tryolabs.com](https://tryolabs.com/blog/machine-learning-on-edge-devices-benchmark-report/) [## 边缘 TPU:谷歌珊瑚 USB 加速器的实践

什么是 Edge AI，为什么它很重要？

heartbeat.fritz.ai](https://heartbeat.fritz.ai/edge-tpu-google-coral-usb-accelerator-cf0d79c7ec56) [## 使用 Coral Dev Board、Edge TPU 和 TensorFlow Lite 构建离线工作的人工智能

由 TensorFlow Lite 的开发者倡导者 Daniel Situnayake (@dansitu)发布。

medium.com](https://medium.com/tensorflow/build-ai-that-works-offline-with-coral-dev-board-edge-tpu-and-tensorflow-lite-7074a9fd0172) [## Google Coral Edge TPU vs NVIDIA Jetson Nano:深入了解 EdgeAI 性能

新的谷歌珊瑚边缘 TPU 和英伟达杰特森纳米之间的快速和肮脏的比较，稍微深入到…

blog.usejournal.com](https://blog.usejournal.com/google-coral-edge-tpu-vs-nvidia-jetson-nano-a-quick-deep-dive-into-edgeai-performance-bc7860b8d87a)

谷歌珊瑚 USB 加速器游戏攻略

原文：https://towardsdatascience.com/google-coral-usb-accelerator-introduction-18989a962d25?source=collection_archive---------8-----------------------

在小型设备中加速机器学习模型

Coral USB Accelerator

去年在谷歌 Next T1 大会上，谷歌宣布他们正在围绕他们在 T4 的 Edge TPUs T5 在 T2 制造两款新的硬件产品 T3。他们的目的是允许边缘设备，如 Raspberry Pi 或其他微控制器，通过允许它们在自己的硬件上本地运行预训练的 Tensorflow Lite 模型的推理，来利用人工智能应用的能力，如图像分类和对象检测。这不仅比拥有服务于机器学习请求的云服务器更安全，而且还可以大大减少延迟。

珊瑚 USB 加速器

Coral USB 加速器的尺寸为 65x30x8mm 毫米，比其竞争对手英特尔 Movidius 神经计算棒略小。起初，这似乎不是什么大问题，但如果你考虑到英特尔棒往往会阻塞附近的 USB 端口，使其难以使用外设，这就非常重要了。
Coral USB 加速器售价为 60€(之前为 75€)，可通过网站订购，包括:

鼠标
参见
亚马逊

在硬件方面，它包含一个边缘张量处理单元(TPU)，以相对较低的功耗为深度学习模型提供快速推理。

Figure 1: Box contains the USB Accelerator, USB Type-C to USB 3 Adapter and a simple getting started instruction

USB 加速器适用于以下操作系统之一:

Linux Debian 10 或其衍生版本(如 Ubuntu 18.04 或 Raspbian)
安装了 MacPorts 或 Homebrew 的 macOS
Windows 10

当通过 USB 3.0 连接时，它工作得最好，即使它也可以与 USB 2.0 一起使用，因此也可以与 Raspberry Pi 3 等不提供任何 USB 3 端口的微控制器一起使用。

设置

珊瑚 USB 加速器的设置是没有痛苦的。官方网站上的入门说明在我的树莓派和 PC 上都非常好用，几分钟后就可以运行了。

1:安装边缘 TPU 运行时

Edge TPU 运行时为 Edge TPU 提供核心编程接口。

Linux

首先，将 Debian 软件包仓库添加到您的系统中:

echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update

然后，安装边缘 TPU 运行时:

sudo apt-get install libedgetpu1-std

以上命令安装默认的 Edge TPU 运行时，它以降低的时钟频率运行。如果您想以最大时钟频率运行 Coral USB 加速器，请运行以下命令:

sudo apt-get install libedgetpu1-max

只有当你真的需要最大功率时才建议这样做，因为当你在最大模式下运行时，USB 加速器的金属摸起来会变得非常热。

现在，使用提供的 USB 3.0 电缆将 USB 加速器连接到您的计算机。如果您在安装时已经插上了它，请将其移除并重新插上，以便新安装的 udev 规则可以生效。

macOS

首先，下载并解压缩 Edge TPU 运行时:

curl -O https://dl.google.com/coral/edgetpu_api/edgetpu_runtime_20210119.zip

unzip edgetpu_runtime_20210119.zip

然后安装边缘 TPU 运行时:

cd edgetpu_runtime

sudo bash install.sh

安装脚本将询问您是否要启用最大工作频率。如上所述，如果真的有必要，我建议只使用最大工作频率。

视窗

首先，确保你有最新版本的微软 Visual C++ 2019 可再发行版。

然后，下载edge TPU _ runtime _ 2021 01 19 . zip文件，解压，双击 install.bat 文件。

安装脚本将询问您是否要启用最大工作频率。如上所述，如果真的有必要，我建议只使用最大工作频率。

2:安装 PyCoral 库

PyCoral 是一个构建在 TensorFlow Lite 库之上的 Python 库，旨在加快开发速度并为 Edge TPU 提供额外的功能。

要安装 PyCoral 库，请使用以下命令。

Linux

sudo apt-get install python3-pycoral

MacOS 还是 Windows

pip3 install --extra-index-url https://google-coral.github.io/py-repo/ pycoral

使用 PyCoral 运行模型

PyCoral 构建在 Tensorflow Lite 之上，允许您在 Edge TPU 上运行 Tensorflow Lite 模型，而无需编写大量样板文件。

您可以在 google-coral/pycoral 知识库中找到使用 PyCoral 进行图像分类、对象检测、语义分割和其他应用的示例。

要运行示例影像分类脚本，请遵循以下步骤:

1.从 GitHub 下载示例代码:

mkdir coral && cd coral

git clone https://github.com/google-coral/pycoral.git

cd pycoral

2.下载鸟类分类器模型、标签文件和一张鸟类照片:

bash examples/install_requirements.sh classify_image.py

3.对鸟照片运行图像分类器:

python3 examples/classify_image.py \
--model test_data/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite \
--labels test_data/inat_bird_labels.txt \
--input test_data/parrot.jpg

Figure 2: Parrot (Source)

使用 Tensorflow Lite API 运行模型

您也可以在没有 PyCoral 库的情况下运行 Tensorflow Lite 模型。这提供了更多的灵活性，因为它允许您在有和没有边缘 TPU 的情况下运行相同的代码，但它也要求您编写更多的代码来使其工作。

为了在 Edge TPU 上运行 Tensorflow Lite 模型，创建一个 tflite 解释器，将 Edge TPU 运行时库作为委托:

import tflite_runtime.interpreter as tflite
interpreter = tflite.Interpreter(model_path,
  experimental_delegates=[tflite.load_delegate('libedgetpu.so.1')])

你可以在 google-coral/tflite 知识库中找到使用它进行图像分类和物体检测的例子。

通过以下步骤运行图像分类示例:

1.从 Github 下载示例代码:

mkdir coral && cd coralgit clone [https://github.com/google-coral/tflite.git](https://github.com/google-coral/tflite.git)

2.下载鸟类分类器模型、标签文件和一张鸟类照片:

cd tflite/python/examples/classificationbash install_requirements.sh

3.用鸟的照片运行图像分类器:

python3 classify_image.py \
--model models/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite \
--labels models/inat_bird_labels.txt \
--input images/parrot.jpg

Figure 3: Parrot (Source)

您应该会看到这样的结果:

INFO: Initialized TensorFlow Lite runtime.
----INFERENCE TIME----
Note: The first inference on Edge TPU is slow because it includes loading the model into Edge TPU memory.
11.8ms
3.0ms
2.8ms
2.9ms
2.9ms
-------RESULTS--------
Ara macao (Scarlet Macaw): 0.76562

您可以对对象检测示例执行相同的操作:

cd tflite/python/examples/detectionbash install_requirements.shpython3 detect_image.py \
  --model models/mobilenet_ssd_v2_coco_quant_postprocess_edgetpu.tflite \
  --labels models/coco_labels.txt \
  --input images/grace_hopper.bmp \
  --output images/grace_hopper_processed.bmp

Figure 4: Grace Hopper (Source)

您应该会看到这样的结果:

INFO: Initialized TensorFlow Lite runtime.
----INFERENCE TIME----
Note: The first inference is slow because it includes loading the model into Edge TPU memory.
33.92 ms
19.71 ms
19.91 ms
19.91 ms
19.90 ms
-------RESULTS--------
tie
  id:     31
  score:  0.83984375
  bbox:   BBox(xmin=228, ymin=421, xmax=293, ymax=545)
person
  id:     0
  score:  0.83984375
  bbox:   BBox(xmin=2, ymin=5, xmax=513, ymax=596)

使用边缘 TPU Python API 运行模型

Edge TPU API(Edge TPU 模块)提供了执行图像分类和对象检测的简单 API。它构建在 TensorFlow Lite C++ API 之上，并抽象出处理输入张量和输出张量所需的大量代码。Edge TPU API 还包括通过权重印记或反向传播来执行设备上传输学习的 API。— 谷歌珊瑚文档

首先，你必须安装边缘 TPU Python 库。在 Mac 或 Windows 上，请遵循此处的说明。如果您使用的是 Linux，可以用 Debian 包安装这个库(示例保存在/usr/share/edgetpu/examples):

sudo apt-get updatesudo apt-get install python3-edgetpu

您可以用与 Tensorflow Lite 示例相同的方式运行这些示例，但是它们使用的是 Edge TPU 库，而不是 Tensorflow Lite。

构建您自己的模型

尽管谷歌提供了许多可以与 USB 加速器一起使用的预编译模型，你可能想要运行你自己的定制模型。

为此，您有多种选择。您可以使用一种称为迁移学习的技术，重新训练已经与 Edge TPU 兼容的现有模型，而不是从头开始构建您的模型。要了解更多细节，请查看重新训练图像分类和物体检测模型的官方教程。

如果你喜欢从头开始训练一个模型，你当然可以这样做，但是你需要注意在 USB 加速器上部署你的模型时会有一些限制。

首先，你需要对你的模型进行量化。这意味着将所有 32 位浮点数(如权重和激活输出)转换为最接近的 8 位定点数。

为了与边缘 TPU 兼容，必须使用量化感知训练(推荐)或全整数训练后量化。有关更多信息，请查看文档中的量化部分。

量化后，你需要将你的模型从 Tensorflow 转换到 Tensorflow Lite，然后使用 Edge TPU 编译器进行编译。

Figure 5: Building custom model process (Source)

结论

谷歌 Coral USB 加速器是一款出色的硬件，它允许边缘设备，如 Raspberry Pi 或其他微型计算机，利用人工智能应用的力量。它拥有优秀的文档，包含从安装和演示应用到构建你自己的模型的所有内容，以及详细的 Python API 文档。

这就是这篇文章的全部内容。感谢阅读。如果你对我接下来应该报道的内容有任何反馈、建议或想法，请随时在社交媒体上发表评论或联系我。

Google Drive+Google Colab+GitHub；不要只是读，要做！

原文：https://towardsdatascience.com/google-drive-google-colab-github-dont-just-read-do-it-5554d5824228?source=collection_archive---------1-----------------------

GitHub、Google Colab 和 Google Drive 如何协同工作；如何处理自定义文件，并将 Jupyter 笔记本修改推送到 GitHub Repo。

Interaction Between The Three Components

我最近被贝塔斯曼理工学院奖学金挑战课程第一期录取了——人工智能轨道纳米学位项目。在课程中，Jupyter 笔记本练习由 Udacity 在 GitHub repo 中提供。我一直在本地使用 Anaconda Jupyter 和 Jupyter lab 来运行这些练习，但是我注意到在这些课程的后面有更多的任务需要更广泛的计算，并且运行时间越来越长。对于我的旧笔记本电脑来说，CPU 的工作量太大了，所以我必须找到其他替代品。

Google Colab 已经在 Slack 社区中提出。它有一个完全在云上运行的 Jupyter 笔记本电脑的预设置环境(我的笔记本电脑非常感谢🐌).最重要的是，它提供了“免费”的 GPU(图形处理单元)。

本文的目标是了解:

如何将 Github repo 集成到 Google Colab(提供步骤)
如何处理自定义 Python 文件
如何将您在 Jupyter 笔记本上的更改保存到不同的分支，并保持主分支干净。

奥列格·żero 的文章和娜塔莉亚斯韦尔奇科娃的 G itHub repo 提供了非常好的指导，帮助我开始设置。然而，对我来说，我在实现过程中发现了几个挑战。我花了几个小时寻找额外的资源来解决我遇到的这些问题，但是没有直接的指南来实现我想要的，所以我希望这篇文章可以帮助面临相同问题的其他人。

开箱即用的解决方案 Google Colab 和 GitHub

在这个笔记本中，有几种直接从 GitHub 加载/浏览笔记本文件的方式。您可以在您的私有存储库(需要 GitHub 认证)或公共存储库中访问您的笔记本。

Colab-Github-demo Jupyter notebook

如果你点击http://colab.research.google.com/github，它会指引你一个弹出窗口，你可以通过 GitHub 网址、组织或用户进行搜索。

在我做出更改后，我可以将这些文件保存回 GitHub 分支。很简单，对吧？没那么快！如果您的笔记本没有任何想要导入的自定义文件，这种方法将会很有效。所以，我需要找到另一种解决方案。

先从 Google Colab + Google Drive + GitHub 开始吧

在我们详细讨论之前，让我们来看看那些组件(Google Drive、Google Colab、GitHub)的每个角色以及它们之间的交互。

Google Colab: 所有的操作都在这里调整大小。它被用作 shell 来运行 bash 命令和 git 命令。当然，我们使用 Jupyter notebook 运行我们的 Udacity 笔记本。
Google Drive: 当我们使用 Google Colab 时，我们的工作被临时存储在一个虚拟机中大约 8 到 12 个小时。所以这并不理想，因为我们的处理任务可能会持续几天、几个月或几年，这取决于每个项目。解决方案之一是将你的培训存储在云存储托管中。众所周知，Google Drive 是谷歌提供的云存储。它提供免费的 15 GB 存储空间，并且很容易与谷歌 Colab 集成。在这种情况下，我们使用这个位置来永久存储我们工作的克隆 GitHub repo。
GitHub: 一个用于版本控制和协作的代码托管平台。使用版本控制和分支策略是一个很好的实践。我分叉了 Udacity 深度学习-v2-pytoch 库。

1.将 Google Drive 安装到 Google Colab

在 Google Colab 中，我们将创建一个笔记本来执行我们的命令。如果您已登录，一旦您创建了笔记本，您的文件将存储在名为 Colab Notebooks 的文件夹中。

Colab Notebooks Folder in Google Drive

我将奥列格·żero 的文章中提供的部分代码划分到笔记本的不同单元格中，以便更好地理解流程。要将 Google Drive 安装到 Colab，我们可以使用:

Mount Google Drive Gist

感谢 Google 提供的库，这非常简单。按照说明使用 Google Drive 进行身份验证。

Running commands to mount Google Drive

Result after authenticated and mounted successfully

如果看到“挂载在/content/drive”，说明 Google Drive 挂载成功。🎉

如果您熟悉终端命令，您可以仔细检查位置和目录:

请参考我为每个命令添加的每个注释。注意上面最后一个命令的输出。我们有“Colab 笔记本”和“MyDrive”文件夹。这些文件夹存储在我的 Google Drive 的根目录下。

2.将 GitHub 存储库克隆到 Google Drive

现在我们准备克隆我们的 GitHub repository 项目，并通过 Google Colab 将其存储在 Google Drive 中。我将克隆分叉库deep-learning-v2-py torch。

在我的例子中，我将把克隆的 GitHub 存储库存储在这个目录中:"/content/Drive/My Drive/uda city/deep-learning-v2-py torch "

Google Drive Directories

我们需要定义一些将在脚本中使用的变量:

我的谷歌驱动路径
GIT _ 用户名
GIT_TOKEN (GitHub 访问令牌)
GIT_REPOSITORY

如何生成 GitHub 访问令牌:

进入右上角的用户资料→点击设置→然后选择开发者设置。

GitHub personal access tokens

select scope for your access token

在这种情况下，回购范围就足够了。要了解有关定义个人令牌访问的范围的更多信息:https://developer . github . com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/

注意:不要将你的访问令牌公开

在笔记本的新单元格中，我们将设置所需的信息:

https://gist.github.com/vsay01/12ff13b05d768dc2d4f4646fbf41cd33

设置完所需的信息后，让我们执行克隆。

我们有两个选择:

选项 1

最后，我们应该看到 GitHub 存储库的内容保存在我们指定的目录中。注意我们有 folder .git，它是用来表示这个文件夹是 git 文件夹。

请记住，我们希望在开发分支中进行更改，而不是在主分支中。所以，我们来验证几件事。如果您不熟悉 git 或需要更新，这里有一个很好的资源。

在输出中！git 分支，有两个分支，开发和掌握。“*”表示我们正在进行的当前分支。默认情况下，您将从主分支开始，除非您克隆特定分支。您可以使用以下命令签出开发分支:

选项 2

如果你想将所有文件/文件夹从你在 google drive 中克隆的存储库中复制到 Google Colab 本地运行时，那么你可以遵循奥列格·żero的文章。

注意: data/是一个包含我想排除的大量数据的文件夹。请随意将其更改为您想要排除的不同文件夹路径/名称。

正如奥列格·żero 的文章中所解释的:

上面的代码片段在*/content/drive*安装 Google Drive 并创建我们项目的目录。然后，它从 Github 中取出所有文件，并将它们复制到那个目录中。最后，它收集属于驱动器目录的所有内容，并将其复制到我们的本地运行时。

这个解决方案的一个好处是，如果多次执行，它不会崩溃。无论何时执行，它只会更新新的东西。此外，使用*rsync*，我们可以选择排除一些内容，这可能需要很长时间来复制(...数据？).

3。修改/处理您的笔记本

到目前为止，我们做了以下工作:

将 Google Drive 安装到 Google Colab
将 GitHub 存储库克隆到 Google Drive

这是有趣的部分😃。现在，我们准备在笔记本上进行更改和工作

4。处理自定义文件问题

第 2 部分 PyTorch 中的神经网络(练习)。ipynb notebook，我们需要导入一个自定义文件 helper.py，来访问 helper 函数。

可以看到，helper . view _ classify(img . view(1，28，28)，ps)正在工作。

5.将更改保存到 GitHub

如果您选择上面的选项 2，那么请按照 奥列格żero的条 一节的“保存，收工”来保存您的更改。

对于选项 1，现在您已经完成了更改，是时候将更改保存并推送到您想要的分支中的 GitHub 存储库中了。这是 git 备忘单。

我建议在不同的单元中运行这些命令，以确保所有的文件更改都正确地添加到提交中。

上面的命令将添加所有文件；如果只想添加修改过的文件，可以使用:

也请更改提交的注释；用户.电子邮件和用户名

在这里，我可以验证更改是否已成功推送:

我们完成了——我希望你喜欢这篇文章。

我将继续添加我在学习过程中发现的与 Google Colab 相关的任何问题:

问题#1

Google Colab 脚本抛出“OSError:传输端点未连接”

适合我的解决方案:

卸载 Google Drive，然后再次重新装载。
运行时→管理会话并终止笔记本

问题#2

我遇到了这个问题，即使；我已经导入了自定义文件。

适合我的解决方案:

当我将 Google Drive 导入 Google Colab 时；我需要确保当前路径是项目文件夹。

问题#3

错误:装入点不能包含空格。

适合我的解决方案:

避免在路径中使用空格

问题#4

资产文件夹中的图像不会加载到 Jupyter 笔记本中；

适合我的解决方案:

从图片中获取可共享 google drive 链接。
在这个 URL 中使用来自可共享 google drive 链接的图片 id:https://docs.google.com/uc?id =[图像 id] [1]

例如:

这是猫狗图片的分享链接:https://drive.google.com/open?id = 1 hfswhk 0 uiwleeiuz _ bwb 1 dxnoqrapzo-；所以我们使用 id 并与 URL [1]连接起来；我们有:

https://docs.google.com/uc?id = 1 hfswhk 0 uiwleeiuz _ bwb 1 dxnoqrapzo-

问题#5

来自 Jupyter 代码的 google drive 中的参考图片。在 custom_filters.ipynb 笔记本中，我们需要引用数据文件夹“data/curved_lane.jpg”中的图像

适合我的解决方案:

导入 google drive
然后你有两个选择:

引用代码中图像的完整路径。比如，“。/Drive/My Drive/My Drive/uda city/deep-learning-v2-py torch/卷积-神经网络/conv-可视化/数据/curved_lane.jpg "
将目录切换到父文件夹并访问数据文件夹。因此，到图像的路径可以缩短为。/data/curved_lane.jpg "

问题#6

我在conv _ visualization . ipynb笔记本中遇到以下错误。

————————————
错误回溯(最近一次调用 last)
<ipython-input-1–9775 b 898 dc2d>在<模块>()
10 bgr _ img = cv2 . im read(img _ path)
11 #转换为灰度【T15COLOR_BGR2GRAY)
13
14 #规格化、重新缩放条目以位于[0，1]内

错误:OpenCV(4 . 1 . 2)/io/OpenCV/modules/imgproc/src/color . CPP:182:错误:(-215:断言失败)！函数“cvtColor”中的 _src.empty()

对我管用的方案:

发生此问题的原因是输入图像的路径不正确或输入图像名称中有特殊字符。在我修正了输入图像路径后，它工作得很好。

谷歌联合学习和人工智能

原文：https://towardsdatascience.com/google-federated-learning-and-ai-64c6e4e4e22f?source=collection_archive---------17-----------------------

Photo by @memorieson35mm

保密性和人工智能

我以前听说过联合学习。然而，最近几天深入半监督学习让我意识到了这个概念及其用法。在这篇文章中，我将给出一个简单的概念解释，而不是深入到广泛的技术细节。由于疏忽管理用户数据，脸书最近被美国联邦贸易委员会罚款 50 亿美元。谷歌同样面临来自欧盟委员会的十亿美元的正式指控。这些公司如何改进？谷歌提出了部分解决方案。

由于对通信技术中的隐私和安全目的的日益关注，很高兴看到 Google 希望通过这个概念来解决这个问题。现在我想进一步探索它，但首先我想分享一幅来自谷歌的关于联合学习的漫画的一部分:

****

谷歌关于联合学习的漫画就这样开始了。我真的建议你查看上一句中链接的完整版本来阅读整个故事。

根据维基百科上机器学习页面的短存根:

联合学习 是一种训练机器学习模型的新方法，它分散了训练过程，允许用户的隐私得到维护，无需将他们的数据发送到中央服务器。这也通过将训练过程分散到许多设备来提高效率。例如，Gboard利用联邦机器学习在用户手机上训练搜索查询预测模型，而无需将单个搜索发回谷歌。

****简而言之:关于在分散的数据上训练一个集中的模型。

那么为什么这很重要呢？

隐私和人工智能

我决定去看看国际隐私组织对人工智能有什么看法。

【隐私国际(PI) 是一家慈善机构，挑战那些想要了解个人、团体和整个社会一切的政府和公司。PI 希望的未来是，人们能够控制他们的数据和他们使用的技术，政府和公司不再能够使用技术来监控、跟踪、分析、描述，并最终操纵和控制我们。但是我们必须为未来而战。

他们的网站上有一个关于人工智能的网页。我将从他们的简短页面中借鉴或复制一些要点(斜体):

重新识别和去匿名 :人工智能应用可用于识别和跟踪不同设备上的个人，无论是在家中、工作场所还是公共场所。
剖析的不透明和保密 :人工智能的一些应用对个人、监管者，甚至系统的设计者本身来说可能是不透明的，因此很难质疑或询问结果。
数据利用 :人们往往无法完全了解自己的设备、网络、平台产生、处理、或分享的数据种类和数量。随着我们将智能和互联设备带入我们的家庭、工作场所、公共空间甚至身体，教育公众了解这种数据利用的需求变得越来越迫切。

在这种情况下，使用人工智能进行侧写，或者跨设备甚至在公共场所跟踪和识别人，这种不对称放大了鸿沟。那么他们提出的解决方案是什么呢？

使人工智能领域和机器学习技术的使用符合尊重、促进和保护国际人权标准的最低要求。
确保人工智能保护个人免受审查现有法律带来的风险并在必要时修订法律，以解决新出现的隐私威胁的影响。

回到谷歌漫画，这是如何在联邦学习中解决的？

****安全聚合是一种交互式加密协议，用于计算屏蔽向量的和，如模型权重。它通过协调成对的参与客户端之间的随机掩码的交换来工作，使得当接收到足够数量的输入时，掩码相互抵消。要了解更多关于安全聚合的信息，请参见保护隐私的机器学习实用安全聚合。

追踪报道的弊端

技术领域的数据科学家、工程师、软件、硬件或销售人员有任何责任吗？是的，所以让我引入医疗事故的概念。

医疗事故 :在侵权法中，医疗事故，也称为业务过失，是“业务人员的疏忽或不称职的一个实例”

这是出了名的难以断言，然而责任的概念是一个有趣的概念。我们可以严肃地质疑这种渎职或专业疏忽是否是技术行业在处理数据方面如此糟糕的声誉的原因。如果有一些关于你如何处理数据的专业标准，那就太好了。

****你觉得沃尔玛更了解你了吗？沃尔玛进行了广泛的市场调查，但是我们可以质疑他们带有机器学习的新相机是否仅用于跟踪盗窃。沃尔玛透露，它已经在 1000 家商店用人工智能摄像头跟踪收银台的盗窃行为。

Everseen 首席执行官艾伦·欧赫利希(Alan O'Herlihy)表示，该公司的技术旨在减少结账处的摩擦，并将结账监控“数字化”。

Ireland-based Everseen is one of several companies supplying Walmart with the technology for its Missed Scan Detection program.YouTube/Everseen from Business Insider

这张照片当然是我在以前的文章中提到的拟人化的一个很好的例子——希望将机器显示为人类。当然，没有像人一样的机器盯着你的图像，尽管它看起来像一系列朗朗上口的词的体现，如机器人，机器人过程自动化(RPA)，自主等。

一家新公司刚刚为一个人工智能筹集了 1 亿美元,这个人工智能融合了线上和线下行为来建立消费者档案。

广告和营销领域的圣杯之一是找到一种方法来准确捕捉和理解消费者一整天都在做什么，不管是数字活动还是线下活动。[……]附近——该公司已经建立了一个名为“火种源”的交互式、基于云的人工智能平台，该平台在 44 个国家开展工作，根据大量信息创建匿名的、基于位置的用户档案(目前每月 16 亿)，这些信息来自手机、数据合作伙伴、运营商及其客户，但该公司声称该平台是“以隐私设计为基础”建立的

那么，追踪你的感受，汇总并在未经你同意的情况下出售它怎么样？至少没有你的明确同意(阅读条款和条件)。**

目前没有同意的案例，因此这在欧盟严格来说可能是不合法的，但我不确定。可能会有一些灰色地带，一些演员可以利用，我不是律师。

当一个人自愿同意另一个人的提议或愿望时，表示同意。这种模糊的定义在技术领域并不可取，因为似乎大多数公司都认为你同意进入他们的平台。

:一般禁止处理个人数据，除非法律明确允许，或者数据主体已经同意处理。虽然同意是处理个人数据的一个较为知名的法律依据，但它只是《一般数据保护条例》( GDPR)中提到的六个依据之一。其他是:合同、法律义务、数据主体的重大利益、公共利益和 GDPR 第 6(1)条所述的合法利益。****

现在可能有更多的要求来说明你收集了哪些数据，并要求那些出售数据的人进行申报。然而，沃尔玛和 Near 或许能够以某种方式绕过这一点。众所周知，很难理解数据卖家的情况，以及他们把什么卖给了谁。然而，作为一个启发式的经验法则，我们可以推测这是否是一个过分的要求。

先征得同意:

使用数据
汇总数据
存储数据
出售数据

这似乎经常被忽视，仅仅是出于权宜之计的考虑— 也就是快速移动和打破东西,这似乎已经成为处理数据的同义词。去年(2018 年)的一个做法被量化的 VC 描述为非常活。

脸书可能在 2019 年 7 月受到 FTC50 亿美元罚款的打击。然而，4 月份的时候，据说[公司预留了 30 亿美元](http://In April, Facebook said it set aside $3 billion to help cover an expected fine of between $3 billion and $5 billion.)来期待这一天的到来。

具体来说，监管机构试图确定脸书是否违反了它在 2011 年与当局达成的协议条款，当时它承诺不会在未经用户同意的情况下收集和分享个人数据。

我们可以严肃地质疑这种公司人员的渎职或专业疏忽以及处理数据的系统性问题是否是导致科技行业如此声名狼藉的原因。以谷歌为例，到目前为止，它已经被欧盟委员会罚款超过 80 亿美元(尽管这对他们的收入影响很小)。

亚马逊最畅销的产品之一是他们的新带摄像头的闹钟。然而，这可能会产生意想不到的不良后果。私人房东已经开始使用便宜的照相软件来追踪车牌。甚至一些人工智能和伦理的倡导者也将它称为“人工智能算法”，并将“它”与伦理行为结合起来。不同收入水平的公司以及个人都在应用这些技术，需要确定如何处理不同个人的数据以及何时越过这条线。

我们必须开始讨论人，而不是技术，尽管透明的算法是要争取的。Cassie Kozyrkov在谈到算法中的偏差时做出了明智的声明:

教科书反映了作者的偏见。像教科书一样，数据集也有作者。它们是根据人们的指示收集的。[……]偏见不是来自 AI 算法，而是来自人。

偏见 :对某人或某团体的倾向或偏见，尤指以被认为不公平的方式。

我这么说，并不是说我们可以责怪人们，而不是他们工作的公司。然而，对于与处理数据相关的实践，必须有专业的责任。在这方面，我们不能一直拿“算法”或“人工智能”当替罪羊。

联邦计算和学习

2019 年 5 月 9 日，谷歌关于 Tensorflow 的演示展示了联合计算和联合学习的概述。您可以在此处查看演示的视频版本，但是您也可以滚动查看此处展示的几张幻灯片:

所以总结起来联邦学习隐私技术的四个原则是:

设备上的数据集:保留原始数据，过期旧数据，静态过期。
联合聚合:合并来自多个设备的报告。
安全聚合:计算加密设备报告的(向量)和。一个具有安全保证的实用协议:通信效率和掉话容忍度。
联合模型平均:每个设备上的梯度下降的许多步骤。

联盟是一组计算或网络提供商，他们以集体的方式就操作标准达成一致。当描述两个不同的、形式上断开的、可能具有不同内部结构的电信网络的互操作时，可以使用该术语。该术语也可用于团体试图授权集体发展权以防止分裂的情况。在电信互连中，不同系统的内部操作方式与联盟的存在无关。****

在软件工程中 碎片化或 项目分叉 当开发人员从一个软件包中取出一份源代码并在其上开始独立开发时，就会出现这种情况，从而创建出一个独特而独立的软件。这个术语通常不仅仅意味着一个开发分支，还意味着开发人员社区的分裂，一种分裂的形式(人与人之间的分裂)。

A 作案手法 (通常简称为 M.O. )是某人的工作习惯，特别是在商业或刑事调查的背景下，但也更为普遍。这是一个拉丁短语，大约翻译为操作模式。

正如我之前在关于半监督机器学习(SSL) 的文章中提到的，我在那里听说过联合学习这个术语:“作为一名作家，我解释谷歌大脑成员的文章和谷歌人工智能的博客帖子，可能看起来像一个青少年在评论一个专业运动队。”

从这个意义上说，如果有什么不清楚的地方，我可能不清楚，如果你想解释或讨论，我总是很乐意这样做。

最后一点，我确实意识到这是谷歌的推销，不能全信。

**********

这是第 500 天的第 44 天

什么是#500daysofAI？
我在挑战自己，用#500daysofAI 来写下并思考未来 500 天的人工智能话题。一起学习是最大的快乐，所以如果你觉得一篇文章引起了共鸣，请给我反馈。

Google 足球环境—使用 A3C 安装和培训 RL 代理

原文：https://towardsdatascience.com/google-football-environment-installation-and-training-rl-agent-using-a3c-d058a44f0fad?source=collection_archive---------13-----------------------

合著者: Ujwal Tewari

Frame from google football environment

几天前，谷歌大脑团队发布了一个开源足球环境，用于强化学习研究。他们提供了代码库(GitHub) 和他们的研究论文。

了解环境

让我们分解这个复杂的环境，了解它的状态空间表示，动作空间和成功的 RL 模型训练所需的其他配置-

状态空间

这个环境支持三种类型的状态表示。

像素:表示由一个 1280×720 的 RGB 图像组成，对应于渲染的屏幕。请注意，这包括记分牌和在画面底部中间部分的小地图(迷你地图),原则上，所有玩家的位置都可以从中推断出来。

4 frames of dimension 1280 x 720

2.超级迷你地图(SMM): SMM 基本上是一堆二进制矩阵，定义了呈现在屏幕中下方的迷你地图。SMM 表示由四个 96 × 72 矩阵组成，分别编码关于主队、客场队、球和现役球员的信息。编码是二进制的，表示在相应的坐标中是否有玩家、球或活动玩家。

Super Mini Map

3.floats:floats 表示提供了更紧凑的编码。它由一个 115 维的向量组成，概括了游戏的许多方面，如球员坐标、控球、方向、活跃球员或游戏模式。

注意-只有像素和 SMM 表示可以跨多个连续的时间步长进行堆叠(例如，确定球的方向)。

动作空间

gfootball 的动作空间非常有趣，并且与实际的足球比赛非常相关。该动作被给予当前活动的玩家，即头上有蓝色条的玩家。该环境支持 20 种操作。

他们已经为不活跃的球员实现了内置的基于规则的机器人，该机器人遵循与合理的足球动作和策略相对应的动作，例如当我们不控球时奔向球或者与我们活跃的球员一起向前移动。

场景

谷歌大脑团队提供了不同难度的不同场景。它的主要目标是允许研究人员快速开始新的研究想法，并对其进行迭代。代理最容易学习的场景是“空球门关闭”，其中只有一名球员站在球门前，没有守门员。

Empty goal close scenario

安装

让我们开始将这种凉爽的环境融入我们的系统。我们使用的系统有 ubuntu 18.04 操作系统和 python 3.6。安装游戏引擎和库的最好和最简单的方法是克隆 git 库。

注意—最好先创建一个 anaconda 环境或 python 虚拟环境，然后在该环境中安装依赖项。

- git clone https://github.com/google-research/football.git
- cd football
- pip3 install .[tf_cpu] --process-dependency-links
  Or for gpu version
- pip3 install .[tf_gpu] --process-dependency-links
- This command can run for a couple of minutes, as it compiles the C++ environment in the background.

安装后，您可以通过运行 GitHub 存储库中的文件 environment_test.py 来测试您的安装。

- git clone [https://github.com/Ujwal2910/Deep-RL-on-Gfootabll-Google-football-OpenAI-style-environment.git](https://github.com/Ujwal2910/Deep-RL-on-Gfootabll-Google-football-OpenAI-style-environment-.git)
- cd Deep-RL-on-Gfootabll-Google-football-OpenAI-style-environment/
- cd enviornment_render/
- python3 environment_test.py

它将连续渲染帧:

Output of running environment_test.py

如果您遇到 numpy 版本错误，根本原因可能是重叠的 numpy 版本。只需尝试卸载 numpy，然后再次尝试运行脚本。

要记住的事情

我们目前已经向 google football Github repository 报告了两个问题，他们已经承认了这个问题，并给出了一个临时的解决方案，直到他们修复这个问题。

在 115 维向量的浮点表示中，115 维仅针对 11v11 场景指定，对于所有其他场景，该数字会有所不同。所以你可以首先用 state.shape[0]检查，然后相应地构建你的模型。(链接到问题)
目前，他们的程序改变了运行代码的当前工作目录，因此在保存模型时使用绝对路径。(链接到问题)

培训 RL 代理

强化学习基本上分为基于值的函数和基于策略的函数上运行的算法。在这些算法中，演员-评论家算法是两者的结合，具有较小的方差和较高的收敛速度。

关于各种 RL 算法的更详细的数学解释，你可以参考这篇博文

Classification of reinforcement algorithms: Source

在这样的行动者-评论家算法中，有一种是异步优势行动者-评论家算法，或通常称为 A3C。

异步优势演员-评论家-

让我们分解这个复杂的算法，理解 A3C-的三个 A

异步-

A3C 具有多个工作人员的优势，每个工作人员分别在自己的环境中工作，并采取彼此完全独立的行动。以下步骤将以简单易懂的方式总结其工作原理，并展示其优于其他 RL 算法的优势-

每个工人在他们自己的环境中独立工作。
随着每个工作者在平行空间中运行，更多的探索发生了。
每个工人在每集结束时给出包含-[当前状态、下一个状态、采取的行动、获得的奖励、完成(布尔值，表明该集是否结束)]的信息元组。
来自每个工作者的这些元组在全局缓冲区中是成对的
然后全局代理在这个全局缓冲区上训练并保存其权重。
然后，工作者加载全局代理的保存的权重。
然后，工人根据全局代理的训练权重采取行动。
重复相同的步骤，直到全局代理收敛。
由于工人平行运行，训练速度更快。

优势功能-

q 值可以分为两部分-

状态值函数 V(s)
优势值 A(s，A)

优势函数可以如下导出

Q(s，a)= V(s)+ A(s，A)

A(s，a) =Q(s，a) -V(s)

A(s，a)= r+ γV(s_cap) -V(s)

优势函数实际上帮助我们更好地描述在给定状态下一个动作与其他动作相比如何，而价值函数则捕捉在这个状态下它有多好。

代码实现

对于 RL 算法的实现，我们使用了 ChainerRL 库，因为它包含 A3C 的优化版本。我们使用了一个名为 a3c.py 的文件，其中包含了培训代理的代码。

上面的代码片段只包含了算法的核心。你可以在这里查看整个文件。我们使用学院关闭目标场景进行训练，场景名称可在变量global _ environment _ name中定义，同样，其状态空间可在变量 state_space_size 中定义。

以下视频展示了培训结果

Training result on Empty Goal Close scenario

存储库链接

https://github . com/ujwal 2910/Deep-RL-on-Gfootabll-Google-football-open ai-style-environment

谷歌已经破解了“量子霸权”，还是他们已经破解了？

原文：https://towardsdatascience.com/google-has-cracked-quantum-supremacy-cd70c79a774b?source=collection_archive---------19-----------------------

数据科学

快速浏览一下谷歌最近在美国宇航局网站上泄露的关于量子计算的论文

Image — Google

问量子计算机和量子比特已经出现有一段时间了，关于它的应用有很多讨论和令人惊讶的关注。美国宇航局和谷歌一直在量子计算项目上合作，今年早些时候有迹象表明，谷歌即将破解量子霸权。几周前的 9 月，一篇谷歌泄露的论文被发布在美国宇航局的网站上，并立即被撤下。但互联网就是互联网，报纸的副本再次浮出水面，从那以后就有很多讨论在进行。

这篇论文的标题是使用可编程超导处理器的量子优势。根据谷歌的说法，一台 53 量子位的量子计算机首次利用量子特性在特定任务上超越了经典机器，从而实现了 量子优势。但是它还没有在任何科学杂志上发表，专家们还没有证实谷歌的说法，但是根据这篇论文的一段引文，它写道

据我们所知，这个实验标志着只能在量子处理器上进行的第一次计算

量子计算机正在与超级强大的经典计算机竞争，以模拟伪随机量子电路的输出，换句话说，就是一个数字发生器。

毫不奇怪，量子计算机轻而易举地赢得了比赛，但与竞争对手相比，它产生输出的速度可能有点令人震惊。在量子处理器上产生 100 万个随机数只需要 200 秒，而传统的超级计算机需要 10000 年。毕竟一万年后，我们中没有人会被留下来验证这些样本，这将需要数百万年的时间。

尽管所有这些说法都有待证实，但所有专家一致同意的事实是，量子计算机远未准备好用于商业用途。引用约翰·普雷斯基尔在 2011 年创造的“量子至上”一词

他们的机器以惊人的速度解决的问题是精心挑选的，只是为了展示量子计算机的优越性

但是，一台至少有 1500 个逻辑量子位的量子计算机可能能够解决比特币、密码术和加密等构成互联网上可信数字通信和账簿的数学问题。谷歌目前使用的量子计算机俗称 Sycamore 仅使用 53 个物理量子位，这是在 72 个物理量子位的计算机变得难以控制后开发的。扩展量子计算机绝非易事，你添加的量子位越多，系统就变得越不稳定。

至少现在，可以肯定的是，数据解密还需要很多年，因为它需要 1000 个量子位。所以，是的，你可以继续购买加密货币，并希望赚钱，只要谷歌在不久的将来不会出现奇迹并震惊我们。

Image- Unsplash

我们也不要破坏谷歌在这方面取得的成就。科学家们多年来一直致力于破解这一难题。值得注意的是，谷歌并不是唯一的玩家。像 IBM、英特尔、微软这样的公司已经为实现量子优势努力了很长时间。IBM 推出了一台 20 量子位的量子计算机，它是为商业用途设计的，但从未真正为它做好准备。因此，如果谷歌的工作得到证实，这将是这场争夺 霸权的激烈战斗中一个值得庆祝的里程碑。

同时，你可以在这里阅读原泄露论文 的节选。

更新-谷歌今天(2019 年 10 月 23 日)发布了一个名为“展示量子优势”的官方视频。

Google Sheets 作为可靠数据源的终极指南

原文：https://towardsdatascience.com/google-sheet-data-warehouse-c22bb2cce4b0?source=collection_archive---------10-----------------------

保持冷静，使用大量的数据验证

我偶尔需要授予一位非技术同事在特定基础上向我们的数据仓库输入信息的能力。例如，我们在 Milk Bar 的客户服务团队在 Google Sheets 中维护了一个特殊的婚礼蛋糕订单列表，我们需要从中收集数据用于下游计算。

对于数据工程师来说，这是一个棘手的问题——我的同事不具备与我们的数据堆栈直接交互的技术技能，我也不想支持自己的 web 表单或类似的基础设施来收集这些信息。如果我们可以将他们的 Google Sheet 直接同步到我们的数据仓库中的一个表，会怎么样？

乍一看，这听起来是个糟糕的主意。向没有模式控制的数据仓库表中自由输入数据是数据工程师的噩梦。如何防止有人意外删除某列或输入错误类型的数据？我如何知道我的同事正在按照我的期望输入数据？我已经能感觉到你的心开始跳动，想着这种方法违反了多少最佳实践！

和我在一起。我在这里想让你相信，Google Sheets，加上适当的防护栏，对于分析团队之外的同事来说，是一种输入表格数据以供下游使用的极好方式，甚至在自动化转换中也是如此！

我们将探索如何建立一个受限的、经过数据验证的 Google 表单，并讨论如何将这些数据同步到您的数据仓库，对其进行测试，甚至将转换后的结果发送回表单供您的同事查看或分析。

保护您的谷歌表单

许可

我们将从您应该对 Google Sheet 数据源实施的最明显的保护开始:共享权限。简单明了地说，唯一允许编辑你的工作表的人应该是你信任的人，他们会适当地编辑你的工作表，并且受过这方面的培训。保持链接共享关闭，除非你需要它打开，在这种情况下，链接权限应该设置为可以查看。

The Google Sheets Share menu. Don’t miss the Advanced button in the bottom right corner!

下一个重要的步骤经常被忽略，因为这个设置隐藏在谷歌共享菜单的高级部分。确保您限制编辑添加新人或更改访问权限。您希望确保您的同事不会无意中添加未经批准的编辑。

This menu is accessed by clicking Share in the top right corner, then clicking Advanced. Check the first box to make sure your share permissions don’t change without you realizing it.

受保护的工作表和区域

除了我们上面设置的工作簿级别的权限之外，我们还可以为单个工作表甚至特定的单元格区域设置权限。

要设置这些权限，导航到数据菜单并选择受保护的工作表和范围。您可以限制工作表和范围，使它们只能由某些人编辑，或者只允许人们在确认有关其操作后果的警告后编辑它们。

The warning message that Google displays if you try to edit a protected sheet or range with the “Show a warning when editing this range” option selected.

您可能有一些工作表包含公式或计算的必要信息，不需要任何用户进行编辑。如果是这种情况，请保护这些工作表，这样只有您可以修改它们。

数据有效性

彻底的数据验证使 Google Sheets 成为直接同步到数据仓库的可靠选择。有了数据验证，你可以在你的工作表中的期望范围上施加几乎任何你能想到的约束。

你可以从谷歌工作表中的数据菜单进入数据验证。数据验证会要求您输入一个单元格区域、一个约束以及在不满足该约束时要采取的动作。

The data validation menu in Google Sheets.

我建议当输入无效数据时，你的表单应该采取“拒绝输入”的动作。谷歌的“显示警告”选项在有问题的单元格的右上角显示一个小小的橙色三角形，用户很容易忽略。拒绝所有未经验证的内容，可以确保您只将干净的数据传递给依赖于一致模式的任何自动化流程。

我将浏览 Google 提供的每个约束选项，并讨论我们如何使用每个选项来限定干净的数据并拒绝杂乱的数据。

列出一个范围。我们经常使用它来迫使用户从预定义的值或类别列表中进行选择。一个便利的好处是，您可以在范围内的每个单元格中添加一个下拉列表，这样您的用户就可以直接选择一个有效值。我喜欢为我的验证范围保留一个单独的、完全受保护的表(只有我可以编辑它)。
物品清单。 类似于来自一个范围的列表，除了你以逗号分隔列表的形式直接提供有效值。这对于根据静态值的简短列表来验证条目非常有用。
号。该标准用于检查条目是否在数值范围内。我们可以防止负数或强制输入小于已知的最大值。
文字。 我们可以测试条目，看看它们是否包含某些子字符串。也许您想确保您的用户在复制发票号码时输入了正确的前缀。在下拉列表的底部还有几个有用的选项:是有效的电子邮件还是有效的网址。这些都是常见的验证需求，需要正则表达式或类似复杂的东西来确认。
日期。 我们可以验证条目是否为有效日期，是否在要求的范围内。由于日期格式的多样性，日期是出了名的混乱。如果用户要在工作表中的任何地方输入日期，这个验证标准是至关重要的。
自定义公式是。 这是数据验证的真正改变者。您可以编写任何返回 True 或 False 值的自定义公式，Google 将根据它来验证条目。你可以用这种方式实现一些非常复杂的验证逻辑。例如，使用REGEXPMATCH公式来确认条目匹配一组更复杂的字符串逻辑。Google Sheets 也不允许对同一个单元格应用多个验证标准，所以这个选项允许我们将标准合并到一个公式中。
复选框。 您可以用复选框替换您单元格区域中的单元格，当被选中和取消选中时，它将返回一个自定义值。这里 99%的用例可能都是对与错，但是如果你愿意的话，也可以灵活地表示其他东西。

如果这还不足以让您进行测试，您可以使用 DataValidationBuilder 类编写一个定制的 Google Apps 脚本来实现您自己的规则。

修改已经设置好的数据验证有点烦人。在一个工作表中应用的所有有效性规则没有一个统一的列表。相反，您必须选择感兴趣的单元格或区域，并返回到数据有效性菜单来删除或修改条件。

一旦您彻底验证了 Google 表单中的数据，您的表单将和定制的 web 表单一样好，甚至更好。您可以对数据的质量充满信心。

用条件格式向用户发出信号

有时用数据验证拒绝用户的输入过于严格，会导致糟糕的用户体验。你可以使用谷歌的“显示警告”选项，但是添加的橙色警告三角形很容易被用户忽略。我更喜欢使用条件格式将整个单元格变成令人担忧的红色或令人满意的绿色。

假设您希望在用户输入的值比平均值大或小两个标准差以上时向用户发出警告。您可以设置带有条件格式的公式，将单元格变为黄色，以警告用户该值是异常值，可能输入不正确。

当然，您可以使用自定义的数据验证公式来拒绝该值，但是条件格式会给您带来灰色阴影(真的！)向您的用户发出除了接受或拒绝之外的信号。有时候，拥有这种灵活性是件好事。我不打算深入设置条件格式的细节，但是如果你不熟悉这个概念，谷歌关于这个特性的文档在这里是。

可选:使用单独的导入范围表进行转换

我喜欢设置一个只有我可以编辑的中间导入表，而不是直接从用户访问的表同步到数据仓库。这个中间表给我提供了更多的控制。我使用IMPORTRANGE 公式配置这个表来复制用户访问的表中的所有数据。在将它传递到我的数据仓库之前，我可以在这个表中进行任何必要的调整。

例如，我可能只导入用户访问的工作表的特定范围，因此该范围之外的错误数据不会破坏下游的任何东西。
我还可以将两个用户访问的表(可能有多个表，一年一个)合并成一个带有垂直数组的表。
我甚至可以使用QUERY 公式来过滤用户访问的工作表中的行，以删除空白。

替代方案:用谷歌表单完全控制数据输入

如果用户在输入数据后不需要编辑数据，您可以使用 Google 表单设置一个仅附加系统。Google Forms 与 Google Sheets 进行了本机集成，这使得这种设置对于仅附加的需求来说非常简单。Google Forms 将在带有时间戳的 Google 表单中为您的表单的每个回复添加一行。如果您添加问题，工作表将扩展以匹配您的表单。

通过为您的表单选择适当的问题类型来确保数据整洁。要配置 Google Sheets 集成，您需要在 responses 选项卡中单击 Google Sheets 徽标，这将生成表单。

This Google Sheets logo in the Responses tab of a Google Form will create an auto-populating Google Sheet with the form’s responses.

因为您不能拒绝表单自身验证之外的数据，所以我建议您设置一个如上所述的中间导入表。在那里执行任何所需的过滤，以使您的数据在干净的状态下进行加载。

将您的 Google Sheet 同步到您的数据仓库

将 Google 表单加载到数据仓库是一个常见的问题，因此有很多潜在的解决方案。

如果你是 Google BigQuery 用户，最简单的方法是将 Google Sheet 设置为一个外部表。BigQuery 的文档更详细地描述了如何做到这一点，但是您需要做的只是为表定义一个模式，并且您可以直接从 BigQuery 查询您的表的第一个选项卡。

如果您正在使用雪花、红移或其他数据仓库，您可以从这些选项中进行选择。

大多数 数据加载服务 都集成了处理加载谷歌表单的功能。参见 Fivetran 的文档和 Alooma 的。
Stitch 的 Google Sheets 集成。 数据加载服务 Stitch 有一个关于如何在 Google Sheets 中设置一些将数据发送到 Stitch 的导入 API 的应用程序脚本代码的指南。然后，Stitch 会将数据加载到您选择的数据仓库中。使用这种方法，您必须通过单击“同步到缝合”来手动同步数据，这可能是一种祝福，也可能是一种诅咒，取决于您的需求。请注意，如果你还不是 Stitch 的客户，你必须注册，但同步几张表不太可能超过他们每月 500 万行的免费级别。
单张纸。 这是一个由 GitLab 的数据团队创建的 Python 工具，用于将本地 CSV 和 Google Sheets 加载到数据仓库中。在编写时，该工具支持 Postgres 和雪花。
Ro 的 Google Sheet 集成。Ro的数据团队开源了他们将 Google Sheets 数据加载到雪花中的定制方法。请注意，他们的方法在每次加载时都会截断并替换数据表，因此不会保留删除或修改的行。
你也可以考虑用 Zapier、webhooks 和像 AWS Lambda 这样的无服务器功能推出自己的模块化方法。您可以在工作表中创建行时触发 Zap，它会通过 webhook 将数据发送到一个无服务器函数，该函数设置为接收有效负载作为端点。如果您需要捕获更新和删除，这种方法会变得更有挑战性。

测试您仓库中的数据

一旦数据同步到您的仓库，您就差不多完成了！如果您仍然担心数据质量，或者对设置的数据验证不完全满意，可以将同步的数据仓库表作为临时表进行测试。一旦您的数据通过了 SQL 测试，就将其复制到生产环境中。

在数据仓库中测试数据是一个更大的主题，(这个主题我已经在这里广泛地写过了)，但是我们在 Milk Bar 使用数据构建工具(dbt) 来实现这一点。dbt 管理我们的数据仓库，并在 CI 管道中运行我们的 SQL 测试，以检查任何逃过验证的数据问题。

BigQuery 的加分:将数据发送回 Google Sheets

如果您是 BigQuery 用户，并且您的公司使用 GSuite，那么还有一个我不得不提到的功能。您可以在 Google Sheets 中查询 BigQuery 数据。

在谷歌工作表的数据菜单中，有一个数据连接器的选项。在这里，您可以连接到 BigQuery 数据仓库，用 SQL 查询表，将实时数据返回到 Google Sheet 中。在您的数据仓库中执行任何必要的下游计算或转换，然后以适合您的数据堆栈的节奏将有价值的信息返回给您的用户。

这种方法最多只支持 10，000 行，但 Google 正在测试这一功能的扩展，称为 Connected Sheets，它将允许您将整个表返回到 Google Sheets，无论它有多大。这项功能目前处于测试阶段，你可以在这里申请。

我希望这篇指南已经让你能够自信而正确地建立自己的 Google Sheet 数据源。如果你对使用 Google Sheets 作为数据源有所顾虑或有创意，请在评论中告诉我。

进一步阅读

Matthew Lincoln 的杰出文章，在你的数据项目中使用 Google Sheets 的最佳实践

使用 python 进行图像分析的 Google vision API

原文：https://towardsdatascience.com/google-vision-api-for-image-analysis-with-python-d3a2e45913d4?source=collection_archive---------19-----------------------

谷歌视觉 API 使用预先训练的机器学习模型从图像中检测物体、人脸、印刷和手写文本。您可以将每个图像上传到该工具并获取其内容。但是，如果您的本地桌面上有大量图像，那么使用 python 向 API 发送请求是非常可行的。

这篇文章讲述了如何使用 python 和 google cloud sdk 创建图像，将图像上传到 google bucket，对大型图像数据集执行标签检测。“gsutil”用于快速上传图片，并在 google bucket 上设置生命周期。所有图像都用批处理进行分析。

第一步:创建一个项目

按照下面链接中的步骤创建一个新项目，并启用 google vision AI。将密钥存储在 JSON 文件中。

[## 开始之前|云视觉 API 文档|谷歌云

在您可以使用 Cloud Vision API 之前，您必须为您的项目启用它:登录您的 Google 帐户。如果你…

cloud.google.com](https://cloud.google.com/vision/docs/before-you-begin)

第二步:下载 google cloud sdk 和 gsutil

Gsutil 工具有助于将大型图像数据集轻松上传到 google bucket。在命令提示符或终端中运行以下代码

【https://sdk.cloud.google.com】|迎头痛击

另外，您也可以从以下链接下载 sdk

MAC OS:https://cloud.google.com/sdk/docs/quickstart-macos(将文件夹存放在主目录中)

windowshttps://cloud.google.com/sdk/docs/quickstart-windows

第三步:设置配置:

需要以下命令来连接到您在步骤 1 中创建的 google cloud 项目。在终端中键入以下内容

gcloud init

选择要使用的配置:选择“创建新配置”

选择一个帐户来执行操作:如果您没有看到您的 gmail 帐户，请选择“使用新帐户登录”并登录该帐户。

选择要使用的云项目:您应该看到您在步骤 1 中创建的项目并选择它

第四步:上传图片到谷歌云存储

创建存储桶:gsutil MB ' GS://bucket name '(存储桶名称应该是唯一的)

将图像文件夹从本地桌面上传到 google bucket:

gsutil-m CP-R ' path/to/image folder ' ' GS://bucket name '

第五步:在 google bucket 中获取图片标签

现在你已经有了桶中的所有图像，使用' ImageAnnotatorClient '获取标签。如果你有很多图像，那么遍历桶中的每一个图像将会非常耗时。批处理可以加快这一过程，每批最多可处理 16 幅图像(https://cloud.google.com/vision/quotas)。

*#install google cloud vision
pip install google-cloud-vision#import dependencies
from google.cloud import vision
from google.cloud import storage
from google.cloud.vision_v1 import enums
from google.cloud.vision_v1 import ImageAnnotatorClient
from google.cloud.vision_v1 import types
import os
import jsonos.environ["GOOGLE_APPLICATION_CREDENTIALS"]='project_key.json' 
#(created in step 1)# Get GCS bucket
storage_client = storage.Client()
bucket = storage_client.bucket('bucket_name’)
image_paths = []
for blob in list(bucket.list_blobs()):
    image_paths.append("gs:// bucket_name/"+blob.name)# We can send a maximum of 16 images per request.
start = 0
end = 16
label_output = []for i in range(int(np.floor(len(image_paths)/16))+1):
    requests = []
    client = vision.ImageAnnotatorClient()
    for image_path in image_paths[start:end]:
        image = types.Image()
        image.source.image_uri = image_path
        requests.append({'image': image,'features': [{'type': vision_v1.Feature.Type.LABEL_DETECTION}]})
        response = client.batch_annotate_images(requests)
    for image_path, i in zip(image_paths[start:end], response.responses):
        labels = [{label.description: label.score} for label in i.label_annotations]
        labels = {k: v for d in labels for k, v in d.items()}
        filename = os.path.basename(image_path)
        l = {'filename': filename, 'labels': labels}
        label_output.append(l)
    start = start+16
    end = end+16#export results to JSON file
with open('image_results.json', 'w') as outputjson:
json.dump(label_output, outputjson, ensure_ascii=False)*

标签检测的结果可以存储在 JSON 文件中。

第六步:从 google bucket 中删除图片:你可能想在完成分析后删除图片，因为会有存储成本。删除循环中的每个图像需要时间。相反，为存储桶设置一个生命周期，这样您就可以一次删除整个存储桶。将以下代码粘贴到一个 JSON 文件中，并将其保存为 lifecycle.json，然后执行 gsutil 代码

*#Age tells about how many days after bucket creation you want to delete it.{
 "rule":
 [
  {
   "action": {"type": "Delete"},
   "condition": {"age": 2}
  }
 ]
}#This codes sets lifecycle for the bucket
gsutil lifecycle set 'lifecycle.json' 'gs://bucket_name'*

如果你还有一些问题或者想做文本/人脸检测，请查看https://code labs . developers . Google . com/code labs/cloud-vision-API-python/index . html？index=#0

希望这篇文章有所帮助。快乐阅读！

谷歌的 AutoML 与手工制作的模型在识别肺炎方面的比较

原文：https://towardsdatascience.com/googles-automl-vs-a-hand-made-model-in-identifying-pneumonia-f818902d24fc?source=collection_archive---------21-----------------------

最近有很多关于 AutoML 或“无人驾驶 ML”改变机器学习方式的潜力的谈论，并将该技术放在非编码人员的手中。谷歌是推动其“云自动”套件的公司之一，该套件包括计算机视觉、表格数据和自然语言处理的应用程序。他们的工具声称易于使用，并通过使用神经架构搜索来找到性能最佳的模型架构，比手工制作的机器学习模型具有更高的准确性。但它真的兑现了宣传吗？我们在 Pytorch 中将 Google AutoML 计算机视觉与我们自己的从头开始模型进行了对比测试。

试题——从 x 光片中识别肺炎

为了比较这两种方法，我们使用了一个代表计算机视觉真实世界用例的测试问题:我们使用 5200 张胸部 x 光图像的数据集来预测患者是否没有肺炎、细菌性肺炎或病毒性肺炎。精确模型的好处是显而易见的，可以帮助医生快速识别患者的肺炎病例。

试用谷歌汽车

我们从谷歌的 AutoML 开始，使用他们的计算机视觉模块来自动构建模型。导入数据和设置作业非常简单，尽管该工具在如何构造和标注要导入的数据方面提供了有限的灵活性。下面是结果页面的截图，显示了< 15 minutes of training. AutoML yielded an impressive 81.3% precision and 78.9% recall on this task, without requiring a single line of code! It also provides an API to access the model we created for use in generating predictions.

使用 PyTorch 和 FastAI 手工制作的模型后的结果

然后，我们使用 PyTorch 和库 FastAI 从头开始构建我们自己的模型，这使得在 PyTorch 中构建和训练模型更快。我们通过使用视觉变换在我们的训练数据集上使用数据增强来建立更鲁棒的模型，并在训练迭代中调整超参数以及缩小然后放大图像。通过几个小时的工作和大约 15 分钟的训练时间，我们实现了 82.7%的准确率和 81.0%的召回率，比 Google AutoML 的结果高出 1-2 个百分点。

我们的结论

虽然我们使用手工制作的神经网络在这个测试问题上取得了优于谷歌 AutoML 的结果，但它也明显更加耗时和复杂。即使有 FastAI 的库和 PyTorch 的帮助，我们自己也花了~ 2 个小时来建立和训练一个模型。一旦我们在 AutoML 上设置好了，不超过 30 分钟就可以导入我们的数据并训练一个模型，而无需编写一行代码。就简单性和易用性而言，AutoML 轻而易举地胜出。

然而，当数据集没有被整齐地组织到带标签的文件夹中或者您想要使用自定义验证集时，事情就变得复杂了。今天的 AutoML 在界面上相当死板，极大地限制了灵活性和可定制性。它非常适合“教科书”问题，但是对于许多在输入、标记或验证技术方面增加了复杂性现实世界的问题，它现在还不能处理它。

虽然我们手动实现了更好的精度建模，但我们获得的 1–2%精度增益的值实际上取决于所解决的具体问题。在某些情况下，这可能不是一个显著的差异，而在其他情况下，它可能会创造或破坏模型的价值。

总的来说，AutoML 是一个很好的简单工具，可以用来为标准分类任务快速构建“足够好”的模型，而不需要编码。然而，在其当前形式下，它在现实世界机器学习问题的适用性方面很快就崩溃了，这些问题涉及实践中经常使用的混乱的数据组织、定制标记方法或定制验证技术。它还充当了一个黑盒模型，不暴露任何内部细节来进行检查，也不需要在以后进行额外的培训或改进时进行调整。根据我们的经验，在现实世界中部署预测时，黑盒模型几乎总是一个坏主意。

谷歌的巴赫人工智能:一位拥有音乐理论博士学位的机器学习科学家做出了反应

原文：https://towardsdatascience.com/googles-bach-ai-a-machine-learning-scientist-with-a-phd-in-music-theory-reacts-68d055f2461d?source=collection_archive---------4-----------------------

Bach’s signature: B(B-flat), A, C, H (B-natural)

迟到的生日快乐，J·S·巴赫。为了庆祝，谷歌发布了一个“涂鸦”，如果你首先提供旋律，它会使用人工智能(AI)来调和巴赫的合唱曲。虽然我很想对谷歌的 Bach AI 进行深入研究，但这需要时间。巴赫的生日是昨天，我不想在派对上迟到了。

由于我拥有音乐理论博士学位，目前是机器学习和人工智能领域的应用科学家，所以有几个人问我的想法，所以他们在这里。

巴赫合唱团在音乐理论中有着特殊的地位。他们经常被认为是优秀的、遵守规则的、西方的、古典的(意思是普通的调性)音乐和声应该是什么样子。事实上，以巴赫合唱风格调和旋律和低音线是我音乐理论教学的一部分，从大学一年级的测验到写论文前必须通过的博士诊断考试。我的理论学生也体验到了巴赫合唱和声对橡皮寿命的不友好。

由于这些原因，当我们(理论家)看到一个“坏的”协调时，我们就知道它。平行第五？巴赫杀死了一只小猫(这是大约 2007 年早期脸书一个流行乐队的名字)。增强秒？你怎么敢。语音穿越？不可唱。这样的例子不胜枚举。

我的音乐理论社交媒体 bubble 很快指出了人工智能生成的合唱中的许多(许多许多许多)部分写作和声错误。乍看之下，我无法忽略这些错误——甚至那些只有基本理论知识的人也能轻易避免的错误。也许我有点嫉妒机器学习和音乐受到如此多的关注，当然我可以做得更好。但是我正在努力让第一物种的对位人工智能工作…

当我想到自己用人工智能创作更简单的音乐时，我意识到谷歌的“涂鸦”非常好。当然，如果是一个大二的学生，他们可能会失败，但是我们在谈论一台电脑。

我有写的代码创造了第一种对位。该代码基本上是一长串的规则和启发，将保证两个声音的和谐，不违反任何规则。这种方法不太符合音乐，尽管它是将音乐规则应用于代码的一个很好的练习。

没有对自我、风格、美等的真实表达。仅仅遵循一套规则。希望即使是我们理论家也不认为规则是最重要的。我怀疑有哪个作曲家只是为了避免不可提及的东西(平行五度音等等)。)就完事了。这并不是说规则不重要，但一个普通调性的作曲家应该对这种风格有足够好的把握，规则是本能地遵循的，重点是表达一种音乐思想(恰好遵循规则)。

谷歌的巴赫人工智能“涂鸦”试图与基于规则的系统相反。人工智能背后的“大脑”是一个人工深度神经网络。我不会进入细节(再说一次，我已经迟到了)，但你可以在他们的 Magenta 项目中了解谷歌在人工智能和音乐方面的工作。

深度学习的基础是这样的:将数据输入到神经网络中(比如旋律的一个度量)；数据通过“神经元”,神经元随机地给数据中的各种参数分配权重；网络随机猜测一个标签(比如输入旋律应该赋予什么和声音符)。

关键在于:基于网络的猜测是正确还是不正确(以及正确的程度)，随机权重被调整。这些调整——称为反向传播——在大量不同的数据上发生数千次甚至数百万次(例如所有巴赫合唱曲，这实际上是一个非常小的深度学习数据集)。

反向传播是机器学习的“学习”部分。在我们上面描述的假设网络中，如果你用一首原创的旋律进行测试，你会得到一个随机的音符和休止符的集合。所谓随机，我指的是 128 面骰子滚动，128 个 midi 音符中的每一个都有一面。随着网络的训练(看到更多的数据，经历更多的反向传播)，产生的谐波开始进入正常的键盘范围。再往后，由此产生的和声可能会开始产生某种音乐感。

把人工智能想象成一个学生。你只是让它“听”巴赫的合唱曲数千次并模仿它，而不是教它规则。从很多方面来说，这是一种音乐教学法。学生艾正在通过接触有关和声的文献来学习。

我们象牙塔中的理论家和谷歌“嘟嘟”之间的区别是，我们有更大的大脑，也许更重要的是，我们已经听了很多年的调性音乐。我不确定如果没有一个有用的规则列表，我们中有多少人会在听合唱时避免所有的和声错误。

作为一名研究人员，我个人最感兴趣的是为什么人工智能会做出这样的决定。通过大量的工作，我们可以深入到神经网络的各个层次来观察决策过程，并将它们与我们的进行比较。当我们了解机器如何作曲时，我们可以了解更多关于我们自己的思想，也许可以找到思考音乐决策的新方法。

在他的书《仙境:游戏如何创造了现代世界》中，史蒂文·约翰逊提供了“自我演奏”的音乐机器和一些塑造了我们周围世界的最卓越的技术发明之间令人信服的联系。也许音乐人工智能将帮助我们发明新的技术里程碑。

所以让小“嘟嘟”继续训练吧。我敢肯定，这只是刚刚开始学习。

P.S .谷歌向数千人介绍了巴赫合唱曲，甚至让他们尝试作曲。别把他们都吓跑了。

谷歌新的“可解释人工智能”(xAI)服务

原文：https://towardsdatascience.com/googles-new-explainable-ai-xai-service-83a7bc823773?source=collection_archive---------6-----------------------

谷歌已经开始为“可解释的人工智能”或 XAI 提供一项新服务，这是一种时髦的叫法。目前提供的工具并不多，但是目标是正确的。

人工智能有一个可解释的问题

人工智能将改变全球生产力、工作模式和生活方式，并创造巨大的财富。

研究公司 Gartner 预计，到 2022 年，全球人工智能经济将从去年的约 1.2 万亿美元增长到约【3.9 万亿美元，而麦肯锡认为，到 2030 年 全球经济活动将达到约【13 万亿美元】。

人工智能技术，特别是DeepLearning(DL)模型正在一个又一个应用领域以令人瞠目结舌的性能彻底改变商业和技术世界——图像分类、对象检测、对象跟踪、姿势识别、视频分析、合成图片生成——仅举几例。

它们被用于医疗保健、信息技术服务、金融、制造、自动驾驶、视频游戏、科学发现，甚至刑事司法系统。

然而，它们一点也不像经典的盈利算法/技术。DL 模型使用数百万个参数，并创建极其复杂和高度非线性的图像或数据集的内部表示。

因此，他们通常被称为完美的暗箱 ML 技术。在我们用大数据集训练它们之后，我们可以从它们那里获得高度准确的预测，但我们几乎没有希望理解模型用来将特定图像归类的数据的内部特征和表示。

****Source: CMU ML blog

谷歌已经启动了一项新的服务来解决这个问题

毫无疑问，正如商业分析师和经济学家所预测的那样，谷歌(或其母公司 Alphabet)在巨大的人工智能经济的适当发展中有很大的利害关系(见上一节)。

早在 2017 年，谷歌就将其官方战略政策设定为“人工智能优先”。

因此，它可能感到了压力，要成为行业的火炬手，通过提供可解释的人工智能服务，让人工智能不那么神秘，更容易为普通用户所接受。

什么是可解释的人工智能？

这个概念，顾名思义，很简单。你希望你的模型不仅能给出预测，还能给出一些解释，关于为什么预测会变成那样。

但是为什么需要它呢？

这篇文章涵盖了一些要点。人工智能系统提供可解释性的主要原因是—

提高人类可读性
确定机器所做决策的合理性
帮助决定责任，责任导致良好的决策
避免歧视
减少社会偏见

围绕它仍有许多争论，但一个共识正在形成，即后预测论证不是一个正确的方法。可解释性目标应该在核心设计阶段构建到 AI 模型/系统中，应该是系统不可分割的一部分，而不是附件。

已经提出了一些流行的方法。

更好地理解数据 —直观形象地展示区别特征
更好地理解模型 —可视化神经网络层的激活。
更好地了解用户心理和行为 —在统计学习的同时将行为模型整合到系统中，并在此过程中生成/整合适当的数据/解释

甚至 DARPA 已经开始了整个项目来为未来人工智能/人工智能驱动的防御系统构建和设计这些 XAI 原理和算法。

在核心设计阶段，可解释性目标应该被构建到人工智能模型/系统中

请阅读这篇文章，以获得对这一概念的全面讨论。

** [## AI 应该自我解释吗？或者我们应该设计可解释的人工智能，这样它就不必

在本文中，我将介绍:

towardsdatascience.com](/should-ai-explain-itself-or-should-we-design-explainable-ai-so-that-it-doesnt-have-to-90e75bb6089e)

谷歌云希望在 xAI 领域领先

谷歌在吸引人工智能和人工智能人才方面处于领先地位，它是当前世界信息化经济中无可争议的巨头。然而，与亚马逊和微软相比，它的云服务远远排在第三位。

Source: Top cloud providers 2019

然而，正如本文所指出的，尽管传统的基础设施即服务之战已经在很大程度上决定了，但人工智能和 ML 等新技术已经为玩家开辟了新的主题、策略和尝试方法的领域。

基于这些想法，在本周伦敦的一次活动中，谷歌的云计算部门推出了一个新设施，希望它能给自己带来相对于微软和亚马逊的优势。

著名人工智能研究员 Andrew Moore 教授在伦敦介绍并解释了这项服务。

Prof. Andrew Moore in London for Google Cloud explainable AI service launch, source

从他们的官方博客，

“可解释的人工智能是一套工具和框架，可以帮助你开发可解释和包容的机器学习模型，并自信地部署它们。通过它，您可以了解 AutoML 表和 AI 平台中的特征属性，并使用假设分析工具直观地研究模型行为。”

最初—适度的目标

最初，目标和范围相当有限。该服务将提供关于人脸和物体检测模型的性能和潜在缺点的信息。

然而，随着时间的推移，GCP 希望提供更广泛的见解和可视化，以帮助使其人工智能系统的内部工作不那么神秘，更值得每个人信任。

人工智能和人工智能等新技术为云服务玩家打开了一个领域，让他们尝试新的主题、策略和方法。

摩尔教授坦率地承认，在可解释性问题上，人工智能系统甚至让谷歌最优秀的头脑也感到为难。

"让我们在谷歌疯狂的一件事是，我们经常建立非常准确的机器学习模型，但我们必须理解他们为什么要做他们正在做的事情。在许多大型系统中，我们为我们的智能手机或我们的搜索排名系统或问答系统构建的，我们在内部努力了解正在发生的事情。”

谷歌希望给用户一个更好的解释，方法之一是通过所谓的型号卡。

Google model card for face detection, Source: ZDNet article

谷歌曾经提供了一个场景分析工具。他们鼓励用户将新的可解释工具与这个场景分析框架结合起来。

“你可以将人工智能解释与我们的假设工具结合起来，以全面了解你的模型的行为，”谷歌云战略总监特雷西·弗雷说。

Google AI’s What-If tool

而且，目前它是一个免费的附加软件。可解释的人工智能工具免费提供给 AutoML 表或人工智能平台的用户。

欲了解更多细节和历史观点，请考虑阅读这篇精彩的白皮书。

总的来说，这听起来是一个好的开始。虽然，并不是每个人，甚至是谷歌内部的人，都对 xAI 的整个想法充满热情。

偏见和审计？

有人说偏见是一个更大的问题

过去，谷歌研究总监彼得·诺维格曾说过可解释的人工智能，

“你可以问一个人，但是，你知道，认知心理学家发现，当你问一个人时，你并没有真正了解决策过程。他们先做决定，然后你问，然后他们给出一个解释，而这个解释可能不是真实的。”

所以，从本质上说，我们的决策过程受到心理学的限制，对机器来说也是如此。我们真的需要为机器智能改变这些机制吗？如果得出的答案和见解不为用户所接受怎么办？

相反，他认为在机器的决策过程中，应该给予跟踪和识别偏见和公平更多的思考和重视。

要做到这一点，模型的内部工作不一定是最好的观察点。人们可以观察系统随时间做出的所有输出决策，并识别隐藏偏差机制的特定模式。

对于未来的人工智能系统来说，偏见和公平应该比单纯的解释更重要吗？

如果你申请贷款并被拒绝，一个可解释的人工智能服务可能会吐出这样一句话——“你的贷款申请被拒绝是因为缺乏足够的收入证明”。然而，任何建立了 ML 模型的人都知道，该过程不是一维的，产生这种决策的数学模型的具体结构和权重(通常作为一个整体)取决于收集的数据集，在涉及收入和经济流动性的问题时，这些数据集可能对社会中的某些人有偏见。

因此，这场辩论将围绕这样一个相对重要的问题展开:仅仅拥有一个显示出基本的、淡化了的解释的系统，以及建立一个更少偏见、更高程度公平的系统。

外部自动审计？

为了让人工智能系统更容易解释(或者至少更负责任)，一些人提出了自动化、可扩展的外部审计系统来管理来自黑盒人工智能平台的决策。艾伦人工智能研究所的柳文欢·埃齐奥尼在这里提出了这样一种方法。

[## 高风险的人工智能决策需要被自动审计

今天的人工智能系统在贷款、医疗诊断、假释等方面做出重大决策。它们也是不透明的…

www.wired.com](https://www.wired.com/story/ai-needs-to-be-audited/)

如果你有任何问题或想法要分享，请联系作者tirthajyoti【AT】Gmail . com。此外，您可以查看作者的 GitHub 资源库中的代码、思想和机器学习和数据科学方面的资源。如果你像我一样，对人工智能/机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。

[## Tirthajyoti Sarkar - Sr .首席工程师-半导体、人工智能、机器学习- ON…

通过写作使数据科学/ML 概念易于理解:https://medium.com/@tirthajyoti 开源和有趣…

www.linkedin.com](https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/?source=post_page-----c02c141c5756----------------------)**

谷歌的夜莺计划和紧急医疗数据

原文：https://towardsdatascience.com/googles-project-nightingale-and-emergent-medical-data-7382b15f051f?source=collection_archive---------43-----------------------

其他人的健康数据对你有什么影响

Photo by Marcelo Leal on Unsplash

你知道手机应用收集位置、通话记录、社交媒体帖子等等。这些数据收集机器在收集相关信息以识别选择性广告的客户方面不断改进。虽然我们所处的这种反乌托邦式的定向广告前景令人恐惧，但这仅仅是商业化潜力或个人数据歧视的冰山一角。数据在我们的数字经济中有着巨大的价值，没有任何数据比患者病历的价值更高。广告商可以利用这些数据来推销昂贵的药品，并针对一个人的医疗状况定制行为广告。保险公司也可以收集这些医疗数据来计算患者的保费。

健康数据影响着我们生活和身份的方方面面。诊断可能使我们改变生活方式或接受终生治疗。对于那些不想公布潜在健康状况的人来说，仍然可以使用我们的数字指纹来观察由于健康原因而导致的生活方式的改变。此外，一些行为可能预示着未诊断的医疗状况。梅森将这些从数字足迹中推断出的医疗状况描述为紧急医疗数据。在今年 6 月发表的一篇文章中，脸书的研究人员表明，来自社交媒体帖子的信息可能与潜在的医疗状况相关联。该研究包括 999 名患者的病历和脸书状态。该研究表明，仅基于脸书的帖子，在诊断糖尿病患者和精神健康状况方面是有效的。

Photo by Joshua Hoehne on Unsplash

脸书邮报是一个面向外部的媒体，旨在向更广泛的社区表达情感。搜索结果对用户来说更加“私密”，因此许多人会搜索他们永远不会公开发布的信息。这种对搜索引擎的信任使得控制搜索引擎的公司特别擅长收集潜在的健康数据，因为患者可能会通过在诊断后收集更多信息来开始他们的健康之旅。最大的搜索引擎谷歌最近被曝与美国最大的非营利医疗系统阿森松岛进行了秘密谈判。这项名为“南丁格尔计划”的交易让谷歌获得了 5000 万份患者病历。谷歌健康记录数据库的规模和来自“私人”搜索结果的扩展信息赋予谷歌前所未有的能力，来识别反映所有用户中疾病的存在或早期发作的单词、短语和其他变量。

南丁格尔项目为谷歌创建了一个黄金标准健康数据库，以发现新的健康标志，并将它们应用于广泛的公司平台，以推断用户的医疗状况。谷歌最有可能将这个黄金标准数据集导出到母公司 Alphabet 的其他分支机构。例如，谷歌和 Nest 正在努力为一种智能家居健康算法申请专利，该算法能够从居住者的行为中推断他们是否患有阿尔茨海默氏症或物质使用障碍。这些新的健康标志将作为商业秘密受到保护，不向公众公开，可能会花费数百万的医疗费用和无数的生命。

谷歌在健康领域的野心越来越大，最近收购 Fitbit 就是明证。2700 万 FitBit 用户为谷歌扩展到可穿戴健康技术时正在建立的消费者健康监控帝国提供了一个新的角度。

谷歌并不是唯一一个雄心勃勃收集消费者健康数据的公司。Apple Health 和 Apple Watch 可穿戴设备可供苹果开发的时机已经成熟。微软和亚马逊紧随其后，这些科技公司提供医疗保险等产品，并利用从购物习惯和智能扬声器收集的数据来预测用户的健康信息。

并非所有数据都是平等的。患者的医疗记录很有价值，因为它们可以用作训练算法的黄金标准，以搜索另一个用户未公开或未诊断的医疗状况。科技公司开始使用这些信息来为行为广告或药物分析用户。我的一个朋友多年来一直在与潜在的疾病作斗争，并向我分享了他对他最喜欢的流媒体平台上不断出现的药品广告的烦恼。他的潜在状况的细节是如何被转移到针对他的健康的广告商那里的，这令人担忧。我们会成为未确诊疾病的行为广告的目标吗？这些技术公司有义务向用户报告推断的情况吗？随着我们越来越多的个人数据被用于盈利，监管机构和个人应该要求提供这些信息。

来源:

https://slate . com/technology/2019/11/Google-ascension-project-nightingale-emergent-medical-data . html

【https://journals.plos.org/plosone/article? id = 10.1371/journal . pone . 0215476

https://blog . petrieflom . law . Harvard . edu/2017/10/11/emergent-medical-data/

被幻觉欺骗的 GoogleVision？

原文：https://towardsdatascience.com/googlevision-tricked-by-illusions-e698d98cc3cf?source=collection_archive---------24-----------------------

Photo by Conor Luddy on Unsplash

马克斯·伍尔夫的这条推文在一段时间内被到处谈论

我发现这很有趣。所以，我想弄清楚谷歌视觉 API 如何对互联网上不同类型的幻觉做出反应。

Classification - Dog 100% (Confidence)

所以，在第一张图中，我们可以清楚地看到一只狗。

而视觉 API 归类为 100% 置信度的狗。

这并不奇怪。

Classification — Head, nose, jaw, and mouth 85% (Confidence, Avg)

现在让我们将图像向右旋转 90 度。

我给你做了标记，让你很容易认出代表一个戴着帽子的男人的部分——看起来有点悲伤，因为是狗耳朵的一部分！

令人惊讶的是， Vision API 也收到了！它以大约 85%的置信度预测它是头部、鼻子、下巴和嘴巴。

下图显示了类似的结果:

Classification — Frog, Toad, Amphibian 65% (Confidence, Avg)

它被归类为青蛙、蟾蜍、两栖动物，有大约 65%的把握。

Classification — Horse 93% (Confidence)

它被归类为马！有着超过 90 %的信心。

谷歌更进一步，把它归类为'鬃毛'、' T24 种马'和' m ustang '也是！

显然视觉 API ，就像你和我会感知一个图像，需要它来旋转图像并得到一个“哦，我现在看到了！”瞬间。

取向的确很重要。

这里有一个陷阱，当伪装在背景中时，视觉 API 无法识别图像中的对象。它甚至在图像中失败，在图像中，它会有不同的组件融合在一起，造成某种东西由它们组成的幻觉。

你可以自己去看。

Save The Animals Poster by WWF

我们可以看到一些隐藏的动物(为了便于可视化而标记)，但遗憾的是 Vision API 只能看到植物群，而不是动物群。

同样，这里它识别一棵树、一根树枝、一棵木本植物，而不是脸。

就是这样！如果你有任何问题，请随时发微博给我。

哦，我在网上找到了这个-

关注我随时更新我的帖子。祝您愉快！🎉

有数据科学的工作吗？

原文：https://towardsdatascience.com/got-data-science-jobs-552e39d48da2?source=collection_archive---------8-----------------------

首次提供后数据科学训练营的登陆挑战(以及一些建议)

那么你正在考虑参加数据科学训练营？你已经看过像这样的列表说数据科学家是美国最好的工作(而且薪水很高),你不断被广告轰炸，广告说训练营 ABC 将如何培训你并帮助你获得第一份数据科学工作。

辞去现在的工作，支付 15，000 到 20，000 美元，回到学校三个月，然后在训练营结束后找一段时间的工作，这绝对是一场赌博。

现在，我已经经历了数据科学训练营的经历，并从另一边走了出来，下面是我希望我事先知道的关于它和随后的求职过程的内容。 免责声明: 我在三藩市参加了 Metis，所以如果你选择另一个训练营和/或地点，你的经历可能会和我的不同。

你会学到很多很酷的东西……但是其中 70%对你的第一份工作没有用处

计算机视觉超级酷，用 LSTM 神经网络生成文本也是如此。但是有 99%的可能性，你的面试官会更关心你的 SQL 表连接技能，而不是你对深度学习的知识和热情。

Eyes blurry from too many SQL queries…

我并不是说了解深度学习和人工智能不重要(它们肯定很重要)，而是说当你第一次完成训练营时，你可能会面试大多数数据分析师角色(或伪装成数据科学家头衔的数据分析师角色)。

据我所知，这些角色需要的关键技能是:

结构化查询语言
结构化查询语言
结构化查询语言
SQL(你需要非常擅长 SQL)
用 Python 清理数据(NumPy 和 Pandas)
A/B 测试
数据可视化(最好使用 Tableau)
基本统计学(相关性、统计推断、线性回归)
一些聚类和分类算法的知识

遗憾的是，你在训练营期间花了大量时间做的许多事情(老实说，训练一个神经网络来引用埃德加·爱伦·坡的话要比对两种方法之间的差异进行假设检验有趣得多)都不会得到面试官的赏识。

不幸的是，作为一名绝对的忍者，SQL 在训练营期间几乎没有涉及到。相反，你很可能会在训练营结束后的前几周独自努力练习 SQL。如果你想加快这个过程，那就在训练营的几个晚上学习和练习 SQL。 我的好朋友兰迪正在这里写一个很棒的 SQL 入门系列。

你必须自己安排大部分的面试

你的训练营将会宣传其校友网络、招聘伙伴、招聘协助和面试准备的变革力量。

是的，肯定有一些职业帮助，但数据科学训练营不同于传统的软件开发人员训练营，我完全是猜测，但我要说，每聘用 1 名数据科学家，就可能聘用 15 至 20 名软件工程师。尽管数据科学家目前很受欢迎，但在技能需求方面，他们仍然无法与软件工程师相比——因此，你不应该利用朋友的软件工程训练营招聘结果作为你参加数据科学训练营的动机。

数据科学家供需不匹配的情况已今非昔比。多年的炒作和高薪可能已经使市场更加接近平衡，与此同时，许多公司发现数据科学和机器学习可以帮助他们实现的目标是有限的。

因此，这个故事的寓意是，我们中有越来越多的人在争夺一块馅饼，而这块馅饼的增长速度可能没有我们希望的那么快。

就我个人而言，我去训练营的时候期望在接近尾声的时候会有一个“招募日”或者“面试日”,但是我很失望。虽然我们确实有一个职业日，在那里我们向一些招聘人员展示了我们的最终项目，但我不相信我的同事中有任何人获得了现场面试，更不用说获得工作了。并不是因为缺乏尝试——我的同学展示了一些非常棒的项目，在网络会议期间，每个人都很努力地交谈。不幸的是，许多招聘人员要么不招聘，要么试图填补需要更多经验的职位。

LinkedIn will become your best friend

那么，一个有抱负的数据科学家应该做些什么呢？我有三个建议:

垃圾邮件 LinkedIn 上的简单应用按钮。 LinkedIn 有一个叫 Easy Apply 的惊人功能，可以让你在 5 秒钟内申请一份工作(只要你的简历已经上传)。即使回复率真的很低(是的，你应该期待这些列表的回复率更低，因为每个人都申请，因为它太容易了)，你仍然可以每周获得一次或两次面试。这是因为如果你每晚只花 10 分钟发送简单的申请，你将会每周申请 40 或 50 份工作。
如果你有关系网的话，那就多依靠你的关系网。和你感兴趣的行业或公司的朋友和熟人一起吃午饭，喝咖啡，做任何你能做的事情。是的，社交并不有趣(至少对我来说)，但它是这个过程中必不可少的一部分。如今，科技公司会发放丰厚的推荐奖金，因此，如果你能证明自己是一个好奇、谦逊、相当博学的人，那么人们通常会渴望(并受到激励)提供帮助。
不要过分拘泥于数据科学家的头衔。你不应该期望你在训练营后的第一份工作是你的梦想工作(但是如果你找到了，那就太棒了)。每一份新工作都是一个学习和建立新技能的机会，只要你继续这个复合过程，你就会在某个时候找到你梦想的角色。但我强烈建议你不要成为一个工作势利者——相反，尽可能多地寻找获得分析经验的途径。

没有人会关心你所做的项目，除非你让他们关心

训练营的一个关键卖点是有机会将数据科学项目组合在一起，然后我可以向公司兜售证据，“嘿，我可以做这个数据科学的事情！”

但是回过头来看，我太天真了，因为我训练了一个产生良好结果的模型，把它放在我的 GitHub 上，并在我的简历上写了一个关于它的项目，招聘人员或招聘经理会神奇地看到它，并说，“酷！我们应该给那个家伙一个机会。”

你需要推销你的项目和你的数据科学知识。就我个人而言，我通过我的博客来做这件事。如果你是一个有抱负的数据科学博客作者，这里有一些中等技巧:

在像 这样的刊物上发表面向数据科学的 ，拥有大量的忠实追随者。比起你自己发表，更多的人会看到你的作品，尤其是在开始的时候。
使用非技术性语言、清晰简单的例子和吸引人的视觉效果来解释你的工作和想法因为媒体上的大多数人都不是数据科学家。这有一个额外的好处，那就是确保你真正理解你所写的东西——学会向一个非技术人员解释一个复杂的话题是建立你自己的理解和专业知识的一个非常有效的方法。你也会得到更多的阅读。
不要只是一步一步地重复你的项目。这不是高中科学项目报告。你是在为既想娱乐又想受教育的观众写作。如果你想突出你的项目工作，你可以考虑你的项目的某个方面如何展示一个关键的数据科学原理。例如，你可以写你的线性回归项目，同时教导你的读者为什么你的模型坚持普通最小二乘法的假设是至关重要的。这样写通常比“我先写 A，然后写 B，然后写 C，等等”更有趣。更有趣意味着更多的阅读，最终会给你和你的作品带来更多的曝光率。

无论你如何推销你的项目和你自己，只要记住，除非你让他们关心你(以引人注目的方式展示你的过程和见解)，否则他们不会关心你所有的努力工作。

你需要了解(你面试的每个地方的)业务

这在湾区更难(相比之下，像休斯顿这样的地方，所有公司都在石油和天然气行业)。有这么多的创业公司，每个都试图用自己独特的商业经济学来颠覆一个特定的行业。

因此，不幸的是，如果你想在湾区的科技行业(尤其是科技创业公司)工作，你将不得不大量阅读和研究各种行业的竞争动态。维基百科和 Crunchbase 是很好的起点。像 这样的商业策略博客，a16z 博客 和strate Chery非常适合深入你感兴趣的行业或进行面试。晨星公司在分析公司和行业方面也做得出奇的好——特别注意他们关于是什么驱动了一家公司的经济护城河的讨论——这些特征使得一家公司能够随着时间的推移持续获得高资本回报。

在多次面试中，我被问到的第一个问题是，“那么你对我们了解多少？”

一般来说，招聘人员和招聘经理希望我至少知道以下事情:

在的公司是做什么业务的，卖什么产品或者服务？
它是怎么赚钱的？公司商业模式的哪些特点使其能够从竞争中脱颖而出并获得利润(如果没有利润，那么是什么使其比竞争对手增长得更快)？
了解公司目前如何应用数据科学来获得竞争优势或克服业务障碍。

Don’t forget to code!

找工作本身就是一项全职工作——同时，如果你不努力，你辛苦获得的数据科学和编码技能将会萎缩

许多数据科学训练营的毕业生都是职业改变者，其中许多人没有或至少没有技术背景。在求职中获得成功需要花费大量的时间和精力。

至少对我来说，找工作及其所有必要的事情(申请、求职信、咖啡会议、电话、面试准备、实际面试本身，以及感谢信)是极其耗时的。除此之外，我还需要维护我的博客。

不知不觉中，一个多星期过去了，我几乎没有接触过 Python。那时，我强迫自己从找工作中抽身出来，从事一个旧的数据科学项目。

尽管我们很想得到这份工作，但重要的是要记住，我们不是数据科学家，因为一些公司愿意付钱让我们成为数据科学家——相反，我们是数据科学家，因为我们经常实践数据科学(编写新项目的代码，参加 Kaggle 竞赛，研究和阅读新算法，等等)。).

所以，继续努力，继续做那些项目，继续展示你的激情，最终会有人给你一个机会。干杯，祝你好运！

更多数据科学与分析相关岗位:

了解 PCA

了解随机森林

理解神经网络

了解 A/B 测试

用 Tableau 可视化股票

维度的诅咒

GPT2，计数意识和好奇的黑客

原文：https://towardsdatascience.com/gpt2-counting-consciousness-and-the-curious-hacker-323c6639a3a8?source=collection_archive---------1-----------------------

免责声明:我希望它是非常明确的，我绝对 100%开放的想法，我在这篇文章中的任何错误。我不仅接受，而且明确要求能够让我相信我在这些问题上是错的论点。如果你认为我在这里有任何错误，并且有一个可能说服我的论点，请联系并提出你的论点。我很高兴说“哎呀”，并收回这里提出的任何意见，并改变我的行动方针。

俗话说:“当事实改变时，我改变我的想法。你是做什么的？”

TL；DR:我是一名复制 OpenAI 的 GPT 2–1.5b 的学生，我计划在 7 月 1 日发布它。在批评我这样做的决定之前，请阅读下面我的论点。如果你仍然认为我错了，请通过 Twitter @NPCollapse 或电子邮件(thecurioushacker@outlook.com 联系我，并说服我。代码和技术细节见本帖。

更新:我的想法已经改变，我打算不发布。看到我的更新帖子 这里 说明了我的推理。

更新 2:这篇文章现在是(计划中的)4 系列文章的第 1 部分。如果你喜欢你所读到的，请继续阅读第二部分。

这篇文章分为三个部分。第一部分介绍了什么是 GPT2 的背景以及为什么它值得关注。在第二(长)部分，我阐述了我对 GPT2 对我们社会意味着什么的想法。在第三部分，我谈了一个有点离题的话题，我认为这个话题对我们关于人工智能安全的一般性讨论是有价值的，也是我开始这个项目的最终原因:好奇黑客的思想。

我为我的长篇大论道歉，但是我有太多的话要说，我可以轻松地写两倍的内容。我呼吁你在阅读时不要妄加评论，请跟我读完。我经常岔开看似不相关的话题，但是如果你坚持下去，我保证我会回到一个有趣的话题(通常…希望如此…)。

第一部分:GPT2

不久前，OpenAI 披露了他们在人工智能系统 GPT2 创造语言方面的最新实验细节。这不是第一次建造这样的系统，尽管它的结果远远超过了迄今为止的任何其他尝试，但可以说这不是这个项目最受关注的地方。OpenAI 决定不发布他们模型的全尺寸版本(1.5B)，因为他们担心其潜在的安全隐患，特别是在产生假新闻方面。他们确实发布了一个较小的版本(117 米)，后来又发布了一个中等大小的版本(345 米)。理论上，将 1.17 亿或 3.45 亿扩展到 1.5 亿没有太大障碍，但有一个实际障碍:计算。在云计算领域，创造 15 亿的成本估计在 4 万美元左右。这遵循了人工智能技术发展水平的一个长期趋势，即计算成本越来越高。

不公开发布他们的模型的决定，尽管他们的名字中有“open ”,获得了广泛的响应。但是直到今天，1.5 亿仍然没有发布(除了几个研究伙伴)，而且据我所知，还没有复制。没有一个个人或合理的学术研究小组会有足够的资源从零开始创造 15 亿。

嗯，我复制了 1.5B。

我不在任何政府、大学或大公司的指导下工作(尽管我觉得我欠谷歌我的第一个孩子或其他什么东西，因为他们给了我大量的免费支持)。我只是一个好奇的本科生，把空闲时间花在人工智能实验上，而不是出去和女孩们聊天。

在这篇文章中，我不想解释我是如何做到这一点的技术细节(我已经在的另一篇文章中这样做了)，而是我想借此机会，当有人看到我时，讨论一下我对整个 GPT2 情况的看法，以及它对人工智能和人工智能安全的意义。

为什么这很重要？

如果你看一看工作中的 GPT2 的样本，你应该很快就会明白为什么这可能是一件大事。他们有时在风格上甚至在内容上出奇地一致。这个例子有些滑稽，但也令人担忧。

GPT2 与许多其他模型的不同之处在于它的通用性。它在所有链接到 reddit.com 的网站上接受了至少三种因果报应(一种人类质量预过滤)的训练。我用较小的型号做了大量的实验，从中获得了巨大的乐趣。我和朋友们花了几个小时的时间试图让这个东西生成有趣的文本，让我们大声读给彼此听(我们发现，如果你用圣经引文来填充它，它会变得特别滑稽的宗教咆哮)。我和一个朋友一直在开发一款融入了 GPT2 的视频游戏，甚至有一次在派对上，我们围坐在一架钢琴旁，提示人工智能，直到它吐出一些类似歌词的东西，所以我的朋友塞巴斯蒂安(@shyteagames) 把它变成了一部即兴的太空歌剧音乐剧(这不是我那天晚上期望做的事情，但真的很有趣)。

当然，就像我的大部分饮食和锻炼习惯一样，任何有趣的事情对你来说都是有害的。让 GPT2 创作关于你朋友的有趣的达达主义情色漫画的一般性也意味着它可以做许多不那么无聊的事情:虚假评论、煽动性的政治信息(它喜欢谈论英国退出欧盟)以及互联网上已经太多的其他事情。出于这些原因，OpenAI 决定不发布完整的模型(它生成的文本远比小模型更有说服力)。但这有效吗？这是正确的选择吗？像我这样的人复制了这种“危险”的技术意味着什么？

分水岭时刻？

"道德是世界应该如何运转，经济是世界实际如何运转."

让我们后退一步。或者很多步骤。是什么让 GPT2 具有潜在的危险性？它有哪些性质是我们需要警惕的？那些属性是如何影响现实世界的？

人们主要担心的是，GPT2 可能会严重扰乱网络世界，甚至比现在更糟。好吧，那它是怎么做到的？这种观点认为，利用 GPT2，恶意行为者可以制造出大量名副其实的虚假内容，以推动叙事，操纵产品评论，或者只是非常令人讨厌。但是 GPT2 是如何实现的呢？GPT2 产生文本。人类可以产生文本。所以这不是什么新鲜事。不，GPT2(以及一般的人工智能和技术)将我们带回了经济学家最喜欢的工具之一:成本。

理由是，使用 GPT2 这样的技术，我们本身并没有从事一项全新的活动，但我们正在降低生成令人信服的文本的成本。如果你在想“嗯，这听起来非常无聊”，那么你真的错过了经济学是多么神奇(我曾经认为经济学就像商业、金钱和其他东西一样。男孩是我错了，经济学是最酷的科学之一。通过降低产品成本，你有时可以让全新的行业和应用变得可行。举个明显的例子，电脑。原则上，你可以在一台 20 世纪 80 年代的计算机上完成任何你现在能做的计算，如果你把它造得足够大并且等得足够久的话。但是在实践中，对于我们现在认为是常规的许多应用程序来说，成本(金钱和时间)将是天文数字。有一种趋势是软件增长似乎跟随硬件增长；随着硬件变得更快，新型算法成为可能。但是经济学家听到的不是“更快”，他听到的是更便宜。

所以，假设，GPT2 可以代表一种分水岭时刻，在这一时刻，它降低了生产文本的成本，以至于可以进行某种新的恶意活动。我明白这个论点的意思，但我认为问题出在细节上。

为了解释我的推理，我们将不得不再往后退步。请容忍我对这个问题极其吹毛求疵的解构，我认为它引导我们得出一个有趣的结论。

第二部分:计数意识

为什么“防御”一定会失败，而且可能是弊大于利

我想澄清一点:我非常重视人工智能的安全(尽管有一些警告，我将在第 3 部分讨论)。我来自 MIRI 学派，认为人工智能及其安全使用是我们这个时代最重要的问题。但是，与 MIRI 类似，我对这个话题的想法与许多主流观点有点不同。(澄清一下:我与 MIRI 没有任何关系，尽管我希望如此)

话虽如此，我认为很多关于 GPT2 的想法不幸地被我们当前的政治迷因圈毒害了。我保证，这不是一篇政治文章，但我确实相信“假新闻”这个词在这一点上已经变成了一个迷因。我并不否认假新闻的存在或危险，但我觉得这个词已经变得如此模糊和政治化，以至于人们并不总是充分考虑假新闻实际上是什么，它的威胁有多大，以及如何有效地打击它。

真的可以推荐这个系列的迷你纪录片的题目。他们真的做得很好，事实上立陶宛有一支对抗巨魔的“精灵”军队是我很久以来听到的最令人惊讶的事情。

假新闻是真实的，无处不在的，潜在的危害非常大。最肯定不是假新闻的是新。

每一代人都有一种倾向，认为一切都比过去糟糕得多，如果一个人真的读一点历史，这很快就会成为大多数人持有的最荒谬的信念之一。我强烈推荐史蒂芬·平克的《我们本性中更好的天使》和《现在的启蒙》以及汉斯·罗斯林的《真实》这两本书，让你领略一下如今的事物是多么令人惊讶的美好，以及这个世界在很多方面曾经是多么不可思议的地狱。

很多人对假新闻的看法也属于这一类。是的，有人认为疫苗会导致自闭症。是的，有人认为世界是平的。是的，有些人持有更危险的观点。是的，他们经常从互联网上获得这些奇怪的，有时甚至是危险的想法。

但是你见过前现代时代吗？

是的，让你所有关于世界的新闻远离你的政治化的脸书信息并不好。你知道什么更糟吗？从你当地的宗教官员那里获得你对政治、物理、生物、经济和该烧死谁的看法。在人类历史的大部分时间里，这是的默认设置。比起西班牙宗教裁判所，我更想要平土器，非常感谢(没想到会在这个帖子里看到它们吧？).

“好吧”，你可能会想，“当然，很好。但是我们可以做得更好！我们仍然需要反对虚假，即使它没有过去那么坏。”这一点我完全同意。我不是说我们不应该反对虚假，实际上恰恰相反。

最近，OpenAI 发布了一个来自 GPT2 的样本输出的数据集,目的是帮助开发反措施来检测这种虚假文本。我认为这不仅是被误导的，而且是完全危险的。原因很简单:

真理不是免费的。

不仅不是免费的，真理是昂贵的。找出这个世界的真相需要做很多工作。如果你想知道某件事的真相，你将不得不投入工作去寻找真相，这是没有办法的。

好吧，有一种可能的解决方法，这就是为什么我们人类在成就上比这个星球上的其他生物成功得多的根本原因。

最有价值的商品

给我出个谜题:人类经济中最有价值的商品是什么？

如果你想到“钱”或“石油”，我会说你想得不够抽象。不，我认为正确答案是“信任”。

什么使人类不同于其他动物？为什么我们可以通过在海洋下面发射激光束，将宇宙飞船送上月球，并与地球另一边的人通话？显而易见的答案是“智力”，但我认为智力只是故事的一部分。把有史以来最聪明的人，或者说是他们的新生克隆体，放在一个山洞里。没有教育，没有语言，什么都没有。现在让他们尝试发明工业技术。你将会等待很长时间的。

不，智力是一个更强大的因素:合作。通过共同努力，人类能够实现对个人来说完全不可能实现的体力和智力的壮举。想象一个人类从未一起工作过的世界。几代人都不会积累知识。每当有人想出一些有用的东西，下一代就会忘记它，不得不从头开始。有些世代和个人会过得更好，有些不会，但总体而言绝对不会有任何改变，不会有任何进步。这基本上是黑猩猩的状态。

但是人类发明了一些强大的东西，信任和与完全陌生的人合作的能力。最终，我们人类的成功在于通过这些广泛的互动积累了越来越多有用的文化知识。我可以就此长篇大论，但你应该读读尤瓦尔·赫拉利的《智人》和《德乌斯人》，丹尼尔·丹尼特的《从细菌到巴赫，再回来》，以及其他更好的相关论文。

对于我们的讨论来说，重要的是:一条信息的危险和/或有用程度取决于我们对它的信任程度。

如果每个人一看到假新闻就立刻认出来，只是不相信它，除了它阻塞带宽之外，就不会有来自它的威胁。但是我们已经确定这不可能这么容易。如果你能立即发现任何谎言，这意味着你是无所不知的，而你(可能)不是。

所以我们来谈谈我的观点:我认为检测假新闻、仇恨言论或其他东西的方法是危险的，至少在目前处理它们的方式上是如此。我认为原因既微妙又明显:如果我们有一个系统负责检测我们能信任什么和不能信任什么，我们并没有消除我们投资信任的需要，我们只是将我们的信任从我们自己的官能转移到机器的官能。(我想大声说出布鲁斯·施奈尔的这篇非凡文章，它帮助我得出了这个结论)

如果我给你一篇文章，却完全不告诉你它来自哪里，你怎么知道它是否可信？这很棘手，你必须阅读它，考虑它如何符合你现有的知识，你如何能找到更多来验证这些说法等等。你对什么该相信的信任分配取决于你大脑和经历中内置的狗屁检测算法。

假设我给你一篇纽约时报的文章。那是另一回事了，对吧？《纽约时报》是一个非常著名的信息来源，所以即使它包含一些你通常会怀疑的信息，你可能会更倾向于更新你的信念，因为你知道你可以信任这个来源。

但是我们为什么要相信《纽约时报》？因为纽约时报是由人类组成的，他们用大脑来做这些检测算法试图做的事情:检测糟糕的故事，找到真相。你可以把《纽约时报》视为一个巨大的、混合生物合成的过滤算法，它接收关于世界的信息，其中大部分是噪音，一些是故意误导，并提取有价值的(希望是)真实的信息供你消费。

理论上，我认为不需要人工干预的算法的存在没有问题。人类和其他人一样是机器，而也有偏见，所以没有理由不存在一种在生成真理方面更好的人工智能算法。但是我们最好确信它确实更好。我认为没有任何现有的技术可以超越人类在这方面的能力，即使他们有偏见。目前的人工智能实际上仍然无法区分相关性和因果性，我们希望和能够判断我们看到的信息？这事不会有好结果的。

我们必须跟踪我们的信任在哪里。因为我们不能不信任，我们必须信任一些东西，我们只需要尽最大努力去信任正确的东西。如果我们使用当前类型的算法来尝试和“防御”GPT2 这样的“威胁”，我认为我们将会弊大于利。因为他们不仅无法认识和管理真相，还有一个更深刻、更令人不安的问题…

令人不安的真相:胡言乱语者

我花了相当多的时间玩人工智能。探测他们的输出，查看他们的数据集，调整参数，诸如此类的事情。自从 GPT2 问世以来，我花了很多时间研究文本生成人工智能。我记得有一天下午，我和一个朋友出去玩，我们在看一些我们在互联网上找到的数据集，我们也许可以在这些数据集上训练我们的下一个人工智能。我们无意中发现了一个“有毒评论”的数据集，并对其进行了深入研究。读了一会儿后，我的朋友问了一个比我认为我们当时意识到的更深刻的问题:

"等等，这些是人工智能生成的，对吗？"

不，他们不是。这些是真实的，人类的评论。但是当我看着他们的时候，我突然想到了一件事。你知道有时候你会觉得某人脑子里什么都没有吗？话从他们嘴里说出来，却没有理解？他们组成完整的句子，表达思想和愿望，但他们只是看起来…像一个僵尸，不受理性的影响。可能你现在正在考虑一些政治对手，因为你自己的人类偏见。现在不要觉得自己太趾高气扬，因为我可以保证你也曾经是那个空虚的人。但是看到这些文本和 GPT2，我终于有了一个具体的例子来描述这种感觉。这些评论，这些人，他们听起来像 GPT2！就像单词和句子的简单统计连接！

一如既往地走在我前面，我发现罗宾·汉森(Robin Hanson)已经写了关于这个确切主题的文章，并将这种现象称为“胡言乱语”。我强烈建议你在这里停下来看看他的博客文章，它不是很长。完成了吗？很好。(莎拉·康斯坦丁在她的非常有趣的博客文章中详细阐述了这个问题)

那么这意味着什么呢？这意味着，据我所知，人工智能无法生成连贯、真实的文本。但是 AI 现在能做的，是咿呀学语。牙牙学语不仅仅是人类交流的一个小部分。我认为有一个强有力的证据表明我们大部分的交流都是在胡言乱语。想想闲聊或学校论文。尽管我认为它比那要深刻得多。

而那个对我们的对话又意味着什么呢？这意味着，即使我们有一个系统可以完美地检测人工智能产生的咿呀学语并部署它，它也不仅仅会审查人工智能，还会审查大量真实的人类交流。我们喜欢认为我们在某种程度上与机器和计算机有着本质的不同，但事实并非如此。GPT2 以另一种新的方式展示了这一点。

我们该拿咿呀学语怎么办？

好了，我们已经建立了一个框架来理解我们现在的处境。

我们有人工智能能够做一些与人类“咿呀学语”行为非常相似或相同的事情，而且它们只会从这里变得更好。精灵从瓶子里出来了。
我们想要改善，或者至少保持，在一个有这些人工喋喋不休者的世界里，我们在线互动的质量。

很明显，我们希望从我们的平台上消除低质量的胡言乱语。在我看来，人们可以沿着两条轴线来识别这种胡言乱语:胡言乱语本身的内容，或者它的来源。

让我们来看看 babble 的内容。理论上，我们可以开发方法来检测胡言乱语，然后过滤掉它，就像我们处理垃圾邮件一样。但我在这一部分试图说明的要点是，这是行不通的，因为与垃圾邮件不同，区分人工智能咿呀学语和人类咿呀学语的不仅仅是风格，而是内容及其真实值。只要我们没有能够自动检测政治主张是否真实的系统，这就行不通。我们无论如何都可以过滤，而且，你知道，也许这并不是那么糟糕，如果它过滤的都是低质量的交互，不管它们是来自人工智能还是人类。但我对此表示怀疑。我认为咿呀学语和高层次思想之间的界限是模糊的，仅仅从一段文字中是很难发现的。因此，如果我们过滤胡言乱语，我们就过滤了许多真实的、高质量的人类互动，创造了一个由不透明算法的难以理解的偏好设计的怪异的人工环境。呀。

另一边呢，源头？好吧，如果一个新的帖子到达我们的网络服务器，我们立即知道它是由人工智能生成的，我们可以简单地否认它，我们很好！但是当然，这是行不通的，因为我们实际上无法知道一段给定文本的来源。它只是一个浮动的数据块，没有附加作者身份(通常)。即使是，我们怎么知道作者数据是真实的？

假新闻如此容易迷惑我们的一个重要原因是，我们的思维是在这样一种环境中进化的，在这种环境中，高水平、基于语言的信息的唯一来源是其他人。尽管有相反的说法，但没有会说话的动物、精灵或石头(不幸的是)。这意味着我们的大脑中有一种本能，当我们看到文本或讲话时，我们知道它是由人类发出的，这决定了我们如何信任这些信息。

但我们不是白痴，我们知道人类可以撒谎和操纵，所以并不是说由另一个人创造的东西会让我们立即相信它。你不相信某个陌生人走到你面前，提出疯狂的要求，是因为说谎的代价很低。宣称月球不存在基本上不花我一分钱(哈，那些登月怀疑论者，居然相信月球存在，真是一群绵羊！).这种说法是真的吗？我把这作为一个练习留给读者。

但是有些关于人类工作本质的东西并不便宜。例如，虽然我很容易声称月亮不是真的，但让 1000 个人声称月亮不是真的对我来说就很难了(尽管没有我希望的那么难)。所以如果你只听到我说月亮不是真的，你不会让我多想。但是如果有 1000 个人来认领呢？如果你全家都认领了呢？如果整个世界和所有的科学家都宣称它是自己的呢？如果这是真的，相信月亮是真的将是愚蠢的事情！

从众会招致很多憎恨，这是理所当然的。但它的存在是有原因的。因为让我们人类如此强大的是合作，而合作的一部分就是承认你可能是错的。如果大量的人，他们中的许多人可能比你我更有资格，声称某事，不改变你的观点将是不理智的，除非你有一些真正该死的非凡的证据。

生物区块链

这就是事情变得奇怪的地方(至少比我已经做出的更奇怪)。

这整个想法之所以可行，基本上是因为一个原因:制造更多的人类并让他们相信某件事是昂贵的。在某种程度上，人类的繁殖和成熟时间与比特币的工作证明算法实现了相同的目的。

让我继续(另一个)小话题来解释一些关于区块链和分布式信任的事情。

假设有一天，一个朋友走过来对我说“我在 PayPal 上给你汇了 100 美元”。我如何知道我是否真的收到了钱？好吧，简单，我检查贝宝，相信他们告诉我的。PayPal 是集中信任的一个例子。我相信 PayPal 会处理一切事情，以确保交易存在并确实有效(我的朋友是否有足够的钱汇给我，他们是否真的汇了钱，各种反欺诈措施等)。因此，当我登录我的 PayPal 帐户，看到我的朋友寄来的 100 美元时，我们可以同意这是一笔真实发生的合法交易。

但是这个系统有一个主要的失败点:PayPal 本身。没有技术上的原因，一个流氓员工(也许是朋友自己)不能在 PayPal 的数据库中编辑一些行，给我多 100 美元，尽管他们从来没有发送过。这意味着数据库现在处于“不一致”的状态，因为现在系统中的钱比投入的多，这可能不是我们想要的。但是理论上 PayPal 可以对他们的数据库做任何他们想做的事情，不管是否一致(至少在联邦政府出现之前，或者客户完全失去信任之前)。

那么，有没有什么方法可以避免有一个你必须信任的中心的、易出错的实体呢？我想澄清的是不存在完全不可信的系统(正如布鲁斯·施奈尔等人长期以来一直在说的)。但有一种东西叫做分布式信任，比特币等加密货币就是其中最显著的例子。

它的工作方式基本上是这样的:我们有(a)某种人人都能看到的共享信息库(“区块链”)。这和站在公共广场上与人交谈没有太大区别。信息是可以交换的，但是制造假信息还是很便宜的。区块链的特别之处在于(b) 以不受欢迎的方式修改它们是非常非常昂贵的(或者是不可能的)。这通常通过一种叫做“工作证明”的方法来完成。基本上，像比特币这样的加密货币使用非常聪明的算法来迫使用户创建一个“证明”，证明他们已经花费了一定的计算量。只有使用这样的(一次性使用)证明，您才能以有限的方式修改区块链。即使是这种有限的编辑，也只有在其他人检查并验证它是真实的情况下才会被接受。这使得以对你不公平有利的方式可靠地编辑区块链(比如给你自己比应该有的更多的钱)是极其昂贵的，以至于不值得或者实际上不可能。实际上并非不可能，只是足够接近而已(你需要运行比特币的所有计算的 50%以上的计算能力，这并非不可能，但仍然是一项几乎难以理解的昂贵努力)。

这样做的结果是，你可以相信比特币区块链，只要你不相信任何人拥有篡改它所必需的超级强大的计算能力(并且代码没有任何致命的错误)。总的来说，这是一个非常合理的假设。因此，相信比特币区块链是有道理的。

这很重要的原因是人类物种形成了一种生物区块链。可信信息就像区块链上的交易。只有当相当一部分管理区块链的人同意它们是有效的，它们才会被认为是真实的。人类以同样的方式工作。一旦大量的人接受了新的信息，我们就把事情当作“常识”和“真理”来接受(这不是我们发现真理的唯一途径，但却是重要的途径)。当然，它比漂亮、干净、数学上精确的区块链要复杂得多，但原理是一样的。

我们有 a)一个以我们共同信念为形式的公共数据仓库，和 b)一种使其难以篡改的方法:你需要让很多人接受和传播你的新信息。这很难的原因是因为有一个固有的限制，那就是有多少人，你能多容易接近并说服他们。请记住:

“你可以一时愚弄所有的人，也可以永远愚弄一些人，但你不可能永远愚弄所有的人。”—亚伯拉罕·林肯

连林肯都理解生物区块链的概念！对于我们的大脑来说，将“很多人相信 X”与“X 一定是真的”联系起来是完全符合生物学意义的。如果我想让我的石器时代部落相信我的新奇想法，那是难，是昂贵。一点也不像胡乱宣称！如果我成功了，这是一个可靠的迹象，表明我的想法已经通过了审查，至少通过了一些合理的审查。同样，这种方法并不完美，但它比什么都没有好得多(回想一下黑猩猩)。

破坏生物区块链

最后，这让我明白了我的观点:这就是为什么假新闻是危险的。

我发现自己一直在这样做:我读了一些我不太了解的 reddit 标题，读了下面的一两条评论，本能地，不加思考地，我相信那些评论说的是真的。我真诚地训练自己注意到这种情况的发生，并试图摆脱它，但这很难。这是我们大脑的一个内置系统，是我们人类思考的方式。而这样想是有道理的。看着那些顶部的评论，我的大脑看到了语音，这意味着它是由真正的人类用真正的人类大脑创造的，不仅如此，它们还有大量的赞成票，这意味着许多其他真正的人类相信这一点！此外，正如丹尼尔·卡内曼(认知偏差研究之父)所说，“所见即所得”。我的大脑看到大量我的人类同胞向生物区块链提交了一条信息，而没有其他信息，所以我认为它是可信的。

一般来说，即使在互联网上，这也不算太坏。投票最高的评论通常更好(尽管到目前为止并不总是如此)。但是这个系统会在几个方面崩溃，我相信你能想到其中的许多(例如愤怒的信息如何传播超过它们的质量优点)，但是现在让我们只关注与我们的讨论最相关的一个。

我感兴趣的失败模式是互联网使之达到全新程度的模式:当且仅当我们的“工作证明”成立时，这种相信“流行”事物的整个启发才有效，这意味着“让”更多的人相信我们的东西是昂贵的。但是随着大众媒体的出现，至少可以追溯到印刷术的发明和互联网的进一步发展，这一点不再那么明确了。

原因是，正如我们之前讨论的，我们(通常)根本看不到一条信息的来源。因此，相反，如果我们想判断是否将我们的生物区块链启发式方法应用于这条新信息，我们首先使用一些方法来尝试和确定来源是否是一个真实的人(这是我们将这条新信息添加到生物区块链的要求)。我们最古老的方法很简单:“如果是演讲/写作，那就是人类”。在历史上的大部分时间里，这种方式运转得非常好。如果我听到你告诉我什么，我就能确定它的来源。甚至在书写被发明之后，我知道书写只能由另一个人产生(尽管是一个有偏见的人类样本，因为很少有人会写)。

自从印刷术被发明以来，这种基本的启发就已经土崩瓦解了(并且在书写发明之后已经被破坏了)，因为现在一小部分人就可以生产大量的文本，如果由真正的人手工制作，将需要一支军队。随着文字制作成本的下降，文字的来源越来越不可靠。而且这种趋势还在继续。录音降低了演讲的成本和价值，录像降低了视力。互联网使这些成本进一步下降。

拿简单的文字来说。如果是在中世纪，我得到了来自不同人的 100 个手写签名来支持我的观点，这意味着很多。但是如果我给你一个没有标记的 100 个名字的网页，你会相信我的观点吗？希望不会。自从互联网诞生以来，人们就已经意识到生成文本是极其廉价的。

所以，作为聪明的猿类，我们开始研究对策。其中一些，如垃圾邮件过滤器，是基于过滤内容，因为虽然生产简单的文本是便宜的，但生产高质量(甚至 babbler 质量)的文本仍然是昂贵的。相反，其他方法试图识别来源是否是人类，例如 CAPTCHA，它在许多情况下工作得相当好，尽管机器人有许多方法来逃避它，有时它也有一些其他类型的问题。

这意味着，在大多数情况下，如果我们看到一段有点连贯、复杂的文本，仍然有理由假设它是由人类生成的，并让其内容影响我们的生物区块链。

这是我的核心论点:多年来，我们认为可以接受的证据影响我们生物区块链的标准一直在稳步上升，GPT2 代表了这一标准的最新上升，标志着我们再也不能相信“胡言乱语”级别的文本。****

现在我认为有一个强有力的论点，那就是我们很久以前就已经超越了这一点，基本上是自从书面宣传的概念被发明以来。但 GPT2 是 babbler 级别文本生成的时刻，其成本已经降至基本为零，就像十年或二十年前互联网是廉价和低质量的垃圾邮件。(对于那些好奇的人来说，这里有一个关于垃圾邮件的非常有趣的 Defcon 演示)

我们能做些什么吗？我认为没有简单的解决办法。我认为我们已经到了这样一个地步，一般来说，不再可能确定一个给定的文本是否是人类生成的。但我认为这根本不是一个单一的“点”，而是一个光谱，从 90 年代最简单的垃圾邮件到今天的 GPT2，再到谁知道明天会发生什么。

我认为这是一个本质上很难解决的问题。我们想做什么，给每个人一个“意识许可证”,让他们在写评论时展示出来？老实说，我认为这将提高我们生物区块链的质量，但我不应该拼写出赛博朋克反乌托邦的含义。我们目前拥有的最好的工具仍然是人脑。我们应该把重点放在教育人类了解他们自身偏见的现实，以及信息是如何在互联网和其他地方产生的。

我真的认为，如果人们知道像 GPT2 这样的东西存在，并且就在外面，这将迫使他们提高他们信任什么信息的标准。垃圾邮件也是如此。当尼日利亚王子和其他类似可笑的原始骗局第一次出现时，他们成功了。计算机病毒也是如此。许多第一批病毒之所以有效，是因为没有人想到一个文件可能是恶意的。为什么安全研究人员会侵入系统并暴露其缺陷？因为这是让人们倾听的唯一方法，所以你必须证明你的威胁确实存在(即便如此，任何安全专家或气候活动家都可以告诉你许多故事，说明有多少人仍然没有足够认真地对待风险)。人们只有在知道威胁是真实存在的时候才会产生抵触情绪。

这就是为什么我计划在 7 月 1 日向公众发布 15 亿美元。我在等待，因为我想给人们时间来说服我，如果我错过了什么，我是错的。因为假装这些东西不存在或“只在像 OpenAI 这样的好人手中”是一个被比 OpenAI 或我更不友好的秘密团体滥用的处方。我认为我们应该尽可能广泛地宣传 GPT2 和其他咿呀学语方法的存在，它们掌握在许多人手中，就像垃圾邮件和病毒一样，我们需要适应。

你不能把精灵放回瓶子里。

把这一切结合在一起:GPT2，咿呀学语和信任

所以，最后，我们在这里，与我的主要论点。概括一下:

目前的人工智能无法生成有价值的真实文本，但它们可以胡言乱语。
很大一部分真实的人类互动是咿呀学语。
目前的技术无法检测或产生真相。

我从这些争论中得出的结论是:

GPT2 并不是唯一危险的，而是不可避免趋势的最新一步。它可能会也可能不会降低生成可信文本的成本，但强大的组织已经可以通过人类和其他算法产生大量更好的内容，而且 GPT2 也不是他们力所不及的。
对抗低质量的胡言乱语，无论人工智能是否产生，现在和将来都是至关重要的，但我认为将信任转移到明显有缺陷的“反胡言乱语”算法是错误的做法。有一天，值得我们信任的系统将会存在。今天不是那一天。
我们不应该训练人们依赖有缺陷的算法，而是应该帮助他们找到正确的信任点，首先是通过训练他们自己的批判性思维技能。人类大脑目前仍然是我们所知的最强大的真相生成机器。
为了促进人类适应，我认为这些方法应该尽可能广泛地传播，这样就没有人能躲在虚假的安全感后面。为了推进这一点(并把我的钱用在我的嘴上)，我计划向公众发布 1.5B。

这是我的论点和这篇文章的核心。这是与 GPT2 及其后果直接相关的部分，但我还有一点我认为值得讨论的。这基本上是一个独立的话题，但我认为它为我们当前的讨论增添了一些内容。

第 3 部分:好奇的黑客

****黑客【原来是用斧头制作家具的人】n.
1。一个喜欢学习编程系统的细节以及如何扩展他们的能力的人，与大多数用户只喜欢学习最少的必要知识相反。
2。热衷于编程的人，或者喜欢编程而不仅仅是编程理论的人。
3。一个能够欣赏黑客价值的人。
4。擅长快速编程的人。并不是黑客制造的所有东西都是黑客。
5。某一特定程序的专家，或经常使用或研究该程序的人；例如:“一个赛尔号黑客”。(定义 1 到 5 是相关的，符合的人聚集在一起。)
6。一个恶意的或好奇的爱管闲事的人，试图通过四处打探来发现信息。于是有了“密码黑客”、“网络黑客”。

——黑客字典(https://www.dourish.com/goodies/jargon.html)

在这篇文章中，我试图把我的人排除在外，因为我认为我是谁对我的核心观点并不重要(希望这些观点仅仅基于他们的客观论点)。但对于这第三部分，我想谈谈一个似乎有点不相关的话题:我称之为“好奇的黑客”的心理学(我可能会称之为“黑客”，但不幸的是，这个词有许多负面含义)。

对一些人来说，我做了这一切，创造了一个“危险的”人工智能，但没有给自己带来任何经济利益(恰恰相反，这让我花费了大量的时间和精力，而这些时间和精力本可以花在更直接的事情上)，然后想把它发布给公众，这是令人困惑的。对于我期望阅读这篇文章的许多人来说，我希望他们认为我这样做的原因是显而易见和可以理解的。那是因为他们和我一样，是好奇的黑客。

但对许多人来说，像我这样的人的想法很奇怪，他们不理解我们为什么要做这些事情。这不是因为他们不能或不想。很难理解那些和你习惯的想法不同的人和你自己以及你的同事。但我认为好奇的黑客在我们的生活中是一个非常重要的因素，即使我们可能没有意识到这一点，我认为理解他们的心理对于理解我们的世界以及如何处理出现的问题是非常必要的。

所以我想邀请你们进入我的思维，来理解我为什么做我正在做的事情，为什么我认为有像我一样的人更重要，为什么理解这些人是至关重要的。

是什么让好奇的黑客？

200 小时的工作。这大约是我对这个项目投资的估计。现在，并不是所有这些都是高质量的工作，很多都是盯着充满数字的黑屏等待事情发生，但很多都是硬核，每天 8 个多小时编码和阅读科学论文。我一分钱也没得到。没有人告诉我这样做，没有人支持我这样做(除了通过硬件谷歌)，我可以花时间和我的朋友在一起，或者为大学学习，或者做任何其他事情。

那么，如果不是为了利润或者是因为别人让我这么做，我为什么要这么做呢？我想说的是，正是出于第二部分提到的所有原因，我有了这个伟大的哲学/道德准则，我准确无误地遵循着这个最终目标，推进我所相信的真实和正确。我认为许多和我相似的人试图为他们自己的项目传递这种信息，他们的行为是经过深思熟虑的，事先有负责任的判断。但事实并非如此(至少通常对我来说是这样)。

我这么做是因为，该死的，这太酷了！

我认为这是好奇黑客的典型特征。我做疯狂的事情，通常很难，也没有明确的回报，因为它们很酷(就我个人而言，甚至更多，因为它们很有趣)。好奇的黑客做事情，因为他们可以。我(和像我一样的人)在做困难的事情时有一种内在的快乐，不是因为它们容易，而是因为它们很难(尽管有些人走得太远了)。

GPT2 不仅非常酷，而且非常有趣，对我来说是不可抗拒的。再加上一些你不应该做的事情的神秘性，好奇的黑客就像鱼一样上钩了。是因素的完美风暴让我这样的人痴迷。

好奇的黑客很重要

好奇的黑客喜欢玩。他们喜欢把坚硬复杂的东西拿来修补，打碎，再重新组装。像我这样有科学或数学问题的人就像一只拿着毛线球的猫。我们喜欢这样做。(你认为科学家为什么会接受他们经常忍受的恶劣工作条件？)

我并不孤单。这种好奇心、游戏性和对解决问题的痴迷的混合是一种强有力的性格特征鸡尾酒，你在一种非常特殊的人身上反复看到:科学家。

我只是一个无名小卒，但是像莱纳斯·托沃兹、阿尔伯特·爱因斯坦和理查德·费曼这样的人呢？(或者更直接地说，像比尔·盖茨、拉里·佩奇和史蒂夫·沃兹尼亚克这样的人)如果你读到任何关于他们个性的东西，你会很快被他们身上有多少好奇的黑客特质所震惊。爱因斯坦是如何提出他著名的狭义相对论的？当他 16 岁时，他试图想象骑着一束光会是什么样子。没有人付钱给他，他只是在玩弄一个巧妙的想法。

学术界以外的一些人想象科学家是非常刻板、正式的人，研究按照非常正式的时间表进行(是的，对我的学术和技术读者来说，我知道这种想法对你来说很奇怪，但许多人确实相信这一点，研究对许多人来说是一个陌生的世界)。有时这是真的，但是，通常情况下，没有什么比这更偏离事实了。最好的科学家是有创造力的，好奇的，而且通常是古怪的。当你听到科学家解释他们为什么进入科学领域，或者他们如何想出他们最伟大的想法时，你会一次又一次地看到这一点:他们更多地遵循内在的好奇心，而不是任何外在的激励因素。太疯狂了，我们这个时代有多少绝对重要的技术仅仅是因为某个家伙曾经在实验室里摆弄过什么东西而产生的。请记住:

***“闲逛和科学的唯一区别是把它写下来”

亚历克斯·杰森***

我们要感谢好奇的黑客们发明了现代物理学、计算机、互联网，谁知道我们的现代世界还有多少。这些人很重要，他们有所作为，这就是为什么我认为理解他们的心理很重要，同样理解政治领导人的个性也很重要(这往往与 T4 大相径庭)。

但是，我也认为另一个原因很重要:因为当这些看起来非常积极和友善的个性变得危险时。

黑客的阴暗面

好奇的黑客创造了互联网，好奇的黑客创造了许多伟大的东西。现在我讨厌成为那个在谈论 AI 时总是去这个地方的家伙，但是你知道什么是肯定是由好奇的黑客制造的吗？核弹。****

费曼在他的书《费曼先生，你肯定是在开玩笑吧》中描述了他在曼哈顿计划中的经历，读起来就像是一个民族讽刺电影剧本。他对他的科学家同事搞恶作剧，和行政部门闹得不可开交，经历各种各样的可怕事情。我记得当我十几岁的时候第一次读到它的时候，我所能想到的就是“天哪，这听起来很有趣！”。不仅仅是费曼，许多科学家也有类似的曼哈顿计划的故事(尽管不那么边缘漫画化)。而我完全明白为什么。你可以从事你那个时代最酷、最疯狂的技术，基本上没有任何限制，没有预算限制，周围都是你这一代最聪明、最酷的人。对我来说，那听起来像天堂。**

但是后来，1945 年 7 月 16 日。关于这如何影响目睹它的科学家有多种说法，对许多人来说，这是一个突然的、黎明的恐怖。

“我们做了什么？”

罗伯特·奥本海默(Robert Oppenheimer)的一句令人心寒的话完美地说明了这一点，这句话似乎是令人心寒的话的无穷来源:

“当你看到一些技术上很好的东西时，你就去做，只有在你取得技术上的成功后，你才会争论该怎么办。原子弹就是这样。”罗伯特·奥本海默

这就是为什么理解好奇的黑客是如何工作的，即使(或特别是如果)你是一个如此重要。

在很大程度上，好奇的黑客是你见过的最好、最善良的人。曼哈顿计划中肯定有很多鹰派，但你只需要看看有多少前曼哈顿科学家最终成为最直言不讳的反核活动人士，就能明白事情变得如此糟糕。

我可能是你能想象到的最善良、最有意图的人之一。我不想伤害任何人，从来没有。这会让你产生一种虚假的安全感。“我不想伤害任何人，所以我不会那么做，简单！我是个好人，我绝不会做坏事。我的行为永远不会对他人构成威胁。”

但是许多好奇的黑客，包括我自己，不管是好是坏，经常成为他们好奇心的奴隶。有时候，在狂热地研究我最新的令人厌恶的人工智能(相信我，GPT2 不是我最古怪的项目)时，我会暂停一会儿，耳机里传来赛博朋克合成音乐，我会问自己:“我是黑镜角色吗？”

你可以想象得到，我是反战的，支持人类的，但是如果我生活在 40 年代，美国邀请我研究原子弹……我不知道我是否会拒绝。

不是因为我想伤害别人，这是了解好奇黑客的重要一点，而是因为它实在是太他妈酷了。分裂物质本身的基本构件来制造大爆炸？那就是他妈的牛逼！**

如果好奇心真的能杀死猫，那么，嗯……喵**

拥抱好奇的黑客

现在会有很多非常严肃的人读到这里，嘲笑以高人一等的姿态被解雇，他们会说:“所以你说的是你在用一个可爱的标签来合理化你残酷、自私的本性？就是不要做那些坏事！”**

这只不过是一个掌声灯，意味着听起来明智和伟大，让每个人点头同意和鼓掌，但缺乏任何实际有用的贡献。我的全部观点是，是的，有坏人出于坏的原因做坏事，而且关于这种危险行为已经说了很多。但是好奇的黑客不是那种典型，他们出于不同的原因做危险的事情。我们在媒体上看到了大量导致危险行为(贪婪、虐待狂等)的“传统”人格特征的描述，但我认为对危险的来源，即好奇的黑客原型关注太少。(来自漫威电影宇宙的托尼·斯塔克是一个明显的例外。当我表达我完全理解托尼为什么在《复仇者联盟 2》中塑造奥创时，我经常受到奇怪的目光。很多人觉得他在那部电影中的行为完全是愚蠢和不可理解的)每个人都明白坏人做坏事，但我们很难把握好人是如何被引导去做坏事的(即使如此也可以说是现实世界中的默认案例)。

我们冒着风险避开好奇的黑客。因为人们犯的错误而妖魔化他们，尤其是聪明和善意的人，是非常短视的。好奇的黑客已经给了我们许多现代世界所能提供的最好的东西，他们将继续这样做。因为他们不能停下来，他们知道他们不能。

与其将此视为对好奇的黑客的批评，我希望这是对理解和自我完善的呼吁。我们，不管是不是好奇的黑客，都需要理解这个原型的光明面和黑暗面。我们在硅谷看到的这么多问题是因为它基本上成了好奇的黑客的飞地，一个数字化的 21 世纪曼哈顿项目(对我来说，这听起来又像是天堂)。

对于那些不好奇的黑客，我想让你了解他们的思维方式。当然也有例外，但一般来说，好奇的黑客都不是坏人。他们通常是最理想主义和最善良的人。正如尤瓦尔·赫拉利(一位著名的硅谷评论家)所说:

***“我见过许多这样的高科技巨头，他们通常都是好人。他们不是匈奴人阿提拉。在人类领袖的抽签中，你可能会变得更糟。”

尤瓦尔·赫拉利***

好奇的黑客会做坏事，做危险的事，但我们都一样。通过相互理解，我们可以原谅，并找到改进的方法。

对于那些好奇的黑客来说，我的信息很简单:注意你的阴暗面。你可能不会觉得自己做了什么坏事，我相信你。我相信你只是出于好玩的好奇心和对人类乐观的希望。怎么会有比这更纯洁的东西呢？但是历史给了我们一个清晰的教训。直到 2014 年，几乎连 AI 安全都没人当回事。许多人仍然不这么认为，尽管只需一次斯图亚特·罗素的演讲就能推翻大多数反驳。我们需要变得更好。

我们需要的不是回避好奇的黑客，而是拥抱他们。我们需要利用他们所能利用的一切优势，并找到负责任的方式来管理风险。

所以我也在努力改进，尽我所能。我可以直接把 15 亿美元扔到网上。我想。当我第一次读到 OpenAI 没有发布 1.5B 时，我非常恼火。信息要免费，妈的，我要看！但是一旦我有了精灵，我就慢慢来了。在把它从瓶子里放出来之前，我想了想我想做什么。我仍然得出结论，我想让它出来，但现在我这样做是有原因的，而不仅仅是因为它很酷。这也是为什么我等了更长时间才发布，因为我足够谦虚地意识到，也许我在逻辑上犯了一个可怕的错误，我根本不应该发布它。我已经接受了自己的阴暗面，并尽我所能负责任地处理它。我认为这很好，因为这仍然是低风险，没有人会死于 GPT2(可能)。但是，十年或二十年后，当我拿到博士学位，新的曼哈顿计划来敲门时，会发生什么呢？

我希望我已经吸取了教训。

如果你喜欢你所读的，继续阅读第二部分和。****

GPU 加速数据分析和机器学习

原文：https://towardsdatascience.com/gpu-accelerated-data-analytics-machine-learning-963aebe956ce?source=collection_archive---------9-----------------------

未来就在这里！使用 Python RAPIDS 库支持加速您的机器学习工作流。

(Source: https://res.infoq.com/news/2018/10/Nvidia-keynote-gtc/en/resources/1BFA0900F-5083-497B-8275-B80D87C9CFF8-1539179054604.jpeg)

介绍

GPU 加速如今变得越来越重要。这一转变的两个主要驱动因素是:

世界上的数据量每年都在翻倍[1]。
由于量子领域的限制，摩尔定律现在即将结束。

作为这种转变的一个证明，越来越多的在线数据科学平台正在添加支持 GPU 的解决方案。一些例子是:Kaggle，谷歌合作实验室，微软 Azure 和亚马逊网络服务(AWS)。

在本文中，我将首先向您介绍 NVIDIA 开源 Python RAPIDS 库，然后向您展示 RAPIDS 如何将数据分析速度提高 50 倍。

本文使用的所有代码都可以在我的 GitHub 和 Google 联合实验室上找到，供您使用。

湍流

在过去的几年中，为了处理大量的数据，已经提出了许多解决方案。一些例子是 MapReduce、Hadoop 和 Spark 。

RAPIDS 现在被设计成数据处理的下一个发展阶段。由于其 Apache Arrow 内存格式，与 Spark 内存处理相比，RAPIDS 的速度提高了大约 50 倍(图 1)。此外，它还能够从一个 GPU 扩展到多个 GPU[3]。

所有的 RAPIDS 库都是基于 Python 的，并且被设计成拥有 Pandas 和 Sklearn 这样的接口来促进采用。

Figure 1: Data Processing Evolution [3]

所有的 RAPIDS 包现在都可以免费在 Anaconda、Docker 和 Google Colaboratory 等基于云的解决方案上使用。

RAPIDS 结构基于不同的库，以便加速端到端的数据科学(图 2)。它的主要组成部分是:

cuDF =用于执行数据处理任务(熊猫喜欢)。
cuML =用于创建机器学习模型(Sklearn like)。
cuGraph =用于执行绘图任务(图论)。

RAPIDS 还集成了:用于深度学习的 PyTorch & Chainer、用于可视化的 Kepler GL 和用于分布式计算的 Dask。

Figure 2: RAPIDS architecture [3]

示范

我现在将向您演示，与使用 Pandas 和 Sklearn 相比，使用 RAPIDS 如何能够实现更快的数据分析。我将使用的所有代码都可以在谷歌合作实验室上获得，所以你可以自由地自己测试它！

为了使用 RAPIDS，我们首先需要使我们的谷歌协作笔记本能够与特斯拉 T4 GPU 一起在 GPU 模式下使用，然后安装所需的依赖项(指南可在我的谷歌协作笔记本上获得)。

预处理

一旦一切就绪，我们就可以导入所有必要的库了。

在这个例子中，我将向您展示与仅使用 Sklearn 相比，RAPIDS 如何加快您的机器学习工作流。在这种情况下，我决定使用 Pandas 来预处理 RAPIDS 和 Sklearn 分析。在我的谷歌合作实验室笔记本上也有另一个例子，我用 cuDF 代替预处理。使用 cuDF 而不是 Pandas，可以导致更快的预处理，特别是在处理大量数据的情况下。

对于本例，我决定使用由三个要素和两个标注(0/1)组成的高斯分布来构建一个简单的数据集。

已经选择了分布的平均值和标准偏差值，以便使这个分类问题相当容易(线性可分数据)。

Figure 3: Sample Dataset

创建数据集后，我将它的特征和标签分开，然后定义一个函数对其进行预处理。

现在我们有了训练/测试集，我们终于准备好开始我们的机器学习了。在这个例子中，我将使用 XGBoost(极端梯度推进)作为分类器。

湍流

为了在 RAPIDS 中使用 XGBoost，我们首先需要将我们的训练/测试输入转换成矩阵形式。

接下来，我们可以开始训练我们的模型。

上述单元的输出如下所示。使用 RAPIDS 提供的 XGBoost 库只花了不到两分钟来训练我们的模型。

CPU times: user 1min 54s, sys: 307 ms, total: 1min 54s
Wall time: 1min 54s

此外，RAPIDS XGBoost 库还提供了一个非常方便的函数，可以对数据集中每个特性的重要性进行排序和绘图(图 4)。

这对于减少我们数据的维度非常有用。事实上，通过选择最重要的特征并在此基础上训练我们的模型，我们将降低过度拟合数据的风险，并且我们还将加快训练时间。如果你想了解更多关于特性选择的信息，你可以阅读我的文章。

Figure 4: XGBoost Feature Importance

最后，我们现在可以计算我们的分类器的准确性。

我们使用 RAPIDS 的模型的整体准确性等于 98%。

XGB accuracy using RAPIDS: 98.0 %

Sklearn

我现在将使用普通的 Sklearn 重复相同的分析。

在这种情况下，训练我们的模型只花了 11 分钟多一点。这意味着使用 Sklearn 解决这个问题比使用 RAPIDS (662s/114s)慢 5.8 倍。通过在预处理阶段使用 cuDF 而不是 Pandas，我们可以为这个例子的整个工作流减少更多的执行时间。

CPU times: user 11min 2s, sys: 594 ms, total: 11min 3s
Wall time: 11min 2s

最后，利用 Sklearn 计算了模型的整体精度。

此外，在这种情况下，总体准确率等于 98%。这意味着使用 RAPIDS 可以更快地得到结果，而不会影响模型的准确性。

XGB accuracy using Sklearn: 98.0 %

结论

正如我们从这个例子中看到的，使用 RAPIDS 导致了执行时间的持续减少。

这在处理大量数据时非常重要，因为 RAPIDS 能够将执行时间从几天减少到几小时，从几小时减少到几分钟。

RAPIDS 提供了有价值的文档和示例来充分利用它的库。如果你有兴趣了解更多，这里有一些例子这里和这里。

我另外创建了另外两个笔记本来探索 RAPIDS cuGraph 和 Dask 库。如果你有兴趣了解更多，这里有这里有和这里有。

联系人

如果你想了解我最新的文章和项目，请在 Medium 上关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:

领英
个人博客
个人网站
中等轮廓
GitHub
卡格尔

文献学

[1]什么是大数据？—大数据世界入门指南。阿努什里·苏布拉马年，爱德华卡！。访问地点:【https://www.edureka.co/blog/what-is-big-data/

[2]不再有晶体管:摩尔定律的终结。有趣的工程学，约翰·雷夫勒。访问地址:https://interesting engineering . com/no-more-transistors-the-end-of-Moores-law

[3]急流:平台内外，乔希·帕特森 10–23–2018。访问网址:http://on-demand . gputechconf . com/gtcdc/2018/pdf/DC 8256-rapids-the-platform-inside-and-out . pdf

[4] GPU 加速的数据科学|英伟达 GTC 主题演示。黄仁勋。访问地点:https://www.youtube.com/watch?v=LztHuPh3GyU

MacOS 上 GPU 加速的机器学习

原文：https://towardsdatascience.com/gpu-accelerated-machine-learning-on-macos-48d53ef1b545?source=collection_archive---------4-----------------------

苹果可能不喜欢 NVIDIA 卡，解决方案叫 PlaidML+OpenCL

PlaidML is a software framework that enables Keras to execute calculations on a GPU using OpenCL instead of CUDA. This is a good solution to do light ML development on a Mac without a NVIDIA eGPU card.

大规模并行编程对于在相似输入上多次应用相同操作的情况下加速计算非常有用。如果你的代码包含许多if或case语句，你可能想在使用的 CPU 上运行，例如 OpenMPI 。如果你的代码涉及到随机数的生成，并行编程可能不是最好的解决方案(不过，这里见)。否则，你很可能是在正确的地方，所以继续阅读！

训练一个神经网络涉及非常大量的矩阵乘法。这是典型的大规模并行操作，这也是 GPU 对机器学习至关重要的主要原因之一。需要记住的一条经验法则是，1K 个 CPUs = 16K 个内核= 3 个 GPU，尽管 CPU 可以执行的操作种类远远超过单个 GPU 内核。对于 GPU 来说，实力在数量！

iMac 和 MacBook Pro 电脑配备了 AMD 镭龙 GPU 卡。不幸的是，这种硬件不能直接用于加速机器学习应用中典型的计算，例如训练 CNN。虽然没有适用于所有可能应用的解决方案，但是仍然有一个基于并行编程语言 OpenCL 的简单架构的解决方案。

两个最流行的 ML 框架 Keras 和 PyTorch 支持基于通用 GPU 库 NVIDIA CUDA 的 GPU 加速。CUDA 只适用于 NVIDIA GPU 卡。

NVIDIA 外置 GPU 卡(eGPU)可用于带有雷电 3 端口的 MacOS 系统和 MacOS High Sierra 10.13.4 或更高版本。按照 本指南 安装 eGPU。

在 MacOs 上安装 CUDA 遵循 官方文档 。这里可以找到 驱动。

使用 Python 的 OpenCL

项目 PyOpenCL 可能是在 Mac 上开始使用 GP-GPU 的最简单的方法。另见其姊妹项目 PyCUDA 。

$ pip install pyopencl

OpenCL 的核心是一个内核，这是一个可以应用于大量输入数据的函数(用类似于 C 的语言编写)。

要了解并行编程，请阅读基于 CUDA 的在线课程 ，或者购买 Tim Mattson et al 撰写的本书 。

OpenCL 比 CUDA 更灵活，允许程序在不同的架构上执行。这是有代价的:需要编写一些“样板”代码来定义一个上下文 ( 即什么样的硬件可用)、一个队列 ( 即一个命令序列)和一组内存标志(如 READ_ONLY、WRITE_ONLY等。).典型的工作流程如下:

输入数据被复制到 GPU 内存中
GPU 缓冲存储器被保留用于存放计算结果
内核被执行
结果从 GPU 内存复制到主机内存

NB: OpenCL 内核可以在 CPU 和 GPU 上执行，但是如果代码针对某个 GPU 架构进行了高度优化(例如具有大内存)，它可能无法完全移植。

虽然 GPU 通常更快，但根据处理器的架构，将大量数据从 CPU 传输到 GPU 所需的时间可能会导致更高的开销时间。

下面是一个计算两个矩阵之和的全功能 OpenCL 程序示例:

#!/usr/bin/env python
# -*- coding: utf-8 -*-from __future__ import absolute_import, print_function
import numpy as np
import pyopencl as cla_np = np.random.rand(50000).astype(np.float32)
b_np = np.random.rand(50000).astype(np.float32)ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)mf = cl.mem_flags
a_g = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=a_np)
b_g = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=b_np)kernel = """
__kernel void sum(
    __global const float *a_g, __global const float *b_g, __global float *res_g)
{
  int gid = get_global_id(0);
  res_g[gid] = a_g[gid] + b_g[gid];
}
"""prg = cl.Program(ctx, kernel).build()res_g = cl.Buffer(ctx, mf.WRITE_ONLY, a_np.nbytes)
prg.sum(queue, a_np.shape, None, a_g, b_g, res_g)res_np = np.empty_like(a_np)
cl.enqueue_copy(queue, res_np, res_g)# Check on CPU with Numpy:
print(res_np - (a_np + b_np))
print(np.linalg.norm(res_np - (a_np + b_np)))
assert np.allclose(res_np, a_np + b_np)

使用 OpenCL 作为 Keras 后端的机器学习(PlaidML)

Keras 是最流行的深度学习框架之一。使用 Keras' 功能 API定义网络架构、运行训练和执行推理非常容易。然而，Keras 本身并不执行实际的计算，而是部署其他软件库来定义、优化和评估涉及多维数组的数学表达式。最常见的有 Theano 和 TensorFlow 。反过来，这些库使用 CUDA 在 GPU 上执行并行计算。如前所述，这带来了非常强的硬件限制，即它只能在 NVIDIA 卡上工作。

通过使用 PlaidML 库可以部分避免这个问题:

$ pip install plaidml-keras

安装之后，执行安装脚本(选择默认，除非您知道自己在做什么):

$ plaidml-setup

您应该会看到类似这样的内容:

PlaidML Setup (0.6.4)Thanks for using PlaidML!Some Notes:
  * Bugs and other issues: https://github.com/plaidml/plaidml
  * Questions: https://stackoverflow.com/questions/tagged/plaidml
  * Say hello: https://groups.google.com/forum/#!forum/plaidml-dev
  * PlaidML is licensed under the Apache License 2.0 Default Config Devices:
   metal_amd_radeon_r9_m380.0 : AMD Radeon R9 M380 (Metal)Experimental Config Devices:
   llvm_cpu.0 : CPU (LLVM)
   opencl_amd_radeon_r9_m380_compute_engine.0 : AMD AMD Radeon R9 M380 Compute Engine (OpenCL)
   opencl_cpu.0 : Intel CPU (OpenCL)
   metal_amd_radeon_r9_m380.0 : AMD Radeon R9 M380 (Metal)Using experimental devices can cause poor performance, crashes, and other nastiness.Enable experimental device support? (y,n)[n]:Selected device:
    metal_amd_radeon_r9_m380.0Almost done. Multiplying some matrices...
Tile code:
  function (B[X,Z], C[Z,Y]) -> (A) { A[x,y : X,Y] = +(B[x,z] * C[z,y]); }
Whew. That worked.Save settings to /Users/user/.plaidml? (y,n)[y]:
Success!

该库支持许多但不是所有的 Keras 层。如果您的架构只涉及密集层、LSTM 层、CNN 层和漏层，那么您当然很好，否则请查看文档。

原则上，您所要做的就是在您的程序前添加以下代码行来激活 PlaidML 后端:

import osos.environ["KERAS_BACKEND"] = "plaidml.keras.backend"

在执行过程中，您应该会看到如下打印输出:

Using plaindml.keras.backend backendINFO:plaidml:Opening device "metal_amd_radeon_r9_m380.0"

这是一个示例，改编自 Keras 的官方文档，应该可以开箱即用:

#!/usr/bin/env pythonimport osos.environ["KERAS_BACKEND"] = "plaidml.keras.backend"import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as Kbatch_size = 128
num_classes = 10
epochs = 12# input image dimensions
img_rows, img_cols = 28, 28# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()if K.image_data_format() == 'channels_first':
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

在 2015 款 iMac (3.2 GHz 英特尔酷睿 i5，16 GB DDR RAM，AMD 镭龙 R9 M380 2 GB GPU)上，使用 PlaidML/OpenCL GPU 后端训练需要 1m50s ，使用 TensorFlow-2.0/CPU 后端训练需要 5m06s 。

注意，如果没有可用的后端，指令from keras import backend as K将返回一个错误。例如，如果您没有安装TensorFlow(默认)，您会看到:

Using TensorFlow backend.
Traceback (most recent call last):
  File "./test_keras.py", line 8, in <module>
    import keras
  File "/Users/Riccardo/development/venv_opencl/lib/python3.7/site-packages/keras/__init__.py", line 3, in <module>
    from . import utils
  File "/Users/Riccardo/development/venv_opencl/lib/python3.7/site-packages/keras/utils/__init__.py", line 6, in <module>
    from . import conv_utils
  File "/Users/Riccardo/development/venv_opencl/lib/python3.7/site-packages/keras/utils/conv_utils.py", line 9, in <module>
    from .. import backend as K
  File "/Users/Riccardo/development/venv_opencl/lib/python3.7/site-packages/keras/backend/__init__.py", line 89, in <module>
    from .tensorflow_backend import *
  File "/Users/Riccardo/development/venv_opencl/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py", line 5, in <module>
    import tensorflow as tf
ModuleNotFoundError: No module named 'tensorflow'

最后一点，TensorFlow >=2.0包括 Keras API。如果你的程序是从 TF 定义层，而不是从 Keras 定义层，那么你不能仅仅改变 Keras 后端来运行在支持 OpenCL 的 GPU 上，因为 TF2 不支持 OpenCL 。更具体地说:

这不会使用 GPU(假设你已经安装了TensorFlow >=2.0)

from tensorflow import keras
from tensorflow.keras import layers

这将工作得很好(假设你已经安装了Keras)

import keras
from keras import layers

用 Tile 编写 OpenCL 内核

事实证明，PlaidML 不仅仅是一个 Keras 后端。事实上，它附带了一种叫做 Tile 的编程语言，帮助用户编写优化的内核，而不需要深入了解 C 和 OpenCL 的大部分古怪之处。Tile 指令看起来更像数学函数。例如，矩阵乘法

在瓷砖上看起来像这样

function (A[M, L], B[L, N]) -> (C) {
    C[i, j: M, N] = +(A[i, k] * B[k, j]);
}

其中“+”运算符代表数学表达式中的“和”。

更多示例可在文档中找到，包括一些最常见的操作，如矩阵乘法、最小/最大、最大池、卷积、累积和。合成内核时，Tile 展平张量并将索引转换为指针偏移量。计算被分成适合内存的块，其大小根据可用硬件进行优化。然后在 GPU 内存中布置图块，以优化 SIMDs 指令，如乘法和累加。最后，内核被写出来，就好像它们是由人类用户创建的一样，并被传递给 OpenCL 进行实际执行。

结论

PlaidML 现在是英特尔人工智能集团 Vertex.ai 的一部分。它可能最终使 AMD 卡(可能会有更多的厂商出现)成为 ML 中一个可行的选择。事实上，英特尔也将在 2020 年进入 GPU 市场，为数据中心的 ML 设计硬件，这可能通过竞争进一步降低计算价格。英特尔首席执行官 Bob Swan 表示“2020 年，我们将继续扩大我们的 10 纳米产品组合，推出令人兴奋的新产品，包括人工智能推理加速器、5G 基站 SOC、用于服务器存储的至强 CPU、网络和独立 GPU。本季度，我们的首款独立 GPU DG1 实现了通电退出，这是一个重要的里程碑。”。敬请关注！

GPU 数据科学:将 CSV 转换为 Parquet / ORC 比使用集群更快更便宜！

原文：https://towardsdatascience.com/gpu-datascience-converting-csv-to-parquet-orc-faster-cheaper-than-using-a-cluster-c4b20d969009?source=collection_archive---------29-----------------------

在本地，有一句话已经说了很久了:“我们用启动资金处理企业级数据”——我们需要以更低的成本做到这一点！

这可能会令人沮丧——老实说，我曾经梦想过能够在几分钟内而不是几个小时内启动一个 1000 节点的集群来进行一些痛苦的处理会好得多。因此，我开始尝试一些替代方法，不仅加快我们的数据科学工作，还让它更便宜！

其中一种方法是利用 GPU 的能力。

是什么让 GPU 对数据科学有好处？

GPU 基本上是一个自包含的集群。NVIDIA 芯片有所谓的“CUDA 核心”，每个核心都是一个微型处理器，可以像 CPU 一样执行一些代码。

一款流行的消费级 GPU——GTX 1080 Ti 如下图所示，它显示该卡拥有 3584 个 CUDA 内核，可以并行处理这些数据。

Courtesy of videocardz.com

为什么用 CSV 到 ORC 或者拼花为例？

很简单，因为从计算上来说这是一件相对困难的事情。为了从基于行转换到基于列，需要透视整个数据集

最重要的是，数据被分割成条带，需要计算各种统计数据，并且要编写包含所保存数据摘要的文件页眉和页脚。

https://www.reddit.com/r/dataengineering/comments/bd5h54/eli5_columnar_databasesdata_storage/

设置

我家里有一个 QNAP NAS，非常适合这次演示，因为我需要大量的存储，它有以下硬件和软件:

14TB SATA (Raid 10)
英伟达 Geforce GTX 1060 6GB
Rapids.ai(通过 Docker)

Rapids.ai 是一个由 NVIDIA 人员支持的开源框架，它提供了 GPU 优化的数据帧和各种其他工具来简化这一过程！

数据集

我们为一个客户端创建了一个数据集，它是 117GB 的压缩 CSV 文件(大约 400GB 未压缩)，大约有 20 亿行。我们需要将它转换成 ORC 格式，这样我们就可以将它插入我们的平台数据仓库(基于 Presto)。

在 GPU 上处理 CSV 到 ORC

注意:我已经包括了在标准 SATA 驱动器上运行时下面每个步骤的时间

第一步是创建一个包含所有 CSV 数据的 Dask GPU 数据帧。我的 GPU 只有 6GB，因此这里的限制是每个未压缩的块必须适合 GPU 内存，如果您以较少的大文件导出 CSV 数据，这可能会导致问题——在这种情况下，您应该处理未压缩的数据。

CPU times: user 1.82 s, sys: 870 ms, total: 2.69 s
Wall time 6.99 s

第二步是将数据重新划分为更易于管理的文件数量——这里的内存限制再次限制了您可以做的事情(尽管 Rapids.ai 团队正在进行这项工作)。

CPU times: user 60.2 ms, sys: 159 µs, total: 60.4 ms
Wall time: 57.6 ms

最后，获取这个新的数据帧并将其写出到 ORC 文件中:

CPU times: user 1h 4min 4s, sys: 30min 19s, total 1h 34min 23s
Wall time: 41min 57s

所以总共 42 分钟处理 400 GB CSV 数据给 ORC

测试回顾

当然，这个测试并不完美。有许多可以改进的地方。对我来说，最大的烦恼是我必须指定大量的分区，以便保持在我的 GPU 限制内。

激流勇进有一些票打开来解决这个，不过:
https://github.com/rapidsai/cudf/issues/3542
https://github.com/rapidsai/cudf/issues/3342
https://github.com/rapidsai/cudf/issues/3004

他们在开发方面非常积极，所以我只是假设这是处于风口浪尖的一部分！

磁盘速度:

同样，在 SATA 驱动器上运行该测试。42 分钟是一个了不起的结果，比运行 Presto 或类似的 21 节点大型实例集群的类似规模的数据集快得多。
我确实在 NVMe 驱动器上运行了这个，返回了 31 分钟，但是我认为可以通过运行单独的 NVMe 驱动器来进一步减少这个时间，以避免 IO 冲突。

结论

GPU 正迅速成为使用集群完成数据科学任务的廉价而现实的替代方案。与拥有 21 个节点的大型集群相比，部署单个 AWS GPU 实例的成本大约是前者的 1/10，探索这种数据处理方法比以往任何时候都更有意义。

抓住多少？跟我谈数据！

原文：https://towardsdatascience.com/grabchat-much-talk-data-to-me-40743ec5a75f?source=collection_archive---------41-----------------------

作者:杰森·李，劳拉·伊姆

2016 年 9 月，GrabChat 诞生了，这是一个旨在实现乘客和司机伙伴之间无缝沟通的平台。从那时起，Grab 通过引入即时翻译、图像和音频聊天等功能不断改善 GrabChat 体验，结果是取消率降低了 50%!我们甚至尝试了各种功能在每个国家提供超本地化的体验！那么有了这些功能，我们的用户反应如何呢？让我们对此进行更深入的研究，从我们在新加坡、马来西亚和印度尼西亚的数据中发现一些有趣的见解。

最健谈的国家

在两年前的一篇博客文章中，我们揭示了印度尼西亚是东南亚最健谈的国家。我们的最新数据没有什么不同。印度尼西亚仍然是三个国家中最健谈的国家，平均每次预订有 5.5 次聊天，而新加坡是最不健谈的国家！此外，新加坡的乘客比司机伴侣更健谈，而其他两个国家的情况正好相反。

但是人们都在谈论什么呢？

Common words in Indonesia

Common words in Singapore

Common words in Malaysia

不出所料，大多数聊天都围绕着搭讪点。这三个国家之间有许多相似之处，例如打招呼如“嗨”和“谢谢”,以及司机伴侣/乘客来了。然而，各国之间还是有细微的差别。你能认出他们吗？

在印度尼西亚，聊天通常是用印度尼西亚语进行的，而且大多是司机伙伴感谢乘客使用 Grab。

另一方面，新加坡的聊天倾向于用英语，而且大多包含上车地点，比如停车场。在新加坡的语境中有很多独特的词，如“垃圾道”和“街区”，反映了新加坡随处可见的 HDB(公共住房)的特征，这些公共住房是受欢迎的住宅区。

马来西亚似乎是其他两个国家的混合体，人们用英语和马来西亚语聊天。许多聊天突出了上车地点，如警卫室，以及所有马来西亚人都知道的短语:堵车。

时间趋势

对这三个国家的聊天趋势的分析揭示了一个意想不到的发现:从午夜到凌晨 4 点的聊天越来越多。困惑但好奇的是，我们进一步挖掘，以发现是什么促使我们的用户在这种奇怪的时间里说更多的话。

从午夜到凌晨 4 点，商店和商场通常在这些时间关闭，随着人们深夜在镇上闲逛，取货地点变得更加模糊。因此，司机伴侣和乘客倾向于进行更多的对话来确定上车点。这也解释了为什么所有消息中基于 接送位置的消息的比例在 12 点和早上 6 点之间最高。另一方面，这些消息在早上(6am-12pm)不太常见，因为人们往往会从标准的住宅区被接走。

图像趋势

GrabChat’s Image-function uptake in Jakarta, Singapore, and Kuala Lumpur (Nov 2018 — March 2019)

GrabChat 上发送图像的功能于 2018 年 9 月推出，旨在帮助司机合作伙伴确定乘客的确切上车位置。在发布的最初几周内，仅在新加坡就有 22，000 张图片被发送出去。从上面的 gif 图中可以看出，雅加达、新加坡和吉隆坡对图片功能的使用有所增加。

通过分析，我们发现更偏远的地区，如新加坡的 Tengah，发送的图像比例往往最高，这表明图像对不熟悉地方的用户很有用。

安全第一

除了图像，Grab 还引入了另外两个功能:模板和音频聊天，以避免司机伴侣在开车时发短信。

Templates and audio features used by driver-partners, and a reduced number of typed texts by driver-partners per booking

“模板”(预先填充的短语)允许司机伙伴只需快速点击即可发送模板消息。在我们最近的数据分析中，我们发现几乎 50%的司机合作伙伴文本包含模板。

“音频聊天”和“图像聊天”于 2018 年 9 月推出，该功能的使用一直在稳步增加，音频包括越来越多的司机合作伙伴文本。

随着这两项功能被所有三个国家的司机合作伙伴采用，Grab 在三个月内成功减少了每次预订的司机合作伙伴文本(非模板)的总数。

简短的提货指南

没人喜欢取消的旅程，对吧？在分析了数百万个数据点后，我们发现了一些巧妙的技巧和窍门来帮助你完成你的旅程，我们正在与你分享！

这第一个建议可能是显而易见的，但是回复你的司机伙伴会导致更高的完成率。没有人喜欢闷闷不乐，是吗？

接下来，我们发现了可以提高完成率的各种方法，如下图所示。

通知司机伙伴你要来了，给他们指路，告诉他们如何识别你，这样完成旅程的机会几乎会翻倍！

最后但同样重要的是，我们不要忘记我们的礼仪。Grab 的数据分析显示，说“谢谢”与完成率的增加相关。另外，要准时到达接车点——记住，对于我们的司机伙伴来说，时间就是金钱！

结论

就像莎士比亚的中的无事生非一样，仅仅是一个突发奇想的信息就可以收集到大量的信息。Grab 一直致力于为乘客和司机伙伴提供最佳体验，而数据在帮助我们实现这一目标方面发挥了巨大作用。

这只是这本书的第一页。隐藏在每一页之间的信息量是无穷无尽的。因此，请继续关注我们 GrabChat 平台的更多有趣见解！

梯度增压机(GBM)—Eli 5 方式

原文：https://towardsdatascience.com/gradient-boosting-machines-gbms-the-eli5-way-c4a21b2e2b0a?source=collection_archive---------21-----------------------

【GBMs】梯度推进机器(GBMs)是机器学习中的一种集成技术，其中建立个体弱学习者(弱模型)的复合模型，以便组合它们的所有结果并形成强学习者(强模型)。这是因为给定一个映射每一个观察值的数据集 (xi，易)，我们和算法总是更容易将整体函数【F(x)分解成个简单的子模块(子函数)，而不是必须一次猜测整个表达式。由于这种分而治之的方法，该算法在逼近强模型方面变得非常好，从而减少了预测过程中出现的错误。

简而言之，Boosting 模型旨在提高前一个函数的精度分数，可以递归表示为:

*Fm(x) = Fm-1(x) + fm(x)where,1\. Fm(x) = overall composite function of "m" simpler models
2\. fm(x) = m-th sub-module for Fm(x)
3\. Fm-1(x) = overall compositve function without fm(x)*

The overall function y = 30 + x + sin(x) has been broken down into its sub-modules to illustrate how its simpler constituents can individually make an overall difference

**Example:***F(x)  =** 30 + x + sin(x)**f1(x) =** 30
**f2(x) =** x
**f3(x) =** sin(x)**F(x)  =** f1(x) + f2(x) + f3(x)*

在这个例子中，我们可以说，我们正在训练 M = 3 个弱学习者来近似整体函数为f1(x)+F2(x)+F3(x)。**

我们训练我们的复合学习器，使得每一次迭代的输出值都向真实值的方向推进。在上图中，我们看到一名高尔夫球手试图通过不同强度和方向的努力将球击入洞中。梯度增强以类似的方式工作。

梯度推进决策树

梯度增强决策树(GBDT)是按顺序建模的——每次构建一棵树，其中每个新树负责纠正先前添加的树所产生的错误。尽管与训练随机森林相比，这个训练过程需要更长的时间，但是我们发现 GBDTs 是更好的学习者，即，我们用更少数量的树获得更好的准确度分数。此外，boosting 还可以处理不平衡的数据集。

培训 GBDTs 时需要执行 3 个步骤—

损失/目标函数被优化
弱学习者做预测
加法模型将弱学习者堆积起来，以最小化成本函数。

**Cost Function = average(outputs of Loss Function)**

培训 GBDTs 时需要考虑的事项

梯度推进是一种贪婪的算法，容易过度拟合。我们可以考虑一些参数来优化我们的模型—

增加树的数量，直到没有观察到改进，以确保我们的模型是可推广的。
较浅的树(4 - 8 层)是首选，以使模型不那么复杂。
学习率可以保持在[0.1，0.3]的范围内，甚至小于 0.1。这是因为收缩减少了每棵树对整体模型未来改进的影响。
也可以通过对权重执行 L1 和 L2 正则化来避免过拟合。一个规则化的目标将倾向于选择一个使用简单和预测函数的模型。

梯度下降

原文：https://towardsdatascience.com/gradient-descent-3a7db7520711?source=collection_archive---------10-----------------------

这是一个滑坡，但是保证在底部会变得更好

TL；dr 梯度下降是一种优化技术，用于通过最小化成本函数来改善深度学习和基于神经网络的模型。

在我们之前的帖子中，我们谈到了激活函数(链接这里)以及它在机器学习模型中的应用。然而，我们也大量使用了术语“梯度下降”，这是深度学习模型中的一个关键元素，这将在本文中讨论。

定义和术语

梯度下降是发生在反向传播阶段的过程，其目标是基于权重 w 在相反方向上连续地重新采样模型参数的梯度，不断地更新，直到我们达到函数 J(w) 的全局最小值。

简单来说，我们用梯度下降最小化代价函数， J(w) 。

Fig 1: How Gradient Descent works for one parameter, w

可以用一座陡峭的山来做类比，这座山的底部与大海相接。我们假设一个人的目标是到达海平面。理想情况下，这个人必须一次迈出一步才能达到目标。每一步都有一个负向的梯度(注意:值可以是不同的量级)。这个人继续往下走，直到他到达底部或一个临界点，在那里没有空间再往下走了。

数学

让我们将类比形式化为算法形式。我们计算输入参数的激活度，通过取激活度及其偏差的加权和来执行前馈。我们通过用实际“目标”值减去输出样本来提取误差项。

梯度下降过程以反向传播步骤的形式展示，其中我们从最后一层开始反向计算误差向量δ。根据激活函数，我们通过对函数相对于 w 的偏导数来确定需要多少变化。变化值乘以学习率。作为输出的一部分，我们从以前的输出中减去这个值，得到更新的值。我们继续这样，直到我们达到收敛。

在下面的代码中，我想强调如何编写一个简单的代码来可视化梯度下降是如何工作的。运行这段代码；使用 Tanh 激活函数，我们将观察到 10 的当前值在第 10000 次迭代时下降到值 8.407e-06 ，这是我们的全局最小值。

Fig 2: A simple implementation of gradient descent, based on the Tanh activation function

有很多梯度下降算法。下面我就举几个:

批量梯度下降
随机梯度下降
小批量梯度下降

如果你想深入研究最近的一些技术细节，我强烈推荐你去看看 Sebastian Ruder 关于这个话题的文章。

爆炸和消失渐变

在深度网络或递归神经网络中，Pascanu 等人(1994 年)在一篇论文中解释了两个已知问题——爆炸和消失梯度。当我们在代码中迭代进行反向传播时，会发生这种情况，权重矩阵的法线有可能超过 1。如果发生这种情况，梯度爆炸，但如果法线低于 1，梯度消失。

如果我们想可视化爆炸梯度，你会遇到至少一个问题:

该模型将输出“Nan”值
该模型在每一步都会显示非常大的变化
对于训练层中的每个节点，误差梯度值始终高于 1.0。

解决方案:渐变裁剪

为了解决渐变爆炸和消失的问题，我们引入了渐变裁剪，如果渐变超过了某个由最大绝对值表示的阈值，我们就对其进行“裁剪”。因此，我们保持神经网络稳定，因为权重值永远不会达到它返回“Nan”的点。在编码实现中，去除削波的梯度导致损失为“Nan”值或无穷大，并且不能进一步运行。

下面的代码展示了如何执行渐变裁剪。假设我们有一个损失向量和一个学习率，我们能够计算一个梯度向量，然后基于最大 L2 范数值对其进行剪切，在这种情况下，我写为 5。

因此，在一天结束时，当向数据科学家提出使用什么优化器来最大限度地减少损失的问题时，有几个因素需要考虑:

训练数据集的大小
我们需要多快训练数据来实现收敛

参考论文链接:【http://proceedings.mlr.press/v28/pascanu13.pdf

结论

在这篇文章中，我们讨论了很多事情:我们讨论了什么是梯度下降以及它在神经网络中是如何工作的。我们研究了相关的数学，并实现了它的编码版本。最后，我们以消失和爆炸梯度问题的形式讨论了涉及梯度下降的问题，并讨论了使用梯度裁剪的解决方案。在下一堂课中，我们将探索什么是激活函数，以及它们在深度学习模型中如何至关重要，请继续关注！

传播和分享知识。如果这篇文章激起了你的兴趣，请分享给你的朋友或专业人士。更多数据科技相关帖子关注我 这里。
我在Linkedin上也有空，偶尔tweet也有空。😃

梯度下降在 5 分钟内揭开神秘面纱

原文：https://towardsdatascience.com/gradient-descent-demystified-in-5-minutes-f02966704e35?source=collection_archive---------19-----------------------

“我在和一个女孩约会。一切都很好，直到我开始谈论梯度下降。从那以后，一切都走下坡路了。”

嗯，运气不好，但这是她的损失。

这对你没有任何意义吗？ 爽，保持阅读。

Photo by Stephen Leonardi on Unsplash

如果你没有生活在岩石下，你很可能听说过一种叫做梯度下降的优化算法。但是仅仅因为你听说过它并不意味着你理解它。试着用几句话解释一下，不要使用专业术语。

没那么容易吧？那么你在这里是件好事。让我们开始吧。

梯度下降是一种优化算法，用于找到最小化成本函数的函数参数的最佳值。这听起来可能很奇特，但是试着从视觉上来思考。你有一个大碗，就像你早上吃麦片的那个一样。那个碗是一个成本函数。现在，在碗的表面上任意取一个位置——这些是你的系数的当前值。这个想法是以某种方式达到底部——因此达到一个函数的最小值——因此找到最佳参数。

我们的想法是继续尝试不同的系数值，并评估每个值的成本，然后选择稍微好一点的新系数—成本更低。重复这个过程足够多的次数将引导你到达碗的底部，你将发现系数的最佳值——最佳值意味着它们导致最小的成本。

但是什么是成本函数呢？

在数据科学和机器学习中，成本函数用于估计你的模型有多好或多坏。用最简单的话来说，成本函数是衡量模型在估计特征( X )和目标变量( y )之间关系的能力方面有多差的一种方法。

使用什么作为成本函数并不重要，但最常用的是:

残差平方和( SSR/SSE )
均方误差( MSE
均方根误差( RMSE )

它有时也被称为损失函数或误差函数。你的目标是找到模型的最优参数，也就是最小化成本函数的参数。

现在当你理解了这一点，让我们继续梯度下降。

逐步梯度下降

该算法从设置系数的初始值开始——您可以随意设置值(而不是字符串或布尔值)，但通常的做法是将它们设置为 0。如果我有两个系数，比如β0 和β1，我会先将它们设置为零:

现在为了简单起见，让我们假设我正在处理一个线性回归任务，这些β是我的系数(β0 是偏差截距)。然后，我将定义我的成本函数，例如 SSR:

这可以进一步简化:

读起来挺简单的。你做一个预测，然后从实际值中减去这个预测，然后取它的平方。然后，对数据集中每个实例的所有方块求和。

现在到了你应该知道一点微积分的部分来完全理解正在发生的事情。您需要为每个系数计算偏导数，这样系数可以在以后更新。您应该熟悉的主题有:

权力规则
链式法则
多元微分

前一段时间，我写了一篇关于在 Python 中求导的文章，它在一定程度上涵盖了这些主题:

[## 在 Python 中取导数

学习如何处理机器学习中的微积分部分

towardsdatascience.com](/taking-derivatives-in-python-d6229ba72c64)

回到正题。由于我的模型只有两个系数，我需要计算两个偏导数，一个关于β0，另一个关于β1。方法如下:

现在到了你使用这两个函数并做一些被称为 epoch 的事情的时候了——这只是一个对数据集进行单次迭代的时髦说法。您正在浏览数据集，关注自己的事情，并跟踪系数的成本—让我们将它们表示为:

不知不觉中，您已经到达了数据集的末尾，是时候重新计算系数了。再介绍一个术语——学习率(LR) 。它决定了新获得的信息覆盖旧信息的程度。在初始化系数时，将其设置为某个常数，通常在 0.0001 到 0.1 之间:

将学习率设置为太小的值将导致需要大量的历元来寻找最佳参数，而将其设置为太高的值可能会导致算法“跳过”最佳值。需要一个学习率来计算步长——一个告诉算法下一次迭代要走多远的数字。

如果函数在给定点很陡，步长会更大，当接近最佳参数时，步长会减小，从而使算法达到最佳状态。

一旦你得到这些计算结果，你可以按如下方式更新系数:

简而言之，这是一个时代。重复这个过程 10000 次，你会得到系数的最佳值。

在你离开之前

这应该是一些可管理的文本和可管理的数学，以理解机器学习和深度学习的最基本的主题之一。如果你还是觉得不明白，那就拿起笔和纸，按照方程，手动计算一切。

如果这对你来说听起来有些难以处理，不用担心，几天后我将发表一篇关于使用梯度下降来寻找线性回归的最佳系数值的文章——我将精确地使用上面列出的方程。

现在概念对你来说更清晰了吧？请让我知道。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

[## 通过我的推荐链接加入 Medium-Dario rade ci

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@radecicdario/membership)

梯度下降:给我看看数学！

原文：https://towardsdatascience.com/gradient-descent-show-me-the-math-7ba7d1caef09?source=collection_archive---------4-----------------------

Photo by Martin Jernberg on Unsplash

梯度下降是一种迭代学习算法，也是神经网络的主力。对于 PyTorch 或 Keras 来说，有了许多可定制的例子，构建一个千篇一律的神经网络就成了一项微不足道的工作。然而，当事情出错时，掌握基础知识可以节省大量冗长的调试时间。

在这篇文章中，我们将深入挖掘梯度下降的数学公式，为它建立一个更好的直觉。有些例子很简单，可以手工解决。此外，写下东西有助于记忆，所以请随意拿一张纸和一个计算器！

误差度量

神经网络(NN)做出的预测经常会错过目标，有时会相差很大。我们需要以这样一种方式量化误差，即符号总是正的，并且大的误差被放大。我们定义误差平方和(SSE)，用大写字母 E 表示:

y=基本事实
ŷ (y hat)=预测
j=网络的输出单位
μ ( 希腊字母 mu )= 所有数据点

在 j 上的第一个和中，找出每个真值和它对应的预测值之间的差，求这些差的平方，然后把它们加起来。

接下来我们有 μ 个数据点。在第二次求和中，对于我们计算平方距离的内部和的每个数据点，我们对所有这些进行求和。

回想一下，神经网络的预测 ŷ 是由其权重决定的:

w=重量
x=特征
i=特征数量

因此，在 SSE 方程中插入 ŷ 的方程，我们可以看到误差取决于权重:

因此，我们的目标是确定最小化误差的权重。后者有时被称为由 J(w) 表示的成本函数，其思想是我们对错误的预测进行惩罚。

链式法则

理论

为了找出函数的最小值出现在哪里，我们对它求导。鉴于我们有许多变量，我们将看到链规则如何帮助我们制定这个导数。

在单个输出单元的情况下，其中 j=1，我们可以得到误差 E 相对于权重的导数为:

假设 ŷ 是单个激活函数 f 的结果，该函数接受输入 h ，使得 h 接受输入并将其乘以其权重:

在误差的导数中替换:

注意求和项的偏导数，如果我们写出随机权重 wi:

和对 I 的偏导数只有 xi，其他都等于零。我们可以代入 E 的偏导数:

相对于某个权重的平方误差的梯度是误差乘以激活函数在 T2 h T3 的导数再乘以输入值 T4 Xi T5 的负值。我们将其乘以学习速率 η (希腊字母 eta)以获得权重步长:

为了使我们的符号更容易理解，我们将误差项 δ 定义为误差乘以 h 处激活函数的导数:

这将重量步骤简化为:

用更一般的符号来写:

单输出单元示例

现在我们有了如何进行的想法，我们可以将它应用到单个输出单元上。我们使用由 S 表示的 sigmoid 函数作为激活函数。回想一下，激活函数的一般符号是 f(h):

sigmoid 函数的一个特殊之处在于其导数的最大值为 0.25。查看这篇帖子以获得如何计算其导数的指导。

用 python 实现它:

现在让我们定义初始特征、权重和学习速率:

根据上面的公式，我们可以如下计算重量的变化:

梯度下降通用实现

在大多数应用中，我们将有不止一个节点。因此，我们需要改变我们计算误差的方式，以避免对可能导致梯度发散的大误差求和。我们引入均方误差:

m=数据中的记录数

我们可以将对数据集应用梯度下降的一般算法定义如下:

将重量步长设置为零:wi = 0
对于培训数据中的每条记录:

向前通过网络，并计算输出 ŷ
计算输出单元的误差项 δ
更新权重步长:δwi =δwi+δXi

3.更新权重:wi = wi+ηδwi/m

4.重复 e 个时期

在这一点上，我们如何初始化权重成为一个相关的问题。我们希望权重足够小，以使 sigmoid 的输入位于 0 附近的线性区域，并且不会在高端和低端受到挤压。

我们遵循斯坦福 CS231n 规定的方法，随机初始化它们，使它们都有不同的初始值并发散，打破对称性。因此，我们从以 0 为中心的正态分布初始化权重，并以 1/sqrt(n)对其进行缩放，其中 n 是输入单元的数量。

对于具有 n _ recrods 和 n_features 的数据集，我们可以用 python 实现如下:

反向传播

到目前为止，我们已经了解了如何计算输出节点中的误差并向前传播误差。我们也可以使用反向传播来反向传播误差。

层的输出由层之间的权重决定，因此由单元产生的误差由相应的权重来缩放。

考虑归因于输出单元 k 和隐藏层 h 的隐藏单元 j 的误差 δ 。我们可以这样写这个错误:

o =输出层
h=隐藏层
j =的隐藏单位
k=输出单位

梯度下降步骤与前面定义的步骤相同，但增加了下标以标识操作发生的位置:

wij=输入层和隐藏层之间的权重
xi=输入单位值

因此，权重步长等于上面计算的步长乘以该层的输出误差乘以该层的输入值:

δ输出 =输出误差
V in =层的输入，如输出单元的隐藏层激活

反向传播手算

如果你还没有纸和笔，现在是个好时机😉。

考虑下面从底部流向顶部的两层神经网络。我们有两个输入值，一个隐藏单元和一个输出单元。

我们还在隐藏和输出单元应用了 sigmoid 激活函数。我们可以使用其他激活， PyTorch 文档列出了许多带有相应图形的公式。

请注意，输入的相应权重用黑色写在线旁边。

Photo credit: Udacity.com

为了这个例子的目的，让我们假设我们的目标输出是 y=1 。

我们从正向传递开始，从输入到隐藏单元:

隐藏单元的输出随后被激活:

对于输出注释，我们将重量倍增与激活相结合:

回想一下，导数 sigmoid 激活函数如下:

因此，输出单元的误差项为:

进一步通过网络，我们计算带有传播的隐藏单元的误差项。回想一下，每个隐藏层对误差的贡献与其权重成比例:

在上面的等式中，我们通过将输出单元连接到隐藏单元的权重 W 来缩放来自输出单元的误差项。在我们的例子中，我们只有一个隐藏节点，可以将上面的表达式简化为:

学习率乘以输出单元误差乘以隐藏单元激活值等于隐藏到输出的权重步长:

因此，连接隐藏到输出层的当前权重 W=0.1 将被更新这个数量。

最后一步是输入隐藏权重。更新等于学习率乘以隐藏单元误差，再乘以输入值:

随着权重的更新，我们可以重复上述步骤，直到我们的预测变得几乎等于地面真相。

请注意，如果我们有许多层，使用 sigmoid 激活函数会将输入附近层中的权重步长快速降低到微小值。这不是别人，正是消失渐变问题。

数字示例

我们可以在 NumPy 中使用稍微复杂一点的网络做同样的事情:三个输入节点，两个隐藏节点，一个输出层。

结论

我们已经看到学习的数学是如何为神经网络工作的。通过上面的练习，我们可以更好地理解错误、激活函数，也许还可以为神经网络构建一个 python 类。

还有更多的资源可以探索，如斯坦福 CS231n。我也强烈推荐 Andrew Trask 的探索深度学习，这是一个很好的资源，有可解释的例子。

使用逻辑回归的梯度下降训练

原文：https://towardsdatascience.com/gradient-descent-training-with-logistic-regression-c5516f5344f7?source=collection_archive---------3-----------------------

梯度下降

梯度下降算法及其变体(Adam、SGD 等。)已经成为许多机器学习应用中非常流行的训练(优化)算法。优化算法可以非正式地分为两类——基于梯度的和无梯度的(例如粒子群、遗传算法等。).你可以猜到，梯度下降是一种基于梯度的算法。为什么梯度在训练机器学习中很重要？

训练机器学习模型的目的是通过改变可训练参数来最小化基础事实和预测之间的损失或误差。梯度是导数在多维空间中的延伸，它告诉我们损失或误差最佳最小化的方向。如果你还记得向量微积分课上，梯度被定义为最大变化率。因此，梯度下降的公式很简单:

θj 是可训练参数，j. α是学习率。J(θ)是一个成本函数。

在下图中，从起点(峰)到最佳点(谷)的最短距离是沿着渐变轨迹。相同的原理适用于多维空间，这通常是机器学习训练的情况。

为了演示梯度下降如何应用于机器学习训练，我们将使用逻辑回归。

逻辑回归

二元情况

为了理解 LR 的工作原理，让我们想象以下场景:我们想根据年龄(x1)、年收入(x2)和教育程度(x3)来预测一个人的性别(男性= 0，女性= 1)。如果 Y 是预测值，则此问题的逻辑回归模型将采用以下形式:

Z = B0+B1(x1)+B2(x2)+B3(x3)

Y = 1.0 / (1.0 + e^-Z)

b0 通常称为“偏差”，b1、b2 和 b3 称为“权重”。

z 具有与线性回归相同的形式，而 Y 是 sigmoid 激活函数。y 取 0 到 1 之间的值。如果 Y 小于 0.5，我们推断预测输出为 0，如果 Y 大于 0.5，我们推断输出为 1。

现在，我们准备看看下面 LR 的更正式的形式:

φn 是 Xn 在特征空间中的增广变换。tn 是类标签。σ是一个 s 形激活。w 是权重向量(包括偏差项)。p(C1 |φ)和 p(C2 |φ)分别是给定φ时分配给 C1 和 C2 的概率。

给定上述公式，这里的主要目标是在给定权重(W)的情况下最大化观察数据的可能性。似然函数是观测数据的联合分布，如下所示:

π是乘积算子。

从似然函数可以看出，y 是伯努利分布。

当处理概率时，最好转换成对数，因为对数将乘积转换成总和，从而避免了取非常小的数的乘积的问题(通常用于概率)。下面是负对数似然(NLL)及其相对于权重的梯度。NLL 用于将最大化问题转化为最小化问题。本质上，最小化 NLL 相当于最大化可能性。

多类案件

LR 的二进制情况可以通过改变符号扩展到多类情况。

假设有 K 类。因此，p(Ck)是在给定φ的情况下分配给类 k 的概率。

代替 sigmoid 激活，softmax 激活用于将类分数(ak)转换成适当的概率。

w 是权重矩阵(DxK) — D 是特征空间维度。

似然函数和负似然(NLL)如下所示。

y 现在是多元分布的。

MNIST 分类

MNIST 是一个经典数据集，由手绘数字(0 到 9 之间)的黑白图像组成。我们将使用 PyTorch 实现多类逻辑回归来对 MNIST 的数字进行分类。因为我们想要演示梯度下降算法，所以我们不使用 torch.optim 中的内置算法。为了简单起见，我们将使用 torch.autograd，而不是手动计算梯度。这个演示来自 PyTorch 网站。

下载数据集

以下代码下载数据集(训练集和验证集)并转换成相应的 numpy 数组。

from pathlib import Path
import requests
import pickle
import gzipDATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"
PATH.mkdir(parents=True, exist_ok=True)
URL = "http://deeplearning.net/data/mnist/"FILENAME = "mnist.pkl.gz"
if not (PATH / FILENAME).exists():
  content = requests.get(URL + FILENAME).content
  (PATH / FILENAME).open("wb").write(content)with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
  ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f,   encoding="latin-1")

转换为张量

在使用 PyTorch 时，我们需要将上面的 numpy 数组转换成张量。

import torch
x_train, y_train, x_valid, y_valid = map(torch.tensor, (x_train,  y_train, x_valid, y_valid))

初始化权重和偏差

接下来，我们将创建和初始化权重和偏差张量。我们使用 Xavier 初始化用于权重，同时用零值初始化偏置。因为我们希望 torch.autograd 负责梯度计算，所以我们需要将 requires_grad 设置为 True，以便 PyTorch 可以跟踪梯度计算所需的操作。

import math
weights = torch.randn(784, 10) / math.sqrt(784)
weights.requires_grad_()
bias = torch.zeros(10, requires_grad=True)

似然函数

我们需要评估的可能性是 yk(φ)。要得到 yk(φ)，我们首先需要对 ak 求值。它不返回 yk(φ)，而是返回 log(yk(φ))，这对以后计算损失函数很有用。

**def** **log_softmax**(x):
    **return** x **-** x**.**exp()**.**sum(**-**1)**.**log()**.**unsqueeze(**-**1)

**def** **model**(xb):
    **return** log_softmax(xb **@** weights **+** bias)

损失函数—负对数似然(NLL)

现在，我们可以使用似然来计算总体负对数似然，这是 MNIST 逻辑回归的损失函数。

**def** **nll**(input, target):
    **return** **-**input[range(target**.**shape[0]), target]**.**mean()

训练循环

到目前为止，我们已经实现了训练 MNIST 逻辑回归所需的所有必要功能。我们将实施小批量培训。

bs **=** 64  *# batch size* loss_func **=** nll
lr **=** 0.5  *# learning rate*
epochs **=** 2  *# how many epochs to train for*

**for** epoch **in** range(epochs):
    **for** i **in** range((n **-** 1) **//** bs **+** 1):
        start_i **=** i ***** bs
        end_i **=** start_i **+** bs
        xb **=** x_train[start_i:end_i]
        yb **=** y_train[start_i:end_i]
        pred **=** model(xb)
        loss **=** loss_func(pred, yb)

        loss**.**backward()
        **with** torch**.**no_grad():
            weights **-=** weights**.**grad ***** lr
            bias **-=** bias**.**grad ***** lr
            weights**.**grad**.**zero_()
            bias**.**grad**.**zero_()

。loss_func 上的 backward()执行参数更新所需的所有梯度计算。一旦计算出梯度。backward()，权重和偏差由梯度和学习率的乘积更新。学习率(LR)用于控制收敛。大 LR 会过冲，而小 LR 会减慢收敛。

一旦权重和偏差被更新，它们的梯度被设置为零；否则，梯度将在下一批中累积。

总结

上面实现的梯度下降非常基本，但足以演示它是如何工作的。PyTorch 和 TensorFlow 等现代机器学习框架有更复杂的梯度下降变体，如 SGD、Adam 等。尽管如此，当我们需要训练机器学习模型时，理解梯度下降如何工作是有益的。

本文中的等式摘自 Christopher M. Bishop 的《模式识别和机器学习》。

毕业于 GANs:从理解生成性对抗网络到经营自己的网络

原文：https://towardsdatascience.com/graduating-in-gans-going-from-understanding-generative-adversarial-networks-to-running-your-own-39804c283399?source=collection_archive---------4-----------------------

阅读如何生成对抗性网络(GANs)的研究和评估已经发展，然后实现自己的 GAN 生成手写数字

Visualization of the latent space for the MNIST dataset — you can make your own GAN that generates MNIST-like handwritten digits later in the post!

生殖对抗网络(GANs)已经接管了公众的想象力——通过人工智能生成的名人渗透流行文化，创造出在高端艺术拍卖会上以数千美元的价格在出售的艺术。

在本帖中，我们将探索:

甘斯简介
了解和评估 GANs
经营自己的 GAN

有大量的资源可以了解 GANs，所以本文的重点是了解如何评估 GANs。我们还将指导您运行自己的 GAN 来生成手写数字，如 MNIST。

Here’s one run of the GAN we’ll show you how to implement later on — see how the handwritten digits it generates become increasingly realistic as training progresses!

关于 GANs 的简要介绍

自 2014 年 Ian Goodfellow 的'Generative Adversarial Networks'论文发表以来，GANs 取得了爆炸式的进展，并带来了越来越现实的成果。

就在三年前，你可以在这个 Reddit 帖子上找到 Ian Goodfellow 对一个询问你是否可以用 GANs 发短信的用户的回复:

“gan 尚未应用于 NLP，因为 gan 仅针对实值数据定义。

gan 的工作原理是训练一个输出合成数据的生成器网络，然后对合成数据运行一个鉴别器网络。鉴频器网络输出相对于合成数据的梯度告诉您如何稍微改变合成数据，使其更加真实。

只有在基于连续数字的情况下，您才能对合成数据进行细微的更改。如果是基于离散数，就没办法稍作改动。

例如，如果输出像素值为 1.0 的图像，可以在下一步将该像素值更改为 1.0001。

如果输出“企鹅”这个词，下一步就不能把那个改成“企鹅+ .001”，因为没有“企鹅+ .001”这个词。你要从“企鹅”一路走到“鸵鸟”。

因为所有的 NLP 都是基于离散值的，比如单词、字符或字节，所以还没有人真正知道如何将 GANs 应用于 NLP。"

现在，GANs 正被用于创建各种内容，包括图像、视频、音频和文本。这些输出可以作为训练其他模型的合成数据，或者只是用来催生有趣的副业，比如【thispersondoesnotexist.com】【thisairbnbdoesnotexist.com/】这种机器学习媒介岗位不存在。😎

甘背后

GAN 由两个神经网络组成，一个是从零开始合成新样本的生成器，另一个是将训练样本与生成器生成的样本进行比较的鉴别器。鉴别器的目标是区分“真实”和“虚假”输入(即分类样本是来自模型分布还是真实分布)。正如我们所描述的，这些样本可以是图像、视频、音频片段和文本。

Simple GAN overview from Kiran Sudhir

为了合成这些新样本，生成器被给予随机噪声，并试图从训练数据的学习分布中生成逼真的图像。

鉴别器网络(卷积神经网络)的输出相对于合成数据的梯度告知如何稍微改变合成数据以使其更真实。最终，生成器收敛于再现真实数据分布的参数，并且鉴别器无法检测到差异。

您可以在 GAN Lab 中看到并体验这些聚合数据分布:

[## 甘实验室:在你的浏览器中玩生成性对抗网络！

GAN 实验室是由 Minsuk Kahng，Nikhil Thorat，Polo Chau，Fernanda Viégas 和 Martin Wattenberg 创建的，他们是…

poloclub.github.io](https://poloclub.github.io/ganlab/)

这里有一些关于甘斯的最佳指南:

斯坦福 CS231 第 13 讲——生成模型
基于风格的 GANs
理解生成性对抗网络
生成性对抗网络简介
莉莲·翁:从甘到 WGAN
一头扎进高级甘斯:探索自我关注和光谱标准
Guim Perarnau:奇异的甘以及在哪里可以找到他们

了解和评估 GANs

量化 GAN 的进展可能感觉非常主观— “这个生成的人脸看起来足够逼真吗？”、“这些生成的图像足够多样吗？”—GANs 可能感觉像是黑匣子，不清楚模型的哪些组成部分会影响学习或结果质量。

为此，麻省理工学院计算机科学和人工智能(CSAIL)实验室的一个小组最近发布了一篇论文，“ GAN 解剖:可视化和理解生成性对抗网络”,介绍了一种可视化 GAN 的方法，以及 GAN 单元如何与图像中的对象以及对象之间的关系相关联。

Figure 1 from Bau et. al 2019 showing image modification through intervention with certain GAN units.

使用基于分段的网络剖析方法，本文的框架允许我们剖析和可视化发电机神经网络的内部工作。这是通过寻找一组 GAN 单元(称为神经元)与输出图像中的概念(如树、天空、云等)之间的一致来实现的。因此，我们能够识别负责某些物体(如建筑物或云)的神经元。

使神经元具有这种粒度级别允许通过强制激活和去激活(消融)那些对象的相应单元来编辑现有图像(例如，添加或移除图像中所示的树)。

然而，尚不清楚网络是否能够推理场景中的对象，或者它是否只是记忆这些对象。接近这个问题答案的一个方法是试图以不切实际的方式扭曲图像。也许麻省理工学院 CSAIL 的 GAN Paint 交互式网络演示最令人印象深刻的部分是该模型似乎能够将这些编辑限制在“照片级”更改。如果你试图将草添加到天空中，会发生以下情况:

尽管我们激活了相应的神经元，但 GAN 似乎抑制了后面几层的信号。

Figure 11 from Bau et. al. 2019 shows how the local context for an object impacts the likelihood of the object synthesis (in this case, the likelihood of a door being generated on a building versus on a tree or in the sky).

另一种可视化 GAN 的有趣方式是进行潜在空间插值(记住，GAN 通过从已学习的潜在空间采样来生成新的实例)。这是查看生成的样本之间的过渡有多平滑的有用方法。

这些可视化可以帮助我们理解 GAN 的内部表示，但找到量化的方法来理解 GAN 的进展和输出质量仍然是一个活跃的研究领域。

图像质量和多样性的两个常用评估指标是:初始得分和弗雷歇初始距离(FID) 。在 Shane Barratt 和 Rishi Sharma 发布了他们的论文“关于初始分数的注释”之后，大多数从业者已经从初始分数转向 FID。

初始得分

Salimans 等人于 2016 年在“训练 GANs 的改进技术”中发明了 Inception 评分，该评分基于一种启发式方法，即当现实样本通过预先训练的网络(如 ImageNet 上的 Inception)时，应该能够对其进行分类。从技术上讲，这意味着样本应该具有低熵 softmax 预测向量。

除了高预测性(低熵)，初始分数还基于所生成样本的差异程度(例如，所生成样本分布的高方差或熵)来评估 GAN。这意味着不应该有任何统治阶级。

如果这两个特征都满足了，那么就应该有一个大的初始得分。结合这两个标准的方法是评估样本的条件标签分布和所有样本的边际分布之间的 Kullback-Leibler (KL)散度。

弗雷歇初始距离

由 Heusel et al. 2017 推出，FID 通过测量生成的图像分布与真实分布之间的距离来估计真实感。FID 将一组生成的样本嵌入到由初始网的特定层给出的特征空间中。该嵌入层被视为连续的多元高斯，然后对生成的数据和真实数据估计均值和协方差。然后使用这两个高斯函数之间的弗雷歇距离(也称为 Wasserstein-2 距离)来量化生成样本的质量。较低的 FID 对应于更相似的真实样本和生成样本。

一个重要的注意事项是，FID 需要一个合适的样本量来给出好的结果(建议大小= 50k 样本)。如果使用的样本太少，最终会高估实际的 FID，估计值会有很大的差异。

关于不同论文之间的 Inception 分数和 FID 分数的比较，见 Neal Jean 的帖子这里。

想看更多吗？

Aji Borji 的论文“[GAN 评估方法的利弊](http://Pros and Cons of GAN Evaluation Measures)”包括一个非常好的表格，更详尽地涵盖了 GAN 评估指标:

有趣的是，其他研究人员正在通过使用特定领域的评估指标来采取不同的方法。对于文本 GAN，Guy Tevet 和他的团队在他们的论文“评估文本 GAN 作为语言模型”中提出使用传统的基于概率的语言模型度量来评估 GAN 生成的文本的分布。

我的甘有多好？’，Konstantin Shmelkov 和他的团队使用了两种基于图像分类的方法，GAN-train 和 GAN-test，这两种方法分别接近于 GAN 的召回率(多样性)和精确度(图像质量)。你可以在谷歌大脑研究论文中看到这些评估指标，“GANS 创造了平等吗”中，他们使用三角形数据集来测量不同 GAN 模型的精度和召回率。

运行您自己的 GAN

为了说明 GANs，我们将改编来自 Wouter Bulten 的这篇优秀教程，它使用 Keras 和 MNIST 数据集来生成书面数字。

完整教程笔记本见这里。

We’ll be tracking our GAN’s progress by visualizing our loss and accuracy curves but also by checking test outputs using Comet.ml

该 GAN 模型将 MNIST 训练数据和随机噪声作为输入(具体地，噪声的随机向量)来生成:

图像(在这种情况下，是手写数字的图像)。最终，这些生成的图像将类似于 MNIST 数据集的数据分布。
鉴别器对生成图像的预测

生成器和鉴别器模型一起形成对抗模型——对于这个例子，如果对抗模型的输出将生成的图像分类为所有输入的真实图像，那么生成器将表现良好。

看完整的代码这里和完整的彗星实验结果这里

跟踪模型的进度

我们能够使用 Comet.ml 来跟踪我们的生成器和鉴别器模型的训练进度。

我们正在绘制鉴别模型和对抗模型的准确性和损失图，这里要跟踪的最重要的指标是:

鉴频器的损耗(见右图中的蓝线)——dis _ loss
对抗模型的准确性(见左图中的蓝线)——ACC _ adv

此处 见本实验 的训练进度。

您还想确认您的培训过程确实使用了 GPU，这可以在Comet 系统指标选项卡中查看。

您会注意到我们的训练 for-loop 包含了从测试向量中报告图像的代码:

if i % 500 == 0:
        # Visualize the performance of the generator by producing images from the test vector
        images = net_generator.predict(vis_noise)
        # Map back to original range
        #images = (images + 1 ) * 0.5
        plt.figure(figsize=(10,10))

        for im in range(images.shape[0]):
            plt.subplot(4, 4, im+1)
            image = images[im, :, :, :]
            image = np.reshape(image, [28, 28])

            plt.imshow(image, cmap='gray')
            plt.axis('off')

        plt.tight_layout()
        # plt.savefig('/home/ubuntu/cecelia/deeplearning-resources/output/mnist-normal/{}.png'.format(i)) plt.savefig(r'output/mnist-normal/{}.png'.format(i)) experiment.log_image(r'output/mnist-normal/{}.png'.format(i)) plt.close('all')

我们希望每隔几个步骤就报告生成的输出的部分原因是，我们可以直观地分析我们的生成器和鉴别器模型在生成真实的手写数字和正确地将生成的数字分别分类为“真”或“假”方面的表现。

让我们来看看这些生成的输出！

在慧星实验中查看自己生成的输出

你可以看到生成器模型是如何从这个模糊的灰色输出开始的(见下面的 0.png ),它看起来不像我们期望的手写数字。

随着训练的进行，我们的模型损失下降，生成的数字变得越来越清晰。在以下位置查看生成的输出:

步骤 500:

步骤 1000:

步骤 1500:

最后，在步骤 10，000 — 中，您可以在下面的红色方框中看到一些 GAN 生成的数字样本

一旦我们的 GAN 模型完成训练，我们甚至可以在 Comet 的图形选项卡中以电影形式查看我们报告的输出(只需按下播放按钮！).

为了完成实验，请务必运行experiment.end()来查看模型和 GPU 使用情况的一些汇总统计数据。

迭代你的模型

我们可以对模型进行更长时间的训练，看看这是如何影响性能的，但让我们尝试用几个不同的参数进行迭代。

我们尝试的一些参数是:

鉴别器的优化器
学习率
退出概率
批量

从 Wouter 的原始博文中，他提到了自己在测试参数方面的努力:

我测试了鉴别器的优化器的SGD、RMSprop和Adam，但是RMSprop表现最好。RMSprop使用了低学习率，我将值修剪在-1 和 1 之间。学习速度的小幅下降有助于稳定

我们将尝试将鉴别器的退出概率从 0.4 增加到 0.5，同时增加鉴别器的学习率(从 0.008 增加到 0.0009)和生成器的学习率(从 0.0004 增加到 0.0006)。很容易看出这些变化是如何失去控制的，并且很难跟踪…🤯

要创建一个不同的实验，只需再次运行实验定义单元，Comet 将为您的新实验发布一个新的 url！记录你的实验很好，这样你就可以比较不同之处:

See the difference between the two experiments’ hyperparameters. Can you spot the differences in learning rate and dropout probability that we made?

不幸的是，我们的调整并没有提高模型的性能！事实上，它产生了一些有趣的输出:

本教程到此为止！如果你喜欢这篇文章，请和你的朋友分享，他可能会觉得这篇文章很有用😎

👉🏼有问题或反馈吗？下面评论！

👉🏼想要更多牛逼的机器学习内容？F 在媒体上关注我们！

格兰杰因果关系和向量自回归模型预测

原文：https://towardsdatascience.com/granger-causality-and-vector-auto-regressive-model-for-time-series-forecasting-3226a64889a6?source=collection_archive---------1-----------------------

预测建模和统计分析

计量经济模型和时间序列数据

【F】黄金和石油受到学术界、投资者和政府机构等的高度关注。这两种产品因其对全球经济的重大影响而闻名。我将在这里展示，如何利用 格兰杰因果检验 来检验时间序列中多个变量的关系，以及 向量自回归模型(VAR) 来预测未来 黄金&石油 价格从 黄金价格、白银价格、原油价格、股票指数、利率和美元汇率 的历史数据中。

黄金价格与其他商品密切相关。石油价格的上涨会对黄金价格产生正面影响，反之亦然。从历史上看，我们已经看到，当股票上涨时，黄金价格就会下跌。

时间序列预测问题公式化
一元和多元时间序列时间序列预测
将 VAR 应用到这个问题上

让我们了解一个多元时间序列是如何制定的。下面是多元时间序列的简单 K 方程，其中每个方程都是另一个序列的滞后。x 是这里的外生数列。目的是看这个系列是否受到它自己的过去以及其他系列的过去的影响。

这种系列允许我们对系列本身的动态以及其他系列的相互依赖性进行建模。我们将通过 格兰杰因果分析 来探究这种相互依存关系。

探索性分析:

让我们加载数据，并通过可视化进行一些分析，以了解数据的洞察力。探索性数据分析在多元时间序列中相当广泛。我将在这里介绍一些领域，以获得对数据的见解。然而，建议进行所有的统计测试，以确保我们对数据分布有清晰的理解。

让我们确定所有系列的日期。

数据中的 NaN 值用前几天的数据填充。在做了一些必要的预处理后，数据集现在可以进行进一步的分析了。

*# Plot
fig, axes = plt.subplots(nrows=3, ncols=2, dpi=120, figsize=(10,6))
for i, ax in enumerate(axes.flatten()):
 data = dataset[dataset.columns[i]]
 ax.plot(data, color=’red’, linewidth=1)
 ax.set_title(dataset.columns[i])
 ax.xaxis.set_ticks_position(‘none’)
 ax.yaxis.set_ticks_position(‘none’)
 ax.spines[“top”].set_alpha(0)
 ax.tick_params(labelsize=6)plt.tight_layout();*

从上面的图中，我们可以看出，所有的序列都包含单位根，具有随机趋势，表现出不可预测的系统模式。

为了从我们的数据中提取最多的信息，数据的正态或高斯分布是很重要的。为了验证这一点，我们做了一个基于零假设和交替假设直觉的正态性检验。

*stat,p = stats.normaltest(dataset.Gold)
print("Statistics = %.3f, p=%.3f" % (stat,p))
alpha = 0.05
if p> alpha:
print('Data looks Gaussian (fail to reject null hypothesis)')
else:
print('Data looks non-Gaussian (reject null hypothesis')output: Statistics = 658.293, p=0.000 Data looks Gaussian (reject null hypothesis*

这两个分布给了我们一些关于数据分布的直觉。这个数据集的峰度是-0.95。由于该值小于 0，因此它被认为是一个轻尾数据集。它在每条尾巴上的数据和在峰值上的一样多。中度偏度指的是-1 和-0.5 或 0.5 和 1 之间的值。

*plt.figure(figsize=(14,6))
plt.subplot(1,2,1)
dataset['Gold'].hist(bins=50)
plt.title('Gold')
plt.subplot(1,2,2)
stats.probplot(dataset['Gold'], plot=plt);
dataset.Gold.describe().T*

正态概率图也显示数据远非正态分布。

自相关:

如果我们不知道如何寻找自相关或序列相关性，那么在分析历史数据时，这可能是一个重大问题。

*# plots the autocorrelation plots for each stock's price at 50 lags
for i in dataset:
  plt_acf(dataset[i], lags = 50)
  plt.title('ACF for %s' % i)
  plt.show()*

从上面的图中我们可以看到,+1 的自相关性代表了完全的正相关，这意味着一个时间序列的增加会导致另一个时间序列的相应增加。我们肯定需要应用变换并中和它，以使级数稳定。它测量线性关系；即使自相关性很小，时间序列和其滞后版本之间仍可能存在非线性关系。

培训和测试数据:

VAR 模型将在 X_train 上拟合，然后用于预测接下来的 15 个观测值。这些预测将与试验数据中的实际数据进行比较。

*n_obs=15
X_train, X_test = dataset[0:-n_obs], dataset[-n_obs:]
print(X_train.shape, X_test.shape)(5114, 6) (15, 6)*

转型:

对训练集应用一阶差分使所有序列平稳。然而，这是一个迭代过程，在第一次差分后，序列可能仍然是非平稳的。在这种情况下，我们必须应用二阶差分或对数变换来标准化数列。

稳定性检查:

*def augmented_dickey_fuller_statistics(time_series):
  result = adfuller(time_series.values)
  print('ADF Statistic: %f' % result[0])
  print('p-value: %f' % result[1])
  print('Critical Values:')
  for key, value in result[4].items():
    print('\t%s: %.3f' % (key, value))print('Augmented Dickey-Fuller Test: Gold Price Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['Gold'])
print('Augmented Dickey-Fuller Test: Silver Price Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['Silver'])
print('Augmented Dickey-Fuller Test: Oil Price Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['Oil'])
print('Augmented Dickey-Fuller Test: Interest_rate Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['Interest_rate'])
print('Augmented Dickey-Fuller Test: Stock_Index Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['Stock_Index'])
print('Augmented Dickey-Fuller Test: USD_Index Time Series')
augmented_dickey_fuller_statistics(X_train_transformed['USD_Index'])*

*fig, axes = plt.subplots(nrows=3, ncols=2, dpi=120, figsize=(10,6))
for i, ax in enumerate(axes.flatten()):
d = X_train_transformed[X_train_transformed.columns[i]]
ax.plot(d, color='red', linewidth=1)# Decorations
ax.set_title(dataset.columns[i])
ax.xaxis.set_ticks_position('none')
ax.yaxis.set_ticks_position('none')
ax.spines['top'].set_alpha(0)
ax.tick_params(labelsize=6)
plt.tight_layout();*

格兰杰因果关系检验:

格兰杰因果关系的正式定义可以解释为，x 的过去值是否有助于 yt 的预测，取决于已经考虑了 y 的过去值(也许还有其他变量的过去值)对 yt 的影响。如果是这样的话，x 就是 y 的格兰杰原因。因此，VAR 背后的基础是系统中的每个时间序列都相互影响。

格兰杰因果关系检验回归方程中过去值的系数为零的零假设。因此，如果从测试中获得的 p 值小于 0.05 的显著性水平，那么，您可以安全地拒绝零假设。这是在原始数据集上进行的。

下面这段代码摘自stack overflow。

*maxlag=12
test = 'ssr-chi2test'
def grangers_causality_matrix(X_train, variables, test = 'ssr_chi2test', verbose=False):
dataset = pd.DataFrame(np.zeros((len(variables), len(variables))), columns=variables, index=variables)
for c in dataset.columns:
for r in dataset.index:
test_result = grangercausalitytests(X_train[[r,c]], maxlag=maxlag, verbose=False)
p_values = [round(test_result[i+1][0][test][1],4) for i in range(maxlag)]
if verbose: print(f'Y = {r}, X = {c}, P Values = {p_values}')
min_p_value = np.min(p_values)
dataset.loc[r,c] = min_p_value
dataset.columns = [var + '_x' for var in variables]
dataset.index = [var + '_y' for var in variables]
return dataset
grangers_causality_matrix(dataset, variables = dataset.columns)*

行是响应(y ),列是预测序列(x)。

如果我们在(第 1 行，第 2 列)中取值 0.0000，它指的是 Silver_x 引起 Gold_y 的格兰杰因果关系检验的 p 值，(第 2 行，第 1 列)中的 0.0000 指的是 Gold_y 引起 Silver_x 的 p 值，以此类推。
我们可以看到，在利息和美元变量的情况下，我们不能拒绝零假设，例如美元* & 白银，美元&石油。我们感兴趣的变量是黄金和石油这里。所以，对于黄金，所有的变量都会引起，但是对于美元不会对石油产生任何影响。***

因此，查看 p 值，我们可以假设，除了美元，系统中的所有其他变量(时间序列)是可互换的，互为因果。这证明了 VAR 建模方法对这一多时间序列系统进行预测的合理性。

风险值模型:

VAR 要求序列的平稳性，这意味着序列的均值不会随时间而改变(我们可以从 Augmented Dickey-Fuller Test 旁边的图中找到这一点)。

先来了解一下 VAR 模型的数学直觉。

在这里，每个系列都是通过它自己的滞后和其他系列的滞后来建模的。y{1，t-1，y{2，t-1}…是时间序列 y1，y2，…的滞后。分别是。上述方程被称为 VAR (1)模型，因为每个方程都是一阶的，也就是说，它包含每个预测因子(y1，y2，…)的一个滞后..).因为方程中的 y 项是相互关联的，所以 y 被认为是内生变量，而不是外生预测因子。为了防止结构不稳定的问题，VAR 框架被用来根据 AIC 选择滞后长度。

因此，我将在训练集上拟合 VAR 模型，然后使用拟合的模型预测接下来的 15 次观察。这些预测将与试验数据中的实际数据进行比较。我采用最大滞后(15)来确定风险值模型所需的滞后。

*mod = smt.VAR(X_train_transformed)
res = mod.fit(maxlags=15, ic='aic')
print(res.summary())*

最大的相关性是 0.38(白银&黄金)和-0.19(石油&美元)；然而，在这种情况下，有足够小的问题可以忽略。

残差图:

除了在 2009 年、2011 年、2014 年等期间有一些大的波动外，残差图看起来是正常的，始终具有恒定的平均值。

*y_fitted = res.fittedvalues
plt.figure(figsize = (15,5))
plt.plot(residuals, label='resid')
plt.plot(y_fitted, label='VAR prediction')
plt.xlabel('Date')
plt.xticks(rotation=45)
plt.ylabel('Residuals')
plt.grid(True)*

德宾-沃森统计:

德宾-沃森统计与自相关相关。

德宾-沃森统计值将总是在 0 和 4 之间。值为 2.0 意味着在样本中没有检测到自相关。从 0 到小于 2 的值表示正自相关，从 2 到 4 的值表示负自相关。根据经验，测试统计值在 1.5 到 2.5 之间是相对正常的。任何超出此范围的值都可能引起关注。

显示正自相关的股票价格将表明昨天的价格与今天的价格正相关，因此如果股票昨天下跌，它今天也可能下跌。另一方面，具有负自相关性的股票随着时间的推移会对自身产生负面影响——因此，如果它昨天下跌，今天上涨的可能性更大。

不存在自相关(2.0)；因此，我们可以继续进行预测。

预测:

为了进行预测，VAR 模型期望从过去的数据中得到多达滞后阶数的观察值。这是因为，风险值模型中的项本质上是数据集中各种时间序列的滞后，因此我们需要提供模型使用的滞后顺序所指示的尽可能多的先前值。

*# Get the lag order
lag_order = res.k_ar
print(lag_order)# Input data for forecasting
input_data = X_train_transformed.values[-lag_order:]
print(input_data)# forecasting
pred = res.forecast(y=input_data, steps=n_obs)
pred = (pd.DataFrame(pred, index=X_test.index, columns=X_test.columns + '_pred'))
print(pred)*

反转变换:

预测是生成的，但它是基于模型使用的训练数据的规模。所以，为了让它回到原来的比例，我们需要去差分。

转换差异的方法是将这些差异连续地加到基数上。一个简单的方法是首先确定索引处的累积和，然后将其加到基数上。

这个过程可以通过将前一时间步的观测值加到差值上来逆转。反演(ts) =差分(ts) +观测值(ts-1)

*# inverting transformation
def invert_transformation(X_train, pred):
forecast = pred.copy()
columns = X_train.columns
for col in columns:
forecast[str(col)+'_pred'] = X_train[col].iloc[-1] + forecast[str(col)+'_pred'].cumsum()
return forecast
output = invert_transformation(X_train, pred)#combining predicted and real data set
combine = pd.concat([output['Gold_pred'], X_test['Gold']], axis=1)
combine['accuracy'] = round(combine.apply(lambda row: row.Gold_pred /row.Gold *100, axis = 1),2)
combine['accuracy'] = pd.Series(["{0:.2f}%".format(val) for val in combine['accuracy']],index = combine.index)
combine = combine.round(decimals=2)
combine = combine.reset_index()
combine = combine.sort_values(by='Date', ascending=False)*

评估:

为了评估预测，可以计算一组全面的指标，如 MAPE、ME、MAE、MPE 和 RMSE。我们计算了其中的一些，如下所示。

*#Forecast bias
forecast_errors = [combine['Gold'][i]- combine['Gold_pred'][i] for i in range(len(combine['Gold']))]
bias = sum(forecast_errors) * 1.0/len(combine['Gold'])
print('Bias: %f' % bias)print('Mean absolute error:', mean_absolute_error(combine['Gold'].values, combine['Gold_pred'].values))print('Mean squared error:', mean_squared_error(combine['Gold'].values, combine['Gold_pred'].values))print('Root mean squared error:', sqrt(mean_squared_error(combine['Gold'].values, combine['Gold_pred'].values)))*

平均绝对误差告诉我们，平均而言，预测的误差有多大。我们的错误率很低，这表明我们有合适的模型。

总结:

VAR 模型是一种基于过去观测值的线性函数来预测多个时间序列联合动态的流行工具。还可以进行更多的分析，例如脉冲响应(IRF)和预测误差方差分解(FEVD)以及 VAR，以评估一项资产对另一项资产的冲击影响。但是，为了便于理解，我在这里将保持简单。在实际业务案例中，我们应该用不同的方法做多个模型来做比较分析，然后再锁定一个或一个混合模型。

我这里可以连接。******

注意:这里描述的程序是实验性的，应该谨慎使用。所有此类使用风险自负。

我想要精确的电影预算数据

原文：https://towardsdatascience.com/granular-film-budget-data-9970b06735e1?source=collection_archive---------9-----------------------

但我找了一段时间，还没找到多少。

我能找到的最详细的电影制作数据是在维基解密上，比如这个难忘的第三季的预算，还有这个采访 :

That there is some high-resolution budget data

我甚至不应该能够看到这两个行项目的电影预算，但我想要几千。我在哪里可以找到他们？我如何打开闸门？

数据科学训练营的学生经常做与电影相关的玩具项目，因为每个人都喜欢电影，并且因为在网络搜索结果的前几页中总是有很好的 kaggle-s 风格的表格电影数据集随时可用。有 OMdB ，在那里你可以查询一个漂亮的 REST-ful API 来获得一堆票房数据(并演示你可以调用 API 作为额外的奖励)。你甚至可以买一个升级的 OMdB 密匙，让你花一整美元就可以进行许多 API 调用。我为承担这样的项目而感到内疚，但是我感觉这个主题的变化太多了。

问题是，对于一些了解电影制作的人来说，公开的票房数据并不那么有趣。它们通常不会很深。我开始觉得真正有趣的电影制作和发行数据，尤其是关于预算的数据，在一些有围墙的花园里被保护得很好，当然这是真的。为什么要分享呢？

Some lame data from Kaggle

任何电影制作公司有什么动机去公开他们全部的、详细的项目预算呢？即使是那些在 Kickstarter 等平台上寻求众包资金的人，也不会被要求或期望提供超过“这就是我们需要的”标量值预算总额、古怪的推介视频，或许还有一些创意奖励。详细的电影预算在内部起草、批准、跟踪、上报给国税局，然后存档。

但是如果电影预算变得透明会怎么样呢？我们能学到什么？

电影制作的艺术和惊人的机械让我着迷，因为我大约十岁的时候就从我的父亲那里学习如何制作关键帧，他是一名视频编辑和电影摄影师。在过去十年的大部分时间里，我在旧金山的电影片场担任摄影助理和灯光技术员。我装上灯光车，重新备货灯光仓库。我搬到了纽约，和一家很棒的后期制作工作室签约做了几年的日常调色师。我非常高兴能参与一些很酷/很大的项目，在一些很棒的导师的指导下学习，学到了很多东西。我通常是一名技术人员，并且总是与主要角色关系密切:导演、摄影师、演员、制片人(在商业工作的情况下，还有代理人)。

我也看到了一部电影在不同的阶段，在某种程度上是如何失败的。当各级管理和创意人员犯错误或遗漏时，当预算分配不当时，当远见者被迫妥协他们的愿景时，或当信任错误地给予无能或好战或某种组合时，我看到了裂缝开始形成的地方。因此，我从该行业获得的主要收获是:

在一部电影作品中，有许多活动的部分，它比你想象的更像一次军事行动；时间变得异常珍贵；成功的程度与准备的程度正相关；专业设备往往是必要的，但不应该分散真正的创造性元素；工作人员、演员和赞助人的积极动机(如故事质量和总血糖水平等因素)赋予了电影生命；金钱是一种肮脏的邪恶，但在整个过程的许多阶段都是完全必要的。拥有特殊技能的人需要为他们的劳动获得报酬，他们需要购买和租赁特殊的材料和工具，需要贿赂特殊地点的看门人以获得访问和许可。每个人都要被喂养和穿梭。一切都必须投保，而且一切都必须按计划进行。

一般来说，新电影制作人低估了他们将承担的费用和他们需要的时间。有经验的电影制作人更擅长估算预算和时间要求，或者雇佣一个由 T2 人组成的中队来为他们做这件事。这并不能阻止令人厌恶的大量时间和金钱在隐喻的垃圾箱火灾中燃烧，其频率在整个行业都令人震惊。

我想说的是:一部电影制作分配预算的方式对其成败至关重要，如果能获得更精细的示例数据，那将会很有趣。每部作品的要求都是完全独特的，所以如果你深入研究，每个预算都会有所不同，但我们可以做得更好，而不仅仅是看 IMdB 上列出的总制作预算，这些预算通常是他们实际花费的几分之一或几倍，原因如下。只要制作预算保密，电影制作，总的来说，在如何花钱上不会变得更聪明。

如果我们只知道几千部电影如何在[前期/前期/后期/销售]阶段之间分配他们的预算，以及他们的结局如何，会怎么样？如果我们能看到几千部电影如何在[制作/摄像/灯光/艺术/服装/餐饮/演员]部门之间分配预算，并了解这如何影响电影的成功，会怎么样？我想要那些数据。

我最喜欢的衡量一部电影“成功”的基本标准是一个简单的比率:它在全球范围内产生的收入(是的，有时是由质的验证因素推动的，如奥斯卡奖或狮或 Prixe )与其总支出的比率——从前期制作一直到制作、后期制作、营销和发行；所有费用。这个标准有利于那些以少赚多的电影制作人，世界上的乔丹·皮尔 s，而不是詹姆斯·卡梅隆，后者必然会获得巨大的资源。我肯定卡梅隆在职业生涯的早期很好斗，但你明白我的意思。

电影制作人不需要有大数据集的学生来弄清楚恐怖类型是非常有利可图的。从 20 世纪 60 年代开始，罗杰·科尔曼就在这个事实的基础上建立了自己的事业和持久的遗产:几十年来，他一直告诉新制片人，把几个美国青少年(穿着美国运动鞋和雷朋，嚼着美国泡泡糖，开着美国车)限制在一个鬼屋的位置，把他们切碎，喷洒一些假血，在国际领土上做一些创造性的许可，赚回你预算的数倍，并活着看到另一个导演机会，这是明智而廉价的。顺便说一句，不要在你的剧本里写任何夜间外景，有很多台词的儿童角色，也不要写动物。

Indie Glimmer

达拉斯买家俱乐部是一部赢得 2013 年奥斯卡三项大奖的电影，从其 500 万美元的预算中获得了 1200%的回报。据称，整个电影的化妆部门获得 250 美元(原文如此),并为自己赢得了奥斯卡奖。据说，加拿大的大金融家在最后一刻退出了，所以这部电影的 800 万美元预算一夜之间化为乌有。一位强大的制片人相信这部电影，并在接下来的周末设法筹集了 500 万美元来维持这个项目。为了让缩减的预算发挥作用，生产部门削减了整个照明部门，但保留了马修·麦康纳。这很好。

但是，他们到底是怎么花掉这 500 万美元的呢？难道每个“低预算”(少于 1000 万美元)的制片人都不关心午餐花了多少钱吗？

But how much did they spend on location scouting?

数字提供了一些样本数据集，但同样，从生产的角度来看，它们并没有让我对完整的数据库抱有希望。每个人似乎都更关心为电影成品确定有效的收入来源，而不是在电影制作过程中优化支出！

我会继续寻找，但在这篇文章中，我不确定在哪里可以找到我想要的东西。

附言:一个有机会接触神秘知识的 NYU·提施毕业生发给我这个:

“如果你在寻找电影预算数据，你不会找到的。这是业内高度保密的秘密。没有人愿意承认他们在一部电影上花了多少钱，因为如果它真的失败了，他们不想让任何人知道有多糟糕——如果他们成功了，他们仍然希望能够声称他们没有盈利。”

如果我们能把这类数据收集在一个匿名的大袋子里会怎么样？难道不是每个人都可以对它进行逆向工程来找出哪部电影是哪部吗？我们有没有办法让电影公司公布预算数字？

图形算法(第二部分)

原文：https://towardsdatascience.com/graph-algorithms-part-2-dce0b2734a1d?source=collection_archive---------4-----------------------

内线艾

Python 中的主要概念、属性和应用

Corsica, France

这些天来，无论你是想通过预测潜在的联系来了解社交网络的结构，检测欺诈，了解汽车租赁服务的客户行为，还是提出实时建议，raphs 都成为机器学习的核心。

在本文中，我们将讨论:

主要的图形算法
插图和使用案例
Python 中的示例

本文原载于我的个人博客:https://maelfabien.github.io/ml/#

我在这个资源库上发布我所有的文章和相应的代码:

[## mael fabien/机器学习教程

本报告包含练习、代码、教程和我的个人博客文章

github.com](https://github.com/maelfabien/Machine_Learning_Tutorials)

如果您还没有，请务必阅读我的第一篇文章:

[## 图表介绍(第一部分)

Python 中的主要概念、属性和应用

towardsdatascience.com](/introduction-to-graphs-part-1-2de6cda8c5a5)

新:第 3 部出来了！

[## 用 Python 学习图形(第 3 部分)

Python 的概念、应用和示例

towardsdatascience.com](/learning-in-graphs-with-python-part-3-8d5513eef62d)

接下来，打开 Jupyter 笔记本，导入以下包:

import numpy as np
import random
import networkx as nx
from IPython.display import Image
import matplotlib.pyplot as plt

以下文章将使用最新版本的networkx``2.x。NetworkX 是一个 Python 包，用于创建、操作和研究复杂网络的结构、动态和功能。

我将尽量保持一种实用的方法，并举例说明每个概念。

在上一篇文章中，我们介绍了图的主要种类，以及描述图的基本特征。我们现在将更详细地介绍图形分析/算法以及分析图形的不同方法。

为了理解上下文，下面是一些图算法的用例:

实时欺诈检测
实时推荐
简化法规遵从性
复杂网络的管理和监控
身份和访问管理
社交应用/功能
…

目前大多数框架都支持三种主要的图形算法(例如 Python 中的networkx或 Neo4J):

寻路:根据可用性和质量等确定最佳路径。我们还将在这一类别中包括搜索算法。例如，这可用于识别最快路线或交通路线。
中心性:确定网络中节点的重要性。这可以用来识别社交媒体中的影响者或者识别网络中的潜在攻击目标。
社区检测:评估一个群体是如何聚集的。这可用于细分客户和检测欺诈等。

我们还将在下周发表的第三篇文章中开发图形中的机器学习基础和图形学习。在 Networkx 中实现的所有算法都可以在这里找到:

[## 算法- NetworkX 2.3 文档

编辑描述

networkx.github.io](https://networkx.github.io/documentation/stable/reference/algorithms/index.html)

您会注意到，我们将只讨论在 Networkx 中实现的基本和最常见的算法。

I .寻路和图搜索算法

寻路算法试图通过最小化跳数找到两个节点之间的最短路径。
搜索算法没有给出最短路径。取而代之的是，他们通过考虑图的邻居或深度来探索图。这可以用于信息检索。

1。搜索算法

有两种主要的图形搜索算法:

广度优先搜索(BFS) 首先搜索每个节点的邻居，然后是邻居的邻居…
深度优先搜索(DFS) 尝试尽可能地沿着一条路径走下去，如果可能的话，访问新邻居。

Search Algorithms

2。寻路算法

a .最短路径

最短路径计算一对节点之间最短的加权(如果图是加权的)路径。

例如，它用于识别社交网络上两个人之间的最佳驾驶方向或分离程度。

有许多方法可以计算图中的最短路径，包括 Dijkstra 的算法，Networkx 中的默认算法。

根据维基百科，该算法的伪代码如下:

将图中的所有节点标记为未访问。创建所有未访问节点的集合，称为未访问集合。
给每个节点分配一个试探性的距离值:对于初始节点，将其设置为零；对于所有其他节点，将其设置为无穷大。将初始开始节点设置为当前节点。
对于当前节点，考虑其所有未访问的邻居，并计算它们通过当前节点的暂定距离。将新计算的暂定距离与当前分配值进行比较，并分配较小的一个。例如，如果当前节点 A 被标记为距离 6，并且连接它和邻居 B 的边的长度为 2，那么通过 A 到 B 的距离将是 6 + 2 = 8。如果 B 之前标记的距离大于 8，则将其更改为 8。否则，保持当前值。
当我们考虑完当前节点的所有未访问邻居后，将当前节点标记为已访问，并将其从未访问集合中移除。被访问的节点将不再被检查。
如果目的地节点已经被标记为已访问(当计划两个特定节点之间的路线时)或者如果未访问集合中的节点之间的最小暂定距离是无穷大(当计划完整遍历时；当初始节点和剩余的未访问节点之间没有连接时发生)，然后停止。算法已经完成。
否则，选择标有最小暂定距离的未访问节点，将其设置为新的“当前节点”，并返回步骤 3。

如果你想了解更多关于最短路径的问题，请看这篇文章:https://en.wikipedia.org/wiki/Shortest_path_problem

Wikipedia’s illustration of the Dijkstra’s algorithm

在 Python 中，实现非常简单:

# Returns shortest path between each node
nx.shortest_path(G_karate)

这将返回图中每个节点之间的最短路径列表:

{0: {0: [0],
    1: [0, 1],
    2: [0, 2],
    ...

b .单源最短路径

单源最短路径(SSSP)查找图中给定节点和所有其他节点之间的最短路径。

例如，它通常用于 IP 网络的路由协议。

c .所有对最短路径

“所有对最短路径”(APSP)算法寻找所有节点对之间的最短路径。

尽管提供了相似的结果，但它比针对每对节点调用单一源最短路径更快。该算法通常可用于确定交通网格不同路段的预期交通负荷。

# Returns shortest path length between each node
list(nx.all_pairs_shortest_path_length(G_karate))

它返回:

[(0,
    {0: 0,
    1: 1,
    2: 1,
    3: 1,
    4: 1,
    ...

d .最小重量生成树

最小生成树是连接图中所有节点的边权重之和最小的图(树)的子图。

最小生成树应该应用于无向图。

from networkx.algorithms import tree
mst = tree.minimum_spanning_edges(G_karate, algorithm='prim', data=False)
edgelist = list(mst)
sorted(edgelist)

它返回:

[(0, 1),
(0, 2),
(0, 3),
(0, 4),
(0, 5),
(0, 6),
...

二。社区检测

社区检测根据给定的 质量准则 将节点划分成若干个 组。

它通常用于识别社交社区、客户行为或网页主题。

社区是一组连接的节点。然而，尽管社区内的节点应该是紧密连接的，但是没有一个通用的定义可以用来定义社区。

Communities

寻找社区的一种常见算法是格文纽曼算法。它通过逐步移除网络中的边来识别社区。我们将把中间性称为“边中间性”。它是一个与通过这条边的节点对之间的最短路径数成比例的分数。

该算法的步骤如下:

计算网络中所有现有边的介数。
移除具有最高介数的边。
移除此边后，重新计算所有边的介数。
重复第 2 步和第 3 步，直到没有剩余的边。

要在 Python 中实现这一点，可以使用以下代码:

from networkx.algorithms import communityk = 1
comp = community.girvan_newman(G_karate)for communities in itertools.islice(comp, k):
    print(tuple(sorted(c) for c in communities))

这是属于每个社区的节点列表的开头(k=1 表示我们期望 2 个社区):

([0, 1, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16, 17, 19, 21], [2, 8, 9, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33])

如上所述，这种方法没有真正的规模。由于这个原因，已经开发了诸如 Louvain 方法的方法。然而，这种方法在大型图上运行起来确实很长。

3.鲁汶模块化

在定义 Louvain 方法之前，引入模块化的概念是很重要的。模块性是对组被划分为集群的良好程度的度量:

Modularity

卢万方法的伪码如下:

首先为每个节点分配一个社区
交替接下来的 2 个步骤，直到收敛:
创建一个具有相邻节点的新社区，以最大化模块化
创建新的加权图。前一步的社区成为图的节点

现在这可能看起来有点混乱。事实上，我们所做的唯一事情就是对最近的节点进行分组，以便优化模块化标准。

Louvain Method

请注意，卢万方法没有理论上的保证，但在实践中效果很好。卢万的方法作为 NetworkX 的一个子项目出现，就在这里:https://python-louvain.readthedocs.io/en/latest/

首先，安装软件包:

pip install python-louvain

然后，计算最佳分区(基于 Louvain 方法):

import community
partition = community.best_partition(G_karate)pos = nx.spring_layout(G_karate)
plt.figure(figsize=(8, 8))
plt.axis('off')
nx.draw_networkx_nodes(G_karate, pos, node_size=600, cmap=plt.cm.RdYlBu, node_color=list(partition.values()))
nx.draw_networkx_edges(G_karate, pos, alpha=0.3)
plt.show(G_karate)

Best partition of the Karate Graph using Louvain

4.强连通分量

强连通分量(SCC)算法在有向图中找到多组 连通节点 。注意，每个节点必须是从同一组中的任何其他节点在 两个方向 上**可达 。

它通常在图表分析过程的早期使用，让我们了解我们的图表是如何构建的，例如，当我们查看谁拥有哪个公司的股份时，探索财务报表数据(例如，想想巴拿马文件)。

5.弱连通分量(联合查找)

弱连通分量或联合查找算法在有向图中查找 连通节点 的集合，其中每个节点是从同一集合中的任何其他节点可达的。

它只需要在一个方向的节点对之间存在一条路径，而 SCC 需要在两个方向都存在一条路径。与 SCC 一样，Union Find 通常在分析的早期用于理解图的结构。

Union-Find 是一个预处理步骤，对于理解图的结构来说，在任何算法之前都是必不可少的。

我们可以使用以下方法测试连通有向图:

*nx.is_weakly_connected(G)
nx.is_strongly_connected(G)*

或者对于无向图，使用:

*nx.is_connected(G_karate)*

它返回一个布尔值。

确保查看关于实施连接的 Networkx 文档。

6.分层聚类

在层次聚类中，我们构建一个的层次聚类。我们用一个 树状图来表示下面的聚类。**

Dendrogram

这个想法是分析不同尺度的社区结构。我们通常自底向上构建树状图。我们从每个节点的一个集群开始，合并两个“最近”的节点。

但是我们如何测量星团是否很接近呢？我们使用相似距离。设 d(i，j)是 I 和 j 之间最短路径的长度。

Similarity Distances

对于最大链接，在每一步，由最短距离分开的两个聚类被组合。相似性距离可以如下所示:

Linkage

回到我们空手道的例子。在应用层次聚类之前，我们需要定义每个节点之间的距离矩阵。

**pcc_longueurs=list(nx.all_pairs_shortest_path_length(G_karate))
distances=np.zeros((n,n))# distances[i, j] is the length of the shortest path between i and j
for i in range(n):
    for j in range(n):
        distances[i, j] = pcc_longueurs[i][1][j]**

现在，我们将使用sklearn的AgglomerativeClustering函数来识别层次聚类。

**from sklearn.cluster import AgglomerativeClusteringclustering = AgglomerativeClustering(n_clusters=2,linkage='average',affinity='precomputed').fit_predict(distances)**

最后，根据分类用不同的颜色绘制结果图:

**nx.draw(G_karate,  node_color = clustering)**

Hierarchical Clustering

7.聚类系数

聚类系数衡量两个节点趋向于 聚类 在一起的程度。

局部聚类系数是以节点 I 为中心的三角形的数量与以节点 I 为中心的三元组的数量之比。在某种意义上，它衡量节点 I 及其邻居与完整图形的接近程度。

Clustering Coefficient

我尝试用下图来说明聚类系数的计算:

Clustering Coefficient

****全局系数测量图形中三角形(局部聚类)的密度:

Global Clustering Coefficient

在上图中，聚类系数等于:

对于 Erdos-Rényi 随机图，E[聚类系数]=E[Ci]=p 其中 p 为上一篇文章定义的概率。

对于 Baràbasi-Albert 随机图，全局聚类系数根据节点数遵循幂律。度为 k 的节点的平均聚类系数与 k 的倒数成正比:

具有低等级的节点连接到其社区中的其他节点。度数高的节点链接到不同社区的节点。

对于给定的图，在networkx中，可以很容易地计算出聚类系数。首先，让我们从局部聚类系数开始:

**# List of local clustering coefficients
list(nx.clustering(G_barabasi).values())**

这应该会返回类似于以下内容的内容:

**0.13636363636363635,
0.2,
0.07602339181286549,
0.04843304843304843,
0.09,
0.055384615384615386,
0.07017543859649122,
...**

并对结果进行平均，以找到图的全局聚类系数:

**# Global clustering coefficient
np.mean(list(nx.clustering(G_barabasi).values()))**

哪些标题:

**0.0965577637155059**

三。中心算法

中心性衡量一个节点的重要性。这不是一个清晰的定义，但当我们想要识别重要的网页、交通网络中的瓶颈时，这很有用…

一条步行是一条可以多次通过同一个节点的路径。中心性度量随着所考虑的行走类型和计算它们的方式而变化。

1.PageRank 算法

*****page rank*从其链接的邻居，然后再从它们各自的邻居，估计当前节点的重要性。

虽然是由谷歌推广的，但这是一种检测任何网络中有影响力节点的方法。例如，它被用来暗示社交网络上的联系。

PageRank 是通过迭代地将一个节点的等级(最初基于度)分配给它的邻居，或者通过随机遍历图形并计算在这些遍历期间命中每个节点的频率来计算的。

Neo4J summary of the Page Rank Algorithm

PageRank 通常是在有向图上计算的。但是，它也可以通过将有向图中的每条边转换为两条边来在无向图上执行。

例如，空手道图的 PageRank 可以通过以下方式访问:

**nx.pagerank(G_karate, alpha=0.9)**

其中，alpha 是阻尼参数(默认为 0.85)。作为回报，它会给你一个排名列表:

**{0: 0.09923208031303203,
 1: 0.0543403155825792,
 2: 0.05919704684187155,
 3: 0.036612460562853694,
...**

2.程度中心性

度中心性 统计结束于节点 I 的长度为 1 的行走次数

它衡量传入和传出的关系。它由 C(Xi)=di 给出。例如，度中心性用于识别社交网络上最有影响力的人。

**c_degree = nx.degree_centrality(G_karate)
c_degree = list(c_degree.values())**

3.特征向量中心性

特征向量中心性是在节点 I 结束的无限长的行走的数量。

这使得具有良好连接的邻居的节点更加重要。

Eigenvector Centrality

**c_eigenvector = nx.eigenvector_centrality(G_karate)
c_eigenvector = list(c_eigenvector.values())**

4.接近中心性

接近中心度 通过图形检测能够有效传播信息的节点。

它可以用来识别假新闻账户或恐怖分子的细胞，以隔离那些可以传播信息的个人。

接近中心性与到其他节点的最短路径的长度之和成反比。

**c_closeness = nx.closeness_centrality(G_karate)
c_closeness = list(c_closeness.values())**

5.中间中心性

中间中心性 检测一个节点对图中信息流的影响程度。

它通常用于查找充当从图的一部分到另一部分的桥梁的节点，例如在电信网络中的包裹递送处理器中，或者在假新闻的传播中。

其中:

σJK j 和 k 之间的最短路径数
σJK(I)j 和 k 之间经过 I 的最短路径数

介数中心性测量一个节点作为两个节点之间的桥梁的次数。例如:

Centrality Measure

**c_betweenness = nx.betweenness_centrality(G_karate)
c_betweenness = list(c_betweenness.values())**

在 Python 中，实现依赖于networkx的内置函数:

**# Plot the centrality of the nodes
plt.figure(figsize=(18, 12))# Degree Centrality
f, axarr = plt.subplots(2, 2, num=1)
plt.sca(axarr[0,0])
nx.draw(G_karate, cmap = plt.get_cmap('inferno'), node_color = c_degree, node_size=300, pos=pos, with_labels=True)
axarr[0,0].set_title('Degree Centrality', size=16)# Eigenvalue Centrality
plt.sca(axarr[0,1])
nx.draw(G_karate, cmap = plt.get_cmap('inferno'), node_color = c_eigenvector, node_size=300, pos=pos, with_labels=True)
axarr[0,1].set_title('Eigenvalue Centrality', size=16)# Proximity Centrality
plt.sca(axarr[1,0])
nx.draw(G_karate, cmap = plt.get_cmap('inferno'), node_color = c_closeness, node_size=300, pos=pos, with_labels=True)
axarr[1,0].set_title('Proximity Centrality', size=16)# Betweenness Centrality
plt.sca(axarr[1,1])
nx.draw(G_karate, cmap = plt.get_cmap('inferno'), node_color = c_betweenness, node_size=300, pos=pos, with_labels=True)
axarr[1,1].set_title('Betweenness Centrality', size=16)**

The different centrality measures

我们观察到由中心性度量突出显示的不同节点是非常不同的。例如，中间中心性产生的结果与其他方法相差甚远，因为它们测量的不是同样的东西。

四。结论

我们现在已经介绍了图的介绍、图的主要类型、不同的图算法以及它们在 Python 和 Networkx 中的实现。

在下一篇文章中，我们将讨论图学习，它提供了预测图中节点和边的方法，以处理丢失的值或预测新的关系。

如果您有任何问题或意见，请随时评论。敬请期待，本系列的最后一篇文章将于下周问世:)

来源:

Neo4j 中的图形算法综合指南
**网络 x 文档，【https://networkx.github.io/documentation/stable/ **

如果你想从我这里读到更多，我以前的文章可以在这里找到:

** [## 图表介绍(第一部分)

Python 中的主要概念、属性和应用

towardsdatascience.com](/introduction-to-graphs-part-1-2de6cda8c5a5) [## 用 Python 学习图形(第 3 部分)

Python 的概念、应用和示例

towardsdatascience.com](/learning-in-graphs-with-python-part-3-8d5513eef62d) [## 马尔可夫链和 hmm

在本文中，我们将关注马尔可夫模型，何时何地应该使用它们，以及隐马尔可夫模型。这个…

towardsdatascience.com](/markov-chains-and-hmms-ceaf2c854788) [## Python 中的人脸检测指南

在本教程中，我们将看到如何使用 OpenCV 和 Dlib 在 Python 中创建和启动人脸检测算法。我们会…

towardsdatascience.com](/a-guide-to-face-detection-in-python-3eab0f6b9fc1) [## 升压和 AdaBoost 解释清楚

直观的解释

towardsdatascience.com](/boosting-and-adaboost-clearly-explained-856e21152d3e)**

图形分析——中心性的介绍和概念

原文：https://towardsdatascience.com/graph-analytics-introduction-and-concepts-of-centrality-8f5543b55de3?source=collection_archive---------1-----------------------

Photo by Alina Grubnyak on Unsplash

社交网络、大数据和电子商务的出现再次强调了分析一种独特类型的数据结构的重要性，这种数据结构描述了其实体之间的关系，也称为图表。在我开始介绍图分析之前，有必要简要介绍一下“图”的概念。

让我们从下面展示的朋友图表开始。我将在下面的一些章节中使用相同的图表来进一步解释图表分析的概念。

Figure 1 ( This graph was designed in Gephi )

上图描绘了朋友的图，其中节点/实体例如 A、B 等。描述了一个特定的个体，任何两个个体之间的链接(也称为边)描述了他们之间的关系(在这种情况下为“友谊”)。

从上面的例子中总结:

图可以被定义为“实体”或“事物”之间关系的表示，其中这些“实体”是图的“节点”(也称为“顶点”)，它们之间的关系由图的“链接”(也称为“边”)来表示。对图的研究也被称为“图论”

此外，通过简单地查看图表，人们可以分析出 A 和 B 有一个共同的朋友 C，而 C 并不是 d 的朋友。数据科学的分支通过对图表进行分析来处理从图表中提取信息，这被称为“图表分析”。

从介绍继续向前，让我们通过探索一些基本概念进入图形分析的世界。在本文中，我们将特别关注图形分析中使用的基于中心性的概念。如果你不理解前面提到的声明，请不要担心，因为随着我们的前进，我将从头开始讲述一切。

中心性

在图分析中，中心性是识别图中重要节点的一个非常重要的概念。它用于测量图中各种节点的重要性(或“中心性”，如节点在图中的“中心”程度)。现在，从某个角度来看，每个节点都可能很重要，这取决于“重要性”是如何定义的。中心性有不同的风格，每种风格或度量从不同的角度定义节点的重要性，并进一步提供关于图及其节点的相关分析信息。

度中心性

我们要讨论的中心性的第一种味道是“度中心性”。为了理解它，我们先来探讨一下图中一个节点的度的概念。

在无向图中，节点的度被定义为一个节点与其他节点的直接连接数。请看下图:

在有向图中(每条边都有一个方向)，节点的度进一步分为入度和出度。入度指的是入射到其上的边/连接数，出度指的是从它到其他节点的边/连接数。让我们看看下面的 Twitter 图表示例，其中节点是个体，带箭头的边表示“关注”关系:

Figure 2

我们可以看到，节点 E、C、D 和 B 具有朝向节点 A 的输出边，因此跟随节点 A。因此，节点 A 的入度是 4，因为它有 4 条边入射到它上面。

我们还可以看到，节点 B 跟随节点 D 和节点 A，因此它的出度为 2。

现在，度中心性度量将图中节点的重要性定义为基于其度来测量，即节点的度越高，它在图中就越重要。

重新检查下面提到的朋友图表(图 1 ):

Figure 3

节点 A 的度中心性是 7，节点 G 是 5，节点 C 是 4，节点 L 是 1。

数学上，度中心性被定义为节点“I”的 D(i ),如下所示:

现在，让我们简要地讨论一下上面显示的朋友图的度中心性的一个示例应用。观察节点 A 和 G，它们具有高度的中心性(分别为 7 和 5 ),并且如果我们想要将任何信息快速传播到网络的大部分，与仅具有 1 的中心性的节点 L 相比，它们将是理想的候选者。如果必须在网络中引入新产品或想法/思想，该信息对于创建营销或影响策略非常有用。营销人员可以关注 A、G 等节点。在网络中高度集中地营销他们的产品或想法，以确保节点之间更高的可及性。

类似地，记住样本 Twitter 图(图 2)，如果我们实际检查一个具有数百万节点的社交网络，如 Twitter，并计算各种节点的入度中心性，具有高入度中心性的节点(如 Kanye West、Lady Gaga 和其他名人)将是拥有大量追随者的节点，并且可能是影响公众或推广商业产品的理想候选节点。现在你知道为什么名人或受欢迎的人在 Instagram 和 Twitter 等社交网络上获得报酬，以说某些事情或推广某些产品，因为商业公司意识到这些人有非常高的参与度，有能力影响或迅速接触到大量的人。

基于度中心性分析节点重要性的应用/有用性是巨大的，并且取决于所考虑的图/网络的性质。

接近中心性

我们要讨论的第二种味道是“接近中心性”。为了理解同样的道理，首先让我们来理解图中两个节点之间的“测地线距离”的概念。

两个节点 a 和 b 之间的测地距离 d 被定义为这两个节点之间的最短路径(具有最少边数的路径)上的边数/链接数。

让我们看看下图:

Figure 4

让我们检查 A 和 F 之间的测地线距离，以进一步阐明这个概念。我们可以通过 B 和 E 或 D 从 A 到达 F。然而，从 F 到 A 的最短路径是通过 D(2 条边)，因此测地线距离 d(A，F)将被定义为 2，因为 A 和 F 之间有 2 条边。

数学上，测地线距离可以定义如下:

d( a ， b ) =从 a 到 b 的最短路径上 a 和 b 之间的边数，如果存在从 a 到 b 的路径

d( a ， b ) = 0，如果 a = b

d( a ， b ) = ∞(无穷大)，如果从 a 到 b 没有路径

此外，接近中心性度量将图中节点的重要性定义为通过它与图中所有其他节点的接近程度来测量。对于一个节点，它被定义为该节点到网络中所有其他节点的测地距离之和。

同样，在下面的图 1 中查看之前介绍的朋友图，我们可以看到节点 A 的亲密度中心性是 17，而节点 L 的亲密度中心性是 33。

Figure 5

数学上，图中节点 i 的接近中心度 C(i)可以定义如下:

让我们通过检查上面图 5 中的朋友图来简要描述亲密度中心性的一个示例应用。现在让我们假设在朋友的图中，每条链路/边都有 1 分钟的权重(属性),即从一个节点向其相邻节点(如 A 到 B 或 B 到 c)传输信息需要 1 分钟。现在让我们假设我们想向图中的每个节点发送一条特定信息(每个节点的信息都不同),我们需要在图中选择一个节点，该节点可以将它快速传输到网络中的所有节点。

为了解决上述问题，我们可以计算网络中所有节点的接近中心度。正如我们在上面已经为节点 A 计算的那样，如果我们选择节点 A，信息可以通过遍历 17 条边到达所有节点(即从 A 开始，在假设从 A 顺序发送的最坏情况下，信息可以在 17 分钟内被发送到所有节点),相比之下，在节点 L，将信息发送到所有节点需要 33 分钟。很明显，我们可以看到节点 A 和 L 在接近中心性度量方面的重要性差异。

中间中心性

我们将要讨论的第三种中心性被称为“中间中心性”(BC)。该度量基于节点在图中所有节点对之间的最短路径中出现的次数来定义和测量节点在网络中的重要性。为了进一步阐述这一指标，我们再来看看下面的朋友图表:

Figure 6

数学上，图中节点 i 的中间中心度 B(i)定义如下:

查看节点 A，我们可以看到它位于以下节点对之间的最短路径上:(D，M)，(D，E)，(G，C)，(G，B)，(G，F)，(G，I)，(K，C)，(D，C)等等。因此在图中的所有其他节点中具有最高的 BC。我们还可以观察到，与图中的其他节点(除了 A)相比，节点 G 和 C 也具有较高的介数中心性(BCs)

如前所述，如果我们看一下上面的朋友图(图 6)，节点 A 有一个非常高的 BC。如果我们移除它，将会导致网络中的巨大中断，因为节点{J，H，G，M，K，E，D}将无法与节点{F，B，C，I，L}通信，反之亦然，并且我们将会以两个孤立的子图结束。这种理解标志着具有高 BCs 的节点的重要性。

BC 的一个示例应用是在图中查找桥节点。具有高 BC 的节点是在大量节点对之间的最短路径上的节点，并且因此对于图中的通信是至关重要的，因为它们将大量节点彼此连接。从网络中移除这些节点将导致网络的链接或通信的巨大中断。

上述应用程序的一个真实使用案例是分析全球恐怖主义网络。例如，如果我们将恐怖分子或恐怖组织以及其他相关个人的网络表示为图的节点，我们可以计算每个节点的 BC，并识别具有高 BC 的节点。这些节点(或者在这种情况下是恐怖分子)将是网络中的桥节点。这些信息对国防机构非常有用，因为他们可以非常有效地破坏整个恐怖主义网络。该指标的另一个用例是检测和监控计算机网络或流网络中可能的瓶颈或热点。

特征向量中心性

我们将探索的中心性的最后一种风格被称为特征向量中心性。该度量将图中节点的重要性作为其邻居重要性的函数来衡量。如果节点连接到非常重要的节点，则与连接到不太重要的节点的节点相比，它将具有更高的特征向量中心性得分。

让我们看看下面给出的图表来进一步解释这个概念:

Figure 7

上图的邻接矩阵 A 如下所示:

Figure 8

我们假设在上面的图中，每个节点的重要性是用它的度来衡量的，这样一个节点的度越高，它在图中的重要性就越大。各节点的度数如下所示:

Figure 9

以上也可以表示为如下所示的矩阵向量 V :

Figure 10

现在，在数学上，特征向量中心性计算如下:

Figure 11 showing Eigen Vector Centrality Calculation — 1st Iteration

上述等式中的合成 1-D 向量给出了图中每个节点的特征向量中心性(EVC)分数。乘法的第一次迭代的效果可以如下所示:

Figure 12 showing EVC scores of each node after 1st iteration of multiplication

正如您在上面看到的，节点 A 和 B 的得分都很高，为 8，因为它们都连接到多个具有高度(重要性)的节点，而节点 E 的得分为 3，因为它只连接到一个 3 度的节点。同样重要的是，观察到合成向量中每个节点的 EVC 分数值只不过是其相邻节点的度数之和。例如:节点 A 的 EVC 分数=度(B) +度(C) +度(D) = 8

现在，如果我们在上面的等式(图 11)中得到的合成 EVC 向量再次乘以邻接矩阵 A，我们将得到图中每个节点的 EVC 得分的更大值，如下所示:

Figure 13 showing Eigen Vector Centrality Calculation — 2nd Iteration of multiplication

将结果向量再次乘以邻接矩阵(乘法的第二次迭代)的效果可以被可视化，如下所示:

Figure 14 showing EVC scores of each node after 2nd iteration of multiplication

现在，为什么我们要用邻接矩阵再次乘以合成向量？

简而言之，答案在于，将所得向量再次与图的邻接矩阵相乘有助于 EVC 分数在图中展开，从而对于图中的每个节点，得到更全局突出的 EVC 分数，而不是局部 EVC 分数。如果我们观察到，在乘法的第一次迭代之后，每个节点的 EVC 分数仅是其直接(第一级)邻居的函数，因此是局部分数，其在图中的全局水平上可能不准确。

阐述上述内容时，如果我们将上述操作可视化，我们可以观察到以下情况:

在乘法的第一次迭代之后，每个节点从它的直接(第一级)邻居获得它的 EVC 分数。
在第二次迭代中，当我们再次将结果向量乘以邻接矩阵时，每个节点再次从它的直接邻居获得它的 EVC 分数，但是第二次迭代中的不同之处在于，这一次，直接邻居的分数已经受到它们自己的直接(第一级)邻居先前(从第一次乘法迭代)的影响，这最终帮助任何节点的 EVC 分数也成为它的第二级相邻节点的函数。
在随后的乘法迭代中，图节点的 EVC 分数通过受到来自更远程度的相邻节点(第三、第四等等)的 EVC 分数的影响而保持更新。

重复乘法使得每个节点的 EVC 分数最终是其相邻节点的几度的函数或依赖于其相邻节点的几度，从而为每个节点提供全局精确的 EVC 分数。通常，重复 EVC 向量与邻接矩阵相乘的过程，直到图中节点的 EVC 值达到平衡或不再显示明显变化。

对特征向量中心性的应用的讨论是广泛的，值得单独的一篇文章来讨论。EVC 的一个示例应用是计算页面排名或页面排名算法，Google 和许多其他公司使用该算法来根据相关性对互联网上的网页进行排名。页面排名是 EVC 的直接变体。万维网上的网页有指向/来自其他网页的链接。你可以把每一个网页想象成图中的一个节点，把每一个输出/输入链接想象成通向/来自网络上另一个网页的有向边，从而构成整个万维网图。万维网中网页的图经历几次 EVS 计算的迭代，以便计算每个网页的全局精确的相关性排名。然后，具有高 EVC 分数的网页可以作为营销和其他商业目的的目标。

图形分析的领域是广阔的，并且有巨大的实际应用。这篇文章的范围是覆盖中心性的基本原理，希望能让读者深入了解图形分析的迷人世界。

以下是可用于图形分析的各种图形分析库和软件列表:

Gephi(【https://gephi.org/】T2)
细胞图(https://github.com/cytoscape/cytoscape.js)
Neo4j(https://neo4j.com)
GraphAnalyticsLib(https://github.com/jb123/GraphAnalyticsLib

用于几何深度学习的图卷积网络

原文：https://towardsdatascience.com/graph-convolutional-networks-for-geometric-deep-learning-1faf17dee008?source=collection_archive---------2-----------------------

图形学习和几何深度学习—第二部分

一定要看一篇 几何深度学习概述 和先决条件 熟悉机器学习这个小众领域。

关注 我的推特 加入 几何深度学习子编辑 获取空间最新更新。

G 图卷积与上一期中介绍的图嵌入方法非常不同。卷积方法不是将图变换到更低的维度，而是在输入图本身上执行，结构和特征保持不变。

Convolutions (Courtesy of Doing Interesting Things in Life)

由于图表在更高的维度上保持最接近其原始形式，因此关系归纳偏差更强。

学习算法的归纳偏差是一组假设，学习者使用这些假设来预测其尚未遇到的给定输入的输出。

每个机器学习算法中都有一种归纳偏差。例如，在普通 CNN 中，最小特征归纳偏差声明，除非有充分的证据表明某个特征是有用的，否则它应该被删除。特征选择算法是建立在这个假设之上的。在几何深度学习中，假设是相关的:

通过以优先考虑特定模式的方式来组织数据，我们可以提高模型性能，即使数据是相同的。

香草卷

通常，传统的卷积网络包括 3 个主要操作:

内核/过滤器

将内核想象成一个扫描仪，而不是“跨越”整个图像。扫描仪一次可以扫描的像素簇由用户定义，为执行下一次扫描而移动的像素数量也是如此。内核将像素聚集成网格格式的值，为池化做准备。

联营

再次执行“扫描仪”类型的操作，但是池化不是聚合一堆像素，而是只挑选出最重要的值(最大池化)或平均所有值(平均池化)，并使用它来构建用于展平的值网格。

展平

扁平化只是采用池化操作的最终网格结构，并将其截断成一个数组，然后可以通过前馈神经模型，最终输出预测。

图形卷积

然而，图上的卷积更具挑战性。由于其不规则的结构，图形的操作并不简单。图像被表示在二维欧几里得网格上，其中内核可以向左、向右等移动。图形是非欧几里得的，方向的概念如上、下等。没有任何意义。图形更加抽象，节点度、邻近度和邻域结构等变量提供了更多的数据信息。所以最终的问题是:

我们如何推广图形数据的卷积？

Wet spider silk sort of looks like a graph!

推广卷积的关键是核/滤波器。我们将会看到图学习方法之间最大的不同是在内核中，或者说内核在操作什么。

在高层次上，卷积聚合来自周围或相邻实体的信息。深度学习中的卷积利用这些聚合信息来构建特征图(网格值)，这些特征图用于通过神经网络进行预测。我们想在图表上这样做。

图卷积的类型

有两种类型的图形卷积:

空间方法:不需要使用特征值

和

光谱方法:需要使用特征材料

这两种方法都建立在不同的数学原理上，很容易注意到每种方法中方法之间的相似之处。然而，为什么谱方法在图形学习中如此流行，这可能不是很直观。

这是对一些最流行的架构的高级分析。

谱图卷积网络

Michal Defferrard 等人的研究方向导致了图论和信号分析中一个新领域的普及。该子域被称为图形信号处理 (GSP)。

GSP 是一般化卷积的关键，它允许我们构建能够考虑图形的整体结构和图形组件的单独属性的函数。

GSP 使用类似于傅立叶变换的信号处理功能，这通常是为信号/频率保留的工具，并将它们应用于图形。正是图傅立叶变换允许人们将“带宽”或“平滑度”的概念引入到图中。在这个术语的空间意义上，平滑度只是指事物集合的每个值相对于彼此有多接近。从光谱的角度来看，这有点复杂。

类似于平滑时间信号，其具有窄的频带宽度，展示聚类属性的图在 GFT 中将具有窄的频带宽度(信号在高度互连节点的集群内变化较小)。换句话说，一个聚类图在频域中将是稀疏的，允许更有效地表示数据(频域、非欧几里德和谱域意味着相同的东西)。对于一点光谱直觉，你可以在这篇伟大的文章中找到一个伟大的总结。

A graph with its signals represented in the spatial domain.

在 GCNs 中，节点特征和属性用“信号”来表示。然后，我们可以使用信号处理中的概念从数据中学习。通常，信号不仅仅是节点或边缘特征，而是应用于该特征的功能。

卷积可以通过寻找拉普拉斯图的特征分解来计算。特征分解是一种将矩阵分解成一组特征向量和特征值的方法。这也被称为谱分解，因此称为谱图卷积网络。计算拉普拉斯的特征向量，返回图形的傅立叶基。由于计算是在拉普拉斯算子上进行的，因此将有与图节点一样多的特征向量。直接求解分解是密集的，因此许多方法选择近似频谱分解。为了深入了解谱分解，机器学习大师有一个关于这个操作的很棒的帖子。

所以总体步骤是:

使用特征分解将图形转换到谱域
对指定的内核应用特征分解
将光谱图和光谱核相乘(像香草卷积一样)
返回原始空间域中的结果(类似于逆 GFT)

关于谱图论的原始论文是这整个图形学习方法家族的灵感来源。这些是最受欢迎的一些。

切布涅茨—德费拉德等人

ChebNets 是关于谱图学习的第一篇也是最重要的论文之一。谱卷积被定义为信号(节点特征/属性)与内核的乘积。这类似于卷积对图像的操作方式，其中像素值乘以核值。

由拉普拉斯特征值的对角矩阵的切比雪夫多项式构成的谱卷积中使用的内核。切比雪夫多项式是一种正交多项式，其特性使其非常擅长于逼近函数等任务。内核由以下等式表示:

其中 gθ 为核( θ 表示切比雪夫系数的向量)应用于λ，拉普拉斯特征值的对角矩阵(λ】表示缩放拉普拉斯特征值的对角矩阵)。 k 代表最小阶邻域， K 代表最大阶邻域。最后， T 代表k阶的切比雪夫多项式。

用简单的英语说:

对于从到 K-1 的每一阶，核等于应用于缩放拉普拉斯特征值的对角矩阵的所有切比雪夫多项式核的总和。

最初的 ChebNet 论文还通过使用图形处理介绍了池化方法，这是完整普通卷积的另一个关键组件。这个额外的步骤提高了效率，并使图形卷积更接近它们的普通表亲。

Before and after graph coarsening (Courtesy of Andreas Loukas)

ChebNet 隐式避免计算特征值位置，而是选择近似它。在这方面，ChebNet 与 Thomas Kipf 等人的图卷积网络非常相似。gcn 本质上是一阶 cheb net(一阶和二阶+在我的上一篇文章中有所解释)，并通过一些其他简化操作来降低复杂性。

一阶仅仅意味着用于确定两个节点之间相似性的度量是基于节点的紧邻。二阶(以及更高阶)意味着用于确定相似性的度量考虑了节点的直接邻域，但是也考虑了邻域结构之间的相似性(随着每一阶的增加，节点被考虑的深度增加)。在大多数论文中，卷积内被考虑的阶数由T5 KT7 表示(最小阶数为K)。****

ChebNets 没有将 K 限制为任何值，因此该模型能够学习给定节点的任意阶邻域。然而，gcn 将其 K 值限制为 1，从而将卷积的范围限制为一阶相似性。

图卷积网络(GCNs)——Kipf 和 Wellin g

在图形学习中被引用最多的作品是 Kipf 和 Welling 的一篇论文。该论文将谱卷积引入了图学习，并被简单地称为“图卷积网络”，这有点误导，因为它被归类为谱方法，而绝不是图学习中所有后续工作的起源。

在 Kipf 和 Welling 的 GCN 中，卷积被定义为:

eqn. 1

其中 gθ 是一个内核( θ 代表参数)，它被应用(由星号代表)到【x】、* 一个图形信号。 K 代表要考虑的远离目标节点的节点数(第 K 阶邻居， k 为最近阶邻居)。 T 表示应用于 L̃ 的切比雪夫多项式，其表示如下等式:*

eqn. 2 (In the original paper, part of the simplification included assuming λ max = 2)

其中λmax表示 L 的最大特征值，归一化图拉普拉斯。可以在一个图形上执行多次卷积，输出聚合成 Z.

eqn. 3

其中 Z 是卷积信号的矩阵(来自相邻节点)是图的邻接矩阵(加上单位矩阵) D ̃是从*θ是核/滤波器参数的矩阵(可以在整个图中共享)，而 【T21 D 到 -1/2 的幂是重正化技巧的一部分，以避免爆炸或消失梯度。***

等式 1 和 3 是包含在激活函数(Relu、Sigmoid 等)中的分量。).合并后的结果是构成 GCN 单一图层的分层传播规则。关键的创新是傅立叶变换的使用，傅立叶变换是量子力学(在 Q 比特的研究中)和信号处理(在波的研究中)中的一种流行操作。

ChebNets 和 gcn 非常相似，但它们最大的区别在于它们对等式中的值 K 的选择。1.在 GCN 中，逐层卷积限于 K = 1 。这是为了减轻图形局部邻域过度拟合的风险。Kipf 等人的原始论文进一步解释了这如何使架构相对于拉普拉斯算子呈线性，从而简化了整体模型的复杂性。**

Component sound waves coming together to make a single sound (Courtesy of Hearing health matters)

在高层次上，GCN 使用图形傅立叶变换来聚合相邻结点的特征和属性。这些特征和属性被表示为信号，这些信号是潜在图的组件分解。这类似于成分频率是声波的分解；分量频率是节点特征(作为信号)，声波信号是潜在图形。

gcn 在节点分类任务和其他图形应用中表现良好，但主要缺点是特征值往往在很小的范围内聚集在一起，每个聚类之间有很大的间隙。对 ChebNets 来说，这一点可以强调到较低的程度。这个问题后来被 CayleyNets 解决了。**

快速/简化图形卷积(FastGCNs/SGCs)

谱卷积的最大缺点是计算量非常大。内核是在傅立叶空间中定义的，而图形傅立叶变换的计算成本是出了名的高。它需要将节点特征与图拉普拉斯的特征向量矩阵相乘，这是对一个有 N 个节点的图的一个 O(N ) 运算。

因此，IBM 研究人员着手解决的问题是，如何在保持最佳结果的同时提高计算效率。fastcn因此诞生于对可伸缩谱图卷积的需求。该项目基本上修改了原始的 GCN 架构，以便能够使用蒙特卡罗(有偏随机抽样方法)方法一致地估计积分，这允许批量训练，减少了总的训练时间。**

另一方面，简化图卷积(SGC)以不同的方式处理这个问题；与其提高计算效率，也许降低计算复杂度才是自然的解决方案。他们的实验结果显示在左边的图表上。他们假设背后的前提是:

“我们假设 GCN 层之间的非线性并不重要，但大部分好处来自局部平均。”

项目去除了每个卷积层之间的非线性转换函数。最终的 softmax 激活允许概率输出，可通过随机梯度下降进行优化。**

凯莱网

CayleyNets 使用一种秘密成分改进了 ChebNet 的高计算开销问题。顾名思义，这种方法使用 Cayley 变换(用单位半圆表示)来解决问题。

Reminds me of fractal visualizations (Courtesy of the globberingmattress blog)

在高层次上，转换有助于“放大”倾斜的数据点，如这张古怪的 GIF 所示。

Cayley 多项式与 ChebNets 中的 Chebshev 多项式具有相似的性质，包括定位的有用概念(注意，在这两种方法中，“多项式”指的是充当内核/滤波器的函数)。**

Cayley 已被证明在广泛的图形学习任务中表现更好，因为他们能够在训练期间检测重要的窄频带，并在图形上很好地定位的同时专注于它们。****

由于 Cayley 内核/滤波器中的一个参数( h )，频谱上较小的特征值可以分散开来，从而允许内核专注于不同的频率。这在原始论文的 3 张图中可以看到，证明了参数(h)的归一化能力，其中标记表示特征值(红色表示保存重要信息)。**

Cheb vs Cayley (Courtesy of ResearchGate)

并列而言，CayleyNets(橙色)大多优于 ChebNets(蓝色)，同时需要的参数更少。

电影

MotifNets 是一种不同的方法，它通过引入“主题”的概念建立在原始 GCN 模型的基础上。本质上，该模式将输入图划分为个主题，这些主题是 x 长度的唯一子结构，因此数据集中的任何图都可以通过主题的某种组合来构建。**

The motifs used in the original paper (Courtesy of the MotifNet team)

这些图案的尺寸为 x = 3。注意，主题考虑到了边的方向性，这是图论中的一个细节，在以前的图形学习方法中被忽略了。这对于具有内在方向概念的应用程序尤其有用，例如社交网络、交通网络和能源网格。**

ChebNet 是具有无向图的单个拉普拉斯算子的 MotifNet 的一个实例，其中使用了 Chebyshev 多项式的矩阵。MotifNet 的每个卷积层都有一个多元矩阵多项式(一个奇特的内核，其中每个元素都是一个多变量的多项式)，它被应用到 motif 的拉普拉斯矩阵并从中学习。**

尽管切布内特和 GCN 的效率很高，但这两种方法在处理包含簇特征值的图时都有困难，这种现象在社区图中很常见。在这方面，MotifNet 力求修复与 CayleyNet 相同的弱点。**

总体光谱方法

稳健、可靠和经过研究的谱卷积从整体上激发了人们对图形学习和几何深度学习的兴趣。甚至 Yann Lecun 和其他研究人员也在这个领域的前沿做出了贡献。

然而，谱方法有很多缺点和不足，但那是另一篇文章的主题。

空间图形卷积网络

GraphSage —汉密尔顿等人

GraphSage 的美在于它的简单性。该型号是顶级的，在性能方面保持竞争力，即使是更新或更强大的型号。它特别强大，因为它可以很好地适应大型、密集、同质的动态网络。Graph sage 部分是由 Jure Leskovec 的贡献创建的，他也为本文中的其他各种算法做出了贡献(包括 node2vec)，它是来自斯坦福大学网络分析项目 SNAP 的许多图形学习算法之一。

在高层次上，GraphSage 有 3 个步骤:

邻域采样:

首先在图中找到目标节点的近邻。深度 k 由用户定义，并确定将采样多少个“邻居的邻居”。这是递归执行的操作，执行设定的步骤数。**

聚合:

在图中的每个节点都采样了其各自的邻域后，我们必须将邻域节点的所有特征汇集到目标节点。原论文提出 3 个聚合函数**

平均聚合 —对所有邻域节点特征进行平均(可以是加权平均)
LSTM 聚合-使用 LSTM 单元选择性聚合邻域结点要素(随机排序)
池化聚合 —最大池化仅考虑“最高”特性(在实验中表现最佳)

预测:

目标节点使用聚集的邻域节点特征通过神经网络进行预测，这可以是像节点分类或结构/上下文确定这样的任务。这是学习发生的地方。以监督的方式对图中的每个节点重复这 3 步过程。该方法的直观表示如下所示:**

GraphSage (Courtesy of the GraphSage research team)

实验表明，池化聚合的性能最好，计算效率也最高。GraphSage 的有效性是为什么它是目前在现实世界应用程序中实现的少数图形学习模型之一。照片分享网站 Pintrest 目前使用 GraphSage(尽管经过修改并更名为 PinSage)根据用户的兴趣和搜索查询来预测相关照片。

混合模型网络(MoNet)——蒙蒂等人

MoNet 在进一步的研究和开发中取得了很大成功，原始论文成为许多方法和架构的灵感和源泉，包括测地线 CNN(gcnn)、各向异性 CNN(acnn)、样条 CNN 和扩散 CNN。

最初的莫奈论文有三重贡献

各种图形学习方法的概括，统一了空间和光谱方法
使用参数核、伪坐标的新方法，与现有模型(各向异性 CNN、测地线 CNN 等)集成
在不同的基准流形、图形和网络上进行的一系列实验

莫奈的概括首先根据应用、任务和输入，将变量 x 视为流形中的点或图中的节点。变量 y 被认为是相邻的节点或点，其与 d 维空间中的伪坐标的向量相关联，使得【x，y】是伪坐标，其对于的每个邻居都有唯一的集合。****

每个伪坐标通过一个加权函数，该函数复制了传统图像卷积核的效果，由此核的每个值乘以当前考虑的值。在 MoNet 的情况下，加权函数是具有可学习参数的内核，它在伪坐标上操作:

其中σj是一个可学习的 d 乘 d 协方差矩阵， μj 是一个 d 乘 1 核的均值向量。 d 是伪坐标向量的尺寸(【x，y】)。这些矢量/伪坐标卷积核映射出一些非常有趣的可视化效果:**

The normalized kernels applied to a manifold (Courtesy of the MoNet research team)

在 3D 模型上是以它们的流形上的一点为中心的局部极坐标。圆图(代表模型的多色部分)是在流形上的不同卷积运算中使用的补丁算子加权函数(内核的奇特说法)。**

这个内核只在 MoNet 中学习，而不是在 GCNNs 和 ACNNs 中硬编码。人们可能注意到的第一件事是莫奈的权重(红色曲线)比其他方法更明显(GCNN)和更完整(ACNN)的权重“平滑”了多少。****

这些内核可视化将随着 GCNNs 和 ACNNs 的每个独特配置而改变。但是莫奈和 GraphSage 一样，可以学习参数。这种灵活性是两者都允许跨数据集共享参数的部分原因。这为像迁移学习这样的想法应用到几何领域开辟了空间。图形学习的未来看起来非常棒！**

整体空间方法

空间方法更容易掌握，特别是对于大多数人来说，他们对线性代数相关的运算没有很强的直觉，如特征分解、傅立叶变换和其他复杂的数学概念。

最近，空间方法获得了越来越多的动力，其潜在原因是另一篇文章的主题。

本质上

在 2010 年至 2012 年期间，由于深度学习领域最优秀的研究人员的共同努力，包括 Yann Lecun(图像卷积)和 Geoff Hinton(反向传播)，卷积神经网络点燃了只有他们看到的深度学习的回归。有效和高效的图卷积有可能产生这种效果，将几何深度学习领域推向聚光灯下。**

谱卷积和空间卷积之间的差异有望得到阐明，最终，这两种方法的特征在于具有如下差异:

频谱卷积在数学上和理论上与普通卷积相似，而空间卷积在概念上和普通卷积相似。

一种方法遵循教科书定义和数学来概括卷积，另一种方法从图论的角度出发。

我肯定错过了一堆算法和模型，尤其是最近对几何深度学习和图形学习的兴趣激增，导致几乎每天都有新的贡献出现在出版物上。一些有趣的方法包括像 Graph U-Net 和 Graph Markov 神经网络这样的项目。还有一些我还没有完全理解的现有模型；但当我做到了，我会更新这篇文章。

关键要点

图形卷积的目的是将图像卷积运算推广到图形，以便我们可以达到相似的性能和精度水平。**
图形卷积不同于图像卷积，因为图形作为一种具有非欧几里德属性的数据结构与欧几里德图像的集合结构非常不同。**
图形学习方法分为两个派别；光谱方法和空间方法。通过检查特征分解和相关操作的使用来确定分类。
谱方法试图使用信号等概念来表示节点特征，并使用傅里叶变换等操作来聚集节点信息并进行预测。**
空间方法使用操作(如消息传递)和表示方法(如伪坐标)来聚合节点之间的信息并做出预测。**

接下来，我们将深入探讨循环图和基于注意力的方法🔥

需要看到更多这样的内容？

跟我上LinkedIn脸书insta gram，当然还有* 中*****

我所有的内容都在 我的网站 我所有的项目都在GitHub

我总是希望结识新朋友、合作或学习新东西，所以请随时联系flawnsontong1@gmail.com

向上和向前，永远和唯一🚀

图形数据库。有什么大不了的？

原文：https://towardsdatascience.com/graph-databases-whats-the-big-deal-ec310b1bc0ed?source=collection_archive---------2-----------------------

继续关于语义和数据科学的分析，是时候讨论图形数据库以及它们能为我们提供什么了。

介绍

我们应该把宝贵的时间投入到学习一种吸收、存储和分析数据的新方法上吗？在图表上接触数学？

对我来说，当我开始调查时，答案是不确定的，但过了一会儿，我的答案是:

I’m using a surprising amount of Kenan Thompson’s gifs. Wow.

在本文中，我将讨论图数据库的一些想法和概念，它们是什么，它们的优势是什么，以及它们如何在我们的日常任务中帮助我们。

顺便说一句，我真的厌倦了编写大量的连接和查询来计算 2017 年 1 月至 2018 年 10 月期间在 Y 州购买商品 X 的客户数量(以及他们的平均工资)，并且该客户已经超过 Z 个月了。所以，一切对我有帮助的事情，我想很多人都是这样，在缩短时间，让它变得更简单、更直观方面，我都参与了。

什么是图？

This is not the type of graph I’ll be talking about 😃

当我们谈论图表时，在英语中有一个问题(在西班牙语中我们没有这个问题)。如果您在线搜索图形图像，您可能会看到以下内容:

google.com

但这不是我想谈论的那种图表。当我在这里谈论一个图表时，这是你应该在脑海中描绘的:

我将给出图的两种定义。首先是数学问题，然后是更简单的问题。

根据贝扎德和沙特兰的说法:

图 G 是一个有限的非空集 V 和一个(可能是空集)集合 E(与 V 不相交),集合 E 是 V 的(不同的)元素的二元子集。V 的每个元素称为一个顶点，V 本身称为 G 的顶点集；边集合 E 的成员称为边。我们所说的图的一个元素是指一个顶点或一条边。

图论最吸引人的特征之一在于该学科的几何或图像方面。给定一个图，用图解法表示它通常是有用的，其中集合的每个元素用平面上的一个点表示，每个边用一条线段表示。

把 G 的这种图称为 G 本身是很方便的，因为集合 V 和 E 是容易辨别的。在下图中，图 G 显示了顶点集 V = {V1，V2，V3，V4}和边集 E = {V1V2，V1V3，V2V4，V3V4}

正如你所看到的，集合 V 包含了图中顶点或点的数量，E 包含了它们之间的关系(读作 V1V2，就像 V1 连接到 V2)。

所以简单来说，图是对象(或实体或节点)及其关系(或边)的数学表示。这些点中的每一个都可以代表不同的东西，这取决于你想要什么。顺便说一下，这里节点和顶点的意思是一样的，我们可以互换使用。

当我们使用图形数据库时，我们将回顾一个如何使用它们的例子。

什么是数据库？

https://www.bmc.com/blogs/dbms-database-management-systems/

来自 techopedia:

从最一般的意义上来说，数据库是一个有组织的数据集合。更具体地说，数据库是一个电子系统，它允许数据被容易地访问、操作和更新。

换句话说，一个组织使用数据库作为存储、管理和检索信息的方法。使用数据库管理系统(DBMS)来管理现代数据库。

你想知道真相吗？根据我的经验，大多数数据库都是:

没有组织
不易接近
不易操纵
不容易更新

当我们谈论做数据科学的时候。在更早的年代(比如 20 lol ),维护一个数据库更容易，因为数据简单、更小、更慢。

如今，我们几乎可以在“数据库”中保存我们想要的任何东西，我认为这个定义与另一个概念有关，即关系数据库。

在关系数据库中，我们有一组“正式”描述的表，可以从这些表中以许多不同的方式访问或重组数据，而不必重新组织数据库表。基本上，我们有模式，可以在其中存储不同的表，在这些表中，我们有一组列和行，在特定位置(行和列)中，我们有一个观察。

我们在这些表之间也有关系。但它们不是最重要的，它们包含的数据才是最重要的。通常情况下，它们会被画成这样:

https://towardsdatascience.com/what-if-i-told-you-database-indexes-could-be-learned-6cf8f59bff94

什么是图形数据库？

https://www.cbronline.com/enterprise-it/software/graph-technology-data-standby-every-fortune-500-company/

基于数学图的概念，图数据库包含节点和边的集合。节点代表一个对象，边代表两个对象之间的连接或关系。图形数据库中的每个节点都由表示键值对的唯一标识符来标识。此外，每条边都由一个唯一的标识符定义，该标识符详细描述了起始或结束节点以及一组属性。

我将用一个来自 Cambidge Semantics 的例子来说明图形数据库是如何工作的。

假设我们有一些存储在本地连锁餐厅的数据。通常，在关系数据库中，您会将客户信息存储在一个数据库表中，将您提供的商品存储在另一个表中，将您的销售额存储在第三个表中。

当我想了解我卖了什么、订购了多少库存以及谁是我的最佳客户时，这很好。但是缺少的是连接组织，项目之间的连接，以及数据库中可以让我充分利用它的函数。

图形数据库存储相同类型的数据，但也能够存储事物之间的联系。约翰买了很多百事可乐，杰克和瓦莱丽结婚了，买了不同的饮料。我不需要运行 JOINs 来了解我应该如何向每个客户进行营销。我可以看到数据中的关系，而不必做出假设并进行测试。

neo4j 的人提到:

访问原生图数据库中的节点和关系是一种高效的、恒定时间的操作，允许您在每个内核上每秒钟快速遍历数百万个连接。

关系数据库将高度结构化的数据存储在具有预先确定的列和行的表中，而图形数据库可以映射多种类型的关系数据和复杂数据。因此，图形数据库的组织和结构不像关系数据库那样严格。所有关系都存储在边的顶点中，这意味着顶点和边都可以有与之关联的属性。这种结构允许数据库能够描述不相关的数据集之间的复杂关系。

图形数据库的使用

https://blog.cambridgesemantics.com/why-knowledge-graph-for-financial-services-real-world-use-cases

您知道吗，2018 年被吹捧为“图形年”，因为越来越多的大型和小型组织最近开始投资图形数据库技术。所以我们并没有走上一条疯狂的道路。

我并不是说我们从关系数据库和 SQL 中了解到的一切都不再适用。我是说，在某些情况下(令人惊讶的是，很多情况下)，使用图形数据库比使用关系数据库更好。

我现在就给你一个建议，告诉你什么时候应该使用图形数据库，而不是其他东西:

你有高度相关的数据。
你需要一个灵活的模式。
您希望有一个结构并构建更接近人们思维方式的查询。

相反，如果您有一个高度结构化的数据，您希望进行大量的分组计算，并且您的表之间没有太多的关系，那么您可能更适合使用关系数据库。

图形数据库还有另一个不明显的优势。它允许你建立一个知识图表。因为它们是图表，知识图表更直观。人们不会用表格来思考，但他们会立刻理解图表。当你在白板上画出一个知识图表的结构时，它对大多数人的意义是显而易见的。

然后你可以开始考虑建立一个数据结构，这可以让你重新思考你做机器学习和数据科学的方式。但是这是下一篇文章的素材。

在您的公司中实现图形数据库

像传统的 RDBMS 一样，图数据库可以是事务型的，也可以是分析型的。

当你选择你的图形数据库时，选择你的焦点。例如，流行的 Neo4J、 Neptune 或 JanusGraph 都专注于事务(OLTP)图数据库。

而类似的 AnzoGraph 是一个分析(OLAP)图形数据库。但是，要小心，您可能需要不同的引擎来运行涉及单个实体的快速查询(例如，Sean 买了什么汽水？)和轮询整个数据库的分析查询。(例如，像肖恩这样的人买一瓶汽水的平均价格是多少？).随着机器学习和人工智能的发展，图 OLAP 数据库变得非常重要，因为许多机器学习算法都是固有的图算法，在图 OLAP 数据库上运行比在 RDBMS 上运行更有效。

在这里，您可以找到不同类型的图形数据库和计算工具的丰富资源:

[## jbmusso/awesome-graph

图形数据库和图形计算工具的精选资源列表

github.com](https://github.com/jbmusso/awesome-graph)

图形 OLAP 数据库的用例非常多。例如，可以使用 PageRank 算法找到关键的意见领袖和书籍推荐者。此外，进行流失分析以提高客户保留率，甚至进行机器学习分析以确定推动图书销售的五大因素。

如果你想了解为什么以及如何实现一个 OLAP 图表，请看这篇文章:

[## 如果您没有使用 OLAP 图表，以下是您应该使用的原因

越来越多的企业和政府机构已经开始使用 GOLTP 系统来存储和挖掘他们的…

blog.cambridgesemantics.com](https://blog.cambridgesemantics.com/if-youre-not-using-graph-olap-heres-why-you-should)

下一步是什么？

下面的图表(摘自https://db-engines.com/)展示了这些类别受欢迎程度的历史趋势。在每个月的排名中，选择每个类别中最好的三个系统，并计算其排名得分的平均值。为了便于比较，初始值被归一化为 100。

Graph databases are getting a lot of attention

Together with Time Series databases, graph databases are on the top.

随着数据源持续快速扩张(非结构化数据增长最快)，寻找基于机器的见解变得越来越重要。

图形数据库为链接不同的数据提供了一个极好的基础设施。图形数据库易于表达数据之间的实体和关系，使程序员、用户和机器更容易理解数据并找到见解。这种更深层次的理解对于成功的机器学习计划至关重要，其中基于上下文的机器学习对于特征工程、基于机器的推理和推断变得越来越重要。

在未来，我将讨论图形数据库如何帮助我们进行机器学习和数据科学。

[## 本体论和数据科学

对现有数据的研究如何帮助我们成为更好的数据科学家。

towardsdatascience.com](/ontology-and-data-science-45e916288cc5) [## 机器学习的数据结构。第一部分。

语义学的新进展如何帮助我们更好地进行机器学习。

towardsdatascience.com](/the-data-fabric-for-machine-learning-part-1-2c558b7035d7) [## 面向大众的深度学习(…和语义层)

深度学习现在无处不在，在你的手表里，在你的电视里，在你的电话里，在某种程度上，在你的平台上…

towardsdatascience.com](/deep-learning-for-the-masses-and-the-semantic-layer-f1db5e3ab94b)

冠军推荐的图形网络(英雄联盟)

原文：https://towardsdatascience.com/graph-networks-for-champion-recommendation-league-of-legends-189c8d55f2b?source=collection_archive---------23-----------------------

让我们想象你为暴乱游戏公司工作。你的第一个任务是设计一种在他们的游戏《英雄联盟》中产生冠军(可玩角色)推荐的方法。你会如何处理这个问题？

标准的方法是给每个冠军贴上关键属性的标签，然后根据这些共同属性将他们联系起来。我们可以用这个来假设享有冠军 A 的参与人 1 也会享有相似的冠军 b。

例子:泽德是一名中路刺客，使用近战攻击，并拥有高机动性装备。塔龙也有这些属性，因此如果一号玩家喜欢泽德，我们可以假设他们也会喜欢塔龙。

然而，通过使用图网络，我们可以反过来解决这个问题:如果我们已经知道平均来说享受冠军 A 的玩家享受冠军 B，那么那些目前只玩冠军 A 的玩家将可能享受冠军 B——不管他们共享什么属性。

例子:经常玩 Zed 的玩家也经常玩 Talon。如果一号玩家只玩泽德，他们可能也会喜欢塔龙。我们可以假设这两个冠军有相似之处——我们只是不需要定义他们是什么。

你可以在这里找到最终产品:【www.lolnets.com

语境

你可以在这里观看游戏介绍。

你可以在这里阅读更多关于图表的信息。

“节点”=图中的特定点，在此上下文中，“节点”是冠军

“边”=两个节点(冠军)之间的连接。如果没有边缘，两个冠军是不相连的。有时与权重(也称为节点间距离)一起使用。

数据采集

对于任何数据科学问题，第一步都是收集数据。首先，我们需要随机选择一个召唤师的名字。幸运的是，这些都可以通过 Riot API 工具轻松实现。

我们首先创建一个区域和部门列表。为此，我使用了 3 个地区(EUW、北美和韩国)和以下分类:钻石、铂金、黄金、白银和青铜(比例为 1:2:4:4:2)。然后可以使用下面的循环随机创建一个大约 8000 个召唤师 id 的列表。

Loop code used to create a randomised list of Summoner IDs

一旦我们有了这些 id，我们可以再次使用 Riot API 来循环每个召唤师，找到他们的前 5 名冠军。代码下方的表格显示了 5 名随机玩家，他们最常玩的 5 个冠军(显示为冠军 ID)。

Each players Top 5 Champions (using Champion ID)

通过聚集这个数据集，我们可以回答每个冠军的以下问题:当他们出现在玩家的前 5 名名单中时，哪些冠军也最常出现在同一名单中？

这将创建下表:

我们可以看到，对于冠军 1(安妮)，最常见的连接是冠军 103 (Ahri)。用最简单的话来说:对于所有 8000 名选手来说，那些经常打安妮的选手也将比其他任何冠军更经常打 Ahri。

通过另一个简单的循环，我们可以将这个表转换为一个矩阵，其中冠军 ID 1(在 Y 轴上)将连接到 X 轴上的冠军 103、142 和 55。然后再一次，以同样的方式从 X 转置到 y。这将在所有冠军中重复。代码下方是最终矩阵的说明性示例(非真实数据)。冠军 id 出现在 X 和 Y 轴上，其中 1 表示两个冠军之间有联系，0 表示没有联系。

数据收集现已完成。

图形网络

下一步是创建图形网络，为此，我将使用 NetworkX 根据我们之前保存的矩阵创建图形。然后我们用散景来更详细地观察它。完整代码如下:

这将创建下图:

你可以在这里看到这张图的互动版本。

节点按泳道着色(黄色:支持，橙色:ADC，蓝色:中间，绿色:丛林，红色:顶部)。由此我们可以得出一些有趣的发现，例如 Thresh/Blitzcrank 往往是由非支援玩家扮演的支援(因为它最接近其他车道组)，而 Soraka 往往是支援主线的首选冠军(因为它最深入支援组)。这个逻辑可以贯穿始终，查看交互图，得出自己的结论！

但是对推荐有帮助吗？答案是依赖。是的，如果你正在寻找你最喜欢的泳道的冠军，不，否则。这是为什么呢？

假设你是一名 ADC main，你可以假设你的前 3 名冠军将围绕以黑色突出显示的橙色部分分组。如果我们使用此图来推荐冠军，可以肯定的是，它只会推荐一小部分最接近 ADC 分组的中间 laners(用蓝色标记)。这不是一个量身定制的建议。它不会从您独特的 ADC 冠军那里获取您的特定玩法，而是简单地将您默认为一个通用 ADC 播放器，并假设您与所有其他 ADC 完全一样。

为了改善这一点，我们需要回到数据收集上来。

数据收集 2

这一次，我们正在以不同的方式完成任务。我们不会给每个玩家找前 5 名冠军，我们会给每个玩家找前 3 名冠军。这意味着，对于每一个冠军，我们也将有共同的连接到每一个车道。

循环代码相当长，所以我不会在这里包括它。最后，我们留下了一个矩阵，它包含每个冠军，并将其连接到每个通道中的前 3 名冠军(总共 15 个连接)。除此之外，这些优势现在也将根据他们的平均冠军掌握程度作为该车道的百分比进行加权。

举例:如果你是一个打 Thresh (80k 精通)、Blitzcrank (10k 精通)、Pyke (10k 精通)做支援的 ADC 主。然后 Thresh 会给 80%，Blitz 给 10%，Pyke 给 10%。

这是反过来计算的:边 A 到 B 权重= 1 —(冠军 B 精通点数/总冠军精通点数)。这样，越高的玩家在一条道上掌握的百分比就在冠军身上，越低的边权重(也称为节点间距离)。

图形网络 2

现在我们有了一个新的方法来处理图网络，我们可以使用相同的代码重新创建图。

这比之前的要复杂得多。节点之间有大量的连接，权重决定了它们之间的距离。虽然看起来不太舒服，但它现在应该会提供更强的推荐。

结论

谢谢你读到文章最后。我希望这为如何在推荐引擎中使用图网络提供了一些启示。我可能最终会将完整的代码发布到 GitHub 上，但直到我对它的编写方式感到更加自豪。我计划很快将此贴在 Reddit 上，当我这样做时，我会包含链接，请随时在这里或那里留下您的反馈和评论。

你已经看到文章的结尾了！我叫 Jack J，是一名将人工智能应用于竞技游戏和电子竞技的专业数据科学家。我是 iTero 的创始人。GGT3和jung . GG。你可以在 Twitter 上关注我，加入 iTero Discord 或者给我发邮件 jack@itero.gg 。下一场见。

**最初发表于:【https://itero.gg/blog】T21

图形神经网络与置换不变性

原文：https://towardsdatascience.com/graph-neural-network-and-permutation-invariance-979754a08178?source=collection_archive---------9-----------------------

用不变性理论学习图形和关系数据

Photo by Alina Grubnyak on Unsplash

在之前的一篇帖子中，我们讨论了一种学习聚合函数的方法。当分析关系数据时，需要根据未知数量的记录得出结论，这种特殊的需求就出现了。例如，根据交易历史对客户进行分类。更一般的情况是在图上学习，其中我们必须基于连接到当前顶点的顶点的属性以及终止于给定顶点的边的任何属性来预测节点的属性。

举例来说，考虑一个基于交易历史预测客户流失的问题。下面是著名的 Northwind 数据库的 ER 图。

Source: https://www.researchgate.net/publication/323340741_A_Comparative_Analysis_of_Extract_Transformation_and_Loading_ETL_Process

这里的挑战是，每个客户有零到多个交易行，因此您不能轻松地为每个客户创建一个只有一行的表格数据集。最常见的方法是生成以某种方式聚合交易的特征，例如，订单计数、所有订单的总金额、上个月的订单数量等。但本着深度学习的精神，我们希望探索的算法能够自己学习这些功能，而不是依赖手工制作的功能。

很容易看出，实体关系可以用图来表示。例如，Northwind 数据库具有以下图形结构:

事实上，图可以很容易地表示实体关系，同时也能够表示更复杂的结构，这些结构不容易用关系数据库来表示。图形表示也使问题更加清晰。给定这个图，我们如何卷起所有相邻顶点的属性，并预测给定其连接的顶点的重要属性。

这个领域的研究已经进行了很长时间。参见[1]中关于神经网络方法的一篇很好的综述，或者如果你更喜欢内核方法，你可以查看[2]。这里我们将集中于神经网络方法，更具体地说，集中于卷积图神经网络。这些网络的灵感来自卷积神经网络(CNN)，它彻底改变了计算机视觉领域。你可以在下面看到 CNN 的基本构件——卷积滤波器:

Source: https://medium.com/machine-learning-bites/deeplearning-series-convolutional-neural-networks-a9c2f2ee1524

应用滤波器，我们可以学习图像的基本特征，堆叠多个卷积层，连同池和其他层，我们可以使用反向传播的能力来学习卷积滤波器的所有参数。这是图形神经网络的目标，其中标签可以分配给顶点、边或子图。

然而有一点不同。CNN 允许来自不同方向的不同贡献，而卷积图神经网络将相同的贡献层分配给所有相邻节点。就好像卷积滤波器只允许卷积矩阵的所有元素具有相同的值。以上面的客户流失为例。典型的图形神经网络将激活函数(或几层神经网络)应用于每个相邻节点，然后取输出的总和，并将其添加到节点的特征，可选地应用另一个变换函数。

这实际上对大多数图表都有意义。如果您再次查看客户订单节点图，您会注意到，如果我们切换任意两个订单节点，客户节点没有任何变化。这个性质被称为不变性，从[3]开始，人们对这个话题有了一定的兴趣。

置换对称对多元函数 f()施加了一个约束。通常，它可以用对称群的不可约表示来分解(因为置换群在形式上是已知的)。然而，有一种更简单的方法来表示这个函数，使用Kolmogorov–Arnold 表示定理。它陈述了如果 f 是多元连续函数，那么 f 可以写成单变量连续函数的有限合成和加法的二元运算。更具体地说，

从某种意义上说，他们证明了唯一真正的多元函数是和，因为其他所有函数都可以用一元函数和求和来编写。如果函数 f 是置换不变的，那么公式可以进一步简化:

这与卷积图神经网络中使用的公式完全相同。请注意， φ 是 x 的多维函数。本质上，上面的公式将一维 x 映射到多维向量，然后对每个相邻节点的向量求和，并使用函数 ρ再次映射到一维值。在【4】中已经证明，对于标量 x， φ 的维数必须至少为 N，以便能够逼近任何函数。这是通用逼近定理的图形版本。对我们来说，这意味着我们必须使用 φ 的维数至少作为每个客户的最大订单数。然而，可以使用更低的维数，但是在这种情况下，不能保证收敛。

我们将运行一个实验，并尝试获得不同维度值 φ 的模型性能。我们将近似max函数，众所周知，使用连续函数很难近似。我们将遵循与之前的 Jupyter 笔记本相同的方法:

我们将在这个实验中使用合成数据。我们假设有 100 个客户，他们的订单数量各不相同。我们将看看是否能成功地了解每个客户的最大订单金额。

首先我们会做一些探索性的数据分析。我们将看到最大订单金额在客户中的分布。

我们将遵循与前一篇文章几乎相同的代码，但是使用更多的隐藏层，因为 max()函数不容易学习，因为它的层很少

现在让我们尝试探索潜在空间维度的不同值的模型性能

总的来说，我们得到了相当低的 MSE。似乎神经网络很好地拟合了数据。我们还可以观察到，对于 100 维潜在空间，我们得到了 MSE 的意外尖峰。但是对于高于 125 的维度，该模型给出了极好的结果，但是即使对于更低的维度，该结果也是可接受的。它证实了[4]的论点，即尽管存在理论上的限制，但实际上潜在空间的维度可以显著低于，并且在实践中仍然给出良好的结果。有可能模型过拟合，因为由于几个隐藏层，我们有这个模型的许多参数。需要进一步的研究来调整它，选择最佳的激活函数和模型结构。

结论和下一步措施

奇怪的是，对图形或关系结构的学习并没有引起应有的关注。这很奇怪，因为大多数业务数据库都是关系型的，而大多数大数据系统都是在图形和关系型方法中获得优势的。然而，大多数机器学习算法都采用严格的表格格式，即使是可选数据也会给大多数算法带来问题。的确，您可以将图形嵌入作为一种策略，从图形数据中生成一个表格数据集。但是在这种情况下，我们失去了反向传播的能力。基于 CNN 的图模型是一个活跃的研究领域，最近关于置换不变性的理论研究证明了这些模型的坚实的理论基础。

我对这个话题感兴趣的原因之一是，大约一周后我将去 NIPS，我希望有机会在那里见到图形和关系学习以及置换理论的研究人员。如果你也打算参加 NIPS，请随时与我联系。与此同时，像往常一样，你可以在我的 github 库中找到这款笔记本的所有代码。

参考资料:

韩综等人。艾尔。，关于图神经网络的综合综述，arXiv:1901.00596v3 [cs。LG]2019 年 8 月 8 日
克里格等人。艾尔。，关于图核的综述，arXiv:1903.11835v1 [cs。2019 年 3 月 28 日
Zaheer 等人。艾尔。，深套，arXiv:1703.06114v3 [cs。2018 年 4 月 14 日

4.瓦格斯塔夫等人。艾尔。，论集合上表示函数的局限性，arXiv:1901.09006v2 [cs。2019 年 10 月 7 日

图形神经网络是如何工作的？

原文：https://towardsdatascience.com/graph-neural-networks-20d0f8da7df6?source=collection_archive---------5-----------------------

图形神经网络(GNNs)作为一种有趣的应用出现在许多问题中。最显著的是在化学和分子生物学领域。在这个领域产生影响的一个例子是 DeepChem ，一个使用 GNNs 的 pythonic 库。但是它们到底是如何工作的呢？

gnn 是什么？

典型的机器学习应用将把图形表示预处理成实值向量，这又丢失了关于图形结构的信息。GNNs 是信息扩散机制和神经网络的组合，代表一组转移函数和一组输出函数。信息扩散机制定义为节点更新它们的状态，并通过向它们的邻居节点传递“消息”来交换信息，直到它们达到稳定的平衡。该过程首先涉及一个转移函数，该函数将每个节点的特征、每个节点的边特征、相邻节点的状态和相邻节点的特征作为输入，并输出节点的新状态。斯卡塞利等人 2009 年[1]提出的原始 GNN 使用了离散特征，并将边和节点特征称为“标签”。然后，该过程涉及一个输出函数，该函数将节点的更新状态和节点的特征作为输入，为每个节点产生一个输出。

The localized functions for GNNs. Equation 1 from [1]

定域跃迁和输出函数都是被学习的参数微分函数。为了找到唯一的解，文献[1]的作者使用了 Banach 不动点定理和 Jacobi 迭代方法来以指数速度计算节点的状态。

Banach 不动点定理和 Jacobi 方法

这个 Banach 不动点定理 (BFP)陈述了一个方程组存在唯一的解，并提供了一种计算这些不动点的方法。如果假设一个度量空间 X ，那么*T:X→XT7 的 mpping 称为 X 上的收缩映射，其中*在 X 中承认一个唯一的不动点 x (例如 T GNN 中的转移函数被假设为相对于节点状态的压缩映射。因为 BFP 保证了唯一的解，所以作者使用雅可比迭代法来计算不动点解，即节点的状态。雅可比方法迭代求解算法，首先将近似值代入，然后迭代直至收敛。***

Equation 5 from [1]

From Kacamarga, M. F., Pardamean, B., & Baurley, J. (2014)

这种计算由一个网络来表示，该网络由计算转换和输出函数的单元组成。下图显示了编码网络及其展开的表示。当转移函数和输出函数由前馈神经网络(NN)实现时，编码网络成为递归神经网络，一种 NN，其中节点之间的连接沿着时间序列形成有向图。这些类型的网络最常用于处理输入序列。所得网络中的每一层对应于一个时刻，并且包含编码网络的所有单元的副本，而层之间的连接取决于原始的编码网络连通性。

Figure 3 From [1].

如上所述，每个反向传播步骤都需要存储单元的每个实例的状态，对于大型图形，所需的内存可能相当大。 Almeida-Pineda 算法【3，4】用于帮助减少这种情况，通过假设等式 5(如上所示)在梯度计算之前已经达到稳定点，可以通过仅存储 x 来执行随时间的反向传播，因为它不期望随着 t 的改变而改变。关于这方面的更多细节，我推荐看他们提供证明和数学公式的原始论文。

消息传递神经网络(MPNN)

由于人们对 GNNs 在化学和分子研究中的应用越来越感兴趣，[5]为 GNNs 制定了一个框架，并将以前的研究转换成这种格式作为说明。主要区别是:

不假设边特征是离散的
两个阶段:消息阶段和读出阶段，其中读出阶段是新的

Message Phase: Message and Update function from [5]

消息阶段与组合的转换函数和输出函数同义，其中 M 是转换函数，而是输出函数。读出阶段是所有节点状态的函数，并输出整个图形的标签。

Readout Phase: Readout function from [5]

作者展示了以前的 GNN 方法是如何在 MPNN 框架中形成的，显示了它的多功能性。

Formulating previous GNN approaches into the MPNN framework [5].

谁在使用 MPNNs？

MPNN 正被用于进一步的研究，如图像分割、位置图、化学/分子图、自然语言处理等。这些方法中的许多已经解决了 gnn 固有的平坦性、不学习图的分层表示以及如果不正确处理的话计算量大的问题。在一篇将 MPNN 应用到他们工作中的论文的文献综述中，对最初的 MPNN 框架最常见的改变是子图的使用。这有助于研究人员在某些情况下减少计算，以及在整个图形中表示分层图形关系。

希望这一领域的研究将继续下去，并能够扩展到更大的具有更动态交互的图形。这将允许对可区分的大型社交网络的进一步建模方法。

参考

[1]g .蒙法迪尼，Ah Chung Tsoi，m .哈根布奇纳，f .斯卡塞利和 m .戈里(2008 年)。图形神经网络模型。神经网络汇刊，20(1)，61–80。https://doi.org/10.1109/tnn.2008.2005605

[2] Kacamarga，M. F .，Pardamean，b .，和 Baurley，J. (2014 年)。mapreduce 框架下共轭梯度法和雅可比法算法的比较。应用数学科学， 8 (17)，837–849。**

[3]皮内达，法官，1987 年。反向传播推广到递归神经网络。物理评论快报，59(19)，第 2229 页

[4]阿尔梅达法律出版社，1987 年。组合神经网络中带反馈的异步感知器的学习规则

[5] Gilmer，j .，Schoenholz，S. S .，Riley，P. F .，Vinyals，o .，& Dahl，G. E. (2017 年)。量子化学的神经信息传递。从 http://arxiv.org/abs/1704.01212取回

6 D. Duvenaud，D. Maclaurin，j . Aguilera-iparaguirre，R. GmezBombarelli，T. Hirzel，A. Aspuru-Guzik 和 R. P. Adams，“用于学习分子指纹的图形卷积网络”，2015 年

7 Y. Li，D. Tarlow，M. Brockschmidt，R. Zemel，“门控图序列神经网络”，2015 年。

[8] P. W .巴塔格利亚和 m .赖，“学习物体、关系和物理学的互动网络 arXiv : 1612。00222v1 [ cs。2016 年 12 月 1 日。”

[9] K. T. Schutt，F. Arbabzadah，S. Chmiela，K. R. M uller 和 A. Tkatchenko，“来自深度张量神经网络的量子化学见解”，《自然通讯》，第 8 卷，第 13890 页，2017 年。

图形神经常微分方程

原文：https://towardsdatascience.com/graph-neural-ordinary-differential-equations-a5e44ac2b6ec?source=collection_archive---------18-----------------------

将图形神经网络扩展到连续深度域

Rayleigh–Bénard convection. Finite element methods discretize spatially continuous problems into sets of entities that display complex inductive relational biases. Source: original author.

多智能体系统普遍存在于各种科学领域:从物理学到机器人学，博弈论，金融和分子生物学，等等。通常，封闭形式的分析公式是不可用的，并且预测或决策任务不得不依赖于有噪声的、不规则采样的观察。

这类系统提供了一个清晰的归纳关系偏差的例子。在统计学或机器学习中引入归纳偏差是一种众所周知的提高样本效率和泛化性能的方法。从目标函数的选择，到适合手头具体问题的特定深度学习架构的设计，偏见是普遍而有效的。

关系归纳偏差[1]代表一类特殊的偏差，涉及实体之间的关系。概率或其他图形模型是一类传统的模型，专门以先验结构的形式对实体施加关系偏差。这些图结构在不同的方面是有用的；即通过引入条件独立性假设来降低计算复杂度，以及通过以图形形式编码先验知识来提高样本效率。

图形神经网络(GNNs)是图形模型的深度学习对应物。当目标问题结构可以被编码为图时，或者在关于输入实体之间的关系的先验知识本身可以被描述为图的设置中，通常使用它们。GNNs 已经在各种应用领域显示出显著的结果，例如节点分类[2]，图分类和预测[3][4]以及生成任务[5]。

深度学习中的常微分方程

另一类不同但同样重要的归纳偏差与收集数据的系统类别有关。尽管深度学习传统上是由离散模型主导的领域，但最近的进展提出了将神经网络视为配备有连续层的模型6。该视图允许将正向传递重新表述为常微分方程(ODE)的初始值问题的解决方案。这种假设允许对微分方程直接建模，并提高神经网络在涉及连续时间过程的任务中的性能。

我们的工作旨在弥合几何深度学习和连续模型之间的差距。图形神经常微分方程 (GDEs)将图形结构数据上的常见任务投射到系统理论框架中:

GDEs model vector fields defined on graphs, both when the structure is fixed or evolves in time. This is achieved by equipping the model with a continuum of GNN layers.

GDEs 提供了灵活性，因为它们的结构是由连续的 GNN 层定义的，因此可以适应不规则采样的顺序数据。

GDEs 的主要目的是为结构化系统的建模提供一种数据驱动的方法，特别是当动态特性是非线性的，因而难以用经典或分析方法处理时。

下面是对 GDEs 的介绍。我们参考完整的论文以获得更多的细节和推导。一个 github 知识库目前正在开发中，它以注释 Jupyter 笔记本的形式提供了一些介绍性的例子。我们鼓励请求/建议 GDEs 的额外应用:我们计划最终包括所有主要图形神经网络 (GNN)架构的 GDE 变体的工作示例，部署在各种设置(预测、控制……)

准备工作和背景

GDEs 和 GNNs 一样，对图 进行操作。我们参考了 GNNs 的优秀调查以及我们论文中的背景部分，以获得关于符号和基本定义的更详细介绍。接下来的 GDE 介绍是经过提炼的，只有两个关于图的基本事实是必须的:

图是由边连接的节点(实体)的集合。深度学习模型通常在属性图、上工作，属性图是其节点由一组特征描述的图(通常以嵌入向量或张量的形式)。对于具有 n 个节点的图，每个节点由 d 个特征描述，我们将nxd个节点的嵌入矩阵表示为 H 。
图的结构通过其邻接矩阵 A. 节点之间的连接结构代表了标准深度学习模型和 GNNs [1]之间的主要区别，因为后者以各种方式直接利用它来执行节点嵌入操作。

图形神经常微分方程

A G raph 神经普通 D 微分Equation【GDE】定义如下:

General GDE formulation

其中 H 是节点特征矩阵。以上为 H 定义了一个向量场，由函数 F 参数化，该函数可以是任何已知的图形神经网络 (GNN)层。换句话说， F 利用图 G 的连通性信息，以及它的节点特征，来指定【S】中 H 的演化，这里S* 是模型的深度域； S 是连续的，不同于深度域由自然数子集指定的 GNNs，代表由 F 定义的常微分方程的积分域。GDEs 可以用多种方式训练，很像标准的神经微分方程6。系统的适定性在论文中有完整的讨论。*

一般的 GDE 公式带有几个含义。在一般神经微分方程的情况下，已经观察到离散化方案的选择可以描述先前已知的 ResNets 的离散多步变量7。因此，深度学习的连续、动态系统观点不限于微分方程的建模，并且可以通过利用丰富的数值方法文献来指导新的通用模型的发现。

与 ResNets 相比，gnn 作为一个模型类相对年轻。因此，具有复杂的、类似分形的剩余连接的多级或变体的文献并不发达；新 GNNs 变体的发现可以通过将各种离散化方案应用于 GDEs 来引导，而不是从零开始。

静态图的结果:节点分类

通过在 Cora、Pubmed 和 Citeseer 上进行的一系列半监督节点分类实验，我们证明了 GDEs 可以作为高性能的通用模型。这些数据集包含静态图，其中邻接矩阵 A 保持固定，因此远离 GDEs 大放异彩的动态系统设置。我们评估图卷积常微分方程* (GCDEs)的性能，定义为:*

GCDE model. A more detailed version is included in our paper, along with GDE versions of popular GNN variants

以及它们完全离散化的对等物 图卷积网络【GCN】【8】。我们包括著名的图形注意网络(GAT)【9】以供参考:

Accuracy on node classification tasks. Mean and standard deviation of 100 runs.

GCDEs 与最先进的模型相比具有竞争力，并且优于它们的离散对应物。我们评估了两个版本的 GCDEs:采用固定步长方案离散化的龙格-库塔4(GCDE-rk4)，以及自适应步长方案Dormand-Prince(GDDE-DP r5)。固定步长离散化不能确保 ODE 近似保持接近解析解；在这种情况下，解决一个适当的 ODE 是没有必要的，GCDE-rk4 只是为 GCNs 提供了一个计算有效的 fractal net-like 结构，以提高准确性。

Training loss and accuracy on Cora. Shaded area is the 95% confidence interval

另一方面，使用自适应分步求解器训练 GCDEs 自然会比使用普通 GCNs 得到更深的模型，后者的层深度会大大降低性能。在我们的实验中，我们成功地用多达 200 个 ODE 函数评估 (NFE)训练了 GCDE-DP r5，这是一个比普通 gcn 可能的图形计算量高得多的计算量，其层深度大大降低了性能。应该注意的是，gde 不需要比它们的离散对应物更多的参数，因为事实上它们在函数计算中重用它们的参数。有趣的是，自适应步长几何微分方程似乎不受节点特征过度平滑的影响。过度平滑问题[10]阻碍了深度 gnn 在各种领域的有效使用，特别是多智能体强化学习(MARL)；我们目前正在探索 GDEs 的这一特性，并将很快包括更详细的分析。

时空 GDEs

GDEs 的一个关键设置涉及时空图形数据。当处理图序列时，GNNs 的递归版本是必要的[11][12]。然而，与常规递归神经网络(RNNs)及其变体非常相似，固定离散化不允许对不规则采样数据进行操作。这一事实推动了 RNNs 形式的进一步发展，RNNs 具有到达时间之间的动力学的先验假设[13]以及 RNN 的 ODE 版本[14]。

在涉及时间分量的场景中，GDEsT3S的深度域与时间域一致，并且可以根据需要进行调整。例如，给定时间窗δt，由 GDE 执行的预测采用以下形式:

不考虑具体的 GDE 架构。GDEs 代表了用于图序列的自回归建模的自然模型类，并且自然地导致以 混合动态系统 ，形式的经典时空体系结构的扩展，即以相互作用的连续和离散时间动态为特征的系统。核心思想是让 GDE 平滑地操纵两个时刻之间的潜在节点特征，然后应用一些离散算子，导致节点特征的跳跃 H ，然后由输出层处理。

给定一组时刻 {(t ₖ)} )和一个状态图数据流 {(X ₜ，G ₜ)} )自回归 GDEs 的一般公式为:

Autoregressive GDE. Continuous variants of known spatio — temporal GNN models can be obtained from this system by choosing appropriate F, G, K

其中 F 、 G 、 K 为类 GNN 算子或一般神经网络层， H ⁺ 代表离散转换后 H 的值。系统的演化可以通过混合自动机来可视化:

Hybrid automata schematic of autoregressive GDEs.

与仅配备离散跳跃的标准递归模型相比，自回归 GDEs 在跳跃之间结合了潜在节点特征的连续流 H 。自回归 GDEs 的这一特性允许它们从不规则的观测中跟踪动力系统。 F 、 G 、 K 的不同组合可以产生最常见的时空 GNN 模型的连续变量。

为了评估自回归 GDE 模型在预测任务中的有效性，我们在已建立的 PeMS 流量数据集上进行了一系列实验。我们按照[15]的实验设置进行额外的预处理步骤:对时间序列进行欠采样，每个条目的移除概率为 0.7，以模拟具有不规则时间戳和缺失值的挑战性环境。

为了测量 GDEs 在使用连续时间系统生成的数据的设置中获得的性能增益，我们采用了 GCGRU 及其离散副本 GCGRU [12]，并且我们将结果与香草 GRU 度量联系起来。对于考虑中的每个模型，我们收集 归一化的 RMSE (NRMSE)和 平均绝对百分比误差 (MAPE)。在我们的论文中可以找到关于所选指标和数据的更多细节。

时间戳之间的非恒定差异导致对单个模型的预测任务具有挑战性，因为平均预测范围在训练和测试过程中会发生剧烈变化。为了在模型之间进行公平的比较，我们将增量时间戳信息作为 GCGNs 和 GRUs 的附加节点功能。

Results of irregular data forecasting task. Mean and standard deviation across 5 training runs.

由于 GCDE-GRUs 和 GCGRUs 被设计为在结构和参数数量上相匹配，我们可以测量出 NRSME 的性能提升 3% 和 MAPE 的性能提升**7%。具有连续动态和不规则数据集的各种其他应用领域可以类似地受益于采用 GDEs 作为建模工具:医学、金融或分布式控制系统，仅举几例。我们正在这些领域进行更多的实验，欢迎提出请求、想法或合作。

结论

如前所述，我们目前正在开发一个 github 库，里面有一系列不同类型 gde 的例子和应用。

我们鼓励请求/建议 GDEs 的其他应用:我们计划最终包括所有主要图形神经网络 (GNN)架构的 GDE 变体的工作示例，部署在各种设置(预测、控制……)。我们的论文在 arXiv 上有预印本:如果你觉得我们的工作有用，可以考虑引用我们。**

参考文献:

[1] P. W .巴塔格利亚等人，关系归纳偏差、深度学习和图形网络。arXiv 预印本 arXiv:1806.01261，2018。

[2] J .阿特伍德和 d .陶斯利扩散卷积神经网络。神经信息处理系统进展，1993–2001 页，2016 年。

[3]崔志勇、亨瑞克森、柯和王。交通图卷积递归神经网络:网络规模交通学习和预测的深度学习框架。arXiv 预印本 arXiv:1802.07007，2018

[4] J .帕克和 j .帕克。物理诱导图形神经网络:风电场功率估算的应用。能源，187:115883，2019。

[5]李、o .维尼亚尔斯、c .戴尔、r .帕斯卡努和 p .巴塔格利亚。学习图的深度生成模型。arXiv 预印本 arXiv:1803.03324，2018。

6 T. Q. Chen、Y. Rubanova、J. Bettencourt 和 D. K. Duvenaud。神经常微分方程。《神经信息处理系统进展》，6571–6583 页，2018 年。

7陆，钟，李，董。超越有限层神经网络:桥接深层结构和数值微分方程。arXiv 预印本 arXiv:1710.10121，2017。

[8]基普夫和韦林。基于图卷积网络的半监督分类。arXiv 预印本 arXiv:1609.02907，2016。

[9]佩利科维奇、库库鲁勒、卡萨诺瓦、罗梅罗、莉雅和本吉奥。图形注意力网络。arXiv 预印本 arXiv:1710.10903，2017。

[10]陈，德利等.“从拓扑角度度量和缓解图神经网络的过光滑问题” arXiv 预印本 arXiv:1909.03211 (2019)。

[11]李，，沙哈比和刘。扩散卷积递归神经网络:数据驱动的交通预测。arXiv 预印本 arXiv:1707.01926，2017

[12]赵晓东、陈芳芳和赵俊辉。预测网络数据中动态不确定观点的深度学习。2018 年 IEEE 大数据国际会议(Big Data)，1150–1155 页。IEEE，2018。

[13] Z. Che、S. Purushotham、K. Cho、D. Sontag 和 Y. Liu。具有缺失值的多变量时间序列的递归神经网络。科学报告，8(1):6085，2018。

[14] Rubanova，R. T. Chen 和 D. Duvenaud。不规则采样时间序列的潜在常微分方程。arXiv 预印本 arXiv:1907.03907，2019。

[15]俞、尹和朱。时空图卷积网络:交通预测的深度学习框架。在 2018 年第 27 届国际人工智能联合会议(IJCAI)的议事录中。

图论的简明介绍

原文：https://towardsdatascience.com/graph-theory-132122ac38f2?source=collection_archive---------12-----------------------

最近，图吸引了机器学习社区过多的注意力。图可以表示许多复杂系统，如社会网络、蛋白质相互作用网络、知识图、引文、互联网等。这些是在非欧几里得空间中操作的信息的例子，但是甚至图像和文本也是在欧几里得空间中操作的特殊图形。

Image is taken from William Hamilton COMP551: Graph Representation Learning

图( G )是由顶点(又称节点 V )和边(又称链接 E ) G(V，E) 组成的特殊数据结构。边可以被加权，并且表示例如城市之间的距离。此外，节点可以有一个概率解释，并代表随机变量。这些特殊的图被称为概率图模型，其中如果没有联系，两个 r.v .就是独立的。例如，神经网络是一种特定的图形模型。图形无处不在，大多数知识都可以用图形来建模。

Undirected Graph G(V, E), circles represents nodes and lines represent edges.

在这里，我将介绍一些图论中常用的术语，以便补充这个好看的帖子，所以一定要查看一下！

让我们从一个关于有向图和无向图的提示开始。当所有的边都表示方向时是一个有向图 (2)，当所有的边都是无向时是一个无向图 (1)。

Example of an undirected graph; 2) example of a directed graph.

路径

路径是连接两个节点所需的所有节点的列表。例如，为了连接节点 A 和 D，我们需要转到节点 {A，B，D}。所以路径可以由节点 A，B，D，和边 {(A，B)，(B，C)，(C，D)}构成。

In order to go from A to D, we need to follow the path {A, B, D}.

有向图有向路径，有一些节点是祖先和后代。祖先是路径中节点的前辈； D 的祖先是 {B，A} 。同样，后代是一个节点的子节点；例如， A 的子代是 {B，D} 。

有向无环图

图包含圈，是有向路径，在同一个节点开始和结束。比如上图有圈{A，B，D，C，A}。如果我们忽略方向，我们就会有循环。例如，节点{A，B，C}是一个循环，但它们不能是一个循环。当有一条边连接两个不相邻的节点时，我们有一条弦。比如边 (C，B) 就是弦。

如果没有循环，则该图是非循环的。所以，有向无环图(DAG)。它只是一个包含没有圈的路径的图。DAG 的祖先和后代可以在路径中找到；节点不会重访一个节点。例如，下图是一条 DAG。

Directed Acyclic Graph. Contains two paths P1 = {A, C, D} and P1 = {A, B, D}.

D 的父母:pa(D)= { C，B} 。

A 的子:ch(A)= { C，B}

一个节点的家族就是它本身和它的双亲。 D 的族: fa(D) = {D，C，B} 。

马氏毯的一个节点是它的父母，孩子，孩子的父母。 B 的马尔科夫毯: MB(B) = {A，D，C} 。

有向图很重要，因为链接代表了父子之间的依赖关系。

派系

无向图有个邻域，表示连接到一个节点 ne(x) 的节点。比如下图 ne(A) = {B，C，D} 。这么说，团是所有节点全连通且长度最大的节点的子集。因此，一个集团的所有成员都是邻居。在图的例子中，我们有两个全连接节点的子集:S 1 = {A，B，C，D} 和 S 2 = {B，D，E} 。S1 最长，是个小团体。非极大的全连通集合被称为。

Example of a clique: {A, B, C, D} is a clique while {B, D, E} is a cliquo.

为了让计算机能够理解，我们将图形信息表示为矩阵或列表。在引入团矩阵之前，我们将定义一个边列表和邻接矩阵。

一个边列表仅仅是一个节点-节点对列表。比如下面的无向图有下面的列表: L = {(A，B)，(B，A)，(A，C)，(C，A)，(B，C)，(C，B)，(C，D)，(D，C)，(B，D)，(D，B)} 。有向边仅表示一次，但无向边会被复制以保持两个方向。

(Left) Undirected graph; (right) directed graph.

另一种表示图的方式是用一个邻接矩阵，如果在节点 i，j 之间有一条边，则该矩阵为 1，否则为 0。您可以通过在对角线上添加 1 来添加自连接。无向图的邻接矩阵是对称的，有向图的邻接矩阵是三角邻接矩阵，因为它们保留了祖先。例如，参见上图中的邻接矩阵和三角形邻接矩阵。

Adjacency matrix for undirected graphs and triangular adjacency matrix for the directed graph (we only add the parents of a node)

邻接矩阵有一个有趣的性质:幂表示路径的数量。基本上你从节点 i 到节点 j 有 k 边希望。

此外，行的添加给出了图的度。度数是一个节点接触的边的数量。

最后，一个集团矩阵在其每一列中都有最大集团。并且集团矩阵放松了具有最大集团的约束。当你有两个节点时，结果矩阵是一个关联矩阵。这个矩阵很有趣，因为关联矩阵的乘积产生了邻接矩阵，图的度在对角线上。参见上面无向图的团矩阵和关联矩阵。

Clique matrix and incidence matrix

还有很多关于图的讨论，比如生成树、拉普拉斯算子、谱图、图核、图因子分解等等。

我希望你喜欢这篇文章，并从中获得一些有用的东西。感谢一直陪伴我直到这篇文章结束。我是 Xavier，我通常从事自然语言处理和贝叶斯推理，但我对图形数据非常感兴趣。所以，如果你想合作并有一个很酷的想法，我很乐意合作。在推特上找到我！

图论和数据科学

原文：https://towardsdatascience.com/graph-theory-and-data-science-ec95fe2f31d8?source=collection_archive---------22-----------------------

图表和数据科学

柯尼斯堡桥的主题介绍

图论可以追溯到 1736 年的普鲁士城市柯尼斯堡。当时，这座城市以普雷格尔河中的两个岛屿为中心，这些岛屿通过七座不同的桥梁与大陆相连。据说，当地的桥牌爱好者举行了一场比赛，看谁能设计出最佳路线，穿过每座桥，同时只穿过一座桥一次。从而在最短的时间内看到所有桥梁的辉煌。

Fig. 1: a map of old Königsberg

虽然这个问题很容易理解，但却很难解决。这个谜题的消息不胫而走，直到引起数学家莱昂哈德·欧拉的注意。他能够证明这个问题实际上没有有效的解决方案，并由此奠定了图论的基础。

为了更容易理解他的解决方案，我们将介绍一些图论术语。

一个图 G ( V ， E )是由一组顶点( V )和一组边( E )定义的数据结构。
顶点 ( v )或节点是一个不可分割的点，由下图中的字母组件表示
一条边 ( vu )将顶点 v 和顶点 u 连接在一起。
顶点 v 的度 d ( v )，就是与之相连的边数。
一个顶点的奇偶性是指 d ( v )是偶数还是奇数。
欧拉路径是有限图中访问每条边恰好一次的路径(允许重访顶点)。

Fig 2: Example Graph with 6 Vertices and 7 Edges

现在回到普鲁士！让我们用我们所学的知识将柯尼斯堡及其桥梁的地图转换成图表。在这个图形表示中，每块陆地将成为一个顶点，每座桥将成为一条边。

Fig 3. Mapping Königsberg onto a Graph

Fig 4. Graph of Königsberg Bridges

现在，让我们按照以下顺序在这张图上尝试一条欧拉路径:

A → B → D
D → A → C

Fig 5. Eulerian walk attempt

我认为，在我们遍历到顶点 C 之后，很容易看到我们的路径无法完成，因为我们将在 B 或 d 处结束。

通过上面的例子，欧拉意识到问题的核心是每个顶点的奇偶性。行走中的旅行者总是需要从每个顶点开始的入口和出口边缘，以便继续他们的行走。因此，为了继续行走，偶校验总是需要的。

因此，对于试图沿着图 G 进行欧拉行走的旅行者来说，以下条件必须成立才能完成:

g 必须连接
g 必须有零个或两个奇数阶的顶点

此外，如果 G 有两个奇数度的顶点，那么行走必须从一个开始，到另一个奇数度的顶点结束。

从这个最初的问题中发展出来的领域在我们高度联系的世界中只会变得越来越重要。图论可以用来表示和分析各种各样的网络信息，并且在数据科学中有许多现代应用。

Fig 6. Variety of Graph Representations of Networks

从谷歌页面排名到网飞内容推荐，它也是众多基础算法发展的基础。

来源

https://math . stack exchange . com/questions/1173328/eulers-solution-of-seven-bridges-of-k % C3 % B6 nigsberg-in-layman-terms

https://en . Wikipedia . org/wiki/Seven _ Bridges _ of _ K % C3 % B6 尼斯堡

https://www . learner . org/courses/mathillumined/units/11/textbook/02 . PHP

https://www.storyofmathematics.com/16th_tartaglia.html

https://cs.mcgill.ca/~wlh/comp551/slides/25-gnns.pdf

关于深度学习的图论，你需要知道的一切

原文：https://towardsdatascience.com/graph-theory-and-deep-learning-know-hows-6556b0e9891b?source=collection_archive---------2-----------------------

图形学习和几何深度学习—第 0 部分

预测未来的最好方法是创造未来——亚伯拉罕·林肯

关注 我的推特 加入 几何深度学习子编辑 获取空间最新更新。

今天，机器学习风靡一时，一旦科学赶上宣传，它将很可能成为我们生活中的一种常态。我们达到下一步的方法之一是一种新形式的深度学习；几何深度学习。点击阅读灵感和创意。这个系列的重点是我们如何在图上使用深度学习

理解图学习所需的两个先决条件就在名称本身；图论和深度学习。这就是你所需要知道的，来理解的本质，并为这两个想法建立一个高层次的直觉。

Progress in A.I means more cute robots (Courtesy of Techgyd)

图论—速成班

什么是图？

在图论的上下文中，图是一种结构化的数据类型，具有节点(保存信息的实体)和边(也可以保存信息的节点之间的连接)。图表是一种组织数据的方式，但它本身也可以是一个数据点。图表是一种非欧几里得数据，这意味着它们以 3D 形式存在，不像图像、文本和音频等其他数据类型。图表可以具有某些属性，这些属性限制了可以对其执行的可能操作和分析。这些属性是可以定义的。

图形定义

首先让我们来看一些定义，这是我一生中最简单的 Photoshop 工作带给你的。

在计算机科学中，我们经常谈论一种叫做图的数据结构:

He’s cute, let’s call him Graham

图可以在它们的边和/或节点上有标签，让我们给 Graham 一些边和节点标签。

Graham looks rather dashing in his new attire

标签也可以被认为是权重，但这取决于图表的设计者。

标签不一定是数字，也可以是文字。

Graham also likes memes

标签不必唯一；给多个节点相同的标签是完全可能的，有时也是有用的。以氢分子为例:

Notice the mix of numerical and textual datatypes

图形可以有特征(也称为属性)。

注意不要混淆特征和标签。一种简单的思考方式是用名字、人物和人来类比:

节点是一个人，节点的标签是一个人的名字，节点的特征是这个人的特征。

图形可以是有向的或无向的:

Note that directed graphs can have undirected edges too

图中的节点甚至可以有一条指向/连接到自身的边。这就是所谓的自循环。

图表可以是:

异构——由不同类型的节点组成
同类 —由相同类型的节点组成

并且是:

静态 —节点和边不变，不添加或删除任何东西
动态 —节点和边的改变、添加、删除、移动等。

粗略地说，图可以模糊地描述为

密集——由许多节点和边组成
稀疏 —由较少的节点和边组成

通过将图表转换成平面形式，可以使它们看起来更整洁，这基本上意味着重新排列节点，使边不相交

(Courtesy of The Geography of Transport Systems)

这些概念和术语在我们探索当前在各种 GNN 架构中使用的许多不同方法时会派上用场。这些基本方法中的一些在:

图形分析

有许多不同的图形结构可供 ML 模型学习(轮子、周期、星形、网格、棒棒糖、密集、稀疏等)。)

你可以遍历一个图

Jon went from Bob’s to Bic’s in 4 timesteps; he better hope it doesn’t snow!

在这种情况下，我们正在遍历一个无向图。显然，如果图是有向的，人们可以简单地沿着边的方向走。有几种不同类型的遍历，所以要小心措辞。以下是一些最常见的图形遍历术语及其含义:

走查:一个图的遍历——一个封闭走查是当目的节点与源节点相同时
步道:没有重复边缘的步道——一条环路是一条封闭的步道
路径:没有重复节点的行走——c循环是封闭路径

基于遍历的概念，我们也可以通过图发送消息。

Sam? More like S-p-am…

山姆的所有邻居都在给他发信息，其中 t 代表时间步长。Sam 可以选择打开自己的邮箱，更新自己的信息。通过网络传播信息的概念对于具有注意力机制的模型来说非常重要。在图中，消息传递是我们推广卷积的一种方式。稍后将详细介绍。

电子图形——计算机上的图形

学完这些，你现在对图论有了一个基本的了解！对于 GNNs 来说，任何其他重要的概念都会在它们出现的时候被解释，但是同时，还有最后一个关于图的主题我们需要讨论。我们必须学会如何通过计算来表达图形。

有几种方法可以把一张图表转换成计算机可以理解的格式；它们都是不同类型的矩阵。

关联矩阵( I ):

关联矩阵，在研究论文中通常用大写字母 I 表示，由 1、0 和-1 组成，关联矩阵可以通过以下简单模式制作:

From Graph to Incidence Matrix

(加权)邻接矩阵( A ):

图的邻接矩阵是由 1 和 0 组成的，除非它被另外加权或标记。在任何情况下一个都可以按照这个规则来构建:

因此，无向图的邻接矩阵沿其对角线对称，从左上到右下:

Adjacency Matrices (Courtesy of Wolfram Mathworld)

有向图的邻接矩阵只覆盖对角线的一边，因为有向图的边只有一个方向。

邻接矩阵可以被“加权”，这基本上意味着每条边都有一个与之相关联的值，因此该值被放在各自的矩阵坐标中，而不是 1。这些权重可以代表你想要的任何东西。以分子为例，它们可以代表两个节点(原子)之间的键的类型。在 LinkedIn 这样的社交网络中，它们可以代表两个节点(人)之间的第一、第二或第三顺序连接。

边缘权重的概念是 GNNs 如此强大的一个原因；它们允许我们同时考虑结构(相关)和奇异(独立)信息。对于真实世界的应用程序，这意味着我们既可以考虑内部信息，也可以考虑外部信息。

度矩阵( D ):

图的度矩阵可以用前面讲过的度的概念来求。 D 本质上是一个对角矩阵，其中对角线的每一个值都是其对应节点的度数。

The different types of graphs and Matrices (Courtesy of the EU Bioinformatics Institute)

注意，度只是邻接矩阵中每一行的和。然后将这些度放在矩阵的对角线上(邻接矩阵的对称线)。这很好地引出了最终的矩阵:

拉普拉斯矩阵(L):

图的拉普拉斯矩阵是从度矩阵中减去邻接矩阵的结果:

度矩阵中的每个值都减去其在邻接矩阵中的相应值，如下所示:

The graph matrix trinity (Courtesy of Wikipedia)

还存在其他图形矩阵表示，如关联矩阵、，但是绝大多数图形类型数据的 GNN 应用程序使用一个、两个或所有三个矩阵。这是因为它们，尤其是拉普拉斯矩阵，提供了关于实体(具有属性的元素)和关系(实体之间的连接)的大量信息。

唯一缺少的是一个规则(一个通过关系将实体映射到其他实体的函数)。这就是神经网络派上用场的地方。

如果你需要更多关于图形及其表示的见解，我强烈推荐你看看 这篇深度中等的文章。

深度学习—速成班

现在让我们快速运行另一半“图形神经网络”。当有人说“深度学习”时，神经网络就是我们谈论的架构。神经网络架构建立在感知器的概念之上，感知器受到人类大脑中神经元相互作用的启发。

人工神经网络(或简称 NN)及其扩展家族，包括卷积神经网络、递归神经网络，当然还有图神经网络，都是深度学习算法的类型。

深度学习是一种机器学习算法，而机器学习算法又是人工智能的一个子集。

这一切都始于不起眼的线性方程。

y = mx + b

如果我们把这个等式构造成一个感知器，我们会看到:

其中输出(y)是偏差(b)和输入(x)之和(E)乘以权重(m)。

神经网络通常有一个激活函数，它基本上决定一个给定的神经元输出(即 y )是否应该被认为是“激活的”，并将一个感知器的输出值保持在一个合理的、可计算的范围内。(sigmoid 表示 0–1，tanh 表示-1–1，ReLU 表示 0 或 1，以此类推。).这就是为什么我们在感知器的末端附加一个激活函数。

当我们把一堆感知器放在一起时，我们得到了类似于神经网络的开端的东西！这些感知器将数值从一层传递到另一层，每次传递都使该数值更接近网络训练所针对的目标/标签。

当你把一堆感知器放在一起，你会得到:

A vanilla NN (courtesy of Digital Trends)

为了训练神经网络，我们需要首先计算我们需要调整模型的权重多少。我们用一个损失函数来计算误差。

其中 e 为误差， Y 为预期输出，为实际输出。在高层次上，误差被计算为实际输出(神经网络的预测)减去预期输出(目标)。目标是最小化误差。通过使用称为反向传播的过程来调整每个层的权重，误差被最小化。

本质上，反向传播将调整分布在从输出层到输入层的整个网络中。调整量由接收误差作为输入的优化功能决定。优化函数可以想象成一个球滚下山坡，球的位置就是误差。因此，当球滚到山脚时，误差最小。

此外，还有一些必须定义的超参数，其中最重要的一个是学习率。学习速率调整应用优化函数的速率。学习速度就像重力设置；重力越大(学习率越高)球滚下山的速度越快，反过来也是一样。

The propagation of a network (Courtesy of 3Blue1Brown)

神经网络有许多不同的宏观和微观定制，使每个模型都是独特的，具有不同的性能水平，但所有这些都是基于这个普通模型。稍后我们将会看到这是如何实现的，特别是对于图形学习。像卷积和递归这样的运算将根据需要引入。

深度学习是图论

为了把我们所研究的一切联系起来，并检验我们的知识，我们将解决房间里的大象。如果你一直在关注，你可能会注意到一个微妙但明显的事实:

人工神经网络其实只是图！

NNs 是一种特殊的图形，但是它们具有相同的结构，因此具有相同的术语、概念和规则。

回想一下，感知器的结构本质上是:

感知器图片(修改)

我们可以将输入值(x)、偏差值(b)和求和运算(E)看作是图中的 3 个节点。我们可以将权重(m)视为连接输入值(x)和求和运算(E)的边。

NNs 最相似的特定类型的图是多部分图。多部图是可以分成不同节点集的图。每个集合中的节点可以共享集合之间的边，但不能共享每个集合内的边。

Isomorphic bipartite graphs (courtesy of Wolfram MathWorld)

一些神经网络甚至具有全连接节点、条件节点和其他疯狂的架构，这些架构赋予了神经网络其标志性的多功能性和能力；以下是一些最受欢迎的架构:

Neural Network Zoo (Courtesy of Asimov Institute)

每种颜色对应一种不同类型的节点，节点可以用多种不同的方式排列。通过网络向前或向后传播数据类似于在图中传递消息。图中的边或节点特征类似于神经网络中的权重。注意一些节点甚至有我们之前提到的自循环(RNNs 固有的——递归神经网络)。

神经网络不是唯一具有类似图形结构的机器学习模型。

k 均值
k-最近邻
决策树
随机森林
马尔可夫链

都像图形本身一样构造，或者在图形结构中输出数据。

因此，这意味着图形学习模型可以用来学习这些机器学习算法本身。在超参数优化中有潜在的应用。这正是这篇令人惊叹的论文的作者们所做的。

随着我们更多地了解在几何数据上推广深度学习，可能性才刚刚开始浮出水面。

本质上

我们讨论了很多，但概括来说，我们深入探讨了 3 个概念

图论
深度学习
基于图论的机器学习

记住先决条件，你就能完全理解和欣赏图形学习。在高层次上，图学习使用一系列旨在处理非欧几里得数据的神经网络，进一步探索和利用深度学习和图论之间的关系。

关键要点

有许多关键要点，但重点是:

所有图形都有属性，这些属性定义了可以使用或分析的可能动作和限制。
使用各种矩阵通过计算表示图形。每个矩阵提供不同数量或类型的信息。
深度学习是机器学习的一个子集它大致模仿了人类大脑使用神经元的工作方式。
深度学习通过迭代学习通过网络向前传递信息，向后传播神经元调整。
神经网络(以及其他机器学习算法)与图论有着密切的联系；有的本身就是图，或者输出。

现在，您已经具备了进入图形学习奇妙世界所需的所有先决条件。一个好的起点是研究到目前为止已经开发的各种图形神经网络。

需要看到更多这样的内容？

跟我上LinkedIn，*** 脸书，insta gram，当然还有 中*

我所有的内容都在 我的网站 我所有的项目都在GitHub

我总是希望结识新朋友、合作或学习新东西，所以请随时联系flawnsontong1@gmail.com

向上和向前，永远和唯一🚀

描绘英国退出欧盟

原文：https://towardsdatascience.com/graphing-brexit-bbe4314cf70?source=collection_archive---------9-----------------------

我和我的许多同胞一起，在周三晚上观看了英国议员对一系列潜在的英国退出欧盟选项投“不”票，然后阅读了不同个人和政党在各种网站上投票的分析。

虽然非常有趣，但所有的分析对我来说都是非常表格化的(T4)，我很好奇我们是否可以通过将数据放到图表中来学习新的东西。

获取数据

我四处搜索了一下，试图找到选票背后的数据，虽然有官方记录，但我发现《卫报》的“你的议员如何投票表”是最容易处理的。

Guardian Voting Table

我编写了一个 scraper，将这些数据放入 CSV 文件中，我们可以使用 LOAD CSV 工具将这些文件导入 Neo4j。

你可以在mneedham/graphing-英国退出欧盟 GitHub 资源库中找到 scrapper 和原始 CSV 文件。下面是其中一个文件的示例:

Sample of mps.csv

导入数据

Enable multi statement query editor

我们可以通过将以下脚本粘贴到 Neo4j 浏览器中，将数据导入到 Neo4j 中。如果您在家里跟进，请确保启用了多语句查询编辑器。

你还需要确保你已经安装了流行的 APOC 库，因为我们用它来创建表明议员投票方式的关系。

// Create one node per motion
LOAD CSV WITH HEADERS FROM "[https://github.com/mneedham/graphing-brexit/raw/master/data/motions.csv](https://github.com/mneedham/graphing-brexit/raw/master/data/motions.csv)" AS row
MERGE (m:Motion {id: toInteger(row.id)})
SET m.name = row.name;// Create nodes for each MP and each party and connect them
LOAD CSV WITH HEADERS FROM "[https://github.com/mneedham/graphing-brexit/raw/master/data/mps.csv](https://github.com/mneedham/graphing-brexit/raw/master/data/mps.csv)" AS row
MERGE (person:Person {name: row.mp})
MERGE (party:Party {name: row.party})
MERGE (person)-[:MEMBER_OF]->(party);// Create a relationship between each MP and each motion
LOAD CSV WITH HEADERS FROM "[https://github.com/mneedham/graphing-brexit/raw/master/data/votes.csv](https://github.com/mneedham/graphing-brexit/raw/master/data/votes.csv)" AS row
MATCH (person:Person {name: row.person})
MATCH (motion:Motion {id: toInteger(row.motionId)})
CALL apoc.create.relationship(person, row.vote, {}, motion) 
YIELD rel
RETURN rel;

我们可以通过执行CALL db.schema()命令来查看图表的模式:

Graph model for the Brexit votes

分析数据

既然我们已经加载了数据，让我们来分析它。我们将从支持和反对不同运动的总次数的概述开始。我们可以通过运行以下查询来做到这一点:

MATCH (motion:Motion)
RETURN motion.name,
       size((motion)<-[:FOR]-()) AS for,
       size((motion)<-[:AGAINST]-()) AS against
ORDER BY motion.id

Total votes for each motion

对于那些熟知这些数字的人来说，你会注意到有些数字差了一位。这是因为守护表好像少了一个 MP ！我不确定是谁，但如果你发现了它，请告诉我，我会更新 CSV 文件。

从数据中我们还能发现什么？

47 个人什么都没投

MATCH (person:Person)-->(party:Party)
WHERE not((person)-[:FOR]->()) AND not ((person)-[:AGAINST]->())
RETURN party.name, count(*) AS count
ORDER BY count DESC

Non votes by party

其中许多人是保守党的内阁成员

MATCH (person:Person)
WHERE not((person)-[:FOR]->()) AND not ((person)-[:AGAINST]->())
MATCH path = (person)-->(:Motion)
WHERE (:Party {name: "Con"})<--(person)
RETURN path
LIMIT 50

Ain’t nobody got time to vote

有保守派投票支持工党的计划吗？

MATCH path = (:Motion {id: 3})<-[:FOR]-()-[:MEMBER_OF]->(:Party {name: "Con"})
RETURN path

Conservatives voting for Labour’s plan

就一个！

用 Neo4j Bloom 可视化数据

在又写了几个 Cypher 查询之后，我开始好奇我们是否可以做任何视觉分析，所以我打开了 Neo4j Bloom 。

呼声最高的两个人是 Boris Johnson 和 Jacob Rees-Mogg，通过输入搜索词Boris Johnson Motion Jacob Rees-Mogg，我们得到下面的 BoRees Star :

The BoRees Star

如我们所见，他们对每一项动议都投了相同的票。

使用图算法寻找相似的投票者

在比较了几个这样的 MP 之后，我想尝试自动化这个过程，这个问题对于 Neo4j 图算法库中的 相似性算法 来说是完美的。

我们想找出不同人的投票模式有多相似。最初我认为我们可以使用 Jaccard 相似性来做到这一点，但意识到它不会工作得很好，因为虽然两个人可以连接到同一个动议，但这并不意味着他们是相似的-他们可能以不同的方式投票！

相反，我们会认为投票是给一个动议打分。如果你投票:

因为这意味着你喜欢它。得分为 1
没有投票，这意味着你不确定。0.5 分
反对那就说明你不喜欢。得分为 0

如果我们像这样对投票进行评分，这意味着我们可以使用一种基于权重的相似性算法。余弦相似性算法通常用于计算推荐引擎中项目之间的相似性，因此我们将尝试使用该算法。

谁的选票最像鲍里斯？

MATCH (p1Party:Party)<-[:MEMBER_OF]-(p1:Person)-[r1]->(m:Motion)
WHERE p1.name = "Boris Johnson"
MATCH (p2Party:Party)<-[:MEMBER_OF]-(p2:Person)-[r2]->(m) 
WHERE p2 <> p1
WITH p1, p2, p2Party,
     CASE WHEN type(r1) = "FOR" THEN 5 
          WHEN type(r1) = "DID_NOT_VOTE" THEN 0.5 
          ELSE 0 END AS r1Score,
     CASE WHEN type(r2) = "FOR" THEN 5 
          WHEN type(r2) = "DID_NOT_VOTE" THEN 0.5 
          ELSE 0 END AS r2Score 
WITH p2.name AS to,
     p2Party.name AS party,
     algo.similarity.cosine(collect(r1Score), collect(r2Score)) 
     AS similarity
WHERE similarity > 0
RETURN to, party, similarity
ORDER BY similarity DESC

也许不足为奇的是，保守党中的许多人也投了相同的票。

如果排除同党的人呢？

MATCH (p1Party:Party)<-[:MEMBER_OF]-(p1:Person)-[r1]->(m:Motion)
WHERE p1.name = "Boris Johnson"
MATCH (p2Party:Party)<-[:MEMBER_OF]-(p2:Person)-[r2]->(m) 
WHERE p2 <> p1
WITH p1, p2, p2Party,
     CASE WHEN type(r1) = "FOR" THEN 5 
          WHEN type(r1) = "DID_NOT_VOTE" THEN 0.5 
          ELSE 0 END AS r1Score,
     CASE WHEN type(r2) = "FOR" THEN 5 
          WHEN type(r2) = "DID_NOT_VOTE" THEN 0.5 
          ELSE 0 END AS r2Score
WHERE p1Party <> p2Party 
WITH p2.name AS to,
     p2Party.name AS party,
     algo.similarity.cosine(collect(r1Score), collect(r2Score)) 
     AS similarity
WHERE similarity > 0
RETURN to, party, similarity
ORDER BY similarity DESC

有趣的是，凯特·霍伊是一个选区的议员，该选区有 78%的人投票支持留欧，但她的投票方式与支持脱欧的人相似。

接下来呢？

这确实为一些潜在的未来分析铺平了道路。我们能否根据这些选项对脱欧/留欧立场的支持程度对它们进行排序，并计算出哪些议员的投票方式最符合其选区的投票结果？

我们可以做的另一件事是创建一个 MPs 的相似图，然后在其上运行一些社区检测算法。

如果你对数据的图形分析感兴趣，你可能会喜欢我和艾米·霍德勒在过去 9 个月里一直在研究的《奥莱利图形算法》一书。我们正处于最后的审查阶段，它应该在未来几周内可用。

你可以从 Neo4j 网站注册获得免费的电子版，网址:neo4j.com/graph-algorithms-book。

O’Reilly Graph Algorithms Book

绘制英国退出欧盟:聚类版

原文：https://towardsdatascience.com/graphing-brexit-clustering-edition-3b966694e723?source=collection_archive---------18-----------------------

这是展示如何用图表分析英国退出欧盟系列文章的第二篇。在本帖中，我们根据投票记录对议员进行分类。

Brexit — EU (https://unsplash.com/photos/yxDhneWz3vk)

上周五，我写了一篇博文，展示了如何使用 Neo4j 对英国退出欧盟的数据进行图形分析，在第一篇博文的末尾，我展示了如何根据议员们对不同动议的立场，计算他们与 Boris Johnson 的相似度。

在做这个分析的时候，我注意到有很多人对每个动议都以同样的方式投票，所以我想进一步探究这个问题。

罗宾·布拉姆雷还指引我去了 CommonsVotes 网站，那里有 CSV 格式的投票记录。

这将有助于未来的英国退出欧盟分析，所以让我们快速了解如何从那里导入数据到 Neo4j。

导入常用选项数据

我已经下载了所有指示性投票的数据，并把文件放到了图形-英国退出欧盟 GitHub 库的data/commons votes目录下。

我们可以使用下面的 Cypher 查询导入所有指示性动作的数据:

UNWIND [655,656,657,658,659,660,661,662] AS division
LOAD CSV FROM "[https://github.com/mneedham/graphing-brexit/raw/master/data/commonsvotes/Division](https://github.com/mneedham/graphing-brexit/raw/master/data/commonsvotes/Division)" + division + ".csv" AS row// Create motion nodes
WITH division, collect(row) AS rows
MERGE (motion:Motion {division: trim(split(rows[0][0], ":")[1]) })
SET motion.name = rows[2][0]// Skip the first 6 rows as they have metadata we don't need
WITH motion, rows
UNWIND rows[7..] AS row// Create person, party, constituency, and corresponding rels
MERGE (person:Person {name: row[0]})
MERGE (party:Party {name: row[1]})
MERGE (constituency:Constituency {name: row[2]})
MERGE (person)-[:MEMBER_OF]->(party)
MERGE (person)-[:REPRESENTS]->(constituency)
WITH person, motion,  
     CASE WHEN row[3] = "Aye" THEN "FOR" 
          WHEN row[3] = "No" THEN "AGAINST" 
          ELSE "DID_NOT_VOTE" END AS vote
CALL apoc.merge.relationship(person, vote, {}, {}, motion)
YIELD rel
RETURN count(*)

相同的选民

现在我们已经加载了数据，我们将探究那些相同的投票者。我尝试了几种不同的方法，最终决定采用以下方法:

基于以相同方式投票的人，创建相似度图
在相似性图上运行连通分量算法来找到人群的聚类

在我们完成这两个步骤之后，我们希望有一个节点来代表我们找到的每个社区或集群，以及从每个人到他们的社区的关系。

我们开始吧！

相似图

我们将创建一个议员相似度图，这是一种奇特的说法，即我们将在以相同方式投票的成对议员之间创建关系。

Cosine Similarity

正如在第一篇文章中，我们将使用来自 Neo4j 图形算法库的余弦相似度算法来做这件事。在我们的数据库中创建任何关系之前，我们将使用write: false和similarityCutoff: 1.0运行该过程的非流版本(即它们的行为相同)，以查看在不写入数据库的情况下我们有多少对相同的投票者。

下面的 Cypher 查询可以做到这一点:

MATCH (p:Person), (c:Motion)
OPTIONAL MATCH (p)-[vote]->(c)
WITH p, c,
     CASE WHEN type(vote) = "FOR" THEN 1
          WHEN type(vote) = "DID_NOT_VOTE" THEN 0.5
          ELSE 0 END AS score
WITH {item:id(p), weights: collect(score)} as userData
WITH collect(userData) as data
CALL algo.similarity.cosine(data, {
  similarityCutoff: 1.0, write: false
})
YIELD nodes, similarityPairs, writeRelationshipType, writeProperty
RETURN nodes, similarityPairs, writeRelationshipType, writeProperty

How many identical votes do we have?

我们的 649 个议员有超过 10，000 个相似性对！这应该是一个有趣的图表。

我们现在将使用write:true运行这个过程，以便在相似度为 1.0 的节点之间创建SIMILAR关系。下面是创建的图表示例:

Similarity Graph

查找具有连通分量的聚类

现在我们将在这个相似度图上运行连通分量算法。但是这个算法是做什么的呢？

在文档页面中:

连通分量或Union Find算法在无向图中寻找连通节点集，其中每个节点都可以从同一集合中的任何其他节点到达。

通过执行以下查询，我们可以在相似度图上运行该算法的流版本:

// Run the algorithm for:
// nodes with 'Person' label, based on the 'SIMILAR' rel type
CALL algo.unionFind.stream('Person', 'SIMILAR', {direction: "BOTH"})
YIELD nodeId,setId// Grouping by setId, create a 'Community' node for each community
WITH setId, collect(algo.getNodeById(nodeId)) AS nodes
MERGE (community:Community {
  id: setId, type: "Connected Components"
})// Create 'IN_COMMUNITY' rel from each node to its community
WITH community, nodes
UNWIND nodes AS node
MERGE (node)-[:IN_COMMUNITY]->(community);

这个查询返回一串setId, nodeId对。然后，我们为每个setId创建一个标签为Community的节点，并创建一个从每个节点到其对应社区的关系。我们可以运行以下查询来可视化这些社区:

MATCH (c:Community)
WHERE size((c)<-[:IN_COMMUNITY]-()) > 10
MATCH path = (c)<-[comm:IN_COMMUNITY]-(person)
RETURN path
LIMIT 200

Communities of MPs based on how they voted

那么…这些社区的人们是如何投票的呢？通过运行以下 Cypher 查询，我们可以创建一个可视化的社区投票方式:

// Find communities with more than 10 people
MATCH (c:Community)
WITH c, size((c)<-[:IN_COMMUNITY]-()) AS size
WHERE size > 10// Take one person to act as a representative of each community
MATCH (c)<-[rel:IN_COMMUNITY]-(person)
WITH c, collect(person)[0] AS person// Check which motions that person voted for
WITH c, [(person)-[:FOR]->(motion:Motion) | motion] AS votes// Create a virtual relationship from each community to the motion
UNWIND votes AS vote       
CALL apoc.create.vRelationship(c,"FOR",{},vote) yield rel
RETURN *

在这个查询中，我们选择一个人作为他们社区的代表。然后我们检查他们是如何投票的，最后从每个社区创建一个虚拟关系(使用 APOC 库)到投票赞成的动议。这导致以下可视化:

How did each community vote?

黄色节点代表社区，数字表示该社区的议员人数。我们可以看到右边有一个很大的社区，里面有 106 个人，他们投票反对任何交易，并希望获得可能的优先安排。我们会假设这些集群中的人大多属于保守党。

另一方面，我们有较小的集团投票赞成其他动议，包括杰里米·科尔宾的替代计划、撤销第 50 条和确认性公众投票。

在每个集群中寻找有影响力的成员

当我向迈克尔展示这一可视化效果时，他建议我们应该找出每个集群中最有影响力的人，我认为一个简单的方法就是统计他们在维基百科页面上的浏览量。

我编写了一个脚本，将这些计数提取到一个 CSV 文件中，然后将它们导入 Neo4j:

load csv with headers from "https://github.com/mneedham/graphing-brexit/raw/master/data/pageviews.csv" AS row
MATCH (p:Person {name: row.person})
SET p.pageviews = toInteger(row.pageviews);

迈克尔还建议给每个议员添加党派标签，这样我们就可以在可视化上用他们的党派颜色给他们上色。以下查询可以做到这一点:

match (p:Person)-[:MEMBER_OF]->(pa:Party)
CALL apoc.create.addLabels(p, [apoc.text.replace(pa.name, " ", "")]) YIELD node
RETURN count(*)

现在我们已经完成了，我们可以将我们的查询更新为将每个聚类中最有影响力的前 3 个人添加到我们的可视化中:

// Find communities with more than 10 people
MATCH (c:Community)
WHERE size((c)<-[:IN_COMMUNITY]-()) > 10// Find the top 3 most influential people per community
MATCH (c)<-[rel:IN_COMMUNITY]-(person)
WITH c, rel, size, person
ORDER BY person.pageviews DESC
WITH c, collect({person: person, rel:rel })[..3] AS topPeople// Select the first of those people to represent the cluster
WITH c, topPeople, topPeople[0].person AS person// Check how that person voted
WITH c, topPeople, 
     [(person)-[:FOR]->(motion:Motion) | motion] AS votes// Create a virtual relationship from each community to the motion     
UNWIND votes AS vote       
CALL apoc.create.vRelationship(c,"FOR",{},vote) 
yield rel
RETURN *

Communities, their most famous MPs, and how they voted

现在我们可以清楚地看到右手边的保守星团。最大的一个包含鲍里斯·约翰逊，雅各布·里斯-莫格和普里蒂·帕特尔，而另一个包含一些不太知名的党员。

左边的苏格兰民族党是黄色的，他们赞成进行公众投票，废除第 50 条。独立党派也投票赞成这两项动议。这两个社区分开的原因是因为我们在构建我们的相似度图时考虑到了反对和没有投票的关系，他们在那里的投票肯定是不同的

最后工党成员分裂成几个群体，尽管他们都投票支持杰里米·科尔宾的动议。与 SNP 和独立聚类一样，如果我们只基于关系的构建相似性图，我们最终会得到数量更少的聚类。

我们已经做了大部分的基础工作，所以让我们看看如果我们只考虑人们投票赞成的动议会发生什么。

基于投票赞成的动议的分组

我们将使用类似的方法来构建我们的相似性图，但是这一次因为我们只关心一种关系类型，所以我们可以使用 Jaccard 相似性算法来计算节点之间的相似性。

我们希望在以相同方式投票支持动议的人们之间建立一种SIMILAR_FOR关系。下面的 Cypher 查询将完成这项工作:

MATCH (p:Person)-[:FOR]->(motion:Motion)
WITH {item:id(p), categories: collect(id(motion))} as userData
WITH collect(userData) as data
CALL algo.similarity.jaccard(data, {
  similarityCutoff: 1.0,
  write:true,
  writeRelationshipType: "SIMILAR_FOR"
})
YIELD nodes, similarityPairs, writeRelationshipType, writeProperty
RETURN nodes, similarityPairs, writeRelationshipType, writeProperty;

现在，我们将在此图表上运行连接组件算法，与之前一样，我们将把人们与社区节点联系起来:

// Run the algorithm for:
// nodes with 'Person' label, based on the 'SIMILAR_FOR' rel type
CALL algo.unionFind.stream('Person', 'SIMILAR_FOR', {
  direction: "BOTH"
})
YIELD nodeId,setId// Grouping by setId, create a 'Community' node for each community
WITH setId, collect(algo.getNodeById(nodeId)) AS nodes
MERGE (community:Community {
  id: setId, type: "Connected Components FOR"
})
WITH community, nodes// Create 'IN_COMMUNITY' rel from each node to its community
UNWIND nodes AS node
MERGE (node)-[:IN_COMMUNITY]->(community);

一旦我们做到了这一点，我们可以重新运行查询，找到集群，运动，每个集群最有名的人。我们根据维基百科页面的浏览量来确定最著名的人。

MATCH (c:Community {type: "Connected Components FOR"})
WITH c, size((c)<-[:IN_COMMUNITY]-()) AS size
WHERE size > 10MATCH (c)<-[rel:IN_COMMUNITY]-(person)
WITH c, rel, size, person
ORDER BY person.pageviews DESCWITH c, collect({person: person, rel:rel })[..3] AS topPeople, size
WITH c, topPeople, topPeople[0].person AS person, size
WITH c, topPeople, size, [(person)-[:FOR]->(motion:Motion) | motion] AS votes

UNWIND votes AS vote       
CALL apoc.create.vRelationship(c,"FOR",{},vote) yield rel
RETURN *;

Communities, their most famous MPs, and how they voted

我们现在在右边有三个集群。保守派集群仍然存在，但我们现在也有一个集群包含民主统一党成员，他们只投票赞成或有优惠安排。

在左边，我们现在有一个包含保守党、独立党和自由民主党成员的集群。该集群投票赞成撤销，以避免无交易和确认性公众投票。

然后有一堆不同的劳工团体投票支持其他 6 项动议的某个子集。

在第一篇文章之后，克里斯·艾尔问了以下问题:

看起来确实有一些基于这些集群的政治团体:

保守党有强硬的英国退出欧盟一面，比我想象的要大得多。
独立党的一些成员似乎与一些保守派和自由民主党人有相似的观点

接下来呢？

在我写完第一篇文章后，我在 twitter 上列出了人们建议的其他类型的分析。

Jo Stichbury 建议我研究一下议员们的投票是否符合他们选区的要求:

作为这篇文章的一部分，我已经加载了选区和投票离开的人的百分比，现在我可以尝试回答这个问题了。

你可以从 Neo4j 网站注册获得免费的电子版，网址:【neo4j.com/graph-algorithms-book】T2。

O’Reilly Graph Algorithms Book

从 MongoDB 绘制数据

原文：https://towardsdatascience.com/graphing-data-from-mongodb-99c3722650da?source=collection_archive---------12-----------------------

本指南将带您了解如何从 Jupyter 笔记本连接到您自己的 MongoDB 实例，获取您的数据并绘制它，所有这些都是用 python 完成的。

介绍

灵活的 NoSQL 数据库可以处理大量的非结构化数据，并且可以灵活地增加或减少存储容量而不造成损失，它将逐渐取代关系数据库。

MongoDB 是 NoSQL 数据库中的佼佼者之一，能够满足在多个开发阶段快速灵活地访问数据的业务需求，尤其是在实时数据占主导地位的情况下。

注意，我不打算介绍 MongoDB 的安装和数据库的设置，因为已经有大量的文档介绍了这方面的内容。

设置全局变量

如上所述，假设您已经在 Atlas 上运行了一个 MongoDB 数据库。在 MongoDB 上的集群下，点击相关数据库上的连接。有 3 种不同的方法连接到数据库。如果您还没有，那么您需要将您自己的 IP 地址加入白名单，并为这个特定项目创建一个 MongoDB 用户。

选择第二个选项— 连接您的应用程序。选择 Python 作为你的驱动，选择 3.6 或更高版本作为你的版本。将连接字符串复制到剪贴板。

在首选编辑器中打开 bash 概要文件，并输入以下内容:

export 'MONGO_URI' = "YOUR_CONNECTION_STRING"

用刚才复制的连接字符串替换“YOUR_CONNECTION_STRING”。在连接字符串中，您还必须替换为当前用户的登录密码。

从命令行运行:

source ~/.bash_profile

安装 Anaconda

现在，为了使本指南可移植并可在任何机器上运行，我首先需要创建一个虚拟环境。查看我们之前关于安装 Anaconda 发行版的指南:

用 Anaconda 安装 Jupyter】

/guides/巨蟒/巨蟒

创建虚拟环境

我们将运行以下命令来创建 python3.7 环境。创建我们的虚拟环境:

conda create -n mongodb-playground python=3.7 -y

并启动它:

conda activate mongodb-playground

我们还需要以下库来连接到 Mongo 4.0:

conda install pymongo==3.8 dnspython ipykernel -y

下一个命令确保我们的 Jupyterlab 实例连接到这个虚拟环境:

python -m ipykernel install --user

附加安装

稍后，一旦我们获取了数据，我们将需要绘制图表。鉴于其相对简单的语法和交互性，我们通常建议在 python 中使用 plotly。

为了在 jupyterlab 中使用，我们需要安装 JupyterLab 和 ipywidgets 包:

conda install -c conda-forge jupyterlab-plotly-extension -y

Plotly 有一个名为袖扣的熊猫包装器(数据处理库)，目前它与 plotly 的最新版本存在兼容性问题。目前解决这个问题的方法是降级 plotly 并使用以下命令安装袖扣。一旦你看到用袖扣生成图形是多么容易，你就会明白为什么我们要经历这种麻烦。袖扣团队已经为修复工作努力了一段时间，但还没有结果。

从 2019 年 9 月起，这将帮助您启动并运行:

conda install -c conda-forge plotly=2.7.0 -y
conda install -c conda-forge cufflinks-py -y

现在我们可以用以下方法旋转 Jupyterlab:

jupyter lab

在启动时，您可能会得到一个推荐构建的提示——我们上面运行的 jupyterlab-plotly-extension 安装。点击构建，等待完成。

在朱庇特

正在连接到 MongoDB

让我们首先导入我们需要的库:

import os # to create an interface with our operating systemimport sys # information on how our code is interacting with the host systemimport pymongo # for working with the MongoDB API

然后，我们连接到我们的 MongoDB 客户端:

client = pymongo.MongoClient(os.environ['MONGO_URI'])

注意，我们可以调用'MONGO_URI'，因为我们已经在~/.bash_profile中将连接字符串设置为环境变量。

访问我们的数据

现在让我们访问一个数据库，在本例中是 sample supplies。

db = client.sample_supplies

一个集合是存储在 MongoDB 数据库中的一组文档，大致相当于关系数据库中的一个表。获取一个集合的工作方式与我们上面访问数据库的方式相同。在这种情况下，我们的集合称为销售。

collection = db.sales

让我们通过获取单个文档来测试我们是否成功。下面的方法返回与我们的查询匹配的单个文档。

test = collection.find_one()

将我们的数据载入熊猫

Pandas 提供了快速、灵活、富于表现力的数据结构，旨在使处理“关系”或“标签”数据变得既简单又直观，可以说是最强大、最灵活的开源数据分析/操作工具。

我们可以用一个简单的命令将我们收集的全部数据转换成熊猫数据帧:

data = pd.DataFrame(list(db.sales.find()))

DataFrame 中的一些列仍然被格式化为字典或 PyMongo 方法。出于本指南的目的，让我们看一下客户列——这是一个字典，包含针对每个客户的年龄和性别的 2 个键值对。

我们需要拆分该列，使年龄和性别成为它们自己的列。为此，我们可以使用.apply(pd.Series)方法将字典转换成它自己的数据帧，并将其连接到我们现有的数据帧，所有这些都在一行中完成。

df = pd.concat([data.drop(['customer'], axis=1), data['customer'].apply(pd.Series)], axis=1)

例如，我们可以对项目列做类似的事情，但是这超出了本指南的范围。

绘制我们的数据

好了，让我们开始绘制数据来回答一些基本问题。首先，我们将导入我们的绘图库。

import plotly.plotly as py
import plotly.graph_objs as go
import plotly
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import cufflinks as cf
cf.set_config_file(offline=True)

下面是链接到和袖扣的文档。

定义您的业务问题

你想回答什么商业问题？我们为样本数据列出了一些示例问题:

商店的平均顾客满意度是多少——这是否会受到购买方式的影响，是通过电话、店内还是网上购买？

**df.groupby(['storeLocation', 'purchaseMethod'], as_index=True)['satisfaction'].mean().unstack().iplot(kind='bar', mode='group', title='Average Customer Satisfaction by Store')**

Average satisfaction ratings across all our stores.

2.按性别分类，收到的采购订单数量如何——有什么重大差异吗？

**df.groupby(['gender', 'purchaseMethod'], as_index=True)['_id'].count().unstack().iplot(kind='bar', mode='group', title='Purchase Orders by Gender')**

Men make more purchases over the phone, women in-store.

3.我们所有顾客的年龄分布是怎样的？

**df['age'].iplot(kind='hist', color='rgb(12, 128, 128)', opacity=0.75, bargap = 0.20,title="Age Distribution of our Customers", xTitle='Age', yTitle='Count')**

The largest group falls within the 35–42 age range.

过帐到 Kyso

好了，我们已经回答了一些关于业务指标的基本问题。是时候将我们的分析发布到我们团队的 Kyso 工作区了，这样每个人都可以从我们的见解中学习并将其应用到各自的角色中。

我们可以从本地机器推送到我们组织的 Github 存储库，并与 Kyso 同步:将 Github repo 连接到 Kyso
由于我们已经在 Jupyterlab 中，我们可以安装 Kyso 的发布扩展，并从这里直接将我们的笔记本发布到 Kyso:使用 Kyso 的 Jupyterlab 扩展
如果这是一次性分析，而不是定期运行，我们也可以在 Kyso 应用程序中手动上传笔记本。

GraphQL、Grafana 和 Dash

原文：https://towardsdatascience.com/graphql-grafana-and-dash-7aa96d940f1b?source=collection_archive---------6-----------------------

如果你对数据科学、数据操作或数据可视化感兴趣，这篇文章正适合你。我相信你已经听说过我在上面的主题中使用的名字。在这篇文章中，我将首先详细介绍每一个，然后进行比较。

GraphQL, Grafana and Dash

从上面三个中除了 GraphQL 另外两个用于数据可视化。今天的数据可视化工具已经超越了 Microsoft Excel 电子表格中使用的标准图表和图形，以更复杂的方式显示数据，如信息图、刻度盘和仪表、地理图、迷你图、热图以及详细的条形图、饼图和散点图。这些图像可能包括交互功能，使用户能够操作它们或深入数据进行查询和分析。还可以包括用于在数据更新或预定义条件发生时提醒用户的指示器。数据可视化已经成为现代商业智能的事实标准。

为了以任何方式可视化数据，首先你必须从某种来源提取数据。它可以是传感器、API、数据库等的系统。它还包括理解数据的不同特征，并得出它们有意义的、重要的和有趣的属性。数据提取还用于执行探索性分析，并从数据中提取相关信息。有许多方法和技术用于数据操作，如 Pandas、R、SQL、GraphQL 等。所以 GraphQL，这是我选择的主题之一，也是一种数据提取方法，但与其他方法完全不同。

所以我们从第一个开始，GraphQL。

GraphQL 是什么？

如今，大多数应用程序都需要从存储在数据库中的服务器获取数据。API 的职责是为存储的数据提供一个满足应用程序需求的接口。或者，应该对通过 API 获取的数据进行某种过滤，以满足应用程序的需求。

大多数人将 GraphQL 混淆为一种数据库技术。这并不十分准确，因为 GraphQL 是一种用于 API 而不是数据库的查询语言。从这个意义上说，它是数据库不可知的，可以有效地用于任何使用 API 的环境中。它支持声明性数据获取，因此与 React/React Native 完美结合，作为构建用户界面的声明性框架。GraphQL 可以补充或完全取代 REST APIs 的使用。

REST 和 GraphQL 的主要区别在于 RESTful APIs 有多个端点返回固定数据结构，而 GraphQL 服务器只公开一个单个端点并返回灵活数据结构。

使用 RESTful API，您最终会得到您不需要的数据。例如，当调用环境/构建/ < id > 端点时，您将获得与该特定构建相关的所有数据。您可以获得类似于创建日期、更新日期、状态等数据。但是我们需要的只是作者的名字。这是一个在 RESTful API 中过度获取的明显例子。

在环境/构建/ < id > 的情况下，不足以检索我们正在寻找的内容。为了获得 build 所属的代码库，我们必须调用另一个端点environment/build//code bases。这种情况称为欠取*。*

GraphQL 使用自己的类型系统来定义一个 API 的模式，其语法称为模式定义语言 (SDL)。模式充当服务器和客户机之间的桥梁，定义客户机如何访问数据。

一旦定义了模式，前端和后端开发人员就可以独立工作了，因为前端可以很容易地用模拟数据进行测试。前端也可以从模式中获得有用的信息，比如它的类型、查询和突变。该模式还提供了类型安全，这对于前端和后端开发来说是一个优势，因为它可以及早发现类型错误。

示例查询:

*query {
  books {
    id
    title
    author
    isbn
    price  } 
}*

这里我们得到了一个端点，在这个端点上，我们可以获得所有必要的数据，而不会通过 GraphQL 服务器进行任何过量或不足的获取。

许多流行的编程语言支持 GraphQL。

C# /。网
走
Groovy
Java
JavaScript
科特林
PHP
Python
红宝石
Scala

除了数据获取方面的进步，性能优化、版本控制和易于启动也是您应该试用 GraphQL 的几个原因。

Grafana 是什么？

Climate Station Dashboard using Grafana ( https://developers.bigclown.com/integrations/grafana-for-visualization )

Grafana 是一个开源的仪表板、分析和监控平台，可以连接各种资源，如 Elasticsearch、Influxdb、Graphite、Prometheus、AWS Cloud Watch 等。最重要的是，Grafana 能够将几个数据源放在一个仪表板中，并添加将托管单个面板(在 UI 中)的行。

Grafana 允许您查询、可视化、提醒和了解您的指标，无论它们存储在哪里。您可以使用 Grafana 创建、探索和共享仪表板，培养数据驱动的文化。

如果我们谈论认证，Grafana 可以与 LDAP，Google Auth，Grafana.com，Github 集成。然而，如果您的公司使用 SSO(单点登录)之类的技术来处理身份验证，Grafana 可以让它轻松地与您现有的工作流程一起工作。

Grafana 也已经创建了由社区构建的仪表板。我们可以通过数据源、面板类型、类别和收集器来选择。你可以在这里看看那些仪表盘。

如果您有与 Grafana 兼容的数据源，您所要做的就是设置这些数据源，然后创建您需要的面板，以便可视化您想要显示的内容。这里，您将从一个只有一行的空仪表板开始。在那一行你可以放任何种类和任何数量的面板，每个面板负责一个视觉。

您可以选择您喜欢的面板，并将其添加到您的仪表板中。就这么简单。您可以选择面板的类型，并探索与之交互的方式。您可以轻松地创建动态和可重用的仪表板，其中变量以下拉列表的形式显示在仪表板顶部，您可以在其中进行更改和交互。此外，您可以通过查询来深入查看视图。除此之外，您还可以使用拆分视图进行相互比较。

您可以轻松创建实时仪表板，甚至可以单独浏览日志。另一个有用的特性是给用户空间来为他们的重要指标定义警报规则。Grafana 将持续寻找最新数据，并向 Slack、PagerDuty、VictorOps 等系统发送通知。

Grafana 是一个非常用户友好的工具，并且有许多吸引人的设计可供选择。

Dash 是什么？

Dash 是一个开源的 Python 库，用于创建反应式的、基于 Web 的应用程序。两年前，Dash 开始在 GitHub 上公开进行概念验证。我们在网上保留了这个原型，但是 Dash 的后续工作是秘密进行的。我们使用来自银行、实验室和数据科学团队的私人试验的反馈来指导产品的发展。 今天，我们很兴奋地宣布 Dash 的首次公开发布，它既是企业级的，也是 Plotly 开源工具的一流成员。 Dash 现在可以通过 *pip install dash* 从 Python 的包管理器中下载——它是完全开源的，并且得到了 MIT 的许可。你可以在这里找到 入门指南 和 GitHub 上的 Dash 代码 。

Sample dashboard from the Dash App Gallery

Dash 使数据科学团队能够专注于数据和模型，同时仍能生产和部署企业就绪型应用。通常需要后端开发团队完成的工作，前端开发人员都可以通过 Dash 完成。

Dash 是一个基于 Python 的框架，主要用于创建包含大量数据可视化的 web 应用程序。顾名思义，Dash 专门用于创建基于 web 的仪表板应用程序。但这是在一些 Python 库的帮助下，通过使用纯 Python 或 R 实现的。

这特别适合任何使用 Python 或 r 语言处理数据的人。Dash 抽象出了构建基于 web 的交互式应用程序所需的所有技术和协议，因此对开发人员来说更加方便。他们目前有一个开源版本和一个企业版本。

我们可以用吸引人的主题和任何类型的图表制作令人敬畏的数据可视化应用程序。美妙之处在于，所有这些都是在纯 Python 或 r 中完成的。此外，当我们使用 Dash 时，您会有更多的灵活性，因为我们可以使用 Python 从头开始创建仪表板。以便您可以创建自己的自定义仪表板。

Dash 基于 Flask、Plotly.js 和 React.js 编写，非常适合构建带有极具吸引力的仪表板的数据可视化应用程序。它特别适合任何使用 Python 处理数据的人。

Dash 应用程序呈现在 web 浏览器中，因此它们可以跨平台和移动使用。Dash 是一个高级框架，它抽象了图形、表格等 UI 组件的低级实现。

以下是使用 Dash 进行数据可视化的更多优点:

能够以可打印的 pdf 或交互式分析 web 应用程序的形式创建报告
自动化报告和监控流式数据流
历史存档、版本控制和状态跟踪，有助于审核和合规性，并创建机构记忆

由于 Dash 与我们之前讨论的两个框架相比是一个相对较新的框架，所以您可以获得关于 Dash 以及如何使用 DashT3(此处为 T5)创建仪表板的总体描述性知识。

比较

与 Dash 和 Grafana 相比，GraphQL 显然走的是一条不同的道路，因为它是关于从你存储的任何地方查询必要的数据。GraphQL 帮助我们得到我们所需要的，不多也不少。当我们考虑像仪表板这样的应用程序时，这对于提高效率非常有用。另一件事是，尽管许多专家和创业公司希望能够说服每个人，GraphQL 不会取代 REST。但这确实是一种简单、高效和有效的查询和操作数据的方式。

Grafana 和 Dash 可以被认为是将您从不同来源收集的数据可视化的方法。在 Grafana 中，您首先通过单击仪表板链接创建一个新的空白 Grafana 仪表板。Grafana 配有各种面板，可以添加到您的仪表板上。除非某种类型的图形与面板相关联，否则面板不是很有用。图表依赖于数据，因此您添加到仪表板的每个面板都将与一个数据源相关联。因此 grafana 将允许您添加预定义的面板和图形，并连接一个数据源。

但是在 Dash 中，我们可以从头开始构建我们自己的非常定制的仪表板。但是在绘制图表和可视化数据时，这真的很容易。我们可以使用数据帧，然后将它们提供给 Dash 中的图形元素。所以 Dash 的可定制性更强，基于 Python。它基于 React 和 Flask，而 Grafana 是用 Go 编程语言(由 Google 创建)和 Node.js 编写的。即使你可能认为使用 Dash 可能需要更多的时间和精力，但如果你熟悉 Python 或 r，这并不困难。

总而言之，我的建议是，如果你需要创建一个仪表板，可以尝试 Grafana 和 Dash。什么是最好的取决于你的要求。但是它们都给你惊人的时尚视觉效果，既有知识性又有吸引力。

欺诈检测的图表分析

原文：https://towardsdatascience.com/graphs-analytics-for-fraud-detection-83ee3af81ec7?source=collection_archive---------14-----------------------

Photo by Ariel Besagar on Unsplash

基于监督学习技术的欺诈检测系统(FDS)将无法跟踪新型欺诈者。由监督和非监督技术组合而成的解决方案将确保 FDS 能够防范常见的欺诈模式和新型欺诈模式。

欺诈检测中的无监督技术通常是异常检测的一种变体。基于图表的方法很有希望通过关联数据分析来检测异常。

图表是金融领域的一种有用的抽象。节点代表实体，而边编码包括交易的关系。图表为理解实体之间的联系提供了一种自然的方式。由于以下原因，图比其他异常检测技术具有显著的优势[1]。

感兴趣的实体是相关和依赖的。对这种关系进行编码对于 FDS 应用程序非常重要。图自然地将节点之间的关系表示为边，这允许更丰富的信息表示。
异常本身的相互关系。例如，一个经历了机会主义欺诈的人可能会告诉她的朋友(图上的相关实体)，他们也可能会这样做。
图对对抗性攻击更具鲁棒性。图表代表长期相关性，即使是高级欺诈者也很难模仿。

这种图表的一个例子如下所示。

Image Credit PGQL

有多种方法可以检测图上的异常。一些常用的方法是基于结构的方法(egonet [2])、基于社区的方法(Autopart [3])和基于关系学习的方法(关系依赖网络[4])。

尽管上面的方法很有希望，但是由于稀疏性的问题，它不能在大型图上扩展。例如，一个现实金融系统中所有实体的图表将有数百万个稀疏连接的节点。即使使用现代图形数据库，这些方法的时间复杂度对于实时欺诈检测系统来说也太高了。

为了克服稀疏性的挑战，同时保留图形表示的优势，网络表示学习(NRL)等新方法越来越受欢迎7。在这种方法中，图嵌入被用来学习大规模网络上顶点的潜在表示。然后，这些表示用于下游异常检测或分类任务。Node2vec [5]就是这样一种方法，它允许“将节点映射到特征的低维空间，最大化保存节点的网络邻域的可能性。”

考虑下面的图像。左图显示了相互关联的账户和交易。左边的图像表示该图在二维空间上的映射。这种转换试图保留图的最重要的优点，同时使图可以被 ML 算法访问。NRL 是无监督的算法，因此通过消除对人工监督的需要，在实际金融网络中具有主要优势。

Image Credit DeepWalk 6

用于异常检测的图形神经网络

来自斯坦福的开源项目 GraphSAGE 是一个基于深度神经网络的 NRL 工具包。该工具包在 Tensorflow 中实现，使其成为开发 FDS 异常检测系统的理想平台。

GraphSAGE 可用于开发实体事务图中每个节点的嵌入。这相当于上面描述的 Node2Vec 方法。一旦这种嵌入可用，这些新特征就被用于使用标准异常检测技术(例如隔离森林)来预测异常[8]。

[1]:https://www . Andrew . CMU . edu/user/lakoglu/pubs/14-dami-graphanomalyservice . pdf

[2]:https://www . cs . CMU . edu/~ abeu tel/CCS 2015 _ tutorial/slides/010 subgraph . pdf

【3】:https://citeseerx.ist.psu.edu/viewdoc/download?doi = 10 . 1 . 1 . 130 . 841&rep = re P1&type = pdf

【4】:https://arxiv.org/abs/1410.7835

【5】:https://cs.stanford.edu/~jure/pubs/node2vec-kdd16.pdf

[8]:https://towards data science . com/outlier-detection-with-isolation-forest-3d 190448 d45e

数据科学的伟大著作

原文：https://towardsdatascience.com/great-books-for-data-science-7a2de76bc612?source=collection_archive---------8-----------------------

10 本让你对数据科学感兴趣的非技术性书籍

承诺教授数据科学的书籍并不缺乏。大多数这些书读起来像大学课本，有大量的技术材料，前面有简短的概念介绍。虽然对这些技术技能的需求很大，但真正优秀的数据科学家也需要概念理解和好奇心的结合，才能充分利用他们的工具。

每本书都以不同的方式介绍了数据科学的概念:有些是关于什么是数据科学的，有些是关于专业数据科学家如何思考的，有些介绍了可能会改变你对世界的看法的观点，还有一本甚至包含了信息的完整历史。

每次我碰到这些书，它都会以我意想不到的方式深刻地影响我的思维。至少我希望这个列表可以作为一个有用的起点:

1.摧毁数学的武器

凯西·奥尼尔

破坏数学的武器是关于当人们在没有对他们的角色和责任有明确概念理解的情况下利用数据科学工具时会出现什么问题。数据科学是一门科学，糟糕的程序、不明确的目标和个人偏见总是会导致完全不可行且往往具有破坏性的结果。

看完这本书，你开始看到无处不在的数据非故意武器化。虽然看到世界上最强大的数据系统实现得如此糟糕可能会引起一些焦虑，但我们没有人能够解决我们未能认识到的问题。

这本书应该被认为是任何想要开发或管理数据系统的人的必读之作。

[## 主要的

《摧毁数学的武器》已经入围国家图书奖！书籍简介:前华尔街…

weaponsofmathdestructionbook.com](https://weaponsofmathdestructionbook.com/)

2.信息

作者:詹姆斯·格雷克

这本书从头开始；信息作为可转移实体的出现。信息追踪数据发展的每一步，从部落的鼓到书面文字，再到今天的大规模数据中心。

就我个人而言，在阅读这本书之前，我并没有对信息的概念提出过深刻的质疑，但仅仅认识到信息在基本生活的存在中所起的作用就会迫使你陷入存在主义危机。读完这本书后，我不得不学习更多关于信息理论的知识，这让我找到了、克劳德·香农以及现代世界的真正基础。与数据科学不完全相关，但绝对值得一读。

* [## 信息:历史，理论，洪水

该信息是如此雄心勃勃，启发性和性感的理论，它将相当于渴望阅读…

around.com](https://around.com/the-information/)

3.每个人都会撒谎

塞思·斯蒂芬斯·达维多维茨

老实说，当我看到这本书的标题时，我觉得它有点令人不快。它显然是为了吸引眼球而创作的，就像一本面向大众的自助书籍。这是一本不应该以封面来评判的书。从第一页开始，它就提供了一些关于尚未探索的良好数据科学的可能性的最有趣的见解。

Seth Stephens-Davidowitz 用他在谷歌担任数据科学家时的例子来说明如何单独使用搜索信息来获得关于我们集体社会的更深层次的潜意识真相。问题不在于人们作为个体会说谎，而是当面对简单的在线搜索和评论中的证据时，我们对自己的总体信念会被提升。

如果数据科学的目标是找到捕捉、建模并利用系统一致性的方法(就像物理学家和工程师到目前为止一直在做的那样)，那么对环境的准确描述就至关重要，这也是本书的真正目的。

在过于理想化的模型、个人偏见和期望之下，隐藏在数据中的是系统的现实。

[## 关于每个人的谎言

然而，我们不再需要依赖人们告诉我们的东西。来自互联网的新数据-信息的痕迹…

sethsd.com](http://sethsd.com/everybodylies/)

4.数据分析

克里斯蒂安·鲁德

当我还是大学生的时候，OkCupid 和 Tinder 是我认为最令人兴奋的两家公司。就包含的基本社会学信息而言，这些在线约会巨头的数据集可能只有脸书能与之匹敌。在这些特定的公司中，使用数据和反馈系统来直接改善客户的结果，同时获得对人类行为模式的洞察，这种潜力令人难以置信。

这本书基本上就是那些见解。

由 OkCupid 的联合创始人兼分析主管 Christian Rudder 撰写的 Dataclysm 是关于数据如何被使用，我们学到了什么以及接下来会发生什么。这本书最棒的一点是使用了可视化。创建直观且易于理解的信息表示是数据科学的一个巨大的(也是经常被忽视的)方面。

这本书通过展示和讲述你可以用数据做什么来激发灵感。

[## 克里斯蒂安·鲁德尔的数据专栏| PenguinRandomHouse.com: Books

NPR 2014 年最佳图书环球邮报 2014 年最佳图书头脑风暴 2014 年最佳科学图书彭博最佳图书…

www.penguinrandomhouse.com](https://www.penguinrandomhouse.com/books/223045/dataclysm-by-christian-rudder/)

5.大数据

维克托·迈尔·舍恩伯格和肯尼斯·尼尔·库基尔

大数据是当今的热门词汇。这本书的作者很清楚这种炒作，但他们并没有把它作为另一种时尚而一笔勾销，而是致力于解释新信息技术创造的合法机会。大数据已经成为陈词滥调，因为人们和企业以如此空灵的方式使用该术语，所以很容易忘记在现实世界的解释和有意义的定义中以某种方式“更大”的“数据”概念。

这本书超越了背景、现有的应用和定义，解释了包含在海量数据集中的不可思议的潜力，以及数据科学家有朝一日将如何开发驱动企业、社会政策和整个国家的系统和自动化。

[## 大数据

欢迎来到“大数据”，即我们可以利用大量数据做以前无法做的事情…

www.big-data-book.com](http://www.big-data-book.com/)

6.赖以生存的算法

布莱恩·克里斯蒂安和汤姆·格里菲斯

《赖以生存的算法》是一本任何人都能从中受益的书。不仅技术概念非常强大，而且这本书还关注在日常生活中导航时每个算法的可访问性和实用性。有 CS 背景的人可能从这本书里收获最多。虽然关于算法、数据结构和离散数学的课程教授如何使用软件工程师的工具，但这本书通过解释工具来自哪里、为什么它们非常有用以及如何开始在日常生活中应用它们，使 cs 变得更加容易理解。

虽然这本书没有教你如何用 C 编写合并排序，但它会给你真实世界的例子，说明图书馆和搜索引擎如何不断地对他们的数据集进行排序，为确保快速搜索所做的妥协，空间和时间复杂性的权衡，以及对最佳搜索和排序的理论限制的直观解释。这都包含在这本相当不可思议的书中的一章里。

每个数据科学家都应该对算法、数据结构和离散数学有透彻的理解，但无论你是否有技术知识，这本书都可以拓展你的思维。

[## 赖以生存的算法:人类决策的计算机科学

一个迷人的探索如何计算机算法可以应用到我们的日常生活中，帮助解决常见的…

algorithmstoliveby.com](http://algorithmstoliveby.com/)

7.信号和噪音

作者奈特·西尔弗

信号与噪声可能是最受欢迎的统计学书籍之一。“噪音中的信号”是数据科学中经常使用的一个比喻:从“噪音”数据集或系统中识别与给定问题的解决方案相关的相关信息“信号”。这个世界充满了干扰，许多最终影响我们决策的事情将我们的注意力从与我们的目标更密切相关的指标上转移开。

例如，Silver 曾经在 saber-metrics 工作，创建与棒球策略相关的有用统计数据。在过去，棒球球探会出去寻找新球员，只凭经验带来的直觉。这些球探关注的是球员的技术，这些技术在他们的相对身材、速度或聪明程度上看起来很明显。在过去的一个世纪里，球队依靠球探来帮助他们赢得比赛，这是基于一种假设，即有经验的球探的直觉是找到最佳球员的关键。在过去的几十年里，专业统计学家和专家已经取代了整个童子军部门。事实证明，侦察兵——以及延伸到棒球队——正被“噪音”引入歧途(依靠侦察兵的直觉，他们只接触到有限的一组观察)。事实证明，在派出自己的队伍时依靠统计判断的队伍在实现他们的目标——赢得比赛方面要好得多。

这只是冰山一角。信号和噪音无缝地流过政治策略、社会动态、赌博、蒙特卡罗方法和博弈论基础(仔细研究最后通牒游戏、重复囚徒困境和公地悲剧的含义)。

在中提出的见解和潜在的心态(作为一只狐狸)信号和噪音是不可或缺的。

[## 内特·西尔弗的《信号与噪音》

《华尔街日报》2012 年最佳十部非虚构作品之一“在精神上与公众的方式没有太大不同…

www.penguinrandomhouse.com](https://www.penguinrandomhouse.com/books/305826/the-signal-and-the-noise-by-nate-silver/9780143125082/)

8.复杂适应系统

约翰·米勒和斯科特·佩奇

复杂适应系统可能是这份名单中最重要的书。这不是最容易的书，也不是最激动人心的书，但是它所假设的观点是令人难以置信的强大。复杂适应系统的概念是，知道组成部分的行为或约束并不允许你对整体的行为做出可操作的预测。在复杂的适应性系统中，有一种涌现的复杂性，使得整体大于部分之和。有无数系统符合这些标准的例子:个体细胞是复杂的适应系统，个体人是复杂的适应系统，个体城市是复杂的适应系统，当然整个生物圈也是复杂的适应系统。

能够将复杂的适应性系统识别为宇宙中无处不在的形式是一回事，但这本书实际上是关于建模和解剖这些系统，以获得它们的内部结构。无论我们是否意识到这一点，当涉及到处理这些复杂系统时，数据科学家都处于第一线，因此随着我们处理的问题变得越来越复杂，拥有识别和建模这些系统的工具只会变得更加重要。

这本书里的概念来得又快又厚，所以值得看看另一个来源来加强理解。我推荐信号和边界，它从稍微不同的角度接近这些相同的想法。

[## 复杂适应系统

这本书提供了复杂的适应性社会系统的第一个清晰的，全面的，和可访问的帐户，由…

press.princeton.edu](https://press.princeton.edu/titles/8429.html)

9.抗碎/增强

作者:纳西姆·尼古拉斯·塔勒布

我选择了《T2》这本抗脆弱的书，因为它是《T4》中我觉得最有影响力的一本书，但是纳西姆·尼古拉斯·塔勒布的《T6》到《T7》系列的四本书中的每一本都有其自身的转变。它们松散地相互引用，但是如果你选择只阅读反脆弱性，你仍然可以很好地充当数据科学家。

Incerto 系列本质上是一篇抨击现代系统如何处理不确定性以及行为和系统背后假设的弱点的长篇大论。它来自一个大胆的经验，仔细的观察和大量的纪律的地方。塔勒布在这个系列中展示了一个世界观，包括动机、背景、理由、反例和轶事，都支持一个中心论点。这是一个完美主义者的作品，完全被现代世界固有的弱点和愚蠢所迷惑。

也许有一天我会单独写 4 篇关于这些书的文章，但是从数据科学的角度来看,反脆弱性是真正引起我共鸣的一篇。抗脆弱性是指当系统暴露在更大的无序中时，它们变得更加强健和有弹性。鉴于这本书被称为抗脆弱(这个概念似乎是尼古拉斯·塔勒布为了解释他的世界观而凭空想出来的)，我将把更详细的定义留给作者。

虽然自然在各个层面都表现出了抗脆弱性，但脆弱性几乎是现代系统的一个内在假设。我在学校学的是物理，最让我感兴趣的是混沌理论或者非线性动力学。当你深入研究物理世界时，似乎所有涌现的秩序都是混乱的。像人体这样错综复杂的有序系统在这些情况下是如何发展的？答案是，任何有序系统的成功传播都是其抗脆弱性的函数。

一旦现代世界最终赶上纳西姆·尼古拉斯·塔勒布，反脆弱性和 Incerto 系列中的其他概念(例如黑天鹅幂律分布，识别随机性或噪声)将对数据科学和工程产生巨大影响。最好先下手为强。

[## 因塞托

《普洛克罗斯特斯之床》是纳西姆·尼古拉斯·塔勒布里程碑式的 Incerto 系列中的一本独立的书，是对不透明性的调查…

www.penguinrandomhouse.com](https://www.penguinrandomhouse.com/series/INO/incerto/)

10.超级预测

菲利普·特洛克和丹·加德纳

数据科学和统计学最重要的应用之一是预测。在一个快速变化的世界中，人们、企业和整个社会都将依赖于准确预测未来事件并做出适当反应的能力。超级预测是关于人们的技能和习惯，他们能够持续地做出令人难以置信的准确预测。它以一个著名的实验为背景介绍了这些策略，在这个实验中，各小组竞相预测未来事件。泰特劳克的团队由来自美国和加拿大的志愿者组成——这些人没有特殊的资格，只有时间和对这个主题的兴趣。尽管缺乏资历，但泰特洛克仅用这些众包预测就能胜过顶级分析公司和中情局。

通过心理学见解和性格研究的结合，泰特洛克揭示了使任何人都能够非常精确和准确地预测未来事件的特质和做法。当我开始阅读这本书时，我对所选案例的有限范围感到有点失望(大部分来自他对志愿者的研究)，但这本书最终出色地揭示和解释了让某人成为优秀预测者的策略。

虽然正式的统计方法保持在最低限度，但允许某人做出可操作的预测的思维模式和启发式方法对任何数据科学家都至关重要。

[## Philip E. Tetlock 和 Dan Gardner 的超级预测

《纽约时报》编辑精选《华盛顿邮报》畅销书《哈德逊书商》最佳商业兴趣书…

www.penguinrandomhouse.com](https://www.penguinrandomhouse.com/books/227815/superforecasting-by-philip-e-tetlock-and-dan-gardner/9780804136716/)*

伟大的开发人员从不停止学习

原文：https://towardsdatascience.com/great-developers-never-stop-learning-77b9ce867eac?source=collection_archive---------4-----------------------

it 专业人员培养持续学习心态的 7 种方法

技术在向前发展，您也应该向前发展！

作为软件工程师、开发人员或架构师，在我们工作的技术和领域中保持最新和相关是至关重要的。我们几年前在大学学习的一些技能已经过时了，所以除非我们掌控自己的学习，否则我们将失去竞争力。此外，我们经常为了项目期限而牺牲学习和发展。

这种短期思维是要付出长期代价的！

尽管在这个瞬息万变的信息技术世界里，不可能跟上所有事情的发展速度，但我们需要选择几个我们感兴趣的领域(无论这些领域是与我们目前的工作相关，还是与我们未来想要的工作相关)，并留出时间来提升技能。

持续学习的第一步是留出时间！

在这篇文章中，我将分享我用来磨砺技能的方法，以及我列表中的其他一些方法。

❶——阅读的艺术

书

我读了很多！无论采用何种方法(传统的还是数字的)，拥有一个庞大的图书馆都是必不可少的，因为它们提供了对相关主题的深刻理解。我避免购买任何特定技术的书籍，因为它们有过期日期:当它们涵盖的技术的新版本发布时，或者不同的做事方法变得更受欢迎时，它们就会过时。相反，我倾向于:

概念性书籍，即涵盖新(或旧)概念、范例或实践的书籍，如行为驱动开发、面向对象设计模式、建模等。
行为学书籍，主题包括项目管理、SDLC、软技能、领导力等，
有影响力的书籍，这是每个开发人员的必读书籍，因为它们在技术对话中经常被提及。一些例子有: 神话中的人月 ， 干净的代码 ， 设计模式:可复用的面向对象软件元素 ， 领域驱动设计 ， 务实的程序员 。

我的奥赖利订阅服务物有所值，因为它提供了大量技术书籍(以及其他媒体，如视频、会议、教程等)的点播服务。虽然我更喜欢纸质书，但快速浏览一本书的能力确实很方便。

博客

阅读博客是我最喜欢的保持最新状态的方法之一:我完全尊重其他开发人员，他们花时间分享他们的个人经验、观点、使用特定技术的成功和失败。一些最好的教程是由业余技术作者编写的，隐藏在谷歌搜索的深处！我使用书签应用(如 Pocket 和 OneNote)将它们保存到我的个人文件夹中，然后在我通勤或工作会议间隙阅读它们。

博客的货币是真实性和信任——贾森·卡拉卡尼斯

只要我们用批判性思维来区分好质量的博客和那些匆忙写的博客(经常是半生不熟的想法甚至误导)，那么博客就能很好地帮助我们在新的领域发展和获得洞察力。

Medium 是技术诀窍文章的好去处，到目前为止，我最喜欢的出版物是**(cc:TDS 团队 ) 。其他博客还有 编码恐怖西雅图数据佬(cc:SeattleDataGuy)DZone等。

推特

在社交媒体上关注技术影响者是另一种保持技术更新的流行方式。带着问题接触他们对于提高我们的学习是至关重要的。他们保持“行业领导者”地位的一个原因是，他们乐于分享资源和经验，而且他们都欢迎想向他们学习的人参与进来。

谁在重塑我们的行业是一个百万美元的问题。我不会在这里给出任何建议，因为我们都有不同的兴趣，而且确实有这么多鼓舞人心的领导者，但你总能看到我以为榜样的。

Photo by Anna Demianenko on Unsplash

❷——从狂热的读者到狂热的作家

在过去的 9 个月里，我开始了自己的博客。起初，这令人望而生畏:我错误地认为只有有独到见解的专家才应该写博客，或者我的观点可能不够好(你说是骗子综合症？)，但我很快意识到，我首先是为自己写作——这是记录自己学习的一种方式，但也为热门主题添加了我的个人印记。

教等于学两次——约瑟夫·儒贝尔

更不用说，这是一个很好的方式来拥有一个在线存在，建立我在某个领域的经验和激情，最重要的是从那些友好阅读和参与我的内容的人那里获得实时反馈！

*🔔 **Did you know?** Based on the [learning pyramid](http://thepeakperformancecenter.com/educational-learning/learning/principles-of-learning/learning-pyramid/), the top 3 ways to retain information, are:
1\. Teaching others   : 90%
2\. Practice by doing : 75%
3\. Group discussions : 50%*

❸——听好了！

播客是我的主要生活方式之一:它们是为多任务处理(做饭、熨衣服、跑腿等)量身定制的，它们的一口大小的格式非常适合我的日常工作。这是我听的一些精选，涵盖了我选择的技术堆栈。Net)以及通用的 I.T .更新: 放牧码 ， 。网石！Hanselminutes软件工程广播编码块本周在理工开发者茶会软件工程日报 。

❹——参加在线课程

不要误解我的意思:我更喜欢亲自动手，而且我确实通过实践学到了很多东西！这是我的第一选择——永远如此！但是我现在有一个年轻的家庭，所以我的个人时间很少。为了开始学习一项新技术，我观看视频:它们提供了理论和实践之间的完美平衡，作为一名视觉学习者，我发现它们真的很有效。我以更快的回放速度观看它们，以最大限度地获取更多的内容。其中一些还提供行业认证。

有无穷无尽的在线课程可以钻研，但这些是我更常用的资源/平台: PluralSight ， Coursera ， 可汗学院 ， edX 。

Photo by Christin Hume on Unsplash

❺——熟能生巧

概念证明(POC)

作为一名架构师，我需要证明技术项目决策的合理性，所以我求助于开发 POC。他们帮助我体验相关技术的挑战或优势，以便提供前瞻性研究，同时我也更擅长评估(不要轻视‘简单’任务需要多长时间来开发)。根据我的其他承诺，我尝试一次专注于一个项目(例如数据科学、ReactJs、大数据等)，并在该领域制作一个原型。看看我的速度，我每年完成 6 到 8 次概念验证。不算太寒酸！

宠物项目

宠物项目允许我们在一个安全的环境中玩耍、实验和学习，因此我们可以将所学应用到真实的项目中。事实上，它们是没有压力的真实项目:没有截止日期，没有技术限制，没有对需求的控制(由于预算原因，大部分需求都被削减了)，没有模式的捷径。我们是老板——我们制定规则！

开放源码

为开源项目做贡献是提升我们的公众形象和实践的一个很好的方式:我们只需找到我们感兴趣的项目，下载源代码，检查代码库，确保我们可以端到端地运行它，调试通过，我们就可以开始工作了。

虽然这是一个我没有积极参与的领域(即没有签入任何更改)，但我体验到的主要好处是，我可以看到最好的开发人员在那里进行编码——这本身就是一种奇妙的学习体验！

❗️点击查看 GitHub 上的趋势。
❗️GitHub 也是一家出色的内容创作服务公司。考虑将这些十大回购标上书签。

*🍭 **Double Whammy:** You can make your Pet Projects Open Source and double up on the benefits described above!*

网上群体

通过在像 Stack Overflow 这样的网站上提问和回答问题，成为一个在线社区的活跃成员，这不仅是一个学习的好机会，也是帮助他人学习的好机会。促进代码和知识共享提供了巨大的成就感。

卡塔斯

形是简单的编码练习，也就是说，它们可以在几分钟内理解，但足够复杂，不会很快解决——这个术语是由《实用程序员》一书的合著者迪夫·托马斯创造的，包含了日本武术中的形的概念。我曾经尝试过这种方法，但是很快就失去了兴趣。我更喜欢看真实的问题和大局，而不是像拼图一样的个人练习。对于有经验的程序员来说，我认为本文中提到的其他方法更加强大。
不过，一个武士道的资源是 kata.softwarecraftsmanship.org。**

❗️如果这种事情让你觉得有趣，也可以看看这些平台: 代码厨师 ， 编码者字节 和 黑客等级 。

黑客马拉松

黑客马拉松是类似短跑的马拉松，允许开发人员和 it 专业人员在软件项目上合作，并创建工作原型、应用程序功能或集成(API)。这些好处已经在 Quora 中很好地列出来了，所以我在这里就不多说了！我从来没有参加过，但这是我想尝试的事情之一！

昨天又新又热的东西今天已经过时了！

❻——利用你的同事网络

虽然从教科书和网上资源中学习有很多好处，但没有什么能比我们与同事的日常互动更好。我很幸运能和一些最好的 C#开发人员一起工作，他们是我灵感和学习的源泉——谢谢大家👍！

我逐渐意识到，没有所谓的愚蠢问题:我们都知道这句老话，但我们仍然认为这是理所当然的！问题实际上是大多数学习的基础，因为它们成为对话的基本起点。

有几个令人信服的理由为什么结对编程也能增强我们的学习，但我发现的最大好处是我们被迫构建我们的思想，让我们在试图向他人解释之前彻底理解自己的想法。
最后，代码评审是通过获得对代码的直接反馈来提高我们知识的最好方式。它们不是关于暴露我们自己的局限性，而是验证我们的想法或者挑战它们。

**💡 **Pro Tip:** If there is someone at work whose coding wisdom and skills you admire, consider asking them if they might mentor you.**

❼ —社交

参加行业活动

参加会议或演示是了解行业发展方向、其他公司正在做什么、哪些技术正在被采用、将技术引入内部的最佳实践等的绝佳方式。与其他开发人员建立关系网也是一个额外的收获——与其他开发人员交换想法是一种保证变得更敏锐和扩大你的专业联系的模式！

这种活动可能会很贵，所以最好是你的公司赞助你。否则，你可以选择在线观看录制的会议，一旦他们发表。下面是我在各自的 YouTube 频道上看的:GOTO Conferences奥莱利思想著作 。

商务化人际关系网

LinkedIn 群组是找到志同道合的专业人士以及了解软件开发领域信息的绝佳方式。

加入专业组织

专业组织(如英国计算机协会)定期举办培训课程，并提供全面的行业新闻、调查、职业信息、工作和活动细节(通常以折扣价)。

这里的问题是我们得到了我们在投入的东西:为了充分收获作为会员提供给我们的内在利益，我们需要投入时间积极参与。

加入本地用户组

开发者都是内向的极客这种想法完全过时了！

加入本地用户组和技术社区是与其他开发者互动的一种简单方式。背景、领域和经历的多样性使这些公司与众不同。不过有一个共同点:每个人都对编程充满热情！因此，每个人都乐于学习和分享他们所知道的！

建立自己的网络

你想在网络方面更进一步吗？以下是一些实用的想法:

在你的组织内建立一个技术社区
创建本地用户组
在会议上做演示或成为主题发言人
举行非正式会议或圆桌会议进行小组技术讨论

成为开发人员的最佳时机！

Photo by Tim Mossholder on Unsplash

技能上去了才能跟上！

我们常常不明白，我们的职业不再是我们所受教育的最终产品，它本身就是对我们的一种教育！如果我们保持学习的习惯，我们很可能会延长我们的寿命，提高我们的就业能力。另一个常见的陷阱是用时间作为不采用持续学习的借口。我们都有时间！事实上，我们都有同样多的时间。区别在于我们选择如何度过它！(↓这是对自己的友情提醒

我在这里列出了一些资源，我利用它们来发展我的专业技能！希望对你也有帮助！

感谢阅读！

我定期在媒体上撰写关于领导力、技术&的数据——如果您想阅读我未来的帖子，请‘关注’我 ！

巨大的期望

原文：https://towardsdatascience.com/great-expectations-ef9059f04995?source=collection_archive---------10-----------------------

“在数据进入某些分析之前，验证你对数据的预期。”

Photo by tian kuan on Unsplash

越来越多与业务相关的决策是基于自动生成的数据做出的。仅仅测试转换源代码的正确性已经不够了。通常从不同的、快速变化的来源编译的数据的正确性也必须被检查…在最坏的情况下，由于数据质量差，可能做出错误的决定。这不一定是一个新的发现，但不幸的是，开源环境中对数据质量检查的工具支持到目前为止还不能令人满意。这篇博客展示了一种所谓的管道测试的方法和 Python 工具，正好填补了这个空白。

什么是管道债务？

数据作为一种原材料在企业所有领域的重要性已经广为人知。从传感器数据到来自所有这些领域的目标数据，数据仓库结构被提供了范围广泛的信息。机器学习模型基于它在训练过程中看到的数据工作。与模型在训练过程中看到的数据相差甚远的数据可能会导致错误的行为。被容易出错的来源或处理步骤篡改的数据肯定会导致错误的结果。从原始数据源到仪表板，数据集通常会经过多个过程(转换、加载、数据模型、机器学习模型)。数据质量的监控和验证在这里经常被忽略。接下来是一个新的开源工具，名为 Great Expectations，用于在运行机器学习模型或使用数字之前验证数据。

数据科学家意识到了这个问题:我们有一个仪表板，上面有来自不同数据源的关键数据。一些关键数字背后是一个机器学习模型，例如用于评分的模型。其中一个关键数字突然发生剧烈变化，以至于不再有意义，或者因为无法再计算该值而变成 NaN。

为什么我需要管道测试？

测试驱动开发已经成为软件开发领域的标准方法。编写单元测试是良好风格的一部分，有助于保持高代码质量和避免错误。

然而，与此同时，复杂性往往不再仅仅表现在代码本身，还表现在数据中。在运行机器学习模型期间发生的意外行为可能实际上反映了真正的异常行为，或者数据可能是错误的。通常，原因是源系统的数据模型发生了未传达的变化。

现在，机器学习模型本身由一个包含几个转换步骤的管道组成:

数据加载(从原始数据源或数据仓库/另一个 DBMS)
清洁和准备
聚集
特征
降维
数据的标准化或缩放

在所有这些步骤中，对数据质量验证工具的需求是显而易见的。与检查可执行代码的单元测试不同(大多在编译或构建/部署时间)，数据测试被称为管道测试，并像批处理一样执行。

对救援寄予厚望！

Python 已经成为机器学习领域的一种开发语言。远大前程工具是一个 Python 包，可以通过 pip 或 conda 安装。

pip install great-expectations
conda install conda-forge::great-expectations

因为其应用范围非常复杂，所以该工具具有非常抽象和通用的结构。虽然这最初可能会导致陡峭的学习曲线，但一旦处理了第一个用例，它就会变平。《远大前程》的开发者已经建立了一个讨论论坛来提供清晰的介绍性例子。还有一个松弛通道用于对话。

安装 Python 包后，每个新项目由以下程序启动:

great-expectations init

这个命令创建了一个远大前程(GE)项目的基本文件夹(GE 行话也叫 DataContext 它后面可以紧跟一个

用 git 管理项目的版本。

初始化调用后远大前程创建的文件夹结构示例

列“ID”不得为空。
列“ID”必须单调递增。
列“ID”必须是整数类型。
“A”列必须始终大于“B”列。
列“B”必须介于 0 和 1000 之间。
….

在初始化过程中，会询问您数据源的位置；这个步骤可以跳过，手动执行。这里可以识别不同的数据源，从本地 CSV、SQLAlchemy 连接器到 Spark 和 Hadoop(例如，HDFS 上的一个分区拼花地板)。

通用电气的基本原则是期望和验证。一旦项目被初始化，数据源被选择，你可以立即开始加载一个批处理(数据摘录)并定义期望。以下是一些期望的例子:

有大量的期望模板可用，包括统计(分布)测试。对于新数据集中期望的探索性开发，文件夹great _ expectations/notebooks/中提供了各种连接器(csv、SQL、pySpark)的笔记本示例。

一旦定义了一组期望值，就需要用新的数据批次来验证期望值(例如，在最后一天的新数据到达之后)。

在验证过程中，也可以将期望变量参数化。假设您有一个包含带有 unixtime 值的 time 列的流数据源。数据被持久化，并且每天一次验证前一天的一批数据。通过设置期望值，可以很容易地验证时间戳应该在一天的界限内的事实

batch.expect_column_values_to_be_between('timestamp', {'$PARAMETER': 'start_time'}, {'$PARAMETER': 'end_time'})

在验证过程中

batch.validate(evaluation_parameters={'start_time': unixtime_start, 'end_time': unixtime_end})

这个工具的一个很好的特性是 DataDocs，它是在管道测试过程中创建和维护的。在那里，GE 项目跟踪的数据源、期望和验证的目录以透明的网站格式存储(也在 GE 文件夹中，在great _ expectations/uncommitted/data _ docs下)并被版本化。通过这种方式，我们总是能够发现哪些数据源被监控，哪些测试(期望)被定义，以及测试是否有正面或负面的结果。

我们不想提交到 GitHub 存储库中的配置密钥可以很容易地保存在 uncommitted 文件夹中的 yml 文件中，这样密码和访问密钥可以安全地保存。

数据上下文的生命周期和版本管理

一旦我们获得了一组期望，在将来使用这些期望来验证数据源，我们就保存了我们的期望集。它作为 JSON 文件存储在项目文件夹中。现在是触发 git commit 来保存版本管理下的期望套件的好时机。

远大前程并不打算成为一个管道自动化工具(管道执行)，但可以集成为一个工具(气流、 Oozie 、…)，以便以定时方式(例如每天)执行验证。

一旦理解了通用电气的运营模式，就可以很容易地对其进行扩展。可以定义额外的期望，或者可以集成新的数据源。为了识别影响数据质量的任何中间步骤，在同一数据源通过处理管道的过程中反复监视它也是有意义的。

可以在下面的 GitHub 存储库中研究一个使用数据源加载数据库的端到端示例。在那里，每天新生成的 CSV 首先作为原始数据进行验证，然后在加载到 MySQL 数据库后再次进行验证。

结论

Great Expectations 是一个快速发展的工具，可以广泛用于确保机器学习模型运行的数据质量。该工具的开发特别重视提供尽可能通用的框架，并为用户提供许多界面，使他们能够根据自己的项目适应巨大的期望，并根据自己的需要进行扩展。例如，可用的操作符可以在验证后自动生成时差通知。该模板和其他模板可用于设计与其他系统的接口。

开发速度和像 Databricks 这样的主要参与者在会议上推广这个工具表明了这个工具的重要性和质量。同时，非常需要借助现代工具将数据质量测试带入现代数据源和开发方法的世界。因此，了解 Great Expectations 并将其集成到您自己的数据管道中是值得的；这个工具肯定会陪伴我们更久。

最初发表于T5【https://www.btelligent.com】。

云中的橄榄球:与 GCP 一起黑足球

原文：https://towardsdatascience.com/gridiron-in-the-cloud-hacking-on-football-with-gcp-eab7b9404bf2?source=collection_archive---------21-----------------------

如果你有一周的时间尽可能多地利用谷歌云，你可能会构建出什么？

你能在周四足球之夜前完成吗？

这就是一群前端软件工程师和 UXers 试图找到的答案。虽然我们每个人都定期开发不同的谷歌云产品，但我们更广泛的团队会在年底留出一个制作周来试验不同的产品，测试新的工程和 UX 技能，与不同的同事合作，并通常使用 GCP(阅读:没有内部工具)来破解一个项目。

这个想法似乎很简单:提出一个机器学习模型，可以在实时 UI 中预测足球比赛的下一场比赛。充其量，我们会发明有史以来最伟大的体育酒吧应用程序(我们最初的目标是每次打电话都有 90%的准确率和 90%的信心——这表明我们不是专业的数据科学家)。在最坏的情况下，我们会对预测建模的挑战产生更大的共鸣。实际上，我们可能会在中间的某个地方着陆——也许不是最好的模型，但至少是能在实时 UI 中提供一些有价值的东西的模型。

实际上，这相当复杂。我们需要创建一个摄取和 ETL 管道，构建一个功能性的数据仓库，训练和服务一个模型，并几乎同时开发一个实时 UI，以便在一周内完成。幸运的是，每个人都被吸引到不同的项目领域，这是基于他们最有技能或精力做出贡献的领域。有了这样分配的团队，我们有大约四天的时间为 12 月 13 日堪萨斯城酋长队和洛杉矶充电器队之间的比赛做好准备。

如果你只想知道我们是否达到了这个大胆的高门槛，那么惊讶吧:我们没有。但是，如果你想知道如何在一周内建立一个具有实时预测 UI 的机器学习模型(以及在这个过程中可能遇到的一些绊脚石)，那么让我们开始吧。

摄取和探索

鉴于之前的一些的例子，我们对如何开始有了一个的大致想法。在一切开始之前，我们需要数据。我们使用 Sportradar 的 API 来获取 2011 年至 2018 年 NFL 常规赛的基本数据集，结果是 1，529 场比赛，或 255，834 场比赛(由于不一致，我们最终没有在我们的模型中使用 2013 年和 2014 年的数据)。虽然这是一个非常小的数据集，但它足以让我们对一个新生的模型进行训练和测试。

为了将每场比赛的详细数据存储到谷歌云存储(GCS)中，我们使用了 bash 脚本——主要是因为它的编写和执行速度非常快。GCS 成为我们其余工作的主要参考，让我们可以在附近存储原始数据，同时也让我们能够转向 BigQuery 进行探索性分析，并转向云机器学习引擎(CMLE)进行建模(这反过来会馈入 Firestore，即我们 UI 的主干)。

但是原始的逐场播放数据很难查询和建模，所以我们建立了一个数据流作业，将数据从非结构化的 JSON 格式转换为结构化的 CSV 文件，使我们能够提取和开发感兴趣的功能。虽然 Dataflow 使这个过程可重复并且相当快，但它针对比我们遇到的大得多的数据问题进行了优化。我们并没有真正处理它的规模，事后我们意识到这项工作实际上在本地机器上会更快。

从 GCS，我们使用 bq load 作业将所有内容导入 BigQuery，该作业在大约 5 秒钟的时间内将 1，500 个文件导入 BigQuery。(虽然可以直接从数据流加载，但它不允许我们使用递归通配符路径来匹配 bucket 中的特定模式，因此是 bq load。)BigQuery 允许我们的团队在开发模型的同时进行一些探索性的分析。

因为我们最感兴趣的是找到跑位和传球的模式，所以我们大部分的 BigQuery 工作都围绕着更好地理解这些比赛。例如，考虑到公认的智慧，NFL 近年来趋向于一个及格的比赛，我们想知道我们是否应该权衡我们的模型来解释这种转变。我们的数据显示，虽然有所转变，但取决于你如何看待它，这是相当渐进的(在所有的快攻和传球比赛中，传球的百分比从 46%增长到 48%)。也就是说，不同的车队和不同的年份会有很大的不同。

Percent of all rush and pass plays across the NFL since 2011

Ratio of rushes to passes broken out by team

此外，我们发现，虽然完成的传球越来越长(这是考虑传球趋势的一种方式)，但跑动也是如此——这些指标和也因团队和年份而异。

Total rush yardage and pass yardage across the NFL

Total pass yardage by team

由于我们没有时间为每个团队训练和创建 32 个独特的模型(或通过会议进行调查)，我们决定不对模型进行加权以通过测试。

建模和细化

随着我们的渠道建立，我们可以开始建立我们的模型。虽然有多种工具可用于构建模型，但处理模型的团队成员对 TensorFlow 最有经验，也最熟悉。方便的是，TensorFlow 比其他建模工具(例如 BQML)有更少的延迟，这非常适合我们的实时目的。

预处理:我们首先从 Sportradar API 中提取 CSV 数据，并使用 tf 对其进行预处理。变换。使用 tf。Transform 让我们编写一个数据流作业，它能够针对所有数字数据对我们的整个数据集进行规范化，并为我们的分类数据创建预定义的词汇表(例如，某部剧中当前的进攻/防守团队)。在规范化数据之后，我们的数据流作业将那些预处理过的例子写入 TFRecords 中，这样它们就可以在模型训练期间被轻松有效地读取。

训练:一旦我们预处理了所有的数据，我们就开始使用张量流估值器训练模型。TensorFlow estimator 库附带了一个预构建的线性分类器,我们可以在数据集上对其进行训练。鉴于我们使用线性模型和 TensorFlow 估值器内置的分布式训练，我们知道我们的训练可以轻松扩展到指数级更多的示例。

我们在很大程度上根据 CloudML census estimator 代码样本调整了我们的培训计划。使用固定估算器使得调整样本代码以适应我们的需求变得特别容易(当您试图赶时间时，这是一个不错的好处)。

测试:除了针对 30%的随机数据测试模型的常见做法之外，我们还在逐场播放的数据上创建了一个模拟游戏重放功能。当我们检查以确保模型没有过度拟合时(我们的验证准确性与训练准确性跟踪得很好)，我们还通过使用模型从未见过的模拟实时回放来确认这些怀疑。通过以这种方式测试模型，我们可以验证它确实具有预测准确性，并且不会过度拟合训练数据。

Refine: 在建立并运行模型之后，我们回到 BigQuery，使用它作为评估工具来帮助我们确定向我们的模型添加(并帮助改进)什么新特性。我们从 17 个基线特征开始(如比赛类型、场地位置、进攻和防守团队)，但根据我们想问的数据问题类型创建了另外 9 个(并删除了 3 个没有帮助的)。23 个特征并不算多——其他创建预测游戏模型的尝试已经使用了 100 多个特征——但鉴于周四晚上即将开始，23 个似乎可以作为概念验证。一个特别的衍生特征，我们称之为 SERA(情景预期冲刺尝试，或给定一个特定的倒球和码到第一倒球的球队持球的可能性)，后来形成了我们天真模型的基础，并帮助我们衡量我们模型的技巧性。

为了给我们的模特上菜，我们靠在 tf 上。再次转变。这确保了在推理过程中接收到的任何输入都将以与我们的训练数据完全相同的方式进行预处理，从而减轻了来自数据预处理差异的任何训练服务偏差。

Machine learning architecture

UI 开发

如果一个模型预测了一场比赛，但没有用户界面让你实时查看，它会发出声音吗？

我们不想找出答案，这意味着我们需要构建与数据管道和模型并行的 UI。在我们对足球预测比赛模型的简短研究中，我们发现了几个复杂机器学习的例子，但没有一个试图实时预测比赛，或试图连接到图形用户界面。根据你自己对你最喜欢的球队的了解(或渴望)做出纸上谈兵的预测可能很有趣，但我们想实际上 看看一个训练有素的模型在整个比赛过程中表现如何。

我们运行了一个简短的设计 sprint 来决定在这样的 UI 中什么信息可能是有趣和有用的，以及如何呈现它。除了包括游戏预测和我们的模型对它的信心得分，我们还想包括 drive 在游戏中的所有先前游戏，以及我们对那些游戏的预测——包括信心和准确性。最后，我们希望包括一个图表，它将更新我们对每场比赛准确性的累积预测，以及对比赛的总信心和准确性。

Design iteration

为此，我们首先创建了一个 Kubernetes 容器来订阅 Sportradar API，这样它就可以将实时的、原始的比赛数据推送到 Firestore 集合中。一个云函数将每个原始剧本标准化为我们预期的结构，并将其输入 CMLE，然后将一个预测写回到第二个预测集合中。当下一次播放发生时，另一个云函数将其与所做的预测进行匹配，然后更新播放集合中的数据。然后，UI 显示预测集合中最新文档的下一次播放的模型预测，以及逐播放集合中所有以前的播放和预测。

在这一周里，我们的模拟游戏回放功能承担了模型测试和 UI 测试的双重任务——我们严重依赖它来检查没有游戏时 UI 的行为。通过模拟游戏回放测试 UI 的功能，我们为周四晚上做好了准备。

Real-time UI architecture

把它放在一起

尽管在测试场景中让模型和 UI 一起工作很有趣，但在周四晚上的足球比赛中运行我们的系统却带来了另一个层次的悬念。在征用了一些投影屏幕后(并不是说晚上 8 点在办公室有很大的阻力)，我们并排排队等候游戏和我们的应用程序。

追随模特可能比游戏更令人兴奋(而且这是一个令人兴奋的游戏！).在游戏过程中，我们的模型实时执行的准确率为 66%，尽管我们第二天用一些更新的功能重新运行了模型，准确率提高到了 73%。为了了解这是否有任何好处，我们检查了我们的天真模型(它严格依赖于 NFL 在过去七年的比赛历史，给定了一次倒地和一次倒地的距离)在那场比赛中的表现——它只有 55.8%。

设计实时 UI 的一个怪癖是确定“实时”对观众的实际意义:我们需要协调 Sportradar API、电视广播和我们这边的任何系统处理之间的延迟。假设我们正在构建一个无服务器 UI，我们不会因为服务器延迟或通知延迟而损失太多时间。为了弥补这一差异(并防止观众在当前播放尚未发生或甚至超过 40 秒播放时钟阈值时看到对未来播放的预测)，我们在从 Firestore 接收更新和更新底层数据之间给了 UI 一个简短的填充。(我们通过轮换一些常见的 play 调用来弥补延迟，这样就不会看起来 UI 被冻结了。)

我们的最终模型以 70.1%的总体准确度和 0.651 的平均损失净出。对于一周的工作来说还不错。

赛季后的

鉴于缺乏无限的时间和资源，我们没有达到 90%的信心和 90%的准确性——这些数字肯定会让任何有经验的数据科学家感到惊讶。但我们确实构建了一个功能性的端到端系统，在一个实时 UI 中提供和评估播放预测，使用的是无服务器云环境和普遍可用的云产品。这需要不同技能的团队来实现。

尽管如此，这个模型总是可以改进的，而且有无数的方向可以探索:

更多更好的功能 : 23 只是可能性的冰山一角。如果有足够的时间，你可以围绕赛季趋势和比赛趋势构建功能，更不用说天气条件，主客场因素，以及围绕时间和比分的更细粒度的功能。(这还是在观察个别球员或教练的信号之前。)
更多更好的数据:我们只用了常规赛；季后赛完全是另一个野兽。
更多更好的模型:足球队是高度特殊的——为球员和教练创造和控制不同的模型会非常有帮助。
更多更好的模型 ing :我们对张量流的了解是有限的。深入研究 TensorFlow 模型分析工具，了解某些特性如何影响我们的模型，是我们改进系统的下一步工作的重中之重。此外，我们仅使用线性分类器运行该模型。

一个结合了实时用户界面的更好的模型不仅会给粉丝带来乐趣，而且会对游戏中的决策产生真正的影响。如果一个模型最终采用了比人类在叫牌时间内所能处理的更复杂的技术特征，你可以想象一个场景，体育评论员可以利用这些信息来改善他们对比赛的报道和洞察力。你可以想象一个场景，四分卫或进攻协调人可能会利用这些知识来制定他们的策略——进行可预测的比赛或惊喜。你甚至可以想象一个与足球完全无关的场景。

只是一些思考的食粮，让你在周日那些史诗般的商业广告时段保持忙碌。

感谢奥斯汀·博格斯特伦、克里·程、约瑟夫·罗林斯、易卜拉欣·阿卜杜勒-萨布尔、艾维·帕吉特、阿雅·达马里、尼古拉斯·凯尔曼、阿萨弗·阿农、埃里克·施密特。

GridsearchCV:打开黑盒

原文：https://towardsdatascience.com/gridsearchcv-cracking-open-the-black-box-ae3ce40ac76d?source=collection_archive---------43-----------------------

Photo by Nikita Kachanovsky on Unsplash

当我第一次开始使用 GridSearchCV 时，我感到困扰的是，在我看来，我们似乎接受了网格搜索抛出的最佳超参数。然后，我们从那里开始工作，更好地调整超参数，以获得最佳结果。我想一定有更好的方法。

然后我注意到了 cv_results 选项，我很兴奋有一种方法可以查看网格搜索所做的一切。我兴奋地把它打印出来，看到了这个:

我非常失望。直到我意识到似乎所有的东西都在字典里，作为每个部分的键/值。我立即试着把它加载到一个熊猫的数据框架中，成功了！

正如你在上面看到的，把所有东西都放在那里仍然没有帮助。我开始研究 dataframe，并意识到 best_params 函数打印具有最高平均测试分数的超参数。

这并不总是我们想要的。在我从事这项工作的时间里，我看到过由于各种不同的原因，最高的结果不是很好的时候。其中之一是过度拟合，如果测试和训练分数比其他组合彼此相差更远，尽管也可能有其他原因。

熊猫的伟大之处在于，我们一直在使用它，并且可以操纵数据来帮助我们找到我们正在寻找的东西。我开始计算训练和测试分数之间的差异，并按此排序。但这可能会导致最高分出现负差异，或者测试和训练分数非常低。

因此，我根据训练和测试分数之间的差异对测试分数进行加权，并按此降序排序。

在这种情况下，您将看到顶部结果与网格搜索中的 best_params 选项相同。这种情况有时确实会发生，但总的来说，这会产生更好的结果。在这种情况下，当根据我的测试数据检查时，这些是带有顶级参数的结果:

这比使用默认超级参数的简单随机森林更糟糕，如下所示:

我尝试了加权分数的第二行参数，得到了与基线随机森林相似的结果:

对于这种情况，随机森林似乎不会给出很好的结果。我在这里只是演示如何做到这一点。

没有一个答案，有时根据你的 EDA，你会觉得在一个随机的森林里你需要更多的树。所以你可以选择分数高的超参数。有时，你可以尝试几种不同的组合，都取得了不错的成绩。这适用于任何可以使用 GridSearch 的模型。

你可以根据你想要的任何东西来决定，最重要的是你可以根据数据来决定，而不是在不理解的情况下得出给定的结果。

我期待着在评论中看到伟大的想法，这样我们就可以在继续寻找我们模型的最佳超参数时使用它们。

这个演示的代码在这里:
https://github . com/lrai chik/GridsearchCV _ cracking _ open _ the _ black _ box

声明:我没有做任何 EDA，因为我这样做只是为了演示的目的。

我欢迎评论中的任何反馈和想法。

探索量子计算——好奇者的古怪指南

原文：https://towardsdatascience.com/grokking-quantum-computing-a-quirky-guide-for-curious-people-8cea6eb67803?source=collection_archive---------8-----------------------

我们承认吧，量子粒子很奇怪。各种违反直觉的现象，如叠加、纠缠，简直就是激发灵感的好科幻小说。除了错综复杂，量子力学已被证明是最成功的理论！

没有量子物理学，我们就不会有现代计算机或智能手机。

说什么？

现在，你可能会想:

等等，我以为量子力学是用于量子计算的！

是的，你说得对；量子计算的计算逻辑利用了这些原理，而经典计算机却没有。这并不意味着构成这些经典计算机的组件不遵守上述原则。🙄

想一想——在现代计算机中你需要半导体，而整个固态物理学的理论都是建立在量子力学的基础上的。

这篇文章聚焦于量子计算，并且是在假设你对量子奇异性有一些高中水平的熟悉的情况下写的！

为什么我们需要量子 computers❓

1965 年，英特尔公司的联合创始人戈登·摩尔声称，集成电路上每平方英寸的晶体管数量每年翻一番，并预言这一趋势将继续下去！

根据摩尔定律，计算机一天比一天小，一天比一天快。单个晶体管的尺寸正在缩小到几个原子的大小，但代价来了——q量子隧道效应。

由于晶体管充当电子流动的开关，它可以与其他电子元件一起用于构建驱动经典计算的逻辑门。但是，如果这些晶体管变得足够小，电子可能会从一边跳到另一边，从而阻碍任何逻辑实现。

那么，解决方案是什么？

量子计算——虽然不完全是你想的那样！

According to IBM, quantum computers are radically different with the potential to solve some problems beyond the reach of today’s classical computers in areas like drug discovery, financial services, and artificial intelligence.

你看，量子计算机不是经典计算机的替代品。相反，这些计算机将能够以相当高的精确度解决某些优化或基于加密的问题，这是我们当前的经典计算机无法解决的。

在经典计算机中，每一个逻辑运算最终都归结为翻转和排列内存中的位。

在这里，经典位由 1 和 0 组成，逻辑上代表-真和假，开和关，阴和阳…你明白了吧！

但是量子比特是如何工作的呢？🤔

量子比特简介

A Q ubit 是对应单位状态机的最简单的量子系统。它是“0”状态和“1”状态的复杂线性组合。

让我们用振幅⟨α、β⟩来表示一个量子位，如上所示，使得α和β是复数，并且‖α‖+β‖= 1。如果α和β只是实数，那么相应的量子位将代表一个圆形状态机，而不是球形状态机。

“一个量子位的值怎么可能既不是 0 也不是 1，”

叠加。

我猜你对薛定谔的猫这个著名的思想实验很熟悉。它处理的是这样一个想法——假设盒子里有一只猫，有 50%的机会活着，有 50%的机会死了。所以，除非你往盒子里面看，否则你会认为这只猫既没死也没活！它是两种不同状态的叠加。

这太荒谬了。其实猫不是死了就是活了。不可能两者兼得。但是你不打开盒子是不会知道的。你看叠加原理不适用于日常物体。

你仍然可以持有类似的论点——如果量子位也处于 0 或 1 的确定状态，会怎么样？也许只是在我们测量之前无法判断而已！

在这种情况下，你说对了一部分——在测量之前，我们不可能知道量子位的确切值。但我们确实从实验中知道，量子位实际上处于叠加状态，当我们测量它时，它有α几率坍缩为 0，β几率坍缩为 1。

我知道这令人困惑，但请耐心听我说…😣

你看，量子计算机使用这种叠加原理，因为它可以用ψ表示的薛定谔波动方程进行数学描述。为了操纵这些量子态来驱动计算，已经开发了几种算法。

A qubit just corresponds to a unit vector in two-dimensional Hilbert space!

当我们谈到一个量子比特以一定的概率坍缩到特定的状态时，你可能会认为这和扔一个公平的硬币或者扔一个平衡的骰子是一样的。很有可能你会选择不读这篇文章而不完成它。这些是经典概率的情况。

我们只能说这些随机实验的结果无法确定，因为我们不知道与之相关的所有隐藏变量。如果我们在投掷时知道了硬币的转数、空气阻力、初始状态、硬币的重量、施加的扭矩和所有其他可能的隐藏变量，我们肯定可以以很高的准确度确定硬币投掷的结果。

然而，量子随机性是真正的随机。在测量之前我们不会联想到经典概率。当我们说一个量子位是 0 和 1 的叠加时，我们并不意味着它要么是 0 要么是 1——相反，我们谈论的是代表这些单独状态的振幅的线性组合。

让我们问问 questions❗️

在我们继续之前，让我澄清一些可能一直萦绕在你脑海中的疑问——

我们如何在物理上表示一个量子位？

理论上，我们可以利用电子的自旋，光子的极化，甚至可以利用原子、分子或离子。

但是，我们怎样才能实际实施呢？

像谷歌和 IBM 这样的科技巨头使用超导回路，其中振荡电流被微波信号激发成叠加态。为了使这些超导材料工作，使用稀释制冷机将工作温度冷却到大约 0.015 开尔文，稀释制冷机是一种低温设备。

另一方面，像英特尔这样的公司使用硅量子点，而像 IonQ 这样的初创公司使用俘获离子。

那么，我们如何操作这些量子位呢？

我们使用矩阵运算子来模拟某些装置的效应，这些装置在不测量或破坏量子位元的情况下，操控量子位元的自旋或极化。有几个重要的矩阵算符只在量子环境中有意义。

嗯，这些矩阵算符是什么！

先说一个——哈达玛门。它被表示为“H ”,它作用于单个量子位，如 0 或 1，并将其置于完全相等的叠加状态——

这意味着测量量子位将有相等的概率坍缩回任一基态。

我猜你对经典逻辑门很熟悉。同样，还有各种各样的其他量子门，如 Deutsch，Pauli-X，等等…

与经典逻辑门不同，所有量子门都是可逆的。这意味着给定操作符和输出，就可以推导出相应的输入。

什么是量子 Computing❓

请记住，我们的目标是实现控制量子态的能力，这样就有可能给计算机编程。量子计算背后的想法是在一定数量的量子位上配置这些不同的量子逻辑门。

到目前为止，我们已经讨论了单个量子位的量子态表现。然而，在量子计算机中，正在使用多个量子位。在那种情况下，叠加只是等式的一面——我们需要量子纠缠的性质！

Einstein’s “spooky action at a distance”!

通俗地说，当两个或两个以上量子比特的状态不能相互独立描述时，就产生了量子纠缠。因此，测量一个纠缠的量子位也会瞬间瓦解其他纠缠的量子位，不管它们之间的空间距离有多远！

现在，在你对量子隐形传态和超光速旅行大肆宣传之前，让我告诉你——即使是纠缠也不能让经典信息的速度超过光速。

那么这一切对量子计算意味着什么？

量子计算实现了叠加和纠缠以及量子干涉的原理。首先，你激活量子位，使其成为所有可能配置的叠加，然后通过对每个状态施加相位，将问题编码到你的量子计算机中。接下来，使用量子干涉来校准一些振幅，而消除其他振幅来优化正确答案。

在这里，1 个量子位可以是 2 个状态的叠加，2 个量子位可以是 2 个状态的叠加，同样，用 300 个量子位，你可以探索 2 个⁰⁰可能的状态——这远远超过了可观测宇宙中的原子数量！😯

“我们怎么可能跟踪所有这些状态，”

你看这不是经典计算。通过纠缠这些量子位，它们的状态保持相关。对于经典计算机，你必须一次探索两个⁰⁰比特的可能性才能找到相关的答案，但在量子计算机中，你只需要跟踪 300 个量子比特！

需要指数级扩展的问题非常适合量子计算。这类问题包括——质因数分解、旅行推销员、模拟化学反应中的化合物等等。

如果输入足够大，一台经典计算机将花费整个宇宙的生命来解决这样的问题！

量子计算背后的挑战

量子计算不全是阳光和彩虹。所以，不要指望量子笔记本电脑会很快运行 PUBG-Q，在那里你的角色同时活着和死去！

当你不断增加更多的门或者增加量子位的数量来实现某些算法时，系统会变得非常不稳定。因此，由于被称为量子退相干的现象，错误率增加。它负责通过无意的相互作用将量子位的量子本质泄露到环境中。

这意味着量子位可以在计算过程中坍缩回经典状态。

2013 年实现了最长的相干长度。量子位持续了超过 39 分钟；然而，他们只有 81%的忠实率。第二年，尽管相干长度减少到了 30 秒，但保真度却提高到了 99.99%以上。🎉

这个想法是建立相干长度足以计算数学问题的系统。为了增加相干长度和构建容错量子计算机，我们需要一个有用的度量来测量两个维度上的量子能力——量子位的数量和错误率。这个度量被称为量子数。

Source: IBM

自从 1995 年量子纠错问世以来，许多新的技术和方法被提出。为了使量子比特稳定并减轻退相干，纠缠起着重要的作用。

然而，量子退相干仍然是研究人员和工程师实现量子优势的最大障碍之一。

迈向量子霸权的竞赛

从本质上说，这是一个里程碑，量子计算机能够执行经典计算机几乎不可能完成的计算。

上个月，谷歌声称他们已经实现了量子计算的这个长期目标。在它被撤下之前，NASA 网站上有一份简短的文件对它进行了描述。这似乎是由谷歌和量子人工智能实验室合作的科学家撰写的早期草案，其中包括美国宇航局的研究人员。

这篇论文描述了如何使用 53 个量子位来确定随机选择的量子电路的输出。实验中涉及的干涉图案是由谷歌的 Sycamore 量子处理器通过在量子电路上进行一百万次测量而确定的，耗时约 200 秒。作者还声称，最先进的经典超级计算机将需要大约 10，000 年来计算相同的数据。

在论文中，作者还指出—

据我们所知，这个实验标志着只能在量子处理器上进行的第一次计算。

然而，这一信息的可信度是一个有争议的话题。自论文消失以来，谷歌和美国宇航局都拒绝回答有关论文的问题。所以，我建议你对此半信半疑！

但无论如何，量子计算的未来就在眼前。现在正在发生。在量子计算机变得强大到足以使用 Shor 算法破解 RSA 加密的世界中，它还可以用于建立预测市场行为的复杂模型，加速供应链物流，使数据分析速度成倍提高，并推动药物和化学开发的巨大研究。

恭喜你！你已经走到这一步了…🏁我希望我能够解释量子计算的基本原理。

如果你想进一步探索这个令人兴奋的话题，可以从阅读《量子计算机编程》这本书开始。
如果你想在一台真正的量子计算机上获得实际操作的体验，可以试试这个平台— IBM Q Experience

感谢您阅读本文！

深度神经网络的组稀疏正则化

原文：https://towardsdatascience.com/group-sparse-regularization-for-deep-neural-networks-6a70ecb1561c?source=collection_archive---------21-----------------------

如何自动修剪神经网络中的节点？

深度神经网络的分组稀疏正则化论文摘要

动机

随着硬件技术的进步和成本的降低，训练大型神经网络变得更加容易。正因为如此，即使是简单的任务也需要大型网络。网络中有太多的层会导致许多问题，

过度拟合
在部署到生产/移动/ IOT 设备之前，需要进行网络修剪

然后就是特征选择的问题。特征选择是搜索对建模很重要的所有特征的子集的过程。这通常在建模开始前作为独立管道完成。

稀疏群正则化(SGR)解决了这三个问题

优化神经网络的权重
优化每个隐藏层的神经元数量
特征选择

并创建了一个单一流程/流水线来解决所有这些问题。在神经网络中，特征选择可以被认为是对输入层节点的修剪，这就是在稀疏群正则化中如何处理它。

神经网络中的稀疏性

如果一个神经元的所有输入和输出权重都是 0，那么该节点可以被移除。

Figure 1

在上面的人工神经网络图像中，红色连接的权重为零。由于来自输入功能 X2 的所有连接为零，因此该功能可以移除。类似地，对于节点 H3，由于所有输出权重都是零，因此该节点也可以被移除。这是在节点和特征的修剪中使用的稀疏性的思想。

如何实现稀疏性？

L1 正则化(Lasso)是实现权重稀疏性的一种方式。在这种技术中，权重的绝对值之和在训练期间被罚。

New Cost = Cost + λ ||w||

由于权重因其绝对大小而受到惩罚，因此可以使用 L1 正则化来实现稀疏性。

点击此处了解更多关于 L1 和 L2 正规化的信息。

然而，单独使用 L1(套索)不能保证系统的稀疏性，使用它可以删除节点。为了删除一个节点，该节点的所有传出权重都应该为零。在非结构化的情况下，L1 可以导致不同类型的稀疏性。见下图

Figure 2 : Sparse connection with L1

这里 2 个权重为零，但是没有一个节点可以被移除。因此，L1 独自不能帮助修剪。这就是稀疏群正则化发挥作用的地方。

稀疏群正则化

Figure 3. Schematic representation of a group LASSO regularization with two inputs (top), two hidden neurons with biases (middle), and one output (bottom). We have three groups of connections. Green: input groups; blue: hidden groups; red: bias groups. Image source [1]

为了获得用于修剪的结构化稀疏度，我们需要对来自每个神经元的传出连接进行分组，并强制它们为零。为此，考虑 3 种不同类型的重量组，

输入组 Gin :一个元素 gi ∈ Gin， i = 1，.。。d 是从第 I 个输入神经元到网络的所有输出连接的向量。在上图(图 3)中，有两个输入组(绿色)。x1 的输入组将包含从 x1 到隐藏层的所有权重。输入组用于特征选择。
隐藏组: Gh :在这种情况下，单个元素 g ∈ Gh 对应于网络隐藏层中某个神经元的所有传出连接的向量。在图 3 中，有两个输出组(与隐藏节点的数量相同)。
偏差组: Gb :这些是与网络上的偏差相对应的一维组(标量)。也可以使用包含所有偏差变量的单个组，而不是将每个偏差视为一个单独的组。

总组数 G 为

稀疏组正则化可以写成，

其中 |g| 表示向量 g 的维数，它确保每个组得到均匀的加权。这里使用每组的 L2 标准。因为 L2 范数不能像 L1 那样产生稀疏性，所以进行阈值化步骤以将低权重转换为零。

这个公式对于获得高水平的稀疏性来说仍然是次优的(即使在阈值化之后)。为了加强这一点，使用了套索和稀疏组惩罚的组合。稀疏群套索惩罚的定义是，

其中第二项是权重的 L1 范数。

Figure 4 : Comparison between Lasso, group Lasso, and sparse group Lasso applied to a single weight matrix. The removed connections are represented in gray. Image source [1]

图 4 显示了本博客中讨论的三种正则化惩罚之间的比较。2×5 矩阵表示 2 维输入层和 5 维输出层之间的权重矩阵。

套索惩罚(l1)在不考虑节点级别的情况下移除连接。在图像中，它导致了 40%的连接稀疏度。输出层中的第二个神经元(5 dim)可以被移除，因为来自两个输入节点的所有传入连接都是灰色的(参见图 4 中 Lasso 中的列 2)。

在组 Lasso 中(在稀疏组正则化中的阈值化之后)，来自第二神经元输入层的所有连接为零，因此可以被移除。

稀疏群套索惩罚结合了前两个公式的优点。来自输出层的两个节点(第 2 和第 5)可以被移除，并且第二输入神经元也可以被移除。连接数减少到 70%,从而形成一个非常紧凑的网络。

参考

[1] Simone Scardapane，Amir Hussain 和 Aurelio Uncini，深度神经网络的组稀疏正则化 s 2017

在几秒钟内将数千个相似的电子表格文本单元格分组

原文：https://towardsdatascience.com/group-thousands-of-similar-spreadsheet-text-cells-in-seconds-2493b3ce6d8d?source=collection_archive---------3-----------------------

用 TF-IDF 和余弦相似度在 Python 中进行字符串匹配

This image — explained below — visualizes the cosine similarity of a document term matrix in a multidimensional space.

下面是一个常见的电子表格或数据库问题:

+-----+-------------------+
| row |     fullname      |
+-----+-------------------+
|   1 | John F. Doe       |
|   2 | Esquivel, Mara    |
|   3 | Doe, John F       |
|   4 | Whyte, Luke       |
|   5 | Doe, John Francis |
+-----+-------------------+

第 1、3 和 5 行可能指的是同一个人，只是在拼写和格式上略有不同。在小型数据集中，可以手动清理像元。但是在巨大的数据集中呢？我们如何梳理成千上万的文本条目并对相似的实体进行分组？

理想情况下，应该有一种简单的方法来添加第三列，如下所示:

+-----+-------------------+---------------+
| row |     fullname      |  name_groups  |
+-----+-------------------+---------------+
|   1 | John F. Doe       | Doe John F    |
|   2 | Esquivel, Mara    | Esquivel Mara |
|   3 | Doe, John F       | Doe John F    |
|   4 | Whyte, Luke       | Whyte Luke    |
|   5 | Doe, John Francis | Doe John F    |
+-----+-------------------+---------------+

嗯，有，这就是我们要做的。

TLDR:我为此制作了一个工具。你可以在这里安装 Python 模块。但是如果你想了解这个工具背后的概念——或者你只是强烈地不信任我(嗨，亲爱的)——请继续读下去。

我们将讨论的话题:

用 TF-IDF 和 N 元文法构建文档术语矩阵
使用余弦相似度计算字符串之间的接近度
使用散列表将我们的发现转换为电子表格中的“组”列

在本教程中，我将使用美国劳工部工资盗窃调查的数据集。它包含了从 1984 年到 2018 年因违反最低工资或加班而对雇主进行的每一次 DOL 调查。

该数据包括一个legal_name列，其中列出了被调查公司的名称。然而，条目格式千差万别:

+-----+----------------------+
| row |      legal_name      |
+-----+----------------------+
|   1 | Wal-mart Inc         |
|   2 | Walmart Stores Inc.  |
|   3 | Wal-mart stores Inc  |
|   4 | Wal-Mart stores Inc. |
+-----+----------------------+

我们将对legal_name下的条目进行标准化和分组，然后使用我们的组进行一些快速分析。

第一步:用 TF-IDF 和 N 元语法构建文档术语矩阵

我们这里最大的挑战是，我们专栏中的每个条目都需要与其他每个条目进行比较。因此，一张 400，000 行的表格需要 400，000 次计算，当我在记得关闭 Photoshop 之前打开网飞时，我的笔记本电脑过热了。

如果我们可以使用矩阵乘法来进行同时计算，这将会快得多，我们可以使用文档术语矩阵、TF-IDF 和 N-Grams 来进行计算。

让我们来定义这些术语:

文档术语矩阵

文档术语矩阵本质上是单词包概念的扩展，我喜欢这个概念，因为它听起来像是一个蒙面人在芝麻街上偷的东西。

BOW 包括计算字符串中单词的频率。所以，鉴于这句话:

“罗德岛既不是路，也不是岛。讨论。”

我们可以像这样制作一个弓:

+---------+-------+
|  term   | count |
+---------+-------+
| rhode   |     1 |
| island  |     2 |
| is      |     2 |
| neither |     1 |
| a       |     1 |
| road    |     1 |
| nor     |     1 |
| it      |     1 |
| an      |     1 |
| discuss |     1 |
+---------+-------+

文档术语矩阵(DTM)将 BOW 扩展到多个字符串(或者在术语中称为“多个文档”)。假设我们有以下三个字符串:

“连我哥哥都有需求”
“我弟弟需要搭车”
“老弟，你到底举不举？”

DTM 可能是这样的:

每个条目的值通过计算每个单词在每个字符串中出现的次数来确定。

上述方法的问题在于，像“The”、“is”和“if”这样的无关紧要的词往往比重要的词出现得更频繁，这可能会扭曲我们的分析。

因此，我们可以给它们分配一个 TF-IDF 分数，来评估每个单词对 DTM 的重要性，而不是计算单词数。

TF-IDF

为了计算 TF-IDF 得分，我们将一个术语在单个文档中出现的次数(术语频率或 TF)乘以该术语对整个语料库的重要性(逆文档频率或 IDF)——一个单词在文档中出现的次数越多，该单词在区分文档中的价值就越低。

如果你对计算 TF-IDF 分数背后的数学感兴趣，看看这里的。

重要的是，对于我们的文档术语矩阵中的每个单词，如果我们用 TF-IDF 分数替换单词计数，我们可以在检查字符串相似性时更有效地加权单词。

N-Grams

最后，我们将解决这个问题:

Burger King是两个字。BurgerKing应该是两个字，但是电脑会把它看成一个。因此，当我们计算文档术语矩阵时，这些术语将不匹配。

n 元语法是一种将字符串分成更小块的方法，其中N是块的大小。所以，如果我们将N设为3，我们得到:

['Bur', 'urg', 'rge', 'ger', 'er ', 'r K', ' Ki', 'Kin', 'ing']

并且:

['Bur', 'urg', 'rge', 'ger', 'erK', 'rKi', 'Kin', 'ing']

这些字符串比原始字符串有更多的重叠。

因此，当我们构建我们的文档术语矩阵时，让我们计算 N-Grams 而不是单词的 TF-IDF 分数。

最后，一些代码:

下面是构建文档术语矩阵的代码，使用 N-gram 作为列标题，使用 TF-IDF 分值作为值:

在第 6 行，我们将 CSV 转换成一个熊猫数据帧。

第 10 行从数据集的legal_name列中提取唯一值，并将它们放入一维 NumPy 数组中。

在第 14 行，我们编写了构建我们的 5 个字符的 N-Grams 的函数(我从这里提取了函数)。使用正则表达式过滤掉一些字符。

第 20 行将ngrams_analyzer传递给 TF-IDF 矢量器，我们将使用它来构建矩阵。

最后，在第 23 行，我们构建了我们的文档术语矩阵。

稀疏矩阵与密集矩阵以及如何让你的电脑崩溃

上面代码的结果tfidf_matrix，是一个压缩的稀疏行(CSR)矩阵。

如果你不熟悉稀疏矩阵，这是一个伟大的介绍。出于我们的目的，要知道任何大部分值为零的矩阵都是稀疏矩阵。这不同于大部分非零值的密集矩阵。

我们的 N 元模型矩阵有 237，573 行和 389，905 列。前 10 行和前 10 列如下所示:

(I added the underscores to represent blank characters.)

那是相当稀少的。没有理由在内存中存储所有这些零。如果我们这样做，就有可能耗尽 RAM 并触发MemoryError。

进入 CSR 矩阵，它只存储矩阵的非零值和对其原始位置的引用。

这是一个过于简化的问题，你可以在这里学习细节。重要的一点是，CSR 格式节省了内存，同时还允许快速的行访问和矩阵乘法。

步骤二:使用余弦相似度计算字符串之间的接近度

余弦相似度是一个介于 0 和 1 之间的度量，用于确定字符串的相似程度，而不考虑其长度。

它测量多维空间中字符串之间角度的余弦值。该值越接近 1(余弦值为 0)，字符串相似度越高。

取以下三个字符串:

我喜欢狗
我爱爱爱爱爱爱爱狗
我讨厌讨厌讨厌猫

并将它们放入文档术语矩阵中:

然后在多维空间上绘制这个矩阵，其中每个维度对应于我们四个术语中的一个。可能是这样的:

如果我们看一下我们之间的距离，“我爱狗”和“我讨厌猫”比“我爱狗”和“我爱…爱狗”在身体上更接近。

然而，如果我们看看我们的点的线之间的角度——余弦距离——我们可以看到，“我爱狗”和“我爱……爱狗”之间的角度比“我爱狗”和“我讨厌猫”之间的角度小得多。

因此，字符串 1 和字符串 2 之间的余弦相似度将比字符串 1 和字符串 3 之间的余弦相似度更高(更接近 1)。

下面是更深入的解释。

用 Python 计算余弦相似度

我们可以使用 scikit-learn 来计算余弦相似度。这将返回具有余弦相似值的成对矩阵，如下所示:

然后，我们将通过相似性阈值(类似于 0.75 或 0.8)过滤这个矩阵，以便对我们认为代表相同实体的字符串进行分组。

然而，如果我们使用由 ING Bank 的数据科学家构建的模块和,我们可以在构建矩阵时根据相似性阈值进行过滤。该方法比 scikit-learn 更快，并返回一个较少占用内存的 CSR 矩阵供我们使用。

ING 写了一篇博客解释为什么，如果你感兴趣的话。

因此，让我们将以下内容添加到我们的脚本中:

现在我们有了一个 CSR 矩阵来表示所有字符串之间的余弦相似性。是时候带它回家了。

第三步:构建一个散列表，将我们的发现转换为电子表格中的“groups”列

我们现在将构建一个 Python 字典，为我们的legal_name列中的每个唯一字符串提供一个键。

最快的方法是将我们的 CSR 矩阵转换成坐标(首席运营官)矩阵。首席运营官矩阵是稀疏矩阵的另一种表示。

举例来说，如果我们有这个稀疏矩阵:

+------------+
| 0, 0, 0, 4 |
| 0, 1, 0, 0 |
| 0, 0, 0, 0 |
| 3, 0, 0, 7 |
+------------+

我们将其转换为首席运营官矩阵，它将成为一个具有三个属性的对象— row、col、data —分别包含以下三个数组:

[0, 1, 3, 3]:每个非零值的行索引(索引为 0)
[3, 1, 0, 3]:每个非零值的列索引(索引为 0)
[4, 1, 3, 7]:矩阵中的非零值

因此，我们可以说值4(存储在matrix.data[0])的坐标是(0,3)(存储在(matrix.row[0],matrix.col[0])。

让我们建立我们的首席运营官矩阵，并用它来填充我们的字典:

在第 2 行，我们将余弦矩阵转换为坐标矩阵。

在第 39–43 行，我们遍历坐标矩阵，提取非零值的行和列索引，记住，所有非零值的余弦相似度都超过 0.8，然后将它们转换为字符串值。

为了澄清，让我们用一个简化的例子进一步解开第 39–43 行。再来看这个余弦矩阵:

如果我们使用阈值设置为 0.8 的awesome_cossim_topn构建它，然后将其转换为首席运营官矩阵，我们可以这样表示它:

 (row, col) | data  
 ------------|------ 
  (0,0)      |    1 
  (0,2)      | 0.84 
  (1,1)      |    1 
  (2,0)      | 0.84 
  (2,2)      |    1

vals将等于['Walmart', 'Target', 'Wal-mart stores']。

因此，在循环内部，我们第一个通过row != col条件的(row, col)对将是(0, 2)，然后我们将它作为(vals[0], vals[2)或('Walmart', 'Wal-mart stores')传递给add_pair_to_lookup。

继续这个例子，在我们所有的字符串都通过add_pair_to_lookup之后，我们会得到:

>>> group_lookup
{
    'Walmart': 'Walmart',
    'Wal-mart stores': 'Walmart'
}

没有类似于“Target”的字符串，因此没有为其分配组。

向量化熊猫

最后，我们可以使用 Pandas 中的矢量化功能，将每个legal_name值映射到数据帧中的一个新的Group列，并导出我们的新 CSV。

由于 Pandas 函数可以同时对整个数组进行操作——而不是依次对单个值进行操作——这个过程非常快:

fillna方法允许我们在group_lookup中不存在键时用legal_name值代替Group。

把所有的放在一起:

剩下要做的就是将这些数据放入数据透视表，看看哪些雇主欠员工的工资最多。

剧透提示:是沃尔玛。183 项调查导致他们同意支付近 4100 万美元的欠薪。

最后一个提示

如果您希望按两列或更多列而不是一列进行分组，一种方法是创建一个临时列，用于在数据帧中将每列的条目连接成一个字符串进行分组:

columns_to_group = ['legal_name', 'address']df['grouper'] = df[
   columns_to_group.pop(0)
].astype(*str*).str.cat(
   df[columns_to_group].astype(*str*)
)

然后将vals设置为:

vals = df['grouper'].unique().astype('U')

最后导出时，删除该列:

df.drop(columns=['grouper']).to_csv('./dol-data-grouped.csv')

同样，我创建了一个 Python 模块来完成这一切。来看看！！

培养你自己的 RNN 细胞:简化

原文：https://towardsdatascience.com/growing-your-own-rnn-cell-simplified-b68ba2c0f082?source=collection_archive---------12-----------------------

一窥单个 RNN 细胞的“深层”世界

什么是 RNN 细胞？

根据 Tensorflow 文档，“在最抽象的设置中，RNN 单元是指 具有状态 并执行一些需要输入矩阵的操作的任何东西。”

RNN 细胞在某种意义上区别于普通神经元，因为它们有一个状态，因此可以记住过去的信息。RNN 细胞构成了循环网络的主干。

在数学层面上，一系列输入通过 RNN 单元，一次一个。单元的状态有助于它记住过去的序列，并将该信息与当前输入相结合以提供输出。一个更简单的方法是展开序列中发生的事情，揭示一个更简单的深层网络。

常见的 RNN 单元架构

两种最常用的 RNN 单元是 GRUs 和 LSTMs。这两个单元都有“门”,基本上是对应于每个输入的 0 和 1 之间的值。这些门背后的直觉是忘记和保留少数选定的输入，表明这些细胞既可以记住来自过去的信息，也可以在需要时让它离开。这使得他们能够更好地处理序列。

要详细了解这些细胞的工作，请参考这个包含动画的相当不错的博客，以便于解释。

[## 动画 RNN，LSTM 和 GRU

gif 中的递归神经网络细胞

towardsdatascience.com](/animated-rnn-lstm-and-gru-ef124d06cf45)

单个节点本身就是一个深度网络！！

让我们看看 LSTM 工作的方程，它是最常用的 RNN 池之一。这里 x_t 表示单元的输入，而 h_t-1，h_t 和 c_t-1，c_t 表示隐藏状态和单元状态。所有其余的变量都是可训练的权重和偏差。

它们看起来确实很吓人，想想这些都发生在 RNN 的一个牢房里。在不深入细节的情况下，这些等式是否让你想起了其他事情？让我强调一下，矩阵与输入的权重相乘，然后是激活函数！！！ 是的！！！人脉深厚！！！

RNN 细胞本身包含一个小而深的网络。虽然 LSTMs 和 GRUs 中的架构是最常用的，但这并不意味着它们是手头每项任务的最佳选择。可能有比这些标准单元性能更好的更复杂、看起来不可思议的架构。

RNN cell created by WeNet, performing better than complex Recurrent networks containing LSTM cells, on the Penn Treebank dataset.

就像神经架构搜索(NAS) 和 AutoML 的发展一样，研究人员也一直致力于创建他们自己的 RNN 细胞架构。如果你不知道 NAS 或 AutoML 是什么，可以看看我之前在 AutoML 上的博客。

常用方法

搜索整个参数空间:从所有可能的连接开始，然后删除多余的连接，留下重要的连接。由于从真正“所有”可能的连接开始在计算上是一场噩梦，这些方法中的实际搜索空间通常是有限的。

生长细胞，一次一个节点:这些方法依赖于类似于生长决策树的策略。每次迭代后，都会在图的顶部添加一个新节点。树从 h_t(输出)开始生长，当我们在叶节点同时得到 x_t 和 h_t-1(输入)时结束。

遗传算法 : RNN 细胞架构是当前一代中的明星，杂交产生下一代更好的细胞架构。

下一步是什么？

AutoML 和 NAS 领域的工作和开发是最近的事，而且每年都在快速增长。然而，不仅没有一种算法能够集成并真正创建任何深度学习网络(包括 CNN 和 RNNs ),而且现有算法所花费的计算时间也是巨大的。这些都是未来研究可以并且将会改进的方向。

本博客是为机器学习领域创建简化介绍的努力的一部分。点击此处查看完整系列

[## 机器学习:简化

在你一头扎进去之前就知道了

towardsdatascience.com](/machine-learning-simplified-1fe22fec0fac)

或者干脆阅读本系列的下一篇博客

[## AutoML 和 AutoDL:简化

看看机器学习新阶段的开始

towardsdatascience.com](/automl-and-autodl-simplified-b6786e5560ff)

参考

[1]拉瓦尔、阿迪蒂亚、里斯托·米库拉宁。"从节点到网络:进化循环神经网络."arXiv 预印本 arXiv:1803.04439 (2018)。
[2]Schrimpf，Martin 等人，“一种灵活的自动化 RNN 架构生成方法”arXiv 预印本 arXiv:1712.07316 (2017)。
[3] Pham，Hieu 等，“通过参数共享进行有效的神经结构搜索”arXiv 预印本 arXiv:1802.03268 (2018)。
[4]黄、智衡、秉祥。" WeNet:用于递归网络体系结构搜索的加权网络."arXiv 预印本 arXiv:1904.03819 (2019)。

Golang

原文：https://towardsdatascience.com/grpc-in-golang-bb40396eb8b1?source=collection_archive---------2-----------------------

使用 gRPC 构建一个简单的 API 服务

在很长一段时间里，REST API 一直统治着 web 编程世界，直到 gRPC 的到来，颠覆了这个行业。网上有很多帖子讨论 gRPC 的优势，并将其与 REST 进行比较，因此我不打算在这一点上做多余的评论。我的理解是 gRPC 继承了 REST 的功能，并用更快、更轻、更灵活的服务对其进行了扩展。在这篇文章中，让我们看一下 gRPC 并使用 Golang 实现一个简单的服务。

先决条件

安装 Go:https://golang.org/doc/install
安装protoc : gRPC 使用protobuf进行通信，为了生成相关文件，需要安装protoc:

brew install protobuf // For MacOS

安装protoc-gen-go:因为我们在这篇文章中使用go，你将需要protobuf的 go-support

go get -u github.com/golang/protobuf/protoc-gen-go

安装grpc:go 的 grpc 包

go get -u google.golang.org/grpc

(注意:确保您的GOPATH设置正确，这样您的包和项目将位于GOPATH/src下)

gRPC 概述

与传统的 REST API 相比，在传统的 REST API 中，客户端通过指定一系列约束条件与服务器进行通信，如发送到特定的 url — localhost/api/v1/hello、localhost/api/v1/doSomething并指定哪种操作，如 PUT、POST、GET……我认为 gRPC 在某种程度上抽象了这个概念，并通过简单地调用函数来定义通信，这些函数中的消息以 *protobuf* 格式定义。

使用 gRPC，客户机可以直接调用服务器中的函数，正如您稍后将看到的，它们实际上共享同一个 protobuf 文件。上图的一个巨大优势是，用不同语言编写的服务器和客户端可以很容易地相互通信，因为它们共享一个 protobuf 文件。

如果到目前为止您对 gRPC 和 protobuf 有点困惑，让我们继续并实现一个服务，看看 protobuf 如何在通信中发挥作用。在这篇文章中，我们将实现一个简单的一元服务，即发送一个问候请求并接收一个响应。客户端会发送一个对其名称的请求，服务器会返回一串 *Hello + client_name* 。

原蟾蜍

在 protobuf 中，它定义了可用的服务和消息。打开具有结构的项目:

并且在hello.proto里面写着:

所以service关键字定义了一个服务，rpc定义了服务的功能。在这个例子中，我们的helloService提供了一个Hello函数，它需要输入helloRequest消息并输出一个helloResponse消息。如果你熟悉任何一门编程语言，我们大致可以打个比方:service => class、rpc => function和message => global variables。

转到您的终端并运行:

protoc --go_out=plugins=grpc:. YOUR_ROOT_FOLDER/hellopb/hello.proto

--go_out选项指定了生成文件的输出目录，也告诉我们需要使用 grpc 插件。第二部分是目标文件。

结果给你一个hello.pb.go文件。如果你查看文件，你会发现 gRPC 的神奇之处在于，所有这些信息都是用 go 特定语言表示的，而如果你使用其他语言，同样的 protobuf 会用其他特定语言表示，这也是 protobuf 可以跨语言交流的原因。

计算机网络服务器

服务器接收来自客户端的请求并相应地做出响应。

在main函数中，我们注册了一个服务器，让它监听地址0.0.0.0:50051，它是本地主机，端口50051是 gRPC 连接的端口。

函数RegisterHelloServiceServer是从我们刚刚编写的 protobuf 文件自动生成的。如果你仔细研究这个函数，你会发现第二个参数需要一个 struct 类型来实现服务接口——做“实际工作”:

// HelloServiceServer is the server API for HelloService service.
type HelloServiceServer interface {
   Hello(context.Context, *HelloRequest) (*HelloResponse, error)
}

上面的代码是在hello.pb.go中生成的。为了实现服务器，struct 类型需要在接口内部实现函数Hello。

然后在实现中，它从请求中接受名称并返回一个字符串Hello + name。

客户

客户端发送请求并接收响应。

代码很简单，我们创建一个客户端hellopb.NewHelloServiceClient拨号到端口50051并通过函数client.Hello发送请求。注意，所有这些函数都在自动生成的文件中提供。

现在，请再次理解文档中所说的内容:

在 gRPC 中，客户端应用程序可以直接调用不同机器上的服务器应用程序的方法，就像它是一个本地对象一样，这使得您可以更容易地创建分布式应用程序和服务。

client.Hello正是上面所描述的，因为客户端可以直接调用服务器端的函数。

运行应用程序

服务器和客户端都准备好了，让我们先运行服务器，然后运行客户端，您将得到结果:

这是 gRPC 在 golang 中最简单的用法，当然，还有很多其他应用，特别是 gRPC 支持流调用，允许客户端和服务器以流格式相互通信。我希望这只是一个起点，还有更多值得探索。

参考:

https://grpc.io/docs/guides/
https://github.com/golang/protobuf
https://github.com/grpc/grpc-go
https://code . tuts plus . com/tutorials/rest-vs-grpc-battle-of-the-API-CMS-30711

GRU 和 LSTM 的

原文：https://towardsdatascience.com/grus-and-lstm-s-741709a9b9b1?source=collection_archive---------13-----------------------

递归神经网络是保存信息的网络。它们对序列相关的任务很有用，如语音识别、音乐生成等。然而，RNN 患有短期记忆。如果一个序列足够长，它们将很难把信息从前面的时间步带到后面的时间步。这就是所谓的消失梯度问题。在这篇文章中，我们将研究门控循环单位(GRU)和长短期记忆(LSTM)网络，它们解决了这个问题。如果你没有读过 RNN 氏症，这里有一个链接指向我解释 RNN 是什么以及它如何工作的帖子。

Basic Architecture of RNN Cell

一个标准 RNN 的架构表明，中继模块具有非常简单的结构，只有一个 tanh 层。GRU 和 LSTM 都有类似 RNN 的重复模块，但是重复模块有不同的结构。

GRU 和 LSTM 的关键思想是细胞状态或记忆细胞。它允许两个网络保留任何信息而不会丢失太多。这些网络也有闸门，帮助调节流向细胞状态的信息流。这些门可以知道序列中哪些数据是重要的，哪些是不重要的。通过这样做，它们以长序列传递信息。现在，在我们进入 LSTM 之前，让我们先试着理解 GRU 或门控循环单元。

Basic Architecture of a GRU Cell

我们可以清楚地看到，GRU 单元的架构比简单的 RNN 单元复杂得多。我觉得方程式比图表更直观，所以我会用方程式来解释一切。

在 GRU 单元中，我们需要注意的第一件事是单元状态h等于时间 t 的输出。现在，让我们一个一个地看所有的方程。

在每个时间步长，我们有两个选项:

保留以前的单元状态。
更新其值。

上面的等式示出了在时间 t 可以替换单元状态的更新值或候选值。它依赖于前一时间步h的单元状态和一个称为r的相关性门，该相关性门在计算当前单元状态时计算前一单元状态的相关性。**

如我们所见，关联门 r < t > 具有 sigmoid 激活，其值在 0 和 1 之间，决定了先前信息的相关程度，然后用于更新值的候选中。

当前单元状态h是先前单元状态 h < t-1 >和更新候选状态 h(tilde) < t > 的过滤组合。这里，更新门z决定计算当前单元状态所需的更新候选的部分，这又决定保留的先前单元状态的部分。**

像关联门一样，更新门也是一个 sigmoid 函数，它帮助 GRU 在需要时保持单元状态。现在，让我们看看在《RNN 邮报》上看到的例子，以便更好地理解 GRU

史密斯太太养的狗意识到房子里有人，正在吠叫。

这里的“dogs”一词是必要的，因为 dogs 是复数，所以要知道单词“were”在末尾。让我们有一个单元格状态c= 1 为复数。因此，当 GRU 到达单词“dogs”时，它理解我们在这里讨论的是句子的主语，并在单元状态中存储值 c < t > = 1。这个值一直保留到单词“were ”,在这里它理解主语是复数，单词应该是“were”而不是“was”。这里的更新门知道什么时候保留值，什么时候忘记值。所以一旦单词“were”完成，它就知道细胞状态不再有用，并忘记了它。这就是 GRU 如何保持记忆，从而解决渐变消失的问题。

虽然 LSTM 的核心思想是相同的，但它是一个更复杂的网络。让我们试着用类似的方式来理解它。

Basic Unit of a LSTM Cell

乍一看，LSTM 单元看起来确实很可怕，但让我们试着像对 GRU 一样将其分解为简单的方程。GRU 有两个门，称为更新门和关联门，而 LSTM 有三个门，即遗忘门f，更新门I和输出门 o < t > 。**

在 GRU，细胞状态等于激活状态/输出，但在 LSTM，它们并不完全相同。时间“t”处的输出由h表示，而单元状态由c表示。**

如同在 GRU，在时间‘t’的单元状态具有候选值 c(波形符)< t > ，其依赖于先前的输出 h < t-1 > 和输入 x < t >。

像在 GRU，LSTM 的当前单元格状态 c < t > 是前一单元格状态和候选值的过滤版本。然而，这里的过滤器由两个门决定，即更新门和忽略门。遗忘门与 GRU 中(1-updateGate < t >的值非常相似，遗忘门和更新门都是 sigmoid 函数。

遗忘门计算当前单元状态需要多少来自前一单元状态的信息。

更新门计算在当前单元状态中需要多少候选值 c(波形符)< t > 。更新门和遗忘门的值都在 0 和 1 之间。

最后，我们需要决定我们要输出什么。这个输出将是我们的细胞状态的过滤版本。因此，我们通过一个 tanh 层传递单元状态，将值推到-1 和 1 之间，然后乘以一个输出门，该输出门有一个 sigmoid 激活，因此我们只输出我们决定输出的内容。

LSTM 氏症和 GRU 氏症在深度学习中基于序列的问题上都非常流行。虽然 GRU 的工作对某些问题有效，但 LSTM 的工作对其他问题也有效。GRU 的简单得多，需要较少的计算能力，因此可以用来形成真正的深度网络，然而 LSTM 的更强大，因为它们有更多的门，但需要大量的计算能力。至此，我希望你对 LSTM 和 GRU 有了基本的了解，并准备好深入序列模型的世界。

参考资料: