使用 R Markdown 创建报告
使用 R Studio 和 R Markdown 编写报告的说明
图片由 Mediamodifier 来自 Pixabay
视频版本
介绍
使用 Jupyter notebook 或 Google Colab 很容易将 python 脚本转换成报告。你知道你也可以对 R 脚本做同样的事情吗？
在本教程中，我将演示如何将您的 R 脚本转换为报表。
先决条件
我们需要安装两个软件。
下载编织机包
请务必下载可以将 R Markdown 文件转换成报告的软件包。
您可以在控制台中运行命令(如下所示)来下载该包。
install.packages("knitr")
在 R Studio 中使用 R Markdown 进行编码
在“文件”标签下，点击“新建文件”和“R Markdown”。
命名文件并选择默认输出格式。您随时可以在以后更改输出格式。
一旦你点击了“Ok”，你现在就可以在 R Markdown 上编码和写报告了。
了解如何使用 R Markdown
突出显示的部分(或单元格)是您可以编写代码的地方。
```{r cars}
YOU CAN WRITE YOUR CODE HERE
并且**非突出显示的**部分是你可以写你的**报告**的地方。
R 降价示例
您可以通过单击单元格右上角的绿色运行按钮来运行整个单元格中的代码。
或者，您可以按 Ctrl + Enter 键只运行选定的代码。
# 针织 R 减价检索报告
为了编织 R Markdown 文件，您可能需要安装几个软件包。R studio 会自动检测到您缺少必要的包，并要求您下载它们。
有三种方法可以输出您的报告。
1. 超文本标记语言
2. 便携文档格式
3. MS Word
输出选项
**HTML 输出**
HTML 输出
**PDF 输出**
PDF 输出
**MS 字输出**
MS Word 输出
我希望这篇文章对你有用。感谢您的阅读！
# 使用 Flask 和 Python 创建 RESTful Web APIs
> 原文：<https://towardsdatascience.com/creating-restful-apis-using-flask-and-python-655bad51b24?source=collection_archive---------0----------------------->
## 编程；编排
## 用 Flask 构建 Web APIs 的综合指南
图片来自 [Pixabay](https://pixabay.com/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=2682712) 的 [Gerd Altmann](https://pixabay.com/users/geralt-9301/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=2682712)
lask 是一个广泛使用的微型 web 框架，用于在 Python 中创建 API。这是一个简单而强大的 web 框架，旨在快速轻松地开始使用，并能够扩展到复杂的应用程序。
从[文档](https://flask.palletsprojects.com/en/1.1.x/foreword/)中，
> “微型”并不意味着您的整个 web 应用程序必须适合一个 Python 文件(尽管它确实可以)，也不意味着 Flask 缺乏功能。微框架中的“微”意味着 Flask 旨在保持核心简单但可扩展。
来源:Flask 的[文件](https://flask.palletsprojects.com/en/1.1.x/_images/flask-logo.png)
# 装置
使用 pip 安装烧瓶
pip install Flask
# 最小烧瓶应用程序
from flask import Flask
app = Flask(name)
@app.route(‘/hello/’, methods=[‘GET’, ‘POST’])
def welcome():
return “Hello World!”
if name == ‘main’:
app.run(host=‘0.0.0.0’, port=105)
将该文件保存为`app.py` *(或任何其他你想要的文件名)*，并进入终端并键入`python app.py`(即`python <filename>.py`)
您应该会看到类似这样的内容:
- Running on http://0.0.0.0:105/ (Press CTRL+C to quit)
启动任何网络浏览器，然后前往`http://localhost:105/hello/`查看应用程序的运行情况。
现在，让我们逐行理解代码的工作原理:
`from flask import Flask` →导入烧瓶类
`app = Flask(__name__)` →创建类的一个实例
`@app.route('/hello/', methods=['GET', 'POST'])` →我们使用`route()`装饰器来告诉 Flask 哪个 URL 应该触发这个函数。
`methods`指定允许哪些 HTTP 方法。默认为`['GET']`
`if __name__ == '__main__'` → `__name__`是 Python 中的一个特殊变量，取脚本名的值。这一行确保我们的 Flask 应用程序仅在主文件中执行时运行，而不是在导入到其他文件中时运行
`app.run(host='0.0.0.0', port=105)` →运行烧瓶应用程序
指定我们希望 flask 应用程序运行的服务器。`host`的默认值为`localhost`或`127.0.0.1`
`0.0.0.0`的意思是*“本地机器上的所有 IPv4 地址”。这确保了从所有地址都可以到达服务器。
默认`port`值为`5000`，您可以设置参数`port`以使用您选择的端口号。*
# 可变规则
您可以使用`<variable_name>`向 URL 添加可变部分。该函数接收变量作为关键字参数。
from flask import Flask
app = Flask(name)
@app.route(‘/int:number/’)
def incrementer(number):
return "Incremented number is " + str(number+1)
@app.route(‘/string:name/’)
def hello(name):
return "Hello " + name
app.run()
运行上面的代码来启动 Flask 应用程序。
打开浏览器并转到`http://localhost:5000/Jimit`，您将看到输出为`Hello Jimit`，当您转到`http://localhost:5000/10`时，输出将为`Incremented number is 11`。
# 返回 JSON 可序列化输出
Flask 应用程序中函数的返回值应该是 JSON 可序列化的。您可以使用`jsonify`使您的输出 JSON 可序列化。该函数包装`json.dumps()`以将 JSON 输出转换成带有*application/JSON*mime-type 的响应对象。
## 示例 1:
这个例子展示了如何对字典对象使用`jsonify`:
from flask import jsonify
@app.route(‘/person/’)
def hello():
return jsonify({‘name’:‘Jimit’,
‘address’:‘India’})
这将发送如下的 JSON 响应:
{
“address”: “India”,
“name”: “Jimit”
}
## 示例 2:
还可以使用`jsonify`自动将列表和元组序列化为 JSON 响应。
from flask import jsonify
@app.route(‘/numbers/’)
def print_list():
return jsonify(list(range(5)))
这将产生输出:
[
0,
1,
2,
3,
4
]
# 重定向行为
@app.route(‘/home/’)
def home():
return “Home page”
@app.route(‘/contact’)
def contact():
return “Contact page”
在上面的例子中，`home`端点的 URL 有一个尾随斜杠，而`contact`端点的 URL 缺少尾随斜杠。
这会导致两种不同的行为:
1. 对于`home`端点，如果您访问不带结尾斜杠的 URL，那么 Flask 会将您重定向到带结尾斜杠的 URL。
2. 对于`contact`端点，如果您访问带有结尾斜杠的 URL，那么它将导致状态 404 Not Found。
# 返回状态代码
通过按如下方式指定状态代码，可以将状态代码与响应一起返回:
@app.route(‘/teapot/’)
def teapot():
return “Would you like some tea?”, 418
对这个 URL 的响应将是带有状态码`418`的`Would you like some tea?`，而不是通常的`200`。
# 请求前
通过使用`app.before_request` decorator，您可以指定一个应该在请求被处理之前一直执行的函数。
@app.before_request
def before():
print(“This is executed BEFORE each request.”)
@app.route(‘/hello/’)
def hello():
return “Hello World!”
对于这个例子，首先在服务器上打印语句`This is executed BEFORE each request.`，然后执行`hello`端点的功能。当您希望记录请求以进行监控时，这尤其有用。
# 访问请求数据
要访问请求数据，请使用以下命令
from flask import request
您可以使用以下属性来提取随请求一起发送的数据:
`[request.data](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.data)` →以字符串形式访问输入的请求数据
`[request.args](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.args)` →访问解析后的 URL 参数。返回`ImmutableMultiDict`
`[request.form](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.form)` →访问表单参数。返回`ImmutableMultiDict`
`[request.values](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.values)` →返回组合了`args`和`form`的`CombinedMultiDict`
`[request.json](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.json)` →如果 *mimetype* 为`application/json`则返回解析后的 JSON 数据
`[request.files](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.files)` →返回包含所有上传文件的`MultiDict`对象。每个键是文件名，值是`FileStorage`对象。
`[request.authorization](https://flask.palletsprojects.com/en/1.1.x/api/#flask.Request.authorization)` →返回一个`[Authorization](https://werkzeug.palletsprojects.com/en/1.0.x/datastructures/#werkzeug.datastructures.Authorization)`类的对象。它代表客户端发送的一个*授权*头。
# app.run()参数
`app.run()`在服务器上运行应用程序。除了`host`和`port`
之外，还有各种参数可以与`[app.run()](https://flask.palletsprojects.com/en/1.1.x/api/?highlight=threaded#flask.Flask.run)`一起使用，其中包括:
`debug` →如果`debug`参数设置为`True`，那么服务器将在代码更改时自动重新加载，并在出现未处理的异常时显示交互式调试器。默认为`False`
`use_reloader` →当`use_reloader`设置为`True`时，当代码改变时，服务器将自动重启。默认为`False`
`threaded` →当`threaded`设置为`True`时，进程将在单独的线程中处理每个请求。默认为`False`
`ssl_context` →连接的 SSL 上下文。如果服务器应该自动创建上下文，则需要`[ssl.SSLContext](https://docs.python.org/3/library/ssl.html#ssl.SSLContext)`、格式为`(cert_file, pkey_file)`的元组或字符串`'adhoc'`。默认值为`None`，即 SSL 被禁用。当我们想在 HTTPS 而不是 HTTP 上托管 Flask 应用程序时，使用这个。
# 蓝图
蓝图允许我们将不同的端点分成子域。
`home.py`
from flask import Blueprint
home_bp = Blueprint(‘home’, name)
@home_bp.route(‘/hello/’)
def hello():
return “Hello from Home Page”
`contact.py`
from flask import Blueprint
contact_bp = Blueprint(‘contact’, name)
@contact_bp.route(‘/hello/’)
def hello():
return “Hello from Contact Page”
`app.py`
from flask import Flask
from home import home_bp
from contact import contact_bp
app = Flask(name)
app.register_blueprint(home_bp, url_prefix=‘/home’)
app.register_blueprint(contact_bp, url_prefix=‘/contact’)
app.run()
注意，在两个蓝图中，`/hello/`路线都在调用`hello`函数。
当你去`http://localhost:5000/home/hello`时，输出将是`Hello from Home Page`
而当你访问`http://localhost:5000/contact/hello`时，输出将是`Hello from Contact Page`
# 记录
您可以使用以下方法在 Flask 应用程序中记录语句
app.logger.debug(‘This is a DEBUG message’)
app.logger.info(‘This is an INFO message’)
app.logger.warning(‘This is a WARNING message’)
app.logger.error(‘This is an ERROR message’)
## 参考
* [https://flask.palletsprojects.com/en/1.1.x/foreword/](https://flask.palletsprojects.com/en/1.1.x/foreword/)
## 资源
这篇文章的所有代码片段都可以在我的 [GitHub 页面](https://jimit105.github.io/medium-articles/Creating%20RESTful%20APIs%20using%20Flask%20and%20Python.html)上找到。
## 推荐阅读
[用 Flask、Flask-RESTPlus / Flask-RESTX 和 Swagger UI 构建 Python API](https://medium.com/p/7461b3a9a2c8)
## 让我们连接
领英:[https://www.linkedin.com/in/jimit105/](https://www.linkedin.com/in/jimit105/)
GitHub:[https://github.com/jimit105](https://github.com/jimit105)
推特:[https://twitter.com/jimit105](https://twitter.com/jimit105)
# 为数据科学项目创建可重用的代码
> 原文：<https://towardsdatascience.com/creating-reusable-code-for-data-science-projects-740391ec7bad?source=collection_archive---------26----------------------->
## 编写自己的库的路线图
作为有抱负的数据科学家，我们花费大量时间编写代码，但是从更大的角度来看，数据科学的核心不是编写代码，而是理解我们的数据并从中提取价值。编码部分只是完成这个目标的手段。显然，我们无法避免编写代码，这样做可能对过程有害，但是我们可以减少我们花在编写代码上的时间，这使我们能够将大部分时间花在制定策略以实现我们的主要目标上。
对我们大多数人来说，这个过程如下。我们倾向于编写小代码块，然后根据需要进行复制、粘贴和修改。这对于小任务来说是没问题的，但是对于大块的代码多次这样做可能会使你的笔记本杂乱无章，很难找到东西，并且更多的时候，在尝试不同的策略时会破坏笔记本。在多个不同的地方修改代码也是非常烦人的，再次浪费你的时间。
我们中的一些人定义了一些函数来解决这个问题，但是问题是每当我们创建新的函数时，我们必须不断地将这些函数复制到不同的笔记本中。此外，当我们在以后的项目中工作时，可能很难检索我们在早期项目中使用的函数，这使我们花费时间试图在我们所有的项目中找到它，然后只是放弃并再次写出一个自定义函数。
图片来自:[https://imgur.com/gallery/0BpqqmW](https://imgur.com/gallery/0BpqqmW)
# 级别 1 —输入。py 文件
这个问题的最佳解决方案是将您的代码定义在外部 py 文件的函数中。这样，您可以在任何需要的时候在任何笔记本中重用您的代码。你所需要做的就是导入那些函数，就像导入你最喜欢的库并使用它们一样。这使您的代码保持有组织，并专注于任务。不会有大块大块的代码分散你对主要任务的注意力，在你的笔记本上找东西会变得容易得多。当你移动到一个不同的项目时，你所需要做的就是将这些 py 文件复制到项目文件夹中，这样你就万事俱备了。(在文章的最后，我讨论了一些方法来帮助你避免这样做。)
现在，我们如何创建这些文件？让我们用一个简单的例子一步步来。
让我们创建一个名为 custom_mean()的函数，它接收一个列表，将所有值加 2，再乘以 2，然后返回平均值。当然，这对于任何真正有用的函数来说都太简单了，但是您可以根据自己的需要将它变成任何样子。
现在，打开一个文本编辑器，将函数复制到其中。在页面顶部，添加您已经用于自己的函数的任何导入函数。在我的例子中，我使用了 Numpy 的 mean()，所以我的文件看起来像这样。
import numpy as npdef my_mean(list):
list = np.array(list)
return np.mean((list + 2) * 2)
接下来，只需用您希望用一个*调用您的导入的名称来保存您的文件。py* 分机。我就把我的*叫做 custom_means.py* 。
现在把它导入你的笔记本，你可以这样做。
from custom_means import my_mean
现在让我们试着利用它。
list = [34, 54, 46, 57, 86, 34]
print(‘My Mean:’, my_mean(list))# Output
My Mean: 107.66666666666667
这很容易。现在你如何把这带到下一个层次？
# 第 2 级—目录
随着项目的进展，您可以在文件中添加更多的函数。您还可以为 Scikit-Learn 之类的库创建定制类。你可以在这里学习如何做那个。
最终，当你写了更多的函数和类时，你会了解到，根据它们完成的任务的种类，在不同的文件中组织它们是很重要的，就像我们使用的流行的库一样。例如，您可能希望您的科学计算功能是 numpy 的一部分，而您的绘图实用程序是 matplotlib 的一部分。所以，对你的函数做同样的事情是明智的。
随着文件数量的增加，将所有文件放在一个或多个文件夹中会变得更加容易。现在，如果一个文件不在你正在工作的同一个文件夹中，你如何从这个文件中导入函数呢？答案是你一直在做却没有意识到的事情。我可以用上一个例子中的同一个文件来举例说明。让我们将它添加到一个名为 *utilities* 的文件夹中。
在我们的工作目录中，我们现在有了包含 *custom_means.py* 文件的 *utilities* 文件夹。为了导入相同的函数，我们现在可以输入。
from utilities.custom_means import my_mean
看起来很熟悉，不是吗？例如，当我们从 Scikit-learn 中导入 RandomForestRegressor 时，
from sklearn.tree import RandomForestRegressor
我们实际做的是访问 sklearn 安装中的树目录，然后从 *_classes.py* 文件中导入类。你可以在这里看一看。
请注意，这与我们上面的例子略有不同，但想法是一样的。这些差异是由于他们使用额外的方法来加速使用 Cython 的代码，这需要额外的文件。由于项目的规模，他们有一种更复杂但有效的方法来管理他们的文件。 *__init__。py* 文件自动告诉 python 每个类的代码应该查看哪个文件，而不需要我们明确地告诉它
from sklearn.tree._classes import RandomForestRegressor#Note: This produces an error, because of the way the code is #organized
你现在不必担心，但是把它作为将来某一天要达到的目标是很好的。
在文件夹中组织我们所有的自定义实用程序会非常有帮助。现在我们只需将文件夹复制到任何新项目的工作目录中，我们就完成了。随着时间的推移，您的工具在调整后变得更加完善，能够调用这些实用程序而不必每次都复制您的实用程序文件夹最终可能会很有用。
# 级别 3-Python 路径
现在让我们进入下一个阶段。除非你有一套不需要经常编辑的有用工具，否则不值得这么做。如果您的函数和类还没有完成，您可能应该继续将文件夹复制到新的项目目录中。但是现在让我们假设我们有一些完善的工具。
为了理解这一点，我们需要理解当您导入一个包时会发生什么。Python 首先检查你的工作目录，然后检查‘path’变量，看看你要导入的函数是否在那里。path 变量实际上是计算机中安装各种软件包的位置列表。您可以通过运行以下命令来查看您的路径变量
import sys
sys.path
我电脑上的输出如下。我使用的是 Linux 系统，它会根据你使用的操作系统而有所不同，但是不管你用的是什么电脑，这个过程都是一样的。
[‘/home/anupjsebastian/anaconda3/envs/my-env/lib/python37.zip’,
‘/home/anupjsebastian/anaconda3/envs/my-env/lib/python3.7’,
‘/home/anupjsebastian/anaconda3/envs/my-env/lib/python3.7/lib-dynload’,
‘’,
‘/home/anupjsebastian/anaconda3/envs/my-env/lib/python3.7/site-packages’,
‘/home/anupjsebastian/anaconda3/envs/my-env/lib/python3.7/site-packages/IPython/extensions’,
‘/home/anupjsebastian/.ipython’]
如果您将 utilities 文件夹放在这些目录中的一个目录中，您将能够像访问您使用的所有其他包一样访问您的函数和类。我个人更希望是在
/home/anupjsebastian/anaconda3/envs/my-env/lib/python3.7
因为的其余部分主要是这个目录的子目录。
还有一种方法是将其放置在自定义位置。对于 Linux 和 Mac，在终端中键入以下内容
For Linux
nano ~/.bashrc# For Mac
nano ~/.bash_profile
并将下面一行添加到文件的末尾。
For Linux
export PYTHONPATH=/Your/path/here# For Mac
export PYTHONPATH=“/Your/path/here”
对于 Windows，你可以在这里找到[。更多关于 Python 路径的细节可以在](https://www.architectryan.com/2018/08/31/how-to-change-environment-variables-on-windows-10/)[这里](https://bic-berkeley.github.io/psych-214-fall-2016/using_pythonpath.html)找到。
## 奖金水平
以简单优雅的方式做同样的事情的一个酷方法是使用 GitHub。你可以把你的代码放在 GitHub 仓库里，然后把它安装到你的电脑上。这确保了软件包会自动与 pip 安装的其他库一起放置在正确的位置。pip 安装 GitHub 存储库的代码如下。
pip install git+(weblink here)# For example pip install git+https://github.com/scikit-learn/scikit-learn
我在上面展示了一个关于如何从其 [GitHub](https://github.com/scikit-learn/scikit-learn) 库安装 scikit learn 的例子，但是我不建议你为 Scikit-learn 或任何专业软件包这样做，除非你知道你在做什么。但是，您可以为自己的包做这件事。
这就是全部内容——这是一个完整的路线图，说明如何通过编写可重用的代码和自动化您最终为每个新项目所做的大量繁琐过程，来逐渐减少您花费在编码上的时间并专注于手头的任务。
总之，首先在代码中编写更多的函数来完成重复的任务，然后将它们转移到单独的 py 文件中，这样它们就可以被很好地组织起来，并且很容易被利用。然后使用目录来管理您的 pip 文件。继续调整和开发您的可重用代码，在您认为它们已经可以在黄金时间使用之后，将它们放在一个您可以从任何地方轻松访问它们的位置。或许，你可以在 GitHub 上分享你的代码，并回馈给开源社区。
这篇文章包含了大量的信息，一次可能要吸收很多。我希望无论你处于学习的哪个阶段，这篇文章都对你有用。即使你不打算做此时此刻提到的每一件事，在你需要的时候回到这里也是有用的。
祝你好运！
# 金融和经济数据的数据管道
> 原文：<https://towardsdatascience.com/creating-smart-etl-data-pipelines-in-python-for-financial-and-economic-data-ad852e8daca7?source=collection_archive---------31----------------------->
## 从 Quandl API 中提取数据，转换并加载到 SQLite DB 中。用 python 动态编程，用 Matplotlib 和 Seaborn 动态加载图表。
构建 ETL 的输出日志
***前置要求*** : Python 3、SQLite、SQLiteStudio(可选)、Quandl 账号
***所需 Python 模块*** : Quandl、pandas、sqlite3、matplotlib、seaborn、numpy
这是一个相当直接的解决方案，只是说明了如何使用 python 和各种可用的模块来实现简单的 ETL。我已经包含了一些代码片段，来说明我是如何把它们拼凑在一起的。
这当然可以通过云平台来实现。然而，对于这个项目，我选择在本地保存和管理我的数据。这也是为云计算资源付费的一种替代方式。即使您可以设法获得免费的计算和存储，也肯定是在有限的时间或有限的能力范围内。在本地运行这将有助于我保持项目的活力。
我将从圣路易斯联邦储备银行的美联储经济数据中寻找一系列数据进行经济研究。包括来自耶鲁大学经济系的数据。所有这些都源自 Quandl 的 API。
我的方法项目的结构如下:通过创建用户定义的函数来处理每个阶段；提取，转换，加载，数据库查询和图表。
第一步是[下载](https://www.sqlite.org/index.html)并在本地机器上安装 SQLite。下一步是创建一个数据库。或者，您可以从命令行使用 SQLite 命令或通过 [SQLiteStudio](https://sqlitestudio.pl/) 创建一个数据库。这将作为数据库管理。
SQLStudioLite
## 构建基块—项目导入
import pandas as pd
import sqlite, quandl
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.dates
from datetime import date, datetime, timezone
import matplotlib.ticker as ticker
import matplotlib.patches as patches
from matplotlib import gridspec
import matplotlib.font_manager as fm
import matplotlib.gridspec as gridspec
import matplotlib.patches as mpatches
## 提取
创建连接到 API 的函数需要两个部分。首先，需要一个 Quandl 帐户。创建一个帐户后，就像收集一个 API 令牌一样简单，可以用它来访问数据。
def data_extract(pair: str, freq: str, key: str):
quandl.ApiConfig.api_key = key
return quandl.get(pair, collapse=freq)
## 改变
转换函数相当简单，因为在这个例子中，数据不需要提炼或清理。从 Quandl 的 API 返回的对象被转换成熊猫数据帧。出于健康原因，在将数据加载到 SQLite 数据库之前，列标题空格被替换为下划线。
def data_tranform(data) -> pd.DataFrame:
df = pd.DataFrame(data)
df.rename(columns=lambda x: x.replace(" ", “_”), inplace=True)
return df
## 负荷
这个阶段非常简单，模块 pandas 提供了到 SQL 数据库的基本连接。commit()函数将提交对数据库的更改。
def data_load(table_name: str, data: pd.DataFrame, conn):
data.to_sql(name=table_name.replace(“/”, “_”), con=conn, if_exists=‘replace’) # update, append new values only, not full overwrite
conn.commit()
## 将 ETL 部分放在一个函数中
这个函数背后的想法是允许迭代不同表的列表，以提取、转换和加载到数据库中。
def ETL(table_collection: list):
global count
list_len=len(table_collection)
for pair in table_collection:
data = data_extract(pair, freq=‘daily’, key=quandl_api_key)
print(“…Loading data…**”)
print(pair+" extracted from API")data = data_tranform(data)
print(pair+" transformed")data_load(table_name=pair, data=data, conn=conn)
print(pair+" loaded into SQL db")count += 1
output = dict(count=count, list_len=list_len)
print(“{count}…of…{list_len}”.format(**output))
## 主要功能
使用 main 函数执行 ETL，然后从 Quandl 中选择仪器进行分析。在主函数中，我通常只包含我想要执行的行为方面，例如，加载/刷新数据库中的数据集。或者在下一节中选择从我的数据库中提取数据到一个数据框架中，并通过一个函数绘制出来。
df = sql_to_df(conn, ‘select MULTPL_SHILLER_PE_RATIO_MONTH.Date, MULTPL_SHILLER_PE_RATIO_MONTH.Value as SP500_PE_RATIO, NASDAQOMX_XQC.Index_Value as NASDAQ_Price from MULTPL_SHILLER_PE_RATIO_MONTH INNER JOIN NASDAQOMX_XQC ON MULTPL_SHILLER_PE_RATIO_MONTH.Date=NASDAQOMX_XQC.“Trade Date”’)
为了说明我迄今为止的解决方案，您必须知道或在 Quandl 的数据库中搜索指标的名称。此外，熟悉数据代表的内容和实际数据本身也将是一个优势。
## 制图
这是这个过程中更细致的部分，这里花了更多的时间来整合视觉效果。我已经创建了接受多个时间序列数据的函数。不管怎样，这是一个临时的解决办法；制作 Matplotlib 时间序列图，以及 Seaborn 进行相关分析。它被设计得看起来简单而专业，而且不太科学。下图显示了加载到数据库中的几个数据集的最终输出。
图 2—S&P500 市盈率和 Nasdaq100 的自定义时间序列图
上面的图 2 是对数据库的查询结果，该查询返回了一个新的数据帧，该数据帧可以传递给图表功能。用 NASDAQ100 得出 S&P500 的市盈率的时间序列图
图 3-M2V v 贸易加权美元
图 3 只是另一个将数据拉入数据库，然后用与上述相同的函数再次绘制的例子。
货币流通速度 M2 *-货币流通速度是在给定的时间内，一个货币单位被用来购买国内生产的商品和服务的频率。换句话说，就是单位时间内，一美元被用来购买商品和服务的次数。**【1】*
贸易加权美元指数代表许多对美元的外汇对，以表明美元的强势。
**注**:标注与轴标签重叠，需要修改。
图 M2V 和贸易加权美元之间的相关性
图 4 加载了与图 3 中相同的数据摘录。这里的想法是突出特征之间的任何相关性。应用 2 个不同样本大小的滚动相关性，右边的图显示了相关性随时间的变化。左边是 seaborn 图，显示了总的观察周期相关性。
## 然后
该项目的未来迭代计划。
* 我想过集成 python [Dash 库](https://plotly.com/dash/)的可能性。为这些图表创建基于 web 的仪表板。
* 我的目标是寻找更有用的抽象数据源，这些数据源可能与具体的金融资产直接或间接相关。我会在字里行间寻找来创建我自己的数据集。
* 将预测模型作为函数加载。(可能是 ARIMA 或 fbProphet)
* 项目自动化和内务管理正在进行中。
如果有任何问题或建议，请随时联系我。
*【1】。圣路易斯美联储银行，M2 货币存量速度[M2V]，检索自圣路易斯美联储银行弗雷德；*[](https://fred.stlouisfed.org/series/M2V,)**2020 年 6 月 30 日。**
# 使用 mkDocs 在 10 分钟内创建软件文档
> 原文：<https://towardsdatascience.com/creating-software-documentation-in-under-10-minutes-with-mkdocs-b11f52f0fb10?source=collection_archive---------46----------------------->
## 为什么以及如何为您的项目快速创建专业文档
当你从事任何项目时，文档都是非常有用的，甚至是至关重要的。幸运的是，mkDocs 创建了一个很好的、高效的方法来创建看起来既专业又易于使用的文档。
# 首先，什么是文档，为什么它很重要？
软件文档是关于你的代码和项目的书写，解释它是关于什么和它是如何工作的。这对开源项目、团队项目，甚至个人项目都很重要。
通过记录您的代码，您可以:
1. 让你的代码对你合作的其他人来说是可解释的(当你回头看你的代码时，对你自己来说也是)。
2. 跟踪软件的所有方面。
3. 使以后的调试更容易。
4. 可以有一个通用的空间来保存你的文件。
用 mkDocs 创建文档的框架最多只需要 10 分钟。现在花 10 分钟编写文档，值得花无数分钟努力调试代码，并在以后向同事和自己解释代码。
# mkDocs 设置
要使用 mkDocs，您需要 pip。你可以在这里找到如何安装 pip [的说明。如果您有 pip，请确保更新它，然后安装 mkDocs。当你安装 mkDocs 的时候，你也应该选择一个主题(查看选项](https://pip.pypa.io/en/stable/installing/)[这里](https://github.com/mkdocs/mkdocs/wiki/MkDocs-Themes))。在这个例子中，我们选择了材质主题。
pip install --upgrade pip
pip install mkdocs
pip install mkdocs-material
现在您已经准备好创建您的文档了。运行下面的命令，但是将 PROJECT_NAME 替换为您的项目名称。
mkdocs new PROJECT_NAME
cd PROJECT_NAME
您应该会看到一个名为`mkdocs.yaml`的文件和一个名为`docs`的文件夹。该文件夹将有一个单一的降价文件，`index.md`。
要运行文档，使用`mkdocs serve`，然后在浏览器中转至`[http://127.0.0.1:8000/](http://127.0.0.1:8000/)`。
运行 mkdocs serve 后，在 https://127.0.0.1:8000/会看到类似这样的东西。
打开`mkdocs.yaml`，您应该会看到以下内容:
site_name: My Docs
我们将编辑这个文档。首先，我们将创建一个通用的大纲；随意填写占位符变量。主题是我们过去安装的 pip。
site_name: NAME
nav:
- Home: index.md
- Page2: page2.md
- Section1:
- Subpage1: subpage1.md
- Subpage2: subpage2.md
theme:
name: THEME_DOWNLOADED
例如，假设我想为一个游乐园模拟创建文档。这是我将在`mkdocs.yaml`中写的内容:
site_name: Amusement Park Simulation
nav:
- Home: index.md
- About: about.md
- Games:
- “Ping Pong”: games/ping.md
- Balloon: games/balloon.md
- Rides:
- “Scary Coaster”: rides/scary.md
- “Drop of Doom”: rides/drop.md
theme:
name: material
注意，`mkdocs.yaml`中提到的所有文件夹和目录都在`docs`目录中。这是我的结构看起来的样子:
PROJECT_NAME/
docs/
index.md
about.md
games/
ping.md
balloon.md
rides/
scary.md
drop.md
mkdocs.yaml
Add the rest of your code here
如果你不想要几个文档，也可以用 markdown 头语法创建类别。如果你不熟悉。md 文件，你可以在这里了解更多的语法[。](https://www.markdownguide.org/basic-syntax/)
只有大纲的最终版本。我的下一步是用内容填充我的减价文件！
# 最后，部署。
最后，我们将在 GitHub 页面上托管我们的文档。只需运行`mkdocs gh-deploy`。它应该在您的存储库中创建一个新的分支，在`USERNAME.github.io/REPOSITORY_NAME`托管您的站点。
就是这样！您已经成功地为项目创建了文档。如果您想了解如何进一步定制您的文档或其他 mkDocs 选项，请访问他们的网站[此处](https://www.mkdocs.org/)。点击这里查看我的 GitHub 资源库中的教程[，点击这里](https://github.com/GenericP3rson/mkDocs)查看已部署的网站[。](https://genericp3rson.github.io/mkDocs/)
# 调试需要注意的事项
* 确保您选择使用制表符或空格。mkDocs 不允许两者的组合。
* 如果名称中有空格，请添加引号。
* 如果你得到一个 404 错误，这意味着你可能丢失了一个文件。检查`docs`以确保你的文件存在。
* 请注意，组织不支持 GitHub 页面。
# 使用无监督学习创建 Spotify 播放列表
> 原文：<https://towardsdatascience.com/creating-spotify-playlists-with-unsupervised-learning-9391835fbc7f?source=collection_archive---------36----------------------->
## 聚类在创建推荐中的实际应用
由[马尔特·温根](https://unsplash.com/@maltewingen?utm_source=medium&utm_medium=referral)在 [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral) 上拍摄的照片
Spotify 提供的播放列表并不短缺。现在在我的主页上，我看到的播放列表有:Rap Caviar，Hot Country，Pump Pop，以及其他各种音乐类型。
虽然许多用户喜欢浏览歌曲，并根据自己的口味创建自己的播放列表，但我想做一些不同的事情。我使用了一种无监督学习技术来寻找密切相关的音乐，并创建自己的播放列表。
该算法不需要对每首歌曲进行分类，也不需要每个播放列表都完美无缺。相反，它只需要产生我可以审查和创造性命名的建议，节省了我研究不同流派歌曲的时间。
# 数据集
Spotify 的 Web API 允许开发者访问他们庞大的音乐库。因此，从 1921 年到 2020 年的近 170，000 首歌曲的数据被收集并在 [Kaggle](https://www.kaggle.com/yamaerenay/spotify-dataset-19212020-160k-tracks) 上发布。这些数据涵盖了几乎所有的音乐类型，包括晦涩和流行的歌曲。
数据集中的每首歌曲都被几个关键的音乐指标所分解。 [Spotify](https://developer.spotify.com/documentation/web-api/reference/tracks/get-audio-features/) 自己定义了每一项措施，但简单来说:
* 声学:一首歌的声学程度。带有柔和钢琴和小提琴的歌曲得分较高，而带有扭曲吉他和尖叫的歌曲得分较低。
* 可舞性:一首歌对舞池的适合程度，基于速度、节奏稳定性、节拍强度和整体规律性。有感染力的流行歌曲得分较高，而呆板的古典音乐得分较低。
* 能量:一首歌给人的感觉有多强烈和活跃。硬摇滚和朋克得分较高，而钢琴民谣得分较低。
* 工具性:一首曲目的工具性如何。纯器乐歌曲得分较高，而口语和说唱歌曲得分较低。
* 活跃度:这首歌在观众面前录制的可能性有多大。
* 响度:音轨的音量。
* 声音:一首歌的声音有多大。没有音乐和只有口语的歌曲得分较高，而器乐歌曲得分较低。
* 效价:一首歌听起来有多积极或快乐。欢快的歌曲得分较高，而悲伤或愤怒的歌曲得分较低。
* 节奏:一首歌曲的速度，单位为每分钟节拍数(bpm)。
# 清理数据
虽然深入分析很有吸引力，但是需要进行一些数据清理。所有工作都将在 python 中完成。
import pandas as pd
import numpy as np# read the data
df = pd.read_csv(“Spotify_Data.csv”)
在做任何事情之前，熊猫和 NumPy 库被导入。最后一行只是将之前保存的 CSV 文件转换为 DataFrame。
from re import search# Writes function to tell if string is degraded beyond recognition
def is_data_corrupt(string):
# Search for a name with letters and numbers. If no numbers or letters are found, returns None object
found = search("[0-9A-Za-z]", string)
# Return 1 if corrupt, 0 if not
return 1 if found == None else 0
在数据收集过程中的某个时刻，大量文本被破坏。因此，一些艺术家和歌曲名称被列为不可理解的文本字符串，例如“‘a’和‘e’”。尽管我很想知道‘a’的最热门歌曲，但我无法搜索和编译这些值。
为了过滤损坏，编写了一个名为 is_data_corrupt()的函数，它使用正则表达式来检查字符串是否包含数字、大写字母或小写字母。它会将任何只包含标点符号或特殊字符的字符串标记为损坏，这应该可以找到有问题的条目，同时保留合法的歌曲和艺术家姓名。
Create a helper column for artist corruption
df[“artists_corrupt”] = df[“artists”].apply(lambda x: is_data_corrupt(x))# Create helper column for name corruption
df[“name_corrupt”] = df[“name”].apply(lambda x: is_data_corrupt(x))# Filter out corrupt artists names
df = df[df[“artists_corrupt”] == 0]# Filter out corrupt song names
df = df[df[“name_corrupt”] == 0]
在将函数 is_data_corrupt()应用于 artists 和 name 列以创建两个新的辅助列之后，任何标记为损坏的文本字符串都会被过滤掉。
值得注意的是，这只标记了被降级到无法识别的文本。一些文本仍然包含部分降级。比如著名作曲家弗雷德里克·肖邦就被改成了“弗雷德里克·肖邦”。更广泛的数据清理纠正了这些条目，但是这些方法超出了本文的范围。
Gets rid of rows with unspecified artists
df = df[df[“artists”] != “[‘Unspecified’]”]
很大一部分艺术家没有被列出，而是被赋予占位符值“未指定”。由于未列出的艺术家给查找歌曲带来了不必要的困难(毕竟歌曲名称不是唯一的)，这些也将被过滤掉。
Filter out speeches, comedy routines, poems, etc.
df = df[df[“speechiness”] < 0.66]
最后，纯声乐曲目，如演讲，喜剧特辑，诗歌朗诵，提出了一个问题。因为分类是基于声音特征的，所以它们会聚集在一起。
不幸的是，由罗斯福总统的炉边谈话和有线电视员拉里的例行公事组成的播放列表是一种非常糟糕但有趣的收听体验。声道必须根据内容进行分类，这超出了本数据的范围。
因此，我简单地过滤了所有“speechiness”值超过 0.66 的音轨。虽然我可能过滤了一些歌曲，但移除这些曲目的回报是值得的。
# 数据探索
即使在运行无监督模型之前，在数据中寻找有趣的模式也能为如何继续提供见解。所有的可视化都是用 seaborn 完成的。
sns.heatmap(df.corr(), cmap = “coolwarm”)
数据中所有相关系数的热图。图由作者制作。
上面的热图显示了不同的数字数据之间的紧密联系。深红色显示强烈的积极关系，深蓝色显示强烈的消极关系。一些有趣的相关性值得一提。
不出所料，流行度和年份之间存在着密切的关系，这意味着越近的音乐越受欢迎。在喜欢流媒体的年轻观众和积极推广新音乐的 Spotify 之间，这种洞察力证实了领域知识。
另一个不足为奇的趋势是，响度与能量相关。直觉上，高能歌曲辐射强度，往往伴随响度而来。
声学有一些有趣的负面关系。它与能量和响度的反比关系抓住了大多数人对民谣的印象。然而，原声歌曲往往不太受欢迎，其数量也随着时间的推移而减少。
虽然令人惊讶的是钢琴和原声吉他曲目顽固地保留在公众意识中，但这一见解更多地说明了失真吉他和合成器在音乐制作中的受欢迎程度。在它们出现之前，每首歌都被认为是原声的，它们的市场份额被现代音乐夺走了。
# 光学聚类
为了创建播放列表，我使用了 Scikit-Learn 的 OPTICS clustering 实现，它本质上是通过数据找到高密度的区域，并将它们分配到一个簇中。低密度区域的观察是不分配的，所以不是每首歌曲都会出现在播放列表中。
df_features = df.filter([
“accousticness”,
“danceability”,
“energy”,
“instramentalness”,
“loudness”,
“mode”,
“tempo”,
“popularity”,
“valence”
])
在运行算法之前，我提取了想要分析的列。大多数功能都是纯粹基于音乐的，除了流行，流行是为了帮助像艺术家一样的群体在一起。
请注意，光学聚类使用基于欧几里得距离来确定密度，没有添加太多列，因为高维数据会扭曲基于距离的度量。
from sklearn.preprocessing import StandardScaler# initialize scaler
scaler = StandardScaler()# Scaled features
scaler.fit(df_features)
df_scaled_features = scaler.transform(df_features)
接下来，数据被转换为标准比例。虽然其余的功能已经在 0 和 1 之间标准化，但速度和响度使用不同的标度，这在计算距离时会扭曲结果。使用标准定标器，一切都达到相同的比例。
Initialize and run OPTICS
ops_cluster = OPTICS(min_samples = 10)
ops_cluster.fit(df_scaled_features)# Add labels to dataframe
df_sample[“clusters”] = ops_cluster.labels_
最后，在数据集上运行光学。请注意参数 min_samples，它表示创建一个聚类所需的最小观察次数。在这种情况下，它规定了制作播放列表所需的最少歌曲数量。
将 min_samples 设置得太小会创建许多只有几首歌曲的播放列表，但将其设置得太高会创建几个有很多歌曲的播放列表。选择 10 个是为了达到合理的平衡。
还要注意，数据集仍然相当大，因此运行算法需要时间。在我的情况下，我的计算机在返回结果之前工作了几个小时。
# 结果
如前所述，我想要一个系统来推荐播放列表，我可以手动检查，以节省自己搜索不同流派艺术家的时间。不是每首歌都需要分类，播放列表也不需要完美。
虽然还有很大的改进空间，但光学满足了我的期望。按照一个总的主题将歌曲分组，我发现了一组有趣的播放列表，涵盖了我一无所知的流派。
不幸的是，大多数歌曲没有聚集在一起，这意味着该算法失去了大量的音乐多样性。我尝试了不同的聚类方法(DBSCAN 和 K-Means)，但是我得到了相似的结果。很简单，数据不是很密集，所以基于密度的方法从一开始就是有缺陷的。
然而，播放列表本身通常会提出有趣的建议。虽然偶尔会提出一些奇怪的组合(例如，流行的电子舞曲艺术家蠢朋克发现自己也是古典作曲家)，但他们仍然很中肯。因此，通过这个项目，我发现了新的艺术家，也学到了很多关于音乐的知识。
这就是无监督学习的神奇之处。
# 播放列表
虽然我可以写不同的指标来评估播放列表的有效性，但我认为没有比互联网的严峻考验更好的评判标准了。我稍微编辑了一些我最喜欢的，并鼓励任何人听并做出自己的判断。请注意，有些歌曲可能包含明确的歌词。
* [重击节拍](https://open.spotify.com/playlist/0Yk0yqeagGmuFRiRKFLZ1t?si=jwYiWkQ_TrWGepiQO9hkSg):嘻哈音乐中紧凑的歌词和砰砰的基线
* [合成糖](https://open.spotify.com/playlist/1WTPROLNJn5rHoMDyL1jSn?si=r0pd8kKrQP2-WjDDm-oRSQ):一碗五颜六色的流行歌曲
* [快节奏硬摇滚](https://open.spotify.com/playlist/34dMKv4kMMwKPxKNtE9thK?si=xCZc5mooTX24GYj8IfkIyA):当朋克和硬摇滚打在你的脸上
* 弦乐组:小提琴和大提琴之夜
# 结论
虽然还有改进的空间，但 OPTICS 集群满足了要求，并创建了一组多样化的有趣播放列表。考虑到基于密度的方法的问题，我会用层次聚类、余弦相似性或其他方法来克服数据的稀疏性。
然而，更广泛地说，这展示了无监督学习在发现甚至人类都难以量化的模式方面的力量。虽然因为需要审查而不是完全自动化，但使用这种算法展示了人类和机器如何合作创造更令人愉快的最终产品。
# 在 python 中创建利益相关者友好的点状图
> 原文：<https://towardsdatascience.com/creating-stakeholder-friendly-dot-plots-e9e9daae9124?source=collection_archive---------45----------------------->
图片来源:[quantlabs.net](https://quantlabs.net/blog/2017/04/intro-to-scientific-python-with-math-behind-it-matplotlib/)
一个美丽的数据可视化胜过千言万语。受我去年看到的[大卫·斯皮格哈尔特](https://en.wikipedia.org/wiki/David_Spiegelhalter)的演讲的启发，我创建了一个易于使用的 python 包来创建视觉上令人惊叹的点状图。
***编者按:*** [*走向数据科学*](http://towardsdatascience.com/) *是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击* [*这里*](https://www.who.int/emergencies/diseases/novel-coronavirus-2019/situation-reports) *。*
# 可视化新冠肺炎症状
由于全球疫情目前影响着世界的每一个部分，我认为使用新冠肺炎相关数据集是及时的，也是有益的。Kaggle 有这样一个数据集，名为“[新型冠状病毒 2019 数据集](https://www.kaggle.com/sudalairajkumar/novel-corona-virus-2019-dataset)”，其中有许多关于冠状病毒患者的不同信息，包括他们表现出的症状。
你可能听说过很多冠状病毒的主要症状是发烧和干咳，但在这个数据集中它们有多普遍呢？下面是我试图用一种非常容易理解的方式来形象化症状频率。
## 解释点状图
可视化是一个 10×10 的点网格，每个点都有颜色，代表 100 个人中的一个。整整一排代表十分之一的人。与条形图相比，这种可视化人群的方法的好处在于，你不需要担心百分比，也不需要担心非技术型观众一提到它就会走神。我们可以说 10 个人中有 1 个，或者 100 个人中有 1 个，这样更直观。
右手边的标签(由于选择了点的布局)有助于传递顶级信息，因为一行代表十分之一的人。例如，可以清楚地看到*发烧*标签横跨 5 行，表明 10 个人中有 5 个人的唯一症状是发烧。更简单的方法是将发烧和咳嗽这两行加在一起，得出 10 个人中有 7 个人发烧，而不必将 47%和 26%的真实百分比加在一起。
## 顶级带回家
1. 十分之八的人患有 T4，要么是咳嗽，要么是发烧
2. 十分之二的人既不咳嗽也不发烧
3. 1/10 的人会咳嗽**但** **不会发烧**
4. 十分之七的人会发烧
5. 100 个人中有 26 个人既咳嗽又发烧
# 自己生成一个图很简单
我在 matplotlib 中创建了这个可视化，并在这个 [GitHub repo](https://github.com/mattcrooksphd/Medium-Dot-Plot) 中将代码包装成一个易于使用的 python 包。在这篇文章中，我将介绍如何生成图的基础知识，但是有一个 jupyter 笔记本会介绍更多的细节。还有从完整的 [Kaggle 数据集](https://www.kaggle.com/sudalairajkumar/novel-corona-virus-2019-dataset)中提取的特定数据集，用于上述可视化。
## 导入包
我们可以使用下面的代码行导入这个包。注意，如果代码不在您的工作目录中，您将需要使用相对路径。
## 基本情节
我们可视化所需的数据集以字典的形式提供。字典的关键字是每个类的标签，值是该类的人数。百分比是自动计算的。
这个包还需要一个类标签列表，这样它就知道绘制类的顺序。这是以列表的形式提供的，第一项在图的底部，最后一项在顶部。
该包的最基本实现只需要以下内容
这产生了下面的图
## 选择颜色
您可以通过将颜色选择字典传递给关键字参数`color_dict`来指定您自己的颜色。这些可以被命名为颜色或 rgb 颜色。
## 添加标签
默认情况下，标签是关闭的。这允许您在布局上工作，而不必担心如果布局不适合包可能会抛出的一些错误。我将在后面讨论这些错误。为了打开标签，我们可以进入`ignore_labels=False.`
这里使用的标签与`class_labels`中使用的标签和`colour_dict`中的按键相同。
## 标题和题注
同样，标题和题注可以通过将它们的文本作为两个额外的关键字参数传入来添加。
## 修改布局
为了给图形加标签，你需要在右栏下面每种颜色至少有一个点。尽管在本例中这是默认情况，但并不总是这样。您可以做一些修改来改变每一行的顺序。这些被传递到关键字参数`*reversed_rows.*`
> D **默认:** `*reversed_rows=None*` *(或左空)*为所有行从左到右
>
> **Snake:** 传入`reversed_rows='snake'`将每行的顺序与第一行左右、第二行左右、第三行左右等互换
>
> **反转行:**传入一个列表，比如`*reversed_rows=[1, 3]*` *，只交换第二行和第四行从右向左运行，其他行从左向右运行。并不是说这些是从 0 开始的 python 索引。*
交换行也是有用的，这样标签就代表了每一个类中 10 个人的数量。
尝试传入`*reversed_rows=[7]*`来获取错误
## 保存数字
该类具有属性`f`和`axis`，它们是标准的`matplotlib`图形和轴句柄。您可以使用这些选项随意修改图，但尤其可以使用以下选项保存图形
## 更改布局
不是每个数据集都最适合 10x10 的网格。关键字参数`gridsize`可以用来告诉代码使用多少个点。它应该是一个元组，第一个元素是水平点数，第二个元素是垂直点数。例如:
在较小的图中，您可能会得到以下错误
这意味着当把每一类的百分比四舍五入到最接近的点数时，你得到的点数太多了。例如，如果我们尝试生成一个 2 x 5 的图，每个点将值 10%，我们的类将四舍五入到最接近的 10%:
*发热* : 47%到 50%
*发烧和咳嗽* : 26%到 30%
*咳嗽* : 10%到 10%
*都不是* : 17%到 20%
这些加起来是 110%，这是误差的基础。如果需要，您可以通过自己提供所需的类百分比来克服这个问题。
## 最佳实践布局
为了获得最大的视觉效果，有一些关于安排点的布局的最佳实践。以下是我在制作上图时所做的选择:
1. 按大小降序排列类别
2. 重点关注发烧和咳嗽症状，其中*和*这两个类别都不代表不属于其他三个类别的人。该类别出现在顶部，并以中性灰色显示
3. 将*发烧和咳嗽*放在*发烧*和*咳嗽*之间，很像维恩图
4. 将标签上的*发烧*四舍五入至 5/10，将*发烧和咳嗽*四舍五入至 2/10。我希望 100 个人中总共有 73 个人用 7 行来表示。47 比 26 比 30 更接近 50。
# 结论
我已经提供了一个演练和代码，让你用 python 制作出你自己的漂亮的点状图。这里又是 GitHub 回购的链接。尽情享受吧！
# 从头开始创建 Streamlit 仪表板。
> 原文：<https://towardsdatascience.com/creating-streamlit-dashboard-from-scratch-59316a74fa1?source=collection_archive---------22----------------------->
## Streamlit 是一个很棒的工具，可以轻松构建视觉上吸引人的仪表板。
马库斯·温克勒在 [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral) 上的照片
构建仪表板从来都不容易，创建仪表板需要 bootstrap、HTML、CSS 等知识和大量的时间。但是通过使用 streamlit，我们只需几行代码就可以创建高度交互式和视觉上吸引人的仪表板。让我们开始构建我们的控制面板，但首先让我们了解一下 streamlit。
# 什么是 Streamlit？
**Streamlit** 是一个开源的 Python 库，其速度快得惊人，可以轻松地为机器学习和数据科学构建漂亮的定制网络应用。这是一个非常棒的工具，只需要一些 python 知识就可以创建高度交互式的仪表板。我们将从安装 streamlit 开始，看看它是如何工作的。
**安装 Streamlit**
pip install streamlit
查看 streamlit 上的一些演示。为此，我们需要在命令提示符下运行下面给出的命令。此命令允许您浏览预加载的 Streamlit 演示。你一定要看看这些，因为它们真的很有趣。
streamlit hello
现在让我们创建自己的仪表板。在这里，我将创建一个仪表板，用于分析 2019 年 5 月至 2020 年 5 月印度股市的 5 大赢家和输家。为了构建它，让我们导入一些我们需要的库。请注意，您需要为 streamlit 创建一个脚本并运行它，因此我们将使用任何代码编辑器，如 Atom 或 Notepad++并使用。py 格式。
import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
from plotly.subplots import make_subplots
import plotly.graph_objects as go
import matplotlib.pyplot as plt
所有这些库将用于股票数据的数学计算和可视化。现在让我们使用 pandas 导入我们的数据，这里我为赢家和输家创建了单独的文件，所以我们将导入这两个文件。
DATA_URL = (“C:/Users/Divya/gainers.csv”)
DATA_UR= (“C:/Users/Divya/losers.csv”)
df=pd.read_csv(DATA_URL)
df1=pd.read_csv(DATA_UR)
导入数据文件后，让我们开始设置仪表板的标题。为此，我们将使用 **st.title** 作为主标题，使用 **st.sidebar.title** 作为侧栏标题，如下所示。
st.title(“Share Price analysis for May 2019 to May 2020:”)
st.sidebar.title(“Share Price analysis for May 2019 to May 2020:”)
st.markdown(“This application is a Share Price dashboard for Top 5 Gainers and Losers:”)
st.sidebar.markdown(“This application is a Share Price dashboard for Top 5 Gainers and Losers:”)
您可以保存此文件并在 streamlit 中运行它来查看更改。您将看到带有您提到的标题的仪表板。我将我的文件存储为 share_new.py，因此我将通过键入下面给出的命令来运行。
streamlit run share_new.py
这是您的仪表板最初的外观。
streamlit 最好的一点是它非常快，也就是说，你可以保存脚本中的更改，应用程序会立即反映这些更改，你不需要一次又一次地刷新应用程序。
在这个仪表板中，我们将为数据集中的所有股票创建蜡烛图。此外，我们将绘制这些股票的移动平均线。首先创建收益者的标题，并创建一个选择框来选择要分析的股票。
st.sidebar.title(“Gainers”)
select = st.sidebar.selectbox(‘Share’, [‘Adani Green Energy’, ‘GMM Pfaudler’, ‘AGC Networks’, ‘Alkyl Amines Chem’, ‘IOL Chem & Pharma’], key=‘1’)
一旦保存文件，更改将会反映在您的应用程序中。
在这里，您可以看到选择框显示了标题增益。
现在，我们将编写代码来创建一个复选框，以启用或禁用蜡烛图的可视化，并为所有股票创建一个蜡烛图。下面给出的代码将创建“阿达尼绿色能源”的蜡烛图，还将计算和显示该份额的移动平均线。
if not st.sidebar.checkbox(“Hide”, True, key=‘1’):
st.title(“Gainers”)
if select == ‘Adani Green Energy’:
for i in [‘AdaLow’, ‘AdaHigh’, ‘AdaClose’, ‘AdaOpen’]:
df[i] = df[i].astype(‘float64’)
avg_20 = df.AdaClose.rolling(window=20, min_periods=1).mean()
avg_50 = df.AdaClose.rolling(window=50, min_periods=1).mean()
avg_200 = df.AdaClose.rolling(window=200, min_periods=1).mean()
set1 = { ‘x’: df.AdaDate, ‘open’: df.AdaOpen, ‘close’: df.AdaClose, ‘high’: df.AdaHigh, ‘low’: df.AdaLow, ‘type’: ‘candlestick’,}
set2 = { ‘x’: df.AdaDate, ‘y’: avg_20, ‘type’: ‘scatter’, ‘mode’: ‘lines’, ‘line’: { ‘width’: 1, ‘color’: ‘blue’ },‘name’: ‘MA 20 periods’}
set3 = { ‘x’: df.AdaDate, ‘y’: avg_50, ‘type’: ‘scatter’, ‘mode’: ‘lines’, ‘line’: { ‘width’: 1, ‘color’: ‘yellow’ },‘name’: ‘MA 50 periods’}
set4 = { ‘x’: df.AdaDate, ‘y’: avg_200, ‘type’: ‘scatter’, ‘mode’: ‘lines’, ‘line’: { ‘width’: 1, ‘color’: ‘black’ },‘name’: ‘MA 200 periods’}
data = [set1, set2, set3, set4]
fig = go.Figure(data=data)
st.plotly_chart(fig)
类似地，我们可以为数据集中列出的所有份额创建烛台图表，但是重复上面提到的代码，最终的仪表板将显示数据集中提到的所有份额。
显示所有功能和共享的最终仪表板。
视频显示了最终创建的仪表板，烛台图表是使用 Plotly 创建的，因此它们是交互式的，移动平均线可以相应地启用或禁用。这个仪表板在不到两个小时的时间内就创建好了，具有高度的交互性和视觉吸引力。
这只是 streamlit 所能做的一个例子。您可以探索更多信息，了解 streamlit 为创建网络应用和仪表盘提供的无限功能。如果您在创建自己的仪表板时遇到任何困难，请回信并与我分享您的经验。
[](/creating-dataset-using-faker-and-use-it-for-pandas-profiling-6fe26e1b9557) [## 使用 Faker 创建数据集并将其用于熊猫概况分析
### 创建您自己的数据并对其执行操作。
towardsdatascience.com](/creating-dataset-using-faker-and-use-it-for-pandas-profiling-6fe26e1b9557)
# 在你走之前
***感谢*** *的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的* [***LinkedIn 个人资料***](http://www.linkedin.com/in/himanshusharmads) *。也可以在我的*[***Github***](https://github.com/hmix13/streamlit_candlestick)*中查看我在这里使用过的代码和数据集。另外，请随意浏览* [***我的简介***](https://medium.com/@hmix13) *并阅读我写的与数据科学相关的不同文章。*
# 为深度学习创建合成 CT 数据
> 原文：<https://towardsdatascience.com/creating-synthetic-ct-data-for-deep-learning-2dca1e43c4f0?source=collection_archive---------61----------------------->
## 当数据太少而无法训练 GAN 时，如何生成逼真的体积图像
# TL；速度三角形定位法(dead reckoning)
我们描述了一种从一小组样本中创建合成体积医学图像的方法。我们的方法基于随机部分变形，因此无需深度学习(不需要 GANs)。创建的卷看起来非常真实，并且适合于创建用于深度学习的训练数据集。在我们的 [Covid19 胸部 CT 挑战赛](https://www.covid19challenge.eu/)中，我们应用这种方法为开发者创建了一个合成玩具数据集。
**数据隐私是公众质疑医学影像数据的一个重要方面。**患者相关信息的匿名化需要两个主要步骤。第一步是从可识别信息中剥离患者数据。这包括患者的姓名、出生日期、出生地或现居住地。在第二步中，可能需要对图像数据本身进行匿名化。一个突出的例子是从脑 CT/MRI 图像重建人脸的可能性。作为进一步的匿名化步骤，这通常需要去面。
在我们的[**covid 19 挑战赛**](https://www.covid19challenge.eu/) 中，我们处理胸部的放射影像数据。幸运的是，这个数据不像脑成像数据那样敏感，因为病人的头和脸都被裁剪了。剩余的图像数据本身不包含与人相关的信息，因为胸部成像是现实的抽象表示。如果没有公共数据库，去识别信息只有主要护理人员知道。
在我们的[covid 19 挑战](https://www.covid19challenge.eu/)中，我们采取了**多种措施来确保完全匿名化**。我们从合作的放射部门和私人诊所接收预先匿名的数据。在数据传输之后，任何剩余的元数据都将被剥离到最少的一组挑战相关信息。其余的临床元数据不是特定于患者的(年龄、性别、PCR 结果、入院后天数、结果类别、临床事件)。事实上，它可能与许多潜在的医院和患者有关。接下来，受过医学教育的训练团队将图像分割成肺叶和 Covid19 相关的病变。根据预定义的分段协议，这种注释集中发生，并具有后续的质量保证步骤，以确保数据的一致和高质量标记。
由此产生的数据是高度匿名的，但仍然没有向公众公布。由于道德和法律要求，**参赛团队在挑战的任何时候都不能直接访问未经更改的成像数据**。相反，开发者可以通过 [Eisen.ai](https://eisen.ai/) 接口[提交](https://medium.com/analytics-vidhya/deep-learning-on-covid-19-data-with-eisen-7ad5b5657ff9)处理作业，在非公开的图像数据上训练和验证方法。
然而，**作为数据科学家，我们更希望至少有一个最小的本地代表性数据集**可用。这有助于对数据外观和可变性、潜在挑战以及算法的快速原型化有所了解。为了弥合这一差距，我们需要设计一种方法来发布用于本地开发的图像子集，这种子集具有高质量和代表性，并且仍然不包含患者的未更改图像数据。实现这一点的一个非常有前途的研究方向是生成神经网络模型，特别是生成[对抗网络(GANs)](https://arxiv.org/abs/1809.07294) 。然而，这种方法需要来自图像域的非常大的数据集，以便学习数万或数十万幅图像的真实外观。这在医学成像中通常很难实现。此外，这些方法仅在 2D 显示出产生逼真的效果。图像尺寸大约为 512-1024 像素边长。此外，基于 GAN 的方法需要[巨大的计算资源](https://www.fastcompany.com/90244767/see-the-shockingly-realistic-images-made-by-googles-new-ai)用于训练。由于很少带注释的图像、高分辨率的 3D 体积(512 x512 x300–500 体素)以及准备阶段有限的计算能力，**基于 GAN 的方法在我们的挑战中不可行**。
相反，我们依赖于一种更传统的技术: [**测地线插值**](https://github.com/stnava/Morpheus) **经由可变形图像配准**。这个过程的一个更常见的表达是**“图像变形”**。基本想法很简单:我们使用一个强大的、现成的非线性图像配准工具包，用于医学图像，名为 [ANTs](http://stnava.github.io/ANTs/) 。将 ant 应用于我们的胸部 CT 图像，我们将“移动”体积配准到“固定”体积。一旦变形被计算出来，我们不会将“移动的”体积一直变形到“固定的”体积，而是只变形一定的百分比。变形因此没有完成，而只是*部分*。这个概念的一个例子如图 1 所示。
图一。通过部分图像变形生成合成胸部 CT 的概念。(*作者图片*)
由于对可变形配准进行了仔细的参数化，因此**生成的体积看起来非常逼真**，无论是在健康组织还是在病变区域。连同原始图像数据一起，所有黄金标准分割标签和患者元数据被变形(标签)和/或内插(年龄、入院后天数等。).**生成的体积具有完全合成的形态:合成体积中的解剖形状和尺寸与“固定”和“移动”体积非线性不同**。因此，胸部的生物标记(如果存在的话，例如椎骨形状或脊柱弯曲)也是非线性改变的和合成的。示例图像如图 2 所示。
图二。通过四个胸部 CT 体积的中心冠状切片。你可能猜到哪个卷是真实的，哪个是合成的。(*底部解决方案)(*作者图片*)
从这个玩具数据集中恢复原始卷应该是不可能的。为了确保这一点，**我们应用了三种形式的随机化**:首先，玩具数据集是从全部数据的*随机选择的子集*中生成的。第二，考虑到成对配准的全连通有向图，我们仅沿着边缘的随机子集执行可变形配准*。第三，从源到目标的部分变形也被设置为一个*随机百分比*。请记住，源数据本身在任何时候都是不可公开访问的，**开发者数据集中的合成卷不再与任何原始源数据相关联**。*
当然，这种方法有一定的局限性。其中包括:
* **拓扑误配准:**微分同胚配准不能处理数据中的拓扑变化。例子可以是支气管路径的不同分支，或者具有不规则形状和位置的 Covid19 损伤。拓扑差异导致配准错误，这表现为合成体积中的拖尾或压缩伪影。
* **插值伪影:**由于合成体积中的体素强度是通过插值计算的，因此与原始数据相比，图像看起来有些模糊。
* **样本外内插:**用零值内插被共同配准到目标体积的体素网格之外的区域中的运动体积的体素。我们用空气等效体素强度来修补这些体素。
无论如何，所有这些伪像通常发生在神经网络训练的增强期间。考虑到参与团队的本地开发的便利性，这些工件是一个可以接受的折衷。
用合成数据创建一个可公开访问的玩具数据集是挑战准备阶段的一个重要里程碑。我们希望有了这些数据，开发者可以更容易地在本地构建他们方法的原型，同时了解 Eisen 接口。一个[艾森代码初学者工具包](https://gist.github.com/faustomilletari/1c1d9d671641e36e63199d26bb232d58)刚刚推出。试一试，并关注我们的团队成员 [Fausto Milletari](https://medium.com/u/a5d79f344c19?source=post_page-----2dca1e43c4f0--------------------------------) 的更新。
(*)解答:没有一个体积是真实的，所有四个体积都是合成的。事实上，所有四卷都是从相同的源主题合成的，共同注册到四个随机选择的目标主题，证明了可以实现的形态学可变性。
下面，图 3 示出了源和目标体以及合成体的另一个更详细的例子(在两者之间正好 50%的变形/变形)。
图 3。随机选择的源、目标和 50%变形合成体积的详细比较。(*图片作者*)
# 用 Matplotlib 创建 Synthwave
> 原文：<https://towardsdatascience.com/creating-synthwave-with-matplotlib-ea7c9be59760?source=collection_archive---------14----------------------->
## 正确使用 Matplotlib 创建动画复古 Synthwave 视觉效果
synthwave 是一种非常独特的音乐类型，灵感来自 20 世纪 80 年代的怀旧，是技术人员的共同最爱。我喜欢它，我发现它的艺术风格非常迷人。
在 YouTube[上快速搜索该类型可以让任何人欣赏该类型带来的复古科幻美学。](https://www.youtube.com/watch?v=wOMwO5T3yT4)
现在，我想创造这样的视觉效果。然而，我日复一日地与数据打交道，我不是动画师、平面设计师或艺术家。
然后我想，*“我确实创造了视觉效果，我在 Matplotlib 中可视化数据。在 Matplotlib 中创建 Synthwave 视觉效果不是很有趣吗？”*。
所以我们在这里。
# 远景
首先要创建的是透视样式的垂直网格线。为此，我们设置一个原点`(0, 5)`。这些线必须从这里延伸到框架底部的`y = -50`处。每一行唯一要更改的值是 Numpy linspace 函数中的最终 x 值。我们用一个从`x = -500`到`x = 500`的 for 循环来实现，步长为`50`。
现在，没有地平线，没有地平线你不可能有一条无尽的 synthwave 路。所以我们简单地用`np.ma.masked_where(y > 0, y)`屏蔽掉`0`以上的所有 y 值。
最后，让我们来确定配色方案。我们将使用黑色背景，并使用多条半透明线来创建发光效果[1]。
# 移动
这个有点棘手。为了创建看起来向我们走来的水平线，我们使用 Matplotlib 动画来不断更新水平线的 y 位置。我们创建了这些运动线的十个实例，每个实例都分配了一个修改后的指数函数，如下所示:
分别用于第 0、4 和 8 行的 y 位置函数。
对于每一帧，每条运动线被分配相同的 x 值。但是，当我们沿着 x 轴移动每个函数时，我们返回一个不同的 y 值。如果我们画出所有十条运动线，记住这个逻辑，我们可以通过时间(x 轴)可视化线的 y 位置(y 轴):
通过使用指数函数，我们将运动线和透视线合二为一。当运动线离我们越来越近时，通过增加向下的速度来创造三维运动的幻觉。这类似于动画中的缓和[2]。
将此应用于水平网格线的 y 位置，会给我们一种在霓虹紫色 tron 般的世界中不断前进的错觉。
幸运的是，对于我们的输出文件的大小，我们的运动线运动每十分之一的总时间重复一次。这意味着我们可以在动画函数`animation.FuncAnimation(fig, animate, frames=int(frames/10))`中将动画帧减少 10 帧。
# 迈阿密太阳报
如果在我们无尽的霓虹紫色之路的尽头没有超大的复古日落，这就不是 Synthwave 了。
当涉及到渐变时，Matplotlib 可能有点困难。我们使用`imshow()`来创建一个图像，在我们的例子中是`plasma`渐变。然后，我们遮蔽该图像，使其超出中心点的指定半径，得到:
很好，但还没到那一步。迈阿密的太阳需要辉光和几条水平线。对于光晕，我们放置了几个半径稍大、alpha 值较低的圆。线条是在使用简单的黑线图后添加的。
将迈阿密的太阳和霓虹网格放在一起，我们得到:
# 目的地
无尽霓虹紫路需要目的。一个遥远但不太遥远的目的地。想想——一个神秘的都市天堂。
幸运的是，Matplotlib 附带了一个专门构建的复古 skyline 生成器，名为`plt.bar()`！我们简单地使用`np.random.uniform(0, 10)`，通过一些计算来定义酒吧宽度，我们有自己美丽的，随机生成的天际线。
由于我们无法在无云的迈阿密夜空下看到我们的地平线轮廓，我们添加了一个从我们无尽的地平线发出的深紫色光芒。我们将再次使用`plt.imshow()`。我们需要的是初始的`gnuplot`渐变，所以让我们使用前 28 个颜色映射并用`[ListedColormap](https://matplotlib.org/3.1.0/tutorials/colors/colormap-manipulation.html)`创建一个新的渐变。
来自 Matplotlib 的 [**gnuplot** 颜色图参考](https://matplotlib.org/3.1.0/gallery/color/colormap_reference.html)
我还擅自减少了我们的霓虹网格线宽，我认为现在看起来好多了。让我们看看我们的无尽之路是什么样子的:
看起来不错，但现在我们过大的迈阿密日落可能太大了，挤压了我们对远处地平线的完美看法。另外，80 年代迈阿密的天空总是布满星星，而我一颗也没看到。
因此，让我们调整太阳的大小，用`plt.scatter()`和`np.random.uniform()`分别代表`x`和`y`来添加星星。我们还根据 y 位置(越靠近地平线越暗)和一点随机性来改变每颗星星的`alpha`参数。
# 收尾
现在有一些小的调整，我认为将完成可视化。
首先，恒星出现在太阳前面。我们简单地调整恒星的`ax.scatter()`函数中的`zorder`参数。将它们移动到太阳下面——默认为`zorder = 1`【3】。
在这一点上，它看起来很好，但星星只是普通的白点，不是很有说服力。所以我们添加了一些随机生成的闪烁。
最后，就像地平线后面放射出的光芒一样。我们添加另一个紫黑色渐变。这一次沿着我们无尽的路。
就是它，Matplotlib 中的 Synthwave！
虽然这没有明显的用例，但我强烈推荐尝试创建类似的东西，因为在这个过程中你会学到很多东西。而且，说实话，很好玩！
我希望你和我一样喜欢阅读这篇文章。
如果您有任何问题或建议，请随时通过 [Twitter](https://twitter.com/jamescalam) 或在下面的评论中联系我们。
谢谢，
# 参考
[1]: **创建照明线**—[https://public wiki . delta RES . nl/display/~ baart _ f/2012/01/03/创建+照明+线](https://publicwiki.deltares.nl/display/~baart_f/2012/01/03/Creating+illuminated+lines)
[2]: **放松的基础**—[https://developers . Google . com/web/fundamentals/design-and-UX/animations/The-basics-of-easing](https://developers.google.com/web/fundamentals/design-and-ux/animations/the-basics-of-easing)
【3】:**佐德演示**——[https://matplotlib.org/3.1.1/gallery/misc/zorder_demo.html](https://matplotlib.org/3.1.1/gallery/misc/zorder_demo.html)
**项目回购**—[https://github.com/jamescalam/python_synthwave](https://github.com/jamescalam/python_synthwave)
**合成波**——[https://www.youtube.com/watch?v=wOMwO5T3yT4](https://www.youtube.com/watch?v=wOMwO5T3yT4)
# 用 Python 制作生态学经典“风筝图”
> 原文：<https://towardsdatascience.com/creating-the-ecology-classic-kite-diagram-in-python-46989e1310ad?source=collection_archive---------41----------------------->
## 使用 Python 的 matplotlib 库
手绘风筝图(图片由作者提供)
风筝图是生态学和生物学研究中的经典用法，也是英国 A 级生物学课程教学大纲的一部分。尽管如此，在标准软件可视化软件包中创建这些图表的选项很少，大多数似乎仍然是手绘的。这篇短文将解释如何用 Python 3 和 matplotlib 库来自动化这个过程。
**那么什么是风筝图呢？**风筝图提供了沿横断面进行的不同观察的图形总结。横断面是横跨栖息地的一部分或整个栖息地的一条线。这通常是用绳子、绳索等手工完成的。各种物种的数量可以沿着样带定期计算。各种物种的分布会受到各种不同因素的影响，包括捕食者以及其他环境因素，如热、光和湿度。这些被称为非生物(非生命)因素。也可以使用样方收集数据，这涉及到使用沿样带移动的正方形(例如 1m2)框架。然后可以在每一点计算方块中的物种数量。
风筝图是一种观察不同物种在一个样带中数量变化的方式。
这使得研究人员可以在栖息地的不同地方，比如海边，看到某些物种的相对丰富度。例如，可能有许多种类的草、植物和昆虫分布在海岸的不同位置。
沿着海岸可以发现各种各样的物种
这些图表通常是手工制作的，在标准的可视化软件包中似乎很少有对它们的支持。我们在 Excel 中找到了一个例子(Luke，2019)和一个使用 R 产生的例子(Hood，2014)，但没有使用 Python 的例子。随着 Python 越来越多地被用于分析数据，我们认为应该尝试使用 Python 实现一个简单的风筝图。这是使用 Python 3 的交互式 Jupyter 笔记本完成的。我们在这里向其他领域的人展示这个过程，这些人可能会发现自动化这样的图是有用的。我们特意尝试保持初学者的基本实现。
例如，我们将使用 Python 的“pandas”库来表示我们将使用的数据集。该数据集被输入 Excel 并保存为逗号分隔值(CSV)文件。我们还将使用 numpy 库从数据集中提取列，并对它们应用操作。按照 Python 的惯例，我们可以使用简写引用来引用这些库(pd 代表 pandas，np 代表 numpy)。
import pandas as pd
import numpy as np
**导入数据**
接下来，我们使用 pandas read_csv()函数将数据集加载到 pandas dataframe 对象中，并提供 csv 文件的路径。我们将这些数据存储在一个名为 kite_data 的变量中，然后可以在笔记本(或其他 Python 环境)中查看该变量。
kite_data = pd.read_csv(“./biology/kitedata.csv”)
kite_data
数据集(作者提供的图片)
数据的第一列应该代表距离。这将用于水平轴。其余的列表示物种的频率，或者有时表示某些植物的覆盖百分比，它们将在 y 轴上以一定的间隔绘制。
**创建风筝绘图功能**
下一步是创建一个函数来生成风筝图。这建立在 matplotlib 库的基础上，matplotlib 库被广泛用于生成各种各样的可视化。你可以在 https://matplotlib.org/3.1.1/gallery/index.html[的画廊里看到一些例子。我们将导入该库，并将其称为 plt。我们还需要使用多边形函数在图上画出风筝的形状。](https://matplotlib.org/3.1.1/gallery/index.html)
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
导入库后，我们可以创建函数。数据框的第一列应该是区域分割的距离或其他度量(如样方)。这里我们使用 iloc 特性，它代表整数位置。这是一种通过数字(0 到列数)而不是通过列名来引用列的方式。我们可以提取并存储第一列距离，供以后在 x 轴上使用。我们还创建了一个空列表来存储起始点。这用于在 y 轴上定位单个风筝形状。我们还获取列名，并将其存储在 y_values 变量中，以便稍后在 y 轴上绘制物种名称。最后，我们获得数据帧中的列数，并将其存储在名为 num_cols 的变量中，这样我们就知道需要向图表中添加多少物种。
def kite_diagram(df, axis_labs):
“”“Function to draw a kite diagram.”“”
plt.axes()
start_points = []
v1 = np.array(df.iloc[:, [0]])
y_values = df.columns
y_values = np.delete(y_values, 0)
num_cols = len(df.columns) - 1
现在我们需要从数据集(不包括距离列)中获取最大值，这样我们就可以在图上以足够的垂直间距放置风筝形状。我们希望将不同的风筝图隔开最大的距离，这样它们就不会相互重叠，因为这会使它们不可读。为此，我们获取除第一列(距离)之外的所有列，然后使用 max()函数来确定列中的最大值。
df_cols = df.iloc[:, 1:len(df.columns)]
max_val = max(df_cols.max())
因为 Python 使用从 0 开始的索引系统，所以我们选择 1 作为列数(列的长度),以排除存储在位置 0 的第一个(距离)列。接下来，我们将数据中的最大值存储在名为 max_val 的变量中。除了第一列之外的每一列都应该代表不同的物种，所以我们需要循环遍历每一列，并为每一个物种制作一个风筝形状。由于 Python 从 0 开始索引，我们将从 1 开始跳过距离列。
for j in range(1, num_cols + 1):
p1 = []
p2 = []
p1 和 p2 列表将存储每个物种的多边形(风筝形状)的坐标点。有两个列表，因为该图本质上显示了基线上方和下方相同形状的镜像，如下图所示。这是通过将每个值减半并投影一对点来实现的，其中一个值在水平基线之上，另一个值在水平基线之下，这样每对点之间的距离代表原始总值。例如，值 8 将比基线高 4 个单位，比基线低 4 个单位。
风筝多边形形状在基线的上方和下方(图片由作者提供)
为了对此进行编码，我们需要获得每个数据值的中点。这通过将每个值除以 2 来实现。我们可以用 numpy 轻松做到这一点。我们可以将每个列的值转换成 numpy 数组。然后，我们可以将数组中的每个值除以 2。
v2 = np.array(df.iloc[:, [j]]) / 2
应该注意的是，使用标准 Python 列表，操作不能应用于整个列表。下图说明了这一点，显示了当我们试图将列表除以 2 时出现的错误。
尝试将 Python 列表除以 2 以将列表中的每个值减半时出错(图片由作者提供)
但是，如果我们使用 numpy 数组，该操作将应用于列表中的所有值:
使用 numpy 数组，我们可以成功地对数组的所有成员执行操作(图片由作者提供)
接下来，我们要确定这是否是我们添加到图表中的第一个风筝，如果是，我们要将垂直基线定位在数据集中找到的最大值的一半处，这样我们就有足够的空间在基线上方和下方绘制所需的图案。对于所有其他随后的风筝模式，我们将把数据集中的最大值添加到先前的起点，以使它们在垂直方向上均匀分布。
if j == 1:
start_point = max_val / 2
else:
start_point = start_point + max_val
我们还将每个物种基线的起点存储在一个列表中，以便以后标记该地块。此外，我们将多边形的第一个点(线的上方和下方)设置为零，这样当我们开始绘制形状时就不会有任何间隙。我们在整个形状的两端都这样做，以防止不必要的间隙。
start_points.append(start_point)
p1.append([0, start_point])
p2.append([0, start_point])
**生成风筝形状的点**
对于所有随后的点，我们将循环遍历所有的值，并对线以上和线以下的值加上或减去我们计算并存储在 v2 变量中的一半值。上面和下面的图案应该是相同的，所以我们将上面的线点和水平距离(v1)存储在一个名为 p1(多边形 1)的变量中，将线下的点和水平距离(v1)存储在一个名为 p2(多边形 2)的变量中。最后，在检查完所有的值后，我们给两个多边形添加一对额外的值，使线回到起点。同样，这避免了形状末端的图案中的任何间隙。
for i in range(0, len(v1)):
p1.append([v1[i], start_point + v2[i]])
p2.append([v1[i], start_point - v2[i]])p1.append([v1[i], start_point])
p2.append([v1[i], start_point])
我们最终得到的是一系列坐标点。每对中的第一个是 x 轴上的位置(水平位置),在我们的示例中从 0 到 20。p1 中的第二个数字是图上基线(垂直 y 轴)上方的位置，而在 p2 中是基线下方的位置:
p1 = [[0，0]，[2，0]，[4，0]，[6，0]，[8，1.5]，[10，2]，[12，4]，[14，4]，[16，3.5]，[18，2.5]，[20，2]，[20，0]]
p2 = [[0，0]，[2，0]，[4，0]，[6，0]，[8，-1.5]，[10，-2]，[12，-4]，[14，-4]，[16，-3.5]，[18，-2.5]，[20，-2]，[20，0]]
**将形状添加到绘图中**
我们现在可以使用 Polygon()函数使用这些点来创建多边形并将其添加到绘图中。
c = np.random.rand(3,)
l1 = plt.Polygon(p1, closed=None, fill=True, edgecolor=c, alpha=0.4, color=c)
l2 = plt.Polygon(p2, closed=None, fill=True, edgecolor=c, alpha=0.4, color=c)
我们为每个风筝形状分配一个随机颜色，并将该值存储在一个名为 c 的变量中。我们使用 matplotlibs 的 Polygon()函数创建了两个多边形，并将它们存储在变量 l1 和 l2 中。第一个参数是数据点(p1 或 p2)，接下来我们设置一些其他可选参数，我们希望形状被填充，所以我们设置为真，我们为边缘添加颜色。在这种情况下，我们使用与整个形状相同的颜色。可以调整 alpha 值来增加形状的透明度。如果形状中有任何重叠，或者只是为了使颜色不那么强烈，这将有所帮助。最后，我们添加填充颜色。
现在可以使用 add_line()函数将多边形添加到绘图中。函数的作用是:获取或者创建一个当前的坐标轴。
plt.gca().add_line(l1)
plt.gca().add_line(l2)
**收尾工作**
最后，在循环所有列并添加了物种风筝形状后，我们可以在主循环后为整个情节添加额外的功能。
plt.yticks(start_points, y_values)
plt.xlabel(axis_labs[0])
plt.ylabel(axis_labs[1])
plt.axis(‘scaled’)
plt.show();
回想一下，我们将列名(物种)添加到一个名为 y_values 的变量中，我们可以使用 yticks()函数将这些名称添加到我们存储的 start_points 位置，以便将物种名称与基线对齐。接下来的两行添加了 x 轴和 y 轴的标签，我们将它们传递给一个列表中的函数。“轴缩放”选项改变绘图容器的尺寸，而不是数据限制。另一个可以使用的选项是“相等”,这样 x，y 点具有相等的增量。最后，show()函数将呈现绘图。
最后，为了绘制图表，我们需要调用在列表中提供数据集和 x/y 轴标签的函数。
kite_diagram(kite_data, [‘Distance’, ‘Species’]);
此输出可以在手绘版本旁边并排看到:
左，手绘的图；右，用 kite_diagram()函数生成的图(图片由作者提供)
完整功能的代码如下所示:
def kite_diagram(df, axis_labs):
“”“Function to draw a kite diagram.”“”
plt.axes()
start_points = []
v1 = np.array(df.iloc[:, [0]])
y_values = df.columns
y_values = np.delete(y_values, 0)
num_cols = len(df.columns) - 1
df_cols = df.iloc[:, 1:len(df.columns)]
max_val = max(df_cols.max())
for j in range(1, num_cols + 1):
p1 = []
p2 = [] v2 = np.array(df.iloc[:, [j]]) / 2
if j == 1:
start_point = max_val / 2
else:
start_point = start_point + max_val start_points.append(start_point)
p1.append([0, start_point])
p2.append([0, start_point])
for i in range(0, len(v1)):
p1.append([v1[i], start_point + v2[i]])
p2.append([v1[i], start_point - v2[i]]) p1.append([v1[i], start_point])
p2.append([v1[i], start_point]) c = np.random.rand(3,)
l1 = plt.Polygon(p1, closed=None, fill=True, edgecolor=c, alpha=0.4, color=c)
l2 = plt.Polygon(p2, closed=None, fill=True, edgecolor=c, alpha=0.4, color=c) plt.gca().add_line(l1)
plt.gca().add_line(l2) plt.yticks(start_points, y_values)
plt.xlabel(axis_labs[0])
plt.ylabel(axis_labs[1])
plt.axis('scaled')
plt.show();
Python 通过 matplotlib、seaborn、ggplot 等库提供了各种各样的可视化。这些库也可以很容易地扩展，以添加额外的可视化类型，如这里所见。这为多个科学领域的科学可视化提供了丰富的基础。支持数据科学的现代语言，如 R 和 Python，鼓励了这种可视化的发展，提供了使这种绘图相对容易实现的工具。
**参考文献**
[1] Luke，K (2019)最佳 Excel 教程:风筝图[在线]。访问时间:2020 年 7 月 7 日【https://best-excel-tutorial.com/56-charts/267-kite-chart
[2] Hood，D(2014)RPubs:R 中的风筝图[在线]。访问时间:2020 年 7 月 7 日【https://rpubs.com/thoughtfulbloke/kitegraph
感谢维多利亚·戈拉斯，她为这篇文章的写作做出了贡献，并提供了图表的手绘版本。
# 在 python 中使用单词云创建排版
> 原文：<https://towardsdatascience.com/creating-typography-using-word-cloud-in-python-9652bd62fa69?source=collection_archive---------32----------------------->
***一图抵千言。***
这是我系列的第一篇博客——使用计算机视觉和深度学习来增强摄影。
> 21 世纪创造价值的最佳方式是将创造力与技术相结合——史蒂夫·乔布斯
相机最近最大的进步来自人工智能，而不是传感器和镜头。在过去的几年里，技术使得摄影技术取得了惊人的进步。人工智能正在改变我们拍摄照片的方式和编辑照片的方式。
随着“计算机视觉”成为自动驾驶汽车等其他新技术的重要组成部分，人工智能在解释和理解我们图像的内容方面将变得越来越复杂。
作为一名热情的摄影师，我总是努力将手动任务自动化，以便我可以专注于创作创意内容。在这个项目中，我将讨论如何通过几个简单的步骤，使用您自己的图像创建和定制 word cloud。
**目标:使用 python 中的 word cloud 将照片转化为排版艺术。**
> 一张图胜过千言万语。字面意思！这张图有 2200+字。*😱*
字体设计:它是一种以视觉上吸引人的方式排列文字的艺术。它旨在引发特定的情感并传达特定的信息。
在某个时间点，人们实际上是把字母和字符放在物理空间中。在这个项目中，我将展示我们如何利用 python 中的 word cloud 的力量来使这种艺术形式可扩展，并在几分钟内创建它。
**单词云:**单词云是一种用于表示文本数据的数据可视化技术，其中每个单词的大小表示其频率或重要性。词云被广泛用于分析来自社交网络网站的数据以进行情感分析。
为了在 Python 中生成单词云，需要的模块有— matplotlib、OpenCV 和 word cloud。
以下是涉及的步骤:
1.相关数据收集(网络搜集)
2.数据清理和自然语言处理(NLP)
3.从图像创建遮罩并生成单词云
1. **相关数据收集:**
在这个项目中，为了获得摄影领域最流行的单词列表，我从一个流行的摄影网站 KelbyOne 上删除了 836 个摄影课程标题(例如，高级人像编辑技术)。我使用 python 模块 Scrapy 从 70 页中删除了数据。这些课程从 2006 年开始上传。
**2。文本预处理:**
我使用 python 模块“Spacy”来执行自然语言处理(NLP)
* ***标记化***
它是将字符串拆分成其组成标记的过程。这些标记可以是单词或标点符号。
课程名称:“什么是闪光？控制你的光线”
代币:["什么"，"那个"，"闪光"，"什么？"、“控制”、“你的”、“光”]
* ***词汇化***
将 word 转换成其基本形式:
例如，像 reducing、reduces、reduced、reduction 这样的词将被转换为 reduce。
* ***文字清理技巧:***
删除不必要的空格、标点符号、特殊字符(数字、表情符号等)。)和非字母符号(如 D750)
* ***停用词***
出现频率极高且对句子没有多大意义的单词。
例如冠词(a，the 等)。)，be 动词(是，am 等。)、代词(他、她等。)
经过处理，我们在数据中总共有 3558 个单词和 1133 个唯一单词，数据中的所有单词都用于创建单词云。
在词云中，最频繁出现的词更突出(频率越高，字体越大)。
**3。从图像中创建遮罩并生成单词云**
我在 photoshop 中创建了两张图片的蒙版，并在每张蒙版中分别应用了文字云。文本填充蒙版的黑色部分。每个面具都充满了所有的 1100+独特的话。
**掩 1 字云:**
我让蒙版 1 的背景为黑色，文字为白色，以突出主体和纪念碑的拱门。
所有 3558 个单词的文本字符串(其中 1133 个单词是唯一的)在 wordcloud 函数中传递。
**代码片段:**
import cv2
from wordcloud import WordCloud
import matplotlib.pyplot as plt**#White text Black Background**
image = cv2.imread(“D:/Photography/Typography/mask1.jpg”, 1)
wordcloud = WordCloud(background_color=‘black’, mask=image, mode=“RGB”, color_func=lambda *args, **kwargs: “white”,
width=1000 , max_words=100, height=1000, random_state=1).generate(text)fig = plt.figure(figsize=(25,25))
plt.imshow(wordcloud, interpolation=‘bilinear’)
plt.tight_layout(pad=0)
plt.axis(“off”)
plt.show()
我创建了多个单词云，并保存了最好的一个。更改参数' **random_state** '的值会生成不同的输出。
您还可以通过更改参数' **max_words** '的值来自定义单词云中的单词数。
参数'**插值=双线性**'用于使图像看起来更平滑。
**掩二字云:**
我为蒙版 2 保留了白色的背景和彩色的文字，以增加排版的细节和趣味。
**代码片段:**
#Colored text white Background
image = cv2.imread(“D:/Photography/Typography/mask2.jpg”, 1)
wordcloud = WordCloud(background_color=‘white’, mask=image, mode=“RGB”, max_words=1200, width=1000 , height=1000, random_state=2).generate(text)fig = plt.figure(figsize=(25,25))
plt.imshow(wordcloud, interpolation=‘bilinear’)
plt.tight_layout(pad=0)
plt.axis(“off”)
plt.show()
我将每个单词云与掩码结合起来，得到了以下结果:
在 photoshop 中合并后的最终结果。
单词 cloud 可以以任何分辨率生成，这使得它非常适合在大尺寸上打印。我在探索如何将诗歌或故事中的词语按顺序插入，这样艺术会更有意义。在我随后的系列博客中，我将谈论艺术风格的转移，3D 图像修复，以及更多。
我在我的摄影作品中应用了这种技术，结果令人惊讶！
华泰！
世界上最小的汽车😜
📸🧕🕌正确的视角让不可能成为可能✨
史上最长镜头！一个好的摄影师知道站在哪里——安塞尔·亚当斯
感谢您的阅读！我希望你喜欢这篇文章。如果你想了解我的文章，请跟我来。
我已经分享了图片(我保留本文中使用的所有图片的权利，它们是由我拍摄的)和面具，以便您可以自己进行实验。
链接:[https://drive.google.com/open?id = 13 cf 8 vna 9 fc 0 vgeh 7h 9 zarxradgtjl 2 ou](https://drive.google.com/open?id=13cf8Vna9Fc0VgEh7H9ZarXRadgTJL2OU)
***阅读我的其他博客:***
[](/art-with-ai-turning-photographs-into-artwork-with-neural-style-transfer-8144ece44bed) [## 人工智能艺术:用神经风格转换将照片变成艺术品
### 有没有希望自己能像毕加索或梵高一样画画？
towardsdatascience.com](/art-with-ai-turning-photographs-into-artwork-with-neural-style-transfer-8144ece44bed) [](/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421) [## 使用 Spotify API 和 Python 中的 Seaborn 对音乐品味进行国别可视化分析
### 你知道哪个国家喜欢欢快的音乐，哪个国家喜欢喧闹的音乐吗？
towardsdatascience.com](/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421)
参考资料:
[https://www . ka ggle . com/aa shita/word-clouds-of-variable-shapes](https://www.kaggle.com/aashita/word-clouds-of-various-shapes)
[https://www . data camp . com/community/tutorials/word cloud-python](https://www.datacamp.com/community/tutorials/wordcloud-python)
[https://www . plural sight . com/guides/natural-language-processing-visualizing-text-data-using-word-cloud](https://www.pluralsight.com/guides/natural-language-processing-visualizing-text-data-using-word-cloud)
[https://amueller.github.io/word_cloud/generated/wordcloud.WordCloud.html](https://amueller.github.io/word_cloud/generated/wordcloud.WordCloud.html)
# 使用张量流从零开始创建 VGG
> 原文：<https://towardsdatascience.com/creating-vgg-from-scratch-using-tensorflow-a998a5640155?source=collection_archive---------12----------------------->
## 我们将看到如何使用 Tensorflow 2.0 从头开始实现 VGG16
图一。VGG 16 号建筑(来源:图片由作者创作)
LeNet-5 是最古老的卷积神经网络架构之一，由 Yann LeCun 于 1998 年设计，用于识别手写数字。它使用 5x5 过滤器，平均池，没有填充。但按照现代标准，这是一个非常小的神经网络，只有 6 万个参数。如今，我们看到的网络有一千万到几十亿个参数。下一个革命性地使用卷积网络的大型卷积神经网络是 AlexNet，它有大约 6000 万个参数。AlexNet 第一层使用 96 个内核大小为 11x11 的滤镜，步长为 4。下一层使用 3x3 滤镜，依此类推。此外，AlexNet 使用最大池和填充，这在 LeNet-5 中没有使用。AlexNet 与 LeNet-5 非常相似，但它要大得多。还有，AlexNet 用的是 ReLU 激活功能，而 LeNet-5 主要用的是 Sigmoid 激活。这些网络的共同点是，随着我们深入网络，张量的大小不断减小，而通道的数量不断增加。此外，如今在创建神经网络架构时仍在使用的另一个趋势是使用卷积层(一层或多层),然后是一些池层，最后是一些完全连接的层。
下一个大的卷积神经网络是 VGG 网络。关于 VGG，值得注意的是，作者没有使用这么多超参数，而是使用了一个更简单的网络，其中重点是使用具有小尺寸 3×3 滤波器的卷积层，步长为 1，并使用“相同”填充，并使所有 MaxPooling 层 2×2 的步长为 2。VGG 大大简化了以前制作的神经网络结构。
[https://arxiv.org/abs/1409.1556](https://arxiv.org/abs/1409.1556)VGG 纸链接
**使用 Tensorflow 的 VGG 16 架构和实现:**
图二。VGG 建筑。用红色突出显示的 VGG 16 号(来源:图片来自原始论文)
图 2 显示了所有的 VGG 架构。VGG 16 号的建筑用红色突出显示。图 1 给出了该架构的一个简单版本。
VGG 网络使用最大池和 ReLU 激活功能。所有隐藏层使用 ReLU 激活，最后一个密集层使用 Softmax 激活。MaxPooling 是在步长为 2 的 2x2 像素窗口上执行的。
VGG 16 有 5 个卷积块和 3 个全连接层。每个块由 2 个或更多卷积层和一个最大池层组成。
**算法:**
1. 导入所有必要的层
2. 为卷积块编写代码
3. 为密集层编写代码
4. 建立模型
**导入库:**
# import necessary layers
from tensorflow.keras.layers import Input, Conv2D
from tensorflow.keras.layers import MaxPool2D, Flatten, Dense
from tensorflow.keras import Model
**输入:**
# input input = Input(shape =(224,224,3))
输入是 224x224 RGB 图像，所以 3 个通道。
**Conv 第一街区:**
它有两个 Conv 层，每个层有 64 个过滤器，后面是最大池。
# 1st Conv Block
x = Conv2D (filters =64, kernel_size =3, padding =‘same’, activation=‘relu’)(input)
x = Conv2D (filters =64, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
**Conv 第二街区:**
它有两个 Conv 层，128 个过滤器，然后是最大池。
# 2nd Conv Block
x = Conv2D (filters =128, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =128, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
**Conv 第三街区:**
它有三个 Conv 层，256 个过滤器，然后是最大池。
# 3rd Conv block x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
**Conv 第 4 和第 5 区块:**
Conv 区块 4 和 5 都有 3 个 Conv 层，512 个过滤器，然后是最大池。
# 4th Conv block
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
# 5th Conv block
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
**密集层:**
有 3 个完全连接的层，前两层具有 4096 个隐藏单元和 ReLU 激活，最后一个输出层具有 1000 个隐藏单元和 Softmax 激活。
# Fully connected layers x = Flatten()(x)
x = Dense(units = 4096, activation =‘relu’)(x)
x = Dense(units = 4096, activation =‘relu’)(x)
output = Dense(units = 1000, activation =‘softmax’)(x)
**创建模型:**
# creating the model
model = Model (inputs=input, outputs =output)
model.summary()
输出:
**绘制模型:**
# plotting the model
from tensorflow.python.keras.utils.vis_utils import model_to_dot
from IPython.display import SVG
import pydot
import graphviz
SVG(model_to_dot(model, show_shapes=True, show_layer_names=True, rankdir=‘TB’,expand_nested=False, dpi=60, subgraph=False).create(prog=‘dot’,format=‘svg’))
输出片段:
# 用 TensorFlow 实现 VGG 16 的完整代码:
# import necessary layers from tensorflow.keras.layers import Input, Conv2D from tensorflow.keras.layers import MaxPool2D, Flatten, Dense from tensorflow.keras import Model***# input***
input = Input(shape =(224,224,3))# 1st Conv Block
x = Conv2D (filters =64, kernel_size =3, padding =‘same’, activation=‘relu’)(input)
x = Conv2D (filters =64, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)# 2nd Conv Block
x = Conv2D (filters =128, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =128, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)# 3rd Conv block
x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =256, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)# 4th Conv block
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)
# 5th Conv block
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = Conv2D (filters =512, kernel_size =3, padding =‘same’, activation=‘relu’)(x)
x = MaxPool2D(pool_size =2, strides =2, padding =‘same’)(x)# Fully connected layers
x = Flatten()(x)
x = Dense(units = 4096, activation =‘relu’)(x)
x = Dense(units = 4096, activation =‘relu’)(x)
output = Dense(units = 1000, activation =‘softmax’)(x)# creating the model
model = Model (inputs=input, outputs =output)
model.summary()
**结论:**
VGG 网络是一个非常简单的卷积神经网络，由于其简单性，使用 Tensorflow 很容易实现。它只有 Conv2D、MaxPooling 和 Dense 图层。VGG 16 共有 1.38 亿个可训练参数。
VGG 是 CNN 出版期间最深的模型架构，最多有 19 个重量层。它在 ImageNet 挑战中取得了最先进的性能，并表明更深的网络有利于更好的分类准确性。
**参考文献:**
1. 卡伦·西蒙扬和安德鲁·齐泽曼，用于大规模图像识别的极深度卷积网络，[arXiv:1409.1556 V6](https://arxiv.org/abs/1409.1556v6)【cs .CV]，2015。
# 创建单词嵌入:使用深度学习在 Python 中编码 Word2Vec 算法
> 原文：<https://towardsdatascience.com/creating-word-embeddings-coding-the-word2vec-algorithm-in-python-using-deep-learning-b337d0ba17a8?source=collection_archive---------1----------------------->
## 用深度学习理解单词嵌入创作背后的直觉
当我在写另一篇展示如何在文本分类目标中使用单词嵌入的文章时，我意识到我总是使用从外部来源(例如[https://nlp.stanford.edu/projects/glove/](https://nlp.stanford.edu/projects/glove/))下载的预训练单词嵌入。我开始思考如何从头开始创建单词嵌入，因此这就是这篇文章的诞生。我的主要目标是让人们通过我的代码片段阅读这篇文章，并深入理解创建单词的向量表示背后的逻辑。
完整的代码可以在这里找到:
https://github.com/Eligijus112/word-embedding-creation
单词 embeddings 的创建的简短版本可以概括为以下流程:
阅读文本 **- >** 预处理文本 **- >** 创建(X，Y)数据点 **- >** 创建一个热编码(X，Y)矩阵 **- >** 训练一个神经网络 **- >** 从输入层提取权重
在这篇文章中，我将简要解释每一步。
来自 wiki: **单词嵌入**是一组[自然语言处理](https://en.wikipedia.org/wiki/Natural_language_processing) (NLP)中的[语言建模](https://en.wikipedia.org/wiki/Language_model)和[特征学习](https://en.wikipedia.org/wiki/Feature_learning)技术的统称，其中来自词汇表的**单词或短语被映射到实数向量。**术语 word2vec 字面翻译为**字到矢量**。举个例子，
“爸爸”= [0.1548，0.4848，…，1.864]
"妈妈" = [0.8785，0.8974，…，2.794]
单词嵌入最重要的特征是语义上相似的单词之间的距离(欧几里德距离、余弦距离或其他距离)比没有语义关系的单词之间的距离要小。例如，像“妈妈”和“爸爸”这样的词应该比“妈妈”和“番茄酱”或“爸爸”和“黄油”更靠近。
使用具有一个输入层、一个隐藏层和一个输出层的神经网络来创建单词嵌入。
在 [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral) 上由 [Toa Heftiba](https://unsplash.com/@heftiba?utm_source=medium&utm_medium=referral) 拍摄的照片
要创建单词嵌入，首先需要的是文本。让我们创建一个简单的例子，用 12 句话陈述一些关于一个虚构的皇室家族的众所周知的事实:
The future king is the princeDaughter is the princessSon is the princeOnly a man can be a kingOnly a woman can be a queenThe princess will be a queenQueen and king rule the realmThe prince is a strong manThe princess is a beautiful womanThe royal family is the king and queen and their childrenPrince is only a boy nowA boy will be a man
计算机不理解国王、王子和男人在语义上比王后、公主和女儿更接近。它看到的都是编码成二进制的字符。那么我们如何让计算机理解某些单词之间的关系呢？**通过创建 X 和 Y 矩阵并使用神经网络。**
当创建用于单词嵌入的训练矩阵时，超参数之一是上下文(w) 的**窗口大小。最小值为 1，因为没有上下文，算法无法工作。让我们看第一句话，假设 w = 2。**
The future king is the prince
粗体字**称为焦点字，左边的 2 个字和右边的 2 个字(因为 w = 2)是所谓的上下文字。所以我们可以开始建立我们的数据点:**
(The, future), (The, king)
**现在，如果我们浏览整个句子，我们会得到:**
(The, future), (The, king),
(future, the), (future, king), (future, is)
(king, the), (king, future), (king, is), (king, the)
(is, future), (is, king), (is, the), (is, prince),
(the, king), (the, is), (the, prince)
(prince, is), (prince, the)
**从 6 个单词中，我们能够创建 18 个数据点。在实践中，我们对文本做了一些预处理，删除了停用词，如 **is，the，a 等。**通过扫描整个文本文档并添加数据，我们创建了初始输入，然后可以将其转换为矩阵形式。**
**文本预处理功能**
**给定字符串列表**文本**创建(X，Y)单词对的完整管道:**
**数据点的创建**
**创建的数据点的第一个条目:**
[‘future’, ‘king’],
[‘future’, ‘prince’],
[‘king’, ‘prince’],
[‘king’, ‘future’],
[‘prince’, ‘king’],
[‘prince’, ‘future’],
[‘daughter’, ‘princess’],
[‘princess’, ‘daughter’],
[‘son’, ‘prince’]
…
**在最初创建数据点之后，我们需要为词汇表中的每个唯一单词分配一个唯一的整数(通常称为 index)。这将在创建**独热编码矢量时进一步使用。****
**创建独特的单词词典**
**对文本使用上述函数后，我们得到字典:**
unique_word_dict = {
‘beautiful’: 0,
‘boy’: 1,
‘can’: 2,
‘children’: 3,
‘daughter’: 4,
‘family’: 5,
‘future’: 6,
‘king’: 7,
‘man’: 8,
‘now’: 9,
‘only’: 10,
‘prince’: 11,
‘princess’: 12,
‘queen’: 13,
‘realm’: 14,
‘royal’: 15,
‘rule’: 16,
‘son’: 17,
‘strong’: 18,
‘their’: 19,
‘woman’: 20
}
**到目前为止，我们所创建的仍然不是神经网络友好的，因为我们所拥有的数据是成对的**(焦点词，上下文词)**。为了让计算机开始计算，我们需要一种聪明的方法将这些数据点转换成由数字组成的数据点。一个聪明的方法是**一键编码**技术。**
**一键编码将一个单词转换成一个向量，该向量由 0 和一个表示字符串的坐标组成，等于 1。向量大小等于文档中唯一单词的数量。例如，让我们定义一个简单的字符串列表:**
a = [‘blue’, ‘sky’, ‘blue’, ‘car’]
**有三个独特的词:蓝色，天空和汽车。每个单词一个热表示:**
‘blue’ = [1, 0, 0]
‘car’ = [0, 1, 0]
‘sky’ = [0, 0, 1]
**因此，列表可以转换成矩阵:**
A =
[
1, 0, 0
0, 0, 1
1, 0, 0
0, 1, 0
]
**我们将用完全相同的技术创建两个矩阵，X 和 Y。将使用焦点词创建 **X 矩阵，使用上下文词创建 **Y 矩阵。******
**回想一下我们根据版税文本创建的前三个数据点:**
[‘future’, ‘king’],
[‘future’, ‘prince’],
[‘king’, ‘prince’]
**python 中的一键编码 X 矩阵(单词 f**future，future，king** )应该是:**
[array([0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0.]),
array([0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0.]),
array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0.])]
**python 中一键编码的 Y 矩阵(单词 **king，prince，prince** )应该是:**
[array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0.]),
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,
0., 0., 0., 0.]),
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,
0., 0., 0., 0.])]
**这些矩阵的最终大小将是**n×m，**其中**
****n** -创建的数据点的数量(焦点词和上下文词对)**
****m**——唯一字的数量**
**创建 X 和 Y 矩阵**
**我们现在有了从焦点单词和上下文单词对构建的 X 和 Y 矩阵。下一步是选择嵌入维度。我将选择维数等于 2，以便稍后绘制单词，并查看相似的单词是否形成簇。**
****
**神经网络体系结构**
**隐层维度就是我们的单词嵌入的大小。输出层激活功能是 **softmax。**隐藏层的激活函数是**线性的。**输入维数等于唯一字的总数(记住，我们的 X 矩阵的维数是 n×21)。每个输入节点将有两个权重将其连接到隐藏层。这些权重就是单词嵌入！在网络的训练之后，我们提取这些权重并去除所有剩余的权重。我们不一定关心输出。**
**对于网络的训练，我们将使用 keras 和 tensorflow:**
**训练和获得重量**
**在网络训练之后，我们可以获得权重并绘制结果:**
import matplotlib.pyplot as pltplt.figure(figsize=(10, 10))for word in list(unique_word_dict.keys()):
coord = embedding_dict.get(word)
plt.scatter(coord[0], coord[1])
plt.annotate(word, (coord[0], coord[1]))
****
**嵌入的可视化**
**我们可以看到，在剧情的各个角落，出现了‘男人’，‘未来’，‘王子’，‘男孩’和‘女儿’，‘女人’，‘公主’这样的字眼，形成一簇簇。所有这些都是通过 21 个独特的单词和 12 个句子实现的。**
**通常在实践中，使用预训练的单词嵌入，典型的单词嵌入维数为 100、200 或 300。我个人使用这里存储的嵌入:\[https://nlp.stanford.edu/projects/glove/](https://nlp.stanford.edu/projects/glove/)。**
# 创建您的第一个机器学习模型
> 原文：<https://towardsdatascience.com/creating-your-first-machine-learning-model-f97f47ee6749?source=collection_archive---------50----------------------->
## 向我展示如何像五岁小孩一样设置我的本地环境
韦斯·希克斯在 [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral) 上的照片
这是我题为“**创建你的第一个机器学习模型**”系列的第一篇文章我假设你已经知道了机器学习的基础知识，并且想要创建你的第一个机器学习模型。我的目标是尽可能地为你分解步骤。
如果你发现任何不清楚的条款或你不明白的东西，这意味着我没有兑现我的承诺。请注意，你可以自由评论和要求澄清。
在这篇文章中，你将学到:
* 如何为机器学习项目设置硬件？
* 使用 conda 管理机器学习依赖性的可重复过程。
* 如何在新计算机上创建相同的机器学习项目环境
* 本地硬件的限制以及何时使用云服务进行机器学习工作。
* 免费云服务，允许你免费研究、构建和训练模型。
如果你要进行一次公路旅行，在开始旅行之前，你需要做一些事情。否则，你可能会停止你的公路旅行，并可能不得不支付一些意想不到的维修费用，也许，浪费时间。同样，在您开始机器学习之旅之前，您的环境必须完全设置好。
# 配置您的硬件
机器学习工作需要大量的计算能力；你要做的第一件事是确保你的硬件足够强大，能够在本地构建东西。对于硬件要求，您应该满足以下条件:
* 中央处理器
* 英特尔酷睿 i5 或更高版本。你也可以选择 AMD 的同类产品
* 你至少有 8GB 的内存
* 建议使用 GPU (NVIDIA GeForce GTX 960 ),但这是可选的
如果您是一名开发人员，这些步骤对您来说并不陌生。你应该做的第一件事是确保你的操作系统是最新的。
作为个人电脑的拥有者，你可能对“发行版”这个概念很熟悉——为便于使用而构建、组装和配置的软件组件的集合。对于科学任务，你需要一组用于科学计算的软件。我们将在本教程中使用的发行版之一是 Anaconda。
Anaconda 只是众多发行版中的一个。对于一个刚刚进入“condas”世界的初学者来说，你可能会发现术语“anaconda”、“miniconda”和 conda 令人困惑。你并不孤单。刚开始我也是这种感觉。如果你仔细看看这些单词，你会发现“conda”这个词在这三个名字中很常见。
“康达”究竟是什么？
## **康达**
如果在 python 中使用 pip 和 virtual env，那么 conda 会更清晰。Conda 是一个独立于平台的包管理器和环境管理器。包管理器允许你管理依赖关系(你或其他人写的代码)。即安装、更新和删除软件包。另一方面，环境管理器允许您隔离软件环境。
环境隔离是机器学习项目的一个重要方面，因为不同的工具可能具有冲突的需求和包；如果没有环境隔离，将很难管理多个项目。
## **迷你康达**
出于许多原因，您可能不想安装 Anaconda。例如，如果您的任务只需要一个包，为什么要安装 199 个您不会使用的包呢？您可以将 miniconda 视为 Anaconda 的引导版本，其中包括包管理器“conda”、python 以及一些基本包。Miniconda 需要大约 400MB 的磁盘空间，当磁盘空间不足时，这可能是一个更好的选择。
## **蟒蛇**
Anaconda 是一个 python 和 R 发行版，其目标是为您提供开箱即用的数据科学包。在撰写本文时，anaconda 已经预打包了多达 200 个数据科学包。因为 anaconda 拥有大多数包，所以它在您的机器上占用了更大的磁盘空间。对于初学者，您可能想从 Anaconda 开始您的机器学习之旅——这就是为什么我们在本教程的剩余部分使用它。
那么如何安装 Anaconda 呢？
# 安装 Anaconda
要安装 anaconda，请进入 Anaconda 的[下载页面](https://www.anaconda.com/products/individual)，下载一个适合您选择的操作系统的二进制文件。
双击二进制发行版进行安装，始终单击“继续”并接受许可协议。在我的 Mac OS 上，Anaconda 的第一个屏幕是这样的:
Anaconda 安装屏幕
请花点时间放松一下；安装可能需要几分钟时间。您可以通过运行以下命令来验证 anaconda 是否已成功安装:
conda list
如果一切正常，您应该会看到软件包和预安装版本的列表，如下图所示。
Conda 列表输出
如果你得到一个错误，不要惊慌，你可能需要杀死你的终端并重新启动它。
## ***使用 conda*** 管理环境
> *科学是基于再现性和人为制造的客观性。这使得它有能力提出关于物质和能量的主张，也使得科学知识不适用于人类生活的存在性和本能，这是独特的、主观的和不可预测的*
>
> *——****保罗·卡兰尼蒂***
你曾经重新运行过你或别人十年前写的代码吗？如果你足够幸运能让它运行起来，这可能会令人沮丧。原因与软件和库确实变化很快这一事实相差不远。所使用的库、操作系统、编译器和解释器的版本可能已经改变或被更新的版本所取代。简而言之，十年前软件运行的环境和条件可能已经发生了变化。
好的代码必须是可重复运行和可复制的。确定您软件可以重新运行的一种方法是确保可再现和可复制的条件和要求是恒定的。我们通过锁定需求和隔离软件环境来做到这一点。
在安装 anaconda 时，conda 会为您创建一个名为“base”的默认环境。如果您将所有代码都放在这个基础环境中，那么隔离代码的目的就失败了。您想要做的是为每个项目创建一个新的环境，以保持您的项目是独立的。
## ***用康达*创造环境**
要创建一个具有特定软件版本的新环境，例如 python 和 scipy 的特定版本，请执行以下命令。
conda create --name example_env python=3.7 scipy=1.4.1
有时，在 YAML 文件中定义所有的环境依赖项会很方便。如果你想和别人分享你的代码，这非常方便。
您可以使用 YAML 文件 environment.yml 将环境定义为:
filename: environment.yml
name: another_example_env
dependencies:
- python=3.7
- scipy=1.4.1
在您的终端中执行下面的代码来创建环境之后
conda env create --file /path/to/environment.yml
## ***用康达*** 更新环境
更新您的环境是您在机器学习过程中的日常任务之一。
库经常变化，旧版本被替换，或者有时您甚至需要用一个库替换另一个库或者删除多余的依赖项。
Conda 提供了一个命令，用于在对环境文件进行更改后更新您的环境。
例如，让我们向环境中添加一个新的依赖项。
filename: environment.yml
name: another_example_env
dependencies:
- python=3.7
- scipy=1.4.1
- pytorch=1.5.0
对环境文件进行更改后，您可以通过运行以下命令来更新环境:
conda env update --file /path/to/environment.yml --prune
## ***列表环境***
当您有多个机器学习项目时，在选择要处理的项目之前，您可能希望先看到您的环境列表。
使用 conda list 命令，您可以看到您的环境列表:
conda info --envs
## ***激活您的环境***
环境激活是应用程序运行的先决条件。当您激活您的环境时，您正在设置您的应用程序工作可能需要的任意环境变量。
要使用 conda 激活环境，请运行以下命令:
conda activate myenv
## ***推出 jupyter 笔记本***
Jupyter notebook 是一个提供基于 web 的交互式界面的工具，允许您交互式地开发和展示数据科学项目。它将您的代码及其输出集成到一个文档中。
一旦您设置并激活了您的环境，您就可以通过执行命令`jupyter notebook`开始开发来启动 Jupyter 笔记本。
jupyter notebook
您将看到一个类似于下图的屏幕:
Jupyter 笔记本
## **分享和复制你的环境**
软件是为多次运行而编写的。通常，我们与同事、朋友、合作者，甚至随机的陌生人共享代码。当我们这样做时，我们应该确保他们能够运行我们与他们共享的代码——没有相同的环境，再现性是不可能的。
您可以通过导出您的环境来共享您的环境，以便您的同事可以构建与您相同的环境来运行您的代码。我们使用以下命令导出环境:
conda env export --file exported_environment.yml
## **打造相同的康达环境**
有时候，您可能希望在一台机器上构建一个相同的环境，而在另一台机器上构建一个相同的操作系统。
例如，如果你购买了新的硬件或者把你的代码从你的工作计算机转移到你的家用计算机，家用计算机有相同的操作系统。Conda 允许您在同一台机器上或者在运行相同操作系统平台的另一台机器上构建一个相同的环境。我们通过将规格列表导出为文件来实现这一点。
conda list --explicit > current/working/directory/spec-file.txt
您可以使用以下命令，使用导出的规范在另一台计算机上创建完全相同的环境:
conda create --name identical_env --file spec-file.txt
# ***本地硬件的限制***
您已经看到了如何为机器学习项目设置本地开发环境。您的本地设置适合需要少量计算能力的小型机器学习项目。
在现实世界中，机器学习项目通常需要大量的数据和巨大的计算能力，远远超出了您的本地机器所能提供的。
如果你正在训练一个模型来识别模式，它可能需要并行计算资源，这在传统处理器上可能需要几天时间。
所有这些限制和更多的限制使我们转向云服务，如[谷歌云平台、](https://cloud.google.com/) [亚马逊 Sagemaker](https://aws.amazon.com/sagemaker/) ，它们的硬件针对机器学习工作进行了优化。它们使我们能够利用无限的计算能力并行训练大型数据集。Google、AWS、Azure 等提供的云服务。拥有针对机器学习作业优化的硬件
# **免费云服务，允许您免费构建模型**
你可能会想，“哦，不，这是一个介绍性的帖子，对于我的项目，我甚至不需要强大的计算能力，我只是想尝试一下。”
我明白，我完全理解。如果你不是在做一个大项目，你可能只需要很少的计算能力来尝试。
这里有一个问题，云已经变得相对便宜，一些服务，如 [Google Colab](https://colab.research.google.com/) 甚至允许你免费训练模型。我的意思是不需要环境设置，大多数机器学习包已经预装。你可以免费快速搜索。
以下是云服务；您可以使用:
* [谷歌合作实验室](http://colab.research.google.com/)
* [朱庇特](http://jupyter.org/try)
* [微软 Azure](https://notebooks.azure.com/)
* [AWS Sagemaker](https://aws.amazon.com/sagemaker/)
* [谷歌人工智能平台](https://cloud.google.com/ai-platform)
* [Cocalc](https://cocalc.com/)
# 结论
在这篇文章中，你看到了如何为机器学习项目设置你的本地机器。我们还看到了一个免费云服务列表，允许您免费构建和训练模型。
同时，在你等待第二个帖子的时候，你可以[订阅我的简讯](http://bit.ly/hubofml)。每月一次，我会发送一份时事通讯，其中包含许多关于数据科学、软件工程和机器学习的令人兴奋的内容。期待快速提示，链接到有趣的教程，意见，论文和图书馆。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
