TowardsDataScience 博客中文翻译 2020（一百四十六）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

Python 中的基本日期时间操作

原文：https://towardsdatascience.com/basic-datetime-operations-in-python-2d706be82c63?source=collection_archive---------8-----------------------

布鲁克·拉克在 Unsplash 拍摄的照片

有时，处理包含日期和时间的数据可能是一项乏味的工作，谢天谢地，有这种内置的方式来帮助我们完成这项工作。Python 提供了一个日期时间模块，使我们能够以多种方式操作日期和时间。

在这个模块中，我们需要查看五个主要的对象类，根据我们想要做的工作，我们最终会需要它们。之后，我们将讨论一些解释课程任务的例子。这些类别如下-

1. datetime.date :它允许我们在不干扰时间(月、日、年)的情况下操作日期
2. datetime.time :它允许我们在不干扰日期(小时、分钟、秒、微秒)的情况下操作日期
3. datetime.datetime :它允许我们操作日期和时间的组合(月、日、年、小时、秒、微秒)。
4. datetime.tzinfo :处理时区的抽象类。这些类型的对象是不可变的。例如，考虑不同的时区和/或夏令时。
5. datetime.timedelta :两个日期、时间或日期时间实例之差；该决议案

创建日期时间对象

由于 datetime includes 使我们能够处理日期和时间，因此，首先让我们看看这个对象的行为。 datetime 既是一个模块，也是该模块中的一个类。我们将从 datetime 模块中导入 datetime 类，并打印当前的日期和时间以便仔细查看。我们可以使用 datetime 的. now()函数来做到这一点。我们将打印我们的日期时间对象。

# import datetime class from datetime module
from datetime import datetime

# get today's date
today = datetime.now()
print(today)

输出如下所示:

现在，如果我们想看类型，我们可以写:

print('Type :- ',type(today))

所以我们从上面看到今天确实是一个 datetime 类的 datetime 对象。

从上面的例子我们可以了解到日期和时间对象应该如何工作。日期只适用于日期，不包括时间，反之亦然。

dt_nw = datetime.now()

# to get hour from datetime
print('Hour: ', dt_nw.hour)

# to get minute from datetime
print('Minute: ', dt_nw.minute)

从 datetime 中，我们还可以使用它的。 weekday() 起数字的作用。但是我们可以使用日历模块和一种叫做**的方法将它转换成文本格式(即星期一、星期二、星期三……)。**日 _ 名()。

首先，我们将导入日历模块，然后找出月份和年份，并执行上述操作。

# import calendar module
import calendar

my_date= datetime.now()
# To get month from date
print('Month: ', my_date.month) 

# To get month from year
print('Year: ', my_date.year) 

# To get day of the month
print('Day of Month:', my_date.day)

# to get name of day(in number) from date
print('Day of Week (number): ', my_date.weekday())

# to get name of day from date
print('Day of Week (name): ', calendar.day_name[my_date.weekday()])

处理时区

现在我们需要了解两种 datetime 对象；

1. 感知——感知对象具有处理模糊时间所需的知识，它包含时区和夏令时信息，因此它可以相对于其他感知对象定位自己。
2. 天真——这个更容易处理。因为它不包含不同时区和夏令时的信息。操作仅仅依赖于程序。

对于需要 aware 对象的程序， datetime 、 date 和 time 对象有一个可选的时区信息属性， tzinfo 。但是 tzinfo 是一个抽象类。处理这个问题时，您必须决定到底需要哪些方法。因为这完全取决于对 aware datetime 对象的使用。

但是处理时区通过 pytz 模块变得很容易。它帮助我们处理跨时区转换，并处理使用该转换的地方的夏令时。让我们看看这个例子:

# import timezone from pytz module
from pytz import timezone

# Create timezone UTC
utc = timezone('UTC')

# Localize date & time
loc = utc.localize(datetime(2020, 1, 1, 3, 50, 0))
print(loc)

# Convert localized date & time into Asia/Dhaka timezone
dhaka = timezone("Asia/Dhaka")
print(loc.astimezone(dhaka))

# Convert localized date & time into Europe/Berlin timezone
berlin = timezone('Europe/Berlin')
print(loc.astimezone(berlin))

我们使用了 localize() 函数向 datetime 对象添加时区位置。函数 astimezone() 将现有的本地时区转换为任何其他指定的时区。

时间跨度和时差

有时在一个程序中，我们可能需要指定剩余时间或时间跨度。在这种情况下，我们总是可以使用时间增量对象。我们可以利用这一点，通过对日期或时间进行加减来操纵它们。让我们看一些例子:

#import timedelta
from datetime import timedelta
print(timedelta(days= 365, hours= 12, minutes= 30))

# get current time
now = datetime.now()
print ("Today's date & time: ", str(now))

#add 365 days to current date
future_date_after_one_year = now + timedelta(days = 365)
print('Date & time after one year: ', future_date_after_one_year)

#subtract 7 days from current date
seven_days_ago = now - timedelta(days = 7)
print('Date & time seven days ago: ', seven_days_ago)
# print('seven_days_ago object type: ', type(seven_days_ago))

这就是我们如何处理时间增量对象。在大多数科学脚本/案例中，delta 总是意味着两个事物之间的差异。

strftime() & strptime():日期格式

datetime 包含两个方法， strptime() 和 strftime() ，用于将对象从字符串转换为 datetime 对象，反之亦然。 strptime( )可以读取带有日期和时间信息的字符串并将其转换为 datetime 对象， strftime() 将 datetime 对象转换回字符串。

# import datetime
from datetime import datetime

date_str = "2 january, 2020"

# format date
date_obj = datetime.strptime(date_str, "%d %B, %Y")

print("Today's date is: ", date_obj)

现在让我们看看 strftime() 的用法:

# current date and time
now = datetime.now()

# format time in HH:MM:SS
time = now.strftime("%H:%M:%S")
print("Time:", time)

# format date
date_time = now.strftime("%m/%d/%Y, %H:%M:%S")
print("Date and Time:",date_time)

处理时间戳

在处理数据时，处理时间戳是非常常见的。也许你想以 Unix 时间戳格式存储你的数据。我们将使用 datetime 的 timestamp() 函数来完成这项工作。

# get current date
now = datetime.now()

# convert current date into timestamp
timestamp = datetime.timestamp(now)

print("Date and Time :", now)
print("Timestamp:", timestamp)

类似地，我们可以从时间戳转换成日期和时间对象。

timestamp = 1577971124.673931

#convert timestamp to datetime object
date_obj = datetime.fromtimestamp(timestamp)

print("Today's date & time:", date_obj)

熊猫日期时间对象

Pandas 是 python 中数据科学项目的主要成分，这是理所当然的。它使得处理日期和时间比其他任何方法都容易。

使用 to_datetime() 将日期和时间文本字符串转换成 pandas Datetime 对象要容易得多。

这个函数很擅长通过自动检测字符串的格式将字符串转换成 Python datetime 对象，而不需要我们使用 strftime 模式来定义它。

# import pandas module
import pandas as pd

# create date object using to_datetime() function
date = pd.to_datetime("2nd of jan, 2020")
print(date)

还有很多操作可以使用带有日期和时间数据的熊猫来完成。但这需要另一个自己的职位。然而，我希望这篇文章提供了关于我们可以用 datetime 模块和 pandas 进行的操作的初步概念。这里用到的所有代码都可以在我的 GitHub 账号https://github.com/muniah上找到。

原载于 2020 年 1 月 2 日 https://muniah.com。

A/B 测试的基本要素——用 Python 代码模拟

原文：https://towardsdatascience.com/basic-elements-of-a-b-testing-with-python-code-to-simulate-2b7f342f5ac6?source=collection_archive---------20-----------------------

照片由 Unsplash 上的 battle creek 咖啡烘焙师拍摄

什么更重要？你花了多少天进行 A/B 测试？或者你每天的样本量？较大的样本量比运行 A/B 测试很多天要重要得多。这篇文章将通过模拟向你展示为什么会这样。

A/B 测试就像咖啡拔火罐；你想客观地决定哪种咖啡更好。这是这两个过程的目的，但是 A/B 测试确实试图做到客观。

假设你正在与一家大型电子商务公司合作。你的客户群平均每天购买 170 美元。网站设计团队希望引入一个更精简的网站，加载速度更快，他们假设这个新的网站设计不会降低平均订单价值。销售团队对此表示怀疑——由于这个新网站在主页上展示的产品较少，他们认为这将降低平均订单价值；他们不想在所有客户群中推出这个新网站。

你带着你的统计工具进来了:“为什么我们不在人口的一个小样本上测试这个，而不是在整个人口上？”

“听起来是个好主意”，web 团队和销售团队都同意，委托你设计测试，即 A/B 测试。

测试需要的东西:

1. 您将需要一个控制样本—将向这些客户展示旧网站，他们将继续以相同的平均订单价值 170 美元购买
2. 您还需要一个目标样本—您将向这些客户展示新网站
3. 你必须选择目标样本的样本大小——最小的样本大小，因为销售团队认为这个新网站有风险
4. 你将不得不选择几天来测试这个理论——同样是最少的，因为销售团队真的不急于改变网站，并且通常你想尽快知道这是否会对你的客户的购买习惯产生不利影响

从中心极限定理中你知道，你进行测试的天数越多，它就能更好地反映总体情况。但是您希望用最少的天数测试新特性，并尽快得出结论。

你运行一些模拟。

设置问题和模拟

但是，让我们后退一步，假设我们的控制样本和目标样本完全相同。本质上，我们没有推出一个新的网站。你也可以把这个场景表述为“我们将会看到，如果新网站没有对顾客购买产生影响，会发生什么”。我们一次随机抽取两个客户样本，并试图了解他们之间的差异是否纯粹是由于统计上的随机性。

换句话说，这是在问“如果你从同一个人群中随机抽取样本，他们的平均值有多不一样？”

因此，在本文的其余部分，让我们假设我们从相同的人群中抽取，也就是说，目标组和控制组都显示相同的网站。

让我们生成一个随机的指数分布(为什么是指数分布？我们在关于样本大小、*、和均值、、*的中心极限定理文章中讨论过，让我们这样做两次——一次针对对照样本，另一次针对(伪)目标样本。我说“伪”是因为他们都来自同一个人群，这是我们的客户群，显示在同一个网站上。每次这样做时，我们都会注意到对照样本和目标样本之间均值的差异:

δμ=对照样本的平均值—目标样本的平均值

那我们就这样做 n 次。

这是对照样本和目标样本之间的均值差异δμ，已绘制出来。

δμ(对照样本的平均值-目标样本的平均值):1)随着 A/B 测试天数的增加(列中向下)以及 2)随着样本量的增加(行中向右)。注意 x 轴上的范围:当您在一行中从左到右移动时，这个 x 轴范围会缩小，但是当您沿着任何一列向下移动时，这个范围或多或少会保持不变。

这些图说明了什么？

以下是一点一点的细节。但是，如果您有困难，请跳过这一步，跳到“模拟观察总结”部分。

增加天数:

1. 左上图是当你两次吸引 1000 名顾客(控制和目标)时，你这样做 5 天。控制平均值和目标平均值之间的差值绘制在 x 轴上。
   *所以你看到δμ(对照样本的均值——目标样本的均值)可以在负$5 和正$5 之间。也就是说，对照样本的平均值可能比目标样本的平均值少或多 5 美元。
2. 如果你看第二行最左边的图，它显示了如果你重复上述实验 15 天会发生什么——也就是说，你抽取 1000 个客户的随机样本对，每个样本对 15 天，然后你看这些对的平均值之间的差异。你可以看到，在这里，大部分时间δμ都在正负 5 美元之间。两个样本(从同一人群中抽取)的平均值相差高达 5 美元。
3. 事实上，您一直将天数增加到左下角的 60 天，同时保持 1000 名客户的相同样本量
   *您会看到目标组和控制组平均值之间的差异仍然有很大变化——它可以在$+/-20(x轴的范围)之间变化，但大多数数据仍然在$+/-5 之间。
4. 所以这是一个问题。我们希望δμ接近 0 美元，因为两个样本都来自我们的同一批客户。

增加样本中的客户数量:

1. 我们来看右上方的图。它显示了如果您绘制 5 天的 100，000 个客户对，并计算这些分布对的平均值之间的差异
   *您会立即看到控制平均值减去目标平均值现在非常低，降至-0.75 美元至+$0.50 美元(x 轴范围)。也就是说，在所有 5 天的测试中，您的控制平均值和目标平均值的差异不会超过+/-1.00 美元。太好了！请记住，控制样本和目标样本来自相同的分布，因此它们的平均值应该大致相同
2. 事实上，如果您使用相同的 100，000 个客户样本对进行 60 天的测试，就像右下角的图一样，您会看到控制平均值和目标平均值之间的差异仍然不会发生很大变化，实际上，它们仍然只相差 1.00 美元

模拟观察总结

1. 这就是你看到的模式。如果您沿着任何特定的列向下，其中样本大小保持不变，天数增加，您看不到控制和目标平均值之间的差异δμ改善很多——X 轴上的范围保持不变。
2. 如果沿着任何给定的行从左到右，也就是说，如果在保持天数不变的情况下增加样本量，那么您会看到控制平均值和目标平均值之间的差异迅速缩小。请记住，我们希望这样，因为控件和目标都来自同一个客户群——还没有引入网站更改。

A/B 测试参数估计—天数和样本量

这个故事的寓意——只要超过 5 天左右，A/B 测试的天数不会有太大影响。但是你每天看的顾客数量确实有很大的影响。

A/B 测试的天数

理想情况下，至少应该是 30 天。为什么是 30？嗯，30 这个数字背后并没有什么魔力，但在工业上，这已经足够了。从的中心极限定理帖子中，我们看到我们需要抽取足够数量的样本，以确保我们有一个良好的样本均值正态分布。但是没有企业会让你运行 30 天的 A/B 测试，大多数企业不会。

往往一个企业只会给你 7 天时间做结论。你确实可以在上面看到的短短 7 天内做出结论，如果你有一个好的样本量，我们将在下面讨论。

A/B 测试的目标群体的规模

剩下的就是目标群体(和对照组)的客户数量。这在很大程度上取决于你的企业愿意处理多少利润。在这个例子中，如果企业愿意说“由于纯粹的机会，5 美元的正负差异对我们没有影响”，那么您可以使用 1000 名客户的样本规模。如果企业要求他们可以处理不超过 1 美元的差异，那么您将不得不要求 100，000 名客户进行 A/B 测试，以确保您看到的任何差异都不是随机的。

但是，根据你公司的风险偏好，你如何得到准确的样本量呢？

我们可以参考这篇关于中心极限定理的文章。
在那里我们看到:

由于我们的总体是均值为 170 美元的指数分布，并且指数分布的均值和标准差相等，因此我们有:

现在你明白了为什么上面的一组图显示了当你从第一列移动到第三列时沿着 x 轴的分布减小了:当
样本量= 10(第一列)时
，σ(样本均值)=170/sqrt(10 )=$5.40
样本量= 10⁴(第二列)，σ(样本 mean)=170/sqrt(10⁴)=$1.70
样本量= 10⁵(第三列)，σ(样本 mean)=170/sqrt(10⁵)=$0.54

重新排列上述公式，我们得到样本量估计的方程:

其中，
σ_population 可以近似为总体均值，因为我们通常得到的是近似的指数分布，并且企业通常对总体均值有一个概念。在这种情况下，业务人员会告诉您，日平均订单价值为 170 美元。
σ_(样本均值)是你企业的风险偏好。例如，如果他们说“我们可以处理控制组和目标组之间不超过$2.00 的差异”，那么σ_(样本均值)=$2
在这个例子中，那么你的样本大小将是(170/2) =7225

其他注意事项

做完这一切后，你需要确保企业没有进行促销，或者你可以通过某种方式为你的控制和目标群体控制这些变量。然后，你必须确保你没有在你的目标群体或控制群体中意外地选择了更保守、更喜欢升职的人，反之亦然。但是如果你做了一个好的，真正随机的选择，那么这个问题就解决了。在后面的文章中，我将讨论如何选择一个真正随机的样本。

在下一篇文章中，我会告诉你如何评估你的 A/B 测试。

Python 代码再现情节

您可以使用以下代码生成本文中的图表:

**import** matplotlib.pyplot **as** plt
**import** matplotlib.patches **as** mpatch
**import** statistics
**import** numpy **as** np

**def** two_exponential_distributions(n, samp_size, mu):
    *# do n times a sample of samp_size each with same mean sigma to see how they differ
    # returns a list of tuples:
    # each element in the list corresponds to one of the two distributions: so list is of length2
    # each element in the list is a tuple; teh tuple returns the number of samples, the sample size, the mean and the stddev* del_m = []
    m1arr = []
    m2arr = []
    **for** ii **in** range(0, n):
        s1 = np.random.exponential(mu, samp_size)
        m1 = np.mean(s1)
        m1arr.append(m1)

        s2 = np.random.exponential(mu, samp_size)
        m2 = np.mean(s2)
        m2arr.append(m2)

        del_m.append(m1 - m2)

    musig = []
    musig.append((n, samp_size, statistics.mean(m1arr), statistics.stdev(m1arr), del_m))
    musig.append((n, samp_size, statistics.mean(m2arr), statistics.stdev(m2arr), del_m))
    **return** musig

**def** simulate_n_sampsize():
    nn = [5, 15, 30, 60]
    ss = [1000, 10000, 100000]
    fig = plt.figure(figsize=(10, 7))
    fig.suptitle(**'Difference of Average Order Value Between Control and (psuedo)Target'**)
    fig.text(0.5, 0.04, **'Number of Customers'**, ha=**'center'**)
    fig.text(0.04, 0.5, **'Number of Days'**, ha=**'center'**, rotation=**'vertical'**)
    l1 = mpatch.FancyArrow(0.3, 0.08, 0.4, 0,
                           transform=fig.transFigure, figure=fig)
    l2 = mpatch.FancyArrow(0.08, 0.7, 0, -0.3,
                           transform=fig.transFigure, figure=fig)

    fig.lines.extend([l1, l2])

    plt.subplots_adjust(hspace=0.5)
    ii = 1
    nsmusig = []
    **for** n **in** nn:
        **for** s **in** ss:
            ax = fig.add_subplot(4, 3, ii)
            musig = two_exponential_distributions(n, s, 2000)
            ax.set_title(**'n={}, s={}'**.format(n, s))
            ii += 1
            nsmusig.append(musig[
                               0])  *# control sample's n, samp_size, statistics.mean(m1arr), statistics.stdev(m1arr) and del_m between control and target* nsmusig.append(musig[
                               1])  *# target sample's n, samp_size, statistics.mean(m1arr), statistics.stdev(m1arr) and del_m between control and target* plt.hist(musig[0][4], color=**'blue'**, edgecolor=**'black'**, bins=int(n), histtype=**'step'**)
            **for** item **in** ([ax.title, ax.xaxis.label, ax.yaxis.label] +
                             ax.get_xticklabels() + ax.get_yticklabels()):
                item.set_fontsize(8)
    plt.show()

    print(nsmusig)
    print([x[2] **for** x **in** nsmusig])
    print([x[2] **if** (x[0] == 5) **else** 0 **for** x **in** nsmusig])

    print(**'some means'**)
    **for** n **in** nn:
        print(n)
        print([x[2] **for** x **in** nsmusig **if** x[0] == n])
    print(**'some stddevs'**)
    **for** n **in** nn:
        print(n)
        print([x[3] **for** x **in** nsmusig **if** x[0] == n])

simulate_n_sampsize()

实现更高效机器学习的基础特征工程—下一步

原文：https://towardsdatascience.com/basic-feature-engineering-to-reach-more-efficient-machine-learning-part-2-bc8e70d00343?source=collection_archive---------38-----------------------

克里斯多夫·伯恩斯在 Unsplash 上拍摄的照片

关于 ML 的一个重要的事情是，大多数机器学习算法在只有原始数据的情况下不会有效地执行。你不能仅仅将一组特性输入到模型中，然后期望它表现良好。尤其是当数据集中有非数字数据时，机器学习模型不会像预期的那样工作，并且准确率非常低。

在这篇文章中，我们将看看如何从一组干净的特性中获得更有意义的特性。为了更好地理解，我将使用一个基本的分类问题来解释检测网络 DDOS 攻击的概念。我以前写过一篇文章，介绍了特征工程的基本步骤，包括清理原始数据的不同方法，以及将非数字数据嵌入数字格式的一些基本方法。可以参考更好的理解(基础特征工程达到更高效的机器学习)。

衍生有意义的特征

衍生要素应在清理现有原始要素后执行。那些清除的数据可以是数字格式，也可以是非数字格式。衍生特征的格式取决于上下文。如果您打算直接将这些嵌入数据输入到模型中，那么根据您的模型，它们最好是数字格式。几乎所有机器学习模型的成功都取决于我们如何向模型呈现数据，也取决于训练。

衍生特征并不是一项困难的任务，但是需要对上下文或问题域有很好的理解。推导建立在上下文之上。比方说，对于您要检测的条件，有某个参数超过了阈值。但是如果没有很好地理解问题领域，您可能不知道这些参数、阈值或关系。此外，我们可能需要根据问题推导出多个这样的条件。我们拥有的功能越多，模型的性能就越好。现在让我们看看一些流行的方法来获得这样的特征。

1。通过参数之间的加/减

一种流行的技术是在参数之间加减。这种加减可以在同一列的参数内进行，也可以在不同列之间进行。

2。统计某个窗口内的发生次数

另一种流行的技术是计算一个窗口内的出现次数。大多数情况下，这用于检测是否超过阈值。如果您的输入涉及时间戳，则可以应用时间窗口(即在特定时间窗口内计算发生的次数)。

3。获取参数之间的比率

在某些情况下，两个或多个参数之间的比率代表该领域的某些特征。但是要识别这样的模式，你必须是该领域的专家，或者必须做大量的实验。

4。通过计算统计参数

像平均值、中值、众数和标准差这样的统计参数代表了领域的行为或特征。通过根据领域计算此类参数，您可能能够获得新的特征。然而，需要一些数学背景来容易地识别这种模式。

5。二元决策

二元决策的答案要么是“0”，要么是“1”。通过回答二元问题可以得出新的特征。例如，我们可以通过检查某个参数是否超过阈值来创建一个特性列。特征值将为代表问题答案的“0”或“1”。

6。交叉特征

特征交叉是最流行的技术之一，尤其是涉及到线性问题时。基本思想是通过将两个或多个现有特征相乘(即交叉)形成一个新特征。

上面提到的只是一些流行的获得特征的技术。你可以根据问题域随意定义和衍生任何特性。

在创建了新的特征并为模型选择了最好的特征之后，我们就可以训练模型了。然而，包括原始特征和新特征在内的所有特征可以采用不同的比例。特别是当我们应用像特征交叉或后比率这样的技术时，这些新值将比现有值具有更大的范围。所以我们必须把所有的柱子放在同一个尺度上。

正常化

规范化的最终目标是将所有值放在相同的范围内，从而提高模型的性能。有几种方法可以实现标准化。其中最著名的是。

缩放意味着将列的值转换成标准范围，通常是 0 到 1。但是，只有当列的值近似均匀地分布在整个范围内，并且我们知道数据列的上限和下限时，缩放才有效。Python scikit 学习库提供了缩放值的函数。

如果缩放不适用，您可以尝试一种其他方法，如特征裁剪、对数缩放或 z 分数。要素裁剪将超出特定阈值的值限制为固定值。对数标度通过计算数据的对数，将大范围的值压缩到小范围内。Z-score 表示偏离值集平均值的标准偏差数。

现在让我们通过一个例子来更好地理解特性的派生。

实例研究

让我们考虑一种 DDOS 攻击情况，攻击者试图使系统的目标用户无法使用资源。在 DDOS 攻击中，攻击者通常使用多台计算机向单个系统发送大量请求。通过考虑 DDOS 攻击的基本定义，我们可以确定以下两个特征(这两个不是仅有的两个特征)。

1. 攻击者从一台计算机上发送同一组请求的频率比平时高得多。
2. 攻击者使用位于不同位置的多台计算机发送请求。

首先，让我们考虑与这两个特征相关的原始特征。通常，一个网络请求包含一个时间戳(如果没有可以用 AI 引擎记录)，消息体和包括源 IP 的报头。通过考虑第一个特性，我们可以创建一个特性来计算某个时间窗口内的请求数量。通常，特定网络资源有一个定义的阈值。这个阈值可以随时、因资源、因用户等而改变(这是我们必须使用 AI 来定义这样的阈值的一个原因)。我们可以定义一个特定长度的时间窗口，并计算该窗口内的请求数。输出编号是该模型的一个新功能。

通常，网络请求的报头包含请求的源 IP。IP 地址可用于检测原始系统的位置(位置、国家、州和许多其他事物的坐标可通过使用合适的数据库或 API 服务从 IP 地址获得)。通过考虑第二个特征，我们可以引入一个新的特征来检测在某个时间间隔内相同请求的位置变化。

考虑到上述两个特征，下面列出了检测 DDOS 攻击的两个衍生特征。请注意，上述两个特征并不是控制 DDOS 攻击的唯一两个特征，这两个特征的行为可能会因环境而异。此外，两个特征下面的并不是控制 DDOS 攻击特征的唯一两个特征，因此可能不足以检测攻击情况。

1. 5 分钟时间窗口内对资源路径的请求数。
2. 同一请求在 10 秒时间窗口内的位置变化距离。

结论

大多数机器学习算法在只有原始数据的情况下无法有效执行，因此需要应用特征工程技术。在本文中，我们已经确定了为机器学习模型派生新特征的重要性，以及如何在示例研究的帮助下派生有意义的特征。此外，我们还确定了标准化的重要性，以便将所有特征置于相同的范围内。作为结论，我想建议特征工程是大多数机器学习模型的核心。

Python 中的线性回归算法:一步一步

原文：https://towardsdatascience.com/basic-linear-regression-algorithm-in-python-for-beginners-c519a808b5f8?source=collection_archive---------6-----------------------

杰里米·毕晓普在 Unsplash 上的照片

学习线性回归的概念，并使用 python 从头开始开发一个完整的线性回归算法

最基本的机器学习算法必须是单变量线性回归算法。如今，有如此多的先进的机器学习算法、库和技术可用，以至于线性回归似乎并不重要。但是学习基础知识总是一个好主意。这样你会非常清楚地掌握这些概念。在本文中，我将逐步解释线性回归算法。

想法和公式

线性回归使用预测的非常基本的想法。公式如下:

Y = C + BX

我们在学校都学过这个公式。提醒一下，这是一条直线的方程。这里，Y 是因变量，B 是斜率，C 是截距。通常，对于线性回归，它被写成:

这里，“h”是假设或预测的因变量，X 是输入特征，θ0 和θ1 是系数。θ值是随机初始化的。然后使用梯度下降，我们将更新θ值以最小化成本函数。下面是成本函数和梯度下降的解释。

成本函数和梯度下降

成本函数决定了预测与原始因变量的距离。这是它的公式

任何机器学习算法的思想都是最小化代价函数，使假设接近原始因变量。为此，我们需要优化θ值。如果我们分别基于θ0 和θ1 对代价函数取偏导数，就会得到梯度下降。为了更新θ值，我们需要从相应的θ值中减去梯度下降:

偏导数之后，上面的公式将变成:

这里，m 是训练数据的数量，α是学习率。我说的是一元线性回归。这就是为什么我只有两个θ值。如果有很多变量，那么每个变量都会有θ值。

工作示例

我要用的数据集来自吴恩达在 Coursera 上的机器学习课程。下面是用 Python 一步步实现线性回归的过程。

1. 导入包和数据集。

import numpy as np
import pandas as pd
df = pd.read_csv('ex1data1.txt', header = None)
df.head()

在该数据集中，第 0 列是输入要素，第 1 列是输出变量或因变量。我们将使用上面的直线公式使用第 0 列来预测第 1 列。

2.根据第 0 列绘制第 1 列。

输入变量和输出变量之间的关系是线性的。当关系是线性时，线性回归效果最好。

3.初始化θ值。我将θ值初始化为零。但是任何其他值也应该起作用。

theta = [0,0]

4.根据之前讨论的公式定义假设和成本函数。

def hypothesis(theta, X):
    return theta[0] + theta[1]*Xdef cost_calc(theta, X, y):
    return (1/2*m) * np.sum((hypothesis(theta, X) - y)**2)

5.根据数据帧的长度计算训练数据的数量。然后定义梯度下降的函数。在这个函数中，我们将更新θ值，直到成本函数最小。它可能需要任意次迭代。在每次迭代中，它将更新 theta 值，并且利用每次更新的 theta 值，我们将计算成本以跟踪成本。

m = len(df)
def gradient_descent(theta, X, y, epoch, alpha):
    cost = []
    i = 0
    while i < epoch:
        hx = hypothesis(theta, X)
        theta[0] -= alpha*(sum(hx-y)/m)
        theta[1] -= (alpha * np.sum((hx - y) * X))/m
        cost.append(cost_calc(theta, X, y))
        i += 1
    return theta, cost

6.最后，定义预测函数。它将从梯度下降函数中获得更新的θ，并预测假设或预测的输出变量。

def predict(theta, X, y, epoch, alpha):
    theta, cost = gradient_descent(theta, X, y, epoch, alpha)
    return hypothesis(theta, X), cost, theta

7.使用预测函数，查找假设、成本和更新的θ值。我选择学习率为 0.01，我将运行这个算法 2000 个时期或迭代。

y_predict, cost, theta = predict(theta, df[0], df[1], 2000, 0.01)

最终的θ值为-3.79 和 1.18。

8.在同一个图表中绘制原始 y 和假设或预测 y。

%matplotlib inline
import matplotlib.pyplot as plt
plt.figure()
plt.scatter(df[0], df[1], label = 'Original y')
plt.scatter(df[0], y_predict, label = 'predicted y')
plt.legend(loc = "upper left")
plt.xlabel("input feature")
plt.ylabel("Original and Predicted Output")
plt.show()

根据公式，假设图是一条直线，并且该直线穿过最佳位置。

9.记住，我们在每次迭代中跟踪成本函数。让我们画出成本函数。

plt.figure()
plt.scatter(range(0, len(cost)), cost)
plt.show()

正如我之前提到的，我们的目的是优化θ值，以最小化成本。正如你从这张图表中看到的，成本在开始时急剧下降，然后变得稳定。这意味着θ值如我们预期的那样得到了正确的优化。

我希望这有所帮助。下面是本文中使用的数据集的链接:

[## rashida 048/用 Python 进行机器学习

通过在 GitHub 上创建一个帐户，为 rashida 048/用 Python 进行机器学习开发做出贡献。

github.com](https://github.com/rashida048/Machine-Learning-With-Python/blob/master/ex1data1.txt)

以下是其他一些机器学习算法的解决方案:

Python 中的多元线性回归逐步

使用优化功能的 Python 逻辑回归

实践数据科学的基础项目

原文：https://towardsdatascience.com/basic-projects-to-practice-data-science-1e93d7b60799?source=collection_archive---------41-----------------------

从这 6 个基础数据科学项目开始您的数据科学之旅

斯科特·格雷厄姆在 Unsplash 上拍照

数据科学是目前最令人兴奋的领域之一，对专家的需求正在增长。网上有很多数据科学课程。学习数据科学的困难在于，它需要大量的实践才能适应现实生活中的数据科学项目。

在过去的几个月里，我一直在学习数据科学并探索这个领域。值得一提的是，我不是数据科学家(我的主要领域是 Web 开发)，但我喜欢所有编程的东西，我想尝试一下，并找到更多关于各种数据科学技术和算法的信息。

我想知道数据科学是否真的像人们所说的那样令人兴奋和强大。我将在另一篇文章中回答我对它的看法，但现在，我想与您分享我参与的六个项目，如果您是数据科学新手或想尝试一下，它们将帮助您扩展您的数据科学知识。如果你是数据科学的新手，或者只是想多探索一下这个领域，那么下面的项目将非常适合你。

在这 6 个项目中，您将发现在从事数据科学项目时可能面临的最常见问题。从数据清理，通过标准化和规范化、降维、特征工程到回归、计算机视觉、自然语言处理(NLP)到神经网络，使用流行的 Python 库，如 Pandas、Numpy、scikit-learn、Tensorflow、Keras、TextBlob 等。完成此列表中的所有项目后，您将拥有流行的数据科学技术和算法的实践经验。

如果您从未从事过数据科学项目，这也是一些介绍性的文章，它们将帮助您设置您的计算机，为您提供从事这些项目所必需的一切，并向您展示如何使用 Git 和 Github，以便您可以在那里存储您的项目。

你需要知道的事情

对 Python 的基本理解和知识会很有用。在这些文章中，我没有涉及 Python 编程语言。如果您不了解 Python，我建议您在开始使用这些项目之前，至少要熟悉基本的 Python。例如，你可以在 Coursera 上完成人人编程(Python 入门)课程。

一旦你掌握了 Python 的基础知识，你就可以开始从事这些项目了。先前的数据科学知识是有帮助的，但不是必需的。所有项目都包含对项目中使用的所有算法、概念和 Python 数据科学库的解释。我会解释代码和项目的每一步，所以你可以理解什么和为什么你必须为每个项目做。

虽然用于所有项目的 Jupyter 笔记本也可以在 Github 上获得，并且欢迎您使用它们，但是我建议您自己编写代码，不要复制/粘贴或使用 Jupyter 笔记本。这样你会学到更多，记住更多的信息。

简介和设置

(1) 如何设置你的计算机进行数据科学

在开始从事数据科学项目之前，您需要在计算机上设置一些东西。幸运的是，有一些免费的开源工具可以让这个过程变得非常简单。

(2)Git 和 GitHub 简介

在本教程中，我将解释一些基本步骤，这些步骤将使您能够创建您的 GitHub 资源库，将您的本地文件添加并提交到 Git，并将它们推送到 GitHub 上的在线资源库。

基础数据科学项目

(1) 分析医药销售数据

在本项目的第一部分，您将学习如何将数据集从文件加载到 Pandas (Python 数据操作和分析库),以及如何执行统计分析并在 Pandas 数据框中查找特定信息。在本项目的第二部分，您将学习使用回归(一种能够发现自变量和因变量之间关系的技术)根据历史销售数据预测未来销售。您将使用三种不同的回归算法:线性回归、多项式回归和支持向量回归(SVR)。在训练您的回归模型之前，您将缩放数据并将其分为训练数据和测试数据，这两者都是非常常见和重要的数据科学技术。缩放将实现更好的模型性能，由于分割数据，我们可以在不同的数据集上训练我们的模型，然后计算模型的准确性分数，以查看它在另一组数据上的表现。因为您使用不同的回归模型，所以您也可以使用 VotingRegressor 来获得更好的结果。VotingRegressor 是一种集合方法，可拟合多个回归变量，并对各个预测进行平均，以形成最终预测。您将使用一个流行的 Matplotlib 库来可视化数据和回归预测。熟悉和练习 Pandas 数据操作和 Matplotlib 可视化非常重要，因为它们在许多数据科学项目中非常常见，用于操作数据和可视化结果。回归也是许多数据科学项目中非常常见和有用的技术。

以下是项目资源:

中篇:https://towards data science . com/analyzing-pharmaceutical-sales-data-in-python-6 ce 74 da 818 ab

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/1-analyzing-Pharmaceutical-Sales-Data

(2) 利用数据科学和机器学习预测泰坦尼克号幸存者

在本项目中，您将使用泰坦尼克号幸存者的数据集来构建一个模型，根据乘客的性别、年龄、乘客等级等特征来预测泰坦尼克号灾难中的幸存者和死者。将数据从文件加载到 Pandas 数据框后，您将执行探索性数据分析。探索性数据分析使我们能够了解我们的数据集中有哪些特征，它们是如何分布的，以及我们的数据集中是否有任何缺失值。更好地理解数据将有助于我们进行数据预处理和特征工程。在预处理阶段，您将清理数据并填充任何缺失的值。您还将从现有要素中提取一些新要素(通过使用数据宁滨等技术)，并移除不需要且对模型性能没有影响的要素。为了训练模型，您将使用两个新的分类器模型:KNeighborsClassifier 和 DecisionTreeClassifier。然后，您将比较这些模型的性能。在这个项目中，你还将学习 K-Fold 交叉验证技术。这种技术有助于更好地使用数据，减少偏差，并让我们更好地了解模型的性能。

以下是项目资源:

中篇:https://towards data science . com/data-science-titanic-challenge-solution-DD 9437683 DCF

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/5-Titanic-Challenge

(3) 计算机视觉导论与 MNIST

在这个项目中，你将开始学习两个非常重要的数据科学概念；计算机视觉和神经网络。MNIST 是一个手写数字的数字数据库。您将构建并训练一个神经网络来识别手写的数字图像。您将使用 Keras，它是专门针对神经网络的 Python 库。您将看到不同类型的神经网络层激活功能以及神经网络的其他功能和配置。您还将学习如何在文件中保存和加载您的训练模型。您还将使用 Keras 函数to _ categorial，该函数将整数转换为二进制类矩阵，从而提高神经网络的性能。在本练习中，您将学习如何使用 Keras 创建、训练和使用简单有效的神经网络，并评估其性能。

以下是项目资源:

Medium 文章:https://Medium . com/swlh/introduction-to-computer-vision-with-mnist-2d 31 c 6 f 4d 9 a 6

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/3-Introduction-to-Computer-Vision-with-MNIST

(4) 利用 Tensorflow 神经网络识别猫和狗

在这个项目中，你将继续使用计算机视觉和神经网络，并使用 Keras 和 Tensorflow 构建一个稍微复杂一点的网络。你在这个项目中的任务是建立、训练和测试一个神经网络，该网络将对猫和狗的图片进行识别和分类。你会有三组猫狗的图像:训练、测试、有效；训练对神经网络模型进行训练，在训练期间对模型进行有效性验证，然后测试对训练好的模型进行测试。每组包含不同的猫和狗的图像。

以下是项目资源:

Medium 文章:https://Medium . com/swlh/recogning-cats-and-dogs-using-neural-networks-with-tensor flow-6f 366 ad 30 DBF

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/9-Cats-and-Dogs

(5)Python 中的图像人脸识别

在这个项目中，你将处理一个不同的但也很常见和有趣的计算机视觉问题，即人脸识别。您将使用face _ recognitionPython 库进行人脸识别，使用 Python 图像库(PIL) 进行图像处理。你不仅可以在测试图像上识别出已知的人脸，还可以用 PIL 在图像上标记人脸。

以下是项目资源:

Medium 文章:https://Medium . com/an-idea/image-face-recognition-in-python-30 b6b 815 f 105

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/4-Face-Recognition

(6)Python 中的 Twitter 情绪分析

在这个项目中，您将了解数据科学的另一个重要概念，即自然语言处理(NLP) 。使用 Python NLP 库 TextBlob ，您将对一个选定的 Twitter 帐户最近的一些推文进行情感分析。要访问 tweets，您首先要设置 Twitter 开发者 API 账户。然后，您将创建一个虚拟环境并安装项目所需的库。您将使用 Tweepy Python 库向 Twitter 开发者 API 认证并下载 tweets。然后，您将清理 tweets 并执行一些基本的 NLP。你将计算每条推文的主观性和极性，并将每条记录标记为正面或负面。然后，您将计算该帐户的积极推文的百分比，并在图表上显示推文的类别。最后，你将生成一个单词云，以查看你正在分析的推文中使用的主题和最常用的单词。

以下是项目资源:

中篇:https://towards data science . com/Twitter-perspection-analysis-in-python-1 bafebe 0 b 566

GitHub 上的项目:https://GitHub . com/pj online/Basic-Data-Science-Projects/tree/master/8-Twitter-情操-分析

总而言之，您将学习和实践以下数据科学技术、算法和概念:

• 熊猫
• Matplotlib
• Python 图像库(PIL)
• 数据预处理
• 特征工程
• 特征缩放
• 训练/测试数据分割
• 宁滨数据
• 统计数字
• 投票回归变量
• 线性回归
• 逻辑回归
• 多项式回归
• 支持向量回归
• k 近邻分类器(KNN)
• 决策树分类器
• 带 Keras 的神经网络
• 人脸识别(计算机视觉)
• 主成分分析
• k 倍交叉验证
• 使用 accuracy_score 指标进行性能验证
• 十二岁
• WordCloud
• 文本二进制大对象
• 词干分析
• 标记化(计数矢量器)

我希望这个基本数据科学项目列表是有用的，它将帮助您了解更多信息并练习您的数据科学技能。

编码快乐！

还没有订阅媒体？考虑报名成为中等会员。每月只需 5 美元，你就可以无限制地阅读媒体上的所有报道。订阅媒介支持我和媒介上的其他作者。

基本航海指南

原文：https://towardsdatascience.com/basic-seaborn-guide-d963a81cb608?source=collection_archive---------31-----------------------

您的数据科学工具

照片由 F rank Mckenna 在 Unsplash 上拍摄

Seaborn 是一个可视化库，位于 matplotlib 之上，使它看起来更好看，并增加了一些额外的功能。数据可视化允许数据科学家向非科学读者传达他们的发现和结果，所以如果你想进入数据科学领域，这是一个很好的工具！

让我们从加载 2019 车型年车辆的真实数据集开始，但首先，我们需要导入相关的包！

import matplotlib.pyplot as plt%matplotlib inlineimport seaborn as sns

条形图

在本例中，我们希望查看所有车辆的档位数量。

gear_counts = df['# Gears'].value_counts()gear_counts.plot(kind='bar')

我们可以加载 Seaborn，只需对它调用 set()就可以将 matplotlib 的默认设置更改为更具视觉效果的设置。

现在，如果我们做同样的情节命令，它看起来更现代一点。

sns.set()gear_counts.plot(kind='bar')

好多了！

距离图

Seaborn 包括 matplotlib 没有提供的许多类型的情节。例如，“distplot”可用于绘制直方图以及叠加在其上的直方图的平滑分布。让我们以此数据库中车辆的 MPG 值分布为例。

这是我们正在处理的数据

sns.distplot(df['CombMPG'])

配对图

你经常遇到的是 Seaborn 的“结对情节”。这使您可以将各种属性的每种组合的图可视化，因此您可以在特征之间寻找有趣的模式。

作为一个例子，让我们寻找气缸、城市 MPG 等级、公路 MPG 等级和综合 MPG 等级之间的关系。

使用的数据

sns.pairplot(df2, height=2.5)

通过研究上面的结果，你可以看到气缸数量和 MPG 之间的关系，但 4 缸车辆的 MPG 范围非常广。在测量 MPG 值的不同方法之间似乎也有很好的线性关系，直到你达到更高的 MPG 等级。

散点图

这将在您选择的两个轴上绘制各个数据点，因此您可以看到数据在这些维度上的分布情况。

当你有发动机排量这样的顺序数据时，散点图会将自己排列成列，但它告诉我们，发动机排量的每个值都有一个相当大的 MPG 值范围，尽管如果你看看数据点聚集的地方，你可以看到随着发动机排量的增加，MPG 值有下降的趋势。

sns.scatterplot(x="Eng Displ", y="CombMPG", data=df)

带直方图的散点图

Seaborn 还提供了一个“jointplot ”,它结合了散点图和两个轴上的直方图。这使您可以同时看到单个数据点和两个维度上的分布。

sns.jointplot(x="Eng Displ", y="CombMPG", data=df)

最常见的发动机排量似乎是 2，3 紧随其后。每加仑汽油的得分似乎大致遵循一条以 22 分左右为中心的钟形曲线。

线性散点图

“lmplot”为我们提供了覆盖在图表上的数据的线性回归，这使得较低 MPG 与较高发动机排量的总体趋势更加明显。就效率而言，高发动机排量似乎并不更好。

sns.lmplot(x="Eng Displ", y="CombMPG", data=df)

箱线图

接下来，我们来看一个“盒状图”。这就是所谓的“方框和胡须”图，它对于可视化给定类别的典型值非常有用，不会被异常值分散注意力。每个方框代表数据的第一个和第三个四分位数之间的范围，一条线代表中值。从框中延伸出来的“胡须”代表数据的其余部分的分布，除了清晰的异常值，这些异常值被绘制为胡须外部的单个点。

例如，让我们看看每个汽车制造商的箱线图，可视化他们生产的汽车的每加仑英里数。这让我们可以看到每个制造商提供的所有车辆的 MPG 评级的分布情况。

有很多制造商，所以为了使结果图可读，我们将增加 Seaborn 的默认图形大小，并使用 set_xticklabels 将标签旋转 45 度。

sns.set(rc={'figure.figsize':(15, 5)})ax = sns.boxplot(x='Mfr Name', y='CombMPG', data=df)ax.set_xticklabels(ax.get_xticklabels(),rotation=45)

箱线图告诉我们，我们在每种变速箱类型上看到的 MPG 值的范围并不像乍看上去那样疯狂分布；许多极值实际上是离群值，在分析趋势时最好将其丢弃。

群体图

另一种可视化相同数据的方法是“群体图”它绘制的不是方框和触须，而是每一个单独的数据点——但这样做的方式是根据它们的分布将它们组合在一起。你看着就更有道理了。

ax = sns.swarmplot(x='Mfr Name', y='CombMPG', data=df)ax.set_xticklabels(ax.get_xticklabels(),rotation=45)

计数图

另一个工具是“计数图”这和直方图基本上是一样的，只是针对分类数据。它可以让你计算 X 轴上每个给定类别在数据中出现的次数，并绘制图表。例如，我们可以看到通用汽车公司提供的车型比其他任何公司都多，宝马紧随其后。

ax = sns.countplot(x='Mfr Name', data=df)ax.set_xticklabels(ax.get_xticklabels(), rotation=45)

热图

热图允许你绘制某种表格形式的 2D 数据，用颜色代表 2D 表中每个单元格的单个值。

在本例中，我们将根据原始数据框创建一个数据透视表，以创建一个 2D 表，其中包含气缸数和发动机排量的每种组合的平均 MPG 评级。

生成的热图显示了沿 X 轴的所有发动机排量值，以及沿 Y 轴的所有气缸排量值。对于表格中的每个单元格，气缸和发动机排量组合的实际平均 MPG 等级不是用数字表示，而是用颜色表示，颜色范围从深色表示小数值，浅色表示大数值。

这确实可以让您看到一个清晰的趋势，随着我们从图表的左上移到右下，情况会逐渐变暗。这是有道理的。较高的 MPG 等级与较低的气缸数量和较低的发动机排量值相关。当我们使用 8 升 16 缸发动机时，平均每加仑汽油跑 12 英里，用黑色表示。

这张图表有很多缺失的数据，但是热图很好地处理了这些数据。3 缸 8 升发动机根本不存在！

df2 = df.pivot_table(index='Cylinders', columns='Eng Displ',          values='CombMPG', aggfunc='mean')sns.heatmap(df2)

我的 Seaborn 教程到此结束。希望这对你的兼职项目和工作有帮助。谢谢大家！

Python 中时间序列分析的基本统计数据

原文：https://towardsdatascience.com/basic-statistics-for-time-series-analysis-in-python-4cb147d56535?source=collection_archive---------15-----------------------

了解描述性统计和推断性统计，快速启动您的时间序列分析

Icons8 团队在 Unsplash 上的照片

时间序列只是一组按时间顺序排列的数据点，其中时间通常是独立变量。

现在，预测未来并不是时间序列分析的唯一目的。它还与评估重要属性相关，如平稳性、季节性或自相关性。

在进入更高级的建模实践之前，我们必须首先掌握基础知识。

在本文中，我们将通过介绍描述性和推断性统计来介绍时间序列分析的构建模块。当我们在时间序列上实现复杂的模型时，这些概念将会派上用场，因为统计显著性对于建立稳健的分析是必要的。

所有的代码示例都是 Python 语言，你可以拿着的笔记本跟着学。

我们开始吧！

通过 Python 课程中的应用时间序列分析，使用 Python 和 TensorFlow 应用更复杂的模型进行时间序列分析！

描述统计学

https://giphy.com/

描述性统计是对数据集进行汇总的一组值和系数。它提供了关于集中趋势和可变性的信息。

平均值、中值、标准偏差、最小值和最大值通常是我们要寻找的值。

那么，让我们看看如何用 Python 获得这些值。

首先，我们将导入所有需要的库。并非所有这些都用于描述性统计，但我们稍后会用到它们。

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
import seaborn as snsfrom sklearn.linear_model import LinearRegressionimport statsmodels.api as sm

现在，我们将探索数据集shampoo . CSV*。*该数据集追踪某段时间内洗发水的历史销量。

为了查看整个数据集，我们可以执行以下 Python 代码:

data = pd.read_csv('shampoo.csv')
data

小心，因为这将显示整个数据集。在这种情况下，只有 36 个实例，但是对于较大的数据集，这不是很实际。

相反，我们应该使用下面这段代码:

data.head()

上面的代码行将显示数据集的前五个条目。您可以通过指定想要查看的条目数量来决定显示更多条目。

data.head(10)

上面一行将显示数据集的前 10 个条目。

现在，有一种非常简单的方法可以获得平均值、中值、标准差和其他关于数据集中心趋势的信息。

只需运行下面的代码行:

data.describe()

您应该会看到洗发水数据集的以下信息:

数据集的描述性统计

如您所见，通过这个简单的方法，我们获得了关于数据集大小、平均值和标准偏差、最小值和最大值的信息，以及关于其四分位数的信息。

形象化

数字是一个很好的起点，但是能够可视化一个时间序列可以给你快速的洞察力，这将帮助你把你的分析引向正确的方向。

当涉及到时间序列时，直方图和散点图是最广泛使用的可视化工具。

我们数据集的简单直方图可以显示为:

data.hist()

数据集的基本直方图

然而，我们可以做得更好。让我们绘制一个更好的直方图，并给这个轴添加标签。

plt.figure(figsize=[10, 7.5]); # Set dimensions for figureplt.hist(data['Sales'])
plt.title('Histogram of Shampoo Sales');
plt.xlabel('Shampoo Sales ($M)');
plt.ylabel('Frequency');

洗发水数据集的直方图

上面的直方图好多了。您可以更改许多参数来根据需要定制可视化。例如，您可以更改直方图中条柱的颜色和数量。

plt.figure(figsize=[10, 7.5]); # Set dimensions for figureplt.hist(data['Sales'], bins=20, color='#fcba03')
plt.title('Histogram of Shampoo Sales');
plt.xlabel('Shampoo Sales ($M)');
plt.ylabel('Frequency');

洗发水数据集的直方图

现在，您应该可以非常轻松地绘制直方图，并根据自己的需要进行定制。

最后但同样重要的是知道如何显示散点图。非常简单，我们可以像这样可视化我们的数据集:

plt.figure(figsize=[20, 7.5]); # Set dimensions for figuresns.scatterplot(x=data['Month'], y=data['Sales']);
plt.title('Historical Shampoo Sales');
plt.ylabel('Shampoo Sales ($M)');
plt.xlabel('Month');

洗发水数据集的散点图

如果你想了解更多关于使用我们使用的库绘图的知识，并看看不同的参数如何改变绘图，请务必查阅 matplotlib 或 seaborn 的文档。

推断统计学

【https://giphy.com/

顾名思义，推断统计是使用分析从数据集中推断属性。

通常，我们希望在数据集中找到一个趋势，以便进行预测。这也是我们检验不同假设的机会。

出于介绍的目的，我们将使用一个简单的线性回归来说明和解释时间序列背景下的推断统计。

时间序列的线性回归

在本节中，我们将使用另一个数据集来追溯大气中 CO2 的历史浓度。由于数据集跨越了 2014 年的历史，让我们只考虑 1950 年及以后的数据。

让我们应用之前所学的知识，展示我们数据的散点图。

# Dataset from here: [https://www.co2.earth/historical-co2-datasets](https://www.co2.earth/historical-co2-datasets)
co2_dataset = pd.read_csv('co2_dataset.csv')plt.figure(figsize=[20, 7.5]); # Set dimensions for figure# Let's only consider the data from the year 1950
X = co2_dataset['year'].values[1950:]
y = co2_dataset['data_mean_global'].values[1950:]sns.scatterplot(x=X, y=y);
plt.title('Historical Global CO2 Concentration in the Atmosphere');
plt.ylabel('CO2 Concentration (ppm)');
plt.xlabel('Year');

从 1950 年到 2014 年的二氧化碳浓度

如你所见，浓度似乎随着时间而增加。

虽然趋势似乎不是线性的，但它可能仍然可以解释数据的部分可变性。因此，让我们做如下假设:

• CO2 浓度以线性方式依赖于时间，存在一些误差

在数学上，这表示为:

线性方程

你应该很容易把它看作一个线性方程，包含一个常数项、一个斜率和一个误差项。

重要的是要注意，在进行简单的线性回归时，要做以下假设:

• 误差呈正态分布，平均为 0
• 误差具有相同的方差(同方差)
• 这些错误互不相关

然而，在执行简单的线性回归时，这些假设在技术上都没有使用。我们不生成误差项的正态分布来估计线性方程的参数。

相反，普通最小二乘法 (OLS)用于估计参数。这只是试图找到误差平方和的最小值:

用 OLS 最小化的参数

线性回归在起作用

现在，让我们用一个线性模型来拟合我们的数据，并查看模型的估计参数:

X = co2_dataset['year'].values[1950:].reshape(-1, 1)
y = co2_dataset['data_mean_global'].values[1950:].reshape(-1, 1)reg = LinearRegression()reg.fit(X, y)print(f"The slope is {reg.coef_[0][0]} and the intercept is {reg.intercept_[0]}")predictions = reg.predict(X.reshape(-1, 1))plt.figure(figsize=(20, 8))
plt.scatter(X, y,c='black')
plt.plot(X, predictions, c='blue', linewidth=2)
plt.title('Historical Global CO2 Concentration in the Atmosphere');
plt.ylabel('CO2 Concentration (ppm)');
plt.xlabel('Year');
plt.show()

线性回归

运行上面的代码，你应该得到同样的图，你会看到斜率是 1.3589，截距是-2348。

参数有意义吗？

斜率确实是正的，这是正常的，因为浓度无疑在增加。

然而，截距是负的。这是否意味着时间 0，CO2 浓度为负？

不。我们的模型绝对不足以让我们回到 1950 年。但是这些参数是最小化误差平方和的参数，因此产生最佳的线性拟合。

评估模型的质量

从图中，我们可以直观地说直线不是我们数据的最佳拟合，但也不是最差的。

回想一下假设误差是正态分布的线性模型。我们可以通过绘制残差的 QQ 图来检验这个假设。

QQ 图是两种不同分布的分位数散点图。如果分布是相同的，那么我们会看到一条直线。

因此，如果我们绘制残差相对于正态分布的 QQ 图，我们可以看到它们是否落在一条直线上；这意味着我们的残差确实是正态分布的。

X = sm.add_constant(co2_dataset['year'].values[1950:])
model = sm.OLS(co2_dataset['data_mean_global'].values[1950:], X).fit()
residuals = model.resid
qq_plot = sm.qqplot(residuals, line='q')
plt.show()

QQ-残差图

如你所见，蓝点代表残差，它们不在一条直线上。因此，它们不是正态分布的，这表明线性模型不是我们数据的最佳拟合。

这可以通过绘制残差直方图得到进一步支持:

X = sm.add_constant(co2_dataset['year'].values[1950:])
model = sm.OLS(co2_dataset['data_mean_global'].values[1950:], X).fit()
residuals = model.residplt.hist(residuals);

残差直方图

同样，我们可以清楚地看到它不是正态分布。

假设检验

推断统计学的一个主要组成部分是假设检验。这是一种确定观察到的趋势是否是由于随机性，或者是否有真正的统计意义的方法。

对于假设检验，我们必须定义一个假设和一个无效假设。假设通常是我们试图从数据中提取的趋势，而零假设恰恰相反。

让我们为我们的情况定义假设:

• 假设:时间与 CO2 浓度呈线性相关
• 零假设:时间和 CO2 浓度没有线性关系

厉害！现在，让我们使用另一个库为我们的数据集拟合一个线性模型，该库将为我们自动运行假设检验:

X = sm.add_constant(co2_dataset['year'].values[1950:])
model = sm.OLS(co2_dataset['data_mean_global'].values[1950:], X).fit()
print(model.summary())

现在，这里有很多信息，但让我们只考虑几个数字。

首先，我们有一个非常高的 R 值 0.971。这意味着超过 97%的 CO2 浓度变化可以用时间变量来解释。

然后，F 统计量也很大:2073。这意味着时间和 CO2 浓度之间存在线性相关性具有统计学意义。

最后，查看斜率系数的 p 值，您会注意到它是 0。虽然该数字可能不为 0，但仍然非常小，这是存在线性相关性的另一个统计显著性指标。

通常，阈值 0.05 用于 p 值。如果小于这个值，则拒绝零假设。

因此，由于一个大的 F 统计量，结合一个小的 p 值，我们可以拒绝零假设。

就是这样！你现在处于一个非常好的位置来启动你的时间序列分析。

有了这些基本概念，我们将在它们的基础上构建更好的模型来帮助我们预测时间序列数据。

了解 Python 中时间序列分析的最新最佳实践:

• 在 Python 中应用时间序列分析

干杯！

数据科学需要了解的基本统计数据

原文：https://towardsdatascience.com/basic-statistics-you-need-to-know-for-data-science-1fdd290f59b5?source=collection_archive---------3-----------------------

让您开始数据科学之旅的基本统计概念

这样做的目的是全面概述统计学的基础知识，这是您开始数据科学之旅所需要的。已经有很多文章了，但我的目标是让这篇文章更简洁！

如果你发现了这个有价值的东西，愿意支持我，就来看看 我的 Patreon 页面 ！

数据类型

数值:用数字表示的数据；是可以衡量的。可以是离散的或连续的。

分类的:将定性数据分类成类别。可以是名义(无顺序)也可以是序数(有序数据)。

集中趋势测量

**均值:**一个数据集的平均值。
**中位数:**有序数据集的中间；不易受离群值的影响。
**模式:**一个数据集中最常见的值；仅与离散数据相关。

差异量数

**范围:**数据集中最高值和最低值之差。

方差(σ2): 测量一组数据相对于平均值的分布程度。

标准差(σ): 数据集中数字分布的另一种度量；它是方差的平方根。

Z-score: 确定数据点偏离平均值的标准偏差数。

**R 平方:**拟合的统计测量，表明自变量解释了因变量的多少变化；仅对简单的线性回归有用。

**调整后的 R 平方:**已针对模型中预测器的数量进行调整的 R 平方的修改版本；如果新项对模型的改进超过偶然的预期，那么它就会增加，反之亦然。

变量之间关系的度量

**协方差:**测量两个(或多个)变量之间的方差。如果是正的，那么它们倾向于向同一个方向移动，如果是负的，那么它们倾向于向相反的方向移动，如果它们是零，那么它们彼此没有关系。

样本的分母变为(n-1)

**相关性:**衡量两个变量之间的关系强度，范围从-1 到 1；协方差的标准化版本。一般来说，+/- 0.7 的相关性代表两个变量之间的密切关系。另一方面，介于-0.3 和 0.3 之间的相关性表明变量之间几乎没有关系。

概率分布函数

概率密度函数(PDF): 连续数据的函数，其中任意点的值可以被解释为提供随机变量的值等于该样本的相对可能性。(维基)

概率质量函数(PMF): 离散数据的函数，给出给定值出现的概率。

累积密度函数(CDF): 告诉我们随机变量小于某个值的概率的函数；PDF 的积分。

连续数据分布

**均匀分布:**所有结果可能性相等的概率分布。

**正态/高斯分布:**通常称为钟形曲线，与 中心极限定理 有关；平均值为 0，标准偏差为 1。

**T-分布:**在样本量较小和/或总体方差未知时用于估计总体参数的一种概率分布(参见更多 此处 )。

**卡方分布:**卡方统计量的分布(见 此处 )。

离散数据分布

**泊松分布:**概率分布，表示给定数量的事件在固定时间段内发生的概率。

**二项式分布:**一系列 n 次独立经历中成功次数的概率分布，每次经历都有自己的布尔值结果(p，1-p)。

朋友圈

矩描述了分布的性质和形状的不同方面。一阶矩是均值，二阶矩是方差，三阶矩是偏度，四阶矩是峰度。

可能性

概率是事件发生的可能性。

条件概率[P(A|B)] 是基于前一事件的发生，某一事件发生的可能性。

独立事件是其结果不影响另一事件结果概率的事件；P(A|B) = P(A)。

互斥事件是不能同时发生的事件；P(A|B) = 0。

**贝叶斯定理:**确定条件概率的数学公式。“给定 B 的概率等于给定 A 的 B 的概率乘以 A 的概率超过 B 的概率”。

准确(性)

**真阳性:**检测条件出现时的条件。

**真否定:**当条件不存在时，不检测条件。

**假阳性:**检测条件不存在时的条件。

**假阴性:**在条件存在时不检测条件。

灵敏度:又称召回；当条件存在时，测量测试检测条件的能力；灵敏度= TP/(TP+FN)

**特异性:**测量当条件不存在时，测试正确排除条件的能力；特异性= TN/(TN+FP)

预测值阳性:又称精度；对应于条件存在的阳性比例；PVP = TP/(TP+FP)

**预测值阴性:**对应于条件不存在的阴性比例；PVN = TN/(TN+FN)

假设检验和统计显著性

查看我的文章“尽可能简单地解释假设检验”以获得更深入的解释 这里 。

零假设:样本观察值完全来自偶然的假设。

**备选假设:**样本观测值受某种非随机原因影响的假设。

**P 值:**假设零假设正确，获得某项检验的观测结果的概率；较小的 p 值意味着有更强的证据支持替代假设。

Alpha: 显著性水平；当零假设为真时拒绝零假设的概率，也称为1 型错误。

**Beta:**2 型错误；未能拒绝虚假的零假设。

假设检验的步骤:
1。陈述零假设和替代假设
2。确定测试规模；是单尾还是双尾检验？
3。计算测试统计和概率值
4。分析结果，拒绝或不拒绝零假设(如果 p 值大于α，不拒绝零假设！)

就是这样！如果我发现我在旅程中错过了很多重要的话题，请随时评论并告诉我:)

更多类似的文章，请看 https://blog.datatron.com/的

感谢阅读！

如果你喜欢我的工作，想支持我…

1. 支持我的最好方式就是在媒体这里关注我。
2. 成为第一批在Twitter这里关注我的人之一。我会在这里发布很多更新和有趣的东西！
3. 此外，成为第一批订阅我的新 YouTube 频道 这里！
4. 关注我LinkedIn这里。
5. 在我的邮箱列表 这里报名。
6. 看看我的网站，terenceshin.com。

机器学习的基本步骤

原文：https://towardsdatascience.com/basic-steps-of-machine-learning-56495730c0e5?source=collection_archive---------82-----------------------

内部 Ai

透过肿瘤学的镜头

让我们开始更深入地研究机器学习的基础知识。我们将从使用机器学习背后的基本理论和我们将用于解决新问题的大纲开始。最后，我们将讨论一些常见的 ML 模型可以解决的潜在问题。

从 NCI 到 Unsplash

为什么是机器学习？

机器学习需要一种处理问题的新方法。在传统的编程中，一个具有一些领域知识的人必须推导出一个将输入转换成期望输出的程序。在这种情况下，输入和转换是已知的。

在机器学习中，未知的是转换。也就是说，我们提供输入和结果输出(至少在监督学习中)。随着我们的建模变得越来越复杂，一个人通过传统的编程为所有的特性做出必要的转换变得很困难。

传统编程和机器学习之间的差异通过它们的输出凸显出来。链接

此外，随着我们的数据集变得越来越大和越来越复杂，人类很难在数据中识别出新的、重要的模式。但是机器更容易理解这种维度。也就是说，由于“维数灾难”，我们可以在模型中包含的特征数量是有限的。随着维度的增加，我们的点之间的距离增加，数据变得稀疏。我们将在后面讨论为什么这很重要，以及如何对抗“诅咒”。

我们应该如何处理一个 ML 问题？

我先说这个帖子是针对一个通用的 ML 模型的。各种模型的相对用例、优点和缺点超出了本文的范围，但是可以通过快速的 Google 搜索获得资源。这里以为例。

1-获取数据

这可以采取多种形式。如果你能接触到电子健康记录(EHR)，那太好了。如果你有单一研究的实验数据或跨元研究的数据，那就更好了。一般来说，一开始你能检查的越多越好。在数据清理和 EDA 过程中，我们将对数据有更好的感觉，并将对包括或不包括什么做出更明智的决定。

API 是一个很好的资源。以下是一些可供选择的方法:

• HealthData.gov:新冠肺炎、EHR、医疗保险等。
• 【HealthIT.gov】T2:EHR、全州绩效指数、临床医生流失等。
• Rapid API :收集了一系列医疗保健相关的 API，主题广泛

2 —处理您的数据

一旦有了数据集合，就需要对其进行预处理，以便在机器学习模型中使用。有些模型对输入数据有非常具体的要求(比如没有遗漏条目)，所以如果适用的话，请确保阅读所选模型和包的文档。

无论型号类型如何，都需要采取一些步骤。您应该熟悉的一些流程:

1. 处理缺失值:您可以删除 NaN 值，估算相似子集中的中值/平均值，或者将缺失值标记为类别或选择的替代值。
2. 删除重复条目 : Pandas 有一个 drop_duplicate()方法。
3. 检查不一致性:例如，如果在列中添加了额外类别的拼写错误，或者某个数值被存储为“字符串”或“对象”，请使用 df.column.dtype 进行检查
4. 过滤掉有影响的离群值:警告一句，你不应该删除离群值，除非它是真实存在的危险。并非所有的异常值都会影响模型的准确性。
5. 如果分类，检查等级不平衡。

你可能需要做的另一个过程是特性选择和工程。这可能包括为分类列创建虚拟变量、移除具有多重共线性的要素(相关变量)或创建基于其他列提供潜在新见解的新列。

这里有一篇很棒的文章深入探讨特性工程，包括缩放、日志转换、一键编码等。

3 —选择一个模型

终于到了模特的时间了！同样，有许多资源可以确定哪种模型适合您的需求。这里有一个来自 scikit-learn 的精彩总结。

基于我们的用例，我们需要确定我们的模型是应该利用监督学习还是非监督学习。对于监督学习，我们试图训练一个模型，将输入正确地转换为相应的已知的输出。这意味着我们需要知道输出是什么，但情况并非总是如此。然后将使用无监督学习，其中我们让模型在我们的数据中找到关系。

监督学习模型的一些例子是回归和分类模型，如逻辑回归、支持向量机(SVMs)或神经网络。

对于无监督学习，我们没有已知的输出。这些模型常用于聚类分析和降维。

4 —培训

现在我们已经选择了一个模型，收集并处理了数据。我们准备开始训练模型。我们首先将数据集分为训练集、验证集和测试集。训练/验证/测试数据的确切比例取决于您使用的模型。具有较少功能的模型更容易调整，因此可能需要较少的验证数据。

根据你的训练计划，你将以不同的方式进行训练。像往常一样，检查文档。Scipy 和 Keras 模型有一个. fit()方法。PyTorch 要求编写自己的训练循环。

5 —评估

有几个指标你可能听说过，可以用来确定你的模型是否成功:

1. 准确度:正确分类输出的百分比(真阳性+真阴性)
2. 精度:真阳性与真阳性和假阳性的比率
3. 回忆:真阳性与实际总阳性的比率(真阳性+假阴性)

这些乍一看都很像。在假阳性很重要的情况下，精确度很重要。在假阴性很重要的情况下，回忆很重要。一如既往，牢记您的业务理解和目标应该推动您的评估指标。

我警告不要把准确性作为你的主要或者唯一的评估标准。举个例子，假设你正在开发一个模型来预测一个病人是否患有一种只影响 0.01%人口的罕见疾病。由于大类不平衡，我们的模型每次都会预测“无病”！那将会有 99.99%的准确度！但是，你可以猜到，这不是一个有用的模型。

关于使用验证集优化模型的说明。当您迭代地改进您的模型时，请注意一遍又一遍地针对您的验证集进行测试将会导致过度适应该验证集，并且模型将不会很好地推广到新的数据(实际的测试集)。解决这个问题的一种方法是使用合成方法，通过交叉验证来“洗牌”训练和验证集，如 k-fold 交叉验证。简而言之，您将训练数据的不同子集视为该单次拟合的验证集，然后再进行下一次拟合。

这是机器学习计算机视觉的一个伟大而幽默的应用:吉娃娃还是松饼？

6 —调谐

在我们开始之前，我们必须划分参数和超参数。参数是模型本身使用误差最小化和梯度下降来改变不同特征的权重和偏差。

超参数是人类用户可以改变的，例如，改变模型经历的迭代次数、改变学习速率、隐藏层的数量和组成、丢弃、优化器和损失函数等。这些超参数是我们实际调整模型的方式。经过大量的耐心和反复试验，我们可以找到一个更好的设置来获得更好的指标。请记住，根据我们的目标，推理或预测，这个过程可能看起来非常不同。也许我们需要增加复杂性来提高准确性，或者我们需要去除复杂性来使我们的模型更容易解释(例如，更少的黑箱)。

这里有一些资源来深入研究调优。

7 —预测

现在我们已经训练和调整了我们的模型，我们可以开始进行预测了！这就是我们一直在建设的。我们确切的预测显然取决于我们的模型是什么。也许使用一个 CNN 通过输入组织切片来预测癌症的存在。或者使用 EHR 记录开发一个分类模型来预测患者住院情况。

回顾一下我们的流程

• 收集和准备您的数据
• 选择型号
• 训练、评估、调整、重复
• 预测！

因此，现在你可以在头脑中有计划地进行数据科学研究了！请记住，这不是一个线性的过程，你应该为你的目标尽可能多地重复这些步骤。

我之前关于机器学习在肿瘤学中的应用的文章可以在这里找到—

[## 机器学习和人工智能在肿瘤学中的应用

肿瘤学的最新进展为癌症治疗和长期缓解带来了令人兴奋的选择。然而…

towardsdatascience.com](/machine-learning-ai-applications-in-oncology-73a8963c4735)

Python 中的基本 Tweet 预处理

原文：https://towardsdatascience.com/basic-tweet-preprocessing-in-python-efd8360d529e?source=collection_archive---------3-----------------------

推文预处理！

了解如何使用 Python 预处理推文

https://hdqwalls.com/astronaut-hanging-on-moon-wallpaper

编者注: 走向数据科学 是一份以研究数据科学和机器学习为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。

只是为了给你一点背景，为什么我要预处理推文:鉴于截至 2020 年 5 月的当前形势，我对美国州长关于正在进行的的政治话语感兴趣。我想分析一下两个政党——共和党&民主党对给定的形势做出了怎样的反应，新冠肺炎。他们此时的主要目标是什么？谁更关注什么？他们最关心的是什么？

在收集了从新冠肺炎案例 1 的第一天开始的各州州长的推文后，我们将它们合并成一个数据帧(如何将各种 JSON 文件合并成一个数据帧)并进行预处理。

我们总共收到了大约 3 万条推文。一条推文包含了很多关于它所代表的数据的观点。未经预处理的原始推文是高度非结构化的，包含冗余信息。为了克服这些问题，通过采取多个步骤来执行 tweets 的预处理。

几乎每个社交媒体网站都因其以标签形式表现的主题而闻名。特别是对我们来说，标签起了重要作用，因为我们对#Covid19、#冠状病毒、#StayHome、#InThisTogether 等感兴趣。因此，第一步是基于 hashtag 值形成一个单独的特征，并对它们进行分段。

1。使用正则表达式提取 hashtag

作为新功能“hashtag”添加到新列的所有 hashtag 的列表

*tweets[‘hashtag’] = tweets[‘tweet_text’].apply(lambda x: re.findall(r”#(\w+)”, x))*

提取标签后

然而，超过一个单词的标签必须分段。我们使用库 ekphrasis 将这些标签分割成 n 个单词。

*#installing ekphrasis
!pip install ekphrasis*

安装完成后，我选择了一个基于 twitter 语料库的分割器

*from ekphrasis.classes.segmenter import Segmenter#segmenter using the word statistics from Twitter
seg_tw = Segmenter(corpus=”twitter”)*

我找到的最相关的 tweet-preprocessor—tweet-preprocessor，这是 Python 中的一个 tweet 预处理库。

它处理—

• 资源定位符
• 提及
• 保留字(RT，FAV)
• 表情符号
• 笑脸消除(游戏名)

*#installing tweet-preprocessor
!pip install tweet-preprocessor*

2 .文本清理(URL、提及等。)

将清理后的(删除网址和提及后的)推文添加到一个新列，作为新功能“文本”

清理是使用tweet-preprocessor包完成的。

*import preprocessor as p#forming a separate feature for cleaned tweets
for i,v in enumerate(tweets['text']):
    tweets.loc[v,’text’] = p.clean(i)*

3.标记化、删除数字、停用词和标点符号

新特征“文本”的进一步预处理

NLTK(自然语言工具包)是预处理文本数据的最佳库之一。

*#important libraries for preprocessing using NLTK
import nltk
from nltk import word_tokenize, FreqDist
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
nltk.download
nltk.download('wordnet')
nltk.download('stopwords')
from nltk.tokenize import TweetTokenizer*

• 去掉数字，降低文字高度(便于处理)

*data = data.astype(str).str.replace('\d+', '')
lower_text = data.str.lower()*

• 删除标点符号

*def remove_punctuation(words):
 new_words = []
 for word in words:
    new_word = re.sub(r'[^\w\s]', '', (word))
    if new_word != '':
       new_words.append(new_word)
 return new_words*

• 词汇化+标记化—使用内置的 TweetTokenizer()

*lemmatizer = nltk.stem.WordNetLemmatizer()
w_tokenizer = TweetTokenizer()def lemmatize_text(text):
 return [(lemmatizer.lemmatize(w)) for w in \
                                     w_tokenizer.tokenize((text))]*

最后一个预处理步骤是

• 删除停用字词—有一个预定义的英文停用字词列表。但是，您可以像这样修改停用字词，只需将这些字词附加到停用字词列表中。

*stop_words = set(stopwords.words('english'))tweets['text'] = tweets['text'].apply(lambda x: [item for item in \ 
                         x if item not in stop_words])*

4.词云

分段标签的频率分布

在预处理步骤之后，我们排除了推文中的所有地名和缩写，因为它充当了泄漏变量，然后我们对最常出现的标签进行了频率分布，并创建了一个词云—

这是意料之中的。

*from wordcloud import WordCloud#Frequency of words
fdist = FreqDist(tweets['Segmented#'])#WordCloud
wc = WordCloud(width=800, height=400, max_words=50).generate_from_frequencies(fdist)
plt.figure(figsize=(12,10))
plt.imshow(wc, interpolation="bilinear")
plt.axis("off")
plt.show()*

最终的数据集—

最终的代码—

*import pandas as pd
import numpy as np
import json
from collections import Counter
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import re, string, unicodedata
import nltk
from nltk import word_tokenize, sent_tokenize, FreqDist
from nltk.corpus import stopwords
from nltk.stem import LancasterStemmer, WordNetLemmatizer
nltk.download
nltk.download('wordnet')
nltk.download('stopwords')
from nltk.tokenize import TweetTokenizer!pip install ekphrasis
!pip install tweet-preprocessor
import preprocessor as ptweets['hashtag'] = tweets['tweet_text'].apply(lambda x: re.findall(r"#(\w+)", x))for i,v in enumerate(tweets['text']):
    tweets.loc[v,’text’] = p.clean(i)def preprocess_data(data):
 #Removes Numbers
 data = data.astype(str).str.replace('\d+', '')
 lower_text = data.str.lower()
 lemmatizer = nltk.stem.WordNetLemmatizer()
 w_tokenizer =  TweetTokenizer()

 def lemmatize_text(text):
  return [(lemmatizer.lemmatize(w)) for w \
                       in w_tokenizer.tokenize((text))] def remove_punctuation(words):
  new_words = []
   for word in words:
      new_word = re.sub(r'[^\w\s]', '', (word))
      if new_word != '':
         new_words.append(new_word)
   return new_words words = lower_text.apply(lemmatize_text)
 words = words.apply(remove_punctuation)
 return pd.DataFrame(words)pre_tweets = preprocess_data(tweets['text'])
tweets['text'] = pre_tweetsstop_words = set(stopwords.words('english'))
tweets['text'] = tweets['text'].apply(lambda x: [item for item in \
                                    x if item not in stop_words])from ekphrasis.classes.segmenter import Segmenter# segmenter using the word statistics from Twitter
seg_tw = Segmenter(corpus="twitter")
a = []
for i in range(len(tweets)):
 if tweets['hashtag'][i] != a
  listToStr1 = ' '.join([str(elem) for elem in \
                                       tweets['hashtag'][i]])
  tweets.loc[i,'Segmented#'] = seg_tw.segment(listToStr1)#Frequency of words
fdist = FreqDist(tweets['Segmented#'])
#WordCloud
wc = WordCloud(width=800, height=400, max_words=50).generate_from_frequencies(fdist)
plt.figure(figsize=(12,10))
plt.imshow(wc, interpolation="bilinear")
plt.axis("off")
plt.show()*

希望我帮到你们了。

如果文本预处理得好，文本分类通常会工作得更好。一定要给它一些额外的时间，最终一切都是值得的。

基础:多重共线性和可解释性

原文：https://towardsdatascience.com/basics-multicollinearity-and-interpretability-3dfef2168efc?source=collection_archive---------33-----------------------

鲁莽的数据科学家的基本错误之一。

马库斯·斯皮斯克在 Unsplash 上的照片

多重共线性是数据集的一种属性，它可能会给您带来对模型和数据的意外、不稳定但在技术上并非错误的解释。在进行回归分析之前检查多重共线性(为简洁起见，以下简称为 MC)有助于确保从数据中获得最大的洞察力，并且不会忽略重要的关系。

多重共线性的例子。

数据中的 MC 意味着数据表中的多列(即特征、预测值、输入变量)是线性 依赖。换句话说，数据表中存在可以表示为其他列的线性组合的列。您的数据矩阵 X 不是满秩的。

我将在线性模型的上下文中证明 MC 的重要性。这个问题也延伸到非线性模型，但只是不容易暴露，因为需要复杂的解释方法来解释这种模型。

线性模型(如线性回归)以可解释而闻名，这意味着与复杂的非线性模型(如神经网络)不同，很容易看出输入与输出之间的关系。您只需读出系数:系数的幅度和符号直接对应于相关特性对输出的影响。

通常，数据分析师通过应用线性回归并检查回归系数，使用该属性来量化两个或多个列的关系。

线性回归模型使得 x 和 y 的关系很容易看出。

*MC 通过引入模糊性破坏了线性回归的可解释性。*在 MC 数据集中，输出不仅可以表示为列的唯一线性组合，还可以等价地表示为其共线列的组合。

以一个虚构的玩具为例，它预测孩子的阅读能力( y )是其年龄( a )和身高( h )的函数。让我们假设年龄和身高在我们的数据中完全相关，如下例所示。现在我们可以将 y 等效表示为:

阅读能力 y、年龄 a 和身高 h(单位:厘米)的数据集示例。

这三个表达式都是正确的，但是它们导致对数据中的关系的非常不同的解释。在第一种情况下，我们可以得出结论，身高是阅读能力的唯一预测因素，年龄没有任何作用。在最后一种情况下，我们可能倾向于假设身高和年龄都是预测阅读能力所需要的。

看待这个问题的另一种方式是，多共线性矩阵不是满秩的。非满秩矩阵 X 是不可逆的。还有，(X^T)X 是不可逆的。线性回归的解析最小二乘解需要 X^T)X 的精确反演，因此它对于多共线性矩阵是不存在的。对于“几乎”MC 矩阵，问题是病态。

到目前为止，我们考虑了一些列是其他列的精确线性组合的情况。在实践中，这种情况可以忽略不计，因为如果我们使用真实(即有限和有噪声的)数据，这种精确的关系实际上永远不会出现。但是，即使列只是近似共线，我们仍然有一个可解释性的问题。我们的模型在固定数据集上可能相当稳定，但对数据中的微小变化仍然敏感。添加或删除一些样本可以使我们的模型从依赖一组特征“跳到”另一组特征——就像以前一样。

如前所述，MC 不仅会妨碍线性模型的可解释性，还会影响非线性模型及其解释方法，如输入梯度、逐层相关性传播，或综合梯度。这是因为不确定性不在于所使用的解释方法，而在于数据，因此也就在于可以从中学习的模型。

现在您已经了解了多重共线性的概念和后果，您可能想知道如何在数据中检测它以及如何补救它的影响。这些步骤超出了我想在这篇文章中传达的基本内容，但是我建议看看在维基百科上收集的有用的方法列表。

希望你学到了有用的东西！

保险定价基础

原文：https://towardsdatascience.com/basics-of-insurance-pricing-47243c2630b9?source=collection_archive---------4-----------------------

快速介绍 GLM 模特

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

简介

在这篇文章中，保险定价的基础知识将被解释:为什么定价如此重要，如果定价策略不一致会发生什么，以及保险公司如何使用统计模型设定他们的保费。在最后一节中，我们将使用真实的保险数据进行一个非常简单的案例研究，以充实导言中的思想。

为什么定价很重要

保险业是一个关注对冲不确定财务损失风险的行业，因此保险公司的业务在很大程度上是一项风险管理工作。被保险人通过一份被称为保险单的合同与保险公司交易未来风险以获得固定的保费，如果保单持有人遭受损失，他们可以在保单允许的情况下向保险公司提出索赔。保费是由保险公司在任何索赔之前设定的，因此，公司预测客户的风险以设定有利可图的保费是至关重要的。考虑到这一点，预测模型在保险公司广泛使用就不足为奇了；无论是评估客户还是设定保费。

作为一个例子来强调有一个深思熟虑的定价策略的重要性，假设有两家保险公司，A 和 B，A 有相对于损失风险的低保费，而 B 有相对于风险的适当保费。在这种情况下，高风险客户会选择 A，因为他们的保费与 B 相比相对较低，因此 A 会吸引高风险客户，实际上看到他们的利润被吃掉。相反，如果 A 的保费太高，他们不会吸引任何有利可图的客户，仍然亏损。根据这个简单的例子，我们明白了为什么有竞争力的定价策略是至关重要的。

此外，根据埃森哲金融服务公司 2017 年全球分销和营销消费者调查，对 18 个市场的 32，715 名保险客户的研究发现，价格是客户忠诚度的头号驱动因素，52%的汽车保险客户选择价格作为他们的首要杠杆。

作者图片

保险公司如何制定保费？

如上所述，保险费是根据客户的风险确定的，以确保客户的损失得到补偿。然而，这并不代表最终价格的全部。像任何其他业务一样，保险公司有自己的成本，并通过运营来盈利。因此，保费不仅要弥补客户的损失，还要弥补成本，保持可观的利润。

尽管如此，保费的基础是根据客户的风险选择保费。要做到这一点，必须估计客户寻求保险的风险。根据我们考虑的保险产品，使用不同的解释变量，通常分为两组:主题变量，涉及购买保险的人，和客体变量，涉及被保险的客体；无论是房子、汽车或任何其他可保物品。例如，在家庭保险中，精算师可以使用诸如财产的居住面积、家庭中居住的人数或投保者的年龄等变量。潜在的假设是，这些变量和风险之间存在相关性，这种相关性看起来当然不同，但作为一个例子，财产保险的风险通常随着承保人的年龄而降低，因为年老通常意味着更加注意和小心。

什么是风险？

在保险术语中，风险是有害的或意想不到的事情发生的可能性。这可能涉及贵重财产和物品的丢失、被盗或损坏，也可能涉及有人受伤。从统计学的角度来看，风险可以定义为:

其中 L 为损失， e 为保险有效期(敞口)。如果我们假设索赔的大小与索赔的频率无关，我们可以进行如下扩展:

其中 N 是索赔的数量， S 是索赔的严重性或规模， F 是索赔频率。

评估风险的方法

精算师使用统计方法来估计风险并不奇怪，直到 20 世纪 80 年代，精算师都依赖线性回归来模拟风险，但由于建立了一个称为广义线性模型(GLM)的模型，这种情况发生了变化。GLM 相对于简单的线性回归的优势在于，GLM 模型通过所谓的链接函数(下面等式中的 g)允许非线性相关性。

其中 Y 为因变量， X 为自变量，β为回归拟合的参数。请注意，如果没有链接函数，表达式将只是简单的线性回归。

今天，大多数保险公司的保费是使用 GLM 模型来确定的，它们在一定程度上已经成为精算师的舒适区。然而，近年来，由于技术突破和许多行业大数据的实现，在业务应用中使用机器学习(ML)的普及程度出现了激增，保险业也不例外。当在保险业中使用 ML 模型时，记住 GDPR 是很重要的，因为它对模型的可解释性提出了要求。因此，易于解释的基于树的模型通常受到青睐，甚至被证明在保险数据上比传统的 GLMs 具有更好的预测准确性(见https://arxiv.org/abs/1904.10890)。

建模假设

在任何模型中，必须对数据的性质和使用的变量做出假设。我们已经遇到了保险风险模型中常见的一个假设，即客户索赔的严重程度和频率是独立的。利用这一假设，精算师建立了两个模型，一个是严重性模型，一个是频率模型，然后将两个模型的预测结合起来，得出风险估计值。但是，这不是一个必要的假设，因为风险也可以直接建模。无论作出何种决定，因变量，无论是风险、严重程度还是频率，总是假定遵循已知的统计分布。例如，客户提交的索赔数量通常被假定为按照泊松分布分布，而严重性通常遵循伽马分布。当精算师直接对风险建模时，通常选择所谓的 Tweedie 分布。

案例分析:从理赔数据到风险预测

这里的一个例子是建立一个频率模型的家庭保险数据使用统计软件 R。

首先，我们看看手头的数据，索赔数量是我们的因变量，我们通过直方图将其可视化，以查看它遵循什么分布，并获得问题的概述:

显然，索赔数量严重倾斜，因为大多数客户没有任何索赔，所以我们看到峰值为零。这激发了为什么使用泊松分布可能是一个好主意，通过调整泊松分布中的λ参数，可以捕获这种偏斜。

建模的第一步是清理数据并选择要使用的要素。完成这些后，我们可以对数据进行 GLM 拟合。

首先，我们将数据读入 R，并将其分成训练/测试集:

Frequency_data <- read.csv("C:/Users/Samuel Tober/Desktop/Projects/Data/Frequency_data.csv")set.seed(123) #Set seed for reproducibility
sample <- sample.split(Frequency_data, SplitRatio = 0.80) #Split data into 80% training 20% test
train = subset(Frequency_data, sample==TRUE)
test = subset(Frequency_data, sample==FALSE)

然后，我们使用“glm”软件包将 GLM 模型拟合到训练数据:

model <- glm('NO_CLAIM_NOT_NULL ~ NO_INSUR + AGE_INSUR_PERS +                                    LIVE_AREA + offset(log(EXP_COV))', family = poisson(link = "log"),         data = train)

在这里，我们将索赔数量(NO_CLAIM_NOT_NULL)建模为家庭人数(NO_INSUR)、客户年龄(AGE_INSUR_PERS)和房产居住面积(LIVE_AREA)的函数。请注意，我们在 GLM 模型中包含了风险敞口(EXP_COV)作为补偿，这样我们就可以对比率数据使用泊松回归(泊松通常仅适用于计数数据)。此外，我们指定 link = "log "，其中 link 指的是前面提到的链接函数 g，我们选择对数，因为我们处理的是泊松分布数据。

接下来，我们使用均方误差(MSE)和平均绝对误差(MAE)作为度量标准来测试和评估该模型(有更合适的度量标准，如泊松偏差，但这里我们选择一个简单易懂的度量标准用于教育目的，在未来的文章中有更多关于度量标准的信息):

pred <- exp(predict(model, test))
MSE <- sqrt(mean((test$NO_CLAIM_NOT_NULL - pred*test$EXP_COV)^2)) #Mean squared error
MAE <- sum(abs(test$NO_CLAIM_NOT_NULL - pred*test$EXP_COV))/nrow(test) #Mean absolute error> MSE = 0.182480104096452
> MAE = 0.0582112950956896

有了这个模型，我们现在可以预测保险客户的索赔频率，如果我们同样建立一个严重性模型，我们在频率-严重性独立性假设下得到一个完全成熟的定价模型。

请注意，这是一个极其简化的示例，请参考https://www . casact . org/pubs/monographs/papers/05-gold burd-Khare-tevet . pdf和/或【https://link.springer.com/book/10.1007/978-3-642-10791-7】获取 GLM 模式的更多解释和展示。

OpenCV 内核和卷积的基础知识

原文：https://towardsdatascience.com/basics-of-kernels-and-convolutions-with-opencv-c15311ab8f55?source=collection_archive---------4-----------------------

如何使用 Python 和 OpenCV 将简单的内核应用于图像

我一直在尝试用 Python 和 OpenCV 学习计算机视觉，我总是偶然发现术语内核和卷积。

图片来自 JESHOTS

起初，我试图依靠那些 gif 和一些简短的解释，但我经常对它们的使用感到困惑，所以我决定更好地看看它。

在这篇文章中，我将分享我对内核和卷积的一些了解，同时探索它的一些主要应用，如模糊，锐化，提取和腐蚀。

核和卷积

和我一样，你可能觉得这和玉米有关系，其实没有。

身份内核——用碳制成的图片

计算机视觉中的核是矩阵，用于在我们的数据中执行某种卷积。让我们试着分解一下。

卷积是两个函数之间创建第三个函数的数学运算。在图像处理中，它通过遍历每个像素来执行与该像素及其邻居的计算。

内核将定义卷积的大小、应用于卷积的权重以及通常位于中心的锚点。

因此，在 3×3 矩阵中，每个像素只受其周围像素的影响，而 7×7 的像素会改变它。

高斯模糊

好的，那么要把它应用到一个图像上，我们会:用它的定位点把它定位在一个给定的像素上，在核的值和像素的值之间执行一些操作，为那个像素定义一个新的值，然后移动到下一个。

图片来源:https://giphy.com/gifs/blog-daniel-keypoints-i4NjAwytgIRDW

总结:

• 我们可以通过与图像的像素交互来过滤和修改图像；
• 这种相互作用可能发生在盘旋时；
• 这些卷积使用核来描述像素将如何受到影响；
• 内核表示每个操作的区域、值/权重和锚点；

亲自动手

说得够多了，让我们看看如何使用这些内核。
我们将使用 OpenCV、Numpy 和 Matplotlib。

import cv2
import numpy as np
import matplotlib.pyplot as plt

导入库后，我们可以绘制原始图像，这样我们就知道发生了什么变化。

image = cv2.imread('Images/6.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)fig, ax = plt.subplots(1, figsize=(12,8))
plt.imshow(image)

雅典艺术学院——拉斐尔

酷，现在让我们做一个模糊图像的内核。我们将使用 Numpy 构建一个 3x3 的 1 矩阵，然后除以 9。

https://en . Wikipedia . org/wiki/Kernel _(image _ processing)

>>> kernel = np.ones((3, 3), np.float32) / 9
>>> kernel
...
array([[0.11111111, 0.11111111, 0.11111111],
       [0.11111111, 0.11111111, 0.11111111],
       [0.11111111, 0.11111111, 0.11111111]], dtype=float32)

我们可以用. filter2D 把它应用到图像上。

img = cv2.filter2D(image, -1, kernel)fig, ax = plt.subplots(1, figsize=(12,8))
plt.imshow(img)

框模糊。

让我们用一个锐化的内核来尝试一下。

https://en . Wikipedia . org/wiki/Kernel _(image _ processing)

kernel = np.array([[0, -1, 0],
                   [-1, 5, -1],
                   [0, -1, 0]])

锐化。

通过使用. filter2D，我们可以使用任何我们想要的内核来应用线性过滤器。但是也有更舒适的方式来达到这些结果。

简单的方法

OpenCV 有一些方便的函数来过滤图像，很多时候你甚至不需要定义内核。

我们可以利用。模糊应用一个框模糊，我们只需要传递图像和内核的大小。

image = cv2.imread('Images/6.jpg')
**image = cv2.blur(img, (5,5))**
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)fig, ax = plt.subplots(1, figsize=(12,8))
plt.imshow(image)

框模糊。

高斯模糊和中值模糊:

image = cv2.imread('Images/6.jpg')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)fig, ax = plt.subplots(1, figsize=(12,16))ax = plt.subplot(211)
g = **cv2.GaussianBlur(image, (3,3), 0)**
plt.imshow(g)ax = plt.subplot(212)
m = **cv2.medianBlur(image, 3)**
plt.imshow(m)

高斯和中值模糊。

膨胀和腐蚀

内核还可以帮助放大和侵蚀图像——这在处理图片和文本时似乎很有用。

image = cv2.imread('Images/9.png')# convert to black and white
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 
r ,image = cv2.threshold(image, 150, 255, cv2.THRESH_BINARY)# create kernel
kernel = np.ones((5,5), np.uint8)fig, ax = plt.subplots(1, figsize=(16,12))# original
ax = plt.subplot(232)
plt.imshow(image, cmap='Greys')
plt.title('original')# erosion
e = cv2.erode(image, kernel)
ax = plt.subplot(234)
plt.imshow(e, cmap='Greys')
plt.title('erosion')# dilation
d = cv2.dilate(image, kernel)
ax = plt.subplot(235)
plt.imshow(d, cmap='Greys')
plt.title('dilation')# morphological gradient (dilation - erosion)
m = cv2.morphologyEx(image, cv2.MORPH_GRADIENT, kernel)
ax = plt.subplot(236)
plt.imshow(m, cmap='Greys')
plt.title('dilation - erosion')

图片作者赫尔巴努

在该应用中，核是定义所应用效果的形状和范围的结构化元素。即使您必须创建一个矩阵，OpenCV 也有一些功能来简化这个过程。

https://docs . opencv . org/trunk/d9/d61/tutorial _ py _ morphology _ ops . html

内核和卷积比我预期的要简单得多，也更容易理解为什么它们在图像处理中被如此广泛地使用，以及它们如何增加复杂性以支持图像分类、对象检测等任务。

感谢阅读我的文章。我希望你能更清楚地了解卷积是如何使用内核来执行运算的。

资源: OpenCV 2D 滤镜；
OpenCV 平滑；
OpenCV 过滤；
OpenCV 形态变换；

更进一步:
OpenCV 去噪；
OpenCV 边缘检测；

每个数据科学家都应该了解线性代数的基础知识

原文：https://towardsdatascience.com/basics-of-linear-algebra-for-data-science-9e93ada24e5c?source=collection_archive---------14-----------------------

照片由 Michael Dziedzic 在 Unsplash 上拍摄

线性代数是我们如此熟悉的强大的机器学习算法的背后

线性代数是广泛应用于各个学科的数学领域。数据科学领域也依赖于线性代数的许多不同应用。这并不意味着每个数据科学家都需要有非凡的数学背景，因为你将处理的数学量在很大程度上取决于你的角色。然而，很好地理解线性代数确实会增强对许多机器学习算法的理解。首先，要真正理解深度学习算法，线性代数是必不可少的。本文介绍了最重要的基本线性代数概念，并展示了线性代数的两个相关数据科学应用。

内容

• 矩阵和向量
• 矩阵运算
• 矩阵求逆
• 正交矩阵
• 线性代数在数据科学中的应用(奇异值分解和主成分分析)

矩阵和向量

简而言之，我们可以说线性代数是向量和矩阵的数学。我们利用这样的向量和矩阵，因为它们是表示大量信息的方便的数学方法。

矩阵是由行和列组成的数字、符号或表达式的数组。矩阵的特征在于它的行数 m 和列数 n。一般来说，阶为’ m x n '(读作:“m 乘 n”)的矩阵具有 m 行和 n 列。下面，我们展示一个 2×3 矩阵 A 的例子:

我们可以通过相应的行和列来引用矩阵的各个元素。例如，A[1，2] = 2，因为数字 2 位于第一行第二列。

只有一列的矩阵称为向量。例如，上面矩阵 A 的每一列都是一个向量。让我们把矩阵 A 的第一列作为向量 v:

在向量中，我们也可以指单个的元素。这里，我们只需要使用一个索引。例如，v[2] = 4，因为 4 是向量 v 的第二个元素。

矩阵运算

当我们能够用矩阵进行代数运算时，我们分析和解决线性代数领域中特殊问题的能力将会大大提高。这里列出了执行这些操作的最重要的基本工具。

㈠矩阵和

如果 A 和 B 是 m×n 矩阵，那么和 A+B 就是 m×n 矩阵，它的列是 A 和 B 中对应列的和，和 A+B 只有在 A 和 B 大小相同时才定义。

当然，矩阵的减法，A-B，以同样的方式工作，B 中的列从 a 中的列中减去

(二)标量倍数

如果 r 是标量，那么矩阵 A 的标量倍数是 r*A，即其列是 A 中相应列的 r 倍的矩阵。

㈢矩阵向量乘法

如果矩阵 A 的大小是 m×n(因此，它有 n 列)，并且 u 是大小为 n 的向量，那么 A 和 u 的乘积，用 Au 表示，是 A 的列的线性组合，使用 u 中的相应条目作为权重。

注:只有矩阵 A 的列数等于向量 u 的项数，才定义乘积 Au！

性质:如果 A 是 m×n 矩阵，u 和 v 是大小为 n 的向量，r 是标量，则:

㈣矩阵乘法

如果 A 是一个 m×n 矩阵，B = [ b 1， b 2，…， b p]是一个 n×p 矩阵，其中 b i 是矩阵 B 的第 I 列，那么矩阵乘积 AB 就是 m×p 矩阵，它的列是 A b 1，A b 2，…，A b p。所以

因为

注:A 中的列数必须与 B 中的行数相匹配，才能进行矩阵乘法。

性质:设 A 是 m×n 矩阵，设 B 和 C 的大小使得和与积被定义，设 r 是标量。然后:

(五)矩阵的幂

如果 a 是一个 n×n 矩阵， k 是一个正整数，那么 A^k (A 的 k 次方)是 a 的 k 个副本的乘积:

㈥矩阵转置

假设我们有一个大小为 m×n 的矩阵 a，那么 a 的转置矩阵(用 A^T 表示)是 n×m 矩阵，它的列是由 a 的相应行组成的

性质:设 A 和 B 为矩阵，其大小适合下列和与积。然后:

矩阵求逆

矩阵代数提供了处理矩阵和创建各种有用公式的工具，其方式类似于用实数处理普通代数。例如，一个实数的(乘法)逆，比如说 3，就是 3^-1，或者 1/3。该逆满足以下等式:

这个概念可以推广到方阵。如果存在一个 n×n 矩阵 C，则称 n×n 矩阵 A 是可逆的:

其中 I 是 n×n单位矩阵。单位矩阵是对角线上有 1 而其他地方有 0 的方阵。下图显示了 5 x 5 单位矩阵:

回到上面的可逆性原理，我们称矩阵 c 为 a 的逆事实上，c 是由 a 唯一确定的，因为如果 b 是 a 的另一个逆，那么 B = BI = B(AC) = (BA)C = IC = C。这个唯一的逆由 A^-1 表示，因此:

属性:

正交矩阵

正交矩阵是其列和行是正交单位向量的方阵。也就是说，正交矩阵是可逆矩阵，我们称之为 Q，其中:

这导致了等价的特征:如果矩阵 Q 的转置与其逆矩阵相等，则矩阵 Q 是正交的:

线性代数在数据科学中的应用

为了展示线性代数在数据科学领域中的相关性，我们将简要介绍两个相关的应用。

奇异值分解

奇异值分解是数据科学领域中一个非常重要的概念。奇异值分解的一些重要应用是图像压缩和降维。让我们在这里集中讨论后一种应用。降维是将数据从一个高维空间转换到一个低维空间，这样原始数据中最重要的信息仍然保留。这是期望的，因为一旦数据的维度太高，数据的分析在计算上变得难以处理。

SVD 将矩阵分解为三个独立矩阵的乘积，如下所示:

在哪里

假设矩阵 M 是一个 M×n 矩阵:

• u 是左奇异向量的 m×m 正交矩阵；
• σ是 M×n 矩阵，其中 D(即 r×r)中的对角元素是 M 的前 r 个奇异值**；**
• v 是右奇异向量的 n×n 正交矩阵。

奇异值可用于理解由每个奇异向量解释的方差量。它捕捉的差异越多，它包含的信息就越多。通过这种方式，我们可以使用这些信息将向量的数量限制在我们希望捕获的方差的数量之内。

手动计算 SVD 是可能的，但是当矩阵变得更高维时，这很快变成一个密集的过程。在实践中，人们正在处理大量的数据。幸运的是，通过使用Numpy，我们可以很容易地用 Python 实现 SVD。为了使例子简单，我们定义一个 3×3 的矩阵 M:

import numpy as np
from numpy.linalg import svd

# define the matrix as a numpy array
M = np.array([[4, 1, 5], [2, -3, 2], [1, 2, 3]])

U, Sigma, VT = svd(M)

print("Left Singular Vectors:")
print(U)
print("Singular Values:")
print(np.diag(Sigma))
print("Right Singular Vectors:")
print(VT)

输出:

Left Singular Vectors:
[[-0.84705289  0.08910901 -0.52398567]
 [-0.32885778 -0.8623538   0.38496556]
 [-0.41755714  0.49840295  0.75976347]]
Singular Values:
[[7.62729138 0\.         0\.        ]
 [0\.         3.78075422 0\.        ]
 [0\.         0\.         0.72823326]]
Right Singular Vectors:
[[-0.58519913 -0.09119802 -0.80574494]
 [-0.23007807  0.97149302  0.0571437 ]
 [-0.77756419 -0.21882468  0.58949953]]

因此，在这个小例子中，奇异值(通常表示为σ)为σ1 = 7.627，σ2 = 3.781，σ3 = 0.728。于是，当只使用前两个奇异向量时，我们解释为(σ1 + σ2 ) / (σ1 + σ2 + σ3 ) = 99.3%的方差！

主成分分析

正如奇异值分解一样，主成分分析(PCA) 是一种降维的替代技术。PCA 的目标是创建新的不相关变量，称为主成分，最大化捕获的方差。因此，我们的想法是降低数据集的维度，同时尽可能多地保留“可变性”(即信息)。这个问题归结为求解一个特征值-特征向量问题。

由于特征值和特征向量超出了本文的范围，我们将不深究 PCA 的数学解释。

结论

在数据科学领域，数学无处不在。要成为一名成功的数据科学家，你绝对不需要知道每个概念背后的所有数学细节。然而，为了能够在处理数据和算法时做出更好的决策，您需要对其背后的数学和统计学有坚实的理解。本文主要关注线性代数的基础知识，作为一名数据科学家，这是一门非常重要的数学学科。

Python 中列表理解的基础

原文：https://towardsdatascience.com/basics-of-list-comprehensions-in-python-e8b75da50b30?source=collection_archive---------40-----------------------

技术的

理解如何在 python 编程语言中比循环标准更快地创建序列类型列表

照片由克莱门特·H在 Unsplash 上拍摄

介绍

本文介绍了列表理解的基础 Python 语言中一种常见的编程语法风格。

尽管列表理解在 python 中很常见，但是来自松散类型语言(如 JavaScript)的程序员可能不熟悉列表理解。

列表理解背后的直觉很容易理解，它们的实现方法也是如此。

所以本文旨在做以下几点:

• 呈现列表理解的直觉
• 用示例代码比较创建列表的标准方法和使用列表理解的方法
• 利用列表理解的好处
• 围绕列表理解主题的常见关键术语的定义。

列表

列表是 Python 编程语言中常见的序列类型之一。还有其他常见的序列类型，如元组、集合或字节数组。

example_list = ['deeplearning', 'machinelearning', 'python', 'datascience']
print(example_list)
print(type(example_list))>> ['deeplearning', 'machinelearning', 'python', 'datascience']
>> <class 'list'>

给来自 JavaScript 等语言的人的提示。列表和数组可能看起来相似，但它们在 Python 中并不相同。Python 中经常使用列表。下面就简要解释一下它们的区别

python 编程语言中的列表被归类为序列类型。序列类型通常能够以结构化的方式存储一个或多个值。

列表是序列类型，可以分为容器序列和可变序列。

• 容器序列中存储了对象的引用，而不是对象本身。
• 可变序列允许修改包含在其中的对象。

列出理解

我们对列表有了一个了解，现在可以深入到列表理解这个话题了。

与使用 for 循环的传统方式相比，列表理解是在 python 中构造列表的一种有效方式。

密码

下面的代码片段描述了构建列表的标准方式

下面的代码没有多大意义，写出来只是为了说明。

name = 'James'
name_and_number = []for i in range(5):
   name_and_number.append(name + ' ' + str(i))
print(name_and_number)>> ['James 0', 'James 1', 'James 2', 'James 3', 'James 4']

上面的代码简单地将数字添加到名称中，并修改在变量’ name_and_number 中初始化的空列表。

现在让我们看看如何用列表理解生成相同的列表。

name = 'James'
name_and_number = [name + ' ' + str(i) for i in range(5)]
print(name_and_number)
>>['James 0', 'James 1', 'James 2', 'James 3', 'James 4']

仅此而已，三行代码实现了相同的结果，如果不包括 print 语句，则需要两行。

列表理解的好处是显而易见的，我将在下面的部分总结它们。

在我们继续之前，读者应该注意到,“ for ”循环允许对列表中的每个元素执行更多的操作，而列表理解只是为构造列表而设计的。

您也可以在列表理解中放置条件语句。

name = 'James'
name_and_number = [name + ' ' + str(i) for i in range(5) if i%2==0 ]
print(name_and_number)
>> ['James 0', 'James 2', 'James 4']

利益

• 简洁:当使用普通的 for 循环时，列表可以在一行中生成，而不是几行
• 可读性:列表理解有一个易于阅读的语法，可以很容易地传达实现的目的。

列表理解是一个有用且容易理解和学习的概念，请随意使用你的例子。

如果你喜欢这篇文章，这里有一些我写的。

[## 人工智能中的算法偏差需要讨论(和解决)

你在这件事上有责任…

towardsdatascience.com](/algorithm-bias-in-artificial-intelligence-needs-to-be-discussed-and-addressed-8d369d675a70) [## 为什么机器学习工程师(或数据科学家)不是这场秀的主角

但是我们仍然是成功的员工队伍中不可或缺的一部分

towardsdatascience.com](/why-machine-learning-engineers-or-data-scientists-are-not-the-stars-of-the-show-d91ec9c5256b)

机器学习所需的 Python 基础知识及其库模块

原文：https://towardsdatascience.com/basics-of-python-and-its-library-modules-required-for-machine-learning-51c9d26026b8?source=collection_archive---------21-----------------------

关于 ML 的一切

通过对机器学习所需的每个库的直观理解，学习 python 数据结构的基础知识

照片由在 Unsplash 上拍摄

ython 是数据科学、机器学习和深度学习的最佳编程选择之一。Python 为完成每项任务提供了广泛的选择。它非常容易使用，也是开始编程的最佳方式之一，因为它使用起来相当简单，学习起来也相当容易。它还有一个不断更新和升级的社区。在撰写本文时，python 的最新版本是 3.8。

本文假设读者具有轻微或适度的编程知识，并了解一点 python。如果你之前没有编程知识，那么不要担心。Python 非常容易上手，YouTube 上有大量免费视频，网上也有很多有趣的教程。如果你们想让我从头开始做一个 python 基础教程，请随时告诉我。只要对 python 有一个基本的了解，我们就可以继续了解这种令人惊叹的语言，以及对机器学习有益的所有扩展和库。

注意:这将是我的“关于机器学习”课程的第二部分。但是，每个后续零件都将是独立零件。你可以根据你的方便以任何顺序阅读这个系列。我将在接下来的文章中尝试涵盖基础知识和大多数机器学习算法。要查看该系列的其他部分，您可以点击此处。如果你还没有看过之前的文章，请点击下面的链接。

[## 开始使用 Python 掌握机器学习的旅程

了解精通机器学习的基本要求

towardsdatascience.com](/starting-your-journey-to-master-machine-learning-with-python-d0bd47ebada9)

你可以从下面的链接下载 python。

[## 下载 Python

关于特定端口的信息、开发人员信息来源和二进制可执行文件由发布经理或……

www.python.org](https://www.python.org/downloads/)

你能从这篇文章中期待什么？

今天，我们将探讨机器学习所需的 python 的所有基本概念。我们将理解 python 的各种数据结构，然后继续深入挖掘机器学习所需的所有库的基础。我们将用一些简单的代码片段来涵盖所有这些概念，以便更好地掌握这些库和特性。所以，事不宜迟，让我们动手做一些编码吧！

在 Unsplash 上由 Max Duzij 拍照

Python 中的数据结构:

数据结构是以某种方式组织起来的数据元素的集合。python 中有很多内置的数据结构。让我们逐一探讨这些问题。

1.列表—

列表是可变的有序元素序列。可变意味着列表可以被修改或改变。列表用方括号“[ ]”括起来。我们在 python 中用于机器学习的列表的重要函数是——“append ”,用于向列表添加元素,“len”函数用于查找列表的长度，而“sort”函数用于按升序排列列表中的元素。这三个通常是列表中最常用的函数。列表切片是另一个理解起来非常有用的概念。列表元素可以通过它们的索引号来寻址。第 0 个索引由第一个元素组成，第 1 个索引由第二个元素组成，依此类推。

关于列表的另一个重要概念是列表理解。这是通过提供一种简洁的方式来创建列表，从而简化代码。创建多达 10 个正方形的示例如下:

您也可以在名为嵌套列表的列表中创建一个列表。这些通常对机器学习中的矩阵运算有帮助。

2.字典—

字典是条目的无序集合。与列表和其他数据结构(如元组或集合)不同，字典数据结构有一对称为键和值的元素。dict()函数可以用来给一个变量分配一个字典。另一种方法是使用花括号’ {} '将变量指定为字典。定义了一个字典之后，我们主要有三个函数——items函数用于查看字典的键和值, keys 函数用于访问字典的键, values 函数用于访问各个键的所有值。字典功能甚至可以用于为熊猫图书馆构建数据框。它是和列表一样重要的数据结构之一。下面的例子展示了如何声明一个字典并访问字典中的所有变量。

3.元组—

元组数据结构类似于列表数据结构，在列表数据结构中，可以用固定数量的元素定义元组。唯一的区别是元组是不可变的。这可以防止对元组中的元素进行任何修改，因为不能从创建的特定元组中追加或删除更多的元素。可以通过指定元组函数或使用普通括号“()”来创建元组。访问元组中的元素的过程可以通过访问它的特定索引位置来完成，类似于列表。还可以创建嵌套元组，即元组中的元素元组。元组数据结构的主要优点是它可以适合于定义图上的(X，Y)点，使得这些点在整个程序中保持一致并且不能被改变。让我们看一个嵌套元组的例子，其中主元组包含((x1，y1))和(x2，y2)形式的另外两个元组。让我们来看看如何访问元组的 y1 元素，如下面的代码块所示。

上面代码块的输出是 2，也就是 y1 和我们想要访问的元素。

4.集合—

集合是无序元素的集合。这些元素也没有被索引。可以通过使用 set 函数或使用只有一个元素的大括号“{ 0 }”来定义集合。集合数据结构是可变的，因为元素可以被添加或删除，但是集合只包含每个元素中的一个。元素的重复不能在一个集合中重复，并且一个集合总是有序的。从最小意义到最大意义进行排序，即按升序排序。集合可用于执行数学集合运算，如并、交、对称差等。下面是一个代码块，展示了集合的简单工作。

其他的数据结构是字符串和冻结集。大多数观众在学习 python 的基础知识时都已经了解了字符串。我将简要介绍字符串，但我个人并没有在我的机器学习项目中大量使用冻结集，因为我觉得它没那么有用。如果你有兴趣了解更多关于这些的信息，请随时学习。

字符串可以在单引号“”或双引号“”中定义。字符串是不可变的字符序列。计算机不处理字符。相反，他们处理数字，尤其是二进制数字。尽管您可能在屏幕上看到字符，但在内部，它是以 0 和 1 的组合形式存储和操作的。这种将字符转换为数字的过程称为编码，相反的过程是解码。美国信息交换标准码(ASCII)和 Unicode 是一些常用的编码。在 Python 中，字符串是 Unicode 字符序列。字符串用于编码的常用格式化技术是用字节表示的 UTF-8 标准。

照片由 Emil Widlund 在 Unsplash 拍摄

python 中用于机器学习的基本重要库:

1.熊猫—

Pandas模块是 python 中的一个开源库，用于创建数据框，这对于组织数据非常有用。Pandas 广泛用于数据科学、机器学习和深度学习领域，用于数据的结构化排列。在 pandas 中创建的数据框是数据的二维表示。将 pandas 库作为 pd 导入后，您可以可视化您喜欢的表格数据。这方面的一个例子如下所示:

总的来说，pandas 模块是一个用于系统查看数据的极好的库，它还允许执行各种各样的操作。

2.Matplotlib —

Matplotlib 模块是可视化数据框或任何其他形式数据的最佳工具之一。Matplotlib 用于可视化数据，以便在数据科学中进行探索性数据分析。了解我们正在处理的数据类型以及确定必须执行的下一步操作非常有用。该库提供了各种各样的可视化功能，如散点图、条形图、直方图、饼图和许多其他类似的功能。将 matplotlib.pyplot 模块作为 plt 导入，以便使用 matplotlib 执行可视化任务。下面是一个例子

散点图

条形图

图中显示了使用 matplotlib 绘制的散点图和条形图。该模块的一个优点是使用非常简单，并且在提供可视化方面非常有效。它还可以与 seaborn 库结合使用，以获得更好的视觉和美学效果。

3.NumPy —

NumPy 库代表数值 Python 。numpy 库是执行矩阵运算的最佳选择之一。它支持多维数组。可以在数组上执行大量的数学和逻辑运算。通过将列表转换成 numpy 数组，我们可以执行诸如加法、减法、点积等计算。numpy 的用例适用于计算机视觉和自然语言处理项目。在计算机视觉中，您可以使用 numpy 数组来可视化 numpy 数组中的 RGB 或灰度图像，并相应地转换它们。在自然语言处理项目中，为了优化计算，您通常喜欢将文本数据转换成向量和数字的形式。将 numpy 作为 np 导入，您可以将文本数据转换为分类数据，如下所示:

4.Scikit-learn —

scikit-learn 模块是机器学习和预测数据分析的最佳工具之一。它提供了广泛的预建算法，如逻辑回归，支持向量机(SVM)，分类算法，如 K 均值聚类，以及更多的操作。这是初学者开始学习机器学习算法的最佳方式，因为该模块提供了简单高效的工具。它是开源的，可以在商业上使用，同时几乎允许任何人访问。它是可重用的，并受到诸如 NumPy、SciPy 和 Matplotlib 等库的支持。导入 sklearn 模块来运行 scikit-learn 代码。下面是一个代码示例，用于将我们拥有的数据集分割成一种形式的训练和测试或验证数据。这对于模型的训练和评估是有用的。

5.NLTK —

NLTK 库代表自然语言工具包平台，它是自然语言处理数据的机器学习的最佳库之一。自然语言处理(NLP)是人工智能的一个分支，它帮助计算机理解、解释和操纵人类语言。NLTK 库非常适合基于语言的任务。它为分类、标记化、词干化、标记、解析和语义推理等任务提供了广泛的选项。它允许用户将数据分成实体，这些实体可以组合在一起，以产生更有组织的意义。该库可以作为 nltk 导入，下面是一个句子标记化的示例代码。

**注:**这只是对所有库的简单介绍。如果你还没有完全理解它们，那也没什么。在本系列接下来的部分中，我们将通过实际的例子以及它们在机器学习算法和问题中的具体应用来更详细地了解每一个问题。

结论:

我们能够对各种数据结构和它们执行的任务有一个简单的了解，同时对 python 中提供机器学习灵活性的各种库有一个直观的了解。有了 python 及其相应的机器学习库模块的基础知识，我们就可以更深入地探索机器学习的各个领域和算法了。在接下来的文章中，我们将重点关注探索性数据分析和机器学习背后的数学。一旦完成，我们将单独查看每个算法，并对它们及其特定用例进行完整的分解。

对于本文中使用的一些代码、截图和图像，参考了我以前的一些文章。请随意查看下面的参考资料。

[## 使用深度学习的人类情感和手势检测器:第 1 部分

了解如何从零开始构建具有深度学习的人类情感和手势检测器。

towardsdatascience.com](/human-emotion-and-gesture-detector-using-deep-learning-part-1-d0023008d0eb) [## 基于自然语言处理和深度学习的下一个单词预测

使用 LSTM 设计单词预测系统

towardsdatascience.com](/next-word-prediction-with-nlp-and-deep-learning-48b9fe0a17bf) [## 使用一维卷积层的创新聊天机器人

从头开始使用深度学习和 Conv-1D 层构建聊天机器人

towardsdatascience.com](/innovative-chatbot-using-1-dimensional-convolutional-layers-2cab4090b0fc)

从以下链接查看与本系列相关的所有文章:

[## 关于 Ml 的一切——走向数据科学

阅读《走向数据科学》中关于 Ml 的文章。共享概念、想法和代码的媒体出版物。

towardsdatascience.com](https://towardsdatascience.com/tagged/All%20About%20ML)

谢谢大家坚持到最后，祝大家有美好的一天！