TowardsDataScience 博客中文翻译 2020（二百四十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

使用数据科学家工具包创建考试档案系统

原文：https://towardsdatascience.com/creating-an-exam-archive-system-with-a-data-scientists-toolkit-a080d497a9a0?source=collection_archive---------53-----------------------

利用 R Shiny 更好地准备考试

图片由 tjevans 来自 Pixabay

随着新冠肺炎疫情中关于大学生晋升标准的不确定性的增加，我决定创建一个集中的平台来聚合来自学生自己的考试资源。

动机:

对任何人来说，每天更新的与新冠肺炎相关的新病例和死亡都是令人痛苦的。然而，大学生不得不处理过多的额外问题，从被取消的工作机会到下学期晋升的不确定性。这也是我的队友们越来越焦虑的一个原因。所以，这个项目是我决定尽自己的一份力量来帮助我的同学和大学同学的原因。

向未知领域展示 R Shiny:

我最近被谷歌选中参加一个著名的暑期项目，该项目隶属于统计计算的 R 项目。我的项目基本上包括开发一个 R 包，让你的 R 代码更加高效。因此，我认为用 R Shiny 进行这个项目可以让我对我的夏季项目有更多的优化想法，因此我选择了 R Shinydashboard 。

正如你可能已经意识到的，R Shiny 主要用于创建仪表板，并在数据分析、争论、操作等之后，交互式地交流你的发现。然而，我的项目是一个典型的 web 开发项目，几乎没有任何与数据相关的元素。尽管如此，我还是继续进行下去，以便为我的夏季奖学金项目发现新的优化想法。

使用这种方法，我必然会面临许多挑战，我将在接下来的章节中讨论这些挑战。

编码策略:

通常一个 R Shiny 项目被分成两个文件，一个 ui。r 文件和一个服务器。r 文件。但是，名为 app 的单个文件。也可以使用 r。

ui。稀有

1. 在侧栏面板中，我首先列举了该应用程序的所有预期功能，包括上传和下载试卷的 功能，这些试卷的解决方案和课堂笔记 。
2. 我还包含了" shinyWidgets “库，这样我就可以在成功上传文件时使用” SweetAlert "以及"downloadbtn"与默认的 R Shiny "download button"相比，它提供了更多的定制选项
3. 我使用 fluidRow 框创建了几个输入字段来收集关于正在上传的论文的信息。我还使用了fileInput()函数的“ 接受 ”参数，只接受 PDF 文件。
4. 我从“字体真棒”网站上选择了图标，并在“关于”部分使用了class = “fa-spin”来吸引人们的注意。

代表性代码，完整的代码向下滚动到结论

服务器。稀有

1. 为了持久存储上传的 PDF 文件，我不得不使用一个包含“ pdftools ”库的解决方案。
2. 选择学期后，我希望科目选项仅限于该学期的科目。这是我用助手函数和req()函数实现的。
3. 在论文/笔记等成功上传后，我想发送一个成功通知，这是我通过包含“ shinyWidgets ”库和使用observeEvent()代码块实现的。
4. 为了从我的本地存储器(我的“www”文件夹)开始下载，在“download handler”中，我将filename参数转换成一个函数，并用file.copy()函数调用了content 参数中的那个函数。

代表性的代码，完整的代码向下滚动到结论

完整应用程序的片段:

web 应用程序的登录页面

上传成功后的温馨提示

下载选项以及所选解决方案的可用选项

结论:

所以，如果你对这个特别的 R Shiny web app 的代码感兴趣，点击这里。

如果你有兴趣看到这个网络应用的现场和部署版本，点击这里。

鉴于 Shiny 的内在能力，这款网络应用对移动用户的响应也足够快。如果你喜欢我的这个项目，看看我之前创建的仪表板这里。

在从事这个项目的过程中，我发现了一些棘手的问题，我将在以后的文章中列举这些常见的陷阱以及如何避免它们。所以，请继续关注，稍后见。

你也可以给我买杯咖啡来支持我的工作。

谢谢你，祝你成功。

用 Jupyter 笔记本创建一个交互式仪表板

原文：https://towardsdatascience.com/creating-an-interactive-dashboard-from-jupyter-notebook-with-voila-b64918b4d15a?source=collection_archive---------4-----------------------

…以及如何将仪表板部署到 Heroku

照片由艾萨克·史密斯在 Unsplash 拍摄

随着 PowerBI 和 Tableau 等 BI 工具的出现，当你想创建一个交互式仪表板时，Jupyter Notebook 可能不会是你脑海中出现的第一个工具。然而，由于 Voila，现在可以直接从 Jupyter Notebook 构建交互式仪表板。

在本文中，我想向您展示如何使用 Jupyter Notebook 创建交互式绘图，将它们转换为独立的仪表板，然后使用 Heroku 将其部署在云上，以便其他人可以看到您的仪表板。所以，让我们开始吧！

加载数据

在本文中，我将使用旧金山数据集。该数据集包含 2016 年发生在旧金山的超过 150，000 行犯罪历史。

像往常一样，我们可以用熊猫加载数据集。为了了解数据集的样子，让我们打印出数据集的前五行。

因为这篇文章的目的是展示如何使用 Voila 将 Jupyter 笔记本中的交互式可视化变成独立的仪表板，所以我不打算对这个数据集进行 EDA。让我们开始创建小部件，为这个数据集的可视化添加交互性。

创建交互式小部件

现在我们已经加载了数据，我们可以立即开始创建小部件。这些小部件是为我们的可视化添加交互性的基本要素。在本文中，我们将使用三个部件:一个滑块部件和两个多选部件。要创建这些小部件，我们可以使用 Jupyter Notebook 的ipywidgets库。

我们要创建的第一个小部件是 slider 小部件。为此，我们可以使用来自ipywidgets的IntSlider()属性。这个 slider 小部件将控制熊猫应该加载多少行数据集。例如，如果滑块值是 1000，那么 Pandas 应该加载数据集的前 1000 行。下面是它的代码实现。

import ipywidgets as widgets
import pandas as pdstyle = {'description_width': 'initial'}limit_case = widgets.IntSlider(
    value=1000,
    min=100,
    max=5000,
    step=1,
    description='Max Number of Case:',
    disabled=False,
    style=style)

在上面的代码中，我们从ipywidgets向IntSlider()属性传递了几个参数。第一个是value，这是我们运行代码时会显示的默认值。接下来，min和max是滑块中可以考虑的最小和最大范围值。同时，step是我们上下移动滑块时的增量或减量。最后，我们添加了style参数，这样description中的单词就不会被截断。

接下来，使用来自ipywidgets的interactive()属性，我们可以将小部件与我们想要交互更改其值的变量链接起来。现在，如果我们更改滑块值，我们可以看到数据集的长度也会相应地更改。

如果您运行上面的代码单元，您将得到一个类似这样的交互式滑块小部件。

接下来，让我们创建第二个小部件，它是多选小部件。我们可以通过使用ipywidgets中的SelectMultiple()属性来实现这一点。有了这个小工具，我们可以选择只在特定的选区而不是所有的选区可视化犯罪。为了创建这个多选小部件，下面是代码实现。

import pandas as pd
import ipywidgets as widgets
from ipywidgets import Layoutdf = pd.read_csv('SF_crimes.csv')unique_district = df.PdDistrict.unique()district = widgets.SelectMultiple(
    options = unique_district.tolist(),
    value = ['BAYVIEW', 'NORTHERN'],
    description='District',
    disabled=False,
    layout = Layout(width='50%', height='80px', display='flex')
)

在上面的代码中，我们使用SelectMultiple()属性来选择区域变量的多个值。我们应该指定的第一个参数是options，它应该包含变量的可用选项列表(在我们的例子中是不同种类的旧金山地区)。下一个是value，它应该包含我们希望默认显示的变量值，然后description是用于描述小部件名称的文本字段。

如果您运行上面的代码单元格，您将得到下面的交互式多选小部件。

最后，我们可以创建第三个小部件，它与前面的多选小部件完全相同。这个小部件的目的是让我们能够选择想要可视化的犯罪类别。下面是这个小部件的代码实现。

import pandas as pd
import ipywidgets as widgets
from ipywidgets import Layoutdf = pd.read_csv('SF_crimes.csv')unique_cat = df.Category.unique()style = {'description_width': 'initial'}category = widgets.SelectMultiple(
    options = unique_cat.tolist(),
    value = ['VANDALISM', 'ASSAULT', 'ROBBERY'],
    description='Criminal Case',
    disabled=False,
    style=style,
    layout = Layout(width='50%', height='80px')
)

我们传递给这个SelectMultiple()属性的参数与之前相同，只是value和options参数是犯罪类别而不是地区。

如果您运行上面的代码单元格，您将得到下面的小部件。

接下来，我们希望将之前创建的所有三个小部件结合起来，创建一个交互式可视化。为了可视化犯罪地点，我们可以用地图来可视化它们，因为我们在数据集中有关于纬度和经度的信息。

为了将数据集可视化成地图，我们可以使用folium库。如果还没有安装folium，可以使用 pip 命令安装。

pip install folium

我们可以将地图与小部件集成在一起，这样当我们用小部件做出不同的选择时，可视化就会相应地调整。

首先，slider 小部件的值将决定我们应该在可视化中考虑的数据集中的犯罪数量。接下来，地图应该会根据我们使用多选小部件的选择显示犯罪类别和地区。

为了创建额外的可视化，我们还可以创建两个条形图。一个条形图显示有多少犯罪基于我们使用小部件选择的类别。另一个图表显示了我们使用小部件选择的地区有多少起犯罪。

最后，我们需要定义一个函数，将所有三个小部件与我们的地图可视化和两个条形图集成在一起。

下面是从头到尾完成所有这些工作的完整代码实现。

现在，如果我们调用上面 Jupyter 笔记本的最后一个代码单元中的函数update_map,我们将根据我们在所有三个小部件中选择的值获得地图和条形图可视化的交互性。

现在我们已经完成了 Jupyter Notebook 的工作，在ipywidgets库的帮助下创建交互式可视化效果！

用 Jupyter 创建一个仪表板

到目前为止，我们已经在ipywidgets、matplotlib和folium库的帮助下创建了交互式可视化。现在，你可以开始向其他人展示你的 Jupyter 笔记本中的可视化。

然而，在大多数情况下，您将向非技术人员展示可视化，这些人对查看您笔记本中的大量 Python 代码不感兴趣，只想看到清晰的可视化。因此，使用 Jupyter 笔记本来显示交互式可视化并不是最佳选择。

要将 Jupyter 笔记本上的可视化转换为独立的仪表板，我们可以使用 Voila。现在，如果您还没有安装 Voila，您可以使用 pip 命令安装它，如下所示:

pip install voila

一旦你安装了 Voila，创建一个独立的仪表板将变得非常容易。您所需要做的就是进入您的终端或 Anaconda 提示符，然后键入以下格式:

voila path/to/your/notebook.ipynb

或者，您也可以通过单击 Jupyter 笔记本工具栏中的 Voila 图标，直接在笔记本中执行此操作。

现在，如果您执行了上述两个步骤中的任何一个，您将获得以下独立的仪表板。

就是这样！我们已经将 Jupyter 笔记本中的可视化内容转化为一个独立的仪表盘。现在，使用同样的技巧，您可以将 Jupyter Notebook 中任何数据集的可视化转换为独立的仪表板。

使用 Heroku 部署仪表板

到目前为止，您用 Voila 构建的仪表板只能在本地计算机上运行。这意味着你实际上不能和其他人分享，除非你把你的电脑借给他们。

为了让其他人访问您的仪表板，您需要将您的仪表板部署在云上，例如 AWS、GCP、Azure 或 Heroku。在本文中，我们将使用 Heroku 来部署我们的仪表板，以便其他人可以用他们自己的计算机看到您的仪表板。

使用 Heroku 部署您的仪表板的第一步是登录您的 Heroku 帐户。如果你还没有账号，你可以免费注册 Heroku。

下一步是下载 Heroku 命令行界面(CLI) 并安装到您的本地机器上。

Heroku CLI 安装后，现在您需要在 Jupyter 笔记本文件旁边创建两个附加文件。这些文件是:

• requirements.txt: 这个文本文件应该包含您在 Jupyter 笔记本中使用的所有依赖项或库。例如，在本文中，我们使用了folium、numpy、pandas、ipywidgets、matplotlib和voila库。因此，我们需要在这个文件中列出它们。另外，由于我们使用 Jupyter Notebook，我们需要在这个文件中添加ipykernel,这样 Heroku 就可以运行我们的 Jupyter Notebook 中的命令。下面是 requirements.txt 内容的样子。

numpy
pandas
folium
ipywidgets
matplotlib
voila
ipykernel

• Procfile: 这个文件告诉 Heroku 如何运行您的 Jupyter 笔记本，以及需要哪些文件。您可以键入以下内容作为该文件的内容。

web: voila --port=$PORT --no-browser --enable_nbextensions=True your_jupyter_notebook_name.ipynb

您可以使用电脑中的任何文本编辑器创建这两个文件，例如 Notepad 或 Notepad++。接下来，将这些文件保存在保存 Jupyter 笔记本文件的同一文件夹中。

现在打开您的终端或命令提示符，然后在其中键入heroku login。这将引导你进入一个浏览器页面，提示你使用 Heroku 帐户登录。

接下来，使用命令提示符进入保存 Jupyter 文件、requirements.txt 和 Procfile 的工作目录。

在工作目录中，通过键入git init初始化一个空的存储库。接下来，您可以通过键入以下格式在 Heroku 帐户上创建一个新的应用程序:heroku create your-app-name。

创建应用程序后，按顺序输入以下命令:

git add .
git commit -m "Your customized message"
git push heroku master

现在，在你输入git push heroku master之后，Heroku 将开始创建应用程序来托管你的仪表板。大约一分钟后，您会在命令提示符下看到一个指向您的仪表板的链接。该链接将与您的应用程序名称相似。

就是这样！现在，您可以与其他人共享该链接，以便他们可以看到您的交互式仪表板。

您可以在这里看到本文中部署的可视化仪表板。

如果您有兴趣查看本文中使用的 Jupyter 笔记本和 requirements.txt 以及 Procfile，您可以在这里看到它。

使用 D3 . js——数据处理，为“办公室”创建交互式数据可视化

原文：https://towardsdatascience.com/creating-an-interactive-data-visualisation-for-the-office-using-d3-js-part-1-894df7f01730?source=collection_archive---------27-----------------------

