TowardsDataScience 博客中文翻译 2021（三百二十六）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

TensorFlow 和 PyTorch 的 Conda 指南

原文：https://towardsdatascience.com/guide-to-conda-for-tensorflow-and-pytorch-db69585e32b8?source=collection_archive---------4-----------------------

了解如何为不同版本的 CUDA、TensorFlow 和 PyTorch 设置 anaconda 环境

维多利亚博物馆在 Unsplash 上拍摄的照片

真的很遗憾，大多数人对深度学习的第一次体验是不得不花几天时间试图找出为什么他们从 GitHub 下载的模型就是…不能…运行…

当试图运行现成的模型时，依赖性问题非常普遍。其中最大的问题是需要为 TensorFlow 安装正确版本的 CUDA。TensorFlow 多年来一直很突出，这意味着即使是新发布的模型也可以使用旧版本的 TensorFlow。除了感觉 TensorFlow 的每个版本都需要一个特定版本的 CUDA，而其他任何版本都不兼容之外，这不是一个问题。可悲的是，在同一台机器上安装多个版本的 CUDA 真的很痛苦！

TensorFlow CUDA 版本匹配

经过多年的头痛，感谢 Anaconda 的帮助，我终于意识到安装 TensorFlow 和正确的 CUDA 版本可以像下面这样简单:

conda create --name tf
conda activate tf
conda install tensorflow-gpu

Conda 与 pip 虚拟环境

由于对pip和conda之间的区别理解错误，我之前只用过pip。真的只是知道pip是“官方”的 Python 包管理器。

两者之间的主要区别是conda环境不仅仅是针对 Python 包的。像 CUDA 这样的库可以安装在您的隔离环境中。另一方面，有些包在conda中不存在，你必须通过pip安装它们，这是人们可能会偏离conda的一个原因。同时使用conda和pip有时会很棘手，但是我会在这篇文章的后面提供一些技巧来解决这个问题。

如果您想开始使用conda，请遵循链接中的 anaconda 安装说明。在pip和conda之间，创建、激活和删除环境的基本命令非常相似。

创造环境

*# pip* virtualenv env_name*# conda* conda create --name env_name

激活环境

*# pip* source /path/to/env_name/bin/activate*# conda* conda activate env_name

注意:安装 anaconda 后，它会自动创建并激活一个基础环境。建议您自己创建新环境。使用以下命令关闭自动激活:

conda config --set auto_activate_base false

删除环境

*# pip* cd /path/to/env_name
rm -rf env_name*# conda* conda env remove -n env_name

例子

下面是一些如何加载存在于五十一模型动物园中的 TensorFlow 和 PyTorch 模型的例子。 FiftyOne 是一款开源工具，用于机器学习工程师以一种易于修改、可视化和分析的方式存储他们的数据、标签和模型预测。包含在51中的是一个计算机视觉模型的动物园，它们只有一行代码，将用于轻松测试我们的conda环境设置。

第五十一模型动物园中的模型子集(图片由作者提供)

注:安装带 GPU 功能的 TensorFlow 需要支持 CUDA 的卡。这里是一个支持 CUDA 的 GPU 列表。

使用 Tensorflow 2。x 型号

conda create --name tf2
conda activate tf2
conda install tensorflow-gpu

FiftyOne 支持各种格式的图像和视频数据集。在这些例子中，我只有一个图像目录，我将把它加载到 FiftyOne 来生成模型预测。如果您传入/path/to/dataset并指定您使用的数据集类型为fiftone.types.ImageDirectory，那么您可以使用自己的图像目录。

这个例子中的大部分工作，我使用的是51 命令行界面(CLI) 。

pip install fiftyone*# Create a dataset from the given data on disk*
fiftyone datasets create \
    --name my_dataset \
    --dataset-dir /path/to/dataset \
    --type fiftyone.types.ImageDirectory

我可以下载我想要使用的模型，然后检查它是否满足要求。

*# Download a model from the zoo* fiftyone zoo models download centernet-hg104-512-coco-tf2*# Ensure you installed all requirements* fiftyone zoo models requirements \
    --ensure centernet-hg104-512-coco-tf2*# This model is from the TF2 Model Zoo which must be installed*
eta install models

然后，我会将该模型应用到数据集，以生成预测并在 FiftyOne 应用程序中可视化它们。

*# Apply a model from the zoo to your dataset*
fiftyone zoo models apply \
    centernet-hg104-512-coco-tf2 \  
    my_dataset \                    
    predictions *# Launch the FiftyOne App to visualize your dataset*
fiftyone app launch my_dataset

查看带有来自 centernet-Hg 104–512-coco-tf2 的预测的数据集(图片由作者提供)

使用 TensorFlow 1。x 型号

conda create --name tf1
conda activate tf1

您可以搜索可用的软件包，然后选择要安装的 TensorFlow 版本。这将在您的conda环境中安装相应的 CUDA 版本。

conda search tensorflow-gpu
conda install tensorflow-gpu=1.15

除了使用 TensorFlow 1 的模型之外，我将使用与 TensorFlow 2 示例中相同的过程。

pip install fiftyone*# Download a model from the zoo* fiftyone zoo models download mask-rcnn-resnet101-atrous-coco-tf*# Create a dataset from the given data on disk*
fiftyone datasets create \
    --name my_dataset \
    --dataset-dir /path/to/dataset \
    --type fiftyone.types.ImageDirectory*# Apply a model from the zoo to your dataset*
fiftyone zoo models apply \
    --error-level 1 \
    mask-rcnn-resnet101-atrous-coco-tf \     
    my_dataset \                              
    predictions *# Launch the FiftyOne App to visualize your dataset*
fiftyone app launch my_dataset

查看带有 mask-rcnn-resnet 101-atrous-coco-TF 预测的数据集(图片由作者提供)

使用 PyTorch 模型

安装 PyTorch 稍微容易一点，因为它是用多个版本的 CUDA 编译的。这给了我们使用任何版本 CUDA 的自由。撰写本文时(2021 年 1 月)的默认安装说明推荐 CUDA 10.2，但 PyTorch 有一个 CUDA 11 兼容版本。

conda create --name pyt
conda activate pyt
conda install pytorch torchvision torchaudio cudatoolkit=10.2 \
    -c pytorchpip install fiftyone

对于这个例子，我将使用 Python API 来执行与我们之前使用命令行几乎相同的步骤。唯一的区别是我们使用的模型，我们正在从51 数据集动物园加载数据集。

查看来自 key point-rcnn-resnet 50-fpn-coco-torch 的带有预测的数据集(图片由作者提供)

注意:如果你用的是 Mac，需要 GPU 支持，从源码安装 PyTorch。

常见问题

当我从pip切换到conda时，出现了三个问题，这需要一点时间来解决。

1) Pip 可以在 conda 内部运行

如果您想要使用的包只存在于pip中，您可以使用pip将其安装在您的conda环境中。然而，pip和conda 在一起并不总是打得好。

主要问题是conda不能控制它没有安装的包。因此，如果在conda环境中使用pip，那么conda不会意识到这些变化，可能会破坏环境。

当一起使用pip和conda时，请遵循张克帆·赫尔默斯的提示:

• 千万不要在 **pip**后使用 **conda** 。用conda安装你能安装的所有东西，然后用pip安装剩余的软件包
• 创造新的conda环境。使用pip会导致环境崩溃，所以在安装pip包之前，一定要创建一个新的隔离的conda环境。
• 如果你在使用了pip之后需要安装一个conda包，最好是创建一个新的环境，并按照正确的顺序重新安装所有的东西。

2)康达环境并不是全球孤立的

创建pip虚拟环境时的默认行为是，在新环境中，您不能访问全局安装的pip包。如果您想要访问全局包，您需要使用以下内容初始化您的虚拟环境:

virtualenv env --system-site-packages

另一方面，conda允许您默认访问全局系统软件包。如果您希望环境与这些全局包完全隔离，就像使用pip一样，您可以基于一个空的 pip virtualenv 的克隆来创建conda 环境。

virtualenv empty_env
conda create -n env --clone empty_env

理想情况下，你应该避免安装全局pip包，所以这不应该是一个问题。

3)需要指定 CUDA 路径

如果您在系统范围内安装了 CUDA，那么在您的conda环境中安装 CUDA 后，LD_LIBRARY_PATH环境变量可能会指向错误的位置。

要解决这个问题，当您进入您的conda环境时，您需要更新LD_LIBRARY_PATH以指向在conda中包含cuda的目录(通常该目录是/path/to/conda/pkgs/)。然后，当您离开conda环境时，您会希望将它指向 CUDA 的系统级安装。

首先，导航到您的conda环境位置并创建以下文件和文件夹:

cd /path/to/anaconda/envs/my_env
mkdir -p ./etc/conda/activate.d
mkdir -p ./etc/conda/deactivate.d
touch ./etc/conda/activate.d/env_vars.sh
touch ./etc/conda/deactivate.d/env_vars.sh

在activate.d/env_vars.sh中添加以下几行。用在您的conda环境中安装 CUDA 的路径替换/your/path。

#!/bin/bashexport OLD_LD_LIBRARY_PATH=${LD_LIBRARY_PATH}
export LD_LIBRARY_PATH=/your/path:${LD_LIBRARY_PATH}

一般来说，这个/your/path应该是这样的:

export LD_LIBRARY_PATH=/home/user/conda/pkgs/cudatoolkit-10.2/lib:${LD_LIBRARY_PATH}

然后在deactivate.d/env_vars.sh中添加以下几行:

#!/bin/bashexport LD_LIBRARY_PATH=${OLD_LD_LIBRARY_PATH}
unset OLD_LD_LIBRARY_PATH

摘要

用conda只用几个命令就能安装非 Python 包，比如 CUDA，这简直是天赐之物。结合使用conda和51 模型动物园意味着你可以在几分钟内从几十个模型中生成预测。然而，如果您没有做好准备，从pip虚拟环境切换到conda环境可能会导致一些意想不到的行为。

在 Veusz 中创建科学地块的指南

原文：https://towardsdatascience.com/guide-to-creating-scientific-plots-in-veusz-cb843e68bd59?source=collection_archive---------31-----------------------

实践教程

为 Veusz 的专业和学术期刊创建图表的综合指南。

由迪诺·瑞奇穆斯在 Unsplash 上拍摄的照片

eusz 是一个图形程序，旨在为学术和专业期刊制作出版就绪的图形。它是免费提供的，并与 Python 很好地集成在一起。凭借创建 2D 和 3D 图形的强大能力，Veusz 帮助研究人员可视化他们在社会科学、工程、生物、医学等领域使用的所有类型的数据结构。

在学术期刊中，编辑需要高度发展的图表，但是一些统计程序并不能提供高质量的图表在像样的期刊上发表。Veusz 是一个简单而强大的工具，用于准备高质量的图形，研究人员可以使用它来可视化他们的结果。尽管有这些好处，但数据科学家和研究人员似乎并没有很好地意识到 Veusz 提供的所有可能性。因此，这篇文章表明:

• Veusz 工作空间简介
• 一些不太常见的图表示例
• 与其他程序相比，使用 Veusz 的好处。

最后，我还将提到用户在使用该程序时会发现的一些缺点。

Veusz 工作空间

Veusz 允许以三种方式格式化图表:

• 在 Veusz GUI 中手动格式化
• 命令行
• 用作 Python 模块。

手动格式化包括导入数据和手动编辑图表以构建 2D 或 3D 产品。在 Veusz 中，通过构建绘图小部件、特定元素(图表、轴、文本标签等)来创建绘图。)用户在编辑窗口中添加或移除。小部件的属性在属性窗口中编辑，它们的外观和形式(字体、轴线颜色、标签颜色等。)在格式化窗口中。

以下是 Veusz GUI 的外观:

来源:自己的工作与一个 Veusz 的例子。

命令行界面

控制 Veusz 的另一种方法是通过它的命令行界面。因为 Veusz 是用 Python 编程的，所以它使用 Python 作为它的脚本语言。因此，您可以在命令行中自由混合使用 Veusz 和 Python 命令。当命令在 Veusz 窗口的命令提示符中输入时，它支持简化的命令语法，其中命令名称后面的括号可以由 Veusz 命令中的空格替换。

Veusz 还可以从文件中读取 Python 脚本。NumPy 包已经导入到命令行界面中。

用作 Python 模块

Veusz 可以用作绘制数据的 Python 模块。因此，标准 python 库(如 Matpotlib、Seaborn 或 Plotly)又多了一个竞争对手。例如，这段代码构建了一个简单的 x 平方图，它变成了 x 立方图(引用自官方文档):

**import** **veusz.embed** **as** **veusz**
**import** **time***#  open a new window and return a new Embedded object*
embed = veusz.Embedded('window title')*#  make a new page, but adding a page widget to the root widget*
page = embed.Root.Add('page')*#  add a new graph widget to the page*
graph = page.Add('graph')*#  add a function widget to the graph.*
function = graph.Add('function', function='x**2')function.function.val = 'x**3'

图形导出可能包括 TIFF 格式和其他标准格式(JPG、PNG 和其他几种格式)。

维尤兹的精彩剧情

三维绘图

与其他一些图形软件包相比，Veusz 最大的竞争优势可能是它能够绘制复杂的 3D 图形。让我们用一个简单的例子来演示一下。

K-means 聚类算法通常用于将客户群聚类为具有相似特征的离散客户组。类似地，它可以将国家、家庭或其他单位聚集成更一致的组。聚类通常出现在 2D 散点图中。为了让它更有趣，我添加了 Z- 轴，其中包含了回答者的年龄。

Veusz 提供了输出数据的出色的 3D 可视化。作为一个例子，我使用的是商场客户细分数据集，该数据集可从 Kaggle 免费获得，用于学习目的:

https://www.kaggle.com/vjchoudhary7/customer-segmentation-tutorial-in-python

彩色 3D 散点图显示:

• 客户在 X- 轴上的消费得分
• Y- 轴上的客户年收入
• Z 轴上的客户年龄
• 使用 K-means 识别客户群。

来源:自己的作品。

这个图是彩色的，但是编辑通常想要灰度图。例如，通过使用主 GUI 中的格式化窗口，它可以被快速转换成灰度图像。

Matlab 漏斗图

漏斗图是一种图表，用于检查系统综述和荟萃分析中是否存在发表偏倚。这是一个 2D 图，在 x 轴上绘制了调查研究的回归系数，在 y 轴上绘制了观察数量(或估计的标准误差)。

