TowardsDataScience 博客中文翻译 2019（三十）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

使用(Python/Numpy/tensor flow/py torch)和(Matplotlib/Plotly)生成和绘制 3D 高斯分布的教程。

原文：https://towardsdatascience.com/a-python-tutorial-on-generating-and-plotting-a-3d-guassian-distribution-8c6ec6c41d03?source=collection_archive---------1-----------------------

问题陈述:

每当提到绘制高斯分布图时，通常都是关于单变量正态分布，这基本上是一种 2D 高斯分布方法，它从 X 轴上的范围数组中采样，然后对其应用高斯函数，并产生绘图的 Y 轴坐标。

然而，在 3D 高斯分布的情况下，采样发生在 X 轴和 Y 轴上，并且坐标投影在 Z 轴上。这种情况在教程中很少提到，虽然在很多情况下非常有用。

解决方案概述:

要在两个轴上采样:X 轴和 Y 轴，您需要对 X 轴上的每个样本进行所有 Y 轴采样。

两个轴上的完整采样将产生范围，一个在 X 轴上，一个在 Y 轴上。

完成后，您需要在 Z 轴上生成一个域，这可以通过计算(X，Y)样本的距离来完成。

然后，可以通过高斯函数运行 Z 域，以产生 Z 轴上的高斯范围。

然后可以构建一个 3D 绘图仪来利用所有三个范围来产生 3D 表面。

数学分解:

• X 范围需要是大小为的 2D 矩阵:

• X 中间范围是从“-域”到“+域”的行空间(1D 范围数组)，每一步的大小为“方差”，该 1D 数组中元素的数量应为:

• X 范围是堆叠 X 中间范围的副本的结果，副本数应为:

• Y 范围是 X 范围矩阵的转置。

• Z 域是 X 和 Y 之间的距离:

• Z 范围是对距离矩阵(Z 域)应用高斯函数的结果:

代码实现:

用纯 Python 制作的二元正态(高斯)分布生成器

• X 范围的构造没有使用 numpy 函数。
• Y 范围是 X 范围矩阵(ndarray)的转置。
• 最终得到的 X 范围、Y 范围和 Z 范围用 numpy 数组封装，以便与绘图仪兼容。

用 Numpy 制作的二元正态(高斯)分布生成器

• X 中间范围由 numpy 使用“arange”函数构建。
• Y 中间范围由 numpy 使用“arange”函数构建。
• X，Y 范围是用 numpy 的“meshgrid”函数构建的。

用 Tensorflow 制作的二元正态(高斯)分布生成器

• X 中间范围由 tensorflow 使用“range”函数构建。
• Y 中间范围由 tensorflow 使用“range”函数构建。
• X，Y 范围是使用 tensorflow 的“meshgrid”函数构建的。

用 PyTorch 制作的二元正态(高斯)分布生成器

• X 中级范围由 torch 使用“arange”功能构建。
• Y 中间范围由 torch 使用“arange”功能构建。
• X，Y 范围是用 torch 的“meshgrid”函数构建的。

用 Matplotlib 绘制二元法线绘图仪

带 Plotly 的二元普通绘图仪(版本 4.0.0)

用 Matplotlib 绘制 Python 生成的二元正态分布

plt_plot_bivariate_normal_pdf(*py_bivariate_normal_pdf(6, 4, .25))

用 Matplotlib 绘制 Numpy 生成的二元正态分布

plt_plot_bivariate_normal_pdf(*np_bivariate_normal_pdf(6, 4, .25))

用 Matplotlib 绘制张量流生成的二元正态分布

plt_plot_bivariate_normal_pdf(*tf_bivariate_normal_pdf(6, 4, .25))

用 Matplotlib 绘制 PyTorch 生成的二元正态分布

plt_plot_bivariate_normal_pdf(*torch_bivariate_normal_pdf(6, 4, .25))

用 Plotly 绘制 Python 生成的二元正态分布

plotly_plot_bivariate_normal_pdf(*py_bivariate_normal_pdf(6, 4, .25))

用 Plotly 绘制二元正态分布图

plotly_plot_bivariate_normal_pdf(*np_bivariate_normal_pdf(6, 4, .25))

用 Plotly 绘制张量流生成的二元正态分布

plotly_plot_bivariate_normal_pdf(*tf_bivariate_normal_pdf(6, 4, .25))

用 Plotly 绘制 PyTorch 生成的二元正态分布

plotly_plot_bivariate_normal_pdf(*torch_bivariate_normal_pdf(6, 4, .25))

读者请注意:

请随时提供反馈，毕竟这些教程背后的原因是为了交流知识，并在出现错误时纠正课程。

Python 的 Plotly 可视化快速指南

原文：https://towardsdatascience.com/a-quick-and-dirty-guide-to-visualization-in-plotly-for-python-6f79f2d06f2?source=collection_archive---------24-----------------------

在几分钟内开始制作美丽的情节

在 Python 中有无数的选项来创建情节，但是我已经开始倾向于使用的一个库是 Plotly。在 Jupyter 工作流程中，这是一个很好的选择，可以很容易地创建漂亮和可展示的情节。它有大量可定制的图供您用于可视化(整个选择可以在这里看到)。

好吧，让我们深入到情节。Plotly 有两种风格，一种是 Plotly Express，另一种是 Graph Objects。

Plotly Express 可以被认为是制作剧情的更快捷的方式。它可以在您工作时用于可视化。使用 Plotly Express 的好处是通常只有很少的代码，但是您可以进行的绘图定制量也是有限的(与 Graph 对象相比，但与典型的图形库相当)。我个人不使用 Plotly Express，所以我不打算在这里介绍它，但是您可以在文档中阅读它，一旦您掌握了图形对象，它应该很容易使用。这是因为我更喜欢使用 Matplotlib 和 Seaborn 进行一般的可视化，因为它们与 Pandas 等流行的库集成得更紧密。当我需要制作非常像样的情节时，我会求助于 Plotly。下面是 Plotly Express 中的一个示例绘图和绘图代码。它直接来自文档。确保您已经安装了 Plotly。你可以在这里找到如何根据你的特定设备和环境做到这一点的细节。

**import** **plotly.express** **as** **px**
df = px.data.tips()
fig = px.histogram(df, x="total_bill")
fig.show()

现在，关于图形对象。使用这种方法的缺点是您通常需要编写更多的代码来创建这些图，但是优点是它们非常美观并且非常可定制。此外，您不必像在 Matplotlib 中那样处理重叠文本和缩放问题。对于我的用例来说，更多的代码行通常不是问题，我的用例是绘制出之前创建的图的最终版本。

下面是 Matplotlib 中的一个简单情节，使用了从票房魔咒中获得的一些电影数据。

import matplotlib.pyplot as plt
plt.bar(top_genres, top_total);

正如您所看到的，如果我们不做一些额外的工作，它不会自动缩放轴以使其看起来更像样。下面是使用 Plotly 的相同情节。

plot_top_genres_total = go.Figure()
plot_top_genres_total = go.Figure([go.Bar(x=top_genres,
                                          y=top_total)])
plot_top_genres_total.show()

如您所见，开箱后更加干净。你不需要花太多的时间去让东西变得可读。

现在，说到我之前承诺的那部分。您可能需要保存这个片段。

这是一个复杂绘图的代码，有多个轴、多个图表、颜色选项、图例和轴标题。你可以添加、删除或更改部分代码来修改情节。

plot_name = make_subplots(specs= [[{“secondary_y”: True}]])# For a single axis plot use the following line instead
# plot_name = go.Figure() plot_name.add_trace(go.Bar(x=x_data,
                           y=y_data_1, 
                           name = ‘Plot 1 Name’, 
                           marker_color=  ’#bfa878'))plot_name.add_trace(go.Scatter(x=x_data, 
                               y=y_data_2, 
                               name = ‘Plot 2 Name’, 
                               marker_color= ’#7a4b4b’), 
                               secondary_y = True)plot_name.update_layout(yaxis_title = ”Y Axis Label”, 
                        showlegend = False,
                        template = ”ggplot2", font = dict(family= ”Calibri”,
                                    size = 24,
                                    color = ’#7a4b4b’))plot_name.update_yaxes(title_text = ”Secondary Y Axis Label”,
                       secondary_y = True)plot_name.show()

例如，要更改绘图类型，您可以将“条形图”和“散点图”关键字更改为“直方图”或“饼图”。打开文档，看看还有什么可用的。

要改变绘图颜色，只需在谷歌上搜索“颜色选择器”。然后，您可以选择您的颜色，并获得十六进制代码的 RGB 值，以替换上面的代码。

您可以通过删除第二个 add_trace 代码行和 update_yaxes 代码行来删除辅助绘图。

可以通过修改 update_layout 下的细节来更改字体、字体大小和字体颜色。

确保所有的 x 和 y 数据都在列表中。我发现在绘图中使用数据之前将数据处理成列表有助于避免错误。此外，在粘贴环境后，您可能需要修复环境中的缩进，这样代码才能工作。

下面是一个使用上面的代码和上面使用的相同数据创建的图的示例。

上面的代码可以满足您 90%的可视化需求(根据您所做的工作，可能多一点或少一点)。在你画了一些图之后，你应该熟悉 Plotly 的代码结构。你会感觉到要改变什么来超越这个情节的限制。

对于后 10%来说，一个好的方法是尝试浏览文档来寻找你想要的情节，而不是复制他们的代码，尝试将它集成到上面的代码中。尝试改变事物，了解事物是如何融合在一起的。这样做，你将开始逐步开发你自己的模块化系统来创建可视化，并节省宝贵的时间。

我希望这些信息可以帮助你在几分钟内开始使用 Plotly，并为你提供一个框架，随着你的需求变得越来越苛刻，你可以学习更多。祝你好运！

回声评论文本分类的自然语言处理快速探索

原文：https://towardsdatascience.com/a-quick-exploration-of-nlp-for-text-classification-on-echo-reviews-6b65a9e2cc9e?source=collection_archive---------22-----------------------

简单几步的情感分析

Alexa，把你的评论分类。

自然语言处理(NLP)是以计算机可以“解释”的方式处理语言数据的领域/科学。Siri、Alexa、Google 等工具和服务。使用这些技术通过语言输入与人类互动，并解释文本数据。机器使用数字信息，这与语言学有本质的不同；因此，这项任务并不容易，需要创造性和复杂的解决方案。

在本文中，我们将使用 NLP 来预测用户对产品的评级，在本例中，是基于评论文本的 Amazon Echo Dot。这个例子需要对情感和极性以及数字分类输出等概念有一些低级的理解。让我们开始吧！

数据和预处理

第一步是打开一个 Google Colab python 笔记本，我们将使用这个环境来处理和可视化数据，构建模型，并做出最终预测。

本文的数据由 Kaggle 在以下位置提供:https://www.kaggle.com/sid321axn/amazon-alexa-reviews

数据由以下字段组成:评级、日期、变化和审阅文本。

第一步是将这些数据导入我们的 Python 笔记本。要做到这一点，你需要一个 Kaggle 的账户，它是免费的，你可以用谷歌证书注册。

首先，我们需要安装允许我们与 Kaggle API 交互的包。

!pip install kaggle

现在，我们需要上传我们的 Kaggle 凭证。这是一个. json 文件，可以从 Kaggle 下载，有很多这方面的教程。只需执行下面几行代码并上传 kaggle.json 文件。

from google.colab import files
files.upload()

我们需要将刚刚上传的文件放入正确的目录中，以符合 API 协议。

!mkdir -p ~/.kaggle
!cp kaggle.json ~/.kaggle/
!chmod 600 ~/.kaggle/kaggle.json

现在我们准备下载数据。只需进入 Kaggle 页面，将链接复制到数据，或者复制下面的行。

!kaggle datasets download -d sid321axn/amazon-alexa-reviews

解压缩文件:

!unzip amazon-alexa-reviews.zip

现在我们将数据导入到熊猫数据框架中；但是首先，我们需要进口熊猫。

import pandas as pd
df = pd.read_table('amazon_alexa.tsv')
df.head()

数据帧中的一列包含代表用户正在查看的回声变化的分类值。给定有限数量的类别，对模型使用一次性编码来理解这个变量将是最有效的。一键编码为每个可能的类别创建一列，并根据相应的行是否包含相应的类别值给出 1 或 0。如果您只想专注于文本分析，请随意从输入变量中排除“variation”列！

df1 = df[['variation']]
df2 = df.drop(['variation'], axis = 1)
df1 = pd.get_dummies(df1)
df = pd.concat([df1,df2], axis = 1)
df.head()

需要处理的下一列是日期；在这种情况下，它以 dd-MMM-yy(例如 2018 年 7 月 31 日)。只接受数字输入的模型将无法解释这些信息。

解决方案是将字符串分解成独立的日、月和年的数字表示，然后将它们放在各自的列中。原始日期列也将被删除。

#df['Year'] = pd.DatetimeIndex(df['date']).year
df['Month'] = pd.DatetimeIndex(df['date']).month
df['Day'] = pd.DatetimeIndex(df['date']).day
df = df.drop(['date'], axis = 1)
df.head()

你可能注意到我把“年”注释掉了。所有审查的年份(2018 年)相同；因此，具有该列不必要地增加了计算负担，而没有提供任何好处。如果这个数据集的某个版本有更新的旧日期，请随意使用“Year”。

下一步将是收集一些与评论文本本身相关的信息。出于这个例子的目的，我们将使用一个工具 TextBlob，它将分析文本字符串并提供与情感相关的数字输出。TextBlob 将以元组的形式输出极性(范围-1 到 1)和主观性(范围 0 到 1)。这个过程的结果可以映射到分别包含极性和主观性的列中。

首先，让我们开始导入 TextBlob 并定义一个函数，该函数在给定一个字符串输入的情况下输出情感，如果输入无法处理，它将返回一个中性的输出。

from textblob import TextBlob
def sentiment_calc(text):
    try:
        return TextBlob(text).sentiment
    except:
        return TextBlob('hello').sentiment

现在，让我们使用一个 lambda 函数将这个新创建的函数应用于包含评论数据的列，并将输出设置为一个新列，我们称之为“情绪”然后，我们将情感元组映射到各个变量的各个列，并删除“情感”列。

df['sentiment'] = df['verified_reviews'].apply(lambda text: sentiment_calc(text))
df[['polarity', 'subjectivity']] = df['sentiment'].apply(pd.Series)
df = df.drop(['sentiment'], axis = 1)
df.head()

接下来，我们可以收集一些关于文本本身性质的附加元数据，包括字符数、字数、平均单词长度和停用词数。这将允许模型识别这些特征和评级输出之间的任何关系。

首先让我们定义一个返回平均单词长度的函数:

def avg_word(sentence):
  try:
    words = sentence.split()
    return (sum(len(word) for word in words)/len(words))
  except:
    return 0

现在，让我们基于 review 文本列为上述元数据元素创建新列。

df['number_words'] = df['verified_reviews'].str.split().str.len()
df['number_character'] = df['verified_reviews'].str.len()
df['avg_word'] = df['verified_reviews'].apply(lambda x: avg_word(x))

现在我们将创建一个包含评论文本中停用词数量的列。停用词通常被认为是更常见、意义更小的词，如“a”、“the”和“I”。我们还不知道这个变量和这个特定应用的输出之间是否有相关性；然而，我们有一个小的数据集和充足的内存，包含它不会有什么坏处！

我们将从 NLTK 导入“停用词”工具(我鼓励那些不知道这个工具包是什么的人去查一下)。导入工具包，然后使用 lambda 函数，通过执行以下代码行将其应用到评审中。

import nltk
nltk.download("stopwords")
from nltk.corpus import stopwords
stop = stopwords.words('english')df['stopwords'] = df['verified_reviews'].apply(lambda x: len([x for x in x.split() if x in stop]))
df.head()

让我们对这些输入应用一个定标器(Scikit-Learn MinMaxScaler ),以便于模型解释:

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()columns = ['number_character','number_words', 'avg_word', 'stopwords']
for col in columns:
  df[[col]] = scaler.fit_transform(df[[col]])
df.head()

此时，我们可以开始构建模型了！如果你喜欢，请随意这样做，因为有足够多的信息来做出一些可靠的预测。然而，我将通过一些额外的步骤来帮助从评论中挤出更多的信息！

这个过程将涉及文本摘要。我要做的是总结每次复习，然后应用前面的步骤。理论上，这应该从评论中分离出最重要的句子，然后收集最重要的观点。让我们试一试！

从 Gensim 导入汇总工具，然后定义一个可应用于列的函数。注意:如果摘要过程中有错误，这个函数将返回原始文本的副本。

from gensim.summarization import summarizedef sum_text(text):
  try:
    summed_text = summarize(text)
    return summed_text
  except:
    return text

现在，让我们应用这个函数，并收集与之相关的情绪。没有必要缩放输出，因为情感分数将总是在模型容易理解的范围内给出。

df['summed_text'] = df['verified_reviews'].apply(lambda x: sum_text(x))
df['sentiment_sum'] = df['summed_text'].apply(lambda text: sentiment_calc(text))
df[['polarity_sum', 'subjectivity_sum']] = df['sentiment_sum'].apply(pd.Series)
df = df.drop(['sentiment_sum'], axis = 1)
df.head()

现在，让我们创建一个可以输入到模型中的新数据帧。我们可以通过创建 dataframe 的副本来做到这一点，该副本排除了带有字符串的列。

df2 = df.drop(['verified_reviews', 'summed_text'], axis = 1)
df2.head()

数据可视化

为了更好的理解数据，我们用 Seaborn 来可视化吧！

导入依赖项:

import seaborn as sns
from matplotlib import pyplot as plt

绘制所需变量的图表:

sns_plot = sns.pairplot(df, hue = 'rating', vars=['polarity','subjectivity', 'number_words', 'number_character'])
#sns_plot.savefig('name_of_file.png')
#files.download('name_of_file.png')

请注意，最后两行被注释掉了，如果您想保存文件，可以随意取消注释！

以下是输出:

总结文本的数据呢？

正如您所看到的，存在某种程度的聚类，让我们希望我们的模型能够捕捉到细微差别！

构建和执行模型

我们已经完成了数据预处理，最困难的部分已经过去了！

下一步我们将使用 Scikit-Learn 实现一个随机森林分类器。如果您不理解这种形式的分类器是如何工作的，这是一个查找它的好机会！

让我们从创建测试和训练数据开始。我们需要将数据帧转换为标签的 numpy 数组和输入的 numpy 矩阵。我们将使用内置的 Scikit-Learn 测试训练函数来拆分数据。

from sklearn.model_selection import train_test_split
import numpy as npdf1=np.matrix(df2.drop(['rating'], axis = 1))
y=np.array(df2['rating'])X_train, X_test, y_train, y_test = train_test_split(df1, y, test_size=0.2)

现在让我们初始化模型，并使其适合训练数据。由于数据集很小，这应该会很快收敛。完成后会显示分数。

from sklearn.tree import DecisionTreeClassifierrfc = RandomForestClassifier(n_estimators=500, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None)rfc.fit(X_train,y_train)
score = rfc.score(X_test,y_test)
print(score)

最后，让我们将结果可视化。

from sklearn.metrics import confusion_matrixpredictions = rfc.predict(X_test)
cm = confusion_matrix(y_test, predictions)
labels = ['1','2','3','4','5']
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(cm)
plt.title('Confusion matrix of the classifier')
fig.colorbar(cax)
ax.set_xticklabels([''] + labels)
ax.set_yticklabels([''] + labels)
plt.xlabel('Predicted')
plt.ylabel('True')
plt.show()
#print(cm)

要查看结果的数值，只需取消最后一行的注释，以 numpy 矩阵的形式打印出混淆矩阵。

输出应该类似于以下内容:

成绩还算不错！我们达到了大约 84%的准确率，大多数不正确的预测都在相邻的方块中(a 5 被归类为 a 4 或反之亦然)。

结论

在这篇文章中，我们已经下载了 Alexa 评论，预处理文本以创建我们的模型可以解释的数据框架，可视化数据，建立模型，并做出一些预测！

要进行更全面的分析，请考虑建立一个回归模型，将预测强制为 0 到 5 范围内最接近的整数。由于等级是线性数字等级，回归模型方法可能具有优势。

NLP 是一个强大的工具，我们只是触及了可能性的表面，我希望你能在这个主题上了解更多，并构建自己的应用程序和实现！

一如既往，有任何问题请联系我，我很乐意帮助您。

使用熊猫和海牛的描述性统计快速指南

原文：https://towardsdatascience.com/a-quick-guide-on-descriptive-statistics-using-pandas-and-seaborn-2aadc7395f32?source=collection_archive---------0-----------------------

Image by rawpixel from Pixabay

描述统计学是一门研究数据分析的学科，以有意义的方式描述、显示或总结数据。它涉及各种测量的计算，例如中心测量值、、可变性测量值、百分位数以及表格&图的构造。

在本文中，我将介绍那些常见描述性度量的基本概念以及表格和图形的构造。同时，将使用 Pandas 和 Seaborn 演示处理描述性测量的计算和构建表格和图表所需的实际步骤。 Pandas 和 Seaborn 是常用于统计分析和可视化的 Python 库。

先决条件 Python 库

• 熊猫
• Matplolib
• Seaborn

注:

这是强烈推荐使用 Jupyter 笔记本来完成本文中的所有编码任务。这里展示的所有 Python 脚本都是在 Jupyter 笔记本上编写和测试的。您可以参考 Jupyter 官方网站获取在您的机器中设置 Jupyter 笔记本的更多说明。

数据集

我们将使用与墨尔本房价相关的公共数据集"*Melbourne _ HOUSE _ PRICES _ less . CSV "*作为我们的样本数据。数据集可在 Kaggle 获得。

主题 1:数据类型

1.1 数值和分类数据

在开始任何技术计算和绘图工作之前，理解统计研究中常见的数据类型非常重要。数据主要有两种类型:分类数据(定性)和数值数据(定量)。

• **分类数据:**非数字信息，如性别、种族、宗教、婚姻状况等。
• **数值数据:**测量或计数如身高、体重、年龄、工资、子女数等

1.2 实践中的 Python 代码

在统计分析或数据科学项目中，数据(分类数据、数字数据或两者兼有)通常以表格格式(如电子表格)存储在 CSV 文件中。

为了更好地理解，让我们从使用 Pandas 库可视化 CSV 文件(MELBOURNE _ HOUSE _ PRICES _ less . CSV)中的数据开始。

Read and show the first five rows of data

• **第一行:**导入熊猫库
• **第 3 行:**使用 read_csv 方法将 csv 文件中的原始数据读入到数据帧 df 中。**数据帧是用于统计和机器学习模型的二维数组式数据结构。
• **第 4 行:**使用 head() 方法显示数据帧的前 5 行数据。

当我们运行 Jupyter Notebook 中的代码时，您将看到数据显示在一个包含 13 个变量(列)的表格中。

The first five rows of data in a tabular format

Pandas 还提供了另一个有用的方法， *info()，*来获得数据集中每个变量的数据类型的更多细节。在同一个 Jupyter 笔记本中，只需在前面的代码下创建一个新的单元格，添加以下代码行并运行它:

Details of data type for each column

结果显示数据集中总共有 63023 个条目。通常，与数据类型“ int64 ”和“ float64 ”相关联的列表示数值数据，而数据类型“ object 表示分类数据。

*唯一的例外是“邮政编码”。虽然邮政编码被表示为一个数字(int64)，但这并不一定使它量化。邮政编码只是应用于分类数据的数字。

只需一行代码， Pandas 就能让我们识别出由*“房间”、“价格”、“物业数量”和“距离”*组成的数字数据，其余的都是分类数据。

Categorical Data vs Numerical Data

主题 2:中心的测量

Photo by Binyamin Mellish from Pexels

总结数字数据的一个常用方法是找出数据的中心趋势。例如，我们可能会问“在我们的数据集中，房价最典型的值是多少？”。为了解决这个问题，我们可以求助于两个最常见的中心测量:均值和中位数。

2.1 表示

Mean 是所有数字的平均值。计算平均值所需的步骤是:

1. 对数据集中目标变量的所有值求和
2. 将总和除以值的个数

例如，如果我们有一组五个值，[70，60，85，80，92]，

然而，有时平均值可能会产生误导，可能不能有效地显示数据集中的典型值。这是因为平均值可能会受到异常值的影响。

异常值是指与数据集中的其余数字相比，要么非常高，要么非常低的数字。

让我们看看另外两个数据集，[70，60，1，80，92]和[70，60，300，80，92]。

上方的 Mean_1 被极低的异常值“1”向下驱动。另一方面， Mean_2 由于具有极高的异常值“300”而被向上驱动。

2.2 中位数

**Median 是一个数字排序列表的中间值。**从一系列数字中获取中值所需的步骤如下:

1. 将数字从最小到最大排序
2. 如果列表中有奇数个值，中间位置的值就是中值
3. 如果列表中有偶数个值，中间两个值的平均值就是中值

下面的两个例子说明了如何从奇数个值和偶数个值中得到中值。

如果我们有一组八个值，[30，45，67，87，94，102，124]，

注意:中位数不受异常值的影响。

我们选择使用均值还是中值作为中心点的度量取决于我们要解决的问题。一般来说，在我们的统计研究中，我们应该报告平均值和中值，并让读者自己解释结果。

实践中的 2.3 Python 代码

为了计算均值和中位数，Pandas 为我们提供了两种简便的方法， mean() 和 median() 。让我们用熊猫从数据集中得到我们房价的平均值和中值。

Get mean and median using Pandas

第 1 行& 4: df[‘Price’] 将选择填充价格值的列。接着是点语法来分别调用方法 mean()和 median()。

第 2 行& 5 :打印平均值和中间值。

注意，熊猫的意味着和中位数的方法已经为我们封装了复杂的公式和计算。我们所需要的只是确保从数据集中选择正确的列，并调用方法来获得平均值和中值。输出如下所示:

The mean and median of house prices

主题 3:变化的度量

Photo by Pritesh Sudra on Unsplash

在数据集中总是可以观察到变化。这是非常不寻常的，看到一整组数字共享完全相同的值，如下所示:

当比较两个数据集之间的差异/可变性时，平均值和中值不是一个好的选择。为了进一步解释这一点，让我们看下面的两个例子

上述两个数据集共享相同的平均值和中值，即 300 。然而，它们有不同程度的变异。尽管第一个数据集中的数字和第二个数据集中的数字具有相同的平均值和中值，但两者的差异较小。因此，我们需要另一种测量来检查数据集的可变性。

3.1 标准偏差

测量数据集变化的一种常用方法是计算标准差(SD) 。SD 只是一种测量方法，用来告诉我们一组值是如何从它们的平均值分散开来的。较低的标准差显示数值接近平均值，较高的标准差显示数值偏离平均值较高。

计算 SD 的步骤如下:

1. 计算数据集的平均值
2. 对于数据集中的每个数字，用平均值减去它
3. 平方从步骤 2 获得的差值
4. 总结第 3 步的结果
5. 将步骤 4 的总和除以数据集中值的个数减 1
6. 平方根来自步骤 5 的结果

注意:

• SD 必须是正数
• SD 受异常值的影响，因为其计算基于平均值
• SD 的最小可能值为零。如果 SD 为零，则数据集中的所有数字共享相同的值。

3.2 实践中的 Python 代码

熊猫还提供了一种简便的方法 std() 来计算 SD。让我们试着用熊猫法来计算我们房价的标准差。

**第 1 行:**调用方法 std()计算房价的 SD

同样，我们可以看到 Pandas std() 方法已经为我们封装了复杂的 SD 计算，我们可以动态地获得 SD 值。

SD of house price

主题 4:以图形方式显示数字数据分布

Photo by Lukas from Pexels

以上章节涵盖了使用单个值的两个描述性测量示例(中心测量和变化测量)。在本节中，我们将了解如何使用图形方式探索数据分布。

4.1 箱线图

揭示数据分布的一种方法是从我们的数据集中找到一个五位数摘要**。**五数汇总包括:

1. 最低限度
2. 第 25 个百分位数或第一个四分位数(Q1)
3. 中间值
4. 第 75 个百分位数或第三个四分位数(Q3)
5. 最大值

这里有必要解释一下“百分位的含义。

百分位数是统计学中使用的一种度量，表示一组观察值中给定百分比的观察值低于该值。例如，第 20 个百分位数是这样一个值，在该值以下可以找到 20%的观察值。(来源:维基百科)

五个数字的汇总提供了一种快速的方法，使我们能够粗略地定位数据集中的最小值、第 25 个百分点、中值、第 75 个百分点和最大值。呈现这五个数字汇总的一种图形化方式是创建一个箱线图。

Samples of boxplot

4.2 直方图

**直方图是一种图形显示，使用矩形条来显示一组数字数据的频率分布。**直方图使我们能够可视化数据的潜在分布模式。

构建直方图所需的步骤如下:

1. 将我们的数据分成称为仓的区间。
2. 记录数据集中每个数字的出现次数(频率),并将它们制成频率表。
3. 根据步骤 2 中获得的频率表绘制直方图。

Steps to create a histogram

4.3 实践中的 Python 代码

在本节中，我们将使用 Seaborn 库为我们的房价创建一个箱线图和直方图。

首先，让我们从箱线图开始。

Create a boxplot using Seaborn

• 第 1 行&第 2 行:导入 Matplolib 和 Seaborn 库
• **第 4 行:**一个神奇的函数，使我们的图形能够在 Jupyter 笔记本中呈现
• **第六行:**设定一个海边的主题
• **第 7 行:**设置绘图的图形大小
• **第 8 行:**使用 Seaborn boxplot() 方法生成一个 boxplot。我们将价格设置为绘图数据的输入。参数“ orient ”中的“ v ”值用于以垂直样式呈现我们的箱线图。

The Seaborn Boxplot of housing price

事实上，在我们的数据集中有三种不同类型的房屋，分别是“H”型房屋、“U”型房屋和“T”型联排别墅。我们可以为每种类型的房屋创建一个箱线图。为此，我们只需在我们的 Seaborn boxplot() 方法中添加另一个参数“y”。

Create Seaborn boxplot for each type of house

• 行 1: 设置“类型为 x 轴数据，“价格为 y 轴数据。

Seaborn boxplot for each type of house

现在，让我们尝试构建一个直方图来观察我们的房价数据的数据分布。我们将使用 Seaborn distplot() 来创建直方图。

Create Seaborn histogram

• **第 1 行:**这是使用“dropna()”方法从我们的住房数据集中的“Price”列中删除所有空值的必要步骤。如果列中存在空值，Seaborn 将无法生成直方图。
• **第 2 行:**设置直方图的图形大小。
• **第 3 行:**使用 distplot() 方法生成直方图。只有一个必需的输入，即过滤后的房价数据(没有任何空值)。

Seaborn Histogram for House Price

主题 5:探索分类数据

Photo by Providence Doucet on Unsplash

在上面的章节中，我们只讨论了数字数据(房价)的描述性统计分析。分类数据怎么样？在我们看来，我们可能会对住房数据集中的分类数据有一些疑问:

• 在我们的数据集中，每种类型的房子(h - house、t-town house 和 u-unit)的比例是多少？
• 哪个地区的房产销售数量最多？

第一个问题可以通过绘制饼图来解决，而条形图可能是解决第二个问题的好选择。

5.1 饼图

**饼图是显示数据集中分类数据的数字比例的简单图形方式。**饼状图也被称为圆形图(来源:维基百科)，它被分成楔形块。每个片段的弧长与分类数据的相对频率成比例。

让我们看一个饼图的例子。

A sample Pie Chart

看一下上面的饼状图样本，我们就能立即了解一年的销售业绩。显然，超过一半的销售额是在第一季度实现的，而第四季度的销售额最低。

5.2 条形图

条形图是分类数据的另一种有效的图形显示。条形图是一种图形显示，使用条形显示每个分类数据的出现次数或频率。

让我们再来看一个条形图的例子。

Sample bar chart

5.3 实践中的 Python 代码

Pandas 提供了一个绘图功能，可以生成一个饼图来显示每种类型的房屋在我们的数据集中所占的比例。

Create a Pie Chart to show the proportion of house

• **第 1 行:**使用 Pandas 方法“ value_counts() ”获得每种房屋类型的频率。
• **第 2–4 行:**创建一个新的数据帧， *df2。*这个新的数据框架只有一个单独的列，“ house_type ”来保存每个房屋类型的数量，“type _ counts”
• **第 5 行:**将列名“ house_type ”赋给参数“y”。这使得 Pandas pie() 方法能够根据每个房屋类型的数量自动生成一个饼图。参数 autopct 启用，在饼状图中显示每种房型所占的百分比。

Pie Chart to show the proportion of each house type

从饼图中，我们可以很容易地确定每种类型的房子的百分比。

接下来，我们可以使用 Seaborn 创建一个条形图来显示基于地区的房产销售数量。

Create a bar chart using Seaborn

• **第 1–2 行:**将 Seaborn 主题设置为“暗格”，并设置地块的图形大小
• **第 3 行:**将分类变量“ Regionname ”赋给参数“ x ”。将绘图数据集“ df ”分配给参数“数据”。Seaborn " countplot() "方法将自动捕获每个区域的出现次数，并呈现一个条形图。

Bar Chart to show the number of property sales in each region

从上面的条形图中，我们可以得出结论，南部大都市的房产销售数量最多。

结论

这篇文章通过介绍一些被社会广泛采用的主要描述性度量和图形显示，提供了一个描述性统计的快速指南。主要目的是通过使用 Pandas 和 Seaborn，展示一些有意义地总结数据集的可能方法。对于那些希望参与统计分析或数据科学项目的人来说，Pandas 和 Seaborn 应该是两个必不可少的工具包。Pandas 和 Seaborn 的一个主要优势是，它们已经将大量复杂的计算和绘图步骤封装到几行 Python 脚本中。这使得数据分析过程变得更加容易和节省时间。

但是，这里涵盖的主题并不详尽，还有许多主题没有在这里讨论。此外，本文中介绍的现有主题也可以被分解并进行更详细的讨论(这可能需要更多的文章来专门讨论每个特定的主题)。

我希望这篇文章能为描述性统计提供一个起点和一个总的回顾。我希望你喜欢阅读。

Github 资源:

这里展示的所有 Python 脚本都写在 Jupyter 笔记本上，并通过 Github Repo 共享。请随意从https://github . com/teobeeguan 2016/Descriptive _ Statistic _ basic . git下载笔记本

参考

1. 百分位数的定义(从 https://en.wikipedia.org/wiki/Percentile 的检索)
2. 饼状图的定义(从 https://en.wikipedia.org/wiki/Pie_chart 的检索)

创建惊人数据科学项目的快速指南

原文：https://towardsdatascience.com/a-quick-guide-to-create-astonishing-data-science-projects-6d848375471f?source=collection_archive---------28-----------------------

又名——擅长团队合作的入门指南

Screenshot from Quora

如果你被困在付费墙后面，点击 此处 阅读完整故事与我的朋友链接

在过去的 8 年里，我有幸领导并成为不同国家和背景下的高绩效团队的一员。我构建伟大项目和产品的经历让我想到一件事:没有人独自创造出真正伟大的项目。 数据科学项目和产品也不例外。

最近，我与其他 3 名团队成员合作“利用数据和 GIS 平台有效应对野火”。我将分享一些概念和想法，帮助我们一起快速行动，创造一个伟大的解决方案。

正如制作三明治的家伙 Rana Usman 所说:

让我们来倒数一下数据科学团队是如何工作的。

• 在第一次会议上建立团队文化:不要开始谈论挑战或问题、技术等。相反，邦德，谈谈你的优势和你想领导的东西——学习。不要深入细节，谈谈如何解决问题的想法。彼此感觉舒服，建立信任。
• **选择项目管理工具:**我们的团队使用 Google Docs 来记录一切。这个想法是把任务、会议结论、提议、时间和结果放在一个共享的地方。我喜欢并强烈推荐 Podio 和 Trello 进行任务管理，但这是一个偏好问题。
• 为所有实验的工件选择一个单一的平台。保存的模型、代码、应用程序，应有尽有。通过这样做，当项目变得复杂时，我们节省了大量时间。我们团队用的是 Google Drive 和 GitHub。
• 最后一点让我想到了这一点，创造一种开放的文化，并习惯于分享:团队可以从彼此的代码和解决问题的方式中学到很多。分享每一份文件，并寻求反馈。
• 对快速的试验和改变保持开放的态度:当遇到这样的问题时，解决方案并不是直截了当的。在我们的项目中有一个点，我们每天都在改变任务和负责任务的人，直到我们到达我们想要的点。从第 0 天开始适应变化。
• 安排固定时间- 每天同步 15 分钟:这让每个团队成员都知道现在正在处理什么，挑战和下一步。
• **强制执行同行代码和文档审查:**团队特别了解彼此的工作风格，额外的关注将使个人任务更上一层楼。
• **只有一个沟通渠道:**使用 Slack。简单。
• **开放地给予和接受反馈:**将消极进取的反馈抛在脑后，并习惯于给予和接受诚实而友好的反馈。如果你不同意某个可以改进的方法，那么在整个过程中，对好的和坏的方面保持透明。

我会结束这一切。永远不要用“我” 的方式说话，一旦开始在团队工作，就要用“我们”的方式说话和思考。整个团队负责每一单’*‘闪耀’‘和’‘成长’ 的项目。*

根据定义，数据科学项目是团队合作。它们由不断迭代新想法的平稳进展组成。希望这些基本但重要的要点将帮助您创建一个令人惊叹的数据科学团队项目。

如果你对团队建设和工作有任何其他建议，请在评论中分享。我很想读读它们。

使用命令行(终端)的快速指南

原文：https://towardsdatascience.com/a-quick-guide-to-using-command-line-terminal-96815b97b955?source=collection_archive---------4-----------------------

能够使用命令行是高级编码所必需的。以下是你需要知道的要领。

Photo by Florian Olivo on Unsplash

打开命令行。如果你刚刚开始编码，你可能甚至不知道命令行是什么。别担心！这只是告诉你的电脑做什么的一个简单方法。根据您使用的操作系统，访问命令行的方式各不相同。

• MacOS:打开 spotlight search(默认方式是点击 command 和空格键)并输入“终端”。选择名为“终端”的应用程序，然后按回车键。这将打开一个黑色背景的应用程序。当您看到您的用户名后面跟着一个美元符号时，您就可以开始使用命令行了。
• Linux:可以直接按[ctrl+alt+T]打开终端，也可以点击“破折号”图标，在搜索框中输入“终端”，打开终端应用程序进行搜索。同样，这应该打开一个黑色背景的应用程序。当您看到您的用户名后面跟着一个美元符号时，您就可以开始使用命令行了。
• Windows:在 Windows 10 上，打开开始菜单，进入名为“Windows 系统”的快捷方式文件夹。按下拉菜单应该会显示一个快捷方式来打开命令提示符应用程序。右键单击快捷方式，按“更多”，然后按“以管理员身份运行”。对于 Windows 8 ，进入开始屏幕，按下“所有应用”，向右滚动直到“Windows 系统”文件夹出现。您可以在那里找到命令提示符。对于 Windows 7 ，打开开始菜单，点击“所有程序”。点击“附件”，你会发现命令提示符的快捷方式。右键单击快捷方式，然后按“以管理员身份运行”。

**访问服务器。**如果你在服务器上运行代码(例如 GPU 集群或类似亚马逊网络服务的东西)，你需要能够访问服务器。最好的方法是通过安全外壳(ssh)，它让您可以使用互联网安全地控制和修改您的服务器。您可以通过键入以下内容来完成此操作:

ssh 用户名@主机服务器

其中，username 是您在服务器上的帐户名称，host_server 是主机(例如，GPU 集群的名称)。如果您有密码来访问您在服务器上的帐户，命令行将提示您输入密码。如果您是第一次访问该特定服务器，您的电脑也可能会询问您是否能记住授权密钥，键入“是”或相应的短语，这样您的电脑就不会每次都问您这个问题。当您链接到服务器时，您应该会看到命令行以某种 username@host 格式的绿色标题开始。将此作为您真正连接到服务器的指示器。

移动文件。这个很简单。键入以下内容:

mv 目标

其中 mv 是 move，target 是要移动的文件，destination 是要移动到的位置。

**复制文件/文件夹。**如果你想拷贝文件，最简单的方法是使用 cp 命令。使用以下脚本复制文件。

cp -r 目标

在这个脚本中，cp 代表复制，而-r 代表递归复制。目标是您要拷贝的目标文件夹/文件，目的地是您要拷贝到的目标文件夹。重要提示:

• 假设你输入“CP-r home/target/home/destination/”。如果“home”是文件夹，“target”是文件夹，但“destination”不是 home 中的文件夹，那么“target”会被复制到 home 中但会被命名为“destination”。
• 假设你输入“CP-r home/target/home/destination/”。如果所有这些都是有效的文件夹，“目标”将被复制为“home”中“destination”内的一个文件夹—您将得到一个“home/destination/target/”文件夹。
• 假设你输入“cp -r home/target/ users/”。这只会将“目标”文件夹复制到同名(目标)下的“用户”文件夹中。
• 使用字符代表所有。例如，要复制文件夹中以字母 a 开头的所有文件，您的目标应该是“/folder/a”。复制某个扩展名的所有文件(比如。png)，你的目标应该是“/folder/*。png”。
• 使用。表示当前文件夹的字符。
• 如果文件/文件夹已经存在于目的地，其将被覆盖。所以一定不要犯这种新手的错误。

删除文件/文件夹。删除文件是非常必要的，所以你应该这样做。使用此脚本:

rm -r 目标

其中 rm 表示删除，-r 表示递归地执行删除。目标是您试图删除的文件/文件夹。如果您没有阅读“复制文件/文件夹”下的注释，请参阅更多专业提示:

• 这个命令不会让你删除一个不存在的文件(它会说“没有这样的文件或目录”)
• 使用字符代表所有。例如，要删除文件夹中以字母 a 开头的所有文件，您的目标应该是“/folder/a”。删除特定扩展名的所有文件(比如。png)，你的目标应该是“/folder/*。png”。
• 使用。表示当前文件夹的字符。
• 这个命令会很快删除文件。文件一旦删除，就无法恢复。这里没有控制 Z。请务必输入正确的目录/文件。
• 或者，您可以在-r 后面输入“-i”(例如 rm -r -i target)，这将提示计算机请求允许删除每个文件。

**清单文件。**当你在一个文件夹中时，能够看到其中的文件/文件夹可能非常有用。用这个:

ls 目标(选项)

Target 是您试图列出其内容的文件夹(如果您试图列出当前所在文件夹的内容，请将 target 留空)。您也可以使用以下选项:

• "-F “:为文件类型添加一个字符(例如” * “表示可执行的脚本，而”/"表示目录)。
• "-f ":停止计算机对内容进行排序。当有大量的文件并且对这些文件进行分类没有用时，这是很有用的。
• "-a ":列出所有文件，包括通常隐藏的隐藏文件。
• "-h ":将让您也获得文件的大小。
• "-t ":按上次修改时间对文件进行排序。

更改您所在的目录。使用这个简单的命令来改变你当前的目录:

cd 目标

其中 cd 是更改目录，target 是要输入的文件夹。更多提示:

• 使用。表示当前文件夹的字符。做“cd”将刷新命令行显示的当前目录(如果您已经更改了文件夹路径中的文件夹名称，这将非常有用)。
• 使用"…/”来表示封闭文件夹。例如，如果您当前在“home/target/”中，那么您可以执行“cd…/”以进入“home”文件夹。的”…/”也是可堆叠的，所以其中两个可以让你拿回两个文件夹。

**制作新文件夹。**这也是一个非常简单的命令。使用以下脚本:

mkdir 目标

其中 mkdir 是制作目录，target 是要制作的文件夹的名称。例如，“mkdir target”会在命令行当前所在的目录中创建一个名为“target”的文件夹。

**清理杂物。**当你运行太多命令时，很容易让你的命令行屏幕被一堆绿色、蓝色和白色的线弄得乱七八糟。使用这个一个字的命令来清除它:

清楚的

不言自明:clear 代表清除屏幕。

运行脚本。如果你正在编码，你可能希望能够使用命令行运行你的代码。你很幸运，有一个很好的方法可以做到这一点！现在，我是一个 Python 用户，所以先说 Python:

python 目标

目标是您想要执行的文件(它应该以“.”结尾)。py”)。

对于 Java，使用以下代码:

java 目标

javac 目标

做“java”会运行文件，“javac”会编译它。目标是您想要执行的文件(它应该以“.”结尾)。java”)。

其他语言如 C 和 JavaScript 需要特殊的包才能在命令行中运行，我已经为它们做了超链接说明。

Photo by Erwan Hesry on Unsplash

恭喜你！您现在能够使用命令行了(在一定程度上)。这些只是基本的命令，还有更多用于特定任务的专用命令，但这些是几乎任何使用命令行的人都应该知道的。

深度学习快速入门

原文：https://towardsdatascience.com/a-quick-introduction-to-deep-learning-41af97e064da?source=collection_archive---------21-----------------------

在过去的几年里，深度学习已经离开了研究实验室，去征服非专家公众。谷歌、亚马逊、脸书和微软等公司通过使用深度学习算法取得的惊人成果，使其受到媒体的广泛关注。让我们在猫或狗分类问题的背景下发现深度学习算法的一些基本原则。

什么是神经科学中的神经元？

神经元是大脑的基本细胞，负责开发一些与智力、识别、决策等相关的机制。为了简化起见，让我们考虑一个神经元总是给出二进制输出；要么是被激励，输出信号非零，要么是未被激励，因此输出信号为零。假设有一个神经元负责区分猫和狗。为了做出决定，这个神经元必须考虑来自视觉和听觉等感官的输入信息，并变得兴奋地说猫，未兴奋的——零输出信号——意味着狗。

当然，收集的输入信息在神经元做出的最终决定中并不具有相同的普遍性。

这里，因为猫和狗可能有相同的颜色，所以关于颜色的输入信息不会像关于高度的信息那样有区别，这似乎没有关于动物声音的信息重要。这是一个生物神经元给它的每一个输入信息分配一个或大或小的重要性的地方，反映了这个信息与它的输出信号的相关程度。为了达到这个目标，信息通过树突提供给神经元，并流向突触，这些化学神经递质可以使抑制，减弱信号或者兴奋，增强信号。

A biological neurone

应该注意的是，这几乎是你开始做深度学习所需要知道的关于神经科学的所有知识。前面提到的机制要复杂得多，它们的核心解释超出了本文的范围。记住这一点可能是至关重要的，深度学习更多的是关于计算机科学和数学——我们将看到它是如何实现的——并且只与神经科学分享设计人工神经元的基本原则。我们不是在做神经科学。正如脸书大学深度学习领域的顶级研究员 Yann LeCun 教授所说的那样。深度学习的灵感来自神经科学，就像飞机的灵感来自鸟类一样，它们使用相同的原理，但细节却截然不同。

我们如何设计人工神经元？

人工神经元总体上依赖于上述机制；输入信息的重要性由一个数字来量化，称为权重 w 数字越大，神经元输出信号中的信息越占优势。

An artificial neurone with three entries

每个输入乘以其相应的重要性系数，该条目的权重 wi I，然后传输到神经元。这样，神经元将所有加权输入相加。假设一个高的结果应该被解释为一只猫—对应于 1 —当一个低的结果，作为一只狗—对应于 0 —时。也就是说，我需要一个真实的值来与之前的结果进行比较——输入的加权和——并做出决定，是猫还是狗。这个中间值被称为偏差，它属于神经元，不依赖于输入。

让我们来回顾一下，神经元接受输入，将每个输入乘以相应的权重，对这些加权输入求和，然后将这个和与其偏差 b 进行比较，并做出最终决定，是猫还是狗。

这就相当于说，神经元对加权输入求和，加上它的偏差，如果结果是肯定的，决定是猫，否则是狗。让我们引入 y 来简化符号，

激活功能

为了理解激活功能，让我们想象你手中有一个打火机，为了科学起见，你戴上它，让它离你的手指更近。随着打火机离你的手指越来越近，你也越来越痛苦。因此，尽管输入，比如说热量增加了，但是负责评估手指疼痛的神经元传递了一个更大的信号，这个信号被解释为越来越痛。

考虑到这一点，我们不是说人工神经元为阳性 y 提供 1，而是说它提供与 y 成比例的反应。 y 越大，输出越大。由此可知， c 为常数的正 y 的输出为 c.y ，负 y 的输出为 0 。因此公式，由于 c 通常取为 1，如果为正，则输出为 y ，如果为负，则输出为 0 。这被称为**激活功能，**准确地说是 RELU ，整流线性单元激活功能。

RELU activation function curve

另一个激活功能

现在假设，皇家马德里队将与巴塞罗那队比赛，我们要求随机选择一个人——不是铁杆球迷——对比赛结果进行预测。即使我们给了这个人关于球员，工作人员等的所有信息，他也不会给出一个绝对的结果，就像他 100%确定的那样。既然总是有疑问，他大概会给出一个队获胜的可能性，比如说有 60%的把握 R.M .会赢这场比赛。我们赋予人工神经元同样的能力。神经元不是从 y 传递一个绝对的二进制结果，比如 0 或 1，而是给出一个介于 0 和 1 之间的数字，这里解释为动物是猫的可能性。这是通过对计算出的 y 应用一个函数来完成的，所以输出是，

Sigmoid activation function

这就是所谓的 sigmoid 激活函数，因为函数的曲线类似于 s

请注意，假设我们将 y 与零进行比较，并输出 0 或 1，正如我们首先介绍的那样，这也是一个具有以下曲线的激活函数，

Basic activation function

一般来说，对于激活函数 f ，神经元的输出是 **f(y)，**其中， y 是条目的加权和，加上神经元的偏差 b。

综上所述，激活函数是我们应用于结果 y 的一个函数f**；因此，神经元的最终输出是 f(y)。**功能 f 的选择取决于要解决的问题和经验。最常用的激活功能是 sigmoid 和 RELU ，因为它们是众所周知的并且导致更好的性能。现在你知道了所有关于人工神经元的知识，让我们用它们来解决猫或狗的问题。

多层感知器网络

决定一种动物是猫还是狗实际上是一项由单个神经元完成的相当困难的任务。然后将这个复杂的任务分成几个简单的子任务，分配给不同的神经元。这些神经元中的每一个都会考虑所有的条目，给它们分配权重，反映它们在最终决定中的重要性。这导致了一个更强大的网络。在这里，神经元 3 将做出最终决定。

A densely connected network with three neurones

由于相同的条目被提供给每个第一层神经元，并且一层的神经元连接到前一层的所有神经元，这被称为密集连接的神经网络。

这里我们有一个神经架构**、——还不深——也就是说，一个感知器；由美国心理学家弗兰克·罗森布拉特于 20 世纪 50 年代首次提出。感知器在这里只有一层。大多数时候，在深度学习中，我们可以利用实际上大量的数据来解决复杂的任务。因为我们希望我们的神经网络足够强大，所以我们上面看到的层将由更多的神经元组成，128 或 256 或 512 个——一般是 2 的幂——然后，一个接一个，几十层将被堆叠起来；我们现在得到了一个深度多层感知器，因此得名深度**学习。同一层的神经元应该具有相同的激活功能。但是从一层到另一层，激活功能可能不同。

A multi-layered perceptron with 6 layers

为了解决猫或狗的分类问题，我们可以设计一个多层感知器神经网络，其第 1 层到第 5 层具有 RELU 激活功能，第 6 层的神经元具有 sigmoid 激活功能，这被认为是产生猫的可能性。层 1 称为输入层，层 6 称为输出层；从 2 到 5 是隐藏层，因为隐藏在输入和输出层之间。这是我们在真正的深度学习模型中通常做的事情。现在我们已经建立了模型，它是如何工作的呢？

有监督的深度学习

我们从设计神经元和我们为模型选择的层数开始。一旦这样做了，我们希望模型能够运行。然而，在最开始，我们不知道权重和偏差应该取什么值，这样模型才能做出正确的决定。因此，权重和偏差参数是用随机值初始化的，这意味着模型非常不准确。顺便说一句，该模型将自己学习神经元的权重 w 和偏差 b 的正确值，并提高准确性，因此在深度学习中学习。学习权重和偏差的步骤被称为训练阶段。

培训过程

训练的最终目标是将权重和偏差从初始随机值移动到优化值，因此该模型在说猫或狗时更准确。

图像和其他类型的数据

生物神经元接收来自视觉、听觉、嗅觉等的综合信息。深度学习模型大部分时间都将被图像喂养，但也可以为视频、声音、文本和表格设计。正如我们在上面看到的，每个神经元都将对条目进行数学运算，所以输入数据必须绝对是数字矩阵；只要与计算和数学运算兼容。

图像到矩阵

考虑如下的灰度图像，该图像实际上以像素矩阵的形式存储在您的计算机设备或电话中，其中像素是一个几乎不可见的正方形，颜色从白色(对应于 255)到黑色(对应于 0)。该矩阵用于为模型提供信息。

From a 100x100 px image zoomed in and the 100x100 matrix, here with random values.

放大图片时，像素变得可见；每个像素灰度——从 0 到 255——符合最右边矩阵中的一个数字。这里我们同样处理一个猫的图像。

Cat 100x100 px image and corresponding 100x100 matrix

在训练阶段，我们让模型计算这个矩阵 x 代表一只猫的概率p——通过 sigmoid 函数，见上文。由于模型还没有训练好，所以不太可能 p=1 。

价值函数

我们知道这张图片是一只猫，所以我们将模型的目标定为给出 1 的 p 值——这意味着 100%确定这是一只猫——为了测量模型与正确结果的差距，我们可以考虑差异 1-p 。通过这样做，我们引入了一些新的东西，一个成本函数或损失函数，它是我们期望的 p 的值和计算出的值之间的差异。

由于可能性 p 取决于模型的权重 W 和偏差 b ，因此成本函数也取决于它们。

如果 C(W，b) 是 0，那就完美了，意味着实际结果与计算结果相同。不幸的是，由于有成千上万的权重和偏差需要调整，很可能无法达到这个目标。因此，我们试图通过名为梯度下降的计算技术来最小化损失 C(W，b) 。我们同样处理成千上万不同的猫和狗的图像。对于它们中的每一个，模型都会移动权重和偏差，以减少损失并提高准确性。一旦训练完成，参数值，即模型的权重和偏差被优化以最小化损失；它们被冻结，以后不会被更改。因为我们需要人类的帮助来计算损失——我们需要实际的结果——这被称为监督学习。

测试阶段模型精度的计算

最后一步，在一个从未见过的猫和狗的独立图像数据集上测试该模型，在这里，模型不会学习，我们只是观察它的反应，看看它是否足够有效和训练有素。这是测试阶段。我们模型的准确率会是正确答案的比例。如果该模型足够高效和准确，它就可以部署在目标基础设施上，即联网设备、移动电话、自动驾驶汽车等。到这个时候，模型将在没有任何人类帮助的情况下对真实世界的图像做出决定。最先进的技术是在分类任务中对最好的模型有 99%的准确性，在实际应用中足够准确。

结论

本文的唯一目的是介绍神经元在深度学习模型和学习过程中的作用背后的直觉。如果你想更深入，发现深度学习的迷人世界，梯度下降，生成模型等。，不要犹豫，订阅时事通讯，发现我的下一篇文章。感谢您的阅读。

深度学习要开始的一些建议

使用 Python 进行深度学习

https://www . Amazon . fr/Deep-Learning-Python-Francois-Chollet/DP/1617294438

使用 Keras 进行深度学习

https://www . Amazon . fr/Deep-Learning-Keras-Implementing-Learning-ebook/DP/b 06 y2 ymrdw

深度学习 TensorFlow 2.0 快速入门

原文：https://towardsdatascience.com/a-quick-introduction-to-tensorflow-2-0-for-deep-learning-e740ca2e974c?source=collection_archive---------4-----------------------

想获得灵感？快来加入我的 超级行情快讯 。😎

经过大量的社区宣传和期待， TensorFlow 2.0 终于在 2019 年 9 月 30 日由 Google 发布。

TensorFlow 2.0 代表了图书馆发展的一个重要里程碑。在过去的几年里，TensorFlow 的主要弱点之一，也是许多人转而使用 PyTorch 的一个重要原因，就是它非常复杂的 API。

定义深度神经网络需要的工作比合理的要多得多。这导致了位于 TensorFlow 之上的几个高级 API 的开发，包括 TF Slim 和 Keras 。

现在事情又回到了起点，Keras 将成为 TensorFlow 2.0 的官方 API。加载数据、定义模型、训练和评估现在都变得容易多了，Keras 风格的代码更干净，开发时间更快。

本文将快速介绍使用 Keras 进行深度学习的新 TensorFlow 2.0 方式。我们将经历加载数据集、定义模型、训练和评估的端到端流程，所有这些都使用新的 TensorFlow 2.0 API。如果你想自己运行全部代码，我已经设置了一个包含全部内容的 Google Colab 笔记本！

导入和设置

我们将从导入 TensorFlow、Keras 和 Matplotlib 开始。请注意我们如何使用tensorflow.keras直接从 TensorFlow 中提取 Keras，因为它现在就捆绑在 tensor flow 中。我们还有一个 if 语句来安装 2.0 版本，以防我们的笔记本运行的是旧版本。

接下来，我们将加载数据集。对于本教程，我们将使用 MNIST 数据集，它包含 60，000 张训练图像和 10，000 张数字从 0 到 9 的测试图像，大小为 28x28。这是一个非常基本的数据集，一直用于快速测试和概念验证。还有一些使用 Matplotlib 的可视化代码，因此我们可以查看数据。

Visualizing MNIST digits

创建用于图像分类的卷积神经网络

做图像分类最好的方法当然是用一个卷积神经网络 (CNN)。API 将拥有我们构建这样一个网络所需的一切。由于 MNIST 非常小——图像大小为 28x28，只有 60，000 个训练图像——我们不需要超级庞大的网络，所以我们将保持简单。

在过去的几年中，构建一个好的 CNN 的公式在很大程度上保持不变:堆叠卷积层(通常为 3×3 或 1×1 ),中间有非线性激活(通常为 ReLU ),添加几个完全连接的层，并在最后添加一个 Softmax 函数来获得类概率。我们已经在下面的网络定义中完成了所有这些工作。

我们的模型共有 6 个卷积层，每个卷积层之后都有一个 ReLU 激活。在卷积层之后，我们有一个 GlobalAveragePooling 来将我们的数据放入一个密集的向量中。我们完成了我们的全连接(密集)层，最后一个有 10 个 MNIST 的 10 类大小。

同样，请注意我们所有的模型层都来自于tensorflow.keras.layers，并且我们使用的是 Keras 的功能 API。使用函数式 API，我们将模型构建为一系列顺序函数。第一层将输入图像作为输入变量。接下来，每个后续层都将前一层的输出作为其输入。我们的model.Model()简单地连接了从输入到输出张量的“管道”。

有关该模型的更详细描述，请查看下面model.summary()的打印结果。

Model: "model_1" _________________________________________________________________ Layer (type)                 Output Shape              Param #    ================================================================= input_3 (InputLayer)         [(None, 28, 28, 1)]       0          _________________________________________________________________ conv2d_12 (Conv2D)           (None, 28, 28, 32)        320        _________________________________________________________________ activation_16 (Activation)   (None, 28, 28, 32)        0          _________________________________________________________________ conv2d_13 (Conv2D)           (None, 14, 14, 32)        9248       _________________________________________________________________ activation_17 (Activation)   (None, 14, 14, 32)        0          _________________________________________________________________ conv2d_14 (Conv2D)           (None, 14, 14, 64)        18496      _________________________________________________________________ activation_18 (Activation)   (None, 14, 14, 64)        0          _________________________________________________________________ conv2d_15 (Conv2D)           (None, 7, 7, 64)          36928      _________________________________________________________________ activation_19 (Activation)   (None, 7, 7, 64)          0          _________________________________________________________________ conv2d_16 (Conv2D)           (None, 7, 7, 64)          36928      _________________________________________________________________ activation_20 (Activation)   (None, 7, 7, 64)          0          _________________________________________________________________ conv2d_17 (Conv2D)           (None, 7, 7, 64)          36928      _________________________________________________________________ activation_21 (Activation)   (None, 7, 7, 64)          0          _________________________________________________________________ global_average_pooling2d_2 ( (None, 64)                0          _________________________________________________________________ dense_4 (Dense)              (None, 32)                2080       _________________________________________________________________ activation_22 (Activation)   (None, 32)                0          _________________________________________________________________ dense_5 (Dense)              (None, 10)                330        _________________________________________________________________ activation_23 (Activation)   (None, 10)                0          ================================================================= Total params: 141,258 Trainable params: 141,258 Non-trainable params: 0 _________________________________________________________________

培训和测试

最精彩的部分来了:训练并获得实际效果！

首先，我们需要做一些数据预处理，以便为训练正确格式化数据。我们的训练图像需要在一个 4 维的阵列中，格式为:

(批量 _ 尺寸，宽度，高度，通道)

我们将图像转换为类型为 float32 的图像，这是正确训练的一个要求，并进行归一化，使每个像素的值在 0.0 和 1.0 之间

至于标签，因为我们正在使用 Softmax 激活，我们希望我们的目标输出是一个热编码向量的形式。为此，我们使用了tf.keras.utils.to_categorical()功能。函数中的第二个变量被设置为 10，因为我们有 10 个类。

我们选择亚当作为我们的优化器——它非常容易使用，开箱即用。我们将损失函数设置为categorical_crossentropy，这与我们的 Softmax 兼容。训练 CNN 就像用我们的数据作为输入调用 Keras .fit()函数一样简单！

请注意，所有这些几乎都是纯粹的 Keras。真正唯一的区别是我们使用了 TensorFlow 的 Keras 库*，*，即tensorflow.keras。它非常方便，因为它包含在一个漂亮的包中 TensorFlow 的强大功能和 Keras 的易用性。太棒了。

MNIST 是一个简单的数据集，所以我们的 CNN 应该很快达到高精度。在我自己的实验中，它在 5 个时期内达到了大约 97%。

一旦训练完成，我们可以绘制损失和准确性的历史。我们再次使用纯 Keras 代码从历史中提取损失和准确性信息。Matplotlib 用于轻松绘图。

Accuracy (left) and loss (right) results from our CNN on MNIST

要评估我们的网络，我们可以使用…你猜对了，Keras .evaluate()功能！我们将应用它，然后打印出精度。

我们的 CNN 模型在测试集上达到了 98.52%的准确率。

喜欢学习？

在推特上关注我，在那里我会发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上与我联系！

树袋熊数据快速入门

原文：https://towardsdatascience.com/a-quick-primer-on-databricks-koalas-38c89369cf9f?source=collection_archive---------26-----------------------

与 Spark 数据框互动熊猫词汇

Photo by Jordan Whitt on Unsplash

在我的一个项目中，我广泛使用 Spark 来管理一些大型数据文件。尽管它通常以使用大型分布式系统的诸多好处而闻名，但它在本地同样适用于处理大量信息的项目。

我经常使用熊猫进行数据处理，但有时 Spark 会让它相形见绌。你可以对 Pandas 使用 chunksize，但是根据我的经验，即使你找到了合适的大小来管理，它也比 Spark 数据帧要慢得多，而且要消耗更多的内存。从 Pandas 迁移到 PySpark(使用 Spark 的 Python API)的挑战是导航数据帧的词汇是不同的。我真的不介意摸索着与包交互，但是 PySpark 的错误消息通常很隐晦，文档也不是很好。在某些情况下，它就像编写一个快速的 SQL 查询一样简单，但是通常情况下，您需要进行更新和创建函数，并且这些部分所需的语言变得更加复杂。

考拉入场！今年早些时候由 Databricks 推出的，考拉很容易将熊猫的相同知识应用到 Spark 数据框架中。从类似的导入开始，创建一个 Spark 会话:

import pandas as pd
import numpy as np
import databricks.koalas as ks
from pyspark.sql import SparkSession

树袋熊数据框可以通过多种不同方式创建:

# Dataframe from scratch
koala_df = ks.DataFrame(
    {'type': ['panda', 'koala', 'grizzly', 'brown'],
     'color': ['black/white', 'grey', 'brown', 'brown'],
      'score': 5, 1, 5, np.nan},
    index=[1, 2, 3, 4])# From a file
koala_df = ks.read_csv("all_the_bears.csv", header=0)# From an existing Spark dataframe
koala_df = spark_df.to_koalas()# From an existing Pandas dataframe
koala_df = ks.from_pandas(pandas_df)

作为一个树袋熊的数据框架，你可以接触到和熊猫一样的语言:

# Get first rows of dataframe
koala_df.head()# See the column names
koala_df.columns# Quick summary stats
koala_df.describe()# Convert to Numpy
koala_df.to_numpy()# Group rows
koala_df.groupby('score')

它还提供了一些在 PySpark 中很麻烦的数据清理特性:

# Drop rows with missing values
koala_df.dropna(how='any')# Fill missing values
koala_df.fillna(value=5)

我最喜欢的功能之一是轻松导出，这在 Spark 中肯定会很时髦:

# Export to csv
koala_df.to_csv("bear_bears.csv")

作为一个不断学习和寻求提高技能的人，对我来说最重要的是，它使使用 Pandas 的本地项目更容易过渡到使用 Spark 的更具可扩展性的项目。我建议你用它弄脏你的手，看看你有什么想法。现在去下载一个 10GB 的 json 文件，尽情享受吧！

对 Genevera Allen 关于机器学习“导致科学危机”的快速回应

原文：https://towardsdatascience.com/a-quick-response-to-genevera-allen-about-machine-learning-causing-science-crisis-8465bbf9da82?source=collection_archive---------18-----------------------

这不是咆哮，我是认真对待这些文章，并解释作者提出的一些观点是错误的。剧透:有些没有错。

https://dailyhive.com/toronto/ago-crowdfunding-infinity-mirrors

文章

在这里我将谈论这两篇文章:

[## 机器学习“引发科学危机”

成千上万的科学家用来分析数据的机器学习技术正在产生误导性的结果…

www.bbc.com](https://www.bbc.com/news/science-environment-47267081) [## 我们能相信使用机器学习做出的科学发现吗？

华盛顿-(2019 年 2 月 15 日)-莱斯大学统计学家 Genevera Allen 表示，科学家必须不断质疑…

www.eurekalert.org](https://www.eurekalert.org/pub_releases/2019-02/ru-cwt021119.php)

请在此之前阅读它们，这样你可以创造你自己的观点。

以下是更多评论:

[## 统计学家:机器学习正在引发一场“科学危机”

莱斯大学的统计学家 Genevera Allen 在本周一个著名的科学会议上发出了严重警告

futurism.com](https://futurism.com/machine-learning-crisis-science) [## 机器学习导致了科学领域的“再现性危机”

来自莱斯大学的统计学家说，使用机器学习技术做出的科学发现不能被自动信任。

www.technologyreview.com](https://www.technologyreview.com/the-download/612982/machine-learning-is-contributing-to-a-reproducibility-crisis-within-science/) [## 统计学家对机器学习的可靠性发出警告|数字趋势

机器学习在科技领域无处不在。但是机器学习技术真的有多可靠呢？一个…

www.digitaltrends.com](https://www.digitaltrends.com/cool-tech/machine-learning-reliability-reproducibility/)

什么没错

不要误解我的意思，文章中有很多重要的观点，我只是认为它们的理由可能不正确。

科学中存在可复制性的危机

https://www.nature.com/news/1-500-scientists-lift-the-lid-on-reproducibility-1.19970

这是真的。我们有麻烦了。在某些科学领域，只有 36%的研究被重复。这还不够。

更多数据:

https://www.nature.com/news/1-500-scientists-lift-the-lid-on-reproducibility-1.19970

他们在研究中指出:

尽管我们调查中的绝大多数研究人员都未能重现实验，但不到 20%的受访者表示，他们曾被另一名无法重现其工作的研究人员联系过。

这也是一些严重的问题，因为一小部分人试图重复研究，他们中的一些人在重复实验中失败了，但只有 20%的人告诉其他人，所以你知道你做的是错的机会是最小的。

但是正如你从上面的图片中看到的，这个问题几乎在每一个科学领域都存在。这一点以后再说。

机器学习不是防弹的

https://rarehistoricalphotos.com/testing-bulletproof-vest-1923/

如果存在危机，那就是如何正确地进行数据科学(DS)的危机。许多数据科学项目失败了，这并不是因为缺乏技能或知识(有时)，数据科学项目需要一个清晰有效的攻击计划才能成功，并需要一个运行它的方法。

大多数机器学习项目都在 DS 世界内部(以某种方式)，我们在 DS 内部运行机器学习周期的方式存在问题。

以下是一些最“有组织”的机器学习工作流:

https://eng.uber.com/scaling-michelangelo/

https://cloud.google.com/ml-engine/docs/tensorflow/ml-solutions-overview

https://medium.com/datadriveninvestor/my-machine-learning-workflow-7576f7dbcef3

https://www.gartner.com/binaries/content/assets/events/keywords/catalyst/catus8/preparing_and_architecting_for_machine_learning.pdf

你看到那里的问题了吗？

我的问题:

• 我们确定我们能重现我们得到的结果吗？
• 我们的测试足够吗？
• 我们如何版本化我们的模型？
• 我们是否对数据进行了版本控制？
• 我们是否向读者提供了足够的信息来重现我们的发现？
• 我们是否愿意回答关于我们在做什么和如何做机器学习的问题？

我认为对于大多数组织来说，答案是不。

分析什么是错的

在这里，我将看看作者提到的一些我认为不正确的事情，以及为什么。

越来越多的科学研究涉及使用机器学习软件来分析已经收集的数据[……]他们得出的答案很可能是不准确或错误的，因为软件正在识别只存在于数据集而不是真实世界中的模式。

错误是因为:

• 在大多数情况下，我们拥有的数据来自现实世界，我们在这里是说我们用来做预测模型的交易没有发生吗？
• 数据可能是脏的(大多数时候是脏的)，但我们有很多方法来改进我们拥有的数据，并了解它是否脏。
• 常见的机器学习周期包括将我们的数据分为训练、验证和测试，这些“验证”或“测试”数据集的行为就像新的“真实数据”。因为它们来自原始数据集，它们都可以被认为是正在发生的事情的“真实”表现。

通常这些研究不会被发现是不准确的，直到有另一个真正的大数据集，有人应用这些技术，并说‘哦，我的天哪，这两个研究的结果没有重叠’

错误是因为:

• 大数据不一定意味着更好的结果。这就是科学工作的方式，就像说我们在物理学上有危机，因为我发现我的结果和其他文章不一样。
• 我不是说结果有时不会错，但我们正在研究如何在发布前欺骗我们自己的系统来确保这一点。

现在科学界普遍认识到了再现性危机。我敢说，其中很大一部分确实来自科学中机器学习技术的使用。

错误是因为:

• 诚然，几乎每个科学领域都在使用机器学习来改善他们的工作方式和结果，但我不认为问题出在机器学习本身。数据问题有时会被忽视，糟糕的机器学习工作流程，糟糕的测试等等。我想说这里不是关于机器学习，而是一些人正在做的方式。
• 将再现性危机归咎于机器学习和数据科学是不了解全貌的。

这些技术中有很多都是被设计用来做预测的。他们从来不会带着“我不知道”或“我什么也没发现”的回答回来，因为他们没有被要求这么做。

错误是因为:

• 是的，这个系统是为寻找数据中的模式而设计的，但是如果你做得正确，你会明白其中一些见解是没有意义的。
• 有些系统带有‘我不知道’，当我们评估我们的模型时，我们会发现它们实际上对数据一无所知。
• 机器学习不仅仅是运行一个算法，它还包括测试它们，进行基准测试，验证它们等等。

什么不是完全错误的

作者说:

我们真的可以相信目前使用应用于大型数据集的机器学习技术做出的发现吗？在许多情况下，答案可能是，“不检查就不行”，但下一代机器学习系统的工作正在进行中，该系统将评估他们预测的不确定性和可重复性。

我认为，如果我们有一个能够理解何时出现问题的系统，我们就可以相信自己的预测。我们有这样做的工具，数据科学方法包括越来越多的:

• 数据治理；
• 数据版本化；
• 代码版本控制；
• 持续集成/部署；
• 模型版本控制。

所有现代技术的发展都是可能的，因为我们找到了处理大数据和小数据的方法。离成功构建防弹工作流还有很长的路要走，但也不远了。在这里，我提出一个非常简单的方法(**免责声明:**这是正在进行的工作):

[## 擎天柱的数据科学。第 1 部分:简介。

用 Python、Spark 和 Optimus 分解数据科学。

towardsdatascience.com](/data-science-with-optimus-part-1-intro-1f3e2392b02a)

下一步是什么？

小心你正在阅读的东西。我并不是说我掌握了真相，我只是从一个作为数据科学家一直在生产中应用机器学习的人那里给出我的意见，并且它正在努力使它更具可重复性、透明性和强大性。

感谢 Genevera 带来了这个重要的话题，我不想在这里冒犯你，只是打开一个对话。

快速浏览霍尔特-温特斯，季节性 ARIMA 和 FB 先知

原文：https://towardsdatascience.com/a-quick-run-through-of-holt-winters-sarima-and-fb-prophet-c6370c6f32f1?source=collection_archive---------15-----------------------

[## 詹费尔顿/比兴-霍尔特-温特斯-萨里玛-和-FBProphet

这是一个比较 Holt-Winters，SARIMA 和 FBProphet 输出的简单笔记本。关于参数的信息…

github.com](https://github.com/gianfelton/Comparing-Holt-Winters-SARIMA-and-FBProphet/blob/master/Holt%20Winters%2C%20SARIMA%20and%20FBProphet.ipynb)

上面的链接将带你到笔记本，下面的代码是从那里获得的。

这篇文章的目的是展示霍尔特温特斯，萨里玛和 FB 先知的快速运行。我跳过了任何关于参数调整的内容，因为这可能是多篇文章。

首先，让我们获得 Holt Winters 的导入，以及数据集。

**import** **numpy** **as** **np**
**import** **pandas** **as** **pd**
**import** **matplotlib.pyplot** **as** **plt**
**from** **statsmodels.tsa.holtwinters** **import** ExponentialSmoothing
%matplotlib inline
**import** **warnings**
warnings.filterwarnings("ignore")

dataset = pd.read_csv('AirPassengers.csv')

数据集可以在本文开头的链接中找到。这是航空乘客的数据，在网上很容易找到。

看前两行就能对形状有个概念。

对于我们的分析，我们需要将 Month 列放入索引中。

dataset['Month'] = pd.to_datetime(dataset['Month'])
dataset.set_index('Month', inplace=**True**)

这会让我们得到这个:

我们需要做的下一件事是设置索引频率，并将数据集分为训练和测试。

dataset.index.freq = 'MS'
train, test = dataset.iloc[:131, 0], dataset.iloc[131:, 0]

在这里，我们可以用训练数据创建和拟合模型。

model = ExponentialSmoothing(train, 
                             trend='add', 
                             damped=**False**, 
                             seasonal='add', 
                             seasonal_periods=12).fit()

模型准备好了，我们现在可以做预测了。

holt_pred = model.predict(start=test.index[0], end=test.index[-1])

为了查看我们的预测，我们可以将它与训练和测试数据一起绘制出来。

plt.figure(figsize=(22, 10))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test', color='r')
plt.plot(holt_pred.index, holt_pred, label='Holt-Winters', color='k')
plt.legend(loc='best', fontsize='xx-large')
plt.xticks(fontsize=18)
plt.yticks(fontsize=16)
plt.show()

接下来，我们来试试萨里玛。

**import** **statsmodels.api** **as** **sm**
**import** **itertools**
**import** **warnings**
warnings.filterwarnings("ignore")

通常情况下，我们会区分和绘制 ACF 和 PACF，以确定我们的条款。一个人应该做这些事情，但我们将跳过这个帖子。下面是对 SARIMA 订单和 seasonal_order 进行参数搜索的函数。

**def** find_best_sarima(train, eval_metric):

    p = d = q = range(0, 2)
    pdq = list(itertools.product(p, d, q))
    seasonal_pdq = [(x[0], x[1], x[2], 12) **for** x **in** list(itertools.product(p, d, q))]

    counter = 0
    myDict = {}

    **for** param **in** pdq:
        **for** param_seasonal **in** seasonal_pdq:
            **try**:
                counter += 1
                mod = sm.tsa.statespace.SARIMAX(train,
                                                order=param,
                                                seasonal_order=param_seasonal,
                                                enforce_stationarity=**False**,
                                                enforce_invertibility=**False**)

                results = mod.fit()
                myDict[counter] = [results.aic, results.bic, param, param_seasonal]

            **except**:
                **continue**

    dict_to_df = pd.DataFrame.from_dict(myDict,orient='index')

    **if** eval_metric == 'aic':
        best_run = dict_to_df[dict_to_df[0] == dict_to_df[0].min()].index.values
        best_run = best_run[0]
    **elif** eval_metric == 'bic':
        best_run = dict_to_df[dict_to_df[1] == dict_to_df[1].min()].index.values
        best_run = best_run[0]

    model = sm.tsa.statespace.SARIMAX(train,
                                      order=myDict[best_run][2],
                                      seasonal_order=myDict[best_run][3],
                                      enforce_stationarity=**False**,
                                      enforce_invertibility=**False**).fit()

    best_model = {'model':model, 
                  'aic':model.aic,
                  'bic':model.bic,
                  'order':myDict[best_run][2], 
                  'seasonal_order':myDict[best_run][3]}

    **return** best_model

输出是一个带有我们的拟合模型的字典，以及 aic、bic、订单元组和季节性订单元组。我们可以调用这个函数来检索我们的模型。

best = find_best_sarima(train, 'aic')

模型准备好了，我们现在可以做预测了。

sarima_pred = best['model'].predict(start=test.index[0], end=test.index[-1], dynamic=**True**)

为了查看我们的预测，我们可以将它与训练和测试数据一起绘制出来。

plt.figure(figsize=(22, 10))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test', color='r')
plt.plot(sarima_pred.index, sarima_pred, label='SARIMA', color='k')
plt.legend(loc='best', fontsize='xx-large')
plt.show()

考验脸书先知的时候到了

**from** **fbprophet** **import** Prophet
**import** **logging**
logging.getLogger().setLevel(logging.ERROR)

与 Holt Winters 和 SARIMA 不同，我们需要月份列作为列，而不是索引。

df = dataset.reset_index()
df.columns = ['ds', 'y']

我们的预测规模将设定为过去 12 个月。在那之前，我们的训练数据就是一切。

prediction_size = 12
train_df = df[:-prediction_size]

现在，我们可以创建模型并使其适合训练数据。

m = Prophet(seasonality_mode='multiplicative')
m.fit(train_df)

我们希望从预测中得到的是一个数据框架。值得研究一下你从中能得到什么。这是相当有用的数据。

future = m.make_future_dataframe(periods=prediction_size, freq='M')
forecast = m.predict(future)

现在我们可以绘制数据了。

single_plot = m.plot(forecast)

现在让我们用我们的训练和测试来绘制预测。

plt.figure(figsize=(22, 10))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test', color='r')
plt.plot(forecast['ds'][131:], forecast['yhat'][131:], label='Prophet', color='k')
plt.legend(loc='best', fontsize='xx-large')
plt.show()

现在让我们放大到测试阶段，看看它们是如何叠加的。

plt.figure(figsize=(22, 10))
plt.plot(holt_pred.index, holt_pred, label='Holt-Winters', color='b')
plt.plot(sarima_pred.index, sarima_pred, label='SARIMA', color='y')
plt.plot(forecast['ds'][131:], forecast['yhat'][131:], label='Prophet', color='k')
plt.plot(test.index, test, label='Test', color='r')
plt.legend(loc='best', fontsize='xx-large')
plt.xticks(fontsize=18)
plt.yticks(fontsize=16)
plt.show()

当然，任何这些模型都可能发生许多不同的参数调整。我只是想针对同一个数据集快速浏览一下。谢谢你。

用 FB Prophet 快速启动时间序列预测的实例

原文：https://towardsdatascience.com/a-quick-start-of-time-series-forecasting-with-a-practical-example-using-fb-prophet-31c4447a2274?source=collection_archive---------1-----------------------

目录

1. 介绍

• 时间序列分析
• 为什么是脸书先知？

2.先知预测模型

• 饱和增长
• 趋势变化点
• 季节性、假日效应和回归因素

3.案例研究:用 Prophet 预测广告支出

4.结案摘要

1.1 时间序列分析

时间序列分析是一种分析时间序列数据的方法，以提取数据的有意义的特征，并产生应用于商业情况的其他有用的见解。通常，时间序列数据是按时间顺序存储的一系列观察值。在跟踪业务指标、监控工业过程等时，时间序列数据往往非常突出。

时间序列分析有助于理解一组度量数据点的基于时间的模式，这对任何业务都是至关重要的。时间序列预测技术可以回答一些商业问题，比如要维持多少库存，你的电子商店预计会有多少网站流量，下个月会卖出多少产品，所有这些都是需要解决的重要时间序列问题。时间序列分析的基本目标通常是确定一个描述时间序列模式并可用于预测的模型。

传统的时间序列预测技术建立在统计模型上，这需要大量的工作来调整模型，并在数据和行业中进行预期。当一个预测模型不能如预期的那样运行时，人们必须根据具体的问题来调整方法的参数。调整这些方法需要彻底了解基本的时间序列模型是如何工作的。如果没有数据科学团队，一些组织很难处理这些预测。如果没有必要建立一个复杂的预测平台或其他服务，对一个组织来说，有一大堆期望似乎没有什么好处。

1.2 为什么是脸书先知？

脸书开发了一个开源 Prophet，这是一个预测工具，有 Python 和 r 两种版本。它提供了易于调整的直观参数。即使是对时间序列预测模型缺乏深入专业知识的人，也可以利用这一点对业务场景中的各种问题做出有意义的预测。

来自脸书先知网站:

“无论对机器还是对大多数分析师来说，做出高质量的预测都不是一个容易的问题。在创建各种业务预测的实践中，我们观察到两个主要主题:

• 完全自动的预测技术可能是脆弱的，并且它们通常太不灵活而不能结合有用的假设或启发。
• 能够做出高质量预测的分析师非常少，因为预测是一项专业的数据科学技能，需要丰富的经验。"

1.3 脸书先知的亮点

• 非常快，因为它是内置的 Stan ，一种用 C++编写的用于统计推断的编程语言。
• 一种加性回归模型，其中非线性趋势与每年、每周和每天的季节性以及假日效应相适应:1。分段线性或逻辑增长曲线趋势。Prophet 通过从数据中选择变化点来自动检测趋势的变化 2。使用傅立叶级数 3 模拟的年度季节分量。使用虚拟变量的每周季节性成分 4。用户提供的重要节假日列表。
• 对缺失数据和趋势变化稳健，通常处理异常值。
• 添加领域知识或业务见解时，调整预测的简单程序。

2.1 先知预测模型

Prophet 使用一个可分解的时间序列模型，它有三个主要的模型组件:趋势、季节性和假日。它们在以下等式中合并:

y(t)= g(t) + s(t) + h(t) + εt

• g(t):分段线性或逻辑增长曲线，用于模拟时间序列中的非周期性变化
• s(t):周期性变化(例如每周/每年的季节性)
• h(t):不定期休假的影响(用户提供)
• εt:误差项说明模型不能适应的任何异常变化
• 使用时间作为回归变量，Prophet 试图将时间的几个线性和非线性函数作为组件进行拟合。将季节性建模为附加成分与霍尔特-温特斯技术中的指数平滑法采用的方法相同。Prophet 将预测问题框定为曲线拟合练习，而不是明确地查看时间序列内每个观察值的时间相关性。

2.2 饱和增长

• 设定一个承载能力cap,根据业务场景或约束条件指定最大可实现点:市场规模、总人口规模、最大预算等。
• 饱和最小值，用列floor指定，与列cap指定最大值的方式相同。

2.3 趋势变化点

使用趋势组件时，模型可能会过拟合或欠拟合。Prophet 允许的内置变点输入增加，拟合变得更加灵活。

在这里，你可以很好地运用你的商业洞察力:节假日期间销售额的大幅增长，有目的地降低未来的成本等等。如果需要的话，用户还可以手动地将这些业务洞察力提供给变更点。在下图中，虚线代表给定时间序列的变点。

2.4 季节性、假日效应和回归因素

季节效应 s(t)由以下函数近似表示:

Prophet 有一个内置的假日功能，允许输入定制的重复事件。

最后，行动时间！

3.案例研究:用 Python 中的 Prophet 预测广告支出

我从一个数字营销平台获取了广告支出的样本数据。为了在这个案例研究中使用，我还故意做了一些修改，使它成为一个“假”数据源。

在这里，我们尝试使用过去 17 个月的数据来预测未来 30 天的广告支出。

步骤 1:导入库和数据集:

[代码]:

导入熊猫作为 PD
PD . set _ option(’ display . max _ columns '，None)

从 fbprophet 导入 numpy 作为 np
导入 Prophet

%matplotlib inline
导入 matplotlib.pyplot 作为 plt

sample = PD . read _ CSV('/…/ad _ spend . CSV ')

步骤 2:检查数据信息

[代码]:

从上面可以看出，该数据集包含了从 2017 年 6 月 1 日到 2018 年 12 月 30 日的一年半的每日广告支出。数据框中有 577 行和两列(日期和花费)。

让我们检查缺少的值:

没有遗漏的价值(从下面的表格中),这很好！👏

[代码]:

步骤 3:绘制时间序列数据

Y-Axis: Ad Spend; X-Axis: Date

从图中可以看出，水平大致不变(日均花费:20 万美元)。季节性波动和随机波动随着时间的推移在大小上大致是恒定的。这表明，使用 Prophet 建立的附加模型来描述数据可能是合适的。

第四步:建模

将数据集分为训练集和测试集。训练集包含 2017 年 6 月 1 日至 2018 年 11 月 30 日的每日广告支出，而测试集包含 2018 年 12 月 1 日至 2018 年 12 月 30 日的每日广告支出。在这里，我们希望使用训练数据集来预测未来 30 天的广告支出。

让我们在不给出任何参数的情况下单独尝试第一个模型。

[代码]:

model 1 = Prophet(interval _ width = 0.95)#默认为 80%

‘interval_width=0.95’ ，设置不确定性区间，产生预测的置信区间。

生成下面的预测图:

Y-Axis: Ad Spend; X-Axis: Date.

检查模型在历史数据上的表现总是好的。(深蓝线是预测花费数字，黑点实际上是花费数字。浅蓝色阴影是预测的 95%置信区间。)从图中可以看出，尽管该模型试图平滑地拟合所有数据点，但它未能捕捉到季节性。第一个模型仅仅通过应用 Prophet 本身并不能很好地拟合数据。

对于第二个模型，让我们应用一些业务见解来调整第一个模型。只需询问一些业务问题，如季节性趋势和假日事件影响，就可以轻松地将这些信息输入到 Prophet 中。

我们应用了:yearly _ seasonity，weekly _ seasonality，holidays (这里手动创建了假日事件，但是您也可以应用先知内置的Country Holidays和 changepoint_prior_scale ，以使模型更加灵活地适应数据点。然后，我们增加了月度季节性。

[Code]:
model 2 = Prophet(interval _ width = 0.95，yearly _ 季节性=True，weekly _ 季节性=True，holidays=us_public_holidays，change point _ prior _ scale = 2)
model 2 . add _ 季节性(name='monthly '，period=30.5，fourier_order=5，prior_scale=0.02)。

生成下面的预测图:

Y-Axis: Ad Spend; X-Axis: Date.

从图中可以看出，第二个模型能够很好地捕捉季节性和拟合历史数据。(深蓝线是预测花费数字，黑点实际上是花费数字。浅蓝色阴影是预测的 95%置信区间。)

检查趋势和季节性因素:

从年度趋势来看，支出在年初上升，在 6 月、8 月和 12 月大幅下降。每周趋势显示，工作日在这里发挥了重要作用。节日事件对广告支出有负面影响，这意味着它会导致广告支出下降，等等。你可以用业务领域的知识来检查这些信息。

第五步:验证

首先，让我们通过可视化预测线和观察线来检查拟合度:

Y-Axis: Ad Spend; X-Axis: Date.

从图中可以看出，该模型似乎能够很好地拟合数据点，尽管它没有捕捉到 12 月底的模式。但是，请记住，输入所有业务信息大约只需要 15 分钟就可以得到这样一个合理的结果。它不需要时间序列建模或机器学习知识方面的专业经验。几乎每个分析师都能做到这一点(然而，Python 或 R 的技能集是必备的。🙃)

通常，在建模评估过程中会用到一些流行的误差术语，如均方根误差(RMSE) 和平均绝对误差(MAE) 。但是我不想在这里讨论这些误差项，因为只有一个模型。(我将在下一篇文章中比较 Prophet 和经典时间序列模型时讨论这些错误术语)

让我们通过比较预测值和观察值来看看模型的性能:

[代码]:

虽然预测值比实际值高出约 13%,但预测值与下限之间的间隔能够捕捉到实际值。到目前为止，该模型做得相当好，它需要大约 15 分钟。

5.结案摘要

从现在开始，我们可以探索许多时间序列分析方法，如异常检测、用外部数据源预测时间序列等。我们才刚刚开始。

从实际例子来看，Prophet 似乎提供了完全自动化的预测，正如其官方文件所述。如果您的组织没有一个非常可靠的数据科学团队来处理预测分析，它将非常有用。它节省了您回答内部利益相关者或客户的预测问题的时间，而无需花费太多精力来基于经典的时间序列建模技术构建一个令人惊叹的模型。

下一篇文章，我将比较 Prophet 和经典的时间序列预测技术，如 ARMIA 模型，重点是效率和性能。

参考和有用的来源:

脸书先知官方文件，如果你想玩先知必须阅读。

对脸书先知的介绍，它大致解释了什么是时间序列分析，并给出了脸书先知的概述。

使用脸书的 Prophet(带 Python & R 代码)生成快速准确的时间序列预测，它包括 R 和 Python 两种语言的脸书 Prophet 简介。如果你是一个 R 用户，它可能对你有用。

使用 SQL 查询从 Pandas 数据框架中提取数据的 1 个快速技巧

原文：https://towardsdatascience.com/a-quick-tip-for-pulling-data-from-a-pandas-dataframe-using-sql-queries-bbe3b39d17d?source=collection_archive---------2-----------------------

Photo by Bruce Hong on Unsplash

想获得灵感？快来加入我的 超级行情快讯 。😎

熊猫图书馆对于任何使用 Python 分析数据的人来说都是非常棒的。

它非常容易使用，正确应用时速度很快，并且功能灵活。有了 Pandas，许多通常需要更多工作的功能，例如检索一些关于数据的基本统计数据，只需调用一个函数就可以完成！

尽管如此，有时我们更喜欢使用一种工具而不是另一种。如果你习惯于在 Excel、Tableau 或 SQL 上浏览数据，那么切换到 Pandas 仍然是一个跳跃。

如果你有 SQL 的背景，有一个很棒的 Python 库可以帮助你平稳过渡: Pandasql 。

Pandasql 允许您编写 sql 查询来查询 pandas 数据框架中的数据。这允许您避开在熊猫中必须学习大量 Python 的正常要求。相反，您可以简单地在函数调用中编写常规的 SQL 查询，并在 Pandas dataframe 上运行它来检索您的数据！

用 Pandasql 查询熊猫数据帧

安装

我们可以通过一个快速的 pip 来安装 Pandasql:

pip install pandasql

加载数据

让我们从实际的数据集开始。我们将使用seaborn库加载 iris flowers 数据集:

*import* pandasql
*import* seaborn *as* sns

data = sns.load_dataset('iris')

选择

通常，如果我们想检索数据帧中的前 20 项，我们会对熊猫做这样的事情:

data.head(20)

有了 pandasql，我们可以像在 sql 数据库上运行标准 SQL 查询一样写出它。只需将 pandas 数据帧的名称作为您正在解析的表的名称，数据将被检索:

sub_data = pandasql.sqldf("SELECT * FROM data LIMIT 20;", globals())
print(sub_data)

我们可以用 SQL 中的 WHERE 进行的常规过滤操作也是适用的。让我们首先使用 pandas 提取所有大于 5 的数据:

sub_data = data[data["petal_length"] > 5.0]

为了在 SQL 中实现这一点，某些行只需添加 WHERE 调用来实现相同的过滤:

sub_data = pandasql.sqldf("SELECT * FROM data WHERE petal_length > 5.0;", globals())

当然，我们也可以总是只选择我们想要的列:

sub_data = pandasql.sqldf("SELECT petal_width, petal_length FROM data WHERE petal_length > 5.0;", globals())

这就是如何使用 SQL 查询从 pandas 数据帧中检索数据。

喜欢学习？

在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn上与我联系！

全球旅行碳排放的研发评估

原文：https://towardsdatascience.com/a-r-api-d-assessment-of-travel-carbon-emissions-around-the-world-e1a2b8508827?source=collection_archive---------37-----------------------

作为一个关注气候的消费者，我经常想知道我从东海岸到盐湖城的日常旅行对环境的影响。在看到最近许多强调航空旅行令人惊讶的高碳排放率的头条新闻之一后，我想知道:乘坐火车、公共汽车或驾驶汽车是否比乘坐飞机更有利于地球？

谢天谢地，我偶然发现了一个由伦敦程序员 Tobe-Nicol 开发的易于使用的 API，它允许你比较各种旅行方式的碳足迹。为了地球，我准备把价格、舒适和方便放在一边，我从这个 API 中取出来比较我的选择，并提出了一系列关于沿途旅行的能源强度的问题。

什么是 API 参数？

我在 Twitter 上发现了这个 API，并且能够在 Jupyter 笔记本上做一些快速的实验，这要感谢简单明了的文档。该 API 具有以下参数:

• 活动(必需):这可以是车辆的燃料消耗，也可以是以英里为单位的行驶距离。因为我们在比较不同的交通方式，所以我将这个参数设置为“3，910”——从纽约到盐湖城的往返行程长度，以英里为单位。
• activityType:该参数表示上面输入的整数值。
• 方式:指运输方式。有几个选项可供选择:柴油汽车、汽油汽车、任何汽车、出租车、经济舱、商务舱、头等舱、任何航班、摩托车、公共汽车和轻轨。
• 燃料类型:这与上面列出的模式配对:车用汽油(也称为汽油)、柴油、航空汽油和喷气燃料。

我假设所有商业航班都使用喷气燃料，但将参数“anyFlight”与航空汽油配对，以查看这两种燃料类型之间的碳足迹是否有重大差异。我还将“柴油汽车”、“公共汽车”和“轻轨”归入柴油燃料；我假设所有其他模式使用汽油。

我首先将这些参数放入两个长度相等的列表中，将每种运输方式与每种燃料类型关联起来。我还从列表中删除了“anyCar”，因为它与“taxi”和“petrolCar”重叠，似乎是多余的。以下是列表:

list_of_modes = ['dieselCar', 'petrolCar', 'taxi', 'motorbike', 'bus', 'transitRail', 'economyFlight', 'businessFlight', 'firstclassFlight', 'anyFlight' ] 

list_of_fuels = ['diesel', 'motorGasoline', 'motorGasoline', 'motorGasoline', 'diesel', 'diesel', 'jetFuel', 'jetFuel','jetFuel', 'aviationGasoline']

我没有手动将每个参数输入到系统中，而是编写了一个函数来遍历这两个列表，并将 API 请求输出为一个字典。在导入了必要的包之后，我定义了函数，插入了列表并将输出打包成一个字典(完整的代码，请参见这篇博文所附的 jupyter 笔记本)。

#import necessary packages 
import requests
import json
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline #use carbon_slc_nyc function to create dictionary with mode of #transportation as keys and of carbon footprint as valuescarbon_footprint = {}
carbon_footprint = carbon_slc_nyc(list_of_modes, list_of_fuels)

将输出打包成字典后，我将它转换成熊猫数据框架，将列重命名为更合适的标题，并将“碳足迹”列数据转换成浮动数据，为绘图做准备。

df = pd.DataFrame(list(carbon_footprint_ground.items()))
df.rename(columns = {0 :'Type of Transport'}, inplace = True)
df.rename(columns = {1 :'Carbon_Footprint'}, inplace = True)
df['Carbon_Footprint'] = df['Carbon_Footprint'].astype('float64')

有了这个数据框架，我绘制了一个条形图来显示每种交通方式在 3910 英里的旅程中排放了多少碳。

plt.figure(figsize=(10,5))
sns.barplot(x=df_ground['Type of Transport'], y=df_ground['Carbon_Footprint'])
plt.xticks(rotation=45)

有意思。如果我要选择一种平均油耗的交通方式，坐公共汽车、火车或经济舱是我的最佳选择。然而，结果产生了许多问题。这个数据满足了一个合乎逻辑的解释，即驾驶自己的汽车不如共乘一辆车和将一辆车的总排放量分散给许多人，如在飞机、公共汽车或火车上。但是为什么一张头等舱机票比经济舱机票差那么多呢？为什么你的普通巴士在这次旅行中的碳足迹是最低的？除了电动或液化天然气燃料的城市公交车，我不认为柴油燃料的灰狗巴士或协和蔻驰巴士是非常环保的。

我认为这种分布是美国独有的，并使用了另一个参数来比较各国之间交通运输方式的平均碳足迹。API 要求输入“usa”、“gbr”和“def”来比较美国、英国和全球平均水平之间的足迹。虽然这个新参数只允许我与其他两个选项进行比较，但我想看看在美国以外行驶 3910 英里是否会改变巴士的气候优势。

世界平均水平与美国大致相同，但在英国，公共汽车污染严重得多。所有的航空旅行都差不多，这表明这个排放计算器在全球范围内标准化了排放，考虑到该行业的国际性质，这是有意义的。在英国，乘坐火车或经济舱是我的最佳选择。

如何计算排放量？

查看了这些结果后，我进一步查看了文档，以了解排放量是如何计算的。有两种方法。对于上面的代码，API 使用给定国家车辆的平均排放系数，并根据行驶距离参数调整结果。然而，API 也提供了一个更具体的计算方法，使用车辆的燃油效率。在这种方法中，API 将燃油消耗总量乘以该燃油的排放系数。排放系数通常由政府机构提供，由 IPCC 推荐。

Total Emissions = Fuel Emission Factor * Fuel Usage

为了更准确地评估我的旅行选择，我需要知道每种交通方式的引擎消耗了多少能量。我从第一次描述性分析中挑选了三个最佳选项，并将结果限制在美国。在接下来的 API 调用中，我加入了我妈妈的 Suburu 的燃油效率(每加仑汽油 33 英里)，一辆典型的灰狗巴士(每加仑柴油 6 英里)，以及一架空客 A220 100 的每加仑喷气燃料英里数。

空客的油耗颇具挑战性，因为官方的维基百科燃油经济性数据要么以千克/公里列出，要么以每座加仑英里数列出，这意味着我要么必须将千克/公里数转换为每加仑英里数，要么将每座加仑英里数乘以空客 A220 100 的座位数(我假设我会飞完全程——SLC 和纽约是受欢迎的目的地)。我不确定 API 的碳计算器是否会自动将燃料消耗参数转换为公共交通的每座加仑英里数，所以我双向调用数据，输入每加仑英里数和每座加仑英里数，以免重复计算。不管怎样，这形成了一个有趣的对比。

通过快速的谷歌搜索，我发现空客 A220s 可以有 120 到 160 个座位。我选了 140 个座位。

#miles per seat gallon divided by seats on the plane 
A220_mpg_A = (85.6 / 140) 
suburu_mpg_A = 33 
greyhound_mpg_A = 6A220_gal_A = 3910/A220_mpg_A
suburu_gal_A = 3910/suburu_mpg_A
greyhound_gal_A = 3910/greyhound_mpg_Alist_gallons_A = [suburu_gal_A, greyhound_gal_A, A220_gal_A]
list_fuel_type_A = ['motorGasoline', 'diesel', 'jetFuel']#call API and create dataframe 
carbon_footprint_A = {}
carbon_footprint_A = carbon_fuel(list_gallons_A, list_fuel_type_A) 
df_A = pd.DataFrame(list(carbon_footprint_A.items()))
df_A.rename(columns = {0 :'Fuel_Type'}, inplace = True)
df_A.rename(columns = {1 :'Carbon_Footprint'}, inplace = True)
df_A['Carbon_Footprint'] = df_A['Carbon_Footprint'].astype('float64')#now adjust to miles per seat gallon
A220_mpg_B = 85.6 
suburu_mpg_B = 33 
#adjusting to miles per seat gallon with 55 seats
greyhound_mpg_B = 6 * 55 A220_gal_B = 3910/A220_mpg_B
suburu_gal_B = 3910/suburu_mpg_B
greyhound_gal_B = 3910/greyhound_mpg_Blist_gallons_B = [suburu_gal_B, greyhound_gal_B, A220_gal_B]
list_fuel_type_B = ['motorGasoline', 'diesel', 'jetFuel']#call API and create dataframe
carbon_footprint_B = {}
carbon_footprint_B = carbon_fuel(list_gallons_B, list_fuel_type_B)
df_B = pd.DataFrame(list(carbon_footprint_B.items()))
df_B.rename(columns = {0 :'Fuel_Type'}, inplace = True)
df_B.rename(columns = {1 :'Carbon_Footprint'}, inplace = True)
df_B['Carbon_Footprint'] = df_B['Carbon_Footprint'].astype('float64')

结果如下:

在绘制了第一次 API 调用的结果后，很明显，驾驶我自己的飞机从纽约到盐湖城并返回会产生很大的环境影响，就像驾驶我自己的灰狗巴士一样。一个人开我妈妈的 Suburu 显然更有效率，因为它小得多。

然而，当在载满乘客的飞机或公共汽车上传播高 MPG 和碳排放时，很明显，公共汽车的碳足迹最低。尽管飞机的载客量是公共汽车的两倍多，从纽约到 SLC 的速度也比任何公路旅行都快，但公共汽车的优势在于使用污染更低、能源密度更低的燃料，同时仍将气候成本分摊到 55 个人身上。我妈妈的 Suburu 虽然拥有汽油驱动汽车市场上最高效的发动机之一，但无法与之相比——即使我搭载了两个搭便车的人(我算过)。

结论

如果限制个人的碳排放是你的首要任务，那就不要开车。尽管在全国范围内移动一辆公共汽车或商业客机需要更多的能源(和更多的碳)，但当你选择乘火车、公共汽车或飞机旅行时，你会将气候成本分摊给更多的人。这种分析可以通过更多的细微差别和粒度数据集来改进，但很明显，在高层次上，激励更多的人乘坐大型车辆从 A 地到 B 地应该在制定脱碳战略中发挥作用。

Github 链接:【https://github.com/kbaranko/SLC-to-NYC-Carbon-Costs

具有改进的协同过滤的闪亮产品推荐器

原文：https://towardsdatascience.com/a-r-shiny-application-with-improved-collaborative-filtering-48a82955da6a?source=collection_archive---------10-----------------------

我对购物篮分析的看法——第 3 部分，共 3 部分

Photo by NeONBRAND on Unsplash

概观

最近我想学习一些新的东西，并挑战自己进行端到端的市场篮子分析。为了继续挑战自己，我决定将我的努力成果展示给数据科学界。

这是的第三个也是最后一个帖子:

Part 1 :(可在此处找到)探索并清理适合用推荐算法建模的数据集* Part 2*:(可在此处找到*)应用各种产品推荐模型***

介绍

在我为这个项目进行研究的过程中，我遇到了几件作品，所有这些都为我闪亮的应用程序提供了巨大的灵感和洞察力。特别要提到的是 Jekaterina Novikova，她的 电影推荐系统 的博士，以及迈克尔·哈斯勒教授，他创造了一个 笑话推荐系统 。他们分别使用了MovieLens和Jester数据集，这是推荐者实验室的默认设置。

然而，两位作者都使用了 recommenderlab 作为他们闪亮应用的引擎，众所周知，这需要很长时间来计算大型数据集的预测。Jekaterina 为使计算更易于管理而采用的解决方案是对数据集进行采样，以减小评级矩阵的大小。然而，这可能证明对预测准确性有害。

幸运的是，我遇到了由 Philipp Spachtholz 开发的这个出色的 Kaggle 内核 ，他不仅对一个非 Kaggle 数据集进行了显著的分析，而且对我来说至关重要的是，他还使用一个快得多的协作过滤代码构建了一个基于 Shiny 的 图书推荐系统 。

Philipp 从这篇由smart cat Consulting撰写的博客文章中获得了灵感，这篇文章描述了如何使用改进的协同过滤代码以及包含在配套 Github 库中的所有相关功能。特别地，存储库包括用于计算相似性矩阵的simililarity_measures.R函数，以及具有协同过滤算法和预测函数的cf_algorithm.R文件。

在这个项目的最后一部分，我将描述如何在我闪亮的实现中使用这些函数。

加载包

**library(tidyverse)            
library(knitr)
library(Matrix)
library(recommenderlab)**

数据

在这一节中，我使用第二部分中的retail数据集来准备闪亮应用程序所需的数据文件。请注意，在第 2 部分的中，我执行了额外的格式化步骤，删除了多次包含相同商品的订单。

****glimpse(retail)
## Observations: 517,354
## Variables: 10
## $ InvoiceNo   <dbl> 536365, 536365, 536365, 536365, 536365,
## $ StockCode   <chr> "85123A", "71053", "84406B", "84029G",
## $ Description <fct> WHITE HANGING HEART T-LIGHT HOLDER, 
## $ Quantity    <dbl> 6, 6, 8, 6, 6, 2, 6, 6, 6, 32, 6, 6, 8, 6,
## $ InvoiceDate <dttm> 2010-12-01 08:26:00, 2010-12-01 08:26:00,
## $ UnitPrice   <dbl> 2.55, 3.39, 2.75, 3.39, 3.39, 7.65, 4.25,
## $ CustomerID  <dbl> 17850, 17850, 17850, 17850, 17850, 17850,
## $ Country     <fct> United Kingdom, United Kingdom, Un...
## $ Date        <date> 2010-12-01, 2010-12-01, 2010-12-01,
## $ Time        <fct> 08:26:00, 08:26:00, 08:26:00, 08:26:00,****

对于应用程序部署，我需要创建 2 个数据文件:past_orders_matrix和item_list。

past_orders_matrix是包含过去订单历史的用户项目稀疏矩阵。所有计算都需要这个闪亮的server.R文件。

****past_orders_matrix <- retail %>%
    # Select only needed variables
    select(InvoiceNo, Description) %>%     # Add a column of 1s
    mutate(value = 1) %>% # Spread into user-item format
    spread(Description, value, fill = 0) %>%
    select(-InvoiceNo) %>%    # Convert to matrix
    as.matrix() %>%

    # Convert to class "dgCMatrix"
    as("dgCMatrix")****

我保存文件，以便在应用程序中使用。

****saveRDS(past_orders_matrix, file = "past_orders_matrix.rds")****

item_list列出了所有可供购买的产品。这将输入闪亮的ui.R文件，使产品列表可供选择。

****# Creating a unique items list
item_list <- retail  %>% 
    select(Description) %>% 
    unique()****

我保存列表，以便在应用程序中使用。

****saveRDS(item_list, file = "item_list.rds")****

改进的协同过滤

为了展示Improved Collaborative Filtering是如何工作的，我将在 第 2 部分item-based CF中找到的表现最好的模型装配在同一个定制订单上。我也在做同样的事情，用recommenderlab来比较这两种方法的性能。

首先，我使用同样的 6 个随机选择的产品重新创建了定制订单。

****customer_order <- c("GREEN REGENCY TEACUP AND SAUCER",
                     "SET OF 3 BUTTERFLY COOKIE CUTTERS",
                     "JAM MAKING SET WITH JARS",
                     "SET OF TEA COFFEE SUGAR TINS PANTRY",
                     "SET OF 4 PANTRY JELLY MOULDS")****

接下来，我将把new_order放入一个 user_item 矩阵格式中。

****# put in a matrix format
    new_order <- item_list %>% # Add a 'value' column with 1's for customer order items
    mutate(value = 
               as.numeric(Description %in% customer_order)) %>% # Spread into sparse matrix format
    spread(key = Description, value = value) %>% # Change to a matrix
    as.matrix() %>%    # Convert to class "dgCMatrix"
    as("dgCMatrix")****

然后，我将new_order添加到past_orders_matrix作为它的第一个条目。

****# binding 2 matrices
   all_orders_dgc <- t(rbind(new_order,past_orders_matrix))****

现在，我需要设置一些改进的 CF 工作所需的参数。

****# Set range of items to calculate predictions for
   items_to_predict <- 1:nrow(all_orders_dgc)  # I select them all# Set current user to 1, which corresponds to new_order
   users <- c(1)# Set prediction indices
   prediction_indices <- as.matrix(expand.grid(items_to_predict, 
                                                   users = users))****

我加载算法实现和相似性计算。

****# Load algorithm implementations and similarity calculations
source("cf_algorithm.R")
source("similarity_measures.R")****

最后，我可以用Improved CF来拟合item-based CF模型，并检查运行时间。

****start <- Sys.time()
recomm <- predict_cf(all_orders_dgc, 
                       prediction_indices,
                       "ibcf", FALSE, cal_cos, 3, 
                       FALSE, 4000, 2000)
end <- Sys.time()
cat('runtime', end - start) ## runtime 0.630003****

哇！真是快如闪电！

现在让我们用recommenderlab运行item-based CF模型并比较性能。

****# Convert `all_orders` to class "binaryRatingMatrix"
    all_orders_brm <- as(all_orders_dgc, "binaryRatingMatrix")# Run run IBCF model on recommenderlab
start <- Sys.time()
recomm <- Recommender(all_orders_brm, 
                      method = "IBCF",  
                      param = list(k = 5))
end <- Sys.time()
cat('runtime', end - start)## runtime 12.75939****

速度增加了大约 20 倍，这与菲利普·斯帕茨在他的工作中所看到的一致。这对闪亮的应用程序来说是相当有前途的！

部署应用程序

对于应用程序的部署，我采用了 概念验证 的方法。我的重点是执行速度，以及如何正确完成本文中显示的所有计算，从而为应用程序的server端提供动力。这反映在目前的极简用户界面上，它仅仅以产品选择和完成购买操作按钮为特色。**

这里有一个 产品推荐者 的链接供你细读。

我将继续在用户界面上工作，增加改善客户体验的功能，使它更像一个最终产品。

以下是我目前正在考虑的一些想法:

1. 添加产品价格和选择产品数量的能力
2. 添加产品图片 —有 4000 种商品可供选择，这本身就是一个迷你项目！
3. 能够使用产品名称的第一个字母从列表中选择项目
4. 使用shinyJS和/或HTML tags增强用户界面的视觉效果
5. 考虑到目前并非所有产品组合都返回建议，研究如何实施混合方法

评论

我真的很喜欢这个市场篮分析项目。推荐系统是一个迷人的研究领域，有着真实世界的应用，我觉得我只是触及了这个主题的表面。

我也非常感谢学习闪亮应用程序开发的诀窍，这比我最初想的要简单得多:反应性是一个让你头脑清醒的关键概念，它迫使你从用户界面和服务器是一个硬币的两面的角度来思考。

对我来说，主要的考虑是潜力是巨大的:即使是在线的小公司也能从实施最基本的推荐系统中受益。只需几行代码，就可以改善客户体验，提高客户忠诚度，促进销售。

代码库

完整的 R 代码可以在我的 GitHub 简介上找到

参考

• 有关推荐的 lab 包，请参见:https://cran.r-project.org/package=recommenderlab
• 有关推荐者实验室软件包简介，请参见:https://cran . r-project . org/web/packages/re commender lab/vignettes/re commender lab . pdf
• 关于 SmartCat 改进的协作过滤器，请参见:https://www . SmartCat . io/blog/2017/Improved-r-implementation-of-Collaborative-filtering/

原载于 2019 年 4 月 15 日https://diegousei . io*。*

使用 Twitter 数据和 Gephi 对特朗普弹劾前后的政治极化进行可视化评估

原文：https://towardsdatascience.com/a-radiography-of-trumps-impeachment-86284710ae1d?source=collection_archive---------24-----------------------

The conversation on Twitter around Trump’s impeachment on December 18th

围绕导致美国历史上第三次总统弹劾的事件，美国在网上是如何互动的？

美国是两极化的，这是事实。但是这种两极分化会是什么样子呢？没有比 Twitter 这个全球数字对话的圣地更好的地方来回答这个问题了，所以我从 12 月 18 日周四开始下载了 50 万条推文，那天众议院举行了弹劾唐纳德·j·特朗普的最终投票。结果既美好又令人生畏。

Pic by History HD on Unsplash

先看方法论。正如我提到的，我使用 Twitter 公共 API 连接到 Twitter 服务器，并获取所有包含通用关键字的推文，如“特朗普”或“弹劾”。不过，这个过程很漫长，我那台含咖啡因的MacBook 花了几天时间才达到 50 万条推文的大关(不用说，在那段时间里，用电脑几乎不可能完成任何事情)。当然，还有其他方法，比如实时传输推文，这更容易，计算成本也更低，但我无法在那个周五下午回到过去，因为太晚了，无法实时捕捉推文。

为了连接到 Twitter API，你需要创建一个开发者档案并申请一个许可。这个过程并不长，如果你做得对，你将很快拥有自己的驾照。

有了推文之后，是时候做一些网络理论了。想想看:如果参与对话的每个帐户都被表示为空间中的一个点(比如说一个节点)，如果每次他们中的任何一个通过回复、转发或引用与另一个进行交互时，我们都在他们之间画一条线，那么我们最终会用我们称之为边的东西将一堆节点链接在一起。因此，我们可以将 12 月 18 日发生的对话表示为一个社交网络，更好的是，我们可以用图表来直观地评估正在发生的事情。

An example of a network graph - Taken form the Gephi Blog on Wordpress.

我的绘图工具是 Gephi ，一个开源的网络绘图软件(关于它有大量的在线教程)。您需要传递给 Gephi 的只是一个简单的 csv 文件，它有两列:生成交互的帐户(“源”列)和接收所述交互的帐户(“目标”列)。在那之后，你可以自由地摆弄你的网络，并以你喜欢的任何方式来表现它。我是这样做的:

1. 选择 ForceAtlas2 布局。
2. 计算模块化得分。
3. 设置节点标签，其大小与每个节点的入度成比例。

技术插曲

让我们一步一步地重温一下:

第一，布局。有几种算法可以计算网络中的各种基本方面，例如，某些节点的中心位置如何，它们之间应该相距多远或多近，在网络中可以找到哪些节点群，边的长度或弹性如何，等等。对于当前的绘图任务，我选择了 ForceAtlas2 ，顾名思义，它是 ForceAtlas 的续集，更适合更大的网络。本质上，该算法采用了几个物理定律来达到力之间的稳定平衡或平衡状态:它模拟节点之间的排斥，就好像它们是带电粒子一样(遵循库仑定律，同时使边缘吸引它们的节点，就像弹簧一样(遵循胡克定律)。

第二，模块化。这是一种通过给出一个分数来检测网络中的社区的方法，该分数决定了网络分成模块的强度。高度模块化意味着网络在社区或模块中具有密集连接的节点，而与其他社区或模块中的其他节点的链接相当松散或稀疏。

最后，标签。至关重要的是，我们知道哪些社交网络代理在给定时间是最相关的，因此我们可以简单地在图上包括他们的标签(例如，他们的 Twitter 处理程序)。但是，想象一下，一个有几十万个标签的图表:它看起来会很混乱，无法辨认。要解决这个问题，我们可以简单地要求 Gephi 计算每个节点的平均加权度。

什么现在？节点的度是与它交互的边的总和:例如，在我们的例子中，转发了一个帐户获得的消息或转发了一个帐户发出的消息。鉴于我们的图形本质上是有向的，我们非常关心每个动作的方向。换句话说，我们最关心的是哪个账号转发得最多(入度)或者哪个账号转发得最多(出度)。所述度的权重简单地与节点的边的重要性或质量相关。例如，当两个特定节点之间存在重复交互时，该边将具有较高的权重，因此在给定这种权重的情况下将考虑其程度。当你有了度数，你可以让 Gephi 相对于它们的度数来标记节点，这样网络中最相关的节点将是最可见的。

我们选择了加权入度来展示图表中每个节点的重要性:我们希望通过谁被转发、回复或引用最多来了解谁对对话的影响最大。

*La pie ce de resistance，*我们的图表。

毫不奇怪，有两个定义明确的主要模块或社区，它们对应于政治辩论的两极，民主党人(用蓝色表示)和共和党人(用红色表示)。

The Democratic community.

民主社区在对话中展示了大约十个重要人物。他们从政治家到作家到新闻主播(佩洛西当然也在其中)。在社区的右侧可以看到 ABC。民主团体代表了图表中超过 50%的节点。

The bridge between the two communities.

对话中两个明显的政治极端之间的桥梁展示了一个有趣的关键节点:C-SPAN。

American rapper YG has his own alt-module.

美国说唱歌手 YG 有自己孤立的另类社区，是除了两个主要社区之外唯一值得一提的代表，拥有图表中超过 6%的节点。这主要是由他的明确声明引起的:

Source: https://twitter.com/YG/status/1207349489255628800

@evadutizena catching some lights with a meme.

一项荣誉要归功于@evadutizena，她通过一个迷因，整合了网络中几乎 2.5%的节点。恭喜你，德洛丽丝！

Source: https://twitter.com/evadutizena/status/1207436447898320897

最后，社交网络图中的共和党社区，有超过 30%的节点。

The Republican community.

在这里，只有大约八个帐户似乎抓住了眼球。与民主党社区不同，共和党本身有一些明确的活动和影响力，还有其他政治家、节目主持人、喜剧演员和作家，以及总统的儿子本人。说到这，你能找到川普吗？

现在是时候看看整个数字对话的画像了，这是对当今美国政治的准确描述，也是 2020 年美国政治格局的基石。尽情享受吧！

Portrait of the polarization of the American political debate around Trump’s impeachment. All rights reserved.

乐章结尾部

我觉得这张图讲述了一系列的故事，所有的故事都同样相关，特别是在 2020 年和总统大选之际:

1. 虽然两极分化很明显，但是两极分化本身早就有了。这不是什么新鲜事，但在过去的几十年里，它一直在增长。
2. 共和党社区仅拥有对话图中 30%多一点的节点，这一事实不足以说明今天美国共和党人占总人口的比例是 30%。因为我们只处理 Twitter 数据，所以存在很大的选择偏差，这不允许我们对美国的一般人口做出统计上无偏见的推断。
3. 民主党社区包含了网络中超过 50%的节点，这表明，在 12 月 18 日，更多倾向于民主党的行动者支持弹劾程序，或者至少，他们在 Twitter 上的数字对话中更加直言不讳。
4. 在数字辩论中仍然有替代叙事的空间，尽管与两个主要叙事相比很小，但它代表了政治观众/光谱的第三部分。
5. 没有办法根据这个图表来预测结果，我们还得等着看参议院会发生什么。然而，2020 年的选举可能会完美地向两个方向发展，民主党被众多强大但不同的候选人分裂，或者一个规模稍小但更加团结的共和党(如图所示)连任，这是美国历史上第一次被弹劾的总统。

别忘了留下评论，祝大家新年快乐！

在推特上关注我！

一位放射科医生对斯坦福 ML 集团 MRNet 数据的探索

原文：https://towardsdatascience.com/a-radiologists-exploration-of-the-stanford-ml-group-s-mrnet-data-8e2374e11bfb?source=collection_archive---------16-----------------------

医学影像领域知识的数据探索

这篇文章回顾了最近发布的斯坦福 MRNet 膝关节 MRI 数据集和竞赛。由于我是一名高级放射科住院医师，我将专注于通过基础领域知识探索数据，解决非医生可能会感到困惑的数据分布方面的问题。我还将包含一些 Python 代码，感兴趣的人可能会发现这些代码对自己探索数据集很有用。

介绍

斯坦福 ML 小组最近发布了他们的第三个医学影像检查公共数据集，称为 MRNet，可以在这里找到。从网站:

MRNet 数据集由斯坦福大学医学中心进行的 1，370 次膝关节 MRI 检查组成。数据集包含 1104 个(80.6%)异常检查，其中 319 个(23.3%)为前交叉韧带撕裂，508 个(37.1%)为半月板撕裂；标签是通过从临床报告中手工提取获得的。

这个数据集伴随着斯坦福 ML 小组工作的发表，可以在这里找到。他们再次举办了一场比赛，以推动医学成像自动化分析的创新。

参赛作品将在私人测试数据集上进行评估，评估标准如下:

排行榜报告了异常检测、ACL 撕裂和半月板撕裂任务的平均 AUC。

你可以在网站上找到更多关于比赛的细节。我这篇文章的目标如下。

目标

• 基本医学成像术语
• 竞赛的数据集和任务概述
• 基础膝关节解剖学
• 目标膝盖病变的例子
• 潜在“坏”数据点的示例
• 用于检查数据的 Python 代码

基本医学成像术语

磁共振成像(MRI)是一种横截面成像模式，这意味着 2D 图像或多或少是在不同的成像平面中连续采集的。MRNet 数据集中包含的标准成像平面有:轴位、冠状位和矢状位。MR 图像可以在任何平面上获得，但这超出了本文的范围。

MR 图像通过射频(RF)脉冲序列(脉冲序列或——简单地说——序列)采集。不同的序列被设计成产生一个信号，该信号可以被采集和处理以揭示生物组织中不同的信号强度模式。T1 加权、T2 加权和质子密度(PD)加权是肌肉骨骼成像中使用的 3 种核心脉冲序列类型。

了解这 3 个序列的脂肪、水和肌肉的基本信号强度模式是很有帮助的(下面的表)。还有一个有用的知识是皮质骨和纤维结构(如韧带、半月板)在所有序列上都应该是黑色的。由于脂肪和水在 T2 和 PD 序列上都是中等亮度，因此脂肪饱和度 (fat-sat)是一种可用于增强水在这些序列上的外观的技术。

异常液体信号(无论是数量还是位置)通常是肌肉骨骼病理(或任何病理，就此而言)的关键指标，因此液体敏感图像确实是膝关节 MRI 的主力。

Source: https://www.fifamedicinediploma.com/lessons/radiology-mri/

附加术语:

• 切片 : 一个单独的图像通常被称为切片
• 系列:在给定的平面上，用给定的脉冲序列采集的一整叠图像
• 视场(FOV) :图像的空间覆盖范围

竞赛的数据集和任务概述

警告:我还没有审查所有提供的数据。这些评论是基于对数据的有限的初步审查。

同样，数据可以通过上面的链接获得。你必须先在斯坦福 ML 集团注册一个账户，然后你会收到一封链接到数据的电子邮件。共享数据是被明确禁止的，即使是和比赛中的队友。

下载并解压缩数据后，您应该会看到这个目录树:

.
├── train
│ ├── axial
│ ├── coronal
│ └── sagittal
├── train-abnormal.csv
├── train-acl.csv
├── train-meniscus.csv
├── valid
│ ├── axial
│ ├── coronal
│ └── sagittal
├── valid-abnormal.csv
├── valid-acl.csv
└── valid-meniscus.csv

*.csv文件包含箱子的标签。train和valid子目录下的*.npy文件是维度为(slices, x, y)的 NumPy 数组。在所有检查中，x和y尺寸始终为 256 x 256，且int值范围为 0 至 255。这意味着像素数据已经被斯坦福 ML 小组标准化了。

*注意:*每个检查的图像堆栈可以包含不同数量的图像，并且每个检查对于任何给定的平面可以具有不同数量的切片。这对于医学影像数据来说是完全正常的。

为了不与竞赛规则相冲突，我将避免在标签中张贴重叠的汇总数据表。但是，有必要注意以下几点:

1.有许多不正常的检查不包含前交叉韧带或半月板撕裂。

2.包含前交叉韧带撕裂和半月板撕裂的检查远远多于仅包含前交叉韧带撕裂的情况。

这些发现表明，数据集对于现实世界中会遇到的情况可能是相当现实的。

其原因如下:

• 膝关节核磁共振成像通常不用于无症状患者。
• 膝关节核磁共振检查中最常见的异常是在软骨和下面的骨头中。
• 由于损伤机制和撕裂 ACL 所需的力，半月板也经常受伤。

图像数据的预览

尽管该网站声明数据集中的 MRI 膝关节检查的标准协议包括各种序列，但我迄今为止查看的数据包含每个病例的三个序列:

• 冠状 T1 加权图像无脂肪饱和

• 矢状 T2 加权图像和脂肪饱和(流体敏感)

• 轴向 PD 加权图像和脂肪饱和(流体敏感)

基础膝关节解剖学

我将在这里包括一个图像的膝盖解剖的基本概述。对于那些有兴趣了解更多关于膝关节在核磁共振成像上的外观的人来说，这个网站(下图的来源)可能会有所帮助。

Source: http://www.freitasrad.net/pages/atlas/Knee/Knee.html

目标膝盖病变的例子

1. 半月板撕裂:下图矢状 T2 fat-sat 图像显示正常的内侧半月板前角(绿色箭头 —图像左侧的黑色三角形)和内侧半月板后角撕裂(红色箭头 —图像右侧的黑色三角形内的小点亮信号)。注意:这张图片上还有几处其他异常，但这些不在本文讨论范围之内。

Sagittal T2-weighted image with fat saturation

2.前十字韧带撕裂:

首先，我将展示一个正常前交叉韧带的矢状 T2 脂肪卫星图像。注:图像中前交叉韧带正上方信号增强的波纹代表腘血管的搏动伪影。

Normal ACL

现在，前交叉韧带撕裂。在下图中，红色箭头指向一个信号强度相对较高的长方形结构，纤维韧带的正常暗带(见上图)缺失。

Torn ACL

潜在“坏”数据点的示例

同样，在撰写本文时，我还没有完整地研究这些数据。然而，我观察到一些潜在的“坏”数据点，增加了这场竞争的挑战。我说潜在不好，因为其中一些可能会被深度学习模型处理得相当好。在这里，我展示了几个例子，并简要解释了为什么这些代表了麻烦的数据点。

我观察到的一个问题是矢状图像堆栈，其中膝盖的大部分在 FOV 之外，导致图像堆栈对于比赛任务基本上无用，因为相关的解剖结构都不可见。这可能是由于 MRNet 数据集中的治疗图像预处理中的错误，或者是由于源数据的问题。到目前为止，这是一个很少遇到的问题。

潜在“坏”数据的另一个原因对于医学成像来说相当典型。在一些情况下，我看到图像伪影严重到使人阅读图像非常困难。然而，深度学习算法可能会“通读”工件，就像我们放射科医生为了病人护理的利益而试图做的那样。这里，腘动脉的搏动导致在膝关节水平的整个图像中出现混叠伪影。

Extensive pulsation artifact can make images hard to read/analyze

用于查看数据的 Python 代码

下面的代码将把一个案例中的数据加载到 NumPy 数组的dict中，然后由KneePlot类使用它来生成下面的*.gif中显示的交互式绘图。

结论

我希望这篇文章能让你对 MRNet 数据集有所了解。也许更重要的是，我希望你已经了解了一点关于膝盖核磁共振成像的知识。虽然我还没有探索它的全部，但我认为这个数据集对 ML 社区来说是一个有价值的资源。我期待着阅读通过比赛开发的模型。感谢您的阅读！