为创建交互式可视化准备数据

[## 办公室:数据故事

编辑描述

cuthchow.github.io](https://cuthchow.github.io/the-office-visualisation/)

我为这个项目创作的一个视觉效果是，一季一季地描绘剧中每个主要角色的情绪得分。

我一直认为，最酷的数据可视化是那些你可以与之互动和玩耍的数据，因为它们给你自己探索数据的自由，并从你自己的角度理解它。我还发现，我在网上看到的许多符合这一描述的可视化是在 D3.js 的帮助下创建的，D3 . js 是由 Mike Bostock 创建的 Javascript 库，其特定意图是为 web 创建高度可定制和交互式的可视化。

因此，我决定学习 D3.js，以便创造我自己的观想。由于我非常支持基于项目的学习，以便更快更深刻地理解一个主题，我决定将电视节目《办公室》中的所有台词可视化，这实际上结合了我最大的两个兴趣。我在这里的目标是记录整个过程，并分享我在这个过程中学到的一些东西，希望也能帮助任何试图学习 D3.js 的人。

数据处理

这第一篇文章将关注我在创建实际可视化之前所做的数据预处理。我做的所有预处理都是在 Jupyter 笔记本中使用 Python 和 Pandas 完成的，还有一些其他用于特定任务(如情感分析)的库。

我开始使用的数据集包含了《办公室》中每一句台词的信息，以及关于季节、剧集、场景、演讲者以及场景是否被删除的信息。

我从一开始就知道我想在我的观想中包含以下信息:

• 口语线长度
• 台词的感悟
• 文本的词汇复杂性

为了得到每一行的长度，我简单地取了 line_text 列，在每个空格处将字符串分成一个列表，并计算结果数组的长度。

import pandas as pddf = pd.read_csv('the-office-lines.csv')
df['word_count'] = df['line_text'].apply(lambda x: len(x.split(' ')))

为了获得每行的情感，我不得不利用自然处理库“NLTK”，它有几个预先训练好的模型，适合分析情感的任务。(对于未来的项目，我的目标是使用“The Office”语料库从头构建一个语言模型，以生成更准确的情感分数，但由于这个项目是关于数据可视化的，我满足于使用 NLTK 的内置模型。)NLTK 提供了 VADER 情绪分析器供我们使用，它提供了一个从-1 到 1 的复合情绪分数，其中-1 表示绝对负面，1 表示绝对正面。

from nltk.sentiment.vader import SentimentIntensityAnalyzer
sid = SentimentIntensityAnalyzer()df['sentiment'] = df['line_text'].apply(lambda x: sid.polarity_score(x)[0]#The 0th element of the polarity scores gives us the compound score, whereas the 1st, 2nd and 3rd element return the negative, neutral and positive scores respectively 

最后，我想分析每一句口语的词汇复杂性。谢天谢地，这种测试已经存在了。我选定的一个是 Flesch-Kincaid 可读性测试，它基本上返回可读性或等级分数，对应于大致的学校等级难度。分数是基于每个单词的平均音节数和每个句子的平均单词数，所以这是一个相当初级的工具。

弗莱施-金凯试验

由于它的简单性，它使得实现起来相当简单。然而，应该注意的是，这个测试是针对书面语言的，而电视节目的台词是针对口语的。

此外，我意识到对每一行都进行测试并不是最好的方法，因为测试在更大的文本上效果更好。因此，我为每个关键人物创建了一个单独的语料库，然后对每个单独的语料库应用测试，以确保返回的分数尽可能准确。

创建单独的搜索集:

df = df.groupby('speaker').count().reset_index()
chars = list(df[df['scene'] > 100].speaker)#chars is the list of characters with over 100 scenes, as I wanted to remove the characters with only a handful of appearances from the dataset char_corpi = dict()for char in chars: 
    corpus = []
    for row in df[df.speaker == char]['line_text']:
        corpus.append(row)
    corpus = ' '.join(corpus)
    char_corpi[char] = corpus#char_corpi is a dictionary of corpuses, where the key is each character, and the value is a string of all their lines in the show.

创建和应用 Flesch-Kincaid 测试:

import re def flesch_kincaid_grade(corpus):
    words = len(corpus.split(' '))
    sents = len(re.split('! |? |. ', corpus))
    check = lambda x: 1 if x in 'aeiouyAEIOUY' else 0
    sylls = sum(list(map(check, corpus)))
    score = 206.835 - 1.015 * (words/sents) - 84.6 * (sylls/words)
    return score kincaid_scores = []for char in char_corpi:
    score = flesch_kincaid_grade(char_corpi[char])
    kincaid_scores.append({'speaker': char, 'score': score})df = pd.toDataframe(kincaid_scores)
df.to_csv('kincaid_score.csv', index = False)## This is the new set of data which I will use directly in the visualisation

结论

这就是我为这个项目做的所有数据预处理。相当简单，对吗？

使用散景和熊猫在 Python 中创建交互式地图

原文：https://towardsdatascience.com/creating-an-interactive-map-in-python-using-bokeh-and-pandas-f84414536a06?source=collection_archive---------17-----------------------

使用 Python 来(相对)容易地创建一个交互式热图，按位置显示鳄梨价格。

作者图片——跟随这篇博文，自己制作。互动版这里。

这篇文章可以看作是我之前处理鳄梨价格数据的文章的延伸(我能说什么呢，我爱鳄梨！)你可以在这里找到。推荐去看看！

作为数据分析师/数据科学家/其他数据操纵者，我们经常发现自己使用可视化来有效地向他人传达我们的发现(并让自己更好地理解它们)。如果使用得当，可视化有很多优势——它们可以总结数据、显示时间趋势、显示地理数据等等。

有时静态的可视化是完美的，但在其他情况下，创建一些交互的东西会更清晰，对最终用户更有用，或者更酷更有趣！

在本文中，我们将介绍创建显示美国鳄梨价格的交互式热图的过程，该热图可以在任何现代 web 浏览器中轻松查看和操作。我们将使用 Python 来完成，主要使用散景和熊猫 数据帧。

在看到纳丁·阿梅西-博尔顿的优秀项目“预测国王郡的房价”后，我受到启发开始使用散景，该项目非常有效地使用了散景。我建议把整本笔记本都看看——里面有一些非常有趣的东西。

入门指南

首先，我们需要一些 Python dict 形式的地理数据、熊猫数据帧或熊猫 GroupBy 对象。方便的是，我碰巧有一个旧的数据框架，我将在这篇文章中使用它。我在我的上一篇文章中生成了这个文件，并使用 pd.to_csv() 将其导出。如果您对我为达到这一点所做的数据争论感兴趣，请查看一下。

这篇文章的所有代码都可以在这个 GitHub repo 中找到，如果你想在不安装任何东西的情况下进行编码，那么使用活页夹 查看这里。如果你只是想边看边读，我推荐你使用 Jupyter 笔记本浏览器。

为什么要用散景？

Bokeh 可以帮助你简单方便地制作好看且有用的交互式可视化效果，然后可以在所有现代浏览器中显示。这意味着你可以在一篇博客文章、一个内部仪表板或者任何你可以查看 HTML 的地方嵌入一些好的有用的东西。几乎每个人都有使用浏览器的经验，这对于让你的视觉呈现在观众面前非常有用。

我的目的的主要卖点是交互性。在我们的示例中，我们今天使用的是地理地图，因此允许用户随意放大和缩小以查看我们的数据点的物理分布，以及当用户悬停在某个点上时选择突出显示哪些数据的能力，让我们创建了一个直观的可视化，我们的观众可以按照自己的节奏进行交互和操作。这反过来会让他们更容易将我们的发现应用到身上，这对任何数据专业人士来说都是一个优势！

如果您有一个工作的 Python 设置，在您的系统上安装散景相对简单。我自己正在使用 Anaconda 生态系统，所以只需要一个简单的conda install bokeh就可以了。如果你喜欢 pip，那么pip install bokeh也可以。更多信息可以在他们的快速入门指南中找到。

它是如何工作的？

散景是建立在四个主要概念上的:地块、字形、引导线和注释以及范围。为了获得完整的信息，我强烈推荐阅读文档(总是阅读文档！)，但是我会在这里提供一个非常简短的说明。

• 剧情。这是您将在输出中看到的所有内容的容器。您将创建一个呈现给用户的图形。任何使用过 Matplotlib 或 Seaborn 或 Python 中其他可视化库的人都会熟悉这个想法。
• 象形文字。这就是散景如何显示你的观想。这些可以简单到一条线或一个圆，也可以复杂到像一个多边形，图像 url(很适合在 viz 上使用你的 logo！)或者文字。
• 参考线和注释。引导线是像轴、网格线等帮助用户理解比例和进行比较的东西。注释是像标题、图例等东西，它们提供额外的信息来帮助用户理解可视化。
• 范围。这是数据的范围。你会注意到，如果你点击我的可视化，默认情况下，它会打开所有可见的数据点，以美国为中心(我所有的数据都来自那里)。如果你愿意，这可以在创建可视化时修改。

事实真相

好了，言归正传。

首先，我们想要导入我们的库。Bokeh 与您可能熟悉的其他 Python 可视化库(如 Matplotlib 或 Seaborn )略有不同，因为它被排列为许多不同的子模块，您可以从中导入您需要的函数。它没有一个可以导入来访问所有功能的包罗万象的包。

这确实使了解它变得有点困难，但是您可以遵循下面的代码。习惯了就不太恐怖了！

*from bokeh.io import output_notebook, show, output_file
from bokeh.plotting import figure, ColumnDataSource
from bokeh.tile_providers import get_provider, Vendors
from bokeh.palettes import PRGn, RdYlGn
from bokeh.transform import linear_cmap,factor_cmap
from bokeh.layouts import row, column
from bokeh.models import GeoJSONDataSource, LinearColorMapper, ColorBar, NumeralTickFormatterimport numpy as np
import pandas as pd*

好了，现在我们准备开始了。首先，我们需要一些数据。我们将使用我们的 CSV 文件，我们可以使用 pd.read_csv() 将它作为数据帧读入 pandas:

*import pandas as pddf = pd.read_csv('avocado_df.csv', index_col=0)display(df.head())*

这为我们提供了以下输出:

出于他们自己最了解的原因，散景图使用墨卡托坐标。我们的位置以经度和纬度列出。这意味着我们需要将纬度和经度转换成墨卡托坐标。

参与编程和数据分析这样一项有趣而富有挑战性的活动的一大好处是，对于你遇到的大多数困难问题，其他一些聪明人可能以前也遇到过。为了取得进步和提高你的技能，你还需要发展有效谷歌的技能，找到那些聪明人在你之前找到的答案！

在我们的例子中，我们的开拓者 Nadine Amersi-Bolton 已经解决了这个问题，并为我们创建了一个函数来完成这个转换。这非常好，所以我们将更聪明地工作，而不是更努力地使用这个现有的解决方案。谢谢纳丁。

*# Define function to switch from lat/long to mercator coordinates
def x_coord(x, y):

    lat = x
    lon = y

    r_major = 6378137.000
    x = r_major * np.radians(lon)
    scale = x/lon
    y = 180.0/np.pi * np.log(np.tan(np.pi/4.0 + 
        lat * (np.pi/180.0)/2.0)) * scale
    return (x, y)# Define coord as tuple (lat,long)
df['coordinates'] = list(zip(df['latitude'], df['longitude']))# Obtain list of mercator coordinates
mercators = [x_coord(x, y) for x, y in df['coordinates'] ]*

现在我们只需要将这一列添加到我们的数据帧中，并将其分成两个单独的列(一个用于 x 坐标，一个用于 y 坐标)。我们可以用熊猫通过两个简单的步骤做到这一点。

*# Create mercator column in our df
df['mercator'] = mercators# Split that column out into two separate columns - mercator_x and mercator_y
df[['mercator_x', 'mercator_y']] = df['mercator'].apply(pd.Series)*

当我运行这个程序时，我发现散景非常不想与数据帧中的geometry列合作。这来自我们在之前的可视化中使用的匀称的文件，这里不需要。我们可以用 df.drop() 来摆脱它。

*df = df.drop(columns=['geometry'] # Examine our modified DataFrame
df.head()*

这给了我们:

看那些墨卡托 x 和墨卡托 y 柱！太棒了。

准备我们的阴谋

现在我们有了开始策划的一切。在创建我们的数字之前，我们需要先做一些准备工作。这些包括:选择用于地图的图块；选择我们的调色板；指示散景使用哪个数据帧作为信息源；创建颜色映射器；并设置我们的工具提示。

别担心，我们会边走边检查的！

首先—选择我们的瓷砖提供商。有各种组织提供可以在散景中使用的地图拼图。这些可能是谷歌地图(很棒，但需要一个 API，所以我们不会在这里使用它)或 CartoDB (也很棒)或 Stamen 。这些大多使用 OpenStreetMap 数据，一般可靠性很高。我们将使用雄蕊碳粉，因为它看起来很棒，单色造型将允许我们的彩色数据点很好地显示出来。

使用雄蕊调色剂制作的西欧地图|由雄蕊设计制作的地图拼贴，在 CC 下由 3.0 制作。数据由 OpenStreetMap 提供，在 ODbL 下。

*# Select tile set to use
chosentile = get_provider(Vendors.STAMEN_TONER)*

接下来，我们需要选择一个调色板。当我们在处理鳄梨时，我选择了紫绿色的 PRGn。我们可以使用PRGn[3]到PRGn[11]选择 3 到 11 种色调。我们将使用最大化来获得我们视觉化的最大变化。

*# Choose palette
palette = PRGn[11]*

现在我们想通过使用 ColumnDataSource 将散景指向我们的数据帧。

*# Tell Bokeh to use df as the source of the data
source = ColumnDataSource(data=df)*

接下来我们需要定义颜色映射器。在这种情况下，我们想让散景知道是我们的'AveragePrice'字段决定了数据点的颜色。

*# Define color mapper - which column will define the colour of the data points
color_mapper = linear_cmap(field_name = 'AveragePrice', palette = palette, low = df['AveragePrice'].min(), high = df['AveragePrice'].max())*

在我们构建图形之前，要做的最后一件准备工作是选择哪些字段应该用作工具提示——也就是说，当用户将鼠标悬停在地图上的数据点上时，应该显示哪些字段。在这种情况下，我们将选择'AveragePrice'字段和'Region'，因为它们可能是我们的观众最感兴趣的。

*# Set tooltips - these appear when we hover over a data point in our map, very nifty and very useful
tooltips = [("Price","[@AveragePrice](http://twitter.com/AveragePrice)"), ("Region","[@region](http://twitter.com/region)")]*

创建图形

我们快到了！坚持住。

下一步是定义我们的数字。这个图形是我们所有元素的持有者。我们这样设置它:

*# Create figure
p = figure(title = 'Avocado Prices by region in the United States', x_axis_type="mercator", y_axis_type="mercator", x_axis_label = 'Longitude', y_axis_label = 'Latitude', tooltips = tooltips)*

您可以看到，我们已经为图形指定了标题，将轴类型设置为墨卡托，为两个轴都指定了标签，并告诉 Bokeh 在哪里可以找到关于 tootltips 的信息。所有这些都在一行代码中——不错！

现在我们需要添加图块，否则我们的数据点会漂浮在空白背景上。不是如此引人注目的观想！

*# Add map tile
p.add_tile(chosentile)*

下一步是创建数据点本身:

*# Add points using mercator coordinates
p.circle(x = 'mercator_x', y = 'mercator_y', color = color_mapper, source=source, size=30, fill_alpha = 0.7)*

在这种情况下，我们调整了fill_alpha，这减少了圆圈的不透明度，并允许用户在缩小时更容易理解重叠的数据点。我们还将圆的大小设置为 30。大小在每一级缩放中都保持不变，所以尝试一下，看看什么适合您的数据。

我们的下一步是创建一个颜色条——这将作为我们可视化旁边的一个图例，提供关于我们的数据点上使用的颜色的含义的重要信息。绿色是贵还是便宜？(贵！)通过给我们的用户这些信息，他们一眼就能明白观想在向他们展示什么。

*#Defines color bar
color_bar = ColorBar(color_mapper=color_mapper['transform'], 
                     formatter = NumeralTickFormatter(format='0.0[0000]'), 
                     label_standoff = 13, width=8, location=(0,0))# Set color_bar location
p.add_layout(color_bar, 'right')*

现在只需几个步骤来确保我们可以在 Jupyter 笔记本中看到可视化，并将文件保存为 HTML 文件，然后我们可以将它嵌入到我们想要的任何地方。

*# Display in notebook
output_notebook()# Save as HTML
output_file('avocado.html', title='Avocado Prices by region in the United States')*

我们到了。我们准备赞美我们的劳动成果！只差一步了:

*# Show map
show(p)*

瞧啊。

辉煌的漫威！放大，摆弄一下！

哒哒！现在，我们已经从一个包含一些位置数据的 CSV 文件变成了一个完全成熟的交互式地图，我们可以将它嵌入到我们的仪表盘、博客帖子或任何我们想嵌入的地方。

我希望这篇文章能给你灵感，让你自己用散景做出一些伟大的东西。

非常感谢您抽出时间和我一起探讨这个话题。一如既往，我非常欢迎您的反馈——您可以在 Twitter 上通过@craigdoedata联系我，让我知道我如何才能更有效地完成这项分析。

你可以在我的网站www . craigdoedata . de上看到我还在做什么。

再说一遍，整个 Jupyter 笔记本和相关文件都可以在我的 Github 页面和活页夹上找到，我鼓励你使用它们。

下次见！

更像这样？访问craigdoedata . de

只用你的数据科学技能创建一个类似 iPhone 的应用程序:一键生活日志链接到 Google Sheets

原文：https://towardsdatascience.com/creating-an-iphone-app-like-with-only-your-data-science-skills-one-tap-life-logger-ac691698d3b3?source=collection_archive---------45-----------------------

你用的都是 Python 和 GCP 云函数或者 Heroku。

作者图片

我没有把自己培养成一名移动应用程序开发人员，因此在我的 iPhone 上拥有自己的应用程序超出了我的梦想。但是，一些简单的功能，如我将在本文中演示的功能，可以在没有任何软件开发技能和流程的情况下实现，如 Swift 编程和 app store review。

在这里，我想创建一个简单的功能，比如当你点击一个图标时，它会记录你点击它的时间。

你点击的以下生活日志怎么样，其中没有一个是你想为此建立一个电子表格的？

• 到达办公室时:你一到办公室就查看邮件，所以你忘了写下你到达办公室的时间，对吗？(远程工作人员的情况并非如此)
• 离职时:你平时都在跑步，所以忘了写时间，对吧？(远程工作人员的情况并非如此)
• 喂宝宝的时候:你忘了写下来，因为你平时都是在收拾烂摊子，对吧？(每个人都是这样)
• 当宝宝醒来:战争开始了！我没时间做笔记！(每个人都是这样)

让我们停止把它存储在本地设备上，把它放到云中。这就是我们现在所做的一切。

德里克·欧文斯在 Unsplash 上拍摄的照片

我就是这样想出这个主意的:当你在你的 iPhone(或任何其他智能手机)上点击图标时，它会自动记住时间，并记录在 Google Sheets 中。

在这篇文章中，我将写下我是如何做到这一点的，不需要真正构建移动应用程序，甚至只需要数据科学技能！

目录

• 规划解决方案
• API 解决方案演示 1——谷歌云功能
• API 解决方案演示 2—Heroku
• 结尾注释

规划解决方案

现在这里是我如何规划背景架构。

我们想要的是 iPhone 主屏幕上的图标。轻触其中一个图标会触发某种东西，并以某种方式在谷歌表单中记录下来。不使用特殊的编程技巧，怎么做呢？？

没有 CS 技能，如何连接你的 iphone 图标和 Google Sheets？(图片由作者提供)

下面是我是如何作弊的:图标不是 app，是一个特定 HTTP 请求的 Safari 快捷方式。中间出现一个 API，接收 HTTP 调用，最后把记录推送到 Google Sheets。

点击图标-> HTTP 请求-> API 触发器->推送到 Google 工作表。(图片由作者提供)

这个技巧已经解决了大部分技术问题，但是仍然有一个问题:谁以及如何托管 API。

谁将主持 API？(图片由作者提供)

有许多可能的 API 解决方案，但是每一个都有优点和缺点。

每个 API 解决方案的优缺点

通过使用个人服务器，你不得不准备许多，但在配置上有更多的自由作为回报。保持机器一直运行以等待 HTTP 请求的维护成本很高，因此这次对于像我们这样的小应用程序来说是大材小用。

PaaS(比如 Heroku) 是一个可行的选择，可以让你的应用一直保持托管和服务状态。正如我们将在后面看到的那样，设置起来相当容易。实际上，我认为这是所有解决方案中最公平的一个；唯一值得注意的是，Heroku 免费帐户有每月使用限制——所有应用程序每月使用 1000 小时。这相当于 41.7 天，因此对于一个应用程序来说足够了，但当你已经有另一个应用程序在 Heroku 上运行时，这可能就很重要了。

像 AWS 上的 Lambda 或 GCP 上的 Cloud Functions 这样的云端无服务器服务是另一个可能的选择。虽然它是最容易部署的，因为几乎每个基础设施都是托管的，并且您只需要运行 Python 代码，但是每个无服务器服务在配置上都有其不可改变的限制:当您使用外部库(包括 Pandas！);而云函数每个函数只接收来自一个 URL 的 HTTP 请求，这意味着当我们有多个生活事件想要记录时，我们必须复制 Python 代码并反复编辑几行。

在本文中，我演示了使用云函数和 Heroku 的情况。从代码的角度来看，本地服务器案例与 Heroku 案例非常相似。

API 解决方案演示 1——谷歌云功能

要让 Google Cloud 函数接收 HTTP 请求并将记录推送到 Google Sheets，请执行以下步骤:

步骤 1 —创建一个新的 GCP 项目

最好创建一个新项目，以便与您已经拥有的其他项目隔离开来。我新建了一个，名字叫“记录 iPhone 点击”。

第二步——首先配置 Google Sheets 来接收来自云功能的数据推送

首先设置 Google Sheets 端，因为我们需要云函数代码的认证信息。

在本页的描述之后，

1. 启用“Google Drive API”。
2. 启用“谷歌工作表 API”。
3. 转到“APIs &服务>凭据”并选择“创建凭据>服务帐户密钥”。
4. 填写表格
5. 点击“创建密钥”
6. 选择“JSON”并点击“创建”。JSON 文件的下载会自动进行。
7. 请注意 JSON 文件中“client_email”的地址。
8. 将 JSON 文件保存到云函数可以访问的地方。
9. 在 Google Sheets 中创建电子表格。在单元格 A1 中写入“事件”,在单元格 B1 中写入“时间”,作为最终日志记录的标题。
10. 在工作表文件中，按下右上角的“Share”按钮，将您在上面第 7 步中获得的 client_email 添加为授权用户。

这就是全部！

步骤 3—在云功能中配置新功能

转到“云函数”并创建函数。使用触发器类型作为“HTTP”。

新云功能的配置(作者截图)

步骤 4—将代码输入 main.py 和 requirements.txt

点击左下角的下一步，进入代码输入页面。

新云功能代码

这是我实际使用的代码。

main.py

requirements.txt

请记住，服务帐户 JSON 文件需要下载到本地文件夹中，当您想要在云功能中执行此操作时，您必须将文件保存在/tmp/子文件夹中。否则，云功能拒绝构建您的应用程序。

步骤 5 —部署功能

点击“部署”按钮，等待成功部署。可能需要几分钟。

第六步——找到网址并检查它是否有效

URL 可以在函数的详细信息中找到。

你可以在那里找到网址。

如果您测试单击它，您将看到类似下面的消息，这意味着代码已成功部署。如果您看到内部错误、服务器错误或任何其他错误，一定是出了问题。

成功消息。

在这里，您还应该在您创建的工作表中看到一条新记录。

工作表中新插入的记录。

第 7 步——将网址发送到你的 iPhone，并在主屏幕上创建一个 Safari 链接

在 iPhone 上打开您的 URL，并将快捷方式添加到主屏幕。

将您的链接添加到主屏幕

然后，您可以在 iPhone 主屏幕上看到新图标。

搞定了。

我们最终得到了什么

第八步——为你的其他生活日志制作 URL 链接，一次又一次地复制函数，设置事件名称，并将每个快捷方式添加到你的主屏幕。

这是这个选项最不方便的地方:云函数的代码只能链接到一个 HTTP 请求 URL。因此，如果你需要一个以上的生活日志(像“喂宝宝”、“宝宝醒来”、“到达办公室”等。)，你唯一能做的就是一次又一次地创建函数。

为每个事件设置单独的功能。

当您对 API 设置有更多的控制时，这个过程可以大大减少，就像使用 Heroku 的下一个选项一样！

API 解决方案演示 2—Heroku

在我的另一篇文章中，我已经讨论了很多关于 Heroku 的好处以及如何建立的问题。因此，我将只讨论提交到与 Heroku 同步的 GitHub 存储库的代码。设置完成后，Heroku 可以自动从 GitHub 下载你的应用并进行部署。

Heroku 与 GitHub 存储库同步，全天候提供最新的应用程序。(图片由作者提供)

步骤 1 —准备要与 Heroku 同步的 GitHub 存储库

这是我的 GitHub 库:

requirements.txt 和上面带云函数的 Demo 1 一模一样。

以下是另外两个文件中的内容:

Procfile

app.py

正如你在代码中看到的，在 Heroku 代码中，你需要编写一些额外的代码来通过 Flask 设置 app。另一方面，我们可以设置多个 URL，子目录链接到你想要设置的每个生活日志(像*main domain/feed-baby*)，而不需要为它们准备多个 app，不像上面的云功能案例。

步骤 2 —配置 Heroku 与 GitHub 存储库同步

这一步欠很多我在这里的另一个帖子告诉你怎么做。只要你选择了我们刚刚建立的正确的 GitHub 库，没有什么不同。

第三步——找到网址并检查它是否有效

从 Heroku 设置中找到根 URL，为生活日志添加子目录，如[https://<your subdomain of Heroku app>.herokuapp.com/](https://record-iphone-click.herokuapp.com/)arrive-at-office/。检查你的浏览器和工作表的 API 是否正常工作。

检查你的浏览器

检查你的工作表

第四步——将网址发送到你的 iPhone，并在主屏幕上创建一个 Safari 链接

这一步和上面云函数的情况完全一样。

我们最终得到了什么

结尾注释

在这篇文章中，我展示了一个例子，结合数据科学家已经知道的技能，可以达到比我们通常预期的更进一步的应用。

iPhone(或任何智能手机)可以发出 HTTP 请求，当我们可以正确设置工作流时，通过 HTTP 请求>启动代码>给出结果，任何事情都可以完成。这篇文章演示了一个非常简单的例子，通过点击 iPhone 图标将生活日志记录到 Google Sheets，但是任何进一步的高级应用程序都可以生成，这取决于您的想象力！

使用 Python 创建和自动化交互式仪表盘

原文：https://towardsdatascience.com/creating-and-automating-an-interactive-dashboard-using-python-5d9dfa170206?source=collection_archive---------9-----------------------

Gif 由你真诚地

在本教程中，我将在 selenium、pandas、dash 和 plotly 的帮助下，使用 python 创建一个自动的、交互式的得克萨斯州新冠肺炎县案例统计仪表板。我假设读者对 python、pandas 和 selenium 有所了解。阅读完本教程后，这就是你创建令人惊叹的交互式仪表盘所需的全部内容！

这些步骤的概述以及您将学到的内容如下:

1. 使用 selenium 从 web 下载每日更新的数据
2. 使用 shutil、glob 和 os python 库更新数据目录
3. 用熊猫简单清理 excel 文件
4. 格式化要输入到 plotly 图形中的时间序列数据帧
5. 使用 dash 为您的仪表板创建本地网页

在我们开始之前，您需要下载将在本教程中使用的 python 库。这可以在您的终端上使用以下命令来完成:

pip install <package name># package names: selenium, pandas, webdriver_manager, shutil, glob, plotly,and dash

需要注意的一点是，我在步骤 1-4 中使用了 Jupyter 笔记本，然后在步骤 5 中使用了 Spyder。当我解释一个代码块做什么的时候，它通常就在文本的正上方。我在本教程中的所有代码都可以在我的 GitHub 中的 Automate collecting of data notebooks 文件下找到。

好，我们开始吧！

第一步:使用 selenium 从网上下载每日更新的数据

# import packages
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.options import Options
import shutil
import glob
import os
from unicodedata import *
import time# open a chrome browser using selenium 
driver = webdriver.Chrome(ChromeDriverManager().install())# got to web page where excel file links are located
driver.get("[https://www.dshs.texas.gov/coronavirus/additionaldata/](https://www.dshs.texas.gov/coronavirus/additionaldata/)")# these options allow selenium to download files 
options = Options()
options.add_experimental_option("browser.download.folderList",2)
options.add_experimental_option("browser.download.manager.showWhenStarting", False)
options.add_experimental_option("browser.helperApps.neverAsk.saveToDisk", "application/octet-stream,application/vnd.ms-excel")

因此，第一个代码块非常简单明了，但是需要注意一些事情。我正在安装一个 selenium chrome web 驱动程序，这样我就不必在新的 chrome 驱动程序更新时重新下载了。这个驱动是用来在线下载我要的 excel 文件的。它会在你的电脑上打开一个新的谷歌 chrome 窗口，然后进入网页，提供每天更新的德克萨斯新冠肺炎各县的案件数量。selenium 的标准选项不允许从 web 下载文件，因此需要修改这些选项以允许这样做。

# initialize an object to the location on the web page and click on it to download
link = driver.find_element_by_xpath('/html/body/form/div[4]/div/div[3]/div[2]/div/div/ul[1]/li[1]/a')
link.click()# Wait for 15 seconds to allow chrome to download file
time.sleep(15)

这段代码使用完整的 Xpath 单击 excel 文件的链接。这可以通过右键单击页面、检查页面、右键单击想要单击的链接并复制完整的 Xpath 来找到。然后驱动程序点击链接，等待 15 秒下载，这对于下一个代码块不出错是至关重要的。

2。使用 shutil、glob 和 os python 库更新数据目录

在继续阅读之前:如果你在家学习，你需要改变我从/Users/tsbloxsom/Downloads/下载目录的路径。xlsx ’ to '/Users//Downloads/。xlsx ’

您还需要从我使用的目录中更改要存储数据和 python 笔记本的目录:'/Users/tsbloxsom/Documents/GitHub/Texas-census-county-data-project/Automate collection of data notebooks/。xlsx’ to '/Users/ <your_username>/bla/bla/。xlsx '</your_username>

# locating most recent .xlsx downloaded file 
list_of_files = glob.glob('/Users/tsbloxsom/Downloads/*.xlsx') 
latest_file = max(list_of_files, key=os.path.getmtime)# replace "\" with "/" so file path can be located by python
latest_file = latest_file.replace("\\", "/")
latest_file# we need to locate the old .xlsx file(s) in the dir we want to store the new xlsx file in
list_of_files = glob.glob('/Users/tsbloxsom/Documents/GitHub/Texas-census-county-data-project/Automate collecting of data notebooks/*.xlsx') # need to delete old xlsx file(s) so if we download new xlsx file with same name we do not get an error while moving it
for file in list_of_files:
    print("deleting old xlsx file:", file)
    os.remove(file)# Move the new file from the download dir to the github dir 
shutil.move(latest_file,'/Users/tsbloxsom/Documents/GitHub/Texas-census-county-data-project/Automate collecting of data notebooks/')

这个代码块是大量自动化发生的地方。它使用 glob 和 os.path.getmtime 函数找到我刚刚下载的 excel 文件，删除我想要存储新 excel 文件的目录中的任何旧 excel 文件(可能是前一天的)，然后将新 excel 文件移动到 GitHub 目录中。os.path.getmtime()函数返回路径的最后修改时间，因此使用 max()函数，可以找到最近下载的 excel 文件。

第三步:用熊猫简单清理 excel 文件

现在我们已经在我们想要的目录中有了最新的新冠肺炎数据，在绘制之前我们需要做一些清理工作。

import pandas as pd
import repd.set_option('display.max_rows', 500)
pd.options.display.max_colwidth = 150# again we need to locate the .xlsx file 
list_of_files = glob.glob('/Users/tsbloxsom/Documents/GitHub/Texas-census-county-data-project/Automate collecting of data notebooks/*.xlsx') 
latest_file = max(list_of_files, key=os.path.getctime)
print(latest_file.split("\\")[-1])df = pd.read_excel("{}".format(latest_file),header=None)df.head()

真实的你的形象

因此，我们读取 excel 文件，并将其转换为熊猫数据框(df)…我们有一些清理工作要做。让我们处理文件的第一行和最后几行。

# print out latest COVID data datetime and notes
date = re.findall("- [0-9]+/[0-9]+/[0-9]+ .+", df.iloc[0, 0])
print("COVID cases latest update:", date[0][2:])
print(df.iloc[1, 0])
print(str(df.iloc[262:266, 0]).lstrip().rstrip())#drop non-data rows
df2 = df.drop([0, 1, 258, 260, 261, 262, 263, 264, 265, 266, 267])

首先，我想打印出前两行和最后几行数据的相关信息，然后我想从 df 中删除这些行。

# clean column names
df2.iloc[0,:] = df2.iloc[0,:].apply(lambda x: x.replace("\r", ""))
df2.iloc[0,:] = df2.iloc[0,:].apply(lambda x: x.replace("\n", ""))
df2.columns = df2.iloc[0]
clean_df = df2.drop(df2.index[0])
clean_df = clean_df.set_index("County Name")# convert clean_df to a .csv file
clean_df.to_csv("Texas county COVID cases data clean.csv")

真实的你的形象

在上面的代码块中，我清除了每个日期的行，其中许多日期在单元格中有新行、和回车、字符。然后，我将日期行作为列名，并删除原来的日期行。我们最终得到了一个清晰的 df，其中的行是德克萨斯州的每个县，每列代表每个日期的案例数。最后，我想为下一步将 df 转换成. csv 文件。

第四步:将输入的时间序列数据帧格式化成 plotly 图形

import plotly.express as pxlist_of_files = glob.glob('/Users/tsbloxsom/Documents/GitHub/Texas-census-county-data-project/Automate collecting of data notebooks/*.csv') 
latest_file = max(list_of_files, key=os.path.getmtime)
latest_file.split("\\")[-1]df = pd.read_csv(latest_file.split("\\")[-1])

我们再次使用 glob 和 os.path.getmtime 函数来查找最新的。csv 文件，即我们的“德州县 COVID 病例数据 clean.csv”。

# convert df into time series where rows are each date and clean up
df_t = df.T
df_t.columns = df_t.iloc[0]
df_t = df_t.iloc[1:]
df_t = df_t.iloc[:,:-2]# next lets convert the index to a date time, must clean up dates first
def clean_index(s):
    s = s.replace("*","")
    s = s[-5:]
    s = s + "-2020"
    #print(s)
    return sdf_t.index = df_t.index.map(clean_index)df_t.index = pd.to_datetime(df_t.index)

真实的你的形象

在上面的代码块中，我将数据帧转换为时间序列 df，其中行现在是日期，列是县。我还删除了几个列，其中包含病例总数和报告病例的县数。最后，我将日期列转换成一种可用的格式，这种格式可以转换成 pandas date_time 对象，对此我使用了函数 clean_index。但是我们还没有完成。

# initalize df with three columns: Date, Case Count, and County
anderson = df_t.T.iloc[0,:]ts = anderson.to_frame().reset_index()ts["County"] = "Anderson"
ts = ts.rename(columns = {"Anderson": "Case Count", "index": "Date"})

我们的 plotly 函数将接受 3 列作为输入:日期、案例数和县。所以我们需要把宽 df 转换成长 df。为此，我首先初始化一个包含三列的长 df:一个日期列、安德森县的案例数和一个包含县名的县列。看起来像这样:

真实的你的形象

# This while loop adds all counties to the above ts so we can input it into plotly
x = 1
while x < 254:
    new_ts = df_t.T.iloc[x,:]
    new_ts = new_ts.to_frame().reset_index()
    new_ts["County"] = new_ts.columns[1]
    new_ts = new_ts.rename(columns = {new_ts.columns[1]: "Case Count", "index": "Date"})
    ts = pd.concat([ts, new_ts])
    x += 1#save long form df for dash app
ts.to_csv("time_series_plotly.csv")

上面代码块的注释说明了一切，但我们现在只是循环遍历整个 wide df 并为每个县创建 new_ts long df，看起来像 Anderson 的 df。然后，我们将每个长 df 连接在一起，wallah 我们自己有了可以输入到 plotly 中的长 df，稍后我们的 dash 应用程序显示如下！

真实的你的形象

fig = px.scatter(ts, x='Date', y='Case Count', color='County')
fig.update_traces(mode='markers+lines')
#fig.update_traces(mode='lines')
fig.show()

真实的你的形象

我们最终可以使用简单的三行代码将数据绘制成散点图！我使用了“标记+线条”选项，我认为它看起来比线条更令人愉快，也更容易交互。我已经爱上了 plotly，因为与 seaborn 或 matplotlib 不同，它的图形是交互式的，而且编码非常简单。Plotly 也有出色的文档，可在此处找到。

第五步:使用 dash 为你的仪表板创建一个本地网页

对于没有任何软件开发经验的人来说，这一步可能会变得棘手。大约一个月前我还没有，所以我会慢慢地走完这一步，尽可能保持简单。首先，我们希望在笔记本/数据目录中创建一个虚拟环境。要做到这一点，我们必须进入命令行或 Anaconda 提示符，并使用 cd 进入该目录。大概是这样的:

C:\Users\tsbloxsom>cd C:\Users\tsbloxsom\Documents\GitHub\Texas-census-county-data-project\Automate collecting of data notebooks

然后我们创建虚拟环境:

python3 -m venv venv

然后我们激活虚拟环境:

venv\Scripts\activate

现在让我们进入短跑项目。这里有一个链接，供新手使用。Dash 是由 plotly 的人制作的，所以你可以得到很棒的文档和产品。我学会了如何在不到两个小时的时间内为时间序列仪表板制作这个应用程序，不是想吹牛，就是这么简单。下面是应用程序的代码。我使用了 dash 网站上本教程中的基础应用模板组合。因此，打开您最喜欢的代码编辑器，如 Spyder，将下面的代码作为 app.py 保存在与您的新 venv 文件夹相同的目录中。csv 文件。

import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.express as px
import pandas as pdexternal_stylesheets = ['[https://codepen.io/chriddyp/pen/bWLwgP.css'](https://codepen.io/chriddyp/pen/bWLwgP.css')]app = dash.Dash(__name__, external_stylesheets=external_stylesheets)colors = {
    'background': '#F0F8FF',
    'text': '#00008B'
}# assume you have a "long-form" data frame
# see [https://plotly.com/python/px-arguments/](https://plotly.com/python/px-arguments/) for more options
df = pd.read_csv("time_series_plotly.csv")fig = px.scatter(df, x='Date', y='Case Count', color='County')fig.update_layout(
    plot_bgcolor=colors['background'],
    paper_bgcolor=colors['background'],
    font_color=colors['text']
)markdown_text = '''
### Texas COVID-19 DashboardCreator: Truett Bloxsom, [LinkedIn]([https://www.linkedin.com/in/truett-bloxsom/](https://www.linkedin.com/in/truett-bloxsom/)), [github]([https://github.com/tsbloxsom](https://github.com/tsbloxsom))This is my first interactive dashboard using Dash! Hope you like it!This first plot is Texas COVID-19 accumulated cases by county over timeSource for data: [dshs.texas.gov]([https://www.dshs.texas.gov/coronavirus/additionaldata/](https://www.dshs.texas.gov/coronavirus/additionaldata/))'''app.layout = html.Div([
    dcc.Markdown(children=markdown_text,
        style={
            'backgroundColor': colors['background'],
            'textAlign': 'center',
            'color': colors['text']
        }),

    dcc.Graph(
        id='example-graph',
        figure=fig
    )
])if __name__ == '__main__':
    app.run_server(debug=True)

现在回到激活的环境，下载 dash、plotly 和 pandas:

pip install <package_name>

然后，您可以通过运行以下命令运行您的应用程序:

python3 app.py

它应该是这样的:

现在只需复制 http 链接，粘贴到 chrome 和 boom 中即可！它应该是这样的:

我更进一步，跟随 Elsa Scola 关于如何免费部署 dash 应用程序的教程。如果你只是想玩我的交互式仪表盘，你可以这里！

感谢您关注我的教程，并随时通过 linkedin 联系我。我总是试图获得反馈并加强我的数据科学技能，所以如果有什么我可以改进编码方式或更详细地解释一些东西，请在评论中告诉我。

用 Amazon 的关系数据库服务(RDS)创建和连接 PostgreSQL 数据库

原文：https://towardsdatascience.com/creating-and-connecting-a-postgresql-database-with-amazons-relational-database-service-rds-dcc9db0cd37f?source=collection_archive---------12-----------------------

梁杰森在 Unsplash 上的照片

开始使用云中的数据库并不困难。事实上，多亏了亚马逊网络服务(AWS ),事情从来没有这么简单过。

关系数据库服务(RDS)是亚马逊全面的 web 产品套件的一部分，截至今天，RDS 支持 6 种数据库引擎:Amazon Aurora、PostgreSQL、MySQL、MariaDB、Oracle 数据库和 SQL Server。

这里，我们将关注使用 Amazon 的 RDS 和 pgAdmin 创建并连接到 PostgreSQL 数据库实例。

前期步骤:这是检查和确定你有两件东西的地方:1) 亚马逊 AWS 账户；如果你还没有账户，亚马逊已经简化了在这里创建一个账户。2)pg admin；如果您的计算机上没有下载 pgAdmin，可以在此 处 解决。

一旦你有了这两样东西，就正式开始了。我们开始吧！

步骤 1- 登录到 AWS 控制台，找到 RDS 服务。选择 RDS 服务会将您带到 Amazon RDS 仪表板。从仪表板中，选择“创建数据库”在继续配置设置之前，您需要确定选择了“标准创建”和“PostgreSQL”。这个可以直接看下面。

步骤 2-使用下拉菜单，选择 PostgreSQL 的最新版本。在我们的例子中，它是“PostgreSQL 11.5-R1”

步骤 3——对于这一步，给数据库实例一个名称，并创建一个用户名和密码。你可能会比下面看到的更具体。

步骤 4-确保选择了“数据库实例大小”和“存储”默认设置。

第 5 步-再次确保“可用性和持久性”和“连接性”默认设置被选中。

步骤 6-在“可公开访问”下的“附加连接配置”中，选择“是”。这是走向正确的重要一步。

步骤 7-确保选择了“数据库认证”和“附加配置”的默认设置。验证完成后，我们就可以创建数据库了。

***重要提示:*创建一个数据库实例并供使用通常至少需要几分钟。

在 Amazon RDS 仪表板的“Databases”中，您应该知道您的数据库实例的名称以及正在使用的引擎(PostgreSQL)。

步骤 8——现在是时候解决最后一个问题了，确保实例可以使用。在“连接性和安全性”中，有一个标题为“安全性”的部分单击列出的默认 VPC 安全组。

第 9 步-点击默认 VPC，我们将进入以下屏幕。在这里，使用“操作”下拉菜单，选择“编辑入站规则”

步骤 10-编辑入站规则时，选择“Anywhere”并保存编辑。

步骤 11-完成出站规则的步骤 9 和 10。

第 12 步-返回亚马逊 RDS 仪表板。在使用 pgAdmin 连接数据库实例之前，再次确认该实例可供使用。

第 13 步——很好，现在是时候打开 pgAdmin 并连接 RDS 数据库实例了。打开 pgAdmin 后，您应该会看到左侧显示“服务器”的侧边栏。右键单击“服务器”创建一个新的服务器。

步骤 14-给服务器一个名称。出于演示的目的，我选择将服务器命名为“example”

第 15 步- 接下来，在“连接”选项卡中填写一些信息。通过在 RDS 仪表板中单击您的数据库实例，可以找到主机名/地址。您可以在“连接性&安全性”中的“端点”下找到它我推荐复制粘贴到 pgAdmin 里。最后，输入您在 RDS 中为数据库实例创建的用户名和密码。一旦你输入了每一项，就到了保存的时候了。

服务器现在应该列在左侧栏中，如下图所示。

第 16 步——现在，让我们继续在服务器中创建一个数据库。右键单击“数据库”，选择“创建”，然后选择“数据库…”

第 17 步——给数据库命名，完成后保存。

是的，就这么简单。我们现在看到数据库列在左侧栏中。

主要成就👏

使用 Amazon 的 RDS 创建一个 PostgreSQL 数据库实例。

使用 pgAdmin 连接到数据库实例。

使用 pgAdmin 创建服务器和数据库。

我很乐意连接！找到我最好的地方是在 LinkedIn 上。😃

在 Julia 中创建和拟合回归模型

原文：https://towardsdatascience.com/creating-and-fitting-a-regression-model-in-julia-4b5c947eabdc?source=collection_archive---------29-----------------------

在 Julia 中根据风速和湿度创建和拟合车床模型。

0.0.9 刚刚被合并到主分支中，随之而来的是一系列令人兴奋的新特性。Julia 的机器学习现在比以往任何时候都容易。Julia 中的机器学习目前面临的唯一问题是缺乏 Python 大小的生态系统，以及缺乏文档。幸运的是，对于车床用户来说，有许多功能和工具可供我们使用，甚至更好:

车床有很好的文档！

我在网上找到了另一个 CSV 数据集。要将这个 CSV 加载到 Julia 中，我们将需要三个依赖项中的第一个，CSV.jl。所以记住这一点，第一步是跳转到 Pkg REPL，首先输入朱莉娅 step，然后按]。从这个 REPL 中，我们可以添加三个依赖项:

julia> ]
pkg> add "Lathe"#Unstable
pkg> add "DataFrames"
pkg> add "CSV"