大多数在经济研究中使用元分析的文章都在 STATA 中格式化他们的图表，这产生了相当平均质量的漏斗图。另一方面，Veusz 制作的漏斗图看起来更整洁、更精致。它们类似于 Matlab 图形，我认为这是学术期刊绘图质量的黄金标准。

以下漏斗图显示了 Veusz 在为系统评价和荟萃分析准备图表方面的可能性。他们揭示了一篇文章中的出版偏见，这篇文章现在正在一家高级期刊上进行修订。

资料来源:Koráb，Fidrmuc，Dibooglu (2021 年)，正在修订中。

缺点和局限性

由于 Veusz 是一个免费提供的程序，它有几个缺点值得一提:

• 几个情节没有实现，或者他们的制造是费时的。例如，这些可能是小提琴图或简单的热图
• 我没有找到一些基本的功能，比如在 Y 轴上的水平编号。这可能有点令人沮丧，但我总能找到一些变通方法来根据需要准备图表
• 有些功能可能不是很直观，所以需要一些时间来学习所有必要的细节。

结论

Veusz 是一个简单但功能强大的工具，用于可视化数据并为学术和专业期刊准备出版就绪的图。与其他类似的软件包相比，如适马图，Veusz 是免费的，它也定期更新新的功能和图表类型。它需要一些初始时间投资，但最终，它会带来回报，并创建非常好的图形。使用 Veusz 的一大好处是主 2D 和 3D 图表已经准备好了，可供任何用户使用。只需导入您的数据，稍作编辑，图表就完成了。尽管有几个缺点，用户可以利用许多格式选项和“玩”图形，直到他们得到完美的结果。

顺便说一下，它的名字应该读作“views”…

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

ggplot2 数据可视化指南

原文：https://towardsdatascience.com/guide-to-data-visualization-with-ggplot2-in-a-hour-634c7e3bc9dd?source=collection_archive---------16-----------------------

扬·巴布拉克在 Unsplash 上拍摄的照片

介绍

我一直是 Matplotlib 和 Seaborn 的忠实用户，因为它们在创建漂亮的图形方面简单方便，满足了您在传达想法方面的期望。在 R 里，我找到了一个类似的包，是 ggplot2。它漂亮的默认图表选项给我留下了深刻的印象，帮助我减少了大量定制可视化的时间，只需专注于创建最能表达数据信息的图表。关于 ggplot2 的另一个有趣的地方是，一旦理解了它在图形设计中的逻辑，学习起来并不困难。在今天的这篇文章中，我将帮助您了解 ggplot2 的概况。

资料组

对于数据可视化示例，我将使用 dplyr 包中的默认数据集。您可以安装 dplyr 包，并获得如下代码所示的数据:

install.packages(dplyr)
library(dplyr)
data = storms

了解图层

ggplot2 在层中构建图形是您需要了解的第一件也是最重要的事情。您可以从显示原始数据的层开始，然后继续添加其他元素以生成您想要的图形。这种方法将帮助你缩小你头脑中的预期结果和现实中的图表之间的差距。

Ggplot

ggplot 函数包含两个主要部分，分别是:

• 数据:您想要可视化的信息
• 映射:变量如何映射到可视属性(映射在 aes 函数中)

install.packages("ggplot2")
library(ggplot2)# specify dataset and mapping
ggplot(data = data,
       mapping = aes(x = pressure y = wind))

图 1:指定数据框架

我确定了 x 和 y 是什么，但是我没有指定如何绘制图形。因此，图 1 仍然是空的。现在，我将继续向我的图表添加下一个元素。

Geoms

几何图形是几何对象(例如:线、条等。)来决定如何呈现观察结果。图层通常从创建几何图形开始。

这是一个带有 geom_point 的散点图示例。

您还可以创建

• 带的条形图geom _ bar()
• 带有 geom_path() 和 geom_line() 的线图
• 带有***geom _ box plot()***的方框图
• 一个带有***geom _ histogram()和geom _ freqply()***的直方图

注意，在代码中，我使用“+”来连接最终图形的元素。

ggplot(data = data,  
       mapping = aes(x = pressure, y = wind)) +
 geom_point()

图 geoms 散点图

我可以在 geom_ponit 中用不同的属性自定义我的图形。其他控件属性包括大小、颜色、形状、alpha 等。让我们将它们添加到我们的图表中，看看有什么不同。

ggplot(data = data,
       mapping = aes(x = pressure, y = wind)) +
  geom_point(color = "pink", 
             alpha = .9,     
             size = 2)

图 3:定制后的散点图

Alpha 控制图形的透明度，其范围从 0(完全透明)到 1(完全不透明)。可以通过调整透明度来可视化重叠点。

面状

分面是一种有助于显示变量的每个类的技术。我将尝试使用 facet_wrap 属性在图形中显示每种风暴的压力和风力。

ggplot(data = data,
       mapping = aes(x = pressure, y = wind)) +
  geom_point(color = "blue", 
             alpha = .9,
             size = 2) +
  facet_wrap(~status)

图 4:具有 facet_wrap 属性的图形

流畅的

在许多情况下，您的数据有很多噪音，很难观察到模式。您可以选择在图表中添加一条平滑线。

例如:

ggplot(data = data,
       mapping = aes(x = pressure, y = wind)) +
  geom_point(color = "blue", 
             alpha = .5,
             size = 2) +
  geom_smooth(span = 1)

图 5:跨度= 1 的平滑线

根据 跨度 参数(0–1)的范围决定线的抖动。 geom_smooth() 中另一个有趣的事情是，你可以陈述用来拟合平滑曲线的方法。在下图中，我使用了***【lm】***的方法，这是线性模型，给出了最佳拟合的线。

ggplot(data = data,
       mapping = aes(x = pressure, y = wind)) +
  geom_point(color = "blue", 
             alpha = .5,
             size = 2) +
  geom_smooth(method = "lm")

图 6:使用线性方法平滑线条

还有 method =***【rlm】类似于【lm】***但是忽略了离群值的影响。

组

变量也可以映射到不同的颜色。在下面的代码中，我在 aes 属性中给我的变量分配了颜色。

ggplot(data = data,
       mapping = aes(x = pressure, y = wind, color = status)) +
  geom_point( alpha = 0.3,
              size = 2)

图 7:给组分配颜色

标签和主题

为了有一个完整的图形，定制主题和标签是必不可少的步骤。我们可以通过控制各种元素来调整视觉效果的主题，比如字体、网格线、图例位置等。此外，自定义标题、副标题和题注可以用功能 labs()修改。

ggplot(data = data,
       mapping = aes(x = pressure, y = wind, color = status)) +
  geom_point(alpha = 0.3,
             size = 2) +
  labs(title = "Relationship Between Wind and Pressure of Storms",
       subtitle = "By Chi Nguyen",
       caption = "Source: dplyr package",
       x = " Pressure",
       y = "Wind",
       color = "Type of Storms") + 
  theme_set(theme_bw())

图 8:调整图表的主题和标签

熟悉一些基本的图表

基本上，当你记住了这些元素后，你就可以轻松地为自己绘制一个漂亮的图形。现在，让我们看看该怎么做。

折线图

前面说过，我们可以用 geom_line 来画折线图。这是计算每年风暴数量的代码。

count_storms <- 
  data %>%
  group_by(year) %>%
  summarise(number_of_storms = n())ggplot(data = count_storms,
        mapping = aes(x = year, y = number_of_storms)) +
  geom_line(size = 1.5,
            color = 'pink') +
  geom_point(size = 2,
             color = 'black') +
  labs(title = "Number of Storms by Years",
       subtitle = "By Chi Nguyen",
       x = "Year",
       y = "Number of Storms") + 
  theme_set(theme_bw())

图 9:每年的风暴数量

条形图

从 1975 年到 2015 年的 40 年间，让我们看看每年有多少风暴发生。我们将使用 geom_bar() 来创建图表。

storms_no <-  
  data %>%
  group_by(status) %>%
  summarise(number_of_storms = n()) %>%
  arrange(desc(number_of_storms)) %>%
  mutate(prop = round(number_of_storms * 100 / count(status), 1))ggplot(storms_no, 
       aes(x = reorder(status,number_of_storms),
           y = number_of_storms)) + 
  geom_bar(stat = "identity", 
           fill = "indianred3", 
           color = "black") +
  geom_text(aes(label = number_of_storms), 
            vjust = -0.25) +
  labs(x = "Types of Storms", 
       y = "Number of Storms", 
       title  = "Number of Storms During The Period of 40 Years")

图 10:条形图

如果想要有水平条形图，我们可以添加***【coord _ flip()】***来变换图形。

ggplot(storms_no, 
       aes(x = reorder(status,number_of_storms),
           y = number_of_storms)) + 
  geom_bar(stat = "identity", 
           fill = "indianred3", 
           color = "black") +
  geom_text(aes(label = number_of_storms), 
            vjust = +0.25,
            hjust = 0
           ) +
  labs(x = "Types of Storms", 
       y = "Number of Storms", 
       title  = "Number of Storms During The Period of 40 Years") +
  coord_flip()

图 11:水平条形图

圆形分格统计图表

现在，我要用饼状图计算 1975 年发生的每种风暴的百分比。

count_storm_75 = length(data$status[which(data$year == '1975')])#Calculate the percentage
storm_pct = 
  data %>%
  filter(year == '1975') %>%
  select(status) %>%
  group_by(status) %>%
  summarise(number_of_storms = n()) %>%
  arrange(desc(number_of_storms)) %>%
  mutate(pct = round(number_of_storms * 100 / count_storm_75, 1))#Plot the Pie chart
ggplot(storm_pct, 
       aes(x = "", 
           y = pct, 
           fill = status)) +
  geom_bar(width = 1, 
           stat = "identity", 
           color = "black") +
  coord_polar("y", 
              start = 0, 
              direction = -1) +
  ggtitle("Percentage of Storms Happened in 1975")+
  theme(plot.title = element_text(hjust = 0.5))+
  guides(fill=guide_legend(title="Types of Storms")) +
  theme_void()

图 12:饼图

结论

我自己发现与 Python 中的其他包相比，ggplot 很容易上手。通过学习这个包的基础知识，您可以根据自己的喜好定制图形，而不必过多考虑从哪里开始以及如何编写代码。此外，我认为这也是可视化统计报告并获得有用见解的有力工具。虽然我已经知道它几天了，但我发现它很方便，并决定在未来进一步了解它。你也可以和我一起阅读下面的文档:

https://ggplot2-book.org/annotations.html

祝你好运！

文本生成模型微调指南:GPT 新协议、GPT 新协议和 T5

原文：https://towardsdatascience.com/guide-to-fine-tuning-text-generation-models-gpt-2-gpt-neo-and-t5-dc5de6b3bc5e?source=collection_archive---------1-----------------------

通过大规模语言模型的基础，我们了解了不同的开源模型，然后通过针对情感检测任务对每个模型进行微调来比较它们。

照片由 Marija Zaric 在 Unsplash 上拍摄

本文使用的代码可以在这里找到——http://mohitmayank.com/a_lazy_data_science_guide/natural_language_processing/GPTs/#finetuning-gpt-2-for-sentiment-classification和 T5 。要阅读更多关于文本生成模型的内容，请参见http://mohitmayank.com/a_lazy_data_science_guide/natural_language_processing/text_generation/*。更多此类文章请访问我的网站*https://mohitmayank.com/blog/或者看看我的 最新数据科学简书 。也可以在LinkedIn上和我联系。**

介绍

最近在自然语言处理方面的研究导致了多个大规模预训练文本生成模型的发布，如 GPT-{1，2，3}，GPT-{Neo，J}和 T5。如果观众(包括你和我)对他们的可调参数大小达到数十亿没有印象，我们会被他们可以轻松地用于一个全新的看不见的任务而着迷，而无需任何训练！虽然这对于快速实验来说是可以的，但是对于任何实际的生产部署来说，仍然建议为特定的任务进一步训练模型。这被称为微调，在本文中，我们将实际学习微调一些目前可用的最好的语言模型的方法。我们还将通过在 Twitter 情感检测数据集上进行微调来比较它们的性能。我们开始吧！

文本生成模型

在 NLP 中，文本生成是一项有趣的任务，其目的是在输入提示时生成文本。通常，我们应用某种形式的序列到序列模型来完成这项任务。它们被称为语言模型，因为它们可以用来根据前面的句子预测下一个单词。最近对该领域的兴趣激增是由于两个主要原因，(1)几个高性能预训练模型的可用性，以及(2)很容易将大量基于 NLP 的任务转换为文本输入文本输出类型的问题。T5 作者非常直观地展示了这一点，他们可以使用相同的模型进行语言翻译、文本回归、摘要等。

T5 文本到文本框架示例。来源:谷歌 AI 博客

在本文中，我们将关注以下模型，

• GPT-2: 是 OpenAI 发布的原系列语言模型的第二次迭代。事实上，这一系列的 GPT 模型使语言模型出名了！GPT 代表“生成式预训练变压器”，目前我们有 3 个版本的模型(v1，v2 和 v3)。其中只有 GPT 1 号和 GPT 2 号是开源的，因此我们将选择最新的版本进行实验。在技术方面，GPT-2 的体系结构由变压器体系结构的解码器部分组成。
• ****GPT-尼奥:该模型由 EleutherAI 发布，以对抗未开源的 GPT-3 模型。该架构与 GPT-3 非常相似，但训练是在 825 GB 大小的文本数据集上进行的。
• T5: 代表“文本到文本转换转换器”，是谷歌对开源语言模型的回应。T5 论文展示了使用完整的编码器-解码器架构(变压器的)比仅使用解码器(如 GPT 系列所做的)更好，因此他们保持了原始变压器架构的真实性。

不同型号的简要比较如下所示。需要注意的一点是，每个模型根据可调参数大小进一步发布了几个版本。对于这篇文章，我们将选择 117 米大小的 GPT-2，125 米大小的 GPT-Neo 和 220 米大小的 T5。

