TowardsDataScience 博客中文翻译 2019（二百一十六）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

Apache Cassandra 和 Python 入门

原文：https://towardsdatascience.com/getting-started-with-apache-cassandra-and-python-81e00ccf17c9?source=collection_archive---------2-----------------------

在这篇文章中，我将谈论 Apache Cassandra，它的用途、用法、配置和设置集群，最后，你如何在你的 Python 应用程序中访问它。在这篇文章的最后，你应该对 Cassandra 有了一个基本的了解，以及如何在你的 Python 应用中使用它。

什么是阿帕奇卡珊德拉？

根据维基百科:

Apache Cassandra 是一个免费的开源分布式宽列存储 NoSQL 数据库管理系统，旨在处理许多商用服务器上的大量数据，提供无单点故障的高可用性。Cassandra 为跨多个数据中心的集群提供了强大的支持，[1]异步无主机复制允许所有客户端进行低延迟操作。

两位脸书工程师开发的 Cassandra 用于处理收件箱的搜索机制。后来，脸书将其作为谷歌代码的开源项目发布，过了一段时间，它被移交给阿帕奇基金会。许多知名公司都在使用 Cassandra，比如网飞、苹果、天气频道、易贝等等。它的分散性(无主系统)、容错性、可伸缩性和持久性使其优于竞争对手。让我们讨论一下它的架构，如果你愿意，你可以跳到安装和设置部分。我建议你浏览一下架构部分，因为它会让你知道为什么你会想使用它。

卡桑德拉建筑

Cassandra 架构由以下组件组成:

结节

它是数据的基本组成部分，是存储数据的机器

资料处理中心

相关节点的集合。它可以是物理数据中心或虚拟数据中心

串

一个集群包含一个或多个数据中心，它可以跨越多个位置。

提交日志

每个写操作首先存储在提交日志中。它用于崩溃恢复。

记忆表

将数据写入提交日志后，它会存储在 Mem-Table(内存表)中，直到达到阈值。

表

Sorted-String Table 或 SSTable 是一个磁盘文件，它在 MemTable 达到阈值时存储其中的数据。表按顺序存储在磁盘上，并为每个数据库表进行维护。

写操作

Write Operation Flow

• 一旦收到写请求，它首先被转储到提交日志中，以确保数据被保存。
• 数据还被写入 MemTable，这是一个内存系统，它保存数据直到填满。
• 一旦 MemTable 达到其阈值，其数据就会被刷新到 SS 表中。

接受写请求的节点被称为用于特定操作的协调器。它充当发送请求的客户端和其他节点之间的代理。然后，协调器根据集群配置确定环中的哪个节点应该接收该数据。

一致性级别决定了有多少节点会用成功确认来回应。

读取操作

协调器可以向副本发送三种类型的读取请求:

1. 直接请求:- 协调器节点向其中一个副本发送读取请求。之后，向其他副本发送一个摘要请求，以确定返回的数据是否是更新的数据。
2. **摘要请求:**协调器联系由一致性级别指定的复制品。被联系的节点用所需数据的摘要请求来响应。每个副本中的行在内存中进行比较，以确保一致性。如果它们不一致，协调器将使用具有最新数据(时间戳)的副本将结果转发回客户端。
3. **读取修复请求:**如果节点上的数据不一致，将启动后台读取修复请求，以确保节点上的最新数据可用。

数据复制策略

数据复制是一项必不可少的功能，以确保不会因硬件或网络故障而丢失数据。复制策略决定在哪些节点上放置副本。Cassandra 提供了两种不同的复制策略。

简单策略

当您只有一个数据中心时，使用 SimpleStrategy。它将第一个副本放在由分区器选择的节点上。分割器决定数据如何在集群中的节点之间分布(包括副本)。之后，剩余的副本以顺时针方向放置在节点环中。

网络拓扑策略

当您跨多个数据中心进行部署时，会用到它。该策略通过顺时针遍历环，直到到达另一个机架中的第一个节点，将副本放置在同一数据中心。这是因为机架中有时会出现故障或问题。那么其他节点上的副本可以提供数据。出于可伸缩性和未来扩展的目的，强烈建议采用这种策略。

好了，理论讨论够了，来点实际的吧。

安装和设置

你可以从官方网站下载该软件包，并以单一模式运行用于开发目的，但它不会帮助你了解 Cassandra 的真正实力，因为它的行为就像任何其他数据库一样。因此，我将使用它的 docker 版本，其中我将设置一个包含两个节点的集群。

注意:在开始之前，请确保将 Docker 内存设置为至少 4GB，否则容器会以错误代码 137 退出。由于内存资源不足，我花了一个小时才发现这个错误。

在你的机器上创建一个文件夹，就像我创建的/Development/PetProjects/CassandraTut/data。在这个文件夹中，我创建了两个子文件夹来存储两个节点的数据。完成后，它将如下所示:

➜  data tree -a.├── node1└── node22 directories, 1 file

留在同一个文件夹，运行命令docker pull cassandra下载官方镜像。如果你是 docker 的新手，那么你应该看看我在 Docker 系列的帖子。一旦下载完毕，docker images命令就会显示在你的终端上。确保 docker 已安装并正在运行。此外，您必须给 Cassandra 存储数据的文件夹写权限。

我们将设置两个节点: Node1 为主节点， Node2 为种子节点。种子在启动过程中用于发现集群。让我们运行第一个节点。

docker run --name cas1 -p 9042:9042 -v /Development/PetProjects/CassandraTut/data/node1:/var/lib/cassandra/data -e CASSANDRA_CLUSTER_NAME=MyCluster -e CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch -e CASSANDRA_DC=datacenter1 -d cassandra

许多环境变量是不言自明的，我将讨论CASSANDRA_ENDPOINT_SNITCH

告密者决定卡珊德拉如何分发复制品。这个飞贼推荐生产。GossipingPropertyFileSnitch在添加新节点时使用八卦协议自动更新所有节点，建议用于生产。运行以下命令了解节点的状态。

➜  data docker exec -it cas1  nodetool status
Datacenter: datacenter1
=======================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
--  Address     Load       Tokens       Owns (effective)  Host ID                               Rack
UN  172.17.0.2  103.67 KiB  256          100.0%            bcb57440-7303-4849-9afc-af0237587870  rack1

UN表示状态为 U p 和 N 正常。当其他节点加入时，您可能会看到状态 UJ，这意味着 U p 和 J 正在加入。我正在使用docker run的-d开关在后台运行它。另外，请注意节点 1 文件夹的内容。它创建默认的系统数据库，类似于 MySQL。

➜  node1 ls
system             system_auth        system_distributed system_schema      system_traces
➜  node1

现在让我们运行第二个节点:

docker run --name cas2 -v /Development/PetProjects/CassandraTut/data/node2:/var/lib/cassandra/data -e CASSANDRA_SEEDS="$(docker inspect --format='{{ .NetworkSettings.IPAddress }}' cas1)" -e CASSANDRA_CLUSTER_NAME=MyCluster -e CASSANDRA_ENDPOINT_SNITCH=GossipingPropertyFileSnitch -e CASSANDRA_DC=datacenter1 -d cassandra:latest

在设置了相关的容器名和数据中心后，您还可以将这里的CASSANDRA_SEEDS 设置为节点cas1的 IP 地址，该节点可以使用docker inspect命令获取。过一会儿，当您在cas1中运行nodetool status命令时，您应该会看到如下所示的内容:

如您所见，我们的第二个节点正在加入集群，我们从状态UJ中了解到这一点。

如果你查看挂载的卷，node2文件夹，你也会看到系统文件夹。

从终端运行命令很烦人，因此我创建了一个docker-compose.yaml文件来运行集群，没有任何麻烦。

为了确保cas1启动并运行，我让cas2依赖于cas1，并设置一个 60 秒的sleep。

我得到 RPC 错误INFO [main] 2019-05-14 01:51:07,336 CassandraDaemon.java:556 - Not starting RPC server as requested. Use JMX (StorageService->startRPCServer()) or nodetool (enablethrift) to start it，所以我也调用CASSANDRA_START_RPC环境参数，并将其设置为真。

让我们运行docker-compose up -d以在分离模式下运行。