现在我们的系统上已经有了 CSV.jl，我们可以使用将它引入到 Julia 中，并使用 CSV.read()方法读入我们的数据:

using CSV
df = CSV.read("weatherHistory.csv")

对于连续和分类特征，这个数据集有许多选项，这将首先允许我展示车床预处理的最新方法，

一个热编码

我决定做的第一件事是将数据分成两个数据帧，一个将用于我们的模型，另一个将用于展示一个热编码器。我这样做是通过首先做

show(df, allcols = true)

其次，我构建了两个具有相应特性的新数据帧类型:

using DataFrames
hotdf = DataFrame(:Humidity => df[:Humidity], :Type => df[Symbol("Precip Type")])
df = DataFrame(:Humidity => df[:Humidity],:WindSpeed => df[Symbol("Wind Speed (km/h)")])

仅仅为了这个例子，我将假装我不知道如何使用车床，以便炫耀车床中的代码内文档。首先，我们当然需要使用以下命令加载车床:

using Lathe

然后我们可以用茱莉亚的？()包本身的方法:

?(Lathe)
|====== Lathe - Easily ML =====|= = = = = v. 0.0.9 = = = = = ||==============================|**__**Lathe.stats|**__**Lathe.validate|**__**Lathe.preprocess|**__**Lathe.models|**__**Use ?(Lathe.package) for information![uuid]38d8eb38-e7b1-11e9-0012-376b6c802672[deps]DataFrames.jlRandom.jl

