admin管理员组

文章数量:1645531

原文：TowardsDataScience

协议：CC BY-NC-SA 4.0

使用 Streamlit 创建交互式数据科学电子课程应用程序

原文：https://towardsdatascience/create-an-interactive-data-science-e-course-app-using-streamlit-b9f093aa64a1

探索 streamlit_book -一个新的 streamlit 伙伴库-用于创建交互式电子书/电子教程/电子课程

图片由 Pixabay 提供

介绍

如果你关注我的 Medium 博客已经有一段时间了，你应该知道我是 Streamlit 的忠实粉丝。我写过几篇关于 Streamlit 的文章，从完整的初学者教程到动手的应用程序构建项目。我永远不会对它感到厌倦，并且每天都在寻找新的特性、很酷的技巧或令人兴奋的能力来探索和学习。

作为一名数据科学家，Streamlit 让我探索 web 应用程序开发的世界变得可能和超级容易，我发现这非常迷人和令人大开眼界。我最近偶然发现了一个新的 streamlit 伙伴库 streamlit_book，它是由 Sebastian Flores Benner 创建的，旨在供教师和内容创建者使用 Streamlit 框架创建交互式电子课程、教程或演示文稿。

我超级感兴趣，马上开始探索，玩起来。使用 Streamlit 和 streamlit_book，我创建了一个样本数据科学电子教程应用程序，它有多个页面，用户可以与之交互的代码示例，以及测试知识的测验。尽管在这个过程中我遇到了一些小问题(我不得不使用一些变通方法)，但总的来说，我发现这个新库非常有用和方便。

在本文中，我将与您分享创建数据科学电子教程应用程序的想法、步骤和代码。这里的主要想法是试验 Streamlit 框架，看看我们是否可以在数据科学教程中引入某种程度的交互性，例如在多个页面中安排内容，允许用户运行并检查代码示例的输出，以及为用户提供测验以增强他们的学习体验。

下面是一个 YouTube 视频短片，演示了这款应用程序:

作者提供的视频

示例教程页面(图片由作者提供)

先决条件

如果您还没有这样做，您需要在您的计算机上安装 Streamlit 和 streamlit_book 来构建此应用程序。

#1:细流安装:

可以参考下面的文章，按照说明安装 Streamlit，学习基础知识。

#2:安装 streamlit_book

按照 streamlit_book 文档页面上的说明安装 streamlit_book 库:

pip install streamlit_book

创建项目文件夹和文件

在我们启动 Streamlit 并开始构建应用程序之前，让我们创建一个项目文件夹和一些空的 python(。py)文件，遵循如下所示的步骤和结构。

首先，让我们创建一个名为“ecourse_app”的项目文件夹，该文件夹将存放该项目所需的所有文件。在项目文件夹中，创建一个名为“ecourse_streamlit”的子文件夹和一个空 python(。py)名为“ecourse_main.py”的文件。这个 python 文件将是设置应用程序结构和属性的主要文件。

在“ecourse_streamlit”子文件夹中，创建几个空的 python 文件，这些文件将存放所有课程内容。每个 python 文件都充当应用程序中的一个页面。由于 streamlit_book 按字母顺序对内容文件进行排序和读取，因此在文件名前加上数字有助于获得所需的排序。在该文件夹中，您还需要包含一个示例数据 CSV 文件和一个将用作封面图像的图像。

作者图片

现在我们可以从 Anaconda 终端窗口启动 Streamlit。一个空白的 Streamlit 应用程序应该会出现在您的本地 web 浏览器中。

作者图片

创建主文件(ecourse_main.py)

打开 ecourse_main.py 文件，插入下面的代码。第 6 行设置了 streamlit_book 属性，并允许您配置应用程序的行为。您需要使用 path 参数指定 streamlit_book 应该在其中查找所有内容文件的文件夹名称。您还可以通过选取自己的图标或文本来自定义“上一页”和“下一页”按钮的外观。

我们还可以向应用程序添加一个侧栏，并提供一些关于应用程序的附加信息。为了节省空间，我们可以使用 st.sidebar.expander()小部件。我们还将创建一个反馈部分，要求用户对我们的应用程序进行评级并提供任何反馈。

作者图片

创建内容文件(00 封面. py 等。)

创建封面(00 封面. py)

让我们首先为我们的电子教程创建一个封面。打开“00 Cover Page.py”文件并插入以下代码。

第 5–9 行:我们给应用程序的封面添加一个标题。我们选择 st.markdown()而不是 st.title()的原因是，我们可以使用 CSS 来设置文本的样式，使其在视觉上更具吸引力。

第 11–19 行:我们给应用程序添加了一个封面图片。我们在这里使用了一个小技巧来使图像居中。使用 st.columns()我们可以创建 3 列，其中第二列(放置图像的列)的宽度是第一列和第三列的 6 倍，因此将图像放置在中间。

我们的封面完成了！看起来是这样的:

作者图片(熊猫图片由 Pixabay 提供)

创建介绍页面(01 什么是熊猫. py)

在封面之后，让我们创建一个介绍页面，给读者一个关于熊猫图书馆和这个电子教程的介绍。打开“01 什么是 Pandas.py”并插入下面的代码:

因为简介页面是一个文本丰富的页面，所以您不必总是使用 python(.py)文件。您可以使用降价文件(.md 文件)，如果您想对文本应用更多的自定义样式和格式。

作者图片

创建“导入数据”页面(02 导入数据. py)

现在让我们进入第三页，即“导入数据”页。在这一页，我们想向读者展示如何导入一个 CSV 文件到熊猫。我们希望通过允许用户运行代码示例并检查输出来使页面具有交互性。我们还希望在页面的末尾包含一些小测验，以便用户可以自测他们的知识。这是一个有趣的页面！

打开“02 Import Data.py”文件并插入以下代码:

让我们详细检查一下上面的代码:

第 5–6 行:我们使用 st.subheader()向页面添加标题，并使用 st.markdown()添加一些文本来解释如何将数据导入 Python。

第 8–10 行:我们将第一段代码放在一个字符串中，然后使用 st.code()显示它。

第 12–18 行:我们创建了一个 Streamlit 按钮，这样当用户点击“检查结果”按钮时，我们使用 st.write()显示第一段代码的输出。

第 20–30 行:我们对第二段代码做同样的事情。

第 32–46 行:我们将第三段代码放入一个字符串中，并使用 st.code()显示它，就像我们对前两段代码所做的那样。但是，由于这段代码的输出不是数据帧，所以我们不能只使用 st.write()来显示输出。相反，我们需要将输出转换成一个字符串，并使用 st.text()来显示结果，如第 39–44 行所示。

第 48–58 行:我们创建了一个测验部分，并使用两个内置的 streamlit_book 小部件添加了两个问题:stb.single_choice()和 stb.true_or_false()。

作者图片

这就是教程的第三页。它有几段解释概念和代码，然后显示代码示例，并允许用户运行和检查输出！它还有一个很好的测验部分，为应用程序带来额外的交互性。

现在，您只需遵循相同的代码模板，并在此应用程序中创建其余的页面！一定要看看 streamlit_books 的文档页面，因为它还有一些其他很酷的功能可以尝试，比如多选题小部件、待办事项小部件等。要有创意，要有乐趣！感谢阅读，我希望你喜欢这篇文章。

作者提供的视频

参考:

  1. 如何用 5 个步骤用 Streamlit 创作互动书籍 Sebastian Flores Benner
  2. Streamlit_book 文档:https://streamlit-book.readthedocs.io/en/latest/

你可以通过这个推荐链接注册 Medium 会员(每月 5 美元)来获得我的作品和 Medium 的其他内容。通过这个链接注册，我将收到你的会员费的一部分，不需要你额外付费。谢谢大家！

用 PyScript 和熊猫创建一个交互式 Web 应用程序

原文：https://towardsdatascience/create-an-interactive-web-app-with-pyscript-and-pandas-3918ad2dada1

PyScript 允许我们用 HTML 和 Python 作为脚本语言创建一个无服务器的 web 应用程序

作者图片

PyScript 是 web 应用的未来吗？也许是，但可能还不是——我敢肯定，它仍然只是一个 alpha 版本，还有很多工作要做。

但是现在它有多大用处呢？

我们将创建一个交互式 web 应用程序，其中的逻辑完全是用 Python 编写的。

你可能听说过 PyScript，它是由 Anaconda 的首席执行官王蒙杰在 2022 年的 PyCon 大会上宣布的。用他们自己的话说这是“一项闪亮的新技术……允许用户在浏览器中编写 Python，事实上还有许多语言”。

PyScript 的最大优势在于，您可以用 Python 编写 web 应用程序，而不需要服务器。这是通过使用用 WebAssembly 编写的 Pyodide Python 解释器来实现的，web assembly 是现代浏览器支持的较低级的 web 语言。

到目前为止，Python web 应用程序都是基于服务器的，并且使用 Django 或 Flask 等框架，其中前端是用 HTML 和 Javascript 创建的，而后端是在远程服务器上运行的 Python。

最近，Dash 和 Streamlit 试图通过提供纯 Python 框架来简化此类应用的构建，从而避免学习 HTML 和 Javascript。但是这些仍然是基于服务器的应用程序。

PyScript 是一种不同的方法。在 PyScript 中，用户界面仍然是用 HTML 构造的，但是 Javascript 被 Python 代替了(尽管如果您愿意，您仍然可以使用 Javascript，并且用两种脚本语言编写的函数可以相互通信)。

网络应用

我将运行一个用 PyScript 和 HTML 编写的简单应用程序，它从远程数据源读取数据，并显示一个简单的仪表板，用户可以在其中选择要在 Pandas 图表中显示的数据。

该应用程序的基本形式如下:

<html>
    <head>
        <link rel="stylesheet" 
            href="https://pyscript/alpha/pyscript.css" />
        <script defer 
            src="https://pyscript/alpha/pyscript.js">
        </script>
        <py-env>
            - libraries-that-will-be-used
        </py-env>
    </head>
    <body> <!-- HTML layout code goes here --> <py-script>
            # PyScript code goes here
        </py-script>
    </body>
</html>

正如你所看到的，它看起来像一个标准的 HTML 文件，事实上它就是一个。但是对于 PyScript app，我们需要在<head>部分包含到 PyScript 样式表和 Javascript 库的链接，以及包含我们稍后将看到的<py-env>块。

接下来在<body>中，我们有 HTML 布局内容，后面是包含 Python 代码的<py-script>...</py-script>标签。

我们现在将充实这些部分。

首先，我将使用 Bootstrap 框架来使整个应用程序看起来很漂亮。这意味着我们需要包含到引导 css 文件的链接。我们将使用 Matplotlib 和 Pandas 库，这些库需要在<py-env>...</pt-env>部分声明。<head>...</head>现在看起来像这样:

<head>
    <link rel="stylesheet" 
        href="https://pyscript/alpha/pyscript.css" />
    <script defer 
        src="https://pyscript/alpha/pyscript.js">
    </script>
    <link rel="stylesheet" 
        href="https://maxcdn.bootstrapcdn/bootstrap/4.3.1/css/bootstrap.min.css">
    <py-env>
        - matplotlib
        - pandas
    </py-env>
</head>

接下来要看的是网页的 HTML 代码。第一部分基本上是页面的标题。我们利用 Bootstrap 的大屏幕容器。这给了我们一个令人愉快的灰色背景的盒子和一些经典引导风格的介绍性文本。

<div class="jumbotron">
    <h1>Weather Data</h1>
    <p class="lead">
        Some graphs about the weather in London in 2020
    </p>
</div>

接下来是两行:第一行有一个按钮和一个下拉菜单，第二行包含要显示的图表。

这是第一行:

<div class="row">
    <div class="col-sm-2 p-2 ml-4 mb-1">
        <button type="button" class="btn btn-secondary">Select chart from list:</button>
    </div> <div class="col-sm-4 p-2 mr-4 mb-1">
        <select class="form-control" id="select">
            <option value="Tmax">Maximum Temperature</option>
            <option value="Tmin">Minimum Temperature</option>
            <option value="Sun">Sun</option>
            <option value="Rain">Rain</option>        
        </select>
    </div>
</div>

它由两列组成，一列用于按钮，另一列用于菜单(我在这里使用按钮只是为了美观，它实际上并没有按钮的功能)。下拉列表中的选项将用于显示四个不同图表中的一个。将使用的数据是 2020 年伦敦的天气状况表。表格中有 12 行代表每个月，表格中的列代表该月的最高温度*、最低温度*、日照时数和降雨量毫米*。***

因此，菜单项代表这些选项，并将取值为“Tmax”、“Tmin”、“Sun”或“Rain”。

到目前为止，我们已经编写了网页代码，现在我们需要定义对用户输入做出反应的逻辑，并绘制图表。这在<py-script>一节中定义。我们接下来要处理的代码在这一节中。

先导入一些库。

**# Import libraries
import pandas as pd
import matplotlib.pyplot as plt**

当然是熊猫和 Matplotlib，但我们还需要以下内容:

**from pyodide.http import open_url**

这是 PyScript 提供的一个库，它允许我们从网上的资源中读取内容，我们是这样使用它的:

**url = 'https://raw.githubusercontent/alanjones2/uk-historical-weather/main/data/Heathrow.csv'
url_content = open_url(url)df = pd.read_csv(url_content)**

PyScript 实现 Pandas 函数read_csv不能直接打开 url，所以我们必须使用上面的技术。

正在下载的文件包含几十年的数据，但为了保持简单，我们将过滤它，只保存 2020 年的数据。

**# filter the data for the year 2020
df = df[df['Year']==2020]**

现在是我们之前看到的在 HTML <div>中绘制图表的函数。

**# Function to plot the chart
def plot(chart):
    fig, ax = plt.subplots()
    df.plot(y=chart, x='Month', figsize=(8,4),ax=ax)
    pyscript.write("chart1",fig)**

这是和熊猫一起策划的非常标准的东西。与“普通”Python 程序的主要区别在于它的呈现方式。pyscript.write函数获取 HTML 元素的 id，并将第二个参数的内容写入其中。