正如您可以看到的，第一个节点没有启动，第二个节点启动过程也没有启动。

过了一会儿，两个节点都使用各自独特的 IP 启动。

所有 Cassandra 配置文件都位于容器内的/etc/cassandra/文件夹中。

让我们运行 CQL 外壳。

➜  CassandraTut docker exec -it cas2  cqlsh          
Connected to MyCluster at 127.0.0.1:9042.
[cqlsh 5.0.1 | Cassandra 3.11.4 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh>

它类似于 MySQL shell。CQL，Cassandra 查询语言在语法上与 SQL 相似，但其用法与 RDBMS 系统不同。我们将很快对此进行更深入的研究。坚持住！

如果你注意到我已经在docker run和docker compose命令中公开了默认的 Cassandra 端口9042。使用终端 like 并不吸引人，使用 GUI 客户端怎么样？我使用的是 SQL/NoSQL 客户端 TablePlus 。

一旦连接，您将看到默认的系统数据库。

让我们在节点cas1上创建一个测试密钥空间、数据库的 Cassandra 版本和一个表。别担心，我稍后会详细讨论。现在，我们的目的是告诉您数据是如何复制的。

将复制因子设置为 2，这意味着将有 2 份数据拷贝，每个节点一份。

让我们连接到第二个节点。

请注意端口 9043。9042 已经分配给cas1。

瞧啊！我的密钥空间在这里也存在，它被很好地从案例 1 复制到案例 2

无论您在 Cas1 或 Cas2 上进行更改，它最终都会被传播。这并不类似于典型的主/从概念，而是被称为无主，因为整个系统是分散的，P2P 连接是在环中建立的(它让你想起区块链了吗？)

接下来是数据建模概念和在 CQL 创建实体。

卡珊德拉数据建模和 CQL

Cassandra 是一头野兽，不可能在这里涵盖数据建模的每个方面。因此，我将介绍一些基础知识，让您了解它与典型的关系数据库系统有何不同。尽管 CQL 看起来非常类似于 SQL 或基于 MySQL 的 SQL，但它根本不是 SQL。让自己做好准备，忘掉 RDBMS 的东西。

术语

下面是 Cassandra 和 RDBMS world 的一点对比。

Keyspace :-它是列族的容器集合。你可以把它想象成 RDBMS 世界中的一个数据库。

列族:- 列族是行的有序集合的容器。每一行又是列的有序集合。可以把它想象成 RDBMS 世界中的一个表。

行:- 行是列的集合，按列排序。

列:- 列是键/值对的集合。

行键:- 主键叫做行键。

复合主键:- 主键由多列组成。该密钥一部分被称为分区密钥和剩余的簇密钥*。*

分区键:-**Cassandra 中的数据分布在各个节点上。分区键的目的是识别存储了被请求的特定行的节点。名为 partition 的函数用于在写入行时计算分区键的哈希值。例如，节点 1 的键值范围从1–10，节点 2 包含11–20*，节点 3 包含范围21–30。当执行带有 WHERE 子句的 SELECT 命令时，使用分区键的哈希值来查找所需的节点，一旦找到该节点，它就会获取数据并返回给客户端。例如，查询是SELECT * FROM users where id = 5，假设分区键的哈希值(在本例中是 5)是 15，那么将会是节点 2 获得该行。下面是它的图示。*

我们来举个例子。您正在开发一个保存网站用户及其所在城市信息的系统。我们将创建一个名为 CityInfo 的密钥空间。你可以使用 CQLSH 或 TablePlus GUI，由你决定。

create keyspace CityInfo with replication = {'class' : 'SimpleStrategy', 'replication_factor':2}

因为我有 2 个节点，所以我将replication_factor设置为2。

设计模型

在 RDBMS 中，我们有一个类似 JOINs 的工具，而编写并不便宜，因此我们通过在相关表中使用外键来避免重复。《卡珊德拉》就不是这样的。Cassandra 是一个分布式系统，编写起来很便宜，因此非常欢迎你在需要的地方去规范化数据。这有助于检索通常通过连接获取的数据。另一方面，数据读取可能会很昂贵，因为数据跨越多个节点并通过分区键检索。设计模型时，您应该记住以下目标:

1. 在集群中均匀分布数据:- 如果主键由单列组成，则主键是分区键，如果是复合主键，则主键是分区键和集群键。要平均分布数据，您必须为 PK 选择一个具有唯一性的列，这样就可以跨节点分布。像 ID、用户名、和 email 这样的东西具有唯一性，会充分利用节点的集群。但是如果您使用像名字/姓氏、性别等这样的键，那么分区键的选择将会非常少，尽管有 100 个节点，但总是只有少数几个会被使用，从而使一个分区变得臃肿，性能降低。
2. 尽量减少读取次数:- 正如我提到的，读取是很昂贵的。如果您以一种单个查询从多个分区获取的方式建模，将会使系统变慢。

因此，与 RDBMS 不同，在 RDBMS 中，您首先设计模式，然后根据您的需求自由地创建查询，而 Cassandra 却不是这样。你必须预先知道系统中需要的查询，然后相应地设计模型。

示例使用案例

我们有一个系统，不同城市的用户访问一个网站。管理层要求提供以下信息:

1. 所有用户的列表
2. 所有城市的列表。
3. 按城市列出的用户列表

让我们首先创建cities表。

*CREATE TABLE cities (
 id int,
 name text,
 country text,
 PRIMARY KEY(id)
);*

然后users

*CREATE TABLE users (
 username text,
 name text,
 age int,
 PRIMARY KEY(username)
);*

插入几个城市。

*INSERT INTO cities(id,name,country) VALUES (1,'Karachi','Pakistan');
INSERT INTO cities(id,name,country) VALUES (2,'Lahore','Pakistan');
INSERT INTO cities(id,name,country) VALUES (3,'Dubai','UAE');
INSERT INTO cities(id,name,country) VALUES (4,'Berlin','Germany');*

并插入一些用户

*INSERT INTO users(username,name,age) VALUES ('aali24','Ali Amin',34);
INSERT INTO users(username,name,age) VALUES ('jack01','Jack David',23);
INSERT INTO users(username,name,age) VALUES ('ninopk','Nina Rehman',34);*

这些插入满足了我们的前两个要求，但是第三个要求呢？在 RDBMS 世界中，我们将使用city_id作为users表中的 FK，连接将很容易返回数据，但这是 Cassandra，我们不能这样做，剩下的是我们创建另一个表来满足我们的需求。

*CREATE TABLE users_by_cities (
 username text,
 name text,
 city text,
 age int,
 PRIMARY KEY(city,age)
);*

这个主键有两个组成部分:第一个成为分区键，第二个成为簇键。它将查找 w . r . t . city，所有记录都按年龄分组。

现在插入一些记录:

*INSERT INTO users_by_cities(username,name,city,age) VALUES ('aali24','Ali Amin','Karachi',34);
INSERT INTO users_by_cities(username,name,city, age) VALUES ('jack01','Jack David','Berlin',23);
INSERT INTO users_by_cities(username,name,city, age) VALUES ('ninopk','Nina Rehman','Lahore',34);*

通常情况下，在两个表中的这些插入会在“添加用户”界面中一次完成，从 CQL 端，您可以做类似这样的事情来添加用户信息。

*BEGIN BATCH
INSERT into users(username,name,age) VALUES('raziz12','Rashid Aziz',34);
INSERT INTO users_by_cities(username,name,city, age) VALUES ('raziz12','Rashid Aziz','Karachi',30);
APPLY BATCH;*

在继续之前，我想提醒您一下我之前讨论过的散列令牌。首先，在 CQL shell 上运行EXPAND ON命令。一旦你这样做了，你会看到如下结果:

看起来不错，不是吗？好了，现在我们将看到我们的主键的令牌值。它返回以下结果:

*cqlsh:cityinfo> select token(username) from users;@ Row 1
------------------------+----------------------
 system.token(username) | -7905752472182359000@ Row 2
------------------------+----------------------
 system.token(username) | 2621513098312339776@ Row 3
------------------------+----------------------
 system.token(username) | 6013687671608201304*

有道理，令牌是唯一的，因为用户名是唯一的。这些令牌将跨节点传播。当用户运行命令SELECT * FROM users where username = 'raziz12'时，它将根据这个令牌值选择节点。我已经在上面几行中展示过了。

下面的查询显示了来自users_by_cities表的令牌值。

*cqlsh:cityinfo> select token(username),username,city from users_by_cities;@ Row 1
------------------------+----------------------
 system.token(username) | 2621513098312339776
 username               | jack01
 city                   | Berlin@ Row 2
------------------------+----------------------
 system.token(username) | 6013687671608201304
 username               | ninopk
 city                   | Lahore@ Row 3
------------------------+----------------------
 system.token(username) | -882788003101376442
 username               | raziz12
 city                   | Karachi@ Row 4
------------------------+----------------------
 system.token(username) | -7905752472182359000
 username               | aali24
 city                   | Karachi*

Select * from users_by_cities where city = 'Karachi';返回以下内容:

*cqlsh:cityinfo> select * from users_by_cities where city = 'Karachi';@ Row 1
----------+-------------
 city     | Karachi
 username | aali24
 name     | Ali Amin@ Row 2
----------+-------------
 city     | Karachi
 username | raziz12
 name     | Rashid Aziz*

该模型还服务于查询select * from users_by_cities where city = 'Karachi' and age = 34

但是，如果您想根据字段选择一条记录，该怎么办呢？

SELECT * from users_by_cities where name = 'Ali Amin';

您会得到下面的错误。

*Error from server: code=2200 [Invalid query] message="Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability*

这是因为没有提到分区键，Cassandra 要求在所有节点中搜索所需的名称，是的，所有节点，想象一下如果节点是 10 或 100，返回数据需要时间。因此不建议这样做。如果您想在 w.r.t 字段中找到一些东西，要么创建另一个表(强烈推荐)，要么创建一个二级索引(不推荐)

数据按城市分区，在查找时，一个节点用城市的令牌响应，一旦发现该节点，它就获取该分区中属于卡拉奇城市的用户的所有记录。对于与卡拉奇相关的数据聚类，也可以看到类似的情况。数据根据年龄列进行聚类。

所以对于一个保存所有 Karachiites 记录的分区，你会看到记录的集群。

你的脑袋一定在打转，会想念你心爱的 MySQL，但我告诉你，这是值得学习的东西，我也在学习，我只是触及了这个野兽的表面。

你可能想知道这篇文章的标题提到了 Python，但是我听说到目前为止还没有写 Python 代码。有必要准备一个基础，因为您将只是在 Python 应用程序中执行查询。主要工作在别的地方，就在上面。

好了，在我转向开发之前，我讨论过 Cassandra 最初在 Commitlog 中写数据。

Cassandra CommitLog 的路径可以从/etc/cassandra/cassandra.yaml获得，也就是从/var/lib/cassandra/commitlog获得，这里它创建了带有时间戳的日志文件。这是不可读的，但当我搜索一些插入的记录，然后发现一些痕迹。检查下面的屏幕:

你可以在这里找到杰克 01 、阿力、和尼诺普的踪迹。你也可以找到与修复机制相关的文字。

在/var/lib/cassandra/data/<keyspacename>可以找到桌子。我的情况是cityinfo

对于每个表/列族，它生成manifest.json文件，一些*.db和一些其他类型的文件，下面是表users_by_cities表的文件。

*./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/manifest.json
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-CompressionInfo.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Data.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Digest.crc32
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Filter.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Index.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Statistics.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-Summary.db
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/md-1-big-TOC.txt
./users_by_cities-62cea5f0788e11e9b568e709cd27ef9f/snapshots/truncated-1558089482008-users_by_cities/schema.cql*

你可以在这里了解更多。

从 Python 访问 Cassandra

好的，首先，我们需要安装驱动程序。我在 docker shell 之外，因为我将从我的主机访问它。运行命令pip install cassandra-driver

构建驱动程序需要一段时间:

*Requirement already satisfied: six>=1.9 in /anaconda3/anaconda/lib/python3.6/site-packages (from cassandra-driver) (1.11.0)
Building wheels for collected packages: cassandra-driver
  Building wheel for cassandra-driver (setup.py) ... done
  Stored in directory: /Users/AdnanAhmad/Library/Caches/pip/wheels/df/f4/40/941c98128d60f08d2f628b04a7a1b10006655aac3803e0e227
Successfully built cassandra-driver
Installing collected packages: cassandra-driver
Successfully installed cassandra-driver-3.17.1*

下面是从 Docker 中运行的 Python 脚本连接到 Docker 中的 Cassandra 集群的代码。

*from cassandra.cluster import Clusterif __name__ == "__main__":
    cluster = Cluster(['0.0.0.0'],port=9042)
    session = cluster.connect('cityinfo',wait_for_all_pools=True)
    session.execute('USE cityinfo')
    rows = session.execute('SELECT * FROM users')
    for row in rows:
        print(row.age,row.name,row.username)*

返回了以下输出:

*➜  CassandraTut python cassandra_connect.py
34 Ali Amin aali24
34 Rashid Aziz raziz12
23 Jack David jack01
34 Nina Rehman ninopk
➜  CassandraTut*

你可以在这里了解更多信息

结论

所以在这篇文章中，你学习了一些关于 Cassandra 的知识，以及如何使用 CQL 并在你的 Python 脚本中连接它。请在下面留下您的评论，以便提出意见、更正或反馈。和往常一样，代码在 Github 上。

本帖原载 此处 。

Apache Spark 入门

原文：https://towardsdatascience.com/getting-started-with-apache-spark-ad9d59e71f6f?source=collection_archive---------7-----------------------

Java 中 Spark 的体系结构及应用

Photo by Markus Spiske on Unsplash

Apache Spark 被解释为“大规模数据处理的快速通用引擎”然而，这甚至没有开始概括它成为大数据领域如此突出的参与者的原因。Apache Spark 是一个分布式计算平台，大数据公司对它的采用一直在以令人瞩目的速度增长。

火花建筑

spark 的架构如下所示:

Spark Eco-System — Image by Author

Spark 是一个分布式处理引擎，但是它没有自己的分布式存储和资源集群管理器。它运行在现成的集群资源管理器和分布式存储之上。

Spark core 由两部分组成:

• 核心 API:非结构化 API(rdd)，结构化 API(数据帧，数据集)。在 Scala、Python、Java 和 r 中可用。
• 计算引擎:内存管理、任务调度、故障恢复、与集群管理器交互。

注意:我们将在文章末尾看到核心 API 的 Java 实现。

在核心 API 之外，Spark 提供了:

• Spark SQL:通过类似 SQL 的查询与结构化数据进行交互。
• 流:消费和处理连续的数据流。
• 机器学习库。但是，我不会推荐在这里训练深度学习模型。
• GraphX:典型的图形处理算法。

以上四个都直接依赖于 spark 核心 API 进行分布式计算。

Spark 的优势

• Spark 为批处理、结构化数据处理、流等提供了一个统一的平台。
• 与 Hadoop 的 map-reduce 相比，spark 代码更容易编写和使用。
• Spark 最重要的特性，它抽象了并行编程方面。Spark core 抽象了分布式存储、计算和并行编程的复杂性。

Apache Spark 的主要用例之一是大规模数据处理。我们创建程序并在 spark 集群上执行它们。

程序在集群上的执行

在 spark cluster 上执行程序主要有两种方法:

1. 互动客户端如py-spark，笔记本等。
2. 提交作业。

大多数开发过程发生在交互式客户机上，但是当我们必须将应用程序投入生产时，我们使用提交作业方法。

对于长时间运行的流作业或定期批处理作业，我们将应用程序打包并提交给 Spark cluster 执行。

Spark 是一个分布式处理引擎，遵循主从架构。在 spark 术语中，主人是 驱动者 ，奴隶是 执行者 。

Image by Author

司机负责:

1. 分析
2. 分发。
3. 监控。
4. 日程安排。
5. 在 spark 进程的生命周期内维护所有必要的信息。

执行者只负责执行驱动程序分配给他们的那部分代码，并将状态报告给驱动程序。

每个 spark 进程都有一个单独的驱动程序和独占的执行器。

执行方式

1. ***客户端模式:*驱动程序是本地虚拟机，您可以在这里提交应用程序。默认情况下，spark 以客户端模式提交所有应用程序。由于驱动程序是整个 spark 流程中的主节点，因此在生产设置中，这是不可取的。对于调试，使用客户端模式更有意义。
2. ***集群模式:*司机是集群中的执行者之一。在 spark-submit 中，您可以如下传递参数:

*--deploy-mode cluster*

集群资源管理器

Image by Author

Yarn 和 Mesos 是常用的集群管理器。

Kubernetes 是一个通用容器编制器。

注意:在撰写本文时，Kubernetes 上的 Spark 还没有做好生产准备。

Yarn 是 spark 最受欢迎的资源管理器，让我们看看它的内部工作原理:

在客户端模式应用程序中，驱动程序是我们的本地虚拟机，用于启动 spark 应用程序:

步骤 1: 一旦驱动程序启动，spark 会话请求就会发送到 yarn 以创建一个 Yarn 应用程序。

步骤 2: 纱线资源经理创建一个应用程序主程序。对于客户机模式，AM 充当执行器启动器。

第 3 步: AM 将联系纱线资源经理，要求提供更多容器。

步骤 4: 资源管理器将分配新的容器，AM 将启动每个容器中的执行器。之后，执行者直接与司机沟通。

Image by Author

注意:在集群模式下，驱动程序在上午启动。

执行器和内存调优

硬件— 6 个节点，每个节点 16 个内核，64 GB RAM

让我们从核心的数量开始。核心的数量代表一个执行器可以运行的并发任务。研究表明，任何具有 5 个以上并发任务的应用程序都会导致糟糕的表现。因此，我建议坚持 5。

注意:上面的数字来自于一个执行器的性能，而不是来自于系统有多少内核。因此，对于 32 核系统来说也是一样的。

操作系统和 Hadoop 守护程序需要 1 个内核和 1 GB RAM。因此，我们只剩下 63 GB 内存和 15 个内核。

对于 15 个内核，每个节点可以有 3 个执行器。我们总共有 18 个遗嘱执行人。AM 容器需要 1 个执行器。因此我们可以得到 17 个遗嘱执行人。

回到内存，我们得到每个执行器 63/3 = 21 GB。但是，在计算完整的内存请求时，需要考虑少量的开销。

*Formula for that over head = max(384, .07 * spark.executor.memory)Calculating that overhead = .07 * 21 = 1.47*

因此，内存下降到大约 19 GB。

因此，该系统得出:

*--num-executors 17 --executor-memory 19G --executor-cores 5* 

注意:如果我们需要更少的内存，我们可以减少内核的数量来增加执行器的数量。

火花核心

现在我们来看看 spark 提供的一些核心 API。Spark 需要一个数据结构来保存数据。我们有三种选择 RDD、数据帧和数据集。从 Spark 2.0 开始，建议只使用数据集和数据帧。这两个内部编译到 RDD 本身。

这三个是弹性的、分布式的、分区的和不可变的数据集合。

Image by Author

***Task:*Spark 中最小的工作单元，由一个执行者执行。

数据集提供两种类型的操作:

• ***转换:*从现有的数据集创建新的数据集。它是懒惰的，数据仍然是分布式的。
• ***动作:*动作向驱动返回数据，本质上是非分布式的。数据集上的操作触发作业。

***混洗和排序:*对数据集进行重新分区，以便对其执行操作。它是 spark 中的一个抽象，我们不需要为它编写代码。这项活动需要一个新的阶段。

常见操作和转换

1) lit，geq，leq，gt，lt