比较不同的文本生成模型。来源:[ 一个懒惰的数据科学指南

情感检测任务和数据集

为了测试不同语言模型的性能，我们将在一个简单的任务——情感检测上进行微调后，比较模型的准确性。这里，我们将使用 Twitter 情感数据集，可以从这里下载。它总共包含超过 160 万条推文，他们的情绪可能是积极的，也可能是消极的。为了提高计算效率，我们将对 10k 条 tweetss 进行采样，这些 tweet 的情感类别分布几乎相等。然后，我们将使用 95%的数据训练模型，将剩余的 5%用于测试目的。为了公平比较，我们将对所有三个模型使用相同的测试和训练分割。最后，我们将执行 3 次分割和训练每个模型的试验——这是一种复制 3 重验证测试的方法。我们将报告单独的和合计的(平均)f1 宏观分数，该分数可用于模型的性能比较。

Twitter 情感数据集示例。按作者。

现在，下一个明显的问题应该是，我们如何将情感检测任务转换为文本生成任务？答案很简单，我们所要做的就是创建一个直观的提示(带有数据的模板),它可以反映类似的表示如何出现在 web 上。让我们这样理解吧，我们希望提供 tweet 作为输入，希望将情绪作为输出。因此，在我们的提示中，我们应该在Tweet: 前缀后传递一条 tweet，并期望模型预测Sentiment: 前缀后下一行的情绪。这种创建有效提示的过程被称为提示工程，事实证明，仅仅通过改变提示，语言模型就能表现得更好！对于我们的用例，我们可以从一个非常简单的提示格式开始。我们将有两个不同的提示，一个用于培训，一个用于测试。示例如下所示。

训练提示(就像我们希望模型学习这种“模式”来解决“任务”)

**Tweet: I am not feeling well.
Sentiment: Negative**

测试提示(现在我们希望模型已经学习了“任务”，因此可以完成“模式”)

**Tweet: I am feeling well.
Sentiment:** 

因此，在测试过程中，我们将提取前缀Sentiment:后由模型预测的单词，并将该单词视为预测的情感标签。现在让我们深入到实现中！

微调 GPT 2 号和 GPT 近地天体

需要注意的一点是——GPT-2 和 GPT-近地天体共享几乎相同的架构，因此大部分微调代码保持不变。因此，为了简洁起见，我将只分享 GPT-2 的代码，但我会指出使其适用于 GPT-近地天体模型所需的更改。好了，让我们从处理数据集开始，为此我们将从创建 Pytorch Dataset类开始，它定义了我们如何为训练准备数据。

这包括 3 个模块:

• __init__:我们基本上标记和存储数据的地方。
• __len__ :这里我们返回总数据集的长度。这是每个时期内步长计算所需要的。
• __getitem__ :获取一个数据，然后返回。

一些附加点— (1)在第 8 行，我们定义了用于将原始数字情感标签转换为文本标签的映射，(2)在第 12 行，我们将数据转换为我们决定的训练提示，以及(3)在第 14 行，我们执行了标记化(将 tweet 拆分为标记+用它们唯一的 id 替换它们)。

接下来，我们用Dataset类连接数据。代码分解如下所示，

• Line 4-8:我们从加载数据集开始。你可以从这里下载，并在第 4 行修改本地路径。接下来，我们只需对相关的列进行子集划分，并对它们进行重命名。在第 8 行，我们为这个实验采样了 10k 条 tweets。
• Line 10–13:我们将数据拆分为训练和测试，分别有 95%和 5%的拆分。我们使用stratify标志，使得分裂在情感类别分布中是均匀的。
• Line 16:我们将列车数据传递给SentimentDataset类。注意，我们可以对测试数据做同样的事情，但是我只是以原始形式返回测试数据。

现在我们将为模型的训练做准备。代码分解如下:

• 我们加载标记器，添加一些特殊的标记来表示 tweets 的不同部分，最后加载模型。注意，model_name 是在第 5 行定义的。还要注意的是，我们添加了特殊的标记，以便模型知道提示的开始和结束。这将有助于稍后的测试阶段，因为我们不希望模型继续写下一个单词，但它应该知道何时停止这个过程。这可以通过设置eos_token 并训练模型在标签后预测它来完成，如这里所做的。
• Line 16:使用我们之前定义的函数加载并准备数据集。
• Line 21–24:我们为培训流程设置配置。简而言之，我们用batch_size、warmup_steps 和weight_decay定义了在哪里和什么时候保存模型、训练多长时间和在哪里保存日志以及训练策略。
• Line 27–31: 我们通过将模型与训练数据集相连接来开始训练。我们还定义了如何在data_collator中处理训练数据。排序器中的前两个元素是input_ids —标记化的提示和attention_mask —一个简单的 1/0 向量，表示标记化向量的哪一部分是提示，哪一部分是填充。最后一部分非常有趣，我们将输入数据作为标签传递，而不仅仅是情感标签。这是因为我们正在训练一个语言模型，因此我们希望模型学习提示的模式，而不仅仅是情感类。在某种意义上，模型学习预测输入 tweet +提示中结构化的情感的单词，并在这个过程中学习情感检测任务。

这将开始训练。根据您的计算机规格，这可能需要一些时间。

最后，我们定义测试块，在这里我们获取训练好的模型，并将其应用于保留的测试数据。代码细分如下:

• Line 5:我们打开模型上的评估模式。
• Line 8–15:对于每个测试数据，我们首先准备提示，但有一个很大的不同，我们不包括情绪标签，因为这是我们希望模型预测的。此外，记住eos_token——我们希望模型能够预测情感标签，然后通过打印eos_token来中断操作。最后，我们对测试提示进行标记。
• Line 17:我们采用测试提示，预测下一组单词。这个函数中有很多参数定义了如何预测下一个单词。关于它们中每一个的详细内容，请参考这个，或者为了更好地理解下一个单词预测的不同策略，请参考这个。
• Line 20–30:我们从解码预测文本开始，即将预测标记 id 重新转换为文本。然后，我们提取预测的情感标签并将所有相关信息存储到列表中。
• Line 33–37:我们首先将所有提取的信息合并到一个 pandas 数据帧中以获得更好的可读性，然后使用 sklearn 包中的f1_score 函数来计算整个模型的性能。

在运行 GPT-2 的代码并在数据集分割代码中使用不同的random_state执行该操作三次时，我们观察到该模型实际上能够如预期的那样完美预测。它能够预测标签，然后使用eos_token中断标签的执行。f1 宏观表现平均分 81.7% ！这与我们预期的专用情感检测模型的表现相当，并且这继续强调了在 NLP 中使用文本生成模型进行迁移学习是多么容易。

符合 GPT-尼奥标准的代码

为了使 GPT-2 号代码适用于 GPT-近地天体，我们必须做以下修改，

• 进口GPTNeoForCausalLM
• 将model_name 设置为"EleutherAI/gpt-neo-2.7B" (从任何可用尺寸型号中选择)
• 加载模型时，使用GPTNeoForCausalLM 代替GPT2LMHeadModel。

就是这样！在运行 GPT-尼奥的修改代码，并遵循相同的训练策略时，平均 f1 宏观性能得分为 80.7% ！

微调 T5

T5 的架构不同于 GPT 模型，因为它保持了原始变压器的架构，而 GPT 模型只保留了解码器部分。对于培训 T5，我们将使用一个名为 SimpleT5 的优秀包装器包，它从培训阶段移除了大部分样板文件。现在请记住，虽然培训的语法会发生变化，但总体流程和直觉保持不变。先说数据部分。

这里，大部分代码与我们之前为 GPT 模型所做的一样。一个主要的变化是我们不需要Dataset类，因为 SimpleT5 直接在 pandas 数据帧上工作。因此，我们加载数据，做一些初步的预处理，分割数据，并返回熊猫数据帧。(无需令牌化，创建 *Dataset* 类，这不是很棒吗！？)

还有一点需要注意的是，我们不需要为这个包创建提示格式。这样，我们可以将输入的 tweet 和情感标签分离到不同的列中，这里分别是source_text 和target_text。

加载和训练模型也非常简单，只需 3 行代码(如果你可以忽略我漂亮的换行)。**

接下来，我们在测试数据集上测试微调后的 T5 模型。如你所见，推理部分也非常简单，在第 11 行，我们使用了predict 函数，只需传递source_text 就可以得到预测的情感标签。我们稍后将它与original_label 进行比较，以在第 18 行生成性能分数。

在运行 T5 代码并遵循与之前相同的训练策略时，f1 宏观表现的平均得分为 80.7% ！

结果

将所有结果合并到一个表中，我们得到，

GPT-2、GPT-尼奥和 T5 在情感探测任务上的比较。

我想讨论的一点是，我根本没有玩过超参数。除此之外，prompt 工程方法学，我认为仅仅通过研究这两个方面，我们就可以进一步提高所有模型的性能指标。我会把它留给读者做练习(如果你得到了更好的分数，一定要让我知道！)**

结论

虽然 GPT-2 可能赢得了这一轮，但结果表确实显示了文本生成模型的整体实力。他们所有人在情感检测任务上都表现得非常好，所需要的只是几个时期的训练。即使这个实验是为一个单一的任务而做的，我希望这有助于展示使用 TG 模型来完成全新的任务是多么容易。在某种程度上，如果我们可以将 NLP 问题转化为文本生成问题，请放心，预先训练的模型不会失败，至少不会彻底失败:)这使得它们成为许多任务的完美基线，如果不是最先进的。

参考

• 科林·拉弗尔，诺姆·沙泽尔，Adam Roberts，凯瑟琳·李和莎兰·纳朗。用统一的文本到文本转换器探索迁移学习的局限性。2020. arXiv:1910.10683
• 亚历克·拉德福德、杰弗里·吴、雷文·柴尔德、大卫·栾、达里奥·阿莫代伊、伊利亚·苏茨基弗等。语言模型是无人监督的多任务学习者。 OpenAI 博客，1(8):9，2019。
• GPT 近地天体
• Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin。你需要的只是关注。2017. arXiv:1706.03762 。

干杯。

热切的数据科学家用 Dask 评估懒惰的指南

原文：https://towardsdatascience.com/guide-to-lazy-evaluation-with-dask-543b48a0aa74?source=collection_archive---------59-----------------------

在 Unsplash 上由 Manja Vitolic 拍摄的照片

懒惰评估不必令人困惑或复杂——在本指南中，学习入门所需的基本概念！

声明:我是 Saturn Cloud 的一名高级数据科学家，Saturn Cloud 是一个支持使用 Dask 对 Python 进行简单并行化和扩展的平台。如果你想了解更多关于土星云的信息，请登陆网站 www.saturncloud.io 访问我们。

Dask 是什么？

Dask 是一个开源框架，支持 Python 代码的并行化。这可以适用于各种 Python 用例，不仅仅是机器学习。Dask 设计用于单机设置和多机集群。您可以将 Dask 与 pandas、NumPy、scikit-learn 和其他 Python 库一起使用。

为什么要并行？

对于机器学习，Dask 并行化在几个领域可能有助于我们更快更好地工作。

• 加载和处理大型数据集(尤其是当它们太大而无法保存在内存中时)
• 同时快速运行时间或计算繁重的任务(例如，考虑超参数调整或集合模型)

延迟任务

并行计算使用所谓的“懒惰”评估。这意味着您的框架将把转换或计算集合排队，以便它们准备好以后并行运行。这是一个你会在很多并行计算框架中发现的概念，包括 Dask。你的框架不会评估请求的计算，直到被明确告知。这不同于“急切”评估函数，后者在被调用时立即计算。许多非常常见和方便的函数被移植到 Dask 中，这意味着它们将是懒惰的(延迟计算),甚至不需要你去问。

然而，有时您会有用 pandas、scikit-learn 甚至是基本 python 编写的复杂的定制代码，而这些代码在 Dask 中是不可用的。其他时候，如果需要利用原生 Dask 元素进行编辑，您可能没有时间或精力将代码重构为 Dask。

如果是这种情况，你可以用@dask.delayed修饰你的函数，它会手动建立函数应该是懒惰的，直到你告诉它才求值。您可以用下一节中描述的过程.compute()或.persist()来告诉它。

示例 1

def exponent(x, y):
    '''Define a basic function.'''
    return x ** y# Function returns result immediately when called
exponent(4, 5)

1024

import dask@dask.delayed
def lazy_exponent(x, y):
    '''Define a lazily evaluating function'''
    return x ** y# Function returns a delayed object, not computation
lazy_exponent(4, 5)

