TowardsDataScience-博客中文翻译-2021-四十九-

龙哥盟 / 2024-10-22 / 原文

TowardsDataScience 博客中文翻译 2021（四十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

如何使用人工智能生成“corridos tumbados”失败

原文：https://towardsdatascience.com/how-to-fail-to-generate-corridos-tumbados-using-ai-b10395d09e26?source=collection_archive---------41-----------------------

“Corridos tumbados”和机器学习

俄罗斯摄影师在 Unsplash 上拍摄的照片

Eliud Gilberto Rodríguez Martínez、Hugo Francisco Cano Beyliss、Martin joséVega Noriega。

索诺拉大学，埃莫西约，索诺拉，

mjvnor@outlook.com，slabxcobra@gmail.com，eliud.giroma@gmail.com。

摘要。该项目旨在使用神经网络为 Julio Waissman Vilanova 教授的神经网络课程生成“corridos tumbados”。我们承担了使用不同方法生成歌曲的任务，使用不同的神经网络，如 RNNs、WaveNets 和合成器。在这里，我们解释了为什么我们能够执行这项任务，但不便之处在于，由于执行这项任务时出现的各种问题，如数据集有大量噪声(他们有不止一台仪器)，以及没有处理大型网络所需的设备，结果不如预期。

关键词: corridos tumbados，神经网络，lstm，wavenet，n-synth，keras

为什么我们决定做这个项目

我们决定做这个项目是因为 Julio Waissman Vilanova 教授在神经网络课上分配给我们的一项任务，这项任务是关于使用递归神经网络(RNN)创作音乐，我们决定借此机会创作主要在墨西哥北部非常流行的“corridos tumbados”。

什么是 corrido tumbado？

Corridos tumbados 是墨西哥地区的变体，是传统 corrido 的变体，但包含了 hip-hop 和 trap，他们的歌手通常穿着 trap 的特色服装。你绝对应该听听。

我们所做的…

我们尝试的第一件事

在我们的例子中，没有 corridos tumbados 的 MIDIs 数据集，所以我们开始创建一个。首先，我们想用这些类型歌曲的所有乐器来生成 corridos tumbados，但我们意识到这太费时且难以实现，所以我们使用了“SpleeterGui”软件来获取我们手头的 corridos tumbados 的 requintos。为什么要求？requinto 是 corridos tumbados 的主要乐器，没有这个乐器就不是 corridos tumbados。我们使用谷歌提供的一个名为“Onsets and Frames”的人工智能，这是一个带有钢琴和鼓模型的自动音乐转录框架，它将帮助我们将安魂曲转换为 MIDIs。

Colab:

https://colab.research.google.com/github/MJVNOR/DatasetMidiCorridosTumbadosAcustico/blob/main/Onsets_and_Frames.ipynb

我们生成了大约 241 个 MIDI 格式的 corridos tumbados，在一个名为“music21”的库的帮助下，我们从中提取音符和和弦，并将它们用作我们网络的输入。然后，我们用一个长短期记忆递归神经网络(LSTM)来产生谎言运行，这是结果:

Colab:

https://colab.research.google.com/github/MJVNOR/DatasetMidiCorridosTumbadosAcustico/blob/main/GeneratorMusicLstm.ipynb

我们失败的原因

我们失败了，因为我们的数据集不够好，它包含了太多的噪音和除了 requintos 以外的其他乐器。我们还需要做更多的 epoch 来更好地生成歌曲，这是一个问题，因为如果我们给它更多的 epoch，它需要超过 15 个小时才能完成，当你超过这个时间时，google colab 不再允许你使用他们的 gpu。

我们尝试的第二件事

我们尝试的第二件事是使用一个名为 N-SYNTH 的 magenta 项目，这是一个神经合成器。N-SYNTH 合成器操纵数据而不是操纵声音；分析音频文件，了解数据之间的关系，然后从头开始制作新的音频文件。要听质量接近现实生活的音乐，需要 48000 个样本。这个合成器基于上面的几千个样本，以及经过训练的音频，一次生成一个样本，听起来有点差，因为使用了 16，000 个样本，而不是 48，000 个样本，这仍然是相当多的。

结果:
Colab:

https://colab.research.google.com/github/MJVNOR/DatasetMidiCorridosTumbadosAcustico/blob/main/nsynth.ipynb

该算法用高音声音训练，它用来自一千种不同乐器的 30 万个音符训练。当您组合两种完全不同的声音时，合成器会更加复杂，因为它必须处理更多的声音，而不仅仅是单个音符，除了合成器在高音方面受过训练，所以它会尝试将任何其他频率解释为高音，这意味着，除了通过使用 16，000 个样本来创建低质量的旋律之外，由于可能缺乏乐器，并希望将频率提高，从而产生看起来像恐怖电影一样的音频畸变。

我们尝试的最后一件事

我们最后尝试使用的是波网。使用 WaveNet 架构的简化版本，而不添加剩余连接或跳过连接，因为这些层的作用是提高快速收敛，并且 WaveNet 将原始音频波作为输入，但是在我们的情况下，输入将是一组节点和和弦，因为我们正在生成音乐。

结果:

少年 H(最佳 5 名)| 50 岁

少年 H(最佳 5 名)| 500 纪元

完整数据集| 50 个纪元

完整数据集| 200 个历元

Colab:

https://colab.research.google.com/github/MJVNOR/DatasetMidiCorridosTumbadosAcustico/blob/main/AutoMusicGen.ipynb

我们失败的原因

有几种可能性，但我们认为该模型未能提取歌曲的重要特征，这是因为该模型仅适用于一种类型的乐器，并且由于我们的数据集不如我们希望的那样干净，这引入了影响学习阶段的噪声，此外，该模型可能需要更多的时期来训练或更多的歌曲。

什么是 LSTM？

长短期记忆(LSTM)网络是一种递归神经网络，它扩展了递归神经网络的记忆，它们有短期记忆问题，所以它们只使用以前的信息，所以它们没有神经节点可用的所有上述信息的列表。由于它们特有的行为，它们被用于解决语音识别问题、手写识别、音乐创作等。递归神经网络无法解决的复杂问题。

什么是 Wavenet？

WaveNet 是一种称为深度卷积神经网络的神经网络，用于生成逐个样本的音频。该技术能够通过使用直接来自真实人类语音样本的经过训练的神经网络直接对波形进行建模来生成逼真的声音，例如人类语音。Wavenet 生成波形的能力允许对任何类型的音频进行建模，包括音乐。在 WaveNet 中，网络采样信号作为输入，并逐个采样输出进行合成。

什么是插值？

插值包括利用特定数据集的信息进行有根据的猜测。根据你手头的信息，这是一个“最佳猜测”。插值是我们经常使用的人工智能。把数据输入计算机，让它为我们做出有根据的猜测。理论上，内插法对于提取有关情况的数据和利用已知经验将知识扩展到不熟悉的领域也很有用。然而，这通常被称为外推。

结论

我们的结论是，我们必须努力改进我们的数据集，如果它更干净，我们第二次尝试的输出就会有很大的改进。除了 google colab 之外，我们还应该使用另一个系统来长时间运行模型。

Github 知识库

https://github.com/MJVNOR/DatasetMidiCorridosTumbadosAcustico

参考

霍桑，c .、埃尔森，e .、宋，j .、罗伯茨，a .、西蒙，I .、拉弗尔，c .、… &埃克，D. (2017)。双目标钢琴改编曲。arXiv 预印本 arXiv:1710.11153。

https://deepai.org/machine-learning-glossary-and-terms/interpolation https://hub.packtpub.com/what-is-lstm/

如何在 LinkedIn 上展示你的 GitHub 知识库

原文：https://towardsdatascience.com/how-to-feature-your-github-repositories-on-linkedin-56078e1ffddb?source=collection_archive---------2-----------------------

把你的工作放在聚光灯下！

Abhyuday Majhi 在 Unsplash 上拍摄的照片

你是一名数据科学家还是软件开发人员，想要在你的 LinkedIn 个人资料上突出你来自 GitHub 的最佳作品？如果是这样，请继续阅读。

步骤 1)在 GitHub 上设置社交媒体预览图片。

记住一句老话，“一图胜千言”，选择一个合适的图像来代表你的作品。 Unsplash 、 Pexels 和 Canva 是一些可免费使用的图片资源。
转到您的 repo 并点击设置。
进入社交预览部分，点击编辑上传图片。
对您想要的每个回购重复上述步骤。

作者图片

第 2 步)在你的 LinkedIn 个人资料中展示你的回购。

转到你的 LinkedIn 个人资料的特色部分(就在关于部分的下方)。
单击加号以显示不同类型的项目。
点击链接。
在添加链接弹出窗口中输入您的回购的 URL，然后点击添加。
输入您希望项目显示的标题和描述，然后点击保存。
同样，对您想要的每个回购重复上述步骤。

从我的错误中吸取教训！

当我最初在我的 LinkedIn 个人资料上展示我的项目时，我忘记了事先在 GitHub 上设置社交媒体预览图像。结果呢？我的 GitHub 档案头像显示在每个…单个…项目上。多么重复，无聊，没有信息！

当然，我想尽快解决这个问题，所以我赶紧回到我的 GitHub 并添加了社交媒体预览图片。我查看了我的 LinkedIn 个人资料，什么都没有！我刷新了网页，看到了…同样的旧的无聊头像，而不是我深思熟虑选择的完美代表我作品的图像。

英国广播公司 GIF

谢天谢地，有一个快速修复(谢谢，谷歌)！我需要清空 LinkedIn 上的图片缓存。

我上了 LinkedIn 帖子检查器 ，输入我的储存库的网址，点击检查。这清除了图像缓存，我的时髦的新图像显示在我的个人资料上！

现在你知道一个简单的方法来在你的 LinkedIn 个人资料上展示你的 GitHub repos！如果你觉得这有用，请分享，如果这对你有帮助，请随时告诉我。

如何从箱线图中获取精确值(Python)

原文：https://towardsdatascience.com/how-to-fetch-the-exact-values-from-a-boxplot-python-8b8a648fc813?source=collection_archive---------7-----------------------

从 matplotlib 盒图中提取数据集描述性统计数据的有效方法

来自 Unsplash

箱线图是一种可视化类型，用于显示数据集描述性统计数据的五位数集合:最小值和最大值(不包括异常值)、中值、第一(Q1)和第三(Q3)四分位数。在 Python 中，可以在各种数据可视化库中创建箱线图，包括最基本的库— matplotlib。

虽然箱线图的主要作用域是可视化关于数据集的统计信息，但是如果我们还需要提取并打印出这些统计信息的确切数字呢？在本文中，我们将讨论在 matplotlib 库中这样做的最简单的方法。

首先，让我们创建 3 个虚拟数据集，并在 matplotlib 中显示它们的箱线图。为了能够进一步提取必要的值，我们必须将plt.boxplot()方法的结果赋给一个变量(bp):

import matplotlib.pyplot as plt
import numpy as npnp.random.seed(1)
data_1 = np.random.normal(50, 30, 300)
data_2 = np.random.normal(100, 40, 300)
data_3 = np.random.normal(70, 10, 300)
data = [data_1, data_2, data_3]bp = plt.boxplot(data)
plt.show()

作者图片

产生的变量bp是一个 Python 字典:

type(bp)**Output:** dict

以下关键字代表箱线图的主要元素:

bp.keys()**Output:** dict_keys(['whiskers', 'caps', 'boxes', 'medians', 'fliers', 'means'])

这是字典本身:

bp**Output:**
{'whiskers': [<matplotlib.lines.Line2D at 0x1eaf6131b50>,
  <matplotlib.lines.Line2D at 0x1eaf6131eb0>,
  <matplotlib.lines.Line2D at 0x1eaf61533a0>,
  <matplotlib.lines.Line2D at 0x1eaf6153700>,
  <matplotlib.lines.Line2D at 0x1eaf6162b80>,
  <matplotlib.lines.Line2D at 0x1eaf6162ee0>],
 'caps': [<matplotlib.lines.Line2D at 0x1eaf614a250>,
  <matplotlib.lines.Line2D at 0x1eaf614a5b0>,
  <matplotlib.lines.Line2D at 0x1eaf6153a60>,
  <matplotlib.lines.Line2D at 0x1eaf6153dc0>,
  <matplotlib.lines.Line2D at 0x1eaf616d280>,
  <matplotlib.lines.Line2D at 0x1eaf616d5e0>],
 'boxes': [<matplotlib.lines.Line2D at 0x1eaf61317f0>,
  <matplotlib.lines.Line2D at 0x1eaf6153040>,
  <matplotlib.lines.Line2D at 0x1eaf6162820>],
 'medians': [<matplotlib.lines.Line2D at 0x1eaf614a910>,
  <matplotlib.lines.Line2D at 0x1eaf6162160>,
  <matplotlib.lines.Line2D at 0x1eaf616d940>],
 'fliers': [<matplotlib.lines.Line2D at 0x1eaf614ac70>,
  <matplotlib.lines.Line2D at 0x1eaf61624c0>,
  <matplotlib.lines.Line2D at 0x1eaf616dca0>],
 'means': []}

我们看到字典的值实际上是 matplotlib 对象的列表(特别是，matplotlib.lines.Line2D)。总之，我们有 6 个须(每个箱线图 2 个)，6 个帽(每个箱线图 2 个)，然后是 3 个盒子，3 个中间值和 3 组异常值(传单)，每个箱线图一个。奇怪的是means有一个空列表作为它的值。这是因为，默认情况下，箱线图不显示样本平均值。为了在箱线图上显示平均值，我们必须通过可选参数showmeans指定它:

bp = plt.boxplot(data, showmeans=True)
bp['means']**Output:** [<matplotlib.lines.Line2D at 0x1eaf6262790>,
 <matplotlib.lines.Line2D at 0x1eaf627b340>,
 <matplotlib.lines.Line2D at 0x1eaf6286e80>][<matplotlib.lines.Line2D at 0x1eaf6262790>,
 <matplotlib.lines.Line2D at 0x1eaf627b340>,
 <matplotlib.lines.Line2D at 0x1eaf6286e80>]

作者图片

现在，means键的值是一个包含 3 个 matplotlib 对象的列表，而不是一个空列表。此外，在 3 个箱线图中的每一个上，我们都可以看到一个代表每个数据集平均值的新标记。

在提取准确的数字之前，让我们先来看看均值箱线图的主要元素(即字典的关键字)，以及我们将要获得的描述性统计数据:

作者图片

现在，让我们使用get_ydata()方法从字典的每个条目中提取初步的统计值，并记住上图，尝试理解它们的结构:

for key in bp:
    print(f'{key}: {[item.get_ydata() for item in bp[key]]}\n')**Output:** whiskers: [array([ 32.27380667, -23.04513292]), array([ 70.59264691, 125.8497712 ]), array([75.68154245, -0.65215444]), array([131.88978143, 185.5131227 ]), array([63.74451462, 46.95092062]), array([76.33158616, 95.05980285])]

caps: [array([-23.04513292, -23.04513292]), array([125.8497712, 125.8497712]), array([-0.65215444, -0.65215444]), array([185.5131227, 185.5131227]), array([46.95092062, 46.95092062]), array([95.05980285, 95.05980285])]

boxes: [array([32.27380667, 32.27380667, 70.59264691, 70.59264691, 32.27380667]), array([ 75.68154245,  75.68154245, 131.88978143, 131.88978143,
        75.68154245]), array([63.74451462, 63.74451462, 76.33158616, 76.33158616, 63.74451462])]

medians: [array([52.64528282, 52.64528282]), array([100.43803244, 100.43803244]), array([70.10978367, 70.10978367])]

fliers: [array([-33.79255]), array([-11.30137871, 221.23428449, 258.34410816]), array([ 42.09003593,  43.01638258,  39.4623562 , 103.21078756])]

means: [array([52.23199524]), array([102.26099759]), array([69.8400676])]

我们获得了字典中每个键的数组列表。我们实际想要获取的内容包括每个数据集的以下信息:

中间值，
意思是，
没有异常值的最小值，
没有异常值的最大值，
第一个四分之一 Q1，
第三个四分位数 Q3，
较低的异常值，
上层异常值。

看上面的图片，应该注意的是，我们可以从caps或whiskers中提取最小和最大值(我们将使用第一种方法)，并且类似地，对于 Q1 和 Q3:从boxes或whiskers(同样，我们将使用第一种方法)。

中位数和平均值

从上面提取的原始值中，我们看到对于medians，我们有 2 个相同项目的 3 个 n 数组，而对于means — 3 个单项目 n 数组。对于中位数，每个 n 数组描述相应框中的中值线(从左到右)，对于平均值-平均值的点。要获得每个箱线图的中值和平均值的精确值，我们必须选择相应 n 数组的第一项:

medians = [item.get_ydata()[0] for item in bp['medians']]
means = [item.get_ydata()[0] for item in bp['means']]
print(f'Medians: {medians}\n'
      f'Means:   {means}')**Output:** Medians: [52.64528282246805, 100.43803243566403, 70.10978366813102] Means:   [52.23199524458482, 102.26099759095463, 69.84006759933192]

最有可能的是，我们可能不想要如此精确的结果。因此，在这里和其他地方，让我们考虑将数字四舍五入到小数点后第一位:

medians = [round(item.get_ydata()[0], 1) for item in bp['medians']]
means = [round(item.get_ydata()[0], 1) for item in bp['means']]
print(f'Medians: {medians}\n'
      f'Means:   {means}')**Output:** Medians: [52.6, 100.4, 70.1]
Means:   [52.2, 102.3, 69.8]

最小值和最大值

对于最小值和最大值，我们可以使用从caps中提取的 ndarrays。让我们仔细看看它们:

[item.get_ydata() for item in bp['caps']]**Output:** [array([-23.04513292, -23.04513292]),
 array([125.8497712, 125.8497712]),
 array([-0.65215444, -0.65215444]),
 array([185.5131227, 185.5131227]),
 array([46.95092062, 46.95092062]),
 array([95.05980285, 95.05980285])]

两个相同项目的排列顺序如下:第一个(最左边的)箱线图最小，第一个箱线图最大，第二个箱线图最小，依此类推。因此，为了获得所有箱线图的最小值，我们必须使用列表切片来获得奇数 n 数组(并从每个数组中选择第一项)，以获得最大值——偶数。同样在这种情况下，为了方便起见，我们将对第一个小数进行舍入:

minimums = [round(item.get_ydata()[0], 1) for item in bp['caps']][::2]
maximums = [round(item.get_ydata()[0], 1) for item in bp['caps']][1::2]
print(f'Minimums: {minimums}\n'
      f'Maximums: {maximums}')**Output:** Minimums: [-23.0, -0.7, 47.0]
Maximums: [125.8, 185.5, 95.1]

Q1 和第三季度

让我们从boxes中提取第一个和第三个四分位数。要提醒箱子的原始数据:

[item.get_ydata() for item in bp['boxes']]**Output:** [array([32.27380667, 32.27380667, 70.59264691, 70.59264691, 32.27380667]),
 array([ 75.68154245,  75.68154245, 131.88978143, 131.88978143,
         75.68154245]),
 array([63.74451462, 63.74451462, 76.33158616, 76.33158616, 63.74451462])]

观察每个 ndarray(代表每个盒子)的图案，我们可以注意到盒图多边形(矩形)是从左边的最小值开始向右绘制的，最后，在最小值处再次闭合。实际上，我们这里需要的是从每个盒子中提取最小值以获得 Q1，并提取最大值以获得 Q3:

q1 = [round(min(item.get_ydata()), 1) for item in bp['boxes']]
q3 = [round(max(item.get_ydata()), 1) for item in bp['boxes']]
print(f'Q1: {q1}\n'
      f'Q3: {q3}')**Output:** Q1: [32.3, 75.7, 63.7]
Q3: [70.6, 131.9, 76.3]

较低和较高异常值

我们可以在字典键fliers中找到异常值:

[item.get_ydata() for item in bp['fliers']]**Output:** [array([-33.79255]),
 array([-11.30137871, 221.23428449, 258.34410816]),
 array([ 42.09003593,  43.01638258,  39.4623562 , 103.21078756])]

目前，它们按箱线图分组。如果我们希望有两个单独的列表来显示较低和较高的异常值，我们可以应用以下代码:

fliers = [item.get_ydata() for item in bp['fliers']]
lower_outliers = []
upper_outliers = []for i in range(len(fliers)):
    lower_outliers_by_box = []
    upper_outliers_by_box = []
    for outlier in fliers[i]:
        if outlier < q1[i]:
            lower_outliers_by_box.append(round(outlier, 1))
        else:
            upper_outliers_by_box.append(round(outlier, 1))
    lower_outliers.append(lower_outliers_by_box)
    upper_outliers.append(upper_outliers_by_box)print(f'Lower outliers: {lower_outliers}\n'
      f'Upper outliers: {upper_outliers}')**Output:** Lower outliers: [[-33.8], [-11.3], [42.1, 43.0, 39.5]] 
Upper outliers: [[], [221.2, 258.3], [103.2]]

由于第一个箱线图没有任何异常值，我们为它获得了一个空列表。

现在，让我们以一种优雅的方式总结我们从每个数据集提取的所有描述性统计数据。尽管下面的代码看起来有点吓人，但每次我们使用一组新的类别(数据集)时，我们唯一需要更新的是用横向注释# to be updated标记的两行代码(当然，我们必须删除用于创建数据集的特定于案例的部分)。可选地，我们可以考虑更新舍入结果(当前设置为第一个小数点的round()方法实例):

# Gather all the previous code
import matplotlib.pyplot as plt
import numpy as np#--------------------------------------
# Creating datasets
np.random.seed(1)
data_1 = np.random.normal(50, 30, 300)
data_2 = np.random.normal(100, 40, 300)
data_3 = np.random.normal(70, 10, 300)
#--------------------------------------data = [data_1, data_2, data_3]  # to be updatedbp = plt.boxplot(data, showmeans=True)medians = [round(item.get_ydata()[0], 1) for item in bp['medians']]
means = [round(item.get_ydata()[0], 1) for item in bp['means']]
minimums = [round(item.get_ydata()[0], 1) for item in bp['caps']][::2]
maximums = [round(item.get_ydata()[0], 1) for item in bp['caps']][1::2]
q1 = [round(min(item.get_ydata()), 1) for item in bp['boxes']]
q3 = [round(max(item.get_ydata()), 1) for item in bp['boxes']]
fliers = [item.get_ydata() for item in bp['fliers']]
lower_outliers = []
upper_outliers = []
for i in range(len(fliers)):
    lower_outliers_by_box = []
    upper_outliers_by_box = []
    for outlier in fliers[i]:
        if outlier < q1[i]:
            lower_outliers_by_box.append(round(outlier, 1))
        else:
            upper_outliers_by_box.append(round(outlier, 1))
    lower_outliers.append(lower_outliers_by_box)
    upper_outliers.append(upper_outliers_by_box)    

# New code
stats = [medians, means, minimums, maximums, q1, q3, lower_outliers, upper_outliers]
stats_names = ['Median', 'Mean', 'Minimum', 'Maximum', 'Q1', 'Q3', 'Lower outliers', 'Upper outliers']
categories = ['DATASET 1', 'DATASET 2', 'DATASET 3'] # to be updated
for i in range(len(categories)):
    print(f'\033[1m{categories[i]}\033[0m')
    for j in range(len(stats)):
        print(f'{stats_names[j]}: {stats[j][i]}')
    print('\n')**Output:****DATASET 1**
Median: 52.6
Mean: 52.2
Minimum: -23.0
Maximum: 125.8
Q1: 32.3
Q3: 70.6
Lower outliers: [-33.8]
Upper outliers: []

**DATASET 2**
Median: 100.4
Mean: 102.3
Minimum: -0.7
Maximum: 185.5
Q1: 75.7
Q3: 131.9
Lower outliers: [-11.3]
Upper outliers: [221.2, 258.3]

**DATASET 3**
Median: 70.1
Mean: 69.8
Minimum: 47.0
Maximum: 95.1
Q1: 63.7
Q3: 76.3
Lower outliers: [42.1, 43.0, 39.5]
Upper outliers: [103.2]

结论

在本文中，我们探讨了如何从 matplotlib 库中创建的箱线图中提取并打印出数据集描述性统计数据的精确值。这种统计信息可以包括没有异常值的中值、平均值、最小值和最大值、第一和第三四分位数、较低和较高异常值。在某些情况下，这些精确的数据可以作为箱线图本身的视觉信息的有价值的补充。

感谢阅读！

你会发现这些文章也很有趣:

[## 在 Python 中对两个字典执行逻辑运算的最简单方法

towardsdatascience.com](/the-easiest-ways-to-perform-logical-operations-on-two-dictionaries-in-python-88c120fa0c8f) </5-pandas-methods-youve-never-used-and-you-didn-t-lose-anything-37277fae7c55> https://levelup.gitconnected.com/when-a-python-gotcha-leads-to-wrong-results-2447f379fdfe

如何在 Matplotlib 中用模式填充绘图

原文：https://towardsdatascience.com/how-to-fill-plots-with-patterns-in-matplotlib-58ad41ea8cf8?source=collection_archive---------5-----------------------

向条形图、直方图、箱线图和饼图添加图案的方法

作者图片

创建地块时使用填充图案是使用颜色的一种很好的替代方法。在下列情况下，它尤其有用:

这个情节将会刊登在一份黑白出版物上，
如果我们想要减少每个绘图使用的颜色数量(例如对于饼图)，
如果我们想要强调图中的一些元素(例如条形图中的一些条)。

不幸的是，目前 matplotlib 在这方面的功能相当有限。此外，对于不同类型的地块没有独特的方法。

在本文中，我们将探讨如何向条形图、直方图、盒图和饼图添加模式。为了最大化数据-墨水比率，我们将通过在各处添加fill=False来创建仅黑白的图。

条形图

要用图形填充条形图，我们只需将以下值之一作为字符串赋给可选参数hatch:/、\\、|、-、+、x、o、O、.、*:

import matplotlib.pyplot as plt
import numpy as np
x = range(1,5)
y = range(1,5)
plt.bar(x, y, fill=False, hatch='/')
plt.show()

输出:

作者图片

为了获得更密集的填充，我们应该在字符串中添加更多的同类符号。所以，让我们用'///'代替'/':

plt.bar(x, y, fill=False, hatch='///')
plt.show()

输出:

作者图片

注意:由于反斜杠(\)是 Python 中的一个特殊字符，如果我们想用这个模式填充我们的条形图，我们就必须使用一个双反斜杠 ( '\\')。在这种情况下，为了获得更密集的模式，有必要将偶数个反斜杠分配给hatch参数('\\\\'、'\\\\\\'等)。).

也可以在相同的条上组合两种或多种模式，将相应的字符添加到字符串中:

plt.bar(x, y, fill=False, hatch='.O')
plt.show()

输出:

作者图片

绘制堆积或分组条形图时，填充变得更加有用:

y1 = range(1,5)
y2 = range(5,9)
plt.bar(x, y1, fill=False, hatch='xx')
plt.bar(x, y2, fill=False, hatch='..', bottom=y1)
plt.show()

输出:

作者图片

此外，与颜色一样，我们可以使用填充来强调最重要的线条。这里的算法如下。plt.bar()方法返回一个包含 n 个条形的容器，可以将这些条形赋给一个变量:

bars = plt.bar(x, y)
print(bars)**Output:** <BarContainer object of 4 artists>

在我们的例子中，容器中有 4 个条。让我们为条形图案设置一个条件。例如，我们只想强调1 < y < 3所在的小节。我们可以遍历 y 值列表，对于满足上述条件的值，分配星号('*')，否则不分配任何值(空字符串)。因此，我们将拥有一个与每个 y 值相对应的hatch参数值列表:

hatches = ['*' if y>1 and y<3 else '' for y in y]
print(hatches)**Output:** ['', '*', '', '']

现在，我们可以遍历容器的各个条，并为每个条设置相应的hatch值:

bars = plt.bar(x, y)
for i in range(len(bars)):
    bars[i].set(hatch = hatches[i], fill=False)
plt.show()

输出:

作者图片

柱状图

为了填充直方图，我们使用了与条形图相同的可选参数hatch,以及相同的可选值:

data = np.random.normal(loc=10, scale=10, size=500)
plt.hist(data, histtype='step', edgecolor='black', fill=False, hatch='.')
plt.show()

输出:

作者图片

当绘制多个堆叠或重叠的直方图时，它变得更加有用:

data1 = np.random.normal(30, 20, 5000)
data2 = np.random.normal(80, 15, 5000)
plt.hist(data1, bins=30, histtype='step', edgecolor='black', fill=False, hatch='.')
plt.hist(data2, bins=30, histtype='step', edgecolor='black', fill=False, hatch='o')
plt.show()

输出:

作者图片

箱形图

然而，对于箱线图，这种方法不太直接，因为plt.boxplot()方法没有hatch参数。因此，我们必须使用一个变通办法。这里的算法如下。plt.boxplot()方法返回一个字典，以盒图的不同元素作为键:胡须、盒子、中线、传单等。该字典可以分配给一个变量:

data = np.random.rand(100)
boxplots = plt.boxplot(data, patch_artist=True)
boxplots**Output:** {'whiskers': [<matplotlib.lines.Line2D at 0x195176862e0>,
  <matplotlib.lines.Line2D at 0x19517686640>],
 'caps': [<matplotlib.lines.Line2D at 0x195176869a0>,
  <matplotlib.lines.Line2D at 0x19517686d00>],
 'boxes': [<matplotlib.patches.PathPatch at 0x19517667f10>],
 'medians': [<matplotlib.lines.Line2D at 0x195176900a0>],
 'fliers': [<matplotlib.lines.Line2D at 0x195176903a0>],
 'means': []}

注意:为了以后能够使用hatch属性，需要在调用plt.boxplot()时设置patch_artist=True。

我们从上面的字典中需要的是'boxes'键。我们必须遍历所有的方框(即使在我们的例子中，我们只有一个方框图，因此只有一个方框),并为每个方框设置相应的hatch值，就像我们在条形图中只强调一个条形一样:

boxplots = plt.boxplot(data, patch_artist=True)
for box in boxplots['boxes']:
    box.set(hatch = 'x', fill=False)    
plt.show()

输出:

作者图片

当创建两个或多个盒状图时，这种技术变得更加有用:只强调其中的一部分，或者只为每个盒状图分配不同的模式。在这种情况下，我们必须创建一个hatch属性的值列表(根据条件，如果必要，或者只是随机的),并遍历它:

data1 = np.random.rand(10)
data2 = np.random.rand(20)
data3 = np.random.rand(500)
hatches = ['o', '++', 'x']
boxplots = plt.boxplot([data1, data2, data3], patch_artist=True)
for i in range(len(boxplots['boxes'])):
    boxplots['boxes'][i].set(hatch = hatches[i], fill=False)
plt.show()

输出:

作者图片

圆形分格统计图表

和盒子图一样，plt.pie()方法没有hatch参数，所以用模式填充饼图也不简单。这一次，plt.pie()方法返回一个元组:

data = np.random.rand(5)
patches = plt.pie(data)
patches**Output:** ([<matplotlib.patches.Wedge at 0x195177aa4c0>,
  <matplotlib.patches.Wedge at 0x195177aa970>,
  <matplotlib.patches.Wedge at 0x195177aadf0>,
  <matplotlib.patches.Wedge at 0x195177b72b0>,
  <matplotlib.patches.Wedge at 0x195177b7730>],
 [Text(1.046742554077009, 0.3381272326866619, ''),
  Text(-0.00440567017664189, 1.0999911772692974, ''),
  Text(-1.0992106691773433, -0.0416641904601184, ''),
  Text(-0.5217111246565277, -0.9684097802116732, ''),
  Text(0.7338182292945598, -0.8194576293836047, '')])

这个元组的第一个元素(patches[0])包含了我们饼图的所有楔形。在这种情况下，有 5 个楔子。我们可以根据特定的条件或随机地给每个人分配一个特定的模式。让我们强调最小和最大的楔子，其他的不填。为此，我们必须遍历数据，对于满足上述条件的值(即最小值和最大值)，将'o'和'O'符号分配给相应的hatch值，否则不分配任何值(空字符串):

hatches = ['o' if value==min(data) else 'O' if value==max(data) else '' for value in data]

现在，让我们遍历楔形区和hatch值，并用选择的模式填充最小和最大的楔形区:

patches = plt.pie(data)
for i in range(len(patches[0])):
    patches[0][i].set(hatch = hatches[i], fill=False)
plt.show()

输出:

作者图片

结论

在本文中，我们探索了在 matplolib 中用不同的模式填充等高线图的方法，如条形图、直方图、箱线图和饼图，并考虑了这种方法特别有用的情况。

我希望你喜欢阅读，并发现这些信息对你未来的项目有用。

你可能也会对这些文章感兴趣:

https://levelup.gitconnected.com/python-can-be-lots-of-fun-999552d69d21 https://levelup.gitconnected.com/when-a-python-gotcha-leads-to-wrong-results-2447f379fdfe https://medium.com/geekculture/creating-toyplots-in-python-49de0bb27ec1

如何在 Python 中过滤掉相似的文本

原文：https://towardsdatascience.com/how-to-filter-out-similar-texts-in-python-c7e7c5f7620e?source=collection_archive---------13-----------------------

复杂问题的简单解决方案！

图片来源:宁石

有什么问题？

假设您在一个归档中有成千上万的文档，其中许多都是彼此的副本。还假设即使文档的内容相同，但标题不同。

现在想象一下，现在是年初的平静期，所以你的老板想利用这段时间做一些家务。她要求您通过删除不必要的重复文档来释放一些归档空间。

问题就在这里:如何过滤掉标题足够相似、内容可能完全相同的文本？接下来，如何实现这一点，以便在完成后，不会删除太多文档，并且保留唯一的文档集？

让我们用一些代码来说明这一点:

为什么是这篇文章？

我已经不得不解决这个问题几次了，我还没能在网上找到一个直截了当的解决方案，所以这就是我在这里尝试做的。

由于代码背后的理论有些复杂，所以我不会深入研究任何东西。

相反，这篇文章是为那些想要快速、实用地了解如何解决这样的问题并同时大致了解他们在做什么的人准备的！

解决方案是什么样的？

接下来，我将介绍解决这个问题的不同步骤。下面是控制流的概要:

预处理所有标题文本
生成所有标题的配对
测试所有配对的相似性
如果一对文本没有通过相似性测试，则删除其中一个文本，并创建一个新的文本列表
继续测试新列表中的相似文本，直到没有相似文本

用 Python 来表达，这可以很好地映射到递归函数上！

代码

下面是 Python 中实现这一功能的两个函数。

第一个是预处理标题文本的简单函数；它删除像“the”、“a”、“and”这样的停用词，只返回标题中单词的词条。

因此，为了大致了解这意味着什么，如果您将“2020 年末回顾”输入到此函数中，您将会收到“2020 年末回顾”作为输出；如果你输入“一月销售预测”，你会得到“一月销售预测”。

为此，它使用了 python 中非常易于使用的 spacy 库；你可以在这里了解更多。

第二个函数——脚本中的第 30 行——为所有标题创建配对，然后确定它们是否通过了余弦相似性测试。如果它没有找到任何相似的标题，那么它输出一个不相似标题的列表。但是，如果它确实找到了相似的标题，在删除未通过相似性测试的标题对之后，它会将这些过滤后的标题再次发送给自己，并检查是否还有任何相似的标题。

这就是递归的原因！简单明了地说，这意味着该函数将不断检查输出，以确保在返回“最终”输出之前没有类似的标题。

余弦相似度是什么？

嗯，这里有一篇关于这个问题的很好的文章。

但是简单地说，这就是斯派西正在做的事情…

首先，还记得那些像“一月销售预测”这样的预处理标题吗？首先 spacy 把它变成了一个数字矩阵。

一旦完成，你就可以把这些数字变成向量，这意味着你可以把它们画在图上。

一旦你完成了，计算两条线之间角度的余弦，基本上给了你一个方法，告诉你它们是否指向相似的方向。

来源:Adobe Stock

所以，在上图中，想象一下 b 线代表一个特定的文本或句子，c 线代表不同的文本或句子。

在这种情况下，b 行和 c 行都对应于 spacy 为它们各自的句子创建的数字矩阵。两条线之间的角度——在上图中用希腊字母 alpha 表示——非常有用！你可以通过计算它的余弦来判断这些线是否指向同一个方向。

这听起来似乎太明显而无法计算，但关键是这种方法为我们提供了一种自动化整个过程的方法。

结论

所以，就这样了！概括地说，我已经解释了递归 python 函数如何使用余弦相似性和 spacy 自然语言处理库来获取相似文本的输入，然后返回彼此不太相似的文本。

这可能有相当多的用例…类似于我在本文开头提到的归档，您可以使用这种方法来过滤数据集中具有独特歌词的歌曲，甚至过滤具有独特内容类型的社交媒体帖子。

或者，你可以把整个事情颠倒过来，只获取重复最多的内容——如果你在大量的推文中发现哪些推文几乎互相重复呢？

如何在 2022 年最终在 Windows 10 上安装 TensorFlow 2 GPU

原文：https://towardsdatascience.com/how-to-finally-install-tensorflow-gpu-on-windows-10-63527910f255?source=collection_archive---------0-----------------------

百分百管用！

照片由 卢卡斯 上传。除非另有说明，所有图片均为作者所有。

我觉得包括我在内的 Windows 用户已经受够了。在尝试了几个小时甚至几天之后，你可能会被这个问题绊倒。因此，出于好意，我将直接切入正题，向您展示在 Windows 10 上安装 TensorFlow GPU 所需的步骤，而不会给出通常的博客介绍。

2022 年 11 月 27 日更新:该指南适用于 Windows 11，以及 tensor flow 2.11 之前的版本(目前是最新版本)。

第一步:找出 TF 版本及其驱动程序。

第一步，也是非常重要的一步，就是到这个链接，决定你要安装哪个 TF 版本。基于此，CUDA 驱动程序版本和其他软件版本会发生变化。

在撰写本指南时，TF 2.6.0 是最新的，我们将安装那个版本。

我们只对 TF 版本、cuDNN 和 CUDA 版本感兴趣。我们保持此选项卡打开，并继续下一步。

https://ibexorigin.medium.com/membership

获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:

https://alphasignal.ai/?referrer=Bex

步骤 2:安装 Microsoft Visual Studio

接下来，我们安装 Microsoft Visual Studio。请注意，这与 Visual Studio 代码不同，后者是很多人喜欢的轻量级 IDE。

转到此链接并点击下载:

运行下载的可执行文件，下载需求需要一分钟时间。然后，它会要求您选择要安装的工作负载。我们不想要任何，所以只需单击不带工作负载的安装，然后单击继续。安装完成后，它会要求您登录，但您不必这样做。

步骤 3:安装 NVIDIA CUDA 工具包

NVIDIA CUDA 工具包包含您的 NVIDIA GPU 的驱动程序。根据您的 Windows，它们可能已经安装，也可能没有安装。如果安装了，我们应该检查它们的版本，看看它们是否与我们要安装的 TensorFlow 版本兼容。

在 Windows 上转到您的设置，然后选择“应用和功能”。然后，搜索 NVIDIA:

我们希望安装 TF 2.6.0，这需要 NVIDIA CUDA Toolkit 版本 11.2(请参见第一个链接进行仔细检查)。如果你的驱动是任何其他版本，删除所有标题中有“NVIDIA CUDA”的驱动(留下其他的)。然后，转到Local Disk (C:) > Program Files > NVIDIA GPU Computing Toolkit > CUDA。在那里，您将看到一个以 CUDA 版本为名称的文件夹。删除那个文件夹。

如果你搜索 NVIDIA，没有找到 CUDA 工具包，就去这个页面。它看起来是这样的:

在这里，我们看到了三个 11.2 版本，这是我们需要的(我们从我提供的第一个 TF 版本链接中得到版本)。点击其中任何一个，选择 Windows 10，下载网络安装程序:

按照屏幕上的提示，使用默认参数安装驱动程序。然后，重新启动计算机并返回。

步骤 4:安装 cuDNN

对于 TensorFlow 2.6.0，需要 cuDNN 8.1。进入页面并按下载:

它会要求您提供一个 NVIDIA 开发者帐户:

如果您还没有帐户，请点击“立即加入”并输入您的电子邮件。填写表格——标准的东西。然后，回到 cuDNN 下载页面:

在顶部，它会要求你填写一份调查。填写它，你会看到上面的页面。单击第一个，因为它与 CUDA Toolkit v. 11 兼容。*.在那里，你会看到一个 Windows 版本，你应该下载。

步骤 5:解压缩 ZIP 文件夹并复制核心目录

提取下载的 ZIP 文件夹:

打开cuda文件夹，复制顶部的三个文件夹(bin, include, lib)。然后，去C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2把它们贴在那里。

资源管理器告诉你这些文件夹已经存在，你应该按下替换目标中的文件。就这样，我们完成了软件需求！再次重新启动计算机。

步骤 6:将 CUDA 工具包添加到 PATH 中

现在，是时候向环境变量添加一些文件夹了。在最后一个目的地，C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2，有一个bin和文件夹:

打开它并复制文件路径。然后，按“开始”(Windows)按钮并键入“环境变量”:

打开它，转到“环境变量”。这将打开弹出窗口:

从顶部选择“路径”,然后按编辑。按“新建”并将复制的链接粘贴到那里。

然后，回到 GPU toolkit 文件夹，打开libnvvp文件夹:

复制它的路径并粘贴到环境变量中，就像您对bin文件夹所做的那样。然后，关闭所有弹出窗口，保存更改。

步骤 7:使用 Jupyter Lab 在虚拟环境中安装 TensorFlow

最后，我们准备安装 TensorFlow。使用您喜欢的软件包管理器创建一个虚拟环境。我使用conda，所以我用 Python 版创建了一个名为tf的conda环境。

conda create -n tf python==3.8
conda activate tf
pip install --upgrade tensorflow
pip install jupyterlab ipykernel

重要的是 TensorFlow 和 JupyterLab 都安装了pip或conda。如果它们是从不同的渠道安装的，你会在 JupyterLab 中得到一个ModelNotFoundError。

接下来，我们应该将conda环境添加到 Jupyterlab，这样当我们启动一个会话时，它就会被列为有效的内核:

ipython kernel install --user --name=<name of the kernel, `tf` for our case>

如果您启动 JupyterLab，您应该能够将环境视为一个内核。创建一个新的笔记本，并运行以下代码片段来检查 TF 是否可以检测到您的 GPU:

import tensorflow as tf
from tensorflow.python.client import device_lib

print("Num GPUs Available: ", len(tf.config.list_physical_devices('GPU')))
device_lib.list_local_devices()

正如输出所说，我有一个单一的 GPU，在最后，它显示其名称。如果您有类似的输出，那么我在这里的工作就完成了！

说明摘自这个视频的 YouTube 视频。

如何找到数据科学导师

原文：https://towardsdatascience.com/how-to-find-a-data-science-mentor-c09fe3d9d74f?source=collection_archive---------15-----------------------

以及为什么这是个好主意。

在 Unsplash 上 NeONBRAND 拍摄的照片

数据科学、分析和工程领域可能会让新人望而生畏。这是一个不断发展和分化的领域。

随着行业的发展，新的角色、利基和工具正在快速产生。直到最近，我才了解到对分析工程师的需求越来越大，这些人可以充当数据工程师和数据分析师之间的桥梁。MOOCs 和新兵训练营千篇一律的课程只能让你到此为止。在一个需求技能变化如此之快的世界里，课程本来就很脆弱。

有一个好的导师可能是一个主要的催化剂。一位导师可以帮助你从噪音中分辨出信号——从现实中辨别出炒作。它们可以减少就业市场固有的信息不对称，引导你找到最好的资源和工具，并帮助你向招聘经理推销自己。鉴于面向大众的数据科学课程必须具有广泛的吸引力，导师可以针对你的目标角色和领域给你提供建议。

但是，如果没有现有的职业关系网——即使有——实际上找到一个导师也是困难和尴尬的。

时不时地，我会收到一条类似这样的消息:

你好，我想成为一名数据科学家，但我不知道该如何着手。请帮帮忙。

我通常会回复这些问题。但我是个例外。我正在建立并指导sharpes minds——一个数据科学、分析和机器学习领域的指导平台——这使我成为指导请求的自然目标。另外，我有一个既得利益去理解那些正在寻找导师的人们的问题。

但这不是正确的方法。这个要求太含糊了。如果不多问一些问题，我无法提供任何实际的建议。当你向潜在的导师提出模糊的、开放式的请求时——比如“请帮忙”，或者“你能指导我吗？”—你为他们创造了更多的工作。

也不是个性化的。它读起来像是被复制粘贴到其他几十个地方。如果看起来他们没怎么努力，我也不会努力。

在你向任何人寻求指导之前，试着弄清楚你到底需要什么帮助。同样重要的是，为什么你需要这个人的帮助。

最好的导师是那些经历过和你一样的事情，并在另一边成功脱颖而出的人——在和你目标相似的职位上工作。但是这些人现在很忙。他们是全职的数据科学家、数据分析师和数据工程师。然而，他们中的许多人很乐意帮忙。你只需要让他们容易些。

在你寻求指导之前，试着自己回答这些问题:

你在寻找什么样的角色(例如，数据科学家、数据分析师、数据工程师、机器学习工程师等。)?
你和那个角色之间最大的障碍是什么？
你已经拥有哪些相关的技能和经验？你上过 MOOCs 吗？建了什么项目？
你缺少什么工具、技能或信息？
有没有你想从事的特定行业(如医疗保健、金融等)。)?
你希望从导师那里得到什么样的指导？

知道这些问题的答案(并保持透明)会让潜在的导师更容易理解你的需求并提供指导。

对所有这些没有一个明确的答案是没关系的——知道你的无知在哪里是件好事。一位导师也许能帮你回答这些问题。例如，我在 SharpestMinds 采访过的许多导师都提到，他们喜欢帮助人们理解和优先考虑各种与数据相关的职位。然而，其他人更希望你已经有了一个明确的职业目标。这就是为什么坦白你知道什么和不知道什么很重要。

在sharpes minds上，向陌生人寻求指导是可以接受的。但是，在现实世界中，你最好先建立关系。你不会想突然出现并请求指导的。

开始关注活跃在网上(LinkedIn、Twitter、Medium 等)的业内人士。).与他们的内容互动——留下一些评论，提出后续问题。如果你从他们写的东西中获得了价值，让他们知道！奉承会大有帮助。

当你这样做的时候，开始在公共场合(在 LinkedIn、Twitter、Medium 等)学习或建立。)在同样的人可能会看到的地方。你想向潜在的导师展示你有上进心和动力。导师不是老师。他们不想填鸭式地喂你——他们没有时间。如果你能证明你是可训练的，那就加分。获得导师关注的最佳方式是展示你已经从他们那里学到了一些东西。

这是一个很好的介绍信息的例子:

“你好<名字>，我看了你关于培养基的烧瓶教程，从中获得了很多价值。感谢分享！我采纳了你的一些建议，为我的项目做了一个简单的前端:< link-to-your-repo >。我在想，<具体跟进问题>？

有了这样的信息，你就表明了你有理由专门去接触他们，你是自我驱动的，可以接受指导的。你也向他们提出了一个具体的问题。比“我想成为一名数据科学家，请帮忙”更容易回答的问题。

如何找到子集和问题的所有解

原文：https://towardsdatascience.com/how-to-find-all-solutions-to-the-subset-sum-problem-597f77677e45?source=collection_archive---------4-----------------------

照片由 Antoine Dautry 在 Unsplash 上拍摄

适用于负数、正数和重复数字的动态编程解决方案

子集和问题涉及确定整数列表中的子集是否可以和为目标值。比如考虑一下nums = [1, 2, 3, 4]的列表。如果target = 7，有两个子集达到这个和:{3, 4}和{1, 2, 4}。如果target = 11，没有解决方案。

一般来说，确定子集和是否有甚至任意个解是 NP 难:如果nums列表中有n个整数，则存在2^n — 1个子集需要检查(不包括空集)。在这篇文章中，我们将会看到一个更有效的解决方法，使用动态规划 (DP)。然而，与大多数教程不同，我们不仅要确定是否存在一个解决方案，还要看看如何发现所有解决方案。该算法适用于负的和正的输入值，以及nums中重复的非唯一整数。

TLDR；Python 包🐍

寻找快速解决方案，但不一定想知道底层细节？我创建了一个名为“ subsetsum 的 Python 包，带有一个超快的求解器:pip install subsetsum

求解器的逻辑用 C++实现，并使用 Pybind11 来公开一个 Python 接口。GitHub 上的提供了源代码。

1.预处理

在进入 DP 解决方案之前，我们将对问题输入(nums和target)进行一些预处理。

翻转标志🔄

我们要做的第一件事是翻转nums中所有整数的符号，如果目标是负的，则翻转target、。这确保了我们的target将总是 0 或更大，这只是让整个算法的生活更容易！我们可以不用担心，因为翻转符号前后的解是相同的:

x0 + x1 + ... + x10 = target
# Multiply both sides by -1
-x0 - x1 - ... - x10 = -target
# The equations are equivalent!

对➡️的数字进行排序

下一个预处理步骤是按升序对nums进行排序，这是 DP 算法工作所必需的(稍后描述)。如果你需要记住nums的原始顺序，你可以执行一个 argsort ，它从一个整数在列表中的当前位置映射到它在排序列表中的位置。如果需要，您可以随时重新映射回原始位置。

nums = [-2, 1, -3, 0, 4, 5]
index = argsort(nums) = [2, 0, 3, 1, 4, 5]
nums[index] = [-3, -2, 0, 1, 4, 5]

检查目标是否过低或过高🛑

考虑nums = [-3, -2, -1, 1, 2, 3, 4]的情况。可达到的最小总和是多少？ -6 。最大的金额可能是多少？ 10 。如果target之和比nums中所有负整数之和少或者比nums中所有正整数之和多则无解。**

我们将在变量a中存储所有负整数的和，在变量b中存储所有正整数的和。如果target < a或者target > b，我们可以以“无解！”

2.动态规划

照片由米卡·鲍梅斯特在 Unsplash 上拍摄

预处理完成后，我们准备填充一个名为DP的动态编程表。DP表将有n行(给定n数字)和target — a + 1列。存储在表格中的值将只是真或假。行和列索引从 0 开始。

如果我们在row i上，我们会考虑使用整数的所有子集，直到并包括排序后的nums中的第i个整数。第i个整数不需要包含，但是如果我们想使用它，它是“可用”的。
如果我们在column j上，我们将试图找到总和为a + j的“中间”目标的子集。注意，因为我们有target — a + 1列，所以j的最终值将是target — a，这意味着最后，我们试图找到总和为a + j = a + target — a = target的子集。
因此，DP[i, j] = 1意味着nums[0...i]中存在一个子集，其总和为a + j。如果DP[i, j] = 0不存在这样的子集。
恢复解:如果DP[n — 1, target — a] == 1，存在nums的子集，总和为target。

更新规则⭐️

我们首先用零初始化DP表，并填充DP的第一行，注意如果nums[0]等于a + j，则DP[0, j]只能是 1 。

for j in range(0, target - a + 1):
    DP[0, j] = (nums[0] == a + j)

对于剩余的行，DP[i, j]可以在以下情况下标记为 1 :

DP[i — 1, j] == 1:如果仅使用来自nums[0...(i — 1)]的子集就可以实现“中间”目标a + j，那么很明显，如果允许第i个数字在该子集中，也可以实现该目标。
nums[i] == a + j:在这种情况下，中间目标a + j可以从单整数子集{nums[i]}中得到。
DP[i — 1, j — nums[i]] == 1:最棘手的规则，让人想起背包问题的动态编程解决方案。如果有一个nums[0...(i — 1)]的子集总计为a + j — nums[i]，那么我们知道有也是的一个子集，通过将nums[i]包含在该子集中而总计为a + j。

for i in range(1, n):
    for j in range(0, target - a + 1):
        DP[i, j] = DP[i - 1, j] or nums[i] == (a + j)
        if DP[i, j] == False:
            next_j = j - nums[i]
            if 0 <= next_j < target - a + 1:
                DP[i, j] = DP[i - 1, next_j]

时间和空间复杂性⏱

这里描述的 DP 解决方案是所谓的伪多项式算法。DP 表格的大小不仅(线性地)取决于nums中元素的数量，还(线性地)取决于nums和target的值，因为表格中的列数是target和nums中负整数之和之间的距离。

表的每个单元格必须设置为 0 或 1 一次，这是使用对其他单元格的恒定数量的查询来确定的，因此算法的运行时与表的大小成比例。

DP 有缺点，蛮干可以更好💪

先说nums = [-1000000, 1000000]和target = 999999。使用 DP 方法，我们将有 2 行和999999 + 1000000 + 1 = 2000000列。对于一个显然无法解决的问题来说，内存使用量太大了！如果nums中的数字很少，但是值的范围很大，你最好强力检查所有可能的子集。

3.寻找所有解决方案🤯

我们会用栈，可惜不是这种栈！照片由布里吉特·托姆在 Unsplash 上拍摄

让我们继续讨论可能是最具挑战性的话题，也是其他教程中最少讨论的话题:如何实际找出哪些子集达到了target和！

要做到这一点，我们需要使用我们的DP表，并通过它回溯。我们将使用一种非递归技术:一个堆栈。堆栈中的每一项都是一个简单的数据结构，我称之为StackItem。

class StackItem:
    row: int  # Row index in the DP table
    col: int  # Column index in the DP table
    take: list[int]  # **Indices** of integers to include in the subset
    togo: int  # Value "to go" until reaching the `target` sum

现在我们知道，如果DP表格右下角的单元格是 1 ，那么就有一个解决方案。否则，就不要费心去寻找解决方案了，因为根本就没有解决方案！我们将从右下角的单元格开始初始化堆栈/回溯。我们假设nums 中的最后一个整数是子集包含的，那么togo将是target值减去nums[n — 1]。

stack.push(
    StackItem(
        row=n - 1,
        col=target - a,
        take=[n - 1],
        togo=target - nums[n - 1]
    )
)

现在，我们不断从堆栈中弹出项目，并添加新的项目，直到它是空的。一旦完成，我们将列举所有可能的解决方案。

假设我们刚刚弹出了一个项目:item = stack.pop()的row = i和col = j。我们将检查item的三个场景:

如果DP[i — 1, j] == 1，那么可能有一个不使用nums中第i个整数的解决方案。在这种情况下，我们将添加一个新的StackItem，就好像第i个整数不包含在子集中，但是第(i-1)个整数是。
如果DP[i — 1, j — nums[i]] == 1，那么有一个解决方案，使用剩余的nums[0...(i — 1)]整数形成一个“中间”子集，其总和为a + j — nums[i]。在这种情况下，我们将添加一个新的StackItem，假设第i个整数是包含在“最终”子集中的。
如果item.togo == 0那么我们已经有了解决方案！然后item.take将整数的索引存储在(排序的)nums中，形成一个子集，其和为target。

while len(stack) > 0:
    item = stack.pop()
    i, j, take, togo = item.unpack() # Scenario 1
    if i > 0 and DP[i - 1, j]:
        new_take = take.copy()
        new_take[-1] = i - 1  # Replace the last element
        new_togo = togo + nums[i] - nums[i - 1]
        stack.push(StackItem(i - 1, j, new_take, new_togo)) # Scenario 2
    next_j = j - nums[i]
    if i > 0 and 0 <= next_j < (target - a + 1):
        if DP[i - 1, next_j]:
            new_take = take.copy()
            new_take.append(row - 1)  # Add a new element
            new_togo = togo - nums[i - 1]
            stack.push(StackItem(i - 1, next_j, new_take, new_togo)) # Scenario 3
    if togo == 0:
        yield [nums[t] for t in take]

结论🎉

我希望您喜欢学习如何使用动态编程解决子集和问题！有相当多的在线资源解释了如何确定是否对于特定的一组(nums，target)存在解，但是这些教程通常假设所有的数字都是正数。这里描述的算法也适用于负数！💡此外，几乎没有现有的教程解释如何利用 DP 表回溯所有解决方案，这是本文的主要动机。

更具体的实现(C++和 Python，不是伪代码)请访问 GitHub 或通过pip install subsetsum下载 pip 模块。

如何使用 Python 找到餐馆的最佳位置

原文：https://towardsdatascience.com/how-to-find-best-locations-for-your-restaurants-with-python-b2fadc91c4dd?source=collection_archive---------5-----------------------

用 CVXPY 解决集合覆盖问题

动机

在模拟你的餐厅中的真实事件后，你的餐厅开始吸引更多的顾客，所以你决定在其他地方开设连锁餐厅。

由于许多顾客喜欢在附近就餐，您希望您的餐厅距离 1、2、3、4 和 5 区最多 15 英里。最佳解决方案是在所有其他区域的 15 英里范围内建立最少数量的餐馆。

假设您的餐厅只能位于 1 区、2 区、3 区、4 区或 5 区，您应该将餐厅建在哪个位置？

作者图片

这就是所谓的集合覆盖问题。在本文中，您将学习如何使用 CVXPY 解决这个问题。

CVXPY 是什么？

CVXPY 是一种嵌入 Python 的建模语言，用于如上所述的凸优化问题。它类似于纸浆，但是它的语法更简单、更直观。

要安装 CVXPY，请键入:

pip install cvxpy

问题陈述

在深入研究数学公式和代码之前，让我们先写下我们拥有什么和我们想要实现什么。

输入参数:我们被提供区域之间的距离:

作者图片

目标:我们想选择最少的区域来建造餐馆

约束:我们需要确保每个区域都在至少一家餐馆的 15 英里范围内

决策变量:我们将根据目标和约束条件决定是否在某一特定区域开店。

解决

输入参数

要解决这个问题，首先，把距离矩阵变成一个表示两个区域之间的距离是否在 15 英里以内的矩阵。具体来说，

小于或等于 15 英里的距离变为 1****
大于 15 英里距离**变成 0**

接下来，将数据帧转换成矩阵:

作者图片

决策变量

我们将决定是否在某个特定的地区开店。

作者图片

限制

我们需要确保每个区域都在至少一家餐馆的 15 英里范围内。

例如，因为我们知道区域 1 在区域 1 和区域 2 的 15 英里范围内，所以我们需要确保其中一个餐馆建在区域 1 或区域 2。

作者图片

这意味着我们需要如下内容:

作者图片

为了将上述等式推广到所有领域，我们可以使用矩阵乘法:

作者图片

目标

尽量减少用于建造餐馆的面积。

作者图片

解决

现在我们有了约束和目标，让我们来解决问题吧！

'optimal'

厉害！因为问题的状态是最优的，所以找到了最优解。要查看解决方案，请键入:

array([0., 1., 1., 0., 0.])

该结果表明，区域 2 和 3 是建造餐馆的两个理想位置。

解决方案的解释

为什么选择 2 区和 3 区？在下面的图片中，我们可以看到，通过在 2 号和 3 号区域建造餐馆，每个区域都在至少一家餐馆的 15 英里范围内！

作者图片

这个问题的解决方案似乎很直观，因为我们只需要考虑 5 个方面。但是当你需要考虑 10 个或者更多的区域时，这种求解方法会非常有帮助。

结论

恭喜你！您刚刚学习了如何使用 CXVPY 解决集合覆盖问题。希望这篇文章能给你解决类似问题所需的知识。

在 Github repo 中，您可以随意使用本文的代码:

https://github.com/khuyentran1401/Data-science/tree/master/mathematical_programming/locations_of_stores

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

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

[## 使用 SimPy 在 Python 中模拟真实事件

towardsdatascience.com](/simulate-real-life-events-in-python-using-simpy-e6d9152a102f)

参考

陈(2010)。应用整数规划:建模与求解。j .威利&的儿子们。

当 A/B 测试不合适时，如何找到因果推断

原文：https://towardsdatascience.com/how-to-find-causal-inference-when-a-b-tests-are-unsuitable-2962846f1759?source=collection_archive---------21-----------------------

回归不连续设计(RDD)是数据科学中经常被忽视的一个计量经济学主要内容。在这里，我用 Python 中的 RDD 来决定是否应该允许孩子喝啤酒。

由乔治·考克斯在 Unsplash 上拍摄的照片

数据科学目前风靡一时，这是很正确的。计量经济学，数据科学的兄弟(统计学是父亲)，有时会觉得有点被冷落。尽管它们的大部分技术和程序是相同的，但在现代数据科学中，一些真正有用的计量经济学技术经常被遗忘。

我在期刊上发表的一些计量经济学作品的例子可以在这里看到。

数据科学主要关注预测，试图确定因果推断通常不被认为是重要的。只要底层系统和关系不变，数据科学预测技术就非常棒，但它们在现实世界中经常发生变化。了解因果关系也有助于推动政策和决策的制定。

尽管计量经济学以令人难以置信的枯燥而闻名(尽管不知何故它的兄弟被称为 21 世纪最性感的工作)，但它通常是一门艺术科学。

因为根据定义，计量经济学研究经济和经济中的人类互动，A/B 测试通常很难获得，因为它们在伦理上具有挑战性。我们不能只是在宏观尺度上玩弄人们的生活，否则人们可能会有点恼火。想象一下，我们刚刚开始随机分配大学名额。因此，计量经济学提出了一些后门方法，可以有一些很大的用途。

在这篇文章中，我将通过一个最有趣，但也最简单的计量经济学技术— 回归不连续设计。我将使用来自 Carpenter(2011 年)的一个例子来分析法定饮酒年龄，以及降低法定饮酒年龄对经济的影响。

作为一名苏格兰人，这是我最关心的事情。

我也会用 Python 来编码。

回归不连续设计

在计量经济学(以及统计学、流行病学和统计学)中，回归不连续设计是一种准实验技术，试图从 A/B 检验不适合的数据中得出因果推断。这通常是事后利用现有数据完成的。这是通过在“干预点”上下指定一个阈值来实现的。然而，仍然不可能用这种方法要求明确的因果推断，因为它不能自动拒绝任何潜在的或未考虑的变量的因果影响。然而，研究表明 RCT(A/B 测试)和 rdd 不会产生太不相似的结果(在进行适当调整后，在 0.07 标准偏差内)。

最常见的例子是奖学金和平均绩点。

我们正在寻找的平均治疗效果的例子。来源:https://www.rpubs.com/muntasir_masum/rdd

考虑一所高中，其中前 x 名学生(按 GPA 排序)获得了奖学金，我们想知道奖学金对这些人的影响。我们不能简单地比较获得奖学金的人和没有获得奖学金的人，因为有明显的选择偏差。更优秀的个人更有可能获得奖学金，因此更有可能在未来出类拔萃(假设未来的成功可以通过 GPA 来预测，这并不夸张)。

奖学金可能根本没有任何效果，只是获得奖学金的学生已经准备好做得更好。所以在上图中，以 C 为奖学金分界点，高于 C 的每个人都能获得奖学金，低于 C 的人则不能。

RDD 所做的，是将分界点附近的点(或学生)进行比较。例如，在 78-82%范围内的学生。考虑到阅卷考试和其他个体随机变量的随机性，这一组被认为在潜在能力上有些平等。比较该组中的个体，一些接受治疗(奖学金)，一些没有，我们可以推断奖学金对个体的影响，并因此估计因果推断(如前所述，这不是真正的因果推断，而是创造的平均治疗效果)。

是否应该降低最低饮酒年龄？

在他们的论文中，Carpenter&DOB kin(2011)使用这种精确的技术来分析如果在美国饮酒年龄从 21 岁降低会有什么影响。考虑到我们在苏格兰大约八岁就开始喝威士忌，我完全赞成削减威士忌，这样我们在池塘那边的兄弟姐妹就可以和我们一样享受生活的果实(尽管你可能不想缩短我们的预期寿命)。让我们看看数据是否一致。

在这里，RDD 是一个很好的工具，因为已经有了一个特定的截止日期——一个人的 21 岁生日。一个人在 21 岁生日的前一天和后一天实际上是同一个人，除了他们现在可以享受生活。用更科学的术语，和原作者的话；“如果在 21 岁时除了法律制度没有发生变化，那么 21 岁时的离散死亡率似乎可以归因于饮酒年龄”。

作者比较了三种不同类型的死亡；机动车死亡、内因死亡和自杀死亡。

可以看出，第一组和最后一组中的最佳拟合线明显不连续。

资料来源:【nih.gov 最低法定饮酒年龄和公共健康(T2)】

为了估计不连续性并检验其在统计上是否显著，他们使用以下等式:

y=β0+β1MLDA+β2生日 + f( 年龄 ) + ε

“y”为分年龄死亡率，每年、每月各一个数据点。

“MLDA”是一个虚拟变量，对于观测值 21 和更老的观测值，其取值为 1，否则取值为 0。

“f(年龄)”是与“MLDA”假人完全交互的二次多项式。

【生日】是死者 21 岁生日所在月份的虚拟变量，旨在吸收生日庆祝对死亡率的显著影响。

“ε”当然是一如既往的未被观察到的误差项。

因此，该模型中感兴趣的参数为β1。

然后，作者用上述方程进行线性回归，并给出了下面的结果表。

资料来源:最低法定饮酒年龄和公共健康(nih.gov)

上表中的结果与图表证据一致，并显示当人们年满 21 岁时，总死亡率增加了 8.7%，具有统计学意义(从 93.07 例死亡的基数开始，每 100，000 人年增加 8.06 例死亡，相当于 8.06/93.07 = 0.087，即增加了 8.7%)。

总的来说，上图中的视觉证据和表中相应的回归估计提供了强有力的证据，证明最低法定饮酒年龄对 21 岁时自杀、机动车事故和酒精过量的死亡率有显著影响。

该死，看来不让孩子喝酒是个好主意。

自己怎么做

现在，我将简要地向您展示如何用 Python 自己运行这个实验的简化版本。这非常简单。因此，首先我通过逆向工程作者用于回归的方程制造了一些虚假数据。规模有点不同，但这没关系。在经历了 23 年的伤痛之后，苏格兰终于获得了欧洲足球锦标赛的参赛资格，这可能是今年的数据

作者创建的虚构数据散点图

由作者创建的用于此分析的数据帧的标题

我使用了同样的 48 个月的周期，也集中了年龄(无论如何，它将在回归中被标准化)。

然后，我们可以像往常一样简单地运行线性回归！我们可以使用“统计模型”来得到一个更加“计量经济学”风格的输出。Sklearn 产生 R 平方，但不产生系数 P 值，这是我们在这种情况下想知道的。

链接到我的 github —作者代码。

因此，输出如下:

作者运行的回归的输出。

不足为奇的是，回归预测了我制作数据集时使用的几乎准确的数字(5 代表年龄，50 代表 21 岁)。我确实添加了一个随机误差项，但显然还不够，因为 R 平方仍然非常高，为 0.98。

可以看出，年龄和 21 岁生日的 P 值都非常显著，因此我们可以拒绝 21 岁生日不影响死亡率的无效假设(当然我们可以这样做，因为我是以这种方式获得数据的)。

因此，正如你所看到的，它实际上与运行正常的线性回归是一样的，只是在指定方程和控制关系时要格外小心。原始论文的作者投入了更多的努力来控制所有其他年龄变量，但这只是一个如何做到这一点的简化示例。

外卖

如果你能做 A/B 测试，那就做吧。但是如果你不能，那么 RDD 是你最好的选择。如果你正确地指定了方程，并且没有违反任何假设，你应该不会有任何问题。小心陷阱，如虚拟变量陷阱%20as%20an%20example.)或过多的[多重共线性](https://en.wikipedia.org/wiki/Multicollinearity#:~:text=In statistics%2C multicollinearity (also collinearity,a substantial degree of accuracy.)。

如前所述，这种方法不能推导出真正的因果推理。例如，我们并不确切知道这个等式中的所有变量。美国青少年长时间等待饮酒可能是他们 21 岁后不久死亡的原因之一。所以在做大胆的陈述时要小心。

最后，总结一下，Carpenter&DOB kin(2011)的研究结果表明，饮料将不得不收取 15 美元，以弥补将饮酒年龄降低到 18 岁的经济成本(使用大约 800 万美元作为生命的统计价值)。

就我个人而言，我不赞成为一杯酒支付 15 美元(尽管我现在在伦敦支付的价格与此相差不远)。

所以，抱歉，年轻的美国人，你得等到 21 岁，反正这对你没好处。

我希望你喜欢这篇文章，如果你喜欢，这里还有一些我的类似的文章。

If I’ve inspired you to join medium I would be really grateful if you did it through this [link](https://jamesasher4994.medium.com/membership) — it will help to support me to write better content in the future.If you want to learn more about data science, become a certified data scientist, or land a job in data science, then checkout [365 data science](https://365datascience.pxf.io/c/3458822/791349/11148) through my [affiliate link.](https://365datascience.pxf.io/c/3458822/791349/11148)

[## 如何预测没有数据的事物——还有盆景树

towardsdatascience.com](/how-to-predict-something-with-no-data-and-bonsai-trees-b6ebc6471da3)

干杯，

詹姆斯。

如何用 TensorFlow 找到最佳的神经网络结构——最简单的方法

原文：https://towardsdatascience.com/how-to-find-optimal-neural-network-architecture-with-tensorflow-the-easy-way-50575a03d060?source=collection_archive---------7-----------------------

在任何数据集上优化前馈神经网络模型的最佳指南

照片由安东尼·里埃拉在 Unsplash 拍摄

深度学习归结为实验。手动训练数百个模型既繁琐又耗时。我宁愿用我的时间做些别的事情，我想你也一样。

想象一下，你想为你的深度神经网络找到最佳架构。你从哪里开始？多少层？每层有多少个节点？激活功能呢？有太多的活动部件。

您可以在一定程度上自动化这个过程，本文将向您展示如何实现。阅读后，您将有一个函数用于在给定特定参数的情况下生成神经网络架构，另一个函数用于寻找最佳架构。

不想看书？请观看我的视频:

你可以在 GitHub 上下载源代码。

使用的数据集和数据预处理

我不打算在这里花太多时间。我们将使用与上一篇文章中相同的数据集——来自 Kaggle 的葡萄酒质量数据集:

图片 1——来自 Kaggle 的葡萄酒质量数据集(图片由作者提供)

您可以使用以下代码将其导入 Python，并随机打印几行:

我们忽略警告并更改默认的 TensorFlow 日志级别，这样我们就不会被输出淹没。

以下是数据集的外观:

图 2——葡萄酒质量数据集的随机样本(图片由作者提供)

数据集基本上是干净的，但默认情况下不是为二元分类(好酒/劣酒)而设计的。取而代之的是，葡萄酒是按等级来评定的。我们现在将解决这个问题，还有许多其他问题:

删除缺失值 —它们为数不多，所以我们不会在插补上浪费时间。
处理分类特征——唯一的一个是type，指示葡萄酒是白还是红。
转换为二分分类任务——我们将把任何 6 分及以上的葡萄酒宣布为好，任何低于的为差。
训练/测试拆分——经典的 80:20 拆分。
缩放数据 —预测值之间的比例差异很大，因此我们将使用StandardScaler来拉近数值。

下面是完整的数据预处理代码片段:

同样，如果您想更详细地了解数据预处理背后的逻辑，请参考上一篇文章。

这样一来，让我们看看如何优化神经网络架构。

如何优化神经网络模型？

寻找最佳神经网络模型的方法将具有一些可调整的常数。今天的网络将有 3 个隐藏层，每层最少 64 个节点，最多 256 个节点。我们将节点之间的步长设置为 64，因此可能是 64、128、192 和 256:

让我们验证节点数的可能性。您可以通过创建最小和最大节点数之间的范围列表来做到这一点，请记住步长:

以下是您将看到的内容:

图 3——节点数的可能性(图片由作者提供)

将这一逻辑延伸到两个隐藏层，您最终会得到以下可能性:

或者视觉上:

图 4-两个隐藏层的节点数可能性(图片由作者提供)

要获得两层之间选项的每一种可能的排列，您可以使用itertools中的product()函数:

以下是输出结果:

图 5 —两层深度神经网络架构排列(图片由作者提供)

我们的目标是优化一个三层深度的神经网络，所以我们最终会有更多的排列。您可以通过首先将节点选项列表乘以num_layers来声明可能性，然后计算排列:

有很多选择——总共 64 种。在优化过程中，我们将迭代排列，然后再次迭代单个排列的值，以获得每个隐藏层的节点数。

简而言之，我们将有两个for循环。前两种排列的逻辑如下:

第二个打印声明放在这里只是为了让型号之间有个空隙，不要想太多。以下是输出结果:

图 6-每层的节点数量(作者提供的图片)

我们将在每次迭代中创建一个新的tf.keras.Sequential模型，并为其添加一个具有单个训练行形状的tf.keras.layers.InputLayer((12,))。然后，我们将迭代单个排列中的项目，并向模型添加一个tf.keras.layers.Dense层，将节点数设置为单个排列的当前值。最后，我们将添加一个tf.keras.layers.Dense输出层。

将名称设置为模型是一个好主意，这样以后比较容易。我们将对 no 的输入形状和激活函数进行硬编码，并在下一节中将这些部分设置为动态的。

代码如下:

现在让我们来看看单个模型是什么样子的:

图 7 —单一模型架构(图片由作者提供)

这就是我们的逻辑。不过，有一种方法可以改进它，因为每次想要运行优化时运行几十个笔记本单元并不方便。为激活函数、输入形状等硬编码值也不是最好的主意。

出于这个原因，接下来我们将声明一个用于生成序列模型的函数。

用于优化神经网络的模型生成函数

该函数接受许多参数，但不包含我们之前没有提到的任何内容。它为您提供了更改输入形状、隐藏和输出层的激活函数以及输出层的节点数量的选项。

代码如下:

让我们测试一下——我们将坚持使用一个具有三个隐藏层的模型，每个隐藏层最少 64 个节点，最多 256 个节点:

请随意检查all_models列表的值。它包含 64 个顺序模型，每个模型都有唯一的名称和体系结构。训练这么多模型需要时间，所以让我们通过编写另一个助手函数来使事情变得格外简单。

用于优化神经网络的模型训练函数

这个函数接受模型列表、训练和测试数据，以及可选的一些时期和详细级别。建议将 verbosity 设置为 0，这样您就不会被控制台输出淹没。该函数返回一个 Pandas DataFrame，其中包含测试集的性能指标，用准确度、精确度、召回率和 F1 来衡量。

代码如下:

现在，让我们开始优化。

运行优化

请记住，优化将需要一些时间，因为我们正在为 50 个时期训练 64 个模型。以下是开始这一过程的方法:

优化在我的机器(M1 MacBook Pro)上运行了 34 分钟，并打印了以下内容:

图 8 —优化输出(作者提供的图片)

您看到这个输出是因为optimize()函数中的print()语句。它给你一种进步的感觉。

我们现在有了一个数据框架，可以按照准确度、精确度、召回率或 F1 进行排序。以下是按精度降序排序的方法，因此首先显示值最高的型号:

图 9-模型优化结果(图片由作者提供)

看起来最简单的模型产生了最好的精确度。您还可以测试具有两个和四个隐藏层的模型的优化，甚至更多，但是我将让您来决定。只是调用get_models()函数，传入不同的参数值。

这就是我今天想讲的全部内容。接下来让我们总结一下。

离别赠言

为您的数据集找到最佳的神经网络架构归结为一件事，而且只有一件事-实验。手工训练和评估上百个模型是相当繁琐的，所以你今天看到的两个函数可以帮你节省一些时间。您仍然需要等待模型训练，但是在这个数据集上整个过程很快。

从这里开始的一个好方法是选择一个你认为最好的架构，并调整学习速度。

如果处理图像数据和卷积层，事情会变得更加复杂，训练时间也会变得更长。这就是下一篇文章将涉及的内容——我们将开始深入计算机视觉，并训练一个简单的卷积神经网络。别担心，它不会出现在 MNIST 的数据集中。

您如何优化前馈神经网络？是类似的东西，还是你使用的是专用的 AutoML 库？请在下面的评论区告诉我。

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

https://medium.com/@radecicdario/membership

保持联系

注册我的简讯
在 YouTube上订阅
在 LinkedIn 上连接

如何找到正确的集群数量

原文：https://towardsdatascience.com/how-to-find-the-right-number-of-clusters-acc1130ed231?source=collection_archive---------28-----------------------

了解课本上没有教的技术

当运行一个聚类/分段项目时，最具挑战性的任务之一是确定存在多少个聚类。

好消息是有很多统计技术可以尝试回答这个问题，从肘法到 t-SNE 可视化到差距统计。

坏消息是这些技术很少是决定性的。机器学习课程使用诸如 Iris flower 数据集之类的例子的原因是，聚类的数量是预先知道的，并且它们相当容易找到。

当你完成学习并开始作为一名数据科学家工作时，你会很快意识到真实的数据更混乱，当数据不能给你一个清晰的画面时，你必须使用艺术和科学的混合。

肘法举例。教科书上的例子有一个清晰的信号，4 个集群就可以很好地工作。然而，现实世界的例子并不那么确定。图片作者。

因此，当你下一次被要求进行细分时，不要扔掉统计分析，只需使用下面的技术来创建一个在实践中有效的聚类，而不仅仅是在理论上。

谁在问？

开始之前不要失败；深入思考是谁要求进行细分，以及他们打算用它来做什么。

如果是营销团队试图更好地了解他们的客户，那么你可能会将搜索重点放在 3 到 10 之间。为什么？因为你不能指望人们脑子里带着超过 10 个集群和他们的轮廓。

如果团队必须为提议提出新的想法，你可能不需要太关心有多少集群描述了整个客户群。相反，你只需要找到尽可能多的有趣的群体，这些群体定义明确，足以激发一些新的想法，但又足够大，足以代表一个有价值的机会。

不要遇到第一个障碍，确保您只考虑适合您的用例的集群范围。GIF via GIPHY 。

或者，你的细分可能会直接进入产品，让顾客获得更个性化的体验。在这种情况下，你不太关心有没有一个人类能记住的数字，你只是想找到尽可能多的对个性化有用的数字，这可能有几千个！

并非所有的先入之见都是不好的

对于您的数据科学团队来说，这可能不是一条很好的原则，但是您不需要为所有事情都使用数据。

利益相关者将非常好地理解客户群中可能存在的集群类型的业务和期望。

虽然让数据说话很重要，而不是简单地产生一个给利益相关者他们想听的聚类，但提前了解他们的期望是一个有用的练习，原因有三:

验证。如果每个人都相信之前的分析表明有客户只在周末使用你的服务，那么一旦你超过一定数量的集群，这个群体开始出现，这应该会给你信心，你正朝着正确的方向前进。
惊喜。单个利益相关者不太可能描述您将在数据中发现的所有聚类，因此当您可以展示超出他们已知范围的新见解时，它就成为了数据科学的强大广告。
特色工程。如果您对存在的聚类有假设，您可以重新访问您的要素，并确保您将足够丰富的数据输入到您的算法中。如果没有捕捉一周中某一天的特征，您怎么能期望找到仅周末的聚类呢？

在执行分析之前，与利益相关者谈论他们期望看到的群体。GIF via GIPHY 。

你的集群稳定吗？

假设您的分析和用例表明适当的集群数量在 5 到 8 之间。与任何机器学习模型一样，您希望对您的数据进行有意义的反映，而不是在它接受训练的数据中出现异常。

考虑到这一点，根据不同时间点的数据来查看您的聚类会产生什么结果是一个有用的练习。您可能会发现，随着时间的推移，所生成的 5 个集群具有相当一致的大小和轮廓(通过检查它们的质心)，而 8 个集群的粒度太细，一些集群会从一个月到下一个月消失或呈现不同的含义。

在这种情况下，您应该倾向于更加一致和稳定的集群。

你的客户稳定吗？

就像你希望集群稳定一样，你也希望它们之间的移动有意义。

要做出决定，使用上一步的相同输出，但是这次检查段之间的迁移级别。例如，当您使用一月份的数据运行聚类分析时，如果 90%的客户属于不同的细分市场，那么二月份和三月份的数据就应该敲响警钟。

如果客户的行为是相同的，或者如果他们已经搬家，那么这是因为他们的构成发生了变化，那么你希望找到许多属于同一细分市场的客户群。因此，再次检查有多少客户搬家，以及这些客户是如何改变的，看看你是否对他们重新分类的原因感到满意。

如果客户迁移到一个新的集群，那应该是因为他们的行为发生了变化。GIF via GIPHY 。

用三个字告诉我

最后，了解你的集群。如果您能够理解属于每一个客户的客户以及为什么算法将他们分组在一起，您就有信心拥有一个合适的数量。

如果你的集群太宽泛，很难定义，或者有一个群体看起来是“其他所有人”的混杂集群，那么你可能没有足够的集群。相反，您可能有一些属于极少数客户的集群，这可能意味着您有太多的客户。

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

一个经常被引用的经验法则是三形容词法则；如果你能用三个形容词来描述你的集群，那么它们是定义明确的，易于交流，如果你需要更多，那么它们可能太细或难以解释。这只是一个指导原则，但是如果您希望集群在整个企业中为人所知，这是一个有用的检查。

总结

请记住以下问题，以补充您的分析并增强您对聚类的信心:

谁在要求细分，他们将如何使用细分？
利益相关者期望提前发现什么？
即使您在一个月后再次运行您的算法，这些聚类仍然相同吗？
随着时间的推移，客户通常会出现在同一个细分市场中，还是因为正确的原因而转移？
您能用三个形容词描述每个集群吗？

快乐聚类！

当你在这里的时候

请随意查看我的其他文章:

避免内存耗尽的简单技巧
如何管理初级数据科学家
计算损失函数
排列测试的威力

如何在你的机器学习模型中找到弱点

原文：https://towardsdatascience.com/how-to-find-weaknesses-in-your-machine-learning-models-ae8bd18880a3?source=collection_archive---------13-----------------------

FreaAI:来自 IBM 研究人员的新方法

任何时候使用汇总统计简化数据，都会丢失信息。模型精度也不例外。当将模型简化为汇总统计数据时，您将无法确定哪里的性能最低/最高以及原因。

图 1:模型性能较低的数据区域示例。图片作者。

为了解决这个问题，IBM 的研究人员最近开发了一种叫做 FreaAI 的方法，可以识别给定模型准确性较差的可解释数据切片。从这些切片中，工程师可以采取必要的步骤来确保模型按预期运行。

不幸的是，FreaAI 不是开源的，但是许多概念可以很容易地在您喜欢的技术栈中实现。让我们开始吧…

技术 TLDR

FreaAI 在测试数据中找到具有统计显著低性能的切片。它们被返回给工程师检查。方法步骤如下:

使用最高先验密度(HPD)方法寻找低精度的单变量数据切片。这些单变量数据切片缩小了搜索空间，并显示了我们的数据在哪里更有可能出现问题。
使用决策树寻找低精度的二元数据切片。这些双变量数据切片减少了分类预测因子和二阶相互作用的搜索空间，以显示我们的数据在哪里更有可能出现问题。
删除所有不符合特定启发式规则的数据切片。主要的两个是测试集的最小支持度和误差的统计显著增加。

但是，到底是怎么回事呢？

这是一大堆术语，所以让我们慢一点，真正理解发生了什么…

1.问题是

当开发一个模型时，我们经常使用“准确性”度量来确定适合度。一个例子是均方误差，用于线性回归，如图 2 所示。

图 2:均方误差公式。图片作者— src 。

但是这个平均误差仅仅告诉我们平均起来我们做的有多好。我们不知道我们是否在数据的某些方面表现得很好，或者在其他方面表现得很差。

这是预测建模中一个长期存在的问题，最近得到了很多关注。

2.解决方案

一种解决方案是 FreaAI。该方法由 IBM 开发，旨在确定我们的模型在数据中表现不佳的地方。

有两个主要步骤。第一步涉及创建数据切片，第二步涉及确定模型在这些数据切片中是否表现不佳。FreaAI 的输出是我们数据中模型性能较低的一组“位置”。

2.1。数据切片

组合测试(CT)是一个框架，它依次查看所有预测器组，以找到表现不佳的区域。例如，如果我们有两个分类预测值，颜色和形状，我们会查看所有可能的组合，看看准确性在哪里下降。

然而，在大型数据集上利用组合测试在计算上是不可能的——随着每个新列的出现，我们看到所需的组合数量呈指数级增长。因此，我们需要定义一种方法来帮助我们搜索特性，找到潜在的不准确的地方。

图 3:蓝色的 50%最高密度区域(HDR)的例子。图片作者——src。

FreaAI 使用的第一种方法是所谓的最高密度区域(HDR) (图 3)。简而言之，HDR 找到了数字特征中可以找到一定比例数据的最小区域，即高密度区域。在图 3 中，该区域由水平蓝色虚线区分，50%的数据位于该线之上。

从这里开始，我们将这个范围迭代地减小一个值ε(默认为 0.05)，并寻找精度的增加。如果在给定的迭代中精度确实增加了，我们知道该模型在前一次迭代和当前迭代之间的区域中表现不好。

为了确定数值预测因子的不良拟合区域，我们对测试集中的所有预测因子反复运行 HDR 方法。

很酷，对吧？

第二种方法利用决策树来处理所有非数字预测器以及两种特征的组合。简而言之，我们拟合一个决策树，并寻找这些特征的哪些分裂降低了准确性。

图 4:连续单变量预测因子“年龄”的决策树示例。图片作者。

在图 4 中，每个决策节点(蓝色)是我们特征的一个分割，每个结束节点(数字)是该分割的精度。通过拟合这些树，我们可以真正减少搜索空间，更快地找到性能差的区域。此外，因为树对于许多不同种类的数据都非常稳健，所以我们可以对分类预测器或多个预测器进行分析，以捕捉交互效应。

这种决策树方法对所有特征组合以及非数字的单个特征重复进行。

2.2.数据切片的试探法

到目前为止，我们只关心使用准确性开发数据切片，但是还有其他启发方法可以帮助我们找到有用的数据切片:

统计显著:为了确保我们只查看准确性有意义下降的数据切片，我们只保留性能比我们的误差置信区间的下限低 4%的切片。通过这样做，我们可以用概率 α 声明我们的数据切片具有更高的误差。
可解释的:我们也想确保发现的有问题的地方可以被采取行动，所以我们在创建组合时只看两三个特征。通过限制低阶交互，我们的工程师有更大的机会开发解决方案。
最小支持度:最后，数据切片必须有足够的误差才值得研究。我们要求必须至少有 2 个错误分类，或者它必须覆盖 5%的测试误差——无论哪个值更大都是我们采用的标准。

有趣的是，您可以根据自己的业务需求定制其他启发式方法。对一些用户进行错误分类比其他用户更糟糕，因此您可以将这一点纳入您的数据切片标准——想想精度/召回权衡。

3.总结和要点

所以，这就是你要的——荣耀的法国。

还是那句话，FreaAI 不是开源的，但希望它将来会向公众发布。与此同时，您可以将我们讨论的框架应用到您自己的预测模型中，并确定哪里存在系统性的表现不佳。

3.1.摘要

概括地说，FreeAI 使用 HDR 和决策树来减少预测器的搜索空间。然后，它反复查看单个特性以及组合，以确定哪里的性能较低。这些低性能领域有一些额外的启发，以确保调查结果是可操作的。

3.2.你为什么要在乎？

首先，这个框架帮助工程师识别模型的弱点。当这些弱点被发现时，它们可以(有希望)被纠正，从而改进预测。这种增益对于黑盒模型(如神经网络)特别有吸引力，因为没有模型系数。

通过隔离表现不佳的数据区域，我们获得了一个了解黑盒的窗口。

FreaAI 在其他应用方面也有着令人感兴趣的潜力。一个例子是识别模型漂移，这是当经过训练的模型随着时间变得越来越不有效时发生的情况。IBM 刚刚发布了一个用于确定模型漂移的假设测试框架。

另一个有趣的应用是确定模型偏差。在这种情况下，偏见是不公平的概念，例如基于性别拒绝给某人贷款。通过查看模型性能较低的不同数据分割，您可能会发现存在偏差的区域。

感谢阅读！我会再写 37 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源以及一些有用的资源。

如何在不同类型的 SQL 中找到自己的路

原文：https://towardsdatascience.com/how-to-find-your-way-through-the-different-types-of-sql-26e3d3c20aab?source=collection_archive---------11-----------------------

入门，SQL 方言:什么，为什么，如何

MySQL、PostgreSQL、SQL Server……为什么会有这么多 SQL 方言存在？你应该选择哪一个？

在 SQL 丛林中寻找正确的方向(由伊森·赛克斯在 Unsplash 上拍摄)

无论你是数据库管理领域的初学者还是整天操纵表和视图的 SQL 专家，你可能已经听说过一些关于 SQL 的术语，比如“Transact-SQL”或“PostgreSQL”。为什么不简单的用“SQL”来谈… SQL？顺便问一下，你念" S. Q. L . "还是"续集"？

我最初认为，用来谈论 SQL 作为一种编程语言的术语的多样性是无聊的工程师或营销人员为了以不同的名称销售相同的“产品”而制造的过度复杂化的结果。然而，我必须承认这不是真的:SQL 编程语言和 SQL 编程语言确实存在差异。

这篇文章有几个目标。首先，它介绍了 SQL 创建和扩展背后的历史背景，这是这种编程语言进一步发展的基础。这将引导我们进入第二部分，旨在更好地理解各种 SQL 方言之间的差异。最后，我们将把这些见解放到中，帮助您选择学习和使用 SQL 作为管理数据库工具的最佳方式。

一点历史:为什么存在不同的 SQL 方言？

为了理解 SQL 方言的起源，我们必须回到关系数据库管理的基础(RDBM) 。1970 年，在 IBM 工作的英国计算机科学家埃德加·弗兰克·科德发表了一篇名为“大型共享数据库数据的关系模型”的论文。这就是他发明数据库管理关系模型的时候，从那时起它就成为了关系数据库和关系数据库管理系统的理论基础。

E.F. Codd 研究论文摘要(来源)

在这个突破性的发明之后，设计者选择用两种方式来表达关系模型:微积分(像 Ingres 那样)或者代数(像 IBM 那样)。代数赢得了这场战斗，这就是现在使用的方法。在此之后，在 80 年代后期做了一些努力来创建一个 SQL 标准。SQL 于 1986 年成为美国国家标准协会(ANSI)的标准，并于 1987 年成为国际标准化组织(ISO)的标准。自 20 世纪 80 年代以来，SQL 标准已经过多次修订，尽管标准 SQL 的核心特性自 1992 年以来一直保持稳定。

然而，新的变化不断出现，因为在不同厂商工作的数据库实现者需要解决新的问题或规避标准中没有解决的已经存在的问题。这解释了为什么多种 SQL 方言出现了，并且今天仍然共存。

总结一下这段历史介绍，目前的情况如下:只有一种 SQL 语言，但是不同的数据库管理系统已经扩展了原始的 SQL 标准，以添加它们自己的功能或者使语法适应它们自己的运行方式。通过这样做，他们诞生了各种 SQL 方言。

SQL 方言:有什么区别？

如您所知， SQL 是一种编程语言，用于提取数据和处理数据库中的数据。其中，SQL Server、Oracle、MySQL 和 PostgreSQL 是关系数据库管理系统(RDBMS)** ,出于我们前面提到的原因，它们有自己的 SQL 方言。**

对于新手或中级用户来说，这些差异主要可以在语法中看到，而对于我们大多数人(包括我自己)来说，这些差异背后的技术原因是相当模糊的。然而，这不会妨碍我们以最恰当的方式使用 SQL！

为了更好地理解四种 SQL 方言之间的主要差异，这里概述了 PostgreSQL、MySQL、Microsoft SQL Server 和标准 SQL 在 Google BigQuery 中使用时的一些语法特性。

四种 SQL 方言的语法差异(按作者分类的图表)

更进一步，你会在一个名为“关系数据库管理系统的比较”的专门维基百科页面上找到各种 RDBMS 之间差异的相对详尽的清单。

选择的时间:应该使用哪种 SQL 方言？

正如我们刚刚讨论的， PostgreSQL 是最接近标准 SQL 的，同时它是一种广泛使用的 SQL 方言。这就是为什么从学习 PostgreSQL 开始会给你最灵活的工具，以便以后可能适应其他 SQL 方言并将你的技能转化到其他 RDBMS。

做出决定的另一种方法可能是检查劳动力市场当前的技术技能需求。在其最新的开发者调查(2021) 中，堆栈溢出位列最受欢迎的数据库技术。顶级技术都包括 SQL，这加强了开始学习 SQL(无论何种方言)的必要性。在这项调查中， MySQL 在很大程度上主导了排名。

基于栈溢出上的问题标签看趋势时， MySQL 也排在其他 SQL 方言之前。微软 SQL Server 排名第二，因为它仍然被大公司广泛使用。

网站 DB-Engines 提出了另一个排名顺序，其中甲骨文排名第一。为了每年建立这个列表，他们分析了从搜索引擎(Google，Bing)，Google Trends，IT 相关网站(Stack Overflow，DBA Stack Exchange)，工作搜索引擎(实际上，只是雇佣)，社交网络(LinkedIn，Twitter)检索的数据。

根据不同来源列出的前 3 种 SQL 方言(按作者排列的图表)

最后，还是务实一点吧。如果你在一家使用特定 RDBMS 的公司工作，那么你应该学习与之相关的 SQL 方言。例如，微软 SQL Server 在许多行业仍然占有很大的市场份额。如果你正在某个行业找工作，你可以浏览职位空缺，看看数据库管理所需的技能。这可能会给你一些宝贵的提示，告诉你为了自己的职业目标应该开始学习哪种 SQL 方言。

最后的想法

掌握 SQL 是数据库管理的必备技能。无论您选择从哪种 SQL 方言开始，基本原理都是相同的，并且是使用数据库的一个关键元素。

在你学习了基础知识之后，当你沿着职业道路前进时，你可能不得不学习几种 SQL 方言。我的最后一条建议是:选择第一种 SQL 方言并坚持下去，直到你获得足够的知识，然后你将能够适应使用 SQL 的其他环境。

举个例子，我在大学和在线课程中学到了 MySQL。但自从我在一家初创公司担任数据分析师以来，我已经将切换到了标准 SQL** ，因为它被用于谷歌大查询。希望这篇文章能帮助你在 SQL 之旅中选择正确的道路！**

你喜欢阅读这篇文章吗？成为 的一员，加入一个不断成长的充满好奇心的社区吧！

https://marie-lefevre.medium.com/membership

如何微调问答转换器

原文：https://towardsdatascience.com/how-to-fine-tune-a-q-a-transformer-86f91ec92997?source=collection_archive---------3-----------------------

了解如何微调问答的 ML 模型

由迈克尔·泽兹奇在 Unsplash 上拍摄的照片

Transformer 模型无疑是 NLP 中的领导者——在几乎所有其他任务中，它都胜过几乎所有其他模型架构。

变形金刚已经证明自己有能力处理的最有趣的基于语言的任务之一是问答。

在本文中，我们将了解 NLP 中的问答领域，并了解如何下载和微调世界上最先进的 transformer 模型。简而言之:

> Our Dataset
  - Downloading SQuAD> Preparing The Data
  - Extraction
  - Encoding
  - Initializing the Dataset> Fine-Tuning> Measuring Performance
  - Implementing Accuracy

如果你喜欢视频——我在这里也涵盖了一切:

我们的数据集

对于我们的例子，我们将使用斯坦福问答数据集(SQuAD) 2.0 。我们的模型将被期望正确地选择回答我们提供的问题的文本片段的特定部分。

下载小队

我们可以像这样用 Python 下载数据:

这将返回两个文件，我们的训练数据train-v2.0.json——和我们的验证数据dev-v2.0.json。两者看起来都像这样:

JSON 预览——它包括几个层，这些层导致一个上下文(底部)和几个问题 - 答案对用于每个上下文

这里我们的数据有三个关键部分，它们是:

问题 —包含我们将向模型提出的问题的字符串
上下文 —包含我们问题答案的更大的文本片段
答案 —较短的字符串，是给定上下文的“摘录”，为我们的问题提供答案

因此，我们将为模型提供一个问题和相应的答案。然后，模型必须读取两者，并从上下文返回预测答案的标记位置。

准备数据

提取，血统

准备这些数据进行微调的第一步是将我们的问题、上下文和答案从 JSON 文件提取到训练和验证集中。我们可以这样做:

答案

这使我们的两个数据集在三个列表(每个列表)之间拆分:

相应的上下文、问题和答案集

我们的上下文和问题是简单的字符串——彼此对应。每个问题的答案都可以在上下文中找到。

答案列表略有不同，因为每个条目都是一个字典，其中答案包含在'text'中，并且该答案在上下文中的起始位置也在'answer_start'中提供。

这没问题，但是我们需要训练我们的模型在上下文中找到答案的开始和结束——所以我们也需要添加一个'answer_end'值:

这给了我们:

字典的答案数组——现在包括一个修正的 answer_start 和一个 answer_end 位置

编码

我们的数据几乎准备好了；我们只需要将我们的字符串转换成记号——然后将我们的answer_start和answer_end索引从字符位置转换成记号位置。

使用内置的 HuggingFace 标记器很容易完成标记化，如下所示:

我们的上下文问题对现在被表示为Encoding对象。这些对象合并每个相应的上下文和问题字符串，以创建 BERT 所期望的 Q & A 格式——它简单地将上下文和问题连接在一起，但用一个[SEP]标记分隔开:

我们输入到模型中的数据(显示出来的数据被解码成人类可读的文本)只是上下文(包含答案)和问题的连接，用一个【SEP】标记分隔

这个串联版本存储在我们的Encoding对象的input_ids属性中。但是，数据存储为 BERT 可读的令牌 id，而不是人类可读的文本。

这个tokenizer很棒，但是它没有产生我们的答案开始-结束令牌位置。为此，我们定义了一个定制的add_token_positions函数:

这个函数向我们的Encoding对象添加了另外两个属性— start_positions和end_positions。其中每一个都是一个简单的列表，包含答案的开始/结束标记位置，对应于它们各自的问题-上下文对。

train_encodings 和存储在对象内部的属性——包括令牌 start_positions 和 end_positions

正在初始化数据集

现在，我们已经准备好了数据，并且拥有了我们需要的一切—我们只需要将它转换成正确的格式，以便使用 PyTorch 进行培训。

为此，我们需要构建一个数据集对象，我们可以像这样轻松地完成:

我们将能够在训练和验证期间将这些数据集对象输入到我们的模型中。

微调

我们的数据现在完全可以供我们的模型使用了。我们现在要做的就是设置我们的 PyTorch 环境，初始化我们将在训练期间用来加载数据的DataLoader——最后，开始微调我们的模型:

与大多数变压器模型相比，DistilBert 是一个小模型——但这仍需要一些时间来训练。

完成后，我们可以继续保存我们新微调的模型(如果需要，还有 tokenizer)——我们将把它保存到一个新目录models/distilbert-custom:

拯救我们的

当再次加载我们的模型时，我们可以使用与从 HuggingFace 加载模型时相同的from_pretrained方法——我们所做的就是用我们的本地路径替换在线模型路径/名称——在这种情况下:

model_path = 'models/distilbert-custom'
model = DistilBertForQuestionAnswering.from_pretrained(model_path)
tokenizer = DistilBertTokenizerFast.from_pretrained(model_path)

或者使用通用AutoModel加载器:

model = AutoModel.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)

衡量绩效

一旦我们训练了我们的模型，我们就可以开始进行预测，并向我们的模型提出一些问题。

请记住，我们已经在使用一个高度优化的基础模型——这使我们成功了一半——但是我们仍然可以从不同模型的实验中受益。

但是现在，我们只需要学习这种方法——以及如何将它应用到我们自己更具体的用例中。所以让我们来学习一下后培训应该怎么做。

为了从我们的模型中提取开始-结束令牌范围，我们可以访问start_logits和end_logits张量并执行argmax函数，如下所示:

start_pred = torch.argmax(outputs['start_logits'], dim=1)
end_pred = torch.argmax(outputs['end_logits'], dim=1)

start_pred 和 end_pred 张量将看起来像这样——这些是模型对开始-结束答案位置的预测。

我们在这里可以测量的最简单的度量是准确性——更具体地称为精确匹配(EM)——模型是否获得了正确的开始或结束标记？当然，这并没有考虑到模型越来越接近，可能会丢失一两个令牌——但这是一个开始。

为了计算每批的 EM，我们取每批匹配数的sum,然后除以总数。我们用 PyTorch 这样做:

acc = ( (start_pred == start_true).sum() / len(start_pred) ).item()

最后的.item()将张量值提取为一个简单的 Python int。

精确匹配

现在我们知道了如何计算我们的问答准确度——让我们为我们的val_dataset实现它吧！

我们再次设置了一个DataLoader——然后遍历每一批。不过这一次，我们调用model.eval()将相关层的行为从训练模式切换到推理模式，并使用torch.no_grad()阻止 PyTorch 计算模型梯度(仅在训练期间需要):

在所有这些之后，我们有了一个——尽管是粗略的——精确度的衡量标准。

在 63.6% 的时间里，该模型设法获得正确答案的确切跨度(开始和/或结束)。63.6%当然不是一个特别令人印象深刻的数字，除非我们更深入地了解该模型的表现。

打印出我们数据集中最后一批问答对——尽管在大约 50%的情况下，它与真实答案的差距不到一个符号(或更少),但它只获得了 18.75%的 EM。

EM 指标并没有描绘出全貌——尽管在最后一批中 EM 得分仅为 18.75%——该模型在 4/8 的问题中确实非常接近，这并没有反映在 EM 得分中。

尽管如此，当测量和比较模型时，EM 是一个完美的起点。

本次演练到此结束！我们采用了一个预训练的 DistilBert 模型，给它安装了一个问答头，并使用小队数据集对它进行了微调。制作我们自己的问答模型。

然而，更重要的是，我们引入了获取问答数据集的过程，并使用它来“微调”预训练的 transformer 模型。

学习和理解这个过程非常重要，如果应用正确，可以将问答模型在特定用例上的性能提高很多。

您很可能不会使用 SQuAD 数据集进行任何微调，而是使用您自己的数据或开源问答数据集:

NewsQA — 120K CNN 新闻文章
图 QA —基于图表的 Q & A
来自 Reddit 的财务意见 Q &
常识问答——祝你好运😄

现在已经有大量的数据集可用，而且越来越多的数据集经常可用，所以有很多东西可以学习！

我希望你喜欢这篇文章！如果你有任何问题，请通过 Twitter 或在下面的评论中告诉我。如果你想知道更多类似的内容，我也会在 YouTube 上发布。

感谢阅读！

参考

使用自定义数据集进行微调，HuggingFace 的变形金刚文档

🤖带变压器的 NLP 课程

全篇代码

*除非另有说明，所有图片均出自作者之手

如何用 spaCy 3 微调 BERT 变压器

原文：https://towardsdatascience.com/how-to-fine-tune-bert-transformer-with-spacy-3-6a90bfe57647?source=collection_archive---------0-----------------------

如何为 NER 微调 BERT 的分步指南

照片由 https://unsplash.com/@jasonrosewell 阿丽娜·格鲁布尼亚在 Unsplash 上拍摄

自从 Vaswani 等人的开创性论文“注意力是你所需要的全部”以来，变压器模型已经成为 NLP 技术中最先进的技术。应用范围从 NER，文本分类，问答或聊天机器人，这项惊人的技术的应用是无限的。

更具体地说，BERT——代表转换器的双向编码器表示——以一种新颖的方式利用转换器架构。例如，BERT 用一个随机屏蔽的单词分析句子的两边来进行预测。除了预测掩码标记之外，BERT 还通过在第一个句子的开头添加分类标记[CLS]来预测句子的顺序，并通过在两个句子之间添加分隔标记[SEP]来尝试预测第二个句子是否跟随第一个句子。

伯特建筑

在本教程中，我将向您展示如何微调 BERT 模型来预测软件职位描述中的技能、文凭、文凭专业和经验等实体。如果你有兴趣更进一步，提取实体之间的关系，请阅读我们的文章关于如何使用 transformers 执行联合实体和关系提取。

微调变压器需要强大的并行处理 GPU。为此，我们使用 Google Colab，因为它提供免费的带有 GPU 的服务器。

对于本教程，我们将使用新发布的 spaCy 3 库来微调我们的转换器。下面是如何在 spaCy 3 上微调 BERT 模型的分步指南(视频教程此处)。代码和必要的文件可以在 G ithub repo 中找到。

数据标签:

为了使用 spaCy 3 对 BERT 进行微调，我们需要提供 spaCy 3 JSON 格式的训练和开发数据(参见这里的)，然后这些数据将被转换成一个. spaCy 二进制文件。我们将提供 TSV 文件中包含的 IOB 格式的数据，然后转换为 spaCy JSON 格式。

对于培训数据集，我只标记了 120 个职位描述和大约 70 个职位描述，这些职位描述带有实体，如技能、文凭、文凭专业、和经验。

在本教程中，我使用了 UBIAI 注释工具，因为它具有广泛的特性，例如:

ML 自动注释
字典、正则表达式和基于规则的自动注释
团队协作以共享注释任务
直接将注释导出为 IOB 格式

使用 UBIAI 中的正则表达式特性，我已经按照“\d.+模式对所有提到的体验进行了预注释。”如“5 年以上 C++经验”。然后，我上传了一个包含所有软件语言的 csv 字典，并分配了实体技能。预先注释可以节省大量时间，并帮助您最大限度地减少手动注释。

UBIAI 注释接口

关于 UBIAI 注释工具的更多信息，请访问文档页面和我之前的文章。

导出的注释将如下所示:

MS B-DIPLOMA
in O
electrical B-DIPLOMA_MAJOR
engineering I-DIPLOMA_MAJOR
or O
computer B-DIPLOMA_MAJOR
engineering I-DIPLOMA_MAJOR
. O
5+ B-EXPERIENCE
years I-EXPERIENCE
of I-EXPERIENCE
industry I-EXPERIENCE
experience I-EXPERIENCE
. I-EXPERIENCE
Familiar O
with O
storage B-SKILLS
server I-SKILLS
architectures I-SKILLS
with O
HDD B-SKILLS

为了从 IOB 转换到 JSON(参见文档这里，我们使用 spaCy 3 命令:

!python -m spacy convert drive/MyDrive/train_set_bert.tsv ./ -t json -n 1 -c iob
!python -m spacy convert drive/MyDrive/dev_set_bert.tsv ./ -t json -n 1 -c iob

在转换成 spaCy 3 JSON 之后，我们需要将 training 和 dev JSON 文件都转换成。spacy 二进制文件使用此命令(用您自己的命令更新文件路径):

!python -m spacy convert drive/MyDrive/train_set_bert.json ./ -t spacy!python -m spacy convert drive/MyDrive/dev_set_bert.json ./ -t spacy

模型培训:

打开一个新的 Google Colab 项目，确保在笔记本设置中选择 GPU 作为硬件加速器。
为了加速训练过程，我们需要在我们的 GPU 上运行并行处理。为此，我们安装了 NVIDIA 9.2 cuda 库:

!wget [https://developer.nvidia.com/compute/cuda/9.2/Prod/local_installers/cuda-repo-ubuntu1604-9-2-local_9.2.88-1_amd64](https://developer.nvidia.com/compute/cuda/9.2/Prod/local_installers/cuda-repo-ubuntu1604-9-2-local_9.2.88-1_amd64) -O cuda-repo-ubuntu1604–9–2-local_9.2.88–1_amd64.deb!dpkg -i cuda-repo-ubuntu1604–9–2-local_9.2.88–1_amd64.deb!apt-key add /var/cuda-repo-9–2-local/7fa2af80.pub!apt-get update!apt-get install cuda-9.2

要检查是否安装了正确的 cuda 编译器，运行:！nvcc -版本

安装空间库和空间转换器管道:

pip install -U spacy
!python -m spacy download en_core_web_trf

接下来，我们安装为 cuda 9.2 配置的 pytorch 机器学习库:

pip install torch==1.7.1+cu92 torchvision==0.8.2+cu92 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html

pytorch 安装后，我们需要安装为 cuda 9.2 调整的 spacy transformers，并更改 CUDA_PATH 和 LD_LIBRARY_PATH，如下所示。最后，安装 cupy 库，它相当于 numpy 库，但用于 GPU:

!pip install -U spacy[cuda92,transformers]
!export CUDA_PATH=”/usr/local/cuda-9.2"
!export LD_LIBRARY_PATH=$CUDA_PATH/lib64:$LD_LIBRARY_PATH
!pip install cupy

SpaCy 3 使用包含所有模型训练组件的配置文件 config.cfg 来训练模型。在 spaCy training 页面中，您可以选择模型的语言(本教程中为英语)、要使用的组件(NER)和硬件(GPU)并下载配置文件模板。

用于培训的 Spacy 3 配置文件。来源

我们唯一需要做的就是为火车和 dev 填充路径。垃圾文件。完成后，我们将文件上传到 Google Colab。

现在我们需要用 BERT 模型需要的其余参数自动填充配置文件；您只需运行以下命令:

!python -m spacy init fill-config drive/MyDrive/config.cfg drive/MyDrive/config_spacy.cfg

我建议调试您的配置文件，以防出现错误:

!python -m spacy debug data drive/MyDrive/config.cfg

我们终于准备好训练 BERT 模型了！只需运行这个命令，培训就应该开始了:

!python -m spacy train -g 0 drive/MyDrive/config.cfg — output ./

页（page 的缩写）如果你得到错误 cupy _ back ends . CUDA . API . driver . CUDA driver ERROR:CUDA _ ERROR _ INVALID _ PTX:一个 PTX JIT 编译失败，只需卸载 cupy 并重新安装它，它应该可以修复这个问题。

如果一切正常，您应该开始看到模型得分和损失正在更新:

在 google colab 上进行 BERT 培训

培训结束时，模型将保存在文件夹“模型-最佳”下。模型分数位于 model-best 文件夹内的 meta.json 文件中:

“performance”:{“ents_per_type”:{“DIPLOMA”:{“p”:0.5584415584,“r”:0.6417910448,“f”:0.5972222222},“SKILLS”:{“p”:0.6796805679,“r”:0.6742957746,“f”:0.6769774635},“DIPLOMA_MAJOR”:{“p”:0.8666666667,“r”:0.7844827586,“f”:0.8235294118},“EXPERIENCE”:{“p”:0.4831460674,“r”:0.3233082707,“f”:0.3873873874}},“ents_f”:0.661754386,“ents_p”:0.6745350501,“ents_r”:0.6494490358,“transformer_loss”:1408.9692438675,“ner_loss”:1269.1254348834}

由于训练数据集有限，分数肯定远低于生产模型水平，但值得在示例工作描述中检查其性能。

用变压器提取实体

为了在示例文本上测试模型，我们需要加载模型并在我们的文本上运行它:

nlp = spacy.load(“./model-best”)
text = ['''Qualifications- A thorough understanding of C# and .NET Core- Knowledge of good database design and usage- An understanding of NoSQL principles- Excellent problem solving and critical thinking skills- Curious about new technologies- Experience building cloud hosted, scalable web services- Azure experience is a plusRequirements- Bachelor's degree in Computer Science or related field(Equivalent experience can substitute for earned educational qualifications)- Minimum 4 years experience with C# and .NET- Minimum 4 years overall experience in developing commercial software''']for doc in nlp.pipe(text, disable=["tagger", "parser"]): print([(ent.text, ent.label_) for ent in doc.ents])

以下是从我们的示例工作描述中提取的实体:

[("C", "SKILLS"),("#", "SKILLS"),(".NET Core", "SKILLS"),("database design", "SKILLS"),("usage", "SKILLS"),("NoSQL", "SKILLS"),("problem solving", "SKILLS"),("critical thinking", "SKILLS"),("Azure", "SKILLS"),("Bachelor", "DIPLOMA"),("'s", "DIPLOMA"),("Computer Science", "DIPLOMA_MAJOR"),("4 years experience with C# and .NET\n-", "EXPERIENCE"),("4 years overall experience in developing commercial software\n\n", "EXPERIENCE")]

仅使用 120 个培训文档就已经相当不错了！我们能够正确地提取大部分技能、文凭、文凭专业和经验。

有了更多的训练数据，该模型肯定会进一步改进，并产生更高的分数。

结论:

由于惊人的 spaCy 3 库，仅用几行代码，我们就成功地训练了一个功能性的 NER 变换器模型。请继续在您的用例上进行尝试，并分享您的结果。注意，您可以使用 UBIAI 标注工具来标注您的数据，我们提供 14 天免费试用。

一如既往，如果您有任何意见，请在下方留言或发送电子邮件至 admin@ubiai.tools！

在 Twitter 上关注我们

参考

https://www.youtube.com/watch?v=Y_N_AO39rRg&t = 1s

如何用 NSP 微调伯特

原文：https://towardsdatascience.com/how-to-fine-tune-bert-with-nsp-8b5615468e12?source=collection_archive---------13-----------------------

使用变压器和 PyTorch 轻松微调

硬拉，伯特的最爱——作者图片

下一句预测(NSP)是 BERT 模型(另一个是掩蔽语言建模——MLM)后面的训练过程的一半。

尽管 NSP(和 MLM)被用来预先训练 BERT 模型，我们可以使用这些精确的方法来微调我们的模型，以更好地理解我们自己的用例中特定的语言风格。

因此，在本文中，我们将详细介绍如何获取非结构化的文本，并使用 NSP 对 BERT 模型进行微调。

培养

那么，我们如何使用 NSP 对模型进行微调呢？

首先，我们需要数据。因为我们本质上只是在连续句和随机句之间切换——我们可以使用几乎任何文本。我们不需要有标签的或特殊的数据。

这里，我们将使用马库斯·奥勒留的冥想，来源于这里并稍加预处理(干净版)。

首先，我们将导入/初始化并加载我们的文本数据。

我们需要在标记化之前对数据进行预处理，这样我们就可以得到一组随机和非随机的句子对。

NSP 预处理

首先，我们将创建一个随机句子的bag——我们将根据句点字符对其进行拆分。

这就给我们留下了 1372 个句子样本。从这里开始，我们需要创建句子对，并标记它们是连续的句子对，还是随机的句子对。

我们可以在最后一个细胞的输出中看到我们创建的两对细胞。第一个标记为 1 并显示一个NotNextSentence对，第二个标记为 0 并显示一个IsNextSentence对。

标记化

我们的数据现在可以进行标记化了，这次我们将每个序列截断/填充到 512 个标记的相同长度。

在 token_type_ids 张量中，我们可以看到同样的 0 后面跟着 1 记号(分别是句子 A 和 B)，后面跟着更多的 0 记号。这些用于指示填充标记。

我们还需要一个标签张量，它将对应于包含在label变量中的值。我们的标签张量——和以前一样——必须是一个torch.LongTensor。

输入管道

现在我们的输入张量已经准备好了，我们可以开始为训练构建模型输入管道。我们首先从数据中创建 PyTorch 数据集。

并初始化数据加载器，这是我们在训练中将用来将数据加载到模型中的。

培训设置

现在，在开始训练之前，我们设置最后几件事情。我们将模型移动到 GPU(如果可用)，激活训练模式，并初始化我们的优化器。

我们使用 Adam with weighted decay 作为我们的优化器，这是训练变压器模型的常见选择，因为它减少了过度拟合的可能性(由于大多数变压器的巨大尺寸，这是一个常见的问题)。

训练循环

最后，我们可以进入训练循环。我们将训练几个时期来展示损失随时间的变化。

就这样，我们用 NSP 微调了我们的伯特模型！

这就是这篇关于用 NSP 微调伯特的文章。

NSP 有很多，但是概念和实现并不太复杂——但是功能非常强大。

使用我们在这里学到的知识，我们可以采用 NLP 中最好的模型，并对它们进行微调以适应我们更特定于领域的语言用例——只需要未标记的文本——通常是很容易找到的数据源。

我希望你喜欢这篇文章！如果你有任何问题，请通过 Twitter 或在下面的评论中告诉我。如果你想要更多这样的内容，我也会在 YouTube 上发布。

感谢阅读！

参考

[1] J .德夫林等人。艾尔。， BERT:语言理解深度双向转换器预训练 (2019)，NAACL

🤖《变形金刚》NLP 课程 70%的折扣

如果你有兴趣了解更多关于 NSP 到底是如何运作的——看看这篇文章:

*所有图片均由作者提供，除非另有说明

如何为文本生成微调 GPT-2

原文：https://towardsdatascience.com/how-to-fine-tune-gpt-2-for-text-generation-ae2ea53bc272?source=collection_archive---------0-----------------------

使用 GPT-2 生成高质量的歌词

来源:https://unsplash.com/photos/gUK3lA3K7Yo

自然语言生成(NLG)在最近几年取得了令人难以置信的进步。2019 年初，OpenAI 发布了 GPT-2，这是一个巨大的预训练模型(1.5B 参数)，能够生成类似人类质量的文本。

顾名思义，创成式预训练变形金刚 2 (GPT-2)基于变形金刚。因此，它使用注意力机制，这意味着它学会关注与上下文最相关的前几个单词，以便预测下一个单词(更多信息，请访问这里)。

本文的目标是向您展示如何根据您提供给它的数据，对 GPT-2 进行微调，以生成上下文相关的文本。

作为一个例子，我将生成歌词。这个想法是使用已经训练好的模型，根据我们的具体数据进行微调，然后根据模型观察到的情况，生成任何给定歌曲中应该遵循的内容。

准备数据

GPT-2 本身可以生成质量不错的文本。但是，如果您希望它在特定的上下文中做得更好，您需要根据您的特定数据对它进行微调。在我的例子中，因为我想生成歌词，所以我将使用下面的 Kaggle 数据集，它包含总共 12，500 首流行摇滚歌曲的歌词，都是英文的。

让我们从导入必要的库和准备数据开始。我推荐在这个项目中使用 Google Colab，因为使用 GPU 会让事情变得更快。

从第 26 行和第 34–35 行可以看出，我创建了一个小型测试集，删除了每首歌的最后 20 个单词。这将允许我将生成的文本与实际文本进行比较，以查看模型的执行情况。

创建数据集

为了在我们的数据上使用 GPT-2，我们还需要做一些事情。我们需要对数据进行记号化，这是将一系列字符转换成记号的过程，即把一个句子分割成单词。

我们还需要确保每首歌曲最多支持 1024 个令牌。

在训练过程中,SongLyrics类将为我们做这些，为我们原始数据帧中的每一首歌。

模型的训练

我们现在可以导入预训练的 GPT-2 模型，以及令牌化器。另外，就像我之前提到的，GPT 2 号是巨大的。如果你试图在你的电脑上使用它，你很可能会得到一堆CUDA Out of Memory错误。

可以使用的另一种方法是累加梯度。

这个想法很简单，在调用优化来执行梯度下降步骤之前，它将对几个操作的梯度求和。然后，将该总数除以累计步数，以获得训练样本的平均损失。这意味着更少的计算。

现在，最后，我们可以创建训练函数，它将使用我们所有的歌词来微调 GPT-2，以便它可以预测未来的优质诗句。

随意使用各种超参数(批量大小、学习率、时期、优化器)。

然后，最后，我们可以训练模型。

model = train(dataset, model, tokenizer)

使用torch.save和torch.load，你也可以保存你训练好的模型以备将来使用。

歌词生成

是时候使用我们全新的微调模型来生成歌词了。通过使用以下两个函数，我们可以为测试数据集中的所有歌曲生成歌词。请记住，我已经删除了每首歌的最后 20 个词。对于给定的歌曲，我们的模型现在将查看他的歌词，并得出歌曲的结尾。

对于整个测试数据帧，generate 函数准备生成，而text_generation 实际上完成生成。

在第 6 行，我们指定了一代的最大长度。我将其保留为 30，但这是因为标点符号很重要，稍后我将删除最后几个单词，以确保生成在句子的末尾结束。

另外两个超参数值得一提:

温度(第 8 行)。它用于衡量给定单词生成的概率。因此，高温迫使模型做出更多的原创预测，而低温则防止模型偏离主题。
顶 p 过滤(第 7 行)。该模型将按降序对单词概率进行排序。然后，它会将这些概率相加，直到 p，同时丢弃其他单词。这意味着该模型只保留最相关的单词概率，而不是只保留最好的一个，因为对于给定的序列，不止一个单词是合适的。

在下面的代码中，我简单地清理了生成的文本，确保它在句子的末尾(而不是中间)结束，并将其存储在测试数据集中的一个新列中。

性能赋值

有许多方法可以评估生成文本的质量。最受欢迎的指标叫做 BLEU。该算法根据生成的文本与现实的相似程度，输出一个介于 0 和 1 之间的分数。分数为 1 表示生成的每个单词都存在于真实文本中。

下面是为生成的歌词评估 BLEU 分数的代码。

我们获得了 0.685 的平均 BLEU 分数，相当不错。相比之下，没有任何微调的 GPT-2 模型的 BLEU 得分为 0.288。

然而，BLEU 也有其局限性。它最初是为机器翻译而创建的，只查看用于确定生成文本质量的词汇。这对我们来说是个问题。事实上，有可能产生高质量的诗句，使用与现实完全不同的词语。

这就是为什么我会对模型的性能做一个主观的评价。为此，我创建了一个小的 web 界面(使用 Dash)。代码可以在我的 Github 库中找到。

界面的工作方式是你给 app 提供一些输入单词。然后，该模型将使用它来预测下一对诗句应该是什么。以下是一些结果示例。

红色的是 GPT-2 模型预测的，给定黑色的输入序列。你看到它已经成功地产生了有意义的诗句，并且尊重了之前发生的事情的背景！此外，它会生成长度相似的句子，这对于保持歌曲的节奏非常重要。在这方面，当生成歌词时，输入文本中的标点符号是绝对必要的。

结论

正如本文所示，通过对特定数据进行 GPT-2 微调，可以相当容易地生成上下文相关的文本。

对于歌词生成，该模型可以生成尊重上下文和句子的期望长度的歌词。当然，可以对模型进行改进。例如，我们可以强迫它生成押韵的诗句，这是写歌词时经常需要的。

非常感谢你的阅读，我希望我能有所帮助！

包含所有代码和模型的库可以在这里找到:https://github . com/francoistamant/lyrics-generation-with-gp T2

对 Flask-vue.js 应用程序中的 CloudFlare 网关超时错误 524 进行故障排除

原文：https://towardsdatascience.com/how-to-fix-a-cloudflare-gateway-timeout-error-in-a-flask-vue-js-ml-application-efe2826585bb?source=collection_archive---------7-----------------------

CloudFlare 如何通过 CloudFlare 网站工作

当我和曼努埃尔·古兹曼 (MSW R & D director)在测试一个 ML 应用程序时，出现了 524 网关超时错误，这个应用程序需要几分钟时间来生成结果，然后再将结果发送给用户。

我们发现应该增加 CloudFlare 中的超时限制来消除错误。

根据我们在谷歌搜索这个错误时发现的一些答案，它是不可能修复的(查看这个 StackOverflow 答案)。

经过一次头脑风暴，我们按照曼纽尔的想法解决了这个问题。

在本文中，我将与您分享我们为解决 Cloudflare 中的 524 网关超时错误而采取的所有步骤。

我将介绍如何解决这种类型的错误，更重要的是我们使用的代码片段。

什么是 524 网关超时错误？

524 网关超时错误是特定于 Cloudflare 的 HTTP 状态代码，表示与服务器的连接因超时而关闭。

下面是在 Cloudflare 支持网站中的定义

错误 524 表示 Cloudflare 成功连接到源 web 服务器，但在默认的 100 秒连接超时之前，源没有提供 HTTP 响应。企业客户可以将 524 超时增加到 600 秒。

在可操作的情况下，浏览器向应用程序所在的 web 服务器发送请求，然后将包含状态代码(即 200)和结果(ML 应用程序的预测)的回答发送回用户。如果与服务器的连接超过 100 秒而没有发回响应，用户将收到状态代码 524 和空内容。

CloudFlare 仅在企业计划上提供超时的定制。

GIF via GIPHY

解决方案

以下步骤描述了该解决方案

浏览器发送带有参数的第一个请求来启动后端进程(在我们的例子中，它是一个 ML 应用程序后端)。

2.应用程序后端为这个请求生成一个 ID

3.应用程序后端使用给定的参数启动(预测)过程

4.应用后端立即将响应发送回浏览器(无需等待预测过程完成),该响应包括请求 ID 和指示该过程当前正在工作的状态 202

5.浏览器收到答案，等待 10 秒钟(这取决于您的预测过程生成最终结果所需的时间)，然后用相同的 ID 发出另一个请求，以检查预测过程是否完成(状态 200)

5.如果预测过程尚未完成，则重复步骤 4 和 5

就是这样！

您的浏览器将等待预测结果，并在准备就绪时获得后端答案。

GIF via GIPHY

摘要

与其他类型的应用程序相比，机器学习应用程序的响应时间通常较长。每当应答时间超过服务器连接超时限制时，就可以应用这种解决方案。

如果你有问题，欢迎在下面评论或通过邮箱或 Linkedin 提问。我会回答的。

如何修复特征偏差

原文：https://towardsdatascience.com/how-to-fix-feature-bias-9e47abccb942?source=collection_archive---------17-----------------------

公平和偏见

选择策略需要测试和权衡

由马特·阿特兹在 Unsplash 上拍摄的照片

特征偏差反映了人类判断中的测量误差或偏差，会对机器学习模型的公平性产生负面影响。这篇文章讨论了减轻这种偏见的五个潜在策略。最好的方法是上下文相关的。可解释性技术对于确保解决方案解决偏见并且不引入额外的不公平是必不可少的。这篇博客是我上一篇文章[1]的后续，那篇文章讨论了一种缓解方法的缺点。

当一个特征在不同的群体中有不同的含义时(如种族或性别类别)，就会出现特征偏差。这可能反映了测量误差、自我报告的差异或有偏见的人类判断。以下是说明该问题的一些示例场景:

男性比女性更不可能报告癌症家族史，即使它确实存在2；这种差异可能导致低估男性的风险。
在刑事累犯模型中使用以前的逮捕受到了批评，因为逮捕不能以统一的方式反映潜在的犯罪。例如，当发现犯罪或使用逮捕与警告存在种族差异时，模型可能高估某些群体的风险[3，4，5]。
低收入人群可能难以准确报告就业和收入，部分原因是当“收入”随时间变化或涉及多个来源时，很难简明地描述“收入”6。对于这个群体来说，这样的调查问题可能更模糊，因此更容易出错。

了解您的数据源至关重要。例如，如果收入特征直接取自工资单或纳税申报表数据，则特征偏差的风险可能较低，但如果是自我报告，则风险非常高。各组间缺失值或缺省值比率的差异也是危险信号。可解释性技术可以帮助识别潜在的风险特征[1，7]。

如果某个特性可能会有偏差，该如何处理？这篇文章包含了我对五种可能的缓解方法的想法。没有适合每种情况的完美技巧。减轻特征偏差可能需要尝试几种策略并彻底测试结果。

修改您的数据

减轻特征偏差的一个显而易见的策略是修复数据。在许多情况下，这可能很难或者不可能，但是值得考虑。与其他策略相比，数据修改降低了意外后果的风险。如果您不知道所有情况下的组成员，这也是唯一有效的技术。例如，在我处理过的数据中，通常只有一部分人的性别或种族/民族信息；可以使用这些案例来评估公平性，但是我们希望在缺少这些信息的情况下进行预测。

可以有许多方法来调整数据。有可能丢弃有偏见的特征或者用来自更可靠来源的信息来代替。如果您能够控制该功能，您也许能够实现直接修复。例如，如果偏见是由您管理的调查中的措辞引起的，那么更改调查并重新收集数据可能是最好的选择。如果特征偏差影响特征的极端值(例如，最高或最低收入的个人)，阈值或分桶可能是有用的。

如果特征偏差与组成员关系密切，也有可能重新调整值，例如在组内使用四分位数。在最近的一篇论文[5]中测试了一种重新标度方法。发现表现不佳。

在模型中包含敏感特性(概述)

我在之前的博文[1]中详细讨论了这个策略。简而言之，一些人认为，在非线性模型中包含一个敏感特征会导致模型自动调整不同组之间特征贡献的相对强度3。然而，我的文章认为，这种交互效应并不能保证会被纳入模型，当敏感特征对预测做出“类似主效应”的贡献时，可能会出现意想不到的后果。

当群体成员与模型中的其他预测因素相关，或与结果有因果关系的未测量特征相关时，纳入敏感特征尤其危险。这使得它特别有可能作为一个主要的影响，或作为一个与意想不到的功能互动。

有可能使用各种可解释性技术来确定敏感特性包含具有预期的效果[1]。对于一些数据集来说，这种方法的优势可能超过其风险。

使用不同的模型类型

对于敏感特征包含技术，不同的模型类型可以更好地捕捉成对的交互。在我之前的文章[1]中，我尝试了两种方法:随机森林和 XGBoost，但是报告了随机森林的结果，因为它们更容易解释。在这里，我将讨论 XGBoost。虽然这两种模型类型都显示了风险，但是对于我的测试场景，XGBoost 通常比 random forest 更好地减轻了特性偏差。

简而言之，我的方法包括在公共贷款数据集中随机分配男性或女性“性别”,然后只减少女性收入特征的值。虽然“性别”对实际违约率没有影响，但收入预测中的特征偏差导致了对女性贷款违约的过度预测。然后，我的帖子测试了将女性身份添加到特征中会纠正偏见的假设。详见上一篇帖子[1]；代码在 GitHub [8]上。

我检验了女性特征的加入是否使人口水平的模型结果更像实际违约率。对于随机森林，这种修正是微弱的[1]。对于 XGBoost，我看到了更大的共识:

实际违约率与随机森林(RF)和 XGBoost (XGB)模型(包括女性指标特征)的预测相比。

群体水平的差异在聚集 Shapley 值图中也很明显。这样的图可以识别出驱动组间差异的特征[7，9]；在这里，我展示了女性与男性违约率的差异有多大是由每个特征造成的。我使用这些图来比较具有和不具有敏感特征的模型:

随机 forest(左)和 XGBoost(右)模型中，女性的聚合 Shapley 值与男性参考值的比较(不含和含女性指标特征)。图片作者。

首先关注灰色条，很明显，如预期的那样，特征偏差通过收入特征影响模型预测。这两种模型类型受到的影响相似。

当女性指标被引入模型时，差异是明显的(图中的橙色柱)。这个特性对 XGBoost 的补偿效果比随机森林模型大得多。这与 XGBoost 更好的群体水平偏倚校正是一致的。

仅对于 XGBoost，包括女性身份在内的模型的收入栏变化显著，表明这一特性的影响更大。这在全球重要性方面也很明显；在没有女性特征的情况下，收入是排列重要性第三重要的特征，但当包括女性地位时，它成为最重要的特征。考虑到特征偏差降低了收入和违约状态之间的相关性，这种增加是可以预期的。具有偏差特征的模型可能低估了收入的影响。

我不是这些算法的专家，但是我认为不同之处在于 XGBoost 提供了定向搜索，而随机森林模型覆盖了更多的解决方案。如果我们有一个与另一个要素相关的强预测器，随机森林将对涉及强预测器的一些解决方案和使用弱预测器的一些解决方案进行采样。但是，如果已经找到涉及较强预测器的解决方案，XGBoost 将不会包含较弱的预测器，假设较弱的预测器没有独立的影响。因此，XGBoost 模型倾向于依赖一小组更强的特性。XGBoost 模型中的收入特征较少被相关信息稀释，我们看到了更强的影响。

所有这些都表明，与随机森林相比，当模型中包含敏感特征时，XGBoost 可以更好地调整特征偏差。然而，群体水平的反应并不能保证个案的公平性。我们可能正在以一种非特定的方式调整偏见，例如通过统一降低所有女性的风险，而不仅仅是那些有偏见的收入使她们处于风险之中。

在示例场景中，女性地位应该只通过与收入的互动来发挥作用。任何“主效应类似”的行为本质上都是用刻板印象抵消特征偏差，而不是纠正偏差。我们可以使用累积局部效应(ALE)图来评估“主效应样”和二阶效应的程度[10]。对于随机森林模型，ALE 图显示了可比较的主效应和二阶效应，表明正在发生某种程度的 s 非特异性调整[1]。

对于 XGBoost，ALE 图显示了比随机森林[1]更强的对收入和女性地位的整体影响。然而，单向和双向幅度也是可比较的，表明“主要效应相似”和交互作用贡献是相似的:

左图:XGBoost 模型中女性特征的单向 ALE 图。右图:模型的收入和女性地位的双向 ALE 图。作者图片

通过检查 XGBoost 模型中的树，我确认存在涉及女性特征但不涉及收入特征的决策路径。因此，陈规定型风险依然存在。

与随机森林模型不同，我看到了 XGBoost 模型包含虚假交互的证据。当弗里德曼的 H 统计[11]被用于筛选互动时，我发现女性地位与贷款金额之间有一个相对较大的值。ALE 图也表明发生了这种相互作用(未显示)。贷款金额与收入相关(收入无偏时 Spearman 系数为 0.44，收入有偏时为 0.36)。通过引入这种相互作用，XGBoost 模型可能会对女性的相关特征进行加权，以补偿不可靠的收入。但是，这是对特征偏差的间接校正，在某些情况下可能不准确。

当敏感特征被合并到 XGBoost 模型中时，诸如误报率和漏报率的公平性度量得到改善。例如，对于不包括女性状态的模型，女性的假阳性率比男性高近 31%,当加入该特征时，假阳性率下降到约-2%。对于有和没有敏感特征的模型，假阳性的原始比率是相似的。相反，对于随机森林测试，敏感特征的添加显著增加了总体假阳性率；尽管男性和女性之间的差距有所缩小，但两种性别的错误率都有所上升。

根据修正不足的程度以及对公平性和性能指标的适度或不存在的改进，我已经得出结论，对于我的随机森林示例来说，增加一个敏感特性可能并不比没有好[1]。然而，XGBoost 模型的总体水平度量的巨大改进可能证明这个解决方案是正确的，至少对于我的场景是这样。

总之，对于我的简单示例，与随机森林模型相比，使用 XGBoost 模型提高了敏感特征包含技术的有效性。然而，刻板印象的风险仍然存在，我看到了意想不到的互动。对于这个项目，我只测试了两种模型类型。可能其他类型会更好地结合成对的相互作用。

创建一个明确的交互术语

对数据集的一个可能的修改是创建一个由收入和女性地位产生的特征；对于所有男性，特征值为 0，对于女性，与年收入相同。我们希望用显式交互建模能够降低类似主效应贡献的风险。然而，在一个基于树的模型中，当分割点接近零时，交互特性可以很容易地作为一个指标，所以不清楚这种好处是否会出现。

当我在随机森林模型中测试交互功能时，与使用功能指示器相比，人口统计奇偶校验略有改善。预测违约的男女差距从 1.1%降至 0.8%；预测仍然是不准确的。在我看来，与使用雌性指标的模型相比，具有显式交互特征的随机森林模型的公平度量的行为稍好一些。假阳性率提高，男女差距缩小。假阴性总体上升，但变得更加平等。

对于 XGBoost，当使用交互项而不是女性指标时，在人口统计均等或公平指标方面没有有意义的改善。

在这种情况下，识别女性地位的潜在主要影响是困难的，因为我们没有一个方便的 ale 图来描述相互作用的“性别部分”。对树的检查提供了一些信息，因为决策路径不包含收入，但是在具有非常低的阈值的收入相互作用上的分裂很可能反映类似主效应的贡献或虚假的相互作用。

对于随机森林，不涉及收入但包含阈值小于 5000 美元的交互特征的决策路径在平均树中出现约 11 次。这是路径的 1.6%，或略低于使用女性指标的模型中出现的 2.4%[1]。模型的 XGBoost 版本也显示了这样的决策路径。

总的来说，收入-女性互动特征的纳入产生了一个在很大程度上类似于涉及女性地位指标的模型。对于随机森林的情况，交互解决方案的性能稍好，但是仍然存在严重的修正不足和意外后果的风险。此外，交互特征解决方案更难解释。

为每个组建立一个单独的模型

另一个建议的特征偏差解决方案是按组创建单独的模型3。我没有测试这个选项，但是我希望它能够很好地修复我的场景中的特性偏差。然而，这个修复在很大程度上取决于我如何设置我的例子。

首先，我在男性和女性群体中都有合理的计数。在真实数据中，一些组可能被严重低估，在这种情况下，对于低容量组，模型可能非常不同，或者表现不佳。数据中的表示级别对于其他解决方案也很重要，但是单独的模型特别容易受到影响。

像敏感特性合并技术一样，在比我的测试更复杂的场景中，单独的模型变得很危险。在我的例子中，女性地位仅通过收入特征起作用，因此我可以合理地预期，如果我构建两个模型，除了该特征之外，它们将非常相似。然而，如果女性地位与其他特征相关，或者与数据中不存在的因果关系相关，我们可能会得出不同群体的非常不同的模型，这可能很难证明。

最后的想法

我已经简要地讨论了减轻特征偏差的五种策略。我希望并想象还有其他我没有考虑到的技术(请在评论中分享)。

正如我在以前的文章[1]中所写的，对于功能偏见，没有“免费的午餐”。某些解决方案在某些环境下可能不可行，数据集特征和模型类型强烈影响有效性。对于一个测试场景，我展示了在 XGBoost 中包含敏感特性比在随机森林模型中更好的缓解。此外，我发现对于随机森林来说，引入交互项比敏感特性包含稍微好一点，但是对于 XGBoost 来说，这两种方法是等效的。机器学习算法的细节可能有助于提出解决方案，但在这一点上，我可能会依靠试验、错误和测试来选择技术。

令人欣慰的是，可解释性技术和公平性度量可以帮助回答如下问题:解决方案在多大程度上纠正了特征偏差？谁可能受益或面临风险？哪些功能会受到我们的更改的影响？这种技术比什么都不做好吗？这样，即使没有完美的解决方案，我们也可以做出明智的决定并预测负面后果。

参考

[1] V. Carey，特征偏见没有免费的午餐 (2021)，走向数据科学

2 M. Sieverding、A.L .阿波加斯特、S. Zintel 和 C. von Wagner，《自我报告的癌症家族史中的性别差异:综述和二次数据分析》 (2020)，癌症医学，9:7772–7780。

3 S. Corbett-Davies 和 S. Goel，《公平的度量和误度量:对公平机器学习的批判性评论》 (2018)，工作论文(arXiv.org)。

[4] Will Douglas Heaven，预测性警务算法是种族主义者。它们需要被拆除 (2020)，麻省理工学院技术评论

[5]Jennifer L . Skeem 和 Christopher Lowenkamp，使用算法解决预测累犯中固有的权衡问题 (2020)，行为科学&法律，即将出版

6 Nancy A. Mathiowetz、Charlie Brown 和 John Bound，第 6 章:低收入人口调查中的测量误差 (2002 年)，福利人口:数据收集和研究问题，由 Michele Ver Ploeg、Robert A. Moffitt 和 Constance F. Citro 编辑

[7]斯科特·伦德伯格(Scott Lundberg)，解释对数据科学公平的衡量 (2020)。

[8]诉凯里。GitHub 库，【https://github.com/vla6/Stereotyping_ROCDS】T2。

[9] V. Carey，公平指标不会把你从刻板印象中拯救出来 (2020)，走向数据科学。

[10] C. Molnar， 5.3 累积局部效应(ALE)图 (2018)，可解释的机器学习:使黑盒模型可解释的指南。

[11] C. Molnar， 5.4 特征交互 (2018)，可解释的机器学习:使黑盒模型可解释的指南。

如何挫败欺诈者破坏您的欺诈模型

原文：https://towardsdatascience.com/how-to-foil-the-fraudsters-messing-with-your-fraud-models-ac426481fd8b?source=collection_archive---------24-----------------------

作者图片

监控、减轻和预防欺诈的洗钱可观察性最佳实践

每年，欺诈给全球经济带来超过 5 万亿美元的损失。除了对个人受害者造成严重的个人损失之外，欺诈还会以收入和生产力损失以及声誉和客户关系受损的形式影响企业。人工智能从业者站在这场战斗的前线，构建和部署复杂的人工智能模型来检测欺诈行为，这些欺诈行为每年为组织节省了数十亿美元。

当然，这是一项具有挑战性的任务。从金融服务到医疗保健、保险、技术和旅游，欺诈的形式和攻击媒介多种多样。事实上，在当今世界，随着数据泄露在大型企业中变得越来越常见，被盗的凭据在暗网上出售，黑客利用勒索软件攻击从关键基础设施到本地连锁医院的所有目标。

为什么在欺诈检测中使用 ML 监控和可观察性？

欺诈持续存在的部分原因是在现实世界中识别欺诈的复杂性。不断演变的滥用模式和不平衡的数据集很容易挫败僵化的基于规则的系统。由于这种脆弱性，企业和政府很久以前就在异常检测、欺诈预防和其他反滥用投资领域采用了 ML 技术。然而，在不受监控的情况下，欺诈者甚至能够在几周内使幼稚的 ML 模型失效。

随着犯罪分子继续重新发明对抗性技术来利用生产中的模型，对异常情况的监控变得对业务和时间都很重要。通过检测基线和生产分布之间的偏差，并检查特征和群组表现，团队可以主动识别问题并重新训练模型，以最大限度地减少损失。

例如，一家信用卡公司在检查推断分布的差异时，可能会发现欺诈模型在生产中的假阳性远远多于验证基线，导致数百万次合法购买在销售点被拒绝，并使客户转而使用其他卡。或者，一个研究总体准确性下降的 ML 团队可能会发现，相对于在训练数据中占主导地位的大额购买，欺诈模型在预测小额交易方面不太好。不管是什么问题，监控可以帮助 ML 团队防止损失，维护来之不易的品牌忠诚度和市场份额。

监控和可观察性之所以重要，还有另一个原因:在金融和医疗保健等受到严格监管的行业，法律要求自动系统提出的任何索赔都要有 ML 模型的透明度。除了遵从性，组织还需要可解释性来反思和理解为什么一个模型做出了一个特定的预测，以确保更广泛的治理、公平和减少偏差。

欺诈特有的挑战

在深入研究解决生产中欺诈模型问题的最佳实践之前，了解处理欺诈数据的一些常见挑战以及可能出现的问题会有所帮助。

即使你觉得你已经很好地处理了数据本身，许多问题经常困扰着反滥用 ML 团队。以下是一些常见的挑战:

不平衡的数据集。一般来说，欺诈只占现实世界交易的一小部分。例如，在医疗保健行业，欺诈估计占总交易的 3%。由于在训练和验证阶段可获得的关于实际活动或感兴趣的观察(即医疗保健中的向上编码或伪造处方)的数据较少，如果没有适当的对策(如数据向上采样)，模型在现实世界中的表现可能会很差。
误导传统评估指标。如果他们的模型达到 99%的准确率，人们可能会认为它表现得非常好。但是，如果您的模型发现不到 1%的欺诈交易，这种误导性的指标实际上可能会掩盖您的模型仍然(在最坏的情况下)遗漏每个可能的欺诈交易的事实。由于大多数最大似然算法都是为了最大化精度和减少误差而优化的，所以当类间样本平衡且相等时，它们往往工作得最好。欺诈很少(如果有的话)出现这种情况，例如，欺诈性信用卡交易可能占所有交易的 0.5%，但每月仍会超过 1 亿美元。
功能受限/敏感。交易数据也可以被限制。在医疗保健或金融服务等行业，法规和合规性措施会导致敏感或个人身份信息(PII)从数据源中被篡改，以将用户从交易中抽象出来。例如，信用卡交易可能限于其最基本的细节(即交易 ID、日期/时间、终端、交易金额、位置等)。
并非所有的推论都同等重要。错误分类的欺诈交易(假阴性——对确实是欺诈的交易预测“不是欺诈”)通常比错误分类的合法交易(假阳性——对不是欺诈的交易预测欺诈)成本更高。在信用卡欺诈中，后者对客户来说是一种轻微的不便——他们通常可以通过短信确认信用卡收费是否合法——而前者是一种直接的经济损失。

作者图片(阿里泽·艾)

欺诈模型可观察性的最佳实践

一旦您设置了基准和监视器，手头的任务就变成了识别问题的根本原因，并随着威胁的实时发展而快速响应。虽然每个行业和组织的模型和指标都略有不同，但在确定哪些方面不如预期以及如何应对方面有一些共性。

重要指标

如上所述，在评估您的欺诈模型的性能时，准确性可能会产生误导。一些重要的观察指标包括:

回忆。您的模型检测到多少欺诈可能具有指导意义，提供了一个窗口来了解您的模型对现实世界威胁的影响。或者，您可以监控您的模型的假阴性率(召回的倒数)。
https://arize.com/glossary/false-negative/假阴性率。假阴性率衡量模型未能准确预测的欺诈(归类为非欺诈)。这是一个关键的性能指标，因为就直接财务损失而言，它对组织来说是最昂贵的，会导致退款和其他被盗资金。T4 估计，金融服务行业每年因欺诈造成的损失高达 1.5 万亿美元。
假阳性率 。假阳性率——或模型预测实际上并不欺诈的交易欺诈的比率——也很重要，因为给客户带来不便有其间接成本，无论是在医疗保健领域，患者的索赔被拒绝，还是在信用卡领域，客户延迟购买食品杂货。根据 Forrester 和 Adobe 的一项研究,重视客户体验的企业创造的客户终身价值是其他公司的 1.6 倍。

性能下降

识别导致性能下降的切片(或特性和值的组合)至关重要。通过过滤各种低性能特征/价值片段来深入分析您的模型的性能，有助于发现欺诈模式、欺诈者来源和隐藏的模型漏洞。

回到之前的信用卡欺诈的例子，业绩突然下降背后的切片可能是小额欺诈费用的激增(

In each case, having an ML observability platform that not only monitors your performance metrics but also proactively surfaces feature performance heatmaps can be the difference between patching costly model exploits in hours versus several days.

漂移的重要性

作为一名 ML 从业者，随着时间的推移，你可能会遇到漂移或分布变化。监测和排除漂移是每个从业者工具箱的重要组成部分(作为参考，这里有一个关于如何排除模型漂移的深度探讨，由达美航空的艾华撰写)。

特别是在欺诈中，策略总是在不断变化，因此考虑偏差以确保您的模型保持相关性非常重要。识别各种模型环境和版本之间的特征、模型和实际偏差有助于识别欺诈模式、数据质量问题和异常分布行为。

为了具体说明这一点，让我们回到信用卡的例子，在这个例子中，一家公司发现当地零售商的小额欺诈交易突然激增。通过检测数据形状的变化(在这种情况下，是交易规模的变化)，从业者可以积极主动，在新策略造成大范围损失之前将其消灭。这在像身份盗窃这样的金融欺诈中尤其重要，因为受害者甚至可能在几个月后才意识到并报告这一活动。

继续以信用卡欺诈为例，下面是一些异常分布变化可能意味着什么的指南，具体取决于它们在哪里发生以及现实世界的场景:

救命！我们看到…

预测漂移

可能的漂移相关性:欺诈预测的涌入和激增可能意味着您的模型受到攻击！你分类的欺诈比你预期在生产中看到的要多得多，但是(到目前为止)你的模型在捕捉这一点上做得很好。让我们希望它保持这种方式。

现实世界的场景:一个健康服务提供商的黑客攻击导致身份盗窃和信用卡号在黑暗网络上出售的激增。幸运的是，犯罪分子在他们的利用中不够新颖，以避免被现有的欺诈模型抓住。

实际漂移(无预测漂移)

可能的漂移相关性:欺诈实际值的大量涌入，而预测值的分布没有发生变化，这意味着欺诈者在你的模型中发现了漏洞，而且他们正在逍遥法外。尽快排除故障并修复您的模型，以避免任何更昂贵的退款。

真实世界场景:一个全球犯罪团伙利用的新战术预付借记卡将失业欺诈推至历史新高，导致根据 COVID 之前或更传统的信用卡数据训练的欺诈模型性能下降。

特征漂移

可能的漂移相关性:新的和/或现有特征值的涌入可能是季节变化(税收或假日季节)的指示，或者在最坏的情况下与欺诈利用相关；使用“随时间推移的漂移”堆叠在“随时间推移的性能指标”图表的顶部，验证是否存在任何相关性。

现实世界的情景:一个比往常更早的假日购物季开始了，购票量比往年更多。这可能是创纪录的零售需求和不断变化的消费者行为的迹象，也可能是一种新型欺诈利用(或两者兼有)。

结论

随着欺诈不断演变，甚至在当今时代以新的形式出现，损失的可能性很高，数据科学和 ML 团队制定一个可观察性战略来捕捉、监控和排查生产中的欺诈模型问题至关重要。通过采用一种既能被动监控关键指标又能主动测量偏差的方法，反滥用反洗钱团队可以提前发现潜在问题，腾出时间专注于最复杂的威胁。作为补充参考，这里的是ML 可观察性平台如何帮助客户处理欺诈监控。

联系我们

如果这个博客引起了你的注意，并且你渴望了解更多关于机器学习可观察性和模型监控，请查看我们其他的博客和 ML 监控上的资源！如果您有兴趣加入一个有趣的 rockstar 工程团队，帮助模型成功生产，请随时联系我们，并在此处找到我们的空缺职位！

如何使用开源软件预测 Shopify 商店的采购订单

原文：https://towardsdatascience.com/how-to-forecast-purchase-orders-for-shopify-stores-using-open-source-db82afec12fe?source=collection_archive---------36-----------------------

使用 MindsDB 中的开源集成机器学习和开源数据集成平台Airbyte预测 Shopify 店铺指标。

作者图片

随着数据量呈指数级增长，对于专注于电子商务的企业来说，尽可能快速高效地利用这些数据至关重要。机器学习代表着一种颠覆，它可以提高预测能力，增强人类对价格、分类和供应链优化、库存管理、交付管理和客户支持等用例的决策能力。在这个“如何做”指南中，我们将提供一步步的说明，向您展示如何使用开源数据集成平台 Airbyte 和运行在任何数据库之上的开源 AutoML 框架 MindsDB 简单而廉价地将机器学习集成到现有的 Shopify 帐户中。

我们的指南将由两部分组成:

使用 Airbyte 提取您的 Shopify 数据并将其加载到数据库中。在我们的例子中，我们将使用开源的 DB PostgreSQL，但是它也可以是您选择的不同的数据库。
使用 MindsDB 自动构建和训练用于预测采购订单的机器学习模型。

我们开始吧！

我们将假设您已经通过 Docker 设置了 Airbyte。如果没有，这里有一个链接，链接到一篇介绍如何做的文章。

步骤 1:用 Airbyte 将数据从 Shopify 复制到 PostgreSQL

a.设置 Airbyte Shopify 连接器

Airbyte 的 Shopify 连接器将允许我们获取你的 Shopify 数据，并将其存储在数据库或数据仓库中。对于本文，我们将把通过 Shopify 连接器获得的数据存储到 PostgreSQL 数据库中。

Airbyte Shopify connector 能够将放弃的结账、收藏、自定义收藏、客户、元字段、订单、产品和交易同步到您选择的目的地。

让我们从启动 Airbyte web 应用程序开始。首先，进入您克隆 Airbyte 库的目录，然后在您的 terminal:‍中运行以下代码

docker-排版

然后，在浏览器中访问 http://localhost:8000 以查看 Airbyte 仪表盘。

在源部分，点击仪表板右上角的 +新源按钮，添加一个新源。

在新屏幕中，输入信号源的名称——我们称之为shopify——source，,但你可以随意命名。然后，在源类型下拉列表中，选择 Shopify。

作者图片

选择 Shopify 连接器会提示 Airbyte 加载 Airbyte Shopify 连接器需要的配置参数。如果是第一次选择 Shopify 连接器，这可能需要一段时间。Airbyte 将在幕后从 Docker Hub 中提取 Shopify 连接器图像。

当它完成提取图像时，您将看到以下内容:

作者图片

让我们来看看 Shopify 连接器需要的参数:

商店:这将是您想要从中复制数据的 Shopify 上的商店名称。因此，如果你的店铺的网址是https://airbyte.myshopify.com，你的店铺名称将是 airbyte 。
start_date :这将是您希望 Airbyte 开始复制的日期，格式为 YYYY-MM-DD。
api_password :这将是你在 Shopify 仪表盘上创建的私人应用的密码。

商店名称和开始日期可以很容易地填写，但 api_password 要求你在 Shopify 上创建一个新的私人应用程序，以防你还没有。让我们在 Shopify 上创建一个私人应用程序，并获取设置 Airbyte Shopify 连接器所需的密码。

b.创建 Shopify 私人应用程序

要创建一个 Shopify 私人应用程序，请登录您的 Shopify 仪表盘，点击侧边栏菜单中的应用程序。

作者图片

然后，点击页面底部的管理私人应用链接。如果您之前没有启用私人应用程序，您将看到一个屏幕来启用它。点击启用私人应用开发按钮。

作者图片

您将被带到一个屏幕，接受 Shopify 关于私人应用程序开发使用的条款。如果您同意，请勾选复选框，然后再次点击启用私人应用程序开发。

启用私人应用程序开发后，您将被重定向到一个屏幕，在此您可以创建私人应用程序。

点击创建私人应用按钮开始。

在 App 详情部分，填写私人 App 名称和紧急开发者邮箱。

作者图片

转到管理 API 部分，并执行以下操作:

点击显示非活动管理 API 权限下拉菜单，并在列表中找到订单 API 。然后，从选择框中授予读取权限。
找到 Shopify 支付争议和 Shopify 支付支出，并批准这些支出。
最后，点击保存按钮保存您的新私人应用。

您将看到一个确认模式，只需点击创建应用按钮，确认创建私人应用。就是这样！现在我们只需要获取私有 app API 密码。

在同一页面上，向下滚动到管理 API 部分，复制您的私有应用 API 密码。

然后，转到 Airbyte web UI 仪表板，提供带有您刚才复制的密码的 Shopify 连接器配置表单。

在你停止设置 Shopify 的 Airbyte UI 中，粘贴你从 Shopify 复制的密码，然后点击设置源。

c.设置目的地

一旦您成功设置了源，Airbyte 将导航到目的屏幕。点击右上角的添加目的地按钮。在下拉列表中，点击 +添加新目的地。

Airbyte 将验证源，然后显示一个表单来输入目的地名称和类型。输入 shopify-destination 作为名称，选择 Postgres 作为目的地类型。为了设置我们的 Postgres 目的地，我们将通过 Docker 旋转一个 Postgres 容器。因此，在您的终端中运行以下命令:

docker run-RM-name shopify-d b-e POSTGRES _ PASSWORD = PASSWORD-v $ HOME/docker/volumes/POSTGRES:/var/lib/PostgreSQL/data-p 2000:5432-d POSTGRES

请注意，上面代码片段中的-v $ HOME/Docker/volumes/Postgres:/var/lib/PostgreSQL/data位对于持久存储数据非常重要，因为默认情况下，Postgres Docker 容器中的数据是短暂的，当容器被销毁时会丢失。您可以在本地机器上创建目录(因为我们假设它不存在)。在剥离 Docker 容器的命令之前，运行以下命令来创建它:

mkdir-p $ HOME/docker/volumes/postgres

验证容器正在运行。然后在 Airbyte 仪表板中填写登录凭证。

作者图片

在 Airbyte 成功设置目标之后，您将看到要复制到目标上的数据的模式，以及指定与源同步频率的下拉列表。在本教程中，我们选择了手动，因为我们想直接控制同步发生的时间。

然后点击设置连接按钮。

Airbyte 会将您导航到目标页面，您可以点击 Launch 按钮开始复制。要监控同步，您可以单击目的地名称来查看同步过程和状态。

作者图片

一旦 Airbyte 将数据复制到 Postgres 数据库，同步的状态将变为成功。要确认同步成功，您可以运行以下命令:

docker exec shopify-source psql-U postgres-c " SELECT COUNT(*)FROM public . transactions；"‍

上面应该返回事务表上所有记录的计数。

步骤 2:使用 MindsDB 预测采购订单

下一步是对我们导入数据库的商店数据进行预测分析。在此之前，我们需要首先安装 MindsDB。有几种安装方法，如文档中所述。我们的建议是始终使用 Docker ，因为它封装了运行 MindsDB 的所有依赖项。要下载最新的生产映像，请运行以下命令:

码头工人拉动 mindsdb/mindsdb

或者，如果您的机器上预装了 Python，您可以使用 pip 来安装最新的 MindsDB 版本。为此，创建一个新的虚拟环境并运行:

pip 安装 mindsdb

然后，启动服务器运行:

docker run-p 47334:47334 minds db/minds db

或者，如果您已经安装了 pip run:

python3 -m mindsdb‍

最后，MindsDB Studio 应该会在您的默认浏览器上自动启动http://127 . 0 . 0 . 1:47334/。

a.连接 MindsDB 和 PostgreSQL

有三种方法可以使用 MindsDB。第一种是通过名为 MindsDB Studio 的图形用户界面。第二种方法是使用 REST APIs。为了简化集成，您可以使用我们的 Python 或 JavaScript SDKs。第三种方法是通过执行 SQL 语句在数据库内部直接完成。

在本教程中，我们将通过 MindsDB Studio 解释一切，以便您可以直观地跟随。我们还将共享 SQL 查询，以防您想直接在数据库内部进行测试。

要从左侧导航菜单连接 MindsDB 和 PostgreSQL，请转到 integrations 并单击添加数据库按钮。在这里，您需要填写连接到 PostgreSQL 数据库的所有参数。

作者图片

连接到 PostgreSQL 所需的参数是:

支持的数据库:从下拉列表中选择 PostgreSQL。
集成名称:姑且称之为 ShopifyData。
数据库:保存 shopify 数据的数据库名称。
主机:PostgreSQL 主机名或 IP 地址。
端口:PostgreSQL 端口(默认为 5432)。
用户名:有权访问数据库的用户。
密码:上述用户的密码。

填写表格后，点击连接。您现在已经成功连接到 PostgreSQL。下一步是从您希望用于模型训练的数据中创建一个数据源。

b.订单数据

让我们来概括一下这些数据。在我们将数据导入 PostgreSQL 之后，Airbyte 在公共模式中创建了不同的表。如果您列出这些表，您将会注意到，在导入数据之前，Airbyte 已经创建了用于订单、订单 _ 退款、产品、交易、已放弃 _ 结账、和其他一些表。

作者图片

预测未来订单数量的重要数据在订单表中。让我们 从命令中选择吧；* 这样我们就可以看到订单列表。表格中有 30 多列，但我们将只关注:

processed_at:订单处理的时间。
供应商:例如，如果你卖鞋，供应商可能是耐克、阿迪达斯、万斯、匡威等。
财务 _ 状态:我们将只选择等待或已经支付的订单。

除了 Shopify 数据，您还可以使用许多其他选项来进行预测分析。为了保持展示简单，我们将重点关注上述 3 个参数，并训练一个模型来估计商店在下一阶段将收到的订单数量。

转到数据库集成仪表板，点击新建数据集。在弹出窗口中，您将能够选择数据来训练模型:。

作者图片

让我们概述一下我们的选择查询:

SELECT processed _ at::date AS order _ day，COUNT(*) AS orders，(unnest(ARRAY(SELECT jsonb _ ARRAY _ elements(line _ items)-> > ' vendor '))FROM orders WHERE financial _ status IN(' pending '，' payed ')GROUP BY vendor，order _ day；

该查询将选择处理订单的时间，并将其转换为 YY:MM:DD 格式(不包括当天的时间，因为我们将按每天的频率进行预测)。然后，从包含 JSON 格式的产品信息的 line_items 列中选择供应商。

最后，合计每个供应商每天的订单数量。

点击 CREATE ，MindsDB 将创建一个名为 ShopifyOrders 的新数据源。

作者图片

如果预览数据，您将看到按供应商分组的每日订单数。上面的例子显示了鞋子和玩具商店的订单。它将过去 5 年不同供应商的每日订单分组，如耐克、VANS、阿迪达斯、乐高、美泰等。

我们现在有连接到 MindsDB 的数据。接下来的步骤是:

执行数据分析
训练一个 ML 模型
通过查询模型来预测未来订单的数量

c.数据分析

在数据集仪表板中，点击质量按钮，以便 MindsDB 可以开始其自动化数据分析程序。在后台，它将迭代每个数据记录，如果数据中有潜在的偏差或异常值，将显示警告。如果您单击某些列，它将显示特定列的附加信息，如数据类型、是否有任何缺失值、不同值的数量，如果有潜在偏差，它将显示更多信息。

作者图片

通过执行数据分析，您将获得有关数据的更多信息，并决定是否信任 MindsDB 显示的警告以对其采取行动(请记住，好的数据集对于好的 ML 模型至关重要)，或者您可以忽略它们并继续进行模型训练。

d.模特培训

要训练新模型，点击左侧导航栏中的预测器选项卡，然后点击训练新模型按钮。在 pup 表单中，您需要输入所有必需的信息，以便 MindsDB 可以开始训练时间序列预测模型:

FROM: 从中选择数据的数据源。在这个例子中，ShopifyOrders。
预测器名称:新模型的名称，例如 shopify_orders。
只选择要预测的列:我们要预测的目标变量。在本例中，订单数量被计算。
选择要为训练移除的列:我们要从模型训练中排除的列。您可以将此字段留空，因为我们训练的模型只有 3 列。
样本误差范围:计算[0.0–1.0]范围内的误差范围。将其留空，因此将使用默认值 0.01。
停止训练后:用于测试目的，加速模型训练。除非您有时间限制，否则请留空。
使用 GPU: 在 GPU 或 CPU 上训练模型。如果您有 GPU，请选择此复选框以获得训练和查询阶段的加速。
这是一个时间序列预测问题吗？:在复选框中选择是。
Order by: 数据排序所基于的列。选择已处理 _at。
分组依据:对数据中的实体进行分组所依据的列。我们将按供应商分组，有效地分析每一个不同的玩具和鞋子供应商，以产生准确的预测。根据维度数据的分组方式，这可能会产生从几个到几百个(或者更多！)MindsDB 预测器将学习预测的时间序列。
未来预测数:使用默认值 1。这意味着我们的模型将被训练来预测第二天应该到来的订单量。
使用先前目标:使用目标列的先前值作为模型的时序特定部分的附加信息。保持选中状态。
回顾窗口:进行预测时要回顾的行数。将其设置为 10，以便在预测时考虑最近 10 天的订单量。

作者图片

要开始培训，点击培训。

或者，您可以通过运行以下查询，直接在数据库中自动训练模型:

将值(' shopify_orders '，' orders '，' SELECT processed _ at::date AS order _ day，COUNT(*) AS orders，(unnest(ARRAY(SELECT jsonb _ ARRAY _ elements(line _ items)-> > " vendor)))作为订单的供应商，其中 financial_status in ("pending "，" payed ")group by vendor，order _ day；');

要获得更多关于插入查询的信息，请访问 MindsDBs PostgreSQL docs 。

MindsDB 将立即启动自动化机器学习管道，推断每一列的数据类型，为每一列实例化一个编码器，以获得数据的信息性中间表示，然后使用它来训练一个基于递归神经网络和梯度助推器混合的预测模型。最后，它将执行模型分析，以提供关于您可以预期预测有多好的见解。

当该程序完成时，状态将变为完成。接下来，单击预览按钮。模型预览面板提供了与已训练模型相关的细节。第一部分展示了模型的准确性以及 MindsDB 如何进行数据集分割。

作者图片

您可以看到，shopify_orders 模型的预测准确率约为 74%，这意味着在 74%的情况下，订单的真实数量落在保留验证数据集的预测范围内。

下一节显示了列的重要性，MindsDB 从 0 到 10 对这些列进行评级，0 表示最不重要，10 表示最重要，以便做出正确的预测。给定我们使用的设置，我们的时间序列预测器需要所有三列来训练，因此这部分分析不适用于该预测器。

最后一部分显示了一个混淆矩阵，如果您将鼠标悬停在该矩阵上，您将看到模型正确预测订单数量的时间百分比，或者模型错误分类订单数量的时间百分比。一个完美的预测者会显示一条又细又直的对角线。在这种情况下，对角线仍然是结构良好的，这加强了报告的 74%的准确性。

作者图片

e.预测订单数量

模型训练成功。怎么用它来预测订单数量呢？从左侧导航选项卡中点击查询选项，然后点击新建查询按钮。

假设我们要预测" 商店下周五将获得多少个逆向订单？ 。”

在下拉列表中，选择供应商(例如 Converse)和日期(例如 2021 年 6 月 18 日),我们希望预测该日期的订单数量。

作者图片

然后，点击运行查询，不到一秒钟 MindsDB 就会返回预测值。

作者图片

如果您想直接从数据库运行中获得预测:

SELECT orders AS predicted，orders_confidence AS confidence，orders _ explain AS info FROM mindsdb . shopify _ orders where " vendor " = ' Converse ' AND " order _ day " = ' 2021–06–18 '；‍

在这个例子中，对于 2002 年 6 月 18 日星期五的 Converse 产品，MindsDB 认为商店将获得大约 57 个订单，最小订单为 32 个，最大订单为 78 个。此外，MindsDB 有 74%的把握这将是正确的订单数量。用户可以以修改置信度为代价进一步调整预测区域的宽度:一对更紧密的边界意味着预测的置信度更低，反之亦然。

另一件要注意的事情是，当您提供更多的历史背景时，查询会更准确。

包扎

我们已经展示了使用 Airbyte 在数据库中提取和加载数据是多么容易，然后利用 MindsDB 执行预测分析以推动更好的基于业务的决策。如需更多信息和示例，请查看关于 Airbyte 、 MindsDB 的文档，并在http://cloud.mindsdb.com 注册一个免费的 MindsDB 云帐户。

最初发布于https://airbyte . io。

如何使用 BigQuery ML 预测旅行持续时间

原文：https://towardsdatascience.com/how-to-forecast-trip-duration-using-bigquery-ml-ef2bf4a52a47?source=collection_archive---------18-----------------------

谷歌云平台

使用 GCP 进行 ML 回归项目

照片由卢西恩·阿利克夏从 Unsplash 拍摄

本教程将通过 Google Cloud 中的挑战实验室 Qwiklab: 用 BigQuery ML: Challenge Lab 创建 ML 模型。

我们将使用谷歌云公共数据集上共享的真实数据集: austin_bikeshare 来帮助公共自行车共享系统选择新的自行车型号。本实验旨在预测不同自行车方案的平均出行持续时间。使用所选特征的不同假设提供了两种方案。你会比较哪一个性能更好。

第一步:创建一个数据集来存储你的机器学习模型

使用分配的凭证登录 Google Cloud Platform 后，打开 BigQuery 并在您的项目中创建一个数据集。

在 BigQuery 中创建数据集(图片由作者提供)

步骤 2:创建预测 BigQuery 机器学习模型

我们将在第一个模型中纳入起始站名称、旅行开始的时间、旅行的工作日和起始站的地址，并仅使用 2018 年的数据来训练第一个模型。

模型 1 培训:

# Create a Linear regression modelCREATE or REPLACE MODEL austin_bikeshare.bikeshare_modelOPTIONS(model_type='linear_reg', labels=['duration_minutes']) AS# Data preprocessing and feature selectionSELECTstart_station_name,EXTRACT(HOUR FROM start_time) AS hourofstart,EXTRACT(DAYOFWEEK FROM start_time) AS day_of_week,address AS location,duration_minutesFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips` AS trips# Join to get the address of the start stationJOIN`bigquery-public-data.austin_bikeshare.bikeshare_stations` AS stationsONtrips.start_station_name=stations.nameWHEREEXTRACT(YEAR FROM start_time) = 2018AND duration_minutes > 0

第三步:创建第二个机器学习模型

第二种型号的功能相对简单。我们将在第二个模型中纳入起始站名称、旅行开始的时间和自行车共享订户类型，并仅使用 2018 年的数据来训练该模型。

模式 2 培训:

# Create a Linear regression modelCREATE or REPLACE MODEL austin_bikeshare.bikeshare_model2OPTIONS(model_type='linear_reg', labels=['duration_minutes']) AS# Data preprocessing and feature selectionSELECTstart_station_name,subscriber_type,EXTRACT(HOUR FROM start_time) AS hourofstart,duration_minutesFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`WHEREEXTRACT(YEAR FROM start_time) = 2018AND duration_minutes > 0

步骤 4:评估两个机器学习模型

平均绝对误差和均方根误差都用于评估。

模型 1 评估:

# Choose evaluation metricsSELECTSQRT(mean_squared_error) AS rmse,mean_absolute_error AS maeFROMML.EVALUATE(MODEL austin_bikeshare.bikeshare_model,(# Prepare the testing dataset with the same features as the training set using for 2019SELECTstart_station_name,EXTRACT(HOUR FROM start_time) AS hourofstart,EXTRACT(DAYOFWEEK FROM start_time) AS day_of_week,address AS location,duration_minutesFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips` AS tripsJOIN`bigquery-public-data.austin_bikeshare.bikeshare_stations` AS stationsONtrips.start_station_name=stations.nameWHEREEXTRACT(YEAR FROM start_time) = 2019))

对第一个模型的评估(图片由作者提供)

模型 2 评估:

# Choose evaluation metricsSELECTSQRT(mean_squared_error) AS rmse,mean_absolute_error AS maeFROMML.EVALUATE(MODEL austin_bikeshare.bikeshare_model2,(# Prepare the testing dataset with the same features as the training set using for 2019SELECTstart_station_name,subscriber_type,EXTRACT(HOUR FROM start_time) AS hourofstart,duration_minutes# No need to join anther table since all the features needed are in one tableFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`WHEREEXTRACT(YEAR FROM start_time) = 2019))

对第二个模型的评估(图片由作者提供)

通过比较，我们可以发现第一种模型更准确。

第五步:使用第二个模型预测平均出行持续时间

我们将使用第二个模型来预测 2019 年从最繁忙的自行车共享站出发的平均行程长度，其中订户类型为Single Trip。

#Create a table containing predicted trip duration for single trip subscribers at the busiet bike sharing station in 2019WITH predicted AS (SELECT*FROMml.PREDICT(MODEL `austin_bikeshare.bikeshare_model2`,(# Find the busiest bike sharing station in 2019WITH params AS (SELECTCOUNT(*) AS counts,start_station_name AS start,FROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`WHEREEXTRACT(YEAR FROM start_time) = 2019GROUP BY start_station_nameORDER BY counts DESCLIMIT 1)# Prepare the features for the modelSELECTstart_station_name,subscriber_type,EXTRACT(HOUR FROM start_time) AS hourofstart,duration_minutesFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`, paramsWHEREstart_station_name = params.startAND subscriber_type = 'Single Trip')))# Get the average of the predicted duration.SELECT AVG(predicted_duration_minutes) AS   predicted_average_trip_duration, start_station_name, subscriber_typeFROM predictedGROUP BY start_station_name, subscriber_type

预测脚本(图片由作者提供)

预计平均出行时长(图片由作者提供)

如果上面的脚本没有通过评分系统，您可以将它分成两部分:一部分查找最繁忙的自行车共享站，另一部分使用站名进行预测，如下所示:

# Find the busiest station
SELECTCOUNT(*) AS counts,start_station_name,FROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`WHEREEXTRACT(YEAR FROM start_time) = 2019GROUP BY start_station_nameORDER BY counts DESC

# Predict
SELECT AVG(predicted_duration_minutes) AS predicted_average_trip_durationFROM ML.predict(MODEL `austin_bikeshare.bikeshare_model2`, (SELECTstart_station_name,EXTRACT(HOUR FROM start_time) AS hourofstart,subscriber_type,duration_minutesFROM`bigquery-public-data.austin_bikeshare.bikeshare_trips`WHEREEXTRACT(YEAR FROM start_time) = 2019AND subscriber_type = 'Single Trip'AND start_station_name = '21st & Speedway @PCL'))

祝贺！

如果您完成了之前的实验，您将通过挑战实验室，并获得来自 Google Cloud 的Create ML Models with big query ML徽章，这些实验有一步一步的说明。

我希望你喜欢这次旅行。欢迎在 Linkedin 上发表评论和我联系。

如何将产品目标框定为机器学习问题

原文：https://towardsdatascience.com/how-to-frame-a-product-goal-as-a-machine-learning-problem-a3c55aeb75b2?source=collection_archive---------27-----------------------

降低处理机器学习项目的风险

由 Unsplash 上罗兰兹·齐尔文斯基拍摄的照片

有些事情最好通过经验来教。机器学习中的许多任务就是如此。机器学习允许我们从大量数据中学习，并使用数学公式通过优化给定目标来解决问题。相比之下，传统编程期望程序员编写一步一步的指令来描述如何解决问题。

“ML 对于构建我们无法定义启发式解决方案的系统特别有用”

— Emmanuel Ameisen，构建机器学习驱动的应用。第三页。

尽管它很强大，但机器学习的一个主要警告是它引入了一定程度的不确定性，这在基于规则的系统中是预料不到的。这是因为机器学习是基于模式识别的。因此，重要的是要认识到产品的哪些方面可以从 ML 中获益，然后考虑如何制定一个学习目标来降低用户体验不佳的风险。

确定产品的可行性

机器学习能够解决一系列问题，但区分哪些问题是可解决的是极其困难的。由于我们无法预先确定一个 ML 项目是否会成功，我们最好的办法是降低处理这样一个项目的风险，最重要的是，从产品目标开始。

一旦我们有了产品目标，下一个目标就是决定解决它的最佳方式。我以前出错的地方是，我会立即下定决心使用机器学习，因为我想建立有趣的方法。更好的方法是考虑解决问题的所有可用选项，不管是否需要 ML。

机器学习并不总是需要的！

如果我们决定使用 ML 方法，我们必须决定它们是否适合产品。《T4 构建机器学习驱动的应用》一书提出了两个步骤:

(1) 以 ML 范式构建产品目标——对于一个目标，可能有多种表述。
(2) 评估 ML 可行性——考虑所有潜在的框架，从最简单的开始。

这个过程要求我们检查问题的数据和模型方面。

设计产品框架

在这个场景中，我将假设我们想要构建一个写作助手。我们的写作助手要能接受作家写的中等文章，并加以改进，使之写得更好。考虑到这个公式，我们必须首先解决“更好”这个词的含义。我们可以通过问更多的问题来做到这一点，直到我们对我们的写作助手的产品目标有一个清晰的定义。

这里有一个更清晰的公式的例子:

Medium 是一个社交媒体平台，供作家分享见解，读者向作家学习见解。然而，一些作家因为他们写的文章而疯狂传播，即使没有大量的追随者，其中一个原因是基于文章写得有多好。这对于那些有着非常有用的见解但不擅长通过写作表达自己的作家来说是不幸的。因此，我们的目标是建立一个写作助手，帮助作者写出更好的文章。

成为算法

在我们实现机器学习算法之前，尝试手动解决问题没有坏处。这样，我们可以了解你的学习算法必须成功解决什么样的问题。在我们的场景中，我们必须考虑如何提高文章的可读性，以及传播的几率。

一种方法可能涉及研究，以确定一些属性，可以用来帮助媒体博客写得更清楚。这些特征的例子有:

散文的简单性:散文意味着语言遵循日常语言的自然模式。因此，任何遵循基本语法结构的作品都被称为散文。我们可以利用这个特性来建立一个关于适当的句子和单词长度的标准，使我们能够在需要的地方提出修改建议。
语气:语气是指作者对读者的态度和信息的主题。通过评估语言，我们可以衡量文章的极性，并确定一篇文章是否触及读者的情感纽带，因为这些文章往往在某些上下文中表现良好。
结构特征:结构描述了文本在页面上是如何排列的，以及所有部分是如何组合在一起形成文章的。作家通常喜欢有意识地组织他们的文章，因为这对读者有影响。

注意:我们也想和病毒媒体的作者谈谈，了解一些他们用来让他们的作品病毒式传播的写作技巧。

通过识别和生成有用的特性，我们能够构建一个简单的解决方案，依靠这些特性向我们的读者提供推荐。报道这个过程可能会很无聊，因为它不涉及机器学习，但它对于提出一个快速基线来衡量其他实验是至关重要的。

基于我们所学到的

有了我们的初步特征，我们可以利用它们从一篇文章中学习一种风格模式。为了执行这一步，我们需要建立一个数据集，提取我们描述的特征，然后训练一个分类器来区分好的和坏的例子。

在建立分类器来分离文本之后，我们想要分析高度可预测的特征，因为这些是我们将用作对我们的系统的推荐改变的特征。

最后的想法

机器学习并不总是所有产品都需要的。在转向 ML 解决方案之前，建立简单的解决方案来测试产品的可行性并评估是否需要机器学习是很重要的。如果确实需要 ML，从一个简单的解决方案开始是一个好主意，可以为您提供一个基线和反馈，以便进一步发展。

感谢阅读！

如果你喜欢这篇文章，请通过订阅我的每周简讯与我联系。不要错过我写的关于人工智能、数据科学和自由职业的帖子。

** **

如何在 GPU 上生成随机数向量

原文：https://towardsdatascience.com/how-to-generate-a-vector-of-random-numbers-on-a-gpu-a37230f887a6?source=collection_archive---------29-----------------------

蒂莫西·戴克斯在 Unsplash 拍摄的照片

解决老问题的现代硬件

随机数是数据科学家生活中必不可少的一部分。例如，如果你需要初始化神经网络的矩阵，使用零模型执行数据分析，或者甚至在运行蒙特卡罗模拟时，你必须生成它们。

想象一下，你必须生成许多独立的随机数序列，比方说，一组蒙特卡罗马尔可夫链 (MCMC)。在这类问题中，给定一个起点和一个规则来产生状态 n+1 给定状态 n 就有可能对给定分布的许多状态进行采样。也可以使用 MCMC 来执行自然语言处理【1】。

在多个独立对象上执行相同任务的理想硬件是图形处理单元。事实上，GPU 可以被编程为运行多个独立的线程，这些线程同时执行相同的操作。

在这里，我将描述一个简单的例子，如何使用苹果金属框架生成随机数序列，以在快速 GPU 硬件上运行操作。

随机数的向量

这里的思路是生成一个独立随机数字均匀分布的向量。举例来说，每个数字可以代表马尔可夫链末端的一个状态。

该代码由三部分组成:

准备好初始状态(种子)的向量
这个向量被传递给 GPU 和每个线程运行一个链并输出一个单一的数字(状态)
状态从 GPU复制到 CPU，然后再复制到磁盘上的文件中，以便稍后进行分析。

在 GPU 上运行

我选择利用 Apple Metal Framework 来执行上述操作，并在 GPU 上执行操作。整个代码可以很容易地翻译成其他语言，如 OpenCL 或 CUDA 。

**https://developer.apple.com/metal/

为了对 Metal 上的数据执行流水线，我们需要创建一个命令缓冲区，将命令写入其中，并将缓冲区提交给命令队列。Metal 将发送命令给 GPU 执行。

在本例中，我们将使用 ComputeCommandBuffer ，因为我们的任务是计算任务，而不是图形任务。

我们用 C++编写的包装了金属代码的程序将在 Mac 内置的 GPU 上高效运行。

计算期间的 GPU 使用统计。图片作者。

算法

(伪)随机数的生成从一个名为种子的整数值开始。然后，有种不同的方法产生后续随机数；Mersenne Twister 和 xorshift 就是两个例子。

梅森扭结算法

梅森扭结器是一个伪随机数发生器，也是目前使用最广泛的通用型。它是由松本诚和西村拓治在 1997 年开发的，它是专门为纠正老式发电机的大部分缺陷而设计的。

最常用的梅森扭转算法是基于梅森素数 2 ⁹⁹ ⁷-1.它的标准实现， MT19937 ，使用 32 位字长。

在这个例子中，我将使用 Mersenne Twister 的金属实现。

马萨格里亚的 xorshift

另一个容易实现的生成随机数的算法是 xorshift 3。这是一种非常快速的发电机。它的创造者还建议对 xorwow 生成器进行改进，其中 xorshift 生成器的输出添加了一个 Weyl 序列。xorwow 生成器是 nVidia CUDA 图形处理单元应用编程接口的 CURAND 库中的默认生成器。

xorshift 的 GPU 实现如下。

uint rand_xorshift(uint rng_state){    
    rng_state ^= (rng_state << 13);
    rng_state ^= (rng_state >> 17);    
    rng_state ^= (rng_state << 5);    
    return rng_state;
}

这可以方便地移植到其他 GPU 编程语言，如 OpenCL 。

示例和运行

在示例中，我将描述线程应该生成从边界为 0 和 1000 的均匀分布中抽取的随机数。

下面显示的 Metal 代码显示了在每个 GPU 线程上生成 100 个随机数并将最后一个存储到一个数组(vOut)的过程示例，该数组稍后将由 CPU 代码访问。

每个线程都有一个由主 CPU 线程通过 vIn 数组传递的种子。然后每个线程创建自己的生成器

#include <metal_stdlib>#include “mersenne.metal”
using namespace metal;
kernel void storyMersenne(
const device uint *vIn [[ buffer(0) ]],
device int *vOut [[ buffer(1) ]],
uint id[[ thread_position_in_grid ]]){mt19937 generator;generator(vIn[id]);uint r;
for (uint l = 0; l < 100; l++) r = generator.rand();vOut[id] = r;}

当 GPU 的每个线程都生成了随机数时，就可以查看它们的分布，并验证它们是否如预期的那样均匀分布。

图中显示是的，它们分布均匀。

如果有多次运行呢

可以用来评估随机数生成器的另一个标准是，生成的随机数序列很有可能互不相同。

我测试了这个事实，生成了多个随机数序列，并研究了它们之间的相关性。该图显示不同运行中产生的点实际上不相关。

不同运行的相关性。图片作者。

结论

在许多应用中，拥有一个好的随机数来源是必要的。快速生成它们将是一个优势。

当您必须进行涉及随机数序列的计算或马尔可夫链蒙特卡罗时，只要它们是独立的，并且知道 GPU 硬件已经过优化可以并行执行许多操作，那么使用 Metal 或 OpenCL 中实现的算法来生成它们可能是一个不错的选择。

一个简单的例子表明，利用 MacBook GPU 可以轻松生成均匀分布且不相关的随机数。

参考

[1] Gerlach，m .，Pexioto T.P .，Altmann E.G. 主题模型的网络方法。 (2018)

2杰森·r·布莱文斯 C++梅森扭扭器包装器类 (2006)。

3乔治·马萨利亚。随机数发生器。(2003)现代应用统计方法杂志。**

如何用 Python 生成自动化的 PDF 文档

原文：https://towardsdatascience.com/how-to-generate-automated-pdf-documents-with-python-55981f4d9e3?source=collection_archive---------2-----------------------

利用自动化轻松创建令人眼花缭乱的 PDF 文档

在 Unsplash 上由 Austin Distel 拍摄的照片

你上一次处理 PDF 文档是什么时候？你可能不需要回顾太久就能找到这个问题的答案。我们每天都要处理大量的文档，其中绝大多数都是 PDF 文档。公平地说，这些文件中有很多都是重复的，而且编写起来非常痛苦。是时候考虑利用 Python 的自动化功能来机械化繁琐的工作了，这样我们就可以将宝贵的时间重新分配给生活中更紧迫的任务。

请注意，完全没有必要精通技术，我们在这里要做的事情应该是足够琐碎的，我们内心不喜欢的门外汉可以在短时间内解决。阅读完本教程后，你将学习如何自动生成 PDF 文档，将你自己的数据、图表和图像打包在一起，呈现出令人眼花缭乱的外观和结构。

具体来说，在本教程中，我们将自动执行以下操作:

创建 PDF 文档
插入图像
插入文本和数字
可视化数据

创建 PDF 文档

在本教程中，我们将使用 FPDF ，它是 Python 中用来生成 PDF 的最通用、最直观的包之一。在我们继续下一步之前，启动 Anaconda 提示符或您选择的任何其他 Python IDE，并安装 FPDF:

pip install FPDF

然后导入我们将用来呈现文档的库栈:

import numpy as np
import pandas as pd
from fpdf import FPDF
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter

随后，继续创建 PDF 文档的第一页，并设置字体的大小和颜色:

pdf = FPDF(orientation = 'P', unit = 'mm', format = 'A4')
pdf.add_page()
pdf.set_font('helvetica', 'bold', 10)
pdf.set_text_color(255, 255, 255)

然而，如果你需要不同的字体，你可以随时改变字体。

插入图像

下一个合乎逻辑的步骤是给我们的文档一个背景图像，为页面的其余部分设置结构。对于本教程，我使用 Microsoft PowerPoint 来呈现我的背景图像的格式。我只是使用文本框和其他视觉效果来创建所需的格式，完成后，我通过选择所有元素并按 Ctrl-G 将所有内容分组在一起。最后，我通过右键单击它们并选择“另存为图片”将分组的元素保存为 PNG 图像。

背景图像。图片作者。

正如您在上面看到的，背景图像为我们的页面设置了结构，并为稍后将生成的图表、图形、文本和数字留出了空间。用于生成该图像的特定 PowerPoint 文件可以从这里下载。

随后将背景图像插入到您的 PDF 文档中，并使用以下内容配置其位置:

pdf.image('C:/Users/.../image.png', x = 0, y = 0, w = 210, h = 297)

请注意，您可以通过扩展上面显示的方法插入任意数量的图像。

插入文本和数字

添加文本和数字有两种方法。我们可以指定要放置文本的确切位置:

pdf.text(x, y, txt)

或者，我们可以创建一个单元格，然后将文本放入其中。这种方法更适合于对齐或居中可变或动态文本:

pdf.set_xy(x, y)
pdf.cell(w, h, txt, border, align, fill)

请注意，在上述方法中:

“x”和“y”是指我们页面上的指定位置
“w”和“h”指的是我们细胞的大小
“txt”是要显示的字符串或数字
“边框”表示是否必须在单元格周围画一条线(0:否，1:是或 L:左，T:上，R:右，B:下)
“对齐”表示文本的对齐方式(左:左，中:右)
“填充”指示单元格背景是否应该填充(真，假)。

可视化数据

在这一部分中，我们将创建一个条形图，显示我们的贷方、借方和余额值随时间变化的时间序列数据集。为此，我们将使用 Matplotlib 来呈现我们的图形，如下所示:

在上面的代码片段中，credit、debit 和 balance 是二维列表，分别包含日期和交易金额的值。一旦生成并保存了图表，就可以使用前面几节中介绍的方法将它插入到我们的 PDF 文档中。

类似地，我们可以用下面的代码片段生成圆环图:

完成后，您可以通过生成自动化的 PDF 文档来完成它:

pdf.output('Automated PDF Report.pdf')

结论

这就是你自己的自动生成的 PDF 报告！现在，您已经学会了如何创建 PDF 文档，将文本和图像插入其中，还学会了如何生成和嵌入图表和图形。但是您决不仅限于此，事实上，您还可以扩展这些技术，使之包括多页文档的其他视觉效果。天空才是真正的极限。

图片作者。

如果您想了解更多关于数据可视化和 Python 的知识，请随时查看以下(附属链接)课程:

使用 Streamlit 开发 Web 应用程序:

https://www.amazon.com/Web-Application-Development-Streamlit-Applications/dp/1484281101?&linkCode=ll1&tag=mkhorasani09-20&linkId=a0cb2bc17df598006fd9029c58792a6b&language=en_US&ref_=as_li_ss_tl

使用 Python 实现数据可视化:

https://www.coursera.org/learn/python-for-data-visualization?irclickid=xgMQ4KWb%3AxyIWO7Uo7Vva0OcUkGQgW2aEwvr1c0&irgwc=1&utm_medium=partners&utm_source=impact&utm_campaign=3308031&utm_content=b2c

面向所有人的 Python 专业化:

https://www.coursera.org/specializations/python?irclickid=xgMQ4KWb%3AxyIWO7Uo7Vva0OcUkGQgW16Ewvr1c0&irgwc=1&utm_medium=partners&utm_source=impact&utm_campaign=3308031&utm_content=b2c

新到中？您可以在此订阅和解锁无限文章。

人工智能的源代码数据集——为什么和如何

原文：https://towardsdatascience.com/how-to-generate-code-dataset-for-machine-learning-applications-fbc1b888cc84?source=collection_archive---------32-----------------------

要避免的陷阱

丹尼尔·怀尔德曼的照片来自自由影像

为什么编码数据集

代码 AI 最近成为一个普遍的话题；无论是对一个代码主题进行分类，发现其中的漏洞，对其进行总结甚至是根据前面的令牌猜测下一个令牌。使它成为可能的是最近 NLP 的进步和丰富多样的源代码数据集的可用性提升。拥有像 Github、Gitlab 和 Bitbucket 这样的服务，生成源代码数据集可能被视为一项微不足道的任务——“抓取 Github 并开始训练模型”。事实上，这种简单性涵盖了一个相当复杂的领域，需要避免许多陷阱。下面详细解释。

案例研究——话题预测

让我们假设我们的任务是建立一个模型来预测一个源代码是否与服务器相关。有许多方法可以处理它，从手动收集特性(比如文件类型，它是测试代码吗，它的导入是什么，等等..)到深度神经网络，它将自动生成一组特征来查看。无论我们走哪条路，第一步都是收集相关的数据集。一个普通(幼稚！！)建议的计划将是使用一些相关的搜索标准(如 Node.js repositories)从公共代码托管服务(如 Github)中随机抽取存储库，并根据相关术语的存在对其进行标记(“服务器相关”与“不相关”)。沿着这条路走下去，我们很可能会发现我们的模型过度适应数据集的浅层特征。什么会出错？

为什么随机抽样代码不是微不足道的

我们最初计划的主要问题是源代码数据集固有的隐含偏差，这会影响不同语言和代码类型的模型泛化。Github 是最常见的代码托管服务之一，据报道它遭遇了语言的长尾；很少是超级常见的(像 Javascript 和 Java)，而大多数(像 C)是非常罕见的。重新审视我们的计划，随机抽样 Github 最终会得到他们长尾分布的代理。由于一些话题与语言有关，情况会变得更糟；例如，Java 比 Clojure 与服务器应用程序更相关。鉴于 Java 在我们的数据集中也更常见，可能会导致模型得出 Clojure 与服务器完全无关的结论(在我们的模型预测中总是负面的，这是不正确的)。解决方案应该是确保我们的数据集更均匀地分布在不同的语言和类中。

为什么分层抽样代码不简单

常见的实现均匀分布的方法是分层抽样。在代码数据集上，通常在回购级别应用采样，以确保生成的训练-测试-验证分割是互斥的(以避免相同回购文件过度匹配的风险)。试图在回购级别上对语言进行抽样可能很困难，因为一些语言如 Json 和 Yaml 通常是通用的；无论实施什么样的抽样政策，它们都可能在我们的数据集中(过于)常见。另一个问题是如何针对相关文件；为了确保数据集有足够多的服务器相关示例，我们建议使用服务器相关的术语搜索 Github(如 Java 上的“tomcat”、Python 上的“flask”和 Javascript 上的“express ”),但问题是这种搜索太过特定于技术(可能会导致过度拟合),通常很难确保每种语言都有相同数量的示例。依赖于标准化的搜索词(比如“服务器”这个词本身)会忽略许多潜在的相关例子。如何确保我们的数据集均匀分布，同时保持其丰富多样？

分阶段采样以调整分布

根据上面提到的代码数据集特征，我们的数据集可能会有偏差。分层抽样只能部分地解决这个问题，因为它隐含着阶级与语言的关系。解决方案应该是分阶段采样；在正类(通常更少)上，欠采样会浪费昂贵的样本，而过采样能够记住不太常见的样本。在负类(通常更容易得到)上，分层抽样可能隐藏了类的多样性。我们的解决方案将是从对阳性类中过于常见的语言进行欠采样开始，并继续对长尾语言进行过采样。最后，我们将对负类进行欠采样，以匹配刚刚生成的正语言分布。这将产生一个数据样本，其中我们保留尽可能多的正面例子，同时确保总体人口几乎均匀分布。重要的一点是，无论我们选择应用什么样的采样策略，我们都应该始终监控；确保观看一般和每种语言的表演。了解潜在的隐藏偏见。

主动学习填补空白

在我们建议的解决方案中，一些例子将被忽略(对太常见的正样本和通常的负样本进行采样),而一些例子将被重复(对正长尾进行过采样)。为了使采样比简单的随机采样更智能，我们可以使用弱模型来识别哪些负面例子要优先考虑(由弱模型正确识别的那些不太重要)，并且用主动瞄准感兴趣的地层来替换过采样重复。专注于数据集的“薄弱”领域将使我们能够更好地将我们的工作力量用于改进模型。

谨慎建造

尽管看起来很简单，但生成可靠的代码数据集可能是一项艰巨的任务，有时甚至比训练模型本身还要困难。一开始就注意训练人群特征，可以防止很多后来的头疼。

如何在 Python 中生成虚拟数据

原文：https://towardsdatascience.com/how-to-generate-dummy-data-in-python-a05bce24a6c6?source=collection_archive---------9-----------------------

为找不到合适的数据集而沮丧？—为什么不自己创造呢？

乔尔·菲利普在 Unsplash 上的照片

每个数据科学项目都始于一组数据。

不管你是一名资深的数据科学家还是一名有抱负的数据爱好者，你都可能在某个时候寻找数据集来启动数据科学或机器学习项目。但通常情况下，寻找一组合适的数据可能是一个非常乏味的过程。虽然许多著名的数据存储库已经使成千上万的数据集易于访问，但它们大多是通用的，实际上需要一些调整和准备，以适应我们正在进行的数据项目。

这让我想到——如果找到一个样本数据集如此复杂，为什么不生成我自己的虚拟数据呢？这个疯狂的想法一开始让我有些反感，因为我认为编写自己的数据实际上也同样耗时。但是在我开始在几个项目中创建自己的数据之后，我发现了一个强大的 Python 库，它可以以直观的方式完成所有这些工作。

历史数据&常见的数据格式类型

照片由 Pietro Jeng 在 Unsplash 上拍摄

人类储存和分析数据的最早记录可以追溯到公元前 18，000 年左右，那时人们使用计数棒。【1】快进到 21 世纪，大多数现代数据都是以数字方式收集的，并且可以像滚雪球一样变成大量数据，称为大数据。在信息系统中，数据以字节为单位存储，例如千字节、兆字节等。据估计，2020 年全球创建、捕获和消费的数据总量为 59ZB (zettabyte ),预计到 2025 年将达到令人难以置信的 175ZB。【2】

Metrix 前缀表显示了 IT 系统中常用的乘法前缀。作者自我图解。

存储在计算机化系统中的数据，即存储在您的计算机或其他电子设备(如智能手机)中的数据，必须指定不同的数据类型。数据格式化的基本思想可以分为数字、字母或字母数字。根据讲授计算机科学，下表中可以看到一些常见的数据类型。

IT 系统中常用的数据类型和格式。作者自我图解。

在 Python 中生成假数据

照片由马库斯·斯皮斯克在 Unsplash 拍摄

当然，要生成假数据，这个库必须被称为 Faker 。在本文中，我将带您浏览一些生成通用营销数据的片段，这些数据将包括一些常见的列(数据格式)，如:

交易日期(时间戳)
客户名称(字符串)
性别(布尔型)
电子邮件(字符串)
城市(字符串)
购买的产品 ID —条形码(字符串)
支出金额(浮动)

为了使 Python 代码可移植，笔记本是使用 Google Colab 构建的，完整的代码可以在 GitHub 上找到。由于 Faker 不是一个标准库，您很可能必须首先安装它。在 Google Colab 中，这可以通过下面的两行代码来完成。

每一列的 Python 代码片段

代码的逐行解释:

第 1–5 行:导入所需的库。Faker是本教程中用来生成大部分伪数据的主库。
第 7 行:定义客户的数量。要生成的行数。
第 11 行:声明一个空列表，用于传递生成的假数据。
第 13 行:为生成的假数据的每次迭代定义一个for循环。
第 15–18 行:为交易日期创建虚假数据—开始和结束日期被定义为日期的中间范围。
第 20–21 行:使用faker库创建假名字。名称也可以定制为只生成名或姓。更多细节可以在这里找到。
第 23–24 行:在“M”和“F”之间使用random库创建假性别。该列表还可以添加更多不同的性别选择选项。
第 25–27 行:使用 faker 库创建假的(ASCII 格式)电子邮件。其他格式的邮件可以在这里找到。
第 29–30 行:使用 faker 库创建假城市。其他形式的称呼请参考这里的。
第 32–33 行:创建 8 位条形码格式的假产品 id。其他格式可以在这里找到。
第 35–36 行:伪造客户的消费金额。参数被设置为只有两位小数，并且数量将始终为 1-100 之间的正数。
第 38 行——一个for循环的结束。该循环将继续 1000 次(在第 7 行中定义),以生成 1000 行假数据。
第 40 行:将生成的转换成熊猫数据帧。
第 42 行:显示笔记本中所有列的参数。
第 43 行:打印并显示数据帧。

生成的输出。作者自我图解。

奖励—导出为 CSV

您可能希望导出或下载生成的假数据，以便在其他地方用于您的数据科学或机器学习项目。在 Google Colab 中，只用三行代码就可以轻松实现。导出的数据将是标准的 CSV 文件。

结论

万岁，你已经走了这么远，现在你已经成功地生成了一个数据集，最适合你的数据处理需求。示例代码片段相当简单，但是已经涵盖了最常见的数据类型，如整数、浮点、字符串和日期。非常欢迎您使用和编辑代码的任何部分来生成您想要的数据集。

完整的笔记本可以在 Github 上的这里找到。

喜欢我的文章吗？在媒体上关注我，以便在我发布新文章时接收通知。😊

参考文献:

[1] 每个人都应该阅读的大数据简史，世界经济论坛

2 世界数据解释，对话

感谢阅读这篇文章。如果你喜欢我的工作，请考虑加入 Medium 来支持我。谢谢大家！😊

https://jackyeetan.medium.com/membership

如何为你的作品集项目产生机器学习用例想法

原文：https://towardsdatascience.com/how-to-generate-machine-learning-use-case-ideas-for-your-portfolio-project-381776f09f73?source=collection_archive---------39-----------------------

三种创意技巧

马克·弗莱彻·布朗在 Unsplash 上的照片

你的作品集项目可能决定你找到工作的机会，也可能毁掉它。随着越来越多的人渴望从事机器学习方面的职业，你能够将自己与其他候选人区分开来是很重要的。有鉴于此，许多人利用他们的投资组合项目来脱颖而出，吸引招聘经理的注意。

你可以为你的项目参加 Kaggle 的竞赛。但是，实现一个 ML 工程师的全部经验来自于完成整个机器学习工作流程，这最好是在处理自己独特的项目时完成——ka ggle 跳过了机器学习工作流程的早期阶段。尽管并非不可能，但生成潜在用例可能会很困难。

下面是三种技术，可以帮助你为下一个项目生成潜在的用例。

使用神奇的岛屿

机器学习是一个高度技术性的领域。当你试图想出一个有趣的用例时，考虑所有的技术细节是一个很大的灾难。我们最终会想到一个高度复杂的用例，可能需要六个人的团队花 12 个月来开发——这是我们在找工作时没有的宝贵时间。

相反，简单的解决方法是使用卡西·科兹尔科夫的魔法岛。对于那些不熟悉它的人来说，凯西提出了一个位于海洋中央的岛屿，她的许多朋友都在那里工作。他们的工作是走到一起，假装自己是人工智能——而你将获得他们聪明(或愚蠢)的所有荣誉。

为了让这个神奇的岛屿工作，你必须给他们发送一个输入。工人们会做他们想做的任何事情，然后给你回复一个决定。然而，你不允许给他们任何规则，他们必须通过例子来学习。你的工作是给他们工作做。为他们找到工作最简单的方法是摆脱重复性的任务。

你会卸下哪些重复性的苦差事？

这个问题的答案离找到一个合理的用例又近了一步。尽可能多地列出:

输入:房产信息，输出 : 建议价格
输入:电影信息，输出 : 我会喜欢吗？
输入:服务请求，输出 : 等待时间量
输入:动物园的照片，输出 : 图中是什么动物？
输入:股票信息，输出 : 股票明天的价格

在你完全投入其中一个想法之前，想想这对你的员工成功完成任务意味着什么——毕竟，他们可能会喝得酩酊大醉。不能盲目相信他们！

“企业犯的一个常见错误是假设机器学习是神奇的，因此可以跳过对做好任务意味着什么的思考。”— Cassie Kozyrkov，寻找 AI 用例的建议。

阅读其他用例

向他人学习会帮助你建立你的直觉。当我踢足球的时候，我会研究梅西。我会分析他如何带球越过对手，他如何在有球和无球的情况下为自己创造空间，并想象自己在他打球时的样子。

当然，我没有成为梅西，但这有帮助。

每当我发现自己在球场上遇到类似的情况时，我会不假思索地本能地做出动作，这经常会有回报。

同样，阅读大量的机器学习用例可以培养你的直觉。最终，您发现机器学习用例的能力将显著提高，您处理部署过程中出现的各种问题的能力也将提高。

“要学习设计机器学习系统，阅读案例研究以了解实际团队如何处理不同的部署要求和约束是有帮助的。”— Chip Huyen，机器学习系统设计

许多公司分享他们的机器学习用例。这里有一些你可以用来发展你的直觉:

使用机器学习来预测 Airbnb 上房屋的价值 ( Robert Chang ，Airbnb Engineering&Data Science，2017)
空间、时间和杂货 ( 杰里米·史丹利，Instacart 的技术人员，2017 年)
欺诈中由浅入深的学习 ( 易浩·昂，Lyft 工程，2018)

增强你的思想力量

也许你的想法力量很弱。虽然上述两种技巧都有助于你产生想法，但有意识地强化你的想法肌肉是有益的。

就像你的二头肌和四头肌一样，你的想法发生器需要被训练来有规律地产生想法。

“每天锻炼 10 次你的理想肌肉”的主题已经在 Medium 流传了一段时间——ayo deji awo sika 和 James Altucher 是该方法的流行倡导者。

作家们使用这种技术为潜在的博客文章不断产生独特的想法，但它可以用来为任何事情产生想法。

只需要一支笔，一张纸，和一天开始时的几分钟——或者你可以把它分开。但是你必须在一天结束前写下 10 个。

在你的情况下，你不会写博客的想法。你的任务是每天写十个机器学习用例。最酷的是…

没人会看到。

如果你想出的主意被证明是垃圾，那又怎样？没人会看到的。你所要做的就是通过一些阻力训练来锻炼你的意念肌肉。

随着时间的推移，你的想法肌肉将会发展，使你成为一台机器学习用例生成机器。

最后的想法

拥有一个独特的项目是让你与众不同的好方法。许多人在思考他们可以实现的事情时，常常很难产生想法。一些帮助产生想法的技巧包括参观凯西岛，阅读其他人的用例，以及增强你的想法肌肉。

感谢阅读！

如果你喜欢这篇文章，请通过订阅我的每周简讯与我联系。千万不要错过我写的关于人工智能、机器学习和自由职业的帖子。

**https://medium.com/geekculture/5-factors-that-contribute-to-successful-machine-learning-projects-340904446eff https://medium.com/geekculture/3-signs-you-dont-need-machine-learning-958199b30c34 https://medium.com/geekculture/how-to-design-a-machine-learning-system-89d806ff3d3b **

如何在几分钟内从 Docstrings 生成专业的 API 文档

原文：https://towardsdatascience.com/how-to-generate-professional-api-docs-in-minutes-from-docstrings-aed0341bbda7?source=collection_archive---------3-----------------------

在一个小 Python 包的帮助下，生成高质量的文档变得简单而直观。包括降价和乳胶。

图片来源 : Pixabay (免费使用)

文档很重要

当我们使用一个新的库(或者第一百万次重用我们最喜欢的库)时，我们都喜欢好的和全面的文档，不是吗？

想象一下，如果他们从 Scikit-learn 或 TensorFlow 网站上拿走所有的文档，你会有什么感觉。你会感到很无力，不是吗？

文档很重要。高质量的文档(特别是对于一个开源项目)证明，

关心这个项目
关心最终用户或客户( 你的代码被阅读的次数比它被编写的次数多得多 )
富有成效的思维，这样开发人员可以更有效地利用代码库进行调试和参考，否则用户很容易产生错误/问题( 什么是富有成效的数据科学 )
倾向于将技术项目进行逻辑总结，即，不要将个人爱好项目停留在 Jupyter 笔记本级别，而是使其可重用并值得为更大的用户群分发( 这样你就可以将自己与其他数据科学家区分开来 )

这里有一篇文章，里面有一些优秀的例子…

https://nordicapis.com/5-examples-of-excellent-api-documentation/

但是，编写文档经常感觉像是一件苦差事。这是每个开发人员在大规模项目中经历的认知负荷之上的额外负担。

如果我们有一个工具可以生成专业外观的文档，也就是说，可以直接从我们编写的原始 Python 函数推送到 docs 服务器或网站供公众使用，那会怎么样？

在本文中，我们介绍了这样一个漂亮的小工具，并展示了一些基本的例子。

`pdoc3` —一个直观但功能强大的编写 Python 文档的工具

我们都为我们的数据科学项目和开源包编写了大量的 Python 函数并创建了大量的 Python 类，不是吗？其实即使是因果分析和爱好项目，我们也应该 把这种面向对象编程风格的习惯 构建到我们的代码库中。

如果能够直接从这些函数和类定义中生成好看的 API 文档，而无需编写一行额外的 HTML/CSS 代码，那就太好了。

图片来源:作者创作

安装和基本使用

只要 pip 安装软件包，

pip install pdoc3

注:有一个比较老的包叫 **pdoc**。你也可以用它来建立文档，这是这个项目的一个分支。但是这里我们使用的是更新的框架。

从一个简单的加法函数开始。假设它包含在本地工作区中名为math-func.py的文件中。

def addition(num1, num2=0):
    """
    Adds two numbers

    Args:

    num1: The first number

    num2: The second number, default 0

    Returns:

    The result of the addition process
    """

    return (num1+num2)

因此，实际的代码只是一个返回语句，但是 docstring 很长。

这就是关键。文档字符串。

docstring 是 pdoc 工作方式的核心。从他们的网站来看，它是“命令行应用程序，可用于将项目文档呈现为静态 HTML 文件。它还包括一个实时重新加载的 web 服务器来预览更改。

所以，上面的流程变成了，

图片来源:作者创作

那么，如何生成 web 预览呢？只需一个 CLI 命令。

pdoc --http localhost:8080 math-func.py

它在localhost:8080端口启动一个活动的 web 服务器。当您在浏览器中打开该页面时，

Starting pdoc server on localhost:8080
pdoc server ready at [http://localhost:8080](http://localhost:8080)

您的浏览器显示如下页面。首先，你会看到有两个链接的页面，当你点击math-func链接时，你会看到 API。

图片来源:作者创作

很酷，不是吗？但是看起来很基础。让我们看看我们是否能给它添加一些小铃铛和哨子。

降价——美化和可用性的关键

我是编写文档的 markdown 格式的忠实粉丝。你不是经常在 Github Readme 文档中使用它吗？pdoc 的伟大之处在于它允许在 docstring 中无缝集成 markdown 文本。

假设，我们将第二个函数mult添加到我们的math-func.py模块中，

def mult(num1, num2=1):
    """
    Multiplies two numbers

    Args:

    `num1`: The first number

    `num2`: The second number, default `1`

    Returns:

    The result of the **multiplication** process
    """

    return (num1*num2)

请注意对 docstring 的细微更改，其中有一些标记符号，如粗体的反勾号…和** … **。

现在，如果您只是保存这个文件，网页会自动重新载入您的更改。

图片来源:作者创作

请注意参数num1和num2是如何作为内联代码块呈现的，以及单词乘法是如何在 API 文档中以粗体显示的。这就是 markdown magic，就在你的 docstring 里面。

您甚至可以在 docstring 中显示带有三个反勾号的代码块。最终的 API(用于我们的下一个divide函数)，

图片来源:作者创作

我们所要做的就是把这个放到 docstring 中，

"""...Handles exception by a check,

    ```python
    if num2 != 0:
        return (num1/num2)
    else:
        raise ValueError('The second argument cannot be zero')
    ```

 """

请注意，在三个反勾号之后使用了标识符 **python**，以便在 API 文档中以格式良好的方式呈现代码块。

LaTeX math

您可以在 docstring 中包含基本的 LaTeX 数学表达式，并在 API doc 上漂亮地呈现它们。例如，我们用下面的 docstring 编写一个毕达哥拉斯距离计算函数，

def pythagorus(num1, num2=0): """
    ### Description:

    Calculates the root-sum-of-square of two numbers

    ### Args:

    `num1`: The first number

    `num2`: The second number, default `0`

    ### Returns:

    The result of the **pythagorus** formula

    $$dist = \\sqrt { a^2+b^2 }$$
    """

我们需要做以下两件事，

使用$$ … $$包装一个 LaTeX 表达式
使用两个反斜杠字符来表示 LaTeX 表达式中常见的反斜杠。这是为了处理反斜杠作为 Python docstring 中的转义字符的常见角色。

结果是，

图片来源:作者创作

建立函数索引

还要注意我们在页面左侧构建的函数索引。这就像一个目录，当你点击那些链接到相应的功能时，它会把你带到文档中的任何地方。这是一个模块一个模块构建的。这里我们的主模块当然是math-func.py文件。

您可能已经注意到，索引是按字母顺序排序的(根据函数名)。虽然在我们的源代码中，我们在mult函数之后添加了divide函数，但是它被索引在第二位。

图片来源:作者创作

其他选项和实用程序

我们在上一节中介绍了基本用法和选项。在这里，我们想要展示更多的全局选项和实用程序，它们可以用于更多的控制和可用性。

输出选项

你可以生成，

HTML 页面:带pdoc --html <filename.py> 。这会将模块 HTML 文件放在工作目录下的./html 文件夹中。您可以使用一个可选的目录标志将 HTML 文件放入其中。
服务器:带pdoc --http HOST:PORT <filename.py>在网页上显示 API 文档的实时预览，带自定义HOST和PORT。

对于类对象

你可以像函数一样用标准类对象构建文档。例如，我们将整个math-func代码转换成一个类，并在我们的模块中添加第二个Dataframe类。当我们为此生成文档时，它看起来像是，

图片来源:作者创作

一起

如果你把你的类和函数放在一个单独的 Python 脚本(模块)中，那么它会像这样显示，

图片来源:作者创作

程序化生成

从根本上说，pdoc3是一个 Python 包，因此您可以在 Python 代码中使用它以编程的方式生成文档。这是一个样板代码示例，

import pdocmodules = ['a', 'b']  # Public submodules are auto-imported
context = pdoc.Context()modules = [pdoc.Module(mod, context=context)
           for mod in modules]
pdoc.link_inheritance(context)def recursive_htmls(mod):
    yield mod.name, mod.html()
    for submod in mod.submodules():
        yield from recursive_htmls(submod)for mod in modules:
    for module_name, html in recursive_htmls(mod):
        ...  # Process

注意mod.html()本质上是一个在处理模块的文档字符串后返回原始 HTML 字符串的函数。这是使用pdoc --html <filename.py>命令渲染的内容。在上面的代码中，您直接使用您的代码检索它，并可以进一步操作它。

构建完整的模块

您可以使用 pdoc3 一次性构建一个完整的模块。为此，您只需将必要的文件放在通常的模块/子模块层次结构中，就像标准的 Python 包一样。

例如，我们可能有这样一个简单的目录结构(注意 Python 名称空间要求的__init__.py)目录math-mod，在这个目录中，我们将这些文件放在子目录中。

图片来源:作者创作

我们可以运行一行命令，

pdoc --http localhost:8080 -c latex_math=True math-mod

我们将得到下面的结构，

图片来源:作者创作

摘要

构建高质量的文档感觉起来像是软件项目中编程和技术问题解决部分的额外负担。数据科学也不例外。然而，伟大的数据科学和机器学习项目和框架是真正伟大的，因为它们因其广泛的 API 文档而易于任何人使用。

在本文中，我们展示了如何使用一个漂亮的小 Python 包来创建漂亮的 API 文档(包括 markdown 语法和 LaTeX math 渲染),就在舒适的 docstrings 函数中。

希望这能打破为您正在从事的下一个开源项目制作良好文档的障碍。

喜欢这篇文章吗？成为 中等会员 继续 无限制学习 。如果您使用下面的链接， ，我将收取您的一部分会员费，而不会对您产生额外费用 。

https://medium.com/@tirthajyoti/membership

如何用 Python 生成罗马风格的马赛克

原文：https://towardsdatascience.com/how-to-generate-roman-style-mosaics-with-python-11d5aa021b09?source=collection_archive---------15-----------------------

实践教程

使用提供的代码制作自己的马赛克，并理解其背后的基本原理

作者基于以下输入图像制作的图像:scikit-image 测试图像“咖啡”、维梅尔的戴珍珠耳环的女孩和 Python 徽标

古代的马赛克是由小块硬质材料如大理石、玻璃或石灰石组装而成的。这种材料的选择产生了极其持久的艺术作品，让我们深入了解几千年前的生活方式。但是马赛克也代表了现代概念。首先，它们是可持续的，因为它们是天然的、可重复使用的建筑材料。它们拥有高度的抽象性，这让它们看起来很有趣。这种效果会自动出现，因为马赛克中的元素数量受到严格限制。尽管有这种限制，对象应该是清晰可辨的。这是创建新马赛克的挑战，需要在放置瓷砖时遵守规则。

可用算法

当我搜索从输入图像中生成马赛克的工具时，我没有找到一个让我信服的工具。因此，我开始尝试神经风格转移，这产生了令人惊叹的马赛克，但仔细观察发现了许多不切实际的瓷砖。后来，我发现有几篇关于镶嵌计算的科学论文，并注意到一篇由迪·布拉希等人写的旧论文(2005 年的)。我决定修改已发布的方法，并用 Python 实现它。事实证明这比预期的要难，因为这项任务异常复杂。此外，我不得不即兴发挥了很多，因为算法的最后步骤没有详细解释。现在我想和所有对此感兴趣的人分享这个剧本。几行相关的代码就贴在这里，完整的代码可以在 GitHub 上找到。

让我们开始

最初，我们加载一个源图像:

图像如下图所示。现在我们可以开始实现算法了。

边缘检测

最广为人知的马赛克( opus 蠕虫状马赛克)的基本设计原则是沿着视觉上重要的物体边缘放置瓷砖链。因此，我们的首要任务是从源图像中提取这些边缘特征。在该论文中指出，传统的边缘检测算法不能很好地工作，必须开发基于亮度水平的定制技术。这是 2005 年写的。如今，我们可以受益于深度学习领域的进步。整体嵌套边缘检测 (HED)是在迪·布拉希的工作十年后发表的，可以使用 openCV 轻松实现。事实证明，在大多数情况下，HED 在检测相关轮廓方面表现得甚至更好。你可以在下面的比较中看到这一点，HED 产生的背景特征明显较少，但更好地保留了杯子的边缘。

源图像是 scikit-image 的测试图像“咖啡”(Rachel Michetti)。作者的边缘检测图像。

指导方针

现在我们有了边缘，可以开始放瓷砖了。但是之后去哪里呢？让我们准备用瓷砖填充整个图像的说明。因此，我们构建了一套完整的平行于检测到的边缘的指导方针。为此，我们首先必须计算每个像素到最近边缘的距离。幸运的是， SciPy 有正确的功能:

在 img_edges 中，已经检测到的边缘被编码为“1”并通过设置 img_edges==0 转换为“假”。您可以在下图中看到生成的图像。这里，像素越亮，它离边缘越远。

现在，我们可以使用我们关于边缘距离的新知识:我们移动 half_tile (即，一半的瓦片大小；由用户选择)远离边缘，并且逐行绘制指引线，同时总是精确地留出一串瓷砖将需要的空间:

结果如下所示。最终，瓷砖将沿着这些线居中放置。之后，我们再次使用距离矩阵来计算每个像素的梯度。我们稍后将需要这些数据来以正确的方向放置瓷砖。

作者提供的图片(基于 scikit-image 测试图片“coffee”)

为了使指导方针对下面的步骤有用，我们必须将它们转换成有序的坐标列表。这不是一项容易的任务，但谢天谢地，SciPy 在这里又帮了大忙:

瓷砖放置

现在，我们可以通过沿着指引线绘制多边形来实际放置瓷砖。随着 Shapely 的出现，有了一个用于创建和操作几何图形的令人敬畏的 python 库。

标准图块的放置如下完成:

创建第 1 条边作为长度为 2⋅ 半瓷砖的线；以指引线为中心(下图中的虚线)
按照预先计算的渐变矩阵中的角度旋转侧边 1
在 2⋅ half_tile 像素的指导线上向前移动
以与第 1 面相同的方式创建第 2 面
通过取四个角点的凸包创建一个多边形(即两边的两个端点)
如果新牌与附近链的牌重叠，则只保留差异

作者图片

如果沿着弯曲的指引线放置瓷砖，则选择较小的宽度，以便最终马赛克中的圆形对象看起来更好。如上图所示，一旦超过临界角，就绘制边 2。最后，指引线链的最后一个单幅图块(通常是一条闭合的线)被放入剩余的空间，因此可能也具有较小的宽度。

所有这些都是在一个循环中完成的，需要相当多的代码行。为了演示 Shapely 背后的简单原理，让我们画一个多边形:

作者图片

在本例中, line0 创建在左侧，而 line1 创建在右侧。两条线都旋转指定的角度。最后提取两条直线的角点并合并成一个凸多边形。

现在让我们继续放置循环。在下图(左侧)中，您可以看到第一个链完成后的结果。标记的链也用彩色线标出。在右图中，所有链都填充了瓷砖。但我们还没有完成，因为我们有很多瓷砖之间的差距。

作者提供的图片(基于 scikit-image 测试图片“coffee”)

平铺到缝隙中

为了填补空白，我们使用了另一个伟大的 Python 库 scikit-image 。为了找出差距，我们从绘制所有现有的图块开始:

这里， x 和 y 是多边形的角坐标。“Draw”将它们转换成多边形内所有像素的坐标 rr ， cc 。你可以在下面的左图中看到结果。从那里，我们再次计算到现有瓷砖的距离。然后，我们使用这些信息来定义差距内的第二套准则(右图)。

作者提供的图片(基于 scikit-image 测试图片“coffee”)

沿着新的指引线放置额外的图块后，所有必要的多边形都已创建。另一个任务是切掉突出图像边界的瓷砖。然后，我们来看看结果。在下图中，您可以看到整个区域都覆盖着瓷砖:

作者提供的图片(基于 scikit-image 测试图片“coffee”)

处理凹面瓷砖

不仔细看几乎看不出来，但是瓷砖的形状有一点不令人满意:有很多凹多边形！如果一个多边形的两个角点之间的一条线可以超出该多边形，则该多边形是凹的。它可以在放置后当它与附近多边形的重叠被移除时形成。这些形状不是很自然，因为实际上石头通常不是凹的，而是凸的。这就是为什么代码提供了将形状转换为凸形的选项。它实施两种策略(见下面的草图):

移除尖状物:如果多边形的面积没有显著变化，则多边形的尖状物部分被简单地移除。去除尖峰后，面积必须比以前小。否则，存在与其他区块新重叠的风险。
右图就是这种情况。如果删除标记的角，生成的多边形将比以前更大。相反，它被分成两个凸多边形。

方便的是，这两种策略都可以使用 shapely 例程来实现。

作者图片

着色

最后，所有的瓷砖都在适当的位置，并有一个凸起的形状。只是颜色不见了！我们只是从输入图像中复制它。最简单的方法是选择多边形中心的颜色值。由于在某些情况下可能会收集到奇怪的像素颜色，因此也可以对位于图块内部的所有像素的颜色进行平均。你得到的结果显示在右边。

一个缺点是，由此产生的马赛克看起来有点人工，因为不是现代照片中出现的所有颜色都可以用天然材料复制。因此，可以在真正的历史镶嵌画中找到的颜色的集合是预先收集的。您可以选择将所有颜色值更改为该源中最接近的对应值。在下面的例子(右侧)中，选择了来自 Ravenna 的源马赛克，由于使用了玻璃片，它仍然包含许多颜色。

作者提供的图片(基于 scikit-image 测试图片“coffee”)

完了！

让我们再看几个生成的马赛克。

例如，我们可以尝试不同瓷砖尺寸的效果。在左图中，它设置为 15px，在右图中设置为 5px。较粗糙的图像需要 1107 个图块，较精细的图像需要 7069 个图块。

作者提供的图片(基于 scikit-image 测试图片“coffee”)

当然，我们可以选择任何类型的输入图像:

作者的图片基于:维米尔的戴珍珠耳环的女孩，塞巴斯蒂安·比茨的教堂照片，作者的花和狗的照片

如果你想自己尝试一下，从这里获取代码。只需更改输入图像的路径并运行脚本。

最后，感谢 Marat Kopytjuk 审阅本文。

如何使用 CTGANs 生成表格数据

原文：https://towardsdatascience.com/how-to-generate-tabular-data-using-ctgans-9386e45836a6?source=collection_archive---------6-----------------------

实践教程，实用机器学习

对 CTGANs 如何工作的深入解释

作者图片

这篇文章的目的是填补互联网上的空白，很好地解释条件表格式 gan 是如何工作的。表格数据生成是一个不断发展的研究领域；CTGANs 的论文已经成为许多其他机器学习架构的基础，这些架构今天构成了该研究领域的艺术状态。

为什么要生成表格数据？

在我之前的两篇文章中，我探讨了如何使用生成式对抗网络(GANs)生成图像数据。在某种程度上，这些都是本文的基础。尽管图像数据非常直观，但实际上，工业和文学中最常用的数据是表格数据。表格数据是结构化的，在训练机器学习模型时通常更容易处理。然而，在生成表格数据时，要制作一个性能良好的模型，实际上会使事情变得复杂很多。

本文的目标是介绍 CTGANs 是如何工作的。为此，我将首先对 GANs 和表格数据做一个简单的解释。然后，我将介绍 CTGANs 最初论文中描述的体系结构。最后，我将介绍一个使用 Python 的示例实现。

重温甘斯

作者图片

gan 属于深度学习生成器网络的分支。这是一个监督学习问题，我们有一组真实的数据，我们想通过使用生成器来扩充这个数据集。GANs 学习生成样本，这与学习分布有着本质的不同(查看我关于 可微分生成网络 的文章了解更多细节)。

GANs 包括两个神经网络，生成器和鉴别器。生成器生成新数据，同时鉴别器尝试正确分类真实和虚假数据。

这两个网络在培训方面有对立的目标。鉴别器试图最大化其分类准确性(正确识别哪些图像来自生成器)，而生成器的目标是欺骗鉴别器。在学习结束时，生成器应该能够生成看起来非常像真实数据集的图像，以至于它们可以欺骗人类，让他们认为它们是真实的。

表列数据

正如我前面提到的，表格数据是结构化的。对于机器学习模型来说，非结构化数据(如文本或图像)更难学习。在大多数情况下，处理图像数据要复杂得多。但是，在生成表格数据时，您会发现算法会很快变得非常复杂。

表格数据的种类

表格数据可以是数字的，也可以是类别的。

作者图片

数字数据可以是连续的，也可以是离散的。连续数据在分辨率上没有限制。重量可以用吨、千克、克、毫克等来衡量。离散变量有唯一的数值。一个例子是你家孩子的数量。至于分类数据，有顺序数据(有顺序的分类数据，如星期几)和名义数据(没有顺序的分类数据)。

在文献中，离散数据、序数数据和名义数据都被归为一类，称为离散数据。这是因为当训练一个神经网络时，你不会将一周中的每一天作为一个向量{“星期一”、“星期二”…}。相反，你可以给它一个向量{0，1 …}。所以这意味着我们可以把离散数据和分类数据同等对待。

问题设置

一个表格数据集 T 可以说包含了 Nd 离散列和 Nc 连续列。表格数据生成的目标是训练生成器 G 学习从 T. 生成合成数据集 Tsynth

在文献中有两篇探索表格数据生成的关键基础论文，它们是徐磊等人的tgan 和徐磊等人的和ctg an。在本文中，我将重点介绍 ctg an，这是一种已经在行业中起步的架构，在表格数据生成研究领域的发展中起到了关键作用。

ctg an—提议的适应措施

为了完成表格数据生成的任务，可以训练一个普通的 GAN，但是，CTGANs 提出了两个修改，试图解决 GAN 在应用于表格数据时的两个问题。

连续数据的典型归一化

CTGANs 试图解决的第一个问题是标准化连续数据。

让我们先来看看离散数据是如何表示的。

离散数据很容易表示，因为它可以一次性编码。一键编码就是将离散变量中的每个类别归类到其自己的维度中的过程。在前面给出的工作日示例中，在一键编码后，我们有 5 列，每一列代表一周中的每一天，并带有类成员的二进制指示，而不是包含工作周中的某一天的向量。

作者图片

上面，第一个向量{1，0，0，0，0}表示星期一。第二个向量{0，1，0，0，0}代表星期二，依此类推。一种热编码为我们提供了一种规范化的方法来很好地表示离散变量。

然而，当涉及到连续数据时，很难表达连续变量所携带的所有信息。让我们看一个例子:

作者图片

假设我们有一个像上面这样的连续变量(蓝色分布)，我们想代表我们的样本(红色)。正如你所看到的，分布是相当复杂的，它有多种模式。因此，通过简单地给模型连续变量的值，我们可能会丢失一些信息，例如样本属于什么模式，以及它在该模式中的重要性。

作者提出了一个解决方案，他们称之为特定于模式的规范化，它将连续变量转换为包含我们上面描述的信息的向量。

特定于模式的归一化首先将 VGM(变分高斯混合模型)拟合到每个连续变量。高斯混合模型只是试图通过期望最大化来找到最佳的 k 高斯分布来表示数据。VGMs 可以通过一个权重阈值来决定适合数据的最佳高斯数(k)。

图片由【徐磊】等人使用条件 GAN【1】对表格数据建模

一旦我们找到了 k 高斯分布，最好地模拟了我们的连续变量，我们可以评估样本在每个高斯分布。从那里我们可以决定样本属于什么分布(这个用β表示。最后，我们可以使用α项来表示样本在其分布中的值(样本在其高斯分布中有多重要)。

在论文的例子中，VGM 找到了 3 个高斯函数来表示连续变量(k=3)的分布。样本 c(红色)使用上述等式编码为β矢量{0，0，1}和α矢量。

就是这样，解决归一化问题，不是给模型连续变量，我们给它α和β。

离散数据的公平抽样

作者试图解决的关于 GANs 和表格数据的第二个问题与随机抽样和离散数据有关。

训练 GAN 发生器时，输入噪声来自先验分布(通常是多变量高斯分布)。以这种方式对离散变量进行采样可能会丢失有关其分布的信息。对于模型来说，以某种方式包括来自离散变量的信息作为输入，并且学习将该输入相应地映射到期望的输出，这将是有用的。本文提出的解决方案包括三个关键要素:c 条件向量、发电机损耗、采样训练。

为了迫使生成器生成离散变量分布与训练数据相似的样本，除了随机噪声之外，输入中还必须包含一些关于所需离散变量的信息。所以他们选择包含一个条件向量。

条件向量允许我们强制生成器从选择的类别中生成一个样本。条件向量包含所有的离散列，one-hot 编码，其中除了一个离散列中的一个类别(我们希望生成的样本满足的条件)之外，所有的值都被设置为零。通过抽样训练选择条件。

CTGANs 采样训练允许我们对条件进行采样，以生成条件向量，使得生成器生成的分布与训练数据中离散变量的分布相匹配。通过采样进行的训练如下:

首先，选择一个随机的离散列
从该离散列中，基于概率质量函数选择类别，该概率质量函数由该离散列中每个类别的出现频率构建。
条件被转换成条件向量，并用作生成器的输入

最终适应发电机损耗。发生器损耗适用于强制发生器在这种情况下生成样本。他们通过将条件向量和生成的样本之间的交叉熵添加到损失项来实现这一点。这迫使产生的样本遵守该条件。

应用示例

对于这个例子，我使用了 Titanic 数据集【2】。目标是生成看起来尽可能真实的数据。

作者图片

在上图中，左边是数据集中泰坦尼克号上死亡和幸存乘客的真实分布。右边是生成的分布。如您所见，CTGAN 学习生成类似于训练数据中的分布。

ctg an 的问题

虽然 CTGANs 可以学习训练数据的分布，但有时他们可能会错过这些和其他重要方面之间的相关性。

作者图片

左边的所有图像对应于真实数据的分布，右边的图像对应于虚假数据的分布。您可以看到生成器遗漏了训练数据中的关键关系。例如，在真实的数据中，你可以看到如果你是女性，你在泰坦尼克号中幸存的可能性会大得多。合成数据生成器不会捕获此信息。生成器的另一个大问题是它正在生成年龄为负的样本！

尽管有各种各样的理论，CTGANs 本身绝对不是完美的。尽管他们很好地捕捉到了每个变量分布的总体形状，但他们未能捕捉到它们之间共享的大量信息。

结论

在本文中，我解释了一种生成表格数据的关键方法。条件表格式可能很难理解，但它为表格数据生成中的一些最大问题提供了一个非常漂亮的解决方案。

在文章的最后，我快速展示了将 vanilla CTGANs 算法应用于一个示例数据集的结果。CTGANs 并不完美，但可以通过多种方式进行改进。在以后的文章中，我将讨论源自 CTGANs 的其他架构，以及这些架构如何克服我们在本文中发现的一些缺陷。

支持我

希望这对你有所帮助，如果你喜欢，你可以 关注我！

你也可以成为 中级会员 使用我的推荐链接，获得我所有的文章和更多:https://diegounzuetaruedas.medium.com/membership

你可能喜欢的其他文章

可微发电机网络:简介

傅立叶变换:直观的可视化

参考

[1]徐，l .和 Veeramachaneni，k .，2018。利用生成式对抗网络合成表格数据。康奈尔大学。

2数据集:《泰坦尼克号》——作者华金·范肖伦，作者:小弗兰克·e·哈勒尔，托马斯·卡森——https://www.openml.org/d/40945

如何更快更好地生成训练数据

原文：https://towardsdatascience.com/how-to-generate-training-data-faster-and-better-e84d05884dc0?source=collection_archive---------24-----------------------

作为机器学习工程师，提高工作效率的最佳实践

照片由像素的皮克斯拜拍摄

当你在现实世界中创建机器学习模型时，与在线课程或 Kaggle 风格的比赛相反，你需要自己生成训练数据。

这是任何 ML 项目的第一步。尽管这很重要，但却是我们最容易忽视的一点。

作为一名自由 ML 工程师，我经常接受新的项目，并且一次又一次地面临同样的问题:我如何更快更好地生成训练数据？

在本文中，我想分享我在这个过程中发现的一些最佳实践，并帮助您提高工作效率。

你可以在这个 资源库 中找到所有的代码。

问题

开发机器学习模型的第一步是获取训练数据。

在现实世界的 ML 项目中，通常情况下，您不会获得数据。你生成它。除非你在非常精通 ML 的公司工作，这些公司拥有先进的数据工程基础设施(例如谷歌、脸书、亚马逊等等)，否则这一步绝不是无足轻重的。作为初创公司的人工智能/人工智能顾问，我需要生成自己的培训数据。每次都是。

在大多数情况下，这些数据是表格形式的，即有行(样本/观测值)和列(特征和目标)的数据。这些数据存储在数据库中，如 Redshift 或 BigQuery 集群，甚至是 SQL server 或 Postgress。您可以使用 SQL 查询这些数据。

理想情况下，您应该编写一个 SQL 查询，如下所示:

然后运行一次，导出一个包含训练数据的 CSV 文件，进入数据探索和模型构建阶段。

然而，在现实中，事情要复杂一点，因为:

1.那个奇妙的桌子不存在

相反，您最终会编写一个更复杂的 SQL 查询，从不同的表中获取、聚合和连接数据。

大概是这样的:

当你写长 SQL 时，你一定会犯错误。要么是语法错误(很容易修复)，要么是根本错误(很难修复)，这些错误来自于对数据库中每个表和字段所代表的含义的误解。

您可能需要花几天时间，与负责数据库的人员(数据库管理员或理想情况下的数据工程师)来回通话，以了解在哪里可以找到您需要输入到模型中的每一位数据，编写查询，运行它，并祈祷能够获得您开始 ML 工作所需的黄金数据集。

因为第二个问题，这不是大多数情况下会发生的。

2.我的 SQL 查询不执行

您完成了长 SQL 查询的编写，并将其发送执行。

等待…等待…0%进度…仍在等待中…

是的，在你意识到它不会执行之后。

我去过那里无数次。试图得到该死的数据。

凯拉·伯顿从派克斯拍摄的照片

问题是你试图一次获取太多的数据。

一种快速解决方法是只查询一小部分数据。你可以在项目的最开始这样做，来排除障碍，并获得问题的基线表现。但是，当您想要改进模型时，您可能会意识到有一些有用的特性没有包含在查询中。这就把你带到了第三个问题。

3.我的 SQL 查询需要调整(通常需要很多次)

你可以用自己的方式获得一个初始数据集。然而，这种方法从长远来看是行不通的，这就是为什么:

在构建机器学习模型的原型时，您需要在数据库中的训练数据中添加额外的功能。因此，您需要编辑并重新运行该查询。又来了。
当您将您的模型转移到生产(顺便说一下，这是您工作的最终目标)时，您将需要实现一个再培训管道，以避免模型漂移。您需要每天、每周或每月重新生成一次培训数据。

生成训练数据是您需要迭代的关键步骤。像我描述的手动方法(遗憾的是，这是 ML 工程师和数据科学家在实践中最常用的方法)并不是最佳的。

有没有更好的方法解决问题 1，2，3，更好更快的生成训练数据？

没错。

解决方案

我想到的解决方案是基于划分 ( 自动化的原理🤖)和征服。

步骤 1:将 SQL 查询拆分成更小的查询

试图通过一次查询执行获取所有训练数据的问题有两个方面:

这个查询很可能不起作用，因为您想要一次获得的数据量太大，DB 无法处理。
即使查询今天运行，也不能保证它明天(当您重新训练模型时)也能运行，因为数据大小会更大。或者后天。或者另一个。最终，这将打破。

我们的朋友，数据工程师，经常使用的一个技巧是聪明地查询数据。我们运行 N 个查询来提取 N 个块中的数据，而不是一个查询提取所有数据。

例如，一个电子商务站点的数据库至少有一个包含所有历史订单的表，以及一些参数，如购买的商品 id、支付的金额等。以及购买的时间。不是一次获取所有数据:

您可以通过一系列查询在 N 个步骤中获取相同的数据:

运行 N 个较小的查询是可伸缩的，并且消除了数据库中的容量瓶颈。但是，如何自动执行 N 个查询呢？我猜您不希望将 N 个查询复制并粘贴到您的 DB IDE 或 CLI 来获取数据，对吗？

这将我们带到解决方案的第 2 步。

步骤 2:用 python 自动执行查询

Python 是你可能在你的机器学习项目中使用的语言。它也是一种很好的语言，可以快速地自动完成一些枯燥的事情，比如将数据从数据库中提取到 CSV 文件中。

Python 还有一个丰富的 DB 客户端库生态系统，允许您从 Python 脚本对 DB 运行查询。我过去广泛使用的一些是用于 MySQL 服务器的py odbc或用于 postr press/Redshift 的psycopg 2。

话虽如此，自动执行 N 个查询的一个简单方法是将一个查询字符串模板和一个简单的 for 循环放在一个data.py脚本中:

这个解决方案是可行的。但是，它也重复了很多不必要的工作人员。以前下载并存储在 CSV 文件中的数据不应重新下载，除非 SQL 查询中有错误或更改。

让我们在最后一步处理这些细节。

第三步:包起来

为了避免重新处理日期，我们可以添加一个overwrite参数。

有时您想要强制覆盖。例如，您在 SQL 查询中发现了一个错误，想要重新生成所有文件。在这种情况下，你设置overwrite=True。

有时，您只想下载缺失日期的文件，以扩展您的培训数据。例如，当您在生产中重新训练模型时，您不需要重新下载所有日期的数据，而只需要重新下载您训练模型时的前一个日期的数据。在这种情况下overwrite=False。

代码如下:

最后，我是tqdm图书馆的忠实粉丝。它可以让您打印出令人惊叹的进度条，为您提供关于迭代速度和预计完成时间的反馈。

再加一个吧😊

你可以在这个 库中找到所有的代码 🎁

结论

所以，这是我作为 ML 工程师提高生产力的策略之一。

使用这个漂亮的data.py脚本，您将能够:

更快地将新功能添加到您的训练集中。
更快地调试和重新生成数据集。
并最终更快更好的训练 ML 模型，创造产品。

我希望这有所帮助，乡亲们。如果有任何问题，请随时联系。

如果你想了解更多真实世界的 ML 技巧和提示，并成为一名更好的机器学习开发者，请订阅我的简讯。

我很乐意帮助你成为一名更好的机器学习开发者。

祝你愉快

如何获得数据科学工作:终极指南

原文：https://towardsdatascience.com/how-to-get-a-data-science-job-the-ultimate-guide-d5035d321d2c?source=collection_archive---------36-----------------------

在这里，我们提供了一个非常具体和实用的指南，告诉你如何在数据科学领域找到理想的工作

图片来自 Canva

每个行业的数据需求都使数据科学成为发展最快的领域之一，任何数据科学职位都有可能成为高增长职业。与此同时，数据科学仍然是一个相对较新的领域，任何特定角色的职责、结构和需求在不同的行业和公司都可能有很大的不同。近年来，人们对获得数据科学领域的工作很感兴趣。那么你是怎么做到的呢？

如何获得数据科学工作？

闯入数据科学

对于那些希望在数据科学领域开始职业生涯的人来说，无论是刚刚开始职业生涯的人还是处于职业转变过程中的人，都需要考虑入门级数据科学角色需要什么样的基准。尽职调查你自己的技能和经验:你需要在哪些方面有所提高？数据科学非常强调计算、数学、统计和编程，虽然不是绝对必要的，但大学学位或高等学位对进入数据科学非常有帮助。

另一个重要的步骤是反思你的个人兴趣所在，以及这与你过去的经历有何不同。对于那些以前在其他领域有工作经验的人来说，哪些技能有可能延续下去？几乎每个行业都有广泛的数据需求和数据科学工作。这意味着，即使你过去没有明确的数据工作经验:你的专业知识仍然可以发挥作用，特别是如果你希望留在同一个行业，并且能够利用以前的经验。

虽然科技和信息行业中的数据科学最为人所知，但金融和医疗保健行业仍有许多数据需求，这两个行业本身就是主要行业。教育、酒店、娱乐甚至公共部门对数据科学工作的需求也越来越大，这意味着任何过去的经验都可能有助于你进入数据科学领域。医疗工作的经历意味着你可以为医疗保健数据方面的任何角色带来独特的视角。营销历史意味着你了解商业世界，可能特别适合商业分析师的职位，或者至少比一般的数据科学专业更适合，尽管他们有正式的数据科学背景。

请记住，数据科学是一个快速发展的行业，许多公司甚至在内部招聘他们的数据角色，其思维过程是，例如，在技术数据分析方面培训业务人员比教授数据科学家抽象业务概念更容易。

查看我们在 上的博文如何从零开始学习数据科学 ！

建筑地基

回到检查你的技能和经验，花点时间了解你自己的优势在哪里。数据科学涵盖一系列广泛的技能，对您可能缺乏的任何领域进行分类和研究非常重要。

网上有各种资源和教育平台，包括一些来自知名大学的资源和教育平台，涵盖了数据科学领域的各种概念，如 Coursera 、麻省理工学院开放式课件、 DataCamp 等。不同的教育平台有不同的专业:大学附属课程通常涵盖数据科学的广泛介绍，像 DataCamp 这样的在线课程允许你深入了解个别概念并按照自己的速度学习，像 StrataScratch 这样的在线课程专注于如何回答从真实的数据科学工作面试中提取的特定技术面试问题。

查看我们关于 如何用 Python 学习数据科学的指南 。在之前的一篇博客文章中，我们还介绍了 25 个数据科学训练营和课程来促进您的职业发展 。

虽然一些数据科学技术技能和要求，特别是对于更高级和更高级的数据科学角色，只有在多年的工作经验中才能获得，但大多数入门级数据科学角色仍然需要一些通用技能，任何有抱负的数据科学家都应该确保他们熟悉这些技能，如 Microsoft Excel、Python 和 SQL 等编码语言以及统计分析。

温习一下基础知识，确保你还记得来龙去脉，或者深入一些你不太熟悉或者有兴趣建立专业知识的特定领域。专业化很重要！请记住，数据科学是一个非常广阔的领域，光有一般知识是不够的。随着你职业生涯的进一步深入，目标是找到数据科学生产线的特定部分，并成为该领域的专家。

尽管主要是一个技术领域，数据科学领域仍然需要你能够推销自己，尤其是在招聘过程中。换句话说，确保你已经在网上建立了自己的形象。虽然 LinkedIn 是每个在职专业人士的基准标准，但数据科学的有志之士也应该立足于许多其他途径。在 GitHub 上发布项目或建立自己的网站作为数据科学博客或作品集。这有助于展示您在数据科学特定领域的兴趣和技能，或者只是展示您知道如何讲述故事以及传达您的想法和思维过程。

还有，查看数据科学组合创意 这里。

让你自己和你的工作在网上可见对你的数据科学求职大有裨益。除了作为您可以在申请中提交的技能的额外见解来源，它还可以成为招聘人员根据可用信息联系您的机会，发送符合您技能组合的工作邀请，并节省您搜索合适的数据科学职位发布的时间和精力。除了潜在的全职工作，还可能出现其他咨询或兼职的机会。甚至在更远的将来，保持这种在线状态可以帮助你找到潜在的机会，即使你并没有主动寻找它们，招聘人员会主动联系你。

但回到最重要的部分:在网上展示意味着更多关于你自己的信息，以证明你的技能和经验，以及更多关于你的思维过程和工作风格的潜在见解，供公司在你更深入地寻找数据科学工作时查看。让我们更深入地了解这份关于如何获得数据科学工作的终极指南，并立即检查工作申请流程。

数据科学工作面试流程

大多数数据科学公司将他们的申请流程分为三个部分:最初的申请提交，与招聘经理的通话，然后是与团队成员的最后一轮，整个过程持续几周。该流程因公司而异，每个数据科学面试的总次数或长或短都不相同。你申请数据科学工作的环境也会影响你的申请过程，例如，你是否被招聘人员看中，是否在内部申请，或者是否通过推荐被介绍到该职位。

请注意，在《疫情》的拍摄过程中，任何采访都会有进一步的中断，很可能是虚拟场景。

作者创造的形象

申请提交

显然，数据科学工作申请流程的第一步是提交申请。当搜索职位发布时，确保通读每一个职位描述，并确保你符合该职位的基本资格。确定公司正在寻找的品质，以及公司的产品和使命，并决定你的技能和经验是否符合该职位的要求。一个好的做法是，在阅读数据科学职位描述后，从头开始完全重写你的简历，使用公告的准确措辞来描述你的工作经历和过去的成就。

许多公司还要求在他们的数据科学职位发布中附上一封求职信，尽管这通常是一个好主意，你可以在提交的任何申请中附上一封求职信，以获得额外的机会来展示你的能力，更不用说只是表明你愿意付出努力并采取额外的步骤。使用求职信简要介绍你自己和你的背景，以及你的技能和成就如何与这个角色和公司相匹配。回到你对公司产品和使命的研究，描述你为什么想在那里工作，或者这个职位的哪些方面让你感兴趣。

最后，为了得到一份数据科学的工作，在你的申请中加入任何你的在线状态的链接，例如你的 LinkedIn、Github、portfolio、portfolio 等，引起人们对你过去项目中与你申请的职位职责相似的任何特定元素的注意。

HR 的第二轮眼球

如果你在简历和求职信中有正确的技能和经验，符合数据科学职位发布的职责，你就可以进入流程的下一步，与真正的人交谈！这通常是以与招聘人员或招聘经理进行初步筛选电话的形式出现的，在这种情况下，你会就该职位和你的背景进行更深入的交谈。可能还有一个带回家作业的中间步骤，通常以编码评估的形式来测试你的数据分析和编码能力。

除了一些行为和技术问题之外，这个电话会给你一个机会去了解你正在面试的角色，比如它在组织中的相对位置和你将要工作的团队。你也可以借此机会询问面试过程的其余部分会是什么样子，甚至可能询问接下来会遇到什么样的数据科学家面试问题。

最后一轮

数据科学面试的最后阶段通常以与团队成员和其他同事的一系列面试和对话而告终。一些公司甚至要求你去他们的办公室，进行现场面试。在那里，你将有一个更深入的对话，探索你是如何工作的，你的特殊技能和背景。如果在面试过程的早期有一个编码评估，你也可能有机会在面试中回顾你的工作，解释你的思维过程和解决给定问题的方法。

期待更具体的行为问题，以及更长更复杂的技术问题，因为你将与你的面试官面对面(或虚拟地)见面。这意味着你有更多的机会通过问题和你的思考过程来交流和讨论。与未来潜在同事的面试过程中，这一阶段也是你深入了解工作和角色的机会。借此机会了解关于角色或责任的任何细节，以及更广泛的团队和公司文化。

如何准备数据科学工作面试

面试是一种独特的社交场合，许多人可能会觉得处理起来压力很大。做好面试的关键是保持冷静，并提前做好适当的准备。

为后勤工作做一个计划:带上多份最新的简历，提前 10 到 15 分钟到达，在前一天晚上计划好去面试地点的交通路线。在面试中，记住你的回答要集中和切题，直接回答被问到的问题。虽然背景当然很重要，但你在谈话中创造良好第一印象的时间也是有限的。注意不要离题。

对公司本身进行研究，尽最大努力了解他们的目标、文化和产品。能够用自己的话准确描述公司的工作。了解公司文化是帮助你决定面试时合适着装的关键，无论是正式的还是办公室便装。此外，像 Glassdoor 这样的资源可以让你深入了解数据科学面试的结构，甚至确切地知道会问什么问题。

我们在这里 谈谈准备数据科学面试的最佳资源 。

作者创造的形象

要准备的问题类型

数据科学面试问题通常分为三类:业务或产品意识、行为和技术。

商业或产品意识问题涵盖了你对所申请公司的了解和兴趣。对这家公司进行调查很重要，这样你就能了解他们在做什么，并能够谈论它，甚至为你可能看到的潜在问题提供解决方案。这类问题包括最基本的“你为什么想在这里工作？”与公司产品相关的特定场景。

行为问题有助于面试官更好地了解你如何在团队环境中工作、沟通和处理冲突。最典型的问题包括一般性的自我介绍，或者浏览你提交的简历。“告诉我一次……在哪里？”的变体也很常见。这些通常是你应该提前准备好的问题。

技术题涵盖统计分析和编码密集题，一般是最难准备的题型。查看在线资源，如 Glassdoor，查找该公司在该职位或类似职位的其他面试中提出的问题，以了解最近可能会提出的技术问题。更广泛地说，招聘启事，甚至是公司本身的公开信息，都可以给你关于面试官想要测试的特定技能的信息。

请记住，不同的公司对一个角色的实际要求有不同的标准，有些公司可能需要更专注于代码，而其他公司则需要广泛的统计能力或机器学习。

看看以上所有内容，你最需要复习的是哪些方面？

需要温习的技能

首先，重要的是建立(或重新建立)你对面试的总体感觉。特别是对于那些最近可能没有参加面试的人，无论是因为最近刚离开学校还是在以前的职位上花了相当多的时间，确保让自己熟悉工作面试的社交环境。我们已经讨论了需要准备的问题类型，您可以使用这些信息来准备对常见问题的回答。在模拟面试中找一个朋友来回答这些问题并给你反馈也是有帮助的。

接下来，花点时间想一想你对哪些数据科学概念和想法最有经验，谈论起来最舒服。另一方面，上一节中的哪些技术概念甚至是招聘启事本身让你有点不舒服，或者你回答起来没有那么自信？

即使对于那些没有那么多关于面试过程的公开数据的小公司，你仍然可以通过大量的在线教育资源进行具体数据科学概念的一般实践。在我们关于 18 个最值得推荐的学习 Python 和 SQL 的数据科学平台的博客文章中，我们比较了不同的教育平台。当你思考你在哪些方面最需要支持时，用它。

面试时要问的问题

请记住，面试过程的一部分就是你依次面试这家公司，以决定你是否觉得这家公司和这个职位非常适合你。相应地准备一些关于你想从工作场所得到什么的问题，比如公司的期望、结构、管理和文化。在面试过程的早期，你甚至可以选择询问面试过程其余部分的结构，包括接下来你要和谁谈话，甚至可能会问什么类型的问题。

当然，针对面试官给你的任何信息提出一些问题也很重要。你可以跟进面试官对你其他问题的任何回答，要求澄清公司结构或团队环境，并跟进他们提到的任何项目。

最后，记住你不需要把你的问题留到最后。面试应该是一种对话。特别是对于他们问你的任何技术问题，有时甚至是行为或产品问题，在回答之前要澄清你的任何不确定性。提出问题并澄清任何潜在的错误假设可能是给出一个好的、全面的答案并获得一份数据科学工作的关键。

后续行动

花点时间发一封跟进邮件，感谢每一位面试官的宝贵时间。除了礼貌之外，这也是一个让你的面试更令人难忘的机会，你可以在写作中提出具体的时刻，帮助你的面试官在以后的工作中记忆。这也是你加入任何额外想法的机会，比如你在谈话中没有提到的你的历史，或者任何比你最初所说的更完美的答案的额外想法。

摘要

数据科学是一个快速发展的职业，在每个行业都有机会，不仅仅是在技术领域。如果你想进入数据科学领域，任何以前的经验都可以继续。查看在线资源和教育平台，弥补你的知识缺口，特别是使用 Microsoft Excel、Python 和 SQL 的数据科学基础知识，以及统计学。当你进入面试过程时，记得做你的调查，彻底适应面试的社会环境。祝你好运！

最初发表于【https://www.stratascratch.com】。

如何获得机器学习模型的免费服务器

原文：https://towardsdatascience.com/how-to-get-a-free-server-for-a-machine-learning-model-efa35a1fe511?source=collection_archive---------26-----------------------

关于如何在世界任何地方启动和配置免费服务器的 10 步教程

保罗·花冈在 Unsplash 上的照片

拥有一台永远在线的服务器是向你未来的雇主展示你的参考资料或者在现实世界中测试你的机器学习模型的一个很好的方式。

在我们开始之前，我想披露我与亚马逊没有任何关系。你在本文中学到的方法应该也适用于其他云提供商(比如微软 Azure，谷歌云平台)。

我写这篇文章是因为我觉得你拥有这些知识很重要。我希望在我有太多时间和金钱的大学时代有人能教我这些。

通过阅读本文，您将了解到:

什么是 AWS？
如何创建 AWS 帐户？
如何在世界任何地方启动免费服务器？
如何配置服务器？
如何连接服务器？
关于如何编写服务器代码的一些提示。

什么是 AWS？

丹尼尔·埃勒杜特在 Unsplash 上的照片

亚马逊网络服务(AWS)是亚马逊的一家子公司，以按需付费的方式向个人、公司和政府提供按需云计算平台和 API。

这些云计算 web 服务提供了各种基本的抽象技术基础设施和分布式计算构件和工具。AWS 在全球范围内提供可靠、可扩展且廉价的云计算服务。

AWS 为新用户提供特别优惠。您可以免费运行一个小型服务器实例一年。

1.创建 AWS 帐户

首先创建一个亚马逊网络服务账户。你需要一张信用卡来注册。可能需要一些时间来验证。

2.登录 AWS

登录您的 AWS 帐户。
在 AWS 管理控制台中选择 EC2。

AWS 管理控制台(图片由作者提供)。

3.设置实例

单击启动实例按钮。
选择一个亚马逊机器镜像(AMI):
选择亚马逊 Linux 2 AMI (HVM)，SSD 卷类型
选择实例类型:
通用 t2.micro 自由层合格
单击查看并启动。
复查实例启动:
单击启动
选择现有的密钥对或创建新的密钥对:
在选择现有的密钥对选择框中选择:创建新的密钥对。
在密钥对名称类型中:my-model。
点击下载密钥对并启动实例。

选择密钥对对话框(图片由作者提供)。

4.连接到实例

单击查看实例按钮。
在您的个人计算机上打开终端(如果您使用的是 Windows，请打开命令提示符)并找到您之前下载的密钥(下载文件夹)。要在终端运行中移动到下载文件夹:

cd Downloads

带 cd 命令的终端(图片由作者提供)。

3.为您的密钥设置权限(如果您使用的是 Windows，请跳过此步骤):

chmod 400 my-model.pem

4.等待您的实例进入运行状态:

等待您的实例进入运行状态(图片由作者提供)。

5.连接到服务器

1.选择实例并单击 Connect 按钮(记住实例 IP，因为您稍后将需要它)。

连接到你的实例(图片作者)。

2.在个人机器的终端窗口上；从 AWS 上的示例(当您点击连接按钮时会看到此示例)中复制连接命令；并将其粘贴到您个人机器的终端上；以连接到 AWS 实例；它看起来应该如下所示:

ssh -i "my-model.pem" ec2-user@XX-XX-XXX-XX.compute.amazonaws.com

如果询问:您确定要继续连接吗(是/否)，请键入 yes？

当成功连接到 AWS 实例时，您应该看到以下 ASCII 图片:

连接 AWS 服务器(图片由作者提供)，

7.更新服务器

必要时更新实例:sudo yum update -y。

8.开放端口

如果计划在实例上运行 web 服务器，请确保打开入站端口，以便能够从 web 浏览器访问它。在下面的例子中，我打开了用于 Flask Web 框架的端口 5000。

单击 Services，选择 EC2，选择 Running instances 并向右滚动，然后单击您的实例的 Security Groups 链接:

编辑入站规则，如下图所示，然后单击保存(图片由作者提供)。

9.部署分析 Web 服务器

空服务器并不比没有服务器好多少。

要部署基于 pandas 的数据分析服务器，请参见:

10.将机器学习模型部署到服务器

你在云端的第一个机器学习模型(图片作者提供)。

生产中的真实项目比在线课程的证书更有价值。这就是为什么我写了你的第一个云端机器学习模型。

云中的第一个机器学习模型将教你如何开发机器学习模型并将其部署到云中的服务器上。

在你走之前

- [How To Create Date Series in SQL](https://dataanalysis.substack.com/p/how-to-create-date-series-in-sql) [Article]- [Free skill tests for Data Scientists & Machine Learning Engineers](https://aigents.co/skills)- [Advance your Career in Cybersecurity (60% off) [Course]](https://imp.i115008.net/c/2402645/1024607/11298)- [Become a Cloud Developer using Microsoft Azure [Course]](https://imp.i115008.net/c/2402645/895504/11298)- [Master SQL, the core language for Big Data analysis [Course]](https://imp.i115008.net/c/2402645/828410/11298)

上面的一些链接是附属链接，如果你通过它们进行购买，我会赚取佣金。请记住，我链接课程是因为它们的质量，而不是因为我从你的购买中获得的佣金。

在推特上关注我，在那里我定期发关于数据科学和机器学习的推特。

照片由Courtney hedge在 Unsplash 上拍摄

如何在没有 STEM 学位的情况下找到数据科学或分析方面的工作

原文：https://towardsdatascience.com/how-to-get-a-job-in-data-science-or-analytics-without-a-stem-degree-f6fd472f9304?source=collection_archive---------13-----------------------

任何背景的人都可以遵循的 4 个步骤。

我的网络中的人问我的第一个问题是，在没有正式技术背景的情况下，如何找到数据科学或分析方面的工作。

不管你喜不喜欢，在申请和面试时，STEM 教育对你在数据科学行业找工作非常有利。招聘人员和人事经理都对拥有技术大学学位的人有偏见——为什么他们不会呢？我们都被训练成相信有一条路可以得到我们想要的工作——上大学，学习那个东西，然后尽我们所能去最大的公司面试那个东西的工作。这是我们被教导的标准化道路，是实现我们职业目标的最佳途径。招聘经理和招聘人员只是在遵循标准路径。

学历也是快速筛选出候选人的简单方法。大多数数据和分析职位都会在职位描述的某个地方列出要点:

要求:计算机科学、电子工程、物理学或相关领域的硕士或博士学位。

这一点之所以存在，是因为存在一种信念，即正规教育将显著降低候选人在某个职位上失败的风险。逻辑是，如果候选人在大学接受过执行该角色任务所需的技能培训，那么该候选人更有可能在该角色中取得成功。具有讽刺意味的是，数据告诉我们，这一总体信念并不正确。一个员工在特定职位上的成功更多的是关于他们如何思考和如何对待他人，而不是他们在技术职业上有多优秀。2013 年，谷歌研究了让员工在公司取得成功的属性，并确定 STEM 专业知识是最不重要的——前七个特征都是软技能:沟通、指导、同理心和能够将复杂的想法联系起来(关于这一想法的更多信息，请阅读系列或本文)等等。谷歌是许多以工程为中心的大型公司之一，这些公司已经取消了工作要求中的大学学位。今年 8 月，该公司宣布其职业证书将与四年制学位同等对待。

所以，如果谷歌、特斯拉、苹果和这个星球上许多最大、最具技术含量的公司不再要求学位，那么为什么它对寻找技术工作如数据科学家、分析师或数据工程师的人仍然有如此高的溢价？通常情况下，能够胜任这些工作的人实际上都接受过正规的培训，而这些培训在当今的经济中已经失去了很多价值。这是“你看起来不像我”综合症——如果你不是来自他们的世界——一个来之不易的统计学、计算机科学或工程学学位——他们很难想象你会在一个角色上取得成功。我们自然会被像我们这样的人吸引，因为这让我们感到安全和舒适。不幸的是，这导致团队无法解决真正复杂、微妙的问题——因为团队中的每个人看起来都一样，想法都一样，并且有着相同类型的经验。

一个没有受过正规大学培训的候选人如何克服偏见，并在 2021 年及以后在数据科学领域找到一份工作？在本文中，我将列出获得数据科学或分析工作的 4 个步骤，任何背景的人都可以遵循。

照片由 Pexels 的赖爷 Subiyanto 拍摄

1。从 Coursera、Google、Udemy、Data Camp 或训练营获得认证

从在线认证课程或训练营获得早期数据科学选择绝对没有什么不好意思的。虽然不像大学里的面对面课程那样时间密集和“身临其境”，但学习数据科学或商业分析的大量在线课程大多做得很好，并提供了非常有价值的练习和知识。尽可能多的从各种渠道学习这些课程。除非你还在纠结一个概念，否则不要重复同一主题的课程——首先，广泛地选择课程，然后当你发现自己真正喜欢什么时，再专攻一点。

我个人推荐 DataCamp 当你刚刚起步的时候，从那里你可以继续学习更复杂的个人课程或者更多来自 Google 或 Udemy 的官方认证。我喜欢 DataCamp，因为代码示例和练习作为 web 应用程序内置到课程中，这比观看讲座解释然后执行一些练习更具互动性和迭代性。

2。创造体验

在 2014 年的一次采访中，备受崇拜的科技亿万富翁埃隆·马斯克谈到在特斯拉的工作时说:

甚至根本不需要大学文凭，甚至不需要高中文凭……如果有人从一所名牌大学毕业，这可能表明他们将有能力做大事，但不一定是这样……如果有非凡成就的记录，那么这很可能会持续到未来。

这句话的关键词是“非凡成就的记录”这是无法回避的——如果你没有接受过正式培训，你必须向招聘经理证明，你完全可以凭借自己的经验胜任这份工作。

大学毕业生或试图进入新职业的人们普遍抱怨:“所有这些入门级的工作都需要 2-3 年的经验！”。事实是，每个工作列表都是谎言。学位要求、多年经验、要点——这些都不重要。事实上，要求的经验是能够说服招聘经理雇佣你的最少的正确经验。在众多候选人中，你可能会因为没有合适的学位或工作时间不够长而被拒绝，但有价值的、高度相关的经历几乎总能让你获得面试机会。

但是，不找工作，你实际上如何获得经验呢？幸运的是，互联网已经开启了创造你自己的体验的能力，而不需要实际上在任何地方工作。这里有几个例子可以告诉你如何创造经验来说服招聘经理:

做一个数据项目，写一篇关于它的博文

这不仅是向雇主证明你可以成功的最佳方式之一，也是在数据科学和分析方面做得更好的最佳方式之一。选择一个数据集并在其上做一个项目。这可以是建立可视化，建立一个模型，描述数据，写下你发现的见解，或者四者的结合。详细描述你是如何完成工作的，你使用的方法，以及你使用的代码。书写清晰，努力传达有趣的信息。在你的简历上写两三篇写得很好的博客文章可以很好地替代实际的工作经验，并展示出真实、切实的证据，证明你能够完成这份工作所要求的任务。

排名在 左右摇摆 竞争

Kaggle 提供了无数数据集和具有明确结果的比赛，这是练习和灵活掌握数据科学技能的绝佳方式。Kaggle 最棒的部分是你可以提交你的项目并在排行榜上排名。我认为，即使排名前 50 也足以给招聘经理留下入门级工作的印象——排名前 5 可以让你获得一个合法的数据科学家职位。你也可以把这个和上面的建议结合起来，写一篇很长的博文，讲述你是如何清理数据集、构建模型并得到你的预测的。

Kaggle 的一个优点是，平台上的许多数据科学家将分享他们的解决方案和代码，说明他们如何在竞争中排名靠前。这是一个不可思议的学习资源，因为简单地重新编写他们的代码并理解他们如何得到解决方案可以极大地提高你自己的技能。重复这个过程十几次，你会发现自己的提交有了显著的进步。

为你的社交网络提供免费的相关工作

我不喜欢“免费”工作，但有时你必须做你该做的。联系你网络中的人，最好是你认识的人，免费为他们做一个数据项目。(注意:这对小公司最有效)。

在这点上要聪明。不要只是发一封电子邮件要求工作——这实际上只是要求那个人为你工作。找出一个能为个人提供真正价值的项目，然后向他们推荐这个项目。下面是一个可能的例子:

简，【X 公司】的营销人员

你好，简

我希望你一切都好！我想提出一个数据项目，我愿意免费为你和你的公司做这个项目。我最近完成了谷歌的数据分析师专业证书，并一直在从事一些项目，试图获得更多的数据分析师经验。我知道你在[X 公司]做数字营销，我想提供营销分析师的服务。我很乐意为你做一个营销效果和广告支出的分析。如果这在这个时候不相关，我很乐意在您需要数据分析或任何类型的数据清理的任何其他项目中帮助您。这是你感兴趣的东西吗？

在你现在的公司做一个数据项目

如果你已经在某个地方工作，但不在数据岗位——要么开始一个数据项目，以某种方式帮助你当前的团队/职位/公司，要么直接联系你公司的任何分析或数据工作人员，问问他们你是否能在某个项目上提供帮助。到目前为止，已经在某个地方工作是向数据科学或分析转型的最佳可能职位，因为你可能已经获得了一些数据，并将能够找到相关的工作，使你能够在没有职称的情况下成为分析师。

3.申请合适的工作

“数据科学家”这个职位有数百种不同的含义和内涵。一家公司可能意味着从零开始创造新算法的博士研究员，另一家可能意味着做一些统计的业务分析师。

数据分析师更刻板，这就是为什么我建议大多数想进入这个领域的人关注头衔中有“分析师”的职位，而不是数据科学家。除非你在新的 Kaggle 竞赛中一直排名前 25，否则如果没有重要的学术证书或实际从业经验，你很难成为一名数据科学家。这并不一定意味着你不能胜任 DS 的工作，只是意味着绝大多数雇主不愿意冒这个险。在这个过程中的这一点上，你只是试图进入他们将委托你数据的某个地方。你不会有数据科学家头衔，不代表你不会做数据科学！即使是低级别的数据分析师也有机会参与构建数据科学组合的项目(即构建和实施预测模型)。

你可能会遇到“小数据科学家”的职位，但以我的经验来看，这种情况很少。

使用 LinkedIn 确定您所在地区的分析师职位。对于一个初级职位来说，获得远程面试会困难得多，所以关注那些在你家通勤距离内的工作，即使工作本身是 100%远程的。同样，这是关于风险的。雇主不太可能为了一个初级职位而让一个住在全国各地的人冒险，即使他们能够胜任这份工作。

通过仔细分析工作要求和描述来准备你的简历，然后写出能反映你的经历如何与工作要求相符的要点。在这个过程中要非常谨慎——通读几十遍职位描述，并使用职位列表中的关键词。因为你可能不会有很多最近的职位可以分享，所以使用“相关经验”这个标题，将你的博客帖子、Kaggle 竞赛和任何其他与工作相关的数据项目添加到这个部分。

找到想要的工作并申请后，在 LinkedIn 上搜索招聘人员。你可以通过输入公司名称和招聘人员来做到这一点，这通常会为你提供一份人力资源人员的名单，你可以通过电子邮件向他们了解你申请的职位。我见过的大多数人力资源人员都很乐意加入 LinkedIn，并会在他们的个人资料标题中说明这一点。这是你发送一封非常简短的“求职信”的机会，说明你申请了这个角色，为什么你想要这个角色，为什么你会非常适合这个角色(2 到 3 个非常短的段落)。我利用这个策略在大公司获得面试机会。

4.要耐心

成为数据科学家或分析专家并不是一个快速的过程。当你试图在这个领域找到你的第一份工作时，尽可能多的学习，想办法扩展你的知识和能力。以我自己的经验来看，找到一份新工作平均需要 6 个月的时间，而且这是针对那些在这个领域有经验的人。如果你是新来的，时间可能会更长。

耐心点。

在数据科学领域开始职业生涯是一个充满挑战的漫长过程，但当你最终找到第一份工作时，我希望你会发现高质量的生活和迷人的工作。

如果你觉得这篇文章很有帮助， 看看其他的 ！你也可以通过电子邮件直接联系我，向我咨询工作、分析或其他方面的问题。

如何在 6 个月内获得一份机器学习的工作

原文：https://towardsdatascience.com/how-to-get-a-machine-learning-job-in-6-months-5aaa61b13af2?source=collection_archive---------6-----------------------

遵循这个学习指南，在顶级科技公司的机器学习面试中取得成功。

我在谷歌、Twitter、Lyft、Snapchat 等公司参加过许多机器学习工程(MLE)面试。由于我参加过 MLE 的面试过程，我可以告诉你，与软件工程不同，MLE 的面试过程是混乱的。我说的混乱，是指每个公司都有自己对候选人需要具备什么技能的想法；因此，每个公司都有不同的招聘流程。不过，我会给你一个模板，这样到最后你就有知识通过 FAANG 和其他科技公司的几乎所有 MLE 面试。

克里斯蒂娜@ wocintechchat.com 在 Unsplash 上的照片

在过去一年左右的时间里，该领域发生的一件好事是，大多数公司正在(慢慢地)向有点类似的流程靠拢:

【有些人认为与招聘人员的通话是第一步，但老实说，除非你在简历中撒谎或说了一些冒犯的话，否则这只是关于下一步的聊天】

电话面试——这通常有两种形式:一个完整的软件工程面试或者软件工程和一些 ML 问题的混合
现场面试:

软件工程/ML 编码面试
ML 理论问题——我看到这个采访分成两部分:ML 理论和 ML 编码
ML 系统设计
特定公司——我把这个放在这里，因为大多数公司倾向于重复上述面试中的一个，或者根据工作进行特定的面试(例如，脸书有一个系统设计面试，注意这不是 ML 系统设计面试)
招聘经理(行为)——我在一家公司的面试中失败了，因为我对这一轮毫无准备。我通过了技术面试，并且有信心得到一份工作。然而，当我没有这样做时，反馈是我在行为面试中做得不好。在那次反馈之后，我花了很多时间准备这些问题。

所以我们可以看到，在几乎任何 MLE 面试中，你都会遇到三个主要回合:

软件工程/ML 编码
ML 理论
ML 系统设计

我们将经历每一轮，我将为你提供最好的(IMO)网站/文件，你可以用它们在 6 个月后的下一次 MLE 面试中取得成功。由于我们有 6 个月的时间，我们可以建立一个强大的知识基线，然后扩展。

软件工程& ML 编码

弗洛里安·奥利佛在 Unsplash 上拍摄的照片

我们可以把它分成两部分:纯软件工程(SWE)编码和 ML 编码。

对于 SWE 编码，计划将是:

leet code:这不应该是一个奇怪的包含，因为它在 SWE 面试中无处不在，而且理由充分！我建议您按照以下步骤进行操作，因为这些步骤是互为基础的:

【2 周】https://leetcode.com/explore/learn/—这有助于刷新你对数据结构和算法的记忆
【2 周】https://seanprashad.com/leetcode-patterns/——这是一个很好的资源，包含许多你在编码面试中会遇到的模式
https://leetcode.com/problemset/top-interview-questions/——你应该注意面试中容易出现的热门问题
名词（noun 的缩写）b:在回答这些编码问题时，你应该创建一个困难问题和所用算法(不是代码)的电子表格。然后稍后回到电子表格，尝试第二次解决问题。这会帮助你了解自己的弱点。一旦完成以上三个环节，你每天至少要回答一个 leetcode 问题(最好是中等难度，有时是硬难度)。离你面试日期比较近的时候，我推荐买 leetcode premium，做公司题。

2。【1 个半月—可选但推荐】 编程面试要素:很多人推荐破解编码面试但是，我会推荐你买编程面试要素 (EPI)。我提出这个建议是因为你可以选择 Java、C++或者 Python 作为你的编程语言，并且可以使用他们的编码系统来测试你的代码。起初这本书对我来说很难读懂，我不能解决大部分问题。然而，随着我的继续，我开始高效地编写 python 代码，并改变了我对解决问题的看法。

对于 ML 编码，计划是:

[ 1 周] ML 编码算法:我会推荐这个网站，因为当我为面试而学习时，获得适当的 ML 编码资源成了一个问题。大多数网站在两个方面有所欠缺:代码过于复杂，超出了面试的要求，或者不包含时间/空间的复杂性。这个网站解决了这两个问题。
【1 周】 Github ML 算法:这个资源几乎包含了你在面试中可能遇到的所有可能的 ML 算法。代码是以非常模块化的方式编写的，这使得代码很容易理解。

ML 理论

照片由 Antoine Dautry 在 Unsplash 上拍摄

我发现自己花了几个小时试图理解这些理论面试我应该知道什么主题。经过无数小时的研究，这些是你应该知道的话题:

“基础性”ML 话题(你必须知道的话题):

线性回归
逻辑回归
KNN
基于树的模型-决策树、随机森林、袋装/提升树、KL 散度、熵)
SVM
聚类(基本的，如 K-means，层次结构)和 EM
主成分分析(奇异值分解和特征值)
朴素贝叶斯
最大似然估计，最大先验估计

专门的 ML 主题(你至少应该知道神经网络架构；对于其他主题，可以根据您的简历和工作要求来查看):

神经网络结构:FFNNs，RNNs，LSTMs，CNN
甘斯
自然语言处理
计算机视觉
推荐算法
信息检索
强化学习

杂项(这些是你应该知道的非常流行的问题):

激活功能
优化方案 SGD，Adam，RMSProp…
损耗—对数损耗、铰链损耗、胡伯损耗、L1/2 损耗…
指标—精确度、召回率、联合交集、F1、RMSE…
特征选择
特征工程

对于学习，我将根据您喜欢的学习方法给出两个选项(注意，如果您愿意，您可以混合搭配):

书籍:

【3/4 周】 用 Scikit-Learn、Keras、TensorFlow 动手机器学习:这本书是一本很优秀的书，涵盖了上面的大部分主题(除了一些专门的主题)。这是一本容易阅读的书，有引人入胜的图表和代码来帮助你理解每个主题。
【1/2 周】100 页的 ML 书:这是另一本很棒的书，涵盖了上面的大部分主题。它比动手操作的 ML 书进入更多的数学细节，但是，作者在简洁的同时仍然是一个容易阅读的出色工作。还有，是免费的:)

(或)视频课程:

【1 周】 Udacity 的机器学习课程:关于 ML 的一门简单但全面的课程。讲师会向您概述大多数基础主题和一些杂项主题。如果你正在寻找开始的地方，这是一个很好的复习。
【2/3 周】 Coursera 的机器学习课程:这肯定是互联网上最受欢迎的机器学习课程，理由很充分！它深入了许多传统 ML 算法的数学基础，同时任何人都可以使用。注意，如果你想要课程的摘要而不是观看所有的视频，你可以查看这些笔记。
【4/5 周】 Coursera 的深度学习专业:这些课程涵盖了上面大部分的神经网络架构，并且深入到足够的细节，可以进行一次面试。我强烈推荐这本书，因为它几乎包含了你在神经网络和深度学习问题上取得成功所需的所有信息。同样，如果你想要课程的总结，你可以阅读这些笔记。

一旦你完成了上面的资源，你可能需要问题来练习。以下是一组问答文档:

https://www . machine learning interfaces . com/linear-regression-coding/
https://github.com/andrewekhalel/MLQuestions
https://github . com/IndyNYU/Machine-Learning-Interview/blob/master/Algorithms % 26 Theory

ML 系统设计

照片由HalGatewood.com在 Unsplash 上拍摄

对于任何 MLE 现场面试来说，一个 ML 系统设计问题(几乎)是必不可少的。由于在撰写本文时还没有这方面的课程或书籍，我们应该使用博客(我们可以在 2 周内完成以下所有内容)

MLE 面试的 ML 系统设计模板:可以用于大多数 ML 系统设计面试问题的通用框架。有大部分公司都会问的具体问题和答案。
构建机器学习管道:理解机器学习系统设计工程方面的博客
机器学习系统设计草案 PDF:一个很好的主题概述，你应该把它包含在你对机器学习系统设计的回应中
机器学习系统设计博客(Machine Learning System Design Blog):许多公司博客的链接资源，这些博客解释了他们如何构建自己的机器学习系统。

哇，太多了！我从没说过为 MLE 职位学习会很容易，但是，如果你喜欢 ML，这应该是令人愉快的。最后一个建议是记笔记，无论是在线还是使用老式的纸笔，不要忘记那些 leetcode 问题，每天一次！

如何获得远程数据科学工作

原文：https://towardsdatascience.com/how-to-get-a-remote-data-science-job-b813d3ff88ae?source=collection_archive---------36-----------------------

在 Gig 经济中利用数据科学的未来

曼尼·潘托贾在 Unsplash 上的照片

越来越少的人在办公室工作，越来越多的人在家办公，远程办公已经变得司空见惯。随着自由职业者和远程工作在数据科学和几乎每个行业中的转变，问题仍然存在…获得自由职业者或远程数据科学工作的最佳方式是什么？

自由职业者的经济经历了一个巨大的增长，有才华的个人寻找自己的时间工作。自由职业者可以自由选择他们想要的工作方式。从外面做自由职业看起来很令人惊讶，一个人怎么能呆在家里远离电脑或笔记本电脑工作呢？幸运的是，我计划给你一个我在零工经济中从事自由职业多年所经历的市场的概述，以及你可以做些什么来增加你被聘为自由职业数据科学家的机会。

什么是自由职业？在零工经济中，自由职业要求你拥有一项技能，你可以向客户提供这项技能，并以此赚取某种价值。如果你已经决定了你想赚钱的技能，那么你就可以开始成为自由职业者的旅程。另一件要记住的事情是，你是否打算远程工作，或者你是否愿意在办公室工作。自由职业也可以是一种体力职业。

我为全球不同的创业公司做自由撰稿人。薪酬越高的工作通常位于加州或纽约之外。我从事自由职业已经 7 年多了。我认为现在是开始自由职业的最佳时机。此外，不要害怕接受其他货币的任务。我被要求完成的一些最好的工作都是用比特币支付的，这种货币在未来会越来越多。

准备

自由职业者和远程工作看起来很棒。但是，为了保证一个光明的未来，准备工作是绝对必要的。有些事情要记住，你最有可能想要的是一个能让你以最佳状态工作的环境。对一些人来说，这是一个繁忙的咖啡馆，但对另一些人来说，这可能是图书馆里一个安静的地方。稳定的互联网和电力连接是必须的，尤其是如果你有最后期限。当你与客户一起规划项目时，你将如何与他们沟通？远程工作时，您不在现场，因此通常会有一点障碍。另一个要考虑的是你的社交生活。因为你不会有同事，如果你选择在安静的环境中工作，你不能依赖频繁的面对面聊天。

寻找职位和申请

既然你已经做好了准备，是时候利用你的努力、动力和技能了。幸运的是，自由职业者和偏远地区的机会数不胜数。有些人甚至用加密货币支付任务支出。大多数自由职业者和远程网站都提供工作通知，所以一定要设置好。

Grindez——完成任务

grindez.com

Grindez 是自由职业者的首选市场。Grindez 是由ul ready打造的 p2p 工作平台。作为以加密货币支付为主机的求职市场，Grindez 通过智能合同将自由职业者和客户联系起来，实现了强大的保护和高效的托管支付——无论不同方位于何处。如果你熟悉任何一个大的和成熟的自由职业平台，那么你会对他们在自由职业者市场上的特色感到满意。

基本上它是如何工作的，你注册一个账户，然后列出清单。公司也会发布工作要求。

Grindez 提供的一个我最喜欢的功能是用 比特币和加密货币 支付。Grindez 提供与其他自由职业者市场类似的所有常见支付方式，但以加密货币支付任务总是很好。这些付款当然要遵循通常的托管方法，以确保卖方和买方的利益都得到照顾。
接下来，我最喜欢的功能之一是搜索提醒。基本上，当网站上有新的工作请求或符合工作标准的列表时，您会收到通知。

我很高兴 Grindez 提供实时列表统计，这样用户就可以看到每次新用户或现有用户查看列表。我最喜欢的另一个功能是 Grindez 的联盟计划。用户可以从他们推荐到网站的人完成的工作中赚取佣金。而且，Grindez 是实时工作的。即时给其他自由职业者或公司发消息的能力对于讨论重大事件或处理纠纷非常方便。

在您开始数据科学自由职业之旅之前

专攻任何事情

对每项技能的需求总是存在的。决定专注于哪项技能通常很困难，所以为什么不列出你拥有的每项技能呢？那么你肯定会被录用。

专攻某件事，真的是任何事，都能让你与潜在客户建立更多的信任，你也更容易被那些寻找确切服务的人接近。

清晰地交流

你的潜在顾客，尤其是你的客户是你的收入来源。始终保持清晰的沟通，尽可能提供诚实和最好的客户服务。如果你碰巧犯了一个错误，那就对雇主诚实。没有人希望自己的时间被浪费，所以要为自己的行为负责。

迎接挑战

当你和客户一起工作时，很容易被自己对项目前景的设想所束缚。然而，有时你完成的工作跟你的客户不一样。开诚布公地讨论你面临的挑战，你的挑战很可能不再困难。

为什么自由数据科学远程工作不一样？

数据科学与其他行业的不同之处通常在于经验上的差距。最大的数据科学雇主通常是大型科技公司或拥有大量数据集的公司，这些公司正在建设大型办公园区，很少提供远程工作。

总结了获得第一份工作的技巧

与试图雇佣你的人交流
按时高标准地完成工作
让客户知道我完成了
解释清楚我做了什么
如果适用，解释我没有做的事情
征求对工作的反馈
请求对我的后续工作评估给予积极反馈
建议我将来可以做的相关工作

最后的想法

如果你正在考虑从事自由职业，那么干得好！创办自己的公司并为自己工作是非常有益的，也是增长技能的好方法。从我自由职业的旅程开始，学习如何推销自己和接触新的机会是非常有趣的。你真正需要弄清楚的是，自由职业是否适合你，你将提供哪些技能，以及在哪里推销自己。一旦你搞清楚了这些，剩下的就容易了。

知识就是力量！分享你的知识，开源你的项目，加入一个社区(任何社区！)，也许只是发表一篇关于它的博文。

欢迎建设性的批评和反馈。可以在 Instagram @nirholas 、 LinkedIn 、和 Twitter @nickresendez 上联系到 Nicholas Resendez，了解新文章的更新。

如何从 Shopify 获得所有订单

原文：https://towardsdatascience.com/how-to-get-all-orders-from-shopify-69db163c7a2d?source=collection_archive---------13-----------------------

Shopify API 调用入门

在 Unsplash 上 Cam Morin 拍摄的照片

Shopify 是最著名的建立网上商店的平台之一。作为一名数据科学家，我多次被要求构建一些集成到 Shopify 中的东西，如订单的自动描述性分析、ERP 连接器等。我们要做的第一件事是从 Shopify 获取我们想要的所有信息，即订单及其信息。在本帖中，我们将向您展示如何设置一个私有应用程序，并使用它来获取 python 中超过 250 行限制的所有订单。

在 Shopify 中创建私人应用程序

首先，我们需要创建一个私有应用程序来获取 API URL。

第一步:导航到左边，点击应用

第二步:向下滚动，点击管理私人应用

第三步:创建一个新的私人应用

创建应用程序后，您可以获得我们将在示例 url 占位符中使用的 URL。

获取所有订单

现在，您应该有一个以下格式的 URL:

[https://{apikey}:{password}@{hostname}/admin/api/{version}/{resource}.json](https://{apikey}:{password}@{hostname}/admin/api/{version}/{resource}.json)

我们希望获得所有订单，所以我们需要在 URL 中添加一些变量。

limit=250 ，这是我们能拿到的最大订单数。
fulfillment _ status = unfully，我们将获得所有未履行的订单，因此我们将使用未履行状态。您可以删除它，并获得已履行的订单。
因为 _id= ，这意味着我们想要从我们将提供的订单 id 开始的所有订单。我们将用它来超过 250 个订单的限制。

这里的技巧是在每次 API 调用后获取最旧的订单 ID，并在下一次调用 since_id 变量时使用它。然后，当 API 将返回少于我们的限制(250)时，我们停止循环并返回订单数据帧。

import pandas as pd
import numpy as np
import re
import requests def get_all_orders():
    last=0
    orders=pd.DataFrame()
    while True:
        url = f"https://{apikey}:{password}@{hostname}/admin/api/{version}/{resource}.json?limit=250&fulfillment_status=unfulfilled&since_id={last}"
        response = requests.request("GET", url)

        df=pd.DataFrame(response.json()['orders'])
        orders=pd.concat([orders,df])
        last=df['id'].iloc[-1]
        if len(df)<250:
            break
    return(orders)df=get_all_orders()
df.head()

最后的想法

个人认为 Shopify 有很多自由职业者数据科学家的机会。需要定制应用程序、API 或仅仅是分析，在大多数情况下，除了订单，你不需要任何其他信息。

以后我会写更多初学者友好的帖子。在媒体上关注我或访问我的博客了解他们。

我欢迎提问、反馈和建设性的批评，你可以通过推特(Twitter)或社交网站(Instagram)联系我。

原载于https://predictivehacks.com

如何摆脱标签少:标签传播

原文：https://towardsdatascience.com/how-to-get-away-with-few-labels-label-propagation-f891782ada5c?source=collection_archive---------3-----------------------

理解大数据

聪明一点，不要自己手动标注数百甚至数千个数据点。

照片由布兰卡·帕洛玛·桑切斯在 Unsplash 上拍摄

介绍

美国数据科学家的一个经典任务是为某个问题建立分类模型。在一个完美的世界里，数据样本——包括它们相应的标签——是放在一个银盘里交给我们的。然后，我们使用机器学习技巧和Mathematica从数据中得出一些有用的见解。到目前为止一切顺利。

然而，在我们这个不完美却又美丽的世界里，经常发生的事情是以下之一:

我们得到一个极小的数据集，它至少是完全标记的。在这种情况下，构建模型可能会非常棘手。我们必须使用先进的特征工程，甚至可能使用贝叶斯方法和其他工具来解决这个问题。以 Kaggle 上的过拟合挑战为例:训练集由 250 个训练样本和 200 个特征组成。玩得开心。
我们得到了足够的数据，但却没有任何标签。嗯，运气不好。尝试聚类，但这不一定能解决您的分类问题。
我们得到了足够的数据，但只是部分标注。这正是我们将在本文中讨论的内容！继续读。

让我们假设从现在开始我们处于第三种情况:我们的数据集的大小相当不错，我们有几千个样本，甚至可能是一百万个。但是看着标签，挫败感油然而生— 只有一小部分数据被贴上了标签！

在本文中，我将向您展示如何处理这些常见的情况。

天真的方法

接近这个设置的最简单的方法是把它转换成我们更熟悉的东西。具体来说:

丢弃未标记的数据点，并在剩余的完全标记但较小的数据集上训练分类器。

我们来分析一下这种做法。

赞成的意见

易于理解和实施
快速转换和快速训练，因为较少的样本意味着较少的计算

骗局

模型可能会过度适应剩余的数据
标记数据的过程中的偏差可能会导致模型的错误决策边界

虽然赞成一方的论点应该很容易理解，但让我们看一张图来更好地理解缺点。

图片由作者提供。

作为人类，我们可以清楚地看到有两个斑点。左边的应该是蓝色的，右边的应该是红色的。中间可能会有一些重叠，但总的来说，它们可以用一条直线很好地分开，即逻辑回归或线性 SVM。

图片由作者提供。

然而，如果我们丢弃未标记的数据并拟合逻辑回归，我们最终得到以下决策区域:

图片由作者提供。

不太好。由于过度拟合，结果并不差，因为逻辑回归是一个简单的模型。但是被标记的数据点的位置是偏移的，即它们有一些奇怪的模式，使分类器混淆。公平地说，如果标记的数据点在两个斑点的中心，逻辑回归会工作得更好。

当然，如果我们试图将随机森林和神经网络放在规模为 4 的训练集上，也会出现过拟合问题。我们可以得出结论:

简单地丢弃未标记的数据不是一个好主意。

现在让我们转向一种更智能的技术，它不仅允许我们整合已标记数据的知识，还允许我们整合未标记数据样本的特征。

这就是人们有时所说的半监督学习。

标签传播算法

标签传播是朱小金和邹斌·格拉马尼[1]在 2002 年提出的一个好主意。

重要提示:在这里，我对原始论文的想法做了一点改动，以便于解释和理解。这两种变体以及其他现有变体的主旨仍然是相同的。

从一个非常高的角度来看，它的工作原理如下:

1。以数据样本为节点构建一个图。在每对样本之间放一条加权边。样本越接近，权重越高。标签在这一点上并不重要。

这迫切需要一个例子。让我们假设我们有另一个二维数据集，它只包含五个样本。有两个类别，一个样本没有标记。样本是我们图表的节点。

图片由作者提供。

现在，让我们建立一个完整的图形，即连接每个节点与任何其他节点。我们还用节点之间的距离(=样本)来注释边。你可以选择任何你喜欢的距离(即欧几里德距离)，它只是算法的另一个超参数。

注意:我省略了标记样本之间的边缘，因为它保持了可视化的清晰，并且算法无论如何都不需要那些。

图片由作者提供。

还记得我们说过更接近的样本之间应该有更高的权重吗？到目前为止，是反过来的！有几种方法可以解决这个问题，最简单的方法是:在所有数字前面加一个减号，或者(相乘)反转数字，例如 4 → 1/4=0.25。

作者在[1]中提出的是使用某种高斯函数，有时也称为径向基函数 (rbf)。

图片由作者提供。

其中 x 和 x 为样本。如果两个样本非常接近，即| x-x '|约为 0，则它们的边权重约为 1。它们离得越远，重量越接近零。

σ 是一个您可以随意使用的超参数。例如，Scikit-learn 对它的缺省值是 σ = 20。

无论如何，现在让我们使用乘法逆运算。图表变成了

图片由作者提供。

这是第一步的结尾。

2.要获取未标记样本的标签，从该样本开始进行随机漫步。遍历的一个步骤包括从一个节点随机跳到相邻节点。具有较高权重的边被选择的概率较高。计算随机漫步首先进入蓝色节点的概率。如果大于 50%，将节点标记为蓝色，否则标记为红色。

这听起来比实际上更困难。例如，让我们从下方白色的未标记节点开始。为了继续，我们必须定义跳转到另一个未标记节点的概率，两个蓝色节点和红色节点中的一个。一个简单的方法是通过规范化。

有四个权重为 1(通向蓝色节点)、0.25(另一个蓝色节点)、0.5(另一个未标记的节点)和 0.5(红色节点)的外出边。所以，举个例子，我们只要把跳到红色节点的概率定义为 0.5/(1+0.25+0.5+0.5)=2/9。跳到更近的蓝色节点发生的概率为 1/(1+0.25+0.5+0.5)=4/9。剩下的你自己算。

使用这些概率，有很多理论涉及到如何计算先到达蓝色或红色节点的概率。你可以通过马尔可夫链来实现，这是数学中一个迷人的领域。有一天我甚至可能会写一篇关于它的文章，但是现在，我只会给你提供结果。

人们可以计算任一颜色着陆的下列概率:

图片由作者提供。

有了这个结果，我们可以说上面的未标记节点可能属于红色类，而下面的节点应该是蓝色的。如果我们不想局限于某一类，我们也可以将这些概率作为软标签。

图片由作者提供。

这大概也是你直觉上已经预料到的，这就说明了这个方法。

现在让我们来看看这个方法的实际应用！

使用 scikit-learn 进行标签传播

使用标签传播很容易，这再次归功于 scikit-learn！在下面的片段中，我

加载所有库和 MNIST 数据集，
用一个 -1 屏蔽标签的 90% 周围，一个丢失标签的预期输入，然后
使用标签传播来恢复我刚刚屏蔽的标签。

由于我们知道真正的标签，在这种情况下，我们甚至可以评估屏蔽集上的性能。但是，请注意，通常情况下，我们不能这样做。

import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import classification_report
from sklearn.semi_supervised import LabelPropagation

np.random.seed(0)

X, y_true = load_digits(return_X_y=True)

n = len(y)
mask = np.random.choice(range(n), 9*n//10, replace=False)
y_missing = y_true.copy()
y_missing[mask] = -1 # -1 indicates a missing label

lp = LabelPropagation(gamma=.25) # rbf is the default, gamma = 1/σ²!
lp.fit(X, y_missing) # run the algorithm we described above

print(classification_report(y_true[mask], lp.transduction_[mask]))

输出如下所示:

 precision    recall  f1-score   support 0       0.98      0.99      0.98       161
           1       0.90      0.99      0.94       163
           2       1.00      0.96      0.98       159
           3       0.90      0.95      0.92       168
           4       0.98      0.97      0.97       159
           5       0.95      0.97      0.96       161
           6       0.99      0.98      0.98       166
           7       0.99      0.98      0.98       159
           8       0.91      0.85      0.88       160
           9       0.95      0.88      0.91       161

    accuracy                           **0.95**      1617
   macro avg       0.95      0.95      0.95      1617
weighted avg       0.95      0.95      0.95      1617

95%的准确率，我还能说什么？太神奇了！该算法只能访问 10% 数据的标签，但它几乎在所有情况下都能正确标记其他样本。当我第一次在 scikit-learn 页面上看到这个例子的另一种形式时，我就开始相信了。我敢打赌，这可能对你的日常工作也很有用！

当然，这不是 100%正确的，但如果你不想自己标记数千甚至数百万个样品，这是一个有效的选择。

作为最后的官方行为，让我给你指出一些有趣的细节。

与 KNN 的联系

仔细想想，标签传播感觉有点k-最近邻 -ish ，不是吗？想象你训练了一个 KNN 分类器。在预测时间，一个没有标签的新点进入。你扫描你的整个训练数据集，并从中挑选最接近的点。离新点越近的点越重要。

正如我们所见，标签传播也是如此。两个样本 x 、 x 越近，它们之间的边在图中的权重就越大，你从 x 跳到 x 的概率就越高，反之亦然。相似之处是存在的，然而标签传播比最近邻居要复杂一些。

标签传播同时考虑了大量未标记的样本，它们相互帮助，在图形/数据集中的任何地方传播正确的标签。就 KNN 而言，每个样本都有其自身的特点。因此，从某种意义上说，标签传播是一种更智能的算法。虽然我们不应该把苹果和梨相提并论，正如我们在德国所说的:两种算法解决了不同的问题。

这些图表很大

假设您有一个由 1，000，000 个样本组成的数据集。在标签传播过程中创建的图形

1，000，000 * (1，000，000–1)/2 =499，999，500，000

边缘。如果您将这些边的权重存储为 64 位浮点，那已经是 4 TB 了。内存太大，写入磁盘时速度太慢。请注意，这是我解释算法的方式，也是scikit-learn[LabelPropagation](https://scikit-learn.org/stable/modules/generated/sklearn.semi_supervised.LabelPropagation.html)的默认行为。

在这些情况下，您可以构建一个不完整的图。与其将每个样本节点与其他节点连接起来，不如将其与其 k 最近的邻居连接起来。(又来了。)

在这种情况下，只有 k * 1，000，000 条边，对于像 k =7 这样的小值，仍然很容易处理。您可以在 scikit-learn 中使用这种方法，通过设置kernel='knn'然后也玩弄n_neighbors参数。

结论

在本文中，我们研究了只有一小部分标记数据的数据集的问题。我们已经确定，丢弃未标记的数据点可能会导致灾难，需要更智能的方法，其中之一就是标记传播。

该算法通过构建一个图来工作，其中数据集的样本是节点，每对样本之间有一条边。对于一个未标记的样本，从那里开始随机游走，看看你大部分时间是在哪个类别的已标记样本中结束的。

我们已经看到，这种方法可以非常好地工作，用一个只有 10%标记数据的 MNIST 例子来证明。准确度高达 95%，这并不完美，但比另一种方法更好:手工标记剩余的 90%或 1617 样本。

但是等等……手工标注剩余的数据集实际上不是唯一的选择。今天我们没有谈到的另一条道路是主动学习。

无论如何，这是另一个时代的故事。

参考

[1]朱小金和邹斌·格拉马尼，利用标签传播从有标签和无标签数据中学习 (2002)，技术报告-CALD-02-107，卡耐基梅隆大学

【更多】sci kit-learn 标签传播用户指南

我希望你今天学到了新的、有趣的、有用的东西。感谢阅读！

作为最后一点，如果你

想支持我多写点机器学习和
无论如何都要计划获得中等订阅量，

为什么不通过此链接https://dr-robert-kuebler.medium.com/membership？这将对我帮助很大！😊

说白了，给你的价格不变，但大约一半的订阅费直接归我。

非常感谢，如果你考虑支持我的话！

有问题就在LinkedIn上写我！**

如何获得 AWS 认证

原文：https://towardsdatascience.com/how-to-get-aws-certified-bab89d2a9dad?source=collection_archive---------33-----------------------

4-6 个月内从零到 AWS 认证解决方案架构师的逐步指南

图片来源: NASA 来自 Unsplash

云计算是当今的热门话题，AWS 是迄今为止世界上最大、性能最好的云计算平台。随着雇主迫切希望将他们过时的内部计算基础设施迁移到云中，并乐于向能够有效完成这一工作的人支付大笔费用，现在是获得 AWS 认证的最佳时机。

在本文中，我将向您介绍一种结构化的 3 步方法，用于通过 AWS 认证解决方案架构师助理 考试。我自己从我在亚马逊的非常能干的经理那里学到了这个方法，并把它教给了许多后来成为成功的 AWS 解决方案架构师的其他人。

整个过程将持续长达 6 个月，需要大量的时间和精神投入，花费约 300 美元。但是，如果最终完成，它将有助于打开全世界 6 位数薪水的解决方案架构师工作的大门。准备好开始了吗？我们走吧！

1)报名参加考试

你可能想知道，为什么报名参加考试是第一步。先学完所有东西再注册不是更有意义吗？

简答:没有。从心理学上来说，如果考试的最后期限临近，你会更有动力去学习。如果你一直推迟报名，直到你有足够的信心，你可能永远不会参加考试。

因此，我建议你从现在开始 3 到 6 个月内定一个固定的日期，尽你所能做好准备。如果最坏的情况发生，AWS 允许免费重新安排 2 次(但尽量不要使用这个选项！).

报名参加考试，进入 AWS 认证网站 点击“安排考试”。如果你没有，你需要创建一个亚马逊账户。

2)云专家课程

报名参加 云专家 并开始 AWS 解决方案架构师助理 课程。如果您还没有个人 AWS 帐户，请访问https://aws.amazon.com/创建一个。你将需要这个来跟随讲师和绝对的云计算超级明星 Ryan 在课程中将要教你的内容。

我给你的建议是跟随课程中的每个视频，做笔记，详细的笔记。请确保在您自己的 AWS 控制台上一步一步地进行实践实验，这样您将更有效地学习。

在课程结束时，您应该感觉自己知道 AWS 中的云计算是什么样的，并对 AWS 服务的生态系统有一个清晰的了解。使用 EC2、S3、VPC 和 RDS 这些服务时，你应该会感到舒适，并会被问到相关问题。如果不是这样，我会建议你在继续之前重温一下不太理解的章节。

3)练习测试

前往 Udemy 购买 John Bonso 的 AWS 认证解决方案架构师助理实践考试 课程。在那里你会发现 6 个模拟考试，它们相当忠实地代表了真实的考试。

一个一个地检查它们。完成一项测试后，确保仔细阅读每一个问题，甚至是那些你回答正确的问题。

在尝试另一个测试之前，请确保您理解为什么所选答案是正确的，为什么其他答案是不正确的。我建议在某一天做一个测试，然后用接下来的 1-3 天彻底检查结果。

每个问题都包含 AWS 文档中相应部分的链接。用它们来加深你的知识。请随意回到本课程的某些部分，在第 2 步)中复习一下。

第一次测试结果可能不好。这是可以的，这是意料之中的。在理解每个问题的过程中保持动力，重温你的薄弱话题，然后尝试另一个测试。如果坚持不懈，这个过程将会结出硕果，你将会在接下来的考试中看到分数的提高。

在理想的情况下，你应该在第五次和第六次测试时达到 90%的分数。如果是这样的话，你应该有信心通过真正的考试。

如果没有，请尝试回到 Ryan 的课程中的步骤 2) 并借助 AWS 文档研究测试中的问题和答案。如果你没有时间学习，重新安排考试时间，但不要超过一个月，以保持动力。

结论

这就是获得 AWS 认证的简单方法。根据您的时间安排和计算机科学知识，该计划将花费您 3-6 个月的时间来完成。因此，在步骤 1) 中设定最后期限时，要对自己诚实。

最后，对于那些对自己的 AWS 能力过于自信的人来说，重要的一点是:考试很难，充满了基于场景的问题，测试你对许多 AWS 服务之间细微特征差异的理解。

即使你有一些 AWS 的经验，也要确保严谨地准备考试。在构建了几个在 S3 和 RDS 之间移动数据的 Lambda 函数之后，认为自己是专业人士是错误的。

希望这篇文章能帮助你获得 AWS 认证。

谢谢你看我的文章，祝你有美好的一天！

如何通过谷歌获得数据科学职位？

原文：https://towardsdatascience.com/how-to-get-contacted-by-google-for-a-data-science-position-95b87f6683fd?source=collection_archive---------4-----------------------

最近，一家大型科技公司的招聘人员联系了我。为什么是现在而不是以前？关于如何增加机会的一些建议。

照片由米切尔罗在 Unsplash

最近，一家大型科技公司的招聘人员联系了我。为什么是现在而不是以前？

在这篇文章中，我提出了我的理论，解释了为什么一位招聘人员联系我申请高级数据科学职位。你可以用我的理论(并进一步发展)来增加你被大型科技公司联系的机会。

许多软件开发人员梦想为大型科技公司工作。我哪里知道？我是其中之一。

我从一家大型科技公司收到的邮件。我故意混淆公司和产品的关键部分。

这里有几个你可能会感兴趣的链接:

- [Complete your Python analyses 10x faster with Mito](https://trymito.io/) [Product]- [Free skill tests for Data Scientists & ML Engineers](https://aigents.co/skills) [Test]- [All New Self-Driving Car Engineer Nanodegree](https://imp.i115008.net/c/2402645/1116216/11298)[Course]

你愿意多看一些这样的文章吗？如果是这样，你可以点击上面的任何链接来支持我。其中一些是附属链接，但你不需要购买任何东西。

联系人

杰克逊·大卫在 Unsplash 上的照片

最近，一家大型科技公司的招聘人员联系了我。我的第一个想法是“这封邮件肯定是假的”。但它写得很好，没有拼写错误(这对于垃圾邮件来说是不寻常的)。

在谷歌上搜索了一下招聘人员后，我发现联系我的人实际上是一家大型科技公司的招聘人员。

然后我就想:为什么他们现在联系我，以前从来不联系？

梦想为一家大型科技公司工作

Johannes Plenio 在 Unsplash 拍摄的照片

2013 年，我大学毕业后，我的梦想是为一家大型科技公司工作。

为什么？因为他们雇佣精英中的精英。真的很难进。这似乎是一个巨大的挑战。

所以我和许多年轻的大学生一样。我润色了我的简历，调整了我的 LinkedIn 个人资料，申请了一个大的技术职位。

但我只听到蟋蟀的叫声。

[## 如何写出完美的数据科学简历

towardsdatascience.com](/how-to-write-the-perfect-data-science-cv-72213d546ebf)

有些人可能会认为，我没有任何参考或经验，但这不是真的。我有一个受欢迎的开源数据科学项目，发表了一篇研究论文，GPA 也不错。

那么和以前有什么不同呢？

电话

照片由汉娜·魏在 Unsplash 上拍摄

起初，我不打算和招聘人员通话，因为我不打算申请这个职位。为什么？

嗯，大的科技公司通常会要求你搬迁。一个不成文的要求也是你需要额外努力——这两个在我目前的人生阶段都是不可接受的。与朋友和家人共度时光对我来说更重要。

然后我对自己说，我那么努力想过去面试。我应该接这个电话。了解他们要说什么，更重要的是，问他们为什么决定联系我？

我以为招聘人员会说:我们的一名工程师偶然发现了你关于 LSTMs 的文章，并说我们需要和这个人谈谈。但是后来我发现事实并非如此。

为什么是我？

LinkedIn 销售导航员在 Unsplash 上的照片

我的答案"你为什么决定联系我？”问题让我大吃一惊:我们在 LinkedIn 上找到了你。

我差不多两年没碰我的 LinkedIn 个人资料了。哦，等等。我不久前改变了我的个人资料图片——但是没有成功😂

但是事情发生了变化，因为我开始在 LinkedIn 上收到许多有趣的工作邀请。

有些事情必须改变，但是是什么？这让我开始思考。

该理论

胡安·鲁米普努在 Unsplash 上拍摄的照片

思考了一段时间后，我想出了这个理论。我需要强调一下，这个 只是一个理论。我还没有事实证明这一点。但仔细想想还是很有道理的。

通过定期在 Medium 上写博客，我开始在 LinkedIn 上收到许多连接请求。在我的中等个人资料描述中，有一个链接指向我的 LinkedIn 个人资料。

随着时间的推移，我在 LinkedIn 上的个人资料越来越多，我看到了用它来发布我的文章的潜力。通过定期发布文章，我的同事们很好奇:罗曼对这些文章有什么企图？这让我的个人资料和内容更受关注。

通过在 LinkedIn 上自我宣传，用户开始与我的内容和个人资料互动。这使得 LinkedIn 排名算法将我推向了更高的排名。因此，当招聘人员寻找高级数据科学家时，我在名单上名列前茅(或接近榜首)。

想想吧。

领英排名算法眼中的数据科学家哪个最好？

获得最多个人资料视图的人和他/她的内容获得最多的互动。LinkedIn 排名算法对数据科学或者编程一窍不通。它只知道内容参与和档案互动。

结论

达维德·扎维亚在 Unsplash 上的照片

关键是在 LinkedIn(或任何其他以就业为导向的在线服务)上进行自我推销，这样排名算法就会给你更高的排名。仅仅像我这么长时间以来所做的那样调整 LinkedIn 的个人资料是没有帮助的。

在你走之前

在 Twitter 上关注我，在那里我定期发布关于数据科学和机器学习的消息。

照片由Courtney hedge在 Unsplash 拍摄

如何在仇恨模因比赛中使用 MMBT 和剪辑获得高分

原文：https://towardsdatascience.com/how-to-get-high-score-using-mmbt-and-clip-in-hateful-memes-competition-90bfa65cb117?source=collection_archive---------20-----------------------

使用剪辑作为一个多模态双变压器的特征编码器，使 MMBT 真正与拥抱脸变压器工作，以获得惊人的高精度

图片由 Pixabay 上的 Manuchi 拍摄

来自脸书的仇恨迷因竞赛的附加阶段几个月前就结束了。我的团队很幸运地参加了这次比赛，甚至取得了相当不错的成绩(我们获得了第十名)。我们是怎么做的，用了什么方法——我会在这篇文章里告诉你。

问题描述

乍一看，比赛中必须解决的问题非常简单——使用文本和图像数据来确定一个模因是否可恶。事实上，由于我们讲话中固有的许多模糊性，以及讽刺和讽刺的存在，问题变得复杂了，因为神经网络的定义有问题。你可以在相应的论文中读到更多关于竞争和它所带来的任务的信息。

图片来自 Unsplash

数据概述

比赛期间，提供了一个可下载的 zip 文件。现在比赛数据可以在这个链接找到。

zip 文件包括一个包含图像的文件夹和几个包含图像注释的 json 文件。

img/ 文件夹包含挑战数据集的所有图像，包括训练、开发和测试分割。这些图像被命名为< id >。png，其中< id >是一个唯一的 5 位数。

train.jsonl，dev_seen.jsonl，dev_unseen.jsonl — json 文件，其中每一行都有一个关于图像的数据的键值对的字典。该词典包括

idimg 目录和。jsonl 文件，例如，“id”:13894。
img 实际的 meme 文件名，例如“img”:img/13894 . png，注意文件名包含上面描述的 img 目录，文件名词干是 id。
文本嵌入在 meme 图像中的原始文本串，例如，img/13894.png 具有“文本”:“给你的宠物戴上蝴蝶结”
标注其中 1 - >“可恨”和 0 - >“非可恨”

例如:

{"id":23058，" img":"img/23058.png "，" label":0，" text ":"不要害怕再爱一次每个人都不像你的前任" }

test_seen.jsnol 包括所提到的按键，除了标签。

绩效指标

使用 AUC ROC 或受试者工作特征曲线下的面积来确定模型性能和排行榜排名。该指标用于衡量二元分类器在不同决策阈值下区分不同类别的能力。

另一个衡量标准是预测的准确性，由正确预测与预测总数的比率给出。

我们的方法

有许多处理多模态数据的模型和框架，其中最突出的是来自脸书的 MMF。 MMF 为访问许多强大的多模态模型提供了一个简单的接口。但是，作为《拥抱脸变形金刚》的超级粉丝，我们决定不走捷径。我们决定找出变形金刚中有哪些多模态模型，以及如何最大限度地利用它们。原来这种型号目前在《变形金刚》里只有一款——【多模态双变压器(MMBT) 。让这个模型工作起来并不容易，但是这让这个任务变得更加有趣。

MMBT 建筑，来自监督的多模式双转换器，用于对图像和文本纸张进行分类

MMBT 融合来自文本和图像编码器的信息。 BERT 用作文本编码器， ResNet 用作图像编码器。我们利用 MMBT 架构的灵活性，用剪辑替换 ResNet 进行图像编码。 CLIP 预训练图像编码器和文本编码器，以预测数据集中哪些图像与哪些文本配对。我们的假设是 CLIP 的特性更加通用，更适合多模态领域。

摘要剪辑模型的方法，来自从自然语言监督论文中学习可转移的视觉模型

对于文本编码，我们使用了Bert-base-un cased-hat explain模型，该模型在 Huggingface Hub 中可用。该模型是为英语中的 hatespeech 检测而创建的，因此在我们的情况下，它的特征比最初在 MMBT 使用的 bert-base-uncased 要好。

最终的 MMBT 模型在训练数据集上进行了微调，并在 dev_seen 数据集上进行了验证。

我们还使用受控的 GPT-2 和简易数据扩充方法扩充了训练数据集中的文本。这使我们的模型的准确性增加了几个百分点。增强超出了本文的范围，如果您对本文和我们的方法感兴趣，我可能会单独写一篇。

履行

在文章的这一部分会有很多代码，但是为了更好的理解，我会尝试详细解释所有重要的部分。

首先，让我们导入所需的库。我们需要

变压器版本> =4.8.2
Pytorch 版本 1.8.1
火炬视觉 0.9.1
sci kit-学习 0.23.2
枕头> =8.2.0
tqdm >= 4.60.0
matplotlib >= 3.3.4
数字> =1.19.5
夹子(可以从仓库安装)。

CLIP 现在可以直接在 Huggingface Transformers 中访问，但在实现我们的方法时，它还不存在。为了充分利用我们的模型，我们还使用了 MADGRAD 优化器。

用可用的设备创建一个变量，它将完成所有需要的计算。我们将需要一个 GPU，所以我们的设备是 CUDA。

加载剪辑模型和所需的预处理。初始化需要的变量。

创建一个以特殊方式为剪辑编码器准备图像的函数。该功能将图像分割成三个图块(根据图像的长宽比，按高度或宽度)。最后，我们将在编码后得到四个矢量(每个图块一个矢量，填充为正方形的整个图像一个矢量)。使用这种方法，我们将从图像中获得更多的信息，因为我们将创建嵌入，不仅描述图像的整体，还描述图像的各个部分

定义一个函数，它将从剪辑中获取图像特征。

创建将加载文本和预处理图像的 JsonlDataset 类。创建 collate_fn ，以 pytorch 模型所需的格式对数据集中的数据进行分组。

定义 load_examples 函数，将 json 数据集中描述的数据加载到 json dataset 对象中。创建函数来加载和保存模型权重。

创建了所需的函数和类，因此我们可以加载我们的模型。

加载训练和评估数据集，并为这些数据集创建数据加载器。

定义模型训练参数、优化器和损失。

定义评估函数，该函数将获取评估数据加载器并计算预测 AUC、 F1 得分和准确性。

最后，我们可以训练我们的模型。我们在 best_valid_auc 变量中指定了所需的最小 auc 值，因此，如果模型在验证数据上获得了比指定值更高的 AUC，我们将保存该模型。

训练完成后，我们可以看到结果:

图像由 Rostyslav Neskorozhenyi 使用 Matplotib 创建

为提交做预测

现在我们可以对测试数据进行预测。首先，我们将通过模拟训练阶段来创建数据加载和处理所需的类和函数。

最后，我们做一个预测，并以指定的格式保存它。

就是这样。如果比赛重新开始，这个预测文件可以立即发送到那里。

结论

在这篇文章中，我试图详细描述我们在脸书的仇恨迷因竞赛中使用的方法的概念和实现。比赛给我们设置的任务变得非常有趣，我们在开发解决这些任务的方法时获得了很多乐趣。我希望你也喜欢阅读这篇文章。

我还想提一下，为了获得最大 AUC，我们结合了用不同损失参数和不同增强选项训练的该模型的几个变体的预测。但是这是另一篇完全不同的文章的主题。

文章中描述的所有代码都可以通过这个链接作为 jupyter 笔记本获得。

如何在您的模型完成 knockknock 训练时得到通知？

原文：https://towardsdatascience.com/how-to-get-notified-when-your-model-is-done-training-with-knockknock-483a0475f82c?source=collection_archive---------31-----------------------

使用这个 Python 库来发送模型训练更新。

萨拉·库菲在 Unsplash 上拍摄的照片

想象一下这个场景——你正在进行一个深度学习项目，刚刚在 GPU 上开始了一项耗时的培训工作。根据你的估计，完成这项工作大约需要 15 个小时。显然，你不想看你的火车模型那么久。但是当你离开电脑或者在做不同的工作时，你仍然想知道它什么时候结束训练。

最近，HuggingFace 发布了一个名为 knockknock 的 Python 库，允许开发人员设置并在他们的模型完成训练时接收通知。在本文中，我将用几行代码演示如何使用 knockknock 在各种平台上接收模型训练更新！

安装敲门

您可以使用下面的命令通过 Pip 轻松安装 knockknock。

pip install knockknock

请记住，这个库只针对 Python 3.6 和更高版本进行了测试。如果你有一个早期版本的 Python，如果你想使用这个库，我建议你升级到 Python 3.6 或更高版本。

训练一个简单的神经网络

为了演示这个库，我将定义一个函数，在经典的 MNIST 手写数字数据集上训练一个简单的 CNN。要找到本教程的完整代码，请查看这个 GitHub 库。

导入库

为了开始，我们需要从 Keras 导入一些模块。

from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, Activation
from keras.datasets import mnist

加载数据

为了简化本教程，我使用 Keras 加载了 MNIST 数据集。我在下面的代码中执行了以下标准预处理步骤:

为 28 x 28 像素的训练和测试图像增加了一个额外的维度。
将训练和测试数据缩放了 255。
将数字目标转换为分类的一次性向量。

(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28,1) # adds extra dimension
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1) # adds extra dimension
input_shape = (28, 28, 1)X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

训练模型

下面的函数创建一个简单的 CNN，在训练数据集上对其进行训练，并返回准确性和损失值，以展示模型在测试数据集上的性能。

用于在输入数据集上训练和测试简单 CNN 的函数。

我不会在上面的代码中详细介绍神经网络的架构，因为本教程的重点是发送模型训练通知。为此，我特意使用了一个简单的神经网络。

获取桌面通知

现在我们有了一个训练神经网络的函数，我们可以创建另一个训练模型的函数，并在函数开始和结束执行时创建桌面通知。

from knockknock import desktop_sender[@desktop_sender](http://twitter.com/desktop_sender)(title="Knockknock Desktop Notifier")
def train_model_desktop_notify(X_train, y_train, X_test, y_test):

    return train_model(X_train, 
                       y_train, 
                       X_test, 
                       y_test)train_model_desktop_notify(X_train, y_train, X_test, y_test)

在我的 Mac 上，运行上面的代码会在训练过程开始时产生一个弹出通知。

培训作业开始时的桌面通知。

一旦作业完成运行，它将生成另一个桌面通知，并显示函数的结果，如下所示。

培训工作完成时的桌面通知。

获取电子邮件通知

我们还可以用 knockknock 设置电子邮件通知。为此，您需要设置一个单独的 Gmail 帐户来发送电子邮件通知。您还需要在安全设置中允许不太安全的应用程序访问您的 Gmail 帐户。

from knockknock import email_sender[@email_sender](http://twitter.com/email_sender)(recipient_emails=["[amolmavuduru@gmail.com](mailto:amolmavuduru@gmail.com)"], 
              sender_email="[knockknocknotificationstest@gmail.com](mailto:knockknocknotificationstest@gmail.com)")
def train_model_email_notify(X_train, y_train, X_test, y_test):

    return train_model(X_train, 
                       y_train, 
                       X_test, 
                       y_test)train_model_email_notify(X_train, y_train, X_test, y_test)

运行代码会在 Gmail 中生成以下电子邮件通知。

Knockknock 中的训练开始通知。

当该功能完成运行时，我们会收到另一封通知电子邮件，如下所示。

Knockknock 中的训练完成通知。

获取时差通知

最后，如果您是正在进行机器学习项目的 Slack 团队的一员，您还可以在模型运行结束时在通道中设置 Slack 通知。为此，您需要创建一个 Slack 工作区，向其中添加一个 Slack 应用程序，并获得一个 Slack webhook URL，您可以将它提供给 slack_sender 函数装饰器。访问 Slack API 页面，然后按照本教程中的步骤 1-3创建一个 webhook。

下面的代码演示了如何在给定一个 webhook URL 和一个特定的发布渠道的情况下创建一个 Slack 通知。请注意，出于安全原因，我将我的 webhook URL 存储在一个环境变量中。

from knockknock import slack_sender
import oswebhook_url = os.environ['KNOCKKNOCK_WEBHOOK']
[@slack_sender](http://twitter.com/slack_sender)(webhook_url=webhook_url, channel="#general")
def train_model_slack_notify(X_train, y_train, X_test, y_test):

    return train_model(X_train, 
                       y_train, 
                       X_test, 
                       y_test)train_model_slack_notify(X_train, y_train, X_test, y_test)

运行上面的代码会产生以下时差通知。

训练模型时产生的时差通知。

如果您的数据科学团队有一个宽松的工作空间，并希望监控您的模型培训工作，这是一个很好的功能。

摘要

Knockknock 是一个有用的工具，它可以让您通过通知来跟踪您的模型训练作业。您可以使用它在各种各样的平台上发送通知，它对于跟踪数据科学团队的实验非常有用。

像往常一样，你可以在 GitHub 上找到本文中的所有代码。

加入我的邮件列表

你想在数据科学和机器学习方面变得更好吗？您想了解数据科学和机器学习社区的最新图书馆、开发和研究吗？

加入我的邮件列表，获取我的数据科学内容的更新。当你注册时，你还会得到我免费的解决机器学习问题的逐步指南！

来源

抱紧脸， knockknock Github 库，(2020)。

如何走出编码教程炼狱

原文：https://towardsdatascience.com/how-to-get-out-of-coding-tutorial-purgatory-ca2adf123114?source=collection_archive---------33-----------------------

帮助您一劳永逸地摆脱编程教程的独特技巧

Ayla Verschueren 在 Unsplash 上拍摄的照片

一个新程序员可能犯的最大错误就是陷入编码教程的炼狱。

我向你保证，几乎每一个为自己设定了学习如何编码的目标的人，都曾在编码教程炼狱中的某一点上结束过。

它在开始时发生得很无辜。

您可以从跟随几个教程开始，直到您熟悉编码的过程。一旦你获得了一些自信，你就会受到鼓舞，开始着手自己的项目。但是，当您在 IDE 中打开一个空白文件时，您不知道要写什么或从哪里开始。

以下两种情况中的一种很可能会发生:a)你回到无休止的循环中完成编码教程，或者 b)你出于沮丧和困惑暂时放弃编码，直到几年后你重新开始，并且不得不从基础开始。

我相信这听起来很熟悉。

从我的角度来看，编码教程消除了对程序员来说至关重要的解决问题技能的需求。程序员的整个工作描述都是围绕着解决问题展开的，当你面对一个编码问题时，不断地跟随一个指导者永远不会教会你独立思考。

以我的经验来看，变得更擅长编程的唯一方法是把自己扔进深水区，把编码教程抛在身后。在你停止溺水并开始游泳之前，可能需要一段时间，但是最终，你会成为一个更有能力和自信的开发者。

安装网站拦截器。

如果当你坐下来写代码时，你首先被一个网站吸引，这个网站充满了后续的编码教程，你可能想安装一个网站拦截器。

有时候，在学习编码时，一种严厉的爱的方法是必要的。这种情况下，就该把训练轮摘下来锁在安全的地方了。

安装网站拦截器是一种流行的生产力技术，自我提升社区使用它来提高注意力，同时努力完成工作。例如，你可能要花八个小时来完成一篇中等的文章，因为你被亚马逊或 Youtube 分散了注意力。然而，通过使用网站拦截器，不允许你打开亚马逊或 Youtube 的标签，你可以带走任何可能阻碍你进步的干扰，从而让你在比如说五个小时内完成你的文章。

对于走出编码教程炼狱来说前提是一样的。

如果你一直呆在自己的舒适区，你就不会成为一名进步的程序员。因此，逻辑上来说，通过禁止你访问编码教程网站，你将被迫使用你已经获得的技能来构建一些东西。通过阻止您访问简单的解决方案，您迫使自己通过探索您不熟悉的代码或使用 Google 找到解决方案来弄脏自己的手。

这里有三个免费的网站拦截器让你入门:

冷火鸡拦截器:冷火鸡拦截器是一款强大的网页拦截器，适用于 Windows、macOS 和 Android。冷火鸡拦截器不仅可以阻止特定的网站，但它也可以阻止应用程序，进入互联网，或你的整个电脑。冷火鸡拦截器还提供了一个高级版本，为您提供扩展功能，以进一步提高您的生产力。
StayFocusd : StayFocusd 是 Chrome 的一个扩展，可以让你设定停留在网站上的时间限制。一旦你用完了分配给你的时间，网站将被封锁，直到第二天。
阻止网站:阻止网站是 Chrome 和 Firefox 上的一个扩展，允许你阻止任何网站或用密码保护对网站的访问。此外，阻止网站允许您设置访问网站的时间限制，第二天重置。

将你学到的概念付诸行动。

人们陷入编码教程炼狱的一个重要原因是，他们无法将学到的概念付诸行动。

这意味着，他们不再花时间将所学的代码实现到个人项目中，甚至不仅仅是在浏览器集成开发环境之外，而是继续学习下一个概念。这导致不理解代码在您遵循的安全浏览器内示例之外如何反应。此外，没有肌肉记忆来记住一个给定的概念是如何工作的，或者它将如何与其他概念交互。

因此，将你学到的每一段代码应用到你自己的项目中是至关重要的。这样做会建立你对自己能力的信心，并减少你参考编码教程的需要。例如，如果您学习如何完成 For 循环，请在您自己的代码中编写一个 for 循环来完成任务。

这就好比你要学习一个新单词，但只能通过使用字典给出的定义来理解它。相反，通过用你自己的术语写出这个词的定义，你会更深刻地理解这个词背后的含义以及如何使用它。

做一个你热爱的项目。

当你知道你需要编码但是不知道你想编码什么的时候，最简单的方法就是完成一个编码教程。

人们的一个误解是，通过每天完成编码教程，他们有助于保持他们的编码习惯，这最终会使他们成为更好的程序员。

然而，他们没有理解的是，每天完成一个编码教程并不能强迫他们跳出框框思考。抄袭专业程序员写的代码并不能让你的大脑为自己工作。相反，它让你的大脑进入一种自满状态，告诉自己“我是一个伟大的程序员”，而实际上，它只是进入了自动驾驶状态，并没有真正找到解决方案。

因此，打破编码教程的炼狱并保持一个实际上会产生结果的编码习惯的更好的方法是从事你热爱的项目。

它可以是一个跟踪你锻炼的应用程序，一个提醒你特斯拉股价突然变化的程序，或者一个让你深入了解特定地区房价的网络抓取器。

通过选择一个与你和你的生活相关的项目，你会有更多的动力去完成它。简单明了。

如果一开始你能写的只是一些变量和一些条件语句，那么那就是你开始的地方。从那里，你可以使用谷歌，源代码，甚至编码教程来填补你的知识空白。

为什么我说在这种情况下可以使用编码教程？因为您引用教程的动机是为了在您的项目中实现一个特性。在典型的过程中，您会漫无目的地完成教程以保持学习代码的外观，而不是使用教程来了解完成项目所需的特定过程和功能。

一点一点地，你的项目会走到一起，你的技能也会随之提高。不仅如此，你还可以将编码教程用于它们的预期目的，以此来加深你的知识，而不是让你日复一日地呆在同一个仓鼠轮子上。

将项目分成更小的部分。

当新程序员看到为了实现他们的梦想项目而需要实现的概念和过程的数量时，立即的反应是放弃，寻找更简单的东西。你已经知道他们的最终目的:完成编码教程。

重要的是把项目分成更小的部分，而不是变得不知所措。通过将项目分解成单独的步骤或组成部分，就很容易看出实际上需要完成什么。不仅如此，还可以解决知识差距，从而使项目的可行性变得合理。

正如我上面提到的，如果你目前唯一能完成的事情是编写一些变量，一些条件语句，也许实现一些类和对象，那么这就是你要做的。你可以利用现有的技能完成项目的所有部分。

做完这些后，你需要看看项目中你不知道如何完成的部分。在这里，您需要推理出项目要工作需要完成什么过程。我的建议是使用白板、一些记号笔和一些便利贴来画出你需要完成的过程。从那里，您可以在互联网上搜索解决方案或方法来完成这个过程的每个部分。重要的是要注意，你可能会遇到上百种方法，都是有效的，你可以使用。

这可能需要一点尝试和错误，但最终，项目的每个部分都会走到一起，直到你有一个正常工作的结果。

学习如何谷歌。

编程社区中一个常见的笑话是，没有人是伟大的程序员。每个人都非常擅长使用谷歌。

一开始，你花在编码上的时间有一半以上实际上是花在谷歌上寻找解决方案。随着时间的推移，花在谷歌上的时间可能会下降，但永远不会达到零。许多顶级高级软件工程师和数据科学家会公开承认，当他们遇到问题或需要更好的解决方案时，他们经常使用谷歌。

遵循编码教程将解决问题的方面从编码中去掉，并允许你每次都通过产生完美的、无错误的代码来跟随指导者的脚步。通过拿走编码教程，你强迫自己修复自己的错误，并创建自己的问题解决方案。这就是深入了解谷歌的切入点。

通过使用谷歌找到你的解决方案，你仍然让你的大脑思考解决方案应该如何工作，而不是让它快速复制编码教程的结果。这将有助于你在长期内巩固概念，因为你看到其他人是如何实现它们的。此外，您将学习如何获取他人源代码中的优秀部分，并在您自己的代码中使用它们。

最后的想法。

走出编码教程炼狱也不是不可能。

困难的部分是承认你已经被困在这个循环中，你需要做出一些改变。

幸运的是，你并不孤单。

你之前的大多数程序员和你之后的大多数程序员都陷入了这个陷阱。通过改变你的关注点，从仅仅跟随一个教程，到实际实现你所学的代码，你会发现你实际上保留了编程概念。此外，你对编程的理解和作为程序员的信心也会增加。

通过避免编程教程，你将重新打开大脑中解决问题的部分。在实现了我上面提到的一些技巧之后，你可能会惊讶于自己成为一名自信的程序员的速度。你需要做的就是跳进深水区。

如何使用语音识别和 NLP 从音频文件中获取报告

原文：https://towardsdatascience.com/how-to-get-reports-from-audio-files-using-speech-recognition-and-nlp-b49c20a24488?source=collection_archive---------15-----------------------

用拥抱脸将语音转化为知识/脸书 AI 和 expert.ai

沃洛季米尔·赫里先科在 Unsplash 上的照片

这些年来，我保存了大量的音频/视频文件，告诉自己我很快就会听它们。这个文件夹现在已经变成了一大堆乱七八糟的音频，我甚至经常不记得每个特定文件是关于什么的。这就是为什么我想创建一个程序来分析音频文件，并产生一份关于其内容的报告。我需要一个简单的点击就能显示主题、主要词汇、主要句子等的东西。为了实现这一点，我结合 expert.ai 的 NL API 使用了脸书 AI/拥抱脸 Wav2Vec 2.0 模型。我在这里上传了代码，希望对别人也有帮助。

模型

该解决方案分为三个主要步骤:

预处理阶段(扩展处理和重采样)

语音到文本转换

文本分析和报告生成

第一步，我检查了许多选项。有些非常实用(不需要订阅，易于实现)，但质量并不令人印象深刻。然后我找到了脸书 AI Wav2Vec 2.0 ，这是一个可以在 HuggingFace 上使用的语音到文本模型，它被证明是可靠的，并提供了良好的结果。多亏了这一点，我能够避免云订阅(这需要信用卡和其他请求，使分享我的工作变得比它需要的更复杂)。即使没有任何进一步的微调，我使用的预训练模型(wav2 vec 2-base-960h)也运行良好。如果你想做更多的微调，请看这里的https://tinyurl.com/ykrhxvzn。

关于 NLP/NLU(自然语言处理和理解)部分，我用的是 expert.ai:容易实现，选择范围很广；只需快速注册即可。这是必要的，因为您的电子邮件注册和密码将是用于调用 expert.ai 云服务的系统变量。Wav2Vec 和 expert.ai NL API 都是免费使用的——有一些容量限制。

规范

据我所知，所有的语音到文本模块只对采样率为 16 千赫的音频进行采样。除此之外，这些模块的计算量非常大(这通常是选择云服务的主要原因)，而且我第一次尝试处理 2 分钟音频样本时，我的笔记本电脑跟不上。这让我又增加了一步:“语音到文本的组块”。想法是，因为我不能给模型提供整个文件，我处理了多个(较小的)音频块，然后将它们的转录内容合并回一个文本文件中。按照这种方法，并不是不可能删掉几个字(在我的测试中，这对质量没有可测量的影响)，但是好处是我可以在普通的笔记本电脑上使用语音到文本模块，而且效果很好！最后但同样重要的是，这一模式只接受。wav 文件。所以我在脚本中添加了一个转换片段，如果音频文件有不同的格式/扩展名，就可以使用它。为了使这个转换工作，您必须下载 ffmpeg.exe(在这里)并将文件存储在运行脚本的同一文件夹中。

就 expert.ai NL API 而言，一个请求中所能分析的文本大小是有限制的(10，000 字节，大约 10-12 分钟的语音，取决于说话者说话的速度)。人工智能专家 NLU 分析的输出有相当大的范围:从 NER 到词性标注，从分类到情感分析，PII、Writeprint 和 要多得多 。然而，由于我们发送到云服务的文本是完全小写的，没有任何标点符号(我们的语音到文本步骤的结果)，一些分析可能不会显示这种 NLU 技术的全部潜力。出于这个原因，我只在服务中查询主题、主要引理(这个列表显示了相关名词，以它们的基本形式)和主要短语(也称相关句子)；这些在我的测试中效果很好。我相信，一旦语音到文本技术得到改进，引入了大写和标点符号，这个专家人工智能步骤将会提供更多。

工作流程

下图显示了项目的工作流程。

工作流程

这个过程从我们的原始文件夹开始，所有音频文件都存储在该文件夹中，带有它们的原始扩展名。程序将这些文件发送到“已转换”文件夹，将非。wav 文件(如有)。然后它开始迭代所有转换的文件。这些信号在 16 千赫下重新采样，并保存在“重新采样”文件夹中。

之后，它们被发送到语音到文本模块。在这里，librosa.stream 函数将音频分割成 30 秒的块(该参数是可定制的),并将这些块一个接一个地发送给 generate _ 抄本函数，该函数返回抄本(更多细节将在以下章节中介绍)。

一个块接一个块，所有的音频都被转录和连接。每隔两个块，我决定插入一个回车符 (expert.ai 将此解释为一个句子的结尾)，以避免以一个巨大的单行作为最终的脚本结束——这将使随后的文本分析变得近乎荒谬。在工作流程的这一点上，我们有了一个有意义的文本文档(尽管都是小写字母，并且使用了最少的/模拟的标点符号)，所以现在是 NLU 时间。该转录由 expert.ai 的 NL API 服务进行分析，其输出然后被处理成报告(以。“audio_report”文件夹中的 txt 文件)。最后，我们有一个文本文件，显示音频文件呈现的主要主题，以及相关的名词和语句。有趣的是，我发现有多少我不再关心的播客，而其他的仍然激起我的兴趣，可以优先考虑。**

简而言之，首先转换所有文件(如有必要)，然后一次转换一个文件，完成重采样、转录、NLU 分析和报告生成的整个过程。

让我们仔细看看代码。

搭建舞台

脚本做的第一件事是导入所有必要的库和模型，并设置变量。

拥抱脸 上有的是 Wav2Vec 型号。我选择“base-960h”是因为它是质量和重量结构之间的一个很好的妥协。在“path_base”中写入音频文件的路径。将变量 sr 保持在 16000(这是采样率)；您也可以选择不同的块长度，这取决于您的 CPU 和 RAM 能力:我将其设置为 30(单位为秒)。将您的 expert.ai 开发者门户 邮箱和密码插入到各自的变量中。然后为转换、重采样和最终报告写下您喜欢的文件夹名称。该程序将为您创建这些路径(mkdir)。如果需要，您可以增加 extension_to_convert 列表，添加更多的扩展名。

预处理

我开始预处理音频。目的是得到一个仅由填充的文件夹。wav 文件。

预处理函数遍历存储音频文件的原始文件夹。如果文件有一个“.wav”扩展名，然后将文件发送到“path_converted_audio”文件夹，否则将此类文件转换为“.wav "分机优先。两件事:1)为了使这个转换工作，你必须将 ffmpeg.exe 安装在你的运行脚本的同一个文件夹中；2)如果你的文件有一个不在“extension_to_convert”列表中的扩展名，那么它将不会被转换，程序进入下一个迭代(它会给你一个文件没有被转换的警告)。

随着预处理函数中的 FOR 循环接近尾声，我将“path_converted_audio”填充为 all。wav "文件。我现在准备开始生成文本报告的过程。它由三个函数组成:重采样、asr _ 转录(及其嵌套的生成 _ 转录函数)和文本 _ 分析。

重采样

重采样功能，顾名思义，对音频进行重采样。它将文件和采样率作为参数。出于我的目的，我以 16kHz 对其进行重采样，但如果您想将其用于接受或需要不同采样率的其他模型，只需更改变量部分中的“sr”变量(或直接将其传递给函数)，您将获得所需的采样率转换。这里，函数(librosa.load)加载文件，对其进行重采样，并获取长度信息(librosa.get_duration)。最后，它将重新采样的文件存储在 resample_path 文件夹中。该函数返回重采样路径和长度。

语音转文本

现在，我可以将重新采样的音频传递给 asr_transcript 函数。

asr_transcript 函数有五个参数:处理器和模型已经在脚本的开始部分导入， block_length 已经在 variables 部分设置(我赋值为 30，这意味着 30 秒)，而 resampled_path 和 length 是从前一个函数(resampled)返回的。在函数开始时，我立即计算音频由多少部分组成，然后将“抄本”实例化为一个空字符串。然后，我对文件应用 librosa.stream 函数，该函数返回(在固定长度的缓冲区中)一个生成器，我对其进行迭代以生成音频块。**

我将每个块发送到 generate_transcription 函数，这是一个适当的语音到文本模块，它将语音(这是我正在迭代的单个音频块)处理器和模型作为参数，并返回转录。在这些行中，程序将输入转换为 pytorch 张量，检索 logits(模型生成的预测向量)，获取 argmax(返回最大值索引的函数)，然后对其进行解码。最后的转录都是大写字母。在缺少大小写的情况下，如果所有内容都是小写的，像 expert.ai 这样的 NLP 服务可以更好地处理这种歧义，因此我应用了大小写转换。**

因此，当我调用 asr _ transcript 函数时，它获取音频，对其进行迭代，每次向 generate_transcription 函数提供一个音频块，generate _ transcription 函数反过来转录它，然后将这个转录附加到前一个转录(每两个块创建一个新行)。

在这一点上，我已经得到了我们的原始音频文件的转录。是时候分析一下了。

文本分析

信息发现时间。现在我有了一个脚本，我可以查询 expert.ai NL API 服务并生成最终报告。

Text_analysis 接受五个参数:抄本(从 asr _ transcript 函数返回)、语言和音频 _ 报告(已经在变量部分设置好)、文件(它是我正在迭代的组中的单个文件)和长度(从重采样函数返回)。我实例化了 ExpertAiClient()，简单地称它为“Client ”,然后发送我的请求。这非常简单，只需要一行代码。我指定方法(在我的例子中是“specific_resource_analysis”)，然后我将“抄本”作为文本，“语言”作为语言，“相关者”作为资源传递。这个调用是针对我的情况的，但稍加修改，你可以查询其他类型的分析，如情绪特征、分类、NER、词性标注、笔迹、PII 和更多的分析。一旦我得到了响应，我就遍历它，提取主要的词条、主要的短语和主要的主题，将这些响应添加到报告中，该报告写在一个存储在 audio_report 文件夹中的. txt 文件中。**

我们已经完成了从音频文件获取报告的所有必要步骤。最后，让我们来看看按正确顺序执行所有其他函数的主函数。

语音-数据转换

Speech2Data 是驱动整个工作流执行的函数。换句话说，这是我们调用的从音频文件中获取报告的一个函数。

该函数触发预处理函数，该函数创建一个包含所有已转换文件的文件夹，以备分析，然后遍历每个文件。它对文件进行重新采样，然后转录，分析文本并生成报告。最后一行代码删除了现在无用的 path_converted_audio 文件夹。

结束语

我喜欢写这段代码。多亏了开源软件、脸书人工智能、HuggingFace 和 expert.ai，我已经能用我的家用电脑从音频文件中获取报告了。我看到的潜在应用列表是无穷无尽的。

链接:

GitHub 代码回购

Expert.ai 开发者门户

Expert.ai 文档

Github wav2 vec

抱紧脸型

如何开始并充分利用 Kaggle

原文：https://towardsdatascience.com/how-to-get-started-and-make-best-use-of-kaggle-41feb8bba2d6?source=collection_archive---------5-----------------------

使用 Kaggle 学习数据科学的指南

布拉登·科拉姆在 Unsplash 拍摄的照片

当我开始使用 Kaggle 时，它非常小。以前每次都有一两个活跃的比赛。每个比赛将有一个论坛。大家可以说说自己的解决方法和疑惑。这非常简单容易。在过去的几年里，Kaggle 已经发展壮大。他们有 500 多万注册用户。在任何时间点都有 10 个以上的活动竞争。

它不仅仅是一个数据科学竞赛的平台。Kaggle 现在已经成为数据科学家的平台。他们有大量的数据集。各种问题相关的笔记本很多。有许多数据科学主题的短期课程。他们有论坛、研究竞赛等等。

我见过有人指出 Kaggle 问题和现实世界问题之间的区别。我同意他们的观点。现实世界的问题和 kaggle 问题之间有太多的不同。但这不应该成为不使用 Kaggle 的理由。关于 Kaggle 上的数据科学，还有很多其他的东西需要学习。重点应该是学习新事物，而不是相反。

Kaggle 现在是如此之大，以至于理解起来让人不知所措。不知道用它来学习数据科学是很常见的。在这篇文章中，我将解释如何开始使用 Kaggle 学习数据科学。

学习基础知识

Kaggle 有许多关于各种数据科学相关主题的短期课程。这些课程是免费的，你也可以获得认证。如果你没有任何数据科学方面的经验，那么你需要从一些课程开始。这些课程将帮助你熟悉基本概念。所有这些课程都在下面详细解释。

计算机编程语言

任何想成为数据科学家的人，第一步都是学习编码。编程技能是解决任何数据科学问题所需的基本技能。Python 是数据科学领域最流行的编程语言。它有许多对数据科学项目的各个阶段非常有帮助的库。

根据 Kaggle 最近的调查，超过 80%的人在工作中使用 Python。易于使用和学习使 Python 成为最受欢迎的编程语言之一。来自非技术背景的人发现 Python 在开始时有点难。但是一旦他们适应了，一切都会水到渠成。

在 Kaggle 有一个 5 小时的 Python 课程。它由 8 个模块组成，涵盖了处理数据科学问题的所有基本概念。下面是课程的链接，

完成上述课程后，为了获得更多自信，请向 Codeacademy 学习。另外，参考这里的 Coursera 课程。任何时候，如果你觉得编码不适合你，那么看下面的视频。它将准确地向您展示学习数据科学编码的方法。

熊猫

Pandas 是 Python 中最重要的库之一。这是数据科学最常用的库之一。它使数据的读写变得很容易。它用于数据预处理和转换。此外，对数据进行结构化，使其易于探索和分析。

在处理数据科学问题时，数据以数组的形式出现是很重要的。无论是数据分析还是建立预测模型。我们需要的数据是使用熊猫实现的数据帧格式。这个库的知识有助于轻松有效地执行各种数据操作。

下面关于熊猫的课程涵盖了这个图书馆的主要功能。这是一门 4 小时的课程，需要事先掌握 Python 知识。

数据清理

Kaggle 数据集通常是干净的，随时可以使用。在大多数现实生活的用例中，数据不是可用的格式。这些数据需要清理，才能供数据科学项目使用。

真实世界的数据集会有很多问题，

有许多丢失的数据点
不同级别的属性，如年龄(以年为单位)和收入(以千年为单位)。许多算法需要属性具有相同的比例。
具有异常值的属性，如果不进行处理，可能会产生不准确的结果
由于印刷错误或其他问题(如不同的日期格式)导致的数据不一致

下面的课程探讨了一些常见的数据问题。它还介绍了处理这些问题的解决方案。这也是一个教授重要数据清理策略的短期课程。本课程没有涵盖所有的数据清理技术，但足以帮助您入门。

数据可视化

人脑很容易从视觉数据中提取模式。可视化是向业务涉众传达见解的关键。数据科学家需要对可视化技术有很好的了解。比如，哪些图表最适合什么类型的数据分析？有哪些技术有助于突出数据中的趋势或模式？

ML 简介

最后，以下课程将有助于理解数据科学项目中的管道。它将涵盖重要的步骤以及采取这些步骤的原因。完成本课程后，你将能够实现一个预测模型。

这些课程可能不会让你成为这些领域的专家。它不会涵盖该主题中的每一个概念。但是，它将帮助您掌握足够的技能来解决任何数据科学问题。自学数据科学一定会让你自给自足。

多做数据探索

完成这些课程后，现在是时候利用这个平台来获得实践技能了。的确，Kaggle 的问题并不代表现实生活中的数据科学问题。是不是意味着学不到有用的东西？肯定不是！在 Kaggle 上可以学到很多关于数据科学的东西。一个如此重要的主题是数据探索。

在大多数项目中，大约 70–80%的时间，数据科学家将致力于执行数据分析。探索性数据分析的学习没有严格的教学大纲。执行数据分析的方法取决于数据集、正在解决的问题、业务提供的输入、在数据中发现的洞察力等等。重要的是要明白没有正确或错误的方法。目标应该是涵盖尽可能多的方面，以发现关键信息。

Kaggle 里有一些学习数据探索的神奇笔记本。它们可以帮助你理解常用的方法和技术。没有人可以通过完成一门课程而成为数据探索方面的专家。要成为专家，尽可能多的练习是很重要的。我将提供一些最佳笔记本的链接，帮助你更好地学习这些概念。

下面的笔记本是一个关于房价数据的综合数据分析笔记本。本笔记本中使用的方法与任何真实世界数据分析中使用的方法一致。它从更好地理解数据开始。单变量分析有助于更好地理解因变量。多变量分析有助于理解因变量和自变量之间的关系。最后，它包括了测试假设的例子，如正态性、同方差性和线性。

https://www.kaggle.com/pmarcelino/comprehensive-data-exploration-with-python

下面的笔记本是关于分析具有不同类型数据的数据集。比如表格数据、文本和图像。这将有助于学习对每种数据类型有用的不同技术。

https://www.kaggle.com/artgor/exploration-of-data-step-by-step

数据科学问题的成功取决于对问题的理解程度。为了更好地理解问题，需要对数据进行适当的分析。执行数据分析并不是一项困难的任务。这通常会耗费时间，诱使人们匆忙进入下一步。不理解就继续前进是一场灾难。

执行完整数据分析的一个最佳方法是在解决数据科学问题时结合首要的思维原则。下面的文章将向你展示在解决一个数据科学问题时如何融入首要原则。

[## 如何用第一性原理思维解决数据科学问题？

towardsdatascience.com](/how-to-use-first-principle-thinking-to-solve-data-science-problems-db94bc5af21)

开始学习算法

在学习了基础知识和数据探索之后，重点可以转移到模型构建上。我见过很多人试图用算法开始学习数据科学。没有打好基础就从算法入手，肯定不是一个好主意。

如果你是数据科学的新手，那么强烈建议你完成下面关于机器学习的短期课程。在那之后，转移到现实世界的问题或 kaggle 竞赛。它将向您展示解决数据科学问题所涉及的步骤。您还可以用它创建一个模板，用于解决任何类似的问题。

模型构建的另一个方面是特征工程。它有助于，

识别正确的特征
转换特征以使其与算法兼容
创建新功能以帮助改进预测
当有大量特征时减少特征

特征工程在提高模型性能方面起着重要作用。下面是一个很好的课程，可以学习更多关于特征工程的概念。同样，这些都不是全面的课程，但它们足以理解核心概念。

了解如何解决不同的数据科学问题

现在，让我向您展示一些 kaggle 笔记本，以了解不同类型的数据科学问题。数据科学中常见的问题有回归、分类、聚类、NLP 和计算机视觉。大多数数据科学项目都可以归入这些类别之一。

学习算法和技术的最好方法是参与项目。下面是一些 kaggle 笔记本，可以帮助你更好地理解这些概念。我在这里选的笔记本都是有据可查的。它将清楚地展示解决不同数据科学问题的标准方法。这里有一个 Kaggle 笔记本，适用于每一个类别，

回归

https://www.kaggle.com/serigne/stacked-regressions-top-4-on-leaderboard

分类

https://www.kaggle.com/startupsci/titanic-data-science-solutions

使聚集

https://www.kaggle.com/kushal1996/customer-segmentation-k-means-analysis

自然语言处理

https://www.kaggle.com/faressayah/natural-language-processing-nlp-for-beginners

计算机视觉

https://www.kaggle.com/yassineghouzam/introduction-to-cnn-keras-0-997-top-6

通过浏览上面的 kaggle 笔记本并逐行执行它们中的每一个，你会学到很多实用的技巧。它将向你展示解决这些问题的方法。这些笔记本大多是由专家写的，因此他们也会教你关于编码标准的知识。

如果你的目标是找一份数据科学方面的工作。那么到这个阶段，你应该已经获得了足够的知识去申请工作。

有哪些不同的竞赛类别？

Kaggle 上有很多比赛。比赛被分为不同的类别。这是一些竞赛类别，

特色比赛

特色比赛是最受欢迎的。这些比赛通常会吸引巨额奖金。它们也吸引了来自世界各地的顶尖人才。这是向专家学习的最佳场所。这些比赛的论坛是金矿。它们包含了大量非常有用的信息。参加特色比赛的先决条件是要有扎实的基础知识。

竞赛入门

这些是最容易接近的竞争。对于刚刚开始使用 kaggle 的人来说，这些是最好的竞争。这一类别的比赛没有任何奖金。这些竞赛的优势在于解决方案有助于学习有趣的技术和方法。

研究竞赛

这些比赛一般和特色比赛一样难。这些比赛一般没有奖金。这些比赛缺乏清晰度，经常让我把它们比作现实世界的问题。

这些是 Kaggle 中的一些标准竞赛类别。这些比赛大多是单阶段的。这意味着数据集和所需的信息都已提供，具有最佳准确性的团队将赢得比赛。有些比赛分为两个阶段。在这两个阶段的比赛中，首先基于初始数据集对参与者进行评估。成功完成第一阶段的人进入第二阶段。第二阶段得分最高的队伍获胜。

充分利用 Kaggle

Kaggle 竞赛经常被与现实世界的数据科学问题相提并论。但是，我的问题是，为什么我们需要将 kaggle 与现实世界的数据科学问题进行比较？为什么我们不能专注于好处，从 kaggle 身上得到最好的东西？而不是等待一个完美的现实世界的问题来工作和学习。

我个人从这个平台上收获了很多。根据我的经验，我将分享一些技巧和技术，它们可以帮助我们充分利用这个平台。去学习数据科学，获得实实在在的收益。

专注学习

在 kaggle 上，最重要的事情是确保专注于学习。至少在你开始使用 Kaggle 的时候。Kaggle 是一个高度游戏化的平台。很容易陷入获得更好排名的循环中。

重点应该是从这个平台学习新的东西。在 Kaggle 上可以学到一些东西，

最适合特定问题或数据集的算法
算法所需的数据转换
增加或减少特征数量的技术
清晰捕捉洞察力和趋势的最佳可视化
最常用的库和包，为什么？

向他人学习

这个平台拥有许多领先的数据科学家。它拥有超过 500 万注册用户。这个平台使得向专家学习成为可能。我不知道有多少其他行业会提供这样的民主水平。这些是可以用来学习的笔记本和论坛。

从以前的比赛中学习并创建模板

所有的历史比赛和提交的解决方案都有。在许多情况下，获胜的解决方案也是共享的。这些对于了解有助于脱颖而出的技术和方法非常有帮助。以前产生良好结果的解决方案可以打包成一个模板，以便用于其他类似的问题。

关注论坛

论坛是学习新事物的最好地方。这是了解数据科学技术方面的好地方。一些通常被讨论的事情是，

错误和可能的解决方案
数据质量问题及其解决方法
提高性能的方法和技术

你没有从 Kaggle 身上学到什么？

尽管了解一个人在 Kaggle 上学到的东西很重要。理解那些我们用 Kaggle 学不到的东西也同样重要。这样其他的方法可以学习和超越这些技能。举个例子，

在 Kaggle 问题中，数据集是结构化的。在大多数真实场景中，数据科学团队收集数据。所需的属性通常是通过与几个业务涉众交谈来确定的。
Kaggle 数据集通常是干净的。因此没有足够的机会学习数据清理技术。
准确性是选择最佳或获胜解决方案的唯一参数。在现实世界的问题中，有几个其他的参数和度量来确定最佳解决方案。100 万美元的网飞竞赛就是一个很好的例子。卡格尔的最佳解决方案比实际的网飞算法好得多。但是，网飞仍然选择不使用它。因为实施获胜解决方案所涉及的工程成本远远高于实际产生的增量效益。

现实世界的项目最好能获得这些方面的经验。自由职业是接触这些领域的一种方式。也为 DataKind 这样的非营利组织工作。

如果你想把你的数据科学技能带到下一个联赛，请查看我的 YouTube 频道中的以下视频。

保持联系

如果你喜欢这篇文章，并对类似的文章感兴趣，在 Medium 上关注我。成为的中级会员，访问数千篇与职业、金钱等相关的文章。
我在我的 YouTube 频道上教授和谈论各种数据科学主题。在这里订阅我的频道。
在这里注册我的电子邮件列表获取更多数据科学技巧，并与我的工作保持联系

现在如何开始数据科学:10 篇顶级文章和一个想法

原文：https://towardsdatascience.com/how-to-get-started-in-data-science-now-10-top-articles-and-one-idea-d9d28ee34cca?source=collection_archive---------13-----------------------

阅读清单

今年对于网络来说是艰难的一年。

照片由来自 Pexels 的克里斯 F 拍摄

你对数据科学感兴趣，却不知道你的下一步该怎么走吗？

你来对地方了

开始一个新的职业可能是最令人兴奋、最令人畏惧和最可怕的挑战之一。无论是出于选择还是出于需要，改变你的生活都是一件大事，值得你给予每一点鼓励和支持。

但是最好的开始方式是什么呢？

(你已经知道我要说什么了。)

联网！

(随便问谁。总是同一个答案。)

理想情况下，你会和那些做过你正在做的事情的人联系起来！通过谷歌搜索的魔力拼凑一份人生计划几乎是不可能的。找到一个在你之前成功走过的人绝对是一个改变游戏规则的人！你会得到意想不到的关注和方向。

不幸的是，说起来容易做起来难。

尤其是现在。

GIF via giphy

没有什么地方比得上家

和其他做过你将要做的事情的人联系可能是最聪明(也是最快)的前进方式之一。但是没有经验怎么做呢？在一个保持距离基本上是生死攸关的世界里，你如何建立关系网？在我们生活的这个勇敢的新世界里，聚会、会议和咖啡店多少有些……受限。

我可能有点偏见，但在我看来，你已经处于世界上向专家学习和建立数据科学联系的最佳位置。走向数据科学充满了数据科学家、机器学习工程师、分析师、程序员、作家、说书人和无数领域的专家。TDS 作者在这里发表文章是因为他们想分享他们学到的东西和他们正在做的事情。

通过阅读这篇文章，你已经是一个想要分享经验、提出概念和讨论想法的社区的一员了。点击评论按钮，几乎每一个在 TDS 上写作的作者都可以联系到。

你在利用这一点吗？

照片由斯凯勒·尤因从派克斯拍摄

我从哪里开始？

开始阅读！多年来，我们发表了许多文章，深入探讨了作为一名新的或有希望的数据科学家，应该学习什么和期待什么。这并没有在 2020 年停止，我们现在仍然很强大。我们今年最受欢迎的文章集中在作为数据科学家的入门、你应该知道的基本概念、你可能考虑的课程和证书以及在面试中会遇到的情况。看一看！

如果你的目标是大联盟，你可能会对这位作者的经历感兴趣，他曾被谷歌招聘人员联系，要求获得一个高级数据科学家的职位。在他的文章中， Roman Orac 研究了为什么谷歌现在联系他，以及他可能会做些什么来实现这一点。

如果你正在考虑换一个数据科学方向，你可能想看看这篇由 Rashida Nasrin Sucky 撰写的文章。Rashida 拥有土木工程背景，并在没有编程经验的情况下开始了职业生涯的转变，他对如何做出转变有着深刻的见解，并分享了他在这一过程中犯的一些错误。

Terence Shin 知道学习统计学并不容易，但是理解统计学概念对于数据科学工作面试来说是必不可少的。在回顾了数百个数据科学面试问题后，Terence 总结了 10 个最常见的问题，并以清晰易懂的方式带您了解这些问题。

</10-statistical-concepts-you-should-know-for-data-science-interviews-373f417e7d11>

在尝试学习如何编程并在成功之前放弃了 10 多次之后， Natassha Selvaraj 对为什么有些人似乎适合编程而有些人不适合有了深刻的见解。这不是你有多聪明的问题！

你有 7.4 秒的时间通过简历的初步筛选。你知道你需要包括什么吗？作为 Riskified 的数据科学副总裁， Elad Cohen 对招聘人员在简历中寻找什么有着深刻的见解。

</7-must-haves-in-your-data-science-cv-9316841aeb78>

“为了让数据科学家向企业交付最大价值，他们需要能够在整个模型开发生命周期中工作。”

在观察了数据科学领域在过去几年中的发展后， Rebecca Vickery 认为，未来最成功的是数据科学通才，并带您了解您需要了解的关键技能。

Sara A. Metwalli 想帮你提升你的投资组合。在这篇文章中，Sara 向你展示了六个最“令人向往的证书，你可以获得这些证书来增加你获得实习或梦想工作的机会。”

</6-data-science-certificates-to-level-up-your-career-275daed7e5df>

基本概念和技术

我们最近发表了非常有用的文章，涵盖了你需要知道的基本数据科学和机器学习概念。到目前为止，我们今年最受欢迎的文章包括 Git 命令、基本统计概念、有用的 Python 函数等主题。

Git 已经从一项不错的技能变成了必需品。你知道最常用的命令吗？Ahmad Abdullah 带你了解(超过)18 条基本命令，这些命令帮助他度过了作为软件开发人员的第一年。

随着您对算法的了解，您会发现许多算法都使用了距离度量。在这篇文章中，Maarten Grootendorst 带你了解九种常见的距离测量方法，检查它们是如何工作的，何时应该使用它们，最重要的是，何时应该避免使用它们。

“知道何时使用哪种距离度量可以帮助你从一个糟糕的分类器变成一个准确的模型。”

</9-distance-measures-in-data-science-918109d069fa>

“当您第一次踏上 Python 领域的旅程时，没有默认的入口可供选择。”

Nishan Pradhan 带你通过一个简单的方法开始学习 Python。通过使用基本的 Python 来自动化 Excel 中的重复任务，您可以节省大量的时间和精力，同时提高您的技能！

深入挖掘

您将会惊讶于数据科学方面的大量信息，这些信息包含了您开始学习数据科学所需要了解的一切。分享这些信息的作者的惊人才华会让你更加惊讶！每天都有新的文章，档案馆里有无数的选择，我强烈建议你去寻找你感兴趣的想法。发现那些作品对你帮助最大的作者，并联系他们。我们的许多作者都过着忙碌的生活，但你可能会惊讶于你可以在舒适的家中建立联系。

你可以在我们的档案中，通过搜索任何你感兴趣的术语，轻松找到你想要的东西。查看我们的专栏，了解介绍性的数据科学概念以及关于在数据科学领域获得工作的更多信息。您还可以探索我们的标签。

那就试着伸出手！

你并不孤单，你正和一群了不起的人在一起。

照片由蒂姆·塞缪尔从 Pexels 拍摄

如果你正在寻找更多像这样的文章，我有一些建议如下。和往常一样，如果你用这些信息做了什么惊人的事情，请在评论中让每个人都知道，并随时在 LinkedIn 上与我联系！

如何在几分钟内开始数据分析

原文：https://towardsdatascience.com/how-to-get-started-with-data-analytics-just-in-a-few-minutes-2a06fe5164d4?source=collection_archive---------37-----------------------

使用 Python 和 Jupyter 笔记本进行数据分析的快速入门—只需要一个浏览器

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

如果你想学习 Python 并且对数据分析或科学感兴趣，你可以从这里开始。你所需要的只是一个浏览器和几分钟。

Jupyter 笔记本

可以通过浏览器在线试用 Jupyter 笔记本。只需访问网站并开始点击尝试 JupyterLab 。

通过 JupyterLab 的 Jupyter 笔记本

对于这个简短的演示，在线版本将提供您需要的一切。稍后，您可能会下载 JypterLab 或通过 Anaconda 发行版安装它。Anaconda 是 Python 的预打包发行版，其中包含许多 Python 模块和包。对于更大的项目，我真的建议在你的笔记本电脑上安装一个稳定的环境，或者通过云来创建、保存和与你的同事分享笔记本。

巨蟒在飞

Python 被用于许多应用，如网站或游戏开发。此外，它也非常受数据科学和分析任务的欢迎。这是吉多·范·罗森发明的。关于 Python 的一些事实是:

与 Java 和 C++不同，Python 不使用大括号来分隔代码。
一个函数可以以元组的形式返回多个值。
Python 支持在一条语句中进行多种赋值。
你可以在他们的官网找到更多信息。

对于数据分析任务，您可以使用 pandas，它是 Python 编程语言的一个程序库，提供了管理和分析数据的工具。

你的第一个项目

您的第一个项目将是从一个 API 获取数据。在这里，我经常使用这些库:

请求— 允许您极其轻松地发送 HTTP/1.1 请求
json — json 库可以从字符串或文件中解析 JSON
熊猫——轻松处理数据

第一步:导入库并获取数据

import requests 
import json 
import time stocks=['AA','AAPL'] 
api_data = dict() 
for i in stocks: 
    rr = requests.get('[https://finnhub.io/api/v1/stock/recommendation?symbol='+i+'&token=bv8v7fn48v6ord6gkqt0'](https://finnhub.io/api/v1/stock/recommendation?symbol='+i+'&token=bv8v7fn48v6ord6gkqt0')) 
    data = json.loads(rr.text) 
    api_data.update({i: data}) 
    time.sleep(2.5)

第二步:将数据加载到熊猫数据框中

从 API 请求 JSON 格式的数据(如上表所示)后，数据被加载到 pandas 数据框中:

第三步:可视化数据

从这里，您可以轻松地处理数据，并在许多可视化库的帮助下将其可视化— 阅读本文中的更多信息。

df = df.pivot(index=’period’, columns=’symbol’, values=’buy’)
df.plot()

瞧，我们有了数据的可视化:

结论

学习 Python 和开始数据分析项目并不需要太多——只需一个浏览器就可以完成。Python、Jupyter Notebook 和各种各样的库是很好的工具集。要深入了解，您可以使用下面的链接。为了更好的理解，你当然可以做一个付费的在线课程，但是我认为从一些编码开始是进入分析世界的最好方式。这里有一个免费学习的好平台。

GIF by GIPHY

资料来源和进一步阅读

https://jupyter.org/try https://pandas.pydata.org/ https://www.learnpython.org/

如何将网站上的表格转换成熊猫数据框架

原文：https://towardsdatascience.com/how-to-get-tables-from-websites-into-pandas-dataframes-e82bd8a0ac59?source=collection_archive---------27-----------------------

从网上获取数据的简单方法

照片由迈克·范·登博斯在 Unsplash 上拍摄

渴望网站上的表格

假设你正在阅读一个维基百科页面，页面上有一个很大的数据表。灵感来了，这正是你可以用在 Python 项目中的东西。但是如何把它放到一个熊猫的数据框架中，以便你能操作它呢？谢天谢地，你可以用 Pandas read_html()功能直接从网上导入表格！

以本文为例让我们使用 维基百科页面的【畅销音乐艺术家排行榜】 。本页包含了一些很好的表格，可能会用于项目分析。

网站上的表格元素

Pandas 中的read_html()函数通过在网站的 html 中查找表格元素来工作。让我们通过查看 Wikipedia 页面上第一个表的代码来看看这意味着什么。如果我们右键单击第一个表格的第一个单元格，并单击“Inspect”选项，该站点的代码将在一个框中弹出。在这段代码中，我们将看到这个表被编码为一个<table>元素。

查看表格的代码(图片由作者创建)

查看表格的扩展代码，您可以看到各种其他元素，如表格标题(<thead>)编码为一行，每个标题(<th>)都有相应的格式。然后您可以看到表体开始(<tbody>)，在这里输入每一行(<tr>)，并为表的每个单元格添加各种数据(<td>)。Pandas 使用 html 代码的这些元素来计算数据应该如何放入数据帧中。

我鼓励您在查看自己感兴趣的站点时，使用灰色箭头进一步扩展代码。更熟悉 html 以了解熊猫如何解析 html 并将其转换成数据帧是很有用的。

将数据带入熊猫体内

现在我们对它的工作原理有了一点了解，让我们实际使用read_html()函数。这非常简单，因为 URL 只是作为字符串传递给函数。

import pandas as pdurl = '[https://en.wikipedia.org/wiki/List_of_best-selling_music_artists](https://en.wikipedia.org/wiki/List_of_best-selling_music_artists)'pd.read_html(url)

在我们的例子中，返回的是一个数据帧列表。它返回一个列表，因为这个 Wikipedia 页面上有几个表格元素。通过索引结果，我们可以检查列表中的每个数据帧。第一个 dataframe 是页面上的第一个表格，用于销售了 2.5 亿张或更多唱片的艺术家。我们可以将它赋给一个变量，然后像处理其他数据帧一样处理它。下面是代码的样子:

url = '[https://en.wikipedia.org/wiki/List_of_best-selling_music_artists](https://en.wikipedia.org/wiki/List_of_best-selling_music_artists)'250_plus = pd.read_html(url)[0]

这是生成的数据帧的样子:

结果数据帧(由作者创建的图像)

在我们的例子中，Pandas 甚至能够使用上面的 html 代码的表格标题元素来解析列标题。如果我们想把文件保存到我们的电脑上，我们可以使用代码250_plus.to_csv(‘250_plus.csv’)，瞧！现在，我们已经从网站上获得了一个保存了表格数据的 csv 文件。

收尾工作

JESHOOTS.COM在 Unsplash 上拍照

预计这种方法需要一定程度的清洁。例如，在我们的例子中，将所有的表合并成一个表是有意义的。这意味着我们需要浏览从网站创建的数据帧列表，为我们想要的每个数据帧创建一个单独的变量，并手动组合它们。

很多时候，您可能还会发现数据解析不那么清晰，并且存在头、空值等问题。如果使用read_html()功能证明任务很困难或不可能，那么你可以使用 web scraper 来代替。通过查看 html 元素，您通常可以预测数据传输的好坏。但是在必须建立网页抓取功能之前，看看read_html()功能是否有效总是值得一试的。

使用该功能时，不要忘记查看 Pandas 文档以获得更多参数或帮助！

如何在简历中加入数据科学的第一点经验

原文：https://towardsdatascience.com/how-to-get-that-first-bit-of-data-science-experience-on-your-resume-80f69fc05ace?source=collection_archive---------26-----------------------

为有抱负的数据科学家解决先有鸡还是先有蛋的问题

我为各种类型的数据科学项目做过大量的教学和指导工作，我的学生在结束时很快遇到的最大挫折之一是经典的第 22 条军规:要获得第一份工作，你需要经验，但唯一能算作经验的是工作。

训练营、课程和在线资源对于获得基本的技术技能非常有用，但雇主想知道你是否真的能在现实世界中处理数据科学项目，而不是用干净的 Kaggle 数据集处理一些明确定义的问题。

梅拉尼娅·索萨在 Unsplash 上的照片

那么，你如何获得第一次体验呢？以下是我的一些学生取得成功的方法:

1.实习

好吧，这个很明显。实习是获得第一点经验的好方法。一些质量较高的实习岗位报酬会相对较高。

然而，作为进入数据科学世界的第一步，它们可能非常具有竞争性，并且不会容易得多。此外，公司通常会寻找仍在攻读学位的学生或刚刚毕业的学生，这意味着对于那些将进入数据科学作为未来职业生涯的人(我的大多数学生)来说，这可能很难实现。

2.在数据组织做志愿者

有许多优秀的社区和组织正在寻找志愿者来帮助技术项目。这些可能是一个很好的开始方式——它们通常涉及到与一个更大的跨学科团队合作，在那里你可以获得解决现实世界问题的经验，并可以向其他人学习。这些项目比简单的学习项目更有分量，因为它们涉及现实世界的问题，这些问题总是混乱而复杂的——不像完美的 Kaggle 数据集那样有明确定义的监督学习问题。

Datakind 将数据志愿者与做社会公益的组织联系起来。美国的代号在各地都有地方部队。你也可以通过 Meetup 找到致力于有趣的数据问题的本地团体。

3.与初创企业合作

小型创业公司(<10 people) often are in the position of having lots of small projects they want someone to tackle so they can shop around a proof of concept to investors. Of course, they are always looking for free labor. This can easily be a win/win — they get a proof of concept, and you get a project for your portfolio that has a real business application.

You can also use this to network. The startup might be more willing to offer you a position if you’ve worked on a project with them already, or might lead to other opportunities as you embed yourself in the startup scene.

The tough part? Getting connected with startups. You can look on meetup 看看你所在的地区是否有创业团体，或者试试联合创始人实验室上的企业家网络。我个人成功的另一个方法是联系在 AngelList 上发布信息的公司。接触小型创业公司(< 10 名员工)，那里可能有更多的灵活性，你可能会直接与首席执行官交谈。

4.构建完整的端到端实时项目

使用 Kaggle 的一些数据构建一个简单的学习项目，并将其上传到 Github 是一回事。打造一个真实的、活的、有用的 app 是另一回事。试着找到一个你真正感兴趣的问题，并且有一些见解，并且能想到一个有用的工具。

举几个例子:我有一个学生使用 Spotify API 创建了一个应用程序，当你输入你的 Spotify 凭据时，它会查看你喜欢的歌曲，并将你与一位似乎符合你音乐品味的音乐评论家配对。很酷，对吧？这更接近于一个完整的项目，而不仅仅是一个在笔记本上训练的模型。

尝试学习一点 Flask 并在 Heroku 上组装一个应用程序。它将展示一些额外的技术技能，并比 jupyter 笔记本中的任何静态内容都好得多。

这些是我发现的帮助人们获得一些超越典型学习项目的经验的资源。有没有对你或你认识的人有效的其他方法？请在评论中告诉我！

如何充分利用谷歌分析专家证书

原文：https://towardsdatascience.com/how-to-get-the-most-from-google-analytics-professional-certificate-875b295d9595?source=collection_archive---------8-----------------------

我对谷歌数据分析专家证书的看法和评论

利亚姆·张在 Unsplash 上的照片

谷歌推出了一项新的教育和职业培训计划，名为“谷歌职业证书”。该公司认为，人们不需要大学文凭来获得就业技能。整个想法听起来很吸引人，但这个计划真的如宣传的那样吗？是也不是。现在就业市场竞争非常激烈。大多数入门级的数据分析师工作需要学士学位和几年的工作经验。此外，许多拥有高等学位的求职者也在参加在线课程，以推进他们的职业生涯，拓宽他们的技能组合。因此，即使谷歌将 6 个月的职业证书视为等同于 4 年的学位，仅凭这一证书可能很难获得数据分析师的职位。然而，我确实认为学生可以从这个项目中学到很多东西。在这篇文章中，我将分享我对每门课程的想法，以帮助您在学习这些课程时更有效地学习。

这真的值得吗？

这真的取决于你的期望。首先你需要意识到的是，有些人完成这个程序需要的时间更少，有些人需要更长的时间。谷歌数据分析专家证书是通过 Coursera 获得的，Coursera 每月收取 39 美元的订阅费。因此，假设您在 6 个月内完成该计划，预计费用为 234 美元。与获得学位或参加训练营相比，价格还不算太低。然而，因为这是一个自定进度的项目，所以确保你有时间和意愿坚持下去是很重要的。

如果你以前没有数据分析经验，希望得到雇主的更多关注，或者试图确定数据分析领域是否适合你，那么这个证书是值得的。如果你已经有了分析学的背景，即使你获得了证书也没关系，但是你仍然可以通过这个项目提高一些技能。

课程设置和重要注意事项

这个项目有八门课程。

1.基础:数据，数据，无处不在:

在本课程中，您将了解数据分析师的日常工作、成为一名成功的数据分析师所需的技能以及数据分析师的职业道路。它很好地解释了什么是数据分析，但如果你已经知道了，我建议加快视频的速度。

2.提出问题以做出数据驱动的决策

我个人对选修这门课感到非常兴奋。作为一名数据分析师/科学家，我注意到数据科学最难的部分之一是提出正确的问题。作为一名数据分析师，最重要的是将数据转化为见解的能力，这种见解可以帮助解决利益相关者的问题。本课程涵盖了有效的提问技巧，可以帮助学生与利益相关者进行更清晰的沟通。

3.为勘探准备数据

数据以各种形式出现。了解不同类型的数据以及如何提取、加载和转换数据非常重要。本课程从涵盖数据类型和数据结构的定义开始；然后提供了如何使用 SQL 处理数据的案例。它还涵盖了数据伦理和隐私的基础知识。您还可以选择学习如何与其他数据专业人员交流。其实人脉在任何领域都是很重要的。这是找到第一份工作的关键。你可以在这里阅读更多关于我获得第一份数据科学工作的建议。

4.将数据从脏数据处理为干净数据

数据清理是在分析数据之前修复/删除重复、缺失值或格式不正确的数据的过程。大多数数据分析师/科学家花费大部分时间(~80%！)清理数据。在这一节中，您将了解脏数据的含义，当没有足够的数据时该怎么办，以及如何使用 SQL 清理数据。最后，本课程的可选主题是在简历中添加数据。您将了解有关如何创建数据驱动型简历和数据分析师招聘流程的更多信息。

大多数数据分析师/科学家每天都与 SQL 打交道，掌握 SQL 技能是必要的。如果您不了解 SQL，本课程将是一个很好的起点。请记住，在面试时，仅仅对 SQL 有基本的了解是不够的。SQL 很容易学，但是特别是当你紧张的时候会很棘手。如果你有兴趣知道什么样的 SQL 概念可能会被问到，看看我之前的帖子。😄

5.分析数据回答问题

本课程包括使用电子表格和 SQL 进行数据处理、数据聚合和数据透视表。Excel 或 Google Sheets 等电子表格软件是小公司广泛使用的数据分析工具。大多数数据分析师使用 Jupyter Notebook、SQL 和 R 进行数据分析。有鉴于此，我建议专注于学习 SQL。本课程涵盖了许多重要的 SQL 语法，如连接和子查询。它还包括许多可供您深入研究的资源，所以不要忘记查看那些推荐的资源。我喜欢这门课的另一点是学习日志电子表格。我发现这个清单格式非常有用。一个最常见的数据分析师面试问题是“告诉我一个你做过的数据分析项目。”——咄！说点我不知道的。

良好的..这不是关于你的项目听起来有多花哨，而是关于项目的影响。回答这个问题的格式确实很重要，下面是格式！回答这个问题时，首先谈谈业务问题或分析的目标，然后谈谈你如何准备、处理和分析数据，最后谈谈你产生了什么影响(也就是这种分析如何影响利益相关者的业务决策。)

Google Analytics Coursera 课程 5 第 4 周——学习日志:完成数据分析清单。(作者截图)

6.通过可视化艺术共享数据

数据故事是将数据点转化为可操作的见解和信息的最佳方式。在本课程中，您将学习设计有效数据可视化的基础知识，以及构建 Tableau 仪表板的基础知识。我强烈建议构建几个 Tableau 仪表板，并在 Tableau 服务器上发布它们。如果你不知道从哪里开始，你可以看看我的 Tableau 作品集这里。

在学习了创建数据可视化之后，您还将学习如何展示您的发现，包括框架和展示技巧。由于数据专家的工作很大一部分是帮助他人理解分析，以及他们如何利用分析结果来制定业务战略和发展业务，因此了解制作优秀演示文稿的技巧有助于更有效地将您的信息传达给受众。

7.用 R 编程进行数据分析

人们经常想知道他们应该首先学习哪种编程语言。R 和 Python 之间的数据科学争论由来已久。毫不奇怪，这是我之前的一次采访。我认为如果你想做更多的统计分析，R 是一个很好的起点，它有很多 Python 没有的很棒的统计包。如果你想做更多的机器学习、深度学习、模型部署，Python 更可取。我认为学习两种语言都有好处，尤其是如果你想在咨询公司工作，因为你永远不知道你的客户更喜欢哪种编程语言。

我喜欢这门课的原因是它涵盖了不同编程语言之间的差异，并且如果你感兴趣的话，它还为你提供了学习这些语言的资源。然而，我认为它们涵盖的基础知识不足以进行更复杂的数据分析。我建议在顶点项目中充分利用你在本课程中学到的知识。

8.谷歌数据分析顶点:完成案例研究

不要跳过这个顶点项目！做顶点工程将允许你把你在整个课程中学到的所有新知识结合起来，并把它应用到实际中去。

最后的想法

谷歌数据分析专业证书是为那些没有经验或经验有限的数据分析。如果你是数据分析的新手，想知道作为一名数据分析师是什么样的，获得这个证书可能会帮助你增加获得数据分析工作的机会。但是，如果你已经有丰富的数据分析经验，我觉得不值得拿这个证书。有些内容非常有趣，我确实看到了选修这门课的价值。如果你不想为证书付费，但仍然想更新一些数据分析方面的知识，我建议你参加这个课程。请记住，证书不能帮助我们找到工作。招聘经理和招聘人员喜欢看申请人的简历，然后决定是否让你的申请进入下一轮。

我希望这篇文章能帮助你确定在学习这门课程时应该关注的最重要的事情。如果你觉得这很有帮助，请关注我，看看我的其他博客。敬请关注更多内容！❤

</10-tips-to-land-your-first-data-science-job-as-a-new-grad-87ecc06c17f7> </10-questions-you-must-know-to-ace-any-sql-interviews-2faa0a424f07>

如何充分利用机器学习模型

原文：https://towardsdatascience.com/how-to-get-the-most-of-the-machine-learning-models-f973b25ee482?source=collection_archive---------16-----------------------

我从 Kaggle 身上学到的提高最终模型性能的经验。每种评估策略的优缺点以及何时使用都包括在内。

与其他卡格勒相比，我的表现🤔—作者图片

介绍

向别人学习，从他们停下来的地方开始，这是一种优秀的品质。还有，我承认任何问题的解决方案都是好好理解，然后判断不同的解决方案，直到得到一个稳定的最终方案。

自从两年前在 Kaggle 上开设账户以来，我的数据科学和机器学习技能取得了显著进步。这样的进步来自于竞争或者阅读其他卡格勒的笔记。然而，每当我提交了一份意见书，我从来没有得到公共董事会。我开始质疑自己。这是为什么呢？我想做更多的调查，并了解其他 kagglers 如何获得更高的分数——他们认为在不过度拟合的情况下提高模型准确性的程序。

我从阅读其他竞争对手的笔记本开始，以了解他们解决问题的方式。然后，在开发最终模型时，我在不同的阶段推断了许多这些见解。最有帮助的策略之一是评估每个训练测试分割策略。本文将讨论分割数据集和评估模型性能的常用策略。

先决条件

本文假设您熟悉以下内容。

用 python3 编写一个基本循环。
如果你想跟进，可以访问 google colab
统计术语的基本知识
sklearn，pandas，matlibplot 库的基础知识
拥有 Kaggle 帐户-使用 API 下载数据集
不同机器学习算法如何工作的基本知识。
一杯咖啡😎开始吧！

与本文相关的笔记本在 Github 上，如果你想继续的话。此外，我还使用了 kaggle 上著名的皮马印第安人糖尿病数据集。我已经包含了从 Kaggle API 获取数据集到 colab 这里的完整脚本。

什么是模型评估？

模型评估是一组程序，允许您选择最可能稳定的模型。这是模型开发过程的重要部分。它揭示了模型的行为及其预测能力，表明了对未知数据的偏差和方差之间的平衡。首先，将给定的数据集分成训练集和测试集。模型将学习使用训练集进行预测；相比之下，我们将利用测试集来评估模型的性能。

用于拆分的方法

考虑到属性可能具有的特殊特征，有不同的策略来拆分数据并确保做到公平。例如，如果原始数据在要素之间存在不平衡，则预测可能会有偏差，因此对于每种情况，可能会推荐一种特定的方法。

本文涉及的主要方法如下:

列车测试分离
交叉验证
留下一个交叉验证，LOOCV

列车测试分离

使用 sklearn 的常规训练测试分割——图片由作者提供

这是一种以特定百分比将数据集分成两半的方法。这既简单又快捷。当比较不同的算法来决定你可能考虑哪一个时，它可能是合适的。

sklearn 中的 train_test_split 方法。model_selection 模块被广泛用于分割原始数据集。常见的分割比例是 80/20 或 70/30。

您可以按照上述相同的拆分比例将训练集拆分为训练集和验证集— Stackoverflow 讨论

我在这里使用了分层，因为原始数据集在目标类中有一个不平衡——500/268。

# set the seed to keep code reducibility
seed = 7# Apply the splitting
x_train, x_test, y_train, y_test = train_test_split(
              X, y, 
              test_size = 0.33,     
              stratify = y, #to keep class balance during splitting
              random_state = seed 
)
model = LogisticRegression(max_iter=1000)
model.fit(x_train, y_train)
result = model.score(x_test, y_test)
print(f'accuracy is: **{**result*100.0**:** 0.3f**}**')

得到的精度为:76.378

优点:

易于实施
快速执行，更少的计算时间

缺点:

如果分割不是随机的，则精确度不准确
如果原始数据集的数据点有限，这可能是拟合不足的原因。

k 倍交叉验证

k 倍分裂程序—作者图片

为了提高模型的准确性，避免常规拆分数据的弊端，我们需要在拆分过程中加入更多的泛化功能。在这个策略中，我们随机多次重复 train _ test _ split。对于每次拆分或折叠，都会计算精确度，然后算法会汇总每次拆分计算出的精确度，并对其进行平均。这样，所有数据集点都参与了模型精度的测量，这样更好。

对于这个例子，我们将使用 sklearn 库中的RepeatedStratifiedKFold()来评估模型，因为它在每次迭代中使用不同的随机方案重复分层折叠 n 次。

from sklearn.model_selection import RepeatedStratifiedKFold
from scipy.stats import sem
import numpy as np
import matplotlib.pyplot as pltcv_repeated = RepeatedStratifiedKFold(
    n_splits = 10,
    n_repeats = 16,
    random_state = seed
)scores_r = cross_val_score(
     model,
     X, y,
     scoring = 'accuracy',
     cv = cv_repeated,
     n_jobs = -1
)print('Accuracy: %.3f (%.3f)' % (scores_r.mean(), scores_r.std())))

得到的精度为:0.775 (0.042)

访问每个褶皱的模型精度

为了更好地做出判断，对估计值的分布进行更多的调查是一个好主意。

**# evaluate a model with a given number of repeats**
def asses_model(X, y, repeats):
 **# define the cv folds** 
  cv = RepeatedStratifiedKFold(
             n_splits=10, 
             n_repeats=repeats,  
             random_state = seed)
 **# create the model**  model = LogisticRegression(max_iter=1000)
 **# evaluate model**  scores = cross_val_score(
             model, 
             X, y, 
             scoring = 'accuracy', 
             cv = cv, 
             n_jobs=-1)
  return scores

然后我们将使用scipy库中的sem()方法来计算每个样本的标准误差。

repeats = range(1, 16)
res = list()
for rep in repeats:
  scores = asses_model(X, y, rep)
  print('Sample_%d mean=%.4f se=%.3f' % (rep, np.mean(scores), sem(scores)))
  res.append(scores)

为了更好地理解结果，让我们用箱线图来直观显示样本精度

跨拆分的准确性—图片由作者提供

橙色线表示精度分布的中值，而绿色三角形表示算术平均值。

如上图所示，模型精度稳定在 6 和 7 左右，这是要利用的折叠数( 0.775 (0.042)精度)。

优点:

更高的精度
更好地处理阶级不平衡。
欠拟合的可能性更小

缺点:

更容易过度拟合，所以我们需要监控折叠的精确度。
更高的计算能力和更多的执行时间。

留一交叉验证

遗漏一个交叉验证—图片由作者提供

在这种策略中，该算法为每个训练折叠选取一个数据点，并在建模训练时将其排除。验证集因此用于计算模型的准确性；然后对每个训练文件夹重复此过程。平均每个折叠精度后，计算出最终精度。

在这个策略中，我们为数据中的 n 个观察值创建 n-1 个模型。

from sklearn.model_selection import LeaveOneOut
loocv = LeaveOneOut()
model = LogisticRegression(max_iter=1000)
res = cross_val_score(model, X, y, cv = loocv)
print('Accuracy: %.3f (%.3f)' % (np.mean(res), np.std(res)))

得到的精度为:0.776 (0.417)

优点:

在数据集有限的情况下非常有效，因为我们希望在拟合模型时使用尽可能多的训练数据。
对于单个新数据点，它具有可能的最佳误差估计。

缺点:

计算开销很大。
如果数据集很大。
如果测试许多不同的参数集。

测试是否使用 LOOCV 的最佳方法是运行 k 值较大的 KFold-CV—考虑 25 或 50** ，并估计训练模型需要多长时间。**

要点和结束语

我们探索了最常用的策略来有效地训练机器学习中的模型。每种方法都有其优点和缺点；然而，当我们选择一个的时候，有一些提示可以考虑。

k 倍交叉验证是比较不同算法性能的经验法则，大多数 k 倍是 3、5 和 10。
从常规的训练测试分割开始，以获得特定算法的估计性能的基本事实。
留下一个交叉验证-LOOCV 是一种确定性估计，其中没有对训练数据集进行采样。另一方面，其他策略遵循随机估计。
当你需要准确估计性能时，LOOCV 可能是合适的。

感谢阅读！

最后，我希望这能对评估机器学习模型的常用方法给出全面的指导。如果你有任何问题，请在评论区列出来；我很乐意帮忙。联系我最好的方式是在中LinkedIn或 Github 。快乐学习！****

如何获得最大限度的 ML 合奏

原文：https://towardsdatascience.com/how-to-get-the-most-of-the-ml-ensembles-ef576c7e6e66?source=collection_archive---------17-----------------------

Kaggle 的经验:比较集成算法在模型准确性、鲁棒性和泛化能力方面的差异。包含实现！

集合方法——作者图片

介绍

我们之前讨论过一些利用机器学习(ML)模型预测能力的常用方法。这些方法主要用于通过将数据分成特定的方案来提高模型的概化能力。

构建不带系综的典型 ML 模型的典型步骤—图片由作者提供

然而，有更先进的方法来提高模型的性能，如集成算法。在这篇文章中，我们将讨论和比较多种集成算法的性能。所以，让我们开始吧！

集成方法旨在组合多个基本估计量的预测，而不是单个估计量的预测，从而利用模型的通用性和稳健性。

更新 02/13/2021:在 sklearn.ensemble 模块中包含 StackingClassifier()类链接。

先决条件

我将使用 UCIML 公共存储库中的玩具数据集，该库托管在 Kaggle 上的；它有九列，包括目标变量。如果你想继续关注的话,笔记本在 GitHub 上。
在笔记本上工作时，我利用了 Kaggle API 来获取数据集。如果你在 Kaggle 上没有账户，只需在本地机器上下载数据集，跳过笔记本中的这一部分。你可以在 StackOverflow 上关注这篇文章，获得一步一步的指导。

我在 google colab 中包含了获取和下载数据的脚本，只需确保在运行之前生成自己的令牌。

3.在建立模型之前，我对数据集做了一些基本的预处理——比如输入缺失的数据，以避免错误。

4.我创建了两个独立的笔记本，一个用来比较前三个合奏。第二个包括从零开始的堆叠系综的实现和使用 MLens 库。

合奏方法

集合方法——作者图片

集成是建立各种模型，然后混合它们以产生改进的预测的过程。与单个模型相比，集成能够实现更精确的预测。在大联盟比赛中，利用合奏通常会给获胜队带来优势。可以找众筹赢家面试——团队四重奏，用合奏赢得比赛。

1.打包—引导汇总:

Bootstrapaggregating倾向于从不同的子样本中构建多个模型(使用相同类型的算法),并替换训练数据集。

Bagging 就是将几个好的模型进行集成，减少模型方差。

BaggingThank 直觉并行处理—图片由作者提供

Bagging 有以下三种类型:

1.2 包装决策树

Bagging 在产生高方差预测的算法中表现最佳。在下面的例子中，我们将在 sklearn 库中开发结合了 DecisionTreeClassifier()的 BaggingClassifier()。

请注意，由于随机学习的性质，结果可能会有所不同！

装袋生产模型并平行分割样品。

**from** sklearn.ensemble **import** BaggingClassifiertree = DecisionTreeClassifier()
bagging_clf = BaggingClassifier(base_estimator=tree, n_estimators=1500, random_state=42)
bagging_clf.fit(X_train, y_train)

evaluate(bagging_clf, X_train, X_test, y_train, y_test)**TRAINIG RESULTS:** 
===============================
CONFUSION MATRIX:
[[350   0]
 [  0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
               0      1  accuracy  macro avg  weighted avg
precision    1.0    1.0       1.0        1.0           1.0
recall       1.0    1.0       1.0        1.0           1.0
f1-score     1.0    1.0       1.0        1.0           1.0
support    350.0  187.0       1.0      537.0         537.0
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[126  24]
 [ 38  43]]
ACCURACY SCORE:
**0.7316**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.768293   0.641791  0.731602    0.705042      0.723935
recall       0.840000   0.530864  0.731602    0.685432      0.731602
**f1-score**     **0.802548**   **0.581081**  0.731602    0.691814      0.724891
support    150.000000  81.000000  0.731602  231.000000    231.000000

1.2 随机森林(RF)

随机森林(RF)是一种元估计器，它在多个子样本上拟合不同的决策树分类器，并估计平均精度。

子样本大小为常量，但如果 bootstrap=True(默认)，则样本被抽取并替换。

现在，让我们试一试随机森林(RF)模型。RF 的工作方式类似于袋装决策树类；但是，它降低了单个分类器之间的相关性。 RF 仅考虑每次分割的随机特征子集，而不是遵循贪婪方法来挑选最佳分割点。

**from** sklearn.ensemble **import** RandomForestClassifier

rf_clf = RandomForestClassifier(random_state=42, n_estimators=1000)
rf_clf.fit(X_train, y_train)
evaluate(rf_clf, X_train, X_test, y_train, y_test)**TRAINIG RESULTS:** 
===============================
CONFUSION MATRIX:
[[350   0]
 [  0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
               0      1  accuracy  macro avg  weighted avg
precision    1.0    1.0       1.0        1.0           1.0
recall       1.0    1.0       1.0        1.0           1.0
f1-score     1.0    1.0       1.0        1.0           1.0
support    350.0  187.0       1.0      537.0         537.0
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[127  23]
 [ 38  43]]
ACCURACY SCORE:
**0.7359**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.769697   0.651515  0.735931    0.710606      0.728257
recall       0.846667   0.530864  0.735931    0.688765      0.735931
**f1-score     0.806349**   **0.585034**  0.735931    0.695692      0.728745
support    150.000000  81.000000  0.735931  231.000000    231.000000

1.3 额外树木— ET

额外树(ET)是套袋的一种改进。ExtraTreesClassifier()是来自 sklearn 库的一个类，它创建一个元估计器来拟合各种子样本的几个随机决策树(也称为 ET)。然后，ET 计算子样本间的平均预测值。这允许提高模型的精度和对过拟合的控制。

**from** **sklearn.ensemble** **import** ExtraTreesClassifier

ex_tree_clf = ExtraTreesClassifier(n_estimators=1000, max_features=7, random_state=42)
ex_tree_clf.fit(X_train, y_train)
evaluate(ex_tree_clf, X_train, X_test, y_train, y_test)**TRAINIG RESULTS:** ===============================
CONFUSION MATRIX:
[[350   0]
 [  0 187]]
ACCURACY SCORE:
1.0000
CLASSIFICATION REPORT:
               0      1  accuracy  macro avg  weighted avg
precision    1.0    1.0       1.0        1.0           1.0
recall       1.0    1.0       1.0        1.0           1.0
f1-score     1.0    1.0       1.0        1.0           1.0
support    350.0  187.0       1.0      537.0         537.0
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[124  26]
 [ 32  49]]
ACCURACY SCORE:
**0.7489**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.794872   0.653333  0.748918    0.724103      0.745241
recall       0.826667   0.604938  0.748918    0.715802      0.748918
**f1-score     0.810458   0.628205**  0.748918    0.719331      0.746551
support    150.000000  81.000000  0.748918  231.000000    231.000000

2.助推

Boosting 是构建多个模型的另一种技术(也来自同一类型)；然而， 每个模型学习在模型序列中修正前一个模型的预测误差 。Boosting 主要用于平衡 监督机器学习模型 中的偏差和方差。Boosting 是一种将弱学习者转化为强学习者的算法。

Boosting 设法从弱估计量开始依次建立基础估计量，然后降低组合估计量的偏差。

作者在序列图像中增强集成

2.1 AdaBoost (AD)

AdaBoost (AD)通过对特征进行分类来对数据集实例进行加权。这使得算法能够在构建后续模型时考虑这些特征。

**from** **sklearn.ensemble** **import** AdaBoostClassifier

ada_boost_clf = AdaBoostClassifier(n_estimators=30)
ada_boost_clf.fit(X_train, y_train)
evaluate(ada_boost_clf, X_train, X_test, y_train, y_test)**TRAINIG RESULTS:** ===============================
CONFUSION MATRIX:
[[314  36]
 [ 49 138]]
ACCURACY SCORE:
0.8417
CLASSIFICATION REPORT:
                    0           1  accuracy   macro avg  weighted avg
precision    0.865014    0.793103  0.841713    0.829059  0.839972
recall       0.897143    0.737968  0.841713    0.817555  0.841713
f1-score     0.880785    0.764543  0.841713    0.822664  0.840306
support    350.000000  187.000000  0.841713  537.000000  537.000000
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[129  21]
 [ 36  45]]
ACCURACY SCORE:
**0.7532**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.781818   0.681818  0.753247    0.731818      0.746753
recall       0.860000   0.555556  0.753247    0.707778      0.753247
**f1-score     0.819048   0.612245**  0.753247    0.715646      0.746532
support    150.000000  81.000000  0.753247  231.000000    231.000000

2.2 随机梯度推进(SGB)

随机梯度推进(SGB)是一种先进的集成算法。在每次迭代中，SGB 从训练集中随机抽取一个子样本(无替换)。然后利用子样本来拟合基本模型(学习者),直到误差变得稳定。

**from** **sklearn.ensemble** **import** GradientBoostingClassifier

grad_boost_clf = GradientBoostingClassifier(n_estimators=100, random_state=42)
grad_boost_clf.fit(X_train, y_train)
evaluate(grad_boost_clf, X_train, X_test, y_train, y_test)**TRAINIG RESULTS**: 
===============================
CONFUSION MATRIX:
[[339  11]
 [ 26 161]]
ACCURACY SCORE:
0.9311
CLASSIFICATION REPORT:
                    0           1  accuracy   macro avg  weighted avg
precision    0.928767    0.936047  0.931099    0.932407  0.931302
recall       0.968571    0.860963  0.931099    0.914767  0.931099
f1-score     0.948252    0.896936  0.931099    0.922594  0.930382
support    350.000000  187.000000  0.931099  537.000000  537.000000
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[126  24]
 [ 37  44]]
ACCURACY SCORE:
**0.7359**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.773006   0.647059  0.735931    0.710032      0.728843
recall       0.840000   0.543210  0.735931    0.691605      0.735931
**f1-score     0.805112   0.590604**  0.735931    0.697858      0.729895
support    150.000000  81.000000  0.735931  231.000000    231.000000

3.投票

投票是一组同样表现良好的模型来平衡它们的弱点。投票使用三种投票程序，硬、软和加权。

硬投票 —大部分类标签预测。
软投票 —预测概率之和的 argmax 。
加权投票 —预测概率加权和的 argmax 。

投票组合—图片由作者提供

投票简单易行。首先，它从数据集创建了两个独立的模型(可能更多，这取决于用例)。然后使用投票分类器来包装模型，并在引入新数据时平均子模型的预测。

**from** sklearn.ensemble **import** VotingClassifier
**from** sklearn.linear_model **import** LogisticRegression
**from** sklearn.svm **import** SVC

estimators = []
log_reg = LogisticRegression(solver='liblinear')
estimators.append(('Logistic', log_reg))

tree = DecisionTreeClassifier()
estimators.append(('Tree', tree))

svm_clf = SVC(gamma='scale')
estimators.append(('SVM', svm_clf))

voting = VotingClassifier(estimators=estimators)
voting.fit(X_train, y_train)

evaluate(voting, X_train, X_test, y_train, y_test)**TRAINIG RESULTS:** 
===============================
CONFUSION MATRIX:
[[328  22]
 [ 75 112]]
ACCURACY SCORE:
0.8194
CLASSIFICATION REPORT:
                    0           1  accuracy   macro avg  weighted avg
precision    0.813896    0.835821  0.819367    0.824858  0.821531
recall       0.937143    0.598930  0.819367    0.768037  0.819367
f1-score     0.871182    0.697819  0.819367    0.784501  0.810812
support    350.000000  187.000000  0.819367  537.000000  537.000000
**TESTING RESULTS:** 
===============================
CONFUSION MATRIX:
[[135  15]
 [ 40  41]]
ACCURACY SCORE:
**0.7619**
CLASSIFICATION REPORT:
                    0          1  accuracy   macro avg  weighted avg
precision    0.771429   0.732143  0.761905    0.751786      0.757653
recall       0.900000   0.506173  0.761905    0.703086      0.761905
**f1-score     0.830769   0.598540**  0.761905    0.714655      0.749338
support    150.000000  81.000000  0.761905  231.000000    231.000000

4.堆垛

堆叠—作者图片

堆叠与投票合奏的工作原理相同。然而，堆叠可以控制 顺序调整子模型预测的能力 -作为元模型的输入，以提高性能。换句话说，叠加从每个模型的算法生成预测；随后，元模型使用这些预测作为输入(权重)来创建最终输出。

堆叠的优势在于，它可以结合不同的强大学习器，做出比任何独立模型都精确和稳健的预测。

sklearn 库在 ensemble 模块下有 StackingClassifier()，你可以在这里找到链接。然而，我将使用 ML-Ensemble 库实现堆栈集成。

为了在叠加和之前的集合之间进行公平的比较，我使用 10 倍重新计算了之前的精度。

**from** mlens.ensemble **import** SuperLearner***# create a list of base-models***
**def** get_models():
	models = list()
	models.append(LogisticRegression(solver='liblinear'))
	models.append(DecisionTreeClassifier())
	models.append(SVC(gamma='scale', probability=**True**))
	models.append(GaussianNB())
	models.append(KNeighborsClassifier())
	models.append(AdaBoostClassifier())
	models.append(BaggingClassifier(n_estimators=10))
	models.append(RandomForestClassifier(n_estimators=10))
	models.append(ExtraTreesClassifier(n_estimators=10))
	**return** models**def** get_super_learner(X):
  ensemble = SuperLearner(scorer=accuracy_score, 
                          folds = 10, 
                          random_state=41)
  model = get_models()
  ensemble.add(model)
**# add some layers to the ensemble structure** ensemble.add([LogisticRegression(), RandomForestClassifier()])
  ensemble.add([LogisticRegression(), SVC()])
**# add meta model**
  ensemble.add_meta(SVC())
  **return** ensemble***# create the super learner***
ensemble = get_super_learner(X_train)
***# fit the super learner***
ensemble.fit(X_train, y_train)
***# summarize base learners***
print(ensemble.data)
***# make predictions on hold out set***
yhat = ensemble.predict(X_test)
print('Super Learner: **%.3f**' % (accuracy_score(y_test, yhat) * 100))

使用超级学习者类进行堆叠—图片由作者提供

ACCURACY SCORE ON TRAIN: 83.24022346368714   
ACCURACY SCORE ON TEST: 76.62337662337663

比较性能

**import** plotly.graph_objects **as** gofig = go.Figure()
fig.add_trace(go.Bar(
              x = test['Algo'],
              y = test['Train'],
              text = test['Train'],
              textposition='auto',
              name = 'Accuracy on Train set',
              marker_color = 'indianred'))fig.add_trace(go.Bar(
              x = test['Algo'],
              y = test['Test'],
              text = test['Test'],
              textposition='auto',
              name = 'Accuracy on Test set',
              marker_color = 'lightsalmon'))fig.update_traces(texttemplate='%{text:.2f}')
fig.update_layout(title_text='Comprehensive comparasion between ensembles on Train and Test set')
fig.show()

集成性能比较条形图——训练集与测试集在准确性指标上的比较——图片由作者提供

如图所示，堆叠集成在测试集上表现很好，最高分类准确率为 76.623%。太好了！

4.结论和要点

我们已经探索了几种类型的集成，并学会了以正确的方式实现它们，以扩展模型的预测能力。我们还总结了一些需要考虑的要点:

叠加法在准确性、鲁棒性方面有所提高，并得到了更好的推广。
在这种情况下，当我们想要建立同样表现良好的模型来平衡它们的弱点时，我们可以使用投票。
助推是一个伟大的合奏；它只是将多个弱学习者组合起来，得到一个强学习者。
当您希望通过组合不同的好模型来生成一个方差较小的模型时，您可以考虑 Bagging 减少过度拟合。
选择合适的组合取决于业务问题和你想要的结果。

最后，我希望这给出了一个关于实现合奏的全面指南，并从中获得最大收益。如果你遇到任何问题，请在评论区列出来；我很乐意帮忙。鼓励我的最好方式是在 Medium ，LinkedIn，或 Github 上关注我。快乐学习！

如何充分利用计算机科学学位

原文：https://towardsdatascience.com/how-to-get-the-most-out-of-a-computer-science-degree-4bfb3bba8859?source=collection_archive---------9-----------------------

确保你充分利用大学时光的 7 条建议

卡尔·海尔达尔在 Unsplash 上拍摄的照片

获得学位需要大量的时间、金钱、汗水和眼泪。

然而，仅仅完成一个计算机科学学位已经不够了。

你为了一个职位而面对的数百名候选人中的每一个人都将拥有和你一样的学位和大致相同的技能。

为了在毕业时找到工作，你需要充分利用找工作前的四年时间。你需要在大学期间利用这段时间来确保你在毕业时脱颖而出。

方法如下:

1.把你的计算机科学学位和其他东西联系起来。

如果你有时间管理技巧、兴趣和能力，你应该考虑把你的计算机科学学位和其他东西结合起来。

拥有编码的能力是很棒的。如果能够在一个环境中编写代码，并在一个你实际了解的行业中解决问题，那就更好了。

编程不再是 IT 和软件行业的专利。随着对软件、网站、IT 服务和数据分析的需求变得对保持竞争优势至关重要，计算机科学毕业生正被各个行业所雇用。

虽然房间里的大多数候选人都有编程经验，但只有那些在特定行业有经验并能理解该行业面临的一些问题的人才会让雇主眼前一亮。

在接受彭博快客采访时，Ivana Seric 描述了她独特的数学博士背景，加上她在大学期间是 NCAA 级篮球运动员，如何帮助她成为费城 76 人队的数据科学家。作为一名大学水平的运动员，她对篮球有着深刻的理解，再加上她拥有数学研究生学位，这使得她从竞争该职位的其他候选人中脱颖而出。

这个例子可以应用到你的计算机科学学位上。通过把它和一些让你与众不同的东西搭配起来，你让雇主很难拒绝你的申请。

2.参加活动，拓展你的人脉。

我通过和大学里认识的人保持联系，找到了毕业后的第一份工作。

一天，一位大学同事突然在 LinkedIn 上给我发消息说，他们工作的公司正在寻找一位具有我这种技能的人来完成合同工作。一次简短的面试后，我被这家公司聘为顾问。

在一个越来越多的人拥有学士学位的世界里，利用现有关系获得毕业后的第一份工作变得至关重要。裙带关系仍然存在，尽管它从来都不是一件好事情，但这是世界的方式。因此，你在大学的时间是扩大你的人际网络和建立联系的最佳时间，这些联系可能会在以后的道路上带来回报。

虽然参加社交活动对一些人来说听起来像是一种折磨，但在这些活动中应用的相同原则可以用在你的日常大学生活中，以确保你在你的网络中增加联系。在您的课堂上结交一些朋友，与您的导师互动，并在顶点项目期间与行业专业人士联系。

虽然带着一张非常昂贵的纸离开你的大学项目是最终目标，但也应该带着一份充满同学、导师和行业专业人士的联系名单，他们可能会在未来帮助你。

3.专注于开发实用的编程技能。

计算机科学学位侧重于大量的理论知识，这些知识支持并解释了为什么某些东西可以工作，而其他东西不能。换句话说，理论知识解释了你的代码为什么能工作或者为什么不能工作。

然而，一旦你进入职场，这些理论知识并不像你想象的那么有用。

2007 年的一篇著名文章描述了当一个看起来像开发人员、走路像开发人员、能像开发人员一样谈论理论的开发人员不能编码时产生的怀疑。文章继续描述了大多数计算机科学毕业生在解决臭名昭著的“嘶嘶-嗡嗡”编码问题时是如何被难住的。作者进一步描述了即使是自称的高级开发人员也很难在不到 15 分钟的时间内写出这个简单问题的解决方案。

这篇文章的要点是:不要成为无法解决“嘶嘶-嗡嗡”编码问题的计算机科学毕业生。

严肃地说，这个故事的寓意是，作为一名计算机科学学生，如果你想在毕业后找到一份开发人员的工作，你就需要会编程。这意味着你需要在大学期间专注于开发实用的编程技能。换句话说，你不能只是说说而已。你需要学会走路。

4.研究招聘信息，这样你就知道雇主在寻找什么。

技术变化很快。

比如超快的。

就像这样快，某一天技术可能是“进”的，第二天就“出”了。

不幸的是，计算机科学学位的变化没有那么快。如果说有什么不同的话，那就是计算机科学学位往往落后于时代。

因此，你必须定期研究招聘信息，这样你才能知道雇主在寻找什么样的候选人。

当你毕业后申请开发人员职位时，你不想太晚意识到你需要精通一堆在大学里从未教授过的新技术。此外，这些工作中的许多都在寻找在这些技术方面有几年经验的开发人员。为什么不在大学期间学习这些技术，并利用它们建立一些项目，这样你就可以证明你有必要的技术经验，成为对公司有用和有贡献的成员。

许多毕业生认为，需要特定语言经验的整个概念是需要严格的就业经验。然而，大多数雇主会认为个人使用和表现出的语言熟练程度足以取代受雇经验。

因此，了解雇主在你感兴趣的行业中寻找什么样的技术和技能，并投入一些个人时间来学习这些技术。这是一项保证会有回报的投资。

5.不要忽视发展你的软技能。

软技能让我在毕业后找到了第一份工作。

虽然我需要一个技术背景来了解正在发生的事情和公司试图完成的事情，但我用来完成工作和完成工作的是软技能。

在大学里，看到所有的课程都集中在你想要精通的技术上，这可能是令人兴奋的。当然，您希望成为最优秀的开发人员(或者至少是毕业班的)。

然而，当需要与数百名其他申请人竞争一个初级开发人员职位时，你的软技能将使你脱颖而出。其他每个申请人都将能够编写干净的代码，将获得计算机科学学位，并将能够顺利通过白板面试会议。但是有多少申请人实际上拥有对雇主有用的还过得去的软技能呢？

当我在大学学习软件开发时，大约 25%的课程是商务沟通和组织行为学，这给了我毕业后找到第一份工作所需的软技能。

换句话说，不要忽视软技能。参加一些课程，让你成为一名全面发展的开发人员，这对你最终工作的公司的成功至关重要。你会惊讶地发现，雇主会多么欣赏你写一份精美商业计划书的能力，或者你向众人发表演讲的能力。

6.通过实习、兼职和咨询工作来获得成功。

在我的毕业班中，大多数毕业后找到工作的人都在大学期间实习过。

没有比向雇主展示你在该领域的实习、兼职或咨询工作经验更好的进入该行业的方法了。

不仅如此，你在大学期间可以找到的这些类型的工作是你毕业后在这个行业是否快乐的重要指标。如果你意识到科技行业不适合你，换专业并不丢人。正如老话所说，如果你对自己的工作感到满意，你一生中就不会有一天是在工作。这是你应该瞄准的目标。

许多人会建议，在你攻读学位的每一年都去实习是最理想的。虽然我部分同意这一点，但我也认为你需要考虑几个因素，包括实习是否有报酬(顺便说一下，是时候取消无报酬的实习了)，他们希望你工作多长时间，你是否能平衡你的课程和实习相关的工作，以及实习是否真的会给你的简历增色。

不管怎样，没有比在大学里更好的时间来迈出你的第一步了。这些最初的经历将会给你带来回报，让你在毕业后找到工作。

7.立即开始你的专业作品集。

职业投资组合正迅速成为雇主在给你打电话面试之前考虑你能力的标准。

专业作品集是向雇主展示你作为候选人的成长的最好方式之一，也是展示你能够将所学应用到现实生活中的最好方式之一。

因此，你必须尽快开始你的投资组合。

首先建立一个 LinkedIn 个人资料、一个个人网站、一个 GitHub 个人资料和知识库，甚至一个博客(最好是在媒体上——没有比向你未来的潜在雇主解释你每月如何获得报酬更好的方式了，因为人们发现你的博客帖子信息丰富、有用且质量高)。

在你大学的第一年开始这个文件夹，每当你完成一个新的项目或者当你学习一个新概念的时候，把它添加进去。通过展示学习的进展，你将向潜在的雇主展示你愿意踏上特定职业的自我教育之旅。

最后的想法。

当你充分利用计算机科学学位时，它是无价的。

事实是，虽然计算机科学专业的毕业生与其他专业相比失业率较低，但毕业后仍然很难找到工作。

因此，不要浪费你在大学的四年时间仅仅为了获得学位而学习。充分利用它，这样到你毕业的时候，雇主就不可能拒绝你了。

如何获得熊猫数据帧的行数

原文：https://towardsdatascience.com/how-to-get-the-row-count-of-a-pandas-dataframe-be67232ad5de?source=collection_archive---------3-----------------------

探讨如何更有效地获取熊猫数据帧的行数

照片由斯蒂夫·约翰森在 Unsplash 上拍摄

介绍

在今天的简短指南中，我们将讨论几种计算熊猫数据帧行数的方法。此外，我们将展示如何在导出计数时忽略空值。最后，我们将观察本文中介绍的每种方法的性能，并确定计算行数的最有效方法。

首先，让我们创建一个示例数据框架，我们将在本指南中引用它来演示一些概念。

import pandas as pddf = pd.DataFrame({
    'colA':[1, 2, None, 4, 5], 
    'colB': [None, 'b', 'c', 'd', 'e'],
    'colC': [True, False, False, True, None],
})print(df)
   *colA  colB   colC
0   1.0  None   True
1   2.0     b  False
2   NaN     c  False
3   4.0     d   True
4   5.0     e   None*

使用 len()

计算数据帧行数最简单明了的方法是使用len()内置方法:

>>> **len(df)**
5

请注意，您甚至可以通过df.index来稍微提高性能(在本文的最后一节中有更多相关内容):

>>> **len(df.index)**
5

使用形状

或者，您甚至可以使用[pandas.DataFrame.shape](https://pandas.pydata.org/pandas-docs/version/0.24.2/reference/api/pandas.DataFrame.shape.html)，它返回一个表示数据帧维度的元组。元组的第一个元素对应于行数，而第二个元素表示列数。

>>> **df.shape[0]**
5

您也可以解包df.shape的结果并推断行数，如下所示:

>>> **n_rows, _ = df.shape**
>>> n_rows
5

使用 count()

在计算 pandas 中的行数时，第三个选项是[pandas.DataFrame.count()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.count.html)方法，即返回非 NA 条目的计数。

假设我们想要计算某一列下没有空值的所有行。以下内容应该对我们有用:

>>> **df[df.columns[1]].count()**
4

只有当您希望忽略空值时，才应该使用此方法。如果不是这种情况，那么您应该使用len()或shape。

表演

现在我们已经知道了一些计算数据帧中行数的不同方法，讨论它们对性能的影响会很有意思。为此，我们将创建一个比我们在本指南中使用的数据帧更大的数据帧。

import numpy as np
import pandas as pd df = pd.DataFrame(
    np.random.randint(0, 100, size=(10000, 4)),
    columns=list('ABCD')
)print(df)
       *A   B   C   D
0     61  38   2  39
1     96  65  20  47
2     35  56  97   8
3     71  31  80  25
4     20  63  99  34
   ..  ..  ..  ..
9995  96  81   6  43
9996  43  22  83  47
9997  62  92  42  26
9998  11  48  91  85
9999  55  47  77  66
[10000 rows x 4 columns]*

为了评估性能，我们将使用[timeit](https://docs.python.org/3/library/timeit.html),这在对少量 Python 代码计时时很有用。

>>> **%timeit len(df)**
**548 ns** ± 24.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)>>> **%timeit len(df.index)**
**358 ns** ± 10.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)>>> **%timeit df.shape[0]
904 ns** ± 48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)>>> %timeit df[df.columns[1]].count()
**81.9 µs** ± 4.91 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

从上面的结果我们可以看出熊猫中最高效的行数计算方法是 **len()** 方法。通过提供索引( **len(df.index)** )甚至更快。

效率最低的方法是 **count()**，因此，只有在需要从计数中排除空条目时，才应该使用这种方法。

最后的想法

在今天的文章中，我们讨论了如何使用

len()
shape
和count()

方法。注意count()应该只在你想忽略某些列的空行时使用。最后，我们讨论了这些方法在性能方面的差异。

成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。

你可能也会喜欢

https://betterprogramming.pub/11-python-one-liners-for-everyday-programming-f346a0a73f39

如何在数据分析中“脱身”

原文：https://towardsdatascience.com/how-to-get-unstuck-in-data-analysis-9d4f7ab32179?source=collection_archive---------41-----------------------

作为一名数据分析师，我学到了一些东西

你有没有过看着数据用头撞墙的经历？我也是。当我开始每天处理数据时，当我碰壁时，我的策略是恐慌和/或压力进食。(我也不推荐。)

照片由 Elisa Ventur 在 Unsplash 上拍摄

下面我整理了一些在这些令人沮丧的情况下对我有用的策略，希望其中至少有一个对你也有用。

数据与预期不符？

1。如果你的“期望”来自别人的数据分析，那就问他们问题。

关于您要比较的数据集，一些重要的问题:

这个数据的来源是什么？
我们是否知道该数据源的任何限制(例如，数据中是否包含一些场景)？
数据集的时间范围和提取日期相似吗？如果不是，数据的波动性有多大？

斯蒂芬·菲利普斯-Hostreviews.co.uk 在 Unsplash 上拍摄的照片

2。仔细检查你的数据清理/格式化。

格式上的差异可能会带来很多问题:前导/尾随空格、数据类型的差异、文本字段的大小写或拼写的差异、舍入问题等。我建议在比较之前对两个数据集进行一些探索性的数据分析，以便在一开始就发现这些问题。

3.在完成所有的基础之后，挑战预期。

有时候，在你开始之前，你的利益相关者就已经有了数据分析的结果。如果你已经检查了你的过程，可能是时候推后并质疑他们期望的来源了，尤其是如果他们没有具体的数据来支持的话。(当然要把这个留到最后——你不会想推回去却发现你的公式在某处不正确。)

由弗兰基·查马基在 Unsplash 上拍摄的照片

想不出自己的错误？

1.快速休息一下。

我数不清有多少次，在工作中或在学校里，我离开一些我搞不清楚的分析，然后回来迅速发现我的错误。有时候，不看屏幕会有助于理清思路。

2.在网上寻找有同样问题的人。

Firmbee.com在 Unsplash 上拍照

这听起来是显而易见的，但是谷歌搜索确实是一门艺术。我会将错误信息中最重要的部分，连同我正在使用的软件或编码语言的名称，复制并粘贴到 Google 中，大多数时候有人会在在线论坛上询问这个问题。利用你正在使用的软件或语言的在线文档也很重要。当你得到一个错误信息时，不要只是举手或者立即联系更了解这个程序的人。

3.变得有条理。

无论是在代码中添加注释，清理文件结构，还是将过程分成逻辑组，“有条理”有助于更容易识别错误。列出你的分析或模型的假设也可以帮助你找出弱点。

4.试着向朋友/同事解释你的过程。

照片由米米·蒂安在 Unsplash 上拍摄

当我和一个同事(和我同级)一步一步地分析 zoom 时，很多时候我会发现自己的错误。当我不这样做时，他或她通常会发现。如果你们两个都不知道，也许是时候去见见你的经理或某个主题专家了。

坐在电脑前等待处理完成？

照片由迈克·范·登博斯在 Unsplash 上拍摄

1.尝试使用数据的子集。

你能从一个更小的数据集开始分析吗？这可能是一个很好的默认技术，因为通过少量的数据样本，您可以轻松地检查流程中不同步骤的结果。或者，你可以把你的分析分成几部分，这样如果第 5 步失败了，你就不会浪费时间去执行第 1-4 步了。

2.如果可以，优化处理能力。

关闭其他程序，确保本地机器有足够的内存和磁盘空间。如果可能的话，我喜欢使用云计算，因为通常你可以访问比笔记本电脑更好的计算资源。根据您所使用的软件/代码，可能有一些方法可以使您的过程更加高效，而不是像

最后，深呼吸。你得到了这个。

照片由艾娃索尔在 Unsplash 拍摄

想拖延解决问题的时间吗？查看我的一些其他文章:

https://megandibble.medium.com/

如何让您的公司为数据科学做好准备

原文：https://towardsdatascience.com/how-to-get-your-company-ready-for-data-science-6bbd94139926?source=collection_archive---------26-----------------------

办公时间

如何在您的公司中利用数据科学

由弗兰基·查马基在 Unsplash 上拍摄的照片

如今，许多公司都在试图成为数据驱动的，甚至是人工智能驱动的。数据科学、机器学习和人工智能(AI)是关于公司数字化转型的几个最主要的术语。有人可能认为这些技术可以解决任何商业问题。在企业内部，数据科学家通常被视为“数字奇才”，他们能够将数据顺利转化为可操作的见解和运行良好的推荐系统。当谈到数据科学项目的需求和可预期的结果时，期望和现实之间存在差距，尤其是非技术人员。是的，这些技术非常强大，是的，数据科学家可以为企业带来巨大的好处，但这两者都只有在特定的条件下才有可能。

在这篇博文中，我将调查这些条件，并展示在企业中成功运行数据科学项目所需的关键促成因素。

IT 基础设施

数据科学并不能为所有类型的业务问题提供答案，在应用数据科学之前，必须有坚实的基础。如果设置不当，企业内部的 IT 基础设施可能会成为数据科学项目的绊脚石。下图描述了数据科学基于需求的层次结构:

数据科学需求层次(图片由作者提供)

数据收集是金字塔最原始的需求，由软件工程师建立。当然，实际收集的数据取决于公司的流程和产品。例如，在面向用户的产品中，我们会收集关于用户如何与我们的产品交互的所有信息。在这种情况下，我们将通过生成用户数据的应用程序直接检索数据。数据源也可以是安装在机器、建筑物、车辆、设备上的传感器，或者是我们想从中获取数据的任何地方。

下一阶段需要解决移动&存储收集的数据。这意味着公司内部的数据工程师必须确保数据能够可靠地在系统中流动。在实践中，实现端到端的数据连续性是一个主要问题，如果从一开始就没有正确设置，就很难实现。由于大多数数据科学项目都包括某种类型的模型拟合，因此我们应该已经在这个阶段考虑了这种互连的架构，以确保训练数据集可以随着新数据的收集而不断更新。

一家公司有不同的数据存储选项:

内部数据存储

由组织自己拥有和管理的服务器
最大程度地控制网络和数据
需要构建和维护 IT 基础架构
硬件:硬盘(价格合理，性能良好)，固态硬盘(最高性能，最高成本)

托管数据存储:

异地保存的数据存储(在数据中心或云提供商处)
云通常比本地托管选项更便宜
可扩展，能够适应业务需求
敏感数据的存储需要关注，数据控制是一个问题，需要具体问题具体解决
AWS、GCP 或 Azure 等云提供商在其生态系统中提供了大量技术，可以将原始数据转化为有意义的见解、产品或服务

混合数据存储:

对非敏感数据使用外部提供程序
本地存储敏感数据

此外，公司将需要决定如何实际管理他们的数据。整合不同来源数据的传统解决方案是数据仓库。数据仓库的架构非常好，可以创建一个清晰、一致和高性能的模型，业务用户可以轻松地使用它来获得洞察力和做出决策。随着数据成为价值最高的资产，像数据科学家这样的新角色开始出现，从数据中寻求价值。这个新角色要求数据探索和转换具有敏捷和特别的性质，这推动了数据湖的创建。数据的探索&转换是数据科学家为了更好地理解数据而要做的第一步。它包括争论数据，为数据科学过程的下一步做准备。数据湖变得越来越受欢迎，因为它们可以处理来自多个来源的大量数据，利用 Spark 等新技术，实现预测分析、推荐系统、图表分析等新型数据分析。

要考虑的关键方面是，数据科学家可以一致地链接数据，而无需付出很大努力。这要求所有相关数据集都存储在一个地方，或者可以通过适当的应用编程接口(API)进行链接。如果组织中的系统之间没有定义适当的 API，这将降低数据科学项目的速度，并阻止数据科学家高效工作。这是因为数据科学家将大部分时间投入到架构讨论中，寻找实现(半)自动化数据管道的工作区，而不是应用核心数据科学技术。

上层阶段聚合&标记、学习&优化、和建模代表了数据科学的核心部分。它们包括定义指标、为机器学习模型构建特征、应用统计技术、开始用干净的输入数据训练算法、评估结果，以及(希望)部署模型或将分析结果传达给利益相关者等活动。

数据文化

拥有强大数据文化的公司始终依靠数据来做出决策。数据驱动文化的概念将数据视为洞察组织每个部门的主要资源。目的是让员工能够主动查询和使用数据。这需要访问数据、数据治理、关于如何分析数据的方法知识，以及前面提到的适当的基础设施。

数据是数据科学的原材料。如果没有数据，就无法应用数据科学技术。当我们想要利用数据科学时，我们需要主要关注两件事:数据量和数据质量。

数据量

进行实质性分析所需的数据量取决于问题、选择的技术和项目的整体设置。对于高级机器学习技术，我们通常需要大量数据来拟合模型。机器学习模型是用特征来训练的。如果要素数量增加，精确概化所需的数据量将呈指数增长。为了理解这一点，我们需要对维度及其与算法的关系有一个概念。

在下图中，每个方框代表一个数据点。假设我们在一维特征空间中训练算法，因此仅考虑特征 X 用于训练。让我们假设五个数据点对于我们的用例是足够的。现在，如果我们添加特性 Y，我们将需要 25 个盒子来保持我们需要的相同的“数据密度”,因为覆盖是进行学习所必需的。如果我们添加另一个功能，我们将需要 125 个盒子用于训练等等。这就是所谓的维度诅咒。

维度的诅咒(作者图片)

这就是为什么我断言你永远没有足够的数据，因为更多的数据产生更好的结果的可能性非常高。更多的数据简化了噪声的处理，为我们的结果提供了更高的可信度。

数据质量

结果的有效性更多地取决于数据的质量而不是数量。垃圾输入/垃圾输出:更多的垃圾只是返回对错误事物的更好的估计。这就是为什么数据科学家总是需要非常了解底层数据。如果他们没有(因为他们是组织中的新人或者在不同的项目之间切换)，那么他们将需要与对这些数据有深刻理解的专家密切合作。

脏的、低质量数据的原因是多方面的:

用户输入错误
遗留系统
数据迁移
编码标准应用不当/程序员错误
不断发展的应用

我们可以从以下几个方面来衡量数据质量:

有效性:符合一个模式
精度:符合黄金标准数据
完整性:数据集包含所有记录
一致性:数据集与其他数据集(来自其他来源)一致
一致性:数值使用相同的测量单位

熟练员工

数据驱动型组织需要高技能员工。数据科学领域是动态的，发展非常迅速，而作为事实上的标准的技术，例如用于大规模数据处理的 Spark，十年前甚至还不存在。数据科学需要结合计算机科学、数学、统计学和领域知识。

数据科学，一个跨学科领域(图片由作者提供)

数据科学从业者通常需要以非技术的方式在演示文稿中传达他们的核心信息和发现，以便更广泛的受众能够理解它们。相应地，公司可能也想寻找具有强大沟通技能的数据科学家。

上述技能的结合是罕见的，公司很难吸引和留住这些人才。显然，第一个挑战是支付数据科学家，因为他们在各行各业都有巨大的需求。根据就业网站实际上的数据，在美国，数据科学家的平均年薪为120，334 美元。在欧洲，平均工资较低，视国家而定。据 Glassdoor 报道，德国一名数据科学家的平均工资为€每年 6 万。在英国，平均工资是 53628 英镑，在法国，€是 45198 英镑。在欧洲，瑞士的薪资最高，超过€的 88400 欧元。

然而，要想让数据科学家留在你的组织中，除了高薪还有更多的事情要做。数据科学家离职是因为现实往往与他们的预期不同。他们寻找有意义和有挑战性的项目来利用他们的技能。很多时候，数据科学家成为任何与数据相关的事情的关键人物，并不断被打断他们实际的数据科学工作。这导致员工感到沮丧，因为编写琐碎的 SQL 查询通常不是数据科学家认为的理想工作。与此同时，许多数据科学家属于 Y 一代，他们正在积极寻找自己角色的意义。他们的工作需要符合他们的个人价值观，千禧一代比以往任何一代人都需要管理者更频繁的反馈和沟通。

此外，数据科学家需要与志同道合的人不断交流，讨论新技术、特定项目、实现他们的模型的挑战等等。如果他们孤立地工作，他们将成为孤独的战士。此外，在许多非科技公司，这类职位没有合适的职业发展路径。其他配置文件确实有这些清晰的路径。例如，在项目管理领域，你可能从 PMO 开始，然后得到你自己的第一个项目，直到你成为高级项目经理。在大多数情况下，数据科学家并不存在明确的道路，这种缺乏发展可能性的情况会导致沮丧和离开的意愿。

企业战略

除非你在硅谷地区的科技公司工作，否则人工智能和数据科学很有可能不是你公司战略的组成部分。这对一些公司来说可能绝对没问题，因为并不是每个公司都有望成为科技行业的领导者。然而，如果您的公司正在进行数字化转型，目标是成为数据驱动的组织，那么这些主题及其促成因素对未来至关重要。问题是，在演示文稿上写下这些流行语并假装利用所有新技术很容易，但深入理解这对组织来说实际上意味着什么，并确定人工智能如何帮助加快流程并实施这些技术以减少耗时、重复的任务是一个更大的挑战。

93%具有两位数有机增长的高增长公司计划在未来一到三年内将人工智能实施到他们的业务中，但 94%的企业难以理解如何在其组织中实施人工智能。资料来源:Udacity

在许多公司，业务领导通常不是极客或数据科学家，因此与他们的“数字”员工没有共同语言。然而，企业战略是由企业领导定义的，并通过不同的层级进行级联。这些策略对整个组织及其员工的日常工作有着巨大的影响。但是，在不理解其基本概念的情况下，商业领袖应该如何为一家现代化、数字化、人工智能公司设定路线？简单的回答是:他们不能。但是每个人都可以提高技能，而且有很多这样做的机会。

例如， Udacity 为人工智能、云计算和数据科学领域的商业领袖提供纳米学位。在这些课程中，企业领导学习这些技术的基础、实际应用，并遍历一系列业务案例研究，以找到特定业务场景的最佳解决方案。这些程序是为没有任何编程经验的人设计的，他们需要做出战略决策并评估提议。

提升管理技能的另一种方式是反向指导。通常情况下，导师应该比他的学员更资深、更有经验。在逆向指导中，初级员工与更资深、更有经验的员工甚至经理建立“职业友谊”。反向指导认识到双方都存在技能差距，每个人都可以从对方的优势中学习。年轻员工可以将新技能和想法传授给年长员工，并从其学员成为榜样或职业教练中受益。

关键要点

转变公司以利用新技术是一项具有挑战性的任务，只有满足一些关键条件才能奏效。让我总结一下为现代数据驱动型组织奠定基础的最重要的几个方面:

IT 基础设施:数据科学家需要一个专业的工作环境来利用新技术。正确的数据收集、存储和数据探索工具是实现数据科学的最基本需求。
数据文化:员工和决策者关注现有数据传达的信息，而不是依靠他们的直觉。数据被视为关键资产。
熟练员工:数据科学家是声誉良好的员工，公司需要支付合理的薪水，并为他们提供有意义的项目。
企业战略:企业领导人需要理解这些新技术的核心概念，以便将它们纳入企业商业模式的战略定位。

https://www.forbes.com/sites/forbesagencycouncil/2019/10/01/the-age-of-analytics-and-the-importance-of-data-quality/#2e39afc5c3c4 https://www.matillion.com/resources/blog/5-key-differences-between-a-data-lake-vs-data-warehouse/ https://coopsys.com/data-storage-options-for-your-small-business/ https://www.forbes.com/sites/bernardmarr/2016/06/15/building-your-big-data-infrastructure-4-key-components-every-business-needs-to-consider/#a04611e577e7 https://www.intouchsol.com/blog/six-must-steps-optimal-machine-learning-data-science/ https://www.wsj.com/articles/companies-take-a-piecemeal-approach-to-automation-tech-11554396270 https://sloanreview.mit.edu/projects/artificial-intelligence-in-business-gets-real/

没有任何工作经验如何获得数据科学的第一份工作

原文：https://towardsdatascience.com/how-to-get-your-first-job-in-data-science-without-any-work-experience-37e33fad41b4?source=collection_archive---------35-----------------------

创造力、勇气和毅力将成为你赖以生存的三个词

图片来自 Pixabay

无论你是刚毕业的学生，正在寻找职业改变的人，还是和上面这只猫类似的猫，数据科学领域充满了几乎符合现代工作者清单上每一个方框的工作。在数据科学领域工作让你有机会获得工作保障、有晋升空间的高薪，以及在世界任何地方工作的能力。基本上，对于感兴趣的人来说，在数据科学领域工作是一件很容易的事情。

然而，在可怕的求职过程中，我们中的许多人都会遇到类似的情况:

图片由 9GAG

是啊，看起来很眼熟。

我自己遇到过很多这样的情况，公司经常在 22 岁之前寻找有 20 年工作经验的候选人，我理解当你是一名新毕业生、一个想改变职业的人、甚至是一只没有相关工作经验的猫时，试图找工作带来的烦恼。

然而，这不是气馁的理由。虽然许多数据科学工作需要工作经验，但有很多方法可以创造自己的工作经验，让你成为这些职业的合格候选人。

你所需要的只是一点创造力、勇气和毅力。

这不是你知道什么的问题。而是你认识谁，谁认识你。

在与加拿大类似的国家，拥有某种形式的大学资格正成为常态(2016 年，54%的 25 至 64 岁加拿大人拥有学院或大学证书)，现在不再是你知道什么的问题了。而是你认识谁，谁认识你。

用谷歌搜索“网络的重要性”，你会被所有主要参与者的文章淹没(福布斯，赫芬顿邮报，事实上，等等。)为什么社交是你职业生涯中最重要的事情之一。福布斯说得好:

“网络不仅是交易信息，也是建立互利的长期关系的途径。”比安卡·米勒·科尔，福布斯

虽然人际关系网是获得如何在特定职业中获得成功的内部知识的一种非凡方式，但它也可以在以后的道路上成为一种互利的关系。

我的第一份科技工作是通过与一位大学同事保持关系获得的。我们是在最后四个月的实习中认识的。毕业后，我们一直保持联系。差不多两年后，我收到一条消息，说他们工作的公司有兴趣雇用我为他们做一些工作。由于保持了这种关系，我在没有任何工作经验的情况下找到了毕业后的第一份工作，这要感谢我的同事推荐了我。

换句话说，在你读大学的时候交几个熟人，参加社交活动，和那里的人交谈，让招聘人员知道你的名字，这些都很重要。

成为一名作家，为个人博客或主要出版物投稿。

数据科学家是天生的故事讲述者，因为他们有能力将海量数据集转化为引人注目的可视化数据，从而向大众讲述故事。正因为如此，有抱负的数据科学家应该写下他们的工作，向未来的雇主展示他们的沟通技巧，这才有意义。

许多数据科学家吹捧在 Medium 这样的平台上开博客或写作的好处。尽管许多人说，写作的好处并不仅限于让你更快乐、更无压力——写作还将有助于你的数据科学事业。

正如我上面提到的，成为一个讲故事的人和一个全面可靠的沟通者，是数据科学家的基本技能，只有在实践中才能提高。例如，通过向公众解释您的数据分析结果，您开始用任何人都能理解和欣赏的简单术语来思考数据。正如理查德·费曼曾经说过的，“我不能把它降低到大学一年级的水平。这意味着我们真的不了解它。”写作不仅会让你成为更好的沟通者，还会让你对数据科学概念有更深的理解，从而让你成为更好的数据科学家。

然而，写作的好处不止于此。

作为一名未来的数据科学家，你写的文章会成为你专业作品集的一部分，让招聘人员了解你对特定概念的理解。他们不仅能够看到你已经建立了一批信任和重视你的工作的人，而且还能够看到你愿意贡献知识来促进其他数据科学家的生活和事业。此外，在一个为你的工作支付报酬的网站上发布信息会告诉招聘人员，人们非常重视你的知识，你实际上是为此而获得报酬的。

这里有一些资源可以激发你的写作灵感:

成为一名自由职业的数据科学家，建立自己的咨询业务。

海军陆战队队员说得好:随机应变，适应，克服。

与其不断打一场硬仗，不如随波逐流，创建自己的数据科学咨询业务。

我从经验中知道，当你投了一百份简历，得到的却是拒绝信和沉默，这是多么令人沮丧。所以，如果没人愿意雇佣你，那就雇佣你自己吧！

自由职业很容易成为人们为了赚钱所能做的最可怕的事情之一，而且它肯定不适合每个人。然而，这是一个公平的选择，而不是连续几天拿头撞墙，等待潜在雇主给你回复(或者不回复)。

如果你有技能和信心，为什么不接受一些自由客户呢？这是双赢的局面。你不必经历招聘过程中的痛苦和磨难，就能获得现实世界的经验(请注意，做自由职业者可能会有同样多的痛苦和磨难，这就是为什么它不适合所有人)。雇佣自己的好处在于，如果由于积累的现实经验，你最终得到了一家梦寐以求的公司的工作邀请，你可以随时离开自由职业。

但是谁知道呢？也许你最终会真正享受自由职业的生活。在我看来，如果你无法通过传统的方式找到工作，那就值得赌一把。

做你自己的项目来展示你的才华。

如果你问我“数据科学”的定义，我会总结为一个专注于解决问题和收集信息的跨学科领域。因此，雇主不想雇佣任何没有解决任何问题或者不能从数据集中得出任何结论的人是有道理的。

通过创建自己的项目，你向雇主展示了你天生的好奇心和动力，这是数据科学家在工作中取得成功所必需的。不仅如此，科技行业的许多雇主都要求看你的项目组合，这样他们才能在雇佣你之前看到你的工作质量。

现在比以往任何时候都更容易找到免费的数据集来构建项目。以为我在开玩笑？我最后一次检查时，在 Kaggle 上有 67862 个数据集可供任何人使用。这是大量的数据。

此外，快速搜索将引导您找到数百篇充满不同数据科学项目的文章，从而激发您的灵感。这里有几个让你开始。

</12-data-science-projects-for-12-days-of-christmas-aff693f5ed2b> </12-cool-data-science-projects-ideas-for-beginners-and-experts-fc75b5498e03>

实习生、志愿者或做公益工作来获得宝贵的行业经验。

有时候，获得必要工作经验的最好方法就是免费做这些工作。没有人喜欢无偿工作，但是在一个经常要求你在 22 岁之前有 20 年工作经验的世界里，无偿工作通常是你求职成功的门票。

实习、志愿服务或做公益工作是获得许多公司正在寻找的必要工作经验的三种最佳方式。这些“工作”不仅能让你利用真实世界的数据获得真实世界的经验，还能让招聘经理看到你是一名团队成员，你是在没有报酬的情况下辛苦获得工作经验的。此外，你可能会有机会创造有意义的解决方案，并在此过程中对许多个人和社区产生积极影响。如果你工作的公司愿意在你的 LinkedIn 个人资料上写一篇热情洋溢的评论或一封推荐信来补偿你，那就更好了！

最后的想法。

对于任何进入一个新领域的人来说，无论是应届毕业生、寻求职业改变的人，还是一只学会打字的猫，缺乏工作经验都是一个令人生畏的问题。

然而，只要你愿意，有无数的机会让你获得工作经验。幸运往往偏爱勇敢的人，对于那些希望在新领域获得成功的人来说，这一点更是如此。

通过练习一点创造力、勇气和毅力(也可能是一些耐心)，你将会顺利地找到第一份梦寐以求的数据科学工作。

如何给你的 Python 代码带来魔力

原文：https://towardsdatascience.com/how-to-give-your-python-code-a-magic-touch-c778eeb9ac57?source=collection_archive---------4-----------------------

构建一个强大的多项式引擎，方便学习和研究

图片来自维基共享资源

在本文中，我将向您展示如何用 Python 构建一个学习多项式的工具。

此外，这个工具使用起来应该很直观，感觉就像 Python 自带的内置类型。

我们将使用所谓的邓德方法一起做这件事。

介绍

几年前，我发现了一种有趣的多项式。

我想研究它们的特性，但没有工具来适当地探索它们。有了技术武装，我将通过构建这样一个工具来进行战斗。

在我们构建它之前，让我们快速回顾一下 Python 的 double-under 或“dunder”方法。

神奇的方法

邓德方法，有时被称为魔法方法，是以两个下划线开始和结束的类的方法。

这些方法模拟了 Python 的内置功能，比如使用关键字 len 、 + 、 with 等。

为了更好地理解这一点，让我们构建一个表示多项式并支持 Python 语法的类。

描述一个多项式所需的最少信息量是多少？是系数的问题，不是吗？

让我们尝试以下方法:

我们肯定需要系数，其余的只是为了展示。系数只是作为以常数项开始的类构造函数的参数给出。我们将为多项式赋予默认名称 f ，当然我们可以在实例化对象时更改它。

str

说到“显示”，让我们确保用户在打印多项式时看到有用的东西。我们将在上面添加一个名为 str 的 dunder 方法。

来自 str 方法的输出就是你打印出你的对象时所看到的。如果你的类中没有这个方法，那么你只能打印出你的类名，这可能没什么用。

不要太担心方法的内容，一会儿你就会看到它做了什么。

现在，我们能够打印出我们期望看到的多项式。当然，您可以根据自己的需要进行更改，请注意，我们也有一个 repr dunder，它属于同一个系列，但更适合开发人员而不是用户。

作者图片

这很好，但是我们还没有真正对多项式做任何事情。为了给这个类增加一些功能，让我们编写代码来实现多项式的加、减、乘、除以及其他有趣的运算和功能。

len

我们想这样做的方法是使用 dunder 方法来获得工具的直观性。具体来说， len 方法将让我们使用内置的 len 函数来显示多项式的某种长度。在这种情况下，我选择使用术语的数量作为度量。

getitem

当你分割一个列表或者获取第 n 个元素时，你使用 list[n]语法。我们可以对多项式做同样的事情。在这种情况下，我决定我们应该得到第 n 个系数。

_ _ eq _ _ ,_ _ add _ _ ,_ _ sub _ _ ,_ _ mul _ _ _，以及 floordiv

以上方法分别对应=， + ， - ， ***** ， // ，唯一需要说明的方法可能是 floordiv 方法，我决定实现这个方法是因为可能要做多项式除法。

我只返回商，而不是余数，如果它应该是非零的。我们也可以选择使用 truediv dunder 方法，但是我认为在这种情况下划分楼层更有意义。

为了更好地理解这一点，您应该亲自试验一下代码。现在，让我们将上述方法添加到我们的类中:

多项式作为函数

我们现在有很多选择。

注意，现在 Python 理解了如何通过使用符号 + 来添加多项式，例如，这给了它在编写代码时更自然的感觉。毕竟，我们现在能够像写数学一样写它。

让我们添加一些功能来实现差异化。

我们将实现一个 prime property 方法和一个更通用的 n 次微分方法，称为 diff 。我们相应地更改名称，以帮助用户跟踪不同的对象。

因为 prime 也返回一个多项式对象，我们的其他方法也处理导数，使我们能够很好地打印出来，并继续处理它。

我们还将添加一个名为 negating_shift 的方法。

我们需要这种方法的原因与我在本文开头提到的研究有关。该方法将采用多项式 f(x) 以及实数α，并返回相应的多项式 f(α - x)。

现在，如果一个多项式不能被调用，它会是什么呢？

我们需要使它成为一个函数对象，它应该能够像我们使用任何其他函数一样计算实数和复数。

让我们将所有这些也添加到模块中。

到目前为止的完整代码:

现在我们可以用一个简单的方法来区分 n 次。还要注意，现在我们可以像调用多项式所代表的函数一样调用它们了！

这要感谢 call dunder 方法。

零和图

我们肯定希望能够找到根，我们也希望能够显示多项式的图形，现在我们有了根，我们也可以找到函数的局部最小值和最大值。

能够显示根在复平面中的位置也是有用的。

因此，我们也可以为此添加方法:

请注意，我们可以更改作为参数的轴的大小。这在某些时候可能会很方便。

现在我们可以得到根或零，也可以得到漂亮的显示和图形。我们在下面看到，单位的 5 根在复平面上构成一个五角星。

显示屏上的点是多项式的复数零点。

到目前为止，我们已经有了很多不错的 Pythonic 功能。我将在未来添加更多的像判别式，因式分解等。在此期间，是时候学习我最初想学习的多项式类了。

这将是一篇单独的文章，因为这篇文章会变得太长。

您可以在这里获得完整的代码:

https://github.com/KRBM/PolynomialEngine/

如果您有任何问题、意见或顾虑，请联系 LinkedIn:

https://www.linkedin.com/in/kasper-müller-96ba95169/

如何像专业人士一样从原始数据走向生产

原文：https://towardsdatascience.com/how-to-go-from-raw-data-to-production-like-a-pro-1f79394c4ddd?source=collection_archive---------21-----------------------

关于使用合成数据提高数据质量和使用 MLOps 交付模型的探索

机器学习和人工智能这两个概念在过去十年中绝对改变了我们的思维方式，在未来几年中可能会发生更大的变化。但是，我们也知道谈论机器学习时的陈词滥调— “垃圾进，垃圾出”。这是不可否认的事实，人工智能解决方案的关键因素是在正确的时间用正确的数据持续改进。

听起来很容易，对吧？但是，如果我告诉您，在正确的时间获取正确的数据并使之成为现实仍然存在许多挑战，那会怎么样？尤其是将数据驱动的应用程序投入生产时。

本文解释了如何通过利用 YData 的合成数据开源工具包来提高数据质量，并确保使用 UbiOps 平台快速轻松地部署，ubi ops 平台是数据科学代码的服务和交付环境。

什么是合成数据？

让我们从基础开始，数据质量可以定义为数据如何准确、完整、一致、可靠，最重要的是，数据是否是最新的。数据是基础，正如下图中的好的和旧的 DIKW 金字塔所描述的那样，在基于机器学习的项目中尤其有效-如果我们没有好的数据，那么我们就不可能有好的信息。

总之，对于数据科学项目来说，及时了解数据的质量可以“决定成败”。

数据金字塔或大多数人所知的 DIKW。来源

在 YData，数据科学团队非常重视数据质量。非常严肃地说，YData 围绕这个概念建立了一个完整的平台。它从访问数据到探索和处理，是综合数据生成的核心特征之一。

合成数据可以成为帮助组织提高数据质量的强大盟友。但是如何？

从它的名字，我们很容易理解它指的不是从现实世界收集的数据，而是由计算机生成的数据。数据合成新技术的最大好处是，生成的数据保持了真实世界的属性。可以使用各种不同的方法生成合成数据，然而，当谈到高质量的合成数据时，我们寻找的是生成的数据，它保留了真实数据的实用性、保真度和可靠性，同时保持了隐私合规性。这就是新的方法论所提供的，如变分自动编码器或生成对抗网络。

为什么要为改进的模型训练合成数据？

来自真实世界事件的数据具有广泛的应用，可帮助数据科学团队改进其现有数据集，减少相关和敏感数据的访问时间，并无缝缓解隐含的偏见问题:

原型开发:收集和建模大量的真实数据是一个复杂而乏味的过程。生成合成数据使数据更快可用。除此之外，它可以帮助更快地迭代 ML 计划的数据收集开发。
边缘情况模拟:通常可以看到，收集的数据并不包含对模型性能产生负面影响的所有可能场景。在这种情况下，我们可以通过人工生成来包含那些罕见的场景。
数据集扩充，偏差&公平性:并非所有时候我们都有所需的数据量，或者在其他情况下，我们可能会处理某些类别中的代表性不足问题。自动化决策会使这些问题变得更糟，但合成数据是缓解这些问题的一个很好的选择。
数据隐私:合成数据是确保数据隐私的绝佳方式，同时能够共享微数据，允许组织共享敏感和个人(合成)数据，而无需担心隐私法规。

什么是机器学习操作？

机器学习操作(MLOps)的核心是一套流程和最佳实践，为运行和管理与机器学习相关的一切提供可靠的基础设施。这就产生了一个可预测的、稳定的、安全的环境。如果没有 MLOps，许多机器学习算法仍然会在一些数据科学家的笔记本电脑上运行。这不是运行关键业务算法的好方法。

好吧，假设您对(本地)模型性能感到满意，并且您想继续让您的模型在您公司的基础设施(由 IT 部门维护)上运行。然而，在将模型代码和数据完全部署到生产环境中之前，它们通常会在数据科学团队和 IT 团队之间进行不同的交接。这不仅耗时，而且令人沮丧，并会导致时间和预算耗尽或安全性受损等风险。这就是为什么理想情况下，数据科学家不仅参与构建数据集和模型训练，还参与模型服务和托管。当然，它必须对流程的安全性和健壮性感到满意。这样就很容易进行迭代，可以快速传递变更，最终的应用程序可以在预期的时间内交付预期的价值。

UbiOps 为您处理许多 MLOps 任务，以便您可以专注于创建有价值的算法，同时仍然在专业环境中使用它们。并且不需要任何 IT 专业知识。

MLOps 的一些示例包括:

可扩展服务:算法应该是可扩展的。对你的算法的需求通常不是恒定的。有了可伸缩性，您总是拥有适量的资源。降低成本并保持速度。
标准化和可移植性:在任何专业环境中，拥有可重复和可预期的结果都是关键。在 MLOps 中，这可以归结为拥有标准格式的模型，可以在任何地方运行，最重要的是在任何地方都可以运行。
版本控制:可靠性与理解和跟踪项目中的变更有很大关系。例如，这有助于在出现问题时快速恢复到旧版本。不仅仅是在源代码层面上，比如 GIT，而且在服务层面上，如果一个新版本出现了意想不到的问题，不同的版本已经准备就绪。

如果你想了解更多关于 MLOps 的信息，你可以看看 MLOps 的 10 条戒律

把所有的放在一起:从原始数据到生产

在现实世界中，遇到非常不平衡的数据集是很常见的。这种类型的行为常见于不同的行业，从金融服务到电信或公用事业，以及许多使用案例，如欺诈检测或预测性维护。通过这种类型的行为来增强数据集的大小和质量的有效方法是通过数据扩充。

想象一下，作为一名数据科学家，您开发了一种检测信用卡欺诈的算法，但由于可用的数据集不平衡，您对结果不满意。最重要的是，您的所有代码都在笔记本电脑上运行，这不适合生产。

高度不平衡的数据。数据来源:来自 Kaggle 的信用卡诈骗

使用诸如合成数据生成器这样的工具，可以让你快速地从代表性不足的班级中学习和复制模式。 YData 的开源存储库允许您探索和试验不同的合成数据生成方法。使用 ydata-synthetic 库，只需几行代码就可以轻松生成合成数据。

使用 ydata-synthetic 库时，您可以通过几行代码轻松生成合成数据:

用 WGAN-GP 生成合成数据

通过将新的合成欺诈与真实数据相结合，您可以轻松提高分类器的质量和准确性。在本例中，我们使用带有梯度惩罚的简单 WGAN 获得了良好的结果，但有许多参数需要调整，还有其他问题需要担心，例如数据维度、生产数据集的规模以及其他问题。这就是 YData 平台所提供的，一种大规模利用最新深度生成数据综合并针对不同用途进行优化的方式。

不同的参数选择会有不同的结果。来源

但是数据科学的生命周期并没有随着模型训练和测试而结束。在获得符合业务预期的结果之后，我们需要将模型交付到稳定的生产服务环境中，并开始为最终用户交付真正的价值。

如何在不掌握容器、Kubernetes、API 开发等概念的情况下做到这一点？对于我们这些数据科学家来说，令人高兴的是，随着 MLOps 工具的兴起，如 UbiOps ，数据科学家现在不仅控制着模型开发的整个过程，还控制着交付和维护。

您可以轻松地重现和测试这个欺诈用例——y data 和 UbiOps 一起创建了一个笔记本，并在 GitHub 上提供。在这本笔记本中，您将学习如何 1)创建合成数据并从中受益，以减轻与不平衡数据集相关的问题，并进行培训，以及 2)向生产服务环境提供更好的模型。

结论

ML 解决方案的生命周期非常复杂且难以确保，这不仅是因为数据科学家和工程师的短缺，还因为(通常)现有的技术债务。数据质量对模型结果的影响是众所周知的，而实现最佳和最优训练数据集的挑战已经相当大。这使得预处理步骤成为确保可靠性和标准化的最重要步骤之一。

然而，只有当模型投入生产时，数据和模型才会对业务产生预期的影响。MLOps 是确保将模型及时、健壮且可扩展地交付到生产中的关键答案。

YData 和 UbiOps 无缝集成，使数据科学团队能够轻松改进现有数据，并在安全稳定的生产环境中交付模型。

关于 ML 数据质量的更多信息，请查看 YData 的博客。加入合成数据社区获取数据合成更新，查看关于时序数据合成数据的最新帖子。

有关 MLOps 和模型服务的更多信息，请查看 UbiOps 网站以及更多技术使用案例，请参见食谱(或查看 Github )。加入我们的[社区休闲频道](http://UbiOps is a feature rich deployment and serving layer for your data science code, models and scripts. It enables you to run your code live behind a secure serving endpoint in only a few clicks. For more information on UbiOps see our website and for more technical use cases see the cookbook (or on Github). Join our community Slack channel here.)。

如何按期间对年度数据进行分组

原文：https://towardsdatascience.com/how-to-group-yearly-data-by-periods-5199a1dba5db?source=collection_archive---------13-----------------------

我将向您展示如何用 Pandas 将每年的数据分成给定长度的时间段，以及如何用 Matplotlib 绘制它们

凯莉·贝丝·威廉姆斯在 Unsplash 拍摄的照片

去年春天，在我参加的一个课程中，一个客户让我将一些年度历史数据可视化为线图。由于每年可用的数据非常少，客户希望将这些年分成几个时间段。此外，如果年度范围不能与所选的期间长度平均分割，则最后一个期间应该更短。

让我向您介绍一下我的解决方案

首先，我们需要一些数据，我们可以根据年份列将这些数据分成不同的时间段。今天我选择用加拿大的气候历史数据来展示，这些数据可以从 Kaggle 获得知识共享许可。

使用的数据集中的前 10 行。该数据集包含从 1940 年初到 2019 年底加拿大八个测量点的日平均温度和降水量。

我们将使用熊猫，NumPy 和 Plotly

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

让我们从将数据读入数据帧开始。然后，让我们缩小数据范围，只包括“本地日期”和“平均温度多伦多”两列。

df = pd.read_csv('Canadian_climate_history.csv')
df = df[['LOCAL_DATE', 'MEAN_TEMPERATURE_TORONTO']]

要创建 year 列，让我们首先将“LOCAL_DATE”列更改为 datetime，它的初始类型是 object。从日期时间类型列中，我们可以提取年份信息，如下所示。

df['LOCAL_DATE'] = pd.to_datetime(df['LOCAL_DATE'])
df['YEAR'] = df['LOCAL_DATE'].dt.year

结果列的类型是 integer，就像我在春天得到的数据一样。

0        1940
1        1940
2        1940
3        1940
4        1940
         ... 
29216    2019
29217    2019
29218    2019
29219    2019
29220    2020
Name: YEAR, Length: 29221, dtype: int64

为了得到结果，我们将调查 1940-2019 年的范围和 20 年的周期长度。对于全年范围，我们会得到一个很好的平均分割，但由于数据中只有一个 2020 年的测量值，这没有意义。

period_length = 20start_year = 1940
end_year = 2019df = df[(df['YEAR'] >= 1940) & (df['YEAR'] <= 2019)]

为了检查分割是否均匀，以及为了确定最后一个周期的长度，我们将取模。

year_range = end_year - start_yearmodulo = year_range % period_length# For 1940–2019 the modulo is 19

接下来，让我们找出最后一期的起止年份。增加一个也是为了包括去年。否则，2019 年将被遗漏，因为它将是下一个时期(如果有的话)的开始年。

if modulo == 0:
    final_start = end_year - period_length
else:
    final_start = end_year - modulofinal_end = end_year + 1

然后，我继续使用 NumPy 创建一个列表，列出该年范围内所有较早开始的年份。

starts = np.arange(start_year, final_start, period_length).tolist()

然后，让我们创建元组列表，其中每个元组类似于(period_start，period_end)。从这些元组中，我们最终可以创建熊猫interval index的库。

tuples = [(start, start+period_length) for start in starts]
# We'll add the last period calculated earlier
tuples.append(tuple([final_start, final_end]))bins = pd.IntervalIndex.from_tuples(tuples, closed='left')

然后，通过将它们转换为字符串，这些 bin 可以很好地转换为标签。例如，当周期长度为 20 时，“1940，1960”将是第一个标签。在这里，我们可以看到 bin 是如何显示周期在左边关闭，在右边打开的。为了清楚起见，我同意客户将它们描述为“1940-1959”。我创建了一个字典，便于在数据框中替换。

original_labels = list(bins.astype(str))new_labels = ['{} - {}'.format(b.strip('[)').split(', ')[0], int(b.strip('[)').split(', ')[1])-1) for b in original_labels]label_dict = dict(zip(original_labels, new_labels)) # The label dict when year range is 1940-2019{'[1940, 1960)': '1940 - 1959',
 '[1960, 1980)': '1960 - 1979',
 '[1980, 2000)': '1980 - 1999',
 '[2000, 2020)': '2000 - 2019'}

然后，使用 Pandas cut() ，我们可以轻松地将 year 列的内容放入这些 bin 中，并创建一个新列“PERIOD”。最后，在 label_dict 的帮助下，bin 标签被替换。

# Assign each row to a period
df['PERIOD'] = pd.cut(df['YEAR'], bins=bins, include_lowest=True, precision=0)
df['PERIOD'] = df['PERIOD'].astype("str")
df = df.replace(label_dict)

最后，我们按照 PERIOD 列对数据进行分组。我去掉了年份一栏，只是为了让 df 更整洁。

df = df.groupby('PERIOD').mean().reset_index().drop('YEAR', axis=1)

最终数据帧

现在我们可以用 Matplotlib 可视化它

# Styling of the figure
fig = plt.figure()
fig.set_figwidth(12)
fig.set_figheight(5)
fig.patch.set_facecolor('white')plt.plot(df['PERIOD'], df['MEAN_TEMPERATURE_TORONTO'], color='#004cff')plt.title(f"20-year average of daily mean temperatures in Toronto between {start_year} and {end_year}")
plt.xlabel("Period") 
plt.ylabel("Mean temperature") # Styling of the plot
plt.grid(color = 'white', linewidth = 1)
plt.locator_params(axis='y', nbins=6)# Styling of the axes
ax = plt.gca()
ax.set_facecolor('#e6ecf7')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.tick_params(axis=u'both', which=u'both',length=0)plt.show()

结论

当每年只有少量可用的数据点，或者当数据点的数量在各年之间变化很大时，为每年的数据创建周期是有益的。为了清楚起见，我鼓励用确切的年份(例如“1940-1959”)来标记周期，而不是用数学区间来表示限制是封闭的还是开放的(例如“[1940-1960)”)。

感谢您的阅读！如果你学到了新的东西或者喜欢这篇文章，在 Medium 上跟随我。我目前正在撰写关于 NLP 和数据工程的未来文章。你也可以在 LinkedIn 上找到我。

你对完成这项任务有其他想法吗？如果你能在评论中告诉我，那就太好了😊

如何在 6 个月内从非编码人员成长为数据科学家

原文：https://towardsdatascience.com/how-to-grow-from-non-coder-to-data-scientist-in-6-months-197f465dfa9f?source=collection_archive---------1-----------------------

包含所有必需资源的完整指南

卡尔·海尔达尔在 Unsplash 上拍摄的照片

许多背景各异的人通过 LinkedIn 联系我。寻求将职业生涯过渡到数据科学的技巧和建议。我曾经认为，网上有大量免费学习数据科学的资源。他们为什么问我？在和一些我清楚了解的人交谈后，

选择的丰富已经成为一种诅咒
许多人不知道如何以及从哪里开始？
有些人就是不够自信
一些人寻求灵感和动力
有些人只是想知道他们是否有机会
他们大多数人都在寻找一个清晰的计划

我还浏览了一些数据科学初级职位的职位描述。很明显，期望被定得很高。这进一步导致了很多压力和焦虑，尤其是在非技术背景的人群中。这也是为什么许多人在整个学习过程中无法保持动力水平的原因。

在这篇文章中，我将向你展示一个清晰的计划。不仅能帮助你学习数据科学，还能帮助你找到工作。

开始简单但一致

学习数据科学的人最常犯的错误是从一个复杂的主题开始。被一个有趣的话题吸引是很自然的。问题是如果你在学习过程中过早地遇到了障碍。这足以降低你的动力，让你放弃。当你开始一个复杂的话题时，遇到问题的可能性非常高。

我给初学数据科学的人的第一条建议是从小处着手。下面是一些在数据科学工作中每天都会用到的基本技能。

Python/R
结构化查询语言
基本统计

好的，但是需要多少专业知识，从哪里学？对于这些主题中的每一个，我将向您展示您可以从中学习的参考资源。

学习使用 Python/R 编码

要成为数据科学家，你需要编写代码。从读取数据、探索数据集、创建可视化、执行特征工程和构建模型，一切都需要编码。有许多 AutoML 和无代码 ML 工具出现来自动化重复的任务，但是作为一名数据科学家，你需要学习编码。

如果你是编码新手，那么基于网络的平台是开始学习编码的最好地方。基于网络的交互式环境使你的学习变得非常容易。通过自己动手，你会对这个话题了解得更多。此外，没有设置环境和安装工具的压力。

学习基本 Python 编程的一个极好的基于网络的平台是 Codecademy 。这是一个以互动方式学习编码的极好平台。从上次离开的地方继续很容易，也有助于跟踪你的进展。因此，当你旅行或有空闲时间的时候，做一些学习是很好的。如果你决定选择 R，那么你仍然可以从 Codecademy 这里学习。

一旦你完成了 python 或 R 的在线教程，你就可以尝试在你的系统上编程了。安装所需的工具并试用。如果你开始时对下面的内容感到满意，这就足够了，

不同的数据类型(包括集合数据类型)及其操作
控制语句(If Then Else，For Loop 等)
函数和λ函数

学习 SQL

数据科学家的另一项必备技能是 SQL。当您进入企业环境时，所有数据通常都存储在 DBs 中。与学习环境不同，数据集不容易提供给数据科学家。数据科学团队的主要职责是理解和提取所需的数据集。要做到这一点，您需要对 SQL 有很好的了解。

同样，在 codecademy 的课程提供了一个学习基本 SQL 的互动平台。这将帮助你掌握 SQL 的基本功能和语法。有像 learnsql 这样的在线平台提供模拟现实生活挑战的实践场景。

比如，python/R 一旦你熟悉了 SQL，你就可以安装开源数据库管理系统 MySQL 了。它有一个内置的数据库。可以参考下面我的学习 SQL 播放列表。它将帮助您使用数据科学家日常工作中使用的 SQL 的常用功能。

基本统计

基本的统计学知识有助于更好地理解数据。随着您在数据科学方面的进步和技能水平的提高。基本的统计知识将有助于提出更好的解决方案。

汗学院的统计和概率课程将涵盖数据科学家所需的所有关键统计主题。如果你觉得这门课太难了，或者你渴望用足够的统计数据开始学习数据科学，那么看看下面的文章。

它涵盖了数据科学家必备的基本统计学概念。如果你更倾向于教程视频，那么检查这个播放列表。

一致性

学数据科学的时候从小做起就够了。但更重要的是保证一致性，尤其是在早期。如果你学了一两个星期，然后休息很长时间，这对学习没有帮助。你需要每周花固定的时间来学习。

提升你的技能

一旦你熟悉了上面的基本技能，是时候扩大规模了。是时候开始处理数据集并了解数据可视化、数据探索和模型构建了。

学习可视化数据

可视化是数据科学家的一项关键技能。它有助于清晰地交流见解，并揭示数据集中存在的模式。与表格或文本数据相比，人们更容易从视觉数据中选择模式。可视化在数据分析和交流中扮演着重要的角色。

要了解更多关于从零开始构建一些惊人的可视化，请查看下面的文章。

学习执行数据分析

Coursera 里有很多数据科学相关的课程。选择一个最适合你的技能组合是非常令人困惑的。下面是一些你可以根据你目前的专业水平选择的课程。

如果你是一个初学者，还没有进行过任何数据分析，那么就从 Coursera 的这个 2 小时的课程开始吧。

https://www.coursera.org/projects/exploratory-data-analysis-python-pandas

如果你对数据分析有一个基本的概念，或者你已经完成了上面的课程，那么你可以报名参加下面的课程。本课程有一些令人惊讶的反馈，许多人承认通过本课程获得了实实在在的好处。

https://www.coursera.org/learn/data-analysis-with-python

如果你渴望了解更多，那么你可以通过下面的课程向 kaggle 学习特征工程。

建立坚实的基础

现在是时候提升你的技能了。以下是 Coursera 的一些课程，可以帮助你建立一个坚实的基础。它有助于理解和了解数据科学团队在整个项目流程中执行的活动。您将了解如何理解问题，进行分析以提取推论和见解，为业务问题选择正确的模型。这些课程也有项目课程，可以提供第一手的项目经验。

这些项目大多是长期的，至少需要几周的努力。但这些都是至关重要的，它有助于你为数据科学面试和工作中的挑战做好准备。

以下是一些关于以下课程的详细信息，帮助您选择最适合您的课程。此外，不要犹豫，浏览已经涵盖的主题。

选项 1 —密歇根大学用 Python 开发的应用数据科学:如果你对本文迄今为止涉及的主题有信心，下面的课程更适合。它不关注基本的统计或数据分析。它将带您快速了解机器学习用例、文本挖掘和网络分析

https://www.coursera.org/specializations/data-science-python

选项 2——约翰·霍普金斯大学的数据科学专业:这个课程是基于 R 的，如果你正在用 R 学习数据科学，那么这个会更适合。这是一门完整的数据科学课程，涵盖了数据探索、可视化、统计和模型构建等主题。

*https://www.coursera.org/specializations/jhu-data-science

选项 3 — IBM 数据科学:这是一门完整的数据科学课程，类似于上面的约翰霍普金斯。这门课是用 Python 讲授的，这使得它更有吸引力。这门课程提供了更好的职业机会。大约 20%完成这门课程的人获得了工作机会。本课程涵盖了数据科学项目的整个流程。它还涵盖了数据科学家常用的工具、技术和库。

https://www.coursera.org/professional-certificates/ibm-data-science

设定目标并庆祝你的胜利

你的学习之旅中最重要的部分是要有目标，并虔诚地追踪你的目标。学习数据科学时，很容易分心。避免任何干扰或偏离原计划的最好方法是写下目标。本文中提到的大多数资源都有一个进度跟踪器。每周设定一些目标，并坚持下去。为了增加责任感，在博客或 LinkedIn 帖子上分享你的学习进度。

此外，分享你的成就和进步有助于创造积极的能量和动力来进一步追求。学习数据科学是一个漫长的旅程，你需要有足够高的动机来维持和完成它。

人们放弃学习数据科学的一个重要原因是缺乏信心。制定计划并跟踪进展有助于树立信心。

做好失败的准备，但要继续学习

向数据科学过渡不会一帆风顺。预计一些技术问题和其他可能的障碍会动摇你的信心。请记住一件事，即使是经验丰富的数据科学家也会遇到问题，这是职业生涯的一部分。数据科学领域是一个快速发展的领域，因此遇到问题并不罕见。但积极的一面是有一个非常好的支持系统。有很多在线社区可以帮助你。一致性起着重要的作用，每天睡觉时多一点知识将对你的职业生涯产生复合影响。

建立工作关系网

接触与你有相似背景的人，他们已经找到了进入数据科学的方法。它有助于理解工作的挑战和需要关注的技能。它会给你一个你需要努力的事情的好画面。人际关系网在求职中也起着关键作用。许多数据科学的机会都是通过推荐直接获得的，而不需要通过求职门户。除了接触有相似背景的人。参加聚会和其他公共数据科学活动有助于建立你的职业网络。

获得数据科学工作的提示

很多学数据科学的人都在苦苦寻找合适的工作。我将分享一些可以帮助你增加被雇佣机会的建议。

识别公司:发挥你的优势会让你更有优势。找出与你的教育或专业背景更相符的公司。你也可以申请许多通才数据科学职位。
建立投资组合:组织招聘新人的时间和资源都是有限的。作品集有助于展示你的能力。这通常会增加你进入面试入围名单的机会。如果你有兴趣免费建立一个作品集网站，请查看我下面的文章。

打造一份好的简历:你的简历代表了你和你的技能。它需要准确地代表你的经验和知识。有一些技巧可以让你用有影响力的陈述写出更好的简历。如果你有兴趣的话，请点击这里查看这篇文章，学习一些技巧和工具来打造一份令人印象深刻的简历。

面试前:对你申请的职位和公司做些调查。可以与现有员工接触，以更好地了解工作、文化等。
面试时:要自信，同时要诚实面对自己的优点和缺点。雇主更喜欢正直、数据科学知识水平较低的候选人，而不是数据科学知识水平很高但不诚实或不透明的人。

需要更多的动力吗？

下面的故事解释了作者从神经科学到数据科学的旅程。经过 8 年的神经科学研究和工作，作者找到了进入数据科学的方法。

下面是我从销售职业进入数据科学的个人旅程。我对 R 和 Python 一无所知。我没有受过数据科学或统计学方面的正规教育。事实上，我不擅长编程，但现在我已经写了 2 本数据科学方面的书，并成功地执行了一些交钥匙数据科学项目。

保持联系

如果你喜欢这篇文章，并对类似的文章感兴趣，在 Medium 上关注我
我在我的 YouTube 频道上教授和谈论各种数据科学主题。在这里订阅我的频道。
在此注册我的电子邮件列表，获取更多数据科学技巧，并与我的工作保持联系*

如何使用无服务器摄取管理器和 Node.js 处理 BigQuery 中的数据加载

原文：https://towardsdatascience.com/how-to-handle-data-loading-in-bigquery-with-serverless-ingest-manager-and-node-js-4f99fba92436?source=collection_archive---------24-----------------------

实践教程

文件格式、yaml 管道定义、转换和事件触发器，为您提供简单可靠的数据接收管理器

样本管道定义。作者图片💡迈克·沙克霍米罗夫

-“现在，您只需使用一个' $ npm run test' '命令，就可以从云存储中加载与您的管道定义匹配的所有文件，或者在那里创建文件时调用数据加载。

代码为的 Github 库

作者图片💡迈克·沙克霍米罗夫

您将了解如何:

将数据自动加载到您的数据仓库中，并使用无服务器 (AWS Lambda)构建一个 数据加载服务
添加各种文件格式支持和加载不同的文件，即 JSON，CSV，AVRO，拼花。
添加 DynamoDB 表来存储摄取日志，并检查文件是否已经被摄取
添加数据转换功能，例如，万一您想要屏蔽一些敏感数据或动态更改格式。
一次加载多个文件
使用基础设施作为代码部署您的数据加载服务，即 AWS Cloudformation
如何将压缩文件加载到 BigQuery
如何监控数据加载错误

关于这个想法

构建数据仓库:加载数据

通常，您会希望将您的数据仓库解决方案(BigQuery、Snowflake 或任何其他解决方案)放在图表的中心。

轻松连接任何外部数据源，即设置一个管道从某个任意 API 获取数据，即像我之前写的关于PayPal【15】并保存到云中。
加载数据到 BigQuery
转换数据，并使用 Git、CI/CD 创建文档化的数据管道。例如，用数据表单或 dbt 。
使用云形成或地形** ( 基础设施作为代码)简化和自动化部署**
用 Google Data Studio 创建 BI 报告(例如，收入对账等。)或任何其他商业智能解决方案。查看下图，了解其他选项。

作者图片💡迈克·沙克霍米罗夫

现代数据堆栈工具(当然不是完整的列表):

摄入:五川，缝合
仓储:雪花，大查询，红移
转换:dbt、数据表单、API。
BI: Looker，Mode，Periscope，Chartio，Metabase，Redash

作者图片💡迈克·沙克霍米罗夫

谈到数据提取和接收您可能希望使用付费和托管工具，如 Fivetran 或 Stitch 从任意数据源(即支付商户提供商、汇率、地理编码数据库等)提取数据。)但是如果你遵循这个指南，你将完全有能力自己做这件事。

方案

假设你是一名数据工程师，你正在做一个项目，将不同的数据源连接到你的数据仓库中。您的公司是一家手机游戏开发工作室，在 IOS 和 ANDROID 两个平台上销售各种产品。

你的筹码

你的开发栈是混合的，包括AWS和GCP。

你的团队经常使用 Node.js。数据科学团队使用 Python，但服务器和客户端数据管道是使用 Node 创建的。

您的数据堆栈是现代的、事件驱动的和数据密集型的。

数据仓库解决方案必须具有足够的成本效益和灵活性，以便您可以添加任何所需的数据源。它必须能够轻松扩展，以满足您不断增长的数据。

任务

所有数据来自各种数据表面的文件，即数据库、kinesis 消防水带流和各种通知服务。它以不同的格式(CSV、JSON、PARQUET 等)存储到您的云数据湖中。).

作为一名数据工程师，你的任务是将数据加载过程自动化到你的 BigQuery 数据仓库中。你有许多任意的数据源和管道将文件送入你的 AWS S3 数据湖。

现在你需要

……“一个可靠的服务来管理文件格式，决定上传到哪个表并监控整个过程。”

你决定使用AWS Lambda函数和node . js来完成这个任务。

你的微服务应用逻辑:

您的数据连接器从一些数据源提取数据(可以是任意的，如 PayPal)
文件正在被保存到 S3 T21 的数据库中。
当新文件进入您的 S3 数据桶时，将触发数据接收。
该服务将处理这些文件，并为 BigQuery 做好准备，以便将其插入到表中。该服务将决定插入哪个表。
该服务将检查文件是否已经被摄取，以防止重复。您将使用 AWS DynamDB 来保存数据加载记录。
捕捉数据摄取错误，并在需要时保存文件以供进一步调查。
现在，您可以在数据仓库中转换数据。
通过通知监控您的数据加载过程。如果有任何错误，您将收到一封电子邮件。

作者图片💡迈克·沙克霍米罗夫

先决条件、库和设置

工具

已安装 Node.js 和节点包管理器
对云计算(Amazon Web Services 帐户)、AWS CLI 和 AWS SDK 有基本的了解
Google BigQuery 和一个服务帐户来验证您的服务。
Shell(命令行界面)命令和脚本(高级)。

技法

对 REST APIs 的理解。
良好的节点知识。JS(中级)。您将创建一个 Lambda 函数。
你必须了解节点。JS 基本概念，即异步函数、节点包和代码如何工作。
基本调试(控制台，打印报表)
循环:即用于
分支:if，if/else，开关
Shell 命令和脚本，就像您希望从命令行使用 AWS CLI 部署 Lambda 并能够在本地测试它一样。

我们开始吧

第一步。如何使用无服务器(AWS Lambda)构建数据加载服务，并自动将数据加载到数据仓库中

为您的数据湖创建新的 S3 存储桶

用您的 bucket 名称替换your-bigquery-project-name.test.aws,并从命令行运行，例如，如果您使用 AWS CLI:

aws s3 mb s3://bq-shakhomirov.bigquery.aws

您将看到如下内容:

$ make_bucket: bq-shakhomirov.bigquery.aws确认存储桶已创建。阅读 AWS S3 文档

将数据集从上传到您新创建的 S3 存储桶:

$ aws s3 cp ./data/payment_transaction s3://bq-shakhomirov.bigquery.aws/payment_transaction

$ aws s3 cp ./data/paypal_transaction s3://bq-shakhomirov.bigquery.aws/paypal_transaction

创建一个空的 AWS Lambda 函数(Node.js)。

您可以使用 AWS web 控制台或 AWS CLI 来完成。这取决于您，并在本地初始化您的Node.js应用程序。您的微服务文件夹结构必须如下所示:

其中bq-shakhomirov-service-account-credentials.json是您的 BigQuery 服务帐户凭证。

授予您的服务从数据湖桶中读取数据的权限

您可能希望从您的 S3 数据桶中读取您的数据集文件，然后将该数据加载到您的 BigQuery 数据仓库中。因此，您需要通过向 Lambda 函数的角色添加一个策略，将 Lambda 函数的 S3 访问权限授予您的 bucket，如下所示:

你可以在 AWS 文档中找到更多关于如何创建角色的信息。后面我会举例说明如何用AWS cloud formation栈来做。

安装所需的依赖项

安装所需的node模块和库，如./package.json所示。您将需要:

“AWS-SDK”:“2 . 804 . 0”用于访问带有数据的 S3 桶
" run-local-lambda": "1.1.1 "来测试 nad 并在本地运行您的 Lamdba
“@google-cloud/bigquery”:摄取数据的“⁵.7.0”
“时刻”:" . 24.0 "处理日期并创建相关的file names / BigQuery jobIds

确保您可以在本地运行它。这个想法是通过从命令行运行npm run local命令来模拟一个事件( S3 对象创建事件)。安装“run-local-lambda”:“1 . 1 . 1”来测试并在本地运行您的 Lamdba。

你的./package.json一定是这样的:

在命令行中运行npm i，它将安装依赖项。

app.js

在您的./app.js中添加async process event()函数来处理事件。

您的./app.js看起来会像:

哪里./config.json是你的服务配置文件。

我更喜欢用YAML来代替，不过是口味问题。最终你会找到使用 *npm config* 和 yaml 的解决方案。 对你的来说似乎是正确的事情。

你的./config.json的例子可以有现场和登台环境设置，看起来像这样:

使用配置文件定义逻辑、表名以及如何为这些表选择相关文件。

使用上面的这个配置文件，您的数据加载服务将尝试将 name 键与相关文件名 fileKey 匹配。如果它在 S3 事件中找到匹配，那么它将开始加载数据。

BigQuery 凭据文件

./bq-shakhomirov-b86071c11c27.json是 BigQuery 凭证文件的一个例子。你将需要这个 服务帐户凭证 文件来通过谷歌认证你的微服务，这样它实际上可以做一些事情。点击阅读更多关于服务账户认证的信息。只需从你的谷歌云平台账号下载，添加到你的应用文件夹。

看起来应该是这样的:

如何检查 BigQuery 中是否存在表

您可能希望在加载数据之前执行此操作。将这个函数添加到您的./app.js文件的processEvent()中。如果表不存在，它将使用配置文件中的模式并创建一个。

这个函数将在名为source的数据集中创建一个带有配置文件模式的表。它也应该来自./config.json，但这只是一个例子。

如何将 JSON 文件流式加载到 BigQuery 中

这将是一个逐行的插入操作。

当一行不符合模式时，只有该特定行会被插入，而不是 BigQuery 中的 批量插入 (一行模式验证失败—所有文件上传失败)。

您可能想要添加一个新功能:

这只是一个例子，其中已经声明了 JSON 数据(不需要从本地文件或者从 云存储 )并且已经创建了表。simple_transaction是一个简单的表，只有 3 列:transaction_id、user_id和dt，在./config.json模式中为名为simple_transaction的表定义。试试看，它会将数据逐行插入 BigQuery 表中。

您可以稍微调整此函数，例如从本地文件中读取数据，它将处理新的行分隔文件./data/simple_transaction并创建一个加载作业操作来代替我们之前使用的写流。

如何从 AWS S3 加载 JSON 新行分隔数据

如果你的数据是新行分隔的 JSON(big query 加载 JSON 数据的自然方式),那么你需要一个像下面这样的函数。该功能将执行以下操作:

从 AWS S3 创建一个读取流并读取文件
使用 JSONStream 模块解析 JSON 文件中的数据
在 BigQuery 中创建一个 批处理 加载作业。

把这个加到你的./app.js里，试试npm run test。将./test/data.json修改为object.key = 'simple_transaction:

您的“simple_transaction”文件内容应该如下所示:

那么 BigQuery 流插入 和批量 插入操作有什么区别呢？

它仍然是一个作业(不是像我们上面做的那样big query streaminginsert ),但是在架构方面它是非常高效的内存，并且 是空闲的 。您只需要不超过每天每个表的批处理作业配额。我之前在这里写过如何在 BigQuery 中监控批量加载作业操作:**

很好，但可能会产生更高的费用。

我建议尽可能使用batch insert。每个表每天有 2000 个插入的配额，但是您可以一次插入整个文件。 流媒体插入 没那么便宜，每 GB 0.05 美元，1TB 50 美元。

流式插入是导入数据的推荐方式，因为它是可伸缩的。

然而，如果数据湖中的文件相对较小(这通常发生在使用数据流时，即 Kinesis 或 Kafka ),这不会产生很大的影响。在这里阅读更多关于大查询配额和限制的信息

如何用 Node.js 和 AWS Lambda 微服务将 CSV 数据加载到 BigQuery 表中

您可能希望添加一个函数，该函数从 S3 对象读取数据，并将其作为 CSV 上传到 BigQuery 表中:

这是一个从 S3 读取一个 CSV 文件的例子，理想情况下，你会希望在 Node.js 流模式下这样做以节省你的内存，而不是将整个文件读入内存。它创建一个 可读流 然后流入 流可写 到 BigQuery。

局部解决

这是这个项目的app.js。这是一个简化的应用程序。复制此文件并使用它来开发您的解决方案。

您必须创建自己的 BigQuery 服务帐户凭证，例如，像我一样下载./bq-shakhomirov-b86071c11c27.json并创建自己的./config.json来定义表模式和应用程序环境。

该应用执行以下操作:

当您运行$npm run test时，它将使用来自./test/data.json的有效载荷来描述 S3 文件的位置(查看./package.json中的脚本)
然后，它将从./config.json获取设置，即凭证位置等。并使用 BigQuery API 进行认证
它将遍历./config.json中描述的表格，试图在有效载荷中找到一个匹配。本例中的有效载荷模拟 S3 对象创建的 事件。
如果找到匹配，服务将尝试从 S3 获取该文件，并将其中的数据加载到相关的 BigQuery 表中。
它将检查表格是否存在，如果不存在，它将使用./config.json的模式创建一个新的表格

添加 DynamoDB 来保存数据摄取记录

如果您需要处理加载作业的复制尝试，那么您可能会想要创建一个新表，并保留摄取文件的记录。那么您可以考虑将这个片段添加到您的应用程序中，在./app.js:

如果你添加类似于await logSuccessfulEvent(sourceBucket, fileKey, now.format('YYYY-MM-DDTHH:mm:ss'));的东西，它将开始记录成功摄取的文件，但是你需要首先创建一个表:进入 AWS 控制台:

为成功获取的文件创建一个名为ingestManager的表。
向您的 Lambda 添加访问 Dynamo 表的权限。

作者图片💡迈克·沙克霍米罗夫

将处理successfull事件的logSuccessfulEvent函数添加到./app.js文件:

因此，您应该会看到创建了一个新的摄取记录:

作者图片💡迈克·沙克霍米罗夫

现在，您可能想要添加一个新函数。姑且称之为checkAlreadyIngested()。

此函数将检查您的数据加载管道是否有任何复制企图，并防止这些复制企图。

确保用try, catch块包裹即可。

如何监控 BigQuery 数据加载服务中的错误和复制尝试

…或者任何其他数据仓库。

您可能想在每次出现错误时收到通知。

使用简单通知服务(SNS)创建一个 AlarmNotificationTopic ，以便在出现任何摄取错误时通过电子邮件接收通知。
当您创建 Lambda 并附加策略时，它一定已经创建了一个 LogGroupName : /aws/lambda/ingestManager或类似的东西。使用它创建 ERRORMetricFilter ，其中错误计数> 0 。例如，我的日志组如下所示:

作者图片

使用以下模式创建一个 ERROR metric filter:filter pattern:' ERROR '调用它ingestManagerStagingMetricFilter

作者图片💡迈克·沙克霍米罗夫

现在去SNS创建你的提醒主题:

作者图片💡迈克·沙克霍米罗夫

单击创建订阅并输入您的电子邮件:

作者图片💡迈克·沙克霍米罗夫

最后创建ERROR metric alarm动作，当数字误差连续 5 分钟大于 5 时触发报警。它应该发送通知到您的社交网站的主题。

作者图片💡迈克·沙克霍米罗夫

选择遇到警报时发送通知的位置:

作者图片💡迈克·沙克霍米罗夫

在摄取管理器出错的情况下，期望的输出是一个通知:

作者图片💡迈克·沙克霍米罗夫

理想情况下，你会希望使用类似于AWS cloud formation的东西来管理你的 基础设施，代码为 。

示例堆栈文件可以在本教程的 Github 库中找到。

如何转换原始数据湖文件中的数据并为 BigQuery 做准备

自然地， BigQuery 可以使用 新行分隔的 JSON 或者其他已经正确形成的格式。因此，如果你正在加载ndJSON，那么它应该在那之前被新行分隔:

现在假设您有另一个服务从 MySQL 数据库 中提取数据，它的输出看起来像一个 JSON 对象数组:[{...},{...},{...}]。这些单独的 JSON 对象也可以深度嵌套。您可能希望将它转换成nldj : '{...}'\n'{...}'\n'{...}'\n，这样 BigQuery 就可以将它装载到表中。

或者想象你正在使用标准的消防软管输出，其中数据被写成一串JSON对象{...}{...}{...}。没有逗号。您可能需要为从OBJECT _ STRING到 SRC variant 格式的 BigQuery (转换为nldj)准备数据，即{...}{...}{...} > > > '{...}'\n'{...}'\n'{...}'\n。

看到里面的使徒了吗？这将把它定义为类型STRING，并且您需要创建一个只有一列的表:name: "src", type: "STRING"。

这可能是一个具有挑战性的任务，但我写了一些方便的助手函数。你以后会找到它们的。

因此，只需在您的 *config* 中添加文件格式规范，就可以定义处理逻辑并正确地将所有文件加载到big query中。

例如，您可能希望在yaml配置中定义您的表，如下所示:

第一个名为paypal_transaction的pipe有一个单独 JSON 对象的数组(深度嵌套),您可能希望将每个单独的嵌套对象作为一个 JSON 记录插入，这样您就可以稍后在您的数据仓库中用JSON_PARSE函数解析它。

第二个管道GeoIP2-Country-Blocks-IPv4需要从 CSV 中解析出来，并插入到 BigQuery 表中，相关的模式有六列。这里您可能希望显式声明一个 CSV 分隔符来帮助 BigQuery 加载数据。

第三个表示一些配置不佳的 Kinesis 流输出，需要作为 JSON 插入，但必须首先为 BigQuery 做好准备(转换为 NLDJ 格式)。

第四个也需要作为 NLDJ 加载，但是它被压缩了，所以你想先解压缩它。

如何将压缩文件加载到 BigQuery

如果你的文件是压缩的，那么你会想先用zlib库解压它。您可能想要添加一个功能loadGzJsonFileFromS3()。因此，在本例中，我们首先解压缩文件，然后将该流通过管道传输到 JSONparse ，后者将提取我们需要的 JSON，并且将通过管道 createWriteStream 传输到 BigQuery。

用这种方法你可以非常有效地加载大文件。

在这个代码为的 Github 库中有更多的例子，包括这些加载函数的分支。例如，一个名为checkSourceFileFormatAndIngest()的函数定义了如何转换数据格式的逻辑，然后将数据加载到 BigQuery 中。

在上面的例子中，我还使用了定制的 BigQuery jobIds。这是在 BigQuery 中防止重复的另一种方法。

在这种情况下你不需要DynamoDB但是我仍然使用并插入额外的度量，即插入的 行数和一个 表名 来生成统计数据。

如何使用 AWS Cloudformation 部署服务

我不想用 AWS 控制台创建所有那些资源。 AWS Cloudformation 是一种简单的方法，只需点击一下鼠标，即可自动部署和配置所有资源。

除其他优势外，您会发现创建生产和试运行环境以及整理(删除)所有资源非常简单。

这个教程实际上是免费的，那些工具不会花费你任何东西。

用代码在 Github 库中检查。

在./stack/cf-config.yaml中，你会发现 AWS Cloudformation 模板描述了本教程可能需要的所有资源。包括例如 AWS Lambda 角色:

要在您的 AWS 帐户中部署服务，请转到./stack并在命令行中运行这两个命令:

那个lambdas.bq-shakhomirov.aws是你的服务工件的 S3 桶，你的 lambda 代码将保存在那里。换成你的。

如何一次将所有文件加载到 BigQuery 表中

当您需要在选定的时间范围内(即特定日期)将所有文件从数据湖中一次性load / reload到您的数据仓库中时，这种多文件上传功能可能会很有用。

如果需要，该服务必须能够扫描您的数据湖，并挑选符合您需要的描述和时间分区的文件。

假设您的数据湖有来自不同来源的文件保存在 AWS S3 中，具有 关键字 前缀，其中包含大查询 table name和date分区，即:

所以在这里，您会希望您的服务扫描数据湖桶，并只选择与这三个pipes : paypal_transaction、simple_transaction和some-other-transaction相关的文件，并带有日期前缀2021/10/04。

然后，您会希望摄取管理器生成一个最终的payload，其中包含找到的所有文件密钥，并将它们加载到 BigQuery 中。

./test/data.json的最终payload应该在数据湖中找到所有文件:

在你的本地文件夹中有了这个 *payload* 你就可以在你的命令行中运行 *$ npm run test* (如果你的有效负载在 *./test/data.json* )你的微服务会把这些文件一个一个的加载到big query中。

我在我的./package.json中添加了脚本来运行这些命令。

例如，如果我在命令行中运行$ npm run test-service，那么./loadTestIngestManager.js中的应用程序将使用test/integration/loadTestPipelines.json中的管道定义扫描数据湖，并生成一个包含所有找到的文件的输出。它会将其保存到test/integration/loadTestPayload.json。
然后，如果我运行$ npm run test-load ./app.js，摄取管理器将使用文件的有效负载，并将它们发送到 BigQuery 。

使用这些脚本，您可以轻松地为加载到 BigQuery 中的文件和格式编写集成测试。

您可能注意到上面的payload.json与original S3 Obj created事件负载略有不同:

那只是因为在我的环境中，我有另一个由S3 Obj created事件触发的orchestrator服务，它将为ingest-manager创建有效负载。该服务可以执行您需要的任何其他功能，并且它会在需要时invoke 摄取管理器。

随意调整摄取管理器的有效载荷。您可能希望在processEvent()函数中为event处理添加S3键。

结论

您刚刚学习了如何为用 Node 编写的 BigQuery 创建一个简单可靠的摄取管理器。带有一些 牛逼功能 的 JS:

无服务器设计和 AWS Lambda 功能。
非常性价比。针对批量加载作业进行了优化，这意味着您无需为数据加载付费。基本上它是免费的，但检查 BigQuery 负载作业限制。
可以使用流式插入(BigQuery 流式加载)。
为 AWS 量身定制但可以轻松迁移到 GCP，Azure 。
用 AWS Cloudformation 构建的代码为 的基础设施。在任何其他 AWS 帐户中一键部署。
使用 AWS Dynamo 进行有效的负载作业监控和文件重复处理。
自定义 BigQuery 作业 id。如果你不想使用 Dynamo，另一个防止复制的方法是。
支持单元和集成测试。

许多人认为 Python 是完成这项任务的最佳选择，但是我不同意。所有的选择都是好的，只要他们能完成工作。以前我写过如何用 Python 写代码，Python 是我最喜欢的编程语言之一。我的大部分生产管道都是用 Python 或 Java 编写的。

我的观点是你不应该限制自己。

本教程不是关于编程语言或它们的具体应用。我确实认为数据只适用于 Python/Java 这种陈词滥调。当我看到不使用 SQL(或者不知道如何使用)的数据科学家时，我也很沮丧。

这个项目是关于数据工程、现代数据堆栈、跳出框框思考、自我学习、定制、语言不可知以及能够用非常规方法达到预期结果。

资源

[1]:https://docs . AWS . Amazon . com/CLI/latest/user guide/CLI-services-S3-commands . html # using-S3-commands-managing-buckets-creating

[4]:https://cloud . Google . com/big query/docs/reference/rest/v2/Job # JobConfigurationLoad

[5]:https://Google APIs . dev/nodejs/big query/latest/table . html # create write stream

[7]:https://docs . AWS . Amazon . com/AWS cloudformation/latest/user guide/AWS-properties-CW-alarm . html

[8]:https://AWS . Amazon . com/blogs/security/how-to-create-an-AWS-iam-policy-to-grant-AWS-lambda-access-to-an-Amazon-dynamo db-table/

【9】:【https://aws.amazon.com/cloudformation/

【10】:http://ndjson.org/

【11】:https://cloud.google.com/bigquery/quotas

[12]:https://stack overflow . com/questions/7985599/notification-of-new-S3-objects

[13]:https://medium . com/swlh/loading-data-into-big query-from-cloud-storage-complete-guide-e 212 F5 C2 db 6

[14]:https://towards data science . com/monitoring-your-big query-costs-and-reports-usage-with-data-studio-b 77819 ffd 9 fa

[15]:https://towardsdatascience . com/extract-data-from-paypal-API-c25c 76748746？gi=e76b91a696e*

原载于 https://mydataschool.com*https://mydataschool.com/blog/how-to-load-data-into-bigquery-with-serverless-node-js/。***

如何使用内置函数在 SQL 中处理日期

原文：https://towardsdatascience.com/how-to-handle-dates-in-sql-using-in-built-functions-d6ca5a345e6d?source=collection_archive---------18-----------------------

日期函数是 SQL 编程中谈论最多的领域之一

埃德加·莫兰在 Unsplash 上的照片

作为一名数据分析师，我用不同的时间粒度构建仪表板和报告，如每周、每月、每季度、每年。对于时间序列分析，我需要聚合数据中的时间戳。这就是日期函数发挥作用的地方。这些内置功能使分析师的任务变得更加容易。我无法想象没有内置日期功能的生活。

今天，我将专门讨论 PostgreSQL 附带的那些。但是几乎所有的 SQL 数据库都以某种形式支持这些。

以下是我的一些主要约会功能。

1.日期 _trunc

Date_trunc 用于将日期截断为周、月、季度或年。此函数最广泛地用于创建时间序列和粒度级聚合。例如，如果您想要绘制 KPI 的趋势，如季度销售额、活跃用户、月订单等，可以使用该函数。

语法:

SELECT DATE_TRUNC('month',calendar_date) AS Month,
       COUNT(DISTINCT USER) AS active_users
FROM usage
GROUP BY 1

2.当前日期

我认为这是我所有查询中最常用的函数。顾名思义，这个函数给出当前日期。几乎每次分析数据集时，我都会根据手头的问题将数据集限制在过去几年/几周/几个月，以缩短查询执行时间。这个函数通过获取当前日期来帮助我这样做，当前日期将成为我的结束日期，然后我提取相对于这个结束日期的开始日期。例如，让我们假设我想看看去年我的销售额逐月增长的情况。我可以使用 current_date 获得最近的一个月，然后从中减去 12 个月，得到完整的一年。

语法:

SELECT DATE_TRUNC('month',calendar_date) AS Month,
       SUM(sales) AS monthly_sales
FROM sales
WHERE calendar_date BETWEEN DATE_TRUNC('month',CURRENT_DATE) -INTERVAL '12 Months' AND DATE_TRUNC('month',calendar_date)
GROUP BY 1

3.Datediff

此函数给出您指定的日期部分中两个日期/时间戳之间的差异。您可以将日期部分指定为秒、分、小时、天、周、月、年等。例如，下面的查询根据用户开始和结束观看会话的时间，以分钟为单位计算电影观众人数。

语法:

SELECT DISTINCT movie,
       SUM(datediff ('minutes',watch_start_time,watch_end_time)) AS watch_minutes
FROM movie
GROUP BY 1

4.日期 _ 部分

date_part 函数提取日期部分的值。例如，有时我必须从我的数据集中排除/突出周末数据来处理异常值。这个功能非常好地完成了这项工作。

语法:

SELECT CASE
         WHEN DATE_PART('dow',calendar_date) IN (1,6) THEN 'Weekend'
         ELSE 'Weekday'
       END AS time_of_week,
       COUNT(DISTINCT session_id) AS sessions
FROM sessions
GROUP BY 1

5.Trunc

Trunc 函数将时间戳截断为日期值。这类似于铸造一个时间戳。
语法:

Select DISTINCT trunc(start_time) as day
FROM usage

6.到时间戳

这个函数将时间戳转换为带时区的时间戳。当我试图分析基于事件的数据时，我不得不使用它，其中一个数据源捕获 UTC 时区的数据，另一个数据源捕获本地时区的数据。默认情况下，会添加 UTC/GMT 时区。

语法:

SELECT to_timestamp('2011-12-18 04:38:15', 'YYYY-MM-DD HH24:MI:SS')

结果:

to_timestamp 
---------------------- 
2011-12-19 04:38:15+00

7.Dateadd

Dateadd 按指定的间隔递增日期或时间戳。例如，假设我们有一个数据集，其中包含一个持续时间为 30 分钟的在线测试的数据，该测试在 30 分钟后自动结束。如果我们只有每个考生的开始时间，我们可以使用 dateadd 来计算每个考生的结束时间。

语法:

SELECT DATE_TRUNC('month',calendar_date) AS Month,
       COUNT(DISTINCT USER) AS active_users
FROM usage
GROUP BY 1

8.最后一天

Last_day 返回包含给定日期的月份的最后一天的日期。例如，你可以用它来检查一年是否是闰年，一个季度的最后几天销售额如何变化，等等。

语法:

SELECT DISTINCT year,
       CASE
         WHEN last_day ((year|| '-02-01')::DATE) = (year|| '-02-29')::DATE THEN 'Leap Year'
         ELSE 'Not a leap Year'
       END AS is_leap_year
FROM years

9.间隔

Interval 实际上是一个文字，而不是一个内置函数。这种文字允许您确定特定的时间段，如 6 个月、30 天、45 天、2 周等。例如，在下面的例子中，我用它将一个纪元值转换成一个时间戳值。

语法:

SELECT epoch_time,
       TIMESTAMP 'epoch' +(epoch_time*INTERVAL '1 seconds') AS date_time_value
FROM date_time_data

总结

在执行时间序列分析时，理解处理日期-时间数据类型的技术是极其重要的。我觉得 SQL 是一个在进一步分析之前尽可能清理数据集的好地方。通过学习这些函数，您将能够分析与趋势相关的数据，并在更短的时间内找到更深入的见解。

我希望你尝试这些功能，并看到使用这些功能的好处。

如果你有任何问题或建议，请在评论区告诉我。

感谢阅读！

下次见……

如何处理丢失的数据

原文：https://towardsdatascience.com/how-to-handle-missing-data-b557c9e82fa0?source=collection_archive---------16-----------------------

使用 XGBoost 的最快多重插补方法

丢失数据太糟糕了。它阻止了某些模型的使用，并且经常需要工程师进行复杂的判断。然而，在 2021 年，奥克兰大学的研究人员开发了一种解决方案…

图 1:大型数据集的缺失数据。图片作者。

他们的方法利用世界闻名的 XGBoost 算法来估算缺失数据。依靠一个针对速度优化的模型，我们可以看到相对于传统插补方法 10-100 倍的性能提升。XGBoost 还几乎不需要超参数调整，这大大减少了工程师的工作量。XGBoost 还能够维护数据中观察到的复杂关系，比如交互和非线性关系。

因此，如果数据集超过 3000 行，您可以考虑使用 XGBoost 来估算缺失数据。下面是该方法的工作原理…

技术 TLDR

使用 XGBoost 进行多重插补。它是在 MICE 框架中实现的——我们不使用线性/逻辑回归，而是使用 XGBoost。
使用预测均值匹配(PMM)来改善我们的方差估计。 PMM 是必需的，因为 XGBoost 低估了估算数据的方差，导致置信区间的覆盖范围很小。

好的，这很好，但是这个方法实际上是如何工作的呢？

我们稍微慢一点，理解一下为什么这个方法这么有效。

我们的目标

首先，从我们的目标开始。许多真实世界的数据集都有缺失数据，这会给建模和分析带来问题。为了让我们的生活更轻松，我们将尝试用现实的预测来填补那些缺失的价值。

图 2:大型数据集缺失数据插补可视化。图片作者。

填充缺失数据的一种常用方法是简单地输入平均值、中值或众数。然而，正如你所料，我们获得的信号很少，而且这些估计的方差往往太低。

方差的重要性

但是我们为什么要在乎呢？嗯，方差是所有统计显著性和置信区间计算的基础。

基于中心极限定理，我们知道许多样本的平均值将类似于正态分布。如果我们观察一个样本，它的平均值远离这个理论分布(总体)的中心，我们可以认为这是极不可能的，因此具有统计学意义。并且，我们不会称之为统计显著的范围被称为我们的置信区间。

图 3:样本方差公式。图片作者。

为了估计这一理论总体的分布，我们使用数据的标准差，即数据方差的平方根，如图 3 所示。因此，方差是所有基于信心的计算的基础。

估算数据的方差

当输入数据时，我们希望使用观察到的数据来估计未观察到的数据。如果我们有一个完美的代表性样本，我们可以完美地估算缺失数据。然而，样本从来都不是完美的，经常会丢失关于丢失数据的关键信息。

由于这个事实，大多数数据插补方法低估了缺失数据的方差。

现在，以正确的方式系统地引入方差真的很难。一种简单的方法是简单地给每个估算值添加一些随机噪声。这肯定会使我们的数据更加多样化，并可能增加方差。但是，这种均匀分布的噪声可能并不代表我们的总体。

这就是mixb的用武之地…

该方法

奥克兰大学的研究人员提出的方法使用流行的建模技术 XGBoost 和预测均值匹配(PMM)来估算数据。让我们依次看一看每一个。

1—MICE 框架中的 XGBoost

XGBoost 是一种非常流行的基于树的算法，因为它速度快，通用性强，并且具有开箱即用的准确性。评论中有一个惊人的解释，但对于这篇文章，你可以把 XGBoost 想象成一个黑盒，它接收预测值并输出我们缺失数据的估计值。

另一方面，我们将讨论 MICE 框架。MICE 代表通过链式方程的多重插补。没有听起来那么糟糕。

图 4:具有 4 个插补集的 MICE 框架。图片作者。

MICE 的工作方式是创建数据的 M 份副本。然后，它依次遍历第一个复制的数据集中的列(图 4 中的 M1 ),并使用线性模型来预测缺失的值。预测值是该行中的所有其他变量。然后 MICE 对其余的 M 数据集重复这个过程，产生 M 个完整的数据集。

从那里，我们取所有 M 数据集的每个指数值的平均值，这些平均值成为我们的最终估算数据集。

现在，如果你仔细观察，你会发现所有的数据集都是一样的。因此，为了给外观自然的变化，我们只是添加一些随机噪声到每个预测。

很直接，对吧？

现在，线性回归有其局限性——它不允许非线性关系，并且需要人工干预来处理交互。XGBoost 在非线性关系和交互方面都很棒，所以我们只是使用 XGBoost 而不是线性回归来预测我们的缺失数据。

2 —预测均值匹配处理低方差

现在，XGBoost 受限于我们给它的数据，所以它经常低估我们预测的方差。为了增加方差，我们实施了一种称为预测均值匹配(PMM)的方法。

图 5:二维预测平均匹配。图片作者。

PMM 随机选择五个最接近我们预测的观察数据点之一。因此，在上面的图 5 中，绿点是我们的预测值，它周围突出显示的圆圈是我们的预测将成为的候选值。

通过用观察到的数据点替换预测，我们确保引入的方差与我们总体中的方差具有相同的结构。

我们对所有预测值重复这一过程，直到我们用预测值附近的观察数据点替换了所有空的数据点。

摘要

现在，你知道了。快速总结一下…

XGBoost 是一种高性能算法，可以对数据中的复杂关系进行建模。
mixgb 包利用 XGBoost 来估算缺失数据。
为了确保我们可以计算准确的置信区间，我们使用预测均值匹配来增加估算数据的方差。

实施说明

在更小的数据集上，XGBoost 在计算速度上更胜一筹。主要的竞争来自于随机森林实现，但是 XGBoost 在大于 3000 X 20 的数据集上表现更好。
对 PMM 来说，有几种不同的方法，但没有一种方法局限于 5 人的捐献者人数。其他常见的值有 2、3 和 10。
目前，我还不知道有哪个 python 包支持这种方法。
在论文中，我们开始看到 mixgb 在 3915 x 20 数据集上在计算速度方面优于所有其他方法。对于所有较大的数据集，XGBoost 是明显的赢家。

感谢阅读！我会再写 39 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源以及 R 包。

如何处理神经网络输出:野生动物无人机图像的实际应用

原文：https://towardsdatascience.com/how-to-handle-neural-network-output-a-practical-application-on-wildlife-drone-images-4670788d770d?source=collection_archive---------22-----------------------

处理人工智能训练的输出不一定简单，需要仔细观察数据。

通过使用野生智能实验室提供的航拍图像，我们试图找到一个好的结构，并深入了解库兹库斯野生动物保护区的土豚洞和枯树。

本文是对主项目中数据科学部分的额外的、更全面的介绍。主要文章已经详细介绍了该项目的起因以及如何训练 Mask RCNN 为我们服务。它可以在这里找到:

https://wildintelligencelab.com/deadwood-and-aardvark-hole/

提供机器学习数据

我们开始查看所提供的信息及其出现的形式。从掩模 RCNN 神经网络结构中，我们得到以下输出:

图像分类(输入图像的预测内容标签): dead_tree 或 aardvark_hole
语义分割(将输入图像中的像素与来自 1 的适当类别标签相关联)
物体检测(通过边界框捕获的图像中物体的位置):【x 轴，y 轴，宽度，高度】 - >例如【1925，248，1962，271】
实例分割(结合对象检测和语义分割以获得检测和精确分割):这输出一个数组，其中每个二进制值表示一个像素是否属于分割遮罩，例如[[假、假、假、假、假、真、Tr…】

可视化 1–4 来自stat twiki

为了在单个图像切片上实现它，我们使用下面的代码。通过改变第 7 行中选定的图像，我们可以看到神经网络生成的结果。

虽然这为我们提供了一个覆盖了分类的图像，但我们现在希望以数字形式详细查看输出。我们可以看到，由于输出 ROI 时的 4 个不同阵列，我们在该图像中检测到了 4 个对象。

>>print(r['rois'].shape)
(4, 4)
>>print(r['rois'])
[[ 767  0  801   26]  [ 868   37  891   62]  [ 316 1763  341 1787]  [2004  980 2026 1006]]
>>print(r['masks'].shape)
(2048, 2048, 4)

另一方面，遮罩为我们提供了一个二进制数组(图像原始切片的大小)。当绘制它时，我们可以清楚地看到神经网络发现的面具。观察标签和面具的大小，我们可以看到在这个特定的输入图像中有 4 个土豚洞。有可能为每一个单独返回它们的边界框和相应的遮罩。

绘制掩码 // plt.imshow(r["masks"][:，:，0]+r["masks"][:，:，1]+ r["masks"][:，:，2] + r["masks"][:，:，3])

数据框架

看到并掌握了掩蔽 RCNN 呈现给我们的新发现的信息，我们现在需要考虑适当地存储数据。但是我们使用的格式很大程度上取决于我们想要得到什么样的内部信息。在第一次头脑风暴中，我们集中讨论了以下一系列模糊的问题:

从枯树上估计木头的重量
分析枯树的存在
一簇簇枯树
分析土豚洞的存在
某些区域的成簇孔洞
土豚洞的大小——与邻居的关系

这是一个困难的情况，因为我们关注每一个单独的物体，但也关注它们与周围环境的关系，从而关注全局。最方便的方式似乎是将每个检测到的对象存储为单独的实例，以便能够例如单独估计大小。我们通过构造一个数据帧并给这个表中每个检测到的对象一个自己的行来做到这一点。最后，我们将有一个填充了所有土豚洞的数据帧和一个检测到所有枯树的数据帧。我们从以下几列开始: ID (唯一标识符)标签(枯树或土豚洞)原点(原始目录)x 和 y 坐标的 pic 位置(给我们原始大图中切片的位置)边界框坐标，遮罩数组及其对应的遮罩尺寸。

直接从屏蔽 RCNN 输出

这看起来已经比单独查看每张图片要干净得多了。有了这么好的表现，我们甚至可以问一些最初的问题:每个土豚洞/死树的大小是多少。通过对掩码数组中的真值求和，我们得到表示掩码填充的像素总和的掩码大小。在无人机图片的元数据中，我们得到一个像素大约为 4 厘米的信息。因此，我们已经可以向表中添加一个新列，说明以平方米为单位的大小。对于我们的其他问题，我们没有使用掩码数组，并决定放弃它。

减少信息

和掩码数组一样，我们现在看看所有其他值，并尝试评估它们给我们带来了什么信息，如果有办法的话，只将它减少到最低限度。拥有所有的像素值使得开始进一步的分析变得困难。所以既然我们已经有了平方米的尺寸，我们就不再需要完整的边界框和它所有的 x 和 y 值了。但是我们需要的是边界框的位置。

计算每个包围盒的质心

因此，我们不使用所有四个值，而是只查看每个边界框的质心。我们通过取宽度和高度的一半，并用边界框的质心的 x 和 y 值生成一个新的数组。从四个点增加到两个点似乎很简单，但是这一步已经使进一步的分析变得更加容易。通过一个点(一维)而不是一个区域(二维)，我们现在可以很容易地计算多个物体之间的距离，并通过散点图非常直观地显示它们。我们现在只需要一个(2，4)数组，而不是像我们对遮罩那样绘制一个(2048，2048，4)数组。四个物体的两个坐标。详细的形状对于聚类分析和距离计算来说是可以忽略的，并且明显比便宜得多的成本更重要。

全无人机拍摄覆盖了所有土豚洞的散点图

通过使用我们所拥有的关于切片在整个图像中的确切位置的信息，我们还可以以这样的方式改变值，即质心不仅仅代表物体在切片中的位置，而是代表整个拼接在一起的无人机拍摄。我们现在有效地将原始的 11 GB 照片压缩成几 MB。当然，颜色、背景和一些细节都不见了，但是我们想要的信息仍然是完整的。我们甚至可以用散点图覆盖原始背景图像，给我们一个现实生活中物体位置的指示。虽然听起来很强大，但在 python 中，背景图像需要极大地缩小才能做到。因为我们不能保持足够的信息和细节，所以它只能成为一个视觉辅助，我们可以放大到最终的情节。

通过查看代码，我们还可以看到，为了使背景与散点图一致，我们需要在第 1 行中适当地设置 figsize，在第 2 行中适当地设置范围。这主要是一个估计，因此这就是为什么在上面的图中一些点位于背景图像之外的原因。

遮罩旁的实际图像

通过执行这些步骤，我们可以组织模型的输出，并以这样的方式减少输出，这样我们只剩下必要的信息用于进一步的分析。同时，这也给我们带来了好处，我们已经能够很好地估计我们探测到的物体的大小。不幸的是，这并没有为死树估计提供好的结果。土豚洞的大小很简单，它们的深色使得神经网络更容易绘制出准确的面具，而树木的复杂形状则不是这样。

感受数据

质心分布 //海风显示

在进入高级主题之前，建议花点时间查看数据，并重新评估它是否正确。我们关注土豚洞及其在地形中的分布和大小。重叠散点图不会根据单个孔的大小进行缩放，只有通过丰富的想象力才能发现多个孔的大量集合。

土豚洞的数量根据它们的大小 //直方图绘制

根据大小标绘所有的洞使我们能够看到所有洞的范围和分布。我们的结果表明，平均孔尺寸约为 0.13 平方米，而中位数约为 0.11 平方米。我们可以看到一个钟形曲线，这是我们对自然现象的预期。

寻找土豚洞群

土豚以它们的洞穴而闻名，但也以它们的地下隧道系统而闻名。Kuzikus 野生动物保护区提供的研究表明，两个洞之间的隧道可长达 10 米。考虑到这个距离，我们的下一个目标是找到可能相连的洞，形成一个更大的隧道系统。

这是一个非常简单和天真的方法，使用空间中的欧几里德距离来测量两个洞之间的米数。然后，从满足 10m 以下限制的数据帧中构建一个数据帧。但是通常天真的方法是最方便的，因为手头没有额外的数据，我们决定选择这个选项。

在距离矩阵的帮助下，我们可以提取每个洞的“邻居”,并以包括所有可能连接的洞的方式创建聚类。如果 36。和 39。球洞都与 38 号球洞相连，聚类列表包括一组中的所有 3 个球洞。最后，我们在数据框中添加了一个“组”列，为位于同一个集群中的组分配相同的组号。

包含 10 个土豚洞的最大集群

应用质心图中的代码并为相应的簇添加连接线，会产生标记所有连接孔的图像。对于未来的可视化，将有可能计算集群的中心点，并围绕它绘制一个半径。目前，我们只尝试了固定半径。根据每个群中的洞的数量使用可变的一个将极大地改善这种可视化。这样一个集群的相应半径，然后可以通过赋予它一个概率增强效应来用于改进人工智能模型。然后，其中的对象将被标记为土豚洞，具有更高的确定性，因为预先存在该区域是聚类的一部分的知识。

集群投影和半径概念

图象分割法

尽管我们的模型在估算土豚洞的真实尺寸时给了我们非常好的结果，但在处理枯树时却不那么成功。正如我们在上面的可视化中已经看到的，遮罩本身就是问题所在，因为它不够精确。为了获得更好的效果，我们将注意力转移到了边界框和它所包围的物体上。由此看来，对这件作品进行图像分割似乎是合理的。

K-均值聚类

用于图像分割的最著名的算法之一。有很多关于这个主题的文章，最好看一看，以便更好地理解底层的过程。我们按照这篇文章的思路构建了一个处理裁剪图像的函数。

然后，它输出原始图像旁边的分割图像，并显示图像中存在的颜色和绝对值。

k-均值分割

我们已经可以看到这里的主要问题。颜色太相似了。很难从背景中分辨出枯树的颜色。在这个特殊的例子中，采用阴影(最暗的颜色)作为尺寸的指示器似乎是有用的，但是它不是一个通用的解决方案，并且对于其他物体是无效的。不幸的是，即使是更大的 K 也不能解决这个问题，因此唯一合理的步骤是更进一步，依靠最新和最先进的聚类和图像分割形式之一。

自组织映射 ( SOM):

Derrick Mwiti 用简单明了的方式解释了它的原理:

“自组织映射是一类用于特征检测的无监督学习神经网络。它们用于产生训练样本的低维空间。因此，它们被用于降维。”

他在 SOMs 上写的文章是进入这个话题的一个很好的入口，非常适用于死树问题。与 Derrick 所做的类似，我们可以将minicom实现应用到我们自己的输入中。

绘制 img_som，聚类和对应的权重我们得到如下结果。

具有 9 种学习颜色的 SOM

很明显，即使是 SOMs 也不能解决颜色相似的问题。虽然它没有为我们解决任何问题，但我们从图像分割中得到了有价值的知识:现在这是一个死胡同。这可能看起来很烦人，但是提高估计的唯一方法是回到掩码。重新标记数据和更加小心地选择 labelme 中的对象可能看起来远不如应用最先进的技术迷人，但这往往是必要的罪恶。要有好的结果，良好的投入是必要的！

在这个项目中，我与 Nuray Agaoglu 一起研究数据科学部分，我衷心感谢她投入的时间。

如何处理增强树的曝光偏移

原文：https://towardsdatascience.com/how-to-handle-the-exposure-offset-with-boosted-trees-fd09cc946837?source=collection_archive---------16-----------------------

保险业从 GLM/GAM 模式转向 GBM 模式的三种方式。

斯科特·格雷厄姆在 Unsplash 上拍照

在保险环境中，索赔频率建模的一个常见任务是处理不同的风险等级。暴露是一个宽泛的术语，保险媒体将其定义为“对损失或风险的敏感性”，但在我们的例子中，它将与时间类似。

我们预计，如果一个实体遭受某项风险达一年之久，其索赔频率会高于仅遭受该风险一周的情况。如果我们有历史索赔信息，但不是我们观察到的所有政策都持续了一年，那么在建模时必须考虑到这一点。传统上，GLM 或 GAM 模型用于预测索赔频率，这些包中的大多数都有一个所谓的偏移参数，让您自动添加暴露的影响。

本质上，我们要求模型根据可用数据进行预测，但我们对暴露部分进行微观管理。

如果您碰巧切换到梯度增强树模型，您将很快意识到在这些包中没有显式的偏移参数。在各种论坛上可以找到很多关于这个话题的讨论，有不同的解决方案，但我还没有真正找到一个值得信赖的综合来源。我决定我将得到这个结束，并彻底调查哪种方法工作，为什么。

摘要

我们将模拟一个数据集，并根据泊松分布(保险业中一个非常常见的假设)定义索赔计数。测试是在 R 中用 LightGBM 包完成的，但是应该很容易将结果转换成 Python 或其他包，如 XGBoost。

然后，我们将研究 3 种方法来处理不同程度的暴露。我们将看看预测有多准确，然后深入研究提升树算法，找出它们是如何工作的。

正如我提到的，最初的动机是一个保险问题，但我们所谈论的将完全适用于任何其他你有时间因素的原则。这不是 LightGBM 的一般教程。然而，我在文章的最后列出了一些通用的技巧。

完整代码在一个 R 脚本中，可以从 my GitHub 中获取。

重要提示:就像你在网上读到的任何东西一样，仔细阅读这些信息。这些软件包很可能会改变现状。总是自己尝试和测试事情。

我们的测试环境

r 包

我们需要以下两个 R 包:

数据表；
lightgbm 。

我们用data.table代替默认的data.frame，这只是我个人的喜好。如果你看到类似table[,.(column_name)]的东西，那就是data.table语法。

模拟数据

他们有两个分类变量，var1和var2。在曝光为 1 的观察中，不同的组合在泊松分布中将具有以下λ:

 var1 var2 lambda_base
1:    A    C         0.3
2:    B    C         0.7
3:    A    D         1.3
4:    B    D         1.9

然后，我们将产生不同的曝光水平，并调整 lambdas。

例如，var1=A，var2=C，exposure = 0.4 的观测，索赔计数将从λ为 0.3 * 0.4 = 0.12 的泊松分布中随机生成。

我们创建了数据表的两个变体，一个简单的，一个适中的。这两个版本的区别在于我们产生风险的方式。对于data_easy，它们被明确定义为 0.1、0.2、…1.0 的集合，而对于data_mod，曝光在 0 和 1 之间随机生成。

我们还生成调整后的索赔计数、定义的 claim_counts / expos(我们稍后会用到)。这是数据表的外观，列名缩写以适应屏幕:

 var1 var2  expos lambda_base  lambda ccn  ccn_adj
    1:    A    C 0.3078         0.3 0.09234   0 0.000000
    2:    A    C 0.2577         0.3 0.07731   0 0.000000
    3:    A    C 0.5523         0.3 0.16569   0 0.000000
    4:    A    C 0.0564         0.3 0.01692   0 0.000000
    5:    A    C 0.4685         0.3 0.14055   0 0.000000
   ---                                                  
 9996:    B    D 0.5999         1.9 1.13981   1 1.666944
 9997:    B    D 0.9259         1.9 1.75921   0 0.000000
 9998:    B    D 0.6517         1.9 1.23823   2 3.068897
 9999:    B    D 0.6904         1.9 1.31176   4 5.793743
10000:    B    D 0.6317         1.9 1.20023   3 4.749090

目标

在进入建模部分之前，重要的是考虑我们期望模型预测什么。

有些人可能认为我们期望预测claim_counts。这是不正确的。claim_counts是一个随机变量，期望模型能够预测是“不公平的”。

我们关心的是模型对λ参数的预测有多好。

解决方案 1 —初始分数

在第一个解决方案中，一个经常在论坛上建议的方案，我们将lgb.Dataset的init_score参数设置为曝光的对数。

密码

solution_1_predict <- function(data_curr){ data_curr_recoded <- lgb.convert_with_rules(
    data = data_curr[,.(var1, var2)])$data

  dtrain <- lgb.Dataset(
    data = as.matrix(data_curr_recoded),
    label = as.matrix(data_curr[,.(claim_count)]),
    init_score = as.matrix(data_curr[,.(log(expos))]),
    categorical_feature = c(1,2))

  param <- list(
    objective = "poisson",
    num_iterations = 100, 
    learning_rate = 0.5)

  lgb_model <- lgb.train(
    params = param, 
    data = dtrain, 
    verbose = -1)

  return(predict(lgb_model, as.matrix(data_curr_recoded)))
}

请注意，LightGBM 预测没有受到init_score的影响！所以在我们的例子中，当我们做一个预测时，我们必须手动乘以暴露量。(我认为它在 XGBoost 中的工作方式不同，除非另有说明，这里包含了base_margin。)

进行预测的正确方法是:

temp_predict <- solution_1_predict(data_easy)
data_easy[,sol_1_predict_raw := temp_predict]
data_easy[,sol_1_predict := sol_1_predict_raw * expos]

当然和data_mod的过程相同。

结果

原始预测非常接近基本的 lambdas，初看起来模型似乎是成功的。对于data_mod，结果:

data_mod[,.N, keyby = .(lambda_base, sol_1_predict_raw)]

 lambda_base sol_1_predict_raw    N
1:         0.3         0.2941616 2500
2:         0.7         0.6677160 2500
3:         1.3         1.2907763 2500
4:         1.9         1.9207416 2500

索赔总数也与预测相符。

 claim_count pred_claim_count theoretical_claim_count
1:        5208             5208                5241.001

观察它和理论上的期望值，也就是 lambdas 的和，是不一样的。

预测的可能性

让我们分析一下，如果预测值与理论值不完全匹配，我们是否会感到满意。我们将解决方案 1)的性能与简单预测λ的模型的性能进行比较。

首先，我们计算对数似然性:

data_mod[,sol_1_ll := dpois(x = claim_count, 
                            lambda = sol_1_predict, log = TRUE)]
data_mod[,base_ll := dpois(x = claim_count, 
                           lambda = lambda, log = TRUE)]
data_mod[,saturated_ll := dpois(x = claim_count, 
                            lambda = claim_count, log = TRUE)]
data_mod[,null_ll := dpois(x = claim_count, 
                            lambda = mean(claim_count), log = TRUE)]
data_mod[,.(sol_1_ll = sum(sol_1_ll), 
            base_ll = sum(base_ll), 
            saturated_ll = sum(saturated_ll), 
            null_ll = sum(null_ll))]

退货:

 sol_1_ll   base_ll saturated_ll   null_ll
1: -8125.188 -8126.383     -3918.93 -10101.24

正如我们所看到的，我们的解决方案的对数似然比我们简单地使用 lambdas 进行预测的结果要高一点点。这意味着我们可以对我们的结果感到满意！

顺便说一下，从对数似然性，我们也可以计算出解释偏差的百分比。我不想跑题文章，代码请参考我的 GitHub 。

然而，我认为重要的是要强调，对于一个几乎完美描述了所有非随机效应的模型，解释的偏差百分比仅为 32%。

它是如何工作的？

我最初对这种方法非常怀疑，我的想法是这样的:“设置 init_score 可以加快这个过程，但最终，模型会远离这些数字。获取日志更没有意义，对于非负目标，它将是一个负数。”这是不正确的。

对数是必要的，因为“poisson”物镜将使用对数链接，即使文档中没有提到这一点。这意味着计算出的原始分数的指数将是模型返回的最终预测值。

注:其实挺有意思的，无论是 XGBoost 的 还是 LightGBM 的 文档都会特别提到 Tweedie 和 Gamma 使用了 log-link，但是没有指定用 Poisson。我知道 log-link 是针对阿松的 规范链接函数 ，但看起来确实有人抄袭了他们的答案！

当我们放入init_score时，我们实际上设置了观测值之间的固定差异。如果曝光是两次观察之间的唯一差异，预测的比率将与曝光相同。

例如，在我们的例子中，如果我们有以下两个观察结果:

 var1 var2  expos
    1:    A    C    0.5
    2:    A    C    0.3

第一个将得到一个修正对数(0.5)，第二个在其预测总和中得到一个修正对数(0.3)。一旦设置完毕，模型就只能使用var1和var2。由于这两个观察值相等，模型无法以任何其他方式区分它们，第一个预测值将始终等于第二个预测值的 0.5/0.3 倍。

这就是我们想要的。拟合模型，同时考虑这种假设的线性暴露影响。

解决方案 2——经调整的索赔

这是我经常看到的另一个解决方案。

首先，计算调整后的索赔次数=索赔次数/风险。例如，如果您只有 0.5 的风险敞口和 3 项索赔，则调整后的索赔数为 3 / 0.5 = 6。
您根据调整后的索赔数量运行模型。
你还需要用曝光率作为权重。(现在没有关于曝光的日志材料！)

让我们看看这个解决方案的表现如何！

密码

代码与解决方案 1)几乎相同，但是

我们的目标不同；
我们没有使用log(expos)作为init_score，而是将expos作为weight放入。

solution_2_predict <- function(data_curr){

  ... (same as solution 1) ...

  dtrain <- lgb.Dataset(
    data = as.matrix(data_curr_recoded),
    label = as.matrix(data_curr[,.(claim_count_adjusted)]),
    weight = as.matrix(data_curr[,.(expos)]),
    categorical_feature = c(1,2))

  ... (same as solution 1) ...
}

结果

不再赘述，结果将与解决方案 1)完全匹配。

这使得关于应该使用哪种解决方案来处理偏移的争论变得毫无意义。

它是如何工作的？

那么，为什么我们从两个看似不同的模型中得到了相同的预测呢？

我们必须考虑提升树(以及一堆其他使用梯度下降的机器学习模型)如何处理最大似然估计。在引擎盖下，他们不会使用原始形式的似然函数。相反，他们将使用对数似然函数相对于预测值的一阶和二阶导数。这些被称为梯度和黑森。

在这个方向上走得更远真的会让我们偏离主题，XGBoost 教程有一个很好的总结。(这里的 g(i) 和 h(i) 函数在文本中没有明确命名，但是它们是 gradient 和 hessian。)底线是，如果你知道目标的梯度和 hessian(比如“泊松”)，你就知道目标。

让我们看看 LightGBM 源代码中的相关位。在RegressionPoissonLoss类下，我们有这个位:

gradients[i] = static_cast<score_t>((std::exp(score[i]) - label_[i])    * weights_[i]);        
hessians[i] = static_cast<score_t>(std::exp(score[i] + max_delta_step_) * weights_[i]);

注意事项:

在这个术语中，分数代表预测。
你可以通过计算导数来重现公式的基础。
权重参数没有任何更深的数学意义，这是它们将如何被用来衡量梯度和黑森。当然，如果不定义权重，就不使用* weights_[i]位。
max_delta_step_在黑森只是一个确保收敛的值。如果我理解正确的话，XGBoost 和 LightGBM 的默认值都是 0.7。

现在，让我们看看给定的claim_count — prediction对会发生什么。

在解决方案 1)中，转折是log(exposure)被自动添加到预测中，因此梯度将是:

exp(prediction + log(exposure)) - claim_count

这等于:

exp(prediction) * exposure - claim_count

而对于解决方案 2)，我们使用权重，因此梯度将简单地乘以曝光度，另外请注意，我们使用调整后的索赔计数作为标签。溶液 2 的梯度):

(exp(prediction) - claim_count_adjusted) * exposure

考虑到

claim_count_adjusted = claim_count / exposure

解 2)的梯度也将等于

exp(prediction) * exposure - claim_count

同样的思考过程可以重复用于 hessian 计算。

对于(预测、曝光、索赔 _ 计数)的任何可能值，两个解决方案具有相同的梯度和 hessian ，它们的所有学习参数都匹配，因此它们将返回相同的预测。

我会留下一点时间来处理这个，我认为这是一个很酷的结果。

解决方案 3 —自定义目标函数

既然我们对“泊松”目标有了如此透彻的理解，我想我们还不如编写我们自己的自定义目标函数。

我不打算在这里包括一个通用教程，我认为 R 演示脚本是相当有帮助的。要点是定制目标函数需要返回两个向量:gradient和hessian。

密码

对于自定义目标函数，我们基本上使用了我们到目前为止讨论过的所有内容。无论我们预测什么，都会随着曝光率自动调整，下文称之为dtrain_expos。黑森里的 0.7，简直就是我们前面说的max_delta_step_。

my_poisson_w_exposure <- function(preds, dtrain){

  labels <- getinfo(dtrain, "label")
  preds <- matrix(preds, nrow = length(labels))
  preds_expos_adj <- preds + log(dtrain_expos)
  grad <- exp(preds_expos_adj) - labels
  hess <- exp(preds_expos_adj + 0.7)

  return(list(grad = grad, hess = hess))
}

然后，我们可以使用这个新的目标函数，而不是内置的“泊松”函数。

solution_3_predict <- function(data_curr){

  data_curr_recoded <- lgb.convert_with_rules(
    data = data_curr[,.(var1, var2)])$data

  dtrain <- lgb.Dataset(
    data = as.matrix(data_curr_recoded),
    label = as.matrix(data_curr[,.(claim_count)]),
    categorical_feature = c(1,2))

  param <- list(
    max_depth = 2,
    objective = my_poisson_w_exposure,
    metric = "mae",
    num_iterations = 100, 
    learning_rate = 0.5)

  lgb_model <- lgb.train(
    params = param, 
    data = dtrain, 
    verbose = -1)

  return(predict(lgb_model, as.matrix(data_curr_recoded)))
}

瞧，基本上就是这样。请注意，我随机输入了“mae”作为度量。每个内置目标都有一个默认的度量对。当我们使用自定义目标时，需要对其进行定义。如果我们想要谨慎，我们还需要定义一个定制的度量函数。但是我们现在没有使用测试集，所以它不会在任何地方使用。

这种方法有两个缺点:

我无法找到在自定义目标函数中包含另一个参数的方法。因此，data_expos只是被假设为在全球环境中可用，这对我来说并不意味着稳定的结构。也许有一种方法可以输入除preds和dtrain之外的参数，一定要让我知道。
除了将从模型中得出的原始预测与暴露量相乘之外，我们还需要计算它们的指数。在内置的“泊松”目标中，有一个额外的步骤来计算原始分数的指数。换句话说，它使用了一个日志链接。这是我在自定义目标中无法做到的。

考虑到这两个问题，使用这种方法进行预测的正确方法是:

dtrain_expos <- as.matrix(data_mod[,.(expos)])
temp_predict <- solution_3_predict(data_mod)
data_mod[,sol_3_predict_raw := temp_predict]
data_mod[,sol_3_predict := exp(sol_3_predict_raw) * expos]

结果

是的，与前两个解决方案相同。

哪个解决方案是最好的？

这是一个个人偏好的问题，从计算的角度来看，它们是相同的模型，并将计算相同的预测。

我认为带有init_score的解决方案 1)是最优雅和简单的。我怀疑那也是最快的。
解决方案 3)，自定义目标函数是最健壮的，一旦你理解了它的工作原理，你就可以用它做任何事情。
我个人最不喜欢的是解决方案 2)，使用调整索赔计数的解决方案，我认为它有点绕弯，没有任何附加值。

一般照明 GBM 提示

我不想在上面的每个细节上花费时间，这里有一个通用提示列表，在使用 LightGBM 或某些情况下其他梯度增强树包时可能会派上用场。

分类特征

在 LightGBM 中，使用分类变量是一个两步过程:

首先，你要用convert_with_rules把它们转换成整数——这一步是必须的；
然后，当您创建lgb.DataSet时，您可能还想用categorical_feature指定数据中的哪些列是分类的——从技术上讲，模型将在没有此步骤的情况下运行，并将分类特征作为序数特征处理。

详情请看这个演示脚本。

证明文件

在我看来，软件包文档不是无缝的，你必须测试所有的东西。许多不同的版本(命令行接口，C / Python / R API)通常只是一起记录，这并没有什么帮助。

例如，我不太清楚如何定义init_score。根据相关的演示脚本，您必须使用以下语法:

setinfo(dtrain, "init_score", ptrain)

然而，这样做的时候用下面的定义lgb.DataSet:

...
init_score = ptrain,
...

似乎对我来说挺好的。set_init_score另一方面，看起来像是 Python 特有的方法。

链接功能

您应该知道您所选择的目标所使用的链接功能。例如，它使用泊松的日志链接。如果你想放入一个init_score，这很重要，你必须根据链接函数转换值。

当您运行predict方法时，您可以传递一个rawscore = TRUE参数来在转换之前获取结果并检查它们。

泊松对特威迪

如果您有非整数值，使用基本的“泊松”目标可能看起来很奇怪。毕竟泊松是离散分布。我们如何用泊松来拟合调整后的索赔数？

首先，你可以将阶乘函数扩展到非整数，所以从技术上来说，你可以在非整数处计算分布函数的值。gradient 和 hessian 也不会关心标签是否为非整数。

但是你可能仍然会倾向于使用分散参数设置为 1 的 Tweedie 分布。这样做将导致完全相同的结果。

换句话说，在模型设置中替换这一行:

...
objective = "poisson",
...

有了这个:

...
objective = "tweedie",
tweedie_variance_power = 1,
...

不会改变你的结果。

如果你看一下源代码中的泊松和特威迪损失函数，你可以看到当rho(色散参数，又名tweedie_variance_power)等于 1 时，它们是如何匹配的。

不同的术语

在 LightGBM 和 XGBoost 中，Metric、objective 和 eval 具有不同的含义。在 LightGBM 中，您需要一个目标函数来进行优化，只有在使用验证集时，才会显示指标。

好消息来源

https://xgboost.readthedocs.io/en/latest/tutorials/model.html https://github.com/microsoft/LightGBM/tree/master/R-package/demo

如何处理预测中的不确定性

原文：https://towardsdatascience.com/how-to-handle-uncertainty-in-forecasts-86817f21bb54?source=collection_archive---------14-----------------------

实践教程

对保形预测的深入研究。

每当我们做预测时，我们的估计都有不确定性。例如，让我们考虑一个柠檬水摊位，该摊位希望预测需求。如果预测非常准确，就可以采取行动，他们可以优化他们的柠檬购买策略。另一方面，如果预测有很大范围的可能值，那就没用了。

图 1:不同水平的预测区间覆盖的例子— src 。顶行显示分类，底行显示回归预测任务。“有条件的”覆盖是最稳健的。图片作者。

在2017 年的一篇论文中，卡耐基梅隆大学的研究人员解决了这个问题。他们证明了在最小假设的情况下，保形预测保证了正确的覆盖率。这个证据适用于小规模的数据集。不确定性很重要的主题，如自动驾驶汽车的物体检测，确实可以从这种方法中受益。然而，尽管保形预测已被证明是有效的，但它仍是一种相当不成熟的方法，还没有被 DS 工业广泛采用。

下面，我们将概述它是如何工作的，并提供一些实现说明...

技术 TLDR

保形预测保证了仅使用可交换性假设的预测的α水平覆盖，不需要 IID 数据。这是通过使用样本外校准集创建共形分数分布来实现的。请注意，这些保形分数本质上是基于条件概率的残差，见图 2。

图 2:共形分数的公式。图片作者。

从有序共形分数的分布中，我们找到什么分位数对应于我们的置信水平( α )。然后，我们使用该分位数来确定保证 1-α 覆盖的预测区间，而不考虑 IID 数据或正确的模型。

但是，保形预测实际上是如何工作的呢？

好吧，那是很多。让我们慢下来，真正明白发生了什么。

预测区间的背景

首先，我们来讨论一下预测区间及其问题。

简而言之，预测区间是预测值的置信区间，即我们预计未来预测的大部分将落在该范围内。

图 3:假数据 95%预测区间的例子— src 。图片作者。

在图 3 中，我们可以看到一些假数据的预测区间的例子。每个数据点上方和下方的水平线对应于 95%的预测区间范围— 我们未来预测的 95%将落在该范围内。

不幸的是，预测间隔通常需要几个假设。一些例子包括独立同分布(IID)数据以及正确指定的模型。如果您真的关心准确的预测区间覆盖率，这些假设可能会有问题。

那么保形预测带来了什么呢？

保形预测缺乏假设

保形预测只需要一个叫做互换性的假设。可交换性是指数据的任何排序都同样可能发生。

对于熟悉 IID 假设的人来说，这是“ID”部分——可交换数据相对于预测值是同分布的。

由于只需要一个假设，保形预测可以说是开发预测区间的最具统计稳健性的方法。

该方法是如何工作的？

让我们从一个二元分类的例子开始。从这里开始，我们将把概念扩展到多类分类以及预测连续变量。

图 4:我们的二元分类目标是确定一幅图像显示的是一头牛还是一头骆驼。图片作者。

如图 4 所示，我们希望确定一幅图像显示的是骆驼还是奶牛。如果我们认为图像显示的是一头牛，我们将预测 y=1，如果我们认为图像显示的是一头骆驼，我们将预测 y=0。

步骤 1-创建一个共形分数分布

在我们的第一步中，我们开发了训练/测试分割，并使用训练数据拟合分类模型。假设我们使用逻辑回归。拟合模型后，我们使用测试集(称为校准集)开发因变量(奶牛对骆驼)的概率预测。

在这一阶段，我们有了校准集中每个观察值的预测概率向量。

从那里，我们使用每个预测的概率计算共形分数。图 5 中定义了保形分数的公式。

图 5:包含每个变量定义的共形分数公式。图片作者。

共形分数可以认为是非共形分数。它们取值在-1 和 1 之间，越接近任一极端，就越偏离观察到的标签。请注意，我们经常使用绝对值，因为我们只关心不符合的程度，而不是方向。

在获得我们校准集中所有标签的共形分数后，我们将共形分数的绝对值从低到高排序。

步骤 2-创建预测间隔

有了保形分数的分布，我们可以将这个概念与预测区间联系起来。

如前所述，预测间隔要求工程师指定一个假阳性率( α )，通常为 0.05 或 0.01。为了找到我们的预测区间的上限和下限，我们找到对应于 α的分布中的分位数。

图 6:通过预测二元类的概率找到的分级共形分数的示例分布。图片作者。

在图 6 中， α- 水平分位数由标有绿色“临界阈值”的垂直线表示。x 轴对应于一组有序的共形分数。假设他们有 500 人。蓝色和红色的交叉点，即“临界阈值”，是百分位数 1-α 。因此，如果 α 为 0.1，那么统计显著性的截止值将是第 90 百分位的一致性分数，例如第 450 一致性分数。

蓝色的适形分数没有统计学意义。它们在我们的预测区间内。非常大的共形分数(红色)表示与真实标签的高度偏离。这些适形评分具有统计学意义，因此超出了我们的预测区间。

还要注意，我们推导出每个标签的分位数截止值。

步骤 3-估计每个标签的概率

从这里开始，对于每一次观察，我们确定成为牛、骆驼、两者或都不是的概率。这是怎么做到的？

嗯，对于每个观察，我们计算每个标签的共形分数，例如骆驼和母牛。从那里，我们确定每个适形分数是否超过其相应的临界阈值。如果超过阈值，我们认为它在统计上是显著的，因此是错误的。如果不是，我们认为这是真的。

图 7:分类矩阵。蓝色和红色的值分别对应于非 stat-sig 和 stat-sig 预测。作者图片

我们的二元分类问题有四种可能的结果，如图 7 所示。红色表示预测在统计上有意义，蓝色表示没有意义。这里，统计显著性意味着预测是假的，缺乏统计显著性意味着预测是真的。

让我们依次看看每个单元格…

左上角:两个标签都不具有统计显著性的预测。在这里，模型预言这两个阶级都是真正的阶级。
右下:两个标签都具有统计显著性的预测。在这里，模型预测这两个类都不是真正的类。
右上:所有 camel 标签(0)都不具有统计显著性的预测。在这里，模型预测 camel 才是真正的类。
左下:所有奶牛标签(1)都不具有统计显著性的预测。在这里，模型预测牛才是真正的类。

这一步可能有点违反直觉。一个模型怎么能预测一个以上的类甚至根本没有类呢？

让我们采取一种直观的方法。简单的二进制分类模型找出哪个类的概率最高，并将其确定为预测。但是有了保形预测，我们可以让模型说两者都不是或者都不是真正的标签。实际上，模型可以说“我不知道”

因为我们不强迫模型做出预测，所以我们在预测集中得到了更可靠的预测。

并且，我们的 1-α 预测集只有一个预测，即右上角和左下角的单元格。

扩展到更复杂的标签

既然我们已经理解了保形预测对于二元分类是如何工作的，那么这个概念就可以很容易地扩展到多级分类。在第 3 步中，我们发现被标记为 1，0，两者皆是，或都不是的概率，我们只是对三个级别而不是两个级别进行相同的操作。

从概念上讲，这是一个简单的下一步，但计算上的复杂性呈指数增长，因此对具有许多级别的标签进行保形预测并不总是一个好主意。

对于连续变量，有几种方法，但最简单的是预测分位数而不是平均值。如前所述，我们可以将共形分数视为残差:真实的 y 减去预测的 y 。然而，与分类变量不同，我们没有固定数量的标签可供尝试。

因此，对于连续标签，我们尝试预测有限数量的不同分位数，并查看它们在哪里变得具有统计显著性。对于处于统计显著性边缘的值，我们认为它们是 α- 水平预测区间。请注意，分位数损失可以添加到几乎任何建模损失函数中，这就是为什么它被称为“最简单的”

如果你想了解更多，这里有一个非常好的资源，可以在连续变量上使用保形预测。

现在你知道了！全盛时期的共形预测。

摘要和实施说明

为了深入理解这些概念，让我们总结一下。

保形预测是开发预测区间的最少假设的方法。因此，这是最普遍的防御方法。它还适用于小样本数据集，可以产生更精确的预测区间/集合。

该方法利用共形分数的分布来开发标记的任何组合为真的概率的排列。如果预测的概率足够低，即保形分数足够大，我们认为它在我们的预测区间之外。然后，这些排列用于开发连续变量的预测区间或分类变量的预测集。

这种方法仍然没有得到太多的关注，但它对预测建模有着巨大的潜力。

感谢阅读！我会再写 36 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源和一些有用的资源。

如何隐藏/加密/混淆任何 Python 程序

原文：https://towardsdatascience.com/how-to-hide-encrypt-obfuscate-any-python-program-51beea81571f?source=collection_archive---------3-----------------------

约翰·萨尔维诺在 Unsplash 上拍摄的照片

出于混淆的目的，我们将使用一个名为 pyarmor 的 python 包。

我们有时可能会面临这样的情况，由于显而易见的原因，我们需要直接向客户提供代码，但是这样做，我们将失去对代码的控制。在这种情况下，我们可能会加密代码来保护它，保留控制权，并添加一些回退条件来控制我们的依赖性，就像我们提供的代码只能在一定时间内使用一样。

为了解决上述问题，我将演示一个具有上述功能的简单函数。我们将使用名为“pyarmor”的 python 库。

1.创建简单的函数

对于我们的实现，我将使用带有推理函数定义的 utils.py，稍后将对它进行加密。

推理函数非常简单，不需要任何解释。

将它保存在一个文件夹中。

2.用 pyarmor 加密它

现在，我们将通过运行以下两个命令来加密它。

pip3 install pyarmor # pip/pip3# Syntax : pyarmor obfuscate --restrict=0 <filename>pyarmor obfuscate --restrict=0 utils.py

1.安装软件包

2.加密 utils.py 函数

现在，如果您看到包含实际 utils.py 文件的文件夹，将会创建一个名为 dist 的新的子文件夹。

在左边的 utils.py(原始文件)和右边的 dist 文件夹中，我们有(加密的)utils.py 文件

让我们看看里面的东西。

dist 子文件夹中的加密 utils.py 文件

3.导入我们的函数/推理

完成后，到现在为止，让我们尝试将这个加密的 utils.py 导入到一个名为 main.py 的新 python 文件中，这个文件是在 dist 文件夹中创建的。

pyarmor 负责在运行时解密 utils.py 所需的密钥，这些密钥存在于 pytransform 文件夹中，因此我们的代码在别人看来完全不可读。

但是如果您希望修改原始的 utils.py 代码，那么您必须从第 1 步开始，并遵循相同的步骤来完成。

main.py 文件中内容，

# Import the inference function definition inside the utils.py filefrom utils import inference_ = inference(name="Balakrishna")

在运行上面的代码行时，我们得到了基于 utils.py 文件配置的输出。

最终输出。

结论:

这仅仅是开始。如果你想真正保护和销售你的代码，考虑添加一个嵌入虚拟日期的实际许可证。超过该日期后，它将不再运行该程序，并抛出一个许可证到期错误。幸运的是 pyarmor 也有。我在下面的参考资料中添加了与许可相关的文档。您甚至可以设置一个条款，在许可过期后自动发送电子邮件，并且您可以使用 python 中的 SMTP 服务与您的客户端取得联系。

如果你有很多。py 文件导入或作为依赖项，必须使用—递归命令行而不是— restrict 命令，代码才能工作。

此外，这种实现可以在 Windows 和基于 Ubuntu 的操作系统中完成。

参考资料:

完整的代码实现可从以下网址获得:

@GitHub

https://github.com/bala-codes/Code-Encryption-Obfuscation---Python

皮铠甲:

【https://pypi.org/project/pyarmor/
https://github.com/dashingsoft/pyarmor
https://pyarmor.readthedocs.io/en/latest/
https://py armor . readthe docs . io/en/latest/usage . html # generating-license-for-obfuscated-scripts
https://docs.python.org/3/library/smtplib.html

如何在 Github 上托管 Jupyter 笔记本幻灯片

原文：https://towardsdatascience.com/how-to-host-jupyter-notebook-slides-on-github-d785f30e6e2?source=collection_archive---------29-----------------------

制作幻灯片和在 Github 上托管 html 文件的工作量最小

凯莉·西克玛在 Unsplash 上的照片

点击这里查看这篇文章的幻灯片:https://sophiamyang.github.io/slides_github_pages/.

本文分为两个部分:

如何将您的 Jupyter 笔记本变成幻灯片并输出到 html 文件。
如何在 Github 上托管 html 文件？

Jupyter 笔记本幻灯片

首先，我们创建一个新环境slideshow，安装一个 Jupyter 笔记本扩展 RISE，并启动 Jupyter 笔记本:

conda create -n slideshow -c conda-forge python=3.9 rise
conda activate slideshow
jupyter notebook

然后像往常一样创建一个 Jupyter 笔记本文件:

单击视图→工具栏→幻灯片显示，定义每个单元格的幻灯片类型。
RISE 在工具栏的右上角创建了一个按钮“进入/退出实时显示幻灯片”。
单击此工具栏，您将能够以幻灯片形式查看您的笔记本。

幻灯片到 html

如果您有代码单元格并希望显示所有代码单元格，请使用:

jupyter nbconvert github_page_example.ipynb --to slides --stdout > index.html

如果您想要隐藏所有代码单元格:

jupyter nbconvert github_page_example.ipynb --no-input --no-prompt --to slides --stdout > index.html

如果您想隐藏某些单元格的代码，我们可以通过视图→单元格工具栏→标签为这些代码单元格添加标签。这里我使用标签“移除输入”。

jupyter nbconvert github_page_example.ipynb --TagRemovePreprocessor.remove_input_tags "remove_input" --to slides --stdout > index.html

Github 上的主机 html 文件

要在 Github 页面上发布一个 html 文件，我们需要推送到gh-pages分支。

使用 gh-pages 分支在本地创建新的 git repo:

git init
git checkout -b gh-pages
git add index.html
git commit

去 Github 创建一个新的空 repo，然后把我们的文件推送到gh-pages分支。

git remote add origin git**@github**.com:YOUR_USER_NAME/YOUR_REPO_NAME.git
git branch -M gh-pages
git push -u origin gh-pages

现在你可以在 Github 页面上看到这个幻灯片:https://YOUR _ USER _ NAME . Github . io/YOUR _ REPO _ NAME

看看我的:https://sophiamyang.github.io/slides_github_pages/.

参考:

https://rise.readthedocs.io/en/stable/

https://pages.github.com/

作者索菲亚·杨 2021 年 7 月 18 日

如何用 Apache 虚拟主机托管多个网站

原文：https://towardsdatascience.com/how-to-host-multiple-website-with-apache-virtual-hosts-4423bd0aefbf?source=collection_archive---------0-----------------------

使用 Ubuntu 20.04 托管网站，包括子域

照片由克里斯蒂娜@ wocintechchat.com在 Unsplash 上拍摄

介绍

Apache 的虚拟主机可以在一台服务器上运行多个网站。在这篇文章中，你将学习如何托管多个网站，包括子域。

我的 Ubuntu 20.04 服务器在/etc/apache2/sites-available目录下有一些文件。我们将在该目录中创建更多文件，以创建多个虚拟主机。

$ ls /etc/apache2/sites-available
000-default.conf       000-default-le-ssl.conf  default-ssl.conf
000-default.conf.dpkg-dist

创建新的虚拟主机

让我们为example.com创建一个虚拟主机。(你需要把 example.com 改成你的域名。我们把文件存放在/var/www/example.com/public_html目录下。如果你想使用 Git 部署你的网站，请参考本文“ 如何创建一个 Git Hook 推送到你的服务器和 Github Repo ”。

步骤 1 —创建一个配置文件

复制000-default.com.conf在/etc/apache2/sites-available新建一个文件:

$ cd /etc/apache2/sites-available
$ sudo cp 000-default.com.conf example.com.conf

步骤 2-修改新的配置文件

在example.com.conf中:

第 2 行:为 ServerAdmin 添加您的电子邮件。第 4 行:将 www 添加到 ServerAlias 的域名中。
第 5 行& 6:添加 DocumentRoot 的文件目录。

步骤 3 —启用虚拟主机

a2ensite启用apache2配置中的指定站点。它在/etc/apache2/sites-enabled中创建一个符号链接(不支持站点)。

$ sudo a2ensite example.com.conf

上面的命令将在/etc/apache2/sites-enabled目录中创建一个符号链接example.com.conf。

步骤 4—启用 SSL

$ sudo certbot --apache -d example.com -d www.example.com

这将在/etc/apache2/sites-available中查找相同的文件名。如果找不到，它会要求您选择 conf 文件。

这将创建example.com-le-ssh.conf。

步骤 5—重新启动 apache

$ sudo systemctl restart apache2

如果您的 DNS 配置正确，您应该能够看到您的域。

子域

我们将为一个子域创建一个虚拟主机。该过程与上一节相同。

我们将 web 文件存储在/var/www/newsletter.example.com/public_html中。

我们复制000-default.com.conf来创建一个新文件newsletter.example.com.conf。

$ sudo cp 000-default.com.conf newsletter.example.com.conf

编辑newsletter.example.com.conf:

与前一个示例的不同之处在于向 ServerName、ServerAlias、DocumentRoot 和 Directory 添加了一个子域。

启用虚拟主机和 SSL

让我们为这个子域启用虚拟主机和 SSL。

sudo a2ensite newsletter.example.com.conf
sudo certbot --apache -d newsletter.example.com -d www.newsletter.example.com

向 DNS 服务添加记录

如果您使用的是 namecheap.com，请转到域列表>高级 DNS 并添加新记录。

可能需要 24-48 小时。

重新启动 apache

$ sudo systemctl restart apache2

确认您的 DNS

使用https://www.whatsmydns.net/检查您的 DNS。如果您配置正确，它会显示您的 IP 地址。

`etc/apache2/sites-available`

现在您在sites-available目录中有了以下文件。

ls /etc/apache2/sites-available/
000-default.conf              000-default.conf.dpkg-dist
default-ssl.conf              000-default-le-ssl.conf 
example.com.conf              example.com-le-ssl.conf 
newsletter.example.com.conf   newsletter.example.com-le-ssl.conf

xxxx-le-ssl.conf文件用于您的 SSL。

如何删除虚拟主机

使用a2dissite命令禁用现有的虚拟主机。

$ sudo a2dissite 000-default.conf
$ sudo a2dissite 000-default-le-ssl.conf

在这里，您正在禁用000-default.conf及其 SSL 虚拟主机。

结论

现在您知道了如何在您的服务器上创建虚拟主机。这允许你在一台服务器上托管尽可能多的网站。

通过成为 会员，获得媒体上所有故事的访问权限。

请订阅。

参考

如何在 Ubuntu 18.04 上设置 Apache 虚拟主机
Apache 配置错误 AH00558:无法可靠地确定服务器的完全限定域名

如何在 7 分钟或更短时间内找到一位聪明的数据科学家

原文：https://towardsdatascience.com/how-to-identify-a-clever-data-scientist-in-7-minutes-or-less-2593ff53b2aa?source=collection_archive---------6-----------------------

区分聪明的数据科学家的关键特征

在我主持的这个现场培训环节，用 TensorFlow 和 Keras 学习 AI 和深度学习的基础知识。

照片由马库斯·温克勒在 Unsplash 上拍摄

聪明和聪明是有区别的。一般来说，数据科学家和机器学习从业者都很聪明，这意味着他们拥有一般的技术智能，这使他们在自己的行业内令人生畏。

另一方面，聪明超越了智力。为了指导行动和决策，聪明的数据科学家在互动过程中结合情感线索、行为模式、环境知识等。

他们讲述引人入胜的故事

照片由 NeONBRAND 在 Unsplash 上拍摄

讲故事，这个短语概括了一个模范沟通者所需要的特征和技能。聪明的数据科学家是有效的沟通者。他们利用讲故事的艺术来完成既定的目标或传达想法。

对沟通等软技能的要求可能被视为次于编程、测试研究或分析技能等技能。尽管如此，聪明的数据科学家认识到与客户、团队成员、顾客和经理培养稳定关系的重要性。讲故事是一种行之有效的方法。

我用讲故事的方式解释了特定技术决策对项目交付、应用程序实现和维护的影响。

例如，使用个人轶事来解释为什么利用苹果发布的深度学习模型有利于使用第三方维护的开源解决方案。

在上面的场景中，利用讲故事比简单地陈述一个显而易见的事实有更好的结果，即苹果等知名品牌发布的软件有很高的可靠性。有时，在观点中加入个性化的元素会引起接受者的共鸣。

此外，讲故事为非技术人员解释机器学习项目中利用的技术和工具增加了人性化的成分。期望普通人理解我们与机器学习实践者同事使用的技术术语几乎是不合理的。

史蒂夫·乔布斯是一个很会讲故事的人，他讲故事的技巧给简单的硬件赋予了灵魂。聪明的数据科学家对数据也是如此。将从数据中收集的情报与人性化的语言注释结合起来，你将获得左右观众的能力。

讲故事不一定要用语言。书面笔记、文章或文件能以一种特殊的方式传达信息和思想，这是口头形式所不能做到的。

以媒体上的数据科学家为例。我遇到过一些人，他们在各自的专业领域表现出色，但他们会采取额外的措施，通过媒体文章来交流他们的经验、知识和专业技能。

关于讲故事，有太多的信息可以分享，以及在技术角色中应用时实现的好处。但是我将把它留到以后的文章中。

提高讲故事和沟通技巧的步骤:

尽可能多的公开演讲。
多读书。
向其他优秀的演说家学习。

他们不会忽视影响

由在 Unsplash 上拍摄的

作为一名计算机视觉工程师，我试图认识到自己对公司其他部分的影响。我承认，我集成到我们旗舰应用程序中的解决方案的速度和准确性是决定我们目标受众中产品采用率的因素。

数据科学家有影响，我们产生的输出也有影响。以下是几个影响类别供您考虑:

业务影响:数据相关活动是技术驱动型公司的核心。数据科学家执行的操作加强了典型业务运营、决策和研究的流程。
产品影响:解决方案或服务驱动的业务在持续交付给客户的基础上蓬勃发展。负责特性实现、维护和升级的 DS 和 ML 实践者共同承担交付可用和功能性产品的责任。
社区影响:在人工智能和数据驱动技术融入社会的当今时代，数据科学家的工作影响着团体和社区的活动。
道德影响:我们的工作对个人的生活有直接或间接的影响。ML 从业者有责任考虑技术和应用开发的道德性。

一个普通的数据科学家通常关心技术影响；具体来说，实现的技术、功能和代码对期望的结果有影响。仅从技术影响的角度来看并没有坏处。但是聪明的数据科学家会更进一步，考虑其他影响。

考虑到数据科学工作的成果可能产生的其他形式的影响，支持了你作为机器学习专业人员进行长期思考的印象。

作为技术团队和项目涉众之间的中介，遇到考虑技术问题之外的因素的 ML 工程师是令人耳目一新的。更具体地说，我对那些在应用程序交付和成本的时间估算中考虑先发优势的团队印象深刻。

改善影响考虑的步骤:

问正确的问题— 稍后会详细介绍。
设身处地为项目中的其他人着想:客户、最终用户、开发者、设计师等等。
感同身受。

他们真的会听

佛朗哥·安东尼奥·乔瓦内拉在 Unsplash 上拍摄的照片

倾听的能力是一门失传的艺术。

这听起来可能有些矛盾，但是成为一个有效的沟通者的第一步是成为一个细致的倾听者。

之前，我写了一篇文章介绍典型机器学习项目中的常见阶段。第一步包括倾听客户、顾客或用户提出的问题。

在我作为一名 web 开发人员的早期，我并不是有目的地倾听客户的问题，而是渴望越过问题定义和分析阶段，直接决定是使用 Angular、React 还是 Vue 来构建解决方案。这导致我错过了客户表达的关键痛点，结果，我实现了客户不需要的解决方案。

这里学到的经验是，积极倾听项目涉众的痛点可以为您节省几个月的时间来实现解决错误问题的解决方案。

热情的 ML 实践者被库、神经网络架构和工具的细节所困扰，以构建提议的解决方案。这不是任何人的错，人工智能领域的本质需要技术驱动的个人。

但最重要的是，作为技术的倡导者，我们要提醒自己技术本身的目的，那就是减轻我们生活中的手工和费力的责任。

提高听力的步骤:

不要不必要的打断。
对不同的想法和思维持开放态度。
排除杂念。
观察身体语言暗示。

他们问了正确的问题

卡尔·约翰逊在 Unsplash 上拍照

科学是一个关注发现和利用知识的领域，在这个领域，成功或者至少是进步是由对世界本质的质疑所引导的。有时，我们会忘记数据科学中的“科学”部分。

数据科学学科要求个人具有好奇的天性。DS/ML 从业者会询问同事、客户，当然还有数据。了解如何以及何时问正确的问题是通往成功的道路。

重要的不是你问的问题的数量，而是什么创造了有影响力和有成效的参与，这取决于所问问题的质量。

客户参与

积极倾听的副产品是确定要问的正确问题，以及问这些问题的正确时间。

数据科学家经常与客户接触，或者产品用户通过询问适当的问题获得丰富的知识。虽然向潜在客户炫耀技术专长和成就很诱人，但从对方那里获取信息更为重要。

通过问开放式问题和避免诱导性问题，可以有效地从客户那里提取有价值的信息。

问题 1:什么样的见解对你企业的成功有价值？

问题 2:您希望我们提取数据洞察，指出您的客户及其位置之间的相关性吗？

上面的问题 1 是一个开放式问题的例子。它允许客户提供关于被认为重要和高价值的因素的信息。

另一方面，问题二允许二元答案，要么是，要么不是。客户没有机会详细说明，更糟糕的是，假设是由提问的数据科学家做出的。

技术约定

最近，我参与了一个机器学习团队，对于原始数据特征提取应该在应用程序管道中的什么位置发生了意见冲突。

而不是强迫他们接受我的观点，炫耀我的专业知识。我选择问正确的问题。通过非利己主义的知识交流，双方都积极地离开了约定。

在技术项目中提出正确的问题提供了一个向他人学习的机会，并广泛地与同事建立人际关系。

问正确问题的步骤:

问一些开放式的后续问题，让对方能够详细阐述具体的话题。
充分阐述问题。

结论

数据科学家形形色色。根据我的经验，我发现成功的数据科学家能够在技术智能和情感智能之间找到平衡。

请在评论区分享你认为一个聪明的机器学习实践者应该具备的品质。

感谢阅读

</5-soft-skills-you-need-as-a-machine-learning-engineer-and-why-41ef6854cef6>

想要更多吗？

订阅在我发表文章时得到通知
成为推荐媒介会员，支持我的写作
通过 LinkedIn 联系我
在 奥莱利 跟我学

如何使用 scikit-learn 实现人工智能

原文：https://towardsdatascience.com/how-to-implement-artificial-intelligence-using-scikit-learn-e4f322ae4f32?source=collection_archive---------24-----------------------

入门

这篇介绍 power Python 工具的文章将让你很快应用人工智能

图片来源:阿迈德·加德在皮克斯拜

数据科学家将人工智能(AI)用于一系列强大的用途。它现在运行控制系统，减少建筑能耗，它为购买衣服或观看节目提供建议，它有助于改善农业实践和我们可以种植的食物量，有一天它甚至可能为我们驾驶汽车。知道如何使用这些工具将使你有能力解决下一代社会的技术挑战。

幸运的是，对于已经熟悉 Python 和数据分析的人来说，开始使用人工智能并不那么具有挑战性。您可以利用强大的 scikit-learn 包来为您完成大部分艰苦的工作。

什么是 scikit-learn？

scikit-learn 是一个 python 包，旨在促进机器学习和人工智能算法的使用。它包括用于分类、回归和聚类的算法，包括流行的随机森林和梯度推进算法。这个软件包被设计成可以很容易地与常见的科学软件包 numpy 和 scipy 接口。尽管不是专门为熊猫设计的，但它也能很好地与熊猫互动。

scikit-learn 还包括一些有用的工具，有助于使用机器学习算法。开发准确预测系统行为的机器学习管道需要将数据分成训练和测试集，以及对算法进行评分以确定它们的运行情况，并确保模型既不过度拟合也不欠拟合。scikit-learn 界面包括执行所有这些任务的工具。

scikit-learn 算法是如何工作的？

开发和测试 scikit-learn 算法可以分三个一般步骤进行。它们是:

使用描述需要模型预测的现象的现有数据集来训练模型。
在另一个现有数据集上测试该模型，以确保其性能良好。
使用模型来预测项目所需的现象。

scikit-learn 应用程序编程接口(API)提供了通过单个函数调用来执行这些步骤的命令。所有的 scikit-learn 算法在这个过程中使用相同的函数调用，所以如果你学会了一个，你就学会了所有的。

训练 scikit-learn 算法的函数调用是。fit() 。来训练你称为。函数，并将训练数据集的两个组件传递给它。这两个组件是 x 数据集，提供描述数据集的特征的数据，以及 y 数据，提供描述系统的目标的数据(特征和目标是机器学习术语，本质上表示 x 和 y 数据)。然后，该算法创建由所选算法和模型参数确定的数学模型，该模型尽可能匹配所提供的训练数据。然后，它将参数存储在模型中，允许您根据项目需要调用模型的 fit 版本。

测试模型拟合度的函数是。score() 。要使用该函数，您需要再次调用该函数，并传递表示特征的 x 数据集和表示目标的相应 y 数据集。与定型模型时相比，使用不同的数据集(称为测试数据集)非常重要。当对训练数据评分时，模型很可能得分很高，因为它在数学上被迫与该数据集匹配。真正的测试是模型在不同数据集上的表现，这是测试数据集的目的。调用时。score() 函数 scikit-learn 将返回 r 值，说明模型使用提供的 x 数据集预测提供的 y 数据集的效果如何。

您可以使用 scikit-learns 预测给定输入的系统输出。预测()函数。重要的是，您只能在拟合模型后执行此操作。拟合是指如何调整模型以匹配数据集，因此如果不首先进行拟合，模型将不会提供有价值的预测。一旦模型合适，您就可以将一个 x 数据集传递给。predict() 函数，它将返回模型预测的 y 数据集。通过这种方式，你可以预测一个系统未来的行为。

这三个函数构成了 scikit-learn API 的核心，对您将人工智能应用于技术问题大有帮助。

如何创建培训和测试数据集？

创建单独的训练和测试数据集是训练人工智能模型的关键组成部分。如果不这样做，我们就无法创建一个与我们试图预测的系统相匹配的模型，也无法验证其预测的准确性。幸运的是，scikit-learn 再次提供了一个有用的工具来促进这一过程。那个工具就是train _ test _ split()函数。

train_test_split() 做的和听起来一样。它将提供的数据集分成训练数据集和测试数据集。您可以使用它来创建所需的数据集，以确保您的模型正确预测您正在研究的系统。您向 train_test_split() 提供一个数据集，它提供您需要的训练和测试数据集。然后，它返回拆分为定型数据集和测试数据集的数据集，您可以使用这些数据集来开发您的模型。

使用 train_test_split() 的时候有几个需要注意的地方。首先， train_test_split() 本质上是随机的。这意味着，如果使用相同的输入数据多次运行，train_test_split()将不会返回相同的训练和测试数据集。如果您想要测试模型准确性的可变性，这可能是好的，但是如果您想要在模型上重复使用相同的数据集，这也可能是不好的。为了确保每次都能得到相同的结果，您可以使用 random_state 参数。随机状态设置将强制它在每次运行时使用相同的随机化种子，并提供相同的数据集分割。当使用 random_state 时，习惯上将其设置为 42，这可能是对《银河系漫游指南》的幽默回应，而不是出于任何技术原因。

这两者是如何结合在一起的？

总之，这些工具创建了一个简化的界面来创建和使用 scikit-learn 工具。让我们以 scikit-learn 的 线性回归 模型为例来讨论一下。

要实现这一过程，我们必须首先导入所需的工具。它们包括 scikit-learn 模型、 train_test_split() 函数和用于数据分析过程的 pandas。这些函数按如下方式导入:

from scikit-learn.linear_model import LinearRegression
from scikit-learn.model_selection import train_test_split
import pandas as pd

然后我们可以读入一个数据集，这样它就可以用于训练和测试模型。我创建了一个真实数据集，展示热泵热水器(HPWHs)的性能作为其运行条件的函数，专门帮助人们学习数据科学和工程技能。假设您已经下载了数据集，并将其保存在与脚本相同的文件夹中，您可以使用下面的代码行打开它。如果没有，您可以根据需要调整这些步骤，在您喜欢的任何数据集上进行练习。

data = pd.read_csv('COP_HPWH_f_Tamb&Tavg.csv', index_col = 0)

下一步是将数据集分成 X 和 y 数据。为此，我们创建新的数据框，指定代表要素和目标的数据集列。在 HPWHs 的情况下，特征是水箱温度和环境温度，而目标是电力消耗。数据集包含八列，显示储水箱中八个不同深度的水温，每一列名为“Tx (deg F)”，其中 x 是代表测量位置的数字。它还包含一个列，显示热水器周围空间的测量环境温度，名为“T_Amb(华氏度)”。最后，数据集包含一个存储电力消耗数据的列，称为“P_Elec (W)”。在这种情况下，过滤我们的数据集也很重要，这样我们只在耗电时使用数据。如果我们跳过这一步，我们将把非线性引入线性模型，这将使模型失败。

我们可以使用以下代码完成所有这些步骤:

# Filter the data to only include points where power > 0
data = data[data['P_Elec (W)'] > 0]# Identify X columns and create the X data set
X_columns = ['T_Amb (deg F)']
for i in range(1, 9):
    X_columns.append('T{} (deg F)'.format(i))

X = data[X_columns]# Create the y data set
y = data['P_Elec (W)']

现在我们有了 X 和 y 数据集，我们可以将这些 X 和 y 数据集分成训练和测试数据集。这可以通过调用 scikit-learn 的函数 train_test_split() 来完成，如下所示。

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 42)

既然我们已经准备好了训练和测试数据集，我们可以创建并拟合数据集的线性回归模型。为此，我们首先创建模型的一个实例，然后调用。fit() 功能如下。

model = LinearRegression()
model = model.fit(X_train, y_train)

注意，这个实现使用了线性回归模型的默认参数。这可能会也可能不会产生与数据的良好拟合，我们可能需要更改参数来获得良好的拟合。我将在以后的文章中提供实现这一点的高级方法，但是现在使用默认参数就足以学习这些概念了。

下一步是在测试数据集上对模型进行评分，以确保它很好地符合数据集。你可以通过调用来实现。score() 并通过测试数据。

score = model.score(X_test, y_test)

如果模型在测试数据集上得分很高，那么你就有机会拥有一个训练有素的、适合数据集的模型。如果没有，那么您需要考虑收集更多的数据，调整模型的参数，或者使用完全不同的模型。

如果模型运行良好，那么您就可以声明模型可以使用，并开始预测系统的行为。因为我们现在没有额外的数据集可以预测，所以我们可以简单地预测测试数据集的输出。为此，您调用了。预测()功能如下。

predict = model.predict(X_test)

当暴露于 X_test 定义的输入时，预测变量现在将保存系统的预测输出。然后，您可以使用这些输出直接与 y test 中的值进行比较，使您能够更仔细地研究模型拟合和预测准确性。

这款车型表现如何？

由于我们计算了模型的分数，并将其保存到变量分数中，因此我们可以很快看到模型对 HPWH 耗电量的预测有多好。在这种情况下，模型的得分为 0.58。

r 是从 0 到 1 的度量。零表示该模型根本不能解释观察到的系统行为。一个表明模型完美地解释了系统的行为。0.58 的 r 值表明该模型解释了一半以上的观察到的行为，这不是很好。

我上面提到的三个潜在改进是:

收集更多的数据，
调整模型的参数，
使用完全不同的模型。

我们当然可以收集更多的数据或调整线性回归模型的参数，但这里的核心问题可能是热泵功耗和水温之间的关系是非线性的。线性模型很难预测非线性的东西！

我们可以使用为非线性系统设计的模型来尝试同样的方法，看看我们是否能得到更好的结果。一个可能的模型是随机森林回归器。我们可以通过在脚本末尾添加以下代码来尝试。

from sklearn.ensemble import RandomForestRegressormodel = RandomForestRegressor()
model.fit(X_train, y_train)
score = model.score(X_test, y_test)

这种方法得到了非常高的分数 0.9999，这在另一方面是可疑的。这个模型很有可能对数据集过度拟合，实际上在未来不会产生现实的预测。不幸的是，给定可用的数据集，我们无法真正确定这一点。如果您要使用这个模型来开始预测系统，您将需要监控它，以查看它在更多数据可用时的表现，并继续训练它。根据测量数据绘制预测图还可以洞察模型的行为。

对于这个特定数据集的例子，我会说我会信任这个模型。这是因为该数据集不包含实际测量数据，而是我通过实施回归方程创建的示例数据集，以显示 HPWH 在这些条件下的表现。这意味着 RandomForestRegressor 可能与数据匹配得很好，因为它确定了我用来创建数据集的方程。

有了这些，你就可以开始使用 scikit-learn 来实现机器学习和人工智能了！如果您记得所有 scikit-learn 算法都使用 fit() 、 score() 和 predict() 函数，并且您可以使用 train_test_split() 创建您的数据集，那么您就踏上了学习不同算法和预测实际系统行为的道路。

如何用 Memgraph MAGE，Python 和 Cypher 实现自定义 JSON 实用程序

原文：https://towardsdatascience.com/how-to-implement-custom-json-utility-procedures-with-memgraph-mage-and-python-7e66bbb8b8e3?source=collection_archive---------33-----------------------

通过使用 Memgraph MAGE 和 Python 实现几个简单的定制过程来加载和导出 JSON 格式的数据，了解如何扩展 Cypher 查询语言。

作者图片

介绍

您经常会发现自己无法提出适合手头问题的完美查询。每种查询语言都有其缺点，Cypher 也不例外。但是谢天谢地，你总是可以选择编写自己的定制程序。

Memgraph 引入了查询模块的概念，这些模块是定制密码程序的集合。您可以使用 Python 或 C API 来实现它们。

在本教程中，您将经历实现几个简单实用程序的过程，以 JSON 格式加载和导出数据。

介绍记忆图图像

MAGE 代表 Memgraph 高级图形扩展。这是一个由 Memgraph 发起的开源项目，鼓励开发人员分享创新和有用的查询模块，以便整个社区都能从中受益。

你可以在这个链接上找到法师储存库。

先决条件

要完成本教程，您需要:

一个 Memgraph DB 的安装:一个为处理企业级实时用例而构建的内存图形数据库。按照快速启动页面上的 Docker 安装说明开始。
一个 Memgraph Lab 的安装:一个集成开发环境，用于导入数据、开发、调试和分析数据库查询以及可视化查询结果。

从 JSON 文件导入数据

Memgraph 没有提供开箱即用的 JSON 处理选项。那么，如果你在即将到来的项目中需要这个特性，你有什么选择呢？

实际上，有两种方法可以导入这些数据:

独立于 Memgraph，
在 Memgraph 中使用查询模块。

第一个选项非常简单。您只需解析所需的 JSON 文档，并创建适当的查询来填充数据库。这样，Memgraph 对 JSON 文件一无所知，您必须完全自己处理它，并且只使用从 JSON 文件中提取的数据运行完成的查询。

第二个选项更加优雅，这也是你将在本教程的剩余部分学到的。

编写自定义密码程序

重要的事情先来。要开始开发新的查询模块，您需要熟悉开发过程。如果你在 Docker 之外的任何东西上运行 Memgraph，那么继续下一段，否则，跳到使用 Docker 开发定制查询模块一节。

启动时，Memgraph 将尝试从默认(/usr/lib/memgraph/query_modules)目录中找到的所有*.so和*.py文件中加载查询模块。如果您想更改 Memgraph 搜索查询模块的目录，只需更改主配置文件(/etc/memgraph/memgraph.conf)中的--query-modules-directory标志或将其作为命令行参数提供(例如，当使用 Docker 时)，例如:

docker run -p 7687:7687 --query-modules-directory /usr/lib/memgraph/new_query_modules memgraph

如果要添加新的查询模块，需要放在这个目录下。它将在 Memgraph 启动时自动加载，但您也可以通过执行以下查询在数据库运行时重新加载它:

CALL mg.load("QUERY_MODULE_NAME")

使用 Docker 开发自定义查询模块

使用 Docker 时，您不能直接访问默认的查询模块目录，因为它在 Docker 容器中。创建一个卷并挂载它以访问/usr/lib/memgraph/query_modules目录。这可以通过创建一个空目录modules并执行以下命令来完成:

docker volume create --driver local --opt type=none  --opt device=~modules --opt o=bind modules

现在，您可以启动 Memgraph 并挂载创建的卷: `了

docker run -it --rm -v modules:/usr/lib/memgraph/query_modules -p 7687:7687 memgraph

目录/usr/lib/memgraph/query_modules中的所有内容在你挂载的modules卷中都是可见/可编辑的，反之亦然。

用 Python 实现 JSON 实用查询模块

您将把查询模块命名为json_util.py，因为它将包含处理 JSON 文件所需的实用函数。现在，让我们实现以下三个过程:

从本地文件加载 JSON
从远程地址加载 JSON
将节点导出为 JSON 文档

1.从本地文件加载 JSON

在您的json_util.py模块中添加以下代码:

import json
import mgp
import urllib.request @mgp.read_proc
def load_from_path(ctx: mgp.ProcCtx,
                   json_path: str) -> mgp.Record(objects=mgp.List[object]): with open(json_path) as json_file:
        objects = json.load(json_file) if type(objects) is dict:
            objects = [objects] return mgp.Record(objects=objects)

至此，您已经实现了第一个步骤。@mgp.read_proc装饰器将函数注册为当前模块的只读过程。if语句确保过程返回一个list，即使它只是一个元素。这对以后处理数据很有用。

你如何测试这个程序？让我们在/usr/lib/memgraph/query_modules目录下创建一个文件，并将其命名为data.txt。将以下内容放入其中:

[{"name":"Leslie"}, {"name":"Ron"}, {"name":"Donna"}]

如果还没有启动 Memgraph Lab 并运行以下查询:

CALL json_util.load_from_path("/usr/lib/memgraph/query_modules/data.txt") 
YIELD * 
RETURN *

2.从远程地址加载 JSON

虽然从本地文件加载数据很有帮助，尤其是在开发新过程时，但是更需要一个通过 URL 从远程位置加载数据的过程。幸运的是，您只需对load_from_path()功能稍加调整即可实现这一功能。让我们将这个新过程命名为load_from_url:

@mgp.read_proc
def load_from_url(ctx: mgp.ProcCtx,
                  json_path: str) -> mgp.Record(objects=mgp.List[object]): with urllib.request.urlopen(json_path) as url:
        objects = json.loads(url.read().decode()) if type(objects) is dict:
            objects = [objects] return mgp.Record(objects=objects)

您可以通过运行以下查询来测试它:

CALL json_util.load_from_url('ADDRESS') 
YIELD objects 
UNWIND objects AS o 
RETURN o.name

3.将节点导出为 JSON 文档

这个过程将接收一个节点列表，并将它们以 JSON 格式保存到一个本地文件中。

@mgp.read_proc
def export_nodes(ctx: mgp.ProcCtx,
                 nodes: mgp.List[mgp.Vertex],
                 file_path: str
                 ) -> mgp.Record(success=bool):

    json_nodes_list = []
    for node in nodes:
        json_node = {}
        json_node['labels'] = [] for label in node.labels:
            json_node['labels'].append(label.name) json_node['properties'] = dict(node.properties.items())
        json_nodes_list.append(json_node)

    with open(file_name, 'w') as fp:
        json.dump(json_nodes_list, fp)

    return mgp.Record(success=True)

您可以通过运行以下命令来测试该过程:

MATCH (n) 
WITH COLLECT(n) AS listn
CALL json_util.export_nodes(listn,"/usr/lib/memgraph/query_modules/data.json")
YIELD success RETURN success

文件data.json应该在/usr/lib/memgraph/query_modules目录中。

结论

在本教程中，您了解了如何通过编写自己的过程来轻松地向 Cypher 查询语言添加额外的功能。虽然从 JSON 文档导入数据更多地被认为是一个实用程序，但查询模块可以成为编写定制图算法或实现图论领域中各种构造的强大工具。

如果您正在开发自己的查询模块，并希望分享它，请查看投稿指南。我们非常乐意提供反馈，并将模块添加到法师库。

关于如何创建自己的自定义密码程序的更深入的解释，请看我们的文档。如果你想要更多探索定制查询模块的分步教程，请务必阅读我们的如何用 NetworkX 和 Memgraph 编写定制密码过程教程。

如何实现雷达图像分类的深度神经网络

原文：https://towardsdatascience.com/how-to-implement-deep-neural-networks-for-radar-image-classification-acb1bfcd7f3?source=collection_archive---------14-----------------------

利用为计算机视觉开发的网络架构和技术

由普雷斯科特·霍恩在 Unsplash 上拍摄

介绍

对家庭环境中的人和物进行基于雷达的识别和定位相对于计算机视觉具有一定的优势，包括增加用户隐私、低功耗、零光操作和更灵活的传感器放置。

可以使用支持向量机和逻辑回归等浅层机器学习技术对来自雷达的图像进行分类，在我之前的工作中，教雷达了解家和使用随机梯度下降训练线性分类器我分享了如何应用其中的一些方法。

在本文中，您将学习如何开发深度神经网络(DNN)并训练它们对雷达图像中的对象进行分类。此外，您将学习如何使用半监督生成对抗网络(SGAN) [1]，它只需要少量的标记数据来训练 DNN 分类器。这在处理雷达数据集时很重要，因为缺乏大型训练集，与基于相机的图像(例如，I mageNet )相比，这有助于使计算机视觉无处不在。

从架构和训练方法的角度来看，最初为视觉图像分类开发的 DNNs(或更具体地说，卷积神经网络)和 SGANs 都可以用于雷达应用。

数据集

为了帮助您理解本文中使用的技术和代码，本节提供了一个简短的数据集浏览。作为 radar-ml 项目的一部分，数据集是从雷达样本中收集的，并在这里找到了。该项目采用自主监督学习，其中标准的基于摄像机的对象检测技术用于自动标记人和对象的雷达扫描。

数据集是以下形式的 Python dict:

{‘samples’: samples, ‘labels’: labels}

samples是 N 个雷达投影中的一个list``numpy.array元组样本的形式:

[(xz_0, yz_0, xy_0), (xz_1, yz_1, xy_1),…,(xz_N, yz_N, xy_N)]

其中雷达投影是投影到 x、y 和 z 轴的三维空间中扫描目标物体的最大返回信号强度。这些 2-D 表示通常是稀疏的，因为投影占据了扫描体积的一小部分。采样、存储和利用二维投影比直接使用三维源数据更有效。

labels是 N 个 numpy.array类标签中的一个list，对应表格中的每个雷达投影样本；

[class_label_0, class_label_1,…,class_label_N]

下面的热图显示了典型单个样本的预测。红色表示返回信号最强的地方。

狗(我的宠物波利)数据集样本的可视化

这些数据是在我家的不同位置捕获的，旨在最大化检测到的对象(目前只有人、狗和猫)、距离和雷达传感器的角度的变化。

数据集仅包含几千个样本(具有已知的标记误差)，并且在过度拟合之前只能用于训练少量时期的深度神经网络。标记误差将影响从该数据集训练的雷达分类器的准确性。虽然未来的努力将试图微调目标探测器以减少误差，但使用 SGAN 可以避免或最大限度地减少标记未来雷达观测的需要。在保持可接受的准确性的同时，减少训练分类器的标记数据点的数量，是在这个项目中探索使用 SGANs 的主要动机。

模型架构

如上所述，数据集包含三维雷达图像的二维表示的集合，幸运的是，计算机视觉领域的先前工作证明了在这种二维表示上设计和训练神经网络的可能性，这种二维表示匹配甚至优于在原始三维数据集上训练的网络，参见2和3。这项先前的工作启发了下面网络的发展。

所有模型和相关培训都是使用 Keras API 实现的，Keras API 是 TensorFlow 的高级 API，是 radar-ml 项目的一部分。

深度神经网络(DNN)分类器

尽管人类无法识别，二维雷达图像投影的集合包含映射回被扫描物体的特征。三个 2-D 投影中的每一个都通过独立的 2-D 卷积层，这些卷积层学习这些特征并连续对图像进行下采样。来自这些层的输出被连接，然后被展平以形成单个特征向量，该特征向量被用作深度连接的密集层的输入，紧接着是分类层。下图中的这个架构。您可能会注意到，这种架构的一个分支类似于计算机视觉中使用的卷积神经网络(CNN)。

DNN 分类器的体系结构

该模型由 radar-ml 资源库中的文件 dnn.py 中的 Python 模块实现。您可以在下面看到定义和编译该模型的代码片段。

创建 DNN 分类器的 Python 代码片段

半监督生成对抗网络

与建立地面事实相比，收集雷达图像用于模型训练相对简单，地面事实需要人在回路中、自主监督学习或半监督学习等技术，半监督学习在训练期间将少量标记数据与大量未标记数据相结合。使用半监督学习的动机是最小化与人类标记雷达扫描或使用复杂(可能容易出错)的自主监督学习相关的工作。

生成对抗网络(GAN)是一种使用未标记数据集来训练图像生成器模型和图像鉴别器模型的架构。在某些情况下，您可以使用鉴别器模型来开发分类器模型。GANs 已用于雷达信号生成[4]，并在计算机视觉应用中得到广泛使用[5]。

半监督 GAN (SGAN)模型是 GAN 架构的扩展，它采用监督鉴别器、非监督鉴别器和生成器模型的共同训练。在这个项目中，监督鉴别器被用作归纳为新数据集的分类模型和生成雷达投影的真实示例的生成器模型(仅用作有效性检查)。

监督鉴频器架构如下图所示，您可能会注意到它类似于附近所示的 DNN 架构，但有一些例外，包括使用 LeakyReLU(泄漏整流线性单元)而不是 ReLU，这是 GAN 培训的最佳实践[7]。该模型包括批量标准化层，以帮助训练收敛，这通常是训练 GANs 的一个问题6。无监督鉴别器共享除最终输出图层之外的大多数图层，因此具有非常相似的架构。监督鉴别器的输出是一个具有 softmax 激活的密集层，它形成一个 3 级分类器，而无监督模型在 softmax 激活之前获取监督模型的输出，然后计算指数输出的归一化和6。

监督鉴别器的体系结构

监督和非监督鉴别器模型都是由位于 radar-ml 存储库中的 sgan.py 文件中的 Python 模块实现的。定义和编译下面模型的代码片段。

创建监督和非监督鉴别器的 Python 代码片段

生成器模型从潜在空间中获取一个向量(从标准正态分布中提取的噪声向量),并使用具有 ReLU 激活的转置卷积层的三个分支来连续上采样潜在空间向量，以形成三个雷达图像投影中的每一个。生成器被堆叠在鉴别器模型的顶部，并且在后者的权重被冻结的情况下被训练。下图描述了这种组合架构。请注意使用批量标准化图层来帮助模型训练收敛。

GAN 架构

生成器和 GAN 由 radar-ml 资源库中的文件 sgan.py 中的 Python 模块实现。下面是定义和编译模型的代码片段。

创建生成器和 GAN 的 Python 代码片段

模型训练和结果

DNN

DNN 通过tf.keras.Model类fit方法训练，并由 radar-ml 资源库中 dnn.py 文件中的 Python 模块实现。下面是训练函数的代码片段，没有显示预处理和过滤数据所需的步骤。

DNN 训练函数的 Python 代码片段

典型训练的结果如下。模型和数据集的当前状态能够获得 80%到 80%的验证集精度。需要做更多的工作来达到或超过 SVM 和逻辑回归模型在之前的工作中获得的 90%的精度[8][9]。这将是今后努力的重点。

DNN 培训结果

斯甘

生成对抗网络(GANs)很难训练。这是因为该架构包括一个生成器和一个鉴别器模型，它们在零和游戏中竞争。这意味着一个模型的改进是以另一个模型的性能下降为代价的。结果是一个非常不稳定的训练过程，经常会导致失败，例如，生成器总是生成相同的图像或生成无意义的图像。因此，在配置和训练您的 GAN 模型时，可以使用许多启发式方法或最佳实践(称为 GAN hacks)。这些试探法是从业者多年来在一系列问题上测试和评估成百上千个配置操作组合来之不易的。

“用 Python 生成对抗性网络”，Jason Brownlee，2021。

您可以找到许多优秀的论文和文章，帮助您了解如何应用最佳实践来培训 GANs。特别是， Jason Brownlee 发表了许多务实的文章和论文，可以证明节省时间[7]。这些工作中的一部分被用于确定在雷达 SGAN 模型和数据集上工作得相当好的训练方法。如果你认真理解应用机器学习的和，可以考虑阅读他的在线文章和购买他的电子书。

训练循环由 radar-ml 存储库中的文件 sgan.py 中的 Python 模块实现。下面是训练循环的一个片段，没有显示预处理和过滤数据集所需的步骤以及几个帮助函数。该代码基于参考文献[7]。注意，鉴别器模型用 1.5 批样本更新，但是生成器模型每次迭代用一批样本更新。

SGAN 训练循环的 Python 代码片段

由于 GANs 的随机性，你会发现每次跑步的训练结果都不一样，所以最好将几次跑步的结果平均起来。对于无监督的鉴别器和生成器，良好的训练会话将具有中等(~ 0.5)和相对稳定的损失，而有监督的鉴别器将在训练集上收敛到非常低的损失(< 0.1) with high accuracy (> 95%)。验证集的准确性结果往往在低到高的 70%之间，每类仅使用 50 个监督样本时，损失在 1.2 左右徘徊。这是一个令人鼓舞的结果，但显然需要更多的建模工作和数据收集，以获得与该数据集上采用的其他机器学习方法相当的验证准确性，通常为约 90% [8][9]。这将是这个项目今后工作的重点。典型的培训结果如下所示。

SGAN 培训结果

您还应该查看生成器生成的图像，以确定它们是否有意义。在这种情况下，由于图像是 3d 物体的雷达扫描的 2d 投影，并且不能被人类识别，因此需要将生成的图像与来自原始数据集的示例进行比较，如上图所示。下图是一组生成的二维扫描。其中一个投影(X-Y 平面)中的相似性是明显的，但在其他投影中不明显，至少对于这次训练运行是如此。这可以解释低准确性，并且找到使其他生成的投影在视觉上类似于训练集的方法留给了未来的练习。

生成的数据集样本的可视化

结论

您可以利用 CNN、SGAN 的模型架构以及为基于摄像机的计算机视觉开发的相关培训技术来开发神经网络，从而对雷达图像进行分类。考虑到雷达数据集的缺乏，您通常需要收集雷达数据集，这些数据集可能是资源密集型的，并且对于地面实况新雷达观测来说容易出错。您可以使用自我监督技术来利用未标记的数据，每个类只使用几十个或更少的标记样本和一个 SGAN。通过这种方式，您可以使用大量未标记的数据开发雷达图像分类器。

以前的工作使用浅层机器学习模型，并在数据集上实现了比当前使用这里描述的网络和技术获得的更高的准确性。未来的努力是计划弥补这一差距，并增加数据集的大小，以在过度拟合之前获得更好的验证集准确性。

参考

生成对抗网络半监督学习，2016。
用于三维形状识别的多视角卷积神经网络，2015。
卷积神经网络多视角分类，2021。
雷达信号生成对抗网络
代，2019。
深度卷积生成对抗网络的无监督表示学习，2016。
训练 GANs 的改进技术，2016。
用 Python 生成对抗性网络，2021。
教雷达了解家，2020。
利用随机梯度下降训练线性分类器，2020。

如何实现深度神经网络进行时间-事件分析

原文：https://towardsdatascience.com/how-to-implement-deep-neural-networks-for-time-to-event-analyses-9aa0aeac4717?source=collection_archive---------7-----------------------

比较 DeepHit 和 DeepSurv 模型

莫里茨·金德勒在 Unsplash 上拍摄的照片

在我的上一篇帖子中，我用随机森林、梯度增强和 SVM 生存模型演示了一些例子。今天，我将向您展示如何使用深度神经网络处理相同类型的问题。具体来说，我们将基于 PyTorch 环境，使用连续时间模型( DeepSurv )和使用 pycox 的离散时间模型( DeepHit )来浏览示例。

因为我在上一篇文章中已经介绍了时间到事件分析的基础知识，所以今天我将省略它以避免任何冗余信息。如果你对更多细节感兴趣，请查看上面的链接。

在我开始之前，我鼓励大家看看上面链接的 pycox 回购。它充满了有用的信息以及额外的例子和资源。您甚至可以直接加载几个时间事件数据集，我今天将使用其中的一个。

数据

对于今天的例子，我使用研究来了解预后偏好结果和治疗风险(支持)数据集，该数据集调查医院中重病患者的存活时间。它包含来自 8，873 名患者的数据，其中有 14 个预测变量和 2 个结果变量(持续时间和事件)。下面，你可以预览我们的数据集。

图 1 —用于我们分析的支持数据集的预览

有关数据集中变量的快速描述，请参考下图。当我打开数据集时，这些要素被命名为 x0 到 x14。我根据这里找到的信息给它们重新命名。

图 2 —数据集中变量的描述

关于我们将要使用的库的完整列表，请点击这里查看我的笔记本。

接下来，我们将使用下面的代码将数据集分为训练集、验证集和测试集。或者，你可以使用 sklearn 的训练测试分割。

图 3 —导入和分割我们的数据集

预处理

在开始之前，我们需要根据变量类型执行一些数据预处理:

数字变量:标准化
二进制变量:不需要预处理
分类变量:创建嵌入

使用图 4 中的代码可以完成对数据的预处理。这里发生了相当多的事情，所以让我们打开它。在第一个块中，我们简单地创建列表来分隔不同的变量类型，因为我们将对每个变量应用不同的转换。

第二个模块是我们将要执行的转换。具体来说，我们将对数值变量使用 标准缩放器 ，对二进制变量不做任何处理，将使用OrderedCategoricalLong来转换我们的分类变量。

下一个块中的 DataFrameMapper 是sklearn _ pandas包的一部分，允许我们轻松地将 sk learn 转换应用到我们的 pandas 数据帧。

最后，最后两个模块将转换应用到我们的数据集。你会注意到来自 x_fit_transform 和 x_transform 的结果被包装在一个使用 tt.tuplefy 的元组中。这个元组称为元组树，用于训练 PyTorch 模型，它可以处理嵌套元组中的数据。

图 4 —支持数据集的数据预处理

在下一节中，我们将开始探索离散时间模型 DeepHit 和连续时间模型 DeepSurv，并了解它们在我们的数据集上的表现。

深度打击

DeepHit 是一个适用于生存(时间到事件)分析的深度学习模型。可以对其进行修改，以用于调查单一风险或竞争风险。由于这是一个离散时间模型，我们研究的第一步是定义要评估的离散时间。

有两种方法可以解决这个问题。我们可以使用下面的代码创建等间距(等距)的离散时间间隔或分位数。这里我们定义了 10 个等间距的区间，然而，通过改变方案，我们可以基于分位数定义区间。值得注意的是，我们不需要转换测试集上的标签。

图 5-深击的等距时间间隔(10)

要了解这种情况，请参考下图，该图展示了等距(左)和分位数(右)离散化之间的差异。在每一个中，有 10 个定义的时间间隔；然而，在分位数离散化中，区间是由事件(死亡)的比例定义的。事件多的地方，间隔就多。在我们的数据集中，我们看到更多的事件发生在早于晚于晚。如果你有兴趣更深入一点，请参考这篇论文。

图 DeepHit 的等距(左)与分位数(右)时间离散化。作者图片

如果你跟随我的笔记本，你会看到我做了几个实验，看看修改不同参数的效果。我将展示在我测试的条件下表现最好的模型。在运行这些实验时，尝试修改不同的参数以查看它对模型性能的影响是很重要的。

在运行我们的模型之前，我们必须定义嵌入的数量和维度。正如您在下面的代码中看到的，每个类别都由一个等于一半级别数的向量表示。最高性能的 DeepHit 模型由 2 个多层感知器组成，每个感知器由 64 个节点组成。在每一层以及 20%的漏失之后进行批量标准化。

选择的优化器是循环的 Adam(WR) ，它是 Adam 优化器的权重衰减正则化版本。

如果您可能在不需要分类嵌入的情况下使用不同的数据集，您可能需要对代码进行一些修改。首先，您不需要定义嵌入的前两行。其次，您需要从第三个代码块中删除 num_embeddings 和 embeddings_dims 。最后，您需要在第三个代码块中用 VanillaMLP 替换 MixedInputMLP 。 MixedInputMLP 将实体嵌入应用于分类变量，并将它们与其他变量连接起来。

图 7 —我们数据集的最高性能 DeepHit 模型

在训练模型时，找到合适的学习率是一个常见的问题。你经常会在文献中找到很多。pycox 中一个非常有用的工具是学习率查找器。虽然它可能不会提供最好的学习速度，但它给了你一个开始实验的好地方。可以使用下面的代码执行实现，它给了我们 0.04 的值。

图 8——学习率查找器

现在我们已经定义了所有的模型参数，我们使用下面的代码来拟合它。

图 9 —根据我们的数据拟合模型

评估模型

为了评估我们的模型，我们可以从查看测试数据的一些预测开始。该代码(图 10)绘制了五名患者的预测存活率。第一行的插值函数创建一个线性插值来平滑时间上的步长(记住这是一个离散时间模型)。可以在代码的正下方看到该图。

图 10——绘制预测存活曲线

图 11 —选定患者的深度打击存活曲线

为了评估模型在我们的测试集上的表现，有几个可用的指标。我将提出审查加权的逆概率(IPCW) 石南得分。这将计算预测结果与我们定义的每个离散时间间隔的实际结果的均方误差(MSE)。由于正确预测的 MSE 为 0，因此分数越低表示性能越好。

我们可以使用以下代码绘制性能随时间变化的曲线图。第一块允许我们绘制 Brier 分数随时间的变化图(图 13)。还可以计算综合得分(第 6 行)，结果得到 0.21 的值(79%的准确度)。

图 12—IPCW·布瑞尔随时间变化的得分和综合得分

图 13——deep surv 模型的 IPCW·布瑞尔评分图

在下一节中，让我们看看这与来自 DeepSurv 的结果相比有多好。

DeepSurv

DeepSurv 是将深度神经网络的潜力纳入时间-事件分析的另一种选择。主要区别在于，这是一个连续时间模型，这意味着我们不需要像在 DeepHit 中那样定义离散间隔。在这里，我们简单地转换我们的标签，如下所示。

图 14——无需离散时间间隔的 DeepSurv 标签转换，如上文针对 DeepHit 所执行的

剩下的和上面类似，我们定义我们的模型并使它适合我们的数据。正如您所看到的(图 15)，主要的区别在第 3 行，这里 out_features = 1。同样，这是因为我们使用的是连续时间模型，而使用 DeepHit 时，它被设置为我们定义的离散间隔数。值得注意的一点是，由学习率查找器确定的该模型的学习率为 0.07(而 DeepHit 的学习率为 0.04)。

图 15 —性能最佳的 DeepSurv 模型

评估模型

最后，我们以与上面完全相同的方式评估模型。下面，你会发现 5 个病人的预测图。您可能会注意到，这些线条比为 DeepHit 绘制的线条更平滑，因为我们不需要在间隔之间进行插值。

图 16 —选定患者的深度生存曲线

IPCW·布瑞尔评分(图 17)比 DeepHit 模型表现稍好。综合得分以 0.18 的值(82%的准确度)证实了这一点。

图 17—deep hit 模型的 IPCW·布瑞尔评分图

摘要

今天，我们通过几个例子学习了如何使用深度神经网络进行时间-事件分析。我希望你给他们两个试一试你的数据，看看他们如何比较。我再次建议您访问 pycox repo，查看所有可用的选项。他们采用了几个离散时间和连续时间的神经网络进行生存分析。感谢阅读！

如何在格朗实施领域驱动设计(DDD)

原文：https://towardsdatascience.com/how-to-implement-domain-driven-design-ddd-in-golang-2e2139beb09d?source=collection_archive---------0-----------------------

学习如何在 Go 应用程序中使用 DDD 的简单方法

Percy Bolmér. Gopher 图片由 Takuya 上田创作，Original Go Gopher 由 Rene French 创作(CC BY 3.0)

近年来，微服务已经成为一种非常流行的软件构建方法。微服务用于构建可扩展且灵活的软件。然而，在许多团队中随机构建微服务会导致很大的挫折和复杂性。

不久前，我还没有听说过领域驱动设计——DDD，但现在似乎每个人都在谈论它，无论我去哪里。

本文中的所有图像均由珀西·博尔梅尔绘制，而《地鼠》则由塔库亚·上田绘制，灵感来自勒内·弗伦奇的作品。图像中的地鼠已被修改。

在本文中，我们将从头开始构建一个在线酒馆，同时逐步探索 DDD 的不同地区。有希望的是，当一件事情一次完成时，会更容易理解 DDD。我想采取这种方法的原因是，阅读关于 DDD 的书让我的脑袋爆炸，每一次。有太多的术语，太宽泛了，不清楚什么是什么。

如果你想看这篇文章的视频版，它可以在 YouTube 上找到

如果你在研究 DDD 的时候不知道为什么我的脑袋会爆炸，下面的图表可能会帮助你意识到这一点。

DDD 的关键词——埃里克·埃文斯的书《领域驱动设计:解决软件核心的复杂性》中的图表

在领域驱动设计:解决软件核心的复杂性中，Eric Evans 需要大约 500 页来解释它是有原因的。如果你真的对学习 DDD 感兴趣，那么不要害怕阅读埃文关于它的书。

首先，我想指出，本文描述了我对 DDD 的理解，我在文中展示的实现是基于我在 Go 相关项目中的经验。我们将创建的实现绝不是社区接受的最佳实践。我还将按照 DDD 的方法来命名项目中的文件夹，以便于理解和遵循，但我不确定我是否希望一个真正的存储库是这样的。出于这个原因，我还将有一个单独的存储库分支，在那里我已经修复了结构，并且重构将在第二篇文章中解释。

我在互联网上看到了许多关于 DDD 以及如何正确实施的热烈讨论。让我印象深刻的一件事是，大多数时候，人们似乎忘记了 DDD 背后的目的，而是最终在小的实施细节上争论不休。我认为重要的是，遵循 Evan 提出的方法论，而不是某个东西被命名为 X 或 y。

DDD 是一个巨大的区域，我们将主要关注它的实现，但是在我们实现任何东西之前，我将快速回顾一下 DDD 中的一些方面。

什么是 DDD

领域驱动设计是一种根据软件所属的领域对软件进行结构化和建模的方法。这意味着首先要为编写的软件考虑一个domain。领域是软件打算处理的主题或问题。软件应该被编写来反映领域。

DDD 主张工程团队必须会见主题专家 SME，他们是领域内的专家。这样做的原因是因为 SME 拥有关于领域的知识，并且这些知识应该反映在软件中。当你想到这一点时，你会觉得很有道理，如果我要建立一个股票交易平台，作为一名工程师，我对这个领域的了解是否足以建立一个好的股票交易平台？如果我和沃伦·巴菲特就这个领域进行几次会谈，这个平台可能会变得更好

代码中的架构也应该反映在领域中。当我们开始写我们的酒馆时，我们将看到如何。

一只地鼠在 DDD 的旅程

两只地鼠庆祝成功合作。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

让我们开始学习如何实现 DDD，首先我想告诉你一个关于地鼠 Dante 的故事，他想创建一个在线酒馆。但丁知道如何写代码，但他对如何经营酒馆一无所知。

但丁决定开始在酒馆工作的那一天，他遇到了一个问题，从哪里以及如何开始？他出去散步思考他的问题。在一个停车标志前等待的时候，一个戴着礼帽的男人走近但丁，说道

“看起来你好像在担心什么，年轻人，也许你需要帮助建造一个酒馆？”

但丁和大礼帽男散步很愉快，他们讨论了酒馆以及如何经营酒馆。

但丁问一般喝酒的人是怎么处理的，大礼帽回答说那叫顾客，不是喝酒的人。

大礼帽也向但丁解释了酒馆需要几样东西来经营，比如顾客、员工、银行和供应商。

领域、模型、通用语言和子域

我希望你喜欢关于但丁的故事，我写它是有原因的。我们可以用这个故事来解释一些在 DDD 使用的关键词，这些词如果不放在上下文中我很难解释，比如一个小故事。

但丁和大礼帽之间进行了一场对话。作为主题专家的 Top hat 和作为工程师的 Dante 讨论了领域空间并找到了共同点。这样做是为了学习Model，模型是处理一个领域所需组件的抽象。

当但丁和大礼帽讨论酒馆的时候，他们在谈论我们所说的Domain。域是软件将要运行的区域，我称酒馆为核心/根域。

大礼帽还指出，它不叫酒客，而叫Customers。这表明在 SMO 和开发人员之间找到一种共同语言是多么重要。如果项目中不是每个人都有一个Ubiquitous Language，这将变得非常混乱

我们也得到一些Sub-domains是礼帽提到的酒馆需要的东西。子域是一个单独的域，用于解决根域内部的一个区域。

用 Go-实体和值对象编写 DDD 应用程序

用可变和不可变状态解释实体和值对象。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

既然我们已经拥有了开始的一切，是时候开始对酒馆进行编码了。首先，通过创建 go 模块来设置项目。

mkdir ddd-go
go mod init github.com/percybolmer/ddd-go

我们将首先创建一个domain文件夹，在其中我们将存储所有需要的子域，但是在我们实现任何域之前，我们需要在根域中创建另一个文件夹。出于演示的目的，我们将其命名为entity，因为它将保存 DDD 方法中所谓的实体。

一个实体是一个结构，它有一个Identifier并且可以改变状态，改变状态意味着实体的值可以改变。

首先，我们将创建两个实体，Person和Item。我确实喜欢将我的实体保存在一个单独的包中，这样它们就可以被所有其他域使用。

在根域中添加了一个实体文件夹

为了保持代码的整洁，我喜欢小文件，并使文件夹结构易于导航。所以我建议创建两个文件，每个实体一个，以实体命名。现在，它只是其中的结构定义，但是以后，可能会添加一些其他的逻辑。

我们为我们的域创建的第一个实体

person.go —代表一个人的实体

item.go 定义产品基础的项目实体

很好，现在我们已经定义了一些实体，并了解了什么是entity。具有引用它的唯一标识符的结构，它具有可以更改的状态。

可能会出现这样的情况，我们有不可变的结构，并且不需要唯一的标识符，这些结构被称为Value Objects。所以在创建后没有标识符和持久值的结构。值对象通常出现在领域内部，用于描述该领域的某些方面。我们现在将创建一个值对象Transaction，一旦事务被执行，它就不能改变状态。

在现实世界的应用程序中，通过 ID 跟踪事务可能是一个好主意，但这只是为了演示的目的

transaction . go——定义双方之间的支付

聚合—组合的实体和值对象

聚合，实体和值对象的组合。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

是时候看看 DDD 的下一个组成部分了，聚合体。聚合是一组实体和值对象的组合。在我们的例子中，我们可以从创建一个新的聚合开始，这个聚合就是Customer。

DDD 集合是领域概念(订单、门诊、播放列表)——马丁·福勒

使用聚合的原因是业务逻辑将应用于Customer聚合，而不是每个实体持有逻辑。聚合不允许直接访问基础实体。同样常见的是，需要多个实体来正确表示现实生活中的数据，例如，一个客户。它是一个人，但他/她可以持有产品，并执行交易。

DDD 集合中的一个重要规则是，它们应该只有一个实体充当root entity。这意味着根实体的引用也用于引用聚合。对于我们的客户集合，这意味着Person ID 是唯一的标识符。

让我们创建一个aggregate文件夹，并在其中创建一个名为customer.go的文件。

mkdir aggregate
cd aggregate
touch customer.go

在该文件中，我们将添加一个名为Customer的新结构，它将保存所有需要的实体来表示一个客户。请注意，struct 中的所有字段都以小写字母开头，这是 Go 中的一种方法，可以使定义 struct 的包之外的对象不可访问。这样做是因为聚合不允许直接访问数据。该结构也没有为数据如何格式化定义任何标签，例如json。

这是从文章的早期版本编辑而来的，我决定让所有项目都可以访问，以便更容易地将它们存储在数据库中，但是因为它违反了 miosz Smóka 在 Threedotlabs 与 miosz Smóka 讨论的 DDD 规则，我决定更改它。

customer . go——表示客户及其内部所需实体的集合

我将所有的实体都设置为指针，这是因为一个实体可以改变状态，我希望它能反映到所有可以访问它的运行时实例中。但是值对象被保持为非指针，因为它们不能改变状态。

很好，现在我们已经创建了一个聚合，我们可以继续了。

工厂—封装复杂的逻辑

工厂，一种创建复杂集合或存储库和服务的模式。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

到目前为止，我们只定义了不同的实体、值对象和集合。是时候开始实现一些实际的业务逻辑了，我们从factories开始。工厂模式是一种设计模式，用于将复杂的逻辑封装在创建所需实例的函数中，而调用者不知道任何实现细节。

工厂模式是一种非常常见的模式，你甚至可以在 DDD 应用程序之外使用它，而且你可能已经使用过很多次了。一个很好的例子是官方 Go Elasticsearch 客户端。您将一个配置插入到一个NewClient函数中，这个函数是一个工厂，它返回一个连接到弹性集群的客户机，您可以插入/删除文档。对其他开发者来说非常简单，在NewClient中有很多东西

弹性搜索——新客户的工厂。仅用于演示工厂的工作方式。

DDD 建议使用工厂来创建复杂的集合、仓库和服务。我们将实现一个工厂函数，它将创建一个新的Customer实例。这将产生一个名为NewCustomer的函数，它接受一个name参数，函数内部发生的事情不应该被想要初始化一个新客户的域所关注。

NewCustomer将验证输入是否包含创建Customer所需的所有数据

在一个实际的应用程序中，我可能会建议在域/客户和工厂中聚集客户，我们将在第二篇文章中讨论这一点

customer.go —为客户创建一个工厂，该工厂验证输入名称并返回一个新的客户指针

客户工厂现在帮助验证输入，创建新的 ID，并确保所有的值都被正确初始化。

现在我们已经有了一些业务逻辑，所以也是时候开始添加测试了。我将在aggregate包中创建一个customer_test.go，在这里测试与Customer相关的逻辑。

对客户工厂进行单元测试，以确保它按预期工作

虽然仅仅创造新客户我们不会走得很远，但是是时候开始寻找我所知道的最好的设计模式了。

存储库—存储库模式

用于隐藏底层实现细节的存储库接口。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

DDD 描述了存储库应该被用来存储和管理集合。一旦我学会了这种模式，我就知道我永远不会停止使用它。这种模式依赖于将存储/数据库解决方案的实现隐藏在接口之后。这允许我们定义一组必须存在的方法，如果它们存在，它就有资格被用作存储库。

这种设计模式的优点是，它允许我们在不破坏任何东西的情况下交换解决方案。我们可以在开发阶段使用内存存储，然后在生产阶段将其切换到 MongoDB 存储。它不仅有助于改变所使用的底层技术而不破坏任何利用存储库的东西，而且在测试中也非常有用。您可以简单地为单元测试等实现一个新的存储库。

我们将从在domain/customer包中创建一个名为repository.go的文件开始。在该文件中，我们将定义存储库所需的功能。我们将希望获得，添加和更新客户。我们不会删除任何顾客，一旦你成为这家酒馆的顾客，你就永远是顾客。我们还将在客户包中实现一些通用错误，不同的存储库实现可以使用这些错误。

repository.go —定义存储客户的存储库规则

接下来，我们需要实现满足接口的实际业务逻辑，我们将从内存存储开始。在本文的最后，我们将看看如何在不破坏其他任何东西的情况下，将其更改为 MongoDB 解决方案。

我喜欢将每个实现放在它的目录中，只是为了让团队中的新开发人员更容易找到正确的代码位置。让我们创建一个名为memory的文件夹来表示存储库正在使用内存作为存储。

另一个解决方案是在客户包中加入 memory.go，但是我发现在更大的系统中它会变得很混乱

mkdir memory
touch memory/memory.go

让我们首先在内存文件中设置正确的结构，我们想要创建一个具有实现CustomerRepository的方法的结构，并且让我们不要忘记factory来创建一个新的存储库。

添加新客户仓库所需的结构

我们需要添加一种从Customer集合中检索信息的方法，比如从根实体中检索 ID。因此，我们应该用一个获取 ID 的函数和一个更改名称的函数来更新聚合。

aggregate/customer.go —添加一个函数来获取根实体的 ID

让我们向内存存储库添加一些非常基本的功能，以便它能按预期工作。

客户存储库—实现客户存储库的逻辑

和往常一样，我们应该为代码添加测试。我想指出从测试的角度来看，存储库模式有多棒。在单元测试中，用专门为测试创建的存储库替换部分逻辑是如此容易，使得复制更容易知道测试中的错误。

大多数客户存储库的单元测试

太好了，我们有了第一个仓库。记住让你的存储库与他们的领域相关。在这种情况下，存储库只处理客户集合，而且它只应该这样做。永远不要让存储库耦合到任何其他集合，我们想要虱子耦合。

那么，我们如何处理酒馆的逻辑流程，我们不能简单地依赖客户存储库？我们将从某一点开始耦合不同的存储库，并构建一个表示酒馆逻辑的流程。

进入服务，我们需要学习的最后一部分。

服务—连接业务逻辑

服务——将存储库连接到实际的业务逻辑中。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

我们有所有这些实体、一个集合和一个存储库，但是它看起来还不像一个应用程序，不是吗？这就是为什么我们需要下一个组件Service。

服务将所有松散耦合的存储库绑定到一个业务逻辑中，以满足特定领域的需求。在 tavern 案例中，我们可能有一个Order服务，负责将存储库链接在一起以执行订单。因此该服务将保持对一个CustomerRepository和一个ProductRepository的访问

服务通常包含执行某个业务逻辑流所需的所有repositories，比如Order、Api或Billing。最棒的是，您甚至可以在服务中包含服务。

我们将实现Order服务，例如，该服务稍后可以成为Tavern服务的一部分。

让我们创建一个名为services的新文件夹，它将保存我们实现的服务。我们将首先创建一个名为order.go的文件，它将保存我们将用来处理酒馆中新订单的OrderService。我们仍然缺少一些域，所以我们将只从 CustomerRepository 开始，但很快会添加更多。

我想从创建新的Service的Factory开始，并展示一个我从 Jon Calhoun 的《web 开发》一书中学到的超级巧妙的技巧。我们将为一个函数创建一个别名，该函数接受一个Service作为指针并修改它，然后允许不同数量的别名。这样，改变服务的行为或者替换存储库就非常容易了。

order.go —新订单服务的工厂函数接受不同数量的配置

看看我们如何在工厂方法中引入可变数量的OrderConfiguration？这是一种允许动态工厂的非常简洁的方式，允许开发人员配置架构，只要它已经实现。这个技巧对于单元测试非常有用，因为您可以用想要的存储库替换服务中的某些部分。

小注意，对于较小的服务来说，这种方法似乎有点大材小用。我想指出的是，在示例中，我们只使用配置来修改存储库，但是这也可以用于内部设置和选项。对于较小的服务，你也可以创建一个简单的工厂，例如接受CustomerRepository的工厂。

让我们创建一个应用了CustomerRepository的OrderConfiguration，这样我们就可以开始创建订单的业务逻辑了。

WithCustomerRepository 返回 OrderConfiguration 的函数，以便将其用作 NewOrderService 的输入参数

现在，为了使用它，当我们创建service时，你可以简单地链接所有的配置，允许我们容易地切换出部件。

// In Memory Example used in Development
NewOrderService(WithMemoryCustomerRepository())
// We could in the future switch to MongoDB like this NewOrderService(WithMongoCustomerRepository())

让我们开始给Order服务添加功能，这样顾客就可以在酒馆里买东西了。

order.go —为客户创建订单。

哎呀，我们酒馆没有任何产品供应。当然，你知道如何解决这个问题，对吗？

让我们实现更多的存储库，并通过使用OrderConfiguration将它们应用到服务中

产品存储库——酒馆的最后一块

产品存储库—处理产品集合。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

现在我们知道了我们在 DDD 需要的所有组件是做什么的，是时候用它们来练习一下了。我们将从修复一个ProductRepository开始，这样我们就可以找到客户订购的产品。

从这一点开始，我会讲得快一点，解释得少一点，因为我们已经讲了基础知识，所以我不会解释两遍。

让我们在aggregate文件夹中创建product.go和product_test.go。我们首先创建Product集合，并为其创建一个factory函数。

product.go —包含项目、价格和数量的聚合。

接下来，您应该为聚合添加单元测试，以确保其中的任何逻辑都按预期工作。

单元测试所有聚合逻辑

在产品域/domain/product/repository.go中创建一个文件。这里我们将定义允许我们访问产品的ProductRepository。

product.go —用于访问产品的产品存储库

很好，就像CustomerRepository一样，我们将为ProductRepository实现一个内存解决方案。在product域中创建一个名为 memory 的文件夹，并插入下面的代码。

memory.go —使用内存逻辑存储产品的产品存储库

当然，我们需要一些测试。

memory_test.go —产品存储库的单元测试

为了开始使用ProductRepository,我们需要修改OrderService,以便它能够保存存储库。打开services/order.go并为其添加一个新字段。

OrderService —现在有两个存储库

请记住，一个服务可以拥有多个存储库，也可以拥有其他服务。

接下来，我们需要添加一个新的OrderConfiguration函数来应用内存存储库。请注意我现在是如何向函数插入一个参数的，一个产品切片。因为我们返回了一个OrderConfiguration，所以我们仍然可以在工厂中使用这个函数。

用于将内存存储库应用到 OrderService 的 OrderConfiguration

让我们更新OrderService中的CreateOrder函数来查找订购的产品，我们还将返回所有订购产品的价格。

CreateOrder —现在使用 ProductRepository 获取产品信息

我将更新order_test.go中的测试，用所有需要的存储库和产品创建OrderService。

Order_test.go —使用两个存储库创建一个 OrderService 并执行订单

Tavern —包含子服务的服务，以及 MongoDB

酒馆——最终解决方案。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

现在到了最后一个环节，即Tavern服务。这个服务将持有OrderService作为子服务，允许酒馆创建订单。

您想要像这样堆叠服务的原因可能是应用了额外的逻辑。例如，Tavern服务很可能希望能够添加Billing。请注意，我们可以多么容易地实现对Tavern的排序逻辑，而不用担心实现细节，然后再对其进行扩展。

我将在services文件夹中创建一个tavern.go。在这个文件中，我们创建了Tavern结构，它保存了OrderService并有一个NewTavern工厂来应用OrderService

Tavern . go-Tavern 现在可以使用订单服务订购产品

为了进行测试，我们可以创建一个单元测试。

Tavern _ test.go 通过点啤酒来测试酒馆

现在我们有了一个酒馆，我想花点时间向您展示如何实现一个针对CustomerRepository.的 MongoDB 解决方案，这是仓库设计模式真正开始闪耀的地方。我喜欢能够轻松地切换存储库。

首先在customer域中添加一个名为mongo的新包。我们将创建一个满足CustomerRepository的结构，这样我们就可以使用它了。

这里需要注意的一件重要事情是用于存储客户的内部mongoCustomer结构。我们不存储aggregate.Customer,因为那会将聚合存储绑定到存储库。相反，每个存储库负责根据需要格式化和组织数据，与其他包没有联系。这就是为什么我们不直接在集合上使用json或bson标签的原因，因为那样会使实现成对。为了进行切换，我们还添加了一个在两者之间转换的factory函数。

mongo . go——用 MongoDB 实现 CustomerRepository

接下来要做的是添加一个OrderConfiguration，这样我们就可以将存储库应用到OrderService中。

order . go——一个 orderConfiguration，它应用 mongo 存储库而不是内存

然后更改tavern_test.go中的输入，改为接受 MongoDB 配置。注意我们可以多么容易地在内存和 MongoDB 之间切换，太神奇了。

Tavern_test.go —用 MongoDB 存储库替换内存

瞧，就这么简单！我们现在有了一个 tavern，它既可以使用内存存储库，也可以使用 MongoDB 存储库。

结束第一篇文章。上田拓也的《地鼠》,雷尼·弗伦奇的《原始地鼠》

简而言之，在本文中，我们已经涵盖了领域驱动设计的基础。

实体 —可变的可识别结构。
值对象 —不可变的不可识别的结构。
聚合 —存储在存储库中的实体和值对象的组合集。
存储库 —存储集合或其他信息的实现
工厂 —创建复杂对象的构造器，使其他领域的开发人员更容易创建新的实例
服务 —构建业务流的存储库和子服务的集合

记住，在这个例子中，我们用适当的 DDD 术语来命名每个组件和包，以便于理解和联系。这是一个学习的例子，在一个真实的存储库中，我可能不会这样命名包，因此，在第二篇文章中，我们将这个项目重构为一个更清晰的架构解决方案。

公平的警告，第二篇文章比这篇长文章要短得多

那么，你的观点是什么，这种建筑方法看起来像是你可以使用的吗？

你可以在 GitHub 上找到完整代码。

感谢您的阅读，并随时以任何可能的方式联系我，在 T witter 、 Instagram 、 Linkedin 上发表评论。

如何在 Python 中实现归并排序算法

原文：https://towardsdatascience.com/how-to-implement-merge-sort-algorithm-in-python-4662a89ae48c?source=collection_archive---------5-----------------------

数据科学

理解合并排序算法的操作以及它是如何在 Python 中实现的

约书亚·阿拉贡在 Unsplash 上拍摄的照片

L 盈利算法有时会很乏味。

算法主题领域是计算机科学的一个分支，它对巨大的复杂性有着臭名昭著的理解。但是算法有不同的形状、大小和复杂程度。

假设你渴望达到能够处理复杂算法并用它们解决问题的水平。在这种情况下，您必须积累理解和实现不太复杂的算法的经验。

这些不太复杂的算法之一是合并排序。

下面是这篇文章的内容:

简介以分而治之的方法解决问题
合并排序算法中涉及的操作和直觉的解释
合并排序算法的 Python 实现

什么是分治算法？

算法设计中使用的分而治之范式结合了递归来解决最初由较大问题衍生而来的小问题。

计算机科学领域中的递归被定义为函数在其主体内调用自身的过程。

分治算法是递归的；这意味着初始问题被分成相关联的子问题，其中解决方案可以递归地应用于每个子问题。更大问题的最终解决方案是子问题解决方案的组合。

算法设计的分治法有三个主要组成部分:

不断地把大问题分解成小部分。
通过使用递归调用的函数来解决每一个小部分。
合并:m 戈尔将所有较小部分的所有解合并成一个统一的解，成为起始问题的解。

什么是合并排序？

合并排序算法采用分治算法范例来高效地对列表中的元素进行排序。该算法是由约翰·冯·诺依曼在 1945 年发明的。

合并排序操作遵循这样的基础:将列表分成两半，然后将新的两半继续分成它们各自的组件。然后是单个组件之间的比较，这些组件被合并以形成最终的排序列表。

Python 中合并排序的实现

实现合并排序算法的方法分为两部分。

第一部分将引导分治范式的划分组件。本节中的代码实现将初始列表分成更小的组件。最初的列表划分只有在每个分离的组件无法再被分解时才会停止。

下面是算法第一部分的图解。

合并排序算法的分割组件图-按作者分类的图像

def merge_sort(list):
    # 1\. Store the length of the list
    list_length = len(list)

    # 2\. List with length less than is already sorted
    if list_length == 1:
        return list

    # 3\. Identify the list midpoint and partition the list into a left_partition and a right_partition
    mid_point = list_length // 2

    # 4\. To ensure all partitions are broken down into their individual components,
    # the merge_sort function is called and a partitioned portion of the list is passed as a parameter
    left_partition = merge_sort(list[:mid_point])
    right_partition = merge_sort(list[mid_point:])

    # 5\. The merge_sort function returns a list composed of a sorted left and right partition.
    return merge(left_partition, right_partition)

将初始列表的长度存储到变量 list_length 中。
merge_sort 函数返回一个排序后的列表。对长度为 1 的列表进行技术排序；因此，列表被返回。
对于任何长度大于 1 的列表，下一步是将列表划分为一个左 _ 分区和一个右 _ 分区。这是通过将初始列表的中点传递给 merge_sort 函数来实现的。
回想一下，分治算法是递归的。在合并排序算法实现中，递归发生在列表的分解中。为了确保所有分区都被分解成各自的组件，调用了 merge_sort 函数，并且列表的一个分区部分作为参数传递。
merge_sort 函数返回一个由排序后的左、右分区组成的列表。

合并排序算法的第二部分涉及到列表中元素按照指定顺序的实际排序。对于这个用例，原始列表中元素的排序顺序是升序。

征服和组合组件—作者的图像

# 6\. takes in two lists and returns a sorted list made up of the content within the two lists
def merge(left, right):
    # 7\. Initialize an empty list output that will be populated with sorted elements.
    # Initialize two variables i and j which are used pointers when iterating through the lists.
    output = []
    i = j = 0

    # 8\. Executes the while loop if both pointers i and j are less than the length of the left and right lists
    while i < len(left) and j < len(right):
        # 9\. Compare the elements at every position of both lists during each iteration
        if left[i] < right[j]:
            # output is populated with the lesser value
            output.append(left[i])
            # 10\. Move pointer to the right
            i += 1
        else:
            output.append(right[j])
            j += 1
    # 11\. The remnant elements are picked from the current pointer value to the end of the respective list
    output.extend(left[i:])
    output.extend(right[j:])

    return output

merge 函数接收两个列表，并返回一个排序列表，该列表由作为参数传递给 merge 函数的两个列表中的元素组成。

7.名为输出的空列表被初始化。该列表由已排序的元素填充。同样，初始化两个变量， i 和 j，，它们在遍历列表时用作指针。

8.我们用 while 循环遍历这两个列表，当指针 i 和 j 分别小于左右列表的长度时，该循环执行其主体。

9.在 while 循环体中，比较每次迭代中两个列表中每个位置的元素。输出列表在相应指针所在列表的当前索引处填充较小的值。

10.在输出列表被填充后，适当的指针将被递增。本质上，我们将指针向右移动，或者移动到列表中的下一个值。

11.在 while 循环完成后，或者如果整个循环条件不满足，则用每个列表的剩余内容填充输出列表。剩余元素从当前指针值拾取到相应列表的末尾。

def run_merge_sort():
    unsorted_list = [2, 4, 1, 5, 7, 2, 6, 1, 1, 6, 4, 10, 33, 5, 7, 23]
    print(unsorted_list)
    sorted_list = merge_sort(unsorted_list)
    print(sorted_list)

run_merge_sort()

最后，我们创建一个函数来初始化一个无序列表。变量 sorted_list 保存 merge_sort 函数的结果。

下面是完整的代码。

归并排序算法要点

为什么归并排序快？

在最坏的性能情况下，执行合并排序算法所需的计算时间量的时间复杂度为 O(n * log(n)) ，，其中 n 是列表中要排序的元素的数量。

使用合并排序算法排序的初始列表的每个分解的子部分花费线性时间与另一个子部分合并。这篇来自 Khanacademy 的文章深入解释了合并排序算法的时间复杂度和分析。

与其他排序算法相比，合并排序对于较大的数据集通常更快。这是因为合并排序减少了对列表进行排序的步骤。大多数其他排序算法，如插入排序 (O(n )) 和冒泡排序都需要很多步骤来对列表进行排序。例如，使用插入排序算法对包含 40 个元素的列表进行排序将需要 1600 步(40*40)，但是使用合并排序，对列表进行排序大约需要 64 步。

结论

一开始，处理算法可能会令人望而生畏，尤其是对初学者而言。我的做法是理解插入排序、归并排序等简单算法；之后，处理更复杂的算法。

对于机器学习从业者来说，开始扩展他们对算法及其实现的领域理解的旅程将会实现大量的好处。首先，您开始考虑您在日常工作中编写的程序的执行时间和性能，这通常有助于在与您开发的产品交互时获得积极的最终用户体验。

要联系我或找到更多类似本文的内容，请执行以下操作:

关注我的T3 推特 T5
订阅我的 邮件列表 获取每周简讯
跟着我上中
通过 LinkedIn 联系我

如何实现用于事件时间分析的随机森林、SVM 和梯度增强模型

原文：https://towardsdatascience.com/how-to-implement-random-forest-svm-and-gradient-boosted-models-for-time-to-event-analyses-5d79d8153bcd?source=collection_archive---------8-----------------------

带示例的循序渐进教程

乔纳森·彼得森在 Unsplash 上拍摄的照片

在这篇文章中，我们将比较几种先进的方法来进行时间-事件分析(又名生存分析)。具体来说，我们将涵盖随机森林，梯度推进和 SVM 生存模型。

时间-事件分析是帮助我们分析问题的重要方法，其中我们的研究问题有时间成分。顾名思义，当我们对理解时间和某个事件之间的关系感兴趣时，就会用到这些。

虽然我们通常在生物研究(即临床、制药)中发现这些研究，但它同样适用于其他领域(即工程、商业、营销)。一些例子包括:

疾病复发的时间
死亡时间
下次购买的时间
取消会员资格的时间

事件时间分析是一种修改的回归任务，但它是独特的，因为一部分数据是不完整的(经过审查的)。要理解这意味着什么，请看下图。

图 1 —事件发生时间(存活)分析。灰色数字代表一个事件。红色数字完成研究，无事件。黄色图没有完成研究，但也没有事件。(图片作者)

假设这是一项临床试验，观察某种药物对肿瘤复发时间的疗效。两个灰色数字代表观察到的事件(新肿瘤)，一个在 3 年后，另一个在 6.5 年左右。红色数字完成了这项研究，历时 10 年，没有观察到任何事件。最后，黄色的数字没有完成研究。他们在 5 年时从研究中丢失，但没有观察到任何事件。

在本例中，灰色数字代表未经审查的数据，而红色和黄色数字代表经审查的数据。删失数据指的是仅部分已知的数据。具体来说，红色数字完成了 10 年的研究。虽然没有观察到肿瘤复发，但这并不意味着两周后没有新的肿瘤形成(希望没有)。

黄色数字在 5 年时从研究中移除，在他们参与研究期间没有观察到新的肿瘤。它们为什么被移除？也许有不可接受的副作用。也许目标死于其他原因。另一种看待受审查参与者的方式是，他们在最后一次随访前没有发生任何事件。

数据

对于今天的例子，我们将使用 NKI 乳腺癌数据集。你可以在这里找到数据集。完整的数据集包括 272 名乳腺癌患者(行)和 1570 列。出于时间的考虑，我选择将列数减少到 11 个预测变量和 2 个结果变量(事件和存活时间)。下面，你可以预览我们的数据集。

图 2 —我们分析中使用的 NKI 乳腺癌数据集的选择。

有关数据集中变量的快速描述，请参考下图。

图 3——数据集中变量的描述

在我们开始之前，分割数据与大多数机器学习模型略有不同，因为我们有 2 个目标变量。这可以使用下面的代码来完成。

很重要的一点是，y 变量的格式应该使事件指示器为布尔型，时间变量为浮点型。点击查看更多细节。

图 4 —为事件时间分析创建数据集

现在我们可以建立我们的时间到事件模型，看看哪一个表现最好！

1.随机森林生存模型

如果你有兴趣了解更多关于随机森林模型是如何工作的，我建议你看看 scikit-survival 文档。也有很多关于这个主题的帖子，其中一个你可以在这里找到。

正如您在下面看到的，运行算法非常简单。在导入您决定评估的模型和指标之后(块 1)，您可以创建您的模型(块 2)。

将模型与数据拟合后，您可以发现它在测试集上的效果如何。事件时间分析最常用的指标是 c 指数(和谐指数)。这是预测风险值与观察时间之间的等级相关分数。你可以在这里找到更多关于这个的信息。

我们的结果提供了 0.77 的 c 指数，这可以解释为一个很好的模型。仅仅作为一个引子，c 指数得分为:

在预测结果方面，0.5 并不比随机概率更好
0.7 表示模型良好
0.8 表示强模型

图 5 —实现随机森林生存模型

尽管 c-index 为我们提供了整个模型的信息，但考察模型在不同时间点的表现也很有趣。为此，我们可以使用 cumulative_dynamic_auc 指标，并使用下面的代码将其可视化。

图 6——如何计算和绘制依赖于时间的 AUC

在下图中，我们看到，尽管该模型在整个研究中表现良好(最小 auc = 0.72)，但在第 2-4 年和第 11-12 年出现峰值，auc 值> 0.80。如果我们试图解释这一点，我们将不得不更多地查阅科学文献，以帮助我们理解哪些因素可能影响不同时间点的存活率。

图 7-随机森林生存模型的时间相关 AUC 分数。(图片作者)

现在我们已经有了模型，是时候找出不同的特性是如何影响我们的模型的了。有几个包可供选择，我从中选择了 ELI5 。下面，您将找到为您的模型实现这一点的必要代码。

图 8 —使用 eli5 的特性重要性

结果表明，雌激素受体表达(esr1)、严重性(等级)和大小(直径)、脉管系统结构的侵袭和年龄是我们模型中的前五个区别特征。有趣的是，在这项研究中，化疗或激素疗法并不能很好地区分那些活着或死去的人。

图 9-随机森林生存模型的特征重要性

2.梯度增强模型

梯度增强模型与随机森林模型有一些相似之处，因为它们都是集合方法。他们将多个模型的预测结合起来，以改进整体模型。区别在于它们是如何组合的。

虽然随机森林独立地适合许多不同的树并平均它们的预测，但是梯度增强模型是相加的。在后者中，来自一个模型的加权特征以连续的方式被输入到下一个模型中。更多信息，请查看 scikit survival 文档。你也可以看看这篇文章，它详细解释了增压和装袋。

与随机森林生存模型相似，它从导入模型开始(参见下面的代码)。有三种损失函数可用，在这里有更详细的描述。我选择了考克斯比例风险模型(coxpf)，这是默认的损失函数，但你可以尝试所有这些方法，看看你的结果有什么不同。

图 10 —实施梯度提升生存模型

整个模型的 c 指数得分为 0.703，低于使用随机森林模型获得的得分。在下图中，我们可以看到，随着时间的推移，区分存活率变得越来越差，到最后略有改善。

图 11-梯度增强生存模型的时间依赖性 AUC 评分。(图片作者)

尽管我们的模型在整体和时间相关拟合方面存在差异，但对于前 5 个特征，特征重要性(见下文)具有几乎相同的轮廓，尽管顺序不同。

图 12 —梯度增强存活率模型的特征重要性

3.生存支持向量机

作为标准支持向量机(SVM)的扩展，生存 SVM 基于我们的特征和生存之间的线性(或非线性)关系来分离类别。如果你想了解更多，你可以参考 scikit survival 文档，或者查看这个深入探究本质。在这一节中，我们将探索线性 SVM 和核 SVM 生存模型，看看哪一个对我们的数据集表现最好。

线性生存 SVM

在下面的代码中，我导入了必要的模型和指标。接下来，定义线性生存 SVM，然后拟合我们的数据。该模型产生了 0.716 的 c 指数，这比我们的梯度增强模型有更好的性能，但不是随机森林模型。

生存 SVM 的局限性之一是我们无法将这些模型与随机森林或 SVM 生存模型进行比较。这是因为它们缺乏时间-事件分析的“标准”指标，如生存函数和累积风险函数。这限制了我们与 c 指数得分的比较。

图 13 —实现线性生存 SVM

前 5 个区别特征再次与其他模型相似。尽管顺序不同，唯一的区别是化疗取代了前 5 名中的肿瘤大小。

图 14-线性生存 SVM 的特征重要性

内核生存 SVM

因为不能总是使用简单的线性方法来实现分类，所以可以使用核 SVM 来考虑我们的特征和生存之间更复杂的关系。下面的代码是我们如何实现内核生存 SVM 的，它导致了 0.766 的 c-index 分数。这与我们的随机森林生存模型(0.768)表现一样好(精确到小数点后两位)。

图 15 —实现内核存活 SVM

你可能在上面的代码中注意到内核是“线性”的。这是默认的内核，但是你可能会问这和线性 SVM 有什么不同？我鼓励你阅读我上面链接的文章来了解更多细节，但是作为一个快速的解释，请考虑下图。

如果我问你我们如何线性分割左边图像中的蓝色和黑色球，你会怎么说？不可能吧？如果我们处理的是二维空间，那就是真的。

如果我们增加另一个维度会发生什么？在右图中，您可以看到球在三维空间中旋转，我们现在可以看到 y 轴在垂直方向，z 轴在水平方向。我们可以在这里想象 x 轴，就好像我们在你的屏幕上插了一根棒(请不要这样做)。

当我们这样做的时候，很明显，至少对于这组球，我们可以用一个沿着 x 和 z 轴的平面来线性分离它们。这被称为超平面。然而，我们可以想象一张纸，而不是一条线。

使用核 SVM，可以将我们的特征映射到可以被(n 维-1)超平面分开的 n 维空间中。这就是 SVM 核中的线性核与线性 SVM 的不同之处。

图 16——通过将特征从 2 维空间(左)映射到 n 维空间(右，3d ),并找到最大程度分隔类别的超平面(n 维-1 ),核存活 SVM 可以找到一种对患者存活进行分类的方法。(图片由作者提供)

查看特征重要性权重(见下文)，我们得到了与其他模型相同的前 5 个特征。尽管在比较我们的模型时 c 指数得分不同，但这些结果让我们在试图从我们的数据中看到更大的画面时更有信心。

如果我试图总结我们从这些分析中学到的东西，那就是患者的生存更多地取决于肿瘤的发展、esr1 受体的表达、年龄和血管浸润，而不是任何种类的治疗(化疗、激素治疗或乳腺切除)。简而言之，我认为早期诊断是我们数据集中患者生存的最佳指标。

图 17 —内核存活 SVM 的特征重要性

4.使用 GridSearch 优化您的模型

到目前为止，我们已经比较了随机森林、SVM 和梯度增强事件时间模型来预测我们数据集中乳腺癌患者的生存率。我认为这将是有益的，通过一个例子，我们可以尝试优化我们的一个模型的结果。如果您想了解如何优化我们今天介绍的其他模型，请查看我们的笔记本。

让我们看看是否可以改进我们的内核 SVM。您可以手动完成这项工作，也可以实现网格搜索，在网格搜索中，您可以一次运行多个模型。你可以在这里找到更多关于这项技术的信息。

重要的是要记住，这是一个计算量很大的过程，所以要确保在这个过程中你有事可做。在下面的代码中，你会看到我们从 sklearn 导入了 GridSearchCV 和 ShuffleSplit 。

在第一个模块中，我们定义了指标，因此我们可以在以后将它添加到模型参数中。下一行定义了我们的基本模型，它与我们上面运行的模型相同。

带有shuffles split的行表示我们想要100 个随机分裂，其中我们训练 80%的数据，并验证 20%的数据。

param_grid 是每次运行模型时将进行的调整，每次调整的结果将进行比较，以查看哪一个执行得最好。值得注意的是，我选择只调查修改 alpha 超参数的影响，这是对损失函数的惩罚，类似于岭或套索回归的工作方式。选择的范围 I 是从 2e-12 到 2e+12，步长为 2(即 2e-12、2e-10、2e-8……)。

最后，定义模型并使其适合您的数据。请记住，当您这样做时，您是在整个数据集(X，y)上运行它，因为您已经使用shuffles split定义了分割。

结果实际上给了我们一个更差的模型，c 指数得分为 0.713。这是你在使用网格搜索时可能已经注意到的。据我所知，这主要是由于数据集分割的随机性造成的。我们还获得了一些关于最佳 alpha 分数的信息，该分数为 0.0625。这不同于默认值 1.0。

当我将 alpha 值插回到我们的原始模型中时，我最终得到了完全相同的分数(0.766)，表明我们的原始结果得到了优化。当然，如果我们改变内核等其他超参数，情况可能会有所不同。如果你感兴趣的话，我把这些放在我的笔记本里，上面有链接。但是，为了不让你担心，结果并没有从 0.766 提高。

图 18——使用 GridSearch 尝试并优化我们的内核生存 SVM

摘要

在今天的帖子中，我们介绍了 3 种不同的模型，用于研究乳腺癌存活率的数据集的时间-事件分析。具体来说，我们发现随机森林和核 SVM 生存模型优于梯度增强生存模型。

我们还研究了如何通过在超参数 alpha 上运行网格搜索来优化我们的内核 SVM 模型。我鼓励您尝试在网格搜索中添加额外的超参数。事实上，这是确保我们的模型得到优化的唯一方法。然而，如果你这样做了，也许可以通宵运行，这样你就不用等待结果了。这有点像观察草的生长。

我希望你喜欢今天的帖子。玩你的数据玩得开心！

如何使用元数据信息在 Python 中实现 Sentinel 2 图像的日光闪烁检测

原文：https://towardsdatascience.com/how-to-implement-sunglint-detection-for-sentinel-2-images-in-python-using-metadata-info-155e683d50?source=collection_archive---------16-----------------------

由 Unsplash 上的 Savvas Kalimeris 拍摄的照片

介绍

光学遥感分析依赖于理解地面物体对太阳辐射的吸收和散射过程。如果我们测量太阳入射辐射和表面的辐照度，我们将能够估计表面的反射率。不同波长的反射率是理解我们观察的目标的关键，因为每种材料都会根据所考虑的波长不同地反射和吸收能量。图 1 显示了水、土壤、植被和岩石等不同材料的平均反射光谱。

图 1:一些地表物质的广义反射光谱。来源:https://www . usna . edu/Users/oceano/pguth/MD _ help/html/ref _ spectra . htm

然而，一些不希望的效应会干扰观察到的反射率。这些效应特别存在于空间传感器中，因为它们位于地球大气层之外，并且存在云、水蒸气等。不断吸收和散射电磁能量。另一个影响反射率的重要因素是日照。

太阳辉光是由卫星或其他传感器以相同角度观察的一些表面上入射辐射的镜面反射(或类似镜子)引起的。在这些情况下，传感器将不会测量被观察目标的特征，而是与发射源的光谱的混合物。这可能会给许多遥感应用带来问题。

在火灾探测中，例如，Giglio 等人。艾尔。(2003)[1]表明，阳光对一些目标如水体、湿土、卷云甚至裸土的影响会导致错误的火警。在水资源中，这种影响尤其重要，因为水面受太阳光线的影响最大(图 2)。

图 Agean 海中的太阳闪烁示例。来源:美国宇航局地球天文台(https://Earth Observatory . Nasa . gov/images/84333/the-science-of-sunglint)

因此，对于大多数遥感应用来说，闪烁校正或至少闪烁识别是一项重要的任务。

方法学

因为我们的目标不是深入挖掘电磁辐射理论，而是展示如何使用 Python 和 Sentinel 2 元数据信息来估计场景中出现的太阳辉光。为了在水生系统中完全消除闪烁，我推荐来自 Harmel et 的论文。艾尔。(2018)2.相反，我们将展示如何使用 Giglio 等人提出的方法来预测太阳辉光的存在。艾尔。(2003).在这种方法中，我们必须根据下面的等式，检查获取图像时太阳和视角(天顶和方位角)之间的关系:

在这个等式中，下标 v、s 和 g 代表观察角、太阳角和闪烁角，θ指天顶角，φ是太阳和传感器之间的方位角差异，如图 3 所示。

图 3:用于计算日照的太阳和视角的表示。图片作者。

最终的闪烁角度值将由Arccos(θg)获得。根据作者的说法，由此产生的闪烁角是太阳辉光出现的预测因子。闪烁角度值越小，传感器和太阳越“对齐”,出现日光闪烁的可能性就越大。

输入数据

我们计算所需的所有信息都包含在 Sentinel 的 2 元数据文件MTD_TL.xml中。该文件位于颗粒子目录中。那么，我们来看看吧。如果我们第一次打开这个文件，它可能会让人不知所措，但是如果我们寻找Sun_Angles_Grid标签，我们可以找到我们需要的关于太阳位置的所有信息:

图 4:哨兵 2 元数据中呈现的太阳角度。

请注意，它是以 5000 米(23x23 网格)的步长呈现的，因此这并不完全是“像素级”信息，但我们可以在之后对其进行插值以匹配像素分辨率。我们将从通过**lxml** 包从元数据中读取太阳角度开始。最后，我们将使用一个 pandas 数据框架来实现可视化。

代码输出:

(         0        1        2        3        4
 0  19.5389  19.4952  19.4514  19.4076  19.3638
 1  19.5431  19.4994  19.4556  19.4119  19.3681
 2  19.5474  19.5037  19.4600  19.4162  19.3725
 3  19.5518  19.5081  19.4644  19.4207  19.3769
 4  19.5564  19.5126  19.4689  19.4252  19.3815,
          0        1        2        3        4
 0  80.1116  80.1092  80.1067  80.1041  80.1014
 1  79.9860  79.9833  79.9804  79.9775  79.9745
 2  79.8605  79.8574  79.8543  79.8510  79.8477
 3  79.7350  79.7316  79.7281  79.7246  79.7209
 4  79.6095  79.6058  79.6021  79.5982  79.5942)

如果我们与 XML 文件中的角度进行比较，我们可以看到我们的数据被正确加载。我们可以对传感器做同样的事情，但如果你仔细观察，你会发现我们有许多不同的传感器，它们有不同的角度。因为我们想要对我们的场景进行平均闪烁预测，我们将使用每个传感器的平均角度。为此，我们将创建一个通用函数，该函数读取给定节点名称的数组并返回其平均值，以检索传感器的平均天顶和方位角。最后，我们将使用 matplotlib 绘制角度。

代码输出:

注意:我们可能会看到，在探测器转换时，观察方位角有一些问题。关于这个问题的讨论线索可以在这里找到(https://forum . step . esa . int/t/sentinel-2-viewing-angles-interpolation-on-per-pixel-basis/2776/4

计算闪烁角

现在我们已经有了所有需要的角度，是时候计算闪烁角了。首先我们应该把它们都转换成弧度(numpy 三角函数使用的单位)。然后，最后的计算非常简单。为了可视化结果，我们将创建一个带注释的热图及其值。

代码输出:

叠加闪烁角和 RGB 图像

要可视化图像中更容易出现日光反射的部分，最好的方法就是将闪烁角网格与图像的 rgb 表示叠加。为了获得卫星图像的 rgb 表示，我们将使用**rasterio**包来读取红色、绿色和蓝色波段，正如 Python for Geosciences:Satellite Image Analysis 系列中所解释的那样(此处为)。

代码输出:

现在，我们可以使用matplotlib 中的imshow 函数叠加两个网格，并正确调整范围参数和 alpha 来应用透明度。

ax.imshow(rgb*4, alpha=0.6, extent=(-0.5, 22.5, 22.5, -0.5))
fig

结论

在这个故事中，我们讨论了如何根据 Giglio (2003)提出的 en Sentinel 2 元数据中可用的太阳和视角来估计太阳辉光事件。有了这一信息，就有可能调整受太阳辉光存在影响的任何遥感应用。例如，这个简单的太阳辉光预测目前正在**waterdetect** python 包(此处为 )3中实现，作为一种在预计有太阳辉光时调整最大阈值水平的方法。它还可以用于云探测器，以避免水被识别为云，或者用于火灾探测，以防止误报。

如果你对我们关于这个主题的评论有任何疑问，请不要犹豫，写在评论里。如果你想收到更多这样的故事，别忘了关注我。所以敬请期待，下篇故事再见。

保持联系

更多这样的故事:https://cordmaur.medium.com/

如果你喜欢这篇文章，并想继续无限制地阅读/学习这些和其他故事，考虑成为 中等会员 。你也可以在 https://cordmaur.carrd.co/查看我的作品集。

http://cordmaur.medium.com/membership

参考

[1]吉廖，l；Descloitres，j；司法总监；一种用于 MODIS 的增强型上下文火灾探测算法。环境遥感 2003 ， 87 (2)，273–282。https://doi . org/10.1016/s 0034-4257(03)00184-6。

2t .哈梅尔；横山雅美，m。t .托尔莫斯；雷诺，新泽西州；来自 SWIR 波段的多光谱仪器(MSI)-SENTINEL-2 图像在内陆和海洋水域上空的 Sunglint 校正。环境遥感 2018 ， 204 ，308–321。https://doi.org/10.1016/j.rse.2017.10.022。

3科尔代罗；马丁内斯，j .-m；Sentinel-2 图像多维层次聚类的自动水检测以及与水平 2A 处理器的比较。环境遥感2021253，112209。https://doi.org/10.1016/j.rse.2020.112209。

如何用一行代码导入所有 Python 库

原文：https://towardsdatascience.com/how-to-import-all-python-libraries-with-one-line-of-code-2b9e66a5879f?source=collection_archive---------23-----------------------

计算机编程语言

了解如何使用 PyForest 导入 40 个最重要的库

图片来源: Unsplash

如果你是一名数据科学家，或者正在学习如何成为一名数据科学家，你应该知道启动一个新的 Jupyter 笔记本项目的流程。您导入库，使用其中一些库，然后开始工作。由于忘记导入另一个库，您可能会在某个时候收到一条错误消息。您可以停止正在进行的工作，导入特定的库，然后重新开始工作。根据项目的大小，这种情况可能会发生几次。你也很有可能在 Google 上查过如何导入 matplotlib.plot。

是的，您可以使您的生活变得更简单，从另一个项目中复制并粘贴您将需要的所有包，但是如果我告诉您，您可以用一行代码导入您所有的基本包并专注于重要的东西，那会怎么样呢？这个解决方案叫做 PyForest。PyForest 是懒惰的舶来品。顾名思义，它为 Python 导入了最流行的数据科学库。PyForest 开发者的目标是导入 99%最常用的库。

听起来很棒，对吧？然而，如果你不使用所有的库呢？你为什么要全部进口？好消息是，PyForest 只会在您使用它们时导入这些库。出于这个原因，没有理由担心你的电脑变慢。因为除非您使用它们的函数或方法，否则不会导入这些库，所以这是一个比从其他项目中复制和粘贴代码更好的解决方案。

安装

现在，如何使用这个神奇的解决方案？越简单越好。Pyforest 可以从 Pypl 安装。您可以在终端上键入以下命令:

pip install pyforest

如果你在 Jupyter 笔记本上，你可以输入:

!pip install pyforest

要导入，您可以使用

import pyforest

或者

from pyforest import *

这些选项应该以同样的方式工作，但是你知道，Python 有时会很棘手。如果一种方法行不通，你可以尝试另一种方法。瞧，你有一些最重要的图书馆，你可以专注于你的项目。

但是实际上导入的是什么呢？

好消息是，这个列表很长，举几个例子，它包括 Pandas、NumPy、Matplotlib、Seaborn、Sklearn、Keras、NLTK，这个列表还在继续。最酷的部分，在我看来？他们使用的别名是数据科学家的标准约定，比如导入 Pandas 作为 pd，导入 NumPy 作为 np。生活可以毫不费力！

键入 lazy_imports() 可以找到完整的库列表，您将能够看到完整的列表。

作者图片

向 PyForest 添加更多库

正如我们所看到的，有大量不同的库，这应该涵盖了您的大部分项目。但是，缺少一些基本的库。我们可以通过手动添加您最喜欢的库来快速解决这个问题。您可以尝试以下步骤来添加 PyForest 最初没有提供的库。

首先，到您的终端键入:

pip show pyforest

您将看到终端将返回 PyForest 目录的位置。如果使用的是 macOS，可以键入 Command+Space 粘贴目录地址。找到名为 _imports.py 的文件，添加您需要的所有库。

作者图片

搞定了。现在，您将拥有所有的收藏夹库，并担心什么对您的项目至关重要。我创建了一个微型项目——，你可以在这里找到它——在这里我展示了我如何使用 PyForest 而没有从其他库导入任何东西。请记住，如果您想要运行 Jupyter 笔记本，您必须在您的环境中安装 PyForest。

如何使用 Python 将 CSV 数据导入 Quickbooks

原文：https://towardsdatascience.com/how-to-import-csv-data-into-quickbooks-using-python-b37c989149f7?source=collection_archive---------34-----------------------

免费使用 Python 将日记条目电子表格导入 Quickbooks Online

如果您处理过将数据导入 Quickbooks Online 的问题，您就会知道这是一个繁琐的过程。事实上，这是一个非常麻烦的问题，像 SaasAnt 这样的公司已经开发了专门用于自动化这一过程的产品。

在本文中，我将向您展示如何利用 hotglue 的目标——quickbooks将 CSV 数据导入 Quickbooks。

来源: unDraw

第一步:格式化你的电子表格

首先，我们必须把我们的日志条目电子表格放在一个 target-quickbooks 包能够理解的格式中。将文件命名为JournalEntries.csv 列应该是:

Transaction Date - The day the transaction occurredJournal Entry Id - The ID of the Journal Entry (becomes the DocNumber in QBO)Account NumberAccount Name - If you aren't using Account Numbers, it will use this column to find the AccountClassCustomer NameAmount - Must be a POSITIVE numberPosting Type - Either "Debit" or "Credit"Description - Description for the entryCurrency - Optional. Allows you to specify a different currency code

您的最终文件应该如下所示:

示例 JournalEntries.csv 文件

步骤 2:设置我们的环境

创造虚拟

为了避免依赖地狱，我强烈建议在虚拟环境中运行这个例子。

# Create the virtual env
$ python3 -m venv ~/env/target-quickbooks# Activate the virtual env
$ source ~/env/target-quickbooks/bin/activate# Install the dependencies
$ pip install git+[https://github.com/hotgluexyz/ta](https://github.com/hotgluexyz/target-csv.git)rget-quickbooks.git# Create a workspace for this
$ mkdir quickbooks-import# Enter the directory
$ cd quickbooks-import

这些命令可能因您的操作系统和 Python 版本而异。

步骤 3:配置目标

获取 OAuth 凭证

首先，你需要 Quickbooks OAuth 证书。Quickbooks 已经很好地记录了这个过程，所以我假设你可以遵循这个指南。如果您不熟悉如何完成 OAuth 授权流程，您可以遵循 hotglue 文档。

创建目标配置

现在我们必须创建一个目标配置。这将指定我们的 OAuth 凭证，它应该在哪里寻找我们的 CSV 文件，以及一些 QBO 特定的设置。下面是一个配置示例:

{
  "client_id": "secret_client_id",
  "client_secret": "secret_client_secret",
  "refresh_token": "secret_refresh_token",
  "sandbox": true,
  "realmId": "123456789",
  "input_path": "tests"
}

填写您的凭证，并将其保存到本地目录中名为config.json的文件中。如果你没有使用沙盒 QBO 帐户，请确保将sandbox设置为false。

保存格式化的电子表格

将您的JournalEntries.csv文件保存到您在input_path中为我指定的文件夹，即tests

注意:目标希望文件被命名为确切地说是 JournalEntries.csv

步骤 4:将数据发送到 Quickbooks Online

现在我们可以运行目标，并将我们的数据发送到 QBO！

target-quickbooks --config config.json

如果在发送日志条目时出现任何错误，您将直接在控制台中看到这些错误。成功的导入应该如下所示:

target-quickbooks - INFO - Converting MAR21 REV_REC (2)...
target-quickbooks - INFO - Loaded 1 journal entries to post
target-quickbooks - INFO - Posting process has completed!

瞧啊。我们在 Quickbooks 中看到新的日志条目:

在 Quickbooks Online 中导入日记条目

结论

后续步骤

如果你想部署这个管道，或者想在你自己的产品中提供这个功能，请查看 hotglue 。

希望这能节省你一些时间。目前，该目标仅支持日志条目，但对发票等的支持将很快推出。感谢阅读！

使用 Pandas DataFrame 无错导入 CSV 文件

原文：https://towardsdatascience.com/how-to-import-csv-files-using-pandas-dataframe-error-free-62da3c31393c?source=collection_archive---------5-----------------------

EmptyDataError。听着耳熟？然后继续关注我的一些提示，以避免在使用 Pandas DataFrame 加载 CSV 文件时出现任何形式的错误。

小植物在 Unsplash 上拍摄

ata 处于机器学习管道的中心。为了充分利用算法的全部能力，必须首先对数据进行适当的清理和处理。

数据清理/争论的第一步是加载文件，然后通过文件的路径建立连接。有不同类型的分隔文件，如制表符分隔文件，逗号分隔文件，多字符分隔文件等。定界符指示数据如何在列内被分开，是通过逗号、制表符还是分号等。最常用的文件是制表符分隔和逗号分隔的文件。

在整个 ML 管道中，数据争论和清理占据了数据分析专业人员大约 50%到 70%的时间。第一步是将文件导入熊猫数据框架。然而，这一步是遇到最多的错误。人们经常在这个特定的步骤中陷入困境，并遇到类似这样的错误

empty data 错误:文件中没有要解析的列

常见错误的出现，主要是由于:

提到了错误的文件分隔符。

文件路径格式不正确。

错误的语法或分隔符用于指定文件路径。

提到了错误的文件目录。

文件连接未形成。

数据分析专业人员无法承受在已经非常耗时的步骤中耗费更多时间。在加载文件时，必须遵循某些重要的步骤，这些步骤将节省时间，并减少在大量信息中寻找特定问题的解决方案的麻烦。因此，我列出了一些步骤，以避免在使用 pandas DataFrame 导入和加载数据文件时出现任何错误。

读取和导入 CSV 文件并不像人们想象的那么简单。一旦你开始加载你的文件来建立你的机器学习模型，这里有一些必须记住的提示。

1。 在设置中检查您的分色类型:

用于 Windows

转到控制面板
点击区域和语言选项
点击区域选项选项卡
点击自定义/附加设置
在“列表分隔符”框中键入逗号(，)
单击“确定”两次以确认更改

注意:这只适用于“十进制符号”也不是逗号的情况。

用于 MacOS

前往系统偏好设置
点击语言和地区，然后进入高级选项
将“小数分隔符”更改为以下情况之一

对于 MacOS，如果小数点分隔符是句点(。)那么 CSV 分隔符将是逗号。
如果小数点分隔符是逗号(，)，那么 CSV 分隔符将是分号。

2。 查看文件的预览:

还可以检查文件的预览，可以看到数据是如何被分隔的，是通过制表符分隔还是逗号分隔。人们可以在 Jupyter notebook 或 Microsoft Excel 中检查预览。

3。 正确指定所有参数:

看了预览并检查了为您的计算机指定的分色后。我们现在必须填充正确的参数，这些参数需要在“pd.read_csv”函数中根据文件类型作为分隔符(制表符分隔等)、空白标题(在这种情况下 header= none)等。

Pandas.read.csv 有许多参数，需要考虑这些参数才能正确读取该文件。

pandas . read _ CSV(file path _ or _ buffer，sep= < object object >，delimiter=None，header='infer '，names=None，index_col=None，usecols=None，squeeze=False，prefix=None，mangle_dupe_cols=True，dtype=None，engine=None，converters=None，true_values=None，false_values=None，skipinitialspace=False，skipfooter=0，nrows=None，na，lineterminator=None，quotechar= ' " '，quoting=0，doublequote=True，escapechar=None，comment=None，encoding=None，dialect=None，error_bad_lines=True，warn_bad_lines=True，delim_whitespace=False，low_memory=True，memory_map=False，float_precision=None，storage_options=None)

这是所有论点的清单，但我们最关心的是以下几点:

sep:这指定了数据值之间的分隔类型。默认值为“，”。在检查了预览和系统设置之后，我们知道了文件的类型。最常见的分隔符/分隔符类型是逗号、制表符和冒号。因此，它将被指定为 sep= '，'，sep= ' '，sep = '；'这告诉 pandas DataFrame 如何将数据分布到列中

如果问题仍然存在，请检查需要输入的任何必需参数。那么问题可能出在文件路径上。

4。 检查文件路径:

此参数用于描述特定数据文件的路径对象或类似文件的对象，基本上是其位置。输入是一个字符串。也可以输入 URL，有效的方案有 HTTP、FTP、s3、gs 和 file。

文件位置应被正确提及。大多数情况下，人们不知道工作目录，结果提到了错误的文件路径。在这种情况下，我们必须检查工作目录，以确保正确描述了指定的文件路径。编写如下所示的代码来检查工作目录。

作者图片

这将打印工作目录。然后，我们必须只指定你的工作目录后的位置。

我们也可以使用下面一行代码来改变工作目录。指定新目录后，我们必须指定路径。

作者图片

5。 检查用于指定文件位置的分隔符:

通常在改变工作目录时也会出错。这是因为没有按照正确的语法编写分隔符。

作者图片

首先。使用以下命令检查分隔符。

作者图片

然后，仅在目录位置的开头使用分隔符，而不要在结尾使用。请注意，这种分隔符(/)语法规范适用于 MacOS，但可能不适用于 Windows。

作者图片

现在，在正确指定位置后，我们已经对其进行了更改。

现在我们必须指定路径。因为我们熟悉工作目录。我们只需指定工作目录之后的位置。

如果你的文件在工作目录中，那么只需要如下所示的文件名。

作者图片

但是，如果您的文件存在于某个其他文件夹中，那么您可以在工作目录后指定后续文件夹，例如，您的工作目录是“/Users/username”，而您的文件位于“documents”中名为“huma”的文件夹中，那么您可以编写以下代码:

*path = ‘Documents/huma/filename.csv’*

6。 检查文件是否在路径:

现在使用下面的代码检查您的文件是否存在于描述的路径中。我们得到的答案要么是“对”，要么是“错”。

作者图片

7。 打印要钩稽的文件数据:

现在，我们可以使用下面的代码检查我们的数据文件是否已经正确加载。

作者图片

有了这些提示，你可能不会在使用 Pandas DataFrame 加载 CSV 文件时遇到任何问题。

如何改进带注释的 D3.js 图形

原文：https://towardsdatascience.com/how-to-improve-d3-js-graphs-with-annotations-252fbb9c5bb5?source=collection_archive---------27-----------------------

数据可视化

一个简短的教程，将简单的 D3.js 图形转换成带有上下文的精彩图形

作者图片

数据驱动库(D3)是用来构建图表和绘画的最著名的 Javascript 库之一。关于图形，有许多网站提供现成的代码，如 D3 图库和从数据到视觉。然而，这些网站只提供基本代码，没有提示或细节来突出数据背景或见解。

在本教程中，我利用了 d3-annotation 库来扩展由 D3 Graph Gallery 提供的两个简单的图形，以使它们对普通读者更具可读性:

简单的条形图
简单的折线图

从来没有人因为一个数字而做出决定。他们需要一个故事。(丹·卡尼曼)

所有代码都在我的 GitHub 库中。

条形图

第一个例子是由 D3 图形库提供的简单条形图，如下图所示:

作者图片

该图尝试绘制以下数据集:

作者图片

从数据上下文的角度来看，该图至少提出了两个问题:

栏中的国家没有排序，因此很难理解哪个国家比其他国家表现得更好。
图表上没有焦点，因此读者应该想象图表想要表达什么。

为了改进图表，我将这两个问题分开处理。

关于条形图的顺序，可以通过根据值字段将所有结果按降序排列来改进图表。在 D3 中，这可以通过sort功能实现:

data.sort(function(x, y){return d3.descending(x.Value, y.Value);})

该函数需要一个函数作为输入参数，该函数指定用于对每对字段进行排序的规则。

关于图形没有焦点的事实，我可以将焦点放在单个国家，例如法国，并用不同于其他国家的颜色来表示它。此外，我可以将其他国家的颜色改为灰色，以减少其他国家产生的噪音。这可以通过为每个国家生成的矩形指定特定颜色来实现:

svg.selectAll("myRect")
    // other code
    .attr("fill", function(d){ if (d.Country == 'France') return "#cc0000" ; else return "#a3a3c2"})

所描述的效果提供了下图:

作者图片

现在，我可以想象描述为什么法国在排名中达到了第三的位置。也许这是由于它去年强有力的营销政策。因此，我可以向图表添加注释，解释上下文。

首先，我通过指定文本(在note字段中)、颜色和位置(通过x, y, dx和dy键)来构建注释:

const annotations = [
    {
    note: {
      label: "Thanks to its marketing policy, in 2021 France has reached the third position.",
      title: "France product sales",
      wrap: 200,  // try something smaller to see text split in several lines
      padding: 10   // More = text lower

    },
    color: ["#cc0000"],
    x: x(2500),
    y: 100,
    dy: 100,
    dx: 100
  }

然后我将注释附加到 SVG 图中:

const makeAnnotations = d3.annotation()
  .annotations(annotations)svg.append("g")
  .call(makeAnnotations)

下图显示了最终结果:

作者图片

折线图

第一个例子是由 D3 图形库提供的简单折线图，如下图所示:

作者图片

这条线主要存在两个问题:

y 轴没有标签，因此很难理解测量单位。
与上图类似，没有上下文。

关于 y 轴标签，添加起来很简单。我在 SVG 图像中添加了一些文本(例如收入),我将它旋转了 90 度，放在 y 轴附近:

svg.append("text")
      .attr("transform", "rotate(-90)")
      .attr("y", 0 - margin.left)
      .attr("x",0 - (height / 2))
      .attr("dy", "1em")
      .style("text-anchor", "middle")
      .text("Earnings");

关于语境，要看数据。我可以想象，这些数据指的是法国在特定时期的收入。我注意到在 18 日星期三有一次失败，而从 20 日星期五开始数据再次上升。因此，我可以用两点来强调这两个方面。

第一个注释应该突出显示所有的翻转周期，因此我可以使用一个d3.annotationCalloutCircle，而第二个注释只能突出显示一个点，对应于星期五 20 日，因此我可以使用一个d3.annotationCalloutElbow。

下面是构建注释的代码:

var parseDate = function(d){ return d3.timeParse("%Y-%m-%d")(d)}
      const annotations = [
       // first annotation
        {
      note: {
        label: "Earnings plummeted",
        title: "April 17th - 19th",
        wrap: 150,  // try something smaller to see text split in several lines
        padding: 10   // More = text lower

     },
     color: ["#cc0000"],
     x: x(parseDate('2018-04-18')),
     y: y(8197),
     dy: -100,
     dx: -5,
     subject: {
      radius: 50,
      radiusPadding: 5
    },
    type: d3.annotationCalloutCircle,
    },
    // second annotation
        {
      note: {
        label: "Strong Recovery",
        title: "April 20th",
        wrap: 150,  // try something smaller to see text split in several lines
        padding: 10   // More = text lower

     },
     color: [" #00b300"],
     x: x(parseDate('2018-04-20')),
     y: y(8880.23),
     dy: 40,
     dx: 40,
    type: d3.annotationCalloutElbow,
    },

      ]

      window.makeAnnotations = d3.annotation()
        .annotations(annotations)

        svg.append("g")
    .call(makeAnnotations)

我定义了一个变量parseDate，它解析一个字符串并返回一个日期。

下图显示了最终的图形:

作者图片

摘要

在这个简短的教程中，我举例说明了如何改进条形图和折线图，以便提供一些背景信息。我已经开发了d3-annotation库，这是 d3 注释的第三方库。

在接下来的几天里，我将写一篇关于改进地理地图的教程…敬请期待；)

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

https://medium.datadriveninvestor.com/getting-started-with-d3-js-maps-e721ba6d8560

上下文分析能帮助提取有意义的见解吗？

上下文分析包括围绕数据集的所有世界的分析。数据集周围的世界可能包括不同的方面。例如，如果您正在测量一段时间内海面的温度，环境可能包括天气条件、一些船只的存在等等。

定义上下文分析有三个要素:

事件
环境
时间

在这里阅读更多。

如何改进时间序列的深度学习预测—第 1 部分

原文：https://towardsdatascience.com/how-to-improve-deep-learning-forecasts-for-time-series-1799e3975d7c?source=collection_archive---------8-----------------------

集群背后的理论及其好处。

在拟合之前对时间序列数据进行聚类可以提高约 33%的精度— src 。

图 1:时间序列聚类示例。图片作者。

2021 年，加州大学洛杉矶分校的研究人员开发了一种方法，可以提高许多不同时间序列的模型拟合度。通过聚集相似结构的数据并为每一组拟合一个模型，我们的模型可以专门化。

虽然实现起来相当简单，但与任何其他复杂的深度学习方法一样，我们经常受到大型数据集的计算限制。然而，所有列出的方法都支持 R 和 python，所以在较小的数据集上开发应该非常“简单”

在本帖中，我们将从一个技术概述开始，然后进入为什么聚类提高时间序列预测拟合的本质。这是第二部分。

让我们开始吧…

1 —技术 TLDR

有效的预处理和聚类可以提高神经网络对序列数据的预测精度。该文件有助于以下每个领域:

利用黄土和 r 中的 tsclean 包移除异常值。
使用 k 近邻输入缺失数据。
使用基于距离和基于特征的方法进行聚类。
概述利用聚类数据的神经网络架构。

2 —但是实际上发生了什么呢？

我们的主要目标是提高深度学习对许多相关时间序列 (TS)预测的准确性。然而，与任何预测模型一样，它们的好坏取决于它们的数据，因此在本文中，我们将主要关注数据争论。

出于解释的目的，让我们假设我们有一个理论数据集，其中我们观察世界各地不同市场的黄金价格。这些市场中的每一个都试图接近全球价格进行交易，但是由于其所在地的供需波动，价格可能会发生变化。

在下面的图 2 中，我们看到了其中一个市场的时间序列。

图 2:黄金价格随时间的时间序列— src 。图片作者。

现在一些市场有相似之处。那些靠近金矿的地区受运输成本的影响较小，因此它们的供应波动性较低。相反，富有买家的地区需求波动较小。

我们的方法将把相似的时间序列组合在一起，这样我们的模型就能适应特定的情况，从而表现出更高的准确性。

2.1—数据预处理

数据预处理是一个手动过程，有助于从潜在的噪声和稀疏数据中提取信号。常见的第一步是去除异常值。

图 3: IQR 方法，其中 Q1 是第一个四分位数，Q3 是第三个四分位数。超出左/右界限的值是异常值。图片作者。

存在大量的非时间异常值检测方法，例如经典的 IQR 方法(图 3 ),其中我们排除了距离分布中心足够远的数据。但是，对于时间序列数据，我们必须采取特殊的预防措施。

例如，如果随着时间的推移，我们的数据出现了强烈的趋势、方差变化或其他一些系统性变化，传统的异常值检测方法就会失效。

为了应对数据的时间变化，我们建议使用一个名为 tsclean 的 R 包。幸运的是，它还支持缺失数据插补，所以如果你的时间序列有空值，你可以很容易地插入它们。在这一步之后，我们将得到一个去除了异常值的不间断的时间序列，如图 4 所示。

图 4:缺失估算(红色)和异常值调整(蓝色)数据— src 。图片作者。

如果你好奇这个方法是如何工作的，简而言之， tsclean 将我们的时间序列分解成趋势、季节和“其余”部分，如下所示。

图 5: tsclean 分解其中 T 是趋势，S 是季节性，R 是其余部分。图片作者。

从这里开始，我们在 R_t 上使用 IQR 异常值检测方法。通过在我们的时间序列的静态(去趋势)部分寻找异常值，我们更有可能找到实际的异常值，而不是依赖于时间的变化。

最后，如前所述， tsclean 软件包支持数据插补的线性插值。线性插值只是用缺失值旁边的非空点的平均值替换缺失值。尽管有这个功能，作者建议使用一种不同的方法，叫做kNNImpute—R package。不幸的是，kNNImpute 超出了本文的范围，但是上面的链接提供了一个健壮的演练。

2.2 —聚类

现在我们有了一个干净的时间序列，我们将把我们的时间序列值聚类到相似的集合中。

聚类的目的是提高我们模型的准确性。通过处理多组相似的数据点，我们更有可能精确地拟合数据。

图 6:基于距离的聚类示例— src 。图片作者。

有两大类集群。第一种类型称为基于距离的聚类。这种方法只是为了最小化聚类中数据点之间的距离。作者建议使用动态时间弯曲(DTW ),这是一种非常健壮和常用的序列数据距离度量方法。与 kNNImpute 一样，这种方法超出了本文的范围，但简而言之，它增加了距离最小化目标的约束，以允许在连续序列之间进行更健壮的比较。

图 7:基于特征聚类成两组(红色和蓝色)的理论示例。图片作者。

第二种方法称为基于特征的聚类。正如您所料，它使用特性将数据点分组到不同的簇中。这很难想象，所以我们在图 7 中创建了一个示例图表。

在本文中，我们测试了两组特性。第一个包括特定于时间序列的特征，如自相关、部分自相关和霍尔特参数。第二组借鉴了信号处理的思想，包括能量、快速傅立叶变换(FFT)系数和方差。通过利用关于数据的信息，我们有望看到组内一致的模式。在此基础上，我们可以为每一组建立一个模型。

当在模拟数据上运行时，基于特征的聚类优于基于距离的聚类。并且，在两个特征集中，基于信号的特征优于时间序列特征。

2.3—神经网络架构

现在，我们已经清理了原始数据并开发了聚类，我们准备开发我们的神经网络架构并进行训练。

本文概述了 7 种体系结构，其中一些结合了动态和静态特性。在我们的黄金市场示例中，动态特征可以是天气，静态特征可以是市场的位置。

图 8:显示集群数据最佳性能的模型结构。作者图片

在本文测试的合成数据上，简单的双向 LSTM 表现最佳。令人惊讶的是，合成数据中的静态特征并没有提高准确性，然而这种观察非常依赖于数据。对于您的用例，您可能想要探索包含静态特性的其他架构。

现在你知道了！

3 —摘要

在这篇文章中，我们介绍了如何预处理和聚类时间序列数据。单独的聚类被引用来提高大约 33%的分类准确度。然而，需要注意的是，这些测试是在合成数据上运行的——您的数据可以看到不同程度的改进。

概括地说，我们首先通过使用季节分解和 IQR 方法去除异常值来预处理数据。然后，我们使用 K 近邻估算缺失数据。

有了干净的数据集，我们对时间序列数据集进行了聚类。最可靠的方法是使用信号处理功能。

由此可见，双向 LSTM 是观察到的训练数据的最有效方法。静态特征没有提高准确性。

本文中讨论了许多备选方案，如果您需要提高模型的准确性，可能值得探索这些方案。

感谢阅读！我会再写 31 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源和一些有用的资源。

如何改进时间序列的深度学习预测—第 2 部分

原文：https://towardsdatascience.com/how-to-improve-deep-learning-forecasts-for-time-series-part-2-c11efc8dfee2?source=collection_archive---------24-----------------------

时序数据聚类背后的代码。

在之前的文章中，我们解释了时间序列数据的聚类是如何工作的。在本帖中，我们将深入探究代码本身。

所有的东西都会用 python 写，但是大多数库都有 R 版本。我们将努力保持相对较高的水平，但如果你想了解更多，代码会有一些有用的资源。

事不宜迟，我们开始吧。

0 —数据创建

为了有助于解释，让我们利用一个理论上的例子:我们试图通过使用来自世界各地本地市场的信息来预测黄金价格。

首先，我们开发一个 1000 x 10 的数据帧。每行对应一个独特的时间点，在我们的例子中是一天，每列对应一个不同的黄金市场。我们数据框中的所有值都是价格。

# create data
rng = pd.date_range('2000-01-01', freq='d', periods=n_rows)
df = pd.DataFrame(np.random.rand(n_rows, n_cols), index=rng)

上面的代码极大地简化了我们的例子。一个概念性的问题是，价格总是取 0 到 1 之间的值，然而代码的教训仍然适用。

创建了一个合成数据框，让我们把它变脏。

# "unclean" data
df = df.apply(lambda x: make_outliers_on_col(x), axis='index')
df = df.apply(lambda x: make_nan_on_col(x), axis='index')

上面的函数在我们的数据框中随机输入了 10 个异常值和 10 个空值。我们生成的数据框看起来像这样…

图 1:合成数据会丢失值和异常值。作者图片

1 —数据清理

有两个主要的数据清理步骤:缺失数据插补和异常值剔除。幸运的是，熊猫有一些简单的内置方法可以帮助我们。

# interpolate missing values
df = df.interpolate(method='spline', order=1, limit=10, limit_direction='both')# interpolate outliers
df = df.apply(lambda x: nullify_outliers(x), axis='index')
df = df.interpolate(method='spline', order=1, limit=10, limit_direction='both')

我们的策略很简单。我们首先使用样条插值法估算所有缺失的数据。然后，我们用空值替换所有异常值，并再次使用样条插值。

论文提出了多种缺失值插补方法，其中一些包括插值(如上所示)奇异值分解(SVD)插补和 K 近邻(KNN)插补。

如果你在乎速度，SVD 或者插值是你最好的选择。KNN 可能会提供更好的结果，但它的计算量更大。

在这一步结束时，我们将得到如图 2 所示的数据框:

图 2:合成清理数据将缺失值和离群值进行估算。作者图片

2 —聚类

有了清晰的数据集，我们现在将寻找具有相似特征的黄金市场。我们的假设是，相似的市场将更容易被模型拟合，从而导致更准确的预测。

论文中引用的最有效的分类类型包括利用每个时间序列的特征。我们会看两种类型:时间序列和信号处理特征。

# TS-specific features
autocorrelation = df.apply(lambda x: acf(x, nlags=3), axis='index')
partial_autocorrelation = df.apply(lambda x: pacf(x, nlags=3), axis='index')# Signal-processing-specific features
fast_fourier_transform = df.apply(lambda x: np.fft.fft(x), axis='index')
variance = df.apply(lambda x: np.var(x), axis='index')

从这里，我们可以对每对特征集执行 k-means 聚类。为了简单起见，我们只限于两个特性，但是本文列举了两个组的四个潜在特性。

import numpy as np
from scipy.cluster.vq import kmeans2# setup ts and signal features for clustering
features = [np.array([autocorrelation, partial_autocorrelation]),
            np.array([fast_fourier_transform, variance])]for f in features:
    # cluster
    out = kmeans2(f, 2)
    cluster_centers, labels = out # ...

上面的代码将我们的 10 个黄金市场分成两个不同的组，如图 3 所示。

图 3:我们的时间序列数据的聚类。左图使用时间序列特征，右图使用信号处理特征。图片作者。

既然我们已经将数据分组到“相似的”时间序列中，我们就可以为每个组建模了。

3 —预测模型

该论文认为双向 LSTM 具有最好的精确度。尽管名字很吓人，双向 LSTM 只是两个 LSTM。第一种是用常规输入进行前向后向训练。第二种是用反向输入向量从后向前训练的。

通过在一个时期内创建两个学习结构，模型通常会更快地收敛，并更完整地学习数据中的结构。

然而，为了简单起见，我们将使用基本的 LSTM，但是这些概念可以很容易地应用于更复杂的模型结构。

在这样做之前，重要的是要注意我们在每个聚类中对时间序列值进行了平均。有些模型，如 DeepAR ，适合多个时间序列，并输出单一预测。然而，普通 LSTMs 需要单变量数据。

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM# fit basic LSTM
model = Sequential()
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=n_epoch, batch_size=1, verbose=2)

上面的代码在所有 4 个数据集上迭代运行，它们的精度如图 4 所示。

图 4:我们每个集群的时间序列预测。蓝色是原始数据，橙色是训练 preds，绿色是我们的预测。图片作者。

仅通过视觉判断，我们的预测似乎没有太大差异，所以让我们看看每个模型的均方根误差(RMSE)。

图 5:我们四个模型的 RMSE。图片作者。

图 5 为我们的评估增加了更多的粒度。我们可以看到，TS 功能在群集 1 上的表现优于信号功能，但在群集 2 上表现较差。总的来说，每组的聚类 1 和聚类 2 之间的平均 RMSE 是相似的。

现在你可能想知道为什么不同组的表现如此相似。如果你还记得，我们的数据生成机制对所有时间序列都是一样的。

聚类的目的是提取时间序列模型中的系统差异。然后我们可以为每一个开发一个专门的模型。

如果数据具有相同的底层数据生成机制，聚类将无助于预测性能。

4 —后续步骤

以上演练的完整代码可以在这里看到。然而，对于具有真实世界数据的建模项目，建议进行更多的尝试。

例如，利用主题知识来了解时间序列应该如何分组也是非常有益的。黄金数据的一个例子是在相似的地理位置对时间序列进行聚类。如果你没有主题知识，这里有更多的想法:

聚集更多功能
同时在 TS 和基于信号的功能上集群
使用更复杂的深度学习结构
介绍静态特性(文章讨论了这方面的架构)

感谢阅读！我会再写 30 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源和一些有用的资源。

提高你的编程技能

原文：https://towardsdatascience.com/how-to-improve-programming-skills-for-data-scientists-and-machine-learning-practitioners-d865d8aadab1?source=collection_archive---------26-----------------------

编程；编排

从机器学习从业者的角度来看，提高编程技能的五种方法。

罗曼·辛克维奇在 Unsplash 上拍摄的照片

我讨厌编程！

这是七年前我实习时对我的同学们说的话。这是真的。我避免像公共交通工具上的无面具人一样编写项目。

快进到今天，我已经获得了编码相关学科的两个高级学位，在五家不同的公司担任 web 开发人员，现在我是一名计算机视觉工程师。

我爱编程！

如果有人问我为什么对技术如此热情，我会这么说。我对编程的热爱源于这样一种认识，即用代码实现一个应用程序实际上在一个技术驱动的社会中打开了机会。

这篇文章介绍了我用来确保我的编程技能不断提高的方法。对你来说，这篇文章将介绍五个策略，你可以采用它们来提高你的编程技能。

1.练习算法

算法往往会吓跑很多 ML 从业者，包括我。机器学习领域作为一种消除实现启发式算法来检测模式的需要的方法而出现，我们将特征检测留给神经网络。

尽管如此，算法在软件和计算领域仍有一席之地，当然在机器学习领域也有一席之地。

Pankaj Patel 在 Unsplash 上拍摄的照片

练习算法的实现是提高编程技能的推荐方法之一。

除了在实现内存高效代码上建立直觉的明显好处之外，处理算法还有另一个好处，那就是发展解决问题的思维。

实现算法包括在您选择的编程语言中探索各种数据结构和数据修改方法。理解如何在编程语言中利用数据对象、方法和其他有用的功能可以提高编程效率。

数据科学家经常实现数据挖掘和 web 抓取算法。对算法和数据结构有很好的理解可以帮助实现高效的代码，在生产中执行得更快。这具有减少总项目交付时间的连锁效应。

算法有不同的复杂程度，但这里有一个简单算法对的解释，可以让你热身。

亲身经历

作为一名移动计算机视觉工程师，我利用许多深度学习模型来完成常见的 CV 任务，如姿势估计、对象检测等。

尽管 PyTorch、TensorFlow 和 Keras 等平台抽象了模型实现的复杂性，但我发现需要为特定用例实现定制算法。

例如，创建具有余弦相似度的姿态匹配算法，或者有效地遍历作为机器学习模型的输出而获得的数据结构。

为了确保我对各种算法有足够的了解，以至于危险，我购买了圣杯。

《算法导论》教科书可能不是一个完全对初学者友好的算法世界介绍，在这种情况下，像 HackerRank 和 CodeWars 这样的平台是有益的。

2.技术书籍

从书本中学习确实让我感觉像回到了学校——没有被拘留，但是没有什么能比得上从写得很好的健壮的技术书籍中获得的知识。

在我职业生涯的早期，我一直认为我最终会停止观看 YouTube 教程和购买编码书籍，主要是因为我将获得‘忍者级’编码技能。

几年过去了，我已经意识到，无论你消费多少，关于编程语言，你总能学到更多。尽管我很喜欢通过 YouTube 编码教程学习，但是没有什么可以取代优秀的技术编码书籍中丰富而简明的知识。

以 Python 为例，它是数据科学家的标准编程语言。Python 是一种容易掌握的语言。经过几周对语法、数据结构和常用函数的学习，实现和运行定制 python 脚本变得很容易。你或许可以通过视频将 Python 学习到中级技能。

但是，Python 编程语言还有很多东西需要探索，可以提高您的编程技能。我发现更多关于 Python 语言的一种方式是通过技术书籍，更具体地说是 流利的 Python 。这本书对初学者来说并不友好，但它的目标读者是希望提高 Python 语言熟练程度的中级到专家程序员。

总之，技术书籍通过提供对编程语言的简单介绍，提高了数据科学家的编程技能。此外，通过对编程语言的深入探索，提升数据科学家的现有编程技能。

3.阅读其他开发人员的代码

照片由海拉戈斯蒂奇在 Unsplash 上拍摄

最近我尝试实现了 Inception Network，这是一个深度学习卷积神经网络。

虽然我有自己的方法来使用 Python 和 TensorFlow 库实现网络，但我很好奇其他 ML 从业者是如何实现网络的。

我的探索将我带到了几个 GitHub 库。我研究了其他开发人员的代码，不用说，我学习了改进我的实现方法的方法，并在我现有的编程技能基础上进行更广泛的开发。

有大量的公共 GitHub repos 可供探索和学习。你不必在谷歌或脸书这样的科技公司工作，也可以向他们的开发者学习。简单地探索由他们的工程师开发的项目的公共存储库。对于数据科学家来说，这可能意味着探索 repos，例如最近发布的 Detectron2 或其他开源机器学习工具。

在您的工作场所，在您的内部开发团队中进行代码评审是一种合适的学习方法。通过理解其他开发人员实现方法背后的推理和直觉，您间接地扩展了您的视野和编程知识。

4.学习其他编程语言

致力于编程语言的多样性是提高编程技能的可靠途径。程序员实现代码来解决问题，多种编程语言的知识扩展了解决问题的工具。

仅仅了解 Python 就可以帮助你学习数据科学的核心实践方面。也就是说，在专业/实践环境中，软件开发包含不同的平台，每个平台都有特定的语言用于访问和实现功能。

一个专业的 ML 从业者角色可能在下面显示的方法中利用不同的编程语言:

JavaScript 从互联网上抓取数据
SQL 修改和查询数据库
Python 实现算法和 ML 模型
Swift/Kotlin/Java 开发集成了 ML 模型的移动设备应用
还有很多。

一旦你已经精通了一门编程语言，学习一门新的编程语言就更容易了。如果你理解传统的软件开发范例，比如面向对象编程、函数式编程等等，那就更容易了。软件开发范例知识适用于各种编程语言。

5.遵守软件开发原则

阿尔瓦罗·雷耶斯在 Unsplash 上拍摄的照片

拥抱简单，避免重复，提高可读性。

这些是我在多年的编码工作中积累的经验。它们可能听起来很简单，但是这些原则是大多数开发人员所缺乏的，我有时会忘记坚持这些实践。

因此，在软件工程领域中，教授并实施了一些原则，以确保开发人员实践干净高效的软件开发。下面我列举了几个。

吻

在开发软件时，eepItSimpleStupid 加强了简单的概念。一个问题的解决方案不需要很复杂，在软件开发的设计和实现阶段采用简单性可以确保编写的代码容易理解和维护。

是的，炫耀可能很诱人，但为了可读性，保持简单— 你是 而不是机器人先生

固体

Solid 包含一组原则，旨在确保面向对象的开发人员构建可重用、可伸缩、可维护和高效的程序。要了解 SOLID 中所涵盖的原理的更多用法和实用性，请查看 Katerina Trajchevska 的视频。

单一责任原则
O 关笔原理
L 伊斯科夫替代原理
I 界面偏析原理
D 依赖反转原理

干燥的

DDtReY我们自己动手。这个原则非常自我描述。在实现程序时，编写执行现有功能的代码是对开发时间的低效利用。避免重复的一个好方法是利用项目文件夹中的实用程序文件。实用程序文件包含经常在源代码中执行的常见任务。

值得注意的提及

个人项目

承担一个个人项目向一些 ML 从业者介绍新的领域、库、平台、框架和编程语言。

使用个人项目来提高你的编程技能的主要好处在于可以接触到开发软件产品时遇到的不同问题。通过编程解决的每个问题都会增加您的总体技术经验。

教学

教育他人如何用你有经验的语言编写程序是一种行之有效的方法，可以提高你的编程技能，展示你的专业知识。

你可以用各种方式教学，或者通过 YouTube 视频，在线课程，或者我最喜欢的媒体文章。

结论

提升你的编程技能是一段没有目的地的旅程。编程总有你可以学习或改进的地方。

学会享受学习的过程。

有时事情确实变得棘手，StackOverflow 可能没有所有的答案，但请记住，每一次努力和每一分钟磨练你的手艺都会走向精通。

感谢阅读

要联系我或找到更多类似本文的内容，请执行以下操作:

订阅我的 邮箱列表 获取每周简讯
跟我上中
在LinkedIn和 Twitter 上连接并联系我

如何提高回归模型的准确性

原文：https://towardsdatascience.com/how-to-improve-the-accuracy-of-a-regression-model-3517accf8604?source=collection_archive---------0-----------------------

提高模型精度的提示和技巧

马克 A 在 Unsplash 上的照片

在这篇文章中，我们将看到如何处理回归问题，以及如何通过使用特征转换、特征工程、聚类、boosting 算法等概念来提高机器学习模型的准确性。

数据科学是一个迭代的过程，只有经过反复实验，我们才能获得满足我们需求的最佳模型/解决方案。

数据科学流程图-作者图片

让我们通过一个例子来关注上面的每个阶段。我有一个健康保险数据集 (CSV 文件)，里面有保险费用、年龄、性别、身体质量指数等客户信息。我们必须根据数据集中的这些参数来预测保险费用。这是一个回归问题，因为我们的目标变量——费用/保险成本——是数字。

让我们从加载数据集和探索属性(EDA 探索性数据分析)开始

#Load csv into a dataframe
df=pd.read_csv('insurance_data.csv')
df.head(3)#Get the number of rows and columns
print(f'Dataset size: {df.shape}')
**(1338,7)**

健康保险数据框架—作者图片

数据集有 1338 条记录和 6 个特征。吸烟者、性别和地区是分类变量，而年龄、身体质量指数和儿童是数字变量。

处理空值/缺失值

让我们检查数据集中缺失值的比例:

df.isnull().sum().sort_values(ascending=False)/df.shape[0]

列中空值的百分比-按作者排序的图像

年龄和身体质量指数有一些空值——尽管很少。我们将处理这些丢失的数据，然后开始我们的数据分析。Sklearn 的simple imputr允许您根据相应列中的平均值/中值/最频繁值替换缺失值。在这个例子中，我使用中间值来填充空值。

#Instantiate SimpleImputer 
si=SimpleImputer(missing_values = np.nan, strategy="median")
si.fit(df[[’age’, 'bmi’]])

#Filling missing data with median
df[[’age’, 'bmi’]] = si.transform(df[[’age’, 'bmi’]])

数据可视化

既然我们的数据是干净的，我们将通过可视化和地图来分析数据。一个简单的 seaborn pairplot 可以给我们很多见解！

sns.pairplot(data=df, diag_kind='kde')

Seaborn Pairplot —作者图片

我们看到了什么..？

收费和孩子是倾斜的。
年龄与电荷呈正相关。
身体质量指数服从正态分布！😎

Seaborn 的箱线图和计数图可用于显示分类变量对电荷的影响。

分类变量的 seaborn 计数图—作者图片

作者图片

基于上述图的观察结果:

男性和女性在数量上几乎相等，平均而言，男性和女性的平均收费也相同，但男性的收费范围更大。
吸烟者的保险费相对较高。
有两到三个孩子的人收费最高
客户几乎平均分布在四个地区，所有的都有几乎相同的费用。
女性吸烟者的百分比低于男性吸烟者的百分比。

因此，我们可以得出结论，“吸烟者”对保险费有相当大的影响，而性别的影响最小。

让我们创建一个热图来了解费用和数字特征(年龄、身体质量指数和儿童)之间的关联强度。

sns.heatmap(df[['age', 'bmi', 'children', 'charges']].corr(), cmap='Blues', annot=True)
plt.show()

如何提高 k-Means 聚类算法的解释性

原文：https://towardsdatascience.com/how-to-improve-the-interpretability-of-k-means-clustering-algorithm-3cf0fd0943ba?source=collection_archive---------48-----------------------

k-Means 和 k-Medoids 聚类的深度分析

Andri Klopfenstein 在 Unsplash 上拍摄的照片

C 聚类是一种无监督的机器学习技术，它将数据点分离或划分为几个聚类或组，使得同一聚类中的点彼此相似，而不同聚类中的点彼此不同。有各种聚类算法，例如:

k 均值聚类
基于密度的噪声应用空间聚类
等级聚类(聚集和分裂)
光学
模糊聚类

还有很多。k-Means 聚类是一种流行的无监督聚类算法。在本文中，您可以了解 k-Means 算法的数学背景，以及如何使用 k-Medoids 算法提高其可解释性。

k 均值聚类:

k 均值聚类是一种基于质心的聚类算法。它将数据点分组成 k 个簇，使得相同簇中的点彼此相似而不同簇中的点不同 t。形成的每个簇具有相等的数据点分布。每个聚类由其质心表示。

k 均值算法概述:

k-Means 聚类算法将整个数据集聚类成 k 个独立的聚类。k 均值算法的成本函数为:

K-Means 算法的思想是找到 K 个质心点(C1，C1，.。。C_k)通过最小化每个聚类上该点与其质心之间距离的平方和。

这个代价是 NP 难的，并且具有指数级的时间复杂度。所以我们采用劳埃德算法的近似思想，步骤如下:

1。k 个簇形心的初始化:

k 个聚类点被随机初始化。

2。分配:

对于每个数据点，计算这些点和每个聚类质心之间的欧几里德距离。这些点将被分配给质心最近的聚类。

3。质心更新:

通过取分配给该聚类的所有点的平均值来更新每个质心的值。

4。重复步骤 2 和 3，直到收敛:

收敛是指质心的值等于或几乎等于前一次迭代的质心点的值的情况。

k-均值聚类的一个问题是质心点的可解释性。最初，k 个质心中的每一个实际上是来自数据集的点，随着劳埃德算法的迭代，每个质心点的值被更新。质心点的这种更新导致可解释性的损失。

这里，k-Means 的一个更新算法来拯救，被称为 k-Medoids 算法。

k-Medoids 聚类:

k-均值聚类的问题是质心点的可解释性的损失。换句话说，质心点不是数据集中的实际点。k-Medoids 聚类的思想是使每个质心点成为数据集中的一个实际点。这将导致质心点可解释。

k-Medoids 算法的算法与 Lloyd 算法的算法几乎相同，只是在最后一步略有变化。k-Medoids 的算法称为 PAM(围绕 Medoids 划分)。

k-Medoids PAM 算法的步骤:

k 个聚类质心的初始化。
分作业。
更新质心:

在 Llyod 算法的情况下，通过计算该聚类中所有点的平均值来更新质心点。

对于 PAM 算法，质心点被更新为，如果在一个聚类中有 m 个点，则用来自该聚类的所有其他(m-1)个点交换先前的质心，并将该点最终确定为具有最小损失的新质心。PAM 算法的损失函数:

4。重复步骤 2 和 3，直到收敛。

(图片由作者提供)，数据集中的 k-Medoids 可解释聚类中心

(图片由作者提供)，聚类结果散点图

结论:

本文讨论了 k-Means 算法和 k-Medoids 算法的逐步工作算法。此外，如何通过使质心点成为实际数据点来增加 k-Means 算法的可解释性。

PAM 算法使用贪婪方法，可能无法找到全局最优解。与质心相比，Medoids 对异常值更加稳健，但是对于高维数据，它们需要更多的计算。

感谢您的阅读

如何提高(监督)机器学习算法的性能

原文：https://towardsdatascience.com/how-to-improve-the-performance-of-a-supervised-machine-learning-algorithm-c9f9f2705a5c?source=collection_archive---------43-----------------------

性能改进

提高机器学习模型性能的不同技术探讨

图片由来自 Pixabay 的 Jess Foami 提供

如今，每个数据科学家都能够编写代码来训练机器学习算法:加载一个数据集，将其分成训练集和测试集，建立模型并使用训练集训练它就足够了。最后，算法的性能可以在测试集上进行评估。

好吧。一切都显得很简单。但是，当您在实际情况中利用经过训练的模型时，可能会发生它无法正确预测输出的情况。

在本文中，我描述了如何通过以下技巧来提高监督机器学习算法的性能:

数据集的大小
特征选择
平衡数据集
模型的选择

数据集的大小

第一个技巧是增加数据集的大小。可能您的数据集太小，因此模型无法正确学习输出。在监督算法的情况下，您需要手动注释数据集。手工标注可能需要很多时间，所以你可以依赖一些外部平台，比如亚马逊机械土耳其人，相对便宜。

特征选择

构建模型时最重要的一个方面是特征选择，即哪些元素会影响输出。您可能有许多特征，但可能没有一个影响输出，因此您的算法性能很差。为了确定哪些特性会影响输出，您可以使用相关性特性选择方法，该方法计算每个特性与输出之间的相关性，并仅选择相关性大于某个阈值的特性。

下表显示了候选特征和输出(最后一列)之间的相关性示例。影响输出的唯一特征是 PROPN 和 previous ，阈值大于 0.5。因此，我们只能选择 PROPN 和 previous 作为输入特征。

作者图片

如果你想深化话题，可以阅读Vishal R的这篇有趣的文章。

选择输入特征的其他方法包括信息增益(IG)、卡方(CS)、最佳优先搜索(BFS)、线性向前选择(LFS)和贪婪逐步搜索。如果你想了解这些方法，请继续关注

平衡数据集

平衡数据集意味着所有输出类对应相同数量的输入记录。因此，如果我有 10.000 条输入记录和 2 个输出类，那么一个好的数据集应该有每个输出类 5.000 条输入记录。如果数据集不平衡，您需要平衡它。可以遵循两种可能的策略:

使用例如随机欠采样算法欠采样过估计的类输出；
对低估类输出进行过采样，生成例如合成数据(例如合成少数过采样技术算法)。

模型的选择

这听起来可能很明显，但有时改变模型可以极大地提高性能:)因此，您可以谷歌搜索哪个模型最适合您的目的。

摘要

在这篇文章中，我简要地说明了一些技巧，以提高监督机器学习模型的性能。如果你知道更多的方法和技巧，请给我留言或留言:)

分析技巧包括增加数据集的大小、特征选择、平衡数据集，以及最终选择模型。

在我的下一篇文章中，我将写一些关于如何用 Python 实现每个技巧的教程。敬请期待:)

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

如何用基函数和正则化改进线性回归

原文：https://towardsdatascience.com/how-to-improve-your-linear-regression-with-basis-functions-and-regularization-8a6fcebdc11c?source=collection_archive---------9-----------------------

基础函数和正则化介绍，理论和 Python 实现

对过度拟合的模型增加正则化的说明。图片作者。

内容

这篇文章是我将要发表的一系列文章的一部分。你可以通过点击这里在我的个人博客上阅读这篇文章的更详细版本。下面你可以看到该系列的概述。

1.机器学习导论

(一)什么是机器学习？
(b)机器学习中的模型选择
(c)维度的诅咒
(d)什么是贝叶斯推理？

2。回归

(a)线性回归的实际工作原理
(b)如何使用基函数和正则化改进您的线性回归

3.分类

(a)分类器概述
(b)二次判别分析(QDA)
(c)线性判别分析
(d)(高斯)朴素贝叶斯

基本函数

在之前的帖子中我们讨论了线性回归模型

我们说一个模型是线性的，如果它在参数中是线性的，而不是在输入变量中。然而， (1)在参数和输入变量中都是线性的，这限制了它适应非线性关系。我们可以通过用输入变量的非线性基函数代替输入变量来扩充模型

在哪里

通过使用非线性基函数， h 有可能适应 x 的非线性关系，我们将很快看到——我们称这些模型为线性基函数模型。

我们已经在系列文章的第一篇文章中看到了基函数的一个例子，其中我们用 x 的幂的基函数扩充了简单的线性回归模型，即，

另一种常见的基函数是高斯函数

遵循与上一篇文章中相同的推导，我们发现 w 和 α 的最大似然解为

在哪里

下图显示了具有 M -1 个高斯基函数的线性基函数模型。我们可以看到增加基函数的数量会产生更好的模型，直到我们开始过度拟合。

使用 m1 高斯基函数(加上截距)的效果图。图片作者。

履行

使用与前几篇文章相同的数据集，我们得到了下面的实现。

正规化

在关于贝叶斯推理的文章中，我们简要地讨论了正则化的概念，我们将其描述为一种防止过度拟合的技术。如果我们回头看看我们在上一篇文章中定义的目标函数(用基函数扩充)，我们可以引入一个正则项

其中 q > 0 表示正则化的类型， λ 控制正则化的程度。

q 最常见的值是 1 和 2，分别称为 L1 正则化和 L2 正则化。当我们使用 L1 正则化时，我们称之为套索回归，当我们使用 L2 正则化时，我们称之为岭回归。

岭回归的目标函数

特别方便，因为它是 w 的二次函数，因此具有唯一的全局最小值。其解决方案是

其中 α 保持不变，因为正则项对其没有影响。

当我们引入正则化时，模型选择的过程从找到合适数量的基函数到找到正则化参数λ的合适值。

下图显示了一个线性基函数模型，其中 λ 的值不同，而基函数的数量保持不变 M =8。我们可以看到即使我们开始时过度拟合，我们也可以调整正则化参数 λ 来防止它——事实上，当正则化过度时，我们开始欠拟合。另一件有趣的事情是，我们的不确定性随着正则化而增加。

对过度拟合的模型增加正则化的说明。图片作者。

履行

摘要

使模型线性的是它在参数而不是输入中是线性的。
我们可以用基函数增加线性回归，产生线性基函数模型。
多项式回归是线性基函数模型。
规则化是一种防止过拟合的技术。
在线性回归中有不同种类的正则化，如 L1 和 L2 正则化。

如何在 Python 笔记本中包含 R 和 ggplot

原文：https://towardsdatascience.com/how-to-include-r-and-ggplot-in-a-python-notebook-f2b76091353d?source=collection_archive---------25-----------------------

您可以在同一个 Jupyter 笔记本中混合使用匹配的 Python 和 R——方法如下

Python 笔记本中 R 的 ggplot2 中的图片-作者图片

你要么是 R 人，要么是 Python 人，对吧？当然，除非你喜欢 Python 的某些方面和 r 的其他方面。

那么为什么不混搭呢？例如，R 的 ggplot2 是一个很棒的可视化包，那么能够在 Python 程序中使用它不是很好吗？

我们将看看如何实现这一点——这很容易——然后你可以决定是否值得努力。

我将从 Python 用户的角度来处理这个问题，所以我假设您的计算机上已经安装了 Python 和 Jupyter。这意味着你还需要两样东西:R 和一个名为 rpy2 的 Python 包。需要安装 R，因为我们将运行 R 脚本(尽管是在 Python 上下文中),而 rpy2 是两种语言之间的桥梁。

所以，你可以去 R 网站下载你的操作系统版本，然后按照说明安装 R。

完成了吗？好了，接下来我们将打开 R 控制台，看起来像这样:

r 控制台—作者图片

我们将使用 ggplot2 可视化软件包，因此需要安装该软件包。在控制台中键入以下内容:

packages.install("tidyverse")

小包装包括 ggplot2 。(如果你想遵循这里的所有代码，你还需要安装软件包 ggalt 。)现在可以关闭 R 控制台了。

接下来，我们用 pip 安装 rpy2 包:

pip install rpy2

我们现在准备编写一个 Python Jupyter 笔记本，它可以运行用 r 编写的单元格。

%load_ext rpy2.ipython

这将加载 rpy2 包并启用 rmagic 命令(我们很快就会看到)。但是首先让我们导入熊猫并创建一个数据框架。

import pandas as pd

这是一个数据帧，代表了 2018 年伦敦记录的月气温。

w = {
  "Month":[1,2,3,4,5,6,7,8,9,10,11,12],
  "Tmax":[9.7,6.7,9.8,15.5,20.8,24.2,28.3,24.5,20.9,16.5,12.2,10.7],
  "Tmin":[3.8,0.6,3.0,7.9,9.8,13.1,16.4,14.5,11.0,8.5,5.8,5.2]
  }weather=pd.DataFrame(w)

这给了我们一个这样的数据框架:

天气数据框—图片由作者提供

现在我们将使用 r 中的 ggplot2 绘制一个图形。因此我们打开一个新的单元格，我们需要输入的第一行是这样的:

%%R -i weather -w 15 -h 10 --units cm

%%R将单元标识为 R 代码，随后是一些决定单元如何工作的参数。-i weather将之前创建的 Python 变量导入到 R 单元格、-w 15、-h 10、— units cm中，使创建的任意图形宽 15 厘米，高 10 厘米。

这是一个完整的单元格，包含了%%R魔法，导入了 ggplot2 库，然后从weather数据帧绘制了一个线图。

%%R -i weather -w 15 -h 10 --units cm 
# import df from Python and set figure size 15 by 10cmlibrary("ggplot2")ggplot(weather,aes(Month, Tmax)) + 
    geom_line() +
    ggtitle("Temperature")

简单线形图—作者提供的图片

默认图并不理想，因为 x 刻度实际上应该是从 1 到 12，它可以更漂亮一点。让我们解决这个问题。

%%R -i weather -w 15 -h 10 --units cm 
# import df from Python and set figure size 15 by 10cmlibrary("ggplot2")ggplot(weather) + 
    geom_line(aes(Month, Tmax),color="Red",size=1.25) +
    scale_x_continuous(breaks=seq(1, 12, 1))+
    scale_y_continuous(breaks=seq(-10, 40, 5))+
    labs(y="Temperature", x="Month", 
         title="London Monthly Temperatures 2018") +
    theme_light() +
    theme(panel.grid.minor=element_blank())

更好的线图—作者图片

在 R 的 ggplot2 中，我们可以看到一种简洁的方式，一层一层地构建图表。

但是如果我们想在同一个图表上绘制Tmax和Tmin呢？我们需要转换数据，以便两个值在同一列中。在 Python 中，我们可以通过打开一个新的单元格并输入以下 Python 代码来做到这一点。

weather2=pd.melt(weather, id_vars=['Month'], 
                 value_vars=['Tmax', 'Tmin'],var_name="Temp")

这创建了一个新的数据帧weather2,如下所示。

Weather2 数据框架—作者图片

我确信你也可以这样做，但是这里的想法是展示这两种语言是如何混合的。

现在我们可以用 ggplot2 绘制一个图表，通过创建一个像这样的新 R 单元格来绘制这两个值。

%%R -i weather2 -w 15 -h 10 --units cm 
# import df from Python and set figure size 15 by 10cmlibrary("ggplot2")ggplot(weather2,aes(Month, value)) + 
    geom_line(aes(color=Temp),size=1.25)+
    scale_x_continuous(breaks=seq(1, 12, 1))+
    scale_y_continuous(breaks=seq(-10, 40, 5))+
    labs(y="Temperature", x="Month", 
         title="London Monthly Temperatures 2018") +
    theme_light() +
    theme(panel.grid.minor=element_blank())

这给了我们下面的图表:

带有两个图的折线图—作者提供的图片

现在，在这一点上，你可能认为这一切都很好，但我可以用 Plotnine 做到这一点，而不会用一种新的语言搞乱我的 Python 笔记本。

from plotnine import *(ggplot(weather2,aes("Month", "value")) + 
    geom_line(aes(color="Temp"),size=1.25)+
    scale_x_continuous(breaks=range(1,13,1))+
    scale_y_continuous(breaks=range(-10, 40, 5))+
    labs(y="Temperature", x="Month", 
         title="London Monthly Temperatures 2018") +
    theme_light() +
    theme(panel_grid_minor=element_blank())
)

Plotnine plot —作者图片

当然，这是真的，你可以从上面的代码中看到。Plotnine 是一个很好的包，正如我在这里描述的一样，但它不是 ggplot 的完全克隆，因为它在它所基于的 Matplotlib 所能实现的方面受到限制。

例如，如果我想创建一个像这样的月温度的 dumbell 图会怎么样。

一个 dumbell 情节-作者的形象

这个简洁的图表显示了每个月的温度范围，当然，通过一点努力和独创性，我们可以在 Plotnine(或者，实际上，在 Matplotlib)中创建它。但也许这样更简单:

%%R -i weather -w 15 -h 10 --units cm 
# import df from Python and set figure size 15 by 10cmlibrary(ggplot2)
library(ggalt)ggplot(weather, aes(y=Month, x=Tmin, xend=Tmax)) +
  geom_dumbbell(size=1.25, color="Gray",
                colour_x = "Blue", 
                colour_xend = "Red",
                size_x=4,
                size_xend=4) +
  labs(x="Temperature", y="Month", 
       title="London Monthly Temperatures 2018") +
  scale_y_continuous(breaks=seq(1, 12, 1))+
  scale_x_continuous(breaks=seq(-10, 40, 5))+
  theme_light()

库 ggalt 用额外的绘图类型扩展了 ggplot2 ，这使得绘制 dumbell 图表非常简单。

除了%%R之外，还有一个神奇的命令%R，可以让你在一个 Python 单元格中使用单独的 R 代码行，但是，坦率地说，我认为混合不同语言的单元格会让笔记本变得很乱，所以我就讲到这里。

所以，R 和 Python 在同一个笔记本里——好主意？嗯，也许吧。我喜欢我可以直接使用 ggplot2 ，但是我也喜欢 Plotnine，它允许我专门使用 Python。

关于 rpy2 的内容比我在这里介绍的还要多。更多详情请看他们的网站。

一如既往，感谢阅读。如果你想知道我什么时候发表新文章，请考虑在这里注册一个电子邮件提醒。

如果你不是一个媒体订阅者，那就注册吧，这样你就可以每月花 5 美元阅读尽可能多的文章。在这里注册,我会赚一点佣金。

如何将 Python 图形插入 HTML 网站

原文：https://towardsdatascience.com/how-to-insert-a-python-graph-into-an-html-web-site-688754f67e1c?source=collection_archive---------1-----------------------

数据可视化

将 Altair 或 Plot.ly 中构建的图形与 HTML 网站集成的简短教程

图片来自 Pixabay

正如许多人所知，Python 是一种非常强大的数据操作语言，包括数据收集、数据分析和数据可视化。关于这最后一个方面，存在许多强大的库和框架，如 Plot.ly 图形库和 Altair 。

Plot.ly 图形库是一个非常强大的库，它允许用 Python、R 和 Javascript 构建图形和地图。Altair 是 Python 的另一个声明性统计可视化库，基于 Vega 和 Vega-lite 。

在本教程中，我假设您已经知道如何使用 Plot.ly 或 Altair 构建图形。我将只说明如何将一个现有的图形与一个 HTML 网站集成。

将 Python 图形集成到 HTML 网站需要三个步骤:

在 Plot.ly 或 Altair 中生成图形
将图表保存为 HTML 页面
操作生成的 HTML

Plot.ly

首先，我在 Plot.ly 中构建了一个通用图。在这个具体的例子中，我将关于意大利新冠肺炎阳性病例数的时间序列作为输入数据。我利用以下 Python 代码绘制了一条线:

import plotly
import plotly.graph_objs as go
import pandas as pddf = pd.read_csv('[https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-andamento-nazionale/dpc-covid19-ita-andamento-nazionale.csv'](https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-andamento-nazionale/dpc-covid19-ita-andamento-nazionale.csv'))# Create a trace
data = [go.Scatter(
    x = df['data'],
    y = df['totale_positivi'],
)]layout = go.Layout(
        xaxis=dict(
            title='Data',    
        ),
        yaxis=dict(
            title='Totale positivi',  
        )
    )
fig = go.Figure(data=data, layout=layout)

下图显示了生成的输出:

作者图片

现在，我可以将该图保存为 HTML 文件。我利用了plotly.offline.plot()函数。作为一个配置参数，我指定在绘图中不显示模式栏(config={‘displayModeBar’: False})。这是为了避免让用户操纵 HTML 页面中的图像。

plotly.offline.plot(fig,filename='positives.html',config={'displayModeBar': False})

现在我可以打开文件positives.html并操作它。该文件类似于下面这段代码:

<html>
  <head><meta charset="utf-8" /></head>
  <body>
    <div>
        <script type="text/javascript">window.PlotlyConfig =  
             {MathJaxConfig: 'local'};
        </script> <script type="text/javascript">
          ...
        </script> <div id="9eec8ee0-8ebf-4199-8f61-7f86aab4cc81" class="plotly-graph-div" style="height:100%; width:100%;"></div> <script type="text/javascript"> 
          ... 
        </script> </div>
  </body>
</html>

该文件由 4 个主要部分组成。第二部分很长。第二部分和第四部分可以复制到两个不同的 javascript 文件中，没有开始和结束标记(<script type=”text/javascript”>和</script>)，命名为chart-part1.js和chart-part2.js。现在，我可以用包含的两个 javascript 文件替换 HTML 文件的第二和第四部分:

<html>
<head><meta charset="utf-8" /></head>
<body>
    <div>
        <script type="text/javascript">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>
        <script src="js/chart-part1.js"></script>

        <div id="9eec8ee0-8ebf-4199-8f61-7f86aab4cc81" class="plotly-graph-div" style="height:100%; width:100%;"></div>
        <script src="js/chart-part2.js"></script>   
    </div>
</body>
</html>

注意，我已经将chart-part1.js和chart-part2.js文件保存到了js文件夹中。现在，我可以将包含在div中的所有代码复制到我的 HTML Web 站点中的任何地方，只要我提醒也将js文件夹复制到我的 Web 站点文件夹中:

<div>
    <script type="text/javascript">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>
    <script src="js/chart-part1.js"></script>

    <div id="9eec8ee0-8ebf-4199-8f61-7f86aab4cc81" class="plotly-graph-div" style="height:100%; width:100%;"></div>
    <script src="js/chart-part2.js"></script>   
</div>

阿尔泰尔

在这个例子中，我使用默认的 vega 数据集构建了一个简单的散点图，包含在vega_datasets库中。

import altair as alt
from vega_datasets import datachart = alt.Chart(data.cars.url).mark_point().encode(
    x='Horsepower:Q',
    y='Miles_per_Gallon:Q',
    color='Origin:N'
)

现在我可以通过save()功能保存图表:

chart.save('chart.html', embed_options={'actions': False})

在embed_options中，我指定我不想打印动作按钮。或者，正如@ 阿兰·琼斯所建议的，我可以在我的 Plotly 配置中设置staticPlot = True而不是隐藏工具栏(这实际上并不会停止交互)。静态图不是交互式的，也没有工具栏。

生成的 HTML 文件如下所示:

<!DOCTYPE html>
<html>
<head>
  <style>
    .error {
        color: red;
    }
  </style>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega@5](https://cdn.jsdelivr.net/npm//vega@5)"></script>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega-lite@4.8.1](https://cdn.jsdelivr.net/npm//vega-lite@4.8.1)"></script>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega-embed@6](https://cdn.jsdelivr.net/npm//vega-embed@6)"></script>
</head>
<body>
  <div id="vis"></div>
  <script>
    (function(vegaEmbed) {
      var spec = {"config": {"view": {"continuousWidth": 400, "continuousHeight": 300}}, "data": {"url": "[https://cdn.jsdelivr.net/npm/vega-datasets@v1.29.0/data/cars.json](https://cdn.jsdelivr.net/npm/vega-datasets@v1.29.0/data/cars.json)"}, "mark": "point", "encoding": {"color": {"type": "nominal", "field": "Origin"}, "x": {"type": "quantitative", "field": "Horsepower"}, "y": {"type": "quantitative", "field": "Miles_per_Gallon"}}, "$schema": "[https://vega.github.io/schema/vega-lite/v4.8.1.json](https://vega.github.io/schema/vega-lite/v4.8.1.json)"};
      var embedOpt = {"actions": false, "mode": "vega-lite"};function showError(el, error){
          el.innerHTML = ('<div class="error" style="color:red;">'
                          + '<p>JavaScript Error: ' + error.message + '</p>'
                          + "<p>This usually means there's a typo in your chart specification. "
                          + "See the javascript console for the full traceback.</p>"
                          + '</div>');
          throw error;
      }
      const el = document.getElementById('vis');
      vegaEmbed("#vis", spec, embedOpt)
        .catch(error => showError(el, error));
    })(vegaEmbed);</script>
</body>
</html>

我将包含在<script>标签中的代码复制到一个名为chart.js的 javascript 文件中。如果我想将图表包含到 HTML 网页中，我必须将以下部分放在我的 HTML 网页中的任意位置:

<div id="vis"></div>
  <script src="js/chart.js"></script>

我还应该提醒在我的 HTML 页面的头部包含vega、vega-lite和vega-embed javascript 文件。最终结果如下所示:

<!DOCTYPE html>
<html>
<head>
  <style>
    .error {
        color: red;
    }
  </style>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega@5](https://cdn.jsdelivr.net/npm//vega@5)"></script>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega-lite@4.8.1](https://cdn.jsdelivr.net/npm//vega-lite@4.8.1)"></script>
  <script type="text/javascript" src="[https://cdn.jsdelivr.net/npm//vega-embed@6](https://cdn.jsdelivr.net/npm//vega-embed@6)"></script>
</head>
<body>
  <div id="vis"></div>
  <script src="js/chart.js"></script>
</body>
</html>

摘要

在这篇简短的教程中，我演示了如何将 Plot.ly 或 Altair Python graph 包含到 HTML 网站中。

需要三个步骤:生成图形，将其保存为 HTML，并处理输出，使代码易于包含在另一个 HTML 页面上。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

https://codeburst.io/quick-start-with-html-through-bootstrap-bbe6f2f1793 [## 如何改进带注释的 D3.js 图形

towardsdatascience.com](/how-to-improve-d3-js-graphs-with-annotations-252fbb9c5bb5)

如何将 Observablehq 图形插入 HTML 页面

原文：https://towardsdatascience.com/how-to-insert-an-observablehq-graph-into-a-html-page-57a9f4546ecf?source=collection_archive---------23-----------------------

数据可视化

一个快速的教程，用你的可观察图形制作精彩的 HTML 页面。

作者图片

Observablehq 是一个非常流行的利用 D3.js 库编写代码的笔记本。由于网上有很多例子和教程，你可以根据自己的需要定制已经制作好的笔记本。

然而，一旦构建了一个图表，就不容易立即嵌入到另一个网站中。

在本教程中，我提出了两种在网站中嵌入图形的策略:

通过 iframe
生成图表的 Javascript。

在这两种情况下，首先，您必须通过点击发布按钮来发布您的笔记本。

此外，在这两种情况下，您都应该遵循以下步骤:

从 Observable 下载嵌入代码
将代码插入 HTML 页面。

在本教程中，我使用了链接中的示例图。

内联框架

第一个解决方案非常简单，也适用于其他网站。它基于 iframes 的使用。实际上，iframe 是一个嵌入在另一个 HTML 文档中的 HTML 文档。

下载嵌入代码

为了下载嵌入代码，您必须在 Observable notebook 中查看您的图表，并单击图表左侧的三个垂直点，如下图所示:

作者图片

将打开一个菜单，如下所示:

作者图片

您可以选择嵌入，然后从下拉菜单中选择 iframe:

图像

然后你可以点击复制按钮。现在代码被复制到你的剪贴板中。复制的代码如下所示:

<iframe width="100%" height="584" frameborder="0"
  src="[https://observablehq.com/embed/@alod83/italian-covid-19-positives?cells=chart](https://observablehq.com/embed/@alod83/italian-covid-19-positives?cells=chart)"></iframe>

将您的代码插入 HTML 页面

现在，您可以将复制的代码插入到您的 HTML 页面中，准确地插入到您希望图形显示的位置。

例如，您可以在段落后插入:

<html>
  <head>...</head>
  <body>
      <p>Before my graph</p>
      <iframe width="100%" height="584" frameborder="0"
  src="[https://observablehq.com/embed/@alod83/italian-covid-19-positives?cells=chart](https://observablehq.com/embed/@alod83/italian-covid-19-positives?cells=chart)"></iframe>
  </body>
</html>

利弊

使用这种技术的主要优点是非常快和快。

但是，iframe 不继承父文档属性，如字体。此外，通常 iframe 没有响应性，因为它不能适应小型设备屏幕，如智能手机和平板电脑。

下载 Javascript

将可观察图形嵌入 HTML 页面的另一个策略是下载生成它的完整 javascript。

下载嵌入代码

这一步与下载 iframe 代码的步骤非常相似:

单击图表左侧的三个垂直点
选择嵌入

唯一的区别是，当您必须从下拉菜单中选择代码类型时，您必须选择带有 Javascript 的运行时:

作者图片

然后你点击复制。您复制的代码可能很长，因此您应该传递到一个空文档中，并将其命名为graph.js。在我的例子中，生成的代码不是很长，如下所示:

<div id="observablehq-chart-0a7b99e8"></div>
<p>Credit: <a href="[https://observablehq.com/@alod83/italian-covid-19-positives](https://observablehq.com/@alod83/italian-covid-19-positives)">Italian COVID-19 positives by Angelica Lo Duca</a></p><script type="module">
import {Runtime, Inspector} from "[https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js](https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js)";
import define from "[https://api.observablehq.com/@alod83/italian-covid-19-positives.js?v=3](https://api.observablehq.com/@alod83/italian-covid-19-positives.js?v=3)";
new Runtime().module(define, name => {
  if (name === "chart") return new Inspector(document.querySelector("#observablehq-chart-0a7b99e8"));
});
</script>

你可以看到在代码的开头有一个div，然后是一个有演职员表的段落，最后是以<script>开头的 javascript。这最后一部分可能会很长。

将您的代码插入 HTML 页面

div将包含您的图表，因此您可以将它准确地复制到您希望它出现在 html 中的位置。div应该如下图所示:

<div id="observablehq-chart-0a7b99e8"></div>

例如，您可以在一个段落后复制:

<html>
  <head>...</head>
  <body>
      <p>Before my graph</p>
      <div id="observablehq-chart-0a7b99e8"></div>
  </body>
</html>

现在您可以清理文档chart.js，以便只包含 javascript 代码。您可以删除演职员表和script标签。

最终的chart.js应该如下所示:

import {Runtime, Inspector} from "[https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js](https://cdn.jsdelivr.net/npm/@observablehq/runtime@4/dist/runtime.js)";
import define from "[https://api.observablehq.com/@alod83/italian-covid-19-positives.js?v=3](https://api.observablehq.com/@alod83/italian-covid-19-positives.js?v=3)";
new Runtime().module(define, name => {
  if (name === "chart") return new Inspector(document.querySelector("#observablehq-chart-0a7b99e8"));
});

最后一步是将生成的 javascript 文件包含到原始 HTML 页面中，紧跟在包含图表的div之后:

<html>
  <head>...</head>
  <body>
      <p>Before my graph</p>
      <div id="observablehq-chart-0a7b99e8"></div>
      **<script src='chart.js'></script>**
  </body>
</html>

您可以保存 HTML 页面，现在图表已经嵌入到您的 HTML 页面中了！

利弊

这个解决方案应该具有响应性，并继承父文档的所有布局。但是，它的实现比前一个更复杂。

摘要

在本文中，我描述了两种将 Observable 生成的图形插入 HTML 页面的策略:

内联框架
java 描述语言

事实上，Observable 还提供了另一种策略， Runtime with React，我在本文中没有涉及到。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

[## 如何改进带注释的 D3.js 图形

towardsdatascience.com](/how-to-improve-d3-js-graphs-with-annotations-252fbb9c5bb5)

如何使用 Docker 安装 Apache Kafka 简单的方法

原文：https://towardsdatascience.com/how-to-install-apache-kafka-using-docker-the-easy-way-4ceb00817d8b?source=collection_archive---------0-----------------------

以及如何创建你的第一个卡夫卡主题。提供视频指南。

在 Unsplash 上拍摄的 ThisisEngineering RAEng

在大数据的世界里，可靠的流媒体平台是必不可少的。这就是卡夫卡出现的地方。今天，你将学习如何在你的机器上安装它，并创建你的第一个 Kafka 主题。

想袖手旁观吗？我掩护你:

今天的文章涵盖以下主题:

安装卡夫卡的方法
术语纲要—您需要知道的一切
使用 Docker 安装 Kafka
连接到 Kafka shell
创建你的第一个卡夫卡主题
将 Visual Studio 代码连接到 Kafka 容器
总结和后续步骤

安装卡夫卡的方法

您可以在任何操作系统上安装 Kafka，如 Windows、Mac 或 Linux，但每个操作系统的安装过程都有所不同。因此，我的目标不是涵盖所有的内容，而是在虚拟机中安装 Kafka，并使用 Linux Ubuntu 作为发行版。

但是，由于我用的是装有 M1 芯片的 MacBook，管理虚拟机并不那么容易。将 ISO 映像附加到 VirtualBox 会失败。如果有人知道解决方法，请在下面的评论区告诉我。

因此，您将使用 Docker。我认为这是一个更好的选择，因为你不必手动安装工具。相反，您将编写一个简单的 Docker compose 文件，它将处理所有的事情。最棒的是，它可以在任何操作系统上运行。因此，如果您在 Windows 或 Linux 上阅读本文，一切都将正常工作。你只需要安装 Docker 和 Docker compose。

如果您需要安装 Docker 的说明，请参考视频。

术语纲要—您需要知道的一切

这篇文章绝不是多克尔或卡夫卡的详尽指南。见鬼，这甚至不应该是你关于这些话题的第一篇文章。本节的其余部分将只给出高层次的定义和概述。关于这些概念的更多内容已经超出了本文的范围。

卡夫卡——基本上是一个事件流平台。它使用户能够收集、存储和处理数据，以构建实时事件驱动的应用程序。它是用 Java 和 Scala 编写的，但你不必知道这些来与 Kafka 一起工作。还有一个 Python API。

Kafka broker —单个 Kafka 集群由经纪人组成。它们处理生产者和消费者，并在集群中保持数据复制。

卡夫卡专题 —记录发布的类别。假设你有一个大型新闻网站——每个新闻类别都可以是一个卡夫卡主题。

Kafka producer —你写的一个应用程序(一段代码)来获取数据给 Kafka。

Kafka consumer——你写的一个从 Kafka 获取数据的程序。有时，消费者也是生产者，因为它将数据放在卡夫卡的其他地方。

Zookeeper —用于管理 Kafka 集群，跟踪节点状态，维护主题和消息列表。Kafka 版本 2.8.0 引入了对没有 Zookeeper 的 Kafka 版本的早期访问，但它还没有为生产环境做好准备。

Docker —一个用于构建、部署和管理容器的开源平台。它允许您将应用程序打包到容器中，这简化了应用程序的分发。这样，您知道如果应用程序在您的机器上工作，它将在您部署它的任何机器上工作。

你现在对卡夫卡、动物园管理员和 Docker 中的概念有了一些基本的高层次理解。下一步是使用 Docker 安装 Zookeeper 和 Kafka。

使用 Docker 安装 Kafka

您将需要两个 Docker 映像来运行 Kafka:

wurstmeister/动物园管理员
伍斯特梅斯特/卡夫卡

你不必手动下载它们，因为docker-compose.yml会为你做的。下面是代码，所以你可以把它复制到你的机器上:

version: '3'

services:
  zookeeper:
    image: wurstmeister/zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
  kafka:
    image: wurstmeister/kafka
    container_name: kafka
    ports:
      - "9092:9092"
    environment:
      KAFKA_ADVERTISED_HOST_NAME: localhost
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181

如果 2181 或 9092 在您的机器上不可用，请确保编辑端口。现在，您可以打开终端并导航到保存docker-compose.yml文件的文件夹。执行以下命令来提取图像并创建容器:

docker-compose -f docker-compose.yml up -d

-d意味着 Zookeeper 和 Kafka 都将在后台运行，所以它们启动后你就可以访问终端了。

现在，您应该看到下载和配置过程打印到了终端上。我的看起来是这样的，但是请记住，我已经配置了这两个:

图 1——Docker 为动物园管理员和卡夫卡创作(图片由作者提供)

就是这样！您可以使用docker ps命令来验证两者都在运行:

图 2 — Docker PS 命令(图片由作者提供)

但是你现在能用这两个容器做什么呢？让我们接下来讨论这个问题，打开一个卡夫卡终端，创建你的第一个卡夫卡主题。

连接到 Kafka shell

Zookeeper 和 Kafka 容器运行后，您可以执行以下终端命令来启动 Kafka shell:

docker exec -it kafka /bin/sh

如果你已经决定在docker-compose.yml文件中用不同的名字命名它，只需用container_name的值替换kafka。

以下是您应该看到的内容:

图 3 —连接到 Kafka shell(图片由作者提供)

现在你已经拥有了创建你的第一个卡夫卡主题所需要的一切！

创建你的第一个卡夫卡主题

所有 Kafka shell 脚本都位于/opt/kafka_<version>/bin:

图 4 —所有 Kafka shell 脚本(图片由作者提供)

下面是创建 Kafka 主题必须发出的命令:

kafka-topics.sh --create --zookeeper zookeeper:2181 --replication-factor 1 --partitions 1 --topic first_kafka_topic

其中first_kafka_topic是您的主题名称。因为这是一个虚拟环境，你可以保持replication-factor和partitions为 1。

下面是您应该看到的输出:

图 5——创造一个卡夫卡主题(作者图片)

就是这样！大约一秒钟后，主题将被创建。您可以使用以下命令列出所有 Kafka 主题:

kafka-topics.sh --list --zookeeper zookeeper:2181

这是它在我的机器上打印的内容:

图 6 —列出卡夫卡主题(作者图片)

这就是你如何创造一个卡夫卡式的话题。你今天不会用它做任何事。下一篇文章将介绍如何用 Python 编写生产者和消费者，但是今天还有其他内容要介绍。

将 Visual Studio 代码连接到 Kafka 容器

不，你今天不会写生产者和消费者，但是你会在下面的文章中写。手动将 Python 文件从您的机器传输到 Docker 容器是非常繁琐的。可以用 Visual Studio 代码直接在 Kafka 容器上写代码。

你需要一个微软官方的 Docker 扩展，所以如果你还没有的话就安装它:

图 7 —安装 VSCode Docker 扩展(图片由作者提供)

安装完成后，点击左侧工具条中的 Docker 图标。您会看到所有正在运行的容器都列在顶部:

图 8-列出 Docker 容器(作者图片)

您可以通过右键单击该容器并选择附加 Visual Studio 代码选项，将 Visual Studio 代码附加到该容器中。它将打开一个新窗口，并询问您打开哪个文件夹。

转到根目录 (/)，您应该会看到几分钟前您在 shell 中看到的所有文件夹:

图 9 —通过 VSCode 探索 Kafka 容器(图片由作者提供)

简单，对吧？嗯，的确如此，而且在编写消费者和生产者代码时，这会节省你很多时间。

总结和后续步骤

今天到此为止。您从安装 Docker、Kafka 和 Zookeeper 到创建您的第一个 Kafka 主题并通过 Shell 和 Visual Studio 代码连接到 Docker 容器。

如果您需要通过 Visual Studio 代码安装 Docker 和附加 Kafka shell 的详细说明，请参考视频。

下一篇文章将涉及 Python 中的消费者和生产者，如果你想了解更多关于卡夫卡的知识，请继续关注。

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

https://medium.com/@radecicdario/membership

保持联系

在媒体上关注我，了解更多类似的故事
注册我的简讯
在 LinkedIn 上连接

原载于 2021 年 9 月 23 日 https://betterdatascience.comhttps://betterdatascience.com/how-to-install-apache-kafka-using-docker-the-easy-way/。

如何在 R Google Colab 中安装包

原文：https://towardsdatascience.com/how-to-install-packages-in-r-google-colab-423e8928cd2e?source=collection_archive---------8-----------------------

GOOGLE COLAB | RSTATS |笔记本

一些限制以及如何克服其中一些限制

照片由埃弗顿维拉在 Unsplash 上拍摄

在我之前的文章中，我已经尝试解释过如何在 Google Colab 中运行 R。简而言之，有两种方式，第一种是使用rpy2在同一个运行时同时使用 R 和 Python，第二种是原生运行 R。

但是，运行 R notebook 时有几个限制。

第一个限制与运行时使用的 R 版本有关。要检查 R 在运行时运行的是什么版本，可以键入:version。这里我指的限制是我们不能选择运行哪个版本的 R。在这篇文章发表之前，Colab notebook 使用的 R 版本是:

platform       x86_64-pc-linux-gnu         
arch           x86_64                      
os             linux-gnu                   
system         x86_64, linux-gnu           
status                                     
major          4                           
minor          0.4                         
year           2021                        
month          02                          
day            15                          
svn rev        80002                       
language       R                           
version.string R version 4.0.4 (2021-02-15)
nickname       Lost Library Book

这不同于 Python 运行时。你可以选择使用 Python 2 或 Python 3，尽管 Google 目前正试图在 Colab 上停止对 Python 2 的支持。Python 2 的弃用声明可以在 Google Colab FAQ 页面上获得。下面是它的内容:

**Does Colab support Python 2?**The Python development team has declared that Python 2 will no longer be supported after [January 1st, 2020](https://www.python.org/dev/peps/pep-0373/#maintenance-releases).  Colab has stopped updating Python 2 runtimes, and is gradually phasing  out support for Python 2 notebooks. We suggest migrating important  notebooks to Python 3.

但是，我们仍然可以通过此链接https://colab.to/py2.访问它

原生运行 R 的第二个限制与 Google Drive 有关。如果我们在 Colab 中本地使用 R，则不直接支持从 Google Drive 装载和获取数据并将其转换为 dataframe。在我的上一篇文章中，我还提供了一种从 Google Drive 或 BigQuery 检索数据的方法。

现在，假设您已经在 Colab 上成功地运行了 R。那那里有什么库或者包？如何安装一个我们需要的，但是默认不可用的包？有哪些选择？

在这篇文章中，我将尝试打破这一点。

Google Colab R 默认安装了哪些包？

要获得已安装库的列表，可以运行以下代码:

str(allPackage <- installed.packages())
allPackage [, c(1,3:5)]

上面的代码将生成如下表格:

结果表。图片作者。

或者，您也可以运行来显示一个帮助窗口，其中包含有关在 R 运行时安装了哪些软件包的信息:

library()

library():帮助结果。图片作者。

从这里我们知道有一些常用的软件包，比如说，dplyr、broom、surival都是默认安装的。

如何在 R Google Colab 中安装包？

要安装默认情况下不可用的包，我们可以像往常一样使用install.packages()函数。

但是有些时候我们会发现 CRAN 中没有的包，所以我们可能需要通过 Github 来安装。或者当 CRAN 中还没有更新版本的包时。在这种情况下，我们可以使用devtools::install_github (“DeveloperName/PackageName”)功能。

例如，让我们尝试安装“rsvg”包，它是将 svg 图像渲染为 PDF、PNG、PostScript 或位图数组所必需的。

我们将在运行时运行install.packages(“rsvg”)代码。稍等片刻，将出现一条错误消息:

Installing package into ‘/usr/local/lib/R/site-library’
(as ‘lib’ is unspecified)

Warning message in install.packages("rsvg"):
“installation of package ‘rsvg’ had non-zero exit status”

我认为这是在 Google Colab 中使用 R 的第三个限制。

显示的消息(错误或警告)不如我们使用 RStudio 时完整。

non-zero exit status表示这个包没有成功安装在我们的系统或运行时上，它没有说明原因。

这种不完整在某些方面对我们来说有点麻烦，因为信息不清晰。我们必须在搜索引擎中找到它的原因。

在示例中使用的rsvg包的情况下，问题在于存在一个系统依赖项，这个系统依赖项是需要的，但在我们使用的系统中并不存在。R 包通常依赖于系统库或 R 外部的其他软件。

如何在 R Google Colab 中安装系统库？

在 R 运行时与操作系统(Ubuntu 终端)的交互可以通过使用system()函数来完成。

继续上面关于rsvg包的例子，结果是这个包需要在我们的系统上安装librsvg2-dev。要安装它，我们需要运行如下代码:

system('sudo apt-get install -y librsvg2-dev', intern=TRUE)

或者，我们可以使用cat()来获得相对更漂亮的结果:

cat(system('sudo apt-get install -y librsvg2-dev', intern=TRUE), sep = "\n")

其他一些 R 包可能有不同的依赖关系。你可以用和上面一样的方法安装它。您可能需要的其他一些库是libcurl4-openssl-dev, libgsl0ldbl, gsl-bin, libgsl0-dev, g++, gcc, gfortran-8。

结束语

可以在 Google Colab 上运行 R 是一件值得庆祝的事情，尽管有一些限制。Google Colab 提供的软件包可能足以完成我们处理数据的部分工作。这篇文章，以及上一篇文章，仅仅是如何绕过 R Google Colab 中存在的限制的例子。最后，希望这篇文章对有需要的人有用。

如何在 Android 设备上安装 Python 和 Jupyter Notebook

原文：https://towardsdatascience.com/how-to-install-python-and-jupyter-notebook-onto-an-android-device-900009df743f?source=collection_archive---------1-----------------------

环境设置

当您排队等候或在旅途中时，提高您的工作效率。

图片来自 Pixabay 的像素

由于移动技术的普及，我们几乎一天中的所有时间都在网上:开车或坐火车旅行时，准备晚餐时，甚至外出散步时。

对于像我一样，总是活跃和一心多用的人来说，可能会发生这样的情况，当她坐在电脑前时，她必须放下手头的工作去做别的事情。这意味着 PC 上的前一个任务被延迟。

我已经找到了这个问题的部分解决方案:为什么不继续在手机(或平板电脑)上完成任务，同时做其他事情呢？

由于我的主要工作是通过 Jupyter 笔记本处理 Python 中的编码，在这篇文章中，我将解释如何在 Android 上安装这两个组件。这个任务非常简单，因为 Android 是一个基于 unix 的操作系统。

1.获得 Python 3

首先，手机/平板上必须安装 Python。Google Play 上有很多应用。我建议为 Python 3 安装 Pydroid 3 — IDE。

作者图片

安装过程非常简单:访问 Google Play ，搜索应用，点击安装按钮即可。

2.运行 Pydroid 3

现在应用程序已经安装好了，我们可以运行它了。第一次启动应用程序时，会下载并安装 Python。之后，我们可以选择左上角的按钮打开一个菜单，选择 Pip ，如下图所示:

作者图片

一旦点击 Pip 按钮，搜索框就会打开。我们可以键入 jupyter 并检查设置:使用预构建的库储存库。我们点击安装，出现以下警告:

我们可以点击获取插件。Google Play 应用程序打开，要求安装 Pydroid 存储库插件。

作者图片

我们点击安装，然后等待完成。现在我们回到 Pydroid 应用程序和 jupyter 的 Pip 安装。

一旦安装完成，我们就可以运行 jupyter 笔记本了。

3.运行 Jupyter 笔记本

我们回到 Pydroid 主页，从主菜单中选择终端。

作者图片

终端打开，我们可以编写命令jupyter notebook。最终笔记本启动，应用程序询问我们是要在浏览器中还是在 Pydroid 应用程序中打开它。

4.将笔记本保存在共享驱动器上

最后一步是储存。为了让我们的笔记本在不同设备之间保持同步，我们应该在它们之间安装一个共享驱动器。一个可能的解决方案是使用 Dropbox 或 Google Drive 。在这篇文章中，我们描述了如何配置 Dropbox，它在免费版本中提供 2 GB 的空间。首先，我从这个链接下载桌面 Dropbox 应用程序，然后我们把它安装在电脑上。然后我们从 Google Play 下载智能手机上的相同应用。

一旦安装到两台设备上，我们就可以同步它们。例如，我们可以从终端访问电脑上的 dropbox 文件夹，然后运行 Jupyter 笔记本。我们可以创建以下 hello world 笔记本，并将其命名为 Test.ipynb 。

print('Hello world!)

然后我们必须从智能手机访问 Test.ipynb 。我们从智能手机上运行 Dropbox，等待同步。然后，我们按住 Test.ipynb，访问右上角的菜单，单击“Save”。我们选择文件系统上的位置。

现在，我们可以通过 Pydroid 从智能手机运行 Jupyter 笔记本，并从 Jupyter 文件管理器访问包含 Test.ipynb 的文件夹。瞧啊。我们可以从智能手机继续我们的笔记本！请注意，我们的编辑不会在 dropbox 上自动同步。因此，一旦完成代码，我们需要从智能手机文件系统访问上一个文件夹，并与 dropbox 共享它。

摘要

在本文中，我展示了如何在基于 Android 的手机上安装和配置 Python 和 Jupyter。然后，我举例说明了如何同步计算机和智能手机，以便处理同一段代码。

所提出的机制的替代解决方案可以是完全在线执行 Python。例如，这可以通过 Google Colab 来实现。不过这个留作以后的帖子:)

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

我最新的文章

如何在 MacBook Pro M1 Pro 上轻松安装 TensorFlow 2.7

原文：https://towardsdatascience.com/how-to-install-tensorflow-2-7-on-macbook-pro-m1-pro-with-ease-744bfa978fe8?source=collection_archive---------10-----------------------

在苹果新推出的 M1 Pro 和 M1 Max 芯片上安装并测试 tensor flow 2.7

由 Anthony Choren 在 Unsplash 上拍摄的照片

早在 2020 年，苹果的 M1 芯片就彻底改变了这个行业。新的 M1 Pro 和 M1 Max 是专业用户一直在等待的。苹果向内容创作者推销这些，但请放心，作为一名数据科学家，你可以压榨的性能值得一谈。

我起初有点怀疑，决定不买新的笔记本电脑，但在商店里看到 16 英寸后，我忍不住了。照相机确实增加了 10 磅。新 M1 Pro 和 M1 Max macbook 在现实生活中看起来并不笨重。

总之，我选择了“基础”型号 16“M1 Pro Macbook Pro，配有 10 核 CPU、16 核 GPU 和 16 GB 内存。它用我去年的 M1 Macbook Pro 擦地板，在一些测试中接近我用 RTX 3060Ti 定制的配置。敬请关注博客，了解即将到来的数据科学基准测试和比较。

今天我将向大家展示如何在 MacBook Pro M1 Pro 上安装 TensorFlow 2.7。你将看到的一切都可以在普通的 M1 和 M1 Max 芯片上工作，只要是苹果硅芯片。我们还将通过训练一个简单的神经网络来验证 TensorFlow 是否已安装。

不想看书？请观看我的视频:

在 MacBook Pro M1 Pro 上安装 TensorFlow 必备软件

在你能想到 TensorFlow 之前，你需要安装一些东西——家酿、 XCode 工具和 Anaconda 。您可以使用以下命令通过 Mac 的终端安装前两个:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

xcode-select --install

如果您不能立即安装 XCode 工具，请重新启动终端窗口，然后再试一次。

最后，你需要一条蟒蛇。截至目前， Miniforge 原生运行在所有 M1 芯片上(M1、M1 Pro、M1 Max)，所以我们会坚持下去。下载 Mac 版 ARM64 下图中标记的版本:

图 1-Miniforge 下载页面(图片由作者提供)

它将下载一个 SH 文件。您必须更改它的权限，并通过终端运行它:

cd <path_to_the_downloaded_file>

chmod -x Miniforge3-MacOSX-arm64.sh
./Miniforge3-MacOSX-arm64.sh

图 2 —从终端安装 Miniforge(图片由作者提供)

按照说明建议—按下进入继续。坚持使用默认选项，一分钟左右你就应该安装好 Miniforge 了！

现在基于 Python 3.9 创建一个新的虚拟环境。我给我的取名为env_tf:

conda create --name env_tf python=3.9

几秒钟后将创建新环境:

图 3 —创建新的虚拟环境(图片由作者提供)

从这里，激活环境:

conda activate env_tf

图 4 —激活新的虚拟环境(图片由作者提供)

这就是我们在 M1 Pro 芯片上安装 TensorFlow 所需的全部内容——接下来让我们开始吧。

如何在 M1 Pro 芯片上安装 TensorFlow 和 TensorFlow Metal

在过去的几个月里，安装有 GPU 支持的 TensorFlow 的过程变得更加顺畅。自从 macOS Monterey 发布以来，如果有人遵循这些说明遇到任何麻烦，我会感到惊讶。

我们将从安装来自 Apple 的 TensorFlow 依赖项开始:

conda install -c apple tensorflow-deps -y

图 5 —安装苹果的 TensorFlow 依赖项(图片由作者提供)

安装完成后，使用以下命令在 M1 专业版 Macbook 上安装 TensorFlow:

python -m pip install tensorflow-macos

图 6 —在 M1 Pro Macbook 上安装 TensorFlow(图片由作者提供)

安装将需要几分钟，因为 Miniforge 必须拉一吨相当大的包。最后一步是用 Metal 插件在 M1 Pro macbook 上安装对 TensorFlow 的 GPU 支持:

pip install tensorflow-metal

图 7 —在 M1 Pro Macbook 上安装 TensorFlow Metal(图片由作者提供)

至此，您已经安装了 TensorFlow 及其所有依赖项。我还将安装 JupyterLab，这样我们就可以轻松地构建和训练一个简单的神经网络:

conda install -c conda-forge jupyter jupyterlab -y

图 8 —安装 JupyterLab(图片由作者提供)

安装后，启动新的 Jupyter 会话:

jupyter lab

下一节我们再见，我们将在 M1 Pro 芯片上用 TensorFlow 训练一个简单的神经网络。

如何在 MacBook Pro M1 Pro 上用 TensorFlow 训练一个神经网络

在继续之前，您应该启动一个 JupyterLab 会话，或者打开任何其他代码编辑器。使用以下代码片段导入 TensorFlow 并验证它是否已安装:

import tensorflow as tf tf.__version__

此外，打印可用训练设备的列表-只是为了验证 M1 Pro Macbook 上的 TensorFlow 可以看到 GPU:

tf.config.list_physical_devices()

以下是两者的输出:

图 9 — TensorFlow 版本和可用设备(图片由作者提供)

现在，M1 Pro 芯片上的 TensorFlow 安装成功，它还将 CPU 和 GPU 视为可用的训练设备！

接下来，让我们为模型训练创建一个虚拟数据集。唯一的输入特征是范围从 1 到 100 的 1000 个数字的数组，步长为 0.1。目标变量是输入要素+ 10。两者都被转换为浮点张量对象:

import numpy as np

X = np.arange(1, 101, step=0.1)
y = [x + 10 for x in X]

X = tf.cast(tf.constant(X), dtype=tf.float32)
y = tf.cast(tf.constant(y), dtype=tf.float32)

从这里，我们将声明一个神经网络模型。体系结构随机设置，网络分为两层，每层 64 个节点。该模型是使用平均绝对误差(T2)来跟踪损失，亚当(T4)作为优化器。最后，该模型被训练 100 个时期:

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, input_shape=(1,), activation='relu'),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(1)
])

model.compile(
    loss=tf.keras.losses.mean_absolute_error,
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
    metrics=['mean_absolute_error']
)

model.fit(X, y, epochs=100)

培训结束后，您将看到以下内容:

图 10 —在 M1 Pro 芯片上用 TensorFlow 训练神经网络模型(图片由作者提供)

一切看起来都很好，所以让我们使用predict()函数对新数据进行预测:

model.predict([10, 20, 30])

图 11 —根据新数据进行预测(图片由作者提供)

实际值应该是 20、30 和 40。我们的简单模型不会太离谱。

结论

今天，您已经在 M1 Pro MacBook 上成功安装了支持 GPU 的 TensorFlow。上述循序渐进的指导应该适用于任何苹果芯片设备，从 Mac Mini 到 M1 Max。

但是 M1 Pro 对于数据科学和机器学习有多好呢？请继续关注，因为我做了大量真实世界的对比测试，我计划在未来几周内分享。

同时，参考以下资源，从头开始学习 TensorFlow:

TensorFlow 文章系列
TensorFlow 视频系列
TensorFlow for computer vison 视频系列

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

https://medium.com/@radecicdario/membership

保持联系

注册我的简讯
订阅 YouTube
在 LinkedIn 上连接

最初发表于 2021 年 12 月 30 日https://betterdatascience.com。

如何将气候风险纳入信用风险评估

原文：https://towardsdatascience.com/how-to-integrate-climate-risk-into-credit-risk-assessments-f7eac5c01850?source=collection_archive---------25-----------------------

行业笔记

使用 NFIP 保险数据重新评估抵押贷款组合风险

由 NOAA 在 Unsplash 上拍摄的照片

十年前，气候风险仅被视为对公司道德和声誉的潜在威胁。今天，越来越多的公司开始将它视为一种可能影响其战略和业务规划的财务风险。正如气候相关财务披露工作组(TCFD)建议中所述，有两大类气候风险会对公司造成财务影响:物理风险和过渡风险。

物理风险 : 由极端天气事件(即急性风险)的频率或严重性(如旋风、飓风或洪水)导致的财产价值减少或运营成本增加(如保险费增加)；或长期气候模式转变(即慢性风险)，如降水、气温上升和海平面上升。

转型风险 : 与向低碳经济转型相关的政策、技术、消费者行为和市场供应的变化，包括由于减排政策的突然变化而导致的化石燃料储备或管道(即搁浅资产)的注销或提前报废。

根据 TCFD 2020 年的最新状况报告，有超过 1700 家公司签署了通过其主要财务报告披露气候相关风险和机遇的协议。更重要的是，大量与气候相关的风险数据预计将在很大程度上由数据提供商和非政府组织补充，如 CDP 、 2Degree Investing 和 Carbon4 Finance 等..预计为了将气候风险完全纳入(信贷)投资/业务决策，将会有越来越多的需求来探索非常规建模技术，以将气候情景、减排途径或碳管理 ESG 指标“转化”为财务影响。

在本文中，我们将讨论如何利用国家洪水保险计划(NFIP)索赔数据来洞察洪水风险对财产价值的影响，从而揭示住宅抵押贷款风险中尚未捕捉到的隐藏风险(即在财产价值和抵押贷款组合的预期损失之间建立联系)。让我们开始吧。

什么是 NFIP 计划？

标准的房主和房客保险政策不包括洪水损害。然而，洪水保险是作为一项独立于 NFIP 的政策提供的，这是一项由国会在 1968 年创建的联邦计划，由联邦紧急事务管理局(FEMA)管理。NFIP 计划有两个主要目标:

保护参与社区的财产所有者免受洪水损失；
通过社区和州采用洪泛区管理条例来减少未来的洪水损失。

由于这两个主要目的，位于参与的 NFIP 社区和特殊洪水危险区(SFHA，又名 100 年一遇洪水危险区，因为这些地区每年有 1%的概率被洪水袭击)的建筑必须投保洪水保险，而一些抵押贷款人可能要求 SFHA 以外的房产投保洪水保险，作为其审批流程的一部分。此外，NFIP 计划的参与是以社区为基础的，而不是以个人为基础的，因为该保险仅在那些洪水易发地区提供，在这些地区，在其社区监督下采用了适当的设计和施工标准。

NFIP 提供两种保险保障，即建筑和内容保障，分别在两种计划下，即常规计划和紧急计划。以单户住宅为例，NFIP 保险公司在常规项目下可提供高达 25 万美元的建筑保险，在紧急项目下可提供 3.5 万美元的建筑保险；额外内容分别高达 100，000 美元和 10，000 美元。从历史上看，最高的 NFIP 支出属于 2005 年的卡特里娜飓风，为 163 亿美元，其次是 2017 年的哈维飓风，为 89 亿美元。

洪水事件会如何影响你的抵押贷款行为？

在被洪水事件破坏或摧毁的地区，人们可能会看到拖欠率瞬间飙升。这是因为一些房主在支付短期住房租金的同时，可能不得不修复重大损坏，甚至重建他们的房产，因为他们尚未获得延期偿付计划或修改。下图显示了 2017 年 8 月飓风哈维过后，德克萨斯州的犯罪率急剧上升。

作者图片—德克萨斯州房地美拖欠状况(2014 年至 2019 年)

同样如上图所示，在向借款人提供金融援助计划(即延期、还款计划和/或贷款修改)后，大量拖欠贷款将在陷入严重拖欠或违约状态之前得到解决。贷款严重拖欠或违约的可能性主要取决于洪水损害的严重程度(或剩余房屋净值规模)和借款人的收入状况。根据基于房利美数据的飓风哈维的案例研究，与未受损害的财产相比，中度至重度损害(即超过财产价值 10%的损害)会使洪水后五个月内贷款逾期 90 天的几率增加三倍。

洪水过后，提前还款行为也会激增，尤其是在需要洪水保险的地区。这是因为这些房主可以用保险索赔来偿还未偿还的贷款。此外，一些受影响的房主可能希望搬到洪水易发区以外，这并不奇怪，其中这些受保的借款人更愿意以折扣价向投资者出售房屋，因为他们的损失已经得到补偿。哈维袭击一年后，房屋销售活动增长了 37.2%，这支持了这一点。

很明显，为了描述后洪水时期损失和提前还款行为的增加，传统信用风险分析中缺失的环节是使用保险单/索赔数据来回答以下关键问题:

如何预测洪水事件造成的财产损失？
如何预测贷款账簿中的保险范围随时间的变化？

我们在下面分析中的重点将放在第一个问题上。

数据下载

联邦应急管理局提供公共访问数据集，包括应急管理，减灾和 NIFP 等。，通过 OpenFEMA ，一个通过直接下载(csv 格式)或 API 端点交付数据的一站式商店。本分析中使用的数据集来源于 FIMA NFIP 修订索赔— v1 ，该数据集代表了自 20 世纪 70 年代以来超过 2，000，000 起索赔交易，涵盖所有州和地区。在这个分析中，我们使用保险索赔与承保范围的比率作为损失的衡量标准，我们的重点将放在独栋房屋上。

深度-损伤关系

由于洪水深度是估计财产损失的最佳代理，几十年来，估计洪水事件造成的经济损失的传统方法是基于深度损失函数。深度损伤函数的形状在很大程度上取决于以下性质特征:

楼层数

似乎楼层越高(此处联排别墅代表三层或三层以上的联排别墅)，遭受洪水损害的风险就越低。最高的风险属于基础上的活动房屋或旅行拖车。

按作者分类的图片—基于 NFIP 索赔数据的按楼层数分类的损坏率(TX 和 FL)

地下室类型

与有地下室结构的房子相比，没有地下室(包括地下室类型——未知)的独户房子往往显示出更高的损坏风险。正如所料，当地下室更完整，更类似于楼上的生活区，财产往往显示较低的洪水损害风险。

按作者分类的图像—根据 NFIP 索赔数据按基底类型分类的损坏率(德克萨斯州和佛罗里达州)

洪水区(洪水保险评级图—公司)

联邦应急管理局指定并维护洪水区评级，以帮助抵押贷款机构确定保险要求，并帮助社区制定降低风险的策略。洪水区是根据洪水风险驱动因素定义的，如洪水袭击概率、区域特征(如海岸、积水等)。)、建设标准等..有关详细信息，请参考下表。

图片由作者提供；原文出处:https://floodpartners.com/flood-zones/

据观察，损坏率对洪水区相当敏感，但是最高的损坏率不一定总是与高风险洪水区相关联。在某些情况下，低到中等风险区(如 C 区和 X 区)也显示出较高的损坏率，情况正好相反。这可能是因为 FEMA 自 20 世纪 70 年代以来引入的静态洪水区评级不再能够提供该地区内在洪水风险的准确测量。事实上，今年早些时候，联邦应急管理局已经宣布在 2021 年 10 月推出风险评级 2.0 。新的风险评级方法预计将纳入更多的洪水风险变量，包括洪水频率、多种洪水类型——河流溢流、风暴潮、海岸侵蚀和暴雨——以及与水源的距离以及财产特征，如海拔和重建成本。

作者图片-基于 NFIP 索赔数据的洪灾区(德克萨斯州和佛罗里达州)损失比率

从下面的数字中可以得出类似的结论，这些数字显示了飓风哈维造成的损失比率的另一种观点，并与同一地区的 SFHA 区进行了比较。

按作者分类的影像-哈维 NFIP 飓风的破坏率和 SFHA 区域比较(使用 Python 中的底图创建)

将上面两个图放在一起，从下图中可以看出，许多遭受严重损坏的区域(蓝色阴影)实际上位于 SFHA 区之外。

按作者分类的影像-哈维·NFIP 飓风损害率和 SFHA 区域重叠(使用 Python 中的底图创建)

下一步是什么？

上述实证分析试图证明在气候相关信用风险分析中使用保险数据的直观性和重要性。如本文开头所述，作为下一步，人们可能希望探索深度损害函数，以生成各种气候情景下的财产级年损失曲线。FEMA 的 Hazus 洪水评估结构工具(FAST)工具 ，一个开源的解决方案，可以成为你一个很好的起点。尽管多年来许多水文学家对危险数据稀疏性限制提出了担忧，并对将 Hazus 模型应用于所有地区和洪水事件提出了批评，但在预测危险损失时，它仍然是各种气候分析供应商解决方案最受欢迎的基础。

另一个需要考虑的步骤是在长期气候情景分析中预测保险范围的演变。除了历史趋势之外，保险范围的建模应该考虑 1)被低估的洪水风险的暴露；以及 2)增加保险价格对低收入社区的不利影响。

结论

希望这篇文章能帮助你思考如何将保险数据纳入你的信用风险分析，并量化气候风险的影响。喜欢就在下面留下你的评论吧。以上分析的完整代码(包括底图邮编等级图)可以在这里找到。

使用底图绘制飓风哈维(德克萨斯州休斯顿)的邮政编码级别损害率和洪水区等级

脚注

[1]SFHA:在 30 年的抵押贷款期间，SFHA 地区至少有四分之一的几率会被洪水淹没。如果有人想知道他或她的房产是否在 SFHA 区，您可以使用您在 https://msc.fema.gov/portal/search的地址或坐标找到该信息。如果您想进一步了解如何通过 FEMA 的 NFHL(国家洪水灾害层)API 提取 SFHA 洪水区信息，请在下面留下您的评论。

如何将 Quickbooks 与 Python 集成

原文：https://towardsdatascience.com/how-to-integrate-quickbooks-with-python-8be2d69f96cb?source=collection_archive---------16-----------------------

使用 Python 构建轻量级 Quickbooks 数据集成管道

如果您是一名 B2B 开发人员，正在开发一个产品，最早的产品开发阶段之一就是创建一个数据集成管道来导入客户数据。

在本文中，我将向您展示如何利用 Singer 的 tap-quickbooks 从 quickbooks 中提取数据。在这里，我将带您了解如何使用 target-csv 解析来自 Singer 的 JSON 输出数据，并使用一个简单的 Python 脚本将其标准化。

来源: unDraw

笔记

这些例子的代码可以在 GitHub 这里上公开获得，还有我将带你浏览的信息的描述。

这些示例依赖于几个开源 Python 包:

点击 quickbooks: 歌手点击 quickbooks 来提取数据。更多关于 GitHub 的信息。我们将使用 hotglue fork ，因为它与 target-csv 版本兼容。
target-csv: 一个 Singer 目标，将输入的 JSON 数据转换成 csv 文件。更多关于 GitHub 的信息。我们将使用热熔胶叉，它使用更新的依赖关系。
singer-discover :一个从歌手目录中选择流的开源工具。更多关于 GitHub 的信息。
pandas: 一个广泛使用的开源数据分析和操纵工具。关于他们的站点和 PyPi 的更多信息。
gluestick: 一个小型开源 Python 包，包含由 hotglue 团队维护的用于 ETL 的 util 函数。更多关于 PyPi 和 GitHub 的信息。

事不宜迟，我们开始吧！

步骤 1:设置我们的环境

创造虚拟

Singer taps 之间往往会有很多依赖冲突——为了避免依赖地狱，我强烈建议在虚拟环境中运行这个示例。

# Install JupyterLab if you don't have it already
$ pip3 install jupyterlab# Create the virtual env
$ python3 -m venv ~/env/tap-quickbooks# Activate the virtual env
$ source ~/env/tap-quickbooks/bin/activate# Install the dependencies
$ pip install git+[https://github.com/hotgluexyz/tap-quickbooks.git](https://github.com/hotgluexyz/target-csv.git) git+[https://github.com/hotgluexyz/target-csv.git](https://github.com/hotgluexyz/target-csv.git) gluestick pandas ipykernel singer-python==5.3.1 requests==2.20.0 xmltodict==0.11.0 jsonpath-ng==1.4.3 pytz==2018.4 attrs==20.2.0[#](https://github.com/chrisgoddard/singer-discover/archive/master.zip#) Make our venv available to JupyterLab
$ python -m ipykernel install --user --name=tap-quickbooks# Create a workspace for this
$ mkdir quickbooks-integration# Enter the directory
$ cd quickbooks-integration

这些命令可能因您的操作系统和 Python 版本而异。欲了解更多关于 Jupyter venvs 的信息，请查看这篇关于数据科学的文章。

步骤 2:配置歌手抽头

获取 OAuth 凭证

首先，你需要 Quickbooks OAuth 证书。Quickbooks 已经很好地记录了这个过程，所以我假设你可以遵循这个指南。

创建歌手点击配置

现在我们必须创建一个歌手配置。这将指定我们的 OAuth 凭证和一些特定于 Singer 的设置。他们的示例配置具有以下格式:

{
  "client_id": "secret_client_id",
  "client_secret": "secret_client_secret",
  "refresh_token": "abc123",
  "start_date": "2017-11-02T00:00:00Z",
  "api_type": "BULK",
  "select_fields_by_default": true,
  "sandbox": true,
  "realmId": "123456789"
}

填写您的凭证，并将其保存到本地目录中名为config.json的文件中。

跑步歌手发现

从 Quickbooks 获取数据的第一步是找出哪些数据是实际可用的。Singer taps 提供了一个 discover 命令，它打印一个描述所有这些内容的 JSON 对象。让我们现在运行它:

# Do the Singer discover and save to catalog.json
$ tap-quickbooks --config config.json --discover > catalog.json

如果成功，您的 catalog.json 应该如下所示:

# Check discover output
$ less catalog.json
{
    "streams": [
        {
            "stream": "Invoice",
            "tap_stream_id": "Invoice",
            "schema": {
                "type": "object",
                "additionalProperties": false,
                "properties": {
                    "AllowIPNPayment": {
                        "type": [
                            "boolean",
                            "null"
                        ]
                    },
...

告诉辛格我们想要什么

在这里，我们想要选择我们实际想要同步的对象。为此，我们将使用之前下载的 singer-discover 实用程序。

# Switch singer-python version to meet singer-discover dep
$ pip install [https://github.com/chrisgoddard/singer-discover/archive/master.zip](https://github.com/chrisgoddard/singer-discover/archive/master.zip#) singer-python==5.4.1 prompt_toolkit==1.0.14# Build our selected catalog
$ singer-discover --input catalog.json --output properties.json

这将启动一个交互式实用程序，从 Quickbooks 中选择您想要的流(对象)。我将选择发票(空格)并按回车键。这将提示您选择特定字段的选项。我将接受默认值并按 enter 键。

发票流的选定字段

这将为您提供以下输出

INFO Catalog configuration starting...
? Select Streams  [Invoice]
? Select fields from stream: `Invoice`  done (18 selections)
INFO Catalog configuration saved.

运行歌手同步

现在，我们终于可以使用我们生成的文件从 Quickbooks 中获取数据了，使用以下命令:

# Switch singer-python version to meet tap-quickbooks dep
$ pip install singer-python==5.3.1# Get Invoice data from Quickbooks and save as a CSV
$ tap-quickbooks --config config.json --properties properties.json | target-csv  > state.json

这将输出两个文件:

包含 Quickbooks 数据的 CSV 文件(类似于Invoice-20210128T125258.csv)
一个 JSON 文件state.json告诉tap-quickbooks它最后同步了什么。这可以在未来反馈到 tap-quickbooks，以避免再次同步相同的数据。

终于！我们已经从 Quickbooks 中提取了数据！不算太坏，对吧？如果你想在生产中使用它，你必须自动化创建properties.json的过程，并且很可能将所有这些都粘贴到 Docker 容器中(非常类似于 hotglue 和 Airbyte 的工作方式)。

步骤 3:标准化数据

您可以在 Jupyter 笔记本中直接阅读这一部分(随意复制并尝试您自己的转换)。

https://github.com/hotgluexyz/recipes/blob/master/src/quickbooks.ipynb

看数据

先来看看tap-quickbooks给了我们什么。

Quickbooks 的 CSV 发票

不算太坏，对吧？让我们将数据加载到 Jupyter 笔记本中，并稍微整理一下数据。对于这篇文章，我将保持它非常简单，但是如果你想了解其他 ETL 操作，请查看我的关于数据科学的文章。

发射 Jupyter

让我们发射 Jupyter

# You may have some issues in Jupyter if you don't do this
$ pip install prompt-toolkit==3.0.14# Deactivate the virtualenv
$ deactivate# Start Jupyter Lab
$ jupyter lab

这应该会在当前目录下启动 Jupyter 并打开浏览器。

JupyterLab 开始了

如果所有的设置命令都有效，您应该在笔记本部分看到 tap-quickbooks。让我们用 tap-quickbooks 内核创建一个新的笔记本。我将把我的名字命名为quickbooks.ipynb

加载数据

让我们使用 gluestick 和 pandas 库来加载数据并查看一下。我们这里的目标是能够容易地操作 tap-quickbooks 的输出。

熊猫数据框架中的数据预览

清理数据

现在我们有了熊猫的数据框架中的数据，你可以随意转换它。当然，你并不局限于使用 Pandas——你可以使用 Spark，或者任何你喜欢的基于 Python 的数据转换工具。

示例最终数据

结论

后续步骤

这实际上只是数据集成管道的起点。如果你想更进一步(在云上编排，将它连接到你的产品上),那就值得看一看专注于开发人员的工具，比如 hotglue 和 Meltano ，它们都旨在让开发人员更容易进行数据集成。

考虑

我最近在 TowardsDataScience 上发表了一篇关于打造 Singer 的利与弊的文章。我建议在决定建立你的歌手管道之前，先看看 Airbyte 。

未来，你可以随意查看开源的热熔胶配方以获取更多样本。感谢阅读！我很乐意回答下面的任何评论或问题。

如何将 Quickbooks 与您的 SaaS 平台集成

原文：https://towardsdatascience.com/how-to-integrate-quickbooks-with-your-saas-platform-50e79d997fa7?source=collection_archive---------38-----------------------

我如何使用 Python 构建 QBO 集成来监控部门收入和成本

最近，我的任务是构建一个 Quickbooks Online (QBO)集成来处理损益(P & L)报告，并确定收入、销货成本(COGS)和部门费用——下面是我如何做的。

来源: unDraw

本文不是关于构建 OAuth 流或使用 cron 作业从 Quickbooks API 提取数据。这个过程相对来说是样板，已经被工具解决了，比如我将要使用的这个。如果您对自己构建感兴趣，请查看我的文章中关于使用 Singer 实现这一点的文章。

相反，本文将带您完成更难的部分——如何理解数据。

获取数据

正如我上面提到的，在这篇文章中，我将使用 hotglue 来处理为 SaaS 平台构建 QBO 集成的所有样板文件。这包括:

创建 OAuth 授权流
允许用户在您的 UI 中连接 Quickbooks 并监控连接
从 Quickbooks API 中提取必要的数据

创建授权流

在 hotglue 中，我将创建一个新的流并添加 Quickbooks sandbox 作为源。为此，我只需提供我的 OAuth 凭证并登录到我的 Quickbooks 沙盒帐户。如果您还没有 OAuth 凭证，您可以选择“使用测试令牌”

创建 Quickbooks OAuth 流

选择我们需要的数据

现在我们可以从 Quickbooks 中选择我们需要的数据。我们将选择帐户(会计科目表)、项目(产品和服务)、采购(费用)、发票和损益报告。

这将为我们提供准确分类交易所需的参考数据。

Quickbooks 选定的数据

将集成添加到您的 UI 中

通过一些基本的 JavaScript，我能够嵌入 hotglue widget ，它使用户能够连接他们的 Quickbooks 帐户，刷新同步的数据，并监视它上次刷新的时间。

嵌入式集成

标记交易

Quickbooks 本身不支持在特定部门或项目下标记事务。为此，我使用 Quickbooks 类字段来标记部门/项目下的事务。例如，下面的发票被标记为Pest Control:Project X,意思是害虫控制部门，项目 x。

使用类别标记 Quickbooks 发票

处理数据

现在是有趣的部分。我们将使用 Python 脚本，使用 pandas 和 gluestick 将 Quickbooks 中的数据转换成 JSON 文件，如下所示。

我们想要生产的东西

正如您在下面看到的，JSON 文件获取了我们 P&L 报告中的每一笔交易，并将其归类到Pest Control部门的Project X下。此外，它将每笔交易分类为revenue、cogs(销售成本)、labor和costs(费用)。

{
  "Pest Control": {
    "Project X": {
      "revenues": {
        "2021-11": {
          "Pest Control Services": {
            "Pest Control Services": {
              "Bed Bug Removal": {
                "total": 350,
                "qty": "10",
                "rate": 35
              }
            }
          }
        }
      },
      "cogs": {
        "2021-11": {
          "Supplies & Materials - COGS": {
            "Pest Control Services": {
              "Bed Bug Removal": {
                "total": 100,
                "qty": 1,
                "rate": 100
              }
            }
          }
        }
      },
      "labor": {
        "2021-11": {
          "Employee": {
            "Inspector": {
              "Employee Benefits": 10.8,
              "Payroll Tax": 61.2,
              "Payroll Wage Expenses": 800
            }
          }
        }
      },
      "costs": {
        "2021-11": {
          "Project Expenses": {
            "Automobile": {
              "Fuel": 100
            }
          }
        }
      }
    }
  }
}

写剧本

hotglue 具有内置功能，可以在每次从 Quickbooks API 同步新数据时运行 Python 脚本，并避免再次同步旧数据(增量同步)。

您可以浏览下面脚本的每个步骤。

如果您正在使用 hotglue 创建您的集成，您可以学习如何在文档中编写和部署脚本。

一起运行

选择数据应该放在哪里

如果你正在使用 hotglue，你需要指定一个最终数据交付的地方(一个目标)。默认情况下，hotglue 会使用 Mailgun 将新数据通过电子邮件发送给您。我使用谷歌云存储来整合我们的 Quickbooks。

配置 Google 云存储目标

运行作业

现在，我们可以运行同步作业了。这将连接到 Quickbooks API，查询任何新数据，将其保存为 CSV，运行我们的转换脚本，并将结果数据上传到我们的目标(Google 云存储)。

Quickbooks 作业已完成

现在我们可以在谷歌云存储中看到最终的actuals.json文件了！

Google 云存储桶中的结果数据

结论

在本文中，我们创建了一个 Quickbooks 集成，并将生成的 CSV 数据处理成可供 SaaS 应用程序使用的 JSON 有效负载。

希望这有助于您考虑如何构建自己的 SaaS 集成。我强烈推荐使用像 hotglue 这样的工具来处理样板集成步骤，这样您就可以专注于提取您需要的数据，而不是授权和编排问题。

感谢阅读！

如何将 Salesforce 与 Python 集成

原文：https://towardsdatascience.com/how-to-integrate-salesforce-with-b2b-apps-76a8a8af7ee6?source=collection_archive---------24-----------------------

使用 Python 构建轻量级 Salesforce 数据集成管道

如果您是一名 B2B 开发人员，正在开发一个产品，最早的产品开发阶段之一就是创建一个数据集成管道来导入客户数据。

在本文中，我将向您展示如何利用 Singer 的 tap-salesforce 从 salesforce 提取数据。在这里，我将带您了解如何使用 target-csv 解析来自 Singer 的 JSON 输出数据，并使用一个简单的 Python 脚本将其标准化。

来源: unDraw

笔记

这些例子的代码可以在 GitHub 这里上公开获得，还有我将带你浏览的信息的描述。

这些示例依赖于几个开源 Python 包:

tap-salesforce: 歌手点击从 salesforce 提取数据。更多关于 GitHub 的信息。
target-csv: 一个 Singer 目标，将输入的 JSON 数据转换成 csv 文件。更多关于 GitHub 的信息。我们将使用 hotglue fork ，它使用更新的依赖关系。
歌手发现:一个从歌手目录中选择数据流的开源工具。更多关于 GitHub 的信息。
pandas: 一个广泛使用的开源数据分析和操纵工具。更多关于他们的站点和 PyPi 的信息。
gluestick: 一个小型开源 Python 包，包含由 hotglue 团队维护的 ETL 的 util 函数。关于 PyPi 和 GitHub 的更多信息。

事不宜迟，我们开始吧！

步骤 1:设置我们的环境

创造虚拟

Singer taps 之间往往会有很多依赖冲突——为了避免依赖地狱，我强烈建议在虚拟环境中运行这个示例。

# Install JupyterLab if you don't have it already
$ pip3 install jupyterlab# Create the virtual env
$ python3 -m venv ~/env/tap-salesforce# Activate the virtual env
$ source ~/env/tap-salesforce/bin/activate# Install the dependencies
$ pip install tap-salesforce git+[https://github.com/hotgluexyz/target-csv.git](https://github.com/hotgluexyz/target-csv.git) gluestick pandas ipykernel singer-python==5.3.1 https://github.com/chrisgoddard/singer-discover/archive/master.zip# Make our venv available to JupyterLab
$ python -m ipykernel install --user --name=tap-salesforce# Create a workspace for this
$ mkdir salesforce-integration# Enter the directory
$ cd salesforce-integration

这些命令可能因您的操作系统和 Python 版本而异。关于 Jupyter 的 venvs 的更多信息，请查看这篇关于数据科学的文章。

步骤 2:配置歌手抽头

获取 OAuth 凭证

首先，您需要 Salesforce OAuth 凭据。Salesforce 已经很好地记录了这个过程，所以我假设你可以遵循这个指南。

创建歌手点击配置

现在我们必须创建一个歌手配置。这将指定我们的 OAuth 凭证和一些特定于 Singer 的设置。他们的示例配置具有以下格式:

{
  "client_id": "secret_client_id",
  "client_secret": "secret_client_secret",
  "refresh_token": "abc123",
  "start_date": "2017-11-02T00:00:00Z",
  "api_type": "BULK",
  "select_fields_by_default": true
}

填写您的凭证，并将其保存到本地目录中名为config.json的文件中。

跑步歌手发现

从 Salesforce 获取数据的第一步是找出实际可用的数据。Singer taps 提供了一个 discover 命令，它打印一个描述所有这些内容的 JSON 对象。让我们现在运行它:

# Do the Singer discover and save to catalog.json
$ tap-salesforce --config config.json --discover > catalog.json

如果成功，您的 catalog.json 应该如下所示:

# Check discover output
$ less catalog.json
{
    "streams": [
        {
            "stream": "UserProvisioningRequestShare",
            "tap_stream_id": "UserProvisioningRequestShare",
            "schema": {
                "type": "object",
                "additionalProperties": false,
                "properties": {
                    "Id": {
                        "type": "string"
                    },
...

告诉辛格我们想要什么

在这里，我们想要选择我们实际想要同步的对象。为此，我们将使用之前下载的 singer-discover 实用程序。

# Switch singer-python version to meet singer-discover dep
$ pip install singer-python==5.4.1# Build our selected catalog
$ singer-discover --input catalog.json --output properties.json

这将启动一个交互式实用程序来选择您希望从 Salesforce 获得的流(对象)。我将选择引线(空格)并按回车键。这将提示您选择特定字段的选项。我将接受默认值并按 enter 键。

潜在客户流的选定字段

这将为您提供以下输出

? Select fields from stream: `Lead`  done (55 selections)
INFO Catalog configuration saved.

运行歌手同步

现在，我们最终可以使用我们生成的文件从 Salesforce 获取数据，使用以下命令:

# Get Lead data from Salesforce and save as a CSV
$ tap-salesforce --config config.json --properties properties.json | target-csv  > state.json

这将输出两个文件:

包含来自 Salesforce 的数据的 CSV(类似于Lead-20210128T125258.csv)
一个 JSON 文件state.json告诉tap-salesforce它最后同步了什么。这可以在未来反馈给 tap-salesforce，以避免再次同步相同的数据。

终于！我们已经从 Salesforce 获取了数据！不算太坏，对吧？如果你想在生产中使用它，你必须自动化创建properties.json的过程，并且很可能将所有这些粘贴到 Docker 容器中(非常类似于 hotglue 和 Airbyte 的工作方式)。

步骤 3:标准化数据

您可以在 Jupyter 笔记本中直接阅读这一部分(随意复制并尝试您自己的转换)。

https://github.com/hotgluexyz/recipes/blob/master/src/salesforce.ipynb

看数据

先来看看tap-salesforce给了我们什么。

来自 Salesforce 的销售线索 CSV

不算太坏，对吧？让我们将数据加载到 Jupyter 笔记本中，并稍微整理一下数据。对于本文，我将保持它非常简单，但是如果你想了解其他 ETL 操作，请查看我的 TowardsDataScience 文章。

发射 Jupyter

让我们发射 Jupyter

# You may have some issues in Jupyter if you don't do this
$ pip install prompt-toolkit==3.0.14# Deactivate the virtualenv
$ deactivate# Start Jupyter Lab
$ jupyter lab

这应该会在当前目录下启动 Jupyter 并打开浏览器。

JupyterLab 开始了

如果所有设置命令都有效，您应该在笔记本部分看到 tap-salesforce 可用。让我们用 tap-salesforce 内核创建一个新的笔记本。我将把我的名字命名为salesforce.ipynb

加载数据

让我们使用 gluestick 和 pandas 库来加载数据并查看一下。我们这里的目标是能够容易地操作 tap-salesforce 的输出。

熊猫数据框架中的数据预览

清理数据

现在我们有了熊猫的数据框架中的数据，你可以随意转换它。当然，你不局限于使用 Pandas——你可以使用 Spark，或者任何其他你喜欢的基于 Python 的数据转换工具。

示例最终数据

结论

后续步骤

这实际上只是数据集成管道的起点。如果你想更进一步(在云上编排，将它连接到你的产品上)，值得看看像 hotglue 和 Meltano 这样的工具，它们都旨在使数据集成对开发者来说更容易。

考虑

我最近在 TowardsDataScience 上发表了一篇关于打造 Singer 的利与弊的文章。我建议在决定建立你的歌手管道之前，先看看 Airbyte 。

未来，你可以随意查看开源的热熔胶配方以获取更多样本。感谢阅读！我很乐意回答下面的任何评论或问题。

如何将 Python 类集成到 Plotly Dash 仪表板中

原文：https://towardsdatascience.com/how-to-integrate-your-python-class-into-plotly-dash-dashboards-11a796a601b4?source=collection_archive---------16-----------------------

Dash 中面向对象编程的简要教程

乔尔·菲利普在 Unsplash 上的照片

介绍

在开发 Python 应用程序时，使用类和通用面向对象编程(OOP)概念可让您定制和加工代码，从而实现最大的灵活性和可用性。

尽管您可以很好地使用 Python，并且从不担心声明自己的对象，但是这样做可以使您的代码和应用程序更上一层楼，并且总体上使您成为一个更有意识和更全面的开发人员。

如果您以前从未使用过 Python 中的类，并且希望了解更多，请在下面找到我以前的一篇文章，在这篇文章中，我给出了一个项目的概述，您可以从这些项目开始，以发展关于类如何工作的基础知识。

💔-useful-projects-to-learn-python-classes-cf0076c36297>

在本文中，我将提供一个将灵活的类对象嵌入到一个简单的 Plotly-Dash python 应用程序中的例子。 Plotly-Dash 是一套面向用户界面的库和框架，用于各种数据可视化用例。

应用概览:项目回收跟踪

描述

下面提供的用于本教程的示例应用程序是一个简单的 Dash 应用程序，名为项目回收跟踪器；该应用程序的目的是提供一个估计时间的图形概览，以摊销为任何特定项目支付的货币价值。

在这个例子中，我很想知道我需要多长时间才能收回对一辆全新自行车的 425 美元投资，假设定期两周使用一次，平均机会成本为 4.8 美元(相当于我没有使用/拥有我的自行车时一次典型乘坐的公共汽车/地铁票的成本)。

该应用程序将初始成本、使用价值和使用频率作为输入，并以图形方式呈现摊销图/时间线，同时提供估计收回投资所需时间的文本结果。

在这种情况下，我需要在将近一年(45 周)后，或者 89 次骑行后归还我的自行车！

现在，您对这个应用程序的上下文更加熟悉了，让我们看看如何在 Python 后端潜在地利用 Python 类来定义并使用我们的跟踪器功能。

我们的物品回收追踪应用程序(来源:作者)

代码概述

我们的简单应用程序使用了两个 Python 脚本:

Payback_Calculator.py: 您可以在其中定义我们自己的回报跟踪器类对象及其功能的脚本
Payback_Application.py: 运行和渲染 Plotly Dash 应用程序的脚本

现在让我们从类实例化到应用程序呈现，一步一步地检查这两个脚本。

1)定义我们的定制类:回报跟踪器

类实例化和属性

Python 中的类用 class 关键字初始化，后跟类名。下面的代码创建并命名了一个 Payback_Tracker 类。

在实例化时，Python 类使用内置的 init() 函数来赋予类属性。属性是可以附加到给定类实例的类对象属性，这取决于它的定义和您计划对类及其对象的使用。

这个 Python Tracker 类在实例化时接受 5 个显式给定的属性( name、initial_cost、usage_benefit、frequency、period )加上 3 个其他属性，如下所述:

名称:类对象实例的名称(即“bike”)

initial_cost :表示所需前期投资的项目成本

usage_benefit :使用该物品所提取的机会成本的货币价值

频率:该物品在一段时间内的使用频率

未偿余额:剩余的待摊销货币价值。在实例化时，即初始投资时，它等于 initial_cost

周期:使用周期参考(即“每日”、“每周”、“每月”或“每年”使用)

Tracker 实例还初始化了三个附加属性，当项目被所有者“使用”和分期偿还时，它将利用这三个属性来跟踪相关的对象信息:

balance _ history:outstanding _ balance值的集合，跟踪器使用这些值来跟踪项目的回报历史。初始化为一个列表，第一个 outstanding_balance 值作为初始值。

pay back _ counter _ period:自使用开始后经过的周期数。初始投资时初始化为 0。

usage_total: 记录在任何给定时间项目使用的总货币等值。(即，在购买该物品并使用 2 次后，使用收益为 4 美元，一段时间后的使用总价值为 24 美元=8 美元*)

类方法

使用类方法，您可以通过自定义功能来丰富我们的跟踪器，并通过该类的典型函数(方法)来定义其行为，从而很好地利用您的类属性。

我们的 Payback_Tracker 类有三个方法:

get_result(): 给定对象的 initial_cost ， usage_benefit，frequency 和 period ，返回估计的使用次数，或 period 属性中定义的 period。

来源:作者

generate _ balance _ history():以降序(从项目的初始投资价值开始)返回一个摊销值列表，它表示有待偿还的初始项目的价值。随着使用量线性减少。

来源:作者

get_balance_history(): 返回按照generate _ balance _ history()方法生成的摊余值列表

来源:作者

get_balance_data(): 返回项目的 balance_history 的数据帧格式版本

这个 Payback_Tracker 类现在有了自己的属性和方法，给定它的输入，它可以计算一个项目的分期偿还历史和时间表。

现在让我们通过将对象嵌入到我们的 Plotly-Dash 应用程序中来实现这一切！

2)将回报跟踪器类嵌入到应用程序的功能中

回收跟踪器应用程序位于 Payback_Application.py 中。该脚本有三个主要部分，如下所述。

包导入和 Dash app 创建

首先，让我们导入必要的包来运行我们的 plotly-dash 应用程序(第 1-11 行)；然后，我们的应用程序的实例可以用相关的破折号和初始化。服务器方法(第 13–15 行)。

注意这个脚本是如何从payroll _ calculator . py中导入我们的 Tracker 类的，这样就可以访问 payroll _ Tracker 类实例及其方法的定义(第 11 行)。

2。应用程序的 HTML 布局(带有一些内置的 CSS 格式)

接下来，我们的 HTML 组件可以作为一个列表定义到 app.layout 变量中。也可以参考上面这张 app 前端的图片，以供参考。

主要组件(嵌入到主容器 < div > 元素集合的开头)有:

一个 H1 表头，设置 app 的标题(“项目回收期计算器”)
一个 < div > 元素，包含 app 的描述，带有标题和副标题
一个附加的 < div > ，带有一个标题(表单图例)和三个段落 < p > 标签，提供用户输入字段周围的图例信息。
另一个 < div > 包含输入字段，供用户填写变量 Payback_Tracker 类将使用该变量来计算投资回报所需的估计时间:项目名称、初始成本、使用收益和频率，以及相关周期。这些元素被编码为 dash 应用程序中的输入元素，以便后端能够引用用户的输入，并将这些值存储为我们的类将在下一步中使用的变量。
布局以包含我们的数据输出图的 < div > 标记(id=' output_graph ')和一个 < div > 标记(id=' output_tex t ')结束，该标记将通过调用用户输入变量上的 get_result() 类方法来呈现输出

已经用一些额外但重要的内嵌 CSS 设计了我们的页面元素，现在你可以进入应用程序的主要功能部分了。

3。调用我们的 Payback_Tracker 类来启用应用程序的功能

我们的应用在 Dash 中的功能是由一个且只有一个函数实现的，这个函数叫做 generate_graph() 。该应用程序使用一个Python decorator来定义该函数将使用的输入和输出组件。

我们的 5 个输入组件来自输入元素，这些元素在前面的部分中被定义为布局的一部分，并由它们在 HTML 中的 ID 字段引用。它们在 generate_graph() 函数中作为参数传递，并对应于 Payback_Tracker 类的 5 个关键属性( name、initial_cost、usage_benefit、frequency、period )。

还定义了 2 个输出元素，分别是‘Output _ graph’和‘Output _ text’HTML 元素，它们将用于返回和呈现函数的输出。

然后定义函数体。在用户用他/她的 5 个输入元素填写表单后，这些元素作为输入参数被传递给 generate_graph() 。然后，该函数使用这 5 个属性(第 11 行)创建一个名为 object_ 的 Payback_Tracker 类实例，并对这些输入连续调用generate _ balance _ history()和 get_balance_data() 方法，将后者的结果存储在一个 data 变量中(第 13 行)。

使用这些数据，然后通过 plotly.express (px)库(第 15-18 行)创建一个条形图(存储在 fig 变量中)。

该函数返回两个 fig 变量，将其嵌入到两个输出元素( output_graph' )的第一个中，然后还将调用 get_result() 方法的结果嵌入到 'output_text' 元素中。

因此，每当用户填写表单时，5 个输入字段都被类用来:

创建该类的一个实例
在其属性上调用其方法
使用 generate_graph() 函数捕获输入，处理方法并将结果(图条形图条形图加上 get_resul t())呈现到 Dash HTML 布局中，每次用户修改表单中的输入字段时重复此工作流。

通过这种方式，您已经能够与 Dash 元素交互并通过您的自定义类处理它们，然后通过 generate_graph() 函数将可视化输出呈现给用户！

我们简单的应用程序的功能现在已经完成。

摘要、代码库、有用资源和后续步骤

我希望这个简单的例子可以作为一个有用的例子，说明如何潜在地利用您自己的类对象来用 Dash 创建数据可视化元素！

感谢阅读！

****代码回购:https://github.com/edoard0/Item-Payback-Calculator

参考文献:

仪表板文档

访问我的免费数据科学资源清单 这里

**https://edo-romani1.medium.com/membership **

如何解读模型:PDP 和 ICE

原文：https://towardsdatascience.com/how-to-interpret-models-pdp-and-ice-eabed0062e2c?source=collection_archive---------6-----------------------

确定每个特征对模型输出的贡献。

粘土银行在 Unsplash 拍摄的照片

M 模型的可解释性变得越来越有价值。然而，当处理具有复杂关系的大型模型时，解释并不总是一件容易的事情。

部分相关图(PDP)显示了不同特性对输出的边际贡献。它们用于显示单个特征或两个特征的贡献。

部分相关图也与个体条件期望(ICE)图高度相关。ICE 图显示了每个数据实例的预测变化。

这些图是模型不可知的，这意味着不管基础模型如何，它们都可以显示改变一个或两个特征如何影响模型的输出。

对于价格预测等任务，了解每个要素的 PDP 趋势对于理解模型如何使用新数据进行预测至关重要。理想情况下，这些 PDP 图应该可以解释和理解，以推动决策制定。

PDP 和 ICE

两个图使用相同的机制来模拟预测变化。但是，如果 PDP 观察到一个或两个特征的总体趋势，ICE 图会显示更细粒度级别的变化。

这些图可以并行使用，以了解预测的整体趋势，并检查有问题的个案。因为 PDP 显示了总体水平上的输出变化，所以丢失了特定实例的较小变化。因此，最好是看两种变化。

当预测任务是回归模型时，输出中显示的变化直接是预测中的变化。然而，在分类期间，输出变化是类别的预测概率的变化。

对于 PDP，为了估计部分函数，使用蒙特卡罗方法用训练数据计算平均值:

部分相关函数(作者图片)

例子

为了展示每一种方法，并浏览对图的解释，我使用了“鲍鱼”数据集。

这个数据集是在开放数据共享公共领域奉献和许可(PDDL)下许可的。

https://datahub.io/machine-learning/abalone#readme

该数据集的目标是确定鲍鱼的年龄。通常，这是通过切开球果，给球果染色，然后用显微镜计数球果的数目来完成的。不幸的是，用这种方法测量年龄非常耗时、有创且费力。

相反，使用八个特征，可以有效地预测年龄。这些特征是性别、长度、直径、高度、总重量、去壳重量、内脏重量和壳重量。该数据有 4177 条记录和八个特征。

PDP 和 ICE 图都可以从 sklearn 中的同一个包中生成。

from sklearn.inspection import plot_partial_dependence# PD Plots
plot_partial_dependence(model, X, [feature_name])

部分相关图(图片由作者提供)

相关图基于梯度推进树回归模型。

在图中，显示了“无壳重量”和“整体重量”的模型行为。鲍鱼的年龄预测值随着去壳重量的增加而降低。而对于“整体重量”，此特征的增加会增加预测年龄，但对于低值，预测不会改变。

此外，特征值的百分位数显示在每个图的底部。每个显著的黑色标记代表该特征的百分位数，增量为 10。

# ICE Plots
plot_partial_dependence(model, X, [feature_name], kind='individual')

部分相关和个体条件期望图(图片由作者提供)

接下来是高度的 PD 图和 ICE 图。在 PD 图中，随着数值的增加，趋势不再是线性的。一旦身高超过 0.3，身高就不再对整体年龄预测有贡献(用 0 的部分相关性指定)。

在 ICE 图中，这种模式在所有实例中都是一致的。身高越低，预测年龄越小。然而，当高度增加时，预测增加，直到高度超过阈值。

高度的分布导致了这种奇怪的行为。作为参考，最大值为 1.13，但在第 75 百分位，该值仅为 0.165。

这些图试图在每个特征的值的范围内建模。但是当大多数特征值集中到值的子集时，模型不能很好地学习这个范围。

因此，当新实例的高度值在此范围内时，我们无法确定。

from sklearn.inspection import plot_partial_dependence# PD Plots, 2-dimensional
plot_partial_dependence(model, X, [(feature_1, feature_2)], kind='both')

部分相关图(图片由作者提供)

最终部分相关性图观察到两个特征对最终输出的相互作用。这里显示了“整体重量”和“去皮重量”。

最终输出值的变化用轮廓的颜色显示，每个特征的先前行为仍然存在。

“整体体重”的增加一旦超过先前定义的阈值，预测的年龄就会增加。对于“去皮重量”，预测值随着值的增加而降低。所以对于这两个特性，并没有太多的交互。

结论

部分相关图和个别条件期望图是开始理解你的模型的好方法。此外，它们易于实现并适用于每种模型。

两个图都允许用户更好地理解他们的模型和暴露不一致的趋势以及不规则的模型行为。

这些图取决于监督学习任务中使用的基础模型。然而，它们揭示了整体和单个实例级别的模型行为。因此，它们允许你有效地解释你的模型。

如果你有兴趣阅读关于新颖的数据科学工具和理解机器学习算法的文章，可以考虑在 Medium 上关注我。

如果你对我的写作感兴趣，想直接支持我，请通过以下链接订阅。这个链接确保我会收到你的会员费的一部分。

https://zjwarnes.medium.com/membership

如何迭代熊猫数据框架中的行

原文：https://towardsdatascience.com/how-to-iterate-over-rows-in-a-pandas-dataframe-6aa173fc6c84?source=collection_archive---------3-----------------------

讨论如何在 pandas 中迭代行，以及为什么最好避免(如果可能的话)

由迪尔在 Unsplash 拍摄的照片

介绍

对 pandas 数据帧进行迭代绝对不是一个最佳实践，你应该只在绝对必要的时候，并且当你已经尝试了所有其他可能的更优雅和更有效的选择时，才考虑这样做。

遍历熊猫对象一般慢。在许多情况下，不需要手动迭代这些行，并且可以避免

— 熊猫文档

在今天的文章中，我们将讨论如何避免在 pandas 中遍历数据帧。在选择迭代方法之前，我们还将浏览一份“清单”,您可能每次都需要参考它。此外，我们将探讨在没有其他选项适合您的特定用例的情况下如何做到这一点。最后，我们将讨论为什么在迭代熊猫对象时应该避免修改它们。

真的需要遍历行吗？

正如 pandas 官方文档中所强调的，通过数据帧的迭代是非常低效的，并且通常可以避免。通常，pandas 新成员不熟悉矢量化的概念，也不知道 pandas 中的大多数操作应该(也可以)在非迭代环境中执行。

在尝试遍历 pandas 对象之前，您必须首先确保以下选项都不符合您的用例需求:

迭代矢量化 : pandas 提供了丰富的内置方法，其性能得到了优化。大多数操作都可以使用这些方法中的一种来执行。此外，您甚至可以查看一下numpy并检查它的任何功能是否可以在您的上下文中使用。
将函数应用于行:一个常见的需求是将函数应用于每一行，比如说，一次只能应用于一行，而不能应用于整个数据帧或序列。在这种情况下，最好使用[apply()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html#pandas.DataFrame.apply)方法，而不是遍历 pandas 对象。要了解更多细节，你可以参考 pandas 文档的这一部分，它解释了如何将你自己的或另一个库的函数应用于 pandas 对象。
迭代操作:如果您需要执行迭代操作，同时性能也是一个问题，那么您可能需要考虑 cython 或 numba。关于这些概念的更多细节，你可以阅读熊猫文档的这一部分。
打印一个数据帧:如果你想打印一个数据帧，那么只需使用[DataFrame.to_string()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_string.html)方法，以便将数据帧呈现为一个控制台友好的表格输出。

迭代数据帧的行

如果以上选项都不适合您，那么您可能仍然希望遍历熊猫对象。您可以使用iterrows()或itertuples()内置方法来实现。

在查看这两种方法的运行之前，让我们创建一个示例数据帧，我们将使用它进行迭代。

import pandas as pd df  = pd.DataFrame({
    'colA': [1, 2, 3, 4, 5],
    'colB': ['a', 'b', 'c', 'd', 'e'],
    'colC': [True, True, False, True, False],
})print(df)
 *colA colB   colC
0     1    a   True
1     2    b   True
2     3    c  False
3     4    d   True
4     5    e  False*

[**pandas.DataFrame.iterrows(**](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iterrows.html#pandas.DataFrame.iterrows)**)**方法用于将 DataFrame 行作为(index, Series)对进行迭代。请注意，该方法不会跨行保存dtypes，因为该方法会将每一行转换为Series。如果您需要保留 pandas 对象的 dtypes，那么您应该使用itertuples()方法。

for index, row in **df.iterrows**():
    print(row['colA'], row['colB'], row['colC'])*1 a True
2 b True
3 c False
4 d True
5 e False*

[**pandas.DataFrame.itertuples()**](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.itertuples.html#pandas.DataFrame.itertuples)方法用于以命名元组的形式迭代数据帧行。一般来说， **itertuples()** 预计会比 **iterrows()** 快。

for row in **df.itertuples**():
    print(row.colA, row.colB, row.colC)*1 a True
2 b True
3 c False
4 d True
5 e False*

关于 Python 中命名元组的更多细节，你可以阅读下面的文章。

迭代行时修改

在这一点上，重要的是要强调你不应该修改你正在迭代的 pandas 数据帧或系列。根据 pandas 对象的数据类型，迭代器可能返回对象的副本，而不是视图。在这种情况下，向副本中写入任何内容都不会达到预期的效果。

例如，假设我们想要将colA中每一行的值加倍。迭代方法不会奏效:

for index, row in df.iterrows():
  row['colA'] = row['colA'] * 2print(df)
 *colA colB   colC
0     1    a   True
1     2    b   True
2     3    c  False
3     4    d   True
4     5    e  False*

在类似的用例中，你应该使用apply()方法。

df['colA'] = df['colA'].apply(lambda x: x * 2)print(df)
 *colA colB   colC
0     2    a   True
1     4    b   True
2     6    c  False
3     8    d   True
4    10    e  False*

最后的想法

在今天的文章中，我们讨论了为什么在处理 pandas 对象时避免迭代方法是重要的，而更喜欢矢量化或任何其他适合您特定用例的方法。

pandas 提供了一组丰富的内置方法，这些方法针对大型 pandas 对象进行了优化，您应该始终优先选择这些方法，而不是其他迭代解决方案。如果您仍然想要/必须迭代一个数据帧或系列，您可以使用iterrows()或itertuples()方法。

最后，我们讨论了为什么必须避免修改正在迭代的 pandas 对象，因为这可能不会像预期的那样工作。

成为会员 阅读媒体上的每一个故事。你的会员费直接支持我和你看的其他作家。

你可能也会喜欢

如何用人工智能加入并赢得黑客马拉松

原文：https://towardsdatascience.com/how-to-join-and-win-hackathons-with-ai-ec055e2b5482?source=collection_archive---------10-----------------------

我参加黑客马拉松的故事以及我如何学会以高比率获胜

图片来自 Unsplash

黑客马拉松是我去年的生活。每个周末熬夜到凌晨 4 点，在时间紧迫的情况下构建高级项目会产生无与伦比的肾上腺素激增。虽然无论结果如何，黑客马拉松都是令人愉快的，但没有胜利就不一样了。奖品和奖品有助于证明周末的辛苦工作和睡眠不足。然而，获胜并不容易，学习如何做到这一点需要很长时间。结果很多新黑客就泄气了，不继续了。对我来说幸运的是，情况并非如此，因为我能够很快制定出帮助我成功的策略。

黑客马拉松对于任何有抱负的 AI/ML/DS 学生和工程师来说都是很棒的。它们是练习技能和学习新领域和框架的好方法，比如 PyTorch 和 TensorFlow。有一种误解，认为黑客马拉松主要是关于应用开发，而不是关于人工智能，然而，正如我在本文后面讨论的那样，事实远非如此。因此，如果你有兴趣以一种高效的方式提高你的人工智能技能，那就试试吧。事实上，我从一次黑客马拉松中学到了大部分人工智能技能，我在那里开发了一个皮肤癌诊断应用程序。因此，即使你没有人工智能经验，黑客马拉松也是一个很好的入门方式。

我的努力最近被大联盟黑客突出了，因为我被选为前 50 名黑客之一(你可以在这里找到我的简介)。鉴于最近的新闻，在这篇文章中，我想谈谈我参加黑客马拉松的经历，希望你能了解到任何背景的人都可以参加黑客马拉松。在文章的后半部分，我将给出 5 个技巧和窍门来帮助你赢得黑客马拉松。希望这些对您有所帮助，如果您有任何想法或其他建议，请告诉我。

我是如何加入黑客马拉松的

我最初加入黑客马拉松社区是在 2019 年初，当时我是高中一年级学生。一月份，我和一个朋友发短信聊到她在一个会议中心参加的一个编程活动。它被称为“黑客马拉松”，你有 24 小时的时间来构建一个完整的应用程序，解决社会中的一个问题。当时我知道基本的 Java 和 Python，但从未开发过应用程序。她花了一整天的时间描述她的黑客马拉松经历和她的应用程序，在我知道之前，已经是凌晨 3 点了。与编码伙伴一起通宵达旦地开发一个应用程序的想法很吸引人。

在接下来的几周里，我在谷歌上快速搜索了一下，想弄清楚内置的是什么语言的应用程序，结果发现 IOS 应用程序是用 Swift 构建的。于是在没有任何其他知识和研究的情况下，我开始学习 Swift 两个半月，为一次黑客马拉松做准备。我试图说服几个朋友参加黑客马拉松，但只有一个人接受了。幸运的是，一个有很多 CS 背景的同学联系了我们。我和他一点都不熟，但是因为我太想参加黑客马拉松了，所以我们组队了。

五月中旬，我们报名参加了两次黑客马拉松，我很高兴能够测试我的新技能。不幸的是，这些黑客马拉松最终都被取消了，所以严格来说，我在 4 个月后的 9 月份加入了黑客马拉松。我们去了一个名为 Omnihacks 的黑客马拉松，它是在旧金山市中心的一所贸易学校举办的。

我们被大肆宣传；我们打包了睡袋，还带了零食以防万一，然后在 12 月 15 日的早上，我们坐火车去参加黑客马拉松。一旦我们发现主题是医疗保健，我们决定创建一个 IOS 应用程序，允许盲人患者用 OCR 阅读处方。我们决定将这个应用程序命名为 Tickbird ，因为 Tickbird 是帮助犀牛穿越世界的鸟类。整个经历是一个爆炸，因为我们一天的大部分时间都在闲逛，参加了一些关于 ML 的研讨会，并为自己囤积了零食和食物。作为周末的圆满结束，我们获得了十佳奖和第二个最佳移动应用，从那以后，我就迷上了它。这款应用对我们的第一次破解来说也出奇的好，经过一些结构上的改动后，我们甚至可以在应用商店买到它。那个周末是我的黑客马拉松生涯的开始，现在一年半过去了，我是一个经验丰富的老手，我很高兴我决定参加那个黑客马拉松，甚至不知道它是什么。

如果你对参加黑客马拉松有任何担心或恐惧，我的经历希望对你有所启发。当我开始时，我没有任何应用程序开发或人工智能经验，但出于纯粹的好奇心，我尝试了一下，并能够很快变得非常成功。相信我，这是一个伟大的时刻，所以如果你还在高中或大学，我建议你参加黑客马拉松。尤其是如果你是一名人工智能开发人员，你不需要太多的应用开发经验，因为我几乎没有。第一次尝试一下，然后从那里开始。在最坏的情况下，你会有一个免费食物和商品的有趣周末。

取胜的 5 个技巧和建议

1.找到一个值得信赖和忠诚的团队

这是最重要的提示。在所有其他提示中，这是第一位的。拥有一个值得信赖并致力于团队发展的团队是你获得长期成功的基本素质。

一年前，我遇到一个来自西雅图的黑客，他每个周末都会和随机的队友一起参加黑客马拉松。我对他最大的建议是在每次黑客马拉松中找到可靠的朋友，而不是新的队友。用一个新的团队来重置每一次黑客马拉松都是一个巨大的挫折。你必须学会如何与他们合作，以及他们擅长什么，这意味着没有长期改善的机会。即使你不认识熟悉 CS 或者开发的人，你也可以随时教他们。在当今这个资源如此丰富的世界，任何努力工作的人都可以很快成为黑客马拉松团队中的重要角色。尤其是对于人工智能，有大量的视频和文章教授如何编写基本的人工智能模型，这意味着你基本上可以与任何感兴趣的人组成一个团队。

如果你想在黑客马拉松上长期成功，能够在没有任何争议或冲突的情况下分割工作是关键。当你和那些只想提升自己的人一起工作时，会有关于谁扮演什么角色的问题。这造成了一种有害的环境，没有人希望团队中的其他人成功。团队合作是巨大的，不仅在黑客马拉松中如此，在许多其他领域也是如此，比如体育或研究。

在几次黑客马拉松后，我找到了一个新团队，因为我的第一个团队永远不会在同一页面上。我和学校里最好的朋友一起合作，虽然他们没有太多的经验，但我们能够快速提升。我们都希望彼此进步，关心我们的集体成功。寻找一个团队可能是黑客活动中最具挑战性的部分之一，通常对新黑客来说是一个巨大的威慑。如果你记得这篇文章的任何建议，这应该是它。只要和你认识的忠诚的人一起工作。

我和我的团队在黑客攻击时玩得很开心，提高了我们应用程序的效率和质量(图片由作者提供)

2.网络应用而非移动应用

我的前四个黑客马拉松项目中有两个是移动应用。前面说过，我学的第一门基于应用的语言是 Swift，而不是 HTML/JS/CSS。这是一个很大的错误，因为据我所知，在移动应用上构建用户界面比在网络应用上要困难得多。这是因为允许使用通过 Bootstrap 构建的 web 应用程序模板。然而，这些类型的模板并不存在于移动应用程序中，或者至少是免费的。UI 是你的 hackathon 项目的主要组成部分——它吸引了人们对项目的注意。一个 UI 糟糕的项目通常是一个糟糕的项目，因为它给人一种黑客没有太多经验的印象。

Web 应用程序也更加通用，可以包含其他组件，最著名的是人工智能。我在步骤 5 中深入探讨了为什么人工智能应用程序是必须的，但现在，你应该知道的是，使用人工智能甚至其他技术比使用 web 应用程序更容易。您可以使用其他后端框架来托管您的模型，比如 PythonAnywhere 或 Heroku。然而，对于移动应用程序，你必须学习如何使用 CoreML 将你的人工智能集成到移动应用程序中，这是一个麻烦，并且经常不能正确工作。

创建 web 应用程序最重要的原因是，它允许评委现场测试您的应用程序。只有一个视频演示，法官想知道该应用程序使用起来感觉如何。对于一个移动应用程序，法官没有办法测试它。幸运的是，有了 web 应用程序，它可以很容易地通过 Netlify、Heroku 或 Github Pages 等免费服务托管在互联网上。现场测试给评委带来了一种信心，让他们更加欣赏你的申请。从移动应用程序切换到 web 应用程序是我和我的团队所做的最重要的改变之一，因为它给我们带来了明显的成功。

移动用户界面看起来不漂亮——字体甚至不匹配(图片由作者提供)

3.关于实施的想法

我经常看到新团队犯的一个大错误是，他们太专注于让他们的应用程序功能化。作为初学者，他们认为他们必须开发全功能的应用程序，因此想出了一个简单的主意。然后，他们最终会花费黑客马拉松的大部分时间用 Firebase 构建一个认证系统，而不是拿出独特的功能。

这是一个巨大的错误，因为没有法官关心应用程序是否有认证系统。黑客马拉松的目标很容易被误解。因为它被称为 CS 活动，所以人们认为代码是最重要的。然而，黑客马拉松更多的是关于企业家精神和想法。有一个简单的原因:24 小时根本不足以构建一个功能性的应用程序。任何黑客马拉松裁判都知道这一点。真正令人印象深刻的不是这个应用是否有效，而是这个应用是否有潜力以独特的方式改变社会。只要应用程序不是完全伪造的，法官知道，如果团队愿意，他们可以花更长的时间让它发挥作用。那么这款应用将会在真实的市场中有价值。然而，一个在 24 小时内完全实现的低劣想法在任何市场上都不值钱。

这对人工智能开发者来说尤其重要，因为在如此短的时间内完全实现一个完整的模型是非常困难的。通常，光是训练一个模特就需要几个小时。人工智能开发人员也可能认为他们需要建立精确的模型，但这也是不正确的。大多数法官明白模型不会是准确的，但他们会被一个强有力的概念所打动，即使它并不完全像预期的那样工作。

我早期的一个项目有一个登录页面作为主要特征(图片由作者提供)

4.展示事项

每次黑客马拉松结束后，我都会浏览一下项目库，看看我要竞争的项目。既然有这么多项目，我就快速浏览一下他们的视频演示和文字介绍，看看项目好不好。如果报道很短，没有描述性，或者视频质量很差，没有脚本，我会跳过它。我还没有看到其中一个项目获胜。

现实是法官也是这样想的。要评判的项目那么多，也就是说不是所有的项目都能拿到满分的评审。因此，如果一个项目的描述写得很差，没有太多的技术细节，或者如果演示文稿有许多口吃，看起来像是一次完成的，他们为什么应该期待这个项目是好的呢？印象很重要，不仅是在黑客马拉松中，在日常生活中也是如此。作为一名人工智能开发人员，请确保将您的人工智能知识用于您的优势。你可能已经知道，能够向人们解释人工智能是非常令人印象深刻的。即使您无法在黑客马拉松期间完成模型的构建，您也可以绘制一个图表并解释实现的方式。这会让评委们惊叹不已，让你们看起来是最棒的团队。

虽然我们不能完全实现我们的模型，但是我们画了一个计划实现的图表(图片由作者提供)

确保在你的黑客马拉松期间，你分配了足够的时间来准备一个强有力的演示，详细说明你的项目的所有技术细节和你正在解决的问题。想到这么多伟大的、技术上复杂的项目仅仅因为演示糟糕而没有得到认可，这是令人难过的。然而，这是生活的一课，你展示自己和你的工作的方式就是一切。简而言之，这个项目看起来有多好就有多好。这是双向的，如果你的项目不是很好，你可以给它加油，让它看起来很棒。

我在第一次黑客马拉松上展示 Tickbird(图片由作者提供)

5.人工智能是新的元素

这是有原因的。2019 年底 2020 年初左右，几乎所有获奖项目都变成了 AI 项目。我在研究 2019 年获奖项目的时候，大部分获奖项目都没有使用 AI。但出于某种原因，就在我开始学习和使用人工智能的时候，其他人也开始学习和使用人工智能，到 2020 年夏天，任何想要获胜的项目都必须使用人工智能。这得益于 AI 教育和资源的广泛民主化。AI 是迄今为止黑客可以使用的最先进和技术最先进的框架或工具，所以如果你不使用它，你将无法竞争。

如果你不了解人工智能，我不认为这是真的，因为你正在研究数据科学，这不应该被阻止。这里有很多资源，包括所有关于 TDS 的文章，您可以将其作为学习的基础。花几个黑客马拉松做一些别人做过的基本的初级人工智能项目。虽然你可能不会赢，但你会获得重要的经验和学习机会，这将为你在不久的将来取得巨大的、持续的成功奠定基础。

我所有的项目(除了 Tickbird)都使用 AI(图片由作者提供)

最后的想法

对于任何参与 CS 或 AI 的人来说，黑客马拉松都是一项令人愉快的活动。周末和其他人一起创造惊人的项目，不仅可以获奖，还可以帮助你的职业追求，这是所有人工智能开发者都应该做的事情。即使你没有经验，也不要被吓倒，因为我完全不知道自己在做什么。虽然这个社区可能有些有毒和竞争，但如果你和你欣赏的人一起工作，你会很开心。所以，如果你不是黑客，试试看。如果你是一个初学黑客，看看我的技巧和故事，这样你也能成为一个赢家。感谢阅读。

如何走工程师之路——第一幕:VS 代码容器

原文：https://towardsdatascience.com/how-to-kaggle-the-engineer-way-act-1-vs-code-containers-b3279970c029?source=collection_archive---------19-----------------------

或者，如何设计出你的 Kaggle 开发环境:一部两幕剧

安托万·佩蒂特维尔在 Unsplash 上拍摄的照片

我的整个 Kaggle 工作，包括本文中讨论的内容，都发表在这里。

简介和动机

我是一名软件工程师，不久前决定开始新的挑战，成为一名数据科学家。作为其中的一部分，我开始参加 Kaggle 上的比赛(到目前为止我只参加了两次)。然而，在开始时，我遇到了一个相当麻烦的上升阶段。前两次比赛的大部分时间，我都在搭建我的开发环境。我只是无法忍受所有那些手动和重复的任务:下载数据集，硬编码路径，通过网站手动提交，最重要的是迷失在模型的所有输入和输出中(即跟踪版本)。

所以，我已经决定，如果我花一些时间在一开始就把事情做好，也就是说，采取软件工程的方式，我会为自己节省很多时间。

这是一个两幕的故事:

Act 1 是我用本地开发容器设置的 VS 代码，以模仿 Kaggle 内核。
第二幕是我设置 Google Colab 独立运行，但与 Kaggle 合作。

在第一幕结束时，你将能够在 Kaggle 上进行本地开发和训练，而无需任何手动步骤。第二幕将在下一篇文章中介绍。

第 1 幕—VS 代码中的本地集装箱化环境

在我参加的第一场比赛(一个图像分类问题)中，我只是通过在线使用 Kaggle 内核开始，因为我的笔记本电脑没有 GPU，训练模型需要花费我很长时间。

然而，很快内核就不够了:

首先，我想跟踪 GitHub 上的所有东西，所以我最终会在本地下载所有东西，提交等等。，每次我做出改变。在工具之间切换是不可接受的。
其次，我希望能够调试我的代码。我相信调试是一个强大的工具，这只是一个事实——对于那些喜欢使用 Vim 输入代码的人来说是一个“眼中钉”。

VS 代码远程概述:容器

如果你不想一遍又一遍地做设置步骤，容器是一个很好的工具。它们允许您定义一次配置步骤，并且可以在任何时候使用该环境。或者，更好的是，使用其他人预先定义的，例如 Kaggle。

你可以在这里找到关于如何使用 VS Code: Remote extension 在容器中工作的大量信息。

获取 Kaggle 容器图像

他们网站上的 Kaggle 内核正是以这种方式工作的——他们有一个预定义的容器映像，可以为每个用户的笔记本加载，从而隔离他们的环境。

对我们来说幸运的是，他们的照片被公开了。

这里他们有关于他们的 Python 图像的信息。
你可以偷看他们的 Dockerfile 里面，看看他们在里面安装了什么。
这些图片被发布在谷歌容器注册表的 CPU 专用或 GPU 上

配置 VS 代码

首先你需要安装 VS 代码远程开发扩展包。
其次，创建.devcontainer/devcontainer.json文件来存储您的环境定义(更多信息):

{
    "name": "Kaggle Dev CPU",
    "image": "gcr.io/kaggle-images/python", // Remember to pull latest before rebuilding.
    "extensions": [
        "ms-python.python",
    ],
    "settings": {
        "terminal.integrated.shell.linux": "/bin/bash",
        "python.pythonPath": "/opt/conda/bin/python"
    },
    "devPort": 8888,
    "shutdownAction": "none"
}

运行 VS 代码命令Remote-Containers: Rebuild and Reopen in Container。
你的 VS 代码窗口标题现在应该显示... [Dev Container: Kaggle Dev CPU] - ...。

模拟 Kaggle 环境

即使现在我已经用 VS 代码完成了开发，由于 GPU 的原因，我仍然希望在 Kaggle 上进行培训。而且，我再次希望必须做最少的手动任务来从本地运行切换到 Kaggle。所以，我决定在本地模拟 Kaggle 环境，这样脚本/笔记本甚至不会知道其中的区别。

我已经运行了同一个容器，所以我只需要模拟文件夹位置:

/kaggle/input:数据集映射到的文件夹。
/kaggle/working:存储输出的文件夹(以及笔记本/脚本的当前工作目录)。

要实现这一点:

在方便的地方创建input和working文件夹。我在我的工作区中选择了data/文件夹。
在devcontainer.json中为容器创建映射:

"mounts": [
    "type=bind,source=${localWorkspaceFolder}/data/input,target=/kaggle/input",
    "type=bind,source=${localWorkspaceFolder}/data/output,target=/kaggle/output",
],

上面的配置从路径/kaggle/input下的容器内我的本地工作区文件夹中映射了data/input文件夹——就像它在 Kaggle 上一样。它还映射了一个额外的文件夹data/output <-> /kaggle/output，这样笔记本就可以在容器之外保存数据。

创建一个脚本.devcontainer/setup.sh，它将在容器创建后由 VS 代码执行:

#!/bin/bash
mkdir /kaggle/working

不要忘记使它可执行:chmod +x .devcontainer/setup.sh。

并告诉 VS 代码运行它(在devcontainer.json):

"postCreateCommand": ".devcontainer/setup.sh",

从 Kaggle 获取数据集

起初，我会简单地手动下载数据集(到一个文件夹data/input)，并给它们起一个与 Kaggle kernel 相同的名字。然而，当我开始使用不同的附加数据集或附加库等时。，我开始寻找 Kaggle 是否有一些 API 或工具来自动化这个过程。幸运的是它做到了。

所以，我决定设置 VS 代码任务(你可以在这里了解更多)来运行下载数据集、文件等的命令。：

按照这里的描述获取您的 Kaggle API 凭证。
我把kaggle.json放在我的工作区文件夹中(确保把它添加到 **.gitignore** ！):
然后，我们需要确保它在容器的主目录中，以便能够在其中运行(不必切换到本地模式)。

添加一个名为.devcontainer/setup-mounted.sh的脚本(这个脚本将在代码挂载后运行):

#!/bin/bash
# Set up a link to the API key to root's home.
mkdir /root/.kaggle
ln -s /workspaces/kaggle/kaggle.json /root/.kaggle/kaggle.json
chmod 600 /root/.kaggle/kaggle.json

并告诉 VS 代码在附加到容器后运行这个脚本:

"postAttachCommand": ".devcontainer/setup-mounted.sh",

Kaggle API 设置完成后，添加 VS 代码任务(在.vscode/tasks.json):

"tasks": [
  {
      "label": "kaggle dataset download",
      "type": "shell",
      "command": "kaggle datasets download ${input:userName}/${input:datasetName} -p ${input:datasetName} --unzip --force",
      "options": {
          "cwd": "/kaggle/input"
      },
      "problemMatcher": []
  }
]

上面的任务将把格式为<username>/<dataset name>的数据集下载到目录/kaggle/input中，就像在 Kaggle 内核中一样。

运行特定于环境的逻辑(如有必要)

如果您的机器上只有 CPU，并且只能运行 2 个时期的训练，这可能是有用的，但是当在 Kaggle 上运行时，您希望运行完整的训练(例如，30 个时期)。

为此，我使用了一个只能在 VS 代码中设置的环境变量。

告诉 VS 代码在devcontainer.json中定义这个环境变量:

"containerEnv": {
    "KAGGLE_MODE": "DEV"
},

在代码中使用它来检查您是否正在本地运行:

import os
DEVMODE = os.getenv("KAGGLE_MODE") == "DEV"
print(f"DEV MODE: {DEVMODE}")
EPOCHS = 2 if DEVMODE else 30

这一步是我最不喜欢的，因为我必须在每台笔记本上重复这一步…然而，这只是在创建笔记本时进行的，所以仍然比每次希望在不同环境之间切换时都必须手动完成所有事情要好得多。

额外的

您可以为您的工作启用许多有用的扩展。在devcontainer.json中:

"extensions": [
    "ms-python.python",
    "ms-python.vscode-pylance",
    // Editing/dev process
    "streetsidesoftware.code-spell-checker",
    "wayou.vscode-todo-highlight",
    "janisdd.vscode-edit-csv",
    "davidanson.vscode-markdownlint",
    // VCS helpers
    "donjayamanne.githistory",
    "eamodio.gitlens"
],

并且不要忘记一堆对你的 VS 代码环境有用的设置(比如格式化和林挺你的代码)。

整个设置

您可以参考这些文件:

。devcontainer 文件夹。
。vscode 文件夹。
cassava_inference.py —示例 python 脚本。

进一步的改进

一些我没有做过的事情，但是在 Kaggle API 中是可能的:

它允许上传笔记本并运行它们(阅读更多)，所以你不必手动进入网站。
它还允许提交竞争(将在法案 2 中涉及)。
它还有其他一些可能对你有用的功能，比如列表排行榜等。

摘要

按照本文中描述的步骤，可以在本地机器上建立与 Kaggle 上非常相似的开发环境，并增加了版本控制系统和调试的额外功能(以及使用 IDE 的其他优势)。

这可以通过几个步骤来实现:

配置 VS 代码在 Kaggle 容器中开发。
设置类似 Kaggle 的目录结构，映射到本地机器的存储。
使用 Kaggle API 下载数据集和更多。
使用环境变量在代码中包含特定于环境的逻辑。

我希望这个设置可以帮助你在参加 Kaggle 比赛时减轻工作负担。

如何走工程师之路？第二幕:谷歌实验室

原文：https://towardsdatascience.com/how-to-kaggle-the-engineer-way-act-2-google-colab-2afa29ab35b8?source=collection_archive---------23-----------------------

或者，如何设计出你的 Kaggle 开发环境:两幕剧。

由 Unsplash 上的 krakenimages 拍摄的照片

这是该剧的第二幕，你可以在这里阅读第一幕。

我的整个 Kaggle 工作，包括本文中讨论的内容，都发表在这里。

序言/介绍

在故事的第一部分，我描述了如何为 Kaggle 设置带有容器的 VS 代码。对我来说，使用系统的方法是最重要的，不管是工程工作还是数据科学。因为这个信念，我在 Kaggle 比赛中的提升在很大程度上是为了将来节省时间。

在本文中，我将描述在我参加的第二次比赛中，我是如何改进我最初使用 VS 代码进行开发的方法的。如题所示，我转到了 Google Colab，但尽管如此，我仍然希望有适当的设置。

以前方法的缺点

在第一场比赛中，在用 Kaggle 容器设置了 VS 代码之后，我在 Kaggle 上进行本地开发和培训。我尽最大努力减少在不同环境间切换的重复性工作。然而，还有一些其他问题:

我仍然不得不在两种环境之间切换。
Kaggle 不允许使用数据集的特定版本(例如，当训练 5 倍时，我必须下载每一个并上传所有数据作为集合的数据集)。
包含依赖项是一件痛苦的事情——我不得不再次上传它们，作为一个数据集，然后映射它们的位置。

在本文中，我将描述我如何使用 Google Colab 来克服所有这些麻烦，并获得一些额外的好处，如更好的 GPU 和更好的运行时。

第 2 幕——谷歌与 GitHub 的 Kaggle 合作实验室

Google Colab 是一个为您的数据科学工作获取免费 GPU 的好方法。只需支付少量额外费用，你就可以获得配备 V100/P100 GPU 的 Colab pro，这比你在 Kaggle 上获得的 T4 GPU 快几倍。它还有其他不错的功能，比如映射 Google Drive 文件、使用 GitHub 等等——如下所述。

我选择这将是对 Kaggle 在训练速度和易用性上的改进，并且我不需要在本地开发。随着更多的研究，看起来我甚至不需要离开 Colab 环境，在里面做任何事情(有点像不离开我的公寓)。

在 Google Drive 中为 Colab 设置 GitHub

我做的第一件事是确保我仍然可以使用 Git，并且不必在环境之间切换。

糟糕的方法:你可以直接从你的私人或公共回购中打开文件，编辑它并提交回来，正如这里的所描述的。但是，有几个问题:

提交仅针对一个笔记本，即 Colab 仅在一个笔记本的上下文中工作。
由于上述原因，您不能拥有依赖关系。

好消息是，Colab 允许你安装你的 Google Drive 。一旦它被映射，它就是运行 Colab 的 VM 实例上的一个常规文件夹。

那么，为什么不克隆你的 GitHub repo 呢？

创建 GitHub 个人访问令牌来代替您的密码— link 。
准备一些临时的笔记本，姑且称之为terminal.ipynb，存储在你的 Google Drive 中，并与你的驱动器进行映射:

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

在 Colab Pro 中，您可以打开一个终端实例— link 。
在任何 Colab 中，您都可以从笔记本单元格中运行终端命令:

%%bash
cd /content/drive/MyDrive/
git clone https://<username>:<PAT>@github.com/<username>/<repo name>.git
cd <repo name>

至此，您已经将所有代码 git 克隆到您的 Google Drive 中，并且您可以在其中打开任何笔记本。我还在笔记本中设置了一些代码来使用 Git，但是我最终只使用了终端命令。

唯一的缺点是，你必须在每个笔记本的开头映射 Google Drive，但我认为这相对来说没什么问题。

try:
    from google.colab import drive
    drive.mount("/content/drive")
    %cd /content/drive/MyDrive/Colab\ Notebooks/kaggle
except:
    print("Not in Colab")

我为自己创建了一个模板笔记本，我复制它作为任何其他笔记本的基准。

注意:一个额外的很酷的技巧，不需要每次都给你的驱动器 Colab 授权，你可以像这里描述的一样为每个笔记本设置自动挂载。

为 Kaggle 设置

下一步是设置 Kaggle ( /kaggle/input、/kaggle/working)和 Kaggle API secrets 等所需的所有目录。这个设置必须在每个笔记本的开头完成，所以它必须作为脚本导入和函数调用。

您不能在 Colab 中真正编辑 Python 脚本，但是您可以让您的笔记本写入文件:

%%writefile setup_colab.py
def setup_colab_for_kaggle():
    ...

在该脚本中，让我们执行必要的设置:

kaggle_dir = Path("/kaggle")
drive_content_dir = Path("/content/drive/MyDrive/kaggle")
(kaggle_dir / "working").mkdir()
target_content_dirs = ["input", "output"] + ([] if local_working else ["working"])
for content_dir in target_content_dirs:
    (kaggle_dir / content_dir).symlink_to(drive_content_dir / content_dir)

设置 Kaggle API 令牌。将你的kaggle.json文件上传到你的硬盘上(我把它放在了 repo 文件夹中，虽然你也这样做，确保把它添加到 **.gitignore**)。

drive_sources_dir = Path("/content/drive/MyDrive/Colab Notebooks/kaggle")
kaggle_config = Path.home() / ".kaggle"
(kaggle_config / "kaggle.json").symlink_to(drive_sources_dir / "kaggle.json")

您可以使用相同的方法来设置 Weights & Biases API 键或任何其他键。
在该文件中有任何其他设置代码。

有相当多的附加逻辑，所以完整的代码在笔记本和输出脚本中。

现在，每台笔记本只需导入代码并运行设置功能:

from setup_colab import setup_colab_for_kaggle
setup_colab_for_kaggle(check_env=False, local_working=True)

使用我的脚本，输出将告诉我们最终的设置:

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).
/content/drive/MyDrive/Colab Notebooks/kaggle
Content of Drive Kaggle data dir (/content/drive/MyDrive/kaggle): ['/content/drive/MyDrive/kaggle/input', '/content/drive/MyDrive/kaggle/working', '/content/drive/MyDrive/kaggle/output']
Content of Kaggle data dir (/kaggle): ['/kaggle/working', '/kaggle/output', '/kaggle/input']
Content of Kaggle data subdir (/kaggle/input): ['/kaggle/input/vinbigdata']
Content of Kaggle data subdir (/kaggle/output): ['/kaggle/output/vbdyolo-out']
Content of Kaggle data subdir (/kaggle/working): []
Content of Kaggle config dir (/root/.kaggle): ['/root/.kaggle/kaggle.json']
Loaded environment variables from .env file: ['WANDB_API_KEY'].

酷，在这一点上，所有的设置都是模仿 Kaggle 内核的设置，以及前一篇文章中描述的本地环境，所以笔记本在两个环境之间切换时不会知道区别(如果你想知道的话)。但是，让我们将它设置得更好，这样我们就根本不用切换了。

从 Kaggle 获取数据

首先，我会将数据下载到本地，然后上传到我的驱动器，最后它会被映射到正确的位置，如上所示。然而，这并不太实际，最重要的是——Colab 从 Google Drive 中访问文件非常慢。事实证明，每次将数据集下载到 Colab 虚拟机的本地存储中要快得多。在你的笔记本上有:

!kaggle competitions download vinbigdata-chest-xray-abnormalities-detection -f train.csv -p {INPUT_FOLDER_DATA} --unzip
!kaggle datasets download xhlulu/vinbigdata-chest-xray-resized-png-1024x1024 -p {INPUT_FOLDER_PNG} --unzip

通过 Google Drive 训练有效网络 B3 的一个时期需要大约 1 小时，而下载 8GB 需要大约 8 分钟，训练一个时期需要大约 15 分钟。速度提高了 4 倍，不错！

版本化数据集和模型

这一节将阐明为什么我们需要设置 Kaggle API 令牌。

由于我对 Kaggle 竞赛的方法是系统的和有条理的，我开始思考如何组织我使用的数据和产生的模型。有点像模型和数据的 Git。事实上，我发现有数据版本控制和其他一些工具。然而，对于 Kaggle 比赛，更简单的方法就可以了。一种选择是只存储在文件夹中，但这不是很整洁，数据可能会丢失，而且很难给每个版本附加注释。所以我选择把所有东西都作为 Kaggle 数据集偷走。

这可以像在每个笔记本末尾上传文件一样简单:

将您想要上传的文件放在一个文件夹中(比如说，yolo_pred/文件夹包含 YOLO 预测和yolo.pt文件)。
创建dataset-metadata.json文件——由 Kaggle API 解析和理解的东西:

with open(Path(folder_path) / "dataset-metadata.json", "w") as f:
    json.dump({
        "title": dataset_name,
        "id": f"{user_name}/{dataset_name}",
        "licenses": [{ "name": "CC0-1.0" }]
    }, f, indent=4)

使用 Kaggle API 命令在笔记本执行(如模型训练)结束时上传文件:如果是第一次:

!kaggle datasets create -p {OUTPUT_FOLDER_CUR} -r zip

否则:

!kaggle datasets version -m "{version_message}" -p {OUTPUT_FOLDER_CUR} -r zip

现在，在您的后处理中，您可以下载特定版本(特定的训练模式及其输出)用于提交:

!kaggle datasets download "username/dataset-name" -v {yolo_version} -p {version_data["path"]} --unzip --force

剧透:虽然，这在官方 Kaggle API 中不起作用——见下一段。

修复 Kaggle API 以满足我们的需求

作为一个偏离主题的话题，我需要在 Kaggle API 中添加/修复一些特性。推动这一点是因为在某一点上，我不能重现良好的结果，我获得了一些早期版本。那时，我已经对所有的东西进行了版本控制，并且记录了所有的设置，所以这几乎是不可能的……但是它正在发生。然后我注意到我选择的任何版本都得到了相同的结果。结果是，嗯，Kaggle API 默默地忽略了我的版本请求，总是下载最新的版本。

因此，他们的 GitHub repo 提到他们欢迎改变，因此我决定自己解决问题(我非常需要竞争的功能)。

首先，我需要确保 Kaggle 会下载一个特定的版本。我的 PR 在这里。
第二，我已经准备好了，所以我做了一些修正，使得比赛中的一个文件可以正确下载(整个数据集大约 200GB，我只下载了带有火车标签的.csv文件，并从另一个数据集获得了大约 8GB 的相同图像)。我的 PR 这里。

不过，很明显，将变更加入 Kaggle API 的过程很慢(他们有一个私有的回购协议，一些开发人员必须去合并变更……)。所以，这两个改动都暂时在我这里的分叉。

您可以从您的 Colab 笔记本上安装带有我的补丁的 Kaggle API，如下所示:

!pip install -U git+https://github.com/Witalia008/kaggle-api.git@witalia-main

臣服于 Kaggle

对于我参加的特定比赛，提交的只是一个.csv文件，所以我只需在我的后处理笔记本的末尾运行以下命令:

!kaggle competitions submit \
    vinbigdata-chest-xray-abnormalities-detection \
    -f {WORK_FOLDER}/submission.csv \
    -m "{submission_message}"

然后检查提交的结果:

!kaggle competitions submissions vinbigdata-chest-xray-abnormalities-detection

整个设置

您可以参考具有完整实现的文件:

setup-colab-for-ka ggle . ipynb—包含使用 Git 的代码以及 setup-colab 逻辑的笔记本。
setup_colab.py —设置脚本(由上述笔记本产生)，包含映射目录、配置密钥等功能。
template-colab-ka ggle-nb . ipynb—需要设置的模板笔记本，我将它用作其他笔记本的基础。
vbd-yolov5.ipynb —下载数据集、训练模型并将输出存储为数据集的示例笔记本。
vbd-postprocess-yolo . ipynb—示例笔记本，它下载以前笔记本输出的多个版本作为数据集，集成它们，并提交给 Kaggle。

进一步的改进

这种方法的问题实际上是失去了 IDE 的全部功能(比如，调试，或者处理笔记本之外的其他文件格式)。笔记本电脑中 pdb 的调试能力有限，人们可以通过终端用 Vim 或 Nano 编辑文件，但这不是很好。但我听说有一种方法可以将 VS 代码连接到 Google Colab ( link )，所以我一定会尝试一下，也许会有续集。

结语/总结

本文中描述的设置是对 Kaggle 开发环境的进一步改进，只需几个简单的步骤，就可以下载数据、进行数据科学工作、存储模型/输出并提交给竞赛，而无需离开 Colab 笔记本。

这可以通过以下步骤实现:

安装 Google Drive 并通过终端命令操作。
像在本地机器上一样克隆 Git repo 和跟踪文件。
在每个笔记本的开头创建一个脚本来运行设置命令，以模拟 Kaggle 环境、设置 API 键等等。
使用 Kaggle API 将数据集和比赛数据从笔记本下载到 Colab VM。
使用 Kaggle API 将模型版本及其输出存储为数据集。
使用 Kaggle API 直接从笔记本提交竞赛。

我希望你会发现这个设置很有用，它可以让你花更少的时间来配置一切，而花更多的时间来解决 Kaggle 比赛。祝你好运:)

如何在没有专有数据的情况下启动人工智能项目

原文：https://towardsdatascience.com/how-to-kickstart-an-ai-venture-without-proprietary-data-13d1502051f2?source=collection_archive---------11-----------------------

AI 创业公司有个鸡&蛋的问题。下面是解决的方法。

几年前，我了解到银行每年因信用卡诈骗损失数十亿美元。更好地检测或预测欺诈将具有难以置信的价值。所以我考虑说服一家银行分享他们的交易数据的可能性，希望建立一个更好的欺诈检测算法。不足为奇的是，没有一家大银行愿意分享这样的数据。他们觉得最好雇佣一个数据科学家团队在内部解决这个问题。我的创业想法很快夭折了。

尽管围绕人工智能有着巨大的创新和创业机会，但对创业者来说，闯入人工智能可能是一项艰巨的任务，因为他们甚至在开始之前就面临着先有鸡还是先有蛋的问题，这是现有公司不太可能应对的问题。我相信具体的策略可以帮助企业家克服这一挑战，创造成功的人工智能驱动的企业。

AI 创业中的鸡和蛋的问题是什么？

今天的人工智能系统需要在大数据集上进行训练，这对企业家来说是一个挑战。拥有相当大客户群的老牌公司已经拥有了一系列数据流，他们可以从中训练人工智能系统，开发新产品并增强现有产品，生成额外的数据，并冲洗和重复(例如，谷歌地图拥有超过 1B 的每月活跃用户和超过 20 的数据))。但对于创业者来说，对数据的需求带来了一个先有鸡还是先有蛋的问题——因为他们的公司还没有建成，他们没有数据，这意味着他们不能那么容易地创造一个 AI 产品。

此外，数据不仅是人工智能入门所必需的，它实际上是人工智能性能的关键。研究表明，虽然算法很重要，但数据更重要。在现代机器学习方法中，与具有更多或更少数据的相同算法之间的性能差异相比，各种算法之间的性能差异相对较小( Banko 和 Brill 2001 )。

有几种策略可以帮助企业家解决这个先有鸡还是先有蛋的问题，并获取他们进入人工智能领域所需的数据。

研究表明，虽然算法很重要，但数据更重要。

克服先有鸡还是先有蛋问题的 5 种方法

从提供一种没有人工智能也有价值的服务开始，这种服务产生数据

虽然数据确实需要先于人工智能产品，但数据不需要先于所有产品。企业家可以从创建一项服务开始，这项服务不是基于人工智能的，而是解决客户问题并在此过程中生成数据。这些数据稍后可以用于训练一个人工智能系统，该系统可以增强现有服务或创建相关服务。

例如，脸书早期没有使用人工智能，但它仍然提供了一个客户希望加入的社交网络平台。在这个过程中，脸书生成了大量数据，这些数据反过来被用于训练人工智能系统，这些系统帮助个性化新闻订阅，并使运行极具针对性的广告成为可能。尽管一开始并不是人工智能驱动的服务，但脸书已经成为人工智能的大量用户。

类似地，insur tech 初创公司 Lemonade 最初没有数据来在第一天建立复杂的人工智能能力。然而，随着时间的推移，Lemonade 已经建立了人工智能工具来创建报价、处理索赔和检测欺诈。今天，他们的人工智能系统处理 96%的索赔的“第一份损失通知”，并在三分之一的案件中管理完整的索赔解决方案，而没有任何人工参与。这些人工智能能力是使用多年运营产生的数据构建的。

2.与拥有专有数据集的非科技公司合作

企业家可以与拥有专有数据集但缺乏内部人工智能专业知识的公司或组织合作。这种方法在很难创建一种产品来生成您的 AI 应用程序所需的数据(如关于患者测试和诊断的医疗数据)的情况下特别有用。在这种情况下，您可以与医院或保险公司合作，以获取匿名数据。

相关的一点是，你的 AI 产品的训练数据可以来自潜在客户。虽然这在医疗保健和金融等受监管行业更难做到，但制造业等其他行业的客户可能更愿意接受这一点。作为回报，你可能需要提供几个月的人工智能产品的独家使用权，或者提前获得未来产品的功能。

这种方法的一个缺陷是，潜在的合作伙伴可能更喜欢与老牌公司合作，而不是那些不太知名和不太受信任的小公司(尤其是在后 GDPR 和剑桥分析时代)。因此，业务发展将会很棘手，但这种策略仍然是可行的，尤其是当知名科技公司尚未追逐你想要的合作伙伴时。

家族企业中的企业家可能已经从他们现有的企业中获得了大量潜在的数据。这也是一个很好的选择。

3.众包你需要的数据

根据所需数据的种类，企业家可以通过众包获得数据。当数据可用但没有被很好地标记时(例如互联网上的图像)，众包可能是获得这种数据的特别合适的方法，因为标记是一项非常适合由众包平台上的大量个人快速完成的任务。亚马逊 Mechanical Turk 和 Scale.ai 等平台经常被用来帮助生成带标签的训练数据。

例如，考虑谷歌对验证码的使用。虽然它们服务于一个重要的安全目的，谷歌同时使用它们作为一个众包图像标签系统。每天“数百万用户是谷歌分析预处理团队的一部分，他们免费验证机器学习算法。”

一些产品的工作流允许客户在使用产品的过程中帮助标记新数据。事实上，主动学习的整个子领域都集中在如何交互式地查询用户以更好地标记新的数据点。例如，考虑一个生成风险警报的网络安全产品和一个工作流，在该工作流中，运营工程师解决这些警报，从而生成新的标记数据。类似地，像 Pandora 这样的产品推荐服务使用 upvotes 和 downvotes 来验证推荐的准确性。在这两种情况下，您可以从 MVP 开始，随着客户提供反馈，MVP 会随着时间的推移而不断改进。

4.利用公共数据

在你下结论说你需要的数据不可用之前，再仔细看看。公开可用的数据比你想象的要多。甚至出现了数据市场。虽然公开可用的数据(以及由此产生的产品)可能不太容易防御，但您可以通过其他服务/产品创新来建立防御，例如创建卓越的用户体验，或者像 Zillow 一样大规模结合离线和数字数据(该公司大规模使用离线公共市政数据作为其创新的在线房地产应用的一部分)。人们还可以将公开可用的数据与一些专有数据结合起来，这些数据可以随着时间的推移生成，也可以通过合作、众包等方式获得。

加拿大蓝点公司使用各种数据来源，包括公开数据，以便在正式报告之前发现新出现疾病的爆发，并预测下一次爆发将蔓延到哪里。BlueDot 使用“官方公共卫生组织的声明、数字媒体、全球机票数据、牲畜健康报告和人口统计数据”，以及其他数据来源。这家公司在 2019 年 12 月 30 日检测到新冠肺炎疫情)，比世卫组织的报告早了 9 天。

除了数据之外，还可以选择使用公开提供的预先训练的 ML 模型，这些模型可以根据您的迁移学习需求进行定制。迁移学习包括使用为一项任务开发的模型作为另一项任务的起点。例如，在数百万幅图像上训练的深度学习模型可以是更特定领域的图像识别模型(例如，识别花)的起点。这种方法通常用于图像识别和自然语言处理，可以显著减少对新数据的需求。

公开可用的数据比你想象的要多。甚至出现了数据市场。

5.反思对数据的需求

诚然，商业世界中大多数实用的 AI 都是基于机器学习的。并且该 ML 的大部分是监督 ML(这需要大的标记训练数据集)。但是，许多问题可以通过其他不依赖于数据的人工智能技术来解决，例如强化学习或专家系统。

强化学习是一种 ML 方法，其中算法通过测试各种动作或策略并观察这些动作的回报来学习。本质上，强化学习使用实验来弥补标记训练数据的缺乏。谷歌围棋对弈软件 Alpha Go 的最初迭代是在大型训练数据集上训练的，但下一个迭代 AlphaZero 是基于强化学习的，没有训练数据。然而，AlphaZero 击败了 alpha Go(alpha Go 本身击败了围棋世界冠军 Lee Sedol)。

强化学习广泛应用于在线个性化。在线公司经常测试和评估多个网站设计、产品描述、产品图片和定价。强化学习算法探索新的设计和营销选择，并根据用户的反应快速学习如何个性化用户体验。

另一种方法是使用专家系统，这是一种简单的基于规则的系统，通常将专家日常使用的规则整理成文。虽然专家系统很少能在复杂任务(如医疗诊断或图像识别)中击败训练有素的 ML 系统，但它们可以帮助打破鸡和蛋的问题，并帮助您开始。例如，虚拟医疗保健公司 Curai 使用来自专家系统的知识来创建临床简介，然后使用这些简介作为 ML 模型的训练数据(以及来自电子健康记录和其他来源的数据)。

需要明确的是，并不是每一个智力问题都可以被视为强化学习问题，或者通过专家系统的方法来解决。但是当训练数据的缺乏阻碍了有趣的 ML 产品的开发时，这些是值得考虑的。

企业家最有可能开发出一致的专有数据流，如果他们开始提供一种没有人工智能也有价值的服务，并产生数据，然后用这种数据来训练人工智能系统。然而，这种策略需要时间，并且不一定适合所有情况。根据初创公司的性质和所需数据的种类，与拥有专有数据集、众包(标签)数据或利用公共数据的非科技公司合作可能会更好。或者，企业家可以完全重新思考对数据的需求，并考虑采取强化学习或专家系统的方法。

Kartik Hosanagar 是沃顿商学院的教授，企业家( Jumpcut Media 和 Yodle 的创始人)，著有A Human ' s Guide to Machine Intelligence，Wharton ' s AI for Business Initiative的负责人。推特:@khosanagar。

鸣谢:感谢沃顿商学院人工智能商业倡议研究助理莫尼莎·古拉巴尼(Monisha Gulabani)所做的大量研究、编辑以及构思和生成上述数字。感谢 Zetta Venture Partners 的 Jocelyn Goldfein 提供的许多有用的建议，以及沃顿商学院学生 Anirudh Viswanathan 的反馈。感谢 Quentin Demersay 建议将公开可用的 ML 模型(以及迁移学习)添加到策略列表中。所有的错误都是我自己的。

如何知道用哪种统计检验进行假设检验？

原文：https://towardsdatascience.com/how-to-know-which-statistical-test-to-use-for-hypothesis-testing-744c91685a5d?source=collection_archive---------1-----------------------

何时使用哪种检验——T 检验、卡方检验、方差分析

图片由穆罕默德·哈桑来自 Pixabay

统计学是数据科学和机器学习不可或缺的一部分。统计学是数学的一个分支，指的是以数学方程的形式将变量之间的关系形式化。它试图找到变量之间的关系来预测结果。统计学是关于，包括收集分析，解释，介绍和组织的研究。

有很多统计测试来衡量变量内部或变量之间的关系。在一个数据科学项目中，数据科学家的脑海中经常会出现一个问题，即对于什么样的数据或变量以及何时使用哪种统计技术。在本文中，您可以了解对几种类型的统计测试的基本理解，以及何时以及如何对您的数据集使用它们。

单样本测试与双样本测试:

图片来自 stux 来自 Pixabay

一个样本测试是一个统计过程，考虑一个列或特征的分析。它可以是百分比分布分析(分类变量)或均值分析(连续变量)。

另一方面，双样本检验是比较或计算两个随机变量之间关系的统计过程。

单一样本测试:

如上所述，单样本检验涉及一个随机变量的假设检验。

均值的单样本 T-检验:对于一个数值或连续变量，您可以使用均值的单样本 T-检验来检验您的总体均值是否不同于一个常数值。例如，一家跨国公司有兴趣测试他们员工的平均年龄是 30 岁。他们可以使用单样本 t 检验来得到结果。

Here, t-stat follows a t-distribution having n-1 DOF
x̅: mean of the sample
µ: mean of the population
S: Sample standard deviation
n: number of observations

比例的一次样本 T 检验:一次样本比例检验用于估计总体的比例。对于分类变量，可以使用比例的单样本 t 检验来检验类别的分布。

p̂: Observed probability of one certain outcome occurring
*p0*: hypothesized probability
*n*: number of trials.

双样本测试:

在假设检验中，双样本检验是对两个随机变量的数据进行的，每个随机变量都来自一个独立的总体。该测试可用于测试两个样本之间的统计显著性差异。

一旦你弄清楚了随机变量的用途和数据类型，基本上有 3 大类数据类型组合:

两个连续变量
一个连续变量和另一个分类变量
两个分类变量

两个连续变量之间的统计检验:

当您的实验试图找出两个连续变量之间的关系时，您可以使用相关统计测试。

皮尔逊相关:

皮尔逊相关是一种统计技术，用于测量两个线性相关变量之间的关系程度。其系数的取值范围在[1，-1]之间，是否 1 表示正相关，-1 表示负相关，0 表示不相关。

斯皮尔曼等级相关性；

两个随机变量之间的 Spearman 秩相关等于两个变量的秩值之间的 Pearson 相关。它可以用来度量两个连续随机变量之间的单调关系。其系数的取值范围在[1，-1]之间，是否 1 表示正相关，-1 表示负相关，0 表示不相关。

一个连续变量和另一个分类变量之间的统计检验:

t 检验:

当您的实验试图进行比较或找出一个分类(有两个类别)和另一个连续变量之间的差异时，您需要进行双样本 T 检验，以找出两个变量之间的显著差异。

方差分析:

当您的实验试图进行比较或找出一个分类(两个以上的分类)和另一个连续变量之间的差异时，您可以使用 ANOVA(方差分析)测试。

两个分类变量之间的统计检验:

卡方检验:

当您的实验试图进行比较或找出两个分类随机变量之间的差异时，您可以使用卡方检验来测试统计差异。

结论:

(图片由作者提供)，何时使用何种统计技术

在本文中，我们讨论了统计技术，以及何时使用何种检验来推导随机变量之间或之内的关系或结论。使用上面讨论的统计技术，您可以评估一个变量对另一个变量的影响。

两个连续变量之间的相关性用来衡量它们之间的关系。所有其他统计检验都可以用来比较两个随机变量，p 值可以用来接受或拒绝零假设。

参考资料:

[1]统计解决方案:https://www . Statistics Solutions . com/correlation-Pearson-Kendall-spearman/

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

https://satyam-kumar.medium.com/membership

感谢您的阅读

如何用人工智能标注文本分类训练数据

原文：https://towardsdatascience.com/how-to-label-text-classification-training-data-with-ai-11ed11a5e893?source=collection_archive---------23-----------------------

用零射击变压器模型标注你的训练数据。然后，使用标记的数据微调一个小的监督模型

作者图片

没错！使用我上个月提出的方法，在没有人工标注器的情况下标注文本分类训练数据是可能的。然后，您可以使用标记的数据来训练监督模型。那么，先有什么——“先有鸡还是先有蛋”，或者类似地，“带人工智能标签的训练数据还是监督模型”？但是这个谜题有一个解决方案——那就是零射击模型。

零镜头文本分类模型需要两个输入:文本和一组标签。然后，他们输出每个标签的分数。因此，他们可以将文本分类为任意类别，而无需任何微调。目前，在 Hugging Face 的模型分发网络上有可用的大型零镜头文本分类转换器模型，只需几行代码就可以实现。

在本文中，我将首先从较高的层面简要概述该系统，以及我为展示其功能而进行的实验的结果。我已经发表了一篇完整的文章，更深入地涵盖了这两个方面，你可以在我的网站上找到，或者发表在走向数据科学上。然后，我将继续讨论如何通过重现我上一篇文章中描述的主要实验来用 Python 代码实现这个系统。

过程

整个系统非常简单。系统的输入是未标记的文本数据和标签列表。然后，输出是一个小的监督模型，将文本分类到给定的标签中。该过程中的关键组件是一个大型零镜头文本分类模型。该模型从未标记的数据集中获取文本片段，并输出每个标记的分数。具有最高分数的标签被分配给该段。最后，新标记的案例用于微调小型监督模型。

作者图片

实验总结

我做的主要实验显示了有希望的结果。首先，我使用了一个名为斯坦福情感树库 V2 (SST2*) 的二进制文本分类数据集。然后，使用名为“ facebook/bart-large-mnli 的零镜头文本分类模型对各种数量的训练案例进行标注，对评测案例的准确率为 88.19%。接下来，新标记的训练案例用于微调朴素贝叶斯文本分类模型。下面是朴素贝叶斯模型在 SST2 评估数据集上的精度。经过 8000 个训练样本，取得了 76.03%的准确率。

【The SST2 数据集是胶水 数据集的一部分，该数据集属于cc-by-4.0许可证

最终，朴素贝叶斯模型实现了与最流行的零镜头文本分类转换器模型大致相同的准确性，该模型可在 Hugging Face 的模型分发网络上获得，名为“typeform/distilbert-base-un cased-mnli”但是当然，与 Transformer 模型相比，朴素贝叶斯模型只需要运行所需资源的一小部分。

意义

实验表明，在没有标记数据的情况下，训练一个小的监督文本分类模型是可能的。因此，通过使用这种方法，可以在没有人工标注器的情况下对训练数据进行标注。然后，带标签的训练数据可以用来微调一个更小的模型，更容易在生产中使用。这为使用监督模型打开了大门，这些模型在过去由于缺乏标记的训练数据而无法训练。

履行

下载零射击模型

首先，我们将使用 Hugging Face 的 Transformers 库来加载一个零镜头文本分类 Transformer 模型。让我们开始安装吧。

pip install transformers

然后，我们将为我们想要的模型导入并创建一个管道对象。在这种情况下，我们将执行一个名为“零任务分类”的任务，我们将使用一个名为“facebook/bart-large-mnl”的模型我还包含了自动检测和使用可用 GPU 的代码。

from transformers import pipeline 
import torch 

# Check to see if a GPU is available 
device = -1
if torch.cuda.is_available():
    device = torch.cuda.current_device() task = "zero-shot-classification" 
zero_shot_model = "facebook/bart-large-mnli" 
zero_shot_classifier = pipeline(task, zero_shot_model, device=device)

做预测

我将简要讨论如何使用零炮模型进行预测。对于这些例子，我们将预测我自己创建的电影评论的情绪。首先，我们需要定义我们将使用什么标签。因此，我们将标签设置为“阳性”和“阴性”记住，在我们的模型开始预测之前，不需要微调。

labels = ["positive", "negative"] 
positive_text = "Wow I loved that movie so much!"

我们现在可以向分类器提供标签和文本来产生预测。

positive_prediction = zero_shot_classifier(positive_text, labels) print(positive_prediction)

结果:{'sequence ':'哇，我太喜欢那部电影了！'，'标签':['正'，'负']，'分数':[0.9640112519264221，0.03598877415060997]}

输出是一个有三个键的字典:序列、标签和分数。序列键包含输入的文本。标签键包含按分数顺序排列的标签。最后，scores 键包含从最高到最低的分数，其中所有分数的总和等于 1。

我们可以隔离顶部标签，如下所示。

positive_result = positive_prediction["labels"][0] print(positive_result)

结果:阳性

数据

让我们讨论如何收集数据，然后我们可以标记并用于训练一个小的监督模型。为了简单起见，我们将使用 ss T2——我在过去的文章中描述的实验所用的相同数据集。该数据集可在 Hugging Face 的数据集分发网络上获得，包含被标记为“正面”或“负面”的电影评论。

我们将从安装拥抱脸的数据集库开始。

pip install datasets

现在，我们将导入一个名为“load_dataset”的函数顾名思义，它允许我们从拥抱脸的网络中获取数据集。它需要三个输入，数据集的名称、数据实例和分割。在这里，数据集是一个更大的数据集“glue”的子集因此，load_dataset 函数的第一个和第二个参数分别是“glue”和“sst2”。然后，对于 split 参数，我们将指明是否希望下载训练或验证数据以及实例的数量。

from datasets import load_dataset # Loading 8000 training cases 
train_data = load_dataset('glue', 'sst2', split="train[:8000]")

# Loading all 872 validation cases
eval_data = load_dataset('glue', 'sst2', split="validation[:]")

我们来探究一下数据。train_data 和 eval_data 对象都属于“Dataset”类型，这是一个可迭代的对象，其中每个事例都包含一个字典。字典包含三个关键字:句子、标签和 idx。句子关键字包含特定案例的文本。然后，标签键指示格是“正”还是“负”，其中整数“1”指示格是正的，而“0”指示格是负的。最后，在 idx 键下，每个都包含自己唯一的整数值。

for i in range(0, 2):
    print(eval_data[i]) 
    print(eval_data[i]["label"]) 
    print("-------------")

{ '句子':“这是一次迷人的、常常令人感动的旅程。"，' label': 1，' idx': 0}

— — — — — — -

{ '句子':'不屈不挠的凄凉和绝望'，'标签':0，' idx': 1}

— — — — — — -

标记和格式化数据

我们可以为训练数据生成自己的标签，而不需要使用零镜头模型的人工注释器。下面的代码迭代训练案例，对于每一个案例，它都使用零命中率模型来生成预测。结果保存在元组列表中，其中每个元组的第一个索引包含案例的文本数据，第二个索引包含字符串形式的标签。这种格式与我们即将训练的 TextBlob 朴素贝叶斯分类器所需的格式相匹配。

train_cases =[] 
labels = ["positive", "negative"] 
for case in train_data: 
    result = zero_shot_classifier(case['sentence'], labels) 
    label = result["labels"][0] 
    result = (case['sentence'], label) 
    train_cases.append(result)

我建议你用一个叫 tqdm 的 Python 包给循环添加一个进度条。只需对上面的代码做一些小的修改，就可以实现这一点。

# In terminal
pip install tqdm# Python code start
from tqdm import tqdmtrain_cases =[] 
labels = ["positive", "negative"] 
for case in tqdm(train_data): 
    result = zero_shot_classifier(case['sentence'], labels) 
    label = result["labels"][0] 
    result = (case['sentence'], label) 
    train_cases.append(result)

仅此而已，我们只是用了一个 AI 模型来标注我们的数据！我们使用的零炮模型对同一数据集的评估数据的准确率为 88.19%，因此尽管不完美，但该训练仍可用于训练监督模型。

让我们将评估数据转换成适当的格式。我们将使用实际的标签，因为这样可以更好地表明最终模型的准确性。

eval_cases = [] 
for case in tqdm(eval_data): 
    label = "positive" if case["label"] else "negative" 
    result = (case['sentence'], label) 
    eval_cases.append(result)

训练朴素贝叶斯分类器

现在让我们使用 TextBlob 创建一个朴素贝叶斯分类器。这种分类器使用“传统的”NLP 技术，并依靠概率进行预测。它比变压器模型等深度学习方法需要的资源少得多。我们可以使用名为 TextBlob 的 Python 包轻松创建一个朴素贝叶斯分类器。TextBlob 构建在著名的 Python 包 NLTK 之上，使其更易于使用，在 GitHub 上获得了 7000 多颗星的好评，下载量超过 1000 万次。

pip install textblob

我们现在可以从 textblob 包中导入一个名为 NaiveBayesClassifier 的类，如下所示。

from textblob.classifiers import NaiveBayesClassifier

但是，在我们开始训练分类器之前，我们需要从 NLTK 下载一个名为“punkt”的标记器。记住，TextBlob 是建立在 NLTK 之上的，所以有时候，我们在使用 TextBlob 的时候，必须从 NLTK 下载特定的资源。另外，当安装 TextBlob 时，NLTK 也会被安装，所以不需要 pip 安装 NLTK。让我们导入 NLTK，下载 punkt。

import nltk 
nltk.download('punkt')

从这里开始，我们可以用一行代码创建和训练一个分类器，如下所示。

classifier = NaiveBayesClassifier(training_cases)

就是这样！我们现在已经成功地训练了一个朴素贝叶斯分类器，而没有任何先前的标记数据！

评价

我们现在可以用如下所示的一行代码来评估模型，以确定它在评估集上的准确性。

accuracy = classifier.accuracy(eval_cases) 
print(accuracy)

结果:0.7603211009174312

就这样，我们的模型有 76%的准确率！

分类

让我们讨论如何使用朴素贝叶斯分类器进行预测。下面的代码检索任意文本的顶部标签。

prob_dist = classifier.prob_classify("I loved this movie") print(prob_dist.max())

结果:阳性

我们也可以得到任何标签的分数。分数介于 0 和 1 之间，其中 1 具有高确定性，0 具有低确定性。所有分数的总和为 1。

print(prob_dist.prob("positive"))

结果:0.907443066804341

结论

我希望你在将来的应用中继续使用这个建议的方法。通过使用这种建议的方法，您可以绕过使用人工注释器来标记数据——这将节省您的时间和潜在的金钱。

有用的链接

上一篇文章更侧重于过程、实验和后续步骤。

订阅我的 YouTube 频道，了解关于本文所述过程的最新内容。

Colab: 包含了本文中使用的代码。

原载于 2021 年 7 月 28 日https://www . vennify . ai。

如何用 Matplotlib 标注图的值

原文：https://towardsdatascience.com/how-to-label-the-values-plots-with-matplotlib-c9b7db0fd2e1?source=collection_archive---------1-----------------------

标注地块的简单指南

Matplotlib 使用起来可能有点棘手。我尤其难以在我的图上显示数据点的值。起初我认为这应该是一个简单的任务，但我发现它并不像我预期的那么简单。因此，在这篇文章中，我会解释你如何做到这一点，并且尽可能的简单易懂。

让我们从创建几个随机数据点开始。

import numpy as np
import matplotlib.pyplot as pltx = np.arange(1, 21)
y = np.random.randint(20, size=20)
print(x)
print(y)
>>>[1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
>>>[9 13 19  8 13  3 19 17 12  4  7  0  3  9 14  0 11 17  6 10]

创建一个从 1 到 20 的 NumPy 数组。第一个数字包含在内，最后一个数字不包含在内。

np.random.randint(20, size=20)生成 20 个 0 到 20 之间的随机值，(0 包含 20 不包含)。如果你自己运行代码，你会得到不同的值。

接下来，我们可以简单地绘制数据。这部分用 Matplotlib 很容易。只需调用plot()函数并提供你的 x 和 y 值。调用show()函数可视化输出图形。

plt.plot(x, y)
plt.show()

作者创作的情节

为了让它更有趣一点，让我们修改一下情节。我认为这将是一个伟大的添加一个主要标题，对坐标轴的描述，并增加大小。

plt.figure(figsize=(8,8))
plt.plot(x, y)
plt.xlabel("x values", size=12)
plt.ylabel("y values", size=12)
plt.title("Learning more about pyplot with random numbers chart", size=15)
plt.show()

可以使用plt.figure(figsize=(12, 8))设置地块的大小。注意，先调用 figure 再调用 plot很重要，否则会得到不希望的结果。另外，请注意，绘图的大小是以英寸而不是像素来度量的。

轴上的标签和标题可以使用xlabel() ylabel()和title()简单设置。这三个函数中的 size 参数决定了标签的字体大小。

代码片段的结果如下。

作者创作的情节

我们仍然缺少数据点本身的 y 值。我们可以通过在一个循环中添加表示每个 x 坐标的 y 值的文本来引入它们。但是在这之前，我们首先需要在开头添加一行额外的代码。新添加的代码行用粗体书写。

**fig, ax = plt.subplots(figsize=(12,8))**
plt.plot(x, y)
plt.xlabel("x values", size=12)
plt.ylabel("y values", size=12)
plt.title("Learning more about pyplot with random numbers chart", size=15)
**for index in range(len(x)):
  ax.text(x[index], y[index], y[index], size=12)** plt.show()

第一行调用了plt.subplots()，它为我们创建了两个对象，并将它们存储在fig和ax中。fig对象用于修改图形，但我们不会在本文中进一步探讨。对象是一个支线剧情，我们可以用它来给剧情添加文本。

ax.text()允许我们在给定位置添加一个文本到绘图中。前两个参数代表文本的 x 和 y 坐标。第三个参数是文本应该具有的实际值，最后 size 参数决定了文本的字体大小。

通过循环浏览range(len(x))，我们创建了 20 个文本。数据中的每个 x 坐标一个。我们在下面看到上面代码片段的结果。

作者创作的情节

提示:如果你认为图上的值很难读取，因为它们直接在绘制线的上面，你可以简单地在ax.text()中的 y 位置参数上增加一点。

我认为通过增加 x 和 y 刻度的频率来匹配 x 的实际值和 y 的可能值，可以进一步提高图形的可读性。这可以通过将 x 值作为参数添加到plt.xticks()并将列表中的值 0 到 19 作为plt.yticks()的参数来实现。此外，作为情节的最后一笔，我还想添加网格线。这是通过调用如下所示的plt.grid()来实现的。

fig, ax = plt.subplots(figsize=(12,8))
plt.plot(x, y)
plt.xlabel("x values", size=12)
plt.ylabel("y values", size=12)
plt.title("Learning more about pyplot with random numbers chart", size=15)
for index in range(len(x)):  ax.text(x[index], y[index], y[index], size=12)
**plt.xticks(x, size=12)
plt.yticks([i for i in range(20)], size=12)
plt.grid()**
plt.show()

作者创作的情节

就是这样！现在，您知道了如何通过添加解释性标签来提高绘图的可读性。

Matplotlib 允许你用你的情节做很多事情，比我在这里提到的要多得多。在这篇文章中，我介绍了一些我一直在努力正确工作的小事情。希望你觉得有用。

感谢阅读。

如何在 6 个月内找到一份数据分析工作

原文：https://towardsdatascience.com/how-to-land-a-data-analytics-job-in-6-months-58f05311b905?source=collection_archive---------4-----------------------

在不到六个月的时间里从零到英雄

万花筒在 Unsplash 上拍摄的照片

数据分析师是世界上最受欢迎的专业人士之一。这些人在数据的帮助下帮助公司做出明智的商业决策。

现在有很多关于数据科学的炒作。

但是，数据科学的准入门槛非常高。这是一个竞争非常激烈的领域，来自不同教育背景的每个人都想进入。

在数据分析领域找工作比在数据科学领域容易得多。

大多数数据科学职位要求你拥有定量领域的研究生学位。然而，我认识的大多数数据分析师都来自完全不相关的背景，也没有技术学位。

数据分析技能可以通过在线课程和训练营轻松获得。学习曲线不像数据科学那样陡峭，而且可以在更短的时间内学会。

即使您之前没有编程或技术经验，也可以在短短几个月内获得成为数据分析师所需的技能。

在这些资源的帮助下，我在短短六个月内获得了一份数据分析的实习工作。

在做了 3 个月的实习后，我收到了一份加入该公司的数据分析师的邀请。

在这篇文章中，我将描述我学习数据分析的步骤。我花了大量的试验和错误来寻找这些资源，并为自己创建一个路线图。

如果你遵循这些步骤，你可以在几个月内学会获得入门级数据分析工作所需的技能。你甚至可以比六个月做得更快，这取决于你每天花在学习上的时间。

第一步:学习 Python

由克里斯多佛·高尔在 Unsplash 拍摄的照片

要进入分析领域，你首先需要学习一门编程语言。Python 和 R 是这个领域中最常用的两种语言。

如果你刚入门，我强烈建议学习 Python。它比 R 界面友好得多，也更容易上手。Python 也有大量的库，使得像数据预处理这样的任务变得容易得多。

Python 的应用也比 r 更广泛，如果你将来要进入 web 开发或机器学习这样的领域，你不需要学习一门新的语言。

在线课程

a) 2020 完整 Python 训练营:从零到 Python 中的英雄上:

如果你是一个完全没有任何编程经验的初学者，请参加这个课程。本课程将带您了解 Python 语法的基础，您将了解变量、条件语句和循环。本课程由何塞·波尔蒂利亚教授，他是 Udemy 上最好的讲师之一。

b) 学习 Python 进行数据分析和可视化:

一旦你理解了 Python 的基础和语法，你就可以开始学习如何用它来分析数据。本课程将带您了解特定于数据分析的库，如 Numpy、Matplotlib、Pandas 和 Seaborn。

学完这两门课程后，你将对 Python 及其在分析领域的使用有一个基本的了解。然后，我建议继续进行语言实践。

编码挑战网站

要获得实践经验，请访问 HackerRank 和 LeetCode 等编码挑战网站。我强烈建议 HackerRank。他们面临不同难度的编码挑战。从最简单的开始，然后一步一步来。

当你开始从事分析工作时，你每天都会面临编程问题。像 HackerRank 这样的网站会帮助你提高解决问题的技能。

每天花大约 4-5 个小时解决 Python HackerRank 问题。这样做大约一个月，你的 Python 编程技能就足够好去找工作了。

第二步:学习 SQL

由大卫·普帕扎在 Unsplash 上拍摄的照片

SQL 技能是获得分析工作的必要条件。您的日常任务通常包括从数据库中查询大量数据，并根据业务需求操作数据。

许多公司将 SQL 与其他框架集成在一起，并希望您知道如何使用这些框架查询数据。

SQL 可以在 Python、Scala 和 Hadoop 等语言中使用。这取决于你工作的公司。但是，如果您了解用于数据操作的 SQL，您将能够轻松地掌握其他 SQL 集成框架。

我上了 Udacity 的这门免费课程，学习数据分析的 SQL。DataCamp 也有一个流行的用于数据分析的SQL赛道，你可以尝试一下。

步骤 3:数据分析和可视化

摄粘土堤上的 Unsplash

你需要知道如何分析数据，并从中获得洞察力。知道如何编码或查询数据是不够的。你需要能够用这些数据回答问题，解决问题。

要学习 Python 中的数据分析，可以上我上面提到的这个 Udemy 课程。你也可以在 DataCamp 继续数据分析师职业生涯。

从数据中获得见解后，你应该能够展示这些见解。利益相关者需要根据你提出的见解做出商业决策，所以你需要确保你的陈述清晰简洁。

这些见解通常在数据可视化工具的帮助下呈现。可以使用 Excel、Python 库或 Tableau 等商业智能工具来创建可视化。

如果你想成为一名数据分析师，我建议学习 Tableau。它是最常用的报告工具之一，受到大多数雇主的追捧。

这个由基里尔·叶列缅科教授的 Udemy 课程是学习 Tableau 的最佳资源之一。

步骤 4:数据讲述和演示

照片由 Dariusz Sankowski 在 Unsplash

完成前三个步骤后，你已经具备了获得数据分析领域入门级工作的所有必要技能。

现在，你需要向未来的雇主展示这些技能。如果你没有技术背景，你需要向招聘人员展示你有成为分析师的必要技能。

为此，我强烈建议建立一个数据分析组合。在 Tableau 中构建仪表板，使用 Python 分析 Kaggle 数据集，并就您新磨练的技能撰写文章。

你可以看看我的作品集网站这里。

这里有一些数据分析项目的例子，你可以在你的投资组合中展示:

创建新冠肺炎世界地图仪表板
从 Spotify 收集音乐数据，找出顶级表演艺术家
使用 LinkedIn 数据来确定薪资最高的地区

在简历中展示这样的项目会让你在潜在雇主面前脱颖而出。

确保围绕你创建的项目讲述故事。记录下你创建这个项目的每一步，并写一篇关于它的文章。你甚至可以创建自己的博客并发表这些文章。

这增加了你的文章落入他人手中的机会，也就是说有更高的机会被潜在的雇主看到。

结论

如果你想进入数据行业，数据分析是一个很好的起点。与机器学习等领域相比，它的准入门槛较低。

如果你喜欢讲故事和创建演示文稿，你会喜欢在分析领域工作。你的日常工作将包括向非技术人员解释技术概念，你需要努力提高你的沟通技巧。

请记住，数据分析是一个领域，人们花了一生的时间试图学习。即使是成为分析师所需的个人技能，也可能需要一生的时间来学习，因此不可能在短短几个月内掌握。

这篇文章只针对那些试图在数据分析领域找到一份入门级工作的人。

按照上面的步骤，我在 6 个月左右的时间里找到了一份分析工作。即使你以前没有数据经验，每天花 5-6 个小时，你也能做到。

教育是你可以用来改变世界的最强大的武器——纳尔逊·曼德拉

如何在 2022 年找到一份数据科学工作

原文：https://towardsdatascience.com/how-to-land-a-data-science-job-in-2022-ebfbc506516b?source=collection_archive---------13-----------------------

提高数据科学职位就业能力的 7 项技能

如何在 2022 年找到一份数据科学的工作？照片由 Unsplash 上的 Prateek Katyal 拍摄

在本文中，我将介绍一些有助于你在 2022 年获得数据科学工作的事情。如果你满足了所有这些要求，我相信你会很快找到一份数据科学的工作。

不久前，我写了一篇类似的文章，列出了【2020 年必备的数据科学技能。我觉得我离得并不远。但是数据科学领域在不断变化，现在似乎是推出新版本的时候了。

但是数据科学不是已经死了吗？

我看到一些文章像病毒一样传播，说“数据科学已死”。

也许转换到数据科学的黄金时期已经过去了，但你仍然可以在 2022 年找到一份数据科学的工作。外面有很多工作，我相信进入(技术)数据工作对你的未来仍然是一个很好的选择。

最大的变化之一是现在有许多竞争的职位。数据科学职位的工作规范仍然因公司而异。

一些较新的职位头衔更多的是技术性职位:

具有机器学习技能的软件工程师
机器学习工程师
ML 操作

其他一些人正在将数据科学工作放在已经存在的位置上，例如:

具有机器学习技能的数据分析师

一些公司希望只雇佣那些精通数据工程的多才多艺的候选人，以便被考虑数据科学职位。

你应该什么都知道吗？

很少有人能深刻掌握所有这些话题。所以，不，你不需要知道所有这些就能找到工作。然而，如果你有时间，提高技能可以大大增加你在就业市场找到匹配的机会。

在这篇文章中，我将列出一些额外的技能，如果你还没有的话，你可以通过这些技能来训练自己。如果你想在 2022 年最大化获得数据科学工作的机会，我希望它能让你很好地理解你需要做什么。

我不包括更标准的技能，如统计学、机器学习和 Python，因为我认为它们是基本的，而且你几乎可以在任何数据科学培训中找到它们。

工作中的数据科学家。克里斯蒂娜@ wocintechchat.com 在 Unsplash 上的照片。

1.软件工程技能

许多软件工程师已经转向数据科学专业。这增加了数据科学家掌握软件工程技能的必要性，即使你最初不是来自软件背景。

以下是一些你在申请数据科学工作时可能会被测试或质疑的技能。

数据结构和算法

数据结构和算法是软件工程学位的基础。然而，在数据科学学位中，它不一定存在，否则它可能有点多余。

数据结构和算法越来越成为数据科学家面试的技术测试的一部分。原因是越来越多的数据科学职位需要编写生产代码，并将您自己的模型发布到生产环境中。

互联网上有很多数据结构和算法的培训资源。

测试和编写单元测试

编写测试和单元测试曾经是开发人员和软件工程师的领域。2022 年，许多数据科学职位要求他们的候选人能够为自己的代码编写测试。

如果你还没有掌握这个，你可以从学习 PyTest 开始，这很容易。

Pytest。来源:https://docs.pytest.org/en/6.2.x/

你也可以研究一下 测试驱动开发 并从现在开始使用它来提高你在这一点上的技能。

完美无缺

为了从事数据科学家的工作，许多公司还要求你在使用 git 时完美无瑕。该工具过去主要面向开发人员，但如今也成为许多数据科学家角色的必备工具。

你可以查阅一些资源来开始使用 git(git 简介和git 基础知识分步指南，或者直接转到高级 git 使用。

饭桶。来源:http://git-scm.com/downloads/logos

码头工人和集装箱

Docker 是另一种曾经被认为对数据科学家有利的技术，但它很快变得非常重要。Docker 容器允许您解决许多环境设置问题，对于任何希望在本地机器之外的任何地方使用其代码的数据科学家来说，它都是一个很好的工具。

你可以从这里的 Docker 开始。

码头工人。来源:https://www.docker.com/company/newsroom/media-resources。

摆脱笔记本电脑环境

许多数据科学家目前正在研究笔记本电脑环境。如今，很多事情都可以在笔记本上或从笔记本上完成。但是，如果你在其他环境中没有一个坚实的环境，面试官可能会很挑剔。能够展示编写独立软件或构建 Python 包的经验对你的工作申请来说是一个巨大的附加值。

2.机器学习工程和 MLOps 技能

机器学习工程师的角色是数据科学家和软件工程师的结合。MLOps 是相当于 DevOps 的机器学习。

使用自动化 CI/CD 和精心设计的云架构将自己的模型投入生产的能力对于在 2022 年找到数据科学工作来说是一个真正的附加值。

部署

部署模型不一定很难，但这是很多数据科学家没有接触过的东西。要么他们的工作更多地停留在分析方面，要么可能他们公司中有专门的角色来做这部分工作。

我强烈建议您对部署模型所需的技能进行培训，包括架构知识、CI/CD 知识、安全性问题、模型速度/性能问题、监控等。

API、微服务和架构

理解 API 和微服务是如何工作的是这方面的第一步。一旦您理解了如何将您的模型工件转换成服务，您就已经开始理解部署了。

像 AWS 这样的云提供商提供很好的培训和认证，可以帮助你提高这方面的技能。

CI/CD

我建议的第二步是研究 CI/CD。一旦你理解了如何建立一个 API 并以这种方式传递你的模型的预测，将会有很多额外的工作需要去做以使它更健壮。

自动化 CI/CD 管道有助于您更好地管理部署管道。毕竟，如果您将您的模型交付到生产环境中，那么您正在为依赖它的应用程序制造风险。你必须确保一切都彻底完成。

在这些艰难的内容中加入一点动力。照片由你好我是尼克在 Unsplash

3.数据工程技能

数据工程是目前最受欢迎的工作之一。如果你想最大化你的就业能力，拥有数据工程技能将是你最好的选择。

随着许多公司现在拥有数据科学团队，数据质量和可访问性问题成为新的热门话题，数据湖建设和云迁移项目正在各地进行。

有大量的文章列举了数据工程技能，所以我在这里就不赘述了。我觉得这篇文章给出了一个很好的列表，但是还有很多其他的列表。

4.使用多种编程语言

你掌握的编程语言越多，你不满足公司要求的可能性就越小。许多招聘人员只是有一个检查列表，没有任何经验的任何一个复选框会直接阻止你的申请。

您可能需要了解的一些编程语言(当然除了 Python 之外)有:

火花
斯卡拉
朱丽娅
锈
戈朗
R
斯堪的纳维亚航空公司
更多

不同的语言通常要求不同类型的职位。例如，Spark 和 Scala 经常被问到大数据环境中的职位，而 R 和 SAS 可能被问到更多的分析角色，而 Rust 或 Golang 则是你将编写生产代码的工作。

5.深度学习专业知识

在更容易的时候，只要知道如何把一个 scikit 学习管道放在一起，就可以找到一份工作。今天，这远远不够，因为招聘人员将扫描你的简历，寻找深度学习和关键词，如、 NLP 、声音分析等等。

张量流。来源:https://www . tensor flow . org/extras/tensor flow _ brand _ guidelines . pdf

要想应聘很多数据科学的职位描述，掌握 Tensorflow 和 Pytorch 是必须的。期待接受这方面的技术测试，因为计算机视觉和 NLP 已经成为许多领域的重要用例，而几年前它们在简历上只是一个小小的加分项。

当然，这也很大程度上取决于你申请的领域。

如果你正在寻找更多关于深度学习的介绍教程，你也可以查看文章这里或者这里。

6.记得你的数学课吗

数据科学以数学为基础。拥有强大的数学背景是在数据科学领域取得成功的必备条件。

在工作面试和技术测试期间，不要惊讶于偶尔手工计算概率，或者在相对较短的时间内做代数、优化甚至更复杂的任务，而招聘人员正在观察你做什么。

如果解决数学问题不是你每天都要做的事情(很多人都是这样)，那么在参加数据科学技术面试之前练习大量的例题将是一个好主意。

7.成为领域专家

领域专长仍然是求职的一大优势。如果你申请的是你非常熟悉的领域的数据科学工作，你将更有可能成功。

将此作为你成为数据科学家的敲门砖是一个好主意。

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

结论

总之，是的，你可以在 2022 年找到一份数据科学家的工作。如果你是从零开始，或者正在进行转换，这可能需要一些工作。

如果你还在犹豫，我建议你花些时间去寻找最适合你的工作。数据科学不是工作机会的金矿:我建议只有当你真的喜欢它时才进入它。你也可以查看目前正在流行的许多其他 IT 工作的职位描述。

我希望这篇文章能给你一些启示，让你知道如何在 2022 年为数据科学工作进行培训。感谢您的阅读，请继续关注更多数学、统计和数据科学内容！

如何获得你的第一份数据科学自由职业

原文：https://towardsdatascience.com/how-to-land-your-first-data-science-freelance-gig-56bd6417abe7?source=collection_archive---------33-----------------------

任何人都可以遵循的 6 个简单步骤。

马库斯·斯皮斯克在 Unsplash 上的照片

在当今世界，由于疫情的种种不确定性，以及它如何改变了我们对世界的看法，尤其是我们过去对工作文化的看法，自由职业变得比以往任何时候都更有吸引力。许多人已经意识到，他们不需要去办公室或在公司工作来谋生；事实上，我们大多数人意识到，出于各种原因，自由职业是一个更有吸引力的选择。

作为一名自由职业者，你可以完全掌控自己的时间、工作内容、工作地点以及你认为自己的技能值多少钱。不幸的是，这些好处淹没了许多开始学习新技能和尝试从事自由职业的人。不久前，我也是这些人中的一员，试图开创一个自由数据科学家的职业生涯并不容易。

开始总是最难的，但这并不意味着它们是不可能的。无论事情从远处看起来有多难，一旦你付出了努力，采取了一些认真的步骤，那么看起来如此困难的事情就会变得容易处理。

这篇文章将带你了解我在尝试——老实说，在奋斗——开始自由职业生涯时采取的一些步骤。我还想说，不管你想从事什么样的自由职业，这些步骤仍然适用。因此，无论你是想成为一名自由职业的数据科学家、网站开发人员、技术作家还是导师，遵循这些步骤都有望帮助你实现目标。

第一步:确定你将提供的技能

一旦你下定决心成为一名自由职业者，你首先需要花些时间想想你到底想提供什么。数据科学是一个巨大的领域，你可以提供很多东西，从数据清理到模式发现，再到应用机器学习和人工智能算法，或者更高级的主题，如大数据和数据挖掘。您也可以更喜欢创建可视化和仪表板。

不管你想提供什么，你都需要清楚地陈述你的优势和劣势。接下来，列出你喜欢做的数据科学的各个方面，并围绕这些方面打造你的品牌。同样，你可以利用你以前的经验来帮助你完成这一步，即使这些经验不是自由职业者的经验。

第二步:对你期望的项目类型有一个清晰的愿景

第二步与第一步密切相关；我建议你同时做这两件事。当你确定你将提供的服务类型，并清楚地列出你的技能时；你在某种程度上构建了一幅你将在网站上寻找或从客户那里接受的项目类型的图片。

如果你是一个初学者，你可能不清楚你的技能可以准确地应用于什么类型的项目。在准备过程的这一阶段，你可以做研究，寻找什么样的项目，公司和客户想要什么，并尝试将一些类型的项目与你在步骤 1 中列出的技能相匹配。

</7-types-of-gigs-you-can-do-as-a-freelance-data-scientist-5b81f3c203af>

第三步:建立网上形象。

自由职业是一个竞争激烈的领域；你将面对来自世界各地的数据科学家，而不仅仅是来自你所在的城镇、城市或国家。这就是为什么你需要建立自己的品牌，创造你的在线存在。这种存在将帮助你找到客户，并帮助客户验证你的可信度。

建立网上存在有不同的方法；最直接的选择是创建一个投资组合网站。作品集网站是一个你可以讲述你的职业故事的地方，你学到了什么，你建立了什么，以及你是如何建立的。你也可以把你的 LinkedIn 个人资料作为你的投资组合。这些投资组合需要包含以前的工作样本，一些博客，可能还有一些以前的客户或主管的证明。

第四步:在现有平台上做功课

所以你知道你的技能，知道你想做什么项目，并建立一个强大的投资组合。现在，你准备开始问我在哪里可以找到自由职业者的工作。今天，你可以在许多网站上找到数据科学自由职业者的工作，但有些网站比其他网站的可信度更高。你需要知道你没有被骗。

总的来说，你可以通过以下三种方式找到自由职业者的工作，要么联系客户，要么客户直接联系你，要么你可以浏览自由职业者的网站并投标。这一步最重要的是确保你找到的工作不是骗局。一个可以帮助你发现合法工作的资源是 FlexJobs 。

</5-new-data-science-books-that-you-should-consider-reading-c90aec1d5b0d>

第五步:社交，交流，建立关系网

当你开始你的自由职业之旅时，与你所在领域的其他自由职业者联系，并建立一个职业网络，对于拥有一个成功和繁荣的职业生涯是至关重要的。要联系其他自由职业者，你可以试试在线社区，比如 LinkedIn groups 或 T2 自由职业者联盟。

加入一个自由职业者社区将在你的旅程中以各种方式帮助你，从寻找客户到帮助建立小时工资或只是对经常发布的项目类型有一个大致的了解。另一种寻找客户的方法是询问你现有的关系网，宣传你的技能。

第六步:迈出第一步

如果你已经走了这么远，那么你是认真地想要建立一个稳固的自由数据科学职业生涯。现在，你已经准备好迈出第一步，尝试找到你的第一份工作。第一步是去像 Upwork 、to tal、 Codementor 或 AngelList 这样的自由职业网站，开始浏览演出。

尝试获得第一份工作的一个重要建议是，优先考虑经验而不是报酬。因为你需要向客户证明你是认真的和有技巧的，你可以很容易地证明你的技能，浏览演出，投标，不要害怕提供更低的价格或一些免费的额外服务。记住，在开始的时候；你在建立一个品牌。你建得越好，你将来得到的报酬就越多。

外卖食品

我们都追求自由，选择的自由，工作的自由，时间的自由。我们都想在工作的时候控制自己的时间，在休息的时候控制自己的时间，去度假。所以这种自由的时间是我一生中最优先考虑的事情。因为，如果我有这种自由，那么我也有选择在哪里工作的自由，我不必被束缚在一个特定的地点，这对我这样的人来说很重要。

</5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204> [## 5 本 Python 书籍，让你的代码更上一层楼

towardsdatascience.com](/5-python-books-to-transfer-your-code-to-the-next-level-a5af0981e204)

但是，开展自由职业可能不是最容易的事情，你知道你有技能和能力，但你是客户成功的可能性。你可能像你说的那样好，然后这是一个双赢的局面，或者你可以振奋自己的能力。这就是为什么获得第一个项目或客户是成功的自由职业生涯的重要一步。

一开始，你可能会以低于你认为它的价值的报酬工作，因为你在建立你的声誉，一旦你出名了，你就可以得到合理的报酬，客户会很乐意这样做，因为他们买的是质量。所以，我的建议是，诚实、透明、有耐心，并且努力工作、持之以恒，你也可以在科技数据科学领域拥有成功的自由职业生涯。祝你好运。

如何获得你的第一个自由职业客户/项目

原文：https://towardsdatascience.com/how-to-land-your-first-freelancing-client-project-a0d4801b4437?source=collection_archive---------27-----------------------

网络和数据科学自由职业项目登陆综合指南。

自从我辞去全职数据工程师的工作，开始全职从事自由职业，已经有将近 3 年的时间了。当我忙于获得我的第一个客户或新项目时，我的职业发展出现了急剧的上升。

除了成长和金钱，我还能找到我真正感兴趣的地方。更不用说，努力实现你的想法会给你带来巨大的快乐。

关于我的职业，我经常遇到的一个问题是

你是如何获得你的第一个自由职业项目的？

因为每个人都知道得到第一份工作可能是最难的。这篇博文和视频(底部)只是关于建立一个策略来开始你的自由职业生涯。

为什么是自由职业者？

如果你有时间，谁不想建立一个副业收入？也许你想攒钱买下一辆车，或者你想休息一年。这就是自由职业的用武之地。

更不用说，你可以成为“你自己的老板”，穿着短裤在海滨别墅工作，同时，你可以赚到无限的钱。你掌控着自己的成长。

所以，给你！

五步迭代，直到你的第一个项目落地

正如信息图(标题图片)所示，你只需遵循这五个步骤中的每一个，直到你得到第一份工作。这里有五个步骤可以帮助你建立自由职业生涯:

将您的技能确定为一项服务
定义你的理想客户或市场
建立您的投资组合和档案
向客户推销你的服务
捕捉结果/差距，分析每一步的结果，调整方法以保持增长。

步骤 1 —将您的技能识别为服务

简历中的技能部分简单地列出了你在技术和技巧方面的知识，但是你必须确定在现实世界中你能用这些技能做什么。

让客户明白你能为他做什么。

你的技能可能是:

Web 开发
平面设计
数字营销
数据分析

您的服务可以是:

构建高性能的端到端网站和 web 应用程序。
为网站、视频和海报创作美丽的插图和数字艺术作品。
帮助个人和中小企业在网上推广他们的产品和服务。
处理数据以发现模式并回答重要的以业务为中心的问题，从而做出明智的决策。

信息图表列出了每个步骤的注意事项。

大多数人都很难迈出第一步。他们不确定是否准备好了。我相信你永远不会准备好。开始吧！

以下是 Gumroad 创始人 Sahil Lavingia 的推文:

在本文的其余部分，我将重点关注 web 开发和数据科学服务，但是您可以将这些原则应用到您必须提供的几乎任何服务中。

温馨提示:

寻找那些从自由职业中获得成功的人。研究并复制他们的过程。
学会使用正确的短语——告诉他们你是做什么的，为什么你比其他人更好。

第二步——定义你的理想客户或市场

整篇博文基本上都试图回答“如何获得你的第一个客户？”

没有客户就没有自由职业，但这并不意味着你应该向任何人伸出援手或推销你的服务。这对你没有好处，反而会增加你的挫败感。

你从第一步就有了自己的定位，做一些研究，看看谁需要这种服务。

一些客户的例子可能包括:

网络开发——本地商店、健身教练、机构、酒店、创作者(现在很热门)
数据分析—数据驱动的初创企业/组织
开发 ML 模型和应用程序(DevOps)—平台即服务和软件即服务组织。

哪些人不是理想的客户(至少对第一个客户来说):

特许经营企业
跨国公司，为客户秘密运营的戒备森严的公司(ZS、安永、德勤等)。)

亲提示:

寻找个人所有的网络开发企业。
对于数据科学项目和机会，首先要确保你很好地掌握了你的基础知识。使用像 codementor 这样的平台来帮助学生完成他们的项目。

第三步——建立你的投资组合和简介

在确定你的定位和目标客户后，是时候建立我们的商店了，在这种情况下，可以是你的投资组合网站(强烈推荐)或 LinkedIn、Upwork、Toptal、AngelList 等平台上的个人资料。

作品集网站

这里要注意的一件重要事情是，你希望有人信任你的业务。

你如何让别人信任你？

你可以从讲述你的职业故事开始。投资组合网站就是这样做的一种方式。如果你还没有故事要讲，那就为自己创作一个故事，也就是说，用网上常用的主题建立一个样本网站，或者你可以提议为一个潜在的客户免费做一个项目。

大多数人会把投资组合网站误认为是在线简历。

投资组合网站不适合你，而是适合你想要锁定的客户。它应该通过以下方式展示您的服务:

工作样本— 您创建的网站/应用、报告、会议演讲(如有)等。如果你没有任何样本，创建几个！开发仪表板/网站，托管它们，并展示你可以交付高质量的工作。
推荐信/推荐信— 让你以前的同事/老板/客户给你写一封推荐信。
提示:如果你以前没有在任何地方工作过，为潜在客户做 1-2 个免费项目，然后请他们写一份推荐信。我已经做了 2-3 个免费的项目，有人把我介绍给另一方。
写博客— 这对我来说很有效。这是建立你信誉的一种方式。博客应该包含相关和真实的内容，通过这些内容，客户可以了解他们的业务。从赠送开始！

博客帖子的创意示例:

如何通过网站接触到更广泛的受众
您的仪表板/报告应该包含什么类型的业务指标

轮廓

除了拥有一个网站，你还需要在 LinkedIn 这样的专业平台上社交，寻找潜在的客户，工作想法，发布更新，宣传自己。

开发作品集网站的原则也适用于社交媒体档案。

一份好的个人资料可以增加你获得机会的几率，原因有很多:

这表明你对待工作有多真诚。
它可以显示你的工作样本和技能的熟练程度，以提供你的利基服务。
如果你有一位真正的同事/合伙人/前老板写的推荐信或推荐信，这会增加你的可信度。

自由职业平台

向上工作轮廓

除了 LinkedIn，还有许多平台拥有完整的自由职业生态系统，客户可以发布他们的需求，自由职业者可以竞标这项工作。

寻找自由职业项目/工作的几个主要平台包括:

向上工作
顶部总计
AngelList(针对初创公司的工作)

那么，在这些平台上建立自由职业的成功秘诀是什么呢？

我要说的是，你必须正确理解一份档案的不止一个方面，而是多个方面。您的成功依赖于以下几点:

您对平台上列出的技能的熟练程度。
你的个人资料整理得有多好。
你对这份工作的提议。它告诉客户你有多适合广告上的工作。
最后，运气！如果你把前三个方面做对了，它的作用就很小，也很少。

这里有一些建立有吸引力和真实的个人资料的建议

回顾你有兴趣申请的项目。记下这些客户用来描述他们需求的关键词和技能。将这些技能(优势)添加到您的个人资料中，可以将您与相关项目联系起来。列出最多 10 项技能。
上传一张专业的图片和一份简短的简历，描述你的专长/服务。
突出你作品集里最好的作品。
如果你有的话，列出你的证书。为您的个人资料增加权重。
与你的技能保持一致，完成个人资料的所有部分，简洁明了，并链接校对每一部分。

步骤 4 —向客户推销(外展)

是时候进入正题了，销售符合客户需求和预算的服务的人赢得了机会。

但首先，你需要让客户向你求婚。这是你需要提高知名度和拓展力的地方。

有许多方法可以做到这一点:

在 LinkedIn 这样的平台上接触客户——这正是我的优势所在！
使用自由职业平台——up work(一般)、Toptal(工程师)、codementor(如果你是专家)和 AngelList。
如果你想领先一步，使用 Google Adwords (为你的服务做广告)或创建一个脸书小组，在你的领域、你的实际位置(城市/州)等地方销售服务。

我的方法(不一定对你的小众有利！):

我做了大量的研究，寻找与我的定位相匹配的组织。我主要用 LinkedIn ， Twitter ，谷歌搜索(浏览)也是一样。
我已经根据入围公司的领域(金融科技、医疗保健、教育科技)对它们进行了分类，并创建了一个模板** 消息(类似于一封求职信)，以配合他们正在进行的项目以及我自己的想法。**
我曾经在每个领域发送我的作品样本，如果没有任何东西可以展示，我会在那个领域开始一个新项目，并向他们发送我的 GitHub repo，告诉他们我在做什么。

2016 年，我通过 Udacity 找到了第一个自由职业客户。因为我是他们的校友之一，他们推出了一个新平台。我的提议符合客户的需求，我被录用了。我认为自己在这方面是幸运的。

从那以后就变得容易了:

步骤 5 —捕捉、分析和协调

你可能会在一天、一个月或六个月内完成你的第一个项目，这个过程中不可或缺的一部分就是不断改进。

你可能会在第一次尝试中失败，但利用这次失败来做得更好。

捕获:

你联系的项目/客户的数量。有多少人回应、感兴趣、拒绝或继续。
为什么你的提议被拒绝了？向客户征求意见。
在你所处的领域取得成功的人，他们在做什么不同的事情？
你所在的领域有什么新东西？大家都是怎么操作的？

分析:

项目需求和您的投资组合之间的差距——看看缺少了什么。
了解你获得的每个数据点，找出你有更多机会转化的客户类型。
创建一个单独的客户类别，你必须在他们的需求和你的专业知识之间架起一座桥梁。

点化:

开始从事新的项目来获得新的技能或者掌握你已经掌握的技能。
重组、润色你的个人资料，使之符合客户的需求。
重写建议书，强调他们的需求和您的服务，以及您的工作样本和数字/统计数据(如果适用)。

如果你每天花 2 个小时写建议书和向客户推销，那么至少花 3-4 个小时来完善你的技能。只有当你每天都有好奇心去学习和建立的时候，你的策略才会奏效。

坚持这些原则，你将会得到你的第一个自由职业客户。

你还在等什么？我们开始吧！

你也可以在我的 YouTube 频道上观看这个话题的视频:

如果您想分享您的客户登陆策略/过程，请随时回复本博客或评论视频。

你可以在推特或者 LinkedIn 上和我联系！

如何在 Google Cloud 上快速启动 GPU 实例

原文：https://towardsdatascience.com/how-to-launch-a-gpu-instance-on-google-cloud-fast-4fb0be7b2a3f?source=collection_archive---------7-----------------------

如何在 Google Cloud 上非常快速的启动一个带有 Jupyter 笔记本界面的 GPU 实例？

汤姆·巴瑞特在 Unsplash 上的照片

在本文中，我将向您展示在 Google Cloud 上启动 GPU 实例的最快和最简单的方法。具体来说，我将演示如何在 Google Cloud 上启动一个连接到 GPU 的 Jupyter 笔记本界面。

使用和访问 GPU 进行深度学习项目是必不可少的。深度学习模型只有在 GPU 上训练，才能在合理的时间内训练出来。然而，GPU 很难获得，拥有一个也很昂贵，所以大多数人都指望基于云的 GPU 服务来训练他们的模型。对于许多初学者来说，使用 GPU 的第一个地方是 google Colab，这是一个免费的类似 Jupyter 笔记本的服务，提供免费的 Nvidia Tesla K80 GPUs 供使用。然而，Google Colab 的问题是它在免费帐户中的限制:你最多只能训练你的模型 12 个小时，并且你只能使用有限的内存。升级到 Google Colab premium 并没有提供更多的优势，除了训练模型的时间更长，训练模型的内存更多。为了获得更大更快的 GPU 和更多的内存和计算能力，人们经常使用基于云的 GPU 服务，如谷歌云、微软 Azure 和亚马逊网络服务。

谷歌云是使用 GPU 训练模型的一个很好的简单方法。在这篇文章中，我将解释如何快速建立一个 google cloud 帐户，并使用它提供的 GPU 服务。请注意，我是在 2021 年 2 月写这篇文章的，因此 Google Cloud 的早期/未来版本可能会略有不同，不一定与本文中介绍的细节一致。

第一步是创建一个谷歌云账户。你可以使用你的 Gmail/google 账户来完成这项工作。一旦你建立了你的账户，你应该像这样。

确保您激活您的帐户成为付费帐户。即使他们提供 300 美元的免费信用，你仍然必须升级你的帐户成为付费帐户，因为这是你被允许使用 GPU 的唯一方式。即使你将账户升级为付费账户，你仍然可以在付费前使用谷歌提供的 300 美元免费信用。

在您启动 GPU 实例之前，您需要确保您的配额设置为 1 或您想要使用的任意数量的 GPU。配额实际上是对您可以使用的 GPU 数量的限制。

要增加您的配额，请在搜索栏中搜索配额，然后单击所有配额。一旦你这样做了，你的屏幕应该看起来像这样。

现在，使用 filter 按钮，屏幕左上角有三个横条的那个，来过滤结果。首先，选择“限制名称”，然后选择“GPU(所有区域)”。您应该有一个这样的屏幕:

单击“所有配额”按钮，您应该会看到一个显示全球配额的页面。选择此项，然后选择编辑配额。您应该有一个这样的屏幕:

将 GPU 限制更改为您想要的 GPU 数量。我一般只需要一个 GPU。添加简短描述，并提交您的请求。你增加配额的请求通常会在几个小时内或者最多 1-2 天内得到答复。

需要记住的重要一点是你的项目需要的 GPU 内存量。如果您的模型或输入非常大，那么您可能会使用大量的 GPU 内存，在创建实例时增加 RAM 并不能解决这个问题。根据我的经验，有一种方法可以增加你的 GPU 内存:增加你使用的 GPU 数量。这个图表显示了每种类型的 GPU 有多少 GPU 内存。这是一个固定的数字，不能改变。不增加你的 GPU 内存将导致 CUDA 内存不足的错误，所以如果这个问题适用于你，你一定要解决它。

如果您的配额增加请求获得批准，您将收到一封电子邮件通知您。现在，你可以启动 Jupyter 笔记本了。

回到你的仪表板。选择导航菜单，并在导航菜单上选择人工智能平台->笔记本电脑。

完成后，选择 Create New Instance。您可以选择使用 Google 预先制作的笔记本，或者创建一个自定义实例。通常，我只是做一个定制的笔记本，因为它允许更多的灵活性。

您可以随意调用您的实例，并且可以选择您想要的任何区域。但是，不同的地区可能有不同的可用 GPU，因此请确保选择包含您要使用的 GPU 的地区。

现在，您可以定制您想要使用的任何环境/库(Pytorch/Tensorflow)、您想要的 RAM、您想要使用的 GPU 以及您想要使用的 GPU 数量。请确保该数字不大于您指定的配额。您将在边上看到您选择的相应 GPU 的成本。我个人喜欢使用 Nvidia V100，因为它是用于深度学习的最好的 GPU 之一，所以我的成本是每小时 1.877 美元。

选择创建实例。您现在有一个工作笔记本可以使用了！为了启动实例，请选择要使用的笔记本并启动。

从现在开始，您的 Jupyter 笔记本应该已经启动并开始工作了。您可以定期上传、下载和保存文件。

当您使用完 GPU 时，请确保停止使用，否则，您将继续被收费。

我希望你觉得这篇文章很容易理解，并学到了一些新东西。如果你有任何问题，请在评论中提出。

如何在变色龙云上启动虚拟机

原文：https://towardsdatascience.com/how-to-launch-virtual-machines-on-chameleon-cloud-a784e2b35850?source=collection_archive---------38-----------------------

在变色龙云上启动虚拟机的分步指南

凯西·霍纳在 Unsplash 上的照片

在本文中，我将解释如何在变色龙云上启动一个虚拟机实例。在我的情况下，我的机器是 Nvidia K80 GPU。

什么是变色龙云？

变色龙云是和 IBM、阿里巴巴、Google、AWS、Azure Cloud 一样的云计算平台。与变色龙的主要区别在于，如果你有使用许可，它是免费使用的。

与传统的云计算平台不同，变色龙主要用于研究目的，它由美国国家科学基金会资助。所有有权使用变色龙的会员都可以免费使用它的机器。只有学术机构的教师，联邦机构如 R&D 国家实验室中心和研究所，以及国际研究机构才有资格创建关于变色龙的项目。这并不意味着只有低于这个标准的人才能使用变色龙。这意味着任何符合该标准的人都可以创建一个项目，并且可以将任何其他人添加到该项目中。因此，如果你在一个符合上述任何标准的人的指导下做研究，那么你可以要求他们创建一个变色龙项目，你可以加入到那个项目中，并且你可以开始免费使用变色龙机器。

入门指南

当你加入一个项目后，你就可以开始使用变色龙上的机器了。chameleon 上的机器实际上分布在两个主要位置:德克萨斯高级计算中心(TACC)和芝加哥大学(加州大学)。您可以在任一位置探索和使用机器。在本文中，我将使用 TACC 的 Nvidia K80。

要选择地点，登录你的账户，进入 chameleoncloud.org 的，然后进入实验- > CHI@TACC(或 CHI@UC，以你正在使用的为准)。

作者图片

一旦你在那里，它应该看起来像这样:

作者图片

保留

与传统的云计算平台不同，您不能随时启动实例。变色龙使用预订系统，用户必须事先预订机器。您可以通过转到预订->租赁，然后选择主机日历来查看主机日历(基本上是一个显示谁在何时使用实例的日历)。您必须查看主机日历，以了解哪些资源何时可用。它看起来会像这样。

作者图片

要查看哪些特定机器可用，请选择节点类型并选择您的机器类型，在我的例子中是 Nvidia K80 GPU。

作者图片

您可以查看每台机器何时可用，或者某台机器当前是否可用。需要记住的重要一点是，如果一个节点当前已经被使用，您就不能保留它，或者当其他人已经保留它时，您也不能提前保留它。

您可以通过转到预订->租赁并选择创建租赁来预订机器。将弹出一个窗口，看起来像这样

作者图片

租赁名称可以是您想要的任何名称。如果您希望尽快开始租赁，您可以将开始时间留空，变色龙将尝试保留您的节点，默认租赁持续时间为 1 天。租期限于 7 天。但是，如果资源可用，活动租赁在其结束时间 48 小时内最多可以从请求之时起延长 7 天。变色龙会在你租期结束前 48 小时给你发邮件提醒。

创建密钥对并关联 IP 地址

在启动实例之前/之时，您必须创建一个密钥对并关联一个 IP 地址，以便正确启动您的机器。要创建密钥对，请转到计算->密钥对，然后选择创建密钥对。将弹出一个类似这样的窗口。

作者图片

您的密钥对名称可以是任何名称，并将您的密钥类型选择为 SSH 密钥。创建完密钥对后，应该会生成并下载一个名为 .pem 的密钥文件。

在启动一个实例之前/之后(什么时候启动并不重要)，您应该创建一个浮动 IP 地址，并且需要在启动实例之后将它分配给实例。

要创建浮动 IP 地址，请转到“网络”->“浮动 IP”并选择“将 IP 分配给项目”。将弹出一个如下所示的窗口:

作者图片

描述是可选的，可以是您想要的任何内容。选择分配 IP。在您启动实例之后，我将展示如何为您的实例分配 IP。

启动实例

预订开始后，您可以在租赁给您的节点上启动一个裸机实例。

转到计算->实例并选择启动实例。将弹出一个窗口，看起来像这样:

作者图片

实例名可以是您想要的任何名称，同样的事情也适用于描述。对于预订，选择您创建的预订。

启动实例之前的下一步是转到源代码。

作者图片

此时，您必须选择您想要的图像。您必须向下滚动图像列表，选择您想要的图像。我使用的是 Nvidia K80 GPU，所以我会选择 CC-Ubuntu18.04-CUDA10。

作者图片

下一步是转到 Flavor 并选择您想要的节点/实例的类型。选择裸机。

作者图片

下一步是转到密钥对并选择您在上一节中创建的密钥对。转到密钥对，找到您在上一步中创建的密钥对并选择它。我把我的密钥对命名为 i_extraction，所以这就是我的窗口的样子

作者图片

一旦完成了所有这些，您就可以启动您的实例了。单击窗口右下角的“启动实例”。您的实例大约需要 10 分钟来加载。您可以通过查看 Compute -> Instance 选项卡来查看它是否已经完成加载并正在运行。

一旦装载了实例，就必须关联前面创建的浮动 IP 地址。转到网络->浮动 IPs。在面板右侧的操作下，选择关联。将弹出一个窗口，并将您的 IP 地址与您的实例相关联。

访问您的实例

我使用的是 Windows 10，因此本指南将介绍如何在 Windows 10 上访问您的实例。对于任何其他系统，请遵循本指南来访问您的实例。注意，对于 windows 用户，你也可以跟随这个视频通过 SSH 登录并访问你的实例。

如果您在没有安装 Linux 子系统的 Windows 上，您必须使用 SSH 客户端。我个人认为这种方法相对容易通过 SSH 登录到您的实例。下载一个像 Bitvise 或者 Putty 这样的 SSH 客户端(我用的是 Bitvise)，你的屏幕应该是这样的。

作者图片

转到客户端密钥管理器->导入，并导入下载的密钥对 pem 文件。为此，您必须将文件类型更改为所有文件。在主机旁边的空白处，键入与您的实例相关联的 12 位 IP 地址。在端口旁边，键入 22。在用户名旁边的空白处，键入 cc。这是大多数变色龙实例的默认用户名。在 Initial method 旁边的下拉列表中，选择 public key。一旦你这样做了，一个新的名为 Client Key 的下拉菜单就会出现。在此下拉列表中，选择您刚刚附加的客户端密钥，对于我来说，这是 Global 1。选择登录。现在，您已经通过 SSH 登录到您的实例。此时，您可能会遇到几种不同类型的错误。如果是这样，请检查您的实例是否已经实际启动，您的密钥对是否正确，以及您是否填写了正确的 IP 地址。在某些情况下，您可能已经做了所有正确的事情，但是 chameleon 只是没有将密钥对与实例相关联，它可能无法启动实例。在这种情况下，我建议您删除实例并重新启动它。您可以通过转至“计算”->“实例”并在“实例的操作”下的下拉列表中选择“删除实例”来终止实例。

在 bitvise 中，如果您已经成功登录到您的实例，在窗口的左侧，您将会看到如下内容:

作者图片

新的终端控制台是你可以访问你的终端和运行代码，新的 SFTP 窗口是你可以从你的电脑上传文件。

我希望你觉得这篇文章简单易懂，内容丰富。如果你有任何问题，请在下面的评论中提出。

如何快速学习一门新的编程语言

原文：https://towardsdatascience.com/how-to-learn-a-new-programming-language-on-the-fly-7b6df0ea0c90?source=collection_archive---------9-----------------------

帮助您快速学习新编程语言的独特技巧。

在 Unsplash 上由zdenk macha ek拍摄的照片

过去，我总是惊讶于程序员可以毫不费力地学会新语言。

类似于看着一个通晓多种语言的人从俄语到德语到葡萄牙语，以及其间的一切都令人惊叹不已，看着一个程序员不费吹灰之力地从一种语言转换到另一种语言也同样令人惊叹。

那些程序员在我看来总是在另一个阶层。我一直认为那些程序员是天生的天才，是那些学生时代不学习就能在数学和科学课上飞来飞去的人。我一直以为我配不上他们。

直到我开始学习编码。

我终于明白，没有人生来就知道如何编码，我终于意识到，在学习一门新的编程语言时，没有人是真正“有天赋”的。最后，这一切都归结于你如何学习，以及你的学习方式是否有效。

熟练掌握编码基础知识。

一旦你学会了如何用一种语言编码，你就基本上知道如何用所有的语言编码。唯一的区别是语法、结构和约定。换句话说，不要忘记基础。就像标点符号、句子结构以及名词、代词和动词的用法在每种自然语言中的用法一样，列表、if/else 语句、for 循环和数据类型也在(几乎)每种编程语言中使用。

记住: 计算思维和编码基础适用于所有编程语言。

因此，一旦您理解了列表、if/else 语句、for 循环和数据类型(以及其他)是如何在一种语言中使用的，您就会熟悉它们在任何编程语言中是如何工作的。唯一的区别是语法、结构和围绕它们的约定。

如果你从这篇文章中吸取了什么，那就是:不要在学习编程基础知识上吝啬。

编写一些比“Hello World”更有意义的代码。

很久以前，在一个遥远的地方，你的第一个新语言节目是“你好，世界”，这成了惯例，不，是传统。

虽然这一切都很好，但是什么时候“Hello World”成为一种新编程语言最有意义的首次应用呢？为什么不做一些大胆的、意想不到的事情呢？为什么不做一些能真正教会你一门新语言如何工作的东西呢？

相反，让你的第一个新语言程序变得有意义。现在是时候真正测试一下引擎盖下是什么，看看它是如何工作的。

诀窍是设计一个程序，让你对语言如何处理基本概念有一个基本的了解，比如打印出字符串，接受用户的输入，存储这些输入以备后用，处理简单的算法，实现数据结构，以及处理错误。

这可以采取的形式，一个随着用户输入越来越多而变得越来越聪明的游戏，一个试图诊断你的症状并随着你给出的症状越来越准确的程序，或者一个简单的博客，当它收到用户喜欢阅读的更多输入时，为用户提供更准确的阅读建议。

先学语言，再学框架。

程序员就像狗一样，很容易被下一个新的闪亮物体(或松鼠)分散注意力。

当学习一门新语言的全部原因是为了能够使用随之而来的框架时，这种情况尤其常见。相信我，我也掉进过同样的陷阱。

框架是建立在它们所属语言的编程概念之上的。如果不了解这门语言，你就不会非常熟悉如何使用这个框架。

例如，假设你在一个你不会说这种语言的国家得到了一把锤子。你以前从未用过锤子，也不知道它能用来做什么。那个国家的当地人试图告诉你如何使用锤子，但他们是在用他们的母语做这件事。你一点也不懂这种语言，所以你不知道该怎么用锤子。除了让那个人在你身上使用锤子让你明白它是如何工作的，下一个合乎逻辑的步骤可能是学习一点语言，让你明白如何使用锤子。

换句话说，在使用工具(框架)之前，你需要学习语言。

力求理解，而非完美。

我不明白为什么这个世界痴迷于编写完美的代码。

当然，编写最干净、最有效的代码绝对是一件值得努力的事情。但是，我觉得这就是人掉进陷阱的地方。

从很多方面来说，编码就像写作。人们写作的问题是他们太过于追求完美，以至于他们实际上没有在纸上记下很多单词或想法。同样的问题也会出现在人们的编码中。许多人不会容忍犯错误和编写糟糕的代码，而是将大部分时间集中在尽可能编写最干净、最短和最有效的代码上。

虽然编写最干净、最短和最有效的代码是每个人都应该渴望的一个美好的长期目标，但在学习一门新的编程语言时，这并不值得关注。例如，当一个方法可以很好地工作时，直接跳到 lambda 函数是没有意义的。lambda 函数有其存在的时间和地点，但现在的重点应该是理解这种新语言的基础。

在你第一次学习一门新的编程语言时，努力追求完美的代码就像在去一个新的国家之前，感觉需要学习所有的动词变化，阴性和阳性名词，以及自然语言的句子结构。事实上，你所需要知道的就是如何说一些简单的短语，一些脏话，并且对如何阅读这种语言有一个大致的了解，这样你就不会到达你不应该到达的地方。每个人都会明白你的意思，即使你用迂回的方式说这种语言，并不总是完美的。

换句话说，在学习一门新的编程语言时，第一次就要减轻自己编写完美代码的压力。总会有更快、更短的方法来做某事，但这不应该是重点。相反，专注于编写运行并完成工作的无 bug 代码——特别是如果你正在匆忙学习这门语言。它可能不漂亮，但它仍然会工作。

最后的想法。

本文仅涵盖了我在学习新编程语言的过程中使用的一些技巧。然而，我觉得我应该补充几个其他更传统的提示，给你快速学习一门新语言的最好机会:

阅读文档。虽然不是所有的语言文档都是一样的，但是你可以很好地了解一下让你正在学习的语言独一无二的具体细节。
确保你是出于正确的理由学习语言。如果你学习这门语言是为了加薪，你的老板需要你用这门语言完成一个项目，或者你会经常使用这门语言，那么恭喜你，你正出于正确的原因学习一门新的编程语言！
参加黑客马拉松、Kaggle 竞赛和编码挑战。没有什么能像竞赛一样迫使你巩固你对新编程语言的知识。
将程序与精通该语言的人配对。我经常发现，当你和精通一门新语言的人一起工作时，学习这门语言的效果最好。当他们编码的时候，坐下来听听他们的思维过程，可以让我们深入了解这种语言是如何工作的，以及为什么他们会以一种特定的方式使用它。
使用适合你的学习方式。如果你是视觉学习者，使用流程图、代码片段、思维导图和视频来更好地理解一门新语言。如果你是听觉学习者，使用 Youtube 视频、在线课程或 MOOC 讲座。如果你是一个阅读/写作学习者，阅读语言文档、博客文章、网站文章、代码片段和 GitHub 代码库。如果你是一个动觉型学习者，跟随视频并在你自己的 IDE 中写下代码，或者基于源代码创建项目。不要忘记你的学习方式可能会随着时间而改变。对通过各种方法学习持开放态度，直到你找到最适合你的方法。

除了坚持和一致，没有什么能保证快速学会一门新的编程语言。不幸的是，当一门新语言对你的工作来说是必要的时候，你会有很大的压力去快速掌握这门语言。为了避免这种压力，在技术世界里，当学习像一门新的编程语言这样棘手的东西时，你必须知道如何学习最好，并发挥你的优势。

学习一门新的编程语言是一项有益的活动，不仅会在你的职业生涯中有所帮助，而且从长远来看，还会使你成为一名更加全面、可靠和足智多谋的程序员。

如何学习机器学习中的任何算法

原文：https://towardsdatascience.com/how-to-learn-any-algorithm-in-machine-learning-1836f093d093?source=collection_archive---------42-----------------------

这个简单的方法也可以让你很好地学习它

Jorge Fernández Salas 在 Unsplash 上拍摄的照片

我们都知道机器学习是一个快速扩展的领域，似乎每分钟都在创造新的技术。虽然在进入这些新的、通常是先进的论文之前，最好从该领域的基础开始，但对于该领域的新手来说，经常会出现一个问题:

我如何学习这个领域中的各种算法，以及如何学好它们？

如果你是这个领域的新手，最好的方法是对基本面有一个坚定的理解，这很简单。简单地说，当你学习算法时，尝试用你最喜欢的编程语言从头开始构建它。请允许我解释…

当在这个高度技术性的领域学习一个新概念时，我相信从零开始构建东西不仅可以加强你的编程技能，还可以让你对算法实际上是如何工作的有一个自下而上的基本理解。需要记住的一点是，在机器学习中，我们所做的一切本质上都是数学化的。如果你不理解算法背后的数学，你就不能有效地将结果的关键见解传递给那些非技术人员——我可以补充一句，你和那些技术人员打交道一样多。

虽然这应该是常识，但让我从现在开始提出一个小小的免责声明:你从零开始构建算法不应该代替高度优化的库来完成特定的任务。相反，你构建的算法应该作为学习数学的补充，并看到它一步一步地实时求解。如果您以前从未构建过神经网络，您可能无法理解 PyTorch 或 TensorFlow 库中 API 调用的底层机制。

我真的相信，如果你正在学习一个新的算法，了解它是如何工作的是一个很好的开始，但是学习如何自己构建它真的会让你迷失在 为什么 它会工作的美丽中，在我看来，这是这个领域中最有趣的地方。

在(随机)森林中迷路比想当然地使用 API 调用更有趣。||照片由塞巴斯蒂安·恩劳在 Unsplash 上拍摄

不要成为一个阅读公式，使用 API 调用来解决问题，并说你熟悉这个概念的人。这不会长期强化你的学习。你可能会假装自己知道什么是 SVD 分解，因为你可以在 Python 中键入SVD(X),但是如果你在面试中被要求解释它，你应该解释它是什么——并且解释得很好。

即使你是该领域经验丰富的工程师，花一个下午的时间从零开始构建一个分类器或聚类算法也是重建基础和进一步巩固基础的好方法。仅仅因为你有经验并不意味着你的技能不会随着时间的推移而生疏。花时间回到基础会让你更擅长你的手艺，这是必然的。

“学习吧，就像你永远无法掌握它一样；拿着它，好像你会害怕失去它。”——孔子

你有什么想法？我很乐意讨论你是否有自己学习新算法或巩固基础的方法。

请继续关注，因为我也计划在闲暇时重建一些算法。我非常喜欢许多机器学习算法背后的数学，从零开始构建它们的能力在我看来非常有趣。

感谢您的阅读。

我的一些文章:

https://medium.com/swlh/why-you-must-use-linux-dddf7cabb266

如何用简单的话学习 CircleCI

原文：https://towardsdatascience.com/how-to-learn-circleci-in-simple-words-2275e4299628?source=collection_archive---------22-----------------------

行业笔记

作为数据科学家创建 CI/CD 管道的行动手册

照片由 Alexas_Fotos 在 Unsplash 上拍摄

在过去的几年里，我开发了几个软件产品。其中常见的一个关键步骤是构建一个管道来测试、构建，以及部署。无论你是建立一个人工智能产品还是 Web 应用程序，你都需要一个持续集成和部署(CI/CD)管道。拥有这条管道有助于您构建高质量的软件，并加快开发过程。有许多 CI/CD 工具，如 CircleCI、TeamCity 和 Jenkins。在本文中，我用简单的语言描述了如何用 CircleCI 建立一个简单的 CI/CD 管道，并为您提供了您必须使用它的场景。首先，让我从我如何熟悉软件开发中的这个重要概念开始。

当时的 MLOps 方案并不多。因此，我们开始使用现有的通用工具创建自己的 MLOps 解决方案。

我在 2013 年开发了一个基于 ML 的手势识别引擎。我们需要一个自动化的管道来构建、测试和归档 ML 模型，以确保质量并加快开发过程。当时的 MLOps 解决方案并不多。因此，我们开始使用现有的通用工具创建自己的 MLOps 解决方案。我们开始与团队合作。那时候， Jenkins 是在 DevOps 团队中建立 CI/CD 渠道最流行的选择。然而，我们是一个小型的机器学习团队，没有太多关于 DevOps 和 Jenkins 的经验，这不是最简单的解决方案！我们发现，与 Jenkins 相比，TeamCity 提供了一个用户友好且易于设置的环境。因此，我们使用 TeamCity 创建了一个自动化的管道来构建、测试和归档 ML 模型。

几年后，我发现了 CircleCI 并爱上了它。你可能会问为什么？因为它非常强大，而且简单直观。在这里，我想帮助您建立 CircleCI 的 CI/CD 渠道。您可能希望使用 CircleCI 构建自己的 MLOps 解决方案，或者构建一个自动化管道来构建和部署 Web 应用。希望这能帮助你更好地适应这项神奇的技术。

照片由德米特里·拉图什尼在 Unsplash 上拍摄

CircleCI 的“工作”是什么？

“作业”是在单个单元中执行的步骤的集合。您可以出于各种目的创建工作。例如，您可以为集成测试创建一个作业，并为性能测试创建另一个作业。您还可以创建一个用于构建解决方案的作业和另一个用于部署该解决方案的作业。一个作业有三个主要部分:(a) 执行者 , (b) 环境变量 , (c) 步骤。这里有更多关于创建工作的细节，你可以在这里找到。

执行者

必须确定作业执行者(即运行作业的机器)。您可以使用 Docker 容器或虚拟机(Linux 或 Windows)。我通常为作业执行者使用 Docker 容器，因为我对它们有更多的控制权。使用 Docker 技术有助于我减少对服务的依赖，并能够在需要时迁移到其他服务。

环境变量

您必须确定该作业所需的所有环境变量。这里定义的环境变量可用于所有步骤。您还可以在某个步骤中定义环境变量，该步骤专用于该步骤。如果你想成为软件开发专家，你应该彻底学习如何定义和使用环境变量。

步伐

最后，在前面的步骤中设置了环境变量之后，您必须确定需要运行的步骤。例如，如果 CircleCI 和 Github 连接正确，可以使用checkout命令将代码库复制到执行器中。您可能还需要运行 CircleCI 团队预先构建的特殊步骤。例如，如果没有特殊的配置，就不能在 docker 容器中构建 docker 映像。CircleCI 让您的生活变得轻松！您只需要在checkout之后添加一个名为setup_remote_docker的新步骤。要了解更多关于如何在 docker 容器中运行 docker 命令的信息，你可以在这里阅读。

version: 2.1 jobs:
  build:
    **docker**:
      - image: circleci/<language>:<version TAG>
        auth:
          username: $USERNAME
          password: $PASSWORD
    **environment**:      
      - USERNAME: my-dockerhub-user
      - PASSWORD: my-dockerhub-password
    **steps**:
      - checkout
      - run: echo "this is the build job"

CircleCI 中的“工作流”是什么？

“工作流”是一组规则，用于根据需要按特定顺序运行一组作业。例如，您可以定义一个简单的工作流来为开发过程中的每个提交运行一个作业(通常是单元测试)。您还可以定义一个更复杂的工作流来构建一个在“构建”作业之前需要“测试”作业的解决方案。工作流中使用了几个重要的操作来设置所需的规则，例如(a) 过滤器、( b) 要求和(c) 触发器。这里有关于创建工作流的更多细节，你可以在这里找到。

下面，您可以找到一些需要设计特殊工作流来满足需求的场景。

场景 1 ( 当您需要一个特定分支的作业) —您希望只在名称以“feature”开头的分支上运行构建作业。您应该过滤分支，只找到那些名称以目标名称开头的分支。在这种情况下，可以使用filters命令。
场景 2 ( 当你需要一个有序的作业系列) —你想按顺序设置一系列作业。例如，当一个新的拉请求被合并到主分支中时，您想要在 web 上自动部署一个解决方案。在部署作业开始之前，必须彻底运行构建作业。在这种情况下，可以使用requires命令。

Workflow:
  jobs:
    - build:
        **filters**:
          branches:
            only:
              - /feature\/.*/
    - deploy:
        **requires**:
          - build

场景 3 (当您需要一个事件在午夜被触发)——您想要使用最新的开发在每天午夜创建一个 ML 模型。您还想在那个时候自动创建一个测试报告，并在第二天的清晨提供给团队。因此，您希望“train_test”作业在夜间运行。在这种情况下，可以使用triggers命令。阅读更多。

workflow:
  version: 2
  nightly:
    **triggers**:
      - schedule:
          cron: "0 0 * * *"
          filters:
            branches:
              only:
                - master
                - beta
  jobs:
    - train_test

场景 4 (当您需要一个事件由一个拉请求触发时)——您希望确保没有错误注入到主分支中。因此，您不仅希望在每次提交时运行测试作业，还希望在拉请求时运行构建作业。很抱歉。在代码上做不到。您应该在 CircleCI 高级设置面板上更改配置。阅读更多。

—遗言

我强烈建议从项目一开始就使用 CircleCI，尤其是在开发基于云的服务时。他们提供令人敬畏的免费服务，可以长期满足个人项目的要求。如今，您可以将 MLflow 等专门的 MLOps 解决方案用于数据科学项目。但这并不意味着他们可以取代 CircleCI。2013 年，我们使用类似于 CircleCI 的服务创建了自己的 MLOps 解决方案。但这并不意味着你应该这样做！

感谢阅读！

如果你喜欢这个帖子，想支持我…

跟我上 中！
在 亚马逊 上查看我的书！
成为 中的一员 ！
连接上Linkedin！
关注我的 推特！

https://pedram-ataee.medium.com/membership

如何用 Python 交互学习数据科学？

原文：https://towardsdatascience.com/how-to-learn-data-science-interactively-with-python-b2528e403aee?source=collection_archive---------5-----------------------

当您进行分析时，JupyterLab 扩展会动态生成代码。

杰米·芬恩在 Unsplash 上的照片

随着人们对数据素养需求的增长，Python 也越来越受欢迎。不管你是博士数据科学家还是刚刚开始学习，Python 的一个缺点是语法需要很长时间才能正确。人们经常花费大量的分析时间去堆栈溢出或谷歌查找正确的代码。

有没有更好的办法？

如果你错过了我以前写的关于米托的文章，看看这里的https://romanorac.medium.com/list/mito-a-spreadsheet-that-generates-python-1df29fc67dff。

当您进行分析时，米托会动态生成代码

照片由亚历山大·奈特在 Unsplash 上拍摄

米托是一个 JupyterLab 扩展，可以轻松地使用 Excel 来探索和转换数据集。

米托通过自动代码生成大大减少了“搜索正确代码片段”的时间。

使用米托，您可以将电子表格接口调用到您的 Python 环境中，并且您所做的每次编辑都会在下面的代码单元格中生成等效的 Python。

每个点击操作都会动态生成一个代码片段(作者可视化)

大多数 Python 用户知道他们想要如何操作他们的数据，无论是:

将数据集合并在一起
填充缺失值
创建图表
添加列等。

米托允许用户不需要知道完美的代码就能完成这样的任务。用户在米托完成操作，米托会为你吐出代码。

米托在运行中自动生成代码(图片由作者提供)

安装米托

可以用这两个命令安装米托:

python -m pip install mitoinstaller
python -m mitoinstaller install

打开 Jupyter 笔记本后，渲染一个有丝分裂表:

import mitosheet
mitosheet.sheet()

以下是完整的安装说明。

米托支持熊猫数据框架

要将数据输入米托，您可以将数据帧作为参数传入，

mitosheet.sheet(df)

或者，您可以使用导入选项从本地文件中选择数据集。

将数据集导入米托(图片由作者提供)

米托功能

在 Unsplash 上由 Patrick 拍摄的照片

米托的功能侧重于数据清理、数据处理/探索和数据可视化。米托的数据清理功能包括:

填充缺失值
删除行
更改列数据类型
编辑特定值
删除列
重命名列
更多

米托利用 Excel 的易用性，将这些特性应用于 Python 和 pandas 数据框架。

例如，如果您需要更改数据帧中的特定值，只需直接在 Mitosheet 中编辑该值。

米托电子表格中数据帧值的交互式编辑(图片由作者提供)

此操作生成的代码如下所示:

ramen_ratings_csv.at[10, 'type'] = "Nissin"

探索性数据分析

由弗兰基·查马基在 Unsplash 上拍摄的照片

数据探索和操作是米托的一些最突出的特点。其中包括:

连接/合并数据集
创建数据透视表
过滤数据集
排序列
查看汇总统计数据
更多

用米托创建数据透视表(图片由作者提供)

形象化

米托还集成了 Plotly ，这是一个允许交互式图表的开源图形库。Plotly 图表允许放大可视化部分、导出为 PNG 等功能。

米托允许用户不用写代码就能生成这些图表。可视化配置完成后，用户可以通过单击“复制图形代码”按钮导出等效代码。

生成的代码如下所示:

# Import plotly and create a figure
import plotly.graph_objects as go
fig = go.Figure()# Add the bar chart traces to the graph
for column_header in ['country']:
    fig.add_trace(
        go.Bar( 
            x=df2[column_header],
            y=df2['type count Movie'],
            name=column_header
        )
    )# Update the title and stacking mode of the graph
# See Plotly documentation for customizations: [https://plotly.com/python/reference/bar/](https://plotly.com/python/reference/bar/)
fig.update_layout(
    xaxis_title='country',
    yaxis_title='type count Movie',
    title='country, type count Movie bar chart',
    barmode='group',
)
fig.show(renderer="iframe")

结论

Jason Blackeye 在 Unsplash 上拍摄的照片

米托是一个强大的 Jupyter 实验室扩展，用于探索性数据分析和快速生成 Python 代码。它的局限性在于它还没有涵盖所有的数据科学功能。米托仍然需要添加更全面的可视化选项，以及更多的统计和建模功能，除非他们想保持探索性的数据工具。但这是一个值得尝试的扩展。

在你走之前

如果你喜欢看这些故事，为什么不成为 中等付费会员 *？每月 5 美元，你可以无限制地阅读 10000 个故事和作家。如果你用我的链接注册，我会赚一小笔佣金。***

由凯利·西克玛在 Unsplash 上拍摄的照片

如何通过看论文学习深度学习

原文：https://towardsdatascience.com/how-to-learn-deep-learning-by-reading-papers-c51b6025f226?source=collection_archive---------19-----------------------

创建一个系统，以便与深度学习研究保持同步

卡斯帕·卡米尔·鲁宾在 Unsplash 上的照片

⚠️读了我在⚠️博客中的原帖

深度学习发展如此之快，以至于跟上的唯一方法是直接从发布这些新发现的人那里阅读。如果你是一个技术人员，想在 2021 年了解深度学习，你需要阅读论文。

正规教育只能让你到此为止。不幸的是，一般来说，大学在将新材料纳入课程方面进展缓慢，直到几年前，它们才开始教授深度学习。这是欧洲的情况，我承认在美国可能会有所不同。

大学深度学习

在 AI 和深度学习的花哨名字下，大多数课程在短短一个学期的时间内挤压了经典的机器学习网络、神经网络、CNN、RNNs、LSTMs 和汽车线路检测等应用。

如果这是你第一次接触机器学习，在课程结束时，你只会知道网络的一般概念，以及一些作业的代码片段。一个学期学不了 ML。

而且因为教材太新，知道的人又太少，大部分课程设计很差，用花哨的名字吸引人，却只教基本的东西。除非你上了一个有完整的、专门的 ML 课程的大学，否则你不能指望光靠大学来学习深度学习。

书本上的深度学习

下一个选择是书籍，由人工智能研究人员编写。Goodfellow 和其他知名人工智能研究人员的深度学习书籍是一本非常全面的基础知识书籍。你可以免费在线阅读个别章节，也可以付费阅读整本书。

书籍的问题在于，由于它们需要花费大量的时间来制作，而且这个领域发展如此之快，到它出版的时候，有些东西可能已经过时了。你可以用书来获得基础知识，但是如果你不想让你的知识过时，你需要跟上当前的研究。

在线课程中的深度学习

在 Coursera、EdX 和许多其他平台上有无数的机器学习和深度学习在线课程。与书籍一样，在线课程需要大量时间来录制、编辑和发布视频和内容。你可以用它们来夯实你的知识基础，也许还可以用来练习编码，但我 2018 年在 Coursera 上做的深度学习认证已经 3 年没变了，这个领域肯定变了。

利用大学视频进行深度学习

这当然是一个富有成效的方法。许多美国大学喜欢在网上发布他们的讲座，其中一些还提供他们的作业。这些大学是唯一提供深度学习方面的最新教育的大学，以结构化的形式提供，并且拥有知道自己在说什么的人。例如，密歇根州的计算机视觉深度学习就非常受欢迎。斯坦福也在学期结束后发表了他们的一些讲座，所以请留意他们，因为他们是最新的。

它们并不完全是最新的，因为课程也需要准备时间。等到讲师开始准备材料，直到学期开始和结束，一整年可能已经过去了。在那一年，许多新的东西将会出版。尽管如此，在观看视频前一年了解深度学习的具体领域是一个非常好的方法，如计算机视觉、自然语言处理、翻译、演讲或任何你感兴趣的东西。最后一年，你必须阅读论文。

用论文进行深度学习

我建议你使用结构化的方法，比如我之前提到的方法，来构建你的深度学习知识的坚实基础。一旦你学会了深度学习的一般概念，我猜你已经做到了 2016 年左右。如果你看过美国大学的视频，可能要到 2018 年。我假设你已经了解了 CNN，RNNs/lstm，一些计算机视觉和 NLP。

如果你想了解新的术语，如变形金刚、BERT、预训练模型、迁移学习、偏见、人工智能中的伦理、零短期学习、神经翻译、GANs、强化学习、多模态模型和许多其他术语，你必须求助于论文，因为这些术语还没有出现在在线课程、书籍和大学讲座中。

阅读报纸

arXiv 是一个论文档案库，深度学习研究人员在这里上传他们的论文。arXiv 中的论文数量逐年稳步增长。一般来说，这些领域停滞不前或略有增长，但数学和计算机科学(cs)却出现了爆炸式增长。这些是机器学习或深度学习的典型领域。

基于类别的 arXiv 累积论文

在训练深度神经网络成为可能之前，机器学习是数学的一个分支，在那之后，它被称为深度学习。2013 年左右，计算机视觉在 ImageNet 上度过了黄金时代，2015 年，NLP 在 LSTMs 上开始了自己的时代，并且随着近年来的进步，变形金刚，预训练模型和其他关于数据集和偏见的更隐藏的研究，它仍然保持强劲。

截至 2018 年，每天约有 100 篇新的 ML 论文，远高于摩尔定律，该定律表明该数量每两年翻一倍。变压器模型是在 2018 年推出的，这是一个大繁荣，所以我估计新 Arxiv 论文的数量要么增加了，要么至少保持不变。

值得注意的是，Arxiv 论文只是预先发表的论文，其中一些会在会议和期刊上发表，但大多数不会。但很多未发表的论文价值很高，值得考虑。

每年 ML arXiv 论文的累计数量(arXiv)

具体看机器学习，发表数量在加速增长。我很想写下研究正在加速，但不幸的是，发表的数量与该领域的进展并不相关。

如果你在过去的几年里关注了关于 ML 的出版物，你会注意到越来越多的论文被发表。对于如何从更具体的事情中分离出相关的事情，你可能会感到不知所措。如果你不在学术界，跟踪研究不是你的工作，这将会更加困难。

深度学习的领导者之一 Andrej Karpathy 最近谈到跟上深度学习研究有多困难，因为有太多的论文。

我没有完美的方法，但在这篇文章中，我想分享我如何跟上深度学习和我感兴趣的子领域的相关论文:NLP，特别是讽刺检测和一些计算机视觉。

1.过滤相关文件

任何试图跟上当前研究的人肯定会问自己:

有这么多论文。

我读哪些？

我如何找到重要的文件？

在如此高的新论文率下，我们可以忘记手动检查和过滤。可惜的是 arXiv 没有任何排名系统，所以直接去页面很难找到感兴趣的论文。我将详细说明我获得潜在论文列表的来源。

1.1.推特

我有一个深度学习人员的名单，他们定期发布他们发现相关的新论文的链接。通过跟踪不同的研究领域，你将在每个领域获得大量有趣的论文。我关注的一些人是:

谷歌人工智能发布谷歌在深度学习所有领域所做的研究，通常是在 arXiv 之外。可以包括计算机视觉，NLP，强化学习，GANs。
一般 ML/DL 研究人员:萨拉胡克，哈德曼鲁，奥马萨罗
NLP 研究人员:阿凯茨·祖比亚加，贾斯米恩·巴斯廷斯，雷切尔·塔特曼，米克尔·阿特塞
计算机视觉:安德烈·卡帕西

这些人中的许多人会从其他人那里转发，所以你可以通过他们找到其他来源。我想特别提到 hardmaru 和 omarsar0，他们会定期发布一篇有趣论文和一个简短摘要的链接，以及许多学习 deepl 收入概念的资源。还有一点要提一下 Rachael Tatman，她定期举行论文阅读会，在阅读论文的同时，她还解释了许多概念。

如果有你感兴趣的深度学习的特定领域，你可以在 Twitter 上搜索研究人员或从业者，你会有规律的新内容为你涌入。

1.2. ArXiv 理智保护者网页

ArXiv sanity preserver 是 Karpathy 建立的一个网站，目的是通过过滤相关论文来保持理智。你可以根据不同的标准进行排名:最近，最近热门，热门宣传(转发次数)，如果你建立一个帐户来保存你的偏好，还有其他可用的功能。

我个人喜欢热门炒作部分，在那里你可以看到过去一天、一周或一个月在 Twitter 上被提及最多的论文。想法是相关的或有影响力的论文将被传阅和讨论。

例如，在撰写本文时，BERT(2018 年出版)在 Twitter 上的参与度很高，位居炒作榜榜首。我们可以看到那是一篇重要的论文。如果你在列表中看到你感兴趣领域的 2-3 年前的论文，我当然会看一看。

尽管这个网站很有用，Karpathy 自己也说这个网站过滤的相关论文数量太多，跟不上，所以更多的过滤可能是必要的。

1.3.论文与代码网页

这是你可以找到趋势研究的另一种方式，在这种情况下，本网站上的所有论文都提供了论文的代码，如果你想复制它或进行更深入的研究，这真的很有用。

你可以找到一般的趋势论文，或者按章节组织:计算机视觉、NLP、医学、演讲等。还可以通过深度学习模型中使用的方法进行浏览。

1.4.棒极了 Github 仓库

在 Github 中，牛逼的资源库是资源的精选列表，你可以找到几乎每个主题的信息。数据科学、机器学习和深度学习都有自己的牛逼的仓库，里面有代码、教程、书籍和论文。在这里你可以找到深度学习论文的精选列表，尽管它已经几年没有更新了。

对于深度学习子领域的更具体列表，您可以搜索“github awesome computer vision medical ”,例如针对您的特定用例。

1.5.本人论文列表😃

这有点自我推销的意思，但我也有自己的相关论文列表，按主题分开，按时间顺序排列，用标签标注。例如，您可以找到一个用于讽刺检测的 NLP 数据集，您可以通过查看标签#datasets 和#讥讽检测来找到它。我主要收集 NLP 的论文，但不是全部，我包括许多旧的，基本的论文，它们是当前研究的基础。

如果你觉得有趣，一定要启动资源库:)

1.6.但是，如果我刚刚开始，这些论文太难了怎么办？

这是一个现实问题。如果你从未读过一篇研究论文，试着去读任何一篇当前的论文，你很可能几乎什么都不懂。这是因为研究是累积的，每篇论文都引用了许多更早的论文，而这些论文又是基于以前的论文。

我的 NLP 研究之旅

当我开始阅读 NLP 论文时，在介绍中作者提到他们正在使用一些人介绍的一些架构。我对它不熟悉，所以我找到了报纸并开始阅读。这个架构引用了一些我也不知道的东西，所以我查了一下，并开始阅读另一篇论文。

我想读一篇论文，结果我有一叠 15 篇论文，这些论文反复引用了其他论文。

所以我的建议是，不要因为不理解论文中提到的大部分概念而感到难过。它可能会被引用，所以先找到那篇论文并试着理解它。

你将不得不递归地回到基础论文之前，但是一旦你这样做并开始理解基础知识，你将构建你的知识模块，并对你阅读的论文有很强的理解。

根据您之前的知识，这可能需要一些时间。但是如果你想阅读和理解论文，你需要理解参考文献。

此外，这个令人惊叹的深度学习论文路线图存储库包含按时间顺序排列的论文，从更基础、更通用到更具体。你也可以用这个来指导你的学习。

2.组织纸质阅读

如果你遵循了第一部分的步骤，你的列表中会有很多论文。阅读论文是一项需要集中注意力至少一个小时的活动，所以除非你是一名学者，可以每天阅读论文，否则你必须在你的时间表中找出时间来阅读它们。

你可以尝试不同的策略，对我来说最有效的一个是在工作日下班后每周阅读 3 篇论文。在前一个星期天，我会选择接下来要读哪三本书，并在日历上分配时间。有时候会有其他事情发生，但是这个系统对我来说非常好。

3.看报纸

你有你想要阅读的论文列表，从基础论文到最新的，或者从我提到的前几个资源。我建议你一次只关注一个话题。如果你对演讲感兴趣，在转向另一个子领域之前，把你的时间集中在演讲上，直到你对自己的知识有信心为止。

但是一旦你选择了你想读的报纸，实际上该怎么做呢？

2.1.模拟与数字

这是个人偏好，有些人喜欢在他们的电脑上阅读 pdf，而其他人喜欢打印出来并在纸上做笔记。

2.2.先弄清楚论文的大意

在你开始阅读细节之前，先了解一下这篇文章的大意。是一个数据集，一个模型，一个系统？它基于什么，一般来说是如何工作的？

如果你明白这一点，那么你就可以深入研究方法论。否则我建议先看参考文献。

2.3.记笔记

除非你有惊人的记忆力，否则你会忘记很多你读过的东西，花这么多时间在上面是浪费时间。所以我建议你像我在我的论文库那样保存你的学习成果。

如果你喜欢把笔记保存在笔记本里，那很好，只要确保它们易于搜索，并且当一篇论文引用另一篇时，你可以快速地从一篇跳到另一篇。

无论你选择哪种媒介，我认为把你理解的东西记下来并保存在某个地方是一个非常好的主意。随意复制我的存储库的模板，制作你自己的列表。

4.跟上新的报纸

看论文是一项永无止境的任务，那么如何跟上新论文呢？

我在 Twitter 上关注许多研究人员，所以如果他们谈论一篇论文，我感兴趣，我就会把它添加到我的列表中。然后，我每周日都会提醒自己查看 arXiv sanity preserver 和带代码的论文，如果有我想看的论文的话。如果是这样，我会将它们添加到列表中。最后，我分配了三篇论文在下周阅读。

结论

深度学习的发展速度越来越快，尽管不可避免地会错过一些东西，但我希望在我的工作领域的研究方面保持一定的更新，我知道很多人也是如此。

我希望这篇文章帮助你创建了一个系统来跟上这种混乱的新论文速度，随时在 Github 上启动我的回购来查看我阅读的新论文的更新，在 Twitter 上关注我或者给我发消息，如果你有任何问题:)

感谢阅读！

如何用简单的话学习 Git

原文：https://towardsdatascience.com/how-to-learn-git-in-simple-words-263618071dd8?source=collection_archive---------1-----------------------

行业笔记

保护你数据科学家职位的行动手册

扬西·敏在 Unsplash 上的照片

在过去的几年里，我和许多数据科学家一起工作过。我发现他们中的一个共同点是缺乏软件开发技能。软件开发中一个简单但重要的实践是版本控制，在其他技术存在的情况下，它在业内被称为 Git 。我发现许多数据科学家对 Git 不太适应，主要是因为他们不明白为什么、在哪里以及如何使用它。在本文中，我用简单的语言描述了 Git 技术，并为您提供了必须使用它的场景。我还描述了你日常开发需要的最重要的功能:(a) 保存变更 , (b) 检查代码库 , (c) 撤销变更，和(d) 重写历史。希望这能帮助你更好地适应这项神奇的技术。

在数据科学面试中，你可能不会被问到，例如，“必须如何有效地使用 Git？”。然而，您必须从第一天开始就知道如何使用 Git。

在数据科学面试中，你可能不会被问到，例如，“必须如何有效地使用 Git？”。然而，您必须从第一天开始就知道如何使用 Git。如果你不愿意和 Git 一起工作，你会给你的经理留下不好的第一印象；尤其是更高级的 Git 操作，比如 Rebase 。如果使用不当，高级 Git 操作可能会产生降低开发速度的问题。

当我采访数据科学家时，我也会评估他们的软件开发技能。许多面试官不进行这样的评估，但这并不意味着他们不希望你知道 Git。由于不了解 Git 技术，你最终会与同事进行非常低效的协作，这很容易危及你的职位。所以，要做好准备。

Git 是什么？

Git 是一个被广泛接受的软件，用于跟踪团队内部用于协调开发的代码库(也称为版本控制)的变化。在版本控制中，主要的目标是保持你的本地代码库与远程代码库同步，同时你拉取其他开发者所做的所有最新变更，并推送你所做的所有最新变更。远程代码库是主要的代码库，开发人员必须经常查看它以了解最新的变化。

Git 是一种技术，它使你能够在所有代码都频繁改变的时候，保持每个代码库与远程代码库同步。 Git 让您保存和检索开发中每个步骤的快照，也称为“状态”。我们有许多软件行业中状态管理技术的例子，如 Docker(平台即服务)或 Terraform ( 基础设施即服务)。Git 是广泛接受的代码变更状态管理技术。

Git 让您保存和检索开发中每个步骤的快照也称为“状态”。我们有许多软件行业中状态管理技术的例子，如 Docker 或 Terraform。Git 是广泛接受的代码变更状态管理技术。

Roman Synkevych 在 Unsplash 上拍摄的照片

—如何使用 Git？

保存更改

开发中一个常见的噩梦是由于任何原因丢失了一天来所做的代码更改。Git 让您有机会在本地代码库和远程存储库中保存您的更改。您可以使用commit命令将您的更改保存在本地代码库中，使用push 命令将您的更改保存在远程代码库中。如果你想暂时保存最新的修改，你可以使用stash命令。你通常在你想要的时候使用stash，例如，在两个分支之间切换而不提交。

检查代码库

有时，您需要检查代码库，以收集关于代码库中变更状态的更多信息。我在上面描述了 Git 是一种状态管理技术，所以你必须能够随时跟踪代码库的状态。您可以使用status命令来显示和跟踪代码库的状态。您还可以使用log命令来显示提交的快照。log命令让你列出项目历史，并搜索特定的变更。

撤消更改

出于多种原因，您可能需要撤消一些已提交的更改。您可以使用reset命令撤销更改。该命令有两种主要类型:hard 和soft。当soft参数被传递时，所有的代码更改都保留在代码库中，但是所有相应的提交都将被删除。当hard参数被传递时，代码库的状态被完全重置为您所指向的代码库的确切状态或快照。代码库的每个快照都用唯一的提交 id 注册。我来分享两个你需要用reset搭配soft和hard实参的场景。

场景 1 (当你需要使用**reset --soft**)——你在一家对开发范式有严格规定的公司工作。你正在开发特性 A 的一个分支，同时，你开始开发特性 B，你忘记创建一个新的分支，并在特性 A 所在的分支上提交与特性 B 相关的代码变更！在几次提交之后，您注意到了这一点，并决定清理您的分支。您必须撤消您的更改。
场景二 ( 当你需要使用**reset --hard**)——你正在进行 Git 操作，突然，你犯了一个错误。你最近所有的改变都被删除了，你变得非常沮丧。您希望将代码库恢复到您可以确定其质量的快照。这时，你需要的是回到干净的代码库的快照。

请注意，hard参数必须由谨慎使用，因为它会删除所有内容。

重写历史

一群开发者可能反对重写历史；然而，许多其他人使用这个强大的特性来更快地开发，同时减少冲突。如果使用正确，您可以使用此功能在状态管理系统中建立干净的历史记录，并快速解决冲突。重写历史必须使用的主要操作符是rebase。您可以使用 rebase 将几个提交压缩成一个提交。

在两种主要场景下，你需要使用rebase。

场景 1 —几天前你拿走了主分支的一个分支。你做了一系列的发展，但你的工作还没有完成。在此期间，您的同事完成他们的任务，并将他们的更改合并到主分支中。现在，您的分支与主分支中的最新变更不同步。您必须将您的分支(取自main分支的旧快照)重新建立在main分支的最新变更之上。你可能会问为什么？因为否则，您不能将您的变更合并到主分支，因为您的分支已经过时了(即，可能与main分支有一些差异)
情景二 —你在一家分公司工作了一段时间。您在大量提交中提交了您最近的更改。出于两个原因，您决定在提交中压缩您的提交(即重写历史)。首先，你要有一个清晰的开发路径(也称为干净的历史)来确保开发的坏习惯不会被推到远程代码库。第二个，你想在main分支的最近变化的基础上重新调整。如果您的分支中有许多提交，冲突解决(即，您的分支和新的主分支之间的差异)会变得更加困难，因为您必须解决每个提交中的冲突。

注意，如果你不是 Git 专家，千万不要试图自己或在关键代码库上重写历史。我强烈建议在一个关键项目中应用这些命令之前，使用一个实验性的代码库来掌握 Git，尤其是复杂的命令。你可以在下面的文章中了解更多。

—遗言

如果你想了解更多，你应该了解一下git-flow。然而，什么是 git-flow 呢？基于 git 的开发工作流，也称为 git-flow，是构建和发布软件的一系列开发步骤的。为了进行有效的协作，你还必须知道最基本的 git 流的具体细节。你可以在这篇文章中读到两个最重要的 git 流: Git 流是生产力的源泉，而不是混乱。

我强烈推荐你去看看 Atlassian 创作的超赞的教程。另外，如果你不习惯 Git CLI，你可以使用伟大的 Atlassian 的 Git 客户端，名为 Sourcetree 。虽然它并没有消除您使用 Git CLI 的需要，但它为您提供了一个用户友好的环境来使用 Git 满足许多常见需求。

感谢阅读！

如果你喜欢这个帖子，想支持我…

跟我上 中！
在 亚马逊 上查看我的书！
成为 中的一员 ！
连接上Linkedin！
关注我 推特！

https://pedram-ataee.medium.com/membership

如何学习 LSTM 的长期趋势

原文：https://towardsdatascience.com/how-to-learn-long-term-trends-with-lstm-c992d32d73be?source=collection_archive---------10-----------------------

Intel 和 Johns Hopkins 开发的一种提高 LSTM 性能的方法

长短期记忆(LSTM)网络广泛用于语音识别、语言翻译和时间序列预测。然而，LSTMs 很难了解长期趋势。

图 1:普通递归神经网络(RNN)的示意图。图片作者。

2021 年，英特尔和约翰霍普金斯大学的研究人员合作开发了一种 LSTM 细胞，提高了准确性和速度。这个方法非常新，所以不幸的是没有任何库/包。但是，它可以使用任何基本的深度学习包手动构建。

让我们开始吧…

技术 TLDR

信息以幂律速度衰减。换句话说，随着我们沿着 LSTM 细胞链越走越远，我们会以幂律速率丢失先验信息。然而，LSTM 忘记盖茨以指数速度删除信息，这阻止了学习长期趋势。
考虑到信息的幂律衰变，我们创造了一个新奇的遗忘门。该遗忘门使用 sigmoid 复位功能，如有必要，清除先前信息，仅清除当前时间步长的参考信息。然而，当复位未被激活时，与传统的遗忘门相比，先前的信息被保留更长时间，从而允许信息的幂律衰减。

但是，到底是怎么回事呢？

这将是一篇非常技术性的文章，但是你不需要太多的先验知识来理解核心概念。这东西很酷，所以让我们慢下来，了解到底发生了什么…

什么是 rnn 和 LSTMs

从头开始，让我们定义我们的神经网络框架。处理顺序数据(NLP、时间序列等)时。)，通常的做法是使用递归神经网络(RNN)。rnn 只是一系列神经网络，其中一个的输出是下一个的输入。

然而，rnn 并不完美。训练时，存在不稳定梯度的可能性。这就是长短期记忆(LSTM)细胞的来源。

lstm 是 RNNs 中的一个专门单元，使用 gates 来管理输入和输出信息。

门是激活功能，取值在 0 和 1 之间。如果一个门取一个小值，比如说 0.001 ，我们将其乘以输入信息，然后大幅缩小。相反，如果门取一个大值，比如说 0.998 ，我们将它乘以输入的信息，并让它基本保持不变。

但是这个不稳定梯度问题是什么，LSTMs 是怎么解决的？

我们为什么需要 LSTMs

嗯，和任何神经网络一样，rnn 是通过按照所有先前节点导数的乘积成比例地更新节点权重来训练的。所以，如果网络中其他节点的导数接近于零，我们的权重更新将会非常非常小。这种现象被称为消失梯度问题，并阻止我们的模型学习。

同样，如果我们网络中的梯度非常大，我们的权重更新也会非常大。这被称为爆炸梯度问题。

现在，基本的神经网络通常不会遇到这个问题——如果你只有两三层，就没有多少小/大导数的复合。但是，如果 RNN 有许多神经网络依次堆叠在一起，会发生什么呢？

正如你可能已经猜到的，rnn 有更多的层，因此细胞衍生物有更多的机会复合。

这就是 LSTM 细胞的用武之地——它们有调节信息流的闸门，因此不稳定的梯度不太常见。

LSTM 细胞结构

现在我们有了背景，让我们来理解 LSTM 细胞的解剖结构…

图 2:LSTM 电池的组件— src 。图片作者。

乍一看，发生了很多事情。但是真的没那么差。

在图 2 中，带有 σ (sigma)的青色方框是门。它们是神经网络，决定有多少信息应该来自先前的细胞和我们的预测者。请注意，它们的编号为 1-3。

在决定保留多少信息后，gates 将这些信息传递给我们的 tanh 。tanh 函数负责更新节点的权重。

最后，我们输出两组信息:单元格状态和隐藏状态。单元状态充当长期记忆，隐藏状态是短期记忆。

快速回顾一下这些门，让我们参考下面的数字并定义它们…

遗忘门:确定我们应该遗忘多少长期信息。被保存的信息被输入到我们的细胞状态中。
输入门:决定我们应该忘记多少短期信息。保存的信息被输入到我们的 tanh 函数中进行培训。
输出门:利用长期和短期信息，确定在我们的隐藏状态下应该输出多少信息。

通过使用这些门来调节信息流，我们能够避免计算有问题的梯度。

很好，所以我们不再有消失梯度的问题了。但是，遗憾的是，LSTMs 也不是一个完美的解决方案。让我们进入英特尔和约翰霍普金斯大学的研究人员讨论的概念。

问题是:信息衰减

在很多情况下，我们希望从数据中了解长期趋势。例如，如果我们在看我们最喜欢的股票价格的每日时间序列，去年的价格可以代表今天的价格。但是,“遗忘之门”倾向于删除之前许多步骤中的信息——如果它在过去的 100 天里没有用，我们为什么要保留它呢？

图 3:细胞状态的指数(红色)与幂律(蓝色)信息衰减。y 轴是保留信息的比率。x 轴是时间步长— src 。图片作者。

事实证明，LSTM 细胞中的信息以指数速度衰减，如图 3 中的红线所示。因此，在这个模拟中，传统的 LSTM 单元将会删除之前 150 个时间步长的几乎所有信息。这无疑给了解年度趋势带来了问题。

那么，我们如何保存信息以便长期学习呢？

先前的研究表明 NLP 信息以幂律速率衰减，而不是指数衰减。通过判断图 3 中的曲线，我们可以看到幂律曲线在保留的信息方面有一个不太陡峭的下降。

很好，那么让我们弄清楚如何让 LSTM 细胞以幂律速度而不是指数速度忘记信息。

解决方案:新的遗忘之门

研究人员的贡献是一种符合幂律标准的新型遗忘门。

图 4:新的遗忘之门在 LSTM 细胞信息流中的位置— src 。图片作者。

如图 4 所示，我们用一个新的遗忘门取代了 sigmoid 遗忘门，它可以更好地调节长期记忆中存储的信息。

免责声明，这可能会有点复杂，但我们会尽可能保持高水平。

细胞状态

让我们从定义我们的细胞状态开始，也就是我们的长期记忆。

图 5:时间步长 t 的单元状态的定义。

在图 5 中，组件 1(我们的遗忘门)和组件 2(我们的先前细胞状态)决定了保留多少长期信息。组件 3(我们的输入门)和组件 4(我们的中间细胞状态)决定了保留多少短期信息。

如果你好奇的话，中间带点的奇怪圆圈是哈达玛积。它仅仅意味着我们将两个矩阵中每个索引的值相乘。

新的遗忘之门

现在，我们来定义一下研究者提出的小说《遗忘之门》。

图 6:幂律遗忘门的定义。图片作者。

在图 6 中，我们有一个新的遗忘门，它控制着我们在长期记忆中回顾多远。 t 对应于当前时间步长的索引， k_t 对应于感兴趣的第一个时间戳的索引， p 是控制我们的信息衰减速率的可学习参数。

请记住，我们的遗忘之门的目的是调节长期信息的流入量。它通过将该信息乘以 0 到 1 之间的值来实现。所以，如果 f_t 接近 1，我们保留大部分信息。反之，如果 f_t 接近于 0，我们就丢失了大部分信息。

更具体地说，当回溯到很远的时候，我们的遗忘门取值接近 1。这意味着我们保留了大量的长期信息。然而，如果我们着眼于短期，我们的遗忘之门会更近，我们只保留部分信息。****

重置门

最后，您可以将 k_t 视为一个黑盒，它输出第一个包含有用信息的索引，然后就此打住。但是，为了完整起见，让我们看一看。

图 7:幂律遗忘门复位元件的定义。图片作者。

在图 7 中，我们看到一个新变量: r_t (重置门)。复位门是一个 sigmoid 激活函数，意味着它取 0 和 1 之间的值。如果其值为 1，则 k_t-1 被取消并删除所有先前信息。如果其值为 0， t 取消，我们保留所有历史信息。

摘要

哇哦。我们刚刚涵盖了大量的信息。

如果一切都不清楚，在这些方程中输入数字和/或阅读论文(链接在评论中)可能会有帮助。话虽如此，要想深入理解，这里有三个要点:

传统的 LSTM 细胞会很快丢弃有用的信息。
在这篇文章中，我们概述了一个对长期信息更明智的遗忘门——它在长期学习任务中胜过传统的 LSTM 细胞。
概述的遗忘门引用找到有用信息的最早索引。利用这个指数，它可以定制应该将多少长期记忆传递到我们的模型中。

感谢阅读！我将再写 40 篇文章，将“学术”研究引入 DS 行业。查看我的链接/教程的意见，建立 LSTM 的权力法。

如何学习 Matlab

原文：https://towardsdatascience.com/how-to-learn-matlab-f96160fc46b2?source=collection_archive---------11-----------------------

开始您的 Matlab 之旅所需要知道的一切

在 Unsplash 上由 Rich Tervet 拍摄的照片

与其他开源编程语言相比，Matlab 无疑拥有最全面的文档。正因为如此，我总是认为学习和进入 Matlab 世界应该是一个非常简单的过程，不管你已经是一个经验丰富的其他语言的程序员，或者这是你想开始的第一个语言。

然而，当我最近开始这段旅程时。我惊讶地发现，阅读官方文档有时并不是体验这种语言的最有效方式。正是因为它非常全面，它应该被更好地描述为参考而不是教程。有鉴于此，我决定总结一下我所学到的东西，我相信这将涵盖你需要知道的最基本的东西。

博客中使用的代码可以在我的 Github 库中找到。

前言:我推荐的学习一门新语言的步骤

虽然这只是我自己的观点，但我坚信学习语言的第一步应该是熟悉它的数据类型。最不重要的步骤是记住各种功能。我们没有人能够知道每一个功能，但是多亏了这些文档和我们的“最好的朋友”——谷歌，现在找到正确的功能已经变得容易多了。然而，如果你不了解每个变量的属性是什么，那将是一个很难前进的道路，并在此基础上发展新的知识。

在这篇博客中，我将严格遵循这个程序，向你展示我通常是如何学习一门新语言的:

第一步:学习 Matlab 数据类型

我发现理解 Matlab 很有用的一点是，

每个对象都是一个矩阵(数组)

让我们用下面的代码片段来说明这一点:

数据类型训练营(图片由作者提供)

我倾向于使用最愚蠢的例子来解释基本的想法，没有任何功能或逻辑语法。所以在 Matlab 控制台中，我输入了 10 多个不同的变量，它们的数据类型显示在右边的工作区窗口中。正如你所看到的，Matlab 中的一切看起来都像一个矩阵/数组(工作区窗口中的 size 列)，当你键入a=1，a时，实际上变成了一个1*1数组，而class是double，这是因为double是所有数值变量的默认类。你可以随意的将它转换成另一个类，使用相应的转换函数。如果你想知道如何做到这一点，只需谷歌那个，这就是为什么我建议函数应该是最后一步学习，而不是首先要担心的事情。现在，你只需要知道你有可能选择不同的职业，然后你就可以知道了。

继续，我们初始化了另一个变量b='hello'，你可能认为它是一个字符串，但实际上，b恰好是一个大小为1*5的数组，类为char。如果你真的想有一个string变量，你需要用双引号，所以我们有c="hello"。现在c变成了一个1*1数组，现在类为string。char array将每个字符视为一个单元，而string将整个字符串/句子视为一个整体。你可以像变量g=["hello","yes"]一样拥有string array。

然后，我们有一个数值向量和矩阵。在 Matlab 中，使用whitespace进行水平扩展，使用;进行垂直扩展。所以，对于一个2*3矩阵f，应该使用[1 2 3; 4 5 6]来创建。同样，行向量d应该是[1 2 3]，列向量e应该是[1;2;3]。

如果我们在一个数组中有混合的类呢？我们需要使用cell array来存储混合类型。变量h是一个形状为2*3的单元格数组，它的类是cell，表示数组中每个元素的类型都是不同的，正如你所看到的，我们既有char、double，甚至还有嵌套的双数组。

下一个类类型是struct，它类似于 Python 中的dictionary，代表一个key-value关系，我们用变量i来说明struct的创建。同样，i也是一个数组，其类类型为struct。

到目前为止，我希望这个思路更清晰一点，你可以把 Matlab 中常见的对象都看成数组， 一个数组也可以包含其他数组 。但是，类的类型是不同的。为了加强理解，让我们构建一个变量j，我把它做成一个三维数组，但是类的类型是struct。我们可以简单地将这个数组的形状指定为(1，2，2)，并将一个struct元素分配到一个槽中。

Matlab 共有哪些内置类类型？ 和大多数其他语言一样，常用的类型包括int，它可以进一步由int8、int16 …和uint8等无符号语言组成。然后，double用于浮点数，char和string用于文本，logical包含值true或false，以及我们上面解释过的struct类类型。

最后但同样重要的是，您是否注意到在每个命令的末尾总是有一个;？这是为了禁止在控制台中打印这一行。默认情况下，每一行都将在控制台中执行和打印。此外，每个没有赋值变量的命令(见第 13 行a+1)将被赋值给一个内部变量ans，这就是为什么我们在工作区窗口中有一个值为 2 的ans对象(ans = a + 1，a = 1)。

基本数据类型的介绍到此结束。因为一切都是数组，所以知道如何访问数组中的每个元素也很有帮助:

如何访问数组中的元素？(图片由作者提供)

需要记住的三件事是:

普通数组使用圆括号，单元数组使用花括号
Matlab 是 1 基索引 (Python 是 0 基索引)
理解**end** 关键字和切片操作(向前和向后)

除了上面的类类型，另一个有趣的类类型叫做“表”，让我们说下面的例子:

Matlab 中的表格类类型(图片由作者提供)

我们创建了一个表格，如右上角所示，在左下角，我们可以看到它的类类型是table，形状为 3*3。如果我们对每一列(姓名、gpa、年级)使用行向量，那么形状将变成 1 * 3。要访问每一列，我们需要使用点.符号。“table”类类型在常见任务中非常有用，因为它类似于其他解释语言中的dataframe对象。

第二步:循环、If、自定义函数等

我发现很多教程都着重于解释如何用每种语言编写for loop和if statement。虽然它们很重要，但是如果你已经有了至少一门语言的经验，一个简单的备忘单就足够了。因为这个教程真正的目的是说明 如何自己学习 一门新的语言，而不仅仅是灌输一些知识。我强烈建议你只要谷歌一下，一秒钟就能得到你需要的东西，但为了完整起见，让我在下面的截图中为你总结一下:

备忘单:Matlab 中的基本逻辑语句(图片由作者提供)

唯一值得注意的是，当构造一个函数时，Matlab 倾向于用一种独特的方式定义它，公式看起来像function return_value = function_name(arg1,arg2,...)，然后你只需通过它的function_name.调用函数

第三步:更多高级功能和各种内置功能

现在是时候探索更高级的主题了，例如，如何在 Matlab 中构建自定义类(面向对象编程，OOP)？或者，什么是 Matlab 中的匿名函数？你可以通过谷歌搜索它们得到你需要的东西(如果你点击链接，我已经为你做了)，我希望这可以帮助你习惯于如何深入真正的编程世界，因为这就是我们日常工作的方式。

正如我最初说的，我甚至没有在我的教程中教你一个内置函数，例如，如何连接两个字符串并进行点积或叉积。尽管如此，对基本数据类型的良好掌握将使您未来的学习更加容易。这就是我今天想与你分享的内容，我希望这篇小文章可以帮助你掌握你的特定任务所需的其他更高级的操作。

差不多就是这样！我希望你觉得这篇文章有趣和有用，感谢阅读！如果你喜欢这篇文章，请在 medium 上关注我，非常感谢你的支持。在我的 Twitter 或 LinkedIn 上联系我，也请让我知道你是否有任何问题或你希望在未来看到什么样的教程！

如何用单个神经网络学习多项任务

原文：https://towardsdatascience.com/how-to-learn-multiple-tasks-with-a-single-neural-network-50a99e01e6f9?source=collection_archive---------16-----------------------

灾难性遗忘曾经是一个棘手的问题。最近取得了进展，请继续阅读以了解更多信息。

艾莉娜·格鲁布尼亚克在 Unsplash 上的照片

现代神经网络非常擅长学习一件特定的事情。无论是下棋还是折叠蛋白质，只要有足够的数据和时间，神经网络就能取得惊人的结果。不幸的是，网络目前只能胜任一项任务。你可以训练一个网络擅长某件事，但一旦你试图教网络别的东西，它就会忘记在第一项任务中学到了什么。这被称为灾难性遗忘。由于智能的标志之一是学习和存储多项任务，因此如何在多项任务上训练神经网络(并解决灾难性遗忘)的问题极其重要。

一个想法是改变训练数据，使得每个任务的训练示例相互交错。例如，假设我们有 3 个任务 A、B 和 C，示例分别标记为 a_i、b_i 和 c_i。这种思想将训练集排序为 a1，B1，C1，a2，B2，C2，a3 等。重点是以同等的重视程度同时训练所有三个任务，希望通过这种方式学习的网络权重将包含关于所有三个任务的信息。在实践中，这个想法是可行的——网络将同时在所有三项任务上慢慢变好，避免灾难性的遗忘。

但是，在我看来这种方法是作弊。真正的智能学习(例如人类)不需要以这种方式交错任务。事实上，通常情况下，任务是在大时间块内连续学习的(我们称之为“块调度”)。典型的学校是这样安排的:首先你学 1 小时数学，然后 1 小时英语，然后再学 1 小时历史，以此类推。你不做一道数学题，写一句作文，然后看一句历史书。那么问题来了:有没有一种方法可以让神经网络用块调度来学习多个任务？

2016 年，Deepmind 的研究人员出了一篇论文解决了这个问题。我特别喜欢他们的方法，因为它没有那么复杂。他们真正做的只是对网络应用一种特殊类型的正则化。让我们仔细看看。

假设我们有两个任务，A 和 b，block schedule 是先用很多例子训练 A，然后我们切换到训练 b，Deepmind 的研究人员提出先正常训练 A(即正则梯度下降/反向传播)。然后，在 B 块期间，我们保持从 A 学习的权重，并继续梯度下降。唯一的区别是我们现在包括了一个二次正则化项，它对于每个权重都是唯一的。这个想法是使用这个每权重正则化来惩罚远离从 A 学习的权重。被认为对 A 更重要的权重将被惩罚得更重。在数学上，我们在 B 训练块期间的成本函数是 L(θ)= L _ B(θ)+σ(k _ I *(θ_Ai-θ_ I))，其中 I 是所有网络权重的指数，θ_ Ai 是 A 训练块完成后的权重。L_B(θ)是 B 的正态成本函数，可能是平方误差或对数损失。最后，k_i 是权重 I 对于预测 a 的重要性。

还有一种更直观的方式来思考每权重正则化。想象一个物理弹簧。当你拉弹簧时，你拉得越远，弹簧拉回来的力就越大。此外，有些弹簧比其他弹簧更坚固。这和我们的算法有什么关系？你可以想象一个弹簧连接到神经网络中的每个重量。所有弹簧的相对强度是正则化的。某些弹簧(对 A 来说很重要)会特别强，所以在 B 的训练过程中，算法会不鼓励去拉那些强弹簧，对应的权重不会有太大的变化。因此，该算法将改为拉动较弱的弹簧，并且对应于这些弹簧的权重将改变更多。

考虑这个算法的另一种方式是，它是对 L2 正则化的改进。利用 L2 正则化，权重不被鼓励改变太多，其惩罚对应于权重大小的平方和。然而，在 L2 正则化中，所有的权重被同等地惩罚。在我们的算法中，只有重要的权重被阻止改变。

好的——我们现在直观地理解了这个算法是如何工作的。通过保持 A 的重要权重相对恒定，我们可以在 b 上成功训练的同时保持 A 的性能。但是，我们仍然没有解释如何确定 A 的“重要”权重。所以让我们问一个问题:什么使权重变得重要？一个合理的答案可能是:如果一个权重比其他权重对最终预测的影响更大，那么它就是重要的。更具体地说，如果一个权重相对于最终预测的导数具有比其他权重导数更高的幅度，我们可以说该权重是重要的。但是我们忽略了一件事——因为神经网络中的权重会影响其他权重，它们的导数是相互关联的。换句话说，我们不能只考虑给定权重的导数本身；我们需要查看所有权重导数的协方差矩阵。一个更正式的版本被称为费希尔信息矩阵，这是研究人员最终使用的。

因此，总结一下:首先我们正常地训练 A，然后我们用每权重二次正则化训练 B。这些每个权重的正则化依赖于权重对 A 的相对重要性，这可以通过 Fisher 信息矩阵找到。结果是一个对 A 和 b 都很有效的神经网络。研究人员给这种方法起的名字是“弹性权重合并”(EWC)。

所有这些理论上的讨论都很棒，但实际上有用吗？研究人员在监督学习和强化学习环境中测试了这种新方法，以找出答案。首先，为了测试监督学习，研究人员使用了流行的 MNIST 任务。为了从 MNIST 创建多个任务，他们获取输入的 MNIST 图像，并用几个固定的常数对它们进行排列。这个想法是，在一个排列(MNIST 图像+常数 1)上训练的分类器不会在另一个排列(MNIST 图像+常数 2)上工作，所以实际上，我们有不同的任务。然后，研究人员比较了 EWC、规则梯度下降和 L2 正则化的结果。在第一项任务中(MNIST 图像的第一次排列)，所有三种方法都是可比较的。随着越来越多的任务被引入(其他排列)，EWC 远远比其他人表现得更好。

强化学习也有类似的结果。在这里，实验是学习十种不同的雅达利游戏。游戏的顺序是随机的。同样，在第一场比赛中，代理使用 EWC 和使用基线( DQN )获得了相似的性能。随着更多游戏的引入，EWC 在监督学习案例中逐渐退出。

在这篇文章中，我们介绍了灾难性遗忘的问题，并通过 EWC 算法背后的直觉。我个人认为 EWC 是朝着真正智能的正确方向迈出的一步，我很高兴看到接下来会发生什么。请留下任何问题/评论，感谢阅读！

4 门现代互动课程，学习和提高您的 Python 编码技能。

原文：https://towardsdatascience.com/how-to-learn-python-coding-9f096d70c22d?source=collection_archive---------12-----------------------

这里有一个免费资源的精选列表来指导你的学习过程。

如何免费学习 Python 编码——图片来自 Pexels 的 Christina Morillo

互联网上充斥着大量的学习资源。虽然我钦佩他们所有人，但我不禁认为初学者很容易迷路，再也回不来了。

我是自学的 Python 程序员。我见过很多成功人士也这样做。Python 理解起来非常直观，应用程序也非常强大。

我很高兴我选择了 Python。

我第一次学习 Python 是通过 codeacademy.com 的。通过他们的互动系统学习真是太棒了。但不幸的是，它不再免费了。

虽然我仍然向我指导的大多数人推荐它，但我有一个其他免费资源的列表。

这里有一个精选的列表，以及为什么它们看起来很棒。我希望这将有助于初学者找到正确的。

我保证会告诉你我会从哪里开始并进步，如果我要重新开始的话。但在此之前，让我们看看我们拥有的现代选择。

Scrimba:免费的交互式 Python 教程。

如何免费学习 Python 编码？截图来自作者。

为什么？ Scrimba 在互动性上更上一层楼！

和其他平台一样，导师会指导你学习课程材料。但是你可以暂停视频，开始编辑上面的代码。

这就是你在 Scrimba 教程上看到的魔力。

当我第一次看到这个的时候，我被迷住了。它几乎把你带到了一个真实的课堂环境。

给自己试试 Scrimba 。

光有交互性并不能成为一个很好的学习平台。Scrimba 每周举办编码挑战，每月增加新的课程。

这就是你在编程之旅中需要帮助成长的那种社区。

Datacamp:内置代码编辑器的高质量 Python 教程。

如何免费学习 Python 编码— Datacamp？截图来自作者。

为什么？ 专攻数据科学的 Python。

Python 对于许多应用程序来说都很棒。数据科学家喜欢它的简单性和对各种问题的适用性。正因为如此，几乎每个渴望成为数据科学家的人都会考虑学习 Python。

如果你对数据科学感兴趣，Datacamp 是你应该去的地方。

你可以在许多课程中选择适合你的课程。你将按照演示者的视频教程做一个互动练习。

除了 Python，还可以选择 R、SQL 等方面的课程。

自己试试 Datacamp 。

Hackinscience:通过解决问题来学习 Python。

如何免费学习 Python 编码— HackInScience？截图来自作者。

为什么？ 引导问题解决，逐步提高你的 Python 编码技能。

如果你不喜欢系列讲座，你应该去看看《黑客科学》。

Hackinscience 与这份名单上的其他网站不同。这是一个由五组互动练习组成的集合；基础、训练、算法、命令行和 NumPy。

Hackinscience 是巩固你的知识的一个方便的工具，值得一试。

亲自尝试黑客科学。

Sololearn:学习 Python 的社区。

如何免费学习 Python 编码— Sololearn？截图来自作者。

为什么？解决挑战，通过纠正彼此的错误来学习。

与其名字相反，Sololearn 是一个面向初级 Python 程序员的优秀社区。

除了 Python 之外，您还指导过许多其他语言的交互式课程。您可以选择一个并完成挑战以解锁下一关。

是的，听起来像电子游戏。

此外，你还可以找到数据科学、机器学习和 web 开发的课程。

亲自尝试一下。

如果它们不适合你，试试 YouTube 上最好的 Python 教程。

我们也有一些非常棒的 Youtube 视频，非常适合开始 Python 编程。我很想提到其中的几个，这是我最近回顾和推荐的。

Mosh Hamedani 的 Youtube Python 教程。

我强烈推荐 Mosh Hamedani 的视频给大家。他制作了很多技术的优秀视频教程，包括 Python。

免费代码营的 Youtube Python 教程。

Freecodecamp 的 youtube 视频是那些想学习 Python 的人的另一个高质量资源。在我看来，他们组织得很好，复习得也很好。

最后的想法，

这是来自互联网上数千篇文章、视频和指导教程的一小部分资源列表。最棒的是，如今知识可以自由获取。

Python 对每个人都非常有帮助，不管他们的职业是什么。如果你正准备开始学习 Python，我希望这里的列表能对你有所帮助。

就像我之前承诺的，如果我必须重新开始，我会这么做。

如果我是一个完全的新手，我会从 Scrimba 开始。这是一个顺畅的互动学习过程。同时，我会做黑客科学的练习。这会让你对基本原理有一个坚实的理解。

然后，我会学习 Datacamp 上的课程，以提高我的数据科学相关的 Python 编码技能。

不管我选择了什么，我都会在 Sololearn 上学习课程，并加入他们的社区。

Youtube 视频呢？在 Python 中工作多年后，我仍然会观看这些视频。

问好👋对我来说 在 LinkedIn 、 Twitter 、 Medium 。看来你和我有许多共同的兴趣。

还不是中等会员？请使用此链接 成为会员 因为我为你免费推荐赚取佣金。

如何像专家一样学习解决数据科学问题，并变得可就业

原文：https://towardsdatascience.com/how-to-learn-to-solve-data-science-problems-like-a-pro-and-become-employable-b3fd2f4bec71?source=collection_archive---------15-----------------------

学习数据科学的最实用方法(包括同类最佳参考资料)

斯科特·格雷厄姆在 Unsplash 上拍照

学习数据科学的方法有很多。有很多课程，新兵训练营，在线教程等等。我见过很多有数据科学认证的人找不到工作。问题是，大多数课程或训练营都不会教你找到工作所需的技能。获得就业机会的最佳途径是获得实践经验。获得能让你被雇佣的技能的最有效的方法是参与项目。

数据科学团队致力于解决许多业务问题。他们中的每一个人的方法都会非常不同。然而，解决问题所需的核心技能并没有太大变化。大多数现实生活中的数据科学问题属于以下类别之一。

回归
分类
使聚集
建议
自然语言处理
计算机视觉

在本文中，我将分享一些问题、解决这些问题的方法以及参考脚本。帮助您学习解决几乎所有数据科学问题。此外，这将有助于你获得能让你找到工作的技能。

回归

回归问题常常被低估，没有得到应有的重视。有些人甚至在不学习基础知识的情况下试图学习花哨的算法。如果你不能解释深度学习中的一个话题，你就可以被录用。但是，如果你不能解释一个回归算法，那就足以不雇佣你。

在回归问题中，目标变量是一个连续的数字。目标变量的值取决于自变量。这是最常见的数据科学问题之一。回归问题可以进一步分为线性和非线性。

线性回归算法的一个简单例子是预测房价。影响房价的因素有很多。所有这些影响房价的因素都是独立变量。房价属性是因变量/目标变量。求解线性回归算法的一般方法是，

1。数据探索

数据探索是任何数据科学项目的关键。项目的成功取决于对数据的理解程度。一些有助于更好的数据分析的技术是，

单变量分析——最能理解个体属性。我们一次选择一个变量来研究模式。这将是任何数据探索活动的第一步。它有助于建立对数据集的良好理解。
多元分析 —建立数据集中不同属性之间的关系。探究自变量和因变量之间的关系。
可视化分析 —用于捕捉数据集中的模式。在视觉数据中很容易找到模式。可视化是与利益相关者交流的有效工具。

2。数据准备

完成全面的数据分析后，我们继续进行数据准备。通常，数据准备和探索可以齐头并进。下面是一些需要修改的典型数据问题，

噪声数据 —数据集可能有噪声。数据集中的噪音无助于解决问题。丢失的数据是噪音。它们通常无助于做出正确的预测。我们需要处理噪声数据以获得更好的结果。
缩放比例 —不同比例的属性可能是个问题。尤其是如果我们使用基于距离的算法。将数据归一化到相似的比例始终是一个好的做法。
相关属性 —当我们有许多相关属性时，这被称为多重共线性。这通常不会影响模型预测。但是，它们确实对自变量的解释有影响。
异常值 —数据中的异常值影响方差和标准差。

最后针对以上问题进行数据分析。我们需要使用相关技术将它们转换成首选格式。转换技术将取决于算法和数据本身。

3。模型建立和评估

团队尝试多种模型是很常见的。那些表现更好的最终会被利用。在回归问题中用于模型评估的一些常见度量是，

绝对平均误差
均方根误差
均方误差
R 平方和调整后的 R 平方

4。模型调整

超参数调整和功能选择有助于模型调整。超参数调整是指为模型参数尝试不同的值范围。要素选择是关于包括和排除数据集的不同属性。

参考脚本

下面是一个文档非常完整的脚本，它将向您展示一个回归问题的实现。它涵盖了回归问题及其实现的各个阶段。它还包括不同的算法及其对性能的影响。

https://www.kaggle.com/faressayah/linear-regression-house-price-prediction

使聚集

聚类算法是一种无监督学习算法。模特培训没有标签。我们寻找数据集中存在的模式，将它们分组到不同的簇中。

解决聚类问题不同于解决监督学习问题。所涉及的步骤是，

1。数据探索

像任何监督学习问题一样，我们从数据探索开始。不同的是，我们更注重视觉分析。这里的目标是了解是否有任何清晰的集群。

2。选择正确的算法

下一步是确定正确的算法集。算法的选择取决于问题本身。在大多数情况下，我们会创建这样的群，其中一个项目只属于一个群。有时我们需要允许项目属于多个集群。在第一种情况下，我们使用 K-Mean 和层次聚类等算法。对于后者，我们使用模糊聚类。客户特征分析是模糊聚类的一个典型例子。客户表现出许多特征是正常的。在这里，允许它们以一定概率成为多个集群的一部分是公平的。

3。理想的集群数量

确定理想的集群数量至关重要。有一些技术和方法可以确定最佳的聚类数。技术取决于算法。

4。集群的特征

在识别聚类之后，聚类问题不被认为已经解决。仅仅向企业展示不同的集群是不够的。需要进一步的分析来证明聚类是正确的。视觉分析在这里起着关键作用。从视觉数据中获取洞察力是很容易的。

了解更多信息

要了解更多关于不同的聚类算法、其中涉及的步骤、每种算法的优点和缺点，以及理解关键概念，请查看下面的文章。

[## 数据科学家需要知道的 5 种聚类算法

towardsdatascience.com](/the-5-clustering-algorithms-data-scientists-need-to-know-a36d136ef68)

参考脚本

要了解聚类算法的实际实现，请查看下面的内容。这个 Kaggle 笔记本清楚地解释了 K-means 聚类算法的各个步骤。

https://www.kaggle.com/kushal1996/customer-segmentation-k-means-analysis

自然语言处理

到目前为止，我们讨论了使用结构化数据集的问题。现在，我们将了解如何使用 NLP 从非结构化数据集中提取值。组织一直在从结构化数据中提取价值。非结构化数据的潜力在很大程度上仍未被发掘。每秒钟都会产生大量的非结构化数据。社交媒体平台和其他公共领域有如此多的数据。这些非结构化数据有很大的价值。

在接下来的几年里，很多焦点将集中在从非结构化数据中提取价值上。流行的 NLP 用例可以分为:

情感提取——这些用例有助于理解公众情感。
主题建模——主题建模的一个例子是文档注释。
摘要——使用抽象或抽取方法对大型文档进行摘要。

了解更多信息

下面的文章将提供一个简单的逐步解决大多数 NLP 问题的方法。

https://blog.insightdatascience.com/how-to-solve-90-of-nlp-problems-a-step-by-step-guide-fda605278e4e

参考脚本

下面的笔记本将向您展示 NLP 用例的实现。首先，了解更多关于数据集结构的信息，生成元特征，并分析有影响的信息。最重要的是，这是有据可查的，很容易学习。

https://www.kaggle.com/tanulsingh077/twitter-sentiment-extaction-analysis-eda-and-model#EDA

计算机视觉

计算机视觉问题是我们从图像和视频数据中提取信息的问题。我们只是试图模仿人类的视觉和大脑。我们的大脑是根据多年来获得的知识来训练的。同样，在计算机视觉出现问题的情况下，我们需要训练机器。有不同种类的计算机视觉问题。他们是，

图像识别
目标检测
事件检测
图像分类

所有上述问题的基本原则是识别数据中的模式。处理能力的进步使得许多人都可以使用计算机视觉应用。AutoML 解决方案使计算机视觉用例的实现变得容易。下面是一篇关于使用 Datature 不用写一行代码就能实现物体检测的文章。

https://medium.com/geekculture/building-computer-vision-application-fast-without-any-coding-b09c3eb75912

参考脚本

下面的笔记本是一个很好的记录清晰的笔记本。它将向您介绍使用卷积神经网络的计算机视觉应用。

https://www.kaggle.com/yassineghouzam/introduction-to-cnn-keras-0-997-top-6

最终注释

学习数据科学的最佳方式是实践。到目前为止，所涵盖的算法将涵盖数据科学家在其工作中处理的大多数问题。包括的笔记本大多来自经验丰富的数据科学家。他们将帮助你学习最好的方法和标准。

为了更好地理解，尝试解决几个类似的问题。数据科学是一个通过实践可以学到更多东西的领域。

如果你在寻找学习数据科学的完整路径。这里有一个来自我的 YouTube 频道的视频，它将向你展示在 6 个月内学习数据科学的最佳方法。

保持联系

如果你喜欢这篇文章，并对类似的文章感兴趣，在 Medium 上关注我。成为的中级会员，访问数千篇与职业、金钱等相关的文章。
我在我的 YouTube 频道上教授和谈论各种数据科学主题。在这里订阅我的频道。
在此注册我的电子邮件列表，获取更多数据科学技巧，并与我的工作保持联系

如何在 90 天内提升您的数据科学技能

原文：https://towardsdatascience.com/how-to-level-up-your-data-science-skills-in-90-days-917c523e8dc9?source=collection_archive---------32-----------------------

学习数据科学技能的敏捷路线图

图片来源: Alex Kotliarskyi @ Unsplash

在过去几年中，数据科学一直是应届毕业生或转行者最受欢迎的领域之一。就业市场不断增长的需求是候选人数量不断增加的重要驱动力。简单看一下“数据科学工作”一词的谷歌搜索查询量就可以看出，对数据科学的需求越来越大，人才也在不断寻求加入这个蓬勃发展的行业。

随着数据科学在人才中越来越受欢迎，以及雇主推动的所需技术技能的膨胀，在过去几年中，数据科学就业市场对候选人的竞争越来越激烈，尤其是对应届毕业生。

谷歌搜索趋势搜索“数据科学工作”(谷歌趋势快照)

这些事实表明了持续学习和提升技能对于候选人和已经在该行业工作的数据科学家的重要性。虽然目前在该行业就业的数据科学家受益于在工作中学习许多新技能，但应届毕业生正在努力寻找合适的背景和路线图来学习就业市场上最受欢迎的技能。

根据我们的研究，活跃在就业市场上的超过 80%的数据科学家是有抱负的数据科学家或实习生，他们很难得到雇主的注意，即使是在全职工作的初步筛选电话中。此外，大约 30%的候选人表示对他们的机器学习技能没有完全的信心，40%的人对数据库技术没有信心，70%的人对云计算没有信心！这些统计数据表明，有抱负的数据科学家需要做大量工作来获得必要的技能，以引起雇主的注意。

Pouyan R. Fard，2021

提升数据科学技能的路线图

因为数据科学是一个非常新的领域，而且对于数据科学家的角色没有普遍的共识，所以对于有抱负的数据科学家来说，很难知道从哪里开始以及他们需要在每个主题上专注到什么程度。在这篇文章中，我展示了一个路线图，展示了有抱负的数据科学家如何在 90 天内提升他们的技术技能。在这里，我只关注候选人的技术技能，这些技能最初能引起雇主的注意。

以下是关于如何学习必要的数据科学技能以提升你在就业市场中的地位的路线图:

第一周:概率&统计
第二周:Python 编程
第三周:数据争论
第 4 周:探索性数据分析
第 5 周:机器学习——监督学习
第 6 周:机器学习——无监督学习
第八周:机器学习——时间序列分析
第九周:机器学习——深度学习
第 7 周:自然语言处理
第 10 周:数据库技术
第 11 周:视觉分析
第 12 周:云计算

如何在 90 天内学会数据科学

要克服在一个新领域开始学习如此多主题的最初困难和不知所措的感觉，你需要在学习上述技术技能的同时采取敏捷的心态。在职业生涯的这个阶段，你不能成为学习数据科学技能的完美主义者。请记住，对于许多雇主来说，你是监督分类等特定方法的绝对专家并不重要。相反，许多雇主需要拥有广泛技能的人来解决不同的问题，如在云上建立数据管道，设置分析仪表板，训练机器学习模型，以及与业务利益相关者交流见解。

在遵循这个路线图时，您需要记住，您需要关注您正在学习的概念和技术的实践方面。这意味着您需要专注于与路线图每周相关主题的实践学习。只要坐下来开始编码或者用编码甚至纸笔解决技术问题。像在线课程或书籍这样的资源可以非常有效地帮助你的学习之旅，但它们不能取代你亲自动手的需要。我相信通过跟随教程(尤其是在 Medium 上)或 Github 库中分享的实际例子，学习大多数技能是可能的。所以，强迫自己只在一周内学习一个新的话题，将有助于你成为最实际的，发现最重要的话题，而不是不必要的和理论上的细节，这些可以在以后学习。

数据科学是一个实用的工程领域；它不是关于理论机器学习和统计学，而是应用这些方法来解决现实世界的商业问题。因此，在您学习这些技术的同时，请始终考虑如何在现实世界中使用这些方法，尤其是解决业务问题。如果你能培养这种心态，你将成为一名成功的数据科学家，你很快就会在这个领域看到自己的成长。

TL；DR Summary:
在这篇文章中，我分享了如何在 90 天内提升你的数据科学职业生涯的必要技能的路线图。我相信大多数有抱负的数据科学家都在努力学习进入该领域所需的技能，或者吸引雇主的注意力以获得面试机会。对于有抱负的数据科学家来说，数据科学技能的学习需要快速、敏捷、实用、动手，并专注于数据科学的现实问题，而不是在每个主题的理论方面走得太深。

请注意，有许多因素决定着候选人求职的成功，包括但不限于技术技能、软技能、工作申请、社交策略、面试技巧等。因此，获得顶级数据科学职位的建议是超越技术技能，致力于软技能、行业知识和网络战略。

更多文章来自作者:

关于作者:

Pouyan R. Fard 是 Fard Consulting 的首席执行官&首席数据科学家。Pouyan 在数据科学、人工智能和营销分析方面拥有多年的公司咨询经验，从初创公司到全球公司。他曾与制药、汽车、航空、运输、金融、保险、人力资源和销售等行业的财富 500 强公司合作。

Pouyan 还积极指导活跃在大数据行业的初创公司和求职者。他的热情是通过职业培训培养下一代数据科学家，并帮助他们找到数据科学领域的顶级工作机会。

Pouyan 已经完成了关于消费者决策预测建模的博士研究工作，并对开发机器学习和人工智能领域的最先进解决方案保持兴趣。

如何利用神经风格转移来创建令人惊叹的图像

原文：https://towardsdatascience.com/how-to-leverage-neural-style-transfer-to-create-stunning-images-c30eb4a9007a?source=collection_archive---------43-----------------------

人工智能艺术

会画图像的人工智能

神经风格转移应用于阿尔及利亚足球运动员马赫雷斯的图像——由作者制作

图像风格转移

图片来自纸张3

图像样式转移是一种可以应用于图像绘画的方法，其目标是从一个图像中提取样式，并将其应用于第二个图像，同时保留第二个图像的内容，就像上面的图像所示。

为了实现这一点，需要定义图像的风格。

事实上，图像的风格与其纹理有很大关系。因此，通过使用纹理提取方法，我们本质上是在提取图像的风格。

这些方法被称为视觉纹理建模方法。这些方法有两种类型:

具有汇总统计的参数纹理建模
基于马尔可夫随机场的非参数纹理建模

为了在图像上应用这种风格，我们可以使用图像重建技术。这些技术也有两种类型:

基于图像优化的在线图像重建。
基于模型优化的离线图像重建。

卷积神经网络可用于视觉纹理建模和图像重建。

神经类型转移

在图像中进行风格转换的一种相当简单的方法是使用论文“ 艺术风格的神经算法 中描述的方法。

你需要什么:

一个 CNN (VGG，盗梦空间等等)，它是在一个大的数据集(ImageNet)上预先训练的。
一个你想样式化但保留其内容的图片，姑且称之为“内容图片”。
一个你想提取其风格的图像，姑且称之为“风格图像”。

怎么办:

把这两张照片都传给 CNN。
从内容图像和样式图像中提取特征映射。
要从样式图像中获取样式，您需要使用所谓的“Gram matrix”。这是一种奇特的说法:计算不同特征地图的平均值和相关性。
因此，特征图将代表图像的内容，而 Gram 矩阵将代表图像的风格。
接下来，你需要优化一个损失函数。这个损失函数的目标是使内容图像的样式尽可能接近样式图像的样式。
最后，你基本上将一幅图像的风格转移到了另一幅图像上，同时保留了后一幅图像的内容。

作者使用 NST 方法创作的狮子图像

上图是我用 Tensorflow 提供的教程中的 开源代码 创建的。

顺便说一句，如果你想学习如何使用 Tensorflow，那么请查看我的 免费 Tensorflow 课程 ，它专注于计算机视觉的深度学习。

实时神经类型转移

从艺术的角度来看，前面的方法给出了一些很好的结果，但是缺点是它太长了。

每幅图像都必须经过一系列的迭代，提取两幅图像的内容和风格，然后进行优化，使一幅图像的风格接近另一幅图像的风格。

由于这个障碍，文献中提出了另一种方法2。通过这种方法，有两个神经网络一起工作。

一个网络从风格图像中提取风格。另一个网络有两个输入:内容图像和前一个网络的输出。

使用这种方法，整个系统在训练阶段从大数据集学习绘画风格的表示。

在测试时，网络直接从样式图像中提取样式，并将其应用于内容图像。不需要优化！

结论

AI 可以用于艺术造型。有一些深度学习方法可以将一幅图像的风格转移到另一幅图像，同时保留后者的内容。

有不同的方法来实现这一点，其中一些需要在线优化。这意味着无论何时你想要设计一个图像，都必须有一个优化例程，这需要一些时间。

其他方法使用离线优化，这使得神经风格转移系统能够学习如何提取图像的风格，并在训练过程中将其应用于新图像。在测试时，样式的转换很快。

参考

[1] Leon A. Gatys，Alexander S. Ecker，Matthias Bethge，“一种艺术风格的神经算法”。

2 Golnaz Ghiasi，Honglak Lee，Manjunath Kudlur，Vincent Dumoulin，黄邦贤 Shlens，“探索实时、任意神经艺术风格化网络的结构”。

3永成静等，神经风格迁移:综述。

关于作者

我是一名机器学习工程师，致力于解决具有挑战性的计算机视觉问题。在 LinkedIn 和 Twitter 上关注我的每日内容。此外，通过加入我的 时事通讯 ，让这样的文章直接进入你的收件箱。

如何在数据块上加载和存储 R 中的 MLFlow 模型

原文：https://towardsdatascience.com/how-to-load-and-store-mlflow-models-in-r-on-databricks-hacking-the-constraints-93ce458af7ff?source=collection_archive---------17-----------------------

破解约束

Databricks 已经成为云计算的重要组成部分，尤其是现在，在谷歌宣布在谷歌云上推出 Databricks 之后。然而，必须指出的是，它仍然是一项试验性的技术，在效率和覆盖面方面还有很长的路要走。

对于数据科学来说，r 是最强大和使用最多的语言和环境之一，年复一年，统计人员努力开发不同的库。由于这一点，你可以找到几乎所有用 R 实现的数学模型，这对于你能想象的大多数 DS 项目的成功是非常有用的。但是，R 有一个重要的缺点:大数据。在处理海量数据时，SparkR 和其他公式还远远不能提供一个庞大的 ML 库目录。大部分 BigData SaaS 和 PaaS 都专注于 Python 和 Spark，比如 Databricks，努力开发一个完整的框架，并试图定义一个 ML 工件的端到端周期，而不是关注在 r 中完全支持他们的产品

例如，当在数据块中对 R 模型使用 MLFlow 时，就会发生这种情况。诚然，Databricks 支持 R、Python 和 Scala 代码，但在使用 MLFlow 和 R 时，尤其是在尝试注册 ML 模型时，会发现不同的弱点。

什么是 MLFlow

MLFlow 是一个围绕 REST APIs 构建的 ML 平台，它允许记录 ML 模型的实例作为存储库。这些实例被打包，以便发送到部署工具，但是在运行您的实验时，它还注册不同的度量、模型数据、配置或代码版本。稍后，您可以将它们可视化，并比较多次运行的输出。

如果您不熟悉 MLFlow，请查看他们的文档，并尝试使用 Databticks 进行免费试用。

来自 DataBricks 网站的一个例子

MLFlow 目前处于 alpha 阶段，这是它仍然存在弱点的原因，但在部署我们的 ML 模型时，这是一个强大的想法。

MLFlow 如何在 Python/Spark 上工作

让我们看一个 Python 上 MLFlow 的快速例子。首先，我们必须安装并加载库:

在此之后，我们必须使用以下命令创建或设置实验:ml flow . set _ experiment(path _ to _ experiment)。在注册任何实验之前，我们可以转到给定的路径，我们会看到实验已经创建，但它是空的:

然后，我们可以运行我们的模型，并在我们的实验中注册执行:

使用 autolog() 我们可以自动记录所有参数、分数和模型本身，但是如果我们不想跟踪整个上下文，我们可以使用 log_metric()、log_param()、log_artifact() 或 log_model() 函数选择保存什么。实际上，我发现 log_model 函数非常有趣，因为它允许我们跟踪带有标签的模型，这可以帮助我们稍后从存储库中加载模型。点击此处查看文档。

在此之后，如果您现在转到实验路径，您将看到您已经记录的所有实验的记录。大概是这样的:

来自 DataBricks 网站的示例

一旦模型被训练和记录，它可以在模型库中从无传播到试运行和生产阶段(寻找transition _ model _ version _ stage()函数)。在 Databricks 中，存储库可以在“模型”选项卡中可视化:

来自 DataBricks 网站的一个例子

然后，可以很容易地从存储库中加载它，用于我们的预测。用户只需调用ml flow . load _ model(path _ to _ model)指令，即可在笔记本中使用所需的模型。

尝试在数据块中使用 MLFlow 的 R API

遵循与 Python 流相同的结构，我们首先加载库并安装 mlflow:

第一个区别出现在设置实验的时候。在 R 中，我们不能设定一个不存在的实验；因此，为了以防万一，必须使用 try-catch 来捕获错误，并在需要时创建实验。之后，让我们尝试运行执行并记录模型:

现在，如果我们检查实验路径，我们将看到实验和运行已经创建；然而，在存储库中没有跟踪到任何模型。这令人惊讶，因为没有返回任何错误。大多数人都被困在这里，MLFlow 必须解决这个问题，但原因是:

registered _ model _ name(‘predictor LDA’)是在 mlflow.log_model，中使用的一个有用的参数，不幸的是目前在 R 库中不可用。

如果我们想在 R 笔记本中加载 MLFlow 模型，这是一个令人头疼的问题，但有一个解决方案。在任何 Databrick 笔记本中，您可以通过在单元格的开头指定语言魔术命令%<language>来覆盖默认语言。支持的魔法命令有:%python、%r、%scala、%sql。该解决方案通过从 R notebook 调用 python(或使用 REST API)来实现:

我们首先设置在前面的 R 命令中创建的实验，然后寻找该实验的最后一次运行。请记住，实验和运行都在 R 中注册，我们唯一无法跟踪的是模型。一旦我们找到了运行，我们就可以获得创建的工件的 URI，我们将使用这个 URI 来获得 python 中的模型并注册它。我们只是创建一个 mlflow 客户端，用 create_model_version 指令进行注册。这个操作可能需要 300 秒来完成创建，所以请记住这一点(在下一个命令中使用 time.sleep(300)可能会很有趣)。现在，在这个“技巧”之后，模型已经被正确地注册到模型库中，并且可以使用了。

Databricks 和 MLFlow 都是正在开发的强大而有前途的技术。尤其是 MLFlow 还是太绿了，一定要有耐心。同时，我希望这个技巧可以帮助您进行云部署。

Adrian Perez 是一名数据科学家，拥有超级计算并行算法博士学位。你可以在他的 中简介 中查看更多关于他的西班牙语和英语内容。

如何将带有隐藏行和列的 Excel 文件加载到 Pandas

原文：https://towardsdatascience.com/how-to-load-excel-files-with-hidden-rows-and-columns-into-pandas-19d445fa5c47?source=collection_archive---------4-----------------------

使用 openpyxl 包在将 Excel 文件作为 Pandas DataFrames 读取时忽略隐藏的行和列

照片由米卡·鲍梅斯特在 Unsplash 上拍摄

我最近学到了一些新东西——在将 Excel 文件作为 Pandas DataFrames 读取时，可以排除隐藏的行和/或列，这都要归功于openpyxl包，我想与你分享一下。

隐藏 Excel 文件的行或列并不罕见。不太相关的列可以被隐藏以保持电子表格的整洁；或者隐藏行以故意忽略重复数据。

无论原因是什么，当加载一个文件作为 Pandas DataFrame 时，隐藏它们可能是有价值的，因为它可能会影响后续的数据争论和探索。

不幸的是，将 Excel 文件作为 Pandas 数据帧读取的传统方式——使用pandas.read_excel()方法——并不方便。

在这篇文章中，我们将探索如何使用openpyxl包来识别 Excel 文件中隐藏的行和列，从而在将其作为 Pandas DataFrame 加载时排除它们。

数据集

我们将使用在 Kaggle 上公开的 titanic 训练数据集的一小部分。为了简单起见，我将数据行数限制为 20。我还故意隐藏了 F(“年龄”)、I(“机票”)和 K(“客舱”)列，以及第 6、11、16 和 21 行。

在 Excel 中预览数据集(图片由作者提供)

为什么 `pandas.read_excel()`不工作？

通常，我们使用 Pandas 的read_excel()方法在 Excel 中加载数据集作为 Pandas DataFrame。让我们看看当我们对包含隐藏行和列的 titanic 数据集这样做时会发生什么。

>>> import pandas as pd>>> df = pd.read_excel("data/titanic.xlsx")>>> df

数据集为熊猫数据框，包含所有行和列(图片由作者提供)

默认情况下，read_excel()方法从指定的 Excel 文件的所有行和列中读入数据。换句话说，它不排除隐藏的行和列。

openpyxl 的安装

要加载 Pandas DataFrames 而不隐藏行和列，我们可以使用 openpyxl 包，一个 Python 库来“读/写 Excel 2010 xlsx/xlsm/xltx/xltm 文件”。

由于 openpyxl 不是一个标准的 Python 内置库，您首先需要安装它。打开命令行窗口，键入以下命令:

>>> pip install openpyxl

使用 openpyxl 加载 Excel 文件和工作表

要使用openpyxl包打开现有的 Excel 文件，我们使用openpyxl.load_workbook()方法，指定存储 Excel 文件的路径名。

>>> import openpyxl# Open an Excel workbook
>>> workbook = openpyxl.load_workbook("data/titanic.xlsx")

这创建了一个Workbook对象，根据文档，它是“所有文档信息的顶级容器”。该对象包含许多与输入文件相关的属性，包括返回工作簿中所有工作表名称列表的.sheetnames属性。

# Create a list of names of all worksheets in `workbook`
>>> sheet_names = workbook.sheetnames# Create a `Worksheet` object 
>>> worksheet = workbook[sheet_names[0]]

在我们的titanic.xlsx文件中，我们只有一个名为“train”的工作表，所以我们通过获取sheet_names列表的第一个元素来获得工作表名称。接下来，我们从Workbook对象创建一个Worksheet对象。

查找隐藏行的索引

类似地，Worksheet对象包含属于指定工作表的属性。为了找到所有隐藏行的索引，我们使用了Worksheet对象的.row_dimensions属性，如下所示:

# List of indices corresponding to all hidden rows
>>> hidden_rows_idx = [
        row - 2 
        for row, dimension in worksheet.row_dimensions.items() 
        if dimension.hidden
    ]>>> print(hidden_rows_idx)[4, 9, 14, 19]

注意，我们需要使用row — 2而不仅仅是row,因为我们想要找到对应于熊猫数据帧的索引，而不是 Excel 文件。

查找隐藏列的名称

为了找到所有隐藏列的名称，我们首先使用Worksheet对象的.column_dimension属性:

# List of indices corresponding to all hidden columns
>>> hidden_cols = [
        col 
        for col, dimension in worksheet.column_dimensions.items() 
        if dimension.hidden
    ]>>> print(hidden_cols)['F', 'I', 'K']

这将生成一个包含大写字母的列表，这些字母对应于 Excel 工作表的隐藏列。因此，我们需要以某种方式将hidden_cols列表转换成隐藏列的名称列表。为此，我们使用 Python 的内置库string及其.ascii_uppercase属性:

# List of indices corresponding to all hidden columns
>>> hidden_cols_idx = [
        string.ascii_uppercase.index(col_name) 
        for col_name in hidden_cols
    ]# Find names of columns corresponding to hidden column indices
>>> hidden_cols_name = df.columns[hidden_cols_idx].tolist()>>> print(hidden_cols_name)['Age', 'Ticket', 'Cabin']

免责声明:请注意，使用 **string.ascii_uppercase** 假设最多有 26 列。如果超过 26 列，就需要修改代码。

最后，一旦我们有了隐藏行的索引和隐藏列的名称，剩下的就简单了。为了排除那些隐藏的行和列，我们简单地使用 Pandas 的.drop()方法。

# Drop the hidden columns
>>> df.drop(hidden_cols_name, axis=1, inplace=True)# Drop the hidden rows
>>> df.drop(hidden_rows_idx, axis=0, inplace=True)# Reset the index 
>>> df.reset_index(drop=True, inplace=True)>>> df

没有隐藏行和列的数据集作为熊猫数据框架(图片由作者提供)

把所有的放在一起

下面是一个代码片段，它通过一些简单的重构将上述代码组合在一起:

包装它

现在，你有了它——一个 Python 代码，它允许你读取一个包含隐藏行和/或列的 Excel 文件，就像熊猫数据帧一样。

这个特殊的用例仅仅触及了openpyxl包所提供的皮毛。关于openpyxl包的更多信息，查看它的文档这里。

这篇文章中显示的代码也可以在这个 GitHub repo 的笔记本中找到。

你好！我是泽雅。感谢你阅读这篇文章。如果你觉得它有用，请在评论中告诉我。我也欢迎讨论、问题和建设性的反馈。请随时通过媒体关注我，或者通过 LinkedIn 或 Twitter 联系我。祝您愉快！

如何在亚马逊红移中加载地理空间数据

原文：https://towardsdatascience.com/how-to-load-geospatial-data-in-amazon-redshift-e2f5528c8ae4?source=collection_archive---------25-----------------------

使用开源地理空间库和 Amazon 红移数据 API 的 pythonic 方法

Pawel Czerwinski 在 Unsplash 上的照片

亚马逊红移于 2019 年 11 月宣布支持空间数据。这种支持包括新的几何数据类型和 40 多种空间函数。它在 2020 年 9 月得到了增强，增加了新的空间函数，并在使用 JDBC/ODBC 驱动程序时支持几何类型。

如果您有地理空间数据，那么在 Amazon Redshift 中加载数据有两个选项，都涉及到 COPY 命令:

CSV 文件，带有 EWKB 格式的几何图形
形状文件

如果您已经有了这种格式的数据，使用 shapefiles 是一个很好的选择，但它是专有的，需要多个文件，属性名称限制为 10 个字符，大小限制为 2 GB。

如今，使用更新、更高级的格式(如 GeoJSON 或 GeoPackage)来查找地理空间数据是很常见的。如果您想要加载以这些格式存储的数据，您需要使用带有 EWKB 几何图形的 CSV 文件选项。

在本文中，我将向您展示如何使用利用开源地理空间包和 AWS SDK 的 Python 脚本，以更常见的格式将地理空间数据加载到 Redshift。

该脚本有三个主要步骤:

从输入文件创建带有 EKWB 几何图形的 CSV 文件
将创建的文件上传到 S3 存储桶
从 S3 文件导入红移表中的数据

创建包含 EWKB 几何图形的 CSV 文件

第一步是读取输入地理空间文件，然后用 EWKB 格式的几何创建一个新的 CSV 文件。

我们将使用最初由 Sean Gillies 开发的两个众所周知的地理空间包:

菲奥娜。基于 GDAL/OGR ，提供了用于读写地理空间文件的 Python API。我们将使用 Fiona 来读取输入文件。
身材匀称的。基于几何 / JTS ，提供操作和分析平面几何对象的功能。我们将使用 Shapely 创建 EWKB 几何图形。

首先我们用 Fiona 打开输入文件，然后使用 Python csv 模块创建一个新文件。我们添加带有一个 geom 列的标题和来自输入文件的属性名( f["properties"])。keys() )作为第一行。然后，我们使用 ShapelyWKB . dumps函数在输入文件中写入特征行，该函数允许我们使用十六进制参数以 EWKB 格式写入几何图形。

如果输入文件使用 EPSG 代码定义空间参考，本文末尾链接的完整源代码支持将 EPSG 代码(空间参考 ID-SRID)添加到输出 EWKB 几何。

把文件上传到 S3

Redshift 中的 COPY 命令要求我们将想要加载的文件存储在 S3 桶中。我们将使用 Python 的AWS SDK(boto 3)来上传我们在上一步中创建的 CSV 文件。

将文件上传到 S3 的代码非常简单，正如您在下面看到的，但是我们需要有适当的权限来写入 S3 存储桶。

您需要登录到 AWS IAM 控制台，创建您的凭证，并确保您在权限部分附加了“ AmazonS3FullAccess ”策略。

Boto3 将在环境变量(AWS_ACCESS_KEY_ID 和 AWS_SECRET_ACCESS_KEY)或您的主文件夹( ~/中的凭证文件中查找访问密钥。用于 macOS/Linux 的 aws/credentials 或 C:\Users\USER_NAME\。Windows 版的 aws\credentials )。您可以自己创建这个文件，也可以安装 AWS CLI 并运行 aws configure 命令。

配置好凭据后，您应该能够运行以下代码将包含 EWKB 几何图形的 CSV 文件上传到 S3。重要的是，你上传文件到 S3 桶在同一个 AWS 地区，你有你的红移集群。

将数据导入红移

现在我们在 S3 有了 CSV 文件，我们将使用 COPY 命令将数据加载到 Redshift 中。在 Redshift 中，我们有不同的选项来执行 SQL 命令；其中一些如下:

我们可以使用 PostgreSQL 的 psycopg 驱动程序。虽然 Redshift 不完全兼容 PostgreSQL，但是我们可以用这个驱动连接 Redshift，执行 SQL 语句。这个选项只允许我们使用传统的数据库认证。
另一种选择是使用红移 ODBC 驱动程序和 pyodbc 模块。这是一个类似于 psycopg 的解决方案，具有红移特有的特性，也只提供传统的数据库认证。
更好的选择是使用 Python 红移连接器。它是特定于红移的，由 AWS 开发，并支持红移特定的功能，如 IAM 身份验证。
我们最终选择的选项是红移数据 API 。它使用 boto3 包进行异步 HTTP 调用。代码稍微复杂一点(您需要执行语句，等待它结束，然后检索结果)，但是它提供了 IAM 和 Secrets Manager 认证，并且避免了管理连接的需要。

要使用红移数据 API，我们需要我们的凭证来附加AmazonRedshiftDataFullAccess策略。如上所述，使用 AWS IAM 控制台附加策略。

在加载数据之前，我们需要创建一个表，数据将被导入到这个表中。我们需要准备带有输入文件中的列名和数据类型的 SQL 语句。Fiona 提供了一个模式属性，我们可以使用它将从 Fiona 读取的 Python 数据类型映射到红移数据类型。请看一下get _ create _ table _ statement和 get_field_mappings 函数来理解这个过程。

为了在 Redshift 上执行 SQL 语句，我们需要提供数据库凭证来访问数据库。该脚本使用存储在 AWS Secrets Manager 中的凭证。这是连接到 Redshift 的推荐选项之一，它为循环、管理和检索数据库凭证提供了非常有用的功能。我们还需要提供这个秘密的 ARN。

一旦我们创建了表，我们就可以使用 COPY 命令导入数据。除了数据库凭证之外，我们还需要为我们的红移集群附加一个角色，以允许对 S3 进行读访问。一旦我们附加了这个角色，我们将在 COPY 命令中使用该角色的 Amazon 资源名称(ARN)。

您可以在下面看到 execute_statement 函数的语法。除了集群标识符和数据库之外，我们还用数据库凭证和 SQL 语句指定了秘密的 ARN。在 SQL 语句中，我们需要指明 S3 中 CSV 文件的路径以及附加到 Redshift 集群的 IAM 角色，该角色对 S3 具有读取权限。

请查看完整的源代码，看看我们如何检查 SQL 语句执行是否成功，以及我们需要使用的其他选项，如 COPY 命令中的 TIMEFORMAT 参数，以正确解释日期/时间字段。

现在呢？

所以你有我们的红移地理空间数据，现在你想工作的空间信息。您可以从红移空间函数开始，这些空间函数提供空间分析的基本功能，如要素相交或计算给定区域内的要素。

但是您可能希望使用这些数据集创建地图来理解信息并执行高级空间分析，如计算零售选址解决方案的双区域或计算包裹递送的最佳路径。

这就是像 CARTO 这样的云原生地理空间平台有用的地方(免责声明:我目前是 CARTO 的产品经理)。CARTO 允许您导入红移表，使用生成器创建令人惊叹的可视化效果，并通过使用来自数据观测站的公共和优质数据集丰富您的信息来执行高级分析。您还可以使用 React 的 CARTO 和 awesome deck.gl 可视化库的 CARTO 模块创建自己的自定义空间应用程序。

除了这些功能之外，CARTO 即将推出的针对 Redshift 的空间分析扩展将允许您执行高级空间分析，而无需将数据从数据库中删除，这一新的云原生功能将允许您直接从 Redshift 集群创建 2D 和 3D 地图。

源代码

您可以在这个 GitHub 资源库中找到 Python 脚本的源代码。脚本( geo2rs.py )可以独立运行，也可以作为模块使用。如果独立运行，它使用 argparse 库来解析命令参数。你可以在 README.md 文件中找到关于命令行参数的更多信息。您还可以使用 AWS Lambda 修改代码，使其无服务器运行。

如何在 Python Pandas 中加载巨大的 CSV 数据集

原文：https://towardsdatascience.com/how-to-load-huge-csv-datasets-in-python-pandas-d306e75ff276?source=collection_archive---------21-----------------------

理解大数据

图片来自 Pixabay 的 xresch

您可能有一个巨大的 CSV 数据集，它占据了您硬盘上 4 或 5 GB(甚至更多)的空间，您想用 Python pandas来处理它。也许你不需要数据集中包含的所有数据，只需要满足某些条件的一些记录。在这个简短的教程中，我将向你展示如何用 Python Pandas处理巨大的数据集。

我们可以采用四种策略:

垂直过滤器
水平过滤器
爆发
记忆。

你可以从我的 Github 库下载完整的 jupyter 笔记本。

垂直过滤器

在这种情况下，我们只加载整个数据集的一些列。我们可以使用read_csv()函数的参数usecols来只选择一些列。

**import** pandas **as** pd
df **=** pd.read_csv('hepatitis.csv', usecols**=**['age','sex'])

水平过滤器

在这种情况下，我们只加载数据集的一些行。我们可以选择起始行以及必须加载多少行。请记住，如果我们跳过第一行，我们必须将列名作为进一步的参数传递。

srow = 5
nrows = 50
columns = ['age','sex','steroid','antivirals','fatigue','malaise','anorexia','liver_big','liver_firm','spleen_palpable','spiders','ascites','varices','bilirubin','alk_phosphate','sgot','albumin','protime','histology','class']
df = pd.read_csv('hepatitis.csv', skiprows=srow, nrows=nrows, names=columns)
df.head()

爆发

可能会发生这样的情况，我们需要加载完整的数据集，但我们没有足够的内存来加载它。因此，我们可以批量加载它，然后应用一些过滤器，并将结果存储到另一个(更小的)数据集中。过滤器可以包括丢弃操作和从较大类型到较小类型的转换。

首先，我们定义一个名为read_burst()的函数，它读取第 I 个突发，执行一些过滤，然后将结果存储到另一个输出 csv 文件中。在我们的例子中，我们可以在malaise = False处删除行。我们传递起始行srow、突发大小burst和列名columns作为read_burst()函数的参数。当起始行等于 1 时，我们还必须将标题写入输出 csv 文件。这样我们定义了一个名为header的变量，如果srow = 1被设置为True。

def read_burst(srow,burst,columns):
    header = False
    if srow == 1:
        header = True
    df = pd.read_csv('hepatitis.csv', skiprows=srow, nrows=burst, names=columns)
    df = df.drop(df[df['malaise'] == False].index)
    df.to_csv('hepatitis_small.csv', mode='a',header=header)

现在我们可以遍历整个数据集。注意，我们必须预先知道 csv 文件的行数。这可以通过使用命令行勾选来完成。我们可以使用wc unix shell 命令。为了在 jupyther 笔记本中运行这个命令，我们必须使用!操作符。

**!** wc **-**l hepatitis.csv

它给出了以下输出:

156 hepatitis.csv

我们的文件包含 156 行，因此我们可以将要读取的最大行数设置为 156，因为第一行对应于标题。我们设置burst = 10。因此，我们有时读 100 本书。最后，我们再次运行read_burst()函数来加载最后剩下的行。

burst =10
srow = 1
nrows = 156
columns = ['age','sex','steroid','antivirals','fatigue','malaise','anorexia','liver_big','liver_firm','spleen_palpable','spiders','ascites','varices','bilirubin','alk_phosphate','sgot','albumin','protime','histology','class']
while srow < nrows:
    print('srow: ' + str(srow))
    read_burst(srow,burst,columns)
    srow = srow + burstread_burst(srow,nrows,columns)

现在我们可以加载较小的数据集。

df **=** pd.read_csv('hepatitis_small.csv')
df.head()

作者图片

我们可以删除Unnamed: 0列。

df.drop(columns**=**['Unnamed: 0'],axis**=**1,inplace**=True**)

存储格局

在 Python pandas中读取巨大数据集的另一个选择是增加与读取操作相关的内存。这可以通过low_memory参数来完成。

df **=** pd.read_csv('hepatitis.csv', low_memory**=False**)

摘要

在这篇简短的教程中，我展示了如何用 Python 处理巨大的数据集。我们了解到可以采用四种策略:

垂直过滤器
水平过滤器
爆发
内存配置。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

如何用 Python 加载 Google 文档的内容

原文：https://towardsdatascience.com/how-to-load-the-content-of-a-google-document-in-python-1d23fd8d8e52?source=collection_archive---------14-----------------------

数据预处理

关于在 Python 中使用 Google Doc APIs 的快速教程

图片由照片合成来自 Pixabay

您可能在 Google Drive 中以 Google Doc 的形式存储了一个文档，并希望将其内容动态加载到 Python pandas DataFrame 中进行进一步处理。

首先，你需要访问谷歌云平台并创建一个新项目，比如说 MyProject 。然后，您必须在主仪表板中选择创建的项目，并选择explore and enable API。你可以搜索谷歌文档 API，然后点击启用 API。启用后，您应该创建新的凭据。

可以选择 Google Doc API，查看用户数据，如下图所示。

作者图片

您可以按照向导完成凭据的创建。在第 4 部分 OAuth 客户端 ID 中，您可以选择桌面应用程序作为应用程序类型。

作者图片

现在您可以下载创建的秘密并将其重命名为credentials.json。将该文件放在将编写 Python 代码的同一个目录中。

作者图片

现在你可以下载并复制官方 Google Doc API 文档的代码，它允许你下载 Google Doc 文档的内容。确保你有权利阅读谷歌文档！！！

提取文本后，可以将其保存到本地文件中，然后转换成数据帧以供进一步分析。您将把文本的每一行作为一个新行存储在数据帧中。让我们假设您已经将 Google 文档的文本存储到一个名为text的变量中。

doc_content = body.get('content')
text = read_strucutural_elements(doc_content)

现在，您可以将它保存到本地文件中:

with open("my_doc.txt", "w") as text_file:
    text_file.write(text)

然后您可以重新加载该文件并将其转换为数据帧:

import pandas as pdwith open('my_doc.txt', 'r') as f:
    text = [line for line in f.readlines()]
df = pd.DataFrame(text,columns=['text'])

最终，您已经准备好处理您的数据了！好好享受吧！

摘要

在本教程中，我演示了如何通过官方的 Google Doc API 从 Google Doc 文档中加载文本，并将其转换为 Python pandas DataFrame。

这个过程很简单，但是需要一些重要的步骤，包括配置用来访问 Google Doc API 的凭证。

如果你想了解我的研究和其他活动的最新情况，你可以在 Twitter 、 Youtube 和 Github 上关注我。

https://medium.datadriveninvestor.com/how-to-restore-the-original-layout-of-a-text-document-after-a-manipulation-in-python-8f3de41e8e95

如何:机器学习管道(初学者)

原文：https://towardsdatascience.com/how-to-machine-leaning-pipeline-beginner-2a736595cbfd?source=collection_archive---------9-----------------------

照片由 JJ 英在 Unsplash

当我第一次开始我的机器学习之旅时，我只知道如何在 Jupyter 笔记本/google colab 中编码并运行它们。然而，当我试图在谷歌云和 AWS 中部署模型时，我发现越来越难以仅仅为了调整某些参数而检查代码行。如果有人只想用一个命令行运行全部代码，这就特别麻烦了。虽然网上有大量的资源，但我认为最好还是列出一个最佳实践的列表，并详细解释每个最佳实践的作用。

在本文中，我将介绍一个简单的回归和分类问题所需的各种组件和模块。整行代码将被分成多个模块，用一行代码编译。

所有文件都可以在这个 github 资源库中找到。

请注意，在这个练习中，我将使用 Windows 操作系统。

先决条件:

安装 Ubuntu LTS。记得安装长期支持版本。
Spyder(蟒蛇 3)。我发现 spyder 界面更好运行。py 文件，也就是说。这完全是我自己的喜好，请随意使用你自己的编辑器。
Python 3。确保 python3 安装在您的计算机或指定的文件夹/驱动器中。
熟悉书写功能。在这篇文章中，我们会用到很多。

文件和文件夹概述

机器学习管道的树形图

数据文件夹

这是您存储数据的地方，以便您的机器学习管道从中提取数据。在本例中，我拥有的数据库位于。db 格式。

Requirements.txt

该文本文件夹包含所有必要的软件包，你应该安装，以使您的回购工作。一种快速提取所有相应库的方法

pip3 freeze > requirements.txt  # Python3
pip freeze > requirements.txt  # Python2

Bash 文件(Run.sh)

run.sh 文件初始化 run.py 文件，后者依次运行所有其他模块，如数据提取、数据处理和 ML 模型。

#!/usr/bin/env bash
python ./src/run.py

第一行也称为 shebang。想了解更多可以参考链接。Run.sh 运行位于 src 文件夹中的 python 文件。

SRC(源)

如前所述，run.py 模块提取在其他 python 文件中创建的函数。所创建的函数将在本文的第 3 步和第 4 步中解释，但现在只需知道它激活了在其他。py 文件。

运行. py 文件

第一步。将 ubuntu LTS 挂载到虚拟环境中

在开始任何项目之前，你会想把 ubuntu 挂载到一个驱动器上，这样它就可以访问你的文件。当你第一次打开你的 ubuntu 时，输入 ls /mnt/看看你能挂载到哪个驱动器上，假设你希望挂载到 c 盘上，命令是 cd /mnt/C/ 。之后，您可以导航到存储数据的驱动器。更多信息，请点击这个 YouTube 视频。

现在你的 Ubuntu 已经挂载到了某个驱动器或文件夹中，你可以继续安装你的虚拟环境了。如果你没有使用 python3，你可以 pip 安装它。

mkdir test-venv ## this creates a drive called test-venv
virutalenv test-venv ## install new virtual environment inside the directory
source ./test-venv/bin/activate ## activate your new environment.

Ubuntu 平台

如果您看到类似这样的内容，请不要关闭它，我们将在第 7 步中讨论它。

第二步。规划你的机器学习管道。

想想你希望你的数据如何在你的项目中流动，并最终形成见解。一个简单的、典型的机器学习管道将如下图所示。

典型的基本机器学习管道

在这个例子中，我将坚持流水线化机器学习模型的标准过程。

第三步。数据提取/数据准备/

数据提取

大多数数据库都是关系数据库，存储在。db 文件格式，因此您可以使用 SQL 提取它。我包含了一个链接来展示我们如何提取不同类型的数据集。该函数输出提取的数据帧，该数据帧将被输入到数据准备 python 文件中。

数据准备

这个 python 文件包含了各种可以对测试分割进行特征工程、编码和训练的方法。

本文件定义的函数输出 4 个数据帧 x_train 、 x_test 、 y_train 、 y_test 。这 4 个数据帧将被输入到模型训练中。

在这个例子中，我对顺序特征使用了目标编码器，并通过 get_dummies 将分类特征转换为数字特征。然而，我建议你尝试不同的编码器，看看哪种帮助最大。

第四步。模特培训

这是建模发生的地方。我在这一部分添加了一个超级参数调整。但是，您可以选择将 hyper parameter tuning 分成不同的部分。

该函数输出 XGBoost、普通线性回归和 LGBM 的平均绝对误差。

第五步。模型评估和验证

建模的结果输出到主 run.py 脚本中。然后，run.py 脚本将结果连接起来，并输出到一个 CSV 文件中，以便于比较。此后，由您决定使用哪种模型。

虽然 LGBM 能产生最好的结果，但考虑利益相关者的其他重要要求也很重要。一些例子是模型的可解释性或模型所需的训练时间，这些因素会影响最终的决策。

第六步。Run.py

现在我们已经编写了 ML 管道的所有构件。现在是时候创建一个主 python 文件了，它结合了所有模块的所有输入和输出。

我之前解释过模型如何从各种函数中获取数据并输出它们。检查您是否将各种文件以正确的名称放在了正确的文件夹中，这一点很重要。如果需要帮助，请参考文件夹概述。

第七步。Run.sh

您所要做的就是创建一个 bash 脚本来运行。py 文件。回到 ubuntu IDE。

#!/usr/bin/env bash 
python ./src/run.py

chmod +x run.sh
./run.sh

现在，当您尝试运行 bash 脚本时，您可能会看到 numpy 或其他一些包没有安装。出现这种情况的原因是因为你在虚拟环境中。因此，你能做的就是 pip 安装你需要的各种包。

现在你所要做的，就是一个接一个地慢慢安装你需要的软件包。安装完所有必需的软件包后:

pip3 freeze > requirements.txt

从这里，您将获得保存在您的文件夹中的 requirements.txt。当您想要共享代码时，需求列表尤其重要。然后，用户可以看到需要哪些软件包，并可以快速安装它们。

结论

在这个练习中，我们学习了所需的各种 ML 模块，以及如何通过 ubuntu 使用 bash 运行它们。您还可以做其他一些改进，比如创建一个配置文件来存储您希望优化的所有变量。此后，您只需要更改配置文件来测试模型的不同变量。我希望你从这里学到一些东西，并一如既往地快乐编码！

如果有任何错误请联系我，我会做出必要的修改。

如何:机器学习驱动的需求预测

原文：https://towardsdatascience.com/how-to-machine-learning-driven-demand-forecasting-5d2fba237c19?source=collection_archive---------6-----------------------

在这篇非技术文章中，我将解释什么是机器学习，它是如何工作的，以及在预测需求时使用它可以得到什么。我们还将讨论启动 ML 计划时的陷阱和最佳实践。

信用

什么是机器学习

通常的统计模型将一组已知的关系应用于数据集。例如，指数平滑法将有其估算潜在需求水平和趋势的方法。

另一方面，机器学习是让算法自己理解数据集及其底层关系。

统计模型与机器学习模型。来源:我的需求预测培训。

机器是如何学习的？

机器学习算法将在数据集上运行，查看数据特征，并(试图)找出任何潜在的关系。

在处理机器学习模型时，您需要注意两个主要方面:

赋予模型的数据(特征)。
你的机器学习模型的超参数。

选择正确的数据输入模型非常重要。数据科学家不应该独自考虑使用什么数据；每个人都应该帮忙。创建预测算法时，您应该问自己以下问题:

如果我必须对下个月我们将销售多少产品进行需求预测，我会问自己什么问题？

当您问自己和您的团队这个问题时，您将会看到对您的模型最有意义的信息。

以下是几个典型的回答:

我的产品目前的价格是多少，在过去的几个月里有变化吗？
我的产品的月平均销售额是多少？
该产品最近缺货吗？
我们目前正在进行一些促销活动吗？

通过向您的 ML 模型提供相关数据，它将能够更准确地预测未来需求。

机器学习模型的典型输入。来源:我的需求预测培训

ML 驱动的需求预测能带来什么？

许多公司对使用机器学习模型来预测他们的销售期望过高或过低。如果你期望和承诺太多，高层管理人员会感到沮丧，需求计划者会变得谨慎，不愿意使用一个承诺过多的工具。另一方面，如果你对 ML 的期望太低，你将永远不会启动一个数据科学计划，它将被证明具有非常高的投资回报率。

通过使用机器学习，你能期望多高的预测准确度？

最近的预测竞赛(如 M5 和corporacio n Favorita)显示，与预测基准相比，误差减少了 20%至 60%。intermarché比赛略有减少，但这是由于使用了对数标度(见下面我的网上研讨会)。

自 2018 年以来，所有需求预测比赛都是机器学习获胜。你还在等什么？

欲了解更多信息，请参见卡斯帕·索尔海姆·博伊尔&延斯·彼得·梅尔德加德撰写的《从卡格尔的预测竞赛中学习》。

在此注册，了解未来的网络研讨会。

根据我自己的咨询经验，与移动平均相比，通常的机器学习项目会导致预测误差降低 5%至 20%。

通常，随着数据越来越多，这种精确度的提高会越来越高。例如，通过提供更多的需求驱动因素(历史库存水平、促销、营销、定价)或通过每日或每周级别的预测。

机器学习和需求计划者

请注意，通过提高预测基准的准确性，您也将提高整体预测流程的准确性，因为您的需求计划团队将能够在需要时编辑预测(他们几乎总是能够增加一些额外的准确性)。例如，假设您当前的预测引擎达到了 50%的准确率，而您的团队由于他们的工作通常可以将准确率提高到 55%。通过更新模型和使用机器学习，可以达到 55%的基线准确率。那么你的团队可能会进一步提高到 57%或 58%。

需求计划员总是可以通过使用模型不知道的信息(例如，通过与客户交流)来改进模型的预测。

机器学习模型不会让你的需求规划团队过时——但它们可能会减少他们的工作量。

使用机器学习的陷阱

启动机器学习计划需要关注几个关键方面。如果你错过了它们，你很可能无法交付成果。

数据质量

不要用销售数据！你应该预测需求，而不是销售。

糟糕的数据会打败优秀的预测者。每次都是。

预期

如上所述，承诺太多，你会失望(并面临最终用户的抵制)。但是，从另一方面来说，承诺太少，项目就不会有吸引力。

不良流程

需求预测的目的不是要准确。而是帮助你的供应链做出正确的决定。

简而言之，如果你预测的不是正确的事情，那么提高预测的准确性是没有意义的。因此，首先，您应该确保在正确的汇总级别预测您的需求。然后努力改进我们的模型。

例如，许多公司按市场逐月预测需求。而他们需要每周将库存从他们的工厂部署到世界上的几个仓库。关注仓库的每周需求预测比关注市场的每月需求预测更有意义。

首先，修复流程。然后，完善模型。

错误的指标

我仍然看到许多供应链使用 MAPE 作为预测指标。除非你确定你跟踪的是正确的指标，否则运行任何预测改进都是没有意义的。

许多供应链也在很大的价格范围内销售不同的产品。价值 1 美分的产品的预测误差不如价值数百欧元/美元的产品的类似预测误差重要。

我提倡供应链跟踪 wMAE(价格加权 MAE)和 wBias(价格加权偏差)。将这两个指标结合起来，将使您能够关注最重要的产品，并确保不会有一个有偏见的模型。

使用机器学习预测需求的最佳实践

项目管理

召集一个有动力、思想开放、好奇、敬业的团队(你需要不同的个人资料)。根据我的经验，机器学习之旅的开始是最困难的:你需要收集和清理数据，而不促进任何短期的成功。这就是为什么你需要一个积极的团队，花必要的时间收集相关数据。

您还必须评估您的模型应该使用什么需求驱动因素。

📊外部数据。请注意，外部数据可能既昂贵又不一致。例如，许多外部提供商将在几个月后共享市场信息，并且基于不符合您要求的粒度。避开就好。

🌦️的天气。天气会影响许多供应链:你会根据天气卖出或多或少的东西。不幸的是，你无法提前几天准确预测天气。我通常以冰淇淋为例:销售受阳光的影响很大，但你无法提前四周预测天气来计划你的生产。

数据科学

在做需求预测项目时，我喜欢遵循下面强调的步骤。

正如您所看到的，在开始收集数据和创建模型之前，有一个明确的目标(在粒度、范围和度量方面)是至关重要的。

您应该对照未用于训练模型的测试集来验证结果。例如，除了用于训练模型的数据集之外，保留几个月的需求。然后，您可以在这些看不见的时间段内测试它，以评估它的准确性。

项目时间表

1️⃣数据收集和清理

👩‍💻电力用户

在第一阶段，您将收集和清理历史需求和需求驱动因素。请注意，获取一些需求驱动因素的数据可能需要几个月的时间(并且需要时间密集型工作)。相反，您可能希望直接进入第 2 步，稍后使用更多数据尝试另一个模型。

✔️Skip:如果你已经在当前的预测软件中使用了相关数据，请执行这一步

2️⃣模型创建

👩‍🔬数据科学家

数据科学家将使用不同的数据特征尝试不同的模型，直到他们获得想要的结果。

生产中的 3️⃣模型

👩‍💻数据工程师

一旦你有了一个工作模型，你就可以把它从“手动/本地计算机”设置转移到“自动/云”设置。

请注意，将工作模型从本地机器转移到云中(并使之自动化)所花费的时间可能不值得。我见过一些项目花费三个月的时间将一个工作模型转移到云上，希望每周节省 10-30 分钟的手工工作。

✔️:如果您同意每周/每月手动运行一次模型，请跳过这一步

4️⃣ 用户接受度

👨‍💼项目经理

模型准确性应根据未来未知数据进行测试。这是评估预测质量的唯一方法。请记住，将您的模型所实现的准确性与简单基准(见下文)、您当前的预测引擎以及您的一致预测所实现的准确性进行比较。

https://nicolas-vandeput.medium.com/assessing-products-forecastability-forecasting-benchmarks-vs-cov-2bdac1e7fd5f

不要犹豫，做一些平行运行，以确认新的模型工作正常。

本文基于我之前的一次网络研讨会。在此注册以获得未来的通知。

问与答(Question and Answer)

使用机器学习来预测需求，我们还能期望多高的准确度？

通常，机器学习模型比最先进的预测软件高出 5%至 15%。随着更多数据的可用，可以实现更高的准确性(需求驱动因素)。

如何启动概念验证(POC)

收集初始数据(您可以使用当前的统计工具数据)
优化模型
试运行几次
成功？实施您的解决方案！

如何在 Tableau 中制作彗星图

原文：https://towardsdatascience.com/how-to-make-a-comet-chart-in-tableau-b5c23e3dc58b?source=collection_archive---------22-----------------------

我喜欢用数据讲故事。因此，我一直在寻找创造性的方法来表示数据。

Justin W 在 Unsplash 上的照片

彗星图，顾名思义，基本上类似于条形图，但有一个方向。所以，当你想展示比较时，它们很有用。例如，彗星图可以用来漂亮地描绘 2019 年和 2020 年的销售情况。尽管这个概念有意义，但由于应用方面的原因，它并没有被广泛使用。

我最近决定使用它，我喜欢我所看到的。因此，我今天写信来尽可能简单地说明如何建立一个。

我们开始吧。

1.获取数据集

当您想要比较两个维度之间的一些度量时，彗星图最有效。所以，我决定使用新冠肺炎疫苗意愿数据集。你可以从这里得到。

2.连接到数据集

下载的数据集是 xls 格式文件。当我试图将它作为数据源连接时，它抛出了错误。因此，您可能希望在 excel 中打开并另存为。然后尝试重新连接。

3.数据操作

数据集是宽格式的，如下所示。我们需要把它转换成长格式。

因此，一旦您将文件连接为数据源，单击除 DateTime 之外的所有列的顶部，右键单击并选择 Pivot。

作者图片

您的数据现在应该是这样的。将透视字段名重命名为 Country，将值重命名为 Willingness。

作者图片

接下来，我们需要创建几个字段-

2020 年意愿

作者图片

2021 年意愿

作者图片

两者的区别

作者图片

符号函数给出计算的符号。正数用 1 表示，负数用-1 表示，零用 0 表示。这将用于突出衡量标准的积极和消极变化。

4.拖放！

现在，只需将 Country 拖到 Rows shelf，将 measure 值拖到 column shelf，就像处理水平条形图一样。

将平均意愿 2021 和平均意愿 2020 添加到测量值卡。
将度量名称拖至路径和大小。
将符号字段(在我的例子中是 diff)拖到 colour。

瞧啊。彗星图准备好了。您的输出将如下所示。

作者图片

你可以进一步定制它，比如添加标签，改变表单格式，在工具提示中添加更多信息等等。

这是我的最终版本。我在工具提示中添加了每个国家的详细趋势以及变化百分比。

作者图片

你可以在这里找到完整的 viz。

我希望这些信息对你有用！请在评论中留下任何问题。

快乐学习！

TowardsDataScience-博客中文翻译-2021-四十九-更多相关文章

今日报告-66

设置Windows10暂停更新3000天

AQS公平锁的流程

AMD锐龙7 7800X3D网游专项测试：竟比i9-13900KS强了15%

常用总线技术基本参数对比

探索图像数据中的隐藏信息：语义实体识别和关系抽取的奇妙之旅

设置Chrome浏览器自动升级

JavaScript – 小技巧 Tips

postgresql在插入数据后怎么获取自增id

EF Core 的基本使用

error: failed to push some refs to 'https://github.com/*******/********.github.io.git'

欧拉降幂

编程语言能力对比

基于机器视觉的小车轨迹控制软件界面展示

随机推荐

AJAX & AXIOS-2024/11/1

验证码处理在自动化测试中的应用

一些学科笑话

NOIP2024模拟赛20 & 11.1 小记

20241101 数据结构与算法期中机试收获

Java，启动！

什么是IT技术

即将到来！

2024/11/1日日志关于JavaScript简介&引入方式以及基础语法的学习

舍得-时间-工作是人的一生最重要的事情-自己要有私房钱-人的一生最重要的事情是书写自己的人生

2.TiUP 部署 DM 集群

原型模式的C++实现

python bytecode解析

09-XSS键盘监听、cookie窃取&文件上传绕过

ubuntu 24.04 部署 mysql 8.4.3 LTS

国标GB28181公网平台LiteGBS国标GB28181视频平台建筑工地无线视频联网监控系统方案