lit:创建一个文字值列。可用于与其他列进行比较。

geq(大于等于)，leq(小于等于)，gt(大于)，lt(小于):用于与其他列值进行比较。例如:

2)加入

Spark 允许我们以各种方式连接数据集。我将试着用一个例子来解释

结果看起来像这样:

3)工会

Spark 联合函数让我们在两个数据集之间建立一个联合。数据集应该具有相同的模式。

4)窗户

Spark 的基本功能之一。它允许您基于一组行(称为帧*)计算表中每个输入行的返回值。*

Spark 提供了翻滚窗口、希望窗口、滑动窗口和延迟窗口的 API。

我们用它来排序、求和、普通的窗口等等。一些使用案例包括:

其他函数，如 lag 、 lead 等等，允许您进行其他操作，使您能够对数据集进行复杂的分析。

但是，如果您仍然需要对数据集执行更复杂的操作，您可以使用 UDF。UDF 的用法示例:

注意:使用 UDF 应该是最后的手段，因为它们不是为 Spark 优化的；他们可能需要更长的时间来执行死刑。建议在 UDF 上使用本机 spark 函数。

这只是 Apache Spark 的冰山一角。它的应用扩展到各个领域，不仅限于数据分析。请关注此空间了解更多信息。

参考

• https://www.youtube.com/watch?v=AYZCpxYVxH4&list = plkz 1 SCF 5 IB 4d xipdfd 4 hxwhergrwhmd 6k
• https://stack overflow . com/questions/37871194/how-to-tune-spark-executor-number-cores-and-executor-memory
• https://medium . com/@ farox 2q/UDFs-vs-map-vs-custom-spark-native-functions-91 ab 2c 154 b 44
• https://stack overflow . com/questions/45990633/what-the-variable-join-types-in-spark