延迟(’ lazy _ exponent-05d 8b 489–554 c-44 E0–9a2c-7a 52 b 7 B3 a 00d ')

# This will now return the computation
lazy_exponent(4,5).compute()

1024

示例 2

我们可以利用这些知识并扩展它——因为我们的惰性函数返回一个对象，我们可以对它赋值，然后在以后以不同的方式将它链接在一起。

这里我们从第一个函数返回一个延迟值，并将其称为 x。然后我们第二次将 x 传递给该函数，并将其称为 y。最后，我们将 x 和 y 相乘以产生 z。

x = lazy_exponent(4, 5)
y = lazy_exponent(x, 2)
z = x * y
z

延迟(’ mul-2257009 fe1a 612243 C4 b 28012 eddd 1 ')

z.visualize(rankdir="LR")

作者

z.compute()

1073741824

持久与计算

我们应该如何指示 Dask 运行我们已经懒洋洋地排队等候的计算？我们有两个选择:.persist()和.compute()。

计算

如果我们使用.compute()，我们要求 Dask 对我们排队等候的数据进行所有的计算和调整，然后运行它们，并把它们全部带到这里。

这意味着如果它是分布式的，我们现在就想把它转换成一个本地对象。如果它是一个 Dask 数据帧，当我们调用.compute()时，我们说“运行我们排队的转换，并立即将它转换成 pandas 数据帧。”但是要小心——如果你的数据集非常大，这可能意味着你没有足够的内存来完成这个任务，你的内核可能会崩溃！

坚持

如果我们使用.persist()，我们要求 Dask 对我们排队的数据进行所有的计算和调整，并运行它们，但是对象将保持分布式，并将驻留在集群上(如果您在一台机器上，则为 LocalCluster)，而不是 Jupyter 实例或其他本地环境上。

因此，当我们使用 Dask 数据帧执行此操作时，我们会告诉我们的集群“运行我们已排队的转换，并将其作为分布式 Dask 数据帧。”

因此，如果您想处理应用于 Dask 对象的所有延迟任务，这两种方法都可以。区别在于你的对象最后会住在哪里。

理解这一点真的有助于告诉你什么时候.persist()可能有意义。考虑这样一种情况，您加载数据，然后将数据用于许多复杂的任务。如果您使用从磁盘上的 CSV 加载的 Dask 数据帧，您可能希望在将该数据传递给其他任务之前调用.persist(),因为其他任务将在每次引用它时反复运行数据加载。如果您首先使用.persist()，那么加载步骤只需要运行一次。

分布式数据对象

除了延迟单个函数之外，我们还需要讨论另一个工作领域——这就是 Dask 数据对象。其中包括 Dask bag(一个基于列表的并行对象)、Dask array(一个基于 NumPy 数组的并行对象)和 Dask Dataframe(一个基于 pandas Dataframes 的并行对象)。

为了展示这些对象能做什么，我们将讨论 Dask 数据帧。

假设我们有很多年的相同数据，我们想一次加载所有数据。我们可以用 Dask 轻松地做到这一点，这个 API 非常像 pandas API。Dask 数据帧包含许多 pandas 数据帧，它们分布在集群中。

作者

示例 3

import dask
import dask.dataframe as dd
df = dask.datasets.timeseries()

这个数据集是 dask 安装附带的示例之一。请注意，当我们查看它时，我们只获得了部分信息！

df

这是因为我们的 dask 数据帧分布在我们的集群中，直到我们要求它被计算。但是我们仍然可以将延迟的计算排队！让我们使用我们的熊猫知识来应用一个过滤器，然后按一列对数据进行分组，并计算另一列的标准偏差。

请注意，这些代码在常规 pandas 数据帧的计算中不会出现任何问题。

df2 = df[df.y > 0]
df3 = df2.groupby('name').x.std()
df3

Dask 系列结构:
npartitions = 1
float 64
…
名称:x，dtype: float64
Dask 名称:sqrt，157 任务

这返回给我们的不是熊猫系列，而是 Dask 系列。这里有一个分区，所以它不会被不同的工人分割。它很小，所以这对我们来说没问题。

如果我们在上面运行.compute()会发生什么？

computed_df = df3.compute()
type(computed_df)

pandas . core . series . series

这使得我们的结果成为熊猫系列，因为它不再是一个分布式对象。结果内容实际上是什么样的？

computed_df.head()

姓名
爱丽丝 0.579278
鲍勃 0.578207
查理 0.577816
丹 0.576983
伊迪丝 0.575430
姓名:x，dtype: float64

实例 4

让我们回到上一个例子中使用的 df 对象。这里我们将使用npartitions属性来检查我们的数据帧被分成了多少部分。

import dask
import dask.dataframe as dd
df = dask.datasets.timeseries()
df.npartitions

所以我们的 Dask 数据帧有 30 个分区。因此，如果我们在这个数据帧上运行一些计算，我们仍然有一个具有许多分区属性的对象，我们可以检查它。我们将对其进行过滤，然后使用 groupby 进行一些汇总统计。

df2 = df[df.y > 0]
df3 = df2.groupby('name').x.std()
print(type(df3))
df3.npartitions

现在，我们已经将对象简化为一个系列，而不是一个数据帧，因此它更改了分区号。

如果我们想的话，我们可以看这个系列！

df4 = df3.repartition(npartitions=3)
df4.npartitions

如果我们在这些对象上使用.persist()或.compute()会发生什么？

正如我们下面看到的，df4是一个 Dask 系列，有 161 个排队任务和 3 个分区。我们可以在同一个对象上运行两个不同的计算命令，并看到不同的结果。

df4

Dask 系列结构:
npartitions = 3
float 64
…
…
…
名称:x，dtype: float64
Dask 名称:重新分区，161 任务

%%timedf4.persist()

CPU 时间:user 1.8 s，sys: 325 ms，total:2.12s
Wall time:1.25s
Dask 系列结构:
npartitions = 3
float 64
…
…
…
Name:x，dtype:float 64
Dask Name:repartition，3 tasks

那么，当我们运行.persist()时，发生了什么变化？请注意，我们从屏幕底部的 161 项任务减少到只有 3 项。这表明每个分区都有一个任务。

现在，我们来试试.compute()。

%%time
df4.compute().head()

CPU 时间:user 1.8 s，sys: 262 ms，total:2.06s
Wall time:1.2s
Name
Alice 0.576798
Bob 0.577411
Charlie 0.579065
Dan 0.577644
Edith 0.577243
Name:x，dtype: float64 【T36

我们得到的是熊猫系列，而不是 Dask 对象。

结论

至此，您已经有了使用 Dask 所需的基本概念！

• 您的定制代码可以通过@dask.delayed实现并行化
• Dask 的生态系统对 pandas、NumPy 和 scikit-learn 功能提供了强大的本地支持，赋予了它们并行化能力
• Dask 数据对象可以使你的数据分布，防止数据过多/内存过少的问题

通过结合这些强大的特性，您可以使用我们用于 pandas、NumPy 和 scikit-learn 的相同 API 来生成强大的、生产质量的数据管道。要了解 Dask 的更多功能，请访问我们的 Saturn Cloud，了解我们的客户在 Dask 上取得的成功！

R 降价指南

原文：https://towardsdatascience.com/guide-to-r-markdown-8468e6464bb4?source=collection_archive---------20-----------------------

如果你正在寻找一个工具来呈现一个整洁有效的报告，R markdown 是一个理想的选择！

科琳·库兹在 Unsplash 上的照片

简介

为了我的研究，我已经做了很多报告，包括用 R 编码和注释我的代码。R markdown 是完成这些报告的一个很好的支持工具。它可以把你的代码、结果和你的评论放在一个地方。然后，只需点击一个按钮，它就可以帮助以 pdf、Word 等不同格式呈现输出。

除了是我研究的一个很好的工具，R markdown 也是决策者的理想选择，他们希望从结果中寻求洞察力，但不想深入研究背后的代码。因此，在本文中，让我们来探索这个方便的工具。

如何开始

您可以创建一个新的。RStudio 中的 Rmd 文件，方法是转到文件>新建文件> R Markdown。

降价基础

如果您理解了下面的基础知识，那么您已经成功地生成了第一个 R markdown 文件:

1. 代码块
2. 不同类型的文本格式:标题、字体等。

HTML 格式的降价示例如下:

图 1:来自 RStudio 的默认 R markdown 文件

现在，让我们进入每一部分。

文本格式

Markdown helps to create different text formats, such as:- **Headings**# 1st Level Header
## 2nd Level Header
Markdown helps to create different text formats, such as:- **Headings**# 1st Level Header
## 2nd Level Header
### 3rd Level Header
#### 4th Lever Header- **Italic**  
*italic* or _italic_- **Bold**  
**bold**   __bold__- **Superscript**  
superscript^2^- **Subscript**  
subscript~2~We can also use markdown to make:- **Latex Equation**  
$\frac{1}{n} = n^{2}$- **Bibliography, footnotes, citations**  
[rmarkdown cheatsheet]([https://rmarkdown.rstudio.com/authoring_quick_tour.html#Overview](https://rmarkdown.rstudio.com/authoring_quick_tour.html#Overview)) [^1][^1]: R-base- **Table**Col1          | Col2
------------- | -------------
Content Col1  | Content Col2
Content Col1  | Content Col2

输出:

图 1

更多参考，可以在这个链接了解。

代码块

要添加新的代码块，您可以使用 Ctrl + Alt + I 或通过以下方式手动创建它:

```{r}
code

若要执行此代码，请单击“运行”或按 Ctrl + Shift + Enter。

代码块有以下本地选项:

`include = FALSE`不允许代码及其结果出现在最终文件中。R Markdown 仍然运行代码片段中的代码，并且结果可以被其他代码片段使用。

`echo = FALSE`不允许代码，但允许结果出现在最终文件中。

`message = FALSE` 不允许代码生成的消息出现在最终文件中。

`warning = FALSE` 不允许代码生成的警告出现在最终文件中。

`fig.cap = "..."`给最终图形添加标题。

我将向您展示所有这些是如何工作的示例。

library(ggplot2)data = stormsggplot(data = data,
       mapping = aes(x = pressure, y = wind, color = status)) +
  geom_point( alpha = 0.3,
              size = 2) +
  labs(title = "Relationship Between Wind and Pressure of Storms",
       subtitle = "By Chi Nguyen",
       caption = "Source:dplyr package",
       x = " Pressure",
       y = "Wind",
       color = "Type of Storms") + 
  theme_set(theme_bw())```

图 2:大块代码

使用 R 参数

R Markdown 文档可能包括许多在报告时设置的参数。当您想要使用新的输入值重新呈现类似的报表时，参数非常有用，例如:

• 运行特定于部门或地理区域的报告。
• 运行涵盖特定时间段的报告。
• 等等。,

例如，在下面的减价中，params年= 1975 年。然后，在格式params$<paramname>下的代码中使用。

---
title: "R markdown"
author: "Chi Nguyen"
date: "9/17/2021"
output: html_document
params: 
  year: '1975'
---```{r, message = FALSE}library(dplyr)
data = storms 
count_storm_75 = length(data$status[which(data$year == params$year)])
count_storm_75 ```

图 3:使用参数

您还可以为参数设置约束:

图 4:为参数设置约束

结论

R markdown 中有大量有趣的特性，你可以在这本有用的食谱链接中详细阅读它们。R markdown 可以执行很多其他语言的代码，比如 Python、SQL、Bash、Rcpp、Stan、JavaScript、CSS 等。我觉得这是一个很好的学习工具，以后一定会帮助你完成很多工作。

Python 中海量三维点云实时可视化指南

原文：https://towardsdatascience.com/guide-to-real-time-visualisation-of-massive-3d-point-clouds-in-python-ea6f00241ee0?source=collection_archive---------0-----------------------

3D Python

Python 中大点云数据的高级可视化和交互教程。(奖金)学习如何创建一个交互式分割“软件”。

数据可视化是一个大难题🌶️:通过使用可视元素制作信息的图形表示，我们可以最好地呈现和理解数据中的趋势、异常值和模式。你猜对了:对于表示真实世界形状的 3D 点云数据集，这是强制性的🙂。

本文中处理和可视化的无人机 3D 点云。您将学习特征提取、交互式和自动分割，同时实时可视化和创建动画。F. Poux

然而，当从激光扫描仪或 3D 重建技术(如摄影测量)收集时，点云对于经典渲染来说通常过于密集。在许多情况下，数据集将远远超过 1000 万大关，这使得它们对于经典的可视化库(如 Matplotlib)来说不切实际。

你可以注意到左边(Open3D)比右边(PPTK)慢多了，后者使用八叉树结构来加速可视化。Matplotlib 会更糟😅。F. Poux

这意味着我们经常需要跳出 Python 脚本(因此使用 I/O 函数将数据写入文件)并在外部可视化它，这可能会成为一个超级麻烦的过程🤯。我不会说谎，我在论文的第一年就是这么做的，试图猜测特定 algorithms🥴.的结果

在你的脚本中直接可视化这些点云不是很好吗？更好的是，将视觉反馈与脚本联系起来？想象一下，现在有了 iPhone 12 Pro 有了激光雷达；您可以创建一个完整的在线应用程序！好消息是，有一种方法可以在不脱离 Python 环境和 IDE 的情况下实现这一点。☕准备好了吗？

步骤 1:启动您的 Python 环境。

在下面的前一篇文章中，我们看到了如何使用 Anaconda 轻松地设置环境，以及如何使用 IDE Spyder 管理您的代码。如果你准备成为一名完全成熟的 python 应用程序开发人员，我建议你继续这样做😆。

如果您使用 Jupyter Notebook 或 Google Colab，脚本可能需要一些调整，以使可视化后端工作，但提供不稳定的性能。如果您想继续使用这些 IDE，我建议您看看第 4 步中给出的库的替代品。

步骤 2:下载点云数据集

在之前的教程中，我展示了通过使用摄影测量和来自开阔地形的航空激光雷达获得的 3D 数据集上的点云处理和网格划分。我将跳过下面文章中涉及的激光雷达 I/O 细节，直接使用高效的。las 文件格式。

只是这一次，我们将使用空中无人机数据集。它是通过摄影测量获得的，让一架小型 DJI 幻影 Pro 4 在我们的大学校园内飞行，收集一些图像，并进行摄影测量重建，如这里所解释的。

以下链接提供的 3D 点云来自 DJI Phantom 4 飞行，随后是摄影测量重建过程。F. Poux

🤓 注意 : 对于这个操作指南，你可以使用这个库中的点云，我已经过滤和转换过了，这样你就处于最佳状态了。如果你想在不安装任何东西的情况下预先可视化并使用它，你可以查看一下 webGL 版本。

步骤 3:在脚本中加载点云

我们首先在脚本中导入必要的库(NumPy 和 LasPy)，并加载。las 文件中一个名为point_cloud的变量。

import numpy as np
import laspy as lp
input_path="D:/CLOUD/POUX/ALL_DATA/"
dataname="2020_Drone_M"
point_cloud=lp.file.File(input_path+dataname+".las", mode="r")

很好，我们差不多准备好了！最棒的是，LasPy 库还为变量point_cloud提供了一个结构，我们可以使用简单的方法来获取，例如，X、Y、Z、红色、蓝色和绿色字段。让我们这样做来分离坐标和颜色，并把它们放在 NumPy 数组中:

points = np.vstack((point_cloud.x, point_cloud.y, point_cloud.z)).transpose()
colors = np.vstack((point_cloud.red, point_cloud.green, point_cloud.blue)).transpose()

🤓

步骤 4(可选):最终预处理

如果您的数据集太大，或者您想在二次抽样版本上进行试验，我建议您查看下面的文章，它给出了实现这一任务的几种方法:

**

或以下形成广泛的点云训练:

https://learngeodata.eu/point-cloud-processor-formation/

为了方便起见，如果您有超过 1 亿个点的点云，我们可以使用以下方法快速切片您的数据集:

factor=10
decimated_points_random = points[::factor]

🤓 注意 : 运行这个将每 10 行保留 1 行，从而将原始点云的大小除以 10。

第五步:选择你的观想策略。

现在，让我们选择如何可视化我们的点云。老实说，虽然可视化本身可以避免繁琐的 I/O 操作，但是能够在 Python 中包含一些可视化交互和处理工具是一个很好的补充！因此，我推荐的解决方案是使用一个点云处理工具包，它可以实现这一点甚至更多。如果你想探索其他的可能性，我还是会给你其他的选择，⚖️.

解决方案 A(保留):PPTK

PPTK 包有一个三维点云查看器，它直接将一个 3 列的 NumPy 数组作为输入，可以交互式地可视化 1 千万到 1 亿个点。它通过使用八叉树来剔除视见体外部的点并将远处的点组近似为单个点，从而减少了每帧中需要渲染的点的数量。

模拟八叉树结构中的平截头体剔除。来源:虚拟现实(VR)环境下海量 3D 点云的分类与集成。

首先，您可以使用 Pip 管理器简单地安装该库:

pip install pptk

然后，您可以通过输入以下命令，从点云中可视化您之前创建的points变量:

import pptk
import numpy as np
v = pptk.viewer(points)

在启动时，查看器将输入点组织成八叉树。当视点被操纵时，八叉树被用于将远处的点组近似为单个点，并在视见平截头体之外剔除点，从而显著减少了被渲染的点的数量。一旦视点不再有变化，观察者就开始执行更耗时的点的详细渲染。F. Poux

你不认为我们漏掉了一些颜色吗？让我们通过在控制台中键入以下命令来解决这个问题:

v.attributes(colors/65535)

PPTK 查看器中带有颜色信息的 3D 点云。F. Poux

🤓 注 : 我们的颜色值是从。las 文件。我们需要[0，1]区间内的值；因此，我们除以 65535。

这是更好的方式！但是，如果我们也想可视化额外的属性呢？嗯，你只要把你的属性链接到你的路径上，它就会动态更新。

预先计算的几个属性的可视化示例。

💡 提示: 不要最大化窗口大小，以保持 30 FPS 以上的良好帧率。目标是拥有最好的执行运行时，同时拥有可读的脚本

您还可以将窗口参数化，以显示与特定色带相关的每个属性，管理点大小，将背景设为黑色，不显示网格和轴信息:

v.color_map('cool')
v.set(point_size=0.001,bg_color=[0,0,0,0],show_axis=0,show_grid=0)

备选方案 B:开放 3D

对于想用 Python 读取和显示点云的优秀替代方案的人，我推荐 Open3D。您也可以使用 Pip 软件包管理器来安装必要的库:

pip install open3d

如果您想扩展 3d 网格操作的知识，我们已经在下面的教程中使用了 Open3d:

</5-step-guide-to-generate-3d-meshes-from-point-clouds-with-python-36bad397d8ba>

这将在您的机器上安装 Open3D，然后您将能够通过执行以下脚本来读取和显示您的点云:

import open3d as o3dpcd = o3d.geometry.PointCloud()
pcd.points = o3d.utility.Vector3dVector(points)
pcd.colors = o3d.utility.Vector3dVector(colors/65535)
pcd.normals = o3d.utility.Vector3dVector(normals)o3d.visualization.draw_geometries([pcd])

在 Open3D 中可视化的三维点云。请注意法线是如何很好地用来增强几何图形的视觉效果的。F. Poux

Open3D 实际上正在发展，您可以通过一些有趣的方式来显示点云，以填充最终的孔洞，如创建体素结构:

voxel_grid = o3d.geometry.VoxelGrid.
create_from_point_cloud(pcd,voxel_size=0.40)o3d.visualization.draw_geometries([voxel_grid])

点云的 3D 体素表示，其中每个体素表示一个 40×40cm 的立方体。F. Poux

🤓 注 : 为什么 Open3d 不是此时的选择？如果您处理的数据集少于 5000 万个点，那么这就是我推荐的。如果您需要这个阈值以上的交互式可视化，我建议要么出于可视化目的对数据集进行采样，要么使用 PPTK，这对于可视化更有效，因为您已经为此目的创建了八叉树结构。

其他(对 Colab 友好的)替代品:Pyntcloud 和 Pypotree

如果您希望能够对点云数据进行简单和交互式的探索，而不管使用哪种传感器来生成它，也不管用例是什么，我建议您查看 Pyntcloud 或 PyPotree 。这些将允许你在你的笔记本上观想点云，但是要小心表演！Pyntcloud 实际上依赖于 Matplotlib，PyPotree 要求 I/O 操作；因此，两者实际上都不是超高效的。尽管如此，我还是想提到它们，因为对于小的点云和 Google Colab 中的简单实验，你可以整合可视化。一些例子:

### PyntCloud ###
conda install pyntcloud -c conda-forge
from pyntcloud import PyntCloudpointcloud = PyntCloud.from_file("example.ply")
pointcloud.plot()### PyntCloud ###
pip install pypotreeimport pypotree 
import numpy as np
xyz = np.random.random((100000,3))
cloudpath = pypotree.generate_cloud_for_display(xyz)
pypotree.display_cloud_colab(cloudpath)

步骤 6:与点云交互

回到 PPTK。要进行交互式选择，比如停车场上的汽车，我将移动我的相机俯视图(快捷键是7)，我将拖动一个矩形选择按住Ctrl + LMB进行选择。

💡 提示: 如果您对选择不满意，一个简单的 RMB 将擦除您当前的选择。是的，您可以进行多项选择😀。

做出选择后，您可以返回 Python 控制台，然后获取赋值的点标识符。

selection=v.get('selected')

这实际上会返回一个 1D 数组，如下所示:

选择是一个数组，包含每个选定点的索引。F. Poux

您实际上可以扩展这个过程，一次选择多个元素(Ctrl + LMB)，同时细化选择，删除特定的点(Ctrl + Shift + LMB)。

从点云创建多个选择。F. Poux

在此之后，在保存所选点索引的selection变量上交互应用一系列过程变得毫不费力。

让我们复制一个场景，其中您自动在地面和非地面元素之间优化您的初始选择(汽车)。

步骤 7:走向自动分段

在包含完整点云的查看器中，存储在变量v中，我做出如下选择selection=v.get('selected'):

步骤 1:我们从初始三维点云中选择点。F. Poux

然后计算每个点的法线。为此，我想说明使用 PPTK 的另一个关键要点:函数estimate_normals，它可用于基于半径搜索或 k 最近邻获得每个点的法线。不用担心，我将在另一个指南中深入说明这些概念，但目前，我将使用 6 个最近的邻居来运行它，以估计我的法线:

normals=pptk.estimate_normals(points[selection],k=6,r=np.inf)

💡 提示: 记住 selection 变量保存点的指数，即点云中的“线号”，从 0 开始。因此，如果我只想在这一点子集上工作，我将把它作为 points[selection]传递给*。然后，我为每个点选择仅使用 6 个最近邻居的 k-NN 方法，通过也将半径参数设置为* np.inf ，这确保我不使用它。我也可以同时使用这两个约束，或者将 k 设置为 -1 ，如果我想进行纯半径搜索的话。

这将基本上返回以下内容:

每个点的法线示例。F. Poux

然后，我要对和进行过滤，返回法线与 Z 轴不共线的原始点的指数。我建议使用以下代码行:

idx_normals=np.where(abs(normals[...,2])<0.9)

🤓 注释*:The*【，是 NumPy 的一种说法，说我只在我的 3×n 点矩阵的第三列工作，持有法线的 Z 属性。它相当于 normals[:,2] 。然后，因为我的法线没有取向(因此可以指向天空或地心)，所以我以绝对值作为比较点，并且将使用功能np.where()仅保持符合条件 <0.9的那个。

为了使结果可视化，我创建了一个新的查看器窗口对象:

viewer1=pptk.viewer(points[idx_normals],colors[idx_normals]/65535)

自动正常过滤后的 3D 点云段。看看有些点是怎么在车顶和整个汽车结构上掉下来的。F. Poux

可以看出，我们还过滤了一些点部分的汽车。这可不好🤨。因此，我们应该将该过滤与另一个过滤相结合，以确保仅选择接近地面的点作为法线过滤的主体:

idx_ground=np.where(points[...,2]>np.min(points[...,2]+0.3))
idx_wronglyfiltered=np.setdiff1d(idx_ground, idx_normals)
idx_retained=np.append(idx_normals, idx_wronglyfiltered)viewer2=pptk.viewer(points[idx_retained],colors[idx_retained]/65535)

3D 点云会针对垂直法向接近初始段的最低 Z 值的点进行过滤。F. Poux

这真好！现在，您可以探索这种强大的思维方式，并结合任何过滤(例如在 RGB 上播放以消除剩余的草……)来创建一个完全交互式的分割应用程序。更好的是，可以结合 3D 深度学习分类！吼吼。但那是以后的事了😉。

步骤 8:用函数打包你的脚本

最后，我建议把你的脚本打包成函数，这样你就可以直接重用其中的一部分作为块。我们可以首先定义一个preparedata()，它将把任何.las点云作为输入，并格式化它:

def preparedata():
    input_path="D:/CLOUD/OneDrive/ALL_DATA/GEODATA-ACADEMY/"
    dataname="2020_Drone_M_Features"
    point_cloud=lp.file.File(input_path+dataname+".las", mode="r")
    points = np.vstack((point_cloud.x, point_cloud.y, point_cloud.z) 
    ).transpose()
    colors = np.vstack((point_cloud.red, point_cloud.green,
    point_cloud.blue)).transpose()
    normals = np.vstack((point_cloud.normalx, point_cloud.normaly, 
    point_cloud.normalz)).transpose()
    return point_cloud,points,colors,normals

然后，我们编写一个显示函数pptkviz，它返回一个查看器对象:

def pptkviz(points,colors):
    v = pptk.viewer(points)
    v.attributes(colors/65535)
    v.set(point_size=0.001,bg_color= [0,0,0,0],show_axis=0,
    show_grid=0)
    return v

此外，还有一个额外的好处，这里有一个函数cameraSelector，可以从打开的浏览器中获取相机的当前参数:

def cameraSelector(v):
    camera=[]
    camera.append(v.get('eye'))
    camera.append(v.get('phi'))
    camera.append(v.get('theta'))
    camera.append(v.get('r'))
    return np.concatenate(camera).tolist()

我们定义了computePCFeatures函数来自动细化您的交互式分割:

def computePCFeatures(points, colors, knn=10, radius=np.inf):
    normals=pptk.estimate_normals(points,knn,radius)
    idx_ground=np.where(points[...,2]>np.min(points[...,2]+0.3))
    idx_normals=np.where(abs(normals[...,2])<0.9)
    idx_wronglyfiltered=np.setdiff1d(idx_ground, idx_normals)
    common_filtering=np.append(idx_normals, idx_wronglyfiltered)
    return points[common_filtering],colors[common_filtering]

好了😁现在，您只需启动包含上述功能的脚本，并开始使用computePCFeatures、cameraSelector和更多您的作品与您的选择进行交互:

import numpy as np
import laspy as lp
import pptk*#Declare all your functions here*if __name__ == "__main__":
    point_cloud,points,colors,normals=preparedata()
    viewer1=pptkviz(points,colors,normals)

然后很容易调用脚本，然后使用控制台作为实验的工作台。例如，我可以保存几个摄像机位置并创建一个动画:

cam1=cameraSelector(v)
*#Change your viewpoint then -->* cam2=cameraSelector(v)
*#Change your viewpoint then -->* cam3=cameraSelector(v)
*#Change your viewpoint then -->* cam4=cameraSelector(v)poses = []
poses.append(cam1)
poses.append(cam2)
poses.append(cam3)
poses.append(cam4)
v.play(poses, 2 * np.arange(4), repeat=True, interp='linear')

点云 PPTK 内 4 个关键帧之间的线性插值。F. Poux

结论

您刚刚学习了如何导入、可视化和分割由 3000 多万个点组成的点云！干得好！有趣的是，直接在 GPU 上执行的点云片段和单个点的交互选择现在可以用于点云实时编辑和分割。但这条路并没有到此为止，未来的帖子将更深入地探讨点云空间分析、文件格式、数据结构、分割[2–4]、动画和深度学习[1]。我们将特别关注如何管理大点云数据，如下面的文章中所定义的。

我的贡献旨在浓缩可操作的信息，以便您可以从零开始为您的项目构建 3D 自动化系统。你可以从今天开始在地理数据学院参加一个编队。

https://learngeodata.eu/point-cloud-processor-formation/

参考

1. Poux，F. ，& J.-J Ponciano。(2020).三维室内点云实例分割的自学习本体。国际摄影测量与遥感学会。拱门。Pho 的。&雷姆。B2，309–316；https://doi . org/10.5194/ISPRS-archives-XLIII-B2–2020–309–2020

2. Poux，F. ，& Billen，R. (2019)。基于体素的三维点云语义分割:无监督的几何和关系特征与深度学习方法。ISPRS 国际地理信息杂志。8(5), 213;https://doi.org/10.3390/ijgi8050213

3. Poux，F. ，纽维尔，r .，纽约，g .-a .&比伦，R. (2018)。三维点云语义建模:室内空间和家具的集成框架。遥感、 10 (9)、1412。https://doi.org/10.3390/rs10091412

4. Poux，F. ，Neuville，r .，Van Wersch，l .，Nys，g .-a .&Billen，R. (2017)。考古学中的 3D 点云:应用于准平面物体的获取、处理和知识集成的进展。地学， 7 (4)，96。https://doi.org/10.3390/GEOSCIENCES7040096**

Python 环境设置指南&理解 Python IDLE

原文：https://towardsdatascience.com/guide-to-setup-python-environment-understanding-python-idle-7ff3e00941d6?source=collection_archive---------12-----------------------

为您的第一个 Python 代码创建环境并开始编码

照片由 Hitesh Choudhary 拍摄自 Unsplash

介绍

在您的计算机上设置 python 环境是启动第一个 Python 脚本的第一步。有许多方法可以开始设置和安装，但是在本文中，我们将通过从官方 python 发行版—【python.org】下载来学习设置我们的 Python 环境。在设置好我们的 Python 环境之后，我们将会了解更多与 Python 安装捆绑在一起的 Python IDLE。( *本教程使用的操作系统是 Windows 上的)

让我们开始设置我们的 Python 环境！

第 1 步—导航至 Windows 的python.org下载页面。

用于 Windows 的 Python 下载页面

步骤 2 —选择最新的 Python 3 版本(截止到本文，最新的 Python 版本是 Python 3.9.6 )

选择最新的 Python 3 版本

第 3 步—滚动到页面底部，选择并下载 64 位 Windows x86–64 可执行安装程序(如果您的电脑使用 32 位，则选择 32 位 Windows x86 可执行安装程序)

选择并下载 Windows Installer

第 4 步—双击下载的文件运行安装程序

• 运行 Python windows 安装程序后会弹出一个对话框

Python 安装-对话框

• 勾选**“将 Python 3.9 添加到路径中”** (此框默认未勾选)

通过将 Python 添加到 PATH，您可以从命令提示符(cmd)运行 Python。总之，您可以通过在命令提示符下键入“python”来运行 Python 脚本。

选中选项-将 Python 添加到路径

第 5 步—单击“立即安装”

Python 安装

如果安装成功，您将收到消息“安装成功”

Python 安装-设置成功消息

步骤 6-在 Windows 搜索栏下，输入“Python”并选择“IDLE (Python 3.9 64 位)”

Windows 搜索栏:python

空闲的 shell 窗口将会打开，您可以开始编写您的第一个 Python 脚本。

Python 空闲外壳

步骤 7 —编写您的第一个 Python 脚本(“Hello，World！”)

打印“你好，世界！”在 Python 空闲 shell 上

干得好！现在，您已经在计算机上安装了 Python 环境，并编写了第一个 Python 剪贴画。在本文的下一部分，我们将了解更多关于 Python IDLE 的内容。

Python 空闲是什么？

Python IDLE 是一个 Python 开发和学习环境，IDLE 代表:

有两个主要窗口，即“外壳窗口”和“编辑器窗口”。“外壳窗口”提供对 python 交互模式的访问，“编辑器窗口”允许您创建或编辑现有的 Python 文件。让我们首先看看如何配置我们的 Python 空闲环境。

在您的空闲 shell 环境中，导航到选项→配置空闲。

配置空闲

“设置”菜单将弹出，标签“字体/标签”显示一个字体列表，您可以为您的 Python 空闲环境选择字体和字体大小。

空闲-设置菜单:字体/标签

在“Highlights”选项卡上，您可以为 Python 空闲环境选择一个主题。例如，我会换成深色的，因为这样对我们的眼睛更舒服。

空闲—设置菜单:突出显示

在“窗口”选项卡中，您可以指定您的窗口首选项，如宽度、高度等。但是让我们注意一下启动时的窗口首选项，默认情况下是“打开 Shell 窗口”。

空闲-设置菜单:窗口

在前面的部分中，我们从窗口搜索栏中打开了“ IDLE (Python 3.9 64 位)】，默认情况下，当设置中默认选择了选项“ Open Shell Window ”时，会打开空闲的“Shell Window”。但是如果选择了选项“打开编辑窗口，会发生什么呢？—让我们尝试选择此选项，并观察不同之处。

空闲-设置菜单:窗口-切换到“打开编辑窗口”

观察在“外壳窗口”中选择“打开编辑窗口”选项时的区别。“外壳窗口”显示关于安装的 Python 版本和操作系统的信息，而“编辑窗口”是一个空文件。

Python 空闲的“外壳窗口”和“编辑窗口”

“外壳窗口”是一个交互式环境，当您只需要执行一行命令时非常有用，但是如果您正在编写一个完整的 python 程序，它就不实用了。因此,“编辑窗口”将会更有用，因为您可以编写 Python 脚本并保存代码。让我们看一个打印“Hello，World！”使用“编辑窗口”的消息。

Python 空闲的“编辑窗口”

请注意,“编辑窗口”不会在输入时运行脚本。要运行该脚本，您需要导航到运行→运行模块。

Python 空闲“编辑窗口”——运行模块

将弹出一条对话框消息，要求必须保存文件。用您喜欢的文件名保存 Python 文件(确保用。py 扩展)。保存后，将执行您的 Python 文件，并将结果打印在一个空闲的“Shell 窗口”中

空闲“外壳窗口”中显示的 Python 脚本的结果

结论:

建立自己的 Python 环境很容易，只需要几个步骤，您就可以开始编写第一个 Python 脚本了。作为一个初学 Python 的人，Python IDLE 是开始你的旅程的好地方。然而，随着您的深入，您将会探索其他工具，如 Pycharm、Eclipse、Microsoft Visual Studio 等。尽管如此，祝贺你第一次探索 Python！

参考和链接

[1]https://realpython.com/installing-python/

[2]https://realpython.com/python-idle/

[3]https://geek-university.com/python/idle-editor/

Python 中的 SQL 及其等效命令指南

原文：https://towardsdatascience.com/guide-to-sql-and-its-equivalent-commands-in-python-445e134adaba?source=collection_archive---------9-----------------------

对于那些想将 SQL 代码转换成 Python 中的等效命令的人来说，这是一个快速而详细的备忘单！

照片由洛佩兹罗宾在 Unsplash 拍摄

介绍

从头开始学习从来都不是一件容易的事情。原因之一是我们不知道自己不知道的事情。当我第一次学习 Python 的时候也是这样。我对它的逻辑、语法等感到沮丧，因为要记住它们太难了。最后，我发现了自己学习 Python 的方法，那就是通过 SQL。由于 SQL 是我在日常工作中经常使用的工具，我试图将我在 SQL 中学到的一切应用到 Python 中。这种学习方式帮助我同时研究、练习和记忆。

在本文中，我将向您展示一些重要的 SQL 查询和它们在 Python 中的对等物，具体来说是 Pandas。这被认为是对那些想用和我一样的方法学习 Python 的人的一个指导。希望它能成为那些想买熊猫的人的有用的小抄。

数据

我将创建一个简单的数据集如下:

data = {'product_name': ['pencil', 'eraser', 'pen', 'desk', 'laptop'],
        'price': [2, 1, 1, 50, 678], 
        'owner': ['Chi','Joe','Dan','Lisa','Rose']}
df = pd.DataFrame(data) 

图 1:测向数据集

现在，让我们开始吧！

选择

下面是 SQL 的一些简单的select语句和 Python 中的等效命令。

您可以通过调用数据集的名称(在我的示例中为 df )来轻松选择所有的列和行。

在另一种情况下，您只需要从数据中提取特定的列，您可以考虑一些简单的方法，例如使用loc & iloc.进行切片和索引。在我下面的示例中，我向您展示了从 df 数据集获取列 owner 的三种不同方法。

如果我想查看我的数据中存在的独特产品？很简单，只需从 df 数据集提取 product_name 列，并应用unique()函数即可。

带条件选择

在 Pandas 中，有几种方法可以选择特定的条件行。我们可以用 Python 的切片方法，索引，应用查询函数或者 lambda。

在下面的例子中，我将向您展示一些解决方案，通过对列值的一个或多个约束来获得所需的数据。通常，当在条件论元中处理数值数据时，我们必须处理不同的比较(例如:col_number > 2，total_people ≥ 10 等)。作为参考，在 Python 中，对数值数据的比较运算符描述如下:

• 等于==
• 不等于!=
• 大于>
• 不到<
• 大于或等于>=
• 小于或等于<=

此外，如果您想要提取特定类别等于字符串或对象的行，您应该用==操作符指定它。我选择所有product _ name为 pen 的行的情况如下表所示。让我们来看看。

选择其值与特定模式相似的行

假设您在一个数据中有数千个产品列表，但您只想选择产品名称与 笔 相关的数据。在这种情况下，使用contains()功能是一个很好的选择。

有时，当您确切地知道所需类别的开始和结束字符时，您可以借助于功能startswith()或endswith()来指定它。

选择其值在确定集合中的行

如果要选择特定列值在某个范围或集合内的行。isin()命令可以帮你做到。例如，我想选择 product_name 为钢笔或铅笔的数据。我将调用如下命令:

计算函数

与 SQL 类似，Python 也提供不同的函数来计算聚合或生成描述性摘要。

在我的例子中，我只用一行代码就可以很容易地找到产品的总数、所有产品的总价格、产品价格的范围(例如:最大值、最小值、中间值等)。

分组依据

Group by 很简单。只需在想要分组的列上使用groupby()功能。例如，从我的 df 数据中，为了计算每个人为他/她的产品支付的钱，我将数据按每个人的名字分组，然后计算相应的产品价格总额。

排序值

基本上，sort_values默认按升序排列值。因此，如果您想按降序排列值，只需在sort_values()参数中声明ascending = 'FALSE'。

为了查看谁付了最多的钱，我用groupby()和sum()函数计算每个人付的钱，然后按降序排列价格总和。

加入

我将创建另一个名为 df2 的数据帧来描述join命令。

*data1 = {'class': ['A','A','C','B','E'],
        'teacher':['Mona','Mila','Laurel','Wes','Connor'], 
        'owner': ['Chi','Joe','Dan','Lisa','Rose']}
df2 = pd.DataFrame(data1)*

图 2:数据帧 df2

基本连接包括左连接、右连接、外连接和内连接。在不同的情况下，根据我们的需要，我们可以选择合适的join.

让我们看看如何用四种类型的join.转换我们的数据

结论

通过与你熟悉的东西联系起来，我认为你可以更好地学习和记忆新的东西。我希望这些技巧能够在将来当你开始钻研 Python 中的数据操作时作为有用的备忘单。祝你好运！

应用研究设计用词云指南

原文：https://towardsdatascience.com/guide-to-using-word-clouds-for-applied-research-design-2e07a6a1a513?source=collection_archive---------18-----------------------

发现文本数据可视化在应用研究中的基本应用，并将其用于您的项目

作者图片

作者:彼得·科拉布 (布拉格，Lentiamo 德国齐柏林大学)、雅尔科·菲德姆克 *(德国齐柏林大学)*和大卫·什特尔巴 (布拉格兰蒂莫)

介绍

在应用经济研究中，经常分析各种形式的文本数据，包括陈述、演讲、公告及其效果。由于文本可以量化并用于建模和预测，研究人员使用各种技术来钻取它并将其用于他们的实证设计。

更具体地说，单词 cloud 是一个简单但广泛使用的图形，用于显示和理解文本数据的结构。所有主要的统计程序如 R 、 SPSS 、 Python 、 STATA 、 MATLAB 以及商业智能工具如 Tableau 、 Looker 、 Power BI 都包含一个 word cloud 实现。Word clouds 还开发了更具吸引力的功能，包括各种形状和背景。

这个简短的指南将向您介绍 word cloud 在设计应用研究和数据科学项目中的四个主要应用，以及一个 Python 实现。您将学习如何:

• 使用词云理解数据的结构
• 选择模型的基本特征
• 理解文本数据中的上下文
• 用词云让数据讲故事

什么是词云？

词云是由特定文本中使用的词组成的图像，其中每个词的大小表明其频率或重要性。这是一个在商业和学术界经常使用的简单图表。从技术上来说，词云是基于计算语言学中的 n 元语法和来自文本或语音样本的 n 项的概率场序列。这些项目可以是音节、字母或单词。

使用拉丁数字前缀，大小为 1 的 n 克被称为**“一元格】，大小为 2 的是“二元格”，大小为 3 的是“三元格”**。当 N=1 时，单字实质上就是句子中的单个单词。例如，在句子“牛跳过月亮”中，如果 N = 2 ，那么 N 个字母组是:“牛”、“牛跳”、“跳过”、“越过”等。若 N = 3 ，则 N 个字母组分别为:“牛跳”、“牛跳”、“跳过”和“跳过月亮”。

许多数据应用程序实际上都使用克数。其中之一是Google Books Ngram Viewer，这是一个在线搜索引擎，它使用在 Google Books 的数字化资源库中找到的 n-gram 的年度计数来绘制任何一组搜索字符串的频率。

在学术界，研究人员最近使用词云来显示文本数据中的频率。在金融领域， Feldkircher 和他的同事们收集了欧洲各国央行行长的讲话，并对其内容进行了分析。在《经济文献杂志》的文章中，鲍尔斯和卡林用文字云来说明经济学教学改革的必要性。早在 2018 年，艾伦和麦卡里尔就探索了关于全球变暖、气候变化和天气的 Twitter 数据，并使用词云来绘制美国前总统唐纳德·特朗普发布的推文中最突出的词。

数据汇总

词云旨在总结文本数据。让我们用欧洲央行(ECB)行长克里斯蒂娜·拉加德(Christine Lagarde)在 2021 年 9 月央行行长论坛上的一次演讲来证明这一点。该讲座可在欧洲央行的网站上获得。即使不读书，我们也能一眼看懂欧洲央行行长的话题。为了实现这一点，的关键问题是:

• 数据的结构是什么？
• 数据中需要重点关注的关键话题是什么？

我们将使用 Python 的 matplotlib 和 wordcloud 库:

文章文本被复制到一个字符串变量:

最后，我们用摘要文本生成一个词云。

通过几行代码，我们看到欧洲央行行长主要关注通胀，而通胀与疫情、复苏、衰退、工资和供给有关。这些显然是欧洲经济在科维德危机两年后面临的话题。

作者图片

这个词云应用的好处随着数据量的增加而显著增加。如果数据集包含几十或几百 MB，那么读取这样的文本会消耗大量时间。另一方面，运行 python 脚本只需几秒钟，可以自动化，并为潜在决策提供最相关的信息。

F 特征选择

超越简单的数据汇总，但遵循相同的原则，我们可以选择最关键的因素，并将其用于进一步建模。特征选择是机器学习中常用的术语，指的是为模型选择必要的变量。词云显示词频(或 n -1 克)或词共现(高阶n-克)，它们本质上对文本数据也是如此。

****关键问题在这里:

• 与特定主题相关的最重要的因素是什么？

这个例子的数据集是冠状病毒新闻标题数据集，可以在 Kaggle 免费获得。在这里，更具体地说，我们可以讨论以下问题:

• 在新冠肺炎疫情期间，讨论最多的话题是什么？

我们只从包含 Covid 危机开始的数据集中选取前 2000 个标题。这个子集就是上一个例子中相同 python 代码的源数据。

作者图片

我们可以看到，Covid 19 爆发后，媒体关注的是它的起源:中国，武汉，以及它向其他国家的传播。任何关注 Covid 危机开始的社会和经济研究都应该反映这些关键因素。

动画词云

词云通常表现为没有时间维度的的静态图。另一方面，动画单词云将动态特征添加到分析中，并有助于讲述有关数据的故事。将数百张图片组合成一个 MP4 视频，我们可以看到话题随着时间的发展所具有的意义。****

**迈克尔·凯恩和他的同事引入了这种原始的方法，收集了在科学杂志摘要中发现的 250 个最常用的单词，并开发了一个名为 **the Word Swarm 的动态版本的单词云。Python 代码可以从他们的 GitHub 中免费获得。

我们优化了 Python 3.8 的原始代码。并用它来分析发表在五个最著名的经济期刊上的文章标题。我们的数据由从这些期刊的文章标题中构建的词频(即单字)组成。动画单词云以激动人心的视频演示方式展示了数据中的研究趋势。文章可从这里获得。

资料来源: Koráb、trba、Fidrmuc (2021 年)。一种新颖的词频可视化方法。In: Python 直白的英语。

文字网络可视化

词云用于生成文本数据的可视摘要；然而，他们可能会忘记上下文。存在得到错误结果和对基础数据做出错误假设的风险。文本网络分析通过考虑“单词”的共现(即高阶 n -grams)来解决这个问题，并提出了一种不同的文本思维方式:不是概念云，而是概念之间关系的云。

InfraNodus 是另一个以文本网络分析为核心框架进行文本挖掘和文本数据分析的工具。文本网络方法可以概括为以下步骤:

• 从各种来源导入数据
• 生成网络结构
• 创建一个与其他相关主题相关的单词云

我们之前的文章提供了对 InfraNodus 的详细介绍，包括在新冠肺炎危机期间对 google 查询的深入分析。要了解更多详细信息，也请阅读 InfraNodus 文档和一个 word cloud 案例研究。

资料来源:科拉布(2021 年)。InfraNodus:文本数据分析的优秀工具。In:走向数据科学。

结论

互联网和其他数字数据源提供了大量的文本信息。例如，政策制定者的演讲可以在网上免费获取，既面向公众，也面向投资者和研究人员等决策者。处理和可视化这些标准方法无法处理的大量信息(阅读和手动总结)变得非常重要。

本文提出了词云在静态、动态和文本网络形式的应用研究设计中的三种应用。我们证明了这些方法对于在早期阶段设计研究或者在后期阶段展示结果是非常有用的。它们还可以用于各种使用文本数据的数据科学项目，无论是在公司还是在其他地方。在不久的将来，工具的数量及其在各个领域的应用肯定会增加。

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

作为数据科学家开始第一次实习前的指导方针

原文：https://towardsdatascience.com/guidelines-before-starting-your-first-internship-as-a-data-scientist-791f435ff709?source=collection_archive---------38-----------------------

在一家瑞士咨询公司做了一年的 ML 工程师

在这里你会找到一些我在开始实习前就知道的提示和建议！

丹尼尔·麦金尼斯在 Unsplash 上的照片

帖子的目的:

这篇文章将引导你完成我的第一次实习之旅。您将找到数据科学家必备工程材料的相关信息，更重要的是，它将帮助您迅速成为同事的可靠伙伴。

在开始我作为一名 ML 工程师的第一次实习之前，我在网上查了一下哪些工具我可能会日常使用。事实证明，找到简明的信息比预期的要难。因此，我决定分享一些我希望在我出生前就知道的建议！

根据你将要工作的公司，你不一定会用到所有这些工具。但是，了解它们会让你成为更好的程序员！

指南:

• *如何在远程服务器上工作？*用 ssh 协议对话，用 tmux 工作。
• 如何和多个工程师一起开发代码？ Github 就是你的一切。
• 如何部署你的项目？ Docker 是你部署的第一步。

如何在远程服务器上工作？

今天，许多公司都在云服务器上工作。了解远程访问协议的基础知识会给你的主管留下深刻印象，并在你实习的头几天为你节省宝贵的时间。你不需要掌握所有的东西，但是能够使用主要的命令会让你很快上手！

照片由 Kvistholt 摄影在 Unsplash 拍摄

什么是宋承宪？

SSH(或安全外壳)是一种远程管理协议，允许用户控制和更改他们的远程服务器。赫尔辛基理工大学的研究员塔图·伊洛宁创建了这个协议，以确保所有与远程服务器的通信都以加密的方式进行。

你需要什么

• 服务器及其 IP 地址
• 使用 sudo 访问的服务器设置
• 本地计算机

Mac/Linux 用户如何使用 SSH 协议

如果您只需要一个密码就可以进行基本的服务器访问，那么使用下面的命令和您的用户名以及 IP 地址。

ssh <user>@<IP-Address>

如果您需要在服务器上打开一个端口，您可以使用 -p 选项轻松完成:

ssh -p 24601 <user>@<IP-Address>

如果您需要使用一个 SSH 密钥(它是一个带有锁定语句的散列密钥)，您将需要首先生成一个 SSH 密钥:

ssh-keygen -t rsa

上面的命令为非对称加密创建了两个密钥——一个用于加密的公共密钥和一个用于描述的私有密钥，并要求您选择存储密钥的路径。我鼓励你保持预设的路径。然后，您将能够通过添加-i 选项和您的公钥的路径来访问您的远程服务器。

ssh -i path/id_rsa.pub <user>@<IP-Address>

对于 Windows 用户，可以使用 Putty。可以关注这个网站。

你知道 Tmux 吗？

它是一个终端管理器，允许你在后台运行程序。这是它最初的主要目的，但是随着我对它的特性了解越来越多，我开始在每次打开终端时使用它！这个终端管理器允许您以高效的方式同时设置许多终端。其结构类似于 Vim 代码编辑器。因此，通过避免使用鼠标，你将比以往任何时候都编程更快！

它可以在 Mac OS 和 Linux OS 上使用。因此，即使你有 Windows，仍然可以使用虚拟机来设置 tmux！

安装:

对于 Mac 用户

brew install tmux

适用于 Linux Ubuntu 或 Debian

sudo apt install tmux

开始使用 tmux:

要开始你的第一个疗程，写下:

tmux

或者，如果您想用预定义的名称创建一个新的:

tmux new -s session_name

如你所见，它就像一个新的终端！但是它可以做得更多。例如，要获得所有命令的列表，您可以键入:Ctrl+b ?

如果要离开当前会话:Ctrl+b

如果你需要继续治疗。首先，列出所有可用的会话:

tmux ls

然后，在会话名称后附加:

tmux a -t session_name

或者，如果您想终止一个会话:

tmux kill-session -t myname

为什么要深入？

如前所述，使用 tmux 作为终端管理器，您可以做的不仅仅是简单的终端界面！如果你看一看这个网站，你会发现你将能够同时管理不止一个而是多个终端(称为窗格)!

如何与多名工程师一起开发代码

Github 是最知名的源代码管理器。它为每个项目提供了代码历史、安全控制、更新跟踪、特性请求、任务管理、持续集成和 wikis。

你需要尽快了解如何使用 GitHub！这是你需要快速变得敏锐的最重要的技能之一。它的技术是独一无二的，它的结构使它非常坚固。它创造的真实故事是非凡的，如果你渴望了解它，我给你链接！

扬西·敏在 Unsplash 上的照片

你需要意识到的主要是 Git 和 Github 的存在。仅仅放；Git 是一个分布式版本控制系统，可以让你管理和跟踪你的源代码历史。GitHub 是其基于云的托管服务，使您能够与其他人一起管理 Git 存储库。这个软件可能会在你作为工程师的整个职业生涯中跟随你！可以比作程序员的脸书，很多公司会尝试/要求访问你在 Github 上的项目。在这个网站上，招聘人员可以很容易地收集到很多信息，帮助他们建立你的个人资料。因此，不要忘记清理你的代码，如果你认为你的项目可以卖得更好，分享你的项目！

安装:

Linux:

sudo apt install git

Mac 用户:

brew install git

Windows:跟随网页链接

现在让我们试一试:

尝试下面的步骤来了解 Git/GitHub 中的主要流程！让我们从一个例子开始:

假设一个 python 代码在某个特定的功能上有一点小问题:您正在使用一个 python 包，它会向您发送关于代码进度的通知。您意识到当代码失败时还不可能发送错误消息。因此，你肯定喜欢这个工具的想法，你想通过增加这个小特性来改进它！

由于它的源代码在 GitHub 上是开源的，您可以执行以下步骤:

1. 在本地机器上克隆存储库:

git clone https://github.com/lolilol/package.git

2)然后，创建你的源代码的 分支 并发送到你的个人 GitHub

git checkout -b issue123
git remote add upstream https://github.com/my_name/demo.git

3. 更新丢失的代码并运行一些测试。

4. 提交 和 推送 您的变更到您的新分支。

git commit -a -m 'Fixed issue 123'
git push -u origin issue123

5)打开一个 拉请求 给仓库的维护者:一旦你将变更推送到你的仓库，GitHub 中就会出现比较&拉请求按钮。点击创建拉动请求按钮，打开拉动请求。

6)如果资源库的维护人员欣赏该代码，就会将 合并 到主分支！

提示和警告:

正如您可能已经听说的那样，许多合并问题和 git 问题很难用很少的经验来解决。因此，我在这里分享一些技巧来避免 Git 可能产生的主要问题。

提示 1: 在每个 git 命令后使用以下命令行来检查您对 Git 行为的预期:

git status

提示 2: 如果您在一些文件之间有合并问题，请不要紧张！Git 将精确地指定由新版本的源代码更新的代码行。您只需要更改需要丢弃的代码部分，然后重新提交您的更改。那么，合并就成功了！这里有一个很好的例子。

提示 3: 不要犯提交和推送超过 GitHub 限制 100MB 的大小的文件的错误！下面两个命令中的一个应该就可以了，但是请记住，您已经在 GitHub 中重写了提交的故事。你需要了解发生了什么，以采取最佳解决方案。检查那两个帖子:链接1&链接 2

git filter-branch --tree-filter 'rm -rf path/to/your/file' HEADgit filter-branch --index-filter 'git rm -r --cached --ignore-unmatch <file/dir>' HEAD

提示 4: 使用 gitignore 文件管理不想推送到 GitHub 的文件夹/文件。这将避免与 3 号提示相关的任何问题！当你在 GitHub 上创建一个新的存储库时，你可以自动为特定的编程语言生成一个 gitignore 文件！

如何部署您的项目

在这个阶段，您能够在服务器上进行通信、工作和协作。您可以在远程机器上设置工作流。最后一步就是要知道怎么部署！

有多种选择，根据项目的重要性，你可能会比我在这篇文章中做得更深入。我主要讲包管理、bash 脚本和 docker。但是你可以自由地去追求你的知识，比如说 Kubernetes！

照片由张秀坤·吕克曼在 Unsplash 上拍摄

为什么使用 bash 脚本？

Bash shell 脚本是可以在终端中执行的命令行。它们将允许你以一种用户友好的方式设置你的应用程序，因为所有奇怪的和不可理解的命令将被收集在一个文件中。

下面是一个下载数据并运行 python 应用程序的 bash 脚本示例。

# create directory.
mkdir models # Download data and deep learning model
wget https:nvjovt/model.zip
cd models && unzip model.zip && rm model.zip && cd ..wget https:nvjovt/data.zip
unzip data.zip && rm data.zip# Run python code
python3.7 app.py

一个简单的命令可以用一个来运行这个脚本。sh 扩展:

bash setup_app.sh

包管理和虚拟环境

打包和虚拟环境密切相关，因为它们都关注包的依赖性。因此，建立一个项目最简单的方法是创建一个虚拟环境并在其中安装软件包。但是你可以用不同的包装来简化你的生活。

下面的包管理器创建了一个虚拟环境，它们还负责包之间的依赖关系！它使用起来更舒服，但是它需要花费时间！下载软件包通常需要更多的时间，但是您可以相信它们会有更简单的部署。

python 最著名的管理器叫做 **pipenv。因此，**让我们以此为例向你展示他们的特色。你可以用一个 pip 命令安装它:

pip install pipenv

使用一个简单的命令，您将创建虚拟环境和包管理器:

pipenv shell

您将看到一个文件名为 Pipfile 的文件，包就保存在这里。这个管理器的一个很大的特点是可以设置一些开发包，这些开发包只能因为开发的原因而安装。

要下载软件包，请使用以下命令之一:

pipenv install package_name 
pipenv install "package_name~=2.2"

要在开发阶段下载它，请使用:

pipenv install package_name --dev

然后，当您想要使用正确的库和正确的版本部署应用程序时，您需要使用以下内容锁定包依赖关系:

pipenv lock

这将创建/更新您的Pipfile.lock。这个文件冻结了你当前的包和它们的依赖关系。现在任何人都可以访问这个文件，您可以运行pipenv install --ignore-pipfile来创建相同的环境！或者pipenv install --dev如果有人需要访问开发包。

提示 1: 尽管这需要一些时间，但是如果不使用这样的打包管理器，您很可能会遇到依赖问题。他们真让人头疼！

提示 2: 它们还有额外的功能，可以帮助你在 Heroku 或 Flask 上部署应用！检查下面的连杆。

提示 3: 还有其他的打包管理器，你可以查看一下poem，因为它可能有比 pipenv 更适合你的特性。

为什么应该使用 Docker？

Docker 是一个你可能已经听说过的开源软件。它使用其操作系统创建容器，以避免在其他机器上部署解决方案时出现软件依赖性问题。我鼓励你学习 Docker，因为如果你从事计算工程，你将会使用它或者其他类似的软件。

总结其复杂的层次，Docker 可以运行与虚拟机目标相同的容器。在每个容器中运行一个独特的操作系统及其环境。你可能会问，为什么大多数人更喜欢 Docker 而不是虚拟机？因为它设置起来容易多了，而且相比 VM 也优化的很好！

首先，你需要学习图像，我们将一起看一个例子！然后，您将了解 Docker Hub，它遵循与 Github 相同的理念。最终，您将能够使用一个命令在任何 Linux 操作系统上部署应用程序！干杯！

如何下载 docker:

• 对于 Mac 用户:跟随这个链接。
• 对于 Linux 用户:跟随这个链接。
• 对于 Windows 用户:跟随这个链接。

主要命令有:构建和运行。第一个命令创建图像。第二个在你的机器上运行。但是在玩命令之前，让我们先了解一下会做一切的 Dockerfile！

什么是 Dockerfile

当您的项目完成并准备部署时，您可以从在工作目录中创建 Dockerfil 开始。这个文件是特殊的，它将定义你的 docker 图像的工作方式！如果你的应用程序需要大量内存，你可以优化这个文件，以确保你没有任何无用的包或数据。

如上所述，这个文件生成操作系统，导入源代码，并设置容器动作。以下是 Dockerfile 文件的可能结构示例:

FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py

请记住:

1. FROM:您将始终基于另一个图像创建一个图像。
2. 复制:Docker 从基础映像创建一个操作系统，你需要将源代码复制到中
3. 运行:Docker 允许你在操作系统内部运行命令来设置你的容器(例如，bash 脚本、包安装、导入数据集、数据库等。)
4. CMD:您还需要指定启动应用程序将执行的启动命令。它将在您运行容器时使用。

如果你对一个你可以在家尝试的例子感兴趣，这里有一个链接。

当您的 docker 文件准备好时，您可以运行以下命令来构建映像:

docker build folder_path_of_dockerfile -t name_your_image

如果代码没有任何错误地完成了，这意味着您的第一个图像已经准备好了！因为您可能需要在不同的机器上部署解决方案，所以您应该将这个新的映像推送到 Docker Hub 存储库中。它将允许您仅通过互联网连接访问图像。因此，您需要:生成一个 Docker Hub 帐户，创建一个存储库，并将其链接到您的本地机器。

docker login --username=yourhubusername

然后，标记您的图像:

docker images
docker tag image_id username/reponame:tagname

并将其推送到您的 Docker Hub 存储库:

docker push account_name/repo_name:tag_name

现在，您可以在任何安装了 Docker 的机器上只运行一个命令来启动您的应用程序:

docker run account_name/repo_name:tag_name

维护您的图像/容器:

图像:

• 显示所有图像:docker images ls
• 擦除图像:docker rmi -f image_id
• 擦除所有图像:docker rmi $(docker image -a -q)

容器:

• 显示所有图像:docker container ls -a
• 擦除一个容器:docker rmi -f container_id
• 擦除所有容器:docker rmi $(docker container -a -q)

结论:

如果你已经到了终点，那就意味着你要为实习的第一周做好准备了！祝你好运，年轻的学徒。

图形用户界面或编码:生产与操作

原文：https://towardsdatascience.com/guis-or-coding-production-vs-operation-fc1de9e483a8?source=collection_archive---------42-----------------------

随着我们更深入地进入数据和计算机科学的时代，一场关于我们使用的工具的辩论开始了，是关于 GUI 软件还是编码软件。到底应该用哪一个？

许多从未想过处理数据和分析的研究人员或专业人士在过去几年中发现自己陷入了这一不断扩展的数据科学学科。即使是上个世纪的科学研究也需要许多学术研究人员在小得多的规模上处理数据分析，对于他们来说，构建甚至简单的线性模型都不是一项直观的任务，而是为他们自己提供了一系列 GUI 软件选项来执行这些任务。

由于我们对数据科学的知识从未像现在这样扎实，我们还发现自己在开发数据科学项目时，澄清了执行分析任务的心态和我们的文化。这就是选择使用 GUI 构建我们的分析还是对它们进行编码的时候了。

用户友好的软件从它自己的名字中发现了它的优点，它是为那些没有扎实编程背景的研究人员设计的，以使他们能够执行分析任务。在数据科学中，它可以包括一个漂亮的可视化或者一个汇总表。然而，当谈到数据科学时，我们不再意味着只提供一个数字或一个表格，我们指的是构建管道，对输入观察执行一系列不同的任务。在这方面，我们的最终产品是复杂的，因此我们构建产品的工具也需要健壮。

使用 GUI 软件没有什么本质上的错误，但是我们需要理解它什么时候可以使用，什么时候不满足健壮性。

数据科学的生产与运营。(图片由作者提供)

用户友好的软件不是一个强大的生产环境

在讨论 GUI 软件的使用与编码时，需要考虑的主要区别是开发/生产一个分析管道和操作一个已建成的管道或将其投入使用之间的区别。对于 DevOps 实践下的计算机科学家和软件开发人员来说，这种区别在历史上一直非常明显，现在是时候开始为数据科学家/统计学家或任何发现自己正在进行数据分析的研究人员澄清这一点了。

为了使用一个数据分析实例，我们可以考虑构建一个预测模型。处理线性模型以发布 p 值的经典统计学家或研究人员可以将自己置于此处，因为计算 p 值是构建线性模型的副产品。构建模型需要多种方法，例如清理数据、过滤信息、测试不同的模型架构、可能在不同标准下进行优化等。许多 GUI 软件都包含执行这项任务的工具，不同方面的面板，不同选项的下拉菜单，最后，由用户测试(许多)不同的选项并保存输出以做出最终决定。

上面描述的场景相当于在高速公路旁边建一辆汽车，上面有一个帐篷，可以存放所有必要的工具。类似的是在办公室的办公桌上搭建一台电脑。这是可以做到的，但应该这样做吗？在这两个例子中，很容易区分这两种环境:有一个生产环境，它通常根据构建它的任务(构建片段、集合等)被分成不同的环境。)，还有一个操作环境，就是高速公路或者办公室的办公桌。

