TowardsDataScience 博客中文翻译 2020（八百一十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

分步指南-用 Python 构建预测模型

原文：https://towardsdatascience.com/step-by-step-guide-building-a-prediction-model-in-python-ac441e8b9e8b?source=collection_archive---------1-----------------------

使用长短期记忆预测模型的动手练习

在 Unsplash 上由 Austin Distel 拍摄的照片

**来自《走向数据科学》编辑的提示:**虽然我们允许独立作者根据我们的规则和指导方针发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的读者术语。

在这篇文章中，我将向你展示如何构建一个可以预测特定股票价格的程序。这是一个在金融领域使用机器学习的伟大工程。如果我们想要一台机器为我们做预测，我们肯定应该用一些数据好好训练它。首先，对于刚接触 python 的人，我将向您介绍一下。然后，我们将开始研究我们的预测模型。正如副标题中提到的，我们将使用苹果股票数据。如果你想知道是否可以免费获得这些数据，答案是肯定的。股票数据可以在纳斯达克官方网站上找到。纳斯达克(全美证券交易商自动报价协会)是一个电子股票交易所，拥有 3300 多家上市公司。

苹果股票数据可以从这里下载。在这个网站上，你还可以找到不同公司的股票数据，并使用不同的数据集练习你的技能。我迫不及待地想看到我们的预测准确性结果，让我们开始吧！

目录:

• Python
• 图书馆
• 了解苹果股票数据
• 数据操作
• 数据可视化
• LSTM 预测模型

计算机编程语言

Python 是一种通用编程语言，在分析数据方面越来越受欢迎。Python 还能让您快速工作，更有效地集成系统。世界各地的公司都在利用 Python 从他们的数据中收集知识。Python 官方页面如果你想了解更多。

[## 面向金融的 Python 完全初学者指南

使用亚马逊股票数据的简单实践

towardsdatascience.com](/python-for-finance-the-complete-beginners-guide-764276d74cef)

图书馆

首先，我们必须安装一些库，这样我们的程序才能工作。下面是我们将要安装的库的列表:pandas、numpy、keras 和 tensorflow。必须安装 Tensorflow，keras 才能工作。

Keras 是为人类设计的 API，不是为机器设计的。Keras 遵循减少认知负荷的最佳实践:它提供一致而简单的 API，最大限度地减少常见用例所需的用户操作数量，并提供清晰可操作的错误消息。它还有大量的文档和开发人员指南。

参考: https://keras.io

我们可以使用 Pip 库管理器安装这些库:

pip install pandas numpy keras tensorflow

安装完成后，让我们将它们导入到代码编辑器中。Python 中已经包含了 Matplotlib，这就是为什么我们不用安装就可以导入它。

import pandas as pd
import numpy as npimport matplotlib.pyplot as plt
%matplotlib inline
from matplotlib.pylab import rcParams
rcParams['figure.figsize']=20,10from keras.models import Sequential
from keras.layers import LSTM,Dropout,Densefrom sklearn.preprocessing import MinMaxScaler

了解苹果股票数据

其次，我们将开始将数据加载到一个数据帧中，在我们开始操作它之前查看它是一个好的做法。这有助于我们理解我们有正确的数据，并获得一些关于它的见解。

如前所述，在本练习中，我们将使用 Apple 的历史数据。我认为苹果会是一个很好的搭配。和我一起完成这个项目后，你会学到一些技巧，让你有能力使用不同的数据集来练习。

我们将使用的数据框架包含过去一年(2019 年 9 月 16 日-2020 年 9 月 15 日)苹果股票的收盘价。

读出数据

import pandas as pddf = pd.read_csv('aapl_stock_1yr.csv')

头部方法

为了对数据有所了解，我们要做的第一件事是使用 head 方法。当您在 dataframe 上调用 head 方法时，它会显示 dataframe 的前五行。运行这个方法后，我们还可以看到我们的数据是按日期索引排序的。

df.head()

作者图片

尾部法

另一个有用的方法我们称之为尾部方法。它显示数据帧的最后五行。假设您想查看最后七行，您可以在括号之间输入整数 7。

df.tail(7)

作者图片

现在我们对数据有了一个概念。让我们进入下一步，即数据操作，并为预测做好准备。

数据操作

子集化

正如您在前面的截图中看到的，我们的数据框架有 6 列。我们需要全部吗？当然不是。对于我们的预测项目，我们只需要“日期”和“结束/最后”列。那么让我们去掉其他的柱子吧。

df = df[['Date', 'Close']]df.head()

作者图片

数据类型

现在，让我们检查列的数据类型。因为收盘价值中有一个“$”符号，所以它可能不是 float 数据类型。当训练数据时，字符串数据类型不能用于我们的模型，所以我们必须将其转换为浮点或整数类型。

作者图片

在我们将它转换为 float 之前，让我们去掉“$”符号。否则，转换方法会给我们一个错误。

df = df.replace({'\$':''}, regex = True)

太好了！现在，我们可以将“收盘价”数据类型转换为 float。我们还将把“日期”数据转换成日期时间类型。

df = df.astype({"Close": float})df["Date"] = pd.to_datetime(df.Date, format="%m/%d/%Y")df.dtypes

作者图片

索引栏

这将是一小步。我们将数据帧的索引值定义为日期列。这将有助于数据可视化步骤。

df.index = df['Date']

数据可视化

我将与你分享一个简单的折线图，只是为了让你对过去一年的股价变化有一个概念。我们还将在最后使用可视化方法来比较我们的预测和现实。

plt.plot(df["Close"],label='Close Price history')

作者图片

LSTM 预测模型

在这一步中，我们将完成大部分编程工作。首先，我们需要对数据做一些基本的调整。当我们的数据准备好了，我们将使用它来训练我们的模型。作为神经网络模型，我们将使用 LSTM(长短期记忆)模型。当基于时间序列数据集进行预测时，LSTM 模型非常有效。

数据准备

df = df.sort_index(ascending=True,axis=0)data = pd.DataFrame(index=range(0,len(df)),columns=['Date','Close'])for i in range(0,len(data)):
    data["Date"][i]=df['Date'][i]
    data["Close"][i]=df["Close"][i]data.head()

作者图片

最小-最大缩放器

scaler=MinMaxScaler(feature_range=(0,1))data.index=data.Date
data.drop(“Date”,axis=1,inplace=True)final_data = data.values
train_data=final_data[0:200,:]
valid_data=final_data[200:,:]scaler=MinMaxScaler(feature_range=(0,1))scaled_data=scaler.fit_transform(final_data)
x_train_data,y_train_data=[],[]
for i in range(60,len(train_data)):
    x_train_data.append(scaled_data[i-60:i,0])
    y_train_data.append(scaled_data[i,0])

LSTM 模型

在这一步，我们定义了长短期记忆模型。

lstm_model=Sequential()
lstm_model.add(LSTM(units=50,return_sequences=True,input_shape=(np.shape(x_train_data)[1],1)))
lstm_model.add(LSTM(units=50))
lstm_model.add(Dense(1))model_data=data[len(data)-len(valid_data)-60:].values
model_data=model_data.reshape(-1,1)
model_data=scaler.transform(model_data)

训练和测试数据

该步骤包括列车数据和测试数据的准备。

lstm_model.compile(loss=’mean_squared_error’,optimizer=’adam’)
lstm_model.fit(x_train_data,y_train_data,epochs=1,batch_size=1,verbose=2)X_test=[]
for i in range(60,model_data.shape[0]):
    X_test.append(model_data[i-60:i,0])
X_test=np.array(X_test)
X_test=np.reshape(X_test,(X_test.shape[0],X_test.shape[1],1))

预测函数

在这一步中，我们使用在上一步中定义的测试数据来运行模型。

predicted_stock_price=lstm_model.predict(X_test)
predicted_stock_price=scaler.inverse_transform(predicted_stock_price)

预测结果

差不多了，让我们检查一下模型的准确性。我们有大约 250 行，所以我用 80%作为训练数据，20%作为测试数据。

train_data=data[:200]
valid_data=data[200:]
valid_data['Predictions']=predicted_stock_price
plt.plot(train_data["Close"])
plt.plot(valid_data[['Close',"Predictions"]])

准确性可视化(红色:实际，绿色:预测)[图片由作者提供]