使用 AWS Glue、RDS 和 S3 在 Amazon EMR 上开始使用 Apache Zeppelin

原文：https://towardsdatascience.com/getting-started-with-apache-zeppelin-on-amazon-emr-using-aws-glue-rds-and-s3-2b5d231a788a?source=collection_archive---------21-----------------------

使用一系列预制的 Zeppelin 笔记本，探索在 Amazon EMR 上使用 Apache Zeppelin 进行数据分析和数据科学。

介绍

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

(courtesy Google Trends and Plotly)

技术

所有三大云提供商，亚马逊网络服务(AWS)、微软 Azure 和谷歌云，都拥有快速成熟的大数据分析、数据科学以及人工智能和人工智能服务。例如，AWS 在 2009 年推出了Amazon Elastic MapReduce(EMR)，主要作为基于 Apache Hadoop 的大数据处理服务。据亚马逊称，从那时起，EMR 已经发展成为一种服务，它使用 Apache Spark 、 Apache Hadoop 和其他几个领先的开源框架来快速、经济高效地处理和分析大量数据。最近，在 2017 年末，亚马逊发布了 SageMaker ，这是一项提供快速安全地构建、训练和部署机器学习模型的能力的服务。

同时，组织正在构建集成和增强这些基于云的大数据分析、数据科学、人工智能和 ML 服务的解决方案。一个这样的例子是阿帕奇齐柏林飞艇。类似于非常受欢迎的项目 Jupyter 和新近开源的网飞的 Polynote ，Apache Zeppelin 是一个基于网络的多语言计算笔记本。Zeppelin 使用大量的解释器，如 Scala、Python、Spark SQL、JDBC、Markdown 和 Shell，实现了数据驱动的交互式数据分析和文档协作。Zeppelin 是亚马逊 EMR 原生支持的核心应用之一。

Example of an Apache Zeppelin Notebook Paragraph

在接下来的文章中，我们将使用一系列 Zeppelin 笔记本，探索在 EMR 上使用 Apache Zeppelin 进行数据分析和数据科学。这些笔记本电脑使用了 AWS Glue ，这是一种完全托管的提取、转换和加载(ETL)服务，可以轻松准备和加载数据以进行分析。这些笔记本还采用了针对 PostgreSQL 的亚马逊关系数据库服务 (RDS)和亚马逊简单云存储服务 (S3)。亚马逊 S3 将作为一个数据湖来存储我们的非结构化数据。鉴于目前 Zeppelin 的二十多个不同的解释器的选择，我们将为所有笔记本使用 Python3 和 Apache Spark ，具体来说就是 Spark SQL 和 PySpark 。

Featured Technologies

我们将构建一个经济的单节点 EMR 集群来进行数据探索，以及一个更大的多节点 EMR 集群来高效地分析大型数据集。亚马逊 S3 将用于存储输入和输出数据，而中间结果存储在 EMR 集群上的 Hadoop 分布式文件系统 (HDFS)中。亚马逊提供了一个很好的概述 EMR 架构。下面是我们将为本次演示构建的基础架构的高级架构图。

High-level AWS Architecture

笔记本功能

下面是每个 Zeppelin 笔记本的简要概述，并带有链接，可以使用 Zepl 的免费笔记本浏览器进行查看。Zepl 由开发阿帕奇齐柏林飞艇的同一批工程师创建，包括阿帕奇齐柏林飞艇的首席技术官兼创造者 Moonsoo Lee。Zepl 的企业协作平台建立在 Apache Zeppelin 的基础上，使数据科学和 AI/ML 团队能够围绕数据进行协作。

笔记本 1

第一个笔记本使用一个小的 21k 行 kaggle 数据集，来自面包店的交易。该笔记本展示了 Zeppelin 与 Helium 插件系统的集成能力，用于添加新的图表类型，使用亚马逊 S3 进行数据存储和检索，使用 Apache Parquet ，一种压缩和高效的列数据存储格式，以及 Zeppelin 与 GitHub 的存储集成，用于笔记本版本控制。

笔记本 2

第二本笔记本演示了使用单节点和多节点亚马逊 EMR 集群，使用 Zeppelin 探索和分析从大约 100k 行到 27MM 行的公共数据集。我们将使用最新的 GroupLens MovieLens 评级数据集，在单节点和多节点 EMR 集群上使用 Spark 来检查 Zeppelin 的性能特征，以便使用各种 Amazon EC2 实例类型来分析大数据。

笔记本 3

第三个笔记本展示了亚马逊 EMR 和 Zeppelin 的集成能力，其中一个 AWS Glue 数据目录作为兼容 Apache Hive 的metastoreforSpark SQL。我们将使用 AWS Glue 数据目录和一组 AWS Glue 爬虫创建一个基于亚马逊 S3 的数据湖。

笔记本 4

第四个笔记本展示了 Zeppelin 与外部数据源集成的能力。在这种情况下，我们将使用三种方法与 Amazon RDS PostgreSQL 关系数据库中的数据进行交互，包括用于 Python 的 Psycopg 2 PostgreSQL 适配器、Spark 的原生 JDBC 功能和 Zeppelin 的 JDBC 解释器。

示范

首先，作为一名数据操作工程师，我们将使用 AWS Glue 数据目录、Amazon RDS PostgreSQL 数据库和基于 S3 的数据湖，创建和配置演示在 EMR 上使用 Apache Zeppelin 所需的 AWS 资源。设置完成后，作为数据分析师，我们将使用预构建的 Zeppelin 笔记本电脑探索 Apache Zeppelin 的功能以及与各种 AWS 服务的集成能力。

源代码

演示的源代码包含在两个公共的 GitHub 存储库中。第一个存储库， zeppelin-emr-demo ，包括四个预建的 zeppelin 笔记本，根据 Zeppelin 的可插拔笔记本存储机制的惯例进行组织。

.
├── 2ERVVKTCG
│   └── note.json
├── 2ERYY923A
│   └── note.json
├── 2ESH8DGFS
│   └── note.json
├── 2EUZKQXX7
│   └── note.json
├── LICENSE
└── README.md

齐柏林 GitHub 存储

在演示过程中，当提交发生时，对运行在 EMR 上的 Zeppelin 笔记本副本所做的更改将自动推回到 GitHub。为了实现这一点，不仅仅是克隆 zeppelin-emr-demo 项目存储库的本地副本，您还需要在您的个人 GitHub 帐户中有自己的副本。您可以派生 zeppelin-emr-demo GitHub 存储库，或者将一个克隆拷贝到您自己的 GitHub 存储库中。

要在您自己的 GitHub 帐户中创建项目的副本，首先，在 GitHub 上创建一个新的空存储库，例如，“my-zeppelin-emr-demo-copy”。然后，从您的终端执行以下命令，将原始项目存储库克隆到您的本地环境，最后，将其推送到您的 GitHub 帐户。

GitHub 个人访问令牌

为了在提交时自动将更改推送到 GitHub 存储库，Zeppelin 将需要一个 GitHub 个人访问令牌。创建一个个人访问令牌，其范围如下所示。一定要保守令牌的秘密。确保不要意外地将令牌值签入 GitHub 上的源代码。为了最大限度地降低风险，请在完成演示后立即更改或删除令牌。

GitHub Developer Settings — Personal Access Tokens

第二个存储库 zeppelin-emr-config ，包含必要的引导文件、CloudFormation 模板和 PostgreSQL DDL(数据定义语言)SQL 脚本。

.
├── LICENSE
├── README.md
├── bootstrap
│   ├── bootstrap.sh
│   ├── emr-config.json
│   ├── helium.json
├── cloudformation
│   ├── crawler.yml
│   ├── emr_single_node.yml
│   ├── emr_cluster.yml
│   └── rds_postgres.yml
└── sql
    └── ratings.sql

使用以下 AWS CLI 命令将 GitHub 存储库克隆到您的本地环境中。

要求

为了进行演示，您将需要一个 AWS 帐户、一个现有的亚马逊 S3 桶来存储 EMR 配置和数据，以及一个 EC2 密钥对。您还需要在您的工作环境中安装最新版本的 AWS CLI 。由于我们将使用特定的 EMR 功能，我建议使用us-east-1 AWS 区域来创建演示资源。

S3 的配置文件

首先，将三个配置文件， bootstrap.sh 、 helium.json 和 ratings.sql ，从zeppelin-emr-demo-setup项目目录复制到我们的 S3 存储桶。更改ZEPPELIN_DEMO_BUCKET变量值，然后使用 AWS CLI 运行下面的s3 cp API 命令。这三个文件将被复制到 S3 存储桶内的引导目录中。

下面是将本地文件复制到 S3 的示例输出。

Copy Configuration Files to S3

创建 AWS 资源

我们将首先使用三个 AWS CloudFormation 模板创建演示所需的大部分 AWS 资源。我们将创建一个单节点 Amazon EMR 集群、一个 Amazon RDS PostgresSQL 数据库、一个 AWS Glue 数据目录数据库、两个 AWS Glue 爬虫和一个 Glue IAM 角色。由于在集群中运行大型 EC2 实例的计算成本，我们将等待创建多节点 EMR 集群。在继续之前，您应该了解这些资源的成本，并确保在演示完成后立即销毁这些资源，以最大限度地减少您的开支。

单节点 EMR 集群

我们将从创建单节点 Amazon EMR 集群开始，它只包含一个主节点，没有核心或任务节点(一个集群)。所有操作都将在主节点上进行。

默认 EMR 资源

以下 EMR 说明假设您过去已经在当前 AWS 区域使用带有“创建集群—快速选项”选项的 EMR web 界面创建了至少一个 EMR 集群。以这种方式创建集群会创建几个额外的 AWS 资源，比如EMR_EC2_DefaultRole EC2 实例概要、默认的EMR_DefaultRole EMR IAM 角色和默认的 EMR S3 日志存储桶。

EMR — AWS Console

如果您过去没有使用 EMR 的“创建集群-快速选项”功能创建任何 EMR 集群，请不要担心。您还可以使用一些快速的 AWS CLI 命令来创建所需的资源。更改下面的LOG_BUCKET变量值，然后使用 AWS CLI 运行aws emr和aws s3api API 命令。LOG_BUCKET变量值遵循aws-logs-awsaccount-region的惯例。比如aws-logs-012345678901-us-east-1。

可以在 IAM 角色 web 界面中查看新的 EMR IAM 角色。

IAM Management Console

我经常看到从 AWS CLI 或 CloudFormation 引用这些默认 EMR 资源的教程，而没有对它们是如何创建的任何理解或解释。

EMR 引导脚本

作为创建 EMR 集群的一部分，云模板 emr_single_node.yml 将调用我们之前复制到 S3 的引导脚本 bootstrap.sh 。bootstrap 脚本预装了所需的 Python 和 Linux 软件包，以及 PostgreSQL 驱动程序 JAR 。引导脚本还会克隆您的 zeppelin-emr-demo GitHub 存储库副本。

EMR 应用程序配置