编程是每个人的

即使一个模型的生产可以很好地在 GUI 软件中进行，这也不能破坏我们通过编程构建分析工具时的健壮性和准确性。随着计算和数据科学的飞速发展，编程或编码正成为本世纪的一项必要技能。为数据分析构建我们的模型或管道需要开始从他们的操作环境中获得独立的位置。我们越是致力于一个清晰和健壮的环境来生产我们的模型，我们将为以后的部署构建更精确的机器。

制作一个模型并不是一个用户友好的任务，但是操作它肯定是。

尽管编程对于许多专业人士来说仍然是一个难以理解的概念，但这个概念现在比以往任何时候都更加用户友好。像 Python 和 R 这样的编程语言在语法和范式上都非常容易理解，更不用说开放访问设施了。它们不是轻轻一点就能出现的，但与学习 c 等低级语言相比，它们付出的努力要少得多。请注意，这里的“显著”没有 p 值来证明。

GUI:操作环境

因此，并不是说图形用户界面一点用都没有。用户友好的软件，正如它的名字所声明的，是用来完成用户友好的任务的。制作一个模型并不是一个用户友好的任务，但是操作它肯定是。从这个角度来看，我们可以并且可能仍然应该依赖 GUI 作为我们的模型或数据科学管道的部署模式。