这依赖于 PyScript 实现中包含的呈现特定对象的方式——在本例中是 matplotlib 图表——这不一定适用于任何类型的对象。例如，如果我们想要显示一个 Plotly 图表，我们将不得不使用不同的技术，因为在 PyScript 中没有直接实现 Plotly 图形(到目前为止)。

接下来要做的是定义当用户从下拉菜单中选择一个新图表时调用plot函数的方法。

首先是更多的库——这些是作为 PyScript 的一部分提供的。

**from js import document
from pyodide import create_proxy**

js库允许 PyScript 访问 Javascript 函数，在这个例子中，我们引入了访问 DOM 的能力。Pyodide 的 create_proxy 则相反，允许 Javascript 直接调用 PyScript 函数。

**def selectChange(event):
    choice = document.getElementById("select").value
    plot(choice)**

当一个改变事件发生时，这个函数被调用。它读取选择的值，然后用该值调用先前定义的plot函数。

接下来，我们定义一个代理，它将允许 change 事件调用 PyScript 函数selectChange。

**# set the proxy
def setup():
    # Create a JsProxy for the callback function
    change_proxy = create_proxy(selectChange) e = document.getElementById("select")
    e.addEventListener("change", change_proxy)**

最后，当页面第一次加载时，我们需要调用setup函数并使用默认值(‘Tmax’)运行plot函数，以便在启动时显示图表。

这是实现一个简单的仪表板应用程序的全部代码，就像本文开头截图中的那个一样。这个代码和一个演示应用程序的链接将在最后的链接。

PyScript 与现有的基于服务器的应用程序相比如何？

就难度而言，只要你熟悉 Python，构建 web 应用程序就相对简单，可能比构建 Django 或 Flask 应用程序更容易——我认为更像 Dash 的水平。

然而细流是一个不同的故事。Streamlit 在视觉设计方面更受限制，但它的优势是你不必学习 HTML。Streamlit 应用程序非常容易创建——我认为比 PyScript 更容易。

然而，PyScript 相对于所有竞争对手的优势在于它不依赖于服务器。这使得部署变得非常容易——我只需将您在这里看到的应用程序上传到 Github Pages 网站，它就可以正常工作了。

目前 PyScript 有点慢。因为所有的工作都是在浏览器中完成的，所以性能由运行浏览器的机器决定——如果你的硬件很弱，那么加载你的应用可能需要很长时间，尽管一旦它启动并运行，性能似乎就没问题了。

但是，随着硬件变得更加强大，PyScript 变得更加成熟，并且(希望)变得更加高效，性能只会变得更好。有一天，谁知道呢，也许我们会看到 PyScript 像今天的 Javascript 一样嵌入到浏览器中。

更新:你可以在这里 找到这个 app 用 Plotly 代替熊猫绘图的版本 。

更新 2:PyScript 新增功能 查看截至 2023 年初 PyScript 所做的一些重大更改。

一如既往，感谢阅读。你可以在我的网站上找到完整代码和演示网页的链接，在那里你还可以找到其他文章的链接。

**https://alanjones2.github.io

如果你想跟上我写的东西，请考虑订阅我偶尔的时事通讯或者点击下面的链接，当我在这里发表时，你会收到一封电子邮件。

https://technofile.substack

笔记

  1. 天气数据来自我的报告英国历史天气，并来自英国气象局历史气象站数据。它是根据英国开放政府许可证发布的，可以在相同的条件下使用。

海生的

在回答“Seaborn 是否适用”这个问题时:

<html><head>
<link rel="stylesheet" href="https://pyscript/alpha/pyscript.css" />
<script defer src="https://pyscript/alpha/pyscript.js"></script><link rel="stylesheet" href="https://maxcdn.bootstrapcdn/bootstrap/4.3.1/css/bootstrap.min.css"><py-env>
   - matplotlib
   - pandas
   - seaborn
</py-env></head>
<body><div class="jumbotron"> <h1>Weather Data</h1>
   <p class="lead">
      Some graphs about the weather in London in 2020
   </p></div><div class="row">
   <div class="col-sm-2 p-2 ml-4 mb-1">
   <button type="button" class="btn btn-secondary">Select chart from list:</button>
   </div>
   <div class="col-sm-4 p-2 mr-4 mb-1">
      <select class="form-control" id="select">
         <option value="Tmax">Maximum Temperature</option>
         <option value="Tmin">Minimum Temperature</option>
         <option value="Sun">Sun</option> 
         <option value="Rain">Rain</option>
      </select>
   </div>
</div><div class="row">
   <div class="col-sm-6 p-2 shadow ml-4 mr-4 mb-4 bg-white rounded">
      <div id="chart1"></div>
   </div>
</div><py-script>
# Import libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns# Get the datafrom pyodide.http import open_urlurl = 'https://raw.githubusercontent/alanjones2/uk-historical-weather/main/data/Heathrow.csv'url_content = open_url(url)df = pd.read_csv(url_content)# filter the data for the year 2020df = df[df['Year']==2020]# Function to plot the chartdef plot(chart):
   fig, ax = plt.subplots()
   sns.lineplot(y=chart, x="Month", data=df, ax=ax)
   pyscript.write("chart1",fig)# Set up a proxy to be called when a 'change'# event occurs in the select controlfrom js import document
from pyodide import create_proxy# Read the value of the select control# and call 'plot'def selectChange(event):
   choice = document.getElementById("select").value
   plot(choice)# set the proxydef setup():
   # Create a JsProxy for the callback function
   change_proxy = create_proxy(selectChange)
   e = document.getElementById("select")
   e.addEventListener("change", change_proxy)setup()# Intitially call plot with 'Tmax'plot('Tmax')</py-script></body></html>

创建 Cad 并将其部署到。stl 转换器:Streamlit 和 Python

原文：https://towardsdatascience/create-and-deploy-a-cad-to-stl-converter-streamlit-and-python-28a01240726a

快速高效地创建并投入生产

这篇文章提出了两个主题:

  • 渴望尝试使用工具来部署**【python】****项目**作为 web 应用，快速与朋友、客户和同事分享自己的工作，并拥有一个响应迅速、令人愉悦的界面
  • 实现一个定制系统，用于将 CAD 几何图形 (step 和 iges)转换为 STL 格式，用于工程和人工智能应用。

我发现这个工作流程(和最终结果)真的让满意让满意，考虑到最终结果的质量和实现所需的时间之间非常高的比率。根据这篇文章，你可以尝试这个应用程序，复制它，从它那里获得灵感，创造一个新的应用程序！

您可以在以下位置尝试此应用程序:

https://share . streamlit . io/git Marco 27/deepcadconverter/main/main . py

什么是简化

https://streamlit.io/

Streamlit 是一个开源的 Python 库，可以轻松创建和共享漂亮的、定制的机器学习和数据科学 web 应用。只需几分钟，您就可以构建和部署强大的数据应用程序。

当我第一次读到这个项目时，我立刻被这个想法吸引住了。

自由地用主机部署应用程序的能力令人难以置信。除此之外，还能拥有具有吸引力和响应性的图形，而无需使用 Html 和 CSS 。只需创建一个格式良好的 Github 库，就大功告成了:我们已经准备好使用和共享我们的 web 应用程序了。这开启了一个潜在应用的海洋:例如，我们可以以快速、实用、有效的方式实现复杂的人工智能算法，进行训练，并将我们的模型投入最终用户的生产。

CAD 到 STL 转换器 streamlit 应用程序—图片由作者提供

关于什么是 streamlit，它是如何工作的，我就不多说了。你可以在https://marcosanguineti.medium/subscribe上找到很多关于它的非常有趣的文章(我提醒你，成为会员你就可以接触到无限的文章，支持我们的工作)。

您可以在下面找到该应用程序的完整代码:

**https://github/GitMarco27/DeepCadConverter

可以随意复制，叉或者改进！

为什么是 Cad 到 Stl 的转换器

在机械和工业工程领域工作，以及在人工智能和软件开发领域工作，恰好要处理各种格式的实体( CAD )，用各种软件制作。

各种格式之间的转换 绝非小事，尤其是在不借助专业软件的情况下，从许可的角度来看通常非常昂贵(尤其是如果仅用于几何图形的转换)。

有很多在线工具可以将 IGES 和 STEP 转换成 STL，但是这些工具通常有:

  • 使用限制
  • 操作问题
  • 缺少设置
  • 成吨的横幅广告。

这导致了用 T21 GMSH T22 Python 和 Streamlit 开发我们自己的转换工具的想法。

Gmsh 是一个开源的 3D 有限元网格生成器，内置 CAD 引擎和后处理器。它的设计目标是提供一个快速、轻便和用户友好的网格工具，具有参数输入和高级可视化功能。Gmsh 围绕四个模块构建:几何、网格、求解器和后处理。对这些模块的任何输入的说明或者使用图形用户界面以交互方式完成，在 ASCII 文本文件中使用 Gmsh 自己的脚本语言(.geo文件)，或者使用 C++、C、Python 或 Julia 应用编程接口(API)。

此工具允许您使用大量参数对几何体进行三角剖分，以最大化您的需求(几何体特征、网格密度……)。

Gmsh —作者图片

工作原理

为了使用 streamlit 实现应用程序，首先需要在您的虚拟环境中安装同名库( pip install streamlit )。

我们的应用程序将从 python 脚本启动:在本例中，我的应用程序指向脚本 main.py

要在本地启动我们的应用程序，只需在我们的操作系统中打开一个终端，然后启动(在您的虚拟环境中):

>> (venv) streamlit run main.py

在我们的应用程序中添加组件非常简单和直观，因为它们已经在大量的小部件中可用。

在我们的应用程序中编写文本支持我们习惯使用的 markdown 格式。我们有一个简单的工具来添加标题，一个用于文本，同样，添加图像也非常简单:只需指向正确的路径。我们还可以使用典型的 markdown 语法添加外部链接。

同时，创建多选菜单的语法非常简单:用“ with ”语句打开一个上下文，并在其中添加小部件。在这种情况下，此类对象(扩展器)用于设置 gmsh 参数，不会使主屏幕过于混乱，并且它也将在转换固有的日志之后使用。

file_uploader 小部件允许用一个对话框窗口加载一个(或多个)文件，或者在屏幕上拖动它们，将加载的数据存储在变量“data”中。

应用程序等待加载文件，直到使用适当的按钮激活转换触发器。

首先，执行任何先前运行的清除。首先，对所有以前的运行进行清理。如果加载的几何图形数量大于或等于 1，代码执行开始:在调用脚本执行真正的 cad 转换之前，几何图形保存在一个临时文件夹中(这样做是为了在主线程中执行 gmsh，避免信号问题)。

一旦所有几何图形的转换完成，文件被压缩并可供用户下载。

还会写入一个关于所执行操作的日志，并显示转换成功(或失败)的几何计数。

因此，让我们看看用于执行实际转换的脚本。

正如预期的那样，这个脚本通过系统 参数调用 gmsh，加载一个几何体(阶梯或 IGES)并根据指定的设置创建一个新的表面网格，导出一个新的 STL 到我们的临时文件夹。

要部署我们的应用程序，必须添加一个需求文件和一个包文件，其中包含关于 python 和系统库的详细信息，它们必须安装在 docker 中，docker 将在远程主机上管理我们的应用程序。

从 streamlit 站点部署非常简单:一旦您将您的 Github 帐户与 streamlit 帐户连接，您就可以连接您的存储库(在我的例子中是 GitMarco27/DeepCadConverter)、主脚本(在我的例子中是 main.py)并选择 python 的版本(在我的应用程序中是 3.8)以在最终 docker 上使用。

结论

飞机。stl 渲染—作者提供的图像

我们已经看到了如何使用 Streamlit 快速高效地构建一个 python 应用程序，使用简单而强大的小部件实现 UI，并尝试解决一个与曲面网格相关的重要工程问题。我们看到了如何使用这些工具与朋友、同事或客户共享应用程序，以及在本地测试和部署(甚至免费)web 应用程序的可能性。

📚在我的个人资料上阅读更多文章

📨成为电子邮件订阅者，了解最新动态

💻加入媒体没有阅读限制

✏️对疑点或新内容的评论

下次见，马可**

使用 R 在几分钟内创建并托管您的个人网站

原文：https://towardsdatascience/create-and-host-your-personal-website-in-a-few-minutes-using-r-9c94e87e2942

在几分钟内建立和主持一个简单，干净，专业的个人网页，如果你喜欢，添加一些铃铛和口哨

我的简单网站的例子创建使用 R 和明信片在keithmcnulty

越来越多的数据科学家和其他技术专业人员因为他们的在线存在和开源活动而被认可，就像他们的职业历史一样。因此，我认为每个数据科学家都应该有自己的个人网页，向世界介绍一些他们自己和他们的工作。

这不必很复杂。我们都有 LinkedIn 个人资料，我们中的一些人还有其他在线存在，如媒体博客、YouTube 视频或 Twitter 账户。所以你的个人网页只需要提供一个链接的中心点，并提供一些关于你是谁和你做什么的基本信息。你想告诉人们多少关于你自己的事，这取决于你自己。

好消息是，你可以在不到一个小时的时间内免费完成这项工作。这是配料和要遵循的食谱。我还添加了一些可选的额外说明，以防你使用你自己的个人网站域名来托管你的网站(比如像我在keithmcnulty的网站)，如果你想添加社交媒体元数据，以便社交媒体上你的网站链接具有专业的外观。

在我开始之前，你可以在 github repo 这里看到我网站上的所有代码，所以你可能希望以此为起点。

佐料

  1. r 和 RStudio
  2. 安装的RMarkdown、postcards和metathis R 包
  3. Github 账户
  4. 一个 AWS 帐户，如果你想购买和使用个人网站域名

真的是这样。这是一个相当简单的过程，如果你按照这个食谱做，你应该能很快完成。

创建网站的方法

  • 为您的网站创建一个新的公共 github repo。
  • 从这个 github repo 在 RStudio 中启动一个新项目(新建项目>版本控制)
  • 将您想在网站上使用的照片添加到项目中(jpg 或 png 格式即可)。
  • 确保您已经安装了RMarkdown和postcards包。如果还没有，现在安装它们并重启 r。
  • 从模板开始一个新的 R Markdown 文档(新建文件> R Markdown >从模板)。选择弹出选项的postcards模板之一。任何一个应该都可以。如果你想的话，你可以随时改变。您将在弹出的模板文件中看到以下内容:

RMarkdown 基本明信片模板

  • 现在，您只需对您的姓名、照片文件以及您希望从个人资料中提供的任何链接进行必要的编辑。你基本上可以把尽可能多的链接向前。label字段将是显示在链接框中的内容，而url字段将是继续点击的地址。
  • 在底部的文本中，你可以写下任何你想告诉人们的关于你的事情。你可以在这里使用标准的 RMarkdown 格式，包括使用#或##或###的标题，或者你可以包括项目符号或其他资源或照片的链接。在本节中，如果您愿意，您甚至可以用原始 HTML 编码。如果你有很多后续链接，那么我会建议你保持一个像我这样的简单的简历。
  • 完成后，将文件保存为index.Rmd(确保它在项目的根目录下)并继续编织它。这将创建网页并保存为index.html。如果您想尝试另一种设计，只需将output字段中的名称更改为另一种postcards格式，如postcards::trestles或其他格式。
  • 完成后，提交新文件并将其推送到 github repo。

主办网站的食谱

我们将在 Github 上托管网站。这意味着每当你改变它，并推动这些变化，网站将自动更新。为您省去管理不同托管平台的麻烦。

  • 将您的网站文件推送到 Github 后，返回 Github repo，选择设置，然后选择页面。
  • 选择主分支和根目录，然后选择保存。
  • 网站上线可能需要几分钟时间，但你最终会看到一个绿框，上面有你的新网址。它通常是https://username.github.io/reponame的形式。
  • 恭喜，你有网站了。
  • 现在，无论你何时对你的网站进行更改，提交和推送，几分钟后这些更改将在你的新网站地址生效。容易得很。

可选方法:添加社交媒体元数据

通常我们会想在社交媒体上分享我们网站的链接。如果我们将社交媒体元数据添加到index.html中，我们可以定制共享时我们网站的链接显示方式。例如，当我在这里分享时，看看我的网站是如何显示的。我已经定制了链接中共享的图像和文本。

https://keithmcnulty

您可以使用metathis R 包轻松地将社交媒体元数据添加到您的index.Rmd文件中。就像这样添加一个 R 代码块:

添加社交媒体元数据

meta_social()功能包含了你想要你的链接如何出现在社交媒体上的所有必要定制。如果你想为你的社交媒体链接使用不同的图片，请确保将该图片上传到你网站的根目录下。请注意，不同的社交媒体平台对图像尺寸和大小有不同的规定，所以保持图像相对简单。300 像素乘 300 像素的正方形效果很好，但你也可以做一些简单的风景格式的照片。你可以随时尝试分享你的网站，直到你对它的外观满意为止。

可选方法:使用个人域名

购买和使用个人域名是个好主意。它有一个更专业的外观，更容易被人们记住，在许多情况下，它每年只需花费 12 美元，一旦你拥有它，你可以使用任何你想要的子域用于不同的目的(如 blog.domain 或 myproject.domain)。

你可以使用亚马逊 Route 53 使用这些指令注册并购买一个域名。大多数域名是可用的，本质上并不罕见，每年只需 12 美元。如果你已经通过另一个提供商购买了一个域名，那么如果你愿意，你也可以找到把它转移到 AWS 的说明。这样做通常更便宜，而且你通常有更大的灵活性。

一旦你购买了一个域名并拥有了它，你需要设置好让yourdomain和www.yourdomain链接到你创建的 Github 网站。你需要确保无论访问者在网址中使用http还是https都会发生这种情况。以下是方法。

  • 首先，您需要在 AWS Route 53 上为您的域名创建一个托管区域。进入托管区域。选择创建托管区域，并输入您购买的基本域名(不带www.)。选择它作为公共托管区域，然后单击创建。现在，您将在您的托管区域列表中看到这一点，并创建了几条记录。
  • 我们现在必须创建一个别名记录，将这个托管区域指向 Github。进入您的新托管区域，然后单击创建记录。然后简单路由。在下一页，单击“定义简单记录”。保持记录名称不变，并选择一个 under 记录类型。在值/将流量路由到下，选择 IP 地址，然后输入这些值，然后选择定义简单记录，然后选择创建记录。
