TowardsDataScience-博客中文翻译-2020-一-

TowardsDataScience 博客中文翻译 2020（一）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

⚡️加载相同 CSV 文件的速度提高了 10 倍，memory⚡️减少了 10 倍

原文：https://towardsdatascience.com/️-load-the-same-csv-file-10x-times-faster-and-with-10x-less-memory-️-e93b485086c7?source=collection_archive---------2-----------------------

熊猫，达克，多重加工，等等…

照片由卡拉·富勒在 Unsplash ( 最快的哺乳动物)上拍摄

即使我们有 1TB 的磁盘存储、8GB/16GB 的 RAM，许多其他数据加载 API 仍然难以加载 2GB 的文件。

这是因为当进程请求内存时，内存以两种方式分配:

1. 连续内存分配(分配连续的块)
2. 非连续内存分配(不同位置的独立块)

Pandas 使用连续内存将数据加载到 RAM 中，因为 RAM 上的读写操作必须比磁盘(或 SSD)快。

• 固态硬盘读数:~16，000 纳秒
• 从 RAM 中读取:~100 纳秒

在进入多处理& GPUs 等之前…让我们看看如何有效地使用 pd.read_csv() 。

Pandas 可以很好地加载数据和预处理，但是要训练你的模型，从 TensorFlow 或 PyTorch 或任何你运行模型的地方开始使用 DataLoader。

塞巴斯蒂安·耶佩斯在 Unsplash 上拍摄的照片

注意:如果您在手机上阅读，您可能无法滚动浏览代码。(打开要点可读性更好。)

1。使用列:

而不是加载数据并删除处理数据时无用的不必要的列。只加载有用的列。

🔥内存使用与您使用的列数成比例。🔥

2 。使用正确的 **dtypes** 进行数值数据:

在熊猫数据框架中，每一列都有自己的dtype，例如，整数有int64、int32、int16等

• int8可以存储-128 到 127 的整数。
• int16可以存储从-32768 到 32767 的整数。
• int64可以存储-9223372036854775808 到 9223372036854775807 的整数。

默认情况下，熊猫将int64分配给整数datatype，因此通过定义正确的dtypes，我们可以显著减少内存使用。

🔥内存使用减少了 75%。🔥

🔥Pro 提示:在加载数据时使用converters来替换缺失值或 nan，特别是对于使用dtype.预定义了数据类型的列

由塞缪尔·吉文在 Unsplash 上拍摄的照片

3。使用正确的 ***dtypes*** 进行分类列:

在我的数据集中，我有一个列Thumb，默认情况下它被解析为一个字符串，但是它只包含固定数量的值，这些值对于任何数据集都保持不变。

还有性别等栏目..可存储为分类值，将内存从约 1000 KB 减少至约 100 KB。(检查 sat)

🔥内存使用减少了 97%。🔥

🔥专业提示:如果你的数据帧包含大量空值、缺失值或 nan，你可以通过将它们转换成稀疏序列来减少它们的内存占用。

4。nrows，跳过行和

甚至在将所有数据加载到 RAM 之前，使用小数据集测试您的函数和工作流总是一个好的做法，pandas 使精确选择行数变得更加容易(您甚至可以跳过不需要的行。)

在大多数情况下，出于测试目的，当一个样本可以做得很好时，您不需要加载所有数据。

nrows从文件中读取的行数。

>>> Import pandas as pd
>>> df = pd.read_csv("train.csv", nrows=1000)
>>>len(df)
1000

skiprows文件开头要跳过的行数(0-索引)或要跳过的行数(int)。

# Can be either list or first N rows.
df = pd.read_csv('train.csv', skiprows=[0,2,5]) 
# It might remove headings

🔥提示:nrows的一个有效用法是当您有超过 100 个列时，检查并为每一列定义正确的数据类型。所有这些开销都可以使用如下所示的nrows来减少。

sample = pd.read_csv("train.csv", nrows=100) # Load Sample datadtypes = sample.dtypes # Get the dtypes
cols = sample.columns # Get the columnsdtype_dictionary = {} 
for c in cols:
    """
    Write your own dtypes using 
    # rule 2
    # rule 3 
    """
    if str(dtypes[c]) == 'int64':
        dtype_dictionary[c] = 'float32' # Handle NANs in int columns
    else:
        dtype_dictionary[c] = str(dtypes[c])# Load Data with increased speed and reduced memory.
df = pd.read_csv("train.csv", dtype=dtype_dictionary, 
                 keep_default_na=False, 
                 error_bad_lines=False,
                 na_values=['na',''])

注意:由于 nan 在 pandas 中被认为是 float，所以如果您的列包含 nan，不要忘记将 integer data _ types 转换为 float。

5。分块加载数据:

熊猫 read_csv()中的内存问题长期存在。因此，加载大型数据集的最佳变通方法之一是分块加载。

注意:分块加载数据实际上比直接读取整个数据要慢，因为您需要再次concat分块，但是您可以轻松加载超过 10 GB 的文件。

照片由伊琳娜·布洛克在 Unsplash 上拍摄

6.使用 pandas 的多重处理:

因为 pandas 没有 njobs 变量来利用多处理能力。我们可以利用multiprocessing库在多线程上异步处理块大小操作，这可以将运行时间减少一半。

古塔曼巴拉拉曼

注意:您只需要在 main 中定义pool，因为只有 main 可以在多个处理器之间异步分配池。

7.Dask 代替熊猫:

虽然 Dask 没有像 pandas 那样提供广泛的数据预处理功能，但它支持并行计算，加载数据比 pandas 更快

import dask.dataframe as dddata = dd.read_csv("train.csv",dtype={'MachineHoursCurrentMeter': 'float64'},assume_missing=True)
data.compute()

🔥专业提示:如果你想知道 jupyter 细胞运行所需的时间，只需在细胞开始处添加%%time魔法函数

试题库:Paratext，Datatable。

他们的是另一种方式，你可以在云中租一台虚拟机，64 个内核和 432GB 内存，每小时 3 美元左右，甚至更好的价格。

警告:你需要花下一周的时间来配置它。

谢谢你坚持到最后，我希望你学到了新的东西。快乐装货…✌️.（👏如果你喜欢的话。)

在下面评论你用来更快加载数据的技巧，我会把它们添加到列表中。

(把他们添加到你的博客列表中):

🔥 Itamar Turner-Trauring —速度巨蟒大师(必须✅).

🔥 Gouthaman Balaraman —用 python 进行量化金融(必须✅).

在 Linkedin 上与我联系。

情感分析:基于方面的观点挖掘

原文：https://towardsdatascience.com/️-sentiment-analysis-aspect-based-opinion-mining-72a75e8c8a6d?source=collection_archive---------7-----------------------

入门

情感分析和主题建模技术的研究。

介绍

当发展一个成功的企业时，最关键的因素之一是你与客户的沟通和关系。然而，随着用户群的增长，一个主要的挑战是产生大量的数据，通常是以自然语言的形式。这些数据可以来自客户反馈，甚至可以来自社交媒体平台，客户可以在这些平台上表达他们对使用您的服务或产品的体验的想法和意见。

真正的挑战是自动解析和组织这些数据，使之成为更易理解和可操作的洞察。应用于这种数据的最流行的自然语言处理技术之一是情感分析。情感分析旨在自动提取和分类文本中表达的情感(观点的主观部分)和/或情绪(感觉的投射或显示)。

意见可以被定义为四个因素(实体、持有人、主张和情感)的组合，其中意见持有人可能相信关于实体的主张，并且在许多情况下，将情感与该信念相关联。与提取一段文本中表达的一般情感相反，基于方面的情感分析旨在提取文本中描述的实体(在这种情况下，是产品或服务的属性或组件)以及对这些实体表达的情感。

通过探索客户对您的服务或产品的特定部分的反应所获得的优势可以帮助支持业务用例，包括产品开发和质量控制、通信、客户支持和决策过程。在这种情况下，这篇文章研究了将传统的主题建模技术与情感分析相结合来提取文本方面，以及对它们表达的情感。

数据预处理

这篇文章中使用的数据集是由朱利安·麦考利提供的。它包含亚马逊的产品评论和元数据，包括 1996 年 5 月至 2014 年 7 月期间的 1.428 亿条评论。该数据集包括评论(评级、文本、有用性投票)、产品元数据(描述、类别信息、价格、品牌和图像特征)和链接(也查看过/也购买过的图表)。在这里，我们将使用手机和配件的评论。该数据集中的评论总数是 194，439。

我们将遵循一些自然语言处理任务中使用的标准预处理技术。这些技术包括:

• 将文本转换为小写。
• 删除标点符号和额外的空格。
• 象征化。
• 删除停用词。
• 引理满足。

在我们研究应用主题建模技术之前，最后一个预处理步骤是对评论进行矢量化，即我们需要将数据表示为数字形式，以便模型可以处理它们。您可以使用几种表示方法，最流行的方法是单词的 TF-IDF 得分或它们的频率计数(单词袋方法)。在这里，我们将坚持单词袋表示法。我们将使用 Sklearn 的特征提取模块中的CounterVectorizer函数。该函数将文本集合转换为字数矩阵。

主题建模

主题建模是一种无监督的机器学习方法，用于将文本分配到最能表征此类文档的组中。这个概念也可以用来提取文本方面。

Sklearn 包括一个潜在的狄利克雷分配(LDA)算法版本。对于这个概念，我们想提炼五个方面。一旦设置了参数，我们就可以使 LDA 适合文本的矢量化版本。

为了使输出更容易阅读，我们可以将为每个主题生成的相关性分数作为一列附加到每个评论中，并通过取具有最高相关性分数的主题来计算主导主题。

现在我们可以看到评论属于哪个主题(根据其编号)。但是 LDA 从这样的评论中提取了什么关键词呢？我们可以通过调用矢量器的get_feature_names()来查看它们，并使用 LDA 的components_函数来查看它们与该方面的相关性分数:

我们通过在五个方面中取其最高相关性分数来确定一个关键词属于哪个方面。然后，对于每个方面，我们可以按降序排列我们的数据框架，并选择得分最高的关键字。

这五个方面是:

• 蓄电池充电器
• 电池组
• 汽车充电器
• 手机
• 屏幕保护器

情感分析

已经开发了各种技术和方法来解决自动识别文本中表达的情感。在这篇文章中，我将使用 Python 情感分析库 VADER 来分类评论是积极的、消极的还是中立的。

一种非常简单的情感分析方法是使用一个单词列表，这些单词已经根据它们的语义取向进行了标记。例如，我们可以假设单词“好”有一个正价，而单词“坏”有一个负价。VADER 使用这种技术，并提供了一个百分比分数，它代表了属于每个情感类别的歌词的比例。它还提供了一个复合得分，计算方法是将每个单词的效价得分相加，然后将得分归一化到-1(最大负值)和+1(最大正值)之间。

VADER 的好处在于我们不需要以任何方式对文本进行预处理。我们可以将原始产品评论输入到 VADER 的情感函数中，并检索每个产品的综合得分。

首先，我们将从 VADER 的 Python 库中导入SentimentIntensityAnalyzer函数。我将初始化 VADER 的情绪分析器，然后迭代数据框架中的评论。然后，我将计算复合情绪得分是高于还是低于阈值，这样我们就可以给它们贴上积极、消极或中性的标签。

从结果中获得的见解

一旦我们获得了每个评论的复合分数，我们就可以对这五个方面中的每一个绘制并计算正面、负面和中性评论的数量。

每个方面的正面、负面和中性评论的总数。

该图表显示，每个方面的大多数评价都是积极的。特别是，超过 83，000 条评论的屏幕保护者获得了 49，572 条正面评论。对于一个企业来说，超过 50%的评论表达了积极的情绪，这是一个很好的迹象，表明你的客户对产品感到满意。

我们还能收集到哪些潜在的见解？让我们更深入地了解一下客户在说什么。对于这个概念，我们将使用对屏幕保护的评论。

用于支持情感分析的主要特征之一包括明确传达主观偏见的个体情感词(例如，好、坏)。情感词汇可以从专业词典中找到，在那里它们被映射到自己的情感上。

这些词通常是形容词(如好的，坏的)，副词(如愉快地，古怪地)，名词(如祝福，垃圾)，动词(如爱，恨)。情感也可以通过使用比较词来表达(例如，更好，更差)。为了识别文本中的形容词、副词、名词和动词，我们可以应用词性标注。词性标注是根据单词的定义和上下文，将文本中的单词标记为对应于特定词类(名词、动词、形容词、副词、代词、介词、连词、感叹词、数词、冠词或限定词)的过程。

这里，我们使用 NLTK POS tagger 来标识 POS 标签。由于我们已经有了一个相当大的数据集，我们希望尽可能地自动缩小情感词的范围。在这种情况下，我们能够识别英语和正确拼写的单词，并将它们映射到 SentiWordNet ，这是一个用于观点挖掘的词汇资源。SentiWordNet 给单词分配三个情感分数:积极、消极和客观。

客观性可以定义为在考虑和陈述事实时不受个人感觉或观点的影响。因此，主观性是客观性的对比。在评分方面，我们要识别客观性评分低的词。但并不是所有的主观词都是感情词。

为了从主观词汇中捕获情感词汇，我们使用了另一种词汇资源 WordNet-Affect ，它以分层结构表示与情感词汇相关的情感概念。一旦我们检查了主观词汇是否在 WordNet-Affect 中，我们就可以很有把握地认为这些是情感词汇。基于他们的 SentiWordNet 正面和负面得分，我们还可以将他们分成单独的集合，并计算他们在整个数据集中出现的次数。

我们将在单词云中展示结果，单词云是一种简单的数据可视化方式，根据单词在数据中出现的频率，单词以不同的大小显示。单词的大小显示了它在评论中出现的频率。

正情词云

负面情绪词云

基于这两个词云，很明显，评论中最常见的正面和负面情绪词分别是快乐和担忧T6。对于一个企业来说，同样，把快乐作为最流行的积极情绪词是令人放心的！

“我爱这个案子！太漂亮了。我喜欢这款保护套的触感，因为它有橡胶。很开心！”

但是负面情绪的话可能会令人担心。在浏览了包含担心的评论后，我们可以注意到，它们出现的大多数是在否定词“没担心”或“别担心”之后。否定在情感分析中起着重要的作用，因为它可以逆转情感词的极性。否定词如“not”或“never”通常被认为是停用词，它们在预处理过程中被移除，并影响情感词的极性。这是未来需要考虑的一个重要问题。

下面的评论举例说明了一个例子，其中出现了评论中第二常见的负面情绪词仇恨:

“我讨厌屏幕保护器。讨厌它们，因而很少使用它们。它们要么很难安装，要么让显示器看起来像垃圾，要么两者兼而有之。”

估计这个人不喜欢屏幕保护…

结论

那么，我从这个分析中学到了什么？

传统的主题建模技术可以用来成功地从文本中提取方面。像许多数据科学问题一样，问题的核心任务之一是数据的预处理。这对于情感分析结果具有特别的影响，其中移除特定的停用词可能会影响否定的识别，从而影响所表达的真实情感。

对于完整的笔记本，请查看下面我的 GitHub repo:

https://github.com/LowriWilliams/Aspect_Sentiment_Analysis

如果你对更多的主题建模帖子感兴趣，我最近写了关于确定给定主题的更有意义的标题。你可以在这里阅读:

🗣️ 主题建模:超越令牌输出

情感分析:习语及其重要性

原文：https://towardsdatascience.com/️-sentiment-analysis-idioms-and-their-importance-2f547f2e646c?source=collection_archive---------19-----------------------

习语在情感分析中的作用研究

注: 本文讨论的方法背后的方法论源于我的博士论文，可以在这篇 学术论文 中找到。

介绍

情感分析(或观点挖掘)旨在自动提取和分类文本中表达的情感(观点的主观部分)和/或情绪(感觉的投射或显示)。

我们用几种语言特征来表示文本中的情感。特征的形式可以是单个单词(uniGRams)、短语(bigrams)和更长的短语(n-grams)、表情符号(例如:)通常用于表示积极的情绪)、俚语(例如 chuffed、do one's nut)、缩写(例如 great — GR8)、拟声词元素(例如 gr、hm)，以及大写字母、标点符号(例如！！, ?！)，以及字母的重复(如 sweeeeet)来强调情感。这些特征通常从文本中提取出来，并呈现给机器学习模型，这些模型经过训练，可以根据文本中包含的特征对文本中表达的情感进行分类。

尽管这些特征在情感分析中得到了广泛的应用，但是忽略习语作为特征的影响却很少被关注。在这种情况下，这篇文章通过比较两种最先进的工具在有习语和没有习语时的性能，研究了将习语作为特征包含在情感分析中的重要性。实现这一点有两个要求:1)需要识别与习语相关联的情感，以及 2)需要自动识别文本中的习语。

什么是成语？

在进入技术层面之前，我们先来定义一下什么是成语。

成语通常被定义为多词表达**s(由至少两个词组成的表达或短语)。但是使它们与其他短语不同的是，它们的整体意思不能从构成习语的每个单词的字面意思中猜测出来。例如，离开水的鱼是用来指在某个特定情境下感到不舒服的人，而不是它的字面意思。下图提供了英语习语的其他例子。

卡普兰关于货币和金融的习语示例

但正因为如此，习语对语言学习者来说是一个挑战。因此，相对于学习它们的结构而言，它们和它们的意义被教授和记忆是很常见的。

为了将习语与其他短语和谚语区分开来，可以考虑以下属性:

• 惯例:一个习语的整体意思不能(完全)从组成它们的每个单词的字面意思中预测出来。
• **不灵活:它们的语法是受限制的，也就是说，它们的构成方式没有太大变化。
• **比喻:它们通常具有源于隐喻、夸张和其他类型比喻的比喻意义。
• 众所周知:它们通常描述一种反复出现的社会状况。
• 非正式:它们与不太正式的语言如口语联系在一起。
• 影响:他们通常暗示对某事的情感态度，而不是中立的态度。

最后一个属性， affect ，意味着习语本身可以用于确定一段文本中表达的情感。例如，“我对结果感到欣喜若狂”表达了一种积极的情绪。

数据收集

风格

为了使用习语作为情感分析的特征，我们需要更多关于它们潜在情感的信息。在这种情况下，我们求助于 Learn English Today 网站，该网站按主题整理了 580 个习语，其中许多可以直接(例如快乐、悲伤)或间接(例如成功、失败)映射到一种情绪。我们特别关注与情感相关的习语，因为它们预计会对情感分析结果产生一些影响。我们从总共 60 个可用主题中选择了 16 个，并在下表中列出了相关习语的数量。

跨主题的习语分布(表 1

文集

除了一系列习语，我们还需要它们在上下文中使用的例子。在这种情况下，我们搜索了英国国家语料库(一个从各种来源收集的书面和口头英语的大型文本语料库)，寻找在不同上下文中使用的 580 个习语的例子。总的来说，我们收集了 2521 个句子，其中包含一个可以与习语匹配的表达式。

在大多数情况下，习语都有与之相关的比喻意义。但在其他情况下，他们传达的是字面意思。从这个意义上说，有些句子是误报的。例如:

“威尔士农民的儿子已经将 1988 年有条件骑师的头衔收入囊中。”

“我看了看袋子，里面全是鱼。”

有必要包括假阳性，这样我们就可以评估错误识别的习语会如何影响情感分析的结果。

手动注释习惯用法

虽然习语已经在许多学科得到了广泛的研究，但到目前为止，还没有一套完整的习语被系统地映射到他们的情感上。这就是为什么习语在情感分析中作为特征的代表性不足的主要原因。

在这种情况下，至少需要 3 名注释者来标记上下文中使用的每个成语示例是否反映了积极、消极、中立或模糊的情绪。同样，要求 5 名注释者断章取义地标记每个习语表达的情感。

为了测量带注释的数据集的可靠性，我们使用 Krippendorff 的 alpha 系数来测量注释者之间的一致性。还有其他协议度量，但是，这种度量被认为是可靠的，因为它考虑了任意数量的注释者(不仅仅是两个)、任意数量的类别，并且考虑了不完整或缺失的数据。

Krippendorff 的α系数根据以下公式计算:

克里彭多夫阿尔法系数

其中 Do 是观察到的不一致(两个注释者都同意的项目的比例)，而 De 是随机给出注释时预期的不一致。Krippendorff 建议将α = 0.667 作为最低可接受值，以将数据集视为训练模型的可靠数据集。Krippendorff 的α系数 1 表示完全一致，而 0 直观地表示不一致。因此，较高的值表示更好的一致性。

在习语数据集上的一致性计算为 De = 0.606， Do = 0.205，α = 0.662。在上下文中使用的成语语料库的一致度计算为 De = 0.643， Do = 0.414，α = 0.355。

仅习语的一致性(α = 0.662)就说明了它们在某种程度上可以映射到它们的情感极性。然而，在成语的上下文例子上显著较低的一致性(α = 0.355)说明了注释者的主观情感解释。

Krippendorff 的 alpha 系数的值可以使用计算注释者协议的在线工具获得，例如 ReCal ，或者可以在 Python 中实现。

金本位

然后，带注释的上下文实例被用来为情感分析实验创建一个黄金标准(被认为是最有效的标准)。为了创造一个黄金标准，至少 50%的注释者中的相对多数同意的每一句注释都被视为基本真理。也就是说，如果两个注释者同意“好吧，不要打断我的话”反映了负面情绪，而第三个注释者注意到它反映了正面情绪，则与该句子相关联的基本事实被确定为负面的。

习语认可

为了将习语作为情感分析的特征，我们需要在文本中自动识别它们的方法。事实上，大多数习语的结构都是不灵活的，这使得这一点变得可行。**

词汇句法模式(一种基于文本标记和句法结构的字符串匹配模式)可以用于计算建模习语，以自动识别它们在文本中的出现。许多习语是冻结的短语(它们的结构不变)，可以通过简单的字符串匹配来识别。但是句法上的变化，如词形变化(如动词时态的变化)，也会在习语中出现。这些可以使用正则表达式(RegEx)来建模，例如 spill[s|t|ed] the beans，或者对于更复杂的习语，使用词汇句法模式(例如将 NP 放在 PRN 的位置)。

在这种情况下，习语识别规则被实现为一种简单的模式匹配语言 Mixup (我的信息提取和理解包)中的表达式。例如，下面的语法:

《习语》: =《VB》《PRP》《PRP 袖上的心》

﹔VB ﹔: = wear | wear | wear | wear | wear

〈PRP$〉 ::=我的，你的，他的，她的，它的，我们的，他们的

被用来成功地识别出习语下面这句话中的穿心:

“与其把你的心放在袖子上，而不是放在帽子下面，你不如把它藏起来。”

将模式匹配规则应用于 500 个句子的测试数据集(原始数据集的 40%)，其中注释者标记所有习语出现，区分比喻和字面意义。例如:

“唷，那真是一次〈习语〉 千钧一发 〈习语】。”

“他的鞋子擦得锃亮，胡子刮得很干净，而且太骄傲了，不想喝免费的酒。”

识别习语的表现以 97.14%的 F1 分数记录，其中如果建议的文本跨度与注释者标记的文本跨度完全匹配，则认为习语被正确识别。

使用 Mixup 识别习语

特征工程

为每个习语收集的 5 个注释用于计算它们的特征向量。每个习语被表示为一个三元组:(正、负、其他)，其中每个值表示相应类别中注释的百分比。比如习语穿心收到了 1 个正面，0 个负面，4 个其他注解。因此，它被表示为以下三元组:(20，0，80)。

由于我们想要调查习语作为情感分析中的特征的影响，我们进行了两个实验，其中我们将习语的三重表示与两种流行的情感分析方法的结果相结合: SentiStrength 和 Stanford CoreNLP 的情感注释器。

在第一个实验中，我们使用了 SentiStrength，这是一种词袋方法，它通过聚合单个词的极性来为句子分配情感极性

输入:晚会结束。**

解析:当事人[1]超过了[1]。

输出:结果= 0，正= 1，负= 1

如给定示例所示，短语 party is over 将被识别为习语，它映射到以下三元组:(0，100，0)表示所有注释者都认为它是否定的。我们将这两个向量相加，为给定的句子创建一个单一的特征向量，如下所示:

在第二个实验中，我们使用了作为 Stanford CoreNLP(一套核心 NLP 工具)的一部分分发的情感注释器。该方法使用递归神经网络，通过在 5 点尺度上对每个子树进行分类(非常负面、负面、中性、正面和非常正面),在解析树的所有组成级别上执行情感分析。除了分类之外，它还提供了跨 5 个类别的概率分布，通过将它们转换成 5 维向量，我们在我们的方法中将其用作特征。如前所述，习语聚会结束了将被识别，并且其三元组被附加以创建给定句子的单个特征向量，如下所示:

对于这两个实验，为每个句子产生的特征向量与它们的基础真实类标签连接在一起:

情感分类

一旦我们将习语和习语的上下文实例作为特征向量来表示和组合，我们就使用一套流行的机器学习软件 Weka 来训练分类器并进行分类实验。我们基于对训练数据集(原始数据集的 60%)的交叉验证实验的结果来选择机器学习方法。贝叶斯网络分类器优于其他方法。

分类性能根据三个指标进行评估——精确度(P)、召回率(R)和基于真阳性(TP)、假阳性(FP)和假阴性(FN)数量的 F1 分数。

使用 SentiStrength 作为基线方法的评估结果

使用 Stanford CoreNLP 情感标注器作为基线方法的评估结果

结论

那么，我们从这个分析中学到了什么？

我们证明了习语作为情感分析特征的价值，通过表明当习语存在时，基于习语的特征显著地改善了情感分类结果。F1 分数的整体表现在一个实验中从 45%提高到 64%，在另一个实验中从 46%提高到 61%。

下一步是探索如何使用正则表达式在 Python 中实现习语识别规则。这是为了使习语识别规则更易于使用并且与使用 Scikit-learn 构建情感分类器兼容。

对于完整的数据集和混淆规则，请查看下面我的 GitHub repo:https://github.com/LowriWilliams/Idiom_Sentiment_Analysis

主题建模:超越令牌输出

原文：https://towardsdatascience.com/️-topic-modelling-going-beyond-token-outputs-5b48df212e06?source=collection_archive---------10-----------------------

关于如何给题目赋予有意义的标题的调查

注: 本文讨论的方法背后的方法论源于 数据创新加速器 和 之间的一个合作项目，简单地说就是做想法 。

介绍

我最近面临一项任务，其最终目标是将大量非结构化的句子和短文段自动聚合到相关主题的组中。

在这个任务中，我意识到主题建模方法还没有太多的报道，特别是当试图给主题起一个有意义的名字时。我很快意识到现有的方法有同样的问题；他们使用一系列标记(单个单词)来命名主题。通常由人类解释者来决定，例如，'mouse', 'keyboard', 'monitor', 'cpu'是来自描述计算机部件的一段文本的标记。

这篇文章讨论了关键词提取技术和主题建模的应用，以便给主题起一个有意义的名字。在这种情况下，我将有意义的 T21 定义为不仅仅是一些符号，在这些符号中，读者必须解释它们之间的整体语义关系，以理解整体主题。作为一名读者，从前面提到的例子中，我希望能够知道这个特定的主题是关于'computer parts'的，而不必考虑太多。

数据预处理

Susan Li 是数据科学社区的知名撰稿人。她那篇名为“ 用 NLTK 和 Gensim”用 Python 进行主题建模的文章，因其清晰地应用了潜在狄利克雷分配 (LDA)，一种广泛使用的主题建模技术，将精选的研究论文转换为一组主题，而获得了一些好评。

有问题的数据集可以在 Susan 的 Github 上找到。它由 2，507 个简短的研究论文标题组成。

在我们开始应用 LDA 主题建模方法之前，让我们先来看看我们需要考虑的预处理技术。像许多自然语言处理(NLP)问题一样，通常要做的第一件事是将文本转换成小写，并去掉文本中的任何标点符号，这样我们就有了一组标准化的字符串来处理。如果我们不删除它们，我们经常会得到重复的字符串集合，它们的不同仅仅是因为它们包含了一些应该被删除的内容。此外，我说“许多 NLP 问题，而不是“所有 NLP”问题作为情感分析中的标点符号，一个旨在自动检测一段文本是否表达积极或消极情感或观点的 NLP 问题，是需要考虑的重要问题。作为一个简短的例子，考虑读者如何基于感叹号的过度包含来不同地解释They cut my hair short和They cut my hair short!!!!的情绪。然而，在应用主题建模时，标点符号是相对无意义的。我们可以通过使用正则表达式来删除它们。我们还想考虑删除字符串两端以及字符串内部可能出现的额外空白。

既然我们的文本去掉了标点符号，我们希望将标题表示为单个单词(记号化),并考虑删除停用词。停用词(如“the”、“a”、“an”、“in”)是提供无意义信息的常用词，通常在预处理阶段从文本中移除。

我们可以使用 Python 的 NLP 库之一自然语言工具包(NLTK)轻松标记和删除停用词。为了说明这一点，我们可以将 NLTK 内置的word_tokenize函数应用于标题。该输出将每个文本表示为一个包含构成标题的每个单词的list。然后我们可以初始化 NLTK 的停止字功能。我注意到现在还没有一个像样的停用词表，很多人和我一样，不得不在原来的列表中添加单词。然后，我们遍历每个列表，删除与停用词列表相对应的词。

最后，我们想看看如何将引理满足应用于每个标题的剩余单词。词条满足考虑了单词的形态分析。为此，有必要拥有详细的字典，算法可以通过这些字典将该形式链接回其所有屈折形式的引理或基础形式(例如，studies, studying共享引理study)。NLTK 包含一个英语词汇数据库。这些单词根据它们的语义关系连接在一起。这种联系取决于单词的意思。特别是，我们可以使用 WordNet，一个词汇之间语义关系的词汇数据库。再一次，我们假设我们想要得到一套描述论文标题的标准化词汇。我们初始化 WordNet lemmatiser，然后应用于列表中的每个单词，用它的 lemma 替换它。现在，输出应该是这样的:

主题建模

现在我们的数据已经处理完毕，我们可以开始研究如何应用 LDA 并将论文标题分组到主题中。在我们这样做之前，还有最后一个预处理步骤，那就是将标题表示为向量，也就是说，我们需要将数据表示为数字形式，以便模型可以处理它们。您可以使用几种表示方法，最流行的方法是单词的 TF-IDF 得分或它们的频率计数(单词袋方法)。在这里，我们将坚持单词袋表示法。我们将使用 Sklearn 的特征提取模块中的CounterVectorizer函数。该函数将文本集合转换为字数矩阵。

Sklearn 还包括一个 LDA 版本。对于这个概念，假设我们想将论文标题分成 10 个主题中的 1 个。一旦设置了参数，我们就可以使 LDA 适合文本的矢量化版本。为了更容易阅读，我们可以将为每个主题产生的相关性分数作为一列附加到每个标题，并通过取具有最高相关性分数的主题来计算主导主题。

太好了！现在我们可以看到标题属于哪个主题(根据其编号)。但是 LDA 给出了什么关键词来描述这些话题呢？我们可以通过调用矢量器的get_feature_names()函数来查看它们:

信息对我们有多大用处？嗯，它不是那么有用，因为有一些主题有相同的关键字，如network和data。我们要删除那些重复的单词，因为我们希望在给主题分配有意义的标题之前，一个标题只属于一个主题。

为主题指定有意义的名称

现在是有趣的部分。让我们首先将每个主题的令牌输出合并到主数据帧中与该主题对应的每一行。这样，我们就有了一个主要的数据框架。

在我解释代码做什么之前，我们先介绍一下快速自动关键词提取(RAKE)。RAKE 是一个众所周知的关键字提取工具，它使用停用词和短语分隔符列表来检测一段文本中最相关的词或短语。以下面的文字为例:

“关键词提取终究没那么难。有许多库可以帮助你提取关键词。快速自动关键词提取就是其中之一。”

首先，RAKE 将文本分割成一个单词列表，在这个过程中删除停用词。这将返回一个名为内容词的列表。

content_words = [ keyword，extraction，difficult，many，libraries，help，rapid，automatic ]

然后，该算法在短语分隔符和停用词处拆分文本，以创建候选表达式。因此，候选关键短语如下:

*Keyword extraction* 终究不是那个 *difficult* 。还有 *many libraries* 可以 *help* 你跟 *keyword extraction* 。 *Rapid automatic keyword extraction* 就是其中之一。

一旦文本被分割，该算法就创建一个单词共现矩阵。每行显示给定的内容词与候选短语中的每一个其他内容词同时出现的次数。对于上面的示例，矩阵如下所示:

在矩阵建立之后，单词被给予一个分数，该分数可以使用三种方法之一来计算:矩阵中单词的度(即该单词与文本中任何其他内容单词共现的次数之和)，作为词频(即该单词在文本中出现的次数)，或者作为该单词的度除以其频率。

如果我们要计算示例中每个单词的程度分数除以频率分数，结果将如下所示:

这些表达也有一个分数，这个分数是单词的分数总和。如果我们要计算上面粗体短语的分数，它们会是这样的:

如果两个关键字或关键短语以相同的顺序同时出现两次以上，则不管该关键短语在原始文本中包含多少停用词，都会创建一个新的关键短语。该关键短语的分数就像单个关键短语的分数一样被计算。

如果关键字或关键短语的分数属于前 T 个分数，则选择该关键字或关键短语，其中 T 是要提取的关键字的数量。对于上面的例子，该方法将返回前 3 个关键字，根据我们定义的分数，它们将是快速自动关键字提取 (13.33)、关键字提取 (5.33)和许多库 (4.0)。

因此，如果我们迭代每个主题，并对这些主题中的原始论文标题应用 RAKE，我们可以提取关键字和短语，以及它们的分数。我们希望能够将使用 RAKE 提取的关键字与 LDA 模型提取的关键字相关联。我们可以将 RAKE 的关键词分成单词和双词，并根据 LDA 的输出屏蔽这些词。我们这样做是因为 RAKE 会提取可能与该主题无关的关键词。

一旦我们过滤掉不相关的关键词，如果我们对它们的得分进行降序排列，我们应该会看到每个主题得分最高的关键词。我们可以把这些得分最高的关键词作为每个题目的主标题。如果有不止一个关键字，我们可以将它们附加在一起，并用分隔符/将它们分开。

剩下的关键词呢？那些也很有用。事实上，根据您试图通过主题建模实现的目标，这些剩余的关键字可以用作主题的子术语。也就是说，这个话题还可能是关于什么的。

我们有很多子术语，所以我们可以通过选择得分高于 10 的关键字来限制它们。让我们用旭日图来展示结果，这样我们就可以看到它的实际效果。

不错！我们有 10 个主题，每个主题都有几个子术语。但最重要的是，每个题目都是知识性的！让我们看看观想的粉红色部分。主题是“mpeg 4 avc h 264 视频编码应用”。它有 7 个子主题，都与视频配置框架相关:

“mpeg 可重构视频编码框架”、“使用小波的分布式视频编码”、“基于分布式视频编码”、“可重构视频编码框架”、“达到 100 编码效率”、“帧间视频编码”、“T10”、“T11”高分辨率视频编码。

结论

那么，我从这个分析中学到了什么？

将关键词提取与主题建模相关联是一种非常有用的方法，可以为给定的主题确定更有意义的标题。像许多数据科学问题一样，问题的核心任务之一是数据的预处理。但是一旦做了，而且做得好，结果会很有希望。

我怀疑这种方法也可以用来支持自动确定将数据分成多少个主题。已经有一些方法可以做到这一点，例如在一系列主题上运行 LDA，并将每个模型的最低复杂度视为主题的最佳数量。在这篇文章中，我们手动选择将数据分布到 10 个主题中。但是，如果一个人可以计算在给定的范围内每个主题是否存在关键词，并将具有全套关键词的最高数量的主题作为最佳主题数量，结果可能会很有趣！这是我想进一步调查的事情。

完整的笔记本，请看下面我的 GitHub repo:https://GitHub . com/lowri Williams/Topic _ modeling _ Beyond _ Tokens

1+1=?当因果推理遇到机器学习时更好的决策

原文：https://towardsdatascience.com/1-1-better-decision-making-when-causal-inference-meets-machine-learning-bd3b00d8286b?source=collection_archive---------46-----------------------

双机器学习:使用机器学习(ML)方法估计因果效应的一般框架

近年来，机器学习已经应用于不同的领域，如在线营销和商务，个性化医疗和数据驱动的政策制定。这一巨大的成功使得人们对自主系统做出正确决策的期望越来越高。公司经常使用经典的机器学习工具来解决决策问题，例如在哪里定价，或者营销活动以哪些客户为目标。这引发了当今机器学习的主要挑战之一，即理解因果联系。

决策问题需要因果关系

要做出数据驱动的决策，对因果关系的理解是关键。这里有一个来自我们日常业务的简单例子:价格弹性。为产品设定最优价格，公司需要知道在不同(假设)价格水平下会卖多少，这就是需求的价格弹性。

如果你是一个 ML 从业者，一个经典的 ML 算法，以价格水平作为一个特征来预测销售结果，可能是你的首选。然而，在实践中，这种方法不能简单地给出价格对销售的因果影响。下面的情节展示了“为什么”——预测和因果推理是截然不同的(尽管密切相关)问题。(Athey，2017，第 484 页)左手边，是预测问题，我们在寻找价格和数量的相关性。在右边，虚线是反事实，即如果我改变价格，给定产品的销售额是多少。尽管有积极的联系，因果关系是负面的。如果我们提高价格，数量就会减少。

预测(左)与因果推理

正如上面的例子和许多其他例子在 Athey，S. (2017)中描述的那样。超越预测:使用大数据解决政策问题。科学 335，483–485，机器学习模型不是为了估计因果关系而建立的。应用机器学习的现成预测方法会导致对因果影响的有偏估计。另一方面，传统的因果推理需要对模型的函数形式进行强有力的假设。如果我们错误地指定了函数形式，我们最终会得到有偏差的估计。因此，可以修改现有的机器学习技术，以利用机器学习的优势从数据中学习条件期望函数的形式——双机器学习的诞生！

两全其美的通用框架

有许多研究人员在因果机器学习领域开发方法。我对双机学习特别感兴趣，因为它的通用性和简单性。它可以与惩罚方法、神经网络、树算法和集成方法结合使用，并且易于操作。让我告诉你这有多简单:

假设我们有几组具有重要特性 X 的产品，我们用 P 来表示价格，Y 是需求响应(销售)。我们然后:

1. 在 X 上回归 Y，并计算 Y 与模型中 Y 的预测值之间的差值(即残差)，我们称之为 Y_res。
2. 我们类似地回归 X 上的 P，并计算 P_res，即 P 与模型中 P 的预测值之间的差值。
3. 最后，我们在 P_res 上回归 Y _ RES。P _ RES 上的结果系数是 P 对 Y 的因果效应的点估计。

为了得到一个公正的估计。你需要在每个步骤中应用交叉拟合。更具体地说，您应该:1)将您的数据随机划分为两个子集 2)在第一个子集中拟合两个 ML 模型 3)使用我们在第一个子集中拟合的模型估计第二个子集中的系数 4)检查 1 到 3，但在每个步骤中翻转子集 5)平均系数，这将是无偏估计

这不是简单明了吗？！如果你仍然对如何实现它没有信心，我推荐一个很棒的 python 包，叫做 econML 。它包含了许多前沿的因果机器学习作品，double ML 就是其中之一。以下是该包的代码片段:

 est = LinearDMLCateEstimator(model_y=MultiTaskElasticNetCV(cv=3, tol=1, selection='random'),
                             model_t=MultiTaskElasticNetCV(cv=3),
                             featurizer=PolynomialFeatures(1),
                             linear_first_stages=**True**)
est.fit(Y, T, X, W)
te_pred = est.const_marginal_effect(X_test)# Reference: [https://github.com/microsoft/EconML/blob/master/notebooks/Double%20Machine%20Learning%20Examples.ipynb](https://github.com/microsoft/EconML/blob/master/notebooks/Double%20Machine%20Learning%20Examples.ipynb)

其中 Y 是结果，T 是治疗，X 是特征，W 是共同创始人。这个包可以让你把不同的机器学习模型嵌入到它的 double ML 类中，超级方便。

在这篇文章中，我介绍了因果关系和机器学习的一些基本概念。此外，我还引入了一个广义 ML 框架来估计因果效应。您可以将这种方法应用到您的工作或其他数据科学项目中，以帮助您获得最佳控制，从而更快地获得正确答案。

我计划分享更多关于这种方法的理论，这样你就能更好地理解为什么以及如何推进这种方法。

参考:

1. 爱丽丝(因果关系和经济学的自动学习和智能)——微软研究院
2. 对随机实验中异质治疗效果的一般机器学习推断

1.Apache Spark 简介

原文：https://towardsdatascience.com/1-introduction-to-apache-spark-299db7a4b68d?source=collection_archive---------17-----------------------

理解大数据，探索 Spark 性能优化

开始探索 Spark 性能优化新系列的启动帖子

照片由 NASA 在 Unsplash 上拍摄

Apache Spark 是大数据领域的一个流行框架。由于我有 Python 和 SQL 编码的背景，我很快就掌握了 Spark 的使用方法。然而，由于不了解这些机制，我在开始时经常感到困惑。我以前在单机上运行代码的经验向使用集群的转变，加上处理的数据大小变化从 MB 向 GB(甚至 TB)的转变，促使我开始学习 Spark。我将在这个系列中讨论我对 Spark 性能优化的探索，从第一篇介绍文章开始。这篇文章将涉及一些与 Spark 相关的关键概念、API 和工具。

事不宜迟，我们开始吧！

Spark 是一个分布式集群计算软件框架。它提供了简单的 API 来计算大量数据，而最终用户几乎不需要了解跨机器的任务和资源管理，这些都是由 Spark 在幕后完成的。

1.分布式计算

要实现分布式计算，需要在一个机器集群上进行资源和任务管理。资源管理包括为当前任务获取可用的机器，而任务管理包括协调集群中的代码和数据。

Spark 应用程序由驱动程序组成，在集群上执行并行计算。为了启动 Spark 应用程序，在主机上运行的驱动程序将首先启动一个SparkContext对象。这个SparkContext对象将与一个集群管理器通信，这个集群管理器可以是 Spark 自己的独立集群管理器、Mesos、YARN 或 Kubernetes，以获取这个应用程序的资源。然后，SparkContext对象将把应用程序代码和任务发送给工作节点。

对于一个应用程序，一个 worker 节点可以有多个执行器，这取决于该 worker 节点上可用的 CPU 数量。在应用程序的计算过程中，每个执行器将数据保存在内存或磁盘存储器中，并运行任务。这样，执行者就相互隔离了，同一个应用程序的任务并行运行。

火花簇模式概述

2.弹性分布式数据集(RDD)

是 Spark 中的核心抽象，代表弹性分布式数据集。它能够将大数据分割成适合每台机器的较小数据，因此计算可以在多台机器上并行进行。此外，rdd 会自动从节点故障中恢复，以确保存储的弹性。

HDFS (Hadoop 分布式文件系统)是我在使用 Spark 时经常碰到的另一个重要概念。尽管 RDD 和 HDFS 都是关于弹性分布式存储的，但它们是为处理不同的问题而设计的。RDD 的弹性观点指的是计算失败的自动处理。虽然 HDFS 是关于存储管理的，但它是为处理存储故障而设计的。

3.Spark APIs

Spark 提供了三个 API:data framesDatasets。所有这三个 API 都确保了分布式、弹性的数据计算，但是它们适用于不同的应用场景。****

三个 Spark API

RDD 是 Spark 提供的底层 API，它支持非结构化或半结构化数据的操作。使用 RDD 就像告诉 Spark 如何执行任务，而不是简单地告诉 Spark 执行什么任务。因此，在这三个 API 中，RDD 提供了最好的编码灵活性和数据控制。然而，与此同时，在没有利用 Spark 内部优化的情况下，一个好的 RDD 大师对程序员的经验提出了更高的要求。

除了低级的 RDD API，Spark 还提供高级的 DataFrames API。数据框架强调数据结构。因此，DataFrames 对有关系数据库经验的程序员来说是友好的。当使用 DataFrame 时，感觉非常类似于使用 Pandas DataFrame 或 Excel 电子表格，但 Spark 在幕后处理集群计算。

如果我们说 RDD 和数据框架 API 位于倾斜的两侧，RDD 位于灵活的低级控制一侧，数据框架位于简单的高级编码一侧，那么数据集 API 位于其他两个 API 的中间。在 DataFrames API 之上，Datasets API 强加了类型安全以避免运行时错误。

RDD 和数据集 API 都需要类型安全，并且只支持 Java 和 Scala。但是 DataFrame API 支持动态类型语言，比如 Python 和 r。

Jules Damji 有一个关于 RDD、数据框架和数据集的精彩博客。如果你有兴趣，别忘了去看看。

4.Spark SQL

Spark SQL 是 Spark 处理结构化数据的模块。

Spark SQL 使用两种结构化 API，即数据集和数据帧。利用仅在数据集或数据帧中可用的模式信息，Spark SQL 代码以声明的方式告诉 Spark 做什么，而不是在使用低级 RDD API 时告诉 Spark 如何做。这样，用 Spark SQL 编写的代码受益于 Spark 的 catalyst，它优化了性能。因此，使用 Spark SQL 和结构化 API 更容易编写高性能代码。

Catalyst 优化 SQL 查询性能

使用 Spark SQL 和 DataFrames API 相当于在关系数据库上运行 SQL 查询。常用的 SQL 函数，如 filter、join、aggregation、window 函数等，在 Spark SQL 中也有。Spark SQL 和 DataFrames API 支持几种编程语言，包括 Python、R、Scala 和 Java。

Spark SQL、 Presto 和 Hive 都支持使用 SQL 语法查询驻留在分布式存储中的大规模数据，但用于不同的场景。

Spark SQL 是 Spark 中的核心模块，而 Presto 在 Hadoop 生态中。Spark SQL 强调计算，通常用于大规模 ETA 和流水线。然而，Presto 强调查询，更常用于特别分析。Spark SQL 和 Presto 都在内存中计算。当谈到内存短缺时，Spark SQL 允许溢出到磁盘中，而 Presto 将遭受 OOM 问题。Spark SQL 中也考虑了容错，但 Presto 中没有。

Hive 是一个数据仓库软件，管理 Hadoop 生态系统中的大规模结构化数据。Hive 查询可以通过 Spark 或 MapReduce 来执行。Hive 有自己的 SQL 引擎，名为 HiveQL。正如我们上面提到的，Spark SQL 是 Spark 处理结构化数据的模块。类似地，Hive 是 Hadoop 处理结构化数据的模块。

总结

在这篇文章中，我讨论了 Spark 的一些基本概念。尽管高级 DataFrame API 和 Spark SQL 使得编写高性能代码更加容易，但是理解 Spark 的工作方式有助于进一步提高性能。在下一篇文章中，我将以 YARN 为例，讨论如何使用 YARN web UI 理解 Spark 资源和任务管理。如果你对本次探索星火性能优化系列感兴趣，敬请关注！

1 个破坏你生产力的错误

原文：https://towardsdatascience.com/1-mistake-ruining-your-productivity-ae6e52ef2693?source=collection_archive---------53-----------------------

改变这一习惯，在进行下一次分析时提高你的效率。

照片来自约书亚·科尔曼在 Unsplash

完成分析后，不要乱扔笔记本。当你开始下一个项目时，它会毁了你的工作效率。当我从事不同的数据科学项目时，我回头看我创建的笔记本，并想，“这些代码可以重用吗？”答案几乎总是肯定的！开发一个可重用的代码库将允许你运行重复的分析，并且当你与他人分享你的代码时，使它更具可读性。

什么是代码重用？

代码重用是将现有的代码或笔记本用于新的功能或应用。正如《T4 系统编程》一书中所说的，代码重用有很多好处，它允许更好的代码可读性、更好的代码结构和更少的测试。

保留旧笔记本有助于代码重用。您可以开始看到您正在重复的代码模式，并使用它们来开发函数或类。这种重构工作将帮助您在避免重复的同时改进代码。您将拥有更多可维护的功能，这些功能在将来需要时更容易更新。当您创建这些函数时，您可以开始合并单元测试来验证您的函数是否正常工作。单元测试是一项有价值的工作，通过向您展示您的功能是否产生了预期的结果，有助于避免将来出现问题。

为什么要实践代码重用？

通过创建函数/类在以后的项目中使用的代码重用是一种有价值的技术，它将帮助您在运行您的分析时变得更有效率并节省时间。正如 Matlab 关于代码重用的文章中所讨论的，代码的模块化也将使多个个体能够容易地使用相同的功能。如果您决定为您的数据科学项目创建您的软件库，您会有许多代码重用的例子。这个库将包含许多函数和类，负责数据科学工作的不同方面。

学习使用可重用和面向对象的代码也将允许您使用自定义实现来实现新的行为。例如，您可能会发现自己使用的数学库不包含您需要的函数或以特定方式行动的能力。学习重用代码和用 OOP 编写将允许你扩展库的功能，使之适合你的用例。

Thomas Huijskens 提出了一个很好的观点，即你的代码应该可以投入生产。当您想要重新运行一个分析时，学习创建函数和清理代码对您也是有价值的。如果你开发了一个有用的分析，你会想把它展示给不同的管理层或者推动一个业务单元的行动。在这种情况下，您的代码应该易于重新运行和维护。在函数中清理代码并使其可读将使您在下次需要分析时更容易重新运行和重新创建结果。您可能会发现，随着您继续开发，您的分析和可视化会推广到其他团队或客户。编写函数将有助于使您的分析可重复，代码可读。

最后的想法

保留您的旧笔记本并开发可重用的代码将有助于提高您在数据科学方面的生产力。创建一个可重用的代码库将允许您运行重复的分析，并在与他人共享您的代码时使其更具可读性。您的代码应该是生产就绪的，这样任何人都可以从您停止的地方开始，重新运行分析，并理解代码。当您开始下一个项目时，考虑使用函数，编写清晰的文档，并找到高重用性的领域。

附加阅读

• Richard John Anthony，在系统编程，2016 第 7.5.4 章机会出现时重用代码
• Matlab 什么是代码重用？
• Arho Huttunen 对代码重用的误解
• 对于数据科学家来说，唯一有用的代码是 Thomas Huijskens 的生产代码

如果你想阅读更多，看看我下面的其他文章吧！

[## 停止浪费你的时间，咨询一个主题专家

在从事数据科学项目时，请一位主题专家来审查您的工作可能会有所帮助。

towardsdatascience.com](/stop-wasting-your-time-and-consult-a-subject-matter-expert-f6ee9bffd0fe) [## 每位数据科学工程师的前三本书

我放在书架上的伟大资源，我喜欢介绍给软件工程师和数据科学家。

towardsdatascience.com](/top-3-books-for-every-data-science-engineer-e1180ab041f1) [## 在数据科学中我们需要面向对象编程吗？

让我们讨论一下作为一名数据科学家转向面向对象编程的利弊。

towardsdatascience.com](/do-we-need-object-orientated-programming-in-data-science-b4a7c431644f) [## 采用现有数据科学项目的成功关键

代码本来可能不是你的，但现在是你的了。那么接下来呢？

towardsdatascience.com](/keys-to-success-when-adopting-a-pre-existing-data-science-project-9f1225fb0275) [## 从一年的会议中吸取的 7 大教训

日历上有如此多的会议，有时 it 会觉得它们没有达到应有的效果。

medium.com](https://medium.com/the-innovation/top-7-lessons-learned-from-a-year-of-meetings-cbf419910649)

为您的数据科学项目查找任何数据集的 1 个技巧

原文：https://towardsdatascience.com/1-trick-to-find-any-dataset-for-your-data-science-project-391c365359f4?source=collection_archive---------48-----------------------

使用谷歌数据集搜索引擎搜索和贡献数据集

弗兰基·查马基在 Unsplash 上拍摄的照片

互联网上有数千个数据集储存库，提供对数百万个数据集的访问。任何人工智能项目的一个共同要求是存在大量数据来训练模型，数据越多越好。每个有抱负的数据科学家都面临着为他们的数据科学项目找到正确数据集的问题。

也有很多开源数据集可供不同组织、大学和政府研究，你可以直接访问他们的网站。您可以在下面找到其中的一些:

一些开源数据集来源:

1. 各种数据集由 ka ggle:【https://www.kaggle.com/datasets
2. https://archive.ics.uci.edu/ml/index.php UCI 的 ML 数据集:
3. 美国政府开源数据:https://www.data.gov/
4. NOAA 提供全球历史天气和气候数据:https://www.ncdc.noaa.gov/cdo-web/
5. Qualdl 的金融、经济和替代数据集:https://www.quandl.com/
6. 英国社会、经济和人口数据资源:https://www.ukdataservice.ac.uk/
7. 国际货币基金组织贷款、汇率和其他经济和金融指标的时间序列数据:https://www.imf.org/en/Data

有很多网站提供开源数据集。您不必再花费宝贵的时间从多个来源为您的数据科学项目寻找合适的数据集，而是在一个地方找到它们。

谷歌数据集搜索:

谷歌有一个数据集搜索引擎，你可以在那里找到你的数据科学项目的数据集。它索引了数据集上可用的宣传，并在这个 Google 数据集搜索引擎上推荐给用户。

(图片由作者提供)，谷歌数据集搜索引擎

使用https://datasetsearch.research.google.com/网址访问谷歌数据集引擎。

谷歌数据集搜索可以为你的项目找到合适的存储在互联网上任何地方的数据集。

如何从 Google 数据集搜索中找到数据集:

您可以通过提供支持信息(如名称或描述)来搜索任何数据集。谷歌搜索使用 schema.org 和其他元数据标准向你推荐数据集。

(图片由作者提供)，在谷歌数据搜索上搜索数据集时的建议

在很高的层面上，谷歌依赖于数据集提供者。它使用可用数据集的元数据，将其与可用的其他资源链接，并建立这个丰富的元数据语料库的索引。

(来源)，谷歌数据集搜索背后的技术概述

为 Google 数据集搜索贡献您的数据:

您也可以在互联网上公开您的数据集，它可以由谷歌数据集搜索引擎推荐。要在互联网上公开您的数据集，您需要遵循特定的步骤。

1. 向 schema.org 的添加元数据，读取文档添加元数据。
2. 验证标记产生了您在结构化数据测试工具中预期的结构化数据
3. 如果你有多个页面，创建一个站点地图，并将它添加到你的搜索控制台

结论:

使用 Google 数据集搜索，您可以从大量公开可用的数据集中找到适合您的数据科学项目的数据集。谷歌数据集搜索引擎的目标是为发布、消费和发现数据集开发一个生态系统。

参考资料:

[1]谷歌数据集搜索常见问题解答(2019 年 3 月 2 日):https://support.google.com/webmasters/thread/1960710

[2]乔·詹姆斯 Youtube 视频(2019 年 12 月 3 日):https://www.youtube.com/watch?v=1aUt8zAG09E

感谢您的阅读

柏林房租冻结前一周:我能在网上找到多少非法的高价报价？

原文：https://towardsdatascience.com/1-week-until-the-berlin-rent-freeze-how-many-illegal-overpriced-offers-can-i-find-online-6e5511d49e5a?source=collection_archive---------20-----------------------

乔纳斯·泰贝在 Unsplash 上的照片

柏林目前的住房状况

搬到柏林后，找到一套价格合理的公寓绝对是最困难的事情之一。为了了解竞争有多激烈，11 月1749 名找房子的人在外面排队参观位于著名的舍内贝格区的一套空置公寓。就在 12 小时前，这套公寓在网上登了广告。

为了阻止不断上涨的住房成本，柏林州政府通过了一项有争议的法律来限制房租。再过一周，2 月 23 日，新法将正式生效。

目前的网上公寓是否遵循租金上限？

作为我的下一个数据科学辅助项目，我决定分析immobilienscout 24上当前的在线房源，看看当前的房东是否已经尊重新的租金上限。不遵守法律会被处以高额罚款:

违反租金上限可能会被处以高达 500，000 欧元的罚款。

我把这篇博客分成三部分，帮助你找到和阅读与你最相关的内容:

• 第一部分:一些技术细节和我如何获得数据集
• 了解更多关于租金上限及其计算方法的信息
• Part 3: 直奔结果，看我发现了什么。

第 1 部分:在 4 分钟内下载 4040 个列表

有了这个惊人的 scrapy 包，我能够在两分钟之内的两个会话中从网上搜集到总共 4040 个房源。当然，设置蜘蛛花了相当长的时间。

接下来，所有的数据都被加载到一个pandasdata frame中并进行清理。我不会在这里说太多细节，但这是相当多的清洗。

第 2 部分:批量计算新的租金上限

为了计算新的租金上限，我不得不为数据集设计一些特性。不过，首先让我们看看租金上限是如何计算的。

租金上限计算 101

简而言之，新租金上限由以下四个部分计算得出:

1. 一个基本价格:下面的租金表根据的建筑年份、中央供暖系统(Sammelheizung)和/或浴室(Bad)的存在情况，确定净冷租金可能有多高。

柏林租金表，来源:柏林体育场

2。现代设备因素:对于配有现代家具的公寓，如果至少具备以下三个特征，价格将增加 1.00 欧元:

• 没有门槛就能到达的电梯
• 安装厨房
• 优质卫生设备
• 绝大多数生活空间都采用高品质地板
• 能耗特征值小于 120 千瓦时/(米·年)

3。a 地段溢价/扣除:适用于 a …

• …简单住宅区，在计算租金上限时，考虑从租金表中的相关租金中扣除 0.28 欧元。
• … 中等住宅区扣 0.09 欧元
• …良好的住宅区将收取 0.74 欧元的附加费。

颇具讽刺意味的是，位置分类至今仍未发布。

4。单人或双人家庭住宅:如果居住空间位于不超过两套公寓的建筑中，租金上限增加百分之十的附加费。

如果你把这四个因素加起来，你就得到租金上限。但是，只有满足以下标准，租金才算过高:

考虑到上述四个因素，如果租金比租金表中的相关租金上限高出 20%以上，则租金过高。

如果你在这一点上迷失了，住在柏林，并相当关心你目前是否为你在柏林的公寓支付了太多的费用，试试这个很酷的 计算器 (德语)，看看你是否更好地理解了计算。

从 256 个 PDF 页面中提取位置评级

到目前为止，最具挑战性的部分是为尚未发布的位置分类找到代理。在在线计算器中，我看到 2019 年的柏林租金指数被用作代理，所以我遵循了同样的方法。

然而,这个项目最大的挑战是,这些信息是以 PDF 格式发布的，与我实际需要的格式相差甚远。在 tabula 包的帮助下，我能够将 256 个 PDF 页面转化为柏林每条街道的 270，068 行位置评级。

最后，合并两个来源中拼写略有不同的街道名称，用fuzzywuzzy包变得简单多了。尽管计算量很大，但比任何可以想象的正则表达式模式都要容易得多。

我对租金上限计算的保守假设

在我的计算中，我采用了以下保守假设来计算每平方米的租金上限:

• 基准表(1) 中相应建造年份的最高价格，假设所有公寓都有中央供暖系统和浴室
• 假设所有的公寓都有现代设备，那么它们至少符合现代家具的三个标准
• 2019 年发布的租金指数 PDF 文档是位置评级(3)的一个很好的近似值
• 所有的公寓都是非独栋住宅，因为我只租了几套公寓

下面提供的信息和分析的正确性和完整性的免责声明:虽然我非常小心地进行了这个项目，但是我对下面提供的结果的正确性和完整性不承担任何责任。

第 3 部分:分析结果

从大约 4k 个搜索到的房源中，有 1687 个房源(41.6%)有 2014 年之前的建造年份和地址信息，以便计算租金上限。

令人震惊的是，在 1687 个房源样本中，有四分之三的分析房源价格高于允许的租金上限。

在 ImmobilienScout 24 网站上，四分之三的分析租赁房源都超过了租金上限。

如果所有这些公寓都以当前的非法价格出租，所有租户每月将比根据新法律多支付 463，059.79€:

数据集中所有非法定价房源的租金构成。

在整个数据集中(信息充足的房源)，月平均冷租为 15.12€/平方米。根据新的法律，这一平均值将降低 39%，至平均 9.21€/平方米。

仔细看看每平方米的冷租金超出新租金上限多少就会发现，例如1272 个房源中有 386 个在 0.50€到 2.49€之间的价格过高。

仔细观察不同地区的价格变化，可以发现中部地区，如 Mitte 或 Tiergarten，与更偏远的地区，如 Hellersdorf 或 Marzahn 相比，平均价格下降幅度更大。

当前平均价格和新租金上限之间的租金比较。

从当前冷租金/平方米到新计算的租金上限/平方米的百分比变化

最后，在我的 1272 套高价公寓的小样本中，我看了看谁在 ImmibolienScout24 上发布了最多的房源。不出所料，许多较大的房地产公司名列榜首。然后，我计算了他们目前的平均非法价格/平方米，并与我计算的平均租金上限进行比较，以找出他们对所有房源的平均超额收费。结果如下所示，Berlin Haus Verwaltung GmbH以 29 个房源位居榜首，平均收费10.60€/平方米，高于新租金上限允许的价格。

所有房地产公司的比较，以及他们在新租金上限下的超额收费。

最后，我想展示一个具体的 的例子 ，把我们带回到这篇博文的开头，我们从舍内贝格一个拥挤的公寓开始。过滤我关于租金超额价格最高的舍内贝格的数据集，发现在新法律下，人们每月可以节省 406.93€，将租金从 650.00€减少到 243.07€。

舍内贝格公寓租金构成示例

为了再次检查我的结果，我把数据输入在线计算器，得到了同样的结果。

来源:https://www . mietendeckelrechner . de

我希望你喜欢这篇博文。如果你目前住在柏林，想知道你是否为你的房子付了太多钱，免费看看这个 整洁的计算器 。

如果我有更多的时间，我可能会自己开发一个小的网络应用，任何人都可以类似地发布一个在线房源的链接和自动计算租金是否超出法律规定。

项目开始一年:佐治亚理工学院 OMSA 分校 vs 加州大学伯克利分校 MIDS 分校

原文：https://towardsdatascience.com/1-year-into-the-program-georgia-tech-omsa-vs-uc-berkeley-mids-c1675356d531?source=collection_archive---------6-----------------------

哪项投资值得你花费时间和金钱？

第一轮。战斗！(图片由作者提供)

我正与我的好朋友和前同事 John Lee 合作，将我们在一年后的经历与两个不同的数据科学/分析在线硕士项目进行比较。

我们将这篇文章分成 3 个部分:1)分享一些关于我们自己的信息，2)在 2 分钟中总结 2 个项目，以及 3)回答 10 个关于我们现在了解的项目的问题。

关于你的参赛者

2019 年秋季同时开学，约翰报名参加了加州大学伯克利分校数据科学硕士(MIDS) 项目，而我报名参加了佐治亚理工在线分析科学硕士(OMSA) 项目。

为了搭建舞台…

• 我们的年龄(28-30 岁)和人生阶段(与不同城市的配偶结婚，没有孩子)非常相似。
• 我们俩有着相似的职业道路(之前是环境工程专业的本科生，后来成为暖通空调/能源效率专业的机械工程师)。在某个时候，我们是两个不同组织的同事。我们有大约 6-7 年的工作经验。
• 我们都在日常工作之外兼职学习(不是数据科学家)。
• 开始这个项目时，我们都没有什么编程或数据科学经验。
• 我们都完成了项目中的大部分基础课程。

为什么这些相似之处是相关的？这证明了我们经验中偏见的一些背景。

两分钟之内，一年的项目看起来像什么？

我们认为“项目一年”相当于两个学期(秋季和春季)。虽然，严格来说，MIDS 每年有三个学期。MIDS 需要暑期班，但 OMSA 不需要。

免责声明:请记住，你应该参考官方学校的网站(盖茨 OMSA ， UCB MIDS )获取最新信息。

盖茨 OMSA

选修的课程:12 门课程中的 3 门

a.ISYE 6501 —分析建模入门(难度:3/5，平均时数/周:10–15)
b . MGT 8803—商业分析入门
(难度:2/5，平均时数/周:5–10)
c . CSE 6040—数据分析计算入门
(难度:3/5，平均时数/周:10–15)

还有两门课程被认为是 OMSA 学生“必读”课程清单的一部分:d . MGT 6203-商业数据分析，和 e. CSE 6262 数据可视化和分析。

期限:您有最多 6 年的时间来完成该计划。每学期最多可以上 2 节课(如果想上 3+节课，联系项目)。我发现每学期 1 节课最适合我的工作生活平衡。如果你需要选择退出一个学期(秋季或春季)，你需要联系该计划。

费用: (3 个班)(3 个单位/班)(＄275/单位)+(＄304 校园费/学期)* 2 个学期= 3083 美元。

资源:面向 GT 学生的典型在线资源工具(图书馆、项目、技术折扣等)。)、 Slack 频道(需要 gatech.edu 的邮箱地址或者给 Slack 的主人)、 Reddit

录取率:校内版的录取率更低。OMSA 录取率在 2017 年约为 24–27%，在 2019 年移至~ 70%(more GaTech stat)。

社区规模:2019-2020 年约有 ~2.8k 在读学生。截至 2020 年 5 月，我们在 OMSA 研究 Slack 频道和 Reddit 上大约有 3.7k。

加入计划前的准备:我考了 UCSD edX Python 的数据科学，交了 350 美金的验证证书。我还兼职做了一些项目。项目+ edX 课程可能总计约 80-100 小时。

加州大学伯克利分校 MIDS 分校

参加的课程:9 门课程中的 4 门

a.W200 —数据科学的 Python 基础
(难度:3/5，平均小时/周:18)
b. W201 —数据和分析的研究设计应用
(难度:2/5，平均小时/周:10)
c. W203 —数据科学的统计学
(难度:4/5，平均小时/周:20)
d. W205 —数据工程基础
(难度:3/5，平均小时/周:8)

还有一门额外的基础课:e .应用机器学习。点击查看课程列表。

持续时间: MIDS 要求夏季学期作为最长 8 个学期(包括夏季学期)的一部分才能毕业。MIDS 允许学生因紧急情况而休学一学期。

费用: (4 个班)* (3 个单位/班)(2573 美元/单位)+(728.50 美元校园费/学期) 2 个学期+ $95 (1 次)= 32428 美元。(官方网站)

资源:任何伯克利学生都可以使用的典型在线工具(图书馆、项目、技术折扣等)。)、WeWork Access(超级酷)、Slack Channel(一旦被该计划接受)、Zoom、通常每年 3 次的面对面会议(但是，学生只需参加一次，500 美元/注册+差旅费)

录取率:不知道。一份 2018 年 MIDS 项目状态报告披露了一些数字，例如该项目每年接受约 150 名学生，目标是增加到 450 名。

社区规模:截止 2020 年 5 月，我们的 Slack 频道约有 880 名会员，官方学堂资讯频道有 2.5k。一旦你被该计划接受，你将需要 ischool.bekeley.edu 帐户加入。

加入计划前的准备:我上了数据科学基础、Python 编程、计算机科学导论、算法导论等在线课程。除了准备 GRE 考试(不再需要)，个人准备的总时间大约是 200 小时。

1 年后我们学到的 10 件事

完成了秋季和春季学期后，我们对各自项目的理解肯定比最初申请时更加清晰。

1.课程如何“体验”？

• 盖茨 OMSA: 班级规模从每班 400 名学生到超过 1000 名学生不等(如果算上 Edx micro master/验证过的学生)。在基础课程之后，这个数字可能会更低。Piazza(官方课程论坛)有时很难跟进每个帖子，但幸运的是，GaTech 和 Edx 学生有单独的论坛。讲座是预先录制好的。成绩在很大程度上基于考试(理解这一点有一些变化)。总的来说，我认为这类似于我在大学时的传统课堂经历。
• 加州大学伯克利分校 MIDS 分校: 班级规模低于 20 人/班。讲座正在现场直播并录制。成绩很大程度上基于项目。

2.你每周花多少时间？

• 盖茨 OMSA : OMScentral 是一个很棒的班级复习网站，在这里你可以更广泛地了解时间承诺和难度因班级而异。就我个人而言，我接近大多数课程的平均水平，平均每周 10-15 小时。
• 加州大学伯克利分校 MIDS 分校:课堂讨论主要在 Slack 上进行。我平均每周花大约 15 个小时来阅读至少 50%的指定阅读材料。

3.关于这个项目，我们最惊讶的是什么？

• 盖茨 OMSA :绝对有一门【艺术】****【科学】一样多的分析学。另外，并不是所有广告的课程每学期都有，尤其是计算方向。你也不能参加 OMSCS 的课程，除非它们是通过 OMSA 项目提供的，这个项目可能每个学期都有变化。
• 加州大学伯克利分校 MIDS 分校:我很惊讶同学们是如何做到全职工作和管理工作量的。这个在线项目也比我预期的要好很多。首先，我认为在线课程与 Udemy 上的典型在线课程没有太大区别，在 Udemy 上，你可以观看讲座，做一些作业(不太关心质量)。然而，现场会议和与同学在项目上的合作会激发你的积极性。此外，与他人一起努力完成工作比独自上课教会你更多，因为讨论的是你从未想过的问题/话题。

4.你能应用你学到的东西吗？

• 盖茨 OMSA:我能够比我预期的更多地应用我所学到的东西。例如，CSE 6040 使我能够在解析 pdf 文件时应用 regex。MGT 8803 帮助我理解了会计和预算中支持我的经理角色的财务术语。ISYE 6501 让我准备好不断思考如何将机器学习方法应用于实际问题。
• 加州大学伯克利分校 MIDS 分校:我的几个同学合作对新冠肺炎数据集进行了探索性分析。统计学课程(W203)教会了我不要盲目相信任何研究。你真的要看看它的方法，自己决定是否有假阳性或假阴性。

5.你最喜欢这个节目的哪一点？

• 盖特奇·OMSA:我很高兴我接触到了很多基础统计学和机器学习理论。这很重要，因为我可以理解数学证明和论文。我对理解这些材料更有信心，并有动力去寻找潜在的应用。我真的很喜欢活跃的 slack 频道，也喜欢和我当前职业领域之外的人联系。
• 加州大学伯克利分校 MIDS 分校:作为这个项目的一部分，我真正感激的是在使用数据处理和从数据中获取价值方面获得了信心。从我开始这个项目到现在总共有 180 个。我喜欢学习是渐进的，你学习建立你的环境，学习概念，然后应用到一个项目中。

6.你最不喜欢这个节目的哪一点？

• 盖特奇·OMSA:有时候会让人感到孤立。
• 加州大学柏克莱分校 MIDS 分校:学费高昂。

7.到目前为止，你对你参加的课程和/或课程的整体质量感觉如何？

• 盖茨 OMSA:只要你投入工作，基础课程对初学者来说是友好的。我确实从我上的每一堂课中获益匪浅。另一方面，我确实认为，在以前的学生做了大量的评论之后，项目课程可以得到改进。由于可用性和顺序设计，我很难选择课程。你必须四处打听，才能知道先上哪门课是个好主意。
• 加州大学伯克利分校 MIDS 分校:基础课程对于数据科学领域的初学者是可行的。但我总是遇到一些同学(他们知道得更多)，让我觉得我不应该在这里(冒名顶替综合症)。例如，我已经按照指示干净、清晰地完成了一个数据分析项目的数据流。提交后，另一名同学超越并分享了他们的相同项目，但相反，他们创建了一个攻击僵尸的游戏来生成流数据。看到其他学生所做的真的激励我去尝试更困难的任务。

8.如果时光能够倒流，你还会选择这个节目吗？

• 盖茨 OMSA :佐治亚理工学院计算机科学在线硕士(OMSCS)是一个非常受欢迎的“哥哥”在线项目。事后看来，我认为我应该选择 OMSCS，因为它更符合我的个人目标，并且在我的舒适区之外。例如，如果你想成为一名机器学习工程师或更多地参与生产管道，Reddit 上的意见建议 OMSCS 可能是一条更好的道路，因为你为开发管道做了更好的准备。我有点担心我将来不会被更认真地对待一个更技术性的角色。尽管如此，我真的很喜欢我正在学习的东西，并计划坚持这个项目。
• 加州大学伯克利分校 MIDS 分校:是的。我仍然不知道我是否更喜欢其他节目，因为我不知道其他节目会怎么样。无论如何，我很自豪也很高兴成为这个项目的一部分。它非常适合我，一个不知道从哪里开始学习数据科学的人。

9.你的项目的价值因素是什么？

• 盖茨 OMSA :物有所值的因素肯定是负担能力和高声誉的学校。有些课程很有挑战性(20 多小时/周)，有些则更灵活(< 20 小时/周)。如果你有策略地选择课程，如果这是你的目标，你可以更快地完成课程(范围从 1200 小时到 2000 小时)。这是一个混合了商业课程的跨学科项目，这可能会给某些雇主增加加分，以资助你的高级学位。
• 加州大学伯克利分校 MIDS 分校:伯克利 MIDS 分校绝对拥有强大的网络，一个积极上进的同龄人社区，以及在美国西海岸广为人知的名校。虽然除了与课程相关的材料，我还没有与我的网络讨论过其他内容，但我接触过的一些同学都在英伟达(Nvidia)、方(FANG)和其他硅科技公司工作。拥有这样的班级群体的好处是真正看到了他们对家庭作业问题的看法，他们的工作场所会如何处理类似的问题，以及他们在该领域的知识。

10.你对每个项目的潜在学生有什么建议？

• 盖茨 OMSA : 垃圾进=垃圾出。从数据分析到你从这个项目中得到的东西，一切都是如此。我推荐所有潜在的学生阅读这个 Reddit 的常见问题指南。省省吧。预订它。多读几遍。认真对待先决条件 ( 编码、微积分、、 prob/stat 、线性代数)用 Jupyter 笔记本(或任何你喜欢的工具)尝试简单的项目( 1 、 2 、 3 )会帮助你在开始时不那么沮丧。如果你在考虑申请 OMSA 大学，这里是我的博客，告诉你如何申请。****
• 加州大学伯克利分校 MIDS 分校利用你的人际网络。无论是在课堂上还是在职业上，你都可以从他们那里学到很多东西。许多人都是来自加州湾区和科技公司的高水平专业人士。对待你的项目，就好像它们会在你的作品集里展示给招聘经理看一样。不要担心成绩，如果你努力，成绩就会随之而来。更早地进入简单的 DS 项目。学习一些 Linux 命令和 git。一旦开始上课，就会变得很忙。

每个项目都提供不同的体验。不管它们是否适合你，最终还是要由你自己来决定。

如果你正在考虑选择哪所学校，我们希望这能为你的研究和决策过程提供有价值的见解。如果你觉得这很有帮助，或者希望看到更多关于这些在线硕士项目的问题，请鼓掌！😃

请随时在社交媒体上与我们联系:

跟随容闳上 中。推特。 Github 。

在 Instagram 上关注约翰。领英。 Github。

10.000 小时的数据科学|熟练掌握

原文：https://towardsdatascience.com/10-000-hours-in-data-science-gaining-proficiency-440387e723c1?source=collection_archive---------41-----------------------

从数据新手到专业人士的路

反数字时钟，布拉格犹太市政厅时钟-理查德·迈克尔(版权所有)。

有一种观点认为，练习一件事超过 10000 小时(10000 小时)就能让你对这门学科达到足够的熟练程度。这个概念是基于 M. Gladwell 的《T2》一书《局外人》。所说的 10k 小时是你花在练习或学习一门学科上的时间，直到你掌握得很牢固，可以被称为精通。虽然这个小时数有些随意，但我们将看看如何利用这些小时来精通数据科学领域。

想象一下，这是你在数据学徒之旅中的学习预算。如果我从零开始，这就是我如何花这一万个小时成为一名熟练的数据科学家。

核心模块

数学与 Stat istics: 基础统计学、贝叶斯统计、数据分析导论、一些概率论、基础分析与微积分。
数据科学家的主要工作是从问题领域提供数据洞察。牢固掌握数学基础是必不可少的。你可以从现有的大学课程和 Coursera 课程中找到很多优秀的内容。这是开始您的旅程并初步了解统计工作原理的好方法。不过，基础课程是必不可少的，请用真实交易挑战自己。假设是 2500 小时(312 天 8 小时的工作时间)。

分析/统计语言和模块 : R，Python(熊猫)，Julia，SAS 。这是你的面包和黄油，可以被视为你统计教育的一部分。这就是边做边学。阅读一本关于 R 的奥莱利的书只会让你到此为止。加载一个精选的数据集，一些挑战和解决一些问题。统计语言存在一个范围。因此，如果你接近科学计算，你可能会考虑朱莉娅。仅有统计分析的另一端是 SAS。有些人认为 R 可以两者兼得。
1000 小时(125 天 8 小时工作制)

多用途编程语言 : Python，Go，Java，Bash，Perl，C++ ，…
这在很大程度上取决于您每天面对的系统。如果你刚开始，选择一门语言并坚持下去。一旦你学会了这个概念，你就会更容易学会不同的语言。我本人在日常工作中非常依赖于 Python 和 Bash 的组合。其他任务需要彻底理解优秀的旧 Java，甚至是 Perl。
2000h (250 天 8 小时工作制)。

数据库技术 : {T-，My-，U-}SQL，PostgreSQL，MongoDB，… 。
关系型或非关系型数据库是您在生产环境中必须使用的一些系统。了解你的数据是如何存储的，查询是如何运行的，如何撤销一个交易是很有用的。对于以后的工作，你的数据来源可能会有很大的不同，最好有一个基本的了解。
750 小时(94 天 8 小时工作制)

操作系统 : Windows，Linux，MacOS。无论你的工作环境如何:掌握它！知道来龙去脉。这一次你可能需要安装一些非常奇怪的库来解决一个特定的问题(真实故事)。知道东西在哪里以及它们为什么在那里有很大的帮助。了解什么是 SSH 连接，以及如何在不同的系统上运行分析。不在本地机器上运行分析将会在未来的某个时候发生。500 小时(62 天 8 小时工作制)。

ETL/ELT 系统: 这是编程语言、数据库技术和操作系统的混合体。像 Spark 、 Hadoop 、 Hive 这样的框架为集群计算平台上的数据存储和分析提供了先进的手段。一些公司可能依赖于不同的技术栈，如微软 Azure Systems、谷歌云或 AWS 解决方案。这与数据库技术密切相关，可能已经要求对高级编程语言(如 Java 或 Python)有很好的理解。也有初学者系统，像 KNIME 让你的脚沾水。400 (50 天 8 小时)

你的问题域 :这可能是 Fin-Tech，Bio-Tech，Business Analytics。你应该熟悉你的工作领域。你做的是研发吗？您是否在可视化业务流程和客户行为？不同的领域需要不同的见解。您的数据必须对您有意义，并且您应该能够看到模型输出是在有效范围内还是完全偏离。花绝对*最少 350 小时在你的问题领域。我建议更多。多得多。你可以决定你是想成为万金油还是你所在领域的专家。

350 小时(44 天 8 小时)*

细心的读者会发现，到目前为止，这总共才 7500 个小时。我们现在有一个基础，你可能想从这里进入某个方向。

不同的数据交易——你的个人方向

回到过去，黑暗蒙昧的时代，我们有行会。处理数据的领域也有不同的行业。不同类型的商人解决不同的问题，在这个主题上有不同的文章。
以下是这些行业在要求上的不同之处:

1. 数据科学家:你做统计和分析，你推出解决方案，部署回答问题和提供见解的平台。干净利落。升级你的统计游戏:+ 200h。也许是一点我们称之为统计学习的 ML+100h 和某种类型的多用途语言，比如 Python、Perl 或 Bash。
2. 数据工程师:你关心数据。您构建系统，使数据科学家能够有效地工作，并为分析师提供日常面包。你的重点在于底层系统。系统+500 小时，ETL/ELT 系统+200 小时，数据库和编程语言+200 小时。你甚至可以不要过多地参与统计部分(500 小时的纯统计和理论)。
3. 机器学习工程师:你实现了让奇迹发生的模型。你需要所有的统计洞察力，还需要精通所有的 ML-
   +300 小时 ML，+200 小时 Stats。你还应该精通一种高级编程语言，这种语言首先使得实现 ML 模型成为可能。
4. 分析师:你从系统中获取数据，让它变得漂亮，便于管理层报告。您需要知道在您的问题领域中什么是重要的，在问题案例中+200h，在数据库系统中+100h。您每天都需要您的 SQL。尽管有各种各样的分析师工作。所以通知自己，继续学习你认为必要的东西。

数据科学家的时间和经验与分析师的工作相比。

ML 工程师相对于数据工程师的时间和经验。
Math/Stats = Mathematics and Statistics，包括您使用 r 等 stat 语言的工作。
Systems =设置和维护数据系统(例如 ETL/ELT、GC、AWS 等)
DBs =数据库系统(关系型、非关系型)
SWE =软件工程(Python、Perl、Java、Scala、Go、JavaScript 等)
Exp。领域=问题领域的经验。花在这个话题上的时间。

上面的数字说明了典型的职业以及在每个领域可以投入多少时间和精力。这些只是简单的建议，因人而异。例如，我们示例中的数据工程师也可以称为处理大量数据的软件工程师，与软件开发相比，另一个工程师需要更多的数据库工作经验。

就像生活中的一切一样，界限是模糊的。有时数据科学家也做 ML 工程师的工作，反之亦然。请记住，10k 预算是你的入门，给你一个进入该领域的方向，而不是你的专业。因此，你拥有世界上所有的自由，最终去攻读你一直想要的超心理学博士学位。

一万小时是多少工作

一万小时是一段很长的时间，如果你要工作一年，那就是每天 27 小时，这对普通人来说不太可行。
因此，更好的 3 年约 9 小时的工作可能更适合。
如果你在兼职学习，并希望在未来的某个时候换一份工作，那么再过几年你可能就万事俱备了。重要的是要和它保持一致。几年后，每天几个小时的高质量锻炼会让你受益匪浅。

关键要素

没关系，如果你在大学、在学校、在研讨会或在家里花了一万个小时。你必须展示你的作品。一个学位，如果做得正确的话，可以显示这一点——但这并不是必须的。它是关于通过解决问题获得领域经验和概念的熟练程度。
解决一个问题，并把它放入文件夹、你的简历或你的 GitHub 库。

对你最合适的。人们雇佣你是因为你解决问题的能力。不是为了你两年前在那个项目上得到的。你可能会说这是一个非常酷的项目。

太好了！如果你对宇宙有所贡献，你应该告诉人们。

这是一个漫长的旅程，如果你喜欢你所做的事情，它就是值得的。一路上你会学到很多东西。

简短的免责声明:请始终记住，在野外有不同领域的数据科学相关工作。每项工作都有其特定的目的，需要不同的工具。每个雇主可能会寻找不同的技能组合。祝你一路顺风！

可视化的 10+1 交叉验证技术

原文：https://towardsdatascience.com/10-1-cross-validation-techniques-visualized-9013095fb68e?source=collection_archive---------41-----------------------

在本文中，我们将:

• 探索 11 种交叉验证技术。
• 可视化****培训和验证样品在中各折。这是立即理解特定 CV 技术如何工作的最佳方式。
• 绘制每次验证中的分布与实际测试的分布。

我们有一个数据集。它被分成两部分。一个叫做训练，另一个叫做测试。除了一列之外，它们的列数相同。培训也有目标。

我们的任务是在训练数据上拟合模型，在测试数据上预测未知目标。

我们不能仅仅满足于所有的训练数据，并期望测试一切顺利。我们需要验证我们的模型捕获了训练数据中的隐藏模式，是稳定的，不会过度拟合，并且在未知数据上概括得很好。

初始数据集分为训练和测试。培训用于交叉验证。来源:向数据科学，通过阿迪·布朗什坦

这就是交叉验证发挥作用的地方。

我们中的许多人都熟悉并使用最著名的交叉验证技术，其中训练集被分成 K 个部分，在 K 次迭代的每一次中，不同的部分被用作测试集(称为验证集)，而剩余的集被用于训练。在每次迭代中，进行预测，最后的预测是它们的平均值。

十重交叉验证。来源:牛等人，转自 researchgate

在我们开始之前，先说几句:这个数据集来自 M5 预测准确性竞赛。任务是尽可能精确地预测沃尔玛在美国销售的各种产品的单位销售(需求)。在这个演示中，我将使用这些数据中的一部分。这个数据是时间序列的。这里将展示的一半技术在时间序列数据的参考书目中没有被推荐(尽管在这里它们表现得相当好)。

我选择尽可能保持文章的整洁，不在这里包含代码。

你在这里看到的所有东西的代码都在我的 Github 上。

好了，我们走吧！

首先快速绘制数据集的目标。测试集正好是一年。

1.k 倍交叉验证—无洗牌

在参考文献中，已知并且不建议对时间序列数据使用这种类型的 CV，因为它忽略了数据中的一致性。记住实际的测试数据是未来的一个时期。

分布图用橙色显示了每次迭代验证的 5 个分布，用蓝色显示了实际样本外测试数据的分布。

CV mean score: 		   23.64240, std: 1.8744.
Out of sample (test) score: 20.455980

2.k 倍交叉验证—洗牌

五分之一的数据也是每次迭代中的验证集，但这次它随机分布在整个数据中。和前面一样，在一次迭代中用作验证的每个样本永远不会在另一次迭代中用作验证。

CV mean score: 		   22.59125, std: 1.7155.
Out of sample (test) score: 20.526280

3.随机排列交叉验证

ShuffleSplit 将在每次迭代期间随机采样整个数据集，以生成训练集和验证集。test_size 和 train_size 参数控制每次迭代的验证和训练集应该有多大。因为我们在每次迭代中从整个数据集进行采样，所以在一次迭代中选择的值可以在另一次迭代中再次选择。

由于一些数据不包括在训练中，这种方法比正常的 k 倍交叉验证更快。

CV mean score: 		   22.47461, std: 2.2129.
Out of sample (test) score: 20.630861

4.分层 K 倍交叉验证—无洗牌

类似于正常的 K 折叠，但是每个折叠包含每个目标的大约相同百分比的样本。最好与分类一起使用，而不是回归。

CV mean score: 		   22.57824, std: 2.7578.
Out of sample (test) score: 20.532799

5.分层 K-折叠交叉验证——带洗牌

对于每个目标，折叠包含大约相同百分比的样本，但是首先，数据被打乱。

CV mean score: 		   22.51464, std: 3.0626.
Out of sample (test) score: 20.585582

6.分组 K 倍

我们可以从数据集的另一列定义组。确保同一组不在训练集和验证集中。

CV mean score: 		   23.21066, std: 2.7148.
Out of sample (test) score: 20.550477

在前一个示例中，我们使用 year 作为组，在下一个示例中使用 months 作为组。

CV mean score: 		   22.32342, std: 3.9974.
Out of sample (test) score: 20.481986

7.成组的 K 倍——去掉一个组

在每次迭代中，用除一组以外的所有组的样本训练模型。在以月为组的情况下，执行 12 次迭代。

CV mean score: 		   22.48503, std: 5.6201.
Out of sample (test) score: 20.468222

8.随机排列的分组 K-折叠

这是两种方法的结合。我们定义组，并在每次迭代期间随机采样整个数据集，以生成训练集和验证集。

CV mean score: 		   21.58829, std: 2.5721.
Out of sample (test) score: 20.365067

9.时间序列分割

建议将以下方法用于时间序列数据。

在时间序列分割中，训练集总是被分成两部分。第一部分始终是训练集，而后一部分是验证集。验证集的长度保持不变，而训练集随着每次迭代变得越来越大。

CV mean score: 		   24.32591, std: 2.0312.
Out of sample (test) score: 20.999613

10.阻止时间序列分割

训练集和验证集在每次迭代中都是唯一。没有值被使用两次。训练集总是在验证之前。由于在更少的样本中训练，它也比其他交叉验证方法更快。

CV mean score: 		   22.57081, std: 6.0085.
Out of sample (test) score: 19.896889

奖金:11。清除的交叉验证

在每次迭代中，在训练集之前和之后，我们移除一些样本。

CV mean score: 		   23.64854, std: 1.9370.
Out of sample (test) score: 20.589597

将禁运设置为大于 0 的值，我们将在验证集之后移除额外的样本。

CV mean score: 		   23.87267, std: 1.7693.
Out of sample (test) score: 20.414387

最后，让我们看看每种技术在交叉验证均方根误差和实际测试 RMSE 上的表现。

我把这个留给你作为思考的食粮，来决定哪种技术是最好的。

我会选择随机排列的 K 倍群。

参考资料:

https://hub . packtpub . com/cross-validation-strategies-for-time-series-forecasting-tutorial/

https://sci kit-learn . org/stable/modules/cross _ validation . html

https://www . Wiley . com/en-us/Advances+in+金融+机器+学习-p-9781119482086

不熟悉 Python？每个 Python 程序员都应该知道的 10 个缩写

原文：https://towardsdatascience.com/10-acronyms-that-every-python-programmer-should-know-58008635b5fe?source=collection_archive---------13-----------------------

阿希什·阿查里亚在 Unsplash 上拍摄的照片

编程原则、规则和一些有趣的事实

介绍

Python 已经成为很多开始学习编码的人的编程语言选择。它有非常直观的语法和支持动态类型的灵活性。此外，它是一种解释语言，这使得使用交互式控制台进行学习成为可能。基本上，你可以只使用一个命令行工具，比如 Mac 中的 Terminal，来开始 Python 的学习，因为现在 macOS 都附带了 Python。

当你学习 Python 时，你会逐渐熟悉它的数据结构、控制流、类、函数和其他基本的东西。我发现有趣的一件事是 Python 中的各种首字母缩写词，我们不时会遇到。本文将回顾十个这样的缩略语。其中一些是通用编程原则，而其他一些则更具体地针对 Python 编码。然而，它们中的每一个都有自己有用和/或有趣的方面。

1.面向对象编程

我们应该知道的第一个缩写是 OOP——面向对象编程，这是 Python 的设计基础。我们知道编程本身是关于编码的，但是程序本身应该是关于数据的。我们的程序需要输入数据、处理数据和输出数据。请注意，这里讨论的数据是最广义的，可以包括表格数据、字符串、用户动作(例如，点击按钮)、图像和任何形式的具有信息的数据。我们代码的工作就是处理这些不同形式的数据，并以期望的方式呈现它们。

为了完成我们的工作，我们需要能够处理这些数据的代码，现代编程语言(包括 Python)中一个常见的设计模式是采用 OOP 范例。这个想法非常直观——我们用特定的对象包装我们的数据。更具体地，对象可以保存数据(例如，属性)并且可以操作数据(例如，方法)。例如，如果我们开发一个赛车游戏。我们可以构建汽车对象，每个对象都有特定的属性，比如颜色、最大速度和重量。此外，这些对象可以有操作，如刹车和加速。这些数据的逻辑组织以汽车为中心。

让我们看一个 Python 中的具体例子。我们可以使用内置的 str 类包装字符串数据，这不仅允许我们使用字符串对象传递字符串数据，还允许我们改变字符串的表示方式。下面来看一个很琐碎的例子。

字符串数据的操作

2.干(不重复)

干的原则(不要重复自己)是每个程序员都应该实践的最根本的规则之一。这个想法很简单— 如果你注意到你的代码中有任何重复，这是一个信号，你需要进行一些重构,以尽可能减少重复代码或完全删除任何重复。以下伪代码向您展示了应用 DRY 原则对一些代码进行的重构。

不要重复你自己

代码重构的另一个可能场景是，您发现自己要处理一堆具有相同结构的数据。与其使用一系列字典、列表或元组来存储每个个体的数据，不如考虑用自己的类来处理这些数据。这不仅仅是为了让你的代码不容易出错，也是为了长期的可维护性。

3.PIP(Python 的包安装程序)

Python 受欢迎的最重要原因可能是它的开源特性，这产生了大量的免费 Python 包。根据维基百科，在 Python 包索引(PyPI)中有超过 235，000 个包被编入索引。我们可以使用 pip 工具从 PyPI 安装任何包。安装相当简单，只需要在命令或终端中输入一行代码。下面的代码片段总结了一些常见的用法。要了解更多关于 pip 工具的用法，您可以访问其官方网站这里。

PIP 使用示例

4.LEGB(本地、封闭、全局和内置)

LEGB 规则是指 Python 中的变量查找顺序，如下图所示。具体来说，当解释器试图解析变量时，Python 有四层作用域——理解哪些值绑定到变量。首先从局部作用域开始，它可以是一个函数或者一个类。如果解释器为变量找到了相应的界限值，它将停止查找并使用具有该特定值的变量。

可变分辨率规则

否则，它将在更高的层次上查找— 封闭范围。封闭范围仅存在于函数的嵌套结构中。具体来说，当一个函数在另一个函数中声明时，我们称内部函数为内部函数，外部函数为外部函数。当解释器试图解析内部函数范围内使用的变量时，如果它不能在局部范围内解析，它将转到封闭范围，即外部函数的局部范围。

如果它仍然不能解析封闭范围内的变量，它将转到全局范围。全局范围通常是模块级的，通常是一个独立的 Python 文件。值得注意的是，当您将包导入到当前文件中时，导入的函数和类也将成为全局范围的一部分。内置作用域是在解释器启动时加载的函数、类和其他模块，以使这些最基本的对象始终可用(如print和其他内置函数)。

5.MRO(方法解析顺序)

方法解析顺序表示Python 或编程语言一般如何解析方法或属性。与上面讨论的 LEGB 规则不同，LEGB 规则关注的是解析变量，而 MRO 关注的是对象以及如何解析其方法调用或检索特定属性。MRO 主要是在多重继承的上下文中讨论的——从多个类(即超类)和/或多层继承继承的类(即子类)。因为子类和超类共享一些可能不同实现的公共方法，Python 解释器需要一种机制来确定在特定调用中应该使用哪个方法或属性，这是 MRO 负责的。下面的代码片段显示了一个示意性示例。

方法解析顺序

对于 W 类的实例(第 22 行)，当我们调用bingo()方法时，这个方法在它自己的类中被解析，因为它是在类中定义的(第 18–20 行)。然而，这个方法将进一步调用bin()和go()方法。以类似的方式，bin()方法在它自己的类中被解析，然而，它调用超类的bin()方法，如第 15 行所示。但是在它的直接超类(即 Y 和 Z)中，都没有实现bin()方法，因此 Python 将更上一层到超类的超类(即 X)，在那里实现并调用bin()方法。

值得注意的是，对于 W 的go()方法，它的两个超类都实现了这个方法，但是正如你所看到的，只有 Y 类中使用的实现被调用。这是因为当我们定义我们的 W 类时，继承顺序是 Y 和 Z，这将使 MRO 遵循相同的顺序。与此相关，我们可以使用特殊方法__mro__找出特定类的 MRO，如下所示。此外，为了向您展示类继承的顺序是如何重要的，我们创建了另一个类，Z 类在 Y 类之前，这改变了 W_ class 的 MRO。

特殊方法 mro

6.& 7.EAFP(请求原谅比请求允许容易)& LBYL(三思而后行)

EAFP(请求原谅比请求许可容易)编码风格是 Python 热衷于遵循的。因为 Python 是一种动态编程语言，所以在运行时实现以及修改现有的实例对象、类甚至模块都是可能的。因此，建议您在编写代码时假设特定的属性或功能是可用的。换句话说，这个想法是如果一些代码潜在地有特殊的问题，让问题浮出水面并相应地解决它们。通过应用 EAFP 规则，如果我们想更进一步，我们可以简单地使用 try…except 语句编写特定的代码来处理代码可能引发的潜在异常。基本上，我们的想法是，当一些意想不到的事情发生时，我们可以事后处理。

与 EAFP 原则相反，还有另一种编码风格叫做 LBYL，代表三思而后行。使用这种编码风格，程序员被期望在某些代码运行之前排除所有可能的不良情况。因此，你可以在项目中看到更多遵循 LBYL 原则的 if 语句。基本上，这种编码风格试图以特别的方式防止任何问题。

下面的代码片段向您展示了一个使用 EAFP 对 LBYL 的可能场景。使用 EAFP 编码风格，我们简单地将我们的代码和预期的可能异常封装在一个 try…except 语句中，而使用 LBYL 编码风格，我们必须使用自省方法和值检查来在划分之前验证适用的条件。正如您所看到的，EAFP 代码看起来更整洁，没有创建嵌套结构。当然，如果你愿意，你也可以在你的项目中应用 LBYL。最终项目仍将类似地工作。

EAFP 对 LBYL

8.PEP (Python 增强提案)

上一节讨论了一般的编码风格。但是最有影响力的 Python 编码风格指南之一被称为 PEP 8—Python 增强提案 # 8，由 BDFL(将在接下来讨论)和其他几个 Python 核心维护者撰写。pep 涵盖了很多东西——都与 Python 相关。你可以在官方网站找到完整的名单。这里列出了一些值得注意的，请随意阅读。

PEP 8:Python 代码样式指南
PEP 257: Docstring 约定
PEP 20:Python 之禅
PEP 498: 文字字符串插值
PEP 202: 列表理解
PEP 405: Python 虚拟环境

9.BDFL(仁慈的终身独裁者)

什么是 BDFL？当然，部分标题已经告诉你它代表什么，但是它实际上意味着什么呢？这是来自维基百科的定义。

终身仁慈的独裁者 ( BDFL )是一个给少数开源软件开发领导者的头衔，通常是项目创始人，他们在社区内的争议或争论中保留最终发言权。

虽然这个定义通常适用于开源软件开发，但它最初是在 Python 社区中使用的，作为一种指代 Python 编程语言的创造者吉多·范·罗苏姆 (GvR)的方式。在担任这个 BDFL 角色超过 20 年后，他在 2018 年卸任。如果你对 BDFL 的故事感兴趣，请在他的维基百科页面上探索更多。

10.REPL(读取-评估-打印循环)

在我看来，REPL (Read-Eval-Print 循环)是一个方便的工具，可以让学习 Python 变得如此轻松。如您所知，我们可以像使用命令或终端窗口一样简单地开始学习 Python 编码。您可以使用 pip 工具在那里安装您的软件包，如前所示。更重要的是，您可以立即编写您的第一行 Python 代码(例如，可能应该是这一行:print(“Hello World!”))，而不需要对其他编程语言可能需要的 IDE 工具进行任何配置。让我们快速拍一张它的快照。

REPL 的例子

REPL 的工作流程非常简单——读取代码，对其进行评估，并在控制台中打印评估的任何适用结果，然后一次又一次地重复这三个步骤，探索 Python 的各种特性。REPL 在标准 python 或其他常见 Python 开发工具中实现为默认模式，如 ipython，它是著名的 Python 学习和编码工具— Jupiter Notebook 的基础。

结论

Python 是一种灵活而强大的面向对象语言，由 BDFL GvR 创建。利用 PIP，我们可以很容易地管理 Python 包，并通过 REPL 在控制台中学习语言和各种包。当我们用 Python 编码时，我们希望遵循 PEP 8 中概述的风格。其他重要的编码原则包括干和 EAFP。如果你愿意，你也可以在你的代码中做一些 LBYL。LEGB 规则和 MRO 将帮助您理解如何解析变量、属性和函数，以使您的代码按预期运行。

深入挖掘:10 本高级人工智能书籍

原文：https://towardsdatascience.com/10-advanced-ai-books-for-those-who-feel-the-need-to-go-deeper-bbb7a7d1c169?source=collection_archive---------25-----------------------

获得洞察力并深入了解最先进的方法

图片来自皮克斯拜的赫尔曼·特劳布

正如你无疑发现了自己，要成为一名有效的机器学习科学家，你需要获得很多知识和经验。要在机器学习和 AI 方面起步，学习几门网络课程和入门书籍大概就够了。然而，为了变得更好，你需要更多的学习。多得多。

大多数关于人工智能最新方法的信息都包含在顶级会议上发表的论文中，如 ICML 、 NeurIPS 或 ICLR 以及 arXiv 。为了能够阅读这些论文，大多数论文需要在它们各自的领域中有深入的知识，并且(通常)需要有很深的数学理解。更重要的是，整个领域都在以惊人的速度发展。因此，不仅你必须能够阅读这些论文，而且你必须快速阅读它们并提取最重要的部分，以便能够决定其中包含的信息对你是否有用。

在这篇文章中，我收集了 10 本书，我想推荐给任何想深入了解最新技术以及更多数学和编程经验的人。总的来说，这些书对任何想在这个领域工作的人都有意义。我没有包括涵盖特定主题的书籍，如 NLP、计算机视觉或医学图像处理。文章根据特定的主题分为不同的类别。这些书中有几本也可以在网上免费获得，所以没有理由不马上开始学习更多的知识！

人工智能的数学基础

图片由皮克斯拜的 Gerd Altmann 提供

特雷弗·哈斯蒂的《统计学习的要素》

毫无疑问，您会同意，良好的统计学基础对于任何数据科学家都是极其重要的。这本书对统计学习中最重要的概念进行了全面而实际的解释。同时，你不需要成为数学专家来理解这些概念。作者涵盖了监督和非监督学习，包括支持向量机，神经网络和决策树，随机森林，套索回归等等。对我来说，这是任何标准 ML 算法的首选参考。

平装本在这里或者亚马逊上可以免费买到。

谢尔登·埃克斯勒正确地完成了线性代数

设计作为线性代数的第二课程书，这本书真正深入到线性代数的数学基础。它假设你已经理解了基本概念，而是以一种更理论化的方式来呈现这个主题。虽然为了理解深度学习领域的大多数论文，绝对没有必要非常了解线性代数，但我发现它不仅对阅读，而且对自己的研究都非常有帮助。

在亚马逊上购买这本书的精装本或平装本。

概率论:阿齐姆·克兰克的综合教程

这是一本全面而严谨的概率论书籍。当我说严格的时候，我是认真的:它是为已经有一些概率论经验的人准备的。像所有关于概率的数学课程一样，它以测度论的一章开始。然而，只有最相关的测量理论概念被涵盖。之后，这本书深入到独立性，条件概率，鞅，马尔可夫链，随机过程和随机积分的概念。由于这是一本主要面向数学家的书，所有的东西都得到了恰当的证明(尽管有些证明是作为练习留下的！)而且你得花时间去理解定理。然而，这本书也提供了大量的例子和数字，以便更好地理解。我会把它推荐给任何想从数学角度理解概率的人。

这本书在亚马逊上有精装版。

一般人工智能主题

图片由 Gerd Altmann 从 Pixabay 拍摄

《人工智能:现代方法》，斯图尔特·拉塞尔和彼得·诺维格著

这是人工智能圣经。它提供了一个非常好的领域概述，同时非常清晰和简洁，要求惊人的数学背景。这本书还设法涵盖了大量的材料:它开始谈论智能代理、搜索算法和约束满足，接着是易于阅读的逻辑介绍，最后是学习、概率推理、NLP 和机器人等主题。这最后几章是在第三次添加时才添加到书中的，我觉得它们包含的信息并没有真正与其余的内容很好地协调。然而，我可以全心全意地把这本书的其余部分推荐给任何想拓展他的人工智能视野的人。

和所有其他的书一样，这本书在亚马逊上有平装本和精装本。

深度学习，作者伊恩·古德菲勒

这本书现在已经成为深度学习的标准书籍，涵盖了非常基础的主题，如线性代数和概率以及前馈网络的介绍，以及更高级的主题，如 CNN，RNNs，正则化和自动编码器。还包括图形模型和蒙特卡罗方法的概述。

如果你刚学完一些基础的机器学习课程，想更深入的了解深度学习，我推荐这本书。

这本书可以在网上免费获得在 deeplearningbook.org。精装版在亚马逊上出售。

机器学习:概率视角

如果你在你的生活中曾经做过一门适当的机器学习课程，这本书可能已经被推荐给你了。事实上，该领域的顶尖人物之一南多·德·弗雷塔斯(Nando de Freitas)的课程(可以在 YouTube 上找到)就是基于这本书。请注意，这本书并不容易阅读，也不打算这么做:它涵盖了优化，概率，支持向量机，高斯模型，贝叶斯和频率统计，线性和逻辑回归，图形模型，期望最大化，高斯过程，变分和蒙特卡洛推理，聚类和深度学习都在一本书里(哇！).这本书的主题，以及标题中“概率”的原因，是作者倾向于贝叶斯方法。如果你认为线性回归很简单，那就看看贝叶斯线性回归这一章吧！这本书对我来说是过去几十年里对这个课题所做的所有研究的参考。它并没有像我在这里提到的其他书籍一样涵盖深度学习的主题，但它也不打算这样做。还有其他的书也是这样设计的。

再次，亚马逊提供这本书(精装本)。然而，考虑到这本书的价格，你也可能倾向于从大学图书馆借阅。

神经网络和深度学习

这是一本关于深度学习的相对较新的书。我拿起它只是为了看看它是否包含我还没有在其他地方读过的信息，因为我已经读过作者的另一本书(文本的机器学习)。男孩被我惊呆了！尤其是第一章让我耳目一新，让我重新思考整个 ML 领域。在这些章节中，Aggarwal 博士建立了支持向量机、回归、奇异值分解和其他经典 ML 算法之间的联系，并解释说这些实际上只是神经网络的特例。很有意思！这本书的其余部分致力于神经网络的基础，非常详细地解释了反向传播，正则化，CNN，RNNs 和自动编码器，同时也简要地看了最新的东西，如注意机制。

在亚马逊上可以找到精装本。

更专业的话题

图片由 Gerd Altmann 从 Pixabay 拍摄

强化学习:理查德·萨顿介绍

在我看来，每个从事 ML 工作的人至少应该知道什么是强化学习，因为它目前似乎是我们朝着通用 AI 前进的最大希望。“强化学习”涵盖了这个主题，如果不是详尽无遗(不可能)，那么至少非常广泛。这本书最大的优点是简单明了。在读这本书的时候，我从来没有感觉到作者遗漏了一些可以帮助我更好地理解这个主题的东西。阅读真的是一种享受。虽然它在某些部分变得相当数学化，但更复杂的东西总是被标记出来，如果你喜欢，你可以跳过它(尽管我会建议你从头开始)。

这本书可以在网上免费获得这里。你也可以在麻省理工学院出版社购买印刷版。

统计学中的因果推理:朱迪亚·珀尔的入门

虽然将这本书列入我的清单可能会感到奇怪，因为它涵盖了一个相当有限的主题，但我觉得它值得在这里占有一席之地，主要是因为因果推理正迅速成为人工智能的一个主要话题，朱迪亚·珀尔是首席研究员和因果推理理论的发明者(在他的许多其他成就中)。在这本书里，你会发现什么是因果推理，当然你会学到所有关于因果关系和相关性的知识。它作为因果关系领域的介绍，因此向读者提供概念而不是详尽的细节。它还包含许多例子和发人深省的问题，作为更深入思考这个问题的动力。对我来说，关于反事实的讨论特别有趣，令人耳目一新。

你可以在威利或者亚马逊上买到这本书。

高级编程知识

图片来自 Pixabay 的 Johnson Martin

流畅的 Python:清晰、简洁和有效的编程，卢西亚诺·拉马尔霍著

IMHO，每个深度学习科学家或者数据科学家都需要能够写出清晰简洁的 Python 代码。虽然设计庞大的代码架构通常不是我们工作的主要部分，但编写易于理解的算法才是。这本书真的可以帮助你发展你的 Python 技能。我在看这本书的时候发现了很多我事先不知道的 Python 特性。我几乎每天都在使用的一个概念是元类。此外，我在其他任何地方都没有找到对 Python 数据模型如此清晰的描述。如果您想让您的同事和 GitHub 追随者对您编写的优雅代码感到敬畏，请拿起这本书！

当然，亚马逊也提供这个。你也可以通过奥莱利的网站购买。

结论

有如此多的资源可以用来学习人工智能和机器学习，以至于比以往任何时候都更容易获得关于这一主题的深刻知识。我提供的书籍只是你可以使用的无数高质量材料的例子。我希望这个列表能给你一些指导，让你对外面的世界有所了解。享受阅读！

Python 编码面试前要解决的 10 个算法

原文：https://towardsdatascience.com/10-algorithms-to-solve-before-your-python-coding-interview-feb74fb9bc27?source=collection_archive---------0-----------------------

编程 | 面试 | 办公时间

在这篇文章中，我提出并分享了在 MAANG 访谈中反复出现的一些基本算法的解决方案。

由上的间隔拍摄

建议的点播课程

你们很多人联系我要有价值的资源 钉 Python 编码面试 。下面我分享几个 课程/平台 我强烈推荐练习完本帖算法后继续锻炼:

• Python 数据工程纳米学位(uda city)→优质课程如果你致力于从事数据工程的职业，
• Python 高级编码问题(StrataScratch)→我找到的准备 Python 的最佳平台& SQL 编码面试到此为止！比 LeetCode 更好更便宜。
• 用 Python 练习编码面试题(60+题) → 列表、数组、集合、字典、map()、filter()、reduce()、iterable 对象。

> > >还不是中等成员？考虑与我的 推荐链接 签约，以获得 Medium 提供的一切服务，费用低至每月 5 美元！

为什么练习算法是关键？

如果你对 Python 相对陌生，并计划开始面试顶级公司(其中包括 MAANG ),听听这个:你需要现在就开始练习算法。

不要像我刚开始解的时候那么幼稚。尽管我认为偶尔破解几个算法很有趣，但我从来没有花太多时间去练习，甚至没有花更少的时间去实现一个更快或更有效的解决方案。在我自己之间，我在想，在一天结束的时候，整天解决算法有点太乏味了，它在真实的日常工作环境中没有实际用途，从长远来看，它不会给我的口袋带来多少。

“知道如何解决算法会让你在求职过程中获得竞争优势”

嗯……我错了(至少部分错了):我仍然认为在算法上花太多时间而不关注其他技能不足以让你获得梦想中的工作，但我明白，由于复杂的问题出现在程序员的日常工作中，大公司必须找到一个标准化的流程来收集对候选人解决问题和关注细节技能的见解。这意味着，知道如何解决算法将让你在求职过程中获得竞争优势，因为即使是不太出名的公司也倾向于采用类似的评估方法。

* [## PySpark 中聚合数据的 3 种方法

PySpark 用编码示例解释基本聚合。

towardsdatascience.com](/3-ways-to-aggregate-data-in-pyspark-72209197c90)

外面有一个完整的世界

在我开始更加一致地解决算法后不久，我发现有大量的资源可供练习，学习解决它们的最有效策略，并为面试做好心理准备( 【黑客等级】 ，**leet code，coding bat和)

在练习顶级面试问题的同时，这些网站通常会按公司对算法进行分组，嵌入活跃的博客，人们可以在博客上分享他们面试经历的详细总结，有时甚至会提供模拟面试问题，作为额外收费计划的一部分。

比如 LeetCode 让你按具体公司、按频率筛选顶级面试问题。您还可以选择自己觉得合适的难度级别(简单、中等和困难):

来源:https://leetcode.com/problemset/all/

有数百种不同的算法问题，这意味着能够识别常见的模式并在不到 10 分钟的时间内编写一个有效的解决方案将需要大量的时间和精力。

“如果你一开始真的很难解决它们，不要失望，这是完全正常的”

如果你一开始真的很难解决它们，也不要失望，这是完全正常的。即使是更有经验的 Python 程序员也会发现，如果没有足够的培训，许多算法在短时间内很难解决。

同样，如果你的面试没有像你预期的那样进行，并且你刚刚开始解决算法，也不要失望。有些人准备了几个月，每天解决几个问题，并定期排练，然后才能搞定面试。

为了在你的训练过程中帮助你，下面我选择了我在电话编码面试中一再看到的 10 种算法(主要围绕字符串操作和数组)。这些问题的水平主要是 容易 所以把它们当作好的起点。

请注意，我为每个问题分享的解决方案只是许多可能实现的潜在解决方案中的一个，而且通常是 BF(“暴力”)解决方案。因此，请随意编写您自己版本的算法，尝试在运行时和使用的内存之间找到正确的平衡。

字符串操作

1.反向整数

*Output:
-132
543*

一个预热算法，可以帮助你练习切片技巧。实际上，唯一棘手的是确保你考虑到了整数为负的情况。我看到这个问题以不同的方式出现，但它通常是更复杂请求的起点。

2。平均单词长度

*Output:
4.2
4.08*

要求您使用字符串进行一些简单计算的算法非常常见，因此熟悉像**.replace()** 和**.split()**这样的方法很重要，在这种情况下，它们帮助我删除了不想要的字符，并创建了一个单词列表，其长度可以很容易地测量和求和。

3。添加字符串

*Output:
2200
2200*

我发现这两种方法都同样敏锐:第一种方法简单直观，使用**eval( )**方法动态评估基于字符串的输入，第二种方法巧妙使用**ord( )** 函数，通过字符的 Unicode 码位将两个字符串重新构建为实际数字。如果我真的必须在这两者之间做出选择，我可能会选择第二种方法，因为它起初看起来更复杂，但在解决需要更高级的字符串操作和计算的“中等”和“硬”算法时，它通常很方便。

4.第一个唯一字符

*Output:
1
2
1
###
1
2
1*

同样在这种情况下，提供了两种可能的解决方案，我猜想，如果您对算法相当陌生，第一种方法看起来更熟悉，因为它从一个空字典开始构建简单的计数器。

然而，从长远来看，理解第二种方法会对你有更大的帮助，这是因为在这个算法中，我简单地使用了**collection.Counter(s)**，而不是自己构建一个字符计数器，并用**enumerate(s)**替换了**range(len(s))**，这个函数可以帮助你更优雅地识别索引。

5.有效回文

*Output:
True*

**“有效回文”问题是一个真正的经典，你可能会在许多不同的口味下反复找到它。在这种情况下，任务是通过删除最多一个字符来检查天气，字符串与其相反的对应物匹配。当 s = 'radkar 时，函数返回**True**，因为通过排除' k '我们得到单词 'radar' ，这是一个回文。

数组

6.单调阵列

*Output:
True
False
True*

这是另一个非常常见的问题，上面提供的解决方案非常优雅，因为它可以写成一行程序。一个数组是单调的* 当且仅当它是单调递增的，或者单调递减的并且为了评估它，上面的算法利用了all()函数，如果 iterable 中的所有项都为真，则返回True，否则返回False。如果 iterable 对象为空，all()函数也返回True。*

7.移动零点

*Output:
[1, 3, 12, 0, 0]
[1, 7, 8, 10, 12, 4, 0, 0, 0, 0]*

当您使用数组时，.remove()和.append()方法是宝贵的盟友。在这个问题中，我使用它们首先删除属于原始数组的每个零，然后将它附加到同一个数组的末尾。

8.填补空白

*Output:
[1, 1, 2, 3, 3, 3, 5, 5]*

在真实的面试中，我被要求解决这个问题几次，两次解决方案都必须包括边缘情况(为了简单起见，我在这里省略了)。理论上，这是一个很容易构建的算法，但是你需要清楚地知道你想用 for 循环和 if 语句实现什么，并且能够自如地使用None值。

9.匹配和不匹配的单词

*Output:
(['The','We','a','are','by','heavy','hit','in','meet','our',
    'pleased','storm','to','was','you'],
 ['city', 'really'])*

这个问题相当直观，但该算法利用了一些非常常见的集合运算，如set()、intersection() or &和symmetric_difference()or ^，这些运算对使您的解决方案更加优雅非常有用。如果这是你第一次遇到它们，一定要看看这篇文章:

10.素数数组

*Output:
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]*

我想用另一个经典问题来结束这一部分。如果你熟悉质数定义和 模运算 ，那么通过range(n)循环可以很容易地找到解决方案。

结论

在这篇文章中，我分享了 10 个 Python 算法的解决方案，这是编码面试中的常见问题。如果你正在准备一个知名科技公司的面试，这篇文章是一个很好的起点，让你熟悉常见的算法模式，然后转向更复杂的问题。还要注意的是这篇文章中的练习(以及它们的解决方案)是对 Leetcode 和 GeekForGeeks 上的问题的重新诠释。我远非该领域的专家，因此我提出的解决方案只是指示性的。**

给我的读者一个提示

还不是中等会员？考虑注册我的推荐链接，以每月 5 美元的价格获得 Medium 提供的一切！

这个帖子包括附属链接，如果你购买的话，我可以免费给你一点佣金。

您可能还喜欢:

* [## 3 门数据工程课程，在 2022 年推进您的职业发展

加入数据行业，改变角色或通过注册数据工程简单地学习前沿技术…

towardsdatascience.com](/3-nanodegrees-you-should-consider-to-advance-your-data-engineering-career-in-2021-baf597debc72) [## 使用 Python 字典计数器解决的 5 种算法

通过 Python 字典学习计数对象的三种方法。

towardsdatascience.com](/5-algorithms-solved-using-python-dictionary-counters-5f68f5740211) [## 下一次面试前要解决的 5 组 Python 算法

集合是许多 Python 访谈中反复出现的话题，并且经常提供高效求解算法的捷径。

towardsdatascience.com](/5-pythons-sets-problems-to-solve-before-your-coding-interview-41bb1d14ac25)**

面向数据科学家的 10 个令人敬畏的编程项目

原文：https://towardsdatascience.com/10-awesome-programming-projects-for-data-scientists-d2bf64f72ee4?source=collection_archive---------20-----------------------

帮助您改进编码和分析的原创想法

约书亚·雷德科普在 Unsplash 上的照片

实践是学习的重要部分。但是根据我学习编程的经验，找到有用的任务和项目来强化你的技能是很困难的。对于数据分析的编程来说尤其如此。如果你不知道去哪里找，找到有意义和有趣的数据真的很难。

幸运的是，有很多很棒的数据集和项目。在寻找你的下一个项目时，有几件事值得考虑:

• 不是每个项目都必须复杂。我从尝试可以用一句话概括的任务中学到了很多。
• 与传统意义上的“数据”无关的项目仍然可以帮助你成为更好的数据科学家/分析师。

考虑到这一点，我喜欢探索快速任务、长期项目以及数据集和问题集合的混合。以下是我最喜欢的 10 个。

1.易贝分析

描述:使用 Python 的数据抓取和分析项目

Justin Lim 在 Unsplash 上的照片

作为一个非常受欢迎的二手物品市场，易贝拥有大量关于其所有物品和列表价格不断变化的数据。如果你想在买卖时获得优势，获取并分析这些数据是非常有用的。

有几种方法可以获得易贝数据。我既使用了像 Python 的 BeautifulSoup 这样的网络抓取库，也使用了不同 Python 脚本中的易贝 API。无论您采用哪种方法，以下是您可以对数据做的一些事情:

• 分析特定项目随时间的价格波动
• 确定一个给定的列表是否可以买卖以获取更大的利润
• 根据标题或描述的内容预测商品的销售价格

我已经尝试过其中的几个，我发现当我准备在易贝买卖时，它很有用。试试看，也许你还能赚点外快。

2.待办事项自动化

描述:使用 Python 和 Todoist API 的生活自动化项目

由 Cathryn Lavery 在 Unsplash 上拍摄的照片

如果您有一个数字待办事项列表，您可以创建一个脚本来以编程方式添加和操作任务。这在过去为我节省了大量的时间，并帮助我处理那些不经常重复的任务。

为了开始这个项目，我建议使用 Todoist 作为你的数字待办事项列表。Todoist 提供了一个简单明了的 API，很容易与 Python 一起使用，还有一些有用的文档。然后，您可以确定添加和操作待办事项列表的条件。您可以:

• 设置动态提醒，根据天气情况给植物浇水
• 当内部温度过高时，创建一个紧急提醒来清理您的计算机
• 如果一项任务已经过期超过了设定的时间，就删除它(并添加另一个提醒来为自己设定更现实的目标)

一旦您将待办事项清单自动化脚本设置为定期运行，您应该有望体验到生产力的激增。至少，你会获得更多的经验。

[## 如何用 Python 自动化你的待办事项列表

花几分钟写代码，再也不会忘记任务

levelup.gitconnected.com](https://levelup.gitconnected.com/how-to-automate-your-to-do-list-with-python-2da26b0ffc8f)

3.嘶嘶作响

描述:快速基本编码任务

Sharon McCutcheon 在 Unsplash 上拍摄的照片

FizzBuzz 是一个非常简单的问题。但我强调它是一个独立的项目，因为我认为每个程序员都应该尝试一下，并学习如何解决它。问题如下:

打印整数 1 到 N，但是如果一个整数能被 3 整除，则打印“Fizz”，如果一个整数能被 5 整除，则打印“Buzz”，如果一个整数能被 3 和 5 整除，则打印“FizzBuzz”。

虽然这是一个简单的任务，但对于一个程序员新手来说，这仍然需要一些思考。也有不同的方法来解决它，其中一些是更有经验的用户感兴趣的。学习这个任务的好的解决方案将有助于提高你解决问题的能力，以及你对什么是好代码的理解。

[## 如何解决 R 中的 FizzBuzz 问题

用这五个解决方案给面试官留下深刻印象并改进你的代码。

towardsdatascience.com](/how-to-solve-the-fizzbuzz-problem-in-r-c62e7e6c959a)

4.代码的出现

描述:快速编程问题集

照片由裘德·贝克在 Unsplash 上拍摄

每年 12 月，Codeinitiative降临节每天都会上传一个新的编程问题，直到圣诞节。不能等到明年圣诞节吗？不用担心—每年的所有问题都已存档，全年可用。

我喜欢《代码降临》有几个原因。随着时间的推移，问题变得越来越难，这意味着每个人都有自己的事情。它们也涵盖了广泛的任务和技能，让你接触到各种奇怪的任务和数据。如果你也是一名自学成才的程序员，其中一些可能会挑战你，并推动你提高计算机科学知识。

5.欧拉项目

描述:数学编码问题集合

照片由安托万·道特里在 Unsplash 上拍摄

想把你的编码技能运用到有趣的娱乐数学问题上吗？ Project Euler 是给你的。

项目欧拉是一个庞大的数学问题集合，旨在提高程序员的技能。这些问题的难度各不相同，但许多都不需要专业的数学知识。虽然项目欧拉问题不是以数据为中心的，但解决它们无疑会加强数学知识和解决问题的方法，这将有助于处理数据。

我建议从档案中的一些早期问题开始。

6.整洁的星期二

描述:收集来自 R 社区的有趣数据集

帕斯卡尔·贝纳登在 Unsplash 上的照片

在 R 社区，周二是一个事件！每周的这一天，一个新的数据集会在整洁的周二 GitHub 库中发布。这些数据集在主题上有很大的不同，无论你喜欢哪种编程语言，探索和分析它们都很有趣。

整洁星期二的社交方面也很独特。鼓励用户每周在 Twitter 标签#TidyTuesday 上分享他们的可视化和分析。这就产生了一个有趣的关于相同数据的汇编，通常对你自己的努力是一个很大的启发。

7.卡格尔比赛

描述:大项目集合，有奖

照片由布拉登·科拉姆在 Unsplash 上拍摄

到目前为止， Kaggle 竞赛已经成为数据科学社区的中流砥柱。Kaggle 是一个托管在线 Jupyter 笔记本环境、教程和数千个免费真实数据集的平台。Kaggle 还举办比赛，参赛队伍尝试使用数据科学回答数据集的问题。

介绍性的比赛都有很好的记录，但是新的比赛不断出现，有时会奖励获胜的团队一大笔现金。如果你能找到一个与你的技能相符的项目，那么看看 Kaggle 是值得的。

8.个人推荐仪表板

描述:决策自动化程序使用从基本逻辑到机器学习的任何东西

丘特尔斯纳普在 Unsplash 上拍照

把你的分析结论应用到有用的事情上总是令人满意的。推荐引擎可以做到这一点。基于一些输入和一些启发，你可以通过让一个程序自动化你的一些日常选择来使你的生活变得更容易。

我之前用 R Shiny 开发了一个仪表盘应用程序，根据温度和正式程度等因素，它会给我建议穿什么。虽然我使用了基本的逻辑来实现这一点，但是使用外部数据和/或统计模型是很自然的下一步。无论你选择哪种方法或推荐问题，从长远来看，这个项目都可以节省你的时间。你的前端、后端和设计技能也会得到锻炼。

9.个人财务分析

描述:用代码洞察你的消费和储蓄

由 Kelly Sikkema 在 Unsplash 上拍摄的照片

如果你记录了你的花费或者有了预算，你就立刻开启了一个伟大的项目。为什么不利用你的分析知识来分解你的支出，预测下一年你会存多少钱，或者根据复利来计算预测回报呢？

虽然一些银行应用程序有预算功能，但我发现它们不够全面或可定制，不符合我的喜好。通过比较，你自己的财务分析可以更深入，并且是一个有用的项目。当你最终量化你在酒吧花了多少钱时，省钱的空间是巨大的。

10.批量图像处理

描述:使用 R 包进行图像编辑

由 Vincentas Liskauskas 在 Unsplash 上拍摄

你想同时编辑一堆图片吗？也许是为了在网页上使用而调整它们的大小，或者因为它们都有点曝光过度而调整它们的亮度？用代码自动化你的图像编辑过程！

虽然编辑图像听起来不像数据分析，但值得记住的是，图像仍然是数据。它们包含大量丰富的信息，可以通过编程进行分析，用于各种用途。因此，学会和他们一起工作是很有价值的。这也比你想象的要容易。我写了一个关于在 R 中使用 magick 包进行批量图片编辑的小教程，整个代码大概有 10 行！

[## 用 R 批量编辑图像

使用函数式编程编辑和文件转换任意多的图像。

levelup.gitconnected.com](https://levelup.gitconnected.com/batch-editing-images-with-r-3d4aef08bc62)

最后的想法

学习任何东西的最好方法是把它应用到你关心的事情上。这些项目中的许多在某种程度上让我的生活变得更容易，并且当我获得理解时，所有这些项目都让我参与进来。所以用你最喜欢的语言打开一个新项目。

不一定是大项目，也不一定让你赚钱。它只需要是新的有趣的东西。

谁知道它会把你带到哪里。

想阅读我所有关于编程、数据科学等方面的文章吗？在这个链接注册一个媒体会员，就可以完全访问我所有的作品和媒体上的所有其他故事。这也直接帮助了我，因为我从你的会员费中得到一小部分，而不需要你额外付费。

只要我在这里订阅，你就可以将我所有的新文章直接发送到你的收件箱。感谢阅读！

10 个令人惊叹的 Python 3.9 特性

原文：https://towardsdatascience.com/10-awesome-python-3-9-features-b8c27f5eba5c?source=collection_archive---------0-----------------------

必须了解的 Python 3.9 特性

最新的 Python 3.9.0 最终版本将于 2020 年 10 月 5 日星期一发布

就像大多数 Python 爱好者一样，我对探索和使用最新的特性感到非常兴奋。本文将概述 Python 3.9 的必备特性。

对于 Python 程序员来说，这又是一个激动人心的时刻。

作者图片

我通读了 Python 3.9 发行说明和相关讨论。基于这些信息，我想写一个全面的指南，这样每个人都可以对这些功能及其详细的工作原理有所了解。

在我开始之前，我必须说，我非常兴奋地探索 3.9 版本，因为一些功能肯定会在我的应用程序中使用。

简单地

从字典更新/合并到添加新的字符串方法，再到引入 zoneinfo 库，已经添加了许多新特性。此外，还引入了一种新的稳定、高性能的解析器。

随着新模块zoneinfo 和graphlib的加入，标准库更新了许多新特性。许多模块也得到了改进，例如ast、asyncio、concurrent.futures、multiprocessing、xml 等等。

这个版本进一步稳定了 Python 标准库。

现在让我们来探索 Python 3.9 的特性。

1.特性:字典更新和合并操作符

内置的dict 类中增加了两个新的操作符|和|=。

|操作符用于合并字典，而|=操作符可用于更新字典。

人教版:584

代码:

用于合并:|

>>> a = {‘farhad’: 1, 'blog’: 2, 'python’: 3}
>>> b = {’farhad’: 'malik’, 'topic’: 'python3.9’}
>>> a | b
{’blog’: 2, 'python’: 3, ’farhad’:’malik’,  'topic’: 'python3.9’}
>>> b | a
{’farhad’: 1,’blog’: 2, 'python’: 3, 'topic’:’python3.9’ }

求更新:|=

>>> a |= b
>>> a
{’blog’: 2, 'python’: 3,’farhad’:’malik’}

要记住的关键规则是，如果有任何键冲突，那么将保留最右边的值。这意味着最后看到的值总是有效的。这也是其他dict 操作的当前行为。

详细解释:

正如我们在上面看到的，两个新的操作符|和|=已经被添加到内置的dict 类中。

|操作符用于合并字典，而|=操作符可用于更新字典。

我们可以认为|是列表中的+(连接)，我们可以认为|=是列表中的+=操作符(扩展)。

如果我们评估 3.8 版本，我们会注意到合并和更新字典的方法很少。

作为一个例子，我们可以做first_dict.update(second_dict)。这种方法的问题是它在适当的位置修改了first_dict 。解决这个问题的一个方法是将first_dict 复制到一个临时变量中，然后执行更新。然而，它添加了额外的不必要的代码，只是为了让更新/合并工作。

我们也可以用{**first_dict, **second_dict}。这种方法的问题是它不容易被发现，并且更难理解代码打算执行什么。这种方法的另一个问题是映射类型被忽略，类型总是 dict。作为一个例子，如果first_dict 是一个defaultdict 并且second_dict 是 dict 类型，那么它将失败。

最后，collections 库包含一个ChainMap 函数。它可以接受两个字典，比如ChainMap(first_dict, second_dict)，并返回一个合并的字典，但是这个库并不常见。

对于具有不兼容的__init__ 方法的dict 的子类，它也会失败。

更多信息:https://www.python.org/dev/peps/pep-0584

作者图片

2.特性:新的灵活的高性能基于 PEG 的解析器

Python 3.9 版本提议用一种新的基于 PEG 的高性能和稳定的解析器取代当前基于 LL(1)的 Python 解析器。

人教版:617

详细解释:

当前的 CPython 解析器是基于 LL(1)的。随后，该语法是基于 LL(1)的，以允许它被 LL(1)解析器解析。LL(1)解析器是一个自顶向下的解析器。此外，它从左到右解析输入。当前的语法是上下文无关的语法，因此没有考虑标记的上下文。

Python 3.9 版本提议用一个新的基于 PEG 的解析器来代替它，这意味着它将取消当前的 LL(1)语法 Python 限制。此外，当前的解析器已经修补了许多将被删除的漏洞。因此，从长远来看，这将降低维护成本。

例如，尽管 LL(1)解析器和语法实现起来很简单，但是这些限制不允许它们以自然的方式向语言设计者和读者表达常见的结构。解析器只查看前面的一个标记来区分可能性。

选择运算符|是命令。对于一个实例，如果编写了以下规则:

rule: A|B|C

LL(1)解析器是一个上下文无关的语法解析器，它将生成这样的构造，即给定一个输入字符串，它将推断出是否需要扩展 A 或 B 或 c。它将检查第一个选项是否成功。如果仅失败一次，它将继续第二次或第三次。

PEG 解析器只为一个字符串生成一个有效的树。因此，它不像 LL(1)解析器那样不明确。

PEG 解析器还通过语法动作直接生成规则的AST 节点。这意味着它避免了中间步骤的产生。

关键是 PEG 解析器已经过广泛的测试和验证。PEG 解析器的性能得到了微调。因此，对于大多数指令来说，它只占用当前解析器 10%的内存和速度。这主要是因为没有构造中间语法树。

为了保持文章的简单和可读性，我删除了对底层细节的提及。如果需要了解更多信息，底部提供了链接。

更多信息:https://www.python.org/dev/peps/pep-0617

作者图片

3.特性:新的字符串功能，以消除前缀和后缀

两个新功能被添加到str 对象中。

• 第一个函数删除前缀。是str.removeprefix(prefix)。
• 第二个函数删除后缀。正是str.removesuffix(suffix)。

人教版:616

代码:

'farhad_python'.removeprefix('farhad_')
#returns python'farhad_python'.removesuffix('_python')
#returns farhad

详细解释:

数据科学应用程序中涉及操作文本的常见任务之一是删除字符串的前缀/后缀。str 对象增加了两个新功能。这些函数可以用来删除字符串中不需要的前缀和后缀。

第一个函数删除前缀。第二个函数是str.removeprefix(prefix).删除后缀。是str.removesuffix(suffix).

记住字符串是字符的集合，每个字符在字符串中都有一个索引。我们可以使用索引和冒号 :来返回字符串的子集。这个特性被称为字符串切片。

如果我们研究函数，它们在内部检查字符串是否以前缀开始(或以后缀结束),如果是，那么它们使用str[:]切片特性返回一个没有前缀(或在后缀之后)的字符串。

随着这些函数成为标准库的一部分，我们得到了一个一致的、不太脆弱的、高性能的、更具描述性的 API。

更多信息:https://www.python.org/dev/peps/pep-0616

4.特性:内置泛型类型的类型提示

在此版本中，通过移除 Python 中的并行类型层次，注释程序变得更加简单。

该版本支持类型模块中当前可用的所有标准集合中的泛型语法。

我们可以使用list 或dict 内置集合类型作为泛型类型，而不是在函数签名中使用typing.List or typing.Dict。

因此，代码现在看起来更清晰，并且更容易理解/解释代码。

PEP: 585

详细解释:

虽然 Python 是一种动态类型语言，但是 Python 程序中的类型注释支持类型的自省。随后，该注释可用于运行时类型检查的 API 生成。

这个版本支持类型模块中当前可用的所有标准集合中的泛型语法。

一般类型通常是一个容器，例如 list。它是一种可以参数化的类型。参数化泛型是具有容器元素的预期类型的泛型的实例，例如 list[str]

我们可以使用list 或dict 内置集合类型作为泛型类型，而不是使用typing.List or typing.Dict.

例如，我们可以通过注释代码来指导 Python 运行时类型检查:

def print_value(input: str):
  print(input)
# We would get notified  if the input is not a string

在过去的几个版本中，已经在现有 Python 运行时的基础上逐步构建了许多静态类型特性。其中一些功能受到现有语法和运行时行为的限制。因此，由于泛型，在类型模块中存在重复的集合层次结构。

例如，我们将看到typing.List、typing.Dictionary 以及内置的list、dictionary等等。这使我们能够编写代码:

**def** read_blog_tags(tags: list[str]) -> **None**:
    **for** tag **in** tags:
        print("Tag Name", tag)

更多信息:https://www.python.org/dev/peps/pep-0585

5.特性:支持 IANA 时区

已经创建了模块zoneinfo 来支持IANA 时区数据库。对IANA 时区数据库的支持已经被添加到标准库中。

人教版:615

IANA 时区通常被称为tz 或zone info。有许多 IANA 时区使用不同的搜索路径来为日期时间对象指定 IANA 时区。例如，我们可以将搜索路径的名称作为洲/城市传递给一个datetime 对象来设置它的tzinfo。

dt = datetime(2000, 01, 25, 01, tzinfo=ZoneInfo("Europe/London"))

如果我们传入一个无效的键，那么zoneinfo.ZoneInfoNotFoundError将被抛出。

详细解释:

我们使用datetime 库来创建一个datetime 对象，并通过设置 tzinfo 属性来指定它的时区。然而，当使用datetime.tzinfo基线时，我们最终会创建复杂的时区规则。

大多数时候，我们只需要设置对象并将其时区设置为 UTC、系统本地时区或 IANA 时区。

我们可以创建一个zoneinfo.ZoneInfo(key) 对象，其中的键是 string 类型的，表示系统时区数据库中时区文件的搜索路径。可以创建zoneinfo.ZoneInfo(key)对象，并将其设置为datetime 对象的tzinfo 属性。

代码:

**from** **zoneinfo** **import** ZoneInfo
**from** **datetime** **import** datetime

dt = datetime(2000, 01, 25, 01, tzinfo=ZoneInfo("America/Los_Angeles"))

欲知详情:https://www.python.org/dev/peps/pep-0615

6.功能:取消并发期货的能力

一个新的参数 cancel_futures被添加到concurrent.futures.Executor.shutdown()中。

此参数cancels 所有未开始的未决期货。在 3.9 版本之前，进程会在关闭执行器之前等待它们完成。

解释:

新参数cancel_futures 已经添加到ThreadPoolExecutor 和ProcessPoolExecutor中。它的工作方式是当参数的值为 True 时，那么当调用 shutdown()函数时，所有未决的期货都将被取消。

简而言之，当执行 shutdown()时，解释器检查执行器是否没有被垃圾收集。如果它仍然在内存中，那么它将获得所有挂起的工作项，然后取消期货。

一旦没有挂起的工作项，它就会关闭工作线程。

链接:https://bugs.python.org/issue30966

7.特性:异步和多处理改进

在这个版本中，对 asyncio 和多处理库进行了许多改进。

作为一个例子，

1. 由于严重的安全问题，不再支持asyncio.loop.create_datagram_endpoint() 的reuse_address 参数。
2. 新增了coroutines, shutdown_default_executor() 和协程asyncio.to_thread()。shutdown_default_executor 为等待ThreadPoolExecutor 完成关闭的默认执行器安排关闭。asyncio.to_thread()主要用于在单独的线程中运行 IO 绑定的函数，以避免阻塞事件循环。

关于多重处理库的改进，一个新的方法close()被添加到了 multiprocessing.SimpleQueue 类中。

此方法显式关闭队列。这将确保队列被关闭，并且不会停留超过预期的时间。要记住的关键是，一旦队列关闭，就不能调用方法get(), put(), empty()。

链接:https://bugs.python.org/issue30966

8.功能:一致的包导入错误

在 3.9 版本之前导入 Python 库的主要问题是，当相对导入越过其顶级包时，Python 中的导入行为不一致。

builtins.__import__()升高ValueError 同时importlib.__import__() 升高 ImportError。

现在已经修好了。import()现在会引发ImportError 而不是ValueError。

欲知详情:https://bugs.python.org/issue37444

9.功能:随机字节生成

3.9 版本中增加的另一个特性是功能random.Random.randbytes()。该函数可用于生成随机字节。

我们可以生成随机数，但是如果我们需要生成随机字节呢？在 3.9 版本之前，开发人员必须发挥创造力来生成随机字节。虽然我们可以使用os.getrandom(), os.urandom() or secrets.token_bytes() 但是我们不能生成伪随机模式。

作为一个例子，为了确保随机数以预期的行为生成，并且该过程是可重复的，我们通常使用随机的种子。随机模块。

因此，random.Random.randbytes()法被引入。它也能以可控的方式生成随机字节。

更多信息:https://bugs.python.org/issue40286

10.功能:字符串替换功能修复

在 Python 版本之前，“”.replace(“”,s,n)返回空字符串，而不是所有非零 n 的 s

这个错误让用户感到困惑，并导致应用程序的行为不一致。

3.9 版本已经修复了这个问题，现在与"".replace("", s)保持一致。

replace 函数的工作方式是，对于给定的 max replace occurrence 参数，它用一组新的字符替换字符串中的一组字符。

string.replace(s, old, new[, maxreplace])Return a copy of string s with all occurrences of substring old replaced by new. If the optional argument maxreplace is given, the first maxreplace occurrences are replaced.

为了进一步解释这个问题，在 3.9 版本之前，replace 函数的行为不一致

"".replace("", "blog", 1)
Returns ’'
One would expect to see blog"".replace("", "|", 1)
Returns ’'
One would expect to see |"".replace("", "prefix")
Howver returns ’prefix'

因此，现在的变化是，如果我们进入:

“”.replace(“”,s,n) returns s instead of empty string for all non-zero n

更多信息:https://bugs.python.org/issue28029

作者图片

Python 3.9 中也删除了许多冗余特性，比如Py_UNICODE_MATCH.

我对探索 3.9 版感到非常兴奋，因为其中的一些特性肯定会在我的应用程序中使用。

如果你想了解更多关于这些改进的信息，请点击阅读官方指南。

数据科学家在封锁期间应该阅读的 10 本书

原文：https://towardsdatascience.com/10-books-data-scientists-should-read-during-lockdown-f49b68fad650?source=collection_archive---------5-----------------------

莎伦·麦卡琴在 Unsplash 上的照片

如果你和数据打交道，这些书会帮助你保持活跃和学习

介绍

几个星期以来，全世界都在与新冠肺炎作战，大多数人已经被封锁了一段时间。尽管我们大多数人仍然在家工作，但在空闲时间很容易感到无聊，不知道接下来在网飞看什么。

就我个人而言，我喜欢阅读，所以我想推荐一些我最近读过的书籍，这些书籍可能对与数据打交道的人有用或有趣。有些更专业，有些更有趣，但我相信你会在这里找到你想要的。

人工智能:思考人类的指南

我不仅向数据科学家推荐这本书，也向所有对人工智能及其未来成果感兴趣的人推荐这本书。对于一本面向普通大众的书来说，它花了很多时间在计算机视觉和计算机如何“思考”的细节上，对该主题进行了清晰而广泛的概述。它还谈到了人工智能对未来的展望以及你对未来几年的期待。AI 潜力有时会吓到我们，但我们也倾向于高估它在过去几年的进步。如果你对人工智能特别感兴趣，你可能会喜欢这篇关于如何让人工智能更有道德的文章。

统计学:非常简短的介绍

如果你是一名来自 IT 或商业背景的数据科学家，并且想了解统计技术的基础，而又不想了解太多细节，这本书特别有用。它涵盖了基础知识，从概率分布到回归分析，以及决策树。顾名思义，它很短，你只需要花几天时间就可以读完。更详细的概述，你可以点击查看其摘要。

精益分析

如果你在一家初创公司从事数据工作，或者如果你拥有一家初创公司并希望它开发其数据潜力，这本书是特别推荐的。它帮助你根据公司的商业模式以及如何优化它们来定义对公司最重要的指标，而不是淹没在一堆无用的指标中。这里可以找到更详细的总结。

解决市场问题的人

这是一本非技术性的书，讲述了数学家吉姆·西蒙斯(Jim Simons)的故事，他开始使用统计数据进行股票交易，当时市场上的其他人都只使用直觉和传统的基本面分析。显然，起初每个人都对他的方法持怀疑态度，但在多年管理他的基金并取得惊人成果后，人们最终屈服了，并开始承认所谓的 quant 对冲基金的力量，这些基金目前在金融行业发挥着巨大作用。

商业预测交易

商业预测艺术的初级读本，这是在商业应用中使用数据和统计的最传统的方法之一。如果你有一些统计学和时间序列的知识，并且必须在工作中做预测，比如预测收入，这真的很有帮助。它涵盖了基础知识和神话，采用了非常实用的方法(尽管所介绍的技术可以被认为是过时的，但与机器学习技术相比，它们通常在这个领域中工作得非常好)。

用数据讲故事

对于那些在工作中必须使用数字来推销想法、展示成果或讲述故事的人来说，这是必备的。它更适合业务分析师，但数据科学家也可以从中受益，通过学习数据可视化技术，帮助他们展示模型的结果，更好地可视化和绘制数据。那种你一直回去复习重要概念的书。

为什么之书

我们经常被告知“相关性并不意味着因果关系”。然而，当你思考这个问题时，因果关系的概念并不是很清楚:T2 到底是什么意思？这本书讲述了我们如何从哲学角度看待因果关系，然后介绍了理解它的数学工具和模型。它会改变你对因果的看法。如果你想了解更多关于因果关系的知识，你应该阅读这篇文章。

钱球

这是一个关于比利·比恩和保罗·德波斯塔的故事，他们通过挑选廉价的被忽视的球员，在职业棒球大联盟的一场出色的比赛中，带领一个小棒球队奥克兰运动家队。他们是怎么做到的？通过使用数据。这改变了球队选择球员的整个方式，以前这完全是由球探和他们的直觉来完成的。这个故事也启发了同名电影，它们都是杰作。

数据策略

这一点更多的是在业务方面，它可能有助于执行经理，甚至 C 级人员了解如何在一个组织中释放数据的力量。从如何从数据中提取有价值的洞察力，到如何将其货币化。如果你是一名数据科学家，它可以帮助你对自己在公司中的角色有一个更广阔的视野，以及如何使用数据帮助 it 创造价值。如果你想了解更多，这里有一篇关于这个主题的好文章。

机器学习的特征工程

尽管特征工程是数据科学工作流程中最重要的步骤之一，但它有时会被忽视。这本书是这个过程的一个很好的概述，包括详细的技术，警告和实际应用。它附带了大多数方法的数学解释和 Python 代码，所以您需要有一定的技术背景才能理解。关于特征工程方法的简要总结，你可以阅读这篇文章，大致基于这本书。

没人会教你的 10 条编码原则

原文：https://towardsdatascience.com/10-coding-principles-that-no-one-will-teach-you-37d64b5081ef?source=collection_archive---------13-----------------------

来源:作者图片

介绍

互联网将编码员定义为用一种外来语言实现涉及复杂逻辑和数学方程的算法以促进特定计算操作和功能的计算机呆子。诚然，人可以用这样的方式编码， 真正的编码技巧是当你能给机器写令人费解的指令时，这些指令也能被人类容易地阅读和理解。

想想看，写好代码就相当于写好故事。首先，给你的变量起个合适的名字。你不会把你故事中的人物命名为*ssddds*或*sfddfd*吧？😛

此外，一个令人恼火的深奥而老成的词汇的混合，使你的故事显得清晰明了，并不能使它成为一个好故事，对吗？(词汇学分，Shashi Tharoor 😛)
同样，仅仅在代码中使用高级算法并不能让你成为一名优秀的程序员！

当我们与不同的团队和业务单位合作进行一个真实世界的项目时，我们需要编写干净的、可维护的、以及(如果可能的话)优化的代码，以确保跨职能流程。本文将展示一些概念和编码实践，从长远来看，它们将对您有所帮助。

1.对合适的人有合适的可见性

如今，在我们生活的世界中，所有业务部门对技术的依赖都在呈指数级增长，以实现业务的自动化、优化和扩展。尤其是在这个在家工作的新世界，数据驱动的解决方案的必要性是不可避免的。我们需要用一种面向对象编程 的方式来思考解决业务问题。需要正确层次的 抽象封装 ，向不同层次的业务展示不同层次的可视性。
在商界，通常，

客户只关心结果，不关心算法！

这里顾客的定义是主观的。

任何直接/间接使用你的解决方案的人都是你的客户。

取决于你做什么，它可以是合作开发者，项目经理，项目经理，测试团队，或者实际的客户本身。在本文中，我将使用术语“客户”。我们的责任是确保客户能够获得输出，而不处理超出范围的任何事情。

考虑一个茶叶店的类比；顾客说的都是，“兄弟，两杯茶！”，他们并不是真的想知道后台发生了什么，也就是说，水和牛奶的比例是多少，我们从哪里获得供应，等等。除非他们明确说明。

同样，泡茶的厨师通常不需要知道玻璃杯是在哪里制造的，或者种植茶叶所需的土壤条件是什么。他只是需要货源。

2.模块化您的解决方案

封装级别[来源:作者图片]

总是将你的代码保持在模块中，而不是给出一个冗长的脚本/笔记本作为你的解决方案，利用 导入系统 。

优点:

1. 让顾客觉得事情简单，对他们隐藏不必要的细节。
2. 可重用资产:你可以找到一些几乎所有项目都会用到的模块，你可以很容易地重用它们，而不是重复发明轮子。
3. 更容易的协作:当每个个体贡献者处理不同的文件时，合并冲突的概率将显著降低。

如果您对创建自己的 Python 包感兴趣，请查看官方文档。你也可以看看我为了创建新的 Python 包而创建的这个 Python 包 。是的，这是一个包装异常！这将创建基本的框架和文件夹结构；你可以用你的溶液填满它们。

3.首先创建 0 版解决方案

总是先创建一个基本解决方案。这将允许我们展示一些进展并开始讨论，这将有助于你从客户那里获得早期反馈。

开始错了，总比结束错了好。

因为即使你有一个你认为能在截止日期前完成的更好的解决方案的想法，你也应该假设你不能完成它的场景。然后，对于客户来说，你什么都没有。

这样，您就取得了一些进步，并可以在按照您的预期完成模块后，以改进的表现给客户留下深刻印象。

总是有一个后备选择。A 计划几乎永远行不通，准备好 B 计划。

4.版本控制系统和错误记录

说到后备选项，当你在团队中工作时，对版本控制系统有一个公平的理解是必须的，比如【Git】。这将确保:

1. 更容易的协作和分支。
2. 隐式备份
3. 指责游戏在这里不起作用。每一行代码都被跟踪。
4. 你的文件夹看起来不像
   final _ code . py
   final _ code _ 2 . py
   final _ code _ for _ sure . py
   final _ code _ possible _ not . py
   final _ code _ tell _ you _ so . py…..
   再也:P

拥有一个日志文件来记录的进度和错误将会大大减少调试工作。

5.即插即用功能

创建一个配置文件，用于激活/停用解决方案的各种功能。这可以在许多方面帮助我们:

1. 如果我们对同一个问题有多种可能的解决方案，并且需要测试所有的可能性。
2. 你需要在一个子模块中调试一个问题，这不需要很多其他模块。在这里，您可以简单地停用它们，避免运行那些不需要的模块所花费的时间。

6.信任他人，而不是他们的代码

现实世界编码中最重要的技能之一是防御性编码的艺术。在我上一篇关于现实项目 中 Python 的 目录和文件处理的文章中，我提到了异常处理的必要性。****

防御性编码是一种编程方式，旨在预测可能的失败点。

当你是一个大型项目的一部分时，你将与许多其他开发人员合作，你将不得不创建具有外部输入的模块，这些外部输入将是原始数据本身或来自其他模块的处理输出。

我们需要预料到人为错误和现实世界噪音的可能性，并努力处理它们；我们的想法是，我们的解决方案不应中断；如果您的模块无法运行，您应该记录错误并继续。

尤其是我们在处理 AI 项目的时候，由于误报，一些模块的失败是意料之中的；这并不意味着代码应该中断；可能还有其他运行良好并为客户增加价值的模块。你需要花时间在:

1. ****异常处理:总是假设你的模块出现故障的情况，并提供异常。
2. ****角落案例:这是你直觉思维可以发挥作用的地方；当您创建一个解决方案时，考虑各种可能需要为异常情况添加一些额外逻辑和条件的场景。

正如他们所说，

代码必须继续！

7.也不要相信你的代码！

不言而喻，我们是人类，人类容易犯错误。无论你是一个多么优秀的程序员，都要对你犯错误的可能性保持开放的态度。您可以尝试以下方法来尽量减少错误:

1. 一旦你完成一个模块，休息一下。做些别的事情，然后回来看看你的代码。你会惊讶地发现，你可以很容易地找到前一阵子从未想到过的错误和优化。这也适用于你被困在某件事情上的时候。
2. ****同行评审:不同的视角总能帮到你，有时候，仅仅通过向别人解释你的代码，你就能想出更好的点子。想大声点！

8.不要对你的代码感情用事！

当你花大量时间头脑风暴、学习新技术、解决大量边角案例、代码优化等。为了创造一个解决方案，你倾向于依赖它，因为它是由你的创造力和智慧创造的。

当然，这种激情和创造力会让你写出更好的代码，解决复杂的挑战，但也有一些缺点。有时候，完美主义会适得其反。

1. 你继续向你的客户过度解释你的算法之美，而客户并不真正关心这些。
2. 在不断发展的业务场景中，任何事情都可能在一天之内发生变化。你会被要求放下去年一直在做的事情，开始一个新的项目，而执着于你的代码会让这变得困难。
3. 你得到过度保护** 你的代码，失去客观性，认为不可能出错。**

这听起来可能很傻，但这是一件真实的事情，即使在这个行业工作了三年多，我有时仍会为此而挣扎。

9.完美只能追求

最后，接受一个事实，完美是无法达到的，只能追求。不管你觉得今天写的代码有多好，如果一个月后再看，你可以想出很多方法来改进它。就像那个迷因，

我，一个知识分子，评判犯同样错误的人，我最近学会停止犯

但是如果你追求完美，你就会达到卓越。只要你玩得开心，就要坚持学习！

10.结论

我们在这个博客中讨论的大多数观点不仅适用于编码，也适用于生活。正如史蒂夫·乔布斯所说，

每个人都应该学会给电脑编程，因为它教会你如何思考

——乔布斯

事实上，我也是遵循这些原则来完成这篇文章的！

感谢您花宝贵的时间阅读我的哲学；我希望你能从中受益:)

您可以在sreekiranar@gmail.com给我反馈和建议，或者在 LinkedIn 上联系我。你也可以看看我的 GitHub 和stack overflow。****

快乐编码！😄

判断实证论文优劣的 10 条戒律

原文：https://towardsdatascience.com/10-commandments-for-judging-the-merits-of-an-empirical-paper-862100b6b32d?source=collection_archive---------55-----------------------

审查人员通用指南

来源

有许多与当前同行评议制度相关的病态问题已经成为许多讨论的主题。最实质性的问题之一是，在主要期刊上报道的结果通常是具有最令人兴奋和最有新闻价值的发现的论文。这里的问题是，对一些人来说可能是新奇的和有新闻价值的东西，对其他人来说可能是过分的，其有效性值得怀疑。研究设计中的各种问题，如小样本和赢家诅咒、多重比较和选择性报告结果，往往有助于发表有效性存疑的“性感”发现。

幸运的是，这些问题已经成为所有学科的科学家们进行大量讨论和自我反思的主题。虽然职业激励可能会导致研究人员为了发布令人兴奋的发现而对他们的分析漫不经心，但最常见的问题是错误信息加上认知偏差的结果，例如确认偏差，我们都容易受到影响(例如，我们往往只看到我们想看到的证据)，而不是任何渎职行为。最终，我觉得这在很大程度上是统计教育的问题，更普遍的问题是专注于教授一种技术，而不是面向问题的技能组合，没有适当关注批判性思维技能。当然，毕业后我可以做各种各样的分析技术，而不需要真正理解我在做什么！

这一领域的大部分焦点正确地集中在试图让研究人员改变他们的行为，在介绍他们的方法时更加反思和透明。较少关注审稿人和编辑的行为。评论者应该注意什么？很难区分新颖但有效的结果和有效性有问题的结果，特别是对于那些没有大量数据处理经验的人。这个博客试图提供一些通用规则来指导评论者。

特别是，本着应用计量经济学的深刻而吸引人的 10 条戒律，我为评论者准备了 10 条戒律。这不是一份详尽的清单，也不是一份完整的清单，主要针对的是经验性的而不是纯理论的论文。研究人员如何组织和撰写论文的一个主要动机(如果不是主要动机的话)是，他们遵循的方法是他们认为最有可能被编辑/审稿人视为可发表的论文。研究人员会对激励做出反应，我建议，如果评审人员遵循这些简单的步骤，我们就可以改变“游戏规则”，因此，最终会改变提交实践和行为。

1.对不确定性持更开放的态度:至少在我的经验中，评论者更喜欢关于因果关系的强有力的陈述，但事情并不总是非黑即白的。作者应该可以(甚至被鼓励)展示他们的发现作为提示，承认局限性并提出未来需要做的工作。然而，评论家们越来越需要的是可靠的确定性。通常，研究人员的目的是证明估计效果的“证据”,并通过一系列稳健性检查证明没有其他可能的替代解释。这反过来会导致作者夸大他们的发现，因为害怕如果他们更谨慎的话会受到评论者的惩罚。

2.更能接受小的/适度的效应大小:并不是每项研究都会证明关键感兴趣变量的变化会导致研究结果的巨大变化。事实上，大多数人不会或至少不应该这么做。研究逐步进行，要求大的效果尺寸是不现实的。这里的主要问题是，效应大小通常可以以多种不同的方式呈现，这种预期扭曲了激励，因此作者可以找到创造性的方式来呈现他们估计的“大”效应。虽然出版不应依赖于展示大的效应尺寸，但效应尺寸也不应小到微不足道。统计显著性应该是不够的，除了关于效应大小的实际大小的报告的问题之外，一个同样成问题的问题是相对常见的是根本不努力报告效应大小。这也是审稿人应该劝阻的。

3.不要被复杂性所迷惑 : 计量经济学的复杂性不应该被误认为是严谨的。简单的分析通常不仅更容易理解和交流，而且不太可能导致严重的错误或失误。如果需要复杂的模型，那么要确保研究人员展示了所有必要的细节，以便“技术细节”能够容易理解。一些根据上下文谨慎提问的例子可能包括:简单的二元关系看起来像什么？即使没有看起来有些奇怪的功能规范，结果还成立吗？在添加控制变量之前，与对照组的处理进行简单比较，结果看起来像什么？

4.作为上述方法的自然延伸，应用笑声测试:应用 Kennedy (2002) 所称的“笑声”测试，或者 Hamermesh (2000，第 374 页)所称的“嗅嗅”测试:“问问自己，如果向一个深思熟虑的外行人仔细解释这些发现，听众是否能避免大笑”。有时，如果结果看起来好得令人难以置信，那么事实往往就是如此。这在低功效研究(小样本)中尤其如此，因为看似意外/新颖的发现往往只是噪声数据集中的随机波动，不太可能是可再现的效果。

5.问正确的问题:我发现自己经常问的一些潜在有用的问题包括:对为什么只在特定的小组或特定的情况下观察到结果的解释是否可信？与这一点相关的是，我经常问自己，给出的解释是否符合结果(观察数据本来就有噪音！)或者作者事先有这些前科是否合理。采用看似更明智的不同程序是否会对实质性结果产生重大影响？这可能包括函数形式的改变或控制变量的选择。我想强调的是，这些问题不应该被设计成“零黑客”调查结果(也考虑这里的第 10 点)，而是对分析的合理程度和结论是否有根据有一个总体感觉。

6.不要被稳健性检查所迷惑，也不要要求太多:稳健性检查可能很重要，但不应该让你相信主要发现的真实性。也许还值得注意的是，从作者的角度来看，建议额外的健壮性检查可能会增加大量时间，但通常不会带来额外的好处。

7.不要歧视 : 根据研究的优点来判断研究，而不是根据它是否是你喜欢的主题或来自知名研究人员或研究所。出版偏见是这样的，做仔细和深思熟虑的研究的人可能不总是有大“声誉”的人。

8.与上述观点相关的还有一个针对编辑的观点不要根据报道结果的新闻价值来拒绝。

9.警惕浮夸的陈述，晦涩的语言或抽象的理论框架。

10.不要纠结于 p 值:据美国统计协会报道，“一个结论不会立刻在分界线的一边变成‘真’而在另一边变成‘假’”。一个 p 值和一个估计的效应大小传递了一些有用的信息，但它不应该是全部。正如美国儿科学会的声明所总结的那样，“没有一个单一的指标可以替代科学推理。”就个人而言，在判断一篇论文的科学价值时，我会寻找许多东西(其中许多在上面讨论过)，但实际报告的 p 值，无论是 0.01 还是 0.10，都远远低于列表。

每个数据科学家都应该知道的 10 个概念

原文：https://towardsdatascience.com/10-concepts-every-data-scientist-should-know-70beddcd4ac2?source=collection_archive---------22-----------------------

面试中可能遇到的概念。

泰勒·凯西在 Unsplash 上的照片

数据科学是一个如此广阔的领域。如果这是一个食谱，主要成分将是线性代数，统计学，软件，分析技能，讲故事，所有与一些领域知识的经验丰富。配料的数量根据你所做的工作而变化。

作为一名数据科学家，无论您做什么，都有一些术语和概念您绝对应该熟悉。在这篇文章中，我将介绍其中的 10 个概念。请注意，这篇文章的目的绝不是要列出你需要知道的所有话题。然而，了解以下概念绝对会增加你的技能组合的价值，并在你的旅程中帮助你学习更多。

我们开始吧。

1。中心极限定理

我们首先需要引入正态(高斯)分布让中心极限定理有意义。正态分布是一种看起来像钟的概率分布:

x 轴代表数值，y 轴代表观察这些数值的概率。正态分布用于表示分布未知的随机变量。因此，它被广泛应用于包括自然科学和社会科学在内的许多领域。证明为什么它可以用来表示未知分布的随机变量的理由是中心极限定理(CLT) 。

根据 CLT ，当我们从一个分布中抽取更多样本时，样本平均值将趋向于一个正态分布，而不管总体分布如何。

考虑一个案例，我们需要学习一个国家所有 20 岁人的身高分布。收集这些数据几乎是不可能的，当然也是不切实际的。所以，我们在全国范围内抽取 20 岁人群的样本，计算样本中人群的平均身高。根据 CLT，当我们从总体中抽取更多样本时，抽样分布将接近正态分布。

为什么正态分布如此重要？正态分布用平均值和标准偏差来描述，它们很容易计算。如果我们知道正态分布的均值和标准差，我们就可以计算出关于它的几乎所有东西。

2。p 值

P 值是获得我们的观察值或有相同或较少机会被观察的值的概率。考虑随机变量 a 的以下概率分布。很可能观察到 10 左右的值。随着值变得更高或更低，概率降低。

我们有另一个随机变量 B，想看看 B 是否大于 a，从 B 得到的平均样本均值是 12.5。12.5 的 p 值是下图中的绿色区域。绿色区域表示获得 12.5 或更极端值(在我们的例子中高于 12.5)的概率。

假设 p 值是 0.11，但是我们如何解释它呢？p 值为 0.11 意味着我们对结果有 89%的把握。换句话说，有 11%的概率结果是随机的。类似地，p 值为 0.5 意味着有 5%的概率结果是随机的。

p 值越低，结果越确定。

如果随机变量 B 的样本平均值是 15，这是一个更极端的值，p 值将低于 0.11。

3。偏差—方差权衡

偏差发生在我们试图用一个简单得多的模型来近似一个复杂或错综复杂的关系的时候。我认为它是一个懒惰的模型。考虑一种情况，其中自变量(特征)和因变量(目标)之间的关系非常复杂并且是非线性的。但是，我们尝试使用线性回归建立一个模型。在这种情况下，即使我们有数百万个训练样本，我们也无法建立准确的模型。通过使用简单的模型，我们限制了性能。不能反映特征和目标之间的真实关系。偏高的型号倾向于欠配。

方差发生在模型对自变量(特征)的变化高度敏感的时候。该模型试图选取关于特征和目标之间关系的每个细节。它甚至学习数据中可能随机出现的噪声。特征中非常小的变化可能会改变模型的预测。因此，我们最终得到了一个模型，它捕获了训练集的每一个细节，因此训练集的准确性将非常高。然而，新的、以前未见过的样本的准确性不会很好，因为特征中总是存在不同的变化。这种情况也被称为过拟合。该模型过度适应训练数据，但未能很好地概括数据集内的实际关系。

所以高偏差和高方差都不好。完美的模型是低偏差和低方差的模型。然而，完美的模型很难找到，如果可能的话。偏差和方差之间有一个权衡。我们应该力求在它们之间找到恰当的平衡。作为一名机器学习工程师，成功的关键是掌握在偏差和方差之间找到正确的平衡。

4。L1 和 L2 正规化

过拟合是数据科学领域中的一个重要问题，需要小心处理，以便建立一个健壮和准确的模型。当模型试图很好地拟合训练数据，以至于不能推广到新的观察结果时，就会出现过度拟合。过度拟合模型捕捉训练数据中的细节和噪声，而不是总体趋势。

过度拟合问题的解决方案是降低模型复杂度。例如，如果我们有一个多项式模型，我们可以通过减少自由度来降低模型的复杂性。多项式模型是非线性的。对于线性模型，我们需要另一种正则化技术，即正则化。

正则化通过惩罚模型中较高的项来控制模型的复杂性。如果增加一个正则项，该模型试图最小化损失和模型的复杂性。

L1 正规化

它也被称为针对稀疏性的正则化。顾名思义，它用于处理主要由零组成的稀疏向量。稀疏向量通常导致非常高维的特征向量空间。因此，模型变得很难处理。

L1 正则化通过在每次迭代中从权重中减去一个小的量来强制无信息特征的权重为零，从而最终使权重为零。

L1 正则化惩罚|权重|。

L2 正规化

为了简单性它也被称为正则化。如果我们把模型的复杂度作为权重的函数，那么特征的复杂度与它的权重的绝对值成正比。

L2 正则化迫使权重趋向于零，但并不使它们完全为零。L2 正则化就像在每次迭代中去除一小部分权重的力。因此，权重永远不会等于零。

L2 正则化惩罚(权重)

注: 岭回归使用 L2 正则化，而拉索回归使用 L1 正则化。弹性网回归结合了 L1 和 L2 正则化。

5。维度的诅咒

简而言之，维数灾难意味着有太多的特征。更多的数据是好的，但是如果数据结构良好。如果我们有许多特征(列)但没有足够的观察值(行)来处理，那么我们就有问题了。

拥有许多特征但没有足够的观察值会导致过度拟合。正如预期的那样，该模型捕捉了数据集中的观察细节，而不是概括要素和目标之间的真实关系。

当我们试图对观察结果进行聚类时，会出现另一个缺点。聚类算法使用距离度量。拥有太多的特征会导致观测值之间的距离非常相似，因此很难将观测值分组到聚类中。

维数灾难的一个解决方案是通过保持特征数量不变来收集更多的观测值(行)。然而，这将是耗时的，并且不总是可行的。此外，它会给模型增加额外的计算负担。更好的解决方案是使用一种降维算法，比如 PCA。降维是通过从现有特征中提取新特征来减少特征的数量，目的是保持数据集中的方差。

6。装袋增压

在机器学习领域，通过组合许多基本估计器(即算法)来设计集合学习方法。例如，随机森林是通过组合几个决策树创建的集成学习算法。打包和提升是组合基本估计量的两种不同方法。

Bagging 的意思是集合几个弱学习者的预测。我们可以把它想成平行结合弱学习者。将几个弱学习者的预测平均值作为整体预测。

随机森林创建与装袋许多决策树

Boosting 就是把系列的几个弱学习者组合起来。我们最终从许多顺序连接的弱学习者中得到一个强学习者。梯度增强决策树(GBDT)是最常用的集成学习算法之一。像在随机森林中一样，GBDT 中的弱学习器(或基估计器)是决策树。

GBDT 创建了许多决策树

7。熵和信息增益

熵是不确定性或随机性的度量。一个变量的随机性越大，熵就越大。均匀分布的变量具有最高的熵。例如，掷一个公平的骰子有 6 个概率相等的可能结果，所以它有均匀的分布和高熵。

熵 vs 随机性

在处理决策树时，我们很可能会遇到熵和信息增益。它们是算法决定拆分时的决定性因素。选择导致更纯节点的分裂。这些都表示“信息增益”，基本上就是分裂前后的熵差。

当选择一个特征进行分割时，决策树算法试图实现

• 更多的预测
• 杂质少
• 低熵

8。精度和召回

精确度和召回率是用于评估分类模型的度量。在描述这些指标之前，最好先解释一下混淆矩阵。

混淆矩阵显示了每个类别的正确和错误(即真或假)预测。在二进制分类任务的情况下，混淆矩阵是 2×2 矩阵。如果有三个不同的类，那就是一个 3x3 的矩阵，以此类推。

假设 A 类是正类，B 类是负类。混淆矩阵的关键术语如下:

• 真阳性(TP) :预测阳性类别为阳性(ok)
• 假阳性(FP) :将阴性类别预测为阳性(不正常)
• 假阴性(FN) :将阳性类别预测为阴性(不正常)
• 真阴性(TN) :预测阴性类别为阴性(ok)

精度表示有多少正面预测是正确的。精度的焦点是正面预测。

Recall 表示模型能够正确预测多少个阳性类别。召回的重点是实际正班。

9.ROC 曲线和 AUC

ROC(接收器工作特性)曲线通过组合所有阈值处的混淆矩阵来总结分类模型的性能。ROC 曲线的 x 轴是真阳性率(灵敏度)，ROC 曲线的 y 轴是假阳性率(1-特异性)。

图源

如果阈值设置为 0，模型将所有样本预测为阳性。在这种情况下，TPR(灵敏度)为 1。然而，FPR(1-特异性)也是 1，因为没有阴性预测。如果阈值设置为 1，TPR 和 FPR 都变为 0。因此，将阈值设置为 0 或 1 不是一个好的选择。

我们的目标是提高真阳性率(TPR ),同时保持低假阳性率(FPR)。正如我们在 ROC 曲线上看到的，随着 TPR 增加，FPR 也增加。所以最终决定了我们能容忍多少假阳性。

我们可以使用另一个称为 AUC (曲线下面积)的指标，而不是试图在 ROC 曲线上找到最佳阈值。AUC 是介于(0，0)和(1，1)之间的 ROC 曲线下的面积，其可以使用积分来计算。AUC 基本上汇总了模型在所有阈值的表现。AUC 的最佳可能值是 1，这表示一个完美的分类器。AUC 越接近 1，分类器越好。在下图中，分类器 A 比分类器 b 好。

图来源

10。朴素贝叶斯分类器的假设

与其他监督学习算法一样，朴素贝叶斯使用特征对目标变量进行预测。关键区别在于，朴素贝叶斯假设特征是相互独立的，特征之间没有相关性。然而，现实生活中并非如此。这种特征不相关的天真假设是这种算法被称为“天真”的原因。

所有特征都是独立的假设使得朴素贝叶斯算法比复杂算法更快。在某些情况下，速度优先于更高的精度。它可以很好地处理文本分类和垃圾邮件检测等高维数据。

感谢您的阅读。如果您有任何反馈，请告诉我。

10 种配置让您的 Kafka Producer 更具弹性

原文：https://towardsdatascience.com/10-configs-to-make-your-kafka-producer-more-resilient-ec6903c63e3f?source=collection_archive---------4-----------------------

让你的卡夫卡制作人更上一层楼

詹姆斯·庞德在 Unsplash 上拍摄的照片

afka 以其弹性、容错和高吞吐量而闻名。但是它的表现并不总是符合所有人的预期。在某些情况下，我们可以通过横向扩展或纵向扩展代理来改进它。而在大多数情况下，我们不得不玩配置的游戏。

卡夫卡生态系统里真的有吨的配置。几乎不可能掌握每一种配置的想法。一方面，它们无疑使系统更加灵活，但另一方面，开发人员可能会对如何使用它们感到非常困惑。

幸运的是，大多数配置都是预先定义好的，在大多数情况下都能很好地工作。首先，他们需要了解的强制性配置非常有限。

但是当然，我假设你正在读这篇文章，因为你想把你的卡夫卡制作人带到一个新的水平。因此，在这篇文章中，我想分享 10 个配置，我认为它们对提高生产商的适应能力非常重要。

本文将要讨论的配置有acks、replica.lag.time.max.ms、min.insync.replicas、retries、enable.idempotent、max.in.flight.requests.per.connection、buffer.memory、max.block.ms、linger.ms、batch.size。

ack(确认)

ack 是生产者从 Kafka 代理那里得到的确认，以确保消息已经成功提交给该代理。config acks是生产者在考虑成功提交之前需要接收的确认数量。

ack=1 和 ack=all 的区别，高创造

默认值为 1，这意味着只要生产者收到来自该主题的主代理的 ack，它就会将其视为成功的提交，并继续处理下一条消息。不建议设置acks=0，因为那样你在提交上没有任何保证。acks=all将确保生产者从该主题的所有同步副本中获得确认。它提供了最强的消息持久性，但也需要很长时间，从而导致更高的延迟。所以，你需要决定什么对你更重要。

同步副本

acks=all会从所有的同步副本(ISR)那里得到确认，那么什么是同步副本呢？创建主题时，必须定义想要多少个副本。副本只不过是其中一个代理中消息的副本，因此副本的最大数量就是代理的数量。

在这些复制品中，有一个领导者，其余的都是追随者。领导者处理所有的读写请求，而从者被动地复制领导者。同步副本是在最后 10 秒完全赶上领先的副本。时间段可以通过replica.lag.time.max.ms进行配置。如果某个代理出现故障或出现网络问题，那么他就无法与负责人联系，10 秒钟后，该代理就会从 ISR 中删除。

默认最小同步副本(min.insync.replicas)为 1。这意味着，如果所有的追随者都倒下了，那么 ISR 就只剩下领导者了。即使acks设置为 all，它实际上只将消息提交给 1 个代理(领导者),这使得消息容易受到攻击。

由高创建的不同最小同步副本之间的差异

配置min.insync.replicas基本上定义了生产者在考虑成功提交之前必须接收多少副本。这个配置添加在acks=all之上，使你的消息更加安全。但另一方面，你必须平衡延迟和速度。

失败时重试

假设你设置了acks=all和min.insync.replicas=2。出于某种原因，跟随者完成了，然后生产者识别出一个失败的提交，因为它不能从min.insync.replicas代理那里得到确认。

您将收到来自生成器的错误消息:

KafkaError{code=NOT_ENOUGH_REPLICAS,val=19,str="Broker: Not enough in-sync replicas"}

您将看到来自正在运行的代理的以下错误消息。这意味着，即使代理正在运行，如果当前的 ISR 不足，Kafka 也不会将消息附加到正在运行的代理。

ERROR [ReplicaManager broker=0] Error processing append operation on partition test-2-2-0 (kafka.server.ReplicaManager)
org.apache.kafka.common.errors.NotEnoughReplicasException: The size of the current ISR Set(0) is insufficient to satisfy the min.isr requirement of 2 for partition test-2-2-0

默认情况下，生成器不会处理这个错误，因此会丢失消息。这被称为最多一次语义。但是您可以通过配置retries=n让生产者重新发送消息。这基本上是提交失败时生成器可以重试的最大次数。默认值为 0。

由高创建的重试次数=0 和重试次数> 0 之差

如果您设置了retries=5，那么生产者将最多重试 5 次。您不会注意到生成器日志中的重试次数，因为它只显示提交最终是否成功。但是你可以在代理端看到retries+1日志消息。

避免重复的消息

在某些情况下，消息实际上已提交给所有同步副本，但由于网络问题(例如，只允许单向通信)，代理无法发回 ack。同时，我们设置retries=3，然后生产者将重新发送消息 3 次。这可能会导致主题中出现重复的消息。

假设我们有一个向主题发送 100 万条消息的生产者，在消息提交后但生产者收到所有 ack 之前，代理失败。在这种情况下，我们可能会收到超过 100 万条关于这个话题的消息。这也被称为一次性租赁语义。

最理想的情况是恰好一次语义，在这种情况下，即使生产者重新发送消息，消费者也应该只收到一次相同的消息。

我们需要的是一个幂等生产者。 幂等是指一个操作应用一次或者应用多次效果相同。用配置enable.idempotent=true很容易打开这个特性。

它是如何工作的？消息是分批发送的，每批都有一个序列号。在代理端，它跟踪每个分区的最大序列号。如果一个具有较小或相等序列号的批次进入，代理不会将该批次写入主题。这样，也保证了批次的顺序。

高创造的禁用幂等元和启用幂等元的区别

按顺序发送消息

保证顺序的另一个重要配置是max.in.flight.requests.per.connection，默认值是 5。这表示可以在生成器端缓冲的未确认请求的数量。如果retries大于 1，并且第一个请求失败，但是第二个请求成功，那么第一个请求将被重新发送，并且消息将处于错误的顺序。

根据文档:

请注意，如果此设置设置为大于 1，并且发送失败，则存在由于重试(即，如果启用重试)而导致消息重新排序的风险。

如果您没有启用幂等，但是仍然希望保持消息有序，那么您应该将该设置配置为 1。

但是如果您已经启用了幂等，那么您就不需要显式定义这个配置。卡夫卡会选择合适的价值观，如这里所说的。

如果用户没有明确设置这些值，将选择合适的值。如果设置了不兼容的值，将抛出一个ConfigException。

发送消息太快

当生产者调用send()时，消息不会立即发送，而是添加到内部缓冲区。默认的buffer.memory是 32MB。如果生产者发送消息的速度比发送给代理的速度快，或者出现了网络问题，那么超过了buffer.memory，那么send()调用将被阻塞到max.block.ms(默认为 1 分钟)。

buffer.memory 和 max.block.ms 由高创建

增加这两个值可以缓解这个问题。

另外两个可以玩的配置是linger.ms和batch.size。linger.ms是批次准备发送前的延迟时间。默认值为 0，这意味着即使批处理中只有一条消息，也会立即发送批处理。有时候，人们增加linger.ms来减少请求的数量，提高吞吐量。但是这将导致更多的消息保存在内存中。所以，确保你照顾到双方。

还有一个和linger.ms相当的配置，就是batch.size。这是单批的最大数量。当满足这两个要求中的任何一个时，将发送批次。

结论

以下是我认为可以让你的卡夫卡制作人更有弹性的 10 个配置。当然，它们不是您需要注意的唯一配置，但这可能是一个很好的起点。请务必阅读官方 Apache Kafka 文档以获得可靠的参考。

如果你有任何其他想法，请在下面留下你的评论。保重！

参考

[## 阿帕奇卡夫卡中的同步副本到底是什么意思？- CloudKarafka，阿帕奇卡夫卡留言…

Kafka 认为，当同步副本集(ISR)中的所有副本都确认它们…

www.cloudkarafka.com](https://www.cloudkarafka.com/blog/2019-09-28-what-does-in-sync-in-apache-kafka-really-mean.html) [## 恰好一次语义是可能的:下面是阿帕奇卡夫卡如何做到这一点

我很高兴我们达到了 Apache Kafkaand 社区期待已久的激动人心的里程碑:我们已经…

www.confluent.io](https://www.confluent.io/blog/exactly-once-semantics-are-possible-heres-how-apache-kafka-does-it/)

给 Python 开发者的 10 个很酷的 Python 项目想法

原文：https://towardsdatascience.com/10-cool-python-project-ideas-for-python-developers-7953047e203?source=collection_archive---------0-----------------------

您可以使用 Python 构建的有趣想法和项目列表

来自 Pexels 的 Andrea Piacquadio 的照片

编写 Python 代码的乐趣应该在于看到短小、简洁、易读的类，这些类用少量清晰的代码表达了大量的动作——而不是让读者厌烦得要死的大量琐碎代码。

吉多·范·罗苏姆

Python 是世界上使用最多的编程语言之一，这可以归功于它的通用性质，这使它成为行业中各个领域的合适候选。使用 Python，你不仅可以为 web 开发程序，还可以为桌面和命令行开发程序。Python 可以适合不同技能水平的程序员，从学生到中级开发人员，再到专家和专业人员。但是每一种编程语言都需要不断的学习，Python 也是如此。

如果你真的想获得深入的实践知识，没有比从事一些很酷的项目更好的方法来使用 Python 了，这些项目不仅能让你在空闲时间有所事事，还能教会你如何更好地使用 Python。

你知道吗？

根据 Stackoverflow 的说法，python 是最受欢迎的语言，这意味着大多数开发人员都使用 Python。

[## 2020 年大一新生热门 Python 面试问答

这里列出了大一新生最常被问到的 python 面试问题和答案，涵盖了核心…

blog.digitalogy.co](https://blog.digitalogy.co/python-interview-questions-and-answers-for-freshers/)

选择项目平台

Python 在合适的人手里可以是一种非常通用的编程语言，你可以用它构建许多漂亮的程序来加强你对这种语言的掌握。与理论知识相比，更多地接触实践知识是至关重要的，尤其是在学习编程语言(如 Python)时。

但是在我们开始我们为你准备的有趣的项目之前，你必须决定你将在哪个平台上工作。本文提及的项目平台可分为以下三类:

● 网页

构建一个 web 应用程序允许你和其他人通过互联网从任何地方访问它。为此，您需要在应用程序的前端、可视部分和后端工作，在那里实现业务逻辑。工具&框架比如 Django 、 烧瓶 和 Web2Py 是你可以使用的许多选项中的一些。

● 桌面 GUI

桌面应用程序也非常普遍，并且迎合了相当大一部分用户的需求。当涉及到构建桌面应用程序时，Python 使得使用其 PySimpleGUI 包开发桌面应用程序变得非常容易，这允许您使用 Python 构建所有必要的元素。框架 PyQt5 也提供了高级的 GUI 构建元素，但是有一个更陡峭的学习曲线。

● 命令行

命令行程序只能在控制台窗口中运行，根本没有 GUI。用户交互是通过命令进行的，这是最古老的与程序交互的方法，但是不要把它缺少 GUI 误认为它没有用处。数百家顶级企业依赖命令行程序来执行其日常业务活动。构建命令行程序，可以使用 docopt ，Python Fire，plac，以及** cliff 等工具。**

“Python 从一开始就是 Google 的重要组成部分，并且随着系统的成长和发展而保持不变。如今，数十名谷歌工程师使用 Python，我们正在寻找更多掌握这种语言的人。”

——彼得·诺维格，谷歌公司搜索质量总监

** [## 10 家使用 Python 的世界级公司

Python 正被 IT 界的一些巨头积极使用

towardsdatascience.com](/10-world-class-companies-using-python-26cde24919a8)**

Python 开发者的 Python 项目理念

如果您已经决定了要使用的平台，让我们直接进入项目。下面提到的是一些面向所有技能水平的开发人员的有趣项目，这些项目将在将他们的 Python 技能和信心提升到下一个水平方面起到至关重要的作用。

1。内容聚合器

在 Unsplash 上奥比·奥尼耶多尔的照片

对于总是在网上寻找东西的数百万人来说，互联网是主要的信息来源。对于那些寻找特定主题的大量信息的人来说，使用内容聚合器可以节省时间。

内容聚合器是一种工具，它从一个地方的大量网站中收集并提供关于某个主题的信息。要制作一个，您可以借助 requests 库来处理 HTTP 请求，借助beautiful soup来解析和抓取所需的信息，并借助一个数据库来保存收集到的信息。

内容聚合器的例子:

• AllTop
• 赫普

2。网址缩写

URL 是导航到互联网上任何资源的主要来源，无论是网页还是文件，有时，其中一些 URL 可能非常大，带有奇怪的字符。URL 缩写在减少这些 URL 中的字符并使它们更容易记忆和使用方面起着重要的作用。

制作 URL 缩短器的想法是使用随机和字符串模块从输入的长 URL 生成一个新的短 URL。一旦你完成了，你就需要映射长 URL 和短 URL，并将它们存储在数据库中，以允许用户将来使用它们。

网址缩写示例—

• bit.ly
• TinyURL

这里是免费参加课程的链接:——

** [## 免费 Django 教程-尝试 Django 1.10 |创建一个 URL 缩短服务

这一切都始于一个想法。我想要自由...很糟糕。从工作中解脱，从无聊中解脱，最重要的是…

www.udemy.com](https://www.udemy.com/course/try-django-1-10/)

3.文件重命名工具

照片由来自 Pexels 的 Brett Sayles 拍摄

如果您的工作需要您经常管理大量文件，那么使用文件重命名工具可以节省您大量的时间。它的基本功能是使用一个定义好的初始标识符来重命名数百个文件，这个标识符可以在代码中定义，也可以从用户那里获得。

为此，您可以使用 Python 中的库，如 sys 、 shutil 和os 来即时重命名文件。要实现向文件添加自定义初始标识符的选项，您可以使用正则表达式库 来匹配文件的命名模式。

批量文件重命名工具示例—

• 任
• 重命名

[## 用于自然语言处理的 Python 库

用于自然语言处理的流行 python 库概述

towardsdatascience.com](/python-libraries-for-natural-language-processing-be0e5a35dd64)

4.目录树生成器

目录树生成器是一种工具，您可以在希望可视化系统中的所有目录并确定它们之间的关系的情况下使用。目录树本质上指示的是哪个目录是父目录，哪个是它的子目录。如果您处理大量目录，并且希望分析它们的位置，像这样的工具会很有帮助。为了构建这个，你可以使用 os 库 列出文件和目录以及 docopt 框架。

目录树生成器示例—

• 树
• Dirtreex

5. MP3 播放器

照片由稍微有用的在 Unsplash 上拍摄

如果你喜欢听音乐，你会惊讶地发现你可以用 Python 来构建一个音乐播放器。您可以构建一个带有图形界面的 mp3 播放器，该播放器带有一组用于播放的基本控件，甚至可以显示集成的媒体信息，如艺术家、媒体长度、专辑名称等。

您还可以选择导航到文件夹并为您的音乐播放器搜索 mp3 文件。为了使在 Python 中处理媒体文件更容易，可以使用simple audio、 pymedia 和 pygame 库。

MP3 播放器示例—

• 音乐蜜蜂
• Foobar2000

6.井字游戏****

井字游戏是一个经典游戏，我们相信你们每个人都很熟悉。这是一个简单有趣的游戏，只需要两个玩家。目标是在一个 3x3 的网格上创建一条由三个 x 或 o 组成的不间断的水平、垂直或对角线，谁先完成，谁就是游戏的赢家。像这样的项目可以使用 Python 的 pygame 库 ，它带有所有需要的图形和音频，让你开始构建这样的东西。

图片来自 Pixabay

这里有几个教程你可以试试:

• https://techvidvan . com/tutorials/python-game-project-TIC-tac-toe/
• 用 Python 制作游戏& Pygame
• 用 Pygame 开发游戏

游戏开发中更有趣的 Python 项目:

• 蛇
• 刽子手
• 猜谜游戏
• 石头剪刀布
• dPython 中的滚冰模拟器

7.测验应用程序

使用 Python 可以构建的另一个流行而有趣的项目是一个测验应用程序。一个流行的例子是 卡豪特，，它因使学习成为学生们的一项有趣活动而闻名。该应用程序提供了一系列具有多个选项的问题，并要求用户选择一个选项，稍后，该应用程序会显示正确的选项。

作为开发人员，您还可以创建功能来添加任何需要的问题以及要在测验中使用的答案。要制作一个测验应用程序，您需要使用一个数据库来存储所有的问题、选项、正确答案和用户分数。

问答应用示例—

• 卡胡特
• 我的测验

了解最好的 Python IDEs 和代码编辑器—

** [## 2020 年你必须使用的最好的 Python IDEs 和代码编辑器

具有显著特性的顶级 Python IDEs 和代码编辑器

towardsdatascience.com](/best-python-ides-and-code-editors-you-must-use-in-2020-2303a53db24)

8.计算器

照片由爱德华多·罗萨斯从 Pexels 拍摄

当然，任何人都不应该错过在学习新的编程语言的同时开发计算器的古老想法，即使只是为了好玩。我们相信你们都知道什么是计算器，如果你已经尝试过，你可以尝试用一个更好的 GUI 来增强它，使它更接近今天操作系统的现代版本 T21。为了实现这一点，您可以使用 tkinter 包来将 GUI 元素添加到您的项目中。

9.打造虚拟助手

由本斯·博罗斯在 Unsplash 拍摄的照片

如今，几乎每部智能手机都有自己的智能助手版本，可以通过语音或文本接收你的命令，管理你的电话、笔记、预订出租车等等。这方面的一些例子有谷歌助手、Alexa、Cortana 和 Siri 。如果你想知道如何制作这样的东西，你可以使用诸如speecher recognitiongTTS、 和 Wikipedia 之类的软件包。这里的目标是记录音频，将音频转换为文本，处理命令，并使程序根据命令进行操作。

这是免费参加课程的链接—

**** [## 免费 Python 教程-学习 Python:构建虚拟助手

我是一个自学的程序员和学习爱好者。我的专长主要是人工智能，Ruby on Rails…

www.udemy.com](https://www.udemy.com/course/learn-python-build-a-virtual-assistant-in-python/?LSNPUBID=JVFxdTr9V80&ranEAID=JVFxdTr9V80&ranMID=39197&ranSiteID=JVFxdTr9V80-l6XGdgLohub6YYv8_fu5pA&utm_medium=udemyads&utm_source=aff-campaign)

10.货币转换器

顾名思义，这个项目包括构建一个货币转换器，允许您以基础货币输入所需的值，并以目标货币返回转换后的值。一个好的做法是对从互联网获取更新的转换率的能力进行编码，以获得更准确的转换。为此，您也可以使用 tkinter 包来构建 GUI。****

更多的 Python 项目想法要建立—

• 用 Django 构建一个简单的网页
• 密码生成器
• 制作一个推特机器人
• 年龄和性别检测
• 乳腺癌分类
• 驾驶员睡意检测
• 语音情感识别
• 用 Python 创建加密应用
• Python 中的速度打字测试
• 用 Python 检测所有假新闻
• Python 中的网络爬虫
• Python 中的剽窃检查器
• Python 文件浏览器
• 闹钟
• 一款实时价格提醒应用
• 站点连接检查器
• 正则表达式查询工具
• 费用跟踪器
• Youtube 视频下载程序

结论

总结我们列出的一些有趣的想法和可以使用 Python 构建的项目，我们可以说 Python 是一种非常有用的编程语言，可以用来开发各种类型和规模的应用程序。此外，Python 提供的包在很大程度上简化了开发过程，为开发人员提供了巨大的价值。总结一下，我们想说 Python 的潜力是无限的，您可能缺少的唯一东西就是正确的想法。

如果你有更多的建议或想法，我们很乐意倾听。

更多有趣的读物

我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢

**** [## 面向所有人的顶级谷歌人工智能工具

使用谷歌人工智能中心将想法变为现实

towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## Python vs. Node。JS:哪个最适合你的项目？

使用一组预定义的因素对 Python 和 Node.js 进行详细比较

towardsdatascience.com](/python-vs-node-js-which-one-is-best-for-your-project-e98f2c63f020) [## 面向数据科学的顶级 Python 库

面向数据科学的流行 Python 库概述

towardsdatascience.com](/top-python-libraries-for-data-science-c226dc74999b) [## 机器学习和深度学习的最佳 Python 库

现代机器学习模型和项目的 Python 库

towardsdatascience.com](/best-python-libraries-for-machine-learning-and-deep-learning-b0bd40c7e8c)

关于作者

克莱尔 D 。是位于Digitalogy—的内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在LinkedinTwitterinsta gram上连接Digitalogy*。***********

Python 开发者的 10 个疯狂的酷项目创意

原文：https://towardsdatascience.com/10-crazy-cool-project-ideas-for-python-developers-d7efeb0a345?source=collection_archive---------9-----------------------

PYTHON 编程

挑战您的 Python 技能的疯狂项目想法

西蒙·艾布拉姆斯在 Unsplash 上拍摄的照片

你知道 Python 被称为全能编程语言吗？

是的，的确如此，尽管它不应该用在每一个项目上，

您可以使用它来创建桌面应用程序、游戏、移动应用程序、网站和系统软件。它甚至是最适合实现人工智能和机器学习算法的语言。

所以，我花了几周时间为 Python 开发者收集独特的项目想法。这些项目想法有望让你重拾对这门神奇语言的兴趣。最好的部分是，您可以通过这些有趣但具有挑战性的项目来增强您的 Python 编程技能。

让我们一个一个来看看。

1-使用语音命令创建软件 GUI

互动样本—原照片由 Headway 在 Unsplash 上拍摄—作者编辑

如今，桌面应用程序开发领域已经取得了巨大的进步。你会看到许多拖放 GUI 生成器和语音识别库。那么，为什么不把它们结合在一起，通过与计算机对话来创建一个用户界面呢？

这纯粹是一个新概念，经过一些研究，我发现从来没有人试图这样做。所以，这可能比下面提到的那些更有挑战性。

下面是一些使用 Python 开始这个项目的说明。首先，你需要这些包:-

• 语音识别库
• 页面—拖动&下拉 GUI 生成器
• 文档
• 页面如何工作的视频
• 使用页面创建登录窗口

现在，我们的想法是硬编码一些语音命令，比如:

你明白了，对吧？添加更多这样的命令非常简单明了。

因为这将是一个最低可行产品(MVP) 。所以，如果你不得不硬编码许多条件语句(比如 if…else)，这完全没问题。

设置了一些基本命令后，就该测试代码了。现在，您可以尝试在窗口中构建一个非常基本的登录表单。

这个想法最大的灵活性在于它可以应用于游戏开发、网站和移动应用。即使在不同的编程语言中。

2-人工智能赌博机器人

网球比赛——照片由 Moises Alex 在 Unsplash 上拍摄

赌博是一种人们预测结果的活动，如果他们是正确的，那么他们就会得到回报。现在，有许多技术进步发生在过去几年的人工智能或机器学习中。

例如，你可能听说过像 AlphaGo Master 、 AlphaGo Zero 和 AlphaZero 这样的程序，它们可以比任何职业人类棋手更好地玩 Go (game) 。你甚至可以获得一个叫做 Leela Zero 的类似程序的源代码。

我想传达的观点是，AI 正在变得比我们更聪明。这意味着它可以通过考虑所有的可能性并从过去的经验中学习来更好地预测一些事情。

让我们应用 Python 中的一些监督学习概念来创建一个 AI 下注机器人。这里有一些你需要开始使用的库。

• 熊猫——数据分析
• NumPy——多维数组、矩阵和数学函数
• scikit-learn——机器学习
• XGBoost —梯度增强
• Matplotlib —绘图
• seaborn —统计数据可视化
• pickle — Python 对象序列化

首先，你需要选择一个游戏(如网球、足球等。)来预测结果。现在搜索可用于训练模型的历史匹配结果数据。

例如，网球比赛的数据可以在。csv 格式来自tennis-data.co.uk 网站。

如果你不熟悉赌博，这里是它是如何工作的。

• 你想在罗杰·费德勒身上赌 10 美元，赔率为 1.3。
• 如果他赢了，你将获得 10 美元(实际金额)，外加 3 美元(利润)。
• 如果他输了，你也会输掉你的钱(例如 10 美元)。

在训练模型之后，我们必须计算每个预测的置信水平，通过检查预测正确的次数来找出我们的机器人的性能，最后还要关注投资回报(ROI) 。

下载 Edouard Thomas 的类似开源人工智能赌博机器人项目。

3-交易机器人

交易—照片由 Nick Chong 在 Unsplash 上拍摄

交易机器人与之前的项目非常相似，因为它也需要 AI 进行预测。

现在的问题是，一个 AI 能否正确预测股价的波动？

答案是肯定的。

在开始之前，我们需要一些数据来开发一个交易机器人。

• 雅虎！金融—获取股票数据
• Alpha Vantage —财务数据实时 API

来自 Investopedia 的这些资源可能有助于训练机器人。

• 新手交易策略
• 只有通过这 5 步测试才能进行交易

读完这两篇文章后，你现在会对什么时候买股票，什么时候不买有更好的理解。这些知识可以很容易地转换成 Python 程序，自动为我们做出决定。

你也可以参考这个叫做 freqtrade 的开源交易机器人。它是使用 Python 构建的，实现了几种机器学习算法。

4-钢铁侠贾维斯(基于人工智能的虚拟助手)

AI 助手界面——Joshua Sortino 在 Unsplash 上拍照

这个创意取自好莱坞电影系列钢铁侠。这部电影围绕技术、机器人和人工智能展开。

在这里，钢铁侠利用人工智能为自己打造了一个虚拟助手。这个程序被称为贾维斯，帮助钢铁侠完成日常任务。

钢铁侠用简单的英语给贾维斯下达指令，贾维斯也用英语回应。这意味着我们的程序将需要语音识别以及文本到语音的功能。

我建议使用这些库:

• 语音识别
• 文本到语音转换(TTS)

现在，您可以像这样硬编码语音命令:

您还可以使用 Jarvis 完成大量其他任务，例如:

• 在手机上设置闹钟。
• 持续检查家庭安全摄像头，并在有人在外面等候时通知。您可以添加更多功能，如面部检测和识别。它能帮助你找出那里有谁或有多少人。
• 打开/关闭房间窗户。
• 开灯/关灯。
• 自动回复邮件。
• 计划任务。

甚至脸书的创始人“马克·扎克伯格”也做了一个 Jarvis 作为副业。

5-监控网站，了解即将到来的艺术家音乐会

门票——安迪·李在 Unsplash 上的照片

Songkick 是一项非常受欢迎的服务，提供关于即将举行的音乐会的信息。它的 API 可以用来搜索即将到来的音乐会:

• 艺术家
• 位置
• 举办地点
• 日期和时间

您可以创建一个 Python 脚本，使用 Songkick 的 API 每天检查特定的音乐会。最后，只要音乐会有空，就给自己发一封电子邮件。

有时 Songkick 甚至会在他们的网站上显示购票链接。但是，这个链接可以转到不同音乐会的不同网站。这意味着即使我们利用网络抓取，也很难自动购买门票。

相反，我们可以简单地显示 buy tickets 链接，就像在我们的手动操作应用程序中一样。

6-自动免费续订让我们加密 SSL 证书

让我们加密 Logo—https://letsencrypt.org/

让我们加密是一个提供免费 SSL 证书的认证机构。但是，问题是这个证书的有效期只有 90 天。90 天后，你必须续费。

在我看来，这是使用 Python 实现自动化的一个很好的场景。我们可以编写一些代码，在网站 SSL 证书到期前自动更新证书。

在 GitHub 上查看这个代码以获得灵感。

7-识别人群中的个人

人脸识别—作者图片

如今，各国政府在公共场所安装了监控摄像头，以加强公民的安全。大多数这些摄像机仅仅是为了记录视频，然后法医专家必须手动识别或追踪个人。

如果我们创建一个 Python 程序，实时识别摄像机中的每个人，会怎么样？首先，我们需要进入一个全国性的身份证数据库，我们可能没有。

因此，一个简单的选择是用你的家庭成员的记录创建一个数据库。

然后你可以使用一个人脸识别库，把它和相机的输出连接起来。

8 触点跟踪

联系人追踪应用程序——照片由 Unsplash 上的 Markus Winkler 拍摄

接触追踪是一种识别在特定时间段内相互接触的所有人的方法。它在像新冠肺炎或艾滋病毒这样的疫情最有用。因为没有任何关于谁被感染的数据，我们无法阻止它的传播。

Python 可以与名为 DBSCAN(基于密度的带噪声应用空间聚类)的机器学习算法一起用于接触追踪。

由于这只是一个附带项目，所以我们无法获得任何官方数据。现在，最好使用 Mockaroo 生成一些真实的测试数据。

具体代码实现你可以看看这篇文章。

9-自动将文件从一个文件夹移动到另一个文件夹

Ubuntu 中的 Nautilus 文件管理器——图片由作者提供

这是一个非常基本的 Python 程序，可以持续监控一个文件夹。每当文件被添加到该文件夹中时，它检查其类型并相应地将其移动到特定的文件夹。

例如，我们可以跟踪我们的下载文件夹。现在，当一个新的文件被下载后，它会根据其类型自动移动到另一个文件夹中。

。exe 文件很可能是软件设置，所以把它们移到“软件”文件夹中。然而，在“图像”文件夹内移动图像(png、jpg、gif)。

这样我们可以组织不同类型的文件以便快速访问。

10-从 YouTube 上收集职业道路视频

YouTube 主页——照片由 Kon Karampelas 在 Unsplash 上拍摄

创建一个应用程序，接受我们在职业生涯中需要学习的技能名称。

例如，要成为一名 web 开发人员，我们需要学习:

• HTML5
• CSS3
• Java Script 语言
• 后端语言(PHP、Node.js、Python、ASP.NET 或 Java)
• 自举 4
• wordpress 软件
• 后端框架(Laravel，Codeigniter，Django，Flask 等。)
• 等等。

进入技能后会有一个“生成职业路径”按钮。它指示我们的程序搜索 YouTube 并根据每个技能选择相关的视频/播放列表。如果有很多类似的技能视频，那么它会选择一个最多的观点，评论，喜欢等。

该程序然后根据技能将这些视频分组，并在 GUI 中显示它们的缩略图、标题和链接。

它还会分析每个视频的持续时间，汇总它们，然后通知我们学习这条职业道路需要多长时间。

现在，作为用户，我们可以观看这些按部就班订购的视频，成为这一职业的大师。

结论

用独特的编程项目挑战自己让你保持活跃，提高你的技能，并帮助你探索新的可能性。

我上面提到的一些项目思路也可以作为你的最后一年项目。

是时候用 Python 编程语言展示你的创造力了，把这些想法变成你会引以为豪的东西。

感谢阅读！

确保数据和代码质量的 10 个数据工程实践

原文：https://towardsdatascience.com/10-data-engineering-practices-to-ensure-data-and-code-quality-6224d012d8fb?source=collection_archive---------7-----------------------

入门

我从不同公司的数据工作中学到了什么

来自 Pexels 的 Kehn Hermano 摄影

数据工程是本世纪发展最快的职业之一。自从我开始在这个领域工作以来，我遇到了各种确保跨组织的数据和代码质量的方法。尽管每个公司可能遵循不同的过程和标准，但有一些通用的原则可以帮助我们提高开发速度，改进代码维护，并使数据工作更容易。

1.函数式编程

我在学习期间学习的第一门编程语言是 Java。尽管我理解面向对象编程在创建可重用的类和模块方面的好处，但我发现在处理数据时很难应用它。两年后，我遇到了 R——一种函数式编程语言，当时我就爱上了它。能够使用dplyr包并简单地通过管道传递函数来转换数据并快速看到结果，这改变了我的生活。

但是最近， Python 允许我们将两个世界结合起来:编写面向对象的模块化脚本的能力，同时利用函数式编程，这种编程在与 r。

函数式编程在处理数据方面如此出色的原因是，几乎任何数据工程任务都可以通过以下方式来完成:获取输入数据，对其应用一些函数(即 ETL 中的 T:转换、清理或丰富数据)，然后将其输出加载到某个集中的存储库中，或者为报告或数据科学用例提供服务。

函数式编程范式在数据工程中非常常见，以至于许多博客文章都是关于它的。例如，下面链接的文章已经由 Apache Airflow 的创始人 Maxime Beauchemin 在 2018 年初发布:

[## 功能数据工程——批量数据处理的现代范例

批量数据处理——历史上称为 ETL——极具挑战性。这很耗时，也很脆弱，而且经常…

medium.com](https://medium.com/@maximebeauchemin/functional-data-engineering-a-modern-paradigm-for-batch-data-processing-2327ec32c42a)

类似地，许多数据工程工具已经被创建来促进这个过程。函数式编程让我们可以创建代码，这些代码可以在许多数据工程任务中重用，并且可以在对大量生产数据运行 ETL 之前，通过向函数提供小块数据来轻松地进行测试。

2.设计你的函数来做一件事

为了使函数可重用，以这样一种方式编写它们是一个很好的实践，即它们只做一件事。你总是可以有你的主要功能，可以把不同的部分联系在一起。总的来说，我发现通过将功能变小(，即专注于做好一件事，我倾向于更快地开发代码，因为单个元素的失败可以更容易地被识别和修复。

更小的功能也更容易更换单个组件，并将其用作乐高积木，可以根据不同的使用情况组合在一起。

3.正确的命名约定至关重要

一个好的做法是给对象命名，这样一个看你代码的新人就能立即理解你的意图。如果有些缩写不是每个人都能理解的，最好避免使用它们，并写出全称。此外，我见过的大多数数据工程师倾向于使用以下约定:

• 作为功能名称的动词，例如。get_dataframe_from_google_ads()可能比google_ads()更容易理解——更长的版本不仅显示了源系统，还显示了函数执行的动作和它返回的对象类型(一个数据帧)。你可以认为它很罗嗦，但是通常，你只需要写两次:一次在你定义它的时候，一次在你调用它的时候。因此，在我看来，那些更长的名字是值得的。
• 大写全局变量 —我合作过的大多数数据工程师都将全局变量定义为大写，以区别于局部变量(例如主函数中的那些)
• 许多人认为最好只在脚本的顶部定义imports——理论上，您可以在函数或类中导入库，但是如果所有的导入都在脚本的顶部，可能会更容易跟踪包的依赖关系。

理想情况下，您的命名可以使您的代码自文档化，这也可以使您更快地编写代码。

4.通过编写更少更好的代码，使您的代码易于维护

一般来说，我们读代码的频率要比写代码的频率高得多。因此，让我们的代码易读、易理解是有意义的。有了正确的命名和良好的结构，我们可以让未来的自己和其他使用我们代码的人更容易。

简洁也是有帮助的:我们写的代码越少，我们需要维护的代码就越少。如果我们可以用更少的代码完成一些事情，这是一个潜在的胜利。

5.文档是关键，但前提是处理得当

这听起来可能违背直觉，但是我们不应该记录我们的代码在做什么。相反，我们应该记录为什么我们的代码正在做它正在做的事情。我经常看到代码注释陈述显而易见的事情。

图片来自 Reddit 上的节目幽默[1]

例如，我们的函数get_dataframe_from_google_ads()不必说我们正在从谷歌广告下载数据，而是说这样做的原因。"下载广告支出数据，用于以后的营销成本归属."

最重要的是，使用 docstrings 或类型注释来记录函数的预期输入和输出非常有用！它会立即让你成为更好的数据工程师。

6.避免硬编码值

我见过许多与 ETL 相关的 SQL 查询使用了一些阈值，却没有解释使用它们的原因。例如，假设有一个脚本从某个表中提取数据，但只针对 2020 年 9 月 30 日之后发生的事件。而且绝对没有文件证明为什么有人选择了这个特定的日期！如果不解释原因，人们以后怎么会发现为什么这个值被硬编码了呢？这可能是因为，在那一天，公司过渡到一个新的源系统、数据提供商，或者他们可能改变了一些业务策略。

我并不是说在代码中指定这样的业务逻辑是错误的。但是，如果没有记录为什么有人选择了这样一个任意的阈值，这个硬编码的值在未来几年对下一代数据工程师来说可能仍然是一个谜。

7.避免保留僵尸代码

我经常遇到的一个常见的反模式是，有人保留了已经被放弃但在脚本中被注释掉的代码。也许有人想测试一些新的行为，并保留旧的版本，以防新的不工作。或者这个人想保留历史。在这两种情况下，我认为最好避免这种情况，因为这可能会使后来的开发人员难以区分什么是真正正确的版本。

例如，我经历过这样一种情况，被注释掉的代码片段比没有被注释掉的版本更有意义。可能在某个时候，有人会调换这两个版本，因为他或她会认为注释掉这个更符合逻辑的版本是错误的。因此，保留一个僵尸代码可能是危险的。

8.模块化做得好:将你的业务逻辑与实用功能分开

混合实用功能和业务逻辑是有意义的，但是将它们分开仍然是有益的。如果使用得当，公共功能可以被推到不同的包中，并在以后的许多项目中重用。这种分离需要更多的前期工作。通过为这样的包建立一个发布过程，但是可重用性和只定义一个功能一次的好处从长远来看是值得的。

9.保持简单

根据 Python 的禅[2]:

“简单比复杂好。”

许多数据工程师，尤其是那些有计算机科学背景的人，有时可以创建复杂但过于复杂的解决方案。例如，如果某个东西可以表示为一个简单的函数，该函数将一些数据作为输入，并返回一个转换后的版本作为输出，那么为这样的操作编写一个自定义类对象可能会被认为是一个过度设计的解决方案。

10.考虑长远

有时候，我们需要在正确做事和快速做事之间做出权衡。创建足够通用的解决方案，以便在不同的用例中重用，这将使我们的长期生活更轻松，需要更长的时间来开发。例如，为跨项目共享的模块建立一个发布过程和 CI/CD 管道可能会在前期花费大量时间，但是这种额外的努力通常会在后期得到回报。花时间创建持续验证和监控数据质量的脚本也是如此。

结论

在本文中，我们讨论了数据工程的最佳实践，以确保高质量的数据和代码的可维护性。我们已经展示了大多数数据工程任务可以表示为函数，这些函数接受一些输入数据，并根据特定的业务需求对其进行转换。

理想情况下，这些函数应该被设计为做一件事，并被记录下来，这样任何阅读代码的人都知道什么是需要的输入，什么是函数生成的输出。

我们还研究了有用的命名约定，以及构造、编写和记录代码的最佳方式，以使其长期有用。

感谢您的阅读！如果这篇文章对您有帮助，请 关注我的 来看我的下一篇文章。

资源:

[1] Reddit — 猫咪图片

【2】Python 之禅

10 天来改进我的 Python 代码

原文：https://towardsdatascience.com/10-days-of-improving-the-efficiency-of-my-python-code-170e934289d9?source=collection_archive---------51-----------------------

对代码进行小的日常修改如何对效率产生大的影响

照片由 chuttersnap 在 Unsplash 上拍摄

在之前的一篇文章中，我谈到了通过每天早上对你前一天写的代码做一个修改来提高你的 Python 代码的效率。无论我做了什么更改，我都会确保在将来使用新的方法，这意味着我的代码的质量和效率总体上有所提高。

做出这些改变后，我会给我的团队发一条消息，让他们知道我做了什么。以下是我在头 10 天发出的消息，它们被汇编成一篇文章，这样你就可以看到这种日常练习对你的代码的重大影响。

注意:这些是我在两周的工作中用来改进代码的真实例子。其中一些可能看起来有点随意或明显，但它们都适用于我当时的代码。不管怎样，我希望你能理解和欣赏代码改进的基本方法。

第一天

仔细定义 Pandas 中的列类型如果您正在使用 Pandas 中的大型数据集，那么在使用dtype参数读取数据或使用astype更改类型时，定义模式总是值得的。存储为 0 和 1 的布尔值通常被设置为 int32 或 int64 类型。在某些情况下，将它们转换为 bool 类型可以大大减少数据帧占用的内存。

将列的类型从 int64 更改为 bool 会导致该列占用八分之一的内存

第二天

快速遍历 Pandas DataFrame 如果您需要遍历 Pandas DataFrame，那么遍历作为 NumPy 数组的值可能会更快。在下面的例子中，这导致代码运行速度提高了两个数量级！

迭代数据帧的值而不是使用 iterrows 可以使时间减少 2 个数量级

第三天

海象操作符 从 Python 3.8 开始，海象操作符(:= see eyes and tucks)已经可以用于变量的赋值，同时也可以用作更大表达式的一部分。

if (n := len(a)) > 5: print(f’The length of a is {n}’)

代替

n = len(a)
if n > 5:
   print(f’The length of a is {n}’)

照片由 Jay Ruzesky 在 Unsplash 上拍摄

第四天

羽毛文件格式 在漫长的数据处理流水线中，在关键的里程碑处保存输出是一个很好的做法。 Apache arrow (你需要安装 pyarrow )已经创建了羽化格式，非常适合这些情况。文件比 csv 小，它是语言不可知的(可以在 R，Python，Julia 等中使用)。)，而且它的读/写速度一般只受本地磁盘性能的速度限制。Pandas 能够读写 feather 文件，因此当您想要快速保存中间数据帧时，它是完美的。

羽化格式几乎是 CSV 格式的三分之一，读/写速度更快

第五天

字符串格式化 Python 提供了许多不同的方法来格式化字符串，其中一个要避免的就是将字符串加在一起。这增加了内存占用，因为 Python 必须在将每个单独的字符串相加之前为它们分配内存。两个更好的选择是使用%符号，或 f 字符串。f 字符串通常是最快的选择，可以让你的代码更容易阅读。

f 字符串速度更快，提高了代码的可读性。(是的，58 个，还在继续)

第六天

Cython Jupyter 扩展 Cython 是 Python 的库和超集语言。它允许你编写编译成 C 语言的 Python 代码，所以它通常运行得更快。 Jupyter 笔记本有一个扩展用于在一个单元内运行 Cython。和 C 一样，你需要确保使用cdef来指定每个变量的类型。

注意:记得先 安装 cython 。

Cython 将这个斐波那契函数的速度提高了 2 个数量级！

第七天

布尔比较 有几种方法可以将变量与布尔进行比较。在 if 语句中，删除比较运算符通常是最快的方法。时差可能看起来不是很大，但这是一个很容易做到的改变，可以使您的代码更具可读性。

对布尔变量使用不带比较运算符的 if 语句会更快，并提高可读性

第八天

NumPy 掩码数组 NumPymasked array类是 NumPy 数组类的子集，在有数据缺失时使用。当一个特定的值已经被用于缺失数据，并且您想从一个操作中排除它时，例如 np.max，它特别有用。

MaskedArray 可以从操作中排除丢失的数据，而无需从对象中移除数据

第九天

排序函数 Python 中有几种排序的方法。两个内置方法是sorted和sort，用于基本排序，可以互换使用。然而，因为sort方法就地修改列表，而不是像sorted那样创建一个新列表，所以它通常更快。即使在使用key参数时也是如此，它在排序前对每个元素应用一个函数。

然而，值得注意的是sorted方法的功能比sort广泛得多。例如，sorted可以接受任何 iterable 作为输入，而sort只能接受一个列表。

对于简单的排序任务，排序方法通常比 sorted 快

第 10 天

使用 pandas 进行多重处理 沿给定轴应用的 Pandas 操作，如 apply 和 map 方法，非常容易并行化，其中沿轴的每一行/列都被单独处理。当数据帧很大或者您想要应用/映射计算开销很大的函数时，这尤其有用。这可以使用 Python 多处理库相对简单地实现。

但是，请记住，对于较小的数据，在内核之间分配作业所花费的时间可能会超过在单个内核上顺序运行作业所花费的时间。

多处理库可用于在多个内核之间分配作业以加快处理速度，但对于较小的数据帧，处理速度通常会较慢

对一些读者来说，这些变化中的一些似乎是显而易见的或无用的，而对其他人来说，它们可能是你从未见过的或真正有用的。不管怎样，我希望看到这篇文章能让你明白，每天花一点时间改进你的 Python 代码(或任何其他语言)会对你的编码技能和效率产生持久的影响。

“程序员深度学习”10 天

原文：https://towardsdatascience.com/10-days-with-deep-learning-for-coders-759b34b9336b?source=collection_archive---------51-----------------------

我对“fastai”的课程和书籍的体验

图片由来自 Pixabay 的 Ryan McGuire 拍摄

背景

10 天前开始针对编码员的实用深度学习。我不得不说他们务实的态度正是我所需要的。

我通过在短短几个月内学习 Python、Pandas、NumPy 以及任何我需要的东西开始了数据科学。我做了我需要做的任何课程(例如 Kaggle 微课)和我需要阅读的任何书籍(例如 Python for Data Analysis )。所有这些都是我在今年四月开始的为期 90 天的 MOOC'athlon 学习挑战的一部分。这是我一生中最伟大的学习时期之一。在这之后，我在 Kaggle 完成了 Iris 数据和波士顿房价预测项目。然后我从网上搜集数据，用我的熊猫技能把它们清理掉。实施研究论文仍然令人困惑和沮丧。我在研究论文和 Kaggle 项目中挣扎。我擅长 C 语言。你可以给我任何编程语言，我可以比大多数人学得更快，因为编程是我的第二天性。计算机编程只是在我的脑海中流动。而这并没有发生在数据科学上。尽管有学习和大量的工作，但最终，我不记得我做了什么(是的，数据争论是一个地狱般的工作)。我一直处于沮丧的状态。我开始为小事生气，这也影响到了我的个人生活。我想到了退出数据科学和机器学习。已经 4 个月了，我根本没有能力完成任何被认为对商业有用的事情。我感觉被困在一个 4x4 英尺的混凝土盒子里。

挫折的终结

我总是在不断寻找解决问题的不同方法。我认为不同的观点是来自宇宙的祝福。是的，我们都有自己的“观点”,当有人从一个你从未想过的不同而奇怪的角度来看待同一个问题时，总是令人耳目一新。改变我处境的是 Caleb Kaiser 的一篇博文:

[## 不要学机器学习

学习如何用 ML 模型构建软件

towardsdatascience.com](/dont-learn-machine-learning-8af3cf946214)

他的博客文章让我明白，这种沮丧不仅仅属于我，这是每个程序员都会有的，我并不孤单。这完全改变了我的观点，我决定采用他的方法。我决定两样都做:看书和看视频。

在仅仅一周的课程中，我就能够理解T2 应用数据科学关于体重中毒的研究论文。

又过了几天，在经历了多次失败之后，我成功地在 binder 上实现了熊探测模型。你可以试试这个网络应用。给它传一张以下图片:

1.美国黑熊

2.灰色的

3.北极熊

4.玩具熊

它会检测出是哪一个。给它传递任何其他东西，比如一只鞋，它会尝试将它与模型中 150x4 的熊图片匹配，并尽最大努力。不是人类=:o):

https://my binder . org/v2/GH/ArnuldOnData/fastai-projects/master？URL path = % 2f voila % 2f fronder % 2f ch 02% 2f bear-detection . ipynb

照片由本·怀特在 Unsplash 上拍摄

我似乎记得我做过的大部分事情。数据科学终于成为我的第二天性。这次 fastai 的课程让我更有信心去追求更多更高的机器学习知识。我认为如果一些学习方法对你不起作用，那么你需要试试这门课的实用方法。

为什么

这并不是说，传统的学习方法，如做 MOOCs，然后 Kaggle 项目或大学毕业的数据科学路线不起作用。他们可能会，也可能不会。人们是不同的，我们都有不同的背景，我们不可能都遵循传统或混合的方法。时代变了。多亏了互联网，它的去中心化特性，以及网络中立性，世界比过去更加紧密地联系在一起。世界变得越来越小，每个人都可以相互联系。这导致了第四次工业革命:

Christoph Roser 在 http://AllAboutLean.com拍摄的图片

克劳斯·施瓦布，世界经济论坛创始人兼执行主席，文字来自维基百科

第四次工业革命将导致:

• 熄灯制造(全自动工厂，不需要人在现场)
• 智能工厂将监控物理过程，创建物理世界的虚拟副本，并做出分散决策。
• 通过物联网，信息物理系统在内部以及跨越价值链的参与者所使用的组织服务，彼此之间以及与人类之间进行实时通信和合作

按照我的理解,第四次工业革命方式说我们需要快速学习工具，我们需要快速适应新技术和新系统。不要花 2-4 年的时间来学习和准备工作，你需要有能力和态度直接投入工作，建立一些有用的东西，在接下来的几个月里为企业增加价值的东西。我们需要以不同于以往的方式学习。我认为杰瑞米·霍华德、 雷切尔·托马斯、和西尔万·古格这种不酷的学习方法正是这个 21 世纪的行业所需要的。

Kaggle 竞赛和现实生活项目的 10 个区别

原文：https://towardsdatascience.com/10-differences-between-a-kaggle-competition-and-real-life-project-38525fb56c60?source=collection_archive---------29-----------------------

Kaggle 竞赛和真实项目之间有一些非常重要的区别，新手数据科学家应该了解这些区别。Kaggle 创造了梦幻般的竞争精神。它的排行榜促使人们提供越来越好的解决方案，将准确性推向极限。Kaggle 的笔记本和讨论让分享知识和学习变得很容易。然而，现实生活中的项目有些不同。我希望这篇文章对考虑从 Kaggle 竞赛开始进入数据科学的人有所帮助。我记得在我的第一个现实生活项目中，所有通常在 Kaggle 上运行良好的模型都悲惨地失败了，这让我有点不知所措。我希望我对此有所准备。

1。数据决定一切，而不是众多型号。在 Kaggle 比赛中，你通常只能使用组织者提供的数据集。在现实生活中，没有这样的限制。你可以挖掘(即收集、准备)尽可能多的新数据。通常是数据造成了差异。也可能有这样的情况，你根本没有任何数据集，你必须定义你想要收集什么数据。你是从零开始，这是另一天的话题。

2。领域专长的确很重要。当杰瑞米·霍华德说没有的时候，他实际上指的是卡格尔竞赛。在 Kaggle 上，您已经创建了一个数据集。这完全是关于理解数据分布、制作特性、构建和堆叠模型。您不需要太多关于 data domain 的知识。然而，只要您对数据收集过程有所控制，您就可以从领域专业知识中受益匪浅。这当然有助于你对数据做出更好的假设，从而改进你的建模。我发现收集适当的数据比建模要困难得多。

3。该死，没有排行榜。 Kaggle 排行榜让你注意到自己犯的一个错误。如果你是项目中唯一的数据科学家，就很难对你的模型性能进行基准测试。排行榜显示了准确性的上限，您总是知道您还可以做多少来改进您的模型。不幸的是，这在现实生活中并不适用。

4。数据清理很重要。没有人为你清理数据。你独自承担在数据收集过程中犯下的所有错误。通常有很多这样的例子。大量的改进来自于数据清理。

5。解决方案的复杂性很重要。在 Kaggle 比赛中，你只需复制一次你的代码。在现实生活中，有时你必须每 5 或 15 分钟复制一次代码。一种新的 Kaggle 竞争(又名内核竞争)正在缩小这种差距，但它们相当罕见。模型响应时间通常对实时预测非常重要。

6。您的测试集是动态的。您的列车组是动态的。在 Kaggle 竞赛中，你要进行大量的测试来挑选最好的特征和模型。您的环境大部分时间是固定的——训练集和测试集不会改变。通常你不会有这么舒适的设置。在 Kaggle 比赛中完成一次的事情，一旦你的火车设置发生变化，就必须一遍又一遍地重做。在某些领域，你的火车设置会每小时改变一次！您的整个解决方案(包括功能和型号选择)应该完全自动化。

7。测试和重构。您的代码的生命周期可能超过 2 个月，您通常会进行几轮深入的重构。良好的测试块将有助于这一点。看一下 pytest。

8。模型部署。你训练出来的模型很棒，但对公司没用。它必须以某种方式部署到生产中。部署通常意味着模型被加载到内存中，有接收请求的接口，可以处理请求并返回预测。像 tornado/flask 这样的网络服务器可能会有所帮助。MOOCs 很少提到这一点，Kaggle 也是。

9。性能控制。一旦你的模型被部署，你需要控制它的性能。通常，当数据集发生重大变化或收集到新数据时，您会希望重新训练模型。报告(比如开源 Dash 或 RShiny)不仅可以帮助你控制模型的准确性，还可以吸引更多的商业注意力到你公司的数据科学项目中。麦肯锡的“用图表说话”或 Dona M. Wong 的“华尔街日报信息图表指南”就像是数据展示世界中的圣经。

10。伐木。通常在 Kaggle 上使用，仅用于控制训练流程。不需要使用不同的日志记录级别来记录训练/预测管道中的每一点。在现实生活项目中，任何事情都可能发生，因为环境要复杂得多—它不仅限于笔记本电脑或服务器上的一台笔记本电脑。良好的日志记录实践有助于减少调试时间。

塞尔吉·马卡雷维奇，2020 年 1 月 8 日，https://www.linkedin.com/in/sergii-makarevych-78b62339/

数据科学家必备的 10 款 Jupyter 笔记本扩展

原文：https://towardsdatascience.com/10-essential-jupyter-notebook-extensions-for-data-scientists-86b68ec7a66e?source=collection_archive---------17-----------------------

近距离观察最佳 jupyter contrib 扩展

布雷特·里奇在Unsplash【1】上拍摄的照片。

目录

1. 介绍
2. 扩展ˌ扩张
3. 摘要
4. 参考

介绍

作为一名主要在 Jupyter Notebook 工作的数据科学家，我在我的笔记本中经历了几次开发的好处，同时也遇到了许多各种各样的问题。其中一些问题可以通过jupyter _ contrib _ nb extensions[2]解决。如果没有解决，那么笔记本可以增强。这个 Python 包有许多 nb 扩展，您可以配置这些扩展来帮助简化您的数据科学开发过程。重要的是要注意，一旦你安装了这个软件包，你将需要从你的终端重启你的笔记本电脑才能看到它的效果。下面，我将描述在我的数据科学过程中帮助我的 10 大或基本 Jupyter 笔记本扩展。

扩展ˌ扩张

nb 扩展选项卡。作者截图[3]。

正如您从上面的截图中看到的，您可以启用大量的扩展来简化 Jupyter 编码和数据科学开发。我已经选择并启用了 10 个扩展，我也将在下面描述。有几个已经预先点击过的，比如jupyter-js-widgets/extensions，一旦你启用了你的扩展，它就会显示小部件和图标。同样，也有 Nbextensions 编辑菜单项已经预选。

代码美化

• 该扩展有助于美化或正确格式化 Jupyter 笔记本单元格中的 Python 代码。您可以单击图标在当前单元格中重新格式化您的代码。下面是这个扩展执行前后的情况。这段代码已经很好地格式化了，所以我想展示一下它在右边正确地创建了格式化的间距。对于一些笔记本来说，这可能是一个小变化，但对于其他人来说，你可能有数百个功能的格式不正确，这个扩展可以立即修复你的格式。

美化前后。作者截图[4]。

可折叠标题

• 如果您用标题构建 Jupyter 笔记本，您可以使用标题左侧的向下箭头折叠同一标题部分中的信息和单元格。以下是可折叠标题的使用前和使用后。当你有，比如说一个笔记本有 10 个标题，而你想在代码评审或涉众会议上只突出一个标题部分，或者只是为了帮助你自己更专注于一个部分时，这是很有用的。除了选项、CSS、内部构件和导出更改之外，还有更多重要的参数可以添加到您的扩展中(一旦您安装了这个库，这些以及其他进一步的实现将包含在大多数扩展中)。

可折叠标题的前后。作者截图[5]。

通知

这个扩展允许您的笔记本在您的内核空闲时向您发送 web 通知。如果您有一个长时间的任务在运行，这个扩展可以通过了解您当前的进程而变得有用。你也可以选择 0 秒、5 秒、10 秒和 30 秒。这是您笔记本中的下拉菜单示例。

通知下拉菜单。作者截图[6]。

代码折叠(和编辑器中的代码折叠)

这可能是我最喜欢的扩展。与可折叠的标题类似，这个扩展可以折叠您的代码部分，以便您可以更容易地滚动和查看您的笔记本。

如果您有一个长字典或长函数，您可以折叠它们，以便它们主要是隐藏的，但仍然显示函数命名，以便您仍然可以看到主要部分。在下面的例子中，你可以看到函数是如何折叠的，你甚至可以折叠到注释级别来隐藏这两个函数，只保留你的注释文本。紫色箭头图标表示代码在那里，但是被隐藏了。当与他人共享您的代码时，或者当您想专注于笔记本的某些部分时，这种扩展是有益的。

代码折叠示例。作者截图[7]。

荧光笔

这个扩展相当简单，不言自明。您可以通过点击荧光笔图标来高亮显示您的减价文本。你可以看到有几个选项，如下面使用的红色和黄色。下面是这个简单而有用的扩展的前后对比。

荧光笔延伸之前和之后。作者截图[8]。

拼写检查器

拼写检查器也很简单，但是很有用。如果您正在共享您的笔记本，将它推送到 GitHub，或者向利益相关者展示它，这个扩展特别有用。你需要确保在你的减价单元格中拼写正确。你不会看到拼写错误的单词出现在你显示的减价中，而只会出现在你的编辑中。这个特性是有益的，因此如果你确实有一些你不同意拼写检查的单词，比如 Jupyter Notebook ( 实际上不是 Jupiter Notebook )，你仍然可以显示它而没有令人分心的红色高亮文本。

拼写检查示例。作者截图[9]。

代码字号

如果你想改变代码的字体大小，这个扩展允许你这样做。当共享和协作时，尤其是共享您的屏幕时，这个特性可以证明是有益的，这样您的代码更容易查看。

日戳

这个扩展允许你粘贴你当前的日期和时间到你的单元格中。我建议将其保存为 markdown，这样格式就不会像代码一样运行很难看到格式。如果您想跟踪何时启动了一个涉及不同单元和功能的进程，这个扩展可能会很有用(在流行的 tqdm 库之上)。

草稿栏

这个扩展非常有用。您可以通过选择键盘上的 Ctrl-B 来使用便签簿，如下所示。您可以修改当前的代码，也可以在相同的内核上运行。如果您需要在笔记本中比较代码和注释，这对于并排查看代码和注释也很有用。

便签簿示例。作者截图[10]。

跳过回溯

这种独特的扩展允许您忽略在 Jupyter 笔记本单元格中看到的一些重复或冗长的错误消息。它的工作原理类似于可折叠的标题和代码折叠。在下面的截图中，您可以看到错误的主要部分仍然在右边，但是减少了重复的错误信息，这些错误信息有时会导致头痛，使您无法修复相同的错误。

跳过追溯示例。作者截图[11]。

摘要

杰斯·贝利在 Unsplash 上拍摄的照片。

这是 Jupyter 笔记本的 10 个基本扩展，适用于数据科学家或任何喜欢在 Jupyter 笔记本上编程和开发的人。我希望你学到了一些新的技巧，可以让你作为数据科学家的工作变得更容易。请记住，还有很多扩展需要探索。这些是我觉得特别有趣和有用的。

这里是我上面提到的所有扩展:

Code prettifyCollapsible HeadingsNotifyCodefoldinghighlighterspellcheckerCode Font SizedatestamperScratchpadSkip-Traceback

感谢您的阅读！如果您曾经使用过这些或其他 Jupyter 笔记本扩展，请在下面评论。

参考

[1]照片由布雷特·里奇在Unsplash(2018)拍摄

[2] Jupyter Contrib 团队，Jupyter-Contrib-nb extensions，(2015–2018)

[3] M.Przybyla，NBextensions 选项卡截图，(2020 年)

[4] M.Przybyla，美化前后截图，(2020 年)

[5] M.Przybyla，可折叠标题前后的截屏，(2020 年)

[6] M.Przybyla，通知下拉菜单截图，(2020 年)

[7] M. Przybyla，代码折叠示例截图，(2020 年)

[8] M.Przybyla，荧光笔扩展截图之前和之后，(2020 年)

[9] M.Przybyla，拼写检查示例截图，(2020 年)

[10] M.Przybyla，Scratchpad 示例截图，(2020 年)

[11] M.Przybyla，作者提供的跳过追溯示例截图，(2020 年)

[12]Jess Bailey 在Unsplash上拍摄的照片，(2018)

数据科学统计学中的 10 个重要数字摘要(理论、Python 和 R)

原文：https://towardsdatascience.com/10-essential-numerical-summaries-in-statistics-for-data-science-theory-python-and-r-f3ee5e0eca32?source=collection_archive---------10-----------------------

理解并使用 Python 和 R 在 stats 中应用基本的数字汇总来描述数据的中心、分布、最可能的值。

在本文中，我们将回顾以下数值摘要的理论和应用(用 Python 和 R 编写的示例):

1. 平均
2. 中位数
3. 方式
4. 百分位
5. 四分位数(五位数汇总)
6. 标准偏差
7. 差异
8. 范围
9. 比例
10. 相互关系

平均

这是平衡点，描述了正态分布数据的最典型的值。我说“正态分布”数据是因为平均值受异常值的影响很大。

平均值将所有数据值相加，然后除以值的总数，如下所示:

平均值的公式

“ x 条用于表示样本均值(数据样本的均值)。“∑”( sigma)表示从“ i =1”直到“ i = n ”的所有值的加法运算(“n”是数据值的数量)。然后将结果除以' n '。

Python: **np.mean([1,2,3,4,5])** 结果为 3。

R: **mean(c(2,2,4,4))** 结果是 3。

异常值的影响:

平均值中异常值的影响

第一个图的范围是从 1 到 10。平均值是 5.5。当我们用 20 代替 10 时，平均值增加到 6.5。在下一个概念中，我们将讨论“中位数”，这是忽略异常值的最佳选择。

中位数

这就是“中间数据点”，一半数据在中位数以下，一半在中位数以上。这是数据的第 50 个百分位数(我们将在本文后面讨论百分位数)。它也主要用于有偏差的数据，因为异常值不会对中位数产生大的影响。

有两个公式来计算中位数。选择使用哪个公式取决于 n (样本中数据点的数量，或样本大小)是偶数还是奇数。

n 为偶数时的中位数公式。

当 n 为偶数时，没有“中间”数据点，所以取中间两个值的平均值。

n 为奇数时的中位数公式。

当 n 为奇数时，中间数据点为中值。

Python:np.median([1,2,3,4,5,6])(n是偶数)。结果是 3.5，3 到 4 之间的平均值(中间点)。

R:(n为奇数)。结果是 4，中间点。

异常值的影响:

异常值对中位数的影响很小。在这种情况下没有。

在上图中，我们使用了计算平均值时使用的相同数据。请注意，当我们用 20 代替 10 时，第二张图中的中位数保持不变。并不意味着中位数会一直忽略离群值。如果我们有大量的数字和/或异常值，中位数可能会受到影响，但异常值的影响很小。

方式

该模式将返回最常出现的数据值。

Python: statistics.mode([1,2,2,2,3,3,4,5,6])结果是 2。

R 并没有给你具体的均值，但是你可以通过下面的操作得到每个数据值的频率: R: table(c('apple','banana','banana','tomato','orange','orange','banana'))结果是apple:1, banana:3, orange:2, tomato:1。“香蕉”出现的频率更高，有 3 次。下面是这个水果矢量的直方图。

使用直方图的模式示例。

百分位

等于或小于给定数据点的数据百分比。它有助于描述数据点在数据集中的位置。如果百分位数接近于零，那么观察值是最小的。如果百分位数接近 100，那么该数据点是数据集中最大的一个。

Python:

from scipy import statsx = [10, 12, 15, 17, 20, 25, 30]## In what percentile lies the number 25?
stats.percentileofscore(x,25)
# result: 85.7

R:

library(stats)x <- c(10, 12, 15, 17, 20, 25, 30)## In what percentile lies the number 25?
ecdf(x)(25)
# resul: 85.7## In what percentile lies the number 12?
ecdf(x)(12)
# resul: 0.29

四分位数(五位数汇总)

四分位测量中心，也很好地描述了数据的分布。对有偏差的数据非常有用。有四个四分位数，它们组成了五数汇总(结合最小值)。五数汇总由以下部分组成:

1. 最低限度
2. 第 25 百分位(下四分位)
3. 第 50 百分位(中位数)
4. 第 75 百分位(上四分位数)
5. 第 100 百分位(最大值)

Python:

import numpy as npx = [10,12,15,17,20,25,30]min = np.min(x)
q1 = np.quantile(x, .25)
median = np.median(x)
q3 = np.quantile(x, .75)
max = np.max(x)print(min, q1, median, q3, max)

R:

x <- c(10,12,15,17,20,25,30)min = min(x)
q1 = quantile(x, .25)
median = median(x)
q3 = quantile(x, .75)
max = max(x)paste(min, q1, median, q3, max)## You can also use the function favstats from the mosaic 
## It will give you the five-number summary, mean, standard deviation, sample size and number of missing values.librarylibrary(mosaic)
favstats(x)

一个箱线图是一个很好的方法来绘制五个数字的摘要和探索数据集。

“mtcars”数据集(mpg x gear)的箱线图。

箱线图的底端代表最小值；第一条水平线代表下四分位数；正方形内部的线是中间值；下一行是上四分位数，最上面是最大值。

标准偏差

标准差广泛用于统计学和数据科学。它测量数据集的变化量或离差量，计算数据相对于平均值的分散程度。小值意味着数据是一致的，并且接近平均值。较大的值表示数据高度可变。

偏差:这个想法是把平均值作为一个参考点，一切都从这个点开始变化。偏差被定义为观察值与参考点之间的距离。该距离通过从平均值( x-bar )中减去数据点( xi )获得。

计算标准差的公式。

计算标准偏差:所有偏差的平均值将始终为零，因此我们对每个偏差进行平方，并将结果相加。然后，我们将其分为' n-1' (称为自由度)。我们对最终结果求平方根，以取消偏差的平方。

标准差是数据中所有偏差的代表。它从不为负，只有当所有值都相同时，它才为零。

萼片的密度图。虹膜数据集中的宽度。

这张图显示了萼片的密度。虹膜数据集中的宽度。标准差为 0.436 。蓝线代表平均值，红线距离平均值一个和两个标准差。例如，萼片。值为 3.5 的宽度与平均值相差 1 个标准偏差。

Python:

R:

离群值的影响:标准差和均值一样，受离群值的影响很大。下面的代码将使用 R 来比较两个向量的标准差，一个没有异常值，另一个有异常值。

x <- c(1,2,3,4,5,6,7,8,9,10)
sd(x)
# result: 3.02765#Replacing 10 by 20:
y <- c(1,2,3,4,5,6,7,8,9,20)
sd(y)
# result: 5.400617

差异

方差几乎是标准偏差的相同计算，但它停留在平方单位。所以，如果你求方差的平方根，你就得到了标准差。

方差的公式。

注意用' s 平方'表示，标准差用' s' 表示。

Python:

R:

范围

最大值和最小值之差。对于一些基本的探索性分析很有用，但不如标准差强大。

范围的公式。

Python:

R:

比例

它通常被称为“百分比”。定义数据集中满足某些要求的观察值的百分比。

相互关系

定义两个定量变量之间关联的强度和方向。它的范围在-1 和 1 之间。正相关意味着一个变量随着另一个变量的增加而增加。负相关意味着一个变量随着另一个变量的增加而减少。当相关性为零时，则完全没有相关性。结果越接近其中一个极端，两个变量之间的关联就越强。

计算相关性的公式。

巨蟒: stats.pearsonr(x,y)

R: cor(x,y)

MPG 和体重的相关性。

该图显示了 mtcars 数据集中 MPG 和重量 (-0.87)之间的相关性。这是一个很强的负相关，意味着随着体重的增加，MPG 下降。

当您探索和分析数据时，这些基本摘要是必不可少的。它们是深入研究统计和高级分析的基础。如果你有什么想让我加入的总结，请随意回复。

作为数据科学家，我不得不处理的 10 个糟糕数据的例子

原文：https://towardsdatascience.com/10-examples-of-awful-data-that-i-had-to-work-with-as-a-data-scientist-10894cd35828?source=collection_archive---------25-----------------------

一瞥使用数据令人沮丧的黑暗面

蒂姆·高在 Unsplash 上拍摄的照片

您可能知道也可能不知道，数据科学的很大一部分都在处理坏数据。

我写这篇文章很开心，所以希望你也能从中得到乐趣。这里有 10 个我不得不处理极其混乱的数据的例子。我相信你们中的许多人会对这些观点产生共鸣！

1)美国，美国，还是美国？

问题:我把这作为第一点，因为我认为这是我们许多人都能体会到的。我从来不明白为什么一个应用程序应该让用户选择拼写他们的国家，而不是给他们一个可搜索的列表，因为这导致了必须处理这个问题。

我曾经处理过地理数据，不得不处理不同拼写的国家，例如美国，美国，美国，美利坚合众国。

解决方案:我们创建了一个映射表来解决这个问题，但这意味着我们必须不断更新它，以应对系统中出现的任何新变化。

2)一周的第一天是星期天还是星期一？

问题:这是我遇到过的最令人沮丧的问题之一——有两个不同的表按周汇总信息，每个表包含两个不同指标的信息。

问题是一个表假定一周的第一天是星期天，而另一个表假定一周的第一天是星期一，这意味着这两个表是不可比的。

想象一下，由于无法匹配时间段，无法正确比较收入和成本。

解决方法:没有。

3)缺少用户 ID

我认为你在数据架构或 SQL 中学到的第一件事是主键的概念，所以我发现这一点令人难以置信。

问题:信不信由你，在多个实例中，我不得不处理对每个用户都没有可靠主键的用户数据。换句话说，我必须处理缺少用户 ID 的表。更糟糕的是，我们没有其他可以使用的标识符，比如电子邮件。

解决方案:除了将问题提交给数据工程团队之外，没有其他解决方法，所以只能这样了。如果你认为那不好，那会变得更好…

4)不使用主键和外键连接表，第 1 部分

通常，如果您想要连接两个表，通常两个表中都有一个列可以用来连接它们。例如，用户 ID 可能在每个表中，允许您执行连接。

问题:曾经有一段时间，我不得不联接两个没有主键和外键的不同表。

解决方案:我们最终不得不通过在交叉连接的表上使用欧几里德距离来计算相似性得分，从而连接两个表，匹配彼此最相似的行。

一切都感觉不对劲，但我们别无选择。

5) 5 万不等于 5 万零 105

问题:我确信这也是非常相关的——处理不一致的数据。例如，一个表可能告诉我，我们的月收入是 50，000 美元，但另一个具有类似信息的表可能说我们的月收入是 50，105 美元。

这是一个非常简单的例子，但是当处理不一致的数据时，会非常令人沮丧，因为您不知道该相信什么！

解决方案:我们的短期解决方案是使用整个公司更常用的表格。长期的解决方案实际上是找出数字不匹配的原因，并从根本上重建管道。

6) Psh。谁在乎逻辑

问题:最糟糕的事情之一是处理逻辑被破坏的数据。举个例子，假设有一个记录显示某个用户卸载了同一个应用程序两次，中间没有重新安装。

解决方案:除了举起一面红旗，让数据工程师们一头扎进去，我这方面做不了什么。有时候，这才是你真正能做的！

7)我是使用表 A、B 还是 C？是的。

问题:令人惊讶的是，我不止一次遇到过这个问题，我不得不处理被划分到几个不同的表中的数据——例如，一个表在 Google Sheet 中，而其他表从 web 应用程序本身被摄取到 Google BigQuery 中。

解决方案:这不是一个太大的问题，但这只是意味着我们必须确保每次我们想要处理这些数据时不会忘记 Google Sheet。

8)缺失数据？只是估算平均值对吗？…

每个人都遇到过丢失数据的情况，但并不是所有的丢失数据都可以用同样的方法处理。更重要的是，处理丢失的数据首先要理解数据丢失的原因。

在工作环境中处理丢失的数据一点也不像 Kaggle。当涉及到 Kaggle 时，您只是简单地接受数据本身，但当涉及到现实世界时，如果您注意到不应该丢失的数据，这将是一个大问题。

问题:我们想要获得各种应用程序的安装指标，所以我们构建了数据管道，却发现它缺少了我们想要的一半应用程序的指标。

解决方案:长话短说，我们使用不同的数据源多次重建管道，结果发现问题与安装如何被跟踪有关——本质上，一半的应用程序在网站上有一个安装按钮，而另一半必须通过完全不同的过程安装，只有安装按钮的应用程序才会被跟踪。因此，为了跟踪我们想要的东西，必须解决这个问题。

9)错别字，错别字，tpyos

问题:有一段时间，我的全部工作包括清理和处理客户输入的数据，这意味着的打字错误。糟糕的是，一些客户拼错了他们的名字，一些人输入的电子邮件没有@符号，等等。

解决方案:我最终构建了一些函数来确保电子邮件、邮政编码和省份等信息有效。这解决了大约 80%的矛盾。至于剩下的 20%，那是手动解决的，没办法。

10)不使用主键和外键连接表，第 2 部分

仅供参考，这涉及到使用微软 Excel，但它仍然处理坏数据！

问题:同样，有一次我必须用金融证券的名称将两个表连接在一起，但是它们没有遵循相同的命名约定，也没有唯一的标识符。

比第一部分更糟糕的是，这是在我了解相似性分数之前，所以只有一个解决方案。

解决方案:我不得不手动将这些行相互匹配。我按照字母顺序对每个表进行了排序，并在出现不匹配时移动行。

感谢阅读！

希望这能给现实世界中存在的各种问题一个更清晰的概念。这 10 个例子只是你可能遇到的所有不同类型的场景和问题的一小部分。

你可能已经注意到，有些问题会比其他问题更容易解决。在少数情况下，有些问题会完全超出你的控制范围，这可能会导致沮丧，但要知道这是工作的正常部分。

我希望你读这篇文章的时候和我写这篇文章的时候一样开心！让我在评论中知道你不得不处理的任何其他坏数据的例子。

不确定接下来要读什么？我为你挑选了另一篇文章:

[## 你不应该成为数据科学家的 4 个理由

为什么数据科学工作可能不适合你

towardsdatascience.com](/4-reasons-why-you-shouldnt-be-a-data-scientist-e3cc6c1d50e)

特伦斯·申

• 如果你喜欢这个， 在 Medium 上关注我 获取更多
• 报名我的邮箱列表 这里 ！
• 我们连线上LinkedIn
• 有兴趣合作？查看我的 网站 。

掌握 Python 中*args 和**kwargs 的 10 个例子

原文：https://towardsdatascience.com/10-examples-to-master-args-and-kwargs-in-python-6f1e8cc30749?source=collection_archive---------0-----------------------

如何使用和不使用它们

安德鲁·西曼在 Unsplash 上拍摄的照片

函数是 Python 中的构建块。它们接受零个或多个参数并返回值。就参数如何传递给函数而言，Python 相当灵活。*args 和**kwargs 使处理参数变得更加容易和简洁。

重要的部分是“*”和“**”。你可以用任何单词来代替 args 和 kwargs，但是通常的做法是用 args 和 kwargs。因此，没有必要进行不必要的冒险。

在这篇文章中，我们将讨论 10 个例子，我认为这些例子将使*args 和**kwargs 的概念变得非常清楚。

示例 1

考虑下面这个对两个数字求和的函数。

def addition(a, b):
   return a + bprint(addition(3,4))
7

这个函数只对两个数求和。如果我们想要一个三四个数相加的函数呢？我们甚至不想限制传递给函数的参数数量。

在这种情况下，我们可以使用*args 作为参数。

*args 允许函数接受任意数量的位置参数。

def addition(*args):
   result = 0
   for i in args:
      result += i
   return result

传递给加法函数的参数存储在一个元组中。因此，我们可以迭代 args 变量。

print(addition())
0print(addition(1,4))
5print(addition(1,7,3))
11

示例 2

在第二个例子之前，最好解释一下位置论元和关键字论元的区别。

• 位置参数仅由名称声明。
• 关键字参数由名称和默认值声明。

调用函数时，必须给出位置参数的值。否则，我们会得到一个错误。

如果我们没有为关键字参数指定值，它将采用默认值。

def addition(a, b=2): #a is positional, b is keyword argument
   return a + bprint(addition(1))
3def addition(a, b): #a and b are positional arguments
   return a + bprint(addition(1))
TypeError: addition() missing 1 required positional argument: 'b'

我们现在可以做第二个例子。可以同时使用*args 和命名变量。下面的函数相应地打印传递的参数。

def arg_printer(a, b, *args):
   print(f'a is {a}')
   print(f'b is {b}')
   print(f'args are {args}')arg_printer(3, 4, 5, 8, 3)
a is 3
b is 4
args are (5, 8, 3)

前两个值给 a 和 b，其余的值存储在 args 元组中。

示例 3

Python 希望我们把关键字参数放在位置参数之后。在调用函数时，我们需要记住这一点。

考虑下面的例子:

arg_printer(a=4, 2, 4, 5)SyntaxError: positional argument follows keyword argument

如果我们给位置参数赋值，它就变成了关键字参数。因为它后面是位置参数，所以我们得到一个语法错误。

实例 4

在下面的函数中，选项是一个关键字参数(它有一个默认值)。

def addition(a, b, *args, option=True):
   result = 0
   if option:
      for i in args:
      result += i
      return a + b + result
   else:
      return result

如果选项为真，此函数执行加法运算。由于默认值为 True，除非 option parameter 声明为 False，否则该函数将返回参数的总和。

print(addition(1,4,5,6,7))
23print(addition(1,4,5,6,7, option=False))
0

实例 5

**kwargs 收集所有没有明确定义的关键字参数。因此，除了关键字参数之外，它的操作与*args 相同。

**kwargs 允许函数接受任意数量的关键字参数。

默认情况下，kwargs 是一个空字典。每个未定义的关键字参数都作为键值对存储在kwargs 字典中。

def arg_printer(a, b, option=True, **kwargs):
   print(a, b)
   print(option)
   print(kwargs)arg_printer(3, 4, param1=5, param2=6)
3 4
True
{'param1': 5, 'param2': 6}

实例 6

我们可以在函数中同时使用args 和**kwargs，但是args 必须放在**kwargs 之前。

def arg_printer(a, b, *args, option=True, **kwargs):
   print(a, b)
   print(args)
   print(option)
   print(kwargs)arg_printer(1, 4, 6, 5, param1=5, param2=6)
1 4
(6, 5)
True
{'param1': 5, 'param2': 6}

例 7

我们可以使用*args 和**kwargs 打包和解包变量。

def arg_printer(*args):
   print(args)

如果我们将一个列表传递给上面的函数，它将作为一个单独的元素存储在 args tuple 中。

lst = [1,4,5]arg_printer(lst)
([1, 4, 5],)

如果我们在 lst 前加一个星号，那么列表中的值会被解包，单独存储在 args tuple 中。

lst = [1,4,5]arg_printer(*lst)
(1, 4, 5)

实施例 8

我们可以将多个 iterables 与单个元素一起解包。所有值都将存储在 args 元组中。

lst = [1,4,5]
tpl = ('a','b',4)arg_printer(*lst, *tpl, 5, 6)
(1, 4, 5, 'a', 'b', 4, 5, 6)

示例 9

我们也可以用关键字参数进行打包和解包。

def arg_printer(**kwargs):
   print(kwargs)

但是作为关键字参数传递的 iterable 必须是一个映射，比如字典。

dct = {'param1':5, 'param2':8}arg_printer(**dct)
{'param1': 5, 'param2': 8}

实例 10

如果我们还将额外的关键字参数与字典一起传递，它们将被合并并存储在 kwargs 字典中。

dct = {'param1':5, 'param2':8}
arg_printer(param3=9, **dct){'param3': 9, 'param1': 5, 'param2': 8}

结论

总结一下我们所讲的内容:

• 函数中有两种类型的参数，即位置参数(仅由名称声明)和关键字参数(由名称和默认值声明)。
• 调用函数时，必须给出位置参数的值。关键字参数是可选的(如果没有指定，则采用默认值)。
• *args 收集未显式定义的位置参数，并将它们存储在元组中
• • 除了关键字参数，kwargs 与args 的作用相同。它们存储在字典中，因为关键字参数存储为名称-值对。
• Python 不允许位置参数跟在关键字参数后面。因此，我们首先声明位置参数，然后声明关键字参数。

感谢您的阅读。如果您有任何反馈，请告诉我。

参考

https://calmcode.io/args-kwargs/introduction.html

掌握 Python 元组的 10 个例子

原文：https://towardsdatascience.com/10-examples-to-master-python-tuples-6c606ed42b96?source=collection_archive---------4-----------------------

综合实践指南

Javier Allegue Barros 在 Unsplash 上拍摄的照片

数据结构是任何编程语言的关键部分。为了创建健壮且性能良好的产品，人们必须非常了解数据结构。

在这篇文章中，我们将研究 Python 编程语言的一个重要数据结构，那就是元组。

元组是由逗号分隔并包含在括号中的值的集合。与列表不同，元组是不可变的。不变性可以被认为是元组的识别特征。

我将举例说明元组的特征和对它们的操作。

1.创建元组

元组由括号中的值组成，用逗号分隔。

a = (3, 4)print(type(a))
<class 'tuple'>

元组可以存储不同数据类型的值和重复值。

a = (3, 3, 'x', [1,2])print(a)
(3, 3, 'x', [1, 2])print(type(a))
<class 'tuple'>

我们也可以在不使用括号的情况下创建元组。由逗号分隔的值序列将创建一个元组。

a = 3, 4, 5, 6print(type(a))
<class 'tuple'>

2.创建包含 0 或 1 个元素的元组

具有零元素的元组只是一个空元组，创建如下:

a = ()print(type(a))
<class 'tuple'>

但是，有一个小技巧可以创建一个只有一个元素的元组。你需要在元素后面加一个逗号。否则，您将创建一个值类型的变量。

a = (3)
print(type(a))
<class 'int'>b = ([1,2])
print(type(b))
<class 'list'>

让我们做同样的事情，但是在值后面使用逗号:

a = (3,)
print(type(a))
<class 'tuple'>b = ([1,2],)
print(type(b))
<class 'tuple'>

3.元组是可迭代的

就像列表一样，您可以迭代一个元组。

a = (1, 2, 3)
for i in a:
   print(i**2)
1
4
9

4.索引和切片

索引和切片元组与列表相同。

a = (3, 5, 'x', 5)
print(f'The first element of tuple a is {a[0]}')
print(f'The last element of tuple a is {a[-1]}')The first element of tuple a is 3
The last element of tuple a is 5

和切片:

a = (1, 2, 5, 6, 7)print(a[-2:])
(6, 7)print(a[:3])
(1, 2, 5)

5.元组是不可变的，但是可以有可变的元素

不变性可能是元组最具识别性的特征。我们不能给元组中的单个项赋值。

a = (3, 5, 'x', 5)
a[0] = 7 #error

然而，元组可以包含可变元素，比如列表。

a = ([1,2], ['x', 'y'])a[0][0] = 99
a[1][0] = 't'print(a)
([99, 2], ['t', 'y'])

6.排序与已排序

因为元组是不可变的，所以我们不能对它们进行排序:

a = (3, 0, 2)a.sort() #error
'tuple' object has no attribute 'sort'

但是，排序函数可以将元组作为参数，并返回元组中值的排序列表。请注意，它不返回排序的元组。返回变量的类型是 list。

a = (3, 5, 8, 2)
b = sorted(a)print(b)
[2, 3, 5, 8]print(type(b))
<class 'list'>

创建于 pythontutor (图片由作者提供)

7.元组的长度

len 函数可以用来获得一个元组的长度。

a = (3, 0, 2)
len(a)
3

8.计数和索引方法

元组有计数和索引方法。count 方法返回一个值在元组中出现的次数。

a = (1, 'x', 1, 1, 'x')print(a.count('x'))
2print(a.count(1))
3

index 方法返回元组中某个值的索引。

a = (1, 'x', 3, 5, 'x')print(a.index('x'))
1print(a.index(1))
0

注意:如果一个值在一个元组中多次出现，index 方法返回第一次出现的索引。

9.将元组相加

“+”运算符可用于将元组相加。

a = (1, 2)
b = ('x', 'y')
c = a + bprint(c)
(1, 2, 'x', 'y')

10.返回多个值的函数

元组最常见的一个用例是使用返回多个值的函数。下面的函数采用一个数组，并返回数组中项目的总数和计数。

def count_sum(arr):
   count = len(arr)
   sum = arr.sum()
   return count, sum

这个函数返回的是一个包含两项的元组:

import numpy as np
arr = np.random.randint(10, size=8)a = count_sum(arr)print(a)
(8, 39)print(type(a))
<class 'tuple'>

奖金

元组和列表都是值的集合。最显著的区别是不变性。

由于不变性，复制元组和列表是不同的。我们在复制列表时需要更加小心，因为它们是可变的。

我们有三种方法复制一个列表并赋给一个新的变量:

x = [1, 2, 3]y = x
z = x[:]
t = x.copy()

列表 y、z 和 t 包含与 x 相同的值。然而，y 指向 x 的值，而 z 和 t 是完全不同的列表。

创建于 pythontutor (图片由作者提供)

因此，x 的任何变化都会引起 y 的变化。

x.append(4)print(y)
[1, 2, 3, 4]print(t)
[1, 2, 3]

复制列表时，我们需要非常小心。然而，我们不应该对元组有同样的关注，因为它们是不可变的。

当你复制一个元组并把它赋给一个新变量时，它们都指向内存中相同的值。

a = (1, 2, 3)b = a
c = a[:]

创建于 pythontutor (图片由作者提供)

感谢您的阅读。如果您有任何反馈，请告诉我。

10 个优秀的 GitHub 库，适合每一个 Java 开发者

原文：https://towardsdatascience.com/10-excellent-github-repositories-for-every-java-developer-41084a91ade9?source=collection_archive---------3-----------------------

面向 Java 开发人员的基本 GitHub 库的精选列表

照片由 克里斯蒂娜·莫里洛 发自 像素

ava 是无可争议的企业软件开发之王，也是最受欢迎的编程语言之一。它最近庆祝了自己的 25 岁生日，在未来几年里，它仍将是领先的编程语言之一。

GitHub 拥有超过 1 亿个知识库，就像软件开发中的“亚历山大图书馆”。GitHub 包含框架、库、教程、书籍，甚至编程语言。

如果你是一名 Java 开发人员，你想提高你的 Java 技能，那么 GitHub 对你来说就像一座金矿。但是从 GitHub 中找到合适的库就像大海捞针。

通过阅读本文，您将了解到 10 个优秀的 Java GitHub 库，分别是:

• 教程
• 学习材料
• 软件设计技能
• 演示应用

请注意，我没有列出流行的 Java 框架，也没有列出有用的 Java 库。

1.Java 设计模式

来源:GitHub

软件设计模式是软件工程师解决软件设计中反复出现的问题的可重用的通用解决方案。它还提供了一个通用的词汇表来讨论软件工程师和架构师之间的常见问题。设计模式可以通过使用久经考验的开发范例来提高代码质量和编码速度。学习设计模式的最好方法是看它们的实际应用，例如代码示例。

这个优秀的 GitHub 存储库拥有各种设计模式的 Java 实现:从最常见和最古老的设计模式(迭代器、单例)到最现代的设计模式(聚合器微服务、无服务器)。这个 GitHub 库不仅会提高你的编码技能，还会让你成为一个更好、更高效的开发者。

如果你是一名 Java 开发人员，从职业生涯开始到退休，你都需要这个 GitHub 库。

链接:

[## iluwatar/Java-设计-模式

设计模式是程序员可以用来解决设计和开发时常见问题的最佳形式化实践

github.com](https://github.com/iluwatar/java-design-patterns)

2.面谈

来源:GitHub

给一份编程工作面试是具有挑战性的。许多人只是在准备不充分的情况下去面试，然后责怪自己运气不好，没能得到这份工作。为面试做好充分的准备将会大大增加你获得理想工作的机会。这个 GitHub 知识库包含了你准备面试所需的一切:YouTube 视频、文章、现场编码实践、数据结构、算法、面试书籍、视频讲座。访谈还包含了针对 Java 中常见编码问题的 Leetcode。

这是另一个令人印象深刻的 GitHub 库，不仅对 Java 开发人员如此，对所有开发人员也是如此。在你的职业生涯中，你可能需要访问这个 GitHub 网站。

链接:

[## kdn 251/采访

得到这份工作你需要知道的一切。通过在…上创建帐户，为 kdn 251/访谈的发展做出贡献

github.com](https://github.com/kdn251/interviews)

3.算法

来源:GitHub

如果你是一名软件工程师，那么算法就是你日常生活的面包和黄油。使用正确的算法可以提高软件的性能。通常，为给定的约束(CPU 复杂性、内存消耗)选择正确算法的能力表明了软件工程师的素质。难怪算法在面试过程中被大量使用:无论是谷歌、微软这样的科技巨头公司，还是一家初创公司。

如果您是初级或中级 Java 开发人员，那么您会经常需要这个 GitHub 存储库。如果你是一个有多年经验的 Java 开发人员，你仍然会发现这个 GitHub 库很有用。

链接:

[## 算法/Java

注意:为这个 repo 创建了一个开发分支，我们试图将现有项目迁移到一个 Java 项目…

github.com](https://github.com/TheAlgorithms/Java)

4.真实世界

来源:GitHub

如果您正在用 Java 开发现代的 Fullstack 应用程序，那么您很有可能在前端使用最新的 JavaScript SPA，在后端使用 Java。 Realworld 提供开发一个应用程序“ Conduit ”(一个中型克隆)，使用几乎所有的前端和后端组合。开发者称它为“所有演示应用之母，”，因为它允许开发真实世界的应用。考虑到它所支持的前端/后端技术的庞大目录， Realworld 当然符合这个口号。

目前支持所有主流编程语言中所有可能的 JavaScript 前端框架(如 React、Angular、Vue、Svelte、AngularJS、Ember.js、Aurelia、Vanilla JS……)和所有可能的后端框架。在 Java 中，支持 Quarkus 和 Vert.x。

Realworld 也是你整个职业生涯都需要的 GitHub 资源库，尤其是如果你从事全栈开发的话。

链接:

[## 哥特斯特/现实世界

虽然大多数“待办事项”演示提供了一个框架功能的极好的粗略浏览，但它们通常不会传达…

github.com](https://github.com/gothinkster/realworld)

5.牛逼的 Java

来源:GitHub

经常会发生这样的情况，我们需要找一些和 Java 相关的东西，花上几个小时在 Google 上找。幸运的是，对于 Java 开发人员来说，这个 GitHub 库可以解决这种情况。牛逼 Java 包含了几乎所有和 Java 有关的东西，就像一本字典。无论你是在寻找一个字节码操作器还是机器学习库或实用程序库，Awesome Java 都有一个链接。

由非常活跃的 ca 社区维护。300 个贡献者，这个库定期更新。

链接:

[## akullpp/awesome-java

Java 编程语言的优秀框架、库和软件的精选列表。— akullpp/awesome-java

github.com](https://github.com/akullpp/awesome-java)

6.贝尔东教程

来源:GitHub

如果你是一名 Java 开发人员，你可能会遇到由 Baeldung 提供的各种教程和例子。目前，它是 Java、Web 和 Spring 开发教程的头号在线资源。Baeldung 与其他类似资料的不同之处在于，它涵盖了 Java/Spring 开发中从基础到高级的主题。除了教程，它还包含课程，指南，电子书等。Baeldung 的另一个重要特性是所有的例子和教程都是通过运行 GitHub 代码来支持的。

这个 GitHub 存储库包含 Java 和 Spring 开发领域的小型集中教程的集合，包括到教程文章的链接，其中对代码进行了更详细的解释。这也是 Spring 开发人员和普通 Java 开发人员必备的存储库。

链接:

[## eug enp/教程

更新:“Learn Spring Security OAuth”的价格将在 12 月 11 日永久更改，同时…

github.com](https://github.com/eugenp/tutorials)

7.吉普斯特

来源:GitHub

如果你在企业 Java 领域工作，那么你可能听说过 JHipster 。JHipster 提供了一个开发平台，用于生成、开发和部署基于生产级单片/微服务的 Web 应用程序。在前端，它提供前 3 名的 SPA 框架(Angular、React、Vue)，在后端，它提供 Spring Boot。它还支持所有主要的数据存储(Oracle、PostgreSQL、MySQL、MS-SQL、MongoDB、Cassandra、ELK、Kafka)。JHipster 还提供了非常高级的安全特性，比如 OAuth2+OpenID Connect。它还提供了许多扩展，这将帮助您开发一个基于 Spring Boot 的企业应用程序，几乎适用于任何环境，包括云。

这个项目非常强大和成熟，您可以用它开发您的 POC 甚至生产级应用程序。

链接:

[## jhipster/发电机-jhipster

你好，Java 潮人！完整的文件和信息可在我们的网站 https://www.jhipster.tech/…

github.com](https://github.com/jhipster/generator-jhipster)

8.RxJava Android 示例

来源:GitHub

近年来，反应式编程通过提供一个很好的抽象来处理异步和基于事件的编程，变得越来越流行。 RxJava 是react vex的 Java 实现，它通过可观察对象提供反应式编程。学习 Java 中的反应式编程有点挑战性，因为默认情况下，Java 提供了同步编程方式。在这个 GitHub 项目中，给出了 RxJava 的真实例子。尽管这些例子是针对 Android 开发给出的，但是 Java 开发人员也可以很容易地将它们应用于非 Android 开发。

链接:

[## kaushikgopal/rx Java-Android-Samples

这是一个知识库，其中包含了在 Android 上使用 RxJava 的真实有用的例子。它通常会在一个常数…

github.com](https://github.com/kaushikgopal/RxJava-Android-Samples)

9.Java8 教程

来源:GitHub

Java8 是发布的最具颠覆性和创新性的 Java 之一，因为它在 Java 中引入了“函数式编程”。有了 Lambda 和 Streaming 这样的概念，Java 最终进入了函数式编程领域，同时保持了其传奇的整体向后兼容性。

不幸的是，并不是所有的 Java 开发人员都充分利用了 Java 的新功能。我见过很多有经验的 Java 开发人员，他们还在用老派的方式开发 Java 程序。原因之一是，与传统的面向对象编程相比，函数式编程是一种范式转变，开发人员希望保持在他们的舒适区。

这个 GitHub 库包含了许多函数式编程概念的小而有用的例子(Lambda、Streams、函数接口、并行流等)。)写得很棒，可读性很强。如果您是 Java 函数式编程的新手，这个库将会给你很大的帮助。

链接:

[## winterbe/Java 8-教程

你也应该看看我的 Java 11 教程(包括 Java 9、10 和 11 的新语言和 API 特性)。欢迎来到…

github.com](https://github.com/winterbe/java8-tutorial)

10.破解 Java 中的编码面试

来源:GitHub

无论你应聘的是世界 500 强公司的编程工作，还是创业公司，你都很可能会经历一次编码面试。广受好评的书《破解编码面试》将帮助你准备富有挑战性的编码面试。这本书涵盖了所有类型和种类的编码挑战，包括算法复杂性、数学和逻辑难题、动态编程、排序和搜索、多线程等等。

使这本书与众不同的是，它还简单而优雅地解释了所有的例子。这个 GitHub 库包含了本书第六版的所有 Java 示例。即使你买不到原版书，浏览一下这个知识库对你的下一次面试也会很方便。

链接:

[## careercup/CtCI-第六版

此时您不能执行该操作。您已使用另一个标签页或窗口登录。您已在另一个选项卡中注销，或者…

github.com](https://github.com/careercup/CtCI-6th-Edition/tree/master/Java)

类似文章:

[## 每个开发人员都应该遵循的 20 个惊人的 GitHub 库

一个 GitHub 库集合，用于提高您的开发技能和促进您的职业发展

towardsdatascience.com](/20-amazing-github-repositories-every-developer-should-follow-d8ce4c728351) [## 每个 Java 开发人员都应该知道的 10 大库

Java 和 JVM 软件开发中基本 Java 库的精选列表

towardsdatascience.com](/top-10-libraries-every-java-developer-should-know-37dd136dff54) [## 您应该尝试的 25 个鲜为人知的 Java 库

对 Java 和 JVM 软件开发有很大帮助的库

towardsdatascience.com](/25-lesser-known-java-libraries-you-should-try-ff8abd354a94)

10 多种免费资源，用于下载机器学习数据集

原文：https://towardsdatascience.com/10-free-resources-to-download-datasets-for-machine-learning-2acfff33822?source=collection_archive---------15-----------------------

为您的机器学习和人工智能项目搜索和下载数据集的在线资源列表

我们可以这样说:这篇文章是数据集的集合[图片来自维基媒体的莫恩图书馆]。]

如果您正在从事机器学习(ML)项目，您可能知道为您的模型找到正确的数据集有多难。你可能致力于你的问题，把它定义为一个 ML 问题，但是现在没有数据来训练你的模型。也许你确实有一些数据，但不足以养活那些渴求数据的神经网络。或者也许你有很多数据，但是没有正确标记。谁说 ML 容易？

我去过那里很多次，一路上我发现了很多在线资源，这些资源帮助我找到了这些珍贵的数据。为了让你的工作更容易，我列出了这个免费的在线资源列表，你可以用它来获取你的 ML 项目的数据，任何你喜欢的主题。希望你觉得有用！

如果你正在寻找强化学习环境，我建议你查看一下我的文章，里面有一个列表。

谷歌数据集搜索

你可能已经知道了。它于 2018 年首次发布为测试版，最终在今年 1 月正式发布。没有它我们怎么活了这么久？我不确定，但我知道现在，当你寻找一个数据集时，它是第一个要去的地方。

谷歌数据集搜索首页。

这个搜索引擎实际上搜索了我下面列出的许多其他资源，并把你引导到数据集的下载页面。一旦你输入了你的关键词，你也可以使用许多选项来过滤你的搜索:最后更新，下载格式，使用权，主题和免费(或不免费)。这是非常有用的，是任何人在 ML，AI 或数据科学的必备。

链接:https://datasetsearch.research.google.com

卡格尔

Kaggle 是一个数据科学和 ML 实践者的在线社区(有趣的事实:它是 Google 的子公司。)Kaggle 非常适合学习和提高你的 ML 技能，事实上，我进入 ML 的第一步就是在 Kaggle 上。你可以找到几个比赛，在这些比赛中你可以比较和分享你的 ML 算法，如果你取得了最好的成绩，你甚至可以赢得金钱。

ka ggle 中的数据集页面。

但除此之外，Kaggle 还有自己的数据集页面，你可以用它来搜索 Kaggle 上目前托管的超过 40，000 个数据集。您还可以根据许可证、数据集大小和文件类型过滤您的搜索。尽管许多数据集质量非常高，但要注意的是，大多数数据集是由像你我这样的人提供的，很多时候数据的质量可能不是最好的。

链接:【https://www.kaggle.com/datasets

令人惊叹的公共数据集

由 Github 贡献者维护的大量免费数据集。该列表目前相当大，涉及许多不同的主题。正如你所料，搜索不像这个网站的其他选项那么容易，因为它只是一个。md 文件，其中包含数据集及其链接的列表，但它包含每个数据集的总体状态信息。

这是一个伟大的贡献，它拥有网络社区的温暖，所以至少对我来说，这增加了一些特别的东西。你也可以加入他们的休闲频道，如果你想为这个不断增长的列表做贡献的话。

链接:https://github.com/awesomedata/awesome-public-datasets

全球开放数据倡议

世界上有几个国家已经免费发布了各种主题的可用数据，如人口统计、领土、预算、法律、环境等。这些是非常宝贵的资源，我们必须感谢开放数据倡议。

全球开放数据指数地图视图【来自官网。]

在全球开放数据指数中，你可以找到一个国家及其开放数据指数的列表，该指数根据它们发布的数据源数量以及更新和管理的程度对它们进行排名。你也可以找到官方网站的链接，在那里你可以找到下载的数据资源。

链接:https://index.okfn.org/

你还可以在欧盟最近推出的开放数据门户中找到几个由欧盟发布的数据集。

嗯，这是谷歌在这个列表中的第三个，我保证这是最后一个。另一种找到数据集的方法是在 Google scholar 上搜索发表这些数据集的论文。这不是那么直接，事实上，这是一个有点老的学校，但它可以取得很大的成果。只需输入你喜欢的数据，然后输入“数据集”，幸运的话，一些研究人员可能已经发布了你可以使用的数据集。

你还可以在欧盟最近推出的 开放数据门户 中找到几个由欧盟发布的数据集。

谷歌学术

谷歌学术的标志【来自维基媒体。]

嗯，这是谷歌在这个列表中的第三个，我保证这是最后一个。另一种找到数据集的方法是在 Google scholar 上搜索发表这些数据集的论文。这不是那么直接，事实上，这是一个有点老的学校，但它可以取得很大的成果。只需输入你喜欢的数据，然后输入“数据集”，幸运的话，一些研究人员可能已经发布了你可以使用的数据集。

尽管不像前两个选项那么容易，但你能找到的数据集的质量通常非常好，因为论文通常由同行评审，并且必须达到一定的质量标准才能发表。此外，像这样发布的数据集几乎总是可以免费获得，并且可以以任何方式重用，只要你引用了正确的出版物。

链接:https://scholar.google.com

AWS 开放数据

AWS 上开放数据注册中心的主页。

亚马逊已经推出了自己的公开数据集存储库，你可以从这里进行搜索。亚马逊将这些数据集免费存储在亚马逊网络服务中，供所有公众使用，这使我认为这里的数据集列表将随着时间的推移继续增长。在撰写本文时，这个存储库中有 157 个数据集，因此没有太多选项可供选择。然而，发布的数据集质量非常高，因为亚马逊在发布之前会对其进行审查。

加州大学欧文分校机器学习知识库

加州大学欧文分校也拥有大约 500 个面向 ML 从业者的数据集。你可以找到各种各样的数据集:从最基本和最流行的如虹膜，到更复杂和新的如用于肩植入 X 射线制造商分类。

尽管数据集是由用户在其网站上捐赠的，但数据的质量总体来说似乎相当不错。我猜有一些来自 UCI 的人提供的数据集的“策展”,所以质量应该普遍良好。你可以在这里看到数据集的完整列表，并通过名称、默认任务和其他属性搜索它们。

链接:【https://archive.ics.uci.edu/ml/index.php

微软研究院开放数据

微软也加入了开放数据的行列，现在正在为研究人员和 ML 从业者共享几个有趣的数据集。他们目前托管着大约 100 个不同主题的数据集，如生物学、计算机科学、信息科学、教育等。

微软研究院开放数据网站中包含的数据类别。

数据的质量非常好，因为所有的数据集在发布到这里之前都是由微软策划的。他们可能会继续发布更多的数据集，所以这个知识库有很大的潜力。

链接:https://msropendata.com

学术洪流

学术洪流是一个很不错的网站，几周前才知道。它拥有一个非常大的数据集目录，用于研究目的，但你也可以用它们来学习和尝试。

您可以按名称或描述搜索数据集，并按大小排序。每个数据集都有一个很长的描述页面，您还可以在其中找到注释、许可条款以及在使用数据集时应该在出版物中使用的引用。顾名思义，你需要一个 BitTorrent 客户端来下载数据集，所以这有点复杂。

链接:http://academictorrents.com/browse.php

五三八

FiveThirtyEight 是一个专注于民意调查分析、政治、经济和体育博客的网站。我是通过查看他们的民意调查了解到这一点的，大部分是关于政治的，也用简单的情节进行了总结。但是 FiveThirtyEight 有一个不太为人知的功能:你可以从它的民意调查中下载数据。

数据的质量并不总是最好的，许多民意调查只有摘要，通常对 ML 来说是不够的。然而，你可以找到一些非常有趣的民意调查，你可以结合其他来源，我认为这是值得一提的。

链接:https://fivethirtyeight.com

股票数据:羊驼

好的，这不是一个真正的数据集资源，但是它给了你从股票市场下载历史数据和免费实时数据的可能性。多酷啊。

羊驼 是一家公司，其使命是为所有人提供使用算法进行交易的可能性。这意味着你不仅可以实时访问股票市场的数据，还可以用真钱或在模拟环境中进行交易。如果你想下载任何交易或投资 ML 项目的历史数据，你可以按照我上一篇文章中的步骤进行:

[## 如何在 Python 上访问股票市场数据进行机器学习

如果您想使用 ML 进行股票交易，您需要创建一个股票市场数据的数据集。了解如何…

towardsdatascience.com](/how-to-access-stocks-market-data-for-machine-learning-on-python-c69db51e7a0d)

包裹

老规矩，感谢阅读！我会试着用我发现的新资源来更新这个列表。如果你有任何其他的建议，请让我在回复中知道，这样我就可以把它添加到这个列表中。

直观解释的 10 种图形算法

原文：https://towardsdatascience.com/10-graph-algorithms-visually-explained-e57faa1336f3?source=collection_archive---------0-----------------------

10 种基本图形算法的快速介绍，包括示例和可视化

图形已经成为现实世界场景中建模和捕捉数据的强大手段，如社交媒体网络、网页和链接，以及 GPS 中的位置和路线。如果您有一组彼此相关的对象，那么您可以使用图形来表示它们。

作者图片

在这篇文章中，我将简要地解释 10 个基本的图形算法，它们对于分析和它们的应用变得非常有用。

首先，我们来介绍一张图。

什么是图？

一个图由一组有限的顶点或节点和一组连接这些顶点的边组成。如果两个顶点通过同一条边相互连接，则称它们为相邻。

下面给出了一些与图形相关的基本定义。您可以参考图 1 中的示例。

• 顺序:图中顶点的数量
• 尺寸:图中的边数
• 顶点度数:与一个顶点关联的边的数目
• 孤立顶点:图中不与任何其它顶点相连的顶点
• 自循环:从顶点到自身的边
• 有向图:所有边都有一个方向的图，指示什么是起始顶点，什么是结束顶点
• 无向图:边没有方向的图
• 加权图:图的边有权重
• 未加权图:图的边没有权重

图一。图形术语的可视化(图片由作者提供)

1.广度优先搜索

图二。BFS 遍历图形的动画(图片由作者提供)

遍历或搜索是可以在图形上执行的基本操作之一。在 广度优先搜索【BFS】中，我们从一个特定的顶点开始，在移动到下一层的顶点之前，在当前深度探索它的所有邻居。与树不同，图可以包含循环(第一个和最后一个顶点相同的路径)。因此，我们必须跟踪访问过的顶点。当实现 BFS 时，我们使用队列数据结构。

图 2 表示示例图的 BFS 遍历的动画。注意顶点是如何被发现的(黄色)和被访问的(红色)。

应用程序

• 用于确定最短路径和最小生成树。
• 由搜索引擎爬虫用来建立网页的索引。
• 用于在社交网络上搜索。
• 用于在对等网络(如 BitTorrent)中查找可用的邻居节点。

2.深度优先搜索

图三。图的 DFS 遍历动画(图片由作者提供)

在 深度优先搜索 (DFS)中，我们从一个特定的顶点开始，沿着每个分支尽可能远地探索，然后往回追溯(回溯)。在 DFS 中，我们也必须跟踪访问过的顶点。在实现 DFS 时，我们使用堆栈数据结构来支持回溯。

图 3 表示图 2 中使用的相同示例图的 DFS 遍历的动画。注意它是如何穿越到深处并返回的。

应用程序

• 用于查找两个顶点之间的路径。
• 用于检测图形中的循环。
• 用于拓扑排序。
• 用于解决只有一个解的谜题(例如迷宫)

3.最短路径

图 4。动画显示从顶点 1 到顶点 6 的最短路径(图片由作者提供)

从一个顶点到另一个顶点的 最短路径 是图中应该行进的边的权重之和最小的路径。

图 4 显示了一个动画，其中确定了从图中的顶点 1 到顶点 6 的最短路径。

算法

1. Dijkstra 最短路径算法
2. 贝尔曼-福特算法

应用程序

• 用于在谷歌地图或苹果地图等地图软件中查找从一个地点到另一个地点的路线。
• 在网络中用于解决最小延迟路径问题。
• 在抽象机器中使用，以确定通过在不同状态之间转换来达到某个目标状态的选择(例如，可用于确定赢得游戏的最小可能移动次数)。

图片来自 Pixabay 的丹尼尔·迪诺-斯洛弗

4.循环检测

图五。一个循环(作者图片)

循环是图中第一个和最后一个顶点相同的路径。如果我们从一个顶点出发，沿着一条路径行进，最后到达起始顶点，那么这条路径就是一个循环。 周期检测 就是检测这些周期的过程。图 5 显示了遍历一个循环的动画。

算法

1. 弗洛伊德循环检测算法
2. 布伦特算法

应用程序

• 用于分布式基于消息的算法。
• 用于在集群上使用分布式处理系统处理大规模图形。
• 用于检测并发系统中的死锁。
• 在加密应用程序中用于确定消息的密钥，这些密钥可以将该消息映射到相同的加密值。

5.最小生成树

图六。显示最小生成树的动画(图片由作者提供)

最小生成树 是一个图的边的子集，它连接所有顶点，边权重之和最小，并且不包含圈。

图 6 是显示获得最小生成树的过程的动画。

算法

1. 普里姆算法
2. 克鲁斯卡尔算法

应用程序

• 用于构建在计算机网络中广播的树。
• 用于基于图形的聚类分析。
• 用于图像分割。
• 用于社会地理区域的区域化，其中区域被分组为连续的区域。

6.强连通分量

图 7。强连接组件(图片由作者提供)

如果一个图中的每个顶点都可以从其他每个顶点到达，则称该图为 强连通的 。

图 7 显示了一个示例图，它有三个强连接的组件，顶点用红色、绿色和黄色表示。

算法

1. Kosaraju 算法
2. Tarjan 的强连通分量算法

应用程序

• 用于计算du lmage–Mendel Sohn 分解，这是二分图边的分类。
• 在社交网络中用于查找一组联系紧密的人，并根据共同兴趣提出建议。

图片由 Gerd Altmann 来自 Pixabay

7.拓扑排序

图 8。图中顶点的拓扑排序(图片由作者提供)

图的拓扑排序 是对其顶点的线性排序，使得对于排序中的每条有向边(u，v)，顶点 u 在 v 之前。

图 8 显示了顶点(1，2，3，5，4，6，7，8)的拓扑排序示例。你可以看到顶点 5 应该在顶点 2 和 3 之后。同样，顶点 6 应该在顶点 4 和 5 之后。

算法

1. 卡恩算法
2. 基于深度优先搜索的算法

应用程序

• 用于指令调度。
• 用于数据序列化。
• 用于确定编译任务在 makefiles 中的执行顺序。
• 用于解析链接器中的符号依赖关系。

8.图形着色

图九。顶点着色(图片由作者提供)

图形着色 在保证一定条件的情况下，给图形的元素分配颜色。顶点着色是最常用的图形着色技术。在顶点着色中，我们尝试用 k 种颜色给一个图的顶点着色，任何两个相邻的顶点都不应该有相同的颜色。其他着色技术包括边缘着色和表面着色。

图的色数是给图着色所需的最小颜色数。

图 9 显示了使用 4 种颜色的示例图的顶点着色。

算法

1. 使用广度优先搜索或深度优先搜索的算法
2. 贪婪着色

应用程序

• 用于安排时间表。
• 用于分配移动无线电频率。
• 用于建模和解决数独等游戏。
• 用于检查一个图是否是二分的。
• 用于给相邻国家或州具有不同颜色的国家或州的地理地图着色。

图片来自 Pixabay 的 TheAndrasBarta

9.最大流量

图 10。确定最大流量(图片由作者提供)

我们可以将一个图建模为一个流网络，用边权重作为流容量。在 最大流量 问题中，我们要找到一条可以获得最大可能流量的流路。

图 10 显示了确定网络最大流量和最终流量值的动画示例。

算法

1. 福特-富尔克森算法
2. 埃德蒙兹-卡普算法
3. 迪尼奇算法

应用程序

• 在航空公司排班中用来安排机组人员。
• 用于图像分割，以找到图像中的背景和前景。
• 用于淘汰那些无法赢得足够比赛以赶上其分区中当前领先者的棒球队。

10.相称的

图 11。二分图的匹配(图片由作者提供)

图中与 匹配的 是一组没有公共顶点的边(即没有两条边共享一个公共顶点)。如果一个匹配包含与尽可能多的顶点匹配的最大可能数量的边，则称之为最大匹配。**

图 11 显示了获得二分图的完全匹配的动画，其中两组顶点用橙色和蓝色表示。

算法

1. 霍普克罗夫特-卡普算法
2. 匈牙利算法
3. 开花算法

应用程序

• 用于做媒，撮合新娘和新郎(稳定的婚姻问题)。
• 用于确定顶点覆盖。
• 在运输理论中用于解决旅行中的资源分配和优化问题。

最后的想法

我希望您发现这篇文章作为简单而概括的图算法介绍是有用的。我很想听听你的想法。😇

您可以查看在 networkx 和 igraph python 模块中找到的图形算法的实现。你可以在我之前的文章python-igraph 新手指南中读到关于 Python-igraph 的内容。

[## Python-igraph 新手指南

python-igraph 常用函数的简单指南，包含示例和代码

towardsdatascience.com](/newbies-guide-to-python-igraph-4e51689c35b4)

你也可以看看我以前写的关于数据结构的文章。

[## 每个程序员都必须知道的 8 种常见数据结构

数据结构是一种在计算机中组织和存储数据的专门方法，以这种方式我们可以执行…

towardsdatascience.com](/8-common-data-structures-every-programmer-must-know-171acf6a1a42) [## C++中的数据结构—第 1 部分

在 C++中实现通用数据结构

towardsdatascience.com](/data-structures-in-c-part-1-b64613b0138d) [## 值得了解的 8 种有用的树数据结构

8 种不同树形数据结构的概述

towardsdatascience.com](/8-useful-tree-data-structures-worth-knowing-8532c7231e8c) [## 自平衡二分搜索法树 101

自平衡二分搜索法树简介

towardsdatascience.com](/self-balancing-binary-search-trees-101-fc4f51199e1d)

非常感谢您的阅读。😊

干杯！😃

10 个超参数优化框架。

原文：https://towardsdatascience.com/10-hyperparameter-optimization-frameworks-8bc87bc8b7e3?source=collection_archive---------5-----------------------

使用开源优化库调整您的机器学习模型

图片由来自 Pixabay 的jrg Felix拍摄

介绍

超参数是用于在建立模型时控制算法行为的参数。这些参数不能从常规训练过程中学习到。它们需要在训练模型之前被分配。

例子:n _ neighbors(KNN)kernel(SVC)max _ depth&criterion(决策树分类器)等。

机器学习中的超参数优化或调整是选择提供最佳性能的超参数的最佳组合的过程。

存在各种自动优化技术，当应用于不同类型的问题时，每种技术都有自己的优点和缺点。

例如:网格搜索、随机搜索、贝叶斯搜索等。

[## 4 种超参数调整技术

每个数据科学家都应该知道的流行超参数调整技术

medium.com](https://medium.com/swlh/4-hyper-parameter-tuning-techniques-924cb188d199) [## 超参数调整的数据泄漏

超参数调优有时会打乱您的模型，并导致对看不见的数据产生不可预测的结果。

towardsdatascience.com](/data-leakage-with-hyper-parameter-tuning-c57ba2006046)

Scikit-learn 是我们可以用于超参数优化的框架之一，但是还有其他框架甚至可以表现得更好。

1. 射线调谐
2. 奥普图纳
3. 远视
4. 多层机器
5. 多轴
6. 贝叶斯最优化
7. 塔罗斯
8. 夏尔巴人
9. sci kit-优化
10. GPyOpt

1.射线调谐

Tune 是一个 Python 库，用于实验执行和任意比例的超参数调谐。[ GitHub ]

关键特征

1. 用不到十行代码启动多节点分布式超参数扫描。
2. 支持任何机器学习框架，包括 PyTorch、XGBoost、MXNet、Keras 。
3. 在最先进的算法中进行选择，如基于人口的训练(PBT) 、 BayesOptSearch 、 HyperBand/ASHA 。
4. Tune 的搜索算法是开源优化库的包装器，如 HyperOpt、SigOpt、蜻蜓和脸书 Ax。
5. 使用 TensorBoard 自动可视化结果。

Scikit 学习调谐

安装:pip install ray[tune]tune-sk learn

2.奥普图纳

Optuna 是一个自动超参数优化软件框架，专门为机器学习而设计。

关键特征

1. 简单并行
2. 快速可视化
3. 高效优化算法
4. 轻量级、通用且平台无关的架构
5. python 式搜索空间

安装:pip 安装 optuna

3.远视

Hyperopt 是一个 Python 库，用于在笨拙的搜索空间上进行串行和并行优化，搜索空间可能包括实值、离散和条件维度。

目前它支持三种算法:

• 随机搜索
• Parzen 估计器树(TPE)
• 自适应 TPE

关键特征

1. 搜索空间(你可以创建非常复杂的参数空间)
2. 持续并重启(您可以保存重要信息并在以后加载，然后继续优化过程)
3. 速度和并行化(您可以将计算分布在一个机器集群上)

安装:pip 安装 hyperopt

[## 用 Hyperopt 实现 Python 中贝叶斯优化的介绍性示例

学习强大优化框架基础的实践示例

towardsdatascience.com](/an-introductory-example-of-bayesian-optimization-in-python-with-hyperopt-aae40fff4ff0)

4.多层机器

mlmachine 是一个 Python 包，它有助于进行整洁有序的基于笔记本的机器学习实验，并完成实验生命周期的许多关键方面。

mlmachine 通过贝叶斯优化对多个估值器执行超参数调整，并包括可视化模型性能和参数选择的功能。

一篇关于 mlmachine 的很好的解释文章。

[## 基于贝叶斯优化的多机超参数整定

这个新的 Python 包加速了基于笔记本的机器学习实验

towardsdatascience.com](/mlmachine-hyperparameter-tuning-with-bayesian-optimization-2de81472e6d)

安装:pip 安装 mlmachine

5.多轴

Polyaxon 是一个用于构建、培训和监控大规模深度学习应用的平台。它构建了一个系统来解决机器学习应用的可重复性、自动化和可扩展性。

Polyaxon 执行超参数调谐的方式是提供一系列可定制的搜索算法。Polyaxon 既支持简单的方法，如random search和grid search，也为高级方法提供简单的接口，如Hyperband和Bayesian Optimization，它还集成了工具，如Hyperopt，并提供运行定制迭代过程的接口。所有这些搜索算法都以异步方式运行，并支持并发和路由，以最大限度地利用集群的资源。

关键特征

1. 易于使用:Polyaxon 的优化引擎是一项内置服务，可以通过向您的操作添加一个matrix部分来轻松使用，您可以使用 CLI、客户端和仪表板运行 hyperparameter tuning。
2. 可扩展性:调整超参数或神经架构需要利用大量的计算资源，使用 Polyaxon 可以并行运行数百次试验，并直观地跟踪它们的进展。
3. 灵活性:除了丰富的内置算法，Polyaxon 还允许用户定制各种超参数调谐算法、神经架构搜索算法、提前停止算法等。
4. 效率:我们正集中精力从系统级和算法级进行更有效的模型调优。例如，利用早期反馈来加速调优过程。

安装 : pip install -U polyaxon

6.贝叶斯优化

贝叶斯优化是另一个框架，是高斯过程贝叶斯全局优化的纯 Python 实现。这是一个基于贝叶斯推理和高斯过程的约束全局优化包，试图在尽可能少的迭代中找到未知函数的最大值。这种技术特别适合于高成本函数的优化，在这种情况下，勘探和开发之间的平衡非常重要。

安装:pip 安装贝叶斯优化

7.塔罗斯

Talos 通过完全自动化超参数调整和模型评估，彻底改变了普通的 Keras 工作流程。Talos 完全公开了 Keras 功能，不需要学习新的语法或模板。

关键特征

1. 单线优化预测流水线talos.Scan(x, y, model, params).predict(x_test, y_test)
2. 自动化超参数优化
3. 模型概括评估器
4. 实验分析
5. 伪、准和量子随机搜索选项
6. 网格搜索
7. 概率优化器
8. 单个文件自定义优化策略

[## Talos 用户手册

欢迎来到塔罗斯！您可以使用 Talos 对 Keras 模型进行超参数优化。Talos 允许您使用 Keras…

autonomio.github.io](https://autonomio.github.io/docs_talos/#introduction) [## 使用 TPU 和塔罗斯对任何深度学习模型进行智能超参数优化

Keras API + Colab 张量处理单元+ Talos

towardsdatascience.com](/smart-hyperparameter-optimization-of-any-deep-learning-model-using-tpu-and-talos-9eb48d09d637)

安装:pip 安装 talos

8.夏尔巴人

SHERPA 是一个 Python 库，用于机器学习模型的超参数调优。

它提供:

1. 机器学习研究人员的超参数优化
2. 超参数优化算法的选择
3. 能够满足用户需求的并行计算
4. 用于结果探索性分析的实时仪表板。

安装:pip 安装参数-sherpa

9.sci kit-优化

Scikit-Optimize 或skopt，是一个简单而高效的库，可以最小化(非常)昂贵且嘈杂的黑盒函数。它实现了几种基于模型的顺序优化方法。skopt旨在在多种环境下易于访问和使用。Scikit-Optimize 支持调整 scikit-learn 库提供的 ML 算法的超参数，即所谓的超参数优化。

该库建立在 NumPy、SciPy 和 Scikit-Learn 之上。

安装:pip 安装 scikit-优化

10.GPyOpt

GPyOpt 是一个使用高斯过程优化(最小化)黑盒函数的工具。它已经被谢菲尔德大学的机器学习小组用 Python 实现了。GPyOpt 基于 GPy ，是 Python 中高斯流程建模的库。它可以通过稀疏高斯过程模型处理大型数据集。

主要特点

1. 任意约束的贝叶斯优化
2. 并行贝叶斯优化
3. 混合不同类型的变量
4. 调整 scikit-learn 模型
5. 整合模型超参数
6. 外部客观评价

安装:pip install gpyopt

感谢您的阅读！

非常感谢您的任何反馈和意见！

我的其他一些帖子你可能会感兴趣，

[## Python 中的 10 个正态性测试(分步指南 2020)

正态性检验检查变量或样本是否呈正态分布。

towardsdatascience.com](/normality-tests-in-python-31e04aa4f411) [## Python 中的“是”和“==”

加快字符串比较的速度

medium.com](https://medium.com/swlh/is-and-in-python-f084f36cbc0e)

重构 Python 代码的 10 种惯用方法

原文：https://towardsdatascience.com/10-idiotic-ways-to-refactor-your-python-code-cbb05bb0c820?source=collection_archive---------6-----------------------

提高您的 Python 技能

让您的 Python 代码更具可读性和性能

马丁·施瑞德在 Unsplash 上的照片

Python 是一种通用编程语言，广泛用于科学计算、人工智能、web 开发、金融建模和许多其他领域。它受欢迎的一个主要原因是它可以灵活地为各种操作提供多种解决方案。然而，在大多数情况下，有一个可能的愚蠢的解决方案是经验丰富的 Python 程序员更喜欢的。在本文中，我想回顾 10 个惯用案例，您可以考虑使用它们来重构您的 Python 代码。

1.（听力或阅读）理解测试

Python 中有三种常见的可变容器数据类型，包括列表、字典和集合。如果我们从一个 iterable 开始，我们可以使用 for 循环遍历 iterable，用 for 循环创建一个新的列表。但是惯用的方式是使用列表理解，其语法如下:[expression for x in iterable if any_condition]。请注意，条件求值部分是可选的。让我们看看下面的代码。

列表理解

除了列表理解，我们还可以使用词典和集合理解，它们分别被称为词典理解和集合理解。字典理解的语法如下:{key_expr: val_expr for item in iterable}，集合理解的语法为:{expr for item in iterable}。下面的代码向您展示了它们的用法。

字典和集合理解

2.f-刺

字符串是一种常见的原始数据类型，我们在几乎所有的项目中都使用它。为了显示字符串数据，在大多数情况下，我们需要进一步以特定的方式格式化字符串。我们可以用 C 风格的方法格式化字符串，包括使用%符号或 Python 字符串的 format 方法。

然而，在 Python 的最新版本中，引入了新的字符串格式化方法。它被称为 f-strings，代表格式化字符串——一种简洁易读的字符串格式化方法。让我们来比较一下这些不同的格式化方法。

f 弦

当然，上面的代码只是向您展示了 string 的最基本的用法，事实上它实现了 C-style 或者 string 的 format 方法支持的几乎所有格式样式。你可以在官方文档或我最近的文章中读到更多关于 f 弦的内容。

3.多重赋值和元组解包

当我们处理变量时，通常的做法是在每一行定义一个变量。然而，当我们声明多个变量时，我们可以在一行中完成。请注意，为了避免混淆，您可能希望声明语义相关的变量。如果他们服务于不同的目的，我不建议这样做。我们来看看下面的重构。

多重赋值

在底层，多重赋值涉及右边元组的创建和左边元组的解包。下面的代码展示了如何解包一个元组。如你所见，这看起来像多重赋值，因为它们使用相同的机制。

元组解包

4.一揽子拆包

在上一节中，我们回顾了如何使用最基本的格式解包元组——用相同数量的变量来表示元素中的每个元素。然而，当元组中有多个元素时，有时您可能希望使用 catch-all 方法来解包它。具体来说，变量没有明确表示的所有元素都将被带有星号前缀的变量捕获。为了获得相同的结果，非惯用方法通常涉及切片，如果我们错过了正确的索引，这很容易出错。

一揽子拆包

你可能注意到了，middle_numbers0和middle_numbers1的值不相等。这是因为在默认情况下，一揽子解包(使用星号)会生成一个列表对象。因此，为了使最终解包的数据具有相同的数据类型，我们可以使用 tuple 构造函数，如下所示。

从一揽子解包创建元组

5.赋值表达式

赋值表达式更好地称为使用海象运算符的海象表达式:=，它看起来像一只有一对眼球和长牙的海象，不是吗？顾名思义，赋值表达式允许你给一个变量赋值，同时，它也可以作为一个表达式使用，比如在 if 语句中。这个定义听起来令人困惑，让我们在下面的代码片段中看看它的用法。

赋值表达式

如上所示，当我们不使用赋值表达式时，我们必须首先获得账号，并用它来进行取款操作，这就产生了一些代码重复。相比之下，我们可以通过赋值表达式消除一行代码，它调用函数，同时将返回值赋给要计算的新变量。

有些人可能会认为保存一行代码没什么大不了的，但这让我们的意图更加明确，即变量account_number只在 if 语句的范围内相关。如果您有 SwIft 的编码经验，那么在 if 语句中赋值表达式的用法很像可选的绑定技术，如下所示。基本上，临时变量accountNumber只有在有效时才会在后续的作用域中使用。因此，您应该熟悉赋值表达式，过一会儿，您会发现代码可读性更好。

可选绑定

6.枚举迭代

几乎在每个项目中，我们都不可避免地让程序对列表、元组或其他容器数据类型中的所有元素重复特定的操作。这些重复的操作可以通过 for 循环来实现。通常，我们可以使用基本形式:for item in iterable。但是，对于迭代，如果我们需要跟踪当前迭代循环的计数，最好使用enumerate函数，它可以为我们创建计数器。此外，我们可以设置启动计数器的次数。

枚举迭代

7.用 zip/zip_longest 连接 Iterables

假设我们从两个 iterables 开始，我们想要为每一对对应的元素连接这两个 iterables。通常，我们可以通过从每个 iterable 中检索元素来使用索引方法，这样我们就可以将它们连接起来形成一个字典。然而，Python 有内置函数 zip ，这正是我们想要实现的。基本上， zip 函数接受多个 iterables，并创建一个长度与 iterables 中最短长度相匹配的 iterable。让我们看看下面的例子。

对 Iterables 使用 Zip

zip 函数的作用是创建一个迭代器 zip 对象，其中每个元素都是一个元组，由提供的 iterables 中的条目组成。需要注意的一点是，默认情况下， zip 函数会在到达任何 iterable 的末尾时停止。相比之下， zip_longest 函数将使用最长的可重复项。

上面惯用的方法是利用 dict 构造函数能够使用 iterable 来创建 dict 对象。除了上面的用法， zip 对象可以直接在迭代中使用，如下所示。

迭代中的压缩

8.串联可重复项

在上面的例子中，我们使用了 zip 函数来按元素连接 iterables。如果我们的特定业务需求是连接可重复项，我们应该怎么做？假设我们需要为同一个操作检查同一个类别的两个可迭代元素。我们可以通过使用链函数来实现这个功能。下面来看看用法。

链式迭代

如上所示，非惯用方法需要创建额外的列表，这不是最节省内存的。相比之下，链函数从这些最初定义的可迭代对象中创建一个可迭代对象。此外，链函数是灵活的，它可以接受任何类型的可迭代对象，这意味着它可以接受字典、集合、列表、 zip 对象、 map 对象(使用 map 函数)，以及 Python 中许多其他类型的可迭代对象。

9.三元表达式

如果我们需要给一个变量赋值，不同的值会根据条件被赋值。在这种情况下，我们可以使用 if 语句来评估条件，并确定使用什么值进行赋值。这通常涉及几行代码。但是，我们可以使用三元表达式，只用一行代码就可以完成这项工作，它具有以下通用语法:var = true_value if condition else false_value。我们来看看它们各自的用法。

三元表达式

10.发电机的使用

对于那些刚接触 Python 的人来说，生成器的概念可能并不熟悉，因为它在许多其他编程语言中并不是一种常见的技术。这是一个巧妙的技巧，允许您在不需要预先建立数据流的情况下处理数据流。相反，当要求生成器生成下一个值时，它会生成下一个值，这非常节省内存。

考虑下面这个微不足道的例子。假设我们需要处理一个文件中的大量数据。理论上，我们可以将整个文件读入一个列表，并处理列表中的每一行数据。然而，当文件非常大时，你的计算机完全有可能耗尽内存。相反，更好、更惯用的解决方案是从文件中生成一个生成器，每次只生成一行数据。

发电机

结论

在 Python 中，有许多更惯用的方法来做各种事情，本文中涵盖的主题只是我在日常项目中发现有用的技巧的不完整列表。我希望它们也能帮助你编写 Python 代码。最后一个提示是，您必须使用这些和其他习惯用法有目的地重构您的代码，这通常是更具性能的方式。通过不断地重构代码，您将逐渐提高您的 Python 编码技能。

感谢阅读这篇文章和快乐编码。

将 10 个有趣的 Python 内置函数和运算符放入您的工具箱

原文：https://towardsdatascience.com/10-interesting-python-built-in-functions-operators-to-put-in-your-toolbox-6ae2175f415a?source=collection_archive---------16-----------------------

来源: Unsplash

我们都至少有过这样的例子，当我们花了相当多的时间试图写一个函数，后来，我们意识到有一个内置函数或操作符。

Python 充满了有趣的内置函数，可以帮助任何应用程序节省时间——在本文中，我们将深入研究其中的 10 个。

r

为了表示一个新行，转义序列是\n。打印时，它显示为一个新行。对于\t等也是一样，只要放入一个字符串就执行。

r号操作员可以帮忙！

print('1'+'\t'+'hello')
print('2'+r'\t'+'hello')

输出:

1     hello
2\thello

格式映射(字典或对象)

与使用字符串的format类似，format_map允许引用字典中的条目。

举个例子，

dinner = {"Food": "Salad", "Drink": "Orange juice"}
print("Lunch: {Food}, {Drink}".format_map(dinner))

输出结果是

Lunch: Salad, Orange juice

当需要打印几个对象时，这非常方便——它保持了数据的结构化，并允许对要打印的变量进行无限制的存储。

%

您可能已经了解了%的字符串格式化功能:

a = "Hi %s" % ("there")
print(a)

…输出…

Hi there

但是您知道您可以对许多其他数据类型使用%操作符吗？

• %s用于字符串转换
• %c对于性格
• %d为带符号的十进制整数
• %e对于带小写 e 的指数符号
• %E对于带大写 e 的指数符号
• %f浮点实数

标题()

如果希望所有单词的第一个字符大写，而不是只大写第一个单词，可以用title()代替capitalize()。

print('1',capitalize('hello there'))
print('2',title('hello there'))

输出将是

Hello there
Hello There

居中(宽度，填充字符)

center返回在字符串中央格式化的字符串。可以用fillchar指定填充。

a = "hey" 
b = a.center(12, "-")
print(b)

这输出

----hey-----

因为“hey”是三个字母，即使指定的 with 是 12，最大字符center()可以容纳的是 11 (3 代表“hey”，每边四个破折号)。

复制()

说你有一个单子l1 = [1,2,3,4,5]。我们想要创建一个列表的副本，l2，所以你分配l2 = l1。

但是当我们对l2做任何事情的时候，比如说l2.pop(2)，l1也会受到影响，甚至在无意改变l1的时候。

l1 = [1,2,3,4,5]
l2 = l1
l2.pop(2)
print('l2',l2)
print('l1',l1)

输出:

l2 [1, 2, 4, 5] 
l1 [1, 2, 4, 5]

若要复制列表而不影响前一个列表，请使用 copy()。这将创建一个相同的副本，可以在不影响其父列表的情况下进行更改。

l1 = [1,2,3,4,5]
l2 = l1.copy()
l2.pop(2)
print('l2',l2)
print('l1',l1)

输出:

l2 [1, 2, 4, 5] 
l1 [1, 2, 3, 4, 5]

encode(编码='utf8 '，错误='strict ')

这个函数以 bytes 对象的形式返回字符串的编码版本。默认编码是utf-8。这允许编码之间的快速转换，当某些函数只能接受某些编码时，这很有帮助。

errors可以给定设置不同的错误处理方案。errors的可能值是:

• strict(编码错误引发一个UnicodeError)
• ignore
• replace
• xmlcharrefreplace
• backslashreplace
• 通过codecs.register_error()注册的任何其他名称

expandtabs(tabsize=8)

该函数返回一个字符串，其中所有的制表符被一个或多个空格替换，这取决于当前列和制表符的大小。

a = "1\t2\t3"
print(a)
print(a.expandtabs())
print(a.expandtabs(tabsize=12))
print(a.expandtabs(tabsize=2))

输出

1 2 3 
1       2       3 
1           2           3 
1 2 3

分区(分割器)

如果.split(splitter)忽略了分割器，只返回分割器两边的字符串，那就试试partition(splitter)。

print('abcdefg.hijklmnop'.partition('.'))

输出

['abcdefg','.','hijklmnop']

清除()

clear()函数是一种清空列表内容的干净方式。

a = ['a','b','c','d']
print(a)
a.clear()
print(a)

输出将是

['a','b','c','d']
[]

在本文中，我们讨论了各种方便的内置方法，从字符串处理(r、expandtabs、title等等)。)到列表(copy、partition、clear)，等等。有了这些函数，您将能够清理和增强您的代码。

感谢阅读！

让你大吃一惊的 10 个有趣的 Python 技巧

原文：https://towardsdatascience.com/10-interesting-python-tricks-to-knock-your-socks-off-1dd4d8e82101?source=collection_archive---------14-----------------------

提高代码效率的 10 个 python 代码片段的重要列表

安德烈·格拉在 Unsplash 上拍摄的照片

Python 被认为是迄今为止最通用的编程语言，在不同领域有着广泛的应用。如果您已经掌握了 Python 的基础知识，那么是时候探索可以在日常工作中帮助您的独特代码片段了。

以下是 10 个特性或片段，它们可能会给你留下深刻印象，并有助于提高代码效率。

将不常用的类别合并成一个

有时你会得到一个元素分布不均匀的列。仅仅存在几个类别。您通常希望将这些类别合并成一个类别。

df.artists.value_counts()

这里，我们希望将 Coldplay 和 Weekend 合并到一个类别中，因为它们仅对数据集有影响。

首先，我们需要找到我们不想改变的元素，即阿姆、泰勒·斯威夫特和布鲁诺·马斯

myList = df.artists.value_counts().nlargest(3).index

我们将使用 where()函数来替换其他元素

df_new = df.where(df.artists.isin(myList),other='other artists')
df_new.artists.value_counts()

这就是我们需要修改的更新专栏。

查找列表中的新元素

当我们有两个不同的列表，我们需要找到在一个列表中出现但在另一个列表中不出现的元素

考虑两个列表

A = [ 1, 3, 5, 7, 9 ]
B = [ 4, 5, 6, 7, 8 ]

为了找到列表 A 的新元素，我们取 A 与 B 的集合差

set(A) - set(B)

值 1、3 和 9 只出现在列表 A 中，而不在列表 b 中。

Map()函数

Map 函数接受两个参数 function 和 iterable，并返回结果的映射

map(func,itr)

func 是一个函数，map 将给定 iterable 的每个元素传递给它。
itr 是要映射的可迭代对象。

def product(n1,n2): 
    return n1 *n2 list1 = (1, 2, 3, 4) 
list2 = (10,20,30,40)result = map(product, list1,list2) 
list(result)

让我们来分解代码

product 函数接受两个列表并返回两个列表的乘积。

列表 1 和列表 2 是两个列表，它们将作为我们地图函数的可迭代列表

map ()取乘积函数和 iterable → list1 和 list2，最后返回两个列表的乘积作为结果。

Map + Lambda 组合

可以使用 lambda 函数替换 product 函数来修改上面的代码

list1 = (1, 2, 3, 4) 
list2 = (10,20,30,40)
result = map(lambda x,y: x * y, list1,list2) 
print(list(result))

Lambda 函数有助于避免单独编写函数的开销。

开始、停止和设置

照片由布鲁诺·纳西门托在 Unsplash 上拍摄

slice(start:stop[:step]) 是通常包含一部分序列的对象。

• 如果只提供了 stop，它将生成从索引 0 到 stop 的序列部分。
• 如果只提供 start，它将生成从索引开始到最后一个元素的序列部分。
• 如果同时提供了 start 和 stop，它将生成从索引开始到停止的序列部分。
• 如果提供了 start、stop 和 step 这三个参数，它将在索引开始后生成序列的一部分，直到以索引步长的增量停止。

x = [ 1, 2, 3, 4, 5, 6, 7, 8 ]
x[ 1: 6: 2]

从上面的代码来看，1 是我们的开始索引，6 是我们的停止索引，2 是我们的步进索引。这意味着我们从索引 1 到索引 6 开始，步长为 2。

您也可以使用[::-1]操作翻转列表

x[::-1]

是的，用开始、停止和步进操作来反转整个列表是很容易的。

一起压缩和枚举

您可能听说过 zip 和 enumerate 函数。它们主要与一起用于循环。但是把它们放在一起使用更酷。它不仅允许您在一个循环中迭代多个值，还可以同时获得索引。

NAME = ['Sid','John','David']
BIRD = ['Eagle','Sparrow','Vulture']
CITY =['Mumbai','US','London']for i,(name,bird,city) in enumerate(zip(NAME,BIRD,CITY)):
    print(i,' represents ',name,' , ',bird,' and ',city)

Zip 函数帮助你把所有的列表放在一起，这样你就可以同时遍历每一个列表，而 Enumerate 函数帮助你获取索引以及附加到该索引的元素。

随意采样

有时，当您遇到非常大的数据集时，您决定处理数据的随机子集。pandas dataframe 的示例功能可帮助您实现更多功能。

让我们考虑一下上面已经创建的艺术家数据帧

df.sample(n=10)

这有助于获得数据集的 10 个随机行。

df.sample(frac=0.5).reset_index(drop=True)

让我们分解上面的代码，

frac 参数取 0 到 1 之间的值，包括 1。它取分配给它的数据帧的一部分。在上面的代码片段中，我们指定了 0.5，因此它将返回大小为→ 0.5 *原始大小的随机子集

你可以注意到它前面的 reset_index 函数。这有助于正确重置索引，因为当我们获取随机子集时，索引也会被打乱。

消除警告

由 Christian Erfurt 在 Unsplash 上拍摄的照片

在运行代码时，您经常会收到很多警告。过了一点，它开始激怒我们。例如，每当您导入纪元时，您可能会收到一条未来警告消息

您可以用下面的代码隐藏所有警告。请确保将这一点写在代码的顶部。

import warnings 
warnings.filterwarnings(action='ignore')
import keras

这将有助于隐藏整个代码中的所有警告。

保存你的记忆

随着对编码的深入研究，您开始意识到高效内存代码的重要性。生成器是一个函数，它返回一个我们可以迭代的对象。这有助于有效地利用内存，因此主要在我们迭代无限长的序列时使用。

def SampleGenerator(n):
    yield n
    n = n+1
    yield n
    n = n+1
    yield ngen = SampleGenerator(1)

Yield 语句暂停保存所有状态的函数，稍后在后续调用中继续。

print(next(gen))
print(next(gen))
print(next(gen))

正如你所看到的，yield 保存了前一个状态，每当我们调用下一个函数时，它就转移到下一个 yield，返回新的输出。

您可以通过添加一个在生成器函数中无限运行的 while 循环来迭代单个 yield。

def updatedGenerator(n):
    while(1):
        yield n
        n = n + 1
a = updatedGenerator(1)for i in range(5):
    print(next(a))

while 语句帮助我们一遍又一遍地迭代相同的 yield 语句。

小艇——救星

终于把最好的留给了我的最后一次。有没有遇到过读取一个 csv 文件太大，以至于你的内存无法容纳它的情况？Skiprows 帮你轻松应对。

它允许您指定数据帧中要跳过的行数。

考虑一个 100 万行的数据集，它不适合您的内存。如果您指定 skiprows = 0.5 百万，它会在读取数据时跳过数据集中的 0.5 百万行，从而使您可以轻松地读取数据帧的子集。

df = pd.read_csv('artist.csv')
df_new = pd.read_csv('artist.csv',skiprows=50)
df.shape, df_new.shape

在上面的代码片段中，df 表示一个 112 行的数据集。在添加 skiprows=50 之后，它从您的数据集中跳过了 50 行，因此读取 62 行作为我们的新数据集。

由保罗·花冈在 Unsplash 上拍摄的照片

感谢您阅读文章。希望你喜欢！

构建成功神经网络的 10 个宝贵技巧和诀窍

原文：https://towardsdatascience.com/10-invaluable-tips-tricks-for-building-successful-neural-networks-566aca17a0f1?source=collection_archive---------38-----------------------

来源: Unsplash

给非结构化的任务带来结构化

建立神经网络很困难，因为涉及到太多的可变性。有了这 10 个技巧和诀窍，你不仅会有具体的改变尝试，而且会有一个策略和心态来处理建立一个成功的神经网络的模糊任务。

输出层的激活功能

神经网络的最后一层对于获得正确的结果非常重要，因为它是预测过程的最后一步。此外，最后一层的激活函数是网络的信息流作为预测输出之前的最后一个函数。获得正确的功能很重要。

sigmoid 函数用于二进制输出。例如，如果一个网络要预测一个图像是一只猫还是一只狗，sigmoid 将是正确的选择。sigmoid 函数(数学上定义为1/(1+e^(-x)))是 logit 函数的反函数，这就是为什么它是建模概率的自然选择。

来源:乙状结肠函数。来源:维基媒体。图片免费分享。

另一方面，如果您有多个输出，例如将图像分类为 10 个可能的数字，我们将使用 SoftMax 函数，这是 sigmoid 函数针对多个类别的扩展，限制所有概率必须加到 1。例如，如果对四个类别的预测是[0.48, 0.23, 0.56,0.03]，这是一个非法的结果，因为概率集中在它们总和总是 100%的事实上。

由于 sigmoid 和 SoftMax 都是有界函数，这意味着它们的y-值不能高于或低于某个值(0 和 1)，因此它们无法处理回归问题，回归问题是连续值，而不是概率。

取而代之的是使用线性激活函数(y=x)，它是没有边界的。此外，如果所有的y-值都大于 0，使用 ReLU 也是可以接受的，因为线的斜率(max(0, ax)中的a)是可调参数。或者，可以使用像漏 ReLU 或 eLU(指数线性单位)这样的两侧无界的激活。

来源: ML 从零开始。图片免费分享。

使用预训练模型

从头开始学习一切是很困难的——即使作为人类也是如此——这就是为什么拥有一些通用知识作为进一步学习的基础是有益的。在图像识别领域，可以访问和进一步微调几个预先训练的模型，如 VGG16 和 Inception，它们被设计和训练来识别对象。

例如，考虑在图像中识别一只狗或一只猫的任务；虽然人们可以从头开始构建神经网络，但为什么不使用已经证明可以完成类似任务的架构和权重呢？提供预训练模型的库还允许用户在模型之前或之后叠加额外的层，以实现一定的可定制性。

在自然语言处理中，嵌入被用于将单词或其他标记从它们的高维矢量化形式映射到较低维空间。相对于数据集的上下文具有相似含义或处于相似类别的单词(例如，water & liquid、king & man、queen & woman)在物理上被放置得更近。

嵌入是有价值的，因为它们是在昂贵的神经网络操作之前提取单词的更深层次含义的成本较低的方法。它们有效地降低了数据的维度，可以使用 t-SNE 等多种学习技术进行可视化和解释，以确保网络处于正确的学习轨道上。

像 GloVE 这样的预训练嵌入，或者单词表示的全局向量，是在世界上最大的文本存储库，比如维基百科上创建的。在你的模型中加入预先训练的元素增加了它的能力并减少了猜测。

嵌入的能力。来源: Tensorflow 。免费分享图片

查看这些资源:在 Keras 中使用预训练图像识别模型，在 Keras 中使用预训练嵌入的指南，在 Keras 中使用嵌入的指南。

刺激健康的梯度流动

尤其是对于深度网络，优先考虑健康的梯度流总是很重要的。只有当架构的构建方式使得信号可以通过整个网络时，反向传播才能有效工作。如果它逐渐变小，前面的层不会改变(消失梯度问题)，如果它被放大太多，随着时间的推移，重量转移变得如此极端，以至于它们变成 NaN。

• 采用跳过连接。这些是跨越层的连接，这意味着梯度即使被有问题的层阻挡也可以继续。这些联系是成功的 ResNet 架构的核心(这是一个预训练的模型，可以在大多数深度学习库中访问)。
• 使用批量归一化图层。这些不仅使输入标准化以确保最佳训练，还平滑了误差空间，允许优化器更容易地工作。
• 尝试使用无限激活。消失梯度问题通常是由 tanh、sigmoid 和 softmax 等有界函数引起的，因为在训练的早期阶段自然移动的输入最终具有逐渐减小的相对重要性。
  一边无界的 ReLU，通常是默认；有时候，像 Leaky ReLU 这样的替代品表现更好；一般来说，除了最后一个输出层，有界函数不会被广泛使用。
  阅读这篇可以直观地了解 ReLU 为何如此有效，以及线性单元如何增加宝贵的非线性。

谨记监管

训练神经网络是一项艰巨的任务，它高度依赖于各种参数和初始化。监管可以起到护栏的作用，防止神经网络偏离其目的太远，这个目的相当抽象:不要对数据过拟合，也不要对数据过拟合。

当然，实际目标是在测试集上表现良好，但是神经网络不应该暴露于它，否则它首先就不是测试集。自然地，一个神经网络——被设计来近似函数——将适合这些数据。监管可以防止它过度拟合，或者通过记忆数据点而不是实际学习概括来采取简单的方法。

添加漏失层可能是在神经网络中添加规则的最简单方法。Dropout 随机阻止一小部分神经元连接到下一层，因此直观上它可以防止网络传递过多的特定信息。有许多其他的角度来理解为什么辍学工作得这么好——例如，它可以被认为是一个整体或渐进的更新。在这里阅读更多。

来源。图片免费分享。

此外，L2 正则化是另一种控制权重的方法，尽管这可能是一种不太“自然”的方法。不管用什么方法来实现它，正则化和梯度流应该是建筑设计的前沿。

不要太在意确切的数字。

构建神经网络可能令人望而生畏，因为这个过程中有太多可变因素——层数、每层中神经元的数量、层的类型等。然而，有可能改变神经元的数量并不会真正改变预测能力。

在教程中，您可能经常会看到每层中的神经元数量或批量大小被写成 2 的幂。虽然有一些研究声称使用 2 的幂更有效(这与高效的 GPU 使用和位有关……？)，它们很可能不是通用的。对于超参数的选择，使用 2 的幂在任何方面都是最优的，这一点还没有得到决定性的证明。

但是，这是一个很好的方法，原因如下:

• 它为一个过程提供了结构。如果一层中的神经元应该是 25 或 26，而不是坐立不安，只要确定在 32。这是一个选择神经元大小的方便模板。
• 这是一种对数搜索方法。由于 32 到 33 个神经元之间的变化远小于从 1 到 2 的变化，所以我们每次都将神经元的数量增加一倍，以搜索下一个似乎合理的神经元是有道理的。如果你发现你想改变一层中神经元的数量，将它减半或加倍，以观察任何真正的潜在变化。

当然，通过网络的信息流来思考是好的，但层数或神经元数在一定范围内是相对任意的。为了更直观的解释，探索一下通用近似定理，它展示了神经网络如何处理任务以及单个神经元在预测中扮演的角色。

尽量少设置常量

一般来说，建模的哲学是遵循数据，尽可能减少对硬编码常数的依赖。这对于神经网络来说尤其如此，但却很困难。虽然某些常数(如层中神经元的数量或过滤器的大小)必须是硬编码的*，但如果可以的话，尽量不要自己设置常数，因为这些是潜在的错误来源。

例如，不要硬编码学习率。您可以设置一个较高的初始学习率，并使用类似于的工具在平稳期降低学习率，以便在性能停滞时自动调整学习率。对于神经网络的许多其他复杂参数来说也是如此——作为一种非常动态的算法，一些参数根本无法保持固定。

*然而，通常使用非常少的常量硬编码和机器学习算法自动选择神经网络架构的开发是非常新且有前途的。

利用预处理层

Keras 和其他几个深度学习库提供了预处理库，可以作为神经网络的前几层添加，例如在向量化文本、标准化图像或标准化数据方面。为了使您的模型易于移植和使用，使用预处理层进行部署总是一个好主意。

点击这里，阅读 Keras 中的预处理图层。

数据扩充

如果您没有在图像识别任务中使用数据扩充，那么您就是在浪费数据集。

图像数据很难获得，如果一个网络只能从如此昂贵的信息中提取有限的学习内容，那将是一种耻辱。数据扩充通过将图像通过随机生成的过滤器来人为地增加数据集的大小，过滤器可以应用缩放、旋转、翻转、变暗、变亮、变白、颜色变化等。

数据扩充的示例结果。来源: Keras 。图片免费分享。

当数据增强被正确应用时，它可以提高网络归纳到图像的能力，并更好地解决对象识别中的现实问题，如敌对/恶意输入，例如，它可以欺骗识别标志的自动驾驶汽车以致命的速度加速。

了解数据生成器中的各种参数，以及为什么您需要小心使用哪些参数这里是。

更多数据！

更多的数据当然是最好的解决方案。最花哨的算法甚至无法与一批好数据带来的好处相提并论:数据是有价值的，因此也是昂贵的商品。简单地加入额外的数据可以拓宽模型的视野，这比花费数小时来微调模型的技术参数要好得多。

在本文的中，我使用简单的随机森林回归模型，通过添加按国家统计的维基百科数据，将冠状病毒预测的平均绝对误差降低了十倍以上。

利用现有模型的灵感。

要构建一个伟大的神经网络，就要向大师们看齐！像伯特、、谷歌神经机器翻译 (GNMT)和盗梦空间这样的现有模型是出于某些原因以某些方式构建的。

Inception 以模块化格式构建，具有多个堆叠的 Inception 单元。它在其他卷积之前使用 1x1 卷积，并出于某些原因对汇集和卷积进行排序。GNMT 在 Google Translate 的编码器和解码器中各堆叠了八个 LSTMs，虽然你可能不关心翻译是如何工作的，但探索该架构如何处理这样一个深度循环架构并将其应用到你的 RNN 设计中是值得的。

创新的 Inception v3 架构，充满了出色的架构决策。资料来源:杰瑞米·乔登。图片免费分享。

最好的技巧和诀窍来自顶级公司和研究部门的创新，开发最新的方法和培养最新的概念。花时间去探索和理解想法。

感谢阅读！

[## 11 个基本的神经网络架构，可视化和解释

标准、循环、卷积和自动编码器网络

medium.com](https://medium.com/analytics-vidhya/11-essential-neural-network-architectures-visualized-explained-7fc7da3486d8)

10 个鲜为人知的用于机器学习的 Python 库

原文：https://towardsdatascience.com/10-lesser-known-python-libraries-for-machine-learning-fca7ad32e53c?source=collection_archive---------48-----------------------

十个你可能不知道的简化机器学习过程的工具

克里斯娅·克鲁兹在 Unsplash 上的照片

Python 凭借 Scikit-learn、Tensorflow 和 Keras 等非常受欢迎的核心包主导了机器学习领域。有一个非常活跃的开发人员社区，致力于开发其他不太知名的库，这些库不仅为模型开发，也为围绕模型开发的许多过程提供了实用工具。包括数据预处理、特征工程和模型解释。

在这篇文章中，我想分享十个我最喜欢的不太为人所知的 Python 库，它们会让你的机器学习生活变得更加容易！

1.熊猫-ml

[## 欢迎来到熊猫-ml 的文档！- pandas_ml 0.3.0 文档

编辑描述

熊猫-ml.readthedocs.io](https://pandas-ml.readthedocs.io/en/latest/index.html)

该库将 pandas、Scikit-learn、XGBoost 和 Matplotlib 功能集成在一起，以简化数据准备和模型评分。

在数据处理方面，pandas-ml 使用一种称为 ModelFrame 的数据格式，其中包含元数据，包括关于要素和目标的信息，以便可以更容易地应用统计数据和模型函数。

因为 ModelFrame 继承了熊猫的所有特征。DataFrame 所有熊猫的方法都可以直接应用到你的机器学习数据上。

2.类别编码器

[## 类别编码器-类别编码器 2.2.2 文档

一套 scikit-learn 风格的转换器，用于使用不同的技术将分类变量编码成数字…

contrib.scikit-learn.org](http://contrib.scikit-learn.org/category_encoders/index.html)

类别编码器库简化了机器学习中分类变量的处理。它可以单独用于转换变量，但也可以与 Scikit-learn 集成，并可以在 Sckit-learn 管道中使用。

尽管 Scikit-learn 有一些将分类特征转换成数字的功能，比如一键编码和序号编码器，但是分类编码器提供了更广泛的方法来处理这些数据类型。特别是，它包含了许多处理高基数特性(具有大量唯一值的特性)的方法，例如证据转换器的权重。

3.黄砖

[## Yellowbrick:机器学习可视化- Yellowbrick v1.1 文档

不管你的技术水平如何，你都可以提供帮助。我们感谢错误报告、用户测试、功能请求…

www.scikit-yb.org](https://www.scikit-yb.org/en/latest/)

Yellowbrick 是一个专门为 Scikit-learn 开发的机器学习模型设计的可视化库。该库提供了广泛的易于使用的可视化，有助于机器学习过程的各个方面，包括模型选择、特征提取以及模型评估和解释。

4.Shap

[## slundberg/shap

SHAP 是一种博弈论的方法来解释任何机器学习模型的输出…

github.com](https://github.com/slundberg/shap)

Shap 库使用一种基于博弈论的技术来为任何机器学习模型的输出提供解释。它可以为使用最流行的 python 机器学习库(包括 Scikit-learn、XGBoost、Pyspark、Tensorflow 和 Keras)开发的模型提供可解释性。

5.特征引擎

[## 快速启动-功能-引擎 0.4.3 文档

如果您是功能引擎的新手，本指南将帮助您入门。特征引擎转换器有 fit()和…

feature-engine.readthedocs.io](https://feature-engine.readthedocs.io/en/latest/quickstart.html)

Feature engine 是一个开源 python 库，旨在使各种各样的功能工程技术易于使用。特征工程通常包括以下步骤:

• 输入缺失值
• 离群点去除
• 编码分类变量
• 离散化和标准化
• 工程新功能

特征引擎库包含执行大多数这些任务的函数和方法。该代码使用 fit()和 transform()方法遵循 Scikit-learn 功能，并且可以在 Scikit-learn 管道中使用。

6.功能工具

要素工具是用于自动化要素工程的 Python 框架。该库采用单个数据集或一组关系数据集，并运行深度特征合成(DFS)来创建现有和新生成特征的矩阵。该工具可以在特征工程过程中节省大量时间。

7.Dabl

[## 欢迎来到 dabl，数据分析基线库- dabl 文档

欢迎来到数据分析基线库 dabl

• dabl 文档欢迎来到数据分析基线库 dabl.github.io](https://dabl.github.io/dev/)

Dabl 包旨在自动化一些常见的重复性机器学习任务，如数据清理和基本分析。Dabl 使用“最佳猜测”理念来应用数据清理流程，但允许用户在必要时检查和修改流程。

我之前在去年的这个帖子中写过一篇更全面的 Dabl 指南。

8.惊喜

[## 主页

Surprise 是一个 Python scikit，它构建并分析处理显式评级数据的推荐系统。惊喜…

surpriselib.com](http://surpriselib.com/)

这个库是为 Python 中显式推荐引擎的简单实现而设计的。它有一个非常类似于 scikit 的界面——如果您已经是该库的用户，那么学习起来非常直观。它有广泛的内置算法，你可以评估你的数据，但你也可以建立自己的。还有用于交叉验证和超参数优化的工具。

9.Pycaret

[## 主页- PyCaret

无论是输入缺失值、转换分类数据、特征工程还是超参数调整…

pycaret.org](https://pycaret.org/)

Pycaret 被设计成一个极低代码的 Python 机器学习库。它既面向希望更快地构建模型的数据科学家，也面向对构建简单模型感兴趣的非数据科学家。

该库包含整个机器学习过程的低代码示例，包括预处理、模型训练、评估和调整。包括所有常见的估计器类型，如逻辑回归、决策树、梯度推进分类器和 cat boost。这个库还包含一个非常简单的部署解决方案，它将在 AWS S3 桶上部署最终模型。模型总是可以保存为 pickle 文件，用于替代部署解决方案。

10.先知

[## 快速启动

Prophet 遵循 sklearn 模型 API。我们创建一个 Prophet 类的实例，然后调用它的 fit 和 predict…

facebook.github.io](https://facebook.github.io/prophet/docs/quick_start.html)

Prophet 是一个 python 库，旨在大大简化时间序列预测，由脸书开源。该库使用与 Scikit-learn 类似的界面，极大地简化了时间序列预测的过程。有一些有用的绘图功能，包括可视化和评估模型。它也很容易模拟季节性和假日效应，包括你自己定制的日期周期。

Python 生态系统有一个非常活跃的社区，人们开发库来使机器学习更简单和更容易。这篇文章是我经常使用的十个不太知名的库的选集，但是对于一个更全面的列表，这是一个非常棒的资源。

感谢阅读！

我每月发一份简讯，如果你想加入请通过这个链接注册。期待成为您学习旅程的一部分！

我作为初学者开始编程时学到的 10 个教训

原文：https://towardsdatascience.com/10-lessons-i-have-learnt-while-starting-programming-as-a-beginner-6eea32be00e3?source=collection_archive---------7-----------------------

当我第一次开始学习如何编程时，对我面临的最大挑战和我想知道的事情的反思。

蒂姆·高在 Unsplash 上拍摄的照片

"你能学到的最糟糕的东西是你的第一门编程语言."
― 艾伦·凯

如果 5 年前有人告诉我，今天我将成为一名程序员，我不会相信。我开始在某种快车道上编程。我是一名数据科学硕士，我们有几个月的时间来学习足够的 Python，以便在通过必修的 Python 课程之后，为我们的毕业设计制作一些像样的机器学习系统。正如我在一篇关于我的商业背景的文章中提到的，当你没有计算机科学背景时，学习编程不是不可能的，但也不容易。

[## 从销售代表到数据科学家

我从销售专员到数据科学家的转变&最大的挑战是什么。

towardsdatascience.com](/from-being-a-sales-rep-to-being-a-data-scientist-4bb1da79ba3f)

1.当别人的观点不能反映你的现实时，你需要对自己充满信心。

当我考虑从事数据科学方面的职业时，我和三个不同的人交谈过，他们都有相当丰富的编程经验。这三个人都建议我不要尝试读数据科学硕士，因为我缺乏编程技能。他们并没有完全错。学习如何编码需要纪律、动力、韧性和努力。

然而，一些程序员非常擅长他们的工作，并且经历了编码和返回的地狱。他们对这门学科了如指掌，这让他们有时会有点自大，尤其是对完全的初学者。他们也可能有点居高临下，有意或无意，他们可能会怀疑你的能力。不要在每次他们提到某件事时感到沮丧或不安，好像你应该知道，而你显然不知道。别往心里去。这与你无关(就像我上面提到的三个程序员与我无关一样)，这与代码有关。承认你的弱点，友好而自豪地寻求帮助，每次他们回答你的问题时，真诚地感谢他们。

你不能改变人们，但是你可以通过你的行为来改变他们。

卫戍永利

2.像程序员一样思考是你应该努力的技能。

一切都需要分配，一切都需要告诉计算机，没有什么可以假设。这就像学习一门新的语言，缩进、逗号、冒号和点可以决定你一天的成败。

然而，我意识到尝试像程序员一样思考的最重要的方面是学习如何使用编程解决问题。这是一项你需要不断发展的技能，不是在你编程的时候，而是在你用编程解决问题的时候。我坚信解决问题也是程序员发挥创造力的地方。

“我看到新程序员犯的最大错误是专注于学习语法，而不是学习如何解决问题。”——v·安东·斯普尔

3.经验和实践是最重要的。

知道规则和应用规则是根本不同的。当我开始编程的时候，基本的练习看起来很愚蠢，有时候我觉得如果我理解了概念，我并不真的需要像老师要求的那样多练习。我完全错了。我们班 70%的人没能通过第一次 Python 考试，因为他们没有把时间花在练习上。我通过了考试，不是因为天赋，而是因为我花了很多时间做推荐的练习，尽管我有自己的假设。

最好的程序员不是那些最有“天赋”的人，而是那些解决了最多编程问题的人。我个人认为天赋被高估了一点，自从我读了马尔科姆·格拉德威尔的《T4:离群者》这本书后，这一点更被高估了。

“练习不是你擅长的事情。是你做的事情让你变得优秀。”
― 马尔科姆·格拉德威尔， 异类:成功的故事

[## 韧性作为座右铭:如何获得成功所需的一项技能

所有的成功故事都有一个共同点。但是这个技能可以教吗？

medium.com](https://medium.com/swlh/resilience-as-a-motto-how-to-get-the-one-skill-required-to-succeed-9c1af901082d)

4.挫折是经历的一个重要部分。

我有时讨厌编程，非常沮丧，以至于我开始怀疑这一切的目的，质疑我自己的目标，甚至我自己的存在。编程的特性是非常符合逻辑，但有时看起来完全不符合逻辑，因为我们看不到我们错过了什么。

有时候讨厌它没关系，寻求帮助，在堆栈溢出时乞讨，或者去冰箱里拿杯冰啤酒，看一部愚蠢的情景喜剧，冷静 20 分钟也没关系。但是，如果你每次编程都不得不鞭策自己，而每次你设法产生你想要的结果时都没有感到任何兴奋，也许你应该重新考虑编程是否真的是你需要并且想要学习的技能。

5.从符合你要求的语言开始。

克里斯里德在 Unsplash 上的照片

我知道很多人都是用 R 或者 Python 开始学习编程的。如果您需要用几行代码创建统计数据和漂亮的图表，r 是一个合乎逻辑的选择。启动成本更低，短期内就能看到成效。

我从 Python 和 R 开始，因为它们都是数据科学世界中重要的主要语言(也是我的老师友好地选择的)。

6.牢记你的目标，让你的任务接近你的目标。

我发现，当我能把一门语言和我想用它做的事情直接联系起来时，学习这门语言就容易多了。在我的第一门 Python 课程中，尽管涵盖了关于语法、函数、变量和常见概念的所有基础知识，但没有任何东西与数据科学直接相关。我们甚至没有看到如何在 pandas 中加载 CSV 文件。尽管我会向任何人推荐这门课程，但这种教学可能会变得非常多余，当所有课程都与你的目标脱节时，你可能会失去耐心或动力。

虽然学习基础知识仍然至关重要，但我会尝试在过程的早期学习与目标相关的任务。例如，数据科学中的数据清理和数据探索是可以在 R 和 Python 中很早就开始的任务，只需借助文档和堆栈溢出。看到以后可以使用的输出有助于你保持动力，并给你一个切实的进步证明。

7.在笔记本或文件中组织你的课程和练习

老实说，我在组织方面很糟糕，但我非常幸运地在一个提供结构化笔记本的学位中开始编程。我发现，当我忘记如何修理一周前修好的东西时，有地方可去是一件非常令人欣慰的事。许多程序员的目标是保存代码和不同问题的解决方案，以节省时间，同时也能够回顾他们过去构建或使用的问题解决方案的类型。

"花在组织上的每一分钟，都是一小时的收获."—本杰明·富兰克林

8.忘记语法没什么大不了的。

我曾经非常担心我总是忘记语法，并且我只记得我几乎每天使用的函数和方法的语法。然而，语法到处都有记载，即使是经验丰富的程序员也会忘记语法。还是那句话，只要你理解了语法，就没有必要记住所有的内容。显然你会成为一个更快的程序员。但是，一个知道所有语法但几乎没有解决问题技能的程序员，与一个有很强的解决问题技能但不断查看熊猫页面以记住如何阅读 CSV 文件的程序员相比，是垃圾。

9.冒险值得回报。

杰瑞米·多洛在 Unsplash 上的照片

作为一名“初级”程序员，我倾向于通过故意选择看起来不太复杂的任务和用户故事来避免承担风险，并保持“在我的水平上”，不管这意味着什么。当我在自己舒适的环境中享受了一段时间后，我并没有像一个开发人员那样尽可能地提高和学习。现在，如果我不注意，我会开始做同样的事情，当我甚至在开始之前没有清楚地看到答案时，我会试图避免工作。然而，看起来有点遥不可及的复杂任务比舒适的任务更能让你学习和成长。

10.少看，多做。

有一个时刻应该停止看视频，停止被动地阅读编程书籍，这个时刻宜早不宜迟。像观看或阅读这样的被动任务可能会有点上瘾，因为它们只需要最少的努力。然而，我知道在看了几个小时的视频后，我的大脑会断开连接，并开始思考我前一天看的网飞系列，以及在那一刻我有多想吃 4 块奶酪披萨。

我在重复我自己，但这是我能给出的最大的建议。边做边学比被动学习带来更多的成果，尤其是在编程方面。

程序员通过编程学习编程，然后再编程一些。

要获得更多关于编程、数据科学和领导力的文章，请关注我的Medium和Twitter，以便在新文章发布时获得通知。

[## 如何让数据科学家开心

为了与您的数据科学家建立牢固的长期关系并让他们满意，需要关注 5 个方面…

towardsdatascience.com](/how-to-make-and-keep-a-data-scientist-happy-4f4253581966) [## 可穿戴设备和生物传感器如何利用机器学习帮助研究人员抗击克罗恩病

男朋友 20 岁的时候发现自己得了克罗恩病。就像我们中的许多人一样，他控制住了疼痛，直到…

towardsdatascience.com](/how-wearables-biosensors-can-help-researchers-fight-crohns-disease-using-machine-learning-1517090f0a35)

通过在 TensorFlow 中将迁移学习应用到 MobileNet，用 10 分钟时间构建一个二值图像分类器

原文：https://towardsdatascience.com/10-minutes-to-building-a-binary-image-classifier-by-applying-transfer-learning-to-mobilenet-eab5a8719525?source=collection_archive---------30-----------------------

莎拉·多维勒在 Unsplash 上的照片

如何通过在 MobileNet 模型上训练来构建二值图像分类器

这是对计算机视觉的简短介绍，即如何在 MobileNet 模型上使用转移学习来构建二值图像分类器，主要面向新用户。这份简单易懂的教程分为 3 个部分:

1. 数据
2. 模型架构
3. 准确性、ROC 曲线和 AUC

要求:没事！按照本教程，你所需要的就是这个包含数据和代码的 Google Colab 笔记本。Google Colab 允许您在浏览器中编写和运行 Python 代码，无需任何设置，并且包括免费的 GPU 访问！要运行此代码，只需转到File -> Make a copy创建一个您可以运行和编辑的笔记本副本。

1.数据

我们将建立一个蒲公英和草的图像分类器。我已经使用 Google Images 中的图片创建了一个小的图片数据集，您可以在本教程的前 8 个单元格中下载并解析它。

在这 8 行结束时，可视化图像数据集的样本将如下所示:

请注意，数据集中的一些图像并不是草地或蒲公英的完美代表。为了简单起见，让我们把它做好，然后继续讨论如何轻松地创建我们的训练和验证数据集。

我们之前获取的数据被分成两个文件夹，train和valid。在这些文件夹中，文件夹dandelion和grass包含每个班级的图像。为了创建数据集，让我们使用keras.preprocessing.image.ImageDataGenerator类来创建我们的训练和验证数据集，并规范化我们的数据。这个类所做的是创建一个数据集，并自动为我们做标记，允许我们只用一行就创建一个数据集！

2.模型架构

在本节的开始，我们首先导入 TensorFlow。

现在，让我们添加 MobileNet 模型。请确保包含 include_top 参数，并将设置为 False。这将减去模型的最后一层，以便我们可以添加我们自己的层，我们将在其上训练。这叫迁移学习！然后，我们将添加一个 GlobalAveragePooling2D 层，以减少我们将输入到最后一层的输出的大小。对于最后一层，我们将添加一个 Sigmoid 层用于二进制分类。这一点很重要:我们必须将 MobileNet 层的可训练参数设置为 False，这样我们就不会训练整个模型——我们只需要训练最后一层！

这是我们建立的模型:

model = Sequential()model.add(MobileNetV2(include_top = False, weights="imagenet", input_shape=(200, 200, 3)))model.add(tf.keras.layers.GlobalAveragePooling2D())model.add(Dense(1, activation = 'sigmoid'))model.layers[0].trainable = False

让我们来看看我们构建的模型的摘要:

Model: "sequential" _________________________________________________________________ Layer (type)                 Output Shape              Param #    ================================================================= mobilenetv2_1.00_224 (Model) (None, 7, 7, 1280)        2257984    _________________________________________________________________ global_average_pooling2d (Gl (None, 1280)              0          _________________________________________________________________ dense (Dense)                (None, 1)                 1281       ================================================================= Total params: 2,259,265 Trainable params: 1,281 Non-trainable params: 2,257,984

接下来，我们将配置模型训练的规范。我们将用binary_crossentropy损失来训练我们的模型。我们将使用RMSProp优化器。 RMSProp 是一个明智的优化算法，因为它为我们自动化了学习率调整(或者，我们也可以使用 Adam 或 Adagrad 获得类似的结果)。我们将增加metrics的准确性，这样模型将在训练过程中监控准确性。

model.compile(optimizer=RMSprop(lr=0.01), loss = 'binary_crossentropy', metrics = 'accuracy')

让我们训练 15 个纪元:

history = model.fit(train_generator,steps_per_epoch=8,epochs=15,verbose=1,validation_data = validation_generator,validation_steps=8)

3.准确性、ROC 曲线和 AUC

让我们评估一下我们模型的准确性:

model.evaluate(validation_generator)

现在，让我们计算我们的 ROC 曲线并绘制它。

首先，让我们对我们的验证集进行预测。当使用生成器进行预测时，我们必须首先关闭 shuffle(正如我们在创建 validation_generator 时所做的那样)并重置生成器:

STEP_SIZE_TEST=validation_generator.n//validation_generator.batch_sizevalidation_generator.reset()preds = model.predict(validation_generator,verbose=1)

为了创建 ROC 曲线和 AUC，我们需要计算假阳性率和真阳性率:

fpr, tpr, _ = roc_curve(validation_generator.classes, preds)roc_auc = auc(fpr, tpr)plt.figure()lw = 2plt.plot(fpr, tpr, color='darkorange',lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')plt.xlim([0.0, 1.0])plt.ylim([0.0, 1.05])plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.title('Receiver operating characteristic example')plt.legend(loc="lower right")plt.show()

我们模型的 ROC 曲线

ROC 曲线是绘制真阳性率(TPR)对假阳性率(FPR)的概率曲线。在这条曲线中，对角线是随机猜测的曲线，例如抛硬币，所以上面的 ROC 曲线表明我们的模型在分类上做得很好！

类似地，AUC(曲线下面积)如上面的图例所示，测量我们的模型在多大程度上能够区分我们的两个类别，蒲公英和草。AUC 越高，我们的模型在分类上就越好。AUC 为 0.96 被认为相当不错！

最后，在笔记本的最后，你将有机会对你自己的图像进行预测！

你现在可以在你自己的图像上做预测了！

我希望这能让您对在 MobileNet 模型上使用迁移学习构建一个简单的二值图像分类器有一个温和的了解！如果你对类似的教程感兴趣，请看看我的其他故事。

用 10 分钟在 TensorFlow 中构建 CNN 二值图像分类器

原文：https://towardsdatascience.com/10-minutes-to-building-a-cnn-binary-image-classifier-in-tensorflow-4e216b2034aa?source=collection_archive---------3-----------------------

照片由 Kara Eads 在 Unsplash 上拍摄

如何在 TensorFlow/Keras 中使用卷积神经网络层构建二值图像分类器

这是对计算机视觉的简短介绍，即如何在 TensorFlow/Keras 中使用卷积神经网络层构建二值图像分类器，主要面向新用户。这份简单易懂的教程分为 3 个部分:

1. 数据
2. 模型架构
3. 准确性、ROC 曲线和 AUC

要求:没事！按照本教程，你所需要的就是这个包含数据和代码的 Google Colab 笔记本。Google Colab 允许您在浏览器中编写和运行 Python 代码，无需任何设置，并且包括免费的 GPU 访问！

1.数据

我们将建立一个蒲公英和草的图像分类器。我已经使用 Google Images 中的图片创建了一个小的图片数据集，您可以在本教程的前 8 个单元格中下载并解析它。

在这 8 行结束时，可视化图像数据集的样本将如下所示:

请注意，数据集中的一些图像并不是草地或蒲公英的完美代表。为了简单起见，让我们把它做好，然后继续讨论如何轻松地创建我们的训练和验证数据集。

我们之前获取的数据被分成两个文件夹，train和valid。在这些文件夹中，dandelion和grass文件夹包含每个班级的图像。为了创建数据集，让我们使用keras.preprocessing.image.ImageDataGenerator类来创建我们的训练和验证数据集，并规范化我们的数据。这个类所做的是创建一个数据集，并自动为我们做标记，允许我们只用一行就创建一个数据集！

2.模型架构

在本节开始，我们首先导入 TensorFlow。

让我们然后添加我们的 CNN 层。我们将首先添加一个卷积 2D 层，有 16 个过滤器，一个 3x3 的内核，输入尺寸为我们的图像尺寸，200x200x3，激活为 ReLU。

tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(200, 200, 3))

之后，我们将添加一个最大池层，将图像尺寸减半，因此在这一层之后，输出将是 100x100x3。

tf.keras.layers.MaxPooling2D(2, 2)

我们将这些层中的 5 层堆叠在一起，随后 CNN 会添加更多的过滤器。

最后，我们将使 CNN 层的输出变平，将其输入到一个全连接层，然后输入到一个 sigmoid 层进行二进制分类。

这是我们建立的模型:

model = tf.keras.models.Sequential([# Note the input shape is the desired size of the image 200x200 with 3 bytes color# This is the first convolutiontf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(200, 200, 3)),tf.keras.layers.MaxPooling2D(2, 2),# The second convolutiontf.keras.layers.Conv2D(32, (3,3), activation='relu'),tf.keras.layers.MaxPooling2D(2,2),# The third convolutiontf.keras.layers.Conv2D(64, (3,3), activation='relu'),tf.keras.layers.MaxPooling2D(2,2),# The fourth convolutiontf.keras.layers.Conv2D(64, (3,3), activation='relu'),tf.keras.layers.MaxPooling2D(2,2),# # The fifth convolutiontf.keras.layers.Conv2D(64, (3,3), activation='relu'),tf.keras.layers.MaxPooling2D(2,2),# Flatten the results to feed into a DNNtf.keras.layers.Flatten(),# 512 neuron hidden layertf.keras.layers.Dense(512, activation='relu'),# Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('dandelions') and 1 for the other ('grass')tf.keras.layers.Dense(1, activation='sigmoid')

让我们来看看我们构建的模型的摘要:

Model: "sequential" _________________________________________________________________ Layer (type)                 Output Shape              Param #    ================================================================= conv2d (Conv2D)              (None, 198, 198, 16)      448        _________________________________________________________________ max_pooling2d (MaxPooling2D) (None, 99, 99, 16)        0          _________________________________________________________________ conv2d_1 (Conv2D)            (None, 97, 97, 32)        4640       _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 48, 48, 32)        0          _________________________________________________________________ conv2d_2 (Conv2D)            (None, 46, 46, 64)        18496      _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 23, 23, 64)        0          _________________________________________________________________ conv2d_3 (Conv2D)            (None, 21, 21, 64)        36928      _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 10, 10, 64)        0          _________________________________________________________________ conv2d_4 (Conv2D)            (None, 8, 8, 64)          36928      _________________________________________________________________ max_pooling2d_4 (MaxPooling2 (None, 4, 4, 64)          0          _________________________________________________________________ flatten (Flatten)            (None, 1024)              0          _________________________________________________________________ dense (Dense)                (None, 512)               524800     _________________________________________________________________ dense_1 (Dense)              (None, 1)                 513        ================================================================= Total params: 622,753 Trainable params: 622,753 Non-trainable params: 0

接下来，我们将配置模型训练的规范。我们将用binary_crossentropy损失来训练我们的模型。我们将使用RMSProp优化器。 RMSProp 是一个明智的优化算法，因为它为我们自动化了学习率调整(或者，我们也可以使用 Adam 或 Adagrad 获得类似的结果)。我们将增加metrics的准确性，这样模型将在训练过程中监控准确性。

model.compile(loss='binary_crossentropy',optimizer=RMSprop(lr=0.001),metrics='accuracy')

让我们训练 15 个纪元:

history = model.fit(train_generator,steps_per_epoch=8,epochs=15,verbose=1,validation_data = validation_generator,validation_steps=8)

3.准确性、ROC 曲线和 AUC

让我们评估一下我们模型的准确性:

model.evaluate(validation_generator)

现在，让我们计算我们的 ROC 曲线并绘制它。

首先，让我们对我们的验证集进行预测。当使用生成器进行预测时，我们必须首先关闭 shuffle(正如我们在创建 validation_generator 时所做的那样)并重置生成器:

STEP_SIZE_TEST=validation_generator.n//validation_generator.batch_sizevalidation_generator.reset()preds = model.predict(validation_generator,verbose=1)

为了创建 ROC 曲线和 AUC，我们需要计算假阳性率和真阳性率:

fpr, tpr, _ = roc_curve(validation_generator.classes, preds)roc_auc = auc(fpr, tpr)plt.figure()lw = 2plt.plot(fpr, tpr, color='darkorange',lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')plt.xlim([0.0, 1.0])plt.ylim([0.0, 1.05])plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.title('Receiver operating characteristic example')plt.legend(loc="lower right")plt.show()

我们模型的 ROC 曲线

ROC 曲线是绘制真阳性率(TPR)对假阳性率(FPR)的概率曲线。

类似地，AUC(曲线下面积)如上面的图例所示，测量我们的模型在多大程度上能够区分我们的两个类别，蒲公英和草。它还用于比较不同的模型，我将在未来的教程中介绍如何使用全连接层构建图像分类器，以及如何使用 ResNet 进行迁移学习。

最后，在笔记本的最后，你将有机会对你自己的图像进行预测！

你现在可以在你自己的图像上做预测

我希望这给你一个温和的介绍，建立一个简单的使用 CNN 层的二值图像分类器。如果你对类似的简单易懂的教程感兴趣，请看看我的其他故事！

在 TensorFlow 中用 10 分钟构建一个全连接的二值图像分类器

原文：https://towardsdatascience.com/10-minutes-to-building-a-fully-connected-binary-image-classifier-in-tensorflow-d88062e1247f?source=collection_archive---------29-----------------------

照片由 Waranont (Joe) 在 Unsplash 上拍摄

如何在 TensorFlow/Keras 中使用全连通层构建二值图像分类器

这是对计算机视觉的简短介绍，即如何在 TensorFlow/Keras 中仅使用全连接层来构建二值图像分类器，主要面向新用户。这份简单易懂的教程分为 3 个部分:

1. 数据
2. 模型架构
3. 准确性、ROC 曲线和 AUC

要求:没事！按照本教程，你所需要的就是这个包含数据和代码的 Google Colab 笔记本。Google Colab 允许您在浏览器中编写和运行 Python 代码，无需任何设置，并且包括免费的 GPU 访问！只需点击文件- >在驱动器中保存一份副本即可。

1.数据

我们将建立一个蒲公英和草的图像分类器。我已经使用 Google Images 中的图片创建了一个小的图片数据集，您可以在本教程的前 8 个单元格中下载并解析它。

在这 8 行结束时，可视化图像数据集的样本将如下所示:

请注意，数据集中的一些图像并不是草地或蒲公英的完美代表。为了简单起见，让我们把它做好，然后继续讨论如何轻松地创建我们的训练和验证数据集。

我们之前获取的数据被分成两个文件夹，train和valid。在这些文件夹中，dandelion和grass文件夹包含每个班级的图像。为了创建数据集，让我们使用keras.preprocessing.image.ImageDataGenerator类来创建我们的训练和验证数据集，并规范化我们的数据。这个类所做的是创建一个数据集，并自动为我们做标记，允许我们只用一行就创建一个数据集！

2.模型架构

在本节的开始，我们首先导入 TensorFlow。

然后，让我们添加一个展平层来展平输入图像，然后输入到下一层，一个密集层，或完全连接层，有 128 个隐藏单元。最后，因为我们的目标是执行二进制分类，所以我们的最终层将是一个 sigmoid，因此我们网络的输出将是 0 和 1 之间的单个标量，编码当前图像属于 1 类(1 类是草，0 类是蒲公英)的概率。

model =
tf.keras.models.Sequential([tf.keras.layers.Flatten(input_shape = (200,200,3)),
tf.keras.layers.Dense(128, activation=tf.nn.relu),
tf.keras.layers.Dense(1, activation=tf.nn.sigmoid)])

让我们来看看我们构建的模型的摘要:

Model: "sequential" _________________________________________________________________ Layer (type)                 Output Shape              Param #    ================================================================= flatten (Flatten)            (None, 120000)            0          _________________________________________________________________ dense (Dense)                (None, 128)               15360128   _________________________________________________________________ dense_1 (Dense)              (None, 1)                 129        ================================================================= Total params: 15,360,257 Trainable params: 15,360,257 Non-trainable params: 0

注意，因为我们使用的是全连接层，一层中的每个单元都连接到它旁边的层中的每个单元。参数真多啊！

接下来，我们将配置模型训练的规范。我们将用binary_crossentropy损失来训练我们的模型。我们将使用Adam优化器。 Adam 是一个明智的优化算法，因为它为我们自动化了学习率调整(或者，我们也可以使用 RMSProp 或 Adagrad 获得类似的结果)。我们将增加metrics的准确性，这样模型将在训练过程中监控准确性。

model.compile(optimizer = tf.optimizers.Adam(),loss = 'binary_crossentropy',metrics=['accuracy'])

让我们训练 15 个纪元:

history = model.fit(train_generator,steps_per_epoch=8,epochs=15,verbose=1,validation_data = validation_generator,validation_steps=8)

3.准确性、ROC 曲线和 AUC

让我们评估一下我们模型的准确性:

model.evaluate(validation_generator)

现在，让我们计算我们的 ROC 曲线并绘制它。

首先，让我们对我们的验证集进行预测。当使用生成器进行预测时，我们必须首先关闭 shuffle(正如我们在创建 validation_generator 时所做的那样)并重置生成器:

STEP_SIZE_TEST=validation_generator.n//validation_generator.batch_sizevalidation_generator.reset()preds = model.predict(validation_generator,verbose=1)

为了创建 ROC 曲线和 AUC，我们需要计算假阳性率和真阳性率:

fpr, tpr, _ = roc_curve(validation_generator.classes, preds)roc_auc = auc(fpr, tpr)plt.figure()lw = 2plt.plot(fpr, tpr, color='darkorange',lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')plt.xlim([0.0, 1.0])plt.ylim([0.0, 1.05])plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.title('Receiver operating characteristic example')plt.legend(loc="lower right")plt.show()

我们模型的 ROC 曲线

ROC 曲线是绘制真阳性率(TPR)对假阳性率(FPR)的概率曲线。

类似地，AUC(曲线下面积)如上面的图例所示，测量我们的模型在多大程度上能够区分我们的两个类别，蒲公英和草。它还用于比较不同的模型，在未来的教程中，当我介绍如何使用卷积神经网络构建图像分类器和使用 ResNet 进行迁移学习时，我会这样做！

最后，在笔记本的最后，你将有机会对你自己的图像进行预测！

你现在可以在你自己的图像上做预测

我希望这给你一个温和的介绍，建立一个简单的二值图像分类器只使用全连接层。如果你对类似的简单易懂的教程感兴趣，请看看我的其他故事！

10 分钟用 Apache Airflow 建立机器学习管道

原文：https://towardsdatascience.com/10-minutes-to-building-a-machine-learning-pipeline-with-apache-airflow-53cd09268977?source=collection_archive---------3-----------------------

为什么 ML 管道很重要，以及如何使用 Apache AirFlow 构建一个简单的 ML 管道

杰米·菲利普斯在 Unsplash 上拍摄的照片

通常，当你想到机器学习时，你往往会想到你现在可以创建的伟大模型。如果你想把这些令人惊奇的模型公之于众，你就必须超越仅仅训练模型，并融入数据收集、特征工程、训练、评估和服务。

最重要的是，你还必须记住，你是在将一个软件应用程序投入生产。这意味着您将拥有任何生产软件所拥有的所有需求，包括可伸缩性、一致性、模块化、可测试性和安全性。

ML 代码只是 ML 系统的一部分

ML 管道允许你自动运行机器学习系统的步骤，从数据收集到模型服务(如上图所示)。它还将 减少机器学习系统 的技术债务，正如这篇链接论文所描述的。这就进入了 MLOps 的领域，这是一个快速发展的领域，与 DevOps 类似，(旨在自动化和监控 ML 系统的所有步骤。

本教程将向您展示如何构建一个简单的 ML 管道，该管道可以自动化使用 FastAI 构建的蒲公英和草的深度学习图像分类器的工作流程，然后使用 Starlette 作为 web 应用。我们将使用众多工作流工具中的 Apache AirFlow ，如 Luigi 、 MLFlow 和 KubeFlow ，因为它提供了广泛的特性和漂亮的 UI。 AirFlow 是一款开源软件，允许您使用有向无环图(DAG)以编程方式创作和调度工作流，并通过内置的 AirFlow 用户界面对其进行监控。在本教程的最后，我将向您展示使您的管道生产就绪的进一步步骤。

需求:由于您将在一个虚拟机实例上运行本教程，您需要的只是一台运行任何操作系统的计算机和一个 Google 帐户。

本教程将分为以下步骤:

1. 注册谷歌云平台并创建一个计算实例
2. 从 Github 获取教程内容
3. 气流中的 ML 管道概述
4. 使用 nginx 安装 Docker 并设置虚拟主机
5. 构建并运行 Docker 容器
6. 打开气流 UI 并运行 ML 管道
7. 运行部署的 web 应用程序

1.登录 Google 云平台并创建一个计算实例

注册 GCP 是免费的！

如果你还没有，通过你的谷歌账户注册谷歌云平台。你必须输入你的信用卡，但注册时不会收取任何费用。您还将获得价值 300 美元的免费积分，有效期为 12 个月！如果你用完了积分，不要担心——运行本教程将花费几分钱，只要你之后停止你的虚拟机实例！

进入控制台后，转到计算引擎并创建一个实例。然后:

1. 将实例命名为greenr-airflow
2. 将计算实例设置为n1-standard-8
3. 将操作系统设置为 Ubuntu 18.04
4. 将硬盘内存提升至 30GB
5. 允许云访问 API 和 HTTP/HTTPS 流量

如何创建虚拟机实例

当您的实例已经创建并正在运行时，通过单击屏幕右侧的 SSH 按钮进入您的实例。

2.从 Github 中提取训练好的模型

我们从 Github 上拉一下教程内容。通过在 VM 实例中键入以下命令，从 Github 克隆 repo:

git clone [https://github.com/btphan95/greenr-](https://github.com/btphan95/greenr-tutorial)airflow
cd [greenr-](https://github.com/btphan95/greenr-tutorial)airflow

3.ML 管道组件概述

让我们探索一下这个 Git 存储库的内容。首先，让我们探索气流配置文件，/config/airflow.cfg。它设置气流管道的所有配置选项，包括气流管道的位置(在本例中，我们将该文件夹设置为/dags/，以及我们连接到元数据数据库sql_alchemy_conn的位置)。Airflow 使用一个数据库来存储关于 Dag、它们的运行以及其他 AirFlow 配置(如用户、角色和连接)的元数据。就像在电子游戏中保存你的进度一样。

接下来，让我们探索 ML 管道，它在/dags/ml_pipeline.py中定义。

ml_pipeline.py

这个 Python 脚本所做的是将我们的有向无环图结构定义为代码，包括我们想要执行的任务及其顺序。

我们来分解一下 ml_pipeline.py 中的代码:

1. default_args = … default_args 定义了将被送入 DAG 函数的参数。这包括所有者名称owner，失败的实例之后 DAG 是否应该再次运行depends_on_past，以及开始日期start_date。注意:AirFlow 将在 DAG 定义下的start_date和schedule_interval的一个实例之后启动 DAG。这意味着在我们的例子中，我们从(31 天前)+ (30 天间隔)=昨天开始。
2. dag = DAG … DAG 与 default_args 和schedule_interval一起实例化有向非循环图。
3. download_images = BashOperator…记住 Apache AirFlow 将我们的有向无环图结构定义为代码，DAGS 由任务组成。任务是使用执行代码的操作符定义的。这里，我们使用 BashOperator 为我们的任务运行 Python 文件，这些文件位于scripts/.中，例如，在我们的 download_images 任务中，我们从 Google Images 下载图像，BashOperator 调用python3 /usr/local/airflow/scripts/download_images.py。
4. 在这里，我们设置 DAG 中任务的顺序。第一个任务完成后，>>命令运行第二个任务。这意味着在管道中，download_images 将在 train 之前运行，train 将在 serve 之前运行。

我鼓励您看一看每个任务的 python 脚本！

4.安装 Docker 并使用 nginx 设置虚拟主机

Docker 允许你在容器中运行软件，容器是运行自己操作系统的虚拟环境，让你轻松可靠地捆绑软件及其所需的软件包。这就是为什么我们要使用 Docker 来运行我们的教程。首先，让我们通过运行 Docker 网站上的 Bash 脚本在我们的虚拟机上安装 Docker(或者您可以在这里手动安装 Docker):

bash <(curl -s [https://get.docker.com/](https://get.docker.com/))

然后，你需要使用一个开源网络服务器软件 nginx 来设置虚拟主机。因为我计划在 Docker 容器中使用两个端口，一个用于 AirFlow UI，一个用于最终的 web 应用程序，并且只有一个公共 IP 地址(我们的计算实例的外部地址)，所以您将使用 nginx 将 HTTP 请求路由到我们的外部 IP 地址。使用以下脚本从端口 8080 上的气流路由到我们的默认端口 80:

bash scripts/nginx-airflow.sh

5.构建并运行 Docker 容器

现在，让我们使用以下命令构建 Docker 容器:

sudo docker build -t greenr-airflow:latest .

这将运行我们目录中的 Dockerfile，并为我们的容器下载和安装必要的库。

请耐心等待——这大约需要 10 分钟。

然后，运行 Docker 容器:

sudo docker run -d -p 8080:8080 -p 8008:8008 greenr-airflow

几秒钟后，访问您机器的外部 IP 地址，您可以在 GCP 控制台的计算引擎中找到该地址。确保在浏览器中输入时，在 IP 地址前加上 http://前缀，如:http://34.68.160.231/

现在，您应该会看到气流用户界面:

您现在应该会看到气流用户界面

现在，单击关闭开关，然后单击最左边的按钮，触发 DAG。管道现在将运行，当您单击 ml_pipeline 并转到树部分时，您将看到有向非循环图以及管道的状态:

几分钟后，最后一个任务 serve 将会运行。您的 ML 管道已成功执行！现在，让 nginx 将我们的应用从端口 8008 路由到我们的外部 IP 地址:

bash scripts/nginx-app.sh

此时，转到你的外部 IP 地址，在后面加上/app，就像这样:http://34.68.160.231/app

您现在将看到最终的 web 应用程序 greenr 正在运行！如果你有兴趣学习如何构建和部署 greenr，可以看看我的教程关于在 Google 云平台上部署深度学习模型！

部署的 web 应用程序！上传一张图片，看看它是蒲公英还是草

最后的结果！

在本教程中，您学习了如何在 Apache AirFlow 中构建一个简单的机器学习管道，该管道由三个任务组成:下载图像、训练和服务。当然，这还可以改进，使其更适合生产和可伸缩。以下是一些关于如何进一步拓展渠道的建议:

1. 考虑使用kubernetoperator来创建在 Kubernetes 中运行的任务，允许更大的可伸缩性
2. 考虑使用另一个执行器，比如 CeleryExecutor ，它支持并行和扩展工作器(我们使用了基本的 SequentialExecutor)
3. 考虑使用 KubeFlow，它允许在 Kubernetes 中编排任务的大规模、生产就绪的 ML 管道，类似于 1。

我希望这给你一个关于在 Apache AirFlow 上构建 ML 管道的温和介绍，并且这可以作为你工作的模板！

不要忘记关闭您的计算实例，以确保您不会因使用 Google Cloud 而被收费！

10 分钟在谷歌云平台上部署深度学习模型

原文：https://towardsdatascience.com/10-minutes-to-deploying-a-deep-learning-model-on-google-cloud-platform-13fa56a266ee?source=collection_archive---------9-----------------------

如何在 GCP 部署深度学习模型，完全免费，永远免费

部署一个蒲公英和草的图像分类器到网络上，通过谷歌云平台！来源: Pixabay

所以你训练了一个令你欣喜若狂的机器学习模型，现在，你想和全世界分享它。所以你建立了一个 web 应用程序来服务这个模型，却发现你不知道如何在互联网上 24/7 托管这个 web 应用程序。毕竟，如果没有人能看到你生产的 ML 模型，它真的存在吗？本教程源于分享一种简单且免费的方法的需求，该方法使用其始终免费的计算服务、f1-micro 在谷歌云平台上将深度学习模型部署到生产中。例如，我们将部署一个使用 FastAI 深度学习库构建的蒲公英和草分类器。我希望你能够在 30 分钟之内，无缝地、毫不费力地将你训练好的模型部署到世界上。

要求:你只需要你现在拥有的电脑和一个谷歌账户！

本教程将分为 4 个步骤:

1. 登录 Google Cloud 并在计算引擎上创建一个 f1-micro 实例
2. 从 Github 中提取训练好的模型
3. 添加交换内存
4. 使用 Starlette 将模型发布到 web 上
5. 在 Docker 容器中构建 web 应用程序
6. 运行 Docker 容器

1.登录 Google Cloud 并创建 f1-micro 实例

注册谷歌云平台是免费的

如果你还没有，通过你的谷歌账户注册谷歌云平台。你必须输入你的信用卡，但注册时不会收取任何费用。您还将获得价值 300 美元的免费积分，有效期为 12 个月！你将利用 GCP 的免费层，所以你不必支付遵循本教程。

进入控制台后，转到计算引擎并创建一个实例。您需要:

1. 将实例命名为greenr
2. 将计算实例设置为f1-micro
3. 将操作系统设置为 Ubuntu 16.04
4. 将硬盘内存提升至 25GB
5. 允许云访问 API 和 HTTP/HTTPS 流量

如何创建虚拟机实例

当您的实例已经创建并正在运行时，通过单击屏幕右侧的 SSH 按钮进入您的实例。

2.从 Github 中提取训练好的模型

首先，让我们从 Github 获取已经训练过的导出模型。如果你有兴趣学习如何使用 FastAI 训练一个蒲公英和草的图像分类器，跟随 Kaggle 上的这个笔记本！如果你对深度学习感兴趣，我建议你使用图书馆并学习 FastAI 课程。

从包含导出模型的 Github 上的 greenr repo 中克隆这个存储库，export.pkl:

git clone [https://github.com/btphan95/greenr-tutorial](https://github.com/btphan95/greenr-tutorial)

3.向我们的计算实例添加交换内存

这是它变得有点 hacky。我们的f1-micro实例只支持高达 0.6GB 的 RAM，这意味着它非常脆弱，无法安装我们所需的所有深度学习库，这些库的大小超过 750MB。我们将为我们的小朋友添加交换内存，以利用其现有的硬盘空间作为 RAM 来实现这一切。幸运的是，我把所有这些都放到了一个脚本中，所以只需从我们的 greenr repo 运行swap.sh,向我们的机器添加 4GB 的交换内存:

cd greenr-tutorial
sudo bash swap.sh

注意，如果您使用的是一个更强的 VM 实例，那么您就不必遵循这个步骤

4.使用 Starlette 将模型发布到 Web 上

现在，我们将使用 Starlette ASGI web 框架构建一个 Python 脚本来为我们的模型提供推理服务。为什么是斯达莱特而不是弗拉斯克？两者都是用 Python 编写的 web 框架，但是 Starlette 和 Uvicorn 比 Flask 快得多，并且在生产中更具可伸缩性。

使用您最喜欢的文本编辑器，将以下代码复制到 greenr-tutorial 目录下名为 app.py 的 python 脚本中。

这将在端口 8008 上创建一个 Starlette 服务器，其中有一个用户可以上传图像并获得结果的网页(是蒲公英还是草？)

在继续之前，我们还将添加一个名为requirements.txt的文件，它将允许 Docker 在构建容器时安装我们需要的所有库。并将以下文本复制到 greenr-tutorial 文件夹中的requirements.txt:

5.使用 Docker 容器化应用程序

使用 Docker 可以让我们构建紧凑的容器化环境，只包含我们需要的库和数据。

首先，我们将使用 Docker 构建一个容器，我们的应用程序将在其中运行。这让我们可以在任何地方，在自己的环境中运行应用程序。

首先，安装 Docker :

卸载旧版本:

sudo apt-get remove docker docker-engine docker.io containerd runc

设置存储库:

sudo apt-get update
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

添加 Docker 官方 GPG 键:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

添加稳定存储库:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

安装 Docker 引擎:

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

通过运行 hello-world 映像来验证安装(它应该打印一条信息性消息，验证安装成功):

sudo docker run hello-world

现在，在 greenr-tutorial 目录中，您将需要创建一个 Docker 文件，为 Docker 提供构建容器的指令。首先，vim 进入Dockerfile并添加以下几行:

这个 Dockerfile 将在 Python3.6 环境中安装所需的库，向容器中添加必要的文件，并在 app.py 中运行 Starlette 服务器。

在 greenr 目录中，使用以下命令构建 Docker 容器:

sudo docker image build -t app:latest .

6.运行 Docker 容器

现在，我们要做的就是运行我们的 Docker 容器！

sudo docker run -d -p 80:8008 app:latest

现在，让我们访问我们机器的外部 IP 地址，您可以在 Compute Engine 上找到它。确保当你在你的浏览器中输入它时，它的格式是这样的(对于我的例子):http://34.68.160.231/

最终部署在网上的模型！

最后的结果！

如果你看到了以上内容，那么你已经坚持到了最后。恭喜你。🎉现在，你可以永远运行你的机器，因为它是谷歌永远免费层的一部分。

我作为数据科学家犯下的 10 个错误

原文：https://towardsdatascience.com/10-mistakes-ive-made-as-a-data-scientist-f6118184e69?source=collection_archive---------18-----------------------

可能出错的地方以及如何解决的例子

与 Raj 在Unsplash【1】上的公路旅行照片。

目录

1. 介绍
2. 错误
3. 摘要
4. 参考

介绍

做了几年数据科学家后，我开始意识到自己适合做什么，哪里需要帮助，以及哪里出了问题。承认错误会令人尴尬和不舒服；然而，我认为这不仅是作为一名数据科学家成长的最佳方式，也是作为一个人成长的最佳方式。如果你敞开心扉接受反馈，你会发现自己学到了更多。数据科学是你需要不断学习的关键领域之一。数据科学家能做的最糟糕的事情就是隐藏他们的错误。尽管老生常谈，我还是会引用曾经非常重要的蜘蛛侠电影——

权力越大，责任越大——本叔叔

因为数据科学对一个企业有如此巨大的影响，所以你会犯的错误也是如此(是的，我们并不完美，最好是预测一个错误及其相应的解决方案，而不是认为你的 100%正确的机器学习模型不是一点点可疑)。

下面，我将包括我过去作为数据科学家所犯的 10 个关键错误，以及我为解决这些错误所做的事情，或者我将来会做的事情。我希望这些突出的错误也能成为有用的指南，供您在作为数据科学家的旅程和努力中使用。

错误

照片由 NeONBRAND 在Unsplash【2】上拍摄。

你可以为任何职业撰写大量关于错误的文章，尤其是在数据科学领域，所以我想强调一下我的个人经历，因为我确信我们过去曾犯过类似的错误，或者将来会犯类似的错误。以下是我作为数据科学家犯下的 10 大错误。

1. 跳过面向对象编程(OOP) — 以为自己不需要了解软件工程或者面向对象编程。当我学习数据科学时，我对编码或不同的通用语言(如 Python 或 r)了解不多。我对 SQL 有一些经验，但 Python(我现在的主要编程语言)是慢慢引入的，只用作基本操作数据科学模型和库的方法。当引入更多 OOP 时，您可以模块化您的代码，这最终将变得更具可伸缩性。一旦你的蟒蛇进去了。OOP 格式的 py 文件，你将能够把它交给机器学习工程师或软件工程师，以便你的模型可以很容易地在生产中执行(如果你是超级数据科学家或没有任何额外数据工程资源的较小公司，你也可以自己完成所有步骤)。

当创建我的数据科学项目时，我通常开始时不太像 OOP，但是一旦我得到了所有的概念和基本代码，我就会专注于模块化。

例如，您不需要定义一个函数和类来读入 CSV 文件以开始您的数据科学过程，但是最终，您可以构建一个模块，该模块通过一个活动连接从 SQL 查询中自动获取新数据。

这里【3】是 Venkatesh Pappakrishnan 博士关于生产级代码的一篇很棒的文章。

2.不使用 GitHub — 我写过两篇关于 GitHub 和 Git 的关于数据科学的文章。也可以随意查看，我会在本文末尾提供这两个链接。

Git 的版本控制和 GitHub 的平台总体上非常有利于与团队中的其他数据科学家共享您的代码库。像 GitHub pull requests 这样的检查和平衡对于确保您的代码不仅在本地更新，而且您推送到主分支的内容也得到您的专业同行的批准非常有用。

人们很容易犯这样的错误:拥有数百本笔记本和。ipynb 文件，代码只有很小的不同。最好的解决方案是使用 GitHub 环境进行简单的协作。

3.写糟糕的 Git 会犯——虽然这个错误在你的整个过程中并不完整，但它会累积起来，你的 GitHub 空间会看起来杂乱无章。当您提交对本地分支的更改以便在 pull 请求后推送到主分支时，您将必须添加一个提交行。以下是一些例子:

**Bad practice:** Adding the next iteration for bugs**Good practice:**Add error handling 

4.不写单元测试——这仍然是我需要集中精力的事情。很多时候，数据科学家会把时间花在模型构建、参数调整和进一步迭代上。然而，当您开始将您的模型部署到产品中时，单元测试将会提供极大的价值。它们可以用来说明未来的错误，这样您的整个管道就不会受到过程中一个简单变化的负面影响。这里 [4]是一篇来自 Ori Cohen 的关于单元测试和数据科学的优秀文章。

5.忘记记录代码——也许最容易犯的错误之一就是忘记对代码进行注释。你可能经常很匆忙或者认为你现在知道了，所以你以后也会知道。然而，你很可能不仅会与自己分享代码，还会与他人分享——数据科学家、数据工程师、机器学习工程师和软件工程师。除了其他人稍后查看您的代码之外，您将回头参考您的代码，并且很可能您会忘记您在代码中的意思，因此，最终，最好注释掉您的代码，以及列出您正在编写的代码的关键功能和含义。

• 写 Python 代码有一种官方的方式，叫 PEP 8，在这里【5】。

6.依靠 Jupyter 笔记本 —当然，Jupyter 笔记本对于开始您的数据科学探索性数据分析和模型构建非常有用，但是在某个点上，您、您自己或另一位工程师将不得不将您的代码投入生产，并使用 Visual Studio 或 Sublime Text 等工具将您的代码组织成。py 模块。下面列出了一些有益的工具:

• 可视化工作室
• 崇高的文本
• 原子

7.不考虑模型训练时间 —当在你的大学课堂上为你的 100 行数据集创建复杂的 XGBoost 模型时，或者可能是一个教程，一旦你进入了“大数据”，你将不再能够轻松地将这么多数据消化到你的模型中，训练将需要几天时间。了解您正在使用的模型的容量非常重要。您还可以求助于其他算法，这些算法实际上可能会导致更高的准确性，比如说您使用随机森林来代替并限制树的最大深度，您可能会提高您的准确性，降低过度拟合的可能性，并大大减少模型训练时间。

另一个小技巧是，不要每天训练你的模型，或者每天你得到新的数据，但是如果你得到一定量的数据。一个例子是:

*train this model if we get 1000 new rows:else:use the previously stored model that was already trained*

8.不练软技能 —刚学数据科学的时候，重点是建模和编码。不一定需要教授或需要实际生活经验的，是在你的角色中取得成功所需的软技能。作为一名数据科学家，您可能会在整个项目中遇到多个非技术用户。你将不得不与软件工程师或数据工程师会面，以了解数据及其来源，然后你将与产品经理和主题专家会面，讨论业务问题和预期的解决方案，最后 UX/UI 设计师有时会将你的模型结果实现到一个制作精美的交互式界面中。总的来说，软技能在通过面对面(或视频)会议和解释项目的过程和结果来实现数据科学模型的成功方面非常出色。

9.忘记实现维护计划——类似于单元测试，过程的这一部分经常被忽略。有像 CircleCI 和 Airflow 这样的工具，以及通常从仪表板创建描述模型行为的可视化。对我来说，为了找到与模型错误相关的紧急问题的解决方案，知道某个模型何时没有被训练是很重要的。下面列出了这些工具:

• 切尔莱西
• 气流
• （舞台上由人扮的）静态画面
• 谷歌数据工作室

10.忘记学习新的数据科学 —一旦你发现自己在职业生涯中安全稳定，你就可以忘记学习新的东西，尤其是新的和即将到来的数据科学方法。为你的机器学习模型保持更有效的工具是很重要的，同时通过学习或写文章来学习，就像我在 Medium 上看到的那样。

摘要

照片由 Eunice De Guzman 在Unsplash【6】上拍摄。

成为一名数据科学家可能充满挑战、乐趣和权力；然而，向利益相关者和最终用户提供快速、准确和可信的结果会带来巨大的压力。关键是你要让自己熟悉你过去犯过的常见错误，以及其他人犯过的错误，这样你才能预见未来可能犯的错误。

一旦你对自己和他人开诚布公，错误就不那么容易被评判，而更容易被视为成为最好的数据科学家的机会。

为了便于查看，这里列出了所有的错误:

• 跳过面向对象编程
• 不使用 GitHub
• 写烂 Git 提交
• 不编写单元测试
• 忘记记录代码
• 依靠 Jupyter 笔记本
• 不计入模型训练时间
• 没有练软技能
• 忘记实施维护计划
• 忘记学习新的数据科学

我希望你觉得我的文章有趣且有用。感谢您的阅读！

链接到我前面提到的 GitHub 文章[7]和[8]。

* [## 一个成功的数据科学模型需要 GitHub。原因如下。

GitHub 给你的数据科学项目带来的好处。

towardsdatascience.com](/a-succesful-data-science-model-needs-github-heres-why-da1ad019f4e0) [## 每个数据科学家都需要知道的通用 GitHub 命令

通过使用 GitHub 成为更好的数据科学家指南

towardsdatascience.com](/common-github-commands-every-data-scientist-needs-to-know-e7d5d9c4f080)

参考文章，[3]和[4]:

[## 数据科学如何写一个生产级代码？

编写生产级代码的能力是数据科学家角色的抢手技能之一——无论是发布…

towardsdatascience.com](/how-to-write-a-production-level-code-in-data-science-5d87bd75ced) [## 数据科学的单元测试和日志记录

在本教程中，我将创建输入输出单元测试，一个日志类和一个 API 合适的部署。

towardsdatascience.com](/unit-testing-and-logging-for-data-science-d7fb8fd5d217)

参考

[1]2018 年与 Raj 在 Unsplash 上的公路旅行照片

[2]照片由 NeONBRAND 在 Unsplash 上拍摄，(2017)

[3] V.Pappakrishnan 博士。、数据科学如何写一个生产级代码？ (2018)

[4] O.Cohen，数据科学的单元测试与记录，(2018)

[5] Python 软件基础，PEP 8—Python 代码风格指南，(2001–2020)

[6]照片由尤妮斯·德·古兹曼在Unsplash(2019)上拍摄

[7] M.Przybyla. 一个成功的数据科学模型需要 GitHub 。原因如下。, (2020)

[8] M.Przybyla，每个数据科学家都需要知道的通用 Git 命令，(2020)*

2020 年及以后最受欢迎的 10 种编程语言

原文：https://towardsdatascience.com/10-most-popular-programming-languages-for-2020-and-beyond-67c512eeea73?source=collection_archive---------7-----------------------

讨论当今 10 种最流行的编程语言的范围、优缺点

图片由皮克斯拜的 Gerd Altmann 提供

在编程领域，大约有 700 种编码语言。

理解每种编程语言的意义以及它们如何影响我们需要执行的特定任务是至关重要的。

因为我们不可能坐在这里看 700 多种编码语言(即使我们可以，也可能不是世界上最足智多谋的活动！)简单回顾一下 2020 年及以后最流行的一些语言是个好主意。

我们将分析这 10 篇文章的特点、优点、缺点和未来的范围，并确定它是否值得学习。有些选择可能是自以为是的，但观众可以在查看所有事实后自己决定什么最适合他们。让我们从零开始，按照降序来分析这些语言！

图片来自 GitHub

10.C

c 是一种通用的、过程化的计算机编程语言，支持结构化编程、词法变量范围和递归，具有静态类型系统。通过设计，C 提供了有效映射到典型机器指令的结构。尽管它是大多数编程语言存在的原因，但它在各种领域仍有一席之地，如嵌入式系统、微控制器和嵌入式操作。

未来范围:

在某些应用程序中，c 可能已经过时了，但是它决不会在短时间内消失。这是一个广泛的用途和现实世界的应用，并将在未来几年应用于行业。这可能很难学，但最终，如果你有时间和资源，这可能是值得的。

优点:

1. 这是一种极其灵活的语言。
2. 对基于嵌入式系统的应用非常有用。
3. 整体强大而高效的语言。

缺点:

1. 稍微过时的语言。
2. 初级阶段学习起来很复杂。

9.C#

C#是本文将要讨论的第一个 C 克隆。C#是一种通用的多范例编程语言，包括强类型、词汇范围、命令式、声明式、函数式、泛型、面向对象和面向组件的编程原则。C#专门用于游戏行业。像 Unity 这样的软件工具也使用 C#来创建游戏。

未来范围:

C#是一种越来越受欢迎的语言，由于它在创建游戏方面的有效能力和对游戏行业有帮助的健壮性，它可能会在未来几年继续流行下去。它在企业应用程序中也非常有用。

优点:

1. 与 Windows 平台集成得非常好。
2. 与 c 语言相比更容易学习的语言。
3. 因为 C#是一种编译语言，所以它是安全的。

缺点:

1. 已知在某些 Linux 框架上有问题。
2. 每次都必须编译代码，这导致了某些限制。

8.服务器端编程语言（Professional Hypertext Preprocessor 的缩写）

PHP 是一种通用的脚本语言，特别适合 web 开发。它最初是由丹麦裔加拿大程序员拉斯马斯·勒德尔夫在 1994 年创建的；PHP 参考实现现在是由 PHP 小组开发的。它更适合服务器端的 web 开发，但不幸的是，它被认为是一种垂死的语言，有更好的替代方法来执行类似的任务。

未来范围:

PHP 现在被认为是一种总体上很枯燥的语言，并不令人印象深刻。与 PHP 相比，有更好的编程语言可供选择。然而，它确实在道德黑客和网络安全以及网站设计领域找到了用途。

优点:

1. 自动化常见的 web 开发任务。
2. 用于道德黑客和网络安全。

缺点:

1. 学习 PHP 的要求写 PHP 代码的要求。
2. 缺少修改核心行为的选项

7.红宝石

Ruby 是一种解释型的高级通用编程语言。它是由日本的松本幸宏(Yukihiro“Matz ”)在 20 世纪 90 年代中期设计和开发的。Ruby 是动态类型的，使用垃圾收集。Ruby 是一种典型的脚本语言，在 GitHub、Fiverr 等网站上有着广泛的实际应用。

未来范围:

在当今世界，Ruby 仍然被大量的应用程序使用。因此，考虑学习它可能是一种很好的语言，因为你很快就能开发复杂的应用程序。它也是很好的技术，即使在今天也能保持其相关性。

优点:

1. 它有大量有用的工具和库。
2. Ruby 的社区非常大而且非常活跃。

缺点:

1. 缺乏灵活性和一个简单的错误可能会付出巨大的代价。
2. 性能时间是一个问题，因为框架的启动时间相当长，尤其是当您处理大型项目时，

6.C++

C++是一种面向对象的编程语言。C++是 C 的超集。我们已经知道的关于 C 的大部分知识也适用于 C++。所以几乎所有的 C 程序也都是 C++程序。然而，有一些微小的差异会阻止 C 程序在 C++编译器下运行。C++添加到 C 中的最重要的功能是类、继承、函数重载和构造函数重载。它广泛用于 AAA 游戏和 3-D 模型的开发。

未来范围:

类似于前面提到的 C 和 C#的 C++仍然很流行，学习它绝对不是一个坏主意。尤其是 C++，因为它相对来说是一种更容易掌握和学习的语言。它在工业中有广泛的应用。也用于 AAA 游戏以及图形设计和 3d 模型。

优点:

1. C++被认为是一种可移植性极强的语言。
2. 它允许对代码进行低级操作。
3. C++是非常可扩展的，因为 C++程序能够在小规模和大规模数据上运行。

缺点:

1. C++中存在轻微的安全问题。
2. 在 C++中，指针消耗大量内存。

5.以打字打的文件

Typescript 是一种较新的编程语言。TypeScript 是一种由微软开发和维护的编程语言。它是 JavaScript 的一个严格的语法超集，并为该语言添加了可选的静态类型。TypeScript 是为开发大型应用程序而设计的，可以转换为 JavaScript。它为编码人员提供了更好的接口模块、更简单的编码、导航、错误管理等。

未来范围:

TypeScript 的未来似乎特别强劲，因为它是由微软开发的，并且正在添加许多附加功能，以使编码、导航、编程接口和其他东西更加用户友好，并使程序员的生活更加轻松。

优点:

1. 更好的类型注释和整体界面。
2. 使代码管理更容易。
3. 人气和信任度上升。

缺点:

1. 对于某些用户来说，与 JavaScript 相比，过于复杂的输入系统。
2. 编译的强制性要求。

4.去

2012 年，谷歌只有 2 名员工开发了 Go 或 Golan。Go 是一种静态类型的编译编程语言，由 Robert Griesemer、Rob Pike 和 Ken Thompson 在 Google 设计。Go 在语法上类似于 C，但是具有内存安全、垃圾收集、结构化类型和 CSP 风格的并发性。Go 是一种开源编程语言，可以轻松构建简单、可靠、高效的软件。

未来范围:

围棋是一门极其流行的新兴语言。围棋的潜力很大，它绝对是一门值得深入学习的语言。最近，围棋甚至开始与许多其他应用一起用于人工智能和机器学习。所以，总体来说，围棋是一门很好的开始学习的语言。

优点:

1. 坚固且极其简单。
2. 它有一个智能库来完成复杂的任务。
3. 强大的内置安全性。

缺点:

1. 缺少虚拟机。
2. 有时过于简单——Go 可能是一种容易掌握的语言，但这也带来了通用性的缺乏。

3.Java 语言(一种计算机语言，尤用于创建网站)

Java 是一种基于类的、面向对象的编程语言，它被设计成具有尽可能少的实现依赖性。Java 是一种通用语言，非常适合游戏和移动应用程序开发。它在企业级应用程序和 web 应用程序中也很有用。它提供了代码的结构和可维护性。

未来范围:

Java 被认为是一种慢慢消亡的语言，类似于 PHP，但不同于后者，它仍然被许多公司广泛使用。它还可以用于创建多种产品，具有广泛的应用。它足够相关和受欢迎，可以被认为是一种需要学习的编程语言。

优点:

1. 提供代码的结构和可维护性。
2. 它简单且独立于平台。
3. 它是安全的，也是多线程的，因为它允许程序在任何情况下执行多个任务。

缺点:

1. 内存消耗高。
2. 与其他语言相比，性能较慢。

2.计算机编程语言

Python 是一种面向对象的高级编程语言，早在 1991 年就发布了。Python 具有高度的可解释性和高效性。简单来说——Python 很神奇。我最初是从 C、C++和 Java 这样的语言开始的。当我终于遇到 python 的时候，我发现它相当优雅，简单易学，易于使用。对于任何人来说，Python 都是开始机器学习的最佳方式，甚至对于以前没有编程或编码语言经验的人也是如此。尽管有一些缺陷，比如被认为是一种“慢”语言，python 仍然是人工智能和机器学习的最佳语言之一。

未来范围:

不用说，python 在编程语言的开发领域有着光明的前景，尤其是在数据可视化、人工智能、数据科学、探索性数据分析和机器学习等领域。

在下面两篇文章中了解关于 python 的更多信息:

[## 开始使用 Python 掌握机器学习的旅程

了解精通机器学习的基本要求

towardsdatascience.com](/starting-your-journey-to-master-machine-learning-with-python-d0bd47ebada9) [## 机器学习所需的 Python 基础知识及其库模块

学习 python 数据结构的基础知识，对机器所需的每个库有直观的理解…

towardsdatascience.com](/basics-of-python-and-its-library-modules-required-for-machine-learning-51c9d26026b8)

优点:

1. python 非常简单和一致。
2. 与各种库和框架相关的丰富资源。
3. 伟大的社区和持续更新。总的来说，python 社区充满了令人惊奇的人，并且不断更新以改进 python。
4. 多功能性和平台独立性。这意味着 python 也可以导入用其他编程语言构建的基本模块。

缺点:

1. 由于某些算法的实现时间比其他编程语言慢，所以它有时被认为是一种很慢的语言。

1.Java Script 语言

JavaScript 通常缩写为 JS，是一种符合 ECMAScript 规范的编程语言。JavaScript 是高级的，通常是即时编译的，并且是多范例的。它有花括号语法、动态类型、基于原型的面向对象和一流的功能。它是一种非常流行的语言，在网络上随处可见。它是一种非常通用的语言，用于构建交互式前端用户界面。

未来范围:

JavaScript 是一种非常流行的语言。它被如此广泛地使用，以至于要用另一种编程语言来取代它可能需要相当长的时间。它不仅可以应用于网络开发，还可以应用于人工智能和其他应用。这门语言应该是任何人学习的首选语言。

优点:

1. 非常简单和通用的语言。
2. 速度快，因为它是一种解释型语言。
3. 高度可解释性，并与其他语言也很好地工作。
4. 人气上升，界面好。

缺点:

1. 客户端安全性有时会受到损害。
2. 缺少调试设备。

照片由 Clément H 在 Unsplash 上拍摄

结论:

本文涵盖了撰写本文时使用的前 10 种编程语言的简明列表。但是，这并不意味着其中一个比另一个更好，或者排名较低的那些没有那么有用。

每种编程语言都有自己独特的方式，可以用于各种目的。所以，如果你有时间、资源和机会，不要停止学习一门新的编程语言！

我强烈鼓励你们所有人研究这些编程语言，看看它们对编码的未来意味着什么，以及它们对人工智能、机器学习和数据科学作为一个整体的资源贡献。

本文的主要来源和参考资料是 2020 年第三季度的 GitHub 。

如果你喜欢这篇文章，那么看看其他你可能也喜欢阅读的文章吧！

[## 聚类无监督学习简明指南！

借助聚类算法详细理解无监督学习的概念。

towardsdatascience.com](/concise-guide-to-unsupervised-learning-with-clustering-4924cdbb27cb) [## 4 个基本正则表达式操作符使自然语言处理变得更简单！

了解四种基本的常规操作，以清理几乎任何类型的可用数据。

towardsdatascience.com](/natural-language-processing-made-simpler-with-4-basic-regular-expression-operators-5002342cbac1) [## 带有完整代码片段和有用链接的 5 个最佳 Python 项目创意！

为 Python 和机器学习创建一份令人敬畏的简历的 5 个最佳项目想法的代码片段和示例！

towardsdatascience.com](/5-best-python-project-ideas-with-full-code-snippets-and-useful-links-d9dc2846a0c5) [## 人工智能是破解宇宙奥秘的关键，下面是原因！

人工智能、数据科学和深度学习的工具是否先进到足以破解人类大脑的秘密

towardsdatascience.com](/artificial-intelligence-is-the-key-to-crack-the-mysteries-of-the-universe-heres-why-56c208d35b62) [## OpenCV:用代码掌握计算机视觉基础的完全初学者指南！

包含代码的教程，用于掌握计算机视觉的所有重要概念，以及如何使用 OpenCV 实现它们

towardsdatascience.com](/opencv-complete-beginners-guide-to-master-the-basics-of-computer-vision-with-code-4a1cd0c687f9)

谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！

10 篇必读的机器学习文章(2020 年 4 月—5 月)

原文：https://towardsdatascience.com/10-must-read-machine-learning-articles-april-may-2020-d490960dd851?source=collection_archive---------51-----------------------

作者图片

在机器学习方面已经完成了许多令人惊叹的工作，以及 2020 年 4 月和 5 月发布的有趣的数据集。在这篇文章中，我们将浏览一些最大的人工智能新闻、研究论文和来自世界上一些最大的科技公司的公开数据集，包括微软、脸书、谷歌和优步。

无论您认为自己是数据科学初学者、中级还是专家，无论您的技能水平如何，都可以从下面的文章中获得有趣的信息。

机器学习新闻

1. 开源 BiT:探索大规模计算机视觉前期训练

从谷歌人工智能博客中，研究人员介绍了大转移(BiT):通用视觉表示学习，这是一种在大规模图像数据集上进行预训练的新方法。

图片来自 ai.googleblog.com

模型和数据集是开源的，文章中有下载链接。有趣的是，该团队表示，仅在更大的数据集上进行预训练并不总是会导致更高的模型准确性。为了从较大数据集的预训练中获得最大收益，必须扩展较小的模型架构，必须增加计算预算，以及更长的训练时间。

2.优步放松其人工智能实验室:看看他们的一些顶级作品

许多公司受到了新冠肺炎危机的负面影响，优步的拼车服务无疑受到了很大冲击。由于这些挫折，该公司已经决定关闭他们的人工智能实验室。他们发表了官方声明:

“鉴于必要的成本削减和对核心的日益关注，我们决定逐步关闭孵化器和人工智能实验室，以寻求优步工厂的战略替代方案。”

本文通过回顾优步人工智能团队所做的一些最好的工作，向该公司的人工智能实验室致敬，包括人工智能生成算法、POET(成对的开放式开拓者)、PLATO 平台等等。

3.物体是揭示视觉和语言之间世界的秘密钥匙

图片来自microsoft.com

这篇文章来自微软研究博客，解释了视觉和语言预训练(VLP)的巨大进步及其在图像-文本对数据上训练大型模型的潜力。在文章中，研究团队还引入了 Oscar(对象语义对齐预训练),以展示如何将对象用作锚点，以绘制图像和文本之间的语义连接。

4.介绍 Holopix50k:图像超分辨率的新基准数据集

图像超分辨率有可能改善虚拟现实、视频监控和许多其他技术。

图片来自 leiainc.com

为了给研究人员提供高质量的图像超分辨率和深度估计训练数据，Leia Inc .最近发布了 Holopix50k，这是世界上最大的“野外”立体图像对数据集。

5.亚马逊科学家作者热门深度学习书籍

作为世界上最大的科技公司之一，亚马逊一直处于将机器学习应用于企业目的的前沿。通过 Amazon SageMaker，他们为数据科学家提供了一个大规模构建和部署 ML 模型的平台。现在，亚马逊一些最伟大的数据科学家发布了一本名为《深入学习》的开源书籍。这本书教授深度学习背后的思想、数学和代码。此外，作者计划根据用户的评论和反馈不断更新这本书。

6.脸书发布仇恨迷因数据集并发起挑战

图片经由ai.facebook.com

脸书的人工智能团队建立并开源了一个新的数据集，以帮助研究人员创建检测仇恨言论的模型。“仇恨迷因”数据集有超过 10，000 个多模态示例。除了数据集，他们还发起了一项名为“仇恨迷因挑战”的比赛，由 DrivenData 主办，总奖金为 10 万美元。

如果你对仇恨言论检测感兴趣，你也应该看看这篇文章重点介绍了脸书·艾在该领域的进展。

机器学习指南和专题文章

7.如何用 WSL 使用不准确的数据进行机器学习

对于预算较少的独立研究人员和团队来说，很难获得大量的训练数据。解决这个问题的一个方法是使用更容易收集的低质量注释。

图片来自 lionbridge.ai

在本文中，作者通过几种基于图像的数据的弱监督学习(WSL)技术，解释了利用弱注释进行机器学习的方法。

8.人工智能如何改变谷歌地图的故事

谷歌地图在过去二十年里发展迅猛，用户界面不断发展，对现有的设计和功能进行了调整。这篇文章讲述了谷歌地图如何发展的故事，特别是谷歌如何使用机器学习来改善他们的平台。

此外，文章还解释了谷歌为使地图平台达到今天的水平而进行的所有收购，以及谷歌地图的未来扩张计划。

9.如何使用数据增强技术将图像数据集放大 10 倍

该指南由 AI Summer 的创始人撰写，解释了什么是数据增强，以及如何使用数据增强来增加影像数据集大小的指南和提示。从基本的图像操作到基于 GAN 的数据增强，本指南为该领域的初学者和中间用户提供了有趣的信息。

10.疫情正在清空呼叫中心，人工智能聊天机器人正在涌入

由于许多国家实行隔离和封锁，许多公司被迫关闭了大部分呼叫中心。然而，对于政府组织来说，在疫情期间，来电者的数量增加了，大多数团队没有人员来处理增加的数量。

这篇文章讲述了纽约州 Ostego 县的 IT 主管如何实现 IBM Watson chatbot 来处理新冠肺炎的查询，尽管大量裁员。

新冠肺炎文章和资源

已经发布了大量关于新冠肺炎的文章，所以我们没有在上面的章节中包括任何与 COVID 相关的文章。然而，如果你正在寻找这样的文章或新冠肺炎数据集，下面是一些可能对你有用的资源。

• 新冠肺炎开发者资源中心
• 全球冠状病毒数据集库
• 人工智能技术如何对抗冠状病毒

希望您从上面的一篇文章中学到了一些新的东西，可以应用到您自己的项目中。尽管由于新冠肺炎，全球遭遇挫折，但我们已经看到在 2020 年初，在机器学习方面做了很多伟大的工作。在今年剩下的时间里，我们可能会看到更多令人惊叹的文章。

为了跟上人工智能和机器学习的所有最新动态，请务必在 Twitter 和 Medium 上关注我。

10 篇必读的机器学习文章(2020 年 3 月)

原文：https://towardsdatascience.com/10-must-read-machine-learning-articles-march-2020-80da9c380981?source=collection_archive---------8-----------------------

虽然新冠肺炎占据了全世界的头条，但值得注意的是，在机器学习的世界里，许多公司都在照常运营。当然，现在几乎每个人都采取了一些措施来对抗冠状病毒的传播。然而，许多研究人员正在努力工作，以保持人工智能世界的进步和创新。

这个列表将展示机器学习领域最近的一些工作和发现，以及初学者和中级数据科学家的指南和资源。

机器学习新闻

1.谷歌推出云人工智能平台管道 —本文解释了谷歌云人工智能平台的测试版，以帮助机器学习开发。该公司将他们的平台描述为一个简单且易于安装的机器学习工作流环境。

2.人工智能植入物让截肢者能够控制假肢手——来自《麻省理工科技评论》，这篇文章概述了一项惊人的研究，旨在帮助截肢者更好地控制假肢的运动。保罗·塞德娜教授(该研究的共同领导者)声称，在最初的校准后，“思想和行动之间没有差距。”

3.人工智能正在改变视频游戏行业——一个增强和合成媒体的时代——正如标题所示，这篇文章解释了人工智能和游戏行业的现状。它详细介绍了人工智能中对改善视频游戏具有巨大潜力的领域，如增强现实和生成式人工智能模型。

4.人工智能的突破可能会显著改善 Oculus Quest——作为虚拟现实消费市场的先驱之一，Oculus 自 2014 年被脸书收购以来已经显著增长。他们的增长很大一部分可能要归功于 Oculus Quest，这是有史以来第一款无绳独立 VR 游戏系统。这篇文章解释了人工智能的突破如何在不改变硬件的情况下将 Quest 的图形功能提高 67%。

ML 指南和专题文章

5.FastAI 简介 —在本指南中，数据科学学生达里奥·拉德契奇对 Fast AI 进行了很好的概述，这是一个广泛用于机器学习的库。本指南详细解释了如何使用 Fast AI 处理 MNIST 数据集，一步一步地介绍了整个过程。

6.CNN 和 RNN 有什么区别？ —本机器学习基础知识指南对卷积神经网络和递归神经网络进行了简要介绍。它解释了如何在计算机视觉和 NLP 中使用它们，以及两种类型的人工神经网络之间的基本差异。

7.数据分析的未来 —公司将如何经营我们的数据？我们能利用数据来改善教育系统吗？从规范分析的道德伦理到教育和虚拟助手，这篇文章让我们一瞥数据分析的未来。

8.社交媒体数据挖掘技术 —数据挖掘和数据收集是当今许多企业正在使用的非常广泛的研究领域。本文简要介绍了社交媒体中的数据挖掘，以及如何使用它来发展在线业务。

机器学习资源

9.谷歌数据集搜索——尽管这个专门的数据集搜索引擎已经在谷歌的开发日历上出现了一段时间，但它最终在今年年初退出了测试。正如在《走向数据科学中报道的，谷歌数据集搜索让你可以访问超过 2500 万个开放数据集。

10.来自每个国家的冠状病毒数据集 —几乎每个人都想到了新冠肺炎，这个数据集聚合器每周更新一次，当新的数据集可用时就会添加进来。这个列表中的许多数据集每天都在更新。

正如你所看到的，每天仍然有大量的机器学习工作在进行。我们希望你从这些人工智能新闻文章中获得一些新的见解，或者从某个指南中学到一些新的东西。

更多机器学习新闻和指南，别忘了关注我的黑客正午、推特、我的个人博客。

你应该知道的 10 个数字函数

原文：https://towardsdatascience.com/10-numpy-functions-you-should-know-1dc4863764c5?source=collection_archive---------2-----------------------

数据科学和人工智能的例子

Numpy 是一个用于科学计算的 python 包，提供了高性能的多维数组对象。这个库广泛用于数值分析、矩阵计算和数学运算。在本文中，我们展示了 10 个有用的 numpy 函数以及数据科学和人工智能应用。我们开始吧！🍀

1.numpy.linspace

numpy . Lin space(start， stop ， num=50 ， endpoint=True ， retstep=False ， dtype=None ， axis=0 ) 函数返回由函数的前两个参数定义的指定间隔内均匀分布的数字生成的样本数量由第三个参数 num 指定。如果省略，将生成 50 个样本。在使用这个函数时要记住的一件重要事情是，停止元素是在返回的数组中提供的(默认情况下 【端点=真】 ，不像在内置的 python 函数 范围 中那样。

例子

Linspace 函数可用于为 x 轴生成均匀间隔的样本。例如，如果我们想要绘制一个数学函数，我们可以通过使用 numpy.linspace 函数轻松地为 x 轴生成样本。在强化学习中，我们可以使用该函数进行离散化，提供连续空间(状态或动作)的最高和最低值，生成一致的离散空间。

下图显示了 4 个数学函数:(1)正弦，(2)余弦，(3)指数，以及(4)对数函数。为了生成 x 轴数据，我们使用 linspace 函数，生成从 0 到 100 的 111 个数据点，包括 0 和 100。你可能会注意到，为了生成数学函数，我们再次使用了 Numpy 。我们可以参考文档来观察 Numpy 提供的大量数学函数:)

2。numpy . digital

也许你从来没有听说过这个函数，但是在强化学习中使用连续空间确实很有用。numpy . digitize(x，bin， right=False ) 函数有两个参数:(1)一个输入数组x；以及(2)一个数组**bin，**返回每个值所在 bin 的索引迷惑？让我们看一个例子👌

例子

在上面的代码中，我们总共有 5 个 bin:

• x < 0 → Index 0
• 0≤ x < 1 → Index 1
• 1≤ x < 2 → Index 2
• 2≤ x < 3 → Index 3
• 3≤ x → Index 4

Therefore, if we provide as an input 0.5, the function returns 1, since that is the index of the bin to which 0.5 belongs.

In 强化学习，我们可以用等间距网格离散化状态空间。离散化允许我们将为离散空间设计的算法，如 Sarsa 、 Sarsamax 或预期 Sarsa 应用于连续空间。

想象我们有下面的连续空间。代理可以在任意位置(x，y)，其中 0≤x≤5，0≤y≤5。我们可以通过提供一个元组来离散化代理的位置，表示代理所在的网格。

我们可以通过使用 numpy.digitize 函数轻松实现这种离散化，如下所示:

我们将考虑任何小于 1 的值属于库索引 0，任何大于或等于 4 的值属于库索引 4。瞧！我们已经把一个连续的空间变成了一个离散的空间。

3。numpy.repeat

numpy . repeat(a， repeats ， axis=None )** 函数repeats 数组的元素。重复次数由第二个参数**指定重复*。*****

例子

假设我们有两个不同的数据框，包含 2017 年和 2018 年的销售额，但我们只想要一个数据框，包括所有信息。

2017 年销售额

2018 年销售额

在合并两个数据框之前，我们需要添加一列，指定产品销售的年份。我们可以通过使用 numpy.repeat 函数来添加这些信息。随后，我们使用 pandas.concat 函数连接两个数据帧。

销售

4.numpy.random

4.1.numpy.random.randint

numpy . random . randint(low， high=None ， size=None ， dtype='l' )** 函数返回区间[low，high]中的随机整数。如果 高 参数缺失(无)，则从区间[0，低]中选取随机数。默认情况下，返回一个随机数(int)。为了生成一个随机整数数组，数组的形状在参数 size 中提供。**

例子

该函数可用于模拟随机事件，如抛硬币或掷骰子，如下所示。

4.2。numpy.random.choice

numpy . random . choice(a， size=None ， replace=True ， p=None )** 从给定数组中返回一个随机样本。默认情况下，返回单个值。要返回更多的元素，可以在参数 size 中指定输出形状，就像我们之前使用 numpy.random.randint 函数一样。**

例子

上面显示的随机事件也可以通过使用 numpy.random.choice 来模拟。

默认情况下，元素被选中的概率相等。为了给每个元素分配不同的概率，可以提供概率数组。使用这个参数 p ，我们可以模拟一个有偏的硬币翻转如下:**

4.3.数字随机二项式

我们可以使用 numpy 来模拟各种各样的统计分布，如正态分布、贝塔分布、二项式分布、均匀分布、伽玛分布或泊松分布。

numpy . random . binomial**(n， p ， size=None ) 从二项分布中抽取样本。当有两个相互排斥的结果时，使用二项分布，提供 n 次试验的成功次数以及单次试验的成功概率****

我建议阅读文档并发现 numpy.random 库提供的广泛功能。

5.numpy.polyfit

numpy.polyfit( x ， y ， deg ， rcond=None ， full=False ， w=None ， cov=False ) 函数输出一个 deg 的多项式，即【T50

这个函数在线性回归问题中非常有用。线性回归模拟因变量和自变量之间的关系，获得最符合数据的直线。

y =a+bx

其中 x 为自变量， y 为因变量， b 为斜率， a 为截距。要获得系数 a 和 b，我们可以使用 numpy.polyfit 函数，如下所示。

例子

假设我们有一个包含 5000 名男性身高和体重的数据框。

正如我们所观察到的，两个变量呈现线性关系。

我们通过以下方式用 numpy.polyfit 函数获得最佳拟合线性方程:

该函数返回线性模型的斜率( 5.96 )和截距( -224.50 )。现在，我们可以利用得到的模型( y=5.96x-224.50 )来预测一个人的体重(看不见的数据)。这个预测可以通过使用 numpy.polyval 函数来获得。

6.numpy.polyval

numpy . polyval**(p， x) 函数计算特定值的多项式。之前我们已经通过使用 numpy.polyfit 函数得到了一个预测一个人(体重= 5.96 身高-224.50) 体重的线性模型。现在，我们使用这个模型通过 numpy.polyval 函数进行预测。假设我们想预测一个 70 英寸高的男人的体重。作为参数，我们提供从最高次到常数项( p=[5.96，-224.49] )的多项式系数(用 polyfit 获得)，以及一个用来计算p(x = 70*)的数。****

下图显示了回归线和预测重量。

7.numpy .楠

Numpy 库包括几个 常量 如非数字(Nan)、无穷大(inf)或 pi。在计算中，not number 是一种可以解释为未定义值的数字数据类型。在 Pandas 中，我们可以使用 not 数字来表示缺失值或空值。不幸的是，脏数据集包含具有其他名称的空值(例如 Unknown、—、n/a ),因此很难检测和丢弃它们。

例子

假设我们有以下数据集，其中包含马德里市的房屋信息(出于解释目的，此数据集有所缩减)。

具有非标准缺失值的数据框

通过使用 熊猫，我们可以很容易地分析缺失值。data frame . info方法。此方法打印有关数据框的信息，包括列类型、非空值的数量和内存使用情况。

info 方法的输出

正如我们所观察到的，info 函数没有检测到意外的空值(Unknown 和-)。我们必须将这些值转换成熊猫可以检测到的空值。我们可以通过使用 numpy.nan 常量来实现这一点。

在分析数据之前，我们必须处理缺失值。为此，有不同的方法:(1)手动分配缺失值(如果我们知道数据)，(2)用平均值/中值替换缺失值，或(3)删除有缺失数据的行，以及其他方法。

在用标准空值替换(Unknown 和-)之后，在 num _ bedrooms 和 num _ balconies 列中检测到两个缺失值。现在，通过使用熊猫可以很容易地删除那些丢失的值。DataFrame.dropna 函数(方法 3)。

删除空值之前的数据帧

删除空值后的数据帧

8.numpy.argmax

numpy . arg max**(a， axis=None ， out=None ) 函数返回一个轴上最大值的索引。****

在 2d 数组中，我们可以很容易地获得最大值的索引，如下所示:

我们可以获得沿指定轴的最大值的索引，为 轴 属性提供 0 或 1。

例子

在强化学习任务中， numpy.argmax 非常有用。 Q 表是一个动作值函数估计，包含每个状态-动作对的，假设代理处于状态 s，并采取动作 a，遵循策略 π 直到剧集结束。**

q 表

我们可以通过选择为每个状态提供最大 期望回报 的动作 a 来容易地获得策略

Q 表中的策略

在上面的例子中， numpy.argmax 函数返回策略:状态 0 →动作 0，状态 1 →动作 2，状态 2 →动作 1。

9.numpy .挤压

numpy . squeeze**(a， axis=None ) 从数组的形状中删除一维条目。参数 轴 指定了我们要挤出的轴。如果所选轴的形状大于 1，则出现 值错误 。如何使用 numpy.squeeze 函数的示例如下所示。****

正如我们所观察到的，只有轴 0 和轴 2 可以被删除，因为它们的长度都是 1。轴 1 有 3 个元素；因此，会引发 ValueError。

例子

Pytorch 是基于 torch 库的开源机器学习库。该库提供了多个数据集，如 MNIST、Fashion-MINST 或 CIFAR，我们可以用它们来训练神经网络。首先，我们用 torchvision.datasets 函数下载数据集(例如 MNIST)。然后，我们通过使用torch . utils . data . data loader创建一个 iterable。这个 iterable 被传递给 iter() 方法，生成一个迭代器。最后，我们通过使用 next() 方法获得迭代器的每个元素。这些元素是形状为[N，C，H，W]的张量，其中 N 表示批量大小，C 表示通道数量，H 表示输入平面的高度(以像素为单位), W 表示宽度(以像素为单位)。****

为了可视化前一批元素，我们必须删除第一个轴，因为matplotlib . py plot . im show函数接受 shape (H，W)的图像作为输入。

批次的第一个图像

10.数字直方图

numpy . histogram(a，bin = 10，** range=None ， normed=None ， weights=None ， 密度=None 该函数返回 2 个值:(1)频率计数，以及(2)箱边缘。****

例子

以下数据框包含 5000 名男性的身高。我们创建一个直方图，将 kind='hist' 传递给 plot 方法。

默认情况下，直方图方法将数据集分成 10 个箱。请注意，x 轴标签与箱子尺寸不匹配。这可以通过传入一个包含箱子尺寸列表的 xticks 参数来解决，方式如下:

感谢阅读！！🍀 🍀 💪并且使用 Numpy！

用于数据分析的 10 个我最喜欢的 Python 库

原文：https://towardsdatascience.com/10-of-my-favorite-python-libraries-for-data-analysis-597e09cca026?source=collection_archive---------3-----------------------

一些你应该在 Python 中使用的优秀分析包的快速概要。

(图片由作者提供)

介绍

目前地球上最流行的通用编程语言是 Python 编程语言。这不仅是因为 Python 非常简单，而且相对较快，而且 Python 有一个杀手级的生态系统，其中的工具适合从商业到金融和科学的各个学科。在数据科学的奇妙世界中，有一个领域肯定证明了这一点。

当然，Python 也是当今用于数据科学的最流行的编程语言。虽然大多数使用这种语言的科学家可能都熟悉许多广为人知且广泛使用的软件包，如 Scipy、Sklearn 和 Matplotlib，但也有一些大多数数据科学家从未听说过的软件包非常棒！

№1: Plot.ly

首先，我将介绍一个非常有名的数据可视化库，但有些人可能从未听说过。Plot.ly 是一个图形库，将交互性提升到了一个全新的水平。我真心建议使用 Plot.ly，而不是 Matplotlib 或 Seaborn。这是因为 Plot.ly 附带了许多不同的工具，大多数科学家肯定会喜欢这些工具。Plot.ly 里到底有多少？

嗯…

基本制图

Plot.ly 预装了普通数据科学家甚至只是计算机程序员可能期望的所有奇妙工具。散点图、条形图和折线图都是 Plot.ly 模块的主要内容。虽然 Matplotlib 可以实现类似的目标，但 Plot.ly 具有相同的功能，同时还具有默认样式和 Java-script 交互性，这使得探索数据变得更加有趣和容易。除此之外，使用 Plot.ly 比使用许多竞争对手的产品更有利于展示。

除此之外，Plot.ly 还有一些鲜为人知的图表，你很难在大多数其他数据可视化包中找到。漏斗图、饼图、小提琴图和树状图只是使用 Plot.ly 库探索数据的一些独特而有趣的方法的几个例子。

三维（three dimension 的缩写）

除了基本情节的漂亮造型之外，Plot.ly 还配备了功能齐全的 3D 可视化系统，可与现代技术的一些最佳产品相媲美。Plot.ly 处理 3D 的一大优势是性能。虽然 3D 可视化当然非常复杂和密集，但 Plot.ly 似乎可以相对轻松地处理许多这些应用程序。3D 可视化也很棒，因为新的轴通过探索数据在 3D 空间中的位置值，允许更多的理解。此外，Z 轴还可以表示各种特征，从而可以一次查看多种不同的相关性。

地图

在最近的技术发展中，一件令人惊讶的事情是地理数据。地理数据在 FIPS 发展到如此程度，主要是因为智能手机和全球定位系统(GPS)，这为数据科学奠定了坚实的基础。这当然是因为现在的数据比以往任何时候都更容易获得，包括地理数据在内。

也很难否认 Plot.ly 对地图的漂亮处理。特别是 Plot.ly 的 clorepleths，使用起来绝对是一种享受，可以在几秒钟内实现引人注目的可视化。

金融的

虽然金融方面的东西肯定不是我的大部分领域知识，但 Plot.ly 对一些金融可视化有很大的支持。这也显示了 Plot.ly 的多功能性，因为可视化依赖于许多科学家的领域内外。就像 Plot.ly 中的所有东西一样，金融图表易于使用，也很漂亮——不久前，我参与了一个项目，在这个项目中，我们跟踪货币的价值，并使用 LSTM 模型创建了一个完整的网络应用程序，该应用程序将重新训练自己，并根据它所学的知识预测新数据。在这种情况下，Plot.ly 因其易于使用和 Javascript 集成的烛台数据可视化而真正派上了用场。

统计的

为了增加 Plot.ly 的不合理功能，Plot.ly 还支持几种不同类型的统计图。此外，Plot.ly 的统计绘图非常成熟，使得绘制分布图等事情变得相对简单和容易。

多语言

Plot.ly 的另一个优点是它是用 c 编写的，因此，它使用 LLVM 编译器库，并且只需一个简单的 API 就可以兼容一系列编程语言。Plot.ly 不仅适用于 Python 用户，还适用于 R 用户、C 用户以及任何愿意实现它的其他语言的用户群。甚至有一个使用 Plots.jl 包的 Julia 语言实现。

开源

Plot.ly 的最后一个优点是它是开源的。虽然这对某些人来说好处不大，但是如果需要的话，能够进行更改或者理解代码在您的机器上是如何运行的，总是一个优势。作为开源软件还意味着 Plot.ly 可以用于实际的商业应用程序，不仅对那些将编程作为业余爱好的人来说是有价值的，对现实世界的专业人士来说也是如此。

№2:gg 图

我推荐的第二个使用 Python 进行数据分析的工具是 GGPlot.py。任何有 R 编程语言经验的科学家都可能使用过 GGPlot 或 GGPlot2。R 和 Python 包都很棒，让绘图变得轻而易举，而且更加深入。虽然 R 实现确实值得一试，但是 Pythonic 版本也确实非常棒。

注重统计的

GGPlot 包和 Python 的 Plot.ly 包之间的一个显著区别是，GGPlot 更加注重统计。Plot.ly 是一个很好的数据可视化工具，但也是针对更典型的数据可视化，而不是专门的统计绘图。

基于几何图形

关于 GGPlot 另一个值得注意的重要事情是它的图形和可视化方法。一般来说，GGPlot 在几何上更加模块化。这意味着可以很容易地添加或更改成分。这对数据科学更有利，因为通常有某个想法或数据点可能比其他的更需要强调。

№3:散景

Bokeh 是另一个交互式绘图库，它是基于现代网络浏览和计算而构建的。与 Plot.ly 类似，Bokeh 可能不像 GGPlot 那样可扩展，但通过与 Javascript 的难以置信的集成，它提供了许多优于前者的好处。每个数据科学家都喜欢交互式可视化，Bokeh 经常将这一点带到一个非常高级和简单的 API，并带来令人惊叹的结果。

类似于 Plot.ly

作为一种可视化工具，散景与 Plot.ly 非常相似，这并不是一件坏事。这意味着使用散景可以非常容易地创建漂亮的交互式可视化效果。

图表

虽然散景在许多方面与 Plot.ly 相似，但散景肯定不是这种情况。不仅支持所有典型的可视化技术，而且散景还允许用户创建几乎任何东西的有趣的交互式可视化。散景的一个相对常见的用途是网络图的可视化，这真的很酷！除此之外，它还提供了人们可能从 Plot.ly 库中期待的地理数据可视化。

第四名:交响乐

脱离可视化世界的是一个奇妙的 Python 包，叫做 SymPy。MATLAB、Mathematica 和 Julia 程序员们，抓紧你们的帽子——SymPy 是一个 Python 模块，它允许 Python 程序员和科学家使用更多的数学绑定。这使得这种语言从一种更典型的软件工程方法转向数学，而在另一端，代码经常被写成数学。

酷图书馆

Pythonic 代码和数学的许多令人惊叹的实现使用 SymPy 进行后端数学计算。以下是一些直接从他们主页上摘下来的著名例子:

• Cadabra :张量代数和(量子)场论体系使用 SymPy 作标量代数。
• ChemPy :用 Python 写的对化学有用的包。
• Lcapy :教学线性电路分析实验 Python 包。
• Spyder :科学的 Python 开发环境，相当于 Rstudio 或 MATLAB 的 Python；Spyder 的 IPython 控制台可以启用完整的 SymPy 支持。

兰比菲

很容易，SymPy 必须提供的最酷的东西是修改语言内部的任何表达或功能的能力。我之前谈过为什么我认为 Lambda 是 Python 开发人员可用的最好工具之一。如果你想读一篇关于这个话题的文章，你可以在这里查阅:

[## 带 Lambda 的科学 Python

在过去的十年中，Python 编程语言已经进入了许多领域的人的脑海…

towardsdatascience.com](/scientific-python-with-lambda-b207b1ddfcd1)

虽然 Python 的 lambda 本身就是一个很好的内联参数，但是使用 SymPy 的 Lambdify 函数，它变得更加强大。它是这样工作的:

首先，您可以创建一个用作数学函数的表达式，在本例中为 sin(x)。

**import** **numpy**a = numpy.arange(10)expr = sin(x)

然后，该函数可以通过 lambdify，成为其自身的一个非常实用的版本:

f = lambdify(x, expr, "numpy")

这是所有 SymPy 的基础，并使使用 Python 编程语言进行科学计算变得更加容易。使用这个函数实际上可以让 Python 探索 Julia 语言的一个好处，语法表达式。如果你想学习更多关于 Julia 语言如何使用表达式的知识，你可以在这里查看完整的教程:

[## 如何在 Julia 中使用语法表达式和调度

朱莉娅的面包和黄油:句法表达和多重调度

towardsdatascience.com](/how-to-use-syntactical-expressions-and-dispatch-in-julia-67ce155e4af9)

№5:火焰

Blaze 生态系统是一组 Python 库，使得用 Python 编程语言查询和处理数据变得容易得多。Blaze 生态系统实际上由几个不同的包组成:

• 火焰
• 达斯克
• 数据形状
• DyND
• 奥多

对于 Python 编程语言来说，这些都是极好的、有用的、制作精良的工具。然而，我将把重点放在我用得最多并且发现最有价值的两个方面，因为它与科学计算有关。

火焰

Blaze 是一个在完全不同的存储系统上查询各种数据的界面。这对于检索和分析大数据转储非常有用，这些大数据转储可能需要通过算法进行分解，而且可能位于不同存储介质的不同部分。对于那些在特殊环境下工作的人来说，这是一个非常有用的工具，并多次拯救了我的生命。

达斯克

Dask 是一个非常独特的包，它允许在 Python 中进行简单和大多数可变的并行计算。Python 中的并行计算在某种程度上一直是该语言的一个挑战，此外，对于该语言可用的许多最大的包来说，优化已经变得难以置信地困难，因为该语言并没有考虑到并行计算的思想。

也就是说，随着语言本身朝着这个方向发展，Dask 是一个很好的工具，可以与 GPU 支持保持一致，并与 CuArrays 一起工作。Dask 还具有由相关程序员明确编码的动态任务调度和大数据收集功能。

№6:橙色

Orange 是一个用于数据挖掘的 Python 库。这与数据分析有什么关系？Orange 有一整套收集数据的工具，这些数据以后可以用于分析，而分析离不开数据。也就是说，数据争论是数据科学过程中非常重要的一步，Orange 有助于使这一过程更加简单。

更酷的是，该模块附带了一些分类和回归模型，您可以在新挖掘的数据上使用它们！

№7: Gensim

Genism 是一个用于主题建模的 Python 库。Genism 的伟大之处在于它既易于使用，又非常强大。使用 Gensim，您可以创建比您的计算机占用更多内存的可扩展统计语义，也可以部署到真实的生产环境中。此外，Genism 可以很容易地实现来执行自然语言处理。

№8: Theano

Theano 是另一个数学 Python 库，它允许程序员高效地处理大量数据。虽然它可能比不上 SymPy 之类的以数学为中心的东西，但它做了许多非常酷和有趣的事情，使 Python 中的线性代数变得有趣多了。最重要的是，与许多类似的解决方案相比，Theano 非常准确，而且相对较快。最重要的是，该包与 Numpy 紧密集成，并动态集成 C 代码，使 Python 运行更快。

№9: SciPy

如果您已经使用 Python 进行了一周的统计，那么您很可能已经使用了 SciPy。SciPy 是 Python 语言中统计测试的首选包。SciPy 不仅通常是一个使用起来很快的包，而且它也是一个值得尊敬的包，并且已经被证明超时工作效果非常好。SciPy、Pandas 和 Numpy 的结合使 Python 成为普通科学家甚至更多数据科学家工作的伟大语言。

包括的

关于 SciPy，可以肯定的一点是，该模块具有很强的包容性。虽然这可能意味着有时很难找到你到底需要什么，但这也意味着你需要的一切都唾手可得——在我看来，这是一笔不错的交易。SciPy 库将从统计到分布，甚至微分方程的所有内容都变成了任何人都可以使用的简单易懂的函数！

№10:海风

我推荐的最后一个用于 Python 编程语言数据分析的工具是 Python 经典之作:

海博恩。

Seaborn 是 MatPlotLib 的扩展。将统计绘图集成到模块中的 PyPlot。Seaborn 为绘制、操作和使用漂亮的统计图形提供了一个高级界面。虽然与 Bokeh 或 Plot.ly 相比，Seaborn 的外观可能会显得苍白，但它在速度方面的重要性令人难以置信。当处理具有大量观测值的数据集时，尝试使用 Seaborn 而不是 Plot.ly 或 Bokeh 进行数据可视化可能是个好主意。Seaborn 的简单性是其最大的好处，因为它使 MatPlotLib 中熟悉的绑定变得快速而容易使用。

结论

如果现代开发人员使用的一种语言拥有数据分析和可视化的最佳生态系统，它很可能是 Python。Python 有很多工具，这些工具不仅对统计观察很有用，而且对使语言本身更具统计性也很有用。此外，就可视化而言，很少有语言能与 Python 编程语言提供给基于 Python 的科学家的惊人模块相媲美。也就是说，这些是我真正喜欢的模块——但是还有更多，所以在回复中了解更多肯定会很有趣！

过去 10 年中被忽视的 10 项机器学习进展

原文：https://towardsdatascience.com/10-overlooked-machine-learning-advances-in-the-last-10-decades-2e9fe9f2f073?source=collection_archive---------23-----------------------

今天的机器学习是建立在近一个世纪的科技进步之上的。一些最重要的进步在当时被低估了，大多数今天仍然被忽视。这篇文章分享了过去十年中机器学习的一个被忽视的进步。

人工智能和机器学习领域最著名的进展已经受到了太多的关注，看看那些被忽视的东西往往更有意思。考虑到这一点，本文描述了每个十年的机器学习趋势，并确定了每个十年中一个重要但被忽视的发展。

1920 年代:我们想象机器学习

20 世纪 20 年代是唯一一个《T2》十年来最著名的电影是关于人工智能的十年。也是在这里，一部成功的国际戏剧将“机器人”一词引入英语。

雅科夫·普罗塔扎诺夫(я́ков·протазааззно)导演的电影《阿丽塔》(аэли́та)是 20 世纪 20 年代最被忽视的进步:一部无声的俄罗斯科幻电影，它是根据阿列克谢的一本书改编的，该书是托尔斯泰的作品，也以《阿丽塔:机器人的反抗》和《阿丽塔:火星女王》的形式发行

Aelita 想象了不同星球上人和机器之间的关系，这有助于它比当代科幻电影更好地经受住时间的考验，后者想象了一个没有实现的未来世界。当时有更多有影响力的电影制作人，甚至在俄罗斯也有，但没有一个人如此深刻地关注艾。虽然一些内容在今天已经站不住脚了，但大部分(尽管不是全部)都是电影中工程师的想象，而不是真实的事件。

一个世纪前 Aelita 的核心经验是我们今天仍然需要学习的:人类和机器的理想组合不应该由一个过于专注于自己的工作而无法与社会互动的特权工程师来幻想。

你可以在线免费观看这部电影:

二十世纪二十年代俄罗斯的无声电影《艾丽塔》

20 世纪 30 年代:第一个机器学习产品

第一台电子计算机建于 20 世纪 30 年代，第一台计算机的复制品正在计算机历史博物馆展出。

由 Homer Dudley 开创的 Voder 是 20 世纪 30 年代一项被忽视的机器学习进步:一种可以从键盘发出逼真人声的语音合成器。令人难以置信的是，在电子计算机发明的同一十年里，达德利试图将一台电子计算机变成一种商业产品。我尤其喜欢他看到了它对语言障碍者的影响。虽然 Voder 在纽约的世界博览会和旧金山的金门国际博览会上进行了演示，但像后来许多来到湾区的人工智能初创公司一样，它并不成功。

然而，Dudley 使用的压缩技术被通信社区所采用，并且相同类型的表示仍然是今天语音识别技术的基础。后来，他发现在 20 世纪 60 年代发布的语音合成技术套件产品获得了成功。

Voder 的早期演示视频可以在这里看到:

20 世纪 40 年代:概率模型

20 世纪 40 年代最著名的进步发生在第二次世界大战期间，包括美国爱国好战的计算机建造者和英国爱国但受压迫的密码破译者。

Stanislaw Ulam 在 20 世纪 40 年代开发的蒙特卡罗方法被忽视了。在蒙特卡罗方法发展之前，所有的模型都被认为是确定性的，概率是用来衡量置信度的。使用蒙特卡罗方法，概率第一次被融入到模型中。

我们今天使用的几乎每一种机器学习算法都是基于概率分布的，Ulam 在 20 世纪 40 年代将其作为当时流行的组合方法的替代方法。但是，这些方法中的许多方法在几十年里都没有在机器学习中得到普及，Ulam 在那个时候已经被更著名的合作者所掩盖。这项工作还受到了第二次世界大战期间的事实的阻碍:最初的蒙特卡罗方法论文/备忘录可能是一份永远不会公开的机密文件。

这种方法的名字来源于蒙特卡洛赌场，该赌场经常公开，不像战争时期的备忘录/文件，它是在那里首次公布的。

20 世纪 50 年代:无监督的机器学习

20 世纪 50 年代是名人统计学家的十年，他们在其他社会影响中宣布吸烟和肺癌之间的关系是相关的，而不是因果关系，所以每个人都应该继续吸烟(在自然！).与机器学习最相关的是第二著名的无监督机器学习算法期望最大化 (EM)，该算法首次发表后被引用超过 10，000 次。

20 世纪 50 年代一个被忽视的进步是 Tore Dalenius 发明的第一个最著名的无监督机器学习算法 K-Means 。与期望最大化的 10，000+引用不同，最初的 K-Means 论文今天还没有 300 次引用:

最优分层的问题。托雷·达勒纽斯。斯堪的纳维亚精算杂志，1950 年。泰勒&弗朗西斯。

与本文中几乎所有其他被忽略的人不同，Dalenius 没有维基百科页面，这一事实凸显了这项工作是如何被忽略的，并且 Dalenius 被错误地从维基百科的K-Means 的历史部分中忽略也没有帮助，该部分只引用了 5 年多后发表的工作。不可思议的是，dale nius在维基百科的差分隐私历史条目中被提及:

"迈向统计披露控制的方法学"。托雷·达勒纽斯。Statistik tidskrft。1977.

另一篇文章被引用的次数稍微多一点，但是引用次数仍然不到 500 次。“差分隐私”允许像你的手机这样的智能设备使用机器学习来根据你的需求定制其行为，而不会泄露你的身份。这可能是未来十年机器学习进步最重要的领域之一，如果 Dalenius 在这两个领域都有第一篇论文，那将令人印象深刻！

这是 1950 年 K-Means 论文的摘要，如果你自己知道，你可以判断达伦纽斯是否值得被认为是最早的发明者:

把“strata”换成“cluster”，自己决定这看起来是不是像 K-Means。一个有趣的观察:斯堪的纳维亚精算杂志仍然存在，并且从 1918 年开始出版！

60 年代:合作

60 年代举办了至今仍在运行的首届 AI 大会；毕业了第一批纯粹专注于人工智能的博士生；并介绍了第一个机器学习模型，其中不同的组件相互作用，而不是独立行动。在计算机为人的时代，美国授予了第一批计算机科学学科的博士学位。专注于机器学习的人从(硬件)工程、数学、语言学和心理学等领域的背景走到一起，进行合作，形成了我们今天所知的机器学习领域。

最被忽视的进步也是在合作方面:当时最大的技术合作是太空竞赛，其中最被忽视的人是凯瑟琳·戈布尔、玛丽·杰克森和多萝西·沃恩，所有的有色人种女性都是在美国种族隔离仍然合法的时候开始职业生涯的，她们都对美国宇航局最早的太空任务的成功至关重要。一部关于他们在美国宇航局工作的电影不足以弥补他们当时没有得到的认可，包括只允许男性名字出现在研究论文上的政策。如果不是他们的一位 NASA 同事有一个女儿，后来成为了一名作家，他们的故事可能不会为人所知。

戈贝尔、杰克逊和沃恩是一个重要的提醒，即使多年后被认为“被忽视”，大多数人已经有特权把他们的名字印在(后来被忽视的)纸张、艺术品或产品上。对于历史上大多数被忽视的人来说，他们所取得的成就没有留下任何记录。

电影《隐藏的人物》:看看这部电影，想想我们改变了多少。例如，有多少其他“十年总结”文章忽略了数据注释社区的多样性？

20 世纪 70 年代:人机界面

除了现代搜索引擎的一些统计基础之外，20 世纪 70 年代是当今最流行的数据驱动的机器学习的“人工智能冬天”。尽管如此，人机交互和人工智能在这段时间里走到了一起，最著名的是十年前的第一款街机游戏，并在十年后的第一款家用游戏机中达到高潮。

电脑游戏激发了我们对与智能机器互动的想象:历史上第一次，人们开始普遍考虑超越智能电脑，即使当时的游戏没有使用我们今天所说的机器学习。

当电脑游戏告诉我们人类如何解读机器的智能时，社会科学家正在研究电脑如何帮助我们理解人类的智能。

20 世纪 70 年代最被忽视的进步仍然是创建精确训练数据最广泛使用的指标，Krippendorff 的 alpha。原始论文今天只有大约 250 次引用:

估计区间数据的可靠性、系统误差和随机误差。克劳斯·克里本多夫。教育与心理测量，30* (1)，1970 年*

今天，大多数机器学习训练数据是由多个人并行注释相同的数据来创建的，以避免任何一个人的错误。例如，当自动驾驶汽车得知某个物体是“骑自行车的人”时，这是因为多个人对同一视频进行了注释，并同意某个物体是“骑自行车的人”，从而克服了任何个人可能将骑自行车的人错误地分类为“摩托车”或“行人”的错误。假设不是所有的注释者都能看到训练数据中的每一幅图像，也不是所有的对象都彼此一样频繁，那么我们如何准确地计算出人们彼此有多少一致呢？Krippendorff 的 alpha，现在已经有半个世纪的历史了，仍然是计算我们的数据集中整体一致性水平最常用的指标。

Krippendorff 的 alpha 应该被称为“Krippendorff 的公牛”，因为像公牛一样，它是机器学习中最努力但不被重视的指标之一。它被广泛应用于各种数据类型——比任何一种算法都要广泛。因此，Krippendorff 的 alpha 对当今更多机器学习应用的准确性的影响可能比任何其他算法都要大。

Krippendorff 的 alpha 也叫“Krippendorff 的公牛”，因为这个算法非常有效，也可能是因为“alpha”的字面意思是“公牛”

80 年代:机器超越人

20 世纪 80 年代见证了第一次真正的人工智能繁荣，主要是人工智能的符号方法，但也有统计方法，如 T2 神经网络和结合统计和符号方法的方法，如 T4 决策树。虽然大多数算法都有更早的前身，有些甚至更早，但到了 20 世纪 80 年代，硬件已经足够先进，通用的机器学习算法可以针对任何有数据的问题进行训练。

虽然当时几乎没有任何一种机器学习进步进入第一台个人计算机，但计算能力的进步意味着计算机可以在简单的任务中超过人类。人们也开始理解分布在全球网络上的信息的内在力量。正是这种对智能、联网计算机的理解，导致艺术家们思考人工智能和人类之间的新关系，发表在现在著名的小说、漫画和电影中，所有这些都是联网人工智能对人类的操作。

在 20 世纪 80 年代，我们如何想象人工智能的一个被忽视的进步是伊恩·M·班克斯的小说《游戏玩家》。班克斯没有想象一个人工智能刚刚超过我们的崩溃社会，而是想象一个人工智能已经远远超过人类能力的先进社会，以至于人们处于后匮乏社会，过着休闲和星际旅行的生活。

虽然将小说设定在一个近乎完美的社会听起来很无聊，但班克斯发现了托尔斯泰(是的，就是那个托尔斯泰)关于人际关系的观察的完美补充:“幸福的家庭都是相似的，不幸的家庭各有各的不幸”。班克斯发现人工智能恰恰相反，可以总结为:不快乐的人工智能都试图以同样的方式毁灭人类，每一个快乐的人工智能都以自己的方式破坏人类”。人工智能(小说中的“思想”)破坏人类个体的无数方式是一个广阔的画布，比一部机器异常专注于杀死所有人的小说更有趣。银行的世界在大范围内同样可怕，这些社会的底层比当时许多更直接的反乌托邦小说、漫画和电影更黑暗、更坚韧。**

游戏的玩家以人类(或类似人类的生物，对乌苏拉·勒奎恩大加赞赏)为中心，玩着可能更容易被人工智能赢得的棋盘游戏。它被公开质疑:为什么人类会选择继续玩一个人工智能可以击败他们的游戏？

这个故事与今天非常相关，在 AI 超越特级大师之后，一位著名的围棋选手最近退出了。尽管这与国际象棋大师们早先做出的将人类和机器玩家结合起来的决定形成了对比。我们显然需要花更多的时间来思考我们与人工智能的未来关系，以防它不试图杀死我们所有人。当我们把所有需要的东西都自动化后，我们还剩下什么角色？

银行的另一本文化书籍正被拍成电视剧，因此它可能不会被忽视太久。

90 年代:AI 在你手中

20 世纪 90 年代是人们开始定期与人工智能互动的时候，最著名的是基于智能新算法的搜索引擎得到广泛传播。

一个被忽视的进步是马自达 Cosmo Eunos。是的，汽车是机器学习中最被忽视的进步之一。这是第一辆拥有 GPS 导航的汽车，并且只配备了自动变速器，这在今天的跑车中几乎是闻所未闻的。它还有一个一次性的旋转发动机，这使它比任何汽车都安静，直到几十年后电动汽车出现。

全球定位系统、触摸屏和自动变速器的自动化在 1990 年感觉很超前，就像自动驾驶汽车在今天感觉很超前一样。我们与智能汽车的关系总是比任何其他产品更能抓住人们的想象力，无论是解决犯罪的会说话的汽车还是感受到健身者因不够智能而愤怒的未来汽车。

考虑到通货膨胀因素，马自达 Cosmo Eunos 仍然是马自达有史以来最昂贵的汽车。不幸的是，它只在日本有售，而且是在汽车和电子经济泡沫破裂时发行的。在许多方面，这是泡沫的顶点，日本的发明家正处于他们想象力的巅峰。最终，在 1996 年停产之前，马自达的销量不到 1 万辆。

汽车专家最近的一篇评论称它为比今天市场上的任何东西都更狂野，其内部造型和早期的触摸板与星际迷航下一代宇宙飞船相比。这是这个时代最令人向往的汽车，也是第一款预示着完全自动驾驶体验的汽车，即使司机仍然是由方向盘后面的人驾驶。

在 20 世纪 90 年代，这种风格是另一回事。

2000 年代:数据十年

随着互联网和廉价数码相机的迅速发展，2000 年意味着比以往任何时候都有更多的数据可用。这是当数据量第一次被认为与算法对模型准确性同样重要的时候。因此，毫不奇怪，今天最流行的数据集是在这十年中建立的。

在这个十年的开始，一个命名实体识别数据集足够聪明地知道，虽然英语和德语是两种关系最密切的语言，但这两种语言对名称的处理非常不同，特别是在名词的大写方式上。将近 20 年后，NLP 的研究人员已经解决了这个问题……忽略德语的结果，只报告英语的结果，希望没人注意到。十年后，最著名的计算机视觉数据集诞生了。

2000 年代机器学习中一个被忽视的进步是由国家标准与技术研究所(NIST) 创建的法律数据集。你可能没有听说过 TREC 2009 法律跟踪，除非你在 NLP 工作的法律文件。当时只有 5 个团队参与了评估，该数据集从那以后就没有在学术界流行过。

然而，这项任务走在了时代的前面:建立在数据基础上的系统的回忆准确性是作为人类审查工作的一个功能来衡量的。这不是孤立地想象机器学习的抽象准确性任务。这项任务特别关注机器学习如何帮助人类。这种被称为电子发现的任务在今天是一个价值 100 亿美元的产业。今天没有多少机器学习行业价值数十亿美元，这一行业在 2000 年代从机器学习中发展出来，几乎没有人注意到。对于 2000 年代创建的任何其他类型的机器学习数据集，甚至没有一个市场接近这样的规模。

对律师来说,“时间就是金钱”,这句话被写进了 TREC 2009 法律追踪的评估标准中。

2010 年代:迁移学习

最近的十年是我们真正展示机器学习模型如何从一项任务适应另一项任务的第一个十年，最终形成了现在主导自然语言处理的模型，这些模型被专门设计为通用模型，以适应非常不同的任务。

十年刚刚过去，很难确定迁移学习的哪个方面是最重要的。很难将功劳归于神经架构的进步，因为大多数都是在更早的时候发明的，你可能已经忘记了(像我一样，直到写这篇文章)，一篇关于计算机视觉中的迁移学习的基础论文使用了 SVM 作为分类器，而不是神经模型。将功劳归于特征的矢量表示也是困难的。NLP 和计算机视觉社区可能在过去十年中发展迅速，但信息检索社区会指出，自 20 世纪 90 年代以来，他们一直在用特征的矢量表示为搜索引擎提供，并向你推荐 15，000+引用的论文。

因此，迁移学习的进步是关于比算法本身更广泛的目标:允许模型容易地用于不同的用例选择，从而支持不同的人群。

一项被忽视的进展是由 David Jurgens、Yulia Tsvetkov 和 Dan Jurafsky 撰写的一篇论文:

将方言的可变性纳入社会公平的语言识别。大卫·尤尔根斯，尤利娅·茨韦特科夫和丹·茹拉夫斯基。2017.计算语言学协会第 55 届年会会议录

语言表达是人工智能中最大的偏见。对于世界上 99%的语言来说，许多人认为理所当然的人工智能，如搜索引擎、垃圾邮件过滤和语音识别，根本不起作用。因此，了解人们在说什么语言是解决这种偏见的最重要的步骤之一，包括吸收每种语言中不太常见的变体(方言)的能力。研究人员特别观察了与健康相关的数据，发现它极大地提高了代表性不足的人群的准确性，使开发更具社会包容性的工具成为可能。

然而，这篇论文只有大约 20 篇引文。研究人员本身也没有被忽视:Jurgens、Tsvetkov 和 Jurafky 是密歇根大学、卡内基梅隆大学和斯坦福大学的研究人员，但这篇论文没有进入其中任何一所大学被引用次数最多的前 10 名。

有多少其他机器学习论文将其准确性与人类发展指数进行了比较？

结论

上个世纪机器学习中被忽视的 10 个进步是:一部电影；一个产品；机密备忘录；瑞典发明家/会计师；人类计算机；协议度量；一本小说；一辆汽车；数据集；和一篇研究论文。

过去 10 年中被忽视的 10 项机器学习进展

很容易忘记将我们带到机器学习当前状态的发明、思想和社会变革的漫长历史。回想过去，让我们的想象力被长达一个世纪的进步重新点燃，这很有趣！

罗伯特·芒罗| 2020 年 1 月| @WWRob

感谢

如果没有我们完全任意的日历和以 10 为基数的计数系统，这篇文章是不可能完成的。我感谢我们 3 . 4 亿年前被忽视的祖先，他决定每只手的 5 个手指应该是标准的。我还要感谢 16 世纪被忽视的医生，T2，他发明了我们的日历。教皇格里高利在路易吉死后继续推广“格里高利”日历，向每个人保证“这是路易吉希望的…以他最喜欢的教皇的名字命名日历。”

让我的数据分析过程更高效的 10 个熊猫窍门:第 1 部分

原文：https://towardsdatascience.com/10-pandas-tricks-to-make-my-data-analyzing-process-more-efficient-part-1-78a0cc1636f3?source=collection_archive---------26-----------------------

我希望我早点知道的技巧

由 Max Duzij 在 Unsplash 上拍摄的照片

Pandas 可能是 Python 中最重要的数据分析库，它就像 Python 中的 Excel。在这篇文章中，我想分享 10 个熊猫的技巧，我希望我作为一个初学者能早点知道。

我将用我以前的文章作为例子，它讨论了新冠肺炎期间的空中交通。数据集包含 7 个独立的 cvs 文件，包含 7 个月的飞行数据。每个文件大约有 200 万行数据。你可以在这里查看原始数据集。

[## 新冠肺炎疫情期间空中交通的可视化

2020 年全球航班数据的探索性数据分析

towardsdatascience.com](/visualization-of-air-traffic-during-covid-19-pandemic-c5941b049401)

read_csv()

read_csv可能是 Pandas 中最常用的函数，它用于读取 csv 文件并创建数据帧。

df=pd.read_csv(path_data/'1.csv')

如果文件很大，可能需要一段时间来读取，所以你可以考虑先读取一小部分，用nrows快速浏览，然后用df.info()检查数据帧

默认情况下，日期时间列作为对象加载。我们可以用parse_dates正确读出。

如果您已经知道您需要哪些列来进行分析，您可以使用usecols来只读取您需要的列。

您也可以使用dtype自行指定数据类型。

selectt_dtypes()

有时您需要选择具有相同数据类型的列进行分析。可以用selectt_dtypes。例如:

复制()

copy()在熊猫的数据分析中很重要。

假设我们有一个数据帧df1

我们分配一个新的数据帧df2 = df1，然后做一些计算

你也会发现df1的变化。

如果不想要，可以用copy()避免。

concat()

如果你有多个数据帧，你想把它们放在一起，你可以使用concat()，例如:

如果你有多个大文件要处理，你也可以将pd.concat和pd.read_csv合并

它比编写循环来读取和连接多个文件更方便、更快。

值计数

value_counts()用于计算唯一值。

您可以通过设置normalize=True对其进行规范化

您也可以使用bins将连续数据转换成离散区间，从而将其用于连续数据

感谢阅读，我将在第 2 部分文章中继续其他 5 个技巧。

[## 让我的数据分析过程更高效的 10 个熊猫窍门:第二部分

我希望我早点知道的技巧

towardsdatascience.com](/10-pandas-tricks-to-make-my-data-analyzing-process-more-efficient-part-2-b72ea43a0bb5)

有兴趣也可以看看我之前关于 Python 和 Numpy 的文章。

[## 让我的代码更好更聪明的 7 个 Python 技巧。

我希望我能早点知道的技巧。

towardsdatascience.com](/7-python-tricks-to-make-my-code-better-and-smarter-60dfde0b6c49) [## 让我的代码更好更聪明的 7 个小技巧

我希望我早点知道的技巧

towardsdatascience.com](/7-numpy-tricks-to-make-my-code-better-and-smarter-9e8a4ccf43d1)

让我的数据分析过程更高效的 10 个熊猫窍门:第二部分

原文：https://towardsdatascience.com/10-pandas-tricks-to-make-my-data-analyzing-process-more-efficient-part-2-b72ea43a0bb5?source=collection_archive---------13-----------------------

我希望我早点知道的技巧

由 Max Duzij 在 Unsplash 上拍摄的照片

Pandas 可能是 Python 中最重要的数据分析库，它就像 Python 中的 Excel。在这篇文章中，我想分享 10 个熊猫的技巧，我希望我作为一个初学者早点知道。你可以在这里查看文章的第一部分:

[## 让我的数据分析过程更高效的 10 个熊猫窍门:第 1 部分

我希望我早点知道的技巧

towardsdatascience.com](/10-pandas-tricks-to-make-my-data-analyzing-process-more-efficient-part-1-78a0cc1636f3)

我将用我以前的文章作为例子，它探讨了新冠肺炎期间的空中交通。数据集包含 7 个独立的 cvs 文件，包含 7 个月的飞行数据。每个文件大约有 200 万行数据。你可以在这里查看原始数据集。

[## 新冠肺炎疫情期间空中交通的可视化

2020 年全球航班数据的探索性数据分析

towardsdatascience.com](/visualization-of-air-traffic-during-covid-19-pandemic-c5941b049401)

地图

map()是一个有用的函数，可以用其他值替换序列中的值。

例如，如果我们有一系列机场代码名称，并且我们希望用全名来替换它们，我们可以使用map来完成这项工作。

replace()也是做这项工作的一个选择。

map()也可以拿功能举例:

应用

apply()是一个将函数应用于数据帧或序列的函数。

如果我们有一个数据框架:

我们可以对数据帧应用一个函数:

我们也可以通过设置axis=0来进行列方式的计算

并按axis=1行

您也可以按不同的列进行计算

询问

query()用于搜索和过滤符合您想要的特定条件的行。

例如，我们有一个包含航班信息的数据帧。

如果我们只想查看来自阿姆斯特丹的航班，可以使用query()进行搜索。

如果您想要搜索多个机场，您可以将它们放在一个列表中:

也可能有多个条件:

分组依据

groupby()是通过对数据分组来探索数据集的强大工具。

再以飞行数据帧为例。

我们可以使用groupby来查看每天的航班数量

我们可以对数字列进行一些计算，例如mean()(这里没有意义)

我们可以使用agg()对不同的列进行不同的操作:

也可以按多个组进行分组:

结合concat()、query()和groupby()，很容易看到不同机场每天的航班数量:

切割()

cut()用于 bin 连续值。例如，如果我有一个包含几个数字的列表。

df=pd.DataFrame({'A':[1,2,4,6,7,2,9,2,1,6,8,9,3,4,6,9,6,3,1,2,4,6,8]})

我们可以使用cut()来绑定这些值:

我们还可以给箱子分配标签:

可以使用qcut()将变量离散成大小相等的桶

就是这样。感谢阅读。欢迎评论和建议。

有兴趣可以看看我关于 Python 和 Numpy 的文章。

[## 让我的代码更好更聪明的 7 个 Python 技巧。

我希望我能早点知道的技巧。

towardsdatascience.com](/7-python-tricks-to-make-my-code-better-and-smarter-60dfde0b6c49) [## 让我的代码更好更聪明的 7 个小技巧

我希望我早点知道的技巧

towardsdatascience.com](/7-numpy-tricks-to-make-my-code-better-and-smarter-9e8a4ccf43d1)

深度学习时代理解图像分类应该阅读的 10 篇论文

原文：https://towardsdatascience.com/10-papers-you-should-read-to-understand-image-classification-in-the-deep-learning-era-4b9d792f45a7?source=collection_archive---------7-----------------------

快速浏览十年来图像分类的最佳论文，帮助您快速学习计算机视觉

自己画

序

计算机视觉是一门将图像和视频转换成机器可理解的信号的学科。通过这些信号，程序员可以基于这种高层次的理解来进一步控制机器的行为。在许多计算机视觉任务中，图像分类是最基本的任务之一。它不仅可以用于许多真实的产品，如谷歌照片的标记和人工智能内容审核，而且还为许多更高级的视觉任务打开了一扇门，如物体检测和视频理解。由于自深度学习取得突破以来，该领域的变化非常快，初学者往往会觉得太难学习了。与典型的软件工程主题不同，关于使用 DCNN 进行图像分类的优秀书籍并不多，理解这一领域的最佳方式是阅读学术论文。但是读什么报纸呢？我从哪里开始？在这篇文章中，我将介绍 10 篇适合初学者阅读的最佳论文。通过这些论文，我们可以看到这个领域是如何发展的，以及研究人员是如何在以往研究成果的基础上提出新观点的。尽管如此，即使你已经在这方面工作了一段时间，理清大局对你还是有帮助的。那么，我们开始吧。

1998 年:LeNet

基于梯度的学习在文档识别中的应用

从 基于梯度的学习应用到文档识别

LeNet 于 1998 年推出，为未来使用卷积神经网络进行图像分类研究奠定了基础。许多经典的 CNN 技术，例如池层、全连接层、填充和激活层，被用于提取特征和进行分类。通过均方误差损失函数和 20 个历元的训练，该网络在 MNIST 测试集上可以达到 99.05%的准确率。即使在 20 年后，许多最先进的分类网络总体上仍然遵循这种模式。

2012 年:AlexNet

基于深度卷积神经网络的图像网分类

来自【ImageNet】用深度卷积神经网络分类

虽然 LeNet 取得了很大的成绩，显示了 CNN 的潜力，但由于计算能力和数据量的限制，这方面的发展停滞了十年。看起来 CNN 只能解决一些简单的任务，如数字识别，但对于更复杂的特征，如人脸和物体，带有 SVM 分类器的 HarrCascade 或 SIFT 特征提取器是更受欢迎的方法。

然而，在 2012 年 ImageNet 大规模视觉识别挑战赛中，Alex Krizhevsky 提出了一种基于 CNN 的解决方案，并将 ImageNet 测试集 top-5 的准确率从 73.8%大幅提高到 84.7%。他们的方法继承了 LeNet 的多层 CNN 的思想，但是大大增加了 CNN 的规模。从上图中可以看出，与 LeNet 的 32x32 相比，输入现在是 224x224，而且许多卷积核有 192 个通道，而 LeNet 的通道是 6 个。虽然设计没有太大变化，但参数增加了数百倍，网络捕捉和表示复杂特征的能力也提高了数百倍。为了训练这样一个大模型，Alex 使用了两个 GTX 580 GPU，每个 3GB RAM，这开创了 GPU 训练的趋势。此外，ReLU 非线性的使用也有助于降低计算成本。

除了为网络带来更多的参数之外，它还通过使用丢弃层来探索由更大的网络带来的过拟合问题。它的局部响应归一化方法后来没有得到太多的欢迎，但启发了其他重要的归一化技术，如 BatchNorm，以解决梯度饱和问题。综上所述，AlexNet 为未来 10 年定义了事实上的分类网络框架:卷积、ReLu 非线性激活、MaxPooling 和密集层的组合。

2014 年:VGG

用于大规模图像识别的超深度卷积网络

来自 Quora "https://www.quora.com/What-is-the-VGG-neural-network

随着使用 CNN 进行视觉识别取得如此巨大的成功，整个研究界都炸开了锅，所有人都开始研究为什么这个神经网络工作得这么好。例如，在 2013 年的“可视化和理解卷积网络”中，马修·泽勒讨论了 CNN 如何提取特征并可视化中间表示。突然，从 2014 年开始，每个人都开始意识到 CNN 是计算机视觉的未来。在这些直接追随者中，来自视觉几何小组的 VGG 网络是最引人注目的一个。在 ImageNet 测试集上取得了 93.2%的前 5 名准确率和 76.3%的前 1 名准确率。

遵循 AlexNet 的设计，VGG 网络有两个主要的更新:1) VGG 不仅使用了像 AlexNet 更广泛的网络，而且更深入。VGG-19 有 19 个卷积层，而 AlexNet 只有 5 个。2) VGG 还证明了一些小的 3×3 卷积滤波器可以取代 AlexNet 的单个 7×7 甚至 11×11 滤波器，实现更好的性能，同时降低计算成本。由于这种优雅的设计，VGG 也成为了其他计算机视觉任务中许多开创性网络的主干网络，例如用于语义分割的 FCN，以及用于对象检测的更快的 R-CNN。

对于更深的网络，多层反向传播的梯度消失成为更大的问题。为了解决这个问题，VGG 还讨论了预训练和重量初始化的重要性。这个问题限制了研究人员不断增加更多的层，否则，网络将真的很难收敛。但是两年后我们会看到更好的解决方案。

2014 年:谷歌网

用回旋更深入

从 到

VGG 有一个好看且易于理解的结构，但它的表现在 ImageNet 2014 竞赛的所有决赛选手中并不是最好的。GoogLeNet，又名 InceptionV1，最终获奖。就像 VGG 一样，GoogLeNet 的主要贡献之一是用 22 层结构推动了网络深度的极限。这再次证明了更深更广的确是提高精度的正确方向。

与 VGG 不同，GoogLeNet 试图正面解决计算和梯度递减问题，而不是提出一个更好的预训练模式和权重初始化的解决方案。

瓶颈初始模块从 到

首先，它通过使用一个名为 Inception 的模块探索了非对称网络设计的思想(见上图)。理想情况下，他们会追求稀疏卷积或密集层，以提高功能效率，但现代硬件设计并不适合这种情况。因此，他们认为网络拓扑级别的稀疏性也有助于功能的融合，同时利用现有的硬件能力。

第二，它通过借用一篇名为《网络中的网络》的论文中的思想来解决高计算成本问题。基本上，在进行像 5×5 卷积核这样的繁重计算操作之前，引入 1×1 卷积滤波器来降低特征的维度。这种结构后来被称为“瓶颈”，并广泛应用于许多后续网络中。与“网络中的网络”类似，它也使用了一个平均池层来取代最终的全连接层，以进一步降低成本。

第三，为了帮助梯度流向更深的层，GoogLeNet 还对一些中间层输出或辅助输出进行了监督。由于复杂性，这种设计后来在图像分类网络中不太流行，但在计算机视觉的其他领域越来越流行，如姿态估计中的沙漏网络。

作为后续，这个谷歌团队为这个盗梦空间系列写了更多的论文。“批量标准化:通过减少内部协变量偏移来加速深度网络训练”代表 InceptionV2。2015 年的“重新思考计算机视觉的初始架构”代表 InceptionV3。而 2015 年的“Inception-v4，Inception-ResNet 以及剩余连接对学习的影响”代表 InceptionV4。每篇论文都在初始网络的基础上增加了更多的改进，并取得了更好的结果。

2015:批量正常化

批量标准化:通过减少内部协变量转移加速深度网络训练

inception 网络帮助研究人员在 ImageNet 数据集上达到了超人的精确度。然而，作为一种统计学习方法，CNN 很大程度上受限于特定训练数据集的统计性质。因此，为了实现更好的准确性，我们通常需要预先计算整个数据集的平均值和标准差，并首先使用它们来归一化我们的输入，以确保网络中的大多数图层输入是接近的，这转化为更好的激活响应。这种近似方法非常麻烦，有时对于新的网络结构或新的数据集根本不起作用，因此深度学习模型仍然被视为难以训练。为了解决这个问题，Sergey Ioffe 和 Chritian Szegedy(Google net 的创始人)决定发明一种更智能的东西，叫做批处理规范化。

从 批量归一化:通过减少内部协变量加速深度网络训练

批量标准化的想法并不难:我们可以使用一系列小批量的统计数据来近似整个数据集的统计数据，只要我们训练足够长的时间。此外，除了手动计算统计数据，我们还可以引入两个可学习的参数“scale”和“shift ”,让网络学习如何自行标准化每一层。

上图显示了计算批量标准化值的过程。如我们所见，我们取整个小批量的平均值，并计算方差。接下来，我们可以用这个小批量平均值和方差来标准化输入。最后，利用一个比例和一个偏移参数，网络将学习调整批量归一化结果，以最佳地适应随后的层，通常是 ReLU。一个警告是，我们在推断过程中没有小批量信息，因此一个变通方法是在训练过程中计算移动平均值和方差，然后在推断路径中使用这些移动平均值。这个小小的创新如此具有冲击力，所有后来的网络都马上开始使用它。

2015 年:ResNet

用于图像识别的深度残差学习

2015 年可能是十年来计算机视觉最好的一年，我们已经看到许多伟大的想法不仅出现在图像分类领域，还出现在各种计算机视觉任务中，如对象检测、语义分割等。2015 年最大的进步属于一个名为 ResNet 的新网络，即残余网络，由微软亚洲研究院的一群中国研究人员提出。

从 深度残差学习进行图像识别

正如我们之前对 VGG 网络所讨论的，变得更深的最大障碍是梯度消失问题，即，当通过更深的层反向传播时，导数变得越来越小，最终达到现代计算机架构无法真正有意义地表示的点。GoogLeNet 试图通过使用辅助监督和不对称启动模块来解决这一问题，但这只是在很小程度上缓解了问题。如果要用 50 层甚至 100 层，会不会有更好的方式让渐变流过网络？ResNet 给出的答案是使用剩余模块。

残差模块来自

ResNet 在输出中增加了一个身份快捷方式，这样每个剩余模块至少不能预测输入是什么，而不会迷失在野外。更重要的是，残差模块试图学习输出和输入之间的差异，而不是希望每一层都直接适合所需的特征映射，这使得任务更容易，因为所需的信息增益更少。想象一下，你正在学习数学，对于每一个新问题，你都有一个类似问题的解决方案，所以你需要做的就是扩展这个解决方案，并试图让它发挥作用。这比为你遇到的每个问题想一个全新的解决方案要容易得多。或者像牛顿说的，我们可以站在巨人的肩膀上，身份输入就是那个巨人对于剩余模。

除了身份映射，ResNet 还借鉴了 Inception networks 的瓶颈和批量规范化。最终，它成功地建立了一个具有 152 个卷积层的网络，并在 ImageNet 上取得了 80.72%的顶级准确率。剩余法也成为后来很多其他网络的默认选项，比如 Xception、Darknet 等。此外，由于其简单美观的设计，它仍然广泛应用于当今许多生产视觉识别系统。

随着剩余网络的出现，出现了更多的不变量。在《深度剩余网络中的身份映射》中，ResNet 的原作者尝试将激活放在剩余模块之前，取得了较好的效果，这个设计后来被称为 ResNetV2。此外，在 2016 年的一篇论文“深度神经网络的聚合残差变换”中，研究人员提出了 ResNeXt，它为残差模块添加了并行分支，以聚合不同变换的输出。

2016 年:例外

例外:深度可分卷积深度学习

从" 例外:深度可分卷积深度学习 "

随着 ResNet 的发布，看起来图像分类器中大多数唾手可得的果实都已经到手了。研究人员开始思考 CNN 魔力的内在机制是什么。由于跨通道卷积通常会引入大量参数，因此 Xception network 选择研究这种操作，以全面了解其效果。

就像它的名字一样，Xception 起源于盗梦空间网络。在初始模块中，不同转换的多个分支被聚集在一起以实现拓扑稀疏性。但是为什么这种稀疏有效呢？Xception 的作者，也是 Keras 框架的作者，将这一思想扩展到了一个极端的情况，即一个 3x3 卷积文件对应于最终连接之前的一个输出通道。在这种情况下，这些并行卷积核实际上形成了一种新的操作，称为深度卷积。

从"深度方向卷积和深度方向可分离卷积

如上图所示，与传统卷积不同，传统卷积将所有通道包括在一次计算中，深度卷积仅单独计算每个通道的卷积，然后将输出连接在一起。这减少了通道之间的特征交换，但也减少了许多连接，因此产生了具有较少参数的层。但是，此操作将输出与输入相同数量的通道(如果将两个或更多通道组合在一起，则输出的通道数量会更少)。因此，一旦通道输出合并，我们需要另一个常规的 1x1 滤波器或逐点卷积来增加或减少通道数量，就像常规卷积一样。

这种想法原本并不奇怪。这在一篇名为“大规模学习视觉表现”的论文中有所描述，在 InceptionV2 中偶尔也会用到。Xception 更进一步，用这种新类型替换了几乎所有的卷积。实验结果证明效果很好。它超越了 ResNet 和 InceptionV3，成为一种新的 SOTA 图像分类方法。这也证明了 CNN 中跨通道相关性和空间相关性的映射可以完全解耦。此外，Xception 与 ResNet 具有相同的优点，设计简洁美观，因此它的思想被用于其他后续研究中，如 MobileNet、DeepLabV3 等。

2017 年:移动互联网

MobileNets:用于移动视觉应用的高效卷积神经网络

Xception 在 ImageNet 上实现了 79%的前 1 名准确率和 94.5%的前 5 名准确率，但与之前的 SOTA inceptions 3 相比，这两个准确率分别只提高了 0.8%和 0.4%。新的图像分类网络的边际收益越来越小，因此研究人员开始将注意力转移到其他领域。MobileNet 在资源受限的环境中极大地推动了图像分类。

“MobileNets:用于移动视觉应用的高效卷积神经网络”中的 MobileNet 模块

与 Xception 类似，MobileNet 使用了如上所示的深度方向可分离卷积模块，并强调了高效率和更少的参数。

“MobileNets:用于移动视觉应用的高效卷积神经网络”中的参数比

上述公式中的分子是深度方向可分离卷积所需的参数总数。分母是相似正则卷积的参数总数。这里 D[K]是卷积核的大小，D[F]是特征图的大小，M 是输入通道的数量，N 是输出通道的数量。由于我们将通道和空间特征的计算分开，所以我们可以将乘法转化为加法，这是一个较小的量级。更好的是，从这个比值可以看出，输出通道的数量越大，使用这个新的卷积可以节省越多的计算量。

MobileNet 的另一个贡献是宽度和分辨率倍增。MobileNet 团队希望找到一种规范的方法来缩小移动设备的模型大小，而最直观的方法是减少输入和输出通道的数量，以及输入图像的分辨率。为了控制这种行为，比率 alpha 与通道相乘，比率 rho 与输入分辨率相乘(这也会影响要素地图的大小)。因此，参数的总数可以用下面的公式表示:

“MobileNets:用于移动视觉应用的高效卷积神经网络”

虽然这种变化在创新方面看起来很幼稚，但它具有巨大的工程价值，因为这是研究人员第一次总结出一种规范的方法来调整网络以适应不同的资源约束。此外，它还总结了改进神经网络的最终解决方案:更宽和高分辨率的输入导致更好的精度，更薄和低分辨率的输入导致更差的精度。

随后在 2018 年和 2019 年，MobiletNet 团队还发布了《MobileNetV2:反向残差和线性瓶颈》和《寻找 MobileNetV3》。在 MobileNetV2 中，使用了一种反向剩余瓶颈结构。在 MobileNetV3 中，它开始使用神经架构搜索技术搜索最佳架构组合，我们将在接下来介绍这一点。

2017 年:纳斯网

用于可伸缩图像识别的学习可转移架构

就像针对资源受限环境的图像分类一样，神经架构搜索是 2017 年左右出现的另一个领域。通过 ResNet、Inception 和 Xception，我们似乎达到了人类可以理解和设计的最佳网络拓扑，但如果有更好、更复杂的组合，远远超出人类的想象，会怎么样呢？2016 年一篇名为《具有强化学习的神经架构搜索》的论文提出了一种思想，利用强化学习在预定义的搜索空间内搜索最优组合。众所周知，强化学习是一种为搜索主体寻找目标明确、回报丰厚的最优解的方法。然而，受计算能力的限制，本文只讨论了在一个小的 CIFAR 数据集上的应用。

NASNet 搜索空间。" 学习可扩展图像识别的可转移架构 "

为了找到像 ImageNet 这样的大型数据集的最佳结构，NASNet 创建了一个为 ImageNet 量身定制的搜索空间。它希望设计一个特殊的搜索空间，这样在 CIFAR 上的搜索结果也可以在 ImageNet 上很好地工作。首先，NASNet 假设 ResNet 和 Xception 等优秀网络中常见手工制作的模块在搜索时仍然有用。所以 NASNet 不是搜索随机的连接和操作，而是搜索 ImageNet 上已经被证明有用的这些模块的组合。第二，实际搜索仍然是在分辨率为 32x32 的 CIFAR 数据集上执行的，因此 NASNet 只搜索不受输入大小影响的模块。为了使第二点起作用，NASNet 预定义了两种类型的模块模板:Reduction 和 Normal。与输入相比，归约像元可能具有归约的特征图，而对于正常像元，情况也是如此。

从" 学习可扩展图像识别的可转换架构 "

尽管 NASNet 比手工设计的网络有更好的度量，但它也有一些缺点。寻找最佳结构的成本非常高，只有像谷歌和脸书这样的大公司才能负担得起。此外，最终的结构对人来说没有太大的意义，因此在生产环境中更难维护和改进。2018 年晚些时候，“MnasNet:移动平台感知神经架构搜索”通过用预定义的链式块结构限制搜索步骤，进一步扩展了 nasNet 的想法。此外，通过定义权重因子，mNASNet 给出了一种更系统的方法来搜索给定特定资源约束的模型，而不仅仅是基于 FLOPs 进行评估。

2019 年:效率网

EfficientNet:重新思考卷积神经网络的模型缩放

2019 年，CNN 的监督图像分类似乎不再有令人兴奋的想法。网络结构的剧烈变化通常只会带来很小的精度提高。更糟糕的是，当相同的网络应用于不同的数据集和任务时，之前声称的技巧似乎不起作用，这导致了对这些改进是否只是在 ImageNet 数据集上过度拟合的批评。另一方面，有一个技巧永远不会辜负我们的期望:使用更高分辨率的输入，为卷积层添加更多的通道，并添加更多的层。虽然非常残酷，但似乎有一种原则性的方法可以按需扩展网络。MobileNetV1 在 2017 年提出了这一点，但后来重点转移到了更好的网络设计上。

摘自"" efficient net:反思卷积神经网络的模型缩放 "

在 NASNet 和 mNASNet 之后，研究人员意识到，即使有计算机的帮助，架构的改变也不会产生那么大的好处。所以他们开始退回到扩展网络。EfficientNet 就是建立在这个假设之上的。一方面，它使用 mNASNet 的最佳构建块来确保良好的基础。另一方面，它定义了三个参数α、β和ρ来相应地控制网络的深度、宽度和分辨率。通过这样做，即使没有大型 GPU 池来搜索最佳结构，工程师仍然可以根据他们不同的要求，依靠这些原则参数来调整网络。最后，EfficientNet 给出了 8 个不同的变体，它们具有不同的宽度、深度和分辨率，并且对于小型和大型模型都获得了良好的性能。换句话说，如果你想要高精度，请使用 600x600 和 66M 参数的高效 B7 网络。如果您想要低延迟和较小的型号，请选择 224x224 和 5.3M 参数 EfficientNet-B0。问题解决了。

阅读更多

如果你读完了以上 10 篇论文，你应该对 CNN 图像分类的历史有了很好的了解。如果你喜欢继续学习这个领域，我还列出了一些其他有趣的论文来阅读。虽然没有被列入前十名，但这些论文在各自领域都很有名，并激励了世界上许多其他研究人员。

2014 年:SPPNet

用于视觉识别的深度卷积网络中的空间金字塔池

SPPNet 借鉴了传统计算机视觉特征提取中特征金字塔的思想。这个金字塔形成了一个不同尺度的特征词包，因此可以适应不同的输入大小，摆脱了固定大小的全连通层。这个想法也进一步启发了 DeepLab 的 ASPP 模块，以及用于对象检测的 FPN。

2016 年:DenseNet

密集连接的卷积网络

康奈尔大学的 DenseNet 进一步扩展了 ResNet 的想法。它不仅提供层之间的跳过连接，而且具有来自所有先前层的跳过连接。

2017 年:SENet

压缩和激励网络

例外网络证明了跨通道相关性与空间相关性没有太大关系。然而，作为上届 ImageNet 比赛的冠军，SENet 设计了一个挤压和激励块，并讲述了一个不同的故事。SE 块首先使用全局池将所有通道压缩为更少的通道，应用完全连接的变换，然后使用另一个完全连接的层将它们“激发”回原始数量的通道。所以本质上，FC 层帮助网络学习输入特征图上的注意力。

2017 年:ShuffleNet

ShuffleNet:一个用于移动设备的非常有效的卷积神经网络

ShuffleNet 建立在 MobileNetV2 的反向瓶颈模块之上，它认为深度方向可分离卷积中的点方向卷积牺牲了精度，换取了更少的计算。为了弥补这一点，ShuffleNet 增加了一个额外的频道洗牌操作，以确保逐点卷积不会总是应用于同一个“点”。在 ShuffleNetV2 中，这种信道混洗机制还进一步扩展到了 ResNet 身份映射分支，因此身份特征的一部分也将用于混洗。

2018:锦囊妙计

卷积神经网络用于图像分类的技巧包

锦囊妙计集中在图像分类领域使用的常见技巧。当工程师需要提高基准性能时，它是一个很好的参考。有趣的是，这些技巧，如混合增强和余弦学习率，有时可以实现比新的网络架构更好的改进。

结论

随着 EfficientNet 的发布，ImageNet 分类基准似乎走到了尽头。利用现有的深度学习方法，除非发生另一次范式转变，否则我们永远不会有一天能够在 ImageNet 上达到 99.999%的准确率。因此，研究人员正在积极寻找一些新的领域，如大规模视觉识别的自监督或半监督学习。与此同时，对于工程师和企业家来说，使用现有的方法找到这种不完美技术的实际应用变得更加困难。未来我还会写一份调查，分析那些以图像分类为动力的现实世界计算机视觉应用，敬请期待！如果你认为还有其他重要的论文可以阅读，请在下面留下评论，让我们知道。

原载于http://yanjia . Li2020 年 7 月 31 日**

参考

• Y.Lecun，L. Bottou，Y. Bengio，P. Haffner， 基于梯度的学习应用于文档识别
• Alex Krizhevsky，Ilya Sutskever，Geoffrey E. Hinton， 使用深度卷积神经网络的 ImageNet 分类
• 卡伦·西蒙扬，安德鲁·齐泽曼， 用于大规模图像识别的极深度卷积网络
• 克里斯蒂安·塞格迪、、贾、皮埃尔·塞尔马内、斯科特·里德、德拉戈米尔·安古洛夫、杜米特鲁·尔汉、文森特·万霍克、安德鲁·拉宾诺维奇、
• Sergey Ioffe，Christian Szegedy， 批量归一化:通过减少内部协变量移位加速深度网络训练
• 何、、、、、、 用于图像识别的深度残差学习
• Franç ois Chollet， 例外:深度可分卷积深度学习
• Andrew G. Howard，Menglong Zhu，，Dmitry Kalenichenko，，Tobias Weyand，Marco Andreetto，Hartwig Adam， MobileNets:用于移动视觉应用的高效卷积神经网络
• 巴雷特·佐夫，维贾伊·瓦苏德万，黄邦贤·施伦斯，阔克诉勒， 学习用于可伸缩图像识别的可转移架构
• 谭明兴，郭诉乐， EfficientNet:卷积神经网络模型缩放的再思考
• 何、、、、、， 空间金字塔池深度卷积网络用于视觉识别
• 黄高，刘庄，劳伦斯·范·德·马腾，基利安·q·温伯格，
• 、沈李、萨缪尔·阿尔巴尼、、吴，压缩-激发网络
• 、林、、、 ShuffleNet:一种用于移动设备的极其高效的卷积神经网络
• 佟鹤，，张航，，，谢，卷积神经网络用于图像分类的锦囊妙计

Github 上的 10 个流行数据科学资源

原文：https://towardsdatascience.com/10-popular-data-science-resources-on-github-7ae288ff4a75?source=collection_archive---------22-----------------------

一些顶级的 GitHub 库将教你所有关于数据科学的知识

照片由 Richy Great 在 Unsplash 上拍摄

数据科学领域带来了各种科学工具、流程、算法和从结构化和非结构化数据中提取知识的系统，用于识别其中有意义的模式。

数据科学正在成为本世纪最重要的技术之一。个人和企业惊讶地看到 数据科学在众多领域 中的能力，例如教育、医疗保健、研究、信息技术等等。如果你也渴望学习数据科学，互联网上有很多资源会对你有用。

GitHub 就是这样一个令人惊叹的平台，一个所有软件工程师都聚集的社区。这篇文章背后的目标是让你从我们为你收集的最流行和顶级的 Github 库开始尽可能多地学习数据科学。请继续阅读！

数据科学是让数据变得有用的学科

[## 面向入门级和中级人员的顶级数据科学面试问题和答案

了解数据科学访谈中的最新问题趋势

towardsdatascience.com](/top-data-science-interview-questions-and-answers-for-entry-level-and-mid-level-folks-ce81ad8fa9bb)

Github 上的数据科学资源

称 GitHub 仅仅是一个代码库和协作平台是不公平的，因为它远不止于此。知道 GitHub 的人不多，但是 GitHub 也是最好的地方之一，可以了解大量使用各种编程语言构建的项目，这些语言现在可以用于各种现代用例。在本节中，我们列出了 10 个顶级 GitHub 存储库，它们将教会你所有关于数据科学的知识。

1.数据科学 iPython 笔记本

星星: 19.7k

分叉者: 6.3k

涵盖的主题:深度学习、scikit-learn、Kaggle、大数据、Python 库、Python essentials、AWS 等等。

作者:多恩·马丁

GitHub 链接:https://GitHub . com/donne Martin/data-science-ipython-notebooks

来自脸书的技术负责人 Donne Martin 的数据科学 IPython 笔记本 repo 涵盖了广泛的热门主题和技术工具，如大数据、 机器学习 、业务分析、Python 基础知识以及一些命令行实用程序、 TensorFlow 、 Keras 、熊猫【等

每本 IPython 笔记本都包含关于基础、实现、有用提示的深入信息，以及一些与主题相关的有用练习。其中一些甚至涵盖了更有经验的专业人士的高级主题。我们建议查看回购协议，了解所涉及工具的完整列表。

**** [## 2020 年必读的 Python 书籍

看看吧，你为什么要读它们？

towardsdatascience.com](/python-books-you-must-read-in-2020-a0fc33798bb) [## GitHub 上十大热门 Python 项目

像这样的 GitHub 项目是人们创造力和才华的完美展示

towardsdatascience.com](/top-10-trending-python-projects-on-github-fb852cd58262)

2.开源数据科学大师

星星: 16.3k

分叉者: 5.6k

涵盖的主题:数据分析，Python，R

作者:克莱尔·科特尔

GitHub 链接:https://github.com/datasciencemasters/go

由 数据科学家 Clare Corthell，Luminant 数据科学咨询的创始合伙人之一创建，开源数据科学硕士是一门学习数据科学的开源课程。本课程的源材料本质上是基础性的，面向步入数据科学世界的初学者。

整个课程分为三个部分，包括来自华盛顿大学的介绍性视频、来自哈佛大学的视频和课程材料，以及一本基于数据科学和开源工具的书。

该报告涵盖了基于 Python 的数据科学的一些介绍性主题，如关系代数、统计、图形、可视化、数据争论技术、数据管理、回归、分类和预测分析等等。

熟悉 R 的个人不会被排除在外，因为课程也提供 R 资源。

[## 2020 年数据可视化 10 大 R 库

可视化在数据科学中扮演着重要的角色，因为它们有能力表示…

blog.digitalogy.co](https://blog.digitalogy.co/top-r-libraries-for-data-visualization/)

3.牛逼的数据科学

星星: 14.4k

分叉者: 4.1k

涵盖的主题:什么是数据科学，为什么数据科学，数据集数据科学学院，MOOCs，数据集，播客和博客，书籍，时事通讯。

作者:法蒂赫·阿克蒂尔克，侯赛因·梅尔特&奥斯曼·温古尔，雷杰普·埃罗尔

GitHub 链接:https://github.com/academic/awesome-datascience

发烧友法提赫·阿克图尔克、胡塞因·梅尔特、雷杰普·埃罗尔和奥斯曼·温古尔是这个令人敬畏的数据科学报告的创造者，该报告专门针对数据科学领域的新手。 repo 使用 Python ,由大量资源组成，这些资源分为几个部分，以便于浏览:

●信息图表

●教授数据科学的大学

●海量在线开放课程列表

●用于实践的样本数据集

●数据科学博客作者及其博客列表

●时事通讯、期刊、出版物和杂志

●数据科学播客

●书籍

●各种以数据科学为中心的工具列表

●可视化工具

●少量教程

●以及其他类似超赞系列的链接

4.数据科学家路线图

星星: 3.2k

分叉者: 914

By: MrMimic

GitHub 链接:【https://github.com/MrMimic/data-scientist-roadmap

MrMimic 的 repo 提供了各种关键领域的全面覆盖，以及一系列常用的工作工具，这是精通数据科学所必需的。

这份极有价值的数据科学家路线图归功于 Swami Chandrasekaran ，毕马威(KPMG)的总经理和前 IBM 工程师，他在他的信息图中精心展示了数据科学家必须具备的技能。

地铁地图将每个主题列为一个区域/领域，而车站代表你必须完成该区域的主题。为了方便起见，域根据难度进行编号，从 1 到 10。

Swami Chandrasekaran 的数据科学技能路线图

5.斯坦福 Tensorflow 教程

星星: 9.7k

分叉者: 4.4k

By: 芯片呼延

GitHub 链接:https://github.com/chiphuyen/stanford-tensorflow-tutorials

由斯坦福大学讲师 Chip Huyen 创建，回购是斯坦福大学名为 tensor flow for Deep Learning Research 的课程的部分，包含该课程的代码示例。本报告的内容分为作业和范例，同时还包括课程中使用的工具清单。

代码示例涵盖了使用 TensorFlow 的各种任务，如建模、简单线性和逻辑回归、卷积网络、递归神经网络。学生可以公开使用这个回购，从斯坦福大学最优秀的头脑之一那里了解上述数据科学主题。

6.数据科学博客

星星: 5.3k

分叉者: 1.6k

涵盖主题:数据科学博客列表

作者: Artem Golubin

GitHub 链接:https://github.com/rushter/data-science-blogs

由 Artem Golubin 创建，数据科学博客 repo 充满了互联网上一些信息量最大、写得最好、免费的数据科学博客的链接。收集的内容包括许多知名数据科学从业者、处于创新前沿的企业(如亚马逊)和各种其他网站如KD nuggets的深刻见解。

此回购中列出的博客涵盖了广泛的主题，包括该行业中具有不同技能和经验水平的人的最新动态。如果你使用 RSS 阅读器，你不会失望，因为 repo 中的大多数链接都是 RSS 友好的。

[## 2020 年最佳数据科学博客

最值得信赖和享有盛誉的来源，让您了解数据科学领域的最新动态。

towardsdatascience.com](/best-data-science-blogs-to-follow-in-2020-d03044169eb4)

7.数据科学资源

星星: 2k

分叉者: 995

涵盖的主题:数据科学工具、博客、演示、教程、课程等等。

作者:乔纳森·鲍尔

GitHub 链接:https://github.com/jonathan-bower/DataScienceResources

回购最初是由乔纳森·布鲁尔创建的，作为他获得的所有最好和高质量数据科学资源的一站式来源。通过看到其他人的兴趣，乔纳森公开了回购给每个人。

Jonathan 包含的不仅仅是数据科学中涉及的技术组件。他的 repo 是帮助识别和理解现实世界中涉及的最佳数据科学实践以及它如何解决行业中的实际问题的资源的家园。如果你想深入了解公开的数据科学的实际实施和好处，以及它为你开辟的职业道路，这份报告会非常有帮助。

[## 2020 年必读的数据科学书籍

看看吧，你为什么要读它们？

towardsdatascience.com](/data-science-books-you-must-read-in-2020-1f30daace1cb)

8.数据科学最佳资源

星星: 808

分叉者: 365

涵盖的主题:数据科学博客、书籍、课程、回购、人工智能、Git 和 Github

作者: Tirthajyoti Sarkar

GitHub 链接:https://github.com/tirthajyoti/Data-science-best-resources

由 Tirthajyoti Sarkar 创建的这个策划回购包含了大量非常有用的资源，可供任何有兴趣了解这十年来最热门技术的人使用。回购的创造者已经纳入了来自趋势领域的几个关键主题，如数据科学、 人工智能 、云计算、Web 技术、等等。

除了详细介绍这些主题之外，repo 还附带了各种书籍、文章、视频、MOOCs、编程教程和指南，以补充各种主题，并结构化个人的数据科学学习过程。

9.火花笔记本

星星: 3k

分叉者: 640

安迪·彼得雷拉

GitHub 链接:https://github.com/spark-notebook/spark-notebook

安迪彼得雷拉在 GitHub 上的 Spark Notebook repo 主要面向企业环境，帮助他们的现代数据科学家和数据工程师配备基于网络的编辑器，这些编辑器能够与Scala、[SQL](http://www.sqlcourse.com/intro.html#:~:text=SQL (pronounced "ess-que,for relational database management systems.)查询、标记和JavaScript无缝协作。如此强大的编辑器可以简化处理海量数据的工作，以完成探索、分析和学习相关的任务。

这款笔记本的亮点 包括多火花上下文支持，允许你用一个新的 JVM 运行每个笔记本。它还支持元数据驱动的配置，独家使用 Scala 作为编程语言，并使用动态和反应组件来创建更直观和交互式的可视化。

10.学数据科学

星星: 2.5k

分叉者: 1.6k

涵盖的主题:线性回归、逻辑回归、随机森林和 K 均值聚类

作者:尼廷·博尔万卡

【https://github.com/nborwankar/LearnDataScience】GitHub 链接:

Nitin Borwankar 的 repo 对任何对数据科学感兴趣的人开放，它包含一个以 IPython 笔记本形式的该领域学习材料的精选集合。repo 涵盖了数据科学中的四个主要主题，包括线性回归、逻辑回归、随机森林和 K 均值聚类，以及它们各自的数据集。

每个主题都有自己的 IPython 笔记本，为您提供技术概述、数据探索工具以及从数据集中提取见解的步骤。学习数据科学报告对于那些希望了解数据科学基础知识，同时有现成的实践工具来尝试这些数据探索技术的人来说非常有价值。

[## 面向数据科学的顶级 Python 库

面向数据科学的流行 Python 库概述

towardsdatascience.com](/top-python-libraries-for-data-science-c226dc74999b)

结论

GitHub repos 不仅是现代代码的重要信息源，也是其背后技术的重要信息源。类似于互联网上的其他来源，如社交媒体帐户、参考网站、指南、视频等，GitHub 也值得成为您关于数据科学以及其他趋势技术的可靠和有用的知识来源。

在整篇文章中，我们简要讨论了一些最受欢迎的 GitHub 存储库，用于学习数据科学，这些存储库中的大多数都包含值得浏览的资源，可以帮助您在行业中找到一份声誉好、收入高的工作。如果你正在学习数据科学，我们强烈建议你查看这些回复，我们相信你会找到一些有价值的东西。祝你好运！

注: 为了消除各种各样的问题，我想提醒你一个事实，这篇文章仅代表我想分享的个人观点，你有权不同意它。

如果你有更多的建议或想法，我很乐意倾听。

更多有趣的读物

我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢

[## 面向所有人的顶级谷歌人工智能工具

使用谷歌人工智能中心将想法变为现实

towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## 2020 年你必须使用的最好的 Python IDEs 和代码编辑器

具有显著特性的顶级 Python IDEs 和代码编辑器

towardsdatascience.com](/best-python-ides-and-code-editors-you-must-use-in-2020-2303a53db24) [## 2020 年必读的机器学习书籍

看看吧，你为什么要读它们？

towardsdatascience.com](/machine-learning-books-you-must-read-in-2020-d6e0620b34d7) [## Python vs. Node。JS:哪个最适合你的项目？

使用一组预定义的因素对 Python 和 Node.js 进行详细比较

towardsdatascience.com](/python-vs-node-js-which-one-is-best-for-your-project-e98f2c63f020) [## 数据科学家的最佳数据科学工具

数据科学工具，使任务可以实现

towardsdatascience.com](/best-data-science-tools-for-data-scientists-75be64144a88)

关于作者

克莱尔丁。是Digitalogy—的内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在 上跟我连线Linkedin&Twitter。********

个性化 Jupyter 笔记本需要知道的 11 个实用技巧

原文：https://towardsdatascience.com/10-practical-tips-you-need-to-know-to-personalize-jupyter-notebook-fbd202777e20?source=collection_archive---------5-----------------------

作者图片

定制 JUPYTER

如何使用 CSS 创建优秀的 Jupyter 笔记本用户界面

你是一个使用 Jupyter Notebook 作为你的编译器的 python 程序员吗？如果您想尝试在 Jupyter Notebook 中运行 python 代码的新体验(以下简称；Jupyter)，你可以通过你喜欢的颜色，字体系列来改变和个性化它。你可以应用我推荐的 11 个实用技巧来构建你的 Jupyter 用户界面。

当您打开它时，您可能看到的默认 Jupyter 如图 1 所示。

图一。Jupyter 中的默认主页(左)和 python 页面(右)(图片作者/ Rizky MN )。

在这个故事的结尾，我将把我的 Jupyter 个性化到我的主题中，如图 2 所示。

图二。Jupyter 中的个性化主页(左)和 python 页面(右)(图片作者/ Rizky MN )。

这个故事是将登陆页面应用到 Jupyter 的后续故事。我重用了那个故事中的一些代码，并从罗德里戈·西尔维拉的故事中给了一些额外的 CSS 定制。他使用 CSS 构建独特的 Jupyter 主题。我试着解释我使用的每个 CSS 代码的含义。

要使用 CSS 定制它，您需要检查目录~/中名为 custom.css 的文件。jupyter/custom。如果有，可以给它添加一些 CSS 代码。但是，如果您还没有它，您需要在提到的目录中创建文件。如果目录不可用，您需要创建目录。您可以在图 3 中看到我提到的文件。

图 3。Linux 中 custom.css 的目录(图片作者/ Rizky MN )。

我说的目录是 Linux 的。如果您使用不同的操作系统，您需要找到 Jupyter 的安装目录。对于 Windows 用户来说，我认为它在下面的目录中。

C:\Users\YourUsername\Anaconda3\Lib\site-packages\notebook\static\custom\custom.css

但是，我没有检查过。

01.自定义标题

当您打开 Jupyter 时，您将被定向到默认的 Jupyter 主页， http://localhost:8888/tree。默认主页界面如图 4 所示。

图 4。默认的 Jupyter 主页(图片作者/ Rizky MN )。

要定制 Jupyter 主页的标题，您需要在 custom.css 文件中添加以下代码

#ipython_notebook::before{
 content:"Welcome to my Jupyter Notebook"
}#ipython_notebook img{
 display:none;
}

添加上面的代码后，您需要保存文件并刷新 Jupyter 页面。刷新后的界面如图 5 所示。

图 5。Jupyter 主页的定制标题(图片由作者/ Rizky MN 提供)。

标题页从 Jupyter 徽标更改为“欢迎使用我的 Jupyter 笔记本”您可以通过在 custom.css 文件中写下您想要的标题来自由更改文本。更新后的 custom.css 文件如图 6 所示。

图 6。更新后的 custom.css 文件(图片作者/ Rizky MN )。

02.自定义字体

您可以更改 Jupyter 中使用的字体，包括标题字体、工具栏字体和单元格字体。要更改标题字体，您需要定义您使用的字体，如下面的 CSS 所示

#ipython_notebook::before{
 content:"Welcome to my Jupyter Notebook";
 font-family: Verdana;
 font-weight: 700;
 color: orange;
}

我将标题默认字体改为 Verdana，权重为 700，颜色为橙色。如果您在 custom.css 中添加上面的 CSS，保存它，并刷新 Jupyter 页面，您将看到 Jupyter 的更新界面，如图 7 所示。

图 7。Jupyter 主页的自定义标题字体(图片由作者/ Rizky MN )。

如果你想改变正文中使用的字体，你可以添加这个 CSS

[@import](http://twitter.com/import) url([https://fonts.googleapis.com/css?family=Open+Sans](https://fonts.googleapis.com/css?family=Open+Sans));body{
   font-family: 'Open Sans';
   font-weight: 600;
}

我把正文字体改成 Open Sans。首先，我需要从 font.googleapis.com 进口。您也可以使用与前一个类似的 CSS 来更改权重。更新后的界面如图 8 所示。

图 8。Jupyter 主页的自定义正文字体(图片由 Author / Rizky MN )。

如果你想从一个文件中导入字体，你可以使用这个 CSS

@font-face { font-family: roboto-regular; 
			 src: url('../font/Roboto-Regular.ttf'); }

下面是更改 Jupyter 界面的 CSS，如图 8 所示。

#ipython_notebook::before{
 content:"Welcome to my Jupyter Notebook";
 font-family: Verdana;
 font-weight: 700;
 color: orange;
}#ipython_notebook img{
 display:none;
}[@import](http://twitter.com/import) url([https://fonts.googleapis.com/css?family=Open+Sans](https://fonts.googleapis.com/css?family=Open+Sans));body{
   font-family: 'Open Sans';
   font-weight: 600;
}

我喜欢 Lato 字体，所以我在我的 Jupyter 主题中使用它。我使用 Verdana (serif)使其不同于默认字体(sans-serif)。

03.自定义徽标

您可以用您的徽标更改 Jupyter 的标题。在这个故事中，我将使用我最喜欢的徽标，如图 9 所示。

图 9。我的 logo(图片作者/ Rizky MN )。

要将它应用到 Jupyter 页面中，可以使用这个 CSS

#ipython_notebook img{                                                                                        
    display:block; 
    background: url("logo.png") no-repeat;
    background-size: contain;
    width: 100px;
    height: 30px;
    padding-left: 100px;
    padding-right: 50px;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

我将我的徽标放在 custom.css 的一个类似目录中，因此我声明我的徽标名为 logo.png。您可以更改宽度、高度和其他 CSS 来精确放置您的徽标。结果如图 10 所示。

图 10。为你的 Jupyter 定制的 logo(图片作者/ Rizky MN )。

如果您检查 python 页面，您将看到更新后的界面，如图 11 所示。

图 11。Jupyter 中为您的 python 页面定制的徽标(图片由作者/ Rizky MN )提供。

如果您将所有的字体都改为宽度为 700 的 Verdana 字体，您可以看到不同之处，如图 12 所示。

图 12。在 Jupyter 中为您的 python 页面定制的徽标和字体(图片由作者/ Rizky MN 提供)。

04.自定义标题元素

现在，我们重点讨论如何在 Jupyter 中自定义 Python 页面的界面。我想把 body 元素背景色上面的所有元素都改成和我的 logo 背景色相似的颜色(蓝色，十六进制颜色索引#78abd2)。我用这个 CSS 来改变它

body > #header {
    background: #78abd2;
}

您可以在图 13 中看到结果。

图 13。Jupyter 中定制的 header 元素(图片作者/ Rizky MN )。

接下来是改变导航栏的背景颜色(文件，编辑，查看等。).要改变它，你可以使用下面的 CSS。

#notebook_name {
    font-weight: 500;
    color: white;
}

用上面的 CSS，我把字体颜色改成白色，加粗一些。结果如图 14 所示。

图 14。Jupyter 中定制的 header 元素(图片作者/ Rizky MN )。

然后，我将使用这个 CSS 改变最后一个检查点的字体颜色

.checkpoint_status,
.autosave_status {
    color: white;
}

结果如图 15 所示。

图 15。Jupyter 中定制的 header 元素(图片由 Author / Rizky MN )。

下一步是改变导航栏的背景颜色(文件，编辑，查看等)。要改变它，你可以使用下面的 CSS。

.navbar-default {
    background: none;
    border: none;
}

我去掉了导航栏的背景色，这样它就有了和标题背景色(蓝色)相似的颜色。我还移除了每个导航选项的边框。结果如图 16 所示。

图 16。Jupyter 中的自定义导航栏(图片由作者/ Rizky MN )。

下一步是改变导航栏中的字体颜色，并使用 CSS 添加动画。

.navbar-default .navbar-nav > li > a, #kernel_indicator {
    color: white;
    transition: all 0.25s;
}

结果如图 17 所示。

图 17。Jupyter 中的自定义导航栏(图片由作者/ Rizky MN )提供。

我提到的动画是当你把光标移动到其中一个导航栏选项，比如文件，文件的颜色会变成黑色。

您可以添加的另一个动画是显示选定导航栏的下划线。要添加它，您可以使用这个 CSS

.navbar-default .navbar-nav > li > a:hover, #kernel_indicator:hover{
    border-bottom: 2px solid #fff;
    color: white;
}

结果如图 18 所示。

图 18。Jupyter 中的自定义导航栏(图片由作者/ Rizky MN )。

当我将光标移至“导航”时，动画会在“导航”下方显示下划线。当你点击另一个地方，它就会消失。

05.自定义背景

在我们定制了标题元素之后，我们将定制正文元素。首先，我将把 body 元素的背景色改为白色。要改变它，可以使用这个 CSS。

.notebook_app {
    background: white !important;
}

结果如图 19 所示。

图 19。Jupyter 中定制的身体元素(图片作者/ Rizky MN )。

06.自定义单元格宽度

要改变单元格宽度，可以使用这个 CSS

.container {
    width: 95% !important;
}

结果如图 20 所示。

图 20。Jupyter 中的自定义单元格宽度(图片由作者/ Rizky MN 提供)。

07.自定义单元格之间的边框

接下来是隐藏单元格之间的边界。要隐藏它，您可以使用这个 CSS

div.input_area {
    border: none;
    border-radius: 0;
    background: #f7f7f7;
    line-height: 1.5em;
    margin: 0.5em 0;
    padding: 0;
}#notebook-container{
    box-shadow: none !important;
    background-color: white;
}

结果如图 21 所示。

图 21。Jupyter 中定制的边框单元格(图片作者/ Rizky MN )。

08.向所选单元格添加动画

您可以添加动画，使选定的单元格将被放大，并有阴影效果。要应用它，您可以使用下面的 CSS

div.cell {
    transition: all 0.25s;
    border: none;
    position: relative;
    top: 0;
}div.cell.selected, div.cell.selected.jupyter-soft-selected {
    border: none;
    background: transparent;
    box-shadow: 0 6px 18px #aaa;
    z-index: 10;
    top: -10px;
}

结果如图 22 所示。

图 22。Jupyter 中的自定义细胞动画(图片由作者/ Rizky MN )。

09.自定义输出单元格

默认情况下，输出单元格是左对齐的，如图 23 所示。

图 23。Jupyter 中的默认输出对齐方式(图片由 Author / Rizky MN )。

要改变它，你可以使用这个 CSS

.output {
    align-items: center;
}

结果如图 24 所示。

图 24。Jupyter 中的自定义输出对齐(图片由作者/ Rizky MN 提供)。

10.自定义数据框/表

您可以在 Jupyter 中自定义数据框的背景、对齐方式和填充。默认设置如图 25 所示(输出居中后)。

图 25。Jupyter 中默认的数据框接口(图片由作者/ Rizky MN )。

你可以使用这个 CSS 来定制它。

.dataframe { /* dataframe atau table */
    background: white;
    box-shadow: 0px 1px 2px #bbb;
}.dataframe thead th, .dataframe tbody td {
    text-align: center;
    padding: 1em;
}

我设置背景颜色为白色，右对齐，并调整框阴影和填充。结果如图 26 所示。

图 26。Jupyter 中定制的数据框接口(图片由作者/ Rizky MN )。

11.定制线路盒

最后，如果你想删除行框，你可以使用这个 CSS

div.prompt,
div.tooltiptext pre {
    display:none
}

结果如图 27 所示。

图 27。Jupyter 中定制的 line 单元格(图片由作者/ Rizky MN )。

我没有在我的 Jupyter 上应用这个习惯。我让行单元格可见。如果你喜欢隐藏它，你可以使用上面的 CSS。

结论

最后，我将在下面的 CSS 中分享我的 Jupyter 的 CSS 定制。

下面是捕获的结果。

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

[## 使用 Matplotlib 实现 Python 数据可视化—第 1 部分

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

towardsdatascience.com](/visualizations-with-matplotlib-part-1-c9651008b6b8) [## 使用 Matplotlib 实现 Python 数据可视化—第 2 部分

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

towardsdatascience.com](/python-data-visualization-with-matplotlib-part-2-66f1307d42fb) [## 使用 Matplotlib 可视化数据的 5 个强大技巧

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

towardsdatascience.com](/5-powerful-tricks-to-visualize-your-data-with-matplotlib-16bc33747e05) [## 在 Matplotlib 中自定义多个子情节

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

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

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

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

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

对 21 世纪 30 年代软件发展趋势的 10 个预测

原文：https://towardsdatascience.com/10-predictions-about-the-software-development-trends-in-the-2030s-2fab86c5f661?source=collection_archive---------13-----------------------

从量子计算到字节码:2030 年及以后的主要软件发展趋势

来源:iStock

如果说我们把现代人类文明想象成一辆汽车，那么软件业就是那辆汽车的发动机。在 21 世纪，软件开发行业发生了许多创新、进步和颠覆。尤其是在过去十年中发生的创新和变化的数量是前所未有的。

以下是我们在过去十年目睹的重大变化:

• DevOps
• 持续集成/持续交付
• 集装箱化和虚拟化
• NoSQL，新西兰
• 云
• 微服务，无服务器
• 区块链
• 深度学习
• 数据密集型应用
• 基于 JavaScript 的 Web 开发(Angular，React，Vue)

随着数字化和工业 4.0 的快速发展，我们将在未来十年看到软件开发行业更加巨大的变化和创新。如果我今天进入低温睡眠，2030 年醒来，我将如何找到软件开发生态系统？

预测未来是一项艰难的工作。预测未来十年的软件发展趋势几乎是不可能的。在这里，我将列出 21 世纪 30 年代我们可以期待的十大软件发展趋势。

1.量子计算

来自 Pixabay 的皮特·林弗斯的图片

1982 年，诺贝尔奖物理学家理查德·费曼发表论文，《用计算机模拟物理的 ， ，量子计算诞生。与经典计算机不同，它使用量子力学现象如叠加和量子纠缠进行计算。简单地说，数字计算机的晶体管可以处于一种状态:要么是 0，要么是 1。

但是量子计算机的基本单元，量子位可以处于 0 或 1 的状态，也可以是 0 和 1 的线性组合。因此，量子计算机的能力随着每增加一个量子位而呈指数级增长。量子纠缠是指两个量子比特一旦纠缠，即使一个在地球上，另一个在仙女座星系上，也能瞬间交换信息。如果我们把数字计算机想象成一个普通人，那么量子计算机就像超级智能的外星人，可以同时和数百万人下棋，或者可以同时解决数百万个数学问题。

在过去的十年里，量子计算取得了很多进步。2019 年 10 月，谷歌声称他们已经通过其 54 量子位 Sycamore 量子计算机实现了量子霸权，尽管该消息受到了 IBM 的挑战:

[## 谷歌证实“量子优势”突破

谷歌在科学杂志上发表的一篇新文章中正式宣布，它已经实现了量子霸权

www.theverge.com](https://www.theverge.com/2019/10/23/20928294/google-quantum-supremacy-sycamore-computer-qubit-milestone)

上个月，霍尼韦尔声称已经制造出最强大的量子计算机，量子体积为64:

[## 霍尼韦尔称，它已经建造了世界上最强大的量子计算机

在通往量子计算未来的竞赛中，霍尼韦尔刚刚取得了新的领先优势。总部位于北卡罗来纳州的…

www.forbes.com](https://www.forbes.com/sites/davidjeans/2020/06/19/honeywell-says-it-has-built-the-worlds-most-powerful-quantum-computer/)

量子计算有几个挑战:QPU 需要放入几乎绝对零度的温度，量子计算机由于量子退相干会产生巨大的误差。在未来十年，量子计算将成为大公司最热门的研究课题，世界超级大国将争夺量子霸权。

在 21 世纪 30 年代，量子计算将得到显著发展，工程师将在现实世界中使用它，如量子物理模拟、天气预报、药物开发、金融建模、人工智能、交通优化、星际旅行。它还将成为人工智能等其他领域进步的催化剂。有了量子纠缠，我们终于可以看到分布式计算中 CAP 定理的终结因为量子纠缠粒子可以瞬间共享信息。

在 21 世纪 30 年代初，量子计算将开始威胁经典密码学和相关领域，如金融交易、区块链。因此，随着每个人都试图用量子密码术取代经典密码术，这个行业将会发生巨大的变化和骚动。到 21 世纪 30 年代末，量子计算将最终打破经典密码学，这可能会像维基解密一样引起巨大的社会骚动，因为它将解密许多安全和敏感的通信。

2030 年代将是量子计算的十年。

2.人工智能驱动的软件开发

图片来自pix abayGerd Altmann

2018 年 5 月，桑德尔·皮帅(谷歌首席执行官)发布了基于人工智能的智能功能，用于 Gmail 和谷歌文档。最初，我对它的有用性持怀疑态度。仅仅过了两年，我发现智能写作功能帮助我提高了打字速度，这真是太神奇了。对于软件开发人员来说，也有 AI 驱动的代码完成插件/扩展可用于主要的 ide，如codata 或 Kite 。人工智能驱动的测试生成工具或人工智能驱动的端到端测试工具也越来越受欢迎。

虽然这些人工智能驱动的软件开发工具还不强大，但它们将成为未来几天的热门话题。这些工具的任何改进都会在软件开发中带来巨大的生产力增益。随着未来开源项目数量的指数级增长，人工智能驱动的软件开发工具将拥有更多的训练数据，并且只会越来越好。

在 21 世纪 30 年代，软件开发人员将从各种人工智能驱动的软件开发工具中获得大量支持，如代码完成、测试生成、端到端测试、数据库建模、CI/CD 等。开发人员只需要定义方法名称和字段，人工智能将生成源代码，包括单元/集成/验收测试。此外，开发人员将用简单的英语编写/讲述项目/类的功能，AI 将生成带有 CI/CD 和集成/验收测试的源代码。在 AI 的帮助下，21 世纪 30 年代的开发者体验和开发者生产率将比今天高得多。

3.低代码/无代码

图片来自 Pixabay 的викториябородинова

软件开发人员是目前最稀缺的资源。如果你是一个企业家，有一个伟大的想法，那么你必须首先雇佣一些开发人员来实现你的第一个产品或 MVP。即使你是软件公司的项目经理/产品经理，你仍然需要一个软件开发团队来开发你的 MVP。同样，你必须等待相当长的时间(几个月到一年)才能看到你的 MVP。

在过去的几年里，一个新的运动 L CNC(低代码无代码)正在获得牵引力，它试图减少产品开发的障碍。有许多优秀的 LCNC 应用程序能够在短时间内开发出第一个产品，而不需要任何软件工程师。Bubble、Huddle、Webflow 提供了快速的 Web 应用程序开发。Kodika 提供无代码的 iOS 应用开发。抛物线是一个无代码数据工作流平台，而 Airtable 是 LCNC 数据库和电子表格的混合体。还有一个人工智能/人工智能的 LCNC 平台。

当前的 LCNC 平台要开发高度灵活的行业级应用程序还有很长的路要走。如果我们认为工业级应用程序是乐高头脑风暴，那么当前的 LCNC 应用程序就像乐高得宝。在未来十年，LCNC 平台将会发生巨大的变化。到 21 世纪 30 年代，将会有大量成熟的 LCNC 平台可以创建行业级应用。企业家或企业高管将使用 LCNC 开发 80–90%的消费者应用 MVP。将会有一些强大的人工智能驱动的 LCNC，甚至软件工程师也将使用它们来开始新的应用程序开发。因此，如果你有新鲜的想法，但没有钱或没有编码经验，21 世纪 30 年代将是你的绝佳时机。

4.新编程语言的兴起

由 Max Duzij 在 Unsplash 上拍摄的照片

在 2000 年代，我们认为我们不需要任何新的编程语言。有用于系统编程的 C/C++，用于商业应用的 Java，用于 Web 开发的 PHP/JavaScript，用于脚本的 Ruby/Python。但在接下来的十年里，我们看到了编程语言领域的许多创新和突破。Rust 的成功证明，有了创新的想法，一种新的语言甚至可以挑战强大的编程语言，如 C/C++。同样，Go 也表明了创造一种简单而强大的成功编程语言是可能的。 Swift、TypeScript、Julia、Kotlin、Dart、Elixir、Crystal、Elm 也是最近十年开发的流行且被广泛采用的编程语言。

在未来十年，我们将会看到编程语言领域更多的创新。起源于过去十年的编程语言将会更加流行，而许多其他新的编程语言将会登场。在 2030 年代，编程语言的市场份额将会更加分散，甚至比今天更分散。Rust 将取代 C/C++成为头号系统编程语言，而 T2 将取代 Python 成为人工智能的事实语言。随着人工智能驱动的软件开发和创新工具的出现，多语言编程将成为 21 世纪 30 年代的常态而非例外。

我预计 21 世纪 30 年代，数十种新的云原生编程语言将成为主流。此外，将会有一些更现代的量子计算编程语言。

到 2030 年， WebAssembly 将成为在支持多线程编程模型的 Web 或智能设备上运行的事实上的字节码格式。它将允许使用任何语言编写消费者应用程序(例如，Web、智能设备),充分利用带下划线的硬件(例如，GPU)的优势。因此，像 Rust 这样强大而接近金属的语言将被用于开发游戏、3d、AR/VAR 应用程序或其他针对 Web、智能设备的 CPU 密集型应用程序。此外，在 21 世纪 30 年代，浏览器将成为操作系统，几乎 100%的消费者桌面应用程序将在浏览器上运行。

5.云计算

图片来自 Pixabay

2006 年，亚马逊在云计算领域迈出了巨大的一步，提供了三种 AWS 云服务:EC2、S3 和 SQS。在接下来的 14 年里，云计算变得无孔不入，无处不在。最初，接受云计算的是初创公司。近年来，政府组织、医疗保健、采矿、银行、保险，甚至五角大楼都在向云迁移。新冠肺炎危机向我们展示了公司不仅需要适应云的纵向扩展/横向扩展，还需要适应云的横向扩展。科纳仕公司报告称，2020 年 Q1 的云支出将增长 34%:

[## Q1 2020 年全球云服务市场

2020 年 Q1 的云支出创历史新高，增长 34%，原因是远程工作需求云基础架构服务支出创历史新高…

www.canalys.com](https://www.canalys.com/newsroom/worldwide-cloud-infrastructure-services-Q1-2020)

未来十年，云计算将在软件开发中无处不在。此外，云计算的当前问题(例如，安全性)将在这十年内得到解决。谷歌通过 Cloud Native Foundation 统一云堆栈的尝试将聚集更多的蒸汽，许多云服务将在 2030 年实现标准化。

在 21 世纪 30 年代，云计算(公共/私有/混合)将是软件开发的“正常”方式。此外，内部数据中心将使用“标准化”云堆栈或特定于供应商的云堆栈。

由于量子计算机的物理要求，2030 年代我们将只在云中使用量子计算和量子人工智能。到 21 世纪 30 年代末，量子加密将会成熟，并将为云计算提供一个牢不可破的强大安全机制。不管我们是否喜欢，21 世纪 30 年代的云计算将是集中式的，只有大型科技公司才会像今天一样主导它。

6.人工智能

图片由 Gerd Altmann 从 Pixabay 拍摄

人工智能是计算机科学中最早的学科之一，但在人工智能的冬天面临着几次挫折。在第二个人工智能冬天(上世纪 90 年代)之后，人工智能的第一个重大突破性事件发生在 2012 年，当时谷歌大脑项目中的吴恩达用从 YouTube 视频中拍摄的 1000 万张未分类图片训练了一个 16000 CPU 节点的神经网络，它可以检测一只猫。另一个开创性的事件发生在 2016 年，当时谷歌的 AlphaGo AI 击败了围棋世界冠军，因为围棋可能的棋盘位置比宇宙中的原子总数还要多。

此外，现代硬件(GPU)和云计算推动了人工智能算法，这导致了过去十年中机器学习/深度学习的许多创新。Alexa/Siri、垃圾邮件检测、欺诈检测、自动驾驶、购物推荐、音乐推荐只是我们每天都在使用的庞大 AI 应用中的一小部分。

同样在未来十年，人工智能将出现重大创新和突破，特别是在强化学习方面。AI 将在 2030 年代开始吃掉世界。与普遍的看法相反，人工智能将帮助人类，而不是取代人类。我们将驾驶自动驾驶汽车。医生将使用人工智能进行更好的治疗。生命科学公司将利用人工智能进行更好的药物开发。即使作为开发者，我们也会使用 AI 驱动的操作系统和 AI 驱动的应用程序。

在 21 世纪 30 年代，人工智能将完全可以解释和诠释，不像今天。到那时，人工智能不仅能找到一只猫，还能解释或理解它为什么是一只猫。21 世纪 30 年代量子计算的突破将大大推动人工智能，因为神经网络模型将在量子计算机的帮助下即时训练并使用训练好的模型。我预计我们将看到人工智能奇点，即它将在没有人类帮助的情况下继续以失控的方式改进。

人工智能和量子计算将在 21 世纪 30 年代把人类文明带到下一个阶段(工业 5.0 )。

7.特定领域的硬件

图片来自 Pixabay

如果说我们从过去十年的软件开发行业中学到了什么，那就是“一刀切”但在硬件开发上，还是“一刀切”。今天的软件应用程序变化如此之大，以至于在许多情况下，专用硬件可以比通用硬件提供显著的优势。在过去几年中，有几个成功的特定领域硬件开发的例子。比特币挖矿有专门的硬件可以更高效地计算 SHA。谷歌开发了一个专门的 GPU (TPU) 为运行 TensorFlow 而优化。另一个非常成功的专业硬件是 Amazon AWS Nitro，这是一个用于容器化/虚拟化的专业硬件，在他们的无服务器 EC2 平台上为 Amazon 提供了很大的帮助。

在下一个十年，我们将会看到越来越多的专用计算硬件。2030 年代将会出现大量的专用硬件:数据库专用硬件、AI 专用硬件、数据处理专用硬件等等。目前，硬件开发类似于 2010 年之前的软件开发，导致发布周期较长。在 21 世纪 30 年代，硬件开发将结合软件开发的许多最佳实践。它将在跨职能团队中使用敏捷方法，硬件工程师将与特定领域的软件工程一起工作。因此，硬件发布周期将会更短，这反过来将会产生更多特定领域的硬件。

8.分布式 SQL

图片由皮克斯拜的 Gerd Altmann 提供

目前，我们面临着两个数据库的问题。根据 CAP 定理，对于分布式系统/分布式数据库，我们只能拥有 CAP 中的任意两个(一致性、可用性、分区容忍)。对于一致性是基本要求的应用程序(例如，银行、保险和大多数其他业务应用程序)，我们使用 SQL 数据库(OLTP)，它提供 CAP 的 CA。对于高度可扩展的应用程序，可用性是一致性的关键要求(例如，分析工作负载、社交媒体类工作负载)，我们使用各种 NoSQL 数据库(OLAP)。将数据从 OLTP 移动到 OLAP 需要大量的工作。此外，SQL 数据库为数据(SQL)提供了单一的抽象层，而 NoSQL 不提供任何单一的抽象层。

在过去的几年里，我们已经看到了分布式 SQL (NewSQL) 数据库的兴起，它结合了 SQL 的一致性和 NoSQL 数据库的可伸缩性。虽然它们中的许多(蟑螂 DB，AWS Aurora)正在获得大量的牵引力，但仍有改进的空间。在下一个十年，我们将在分布式 SQL 领域看到更多的创新。

在 21 世纪 30 年代，我们可以看到真正的分布式 SQL，因为许多其他领域的创新(例如，专用硬件、量子计算)。一个想法可能是“量子纠缠 SQL 数据库，”其中量子纠缠 SQL 数据库的集群将提供 SQL 数据库的一致性，即使一个数据库在地球上，而另一个数据库在火星上。

9.统一的数据密集型应用

来自 Pixabay 的 David Mark 的图片

在过去的十年中，我们看到了数据密集型应用的爆炸式增长。我们有批处理工具(Spark，Hadoop Map Reduce)，流处理工具(Flink，Strom)，排队(Kafka，Pulsar)，全文搜索工具(Solr，Elastic Search)，缓存(Redis)，列存储(Cassandra)，行存储(SQL 数据库)。缺点是现在没有类似 SQL 的数据处理抽象。目前，为特定的数据建模寻找合适的数据密集型工具是一项艰巨的任务。

在未来十年，我们将看到许多数据处理工具的融合，它们将为批处理和流处理提供统一的数据建模。在 21 世纪 30 年代，我们将发现数据密集型应用程序更少分散，更统一。我们还将看到在同一数据处理框架中抽象许多数据建模(例如，流、全文搜索、缓存、列操作、行操作)的工具。此外，我们将看到数据密集型应用程序更加可组合(如 Unix ),这样我们就可以轻松地插入多个应用程序。在 21 世纪 30 年代，开发人员将通过一个类似“管道”的操作符将分布式 SQL 数据库与全文搜索引擎连接起来。

10.区块链

图片由 mmi9 来自 Pixabay

绝望的时代往往会带来颠覆性的创新。2007 年全球金融危机期间，T5， 结合 5/6 现有技术(哈希、hashcash、公私密码、点对点网络)，创造了比特币，第一种加密货币。比特币的成功带动了新技术的兴起:区块链或者分布式账本。在过去十年中，区块链技术取得了许多进步，并为在非加密货币用例中使用区块链打开了大门。一个这样的创新是以太坊，其中一个块是一段代码。以太坊的优势在于这段代码是通用的，即智能合约，可以映射到包括加密货币在内的任何东西。

尽管区块链是一项颠覆性技术，但它有许多限制，阻碍了它的大规模采用。在未来十年，我们将看到区块链的许多创新，它的许多限制将得到解决。在 21 世纪 30 年代，区块链将是成熟的技术。会用在很多领域，以合同/交易为基础，集中化:金融交易、房地产合同、油气采购、供应链、版权、分享音乐。在 21 世纪 30 年代，量子计算将开始威胁经典加密。由于传统加密是区块链的关键，它将在 21 世纪 30 年代经历重大变化，并将适应量子加密。

类似文章:

[## 2020 年最受欢迎的 10 种编程语言

针对求职者和新开发人员的顶级编程语言的深入分析和排名

towardsdatascience.com](/top-10-in-demand-programming-languages-to-learn-in-2020-4462eb7d8d3e) [## 有效的微服务:10 个最佳实践

正确实施微服务架构的 10 个技巧

towardsdatascience.com](/effective-microservices-10-best-practices-c6e4ba0c6ee2) [## 2020 年要学习的十大 JavaScript 框架

现代 JavaScript 开发中最重要的 JavaScript 框架的精选列表

towardsdatascience.com](/top-10-javascript-frameworks-to-learn-in-2020-a0b83ed3211b)

实用统计推理的 10 个原则

原文：https://towardsdatascience.com/10-principles-of-practical-statistical-reasoning-3071d360d255?source=collection_archive---------33-----------------------

安德烈亚斯·布吕克尔在 Unsplash 上的照片

卓有成效地应用统计学(数据科学)有两个核心方面:

1. 领域知识。
2. 统计方法。

由于这一领域的高度特殊性，任何一本书或文章都很难对两者之间的相互作用进行详细而准确的描述。一般来说，人们可以阅读两种类型的材料:

1. 关于统计方法的广泛信息，带有概括但不具体的结论。
2. 详细的统计方法，其结论只在特定领域有用。

在我自己的数据科学项目上工作了 3 年，在交易大厅操纵数据 3 年半之后，我学到了另外一类知识。它基本上和上面一样有用，我把它们带到了的每个项目/兼职/咨询工作中…

实用统计推理

我创造了这个术语，因为我真的不知道该如何称呼这个类别。但是，它涵盖了:

• 应用统计学/数据科学的性质和目标。
• 所有应用的通用原则
• 获得更好结论的实用步骤/问题

如果你有应用统计方法的经验，我鼓励你用你的经验来阐明和批评下面的原则。如果您从未尝试过实现统计模型，请尝试一下，然后再回来。不要把下面的内容看成是需要记忆的清单。如果你能联系自己的经历，你会得到信息的最高综合。

以下原则帮助我提高了分析的效率，并使我的结论更加清晰。我希望你也能从中发现价值。

1 —数据质量问题

通过更精细的分析可以纠正差的数据质量的程度是有限的。值得完成的实际检查有:

• 对逻辑上不一致或与每个变量可能产生的范围的先验信息相冲突的值进行视觉/自动检查。例如极值、变量类型。
• 分布频率。
• 两两散点图用于共线性的低水平检验。
• 缺失观察值(0，99，无，NaN 值)。
• 质疑由不一致(如观察者之间的差异)引入的偏倚的收集方法。

2 —批评变异

在几乎所有的问题中，你都将面对不受控制的变化。对于这种变化的态度应该是不同的，这取决于这种可变性是被研究系统的固有部分还是代表实验误差。在这两种情况下，我们考虑变异的分布，但动机不同:

• 内在变异:我们对分布形式的细节感兴趣。
• 误差变化:我们感兴趣的是，如果误差被消除，会观察到什么。

3 —选择合理的分析深度

尝试独立于可用的数据量或可用的技术来考虑深度。仅仅因为收集数据容易/便宜，并不意味着数据是相关的。这同样适用于方法和技术。精心选择的分析深度支持清晰的结论，而清晰的结论支持更好的决策。

4 —理解数据结构

数据量涉及个体数量和每个个体的变量数量。数据结构=数据量+个体分组。大多数数据集具有以下形式:

• 有很多人。
• 在每个个体上，观察到许多变量。
• 个人被认为是相互独立的。

鉴于这种形式，回答下面的问题将缩短有意义的结论解释的路径。

• 什么才算是个体？
• 个人是否以必须纳入分析的方式分组/关联？
• 对每个人测量哪些变量？
• 是否有任何观测数据丢失？可以做些什么来替换/估计这些值？

注意:小数据集允许容易地检查数据结构，而大数据集可能只允许结构的小部分分析。把这个因素考虑到你的分析中，需要多长时间就多长时间。

统计分析的 5 — 4 个阶段

1. 初始数据操作。 意图=对数据质量、结构和数量进行检查，并以表格形式汇总数据进行详细分析。
2. 初步分析。意图=阐明数据的形式，并建议最终分析的方向(图、表)。
3. 权威分析。意图=为结论提供依据。
4. 结论陈述。意图=准确、简洁、清晰的结论和领域解释。

…但是这些阶段有一些注意事项:

• 阶段划分是有用的，但并不严格。初步分析可能会得出明确的结论，而最终分析可能会揭示出人意料的差异，需要重新考虑整个分析基础。
• 当给定一个干净的数据集时，跳过 1。
• 在有大量现有分析的字段中跳过第 2 步。

产量是多少？

记住，统计分析只是更大的决策过程中的一个步骤。向决策者展示结论对于任何分析的有效性至关重要:

• 结论风格要看受众。
• 以一种对批判性的非技术读者来说合理的形式解释广泛的分析策略。
• 包括结论和数据之间的直接联系。
• 用简单的方式展示复杂的分析是值得的。然而，要知道简单是主观的，与熟悉程度相关。

7 —合适的分析风格

从技术角度来看，分析风格指的是如何对感兴趣的底层系统进行建模:

• 概率/推理:得出不确定的结论，通常是数字。
• 描述性:试图总结数据，通常是图形。

适当的分析风格有助于保持重点。尽早考虑它，这将减少返回到耗时的数据处理步骤的需要。

8 —计算方面的考虑有时只是一个问题

技术的选择渗透到应用统计分析的各个方面，包括:

• 原始数据的组织和存储。
• 结论的排列。
• 主要分析的实施。

但是这应该在什么时候引起注意呢？

• 大规模调查+大数据 =如果通过现有工具无法实现灵活性和性能，则值得投入资源来定制程序/库。
• 大规模调查+小数据 =计算考虑不重要。
• 小规模调查+大数据 =定制程序不可行，灵活通用程序/库的可用性至关重要。
• 小规模调查+小数据 =计算考虑不重要。

9 —设计调查井

同时一系列的统计方法可以用于一系列的调查类型。结果的解释将根据调查设计而有所不同；

• 实验 =研究中的系统由研究者建立和控制。明显的差异可以理直气壮地归因于变量。
• 观察性研究 =除了监测数据质量之外，研究者无法控制数据收集。真正的解释变量可能会丢失，很难有把握地得出结论。
• 抽样调查 =在研究者的控制下，通过方法(随机)从人群中抽取样本。尽管解释变量如上所述受到影响，但仍可对人口的描述性特征得出有把握的结论。
• 受控前瞻性研究 =研究者选择的样本，测量并随时间推移跟踪的解释变量。实验有一些优点，但在现实中，不可能测量所有的解释变量。
• 受控回顾性研究 =对解释变量进行适当处理的现有数据集。

注:调查设计的一个重要方面是区分响应和解释变量。

10 —调查目的

显然调查的目的很重要。但是你应该如何考虑目的呢？

第一，目标的一般质量区别:

• 说明:增加理解。在合身的模特中任意挑选是危险的。
• 预测:初级实际使用。易于在合身的模型中任意挑选。

调查的具体目的可能表明，分析应该集中在所研究系统的某个特定方面。它还影响到要寻求的结论的种类和结论的表述方式。

目的可能决定结论的失效日期。如果观察到变量之间相互关系的变化，任何完全基于经验的模型都是有风险的。

一锤定音

生活中几乎所有的任务都可以从框架中考虑:

输入->系统->输出

接下来的工作就是定义框架的每个方面。

实用的统计推理针对的是“系统”。系统的某些部分不能脱离上下文来确定。有些部分可以。实用的统计推理实际上就是简单而胜任地定义你的“系统”的能力。那种能力绝对不局限于这些原则。

如果你想看编程/数据科学方面的构建，请查看我的 YouTube 频道 ，我在那里发布了 python 的完整构建。

我们的目标是激励和合作，所以伸出援手吧！

实践几乎所有 SQL 概念的 10 大问题

原文：https://towardsdatascience.com/10-problems-to-practice-almost-all-sql-concepts-37545e7c5219?source=collection_archive---------2-----------------------

涵盖连接、聚合、窗口函数和子查询的所有 SQL 概念

图片由 Unsplash 上的 Alexandru Acea 拍摄

介绍

我最近在 Leetcode 上用 25 天的时间完成了所有 117 个 SQL 问题，leet code 可能是最受欢迎的练习各种编程语言编码技能的网站之一。该网站将所有问题漂亮地分为三类，即简单、中等和困难，其中难度随着每个后续级别的提高而大幅提高。完成所有这些问题后，我决定突出 10 个问题，它们几乎涵盖了从基础到高级 SQL 的所有概念，您可以通过练习来提高 SQL 编程技能。此外，几乎所有大型科技公司都在面试中问过这些问题。

以下是每个问题中测试的 SQL 技能的明细:

• Q1 平均工资: CTE ，聚集在窗口函数中，CASE WHEN，DATE_PART、INNER JOIN 等日期函数
• Q2 在结果中找到安静的学生— 子查询，最小值，最大值，窗口函数，窗口别名，内部连接，所有关键字
• Q3 体育场人流量— 左连接子查询，CTE，行号
• Q4 每次访问的事务数量— 递归 CTE、联合、计数
• Q5 报告连续日期(MySQL)——日期子，行数
• Q6 按周销售— 数据透视表，CASE WHEN
• Q7 部门前 3 名薪资— DENSE_RANK
• Q8 餐厅增长— 移动平均线前置，偏置
• Q9 平面内最短距离— 交叉连接、SQRT、POW
• Q10 连续数字— 滞后，超前

所以，我们言归正传吧！

1. 给定下面两张表，写一个查询，显示某部门员工平均工资与公司平均工资的比较结果(高/低/相同)。

方案一:

2。 写一个 SQL 查询，报告学生(student_id，student_name)在所有考试中“安静”的情况。“相当”的学生是指至少参加了一次考试，既没有高分也没有低分的学生。

方案二 :

3。编写一个查询来显示连续 3 行或
多行且人数超过 100(含)的记录。

方案三:

4。编写一个 SQL 查询来查找有多少用户访问了银行但没有进行任何交易，有多少用户访问了银行并进行一次交易等等。

方案四:

5。编写 SQL 查询，为 2019 年 1 月 1 日至 2019 年 12 月 31 日期间的每个连续天数间隔生成 period_state 报告。

方案五:

66。编写一个 SQL 查询来报告一周中每天每个类别中订购了多少台。

方案六:

7。编写一个 SQL 查询来查找每个部门中工资最高的三名员工。对于上面的表，您的 SQL 查询应该返回下面的行(行的顺序无关紧要)。

解决方案 7:

8。编写一个 SQL 查询来计算 7 天内(当天+ 6 天前)客户支付金额的移动平均值。

解决方案 8:

9。编写一个查询，找出这些点之间的最短距离，四舍五入到 2 位小数。

解决方案 9:

10。编写一个 SQL 查询来查找至少连续出现三次的所有数字。

方案 10:

这是一个总结！我希望您喜欢这些问题，并且能够实践一些最重要的 SQL 概念。如果你想练习更多像这样的问题，请随时到我的Github页面，我已经上传了所有 117 个解决方案。

谢谢大家！

如果你喜欢我的作品，请在不久的将来跟随我在媒体上阅读更多的文章。

• 阅读我关于特征工程 & 自动化基础数据分析的其他文章。
• 很乐意在 LinkedIn 上与您联系。

驯服无数电子表格的 10 个编程概念

原文：https://towardsdatascience.com/10-programming-concepts-to-design-a-spreadsheet-system-around-9ab3f6704d06?source=collection_archive---------42-----------------------

如何将你的一群电子表格从猫变成羊

制造者在 Unsplash 上 NESA 的照片

F 在工作中，我不时会听到同事们谈论找不到电子表格或忘记更新电子表格，因此信息错位，耗费他们的时间和精力来重做一切。

尽管电子表格对于业务用户创建数据驱动的流程(例如，可视化的数据操作、BI 报告和某种程度的自动化)的门槛很低，但它们也很快滋生了孤岛，因为每个人都有自己版本的相同流程。

当然，没有人喜欢“伟大的电子表格”，那么我们如何在他们成为我们最大的敌人之前和他们交朋友呢？

虽然我的上一篇文章给出了一个理想化的案例研究，介绍了一家公司如何更容易地从使用电子表格过渡到使用 SQL 进行快速查询和报告周转，但 SQL 并不是最终答案。业务涉众必须定义一组电子表格解决的确切的业务问题以及它们收集的数据类型。

尽管 Knox 很好地强调了滞后指标和领先指标的区别，但我想补充的是，在探索更多领先指标之前，滞后指标的报告应该是高质量的。如果一份关于月收入、运营成本或客户订阅的报告来自多个电子表格，你将会把时间花在困惑和对数字进行质量评估上，而不是探索可能影响它们的领先指标。

一旦为滞后指标建立了报告渠道，并且有少数领先指标显示出影响滞后指标的有希望的结果，这就是数据产品的开始。

不管将来它是否会被重构为 BI 工具或软件解决方案，已经设计了 一个复杂的电子表格系统正在为一个成熟的数据产品 做原型。

事不宜迟，让我们来看看这 10 个从软件开发中借鉴来的概念，电子表格用户可以将它们添加到他们的技术技能工具箱中，并提高他们在“处理表格”中的生产率。

萨姆·丹·张在 Unsplash 上的照片

1.整理资产

用户如何识别数据集中的唯一记录？还记得当查找值依赖于多个字段时需要执行的串联吗？在 RDBMS 世界中，这些串联字段被视为“候选键，或者在不同的上下文中也被称为“自然键，因为它们是原始数据集的一部分，并且是最好不要由公式创建的独立变量。虽然使用自然键便于人们阅读和直观理解，但是使用它们有两个缺点。首先，如果业务逻辑发生变化，键的数量或一个键的含义也可能发生变化。其次，随着键的数量和/或这些键的潜在值的增加，它降低了电子表格的性能。因此，使用指定的惟一标识符(类似于 CAT-PRODUCT-1)跟踪自然键(每次真正有新记录时递增 1)是一种经得起未来考验的权衡，既保留了不断发展的业务逻辑，又实现了使用单个标识符(然后成为主键)而不使用纯整数代理键的优雅。

2.数据类型

请注意公式如何抛出“#VALUE！”当你试图用文本除一个数时出错，你希望早点知道这个愚蠢的问题？许多公式是特定于类型的，因此理解值的数据类型确实有助于调试错误和清除数据，例如 2 而不是“2”或 07/20/2020 22:35 而不是 1595284509。有一些常见的数据类型如字符串、整数、浮点、日期时间和布尔。人们也可以将数据类型视为计算机的记账系统，因为计算机内的资源是有限的。Integer 比 float 占用的内存空间少，boolean 占用的空间最少，只有两个可能的值，0 和 1。转换一个字段的数据类型就相当于告诉计算机你愿意给它分配多少空间，所以当一个对象占用了过多的空间时，性能可以得到调整。

3.属性与价值

或者电子表格行话中的列对行。如果你说这两种语言中的任何一种，你都知道我在说什么，这是有区别的。许多用户根据他们当时正在开发的报告任意地确定这一点。虽然财务报表需要“一月”、“二月”、“三月”都是它们自己的列，但是提供给报表的原始数据可能不需要，所以您需要一个名为“月”的属性以及“一月”、“二月”、“三月”的值。在数据处理的不同阶段区分这两者与您的报告流程的简化程度有关，也是下一个指针中“整洁数据”的基石之一。

4.整洁的数据(英尺。宽或长的桌子)

许多用户花费大量的时间和精力来开发和维护一个丰富多彩的 Excel 报表，它通常看起来非常宽，尤其是财务报表。如果这些报告不是“中间”数据，仍然需要被操作来生成另一个报告，那么它们是非常好的。经理们也喜欢这种视图，因为它们看起来像数据透视表。另一方面，对于分析师来说，创建一个 fork 过程是至关重要的，其中一个过程导致一个“宽表”报告，另一个导致一个“长表”。一个规范化的长表就是 t idy 数据(源自一个名为 tidyr 的 R 包)的样子。这种格式最适合分析和可视化。

5.数据字典或映射

有些价值观的组合根本没有意义，但是你如何在一开始就防止它们发生呢？在 Excel 中，无所不能的间接函数会帮你完成繁重的工作。只要您的公式是正确的，您将只看到根据其他值进行选择的有意义的值。但是即使是间接的也需要一个“地图”来知道哪些对是有效的。开始一个全新的选项卡并键入可能的组合很有诱惑力，但是等等，一个不太冗余的方法是将这些映射都放在一个共享目录中。这样，每个人都引用相同的内容，并避免手动创建可能与原始副本略有不同的冗余选项卡。

托尼·赫斯特在谷歌电子表格中的数据验证

6.数据有效性

数据验证通常不被重视，直到人们意识到“他们应该(或可能)在字段上设置一个简单的约束，这样至少当一个无效值出现时，它会对你怒目而视。为了补充这一点，利用数据字典来建议可能的值，而不是等待无效的值，特别是对于有类别的文本。此外，条件格式也是一个很好的工具，可以用来验证还没有任何“绑定”的数据。尤其是当您还不熟悉收集到的值时，使用条件格式会立即用突出显示的颜色突出重复或异常值。

7.结构化目录

也许这与一个人的组织技能有关，而不是操作电子表格的技术能力，但是即使在软件工程中，文件的位置对模块化应用程序的功能也有重要影响。通常，更频繁使用的对象会更靠近根文件夹(第一层)，而更具体使用的对象会有自己专用的子文件夹。如果文件是以这种方式组织的，而不是按照个人偏好或特定部门的逻辑，那么它不仅可以方便任何人的文件导航，还可以激励未来的开发人员基于现有系统设计软件解决方案。

8.公式与脚本

随着职业生涯的进一步发展，许多经验丰富的分析专家会发现自己至少是半个程序员。这是因为他们已经能够流利地编写公式，甚至是支持电子表格软件的脚本语言(Excel 的 VBA 和 Google Sheet 的 Google Apps 脚本)。虽然这是开始自动化手动工作的一个很好的地方，但人们应该将前面的要点纳入整体考虑，因为在 8 个电子表格中编写 8 个 Vlookup 也是手动的，并且不可伸缩。通常情况下，如果电子表格变慢了，或者调试脚本变得困难了，这就是分解或简化它试图执行的任务的信号。

9.用户输入表单

永远不要相信你的用户。这是很多人宣扬的，我再补充一条:也永远不要相信自己。如果您是输入数据或为其他人输入数据创建空间的人，最好不要让数据生成者看到基础表，尤其是当它还包含数据生成者不直接输入的数据时。数据生产者应该只关注需要他们输入的字段，这些字段应该有护栏，如不允许的值和/或必填字段。在这种情况下，表单会派上用场，为了进一步降低出现错误数据的可能性，可以使用下拉菜单(如果只有某些允许的值，请记住利用第 5 点中的数据映射！)和自动完成。

10.机器生成的值

如果我不得不相信其中一个，我会选择机器生成的值而不是用户输入的值。这应该有自己的一个小部分，因为利用机器为您生成/转换/推导值本身就是过程标准化和自动化的一个里程碑。还记得那些极其相似的电子邮件吗？它们的附件都是你应该关心的发票或明细表格。不要一个一个地打开，然后手动将它们转录到电子表格中。接入 API。自动化数据提取。如果有根据用户输入填充的日期时间字段，则在公式检测到用户输入时为他们填写，而不是要求他们填写。只要有替代用户输入的方法，就要考虑自动收集数据。

虽然我同意基于文件的系统所能提供的是有限的，但电子表格仍然被证明是业务人员和技术人员都理解的灵活、低预算的入门工具。我经常发现，从长远来看，应用更多的编程概念有助于分析专家帮助企业更好地控制他们的数据。

想象一下，买一个最新型号的吸尘器，它还可以拖地，如果你没有养成清理和清理吸尘器路径的习惯，它就不会得到很好的利用。聘请顾问或为软件解决方案付费是没有问题的，但如果电子表格用户继续在分散的手动电子表格上运行关键业务流程，这些就没有什么意义了。

决策者在顾问或软件解决方案上花费大量金钱，希望这些能清除他们低效的流程，当归结为一个更好的深思熟虑的(和记录在案的)业务流程和一个更有组织的电子表格系统。

有太多的时候，我看到耸人听闻的文章标题炒作电子表格或 SQL 是否已经“到达其终点”，而事实上，每个人仍然非常依赖它。鉴于大多数企业的资源和知识有限，利用电子表格作为数据产品原型的起点，比眼睁睁地看着一个“遗留”的优秀电子表格不断增长，直到下一个最佳解决方案出现，要实用和高效得多。

特别感谢我的作品萌芽、 安倍列车 ，是他们给了我写作的灵感，并对本文进行了反馈。

用于即席文本分析的 10 个纯 Python 函数

原文：https://towardsdatascience.com/10-pure-python-functions-for-ad-hoc-text-analysis-e23dd4b1508a?source=collection_archive---------36-----------------------

不使用外部库压缩文本数据

克里斯多夫·伯恩斯在 Unsplash 上拍摄的照片

Text*data是最常见的数据格式。大量的文章、推文、文档、书籍等等，每天都在我们周围飞来飞去。您可以提取的见解数量巨大，帮助提取这些见解的工具也在不断改进。*

在 Python 中，可以使用外部库来处理文本数据。这些库的一个问题是它们不是轻量级的，而且对于初学者来说，它们确实有一个陡峭的学习曲线。在许多情况下，如果您的唯一目的是探索和了解数据，用纯 Python 编写的函数可以做得很好。

下面我列出了 10 个我最常用的功能。这些功能主要是启发式功能，在假设条件下正常工作。这些假设在以下考虑它们的功能中陈述。

#1 获取句子

假设:凡是以点、问号、感叹号结尾的，都作为一个句子。

#2 获取每句话的条目列表

假设:取一个冒号，后跟用逗号分隔的项目列表。

#3 获取所有数值

假设:所有数字都被考虑，不管它们是字符串的一部分还是独立的。

#4 获取引号内的文本

假设:介于引号之间的内容将被采用。

#5 获取大写单词

假设:取全大写中的任意一个字。

#6 获取单词的上下文

#7 获取句子中的结果标题词

假设:取句子中的后件标题词。

#8 获取括号内的文本

假设:取圆括号、方括号或大括号之间的内容。

#9 去掉标点符号

#10 描述文本

结论

在处理和分析过程中，文本数据伴随着巨大的洞察机遇和挑战。有很多用于语言处理的外部库，比如 NLTK 、 spaCy 和 polyglot 。如果你想在 NLP 中做一些严肃的事情，这些工具是你应该使用的。

这些库的一个问题是它们相当重。当然，他们必须用不同的结构组织支持不同的语言，这是主要原因。如果您只是想研究和提取文本数据的统计数据，带有内置模块的 Python 可以做得很好。

上面列出的 10 个 Python 函数为此提供了一个良好的开端。使用这些函数来探索和了解数据。这些不是生产就绪的脚本。明智地使用它们，并根据需要扩展它们的功能。编码快乐！

* [## 提升你的软件开发职业生涯的三件大事

从优秀到卓越

medium.com](https://medium.com/swlh/three-significant-things-to-elevate-your-software-development-career-83be99cedf28) [## 作为一名开发人员，赢得尊重的 4 件事

迈向成功的事业

medium.com](https://medium.com/@dardanx/4-things-that-will-earn-you-respect-as-a-developer-eec54d1ac189)*

每个数据科学家都应该知道的 10 个 Python 内置函数

原文：https://towardsdatascience.com/10-python-built-in-functions-every-data-scientist-should-know-233b302abc05?source=collection_archive---------14-----------------------

用例子和用例解释

斯蒂芬·亨宁在 Unsplash 上的照片

Python 是许多数据科学家和分析师的首选编程语言。这样选择的原因之一是 python 相对更容易学习和使用。更重要的是，有各种各样的第三方库可以简化数据科学领域的许多任务。例如， numpy 和 pandas 就是很好的数据分析库。 Scikit-learn 和 tensorflow 用于机器学习和数据预处理任务。我们还有 python 数据可视化库，如 matplotlib 和 seaborn 。python 生态系统中还有很多更有用的数据科学库。

在这篇文章中，我们不会谈论这些库或框架。我们更愿意讨论 python 的重要内置函数。这些函数中的一些也在我们提到的库中使用。没有必要重新发明轮子。

我们开始吧。

1。设置

Set 函数从 iterable(如列表)中返回一个 set 对象。集合是唯一值的无序序列。因此，与列表不同，集合没有重复的值。集合的一个用例是从列表或元组中删除重复值。让我们看一个例子。

list_a = [1,8,5,3,3,4,4,4,5,6]
set_a = set(list_a)
print(list_a)
print(set_a)
[1, 8, 5, 3, 3, 4, 4, 4, 5, 6]
{1, 3, 4, 5, 6, 8}

如您所见，重复项被删除，值被排序。集合是不可订阅的(因为没有保持顺序),所以我们不能访问或修改集合中的单个元素。然而，我们可以向集合中添加元素T21 或者从集合中移除元素。

set_a.add(15)
print(set_a)
{1, 3, 4, 5, 6, 8, 15}

2。枚举

使用 iterables 时，Enumerate 提供计数。它可以放在 for 循环中，也可以直接用在 iterable 上来创建枚举对象。枚举对象基本上是一个元组列表。

cities = ['Houston', 'Rome', 'Berlin', 'Madrid']
print(list(enumerate(cities)))
[(0, 'Houston'), (1, 'Rome'), (2, 'Berlin'), (3, 'Madrid')]

与 for 循环一起使用:

for count, city in enumerate(cities):
   print(count, city)0 Houston
1 Rome
2 Berlin
3 Madrid

3。Isinstance

Isinstance 函数用于检查或比较对象的类别。它接受一个对象和一个类作为参数，如果该对象是该类的实例，则返回 True。

a = [1,4,3,5,5,7]
b = set(a)
print(isinstance(a, list))
print(isinstance(b, list))
True
False

我们可以使用 type 函数来访问一个对象的类，但是在进行比较时，isinstance 就在手边。

4。Len

Len 函数返回对象的长度或对象中的项数。例如，len 可用于检查:

• 字符串中的字符数
• 列表中元素的数量
• 数据帧中的行数

a = [1,4,3,5,5,7]
b = set(a)
c = 'Data science'print(f'The length of a is {len(a)}')
print(f'The length of b is {len(b)}')
print(f'The length of c is {len(c)}')The length of a is 6
The length of b is 5
The length of c is 12

5。已排序

顾名思义，sorted 函数用于对 iterable 进行排序。默认情况下，按升序排序，但可以用反转参数改变。

a = [1,4,3,2,8]print(sorted(a))
print(sorted(a, reverse=True))[1, 2, 3, 4, 8]
[8, 4, 3, 2, 1]

在做数据清理和处理时，我们可能需要对一个列表或熊猫系列进行排序。Sorted 也可以用来对字符串中的字符进行排序，但它返回的是一个列表。

c = "science"
print(sorted(c))
['c', 'c', 'e', 'e', 'i', 'n', 's']

6。Zip

Zip 函数以 iterables 作为参数，返回一个由元组组成的迭代器。假设我们有两个关联列表。

a = [1,3,2,4]
b = ['Rome','Houston','Madrid','Berlin']print(list(zip(a,b)))
[(1, 'Rome'), (3, 'Houston'), (2, 'Madrid'), (4, 'Berlin')]

可重复项不必具有相同的长度。第一个匹配的索引被压缩。例如，在上面的例子中，如果列表 a 是[1，3，2，4，5]，输出将是相同的。Zip 函数也可以接受两个以上的 iterables。

7。任何和所有

我不想把的任何和的所有功能分开，因为它们是互补的。如果 iterable 的任何元素为 True，则 Any 返回 True。如果 iterable 的所有元素都为 True，则 All 返回 True。

any and all 的一个典型用例是检查 pandas 系列或 dataframe 中缺失的值。

import pandas as pd
ser = pd.Series([1,4,5,None,9])print(ser.isna().any())
print(ser.isna().all())True
False

8。范围

范围是不可变的序列。它需要 3 个参数，即开始、停止和步长大小。例如，range(0，10，2)返回一个序列，从 0 开始，到 10 结束(10 不包括在内)，增量为 2。

唯一需要的参数是 stop。Start 和 step 参数是可选的。

print(list(range(5)))
[0, 1, 2, 3, 4]print(list(range(2,10,2)))
[2, 4, 6, 8]print(list(range(0,10,3)))
[0, 3, 6, 9]

9。地图

Map function 将函数应用于迭代器的每个元素，并返回一个 iterable。

a = [1,2,3,4,5]print(list(map(lambda x: x*x, a)))
[1, 4, 9, 16, 25]

我们使用映射函数来平方列表 a 的每个元素。这个操作也可以用列表理解来完成。

a = [1,2,3,4,5]
b = [x*x for x in a]
print(b)

在大多数情况下，列表理解优于映射函数，因为它速度快，语法简单。例如，对于一个有 100 万个元素的列表，我的计算机在 1.2 秒内完成了理解列表的任务，在 1.4 秒内完成了映射功能。

当处理较大的可迭代对象(远大于一百万)时，由于内存问题，map 是更好的选择。如果你想进一步阅读，这里有一个关于列表理解的详细帖子。

[## Python 中的列表理解—解释

何时使用和不使用列表理解。

towardsdatascience.com](/list-comprehensions-in-python-explained-294a464b5245)

10。列表

List 是一个可变序列，用于存储相同或不同类型的项目集合。

a = [1, 'a', True, [1,2,3], {1,2}]print(type(a))
<class 'list'>print(len(a))
5

是包含整数、字符串、布尔值、列表和集合的列表。对于这篇文章，我们更感兴趣的是用类型构造函数(list())创建 list。你可能已经注意到我们在这篇文章中使用了 list()。它接受一个 iterable 并将其转换为一个列表。例如，map(lambda x: x*x，a)创建一个迭代器。我们转换成一个列表来打印它。

我们可以从一个范围、集合、pandas 系列、numpy 数组或任何其他的 iterable 中创建一个列表。

import numpy as npa = {1,2,3,4}
b = np.random.randint(10, size=5)
c = range(6)print(list(a))
[1, 2, 3, 4]print(list(b))
[4, 4, 0, 5, 3]print(list(c))
[0, 1, 2, 3, 4, 5]

感谢您的阅读。如果您有任何反馈，请告诉我。

你应该知道的 10 个 Python 内置函数

原文：https://towardsdatascience.com/10-python-built-in-functions-you-should-know-f6beba1698bb?source=collection_archive---------2-----------------------

带有用法示例

Python 解释器内置了许多始终可用的函数和类型。在本文中，我们将详细解释其中的 10 个功能。我们开始吧！

1.isinstance

如果对象参数是 classinfo 参数的实例，则 isinstance(object，classinfo) 函数返回 True 。如果不是，函数返回假。如果 classinfo 是一个对象元组，并且对象是其中任何一个的实例，那么函数返回 True。

例子

这个函数对于对象类型比较非常有用。我们可以通过以下方式轻松检查对象是否属于 list 类型:

2.活力

zip(*iterables) 函数返回元组的迭代器，其中 i 元组包含来自每个 iterables 的 i 元素。元组的长度等于传递给函数的可迭代变量的数量。在下面的代码块中，两个列表被传递给 zip 函数，获得每个长度为 2 的元组的迭代器。

zip 函数可以接受任何类型的 iterable，比如列表、字符串、元组或字典，返回一个 iterator 对象。为了可视化这个对象，我们可以用内置函数 list() 将其转换成一个 list 。

例子

这个函数在处理循环时会派上用场，允许一次遍历多个可迭代对象。我们可以使用 zip 函数轻松地遍历两个列表，如下所示:

该函数也可与内置函数 dict() 结合使用，以如下方式从两个列表中创建一个字典:

功能 zip 也可用于使用解包操作符*** 将序列解压缩成独立的序列。在下面的代码块中，我们将一个元组列表解压**成两个元组。

3.地图

映射(函数，可迭代，...) function 将给定的函数应用于 iterable 的每个元素。返回值是一个地图对象。这个对象基本上是一个迭代器，我们可以很容易地转换成一个列表或集合，再次使用内置的函数。

映射函数将函数作为第一个参数。当我们想到 Python 中的一个函数时，我们会自动想到 def 关键字，但 map 函数不仅接受用户使用 def 关键字创建的函数，还接受内置、和匿名函数 (lambda 表达式)。第二个参数是一个可迭代的。iterable 是具有可计数数量的值的对象，例如可以使用 for 循环进行迭代。列表、集合、元组或字典是可迭代的，可用作映射函数的第二个参数。

例子

当我们想要对一个 iterable 的所有元素应用数学运算时,映射函数会非常有用。在下面的代码块中，三种不同的数学运算应用于列表的元素。

如上所示，我们使用了匿名函数，因为它们对于短期使用非常有用。然而，正如我之前提到的，我们也可以使用常规函数。

如果多个可迭代参数被传递，该函数将被并行应用于所有可迭代的项目。下面的代码展示了如何用 map 函数将两个 iterables(列表)的元素相乘。

4.过滤器

filter(function，iterable) 函数以一个函数和一个 iterable 作为输入，返回 iterable 中的元素，函数返回 True 。与映射函数一样，过滤函数不仅接受常规函数 (def 关键字)，还接受内置、和匿名函数。

例子

下面的代码使用过滤器函数从列表中获取奇数。

过滤函数接受任何类型的 iterable 作为第二个参数，比如列表、字符串、元组或字典，返回一个 iterator 对象。为了可视化这个对象，我们可以用内置函数 list() 将其转换成一个 list 。

在下面的代码块中，我们使用一组字符串作为输入，过滤那些以 M 或 v 开头的字符串。

5.投入

input([prompt]) 函数从用户处获取原始输入，并以字符串形式返回。该函数采用可选参数( prompt )，可用于在用户要求输入时向用户显示消息。

例子

下面的代码要求用户输入他/她的名字。

如果我们想将输入作为一个数字使用，我们必须将它转换成一个整数或浮点数，因为函数将输入存储为一个字符串。

如上图，通过内置函数 float() 将用户的输入转化为浮点数。

6.身份证明（identification）

函数的作用是:返回一个对象的身份。这是一个整数，在对象的生命周期中是唯一的和恒定的。

例子

当复制对象来检查我们是否已经创建了对象的独立副本时，这个函数会派上用场。

在 Python 中， =操作符不复制对象。它提供了另一个名称来引用同一个对象，这意味着对新对象的任何修改都会反映在原始对象中。下面的代码块显示赋值操作符(=)并没有创建一个新对象，而是创建了一个对原始对象的新引用，因为两个变量有相同的 id 号。

我们还可以使用下面的恒等运算符来检查两个变量是否指向同一个对象:

• 是否为 →如果双方具有相同的身份，则评估为真
• 不为 →如果双方具有不同的身份，则评估为真

如上所示，两个变量(numbers 和 new_numbers)指向同一个对象，因为是操作符的值为真。

为了创建对象的完全独立的克隆，我们可以使用 copy.deepcopy(x) 函数(在 copy 模块中定义)。这个函数创建了一个独立的副本，这意味着我们可以在不修改原始对象的情况下改变新对象。在这种情况下，两个变量具有不同的 id 编号，并且标识运算符为的结果为假。

7。六角

函数的作用是:将一个整数转换成一个小写的十六进制字符串。该字符串以前缀‘0x’开头，表示是一个十六进制数。如果输入的对象不是整数，该函数将引发异常( TypeError )。下面的代码将整数 10 转换成十六进制数。

例题

十六进制数字经常被程序员用来指定颜色，因为它们提供了比“绿色”或“红色”等字符串值更宽的范围。Python 使用形式为 '#RRGGBB' 的字符串来表示十六进制颜色，其中RR(红色)、GG(绿色)和 BB(蓝色)是介于 00 和 FF 之间的十六进制数字，表示颜色的强度。颜色也可以用一个元组 RGB (红、绿、蓝)来表示，其中每个参数用一个 0 到 255 之间的整数定义颜色的强度。现在假设您想要一个函数将一个 RGB 元组表示映射到一个十六进制字符串。下面的代码块显示了我们如何在十六进制函数的帮助下实现这种转换。

8.箱子

bin(x) 函数将一个整数转换成前缀为‘0b’的二进制字符串。

例子

如果输入的对象不是整数，函数 bin 会产生一个异常( TypeError )。为了避免这个问题，在尝试将整数转换为二进制数时，我们可以使用 try 和 except 语句。 try 子句包含了可以引发异常的操作( bin 函数)，而 except 子句包含了处理异常的代码。下面的函数将整数转换为二进制数，考虑到如果提供不同于整数的对象作为输入，将引发异常。此外，前缀‘0b’被删除，只返回二进制数。

9.格式

format(value[，format_spec]) 函数返回由格式说明符控制的给定值的格式化表示。

例子

格式说明符确定如何格式化值，其结构如下:

[[fill]align][sign][#][0][width][grouping _ option][。【精确类型】

您可以通过以下链接了解有关格式化值的所有选项的详细信息:

[## 字符串-常见字符串操作- Python 3.8.2 文档

内置的 string 类提供了通过方法…进行复杂的变量替换和值格式化的能力

docs.python.org](https://docs.python.org/3/library/string.html#formatspec)

现在，让我们看一些例子:

• 四舍五入到两位小数的定点记数法
• 百分比四舍五入到小数点后一位
• 十六进制数
• 指数记数法四舍五入两位小数，正数和负数都带符号
• 带填充字符、宽度和右对齐的数字

正如您所观察到的，format 函数提供了多种格式化值的方法。组合格式说明符的不同参数以发现更多的表示形式。😄

10.打开

open( file ， mode='r' ， buffering=-1 ， encoding=None ， errors=None ， newline=None ， closefd=True ， opener=None ) 函数以一个字符串作为输入，指定文件的路径，返回一个 file 对象。如果文件无法打开，则会出现 OSError 。

例子

我们使用 open 函数在 Python 中读写文件。要读取一个文件，首先我们在读取模式 (mode='r') 下使用打开函数打开它。这个函数返回一个文件对象，我们将它赋给变量 f。然后，我们使用读取方法来访问文件的内容，并将其放入一个字符串中。最后，我们使用关闭方法关闭文件。当我们不再需要文件时，记住关闭所有文件以避免用完文件句柄是很重要的。

我们还可以使用。readlines()方法如下:

为了逐行读取文件，我们使用 readline()方法。该方法从文件中读取一整行，并将其作为字符串返回。

在 Python 中工作时，很容易忘记关闭文件。因此，Python 为提供了语句，该语句在嵌套代码块执行后自动关闭文件。

如您所见，不再需要关闭方法！

用 Python 写文件，我们在写模式 (mode='w') 下使用打开函数。如果文件不存在，Python 会为您创建一个。一旦文件打开，我们用写方法向文件添加文本。请记住，write 方法会在插入文本之前删除文件的内容，这一点很重要。最后，我们必须关闭文件，除非我们像以前一样使用带有语句的。

有趣的网页

除了官方文档之外，还有各种各样的网页可以找到有趣的例子！

[## 内置函数- Python 3.8.2 文档

Python 解释器内置了许多始终可用的函数和类型。它们被列出…

docs.python.org](https://docs.python.org/3/library/functions.html) [## Python 内置函数

Python 有一组内置函数。

www.w3schools.com](https://www.w3schools.com/python/python_ref_functions.asp) [## Python 内置函数

Python 有几个现成的函数可供使用。这些函数称为内置函数。在这个…

www.programiz.com](https://www.programiz.com/python-programming/methods/built-in) [## 极客论坛|极客的计算机科学门户

极客的计算机科学门户。它包含写得很好，很好的思想和很好的解释计算机科学和…

www.geeksforgeeks.org](https://www.geeksforgeeks.org/) [## Python 编程简介| Udacity

在本课程中，您将学习 Python 编程语言的基础，以及编程最佳…

www.udacity.com](https://www.udacity.com/course/introduction-to-python--ud1110)

感谢阅读🍀 🎬

阿曼达

你应该知道的 10 个 Python 内置函数

原文：https://towardsdatascience.com/10-python-built-in-functions-you-should-know-fbd5c879e0ab?source=collection_archive---------28-----------------------

第 2 部分—使用示例

功能是一组允许你执行特定任务的语句。它们对于避免代码重复、使程序更有条理、更易于调试特别有用。尽管你可以随时定义自己的函数， Python 提供了多个内置函数随时可用。在本文中，我们将详细解释其中的 10 个功能。我们开始吧！

1.目录

dir([object]) 函数返回包含 Python 中任意对象的属性和方法的字符串排序列表。该函数将单个对象作为输入，并有助于获取关于我们可以对该对象执行的操作的信息。

其中，我们可以使用 dir 函数与:

• 内置容器(如字典)

正如您所看到的， dir 函数返回一个列表，其中包含 Python 中字典可用的所有方法(甚至是魔法方法)。

• 模块(例如来自 Python 标准库)

在下面的代码块中， dir 函数返回在 glob 模块中定义的所有属性和方法。

• 自己的对象

我们创建了一个名为 Rectangle 的新类，它通过矩形的高度和宽度来定义矩形。接下来，我们创建这个类的一个实例，名为 rectangle_1。然后，我们使用 dir 函数获取 rectangle_1 对象的所有属性和方法(包括继承的魔法方法)。

2.列举

枚举(iterable，start=0) 函数将一个计数器添加到一个 iterable(例如一个列表)中，并返回一个枚举对象。这个对象可以直接在 for 循环中使用，每次迭代都获得一个形式为( index，item )的双项元组。

如上所示，枚举函数创建了一个元组的**可迭代对象，它可以直接在指定两个变量的 for 循环中解包。**

或者，我们可以使用 next() 函数来遍历枚举对象，因为该对象支持迭代协议，这意味着 iter 和 next 方法都被实现。下一个函数每次被调用时都从枚举对象返回下一个元组。

为了检查枚举对象，我们可以通过以下方式使用内置函数 list() 将其转换为一个列表。

默认情况下，枚举函数从 0 开始计数。但是，在某些情况下，您希望计数器从不同的数字开始计数。我们可以通过在第二个参数( start) 中指定索引(整数)来轻松地更改起始索引，如下所示。

3.evaluate 评价

eval(expression[，globals[，locals]])函数执行包含 Python 代码的字符串并返回结果。这个函数有 3 个参数:(1) 表达式 , (2) 全局变量,( 3)局部变量。第一个参数包含要作为 Python 表达式计算的字符串。另外两个参数是可选的，包含全局/局部方法和变量。

如下图所示，使用 eval 函数，我们不仅可以对表达式求值，还可以调用方法和函数。

eval 函数仅适用于表达式，试图将语句作为输入将引发异常( SyntaxError )。

虽然 eval 函数在评估用户引入的表达式时很方便，但该函数有重要的安全缺陷。用户可以将不受信任的代码传递给 eval 函数，甚至可以删除您系统中的文件。这个问题的解决方案是通过修改全局和局部参数来限制 eval 函数的执行环境。

如果你想知道更多关于 eval 函数的信息，我真的建议你看看下面的文章。

[## Python eval():动态计算表达式——真正的 Python

在本教程中，您将了解到:您可以使用内置的 Python eval()从一个…

realpython.com](https://realpython.com/python-eval-function/)

4.全部

当给定的可迭代(例如一个列表)中的所有元素都为真时， all(iterable) 函数返回 True 。如果不是，则返回假。

在 Python 中，以下值被视为假(假值):

• 没有人
• False(布尔类型)
• 任何数值类型的零(例如 0，0.0，0j)
• 空序列(例如()，[])
• 空映射(例如{})

所有这些值在布尔上下文中评估为假，并且它们可以在 if 或 while 语句中使用，也可以与操作数和、或以及 not 一起使用。

如果其中一个 False 值包含在可迭代中，则 all()函数返回 False ，如下所示。

5.任何的

any(iterable) 函数接受一个 iterable(如列表、字典或元组)作为输入，如果 iterable 的任何元素为真，则返回 True 。如果不是，则返回假。

与 all()函数一样，any()不限于评估布尔数据类型。该函数评估 iterable 的值是 True 还是 falsy，如果任何值为 True，则返回 True 。(参见第 4 部分中被视为虚假的值)

要检查一个值是真还是假，我们可以使用如下所示的 bool() 函数。

• 如果输入值为真值，该函数返回真值。
• 如果输入值为 falsy ，则返回 False 。

6.混杂

哈希表是将键映射到值的数据结构。一个哈希表使用一个哈希函数来获得索引，其中值可以在下表中找到，如下图所示。

hash() 函数返回一个对象的哈希值(如果它有一个的话)，意思是提供在哈希表中查找的索引。

正如您所看到的，如果提供了一个不可变的对象作为输入，这个函数将返回一个整数 ( 哈希值)。相反，如果提供了一个可变对象，则 hash()函数会引发一个异常( TypeError ),因为可变对象(例如列表)是不可共享的(它们可以在其生命周期内改变)。

当提供特定的输入时， hash()函数总是返回相同的数字输出值，这意味着它是一个确定性函数。

请记住，散列函数的输出在您的计算机上可能不同，因为这个函数是依赖于平台的。

Python 对字典和集合使用哈希表。因此，我们可以很容易地确定一个对象是否属于一个字典或集合，因为我们知道它在内存数组中的索引(哈希函数的输出)。因此，在字典或集合中搜索一个元素的时间复杂度仅为 O(1)(无哈希冲突)。

相反，如果我们将元素存储在列表中，我们需要潜在地搜索列表中的每个元素，以确定给定元素是否存在(时间复杂度 O(n) )。

下面的代码块显示了在集合中搜索元素要比在列表中快得多。

正如我之前所说的， hash()函数的输入应该是一个不可变的对象。出于这个原因，我们不能使用可变的对象作为字典的键或者集合的元素。

如上所示，当试图使用一个列表作为字典的键时，会引发一个 TypeError。

7。可调用

如果作为参数传递的对象是可调用的，则 callable(object) 函数返回 True 。如果没有，返回假。

可调用对象是可以用函数运算符()调用的对象。Python 有五个可调用的对象:(1) 函数，(2) 方法，(3) 类，(4) 类实例(如果 call 方法被定义 ) ，(5) 生成器。

如下所示，如果这些对象中的任何一个作为输入被提供，可调用函数返回 True 。相反，如果我们提供一个整数，函数返回 False 。

8.范围

range([start]，stop，[step]) 函数返回一个不可变的整数序列 (range 对象)，将三个参数作为输入:

• 开始→ 序列的开始索引(默认为 0)
• 停止→ 范围的上限(总是被排除)
• 步长→ 序列的步长(默认为 1)

启动和步骤是可选参数，调用该函数时停止是唯一需要的参数。为了可视化一个 range 对象的元素，我们可以使用内置函数 list() 将其转换为一个列表。

下面的代码块显示了使用 range 函数生成的多个整数范围。

范围函数通常与一起用于循环以迭代一系列数字。

如上所示，range 函数的上限总是被排除在外。

虽然不太常用，但是范围函数也与 while 循环和 if 语句一起使用。

9.低输入联网（low-entry networking 的缩写）

len(object) 函数返回一个对象中的项数。如下图所示， len()函数的输入可以是集合、序列、 NumPy 数组、甚至是熊猫系列。

len()函数通常与 range()函数一起使用，以迭代可迭代的索引。

如下所示，我们可以使用语法 range(len(iterable))迭代从 0 到 iterable 长度的数字。

下面的代码块产生与前面相同的输出，但是在这种情况下，我们迭代列表的项，而不是索引。

10.轮次

round(number[，ndigits]) 函数返回一个浮点数四舍五入到小数点后 n 位数。函数的第二个参数是可选的，如果省略，函数将返回一个整数作为输出。

如下图所示，我们可以很容易地用 round()函数将圆周率四舍五入到小数点后两位或最接近的整数。

Python 包括更多的内置函数，它们执行数学运算，比如:

• abs(x) →获取一个数的绝对值 x
• 复数([real[，imag]]) → 定义一个复数 real+imagj
• max(iterable) →获得 iterable 中的最大项目
• 最小(可迭代) →获得可迭代中的最小项目

有趣的网页

除了官方文档之外，还有各种各样的网页可以找到有趣的例子！

[## 内置函数- Python 3.8.3 文档

Python 解释器内置了许多始终可用的函数和类型。它们被列出…

docs.python.org](https://docs.python.org/3/library/functions.html) [## Python 内置函数

Python 有一组内置函数。

www.w3schools.com](https://www.w3schools.com/python/python_ref_functions.asp) [## Python 内置函数

Python 有几个现成的函数可供使用。这些函数称为内置函数。在这个…

www.programiz.com](https://www.programiz.com/python-programming/methods/built-in) [## 极客论坛|极客的计算机科学门户

极客的计算机科学门户。它包含写得很好，很好的思想和很好的解释计算机科学和…

www.geeksforgeeks.org](https://www.geeksforgeeks.org/) [## Python 编程简介| Udacity

在本课程中，您将学习 Python 编程语言的基础，以及编程最佳…

www.udacity.com](https://www.udacity.com/course/introduction-to-python--ud1110)

第一部分

如果你还有兴趣了解更多关于内置函数的知识。阅读第 1 部分:)

[## 你应该知道的 10 个 Python 内置函数

带有用法示例

towardsdatascience.com](/10-python-built-in-functions-you-should-know-f6beba1698bb)

Python 提供了各种各样的内置函数，随时可供使用，这使得您的编程生活变得更加容易，因为您不需要浪费时间编写自己的代码。此外，Python 标准库以及第三方模块提供了更多功能来处理日常编程。因此，在大多数情况下，掌握 Python 编程就是了解可用的代码。💪

我希望你喜欢阅读这篇文章！再见👐

阿曼达💜

每个人都应该构建的 10 个 Python 迷你项目(带代码)

原文：https://towardsdatascience.com/10-python-mini-projects-that-everyone-should-build-with-code-769c6f1af0c4?source=collection_archive---------0-----------------------

今天你能在互联网上找到的最好的 python 迷你项目

戴维·克洛德在 Unsplash 上的照片

你好，我是阿沛

我们在 2020 年。我们都知道这个行业正在日益发展。如果你看到从 2013 年到 2019 年，python 在行业中的增长在 40%左右，据说在未来几年将增长 20%以上。在过去的几年中，python 开发者的增长率增加了 30%,所以没有比学习 python 更好的时间了，也没有比做项目更好的方法了。

在这个博客中，我们将创建 10 个 python 迷你项目。

1. 掷骰模拟器
2. 猜数字游戏
3. 随机密码生成器
4. 二分搜索法
5. 使用 python 发送邮件
6. 中型文章阅读器
7. 闹钟
8. 网址缩写
9. 天气 app
10. 按键记录器

照片由 Riz Mooney 在 Unsplash 上拍摄

掷骰模拟器

目标是创建一个模拟掷骰子的程序。

主题:随机模块、循环和 if-else

提示: 使用随机模块生成一个用户想要的 1 到 6 之间的随机数。

自己试试

import random 
while True:     
     print(''' 1\. roll the dice             2\. exit     ''')    
     user = int(input("what you want to do\n"))     
     if user==1:         
        number = random.randint(1,6)         
        print(number)     
     else:         
        break

猜数字游戏

该项目的主要目标是创建一个程序，在一个范围内随机选择一个数字，然后用户必须猜测这个数字。用户有三次机会猜测数字，如果他猜对了，然后打印一条消息说“你猜对了”，否则打印一条负面消息。

主题:随机模块，for 循环，f 字符串

自己试一试

import random
number = random.randint(1,10)
for i in range(0,3):
    user = int(input("guess the number"))
    if user == number:
        print("Hurray!!")
        print(f"you guessed the number right it's {number}")
        break
if user != number:
    print(f"Your guess is incorrect the number is {number}")

随机密码生成器

创建一个程序，接受一个数字并生成该数字的随机密码长度。

主题:随机模块，连接字符串，接受输入

提示:创建一个包含所有字符的字符串，然后从中随机抽取字符，并将每个字符连接起来，形成一个大字符串。

自己试试

import random
passlen = int(input("enter the length of password"))
s="abcdefghijklmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()?"
p =  "".join(random.sample(s,passlen ))
print (p)

二分搜索法

二分搜索法的目标是搜索一个给定的数字是否出现在字符串中。

主题:列表、排序、搜索

提示:先检查中间是否有，再检查前后。

自己尝试一下

lst = [1,3,2,4,5,6,9,8,7,10]
lst.sort()
first=0
last=len(lst)-1
mid = (first+last)//2
item = int(input("enter the number to be search"))
found = False
while( first<=last and not found):
    mid = (first + last)//2
    if lst[mid] == item :
         print(f"found at location {mid}")
         found= True
    else:
        if item < lst[mid]:
            last = mid - 1
        else:
            first = mid + 1 

if found == False:
    print("Number not found")

使用 python 发送邮件

创建一个可以发送电子邮件的 python 脚本

主题:导入包，SMTP 库，向服务器发送请求

自己试一试

import smtplib from email.message import EmailMessageemail = EmailMessage() ## Creating a object for EmailMessageemail['from'] = 'xyz name'   ## Person who is sendingemail['to'] = 'xyz id'       ## Whom we are sendingemail['subject'] = 'xyz subject'  ## Subject of emailemail.set_content("Xyz content of email") ## content of emailwith smtlib.SMTP(host='smtp.gmail.com',port=587)as smtp:     
## sending request to server 

    smtp.ehlo()          ## server objectsmtp.starttls()      ## used to send data between server and clientsmtop.login("email_id","Password") ## login id and password of gmailsmtp.send_message(email)   ## Sending emailprint("email send")    ## Printing success message

由 Fab Lentz 在 Unsplash 上拍摄的照片

中型文章阅读器

任务是创建一个可以从链接中读取文章的脚本。

主题:网页抓取，文字转语音

提示:

自己试试

import pyttsx3
import requests
from bs4 import BeautifulSoup
engine = pyttsx3.init('sapi5')
voices = engine.getProperty('voices')
engine.setProperty('voice', voices[0].id)def speak(audio):
  engine.say(audio)
  engine.runAndWait()text = str(input("Paste article\n"))
res = requests.get(text)
soup = BeautifulSoup(res.text,'html.parser')
articles = []
for i in range(len(soup.select('.p'))):
    article = soup.select('.p')[i].getText().strip()
    articles.append(article)
text = " ".join(articles)
speak(text)# engine.save_to_file(text, 'test.mp3') ## If you want to save the speech as a audio fileengine.runAndWait()

闹钟

我们的任务是使用 python 构建一个闹钟

主题:日期时间模块，播放声音库

网址缩写

使用 API 创建一个短 URL 的 python 脚本。

要运行上述代码，请执行python filename.py url。

***python tinyurl_url_shortener.py*** [***https://www.wikipedia.org/***](https://www.wikipedia.org/)

天气 app

我们的任务是创建一个能够给出天气信息的 python 脚本。

主题:网页抓取，谷歌抓取

提示: 使用网页抓取直接从谷歌抓取天气信息。

照片由在 Unsplash 上绘制光束

按键记录器

我们的任务是创建一个按键记录器，可以将按键存储在一个 txt 文件中。

主题: pynput 库，与文件交互

****提示:使用 pynput 读取按键，然后保存到一个 txt 文件中。

谢谢你的阅读😄

未来阅读

** [## 6 每个人都应该构建的 python 中间项目(带代码)

今天你能在互联网上找到的最好的 python 项目。

medium.com](https://medium.com/@parasharabhay13/5-python-intermediate-project-that-everyone-should-build-with-codes-5039f13feadb)**

感谢你读到这里，如果你喜欢我的内容并想支持我，最好的方式是—

1. 跟我上 中。
2. 在LinkedIn上联系我。
3. 使用 我的推荐链接 用一个披萨的费用成为中等会员。你会费的一小部分会归我。
4. 订阅 我的邮件列表 从不会错过我的一篇文章。

关于深度学习的 10 个问题

原文：https://towardsdatascience.com/10-questions-about-deep-learning-b37c61684c3?source=collection_archive---------47-----------------------

了解神经网络为何如此强大，如何以及在哪里使用它们，以及如何开始——无需编程

罗莎丽亚·西里波，凯瑟琳·梅尔彻，阿德里安·奈姆巴赫，科里·威辛格，克尼梅

如今，无论你在哪里看，你都会发现一篇文章，描述了在数据科学问题中使用深度学习的获胜策略，或者更具体地说，在人工智能(AI)领域。然而，对深度学习的清晰解释，为什么它如此强大，以及深度学习在实践中采取的各种形式，并不那么容易得到。

为了了解更多关于深度学习、神经网络、主要创新、最广泛使用的范式、深度学习在哪里起作用和不起作用，甚至一点历史，我们问了并回答了几个基本问题。

深度学习到底是什么？

深度学习是传统神经网络的现代进化。事实上，除了经典的前馈、全连接、反向传播训练的多层感知器(MLPs)，还增加了“更深层次”的架构。更深意味着更多的隐藏层和一些新的额外的神经范式，如在递归网络和卷积网络中。

深度学习和神经网络有什么区别？

没有区别。深度学习网络是神经网络，只是具有比 20 世纪 90 年代可能训练的更复杂的架构。例如， Hochreiter 和 schmid Huber在 1997 年引入了递归神经网络(RNNs)中的长短期记忆(LSTM)单元，但是由于需要较长的计算时间和大量的计算资源，该单元从未被广泛采用。具有不止一个隐藏层的多层感知器也已经存在很长时间了，它们的好处显而易见。主要的区别是现代计算资源使它们的实现变得可行。

深度学习主要是关于更快更强大的计算资源吗？

一般来说，更快和更强大的计算资源已经允许实现和实验更强大和更有前途的神经架构。很明显，在网络训练中花费几天时间无法与在 GPU 加速的帮助下训练相同网络所花费的几分钟时间相媲美。

是什么突破性的项目引发了深度学习的流行？

重大突破发生在 2012 年，当时基于深度学习的 AlexNet 网络以前所未有的优势赢得了 ImageNet 挑战赛。AlexNet 的前五名错误率为 15%，而第二名的最佳竞争对手的错误率为 26%。这场胜利引发了深度学习网络的激增，如今最好的模型的错误率低于 3%。

如果你考虑到人为错误率约为 5 %,那就更令人印象深刻了。

是什么让深度学习如此强大？

一句话，灵活性。一方面，神经网络是通用函数逼近器，这是一个聪明的说法，你可以用神经网络逼近几乎任何东西——如果你让它足够复杂的话。另一方面，您可以使用网络的训练权重来初始化执行类似任务的另一个网络的权重。这被称为迁移学习，你会惊讶它的效果有多好，即使是对于乍看起来完全不同的任务。

最广泛使用的神经网络范例有哪些？

有四种非常成功并被广泛采用的深度学习范式:递归神经网络中的 LSTM 单元、卷积神经网络(CNN)中的卷积层、编码器-解码器结构和生成对抗网络(GANs)。

rnn 是用于处理序列数据的神经网络家族，例如文本(例如，单词或字符的序列)或时间序列数据。其思想是在每个时间步应用相同网络的副本，并通过一些状态向量连接不同的副本。这使得网络能够记住过去的信息。rnn 中流行的单元网络结构是门控循环单元(gru)和 LSTMs。

CNN 图层对于具有空间依赖性的数据(如图像)尤其有用。不是将每个神经元连接到新层，而是使用滑动窗口，其工作方式类似于过滤器。一些卷积可以检测边缘或角落，而其他卷积可以检测图像中的猫、狗或街道标志。

另一种常用的神经网络结构是编码器-解码器网络。一个简单的例子是自动编码器，其中具有瓶颈层的神经网络被训练来将输入重构为输出。编码器-解码器网络的第二个应用是神经机器翻译，其中编码器-解码器结构用于 RNN。基于 LSTM 的编码器提取源语言内容的密集表示，基于 LSTM 的解码器生成目标语言的输出序列。

当然，还有生殖对抗网络。生成式对抗网络由两个深度学习网络组成，生成器和鉴别器。两个网络都在交替的步骤中接受训练，竞相提高自己。GANs 已成功应用于图像张量，创造出动漫、人形，甚至类似梵高的杰作。

深度学习是否已经接管了整个机器学习世界？

没有，至少现在还没有。在某些领域，比如计算机视觉，你无法再回避深度学习，但在其他领域，比如表格数据，已经被证明是深度学习的一个挑战。

在表格数据的情况下，这仍然是用于存储业务数据的主要格式，深度学习在这方面做得并不差。然而，在昂贵的 GPU 服务器上训练一个深度学习模型几天很难证明，如果你可以使用随机森林或梯度增强树获得类似的准确性，你可以在一台像样的笔记本电脑上在几分钟内训练。

我需要知道如何编码才能使用深度学习吗？

不完全是。的确，大多数深度学习范式都可以在 TensorFlow 和 Keras 中使用，而且这两个工具都需要 Python 技能。然而，在我们的开源 KNIME 分析平台中，我们提供了一个图形用户界面(GUI)来在后端使用 TensorFlow 准确地处理那些 Keras 和深度学习库。你可以通过一个接一个地拖放适当的节点来构建一个你想要的复杂的神经架构。

下面的图 1 显示了一个例子，我们训练了一个 LSTM 的 RNN 来生成自由文本。这位模特为一个新的户外服装系列创造了类似山脉名称的假名字。在顶部(棕色节点)，您可以看到我们构建神经架构的位置，然后我们使用 Keras 网络学习器节点对其进行训练。经过训练的网络经过适当的修改后，以 TensorFlow 格式保存。

图一。构造和训练基于 LSTM 的 RNN 以生成自由文本。在顶部，棕色节点构建网络架构。然后，Keras 网络学习器节点训练该网络，该网络在经过一些适当的后处理后被保存在 TensorFlow 文件中。

哪里可以找到深度学习网络的例子？

你可以在我们的社区 KNIME Hub 找到很多。例如，具有 LSTM 单元的递归神经网络可以在这个例子中找到，用于自由文本生成(也在图 1 中示出)，或者在这个例子中用于时间序列预测。此外，还有几个使用卷积神经网络处理图像的示例工作流，如“从头开始构建 CNN”或“训练简单的 CNN ”构建了一个简单的前馈全连接多层自动编码结构并将其用作欺诈检测任务的解决方案。我敢肯定，在我们说话的时候，社区上传了更多的内容。

如果我使用 KNIME Analytics 平台，我需要在云上托管我的工作吗？

KNIME Analytics Platform 是一个开源应用程序，它的集成也是如此，包括 Keras 和 TensorFlow 集成。你可以把它们安装在任何你想安装的地方，比如你选择的公共云中或者你的机器上。不过，很明显，机器越强大，执行速度就越快。您甚至可以在 KNIME Keras 集成中应用 GPU 加速。你只需要一台安装了 CUDA 的配备 GPU 的机器，一个安装了 Keras 的 Conda 环境，以及在此之上的 KNIME Keras 集成。

最早发表于 信息世界。

Python 中的 10 个快速清理编码技巧

原文：https://towardsdatascience.com/10-quick-and-clean-coding-hacks-in-python-1ccb16aa571b?source=collection_archive---------6-----------------------

让你的 Python 脚本漂亮易读

克里斯里德在 Unsplash 上的照片

嘿大家好！得益于 Python 漂亮的简单性，它提供了多种方法来完成相同的任务。它也是一种非常直观和易于读写的语言。也就是说，很容易被 Python 冲昏头脑，使事情看起来比实际需要的更复杂。pep 8《python 风格指南》提供了一些保持 python 整洁的指南。这里有一个快速列表，列出了 10 个你可以在代码中立即开始做的事情。

1.帮你的合作开发者一个忙，使用 docstrings

使用“三重双引号”来编写文档字符串，清楚地解释您的函数、模块和脚本的用途，即使您是以其他方式对其进行注释。请记住以句点结束文档字符串。(.)

def get_percent_sales(product,sales,region):“““Return the product Sales volumes in percent of total in country.Get percentage of product sales of the region.This function gets the product and corresponding sales by region and returns a percent sales of the region by total sales in that country. Region input is accepted only by city. Districts are not accepted. If city name is not found, exception is thrown. Parameters:             product (str) : Product name sales (int) : Sales Volume Returns: 
             percent_sales (float): Percent of total sales of    
                                    product.
"""

2.让你的逻辑陈述看起来更直观

不

if is_white == Falseif not is_white == False

做

is_white = Trueif is_white:else: 

3.使用。用 join 代替+来执行字符串连接

不

my_name = ‘firstname’+ ‘ ‘ + ‘lastname’

做

my_name = " ".join(['firstname','lastname'])

4.对可读的 for 循环使用列表理解

numbers = [1,2,3,4,5,6,7,8,9,10]

不

even_halves = [ ]for num in numbers:
    if num%2 == 0:
       even_halves.append(num/2)print(even_halves)

做:

even_halves = [num/2 for num in numbers if num%2==0]

5.如果要给变量赋值，请使用 def 函数而不是 lambda

保存 lambda 函数，以便在表达式中进行计算。

不

squared = lamdba x: x**2

做

def squared(x):
   return x**2

6.打破那些长长的队伍

注意文本换行。保持在编辑器的换行范围内。

不

df = pd.read_excel('This/extremely/long/file/path/that/extends/ /to/the/next/line/and/screws/with/indentation.xlsx')mylist = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20000,30000,3100000320000]

做反斜杠和隐式延续:

filepath = "this/sweet/line/" **\**
           "continued/prettily/"**\**
           "looksbetter.xlsx"df = pd.read_excel(filepath)my_list = [1,2,3,4,5,6,7,8,9,10,11,
          12,13,14,15,16,17,18,19,
          20000,30000,3100000,320000]if this_happens or that_happens **\**
   or these_happen:
      print('blah')
else:
   print('the other blah')

7.尽可能使用范围而不是列表

不

indices = [0,2,4,6,8,10]for idX in indices: print(name[idX])

做

for idX in range(0,12,2): print(name[idX])

8.在 Try 块下保持最小的代码量

不

try: names = get_data(students, classroom) numbers = get_scores(students, classroom) return names,numbersexcept KeyError: 

做:

try: names = get_data(students, classroom) numbers = get_scores(students, classroom)except KeyError:
    print('That's not a student in this classroom!')return names, numbers

9.比你已经做的多使用一些器械包

器械包提供的是性能而不是功能。如果在当前情况下不需要很多功能，那么最好选择集合而不是其他数据结构。

data = {‘find_this’, ‘among’, ‘all_the’,'other',’data’}if‘find_this’ in data: print(‘this exists!’)long_stuff = [‘this’,’list’,’list’,’is’,
             ’enormous’,’oh’,’my’,’god’,
             ’god’,’what’,’is’,
             ’unique’,’unique’]unique_values = set(long_stuff) 

10.使用 zip 迭代多个列表

students = [‘tom’,’dick’,’harry’,’larry’,’tim’,’benny’]scores = [100,20,40,60,30,40]

不要:

for i in range(len(students)): print(student[i],scores[i]

做

for student,score in zip(students,scores):
    print(student,score)

这是关于用 python 改进脚本的一些基本方法。遵循风格指南，做一个友好的程序员！

10 个商业智能工具应用实例|商业智能

原文：https://towardsdatascience.com/10-real-world-examples-of-bi-tools-in-action-business-intelligence-54d5af285b9?source=collection_archive---------47-----------------------

nabler.com

了解商务智能工具的应用

如今，每个组织都期待采用高级分析来理解不断增长的数据量，商业智能 (BI)开启了一个充满机遇的世界。BI 可以为几乎每个业务流程增加价值。从提高生产力到深入了解客户需求和产品使用方式，商务智能几乎无所不在。商业智能可以使组织提供更新的见解和方向，并帮助他们在分析数据时变得更加积极主动，以提高效率并做出更好的业务决策。

为了获得更好的商业价值和持续跟踪，您的商务智能专业人员需要具备广泛领域的资格，并紧跟所有新趋势。随着技术的进步，数字化转型现在被视为一项至关重要的战略举措，商业智能工具已经演变为一种帮助公司充分利用数据的工具。这种反应是现代商业智能平台不断增强的能力的结果，这些平台支持数据访问、交互性、发现、实时警报、可操作的仪表盘、移动数据访问、人工智能生成的见解、人工智能驱动的数据播客和许多其他东西。整体商业智能市场预计将以 9.5%的 CAGR 增长，从 2016 年的 170.9 亿美元增长到 2021 年的 268.8 亿美元。

以下是 10 大商业智能工具的实际例子。

• 带来整体视图(收集和拼接正确的数据)
• 来自您的商业智能系统的警报(用于实时操作)
• 拥有更多可操作的仪表盘(洞察行动)
• 经验很重要(以行动为动机的陈述非常普遍)
• 优化您的移动数据访问(随时随地通过任何设备访问)
• 人工智能生成的见解(为更聪明的人提供的智能见解)
• 人工智能驱动的数据播客(尝试你传递信息的方式)
• 提升分析(用您的活动击中靶心)
• 面向营销人员的仪表板解决方案(提高 CMO 效率)
• A/B 统计显著性计算器(数据集的关系计算器)

1.带来整体视图(收集和拼接正确的数据):

BI 报告平台使您能够做出明智的决策，但如何处理来自多个来源的不断增长的数据量仍然是一个挑战。您还将面临数据同步和以正确的粒度级别拼接数据的挑战。为了准确了解您的公司在任何给定时间的运营情况，您需要一个商业智能工具，将来自各部门的大量数据转化为组织的整体视图。

解决方案:尽管客户在进行数据业务，但他们的数据仍然分散在不同的地方，造成了对最后一次联系归属的混淆。我们采取的方法是首先理解业务目标和他们现有的数据源。这帮助我们决定哪些数据源应该自动化，哪些数据应该缝合在一起。

我们对情况的综合分析使我们的客户能够自动化 7 个以上的基本数据源和 50 个以上的用户。能够看到真相的一个版本也让他们能够实时做出明智的决定。

2.来自您的商业智能系统的警报(用于实时操作)

当您监控大量 KPI 并管理大量仪表板时，很容易忘记什么对您重要。Business alerts 将帮助您解决各种情况，例如当达到预定目标时，或者每当发生意外事件时，您都会收到通知，并完全控制推动您业务发展的因素。

解决方案:设置定制的数据警报是监控业务绩效的最有效方式。设置警报并不复杂，但是您的 BI 团队或顾问应该首先为合适的人员选择合适的 KPI。因此，BI 的发现阶段变得非常重要，在此阶段您可以了解棘手问题。有时不够清晰，但这足以指导我们思考 KPI 和警报。有时，高水平的 KPI 不会引起太多的兴趣，需要的是寻找一些相关的东西或试图得出一个分数或比率。最后一步是设置阈值和警报模式。大多数情况下，电子邮件是接收提醒的首选，但在某些情况下，短信文本。

3.拥有更多可操作的仪表盘(洞察行动)

决定什么应该在仪表板上是非常重要的。您不需要仪表盘上的大量数据，只要有足够的数据来帮助实现您组织的关键绩效指标(KPI)就足够了。获胜的分数不是仪表盘的总数，而是有多少仪表盘是可操作的，被广泛使用的。使仪表板更具可操作性的几个要素是:内容基准、目标、实时 KPI 监控、流量趋势、按主题和角色划分的绩效、参与度指标、ROI 证明。

解决方案:我们让客户能够查看他们的销售业绩仪表板。有几个仪表盘在显示销售业绩。根据服务的不同，每个销售经理都有自己的活动门槛(跟进电话和电子邮件/询问)。他们过去常常查看这些仪表板，并召开评审会议。但是，大量的表格和分散的视觉效果让我们很难理解整体表现，也很难看到他们与其他销售人员相比的位置。

使用散点图为他们创建分布，并通过启用参考线使其动态化，然后与 viz 交互，在数据手册中为他们提供实际结果。

4.经验很重要

也许你已经准备好了所有复杂转换的精确数据。但是呈现的方式很重要。带着行动动机看待数据的文化转变正在广泛流行。因此，在增强这些功能的同时，我们可能需要关注视觉效果的外观和感觉。正确的图表类型、度量标准和维度的正确使用以及良好的表示层会带来很大的不同。

解决方案:一个从输入到输出的开关。随着对高质量和正确数据输入的日益关注，对高质量输出的需求也在增加。对可视化可以提供什么的理解在很大程度上推动了消费者方面的需求。

一个交互式的、自我解释的商业智能仪表板是一种很好的方式，可以汇编几种不同的数据可视化，以提供对业务绩效的一目了然的概述。

图片由 nabler.com 拍摄

5.优化您的移动数据访问

移动商务智能的好处数不胜数。随时随地获得数据是时代的需要。这有助于您通过在整个组织中更广泛地传播商业智能来创建数据驱动的决策文化。但是这个旅程并不是偶然发生的。桌面上的视觉效果和移动中的数据是有区别的。您应该重建整个商业智能基础设施吗？这可能需要几年时间。

解决方案:如果您正在考虑移动商务智能，或者已经开始使用移动商务智能，这里有五个针对移动受众发布信息的最佳实践。

• 避免仪表板激增
• 写入更小的外形
• 考虑一个忙碌的观众
• 考虑新的移动场景
• 利用移动设备的自然协作流程

但是，在您考虑使用移动商务智能之前，您应该了解以下几点:

• 较小的屏幕意味着您可以使用的空间更少。布局必须是流线型的，整洁的，简洁的。
• 只显示桌面版本的基本数据，用户离不开这些数据。理想情况下，创建一个专属的移动商务智能仪表板来代表这一点。
• 由于用户将在旅途中检查手机上的数据，他们更可能关注日常运营数据，而不是分析。
• 考虑触摸屏——“胖手指”点击屏幕上的一个元素并被带到错误的页面是令人沮丧的。确保每个部件都有足够的空间，并且这些视觉元素之间有足够的间隔。
• 在应用程序的布局、颜色和元素方面保持一致，以避免混淆用户。
• 对比色。由于移动仪表板是为小屏幕设计的，您希望确保它在视觉上吸引人，并吸引人们对关键元素的注意。对比背景色和前景色，使数据点突出出来。

图片由 nabler.com 拍摄

6.人工智能产生的见解

企业似乎正在进入一个由数据统治的新时代。商业智能中的人工智能正在演变成日常商业活动。现在，您可以使用机器学习算法来识别大量数据中的趋势和见解，并做出更快的决策，这可能会使您实时保持竞争力。杰出的解决方案提供商已经超越了创建传统解决方案的阶段，开发出完整的整体平台，更好地实现商业智能和分析流程的自动化。

解决方案:人工智能可以用来释放真正分析的力量。虽然建立假设的传统方式是通过查询数据，但人工智能将帮助决策者使用查询数据来验证机器生成的洞察力。

荷兰国际集团、沃尔玛和通用电气等公司多年来一直在使用人工智能衍生的见解。这里有更多信息。

纳布勒的图片

纳布勒的图片

7.人工智能驱动的数据播客

为你的企业建立一个数据播客是传递信息的另一种创新方式。人工智能层将以纯文本的形式让你获得洞察力，而 NLP 层会将其转换为音频层。你甚至可以为你的企业尝试一些有趣的背景和品牌。

8.升力分析

提升分析是一种衡量活动如何影响关键指标的方法。当涉及多重接触归因时，可以通过查看受您的活动影响的场合，并将其与未受您的活动影响的场合进行比较，来应用营销提升分析。通过将您的治疗组与您的对照组进行比较，您可以看到上述每个指标的“提升”,并根据数据做出投资哪些活动或停止投资哪些活动的决策。

纳布勒的图片

它们有助于您更好地了解模型的整体性能。如果提升图的斜率不单调，您可以快速发现缺陷。此外，它还帮助您设置一个阈值，哪些用户值得锁定。最后，与随机定位相比，您可以估计您可以更好地定位用户。

9.面向营销人员的仪表板解决方案

成功的营销融合了硬数据和创造性的见解。您可以在一个营销仪表板中查看您的所有数据源，包括您的社交媒体平台、CRM、Google Analytics、内容营销仪表板、Web Analytics 仪表板等。所有营销 KPI 都在一个易于阅读的仪表板中，您将立即看到优化整体战略的机会。

解决方案:像现代的 CMO 一样，你使用各种营销技术和工具。您有许多数据源，并且总是在一个仪表板中创建一个整体视图是一项挑战。CMOs 通常会寻找以下类型的仪表板:

营销漏斗仪表板、渠道仪表板、社交媒体仪表板、内容营销仪表板、网络分析仪表板、搜索引擎营销仪表板、搜索引擎优化仪表板。

在这里，我们通过首先采取一种理解业务目标和数据类型的方法来帮助我们的客户。这有助于我们决定哪些数据源应该自动化和连接，并使数据流流向一个单一的仪表板，以提供完整的营销绩效的整体视图。我们还让我们的客户能够以正确的粒度级别将相关数据缝合在一起。

纳布勒的图片

10.A/B 统计意义计算器

A/B 测试显著性计算器是一种统计假设测试工具，用于计算两个数据集之间的关系，然后将这些数据集相互比较，以确定是否存在统计显著性关系。我们的客户使用 A/B 显著性计算器来确定 A/B 检验在统计上是否显著。你也可以在这里查看

纳布勒的图片

结论

如果你想跟上数字革命的步伐，你必须对你的数据采取严肃的策略。虽然今天进行的许多数据分析都是基于历史数据，但重点正在迅速转向商业中的人工智能。今天，它不再仅仅是呈现数据。重点是给出更多可操作的见解。为了在 2020 年的竞争中保持竞争力，您必须了解最新的商务智能工具，这些工具可以帮助您实时做出相关的业务决策。

最初发表于【https://www.nabler.com】。

作为数据科学家，业务知识非常重要的 10 个原因

原文：https://towardsdatascience.com/10-reasons-why-business-knowlege-ist-important-as-a-data-scientist-9939e08f723c?source=collection_archive---------45-----------------------

我从信息系统和黑客马拉松到数据科学的旅程

图片由弗兰基·查马基在 Unsplash 上拍摄

我 10 岁的时候没有开始编程。我第一次参加数学竞赛是在 23 岁的时候。我很好，但这还不足以进入决赛。现在，我在研究生项目中学习计算机科学的同时，专注于数据科学。

我成为数据科学家的梦想始于我在信息系统和管理的学士学位结束时。一方面，我感到被我的同事淹没了，他们通常是比我更好的数学家。另一方面，我认为一个侧重于商业和技术的学士学位有利于我的旅程。我的想法是基于我在本科学习期间必须参加的商业必修课。

第一部分—信息系统和管理作为起点

照片由 Ruthosen Zimmerman 在 Unsplash 上拍摄

1.知识管理

知识管理是每个成功产品的支柱。如果我想到为我使用的任何软件库制作的成千上万的文档，很明显这个主题是必不可少的。例如，你能想象没有它的文档如何使用 Python 熊猫库吗？另一个例子是当我还是一名数据分析师时，我不得不引入知识管理策略。作为一个成长中的团队，我们的问题是新团队成员对我们的仪表板一无所知。记住并解释每一项知识似乎是不可能的。对我来说，学习一些知识管理的基础知识是有益的，特别是如果你必须决定什么是隐性知识和显性知识。

2.业务流程管理

数据科学不仅仅是处理数据。也是为了在解释数据以改进业务流程时给出一些建议。在我实习期间，我意识到这些业务流程是多么复杂。没有课堂上的知识，我大部分时间都没有机会理解他们在说什么。无论我在解释数据方面有多好，我都必须知道我们的数据来自哪里，以及我们为什么要使用它。在课堂上，我们学习了这些过程的基本原理。这让我想到了如何利用数据来改善它。甚至面团课程根本不是关于数据科学。

3.信息管理

在这堂课上，我第一次听到了愿景和使命这两个术语。我喜欢与朋友和家人讨论数据科学用例及应用。看来，如果你心中有一个愿景和使命，你可以更好地提出你的想法，尤其是那些朋友对数据科学一无所知。

4.ERP-系统研讨会

企业中几乎每一种数据都来自 ERP 系统。幸运的是，我们有机会与 ERP 系统合作，了解用户如何产生数据，你将作为一名数据科学家与之共事。不幸的是，我不感兴趣，因为不严格地说，我年轻和愚蠢。如果我再去那里，我会试着更好地理解它。尤其是人机交互，因为我认为数据质量差的原因与那些系统有关。

5.商业信息系统的体系结构

在这里，我学到了 ETL 和数据仓库的基础知识。学习 ETL 可以看作是我对数据科学的第一次体验。我说不清我现在要多长时间处理一次那些话题。如果你在一个处理大数据的部门工作过，我想你会知道的。可能有些同学没有。所以，请不要和我在 ERP 系统研讨会上犯同样的错误。仔细听着。如果你知道数据管理在一家公司是如何运作的，这将对你有很大帮助。

第二部分 MBA 的力量

在某个时候，我迷上了数据科学。我只选择了与这个领域相关的课程。不到一年，我参加了在线课程，参加了我的第一次 Kaggle 竞赛，学到了更多的统计学知识。我一边学习，一边在一家德国工程公司做数据分析师。

为了获得更多的经验，我决定以数据科学家的身份参加黑客马拉松。在我们完成最后的任务之前，我觉得自己已经准备好了。

"为我们公司创造另一种产品或品牌."

我以为他们会给我们一个数据集或更具体的任务，因为他们要求不同的职业，如商业大师，想法生成器，数据科学家等。我错了，我们没有具体的任务，他们要求我们不要太技术性的产品。即使我有一点失望，因为我有不同的期望，我试着保持开放的心态。我运用了我在第一部分描述的课堂知识以及我的工作和实习经历。

在获得第二名和四周的黑客生涯后，我决定再次努力提高我的商业技能。即使我仍然认为拥有像 Python 和 Linux 这样的强大技术能力是必不可少的，但我认为以下五个主题对于数据科学家来说是至关重要的。

6.商业策略

第一周过后，很明显，黑客马拉松的公司希望我们能推出一款符合他们战略的产品。对我来说，将我关于数据科学、机器学习和人工智能的想法与他们的战略联系起来是相当具有挑战性的。我希望我对如何使应用程序适应特定的策略有更强的感觉。

7.企业家精神

公司期望我们成为企业家，或者至少像企业家一样思考。我以前想过产品创意，但我不知道如何推销，如何评估这些创意。我的一个队友已经创业了。我对她对此的热情印象深刻。我试图用这种热情作为动力。即使我没有发明一个创业公司，感觉像一个企业家也很有趣。对我来说，快乐是事业成功最重要的因素。

8.领导力

倾向于创新、发明、有独特观点和敏锐思维的人是理想的管理者。至少在 90 年代是这样。

这是电视节目《如何在网上快速销售毒品》中的一句话这很有趣，但我认为有一些隐藏的真相。在我们的黑客马拉松小组中，我们总是不得不处理争论和误解。我认为学习领导力是非常重要的。如果我想到现代经理，我会想到教练。此外，我认为当教练很难，所以我必须尽快努力。

9.颠覆性技术

我已经对颠覆性技术想了很多。与此同时，我了解到了解技术是一回事，但另一件事是看这将如何改变一个市场。我希望我将来能更好地理解这种关系，以知道如何使用一种特定的技术。

10.数字营销

有一个好主意是不够的。你必须说服你的利益相关者。当我还是一名软件工程实习生时，我对消费者沟通的工作方式有了第一印象。在黑客马拉松上，我了解到这个领域正在成长。最好能知道如何在网上销售和展示你的产品。否则，自己推出任何产品都是不可能的。我对我的队友们的熟练程度印象深刻，甚至他们中的一些人拥有完全不同领域的博士学位。

图片来自power MBA

我将在参加 PowerMBA 课程的同时从事这些领域的工作。我不能说这门课程是否符合我的期望。到目前为止，我有一种强烈的感觉，这将是有益的，并鼓励你看看这些领域。只要你迈出进步的第一步，你选择哪门课程进入这个领域并不重要。

摘要

我很高兴在开始学习数据科学之前，我有机会学习知识管理、信息管理和 ERP 系统。我认为你在职业生涯的哪个阶段并不重要；更多地了解我所介绍的领域是有益的。我也很高兴我有机会在黑客马拉松上遇到一些人，他们向我展示了一个优秀的数据科学家也是多面手。他们欣赏我已经掌握的知识，并鼓励我在商业战略、企业家精神、领导力、颠覆性技术和数字营销技能方面努力。我相信，如果你认为自己非常擅长数据科学，你也应该看看这些主题。还是那句话，好并不是对每个人都一样。但是如果你不想提高你的技能，我仍然希望这能给你一些启发。

感谢您阅读这篇文章。如果你喜欢它，请鼓掌或留下评论。我感谢任何反馈。有兴趣也可以看看我的 网站 。

您需要可靠数据质量的 10 个理由

原文：https://towardsdatascience.com/10-reasons-why-you-need-reliable-data-quality-84655974debf?source=collection_archive---------86-----------------------

好的、坏的和丑陋的

在这个数据驱动的时代，组织希望利用数据来提高业务效率和有效性。所有级别的决策都是通过使用 BI 和高级分析工具做出的，这些工具提供的数据越好，产出越多，从而创造机会、产生更多收入并提高运营绩效。

垃圾输入垃圾输出——如果你想分析的数据不准确，那么它就没有用

照片由弗兰基·查马基在未拉什拍摄

以下是您需要保持数据质量有序的 10 个原因:

1.更好的战略决策—数据质量越高，您从中受益就越多。在数据驱动的组织中，您对自己的决策更有信心，风险也可以降低

2.更好的定位和客户管理——使营销工作更加高效。如果你的客户数据是干净的，你的目标受众更适合，销售活动可以战略性地规划，以满足客户的需求。同时，找到与你已经拥有的客户有相似属性的客户要容易得多

3.改进的 CRM —随着您对客户的了解，您的营销内容现在可以更有针对性。你可以创建精确的推荐系统和模式，可以帮助你识别你最有价值的客户和更渴望离开的客户

4.竞争优势—数据是一种资产，应该作为一种资产来获取可以带来优势的见解。一个更成熟的公司可以利用它来寻找新产品和客户的关键机会。

5.法规遵从性—降低因不遵守法规而被罚款的风险。利用成熟的客户主数据功能，可以简化个人信息的保护。这通常是为了避免成本，例如，根据 GDPR，保护个人信息的最高罚款为全球收入的 4%。与黑名单上的客户或材料进行交易的成本也很高

6.降低运营成本—在拥有多个入口点的大型组织中，保持数据一致性至关重要。在分析和满足客户需求时，一致的数据有助于让公司的每个职能部门保持一致。

7.消除重复工作——如果您的输入不规范，将导致重复工作，并增加维护同一记录两次的成本。

8.消除不必要的行动——在审查一位客户的数据时，估计有 20%的直邮广告发送到了错误的地址，每封邮件的成本为 1 美元。对于一家每年邮寄数百万封邮件的公司来说，这造成了大量的浪费

9.生产力—良好的数据质量使分析师能够提高效率，并且在创建仪表板时不会在数据清理过程中浪费太多时间。随便问一个分析师，试图从肮脏的数据中获取某些东西有什么痛苦。

10.声誉——它可以是日常的小损失，组织可能永远不会意识到大的公共关系灾难。改善客户体验的努力也可能被不良数据破坏，导致向客户发送包含错误信息的通信。从更大的角度来看，银行业的不良数据可能会影响 KYC 和尽职调查的工作，可能会导致与受制裁或可疑机构的无意交易，从而导致除惩罚性罚款之外的公关后果。

订阅并关注我的 twitter ，了解数据质量主题。

原载于 2020 年 5 月 26 日。

初创公司拥有令人敬畏的工作文化的 10 个迹象

原文：https://towardsdatascience.com/10-signs-a-startup-has-awesome-work-culture-90d7aa25e3a5?source=collection_archive---------32-----------------------

如何找到一家能够培养你的数据科学事业和精神的创业公司

布鲁克·卡吉尔在 Unsplash 上的照片

数据科学家需求量很大。因此，在寻找工作的公司时，你可以有点挑剔。即使你正在寻找你的第一份数据科学工作，我也要提醒你不要盲目接受你收到的第一份工作。做好功课，确保这家公司非常适合你是非常重要的。

显然，有许多不同类型的公司可能会聘请数据科学家，但对于这个故事，我将重点关注初创公司。我将详细说明我用来识别一家初创公司是否是一个健康的工作环境的标志。我希望这些想法能帮助你在下一次在创业公司找工作时做出正确的决定。

有趣且具有挑战性的工作

对我来说，这不言而喻。

在我下面提供的建议中，我假设你正在考虑的创业公司已经向你证明了你对那里的工作感兴趣。我还认为这份工作会挑战你的职业发展。

因为让我们面对它，如果你没有有趣的和具有挑战性的数据问题要处理，那么所有其他的对一个数据科学家来说都是有点浪费的。

金钱不是万能的

钱是许多人用来决定他们将接受哪份工作的一个明显的因素。然而，金钱不是一切，你的薪酬也不会让你长期快乐。一旦你有足够的钱去过你选择的生活方式，更多的钱不会对你的生活产生巨大的影响。

这并不是说你应该接受没有竞争力的薪水。你想被你工作的公司重视！

不要被闪亮的创业津贴分心

额外津贴是很好的，但是对我来说不是成功就是失败。

许多初创公司为员工提供额外津贴，以吸引和留住最优秀的人才。这些可以是任何东西，从免费午餐到颈部按摩。很多都是有用的，比如交通补贴。其他人似乎更轻浮，但仍然可以很有趣。

然而，我会建议你在决定你想在哪里度过你的时间时，看得更深一点。想到在有如此丰厚福利的地方工作可能会令人兴奋，但要确保在那里工作也会让你快乐。

我寻找的东西

下面的列表是我在未来的创业公司中寻找的东西。它是基于我所重视的和我所知道的能让我快乐的东西。你可能对我有不同的价值观，但希望这些想法能帮助你辨别一家初创公司是否符合你的价值观。

1. 透明度
2. 灵活性
3. 工作生活平衡
4. 伟大的首席执行官
5. 共享信用文化
6. 授权
7. 良好的公司政策
8. 对人的投资
9. 关注人体工程学
10. 有趣的传统

1.透明度

透明度对不同的人来说可能意味着很多不同的东西。对我来说，这意味着领导团队鼓励开诚布公的谈话。特别是，他们支持员工询问有关公司方向、资金和工资的问题。

我真的很讨厌有人试图欺骗我的感觉。这就是透明度对我如此重要的原因。如果期望员工像旅鼠一样盲从，那么我知道创业公司不适合我。

首席执行官和公司领导层真的可以为初创公司分享多少信息定下基调。

当我在一家初创公司工作时，他们会定期召开领导务虚会。在这些务虚会上，将决定公司下一季度的方向。务虚会结束后的星期一上午，将安排一次全公司会议。这样，决策可以直接传达给团队的每个成员。能够就创业的方向向领导团队提出问题并提供反馈，这是一种授权。

通常，领导力撤退会在产品转向之前进行。我喜欢公司提供他们做出决定的原因，这样我们就能理解他们的想法。

有效透明度的另一个例子是在一家公司，首席执行官会定期就启动资金和股票期权如何运作举行研讨会。我发现其中一个研讨会的内容特别丰富，它讨论了最新一轮融资以及对员工股票期权的影响。我发现了解融资如何稀释每一种股票非常有趣。

这让我更有信心，因为首席执行官把公司和员工的最佳利益放在心上，因为他花时间向我们解释这些概念。此外，他还谈到了初创公司接受不同轮次融资的原因。这真的让我大开眼界，了解了旧金山的初创公司是如何运作的。

另一个层次的透明度是公开所有员工的工资。我从来没有实际经历过这一点，但理论上我认为这是一个理论上的好主意。

有些初创公司有一个职位列表，上面列有每个职位的薪酬。这样就有了完全的透明度，他们可以避免很多工资不平等的问题。

唯一的问题可能是，这些公布的工资是否没有足够的竞争力来吸引顶级数据科学家。但从好的方面来看，如果你真的决定创办一家薪酬公开的公司，那么你就不必担心工资谈判了。

2.灵活性

一些创业公司会让员工在适合他们的时间工作。通过让团队成员设定自己的工作时间，人们可以以最大化效率的方式工作。

早起的鸟儿可以在太阳升起的时候就出发，但要及时回家去接孩子放学。而夜猫子可以睡懒觉，工作到很晚，一直工作到深夜。

不同的人在一天的不同时间自然会工作得更好。就我个人而言，我总是觉得我在中午之前工作得最好。同样，不同的人有不同的家庭生活，这可能会给他们的时间带来不同的压力。

显然，他们仍然需要履行作为员工的所有承诺，比如参加会议。然而，通过允许灵活性，创业公司可能能够从他们的团队获得更好的工作质量和数量。在我之前关于旧金山初创公司的数据科学家的一天的故事中，我谈了更多关于弹性工作时间表的内容。

实行弹性工作制的初创公司的另一个巨大优势是，许多员工可以协商在家里工作，有时甚至是全部时间。在我看来，有些讨论最好当面进行，但我一直很喜欢为那些允许至少部分时间在家工作的公司工作。

此外，让员工在家工作的灵活性意味着，如果人们感到不舒服，他们可以离开。如果人们只是流鼻涕，正常情况下他们可能会想继续工作。然而，如果他们有在家工作的选择，那么如果他们没有不舒服到需要请一天病假，他们仍然可以呆在家里。这样他们就不会在整个公司传播他们的疾病。

3.工作生活平衡

我听说过很多关于创业公司的可怕故事，他们把人用光，然后又把他们放回去。到目前为止，我还没有这样的经历，但我知道这种事情确实会发生。

为了避免有这种做法的公司，我寻找鼓励员工拥有良好工作生活平衡的创业公司。

从表面上看，这可能很难辨别一家公司。领导层可能会说，他们鼓励员工在生活中保持良好的平衡，但实际情况可能并非如此。

比如很多创业公司都有无限病假和假期政策。乍一看，这似乎是鼓励工作生活平衡的一个很好的指标。然而，许多实行无限休假政策的地方，如果员工真的休假，他们会感到内疚。如果员工从来没有真正休过假，那么，事实上，他们的生活没有很好的平衡。

判断一家初创公司在鼓励工作生活平衡方面是否有好的做法的一个潜在方法是与一些员工交谈。最好离开办公室去散散步，和一些你未来的队友进行一对一的交谈。希望他们会觉得很舒服，告诉你真相。或者，你可以问问周围的人有哪些有趣的旅行，看看是否鼓励人们抽出时间去旅行。

4.伟大的首席执行官

一个伟大的 CEO 对任何创业公司的成功都是如此重要。但是你如何发现一个呢？

我认为优秀 CEO 的一个重要标志是，他们是否有前一家创业公司的员工追随他们。这表明，在他们以前的努力中，他们在周围的人中赢得了足够的信任和善意，这些人愿意再次为他们工作。也说明他们是一个有经验的 CEO。

这方面的一个例子是，当我在一家初创公司工作时，那里的首席执行官成功地卖掉了他以前的公司。我知道他一定对他的员工做了正确的事情，因为他们中的一些人跟着他。他们分享了他出售前公司的好处。

这是对他能力的信任票。人们选择再次为他工作，尽管该公司专注于解决一个完全不同的技术问题。

5.共享信用文化

我认为，你可以通过在面试中问几个关键问题来判断一家初创公司是否有分享信用的文化。如果您对他们的一些数据科学项目感兴趣，您可以询问负责这项工作的数据科学团队的不同成员。你可以从他们的回答中判断出这家初创公司是否有慷慨贷款的文化。

每个人都想感觉自己工作做得很好，但以我的经验来看，只有那些已经感受到被欣赏的人，才会愿意分享出色工作的荣誉。

对我来说，我工作过的一些地方和分享荣誉的方式形成了鲜明的对比。

在一个地方，人们对自己的职位没有安全感，因此会觉得有必要为自己辩护，并确保他们所做的工作得到表扬。相反，在另一家公司的会议上，人们总是很快对他们的同事在协作工作中做出的任何贡献给予支持。

后者是一个更好的工作场所，因为如果你犯了一个错误，同事们都很乐意帮助你，而不是把你扔到公共汽车底下。我个人认为，这与公司领导团队和个别部门主管对团队成员的出色工作给予了大量认可这一事实有关。

6.授权

我认为，让创业团队的所有成员都感到自己被赋予了权力，这一点极其重要。

赋权可以通过多种方式实现，但我认为特别重要的一种方式是鼓励投入。

如果员工可以说出他们对产品的任何想法，他们可能会感到被授权。如果公司有既定的方式让员工提交想法，那就更好了。这样他们就可以被公司领导团队考虑。

我工作过的一个地方设立了一个特殊的电子邮件地址，这样公司里的任何人都可以通过电子邮件向产品团队提出想法。然后，他们会将这些想法筛选到票务系统中，并在为此目的召开的定期产品会议上加以考虑。这使得公司的每个人都觉得如果他们有好的想法，他们就有权力影响产品开发的方向。

授权在创业公司中的另一个重要方面是管理风格。没有什么比微观管理者更让我讨厌的了。

因此，在面试工作时，我总是会问数据科学团队的负责人，他们有什么样的管理风格？其他团队成员也可以就你未来的老板如何管理他们的直接下属提供见解。

这样你就能知道，如果你加入公司，你是否会被信任，可以独自继续工作，或者你的主管是否会一直在你身后徘徊。

7.良好的公司政策

好的公司政策对你和我来说可能有不同的意义。然而，我所寻求的一些东西是平等机会政策、良好的产假政策、良好的病假政策和充分的假期政策。

我之前工作过的一家初创公司在营销团队的一名成员怀孕时没有产假政策。她需要实现一个，以便在她有孩子的时候能够使用它。我认为，如果他们在此之前就考虑到产假政策，情况会好得多。

不过，能参与制定直接适用于她的政策还是不错的。她能够修改它，以包括她认为重要的附加元素。然而，她确实告诉我，试图让新政策及时实施有点压力。

如果你想请一天假，一些工作场所要求你开一张病假证明。这就像你必须证明你真的生病了。对我来说，这表明缺乏信任。相反，我认为更好的办法是鼓励员工在需要的时候休假，这样他们就可以在生病时更快地康复。

在一家初创公司，我是一名数据科学家，那里的医疗总监制定了非常具体的疾病政策。该政策的一部分是，如果员工需要一盒纸巾，他们就不允许来上班。这家公司真的想鼓励员工在生病时呆在家里，这样整个公司都不会染上疾病。这个团队很小，所以如果流感在办公室蔓延，产品开发就会陷入停滞。

如果我不确定自己是不是生病了，可以灵活地呆在家里工作，这真是太好了。如果我认为我生病了，我通常会休息半天，然后在下午工作。我们不必具体说明这是不是一个生病的日子，只要告诉我们的经理，我们觉得有点不舒服。然后我们可以做我们认为合适的或多或少的工作。一切都来自于我们舒适的睡衣。

8.对人的投资

我喜欢为那些愿意投资员工教育和职业发展的创业公司工作。这是创业公司的领导层让他们的团队感到被重视的另一种方式。此外，提升技能并留住他们宝贵的人才符合公司的最大利益。

对于许多创业公司来说，工资是业务中最昂贵的方面之一。因此，如果投资于这些人的技能发展，对每个人都有好处。如果人们可以在同一家创业公司发展职业生涯，他们更有可能留下来。从而保留他们学到的所有公司知识。

许多数据科学团队有时间和金钱来参加会议、参加研讨会或继续研究与其工作相关的主题。这样，如果员工知道有发展的潜力，他们就不太可能对自己的职位感到厌倦或不满足。这是你在面试中很容易问到的问题。

9.对人体工程学的强调

这可能看起来琐碎无聊，但是人体工程学很重要。从长远来看，如果你选择在一家重视人体工程学的公司工作，你的身体会感谢你的。

如果你打算把职业生涯的大部分时间花在数据科学家身上，你将会花很多时间在电脑前工作。所以，想要在事业上有长进，就需要照顾好自己。如果你忽视良好的人体工程学，很可能你最终会患上重复性劳损(RSI)，颈部和可能的背部疼痛。

然而，如果你小心谨慎，并遵循人体工程学的最佳实践，你可能能够避免这些问题。许多创业公司会让你选择你喜欢的办公桌布置。这可能包括您使用的计算机类型，也包括外部屏幕、鼠标和键盘。

在我加入第一家创业公司之前，他们问我希望他们提供什么设备给我使用？我当时没有任何想法，但 CTO 建议我考虑一下，然后回复他。幸运的是，我咨询了一位职业治疗师朋友，得到了一些很好的建议。因为这个建议，我得到了适合我情况的最好的键盘和鼠标。因此，到目前为止，我已经能够避免我上面提到的许多问题。

许多创业公司现在为他们的办公室提供坐式和立式办公桌。它们可以是电子的，也可以有曲柄系统，这样你就可以在一天中升高或降低你的桌子。有人建议我，每小时尝试站立 5-10 分钟是个好习惯。

我没有必要每天、每小时都做到这一点。但至少我知道目标是什么。即使我不能像应该的那样经常站着，我也会确保休息一下，在办公室周围散散步。泡杯茶是我的一种习惯，让自己保持运动，而不是停留在同一个位置。很高兴知道我工作的初创公司真的关心他们的员工和他们的健康。

10.有趣的传统

你知道他们怎么说只工作不玩耍。

工作中的奇思妙想可以大大减轻工作中的情绪。许多创业公司都有自己各种有趣的传统。我认为最主要的是这些传统是包容性的，不会疏远任何个人。

例如，一些创业公司有欢乐时光扑克之夜。如果所有想留下来享受快乐时光的员工都喜欢玩扑克，那当然很好。然而，这可能不是每个人都喜欢的。

我工作的一家初创公司就是这种情况。他们的解决方案是购买各种各样的棋盘游戏，这样每个人都更愿意加入进来。

同样，在同一家公司，我们经常下班后出去喝酒。少数人不喜欢酒，也不喜欢饮酒文化。为了确保这些人也觉得他们可以加入进来，办公室经理会在室外场地安排欢乐时光，那里有不喝酒的人也会喜欢的其他选择。

例如，我们经常去旧金山 Embarcadero 的渡轮大厦，那里有一个喝啤酒的好地方。就在隔壁是这个城市最好的冰淇淋店之一。这样，每个人都可以得到他们想要的东西，并有归属感。

我们的另一个有趣的传统是，每当团队成员去度假时，他们被鼓励带回他们能找到的最丑的杯子。对于公司来说，这是一个很好的方式来表明他们希望人们利用他们的无限假期政策。此外，任何人都可以参与其中，并从中获得一点乐趣。

我们收藏的一些马克杯甚至不实用😜那有加分！

我们从员工假期开始收集丑陋的马克杯

我在创业公司经历的其他伟大传统是公司外的。这些团队建设活动可能看起来很庸俗，但我认为它们总是能起到让团队更加团结和鼓励交流的预期效果。

结论

我希望这些关于如何发现一家拥有健康文化的伟大创业公司的建议对你有用。有毒文化确实存在于一些初创公司，这些想法可能有助于你在数据科学职业生涯中避免它们。如果你在一个你感觉不到重视、欣赏和信任的地方工作，我会鼓励你利用这些建议开始寻找其他地方。每个人都应该在工作中感受到力量和受欢迎。

除了数据，我的另一个爱好是绘画。你可以在 www.katemarielewis.com 找到我的野生动物艺术

[## 如何将一个数据科学项目从想法变成产品

回答了我最喜欢的数据科学面试问题之一

towardsdatascience.com](/how-to-take-a-data-science-project-from-idea-to-production-8216a653011f) [## 我如何在 6 个月内从零编码技能成为数据科学家

我用来自学数据科学的 4 个工具没有花一美元

towardsdatascience.com](/how-i-went-from-zero-coding-skills-to-data-scientist-in-6-months-c2207b65f2f3)

蟒蛇神的 10 个流畅蟒蛇招数

原文：https://towardsdatascience.com/10-smooth-python-tricks-for-python-gods-2e4f6180e5e3?source=collection_archive---------1-----------------------

使你的 Python 代码个性化和更好的 10 个技巧

(Python logo src = http://python.org/)

虽然从表面上看，Python 似乎是一门简单的语言，任何人都可以学习，而且确实如此，但是当人们知道自己对这门语言的掌握程度时，可能会感到惊讶。Python 是很容易学习，但是很难掌握的东西之一。在 Python 中，做事情通常有多种方式，但是很容易做错事情，或者仅仅因为不知道模块的存在而重新创建标准库并浪费时间。

不幸的是，Python 标准库是一个巨大的怪兽，而且，它的生态系统绝对大得可怕。尽管可能有 200 万千兆字节的 Python 模块，但是您可以从 Python 中通常与科学计算相关的标准库和包中学习一些有用的技巧。

№1:反转字符串

虽然这看起来很简单，但是用 char 循环反转一个字符串可能会很乏味和烦人。幸运的是，Python 包含了一个简单的内置操作来执行这项任务。为此，我们只需访问字符串中的 indice ::-1。

a = "!dlrow olleH"
backward = a[::-1]

№2:变暗作为变量

在大多数语言中，为了将一个数组放入一组变量中，我们需要迭代地遍历这些值，或者按位置访问 dim，如下所示:

firstdim = array[1]

然而，在 Python 中，有一种更酷、更快的方法可以做到这一点。为了将值列表转换为变量，我们可以简单地将变量名设置为与数组相同的长度:

array = [5, 10, 15, 20]
five, ten, fift, twent = array

№3:迭代工具

如果你打算花点时间在 Python 上，你肯定想熟悉 itertools。Itertools 是标准库中的一个模块，可以让你不断地进行迭代。它不仅使编写复杂的循环变得容易得多，还使您的代码更快、更简洁。这里只是使用 Itertools 的一个例子，但是有上百个例子:

c = [[1, 2], [3, 4], [5, 6]]
# Let's convert this matrix to a 1 dimensional list.
import itertools as it
newlist = list(it.chain.from_iterable(c))

№4:智能拆包

迭代解包值可能相当密集和耗时。幸运的是，Python 有几个很酷的方法可以解包列表！一个例子是*，它将填充未赋值的值，并将它们添加到变量名下的新列表中。

a, *b, c = [1, 2, 3, 4, 5]

№5:枚举

如果你不知道枚举，你可能应该熟悉它。枚举将允许你获取列表中某些值的索引。当处理数组而不是数据框时，这在数据科学中特别有用。

for i,w in enumerate(array):
    print(i,w)

№6:命名切片

在 Python 中分割列表非常容易！有各种各样很棒的工具可以用来做这件事，但是有一个很有价值的工具是给你的列表命名的能力。这对于 Python 中的线性代数尤其有用。

a = [0, 1, 2, 3, 4, 5]
LASTTHREE = slice(-3, None)
slice(-3, None, None)
print(a[LASTTHREE])

№7:将相邻列表分组

在 for 循环中，对相邻循环进行分组当然很容易，尤其是通过使用 zip()，但这肯定不是最好的方法。为了使事情变得简单和快速，我们可以用 zip 编写一个 lambda 表达式，将我们的相邻列表分组如下:

a = [1, 2, 3, 4, 5, 6]  
group_adjacent = lambda a, k: zip(*([iter(a)] * k)) 
group_adjacent(a, 3) [(1, 2, 3), (4, 5, 6)] 
group_adjacent(a, 2) [(1, 2), (3, 4), (5, 6)] 
group_adjacent(a, 1)

№8:发生器的下一次()迭代

在编程中的大多数正常情况下，我们可以通过使用计数器来访问一个索引并获得我们的位置号，它只是一个加到:

array1 = [5, 10, 15, 20]
array2 = (x ** 2 for x in range(10))
counter = 0for i in array1:# This code wouldn't work because 'i' is not in array2.
   # i = array2[i]
    i = array2[counter]
#    ^^^ This code would because we are accessing the position of i

然而，我们可以使用 next()来代替它。接下来使用一个迭代器，它将我们当前的位置存储在内存中，并在后台遍历我们的列表。

g = (x ** 2 for x in range(10))
print(next(g))
print(next(g))

№9:计数器

标准库中另一个很棒的模块是集合，今天我要向大家介绍的是集合中的计数器。使用计数器，我们可以很容易地得到一个列表的计数。这对于获取数据中值的总数、获取数据的空计数以及查看数据的唯一值非常有用。我知道你在想什么，

“为什么不用熊猫呢？”

这当然是一个有效的观点。然而，使用 Pandas 来实现这一点肯定会更加难以自动化，这也是您在部署算法时需要添加到虚拟环境中的另一个依赖项。此外，Python 中的计数器类型有很多 Pandas 系列没有的特性，这使得它在某些情况下更加有用。

A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7]) 
A Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1}) 
A.most_common(1) [(3, 4)] 
A.most_common(3) [(3, 4), (1, 2), (2, 2)]

№10:出列

集合模块的另一个优点是出列。看看我们可以用这种类型做的所有巧妙的事情！

import collections
Q = collections.deque() 
Q.append(1) 
Q.appendleft(2) 
Q.extend([3, 4]) 
Q.extendleft([5, 6]) 
Q.pop()
Q.popleft()
Q.rotate(3) 
Q.rotate(-3)
print(Q)

结论

现在你知道了，这些是我一直在使用的一些我最喜欢的 Python 技巧。虽然其中一些可能用得不多，但这些技巧往往非常通用和有用。幸运的是，标准库函数的 Python 工具箱肯定不会开始变得光秃秃的，而且里面肯定有更多的工具。很可能有一些我甚至不知道，所以总是有一些令人兴奋的东西要学！

2020 年机器学习项目的 10 个阶段(以及你适合的阶段)

原文：https://towardsdatascience.com/10-stages-of-a-machine-learning-project-in-2020-and-where-you-fit-cb73ad4726cb?source=collection_archive---------2-----------------------

了解机器学习相关项目涉及哪些阶段，并深入了解每个阶段相关的可交付成果和工作角色。

机器学习的阶段

介绍

随着领域和技术本身的发展，机器学习项目中涉及的阶段和工作流也在不断发展。

支持 GPU 的移动设备的出现在传统的 ML 项目工作流程中引入了一个新的阶段。新阶段的出现也创造了新的角色和职称。

本文旨在:

1.详细解释机器学习项目中涉及的每个阶段。

2.提及每个阶段涉及的角色。我还在 LinkedIn 上添加了每个职位在美国的求职链接。

3.通知您每个阶段后交付的最终结果(这些被称为可交付成果)。

让我们开始吧。

1.问题定义

由 Austin Distel 在 Unsplash 上拍摄

问题定义是计算机视觉/ML 项目的初始阶段，它集中于获得对准备通过应用 ML 来解决的问题的理解。

它通常包括一个问题描述符，它以一种选定的形式记录了遇到要解决的问题的第一手经验的基于场景的描述。

这一阶段还从问题描述者的角度捕捉问题的理想解决方案。

问题描述者可以是客户、顾客、用户或同事。

本阶段的可交付成果为一份文档(word 或 pdf)，包括(但不限于):

1。问题陈述

②。理想问题解答

3。对问题的理解和洞察

4。技术要求

关联角色: IT 业务分析师

2.研究

威廉·艾文在 Unsplash 上的照片

此阶段为后面的阶段奠定了基础，同时也为后续阶段中执行的实施和开发工作奠定了基础。

对解决方案将采取的形式以及数据结构、格式和来源的信息进行了探索。

结合对问题的理解、建议的解决方案和可用数据，将使合适的 ML 模型选择过程能够实现理想的解决方案结果。

在这个阶段，研究算法和模型实现的硬件和软件要求是有帮助的；这在后期节省了很多时间。

此阶段的可交付成果是一份文档(word 或 pdf ),包括对以下内容的研究:

1。数据结构和来源

2。解决方案表单

3。神经网络/模型架构

4。算法研究

5。硬件要求

6。软件需求

关联角色:机器学习研究员，数据科学家， AI 研究员

3.数据聚合/挖掘/搜集

照片由 Sai Kiran Anagani 在 Unsplash 上拍摄

数据是 ML/CV 应用的燃料。数据聚合是为训练模型的有效性和性能建立先例的关键步骤。

达成一致的解决方案的输出定义了聚合的数据。

数据理解至关重要，任何来源的数据都应利用可视化工具或统计方法进行检查和分析。

数据检查通过确保数据源是预期的数据来提高数据的完整性和可信度。

对数据进行的数据分析和探索还确保满足以下要求:

• 收集的数据需要足够多样化，以确保模型预测能力能够适应各种可能的情况。
• 收集的数据需要力求无偏，以确保模型能够在推断过程中恰当地概括。
• 收集的数据需要丰富。

收集数据的工具会有所不同。数据源可以是 API、XML 提要、CSV 或 Excel 文件的形式。在某些情况下，需要从在线资源中挖掘/搜集数据。确保在进行刮擦之前检查第三方网站的刮擦/挖掘政策。

此阶段的可交付成果是一个文件夹，其中包含原始源数据以及每个子文件夹中的注释文件。

关联角色:数据科学家，数据分析师

4.数据准备/预处理/扩充

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

数据的预处理步骤主要基于模型输入要求。回到研究阶段，回忆所选模型/神经网络架构需要的输入参数和要求。

预处理步骤将原始数据转换成能够成功进行模型训练的格式。

数据预处理可包括以下确定的步骤，但不限于上述步骤:

• 数据重新格式化(调整图像大小、修改颜色通道、降噪、图像增强)
• 数据清理
• 数据标准化

数据扩充是一个步骤，旨在提高数据来源的多样性。图像数据的增强可以采取以下形式:

• 将图像旋转任意角度
• 缩放图像以创建放大/缩小效果
• 图像的裁剪
• 翻转(水平或垂直)图像
• 均值减法

此阶段的可交付成果是一个文件夹，其中包含标记为 train、test 和 validation 的子文件夹，以及每个子文件夹中的注释文件。

相关角色:数据科学家

5.模型实现

由凯文·Ku在 Unsplash 上拍摄

通常，通过利用可从各种在线来源获得的现有模型来简化模型实现。大多数 ML/DL 框架，如 PyTorch 或 TensorFlow ，都有预先训练好的模型，用于加速模型实现阶段。

这些预训练模型已经在稳健的数据集上进行了训练，并模仿了最先进的神经网络架构的性能和结构。

你很少需要从零开始实现一个模型。在模型实施阶段，预计将进行以下工作:

• 去除神经网络中的最后几层，使模型适应特定的任务。例如，移除 Resnet 神经网络架构的最后一层使得能够利用由编码器-解码器神经网络架构内的模型提供的描述符
• 微调预训练模型

此阶段的可交付成果是一个准备好接受训练的模型。

关联角色:数据科学家、机器学习工程师、计算机视觉工程师、 NLP 工程师、 AI 工程师

6.培养

来自 https://github.com/tensorflow/tensorboard的 tensor board UI

在训练阶段中利用从先前数据阶段传递的训练数据。模型训练的实现包括通过已实现的模型传递细化的聚集训练数据，以创建能够很好地执行其专用任务的模型。

所实现的模型的训练包括在指定数量的时期内反复地通过模型传递小批量的训练数据。在训练的早期阶段，模型的性能和准确性可能非常不显著。尽管如此，当模型进行预测并将预测值与期望值/目标值进行比较时，神经网络中会发生反向传播，模型开始改进，并在设计和实现的任务中变得更好。

就在训练开始之前，我们必须设置超参数和网络参数，这些参数将指导我们在模型上的训练阶段的有效性。

超参数:这些是在网络训练开始前定义的值；它们被初始化以帮助引导网络达到积极的训练结果。它们的作用在机器/深度学习算法上，但不受算法影响。他们的价值观在训练中不会改变。超参数的例子是正则化值、学习率、层数等。

网络参数:这些是我们网络中未被手动初始化的组件。它们是嵌入的网络值，由网络直接操纵。网络参数的一个例子是网络内部的权重。

进行培训时，确保记录每个培训过程和每个时期的指标至关重要。通常收集的指标如下:

• 训练准确性
• 验证准确性
• 培训损失
• 验证损失

为了整理和可视化培训指标，可以使用可视化工具 Matplotlib 和 Tensorboard。

通过可视化训练度量，可以识别一些常见的 ML 模型训练陷阱，例如欠拟合和过拟合。

• 欠拟合:当机器学习算法无法学习数据集中的模式时，就会出现这种情况。可以通过使用更适合该任务的更好的算法或模型来修复欠拟合。还可以通过识别数据中的更多特征并将其呈现给算法来调整欠拟合。
• 过度拟合:这个问题涉及算法预测呈现给它的模式的新实例，过于基于它在训练期间观察到的模式实例。这可能导致机器学习算法无法准确地推广到看不见的数据。如果训练数据没有准确地表示测试数据的分布，则会发生过度拟合。可以通过减少训练数据中的特征数量以及通过各种技术降低网络的复杂性来修复过拟合。

此阶段的可交付成果是开发的模型和培训指标

关联角色:数据科学家，机器学习工程师，计算机视觉工程师， NLP 工程师， AI 工程师

7.估价

混淆矩阵图片来自https://sci kit-learn . org/stable/auto _ examples/model _ selection/plot _ confusion _ matrix . html

在这个阶段，您应该有一个经过训练的模型，并准备好对其性能进行评估。

为了进行评估，我们利用了细化数据的一个分区，通常称为“测试数据”。在模型训练期间没有看到测试数据。它们也是预期在实际场景中遇到的数据示例的代表。

可以利用的评估策略的一些例子如下:

• 混淆矩阵(误差矩阵):提供对分类器结果的基本事实的注释的匹配或不匹配的数量的可视化说明。混淆矩阵通常以表格形式构造，其中行用来自地面实况的观察结果填充，列用来自分类器的推断结果填充。
• 精确召回:这些是用于评估分类算法、视觉搜索系统等的性能指标。以评估可视化搜索系统(基于查询图像查找相似图像)为例，precision 捕获返回的相关结果的数量，而 recall 捕获数据集中返回的相关结果的数量。

该阶段的可交付成果是包含评估结果的文件，也包括评估策略输出。

关联角色:数据科学家，机器学习工程师，计算机视觉工程师， NLP 工程师， AI 工程师

8.参数调整和推理

比尔·牛津在 Unsplash 拍摄的照片

参数调整是通过修改超参数值进行的模型改进过程。参数调整的目的是提高模型性能，这与评估结果的改进相关。

一旦超参数被调整并且新的值被选择，训练和评估再次开始。

执行参数调整的过程，直到产生足够合适的模型。

推理是对我们模型的真实测试。它包括利用来自适用环境的真实世界数据。在这个阶段，我们应该对我们的模型性能充满信心。

这个阶段的可交付成果是一个细化的模型

关联角色:数据科学家、机器学习工程师、计算机视觉工程师、 NLP 工程师、 AI 工程师

9.将模型转换为适当的移动格式

Patrick Michalicka 在 Unsplash 上拍摄的照片

一旦我们有了改进的模型，我们就可以把它放在可以使用的设备上。

当开发要在边缘设备(如手机或物联网设备)中使用的模型时，模型转换是一个必需的步骤。

模型转换涉及在 GPU/CPU 环境中训练的 ML 模型，并将它们转换成优化且高效的版本。流线型模型足够小，可以存储在设备上，并且足够精确，可以进行适当的推断。

支持将模型转换为移动优化模型的工具示例如下:

• Core ML :这是苹果发布的一个框架，用来打造 iOS 专用机型。CoreML 为常见的机器学习任务(如识别和检测)提供了一些模型。它是 TensorFlow Lite 的 iOS 专用替代产品。
• py torch Mobile:py torch 是一个流行的机器学习框架，广泛用于机器学习相关的研究。PyTorch mobile 可以与 TensorFlow Lite 相比较，因为它能够将 PyTorch 训练模型转换为移动优化版本，可以在 iOS 和 Android 设备上利用。虽然，PyTorch Mobile 还处于起步阶段，目前处于实验发布状态。
• TensorFlow Lite :取已有的 TensorFlow 模型，以. tflite 文件的形式将转换成优化的高效版本。流线型模型足够小，可以存储在设备上，并且足够精确，可以进行适当的推断。

本阶段的交付成果是一款针对设备使用进行了优化的 ML 模型。

关联角色:数据科学家，机器学习工程师，计算机视觉工程师， NLP 工程师， AI 工程师

10.模型部署

由 SpaceX 在 Unsplash 上拍摄的照片

部署我们最终训练好的模型是所有确定阶段的最后一步。将我们的模型集成到一个更广泛的应用程序或工具生态系统中，或者简单地围绕我们的模型构建一个交互式 web 界面，是模型部署的一个基本步骤。

在生产环境中，还应该承担监控责任来评估模型的性能。这是为了确保模型表现足够好，并且仍然符合目的。

模型再训练和更新也是模型部署阶段中的一个过程。模型更新确保了我们的模型对于期望任务的可信性和可靠性。

此阶段的可交付成果可能如下:

1。型号性能监控系统

2。访问模型功能的 Web UI 界面

3。支持模型重新部署的持续集成管道

关联角色:关联角色:数据工程师、机器学习工程师、计算机视觉工程师、 NLP 工程师、 AI 工程师

希望你能从这篇文章中获得一些有用的信息。如果你喜欢这篇文章，并且想要更多，给我一个关注。

机器学习和数据科学项目的 10 步终极指南！

原文：https://towardsdatascience.com/10-step-ultimate-guide-for-machine-learning-and-data-science-projects-ed61ae9aa301?source=collection_archive---------33-----------------------

详细讨论构建您的机器学习和数据科学项目的最佳方法。利用这 10 个步骤建立任何 ML 或数据科学项目！

照片由 XPS 在 Unsplash 上拍摄

数据科学和机器学习项目是最有趣和最吸引人的工作。

最初，当我开始我的人工智能之旅时，我对我可以支配的巨大机会和项目着迷。

我很兴奋，想把它们都做一遍。

然而，我会挑选一些这样的项目，一次开始一个，有时甚至一起开始，但是我很难找到成功完成它们的正确途径。

我发现大多数初学者也有类似的问题，并且在开始他们的项目时也在方向和组装上挣扎。为了以正确的方式构建您的项目，本文将介绍完整的路线图。

严格按照本文中编写的每一步来遵循给出的路线图是很重要的(除了少数例外)。类似于没有烹饪或订购就不能吃食物，没有实际构建就不能部署模型。

抛开这个类比，让我们来看看开发令人敬畏和酷的机器学习/数据科学项目的逐步过程。

1.问题陈述的选择和制定:

照片由🇸🇮·扬科·菲利在 Unsplash 拍摄

研究，研究，再研究。

对于任何机器学习或数据科学项目来说，最重要的一步是确保你脑海中有一个问题陈述。然后继续研究同样的问题。

选择你认为比你的技能水平高一小步的问题陈述。如果你只是一个开始数据科学之旅的初学者，那么选择一个稍微复杂的初级项目。让我们说一些简单的线性回归项目也应该足够了。

如果你已经完成了一些基本的初级项目，那么瞄准一些中级项目射高一点应该是个不错的主意。了解你的技能，并不断努力提高它们。

请一次做一个项目。确保你对你选择从事的项目做了广泛的研究，不要让自己不知所措。

同时，不要一开始就放弃。请记住，没有人，绝对没有人在第一次尝试时就能得到所有的东西。所以不要放弃，坚持下去，直到完成你的机器学习或者数据科学项目。

2.制定和策划您的计划:

在 Unsplash 上由 Austin Distel 拍摄的照片

既然我们对要实施的项目有了一个清晰的概念，那么制定相应的策略和计划是非常必要的。

我强烈推荐的一个策略是通过研究论文、谷歌搜索(尤其是关于谷歌学术的搜索)阅读更多，或者通过在线观看 YouTube 视频了解更多。

在进入下一步并开始项目的实际实施之前，获得更多关于项目的信息和知识总是更好的。

为要执行的每项任务和应用程序建立一个大概的估计。考虑计算过程可能需要的资源和时间的数量。而且不用担心，这个估计不需要 100%准确。

对于这一步来说，只需要简单地了解一下计划如何执行就足够了。

3.数据收集:

作者截图

分析您的计划后的下一步是收集一些数据，以便您可以开始实施您的数据科学或机器学习项目。

数据收集是在一个已建立的系统中收集和测量目标变量信息的过程，然后使人们能够回答相关问题和评估结果。

谷歌搜索显然是寻找新资源的最佳方式。Kaggle 为其举办的每个特定比赛提供了一些最佳数据和数据集选项。有时在 GitHub 上也可以找到非常有趣的数据集。

如果你正在寻找做一些自然语言处理项目，那么你也可以利用维基百科或其他类似的网站通过网络抓取来提取数据。

Data.gov 和 UCI 机器学习库是其他很棒的网站，它们提供了大量丰富的数据集选项。

如果你想知道上面的人脸数据集使用的图像，那么请随意访问我的另一篇文章，它涵盖了深度学习端到端项目。下面提供了链接。

[## 使用深度学习的人类情感和手势检测器:第 1 部分

了解如何从零开始构建具有深度学习的人类情感和手势检测器。

towardsdatascience.com](/human-emotion-and-gesture-detector-using-deep-learning-part-1-d0023008d0eb)

4.探索性数据分析:

作者截图

可视化是任何数据科学项目的一个重要方面。

在统计学中，探索性数据分析是一种分析数据集以总结其主要特征的方法，通常采用可视化方法。可以使用或不使用统计模型，但 EDA 主要是为了查看数据可以告诉我们什么，而不仅仅是正式的建模或假设测试任务。

探索性数据分析在数据科学和机器学习项目领域的作用是能够详细了解手头的数据。

探索性数据分析提供了许多图表和种类来可视化和分析可用的数据。它提供了对如何进一步发展的简要理解和想法。

pyplot 和 seaborn 是用于可视化和执行探索性数据分析任务的两个最佳库模块。

请随意通过下面提供的链接访问我的另一篇文章，这篇文章涵盖了深度学习端到端项目的第二部分。下面链接中的文章进一步详细介绍了探索性数据分析，这是一个现实生活中的问题，有助于更好地理解这个分步指南。

[## 使用深度学习的人类情感和手势检测器:第 2 部分

深入探究人类情感和手势识别

towardsdatascience.com](/human-emotion-and-gesture-detector-using-deep-learning-part-2-471724f7a023)

5.预处理数据集:

照片由 Unsplash 上的 battle creek 咖啡烘焙师拍摄

对数据集进行预处理是数据科学的精髓部分。

我们可用的数据可能并不总是“干净的”在此引用中，clean 的含义是对任务有用的选择性数据。在自然可用的数据中，有许多冗余必须被删除，以获得一个整体干净的数据集来处理。

数据预处理是数据挖掘过程中的一个重要步骤。“垃圾进，垃圾出”这句话特别适用于数据挖掘和机器学习项目。

数据收集方法通常控制松散，导致超出范围的值、不可能的数据组合和缺失值等。

为了简化自然语言处理任务，最好使用 python 中内置的正则表达式模块。有关这方面的更多信息，请参考下面提供的文章链接。

[## 4 个基本正则表达式操作符使自然语言处理变得更简单！

了解四种基本的常规操作，以清理几乎任何类型的可用数据。

towardsdatascience.com](/natural-language-processing-made-simpler-with-4-basic-regular-expression-operators-5002342cbac1)

熊猫模块必须高度重视浏览我们的数据集。正则表达式模块对于预处理也非常重要。

6.构建您的结构:

克里斯多夫·伯恩斯在 Unsplash 上拍摄的照片

预处理步骤完成后，下一步是为您计划构建的模型构建结构。

这一步可以代表各种事物。

如果你正在处理一个机器学习问题，那么你要确保你完成了所有必要参数的计算。

其他需求可以是变量的热编码、特征缩放或其他建模需求，如将数据相应地分割成训练、测试或验证、选择超参数、调整模型等。

决定将用于整体实施的整个结构和流程。设计您的建模方法并构建一个最终管道，您可以开始开发您的模型。

您还可以选择最适合当前任务的算法。这可以是简单的线性回归算法，也可以是复杂的深度学习方法。

现在让我们进入有趣的部分，即模型的开发。

7.开发您的机器学习或深度学习模型:

作者截图

在可视化、预处理和构造步骤之后，我们最终可以转移到开发模型的更有趣的部分。

为更好地完成任务设计合适的模型是机器学习和数据科学最重要的方面。

为特定任务选择正确的算法以及设计能够解决问题并证明是最佳方法的简明架构是极其重要的。

在机器学习中，无论是有监督的还是无监督的，你都有一堆选项可以选择。如果您有时间和资源，并且不太确定哪种算法执行得最好，您可以尝试所有算法，然后决定哪种模型最适合您的问题陈述。

在深度学习中，您可以通过顺序方法、功能方法或自定义方法构建一个架构，以从头开始构建您自己的自定义模型，或者您可以利用许多可用的迁移学习模型，并尝试简化您的任务。

模型的开发是最重要的一步，因为该模型将被训练、测试和部署。所以把这一步做好是极其重要的。

现在让我们进入培训阶段。

8.训练/拟合您的模型:

作者截图

一旦模型建立起来，我们就可以前进到培训步骤。

训练模型是为了确保我们找到一个几乎完美的拟合，具有较低的损失和较高的精度。这也是为了确保没有欠拟合或过拟合。

欠拟合是指构建的模型表现不佳，无法对事物进行相应的分类并按要求解决问题。

过度拟合是指模型拟合得非常好，甚至考虑了异常值和噪声点，导致预测任务不准确。

学习算法在训练数据中查找将输入数据属性映射到目标(您要预测的答案)的模式，并输出捕获这些模式的 ML 模型。您可以使用 ML 模型来预测您不知道目标的新数据。

基本上，训练模型仅仅意味着从标记的例子中学习(确定)所有权重和偏差的好值。

现在让我们看看如何执行测试和分析步骤。

9.测试和分析您创建的模型:

作者截图

随着模型的构建和拟合完成，我们需要测试和分析我们拥有的模型。

我们可以利用图表来验证这些测试，并确保模型按预期执行。对于机器学习项目，您可以借助 python 提供的 matplotlib 库制作自己的自定义图表。

但是，您可以利用 TensorFlow 中的 tensorboard 选项来验证和检查培训实施。

这些图表应该能够提供一个详细的方法来说明所构建的模型将如何执行。在部署您的模型之前，还可以通过使用 AB 测试的方法来做进一步的分析。

如果你有兴趣了解更多，请随时查看这篇关于下一个单词预测和创新聊天机器人的文章。

10.部署您的模型:

钳工对去毛刺拍照

部署阶段是构建任何模型的最后阶段。

一旦您成功地完成了模型的构建，如果您想自己保留它或部署它以便您可以面向更广泛的受众，这是一个可选步骤。

部署的方法各不相同，从将它部署为可以跨平台转移的应用程序，到使用 amazon 提供的 AWS 云平台进行部署，再到使用嵌入式系统。

如果你想部署像安全摄像头这样的东西，那么你可以考虑在摄像头旁边使用像 raspberry pi 这样的东西。如果您有兴趣了解更多关于面部识别的信息，以便只授予授权所有者访问权限，那么可以考虑下面提供的文章。

[## 智能面部锁定系统

建立高精度人脸识别模型

towardsdatascience.com](/smart-face-lock-system-6c5a77aa5d30)

有了所有这 10 个步骤，你应该准备好开始和完成你所有的数据科学或机器学习项目！

肖恩·奥·在 Unsplash 上拍摄的照片

结论:

在本文中，我们介绍了每个机器学习项目的逐步路线图和方法。

这些步骤中的每一步对于构建成功的数据科学或机器学习项目的完美架构都非常重要。

此外，必须按照上述相同的顺序执行上述每个步骤，选择性项目可能只有极少数例外。

总结一下所有涉及的步骤，确保在决定你的项目之前进行彻底的研究。然后在你开始实施你的项目之前制定一个计划。收集所有需要的数据，开始着手手头的工作。

执行探索性数据分析，以便对您拥有的数据和数据集有一个简要的了解。然后对数据进行相应的预处理，从构建结构开始。构建所需的模型并开始训练它们。

测试你训练过的模型，彻底分析。最后，您的模型现在应该可以部署了。部署您的模型以获得更广泛的受众。

看看我的其他一些文章，你可能会喜欢读！

[## OpenCV:用代码掌握计算机视觉基础的完全初学者指南！

包含代码的教程，用于掌握计算机视觉的所有重要概念，以及如何使用 OpenCV 实现它们

towardsdatascience.com](/opencv-complete-beginners-guide-to-master-the-basics-of-computer-vision-with-code-4a1cd0c687f9) [## 分步指南:使用 Python 进行数据科学的比例采样！

了解使用 python 进行数据科学所需的比例采样的概念和实现…

towardsdatascience.com](/step-by-step-guide-proportional-sampling-for-data-science-with-python-8b2871159ae6) [## 2020 年及以后最受欢迎的 10 种编程语言

讨论当今 10 种最流行的编程语言的范围、优缺点

towardsdatascience.com](/10-most-popular-programming-languages-for-2020-and-beyond-67c512eeea73) [## 带有完整代码片段和有用链接的 5 个最佳 Python 项目创意！

为 Python 和机器学习创建一份令人敬畏的简历的 5 个最佳项目想法的代码片段和示例！

towardsdatascience.com](/5-best-python-project-ideas-with-full-code-snippets-and-useful-links-d9dc2846a0c5)

谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！

Pandas 中处理 LAS 文件和绘图的 10 个步骤(第一部分)

原文：https://towardsdatascience.com/10-steps-in-pandas-to-process-las-file-and-plot-610732093338?source=collection_archive---------7-----------------------

我使用这些步骤来准备 LAS 格式的测井数据，以便用 python 绘图

测井 ASCII 标准(LAS)是石油和天然气行业存储测井信息的常用格式。测井是通过深度间隔测量的地下岩石的物理特性。有几个商业软件可以读取这种格式。LAS 查看器有时是免费的，但功能有限。如果你想实现数据分析或高级数学计算，你必须购买许可证。

下面列出我使用最多的步骤:
1)读取文件
2)数据检查
3)列选择
4)缺失数据
5)删除行
6)统计
7)过滤
8)添加列
9)索引
10)绘图

如果你想使用我的示例数据，你可以访问堪萨斯大学的免费数据集。下载 2019 年 8 月的压缩文件，解压到您最喜欢的硬盘中。然后将文件号 1050383876 复制到工作 Jupyter 笔记本目录中读取。你也可以直接从我的 Github 账户中获取本作品的全部 Jupyter 笔记本源文件和数据。

LAS 格式文件不能像熊猫那样用 python 中的通用库读取。首先我们需要安装 lasio lib。lasio 被编写为与 python 兼容，并且具有 NumPy 和 ordereddict 依赖。运行以下代码进行安装:

pip install lasio
pip install -r optional-packages.txt
pip install --upgrade lasio

1)读取文件

导入熊猫、numpy 和 lasio 后，按如下方式读取 LAS 文件:

import pandas as pd
import numpy as np
import lasiolas = lasio.read(r'1050383876.las')

lasio 有很好的特性，比如曲线可以在 LAS 文件的头部分显示日志信息。运行:

las.curves

使用这个命令，我们可以看到可用的曲线日志和基本信息，如文件中的单位和样本数据点数量。lasio 有其他功能，但我个人更喜欢将 LAS 文件转换成 pandas 数据帧，以获得其常用功能的优势:

df = las.df()    #store las file in df variable as pandas dataframe

2)数据检查

在 pandas 中使用 head() 函数，如果适合屏幕，我们可以看到 5 行和全部列。

df.head()

df.shape

数据帧有 17 个测井数据，列中有 7056 行作为深度间隔的采样点。我们可以认为井的较浅部分仅由 GR 记录，其余部分为空值。空值的 LAS 标准是-999.2500。

3)列选择

根据您的项目目的，您可以在数据集中选择不同的变量。首先，让我们看看这个文件中的可用日志:

df.columns

从这些日志中，我宁愿选择中子孔隙度、伽马射线、体积密度、声波、井径和计算声波孔隙度的列，并存储在一个新的变量中。请记住使用双括号，如下所示:

df_selected = df[['CNPOR', 'GR', 'RHOB', 'DT', 'MELCAL', 'SPOR']]

4)缺失数据

缺少值在 LAS 文件中非常常见，因为感兴趣的深度可能因具体测量而异。LAS 文件中打印的值-999.2500 表示空值。缺失值在数据集的中间部分并不常见。通常，它发生在文件的头部或尾部。 isna 函数如果位置有空值则返回 True，否则为 False。我们可以使用 sum() 函数将这些布尔值相加，如下所示:

df_selected.isna().sum()

假设我们希望将 GR、DT 和 SPOR 作为重要的日志保存在数据集中。因此，为了消除丢失的值，我们可以删除其中一个日志丢失的行。

5)删除行

df_dropped = df_selected.dropna(subset=['GR', 'DT', 'SPOR'],axis=0, how='any')

这行代码将删除一个(或多个)子集日志(' GR '，' DT '，' SPOR ')具有空值的所有行。

6)统计

运行描述命令查看数据统计。这有助于查看数据范围和异常值。

df_dropped.describe()

岩石的岩石物理性质有一个正常范围。超出该范围的读数不应视为有效。这些范围是:

将此表与我们文件的统计数据进行比较，可以看出我们有一些值超出了范围，我们可以过滤数据集。例如,“SPOR”的最大值是 162 %,而这在自然界是不可能的。

7)过滤

有几种方法可以过滤数据，比如 zscore。在这种方法中，我们可以去掉超出特定标准偏差范围(如 2 或更大)的值。我个人更喜欢高/低截滤波器，因为我可以控制最小值和最大值，如下所示:

df_filt1 = df_dropped.loc[(df_dropped.CNPOR > -15) & (df_dropped.CNPOR <= 50)]
df_filt2 = df_filt1.loc[(df_dropped.GR > 0) & (df_dropped.GR  <= 250)]
df_filt3 = df_filt2.loc[(df_dropped.RHOB> 1) & (df_dropped.RHOB<= 3)]
df_filt = df_filt3.loc[(df_dropped.DT > 30) & (df_dropped.DT <= 140)]

我们不需要过滤 SPOR，因为它是 DT 的函数。

8)添加列

有时我们需要使用现有的日志计算一个参数，并存储在单独的列中。让我们用最简单的等式来计算页岩体积:

df = df_filt.copy()      #make a copy of the latest dataset
df['Vsh'] = (df.GR - df.GR.min()) / (df.GR.max() - df.GR.min())

页岩体积作为名为 Vsh 的列添加。

9)索引

当我们读取 LAS 文件时，lasio 将深度列转换为索引。我们可以将深度称为绘制 aim 和重新索引数据集的新列。

df_idx = df.rename_axis('Depth').reset_index()
df_idx.head()

10)绘图

用 python 绘图是一个全面的讨论，但我将使用最简单的方法来可视化我的最终数据集。

import matplotlib.pyplot as plt

为了使代码可读和可重用，让我们定义一个函数:

def log_plot(logs):
    logs = logs.sort_values(by='Depth')
    top = logs.Depth.min()
    bot = logs.Depth.max()

    f, ax = plt.subplots(nrows=1, ncols=6, figsize=(12,8))
    ax[0].plot(logs.GR, logs.Depth, color='green')
    ax[1].plot(logs.CNPOR, logs.Depth, color='red')
    ax[2].plot(logs.DT, logs.Depth, color='black')
    ax[3].plot(logs.MELCAL, logs.Depth, color='blue')
    ax[4].plot(logs.RHOB, logs.Depth, color='c')
    ax[5].plot(logs.Vsh, logs.Depth, color='m')

    for i in range(len(ax)):
        ax[i].set_ylim(top,bot)
        ax[i].invert_yaxis()
        ax[i].grid()

    ax[0].set_xlabel("GR")
    ax[0].set_xlim(logs.GR.min(),logs.GR.max())
    ax[0].set_ylabel("Depth(ft)")
    ax[1].set_xlabel("CNPOR")
    ax[1].set_xlim(logs.CNPOR.min(),logs.CNPOR.max())
    ax[2].set_xlabel("DT")
    ax[2].set_xlim(logs.DT.min(),logs.DT.max())
    ax[3].set_xlabel("MELCAL")
    ax[3].set_xlim(logs.MELCAL.min(),logs.MELCAL.max())
    ax[4].set_xlabel("RHOB")
    ax[4].set_xlim(logs.RHOB.min(),logs.RHOB.max())
    ax[5].set_xlabel("Vsh")
    ax[5].set_xlim(logs.Vsh.min(),logs.Vsh.max())

    ax[1].set_yticklabels([]); ax[2].set_yticklabels([]);
    ax[3].set_yticklabels([])
    ax[4].set_yticklabels([]); ax[5].set_yticklabels([]) 

    f.suptitle('Well:KOOCHEL MOUNTAIN #1', fontsize=14,y=0.94)

像这样调用函数:

log_plot(df_idx)

结论

在这项工作中，我阅读了一口单井的 LAS 文件，其中包括几份岩石物理测井记录。转换为 pandas 数据框便于流畅地使用和处理。这些步骤可以以不同的顺序实现。

如果您喜欢其他方式，建议改进，或者对类似的数据集有一些困难，请留下评论！

在 Windows 上使用 VSCode 设置全面的数据科学工作空间的 10 个步骤

原文：https://towardsdatascience.com/10-steps-to-setup-a-comprehensive-data-science-workspace-with-vscode-on-windows-32fe190a8f3?source=collection_archive---------28-----------------------

VSCode 扩展。作者图片

要开始一个数据科学项目，选择一个有效的开发环境总是第一步。Jupyter 笔记本/实验室是常见的选择。我非常喜欢它。但是真的不够。

在我开始第一个专业数据科学项目的时候，我一起使用了很多工具:用于模型训练的 Jupyter Notebook，用于结构化 python 脚本的 PyCharm(免费社区版)，用于 Python 包管理的 Anaconda Prompt，用于远程 SSH 连接的 MobaXterm，用于原始数据审核的 Excel 等等。每天，我总是在不同的窗口之间跳来跳去。

幸运的是，我找到了一个支持以上所有功能的工具，最重要的是，它是免费的: VSCode 。

如果您正遭受与上述相同的问题，或者您是数据科学领域的初学者，本指南可能会帮助您构建自己的有效数据科学工作空间，并有一个良好的起点。

完成 10 个设置步骤后，在 VSCode 的单一窗口中，您将能够:

• 使用 Anaconda
• 编写结构化和可读的 python 脚本
• 使用 Jupyter 笔记本
• 管理 python 包和 conda 虚拟环境
• 通过 SSH 在远程服务器(例如 GPU 节点)上工作，界面非常用户友好
• 查看和编辑不同类型的文件(例如 txt，。csv，。xlsx，。png，。md，。yml，Dockerfile …)
• 使用 Git 版本控制
• 灵活应对未来的项目扩展，例如添加基于 Docker 的部署

现在，我们开始吧~🚀

**Overview of Contents**
Step 1: Install Anaconda
Step 2: (Optional) Create a Virtualenv in Anaconda Prompt
Step 3: Open VSCode
Step 4: Open Your Project Folder from VSCode
Step 5: Install Python Extension in VSCode
Step 6: Enable Your Virtualenv in VSCode
Step 7: Config the VSCode Terminal for 'conda' & 'python'
Step 8: Enable Jupyter Notebook in VSCode
Step 9: Connect to the Remote Server from VSCode via SSH
Step 10: Do Git Push in VSCode

【以下设置基于 win 10】

步骤 1:安装 Anaconda

你可以从这里安装最新版本，或者从这里安装存档版本。如果你准备使用 VSCode 中的集成终端，我强烈推荐你安装 Anaconda ≥ 4.6 的版本。

成功安装后，您还安装了 Jupyter Notebook、python 和一些用于数据科学的常见 Python 包。而且你现在可以在**中找到 蟒蛇导航器蟒蛇提示Jupyter 笔记本 图标。****

步骤 2:(可选)在 Anaconda 提示符下创建一个虚拟环境

为了避免不同项目之间的相互干扰，最好在隔离的虚拟环境中开发。如果你真的喜欢在默认的base env 中开发，你可以跳过这一步。

打开 蟒蛇提示 从 开始 菜单:

检查您当前的环境列表:

*conda env list*

创建自己的 virtualenv ，使用名称和指定的 python 版本(例如名称:ssl):

*conda create --name ssl python==3.6.4*

激活 virtualenv:

*conda activate ssl*

检查此 virtualenv 中存在哪些包(python 应该在 virtualenv 创建期间安装):

*conda list*

在 VSCode 中完成设置后，您可以在 VSCode 终端中直接管理您的 virtualenv。

更多康达环境管理，请查看此处。

步骤 3:打开 VSCode

选项 1: 从 首页 页面打开 巨蟒导航> 启动 VSCode 。

Anaconda Navigator 主页

选项 2: 也可以从网站安装 VSCode。这样，您可以获得一个快捷方式，然后从桌面或任务栏快速启动 VSCode。从我自己的经验来看，这种方式比方案一更快。

步骤 4:从 VSCode 打开项目文件夹

在您喜欢的任何地方创建一个新的项目文件夹作为您的根目录。打开 VSCode >点击左上方的 文件 点击 打开文件夹 >点击目标文件夹名称。现在，您可以将所有项目文件和脚本放在这里。

**

步骤 5:在 VSCode 中安装 Python 扩展

VSCode 是一个支持多种语言的源代码编辑器。为了启用 Python，我们需要安装 Python 扩展。

点击 扩展 图标在左栏>搜索 Python >点击 安装 :

现在，您可以简单地用.py文件扩展名创建标准的 python 脚本:

**

如果你也喜欢 helloWorld.py 前面可爱的 python 图标，可以通过添加vs code Great Icons扩展得到。它可以帮助您轻松区分不同类型的文件和文件夹:

步骤 6:在 VSCode 中启用您的 Virtualenv

在 VSCode 中，按ctrl+shift+p，中间上方会弹出一个命令面板。点击Python:Select Interpreter>你会看到一个包含你所有 virtualenv 和 base env >的列表选择合适的 virtualenv。

如果看不到Python:Select Interpreter，只需键入并搜索即可。

**

之后，带有 env 名称的 python 解释器将显示在状态栏的左下方:

步骤 7:为“conda”和“python”配置 VSCode 终端

点击左上方的‘终端’或快捷方式`ctrl+shift+``，打开一个新的 VSCode 终端。终端将在右下方打开。

根据您的个人偏好选择默认 shell(默认值:cmd):

**

如果你和我一样想在 Windows 上使用 Linux 命令，Powershell 是你不错的选择。

选中后，只需打开另一个新的终端来捕捉您的更新。如果您在上一步成功选择了 python 解释器，virtualenv 现在将通过conda activate在您新打开的终端中自动激活。并且 virtualenv 名称将显示在前面的**()**中:

现在，您可以通过以下方式在终端中执行.py文件

*python helloWorld.py*

💢你可能会遇到的两个常见错误:

1。无法在 Powershell 中运行conda activate。

解决方案:康达仅从 4.6 版本开始支持 Powershell 中的conda activate。因此，如果您想在 VSCode 中使用 Powershell 作为默认 shell，请确保您的 conda 版本至少是 4.6 或更高(在不同的 Windows 系统中可能会有所不同)

2。无法识别的术语错误当你在终端中运行conda或python解决方案:*通过在终端中运行下面的命令得到你的 python 和 conda 路径*

*where python
where conda*

将 python 和 conda 路径复制并粘贴到环境变量的路径:

步骤 8:在 VSCode 中启用 Jupyter 笔记本

安装包，其中包括笔记本、 qtconsole 和 IPython 内核 via**

**pip install jupyter
# or
conda install -c conda-forge jupyter**

创建新的 jupyter 笔记本文件:按ctrl+shif+p >搜索 创建新的空白 Jupyter 笔记本 >点击>保存创建的.ipynb文件并命名:

****

几秒钟后，右上方的 Jupyter 服务器 将自动设置为本地，而 内核 为步骤 5 中选择的 conda 环境。

如果没有，或者你想改变内核/env:按ctrl+shif+p >搜索 选择解释器启动 Jupyter 服务器 >点击它> 从显示的列表中选择一个合适的 env:

****

现在，你可以像往常一样使用 Jupyter 笔记本了:

步骤 9:从 VSCode 连接到远程 SSH 服务器

另一个我最喜欢的很棒的特性是远程 SSH 连接，它支持使用完整的 VSCode 特性集打开任何远程文件夹。

安装 远程 SSH 扩展:

然后，您会在状态栏的左下角看到一个小小的连接图标:

点击图标>选择 远程-SSH:连接主机… > 添加标准 SSH 连接命令ssh username@hostname >回车:

****

将会打开一个空窗口，自动设置远程 SSH 连接。连接后，您会在状态栏的左下方看到带有SSH:username@hostname的主机名:

现在，您可以在连接的远程机器上打开您的主目录下的任何文件夹，并像在本地一样使用它:

💢如果您在远程连接期间得到如下的 输入时 MAC 损坏 错误，您可以通过在ssh中添加可用的 MAC 加密算法来解决。我在这个故事里贴出了详细的步骤。

步骤 10:在 VSCode 中执行 Git 推送

VSCode 支持即时可用的 Git 版本控制，因此您可以用一种非常令人愉快的格式跟踪您的代码，并通过几次点击轻松地推送它。

如果您打开的文件夹在 git 存储库下，那么分支名称将显示在左下方，在 VSCode 中带有一个*****。更改文件的总数将在左边栏中显示 源代码控制 图标。

在下面的例子中，它在主分支中，有一个更改的文件处于未跟踪状态。

点击 源代码控制 图标>点击文件名>可以在比较视图中查看详细的代码变化:

点击文件后的**+**图标进行修改>在上面的框中添加提交消息>点击上面的✔提交:

然后一个同步更改操作将显示在状态栏中，带有一个小图标**1↑**，表示您还有 1 个提交尚未推送:

只需单击它即可推送所有已提交的更改。成功推送后，**1↑**指示灯将消失:

现在，您在 VSCode 中的数据科学工作区已经准备好了！

结论

VSCode 远比我上面分享的强大。有许多支持不同开发需求的多样化扩展。如果您对它们不熟悉，并且在开始时对大型扩展池感到有点困惑，下面的基本扩展可能会帮助您开始。继续努力吧！

****- Predawn Theme Kit**  # readable code
**- Sublime Text Keymap and Settings Importer** # readable code
**- Excel Viewer ** # preview csv file in excel format
**- Prettify JSON**  # parameter config
**- YAML**  # parameter config**

加速 Python 运行时的 10 种技术

原文：https://towardsdatascience.com/10-techniques-to-speed-up-python-runtime-95e213e925dc?source=collection_archive---------9-----------------------

用代码运行时比较好的写法和不好的写法

哈雷戴维森在 Unsplash 上拍摄的照片

Python 是一种脚本语言。与 C/C++这样的编译语言相比，Python 在效率和性能上有一定的劣势。然而，我们可以使用一些技术来提高 Python 代码的效率。在本文中，我将向您展示我在工作中通常使用的加速技术。

测试环境是 Python 3.7，macOS 10.14.6，2.3 GHz 英特尔酷睿 i5。

0.优化原则

在深入代码优化的细节之前，我们需要了解一些代码优化的基本原则。

1. 先确认代码能正常工作。因为让正确的程序更快比让快程序正确容易得多。
2. 权衡优化成本。优化是有代价的。例如，较少的运行时间通常需要更多的空间使用，或者较少的空间使用通常需要更多的运行时间。
3. 优化不能牺牲代码可读性。

1.Python 中正确的数据类型用法

1.1 用 set 替换 list 以检查元素是否在序列中

根据 Python 的 TimeComplexity 可知list的x in s操作的平均情况为 O(n)。另一方面，set的x in s运算的平均情况是 O(1)。

1.2 用 defaultdict 初始化字典

我们应该使用defaultdict进行初始化。

2.用生成器表达式替换列表理解

# Bad: 447ms
nums_sum_list_comprehension = sum([num**2 for num in range(1000000)])# Good: 300ms
nums_sum_generator_expression = sum((num**2 for num in range(1000000)))

生成器表达式的另一个好处是，我们可以在迭代之前获得结果，而无需在内存中构建和保存整个列表对象。换句话说，生成器表达式节省了内存使用。

import sys# Bad
nums_squared_list = [num**2 for num in range(1000000)]
print(sys.getsizeof(nums_squared_list))  # 87632# Good
nums_squared_generator = (num**2 for num in range(1000000))
print(sys.getsizeof(nums_squared_generator))  # 128

3.用局部变量替换全局变量

我们应该把全局变量放入函数中。局部变量比全局变量快。

4.避免点操作

4.1 避免功能访问

每次我们用.访问函数，都会触发特定的方法，像__getattribute__()和__getattr__()。这些方法将使用字典操作，这将导致时间成本。我们可以用from xx import xx去掉这样的成本。

根据技术 3，我们也可以将全局函数分配给局部函数。

此外，我们可以将list.append()方法分配给一个局部函数。

4.2 避免类属性访问

访问self._value的速度比访问局部变量慢。我们可以将 class 属性赋给一个局部变量来加快运行速度。

5.避免不必要的抽象

当使用额外的处理层(如 decorators、property access、descriptors)来包装代码时，会使代码变慢。在大多数情况下，需要重新考虑是否有必要使用这些层。一些 C/C++程序员可能会遵循使用 getter/setter 函数来访问属性的编码风格。但是我们可以使用更简单的写作风格。

6.避免数据重复

6.1 避免无意义的数据复制

value_list没有意义。

6.2 更改值时避免使用 temp 变量

temp是没有必要的。

6.3 连接字符串时，将+替换为join()

使用a + b串接字符串时，Python 会申请内存空间，将 a 和 b 分别复制到新申请的内存空间。这是因为 Python 中的字符串数据类型是不可变的对象。如果连接n字符串，将生成n-1中间结果，每个中间结果将申请内存空间并复制新字符串。

另一方面， join()会节省时间。它会先计算出需要申请的总内存空间，然后一次性申请所需内存，将每个字符串元素复制到内存中。

7.利用if语句的短路评估

Python 使用短路技术来加速真值评估。如果第一个语句是假的，那么整个事情一定是假的，所以它返回那个值。否则，如果第一个值为真，它将检查第二个值并返回该值。

因此，为了节省运行时间，我们可以遵循以下规则:

• if a and b:变量a应该有很大概率为假，所以 Python 不会计算 b。
• if a or b:变量a应该有更高的概率为真，所以 Python 不会计算 b。

8.循环优化

8.1 将while替换为for

for循环比while循环快。

8.2 用隐式 for 循环替换显式 for 循环

我们用上面的例子。

8.3 减少内部 for 循环的计算

我们将sqrt(x)从内部 for 循环移动到外部 for 循环。

9.使用 numba.jit

Numba 可以将 Python 函数 JIT 编译成机器码执行，大大提高了代码的速度。想了解更多关于 numba 的信息，请看主页。

我们用上面的例子。

我们将sqrt(x)从内部 for 循环移动到外部 for 循环。

10.使用 cProfile 定位时间成本函数

“cProfile”将输出每个功能的时间使用情况。所以我们可以找到时间成本函数。

查看我的其他帖子 中等 同 一分类查看 ！
GitHub:bramble Xu LinkedIn:徐亮 博客:bramble Xu

参考

• https://wiki.python.org/moin/PythonSpeed/PerformanceTips
• https://real python . com/introduction-to-python-generators/# building-generators-with-generator-expressions
• 编写可靠的 Python 代码 91 建议
• Python 食谱，第三版
• https://zhuanlan.zhihu.com/p/143052860
• https://pybit.es/faster-python.html

每个 ML 从业者必须知道的 10 个张量流技巧

原文：https://towardsdatascience.com/10-tensorflow-tricks-every-ml-practitioner-must-know-96b860e53c1?source=collection_archive---------30-----------------------

为什么 TensorFlow 是完整的 ML 包

作者照片，Logo via TensorFlow

TensorFlow 2.x 在构建模型和总体 TensorFlow 使用方面提供了很多简单性。TF2 有什么新鲜事吗？

• 使用 Keras 和热切的执行轻松构建模型。
• 在任何平台上的生产中实现强大的模型部署。
• 强大的研究实验。
• 通过清理废弃的 API 和减少重复来简化 API。

在本文中，我们将探讨 TF 2.0 的 10 个特性，这些特性使 TensorFlow 的使用更加流畅，减少了代码行数，提高了效率，因为这些函数/类属于 TensorFlow API。

第 1(a)条。用于构建输入管道的 tf.data API

tf.data API 提供了数据管道和相关操作的函数。我们可以构建管道、映射预处理函数、混洗或批处理数据集等等。

从张量构建管道

>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1])
>>> iter(dataset).next().numpy()
8

分批和洗牌

**# Shuffle**
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).shuffle(6)
>>> iter(dataset).next().numpy()
0**# Batch**
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).batch(2)
>>> iter(dataset).next().numpy()
array([8, 3], dtype=int32)**# Shuffle and Batch**
>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).shuffle(6).batch(2)
>>> iter(dataset).next().numpy()
array([3, 0], dtype=int32)

压缩两个数据集

>>> dataset0 = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1])
>>> dataset1 = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6])
>>> dataset = tf.data.Dataset.zip((dataset0, dataset1))
>>> iter(dataset).next()
(<tf.Tensor: shape=(), dtype=int32, numpy=8>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)

映射外部函数

def into_2(num):
     return num * 2>>> dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1]).map(into_2)
>>> iter(dataset).next().numpy()
16

第 1 款(b)项。图像数据生成器

这是 tensorflow.keras API 最好的特性之一(在我看来)。ImageDataGenerator 能够生成数据集切片，同时进行批处理和预处理，并实时增加数据。

生成器允许数据流直接来自目录或数据帧。

关于 ImageDataGenerator 中数据扩充的一个误解是，它向现有数据集添加更多数据。虽然这是数据扩充的实际定义，但在 ImageDataGenerator 中，数据集中的图像会在训练的不同步骤中动态转换，以便模型可以在它没有看到的有噪声的数据上进行训练。

train_datagen = ImageDataGenerator(
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True
)

这里，对所有样本进行重新缩放(用于归一化)，而其他参数用于增强。

train_generator = train_datagen.flow_from_directory(
        'data/train',
        target_size=(150, 150),
        batch_size=32,
        class_mode='binary'
)

我们为实时数据流指定目录。这也可以使用数据帧来完成。

train_generator = flow_from_dataframe(
    dataframe,
    x_col='filename',
    y_col='class',
    class_mode='categorical',
    batch_size=32
)

x_col 参数定义图像的完整路径，而 y_col 参数定义分类的标签列。

该模型可以直接由发电机供电。尽管需要指定每个时期的步骤数参数，该参数本质上是样本数//批量大小。

model.fit(
    train_generator,
    validation_data=val_generator,
    epochs=EPOCHS,
    steps_per_epoch=(num_samples // batch_size),
    validation_steps=(num_val_samples // batch_size)
)

2.用 tf.image 扩充数据

数据扩充是必要的。在数据不足的情况下，对数据进行修改并将其作为一个独立的数据点，是在数据较少的情况下进行训练的一种非常有效的方法。

tf.image API 提供了用于转换图像的工具，这些工具稍后可以用于前面讨论的 tf.data API 的数据扩充。

flipped = tf.image.flip_left_right(image)
visualise(image, flipped)

上述代码片段的输出

saturated = tf.image.adjust_saturation(image, 5)
visualise(image, saturated)

上述代码片段的输出

rotated = tf.image.rot90(image)
visualise(image, rotated)

上述代码片段的输出

cropped = tf.image.central_crop(image, central_fraction=0.5)
visualise(image, cropped)

上述代码片段的输出

3.张量流数据集

pip install tensorflow-datasets

这是一个非常有用的库，因为它是 TensorFlow 从各个领域收集的非常著名的数据集的单一转储点。

import tensorflow_datasets as tfdsmnist_data = tfds.load("mnist")
mnist_train, mnist_test = mnist_data["train"], mnist_data["test"]
assert isinstance(mnist_train, tf.data.Dataset)

tensorflow-datasets 中可用数据集的详细列表可在文档的数据集页面上找到。

音频、图像、图像分类、对象检测、结构化、摘要、文本、翻译、视频是 tfds 提供的类型。

4.预训练模型下的迁移学习

迁移学习是机器学习中的新亮点，听起来很重要。训练一个已经被其他人训练过的基准模型并且拥有大量资源(例如，一个人可能负担不起的多个昂贵的 GPU)是不可行和不切实际的。迁移学习解决了这个问题。一个预训练的模型可以为一个给定的用例重用，或者可以为一个不同的用例扩展。

TensorFlow 提供了基准预训练模型，可以根据所需的使用情况轻松扩展。

base_model = tf.keras.applications.MobileNetV2(
    input_shape=IMG_SHAPE,
    include_top=False,
    weights='imagenet'
)

这个 base_model 可以很容易地用附加层或者不同的模型来扩展。例如:

model = tf.keras.Sequential([
    base_model,
    global_average_layer,
    prediction_layer
])

有关 tf.keras.applications 下其他模型和/或模块的详细列表，请参考文档页面。

5.评估者

估计器是 TensorFlow 对完整模型的高级表示，它被设计为易于扩展和异步训练

— 张量流文档

预制估算器提供了一个非常高层次的模型抽象，因此您可以直接专注于训练模型，而不用担心较低层次的复杂性。例如:

linear_est = tf.estimator.LinearClassifier(
    feature_columns=feature_columns
)linear_est.train(train_input_fn)
result = linear_est.evaluate(eval_input_fn)

这显示了使用 tf.estimator 构建和训练估计器是多么容易。估计器也可以定制。

TensorFlow 有许多预制的估计器，包括线性回归器、BoostedTreesClassifier 等。在 TensorFlow 文档中可以找到完整、详细的估算表。

6.自定义图层

众所周知，神经网络是多层深度网络，其中各层可以是不同的类型。张量流包含许多预定义的层(如密集，LSTM 等。).但是对于更复杂的体系结构，层的逻辑要比主层复杂得多。对于这种情况，TensorFlow 允许构建自定义图层。这可以通过创建 tf.keras.layers.Layer 类的子类来实现。

class CustomDense(tf.keras.layers.Layer):
    def __init__(self, num_outputs):
        super(CustomDense, self).__init__()
        self.num_outputs = num_outputs

    def build(self, input_shape):
        self.kernel = self.add_weight(
            "kernel",
            shape=[int(input_shape[-1]),
            self.num_outputs]
        )

    def call(self, input):
        return tf.matmul(input, self.kernel)

如文档中所述，实现您自己的层的最佳方式是扩展 tf.keras.Layer 类并实现:

1. init ，在这里可以进行所有与输入无关的初始化。
2. 构建，在这里你知道输入张量的形状，并且可以完成剩下的初始化工作。
3. 调用，在这里进行正向计算。

虽然内核初始化可以在 init 中完成，但是在 build 中初始化被认为更好，否则，您将不得不在每个新层创建的实例上显式指定 input_shape 。

7.定制培训

tf.keras Sequential 和 Model API 使得训练模型更加容易。然而，大多数时候在训练复杂模型时，使用定制损失函数。此外，模型训练也可以不同于默认值(例如，将梯度分别应用于不同的模型组件)。

TensorFlow 的自动微分功能有助于高效计算梯度。这些原语用于定义自定义训练循环。

def train(model, inputs, outputs, learning_rate):
    with tf.GradientTape() as t:
 **# Computing Losses from Model Prediction**
        current_loss = loss(outputs, model(inputs)) **# Gradients for Trainable Variables with Obtained Losses**
    dW, db = t.gradient(current_loss, [model.W, model.b]) **# Applying Gradients to Weights**
    model.W.assign_sub(learning_rate * dW)
    model.b.assign_sub(learning_rate * db)

这个循环可以重复多个时期，并根据使用情况进行更加定制的设置。

8.检查站

保存张量流模型有两种类型:

1. SavedModel :保存模型的完整状态以及所有参数。这与源代码无关。model.save_weights('checkpoint')
2. 检查点

检查点捕获模型使用的所有参数的精确值。用顺序 API 或模型 API 构建的模型可以简单地保存为 SavedModel 格式。

但是，对于定制模型，检查点是必需的。

检查点不包含由模型定义的计算的任何描述，因此通常仅当使用保存的参数值的源代码可用时才有用。

保存检查点

checkpoint_path = “save_path”**# Defining a Checkpoint**
ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer)**# Creating a CheckpointManager Object**
ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)**# Saving a Model**
ckpt_manager.save()

从检查点加载

TensorFlow 通过遍历带有命名边的有向图，从正在加载的对象开始，将变量与检查点值进行匹配。

通过文档恢复模型的依赖图

if ckpt_manager.latest_checkpoint:
    ckpt.restore(ckpt_manager.latest_checkpoint)

9.Keras 调谐器

这是 TensorFlow 中一个相当新的特性。

!pip install keras-tuner

超参数调整或超调整是挑选定义 ML 模型配置的参数的过程。这些因素是特征工程和预处理后模型性能的决定因素。

**# model_builder is a function that builds a model and returns it**
tuner = kt.Hyperband(
    model_builder,
    objective='val_accuracy', 
    max_epochs=10,
    factor=3,
    directory='my_dir',
    project_name='intro_to_kt'
)

除了 HyperBand，BayesianOptimization 和 RandomSearch 也可用于调优。

tuner.search(
    img_train, label_train, 
    epochs = 10, 
    validation_data=(img_test,label_test), 
    callbacks=[ClearTrainingOutput()]
)
 **# Get the optimal hyperparameters**
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]

此外，我们使用最佳超参数来训练模型:

model = tuner.hypermodel.build(best_hps)
model.fit(
    img_train, 
    label_train, 
    epochs=10, 
    validation_data=(img_test, label_test)
)

10.分布式培训

如果您有多个 GPU，并希望通过在多个 GPU 上分散训练循环来优化训练，TensorFlow 的各种分布式训练策略能够优化 GPU 的使用，并为您操纵 GPU 上的训练。

tf.distribute.MirroredStrategy 是最常用的策略。它到底是怎么工作的？单据状态:

• 所有的变量和模型图都被复制到复制品上。
• 输入在副本之间均匀分布。
• 每个复制品计算它接收的输入的损失和梯度。
• 通过求和，梯度在所有副本中同步。
• 同步后，对每个副本上的变量副本进行相同的更新。

strategy = tf.distribute.MirroredStrategy()with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Conv2D(
            32, 3, activation='relu',  input_shape=(28, 28, 1)
        ),
        tf.keras.layers.MaxPooling2D(),
        tf.keras.layers.Flatten(),
        tf.keras.layers.Dense(64, activation='relu'),
        tf.keras.layers.Dense(10)
    ])

    model.compile(
        loss="sparse_categorical_crossentropy",
        optimizer="adam",
        metrics=['accuracy']
    )

对于其他策略和自定义训练循环，请参考文档。

结论

TensorFlow 足以构建 ML 管道的几乎所有组件。本教程的要点是介绍 TensorFlow 提供的各种 API 以及如何使用它们的快速指南。

这里的是指向 GitHub 代码库的链接。随便叉吧。

参考

本指南中使用的代码引用自以下官方 TensorFlow 文档:

[## 教程| TensorFlow 核心

完整的端到端示例，帮助 ML 初学者和专家了解如何使用 TensorFlow。尝试谷歌教程…

www.tensorflow.org](https://www.tensorflow.org/tutorials) [## 教程| TensorFlow 核心

完整的端到端示例，帮助 ML 初学者和专家了解如何使用 TensorFlow。尝试谷歌教程…

www.tensorflow.org](https://www.tensorflow.org/tutorials)

Swift 程序员应该知道的 10 个术语(基础)

原文：https://towardsdatascience.com/10-terms-and-terminologies-a-swift-programmer-should-know-basic-e2c469c359f6?source=collection_archive---------30-----------------------

理解 Swift 中的基本术语，这是一种编程语言，TensorFlow 利用它来实现稳健算法

罗曼·辛克维奇在 Unsplash 上拍摄的照片

介绍

Swift 是苹果在 2014 年发布的开源语言。它已经迅速成为开发人员正在学习和使用的流行的现代编程语言之一。

Swift 是一种通用的编程语言，用于 iOS 应用程序开发甚至机器学习等任务。

雨燕和张量流

TensorFlow(机器学习平台)发布了其流行库的 beta Swift 实现。虽然 TensorFlow 的 Swift 版本才刚刚处于测试阶段。

[## TensorFlow 的 Swift

Swift for TensorFlow 是用于深度学习和差异化计算的下一代系统。

www.tensorflow.org](https://www.tensorflow.org/swift)

本文提供了不熟悉 Swift 编程语言的开发人员需要理解的基本术语，以便完全掌握和利用该语言。

条款

• 引用类型(类):当这些类型被分配给一个变量、常量或传递给一个函数时，它们不会被复制，而只是新的分配器指向数据在内存中的位置。
• 值类型(结构):这些是类型(整数、布尔、字符串等。)的值在分配给占位符变量、常量或作为变量/参数传递给函数时被复制。
• 继承:类通常有定义的属性、方法、类型和其他封装在其中的对象。Swift 中的类对象可以获取另一个类的封装对象和属性；这就是所谓的继承。通过利用继承，另一个类可以访问不同类的方法和属性。
• 子类:从不同类继承属性、函数和其他对象的类。
• 超类:向其他类提供其属性、函数和其他嵌入对象的类。
• 基类:缺少的类不继承或者依赖于另一个类。
• 扩展:诸如结构、类或枚举的构造对象可以通过使用扩展来扩展它们现有的功能。扩展向对象、类或协议添加新的类型、方法、属性、初始化器等。
• 覆盖:从另一个类(超类)继承属性和方法的类(子类)可以修改超类的现有属性、方法和其他对象。
• 枚举 : Swift 提供了定义一级类型的能力，该类型包含在程序执行阶段不会受到任何形式修改的数据。枚举允许在单个类型下组合相关的值和数据类型。
• 协议:启用“设计规范”对象的定义，该对象可以包含诸如类、结构、枚举或协议之类的对象应该遵守和符合的属性和方法。

结论

现在，您已经有了一些基本的 Swift 术语和一些描述，以便全面理解 Swift 编程语言提供的标准工具和额外津贴。

从现在开始，您可以观看 YouTube 上关于本文中提到的术语的底层实施的教程，或者直接访问 Swift 官方文档网站。

我在下面的文章中介绍了两种常见的 Swift 对象、类和结构之间的区别。

[## Swift 中类别和结构之间的差异

虽然类和结构有一些明显的相似之处，但本文列出了结构之间的差异…

medium.com](https://medium.com/swlh/differences-between-classes-and-structures-in-swift-ab2e27956665)

用 10 个步骤学习数据科学

原文：https://towardsdatascience.com/10-things-i-wish-i-knew-about-learning-data-science-7a30bfb91759?source=collection_archive---------2-----------------------

数据科学

开始数据科学之旅的终极路线图

由 koctia 在 Envato Elements 上的照片修改(经许可)

在我的 YouTube 频道(数据教授)上，我经常被问到以下关于如何进入数据科学的问题:

• 如何成为一名数据科学家？
• 成为数据科学家的路线图是什么？
• 学数据科学要上哪些课程？

所以我想写一篇关于它的文章可能是一个好主意。所以，在这里。应该注意的是，我希望了解的关于学习数据科学的 10 件事是基于我作为一名自学成才的数据科学家的个人经历。问题是，如果我可以让时间倒流，并建议我 22 岁的自己学习数据科学，那么这些是我想说的一些事情。

我在 2004 年开始了我的数据科学之旅。那时，数据科学这个术语还处于婴儿期，而更广泛使用的术语是数据挖掘。直到 2012 年，数据科学这个术语才开始获得关注，并成为主流流行，这是因为《哈佛商业评论》的一篇题为 数据科学家:21 世纪最性感的工作 的文章，作者是 Thomas Davenport 和 D.J. Patil。

什么是数据科学？

简而言之，数据科学本质上是一个利用数据来解决问题，并为公司和组织带来影响、价值和洞察力的领域。数据科学已经应用于广泛的学科和行业，涵盖教育、金融、医疗保健、地质、零售、旅游和电子竞技。数据科学的技术技能集涉及数据收集、数据预处理、探索性数据分析、数据可视化、统计分析、机器学习、编程和软件工程的使用。除了技术方面，数据科学家还需要各种软技能。下面的信息图高度概括了数据科学家的基本技能。

资料图由查宁·南塔塞纳马特(又名数据教授

1.您的数据科学之旅是个人的

您的数据科学之旅是个人的。不要拿自己和别人比较，记住每个人都是独一无二的，我们每个人都在不同的旅途上。为什么我们要踏上别人的旅程？专注于您自己的数据科学之旅。被挫折耽搁是可以的，但是不要让这些阻碍阻止你达到你的目标。迟到总比不到好。

拥抱 i mposter 综合征，将不安全感视为导向图，这将在你的数据科学之旅中帮助你。特别是，这可能会引导你走向自我完善的道路。列出你自己要学习和要做的事情。找出你还不知道的数据科学概念和技能，记下你想知道的。然后从这份数据科学概念/技能的清单中，集中精力每天只学习 1 件新东西。在一年的时间里，你会惊讶于复合效应以及你学到了多少新概念和技能。

2.如何学习数据科学？

学习风格

我们如何学习？学习风格***通俗地说分为三大类型:

1. 视觉(参见)
2. 听觉(听觉)
3. 动觉

**Disclaimer: It should be noted that there is no scientific proof for the learning styles and thus herein we used the term ‘popularly’ to depict the mainstream popularity of its use. The learning style is used herein to illustrate the various and many form and medium that exists. Advices presented herein are based solely on my own opinion and experience. Please refer to the published research on learning style myth at:* https://www.apa.org/news/press/releases/2019/05/learning-styles-myth

知识无处不在，学习的源泉有多种形式。例如，你可以从书籍、博客、视频、播客、有声读物、讲座、教学中学习，最重要的是通过实践。

“学习数据科学的最佳方式是研究数据科学。”

— Chanin Nantasenamat(又名数据教授)

当您学习新的概念或技能时(即来自视觉和听觉)，您可以通过将新获得的知识立即应用到您的数据科学项目中来巩固您所学的知识(即动觉)。通过不断学习数据科学，你将逐渐强化和磨练你刚刚学到的新概念和新技能。随着时间的推移，你会掌握它们。

此外，为了进一步巩固你对这些新概念或新技能的理解，你可以教别人(例如，写一篇教程博客，制作一个视频教程和教别人)。通过这样做，你可以利用上面提到的三种学习方式，从而最大限度地发挥你的学习潜力。同样值得注意的是，教导他人将有助于你将新的概念或技能具体化为你自己的语言，这样做有助于重组你的思想并更好地理解它。

学会如何学习

这只是关于如何学习的建议的冰山一角。事实上，在 Coursera 上有一个由 Barbara Oakley 博士和 Terrence Sejnowski 博士开设的名为 的在线课程，学习如何学习 ，这是一个很棒的课程，它会教你一些学习技巧，帮助你更有效地学习。

另一篇值得一读的文章是 Evernote 的一篇中型文章，题为 学习费曼技巧 ，总结了诺贝尔奖获得者、物理学家理查德·费曼发明的学习技巧。此外，YouTube 上一个关于 25 个最佳科学研究技巧的视频提供了关于有效学习技巧的可行技巧，您也可以在学习数据科学时使用。

此外，斯科特·扬写了一本关于 超学习 的优秀书籍，分享了他在短短一年内学习麻省理工学院四年制计算机科学课程的自学经历。此外，乔希·考夫曼发表了一个 TED 演讲并在他的书 中描述了前 20 个小时 我们可以在短短的 20 个小时内学会任何我们想要的东西。

掌握学习的艺术将使您能够更有效地学习和研究数据科学，从而使您的学习体验更加愉快。

学习数据科学的策略和所需的技能

2020 年初，我在 YouTube 上发布了一个视频2020 年学习数据科学的策略 ，我在视频中分享了一些实用的技巧和诀窍，以帮助你开始数据科学之旅。您可能还想了解如何成为一名数据科学家 (学习途径和所需技能) 在这里，我将带您鸟瞰数据科学的整体面貌，并涵盖所有数据科学家都应该了解的 8 项重要技能。

2021 年初，我发布了一个更加扩展的视频 【学习数据科学的艺术(2021 年如何学习数据科学) ，在这里我分享了我关于如何开始学习数据科学的最佳技巧。我研究并提炼了一些必要的最佳实践，帮助你开始学习数据科学的旅程。可以在 Data Professor YouTube 频道的数据科学 101 播放列表中找到提供学习数据科学的策略和建议的其他视频。

学习数据科学的艺术(2021 年如何学习数据科学)

2020 年学习数据科学的策略

如何成为数据科学家(学习路径和技能)

Ken Jee 就如何学习数据科学发表了一篇优秀的媒体文章和 YouTube 视频。此外，他还在他的 YouTube 视频中分享了他的建议 我将如何学习数据科学(如果我必须重新开始) 。

4.学习数据科学的资源(收费还是免费)

有大量的学习资源可供学习数据科学。事实上有这么多，这可能是压倒性的选择。我将把可用的学习资源分为两大类:收费和免费。

在接下来的部分中，我将列出一些学习数据科学的资源，分别是收费和免费。

收费学习资源

• 365 数据科学
• 数据营
• 数据请求
• 数据科学道场
  1。数据科学训练营2。用于数据科学的 Python
  3。实习
• 奥赖利在线学习(每月 49 美元或每年 499 美元)
• Udemy ( 数据科学课程 ) —以下为顶级课程:
  1。机器学习 A-Z:动手 Python & R 在数据科学
  2。 Python for Data Science 与机器学习训练营
  3。数据科学课程 2020:完整的数据科学训练营
  4。数据科学 A-Z:现实生活中的数据科学练习包括
  5。R Programming A-Z:R For Data Science With Real exercise！
  6。人工智能 A-Z:学习如何构建一个人工智能。机器学习、数据科学和深度学习用 Python
  8。 Python A-Z:具有真实练习的数据科学 Python！
  9。数据科学统计与商业分析
  10。完整的机器学习和数据科学:零到精通

免费或收费的学习资源

• edX —除了 CS50，其他都是收费的1。 CS50 (价值 90 美元的免费/可验证证书)
  2。数据科学专业证书(哈佛大学)
  3。统计学和数据科学的微硕士项目(麻省理工)
  4。数据科学微硕士项目(加州大学圣地亚哥分校)
  5。 IBM 的 IBM 数据科学专业证书 (IBM)
  6。微观分析硕士项目:基本工具和方法(佐治亚理工大学)
  7。分析学硕士(佐治亚理工大学)
• Coursera —免费审核或收费获得证书1。机器学习(吴恩达/斯坦福大学)
  2。数据科学专业 (10 门课程/约翰·霍普斯金大学)
  3。高管数据科学专业 (5 门课程/约翰·霍普斯金大学)
  4。数据挖掘专业 (6 门课程/伊利诺伊大学)
  5。数据科学计算机科学硕士 (8 门课程/伊利诺伊大学香槟分校)
  6。应用数据科学硕士(密歇根大学)
• uda city——uda city 的数据科学学院和人工智能学院提供的精选入门课程免费或纳米学位课程收费。
  1。数据科学入门(免费)
  2。数据分析介绍(免费)
  3。数据分析与可视化(免费)
  4。用于数据分析的 SQL(免费)
  5。推断统计学简介(免费)
  6。数据科学家纳米学位项目(收费)
  7。数据分析师纳米学位项目(收费)
  8。数据可视化纳米学位计划(收费)
  9。数据工程师纳米学位项目(收费)
  10。机器学习工程师纳米学位项目(收费)

免费的学习资源

• Kaggle 微课 — 14 门微课组成:
  1。Python2。机器学习介绍
  3。中级机器学习
  4。数据可视化
  5。熊猫6。特色工程
  7。深度学习
  8。SQL简介
  9。高级 SQL
  10。地理空间分析
  11。微挑战
  12。机器学习可解释性
  13。自然语言处理
  14。游戏 AI 和强化学习简介
• YouTube —有几个极好的频道，涵盖了数据科学中的几个重要主题。1。数据教授2。肯吉3。克里斯纳伊克4
  4。 Codebasics
  5。3 蓝色 1 棕色6。乔希·斯塔默的 StatQuest。send ex8。数据学校
  9。 Python 程序员
  10。莱克斯·弗里德曼
  11。Abhishek tha kur12。两分钟试卷
  13。安德烈亚斯·克雷茨14
  。科里斯查费
  15。西拉杰·拉瓦尔
  16。故事由数据(Kate Strachnyi)
  17。RichardOnData
  18。霍马理工 ( 数据科学播放列表 )
  19。 365 数据科学
  20。数据科学道场
  21。数据营
  22。导入数据
  23。数据科学杰伦
  24。大卫·兰格
  25。丹尼尔·伯克
  26。 Python 工程师

从竞赛和黑客马拉松中学习

学习和提高数据科学技能的另一种方式是参加数据科学竞赛和黑客马拉松。你可以参加数据科学竞赛的一个知名和受欢迎的平台是 Kaggle ，而主办机器学习黑客马拉松的平台是 MachineHack 。

参加这些活动的最大好处是，由于即兴的性质，在处理手头的问题时需要大量的即兴创作和创造力。由于这些事件涉及时间因素(例如，有一个具体的截止日期提交日期)，因此潜意识里你有动力将项目进行到底。可以想象，在一个学习场景中，你没有在特定日期或时间前完成数据科学项目的压力，那么你可能会推迟(即，可能因拖延或生活中的事件而推迟)项目的完成。回想一下你在学校的时候，你必须为一场在特定日期和时间举行的考试而学习。因此，你将通过进行必要的阅读、回忆、理解和记忆来准备考试(即)，以便你能够参加和参加考试。同样，如果您决定参加并完成一项竞赛或黑客马拉松，那么您将需要准备并分析由这些事件给出的数据集(即数据预处理、探索性数据分析、特征工程、模型构建和模型解释)。

参加竞赛和黑客马拉松的另一个重要原因是，通过寻找提高模型性能的创造性方法，您可能会获得有价值的提示和技巧。在这样做的过程中，您可能会参与到学习过程中，从而接触到其他数据科学家同事，讨论如何处理数据集的新方法，并在这样做的过程中学习一些新东西。此外，您寻找提高模型性能的方法的旅程可能会引导您挖掘研究文献并尝试新事物、库和/或方法。如果仅仅通过传统和被动的方式学习，所有这些都是不可能的。

有关更多精彩的数据科学竞赛和黑客马拉松，请参考 Benedict Neo 在《走向数据科学》中关于 10 个数据科学竞赛的精彩帖子，为您磨练 2020 年 的技能。此外，还建议参加 Coursera 关于 如何赢得数据科学竞赛的课程:向顶级 kaggler学习，并了解在这些竞赛中获胜的一些最佳实践。你可能还想看看 Abhishek Thakur 在 YouTube 上关于 我的旅程的视频:我如何在 Kaggle 上成为世界上第一个 4x(和 3x)大师。

5.为什么是数据科学？

对你为什么要学习数据科学有一个明确的目的和原因，可以帮助你更好地欣赏数据科学。通过探索以下主要问题，花些时间来思考这个问题。

我为什么要学数据科学？

你想问自己的最重要的问题很简单你为什么想学数据科学？通过回答这个问题，你将更好地了解你需要首先专注于学习数据科学的哪个领域，因为这个领域非常广阔，而且很容易迷路和掉进兔子洞。

我将如何在我的项目中使用数据科学

确定如何在项目中使用数据科学非常重要。您想要回答的一些问题包括:

• 您将执行探索性数据分析吗
• 你会开发一个回归/分类/聚类模型吗
• 你会开发一个聊天机器人吗
• 你会开发一个推荐系统吗

通过使用数据科学，我能为我的工作带来什么价值

正如斯蒂芬·柯维在他的《高效人士的 7 个习惯》中所说，“从心中的目标开始。”

• 因此，花点时间想想你希望数据科学达到的理想目标。
• 心中有了一个明确的目标，你会惊讶地发现自己对实现这个目标有多投入。

6.保持自己的责任感和生产力！

首先，对自己的学习进度负责将有助于你坚持下去。我是由肯·吉创立的一个了不起的数据科学家在线社区的成员。在这个在线社区中，会有一个讨论板，成员可以公开发布他们一周或一个月的目标。这样做，有助于我们坚持我们最初的意图和目标。

Ken 还在他的中型文章 中分享了他关于如何在学习数据科学 时保持动力和生产力的更多技巧和诀窍。凯文·道姆出版的《高度负责的人的八个习惯》中有更多的建议。

以下是一些提高工作效率的基本建议:

1. 每天留出专门的时间(最好是每天 1-2 小时或至少 45 分钟)来学习和研究数据科学
2. 避免分心(关掉手机，避免查看社交媒体等。).如果你不能阻止分心的事物接近你，那么把自己从一个分心的环境中转移出来可能是一个更好的主意。这意味着你应该找一个安静的地方，在那里你可以全神贯注。
3. 不要拖延，不要想太多，去做吧！(像耐克一样)为了帮助你克服这一点，尝试应用两分钟规则(阅读这篇关于如何通过使用‘两分钟规则’停止拖延的中型文章)来帮助你保持运动。

因为在一天结束的时候，如果你没有进步，你就没有学习，你就不能实现你的目标，在你的职业生涯中达到你想要的位置。

我的一个好朋友 Ken Jee 发起了一个学习挑战，帮助你对自己的学习之旅负责。如肯所说，为了参加挑战:

1. 每天至少花 5 分钟阅读、学习或实施一个数据科学项目
2. 在社交平台( Twitter 、 LinkedIn 等)分享自己的进步。)使用 #66daysofdata

这就是全部，现在您有了一个庞大的数据科学学习者社区，让您在数据科学学习之旅中负起责任。您可以从下面的视频中了解这一举措:

什么是 #66DaysOfData ？

7.拥抱失败，学会热爱调试

拥抱失败。你必须学会适应不舒服的事情。因为简单来说，没有免费的午餐。没有付出，就没有收获。所以当你遇到失败时，不要纠结于它，只要重新站起来，继续尝试。

卡住是完全可以的，不理解 X 算法是可以的，不知道如何调试失败的代码也是可以的。在继续应对挑战之前，你可以休息一会儿，让头脑清醒一下。有时你的大脑变得堵塞和迟钝，所以休息一下可能有助于恢复活力和精神。

当您陷入数据科学项目的编码错误中，并且不确定如何继续时。如果你有一个精通编码的朋友，问问他或她。否则，如果您的问题已经有答案，搜索堆栈溢出。如果没有，就问！

学会热爱调试，把它作为一个学习机会，你可以从失败和错误中获得有价值的见解和教训。因为不失败就不学习。但是当你失败的时候，不要对自己太苛刻，要学会重新站起来，重新开始。你想从失败中恢复过来。

8.不要担心试图学习一切

该领域的新手可能会被所有花哨的术语所震惊，但请不要被吓倒，并记住数据科学和机器学习是一个动态的、不断增长和发展的领域，因此总会有新技术的引入。简单来说，唯一不变的就是变化本身。

如上所述，不要被吓倒，采取潜水和开始。你从哪里开始并不重要，最重要的是你真正开始你的数据科学之旅。

专注于基础

1. 数据角力 (Python — pandas，R — dplyr)
2. 仔细阅读 统计数据 ，以便将它们应用到您的模型中。例如，应用适当的统计来比较模型(参数与非参数)。
3. 探索性数据分析 和 描述性统计 用于获得数据的概述
4. 从构建 简单且可解释的机器学习 模型开始(线性回归，基于树的方法)
5. 使用你有信心使用的机器学习方法( 了解其背后的数学 )

专注于项目，而不是技术

不要想太多。克服“我应该学什么语言？”两难，选一个继续前进。

要知道编程是一种工具，它应该可以帮助你将你的项目理念推向开发和部署

编程的基本概念是与语言无关的，这意味着核心基础适用于各种语言:

• 定义变量、数组、数据框等。
• 流量控制(例如循环、if 和 else 语句)
• 数据科学中的具体任务
  -数据争论/数据预处理
  -数据可视化
  -模型构建
  -模型部署

9.让您的项目可重复

使您的数据科学项目可重现的一些好处如下:

其他人可以帮助你

• 当你面临一个编码错误时，制作一个最小的工作示例(MWE)是很重要的，因为这将允许其他人重现你的错误，以便他们可以帮助你。

为未来的自己和他人节省时间

• 将您的项目导出为 Docker 容器以及 Python 和 Conda 的环境。因为由于安装在您的编码环境中的基础库的不断变化的版本，今天起作用的可能 6 个月后就不起作用了。因此，使用虚拟环境、Docker 容器或至少导出库版本(如下所示的 pip 和 conda)是非常必要的。

在 pip 中导出环境:

*pip freeze > requirements.txt*

conda 中的导出环境:

*conda env export > environment.yml*

10.学习成功从内部开始

本节探讨数据科学之旅的成功水平从内部开始这一理念。它是关于让你的思想为即将到来的和即将成为的你做好准备。这些概念包括:好奇心、热爱过程、成长心态和毅力。

好奇心

好奇心可以被认为是成为数据科学家的核心和必要技能之一，因为它让我们在追求解决问题的创造性方法时保持动力和毅力。阿尔伯特·爱因斯坦曾经把好奇心和知识相提并论。

“好奇心比知识更重要。”

―阿尔伯特·爱因斯坦

Eric Colson 在他的哈佛商业评论文章 好奇心驱动的数据科学 中强调了好奇心的重要性。

“…少考虑数据科学将如何支持和执行您的计划，多考虑如何创造一个环境，让您的数据科学家能够提出您做梦也想不到的东西。”

―埃里克·科尔森

热爱这个过程

学习数据科学不是一件容易的事，也不是不可能的事。一个非技术背景的人绝对有可能闯入数据科学，就像我在我以前的媒体文章 中所做的那样，并讨论了生物学家如何成为数据科学家 。

当谈到热爱这个过程时，三个名字浮现在脑海中:迈克尔·乔丹、加里·维纳查克和克莱门特·米哈伊尔斯库。这三个人可以被认为是他们所做的最好的人，他们对他们所做的事情充满热情。

在签署他的第一份职业篮球合同时，迈克尔·乔丹确保了一份特殊的

《游戏之爱》

合同中包括了一项条款，允许乔丹随时随地不受限制地打篮球。

正如加里·维纳查克(VaynerX 的董事长，VaynerMedia 的首席执行官，五次 NYT 畅销书作家)在一个 YouTube 视频中被问及他是否可以委派大部分工作以减少工作时间时说的。

“我热爱工作的过程，我热爱磨砺，我热爱攀登。…如果我不能完成完成我想要的事情所需的工作，我会窒息的。”

―加里·维纳查克

clément Mihailescu(algo expert 首席执行官，前脸书软件工程师和技术 YouTube)在一个 YouTube 视频中说，他没有感到筋疲力尽。

“归根结底，你必须享受这个过程。无论你在做什么，无论你在努力追求什么，你都必须享受每一天，你必须热爱本质的东西。你必须活着，呼吸它。”

―克莱门特·米哈伊尔斯库

成长心态和勇气

基于几年的研究，安吉拉·杜克沃斯(性格实验室的创始人兼首席执行官，宾夕法尼亚大学心理学教授)在她的畅销书 Grit:激情和毅力的力量 ( YouTube 视频)中将术语 g rit 定义为激情和坚持的结合。特别是，她对勇气的定义摘录如下:

"毅力是保持对长期目标的兴趣和努力的倾向。"

―安吉拉·杜克沃斯

卡罗尔·德韦克在她的书《心态:改变你的思维方式以实现你的潜力》中描述了她对指导我们生活的两种主要心态的研究结果:(1)成长心态和(2)固定心态。前者与成功联系在一起，而后者通常会导致自我怀疑和不满足的生活。在她的 TED 演讲中，Dweck 提出了在舒适区之外工作的重要性，认为这是提高你表现的关键。**

在数据科学中，变化是不可避免的，因为总是会引入新的和具有挑战性的概念，这些概念可能会完全覆盖或重新定义以前的概念。我们总是会受到复杂挑战的轰炸，要应对这些变化和挑战，要从内心开始，特别是要有正确的心态，帮助你走向成功。

奖金:11。承担全部责任

往往很容易想出借口，把人生的不幸归咎于无数的事情。当我们这样做时，就像加里·维纳查克常说的那样，“我们没有责任”(YouTube 上的一个优秀视频 停止指责他人&承担全部责任 )。

学习数据科学与我们生活中的任何其他努力没有什么不同。问题是，我们会对自己在学习过程中遇到的延误或障碍负责，还是不承担全部责任，把责任推给别人。

考虑以下关于承担全部责任的引语(在 YouTube 上观看这些引语的前两个引语和第三个引语)

“对发生在你身上的事情承担全部责任，这是人类成熟的最高形式之一。接受全部责任，这是你知道自己已经从童年步入成年的一天。”

―吉米·罗恩

"在你接受对自己生活的责任之前，别人会主宰你的生活."

―欧灵·伍德沃

“一切都在你身上，一切都是你的错。你想真正赢得人生吗？你想得到真正的快乐吗？你知道我为什么真的开心吗？因为我认为一切都是我的错。如果我不喜欢，我可以改变。”

―加里·维纳查克

现在，花点时间思考一下。让我们开始承担责任并承担全部责任，你会惊讶于你在数据科学之旅中所能取得的成就。只有我们能够客观并对我们的行为和缺乏进展承担全部责任，我们才会有能力对此采取行动。我将引用吉米·罗恩的一句话。

成功不是你追求的东西，成功是你成为的东西。

―吉米·罗恩

结束语

这就是我希望了解的关于学习数据科学的 10 件事，如果我能回到过去，告诉 22 岁的自己关于学习数据科学的事情。我希望这些对您开始数据科学之旅有用，或者如果您已经开始，希望您能从中找到有用的东西。直到下一次，学习数据科学的最好方法是做数据科学，请享受旅程！

公开

• 作为亚马逊的合作伙伴和 Kite 的会员，我可能会从合格的购买中获利，这将有助于未来内容的创作。

接下来读这些

• 如何用 Python 构建 AutoML App
  使用 Streamlit 库的分步教程
• 学习数据科学的策略
  打入数据科学的实用建议
• 如何免费搭建一个简单的作品集网站
  不到 10 分钟从头开始的分步教程

✉️ 订阅我的邮件列表，获取我在数据科学方面的最佳更新(偶尔还有免费赠品)!

关于我

我是泰国一所研究型大学的生物信息学副教授和数据挖掘和生物医学信息学负责人。在我下班后的时间里，我是一名 YouTuber(又名数据教授)制作关于数据科学的在线视频。在我做的所有教程视频中，我也在 GitHub 上分享 Jupyter 笔记本(数据教授 GitHub page )。

** [## 数据教授

数据科学、机器学习、生物信息学、研究和教学是我的激情所在。数据教授 YouTube…

www.youtube.com](https://www.youtube.com/dataprofessor?sub_confirmation=1)

在社交网络上与我联系

YouTube: http://youtube.com/dataprofessor/

LinkedIn:https://www.linkedin.com/company/dataprofessor/

https://www.linkedin.com/company/dataprofessor/

【HTTP://facebook.com/dataprofessor/】
【GitHub:【HTTPS://github.com/dataprofessor/】
Instagram:【HTTPS://www.instagram.com/data**

关于熊猫你不知道的 10 件事

原文：https://towardsdatascience.com/10-things-you-didnt-know-about-pandas-d20f06d1bf6b?source=collection_archive---------15-----------------------

直到现在…

乔恩·泰森在 Unsplash 上的照片

Pandas 是使用 Python 执行数据分析的权威库。它最初是由一家名为 AQR Capital Management 的公司开发的，但在 2009 年被开源用于一般用途。

它迅速成为 Python 用户数据分析的首选工具，现在拥有大量用于数据提取、操作、可视化和分析的功能。

熊猫有许多有用的方法和功能，这里是关于这个库你可能不知道的十件事。

熊猫可以 pip 安装，如果你还没有它。完整的文档，以及一些优秀的通用数据分析教程，可以在这里找到。

pip install pandas

在整篇文章中，我将使用“汽车”数据集提供代码示例，该数据集包含汽车的各种特征及其相应的保险风险评级。该数据集通常用作机器学习分类任务，目标是预测汽车的风险评级。

在建立机器学习模型之前，数据分析是一个重要的初步步骤。

如果您有 Scikit-learn，可以使用下面的代码导入数据集。或者，也可以在这里下载。

1.您可以创建类似 Excel 的数据透视表

数据透视表通常被认为是 Excel 最强大的功能之一。它们通过对变量进行分组、过滤和计算，使用户能够快速理解包含在非常大的数据集中的模式和特征。

Pandas 库包含允许你创建数据透视表的方法，这些数据透视表与 Excel 和其他电子表格工具中的数据透视表非常相似。

下面的代码使用 Pandas 数据透视表根据汽车拥有的气缸数量来比较汽车的保险风险评级。

2.describe()函数也可用于分析非数字特征

pandas [**describe()**](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.describe.html)函数可以快速生成描述性统计数据的摘要，默认情况下，只针对数据集中的数值。然而，这个非常有用的 Pandas 工具也能够通过简单地添加include=’all’参数来提供非数字列的摘要。

这对于包含分类变量的维度等信息非常有帮助，这些信息有助于为机器学习的转换策略提供信息。

data.describe(include='all')

3.内置统计函数

就像 Excel Pandas 一样，它包含了大量的计算工具，可以将常用的统计方法应用到数据中。例如，使用corr() 方法可以快速计算出数据集中变量之间的相关性。

round(data.corr(),2)

4.绘图功能

Pandas 具有内置绘图功能，允许您从数据框、分组或数据透视表中快速创建最常见类型的绘图。

以下代码创建了一个散点图，在我们的数据框架中比较发动机大小和马力。

data.plot.scatter(x='engine-size', y='horsepower')

只需将.plot()添加到我之前创建的数据透视表中，就可以生成汇总数据的图表。

pivot_table.plot()

5.更漂亮的情节

默认情况下，Pandas 绘图方法使用 Matplotlib 作为可视化的后端。然而，Pandas 也支持许多其他的 Python 绘图库。

例如，要更改后端并使用散景进行可视化，只需使用以下代码。

这提供了一个更丰富的，交互式的可视化。

关于熊猫可视化使用不同后端的更详细的教程，见下面我以前的文章。

[## 熊猫里的情节越来越漂亮了

创建丰富的可视化和仪表板与熊猫绘图后端为 Plotly 和 Bokeh

towardsdatascience.com](/plotting-in-pandas-just-got-prettier-289d0e0fe5c0)

6.分割-应用-组合策略的工具

Hadley Wickham 在 2011 年发表的一篇论文中首次概述了拆分-应用-合并这一有用的数据分析策略。本文详细介绍了一种常见的数据分析模式，通过这种模式，数据首先被分解为合理的、可管理的块或段，对每个单独的段执行操作，然后再次拼凑在一起以形成比较。

这种数据分析模式可以在数据透视表中看到，正如我们在上面描述的那样，也可以在 SQL group by 语句中看到。除了数据透视表，Pandas 还提供了另一种利用这种策略的方法，称为[**groupby()**](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html)。

这种方法，在一行代码中，允许您将数据集分解成片段，执行一些统计计算，然后将这些片段重新组合在一起进行比较。

以下代码按目标变量中的唯一值对数据进行分段，计算每列的平均值，然后显示结果。

7.美观时尚的桌子

如果你想用熊猫分享你的数据分析结果，那么你可能会想让你的数据表看起来更好，更容易被人类消化。Pandas 有一系列的样式选项来控制结果在数据框中的显示方式。

样式选项可以更改数字的显示方式，例如，在百分点上添加%符号、控制小数位数、在结果中添加条件格式或突出显示特定值。

下面的代码将适当的样式应用于我们的数据集中选择的列。输出现在更容易阅读了。

8.使用内置样式轻松创建热图

熊猫内置了一些常见的风格模式。您可以使用其中之一轻松创建热图。

下面的代码将热图格式应用于我们之前创建的 data_summary。

9.使用熊猫选项来控制显示

熊猫有一系列选项，你可以设置它们来控制数据帧的输出。这些可以用来控制要显示的最大行数或列数、显示浮点数时使用的小数位数以及日期显示的格式。

10.给表格添加标题

还有一系列样式可以添加到表格中，以增强数据之外的显示。

例如，您可以像这样给表格添加标题。

感谢阅读！

我每月都会发一份简讯，如果你想加入，请点击此链接注册。期待成为您学习旅程的一部分！

关于 Scikit 你不知道的 10 件事-了解

原文：https://towardsdatascience.com/10-things-you-didnt-know-about-scikit-learn-cccc94c50e4f?source=collection_archive---------24-----------------------

…直到现在

莎莎的故事在 Unsplash 上的照片

Scikit-learn 是使用最广泛的 Python 机器学习库之一。它有一个标准化和简单的界面，用于预处理数据和模型训练，优化和评估。

该项目最初是由 David courna peau 开发的谷歌代码之夏项目，并于 2010 年首次公开发布。自创建以来，该库已经发展成为一个丰富的生态系统，用于开发机器学习模型。

随着时间的推移，该项目开发了许多方便的功能和能力，增强了它的易用性。在本文中，我将介绍您可能不知道的 10 个最有用的特性。

1.Scikit-learn 有内置的数据集

Scikit-learn API 内置了各种各样的 玩具和真实世界数据集 。这些可以通过一行代码来访问，如果您正在学习或者只是想快速尝试一种新的功能，这些非常有用。

您还可以使用 生成器 轻松生成合成数据集，用于回归make_regression()、聚类make_blobs()和分类make_classification()。

所有加载实用程序都提供了返回已经分割为 X(特征)和 y(目标)的数据的选项，以便它们可以直接用于训练模型。

2.第三方公共数据集也很容易获得

如果你想直接通过 Scikit-learn 访问更多种类的公开可用数据集，有一个方便的功能可以让你直接从 openml.org 网站导入数据。该网站包含超过 21，000 个不同的数据集，用于机器学习项目。

3.有现成的分类器来训练基线模型

为项目开发机器学习模型时，首先创建基线模型是明智的。这个模型本质上应该是一个“虚拟”模型，例如总是预测最频繁出现的类别的模型。这提供了一个基准来测试你的“智能”模型，这样你就可以确保它比随机结果表现得更好。

Scikit-learn 包括一个用于分类任务的[**DummyClassifier()**](https://scikit-learn.org/stable/modules/generated/sklearn.dummy.DummyClassifier.html) 和一个用于基于回归的问题的**DummyRegressor()**。

4.Scikit-learn 有自己的绘图 API

Scikit-learn 有一个内置的 绘图 API ，它允许您在不导入任何其他库的情况下可视化模型性能。包括以下绘图实用程序:部分相关图，混淆矩阵，精确回忆曲线和 ROC 曲线。

5.Scikit-learn 具有内置的特征选择方法

提高模型性能的一种技术是仅使用最佳特征集或通过移除冗余特征来训练模型。这个过程被称为特征选择。

Scikit-learn 有许多功能来执行 特征选择 。一个例子就是众所周知的[**SelectPercentile()**](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html#sklearn.feature_selection.SelectPercentile)。该方法根据所选的统计方法来选择表现最好的 X 百分位特征进行评分。

6.管道允许你将机器学习工作流程中的所有步骤连接在一起

除了为机器学习提供广泛的算法，Scikit-learn 还提供了一系列预处理和转换数据的功能。为了促进机器学习工作流程的可重复性和简单性，Scikit-learn 创建了管道 ，允许您将众多预处理步骤与模型训练阶段链接在一起。

管道将工作流中的所有步骤存储为单个实体，可以通过 fit 和 predict 方法调用该实体。当您对管道对象调用 fit 方法时，预处理步骤和模型训练会自动执行。

7.使用 ColumnTransformer，您可以对不同的特性应用不同的预处理

在许多数据集中，您将拥有不同类型的要素，这些要素需要应用不同的预处理步骤。例如，您可能混合了分类数据和数值数据，您可能希望通过一键编码将分类数据转换为数值数据，并对数值变量进行缩放。

Scikit-learn 管道有一个名为column transformer的函数，它允许您通过索引或指定列名来轻松指定对哪些列应用最合适的预处理。

8.您可以轻松地输出管道的 HTML 表示

管道通常会变得非常复杂，尤其是在处理真实世界的数据时。因此，Scikit-learn 提供了一种方法来输出管道中步骤的 HTML 图，这非常方便。****

9.有一个绘图功能来可视化树木

[**plot_tree()**](https://scikit-learn.org/stable/modules/generated/sklearn.tree.plot_tree.html)功能允许您创建决策树模型中的步骤图。

10.有许多第三方库扩展了 Scikit-learn 的特性

许多第三方库都可以使用 Scikit-learn 并扩展它的特性。

两个例子包括 类别编码器 库，它为分类特征提供了更大范围的预处理方法，以及 ELI5 包，用于更好的模型解释能力。

这两个包也可以直接在 Scikit-learn 管道中使用。

感谢阅读！

我每月发送一份时事通讯，如果你想加入，请通过此链接注册。期待成为您学习旅程的一部分！

关于 Python 中的集合，你应该知道的 10 件事

原文：https://towardsdatascience.com/10-things-you-should-know-about-sets-in-python-9902828c0e80?source=collection_archive---------14-----------------------

Python 中集合的使用指南

1.什么是 Python 集合？

一个集合是一个无序和可变的唯一元素的集合。集合用花括号( {} )表示，是用逗号分隔的元素。

下面的代码块显示了两个集合，包含数字和城市的集合。

任何不可变的数据类型都可以是集合中的元素(例如字符串和整数)。如果试图在集合中使用可变数据类型，就会引发异常( TypeError )，如下所示。

2.用 set()构造函数创建一个集合

集合也可以用内置函数集合(【iterable】)定义。该函数将 iterable(即任何类型的序列、集合或迭代器)作为参数，返回包含输入中唯一项的集合(删除重复值)。

如上所示，输入项的原始顺序没有保持，因为集合是无序的容器。

我们也可以使用没有任何输入参数的 set() 构造函数。在这种情况下，构造函数返回一个空的集合。

3.向集合中添加元素

要将一个元素添加到一个集合，我们使用 set.add(element) 方法。该方法就地修改集合，返回 None 。

如下图所示，。如果元素已经存在，add() 方法不会将元素添加到集合中，因为集合不能包含重复的项目。

与列表不同，我们不能在给定的索引处插入元素，因为集合是无序容器，这意味着元素在集合中没有特定的位置。

4.从集合中移除元素

从集合中移除元素有三种方式:

• 使用 set.remove(x) 方法
• 使用 set.discard(x) 方法
• 使用 set.pop() 方法

该移除方法

set.remove(x) 方法从集合中移除一个元素 x 。该方法修改设置在位，返回无。如果元素 x 不存在，则引发异常( KeyError )。

丢弃方法

set.discard(x) 方法从一个集合中移除一个元素 x ，如果它存在的话。与移除方法相比，如果要移除的元素不存在，丢弃方法不会引发异常( KeyError )。

如上图所示，丢弃方法修改设置在位，返回无。

流行方法

set.pop() 方法从集合中移除并返回任意元素。

与列表相比，弹出方法没有任何参数。我们不能指定想要移除的索引，因为集合是一个无序的元素集合。

5.数学运算:并、交、差和对称差

我们可以使用 Python 中的集合来计算并、交、差、对称差等数学运算。这些逻辑运算可以用一个叫做维恩图的图来表示。文氏图广泛应用于数学、统计学和计算机科学中，以可视化集合之间的差异和相似性。我们可以使用第三方库 matplotlib-venn 绘制面积加权的二圆和三圆维恩图。💜

给定两个集合，一个包含哺乳动物，另一个包含水生动物。

我们可以用下面的方式计算上述数学运算。

联盟

两套 A 和 B 的并集是包含 A 、 B 或两者中元素的集合，用 A ∪ B 表示。

文氏图的红色阴影区域代表哺乳动物和水生动物集合的联合。

两个集合的并

为了用 Python 计算这个操作，我们可以使用 set.union(另一个集合)方法或者 | 操作符。

两个集合的并

如上所示，两者都返回一个包含哺乳动物和水生动物集合中所有项目的新集合。

交集

两个集合 A 和 B 的交集是包含两个集合共有元素的集合，用 A ∩ B 表示。

文氏图的红色阴影区域代表哺乳动物和水生动物集合的交叉点。

两个集合的交集

在 Python 中，我们可以使用 set.intersection(另一个集合)方法或 & 运算符来计算两个集合的交集。

如您所见，交集方法和 & 操作符返回一个新的集合，包含两个集合中存在的项目，而不修改它们。

差异

两个集合 A 和 B 的差是集合 A 中不包含在集合 B 中的所有元素的集合，用 A-B 表示。

文氏图的红色阴影区域代表哺乳动物和水生动物(哺乳动物-水生动物)的差异。这一组包括哺乳动物，但不是水生动物。

哺乳动物减去水生动物的差异

我们还可以获得水生动物而不是哺乳动物，计算水生动物和哺乳动物之间的差异。

水生动物减去哺乳动物的差异

要在 Python 中计算两个集合之间的差，我们可以使用 set.difference(另一个集合)方法(set-other set)或( - )运算符。

正如您所观察到的，哺乳动物和水生动物这两个集合没有被就地修改。

对称差

两个集合 A 和 B 的对称差是在集合 A 和 B 中的一个集合中，但不在两个集合中的元素集合，用A△B表示

下面的维恩图表示哺乳动物和水生动物(红色阴影区域)集合的对称差。这一组包括哺乳动物和水生动物，但不包括两者。

两个集合的对称差

在 Python 中，我们可以使用set . symmetric _ difference(another set)方法或 ^算子找到两个集合的对称差，如下所示。

6.子集和超集

A 集合 A 是 a 集合 B (A ⊆ B) 的子集或者等价地集合 B 是 a集合 a(b⊇a)的超集，如果集合 A 的所有元素都包含在集合 B 中。

下面的维恩图代表两组哺乳动物和水生哺乳动物，是水生哺乳动物哺乳动物的子集。

为了检查集合 A 是否是集合 B 的子集/超集，我们可以使用以下方法:

• A.issubset(B) →如果集合 A 的所有元素都包含在集合 B. 中，则该方法返回 True
• A.issuperset(B) → 如果集合 B 的所有元素都包含在集合 A 中，则该方法返回 True 。

下面的代码块使用这两种方法来检查一个集合是否是另一个集合的子集/超集。

7。不相交

如果两个集合没有公共元素，则它们是不相交的。以下两组哺乳动物和爬行动物是不相交的集合，因为它们的交集是一个空集。

我们可以使用 set.isdisjoint(另一个集合)方法检查两个集合是否不相交。如果两个集合没有共同的元素，这个方法返回 True 。如果有，它返回假。

8.检查元素是否存在于集合中

为了检查一个元素是否存在于集合中，我们必须使用一个成员操作符。成员运算符用于测试序列中是否存在某个元素(例如字符串、列表、元组、集合或字典)。有两个成员资格运算符，如下所述。

• 中的→如果左侧的对象包含在右侧的对象中，则评估为真。
• 不在中→如果左侧的对象不在右侧的对象中，则评估为真。

9.求一个集合的长度

要确定集合中包含多少个元素，我们可以使用 len() 函数。这个函数返回一个对象的项数。函数的输入不仅可以是集合，也可以是另一种类型的序列，如字符串、字典、列表或元组。

10。替代容器:冷冻器

一个 frozenset 对象是一个一旦被创建就不能被改变的集合。我们使用frozenset(【iterable】)构造函数在 Python 中创建一个 frozenset，提供一个 iterable 作为输入。

由于 frozensets 是不可变的，它们不接受就地修改集合的方法，例如 add 、 pop 或 remove 。如下所示，试图将一个元素添加到一个 frozenset 中会引发一个异常( AttributeError )。

与集合不同，frozensets 可以用作字典中的键或另一个集合的元素。

有趣的网站

除了官方的 Python 文档之外，还有多个网页提供了如何使用集合的详细解释和示例。

[## Python 集合

集合是一个没有顺序和索引的集合。在 Python 中，集合是用花括号写的。创建一个集…

www.w3schools.com](https://www.w3schools.com/python/python_sets.asp) [## Python 集(带示例)

集合是项目的无序集合。每个集合元素都是唯一的(没有重复)并且必须是不可变的(不能是…

www.programiz.com](https://www.programiz.com/python-programming/set) [## Python 中的集合-真正的 Python

在本教程中，您将学习如何有效地使用 Python 的 set 数据类型。

realpython.com](https://realpython.com/python-sets/)

更多关于 Python 容器的文章

[## 关于 Python 中的列表，你应该知道的 15 件事

Python 中列表的使用指南

towardsdatascience.com](/15-things-you-should-know-about-lists-in-python-c566792eca98) [## 关于 Python 中的字典，你应该知道的 15 件事

Python 中词典的使用指南

towardsdatascience.com](/15-things-you-should-know-about-dictionaries-in-python-44c55e75405c)

阿曼达💜

Java 中你做错的 10 件事

原文：https://towardsdatascience.com/10-things-youre-doing-wrong-in-java-7608e2f050c7?source=collection_archive---------1-----------------------

Java 开发人员最常犯的错误

由 Max Duzij 在 Unsplash 上拍摄的照片

在我的职业生涯中，我面试过几十个软件工程师，从初级到高级技术领导。在许多情况下，候选人在基本概念上有差距。

在本文中，我将根据我作为技术领导者和采访者的经验，列出 Java 开发人员最常犯的错误。

1)忽略访问修饰符

不要问我为什么，考生经常忘记 Java 中受保护的访问修饰符的作用域。可能是面试中积累的焦虑和紧张，但通常他们只提到两者之一:

• 受保护的字段、方法和构造函数可以从同一个包中访问
• 可以从子类中访问受保护的字段、方法和构造函数

我真的不知道忘记哪个更糟糕，但不引用包级范围揭示了候选人从未测试过受保护的方法(受保护的项可从测试类路径访问，只要包是相同的)；公共的和受保护的方法是你的软件提供的 API 的一部分。所以忘记这个属性就相当于在一次采访中宣称从来没有为你的软件编写过有意义的测试！

2)不使用 equals()

如果你使用==(比较运算符)而不是equals()调用，那么你必须改变你的习惯，因为结果可能会让你大吃一惊。

说明

当你想比较两个String时，千万不要用==，一般来说，不要用任何物体。==只是比较两个操作数的对象引用(内存地址比较)而不是它们的内容。

在上面的例子中，字符串y并没有受益于字符串内部化:它的内存地址不同于x的地址。

3)字符串连接

如果你处理大量的字符串或者巨大的String，你可能会在连接过程中浪费大量的内存。

在上面的例子中，您正在创建几个StringBuilder和String对象:准确地说是 10.000.000 StringBuilder和 10.000.001 String！

说明

为了理解正在发生的事情，我们必须后退一步。

当您使用+操作符进行字符串连接时，您正在创建一个中间对象，它在将值赋给目标对象之前存储连接的结果。

在上面的例子中，我们一共创建了 3 个对象:2 个用于文字，1 个用于连接，即第一个字符串result加上第二个" world!"的副本。这是因为String是不可变的。

但是编译器足够聪明，可以将代码转换成以下代码(不适用于 java 9+，因为它使用了[StringContactFacotry](https://docs.oracle.com/javase/9/docs/api/java/lang/invoke/StringConcatFactory.html)，但是结果非常相似)

这种优化移除了中间串联对象，内存被 2 个字符串文字和 1 个StringBuilder占用。一般情况下，字符串对象的数量从 O(n ) 下降到 O(n) 。

回到第一个例子，编译器像这样优化代码

编译器只是优化了内部连接，但是这会创建大量的StringBuilder和String对象！连接字符串的正确方法如下，只需要 1 个StringBuilder和 1 个String

不错的进步！

4)字符串形式的密码

将用户提供的密码存储在字符串对象中是一个安全问题，因为它们容易受到内存攻击。

你应该使用char[]，因为[JPasswordField](https://docs.oracle.com/en/java/javase/12/docs/api/java.desktop/javax/swing/JPasswordField.html)和 Password4j 已经在做了。如果我们谈论 web 应用程序，大多数 web 容器在HttpServletRequest对象中以String的形式传递纯文本密码，所以在这种情况下，您几乎无能为力。

说明

字符串由 JVM 缓存(interning)并存储在 PermGen 空间(Java 8 之前)或堆空间中。在这两种情况下，缓存的值仅在垃圾回收发生后被删除:这意味着您不知道特定的值何时从字符串池中被删除，因为垃圾回收器的行为是非确定性的。

另一个问题是String是不可变的，所以你不能清除它们。然而char[]并不是不可变的，在处理之后可以被删除(例如用0替换每个元素)。通过这个简单的技巧，攻击者可以在内存中找到清零的数组，而不是明文密码。

5)返回空值

我发现过多少次这样的方法:

返回null的问题是，您强迫调用者对结果进行空检查；在这种情况下，调用者希望如果没有条目，那么将返回一个空列表。

你总是想返回一个异常或者一个特殊的对象(比如一个空列表),否则使用你的代码的应用程序将会受到NullPointerException的影响

6)传递空值

另一方面，传递null意味着你想当然地认为你调用的代码可以管理一个null。如果这不是真的，你的应用程序肯定会抛出一个NullPointerException。

当你显式地传递null时，你会在你的代码中产生很多混乱。下面是一个经典的例子

调用init()时，没有User对象可用。那么，如果你连一个User都没有，为什么要调用一个用User操作的方法呢？如果你需要包含在grantAccessToUser()中的逻辑，你应该用不同的方法提取并使用它，而不是传递一个null。

7)重方法

以下示例可能会导致您系统的性能损失:

Pattern.compile()是一个重方法，不应该在每次需要检查字符串是否匹配相同模式时调用它。

说明

Pattern.compile()预编译模式，以便使用更快的内存表示。与单个匹配相比，该操作需要不可忽略的计算能力。

提高性能的一个经典方法是在静态字段中缓存Pattern对象，如下所示:

每当您重用同一个计算量很大的无状态对象时，都应该使用这种解决方案。

8)使用“返回代码”而不是抛出异常

在某种程度上，开发人员认为异常是邪恶的，他们倾向于编写返回奇怪值的方法，比如-1或"C_ERR"。

这是一个值得创建自定义Exception的典型案例。然后，该示例可以重写如下:

如您所见，可读性和可维护性大大提高了。调用者不必处理每一个返回代码，只需读取DeviceStartException的内容。

9)迭代时触摸集合

这段代码会抛出一个ConcurrentModificationException。

说明

在对列表进行迭代时从列表中删除一个项目会使列表迭代器表现不佳，例如跳过元素、重复元素、索引数组末尾等。这也是为什么很多收藏更喜欢扔个ConcurrentModificationException的原因。

您应该使用底层数组的迭代器:

10)使用字符串缓冲区

由于StringBuffer的同步特性，这个例子产生了大量的开销。在更复杂的上下文中，读者可能会认为需要同步，而实际上并不需要。

如果你在一个项目中发现了一个StringBuffer，这可能是因为一些遗留 API(即 Java 5 之前)需要它，很少是因为你的代码试图在并发上下文中添加String。

用StringBuilder代替:随 Java 5 引入，所有操作不同步。

结论

这只是我在采访和许多活跃的项目中看到的错误的一个子集。我甚至没有提到 OOP 的陷阱，设计模式，过度工程，内存泄漏等等…

如果你正在犯这些错误，现在是时候改变你的编码风格，让你的应用程序更易维护，更安全。这并不难，避免这些陷阱会提高你作为开发人员的经验，并且会自动让你为下一次面试做好准备。

继续学习任何编程语言背后的理论，而不仅仅是语法，多写代码，使用静态代码分析器，比如 SonarQube，因为它可以指出实际的错误并突出潜在的错误。

来源: xkcd

更好的 Google Colab 体验的 10 个技巧

原文：https://towardsdatascience.com/10-tips-for-a-better-google-colab-experience-33f8fe721b82?source=collection_archive---------1-----------------------

杰森·塔西曼在 Unsplash 上的照片

Colab 是一个伟大的编码工具。我经常使用它，用于大量的任务，从传统的机器学习到使用 PyTorch、TensorFlow 或 OpenCV 的深度学习应用程序。有了 Google Colab ，创建和共享笔记本变得直观而简单😃

以下是我长期收集的 10 个技巧和窍门，可以帮助你充分利用 Google Colab。

目录:

1. 使用键盘快捷键节省时间
2. 将您的 Google Drive 安装到 Colab 上
3. 运行 bash 命令
4. 上传/下载文件
5. 激活 GPU 和 TPU
6. 将 Colab 链接到 GitHub
7. 阻止 Colab 断开
8. 将数据框显示为交互式表格
9. 配合 Colab 使用 TensorBoard】
10. 改变显示模式

1.使用键盘快捷键节省时间

您可以通过选择“工具”→“键盘快捷键”来访问所有快捷键。

但这里是我选择的 5 个最佳:

• 撤消上一个操作(在单元格内): ctrl + m + z
• 查找并替换: ctrl + m + h
• 在上面插入代码单元格: ctrl + m + a
• 在下面插入代码单元格: ctrl + m + b
• 删除单元格: ctrl + m + d

请务必查看其他快捷方式，并定制您最喜欢的快捷方式！

2.将你的谷歌硬盘安装到 COLAB

这项功能对于访问存储在 Google Drive 上的文件非常有用。这也是保存模型和数据的最佳方式。为此，只需输入以下代码片段:

**from** google.colab **import** drive
drive.mount('/content/gdrive')

该单元将返回以下内容:

点击链接，让谷歌 Colab 访问你的驱动器，并检索授权码。粘贴，就大功告成了！

现在，您可以使用批处理命令!cd或左侧的“文件”面板来访问位于
/content/g Drive/My Drive/
下的 Google Drive 文件。

3.运行 BASH 命令

Bash 命令可以通过在命令前面加上“！”来运行。
举例:

• 用!wget <ENTER URL>从网上下载数据集
• 用!pip install <LIBRARY>或!apt-get install <LIBRARY>安装库
• 运行一个现有的。带!python script.py的 py 脚本
• 用!git clone <REPOSITORY URL>克隆一个 git 库

4.上传/下载文件

要从您的计算机上传一个(或多个)文件，请运行:

**from** google.colab **import** files
files.upload()

要下载文件，请运行:

**from** google.colab **import** files
files.download('path/to/your/file')

另一种方法是使用左侧面板上的文件浏览器，拖动&拖放。

⚠️请注意，你一离开谷歌实验室，这些文件就会消失。

5.激活 GPU 和 TPU

Google Colab 的默认硬件是 CPU。然而，您可以为深度学习等计算要求更高的任务启用 GPU(甚至 TPU)支持。

点击:“运行时”→“更改运行时类型”→“硬件加速器”。然后选择所需的硬件。

通过执行以下代码，您可以轻松检查 GPU 是否已启用:

import tensorflow as tf
tf.test.gpu_device_name()

6.将 COLAB 链接到 GITHUB

打开 Colab 下的 GitHub 文件:

要打开 GitHub 上托管的笔记本，有 3 个选项:

• 前往 https://colab.research.google.com 的切换到 GitHub 标签，输入笔记本的网址
• 该笔记本带有一个“在 Colab 中打开”的徽章，允许您直接在 Google Colab 上打开它。
  插入 README.md 文件的降价代码是:

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googlecolab/colabtools/blob/master/notebooks/colab-github-demo.ipynb)

• 使用“在 Colab 中打开”镀铬加长件。安装后，每当你在 GitHub 中找到一个 Jupyter 笔记本，点击插件的图标，它就会在 Colab 中打开。

将 Colab 笔记本保存在 GitHub 存储库中:

跟随:“文件”→“在 GitHub 中保存一个副本”。一旦点击，它将要求您的 git 帐户的授权。最后，您将能够将 collaboratory 笔记本保存到您选择的存储库中。

7.阻止 COLAB 断开连接

因闲置而断开连接:

这是 Google Colab 的一个很大的缺点，我相信你们很多人至少遇到过一次这个问题。你决定休息一会儿，但是当你回来的时候，你的笔记本是断开的！

实际上，如果我们让笔记本闲置超过 30 分钟，Google Colab 就会自动断开连接。🕑

在 Linux 上，通过按 F12 或 ctrl+shift+i 打开 Chrome DevTools，并在控制台中输入以下 JavaScript 代码片段:

**function KeepClicking**(){
console.log("Clicking");
document.querySelector("colab-connect-button").click()
}
**setInterval**(KeepClicking,60000)

该功能每 60 秒点击一次连接按钮。由此，Colab 认为笔记本不是闲置的，你不用担心断线！

任务运行时断开连接:

首先，要知道当你连接到 GPU 时，你在云机器上一次最多有 12 个小时。

有时你会被切断连接，即使是在这 12 小时的时间间隔内。如 Colab 的 FAQ 中所解释的:“协同实验室是为了交互使用。长时间运行的后台计算，特别是在图形处理器上，可能会停止。”😕

8.将数据框架显示为交互式表格

Colab 包括一个扩展，可以将 pandas 数据帧呈现到交互式表格中，这些表格可以被动态地过滤、排序和浏览。

用%load_ext google.colab.data_table启用该扩展，用%unload_ext google.colab.data_table禁用

9.配合 COLAB 使用 TENSORBOARD

TensorBoard 是一种工具，用于提供深度学习工作流程中所需的测量和可视化。它可以直接在 Colab 中使用。📉 📈

首先加载 TensorBoard 笔记本扩展:

%load_ext tensorboard

创建模型后，使用以下命令在笔记本中启动 TensorBoard:

%tensorboard --logdir logs

更多细节，请查看关于该主题的 Tensorflow 教程。

10.更改显示模式

黑暗模式:很多人更喜欢这种模式，因为它对他们的眼睛来说更放松。您可以按照“工具”→“设置”→“主题”来激活它。

对于猫&爱狗人士:对，有 Kitty 和 Corgi 模式。进入“工具”→“设置”→“其他”。在这里，你可以选择模式，你会看到你的猫和狗在你的屏幕上漫步！😹 🐶

我希望这篇文章对您有所帮助，并且您将继续使用这个精彩的免费工具。请在下面的评论中分享你的额外建议。编码快乐！

为了进一步阅读，你可以看看这篇非常详尽的博文:

[## 如何在 Google Colab 中处理文件:你需要知道的一切- neptune.ai

谷歌合作实验室是一个免费的 Jupyter 笔记本环境，运行在谷歌的云服务器上，让用户…

海王星. ai](https://neptune.ai/blog/google-colab-dealing-with-files)

成功实习的 10 个秘诀

原文：https://towardsdatascience.com/10-tips-for-a-successful-internship-e8f0c14cd3d3?source=collection_archive---------48-----------------------

实习/数据/教育

关于充分利用暑期数据实习的思考

来源

在我最后四周的实习中，我思考了很多我所学到的东西，以及为什么我觉得我的实习是成功的。现在，当我说成功时，我并不是说我开发了一个突破性的模型，可以准确预测客户何时会购买产品，我的意思是成功，因为我在实习期间学到了比我想象的更多的东西，我觉得我真正理解了数据专业人员的工作。

我的成功很大一部分来自我今年夏天实习的公司，但我也觉得我知道该做什么，因为我的第一次实习远没有那么成功。这里有十条建议，将帮助你在下一次实习中获得成功！

免责声明:我不是全职的数据专家，我只是简单地转述我在暑期实习中的经验。这并不是要告诉你该做什么，而是从我的经历中给你一些建议。如需了解此信息，请查看 走向数据科学 。如果你对一些能帮助你从实习中获得最大收益的建议感兴趣，请继续阅读！

技巧 1:提问

这可能是你能收到的最老套的建议了。每当有人问我，“你有什么问题吗？”，90%的时候我会回答，“不，我想我明白了！”。这是我实习期间的一个主题，也是我目前实习的第一部分，直到我实习期间的营销策略师，他也非常热爱数据，给了我一些非常好的建议:“作为数据专业人员，我们的整个工作都是围绕提问进行的。下次有人问你有什么问题时，挑战自己，超越你想知道的，问你认为你应该知道的”。所以下次有人问你有什么问题时，挑战自己问一个更深层次的问题。你的同事和主管会把它看作是智慧和学习热情的标志，你也会在数据工艺中练习一项基本技能，那就是提问！

“作为数据专业人员，我们的整个工作就是围绕提问展开的。下次有人问你有什么问题时，挑战自己，超越你想知道的，问你认为你应该知道的。”

秘诀 2:每天早上对你的同事说“早上好”

如果你读过我之前的故事， 我作为营销分析实习生 学到的东西，那么你会记得我是如何提到建立关系是一项极其重要的技能。摆脱这个想法，做一些简单的事情，比如说“早上好！”向你的同事表明你承认他们的存在，并关心和他们在一起。这不仅有助于与你的同事建立关系，而且坦率地说，这也会让你的经历更加愉快！你会觉得自己是团队的一部分，因为当你在乎时，你的同事也会在乎。

提示 3:在办公室之外练习你所学的东西

熟能生巧！数据专业人员不仅仅是科学家和分析师，他们还是工匠和建筑工人。正如艺术家和音乐家完善他们的工艺(个人经历另当别论)，数据专业人员也是如此。如果你看到有人做你不知道如何去做的事情，不管是首席信息官还是实习同事，向他们学习并实践！在观看了用 Python 工作的终身市场分析师之后，我每天回家至少花一个小时练习我的 Python 编程技能。当你的同事和主管看到你的技能在他们眼前增长，他们会更倾向于让你尝试更困难和更有价值的项目！

技巧 4:没有一项任务是微不足道的

如果你的一个同事问你是否可以梳理一个 200，000 行的电子表格并清理一些数据，那么就去做吧！无论你在机器学习和数据科学/分析方面有多少经验，都不要觉得任何任务都有失身份。在我第一次实习期间，这对我来说是一个挑战，因为我认为自己“太优秀了”，无法梳理电子表格。我很快意识到这不是明智之举。接受任务显示了你的谦逊，团队合作的能力，坦率地说，会让你用数据测试你的技能。我是说，我们都是有抱负的数据专家，不是吗？

提示 5:尽可能多的会见一些人

直到你遇见一个人，你才会了解他。今年夏天，我从营销自动化部门以外的人那里学到了很多东西。我见过商业智能、销售、营销传播和信息服务方面的人。这些人都在某种程度上帮助了我的成长，并且分享了他们职业生涯中一些非常精彩的故事。你所要做的就是给他们发一封电子邮件或者去他们的办公室说，“你好！我的名字叫 ______。我是实习生之一，我真的很有兴趣找个时间一起吃顿午饭，向你请教一下！”。你会惊讶有多少非常成功的专业人士愿意和你坐下来分享他们所知道的！

秘诀 6:成为团队的一员

每个人都喜欢团队成员。如果你是一个走进办公室的实习生，把你的脚放在桌子上，开始谈论你的大学如何是最好的，你基本上是一个受过 2-3 年教育的数据大师，你将不会被很好地接受。现在想象一下，你走进办公室，对每个人说早上好，问你同事的孩子生日过得怎么样，问你的经理今天早上是否需要他们做什么，你会受到很好的接待。实习的目的是看你是否适合可能的就业机会。如果你表现出你想成为团队的一员，并帮助团队取得成功，当你的简历出现在某人的办公桌上时，你会显得非常漂亮。

“现在想象一下，你走进办公室，向每个人说早上好，询问你同事的孩子生日过得怎么样，并问你的经理今天早上是否需要他们做什么，你会受到很好的接待。"

秘诀 7:要有雄心壮志

在大多数实习中，你的同事会支持你，帮助你学习。如果你想接手一个比你一直在做的项目更大的项目，那就去问吧！如果你想做一些模型建设，然后问！你的同事希望你成功，所以如果你因为好奇而想做某件事，或者想测试你的技能，一定要向你团队中的某个人提起，因为他们很有可能帮助你实现它！

提示 8:推销你的品牌

正如我所说的，大多数实习的目的是看你是否适合公司的长期职位。然而，你需要向你的同事展示你能为公司提供价值。在这种情况下，能够推销自己是非常重要的。确保你来上班时看起来很专业，在电子邮件中使用专业语言，并试图在你做的每个项目中提供价值，这是至关重要的。这会让你的同事知道你关心这个组织，关心你所做的工作。如果他们从你这里看到这些，他们很可能会检查你的工作，看看你在做什么！

技巧 9:与你的实习生同事建立联系

如果你参加的实习项目中有不止一个实习生，那么试着和他们建立关系！这一点很重要，因为通常来说，实习项目中的大部分实习生年龄都差不多，职业生涯也差不多。认识他们意味着有机会向他们学习，和他们交往，和他们成为朋友！你永远不知道，十年后你可能正在找工作，而你的一个实习生同事恰好是你正在寻找的一家公司的副总裁。如果他们记得你特意和他们做朋友，并且希望现在还是朋友，他们会更愿意帮助你。

技巧 10:保存你的经历！

这个很重要。实习是快节奏的，在接下来的几个月里，你每天都会收到大量的信息。我敢说，仅仅通过听不可能 100%记住这些信息。每天结束时，写一段关于你所学到的东西，把它和你的项目以及其他有形的文件放在同一个地方。这样，你就可以在整个夏天以及实习结束后的几个月里参考这些信息，继续保留你所学到的所有信息。

如果这有帮助，请让我知道！我真的很喜欢写关于数据的文章，并且很乐意写更多关于数据作为一门手艺，如何在实习中脱颖而出的文章，并且分享更多我从技术角度学到的东西！大家注意安全，祝你们有美好的一天！

若要联系我或接收更多内容，请在 Twitter 上关注我@BMNAnalytics！

教授数据科学的 10 个技巧

原文：https://towardsdatascience.com/10-tips-for-teach-data-science-474d49eb9c5e?source=collection_archive---------78-----------------------

学生对数据科学教学的看法

https://unsplash.com/photos/5fNmWej4tAA

在我提到如何更有效地教授数据科学的任何技巧或建议之前，我想先说教授数据科学不是一件容易的事情。有这么多的应用领域和子领域，没有一个类或一系列类可以涵盖数据科学的世界。此外，我想强调的是，这里的一切只是我对数据科学世界的看法——我研究过这个世界，但只是最近才出现。

话虽如此，我仍然相信有许多有用的建议可以帮助学生在课堂上学习数据科学。当我从课堂学习过渡到商业世界时，我不禁注意到两者之间的脱节以及如何缩小这种差距。下面是 10 个提示，我相信它们不仅会进一步增强数据科学学习体验，还会帮助个人为数据科学职业做好准备。

1.命名游戏

在计算机科学中，你学到的第一件事就是变量应该被恰当而简洁地命名。太长的名字输入起来效率很低，而且会使代码变得笨拙。太短的名称可能不足以代表变量的内容。似乎有某种中间地带的甜蜜点，但你如何找到它。我对最佳命名实践的建议是创造尽可能短的名字，这样除了你自己之外的人(限于对代码或项目一无所知)可以准确地说出变量代表什么。

虽然糟糕的命名最糟糕的例子会导致开发人员自己忘记一个变量代表什么，但大多数时候不遵守命名游戏的规则会让其他人感到困惑。糟糕的变量赋值效果也可以在一个人的代码环境之外看到。数据库经常包含大量糟糕的属性命名的例子，包括无法解释的首字母缩略词，过多的下划线等等。有时这些策略是必要的，因为变量可以代表相当复杂的想法和数字。然而，当利用这些实践时，重要的是记录这些混淆的区域，以便将来的用户或代码/数据库的编辑(包括你自己)不会迷失。

2.代码之外的注释

在编码或开发数据科学项目时，变量赋值只是一个潜在的混淆来源。由于某些代码块可能变得相当复杂，注释通常被视为解释一些复杂性的一种方式。然而，注释经常随机散布在代码各处，作为开发人员的短期提醒，而不是为用户或后来的代码编辑设计的。拥有可读和干净的代码可以说与拥有可以流畅运行的代码一样重要，因此应该向学生强调这一点。在我看来，一个人对代码中发生的事情解释得越多，他们就越有可能期待代码在实践中使用得越久。如果只有你自己能够理解它是如何工作的，那么一旦你开始工作，它就更有可能死去。

正如本技巧的标题所解释的，并不是所有的注释和解释都需要在代码中完成。经常可以看到人们开发 READMEs，即包含程序有用信息的文本文件。虽然我在大学时一直写这些，但我觉得它们没有得到足够的重视。我看到的一个强调干净和解释清楚的代码的重要性的实践是允许学生们互相检查代码。这不仅能让学生理解外部资源能够理解一个人的工作是多么重要，而且还能让学生对概念化问题的不同方式有所了解。

3.数据科学

在数据科学领域，你会听到一个最流行的说法，那就是一个项目 80%以上的时间都花在了数据争论和清理上。虽然我不确定 80%的统计数据是否准确(从一些公开进行的调查来看，似乎更像是 60%)，但数据清理在数据科学家的生活中确实是一项既耗时又关键的任务。数据是拼图中的一大块，如果您不理解它并以正确的方式构建它，您的项目很可能从一开始就注定失败。

因此，一旦收到数据集，课堂必须教授探索数据集的正确方法，以及清理和争论数据集的正确技术。任何项目的第一步都应该是深入研究数据。执行探索性数据分析技术。过滤无关的数据点。确定如何处理缺失/空值和重复值。评估是否有必要进行类型转换。执行数据标准化、转换或归约方法。数据科学项目的输出只能与其输入一样有价值，或者换句话说，垃圾输入就是垃圾输出。

3a。真实与虚假

快速补充说明。我更倾向于认为真实的数据集总是比假的好。我的真实是什么意思？基本上任何不是为了学生学习或机器学习作业的唯一目的而创建的数据集。现在有多个公开可用的数据集库，跨越不同的领域。谷歌的数据集搜索引擎和 Kaggle 的数据集都是学生获得实践机会的绝佳起点。对于初学者，我会推荐 Kaggle 的泰坦尼克号:灾难中的机器学习或者房价:高级回归技术。对于更高级的学生，我建议让他们根据自己的兴趣找到自己的数据集。

4.数据科学

数据科学最被低估的部分之一是该领域如何与其标题的后半部分相关联。例如,“科学”领域与数学领域有很大的不同，因为数学通常不包含歧义，一个人对一个问题的答案要么是 100%正确，要么是 0%正确。数据科学就不是这样了。

从本质上来说，数据科学家应该探索和进行“实验”，以查看他们的先入之见是否可以被支持或反驳。人们应该对他们的数据和项目提出假设，并努力找到令人信服的证据来证实或反驳。学生必须学会快速失败，永远不要害怕失败，而是拥抱失败。他们必须学会区分容易解决的问题(可以迅速解决)、难以解决的问题(需要付出相当多的血汗和眼泪)和不可能解决的问题(无论采取何种策略或方法都不可能解决)。项目应该经过充分的思考和设计(并记录在案！)才被进行。毕竟，他们不仅仅被称为数据主义者是有原因的。

5.学习>教学

教和学似乎永远交织在一种循环的关系中。为了成为一名好老师，你需要好学生；为了成为一个好学生，你需要一个好老师。但是什么是好呢？我相信有一个正确的老师比有一个好老师更重要，这也是这篇技巧的要点。我们的目标是让学生学习，而不是让教育者去教——因此，学生的学习偏好和需求应该超越教育者的。

我想强调的是，我并没有以任何方式将之前的声明视为对教育者的轻视。我只是断言，如果真正的目标是让学生发挥他们的全部潜力，那么教材必须(至少部分地)适合他们。显然，大多数情况下涉及到一个老师对多个学生的比例，这导致教育工作者得出结论，很难专门为每个学生量身定制学习。但是学生之间有共性。他们有相似的知识基础和解释材料的方式。这条建议的意思并不是说课程应该专门针对每个学生的喜好，而是说教学方法、课程和哲学应该随着时间的推移而发展。“在过去的 20 年里，我一直用同样的方式教这个班，”这句话对我来说是一个主要的危险信号。我和 20 年前的学生已经大不相同了，那么教学方法为什么不应该是这样呢？

6.谷歌——自成一类

这个很简单。我在早期教育和大学期间学到的一件事是，知道如何谷歌是一个游戏规则的改变者。我真诚地相信，整个班级不仅可以学习，而且应该学习如何最有效地使用谷歌。当你只有部分信息时，能够有效地找到问题的答案是至关重要的。

成功的信息检索并不是谷歌应该教授的唯一重要的方面。数据科学家还需要解读哪些信息应该存储在“RAM”(不需要外部查询)和“SSD”(需要外部查询)中。我需要立即知道什么，我可以留给谷歌跟踪什么？掌握两者之间的平衡将减少浪费在寻找答案上的时间，并允许将时间重新分配给更重要的任务。

7.更开放，更不切题

虽然当你知道你在找什么的时候，谷歌是一个很好的工具来找到信息，但是数据科学家并不总是有机会确切地知道他们在找什么。在学校里，我觉得作业或项目的目标经常被详细说明，但是如果在实践中不是这样，为什么项目在学术界是这样进行的呢？

重要的是要将任务放在情境中，不要只关注它们背后的理论和数字，还要阐明它们在实践中可能产生的商业影响。准确度、精度、召回率……都很棒，但只是模型指标，不是模型目标。例如，如果我正在设计一个检测欺诈的系统，其中潜在的欺诈数据点被标记出来并发送进行审查，那么我的模型的更重要的衡量标准是什么——精确度还是召回率？我是否想尝试标记尽可能多的潜在欺诈，即使这意味着标记一些额外的欺诈(最大化回忆)？或者，当我标记一个案例时，我宁愿确保我真的有信心，但可能会错过一些(最大限度地提高精确度)？对于这个例子，我认为最大限度地提高召回率是应该追求的目标，因为错过一个欺诈案件的成本将比标记额外的非欺诈案件的成本高得多。这些是数据科学家在开发模型时必须问和弄清楚的问题——他们必须推动价值，而不是优化数字。

8.越蠢越好

在我看来，最令人印象深刻和“最聪明”的人是那些能够将复杂和令人困惑的概念简化，以便他人消化的人。没有公式可以做到这一点，这在很大程度上取决于你试图将信息传达给谁。许多人似乎喜欢用深奥、费解和令人困惑的技术术语说话，只是为了炫耀和显得更聪明，向自己重申他们实际上有更好的头脑。然而，在教室里(以及任何学习环境中)，这没有任何价值。

这反过来又与该领域越来越强调的一个更广泛的原则相联系——可解释性。复杂的模型和结果可能是惊人的，但这些东西需要解释。天才背后的策划者需要能够将他们创造的想法、概念和价值传达给不同背景和专业知识的人和团体。正因为如此，作为一名学生，在开发个人项目时必须强调可解释性。数据科学家的工作不是成为房间里最聪明的人，并在每次发言时证明这一点。

9.软技能很重要！！

硬技能很重要。这是无可辩驳的。通常情况下，硬技能可以让你迈出第一步，甚至有可能一直走到终点，但软技能可以将一名普通的数据科学家变成最好的数据科学家之一。而且我相信这几乎可以应用到任何领域。核心的知识和专业技能对于成功来说是绝对必要的，但是掌握软的东西才是真正能够脱颖而出的。

可以为数据科学家带来好处的软技能清单很长，因此我将只涉及我认为最重要的几项。强大的沟通技巧和团队合作能力不仅能提高你自己的效率，也能提高你周围团队成员的效率。全面的领域知识可以增加项目的预期价值，并允许您回答关于有效实施和业务影响的迫切问题。高度的批判性思维技能和好奇心会让你的知识领域不断发展，让你更好地推销自己。讲故事和公开演讲可以缩小不同业务线之间的差距，允许更无缝的实施和生产。作为一名教育工作者，重要的是要认识到这些软技能可以像硬技能一样发挥作用。

10.模拟人类

教授数据科学时要记住的一件重要事情是，最有价值和最重要的一块拼图是人，而不是模型或机器。能够思考解决方案、为特定需求构建解决方案以及部署结果都是至关重要的，并且只能由人类来完成。

像数据一样，模型可以被淡化和变形，以显得与众不同。让我们再次回到上面提到的欺诈模型。假设该模型已经过测试，显示可以检测出 91%的欺诈案件。乍一看，那看起来相当令人印象深刻。但是在幕后，80%的测试数据是欺诈案例，只有 20%是非欺诈案例。因此，如果我只是开发了一个基本模型来预测每次欺诈，我就会达到 80%的准确性水平。然而，很明显，如果部署该模型，将无法达到这一水平。

人类必须决定一个模型有多好，如何调整它，以及如何优化它。仅仅因为正在生产一个模型，并不意味着某人就是数据科学家。一个人需要可操作的结果，这需要在学习该学科时强调。

结论

这就是了。这些是我对在数据科学领域教学/发展时要强调的领域和要记住的事情的想法。请随意分享下面的其他提示或建议。感谢阅读！

数据之旅的 10 个技巧(我希望我知道)

原文：https://towardsdatascience.com/10-tips-i-wish-i-had-known-before-starting-a-data-journey-905d83f06c33?source=collection_archive---------29-----------------------

在与数据打交道 6 年多之后，在开始这段奇妙的旅程之前，我想知道以下这些

布拉德利·埃夫隆先生在斯坦福大学为我签名售书《计算机时代的统计推断》。作者照片

关于数据科学、机器学习、人工智能和大数据，人们说了很多。从 【新石油】 的做法，到 【二十一世纪最性感的工作】 ，到一个被炒作的部门的 【欧洲百分之四十的‘人工智能创业公司’实际上并不使用人工智能，索赔报告】 。

在一个新行业的兴起过程中，承诺和期望不断涌现。很多人都在研究这个领域，但从某种意义上来说，信息是相当分散的，而不是。这篇文章简要总结了在开始之前我想知道的关于数据的 10 件事:

1. 背景:我们是如何走到这一步的？
2. 这完全是尺寸问题
3. 在维度上有意义- >训练算法
4. 聪明的数据胜过复杂的算法
5. 不是有机器学习的问题等着你
6. 端到端构建、快速迭代和沟通
7. 开源，这不是宗教
8. 每天学习，应对冒名顶替综合症
9. 要谦虚
10. 未来、职业和话题

这个演讲是启动第三版 AI 星期六马德里分会的基调。 AISaturdays 是一个惊人的倡议，旨在通过聚集在一起并通过编码学习来实现人工智能的民主化，目的是创建项目。

请继续收听第四版！https://www.saturdays.ai/city-madrid.html。作者照片

开始吧！

1.-语境:我们是怎么走到这一步的？

在某种程度上，似乎突然之间大多数公司都对【大数据】产生了浓厚的兴趣。从所有这些噪音中，出现了一句话:“大数据就像青少年的性行为:每个人都在谈论它，没有人真正知道如何去做，每个人都认为其他人都在做，所以每个人都声称自己在做”**

三件事情的发展创造了这个【大数据】机会:

1. 数据:社会的数字化以及收集和存储所有这些知识的能力。把数据当成*原材料*
2. 计算:计算能力遵循摩尔定律发展，摩尔定律描述了计算机的能力每两年翻一番。这使得能够处理所有这些知识。把它想象成*工具*
3. 算法:我们今天使用的算法自 80 年代(甚至更早)就已经存在，但现在它们可以被编程为所有这些知识的行动号召。把它想象成食谱**

2.-这都是尺寸的问题

把数据想象成维度，就像图形中的点。维度可以像 Excel 列一样简单。在下面的示例中，您可以看到由一组变量(维度)表示的三个人。这些变量可以用图表来表示:

在这种情况下，我们有 3 个维度，距离 _ 织机、每周 _ 小时数和流失 _ 人工智能。这里的目标是用一种算法来区分不同的用户。

一旦你用维度来表示信息，你就会更好地理解算法是做什么的。

3.-在维度上有意义->训练算法

一旦你把数据看作是维度的集合，就把算法看作是一种工具，它试图在这些维度上找到意义。在下面的示例中，目标是用可用数据(列/维度)区分蓝色和红色用户。不同的算法会以不同的方式提取它们的逻辑:

• 逻辑推理:以线性方式
• 支持向量机(SVM)非线性方式
• 随机森林(RF): 以“树”的方式划分各个维度

算法想要优化以区分这些点的函数(在我们的例子中是用户之间的分离)就是我们所说的目标函数。指导算法的函数，并告诉我们它是对还是错:

最终目标是使实际值和预测值尽可能接近、而不过度拟合。该算法使用可用的维度(变量)并使用其自身的逻辑来实现这一目标。

4.-复杂算法之上的智能数据

机器学习对复杂性有偏见。一旦你在这个领域工作，有时你可能会试图以某种深奥的方式混合不同的模型，这只会增加越来越多的复杂性。通常情况下，越简单越好。为了提高算法的性能，有两种明确的方法:

1. 特征工程:从当前信息创建新变量。
2. 聪明的数据:添加与你的问题相关的新数据。

几乎总是，聪明的数据会赢。当你面临一个 ML 问题时，想想哪些变量会帮助你改进你的模型。

5.-没有机器学习问题等着你

句号。大多数时候，当你到达一家公司时，你可能会认为他们会有一个机器学习问题，就像你在课程中看到的那样，为你准备好了。现实离得再远不过了。有三种情况:

1. 在“大数据”流程中工作的公司，你可能是他们的第一个数据人。这对于第一份工作来说是一个痛苦的处境。如果你听到“是的，我们有很多数据。csv 文件"**
2. 公司拥有良好的技术堆栈，你可以访问数据库并找到一个 ML 问题。你必须判断何时何地应用 ML
3. 你可以有第三种类型，在这种类型中，你受到优秀数据团队的欢迎，但是，这种情况很难找到

在寻找机器学习问题时，你应该记住两个事情:

1. 研究值得回答的问题
2. 通过人工工作利用您的解决方案

6.-端到端构建、快速迭代和沟通

产生影响的关键是尽可能快地对算法流程进行端到端迭代。你的变量对你的问题可能是误导性的/不现实的(泄漏)，其中一些在生产中可能无法计算。问自己一个问题:我的预测有意义吗？

当你迭代直到过程结束时，你会意识到这些事情。

找工作？做事，分享东西。拥有一个 Github repo，参与黑客马拉松，融入你的社区……不要听起来像个 Furby。

7.——开源，这不是宗教

从授权软件到开放知识。谢谢开源。如今，知识对每个人都是开放的，公司不能拥有“专属知识”。从一开始就不是这样。这么多年来一直有个讨论，哪个更好:**

老企业软件？开源 R 还是 Python？这一点目前已经转移到参考框架。以“开源的方式”思考，拥抱知识，准备好学习新的东西。像这样新的、毫无结果的讨论肯定会出现，不要浪费你的时间。

8.-每天学习并应对冒名顶替综合症

这是一场马拉松，而不是短跑。在左图中，您看到了过去被称为数据科学家的独角兽(🦄).在右边，一个来自 David Silver 的 RL 课程的更真实的图表(链接)。

依我拙见，跟上时代并成为“人工智能专家”几乎是不可能的。你可以成为某个领域的专家，但不是所有领域的专家。这可能会产生某种冒名顶替综合症。不要担心，我采访过的几乎每个数据科学家都会遇到这种情况。在这个行业中，你必须每天学习。

9.-保持谦逊

这是特雷弗·哈斯蒂。斯坦福大学教授，世界上最著名的统计学家之一。图片背后的故事是，我敲他的门要书签名(是的，书呆子)，我们进行了一次很棒的关于统计学、深度学习和 r 的对话。

作者照片。

他，最好的人之一，他对我非常谦虚和友好。旅途中非常重要的一件事。

完整的故事在这里👇

10.-未来、职业和主题

数据科学职业的繁荣可能类似于突然诞生的“医生”职业。数据科学家是一个越来越专业化的通用术语。两个剖面是顶级的:

1. 机器学习工程师:云+算法
2. 应用数据科学家:发现 ML 商机

我认为最有趣的话题之一是因果推断。我们正在创造惊人的东西，这些东西可以预测、构建洞察力并帮助我们，但它们是如何做出决策的呢？我们能从分析中得出因果关系吗？突破关联，才能明白事情为什么会发生。

祝您的数据之旅愉快！

完整演示

请随时联系我:bort@xplore.ai

让您的数据科学代码更干净、更高效的 10 个技巧

原文：https://towardsdatascience.com/10-tips-to-make-your-data-science-code-cleaner-798ba398fcbe?source=collection_archive---------34-----------------------

现实世界中的数据科学

大多数 Moocs 和大学课程都不会教你如何用 Python 进行专业编码，这篇文章会给你一些提示。

[注意:本文会根据您的反馈定期更新。欢迎在评论中添加您的评论。]

首先，我想指出的是，这个列表并不详尽，但它是我的许多经验和阅读的结果:

• 我从事数据科学项目、进行代码审查和开发机器学习管道的经验，其中涉及许多数据科学家(数据科学家 Modeo.ai 的联合创始人、Pronoo.ai 的 CTO、自由数据科学家和 GarageISEP 的 AiLab 负责人)。
• 我在亚马逊网络服务组织的自动驾驶汽车锦标赛 AWS DeepRacer 上的工作，在那里我赢得了法国版并参加了 2019 年 12 月在拉斯维加斯举行的世界决赛(见:https://medium . com/@ matthieurousseau _ 16015/what-is-the-AWS-deep racer-league-and-how-do-we-win-the-French-edition-facae 656680 c)
• 我读过的关于这个主题的书(我强烈推荐):

1. 罗伯特·马丁。干净的代码:敏捷软件技术手册。皮尔森，2009 年。
2. 奥雷连·盖伦。使用 Scikit-Learn 和 TensorFlow 进行动手机器学习:构建智能系统的概念、工具和技术。奥莱利，2017。
3. 韦斯·麦金尼。用于数据分析的 Python。奥莱利，2017。
4. 罗伯特·马丁。干净的架构:软件结构和设计的工匠指南。培生，2017。

罗伯特·马丁。干净的代码:敏捷软件技术手册。皮尔森，2009 年，https://www.amazon.fr/。

尽管我在法国大学学习数据科学多年，但我的大部分知识都是通过 Coursera 和 Udemy 上的在线课程获得的(我想我是现代数据科学家的陈词滥调，但感谢吴恩达)。然而，我不得不说，在在线课程中教授代码的方式和如何开发代码以用于现实世界的应用程序之间存在巨大的差距。

我不会假装说我的编码方式是最好的，我也不认为正确编码是一门精确的科学，但是通过遵循这 10 个技巧，你可以大大提高代码的可读性。

1。每个功能一个抽象层次

为了使代码更具可读性，每个函数必须专用于一个任务。最好有很多函数，而不是太长的函数，做几件事，因此令人困惑。为了确保一个函数只做一件事，将函数限制在一个抽象层次上是很重要的。

什么是抽象层次？该函数的目的是从数据库中检索数据，然后对数据进行预处理。

在下图中，你可以看到三个层次的抽象。这其实是代码层面的问题。我们是否将“高级”函数视为 process_data_from_db，我们是否像重命名列一样直接操作 Pandas 数据框架？

下面是我们可以做些什么来使这段代码更具可读性:

2。使用类型提示提高可读性

因为我们的目标是操作数据，所以我们的函数通常采用不同的数据类型作为参数(列表、元组、字典、Pandas DataFrame、Numpy 数组等)。因此，必须指定每个参数的类型以及返回对象的类型。

为此，建议使用提示来指定每个参数和每个返回对象的类型。这使得代码更容易阅读和维护。

https://www.bernat.tech/the-state-of-type-hints-in-python/见

3.论据

应该尽可能地限制争论。令人惊讶，对吧？让我告诉你为什么。

函数有几种类型，一元(0 个自变量)、一元(1 个自变量)、二元(2 个自变量)、三元(3 个自变量)和多元(3 个以上自变量)。一元是可以接受的，二元应该避免，超过 3 个参数就太多了。

主要原因是它们需要大量的概念性工作，因此很难理解，尤其是在具有复杂工作流的管道中。第二个原因与单元测试有关。当您对函数执行单元测试时，您必须测试每个参数之间所有可能的组合，这使得这一阶段的测试更加复杂。

4。分块和缩进

功能必须很小。没有人想在 2000 行的函数中寻找错误。为了使函数可读，每个语句尽量少用几行(if，else，while…)。

理想情况下，每条语句尽量只占一行。为了尽可能清楚起见，这一行可以用来调用具有显式名称的函数。当你别无选择的时候，尽量限制自己最多两级缩进，以免影响代码的可读性。

此外，Python 允许在一行中进行循环，这有助于提高清晰度。

5。错误处理

错误管理不是开发数据科学管道中最令人兴奋的部分，但却是必不可少的。它将帮助您监督管道的执行，并在出错时做出正确的决策。

首先，一个好的反应是用 try 开始你的顶层脚本，除了，最后，因为它们定义了你的程序的执行范围。如果执行失败，它将在 catch 中恢复，因此您将能够根据错误的类型做出正确的决定。

另一个充分利用例外的方法是发展你自己的例外。

假设您正在通过 API 检索数据。最有可能的是，您无法控制 API 返回给您的内容，这会影响您的程序的正确执行。

见:https://jeffknupp . com/blog/2013/02/06/write-cleaner-python-use-exceptions/

6.使用记录器，不打印

打印有利于调试和测试，但是当涉及到将代码投入生产时，日志记录器更合适。

印刷品的格式更复杂，可读性更差，最重要的是包含的信息很少。另一方面，记录器包含更多的信息，被直接格式化，并且具有一定的信息级别，可以识别信息的重要性(信息、警告、错误等)。).

在下图中，您可以看到培训脚本的执行显示。关于登录 Python 的更多细节，请参见 https://docs.python.org/3/howto/logging.html。

7.文档字符串

Docstring 是 Python 中必不可少的元素。它必须出现在任何语句声明中(函数、类或方法定义)。它们使代码更加清晰，并作为对象的文档。

一个通用的约定提供了所有的可维护性、清晰性、一致性，也是良好编程习惯的基础。它没有做的是坚持让你违背自己的意愿去跟随它。那是 Python！”

—蒂姆·彼得斯论比较语言. python，2001 年 6 月 16 日

有两种类型的文档字符串，单行文档字符串和多行文档字符串。

单行 docstring 用于最明显的情况，它们适合单行。描述简明扼要，并提供了函数名称所提供的附加信息。正如 Python 文档中所述:

• 即使字符串在一行中，也要使用三重引号。这使得以后扩展它变得容易。
• 结束引号和开始引号在同一行。这看起来更适合一行程序。
• docstring 前后都没有空行。
• 文档字符串是以句点结尾的短语。它将函数或方法的效果规定为命令(“Do this”、“Return that”)，而不是描述；例如，不要写“返回路径名…”。
• 单行 docstring 不应该是重复函数/方法参数的“签名”(可以通过内省获得)。

多行文档字符串用于更复杂的情况。描述更加详细，后面还有一个空行。重要的是，它应该在一行中，并通过一个空行与 docstring 的其余部分分隔开。摘要行可以与起始引号在同一行，也可以在下一行。整个文档字符串的缩进与其第一行的引号相同(参见下面的示例)。

参见:【https://www.python.org/dev/peps/pep-0257/#abstract】T2

8.单元测试

Python 测试是一个非常广泛的话题，并且可能非常复杂，但是它们对于使您的 python 代码更干净和更健壮是必不可少的。

“在计算机程序设计中， 单元测试 是一种软件测试方法，通过这种方法对单个源代码单元、一组或多组计算机程序模块以及相关的控制数据、使用程序和操作程序进行测试，以确定它们是否适合使用”。科拉瓦、亚当、胡伊津加、多洛塔(2007 年)。 自动化缺陷预防:软件管理中的最佳实践 。威利-IEEE 计算机学会出版社。第 75 页。

有效测试的一个好技巧是使用 TDD 三定律和 F.I.RS.T 原则(适用于 Python 和其他编程语言)。

TDD 三定律:

1. 在你写完一个失败的单元测试之前，你不能写任何产品代码。
2. 你不能写超过足以失败的单元测试，不编译就是失败。
3. 您不能编写比足以通过当前失败的单元测试更多的产品代码。

F.I.R.S.T

1. 快速:测试应该快速运行，因为你必须经常测试它们。否则，你就不能充分发挥它们的潜力，因为它们会浪费你的时间。
2. 独立:测试不应该相互依赖，它们不应该为下一次测试设置条件。您应该能够按照您想要的顺序运行它们。
3. 可重复:测试必须能够在任何环境下运行，无论是生产阶段还是原型开发阶段，无论是在任何机器上。因此，使用的环境不会影响测试的成功。
4. 自我验证:测试的输出应该是布尔值。要么考上了，要么没考上但是没有中介。否则，通过测试就变得主观了。
5. 及时:单元测试必须在正确的时间开发，即在测试阶段，而不是在产品中。

参见:【https://docs.python.org/3/library/unittest.html

9.评论

如果使用得当，Python 注释非常有用，但是如果使用不当，它可能会成为混乱和信息过剩的主要来源。当我们开发的代码不够清晰时，我们使用它们，这是正常的，因为并不总是能够清楚地解释我们的代码做什么。

有几种类型的好的评论:

1. 法律意见:版权、许可等…
2. 信息性注释:当您需要指定正在解析的日期的格式时。
3. 意图解释:缩进往往反映了一种复杂的逻辑，它可以用来简要解释他们在做什么。
4. 澄清:你的代码很难理解。阐明返回的参数或变量的用法有时很有用。
5. 后果警告:执行某些代码块可能会产生重要后果。注释可以用来提醒另一个代码用户。
6. 放大:它们可以用来放大可能被忽视的代码的重要性。

但也有几种类型的恶评:

1. 不明确:当你懒于写好，评论没有提供明确的信息。
2. 多余:当你重复 docstring 中或者之前注释中说过的话。
3. 噪音信息:不必事事评论，否则说明你的代码不清楚。
4. 注释掉的代码:删除旧的不用的代码比注释掉好。

10.重新格式化代码的工具

关于代码的格式，Python 的结构要求我们非常仔细，以便正确地格式化我们的代码。实际上，要跳过的行数根据代码中声明的内容而有所不同(我们是声明一个类、一个方法还是一个变量？).

列表不要太长，否则，你必须回到那一行，行的长度、空间规则等等也是如此……总之，有很多规则要遵循，用手一丝不苟地遵循它们太长了(见https://www.python.org/dev/peps/pep-0008/)。

幸运的是，一些库会自动格式化你的代码，节省的时间是相当可观的。最著名的库是 Black 和 Yapf，我强烈推荐它们。它们很容易集成到像 PyCharm 这样的 IDE 中，结果非常好。

此外，一个好的 IDE 可以指出主要的风格错误，并提出修改建议。就我而言，我使用 PyCharm，其纠错系统非常高效。

下面的代码向您展示了如何将格式糟糕的难看代码转换成格式良好的难看代码。

以前

在布莱克和皮查姆之后

参见:https://open source . com/article/18/7/7-python-libraries-more-maintable-code

结论

我希望您会对这篇文章感兴趣，并且它会为您提供一些改进 Python 代码的线索。

我还推荐你看看这个 GitHub 资源库，它包括了本文中提到的概念和其他代码示例:【https://github.com/davified/clean-code-ml。

如果您对本文中提到的技巧有任何意见，请随时对本文发表评论或通过电子邮件发送给我: matthieu@modeo.ai 。

向数据科学过渡的 10 项任务

原文：https://towardsdatascience.com/10-to-dos-to-transition-into-data-science-e84b7eb1f3fa?source=collection_archive---------51-----------------------

意见

构建个人数据科学组合的一些有用提示

Avel Chuklanov 在 Unsplash 上拍摄的照片

数据科学是统计学、编程和讲故事的交叉。从根本上说，数据科学角色从创造可操作的见解的能力中获得价值。数据科学家的职责不同于学术界的研究科学家。与传统研究相比，行业任务的进展速度更快，不那么模糊。本文将为那些希望从学术界跳到数据科学家岗位的人提供指导。

1:不断学习

适应新技术和信息的能力是成为一名娴熟的数据科学家的关键。不断学习新的技巧和技术将有助于你获得一个职位，并在这个职位上取得进步。在我自己的经历中，我遇到过许多要求 Go 的开放职位。虽然我的工作主要是用 Python 编写的，但我已经开始创建一个小型的围棋组合。对于那些寻求更结构化的数据科学学习的人，还存在训练营、开放式课件和远程程序。对于那些拥有研究生学位的人，我推荐像 Insight 这样的公司，除了培训之外，它还提供指导。这篇文章最大的收获是不断学习。

照片由蒂姆·莫斯霍尔德在 Unsplash 上拍摄

2:沟渠 R

对于那些有学术背景的人来说，你可能熟悉统计编程语言 R。根据对 S tackOverflow 工作板的特别搜索，R 只是 1.26%的可用职位的标签。我猜这个数字会继续下降。工业上通常不使用 r，原因有二。第一:R 是开源的，一些公司要求统计软件具有商业责任，这意味着使用 SAS 或 Matlab。第二:R 在规模上较慢，R 的功能在其他语言中被复制，比如 python 中的 pandas。如果你打算转行到工业界，现在就从避免 r 开始。

克里斯·迪诺托在 Unsplash 上拍摄的照片

3:开始写博客

真正学到东西的最好方法是教书。博客可以兼作文件夹和巩固你所学知识的地方。Medium 是开始写作和吸引他人的好地方。我喜欢将我的兼职项目发布到的数据科学网站上，我发现向他们的出版物投稿很简单。Medium 是一个很好的平台，可以通过代码、图像甚至动画来练习讲述数据故事。

[## 不断变化的美国住房市场人口统计数据

一个使用海绵和赛璐珞制作动画的人口金字塔

towardsdatascience.com](/changing-us-housing-markets-demographics-34d9b0c71cb4)

4:获得一个 GitHub 帐户

熟悉 Git 和 GitHub 是数据科学家的必备技能。Git 是版本控制的一个例子。版本控制创建程序的历史副本，允许团队灵活地进行更改、修复错误或恢复代码，以实现流畅的功能。GitHub 也被用作数据科学家的公共投资组合。GitHub 的另一个好处是能够通过 GitHub 页面免费托管域名。

[## 使用 GitHub 创建漂亮的静态网页

查找模板和为静态网页创建表单的位置

towardsdatascience.com](/building-a-beautiful-static-webpage-using-github-f0f92c6e1f02)

5:制作个人网站

网站是一个有趣又方便的项目，可以提升你的形象，也是一种资源，让其他人可以看到你的成就、博客或任何你想分享的东西。我的个人网站可以在 codyglickman.com找到。如果你打算做自由职业者，网站开发会很有用，一些咨询数据科学网站的好例子包括 Claudia Ten Hoope 和 Data Dolittle 。

由 Le Buzz 在 Unsplash 上拍摄

6:创建 StackOverflow 配置文件

StackOverflow 是一个学习和运用你的知识帮助他人的好地方。StackOverflow 也是一个地方，当我完全被某件事难倒时，我会去那里。这个社区很棒，也很有帮助。你也可以通过帮助回答别人的问题来回馈社会。

格伦·诺布尔在 Unsplash 上的照片

7:熟悉云计算

远程工作的兴起和不断增长的数据规模意味着您的个人笔记本电脑可能无法处理工业所需的任务。 AWS 、谷歌云和微软 Azure 是云计算领域的主导者，这三家公司都有低成本或免费的试用版，让你熟悉在网络上发布命令。

图片由 C Dustin 在 Unsplash 上拍摄

8:在社交媒体上与其他数据科学家联系

Twitter 和 LinkedIn 是联系其他数据科学家的好地方。与其他数据科学家的交流创造了新的发展机会。我通过推文找到了很多辅助项目的灵感，比如我的照片马赛克项目。

[## 使用 Python 创建照片镶嵌

一步一步的教程，让你自己的美丽的图像

towardsdatascience.com](/creating-photo-mosaics-using-python-49100e87efc)

9:练习打包您的代码并使其可重复

要成为一个优秀的数据故事讲述者，你的代码应该引导他人理解你的思维过程，并且易于使用。在我的博士项目中，我遇到了一些软件，它们是这个领域的标准，不是因为它性能最好，而是因为它非常容易使用。打包、整理或分发你的代码对于与队友或客户的适当合作是必须的。

照片由 Unsplash 上的 Victoire Joncheray 拍摄

10:用数据科学材料更新你的简历

更新你的简历，加入你的成就和新获得的技能。突出你为你的博客创建的项目，分享你的网站链接，或者包括你的 GitHub，以引导潜在雇主注意你的成就。

joo ferro在 Unsplash 上拍摄的照片

概括起来

不断学习|放弃 R |开始写博客|获得 GitHub 帐户|创建个人网站|创建 StackOverflow 个人资料|熟悉基于云的计算|在社交媒体上与其他数据科学家联系|练习打包您的代码并使其可复制|用数据科学材料更新您的简历

祝你过渡顺利。在评论中添加额外的技巧和提示，我会相应地更新这篇文章。我叫科迪·格利克曼，可以在 LinkedIn 上找到我。查看下面的一些其他文章和附带项目。

[## 医学图像中的数据增强

如何通过重塑和重采样数据来提高视觉模型的性能

towardsdatascience.com](/data-augmentation-in-medical-images-95c774e6eaae) [## Python 中的星图

使用 Diamonds 和 Matplotlib 创建星图的教程

towardsdatascience.com](/stars-charts-in-python-9c20d02fb6c0) [## 探索大学足球薪酬

按州和会议列出的每个学生的价格

medium.com](https://medium.com/swlh/exploring-college-football-salaries-dc472448684d)

10 项被低估的 Python 技能

原文：https://towardsdatascience.com/10-underrated-python-skills-dfdff5741fdf?source=collection_archive---------5-----------------------

特征分析、超参数调整、数据可视化等技巧。

来自 Pexels 的杰梅因·乌林瓦的照片

在 2012 年的一篇文章中，"21 世纪最性感的工作，"哈佛商业评论描绘了数据科学团队毫不费力地从数据中创造可操作信息的愿景。

虽然它不完全是 Baywatch ，但数据科学是一个充满活力的领域，具有巨大的潜力，可以从组织的顶级战略资产(由强大的数据基础架构提供的竞争优势)中产生有价值的见解。

为了帮助你的数据科学工作，这里有十个被低估的 Python 技能。我敢说，掌握这些能力会让你成为更性感的数据科学家。我们的团队平衡了美貌和智慧，同时挑战极限，救人于危难之中，并做出英雄行为。所以让我们开始吧。

#10 —设置虚拟环境

虚拟环境为您的 Python 项目设置了一个独立的工作空间。无论您是独自工作还是与合作者一起工作，拥有一个虚拟环境都是有帮助的，原因如下:

1. 避免包冲突
2. 为软件包的安装位置提供清晰的视线
3. 确保项目使用的包版本的一致性

虚拟环境的使用允许你(和你的队友)对不同的项目有不同的依赖。在虚拟环境中，您可以在不影响系统安装的情况下测试安装包。

“我有点喜欢这里。这是隐私。”—流言终结者的杰米·韩门。美国宇航局在 Unsplash 拍摄的照片。

部署 venv 模块对避免后续问题非常有帮助，所以在开始你的项目时不要跳过这一步。

阅读更多 :通过建立一个包含科学计算最常用软件包的虚拟环境，节省空间——并避免在不同的地方安装多个软件包的相同版本。然后在特定于项目的环境中以. pth 文件的形式共享该公共环境。

#9 —根据 PEP8 标准进行评论

写一些好的评论来增强自信和协作能力。在 Python 中，这意味着遵循 PEP8 风格指南。

注释应该是声明性的，比如:

# Fix issue with utf-8 parsing

不是 # fixes issue

这里有一个关于 docstring 的例子，这是一种特殊类型的注释，用于解释函数的用途:

def persuasion():
   """Attempt to get point across."""
   print('Following this advice about writing proper Python comments will make you popular at parties')

文档字符串特别有用，因为您的 IDE 会将该字符串文字识别为与类相关联的定义。在 Jupyter Notebook 中，您可以通过将光标放在函数的末尾并同时按 Shift 和 Tab 来查看函数的文档字符串。

#8 —寻找好的公用事业代码

你听说过“站在巨人的肩膀上”这句话 Python 是一种资源极其丰富的语言。你可以通过认识到你不必单干来加速你的数据科学发现——你可以而且应该重用在你之前的程序员的实用程序代码。

实用程序代码的一个很好的来源是 Chris Albon 的博客，他是装饰我家庭办公室/卧室墙壁的机器学习抽认卡的创造者。他的网站的登录页面提供了数百个代码片段的导航，以加速您在 Python 中的工作流程。

例如，克里斯向我们展示了如何应用一个函数(这样一个熊猫的滚动平均值——)。rolling())到数据帧，按组:

df.groupby('lifeguard_team')['lives_saved'].apply(**lambda** x:x.rolling(center=False,window=**2**).mean())

这段代码输出一个数据帧，其中包含每两行的滚动平均值，在。groupby()语句。

#7 —使用 pandas-profiling 实现自动化 EDA

使用 pandas-profiling toolkit 来自动化您的大部分探索性数据分析。EDA 是任何数据科学项目的关键阶段零。它通常涉及基本的统计分析，并查看特征如何相互关联。

熊猫——剖图前来救援。照片由 NeONBRAND 在 Unsplash 上拍摄

本文将带您了解一种标准的“手动”数据探索方法，并将其与 pandas-profiling 库创建的自动报告进行比较:

[## 一个更好的带有熊猫轮廓的 EDA

探索性数据分析已死，熊猫万岁——剖析！事半功倍，完美概述您的数据。

towardsdatascience.com](/a-better-eda-with-pandas-profiling-e842a00e1136)

#6 —利用 qcut 改进目标分析

在这个关于改善机器学习工作流程的优秀视频中， Rebecca Bilbro 提供了明智的建议，在进行特征分析之前检查一下你的目标列。

从心中的目标开始——这样你就能在投入预测或分类之前对目标变量有一个坚实的理解。采取这种方法有助于你提前发现潜在的棘手问题(例如阶级不平衡)。

如果你正在处理一个连续的变量，绑定你的值可能是有用的。使用 5 个箱子提供了利用帕累托原则的机会。要创建五分位数，只需使用 panda 的 q-cut 功能:

amount_quintiles = pd.qcut(df.amount, q**=**5)

每个容器将包含 20%的数据集。将目标变量的前五分之一与后五分之一进行比较，通常会产生有趣的结果。这种方法是一个很好的起点，可以用来确定在你的目标变量中，哪些表现最好(或最差)的人是异常的。

为了进一步了解，还可以看看丽贝卡在《DC 职业系列》中的表现，由你的真实采访:

# 5-向要素分析添加可视化

可视化不仅仅用于商业智能仪表板。当你研究一个新的数据集时，加入一些有用的图表和图形会降低洞察的速度。

Seaborn 示例图库

使用数据来提高你的分析能力有许多可能的方法。一些可供探索的资源:

• Seaborn 样板间
• 散景笔记本示例
• Plotly Python 开源图形库
• 黄砖画廊
• Streamlit for data exploration(感谢Ian Xiao的这个提示！)
• Tableau 入门指南

#4 —测量和优化运行时间

数据科学家有点像修补匠的名声。但是随着这个领域越来越接近软件工程，对简洁、高性能代码的需求也增加了。应该根据时间、空间和磁盘使用来评估程序的性能，这是可伸缩性能的关键。

Python 提供了一些分析工具来展示你的代码在哪里花费时间。为了支持函数运行时的监控，Python 提供了 timeit 函数。

**%%**timeitfor i in range(100000):
    i **=** i******3

在和熊猫一起工作的时候，提高你的代码的一些快速胜利:

1. 按照预期的方式使用 pandas:不要遍历数据帧行，而是使用 apply 方法
2. 利用 NumPy 数组实现更高效的编码

#3—简化时间序列分析

处理时间序列可能令人望而生畏。我的训练营教练在准备讲授这个话题的那天，带着一副闹鬼的表情出现在课堂上。

幸运的是， dtw-python 包提供了一种比较时间序列的直观方式。简而言之，动态时间弯曲计算不同长度的两个数组或时间序列之间的距离。

通过DTW 包对齐两个时间序列

首先，DTW 拉伸和/或压缩一系列潜在的不同长度，使它们尽可能彼此相似。借用语音识别的一个例子，采用这种技术将有助于算法识别“now”和“nowwwwwwww”是同一个词，无论是由一个急躁的成年人还是一个暴躁的蹒跚学步的孩子说出。变换后，包计算单个对齐元素之间的距离。

了解更多信息:

• 在这里下载论文(最初在 R 中实现，但仍然与 Python 相关)
• 在此阅读用例
• 使用 Google Colab 此处 &此处玩玩 DTW Python 吧。

#2 —为实验跟踪设置 ML 流量

ML 流支持跟踪参数、代码版本、指标和输出文件。MlflowClient 函数创建和管理实验、管道运行和模型版本。使用mlflow.log_artifact、.log_metric()和.log_param()记录工件(例如数据集)、指标和超参数。

您可以使用mlflow ui命令在本地主机浏览器中轻松查看所有实验的元数据和结果。

此外，请查看这份完整的数据科学工作流程指南:

[## 型号选择综合指南

选择正确算法的系统方法。

medium.com](https://medium.com/atlas-research/model-selection-d190fb8bbdda)

#1 —理解 main 函数

使用if __name__ == '__main__'提供了编写代码的灵活性，这些代码可以从命令行执行或者作为一个包导入到交互式环境中。这个条件语句控制程序在给定的上下文中如何执行。

您应该预料到，将您的代码作为可执行文件运行的用户与将您的代码作为包导入的用户有着不同的目标。if __name__ == ‘__main__'语句提供了基于代码执行环境的控制流。

• __name__是模块全局命名空间中的一个特殊变量
• 它有一个由 Python 设置的repr()方法
• repr(__name__)的值取决于执行上下文
• 在命令行中，repr(__name__)的计算结果为“_ _ main _ _”——因此 if 块中的任何代码都将运行
• 作为包导入，repr(__name__)评估为导入的名称——因此 if 块中的代码将而不是运行

为什么这很有帮助？好吧，从命令行运行你的代码的人会有立即执行函数的意图。有人将您的软件包作为实用程序代码导入到 Jupyter 笔记本中，这可能不是真的。

在if __name__ == ‘__main__'中，您应该创建一个名为main()的函数，其中包含您想要运行的代码。在各种编程语言中，main 函数提供了执行的入口点。在 Python 中，我们只是按照惯例命名这个函数main()——与低级语言不同，Python 并没有赋予 main 函数任何特殊的意义。然而，通过使用标准术语，我们让其他程序员知道这个函数代表了完成脚本主要任务的代码的起点。

主函数应该调用模块中存储的其他函数，而不是在main()中包含完成任务的代码块。有效的模块化允许用户按照自己的意愿重用代码的某些方面。

模块化的程度取决于您——更多的功能意味着更大的灵活性和更容易的重用，但是可能会使您的包更难被人阅读和解释，因为他们要遍历功能之间的逻辑中断。

额外收获:知道何时不使用 Python

作为一名全职 Python 程序员，有时我怀疑自己是否过度依赖这个工具进行科学计算。Python 是一种令人愉快的语言。它简单明了，维护成本低，而且它的动态结构非常适合数据科学研究的探索性质。

尽管如此，Python 肯定不是处理广义的机器学习工作流程的每个方面的最佳工具。例如:

• SQL 对于将数据移入数据仓库的 ETL 过程是必不可少的，数据仓库中的数据可以被数据分析师和数据科学家查询
• Java 可能有助于构建管道组件，如数据摄取和清理工具(例如，使用 Apache PDFBox 解析 PDF 文档中的文本)
• 在数据科学领域，Julia 正以极快的速度取代 Python
• Scala 通常用于大数据和模型服务

在这个由 TWIML AI 播客主持的小组讨论中，专家们探索了他们选择的编程语言的数据科学应用。

听到一个 JavaScript 开发人员谈论使用这种典型的以 web 开发为中心的语言进行机器学习的潜力有点奇怪。但是，嘿，它是勇敢的和有创造性的——它有潜力通过打破机器学习和传统软件开发之间的障碍来使数据科学民主化。

目前，JavaScript 拥有数量优势:根据 2020 年栈溢出开发者调查，68%的开发者使用 JavaScript，相比之下，44%的开发者使用 Python。只有 1%的人使用朱莉娅，但预计这种情况会迅速改变。更多的 ML 开发者是否意味着更多的竞争，更多的见解，甚至更多的 arXiv 论文？更有理由提高您的 Python 技能。

摘要

在本文中，我们介绍了数据科学家可能忽略的 10 项 Python 技能。这些提示包括:

• 为您的项目创建虚拟环境(#10)
• 根据 Python 风格指南进行评论(#9)
• 寻找公用事业代码而不是重新发明轮子(#8)
• 提升你的 EDA 、目标分析、特征分析 (#7、6、5)
• 基于运行时优化编写更高性能的代码(#4)
• 使用动态时间弯曲进行时间序列分析(#3)
• ML 流(#2)的跟踪实验
• 结合主功能，增加软件包的灵活性(#1)

我希望这篇文章能够让您在推进数据科学实践的同时学到一些新东西。

如果你喜欢这篇文章，请在 Medium 、 LinkedIn 、 YouTube 和 Twitter 上关注我，了解更多提高你数据科学技能的想法。当“ 资源在 2020 年 最后几个月为您的数据科学增压”发布时，注册即可获得通知。

免责声明:本文中任何指向书籍的超链接都是附属链接。提前感谢你对我写作的支持。

你认为哪些蟒蛇技能被低估了？请在评论中告诉我。

提升 Python 技能的项目

[## 面向临床文本的命名实体识别

使用 pandas 将 2011 i2b2 数据集重新格式化为用于自然语言处理(NLP)的 CoNLL 格式。

medium.com](https://medium.com/atlas-research/ner-for-clinical-text-7c73caddd180) [## 12 小时 ML 挑战

如何使用 Streamlit 和 DevOps 工具构建和部署 ML 应用程序

towardsdatascience.com](/build-full-stack-ml-12-hours-50c310fedd51) [## 演练:在 Python 中映射 GIS 数据

通过 GeoPandas DataFrames 和 Google Colab 提高您对地理空间信息的理解

towardsdatascience.com](/walkthrough-mapping-gis-data-in-python-92c77cd2b87a) [## 开始使用 Spotify 的 API & Spotipy

《数据科学家快速入门指南》,指导如何浏览 Spotify 的 Web API 并使用 Spotipy Python 访问数据…

medium.com](https://medium.com/@maxtingle/getting-started-with-spotifys-api-spotipy-197c3dc6353b)

NBA 的 10 个独特形象

原文：https://towardsdatascience.com/10-unique-visualizations-of-the-nba-b981cfdb78bf?source=collection_archive---------20-----------------------

体育分析

一种数据科学的方法来处理丢失篮球

篮球，快回来。(照片由 TJ 德拉戈塔在 Unsplash 上拍摄)

我想念 NBA。

由于新冠肺炎疫情事件，NBA 暂停比赛，这只是当今世界的一个小插曲。但和很多其他体育爱好者一样，我怀念观看体育直播的那种刺激感。

所以我处理了它，就像任何热爱数据的篮球爱好者会做的一样:我进入了统计数据，并建立了一些图表。

我使用 Tableau (我最近才学会如何使用，但已经绝对喜欢上了)来构建这些情节，以及我在 Kaggle 上找到的一个数据集，其中包含了从 1996-97 赛季到 2019-20 赛季在 NBA 打球的所有球员的信息。

在我开始之前，没有创建一个单独的图表，我立即发现了我的第一个有趣的见解:

自 1996 年以来，NBA 只有 2235 名独特的球员。

对于 24 年的篮球生涯来说，这是一个非常低的数字。而这也是为什么我们不断听到专家说进入 NBA 就像“中彩票”一样。

在 NBA 之前

大学篮球是 NBA 典型的招募点，大多数球员在成功的大学篮球生涯后都会转为职业球员。像 NCAA 疯狂三月这样的比赛非常受欢迎，在这些比赛中表现出色的球员吸引了 NBA 招聘人员的目光。

1.就让球员进入 NBA 而言，最成功的大学是哪几所？

每所大学参加过 NBA 的球员人数

这些是美国前 20 名进入 NBA 打球的大学。

排名前三的大学是肯塔基大学、杜克大学和加州大学洛杉矶分校，它们是最成功的大学，有 168 名球员继续在 NBA 打球。

球员通常是在不同的选秀轮中从大学中挑选出来的。成为首轮选秀权，意味着你是精英中的精英。

2。但是选秀会影响球员每个赛季参加多少场比赛吗？

选秀轮 vs 每个赛季的平均比赛场次(颜色表示每个赛季的平均分数)

未必。

第一轮选秀权只打第三多的比赛，而第七轮和第三轮选秀权平均每个赛季打更多的比赛。

但就每个赛季的平均分数(图中的颜色)而言，第一轮选秀权贡献的分数最高。这可能是因为第一轮选秀权得到了更多的休息，以便在对球队至关重要的比赛中更有效地得分吗？

另一个有趣的见解，未被选秀帮助你比被第四、第六或第八轮选上打更多的比赛。令人惊讶。

最大的最大的

所以球员被选中了。他很有可能又高又壮。NBA 以拥有最高最强壮的球员而闻名，他们是真正的运动员。

事实上，自 1996 年以来，球员的平均身高和体重分别为 200.8 厘米(6 英尺 5 英寸)和 100.6 公斤(221.7 磅)。

3.他们中最大的玩家是谁？

NBA 最大的球员，身高(厘米)和体重(公斤)(颜色代表国家)

由于 NBA 的大多数球员都来自美国，所以一些大牌球员也来自美国也就不足为奇了。

但看起来有史以来最大的球员之一是来自加拿大的西姆·布拉尔，他身高 2.26 米(7 英尺 5 英寸)，体重 163 公斤(359 磅)。

沙奎尔·奥尼尔 ，被誉为 NBA 最好的“大个子”之一，身高 2.15 米(7 英尺 1 英寸)，体重 145 公斤(319 磅)。姚明 (图中未标注的橙色图标)也是最好的“大个子”之一，身高 2.29 米(7 英尺 6 英寸)，体重 141 公斤(310 磅)

最重要的团队统计数据？

团队可以用许多不同的方式来衡量，每种方式都会带来不同的见解。但可以说，其中最重要的是“净评级”。净评分是指球队每 100 分的得分差异。

4.哪支球队的净评分最好和最差？

自 1996 年以来所有团队的平均净评分(颜色表示团队的平均年龄)

事实证明，圣安东尼奥马刺队自 1996 年以来平均净得分最高，为+3.24 ，这意味着平均每 100 分，他们领先 3 分。只有另外两个队有积极的净收视率，迈阿密热火队和俄克拉荷马雷霆队。最差的球队是现已解散的温哥华灰熊队，负 8.39 分。

另一个令人惊讶的发现是圣安东尼奥马刺队也是所有赛季中平均年龄最大的球队。经验，以拥有一个更老的团队的形式，真的有用吗？这可能是另一个分析的基础。

最佳进攻球员

(免责声明:这些统计数据是从 1996 年开始的，所以这里只记录了迈克尔·乔丹职业生涯的一半，他不在这些的名单上，但是有了一个更大的数据集，你可以肯定他会在那里。)

有太多的指标可以用来衡量单个球员。对于一个进攻球员，负责创造尽可能多的篮筐的球员，使用和分析最多的指标是得分和助攻。

5.哪些球员得分和助攻最多？

总积分 vs 总助攻(颜色表示比赛总次数)

勒布朗·詹姆斯，在一个完全属于他自己的联盟中，一个完全的异类，以惊人的 34，027 分和 9，280 次助攻远远超过其他人。科比·布莱恩特*(瑞普·曼巴)是唯一一个能以 33633 分和 6319 次助攻接近 LBJ 的人。(我用谷歌搜索了迈克尔·乔丹的完整数据，他以 32292 分和 5633 次助攻排在第三位左右)*

名单上其他值得注意的球员有德克·诺维茨基，他得到 31，561 分和 3，667 次助攻；以及阿伦·艾弗森，他在这张图表上出场次数最少，在 914 场比赛中得到 24，380 分和 5，622 次助攻。(相比之下，勒布朗打了 1256 场，科比打了 1346 场，德克打了 1522 场)。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

用不同的方式使用得分和助攻可以带来更多的见解。使用球员的总投篮效率和球员在场上的助攻百分比，一组完全不同的球员出现了。

6.哪些球员的投篮效率和助攻率最高？

得分效率% vs 助攻贡献百分比(颜色表示每个赛季的平均比赛场次)

约翰·斯托克顿看起来几乎像一个异类，有着很高的投篮效率和很高的平均助攻率。但是图中某些球员的重复出现，比如斯蒂芬·库里、詹姆斯·哈登、勒布朗·詹姆斯和克里斯·保罗，展示了他们出众的投篮能力。同样更年轻的是，像本·西蒙斯和尼古拉·约基奇这样的现役球员无疑正在上升，并且很快会以稳定的表现主导这些统计数据。

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

游戏使用百分比是一个球员在场上使用团队游戏的百分比估计值。通常，当游戏使用百分比增加时，玩家的得分效率降低。真正的超级明星球员是那些能够保持这两个数字的人，他们变成了非常高效的射手。

7。谁是最有效的射手？

得分效率%与游戏使用率% (颜色表示每个赛季的平均游戏次数)

乔尔·恩比德的平均播放使用率最高，而博班·马扬诺维奇*的平均命中率最高。*

但是最有效的超级射手似乎是凯文·杜兰特、詹姆斯·哈登和勒布朗,詹姆斯，因为他们运用战术的能力全面，投篮效率高。

紧随其后的是安东尼·戴维斯、沙奎尔·奥尼尔和斯蒂芬·库里。

最佳防守队员

尽管通常被忽视，防守球员是那些做大部分繁重工作并积极为团队的成功做出贡献的人。如果没有一个伟大的防守球员，不管你有多少伟大的进攻球员，你最终都会陷入更糟糕的境地。

篮板是另一个衡量防守球员效率的重要指标。抢篮板球指的是球员在错过投篮或罚球后把球捡回来。

篮板有两种类型，进攻型和防守型。一个超级防守球员在理想状态下会有很多这两种类型的篮板。

8.就篮板而言，谁是防守最好的球员？

平均进攻篮板% vs 平均防守篮板% (颜色表示每个赛季的平均出场次数)

平均每个赛季至少打 10 场比赛，至少 2 个赛季，他们是篮板最多的 10 名防守球员。

最佳防守篮板手是克里斯·鲍彻，最佳进攻篮板手是吉登斯和特雷耶·布拉格斯。

但是一个后卫最重要的是他们的全面能力，在进攻和防守篮板方面最好的球员是丹尼斯·罗德曼和安德烈·德拉蒙德。

双重麻烦

另一个经常使用的指标是“双双”，当一个球员在以下指标中的两个指标上超过 10 分:得分、助攻、篮板、抢断和盖帽。

大多数双打双打通常由得分、助攻和篮板组成，我在这里称之为“最常见的双打”。

9.哪些球员有最多的赛季场均“最普通”的两双？

平均“最常见”双双的赛季数

德怀特·霍华德(14 个双双赛季)以微弱优势超过蒂姆·邓肯(13 个双双赛季)，成为“最常见”双双的最高赛季数。

安东尼·戴维斯，一个更年轻的现役球员，也在这个名单上，这表明经过几个伟大的赛季，他有很好的机会在这个名单上上升。

令人惊讶的是，克里斯·保罗也出现在这张图中，展示了他出色的投篮能力和全面的能力。

进化中的游戏？

有很多关于这项运动如何随着时间的推移而改变的讨论。许多人认为攻击性和强度已经随着时间的推移而下降，而另一些人认为游戏已经演变成一种更优雅和更具观赏性的形式。

可以说，到目前为止，一些最重要的指标是得分、助攻和篮板。

10.随着时间的推移，这些重要的指标(得分、助攻、篮板)实际上改变了多少？

1996-97 年至 2019-20 年的得分、篮板和助攻

赛季总助攻和赛季总篮板在很大程度上看起来不变*，有略微增加的趋势。*

每赛季总积分，另一方面大幅增加*。1996-97 赛季的总积分为 3540 分，而 2018-19 赛季的总积分为 4565 分。即使是不完整的 2019-20 赛季也已经有 4434 分，有望超过 2018-19 赛季，成为有史以来得分最高的赛季(无论赛季何时恢复)。得分的增加可以归功于三分球革命的兴起，现在的三分球得分比以往任何时候都多。这也可能是因为现在比以前有更多的高得分比赛。*

结论

我希望你能从这些图表中得到一些启示，因为我确实做到了。这只是表明最好的学习方法是实践的另一种方式。

我欢迎对这些可视化的任何类型的建议或修改，或新的想法。如果你认为合适的话，一定要在篮球对话和争论中使用它们。

我希望这有助于填补目前缺乏运动留下的空白。(早点回来，正常生活)

随时联系我LinkedIn，或者查看我的GitHub我做过的其他项目。

人工智能改善分销和供应链的 10 种方式

原文：https://towardsdatascience.com/10-ways-ai-improves-distribution-and-the-supply-chain-bbd2dc600965?source=collection_archive---------44-----------------------

在世界各地，人工智能正在让供应链变得更快、更可靠、更有利可图。

图片来源: Unsplash

在世界各地，人工智能正在让供应链变得更快、更可靠、更有利可图。

人工智能是当今企业最有前途的技术之一。麦肯锡对 2000 多名参与者的研究发现， 58%的受访者至少在一个流程中使用 AI 。这一令人印象深刻的采用率也不是毫无根据的，因为人工智能可以在几个方面改善供应链管理等领域。

物流是一个快速发展的重要行业，也是许多其他行业赖以运转的行业。因此，它将受益于全面而及时的数据分析。AI 让这一切成为可能。

一些人工智能技术已经在物流领域得到广泛应用，而一些则刚刚出现。以下是人工智能改善供应链的 10 种方式。

1.更快的数据分析

数据分析对现代供应链至关重要。物流公司需要分析大量信息，找出效率低下的地方和潜在的改进方法。这个过程不需要人工智能，但速度要快得多。

手动梳理信息以建立有见地的联系会花费很多时间。在像物流这样对时间敏感的行业，这可能是个问题。由于人工智能系统可以一次分析多个数据集，它们可以在很短的时间内给出供应链结果。

2.预估需水量

管理库存通常不像你想象的那么简单。如果一个仓库错误地估计了未来的需求，它可能会以产品过少或过多而告终。这两种情况都可能造成巨大的金钱损失，但 AI 提供了一个解决方案。

通过预测分析，人工智能系统可以利用过去的趋势和市场信号来预测需求。仓库经理可以使用它们来查看他们需要储存或多或少的物品。然后，他们可以避免盈余和赤字，保持一贯的准备行动。

亚马逊在其供应链的几乎每个层面都使用人工智能，尤其是在仓库。它对客户需求的人工智能预测是它如何在电子商务行业保持领先地位的一部分。这有助于它比大多数竞争对手(如果不是全部的话)更快地完成订单。

3.工序自动化

亚马逊几乎在供应链的每个层面都使用人工智能，尤其是在仓库。它对客户需求的人工智能预测是它如何在电子商务行业保持领先地位的一部分。这有助于它比大多数竞争对手(如果不是全部的话)更快地完成订单。

一般来说，人工智能系统往往比人类更擅长数据繁重、单调的工作。将这样的任务分配给 AI 不仅节省了时间，还节省了资金。当人工智能处理这些行政工作时，它将人类员工解放出来，同时从事其他项目。

像手动归档文件这样的任务会让企业每年花费 6500 个小时，这是一个巨大的时间损失。想象一下，一家公司如果增加 6000 多个小时的工作时间，可以完成多少事情。这种生产率优势对物流企业来说太有利了，不容忽视。

4.更可靠的发货更新

许多公司使用 RFID 标签等技术来跟踪供应链中的产品。然而，有时，物品运输时没有这些标签或事件会导致它们不可读。通过使用人工智能，企业仍然可以向客户提供货运更新。

当跟踪技术失败时，人工智能可以计算交付量，因此公司仍然可以提供估计。这些程序可以分析像平均运输时间和天气模式这样的事情，以提供准确的结果。然后，供应链可以了解他们的进展，并保持客户满意度。

5.自动化仓库管理

无数其他因素影响着供应链运行的效率，但管理不善的仓库从一开始就阻碍了成功。尽管情况紧急，只有 20-30%的仓库在尽可能有效地运转。使用人工智能来管理运营可以有所帮助。

自动化仓库管理系统(WMS)可以通过数据分析发现低效之处。由于人工智能通常更擅长在数据点之间建立有见地的联系，这可以消除管理中的人为错误。全面的小改变可以导致效率的大幅度提高。

6.优化路线规划

供应链需要充分利用运输来按时交付产品。通常，这意味着规划从 A 点到 b 点的最快、最安全的方式。在预测分析的另一个应用中，人工智能也非常适合这项工作。

人工智能系统可以观察交通模式和天气，以确定最佳行动方案。由于诸如此类的因素是动态的，最佳路线可能每天都在变化。因此，供应链需要像 AI 这样的工具，可以快速分析数据和规划路线。

自 2012 年以来，UPS 已经使用一个名为 ORION 的系统来优化其路线。从那以后，这个人工智能每年为该公司节省了 1 亿英里和 1000 万加仑的燃料。

7.监控产品质量

自 2012 年以来，UPS已经使用一个名为 ORION 的系统来优化其路线。从那以后，这个人工智能每年为该公司节省了 1 亿英里和 1000 万加仑的燃料。

供应链管理不仅仅是确保产品准时到达。物流公司还需要确保货物完好无损地到达，这对于一些物品来说是一个挑战。人工智能可以确定敏感产品的寿命和风险因素，帮助企业确保产品质量。

如果有任何不可预见的延误，人工智能系统可以确定他们是否需要重新调整路线以保护一些产品。如果一批货物包含食物或植物，他们可能需要改变路线，先运送这些。没有人工智能，公司可能不知道如何即时做出这些改变。

8.明智的供应商选择

对于一些供应链经理来说，选择合适的产品供应商可能是一场赌博。如果他们不能提供一致的质量，或者容易出现丑闻和道德问题，这可能会损害物流公司的公众形象。然而，在人工智能的帮助下，他们可以更好地了解每个企业的历史和潜在风险。

人工智能系统可以确定与一家公司做生意是否会有财务或公共关系风险。然后，供应链可以就供应商选择做出明智的决策。

9.改进的客户支持

人工智能最常见的应用之一是聊天机器人，最常见的是客户支持角色。在过去的一年里，大约有 40%的美国消费者使用过聊天机器人。它们使供应链能够提供全天候的客户支持。

通过人工智能处理客户参与，物流公司将员工解放出来，专注于其他任务。不仅客户支持得到改善，整体效率也得到提高。这些人工智能也让顾客更容易获得信息。

DHL 允许客户通过 Alexa 检查他们的订单状态，给他们快速、可靠的答复。除了作为一个快速、免提的信息网关，智能扬声器已经出现在许多家庭中。习惯使用这些技术的人将会很高兴能够通过它们了解他们的订单。

10.自主航运

这些人工智能也让顾客更容易获得信息。

DHL 允许客户通过 Alexa 检查他们的订单状态，给他们快速、可靠的答复。除了作为一个快速、免提的信息网关，智能扬声器已经出现在许多家庭中。习惯使用这些技术的人将会很高兴能够通过它们了解他们的订单。

随着人工智能技术的进步，它最终将实现完全自主的航运。人工智能是自动驾驶汽车的关键，无人驾驶交付将缩短运输时间。自动驾驶卡车不需要停下来休息，所以他们可以在更短的时间内行驶更长的路程。

这项技术还不可用，但研究人员正在接近成功。它将随着人工智能的进一步采用而改进，从而导致更快的开发和实现。

完全自主的航运可能现在还不是现实，但几家公司正在努力。2017 年，劳斯莱斯与谷歌合作开发自动驾驶货船。虽然这项技术还不可用，但随着人工智能的进一步采用，它将得到改善，从而加快开发和实施。

数据驱动的物流链

以数据为中心的供应链管理对于改善物流行业至关重要。人工智能与此密切相关，因为它允许公司充分利用数据的潜力。随着 AI 在这一领域的广泛采用，该行业将继续改善。

供应链是许多行业的支柱。当物流公司采用人工智能时，它会产生效益的连锁反应，并改善该部门的功能。

部署和服务人工智能模型进行预测的 10 种方法

原文：https://towardsdatascience.com/10-ways-to-deploy-and-serve-ai-models-to-make-predictions-336527ef00b2?source=collection_archive---------32-----------------------

探索 Flask、云巨头、小众玩家、AutoML 和其他部署 AI 的方式。

克里斯汀·休姆在 Unsplash 上拍摄的照片

创建模型只是通往现实世界人工智能之旅的一步。部署意味着将您的模型——无论是 Jupyter 笔记本还是某处的. py 文件——转化为可用的服务。

简化的 AI 管道。由作者创建。

我不会深入讨论容器，它们与部署和服务模型是分开的。像 Docker 和 Kubernetes(托管 Docker 容器)这样的容器系统就像是模型的盒子，可以创建可复制、可伸缩和隔离的环境，您可以在其中设置依赖关系，这样模型就可以在任何执行环境中工作。

以下是部署、托管和服务人工智能模型进行预测的 10 种方式。

1.Flask 的内置服务器

首先，Flask 的内置服务器不是生产级的，因为它不能扩展。尽管如此，由于它的易用性，它是一个方便的工具，用于快速实验和快速建立并运行您的模型。

要在 Flask 上部署，请遵循以下一般步骤:

• 安装烧瓶
• 序列化你的 AI 模型(例如用 Pickle 或 joblib
• 创建另一个。py 文件与上面的序列化模型在同一个目录中，它将用于在 Flask 中创建 web 服务
• 运行。来自终端的 py 文件
• 检查您的本地主机地址，看看它是否工作
• 使用输入数据进行 http POST 调用以接收预测

这篇关于数据科学的文章展示了一个使用 Flask API 部署 Sklearn 模型的示例。

2.云中的烧瓶

在云中运行 Flask 将让您获得更大的可伸缩性，尽管这比使用内置服务器更复杂。

这里有一些你可以使用的云服务器:

• 在 Heroku 部署烧瓶
• 在谷歌应用引擎上部署 Flask
• 在 AWS 弹性豆茎上展开烧瓶
• 在 Azure (IIS)上部署
• 在 PythonAnywhere 上部署

这篇 FreeCodeCamp 文章非常详细地介绍了如何在云中部署带有 Flask 的模型。

3.AutoML 解决方案

AutoML 越来越受欢迎。尽管与 AI 部署不是同一个概念，但是大多数 AutoML 解决方案都允许在其核心 AutoML 功能之上进行简单的模型部署。

AI 部署解决方案和 AutoML 解决方案的重叠。由作者创建。

以下是一些 AutoML 解决方案，可以实现简单(甚至是一次点击)的模型部署:

• Cloud AutoML (这允许您使用提供的 REST API 生成预测)
• Azure AutoML (这将生成一个.pkl文件，其中包含您可以在 Azure 中部署的模型)
• Apteo (这是一个无代码的解决方案，允许您在浏览器中或通过 API 生成预测)

这些解决方案提供的不仅仅是人工智能部署，还可以大幅提高数据科学团队的效率。

[## AutoML 会是数据科学家的末日吗？

AutoML 越来越受欢迎。这就是事情的变化。

towardsdatascience.com](/will-automl-be-the-end-of-data-scientists-9af3e63990e0)

4.Azure 机器学习

Azure ML 专注于提供企业级云服务，尽管使用微软的服务器显然会让你付出代价。

通过 Azure ML 部署任何模型有 5 个主要步骤:

• 收集先决条件(Azure ML 工作区、Azure CLI、工作区中经过培训的 ML 模型)
• 通过创建推理配置来准备部署
• 使用 Model.package 创建一个 Docker 映像
• 将图像部署为 web 应用程序
• 通过向 URL 提交数据并显示响应来使用 web 应用程序

5.GCP

在 GCP 部署有三个主要步骤:

• 将您的模型上传到云存储桶。
• 创建一个 AI 平台预测模型资源。
• 创建一个 AI 平台预测版本资源，指定你保存模型的云存储路径。

像 Azure 一样，GCP 提供了企业级的可扩展性和安全性，尽管它需要广泛的技术专长才能运行。

6.AWS SageMaker

AWS SageMaker 为您的模型提供了一个 HTTPS 端点，利用它在三个步骤中提供推理:

• 在 SageMaker 中创建模型，包括相关的 S3 路径和 Docker 注册路径
• 为 HTTPS 端点创建端点配置
• 创建 HTTPS 端点

7.IBM Watson ML

虽然 AWS、GCP 和 Azure 是在云中部署人工智能的三大巨头，但 IBM 的 Watson ML 提供了一个更适合的解决方案，允许您动态地重新训练模型并自动生成 API。

IBM 为其服务提供了一份很好的白皮书，它更广泛地扩展到 ML 服务器和管道。

8.Oracle 数据科学平台

Oracle 的数据科学平台允许团队构建、管理和部署具有可再现性、高安全性和全面的模型构建环境的模型。

[## Oracle 云数据科学平台

AgroScout 和 Oracle——利用新一代技术战胜饥饿“这一愿景的成功依赖于管理……

www.oracle.com](https://www.oracle.com/dk/data-science/cloud-infrastructure-data-science.html)

9.阿里云

阿里云通过其弹性算法服务(EAS)提供了几种部署模型的方法，包括:

• 将模型上传到控制台
• 使用 PAI Studio 部署模型
• 使用 DSW 部署模型
• 使用 EASCMD 客户端部署模型

[## 如何在 EAS 中部署模型

人工智能机器学习平台(PAI)的弹性算法服务(EAS)与 PAI Studio 和

www.alibabacloud.com](https://www.alibabacloud.com/help/doc-detail/126312.htm)

10.提供；给予

Render 是这个列表中比较容易使用的工具之一，因为它直接从 GitHub 或 GitLab 部署你的模型。你需要做的就是像平常一样推送你的代码。

很快。AI 为在 Render 上部署模型提供了一个有用的指南，展示了它是多么简单。

[## 渲染时部署

这是一个快速指南，只需点击几下鼠标，就可以在 Render 上部署训练好的模型。它附带了一个启动回购…

course.fast.ai](https://course.fast.ai/deployment_render.html)

结论

部署和服务人工智能模型的解决方案越来越多。

如果您的需求很简单，您可能会坚持使用 Flask，而如果您需要企业级的可伸缩性(并且拥有企业级的专业知识和资源)，您可能会选择 AWS、Azure 或 GCP。

如果你有更多的小众需求，你可能会选择甲骨文，IBM，或者阿里巴巴。如果您想要一个没有太多麻烦的端到端解决方案，您可能会选择 AutoML 工具。

你怎么看——你会在这个列表中添加任何部署工具吗？

10 家使用 Python 的世界级公司

原文：https://towardsdatascience.com/10-world-class-companies-using-python-26cde24919a8?source=collection_archive---------23-----------------------

Python 正被 IT 界的一些巨头积极使用

照片由尤哈什·伊姆雷从派克斯拍摄

编写 Python 代码的乐趣应该在于看到短小、简洁、易读的类，这些类用少量清晰的代码表达大量的动作——而不是让读者厌烦得要死的大量琐碎代码。

——吉多·范·罗苏姆

在现代，每一个其他公司都使用数字工具来管理他们的运营，并保持一切顺利运行。企业总是努力在可用资源的范围内实现最大效率。提供软件即服务的公司一直在寻找最佳和最有效的技术来采用。

Python 一直在证明其作为全能编程语言的实力，并为企业面临的众多挑战提供解决方案，无论是与人工智能、统计中的数字处理、开发还是访问数据库有关。这使得 Python 成为业内一些顶级公司首选的编程语言。

根据 StackOverflow 的说法，Python 是发展最快的主流编程语言。

[## 2019 年堆栈溢出开发者调查

每个月，大约有 5000 万人访问 Stack Overflow 来学习、分享和建立他们的职业生涯。我们估计 21…

insights.stackoverflow.com](https://insights.stackoverflow.com/survey/2019)

Python 能做什么？

Python 是一种强大的编程语言，支持过程化、面向对象和函数式编程，并且是世界上最常用的五种编程语言之一。

由吉多·范·罗苏姆于 1991 年发布的 Python 已经成为发展最快的编程语言之一，并随着时间的推移超越了许多其他语言。Python 不仅仅是应用程序和网站开发，它还可以用于各种领域，例如:

●数据库

●图像处理

●数据分析

● 机器学习

● 人工智能

●科学计算

●网页抓取

●还有更多

Python 之所以如此具有竞争力，是因为它支持 REST APIs、详尽的库和框架集合、跨平台兼容性，并且对程序员非常友好，易于调试和使用，这使它成为企业的有利选择。

Python 兴趣随时间推移— 谷歌趋势

使用 Python 的顶级公司

●谷歌

由 Rajeshwar Bachu 在 Unsplash 上拍摄的照片

“Python 从一开始就是 Google 的重要组成部分，并且随着系统的成长和发展而保持不变。如今，数十名谷歌工程师使用 Python，我们正在寻找更多掌握这种语言的人。”

- 彼得·诺维格

谷歌是世界上最大的科技公司之一，因为他们参与了数十项在线服务，如搜索、安卓、 Youtube 、 Stadia 等等。对于这种规模的公司，其技术堆栈包括不止一种核心语言，即 Python 、 Java 和 Golang ，Python 在这些语言中获得了更多的支持和参与。

Google 在早期采用了 Python，并一直使用到今天，这是因为它简单的特性和相对快速的维护，允许在其许多领域快速部署。服务，如部分搜索引擎，YouTube，以及实施机器学习，人工智能以及机器人项目。

事实上，根据《 In the Plex》的作者史蒂文·利维(Steven Levy)，的说法，“谷歌的第一个网络爬行蜘蛛最初是用 Java 1.0 编写的，因为太难了，所以他们把它重写为 Python。

[## 谷歌大量使用 Python

谷歌大量使用 Python，这仅仅是一个品味问题还是给了他们竞争优势？

stackoverflow.com](https://stackoverflow.com/questions/2560310/heavy-usage-of-python-at-google/2561008#2561008)

●脸书

照片由思想目录在 Unsplash 上拍摄

作为有史以来第一个挑起竞争并升至榜首的社交媒体平台，脸书已经发生了重大变化，这背后的部分原因是在其技术栈中采用了 Python。脸书在几个领域使用了许多 Python 包，例如:

● TORconfig、FBOSS、FBAR、Cyborg、machinechecker，用于生产工程

●作业引擎、fbpkg、FBTFTP、渗透，用于平台服务

●配置器，用于服务配置管理

● MySQL 池扫描器，slowroll orchestrator，用于管理运营效率

脸书还积极参与 Python 的开发，定期为该平台提供错误修复和增强性能的附加功能。脸书的技术栈中使用的其他语言包括 PHP 和 C++。

● Instagram

照片由 Unsplas h 上的 NeONBRAND 拍摄

Instagram 是一个非常受欢迎的照片和视频共享平台，它使用 Python 来实现最大的运营效率，使用了著名的 Python 框架、 Django 。被认为是 Django 迄今为止最大的实现，其背后的动机是框架的简单性和可靠性。

Instagram 的开发人员在选择他们首选的基线编程语言时，似乎更喜欢 Python 而不是 PHP，因为 PHP 带来的性能提升不够令人信服。

该公司甚至在长达 10 个月的时间内将 从 Python 2 切换到 Python 3 ，这清楚地表明 Instagram 对 Python 印象深刻。

Instagram 的一名软件工程师这样描述他们对 Python 的生产使用

“我们最初选择使用 Python 是因为它简单实用的名声，这与我们‘先做简单的事情’的理念非常吻合。”

[## 使用 Python 提高 Instagram 的 Web 服务效率

Instagram 目前拥有世界上最大的 Django web 框架部署，它完全是用…

instagram-engineering.com](https://instagram-engineering.com/web-service-efficiency-at-instagram-with-python-4976d078e366)

● Spotify

夹具在 Unsplash 上拍照

Spotify 是数百万人的首选音乐流媒体应用,这是因为它的广泛可用性和适合所有情绪的惊人音乐收藏。Spotify 广泛使用 Python 的原因有很多，包括数据分析、使用 ZeroMQ 的服务间通信等等。

凭借丰富的数据，Spotify 使用 Hadoop 管理其收集的海量数据的推荐系统，并结合 Luigi 进行处理，这是一个用于批处理作业的 python 包。采用 Python 的另一个原因是快速的开发流程和服务之间的无缝操作。

[## 我们如何在 Spotify 使用 Python

本周末我们在 PyCon 上听到的最常见的问题是，我们如何在 Spotify 上使用 Python。希望这篇文章…

engineering.atspotify.com](https://engineering.atspotify.com/2013/03/20/how-we-use-python-at-spotify/)

● Quora

图片来源— Quora

Quora 是一个流行的问答平台，每天都有数百个问题被张贴出来，从一些最聪明的人那里获得回复。Quora 采用 Python 是因为它高效、快速的特性，以及易用性的额外好处。Quora 使用了Tornado 框架pypypy，以及更多的 python 库。Quora 通过编写全面的单元测试来规避 Python 的类型检查缺点。

诸如减少开发时间、增强可伸缩性、更好的代码可读性的开发人员友好性以及大量库的可用性等好处保证了他们将注意力从其他两个潜在候选语言(包括 C#、Java 和 Scala)转向 Python。

●网飞

自由股票在 Unsplash 上的照片

广受欢迎的视频流媒体巨头网飞特别喜欢 Python，并试图尽可能多地使用它。从早期开始，网飞就对他们如何使用 Python 和其他库 非常开放。几乎在每个子系统中都可以找到 Python 的实现，例如:

● 安全性:一套名为 Simian Army 的工具模拟故障，测试系统的可靠性，帮助计划系统故障的恢复措施。

● 警报:中央警报网关将所有警报传达给合适的团队。

● 数据分析:像 NumPy、SciPy 这样的库来执行数值数据分析。

** [## 网飞的 Python

现在有一只混乱的猴子在 AWS 中运行，破坏了网飞的服务器。但是不要惊慌！都是…

talkpython.fm](https://talkpython.fm/episodes/show/16/python-at-netflix) [## 数据科学如何助推网飞

当有效使用时，数据可以神奇的方式改变您的业务，并将它带到新的高度。

towardsdatascience.com](/how-data-science-is-boosting-netflix-785a1cba7e45)

● Dropbox

图片来源— 朝九晚五谷歌

Python 是在线文件共享和存储公司 Dropbox 背后的生命力，为其大部分服务和桌面客户端提供支持。Dropbox 对 Python 的印象非常深刻，他们设法从谷歌和 Dropbox 团队那里得到了 Python 的创造者吉多·范·罗苏姆的帮助来改进他们的平台。

虽然是专有的，但该公司也向开发者提供 Python SDK，希望将其集成到他们的 Python 应用程序中，让你知道他们在该平台上投入了多少。Dropbox 的开发人员也证实，大部分服务器端代码都是用 Python 编写的。

[## Dropbox 是如何扩展到 1.75 亿用户的？一位前工程师详述了早期的日子

女士们先生们，我们中断了关于疯狂的企业家和更疯狂的风投的正常节目，为你们带来一个…

techcrunch.com](https://techcrunch.com/2013/07/11/how-did-dropbox-scale-to-175m-users-a-former-engineer-details-the-early-days/) [## 抄本第 30 集 Dropbox 上的 Python 社区和 Python-[与我谈论 Python 播客]

00:00 是否意味着成为 Python 社区的领导者？这意味着你为开源项目做贡献吗？你…

talkpython.fm](https://talkpython.fm/episodes/transcript/30/python-community-and-python-at-dropbox)

● Reddit

Reddit 被认为是最大的微博网站之一，自称是互联网的第一页，如果你想收集关于任何事情的信息，它是你的地方，拥有数百万用户和数十亿主题。

Reddit 从 Python 及其广泛的库集合中获得了很多灵感，通过逐步实现每个被采用的库的高度定制的变体。在其核心，Reddit 使用以下库来保持其服务运行:

● 底板. py: 作为 Python 中的核心服务框架

●rolling pin:方便更快的部署到各种服务器

●pywebpush:Python 中的 webpush 数据加密

●aws-MFA:用于管理 AWS 多因素认证

● 监视器: 监视所有操作

●gevent:管理基于协程的并发

●django-裤衩: 整合 django 到裤衩的帮手

●以及更多的库

据其联合创始人:

它极具表现力、可读性和可写性。这让生活保持平稳。

●亚马逊

布莱恩·安杰洛在 Unsplash 上拍摄的照片

在线市场的顶级玩家之一 Amazon 在其平台的多个领域使用 Python。在产品和交易推荐系统中实现，其中，通过人工智能和机器学习，亚马逊分析客户的购买和习惯，并推荐产品。

随着亚马逊处理海量数据，需要管理这些数据的技术，这就是 Python 凭借其高可伸缩性和与 Hadoop 等其他技术无缝协作的能力发挥作用的地方。

亚马逊使用 Python 的另一个例子是用于各种用例的 Jupyter 笔记本，甚至涉及 AWS 资源中的机器学习和自动化。

●优步

查尔斯·德鲁维奥在 Unsplash 上拍摄的照片

优步是一家跨国公司，它可以让你预订去你喜欢的目的地的旅程，它在较低层次上使用 Python 和 Node.js、Java 和 Go。面向其用户的大多数服务仍然由 Python 提供，包括业务逻辑和所有发生的计算，包括中间层和顶层，如计算 ETA、乘车费用、计算地理位置以及需求和供应。

优步声称将 Tornado 与 Python 一起使用，但经常与 Go 交换，以在并发性方面实现更好的吞吐量。优步还开发了 Python、R 和 Shiny 使用的可视化框架，并使用 Jupyter 笔记本完成所有数据分析任务。

[## 优步工程技术栈，第一部分:基础

更新:本文讨论堆栈的下半部分。其余的，见第二部分:边缘和超越。优步的…

eng.uber.com](https://eng.uber.com/tech-stack-part-one-foundation/)

结论

Python 正被 IT 界的一些巨头积极使用，这使它成为完成各种事情的最佳编程语言之一，修补 Python 的能力使它更加诱人。更容易的学习曲线、大量的库、高可伸缩性和框架，包括 Python 的快速开发和对开发人员友好的特性，被证明是公司使用它的令人信服的理由。

如果您对 Python 在当今数字时代的受欢迎程度和作用感兴趣，我们强烈建议您参加一两门课程，深入 Python 的世界，因为它带来了大量的创新机会。

更多有趣的阅读—

我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢

[## 2020 年必读的机器学习书籍

看看吧，你为什么要读它们？

towardsdatascience.com](/machine-learning-books-you-must-read-in-2020-d6e0620b34d7) [## 面向所有人的顶级谷歌人工智能工具

使用谷歌人工智能中心将想法变为现实

towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## 数据科学家的最佳数据科学工具

数据科学工具，使任务可以实现

towardsdatascience.com](/best-data-science-tools-for-data-scientists-75be64144a88) [## 用于自然语言处理的 Python 库

用于自然语言处理的流行 python 库概述

towardsdatascience.com](/python-libraries-for-natural-language-processing-be0e5a35dd64) [## 选择 PyTorch 进行深度学习的理由

PyTorch 可以为深度学习程序员提供很多东西

towardsdatascience.com](/reasons-to-choose-pytorch-for-deep-learning-c087e031eaca)

关于作者

克莱尔丁。是Digitalogy—的内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在 Linkedin ， Twitter ， Instagram 上连接 Digitalogy 。**

使用 Cygym，强化学习环境速度提高 100%

原文：https://towardsdatascience.com/100-faster-reinforcement-learning-environments-with-cygym-20a3a970ebd1?source=collection_archive---------28-----------------------

使用 cygym 更快地替代健身房环境

我们可以用更快的环境来加速强化学习吗？图片来源

任何至少涉足强化学习的人都可能会告诉你他们已经使用了 OpenAI 的健身包(链接如下)，而且理由充分！这是一个易于使用、可扩展且支持良好的包，它减少了设置 RL 项目的大部分开销。

然而，当用最少的资源进行一个大规模的项目时，从多次运行的代码中挤出每一滴性能是很重要的。在从事一个 RL 项目时，我浏览了一下经典控制环境的源代码，这些环境通常用于对 RL 代理进行基准测试，看看我们是否可以获得一些廉价的速度增益。

我注意到所有的 gym 代码都是用纯 Python 编写的，所以我大脑中的生产代码部分立即想到:“将这些环境进行 cythonizing 以提高速度怎么样？”

Cython 快速介绍

Cython 是 Python 的一个超集，支持将解释的 Python 代码编译成速度极快的 C 扩展。这样做的好处是，我们实际上不必编写任何 C 代码，只需对我们的 Python 脚本做一些小的修改！根据不同的用例，有时您会发现 Python 代码的速度提高了 1000 倍以上。健身房环境的方法看起来是一个很好的选择，因为它在游戏的每一帧都被调用一次，这在训练 RL 代理时会出现数百万次。

cygym 简介

我最近发布了一个公共存储库，其中包含一个名为 cygym 的 Python 包，它包含了原始 gym 包中经典控制环境的 cythonized 版本。原始环境代码的所有功劳都归于这些脚本的作者，但我确实引入了一些小的优化，并利用一些 Cython 魔术来获得比原始实现高达 100%的速度提升。希望这个数字只会随着我们扩展代码库和获得更多贡献者而上升。

安装和导入

cygym 的安装和设置非常容易，只需克隆公共包存储库并使用 pip 安装即可！

git clone https://github.com/gursky1/cygym
cd cygym
pip install -e . 

Pip 应该处理软件包所需的所有设置，但是如果您对这种方式的安装有问题，您可以自己手动构建软件包，并使用setuptools以另一种方式安装:

python setup.py build_ext --inplace bdist_wheel
pip install dist/(wheel file here).whl

如果您仍然遇到问题，请随时打开问题或直接联系我！

快速启动

Cygym 几乎是 OpenAI gym 的一个完整插件，你所要做的就是导入环境类并开始！

开始使用 cygym

Cygym 也应该兼容任何和所有的 OpenAI 健身房包装器。我们现在正在做的一个功能是让 cythonized 类与 OpenAI gym 注册表兼容，但由于 Cython 的原因，这不是非常简单的。

一些初始速度比较

我们可以执行的第一个速度测试是比较两种最常见的健身房方法.reset()和.step()在健身房和 cygym 中运行经典控制问题所需的时间。

当我们初始化一个环境时，.reset()被调用，而.step()被调用来应用一个动作并获得下一帧。与环境交互的大部分运行时间是在.step()中度过的，所以我们将更加重视这种比较:

gym 和 cygym 在初始化环境时的绝对和相对速度比较

不幸的是，cythonizing 似乎只给使用.reset()的初始化环境带来了适度的速度提升，有时甚至会减慢它的速度！但是不用担心，这个方法每集只调用一次，所以这些结果对于我们的下一个比较来说是次要的:

gym 和 cygym 在迭代环境中的绝对和相对速度比较

哇！使用我们的 cythonized 变体，我们可以看到迭代环境的速度提高了六倍！请注意，我们的大部分环境交互时间都在这里，这意味着我们的整体模型训练时间应该较少依赖于环境！

用随机动作测试两种常见的方法都很好，但是 cygym 在实际训练代理方面做得如何呢？让我们来看看…

具有稳定基线的 RL 代理培训

Stable baselines 是原始 OpenAI baselines 包的优秀分支，它包含了许多 RL 算法的实现，如 Deep-Q、TRPO、SAC、PPO 等等。我不会深入研究这个包，但我们将利用 Stable-Baseslines 中可用的矢量化环境以及我们的 gym 和 cygym 环境来训练实际的 RL 代理，并查看为 100k 帧训练我们的模型需要多长时间:

使用 Cygym 培训稳定基线代理的示例

现在，我们将进行与前面部分类似的比较，查看我们所有的经典控制环境，看看使用 cygym 可以获得什么样的速度提升:

gym 和 cygym 训练 RL 代理的绝对和相对速度比较

又来了，哇！看起来 cygym 总是比 gym 快，火车时间减少了 50%!当尝试构建新模型架构的原型或进行超参数搜索时，这可能是一个巨大的差异。

未来版本

在未来，我们计划看看与 OpenAI gym 的进一步兼容性，例如在我们的 cythonized 环境中使用gym.make()，以及可能的快速渲染(目前还不支持)。

我们还计划研究一下 cythonizing 更复杂的任务，比如最初 gym 包的 box2d 和算法模块中的任务。

结论

我们已经证明，使用 cygym 进行简单的 cythonization 可以大幅减少 RL 代理培训时间，这意味着等待时间更少，分析结果的时间更多！我们正在积极寻找 cygym 的贡献者和维护者，所以如果你有 Cython 包开发和优化的经验，请联系我们！

资源

Cygym:快速 gym 兼容经典控制 RL 环境

[## gursky1/cygym

这个存储库包含 OpenAI Gym classic 控制环境的 cythonized 版本。注意是这个包…

github.com](https://github.com/gursky1/cygym)

OpenAI Gym:强化学习环境的多功能包

[## 开放/健身房

状态:维护(期待 bug 修复和小更新)OpenAI Gym 是一个开发和比较…

github.com](https://github.com/openai/gym)

cy thon:Python 语言的编译超集

[## cy thon:Python 的 C 扩展

Cython 是一个针对编程语言和扩展 Cython 编程语言的优化静态编译器…

cython.org](https://cython.org/)

稳定基线:OpenAI 基线的一个分支

[## 丘陵/稳定基线

稳定基线是一组基于 OpenAI 基线的强化学习算法的改进实现…

github.com](https://github.com/hill-a/stable-baselines)

面向数据专业人员的 100 篇开源大数据和 ML 架构论文(续)

原文：https://towardsdatascience.com/100-open-source-big-data-and-ml-architecture-papers-for-data-professionals-sequel-53fe690440a8?source=collection_archive---------38-----------------------

作者图片

介绍

在过去十年中，大数据技术极具颠覆性，开源在塑造其发展过程中发挥了主导作用。它已经导致了一个复杂的生态系统，新的框架、库和工具几乎每天都在发布，在技术人员努力理解系统的复杂性时造成了混乱。2015 年，我试图通过揭开这个空间的神秘面纱来解决这个问题。过去 5 年发生了很多变化，Spark 和 Flink 等新生态系统颠覆了第一代系统，人工智能和 ML 的进步以及云提供商产品的成熟。觉得这是拍续集的好时机。

这一次，我试图用一个由 3 部分组成的系列来解开这个复杂性。第一部分(当前文章)从开源生态系统的角度概述了该架构。第二篇将从云提供商的角度介绍架构的实现，而第三篇将从一些正在大规模处理数据的领先技术公司的角度介绍架构的实现。

如果你是一个大数据爱好者或技术专家(或挠头)，花一些时间深入理解关键系统的架构以了解其演变是很重要的。理解架构组件和微妙之处也将帮助您为您的用例选择和应用合适的技术。在我过去十年的旅程中，一些文献帮助我成为一名受过更好教育的数据专家。我在这里的目标不仅是分享文献，也是利用这个机会让开放源码系统的迷宫变得更加清晰。

需要注意的是，大部分参考文献都非常倾向于提供一个深入的架构概述(在大多数情况下，它指的是原始的研究论文)。

架构层

1.数据基础服务

作者图片

a)协调——这些系统用于跨分布式数据系统的协调和状态管理，都是从 Paxos 中获得灵感的。

• Zookeeper——灵感来自于 Chubby 虽然是一个一般的协调服务，而不仅仅是一个锁定服务。
• Raft 一种在多个现代数据库中使用的共识算法，例如 CockroachDB MongoDB 和 InfluxDB。

b)资源管理器 —虽然第一代 Hadoop 生态系统始于 YARN 之类的单片调度器，但进化发生在分层调度器(Mesos)上，这些调度器可以跨不同类型的计算范式管理不同的工作负载，以实现更高的利用率和效率。

• YARN —是一个资源管理和作业调度框架。
• Mesos —在多个不同的集群计算框架之间进行调度。
• Peloton是由优步构建的统一资源调度器，运行在 Mesos 之上，支持不同的工作负载——I)具有长期运行服务的无状态作业 ii)有状态作业长期运行的服务，如来自 Cassandra、MySQL 和 Redis 的服务，它们具有状态，iii)批处理作业或 iv)守护程序作业。

这些与 Hadoop 调度程序松散耦合，Hadoop 调度程序的主要功能是基于调度策略/配置来调度作业。比较流行的有容量调度和公平份额调度(此处背景)。

c)引擎— 是执行运行时，为运行不同种类的计算提供环境。两种最常见的引擎是

● Spark —在蓬勃发展的生态系统中广受欢迎和广泛采用。

● 弗林克——很像火花；优于火花的优势在于恰好一次流处理。

d)消息传递 — Kafka 是最广泛使用的数据处理消息传递系统。

e)安全

● Hadoop 安全设计——抓住 Hadoop 设计关键方面的开创性论文。可以在这里找到这些项目的概述。

● 阿帕奇密特隆 -是一个网络安全应用框架，为安全监控和异常检测提供一个集中的工具，具有日志聚合、完整数据包捕获索引、存储、高级行为分析和数据丰富的功能，同时将最新的威胁情报信息应用于安全遥测。

●Apache Knox——是 Hadoop 的 Web/REST API 网关解决方案。它通过 REST 提供了访问所有 Hadoop 资源的单一访问点。它充当虚拟防火墙，对入站请求强制执行身份验证和使用策略，并阻止所有其他内容。

● Apache Ranger —是一个用于 Hadoop 集群的策略管理工具。它包括一组广泛的管理功能，包括审计、密钥管理和跨 HDFS、Hive、YARN、Solr、Kafka 和其他模块的细粒度数据访问策略。

● Apache Sentry -对存储在 Apache Hadoop 中的数据进行细粒度授权。在 Hadoop 中跨多个数据访问路径实施一组通用策略。Apache Sentry 与 Apache Ranger 重叠，因为它也处理授权和许可。

f)可操作性 —操作框架提供了管理工作负载的指标、基准和性能优化功能。

• OpenTSDB —一个建立在 HBase 之上的时间序列度量系统。
• Ambari —是一个用于收集、聚合和提供 Hadoop 和系统指标的系统。
• Helix—LinkedIn 开发的一个通用集群管理系统。
• 螳螂 —螳螂平台建于网飞，提供可观察性以帮助快速识别问题，触发警报，并应用弹性以最小化或完全避免停机时间。

2.数据存储服务

作者图片

a)文件系统— 分布式文件系统提供存储、容错、可伸缩性、可靠性和可用性。

• Google 文件系统——分布式文件系统的开创性工作，塑造了 Hadoop 文件系统。
• Hadoop 文件系统-HDFS 发展的历史背景/架构。
• Ceph 文件系统—HDFS 的替代方案，融合了块、文件和对象存储。
• Alluxio 公司。超光速粒子-一种内存存储系统，用于处理现代低延迟数据处理。

b)文件格式— 文件系统也经历了文件格式和压缩技术的发展。面向列与行存储很好地概述了数据布局、压缩和物化。一篇比较和对比它们的好的综述论文可以在这里找到。一篇详细的论文在这里是。一个相关的主题是压缩技术及其在 Hadoop 生态系统上的比较。

• Avro——围绕protocol buffers——谷歌推广的语言中立序列化格式——为 Hadoop 生态系统建模。它是基于行的格式。
• 在 Google 的 Dremel 的论文中首次提到了面向列的拼花格式。
• orc file—Hive 使用的一种改进的面向列的格式。
• 箭头 —一种内存中独立于语言的列格式，用于平面和分层数据，还支持零拷贝读取，用于闪电般快速的数据访问，而没有序列化开销。

c)表格式— 最近，一组现代的表格式，如 Delta Lake、胡迪、Iceberg ( 比较)正试图通过 ACID 合规性、快照隔离、安全模式演化和对 CRUD 操作的高性能支持来解决事务性保证。

• Delta Lake —使用压缩成 Apache Parquet 格式的事务日志来提供 ACID 属性和时间旅行。
• Apache Iceberg —最初由网飞开发，提供事务保证、快照隔离、列投影和谓词下推。
• 阿帕奇胡迪 (Hadoop Upserts 删除和增量)——最初在优步开发，再次带来了数据湖的 ACID 合规性。

3.数据管理服务

作者图片

a)数据查询— 数据查询工具的范围从 SQL 这样的声明性语言到 Pig 这样的过程性语言。

• Pig —很好地概述了 Pig 拉丁语，而 Pig 则介绍了如何使用 Pig 构建数据管道。
• Hive —提供 Hive 的介绍，而 Hive 另一篇好文章试图分享 Hive 在脸书背后的动机。
• 凤凰—h base 上的 SQL。
• Spark SQL—Spark 上的关系数据处理。
• 方解石 —提供对异构数据源的优化查询处理，并嵌入到多个大数据系统中。

b)可视化

• 超集 —由 AirBnb 开发，是一款针对大数据的数据探索和数据可视化工具。

c)数据集成— 数据集成框架提供了在大数据系统之间接收和输出数据的良好机制。

• Sqoop——在 Hadoop 和关系数据存储之间移动数据的工具。
• Flume —面向流的数据流，从所有指定的服务器收集日志，并将其加载到中央存储。
• Goblin —最初由 LinkedIn 开发，简化了大数据集成的常见方面，如流数据和批量数据生态系统的数据摄取、复制、组织和生命周期管理。
• 马尔马拉——优步研发，支持摄食和扩散。

d)流程编排— 工具帮助构建数据管道

• 阿帕奇 Nifi -数据分发与处理系统；提供了一种将数据从一个地方移动到另一个地方的方法，并在移动过程中根据需要做出路由决策和转换。
• Apache air flow——最初由 AirBnb 开发，帮助创作、安排和监控工作流程。
• Oozie —管理 Hadoop 作业的工作流调度系统。
• 阿兹卡班——LinkedIn 开发的工作流管理器。
• Genie —网飞开发的数据管道框架。

e)元数据工具 —提供一个中心位置来接收新数据源、发现数据集和见解、浏览元数据、探索原始或相当未处理的数据以了解数据谱系、创建和共享见解以及查看数据质量监控&异常检测。

• 地面 —管理所有告知数据使用的信息的系统。
• Apache Atlas —数据治理平台，旨在与 Hadoop 堆栈中的其他工具和流程交换元数据、跟踪血统。
• DataHub —由 LinkedIn 开发，提供元数据发现和数据门户的完整解决方案。
• Amundsen —由 Lyft 开发，提供数据发现和元数据管理。
• Metacat —由网飞开发，提供统一的元数据探索 API 服务。

4.数据处理服务

作者图片

数据处理框架可以根据处理的模型和延迟大致分类。

a)Batch—MapReduce—来自 Google on MapReduce 的开创性论文。

b)流式传输

• Apache Beam 受 Google Dataflow 和 Millwheel 的启发，它统一了定义批处理和流数据并行处理流水线的模型。
• Flink — Flink 为编程模型和执行引擎中的实时分析、连续流和批处理提供了统一的模型。使用异步屏障同步处理状态。
• Spark Streaming —引入了连接传统批处理和交互处理的微批处理架构。
• Twitter Heron——公开了与 Storm 相同的 API 接口，但是在它的基础上进行了改进，具有更高的可扩展性、更好的可调试性、更好的性能，并且更易于管理。
• Samza—LinkedIn 的流处理框架。

c)互动

• Dremel——谷歌关于其如何处理交互式大数据工作负载的论文，该论文为 Hadoop 上的多个开源 SQL 系统奠定了基础。
• 脸书开发的开源 MPP SQL 查询引擎，可以快速处理大型数据集。
• Impala — MPI 风格的处理使 Hadoop 能够应对交互式工作负载。
• Drill—Dremel 的开源实现。
• Tez —使用 YARN 的得律阿德斯的开源实现。

d)实时

• 德鲁伊——一个实时的 OLAP 数据仓库。可操作的时间序列分析数据库。
• 皮诺 —在 OLAP LinkedIn 数据商店开发，与德鲁伊非常相似。
• AresDB —开发了利用 GPU 进行实时分析的优步。

e)迭代

• Pregel——谷歌关于大规模图形处理的论文。
• Giraph —围绕 Google Pregel 建模的大规模分布式图形处理系统。

5.ML 服务

作者图片

ML 服务为机器学习开发人员、数据科学家和数据工程师提供基础，使他们的 ML 项目从构思到生产和部署，快速且经济高效。

a) ML 生命周期 —典型的 ML 生命周期始于数据准备，随后是(特征)发现、开发和训练模型、测试、部署，最后使用模型进行推理或预测。数据准备通常与获取、导出和清理足够的训练数据以馈入 ML 算法相关联。特征发现和提取识别对业务领域最重要的关键数据属性。部署包括可观察性、可调试性、监控和生产化。现代 ML 生命周期中有几个挑战(见科技债务)ML 生命周期系统正在试图解决。

著名的开源软件有(很好的概述这里):

• 来自 Databricks 的 MLFlow 的一个关键原则是开放接口设计，科学家和数据工程师可以将他们的模型引入到结构化环境中。
• 米开朗基罗由优步打造，允许大规模无缝构建、部署和操作机器学习解决方案。
• Metaflow 是网飞大学使用的一个 python 库，用于构建和部署数据科学工作流。

b)分布式处理框架— 在构建分布式深度学习框架方面有很多进展，这里可以找到很好的介绍其中比较流行的是谷歌的 GPIPE ，优步的 Horovard 和 DeepMind 的 TF-Replicator 。

特征存储库(Feature Stores)—特征存储库允许不同的团队管理、存储和发现用于机器学习项目的特征。它充当数据工程和数据科学之间的 API，实现改进的协作。这里有一个很棒的介绍，这里有列出的特色店列表。几个受欢迎的是来自谷歌的盛宴和一些背景这里的，来自 Logicalclocks 的 HopsWorks ，来自 LinkedIn 的 Frame 和来自 Airbnb 的 ZipLine 。

d) ML 库 — ML 开发人员通常希望尝试每一种可用的算法来构建最精确的模型，一个从事活动项目的团队可能会尝试多个处理库，常见的有 MxNet 、 TensorFlow 、 Clipper 、 Caffe 、 PyTorch 、 Theano 和Chainer

6.数据服务系统

作者图片

广义地说，分布式数据存储根据底层模式和支持的数据结构分为列、键值、文档、图形、搜索、关系和内存中。

a)面向列的商店

• BigTable—Google 关于分布式面向列的数据存储的开创性论文。
• HBase —虽然没有明确的论文，但这提供了该技术的一个很好的概述。
• Hypertable——围绕 BigTable 建模。

b)关键值商店

• Dynamo —关于键值分布式存储系统的开创性论文。
• 卡珊德拉——灵感来自迪纳摩；面向多维键值/列的数据存储。
• 伏地魔——另一个受迪纳摩启发，在 LinkedIn 开发的。
• RocksDB —由脸书开发，是一种日志结构数据库引擎，针对闪存驱动器和高速磁盘驱动器等快速、低延迟存储进行了优化。

c)文档存储

• CouchDB —一种流行的面向文档的数据存储。
• MongoDB —对 MongoDB 架构的很好介绍。

d)图形存储

• Neo4j —最流行的图形数据库。
• 泰坦—Apache 许可下的图形数据库。

e)搜索商店

• 弹性搜索 —分布式可扩展搜索引擎。
• Solr —类似于 ElasticSearch。

f)时间序列

• TimeScaleDB —可伸缩的时间序列数据库。
• InfluxDB —另一个流行的时间序列数据库(差异)。

g)关系

• cocroach db——仿照谷歌的扳手。
• MySQL —广泛使用的关系数据库。
• 另一个非常流行的数据库。

h)内存中

• Memcache —一个可扩展的分布式缓存，它在脸书的使用。
• Redis —另一种流行的分布式缓存，带有磁盘持久性选项。

附录

一些一般性的论文可以为您提供关于 NoSQL、数据仓库规模计算和分布式系统的背景知识。

• 分布式系统基础
• 作为计算机的数据中心–为仓库规模计算提供了很好的背景。
• 最终一致性–分布式系统不同一致性模型的背景。
• CAP 定理 —一个关于 CAP 及其演化的很好的背景及其评论。
• λ-典型数据管道的既定架构。
• Kappa–一种将处理向上游移动到流层的替代架构。

摘要

我希望这些文件在你开始或加强你的旅程时有用。在第二部分，我们将从云提供商的角度来看架构，而在第三部分，我们将了解一些领先的技术公司如何使用这些(或开发了类似的技术)来解决他们的业务问题。

最初发表于T5【https://www.linkedin.com】。

Pyspark 超参数搜索框架速度提高 100 倍

原文：https://towardsdatascience.com/100x-faster-randomized-hyperparameter-searching-framework-with-pyspark-4de19e44f5e6?source=collection_archive---------13-----------------------

闪电力量。 Pixabay

现成的、可重用的、快速的代码

最近我在为一个巨大的机器学习模型调整超参数。

手动调整不是一个选项，因为我必须调整很多参数。 Hyperopt 也不是一个选项，因为它是连续工作的，也就是说，一次只能制造一个模型。所以训练每个模特要花很多时间，而我的时间很紧。

如果我要赶上最后期限，我必须想出一个更好更有效的方法。因此，我想到了在许多这样的场景中帮助我们数据科学家的一件事— 并行化。

我可以并行化我的模型超参数搜索过程吗？

你可能已经猜到了，答案是肯定的。

这篇文章是关于使用 scikit-learn/xgboost/lightgbm 和 pySpark 为数据科学建立一个超参数调优框架。

网格 vs 随机化？

在我们开始实现超参数搜索之前，我们有两个选项来设置超参数搜索——网格搜索或随机搜索。

从一个 3×3 的参数网格开始，我们可以看到随机搜索最终会对重要参数进行更多的搜索。

上图给出了为什么随机搜索更好的明确答案。

假设我们必须为我们的机器学习模型调整两个超参数。一个不重要，一个很重要。在网格搜索中，我们查看重要参数的三个设置。在随机搜索中，我们在 9 个设置中搜索重要参数。我们花的时间是一样的。

因为随机化搜索更彻底地搜索整个空间，并为我们提供更好的超参数，所以我们将在我们的示例中使用它。

树立我们的榜样

在我的工作场所，我可以访问一个有数百个节点的非常大的集群。这是数据科学家的梦想。但是在这篇文章中，我将使用 Databricks 社区版免费服务器和一个玩具示例。如果你想为自己设置这个小服务器进行练习，请查看我在 Spark 上的帖子。

您可以选择使用 Spark 加载数据，但是在这里，我首先创建我们自己的分类数据，以建立一个我们可以使用的最小示例。

X,y = datasets.make_classification(n_samples=10000, n_features=4, n_informative=2, n_classes=2, random_state=1,shuffle=True)train = pd.DataFrame(X)
train['target'] = y# Convert this pandas Data to spark Dataframe. 
train_sp = spark.createDataFrame(train)# Change the column names.
train_sp = train_sp.toDF(*['c0', 'c1', 'c2', 'c3', 'target'])

train_sp spark 数据集看起来像:

这个想法——复制和应用

由弗兰克·维西亚在 Unsplash 上拍摄的照片

现在我们在 Spark 中有了我们的训练数据集。我们想在这个数据框架上运行多个模型。

Spark 天生擅长键值对。也就是说，具有特定密钥的所有数据都可以发送到一台机器。我们可以对这些数据应用函数。

但是我们需要每台机器上的所有数据。我们如何做到这一点？

我们复制我们的数据 n 次，并给我们的数据添加一个 replication_id，这样每个键都有所有的数据。

好了，现在我们可以使用 replication_id 上的 groupby 将整个数据发送到多台机器。但是我们如何使用熊猫和 scikit 来学习这些数据呢？

答案是:我们用 pandas_udf。这个功能是在 Spark 版本 2.3.1 中引入的。这让你可以利用 Spark 的熊猫功能。

如果您还不理解这一点，请查看代码，因为有时理解代码更容易。

代码

在这里，我们首先通过将cross_join与包含 1–100replication_id的列的数据帧一起使用，将我们的训练数据帧复制 100 次。

# replicate the spark dataframe into multiple copiesreplication_df = spark.createDataFrame(pd.DataFrame(list(range(1,100)),columns=['replication_id']))**replicated_train_df = train_sp.crossJoin(replication_df)**

每一行都用不同的 replication_id 复制 100 次

我们还定义了一个函数，该函数将 pandas 数据帧作为输入，使用 python random 模块获取随机超参数，对数据运行模型(这里我训练的是 scikit 模型，但您也可以用任何模型(如 XGBoost 或 Lightgbm)替换它),并以 Pandas 数据帧的形式返回结果。一定要看看函数和注释。

这里不需要(太多)火花。该函数将熊猫数据框作为输入。

我们现在可以将这个pandas_udf函数应用于我们复制的数据帧，使用:

results = replicated_train_df.groupby("replication_id").apply(run_model)

上面的代码所做的是将具有相同复制 id 的所有数据发送到一台机器上，并将函数run_model应用到数据上。上面的调用是延迟发生的，所以在运行下面的操作调用之前，您无法看到结果。

results.sort(F.desc("Accuracy")).show()

我们的超参数搜索结果

对于这个玩具示例，精度结果可能看起来非常接近，但在嘈杂的真实世界数据集的情况下，它们会有所不同。由于这 100 个模型都是在不同的节点上并行运行的，所以我们在做随机超参数搜索的时候可以节省很多时间。

加速因子当然取决于集群中有多少节点。对我来说，我有 100 台机器可供我使用，所以我获得了大约 100 倍的加速。

你可以从这个数据砖笔记本中获得完整的代码，或者从我的 GitHub 仓库中获得，我在那里保存了我所有帖子的代码。

继续学习

如果你想了解更多关于实用数据科学的知识，请看看 Coursera 的 【如何赢得数据科学竞赛】 课程。我从卡格勒教授的这门课程中学到了很多新东西。

谢谢你的阅读。将来我也会写更多初学者友好的帖子。在 媒体 关注我，或者订阅我的 博客 了解他们。一如既往，我欢迎反馈和建设性的批评，可以通过 Twitter @mlwhiz 联系。

此外，一个小小的免责声明——在这篇文章中可能会有一些相关资源的附属链接，因为分享知识从来都不是一个坏主意。

幸运的是，10 倍数据科学家不是“一件事”,让我们共同努力保持这种状态

原文：https://towardsdatascience.com/10x-data-scientist-is-luckily-not-a-thing-lets-all-work-to-keep-it-this-way-4aa268790a4d?source=collection_archive---------30-----------------------

我们真的不需要那种废话

嘎嘎(摄影:兰迪·欧)

这个周末，Medium 的拜占庭式文章推荐算法决定给我推荐一篇关于成为“10x 数据科学家”的文章。我的第一反应是“绝对 f-？”。我没有链接到它，因为这将奖励一个自我夸大的傻瓜的不良行为(在开放的互联网上宣布自己是 10 倍的任何东西，这需要一个全新的傲慢水平)。如果你必须阅读，搜索并使用谷歌缓存。

我后来意识到，这篇文章发表于 2019 年 10 月，谢天谢地不是最近，但距离写这篇文章还不到 5 个月。这也是 7 月份“10 倍工程师”首次病毒式增长的几个月后。在谷歌上搜索这个词，实际上在互联网上出现了相对少量的使用这个词的帖子，分散在过去 3 年左右。这多少让人松了一口气。它并没有在社区中广泛传播，只是一些博主试图获得廉价的点击率。

按照 2019 年时代精神的理解，整个 10 倍工程师神话是软件工程中可能存在的有毒刻板印象的结晶，我们需要将这种垃圾从数据科学中剔除。如果愚蠢的神话像病毒一样传播开来，并在这个领域之外占据主导地位，比如未来的学生、招聘人员和招聘人员，我们都会因此而遭受损失。

对于那些不熟悉 10x 的人来说，我们将在本文的后面介绍历史和细节。它的要点是，一些非常古老的研究发现，一些程序员在一些指标上比其他人表现得好几个数量级，如编写代码的执行速度、生成的代码行数等。在接下来的研究中，这个观察结果被简化为大约“10 比 1 ”,高性能者产生的代码量是最差性能者的 10 倍。

就其本身而言，观察到在一群人中有更高和更低的表现者并没有特别的争议，幂律分布是一毛钱一打。让整个事情像病毒一样传播的是这个概念是如何与“比其他人都好的孤独的混蛋程序员”的漫画联系在一起的。更糟糕的是，有人宣称这些“10x 工程师”是值得雇佣的，应该积极寻找。从那以后事情就变得疯狂了。

瓦特？！

故意找出有毒人格的核心概念是因为他们可以更好地编码，同时有效地让他们周围的每个人牺牲各种事情，这足以令人难以置信。在数据科学的背景下，这甚至更没有意义，因为这个领域是如此荒谬地跨职能。一个典型的数据人员将直接与整个组织中的所有人一起工作，通常是上下多层。你绝对不需要让一个拥有如此广泛影响力的人成为一个有毒的个体。在一个相对孤立的开发团队中强加这样的人已经是一种暴行，理论上你可以把他们封闭在一个 1 人的团队中。但是让他们和整个组织保持密切联系？还不如在开放式办公室计划里扔个炸弹。

需要说明的是，最初的 10x 概念的基本事实是，工程师(和数据科学家)之间的表现存在巨大的个体差异，这一点并没有真正的争议。有些人的表现不可避免地会比你想衡量的任何指标中表现最差的人好一个数量级。

互联网抓住并拒绝了这样一种观点，即组织中的每个人都应该忍受这些更有生产力的个人带来的任何有害垃圾，仅仅因为他们是高产的。

提示:有些高效的人不是混蛋，去雇佣他们吧。

数据社区非常棒，保持这种状态是我们的共同责任

数据社区是我所知道的最包容和积极的社区之一。我们有来自各行各业的人参加，从博士到高中生。艺术、社会科学和硬科学都有代表。有核心工程师，核心研究人员，各行各业的人，周末散客和学生，他们都对用数据来理解世界感兴趣。看看 datahelpers.org 的上的所有伟人吧。

Twitter 上的数据人群总体上是令人惊讶和开放的。几乎在这个领域的任何地方，你都可以很容易地与人交谈。有很多善意的玩笑，论文和话题的链接和讨论。

还有更广阔的精彩社区。围绕 R 建立了一个巨大的社区，包括用户组、meetup 组和会议。我甚至不知道如何真正使用 R，但仍然高度评价那个社区中的了不起的人。记得 2019 年 R-Ladies 在揭露巨大的数据营丑闻中发挥了重要作用。我们团结一致，大声疾呼，站出来说我们不会接受这种行为，这是社区的荣誉。

这也不是说一切都很完美，但你很难找到一个更好的技术团队。仍然有很多看门人看起来更感兴趣的是宣布什么是“真正的”数据科学，而不是对任何人有所帮助。我还确信，在这个巨大而丑陋的世界的某个地方，粗略的骚扰问题正在发生，没有任何独特的情况允许 DataCamp 丑闻像病毒一样传播。

我们有责任大声明确地说出什么是不可接受的。社会规范是一个社会保持稳定控制和自我节制的最佳方式之一。我们得到了一件好事，不能想当然。这东西分解得很快。

现在，来看看整个 10 倍的事情

对 10x 工程师概念的引用似乎要归因于 Sackman、Erikson 和 Grant 在 1968 年发表的一篇论文，“比较在线和离线编程性能的探索性实验研究”。(美国计算机学会通讯，1968 年 1 月)这是一篇相当短的论文，你必须把你的大脑包裹在历史背景中。简介中给出的研究的主要动机是这样的:关于传统的批处理或分时系统是否更好存在激烈的争论。当程序员可以一直使用电脑，在更昂贵的支持在线访问的硬件上反复调试代码时，他们会变得更懒吗？难道他们不应该在提交程序之前先在纸上手工推理出他们的代码吗？

“现在的孩子！”—最终每个人

这篇论文描述了分时系统是如何工作的，这对更现代的计算机用户来说听起来是非常基本的:

用户程序存储在磁带或磁盘文件存储器中。当用户希望操作他的程序时，他就去几个电传控制台中的一个；这些控制台是 Q-32 的直接输入/输出设备。他通过电传打字机指示计算机装入并启动他的程序。然后，系统将程序从磁盘文件或磁带装入活动存储磁鼓存储器。所有当前运行的程序都存储在磁鼓存储器中，并依次一次一个地传送到磁心存储器中进行处理。在 TSS(分时系统)的调度控制下，每个程序被处理一小段时间(通常是几分之一秒),然后被替换到活动存储器中，等待下一次处理。一个程序只有在需要处理时才被转移到核心；否则，该轮将被拒绝。因此，用户可以花尽可能多的时间来思考下一步做什么，而不会浪费机器的计算时间。

实验是一个 2×2 的设计。受试者(12 名经验丰富的程序员)被要求编写和调试两个问题——一个是“代数”问题，你要编写一个程序来解决输入到电传打字机中的代数方程；另一个是“迷宫”问题，他们必须编写一个程序来打印出通过 20x20 网格迷宫的单条路线。所有的受试者都“参考了公开发表的资料，以获得解决代数问题的可行逻辑建议”。

这些问题是在调试的“在线”条件下给出的，在这种情况下，他们使用 TSS 系统，可以完全访问系统上的所有内容。还有一个模拟的“离线”条件，使用相同的 TSS 系统，但用户必须成批提交他们的工作，并等待 2 小时，等待他们的工作返回。该研究指出，2 小时比典型的批处理系统短，但足够长，大多数受试者抱怨延迟。六名受试者在“在线”条件下接受代数问题，然后在“离线”条件下接受另一个问题，剩下的六名受试者接受在线迷宫。

测试结果表明，分时系统有利于减少用于调试的工时。有趣的是，在线代数问题的平均时间为 34.5 小时(30.5 SD)，而调试问题的平均时间为 50.2 小时(58.9 SD)。平均 35 个人- 小时来解决一个棘手的问题！还要注意巨大的标准差。

这是那篇论文中的表 III，它将播下最初的种子，这将导致 10 倍的废话:

据观察，最好的程序员和最差的程序员之间的差别可能是巨大的。就花在调试代数问题上的时间而言，高达 28 比 1。研究人员还发现，在对简单问题进行类似实验的情况下，9 名“见习”程序员之间存在类似的巨大个体差异。

然后在“快速发展中，史蒂夫·麦康奈尔在 1996 年说了如下的话:

“自 20 世纪 60 年代末以来，一项又一项研究发现，经验水平相似的程序员的生产率确实相差至少 10 比 1 (Sackman，Erikson 和 Grant 1968，Curtis 1981，Mills 1983，DeMarco arid Lister 1985，Curtis 等人 1986，Card 1987，Valett 和 McGarry 1989)。”

这本书本身正面地强调了10 比 1 的理念，试图让读者相信他们也可以将他们的软件开发团队从 1 倍生产力的团队向 10 倍生产力的方向发展。这本书存在的全部原因是教读者(大型软件项目的经理)如何管理他们的团队，使其不像 1x 团队，并表现得更好。

最近引用的来自该段落的论文 McConnell，Valett 和 McGarry，1989 ，查看了 NASA 工程师为各种项目收集的大量项目数据，并显示(大致)最差者和最佳者之间存在 10 倍的差异。但是请注意，以今天的标准来看，这个指标是相当粗略的:源代码行数/小时。所以，总而言之，人们发现一些工程师可以像另一个工程师一样粗制滥造出 10 倍数量的代码。我将在以后的文章中更深入地研究这个 SLoC 度量的历史，因为它太大了，无法在这里涵盖。

整个 10x 的历史比我所能理解的还要曲折，因为研究人员 30 多年来发表了一篇又一篇论文。你可以点击这里，点击这里，为了获得更多的综述和引用，我最初把它们作为我的出发点。

从枯燥的学术/管理概念到荒谬的模因

自 2010 年以来(根据谷歌趋势)，短语“10 倍工程师”不时会出现，这不是一个非常流行的术语。我想它只是静静地在软件管理文献中飘来飘去，并没有走出去。

Knowyourmeme 链接到许多关于 10x 工程师概念的文章或文章。见鬼，我找到一篇文章，说 10x 工程师的概念正在(令人高兴地)消失……发表于 2014 年。

直到 2019 年 7 月 11 日某个决定命运的一天:

一位投资者在推特上说，创业公司应该雇用 10 倍的工程师，以增加成功的几率……你如何找到这位 10 倍的工程师？显然你正在寻找某种 90 年代反社会的技术专家的卡通素描:讨厌开会，工作时间奇怪，使用黑屏背景(？！)，知道产品中的每一行代码，拥有完整的堆栈，可以在几个小时内写出代码，很少使用文档，学习新的框架/语言，是糟糕的导师，不黑东西，很少换工作……这几乎够疯狂的了，它会认为这是讽刺，除了没有任何迹象表明这条推文不是认真的。

讽刺和嘲笑 回复来得又快又猛。然后火继续燃烧，因为 Shekhar 弯下腰:

博主们当然无法抗拒争议，开始写他们自己对 10x 工程师的看法，一些人进入了历史等等。很快它就传播开来，在黑客新闻等网站上找到了它的位置。

这种情况现在已经冷却下来，变成了一个彻底被嘲笑的迷因。但即使是现在，这个概念也存在于更广阔的世界中。缺乏经验和信息的人，不了解迷因的人仍然会问一些关于迷因的问题。过去一个月，我在 Quora 上搜索帖子，仍然有几个 10 倍的工程师问题:

数据科学有机会从情境中学习。我们真的应该听听。

这篇文章最初出现在 Randy 的 Counting Stuff 时事通讯上。通过https://counting.substack.com免费订阅这些文章，并直接放入你的收件箱

如果你因为冠状病毒而被锁在家里，11 堂最好的数据科学课

原文：https://towardsdatascience.com/11-best-data-science-classes-if-youre-locked-home-because-of-coronavirus-ca7d2d74a454?source=collection_archive---------6-----------------------

不用花一分钱就可以开始你的职业生涯

如果你在家的时间太多，为什么不投资在你的技能上呢？照片由 Unsplash 上的 Grzegorz Walczak 拍摄

S 哈克斯佩雷在隔离期间写了李尔王。牛顿在隔离期间为他的运动定律奠定了基础。人们在隔离期间制造有趣的迷因。

你能做什么？永远改变戏剧世界或彻底改变物理世界——我认为这个标准太高了。但你可以提高你在数据科学方面的技能，并在疫情结束后启动你的职业生涯。

[## 我如何在 6 个月内从零编码技能成为数据科学家

我用来自学数据科学的 4 个工具没有花一美元

towardsdatascience.com](/how-i-went-from-zero-coding-skills-to-data-scientist-in-6-months-c2207b65f2f3)

这并不是所有职业的完整指南。如果你做一个简单的谷歌搜索，你会发现你一辈子都拿不完的东西…

相反，这是我和其他人发现特别有用的类的概要。哪些课程适合你取决于你目前的编程和统计技能水平。尽管在实践中编程和统计之间的界限是模糊的，但本指南将这两个学科分开，以便于浏览。

编程方面，三种语言必不可少:Python、R 和 shell 脚本。后者往往被初学者低估。但如果你是一名数据科学家，这是你的饭碗。您还会想了解一两件关于 Git 和 GitHub 的事情。

是时候编码了。马库斯·斯皮斯克在 Unsplash 上的照片

关于 Python 和 R，您可能只需要深入了解其中一个就可以了。这取决于你以后想在哪里工作。

你还需要一些关于数据库的知识。(你想成为一名数据科学家，对吗？SQL 是最先进的语言，所以我建议你在开始申请工作之前开始使用它。

在统计学方面，任何关于数据科学的普通课程都可以。其中许多还介绍了最重要的语言和技术环境。但我还是建议你也去上专门的语言课。因为。编程。是。重要！

由于我们中的许多人都面临着工作和预算的不安全感，我决定只列出免费资源。毕竟，对你的进步来说，你的纪律比你投资的金钱重要一千倍。

编程类

根据您当前的技能，您可能需要这里列出的部分或全部课程。我特意为每种语言只列出了一个，最多两个类，以避免混淆哪一个最适合你。

如果你是一个绝对的初学者，我建议你在继续下面列出的数据科学课程之前遵循所有这些。

1.计算机编程语言

learnpython.org的材料是一个很好的起点。这一切都是交互式的，不需要安装任何东西——你可以直接在浏览器中键入你的代码。

几个小时后，你可能会发现你可以摆弄它了。花几天时间，你就能编写自己的 basic 程序了。

迟早，你需要能够安装 Python 和相关的包。如果你觉得已经准备好了，你可以试试 Python 的官方资源。然而，我不鼓励你这样做，如果你以前没有编码经验，因为这可能是相当令人生畏的。

如果你有一些钱可以花，你可以通过 DataCamp 访问 Python 类。你可以以每月 25 美元的价格学习大多数课程，这些课程也是浏览器代码课程。然而，对于大多数目的来说，来自 Python 和 learnpython.org 的免费资源已经足够了。

2.稀有

哈佛大学的 edX 课程将为你提供开始学习 r 所需的一切。该课程为期 8 周，但你每周只需投入 1-2 小时。所以，即使你的日程很忙，这也是可行的。

如果你想多付出一点努力，获得更深层次的知识，还有约翰霍普金斯大学的 coursera class 。它长达四周，第一周花费 25 小时，之后每周花费 10-12 小时。本课程还包括安装，并为您提供一些背景知识。

[## R 编程入门

使用数据科学中第二常用的编程语言 R 进行端到端的数据分析。

towardsdatascience.com](/getting-started-with-r-programming-2f15e9256c9)

3.结构化查询语言

虽然数据集在 Python 中很容易管理，但 SQL 是处理大数据量的好方法。w3schools.com 的教程涵盖了几乎所有的基础知识。

本教程包含大量浏览器代码示例，非常适合初学者。大约需要 10-15 个小时才能完成。

如果你更喜欢视频课程，你也可以试试可汗学院的课程。这里有更具挑战性的浏览器文本示例，但整个课程的时间会更短，你需要花 5-10 个小时来完成。

4.命令过程

一个很好的开始方式是艰难地学习代码的书。它非常系统，没有任何花哨的 UI。但这正是它的好处所在——稍后，您还将坐在命令行上，没有通常的图形颤音。

学习这门课需要一些纪律。但是值得。完成这个过程需要 5-10 个小时，取决于你潜水的深度。

5.开源代码库

如果你以前从未使用过 GitHub，我建议你阅读并遵循 Anne Bonner 的指南。它在这里:

[## Git 和 GitHub 入门:完全初学者指南

Git 和 GitHub 基础知识，供好奇和完全困惑的人使用(加上最简单的方法来为您的第一次公开…

towardsdatascience.com](/getting-started-with-git-and-github-6fcd0f2d4ac6)

这是一个 18 分钟的阅读，但我建议你至少花几个小时开始。这是一个好主意，当你阅读指南的时候把所有的东西都准备好，因为你会一遍又一遍地需要这些东西。

如果你已经略知一二，那么 GitHub 的指南可以帮你填补空白。

那些统计数据不会自己掌握。由马库斯·斯皮斯克在 Unsplash 上拍摄的照片

数据科学和统计课程

如果你已经掌握了一些编程技巧，你可以利用这些课程来加深你在统计学方面的知识。参加一两门课就足够了——什么最适合你取决于你的时间预算和你喜欢的语言。

6.约翰·霍普金斯大学/ coursera:数据科学专业

时间:~200 小时(或 8 个月每周 6 小时)，自定进度
语言:R，但 Python 是先决条件

这个课程是最值得推荐给有抱负的数据科学家的课程之一。它由 10 个子课程组成，你可以随意混合搭配。但是如果你想获得一个证书给你未来的雇主看，你必须做所有的事情。

7.哈佛工程学院:CS109 课程材料

时间:~100 小时(或每周 8 小时，共 13 周)，自定进度
语言:Python

这是哈佛大学约翰·a·保尔森工程和应用科学学院教授的一堂真实的课。尽管它不像 coursera、edX 等网站上的在线课程，但浏览这些丰富的资料是一种享受。

8.哈佛大学/ edX:统计和研究

时间:8-16 小时(或每周 2-4 小时，共 4 周)，自定进度
语言:R，基本编程是先决条件

鉴于时间有限，这门课涵盖了数据科学的基础知识。它更侧重于数据分析和可视化。如果你时间不多，但仍想学些东西，这是一个选择。

9.udacity:数据科学导论

时间:~100 小时(或 2 个月每周 10 小时)，自定进度
语言:Python

这门课涵盖了从数据采集、分析到可视化的所有内容。小时数和互动形式可能是那些此刻被困在家里的人的理想选择。如果你以更高的强度工作，你可以在几周内完成！

10.德克萨斯大学/ edX:数据分析基础

时间:18-36 小时(或每周 3-6 小时，共 6 周)，自定进度
语言:R，基本编程是先决条件

这门课程将自己定位为一门典型的本科统计学课程，并加入了建模元素。然而，由于投入的时间很少，我认为这更像是对统计学和建模的介绍。

11.密歇根大学/ coursera:应用数据科学

时间:~120 小时(或 4 个月每周 8 小时)，自定进度
语言:Python

本课程的构成与 6 号课程相似，但实际操作性更强。它由 5 个子课程组成，你可以随意混合搭配。如果你已经知道你想从事什么行业，这可能会特别有用。例如，该课程的两个令人兴奋的部分是机器学习和社交网络分析。

是时候学习新东西了。安妮·斯普拉特在 Unsplash 上拍摄的照片

额外收获:统计学入门

6 到 11 级可能对数据科学有点陌生，也许你想先在你的基础上建立。在这种情况下，coursera 上有两个免费的课程，侧重于统计学的基础知识。选择哪一种(或者两者都选)取决于你更喜欢哪种语言。

密歇根大学/coursera:Python 专业统计学

时间:~56 小时(或 2 个月每周 7 小时)，自定进度
语言:Python

适中的时间量使得这个过程非常适合典型的电晕锁定。它由三个子模块组成，包括理解和可视化数据、推理统计分析和拟合统计模型。

杜克大学/coursera:R 专业统计学

时间:~140 小时(或 7 个月每周 5 小时)，自定进度
语言:R

这个类比 Python 中的同类类要长一点，因为它需要你完成更多的数学基础。它的五个子模块包括推理统计、线性回归和建模以及贝叶斯统计。如果你想建立一个坚实的数学基础，并享受 R，这是给你的。

最后一点:运用你的领域知识。你的网络呢

所有这些课程对所有能上网的人都开放。因此，虽然他们可能会给你打下良好的基础，但他们不会成为将你与其他候选人区分开来的优势。

想想是什么让你成为一名独一无二的数据科学家？你以前在哪些领域工作过——健康、数学、生物、化学、物理或完全不同的领域？

[## 你永远不会成为数据科学家的 9 个原因

你需要改变你的心态

towardsdatascience.com](/9-reasons-why-youll-never-become-a-data-scientist-c8c5b75503cf)

你的关系网中谁能给你一个好的介绍？谁认识认识数据科学领域其他人的人？让你的人脉发挥作用。

最后，接受建议。不要相信我，相信其他已经转型为数据科学家的人。阅读《走向数据科学》中的故事是一个很好的起点。

但是你的目标也应该是与你所敬仰的人直接接触并安排非正式的面试。这样，你可以直接从他们的经历中学习。

对于那些被隔离的人，我希望这个指南有助于让你保持理智和知情。不管是否被隔离，我希望我们都能利用这些时间来建立一个更光明的未来。学习新的东西只是开始。

[## 数据科学入门终极指南

我是如何在不到 6 个月的时间里获得数据科学工作机会的

towardsdatascience.com](/the-ultimate-guide-to-getting-started-in-data-science-234149684ef7)

编辑 2020 年 3 月 23 日:正如Mark M所指出的，本文中没有统计 101 课程。我现在在统计中增加了一个带引子的奖励部分。

掌握熊猫分组功能的 11 个例子

原文：https://towardsdatascience.com/11-examples-to-master-pandas-groupby-function-86e0de574f38?source=collection_archive---------7-----------------------

在 EDA 过程中使用的最佳函数。

马库斯·斯皮斯克在 Unsplash 上的照片

Pandas Groupby 函数是一个多功能且易于使用的函数，有助于获得数据的概览。这使得探索数据集和揭示变量之间的潜在关系变得更加容易。

在本帖中，我们将通过 11 个不同的例子来全面理解 groupby 函数，并看看它在探索数据时如何有用。

我将使用客户流失数据集作为示例。第一步是将数据集读入熊猫数据帧。

import pandas as pd
import numpy as npdf = pd.read_csv("/content/Churn_Modelling.csv")df.head()

我们有一些关于银行客户及其产品的特征。这里的目标是预测客户是否会使用提供的功能流失(即退出= 1)。

从机器赚的角度来说，这是一个分类问题。Groupby 函数可用于探索特性如何相关或如何对目标变量产生影响(“Exited”)。

下图是 groupby 函数的逻辑和工作原理。

Groupby 函数(图片由作者提供)

让我们从例子开始。

第一个是检查性别对客户流失是否有影响。

#example 1
df[['Gender','Exited']].groupby('Gender').mean()

我们获取了数据帧的一个子集，它由性别和退出列组成。然后，我们根据性别列中的值(男性和女性)对行进行分组。最后，应用一个集合函数。结果是女性和男性的平均流失率。

除了平均值之外，您可能还想了解数据集中有多少男性和女性。如果存在极端的不平衡，检查平均值可能会导致错误的假设。

解决方案是将 mean 和 count 都用作聚合函数。

#example 2
df[['Gender','Exited']].groupby('Gender').agg(['mean','count'])

女性和男性的数量接近，所以不存在很大的不平衡。平均而言，女性的流失率高于男性。

你可能会觉得只根据性别来做比较太笼统了。在这种情况下，我们可以通过向 group by 函数传递一个列列表来按多个列进行分组。

#example 3
df[['Gender','Geography','Exited']].groupby(['Gender','Geography']).mean()

在我们的数据集中，这三个国家的女性流失率较高。

我们也可以对结果进行排序。

#example 4
df[['Gender','Geography','Exited']].groupby(['Gender','Geography']).mean().sort_values(by='Exited')

结果按升序排列，但我们可以使用升序参数进行更改。

#example 5
df[['Gender','Geography','Exited']].groupby(['Gender','Geography']).mean().sort_values(by='Exited', ascending=False)

我们还可以基于另一个特征中的组来检查多个特征。让我们来看看不同国家的年龄和任期是如何变化的。

#example 6
df[['Geography','Age','Tenure']].groupby(['Geography']).agg(['mean','max'])

在这三个国家中，年龄和任期列的平均值和最大值非常接近。

让我们也将“Exited”列添加到示例 6 中。

#example 7
df[['Exited','Geography','Age','Tenure']].groupby(['Exited','Geography']).agg(['mean','count'])

我们可以根据任何列对结果进行排序。但是，由于它是一个多索引，我们需要向 sort_values 函数传递一个元组。

#example 8
df[['Exited','Geography','Age','Tenure']].groupby(['Exited','Geography']).agg(['mean','count']).sort_values(by=[('Age','mean')])

结果按(“年龄”、“平均值”)列排序。

groupby 函数中的变量作为结果数据帧的索引返回。我们可以通过将 as_index 参数设置为 false 来改变它。

#example 9
df[['Exited','IsActiveMember','NumOfProducts','Balance']].groupby(['Exited','IsActiveMember'], as_index=False).mean()

groupby 函数中的每一列都用一个列表示。每个类别组合都有一行。

默认情况下，groupby 函数会删除缺少的值。我们的数据集没有任何缺失值。让我们添加一些缺失的值，看看如何使用 dropna 参数。

#example 10
df['Geography'][30:50] = np.nandf[['Geography','Exited']].groupby('Geography').mean()

尽管我们在 geography 列中缺少值，但它们被忽略了。我们可以通过将 dropna 参数设置为 false 来更改它。

#example 11
df[['Geography','Exited']].groupby('Geography', dropna=False).agg(['mean','count'])

如您所见，还有另一类缺失值。

注意:为了使用 groupby 函数的 dropna 参数，你需要有 pandas 版本 1.1.0 或更高版本。

我们可以多样化的例子，但基本的逻辑是相同的。Groupby 函数可用作探索性数据分析过程的第一步，因为它让我们了解数据集中变量之间的关系。

感谢阅读。如果您有任何反馈，请告诉我。

掌握 Python 列表理解的 11 个例子

原文：https://towardsdatascience.com/11-examples-to-master-python-list-comprehensions-33c681b56212?source=collection_archive---------7-----------------------

如何有效地使用列表理解？

图片由皮克斯拜的 Gerd Altmann 提供

List 是 Python 中内置的数据结构，方括号中是数据点的集合。列表可用于存储任何数据类型或不同数据类型的混合。

在这篇文章中，我们将通过 11 个例子介绍 python 中的列表理解。我试图根据它们的复杂程度(在我看来)对例子进行排序。

列表理解基本上是基于现有的可重复项创建列表。它还可以被描述为用更简单、更吸引人的语法来表示 for 和 if 循环。列表理解相对来说比循环要快。

Python 列表理解

所以我们迭代一个 iterable 并做一些事情(可选！)，然后将它们放在一个列表中。在某些情况下，我们只取符合特定条件的项目。

让我们从例子开始。

#example 1
import numpy as npa = [4,6,7,3,2]b = [x for x in a if x > 5]
b
[6, 7]

我们迭代一个列表(iterable)并获取大于 5 的元素(condition)。

for 循环的等价形式是:

b = []
for x in a:
  if x > 5:
    b.append(x)
b
[6, 7]

在将项目放入新列表之前，我们还可以对其进行一些处理:

#example 2
import numpy as npa = [4,6,7,3,2]b = [x*2 for x in a if x > 5]
b
[12, 14]

我们将符合条件的项目乘以 2，然后放入一个列表中。

第三个示例是字符串列表:

#example 3
names = ['Ch','Dh','Eh','cb','Tb','Td']new_names = [name for name in names if name.lower().startswith('c')]new_names
['Ch', 'cb']

条件是 string 以字母“c”开头。因为我们既有大写字母也有小写字母，所以我们首先将所有字母转换成小写字母。

iterable 不一定是列表。它可以是任何 python 可迭代的。例如，我们可以迭代一个二维 NumPy 数组，它实际上是一个矩阵。

#example 4
import numpy as np
A = np.random.randint(10, size=(4,4))
A
array([[1, 7, 4, 4],        
       [5, 0, 0, 6],        
       [7, 5, 8, 4],        
       [1, 3, 2, 2]])max_element = [max(i) for i in A]
max_element
[7, 6, 8, 3]

我们迭代矩阵 A 中的行并取最大值。

列表可以存储任何数据类型。我们来做一个列表列表的例子。

#example 5
vals = [[1,2,3],[4,5,2],[3,2,6]]
vals_max = [max(x) for x in vals]
vals_max
[3, 5, 6]

我们在每个列表中创建一个最大值列表。

在列表理解中，我们可以有多个条件。

#example 6
names = ['Ch','Dh','Eh','cb','Tb','Td','Chb','Tdb']new_names = [name for name in names if 
name.lower().endswith('b') and len(name) > 2]new_names
['Chb', 'Tdb']

我们得到以字母“b”结尾并且长度大于 2 的字符串。

我们可以用其他逻辑运算符组合多个条件:

#example 7
names = ['chb', 'ydb', 'thd', 'hgh']new_names = [name for name in names 
if name.endswith('b') | name.startswith('c')]new_names
['chb', 'ydb']

我们也可以有更复杂一点的嵌套列表理解。它们表示嵌套的 for 循环。

考虑下面的列表列表:

vals = [[1,2,3],[4,5,2],[3,2,6]]

我们希望从嵌套列表中取出每个元素，因此期望的输出是:

vals = [1,2,3,4,5,2,3,2,6]

下面是执行此操作的嵌套列表理解:

#example 8
vals = [[1,2,3],[4,5,2],[3,2,6]]vals_exp = [y for x in vals for y in x]vals_exp
[1, 2, 3, 4, 5, 2, 3, 2, 6]

语法可能看起来不太直观。与等效的 for 循环相比，这一点就很清楚了。

对于循环和列表理解(图片由作者提供)

我们将嵌套 for 循环的块放入一个列表理解中。

注:例 7 中有一个更简单的操作方法，就是熊猫的爆炸功能。我使用列表理解只是为了显示结构。可以使用分解功能完成，如下所示:

pd.Series(vals).explode()

它返回一个熊猫系列，但是你可以很容易地把它转换成一个列表。

我们也可以在嵌套列表理解中添加条件。考虑下面的字符串列表。

text = [['bar','foo','fooba'],['Rome','Madrid','Houston'], ['aa','bb','cc','dd']]

我们只需要长度大于 3 的嵌套列表中的字符串。

#example 9
text_1 = [y for x in text if len(x)>3 for y in x]text_1
['aa', 'bb', 'cc', 'dd']

我们将条件放在嵌套列表上，而不是放在单个元素上。因此，等效的嵌套 for/if 循环语法如下。

我们也可以对单个元素设置条件。

#example 10
text_2 = [y for x in text for y in x if len(y)>4]text_2
['fooba', 'Madrid', 'Houston']

我们现在有超过 4 个字符的字符串。因为条件是在单个元素上，所以等价的嵌套 for/if 循环:

我们可能还需要在嵌套列表和单个项目上设置条件。

#example 11
text_3 = [y.upper() for x in text if len(x) == 3 for y in x if y.startswith('f')]text_3
['FOO', 'FOOBA']

我们在长度为 3 的嵌套列表中获取以字母“f”开头的项目，然后将所选项目的所有字母转换为大写。

等效的 for/if 循环:

提示:当你不确定并且找不到理解列表的语法时，试着用 for/if 循环来构建。然后，你可以通过在列表理解中添加单独的循环块，将其转换为列表理解。

额外收获:何时不使用列表理解

列表理解将整个输出列表加载到内存中。这对于小型或中型的列表来说是可以接受的，甚至是可取的，因为它使操作更快。然而，当我们处理大型列表(例如 10 亿个元素)时，应该避免理解列表。这可能会导致您的计算机崩溃，由于内存需求的极端数额。

对于这种大型列表，更好的替代方法是使用一个生成器，它实际上不会在内存中创建大型数据结构。生成器在使用项目时创建项目。物品用完后，生成者会将它们扔掉。使用生成器，我们可以请求 iterable 中的下一项，直到到达末尾，每次存储一个值。

感谢您的阅读。如果您有任何反馈，请告诉我。

简单解释 11 种最常见的机器学习算法

原文：https://towardsdatascience.com/11-most-common-machine-learning-algorithms-explained-in-a-nutshell-cc6e98df93be?source=collection_archive---------1-----------------------

常用机器学习算法综述。

圣地亚哥·拉卡尔塔在 Unsplash 上拍摄的照片

近年来，由于高需求和技术进步，机器学习的流行程度已经大大增加。机器学习从数据中创造价值的潜力使其对许多不同行业的企业具有吸引力。大多数机器学习产品都是用现成的机器学习算法设计和实现的，只做了一些调整和微小的更改。

有各种各样的机器学习算法，可以分为三个主要类别:

• 监督学习算法在给定一组观察值的情况下，对特征(独立变量)和标签(目标)之间的关系进行建模。然后，该模型被用于使用这些特征来预测新观察的标签。根据目标变量的特性，可以是分类(离散目标变量)或回归(连续目标变量)任务。
• 无监督学习算法试图在无标签数据中找到结构。
• 强化学习基于行动奖励原则工作。一个代理通过迭代计算其行动的回报来学习达到一个目标。

在这篇文章中，我将讨论前两类中最常见的算法。

注:虽然深度学习是机器学习的一个子领域，但我不会在本帖中包含任何深度学习算法。我认为深度学习算法由于复杂性和具有明显的动态性，应该单独讨论。此外，我不想把这篇文章写得太长，让读者感到厌烦。

我们开始吧。

1。线性回归

线性回归是一种监督的学习算法，它试图通过将线性方程拟合到数据上来模拟连续目标变量和一个或多个独立变量之间的关系。

线性回归是一个好的选择，自变量和目标变量之间需要有线性关系。有许多工具可以探索变量之间的关系，如散点图和相关矩阵。例如，下面的散点图显示了自变量(x 轴)和因变量(y 轴)之间的正相关关系。一个增加，另一个也增加。

线性回归模型试图将回归线拟合到最能代表关系或相关性的数据点。最常用的技术是普通最小二乘法 (OLE)。使用这种方法，通过最小化数据点和回归线之间距离的平方和来找到最佳回归线。对于上面的数据点，使用 OLE 获得的回归线看起来像:

2.支持向量机

支持向量机(SVM)是一种监督的学习算法，主要用于分类任务，但也适用于回归任务。

SVM 通过画一个决定边界来区分阶级。如何绘制或确定决策边界是 SVM 算法中最关键的部分。在创建决策边界之前，在 n 维空间中绘制每个观察值(或数据点)。“n”是使用的特征数量。例如，如果我们使用“长度”和“宽度”来对不同的“细胞”进行分类，则观察值被绘制在二维空间中，而决策边界是一条线。如果我们使用 3 个特征，则判定边界是三维空间中的平面。如果我们使用 3 个以上的特征，决策边界就变成了一个超平面，很难可视化。

2D 空间中的决策边界是一条线

以到支持向量的距离最大化的方式绘制决策边界。如果决策边界离支持向量太近，会对噪声高度敏感，不能很好地泛化。即使独立变量非常小的变化也可能导致错误分类。

数据点并不总是线性可分的，如上图所示。在这些情况下，SVM 使用核技巧，它测量高维空间中数据点的相似性(或接近度)以使它们线性可分。

核函数是一种相似性度量。输入是原始特征，输出是新特征空间中的相似性度量。这里的相似性是指接近的程度。将数据点实际转换到高维特征空间是一个代价很高的操作。该算法实际上并不将数据点转换到新的高维特征空间。内核化 SVM 根据高维特征空间中的相似性度量来计算决策边界，而不实际进行变换。我想这也是为什么又叫内核绝招的原因吧。

SVM 在维数大于样本数的情况下特别有效。当寻找决策边界时，SVM 使用训练点的子集，而不是所有点，这使得它的记忆效率。另一方面，对于大型数据集，训练时间会增加，这会对性能产生负面影响。

3。朴素贝叶斯

朴素贝叶斯是一种用于分类任务的监督学习算法。因此，它也被称为朴素贝叶斯分类器。

朴素贝叶斯假设特征相互独立和特征之间没有相关性。然而，现实生活中并非如此。这种特征不相关的天真假设是这种算法被称为“天真”的原因。

朴素贝叶斯算法背后的直觉是贝叶斯定理:

p(A|B):给定事件 B 已经发生的概率

p(B|A):给定事件 A 已经发生，事件 B 发生的概率

p(A):事件 A 的概率

p(B):事件 B 的概率

朴素贝叶斯分类器计算给定一组特征值(即 p(yi | x1，x2，…，xn))的类的概率。把这个输入到贝叶斯定理中:

p(x1，x2，…，xn | yi) 表示给定类别标签的特定特征组合(数据集中的一个观察值/行)的概率。我们需要非常大的数据集来估计所有不同特征值组合的概率分布。为了克服这个问题，朴素贝叶斯算法假设所有特征都是相互独立的。此外，分母(p(x1，x2，…，xn))可以被移除以简化方程，因为它仅归一化给定观察值的类的条件概率的值(p(yi | x1，x2，…，xn))。

一个类的概率(p(yi))很容易计算:

在特征相互独立的假设下， p(x1，x2，…，xn | yi) 可以写成 :

给定类标签(即 p(x1 | yi))的单个特征的条件概率可以更容易地从数据中估计出来。该算法需要独立地存储每个类别的特征的概率分布。例如，如果有 5 个类别和 10 个特征，则需要存储 50 个不同的概率分布。

将所有这些加起来，对于朴素贝叶斯算法来说，计算观察一类给定值的特征的概率( p(yi | x1，x2，…，xn) ) 变得很容易

所有特征都是独立的假设使得朴素贝叶斯算法比复杂算法更快。在某些情况下，速度优先于更高的精度。另一方面，相同的假设使得朴素贝叶斯算法不如复杂算法准确。速度是有代价的！

4。逻辑回归

逻辑回归是一种监督学习算法，主要用于二元 分类问题。虽然“回归”与“分类”相矛盾，但这里的重点是“逻辑”一词，指的是在该算法中执行分类任务的逻辑函数。逻辑回归是一种简单但非常有效的分类算法，因此它通常用于许多二元分类任务。客户流失、垃圾邮件、网站或广告点击预测是逻辑回归提供强大解决方案的一些领域的例子。

逻辑回归的基础是逻辑函数，也称为 sigmoid 函数，它接受任何实数值并将其映射到 0 到 1 之间的值。

假设我们要求解以下线性方程:

逻辑回归模型将线性方程作为输入，并使用逻辑函数和对数比值来执行二元分类任务。然后，我们会得到著名的逻辑回归 s 形图:

我们可以“原样”使用计算出的概率。例如，输出可以是“此电子邮件是垃圾邮件的概率是 95%”或“客户点击此广告的概率是 70%”。然而，在大多数情况下，概率被用来分类数据点。例如，如果概率大于 50%，则预测为正类(1)。否则，预测为负类(0)。

并不总是希望为所有高于 50%的概率值选择正类。关于垃圾邮件的情况，为了将一封邮件归类为垃圾邮件，我们必须几乎确定。由于被检测为垃圾邮件的电子邮件会直接进入垃圾邮件文件夹，我们不希望用户错过重要的电子邮件。除非我们几乎确定，否则电子邮件不会被归类为垃圾邮件。另一方面，当健康相关问题的分类需要我们更加敏感时。即使我们有点怀疑一个细胞是恶性的，我们也不想错过它。因此，作为正类和负类之间的阈值的值取决于问题。好的一面是，逻辑回归允许我们调整这个阈值。

5.k 最近邻(kNN)

k-最近邻(kNN)是一种监督的学习算法，可用于解决分类和回归任务。kNN 背后的主要思想是，数据点的值或类是由其周围的数据点决定的。

kNN 分类器通过多数表决原则确定数据点的类别。例如，如果 k 设置为 5，则检查 5 个最近点的类。根据多数类进行预测。类似地，kNN 回归取 5 个最近点的平均值。让我们看一个例子。考虑以下属于 4 个不同类别的数据点:

让我们看看预测类如何根据 k 值变化:

确定最佳 k 值是非常重要的。如果 k 太低，模型太具体，不能很好地概括。它对噪音也很敏感。该模型在训练集上实现了高精度，但是在新的、以前看不到的数据点上将是差的预测器。因此，我们很可能以一个过度拟合的模型而告终。另一方面，如果 k 太大，则该模型太一般化，并且在训练集和测试集上都不是好的预测器。这种情况被称为欠适配。

kNN 简单且易于解释。它不做任何假设，因此可以在非线性任务中实现。随着数据点数量的增加，kNN 变得非常慢，因为模型需要存储所有的数据点。因此，它也不是内存高效的。kNN 的另一个缺点是它对异常值很敏感。

6.决策树

决策树建立在反复询问问题以划分数据的基础上。用决策树的可视化表示来概念化分区数据更容易:

这代表了预测客户流失的决策树。第一次拆分基于每月费用金额。然后算法不断提问分离类标签。随着树越来越深，问题也越来越具体。

决策树算法的目标是在每次分区时尽可能提高预测性，以便模型不断获得有关数据集的信息。随机分割要素通常不会让我们对数据集有有价值的了解。增加节点纯度的分割更能提供信息。节点的纯度与该节点中不同类的分布成反比。要问的问题是以增加纯度或减少杂质的方式选择的。

我们要问多少问题？我们什么时候停止？什么时候我们的树足以解决我们的分类问题？所有这些问题的答案将我们引向机器学习中最重要的概念之一:过拟合。模型可以一直提问，直到所有节点都是纯的。然而，这将是一个过于具体的模型，不能很好地概括。它在训练集上实现了高精度，但在新的、以前看不到的数据点上表现不佳，这表明过拟合。树的深度由 scikit-learn 中决策树算法的 max_depth 参数控制。

决策树算法通常不需要归一化或缩放特征。它也适用于处理混合的要素数据类型(连续、分类、二进制)。消极的一面是，它容易过度拟合，需要集合才能很好地概括。

6.随机森林

随机森林是许多决策树的集合。随机森林是用一种叫做装袋的方法建立的，在这种方法中，决策树被用作并行估计器。如果用于分类问题，结果基于从每个决策树接收的结果的多数投票。对于回归，叶节点的预测是该叶中目标值的平均值。随机森林回归取决策树结果的平均值。

随机森林降低了过度拟合的风险，并且准确性比单个决策树高得多。此外，随机森林中的决策树并行运行，因此时间不会成为瓶颈。

随机森林的成功高度依赖于使用不相关的决策树。如果我们使用相同或非常相似的树，总体结果将不会比单个决策树的结果有太大的不同。随机森林通过自举和特征随机性实现不相关的决策树。

bootstrapping是从带有替换的训练数据中随机选择样本。它们被称为 bootstrap 样本。

自举样本(图源)

特征随机性通过为随机森林中的每个决策树随机选择特征来实现。随机森林中每棵树使用的特征数量可以通过 max_features 参数控制。

特征随机性

随机森林是许多不同问题的高度精确的模型，不需要标准化或缩放。但是，与快速线性模型(即朴素贝叶斯)相比，它不是高维数据集(即文本分类)的好选择。

7.梯度推进决策树(GBDT)

GBDT 是一种集成算法，使用 boosting 方法来组合个体决策树。

Boosting 是指将一个学习算法串联起来，从许多顺序连接的弱学习器中实现一个强学习器。在 GBDT 的例子中，弱学习器是决策树。

每棵树都试图最小化前一棵树的错误。boosting 中的树是弱学习器，但是连续添加许多树，并且每个树集中于前一个树的错误，使得 boosting 成为高效且准确的模型。与装袋不同，增压不涉及自举取样。每次添加新树时，它都适合初始数据集的修改版本。

由于树是按顺序添加的，boosting 算法学习起来很慢。在统计学习中，学习速度慢的模型表现更好。

损失函数用于检测残差。例如，均方误差(MSE)可用于回归任务，对数损失(log loss)可用于分类任务。值得注意的是，当添加新的树时，模型中现有的树不会改变。添加的决策树符合当前模型的残差。

学习率和 n_estimators 是梯度推进决策树的两个关键超参数。学习率，表示为α，简单地表示模型学习的速度。每个新的树修改整个模型。修改的幅度由学习速率控制。 n_estimator 是模型中使用的树的数量。如果学习率低，我们需要更多的树来训练模型。然而，我们需要非常小心地选择树的数量。使用太多的树会产生过度适应的高风险。

与随机森林相比，GBDT 在分类和回归任务上都非常高效，并且提供了更准确的预测。它可以处理混合类型的特征，并且不需要预处理。GBDT 要求仔细调整超参数，以防止模型过度拟合。

GBDT 算法非常强大，已经实现了许多升级版本，如 XGBOOST、LightGBM、CatBoost。

关于过度配合的注意事项

随机森林和梯度推进决策树之间的一个关键区别是模型中使用的树的数量。增加随机森林中的树木数量不会导致过度拟合。在某个点之后，模型的准确性不会因为添加更多的树而增加，但是也不会因为添加过多的树而受到负面影响。由于计算原因，您仍然不希望添加不必要数量的树，但是没有与随机森林中的树的数量相关联的过度拟合的风险。

然而，梯度提升决策树中的树的数量在过度拟合方面非常关键。添加太多的树会导致过度拟合，所以在某个时候停止添加树是很重要的。

8。k-均值聚类

聚类是一种对一组数据点进行分组的方法，将相似的数据点分组在一起。因此，聚类算法寻找数据点之间的相似或相异之处。聚类是一种无监督的学习方法，因此没有与数据点相关联的标签。聚类算法试图找到数据的底层结构。

聚类不是分类。

分类任务中的观察值(或数据点)有标签。根据一些测量值对每个观察值进行分类。分类算法试图对观测值的测量值(特征)和它们的指定类别之间的关系进行建模。然后，模型预测新观察的类别。

K 均值聚类旨在将数据划分为 K 个聚类，使得同一聚类中的数据点相似，而不同聚类中的数据点相距较远。因此，它是一种基于划分的聚类技术。两点的相似性由它们之间的距离决定。

K-means 聚类试图最小化一个类内的距离，最大化不同类之间的距离。K-means 算法不能确定聚类数。我们需要在创建 KMeans 对象时定义它，这可能是一项具有挑战性的任务。

考虑以下数据集的 2D 可视化:

它可以分为以下 4 个不同的集群:

现实生活中的数据集要复杂得多，其中的聚类没有明显的区分。但是，算法的工作方式是一样的。K-means 是一个迭代过程。它基于期望最大化算法。确定集群数量后，它通过执行以下步骤来工作:

1. 为每个簇随机选择质心(簇的中心)。
2. 计算所有数据点到质心的距离。
3. 将数据点分配给最近的聚类。
4. 通过取聚类中所有数据点的平均值，找到每个聚类的新质心。
5. 重复步骤 2、3 和 4，直到所有点收敛并且聚类中心停止移动。

K-Means 聚类相对较快且易于解释。它还能够以一种智能的方式选择初始质心的位置，从而加快收敛速度。

k-means 的一个挑战是必须预先确定聚类的数量。K-means 算法无法猜测数据中存在多少个聚类。如果数据中存在非线性结构来分隔组，k-means 将不是一个好的选择。

9。层次聚类

分层聚类意味着通过迭代分组或分离数据点来创建聚类树。有两种类型的分层聚类:

• 凝聚聚类
• 分裂聚类

分层聚类的优点之一是我们不必指定聚类的数量(但是我们可以)。

聚集聚类是一种自下而上的方法。每个数据点首先被假定为一个单独的聚类。然后迭代地组合相似的聚类。

上图称为树状图，这是一个表示基于树的方法的图表。在层次聚类中，树状图用于可视化聚类之间的关系。

层次聚类的优点之一是我们不必预先指定聚类的数量。但是，将所有数据点合并到一个聚类中是不明智的。我们应该在某个时候停止组合集群。Scikit-learn 为此提供了两个选项:

• 达到一定数量的簇后停止( n_clusters )
• 设置联动的阈值(距离 _ 阈值)。如果两个聚类之间的距离超过阈值，这些聚类将不会被合并。

分裂聚类在现实生活中并不常用，所以我将简单地提到它。简单而清晰的解释是分裂集群是凝聚集群的反义词。我们从一个包含所有数据点的巨大集群开始。然后数据点被分成不同的簇。这是一种自上而下的方法。

分层聚类总是生成相同的聚类。k-均值聚类可能会产生不同的聚类，这取决于质心(聚类的中心)是如何开始的。然而，与 k-means 相比，它是一种较慢的算法。分层聚类需要很长时间来运行，尤其是对于大型数据集。

10。数据库扫描聚类

基于分区和层次聚类技术对于正常形状的聚类非常有效。然而，当涉及到任意形状的聚类或检测异常值时，基于密度的技术更有效。

任意形状的簇

任意形状的簇

DBSCAN 代表den sity-basssclustering ofa应用与 n oise。它能够找到任意形状的聚类和带有噪声的聚类(即异常值)。

DBSCAN 背后的主要思想是，如果一个点靠近来自该簇的许多点，则该点属于该簇。

DBSCAN 有两个关键参数:

• eps :指定邻域的距离。如果两点之间的距离小于或等于 eps，则认为这两点是相邻的。
• minPts: 定义一个聚类的最小数据点数。

基于这两个参数，点被分类为核心点、边界点或异常点:

• 核心点:如果一个点在其半径为 eps 的周围区域内至少有 minPts 个数的点(包括该点本身)，则该点为核心点。
• 边界点:如果一个点可以从一个核心点到达，并且其周围区域内的点数少于 minPts，那么这个点就是边界点。
• 离群点:如果一个点不是核心点，并且从任何核心点都不可达，那么这个点就是离群点。

DBSCAN 不需要预先指定簇的数量。它对异常值是鲁棒的，并且能够检测异常值。

在某些情况下，确定适当的邻域距离(eps)并不容易，这需要领域知识。

11。主成分分析

PCA 是一种降维算法，它基本上从现有的特征中获得新的特征，同时尽可能多地保留信息。PCA 是一种非监督学习算法，但它也广泛用作监督学习算法的预处理步骤。

PCA 通过查找数据集中要素之间的关系来获取新要素。

注 : PCA 是一种线性降维算法。也有非线性方法可用。

PCA 的目的是通过使用较少的特征(或列)尽可能多地解释原始数据集中的差异。新的衍生特征称为主成分。主成分的顺序是根据它们所解释的原始数据集的方差分数来确定的。

主成分是原始数据集特征的线性组合。

PCA 的优点是使用比原始数据集少得多的特征保留了原始数据集的大量差异。主成分是根据它们解释的方差大小排序的。

感谢您的阅读。如果您有任何反馈，请告诉我。

掌握 Python 列表的 11 个必知操作

原文：https://towardsdatascience.com/11-must-know-operations-to-master-python-lists-f03c71b6bbb6?source=collection_archive---------18-----------------------

附有示例的综合实践指南。

照片由恒电影在 Unsplash 拍摄

List 是 Python 中内置的数据结构。它表示为方括号中的数据点集合。列表可用于存储任何数据类型或不同数据类型的混合。

列表是可变的，这也是它们被广泛使用的原因之一。然而，在某些情况下，可变性需要格外小心。

在本帖中，我们将介绍 11 个非常重要的操作，几乎涵盖了你需要了解的关于 Python 列表的所有内容。

1.从列表中删除元素的三种方法

第一种方法是 del 函数。我们刚刚经过了要删除的元素的索引。

a = [1, 2, 'x', 4, 5]
del(a[0])
print(f'a is {a}')a is [2, 'x', 4, 5]

我们可以使用 remove 函数来查找要删除的值。

a = [1, 2, 'x', 4, 5]
a.remove('x')
print(f'a is {a}')a is [1, 2, 4, 5]

第三种方法是 pop 函数，默认情况下它删除列表的最后一个元素。与其他两个函数不同，pop 返回被删除的值。因此，我们可以选择将它赋给不同的变量。

a = [1, 2, 'x', 4, 5]
b = a.pop()
print(f'a is {a}')
print(f'b is {b}')a is [1, 2, 'x', 4]
b is 5

Edit : Pop 常用于弹出(或移除)列表的最后一个元素。但是，它也可以通过提供索引来删除任何元素。感谢 Keethesh 在评论中的提醒。

a.pop(-1) #removes the last element
a.pop(2) #removes the third element

注意:列表有两种索引方式:

• 从开始到结束:0，1，2，3
• 从结束到开始:-1，-2，-3

a = ['x','y','z','t','u','v']print(a[-1])
vprint(a[2])
z

2.追加 vs 扩展 vs 插入

Append 用于将项目添加到列表中。

a = [1, 2]
a.append(3)
a
[1, 2, 3]

无论你在列表中添加什么，它都将成为列表中的一项。

a = [1, 2]
b = [3, 4, 5]
a.append(b)
a
[1, 2, [3, 4, 5]]

列表 b 成为列表 a 的第三个项目。如果您想要创建一个列表，该列表是 a 和 b 中的项目的组合([1，2，3，4，5])，您需要使用 extend 函数或“+”运算符。

a = [1, 2]
b = [3, 4, 5]a.extend(b)
a
[1, 2, 3, 4, 5] # a + b will give the same result 

insert 函数也用于向列表中添加元素。但是，它允许指定新元素的索引。例如，我们可以在列表的开头添加一个新元素(index=0)。

a = [1, 2, 3, 4, 5]
a.insert(0, 'a')
a
['a', 1, 2, 3, 4, 5]

第一个参数是索引，第二个参数是值。

3.通过“=”复制列表

我们可以复制一个列表并创建一个新的变量。

a = [1, 2, 3]
b = a

创建于 pythontutor (图片由作者提供)

然而，新变量“b”只是指向“a”的值的指针。因此，a 的任何变化也会改变 b。让我们通过给 a 加一个值来确认。

a.append(4)
print(f'a is {a}')
print(f'b is {b}')a is [1, 2, 3, 4]
b is [1, 2, 3, 4]

4.使用索引复制列表

我们可以通过选择列表的所有索引来复制列表。

a = [1, 2, 3]
b = a[:]

创建于 pythontutor (图片由作者提供)

新列表 b 包含与 a 相同的值，但是在不同的存储位置。如果我们改变 a，b 不会受到影响。

a.append(4)
print(f'a is {a}')
print(f'b is {b}')a is [1, 2, 3, 4]
b is [1, 2, 3]

使用 copy 函数复制列表的工作原理与复制索引相同。

a = [1, 2, 3]
b = a.copy()
a.append(4)print(f'a is {a}')
print(f'b is {b}')
a is [1, 2, 3, 4]
b is [1, 2, 3]

5.使用 sort()和 sorted()对列表进行排序

sort 和 sorted 函数都可以用来对列表进行排序:

• sort():对列表进行排序，但不返回任何内容。
• sorted():返回列表的排序副本，但不对原始列表进行排序。

a = [2, 0, 4, 3]
b = a.sort()
print(f'a is {a}')
print(f'b is {b}')a is [0, 2, 3, 4]
b is None

创建于 pythontutor (图片由作者提供)

让我们用排序函数做同样的例子。

a = [2, 0, 4, 3]
b = sorted(a)
print(f'a is {a}')
print(f'b is {b}')a is [2, 0, 4, 3]
b is [0, 2, 3, 4]

创建于 pythontutor (图片由作者提供)

6.通过复制创建嵌套列表

当通过复制创建嵌套列表时，我们需要小心修改。原始列表中的任何更改都会更改复制的列表。

a = [1, 2]
b = [4, 5, 6]
c = [a, b]a.append(3)
b.pop()

列表 c 由列表 a 和 b 组成。我们通过添加和删除一个元素更新了列表 a 和 b。结果，列表 c 也被更新。

print(f'a is {a}')
print(f'b is {b}')
print(f'c is {c}')a is [1, 2, 3]
b is [4, 5]
c is [[1, 2, 3], [4, 5]]

创建于 pythontutor (图片由作者提供)

7.在迭代过程中修改列表

列表是可迭代的对象，所以在循环中使用它们是很常见的。迭代是基于索引的，所以如果我们在迭代时更新列表，我们需要小心。

考虑下面的代码。如果项目也在列表 b 中，则它从列表 a 中移除项目。

a = ['x', 'y', 'z', 't']
b = ['x', 'y', 'u', 'v']for item in a:
   if item in b:
      a.remove(item)

当代码被执行时，我们期望列表 a 变成['z '，' t']。让我们看看实际发生了什么。

print(f'a is {a}')
print(f'b is {b}')a is ['y', 'z', 't']
b is ['x', 'y', 'u', 'v']

虽然' y '存在于列表 b 中，但它仍然在列表 a 中。原因是当第一个项目(' x ')从列表 a 中移除时，索引也会更新。下一项 a[1]变成了‘z ’,但它应该是‘y’。因此，for 循环每隔一项进行比较。

下面是从列表 a 中删除第一项的步骤:

创建于 pythontutor (图片由作者提供)

这是下一个比较的项目。如你所见，它是“z ”,所以“y”永远不会被比较。

创建于 pythontutor (图片由作者提供)

8.列出理解

列表理解基本上是基于现有的可重复项创建列表。它以更快的方式实现了 for 循环所能实现的功能。列表理解的语法也比 for 循环的语法更简单、更吸引人。

列表理解的语法(图片由作者提供)

我们来做一个简单的例子。

a = [1, 2, 4, 5, 7, 9, 11]
b = [x for x in a if x % 2 == 0]print(b)
[2,4]

列表 b 仅包含列表 a 的偶数元素。使用 for 循环可以完成相同的操作，如下所示:

for item in a:
   if item % 2 == 0:
      b.append(item)

如你所见，列表理解更简单。

注意 : List comprehension 将整个输出列表加载到内存中，这比 for 循环更快。在处理小型或中型列表时，最好使用列表理解。然而，当我们处理大型列表(例如 10 亿个元素)时，应该避免理解列表。这可能会导致您的计算机崩溃，由于内存需求的极端数额。

9.列出修改元素的理解

我们还可以对列表理解中的每一项进行操作。考虑下面的列表 a:

a = ['john', 'emily', 'julia']

我们想要创建一个列表 b，其中包含以字母“j”开头的名字。我们还想大写的名字。

b = [item.capitalize() for item in a if item.startswith('j')]print(b)
['John', 'Julia']

10.嵌套列表上的列表理解

我们可以在列表理解中迭代嵌套列表。考虑下面的列表列表:

vals = [[1,2,3],[4,5,2],[3,2,6]]

我们希望从嵌套列表中取出每个元素，因此期望的输出是:

vals_exp = [1,2,3,4,5,2,3,2,6]

以下是完成这项任务的理解列表:

vals_exp = [y for x in vals for y in x]
vals_exp
[1,2,3,4,5,2,3,2,6]

如果你对语法不清楚，先用 for 循环试试。然后，您可以将 for 循环块移动到列表理解中。下图将帮助你理解我的意思:

对于循环和列表理解(图片由作者提供)

11.Len、reverse 和 count

这些都是非常简单却非常有用的操作。

• len:返回列表的长度(项目数)
• 反转:反转列表中项目的顺序
• count:统计特定项目在列表中出现的次数

(图片由作者提供)

奖金

在例 10 中有一个更简单的方法来完成这个任务。这涉及到熊猫的爆炸功能。

我们需要将嵌套列表(val)转换为 Pandas 系列，然后应用 explode 函数。为了将它转换回列表，我们可以使用 list 函数。

import pandas as pd
list(pd.Series(vals).explode())[1, 2, 3, 4, 5, 2, 3, 2, 6]

感谢您的阅读。如果您有任何反馈，请告诉我。

从图像处理开始的 11 个步骤

原文：https://towardsdatascience.com/11-steps-to-start-with-image-processing-9f88f16b170c?source=collection_archive---------18-----------------------

OpenCV 和 Python:超级流行的图像处理库的基础

猎户座星云(又名 M42) 由作者拍摄。【天竺葵】

Python 现在是世界上用于任何目的的最广泛使用的编程语言之一。与此同时，图像已经成为大多数深度学习算法的基础，用于与自动驾驶、地球观测或人脸检测等相关的显然遥远的任务。

OpenCV 是用 C++编写的多平台库，为 处理图像 而生。你可以用它做 几乎所有的 :从 蒙版 到 人脸检测 。

幸运的是，有 API 比允许你用 C、Java，当然还有 Python 。

在本文中，我们将通过 10 的步骤来学习成像的基础知识 。

0.安装 OpenCV

要安装OpenCV Python 3 API我们可以简单地使用 pip 。所以在 命令行 或 Anaconda 提示符 中我们可以写:

1.导入图像

安装完成后，我们可以 导入名为cv2的 包。我们还将导入matplotlib来显示我们的实验结果。

2.阅读图像

现在让我们定义一下我们想玩的 图像路径 。我们可以使用函数**cv.imread()**将图像作为 Numpy 数组导入和读取。

认识我最久的人都注意到了我是多么热爱天体摄影。所以，我们来玩一张美丽的 猎户座星云的照片吧！ (更多信息*此处 和 此处 为 astro-addicteds)。*

让我们使用**matplotlib**立即显示该图像的内容:

**

图 1-假彩色的猎户座星云(又名 M42)。[瓦卡罗]

这张 8 bit ( 压缩 ) JPEG 图像是用我的 80/480 折光仪 和一台 佳能 EOS 60D 采集的。 它有(R、G、B)三个通道，分辨率约为2048 x 1328。**

不幸的是，正如我们所看到的，图像 的颜色绝对是交错的 ( 图 1 )。

OpenCV 实际上使用了 BGR 三合 而不是 RGB 作为标准。
因此，有必要转换图像并将通道放在正确的位置: 从 BGR 到 RGB 。

4.重新排列频道:从 BGR 到 RGB

为了将通道按正确的顺序排列，并使它们适应 RGB 颜色空间 ，我们可以使用**cv.cvtColor()**函数将**COLOR_BGR2RGB**作为转换参数。

****

图 2——真实颜色的猎户座星云(又名 M42)。稍微好一点，不是吗？[瓦卡罗]

颜色都是 现在肯定 比较均衡 ( 图 2 )。

5.分别显示频道

由于我们的图像实际上是 3 个不同矩阵*的 堆栈(每个颜色通道 R、G 和 B 一个矩阵)，我们可以考虑分别显示每个矩阵。*

我们可以使用numpy 语法来对立方体进行切片。**

****

图 3 — RGB 图像通道[A.Vaccaro]

我们到了！ 分割三个通道 可以让我们从 光谱角度 (图 3)注意到表征我们主题的有趣细节。

例如，猎户座星云的中心富含 氢气，它发出的光(能量)主要是红色和近红外 。
相反，旁边的反射星云(跑男星云，左边)反射周围年轻恒星的光(通常趋向蓝色)。

拆分渠道 我们实现 ，不出所料，准确的说是 这些 前面提到的 方面 。

红色通道中的白色代表猎户座星云的中心，而蓝色通道则更多地出现在小跑步者星云中。

6.可视化直方图

直方图和图像。不可避免的结合！

一个通道 的 直方图可以告诉我们 数字在每个通道 内是如何分布的。例如，通过分析单个直方图，我们能够知道 是深色区域还是浅色区域占优势 。

**

图 4 — RGB 图像直方图[A.Vaccaro]

注意: ***flatten()*** 这里使用的是展开数组的函数。

天空背景像素是暗的 ，由于它们占优势，它们将直方图(图 4* )向相对 低动态值 ( 例如 25 )移动。*

7.提取位深度

每个像素具有预定的容器大小。不，我说的不是图像几何(例如分辨率)。

我指的是图像 信息内容 :其通道灰度 的种类、丰富度和 动态。

例如，我们可以选择将收集到的信息保存在一个 2 位 容器中的每个像素内:我们会发现自己拥有一个只有白色或黑色像素(0，1 )的图像。**

如果我们决定切换到 8 位 呢？我们将有一个从 0 到 255 的灰度(用于每个通道)。信息，就这样， 开始有了自己的动态 。你明白了！

我们正在玩的物体是一个**numpy** **ndarray**。让我们来看看它们的像素有多大。

所以它有经典的**dtype**属性，我们可以用它来知道图像 的 位深度。

不错！这是 的 8 位 图像。这是我们可以预料到的事情，因为它是一个 JPEG 文件。

这意味着图像中最清晰的像素的值为最暗的像素为 0 。**

一个 16 位 通道图像将允许我们保留高达 65536 级 的灰度( 0，65535 )而不是只有 256 级。这一切，显然是以 为代价，其大小在 盘上。

8.裁剪图像

在我们 裁剪图像 之前，让我们利用**shape**属性找出它的(几何 ) 尺寸 :

输出元组 告诉我们图像有1328 行2048 列3 个通道** ( RGB )。为了 裁剪图像 我们可以简单地使用**numpy**索引方法。**

例如，取 的前 200 行 和 的前 300 列 (所有通道的)我们可以简单地这样写:

****

图 5 —图像左上角的裁剪部分。

瞧！如果我们想从 600 到 900 行、350 到 1250 列和所有通道中进行选择:

****

图 6 —图像的中央裁剪部分。

如果相反，我们想 只裁剪一个通道 ( 第一个)我们只需要写:

****

图 7 —图像的中心单色裁剪。

超级简单！

9.像素数量

图像中有多少像素？要回答这个很简单的问题，只需 将长边的像素数 乘以短边的像素数即可。

2,719,744.大约对应270 万像素** 。**

10.剖析图像

假设你想 从图像中提取一个垂直和一个水平截面 。

****

图 7——如果我们想剖析图像，该怎么办？

我们要 提取这两个轮廓 。我们如何做到这一点？很简单。

我们可以按照这种方式对第 600 行的 水平段 进行操作。

****

图 8-第 600 排的水平剖面图。

对于列#1000 处的 垂直的一个 也是如此。

****

图 9-立柱#1000 的垂直剖面图。

图形中的每条曲线 对应每个 RGB 通道 的 段。

有了这样的简介(图 8，9 )就很容易验证，并且有 的证据 证明我们仅仅通过看图像就能读到的东西。

-1.结论

我们可以暂时停在这里。OpenCV 是一头贪得无厌的野兽:这只是冰山一角。欢迎来到这个 无比广阔的世界 。

🤝如有任何疑问、反馈或协作要求，请随时 联系我Linkedin。我会很高兴和你聊天！

👉要获得更多类似的内容，并关注即将发布的文章，请不要忘记在 Medium上关注我。****

👉如需参考本文，请联系我。谢谢你。

我的数据科学之旅给你的 11 条建议

原文：https://towardsdatascience.com/11-tips-for-you-from-my-data-science-journey-df884faa9f3?source=collection_archive---------35-----------------------

帮助您更成功地进入数据科学的提示。

本杰明·戴维斯在 Unsplash 上拍摄的照片

我做到了！大约两年半后，我转行进入了数据科学领域。如果你正计划将职业生涯转向数据科学，并担心这会花费你这么长的时间，不要这样做。我并不完美，可能和你有不同的生活境遇。但是我会和你分享一些我希望我做了(或者更快做了)的事情来帮助你在更短的时间内成功。

为我的情况做好准备:

a)我是一个蹒跚学步的孩子的丈夫和父亲。

b)我有数学硕士学位，刚开始的时候几乎没有编码经验。

c)我是一名高中数学老师，开车上班要花一个小时。

解决了这个问题，让我们来看看这些技巧吧！

1.如果你要转行，寻找在当前领域应用数据科学技能的机会。

由元素 5 数码在 Unsplash 上拍摄

请记住，作为一名数据科学家，你是一名问题解决者。当你培养了一种分析思维，开始把它应用到你领域的问题中。这可能意味着做你自己的副业。更好的是，你可以在你目前的职业中找到一个你可以用数据科学解决的问题。我在学校这样做是为了影响为学生雇佣额外支持的决定。也许在你的公司里，如果你能经常展示使用数据科学解决公司问题的益处，就能创造一个机会。

2.如果你参加课程，立即应用你学到的技能。

Jonathan Chng 在 Unsplash 上拍摄的照片

所以你已经参加了几门课程来增强基本技能。这很好，但不要陷入所谓的“教程炼狱”。这是你一门接一门地学习，仅此而已。立即应用您的技能！课程使用的数据是为了教学目的，但不会总是让你准备好面对真正杂乱的数据。尝试一两项新技能，感受在未知情况下使用它们的感觉。说到实验…

3.经常实验。

照片由 Unsplash 上的 battle creek 咖啡烘焙师拍摄

玩你所学的。尝试新功能。获取一些新数据以使用新的可视化。将你从未想过会接触到的数据可视化。将您的工作流程转换成可重复使用的脚本。根据你的分析写一份报告。尝试设置一个基本的 web 应用程序。做所有这些将有助于引导你走向你真正喜欢的数据科学。

4.尝试公开分享你的作品。

照片由马库斯·温克勒在 Unsplash 上拍摄

你需要一种方式来展示你的能力。找一个平台来做这件事。我在用 Squarespace 制作的个人网站上写过博客，在 Medium 上也写过博客(当然是在 Medium 上)，制作过 Youtube 视频，在 Twitter 和 Linkedin 上分享过可视化效果和我正在做的事情。无论你决定哪一个，坚持一个，并试着每月至少做一次以上的事情。这样做实际上引起了一家出版公司的注意，他们让我做一个关于 Tensorflow 的在线课程。

5.迅速决定你想在数据科学领域做什么。

由 Jens Lelie 在 Unsplash 上拍摄的照片

有句谚语说“万事通，无所不能”。如果你的时间像我一样被限制在每天一个小时，你就无法掌握 Python、R、SQL、统计学、机器学习、数据可视化、AI 以及有效沟通上述任何一项的能力。你可以根据你喜欢使用的东西和/或你做过的项目来选择你想要专注的技能。对我来说，我坚持使用 Python，因为它可以灵活地访问数据科学的任何部分，并允许我构建 web 应用程序。我对使用什么工具的关注是基于我正在做的与教育相关的项目，因为那是我的领域。

6.不要放弃锻炼。

布鲁诺·纳西门托在 Unsplash 上拍照

当我开始这段旅程时，我正开始完全摆脱我的父亲。但当我如此沉迷于数据科学世界时，我开始否定我在锻炼方面的兴趣和健康。我在中途意识到这一点，不得不重新获得我失去的所有健康进步。我的武术练习也落后了一点。即使每天只做 5 到 10 分钟的小运动量训练，也要做些事情让你的身体保持运动。虽然我们是有伟大思想能力的生物，但我们最初是被设计来移动的

7.让你的 LinkedIn 个人资料迅速脱颖而出

在广告周刊上发现 Linkedin 标志

不管你在旅程的哪个阶段，清理你的 LinkedIn 个人资料。有很多方法可以让你修改这份资料，以引起他人的注意，并找到潜在的雇主。我的简介让一位脸书招聘人员联系我，希望得到一份起薪超过 13 万美元的工作。根据我所学的一些快速修改是:

a)将“数据科学家”和“机器学习”等词放在你要陈述的地方。

b)如果您做过数据科学相关的工作或项目，请将它们添加到您的个人资料中，强调某人如何从您的工作中受益。

这里是我的 LinkedIn 个人资料，给你一些关于以上的想法。

8.寻找导师。

照片由 NeONBRAND 在 Unsplash 上拍摄

或者至少是对你的工作和进步的第二种意见。你需要有人来帮助你调整你的技能。有一个导师当然是很好的。鉴于我的情况，我不能放弃我的工作去全职的新兵训练营。这就是我选择sharpes minds的原因。无论你在哪里，他们都会为你安排一位来自该领域的导师，时间灵活，有大量的招聘支持，并且在你被聘用之前不会收取任何费用。

9.不要得寸进尺。

瑞安·弗兰科在 Unsplash 上拍摄的照片

有了正确的支持系统，事情当然会变得容易得多。对我来说，那是我的妻子。她每天给我一个小时的时间学习，做项目，申请职位。我本可以拿更多，但除非绝对必要，否则我尽量不拿。但它确实有负面影响，让我牺牲了和她在一起的宝贵时间。除此之外，我有时还会抱怨转行花了这么长时间，我一度把她推得太远了。过了一段时间，我的妻子原谅了我，并暂停了其他一切。在追求新职业的同时，记得平衡你的生活。它对别人的影响比你想象的要大。

10.开始写博客

照片由格伦·卡斯滕斯-彼得斯在 Unsplash 拍摄

我之前提到过这一点，但我特别强调这一点是因为书面交流的重要性。到目前为止，我需要我的写作技巧来传达项目提案的请求，为上周发布的用户创建一个使用/解释仪表板的教程，用于与同事就任务进行日常交流，以及起草电子邮件以澄清临时请求。博客有助于培养这些技能。如果你需要更多关于为什么你应该写博客的影响，请阅读大卫·罗宾逊的这篇文章，它与我分享来影响这个决定。

11.做能完成以上 2 条以上建议的事情

图片来自financialish.com

如果你想做我之前提到的 2+个想法，试着做能完成多件事的项目。例如，当我必须为一个项目做点双列相关时，我必须了解它，然后应用它。为了加深我对它的理解，我写了一篇博文。

[## 与 Python 的点双列相关

线性回归是确定数据的两个或多个连续特征之间相关性的经典技术…

towardsdatascience.com](/point-biserial-correlation-with-python-f7cd591bd3b1)

因此，这个项目让我解决了我在数据科学工作中的问题，并产生了一篇博文，增加了我在公众面前的曝光率。通过在 youtube 视频中演练代码，可以更进一步。

通过写这篇博客，我实际上同时完成了两项任务。我将与 SharpestMinds 学员进行一次私人网络研讨会，分享我获得数据科学职位的经验。在这篇博文中，我总结了我将分享的技巧，并创建了一篇对你和他们都有帮助的博文。谁说你不能一心多用。

最终想法

这不是一个详尽的列表。如果你对我提到的更多技巧感兴趣，我会非常乐意和你聊天。我已经不怎么用 Linkedin 了。在 Twitter 上直接给我发消息，告诉我你是通过这篇博客找到我的，我们可以约个时间。

如果你想根据我的经验得到更深入的建议，看看下面这些帖子:

[## 数学背景的潜在数据科学基础

帮助您开始学习数据科学的课程指南

towardsdatascience.com](/a-potential-data-science-foundation-for-math-backgrounds-188b03b9f1ff) [## 为什么专注对您的数据科学之旅至关重要

以及它将如何节省您进入该领域的时间

towardsdatascience.com](/why-focus-is-key-for-your-data-science-journey-b62715b2a1c)

再次感谢您的阅读！如果你是一名数据科学家，正在阅读这篇文章，请在下面的评论中添加我遗漏的任何建议。

直到下一次，

约翰·德杰苏斯

实践 Matplotlib 的 11 个可视化示例

原文：https://towardsdatascience.com/11-visualization-examples-to-practice-matplotlib-4fe4c7dd665c?source=collection_archive---------14-----------------------

综合实践指南

韦斯利·廷吉在 Unsplash 上拍摄的照片

数据可视化在数据科学领域非常重要。它不仅用于交付结果，也是探索性数据分析的重要组成部分。

Matplotlib 是一个广泛使用的 Python 数据可视化库。事实上，许多其他库都是构建在 Matplotlib 之上的，比如 Seaborn。

Matplotlib 的语法通常比 Python 的其他可视化库更复杂。但是，它为您提供了灵活性。你可以自由定制剧情。

这篇文章可以被认为是一个 Matplotlib 教程，但主要集中在实践方面。在每个示例中，我将尝试生成一个不同的图，指出 Matplotlib 的重要特性。

我将在 Kaggle 上的客户流失数据集上做例子。我经常使用这个数据集，因为它很好地混合了分类变量和数字变量。此外，它带有目的性，因此示例构成了探索性的数据分析过程。

让我们首先安装依赖项:

import numpy as np
import pandas as pdimport matplotlib.pyplot as plt
%matplotlib inline

Matplotlib 由 3 层组成，分别是后端、艺术家和脚本层。脚本层是 matplotlib.pyplot 接口。

脚本层使得创建情节相对容易，因为它自动化了将所有东西放在一起的过程。因此，它是数据科学家使用最广泛的图层。

我们将把数据集读入熊猫数据帧。

cols = ['CreditScore', 'Geography', 'Gender', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'IsActiveMember', 'EstimatedSalary',
'Exited']churn = pd.read_csv("/content/Churn_Modelling.csv", usecols=cols)churn.head()

(图片由作者提供)

数据集包含一些关于银行客户及其银行账户的特征。“退出”栏表明客户是否发生了搅动(即离开了银行)。

我们准备好出发了。

1.每个国家的客户数量

这个很简单，但是对于柱状图来说是一个很好的例子。

plt.figure(figsize=(8,5))
plt.title("Number of Customers", fontsize=14)plt.bar(x=churn['Geography'].value_counts().index,
        height=churn.Geography.value_counts().values)

(图片由作者提供)

在第一行中，我们创建了一个特定大小的人物对象。下一行向 Figure 对象添加一个标题。bar 函数绘制实际数据。

2.调整 xticks 和 yticks

默认设置通常是合适的，但在某些情况下可能需要进行细微的调整。例如，我们可以增加字体大小，也可以调整 y 轴的取值范围。

plt.xticks(fontsize=12, rotation=45)
plt.yticks(ticks=np.arange(0, 7000, 1000), fontsize=12)

将这两行代码添加到前面的图中将产生:

(图片由作者提供)

3.更改默认体形大小

默认的图形大小是(6，4)，我认为这是非常小的。如果您不想明确定义每个图形的大小，您可能需要更改默认设置。

matplotlib 的 rcParams 包用于存储和更改默认设置。

plt.rcParams.get('figure.figsize')
[6.0, 4.0]

如您所见，默认大小为(6，4)。我们把它改成(8，5):

plt.rcParams['figure.figsize'] = (8,5)

我们还可以更改其他参数的默认设置，如线条样式、线条宽度等。

我还将 xtick 和 yticks 的字体大小更改为 12。

plt.rc('xtick', labelsize=12)
plt.rc('ytick', labelsize=12)

4.创建简单的直方图

直方图用于可视化变量的分布。

下面的语法将创建一个简单的客户余额直方图。

plt.hist(x=churn['Balance'])

(图片由作者提供)

大多数顾客的账户余额为零。当排除零平衡时，分布接近正态(高斯)分布。

5.自定义直方图

定义直方图的两个基本特征是仓的数量和值的范围。

箱数的默认值为 10，因此值范围将被分成 10 个相等的箱。例如，先前直方图中的第一个柱是 0–25000。增加容器大小就像提高分辨率一样。在某种程度上，我们会对分布有更准确的了解。

取该列的最小值和最大值来定义值范围。我们可以调整它以排除异常值或特定值。

plt.hist(x=churn['Balance'], bins=12, color='darkgrey',
         range=(25000, 225000))plt.title("Distribution on Balance (25000 - 225000)", fontsize=14)

(图片由作者提供)

低于 25000 或高于 225000 的值被排除，并且箱的数量从 10 增加到 16。我们现在看到一个典型的正态分布。

6.创建简单的散点图

散点图通常用于绘制数值变量之间的关系。我们可以用散点图来显示变量之间的相关性。

sample = churn.sample(n=200, random_state=42) #small sampleplt.scatter(x=sample['CreditScore'], y=sample['Age'])

(图片由作者提供)

年龄和信用评分之间似乎没有关联。

7.带支线剧情的散点图

我们可以在同一个图形对象上放置多个散点图。虽然语法比其他一些库(例如 Seaborn)长，但 Matplotlib 在子情节方面非常灵活。我们将做几个由支线剧情组成的例子。

支线剧情函数创建一个图形和一组支线剧情:

fig, ax = plt.subplots()

我们可以在图上创建多个图，并用图例来标识它们。

plt.title("France vs Germany", fontsize=14)ax.scatter(x=sample[sample.Geography == 'France']['CreditScore'], y=sample[sample.Geography == 'France']['Age'])ax.scatter(x=sample[sample.Geography == 'Germany']['CreditScore'], y=sample[sample.Geography == 'Germany']['Age'])ax.legend(labels=['France','Germany'], loc='lower left', fontsize=12)

(图片由作者提供)

8.支线剧情网格

支线剧情不一定要一个接一个。subplots 函数允许使用 nrows 和 ncols 参数创建一个 subplots 网格。

fig, (ax1, ax2, ax3) = plt.subplots(nrows=3, ncols=1)

(图片由作者提供)

我们有一个空的支线剧情网格。在下面的例子中，我们将看到如何填充这些支线剧情，并做一些小的调整，使它们看起来更好。

9.重新安排和访问支线剧情

在添加标题之前，让我们在支线剧情之间留出一点空间，这样它们会看起来更好。我们将使用 tight_layout 函数来实现这一点。

我们也可以去掉中间的 x 记号，只保留底部的。这可以通过 sharex 参数来完成。

fig, (ax1, ax2, ax3) = plt.subplots(nrows=3, ncols=1, figsize=(9,6), sharex=True)fig.tight_layout(pad=2)

(图片由作者提供)

有两种方法可以进入支线剧情。一种方法是显式定义它们，另一种方法是使用索引。

# 1
fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1)
first subplot: ax1
first subplot: ax2# 2
fig, axs = plt.subplots(nrows=2, ncols=1)
first subplot: axs[0]
second subplot: axs[1]

10.绘制支线剧情

我们将创建一个包含两列的网格，并为每一列添加条形图。

fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, sharey=True,
figsize=(8,5))countries = churn.Geography.value_counts()
products = churn.NumOfProducts.value_counts()ax1.bar(x=countries.index, height=countries.values)
ax1.set_title("Countries", fontsize=12)ax2.bar(x=products.index, height=products.values)
ax2.set_title("Number of Products", fontsize=12)

(图片由作者提供)

11.创建二维直方图

2D 直方图显示了一对变量的分布。我们得到了两个变量的值如何一起变化的概述。

让我们创建一个信用评分和年龄的 2D 直方图。

plt.title("Credit Score vs Age", fontsize=15)
plt.hist2d(x=churn.CreditScore, y=churn.Age)

(图片由作者提供)

人口最多的群体由年龄在 30 到 40 岁之间的客户组成，他们的信用评分在 600 到 700 之间。

结论

我们在这篇文章中介绍的只是 Matplotlib 功能的一小部分。我分享的一些信息可以被认为是细节，而其中一些是非常基本的。然而，它们都有助于充分利用 Matplotlib。

和其他学科一样，掌握 Matplotlib 的最好方法是实践。一旦您熟悉了基本功能，就可以继续使用更高级的功能。

感谢您的阅读。如果您有任何反馈，请告诉我。

12 只神奇的熊猫和数字功能

原文：https://towardsdatascience.com/12-amazing-pandas-numpy-functions-22e5671a45b8?source=collection_archive---------3-----------------------

通过在您的分析中使用这些函数，让您的日常生活更加轻松

礼貌:https://pixabay.com/photos/code-programming-python-1084923/

我们都知道熊猫和熊猫很神奇，它们在我们的日常分析中起着至关重要的作用。如果没有熊猫和 NumPy，我们将被遗弃在这个巨大的数据分析和科学世界中。今天，我将分享 12 个令人惊奇的熊猫和 NumPy 函数，它们将使你的生活和分析比以前容易得多。最后，您可以在 Jupyter 笔记本上找到本文中使用的代码。

让我们从 NumPy 开始:

NumPy 是使用 Python 进行科学计算的基础包。除其他外，它包含:

• 一个强大的 N 维数组对象
• 复杂的(广播)功能
• 集成 C/C++和 Fortran 代码的工具
• 有用的线性代数、傅立叶变换和随机数功能

除了其明显的科学用途，NumPy 还可以用作通用数据的高效多维容器。可以定义任意的数据类型。这使得 NumPy 可以无缝、快速地与各种数据库集成。

1. argpartition()

NumPy 有这个神奇的功能，可以找到 N 个最大值索引。输出将是 N 个最大值的索引，然后我们可以根据需要对这些值进行排序。

x = np.array([12, 10, 12, 0, 6, 8, 9, 1, 16, 4, 6, 0])index_val = np.argpartition(x, -4)[-4:]
index_val
array([1, 8, 2, 0], dtype=int64)np.sort(x[index_val])
array([10, 12, 12, 16])

2. allclose()

Allclose()用于匹配两个数组并获得布尔值形式的输出。如果两个数组中的项在容差范围内不相等，它将返回 False。这是检查两个数组是否相似的好方法，而这实际上很难手工实现。

array1 = np.array([0.12,0.17,0.24,0.29])
array2 = np.array([0.13,0.19,0.26,0.31])# with a tolerance of 0.1, it should return False:
np.allclose(array1,array2,0.1)
False# with a tolerance of 0.2, it should return True:
np.allclose(array1,array2,0.2)
True

3.剪辑()

Clip()用于将数组中的值保持在一个区间内。有时，我们需要将值保持在一个上限和下限内。出于上述目的，我们可以利用 NumPy 的 clip()。给定一个区间，区间外的值被剪切到区间边缘。

x = np.array([3, 17, 14, 23, 2, 2, 6, 8, 1, 2, 16, 0])np.clip(x,2,5)
array([3, 5, 5, 5, 2, 2, 5, 5, 2, 2, 5, 2])

4.提取()

Extract()顾名思义，用于根据特定的条件从数组中提取特定的元素。使用 extract()，我们还可以使用类似于和和或的条件。

# Random integers
array = np.random.randint(20, size=12)
array
array([ 0,  1,  8, 19, 16, 18, 10, 11,  2, 13, 14,  3])#  Divide by 2 and check if remainder is 1
cond = np.mod(array, 2)==1
cond
array([False,  True, False,  True, False, False, False,  True, False, True, False,  True])# Use extract to get the values
np.extract(cond, array)
array([ 1, 19, 11, 13,  3])# Apply condition on extract directly
np.extract(((array < 3) | (array > 15)), array)
array([ 0,  1, 19, 16, 18,  2])

5. where()

其中()用于从满足特定条件的数组中返回元素。它返回符合特定条件的值的索引位置。这几乎类似于我们在 SQL 中使用的 where 条件，我将在下面的例子中演示它。

y = np.array([1,5,6,8,1,7,3,6,9])# Where y is greater than 5, returns index position
np.where(y>5)
array([2, 3, 5, 7, 8], dtype=int64),)# First will replace the values that match the condition, 
# second will replace the values that does not
np.where(y>5, "Hit", "Miss")
array(['Miss', 'Miss', 'Hit', 'Hit', 'Miss', 'Hit', 'Miss', 'Hit', 'Hit'],dtype='<U4')

6.百分位()

Percentile()用于计算沿指定轴的数组元素的第 n 个百分位数。

a = np.array([1,5,6,8,1,7,3,6,9])print("50th Percentile of a, axis = 0 : ",  
      np.percentile(a, 50, axis =0))
50th Percentile of a, axis = 0 :  6.0b = np.array([[10, 7, 4], [3, 2, 1]])print("30th Percentile of b, axis = 0 : ",  
      np.percentile(b, 30, axis =0))
30th Percentile of b, axis = 0 :  [5.1 3.5 1.9]

让我知道你以前是否用过它们，它对你有多大帮助。让我们继续看神奇的熊猫。

熊猫:

pandas 是一个 Python 包，提供了快速、灵活、富于表现力的数据结构，旨在使结构化(表格、多维、潜在异构)和时间序列数据的处理变得既简单又直观。

pandas 非常适合许多不同类型的数据:

• 具有不同类型列的表格数据，如在 SQL 表或 Excel 电子表格中
• 有序和无序(不一定是固定频率)时间序列数据。
• 带有行和列标签的任意矩阵数据(同类或异类)
• 任何其他形式的观察/统计数据集。这些数据实际上根本不需要标记就可以放入 pandas 数据结构中。

以下是熊猫擅长的几件事:

• 轻松处理浮点和非浮点数据中的缺失数据(表示为 NaN)
• 大小可变性:可以在数据帧和高维对象中插入和删除列
• 自动和明确的数据对齐:对象可以明确地与一组标签对齐，或者用户可以简单地忽略标签，让系列、数据框等。在计算中自动调整数据
• 强大、灵活的分组功能，可对数据集执行拆分-应用-组合操作，用于聚合和转换数据
• 使将其他 Python 和 NumPy 数据结构中粗糙的、不同索引的数据转换成 DataFrame 对象变得容易
• 大型数据集的智能基于标签的切片、花式索引和子集化
• 直观的合并和连接数据集
• 数据集的灵活整形和旋转
• 轴的分层标签(每个刻度可能有多个标签)
• 强大的 IO 工具，用于从平面文件(CSV 和带分隔符文件)、Excel 文件、数据库加载数据，以及从超快速 HDF5 格式保存/加载数据
• 特定于时间序列的功能:日期范围生成和频率转换、移动窗口统计、日期移动和滞后。

1. read_csv(nrows=n)

您可能已经知道 read_csv 函数的用法。但是，我们中的大多数人仍然会犯一个错误。csv 文件，即使它不是必需的。让我们考虑这样一种情况，我们不知道一个 10gb 的. csv 文件中存在的列和数据，整个读取。csv 文件在这里不会是一个聪明的决定，因为它会不必要的使用我们的内存，并会花费大量的时间。我们可以只从。csv 文件，然后根据我们的需要进一步进行。

import io
import requests# I am using this online data set just to make things easier for you guys
url = "[https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/datasets/AirPassengers.csv](https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/datasets/AirPassengers.csv)"
s = requests.get(url).content# read only first 10 rows
df = pd.read_csv(io.StringIO(s.decode('utf-8')),nrows=10 , index_col=0)

2.地图()

map()函数用于根据输入的对应关系映射系列的值。用于将一个数列中的每一个值替换为另一个值，该值可以是从一个函数、一个字典或一个数列中导出的。

# create a dataframe
dframe = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['India', 'USA', 'China', 'Russia'])#compute a formatted string from each floating point value in frame
changefn = lambda x: '%.2f' % x# Make changes element-wise
dframe['d'].map(changefn)

3. apply()

apply()允许用户传递一个函数，并将其应用于 Pandas 系列的每个值。

# max minus mix lambda fn
fn = lambda x: x.max() - x.min()# Apply this on dframe that we've just created above
dframe.apply(fn)

4. isin()

isin()用于过滤数据帧。isin()有助于选择在特定列中具有特定(或多个)值的行。这是我遇到的最有用的功能。

# Using the dataframe we created for read_csv
filter1 = df["value"].isin([112]) 
filter2 = df["time"].isin([1949.000000])df [filter1 & filter2]

5.复制()

copy()用于创建一个熊猫对象的副本。当您将一个数据框分配给另一个数据框时，当您在另一个数据框中进行更改时，其值也会发生变化。为了防止上述问题，我们可以使用 copy()。

# creating sample series 
data = pd.Series(['India', 'Pakistan', 'China', 'Mongolia'])# Assigning issue that we face
data1= data
# Change a value
data1[0]='USA'
# Also changes value in old dataframe
data# To prevent that, we use
# creating copy of series 
new = data.copy()# assigning new values 
new[1]='Changed value'# printing data 
print(new) 
print(data)

6. select_dtypes()

select_dtypes()函数根据列 dtypes 返回数据框列的子集。此函数的参数可以设置为包括所有具有某种特定数据类型的列，也可以设置为排除所有具有某种特定数据类型的列。

# We'll use the same dataframe that we used for read_csv
framex =  df.select_dtypes(include="float64")# Returns only time column

奖励:

pivot_table()

熊猫最神奇最有用的功能就是 pivot_table。如果您对使用 groupby 犹豫不决，并且希望扩展它的功能，那么您可以使用 pivot_table。如果您知道 excel 中的数据透视表是如何工作的，那么这对您来说可能是小菜一碟。数据透视表中的级别将存储在结果数据帧的索引和列上的多索引对象(分层索引)中。

# Create a sample dataframe
school = pd.DataFrame({'A': ['Jay', 'Usher', 'Nicky', 'Romero', 'Will'], 
      'B': ['Masters', 'Graduate', 'Graduate', 'Masters', 'Graduate'], 
      'C': [26, 22, 20, 23, 24]}) # Lets create a pivot table to segregate students based on age and course
table = pd.pivot_table(school, values ='A', index =['B', 'C'], 
                         columns =['B'], aggfunc = np.sum, fill_value="Not Available") 

table

如果你们遇到或使用过其他神奇的功能，请在下面的评论中告诉我。我很想知道更多关于他们的事情。

Jupyter 笔记本(使用代码):https://github . com/kunaldhariwal/Medium-12-Amazing-Pandas-NumPy-Functions

LinkedIn:https://bit.ly/2u4YPoF

我希望这有助于增强你的知识基础:)

更多信息请关注我！

感谢您的阅读和宝贵时间！

12 台重要的 Colab 笔记本电脑

原文：https://towardsdatascience.com/12-colab-notebooks-that-matter-e14ce1e3bdd0?source=collection_archive---------5-----------------------

StyleGAN、GPT-2、StyleTransfer、DeOldify、Magenta 等。参加选拔

我喜欢 Colab 笔记本。作曲:Merzmensch(本文作者)

打开手机。

它至少花了两个艾特斯 才活下来。故事很明显:理论上，人工智能作为一个概念已经在这里了。神经元网络(作为一个概念:1943 — 麦卡洛克&皮茨/泛函:1965 — 伊瓦赫年科/帕拉)，机器学习 ( 塞缪尔，1959)，反向传播 ( 沃博斯 — 1975)，仅举几个重点研究。理论上。但实际上，计算能力仍然是这样的:

人工智能的研究还有待于实际实现。最后，在 2000 年代，每一个拥有个人电脑的人都能够用机器和深度学习做实验。

我记得 2016 年，随着谷歌深度梦想的出现(感谢亚历山大·莫尔德温采夫)。我花了很长时间来设置和运行它。但是结果是惊人的:

左边:Merzmensch 的照片，我平时的“Merzmensch userpic”。右边:这张被 DeepDream 改造的照片，截图:Merzmensch

我爱上了艾。我想尝试更多。后来我发现了 Colab 笔记本。他们改变了我的生活。

Google Colab 笔记本实现了数据科学的民主化。它们允许每个人——人工智能研究员、艺术家、数据科学家等——在每个设备上(甚至在智能手机上)享受机器和深度学习的力量。只需运行细胞，改变参数、值和来源，享受 AI 的多样性。

我想和你分享一些我喜欢的笔记本。试试吧！你可以在这里找到许多关于背景和使用 Colab 笔记本的优秀文章。

图像和视频

01)谷歌深梦

来源:【TensorFlow.org//图片抄送:Von.grzanka

这是怎么回事？

DeepDream 通过神经网络可视化模式识别、解释和迭代生成。通过增加这种创造性的解释，你可以产生梦一样的意象。

神经网络就像我们的大脑一样:它寻找熟悉的模式，这些模式来自它们被训练的数据集。

资料来源——左边:美国国家航空航天局，公共领域，1976 //右边:蒙娜丽莎，带着深深的梦想，CC-by nixtown ，2016

上面的例子(我在 2019 年 11 月法兰克福 AI Meetup 上的一个 屏幕)展示了我们的大脑如何在火星 Cydonia 地区的岩层中识别一张脸。一位用户 Nixtown 通过连续的 DeepDream 迭代改变了达芬奇的蒙娜丽莎——AI 识别出了奇怪的模式。

通常我们的大脑会识别不存在的模式或物体。但是如果我们人类的感知做到了，为什么 AI 不应该呢？

链接:

• Alexander Mordvintsev 的原创博文
• GitHub
• Colab 笔记本

要尝试的东西:

尝试生成不同的图案并调整图像大小(八度)。使用更多迭代。不要害怕疯狂——结果可能会令人不安。

有趣的事实:

最初，DeepDream 习惯于在每个图案中识别大部分是狗脸。据 FastCompany 称，该网络是在…

ImageNet 数据库的一个更小的子集，于 2012 年发布，用于一场比赛…该子集包含“120 个狗子类的细粒度分类( FastCompany )。

阅读 更多关于我与 DeepDream 的实验。

02)比根

模拟时钟(#409)，由比根创造。我截图。

这是怎么回事？

比格根是第一批著名的生成对抗网络之一。在 ImageNet 上以现在不起眼的 128x128 分辨率训练，这个网络因其多方面的生成能力而成为一个标准。

在这个笔记本中，您可以从一长串类别中生成样本。

选择类别“山谷”……(截图:Merzmensch)

…生成照片般逼真的山谷图像系列(由:Merzmensch 生成)

链接:

• 比根关于 arXiv 的论文(安德鲁·布洛克，杰夫·多纳休，卡伦·西蒙扬。高保真自然图像合成的大规模 GAN 训练。 arxiv:1809.11096 ，2018)
• Colab 笔记本

要尝试的东西:

同一个笔记本可以让你创建图像之间的插值。这种方法过去是——现在也是——令人兴奋和创新的，因为以前只有超现实主义者和抽象艺术家才有勇气把不相容的东西结合起来。现在你可以用照片级的结果来做这件事，例如，在约克夏犬和航天飞机之间生成插值。

截图:Merzmensch

生成人:Merzmensch

参见:

• 作为创意引擎的比根
• 比根和万物的蜕变

03)样式转移

我的用户 pic，正在被梵高画//生成人:Merzmensch //右边来源:梵高，文森特·凡:星夜，1889

这是怎么回事:

在这个实验中，深度学习系统检查了两幅源图像——并转换了它们的风格:不仅是颜色，还有形状和图案。

链接:

• Lucid (TensorFlow)
• Colab 笔记本

请参阅:

• 风格转移(你也可以这样做)
• 艾&创意:风格迥异的元素

人工智能中的艺术

截图来自我的文章“ 14 种深度和机器学习的使用使 2019 年成为一个新的人工智能时代”//右边是迭戈·贝拉斯克斯的《拉斯梅尼亚斯》

有许多方法可以在艺术品上训练人工智能。

其中一个是通过 Reddit 提供的:StyleGAN 在艺术数据集上用 Kaggle 的 24k 图像进行了训练。

你会得到有趣的结果，甚至有可能追踪到模型被训练的原始艺术品。(美术新游戏，各位？视觉词源”:

我用 StyleGAN 生成的图像，在 Kaggle 上训练(截图:Merzmensch)

另一个是 WikiART StyleGAN2 条件模型，由彼得·贝勒斯(等人)提供，由多伦·阿德勒打包成笔记本:

这个模型是在维基图片上训练出来的。它甚至允许在艺术家、流派和风格之间进行选择。

Merzmensch 截图

这些图像令人印象深刻:

Merzmensch 使用 WikiART 模型生成的图像。

要尝试的东西:

• 每一种新的组合都会产生有趣的艺术品。尽量选择不同时代风格不典型的艺术家。像毕加索&文艺复兴或者希什金 & 波普艺术。结果有时出乎意料，也不总是容易理解，但这毕竟是艺术。

链接:

• C0D32 Colab 笔记本(24k 艺术品培训)
• WikiART StyleGAN2 Colab 笔记本

参见:

• 如何培养自己的艺人。
• 数据集的不可背叛性。

06)样式 2

StyleGAN2 生成的图片(数据集 FFHQ，Flickr-Faces-HQ)，截图由 Merzmensch 提供

这是怎么回事？

由 NVidia 开发的这个网络是目前(2020 年 3 月 6 日下午 4:27)最先进的图像生成网络。它在高清数据集上进行了训练(例如，来自 Flickr-Faces-HQ 的人脸)。StyleGAN2 提供自动学习、无监督的高级属性分离、随机变化和具有视觉特征的层控制。

有各种各样的笔记本(众包研究的好处)，但我最喜欢的是 Mikael Christensen 设计的。

链接:

• 论文:https://arxiv.org/abs/1812.04948
• 视频:https://youtu.be/kSLJriaOumA
• 代号:https://github.com/NVlabs/stylegan/https://github.com/NVlabs/stylegan2
• Colab 笔记本

要尝试的东西:

• 笔记本电脑中有各种 NVidia 默认数据集(注意分辨率):

各种数据集，由 NVidia 提供。Merzmensch 截图

• 尝试新的数据集。训练你自己的模型或者使用那些由各种艺术家和研究人员提供的模型，比如迈克尔·弗里森(关注他的推特以获得新的更新)。

细菌类型 g

我用细菌样式生成的一些图片，截图来自 Merzmensch

艺术风格:

麦克·埃舍尔-斯泰勒根:

我用 Merzmensch 的数据集/截图生成的一些图像

• 制作插值视频:

我的插值实验

• 试用 StyleGAN2 投影。使用 StyleGAN2 笔记本，您会发现(或者更好:重新覆盖)隐藏在网络的潜在空间中的图像。StyleGAN Projection 是一种追溯 StyleGAN2 生成的图像的方法——所以你可以将一张照片检测为人工智能生成的产品(# deep fake decide)。它仍然有一些缺点:你必须知道特定图像的具体数据集；图像的每一个变化都会使投影的过程不可行。

这是一个成功的预测:

我的投影实验，两幅图像都是 StyleGAN2 生成的

这个可能会让你第二天晚上睡不着觉:

我的投影实验，图片在左边

阅读更多信息:

• StyleGAN2 投影。可靠的图像取证方法？

如果你想尝试更多样的动机，试试art breader，这是由乔尔·西蒙设计的强大的图像生成器:

[## 艺术育种家

发现图像的协作工具。

artbreeder.com](https://artbreeder.com/)

07)#解除锁定

摄影:弗拉基米尔·佩雷尔曼

那是怎么回事:

由杰森·安蒂奇设计的去彩色模型允许对照片和视频进行有机着色。你可以把古老的历史片段带回到生动的生活中。同时，在 MyHeritage.org实施。

方法是强大的。它可以识别图案和物体，并在其上应用经过训练的视觉数据库的颜色。

例如，这些 1950 年代的花:

它也适用于视频。在这里观看#著名的"火车到达拉乔塔特(卢米埃尔兄弟，1896) 的简化和升级版本

建议:

上传你的黑白影片到你的谷歌硬盘。所以你可以保护隐私(当然，如果你信任谷歌云的话)。

链接:

• GitHub
• 图像去模糊
• 解除视频锁定(支持各种视频平台)

阅读更多信息:

• 去模糊:基于 GAN 的图像彩色化
• 历史重演

8) 3D 本·伯恩斯效应

3D 本·伯恩斯版我的照片(Merzmensch)，来源

这是怎么回事:

3D 本·伯恩斯效果(由西蒙·尼克劳斯等人开发)允许生成单张照片的动画 3D 视频片段。

要尝试的东西:

在 Colab 笔记本中你会找到组件 autozoom.py 。尝试使用以下参数对其进行微调:

objectTo = process_autozoom({**'dblShift': 10.0,****'dblZoom': 10000000000000000000000000000000000000000000000000000000,**'objectFrom': objectFrom})numpyResult = process_kenburns({'dblSteps': numpy.linspace(0.0, **8.0, 400**).tolist(),'objectFrom': objectFrom,'objectTo': objectTo,'boolInpaint': True})

这将会夸大相机的运动——你会飞过整个场景。就像这个例子:

做一些参数的实验，你会从一个全新的角度体验你的照片。该笔记本提供了许多有用的功能，如串行图像= >视频传输。

链接:

• ArXiv 上单幅图像的 3D 本·伯恩斯效果
• Colab 笔记本(由 Andi Bayo 提供，由 Manuel Romero 改进)

阅读更多:

• 很空间感！来自照片的基于 AI 的视差 3D 视频。
• 重新制作的历史动画
• 超越界限
• 观看我的系列dreams

[## 很有空间感！

3D 本·伯恩斯效应。在人工智能的帮助下赋予照片新的维度。

towardsdatascience.com](/very-spatial-507aa847179d)

9)一阶运动模型

娜芙蒂蒂半身像(来源)结合杰弗瑞·辛顿的演讲(来源)，部分模型库

这是怎么回事:

Aliaksandr Siarohin 等人的一阶运动模型将面部运动从视频片段转换成图像。

要尝试的东西:

选择您的视频素材和源图像！这么多可能性。说句公道话，不要#DeepFake。

链接:

• 项目页面
• GitHub / 纸
• Colab 笔记本

神经语言处理

10，11)GPT 2

这个由 OpenAI 在 2019 年发布的语言模型是在各种来源的 40 GB 文本上训练的。有几个 GPT-2 Colab 笔记本，其工作方式类似:你输入句子的开头，GPT-2 继续(或者你向提供的文本提问)。变压器驱动模式与“自我关注”一起工作，将的注意力放在指定邻近的文本部分，这允许生成连贯的故事，而不是杂乱无章的胡言乱语。

我更喜欢两个 GPT-2 笔记本:

• “训练一个 GPT-2 文本生成模型”作者 Max Woolf
• 带 Javascript 接口的 GPT-2由 gpt2ent

马克斯·伍尔夫的笔记本允许:

• 通过 GPT-2 生成各种文本
• 训练您自己的文本(高达 355m 型号)

我用了三种语言:

1. 英文(关于《爱丽丝梦游仙境》)
2. 德语(关于歌德的《浮士德 I》)
3. 俄语(论普希金的早期诗歌)

Merzmensch 截图

如您所见，它在某种程度上适用于所有语言。当然，GPT-2 是在英语资源上训练的。对于外语，我们应该应用微调和其他资产，但这个概念证明对我来说是有说服力的。有一些有趣的观察:

• 我对《浮士德》的德语训练越多，这些课文就越接近原著。原因可能是在一个小的数据集中(只有一个单一的文本)。如果你想训练你的文本，提供更广泛的数据量。
• 俄语文本不是很容易理解，但是你仍然可以从普希金的诗歌中辨认出风格甚至形式。和新词是完美的，每个文学先锋都会为这样的发明感到自豪。

《带 Javascript 接口的 GPT-2》——笔记本允许:

文字生成，不多不少。但是你可以控制文本长度(这是一个非常相关的因素):

使用温度和 top_k 可以修改文本的随机性、重复性和“怪异性”。

用生成多少可以生成更长的文本(我用的是值 1000)。

链接:

• 关于 GPT2 的第一个 OpenAI 帖子
• GPT-2: 1.5B 发布
• 马克斯·伍尔夫的博客
• 马克斯·伍尔夫的《柯拉布笔记本》
• 带 Javascript 接口的 GPT 2 号

你也可以使用亚当·金的《GPT 2》的网络实现:

• TalkToTransformer.com

我问这个应用关于生命的意义。这个回答非常明智和成熟。

确实很明智！(截图TalkToTransformer.com作者:Merzmensch)

另请阅读:

• 拉克鲁奇！(我的 GPT 三部曲-2)

音乐

12)洋红色:带变形金刚的音乐

AI 也可以写音乐。在基于张量流的洋红色的情况下，它使用变压器，如 GPT-2，具有自我关注，以允许谐波相干和一致的组成。

这是一个用洋红色生成的示例:

Merzmesch 从 Magenta Colab 笔记本上截取的截图

要尝试的东西:

笔记本提供了很多可能性，比如说对于延续，调制，它都允许。wav 和。midi 导出。Magenta 是 GoogleAI 的一个项目。巨大的东西，它甚至包括硬件。

如果你只是想听，这里是洋红色电台:

[## 聆听变形金刚

Music Transformer 是谷歌 Magenta 研究小组的一个开源机器学习模型，可以生成…

magenta.github.io](https://magenta.github.io/listen-to-transformer)

链接:

• Google . ai 出品的洋红色
• Colab 笔记本
• 洋红色-收音机

人工智能的民主化

这就是 Colab 笔记本的使命——为广大读者提供使用 ML/DL 的可能性。让人工智能变得触手可及。提高数字意识和能力。

而这仅仅是艾春天的开始。经过多年的冰雪覆盖。冷冻系统之后。

在这些图书馆中，您可以找到更多笔记本:

[## tugstugi/dl-colab-笔记本

在 Google cola b-tugstugi/dl-cola b-notebooks 上在线尝试深度学习模型

github.com](https://github.com/tugstugi/dl-colab-notebooks) [## MRM 8488/shared _ colab _ 笔记本

存储我创建和共享的 Google 协作笔记本的回购-MRM 8488/shared _ colab _ Notebooks

github.com](https://github.com/mrm8488/shared_colab_notebooks)

让我们实验，探索，创造！

你最喜欢的 Colab 笔记本有哪些？在评论中分享吧！

令初学者惊讶的 12 个数据科学现实

原文：https://towardsdatascience.com/12-data-science-realities-that-surprise-beginners-b06cb6346c9c?source=collection_archive---------51-----------------------

做数据科学工作的白日梦时你应该知道的事情

由 You X Ventures 在 Unsplash 上拍摄的照片

所以你想成为一名数据科学家？闭上眼睛，告诉我你看到自己在做什么。

我真的听不到你说什么，但我会假设它听起来或多或少像这样:“我在我的电脑前用最新最酷的算法做模型。我根据我的前沿模型的结果制作了一个惊人的图表，来帮助我决定我工作的公司的下一步行动。我展示了我的发现，每个人都印象深刻，这改变了我们做生意的方式。”这是我作为一名有抱负的数据科学家时的想法。我从来没有真正停下来思考过那些可能会出现在我面前的恼人的小细节。

从我目前的经历来看，作为一名数据科学家有相当多的……副作用，姑且称之为副作用吧。在这篇文章中，我将告诉你一些数据科学家处理的日常问题/现实，希望能说明工作的现实。

#1: 你可能会收到难以解释的肮脏数据，并且需要找到 5 个不同的人，以不兼容的方式向你解释数据的 5 个不同部分。

在实施一些有用的东西之前，你会做很多将要被丢弃的东西。

#3: 你会在数据清理和特征工程上花费超乎想象的时间。毕竟，这是很多次奇迹发生的地方。

#4: 根据问题的不同，你可能实际上需要使用 excel 或者构建极其简单的产品。从小处着手，逐步构建更复杂的解决方案，这不是懒惰，而是聪明。

当人们向你询问仪表盘或对他们的数据进行想象时，你必须学会避开他们。从好的方面来看，即使在这种类型的任务中没有充分发挥你的潜力很烦人，但有时做一个简单的兼职项目也很有趣。

#6: 你不仅需要知道数据科学，还需要知道如何处理数据。你必须确保遵守合规和 GDPR 规则。

客户会询问他们听到的最新消息(他们在《连线》杂志上读到的闪亮的新算法或新的可解释工具)，即使它与你正在做的项目无关。大多数情况下，解释情况是你的责任。

#8: 你不会真的去开发算法。那些已经为你做好了，包装好了，送来了。这当然有助于了解一切是如何工作的，但你与算法本身的关系可能只包括调整它们的参数。

#9: 你必须解释机器学习/数据科学/人工智能在项目之前、期间和之后能够或不能实现什么。

#10: 接收到一条数据后，你无法躲在你的电脑里。理解问题的领域是数据科学项目最重要的部分之一。你将不得不学习很多关于“收集数据的东西”是如何工作的。

你必须让商业利益相关者相信你的解决方案的价值。即使我们生活在一个对数据和人工智能大肆宣传的世界，仍然需要努力让每个人都参与进来。尤其是当你正在改变公司的做事方式时。

#12: 你还必须让你的业务涉众理解你的解决方案的不确定性。机器学习解决方案不将结果基于物理规则。结果基于数据中的模式。对于习惯于听到“猫”、“狗”或“兔子”而不是“概率为 0.879 的狗”的利益相关者来说，这个事实有时很难理解。

如果你在网上阅读 Quora 关于“成为数据科学家的现实”问题的答案，你可能会从其他人那里看到类似或甚至更糟糕的轶事。然而，这些事实不应该阻止你从事数据科学的职业。

如果你问我，这些小“副作用”是让我保持警觉的东西，让我觉得更有趣。我喜欢数据不是每次都非常干净。清理的过程帮助我更好地理解数据，它帮助我了解了一些我以前没有意识到的事情。我也喜欢研究不同的领域。我的工作性质要求我了解不同的行业，不管我认为自己对某个行业有多不感兴趣，我总能学到令我着迷的东西。

我想让你做的就是了解从数据科学家的职位上可以期待什么。你可能不会从工作的第一天开始就活在梦想中。但是只要你享受你正在做的事情，足以应对这些副作用，你就会没事。

👉对数据科学领域以及如何开始学习感到困惑？ 免费参加数据科学入门迷你课程 ！

掌握 Python 词典的 12 个例子

原文：https://towardsdatascience.com/12-examples-to-master-python-dictionaries-5a8bcd688c6d?source=collection_archive---------7-----------------------

学习词典的综合实用指南

照片由皮斯特亨在 Unsplash 上拍摄

数据结构是任何编程语言的关键部分。为了创建健壮且性能良好的产品，人们必须非常了解数据结构。

在这篇文章中，我们将研究 Python 编程语言的一个重要数据结构，那就是字典。

Dictionary 是一个无序的键值对集合。每个条目都有一个键和值。字典可以被认为是一个有特殊索引的列表。

这些键必须是唯一且不可变的。所以我们可以使用字符串、数字(int 或 float)或元组作为键。值可以是任何类型。

考虑这样一种情况，我们需要存储学生的成绩。我们可以将它们存储在字典或列表中。

(图片由作者提供)

使用字典，我们可以通过提供学生的姓名(答案)来访问每个学生的成绩。另一方面，为了能够访问特定学生的成绩，我们需要一个额外的列表。

新列表包含学生的姓名，并且与成绩列表具有完全相同的顺序。

(图片由作者提供)

因此，对于这种情况，字典比列表更好。

在这个简短的介绍之后，让我们从例子开始深入字典。这些例子将涵盖字典的特性以及对它们进行操作的功能和方法。

1.创建字典

我们可以通过在花括号之间提供 0 个或更多的键值对来创建一个字典。

empty_dict = {}grades = {'John':'A', 'Emily':'A+', 'Betty':'B', 'Mike':'C', 'Ashley':'A'}grades
{'Ashley': 'A', 'Betty': 'B', 'Emily': 'A+', 'John': 'A', 'Mike': 'C'}

2.访问值

我们通过提供索引来访问列表中的值。类似地，在字典中，通过使用键来访问值。

grades['John']
'A'grades.get('Betty')
'B'

3.所有值和/或所有键

keys 方法用于获取所有的密钥。

grades.keys()dict_keys(['John', 'Emily', 'Betty', 'Mike', 'Ashley'])

返回对象是一个可迭代的 dict_keys 对象。因此，我们可以在 for 循环中迭代它。

同样，values 方法返回所有值。

grades.values()dict_values(['A', 'A+', 'B', 'C', 'A'])

我们不能对 dict_keys 或 dict_values 进行索引，但是我们可以将它们转换成一个列表，然后使用索引。

list(grades.values())[0]
'A'

items 方法返回元组中的键值对。

grades.items()dict_items([('John', 'A'), ('Emily', 'A+'), ('Betty', 'B'), ('Mike', 'C'), ('Ashley', 'A')])

4.更新或添加项目

字典是可变的，所以我们可以更新、添加或删除条目。更新或添加项目的语法是相同的。如果字典中存在给定的键，则更新现有项的值。否则，将创建一个新项目(即键值对)。

grades['Edward'] = 'B+'
grades['John'] = 'B'grades
{'Ashley': 'A',
 'Betty': 'B',
 'Edward': 'B+',
 'Emily': 'A+',
 'John': 'B',
 'Mike': 'C'}

5.用新字典更新

我们还可以将字典传递给更新函数。该词典将根据新词典中的项目进行更新。用一个例子会更清楚。

考虑以下年级和年级 _ 新词典:

grades = {'John':'A', 'Emily':'A+', 'Betty':'B', 'Mike':'C'}
grades_new = {'John':'B', 'Sam':'A', 'Betty':'A'}

如果我们基于 grades_new 更新成绩，John 和 Betty 的值也将被更新。此外，一个新的项目('山姆':' A ')将被添加。

grades.update(grades_new)grades
{'Betty': 'A', 'Emily': 'A+', 'John': 'B', 'Mike': 'C', 'Sam': 'A'}

6.删除项目

我们可以使用 del 或 pop 函数来删除一个项目。我们只是传递要删除的条目的键。

del(grades['Edward'])grades.pop('Ashley')
'A'grades
'Betty': 'B', 'Emily': 'A+', 'John': 'B', 'Mike': 'C'}

与 del 函数不同，pop 函数返回被删除项的值。因此，我们可以选择将它赋给一个变量。

7.可重复的字典

我们可以迭代字典。默认情况下，迭代是基于键的。

for i in grades:
    print(i)John
Emily
Betty
Mike

我们还可以迭代值(grades.values())或键值对(grades.items())。

8.词典理解

它类似于列表理解。词典理解是一种基于可重复项创建词典的方法。

{x: x**2 for x in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}{word: len(word) for word in ['data','science','is','awesome']}
{'awesome': 7, 'data': 4, 'is': 2, 'science': 7}

iterable 中的元素成为字典的键。这些值是基于字典理解中的赋值来确定的。

9.从列表列表中创建字典

我们可以使用列表或元组列表来创建字典。

a = [['A',4], ['B',5], ['C',11]]dict(a)
{'A': 4, 'B': 5, 'C': 11}b = [('A',4), ('B',5), ('C',11)]dict(b)
{'A': 4, 'B': 5, 'C': 11}

10.从字典到数据框架

Pandas 的 dataframe 函数可用于使用字典创建数据帧。键成为列名，值成为行。

到目前为止，我们已经用值是字符串的字典做了例子。然而，字典中的值可以是任何类型，比如列表、numpy 数组、其他字典等等。

在从字典创建数据帧的情况下，值由数组组成(例如 list、numpy 数组)。

import numpy as np
import pandas as pddict_a = {'names':['Amber','John','Edward','Emily'],
         'points':np.random.randint(100, size=4)}df = pd.DataFrame(dict_a)
df

11.清澈透亮

len 函数返回字典中条目的数量(即长度)。clear 方法用于删除字典中的所有条目，因此我们将得到一个空字典。

len(grades)
4grades.clear()len(grades)
0

12.抄写字典

grades = {'John':'A', 'Emily':'A+', 'Betty':'B'}dict1 = gradesdict2 = grades.copy()dict3 = dict(grades)

所有 dict1、dict2 和 dict3 都包含与 grades 完全相同的键值对。然而，dict1 只是一个指向等级中的键值对的指针。因此，成绩的任何变化也会改变字典 1。

Dict2 和 dict3 在内存中是独立的对象，因此它们不会受到成绩变化的影响。

创建于 pythontutor (图片由作者提供)

我们需要特别注意如何抄写字典。

额外收获:使用 Python 3.9 合并和更新操作符

Python 3.9 为字典提供了 merge(“|”)和 update(“| =”)操作符。我还没有安装 Python 3.9，所以我将使用来自 python 文档的例子:

>>> x = {"key1": "value1 from x", "key2": "value2 from x"}
>>> y = {"key2": "value2 from y", "key3": "value3 from y"}
>>> x | y
{'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}
>>> y | x
{'key2': 'value2 from x', 'key3': 'value3 from y', 'key1': 'value1 from x'}

字典是 Python 中非常重要的数据结构，在很多情况下都会用到。我们在这篇文章中所举的例子将涵盖你需要了解的关于字典的大部分内容。它们会让你在使用字典时感到舒适。

然而，当然还有更多。就像任何其他科目一样，熟能生巧，你会在不断练习中掌握。

感谢您的阅读。如果您有任何反馈，请告诉我。

仪表板的 12 条不太明显的规则

原文：https://towardsdatascience.com/12-less-obvious-rules-for-your-dashboard-4d7c35a1cee9?source=collection_archive---------33-----------------------

开始可视化之旅时的常见陷阱

挪威厄斯峡湾。作者照片。

既然您已经找到了这里的方法，那么您可能是一名试图理解您的数据以传递信息的分析师，或者是一名试图帮助分析师实现这一目标的设计师/开发人员。我主要在后一个联盟中工作，所以我日常工作的一部分包括让商业用户能够通过数据自助服务他们的决策过程。在这里，我将分享一些对业务分析师有用的精选技巧(我在许多项目中反复看到这些东西)。开发者社区应该也非常好。不过，DataViz 的人在这里可能看不到太多新东西。

你可能已经读过关于数据可视化的最重要和最通用的建议，比如:一个观众、一个目的、一个故事、区域和一个流程。我们将在这里跳过它。如果你想冒险，请查阅一些组织良好的快速阅读材料来开始你的冒险之旅:

仪表盘设计的 10 条法则
如何设计和打造一个伟大的仪表盘

所以。你已经得到了数据，你理解了它你准备好上场了。让我们记住几个核心思想:

• 可视化是关于形状的。数字对人脑来说是不自然的。我们生来就没有数字、数字和数学的概念。然而，我们有一个预先训练好的神经网络来进行形状识别。
• 少即是多。如果你能用更少的形状和顶点来展示一些东西，那就去做吧。视觉障碍减缓了感知。最重要的是，有些模式会触发你的潜意识背景威胁分析，应该避免。

条形图和折线图

1.簇状条形图最擅长创造一种令人不安的斑马效果。使用条形图+折线图或折线图/面积图，可以用较少的形状和顶点来传达相同的信息。

聚类图(左上角)具有最高的视觉复杂度(形状和顶点的数量)。面积图(右下角)的视觉复杂度最低。

2.永远不要用堆积图来表示不能自然总结的事物。

典型的错误是将“总计”(即收入)或“小计”包括在你累加的东西中。第二个最常见的错误——累加平均值(平均值不能相加！).

3.避免自然总结的事物的未堆叠图表(除非你知道你在做什么)

除非你想比较上例中城市之间的数字，否则你应该累加。即使你想比较城市之间的数据，那也是骗人的，因为一个城市市场份额的减少并不意味着这个城市的表现不好。只能说明另一个城市表现更好。

4.避免长尾条形图(以及随之而来的未使用的空白空间)。使用树形图或“Top N 条形图可能会更好。

长尾不仅带来大量的空白空间；它们还造成了一种错误的印象，即前 10 根棒线很重要(而在上面的例子中，它们总共只占总量的 12%，88%的交易量来自小棒线)。

好了，今天的条形图已经足够了；让我们继续我们的下一个最爱…

饼图

让我们重复一下:饼图的分析值(您无法直观地感知“这个切片”比“那个切片”大多少，因此您最终会检查每个有问题的切片的数字，并手动计算)。

除了其他问题，香草饼图往往有尖锐的边缘靠近中心。圆环图看起来更轻，内部有一个数字空间。

5.这伴随着一个“但是”:作为哺乳动物，我们在出生时就锁定了圆形，所以当我们看到圆形时，它自然会吸引我们。使用甜甜圈图来美化事物，并把注意力吸引到最重要的数字上。我们不想要一个全条形图的无聊仪表盘，对吧？

轴线

6.条形图更适合于分类轴。对于时间线，折线图效果更好。

然而，这不是一个规则。如果你打算用时间作为交叉过滤器，条形图会更有意义(因为条形图更容易点击)。反之亦然，如果你的条形图有太多的条，你可以通过切换到面积图来释放视觉压力。

7.如果您必须有多个时间线图表，请将它们叠放在一起，使它们的轴对齐。

也尽量有相同的时间框架。

8.确实有秤。它们可以让您避免在每个数据点显示太多值的混乱。

你的观众可能以前看过图表。有些人见过很多。他们的大脑被训练通过在特定的地方寻找特定的元素来阅读图表。缺少轴线会破坏这种阅读过程，引起烦恼。

颜色；色彩；色调

9.简单。图表中的相同事物使用相同的颜色。

你也可以用浅色表示计划(没有发生的事情)，纯色表示事实(发生的事情)。

过滤

10.如今，大多数工具都带有可折叠的过滤板。使用它，而不是消耗仪表板的宝贵空间。

我们都不喜欢躲不开的讨厌广告。那么为什么我们喜欢全屏消费内容时无法隐藏的切片器呢？

文本、数字和表格

11.理想情况下，这些不应该太多。如果已经在其他地方显示了页面标题或数据日期，则不需要在报告中重复它(除非您试图创建一个可打印的报告，在这种情况下:为什么呢？).

可视化应该是不言自明的。如果没有，可能即使是文本也无济于事。

12.真的需要那么多裸号吗？都是关于形状的，记得吗？

如果数字在图表中非常明显，就没有必要把它复制成文本。在多个地方显示相同的数字会使人困惑并浪费空间。

额外收获:统计技巧

与简单平均值不同，中位数可以抵抗异常值和偏态。

在真实的数据中，你会不时地遇到偏差很大的值，它们会极大地影响平均值。这就是为什么我们使用中值收入/价格/持续时间，而不是平均值。

分布形状告诉你的不仅仅是简单的平均值/最小值/最大值。看起来也很花哨。

在你的生活中，比你想象的更多的时候，你会对非一般事物感兴趣。

对数标度适用于指数。如果你需要操纵你的观众做些什么，他们也是一个很好的工具。

“我们的销售额在 4 月份有所下降，但我们预计会很快恢复，现在完全不会打包我们的东西”。很酷很正常！

你猜对了。请不要这样做。

还有…奖金奖金！从这个故事开始，还有更多吸引人的角色:

干杯！

12 种主要的退出方法:DNNs、CNN 和 RNNs 的数学和视觉解释

原文：https://towardsdatascience.com/12-main-dropout-methods-mathematical-and-visual-explanation-58cdc2112293?source=collection_archive---------12-----------------------

深入研究用于正则化、蒙特卡罗不确定性和模型压缩的 DNNs、CNN 和 RNNs 丢弃方法

动机

在(深度)机器学习中训练模型的重大挑战之一就是协同改编。这意味着神经元非常依赖彼此。它们在很大程度上相互影响，并且在输入方面不够独立。同样常见的情况是，一些神经元具有比其他神经元更显著的预测能力。换句话说，我们的输出过度依赖于一个神经元。

这些影响必须避免并且重量必须分配给以防止过度配合。一些神经元的共同适应性和高预测能力可以用不同的正则化方法来调节。最常用的一种是辍学。然而，辍学方法的全部能力很少被使用。

根据是 DNN ，还是 CNN 还是 RNN ，可以采用不同的退出方式。实际操作中，我们只用一个(或者差不多)。我认为这是一个可怕的陷阱。所以在这篇文章中，我们将从数学上和视觉上深入到辍学者的世界中去理解:

• 标准辍学方法
• 标准辍学的变体
• 应用于 CNN 的退出方法
• 应用于 RNNs 的退出方法
• 其他压差应用(蒙特卡罗和压缩)

(不好意思停不下来，所以是 12 法多一点…😄)

记号

标准辍学

最广为人知和使用的退出方法是 Hinton 等人在 2012 年推出的标准退出【1】..通常简称为“辍学”，出于显而易见的原因，在本文中我们将称之为标准辍学。

p=0.5 时的辍学

为了防止过拟合在训练阶段，神经元被随机省略。在密集(或全连接)网络中引入，对于每一层我们给出了丢失的概率p。在每次迭代中，每个神经元都有被忽略的概率p。Hinton 等人的论文推荐了输入层上的丢失概率p=0.2和隐藏层上的概率p=0.5。显然，我们对输出层感兴趣，这是我们的预测。因此，我们不在输出层应用辍学。

在数学上，我们说每个神经元的遗漏概率遵循一个伯努利概率分布p。因此，我们在神经元(层)的向量与掩码之间进行元素方式的乘法，其中每个元素都是遵循伯努利分布的随机变量。

在测试(或推断)阶段，没有没有脱落。所有的神经元都是活跃的。为了补偿与训练阶段相比的额外信息，我们根据出现的概率进行加权。所以一个神经元不被忽略的概率。是1-p。

下拉连接

也许你已经熟悉了标准的辍学方法。但是有很多变化。要调整密集网络的前向传递，您可以对神经元应用下降。L. Wan 等人介绍的drop connect【2】不是而是直接在神经元上施加压降，而是在连接这些神经元的权重和偏置上施加压降。

p=0.5 时的辍学

因此，我们发现了与标准辍学方法相同的机制。除了掩模(其元素是遵循分布的随机变量)不是应用于神经元 向量 而是应用于将该层连接到前一层的权重矩阵。

对于测试阶段，可以使用与标准退出方法相同的逻辑。我们可以乘以出现的概率。但这不是 L. Wan 等人提出的方法。这很有趣，因为他们提出了一种即使在测试阶段也能通过应用 DropConnect 的高斯近似来处理 dropout】的随机方法。然后通过从该高斯表示中随机抽取样本。我们将在突出部分之后回到高斯近似。

杰出的人

L. J. Ba 和 B. Frey 介绍的脱颖而出【3】作为一种标准的脱颖而出方法，是基于一个伯努利面具(我会根据这些面具所遵循的分布来称呼它们，这样会更简单)。不同之处在于，在层上，省略神经元的概率p是而不是常数。根据重量的值自适应。

这可以用于任何g激活函数，甚至可以是一个单独的神经网络。同样，对于Ws，它可以是W的函数。然后对于测试阶段，我们通过出现的概率来平衡。

例子

有点晦涩，举个例子吧。在他们的论文中，他们表明在实践中信任网络权重可以近似为权重的仿射函数。又比如我会把乙状结肠的绝对值作为激活函数。

与突出示例相比，p=0.5 时的标准压差

因此，我们可以看到权重越大，神经元被忽略的概率就越大。这有力地限制了某些神经元可能具有的高预测能力。

高斯漏失

应用于神经网络的退出方法的列表继续增长。因此，在继续讨论 DNNs 之外的其他内容之前，我想谈谈一类辍学方法，这无疑是最令人着迷的。

仅举几个例子，快速辍学【4】，变化辍学【5】或具体辍学【6】是从贝叶斯角度解释辍学的方法。具体地说，我们有一个掩码，其元素是遵循高斯分布 ( 正态分布)的随机变量，而不是伯努利掩码。这里不赘述大数定律的论证，那不是重点。所以我们试着直观的理解一下这个。****

p=0.5 时的辍学

论文[4]、[5]和[6]表明我们可以用正态定律 T20 为我们的辍学者模拟 T17 伯努利面具 T18。但这有什么区别。万物与虚无同时存在。由于共同适应和/或我们神经元的预测能力，它不会改变任何关于这些方法与过度拟合的相关性的事情。但是与之前介绍的方法相比，它改变了训练阶段所需的执行时间。****

从逻辑上讲，通过在每次迭代中省略掉丢失的神经元，那些在迭代中被省略的神经元在反向传播期间不被更新。他们不存在。所以训练阶段是放慢了。另一方面，通过使用高斯丢弃方法，所有神经元在每次迭代和每个训练样本中暴露。这样就避免了减速。

在数学上，存在与高斯掩码的乘法(例如以 1 为中心，具有伯努利定律标准偏差p(1-p))。这个通过在每次迭代中保持所有神经元活动来随机加权它们的预测能力来模拟退出。这种方法的另一个实际优势集中在 1:在测试阶段，与没有脱落的模型相比，不需要进行修改。

集体辍学

本文的“难”理解部分结束了。保留更多的直观的部分给我们更好的性能。

****图像或特征图的问题是像素非常依赖于它们的邻居。简而言之，在一张猫的图片上，如果你取一个对应于它皮毛的像素，那么所有相邻的像素都将对应于同一皮毛。几乎没有或者没有区别。

所以我们理解标准辍学方法的极限。我们甚至可以说它是低效的，它带来的唯一改变是额外的计算时间。如果我们随机忽略图像上的像素，那么几乎没有信息被删除。省略的像素与其周围的像素几乎相同。表示性能差防止过拟合。

为什么不利用适当的并且经常在CNN中使用的层。例如最大池层。对于那些不知道的人:最大池层是一张图片上传递的过滤器或(特征图)选择重叠区域的最大激活。

Max-Pooling Dropout【7】是 H. Wu 和 X. Gu 提出的一种应用于细胞神经网络的退出方法。在执行池化操作之前，它将伯努利遮罩直接应用于最大池化层内核。直觉上，这使得高活化剂的聚集最小化。限制某些神经元沉重的预测能力是一个非常好的观点。在测试阶段，您可以像前面的方法一样，根据出现的概率进行加权。

最大池层已被作为一个例子，但同样可以用其他池层来完成。例如，对于平均池层，我们可以在培训阶段以同样的方式应用退出。然后在测试阶段，将不会有变化，因为它已经是一个加权平均。

空间缺失

对于 CNN，我们可以利用池层。但是，我们也可以通过遵循 J. Tompson 等人提出的空间丢失【8】方法来变得更聪明。他们建议克服经典丢失方法的问题，因为相邻像素与高度相关。

我们可以考虑对每个特征映射应用一个丢弃，而不是随机地对像素应用一个丢弃。如果我们以我们的猫为例，那么这就像从图像中移除红色，并迫使它对图像的蓝色和绿色进行概括。然后，在下一次迭代中随机丢弃其他特征图。

我不知道如何恰当地用数学来表达，使它变得易懂。但是如果你理解了前面的方法，你就不会有任何问题了。在训练阶段，按照具有遗漏概率p的特征图应用伯努利掩码。然后，在测试阶段，没有丢失，而是通过出现概率1-p对进行加权。

断流器

让我们深入我们的方法，以克服相邻像素高度相关的事实。代替对每个特征图应用伯努利掩模，它们可以在区域中应用。这就是 T. DeVries 和 G. W. Taylor 提出的剪切方法【9】。****

通过最后一次以我们的猫图像为例:这种方法可以通过隐藏图像的区域来进行归纳，从而限制过度拟合。我们最终得到猫的头垂下的图像。这迫使 CNN 去识别描述一只猫的不太明显的属性。

这一节也没有数学。这种方法在很大程度上取决于我们的想象力:正方形区域、长方形、圆形、所有的特征地图、一次一个或者可能几个……这由你决定。😃

最大落差

最后，在结束关于 CNN 的这一节之前，我必须指出，显然可以将几种方法结合起来。当我们知道不同的方法时，这就是让我们强大的原因:我们可以同时利用它们的好处。这就是 S. Park 和 N. Kwak 提出的他们的最大落差方法【10】。

这种方法在某种程度上是池丢失和高斯丢失的混合。在最大池层上执行退出，但是使用贝叶斯方法。

在他们的论文中，他们展示了这种方法给出的结果与一样有效与空间丢失一样。此外，在每次迭代中，所有神经元都保持激活，这限制了训练阶段的减速。
这些结果是在= 0.02 和σ = 0.05 时获得的。

RNNDrop

****

嗯，我们已经看到了 DNNs 和 CNN 的一些退出方法。该研究还试图找出哪些方法对循环神经网络 (RNNs)有效。他们通常依赖于 LSTMs，所以我将采用 RNNs 的这种特殊情况。它将推广到其他 rnn。

问题很简单:对 RNN 申请退学是危险的。从这个意义上来说，RNN 的目的是保持对事件的长期记忆。但是传统的辍学方法效率不高，因为它们会产生噪音，阻止这些模型保持长期记忆。将要介绍的方法允许长期保存这种记忆。

****

T. Moon 等人提出的RNNDrop【11】是最简单的方法。一个伯努利掩码仅应用于隐藏的单元状态。但是这个屏蔽从序列到另一个保持相同。这被称为丢失的每序列采样。这仅仅意味着在每次迭代中，我们创建一个随机掩码。然后从一个序列到另一个序列，该屏蔽保持不变。因此被丢弃的元素保持被丢弃，而当前的元素保持存在。所有的序列都是这样。****

经常辍学

****

S. Semeniuta 等人提出的复发性辍学【12】是一个有趣的变体。单元状态保持不变。下降仅适用于更新单元状态的部分。所以在每次迭代中，伯努利掩模使得一些元素不再对长期记忆有贡献。但是内存没有改变。****

变化的 RNN 辍学

****

最后，Y. Gal 和 Z. Ghahramani 介绍的 RNN 丢弃【13】是在内部门之前应用基于序列的丢弃。这导致 LSTM 的不同点上的信号丢失。

打开我们的思维

仍然有许多不同的辍学方法，但是我们将在这里停止这篇文章。完成它，我发现知道辍学方法不仅仅是正规化方法非常有趣。

蒙特卡洛辍学

退出方法还可以提供模型不确定性的指标。让我解释一下。对于相同的输入，经历退出的模型将在每次迭代中拥有不同的架构。这导致输出中的差异。如果网络相当一般化并且如果共同适应受限，则预测分布在整个模型中。这导致在具有相同输入的每次迭代中输出的较低的方差。研究这个方差可以给出分配给模型的置信度的概念。这可以从 Y. Gal 和 Z. Ghahramani 的方法中看出[14]。

模型压缩

最后直观的，通过随机应用漏失，我们可以看到给定神经元甚至层的效率或无效率进行预测。根据这一观察，我们可以通过减少参数数量来压缩模型，同时将性能下降最小化。K. Neklyudov 等人[15]已经提出了这样一种方法，该方法使用变分丢失来修剪 DNNs 和 CNN。

知识就是分享。
支持我，一键获得访问 中我所有文章的。****

来源和参考

[1] G. E. Hinton，N. Srivastava，A. Krizhevsky，I. Sutskever 和 R. R. Salakhutdinov，通过防止特征检测器的共同适应来改进神经网络****

[2] L. Wan，m .，S. Zhang，Y. LeCun 和 R. Fergus，使用 dropconnect 调整神经网络****

[3] L. J. Ba 和 B. Frey，用于训练深度神经网络的自适应退出****

[4] S .王和 c .曼宁，快速辍学训练****

[5] D. P .金玛、t .萨利曼斯和 m .韦林，变分退出和局部重新参数化技巧****

[6] Y. Gal，J. Hron，A. Kendall，混凝土脱落****

[7] H. Wu 和 X. Gu，卷积神经网络的丢失训练****

[8] J. Tompson、R. Goroshin、A. Jain、Y. LeCun 和 C. Bregler，使用卷积网络的有效目标定位****

[9] T. DeVries 和 G. W. Taylor，改进了截断卷积神经网络的正则化****

[10] S. Park 和 N. Kwak，卷积神经网络中的丢包效应分析****

[11] T. Moon，H. Choi，H. Lee 和 I. Song， Rnndrop

[12]s . semen uita，A. Severyn 和 E. Barth，无记忆丧失的经常性辍学****

[13] Y. Gal 和 Z. Ghahramani，递归神经网络中辍学的理论基础应用****

[14] Y. Gal 和 Z. Ghahramani，辍学作为贝叶斯近似:表示深度学习中的模型不确定性****

[15] K. Neklyudov、D. Molchanov、A. Ashukha 和 D. P. Vetrov，通过对数正态乘法噪声进行结构化贝叶斯修剪****

[16] A. Labach，H. Salehinejad，深度神经网络退出方法调查****

所有图片和 gif 都是自制的，可以免费使用