GUI 在编码方面无法超越的一个方面:再现性

讨论中不能忽略的另一个方面是再现性原则，这在通过计算机发展的科学中特别重要。再现性是学术界和工业界许多领域讨论的一个新兴话题。在不同的讨论中，我们发现关于对人工智能来说可再现性意味着什么、科学和它所代表的价值的争论。尽管一种编码文化并不能保证流畅的可再现性，因为还需要更多的东西，但是它确实克服了 GUI 的缺点，比如完全依赖于用户。

随着我们渴望成为更好的数据科学家，以及该领域的持续增长，特别是以如此高的速度增长，事实证明有必要为发展新技能腾出空间，并将我们的工作文化从更快的生产结果转变为数据科学的稳健生产环境。

HAC:层次凝聚聚类——比 K-Means 更好吗？

原文：https://towardsdatascience.com/hac-hierarchical-agglomerative-clustering-is-it-better-than-k-means-4ff6f459e390?source=collection_archive---------8-----------------------

机器学习

HAC 算法的详细介绍，以及 Python 代码和几个有用的图表

层次凝聚聚类(HAC)。图片由作者提供。

介绍

如果你想成为一名成功的数据科学家，了解不同的机器学习算法是如何工作的是至关重要的。

这个故事是解释每个算法的细微差别的系列的一部分，并提供了一系列 Python 示例来帮助您构建自己的 ML 模型。