185.199.108.153
185.199.109.153
185.199.110.153
185.199.111.153
  • 现在对域的www版本做同样的事情，创建另一个简单的记录，这次使用记录名[www.yourdomain](http://www.yourdomain)。这一次，在记录类型下，选择 CNAME。在 Value/Route traffic to 下，输入您之前创建的 Github 网站的基本网址— yourusername.github.io。不要输入回购名称。定义并创建新记录。
  • 最后，回到你的 github repo，回到设置>页面。在显示自定义域的地方，输入您的根域(不带www.)并点击保存。如果您正确地遵循了前面的步骤，您最终应该会看到一个绿色的勾号，并看到一个过程开始提供您的 TLS 证书。
  • 这可能需要一点时间，但完成后，您可以选择“强制 HTTPS ”,这样就完成了。你可能需要一点耐心来完成这一切，但是一旦完成，访问你在https://yourdomain或https://www.yourdomain的新网站，希望你都准备好了。

仅此而已。只需要几分钟就可以设置好网站的基本版本。建议将其附加到自定义域，如果您遵循这些说明，应该不会太难。希望这些对你有帮助。

用 SMOTE 创建人工数据

原文：https://towardsdatascience/create-artificial-data-with-smote-2a31ee855904

如何利用简单的算法来弥补数据的不足

布雷特·乔丹在 Unsplash 上的照片

数据不平衡在机器学习中普遍存在。真实数据很少平等地代表每个类。在疾病诊断、欺诈检测和垃圾邮件分类等应用程序中，一些类别将总是被低估。

这是许多机器学习相关工作的主要障碍。毕竟，如果您缺少特定结果的数据，您的模型将无法充分预测该结果。

值得庆幸的是，有办法绕过这个问题。如果你不能为少数民族阶层获取足够的数据，为什么不自己做一些呢？

这里，我们介绍合成少数过采样技术(SMOTE)，这是一种用于生成人工数据的流行算法。

为什么击打？

在介绍 SMOTE 的来龙去脉之前，让我们首先讨论一下对人工数据的需求。

当我们可以利用欠采样和过采样等采样技术时，为什么我们需要经历创建我们自己的数据的麻烦？

简而言之，这是因为这些方法存在重大缺陷。

欠采样需要通过从多数类中移除记录来均衡每个类的样本。这在理论上是明智的，但付诸实践就完全荒谬了。

数据是宝贵的。

为了进行后续的分析和建立依赖于这些数据的模型，企业需要付出相当大的努力来收集和存储数据。

试着告诉你的老板，为了“平衡”，你想丢弃你的数据工程师辛辛苦苦获得的 80%的数据。不会有好结果的。

过采样需要通过复制少数类样本来增加少数类大小，从而使每个类的样本均匀。这不是一个更好的选择，因为用这样的数据训练的模型容易过度拟合。

如果丢弃或复制样本无效，剩下的唯一选择就是创建自己的数据。

SMOTE 是用来实现这一点的最流行的算法之一。

SMOTE 如何工作

SMOTE 的内部工作看似抽象，但相当简单。

为了理解 SMOTE 如何生成人工数据，最好认识到每个样本在特征空间中都有自己的表示。

我们用一个例子来演示一下 SMOTE。下面是一组由 2D 特征空间中的向量表示的虚构数据。红点代表少数阶级。

注意:大多数数据集通常有更高的维度。为了方便起见，我们使用了一个过于简化的 2D 特征空间。

2D 特征空间(由作者创建)

首先，SMOTE 识别来自少数类的数据点的 k 个最近邻(在这种情况下，k=3)。

2D 特征空间(由作者创建)

接下来，它在所有邻居之间的随机位置创建一个新点。这些新点表示属于少数类的人工数据。

2D 特征空间(由作者创建)

它将继续生成新数据，直到数据不平衡得到解决。

2D 特征空间(由作者创建)

缺点

SMOTE 补救不平衡的数据集，而不会带来欠采样或过采样带来的风险。然而，这种方法有其自身的局限性。

首先，当搜索少数类的邻居时，SMOTE 冒着包括其他类的风险。这将导致产生不能充分代表少数群体的数据。

其次，SMOTE 的算法用在高维数据上并不可靠。

自然，在大量的研究中已经解决了许多这些弱点，开发了 SMOTE 的不同变体。然而，这超出了本文的范围。

警告

照片由吴礼仁在 Unsplash 上拍摄

SMOTE 应仅用于增加训练数据。您的测试数据集应该保持不变。对整个数据集应用 SMOTE 将导致数据泄漏。

这也意味着用于评估模型的测试数据将由人工数据组成。这听起来可能是显而易见的，但是您希望评估您的模型的数据是真实的。否则，任何报告的评估指标都没有任何意义。

个案研究

这一次，让我们看看在真实数据上使用 SMOTE 是如何工作的。在这个演示中，我们使用一个提供客户信息的数据集(无版权保护)来构建一个模型，以确定他们是否对车辆保险感兴趣。在这里可以访问的原始数据。

下面，我们可以看到数据集中的变量。

代码输出(由作者创建)

目标标签是“响应”。

在任何模型建立之前，我们需要预处理原始数据。

快速计数显示了每个类中的记录数。

代码输出(由作者创建)

多数群体与少数群体的人数比例约为 5:1，这是数据不平衡的一个明显迹象。

首先，让我们建立一个随机森林模型，在没有 SMOTE 的情况下预测客户对车辆保险的兴趣。

我们将使用 f-1 评分标准评估该模型。

代码输出(由作者创建)

该模型的 f-1 分数为 0.44，有改进的余地。

接下来，我们将重复相同的过程，但是在添加人工数据之后。我们可以用 Python 中的 imblearn 模块的 SMOTE 来实现。

该模块允许我们在创建合成数据时具有一定的灵活性。你可以控制这样的事情:

  • 多数类样本数与少数类样本数的比率
  • SMOTE 针对的类别
  • 构建样本时要考虑的最近邻的数量

我们将坚持默认参数。这意味着该算法考虑 5 个最近的邻居，并将生成数据，直到少数样本的数量和多数样本的数量相同。

请注意 SMOTE 如何仅应用于训练组。如前所述，不要为测试集生成人工数据是非常重要的。

代码输出(由作者创建)

现在已经解决了训练数据中的数据不平衡问题。因此，让我们用这些数据构建一个随机森林分类器，看看它在测试集上的表现如何。

代码输出(由作者创建)

该模型的 f-1 得分为 0.52，证明与未经人工数据训练的模型相比，该模型能更好地预测客户对车辆保险的兴趣。

结论

照片由 Prateek Katyal 在 Unsplash 上拍摄

总而言之，SMOTE 的这个简要概述应该可以帮助您熟悉人工数据生成背后的逻辑及其在机器学习应用程序中的使用。

SMOTE 虽然非常适用，但也有其局限性和弊端。即使是现在，大量的研究和投资正被投入到探索新的变种中。

如果你感兴趣，你可以看看 smote-variants 包，它允许你实现 85 种不同的算法变体！

我祝你在数据科学的努力中好运！

参考

  1. 莫比乌斯。(2022).从不平衡的保险数据中学习，第 4 版。2022 年 1 月 22 日从 https://www.kaggle/arashnic/imbalanced-data-practice.取回

使用这些 R 包轻松创建美丽的情节

原文：https://towardsdatascience/create-beautiful-plots-easily-with-these-r-packages-bf2f278d479c

不费吹灰之力就能制作出优雅而专业的图表

图片作者。

目录

  1. 简介
  2. 包
    2.1gg map
    2.2gg pubr
    2.3拼凑
    2.4 ggforce
  3. 结论
  4. 参考文献

1.介绍

是一个强大的数据可视化 R 包。

遵循图形的语法，它将绘图定义为数据和:

  • 审美:颜色或大小等属性。
  • 几何图形:线条或条形物体。

该软件包以模块化的方式实现这些独立的组件，允许以优雅和灵活的方式创建几乎任何情节。

在本帖中，我们探索了四个 R 包，它们简化了基于ggplot2的高级绘图的生成。特别是:

  • ggmap为空间图形添加地理背景。
  • ggpubr生成用于发布的图表。
  • patchwork将独立的情节组合成相同的图形。
  • ggforce提供定制ggplot2图表和生成更专业的可视化的方法。

我们使用加州房价数据集，可以在 Kaggle 上免费获得(CC0⁴)。它包含了从 1990 年人口普查中得出的加州各区房价中值。

我们从导入所需的包开始:

library(tidyverse)
library(ggmap)
library(ggforce)
library(ggpubr)
library(patchwork)library(concaveman) # needed for hull geometry

它们可以通过在 R 控制台中键入install.packages("package_name")来安装。

tidyverse包含不同的包。其中，我们将使用:

  • dplyr和tibble用于数据操作。
  • readr加载 csv 文件。
  • ggplot2用于可视化。

让我们导入数据集，并对价格和收入变量应用简单的宁滨:

df <- 
  read_delim(file      = "C:/data/housing.csv",
    col_types = "dddddddddf",
    delim     = ",")# Create bins for income and house price
df <- df %>% 
  mutate(
    price_bin  = as.factor(ntile(median_house_value, 4)),
    income_bin = ntile(median_income, 4))

2.包装

2.1 ggmap

作者: 大卫·卡勒，哈雷·威克姆

当数据集包含空间信息时，观察地理环境中的变量会很有趣。

我们首先用ggplot2来表示latitude和longitude，并一瞥加州的形状:

df %>%
  ggplot(aes(x = longitude, y = latitude)) +
  geom_point()

图片作者。

ggmap ⁵使用了与ggplot2相同的分层语法来给情节添加地理背景。它允许轻松地包含静态地图，例如来自谷歌地图、 OpenStreetMap 或 Stamen 地图的静态地图。

我们只需要将Latitude和Longitude信息传递给qmplot ⁶函数，如下所示

df %>%
  qmplot(x    = longitude, 
         y    = latitude, 
         data = .)

图片作者。

我们可以根据房价应用颜色渐变:

df %>% 
  qmplot(x      = longitude, 
         y      = latitude, 
         data   = ., 
         colour = median_house_value, 
         legend = "topright") +
  scale_color_gradient("House Prices", 
                       low  = "blue",
                       high = "red")

图片作者。

我们可以过滤我们的坐标来探索特定的区域。比如我们可以观察萨克拉门托周边的房价(纬度:38.575764，经度:-121.478851):

df %>% 
  filter(between(longitude, -121.6, -121.3), 
         between(latitude, 38.4, 38.7)) %>%
  qmplot(x      = longitude, 
         y      = latitude, 
         data   = ., 
         colour = median_house_value, 
         size   = I(7), 
         alpha  = I(0.8), 
         legend = "topright") +
  scale_color_gradient("House Prices", 
                       low  = "blue", 
                       high = "red")

图片作者。

更多信息和例子可以在 here⁷.找到

2.2 ggpubr

作者: 阿尔布卡德尔

基本 ggplots 的定制和格式化需要更深入的语法知识和更高级的 R 技能。

⁸套餐有助于创造美丽的情节。它提供了易于使用的功能，为研究人员和 R 从业人员生成可供发布的图。简而言之，它是一个围绕着ggplot2的包装器，处理大部分复杂的情节定制。

例如，我们可以用一行代码生成一个格式良好的箱线图:

df %>%
 ggboxplot(x       = "income_bin", 
           y       = "median_house_value",
           fill    = "income_bin",
           palette = c("#2e00fa", "#a000bc", "#ca0086", "#e40058"))

图片作者。

该软件包允许向图表添加 p 值和显著性水平。在这个例子中，我们使用ggviolin ⁹创建了一个小提琴图，并添加了与stat_compare_means ⁰:的平均值比较

# Comparison between the Income groups
bin_comparisons <- list( c("1", "2"), 
                         c("2", "3"), 
                         c("3", "4"),
                         c("1", "3"),
                         c("2", "4"),
                         c("1", "4"))df %>%
 ggviolin(x          = "income_bin", 
          y          = "median_house_value", 
          title      = "Violin Plot",
          xlab       = "Income Levels",
          ylab       = "House Prices",
          fill       = "income_bin",
          alpha      = 0.8,
          palette    = c("#2e00fa","#a000bc","#ca0086","#e40058"),
          add        = "boxplot", 
          add.params = list(fill = "white")) +
  stat_compare_means(comparisons = bin_comparisons, 
                     label       = "p.signif") +
  stat_compare_means(label.y = 9000)

Violin 图类似于 box 图，只是它们也显示数据的核心概率密度。图片作者。

ggpubr提供几个函数，可轻松生成格式良好的图。密度图和直方图如下所示:

df %>%
  ggdensity(x       = "median_income",
            add     = "mean", 
            rug     = TRUE,
            color   = "price_bin", 
            fill    = "price_bin",
            title   = "Density plot",
            xlab    = "Income",
            ylab    = "Density",
            palette = c("#2e00fa", "#a000bc", "#ca0086", "#e40058")
   )

图片作者。

df %>%
  gghistogram(x       = "median_income",
              add     = "mean", 
              rug     = TRUE,
              color   = "price_bin", 
              fill    = "price_bin",
              title   = "Histogram plot",
              xlab    = "Income",
              ylab    = "Count",
              palette = c("#2e00fa","#a000bc","#ca0086","#e40058")
   )

图片作者。

我们甚至可以在一个页面上混合多个图，甚至可以通过ggarrange功能创建一个独特的图例:

p1 <- df %>%
  ggdensity(x       = "median_income", 
            add     = "mean", 
            rug     = TRUE,
            color   = "price_bin", 
            fill    = "price_bin",
            title   = "Density plot",
            xlab    = "Income",
            ylab    = "Density",
            palette =  c("#2e00fa","#a000bc","#ca0086","#e40058")
   )p2 <- df %>%
  gghistogram(x       = "median_income",
              add     = "mean", 
              rug     = TRUE,
              color   = "price_bin", 
              fill    = "price_bin",
              title   = "Histogram plot",
              xlab    = "Income",
              ylab    = "Count",
              palette = c("#2e00fa","#a000bc","#ca0086","#e40058")
   )ggarrange(p1, 
          p2, 
          labels = c("A", "B"),
          ncol   = 2
   )

图片作者。

官方文档包含更多信息和示例。

2.3 拼接

作者: 托马斯·林

patchwork允许轻松地将单独的ggplot2可视化组合到同一图形中。它还提供了数学运算符，可以更直观地操纵图形。

与前面的ggarrange示例类似，我们可以在同一个图形上混合两个图，如下所示:

p1 + p2

图片作者。

该软件包的最大优势在于直观和简单的 API 的完美结合，以及创建任意复杂的绘图组合的能力。以下是一些例子:

图片作者。

更多信息和例子可以在这里找到。

2.4 ggforce

作者: 托马斯·林

ggforce延伸ggplot2为构成专门地块提供设施。

在分享一些示例之前，我们创建了一个新的列，大约标识了一些著名的地点及其周边地区:

  • 洛杉矶(纬度:34.052235，经度:118.243683)
  • 圣何塞(纬度:37.335480，经度:121.893028)
  • 旧金山(纬度:37.773972，经度:122.431297)
  • 萨克拉门托(纬度:38.575764，经度:121.478851)
  • 圣地亚哥(纬度:32.715736，-117.161087)
  • 弗雷斯诺(纬度:36.746841，经度:119.772591)
  • 斯托克顿(纬度:37.961632，经度:121.275604)
df <- df %>% 
  mutate(area = case_when(
    between(longitude, -118.54, -117.94) 
     & between(latitude, 33.75, 34.35) ~ 'Los Angeles',
    between(longitude, -122.19, -121.59) 
     & between(latitude, 37.03, 37.63) ~ 'San Jose',
    between(longitude, -122.73, -122.13) 
     & between(latitude, 37.47, 38.07) ~ 'San Francisco',
    between(longitude, -121.77, -121.17) 
     & between(latitude, 38.27, 38.87) ~ 'Sacramento',
    between(longitude, -117.46, -116.86) 
     & between(latitude, 32.41, 33.01) ~ 'San Diego',
    between(longitude, -120.07, -119.47) 
     & between(latitude, 36.44, 37.04) ~ 'Fresno',
    between(longitude, -121.57, -120.97) 
     & between(latitude, 37.66, 38.26) ~ 'Stockton',
    TRUE ~ 'Other areas'
    )
  ) %>%
  mutate_if(is.character,as.factor)

我们观察结果:

df %>%
  filter(area != "Other areas") %>%
  ggplot(aes( x = longitude, y = latitude)) +
  geom_point()

图片作者。

ggforce提供不同的功能来高亮显示数据集。人们可以围绕具有不同形状的数据组画出轮廓:

  • 圆圈:geom_mark_circle()
  • 省略号:geom_mark_ellipse()
  • 矩形:geom_mark_rect()
  • 外壳(凸闭包):geom_mark_hull()

我们可以试着在地理区域周围画一个矩形:

df %>%
  filter(area != "Other areas") %>%
  ggplot(aes(x = longitude, y = latitude, color = area)) +
  geom_mark_rect(aes(fill = area), concavity=10) +
  geom_point()

图片作者。

我们可以尝试用geom_mark_hull()画更复杂的多边形。可以通过concavity参数调整最终船体的凹度:

df %>%
  filter(area != "Other areas") %>%
  ggplot(aes(x = longitude, y = latitude, color = area)) +
  geom_mark_hull(aes(fill = area), concavity=10) +
  geom_point()

图片作者。

可以向图上的组添加标签:

df %>%
  filter(area != "Other areas") %>%
  ggplot(aes(x = longitude, y = latitude, color = area)) +
  geom_mark_hull(aes(fill = area, label = area), concavity = 10) +
  geom_point()

图片作者。

我们也可以将图与来自ggmap的地理信息结合起来，如下所示:

df %>%
  filter(area != "Other areas") %>%
  qmplot(x = longitude, y = latitude, data = .) +
  geom_mark_hull(aes(fill  = area, label = area), concavity = 10) +
  geom_point()

图片作者。

更多信息和进一步的例子可以在这里找到⁵.

3.结论

r 是一个强大的数据分析和可视化工具。

在这篇文章中，我们的目标是而不是分享完整的数据分析工作或机器学习问题的解决方案。相反，我们想探索一些能够简化创建漂亮可视化的任务的包。

参考文档提供了更多示例和信息。

关于图形的语法和ggplot2背后的概念的更多见解，我们推荐 Hadley Wickham 的“gg plot 2——数据分析的优雅图形”。

4.参考

[1] Hadley Wickham，“ ggplot2 —用于数据分析的优雅图形”，Springer，2009 年(公共链接)。

[2]利兰·威尔金森，“图形的语法”，斯普林格，2005。

[3]https://www . ka ggle . com/datasets/camnugent/California-housing-prices

https://creativecommons/publicdomain/zero/1.0/

https://cran.r-project/package=ggmap

[6]https://www . rdocumentation . org/packages/gg map/versions/3 . 0 . 0/topics/QM plot

[7] David Kahle 和 Hadley Wickham， ggmap:用 ggplot2 实现空间可视化，《R Journal》第 5/1 卷，2013 年 6 月，链接。

https://cran.r-project/package=ggpubr

[9]https://www . rdocumentation . org/packages/gg pubr/versions/0 . 4 . 0/topics/gg violin

[10]https://www . rdocumentation . org/packages/gg pubr/versions/0 . 4 . 0/topics/stat _ compare _ means

https://rpkgs.datanovia/ggpubr/

https://cran.r-project/package=patchwork

[13]https://patchwork . data-imaginist . com/articles/guides/assembly . html

https://cran.r-project/package=ggforce

[15]https://ggforce.data-imaginist/

使用 BigQuery 统计聚集函数和 Looker 创建控制图

原文：https://towardsdatascience/create-control-charts-using-bigquery-statistical-aggregate-functions-and-looker-2808c14fc102

另一种监控 KPI 目标的方法

亨利&公司在 Unsplash 上拍摄的照片

检查图

统计

“一种图表，在其上绘制一个变量的观察值，通常对照该变量的预期值及其允许偏差，以便在质量、数量等方面的过度变化。变量的，可以被 检测到1

介绍

在我的本科学习期间，一门颇有见地的大学课程是“质量保证简介”。从本质上讲，这是另一个以不同名称包装的统计学课程，但旨在传授跟踪生产过程质量的技术和仪器知识。

其中， 控制图 就是这些工具之一，因为它们显示了以下内容:

  • 过程度量如何发展，
  • 如果工艺措施在预期控制范围内，
  • 应该改进哪些措施来提高生产过程质量。

换句话说，它们是过程图片，通过为观察测量设置以下元素来评估过程质量:

  • 中线 —测量的平均历史值，
  • 控制上限(UCL) —在中心线上方设置三个标准偏差 (+3σ)，以及
  • 控制下限(LCL) —在中心线以下设置三个标准偏差(-3σ)。

并且这三个要素易于计算，可用于跟踪各业务领域而不仅仅是生产领域的持续 KPI 的目标。

也就是说，这篇文章旨在展示控制图的实现方法，使用 BigQuery 统计聚合函数来计算标准偏差并找到 UCL 和 LCL 值。

此处介绍的工作是之前使用 BigQuery ML 和硬编码 Looker 方法设置 KPI 目标的后续工作:

与前一篇文章类似，数据将通过 Looker 实例进行建模和可视化。

我们开始吧。😃

用例解释

在过去的工作中，我们重点介绍了跟踪marketing costs、[cost revenue ratio](https://www.indeed/career-advice/career-development/cost-revenue-ratio#:~:text=What%20is%20a%20cost%20revenue,including%20marketing%20and%20shipping%20costs.)和[return on ad spend](https://www.klipfolio/metrics/marketing/return-on-ad-spend-roas)KPI 的方法。

现在，我们将关注[Cost per Order (CPO)](https://www.klipfolio/resources/kpi-examples/ecommerce/cost-per-order) KPI，并展示一种创建统计控制图以跟踪CPO值的方法。

在我们开始解释新开发之前，应该提到以下实施说明:

  • 从业务角度来看，Cost per order KPI 的未来值不应该偏离其历史值太多，这就是为什么用统计控制极限来监控其目标是可行的。
  • 多系列数据集将再次用于开发。
  • 开发的重点放在方法而不是数据集上，并且底层数据源不会被共享。

开发方法学

下图展示了 Looker 中控制图的数据建模和可视化的三步方法。

开发方法的分解[图片由作者提供]

第一步，我们将扩展现有的 LookML 视图，对CPO度量进行新的计算。在此步骤之后，我们将计算CPO控制上限和下限。最后，我们将可视化的见解，并提出了一个在 Looker 创建控制图的教程。

前两个步骤是为 Looker 开发者设计的，而最后一个步骤是为商业用户设计的。

步骤 1/3: LookML 建模:使用 CPO 计算扩展现有视图，并开发一个用于计算统计控制限值的新视图

第一步的任务很简单:

  • 用CPO计算扩展视图T2。
  • 创建一个新视图[cpo_targets](https://gist.github/CassandraOfTroy/6d375f59431d0a6bd579e00d33c26266)，用于计算统计控制上限和下限。

计算CPO的公式是实际绩效营销成本与观察时间段内创建的订单总数的比率:

measure: cost_per_order { 
  label: “CPO Actual” 
  description: “Cost per Order = PM Costs / Total Order Number”                          
  type: number 
  value_format_name: eur
  sql: ${pm_costs_actual}/NULLIF(${total_number_of_orders},0);; 
}

在我们创建了一个新的度量之后，接下来是从现有数据模型[marketing_control_charts](https://gist.github/CassandraOfTroy/494188438a739c098b3f8adefc72a5c6#file-marketing_control_charts-model)开发一个派生表视图。

我们将从模型中选择所需的维度和度量，并使用 BigQuery 统计函数创建一个派生列来计算CPO标准偏差。

新创建的视图的功能可以总结如下:

  • 我们使用了 STDDEV_SAMP 统计聚合函数，它返回值的样本(无偏)标准偏差。
  • 除了计算标准偏差之外，我们还计算了CPO平均值，从这两个测量值中，我们计算了 UCL 和 LCL 值。
  • 测量值cpo_lcl_2sigma和cpo_ucl_2sigma被计算以设置可能的CPO异常值的早期警报。

让我们进入下一步，展示如何用新的开发来扩展现有的数据模型。

步骤 2/3: LookML 建模:用新视图扩展现有的数据模型

在这一步，我们创建了一个新的数据模型版本，即[marketing_control_charts_v2](https://gist.github/CassandraOfTroy/d52fd4c87b662afe469d3c37cd3bc20b)，以显示旧模型[marketing_control_charts](https://gist.github/CassandraOfTroy/494188438a739c098b3f8adefc72a5c6#file-marketing_control_charts-model)之间的代码差异。

在新模型中，我们在两个视图上增加了一个join:

  • “旧”视图kpi_actual_vs_target——保存CPO实际值，以及
  • “新”视图cpo_target —包含CPO’s统计控制限值。

视图之间的连接是在序列标识符(shop_brand和marketing_shop_types)上创建的，而不是在date标识符上创建的，因为我们希望在不同的时间范围中灵活地观察统计控制限值和实际CPO值的变化。

有了这个解释，我们可以移动到最后一步。😃

第 3/3 步:观察者:创建控制图

见解展示环节终于开始了。利用之前开发的数据模型，业务用户可以探索 it 并创建控制图。

教程:

  • 选择过滤器:CPO Target Date、Order Date Date、Shop Brand。
  • 选择维度和度量:Order Date Date、Shop Brand、CPO Actual、CPO Average、CPO LCL、CPO UCL、CPO 2 sigma LCL、CPO 2 sigma UCL。
  • 选择Table (Report)可视化类型来呈现结果。

Looker:监控 CPO 值的控制图[图片由作者提供]

功能性:

  • 通过上述设置，我们可以在数据集中为的每个商店(系列)每天跟踪CPO，
  • 过滤器部分的两个日期，即CPO Target Date和Order Date Date，使我们能够跟踪CPO 目标日期的实际 CPO值不可知(统计控制限)。例如，我们可以将当月的实际CPO值与上个月或去年同月的目标CPO值进行比较。
  • 2 西格玛 UCL 和 LCL 经过计算，可用于及早提醒业务用户可能的CPO异常值。

结论

这个职位的目标可以总结如下:

  • 开发目标是展示使用 BigQuery 统计函数和 Looker 实例创建控制图的方法。
  • 业务目标是为跟踪 KPI 记分卡提供一个简单的框架**。**

总的来说,“大”目标是通过让最终用户尽早识别KPI 异常值来创造商业价值**。此外，提议的方法旨在减少采取行动的反应时间，以将 KPI 保持在控制范围内。**

带着这些笔记，我们结束我们的帖子。一如既往…编码快乐！😃

参考文献:

[1]柯林斯字典，访问时间:2022 年 6 月 11 日，https://www . Collins Dictionary . com/Dictionary/English/control-chart

在 R 图中创建自定义布局

原文：https://towardsdatascience/create-custom-layouts-in-your-r-plots-eb7488e6f19f

哈尔·盖特伍德在 Unsplash 上拍摄的照片

当绘制数据时，我们通常试图创建一个单独的图。但是，如果您想创建一组相关情节的单一呈现，该怎么做呢？在 r 中有许多方法可以做到这一点。在本文中，我将向您展示其中的三种，使用我在一些#TidyTuesday 提交中创建的示例。完整的代码可以在我的 github 页面上找到。

基本多情节

作者图片

创建多图的最基本方法之一是使用 par()函数和" mfrow = "属性。在这个项目中，我们有六种不同类型水果的尺寸数据。我决定为它们分别创建直方图，但是我想把它们都放在一个图表中。

我的第一次尝试如上图。这完全是用 base R 图形做的。这些图是简单的 hist()函数，注释是用 lines()和 text()函数创建的。

制作多图的关键是在创建任何图之前运行以下代码块:

par(mfrow = c(2,3))

这将屏幕分为两行和三列，每个图将按顺序逐行填充屏幕。如果您想回到单图模式，只需再次运行该功能，在结束时进行重置即可:

par(mfrow = c(1,1))

这使我们回到一行一列。

这个情节的完整代码在 https://github/dikbrown/TTGiantPumpkins/blob/main/EDA.R的

网格库

作者图片

对于这个#TidyTuesday 提交，我们只是被要求做一些映射。由于 WalletHub 最近刚刚发表了一篇关于美国多元化的文章，我决定看看我能利用这些数据做些什么。

该数据集包括六个主要类别的多样性排名，以及总体多样性排名。我决定为这些排名创建一个地图，其中“整体”多样性得分在顶部占据优先位置。

除了 ggplot2 和 usmap 库，我发现 grid 和 gridExtra 库在这里也很有帮助。这些库使您能够通过创建矩阵将屏幕分割成单独的窗口。

layout <- rbind(c(1, 2, 2, 2, 2, 3),
                c(1, 2, 2, 2, 2, 3),
                c(4, 4, 5, 5, 6, 6),
                c(7, 7, 8, 8, 9, 9))

由于刚刚创建的矩阵有四行六列，屏幕以同样的方式划分:

作者图片

但是，我们使用的数字允许我们定义哪些扇区将成为屏幕每个部分的一部分。例如，所有的“1”部分将组合成屏幕的一个部分，我们可以在那里放置一些东西。这将创建以下布局:

作者图片

现在我们有了布局，我们可以用 grid.arrange()函数把东西放进去。然而，我们只能放入某些类型的对象，例如图形对象(称为 grobs)或 ggplot 对象。如果我们只想在其中一个部分中放入文本，我们可以使用 textGrob()函数。上图中的线条是用 rectGrob()函数创建的。

textobj1 <- textGrob("This is some text.", gp = gpar(fontsize = 24), hjust = 1)
...
create some plots
...
grid.arrange(textobj1, plot1, textobj2, 
             plot2, plot3, plot4, plot5, plot6, plot7,
             layout_matrix = layout)

我们添加的不同对象将按照 grid.arrange()函数中指示的顺序进入上面的部分。因此，textobj1 进入第 1 部分，plot1 进入第 2 部分，以此类推。

我在本节开始创建地图的所有代码，以及布局图像，都可以在我的 GitHub 页面上找到，地址是https://github/dikbrown/TTMappingDiversity21

您可以在 https://bookdown/rdpeng/RProgDA/the-grid-package.html获得网格包的概述，并在https://stat . ethz . ch/R-manual/R-devel/library/grid/html/00 index . html找到文档

split.screen()

作者图片

split.screen()函数是 r 中基本图形包的一部分，用于将屏幕分割成不同的区域。此外，每个区域可以进一步划分成更小的区域(尽管这超出了本文的范围)。这种能力比前面提到的其他方法更加复杂。它也比其他任何一种方法更容易微调。我用这种方法重做了之前展示的巨型南瓜图片。

首先，我们创建一个布局，其方式类似于网格图形中的布局。然而，我们不是简单地标记不同的区域，而是使用布局矩阵来定义每个区域的边界。该矩阵将由四列组成。这些列表示 x1(左边缘)、x2(右边缘)、y1(下边缘)和 y2(上边缘)。对于要创建的每个区段，基准表中都有一行。以下是一些例子:

最简单的布局，只有一个部分:

layout <- matrix(c(0, 1, 0, 1),          # x1=0, x2=1, y1=0, y2=1
                  ncol = 4, byrow = TRUE)

作者图片

请注意，编号从左下方的(0，0)开始，正如您在笛卡尔坐标系中所期望的那样，右上角的坐标为(1，1)。

现在，假设您想将屏幕分成并排的两半。您可以使用:

layout <- matrix(c(0, 0.5, 0, 1,          # x1=0, x2=0.5, y1=0, y2=1
                   0.5, 1, 0, 1),         # x1=0.5, x2=1, y1=0, y2=1
                  ncol = 4, byrow = TRUE)

作者图片

相反，如果您想将屏幕分成上下两半，您可以使用以下布局:

layout <- matrix(c(0, 1, 0.5, 1,         # x1=0, x2=1, y1=0.5, y2=1
                   0, 1, 0, 0.5),        # x1=0, x2=1, y1=0, y2=0.5 
                  ncol = 4, byrow = TRUE)

作者图片

您应该意识到行的顺序不是固定的，但是跟踪它们的顺序是很重要的。例如，以下布局在质量上等同于第一个布局(即上半部分和下半部分):

layout <- matrix(c(0, 1, 0, 0.5,
                   0, 1, 0.5, 1),
                  ncol = 4, byrow = TRUE)

这里唯一的区别是，在第一个版本中，上半部分是第 1 部分，下半部分是第 2 部分，而在第二个版本中，情况正好相反。当你想把一些东西放在一个特定部分时，这就变得很重要了。出于这个原因，我强烈建议用注释标记这些行:

layout <- matrix(c(0, 1, 0.5, 1,          # top half
                   0, 1, 0, 0.5),         # bottom half
                  ncol = 4, byrow = TRUE)

或者

layout <- matrix(c(0, 1, 0, 0.5,        # bottom half
                   0, 1, 0.5, 1),       # top half
                  ncol = 4, byrow = TRUE)

让我们开始变得更好一点。让我们把顶部(2/3)做得比底部(1/3)大，而不是一模一样的两半

layout <- matrix(c(0, 1, 0.33, 1,        # top section
                   0, 1, 0, 0.33),       # bottom section
                  ncol = 4, byrow = TRUE)

我们还可以将屏幕垂直和水平分成两半:

layout <- matrix(c(0,   0.5, 0.5, 1,        # top-left section
                   0.5, 1,   0.5, 1,        # top-right section
                   0,   0.5, 0,   0.5,      # bottom-left section
                   0.5, 1,   0.5, 1),       # bottom-right section
                  ncol = 4, byrow = TRUE)

作者图片

为了创建本节开头所示的图，我决定要八个部分:六个部分用于六个图，顶部和底部的条用于额外的文本。标题和副标题在顶部，而引用信息(数据源和作者信息)在底部。通过这种方式，我可以非常简单地完全控制文本部分的格式。以下是我使用的布局:

layout <- matrix(c(0,    1,    0.9,  1,      #top strip for title
                   0,    0.33, 0.47, 0.9,    # row 1, plot 1
                   0.33, 0.67, 0.47, 0.9,    # row 1, plot 2
                   0.67, 1,    0.47, 0.9,    # row 1, plot 3
                   0,    0.33, 0.06, 0.47,   # row 2, plot 1
                   0.33, 0.67, 0.06, 0.47,   # row 2, plot 2
                   0.67, 1,    0.06, 0.47,   # row 2, plot 3
                   0,    1,    0,    0.04),  # bottom strip for citation
                 ncol = 4, byrow = TRUE)

总而言之，顶部的条代表屏幕的顶部 10%,底部的条代表屏幕的底部 4%。剩下的 86%的身高被一分为二(43%)，这就是我得出 0.47 的数值(0.04 + 0.43)的原因。然后我给每个图 1/3 的水平空间(因此 0.33 和 0.67 作为分界点)。

现在，要填充这些部分，您必须添加一些代码来告诉系统如何使用布局矩阵，并指示您的输出(绘图或文本)将去往何处。

# tell the system to use the layout matrix to split the screen
split.screen(layout)      

# screen(#) tells the system to put the upcoming output in section #
screen(1)                 
text("Overall title of plot", formatting parameters)

screen(2)  # use section 2: row 1, plot 1 from layout
hist(data, parameters)  # add a histogram to section 2 

...

screen(8)
text("Other text to be added", parameters)

# The next step is very important, or you will have 
# issues trying to re-run the code

close.screen(all = TRUE)

创建上述情节的完整代码位于https://github . com/dik brown/TTGiantPumpkins/blob/main/Distribution。R

值得注意的是，这些不同的技术并不总是相互兼容。你一定要阅读每个包装上的警告。例如，您会发现以下一些问题:

  1. split.screen()与其他排列地块的方法不兼容，如 par(mfrow)和 layout()。
  2. 网格图形和常规图形不一定能很好地配合。
  3. par(mfrow)函数根本不适用于 ggplot2 图形。但是，ggplot2 中的 geom_facet()函数会做一些类似的事情。

如果你觉得这篇文章有用，请关注我，看看我的其他文章，包括:

用 Python 创建数字全息图

原文：https://towardsdatascience/create-digital-holograms-in-python-with-holopy-eacacad989ae

用 HoloPy 探索数字全息图的世界——用于计算光散射和数字全息术的 python 包

为了看到全息图，前后移动你的头，聚焦在中心点上至少五次。它在桌面显示器或笔记本电脑上显示得更好。图片由作者提供，使用 Holopy。

全息图是用激光制作的一种特殊类型的图像，其中平面物体看起来是固体，就好像它们是真实的一样。随着计算机科学的最新进展，我们可以通过编程从一张图片中重建全息图，而无需使用物理技术(数字传感器、照相机、激光等)。)

似乎数字全息术意味着人类通信许多领域的未来。Meta 的首席执行官马克·扎克伯格解释了流入增强现实的巨额资金，并预测了全息图是其不可或缺的一部分的未来:

“在未来，你将能够坐在我的沙发上，或者我将能够坐在你的沙发上，而不只是通过电话来做这件事，这将实际上感觉我们在同一个地方，即使我们在不同的州或相距数百英里。我认为那真的很强大。”( BBC 新闻，2021 )。

此外，谷歌最近推出了项目 Starline ，一个类似全息图的视频聊天工具。想象一下，透过一个全息窗口，透过那个窗口，你看到的是另一个三维的人。你可以说话、做手势、眼神交流，就好像那个人就在你面前一样。Starline 项目目前只在谷歌的几个办公室可用，它依赖于定制的硬件，但我们可以预计它很快会扩展到标准的谷歌产品。

这篇文章属于这一类。它将为数字全息术提供非常实用的介绍，并介绍 HoloPy，一种基于 python 的处理数字全息图的工具。我们可以在舒适的办公室里编写全息图，而不是建造复杂的机器。

全息照相术:Python 环境中的数字全息术

HoloPy 是由哈佛大学马诺哈兰实验室打造的计算光散射和数字全息软件包。它提供了管理元数据、从 2D 图像重建全息图、将散射模型拟合到数字全息图以及许多其他应用的工具。

Barkley 等人(2020)在中详细描述了全息照相背后的理论。

全息图示例

我们用 HoloPy 准备一些简单的全息图。经过一些编辑，它们是从 HoloPy 文档中改编而来的。下面这段文字包括(a) python 实现和(b)创建高分辨率全息图。

你是怎么看到全息图的？

  1. 用鼠标缩小，直到图片变小
  2. 慢慢放大，直到隐藏的图案开始出现
  3. 当图像有正常尺寸时，来回移动头部几次，以查看更多新的隐藏动机。

全息图至少可以在 14ʺ大小的桌面显示器或笔记本电脑上清晰可见。下面是实现过程:

一个简单的代码产生一个灰度全息图:

全息图在台式显示器或笔记本电脑上显示得更好。图片由作者提供，使用 Holopy。

下一个例子是一个缺乏一些背景动机的单中心彩色全息图。这是 python 代码，后面是全息图像:

图片由作者提供，使用 Holopy。

Holopy 提供了不同的球体、颜色、参数和理论来重建全息图，进行散射计算，并根据数据拟合模型，这确实值得进行实验。

结论

这篇文章用 python 提供了一个数字全息术的实用介绍。全息图在其他领域也有许多应用。例如，在市场营销中， Tohana (2020) 和 Ardolf (2021) 强调了全息营销蓬勃发展的三个原因:

  • X-Factor–全息图具有突破噪音的独特方式
  • 可展示的体验的——它们提供了真实的生活体验
  • 难忘的–难忘的经历可以与朋友和家人分享。

数字全息是一门广泛的科学，其概述超出了本文的范围。该领域发展非常迅速，研究和创新在学术界和私营部门受到优先重视。一个激动人心的例子是苏塞克斯大学的科学家 T21 正在开发一种 3D 图像，它可以移动，重现声音，甚至模仿触觉。

所有这些进步看起来都很有希望。自然地，任何 3D 图像都会被拿来与星球大战全息图相比较。但是，目前的技术创造的图像仍然很小，远远没有达到照片级的真实感。然而，Gibney (2019)在《自然》杂志的一篇文章中持乐观态度，并引用了北京航空航天大学的琼的话:

“以任何方式创造《星球大战》中的那种 3D 效果可能需要十年，甚至更长时间”( 吉布尼，2019 )。

这些预测非常激动人心，值得期待。

PS:你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入https://medium/@petrkorab/membership。****

参考资料:

[1]阿尔多夫，M. (2021)。全息营销-数字营销的未来。2021 年 8 月 16 日。检索自:https://youdontneedwp . com/mathewardolf/hologram-marketing-the-future-of-digital-marketing。

[2] Barkley，s .，Dimiduk，t .，g .，Fung，j .，Kaz，d .，m .，Manoharan，v .，n .，McGorty，r .，Perry，r .，w .，Wang，A. (2020 年)。用 Python 和 HoloPy 实现全息显微术。科学中的计算&工程，第 22 卷，第 5 期。

[3] BBC 新闻(2021)。扎克伯格希望脸书成为网上的“元宇宙”。2021 年 7 月 23 日，英国广播公司新闻处。从https://www.bbc/news/technology-57942909取回。

[4]吉布尼，E. (2019)。由一粒泡沫创造的星球大战风格的 3D 图像。自然， 575，第 272–273 页。检索自:https://www.nature/articles/d41586-019-03454-y。

**[5]托哈纳，L. (2020)。全息图的优势及其对未来营销的意义。营销学院的未来，2020 年 9 月 23 日。检索自:https://futureofmarketinginstitute . com/advantages-of-holograms-and-it-means-for-the-future-of-marketing/。

使用 Julia 的 Unicode 绘图创建快速、通用的可视化效果

原文：https://towardsdatascience/create-fast-versatile-visualizations-with-julias-unicode-plots-8750bb7d7450

Julia 的 UnicodePlots.jl 包中令人敬畏的特性概述

(图片由作者提供)

介绍

在很多方面，那些从事更多计算领域和数据科学的人将自己与其他程序员区分开来。首先，我们通常不会一次性编译我们的工作。我们更希望有某种程度的互动，因为你需要从你的数据中获得持续的反馈，以便真正理解它。这当然也是笔记本这个创意的来源。然而，虽然这些笔记本电脑从表面上看是一个很好的解决方案，但它们也带来了一些挑战。

Jupyter 笔记本经常提到的一个重要问题是状态。许多人试图解决这一问题，像 Pluto.jl 这样的项目试图通过使环境对实际查看的代码更具反应性来缓解这些问题。另一个重要的问题是，Jupyter 内核的局限性很大，当达到极限时，有时会令人沮丧。一遍又一遍重启死内核很烦。

然而，这些笔记本电脑的一个非常大的好处是，数据科学家经常想要在网络浏览器中查看他们的输出。在某些情况下，这有点像试图在没有浏览器的情况下测试新的 JavaScript 网站，而试图在浏览器之外进行数据科学研究。至少，对于许多分析任务来说是这样的——更具体地说，是可视化。说到数据可视化，Julia 确实有一些相当健壮和有用的图形库，在大多数情况下，我已经在我的博客上查看了几乎所有的图形库。如果你想看看我过去写的故事的模块的比较，这里有一个文章的链接，我在这里做了一个概述，并对 Plots.jl 和 Vegalite.jl 这样的模块做了比较:

鉴于笔记本电脑存在的所有问题，大多数数据科学家可能已经考虑彻底抛弃它们。REPLs 虽然不是地球上最具可复制性的东西，但实际上工作得相当好——而且有一些 IDE 提供了数据科学家经常渴望的那种反应式编程，所以为什么不抛弃笔记本，尝试一些新的东西呢？今天，我们将在 Julia 中测试 REPL 的潜力，尝试使用一个名为 UnicodePlots.jl 的强大软件包将我们的数据可视化移回 REPL。除了强大之外，这些可视化对于那些可能会暂时或永久绑定到终端的人来说也非常有用。然而，以我的读者能够非常容易地复制我的代码(并在他们的 web 浏览器中查看输入/输出)的名义，我将在下面的例子中在笔记本中使用这个库。如果您想查看此笔记本，请点击以下链接:

https://github/emmettgb/Emmetts-DS-NoteBooks/blob/master/Julia/Unicode Plotting.ipynb

基础知识

UnicodePlots 的基础可能是您对大多数不以 Unicode 编码的图形库的期望。这很好，因为它增加了一种熟悉程度。此外，将方法和参数与 Julia 中的许多其他解决方案进行比较，我觉得 UnicodePlots 有许多更容易进行和阅读的调用。当然，这都是主观的——但我的观点是，作为一个有经验的可视化库用户，我非常喜欢 UnicodePlots 的界面设计方式。让我们为我们的绘图示例制作一些快速数组:

x = randn(500)
y = randn(500)

关于许多其他的 Julia 可视化库，我不喜欢的一点是，它们需要大量的工作来获得第一个图，此外，对于它们中的许多来说，“第一个图的时间”真的很长。当然，由于预编译的原因，这是大部分时间，Julia 通常需要编译几个后端，无论是 SDL、Cairo 还是其他，这肯定会增加为数据绘图所需的时间。然而，这些图是 unicode 的，所以这里唯一的可视化库是显示管理器或内核向我们显示的文本。结果，绘图真的很快。该库还关注简单的位置参数，但功能丰富的关键字参数—这在大多数软件情况下不是您想要的，但在绘图的情况下却是最佳的。

plot = lineplot(x, y,
               title = "Unicode Plot", xlabel = "x", ylabel = "y", border = :dotted)

作者图片

基本的线条画看起来确实很棒。这些图的可读性真的很好，因为有时你可能不希望它们像这样超级容易评估。更酷的是，如果你在电脑上，我可以把它粘贴到 Medium 上的一个文本框中，看起来太酷了！！！

⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀**Unicode Plot**⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀          ⡤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⠤⢤        3 ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⡀⠀⡜⣿⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠐⢤⣄⡀⠀⢀⠀⢢⢌⡢⣏⣲⣁⣧⢴⣿⣑⣄⣀⡠⢤⣴⢢⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠈⠪⡑⠺⣷⣖⣿⣿⣿⣷⣿⣿⡾⣿⣉⣹⣡⣜⣿⣾⣳⠬⢵⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠀⠀⢈⣵⣯⣾⡿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣋⣯⣟⣏⣉⣉⡩⠭⠶⠶⠒⠒⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠀⣀⣼⣻⣹⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣭⢤⣖⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⢀⣁⡠⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣿⣿⣿⡯⡿⣛⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸     y    ⡇⠤⠤⠤⠭⠷⠶⢼⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣽⣿⣿⣷⣤⠤⠤⠵⠤⡤⠤⠤⠤⠤⠤⠤⠤⢸          ⡇⠀⠀⠀⢀⠤⠤⡞⡾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣽⣍⣙⣍⣉⣉⣉⣀⣀⡀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠑⢤⡿⠶⣿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⣿⣗⠊⠑⠤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠀⡸⣣⣠⠴⢟⣻⣿⣿⡿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⡷⠌⠙⠉⠒⠚⠳⠄⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⣀⠝⠋⠉⠫⡡⣯⣿⣏⣯⣿⡿⣿⡿⠒⠻⣿⡾⠿⢏⠉⠞⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠘⠊⠉⠉⢩⠿⠛⢫⢋⡷⡟⠀⢀⢎⡧⠒⠉⠹⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠕⠁⠀⠀⠀⠚⠁⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸       -3 ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸          ⠓⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠚          ⠀-3⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀4⠀          ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀x⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀

你可能会想，与 unicode 相比，这样的东西在 ASCII 中是多么的可能。不管怎样，这看起来很棒。然而，正如您所料，这并不是 UnicodePlots 能够产生的唯一东西。

可变地块

这就是 Unicode 比许多其他绘图库更聪明的地方。库中的图实际上是可变的，这意味着我们可以在刚刚创建的这个新图中添加或删除元素。比如我们可以用线图！()方法来添加另一行:

lineplot!(plot, randn(500), randn(500), color = :blue)

作者图片

探索更多可视化

这可能令人惊讶，但是这个库实际上能够实现很多非常酷的可视化，例子包括

  • 散点图
  • 楼梯图
  • 条形图
  • 柱状图
  • 箱线图
  • 稀疏模式
  • 密度图
  • 热图图
  • 等值线图表
  • 表面图
  • 等值面图

没错，甚至还有 3D 图可用。虽然三维图是相当新的，它是相当令人印象深刻的，结果看起来相当可怕。下面是一个使用曲面图制作的示例:

sombrero(x, y) = 15sinc(√(x^2 + y^2) / π)
surfaceplot(-8:.5:8, -8:.5:8, sombrero, colormap=:jet, border=:dotted)

作者图片

还有非常酷的等值面图:

torus(x, y, z, r=0.2, R=0.5) = (√(x^2 + y^2) - R)^2 + z^2 - r^2
isosurface(-1:.1:1, -1:.1:1, -1:.1:1, torus, cull=true, zoom=2, elevation=50, border=:dotted)

作者图片

结论

jl 是一个非常棒的图形库，我怎么推荐都不为过。对于探索性分析，与调用真正的图形 API 绑定相比，使用类似 unicode 的东西进行绘图具有很多优势。性能和预编译可能是最大的。此外，我真的很喜欢这种方法，这种可变性，以及这个包的总体设计。

与 Julia 中的许多其他选项相比，UnicodePlots.jl 是一个显而易见的选项。我强烈建议把它捡起来，即使只是为了新奇。该库能够产生一些非常激进的可视化效果，在大多数情况下，我认为这些可视化效果会覆盖你！非常感谢您的阅读，我希望您考虑将此模块添加到您的朱利安科学计算团队中！

在 20 分钟内创建地理图像数据集

原文：https://towardsdatascience/create-geo-image-dataset-in-20-minutes-4c893c60b9e6

构建 LAION-5B 的地理特定子集

由丹尼斯·库默在 Unsplash 拍摄的照片

LAION-5B 简介

大规模人工智能开放网络(LAION)是一个非营利性组织，旨在向公众提供机器学习资源。最近，LAION 发布了一个从互联网收集的 58.5 亿个图文对的数据集。LAION-5B 数据集包含 URL、文本以及 KNN 索引。

KNN 索引为一个名为剪辑检索的搜索引擎提供动力，使用户能够交互式地探索 LAION-5B 数据集。剪辑检索提供了一个 anUI 和一个 API 来查询带有文本、图像或嵌入向量的 LAION。剪辑检索使得创建原始 LAION-5B 图像数据集的特定任务子集变得容易。

使用剪辑检索 UI 构建的 LAION 搜索网络界面

[ClipClient](https://github/rom1504/clip-retrieval/blob/main/notebook/clip-client-query-api.ipynb) API Example

先前关于介子子集的工作

LAION 数据集以及剪辑检索为生成特定领域的 LAION 子集提供了巨大的机会。这些领域特定的子集然后可以用于训练任务特定的模型。其他人已经探索了这种方法来创建以下子集-

LAION-Face 是 LAION-400M 的人脸子集，它由 5000 万个图文对组成。进行人脸检测是为了找到带有人脸的图像。LAION-Face 随后被用作 FaRL 的训练集，为人脸分析任务提供强大的预训练变压器骨干。

LAION Aesthetic 是 LAION-5B 的一个子集，已经通过在被判断为美学的图像的剪辑嵌入顶部训练的模型进行了估计。其预期目标是能够创建图像生成模型。

LAION 高分辨率是 LAION-5B 的一个> = 1024x1024 的子集，它有 170M 个样本。该数据集的预期用途是训练超分辨率模型。

里昂地理子集

鉴于 LAION 5B 中存在的规模和多样性，我们希望了解创建 geo 子集的可行性。地理子集可用于训练地理标记、地标检测等的模型。创建子集的流水线大致包括三个阶段，

  • 生成一组位置关键词
  • 使用剪辑检索 API 检索图像
  • 执行探索性分析

**位置关键词数据集:**为了获得高质量的位置关键词，我们利用 Instagram 的探索位置页面。为了构建概念验证，我们将位置关键字限制在美国>(纽约市)中城东部。然后使用 JavaScript 代码片段下载位置关键字。这给了我们 1096 个位置关键字的列表。

Instagram 位置探索页面

**使用 ClipClient 检索图像:**使用 clip-retrieval，我们可以为每个关键字检索图像。剪辑客户端有以下参数:

  • backend_url:后台的 url
  • indice_name:指定要使用的索引的名称
  • aesthetic_score:由审美检测器评定的审美分数
  • use_mclip:是否使用多语言版本的剪辑，默认为 False
  • aesthetic_weight:审美得分的权重
  • modality:在索引中搜索图像或文本
  • num_images:从 API 返回的图像数量
  • deduplicate:是否通过图像嵌入对结果进行去重，默认为真
  • use_safety_model:是否删除不安全图像，默认为真
  • use_violence_detector:是否删除暴力图片，默认为真

为了获得最相关的结果，我们对 clip 客户端使用以下配置:

剪辑客户端配置

例如，我们通过向关键字添加上下文来创建搜索字符串。从关键字’ grand central terminal '中，我们创建搜索字符串’grand central terminal in midtown east，united states '。我们遍历搜索字符串列表，为每个关键字检索多达 1000 张图片。

检索关键字的图像

**执行探索性分析:**从 clip 客户端检索所有位置关键字的图像后，我们目测检查一些结果，以执行基本的健全性检查。

中央车站的结果

我们在目视检查一些结果后进行探索性分析。对于 1096 个位置关键字，我们总共有 484，714 个图像，平均每个位置关键字有 513.47 个图像和 540.5 个图像的&中值。图片数量最多的前 20 个地点大多是餐馆。

数据集中的属性域分布高度倾斜。总共有44992 个域，但是数据集中所有图像的 37.88% 仅来自前 20 个域。

前 20 个域

结论和未来工作

我们构建了 LAION-5B 的美国中城东(纽约市)子集，并对数据集进行了探索性分析。该数据集可用于训练地理标记、地标检测模型。您可以通过运行 colab 笔记本中的代码来重现结果。

未来，我们计划扩展到美国的所有地理位置，通过比较现有地理模型的性能来验证结果，并发布带有验证分数的数据集。

如果你觉得我们的工作有帮助，请考虑引用

@article{LAION-geo,
  title={Create geo image dataset in 20 minutes},
  author={Bhat, Aaditya and Jain, Shrey},
  journal={Towards Data Science},
  year={2022},
  url={[https://towardsdatascience/create-geo-image-dataset-in-20-minutes-4c893c60b9e6](/create-geo-image-dataset-in-20-minutes-4c893c60b9e6)}
}

使用 TensorFlow 在 10 分钟内创建图像分类模型

原文：https://towardsdatascience/create-image-classification-models-with-tensorflow-in-10-minutes-d0caef7ca011

端到端教程—从数据准备到模型训练和评估

Anton Maksimov 5642.su 在 Unsplash 上的照片

机器学习生命周期是一个复杂的过程，涉及许多不同的部分，包括:

  • 预处理和数据清洗。
  • 寻找和建立正确的模型。
  • 测试和适当的评估。

本文将上述所有技术打包成一个简单的教程:

如果我对深度学习或 Tensorflow 一无所知，这就是我希望有人给我看的！

**先决条件:**你需要 Tensorflow 2.0+和几个库——Numpy、熊猫、 *Sklearn、*和 Matplotlib 。我们将使用 Tensorflow 中包含的时尚 MNIST[1] 数据集。

加载数据

数据集包含训练集中的 60，000 幅灰度图像和测试集中的 10，000 幅图像。每张图片代表属于 10 个类别之一的时尚单品。图 1 中给出了一个例子:

fashion_mnist = tf.keras.datasets.fashion_mnist(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()class_names={ 0: 'T-shirt/top',
              1: 'Trouser',
              2: 'Pullover',
              3: 'Dress',
              4: 'Coat',
              5: 'Sandal',
              6: 'Shirt',
              7: 'Sneaker',
              8: 'Bag',
              9: 'Ankle boot' }plt.figure(figsize=(10,10))
for i in range(25):
   plt.subplot(5,5,i+1)
   plt.xticks([])
   plt.yticks([])
   plt.imshow(train_images[i], cmap=plt.cm.binary)
   plt.xlabel(class_names[train_labels[i]])
plt.show()

图 1: 来自数据集的图像样本

我们的目标是建立一个模型，正确预测每个图像的标签/类别。于是，我们有了一个多类，分类问题。

培训/验证/测试分割

我们已经有了训练和测试数据集。我们保留 5%的训练数据集，我们称之为验证数据集。这用于超参数优化。

train_x, val_x, train_y, val_y = train_test_split(train_images, train_labels, stratify=train_labels, random_state=48, test_size=0.05)(test_x, test_y)=(test_images, test_labels)

像素重新缩放

由于图像是灰度，所有值都在0–255的范围内。我们除以 255 ，使像素值位于 0 和 1 之间。这是常态化的一种形式，以后会加快我们的训练进程。

# normalize to range 0-1
train_x = train_x / 255.0
val_x = val_x / 255.0
test_x = test_x / 255.0

目标值的一键编码

每个标签属于我们上面看到的 10 个类别中的一个。因此，目标值(y)取 0 到 9 之间的值。比如根据字典class_names ，，**，【0】，就是，【t 恤/上衣】，**的类。

让我们看看训练集中前 5 件衣服的目标值:

train_y[:5]
-> array([[2],                  (Pullover)
          [8],                  (Bag)
          [6],                  (Shirt)
          [1],                  (Trouser)
          [.3]], dtype=uint8).  (Dress)

然后，我们对它们进行一次性编码——将每个目标值分配给一个向量。对所有 y 数据集(训练、验证、测试)进行该过程。我们使用**to _ categorial()**函数:

train_y = to_categorical(train_y)
val_y = to_categorical(val_y)
test_y = to_categorical(test_y)

因此，前 5 件衣服的目标值变为:

array([[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],        
       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],        
       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],        
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],        
       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.]], dtype=float32)

概述

每个数据集存储为一个 Numpy 数组。让我们检查一下它们的尺寸:

print(train_x.shape)  #(57000, 28, 28)
print(train_y.shape)  #(57000, 10)
print(val_x.shape)    #(3000, 28, 28)
print(val_y.shape)    #(3000, 10)
print(test_x.shape)   #(10000, 28, 28)
print(test_y.shape)   #(10000, 10)

训练分类模型

现在，构建我们的模型的一切都准备好了:我们将使用两种类型的神经网络:经典的多层感知器 ( MLP )和卷积神经网络 ( CNN )。

多层感知器(MLP)

标准神经网络架构如图 1 中所示。具有至少一个隐藏层和非线性激活的 MLP 的行为类似于通用连续函数逼近器**。像所有的神经网络一样，它们基于**斯通-维尔斯特拉斯定理:****

E 定义在闭区间上的非常连续函数[ a ， b ]可以用一个多项式函数按所希望的那样一致逼近。

当然，神经网络的每一层都将输入的多项式表示投射到不同的空间。

图 1 :具有一个隐藏层的多层感知器[2]

接下来，让我们使用来自 Tensorflow 的 Keras API 来定义我们的模型。

model_mlp = Sequential()
model_mlp.add(Flatten(input_shape=(28, 28)))
model_mlp.add(Dense(350, activation='relu'))
model_mlp.add(Dense(10, activation='softmax'))print(model_mlp.summary())
model_mlppile(optimizer="adam",loss='categorical_crossentropy', metrics=['accuracy'])

你应该知道的是:

  • **网络结构:**每幅图像是28x28个像素。第一层将输入展平成一个28*28=784大小的向量。然后，我们添加一个有 350 个神经元的隐藏层。最后一层有 10 个神经元，一个用于我们数据集中的类。
  • **激活功能:**隐藏层使用标准 RELU 激活。最后一层使用 softmax 激活，因为我们有一个多类问题。
  • ****损失函数:我们的模型试图最小化的目标。由于我们有一个多类问题，我们使用categorical_crossentropy损失。
  • ****度量:在训练期间，我们监控准确性:即，我们正确分类的实例的百分比。
  • ****时期:模型在训练期间遍历整个数据集的次数。

这是我们网络的结构:

_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 flatten (Flatten)           (None, 784)               0         

 dense (Dense)               (None, 350)               274750    

 dense_1 (Dense)             (None, 10)                3510      
                                                               =================================================================
Total params: 278,260
Trainable params: 278,260
Non-trainable params: 0

尽管这是一个初学者友好的教程，但是有一个重要的特性你应该知道:

神经网络容易过度拟合:有可能从训练数据中学习得如此之好，以至于它们可能无法对新的(测试)数据进行归纳。

如果我们让网络无限地训练，过拟合最终会发生。由于我们无法确切知道神经网络需要多长时间才能开始过度拟合，我们使用一种称为 提前停止的机制。

提前停止 监控训练期间的确认损失。如果验证损失在指定的时期(称为耐心)内停止下降，训练立即停止。让我们在实现中使用它:

early_stop=EarlyStopping(monitor='val_loss', restore_best_weights= True, patience=5, verbose=1)callback = [early_stop]

最后，我们训练我们的模型:

history_mlp = model_mlp.fit(train_x, train_y, epochs=100, batch_size=32, validation_data=(val_x, val_y), callbacks=callback)

****图 2:MLP 模型的训练历史

对于这个简单的数据集，我们使用了大量的时段(100)来证明提前停止在时段 10 被激活，并恢复了最佳权重(具体来说，在时段 5)。

现在，这里最重要的指标是 损失 和 准确性 :让我们把它们形象化在一个图中。我们定义 plot_history 函数:

# define the function:
def plot_history(hs, epochs, metric):
    plt.rcParams['font.size'] = 16
    plt.figure(figsize=(10, 8))
    for label in hs:
        plt.plot(hs[label].history[metric], label='{0:s} train {1:s}'.format(label, metric), linewidth=2)
        plt.plot(hs[label].history['val_{0:s}'.format(metric)], label='{0:s} validation {1:s}'.format(label, metric), linewidth=2)
    plt.ylim((0, 1))
    plt.xlabel('Epochs')
    plt.ylabel('Loss' if metric=='loss' else 'Accuracy')
    plt.legend()
    plt.grid()
    plt.show()plot_history(hs={'MLP': history_mlp}, epochs=15, metric='loss')
plot_history( hs={'MLP': history_mlp}, epochs=15, metric='accuracy')

****图 3:MLP 的培训和验证损失

****图 4:MLP 的训练和验证精度

两个图都显示了度量标准的改进:损失减少了，而准确性提高了。

如果模型被训练了更多的时期，训练损失将继续减少，而验证损失将保持不变(甚至更糟，增加)。这将导致模型过度拟合。

最后，让我们检查培训、验证和测试集的准确性:

mlp_train_loss, mlp_train_acc = model_mlp.evaluate(train_x,  train_y, verbose=0)
print('\nTrain accuracy:', np.round(mlp_train_acc,3))mlp_val_loss, mlp_val_acc = model_mlp.evaluate(val_x,  val_y, verbose=0)
print('\nValidation accuracy:', np.round(mlp_val_acc,3))mlp_test_loss, mlp_test_acc = model_mlp.evaluate(test_x,  test_y, verbose=0)
print('\nTest accuracy:', np.round(mlp_test_acc,3)) #Output:#Train accuracy: 0.916
#Validation accuracy: 0.889
#Test accuracy: 0.866

测试精度约为 90%。此外，训练和验证/测试精度之间存在 2%的差异。

卷积神经网络

另一类神经网络是卷积神经网络**(或 CNN )。CNN 更适合图像分类。他们使用 滤镜 (也称为 内核 或 特征图 )帮助模型捕捉和学习图像的各种特征。 CNN 的通用架构如图 5**所示。****

这些过滤器不是静态的:它们是可训练的，这意味着模型在拟合期间以优化训练目标的方式学习它们。这与传统的计算机视觉相反，传统的计算机视觉使用静态过滤器进行特征提取。

此外，CNN 的深度至关重要。这是因为图像可以被视为一个层次结构，所以几层处理对这个领域有直观的意义。CNN 的第一层专注于提取底层特征(如边缘、角落)。随着深度的增加，特征地图学习更复杂的特征，例如形状和脸。

此外，在每个步骤中，信息在被传递到下一个过滤层之前经历“子采样“”。最后一个组件是一个全连接层**，它看起来像一个 MLP，但是没有隐藏层。**

****图 5:CNN 的顶层架构[3]

让我们深入研究一下实现。

首先，了解每个网络接受什么类型的输入至关重要。对于 MLPs，每个图像被展平成一个单独的28x28向量。这里，每个图像被表示为一个 3d 立方体，其尺寸28x28x1表示格式(宽度、高度、颜色通道)。如果我们的图像不是灰度的，尺寸将会是28x28x3。

我们仍然会像以前一样使用相同的激活和损失函数。此外，我们只执行一组过滤/特征映射和子采样。在 Keras API 中，这些分别被称为 Conv2D 和 MaxPooling2D 层:

model_cnn = Sequential()
model_cnn.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model_cnn.add(MaxPooling2D((2, 2)))
model_cnn.add(Flatten())
model_cnn.add(Dense(100, activation='relu'))
model_cnn.add(Dense(10, activation='softmax'))model_cnnpile(optimizer="adam", loss='categorical_crossentropy', metrics=['accuracy'])
print(model_cnn.summary())history_cnn= model_cnn.fit(train_x, train_y, epochs=100, batch_size=32, validation_data=(val_x, val_y), callbacks=callback)

输出是:

_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_3 (Conv2D)           (None, 26, 26, 32)        320       

 max_pooling2d_3 (MaxPooling  (None, 13, 13, 32)       0         
 2D)                                                             

 flatten_3 (Flatten)         (None, 5408)              0         

 dense_6 (Dense)             (None, 100)               540900    

 dense_7 (Dense)             (None, 10)                1010      

=================================================================
Total params: 542,230
Trainable params: 542,230
Non-trainable params: 0
_________________________________________________________________
Epoch 1/100
1782/1782 [==============================] - 19s 5ms/step - loss: 0.4063 - accuracy: 0.8581 - val_loss: 0.3240 - val_accuracy: 0.8913
Epoch 2/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.2781 - accuracy: 0.9001 - val_loss: 0.3096 - val_accuracy: 0.8883
Epoch 3/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.2343 - accuracy: 0.9138 - val_loss: 0.2621 - val_accuracy: 0.9057
Epoch 4/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.2025 - accuracy: 0.9259 - val_loss: 0.2497 - val_accuracy: 0.9080
Epoch 5/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.1763 - accuracy: 0.9349 - val_loss: 0.2252 - val_accuracy: 0.9200
Epoch 6/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.1533 - accuracy: 0.9437 - val_loss: 0.2303 - val_accuracy: 0.9250
Epoch 7/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.1308 - accuracy: 0.9516 - val_loss: 0.2447 - val_accuracy: 0.9140
Epoch 8/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.1152 - accuracy: 0.9573 - val_loss: 0.2504 - val_accuracy: 0.9213
Epoch 9/100
1782/1782 [==============================] - 9s 5ms/step - loss: 0.0968 - accuracy: 0.9644 - val_loss: 0.2930 - val_accuracy: 0.9133
Epoch 10/100
1779/1782 [============================>.] - ETA: 0s - loss: 0.0849 - accuracy: 0.9686Restoring model weights from the end of the best epoch: 5.
1782/1782 [==============================] - 9s 5ms/step - loss: 0.0849 - accuracy: 0.9686 - val_loss: 0.2866 - val_accuracy: 0.9187
Epoch 10: early stopping

同样，我们用 100 个历元初始化我们的模型。然而，10 个纪元足够训练了——直到提前停止开始。

让我们画出我们的训练和验证曲线。我们使用与之前相同的 plot_history 函数方法:

plot_history(hs={'CNN': history_cnn},epochs=10,metric='loss')
plot_history(hs={'CNN': history_cnn},epochs=10,metric='accuracy')

****图 6:CNN 的训练和验证损失

****图 7:CNN 的训练和验证精度

验证曲线遵循与 MLP 车型相同的模式。

最后，我们计算训练、验证和测试精度:

cnn_train_loss, cnn_train_acc = model_cnn.evaluate(train_x,  train_y, verbose=2)
print('\nTrain accuracy:', cnn_train_acc)cnn_val_loss, cnn_val_acc = model_cnn.evaluate(val_x,  val_y, verbose=2)
print('\nValidation accuracy:', cnn_val_acc)cnn_test_loss, cnn_test_acc = model_cnn.evaluate(test_x,  test_y, verbose=2)
print('\nTest accuracy:', cnn_test_acc)#Output:#Train accuracy: 0.938
#Validation accuracy: 0.91
#Test accuracy: 0.908

CNN 的模式胜过了 MLP 的模式。这是意料之中的，因为 CNN更适合图像分类。

结束语

  • 神经网络用于训练的优化函数是“随机”。这意味着，除了别的以外，每次你训练一个模型，你会得到稍微不同的结果。
  • 数据集很简单。首先，图像是灰度的，这意味着它们只有一个通道。彩色图像有 3 个通道(RGB)。
  • 即使我们使用了验证集，我们也没有执行任何超参数调优。在本教程的下一部分，我们将展示如何进一步优化我们的模型。

完整的例子可以在这里找到。

感谢您的阅读！

  • 订阅我的简讯！
  • 在 Linkedin 上关注我！
  • 加入介质 ！(附属链接)

参考

  1. 时尚 MNIST 数据集由 Zalando，https://www . ka ggle . com/datasets/Zalando-research/fashion mnist，麻省理工学院许可(MIT)版权【2017】
  2. By Glosser.ca —自己的作品，衍生文件:人工神经网络. svg，CC BY-SA 3.0，https://commons.wikimedia/w/index.php?curid=24913461
  3. By Aphex34 —自己的作品，CC BY-SA 4.0，https://commons.wikimedia/w/index.php?curid=45679374

使用 DCGAN 和 PyTorch 创建新动物

原文：https://towardsdatascience/create-new-animals-using-dcgan-with-pytorch-2ce47810ebd4

从野生动物身上学习特征来创造新的生物

图一。动物脸的 DCGAN。作者在 Unsplash 的帮助下创建的图像。

生成网络已经开辟了大量有趣的项目，人们可以用深度学习来做这些项目——其中一项是基于一组逼真的照片生成图像。我们在之前的文章中可以看到，一个非常简单的 GAN 网络在生成数字上可以有很好的效果；但是如果我们有一个更复杂的数据集，比如一群野生动物，会怎么样呢？阿甘看到狐狸、老虎、狮子在一起会产生什么？在本教程中，让我们使用 PyTorch 构建这个实验并找出答案。

边注:本文假设生成性敌对网络的先验知识。请参考之前的 文章 了解更多关于 GANs 的信息。

PyTorch 的 DCGAN

为了测试这一点，我们将需要创建一个更复杂的 GAN，最好是一个 DCGAN，其中我们为这一代涉及了卷积。卷积使它们非常适合学习图像表示。该架构比我们之前构建的 GAN 的 FC 层复杂得多，因为我们必须在生成阶段加入转置卷积。幸运的是，PyTorch 提供了一个非常深入的 教程 自己在创建一个可行的生成器和鉴别器，所以我们将直接使用它的架构如下:

动物面孔数据集

Choi 等人的动物面孔数据集(afhq) 首次在他们的论文 StarGAN 中介绍，可以在 Kaggle 上找到，野生动物文件夹将直接满足我们在数据集中拥有多个动物的需求。然而，这些图像具有相当高的分辨率(512x512)，对于使用 CPU 或不太好的 GPU 进行训练来说可能不可行。因此，我们对 64x64 的维度执行额外的自适应平均池。这也符合用于生成的默认 DCGAN 的原始尺寸。以下是数据集创建的代码:

实施环境

虽然 CPU 的训练时间可能要长得多，但我已经在免费版本的 Google Colab 上测试了整个管道，GPU 应该足以执行我们的实验。但是，这需要您将整个数据集放到 Google Drive 上，并将其安装到 Colab 笔记本上。

培养

DCGAN 的训练与普通 GAN 的训练相同。本质上，我们试图玩一个极大极小游戏，试图鼓励鉴别者确定一个图像是真实的还是生成的，同时鼓励生成者愚弄鉴别者。以下是 DCGAN 的代码:

可视化

我们在 30 和 100 个时期后绘制一些随机生成的结果。

30 个时期后:

100 个时期后:

从粗糙的补丁开始，网络似乎通过越来越多的时代逐渐学会了动物的精细表示，并开始生成“动物”，这些“动物”类似于确切有助于成为生物的东西，尽管不知道我们输入的动物的标签或类型！

结论

所以你有它！希望这篇文章提供了如何自己构建 DCGAN 的概述。你甚至可以应用不同的数据集，生成完全不同的东西，比如汽车、飞机，甚至梵高的画！(记住，如果你没有太多的 GPU 资源，一定要平均使用它！).

完整的实现可以在下面的 Github 资源库中找到:

https://github/ttchengab/MnistGAN

感谢您坚持到现在🙏*！* 我会在计算机视觉/深度学习的不同领域发布更多内容，所以 加入并订阅 如果你有兴趣了解更多！

使用 Hex 创建可观察和可复制的笔记本

原文：https://towardsdatascience/create-observable-and-reproducible-notebooks-with-hex-460e75818a09

如何将笔记本电脑集成到您的数据管道中

动机

Jupyter Notebook 是数据科学家探索和处理数据的流行工具，因为它易于检查代码输出。

然而，Jupyter 笔记本有几个缺点，包括:

  • 可解释性问题:随着代码变大，单元之间的关系变得越来越复杂。因此，当一个单元格发生变化时，很难知道接下来要执行哪个单元格。
  • **再现性问题:**因为笔记本中的单元格可以以任何顺序执行，所以以不同的顺序执行同一个笔记本可能会导致不同的输出。
  • **版本问题:**很难用 Git 比较一个笔记本两个不同版本的变化。

幸运的是，所有这些问题都可以用 Hex 笔记本解决。Hex 允许您通过依赖关系链接单元，并只执行依赖关系发生变化的单元。

作者图片

在本文中，您将了解 Hex 的一些有用特性，以及如何使用 Prefect 将它集成到您的数据管道中。

作者图片

通过使用 Hex 笔记本来查询和可视化您的管道的最终输出，您团队中的数据分析师不再需要通过管道来分析数据。

免责声明:我与 Hex 没有任何关系。我在工作中发现了 Hex，并写下了它，因为我发现它很有用。

什么是 Hex？

Hex 是一个现代化的数据工作空间，可以轻松连接数据并创建可复制的笔记本。

Hex 提供了很多很酷的特性，但是我喜欢 Hex，因为它使我能够:

  • 轻松连接到数据源
  • 使用 SQL 和 Python 来分析数据
  • 理解细胞之间的关系
  • 仅当单元的依赖关系发生变化时才重新执行单元
  • 给笔记本版本
  • 创建动态报告

让我们在接下来的几节中探索这些特性。

轻松连接到数据源

Hex 允许您通过几个简单的步骤连接到各种数据源。

作者图片

添加数据连接后，您只需从下拉列表中选择即可在笔记本的任何单元格中访问它。

作者图片

使用 SQL 和 Python 来分析数据

Hex 还允许您在一个笔记本中同时使用 SQL 和 Python。

在下面的截图中，有一个 SQL 单元和一个 Python 单元。SQL 单元(segmented)创建的输出随后被用于 Python 单元。

作者图片

这对于那些想在同一个笔记本中同时使用 SQL 和 Python 的人来说很方便。

理解细胞之间的关系

如前所述，在 Jupyter 笔记本中很难找到单元格之间的关系。

Hex 使得用图形视图观察单元之间的关系变得容易。

下面的 GIF 显示了一个十六进制笔记本的图形视图。每个节点代表一个单元。每条边显示单元格之间的依赖关系。

作者图片

仅当单元的依赖关系发生变化时才重新执行单元

当输入改变时，Hex 将自动只重新运行使用该输入的单元格。

因此，您不再需要花费时间寻找执行的单元，或者花费资源运行不相关的单元。

笔记本也是可复制的,因为一个变化将通过图表触发一个可预测的、一致的重新计算集。

作者图片

版本笔记本

给 Jupyter 笔记本版本总是一件痛苦的事。使用 Hex，您可以比较同一工作区中笔记本版本之间的差异。

作者图片

创建动态报告

使用 Hex，您可以创建一个带有内置小部件的动态报告，比如下拉菜单、复选框、按钮、日期、多选、数字和滑块。

作者图片

在下面的 GIF 中，我使用 dropdown 小部件根据选择的值更新绘图。

作者图片

Hex 还允许你通过一个漂亮的 GUI 创建一个简单的图表。

作者图片

如果你想向 CEO 或利益相关者展示你的见解，你可能想隐藏代码。要仅查看笔记本的输出，请从笔记本顶部的逻辑模式切换到应用模式。

作者图片

现在您将看到一个没有代码的漂亮报告。

作者图片

如何将 Hex 集成到您的数据管道中

现在我们知道了 Hex 有多有用，让我们将它集成到我们的数据管道中。我们将使用 Hex 笔记本从数据的最终输出中获得洞察力。

作者图片

您可以在此处找到此数据管道的代码:

https://github/khuyentran1401/customer_segmentation/tree/prefect2

概观

我们将使用perfect来观察和编排我们的数据管道。Prefect 是一个开源库，允许您编排和观察 Python 中定义的数据管道。

https://medium/the-prefect-blog/orchestrate-your-data-science-project-with-prefect-2-0-4118418fd7ce

管道中有四种流量:process_data、segment和run_notebook。这些流程的详细信息:

  • process_data :从 Postgres SQL 数据库中提取原始数据，进行处理，并将处理后的数据保存到数据库中
  • 段 :从数据库中提取处理后的数据，训练一个 ML 模型，并将最终数据保存到数据库中
  • run_notebook :运行 Hex notebook，它将从数据库中提取数据，并运行依赖关系发生变化的单元格
  • main :运行上面列出的所有三种流量

在下一节中，我们将更深入地研究run_notebook流程。

用提督运行十六进制笔记本

我们将使用perfect-hex库在一个 perfect 流中运行一个 Hex 笔记本。要安装此库，请键入:

pip install prefect-hex

要访问特定的 Hex 笔记本，您需要项目 ID 和令牌。获得凭证后，您可以通过从prefect_hex.project调用get_project_runs函数在 Python 脚本中运行笔记本。

from prefect import flow
from prefect_hex import HexCredentials

from prefect_hex.project import get_project_runs
from prefect_hex import HexCredentials

@flow
def run_notebook():
    hex_credentials = HexCredentials(token="your-token")
    project_id = 'your-project-id'
    return get_project_runs(
        project_id=project_id,
        hex_credentials=hex_credentials,
    )

if __name__ == "__main__":
    run_notebook()

就是这样！现在，当输入数据改变并且管道重新运行时，报告将被更新。

作者图片

使用完美的 UI，您还可以观察到流程的所有组件。

作者图片

结论

我希望这篇文章能给你建立一个可观察和可复制的管道所需的知识。

总而言之，提督和十六进制的结合:

  • 允许数据工程师协调和观察管道
  • 允许数据分析师专注于分析笔记本电脑中的数据

多酷啊。

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

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

本文标签： 中文翻译一百一十博客TowardsDataScience

版权声明：本文标题：TowardsDataScience 博客中文翻译 2022（一百一十一） 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：https://www.elefans.com/dianzi/1729413679a1200127.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。