[## 每当贝希克居文出版时收到电子邮件。

每当贝希克居文出版时收到电子邮件。通过注册，您将创建一个中型帐户，如果您还没有…

lifexplorer.medium.com](https://lifexplorer.medium.com/subscribe)

恭喜你。！您已经创建了一个 Python 程序来预测一家公司的股票收盘价。现在，你对如何在金融中使用机器学习有了一些想法，你应该在不同的股票上尝试一下。希望你喜欢读我的文章。从事像这样的动手编程项目是提高编码技能的最好方式。

我很高兴你今天学到了新东西。如果您在执行代码时有任何问题，请随时联系我。😊

我是贝希克·居文，我喜欢分享关于编程、教育和生活的故事。订阅我的内容，保持灵感。泰，

AWS 弹性容器服务的逐步指南(附图片)

原文：https://towardsdatascience.com/step-by-step-guide-of-aws-elastic-container-service-with-images-c258078130ce?source=collection_archive---------12-----------------------

部署您的容器并配置为访问 AWS 资源

在这篇文章中，我将展示使用 AWS ECS 部署 docker 容器的过程，并配置它来访问其他 AWS 资源。现在，让我们直接进入核心。

先决条件:对 docker，AWS 的基本了解，你需要有一个具有管理员权限的 AWS 帐户。

建造一个容器

如果您已经准备好要部署的容器，那么您可以跳过这一部分。如果没有，我写了一个最简单的 python 项目这里是，其中有 docker 容器最基本的结构:

ecs-example:
    |_ model
    |    |_ run.py
    |    |_ sample.txt
    |
    |_ docker-entrypoint.sh
    |_ Dockerfile
    |_ requirements.txt

主文件run.py驻留在model文件夹中，它所做的只是将sample.txt上传到s3 (S3 是 AWS 存储数据的简单存储系统)

docker-entrypoint.sh定义了在容器开始时运行的命令

**#!/usr/bin/env bash** export PYTHONPATH=.

python3 model/run.py

所以当容器启动时，它会调用上面写的run.py并将指定的文件加载到 s3。

现在看看我们的Dockerfile

FROM python:3.7-slim

ENV *APP_DIR* /ecs-example

RUN mkdir -p ${*APP_DIR*}

WORKDIR ${*APP_DIR*}

ADD ./requirements.txt ${*APP_DIR*}
RUN pip install -r requirements.txt

COPY ./model ${*APP_DIR*}/model
COPY ./docker-entrypoint.sh ${*APP_DIR*}/docker-entrypoint.sh

ENTRYPOINT ${*APP_DIR*}/docker-entrypoint.sh

它做以下事情，

1. 设置工作目录
2. 安装所需的软件包
3. 将本地文件复制到 docker 容器中
4. 在容器的起点设置起点

现在我们的演示项目已经设置好了，让我们构建并标记我们的容器，并将它推送到您自己的 docker hub。

在项目根目录中，执行以下操作

docker build -t ecs-example .
(Optional) docker run ecs-example

标记并推送至私有回购

docker tag ecs-example {YOUR_REPO_ACCOUNT}/ecs-example:v1
docker push {YOUR_REPO_ACCOUNT}/ecs-example:v1

现在转到您的私有 docker 注册表，您应该会在您的回购中看到它，如下所示:

现在我们已经将项目装箱并发布了，让我们开始部署吧。

在 ECS 上部署

ECS 代表弹性集装箱服务。顾名思义，这是一项专门用于管理 docker 容器的服务，但其优势在于简化了容器部署的过程，并避免了来自用户的繁重工作。简而言之，这可能是在云上部署容器的最简单的方式，并且具有适当的标准。(有关更多信息，您可以在此处阅读文档

ECS 概述

首先，去你的 AWS 控制台，搜索弹性容器服务或者仅仅是 ECS。

你开始的最快方法可能是点击首页的Get Started按钮，并遵循指导，但在这篇文章中，我们将手动构建每个组件，我相信这将使你对每个部分有更深的理解，而且对于我们的容器来说，访问 S3，它需要额外的配置，这是“开始”不允许的。

首先，我们来了解一下 ECS 中的组件，

1. 容器定义:定义你的容器镜像、环境变量、存储挂载等等。
2. 任务定义:包装你的容器，是你部署的蓝图，为你的容器指定角色，如何拉取图像等等。
3. 服务:管理要部署多少容器实例，它应该驻留在哪个网络中等等。
4. 集群:包含 VPC、子网等。

创建一个集群

首先，让我们创建一个集群。选择边栏上的集群并选择Create Cluster，

选择Networking only，并选择下一步。Networking only是为 Fargate taks 建造的。与 EC2 任务相反，

Fargate 启动类型允许您运行您的容器化应用程序，而无需供应和管理后端基础架构。当您使用与 Fargate 兼容的任务定义运行任务时，Fargate 会为您启动容器。

基本上，使用这种类型，AWS 可以为您处理大部分基础设施，因此您最不用担心。

下一步，输入您的集群名称(这里我使用 ecs-example-cluster)，选择创建新的 VPC (如果您没有的话)，然后启用容器洞察(这将提供 CloudWatch 监控和帮助调试)。

并点击创建。您的集群应该马上就准备好了。

为您的集群设置了一组资源。现在让我们转到任务定义。

创建任务定义

现在让我们开始创建您的容器蓝图。在工具条上，选择任务定义并选择创建新的任务定义。

选择 Fargate (如果您希望 AWS 为您处理 infra)，它将引导您:

创建任务角色

为您的任务定义命名。并为您的容器选择一个任务角色，但是等等，什么是任务角色？如输入中所解释的，

任务角色 :可选的 IAM 角色，任务可以使用它向授权的 AWS 服务发出 API 请求。在 IAM 控制台中创建一个 Amazon 弹性容器服务任务角色

记得我们的容器需要上传一个文件到 S3 吗？因此，要允许您的容器访问 s3，它需要一个角色来授权它这样做。(更多信息，请点击此处获取官方文档)

现在在一个新标签页中打开 AWS 控制台。

选择服务 IAM →选择角色 → 创建角色

对于选择可信实体类型部分，选择 AWS 服务。

对于选择将使用这个角色的服务，选择弹性容器服务。

对于选择您的用例，选择弹性容器服务任务并选择下一步:权限。

对于我们访问 s3 的服务，选择 Amazons3FullAccess (这不是授予 S3 对服务的完全访问权的最佳实践，您可能需要通过创建新的策略来将服务限制到某个桶)。

对于添加标签(可选)，输入您想要与 IAM 角色关联的任何元数据标签，然后选择下一步:查看。

对于角色名称，输入您的角色名称。对于本例，键入ECSs3AccessTaskRole来命名角色，然后选择创建角色来完成。

现在回到任务定义

将您刚刚创建的角色选择到任务角色中。

对于任务执行 IAM 角色，该角色有助于从 docker 寄存器中提取图像，因此如果您还没有该角色，我们首先需要创建它。角色创建过程与上面类似，您可以在这里按照步骤操作。(这里创建的角色名称是ecsTaskExecutionRole！)

而对于任务大小，我们都选择最小，当然我们的任务简单，不需要太多资源。

任务执行角色不同于我们刚刚创建的任务角色，如创建过程中所述:

任务执行角色 :这个角色是任务需要的，代表你拉容器镜像，发布容器日志到 Amazon CloudWatch。

任务角色 :可选的 IAM 角色，任务可以使用它向授权的 AWS 服务发出 API 请求。在 IAM 控制台中创建一个 Amazon 弹性容器服务任务角色

从堆栈溢出到这里的一个很好的区别解释。

添加容器

现在最重要的是，让我们来看看容器的定义。输入以下内容:

对于图像* ，输入您的私人图像注册表 url。勾选私有存储库认证，因为我们的映像驻留在 docker hub 上的私有回购中。为了让我们的服务访问我们的私人注册表，我们需要告诉代理我们的帐户和密码。AWS 上管理秘密的方式是使用秘密管理器。

创建秘密

再次转到 AWS 控制台→选择机密管理器→存储新机密→其他类型的机密

输入纯文本:

{
  "username": {YOUR_DOCKER_ACCOUNT},
  "password": {YOUR_DOCKER_PWD}
}

选择下一步，给你的秘密一个名字，其他的就用默认的。

创建后，你应该有这样的东西:

点击您的秘密，您可以检索您的秘密 ARN，并输入这个 ARN 到上面的容器定义！

虽然我们已经在容器中输入了我们的秘密，但是请记住，fargate 代理使用任务执行角色从您的私有注册表中提取图像，您可以这样理解这个过程:

因此，下一步是将这个秘密添加到我们上面创建的执行角色中。

向任务执行角色添加机密

现在再次转到 IAM 下的执行角色，添加内联策略:

选择 Json 格式并输入、

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue"
            ],
            "Resource": [
               {YOUR_SECRET_ARN}
            ]
        }
    ]
}

我知道很累，但我们就要完成了！现在我们的任务定义完成了！回到我们的任务定义，保留其他为默认，并点击创建。

创建服务并部署任务定义

我们已经完成了最难的部分，现在我们需要的是创建最后一个组件——服务并部署我们的任务！

在侧面板上，单击集群

选择 ECS-示例-集群

在服务选项卡下，选择创建，并输入以下内容:

选择下一步，对于 VPC，只需选择我们在**创建集群会话中创建的 VPC 和子网，**其他保持默认，最后创建服务。

现在转到“service”选项卡，您应该会看到作业正在运行…

为了验证我们的工作，请转到 s3，您应该看到(前提条件是，您应该在此之前创建了您的存储桶):

搞定了。我们的容器成功部署，文件上传到 S3！

删除集群

要删除我们的集群，首先删除我们的服务，然后删除集群，这需要几分钟才能生效。

如何使用谷歌 Colab 在书籍上训练 GPT-2 的逐步指南

原文：https://towardsdatascience.com/step-by-step-guide-on-how-to-train-gpt-2-on-books-using-google-colab-b3c6fa15fef0?source=collection_archive---------8-----------------------

我是如何成为一名共产党员的

共产主义者的人工智能是用 GPT-2 训练的。它阅读马克思、法农、葛兰西、列宁和其他革命作家的书籍。该项目旨在看看 GPT-2 能理解多深的哲学思想和概念。
结果相当有趣，也很有希望，因为我们见证了 A。我合乎逻辑地扭曲了我们给它的任何句子，使之成为抨击资本主义和为“工人”而斗争的借口。只要有可能，它就呼吁革命。

这是使用无条件生成的样本生成的——没有人的输入

此外，在介绍了无政府共产主义作家克鲁泡特金之后，我注意到“共产主义人工智能”倾向于使用更具攻击性的词语。另一方面，当我们介绍德·波伏娃的《第二性》(The Second Sex)时，《共产主义者人工智能》(The Communist A.I)有点错过了这本书的重点，在某些时候谈到了资本家的恋物癖——或者说它错过了重点？

而讨论人工智能的话语和哲学很有趣，比如回答“一个人如何变得自由”的问题，这篇文章旨在展示一个简单的分步指南，告诉你如何只用 GPT-2、谷歌 Colab 和你的谷歌硬盘创建你自己的人工智能角色。那我们开始吧。
如果你想阅读更多关于共产主义人工智能的信息，请点击此链接

准备您的 Google Colab 笔记本

我们将使用 Google Drive 来保存我们的检查点(检查点是我们最后保存的训练模型)。一旦我们训练好的模型被保存，我们就可以在任何时候加载它来生成有条件和无条件的文本。

首先，把你的 Colab 的运行时间设置为 GPU，以后你会感谢我的。
使用以下代码连接您的 Google Drive:

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

现在您已经连接了 Google Drive，让我们创建一个检查点文件夹:

%cd drive
%cd My\ Drive
%mkdir NAME_OF_FOLDER
%cd /content/
!ls

现在让我们克隆我们将使用的 GPT-2 存储库，它来自 nnsheperd 的 awesome 存储库(它来自 OpenAI，但添加了令人敬畏的 train.py)，我添加了一个 conditional_model()方法，该方法允许我们一次传递多个句子，并返回一个包含相关模型输出样本的字典。它还让我们避免使用 bash 代码。

[!git clone](https://github.com/mohamad-ali-nasser/gpt-2.git) [https://github.com/mohamad-ali-nasser/gpt-2.git](https://github.com/mohamad-ali-nasser/gpt-2.git)

现在让我们下载我们选择的模型。我们将使用相当不错的 345M 型号。我们将使用该型号而不是 774M 或 1558M 的原因是训练时 Colab 中可用的 GPU 内存有限。也就是说，如果我们想使用预训练的 GPT-2，而不需要对我们的语料库进行任何微调或训练，我们可以使用 774M 和 1558M。

%cd gpt-2
!python3 download_model.py 345M

现在模型已经安装好了，让我们准备好语料库并加载检查点，以防我们之前已经训练过模型。

# In Case I have saved checkpoints
!cp -r /content/drive/My\ Drive/communist_ai/gpt-2/checkpoint/run1/* /content/gpt-2/models/345M

下载文本并将其合并到一个语料库中

让我们创建并移动到我们的语料库文件夹，并获得这些文本。

%cd src
%mkdir corpus
%cd corpus/
!export PYTHONIOENCODING=UTF-8

我在 Github 存储库中有我的文本，但是您可以用您需要的任何链接替换 url 变量。你也可以手动将你的文本文件上传到 Google Colab，或者如果你的 Google Drive 中有文本文件，那么只需将 cd 放入该文件夹即可。

import requests
import osfile_name = "NAME_OF_TEXT.txt"if not os.path.isfile(file_name):
    url = "https://raw.githubusercontent.com/mohamad-ali-nasser/the-
           communist-ai/master/corpus/manifesto.txt?
           token=AJCVVAFWMDCHUIOOUDSD2FK6PYTN2"
    data = requests.get(url)with open(file_name, 'w') as f:
         f.write(data.text)
f.close()

现在文本已经下载完毕，使用下面的代码将多个文本文件合并成一个文件。如果您将只使用一个文本文件，请忽略此代码。

# Get list of file Namesimport glob
filenames = glob.glob("*.txt") # Add all texts into one filewith open('corpus.txt', 'w') as outfile:
       for fname in filenames:
            with open(fname) as infile:
                  outfile.write(infile.read())
outfile.close()

下载库和 CUDA

现在我们已经准备好了一切，让我们准备环境。我们将从安装需求文件开始。(如果你碰巧用你本地的 Jupyter 笔记本来使用 GPT-2，那么在使用 download_model.py 之前安装需求文件)

# Move into gpt-2 folder
%cd /content/gpt-2!pip3 install -r requirements.txt

现在，以下是可选的，因为如果您想使用 774M 型号和 1558M 型号，它们是必需的。我使用过没有这些的 334M，但我还是建议这样做，尤其是 CUDA，因为你的模型会运行得更快，这些可能会修复一些你可能会遇到的随机错误。

!pip install tensorflow-gpu==1.15.0
!pip install 'tensorflow-estimator<1.15.0rc0,>=1.14.0rc0' --force-reinstall

现在安装 Cuda v9.0:

!wget [https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda-repo-ubuntu1604-9-0-local_9.0.176-1_amd64-deb](https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda-repo-ubuntu1604-9-0-local_9.0.176-1_amd64-deb)
!dpkg -i cuda-repo-ubuntu1604-9-0-local_9.0.176-1_amd64-deb
!apt-key add /var/cuda-repo-*/7fa2af80.pub
!apt-get update
!apt-get install cuda-9-0!export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-9.0/lib64/

重启运行时并移回 GPT2 文件夹

%cd gpt-2

让我们训练模型:

现在是我们一直在等待的时刻，对模型进行微调。复制下面的一行程序并运行它。

!PYTHONPATH=src ./train.py --dataset src/corpus/corpus.txt --model_name '345M'

该模型将加载最新的检查点，并从那里开始训练(似乎加载以前训练过的检查点并添加到其中会导致您在使用 Colab 中的 345M 时遇到内存问题)。
还可以指定批次数和学习率。批次数量真正的整体好处是训练的速度，默认的批次大小是 1，增加批次大小会导致你遇到内存问题，所以要小心你增加多少，特别是当你在一个 GPU 上运行时，我使用的批次大小是 1，尝试 2 或 4，并在评论中添加你的结果。

虽然提高学习率可以提高训练的速度，但它可能会导致模型卡在局部最小值(梯度)甚至超调，因此我建议保持学习率不变，或者如果损失停止下降，则降低学习率。默认学习率为 0.00001。

!PYTHONPATH=src ./train.py --dataset src/corpus/corpus.txt --model_name '345M' --batch_size 1 --learning_rate 0.00001

该模型将每 1000 步保存一个检查点。你可以持续运行它几分钟、几小时或几天，这完全取决于你，只要确保如果你有一个小文本，你不要过度拟合模型。
要停止模型，只需“停止”它，它将保存最后一个训练步骤(因此，如果您在步骤 1028 停止，您将有两个检查点 1000 和 1028)。
注意:当在训练 Colab 时停止模型时，它可能看起来没有反应并保持训练，为了避免这种情况，在它训练时，清除输出，然后停止它，这将节省您的几次点击。

现在模型已经训练好了，让我们将检查点保存在 Google Drive 中:

!cp -r /content/gpt-2/checkpoint/ /content/drive/My\ Drive/checkpoint

将新保存的检查点复制到模型的目录中

!cp -r /content/gpt-2/checkpoint/run1/* /content/gpt-2/models/345M/

生成条件文本

import os
%cd src
from conditional_model import conditional_model
%cd ..

运行下面的代码，了解该方法的参数是什么:

conditional_model??

我建议设置一个种子，这样你可以得到一些可重复的结果。参数语句接受一个字符串或字符串列表，并返回一个字典，其中输入作为键，输出样本作为值。

现在来看看魔术:

conditional_model(seed=1,sentences=['How are you today?', 'Hi i am here'])

你现在已经根据你选择的书籍对你的 GPT-2 进行了微调，并且创建了你自己的人工智能，祝贺你！！

如果你觉得这个教程有帮助，请分享并开始 GitHub repo—https://github.com/mohamad-ali-nasser/gpt-2。谢谢

别忘了跟着共产主义者 A.I 。

在 LinkedIn 上联系，在 Twitter 上关注。

您也可以查看我的组合网站，了解更多项目。

编码快乐！

分步指南:使用 Python 进行数据科学的比例采样

原文：https://towardsdatascience.com/step-by-step-guide-proportional-sampling-for-data-science-with-python-8b2871159ae6?source=collection_archive---------14-----------------------

从头开始使用 python 理解数据科学所需的比例采样的概念和实现

图片由 jakob5200 来自 Pixabay

骰子的形象让我想起了我小时候玩的游戏，比如蛇和梯子或者鲁道。

掷骰子时，在任何时间间隔可能出现的数字的可能性是 1-6。六个通常是最好的结果，而一个在大多数情况下可能不是很好。

然而，如果你能比其他数字更多次地掷出数字 6，这不是很棒吗？

这个技巧正是比例采样所实现的，我们将在下一节中进一步研究其逐步实现的细节。但首先，让我们理解这些概念的必要性。

数学在数据科学和机器学习中扮演着重要的角色。

概率统计就是这样一个基本要求。概率涉及预测未来事件发生的可能性，而统计学涉及对过去事件发生频率的分析。我们利用这些概念来处理机器学习和数据科学问题的一个重要方面叫做采样。

在统计学、质量保证和调查方法学中，抽样是从统计总体中选择个体子集，以估计总体特征。统计学家试图用样本来代表所讨论的人口。

基本上，抽样是统计分析中使用的一个过程，其中从一个较大的总体中抽取预定数量的观察值。

与测量整个人口相比，抽样的两个主要优点是成本更低和数据收集更快。

有许多抽样方法，如随机抽样、均匀抽样等。在本文中，我们将主要分析比例抽样的逐步方法。

比例抽样是一种按重量比例选取元素的方法，即对象的重量越大，被选中的机会就越大。

参考前面所述的骰子示例，像五或六这样的较大数字比像一或二这样的较小数字更有可能被选中。

让我们通过一些一步一步的程序实现和一些 python 代码来理解这一点。

林赛·亨伍德在 Unsplash 上的照片

比例取样的逐步方法；

执行比例采样所需导入的唯一附加库是 python 中的 random 模块。该模块可以按如下方式导入:

import random

这个模块是唯一的额外要求。剩下的步骤可以用简单的 python 代码来执行。

在我们继续之前，让我们定义我们的输入。作为一个例子，我将使用一个从 1 到 6 的数字列表来表示骰子。你可以随意选择你的问题的任意输入。

A = [1,2,3,4,5,6]

第一步:

计算输入的所有元素的总和。

Sum = A[0] + A[1] + ……。+ A[n]
其中，n =已定义输入的最后一个元素的索引

代码:

在上面的代码块中，我们将输入列表存储在变量“a”中。我们将继续计算列表中所有元素的总和。我已经使用了上面提到的简单方法，但是如果你觉得舒服的话，你也可以使用一个具有高级功能的更紧凑的方法。

第二步:

计算输入列表中每个元素的归一化总和。

A0 ’ = A[0]/Sum；a1 ’ = A[1]/Sum；…………
其中，A’表示每个元素的归一化和

代码:

下一个代码块计算分配给输入的每个元素的归一化和。我使用了一个字典变量“C”来相应地存储这些值。

第三步:

使用所有标准化值计算每个元素的累积和。

A0 ~ = A0’；A1 ~ = A0 ~+A1 '；…….
其中，A~代表每个元素的累积和

代码:

上面的代码块使用我们在上一步中找到的标准化值来计算每个元素的累积和。我使用了另一个字典变量‘D ’,它将存储所有需要的累积值。

第四步:

在(0，1)范围内选择一个随机值。

r =随机均匀(0.0，1.0)

如果 r≤ A0~ =返回 choice-1；
else 如果 r≤ A1~ =返回 choice-2；
…………依此类推，直到覆盖所有元素。

代码:

在下一个代码块中，我使用了我们在程序开始时导入的随机模块。使用 0-1 范围内的随机数，我们可以计算加权和出现的概率。

观察代码，尝试直观地理解我们在上面的代码块中试图实现的内容。与较小的数字相比，较大的数字有更大的机会被选中，因为它们之间的桥梁在范围内出现得更高。

如果你对这一步感到困惑，我强烈建议你试着把它写在纸上，并解决这个计算是如何工作的。

现在让我们进入最后一个代码块，并理解最后一步。

第五步:

最终实现。

代码:

上面显示的最后一个代码块用于随机数生成和计数。上面的函数用于运行第一个定义的函数 99 次，并检查每个发生可能性的计数。

期望的输出对于数字 6 具有最高的计数，对于数字 5 具有第二高的计数，依此类推，直到我们对于数字 1 具有最少的计数。

第一次运行的一个输出示例如下所示。

注意:由于我们使用的是随机函数，每次输出都会不同。所以如果你得不到和我一样的输出也不用担心。要考虑的重要事情是哪个数字的计数最大。

输出:

[6, 5, 4, 3, 2, 1]
count of 6 is 30
count of 5 is 24
count of 4 is 20
count of 3 is 11
count of 2 is 10
count of 1 is 4

每次运行程序时，输出可能会有所不同。不要求您获得如上所示的相同输出。出现这种情况的原因是因为我们使用了随机模块。需要注意的要点是，与其他数字相比，最大的重量数字具有更高的计数。

这样，我们成功地实现了比例抽样。这个概念在数据科学的许多方面都非常重要，在这些方面，需要给予较大的权重更高的优先级。

骰子的引用就是一个很好的例子。如果我有这个骰子，那么我赢得游戏的机会会高得多！

Sebastien Gabriel 在 Unsplash 上的照片

结论:

至此，我们已经到了文章的结尾。我们理解数学对于数据科学的重要性，特别是在使用骰子的例子所需的概率和统计方面。

然后，我们进一步讨论了采样的主题及其在数据科学领域的优势。然后，我们具体探讨了比例抽样技术，一步一步的指南和完整的代码。

如果你对我们今天在这篇文章中提到的比例抽样有任何疑问，请在评论区联系我。

看看我的其他一些文章，你可能会喜欢读！

[## 2020 年及以后最受欢迎的 10 种编程语言

讨论当今 10 种最流行的编程语言的范围、优缺点

towardsdatascience.com](/10-most-popular-programming-languages-for-2020-and-beyond-67c512eeea73) [## 必须使用内置工具来调试你的 Python 代码！

python 调试器模块指南，包含有用的代码和命令。有效且高效地利用这一工具…

towardsdatascience.com](/must-use-built-in-tool-for-debugging-your-python-code-d5f69fecbdbe) [## 带有完整代码片段和有用链接的 5 个最佳 Python 项目创意！

为 Python 和机器学习创建一份令人敬畏的简历的 5 个最佳项目想法的代码片段和示例！

towardsdatascience.com](/5-best-python-project-ideas-with-full-code-snippets-and-useful-links-d9dc2846a0c5) [## OpenCV:用代码掌握计算机视觉基础的完全初学者指南！

包含代码的教程，用于掌握计算机视觉的所有重要概念，以及如何使用 OpenCV 实现它们

towardsdatascience.com](/opencv-complete-beginners-guide-to-master-the-basics-of-computer-vision-with-code-4a1cd0c687f9)

谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！

ECDFs 分步指南——强大的直方图替换

原文：https://towardsdatascience.com/step-by-step-guide-to-ecdfs-a-robust-histogram-replacement-8b2309ac9c1c?source=collection_archive---------43-----------------------

用 ECDFs 一劳永逸地抛弃宁滨偏见

照片由尼克·费因斯在 Unsplash 上拍摄

每个人都喜欢好的数据可视化。尽管如此，他们不应该把解释留给观众，就像直方图一样。今天我们将回答宁滨偏差如何在分析中误导你，以及如何用 ECDF 图的力量来防止这个问题。

这篇文章回答了以下问题:

• 直方图有什么问题——什么时候应该避免使用它们
• 如何用 ECDFs 替换直方图——一种更健壮的检查数据分布的方法
• 如何在单个图表中使用和解释多个 ECDFs 比较不同数据段之间的分布

事不宜迟，我们开始吧！

直方图有什么问题？

正如来自数据营的贾斯汀·博伊斯所说——宁滨偏见——我完全同意。这意味着在直方图上使用不同的区间大小会使数据分布看起来不同。不要相信我的话，下面的例子不言自明。

首先，我们将导入几个用于数据分析和可视化的库，并直接从 web 加载 Titanic 数据集:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()

df = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv')

如果您不熟悉数据集，下面是前几行的样子:

作者图片

df.dropna(subset=['Age'], inplace=True)

接下来，让我们声明一个可视化直方图的函数。它需要很多参数，但在我们的例子中最重要的参数是:

• x–表示我们要为其绘制直方图的单个属性
• nbins–直方图应该有多少个箱

def plot_histogram(x, size=(14, 8), nbins=10, title='Histogram', xlab='Age', ylab='Count'):
    plt.figure(figsize=size)
    plt.hist(x, bins=nbins, color='#087E8B')
    plt.title(title, size=20)
    plt.xlabel(xlab, size=14)
    plt.ylabel(ylab, size=14)

plot_histogram(df['Age'], title='Histogram of passenger ages')
plot_histogram(df['Age'], nbins=30, title='Histogram of passenger ages')

我们将使用提到的函数两次，第一次用 10 个面元制作直方图，第二次用 30 个面元制作直方图。结果如下:

有 10 个条块的直方图:

作者图片

有 30 个条柱的直方图:

作者图片

数据是相同的，但不同的箱大小会导致宁滨偏差——由于视觉表现的细微变化，对相同数据的感知不同。

我们能做些什么来解决这个问题？ECDF 的阴谋终于来了。

ECD fs——更强大的直方图替换

ECDF 代表经验累积分布函数。别担心，它没有听起来那么花哨，也相对容易理解。

像直方图一样，ECDFs 显示单个变量的分布，但方式更有效。我们之前已经看到了直方图是如何由于不同的 bin 大小选项而产生误导的。ECDFs 就不是这样了。ECDFs 显示每一个数据点，并且该图只能以一种方式解释。

将 ECDFs 视为散点图，因为它们也有沿 X 轴和 Y 轴的点。更准确地说，这是 ECDFs 在两个轴上显示的内容:

• x 轴——我们正在测量的量(上面例子中的年龄)
• Y 轴-值小于相应 X 值的数据点的百分比(在每个点 X，Y%的值小于或等于 X)

为了实现这种可视化，我们需要先做一些计算。需要两个阵列:

• X —排序数据(从最低到最高排序年龄列)
• y-最大值为 1 的均匀间隔数据点列表(如 100%)

以下 Python 片段可用于计算 Pandas 数据帧中单个列的 X 和 Y 值:

def ecdf(df, column):
    x = np.sort(df[column])
    y = np.arange(1, len(x) + 1) / len(x)
    return x, y

这是一个非常简单的问题。不过，我们还需要一个函数。这个是用来做一个实际的图表的:

def plot_ecdf(x, y, size=(14, 8), title='ECDF', xlab='Age', ylab='Percentage', color='#087E8B'):
    plt.figure(figsize=size)
    plt.scatter(x, y, color=color)
    plt.title(title, size=20)
    plt.xlabel(xlab, size=14)
    plt.ylabel(ylab, size=14)

让我们使用这个函数来制作一个年龄属性的 ECDF 图:

x, y = ecdf(df, 'Age')

plot_ecdf(x, y, title='ECDF of passenger ages', xlab='Age')
plt.show()

作者图片

但是等等，我该怎么解读这个？这很容易。这里有几个例子:

• 大约 25%的乘客年龄在 20 岁或以下
• 大约 80%的乘客年龄在 40 岁以下
• 大约 5%的乘客年龄在 60 岁或以上(1——百分比)

那不是很容易吗？但是等等，派对不会就此结束。接下来我们来探讨如何绘制和解释多个 ECDFs。

多个 ECDFs

在 Titanic 数据集中，我们有 Pclass 属性，它表示乘客类别。即使在今天，这种等级组织也是旅行中的典型，因为头等舱是为较富裕的人保留的，其他的舱是其他人所在的地方。

借助 ECDFs 的强大功能，我们可以探索乘客年龄是如何在各个阶层中分布的。我们需要调用ecdf()函数三次，因为船上有三个类。代码的其余部分归结为数据可视化，这是不言自明的:

x1, y1 = ecdf(df[df['Pclass'] == 1], 'Age')
x2, y2 = ecdf(df[df['Pclass'] == 2], 'Age')
x3, y3 = ecdf(df[df['Pclass'] == 3], 'Age')

plt.figure(figsize=(14, 8))
plt.scatter(x1, y1, color='#087E8B')
plt.scatter(x2, y2, color='#f1c40f')
plt.scatter(x3, y3, color='#e74c3c')
plt.title('ECDF of ages across passenger classes', size=20)
plt.xlabel('Age', size=14)
plt.ylabel('Percentage', size=14)
plt.legend(labels=['Pclass = 1', 'Pclass = 2', 'Pclass = 3'])
plt.show()

结果可视化如下所示:

作者图片

正如我们所看到的，第三个班级(红色)有很多孩子，而第一个班级(绿色)没有这么多孩子。第一个班级的学生年龄也很大:

• 只有 20%的头等舱乘客年龄超过 50 岁
• 只有 20%的二等舱乘客年龄超过 40 岁
• 只有 20%的三等舱乘客年龄超过 34 岁

这些只是粗略的数字，所以如果我犯了一两年的错误，不要引用我的话。现在您知道了如何使用和解释 ECDFs。让我们在下一部分总结一下。

离别赠言

不要把任何东西留给数据科学中的个人解读。仅仅因为你喜欢在柱状图中看到 15 个柱，并不意味着你的同事也喜欢。如果直观地解释，这些差异可能会导致不同的数据解释。

ECDFs 就不是这样了。现在，您已经对它们有了足够的了解，可以将它们包含在下一个数据分析项目中。乍一看，它们似乎令人望而生畏，但我希望这篇文章做出了必要的澄清。

感谢阅读。

加入我的私人邮件列表，获取更多有用的见解。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

[## 通过我的推荐链接加入 Medium-Dario rade ci

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

medium.com](https://medium.com/@radecicdario/membership)

原载于 2020 年 10 月 23 日 https://betterdatascience.com。

在数据科学面试中解释你的 ML 项目的逐步指南。

原文：https://towardsdatascience.com/step-by-step-guide-to-explaining-your-ml-project-during-a-data-science-interview-81dfaaa408bf?source=collection_archive---------1-----------------------

在结尾有一个额外的样本脚本，让你谨慎地展示你的技术技能！

这是我最近开始的 面试问题 系列的第二部分。在 第 1 部分 中，我们谈到了另一个与扩展您的 ML 模型有关的重要数据科学面试问题。一定要去看看！

Pinterest

面试可能会令人生畏，但解释一个你付出血汗的项目却不应该！

一个典型的开放式问题经常在面试(第一轮和第二轮)中出现，它与你的个人(或兼职)项目有关。这个问题可以有多种形式，例如:

• 你能给我们介绍一下你最近完成的一个项目吗？
• 你能告诉我们你参与一个具有挑战性的项目的时候吗？
• 你参与过哪些有趣的项目？

相信我，这个问题是你在面试中遇到的最好的事情。它让你把谈话引向你喜欢的方向，把注意力集中在你有信心的主题/ML 框架/算法上！

在这篇文章中，我们将解码如何挑选一个有趣的项目，如何组织我们的答案以便我们不会错过任何重要的细节，并且学习一些应该成为你答案一部分的时髦词汇。所有这一切都在 10 个简单的步骤中完成！

第一步:选择一个项目。

不用说，在选择一个项目来展示你的技术实力时，要确保它能与你申请的公司产生共鸣。

例如，对于一家电子商务公司，我会选择零售数据集，对于一家金融科技公司，我会选择贷款申请数据集，而对于一家医疗保健公司，我会选择新冠肺炎或乳腺癌数据集。诀窍是根据你的目标受众选择一个项目。我向 Kaggle 发誓，我会提供高质量的数据集和一些分析笔记本来帮助你开始。

此外，在你的 kitty 下拥有一些来自不同部门的端到端项目实际上是一个好主意。

第二步:解释数据源。

开始你的解释，具体说明你从哪里得到的数据。

这些数据可能是你在上一家公司提供/收集的。也许你做这个项目是为了好玩，通过 Kaggle 提取了所需的数据。你甚至可以提到它是一些在网上免费提供的开源数据。也许你使用第三方 API(Twitter 数据经常发生)挖掘数据(当然是道德上的)。无论是哪种情况，确保你透露了数据的来源。此外，简要概述数据集中的一些列/特征。

第三步:解释你在这个项目背后的目标。

请具体说明你在这个项目中想要达到的目标。

这可能是一个区分批准和拒绝贷款申请的分类问题，一个预测房价的回归问题，一个推荐系统的冷启动问题，一个为目标广告寻找相似用户的聚类问题。从面试官的角度来看，绝对清晰地解释项目内容是最重要的。

步骤 3:准备数据集。

这是您讨论数据清理、数据争论、处理异常值、多重共线性、重复删除、特征工程、特征标准化等以及处理它们的技术的地方。

这个想法是要提到你用来针对上述每个数据准备步骤的实际技术。例如，明确声明,库克距离超过平均值 3 倍的观察值被视为异常值。超过 10 的 VIF (方差膨胀因子)值被视为表示多重共线性。一个热编码(或标签编码)用于处理分类数据。数字数据经过缩放/标准化以确保所有特征都在同一比例上。进行了 80:20 列车测试分割以确保没有数据泄漏。使用 t-SNE 图来查看类之间的可见分离(在分类问题的情况下)。

步骤 4:陈述 KPI 或绩效指标

对你的研究问题最重要的是什么——准确度、精确度、回忆、假阳性、假阴性等等？

每个 ML 模型都有一些你试图优化的指标。它可能因人而异，因问题而异，因利益相关者而异，甚至因部门而异。医疗保健数据科学家必须确保他(或她)的模型具有更少的假阴性，因为如果进行不正确的癌症诊断，可能会让患者付出生命的代价。另一方面，安装在购物中心的检测商店扒手的系统不得不担心太多的误报，因为这将意味着给无辜的购物者带来巨大的尴尬。

此外，如果出现分类问题，请确保您指定了您的数据集是不平衡的还是平衡的，这主要是因为您对性能指标的选择在很大程度上取决于您的数据集中类的分布。

步骤 5:基线模型

你怎么知道你创建的模型比现有的更好呢？

这是经常被忽视的一步，但却非常重要。我见过很多人在面试官的后续问题是— 时答非所问，那么请告诉我，你为什么认为你的模型很好？

有一个可以用来比较最终模型的基线是很重要的。更多的时候，你可以通过快速的谷歌搜索来选择一个基线——在 MNIST 数据集上达到的最高准确率是多少？或者网飞的推荐系统 Cinematch 的准确度如何。如果你找不到你的领域/问题的基线，你总是可以自己创建一个。

基线模型是一种设置简单并且有合理机会提供良好结果的模型。例如，在冰淇淋销售的时间序列预测的情况下，我的基线(阅读:愚蠢)模型可能只使用今天的数据来预测明天。**

第六步:解释培训过程

解释为什么选择特定的算法。

总是从基本的开始，使用交叉验证抽查几个算法，然后选择具有最高性能指标值的算法(在步骤 4 中指定)。根据我的经验，这总是归结为两三种算法，它们的性能只有细微的差别。在这三个中，我个人倾向于选择像 Random Forest、XG Boost、CART 等这样的组合模式。(特别是因为它们倾向于通过将来自多个模型的预测组合在一起来提高预测准确性)。

但是嘿，那是我的推理！您可能很乐意选择线性回归作为您的首选模型，特别是因为它很容易向非技术风险承担者解释。总而言之，一定要记得和你的面试官分享你的模特选择决定。

步骤 7:解释模型调整过程

你是如何提高你的模型的准确性的？在这个过程中，你遇到了哪些挑战？

诀窍是谈论你如何提高精度同时防止高方差(或过拟合)问题。谈谈 超参数调谐 采用网格搜索还是随机搜索。另外，说明你是否使用了某种过采样/欠采样技术来平衡你的数据集？在你的 ML 工作流程中强调管道的使用，以避免数据泄露和随后的过度拟合。解释你如何使用 学习曲线 来跟踪损失函数。

至于挑战，这些都是个人经历所特有的。我将在最后的示例脚本中解释我最大的挑战。

第八步:模型部署流程

你的模型是放在你的 Jupyter 笔记本里，还是放在外面让其他人也能欣赏？

通常，面试官在寻找潜在的数据科学新人，他们知道如何将他们的模型包装在一个漂亮的小容器中并向世界展示。这可以是 web 应用程序或 API 的形式。我强烈建议多走一步，学习如何做其中的一项。完全的初学者可以查看这篇关于如何使用 Flask 框架将模型部署为 API 的文章。

第九步:准备一些备份问题！

如果你要做一些不同的事情，那会是什么？如果我要改变这个项目中的条件 X，你的方法会如何改变？

一旦你解释完你的项目，像上面这样的问题肯定会被问到。而且很多时候，这是一个好兆头！这意味着面试官在倾听，并真诚地想知道更多关于你的工作。试着为你的项目想一些不同的事情——例如，我会试着获得无偏见的数据(例如，一个有相等的男性和女性代表的数据)，我会用堆叠模型做实验，我会用不同的分类阈值重新评估我的混淆矩阵，等等。

第十步:记得呼吸！

不要急着完成！享受这个过程，为你的观众编织一个美丽的故事。

我知道将一个耗时 3-4 周的项目浓缩成 90 秒钟的电梯营销会有多难。但问题不在于你做了多少工作，而在于你能把多少工作有效地传达给面试官。所以呼吸…

顶空

现在，用一个示例脚本把它们结合起来！！！

额外收获:这个问题的答案样本

问——那么，你能告诉我们你最近做了什么项目吗？

肯定的。我做了很多，特别是在锁定的情况下，但我想我会选择我最喜欢的，因为它为我清除了许多数据科学基础。博士实习期间，我在给一家专门给二手车贷款的公司提供咨询。他们试图在尽可能短的时间内实现评估贷款申请流程的自动化。所以基本上，我处理的是一个二元分类，但是是一个不平衡的分类问题——被批准的申请数量远远多于被拒绝的申请数量。

由于数据不平衡，我决定使用 F1 作为性能指标，因为它减少了误报和漏报。该数据集由该公司自己提供，包含年龄、汽车类型、贷款金额、存款、信用评分等特征。作为探索性数据分析阶段的一部分，我使用 Cook’s distance 处理异常值，使用 VIFs 处理多重共线性，删除重复项，使用 KNNImputer 处理缺失值，并对数据执行 80:20 分割。分类特征和数字特征分别被热编码和归一化。所有的分析都是使用 SkLearn 进行的。

对于基线模型，我选择了一个简单的模型，仅使用申请人的信用评分来预测申请结果。有了它，我的 F1 成绩达到了 56%。对于模型选择，我首先抽查了一些算法，如 SVM、LR、KNN、NN 和 RF，它们给出了最好的交叉验证分数。我使用 GridSearch CV 继续进行超参数调优，并能够在测试集上获得等于 74%的 F1 分数。我还尝试使用 SMOTEENN 库对罕见的类进行过采样，但这对提高性能没有太大帮助。有帮助的是使用 RF 的方差重要性图做了一些特征减少，最后我的 F1 分数大约是 82%。

我对此很满意，并决定在该公司提供的以前从未见过的测试集上测试我的模型。我惊讶地发现它的表现不如我预期的那样好。然后我参考了几篇博客文章，意识到我做错了什么。显然，一次性编码分类特征对于基于树的模型是不好的，特别是因为我们创建了许多二进制稀疏特征，并且从分裂算法的角度来看，它们都是独立的。因此，连续变量被自动赋予更高的重要性，并被选择在树的顶部进行拆分。为了缓解这个问题，我从 SkLearn 转到了 H2o 框架，它不需要对分类特征进行一次性编码。虽然我的 F1 分数大致保持不变，但我的 H2o 模型在看不见的数据集上概括得更好。

结尾注释

这就是展示你的 ML 项目的详细指南。确保你的回答不遗漏任何细节。至于我在开头谈到的时髦词汇，这里有几个词肯定会给你的面试官留下深刻印象:

超参数调谐

交叉验证

ML 工作流管道

偏差-方差权衡

过/欠采样

集合模型

缩放、标准化、一次热编码

特征简化、特征工程

绩效指标、混淆矩阵

我喜欢写循序渐进的初学者指南、操作指南、面试问题、解码 ML/AI 中使用的术语等。如果你想完全访问我的所有文章(以及其他媒体上的文章)，那么你可以使用 我的链接这里 注册。

** [## 面试官最喜欢的问题-你会如何“扩展你的 ML 模型？”

您正在构建一个生产就绪的 ML 模型吗？

towardsdatascience.com](/interviewers-favorite-question-how-would-you-scale-your-ml-model-56e4fa40071b) [## 了解 Python 导入，init。py 和 pythonpath —一劳永逸

了解如何导入包和模块(以及两者之间的区别)

towardsdatascience.com](/understanding-python-imports-init-py-and-pythonpath-once-and-for-all-4c5249ab6355) [## 我将如何从零开始向一个 5 岁的孩子解释甘斯:第 1 部分

GANs 背后的基本直觉、目标函数、生成器和鉴别器架构以及深入的伪代码…

medium.com](https://medium.com/swlh/how-i-would-explain-gans-from-scratch-to-a-5-year-old-part-1-ce6a6bccebbb) [## 如何使用 AutoKeras 用一行代码建立图像分类模型？

甚至不需要知道 Conv2d、Maxpool 或批处理规范化层是做什么的！

medium.com](https://medium.com/analytics-vidhya/how-to-use-autokeras-to-build-image-classification-models-using-one-line-of-code-c35b0c36e66e)**

循序渐进:如何创建具有地图功能的交互式仪表盘

原文：https://towardsdatascience.com/step-by-step-how-to-create-interactive-dashboard-with-map-features-512e6e44a8f0?source=collection_archive---------27-----------------------

图片由 janjf93 来自 Pixabay

演示是许多数据科学项目中最关键的部分。当你准备一个演示文稿时，也许你不喜欢花时间清理数据。但是演示对你的同事/客户/顾客的影响非常大。简单明了很有必要，尤其是在向一个非技术人员解释结果的时候。

空间数据的重要性？

空间数据是需求最大的数据类型之一。因为空间数据可以帮助我们；

• 更好的理解哪里的答案？
• 确定关系
• 识别模式
• 作出预测

地图当然是显示空间数据的好方法。如今，你不需要任何 GIS 软件来创建和发布地图。BI 工具现在能够创建专题地图。

有许多商业智能工具可以帮助你创建强大而有效的图表、仪表盘、可视化工具，如 Tableau、Qlik Sence、Power BI、Looker、Microstrategy 等。

在这篇文章中，我将一步一步地解释如何用 Tableau Public 创建一个交互式仪表盘。您可以在我的 Github 资源库中找到我将在本教程中使用的数据。

• 伦敦行政区:从 Airbnb 内部获取的该城市街区的 GeoJSON 文件
• LondonBoroughProfile: 从大伦敦当局获取的伦敦自治市档案的 CSV 文件

步骤 1:安装 Tableau Public 并创建概要文件

Tableau Public 是一款免费软件，允许任何人连接到电子表格或文件，并为 web 创建交互式数据可视化。你可以使用 这个链接下载 Tableau Public for windows and Mac。

然而，你需要创建一个个人资料来展示你在互联网上的形象。

步骤 2:将你的文件连接到 Tableau Public

打开 Tableau 公共应用，可以看到左上角的“**连接”**区域。

作者照片

来连接你的空间文件 (LondonBorough。选择空间文件，浏览你的文件并打开。当您打开您的空间文件连接屏幕出现如下所示。您的文件必须包括多重多边形类型的几何列。

作者照片

要添加您的表格数据(**londonboroughprofile . CSV)**点击连接区域的添加按钮，然后选择“文本文件”。

作者照片

浏览您的 LondonBoroughProfile.csv 文件并点击打开。现在你有 2 个连接和 2 个文件，一个是空间文件，另一个是**“文本文件”**。

作者照片

如果您想预览您的表格数据，您可以点击“**查看数据”**按钮并预览您的数据。

作者照片

作者照片

要创建两个文件的关系，选择 LondonBoroughProfile.csv 文件，拖放到关系区域。

作者照片

现在，您必须选择两个文件的公共列(区名)。LondonBoroughs.geojson 的专栏名称为“街区”，LondonBoroughProfile.csv 的专栏名称为“区名”

作者照片

创建文件之间的关系后，您可以看到如下所示的连接。

作者照片

步骤 3:创建地图图幅

要创建地图可视化，点击左下方的第 1 页。

作者照片

现在你有了两个表格和几十个属性，根据它们的类型(字符串、数字、日期、地理角色等)显示不同的图标。)

作者照片

要创建伦敦区地图，请选择放置在 LondonBoroughs.geojson 下的几何列，拖放 Sheet1 area。

作者照片

现在你有了伦敦行政区的基本地图。你需要用一些外观特征来配置你的地图，比如标签、颜色、工具提示等等。

**创建标签:**选择邻居，拖拽至标签

作者照片

作者照片

创建专题地图:选择一个你想作为专题地图查看的特征(在 LondonBoroughProfile.csv 下)，拖放到彩色区域。在本教程中，我选择了**“2014/2015 年每千人口犯罪率”**

作者照片

现在，您有了一个基于犯罪率的专题地图。您可以通过改变颜色、标签等来配置外观特征。您可以添加过滤器，图例，标题等，以获得一个更容易理解的地图。

作者照片

添加新特性作为工具提示:工具提示为我们提供了关于属性的附加信息。因此，您可以添加更多的属性，当光标在地图上移动时，用户可以进行交互。选择一个或多个属性，拖放到工具提示区域。在本教程中我选择了“2015 年就业率(%)”“2017 年平均年龄”**“汽车数量，(2011 年人口普查)”**属性并重命名如下图所示；

• 就业率
• 平均年龄
• 汽车数量

作者照片

步骤 4:创建图表

要创建新图表，请单击左下角的新工作表。

作者照片

创建新工作表后，将出现一个空工作表。选择**区名称，拖拽到列区。选择犯罪率，**拖拽到行区域。

作者照片

要着色并添加标签，选择犯罪率，拖放以着色，再次拖放以标记犯罪率

作者照片

“伦敦金融城”区没有数据，因此您需要从图表中移除该记录。单击行政区名称的箭头并选择过滤器。然后取消选中伦敦城

作者照片

作者照片

步骤 5:创建仪表板

您可以创建更多包含不同图表的工作表。最后，您可以将这些工作表组合成一个仪表板。要创建新的仪表板，请单击“新建仪表板”按钮，此时将显示空仪表板。

作者照片

将尺寸更改为“自动”

作者照片

将 Sheet1(专题地图)和 Sheet2(条形图)拖放到仪表板区域。

如下图所示，我放置了这两张纸。

作者照片

如果你想看到所有可视化的交互，你需要设置“用作过滤器”按钮。

作者照片

因此，如果您从地图或图形中选择一个区，您会动态地看到其他图形的结果

作者照片

第六步:发布

最后，您准备了一个包含地图和图表的仪表板。现在，您需要将此仪表板发布到您的 Tableau 公共个人资料。点击文件并选择另存为 Tableau Public As

作者照片

作者照片

保存仪表板后，您的 Tableau 公共个人资料会自动打开。您可以使用全屏按钮来最大化您的仪表板。

作者照片

你可以在我的 Tableau 公众号 找到我的仪表盘。

感谢你阅读我的帖子，希望你喜欢。如果您有任何问题或想要分享您的意见，请随时联系我。

一步一步实现:Keras 中的 3D 卷积神经网络

原文：https://towardsdatascience.com/step-by-step-implementation-3d-convolutional-neural-network-in-keras-12efbdd7b130?source=collection_archive---------1-----------------------

深度学习

了解如何实现您自己的 3D CNN

来源

在本文中，我们将简要解释什么是 3d CNN，以及它与普通的 2d CNN 有何不同。然后我们会一步步教你如何用 Keras 实现自己的 3D 卷积神经网络。

本文将围绕这四个部分展开:

• 1】什么是 3D 卷积神经网络？
• 2】3d 数据是什么样的？(如 MNIST)
• 3】现在如何实施？！
• 4】但是然后一个 3d？为什么

1]什么是 3D 卷积神经网络？

不管我们怎么说，3d CNN 仍然是一个与 2d CNN 非常相似的 CNN。不同之处在于以下几点(非穷尽列举):

3d 卷积层

最初，2d 卷积层是输入和不同滤波器之间的逐条目乘法，其中滤波器和输入是 2d 矩阵。(图 1)

图 1(版权所有:自有)

在 3d 卷积层中，使用相同的操作。我们在多对 2d 矩阵上进行这些操作。(图 2)

图 2(版权所有:自有)

填充选项和幻灯片步长选项的工作方式相同。

3d 最大池图层

2d Maxpool Layers (2x2 filter)是从输入中提取一个 2x2 小正方形的最大元素。(图 3)

图 3(版权所有:自有)

现在，在 3d Maxpool (2x2x2 内核)中，我们寻找宽度为 2 的立方体中的最大元素。此立方体代表由输入的 2x2x2 区域界定的空间。(图 4)

图 4(版权所有:自有)

请注意，操作的数量(与 2d CNN 层相比)乘以所使用的过滤器的大小(不管该层是最大池还是卷积层)，还乘以输入本身的大小。

2]3d 数据是什么样子的？

那么 3d CNN 的数据点是什么样的呢？

描绘它的一种方法是使用下面的图像(图 5):

图 5(版权所有:自有)

其他可用于 CNN 的现有数据集有:

• RGB-D 设备:谷歌 Tango 、微软 Kinect 等。
• 激光雷达
• 多幅图像的三维重建

3] **现在如何实现？！(**预处理和实现)

你可以自己试试我们正在使用的来自 Kaggle 的数据集上的代码。

需要导入的库如下:

首先，由于数据集有点特殊，我们使用下面的 to helper 函数在将它们提供给网络之前对它们进行处理。

另外，数据集存储为 h5 文件，因此要提取实际的数据点，我们需要从 h5 文件中读取数据，并使用 to _ categorical 函数将其转换为向量。在这一步中，我们还要准备交叉验证。

最后，3d CNN 的模型和语法如下:(架构是在没有太多改进的情况下挑选的，因为这不是本文的重点)

请注意，与 2d CNN 相比，对于相同数量的层，参数的数量要高得多。

供您参考，经过小样本训练，我们得到了以下准确度和损耗。(图 6)

图 6(版权所有:自有)

4]但是然后一个 3d？为什么

3d CNN 碰巧有许多应用，例如:

• IRM 的数据处理和由此得出的推论
• 自驾
• 距离估计

好了，差不多就这些了。我希望你尝试一下这项技术！源代码结束这里！

感谢您的阅读，如果您喜欢，请关注我、我的网站和我的脸书页面！

[## 经典神经网络:什么是真正的节点和层？

一个节点和一个层在数学上代表什么？简单易懂的幕后概念介绍。

towardsdatascience.com](/classical-neural-network-what-really-are-nodes-and-layers-ec51c6122e09) [## 卷积神经网络:为什么它们对图像相关学习如此有效？

快速解释为什么 CNN 现在几乎总是用于计算机视觉任务。

towardsdatascience.com](/convolutional-neural-networks-why-are-they-so-good-for-image-related-learning-2b202a25d757)

使用 Travis-CI 为您的 Python 项目构建最小 CI/CD 管道的分步教程

原文：https://towardsdatascience.com/step-by-step-tutorial-to-build-a-minimal-ci-cd-pipeline-for-your-python-project-using-travis-ci-c074e42f0c65?source=collection_archive---------21-----------------------

使用 Travis-CI、Codecov 和 Pypi 自动构建、测试和发布您的 Python 包。

Philipp Wüthrich 在 Unsplash 上的照片

如果您想在自动发布/部署包之前，节省在多种环境中测试 python 代码的时间，那么构建 CI/CD 管道非常有用。这也是一种及早发现错误并确保开发过程的一致性和可重复性的方法。

我最近参与了一个项目，该项目实现了一种相对较新的方法，将深度学习模型应用于结构化数据，该方法的细节可以在这里找到:使用半监督学习为结构化数据训练更好的深度学习模型。我想建立一个 CI/CD 管道来完成以下任务:

• 在每次合并请求时自动测试代码的。
• 计算并显示主分支的测试覆盖率。
• 如果登台分支上的构建通过了测试，python 包 /wheel 的自动部署到 PyPi。

为了做到这一点，我使用了 Github、 Travis-CI 和 Codecov、这两个软件对开源项目都是免费的。

步骤:

1)登录

第一步是使用您的 Github 帐户登录 Travis-CI，然后转到 settings 并激活您想要处理的存储库:

然后用 Codecov 做同样的事情:

最后是 PyPI，您需要通过转到 account setting 来生成一个访问令牌:

2)将 PyPI 令牌添加到 Travis-CI:

要自动发布包，您需要将 PyPI 令牌作为环境变量添加到 Travis-CI 中。在设置中:

3)代码

代码需要有一个 setup.py 文件以及一个 requirements.txt (如果需要的话)。例如，我的代码依赖于多个像 Tensorflow 或 Pandas 这样的库，所以我需要一个这样的需求文件:

**pandas**==**1.0.4
numpy**==**1.17.3
scipy**==**1.4.1
matplotlib**==**3.1.1
tensorflow_gpu**==**2.0.1
tqdm**==**4.36.1
scikit_learn**==**0.23.2
tensorflow**==**2.3.0**

您还需要实现一些测试，并将它们放在 tests/文件夹中。我的代码中的一个测试示例是在合成训练集上运行一个小训练，并通过在测试集上运行一个评估来检查网络是否学习了:

**from** deeptabular.deeptabular **import** (
    DeepTabularClassifier,
)
**import** pandas **as** pd
**import** numpy **as** np
**import** tensorflow **as** tf
**from** sklearn.metrics **import** accuracy_score

**def** test_build_classifier():
    classifier = DeepTabularClassifier(
        cat_cols=[**"C1"**, **"C2"**], num_cols=[**"N1"**, **"N2"**], n_targets=1, num_layers=1
    )
    df = pd.DataFrame(
        {
            **"C1"**: np.random.randint(0, 10, size=5000),
            **"C2"**: np.random.randint(0, 10, size=5000),
            **"N1"**: np.random.uniform(-1, 1, size=5000),
            **"N2"**: np.random.uniform(-1, 1, size=5000),
            **"target"**: np.random.uniform(-1, 1, size=5000),
        }
    )
    df[**"target"**] = df.apply(
        **lambda** x: 1 **if** (x[**"C1"**] == 4 **and** x[**"N1"**] < 0.5) **else** 0, axis=1
    )

    test = pd.DataFrame(
        {
            **"C1"**: np.random.randint(0, 10, size=5000),
            **"C2"**: np.random.randint(0, 10, size=5000),
            **"N1"**: np.random.uniform(-1, 1, size=5000),
            **"N2"**: np.random.uniform(-1, 1, size=5000),
            **"target"**: np.random.uniform(-1, 1, size=5000),
        }
    )
    test[**"target"**] = test.apply(
        **lambda** x: 1 **if** (x[**"C1"**] == 4 **and** x[**"N1"**] < 0.5) **else** 0, axis=1
    )

    classifier.fit(df, target_col=**"target"**, epochs=100, save_path=**None**)

    pred = classifier.predict(test)

    acc = accuracy_score(test[**"target"**], pred)

    **assert** isinstance(classifier.model, tf.keras.models.Model)
    **assert** acc > 0.9

4)管道

Travis-CI 中使用的管道被编写为 YAML 文件。例如，deeptabular 存储库中使用的是:

**language**: python
**python**:
  - **"3.6"** - **"3.7"
install**:
  - pip install -r requirements.txt
  - pip install codecov
  - pip install pytest-cov
  - pip install .
**script**:
  - pytest --cov-report=xml --cov=deeptabular tests/

**after_success**:
  - codecov

**deploy**:
  **provider**: pypi
  **user**: __token__
  **password**: $TEST_PYPI_TOKEN
  **distributions**: **"sdist bdist_wheel"
  skip_existing**: true
  **on**:
    **branch**: staging

首先选择要使用的 python 版本:

**python**:
  - **"3.6"** - **"3.7"**

然后安装库的需求加上库本身，pytest 和用于测试的 Codecov:

**install**:
  - pip install -r requirements.txt
  - pip install codecov
  - pip install pytest-cov
  - pip install .

运行测试并将测试覆盖结果写成 XML 格式:

**script**:
  - pytest --cov-report=xml --cov=deeptabular tests/

将覆盖报告推送到 codecov:

**after_success**:
  - codecov

最后，将包作为 zip 和 wheel 发布到 PyPI:

**deploy**:
  **provider**: pypi
  **user**: __token__
  **password**: $TEST_PYPI_TOKEN
  **distributions**: **"sdist bdist_wheel"
  skip_existing**: true
  **on**:
    **branch**: staging

然后将包推送到 PyPI:

测试覆盖结果可以在 Codecov:

结论:

就是这样，每当有代码被推送到任何分支时，这个管道就运行测试，如果 staging 分支发生变化，就将包发布到 PyPI。

参考资料:

1. https://dev . to/oscarmcm/distributing-pypi-packages-using-API-tokens-in-travisci-1n9i
2. 【https://docs.travis-ci.com/user/languages/python/ 号

代码:

【https://github.com/CVxTz/DeepTabular

将 Kubernetes 部署到您的 GCP 云的分步指南

原文：https://towardsdatascience.com/step-by-step-tutorial-to-deploy-kubernetes-to-your-gcp-cloud-171e739eedc2?source=collection_archive---------18-----------------------

实践教程

用动手练习揭开 Kubernetes 的神秘面纱！

由克里斯托弗·高尔在 Unsplash 上拍摄的照片

介绍

作为一名在实践中的数据科学家，我感受到了将数据处理、模型训练和推理的传统例行程序推入具有( CI/CD )持续集成/持续部署的集成管道的趋势，其概念是从 DevOps 借用的。至少从我的角度来看，有两个主要原因。一个是建模正在走出原型阶段，进入生产中模型的大规模采用，无论是作为一个附件还是应用程序。另一个原因是将整个建模体验带到云中的需求增加，以及模型开发的增强编排。

在这种需求的驱使下，我开始了我的技能提升之旅，使用了适合建模转型的工具，比如 Kubernetes。它现在很受欢迎，并获得了易于扩展、可移植性和可扩展性的声誉。这篇博客在这里特别展示了它提供的组件。然而，当我开始我的研究并得到它的时候，我感到被所有这些概念和“官方指南”淹没了，因为我不是一个训练有素的软件开发人员。我一点一点地咀嚼所有这些材料，并开始获得更完整的图片，即使我没有丰富的 DevOps 背景。我的笔记和理解都在这个教程中，我希望这对于那些也需要在 Kubernetes 中提升自己的人来说是一个简单而成功的开始。

一言以蔽之的库伯内特

Kubernetes 将自己定义为一个生产级的开源平台，在计算机集群内部和之间协调应用程序容器的执行。简而言之，Kubernetes 是一个为你组装几台计算机来执行应用程序的管理者。它是执行您分配给它的任务的指挥中心:安排应用程序、定期维护、扩展容量和推出更新。

来自 Kubernetes 的聚类图

Kubernetes 集群最基本的组件是主节点和节点。主服务器是管理器，是集群的中心。节点是虚拟机或物理计算机。每个节点都有一个 Kubelet 来管理它并与主节点通信。由于节点是一个虚拟机，我们还应该有 Docker/Container 作为工具来执行我们的应用程序。

Kubernetes 应用程序

现在我们知道了 Kubernetes 的基本知识，我们可能会开始想从数据科学家的角度来看它能做什么。以我的观点和经验，我确实发现 Kubernetes 的概念非常吸引人，尤其是当你认为建模最终应该作为应用程序/服务产品化的时候。当我们想让最终用户访问模型时，它阻碍许多产品设计者的问题，如可伸缩性和可扩展性也将是考虑的一部分。

谷歌提供了一份他们内部解决方案的应用程序列表。但是我们在这里想要实现的是根据我们的需求和目的来使用和定制 Kubernetes。因此，本教程将自下而上，从基础开始设置 GCP，一直到在 Kubernetes 集群上部署应用程序。

步骤 0。GCP 设置

在本教程中，我们将使用 Google Kubernetes 引擎来建立一个 Kubernetes 集群。但是在开始之前，请确保满足以下先决条件:

1. 在 GCP 获得一个账号，登录控制台。
2. 在控制台中，启用 Kubernetes Engine AP I .你可以在 API 库中找到一个库 API，只需搜索名称即可。

API 库(图片由作者提供)

3.安装 gcloud 。您可以使用基于网络的终端或您自己的计算机终端。要在 GCP 控制台中找到基于 web 的终端:

单击红色框中的图标(图片由作者提供)

建议按照官方指南安装 gcloud，但为了方便起见，您也可以使用以下命令:

4.安装 kubectl。这一步很简单:设置 gcloud 后，输入命令:

gcloud components install kubectl

第一步。Kubernetes 设置

一旦我们完成了前面的所有步骤，项目现在可以使用 Google Cloud SDK 来创建一个托管的 Kubernetes 集群。

1. 要使用 gcloud 创建容器集群:

gcloud container clusters create \
--machine-type n1-standard-2 \
--num-nodes 3\
--zone <compute zone from the list linked below> \
--cluster-version latest \
<CLUSTERNAME>

• 机器类型:用于节点的机器类型。
• num-nodes :要在每个集群区域中创建的节点数量。您可以将其设置为 1 来创建一个单节点集群，但是构建一个 Kubernetes 集群至少需要 3 个节点。稍后可以使用 gcloud 命令调整大小。
• zone :计算集群的 zone (例如 us-central1-a)。

如果集群创建正确，它将显示如下信息:

2.为了测试新设置的集群，我们可以使用 kubectl:

kubectl get node

3.接下来，我们将授予用户执行管理操作的权限。

kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole**=**cluster-admin \
  --user**=**<GOOGLE-EMAIL-ACCOUNT>

4.安装舵。Helm 是 Kubernetes 应用程序的包管理器。您可以使用导航图来搜索要部署到 Kubernetes 的应用程序/包。Helm Chart 是预设的抽象概念，用来描述如何将包安装到 Kubernetes

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

安装 Helm 后，我们可以通过调用以下命令来检查集群中安装了什么:

helm list

现在你的 Kubernetes 已经准备好了！祝贺🤓

第二步。Kubernetes 的应用

以 JupyerHub 为例

在开始安装过程之前，从较高的层次进行检查并了解它的样子总是有帮助的。在前面的步骤中，我们已经完成了安装 Helm 的 Kubernetes 集群的设置。现在，我们想为它部署一个应用程序，并开始使用它。对于这里的例子，我将使用可以服务多个用户的 JupyterHub。下面是这个练习的结构，以便于参考。

安装结构(图片由作者使用 LucidChart 提供)

1. 安全设置

• 生成代理安全令牌。出于安全考虑，强烈建议不要在没有 SSL 加密的情况下运行 JupyerHub。用openssl rand -hex 32简单生成。将生成的令牌保存在记事本中以备后用。
• 向您的[代理](http://penssl rand -hex 32)添加令牌。它可以在配置文件中设置，也可以使用或存储为环境变量。然而，由于我们已经安装了 Helm，我们可以使用helm来模板化yaml文件以添加 SSL 令牌。下面是您用上一步生成的令牌提供给yaml的格式。我们稍后将把它添加到配置文件中。

**proxy:**
  **secretToken:** "<SSL_Token>"

2.添加配置

JupyterHub 就如何设置配置提供了非常全面的指南。我正在添加一些有用的自定义数据科学的目的。您也可以参考指南来设置您的定制或使用参考此处的来导航您的需求。

• 图片:我们可以从这里提供的综合列表中添加数据科学笔记本图片。还有，记得用标签代替latest。你的图片标签可以在 DockerHub 中找到，数据科学笔记本的标签信息可以在这里找到。
• 内存:我们为你的用户指定存储限制。这将向 Kubernetes API 发送请求。

如果您只想遵循示例，只需复制并粘贴上面的内容，并替换必要的凭证。使用nano config.yaml或vim config.yaml创建yaml文件并替换内容。

3.用舵安装。以下脚本将使用helm upgrade安装 JupyterHub。有关该命令的详细信息，请查看此处的以供参考。

对于将来使用helm的升级，我们不需要创建名称空间。

JupyterHub 的指南对这一部分做了非常透彻的解释，我个人认为阅读起来非常有帮助。RELEASE指定您希望如何从helm命令调用，NAMESPACE是您希望与kubectl一致的内容。

在 helm 开始安装的时候休息一下，一旦安装完成，你将会看到 JupyterHub 的结束信息。如果您需要对该步骤中的任何问题进行故障诊断，请参考指南或使用kubectl get events检索日志并自己找出发生了什么。

4.检查状态并测试您的 JupyterHub。正确设置后，我们应该通过调用以下命令看到集线器准备就绪:

kubectl —-namespace=jhub get pod

要通过集群访问集线器，请调用以下命令来获取 IP 地址:

kubectl --namespace=jhub get svc proxy-public

将您的外部 IP 复制并粘贴到一个新的浏览器，它应该会将您导航到 JupyerHub 登录页面。您可以将自己的 JupyterHub 用于 Kubernetes 集群。

JupyterHub 界面(图片由作者提供)

请注意，我们没有为用户设置任何身份验证，所以我们只需输入随机的用户名和密码即可开始。但是，如果您正在寻找更多的安全性来保护您的集群，请检查此链接来设置您的 JupyerHub 身份验证。

打扫卫生。&最终想法

如果你什么都不做就让云闲置，那它就不便宜。所以如果你不再需要你的集群，建议将删除它。

# Retrieve the cluster **gcloud container clusters list**# Delete the cluster**gcloud container clusters delete <CLUSTER-NAME>**

我从这个例子的实现中学到了很多，希望你也有同感。Kubernetes 并不完全是神秘的，作为一名数据科学家，即使没有事先培训，也可以理解基本原理并获得实际应用。我将继续用 Kubernetes 写我的研究、想法和应用，并用简单明了的语言揭开的神秘面纱。和平！🤗

分步教程:用 BeautifulSoup 抓取维基百科

原文：https://towardsdatascience.com/step-by-step-tutorial-web-scraping-wikipedia-with-beautifulsoup-48d7f2dfa52d?source=collection_archive---------1-----------------------

我的室友和我讨论了她对瑞典高抑郁率的观察。我们得出了抑郁率和缺少阳光之间的联系。我决定通过收集自己的数据并进行分析来支持我的假设。

我使用 Beautiful Soup，这是一个易于使用的 Python web 抓取工具。我喜欢这个工具的原因是它易于使用和理解。库的文档可以在这里找到。

准备

假设:一个国家的日照时间越少，这个国家的抑郁率就越高。

要收集的数据:

• 国家名称
• 他们的抑郁率
• 他们的日照时间

要使用的资源:

• https://en.wikipedia.org/wiki/Epidemiology_of_depression
• https://en . Wikipedia . org/wiki/List _ of _ cities _ by _ sunshine _ duration

开始

import requests
import urllib.request
import time
from bs4 import BeautifulSoup
import numpy as np
import pandas as pd
from urllib.request import urlopenurl = 'https://en.wikipedia.org/wiki/Epidemiology_of_depression'html = urlopen(url) soup = BeautifulSoup(html, 'html.parser')

右键单击页面，然后转到检查。单击上面显示的图标，选择网站中要检查的元素。

我们对从表格中提取信息感兴趣。这可以用一行代码轻松完成。通过检查，我们发现这张桌子被贴上了<table>标签。

find_all('table')扫描整个文档寻找标签<table>

tables = soup.find_all('table')

find_all()是一个简单有效的方法，在本教程中会经常用到。

收集数据

因为“，”，看起来DALY rate列中的数据在收集时将是一个字符串。创建一个函数，通过使用 re.sub()将字符串处理成整数，这是一个返回与正则表达式匹配的子字符串的方法。

import re
def process_num(num):
    return float(re.sub(r'[^\w\s.]','',num))

测试功能

num1 = float(re.sub(r'[^\w\s.]','','1,156.30'))
num1

产量:1156.30

我们来分析一下。

第 6–7 行:我们注意每一行都在<tr>标签下。这给了我们一个想法，我们将通过找到所有的标签<tr>来得到这些行

第 9–10 行:通过查找所有<td> tags来提取行

第 14 行:由于第一行的len(cells)是 1，我们设置条件跳过第一行，从其他行提取。

第 15 行:因为cells是 3 个单元格的列表，我们使用第一个单元格提取排名，使用第二个单元格提取国家名称，使用第三个单元格提取 DALY 比率。

把数据放入pandas.DataFrame

df1 = pd.DataFrame(ranks, index= countriescolumns = ['Rank'])df1['DALY rate'] = ratesdf1.head(10)

使用与上述相同的方法从第二个网站收集日照时数。请记住，这两个网站的数据有两个不同之处:

• 同一个国家的日照时数有多种数据。因此，我们可能希望取这些数据的平均值，以获得每个国家的小时数。为了取平均值，我们简单地使用两个字典，country_suns 和count，它们具有相同的关键字但不同的值。
• 第二次数据中的一些国家在第一次数据中没有。因此，我们只想从第一个数据中的国家收集数据，这些数据存储在上面创建的变量countries中。

结果:

789.14 3
Country: Benin, Sunshine Hours: 263.05
515.99 2
Country: Togo, Sunshine Hours: 258.0
710.25 3
Country: Ghana, Sunshine Hours: 236.75
866.0500000000001 4
Country: Cameroon, Sunshine Hours: 216.51
344.03999999999996 2
Country: Gabon, Sunshine Hours: 172.02
1334.54 5
Country: Nigeria, Sunshine Hours: 266.91
711.91 2
Country: Sudan, Sunshine Hours: 355.95
336.1 1
...

清理数据

使用 join 方法连接我们之前收集的两个数据。

df2 = pd.DataFrame.from_dict(country_suns,orient='index', columns = ['Sunshine Hours/Year'])df = df1.join(df2)df.info()

结果:

<class 'pandas.core.frame.DataFrame'>
Index: 192 entries, United States to Japan
Data columns (total 3 columns):
Rank                   192 non-null int64
DALY rate              192 non-null float64
Sunshine Hours/Year    122 non-null float64
dtypes: float64(2), int64(1)
memory usage: 11.0+ KB

我们意识到最后一列中有空值，因为第一个来源中的一些国家不在第二个来源中。有许多方法可以处理缺失值。但是现在，只需删除缺少值的行，就可以直观地看到我们得到了什么。

df.dropna(inplace=True)

将数据可视化

import matplotlib.pyplot as plt
import seaborn as snssns.scatterplot('Rank', 'Sunshine Hours/Year', data=df)

这里似乎没有很强的相关性。看一下相关系数。

如果要使用不同的工具处理数据，请保存数据。

df.to_csv('wiki-2.csv')

结论

相关性没有我想象的那么强。但是我们没有考虑到不同的因素，如确定抑郁率的指标的准确性，国家的大小(国家越大，日照时数/年的变化越大)，GDP，人口等。应该收集更多的数据以获得更准确的结果。但在此之前，要为自己感到骄傲，因为你刚刚学会了网络搜集，这是数据科学中最重要的过程之一。

本教程的 Github 库可以在这里找到:https://github.com/khuyentran1401/Web-Scrapping-Wikipedia。

我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和 Twitter 上联系我。

如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:

参考

[1]抑郁症流行病学，维基百科

[2]根据日照时间列出的城市列表，维基百科

[3]Varun Choudhary，如何抓取网站而不被列入黑名单(2019)，Hackernoon

循序渐进:Python 中的 Twitter 情感分析

原文：https://towardsdatascience.com/step-by-step-twitter-sentiment-analysis-in-python-d6f650ade58d?source=collection_archive---------0-----------------------

图片由皮克斯拜的 Gerd Altmann 提供

通过分析人们分享的推文，了解人们对一个话题的看法不再困难。情感分析是 NLP(自然语言处理)最流行的用例之一。

在这篇文章中，我将使用**“Tweepy”，**，这是一个易于使用的 Python 库，用于访问 Twitter API。您需要有一个 Twitter 开发人员帐户和样本代码来做这个分析。你可以在我的 Github 库中找到 Jupyter 笔记本代码。

这篇文章的目的是分析人们对伦敦第二次封锁的看法。

步骤 1:安装并导入库

在分析之前，需要使用 安装 textblob 和 tweepy 库！pip 在你的 Jupyter 笔记本上安装 命令。

# Install Libraries
!pip install textblob
!pip install tweepy

您需要导入将在这个情感分析项目中使用的库。

# Import Librariesfrom textblob import TextBlob
import sys
import tweepy
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import os
import nltk
import pycountry
import re
import stringfrom wordcloud import WordCloud, STOPWORDS
from PIL import Image
from nltk.sentiment.vader import SentimentIntensityAnalyzer
from langdetect import detect
from nltk.stem import SnowballStemmer
from nltk.sentiment.vader import SentimentIntensityAnalyzer
from sklearn.feature_extraction.text import CountVectorizer

Tweepy 支持 OAuth 1a(应用程序用户)和 OAuth 2(仅应用程序)身份验证。身份验证由 tweepy 处理。AuthHandler 类。

OAuth 2 是一种身份验证方法，其中应用程序在没有用户上下文的情况下发出 API 请求。如果您只需要对公共信息进行只读访问，请使用此方法。

您首先注册我们的客户端应用程序，并获得一个消费者密钥和秘密。然后创建一个 AppAuthHandler 实例，传入我们的消费者密钥和秘密。

认证之前，你需要有 **Twitter 开发者账号。**如果没有，可以通过使用此 链接 进行申请。获得 Twitter 开发者账户通常需要一两天，有时甚至更长时间，你的申请才会被 Twitter 审核。

步骤 Twitter API 的认证

# Authentication
consumerKey = “Type your consumer key here”
consumerSecret = “Type your consumer secret here”
accessToken = “Type your accedd token here”
accessTokenSecret = “Type your access token secret here”auth = tweepy.OAuthHandler(consumerKey, consumerSecret)
auth.set_access_token(accessToken, accessTokenSecret)
api = tweepy.API(auth)

在您认证之后，您需要使用 tweepy 获取文本，并使用 Textblob 从文本中计算出正、负、中性、极性和复合参数。

第三步:获取带有关键词或标签的推文

#Sentiment Analysisdef percentage(part,whole):
 return 100 * float(part)/float(whole)keyword = input(“Please enter keyword or hashtag to search: “)
noOfTweet = int(input (“Please enter how many tweets to analyze: “))tweets = tweepy.Cursor(api.search, q=keyword).items(noOfTweet)
positive = 0
negative = 0
neutral = 0
polarity = 0
tweet_list = []
neutral_list = []
negative_list = []
positive_list = []for tweet in tweets:

 #print(tweet.text)
 tweet_list.append(tweet.text)
 analysis = TextBlob(tweet.text)
 score = SentimentIntensityAnalyzer().polarity_scores(tweet.text)
 neg = score[‘neg’]
 neu = score[‘neu’]
 pos = score[‘pos’]
 comp = score[‘compound’]
 polarity += analysis.sentiment.polarity

 if neg > pos:
 negative_list.append(tweet.text)
 negative += 1elif pos > neg:
 positive_list.append(tweet.text)
 positive += 1

 elif pos == neg:
 neutral_list.append(tweet.text)
 neutral += 1positive = percentage(positive, noOfTweet)
negative = percentage(negative, noOfTweet)
neutral = percentage(neutral, noOfTweet)
polarity = percentage(polarity, noOfTweet)
positive = format(positive, ‘.1f’)
negative = format(negative, ‘.1f’)
neutral = format(neutral, ‘.1f’)

这篇文章中的场景是这样的，用户应该键入关键字或标签( lockdown2 london )并键入想要获取和分析多少条推文( 2500 )。

因为有限制，tweets 参数的数量很重要。

作者图片

在收到 2500 条关于“封锁伦敦”的推文后，让我们看看有多少条推文表达了这种情绪

#Number of Tweets (Total, Positive, Negative, Neutral)tweet_list = pd.DataFrame(tweet_list)
neutral_list = pd.DataFrame(neutral_list)
negative_list = pd.DataFrame(negative_list)
positive_list = pd.DataFrame(positive_list)
print(“total number: “,len(tweet_list))
print(“positive number: “,len(positive_list))
print(“negative number: “, len(negative_list))
print(“neutral number: “,len(neutral_list))

你会收到 2500 条推文。

• 1025 条推文(41.0%) 包含正面情绪
• 580 条(23.2%) 条推文中包含负面情绪
• 895 条(35.8%) 条推文包含中性情绪

#Creating PieCartlabels = [‘Positive [‘+str(positive)+’%]’ , ‘Neutral [‘+str(neutral)+’%]’,’Negative [‘+str(negative)+’%]’]
sizes = [positive, neutral, negative]
colors = [‘yellowgreen’, ‘blue’,’red’]
patches, texts = plt.pie(sizes,colors=colors, startangle=90)
plt.style.use(‘default’)
plt.legend(labels)
plt.title(“Sentiment Analysis Result for keyword= “+keyword+”” )
plt.axis(‘equal’)
plt.show()

作者图片

让我们看看推文列表。

tweet_list

作者图片

第四步:清理推文以分析情绪

当你查看 tweet 列表时，你可以看到一些重复的 tweet，所以你需要使用 drop_duplicates 函数删除重复的记录。

tweet_list.drop_duplicates(inplace = True)

作者图片

我们的新数据框有 1281 条独特的推文。

首先，我创建一个新的数据框(tw_list)和一个新的特征(text)，然后使用 lambda 函数清洗文本，清洗 RT、link、标点符号字符，最后转换成小写。

#Cleaning Text (RT, Punctuation etc)#Creating new dataframe and new features
tw_list = pd.DataFrame(tweet_list)
tw_list[“text”] = tw_list[0]#Removing RT, Punctuation etc
remove_rt = lambda x: re.sub(‘RT @\w+: ‘,” “,x)
rt = lambda x: re.sub(“(@[A-Za-z0–9]+)|([⁰-9A-Za-z \t])|(\w+:\/\/\S+)”,” “,x)
tw_list[“text”] = tw_list.text.map(remove_rt).map(rt)
tw_list[“text”] = tw_list.text.str.lower()
tw_list.head(10)

作者图片

第五步:情感分析

现在，我可以使用清理后的文本再次计算极性、主观性、情绪、负面、正面、中性和复合参数。对于所有计算的参数，我在数据框中创建新要素

#Calculating Negative, Positive, Neutral and Compound valuestw_list[[‘polarity’, ‘subjectivity’]] = tw_list[‘text’].apply(lambda Text: pd.Series(TextBlob(Text).sentiment))
for index, row in tw_list[‘text’].iteritems():
 score = SentimentIntensityAnalyzer().polarity_scores(row)
 neg = score[‘neg’]
 neu = score[‘neu’]
 pos = score[‘pos’]
 comp = score[‘compound’]
 if neg > pos:
 tw_list.loc[index, ‘sentiment’] = “negative”
 elif pos > neg:
 tw_list.loc[index, ‘sentiment’] = “positive”
 else:
 tw_list.loc[index, ‘sentiment’] = “neutral”
 tw_list.loc[index, ‘neg’] = neg
 tw_list.loc[index, ‘neu’] = neu
 tw_list.loc[index, ‘pos’] = pos
 tw_list.loc[index, ‘compound’] = comptw_list.head(10)

作者图片

您可以根据情绪将数据框分为 3 组。对于这一个，创建 3 个新数据帧(tw_list_negative、tw_list_positive、tw_list_neutral)并从原始 tw_list 数据帧导入

#Creating new data frames for all sentiments (positive, negative and neutral)tw_list_negative = tw_list[tw_list[“sentiment”]==”negative”]
tw_list_positive = tw_list[tw_list[“sentiment”]==”positive”]
tw_list_neutral = tw_list[tw_list[“sentiment”]==”neutral”]

让我们计算情感特征的值，并查看总百分比。

#单列中 count _ values _ 的函数

def count_values_in_column(data,feature):
 total=data.loc[:,feature].value_counts(dropna=False)
 percentage=round(data.loc[:,feature].value_counts(dropna=False,normalize=True)*100,2)
 return pd.concat([total,percentage],axis=1,keys=[‘Total’,’Percentage’])#Count_values for sentiment
count_values_in_column(tw_list,”sentiment”)

作者图片

你可以通过使用情绪推文的数量来创建一个图表。

# create data for Pie Chart
pichart = count_values_in_column(tw_list,”sentiment”)
names= pc.index
size=pc[“Percentage”]

# Create a circle for the center of the plot
my_circle=plt.Circle( (0,0), 0.7, color=’white’)
plt.pie(size, labels=names, colors=[‘green’,’blue’,’red’])
p=plt.gcf()
p.gca().add_artist(my_circle)
plt.show()

作者图片

现在你可以准备使用 1281 条推文创建 worcloud，这样你就可以知道哪些词在这些推文中使用得最多。要创建 worcloud，首先让我们定义下面的函数，这样你就可以再次使用 wor cloud 来处理所有的推文，正面推文，负面推文等等。

#Function to Create Wordclouddef create_wordcloud(text):
 mask = np.array(Image.open(“cloud.png”))
 stopwords = set(STOPWORDS)
 wc = WordCloud(background_color=”white”,
 mask = mask,
 max_words=3000,
 stopwords=stopwords,
 repeat=True)
 wc.generate(str(text))
 wc.to_file(“wc.png”)
 print(“Word Cloud Saved Successfully”)
 path=”wc.png”
 display(Image.open(path))

定义了这个函数后，你就可以查看所有推文的 wordcloud 了

#Creating wordcloud for all tweets
create_wordcloud(tw_list[“text”].values)

作者图片

针对具有积极情绪的推文的词云；

#Creating wordcloud for positive sentiment
create_wordcloud(tw_list_positive[“text”].values)

作者图片

针对带有负面情绪的推文的词云；

#Creating wordcloud for negative sentiment
create_wordcloud(tw_list_negative[“text”].values)

作者图片

我们来计算一下推文长度和字数。因此，你可以看到基于不同情绪的推文中使用的单词和字符的密度。

#Calculating tweet’s lenght and word count
tw_list[‘text_len’] = tw_list[‘text’].astype(str).apply(len)
tw_list[‘text_word_count’] = tw_list[‘text’].apply(lambda x: len(str(x).split()))round(pd.DataFrame(tw_list.groupby("sentiment").text_len.mean()),2)

作者图片

round(pd.DataFrame(tw_list.groupby(“sentiment”).text_word_count.mean()),2)

作者图片

应用计数矢量器可在生成矢量表示之前对文本数据进行预处理，使其成为高度灵活的文本特征表示模块。在计数矢量器之后，可以用两个或三个或者任何你想要的来分析单词。

应用词干分析器还可以提供单词的词根。所以你可以排除来自同一个词根的单词，比如；

• 连接
• 关系
• 连接的
• 连接
• 连接

来源于**“连接”。如果您应用词干分析器功能，您可以认为这些单词是相同的**

#Removing Punctuation
def remove_punct(text):
 text = “”.join([char for char in text if char not in string.punctuation])
 text = re.sub(‘[0–9]+’, ‘’, text)
 return texttw_list[‘punct’] = tw_list[‘text’].apply(lambda x: remove_punct(x))#Appliyng tokenization
def tokenization(text):
    text = re.split('\W+', text)
    return texttw_list['tokenized'] = tw_list['punct'].apply(lambda x: tokenization(x.lower()))#Removing stopwords
stopword = nltk.corpus.stopwords.words('english')
def remove_stopwords(text):
    text = [word for word in text if word not in stopword]
    return text

tw_list['nonstop'] = tw_list['tokenized'].apply(lambda x: remove_stopwords(x))#Appliyng Stemmer
ps = nltk.PorterStemmer()def stemming(text):
    text = [ps.stem(word) for word in text]
    return texttw_list['stemmed'] = tw_list['nonstop'].apply(lambda x: stemming(x))#Cleaning Text
def clean_text(text):
    text_lc = "".join([word.lower() for word in text if word not in string.punctuation]) # remove puntuation
    text_rc = re.sub('[0-9]+', '', text_lc)
    tokens = re.split('\W+', text_rc)    # tokenization
    text = [ps.stem(word) for word in tokens if word not in stopword]  # remove stopwords and stemming
    return texttw_list.head()

应用 countverctorizer 后，两个结果显示所有 1281 条 tweets 有 2966 个独特的单词。

如果您看一下我们的数据框，您会看到一些新功能，如点状、标记化、不间断、词干化。

作者图片

现在，您可以应用 coun 矢量器将所有 2966 个唯一的单词视为一个新功能。

#Appliyng Countvectorizer
countVectorizer = CountVectorizer(analyzer=clean_text) 
countVector = countVectorizer.fit_transform(tw_list[‘text’])
print(‘{} Number of reviews has {} words’.format(countVector.shape[0], countVector.shape[1]))
#print(countVectorizer.get_feature_names())1281 Number of reviews has 2966 wordscount_vect_df = pd.DataFrame(countVector.toarray(), columns=countVectorizer.get_feature_names())
count_vect_df.head()

作者图片

您可以按降序对值进行排序，以查看最常用的单词

# Most Used Words
count = pd.DataFrame(count_vect_df.sum())
countdf = count.sort_values(0,ascending=False).head(20)
countdf[1:11]

作者图片

建立 n 元模型有助于我们预测最有可能出现在这个序列之后的单词。首先让我们创建一个函数，然后构建 n2_bigram，n3_trigram 等。

#Function to ngram
def get_top_n_gram(corpus,ngram_range,n=None):
 vec = CountVectorizer(ngram_range=ngram_range,stop_words = ‘english’).fit(corpus)
 bag_of_words = vec.transform(corpus)
 sum_words = bag_of_words.sum(axis=0) 
 words_freq = [(word, sum_words[0, idx]) for word, idx in vec.vocabulary_.items()]
 words_freq =sorted(words_freq, key = lambda x: x[1], reverse=True)
 return words_freq[:n]#n2_bigram
n2_bigrams = get_top_n_gram(tw_list[‘text’],(2,2),20)n2_bigrams

作者图片

#n3_trigram
n3_trigrams = get_top_n_gram(tw_list[‘text’],(3,3),20)n3_trigrams

作者图片

最后，你可以使用 tweets 来分析情绪，你可以意识到哪些词最常用，哪些词一起使用。

感谢你阅读我的帖子，希望你喜欢。如果您有任何问题或想要分享您的意见，请随时联系我。