故事涵盖以下主题:

• 层次凝聚聚类(HAC)属于算法的范畴。
• HAC 算法如何工作的细节。
• Python 示例，使用 HAC 对澳大利亚城市进行聚类。

层次凝聚聚类属于哪一类算法？

答案就藏在它的名字里。由于 HAC 是一种聚类算法，它位于机器学习的无监督分支之下。

无监督技术，尤其是聚类，通常用于细分分析，或作为更复杂项目的起点，这些项目需要了解数据点之间的相似性(例如，客户、产品、行为)。

下面的图表是我对各种不同算法进行分类的尝试。在许多情况下，一个算法可以用来解决多种类型的问题。例如，由于神经网络独特的机器学习方法，我将神经网络归为一类。然而，神经网络可以用于广泛的问题，如分类，回归，或作为强化学习的一个组成部分。

下图是互动，所以请点击不同类别放大并展示更多👇。

机器学习算法分类。由作者创建的互动图表。

如果你喜欢数据科学和机器学习 ，请 订阅 每当我发表一个新的故事，你都会收到一封电子邮件。

分层凝聚聚类(HAC)算法是如何工作的？

基础知识

HAC 不像 K-Means 那样广为人知，但它非常灵活，通常更容易解释。它使用“自下而上”的方法，这意味着每个观察从它自己的集群开始，随着一个集群在层次结构中向上移动，集群对被合并。