由此，我们看到了一个模块树，其中显示了三个模块:

• 车床.统计
• 车床.验证
• 车床.预处理
• 车床.型号

对于 one hot encoder，我们当然要研究 Lathe.preprocess。(Lathe.package)了解更多信息，所以让我们试试吧！

现在我们可以在模块树中看到 OneHotEncode()函数，让我们对它做同样的操作:

?(Lathe.preprocess.OneHotEncode)

由此我们得到一个简短的描述，参数，甚至用法。看起来这个函数需要一个数据帧，以及一个表示我们想要编码的列的符号。这当然与你的预期有关:

抛开手边的方法，让我们回到我们的原始数据框架，用我们的两个特征，湿度和风速。因为数据集在这个特定的列上没有缺失值，并且我不打算缩放任何特性，所以我决定要做的第一件事是继续并训练 TestSplit:

using Lathe.preprocess: TrainTestSplit
train, test = TrainTestSplit(df)

这将返回两个新的数据帧，train 将占数据的 75%，而 test 将占剩余的 25%。我们可以通过在 df 后面添加一个浮动百分比来对此进行调整:

train, test = TrainTestSplit(df, .5)

这将平均分割数据。

就我个人而言，我喜欢将我所有的数据分配给变量，这些变量在考虑做模型之前就可以很容易地改变。在 Julia 中，你可以这样做:

x = :Humidity
y = :WindSpeed
trainX = train[x]
trainy = train[y]
testX = test[x]
testy = test[y]

接下来，我们只需要导入我们的模型，我们的预测函数，然后我们就可以构建和拟合了！

using Lathe.models: predict, LinearRegression
model = LinearRegression(trainX, trainy)
yhat = predict(model, testX)

这是结果:

真的是太简单了！你怎么会对此感到不安呢？我很期待车床在未来的发展方向，以及这个模块会对 Julia 产生怎样的影响。到目前为止，Lathe 可能是您可以使用的最简单的 ML 包，我认为大部分学习曲线源于使用 DataFrames.jl，而不是 Lathe。总的来说，我对车床的下一个版本，0.1.0 以及更高版本感到非常兴奋！

使用深度神经网络创建艺术直播视频滤镜

原文：https://towardsdatascience.com/creating-artistic-live-video-filters-with-deep-neural-networks-36f8f5a9ac69?source=collection_archive---------54-----------------------

将 CoreML 用于 iPhone 的复杂视频滤镜和效果

在 Unsplash 上 veeterzy 拍摄的照片

在之前的一个项目中，我致力于复制快速神经风格转移，通过深度神经网络将一幅图像的艺术风格应用于另一幅图像，从而转换一幅图像。虽然在 python 笔记本中转换图像效果很好，但对于普通用户来说并不容易。我想在 iOS 设备上部署这个模型，类似于几年前流行的 Prisma 应用程序。除此之外，我还想测试生成模型的极限，并在直播视频上转换帧。这个项目的目标是在实时视频上运行一个生成模型，探索在当前技术界限下的可能性。有几件事情使这成为可能——1)缩放输入，2)利用设备的 GPU，3)简化模型。因为这是建立在以前的项目之上的，所以熟悉一下以前的帖子会有所帮助。

缩放输入

今天许多手机可以拍摄令人惊叹的 4k 视频，包括我开发的 iPhone XS。虽然设备中的 A12 芯片功能强大，但要在这种大小的每一帧上使用深度神经网络，速度太慢了。通常视频帧被缩小以用于设备上的图像识别，并且该模型在帧的子集上运行。例如，对象识别应用程序可以在 224 x 244 帧上每秒运行一次模型，而不是在 4096 x 2160 帧上每秒运行 30 次。这适用于对象检测用例，因为对象在帧之间不会改变太多。

这显然不适用于视频帧的风格化。每秒只有一个风格化的帧闪烁对用户来说没有吸引力。然而，这里有一些要点。首先，缩小框架尺寸是完全合理的。视频通常以 360p 的分辨率流式传输，并放大到设备的 1080p 屏幕。第二，也许没有必要以每秒 30 帧的速度运行模型，较慢的帧速率就足够了。

在模型分辨率和帧速率之间有一个权衡，因为 GPU 在一秒钟内可以进行的计算数量有限。您可能会看到一些视频聊天平台在使用卷积实现视频效果(即改变背景)时，帧率较低或缓冲更多。为了了解不同的帧速率和输入形状是什么样子，我用原始的神经网络和 OpenCV 在电脑上制作了几个风格化的视频。我选定的目标帧速率为 15 fps，输入为 480 x 853。我发现这些仍然是视觉上吸引人的，也是基准测试中可识别的数字。

利用 GPU

我使用 tfcoreml 和 coremltools 将 Tensorflow 模型转换为 coreml 模型。完整方法的要点可以在下面找到。这里有几个考虑因素。首先，我转向了批量规范化，而不是实例规范化。这是因为 CoreML 没有现成的实例标准化层，这简化了实现，因为在干扰时间，每批中只有一个帧。还可以在 tfcoreml 中使用自定义方法来转换实例规范化层。

接下来，TensorFlow 和 CoreML 之间的张量形状不同。TensorFlow 模型有一个 out in (B，W，H，CH)，而 CoreML 支持图像的(B，CH，W，H)。在将模型转换为 CoreML 模型后，我编辑了模型规格，以使转置层适应形状。只有在将模型输出形状更改为格式(B，CH，W，H)之后，我才将输出类型更改为图像。这必须在模型规格中手动完成；在撰写本文时，tfcoreml 支持图像作为输入参数，但不支持输出。

此外，由于我缩小了图像的尺寸，以便通过网络传递它们，因此我能够使用 coremltools 添加一个放大层，将图像放大到合理的 1920 x 1080 帧大小。一种替代方法是在获得网络结果后调整像素缓冲区的大小，但这将涉及 CPU 的工作或 GPU 上的额外排队。CoreML 的 resize 层具有双线性缩放，并提供了令人满意的放大，几乎没有特征或像素伪像。由于这个调整大小层不是基于卷积，它也增加了模型推断时间的最小时间。

我使用 GPU 的最后一个方法是显示帧。由于我向帧添加了自定义处理，所以我不能将它们直接发送到标准的 AVCaptureVideoPreviewLayer。我使用 Metal Kit 中的 MTKView 来展示框架，它利用了 GPU。虽然金属着色器是一个简单的传递函数(输入作为输出返回)，但绘图证明是高性能的，并且视图中的队列在丢帧的情况下也很有帮助。

简化模型架构

原始模型架构有五个剩余卷积层。虽然在标准 GPU 上性能很高，但这对 A12 处理器来说太深了，至少对于典型的帧速率来说是这样。神经网络学习各种纹理的一个主要组成部分是五个残余块。如果纹理很简单，后面的剩余层可能看起来更接近身份过滤器。如果纹理更复杂，所有的层可能有有意义的过滤器。我试着为一个更高性能的网络修剪掉一些这样的块，代价是不能学习一些高度复杂的纹理。此外，我试验了可分离的卷积层，而不是传统的全连接层，就像在其他轻量级架构(如 MobileNets)中使用的那样。

A12 测试中使用的架构。灰色卷积残差块(2–4)是通过移除或使用块中的可分离卷积层进行实验的。

我在一台计算机 GPU 上测试了几种不同的架构，以缩小最具性能的网络，同时将纹理降级降至最低。虽然我只使用了 3 x 3 大小的内核，但我保持了原始架构的缩小和放大在很大程度上的一致性。一些改变(将剩余块减少到 1，将过滤器的数量减少到 64)具有快速的推断时间，但是在质量上有很大的下降。在 GPU 测试之后，我在一台配有 A12 芯片的 iPhone XS 上测试了这些模型。

各种模型架构的结果(毫秒)。

这些是 100 次迭代的基准测试的结果(以毫秒为单位)，输入帧大小为 480 x 853。第一帧被省略，因为它是模型“启动”的异常值。从这些结果中得出的一个有趣的结论是，可分离的卷积块并没有提高网络的性能。为了提高效率，可分离的卷积层通常难以实现。我读过各种案例，其中可分离层在不同环境中的表现不尽如人意，这里也可能是这种情况，这值得进一步研究。

我使用了 3 个完整的(不可分离的)剩余块来获得以下结果。这种模式在各种风格和案例上都非常有效。15 fps 是每帧 66 毫秒，这种实现可能是该设备的上限，因为会出现几次丢帧或延迟。

结果和考虑

下面是一些应用了不同风格和纹理的例子。这些结果为移动设备上的视频显示了比当前流行的仅使用着色器或单个滤镜的效果复杂得多的效果。

草图纹理样式

“缪斯”风格

“尖叫”风格

“雨公主”风格

马赛克风格

从这个实验中得到的一个教训是，修整过的神经结构并不能概括所有的风格，因为分解图像的层数较少。这在复杂的样式中最为明显，这些样式更多地变换了图像中的对象。用神经网络进行转换是一个很难解决的问题，所以这并不奇怪。马赛克风格是这个问题的一个很好的例子。与其他实现包含的更复杂的特征相比，我的实现在图像中重复类似的镶嵌，后者在后处理中使用完整的网络。另一方面，更简单的风格，如“尖叫”和普通的草图纹理表现得相当好，与整个建筑的预期相似。

另一个缺点是缺乏广义超参数。通过修剪后的网络，我发现没有一组可靠的超参数适用于大多数风格。再一次，马赛克风格在这里有改进的空间，因为内容组件被牺牲了，希望有更复杂的风格特征。

随着未来硬件的进步，能够使用更大的神经网络是不可避免的。随着更复杂的网络，更复杂的风格，纹理，甚至对象转换都是可能的。目前，这表明可以开发各种过滤器和效果，用于社交媒体等实时视频内容。

相关著作

*实时视频神经风格转移，*凯特·鲍姆利，丹尼尔·迪亚蒙，约翰·西格蒙——https://towards data science . com/Real-Time-Video-Neural-Style-Transfer-9f6f 84590832

创建 AWS EC2 并将其与 AWS Cloud9 IDE 和 AWS S3 连接

原文：https://towardsdatascience.com/creating-aws-ec2-and-connecting-it-with-aws-cloud9-ide-and-aws-s3-a6313aa82ec?source=collection_archive---------9-----------------------

创建亚马逊弹性计算云 (EC2)、将其与亚马逊简单存储服务(S3)链接并连接到 AWS Cloud9 集成开发环境(IDE)的分步教程

由克里斯蒂安·威迪格在 Unsplash 上拍摄的照片

亚马逊网络服务(AWS)。

有时，您可能会因为您的桌面功能而无法完成任务。例如，作为一名数据科学家，大部分时间几乎不可能将一个巨大的数据集加载到您的个人桌面上。即使您能够加载这些数据，训练您的模型也可能需要很长时间。一个可能的解决方案是使用亚马逊 Web 服务 ( AWS )。你可以从这里阅读更多关于 AWS 的内容。

使用亚马逊弹性计算云 ( 亚马逊 EC2将有助于解决前面提到的问题。它是可扩展的，并且消除了预先投资硬件的需要。你可以从这里阅读更多关于亚马逊 EC2 的信息。

还有亚马逊简单存储服务 ( 亚马逊 S3 )可以用来随时存储和检索任意数量的数据。你可以从这里阅读更多关于亚马逊 S3 的信息。

为了使与亚马逊 EC2 的通信更容易，可以使用 AWS Cloud9 。它是一个基于云的集成开发环境( IDE )，让你可以使用浏览器编写、运行和调试你的代码。你可以从这里阅读更多关于 AWS Cloud9 的内容。

在本文中，我们将:

1. 获取访问密钥和秘密密钥
2. 构建一个 AWS EC2 实例。
3. 使用 PuTTY 连接到该实例。
4. 连接到 S3 自动气象站。
5. 连接 AWS Cloud9。

1.获取访问密钥和秘密密钥

访问密钥和秘密密钥用于验证您向 AWS 发出的请求。

从这里创建 AWS 账户后，从这里登录 AWS 管理控制台。

登录后显示的 AWS 管理控制台-作者图片

首先，我们需要创建一个访问密钥和秘密密钥。在安全、身份、&合规挑选 IAM (身份和访问管理)。

Pick IAM 按作者分类的图像

按下用户然后选择你的用户名。如果找不到您的用户名，按 添加用户。

按下用户 —图片作者

按下您的用户名后，在安全凭证选项卡内按下创建访问键。然后下载。csv 文件。你会在里面找到你的访问密钥&秘密密钥。把它们存放在安全的地方，因为你以后会需要它们。

按下创建访问密钥然后下载。csv —作者图片

2.构建一个 AWS EC2 实例

回到 AWS 管理控制台，从 compute pick EC2。

选择 EC2 —按作者分类的图像

按下启动实例。

按下启动实例 —图片由作者提供

从显示的选项中选择适合你的。在这个教程中，我将选择 Ubuntu Server 20.04 LTS 版本**。按下**选择****

搜索或向下滚动到 Ubuntu Server 20.04 LTS，然后按选择—作者图片

选择您需要的实例。对于本教程，我将选择 t2.micro 。有关 Amazon EC2 实例类型的更多信息，您可以按这里的。

选择所需的实例类型-按作者分类的图像

从上面的标签中选择 4。添加存储器。如果需要，您可以增加大小。

如果需要，增加大小—图片由作者提供

选择 6。配置安全组。将分配一个安全组改为选择一个现有的安全组。选择您想要的群组。您的管理员应该已经创建了该策略，或者您也可以创建它。如果不选择安全组，您的计算机将是公共的，任何人都可以访问。如果需要，您可以随意使用任何其他配置。最后，按下查看并发射然后发射。

选择一个安全组，然后按查看并启动 —图片由作者提供

将选择现有的密钥对改为创建新的密钥对。然后为该密钥对添加一个名称，并按下下载密钥对。这将下载一个 pem 文件。然后按下启动实例。最后，按下视图实例。

创建新的密钥对，然后下载 pem 文件。启动实例，然后按查看实例-按作者分类的图像

你会发现你的机器没有名字。将其重命名为您想要的名称，然后点击选择它。复制公共 DNS(IPv4) ，因为我们将在下一步中需要它。

重命名您的机器，然后选择它，并复制公共 DNS 由作者的形象

3.使用 PuTTY 连接到此实例

下一步你需要安装油灰。PuTTY 是一个终端仿真软件，可以在 Windows、Unix 和 Linux 上运行。

打开推杆。选择加载。转到保存 pem 文件的路径(之前在步骤 2 中保存)。确保将类型的文件设置为所有文件(。) 查看 pem 文件。双击 pem 文件。

您应该会得到一条消息，表明您成功导入了外键。按确定，然后保存私钥。

油灰键生成器。媒体负载—作者提供的图像

关闭油灰并打开油灰。

在主机名中写上 ubuntu@ <粘贴公共 DNS(IPv4) >

展开 SSH 然后按下 AUTH 。点击浏览并转到你之前保存的 PPK 然后双击它。

回到会话，然后在“保存的会话中添加一个名称，然后按保存。这样，您就将配置保存到了 PuTTY 中。下次要连接机器时，只需按下 load 即可。

最后按下打开

PuTTY —作者提供的图像

现在你通过终端连接到机器上，可以写任何你想要的 linux 命令。

PuTTY 连接的终端—图片由作者提供

您应该从以下两个命令开始更新环境。

sudo apt-get update
sudo apt-get -y upgrade

4.将 AWS EC2 连接到 AWS S3。

要通过机器与 AWS S3 交互，您可以通过以下命令安装 awscli

sudo apt-get install -y awscli
aws configure

" aws configure "将要求您输入之前在 IAM 中生成的访问密钥和秘密密钥(来自步骤 1)。对于其他 2 个提示，按回车键即可(无需填写)。

从 aws 复制一些东西到你的机器就像在 linux 中使用 cp 命令。示例:

aws s3 cp source destination

源和目的可以是机器上的本地路径，也可以是 s3 上的路径。

对于 s3 路径，只需要在开头加上 s3:// 即可。

将文件从 S3 复制到本地机器的示例:

aws s3 cp s3://FolderName/fileName.txt ./fileName.txt

保持 PuTTY 与实例的连接，并为下一步运行终端。

5.将 AWS EC2 连接到 AWS Cloud9

从 AWS 管理控制台，在开发者工具内选择 Cloud9。

Pick Cloud9 —按作者分类的图片

按创建环境。为该环境添加任何名称，然后按下下一个。

按创建环境-按作者分类的图像

在配置设置中，将环境类型更改为连接并运行在远程服务器(SSH) 。在用户中，写入 ubuntu 。添加实例的公共 DNS IPv4 。然后按下复制密钥到剪贴板。

更改环境类型并填充数据-按作者分类的图像

在连接到机器的 PuTTY 终端中，写入以下命令，将键保存到机器中:

echo <**Paste the Copied Key**> >> ~/.ssh/authorized_keys
sudo apt-get install -y nodejs

Cloud9 需要 nodejs 这就是我们安装它的原因。

在配置设置中按下下一步，然后创建环境。

Cloud9 加载屏幕—作者图片

右键点击 C9 安装和复制链接地址。

按下下一个并勾选所有选项。

右键点击“ C9 安装”和复制链接地址 —图片作者

进入 PuTTY 终端并运行以下命令:

wget <**Paste the copied link address**>
chmod a+x c9-install.sh
sudo apt-get -y install python
sudo apt-get install build-essential
./c9-install.sh

现在你可以关闭油灰并从云 9 继续。

Cloud9 欢迎屏幕—作者图片

现在，您已经准备好在这个 IDE 上开始开发了。你可以使用 Cloud9 通过拖放将文件或数据从你的本地机器上传到 EC2 。您也可以运行 / 调试代码或使用下面的终端与机器交互。

Cloud9 IDE —作者图片

注意:如果实例的 IP 地址改变了(当你停止一个实例，然后重启它的运行时发生)，你只需要复制新的 IPv4 地址。

在 Cloud9 中，点击左上角的 Cloud9 图标。

点击“转到您的仪表板”。按下所需的环境，然后从右上角选择编辑。然后向下滚动到主机，只需更改 IPv4 地址。

选择环境，然后按编辑-按作者分类的图像

结论

本教程提供了启动和连接 AWS EC2 到 AWS Cloud9 的分步指南，以及将数据从 AWS S3 移入或移出。这应该有助于设置一个基本的数据科学环境。

我推荐 AWS 文档来获得更多关于亚马逊提供的所有服务的信息。

创建漂亮且信息丰富的文本表示:单词云

原文：https://towardsdatascience.com/creating-beautiful-informative-representations-of-text-wordclouds-84911f6d05b5?source=collection_archive---------50-----------------------

一个简单的 Python 教程

单词云经常被误认为是笨重和过时的。事实上，它们可以是优雅和创造性的文本交流方法，既可以作为探索性分析，也可以作为演示。此外，它们很容易用 Python 创建——所以让我们开始吧！

让我们复制粘贴这篇新冠肺炎文章的内容，并将其粘贴到一个名为covid_article.txt的文本文件中。这个文本文件的内容将被存储到一个名为content的变量中。

为了确保一个单词与另一个单词相同，我们需要去掉标点符号和大写字母，这样“hello”就与“hello”相同，而“Hello”与“Hello！”相同。我们还需要确保字符都是字母——我们可以通过列表理解(或者正则表达式)来实现这一点。

显然有一些小问题需要解决，但一般来说这只是一串单词，我们现在继续。我们需要导入wordcloud模块(使用pip install wordcloud安装)和matplotlib库来显示图像。

我们可以使用 wordcloud 用简单的参数构建一个 WordCloud。使用了三个参数——max_font_size，表示一个字的最大大小；max_words，显示的最大字数；还有background_color，设置背景的颜色。Matplotlib 可以用来设置图形大小，显示文字云，不显示轴。

不要担心分辨率低，我们稍后会解决这个问题。

它看起来不是很好，但它有很多我们期望看到的信息，每个单词的大小取决于它在文本中出现的次数。请注意，默认情况下，所谓的“停用词”，或者像“a”、“I”或“and”这样的常用词被排除在词云之外。您可以编写额外的过滤器来删除其他单词。

让我们试着改变颜色。我们需要创建一个函数color_func()，它返回一个 HSL 颜色，这是另一种表示颜色的方法(仅次于 RGB)。这个函数返回介于灰色和红色之间的随机颜色。

你可以在这里熟悉 HSL(色相、饱和度、明度)。供参考，这是hsl(0,50,50)的数值。

要应用 color 函数，请使用以下代码将 wordcloud 转换为数组，并应用重新着色函数。

或者，我们可以重新定义color_func函数来接受一个word参数，并检查它是否在最常见的单词列表中，top_words。在这种情况下，top_words是文本中出现超过二十次的所有单词的集合。如果单词是顶部单词，则返回一个随机的红色值。否则，该单词将显示为灰黑色。

让我们把这个词做成病毒形状的云。首先，我们需要找到病毒的图片——你可以在任何搜索引擎上找到它。理想情况下，图像将有一个白色背景来创建一个“面具”。

来源: IconExperience 。图片免费分享。

掩码需要通过 PIL (Python Imaging Library)读取，并通过 NumPy 转换成数组。我们需要进口这些。

一旦mask被创建，就可以在WordCloud中使用，包括参数mask=mask。这个例子也使用了上面例子中的着色函数。

不错！Wordcloud 为我们做了适应面具的大部分工作。对于我们的特定图像，较大的单词被推到中间，较小的单词被推到外面，这提供了一个很好的层次风格的可视化。

或者，我们可以将背景改为‘black’，将文本颜色改为灰白色，以获得另一种可视化效果。

一些额外的想法/建议:

• 增加字数可以帮助更好地勾勒出面具的轮廓。
• 这些单词云的输出通常是粒状的。要导出高质量图像，请使用plt.savefig(“filepath/name.png”, dpi=600)，其中 DPI 为“每英寸点数”。600 DPI 很好地平衡了质量和处理时间。

高分辨率图像！

• 了解到较大的区域通常由较大的单词填充，尝试在 photoshop/PowerPoint 中创建自己的蒙版来表达层次。
• 使用着色功能，您可以突出显示重要的单词，并探索其他提供的**kwargs，如font_size、position和orientation。例如，可以根据单词的大小或其在图像中的位置成比例地对单词进行着色(例如，根据单词在图像中的位置对单词进行着色)。

感谢阅读！

[## 您一直在寻找的 5 个以上简单的一行程序来提升您的 Python 可视化水平

最小的努力，最大的收获

towardsdatascience.com](/5-simple-one-liners-youve-been-looking-for-to-level-up-your-python-visualization-42ebc1deafbc)

除非另有说明，图片由作者创作。

使用 Python 创建超越默认设置的美丽地图

原文：https://towardsdatascience.com/creating-beautiful-maps-with-python-beyond-the-defaults-c92593ccf2cc?source=collection_archive---------17-----------------------

超越默认地图定制的初学者指南

照片由珍·西奥多在 Unsplash 拍摄

用 Geopandas 制作地图非常容易，但我必须承认，它的默认设置不如其他数据可视化软件。在本教程中，我们将研究改变和创建美丽地图的方法。有许多不同的方式来定制您的地图。我们介绍了一些具体的方法，您可以通过参数、选择颜色以及在地图中添加背景图和底图来增强地图制作。

让我们用少而简单的代码制作出光滑美观的地图。

数据和默认地图

让我们读取数据，并用默认值将其可视化。我们使用 Geopandas read_file() 函数读取数据。用 Geopandas 绘制地理数据也很简单，只需调用plot()) 函数。

gdf = gpd.read_file(“data/malmo-pop.shp”)
gdf.plot()

看那张地图。尽管长得丑，我们还是要欣赏这种轻松。我们可以用参数来增强和定制地图。绝不接受默认值。

自定义地图参数

上面的地图有几个缺点，我们可以很容易地通过获取和定制参数来解决。在这一节中，我们回顾一些可以帮助我们制作更加美观的地图的基本元素。让我们添加一些基本元素和自定义地图。

fig, ax = plt.subplots(figsize=(16,16)) # 1gdf.plot(ax=ax, color=”grey”, edgecolor=”white”, linewidth=0.2) # 2plt.title(‘Mälmo Neighbourhoods’, fontsize=40, fontname=”Palatino 
Linotype”, color=”grey”) # 3ax.axis(“off”) # 4plt.axis('equal') # 5plt.show() # 6

到目前为止我们做了什么？。我们为地图添加了一个标题(#3)，并删除了纬度和经度的轴标签(# 4)。在(#5)中，我们还通过确保比例保持固定来确保地图尽可能地代表现实— plt.axis("equal")。我们也增加了地图的大小(# 1)。

地图的实际颜色作为参数传递给plot()函数。我们将地图默认的蓝色改为灰色，并使线条边缘变小为白色。

我们在定制地图方面走得更远了。上面的地图比之前默认的地图更令人愉快。在下一节，我们将了解如何有效地使用颜色。

有效地使用颜色

虽然颜色的选择是个人的，但有许多工具可以通过设计指南帮助你有效地选择颜色。一个这样的工具是平板。这些是可口可乐的一些指导颜色选择。

我将在地图上添加街道线，这样我们就可以为地图选择不同的颜色。

streets = gpd.read_file(“data/malmo-streets.shp”)colors = [“#A1E2E6”, “#E6BDA1”, “#B3A16B”, “#678072”, “#524A4A”]
palplot(colors, size=4)

我们可以使用这些颜色来传递函数参数。

fig, ax = plt.subplots(figsize=(20,20))
streets.plot(ax=ax, color = colors[4], linewidth= 0.2)
gdf.plot(ax=ax, color=colors[1], edgecolor=”white”, linewidth=0.3)plt.title(‘Mälmo Neighbourhoods’, fontsize=40, fontname=”Palatino Linotype”, color=”grey”)
ax.axis(“off”)
#plt.axis(‘equal’)
plt.show()

使用您选择的颜色，您可以增强地图的视觉美感。在这个例子中，我们修改了地图的背景颜色，并给街道线赋予了十六进制颜色#678072。

上图显示了颜色的有效使用，以及如何使用十六进制代码选择颜色。为了给我们的地图添加上下文，我们可以添加底图。

添加底图

早先添加背景底图相当复杂，但是随着上下文库的引入，我们可以很容易地将不同的底图添加到我们的地图中。让我们这样做吧。

fig, ax = plt.subplots(figsize=(16, 18))gdf.to_crs(epsg=3857).plot(ax=ax, color=colors[1], edgecolor=”white”, linewidth=0.3, alpha=0.5) # 2 - Projected plot streets.to_crs(epsg=3857).plot(ax=ax, color = colors[4], linewidth= 0.2)ctx.add_basemap(ax, url=ctx.providers.Stamen.TonerLite) # 3plt.title(‘Mälmo Neighbourhoods’, fontsize=40, fontname=”Palatino Linotype”, color=”grey”)
ax.axis(“off”)
#plt.axis(‘equal’)
plt.show()

我们只是将数据投影到网络墨卡托，然后绘制它(# 2)，并添加一个底图，在这种情况下，Stamen Toner Lite 设计。这是带底图的地图。根据您的选择，您可以选择许多不同的底图。

上面的地图有一个上下文底图，与 Geopandas 提供的默认地图相比，视觉效果更好。不要接受默认设置，尝试实验和设计你的地图。有了 Matplotlib 的一些知识，您可以用 Python 创建一个美观的地图。

结论

在本教程中，我们介绍了如何在使用 Geopandas 制作地图时超越默认设置。我们已经看到了如何使用参数调整和定制绘图。我们也分享了如何在你的地图中加入色彩设计。最后，我们很容易地添加了底图，为地图提供了上下文。

本教程的代码可以在这个 Github 仓库中获得。

[## shakasom/esda

permalink dissolve GitHub 是 4000 多万开发人员的家园，他们一起工作来托管和审查代码，管理…

github.com](https://github.com/shakasom/esda/blob/master/Plotting.ipynb)

用 floWeaver 创建漂亮的桑基图

原文：https://towardsdatascience.com/creating-beautiful-sankey-diagrams-with-floweaver-dc1f02fe76bc?source=collection_archive---------5-----------------------

用 Python 升级您的 Sankey 游戏

不久前，我写了“桑基图的什么、为什么和如何”在探索 Matplotlib 的 Sankey 库的过程中，我发现了一个可爱的替代品:floWeaver。如果您正在寻找一个不同风格的 Sankey 风格的图来记录流程，这个博客就是为您准备的。

叙利亚难民及其目的地的桑基图(注:性别/年龄数据系捏造)。

老实说，我希望 floWeaver 比 matplotlib sankey 更容易使用。我最终发现它是不同的，而不是更容易/更难。我确实认为默认设置的图表更吸引我，在默认设置中，您必须有一个愿景，并在 matplotlib sankey 中更有意识地进行设计选择。

当 floWeaver 运行良好时

以下是一些您可能选择 floWeaver 而不是 matplotlib sankey 的情况:

• 您希望跟踪跨节点的流(例如，标记原始输入源，即使它经过了几个步骤)
• 您没有连接到箭头和方向端点(例如，指向上或指向下的流)
• 你可以接受好看的默认值，不需要对字体大小之类的东西进行太多的控制

安装 floWeaver

在 floWeaver GitHub 上找到你需要知道的一切。或者这里是给conda用户的概要:

安装 floWeaver 本身:

conda install -c conda-forge floweaver

安装 ipysankeywidget 以在 Jupyter 笔记本中显示 sankey 图:

conda install -c conda-forge ipysankeywidget

启用 ipywidgets。这可能已经启用，但确认一下也无妨:

jupyter nbextension enable --py widgetsnbextension --sys-prefix

数据格式

看起来floWeaver需要列/特性“源”、“目标”和“值”。从这里，您可以添加其他特性，使用您想要的任何列名。这些源和目标将成为您的终端节点的一个选项。如果你真的想绘制一个其他的特征作为你的末端节点，那也可以，但是你的末端节点的一个选项仍然应该在“目标”列中(如果我的推断是正确的)

以下是我将在下面使用的示例的数据表:

叙利亚难民数据表

扩大的叙利亚难民数据表(捏造的数据)

家庭财务数据表

使用 floWeaver

首先，在 Rick Lubton 和团队的教程、文档和例子中找到这个和更多。我强烈建议您使用它们( docs ， GitHub repo )来进一步调查。

制作桑基图

简单难民数据集的桑基图。

1. 从导入和导入数据集开始。这里我们使用上面显示的简单难民数据集。

import pandas as pd
from floweaver import *refugees = pd.read_csv('refugees.csv')

2.设置您的节点、顺序、包和分区

节点是桑基图的聚集点。你的流动将要流入和流出的固定“位置”。在本例中，左侧是叙利亚，右侧是七个目的地。您可以根据需要命名节点组。每个“进程组”将显示为一组垂直排列的节点。注意 ProcessGroup 接受一个列表作为它的参数，但是在节点名称是否重复方面是灵活的。

nodes = {
    'start': ProcessGroup(['Syria']), # one (Syria) at the start 
    'end': ProcessGroup(list(refugees['target'])), # 7 at the end
}

顺序是您希望节点进程组出现的顺序(从左到右)。请注意，这是一个进程组/节点名称列表:

ordering = [[‘start’], [‘end’]]

束是您想要显示的一组连接。这使您可以选择删除任何不必要的连接。包应该是 floWeaver 的列表。捆绑包含连接信息的对象。

bundles = [Bundle('start', 'end')]

即使您已经定义了节点，我们也需要设置分区，以指示我们希望它们被分割的确切方式。使用.unique()让我们不必单独列出每个目的地。

nodes['start'].partition = Partition.Simple('source', ['Syria'])
nodes['end'].partition = Partition.Simple('target', 
                                        refugees['target'].unique())

3.创建并显示您的桑基图

使用上面的节点、排序和捆绑包创建 Sankey:

sdd = SankeyDefinition(nodes, bundles, ordering)

要显示桑基，将 floWeaver 的weave(*sankey_definition, dataset, measures=’value’, link_width=None, link_color=None, palette=None*)与.to_widget()结合使用，以显示在 Jupyter 笔记本中。如果要保存图像，请在.to_widget()后添加.auto_save_png(*filename*)。

weave(sdd, refugees).to_widget().auto_save_png('syria1.png')

将较小的功能捆绑到一个组合类别中

正如你在上面看到的，我们有一些非常小的流量。除了修改 end nodes 分区之外，您可以使用与上面相同的代码将它们捆绑在一起。不是列出同一级别上的所有节点，而是为您想要进行的任何分组创建一个(名称，节点列表)元组。

nodes[‘end’].partition = Partition.Simple(‘target’, 
                            [‘Turkey’, 
                             ‘Lebanon’, 
                             ‘Jordan’, 
                             ‘Europe’,
                             (‘Other’, [‘Iraq’, ‘Egypt’, ‘USA’])])

您需要重新创建 Sankey 定义并重新编制 Sankey:

sdd = SankeyDefinition(nodes, bundles, ordering)
weave(sdd, refugees).to_widget().auto_save_png('syria_other.png')

叙利亚难民与伊拉克、埃及和美国捆绑成“其他”的桑基图

突出显示不同的(非目标)特征

为了突出显示一个非目标特性，再次调整分区。在这里，我们按地区划分。

# set end partition to region
nodes[‘end’].partition = Partition.Simple(‘region’, 
                                       refugees[‘region’].unique())# create SankeyDefintion, display and save image
sdd = SankeyDefinition(nodes, bundles, ordering)
weave(sdd, refugees).to_widget().auto_save_png('syria_region.png')

按地区分列的锡兰难民目的地桑基图。

添加路点(中间步骤)

突出流程中不同特征或步骤的另一种方式是通过路点(额外的节点集)。

按地区和目的地分列的叙利亚难民目的地桑基图。

要添加此路点，我们需要

1. 为我们的航点(区域)创建一个新的分区
2. 将航路点添加到我们的节点字典中，提供给Waypoint新的区域划分
3. 将航点添加到我们的订购列表中(中间)
4. 通过添加 waypoints=[ node_name 作为参数，将航点添加到我们的包中。

# create region partition
region = Partition.Simple('region', refugees['region'].unique())# set the "nodes"
nodes = {
    'start': ProcessGroup(['Syria']),
    'middle': Waypoint(region),
    'end': ProcessGroup(list(refugees['target'].unique())), 
}# set the order of the nodes left to right
ordering = [['start'], ['middle'], ['end']]# set the "bundle" of connections
bundles = [Bundle('start', 'end', waypoints=['middle'])]# partition the groups for display
nodes['start'].partition = Partition.Simple('source', ['Syria'])
nodes['end'].partition = Partition.Simple('target', 
                                        refugees['target'].unique())# set color palette
palette = {'North America': '#ED533B', 'Middle East': '#3CAEA3', 
           'Europe': '#F6D55C'}# create sankey with flow_partition
sdd = SankeyDefinition(nodes, bundles, ordering, 
                       flow_partition=region)# display sankey (with color palette) and save as png
weave(sdd, refugees, palette=palette).to_widget().auto_save_png('syria_waypt.png')

调整显示功能

要调整颜色，创建一个调色板字典，在 SankeyDefinition 中添加您想要着色的分区作为“flow_partition”，并将您的调色板添加到weave()。注意:这段代码使用了上面的节点、包、排序和数据集。

# set color palette
palette = {'North America': '#ED533B', 'Middle East': '#3CAEA3', 
           'Europe': '#F6D55C'}# create sankey with flow_partition for color
sdd = SankeyDefinition(nodes, bundles, ordering, 
                       flow_partition=region)# display sankey (with color palette) and save as png
weave(sdd, refugees, palette=palette) \
     .to_widget().auto_save_png('syria_waypt.png')

要调整 Sankey 输出的大小，创建一个大小字典并将其添加为.to_widget()的参数

# image size
size = dict(width=570, height=300)# create sankey diagram
weave(sdd, refugees).to_widget(**size).auto_save_png('syria_sm.png')

这是最后一个例子，一起展示。

假设家庭资金流动的桑基图

# set the nodes
nodes = {
    'start': ProcessGroup(list(household['source'])),
    'category': Waypoint(Partition.Simple('category', 
                         household['category'].unique())),
    'end': ProcessGroup(list(household['target'])),
}# set the order of the nodes left to right
ordering = [['start'], 
            ['category'],
            ['end']]# set the "bundle" of connections you want to show
bundles = [Bundle('start', 'end', waypoints=['category'])]# add the partitions
partner = Partition.Simple('source', household['source'].unique())
nodes['start'].partition = partner
nodes['end'].partition = Partition.Simple('target', 
                         household['target'].unique())# add the color palette
palette = {'partner 1': '#027368', 'partner 2': '#58A4B0'}# create the sankey diagram
sdd = SankeyDefinition(nodes, bundles, ordering, 
                       flow_partition=partner)# display the sankey diagram
weave(sdd, household, palette=palette).to_widget().auto_save_png('./images/household.png')

你可以在上面看到，颜色划分并不总是产生我想要的结果，但是在这一点上，我不确定如何调整它。对我来说，根据航路点给流着色看起来最可爱，但不一定能实现桑基图的目标——别忘了把它放在最前面！

更美观的家用桑基图，但不是很好地显示了乐趣、必需品和拯救每个伙伴的贡献。

和往常一样，请查看 GitHub repo 中的完整代码。编码快乐！

叙利亚日落。照片由蒂莫西·卡西斯在 Unsplash 上拍摄

以 scikit-learn 方式创建基准模型

原文：https://towardsdatascience.com/creating-benchmark-models-the-scikit-learn-way-af227f6ea977?source=collection_archive---------16-----------------------

来源: pixabay

了解如何为分类和回归问题创建一系列基准模型

我真正喜欢scikit-learn的是我经常偶然发现一些我以前没有意识到的功能。我最近的“发现”是DummyClassifier。虚拟估计器不从特征中学习任何模式，它使用简单的试探法(从目标中推断)来计算预测。

我们可以使用那个简单的估计量作为我们更高级模型的一个简单的健全性检查。为了通过检查，所考虑的模型应该产生比简单基准更好的性能。

在这篇短文中，我将展示如何使用DummyClassifier,并解释可用的启发式方法。

设置

我们需要导入所需的库:

在本文中，我编写了一个简单的函数，打印一些选择的评估指标来评估模型的性能。除了准确性之外，我还包括了在类不平衡的情况下有助于评估性能的指标(这个列表并不详尽)。

加载数据

对于本文，我使用著名的 Iris 数据集。为了进一步简化问题，我将多类问题转化为二元分类，同时引入类不平衡。这个练习的目的是预测给定的植物是属于杂色类还是“其他”(Setosa 或 Virginica)。

改造后班级比例为 2:1。

训练模型前的最后一步是使用train_test_split函数将数据分成训练集和测试集:

因为我们有意引入了阶级不平衡

探索DummyClassifier的变种

DummyClassifier估计器提供了一些可能的规则(称为策略)，我们可以用它们来确定基准类预测。下面我将简要描述它们，并给出相应的代码片段来展示实现。

“持续”战略

可以说是虚拟分类器的最简单的变体。这个想法是用一个值代替所有的标签。这种变体的一个可能的用例是，当我们想要根据 F1 分数来评估一个潜在的评估者时，F1 分数是精确度和召回率的调和平均值。

我使用少数类(Versicolour)来创建天真的预测。同样值得一提的是，这些特性在确定预测值时不起任何作用，它们只是为了匹配scikit-learn的 fit + predict 风格。在下面的总结中，我们看到我们实现了完美的回忆，F1 得分为 0.5。

{'accuracy': 0.3333333333333333,
 'recall': 1.0,
 'precision': 0.3333333333333333,
 'f1_score': 0.5}

“统一”战略

在这个变体中，从可用的类中随机地(一致地)生成天真的预测。

运行代码会产生以下摘要:

{'accuracy': 0.4,
 'recall': 0.4,
 'precision': 0.25,
 'f1_score': 0.3076923076923077}

此外，我们使用Counter检查预测标签的分布:

Counter({0: 14, 1: 16})

正如均匀绘制所预期的，目标的分布是随机的，并不反映标签的真实分布。

“分层”战略

为了解决前面提到的缺点，我们可以使用stratified规则。预测是随机生成的，但是保留了来自训练集的类的分布。正如在分层的train_test_split中一样。

运行代码会产生以下摘要:

{'accuracy': 0.6333333333333333,
 'recall': 0.3,
 'precision': 0.42857142857142855,
 'f1_score': 0.3529411764705882}

我们再一次查看每一类的观察次数:

Counter({0: 23, 1: 7})

使用stratified策略会产生类似于我们在观察值中看到的分布。

“最频繁”策略

策略的名称很容易理解——预测值是标签中最常见的值。

运行代码会产生以下摘要:

{'accuracy': 0.6666666666666666,
 'recall': 0.0,
 'precision': 0.0,
 'f1_score': 0.0}

运行代码时，我们收到以下警告:UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples.原因是我们选择的策略。由于多数类用于所有预测，因此没有少数类的观测值，并且无法计算精度和召回率等指标。

“优先”策略

与‘most_frequent’策略非常相似的策略。伪分类器总是预测最大化类先验的类。区别在于拟合分类器的predict_proba方法。在‘prior’策略的情况下，它返回类别先验(类别概率由训练集中标签的比率决定)。

‘prior’和‘most_frequent’策略的结果是相同的，所以为了简洁起见，我不再展示它们。

值得一提的是，对于所有策略，predict方法完全忽略了输入数据，用作预测的值是在拟合阶段确定的(或在使用‘constant’策略时由我们提供)。

训练一个实际的评估者

在尝试了创建基准模型的多种策略之后，是时候训练一个简单的分类器并评估它是否优于基准了。为此，我使用带有默认设置的决策树分类器(除了为再现性指定的random_state)。

通过检查下面的总结，我们可以清楚地表明决策树优于所有的基准。

{'accuracy': 0.9473684210526315,
 'recall': 0.9230769230769231,
 'precision': 0.9230769230769231,
 'f1_score': 0.9230769230769231}

DummyRegressor

我已经展示了如何使用scikit-learn的DummyClassifier来评估分类任务的基准模型。自然，回归问题存在一个类比估计量——DummyRegressor。我就不赘述了，因为用法和DummyClassifier很像。为了完整起见，我只提到可用的策略:

• 'mean’ —估计器使用目标(来自训练集)的平均值作为预测
• 'median’ —估计器使用目标(训练集)的中值作为预测
• 'constant’ —估计器使用常数值作为预测值
• 'quantile’ —估计器使用目标(训练集)的指定分位数作为预测

与DummyClassifier类似，predict方法忽略计算预测的输入数据。

结论

在本文中，我展示了如何使用简单的试探法使用scikit-learn中可用的估计器来创建基准模型。我们可以使用这样的模型进行健全性检查，看看我们的评估者是否比天真的基线表现得更好。如果不是，我们应该调查是什么导致了这个问题(也许这些特性没有帮助或者类的不平衡影响了结果)。

您可以在我的 GitHub 上找到本文使用的代码。一如既往，我们欢迎任何建设性的反馈。你可以在推特上或者评论里联系我。

我最近出版了一本关于使用 Python 解决金融领域实际任务的书。如果你有兴趣，我贴了一篇文章介绍这本书的内容。你可以在亚马逊或者 Packt 的网站上买到这本书。

在 Matplotlib 中选择和创建色彩映射表

原文：https://towardsdatascience.com/creating-colormaps-in-matplotlib-4d4de78a04b8?source=collection_archive---------7-----------------------

Elena Mozhvilo 在 Unsplash 上的照片

MATPLOTLIB 简介

从颜色列表中创建和定制自己的色彩映射表的指南

答几乎所有使用 Python 编程语言的程序员都知道 Matplotlib。这是最常用的库之一。它是一个多平台库，可以运行许多操作系统，由 John Hunter 于 2002 年创建。

现在人们开始开发比 Matplotlib 更简单更现代风格的新包，像 Seaborn，Plotly，甚至熊猫都用 Matplotlib 的 API 包装器。但是，我认为 Matplotlib 仍然在许多程序员的心中。

如果你需要学习使用 Matplotlib 的入门知识，你可以看看这个链接。

[## 用 Matplotlib 实现数据可视化——绝对初学者第一部分

这是使用 Matplotlib 和 Jupyter Notebook(一个强大的 Python 模块)可视化我们的数据的教程。

medium.comI](https://medium.com/@bahrulsg/data-visualization-with-matplotlib-for-absolute-beginner-part-i-655275855ec8)

Matplotlib 中的色彩映射表

在可视化 3D 绘图时，我们需要色图来区分 3D 参数并做出一些直觉。科学上讲，人脑是根据看到的不同颜色来感知各种直觉的。

Matplotlib 提供了一些您可以使用的漂亮的色彩映射表，例如顺序色彩映射表、发散色彩映射表、循环色彩映射表和定性色彩映射表。出于实用的目的，我没有更详细地解释它们之间的区别。如果我向您展示 Matplotlib 中每个分类色彩映射表的示例，我想这将会很简单。

以下是一些连续色彩映射表的示例(并非全部)。

由 Matplotlib 提供的连续色彩映射表。

Matplotlib 会给你绿色的作为默认的颜色图。然后，接下来是 Matplotlib 中发散、循环、定性和杂项色彩映射表的示例。

Matplotlib 中的色彩映射表。

你自己的彩色地图

你对所有提供的颜色图都不感兴趣吗？还是需要其他花哨的彩图？如果是的话，你需要看完这篇文章。我将指导你定制和创建你自己的色彩映射表。

但是在定制它之前，我会给你看一个使用色彩映射表的例子。我使用’ RdYlBu_r '色彩映射表来可视化我的数据。

Matplotlib 中 RdYlBu_r 色彩映射表的示例(图片由作者提供)

让我们修改你自己的色彩映射表。

首先，我们需要使用下面的代码创建可视化的模拟数据

# import some libraries /  modules
import numpy as np
import matplotlib.pyplot as plt# create mock data
data = np.random.random([100, 100]) * 10

数据变量是一个数组，由 100 x 100 个从 0 到 10 的随机数组成。你可以通过写这段代码来检查它。

要可视化的模拟数据(图片由作者提供)

之后，我们将使用下面的简单代码显示带有默认颜色图的模拟数据。

plt.figure(figsize=(7, 6)) 
plt.pcolormesh(data)
plt.colorbar()

代码将向您显示这样的图形。

Colormesh 使用默认色彩映射表可视化模拟数据(图片由作者提供)

正如我之前提到的，如果你没有定义你使用的色彩映射表，你将得到默认的色彩映射表，命名为’ viridis '。

接下来，我将用这段代码将彩色地图从’绿色改为’地狱彩色地图

plt.pcolormesh(data, **cmap='inferno'**)

你会得到这样的结果

Colormesh 使用“inferno”色图可视化模拟数据

修改色彩映射表

现在，要修改色彩映射表，您需要在 Matplotlib 中导入以下子库。

from matplotlib import cm 
from matplotlib.colors import ListedColormap,LinearSegmentedColormap

要修改颜色图中颜色类别的数量，您可以使用以下代码

new_inferno = cm.get_cmap('inferno', 5)# visualize with the new_inferno colormaps
plt.pcolormesh(data, **cmap = new_inferno**)
plt.colorbar()

并且会得到这样一个结果

修改后的地狱只有 5 种颜色。

下一步是修改色图中的范围颜色。我会给你一个“hsv”色图的例子。你需要用这个图来了解颜色的范围。

hsv 彩色地图(图片由作者提供)

如果我们只想使用绿色(大约 0.3)到蓝色(0.7)，我们可以使用下面的代码。

# modified hsv in 256 color class
hsv_modified = cm.get_cmap('hsv', 256)# create new hsv colormaps in range of 0.3 (green) to 0.7 (blue)
newcmp = ListedColormap(hsv_modified(np.linspace(0.3, 0.7, 256)))# show figure
plt.figure(figsize=(7, 6))
plt.pcolormesh(data, **cmap = newcmp**)
plt.colorbar()

它会给你一个这样的数字

修改“hsv”色彩映射表的范围颜色(图片由作者提供)

创建您自己的色彩映射表

要创建自己的色彩映射表，至少有两种方法。首先，您可以在 Matplotlib 中组合两个连续的色彩映射表。第二，你可以在 RGB 中选择和组合你喜欢的颜色来创建彩色地图。

我们将向您演示如何将两个连续的色彩映射表合并为一个新的色彩映射表。我们想把“橙色”和“蓝色”结合起来。

结合蓝色和橙色的色彩映射表创建一个新的(作者图片)

你可以仔细阅读这段代码。

# define top and bottom colormaps 
top = cm.get_cmap('Oranges_r', 128) # r means reversed version
bottom = cm.get_cmap('Blues', 128)# combine it all
newcolors = np.vstack((top(np.linspace(0, 1, 128)),
                       bottom(np.linspace(0, 1, 128))))# create a new colormaps with a name of OrangeBlue
orange_blue = ListedColormap(newcolors, name='OrangeBlue')

如果您使用‘orange blue’色彩映射表来可视化模拟数据，您将得到如下图。

橙色蓝色地图(图片由作者提供)

下一步是从你喜欢的两种不同的颜色创建一个色图。在这种情况下，我将尝试从黄色和红色创建它，如下图所示

将被组合的两种颜色(图片由作者提供)

首先，你需要创建黄色色图

# create yellow colormapsN = 256yellow = np.ones((N, 4))yellow[:, 0] = np.linspace(255/256, 1, N) # R = 255
yellow[:, 1] = np.linspace(232/256, 1, N) # G = 232
yellow[:, 2] = np.linspace(11/256, 1, N)  # B = 11yellow_cmp = ListedColormap(yellow)

和红色地图

red = np.ones((N, 4))red[:, 0] = np.linspace(255/256, 1, N)
red[:, 1] = np.linspace(0/256, 1, N)
red[:, 2] = np.linspace(65/256, 1, N)red_cmp = ListedColormap(red)

下图显示了您创建的黄色和红色色彩映射表的可视化效果

左:红色 _cmp 和右:黄色 _cmp(图片由作者提供)

之后，您可以使用前面的方法组合它。

newcolors2 = np.vstack((yellow_cmp(np.linspace(0, 1, 128)),
                       red_cmp(np.linspace(1, 0, 128))))double = ListedColormap(newcolors2, name='double')plt.figure(figsize=(7, 6))plt.pcolormesh(data, cmap=double)
plt.colorbar()

你会得到这样一个数字

你自己的彩色地图:D

您还可以使用此代码调整色彩映射表的方向、延伸和焊盘距离。

plt.figure(figsize=(6, 7))plt.pcolormesh(data, cmap = double)
plt.colorbar(orientation = 'horizontal', label = 'My Favourite Colormaps', extend = 'both', pad = 0.1)

你会看到一个这样的图形

修改的色彩映射表

结论

为你的色彩图选择正确的颜色是很重要的，因为这是人类思维的表现。颜色表达思想、信息和情感。Matplotlib 提供了许多颜色图，但是有些人在选择颜色图时有不同的倾向。如果他们想建立自己的品牌，他们需要创建自己的色彩映射表。我希望这个故事可以帮助你在 Matplotlib 中创建和修改你自己的色彩映射表。

如果你喜欢这篇文章，这里有一些你可能喜欢的其他文章:

[## 使用 Matplotlib 可视化数据的 5 个强大技巧

如何使用 LaTeX 字体，创建缩放效果，发件箱图例，连续错误，以及调整框填充边距

towardsdatascience.com](/5-powerful-tricks-to-visualize-your-data-with-matplotlib-16bc33747e05) [## 用于科学绘图的 Matplotlib 样式

为您的科学数据可视化定制 Matplotlib

towardsdatascience.com](/matplotlib-styles-for-scientific-plotting-d023f74515b4) [## 使用 Matplotlib 实现 Python 数据可视化—第 1 部分

完成了从基础到高级的 Python 绘图的 Matplotlib 教程，包含 90 多个示例

towardsdatascience.com](/visualizations-with-matplotlib-part-1-c9651008b6b8) [## 在 Matplotlib 中自定义多个子情节

使用 subplot、add_subplot 和 GridSpec 在 Matplotlib 中创建复杂 subplot 的指南

towardsdatascience.com](/customizing-multiple-subplots-in-matplotlib-a3e1c2e099bc) [## Vaex 大数据简介—读取 12.5 亿行的简单代码

用 Python 高效读取和可视化 12.5 亿行星系模拟数据

towardsdatascience.com](/introduction-to-big-data-a-simple-code-to-read-1-25-billion-rows-c02f3f166ec9)

仅此而已。感谢您阅读这个故事。喜欢就评论分享。我还建议您关注我的帐户，以便在我发布新故事时收到通知。