EMR CloudFormation 模板还将修改 EMR 集群的 Spark 和 Zeppelin 应用程序配置。在其他配置属性中，模板将默认 Python 版本设置为 Python3，指示 Zeppelin 使用克隆的 GitHub 笔记本目录路径，并将 PostgreSQL 驱动程序 JAR 添加到 JVM 类路径中。下面我们可以看到应用于现有 EMR 集群的配置属性。

EMR — AWS Console

EMR 应用程序版本

截至本文发布之日(2019 年 12 月)，EMR 的版本为 5.28.0 。如 EMR web 界面所示，下面是可安装在 EMR 上的当前(21)个应用程序和框架。

对于这个演示，我们将安装 Apache Spark v2.4.4、 Ganglia v3.7.2 和 Zeppelin 0.8.2。

Apache Zeppelin: Web Interface

Apache Spark: DAG Visualization

Ganglia: Cluster CPU Monitoring

创建 EMR 云信息堆栈

更改以下(7)个变量值，然后使用 AWS CLI 运行emr cloudformation create-stack API 命令。

您可以使用 Amazon EMR web 界面来确认 CloudFormation 堆栈的结果。集群应该处于“等待”状态。

EMR — AWS Console

亚马逊 RDS 上的 PostgreSQL

接下来，使用包含的 CloudFormation 模板 rds_postgres.yml ，创建一个简单的、单 AZ、单主、非复制的 Amazon RDS PostgreSQL 数据库。我们将在笔记本 4 中使用该数据库。对于演示，我选择了当前通用的db.m4.large EC2 实例类型来运行 PostgreSQL。您可以轻松地将实例类型更改为另一个支持 RDS 的实例类型，以满足您的特定需求。

更改以下(3)个变量值，然后使用 AWS CLI 运行cloudformation create-stack API 命令。

您可以使用 Amazon RDS web 界面来确认 CloudFormation 堆栈的结果。

RDS — AWS Console

AWS 胶水

接下来，使用包含的 CloudFormation 模板 crawler.yml 创建 AWS Glue 数据目录数据库、Apache Hive 兼容的 metastore for Spark SQL、两个 AWS Glue Crawlers 和一个 Glue IAM 角色(ZeppelinDemoCrawlerRole)。AWS 胶水数据目录数据库将在笔记本 3 中使用。

更改以下变量值，然后使用 AWS CLI 运行cloudformation create-stack API 命令。

您可以使用 AWS Glue web 界面来确认 CloudFormation 堆栈的结果。注意数据目录数据库和两个 Glue Crawlers。我们不会在后面的文章中运行这两个爬虫。因此，数据目录数据库中还不存在任何表。

AWS Glue Console

AWS Glue Console

至此，您应该已经成功创建了一个单节点 Amazon EMR 集群、一个 Amazon RDS PostgresSQL 数据库和几个 AWS Glue 资源，所有这些都使用了 CloudFormation 模板。

CloudFormation — AWS Console

EMR 创建后配置

RDS 安全性

为了让新的 EMR 集群与 RDS PostgreSQL 数据库通信，我们需要确保从 RDS 数据库的 VPC 安全组(默认的 VPC 安全组)到 EMR 节点的安全组的端口 5432 是开放的。从 EMR web 界面或使用 AWS CLI 获取ElasticMapReduce-master和ElasticMapReduce-slave安全组的组 ID。

EMR — AWS Console

使用 RDS web 界面访问 RDS 数据库的安全组。将端口 5432 的入站规则更改为包含两个安全组 id。

EC2 Management Console

到 EMR 主节点的 SSH

除了引导脚本和配置之外，我们已经应用于 EMR 集群，我们需要对 EMR 集群进行一些 EMR 创建后配置更改，以便进行演示。这些变化需要使用 SSH 连接到 EMR 集群。使用主节点的公共 DNS 地址和 EMR web 控制台中提供的 SSH 命令，SSH 进入主节点。

EMR — AWS Console

如果您无法使用 SSH 访问节点，请检查相关 EMR 主节点 IAM 安全组(ElasticMapReduce-master)上的端口 22 是否对您的 IP 地址或地址范围开放。

EMR — AWS Console

EC2 Management Console

Git 权限

我们需要更改在 EMR 引导阶段安装的 git 存储库的权限。通常，对于 EC2 实例，您作为ec2-user用户执行操作。使用 Amazon EMR，您经常以hadoop用户的身份执行操作。使用 EMR 上的 Zeppelin，笔记本执行操作，包括作为zeppelin用户与 git 存储库交互。作为 bootstrap.sh 脚本的结果，默认情况下，git 存储库目录/tmp/zeppelin-emr-demo/的内容归hadoop用户和组所有。

Git Clone Project Permissions on EMR Master Node

我们将把他们的所有者改为zeppelin用户和组。我们无法将此步骤作为引导脚本的一部分来执行，因为在脚本执行时不存在zeppelin用户和组。

cd /tmp/zeppelin-emr-demo/
sudo chown -R zeppelin:zeppelin .

结果应该类似于下面的输出。

Git Clone Project Permissions on EMR Master Node

预安装可视化软件包

接下来，我们将预装几个 Apache Zeppelin 可视化软件包。据 Zeppelin 网站介绍，Apache Zeppelin 可视化是一个可插拔的包，可以在运行时通过 Zeppelin 中的氦框架加载和卸载。我们可以像使用笔记本中的任何其他内置可视化一样使用它们。可视化是一个 javascript npm 包。例如，这里有一个公共 npm 注册表上的最终饼状图的链接。

我们可以通过用之前复制到 S3 的 helium.json 版本替换/usr/lib/zeppelin/conf/helium.json文件，并重启 Zeppelin 来预加载插件。如果您有很多可视化或包类型，或者使用任何 DataOps 自动化来创建 EMR 集群，这种方法比每次创建新的 EMR 集群时使用 Zeppelin UI 手动加载插件更有效且可重复。下面是helium.json文件，它预加载了 8 个可视化包。

运行以下命令来加载插件并调整文件的权限。

创建新的 JDBC 解释器

最后，我们需要创建一个新的齐柏林 JDBC 解释器来连接到我们的 RDS 数据库。默认情况下，Zeppelin 安装了几个解释器。您可以使用以下命令查看可用解释器的列表。

sudo sh /usr/lib/zeppelin/bin/install-interpreter.sh --list

List of Installed Interpreters

新的 JDBC 解释器将允许我们使用 Java 数据库连接 (JDBC)连接到我们的 RDS PostgreSQL 数据库。首先，确保安装了所有可用的解释器，包括当前的齐柏林 JDBC 驱动程序(org.apache.zeppelin:zeppelin-jdbc:0.8.0)到/usr/lib/zeppelin/interpreter/jdbc。

创建一个新的解释器是一个两部分的过程。在这个阶段，我们使用下面的命令在主节点上安装所需的解释器文件。然后，在 Zeppelin web 界面中，我们将配置新的 PostgreSQL JDBC 解释器。注意，我们必须为解释器提供一个唯一的名称(即‘postgres’)，我们将在解释器创建过程的第二部分中引用这个名称。

为了在主节点上完成后 EMR 创建配置，我们必须重新启动 Zeppelin 以使我们的更改生效。

sudo stop zeppelin && sudo start zeppelin

根据我的经验，重启后 Zeppelin UI 可能需要 2-3 分钟才能完全响应。

Restarting Zeppelin

Zeppelin Web 界面访问

随着所有 EMR 应用程序配置的完成，我们将访问运行在主节点上的 Zeppelin web 界面。使用 EMR web 界面中提供的 Zeppelin 连接信息来设置 SSH 隧道到 Zeppelin web 界面，在主节点上运行。使用 SSH 隧道，我们还可以访问 Spark 历史服务器、Ganglia 和 Hadoop 资源管理器 web 界面。所有链接都是从 EMR web 控制台提供的。

EMR — AWS Console

为了建立到 EMR 集群上安装的应用程序的 web 连接，我使用了 FoxyProxy 作为 Google Chrome 的代理管理工具。

EMR — Enable Web Connection

如果到目前为止一切正常，您应该会看到 Zeppelin web 界面，其中包含了从克隆的 GitHub 存储库中获得的所有四个 Zeppelin 笔记本。您将作为anonymous用户登录。Zeppelin 为访问 EMR 集群上的笔记本提供了身份验证。为了简洁起见，我们将不讨论在 Zeppelin 中使用 Shiro 认证来设置认证。

Apache Zeppelin Landing Page

笔记本路径

要确认 GitHub 笔记本存储库的本地克隆副本的路径是否正确，请检查笔记本存储库界面，该界面可在屏幕右上角的设置下拉菜单(anonymous用户)下访问。该值应该与我们之前执行的EMR _ single _ node . ymlcloud formation 模板中的ZEPPELIN_NOTEBOOK_DIR配置属性值相匹配。

Apache Zeppelin GitHub Notebook Repository

氦可视化

为了确认氦可视化已正确预安装，使用氦. json 文件，打开氦界面，可在屏幕右上角的设置下拉菜单(anonymous用户)下访问。

Apache Zeppelin — Available Helium Visualizations

请注意启用的可视化。而且，通过 web 界面启用附加插件也很容易。

Apache Zeppelin — Enabled Helium Visualizations

新的 PostgreSQL JDBC 解释器

如果您还记得，在前面，我们使用下面的命令和引导脚本在主节点上安装了所需的解释器文件。我们现在将完成配置新的 PostgreSQL JDBC 解释器的过程。打开口译员界面，可通过屏幕右上角的设置下拉菜单(anonymous用户)进入。

新解释器的名称必须与我们用来安装解释器文件的名称“postgres”相匹配。解释器组将是“jdbc”。我们至少需要为您的特定 RDS 数据库实例配置三个属性，包括default.url、default.user和default.password。这些值应该与前面创建 RDS 实例时使用的值相匹配。确保在default.url中包含数据库名称。下面是一个例子。

我们还需要提供 PostgreSQL 驱动程序 JAR 依赖项的路径。这个路径是我们之前使用 bootstrap.sh 脚本/home/hadoop/extrajars/postgresql-42.2.8.jar放置 JAR 的位置。保存新的解释器并确保它成功启动(显示绿色图标)。

Configuring the PostgreSQL JDBC Interpreter

Configuring the PostgreSQL JDBC Interpreter

将解释器切换到 Python 3

我们需要做的最后一件事是改变 Spark 和 Python 解释器，使用 Python 3 而不是默认的 Python 2。在用于创建新解释器的同一个屏幕上，修改 Spark 和 Python 解释器。首先，对于 Python 解释器，将zeppelin.python属性改为python3。

Setting Interpreters to Python 3

最后，对于 Spark 解释器，将zeppelin.pyspark.python属性更改为python3。

Setting Interpreters to Python 3

祝贺您，随着演示设置的完成，我们已经准备好开始使用我们的四个笔记本中的每一个来探索 Apache Zeppelin。

笔记本 1

第一个笔记本使用一个小的 21k 行 kaggle 数据集，来自面包店的交易。该笔记本展示了 Zeppelin 与 Helium 插件系统的集成能力，用于添加新的图表类型，使用亚马逊 S3 进行数据存储和检索，使用 Apache Parquet ，一种压缩和高效的列数据存储格式，以及 Zeppelin 与 GitHub 的存储集成，用于笔记本版本控制。

解释程序

当您第一次打开一个笔记本时，您可以选择绑定和解除绑定到笔记本的解释器。下面显示的列表中的最后一个解释器postgres，是我们在帖子前面创建的新的 PostgreSQL JDBC Zeppelin 解释器。我们将在笔记本 3 中使用这个解释器。

应用程序版本

笔记本的前两段用来确认我们正在使用的 Spark、Scala、OpenJDK、Python 的版本。回想一下，我们更新了 Spark 和 Python 解释器以使用 Python 3。

氦可视化

如果你记得在这篇文章的前面，我们预装了几个额外的氦可视化，包括终极饼状图。下面，我们看到使用 Spark SQL ( %sql)解释器来查询 Spark 数据帧，返回结果，并使用最终的饼图来可视化数据。除了饼图之外，我们还可以在菜单栏中看到其他预安装的氦可视化，它们位于五个默认可视化之前。

有了 Zeppelin，我们所要做的就是针对之前在笔记本中创建的 Spark 数据帧编写 Spark SQL 查询，Zeppelin 将处理可视化。您可以使用“设置”下拉选项对图表进行一些基本控制。

构建数据湖

笔记本 1 演示了如何向 S3 读写数据。我们使用 Spark (PySpark)将面包店数据集读写为 CSV 格式和 Apache Parquet 格式。我们还将 Spark SQL 查询的结果写入 S3 的 Parquet 中，如上图所示。

S3 Management Console

使用 Parquet，数据可以被分割成多个文件，如下面的 S3 桶目录所示。Parquet 比 CSV 更快地读入 Spark 数据帧。Spark 支持读写拼花文件。我们将把我们所有的数据写到 S3 的 Parquet 上，这使得未来数据的重复使用比从互联网上下载数据(如 GroupLens 或 kaggle)或从 S3 消费 CSV 文件更有效率。

Paquet-Format Files in S3

预览 S3 数据

除了使用 Zeppelin 笔记本，我们还可以使用亚马逊 S3 选择 T2 功能在 S3 木桶网络界面上预览数据。这个就地查询特性有助于快速理解您想要在 Zeppelin 中与之交互的新数据文件的结构和内容。

Previewing Data in S3 using the ‘Select from’ Feature

Previewing Data in S3 using the ‘Select from’ Feature

Previewing Data in S3 using the ‘Select from’ Feature

将更改保存到 GitHub

之前，我们将 Zeppelin 配置为从您自己的 GitHub 笔记本存储库中读取和写入笔记本。使用“版本控制”菜单项，对笔记本所做的更改可以直接提交到 GitHub。

在 GitHub 中，注意提交者是zeppelin用户。

Commits in GitHub

笔记本 2

第二本笔记本演示了使用单节点和多节点 Amazon EMR 集群，使用 Zeppelin 探索和分析从大约 100k 行到 27MM 行的公共数据集。我们将使用最新的 GroupLens MovieLens 评级数据集，在单节点和多节点 EMR 集群上使用 Spark 来检查 Zeppelin 的性能特征，以便使用各种 Amazon EC2 实例类型来分析大数据。

多节点 EMR 集群

如果您还记得，我们等待创建多节点集群是因为运行集群的大型 EC2 实例的计算成本。在继续之前，您应该了解这些资源的成本，并确保在演示完成后立即销毁这些资源，以最大限度地减少您的开支。

标准化实例小时数

理解 EMR 的成本需要理解标准化实例时间的概念。EMR AWS 控制台中显示的集群包含两列，“运行时间”和“标准化实例小时数”。“已用时间”列反映了使用集群的实际挂钟时间。“标准化实例小时数”列指示群集已使用的计算小时数的近似值，四舍五入到最接近的小时数。

EMR — AWS Console: Normalized Instance Hours

标准化实例小时数的计算基于一个标准化因子。规范化因子的范围从小型实例的 1 到大型实例的 64。根据我们多节点集群中实例的类型和数量，我们将每一个小时的挂钟时间使用大约 56 个计算小时(也称为标准化实例小时)。请注意我们的演示中使用的多节点集群，上面以黄色突出显示。集群运行了两个小时，相当于 112 个标准化实例小时。

创建多节点集群

使用 CloudFormation 创建多节点 EMR 集群。更改以下九个变量值，然后使用 AWS CLI 运行emr cloudformation create-stack API 命令。

使用 Amazon EMR web 界面来确认 CloudFormation 堆栈的成功。准备就绪时，完全调配的群集应处于“等待”状态。

EMR — AWS Console

配置 EMR 集群

继续之前，请参考前面的单节点集群说明，了解准备 EMR 集群和 Zeppelin 所需的配置步骤。重复用于单节点集群的所有步骤。

使用 Ganglia 进行监控

之前，我们在创建 EMR 集群时安装了 Ganglia。 Ganglia ，据其网站介绍，是一个可扩展的分布式监控系统，用于集群和网格等高性能计算系统。Ganglia 可用于评估单节点和多节点 EMR 集群的性能。使用 Ganglia，我们可以轻松查看集群和单个实例的 CPU、内存和网络 I/O 性能。

Ganglia Example: Cluster CPU

Ganglia Example: Cluster Memory

Ganglia Example: Cluster Network I/O

纱线资源经理

我们的 EMR 集群也提供纱线资源管理器网络用户界面。使用资源管理器，我们可以查看集群上的计算资源负载，以及各个 EMR 核心节点。下面，我们看到多节点集群有 24 个 vCPUs 和 72 GiB 可用内存，平均分布在三个核心集群节点上。

您可能还记得，用于三个核心节点的 m5.2xlarge EC2 实例类型，每个包含 8 个 vCPUs 和 32 GiB 内存。然而，通过默认，尽管每个节点的所有 8 个虚拟 CPU 都可用于计算，但是节点的 32 GiB 内存中只有 24 GiB 可用于计算。EMR 确保每个节点上都有一部分内存保留给其他系统进程。最大可用内存由纱线内存配置选项yarn.scheduler.maximum-allocation-mb控制。

YARN Resource Manager

上面的纱线资源管理器预览显示了 Notebook 2 在 27MM 评级的大型 MovieLens 数据帧上执行 Spark SQL 查询时代码节点上的负载。请注意，24 个 vCPUs 中只有 4 个(16.6%)正在使用，但 72 GiB (97.6%)可用内存中有 70.25%正在使用。根据 Spark 的说法，由于大多数 Spark 计算的内存性质，Spark 程序可能会受到集群中任何资源的瓶颈:CPU、网络带宽或内存。通常，如果数据适合内存，瓶颈是网络带宽。在这种情况下，内存似乎是最受限制的资源。使用内存优化的实例，比如 r4 或 r5 实例类型，对于核心节点可能比 m5 实例类型更有效。

电影镜头数据集

通过更改笔记本中的一个变量，我们可以使用最新的、更小的 GroupLens MovieLens 数据集，包含大约 100k 行(ml-latest-small)或更大的数据集，包含大约 2700 万行(ml-latest)。对于本演示，请在单节点和多节点集群上尝试这两个数据集。比较四个变量中每个变量的 Spark SQL 段落执行时间，包括 1)小数据集的单节点，2)大数据集的单节点，3)小数据集的多节点，以及 4)大数据集的多节点。观察 SQL 查询在单节点集群和多节点集群上的执行速度。尝试切换到不同的核心节点实例类型，例如 r5.2xlarge。计算时间是如何实现的？

在继续笔记本 3 之前，终止多节点 EMR 群集以节省您的费用。

aws cloudformation delete-stack --stack-name=zeppelin-emr-prod-stack

笔记本 3

第三个笔记本展示了亚马逊 EMR 和 Zeppelin 与AWS Glue数据目录的集成能力，作为 Apache Hive 兼容 metastore 用于 Spark SQL 。我们将使用 AWS Glue 数据目录和一组 AWS Glue 爬虫创建一个基于亚马逊 S3 的数据湖。

胶粘履带车

在继续使用 Notebook 3 之前，使用 AWS CLI 启动两个 Glue 爬虫。

aws glue start-crawler --name bakery-transactions-crawler
aws glue start-crawler --name movie-ratings-crawler

这两个爬行器应该在 Glue 数据目录数据库中创建总共七个表。

AWS Glue Console: Crawlers

如果我们检查 Glue 数据目录数据库，我们现在应该观察几个表，每个表对应于在 S3 桶中找到的一个数据集。每个数据集的位置显示在表视图的“位置”列中。

AWS Glue Console: Data Catalog Tables

从 Zeppelin 笔记本中，我们甚至可以使用 Spark SQL 来查询 AWS Glue 数据目录本身，以获得其数据库和其中的表。

根据亚马逊的说法，粘合数据目录表和数据库是元数据定义的容器，这些元数据定义定义了底层源数据的模式。使用 Zeppelin 的 SQL 解释器，我们可以查询数据目录的元数据并返回底层的源数据。下面的 SQL 查询示例演示了如何跨数据目录数据库中的两个表执行连接，这两个表代表两个不同的数据源，并返回结果。

笔记本 4

第四个笔记本展示了 Zeppelin 与外部数据源整合的能力。在这种情况下，我们将使用三种方法与 Amazon RDS PostgreSQL 关系数据库中的数据进行交互，包括用于 Python 的 Psycopg 2 PostgreSQL 适配器、Spark 的原生 JDBC 功能和 Zeppelin 的 JDBC 解释器。

心理战

首先，使用 Psycopg 2 PostgreSQL adapter for Python 和 SQL 文件为 RDS PostgreSQL movie ratings 数据库创建一个新的数据库模式和四个相关的表，我们之前已经将该文件复制到了 S3。

RDS 数据库的模式如下所示，近似于我们在笔记本 2 中使用的 GroupLens MovieLens 评级数据集的四个 CSV 文件的模式。

MovieLens Relational Database Schema

由于 PostgreSQL 数据库的模式与 MovieLens 数据集文件相匹配，我们可以将从 GroupLens 下载的 CVS 文件中的数据直接导入到 RDS 数据库中，再次使用PsycopgPostgreSQL adapter for Python。

火花 JDBC

根据 Spark 文档，Spark SQL 还包括一个数据源，可以使用 JDBC 从其他数据库读取数据。使用 Spark 的 JDBC 功能和我们之前安装的 PostgreSQL JDBC 驱动程序，在安装期间，我们可以使用 PySpark ( %spark.pyspark)对 RDS 数据库执行 Spark SQL 查询。下面，我们看到一个使用 Spark 读取 RDS 数据库的movies表的例子。

Zeppelin PostgreSQL 解释程序

作为查询 RDS 数据库的第三种方法，我们可以使用我们之前创建的定制 Zeppelin PostgreSQL JDBC 解释器(%postgres)。尽管 JDBC 解释器的默认驱动程序被设置为 PostgreSQL，并且相关的 JAR 包含在 Zeppelin 中，但是我们用最新的 PostgreSQL JDBC 驱动程序 JAR 覆盖了旧的 JAR。

使用%postgres解释器，我们查询 RDS 数据库的public模式，并返回我们之前在笔记本中创建的四个数据库表。

动态表单

使用笔记本段落中的%postgres解释器，我们查询 RDS 数据库并返回数据，然后使用 Zeppelin 的条形图可视化这些数据。最后，注意这个例子中 Zeppelin 动态形式的使用。动态表单允许 Zeppelin 动态地创建输入表单，然后可以通过编程使用表单的输入值。笔记本使用两个表单输入值来控制从我们的查询返回的数据和结果可视化。

结论

在这篇文章中，我们了解了 Apache Zeppelin 如何有效地与 Amazon EMR 集成。我们还学习了如何使用 AWS Glue、亚马逊 RDS 和亚马逊 S3 作为数据湖来扩展 Zeppelin 的功能。除了这篇文章中提到的，还有几十个 Zeppelin 和 EMR 特性，以及几十个与 Zeppelin 和 EMR 集成的 AWS 服务，供您探索。

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

增强现实和虚拟现实入门

原文：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]:

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

增强现实可以用于许多不同的环境和应用中。例如，今年夏天我决定创建一张个人 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 个主要部分:

1. 加载本例所需的所有库/依赖项。
2. 加载要使用的图像并对其进行预处理以适应虚拟环境。
3. 向图像添加动画。
4. 添加欢迎用户使用应用程序的文本横幅。
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 人口。另一方面，幼儿园数据集是坐标点格式，包含全国幼儿园的地址。在对两个数据集进行简短的探索性数据分析后，我们将执行预处理和空间连接地理处理任务来合并两个数据集。这是统计每个地区幼儿园数量的路线图。

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

最后，我们将进行探索性空间数据分析(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

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

空间连接

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

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

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

因此，如果我们现在查看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 文件都是非常困难的，因此最好了解一下您将要处理的文件格式的类型。有一些常见的和不常见的格式，让我们了解一下它们是什么，它们是如何工作的。

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

栅格数据

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

Image source

栅格数据的格式

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

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

数据源

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

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

可视化工具

包装

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

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

开源软件

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

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

感谢阅读！

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