为了帮助说明这一点，我制作了一些图表。第一个演示了该算法如何一步一步地合并最近的点，直到只剩下一个聚类。

等级凝聚聚类(HAC)的作用。图片由作者提供。

注意，上面的 HAC 实现使用了“平均”链接，我将在本节稍后解释这一点。

第二张图被称为树状图。它给出了所采取的路径的全貌，从所有单独的点(图形的底部)移动到一个单独的点/簇(图形的顶部)。

层次凝聚聚类(HAC)树状图。图片由作者提供。

注意，我添加了一条水平虚线来表示我选择的集群的数量。一般来说，一个好的经验法则是确定 y 轴上没有垂直线与任何水平线相交的最大部分。让我进一步解释一下。

y 轴上的值是点/簇之间接近程度的度量。水平线表示那些点/簇被合并的地方。

上图表明您可能需要考虑 2 个集群，因为没有集群合并的最大距离在 24 和 30 之间(30–24 = 6)。

然而，在这种情况下，我决定选择 4 个集群，这是一个稍微不太理想的解决方案(大约。19.5–14.5=5).因此，我的集群是红色，亮绿色，蓝色，诺福克岛独自坐在角落里。

这是星团在地图上的样子:

用 HAC 算法进行澳大利亚城市聚类。图片由作者提供。

链接类型

有多种方法将这些点连接在一起。我在上面的例子中使用了“平均”链接，因为它易于说明和理解。但是，熟悉其他链接类型也很重要。注意，本文末尾的 Python 部分将向您展示如何指定您想要使用的链接方法。

• **‘Average’😗*使用两个集合的每个观察值的距离的平均值，即找到观察值之间的中点(如图所示)。
• **“Single”😗*使用两个集合的所有观察值之间的最小距离，即在该阶段的点群中寻找最近的点(而不是“average”中使用的群中点)。
• **“完整”或“最大”😗*使用两组所有观察值之间的最大距离。例如，如果该点比聚类 B 的最远点更接近聚类 A 的最远点，则这样的点将被添加到聚类 A 中
• **‘Ward’😗*最小化被合并的聚类的方差。这非常类似于 K-Means 使用的最小化类内平方和(WCSS)。

沃德连杆通常是最常用的一种。它也是 sklearn 实现 HAC 的默认选项，我们将在下面的 Python 部分中探讨。

HAC 优于 K 均值聚类

使用 HAC 最吸引人的部分是分析树状图的能力，它提供了对任意两个数据点之间相似性水平的洞察。

只需看一眼树状图，就能看出皮尔斯-布斯布鲁克离诺福克岛很“远”，而悉尼和悉尼机场离得很近。鉴于我们的位置数据，这是相当明显的，当我们使用更抽象的属性时，它变得非常有益。

一般来说，您可以使用 HAC 和 K-Means 生成非常相似的聚类，但是能够查看每个数据点的路径，使得 HAC 在分析各个数据点或聚类之间的相似性和差异时更有用。

使用澳大利亚城市位置数据的 Python 中的层次凝聚聚类(HAC)

设置

我们将使用以下数据和库:

• 来自 Kaggle 的澳大利亚天气数据
• Scikit-learn 库执行 HAC 聚类
• Scipy 库创建树状图
• 用于数据可视化的 Plotly 和 Matplotlib
• 熊猫用于数据操作
• 地理坐标，进度条，采集澳大利亚城市坐标的时间

让我们导入所有的库:

然后我们从 Kaggle 获取澳大利亚的天气数据，你可以按照这个链接下载:https://www . ka ggle . com/jsphyg/weather-dataset-rattle-package。

我们接收数据并派生出一些新的变量，比如 Location2，它具有使用 Geopy 提取城市坐标的正确格式。

经过一些修改的 Kaggle 的澳大利亚天气数据片段。图片由作者提供。

因为我们的原始数据只包含位置(城市)名称而不包含坐标，所以我们将使用 Geopy 的名称来获取这些坐标。请注意，我们在每次调用之间添加了 1 秒钟的睡眠时间，以避免服务器过载。

这是我们得到的回报片段:

澳大利亚城市坐标。图片由作者提供。

让我们在地图上标出这些城市:

地图上的澳大利亚城市。图片由作者提供。

HAC 聚类—树状图

为了决定聚类的数量，我们将首先绘制一个类似于我们前面分析的树状图。请注意，我们将绘制其中两个，一个使用“平均”链接，另一个使用“沃德”链接，这样您就可以看到结果的差异。

平均联动:

使用平均联动的 HAC 树状图(同上)。图片由作者提供。

病房联动:

HAC 树状图使用 ward 联动。图片由作者提供。

如你所见，当使用“ward”链接时，我们得到了完全不同的结果。之前的蓝色星团已经一分为二，孤独的诺福克岛已经并入紫色星团。

HAC 聚类—生成聚类标签

既然我们已经决定有 4 个聚类，让我们运行 scikit learn 的 HAC 算法来为“平均”和“区”链接方法生成聚类标签。

附加了聚类标签的位置数据片段。图片来自作者。

最后，让我们在地图上画出结果。

平均联动:

使用平均链接的澳大利亚城市 HAC 聚类(同上)。图片由作者提供。

病房联动:

为了使用’ ward ‘绘制聚类，我们使用了与上面相同的 Python 代码，只是我们将第 5 行和第 8 行中的’ Clusta4 ‘更改为’ Clustw4 '。

使用 ward 链接的澳大利亚城市 HAC 聚类。图片由作者提供。

结论

分层凝聚聚类的好处在于，它让您可以通过树状图了解所有数据点的接近程度。当您通过使用两个以上的属性将聚类带到多维空间时，这变得更加重要。

总结一下，我想重申我在 K-Means 文章里说过的话:**聚类很少是你分析的终点；通常，这只是一个开始。**因此，一定要探索如何使用新创建的聚类来提高对数据的理解，并了解它如何帮助开发其他类型的模型。

祝您在项目中使用 HAC 愉快，如果您有任何问题或建议，请随时告诉我！

干杯！👏
T3【索尔·多比拉斯】T4

如果你已经花光了这个月的学习预算，下次请记得我。 我的个性化链接加入媒介是:

https://solclover.com/membership

如果您喜欢这篇文章，您可能也会喜欢对其他类型的聚类算法的内部工作原理的详细解释: