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

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

机器学习:通过预测意大利葡萄酒的品种来观察 KNN 是如何工作的

原文：https://towardsdatascience.com/machine-learning-observe-how-knn-works-by-predicting-the-varieties-of-italian-wines-a64960bb2dae?source=collection_archive---------62-----------------------

做中学

凯尔西·钱斯在 Unsplash 上的照片

简介

在这篇文章中，我想用一个实际的例子向你介绍 KNN。

我会考虑我的一个项目，你可以在我的 GitHub 简介中找到。对于这个项目，我使用了来自 Kaggle 的数据集。

该数据集是对意大利同一地区种植的葡萄酒进行化学分析的结果，但这些葡萄酒来自三个类别的三个不同品种。分析是通过考虑在三种类型的葡萄酒中发现的 13 种成分的数量来完成的。

本文将分为三个部分。在第一部分中，我将对 KNN 进行理论描述，然后我将专注于探索性数据分析部分，以便向您展示我发现的见解，最后，我将向您展示我用来准备和评估机器学习模型的代码。

第一部分:什么是 KNN，它在数学上是如何工作的？

k-最近邻算法不是复杂的算法。KNN 预测和分类数据的方法包括浏览训练数据，并找到最接近新点的 k 个训练点。然后，它将最接近的训练数据的类别标签分配给新数据。

但是 KNN 是如何运作的呢？要回答这个问题，我们必须参考两点之间的欧几里德距离公式。假设你需要计算笛卡尔平面上两点 A(5，7)和 B(1，4)之间的距离。您将应用的公式非常简单:

好吧，但是我们如何把它应用到机器学习中呢？假设你是一名书商，你想给一本名为《菲利普·K·蒂克的 Ubick》的新书分类，该书有 240 页，售价 14 欧元。正如你在下面看到的，有 5 个可能的类来放置我们的新书。

作者图片

为了知道哪个类最适合于 Ubick，我们可以使用欧几里德公式来计算数据集中每个观察值的距离。

公式:

作者图片

输出:

作者图片

正如你在上面看到的，最近的 Ubick 类是 C 类。

第二部分:我发现的创建模型的见解

在开始谈论我用来创建模型和预测葡萄酒品种的算法之前，让我简要地向你们展示一下我发现的主要见解。

在下面的热图中，不同功能之间存在关联。这对于初步了解我们数据集的情况以及了解是否有可能应用分类算法非常有用。

作者图片

乍一看，热图很棒，但这还不够。我还想知道是否有一些元素的绝对相关和很低，以便在训练机器学习模型之前删除它们。所以，我构建了一个直方图，如下图所示。

可以看到，有三个元素的总绝对相关度很低。元素是灰、镁和颜色强度。

作者图片

由于这些观察，现在我们确信有可能应用 KNN 算法来创建预测模型。

第三部分:使用 scikit-learn 进行预测

在这一部分中，我们将通过 scikit-learn 了解如何准备模型并对其进行评估。

下面你可以观察到我把模型分成两部分:80%用于训练，20%用于测试。我选择这个比例是因为数据集不大。

出局:

X_train shape: (141, 10)
y_train shape: (141,)X_test shape: (36, 10)
y_test shape: (36,)

你要知道 scikit-learn 中所有的机器学习模型都是在自己的类中实现的。例如，k-最近邻分类算法是在 KNeighborsClassifier 类中实现的。

第一步是将类实例化为一个对象，我称之为 cli ，如下图所示。该对象包含我将用来根据训练数据构建模型并对新数据点进行预测的算法。它还包含算法从训练数据中提取的信息。

最后，为了在训练集上构建模型，我们调用了 cli 对象的拟合方法。

出局:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',metric_params=None, n_jobs=None, n_neighbors=1, p=2,weights='uniform')

在 fit 方法的输出中，您可以看到创建模型时使用的参数。

现在，是时候对模型进行评估了。下面，第一个输出向我们展示了模型预测了 89%的测试数据。相反，第二个输出为我们提供了每个类的精确度的完整概述。

出局:

Test set score: 0.89

出局:

结论

我认为学习东西的最好方法是实践。所以在我的情况下，我从 Kaggle 下载数据集，这是找到一个好的数据集的最好地方之一，你可以在其上应用你的机器学习算法并了解它们是如何工作的。

感谢你阅读这篇文章。您还可以通过其他方式与我保持联系并关注我的工作:

• 订阅我的时事通讯。
• 也可以通过我的电报群 初学数据科学 联系。

AWS SageMaker 上的机器学习

原文：https://towardsdatascience.com/machine-learning-on-aws-sagemaker-b23e32503106?source=collection_archive---------27-----------------------

如何用线性回归预测员工工资

Photo by @ 你好我是 Nik 上Unsplash

在本教程中，我们将使用亚马逊 SageMaker Studio 在 AWS SageMaker 上创建一个 ML 模型，根据多年的经验来预测员工的工资。

问题陈述

想象一下，一个潜在的员工已经通过了面试，现在 HR 想要给他们一份工作。薪水会是多少？

假设:对薪水有影响的唯一因素是多年的经验。

成果概述

在本教程中，我将提出一个简单的线性回归模型。你在这个模型中输入多年的经验，它会做出相应的工资预测。

注:你可以在这里找到我之前的帖子 TK 中关于线性回归的完整解释。

案例研究—结果概述

使用的数据 : 卡格尔-工资-数据

为了让这更令人兴奋，我们将在 Amazon SageMaker 上构建、训练和部署 ML 模型——耶！

亚马逊 SageMaker 工作室

Sagemaker Studio 是一个用于机器学习的完全集成的开发环境(IDE)，它允许我们编写代码、跟踪实验、可视化数据和执行调试。

跟随:

• 从 AWS 管理控制台搜索栏中找到 SageMaker 服务。
• 点击亚马逊 SageMaker 工作室。
• 点击左上角的+图标，启动你的 Jupyter 笔记本。

第一步:这项研究的目的是什么？

• 根据经验年限预测员工工资。
• 我们使用简单的线性回归模型:根据多年的经验(变量 X，独立变量)预测工资(变量 Y，独立变量)。

步骤 2:导入库和数据集

**#import required libraries**
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt**#if you need to install some packages, use this command:**
!pip install tensorflow**#read the Dataset**
salary_df = pd.read_csv('salary.csv')
salary_df.head(10)
salary_df.tail(10)

数据集的头部和尾部

第三步:探索性数据分析和可视化

**#get some information about our DataSet** salary_df.info()
salary_df.describe()**#check if there are any Null values**
salary_df.isnull().sum()

信息-描述-并检查是否有空值

**#visualizing data**
sns.pairplot(salary_df)
sns.heatmap(salary_df.corr(), annot=True)sns.regplot(salary_df['YearsExperience'], salary_df['Salary'], data = salary_df )

配对图-热图-正则图

第四步:将数据集分成训练集和测试集

我们使用Train集合让算法学习数据的行为，然后我们在Test集合上检查我们的模型的准确性。

• Features(X):插入到我们模型中的列将用于进行预测。
• Prediction(y):将由特征预测的目标变量

**#define X variables and our target(y)**
X = salary_df[['YearsExperience']]
y = salary_df[['Salary']]**#splitting Train and Test** 
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=0)**#need to have y_train & y_test as an vector(for SageMaker linear learner)** y_train = y_train[:,0]
y_test = y_test[:,0]

第五步:使用 SageMaker 训练线性学习模型

在我们开始之前，让我们解释一下我们需要准备什么——我保证，我会很快的！

设置准备

亚马逊 S3

• 亚马逊 S3 是一种存储服务，允许我们在目录(桶)中存储和保护我们的数据。我们将需要这项服务继续前进
• **bucket:**是存储在亚马逊 S3 的对象的容器，每个 bucket 都有全局唯一的名称。

创建桶

• 首次搜索 S3 服务。
• 选择创建一个存储桶，并给它一个名称和区域。
• 点击下一步，直到您得到配置选项，您将阻止所有公共访问，并创建您的桶。

【创建前缀(桶内子文件夹)

在创建的桶中，点击“创建文件夹”并给它一个名字。

所以，我们有:

• **斗:**斗:sagemaker-practical-m
• 前缀:

IAM(身份和访问管理)

我们需要给我们的 Sagemaker 一个 IAM 角色，这样它就可以代表我们执行任务(例如，读取训练结果，从 S3 存储桶中调用模型工件，以及将训练结果写入 S3)

让我们回到我们的代码:

**#import required kits** import sagemaker
import boto3 **#create a Sagemaker session**
sagemaker_session = sagemaker.Session()**#define the S3 bucket and prefix(subfolder within the bucket)** bucket = 'sagemaker-practical-m'
prefix = 'linear-learner' **#define IAM role**
role = sagemaker.get_execution_role()
print(role)

运行上述代码后的结果。

Boto3 一个 AWS Python SDK，允许开发者编写使用亚马逊 S3 或 EC2 等服务的应用程序。

让我们将训练数据转换成 Sagemaker 兼容的输入格式(RecordIO)。更多关于这个的信息请点击。

**#import module in terms of dealing with various types of I/O** import io**#import sagemaker common library** import sagemaker.amazon.common as smac **#converts the data in numpy array format to RecordIO format** buf = io.BytesIO()
smac.write_numpy_to_dense_tensor(buf, X_train, y_train)

**#reset in-memory byte arrays to zero** buf.seek(0)

最后一个命令用于清除内存缓冲区。

在我们的数据被转换成记录格式并包含在缓冲区中之后。我们现在可以将数据上传到 S3:

**#import module**
import os

**#Key refers to the name of the file** key = 'linear-train-data'**#uploads the data in record-io format to S3 bucket** boto3.resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'train', key)).upload_fileobj(buf)**#training data location in s3**
s3_train_data = 's3://{}/{}/train/{}'.format(bucket, prefix, key)print('uploaded training data location: {}'.format(s3_train_data))

我们刚刚创建了“train”文件夹，其中包含我们上传的数据(linear-train-data)。

让我们回到 S3 仓库，检查文件是否在那里:

我们需要指定 S3 位置来存储我们的线性学习器输出:

**#create an output location in S3 bucket to store the linear learner output** output_location = 's3://{}/{}/output'.format(**bucket**, **prefix**)print('Training artifacts will be uploaded to: {}'.format(output_location))

现在，要获得对线性学习器容器的引用，只需指定算法名:

**#specify the name of the algorithm, that we want to use** from sagemaker.amazon.amazon_estimator import get_image_uricontainer = get_image_uri(boto3.Session().region_name, 'linear-learner')

然后，我们传递希望用于训练的容器和实例类型。已经定义了输出路径和 SageMaker 会话变量。

linear = sagemaker.estimator.Estimator(container,
          role, 
          train_instance_count = 1, 
          train_instance_type = 'ml.c4.xlarge',
          output_path = output_location,
          sagemaker_session = sagemaker_session)

这些参数可以调整:

• 传入的要素数。
• 预测器的类型(regressor或classifier)。
• 小批量(每个小批量的观察次数)。

**#Train 32 different versions of the model and will get the best out of them** linear.set_hyperparameters(feature_dim = 1,
                           predictor_type = 'regressor',
                           mini_batch_size = 5,
                           epochs = 5,
                           num_models = 32,
                           loss = 'absolute_loss')**#pass in the training data from S3 to train the linear learner model** linear.fit({'train': s3_train_data})

步骤 6:部署训练好的线性学习模式

linear_regressor = linear.deploy(initial_instance_count = 1,
                                 instance_type = 'ml.m4.xlarge')

为了在我们的模型中进行推理，我们需要将数据转换成文本/CSV 格式。在这里阅读更多。

from sagemaker.predictor import csv_serializer, json_deserializerlinear_regressor.content_type = 'text/csv'
linear_regressor.serializer = csv_serializer
linear_regressor.deserializer = json_deserializer

对测试集的预测:

**# making prediction on the test data** result = linear_regressor.predict(X_test)
result

让我们取出结果编号并保存在Prediction板变量中:

**#access the scores by iterating through the scores in predictions** predictions = np.array([r['score'] for r in result['predictions']])
predictions

让我们检查结果作为一个DataFrame:

**#compare actual output values with predicted values** df = pd.DataFrame({'Actual': y_test.flatten(), 'Predicted': predictions.flatten()})
df

**# visualize comparison result as a bar graph** df1 = df.head(20)
df1.plot(kind='bar',figsize=(12,8))
plt.grid(which='major', linestyle='-', linewidth='0.5', color='green')
plt.grid(which='minor', linestyle=':', linewidth='0.5', color='black')
plt.show()

**#prediction vs test set**
plt.scatter(X_test, y_test,  color='blue')
plt.plot(X_test, predictions, color='red', linewidth=2)
plt.xlabel('Years of Experience (Testing Dataset)')
plt.ylabel('salary')
plt.title('Salary vs. Years of Experience')
plt.show()

差不多就是这样！

**重要:**如果不想被亚马逊收费，永远记得删除端点！

**# Delete the end-point** linear_regressor.delete_endpoint()

我希望这篇文章能帮助你更好地理解这个话题。欢迎任何反馈，因为它让我获得新的见解！

Azure 上带有自动预测的机器学习

原文：https://towardsdatascience.com/machine-learning-on-azure-with-automated-predictions-51d1721210f5?source=collection_archive---------17-----------------------

利用各种 Azure 服务创建端到端的生产机器学习管道

加州 17 英里路 Lone Cypress

我最近有机会在一家使用微软 Azure 作为人工智能平台的公司担任数据科学实习生。在我的一个项目中，我不得不推荐一个最优策略(设定点),在一个制造工厂中并行运行多个蒸汽锅炉。例如，在给定的特定条件下，以 100%(全容量)运行锅炉 1，以 50%运行锅炉 2，依此类推。目标是以最小的累积燃料输入满足工厂蒸汽需求。

由于这个问题的性质，锅炉的设定点将会 24/7 每分钟更新。

为了实现这一点，我在 Azure 上创建了一个端到端的机器学习(ML)管道。我所说的管道是指:

1. 将数据从本地服务器获取到云
2. 使用云计算创建预测模型，并将其部署为 API 端点
3. 每周 7 天、每天 24 小时自动进行预测，并将其存储回本地服务器(这被证明是很棘手的)
4. 创建用于监控性能的仪表板

在构建这个管道时，我发现微软的文档分散在几个产品中，而且不够直观，所以我认为分享我的工作流程并提供适当资源的链接会有所帮助。

工作流程可以总结在下图中。

这个博客的目的不是讨论 ML 方法论，而是理解如何利用不同的微软产品来创建端到端的生产管道。

那么，我们开始吧。

获取数据

在开始构建 ML 模型之前，我需要从本地 SQL server 查询相关的历史数据，并将其存储在云中。在这里，Azure Data Factory v2 ( ADF )派上了用场。ADF 允许您连接到本地数据库并编写 t-SQL 查询来将数据存储在 Azure Blob 存储中(Blob)。ADF 的 复制 工具(在移动和变换活动下)允许您复制所需的数据。

预测建模

一旦将所需数据存储在 blob 存储中，就可以使用 Azure 为开发 ML 模型提供的机器学习服务工作空间( ML Services )平台。如果你熟悉 Jupyter 笔记本环境，那么你会很高兴地知道 ML Services 允许你创建预装了重要库的笔记本。因此，您不需要担心环境的设置。

建立预测模型需要以下步骤:

1. 创建你的 Azure 机器学习工作空间，根据你的数据大小和计算需求指定虚拟机(VM)的大小。我使用了一个 3M 乘 13 的数据集，需要创建多个 ML 模型。因此，我决定使用 8 核 28 GB 虚拟机(V2 D4 标准)
2. 接下来，创建一个 Jupyter 笔记本和连接到 blob 存储器。一旦连接上，就可以很容易地将 blob 数据转换成 pandas 数据框架
3. 创建一个 Azure 机器学习计算目标，它将并行运行多个作业，以加速训练和超参数调优
4. 创建一个训练脚本，它将导入库、接受用户定义的参数、执行数据转换(如果有)、调整超参数、记录度量值等。基本上，它是在计算目标上运行的代码，用于训练您的模型
5. 创建一个评估器，其中包含训练脚本的位置、用户定义的参数值、所需的 conda 和/或 pip 库，以及计算目标
6. 使用定义的超参数搜索空间、提前终止策略、主要指标、最大超参数运行和最大并发作业，配置您的超参数调整实验。此外，提供将使用采样超参数调用的估计器(在上面的步骤中创建)
7. 提交实验并实时可视化超参数调整进度
8. 最后，群集返回最佳模型。使用完整的数据集重新训练它，注册最终模型用于部署

好的教程可以在这里找到。

部署模型

一旦最终的模型在工作空间中注册，我们需要将它部署为一个 API 端点，我们可以查询它以获得几乎即时的预测。为了创建 API，我使用了 Azure 容器实例( ACI )。

除了最终模型之外，您还需要以下内容来使用 ACI 成功部署模型:

1. 入口脚本:该脚本将通过部署的 web 服务提交的数据传递给最终模型。然后，它将输出返回给客户端
2. 依赖关系:创建一个. yml 文件，其中包含模型进行推理所需的包
3. 部署配置:这描述了 API 的计算资源，例如内核和内存的数量

一旦您有了最终的模型、入口脚本、依赖项和部署配置，您就可以创建一个 docker 映像并部署模型。

全天候自动预测

这是有趣的部分。我需要 24/7 每分钟向本地服务器数据库提交预测，所以我必须自动化预测部分。为此，我创建了一个 Databricks 笔记本(参见下面的代码示例),它获取输入，向 API 提交请求，并提交预测。流程可以总结如下:

1. 使用 ADF 将预测数据从本地服务器复制到云
2. 运行 databricks 记事本，并根据您的需求将预测存储在 blob 存储或 SQL 数据库中(我将在下面讨论这两者)
3. 使用 ADF 将预测从 blob 复制到本地 SQL 数据库

我的 ADF 管道快照，用于每分钟自动进行预测。绿色箭头确保前一个活动完成后，下一个活动才开始

为了每分钟都自动完成这个流程，您可以安排一个触发(触发的频率、开始和停止的时间等等。)在 ADF 中。跟随这个了解更多关于如何添加数据块到 ADF 的细节。

我的 Databricks 笔记本看起来像这样:

## Connect to the storage account containing input datastorage_account_name = 'storage_account_name' storage_account_access_key = 'access_key' spark.conf.set("fs.azure.account.key."+storage_account_name+".blob.core.windows.net", storage_account_access_key)

这将允许您连接到 blob 存储。接下来，我连接到特定的 blob 并将其转换为 pandas 数据帧。

## To read in the blob as spark dataframedf = spark.read.csv(“wasbs://folder@storage_account_name.blob.core.windows.net/blob_name”, header = True)
df_panda = df.toPandas()

现在，你有了熊猫数据框架中的数据。如果有的话，进行必要的数据转换。然后，调用 API 端点来获得预测。

## Post requests to API end-point to get predictions
uri = ‘API_end_point’
test_samples = json.dumps({‘input data feature’: values})
test_samples = bytes(test_samples, encoding=’utf8')
fitness_ga = requests.post(uri, test_samples, headers = {‘Content-Type’: ‘application/json’})
ng_pred = [fitness_ga.json()]
pd_df = spark.createDataFrame(pd.DataFrame(ng_pred))

这里 pd_df 是包含预测的火花数据帧。最后，您可以将这些预测保存到 Azure SQL Server 数据库或 blob，如下所示。

将数据块连接到 Azure SQL Server 数据库

## Connecting to SQL server database from databricks
jdbcHostname = ‘your_sql_server_name.database.windows.net’
jdbcDatabase = ‘sql_server_database_name’ 
jdbcPort = 1433
jdbcUsername=’your_sql_server_username’
jdbcPassword=’your_sql_server_password’jdbcUrl = “jdbc:sqlserver://{0}:{1};database={2}”.format(jdbcHostname, jdbcPort, jdbcDatabase)
connectionProperties = { “user” : jdbcUsername, 
“password” : jdbcPassword, 
“driver” : “com.microsoft.sqlserver.jdbc.SQLServerDriver”} ## append spark dataframe to SQL database
mode=’append’
pd_df.write.jdbc(url=jdbcUrl, table=”sql_table_name”, mode=mode, properties=connectionProperties)

将数据块连接到 Azure Blob 存储

## Connecting Databricks to Azure blob storage
output_container_path = “wasbs://folder@storage_account_name.blob.core.windows.net”
output_blob_folder = output_container_path+”/temporary_blob_name” ## overwrite the blob, this creates a bunch of files
pd_df.coalesce(1).write.mode(“overwrite”).option(‘header’, ‘true’).format(‘com.databricks.spark.csv’).save(output_blob_folder) ## move the required data to blob where you want predictions finally
files = dbutils.fs.ls(output_blob_folder)output_file = [x for x in        files if x.name.startswith(‘part-’)]
dbutils.fs.mv(output_file[0].path, output_container_path+’/blob_name’)

仪表盘

一旦开始用预测填充本地数据库，就可以用 PowerBI 连接本地数据库。PowerBI 让您只需从数据库表中拖放字段，就可以创建令人惊叹的可视化效果。一旦您在 PowerBI 中获得了所需的数据，您就可以计算和可视化关键性能指标(KPI)来衡量您的模型的性能。例如，在我的例子中，一个 KPI 可以是一段时间内的产出与投入(效率)的比率。创建后，您可以在数据库更新时自动更新仪表板。

事实上，在分析您的数据时，PowerBI 非常方便，可以节省您的时间和编码工作，同时创建出版物质量的交互式图表。

重要的考虑和学习

1. 成本 :涉及两大成本，ML 服务的虚拟机(VM)和数据块集群。根据数据的大小和建模的复杂程度，您必须决定虚拟机内核和内存的最佳数量。同样，选择大于所需的 Databricks 集群可能会导致更高的成本。此外，确保在不使用时停止 ML 服务工作区和 Databricks 集群，以节省不必要的额外成本
2. 延迟与模型复杂性:在我的情况下，我有多个 ML 模型，每分钟都需要预测(从本地服务器获取数据到将预测提交回本地服务器需要 1 分钟)。因此，我需要选择一个预测时间最短的模型，同时又不影响预测的准确性。 LightGBM 对我很有效
3. 为什么是数据砖块？ :我知道我可以使用 ADF 自动触发一个管道，ADF 允许我使用 Databricks notebook 作为活动。因为我可以用 Databricks 编写 python 和 spark 代码，所以这对我来说是一条自然的道路
4. 从内部部署到云 :从内部部署的 SQL 数据库向云查询大量数据可能非常耗时。因此，确保将查询的数据保存在云上的某个地方。例如，如果您想在 3 个月后重新训练您的模型，您只需要查询最近 3 个月的附加数据
5. 数据块到数据库 :我无法直接从数据块将预测写入本地数据库。但是，能够使用 ADF 将预测从 azure blob 存储写入本地数据库
6. 输出错误日志 : Azure 在出错时输出错误日志。例如，如果您在超参数调整或部署模型时遇到错误，阅读错误日志可以节省您大量的调试时间
7. XGBoost 风扇 :在 ML 服务中，XGBoost 不会预装 Jupyter 笔记本。要获得 XGBoost，将下面的代码复制粘贴到 jupyter 笔记本中，它应该可以工作了

*import sys
!conda install — yes — prefix {sys.prefix} py-xgboost
!conda install -y anaconda py-xgboost*

从头开始设计如此复杂的管道可能很难，尤其是如果你是 Azure 的新手。希望这篇博客能帮助你开始。您可以创建一个 Microsoft Azure 免费帐户，并开始使用他们的大部分服务。关于如何开始的更多细节，请跟随这个。

最后，我想真诚地感谢我的合作者 Radek Rybicki，他帮助我定义了这个项目，并指导我完成了它的不同阶段。

这是我的第一个数据科学博客，我真的很兴奋能继续写博客。如果您有任何意见和/或建议，请告诉我。我们可以稍后更详细地讨论管道的每个方面。

机器学习或回归的意想不到的优点

原文：https://towardsdatascience.com/machine-learning-or-the-unexpected-virtue-of-regression-b466a341acac?source=collection_archive---------51-----------------------

我希望在艰难地学会 ML 之前就知道的事情

照片由张秀坤镰刀在 Unsplash 上拍摄

计算机可以学习的想法激发了我们的想象力。我们看到机器人，自动驾驶汽车，我们想知道这怎么可能？好的，我们可以试着对我们的笔记本电脑说“来吧，伙计，跟着我学”。这是个好主意，不是吗？哦，你是对的，它不是那样工作的…暂时。

理解计算机如何能够学习东西可能是相当令人生畏的。我去过那里，努力研究人工神经网络是如何工作的。最后，所有元素都点击了。然而，我学得越多，就越明白我应该从一个不同的位置开始，让学习变得更容易、更有效。

这就是为什么我分享一个解释我们的计算机如何学习的故事。你也会发现回归并不总是意味着坏事。实际上，它会给你一个坚实的开端，让你进入机器学习的迷人世界。

闪回

想象一个典型的计算机科学学生。戴着眼镜，穿着极客 t 恤，因为熬夜和学习(或者玩电子游戏)看起来很累。主要的光源是一台来自计算机的显示器，太阳不是他的朋友。那是我，几年前。我已经了解了神经网络是如何工作的，我将参加关于更高级智能系统的实验室。实验开始了，我拿到任务，开始阅读:

实施一种智能方法…

这个简单的句子打动了我。什么是智能方法？我试图按照 费曼手法【1】去学习东西:

第一步:选择一门你想学的学科，开始学习。

第二步:试着像对孩子解释一样解释。

我无法完成第二步，所以我决定问问我的讲师。他是这么回答的:

“嗯，我认为每一种需要某种训练的方法都是智能的或机器学习的方法。你知道，动物和人通常被认为是聪明的。我们需要训练来掌握我们需要的技能。你的程序也努力训练，为你解决问题。”

这个简单的，非正式的定义是辉煌的。只是模仿一个程序，把它看作一个运动员或学生，他们通过试错变得越来越好。而且在实现目标的过程中非常执着。这就是机器学习的大视野。

记住这幅图，让我们来解释机器学习的主要方法之一，即监督学习。

回到学校

我喜欢把监督学习比作被老师思考。让我们回到我们上小学的时候。坐在教室里，等待老师教我们如何识别不同种类的树叶，如何命名和书写字母和数字。

疾控中心在 Unsplash 上拍摄的照片

可能你的老师给了你一些例子。例如，他们给你看不同树的叶子，并给这些树命名。此外，它们可以让你注意到叶子的一些特征，如形状、颜色或结构。上完这一课后，你可以在公园散步时摘一片叶子，给一棵树命名。

这个想法适用于监督学习。首先，你是老师。你想解决某个任务，想教某人如何去做。这意味着你需要一个学生。在机器学习世界中，它通常是一个数学模型(比如一个方程或一组以特定方式组合的数字)。

然后，你要准备你的例子和每个例子的正确答案。这个数据集对于解决你的任务应该是有用的(例如，如果你想有一个识别它们的程序，树叶的照片)。

有了这个数据集，你就可以向你的模型展示你的例子了。您检查模型的反应，并将其与正确答案进行比较。最后，您必须调整您的模型参数(通常是许多数字)，以便它正确响应。

呈现示例、将模型的响应与正确答案进行比较以及调整参数的过程是迭代的。你重复它直到你的模型学习正确的答案。

寓教于乐

现在我们可以进入更多的细节，并尝试使用 ML 解决一个问题。所以作为一名教师，你想激发学生学习 ML 的好奇心。大概很多同学都爱超级英雄(我也爱他们)。你可以在任何地方找到它们，它们成为了我们文化的一部分。

照片由 Ali Kokab 在 Unsplash 上拍摄

所以我们来公式化一个你想解决的问题。你想知道超级英雄服装和他们的受欢迎程度之间有什么关系。

首先，我们来准备我们的例题和正确答案。为了做到这一点，我们需要弄清楚我们可以使用什么样的数据来建立服装和流行之间的关系。

幸运的是，浏览互联网会给你带来一个绝妙的主意。金钱可以很好地反映受欢迎程度。让我们试一试。选择大约 50 个超级英雄，检查我们需要为每个超级英雄服装支付多少钱。

然后你可以找到超级英雄出现的漫画书数量，并假设他们出现的越多越好。为了找到这样的数据，我们将使用下面的【2】。

综合来看，排名中的每个超级英雄都有两个数字。服装价格(x)，漫画出镜率(y):

超级英雄数据集。(图片由作者提供)

这是我们的数据集。因为每行有两个数字，我们可以画一个图，看看它在 2D 是什么样子。

2D 的超级英雄。

现在是时候选择我们的学生了，一个将学习如何解决任务的机器学习模型。如果你看我们的情节，你可能会看到这个趋势，越贵的服装越多的漫画出现。如果我给你一支笔，让你画出这个趋势，你可以画一条简单的直线。

用我们自己的大脑画出一个趋势。(图片由作者提供)

它非常符合我们的数据，不是吗？所以让我们用一条线作为我们的 ML 模型。

是鸟…是飞机…是线性回归！

我们将要使用的方法的正式名称是线性回归[3]。这是一种建模变量之间关系的方法。你可以用它来检查房子的大小与价格的关系，或者电流与电压的关系。我们想知道服装价格和漫画形象之间的关系。

我们的模型是一个线性方程(f(x)-漫画书发行数量)，有两个参数θ₀，θ₁(thetas)和变量 x(服装价格)。

线方程。(图片由作者提供)

它是如何工作的？让我们假设θ₀= 1，θ₁= 1。这意味着如果我们把 0 作为 x，我们有 0 乘以 1 等于 0，加上 1 等于 1。对于 x = 2，它是 2 乘以 1，加上 1 就是 3。我们可以用这些点(0，1)，(2，3)来画一条线。

θ₀= 1，θ₁= 1 的线性函数草图(图片由作者提供)

如果我们改变参数，我们的线将通过不同的点。当然，在我们的机器学习风味的线性回归中，我们希望自动找到最佳参数。我们的程序将尝试不同的θ值，它需要知道这些参数正常意味着什么。这就是为什么我们需要一个目标函数。

测试你的学生

在 ML 中，能够评估你的模型是非常重要的。你只需要知道它的表现是好是坏。我们使用所谓的目标函数来实现。让我们定义我们的线性回归目标函数。

线性回归目标函数。(图片由作者提供)

目标函数 Q 取决于在我们的程序寻找解决方案时改变的 thetas 参数，以及代表超级英雄的数据点(点是不变的，它们是真理的来源)。

按照这个公式，我们需要遍历所有的数据点(按照 jᵗʰ指数编号)。所以拿第一点来说，得到它的服装价格(xʲ)并计算函数 f 的一个值。然后减去这一点的漫画书发行数量(yʲ).将结果平方，并将其添加到总和中。对我们数据集中的每一点都这样做。

为了更容易理解，让我们看看这些例子。从我们的数据集中抓取一个点。想象一下，f(xʲ对这一点给你 4，而 yʲ等于 2。将这些值代入目标函数公式:

图片作者。

如你所见，在计算了这个特定点的目标函数公式后，我们得到了 4。这意味着我们需要在总和上加 4。好了，和在增长，去下一个点。

图片作者。

函数 f(xʲ的时间值是 1，而我们期望的是 1 (yʲ=1).如你所见，根据目标函数公式，我们在这一点上得到了 0。这意味着我们不需要添加任何东西到我们的总和，它保持在同一水平。

这就是我们的目标函数的工作方式！总和越接近 0 越好。如果数据点的函数值 f(x)接近或等于期望值(y)，这意味着我们找到了最佳θ参数。换句话说，当例子与正确答案相匹配时，我们会很高兴。所以我们需要最小化目标函数(总和应该很低)来解决我们的问题。

机器学习的超级英雄

为了最小化我们的目标函数，我们将使用梯度下降算法【3，4】。对我来说，它是 ML 中的主要算法之一。其背后的基本思想通常用于复杂而强大的 ML 方法，如深度学习[4]。幸运的是，我们可以用一种非常简单的方式将它用于线性回归任务，并理解它是如何工作的。

首先，梯度下降是一种迭代算法。在每次迭代中，我们按照神秘的公式更新θ参数:

图片作者。

图片作者。

别担心，它看起来比实际复杂得多。开始之前，我们将θ初始化为一些随机值。然后我们开始更新它们。θ₀(t)和θ₁(t)是当前迭代(t)中θ参数的值。我们通过减去α，也称为学习步长(小实数，如 0.25)，乘以我们的目标函数的偏导数(∂q/∂θ)来改变它们。好吧，这听起来不简单，为什么我们需要衍生品？

关于导数你需要知道的最重要的事情是，函数的导数告诉你函数是如何变化的。如果你的函数是递增的，这个函数在这一点的导数将是正的。如果它在减少，导数将是负的。

为了简单起见，让我们假设我们的目标函数是一个简单的抛物线。其值取决于θ参数(θ轴)。如果我们计算函数 f 在抛物线上升点的导数，导数的值将是正的。在梯度下降公式中，它成立:-α乘以正导数。负乘以正得出一个负值
(例如-4 * 3 = -12)。这意味着我们需要从当前的θ中减去一些东西。

在下一次迭代中，我们计算一个新点的导数，如果它是正的，我们再从θ中减去一些。这就是我们如何在几个步骤中达到最小值。为了更好的理解，我们来形象化一下。

当从抛物线的上升边缘开始时，通过减法更新θ。(图片由作者提供)

如果我们把起点选在抛物线的递减边缘，我们的导数将是负的。所以当我们遵循梯度下降公式时，我们有-α倍的负导数。负乘以负得出正值(例如(-2)*(-3) = 6)。所以现在我们在θ上加一些东西。加法意味着我们在θ轴上向右移动。按照同样的步骤，我们最终达到最小值。这是视觉效果。

当从抛物线的递减边缘开始时，通过增加来更新θ。(图片由作者提供)

这就是如何使用梯度下降来最小化目标函数并找到最佳θ。想象你正在下山**。不管你在哪里，计算导数的值，反方向(-α)到达山谷。把这个想法记在脑子里。计算机就是这样学习的。**

买一套超级英雄服装要花多少钱？

最后，我们有了拼图的所有元素:

1. 数据集(代表超级英雄的点)
2. 模型(直线方程)
3. 目标函数(对我们所有的点进行巧妙的求和)
4. 学习算法(梯度下降)

让我们运行梯度下降 1000 次迭代。这意味着我们将更新这两个标签 1000 次。那么我们的程序应该已经有最好的 thetas 了。

我们的最佳 thetas 是:

最佳 thetas。(图片由作者提供)

当我们将它们代入线方程时，我们得到:

我们数据集的最佳直线方程。(图片由作者提供)

这就是我们的模型从数据集中学到的，但我同意这不是很有用。为了让它更实用，我们可以让它来回答我们的问题。假设你想投资 1 000 美元购买超级英雄服装(这是一大笔钱，但超级英雄的崇拜者会这么做)。一张图胜过千言万语，让我们画出最佳路线:

基于机器学习的服装价格对商品图书发行的线性回归模型。(图片由作者提供)

多亏了我们的模型，我们看到，如果我们投资如此昂贵的服装，它预测大约 8000 本漫画书会出现。不错啊，我们可以跻身出版最多的超级英雄前 10 名了！

你要去冒险了

关于老师，学生，识别树叶，解决超级英雄问题的故事到此结束。然而，这是你进入机器学习世界的旅程的开始。现在你对计算机如何学习有了直觉，并且熟悉了最强大的 ML 概念之一，梯度下降算法。如果你对本文介绍的 ML 风格线性回归的实际实现感兴趣，请查看我的 Github 库 [5]。

是时候更进一步了，认识新的算法，概念，问很多问题。也许值得检查一下当教室里没有老师时会发生什么？如果是这样，理解无监督学习应该是你的下一步。

参考书目:

1. https://interesting engineering . com/learn-like-an-engineer-the-Feynman-technique
2. https://www . ranker . com/list/super heroes-rank-by-most-comic-book-appearances/ranker-comics
3. Grus Joel,《从零开始的数据科学》,第二版，奥赖利媒体公司。
4. 帕特森乔希，吉布森亚当，深度学习，奥莱利媒体公司。
5. https://github.com/rauluka/mluvr-regression

机器学习感知器实现

原文：https://towardsdatascience.com/machine-learning-perceptron-implementation-b867016269ec?source=collection_archive---------34-----------------------

Python 使用增量规则(梯度下降)

照片由摄影师在 Unsplash 上拍摄

在这篇文章中，我们将看看用numpy用Python3写的一个程序。我们将讨论什么是感知器的基础知识，什么是 delta 规则以及如何使用它来收敛感知器的学习。

什么是感知器？

感知器是二元分类器监督学习的算法(让我们假设{1, 0})。我们有一个权重向量和输入数据向量的线性组合，它通过一个激活函数，然后与一个阈值进行比较。如果线性组合大于阈值，我们预测该类为1，否则为0\. Mathematically,

资料来源:stackexchange.com

感知器只代表线性可分的问题。如果训练样本不是线性可分的，它们就不能收敛。这就带来了德尔塔法则。

delta 规则向目标概念的最佳近似收敛。其核心思想是利用 梯度下降 搜索所有可能权重向量的假设空间。

注意:这为“反向传播”算法提供了基础。

现在，让我们讨论一下手头的问题。程序将读取一个数据集(制表符分隔文件)，并将第一列视为目标概念。目标概念中存在的值是 **A 和 B，**我们将把 A 视为+ve 类或1，把 B 视为-ve 类或0。该程序以批处理模式实现感知器训练规则，具有恒定的学习速率和退火(随着迭代次数的增加而减少)学习速率，从学习速率为 1 开始。

其中 Y(x，w)是被错误分类的样本集。我们将使用错误分类点的计数或数量作为我们的错误率(即| Y(x，w)|)。输出也将是包含每次迭代误差的制表符分隔(tsv)文件，即它将有 100 列。同样，它将有 2 行，一行用于正常学习率，一行用于退火学习率。

现在，理解什么是感知机，什么是德尔塔法则，以及我们将如何使用它。让我们开始实施Python3。

在程序中，我们从命令行提供两个输入。它们是:

1.数据 —数据文件的位置。

2.输出—tsv 解决方案的写入位置

因此，程序应该能够这样启动:

python3 perceptron.py --data data.tsv --output solution.tsv

该程序由 8 部分组成，我们将一次看一个。

进口报表

import argparse # to read inputs from command line
import csv # to read and process dataset
import numpy as np # to perform mathematical functions

代码执行初始化程序块

# initialise argument parser and read arguments from command line with the respective flags and then call the main() functionif __name__ == '__main__':    
    parser = argparse.ArgumentParser()    
    parser.add_argument("-d", "--data", help="Data File")        
    parser.add_argument("-o", "--output", help="output")    
    main()

[main()](https://gist.github.com/tarunlnmiit/744221fb4289efc5d1e02d2a20b251d1)功能

main()功能的流程如下:

1. 将各自的命令行输入保存到变量中
2. 设置开始学习率= 1
3. 使用csv和delimiter='\t'读取数据集，在X中存储自变量，在Y中存储因变量。我们将1.0作为偏差添加到我们的独立数据中
4. 独立数据和从属数据被转换为浮点型
5. 重量向量用与X维数相同的零初始化
6. normal error和anneal error通过调用各自的方法来计算
7. 最后，输出保存到一个 tsv 文件中

calculateNormalBatchLearning()函数

calculateNormalBatchLearning()的流程如下:

1. 初始化变量e以存储错误计数
2. 循环运行 100 次迭代
3. 使用calculatecopredictedvalue()方法，根据之前描述的感知器规则计算预测值
4. 使用 calculateError() 方法计算错误计数
5. 使用 calculateGradient() 方法根据上述等式更新权重

calculateanelbatchlearning()函数

calculateNormalBatchLearning()的流程如下:

1. 初始化变量e以存储错误计数
2. 循环运行 100 次迭代
3. 使用calculatecopredictedvalue()方法，根据之前描述的感知器规则计算预测值
4. 使用 calculateError() 方法计算错误计数
5. 学习率除以迭代次数
6. 使用 calculateGradient() 方法根据上述等式更新权重

calculated predicted value()函数

如感知器图像所述，如果W和X的线性组合大于0，那么我们预测类为1否则为0。

calculateError() 函数

我们计算预测值和真实值不匹配的情况的数量，这成为我们的错误计数。

calculateGradient() 函数

该方法是上述权重更新公式的翻译。

我将免费赠送一本关于一致性的电子书。在这里获得你的免费电子书。

现在，所有的代码都在外面。让我们来看看程序的执行情况。

下面是输出的样子:

最终程序

如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金，不需要你额外付费。

**** [## 加入我的推荐链接-塔伦古普塔

作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…

tarun-gupta.medium.com](https://tarun-gupta.medium.com/membership)

这是我的故事索引:

[## 标记故事列表的快速链接—感谢您的访问

我也有一份以快节奏出版为目标的出版物。读书成为作家。

tarun-gupta.medium.com](https://tarun-gupta.medium.com/thank-you-for-visiting-my-profile-9f708062c75e)****

使用 Kubeflow 的机器学习管道

原文：https://towardsdatascience.com/machine-learning-pipelines-with-kubeflow-4c59ad05522?source=collection_archive---------5-----------------------

如何使用 Kubeflow 管道自动化机器学习工作流

为什么是机器学习管道？

现在，人们对机器学习管道的想法给予了很多关注，这意味着自动化和协调训练机器学习模型所涉及的各种步骤；然而，将机器学习工作流建模为自动化管道的好处并不总是很清楚。

当承担训练新的 ML 模型的任务时，大多数数据科学家和 ML 工程师可能会从开发一些新的 Python 脚本或交互式笔记本开始，这些脚本或笔记本执行必要的数据提取和预处理，以构建一组干净的数据来训练模型。然后，他们可能会创建几个额外的脚本或笔记本来尝试不同类型的模型或不同的机器学习框架。最后，他们将收集和探索指标，以评估每个模型在测试数据集上的表现，然后确定将哪个模型部署到生产环境中。

人工机器学习工作流程。(图片由作者提供)

这显然是对真正的机器学习工作流的过度简化，但关键是这种通用方法需要大量的人工参与，并且除了最初开发它的工程师之外，任何人都无法重用或轻松重复。

我们可以使用机器学习管道来解决这些问题。我们可以将这个工作流程视为一系列独立的模块化步骤，每个步骤都专注于一个特定的任务，而不是将数据准备、模型训练、模型验证和模型部署视为针对我们正在工作的特定模型的单个代码库。

机器学习管道。(图片由作者提供)

将我们的机器学习工作流建模为机器学习管道有许多好处:

• 自动化:通过消除人工干预的需要，我们可以安排我们的管道以特定的节奏重新训练模型，确保我们的模型适应训练数据随时间的漂移。
• 重用:由于管道的步骤与管道本身是分离的，我们可以很容易地在多个管道中重用单个步骤。
• 可重复性 : 任何数据科学家或工程师都可以重新运行管道，然而，通过手动工作流，现在可能总是很清楚不同脚本或笔记本需要以什么顺序运行。
• 环境的解耦:通过保持机器学习流水线的步骤解耦，我们可以在不同类型的环境中运行不同的步骤。例如，一些数据准备步骤可能需要在大型机器集群上运行，而模型部署步骤可能在单台机器上运行。

如果你有兴趣深入研究机器学习管道及其优势，Google Cloud 有一篇很棒的文章，描述了更好、更自动化的实践(包括 ML 管道)的自然进展，团队可以采用它来完善他们的 ML 工作流: MLOps:机器学习中的连续交付和自动化管道

什么是库伯流？

Kubeflow 是一个基于 Kubernetes 的开源平台，旨在简化机器学习系统的开发和部署。在官方文档中被描述为 Kubernetes 的 ML 工具包，Kubeflow 由几个组件组成，跨越了机器学习开发生命周期的各个步骤。这些组件包括笔记本开发环境、超参数调优、功能管理、模型服务，当然还有机器学习管道。

Kubeflow 中央仪表盘。(图片由作者提供)

在本文中，我们将只关注 Kubeflow 的管道组件。

环境

为了运行示例管道，我使用了在裸机上运行的 Kubernetes 集群，但是您可以在安装了 Kubeflow 的任何 Kubernetes 集群上运行示例代码。

本地唯一需要的依赖项是 Kubeflow Pipelines SDK。您可以使用 pip 安装 SDK:

pip install kfp

库伯弗洛管道公司

Kubeflow 中的管道由一个或多个组件组成，它们代表管道中的各个步骤。每个组件都在自己的 Docker 容器中执行，这意味着管道中的每个步骤都可以有自己的依赖集，独立于其他组件。

对于我们开发的每个组件，我们将创建一个单独的 Docker 映像，它接受一些输入，执行一个操作，然后公开一些输出。我们还将有一个单独的 python 脚本，pipeline.py,它从每个 Docker 映像创建管道组件，然后使用这些组件构建一个管道。

我们将总共创建四个组件:

• 预处理-数据 : 该组件将从sklearn.datasets加载波士顿住房数据集，然后将数据集拆分为训练集和测试集。
• train-model :该组件将训练一个模型，使用波士顿住房数据集来预测波士顿房屋的中值。
• 测试模型:该组件将计算并输出测试数据集上模型的均方误差
• deploy-model :在本文中，我们不会关注模型部署或服务，所以这个组件只会记录一条消息，说明它正在部署模型。在真实的场景中，这可能是将任何模型部署到 QA 或生产环境的通用组件。

ML 管道图视图。(图片由作者提供)

如果所有这些关于组件和 Docker 图像的讨论听起来令人困惑:不要担心，当我们进入代码时，它们应该会变得更有意义。

组件:预处理数据

我们管道中的第一个组件将使用sklearn.datasets加载波士顿住房数据集。我们将使用 Sci-kit learn 的train_test_split函数将这个数据集分成训练集和测试集，然后我们将使用np.save将我们的数据集保存到磁盘，以便它可以被后面的组件重用。

到目前为止，这只是一个简单的 Python 脚本。现在我们需要创建一个 Docker 映像来执行这个脚本。我们将编写一个 Dockerfile 文件来构建映像:

从python:3.7-slim基础映像开始，我们将使用pip安装必要的包，将预处理 Python 脚本从我们的本地机器复制到容器，然后将preprocess.py脚本指定为容器入口点，这意味着当容器启动时，它将执行我们的脚本。

建设管道

现在我们开始管道工程。首先，您需要确保我们上面定义的 Docker 映像可以从您的 Kubernetes 集群中访问。出于这个例子的目的，我使用了 GitHub Actions 来构建图像并将其推送到 Docker Hub 。

现在让我们定义一个组件。每个组件都被定义为一个返回类型为ContainerOp的对象的函数。这种类型来自我们之前安装的kfp SDK。下面是我们管道中第一个组件的组件定义:

注意，对于image参数，我们传递由上面的 Docker 文件定义的 Docker 图像的名称，对于file_outputs参数，我们指定由组件 Python 脚本保存到磁盘的四个.npy文件的文件路径。

通过将这四个文件指定为文件输出，我们使它们可用于管道中的其他组件。

注意:在我们的组件中硬编码文件路径并不是一个很好的做法，因为，正如你从上面的代码中看到的，这要求创建组件定义的人知道关于组件实现的具体细节(也就是包含在 Docker 映像中的实现)。让我们的组件接受文件路径作为命令行参数会干净得多。这样，定义组件的人可以完全控制输出文件的位置。我以这种方式对它进行了硬编码，希望可以更容易地看到所有这些部分是如何组合在一起的。

定义了第一个组件后，我们可以创建一个使用预处理数据组件的管道。

管道定义是一个用@dsl.pipeline注释修饰的 Python 函数。在函数中，我们可以像使用任何其他函数一样使用组件。

为了执行管道，我们创建一个kfp.Client对象并调用create_run_from_pipeline_func函数，传入定义管道的函数。

如果我们执行这个脚本，然后导航到 Kubeflow 中央仪表板的 Pipelines 部分中的 Experiments 视图，我们将看到我们的管道的执行。我们还可以通过在管道的图形视图中单击组件来查看来自预处理数据组件的四个文件输出。

Kubeflow 管道用户界面。(图片由作者提供)

因此，我们可以执行我们的管道，并在 GUI 中可视化它，但是只有一个步骤的管道并不那么令人兴奋。让我们创建剩余的组件。

剩余组件

对于 train-model 组件，我们将创建一个简单的 python 脚本，它使用 Sci-kit learn 训练一个回归模型。这应该类似于预处理组件的 python 脚本。最大的区别是，这里我们使用argparse接受训练数据的文件路径作为命令行参数。

同样，docker 文件与我们用于第一个组件的文件非常相似。我们从基本映像开始，安装必要的包，将 python 脚本复制到容器中，然后执行脚本。

另外两个组件测试模型和部署模型遵循相同的模式。事实上，它们与我们已经实现的两个组件非常相似，为了简洁起见，我不会在这里展示它们。如果你感兴趣，你可以在这个 GitHub 仓库中找到管道的所有代码:https://github.com/gnovack/kubeflow-pipelines

就像前面的预处理-数据组件一样，我们将从这三个组件中构建 Docker 映像，并将它们推送到 Docker Hub:

• 列车型号:gnovack/Boston _ pipeline _ train
• 测试模型:gnovack/Boston _ pipeline _ test
• 部署模型:gnovack/Boston _ pipeline _ deploy

完整的管道

现在是时候创建完整的机器学习管道了。

首先，我们将为训练模型、测试模型和部署模型组件创建组件定义。

train-model 组件的定义与之前的预处理数据组件的定义之间唯一的主要区别是 train-model 接受两个参数，x_train和y_train，这两个参数将作为命令行参数传递给容器，并将在使用argparse模块的组件实现中解析出来。

现在定义测试模型和部署模型组件:

定义了四个管道组件后，我们现在将重温前面的boston_pipeline函数，并一起使用我们所有的组件。

让我们来分解一下:

• 注意第 6 行的**，当我们调用preprocess_op()函数时，我们将函数的输出存储在一个名为_preprocess_op的变量中。为了访问预处理数据组件的输出，我们调用_preprocess_op.outputs['NAME_OF_OUTPUT']。**
• 默认情况下，当我们从一个组件访问file_outputs时，我们得到的是文件的内容而不是文件路径。在我们的例子中，由于这些不是纯文本文件，我们不能仅仅将文件内容作为命令行参数传递给组件 Docker 容器。为了访问文件路径，我们使用dsl.InputArgumentPath()并传入组件输出。

现在，如果我们从管道创建一个运行，并导航到 Kubeflow central 仪表板中的管道 UI，我们应该会看到管道图中显示的所有四个组件。

Kubeflow 管道用户界面。(图片由作者提供)

结论

在本文中，我们创建了一个非常简单的机器学习管道，它加载一些数据，训练一个模型，在维持数据集上评估它，然后“部署”它。通过使用 Kubeflow 管道，我们能够将工作流中的每个步骤封装到管道组件中，每个组件都运行在自己的、隔离的 Docker 容器环境中。

这种封装促进了我们的机器学习工作流中各步骤之间的松散耦合，并为在未来的管道中重用组件提供了可能性。例如，在我们的培训组件中没有任何东西是专门针对波士顿住房数据集的。我们可以在任何时候使用 Sci-kit learn 训练回归模型时重用这个组件。

我们只是触及了 Kubeflow 管道的表面，但是希望本文能帮助您理解组件的基础，以及我们如何一起使用它们来创建和执行管道。

如果您有兴趣探索本文中使用的全部代码库，您可以在 GitHub repo 中找到它们:https://github.com/gnovack/kubeflow-pipelines

参考文献

• https://kube flow-pipelines . readthedocs . io/en/latest/index . html
• https://www . kube flow . org/docs/pipelines/SDK/build-component/
• MLOps:机器学习中的连续交付和自动化管道

感谢阅读！如有任何问题或意见，请随时联系我们。

使用 Scikit-Learn 的机器学习管道

原文：https://towardsdatascience.com/machine-learning-pipelines-with-scikit-learn-d43c32a6aa52?source=collection_archive---------3-----------------------

构建机器学习管道的分步教程

照片由昆腾·德格拉夫在 Unsplash 拍摄

概观

这篇文章将作为一步一步的指南来建立流水线，简化机器学习的工作流程。我将在本教程中使用臭名昭著的泰坦尼克号数据集。数据集是从 Kaggle 获得的。目标是预测一个给定的人是否幸存。我将实现各种分类算法，以及网格搜索和交叉验证。该数据集包含每位乘客的记录，由 10 个变量组成(见下面的数据字典)。出于本教程的目的，我将只使用train数据集，它将被分成训练集、验证集和测试集。

(图片由作者提供)

为什么是管道？

机器学习工作流由数据准备的许多步骤组成(例如，处理缺失值、缩放/编码、特征提取)。当第一次学习这个工作流程时，我们一次执行一个步骤的数据准备。这可能会变得很耗时，因为我们需要对训练和测试数据都执行准备步骤。管道允许我们通过编译准备步骤来简化这个过程，同时减轻模型调整和监控的任务。Scikit-Learn 的 Pipeline 类提供了一种结构，用于应用一系列数据转换，然后是一个估计器(Mayo，2017)。有关更详细的概述，请查看 文档 。实现管道有很多好处:

• **便利性和封装性:**我们只对数据调用一次fit和predict，以适应整个估计器序列。
• **联合参数选择:**我们可以对管道中所有估计器的参数进行网格搜索。
• **交叉验证:**管道有助于避免数据在交叉验证过程中从测试数据泄露到训练好的模型中。这是通过确保使用相同的样本来训练变压器和预测器来实现的。

是时候看看管道的运行了！下面，我将安装并导入必要的库。然后继续加载数据集并处理缺失值。一旦数据准备好了，我将为不同的数据类型创建转换器，并创建一个列转换器来封装预处理步骤。最后，我将编写一个函数来训练一个具有交叉验证的模型，以及一个类似的函数，包括网格搜索交叉验证。

• 安装 Scikit-Learn

!pip install -U scikit-learn

• 导入必要的库

***# Standard Imports*** import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
import pickle

***# Transformers*
from sklearn.preprocessing** import LabelEncoder, OneHotEncoder, StandardScaler, MinMaxScaler

***# Modeling Evaluation*
from sklearn.model_selection** import train_test_split, cross_val_score, KFold, GridSearchCV
**from sklearn.metrics** import accuracy_score, precision_score, recall_score,f1_score, confusion_matrix, classification_report
**from IPython.display** import display, Markdown
***# Pipelines***
**from sklearn.pipeline** import Pipeline, FeatureUnion
**from sklearn.base** import BaseEstimator, TransformerMixin
**from sklearn.compose** import ColumnTransformer
***# Machine Learning***
**from sklearn.tree** import DecisionTreeClassifier
**from sklearn.ensemble** import RandomForestClassifier
**from** **sklearn.model_selection** **import** KFold
**from** **sklearn.neighbors** **import** KNeighborsClassifier

• 加载数据并查看前 5 行

**df =** pd.read_csv("titanic.csv")
df.head()

作者图片

• 检查缺失值

df.isna().sum()

在Age列中有 891 个缺失值中的 177 个。出于本管道教程的目的，我将继续用平均年龄填充缺失的Age值。在Cabin列中有 891 个缺失值中的 687 个。我正在删除这个特性，因为大约 77%的值丢失了。Embarked特性只缺少 2 个值，所以我们可以用最常见的值来填充它们。Name和Ticket功能对每个乘客都有独特的价值，预测分类不需要这些功能，因此也将被删除。

• 下降特性

df.drop(["Name", "Ticket", "Cabin"], axis=1, inplace=True)

• 填充 na 值为 **Embarked** 特征中出现频率最高的值， **S** 。

**df.Embarked =** df.Embarked.fillna(value='S')

既然我们已经处理了数据集中的缺失值，我们可以继续定义连续变量和分类变量。

• 为数据帧中的列定义变量，以执行训练测试分割。

**columns =** ['Pclass', 'Sex', 'SibSp', 'Parch', 'Fare', 'Embarked']**numerical_columns =** ['Age', 'Fare']**categorical_columns =** ["Pclass", "Sex",
                       "SibSp", "Parch", "Embarked"]

接下来，我将创建两个函数。第一个函数cross_validate将接受一个分类器和 cv(交叉验证器),将训练数据分成训练集和测试集，使分类器适合训练，并对其进行预测。然后，该函数将对保留验证集进行预测，并返回来自训练集和测试集的分数。

管道允许我们在一个步骤中执行预处理(例如标准化、编码、模型拟合)。一个管道可以接受任意数量的预处理步骤，每个步骤都有.fit()和.transform()方法。下面，我正在创建两个变压器，一个标准的定标器和一个热编码器。两个不同的转换器将用于不同的数据类型。

**#Creating** **ss** **transformer to scale the continuous numerical data with** **StandardScaler()****ss =** Pipeline(steps=[('ss', StandardScaler())])--------------------------------------------------------------------**#Creating ohe transformer to encode the categorical data with** **OneHotEncoder()****ohe =** Pipeline(steps=[('ohe', OneHotEncoder(drop='first'))])--------------------------------------------------------------------**#Creating preprocess column transformer to combine the ss and ohe pipelines****preprocess =** ColumnTransformer(
                    transformers=[
                        ('cont', ss, numerical),
                        ('cat', ohe, categorical)
                    ])

• 创建评估函数以绘制混淆矩阵并返回准确度、精确度、召回率和 f1 分数

def evaluation(y, y_hat, title = 'Confusion Matrix'):
    cm = confusion_matrix(y, y_hat)
    precision = precision_score(y, y_hat)
    recall = recall_score(y, y_hat)
    accuracy = accuracy_score(y,y_hat)
    f1 = f1_score(y,y_hat)
    print('Recall: ', recall)
    print('Accuracy: ', accuracy)
    print('Precision: ', precision)
    print('F1: ', f1)
    sns.heatmap(cm,  cmap= 'PuBu', annot=True, fmt='g', annot_kws=    {'size':20})
    plt.xlabel('predicted', fontsize=18)
    plt.ylabel('actual', fontsize=18)
    plt.title(title, fontsize=18)

    plt.show();

• 对数据执行 train _ test _ split

**X =** df.drop(['Survived'], axis=1)
**y =** df.Survived
**y =** LabelEncoder().fit_transform(y)
**X_train, X_test, y_train, y_test =** train_test_split(X, y, random_state=42)

创建cross_validate功能

• 定义带有预处理和分类器管道的完整管道
• 遍历交叉验证器中的每个折叠(默认为 5)
• 将分类器安装在训练装置上，train_ind(防止测试装置的数据泄漏)
• 根据训练集进行预测
• 对验证集进行预测
• 打印一份评估报告，其中包含混淆矩阵以及训练集和验证集的平均准确度分数

def cross_validate(classifier, cv):
    pipeline = Pipeline(steps=[
        ('preprocess', preprocess),
        ('classifier', classifier)
    ])
    train_acc = []
    test_acc = []
    for train_ind, val_ind in cv.split(X_train, y_train):
        X_t, y_t = X_train.iloc[train_ind], y_train[train_ind]
        pipeline.fit(X_t, y_t)
        y_hat_t = pipeline.predict(X_t) train_acc.append(accuracy_score(y_t, y_hat_t)) X_val, y_val = X_train.iloc[val_ind], y_train[val_ind]
        y_hat_val = pipeline.predict(X_val) test_acc.append(accuracy_score(y_val, y_hat_val))
    print(evaluation(y_val, y_hat_val))
    print('Training Accuracy: {}'.format(np.mean(train_acc)))
    print('\n')
    print('Validation Accuracy: {}'.format(np.mean(test_acc)))
    print('\n')

在函数中，我使用交叉验证器来分割训练数据，以便得到一个支持测试集(X_test，y_test)。现在我们可以通过输入想要的分类器和交叉验证器来使用上面的函数。

cross_validate(DecisionTreeClassifier(), KFold())

输出:

作者图片

• 用 K 最近邻分类器

cross_validate(KNeighborsClassifier(), KFold())

输出:

作者图片

网格搜索

假设我们想在管道中找到模型的最佳参数，我们可以创建一个网格搜索管道。要复习网格搜索，请查看 文档 。我们可以创建一个类似上面的函数来进行交叉验证，但是要稍微修改一下来执行网格搜索。该函数将接收所需的分类器、参数网格和交叉验证器。然后，将通过网格搜索完成与cross_validate功能相同的过程。

def grid_search(classifier, param_grid, cv):
    search = GridSearchCV(Pipeline(steps=[
        ('preprocess', preprocess),
        ('classifier', classifier)
    ]), param_grid, cv=cv)
    train_acc = []
    test_acc = []
    for train_ind, val_ind in cv.split(X_train, y_train):
        X_t, y_t = X_train.iloc[train_ind], y_train[train_ind]
        search.fit(X_t, y_t)
        y_hat_t = search.predict(X_t) train_acc.append(accuracy_score(y_t, y_hat_t)) X_val, y_val = X_train.iloc[val_ind], y_train[val_ind]
        y_hat_val = search.predict(X_val) test_acc.append(accuracy_score(y_val, y_hat_val))
    print(evaluation(y_val, y_hat_val))
    print('Training Accuracy: {}'.format(np.mean(train_acc)))
    print('\n')
    print('Validation Accuracy: {}'.format(np.mean(test_acc)))
    print('\n')
    print('Grid Search Best Params:')
    print('\n')
    print(search.best_params_)

• GridSearchCV 与随机森林

为管道中的模型创建参数网格时，需要将模型名称附加到每个参数上。在下面的代码块中，我添加了'classifier__'来匹配管道中模型的名称(在管道中命名为模型‘classifier’)。

**#Creating parameter grid for Random Forest** rand_forest_parms = {'classifier__n_estimators': [100, 300, 500],
                     'classifier__max_depth':[6, 25, 50, 70],
                     'classifier__min_samples_split': [2, 5, 10],
                     'classifier__min_samples_leaf': [1, 2, 10]}**#Calling the grid_search function using the parameters above** grid_search(RandomForestClassifier(), rand_forest_parms)

输出:

在模型训练期间，重要的是执行特征选择，以确保模型具有最强的预测能力，并确保我们的模型不会太复杂。我们可以使用eli5库来检查管道中分类器的特征重要性。为此，我们需要创建一个包含数字特征列和编码列的列表。然后，用网格搜索管道的best_estimator_和它的named_steps调用eli5.explain_weights_df。当然，我们可以将它添加到我们的网格搜索函数中，通过修改该函数来接受一个将打印出这些特性的布尔值，从而返回前十个特性的重要性。

具有特征重要性的网格搜索功能

• 在下面的函数中包含特性重要性的修改以粗体显示。

def grid_search(classifier, param_grid, cv, ***print_feat=False***):
    cv = cv
    search = GridSearchCV(Pipeline(steps=[
        ('preprocess', preprocess),
        ('classifier', classifier)
    ]), param_grid, cv=cv)
    train_acc = []
    test_acc = []
    for train_ind, val_ind in cv.split(X_train, y_train):
        X_t, y_t = X_train.iloc[train_ind], y_train[train_ind]
        search.fit(X_t, y_t)
        y_hat_t = search.predict(X_t) train_acc.append(accuracy_score(y_t, y_hat_t)) X_val, y_val = X_train.iloc[val_ind], y_train[val_ind]
        y_hat_val = search.predict(X_val) test_acc.append(accuracy_score(y_val, y_hat_val))
    ***if print_feat:
        ohe_cols = list(search.best_estimator_.named_steps['preprocess'].named_transformers_['cat'].named_steps['ohe'].get_feature_names(
        input_features=categorical))
        num_feats = list(numerical)
        num_feats.extend(ohe_cols)
        feat_imp = eli5.explain_weights_df(search.best_estimator_.named_steps['classifier'], top=10, feature_names=num_feats)
        print(feat_imp)***
    print('\n')
    print(evaluation(y_val, y_hat_val))
    print('Training Accuracy: {}'.format(np.mean(train_acc)))
    print('\n')
    print('Validation Accuracy: {}'.format(np.mean(test_acc)))
    print('\n')
    print('Grid Search Best Params:')
    print('\n')
    print(search.best_params_)

• 执行网格搜索并返回前十个重要特征及其权重

grid_search(RandomForestClassifier(), rand_forest_parms, KFold(), print_feat=True)

输出:

假设网格搜索管道中的随机森林分类器表现最好。下一步将是观察经过训练的模型在坚持测试数据上的表现。我们需要做的就是用 GridSearchCV 创建一个最终的管道，并使其适合整个 X_train 和 y_train。然后，在 X_test 上预测。

• 将最终管线拟合到 **X_train** 和 **y_train** ，并预测到 **X_test**

final_pipeline = GridSearchCV(Pipeline(steps=[
        ('preprocess', preprocess),
        ('classifier', RandomForestClassifier())
    ]), rand_forest_parms, cv=KFold())**#Fit and predict on train data**final_pipeline.fit(X_train, y_train)
train_pred = final_pipeline.best_estimator_.predict(X_train)
print('Evaluation on training data \n')
print(evaluation(y_train, train_pred))
print('\n')**#Predict on test data**test_pred = final_pipeline.best_estimator_.predict(X_test)
print('Evaluation on testing data \n')
print(evaluation(y_test, test_pred))

输出:

作者图片

结论

管道封装了我们的预处理步骤和模型，使机器学习工作流程变得更加容易。如果需要，我们可以在管道中拟合模型之前应用多个预处理步骤。对我来说，主要的好处是能够回到一个项目，并遵循我用管道设置的工作流程。在我了解管道之前，这个过程需要几个小时。我希望本教程能够成为学习管道工作流的有用资源。

资源

• 使用 Scikit-learn 管道管理机器学习工作流第 1 部分:简介。(未注明)。检索自https://www . kdnugges . com/2017/12/managing-machine-learning-workflows-sci kit-learn-pipelines-part-1 . html
• 柯恩，S. (2019 年 08 月 09 日)。构建机器学习管道。检索自https://towards data science . com/architecting-a-machine-learning-pipeline-a 847 f 094 D1 c 7
• sk learn . pipeline . pipeline .(n . d .)。检索自https://scikit-learn . org/stable/modules/generated/sk learn . pipeline . pipeline . html
• M，S. (2019 年 12 月 13 日)。机器学习中的流水线是什么？如何创建一个？检索自https://medium . com/analytics-vid hya/what-A-pipeline-in-machine-learning-how-to-create-one-BDA 91d 0 ce ACA #:~:text = A机器学习管道用于帮助机器学习工作流程自动化。&text =机器学习(ML)流水线组成，并实现一个成功的算法。
• 泰坦尼克号:机器从灾难中学习。(未注明)。检索自https://www.kaggle.com/c/titanic/data
• 3.2。调整估计器的超参数。(未注明)。检索自https://scikit-learn.org/stable/modules/grid_search.html
• 概述。(未注明)。检索自【https://eli5.readthedocs.io/en/latest/overview.html】

机器学习陷阱

原文：https://towardsdatascience.com/machine-learning-pitfalls-e54ac3edc25?source=collection_archive---------23-----------------------

你的 ML 项目有多强就有多弱

Jelleke Vanooteghem 在 Unsplash 上拍摄的照片。

机器学习(ML)系统是复杂的，系统越复杂，故障模式就越多。知道什么会出错对于构建健壮的 ML 系统是至关重要的。我们将一起使用具体的例子来探索在 5 个不同的成熟度级别上可能出现的陷阱。

0 级—问题定义【T11 级—你的第一个 ML 模型
2 级—泛化
3 级—系统级性能
4 级— 性能不是 o 输出结果

这篇文章的最后一部分将讨论如何避免这些陷阱。专注于避免陷阱比从你的模型中榨取每一点准确性更好。

“值得注意的是，像我们这样的人通过努力保持不愚蠢，而不是努力变得非常聪明，获得了多少长期优势。”

—查理·芒格

0 级问题定义

现实世界的问题很少表现为易处理的数据科学问题。因此，对于任何 ML 项目来说，第一步都是制定问题，换句话说，就是将一个高层次的目标转化为一个定义良好的数据科学问题。

在这个层次上最大的威胁是提出一个问题定义，当它被解决时，实际上对任何人都没有帮助。这篇文章中有两个例子:

1)大多数将深度学习应用于超声心动图分析的研究试图超越医生预测疾病的能力。但是，预测正常的心脏功能实际上会通过识别不需要他们专业知识的患者来节省心脏病专家的更多时间。

2)许多将机器学习应用于葡萄栽培的研究旨在优化葡萄产量，但酿酒师“想要合适的糖和酸水平，而不仅仅是大量大而含水的浆果”。

第一级你的第一个 ML 模型

这一关是让一个 ML 模型在你的笔记本电脑上的测试集上工作。这不是一件容易的事情，但是大部分的内容已经集中在这一点上，因此我将只提到一个陷阱:

陷阱 1.1 假设更多的数据可以解决所有的问题

不相关的要素或低质量的数据会降低您可以达到的上限性能，这无法通过更多的数据来解决。

由于模型容量低而导致的拟合不足是另一个更多数据没有帮助的情况。

二级概括

这就是有趣的地方。假设您有一个模型，它在您的测试集上运行得非常好，但是在使用外部数据集进行测试时，它的性能会急剧下降。以下陷阱或许可以解释其中的原因:

陷阱 2.1 虚假关联

如果数据集包含与标注相关的信号(即噪声)之外的任何内容，您的模型将学习利用它进行预测。

在下面的例子中，神经网络将图像分类为“马”在看文本，而不是马。一旦文字被删除，图像就不会被归类为“马”。

Lapuschkin 等人的图片来自揭露聪明的 Hans 预测器并评估机器真正学习什么。

陷阱 2.2 非代表性数据集

你用来训练你的 ML 模型的样本应该代表你计划使用它的人群。

假设您正在基于光散射数据构建一个粒子大小预测器，并且您只使用球形粒子对其进行了训练。如果在实践中人们也将它用于非球形粒子，模型性能将显著下降。

缺陷 2.3 测试和用例之间的数据不匹配

ImageNet 是一个包含数百万张图片和数千个类的数据库。年复一年，研究人员在 ImageNet challenge 上开发了性能更好的模型，这导致一些人说“视觉是一个已解决的问题”。

然而，当在 ObjectNet 上测试时，这些算法的性能下降了大约 40%。原因是 ObjectNet 有适当的控制，对象在所有可能的旋转背景和视点。这是 ImageNet 所缺乏的。看一下样本数据集以了解差异。

隐患 2.4 列车测试泄漏

假设你正在从断层图像中检测某种疾病。您可能会有多个属于同一个患者的图像。如果您将所有图像随机分为训练集和测试集，来自同一患者的一些图像可能会进入训练集，而其他图像可能会进入测试集。在这种情况下，在训练集上训练的模型在测试集上可能具有高性能，因为您的模型识别患者，而不是疾病。

陷阱 2.5 随时间改变数据生成分布

数据生成过程会随时间而变化。10 年前的手机摄像头和今天大不一样。因此，如果一个模型是使用 10 年前的手机图像数据集开发的，但在今天测试，性能可能会有所不同。

大多数统计和机器学习算法都假设数据是从平稳分布中抽取的随机样本。不幸的是，今天大多数可用于挖掘的大型数据库违背了这一假设。它们是在几个月或几年内收集的，在此期间，产生它们的基本过程发生了变化，有时是彻底的变化。来源。

3 级系统级性能

我们开发机器学习模型，但它们通常作为另一个系统的一部分投入使用。因此，仅仅验证您的模型是不够的，您还应该验证您的系统。这一级别的陷阱是由于没有系统方法而产生的。

缺陷 3.1 错误输入

如果输入被破坏，完美的模型将产生错误的预测。导致两架 737 Max 飞机相隔五个月坠毁的防失速软件(MCAS)依靠单一传感器进行输入。一个传感器的故障导致 346 人死亡。

它没有冗余:它一次只从一个 AoA 传感器获取输入。这使得 MCAS 完全无法应对传感器故障。如果原始来源发生故障，它无法根据第二个传感器对其数据进行“健全检查”或切换到备份。它只是相信给它的任何数据，，即使那些数据是坏的，这就是发生在狮航 610 航班和埃塞俄比亚航空 302 航班上的事情。来源。

缺陷 3.2 没有为失败做准备

继续波音公司的例子，MCAS 系统并不是直接覆盖，飞行员也没有接受过适当的培训。

这个系统的存在，潜伏在 Max 的软件套件中的某个地方，是足够令人震惊的。更可怕的是，波音公司只向航空公司和飞行员提供了最低限度的信息。公告没有给出系统的名称，也没有解释它在正常操作中的作用。它只是说，有时它会出现故障，这可能会使你的飞机坠毁。

“这有点像，'好吧，飞行员，祝你好运，想出办法，【T13]'”Einsetler 说。来源。

缺陷 3.3 对系统其他部分的不利影响

最近，特斯拉 autopilot 在驾驶员专注度方面获得了一个低分:

“不幸的是，有些驾车者认为他们今天可以购买一辆无人驾驶汽车。这是一种危险的误解，认为太多的控制权交给了没有准备好应对所有情况的车辆，”Thatcham Research 的欧洲 NCAP 董事会成员兼研究主管马修·艾弗里说。来源

这种错误的安全感可能会降低驾驶员的表现，导致撞车:

[## 一家联邦机构表示，对特斯拉自动驾驶仪的过度依赖导致了一起致命事故

揭示和解释我们的数字世界是如何改变的，以及如何改变我们。国家运输安全委员会…

www.vox.com](https://www.vox.com/2017/9/12/16294510/fatal-tesla-crash-self-driving-elon-musk-autopilot)

四级表现不欧 utcome

表现不是结果。采用在问题定义期间设定的指标并不能保证达到预期的结果。

隐患 4.1 隐藏分层

一个具有高整体性能的癌症检测模型可能会持续遗漏一种罕见的癌症亚型，这被称为隐藏分层问题。整体绩效隐藏了小组绩效的可变性。

陷阱 4.2 人口统计偏见

作用于人类数据的机器学习模型容易受到人口统计学偏见的影响。亚马逊意识到他们的人工智能招聘工具对女性有偏见，即使性别没有在简历上明确标出。

[## 据报道，亚马逊废除了歧视女性的内部人工智能招聘工具

即使对于亚马逊这样在人工智能方面有丰富经验的公司，机器学习的偏见也可能是一个问题。根据…

www.theverge.com](https://www.theverge.com/2018/10/10/17958784/ai-recruiting-tool-bias-amazon-report)

陷阱 4.3 违反法规

一个技术上完美的模型，如果违反了规定，可能就没用了。

[## 在加利福尼亚州，在设定汽车保险费率时不再考虑性别(2019 年发布)

加州本月加入了六个州的行列，禁止在评估风险时使用个人性别…

www.nytimes.com](https://www.nytimes.com/2019/01/18/your-money/car-insurance-gender-california.html)

但最重要的是:你想这样做吗？

即使你建立了一个技术上完美的 ML 系统并产生了预期的商业结果，你对它的存在感到高兴吗？

这是网飞(2015) 的一篇很棒的论文，解释了他们的推荐系统以及商业成果。他们估计该系统每年为他们节省 10 亿美元。

但是你真的想造一个和睡眠竞争的让人上瘾的数码产品吗？你可能会，也可能不会，关键是要在构建它之前考虑它，而不是在事后考虑。

[## 网飞首席执行官雷德·哈斯汀斯:睡眠是我们的竞争

网飞已经成为了疯狂观看的代名词——一整季疯狂观看陌生事物的行为

www.fastcompany.com](https://www.fastcompany.com/40491939/netflix-ceo-reed-hastings-sleep-is-our-competition)

以 YOLO 物体检测算法闻名的 Redmon 在今年早些时候发表了以下声明:

解决方案？

以下是我在 Ipsumio 日常工作中使用的一些技巧。

提示 0:如果没有必要，不要使用 ML

我多次被要求用 ML 解决不需要 ML 的问题。如果没有必要，你可以通过不使用机器学习来避免上述所有挑战。

同样，如果一个有 3 个参数的 ML 模型解决了问题，不要使用有数千个参数的神经网络。

技巧 1:迭代地构建项目

而不是完善项目阶段，线性推进，反反复复。尽快部署概念证明，然后重新开始。

技巧 2:让领域专家参与进来

这是必须的。几乎项目的所有阶段都需要领域知识。如果不是:

技巧 3:让软件专家参与进来

将一个 ML 模型转变成一个系统并不简单。你的模型代码只是整个系统的一小部分。

ML 代码只是现实生产 ML 系统的一小部分。来自机器学习速成班。

技巧 4:跨专业交流

我参与了一个关于识别从皮肤损伤处收集的某些细胞的研究项目(赞克试验)。作为数据科学家，我阅读了几十篇关于赞克测试的研究论文和两本书。除此之外，我给了项目中的皮肤科医生一个关于 ML 的短期培训。这有助于我们在项目的所有阶段相互理解，从问题定义到结果解释。

[## TzanckNet:一个卷积神经网络，用于识别细胞学中的细胞…

赞克涂片试验是一种低成本、快速和可靠的工具，可用于许多疾病的诊断

www.nature.com](https://www.nature.com/articles/s41598-020-75546-z)

技巧 5:考虑可解释性和可解释性

对于某些应用程序，高性能本身就足够了，但是当风险很高时，可解释性和可解释性就变得不可或缺了。

在的播客中，Arnaud Hubaux 解释了他们是如何在 ASML 将物理学和 ML 结合起来的。他提到他们的客户看重因果关系多于相关性。在没有解释的情况下，他们不关心准确性的提高。因此，他们将物理定律用于特征工程和解释输出。

医疗保健是黑盒解决方案产生问题的另一个领域。例如，这条推文围绕这个问题引发了一场激烈的辩论:

技巧 6:错误分析

一个简单但有效的提示。看看你所有的错误，看看有没有系统性的错误。假设您正在开发一个汽车分类器，并意识到所有的假阴性都属于被物体遮挡的汽车。您可以注明“模型在遮挡情况下无法工作”,也可以增加训练数据中被遮挡的汽车图像，并尝试解决该问题。

技巧 7:用外部数据集测试模型

如果您使用来自一家医院的数据集开发模型，请考虑使用外部数据集按以下顺序测试您的模型:来自同一家医院的预期数据，来自同一医疗保健系统中不同医院的数据，来自不同医疗保健系统中不同医院的数据…

技巧 8:测试系统

仅仅测试模型是不够的，要把它作为一个系统来测试，看看它将如何与系统的其他部分及其环境发生反应。

技巧 9:检查子组性能

在标记数据的过程中，也让领域专家定义和注释子集。然后在这些子集中分析您的模型性能。

技巧 10:仔细创建数据集

查明

• 你要找的信号在数据里面
• 它是人口的代表
• 如果你正在生成数据集，模拟现实，而不是创建一个完美的数据集。(例如，如果实际使用低分辨率显微镜，不要用昂贵的显微镜创建数据集)。

技巧 11:利用 MLOps

随着我们开始看到更多的生产 ML，部署和维护这些系统吸引了更多的注意力。在您的工作流程中使用 MLOps 原则。

[## 机器学习系统中隐藏的技术债务

机器学习为快速构建有用的复杂预测系统提供了一个非常强大的工具包。这个…

dl.acm.org](https://dl.acm.org/doi/10.5555/2969442.2969519)

关键要点:

• 成功的机器学习项目需要的不仅仅是回溯测试集上的高性能模型。
• 因此，不要关注模型性能的增量收益，而要关注预防、检测和修复所有成熟度级别的缺陷。

“我只想知道我会死在哪里，所以我永远不会去那里。”—查理·芒格

机器学习过程

原文：https://towardsdatascience.com/machine-learning-process-7beab5c4f31b?source=collection_archive---------27-----------------------

艾萨克·史密斯在 Unsplash 上拍摄的照片

尽管有许多机器学习算法，每一个都有不同的方法，但有一个通用的程序可以用来解决任何机器学习问题。在本文中，我们将了解所有这些是如何发生的。

如果你想在此之前获得机器学习的一般介绍，请查看这篇文章:

[## 那么什么是机器学习呢？

我相信到现在为止，你一定听说过这个术语，如果不出所料的话，只要看看…的演讲就知道了

thedatascienceportal.com](https://thedatascienceportal.com/so-what-is-machine-learning/)

既然我们理解了什么是机器学习，那么现在让我们来学习如何应用机器学习来解决任何问题。

这是用于将机器学习应用于任何问题的基本过程

数据采集

解决任何机器学习问题的第一步是收集相关数据。它可能来自不同的来源，并采用不同的格式，如纯文本、分类或数字。数据收集很重要，因为这一步的结果直接影响我们问题的性质。

在大多数情况下，数据并不是放在现成的银盘上交给我们的，也就是说，通常情况下，我们认为相关的数据可能不会马上可用。我们很有可能必须进行某种练习或受控实验来收集我们可以使用的数据。我们还必须记住，我们正在收集的数据来自合法的程序，因此所有相关方都非常清楚正在收集的内容。

为了本文的目的，让我们假设我们已经收集了关于汽车的数据，并且我们正在尝试在机器学习的帮助下预测一辆新车的价格。

数据预处理

既然我们已经收集了与手头问题相关的数据，我们必须让它进入同质状态。我们的数据的当前形式可以包括各种类型的数据集，可能是由一千行和多列汽车数据组成的表格，或者可能是不同角度的汽车照片。保持事情简单并处理一种特定类型的数据总是明智的，也就是说，如果我们感觉有点太冒险，我们应该在开始处理我们的算法之前决定我们是要处理图像数据、文本数据还是视频数据！

*数据类型。*作者照片。

像每个计算机程序一样，机器学习算法也只理解 1 和 0。因此，为了运行任何这样的算法，我们必须首先将数据转换成机器可读的格式。如果我们把我们的照片放在幻灯片上，它根本不会理解！我们可以使用任何类型的数据——数字、图像、视频或文本——但我们必须对其进行配置，使其能够被机器理解。我们通过对数据进行编码来确保这一点——在这个过程中，我们将所有类型的数据用数字表示出来。

有关数据预处理和所有相关步骤的简单易懂的介绍，请查阅本文:

[## 数据预处理

标签:当我们谈论数据时，我们通常会想到一些包含大量行和列的大型数据集。而那个…

thedatascienceportal.com](https://thedatascienceportal.com/data-preprocessing/)

训练和测试数据

在我们开始构建机器学习模型之前，我们必须首先确定我们的特征，并决定我们的目标。特性是数据的属性，告诉我们数据中不同的实体。例如，我们可能有一个关于汽车的庞大数据集，使用机器学习来预测新车的价格。由于这些汽车是实体，在这种情况下，特征可能是发动机功率、里程、最高速度、颜色、座位容量、汽车类型等。等等…在这种情况下，目标或目标变量将是汽车的价格。

当我们处理任何机器学习问题时，我们总是将我们拥有的数据集分成训练集和测试集，通常分别是(70/30)或(80/20)分割。训练集，顾名思义，是用来训练模型的。当我们“训练”模型时，它试图理解数据集的所有特征如何形成目标变量——在监督学习的情况下，或者所有特征之间的关系和相关性——在非监督学习的情况下。在此之后，测试集将用于找出模型对数据的理解程度。

机器学习算法选择

在转换数据，使其变得清晰和可行之后，我们会对解决问题的方法有更好的想法，并尝试实现它。这是因为实际上是数据决定了我们能使用什么，不能使用什么。

比如说我们想造一个聊天机器人。聊天机器人将按照用户的询问进行回答。因此，我们可以说，任何对话的第一步都将是聊天机器人试图识别用户的意图，这是我们的第一个机器学习问题——意图分类。

这个问题要求我们使用一种特殊类型的数据——基于文本的数据。我们选择的机器学习算法一定是一种分类算法，即它根据已经看到的数据，将新输入的数据分类到某个标签类。当然，在这一步之前，来自用户的文本将被编码并经过所有必要的数据预处理步骤，然后将被输入到机器学习算法中。尽管我们必须小心选择我们的机器学习算法，但在选择最终的算法之前，探索所有可用的选项并使用各种合适的机器学习算法是很好的——无论如何，这都被认为是最佳实践。

价值函数

简而言之，成本函数是一个数学函数，它给出成本的度量；正如你可能已经听说的那样，我们做出的每一个决定都是有代价的。

“成本函数或损失函数是将一个事件或一个或多个变量的值映射到一个实数上的函数，该实数直观地表示与该事件相关的一些“成本”——百科

该功能用于量化任何程序中每一步对应的惩罚。就优化问题而言，我们必须致力于最小化该成本值。

让我们来看一个例子——
假设你正在爬下一个悬崖。在任何时候，你都有几条路可以走，但你会:

• 从该点寻找最佳路径
• 拒绝所有让你超越自我的道路

如果我们将上涨与惩罚或成本联系起来，那么如果上涨，我们将增加总成本(就时间和精力而言)。因此，如果我们要设计一个数学函数来量化这个成本指标，我们可以潜在地将时间和精力作为因素。

另一个例子-
假设你开车从 A 地到 B 地，同样，我们有多条路径到达 B 地，但是我们:

• 寻找最短的路径
• 拒绝所有带我们去其他地方的路(很明显！)

如果我们把这种情况与成本联系起来，如果我们忽略了上面提到的两点，我们将会有很高的成本。在这里，我们可以将时间和油钱作为组成成本函数的因素，并判断此后采取的路径。

照片由维达尔·诺德里-马西森在 Unsplash 拍摄

机器学习中的代价函数

任何机器学习算法都必须达到一个最优状态才能正常运行。成本函数帮助我们确定我们的模型是否处于最佳状态。通过不断比较模型假设值和训练集中的原始值，模型找出最佳状态。哇…退后！什么！？
别担心，我们会仔细研究所有概念！

假设功能

任何机器学习模型的背后本质上都是一个数学函数，它解释了数据中各种特征的作用，以形成目标变量或形成不同特征之间的相关性。

假设函数。作者照片。

如前所述，在训练期间，机器学习模型试图理解训练数据特征的值的不同组合如何形成相应的目标变量。为了更好地理解，让我们以一个培训记录为例，培训本质上意味着获取该记录的所有特征，并以某种方式将其映射到该培训记录的目标值。一个很好的例子就是我们之前讨论的汽车数据集。符号方面，特征取为 X，目标变量取为 y。
在此过程中，训练数据被输入到学习算法中，该算法是根据我们试图解决的问题选择的。这可能是一个分类问题，一个回归问题，或者完全是别的什么问题。输出这个假设函数是这个学习算法的工作。

假设函数。来源: CS229 吴恩达讲稿

对于一个两变量的问题，这可能是我们的假设函数。所有θ值都是参数或权重，选择这些参数或权重是为了使我们获得最接近每条记录的相应目标值的估计值。

然后，假设函数从每个训练记录中获取特征，并尝试估计相应的目标值。这个函数可以是简单的线性函数，也可以是复杂的函数，这取决于数据和所用的算法类型。并且因为它是一个估计函数，所以输出值不期望与目标值完全相等，至少在第一次尝试中不期望。
让我们再次使用汽车数据集，如果我们在这个数据集上使用一个学习算法，并尝试使用这些功能来训练它，我们将获得数据集中每辆汽车的价格估计值。由于这是一个训练数据集，我们已经将每辆车的价格作为目标变量。

假设趋势线的估计值用蓝色切割接近目标值用红色。作者照片。

成本函数

这就是成本函数发挥作用的地方。我们希望训练数据中的估计值和实际目标值之间的差异尽可能低，只有这样，我们才能说我们的模型是一个强模型，这意味着它将给出正确的目标值，或者至少返回一个非常非常接近特定训练记录的目标值的值。
所以，这就变成了一个最小化的问题。区别就是所谓的成本，而最小化函数就是所谓的成本函数。有几种方法可以达到极小的状态。我们可以简单地最小化整个训练集上的估计值和目标值之间的差异，或者我们可以采用平方差，或者其他一些变化来实现相同的事情。最广为接受且相当合理的成本函数之一是这样一个函数，如果你正在研究机器学习算法，你会很容易发现它:

成本函数。来源: CS229 吴恩达讲稿

这个函数适用于大多数回归问题。是的，我知道，我知道我说过我会保持简单，不会用奇怪的方程式吓到你。别担心，如果你这么正式，我们不会用公式或公式填满一块巨大的黑板。我给你简单解释一下，把一切都说得清清楚楚。

J(θ) —成本函数符号
m —训练记录数
hθ —假设函数
x(ᶦ)- iᵗʰ训练数据记录
hθ(x(ᶦ)——iᵗʰ训练记录的假设函数值
y(ᶦ)- iᵗʰ目标值

• 正如我之前提到的，我们将成本定义为假设函数值和目标值之间的差值
• 我们必须最终将我们从每个训练记录中得到的所有平方差相加，以得到整个训练数据的总成本
• 我们对每种情况下的差值进行平方，这有两个显著的优点
• 假设函数的估计值和目标值之间的差异可能是负的，对其求平方消除了我们降低总成本值的可能性，同时对我们从每个训练记录中获得的差异求和，仅仅因为其中一些是负的。
  |请注意，我们也可以采用绝对值，但这导致了一个问题——绝对值函数比平方函数更难进行数学分析——如果您需要进一步的解释，请在评论中告诉我——基本上，绝对值函数在所有点上都是不可微的，这是找到成本函数处于最小值的点所必需的|
• 平方也更加强调较大的差异，因为这些差异的影响也是平方的。因此，这些较大差异的贡献增加并突出。
• 通过在θ值上对函数求微分来执行最小化将移除公式中存在的 1/2

机器学习模型

如上面的假设趋势线图所示，最小化成本函数的主要目标是获得一条覆盖大部分目标值的直线趋势线，或者至少尽可能接近这些点。这就是为什么我们计算差异，并编写一个成本函数来减少它们。

而且这不是一次性的过程，更多的是一个迭代的过程，在这个过程中我们为假设函数选择我们的参数，计算估计值，然后用代价函数找出代价。之后，我们最小化这个成本，并再次执行整个活动。通过这种方式，我们重新进行整个计算，以达到我们认为具有最佳功能的点。我们可以随时检查当前结果的状态，只需对照目标值绘制函数。
然而，这整个迭代过程是当今所有优化算法的核心，因此您不必重复执行这一活动。最流行的一种，你可能听说过，是梯度下降。

[## 梯度下降:机器学习最流行的算法之一介绍

梯度下降是迄今为止在机器学习和深度学习中使用的最流行的优化策略

builtin.com](https://builtin.com/data-science/gradient-descent)

当我们确实有一个假设函数，它的估计值最接近目标值时，我们可以采用这个函数，并声称它是以尽可能好的方式拟合数据的函数。这就是我们的模型！

在这篇文章中，我想写的是解决任何机器学习问题和建立机器学习模型时遵循的一般过程。这更多的是一个理论上的解释，但我有更多的技术指南。

我希望你喜欢这篇文章。如果你对内容有任何疑问，请在评论中告诉我！
感谢阅读！

原载于 2020 年 8 月 7 日【https://thedatascienceportal.com】。更多此类内容请访问数据科学门户网站。

* [## 数据科学门户

大家好，欢迎来到数据科学门户。这个空间致力于学习和理解所有令人兴奋的…

thedatascienceportal.com](https://thedatascienceportal.com/)*

机器学习项目管理—决策者指南— 2d3d.ai

原文：https://towardsdatascience.com/machine-learning-project-management-a-decision-makers-guide-2d3d-ai-6fbd59504bb1?source=collection_archive---------51-----------------------

我们为许多不同的客户从事许多机器学习(ML)项目，并与其他同行和 ML 专家讨论 ML 项目管理的性质，我们认识到，有时，对在其业务中实施 ML 感兴趣的决策者的期望与实际可以做什么、在什么时间范围以及可能需要多少努力和成本之间存在差距。因此，我们决定为经理、首席执行官、产品副总裁、业务分析师、初创公司创始人以及一般来说任何考虑雇佣内部或外部人员帮助开发 ML 算法来解决问题的人编写本指南。

在本指南中，您将学习:

• 在你的公司开始一个机器学习项目时，你会期待什么？
• 你应该警惕什么？
• 使用机器学习的机会在哪里？
• 你的团队需要做哪些努力才能成功？
• 一个机器学习项目要花你多少钱？
• 如何认可好的 ML 工程师？

我们需要的一些定义

机器学习的形式-目前的行业趋势定义了几种不同形式的机器学习:

• 深度学习，或称神经网络——一种计算机被编程为以类似于生物大脑中神经元细胞的方式运行的形式。有一个由计算机编程的神经元组成的网络，这些神经元相互连接，形成一个图形，网络的一端接收输入，另一端发出输出
• 统计分析——这些是老派的技术，例如，回归或方差分析。今天，在行业中，他们通常被认为是 ML 的一部分。
• 机器学习多次涉及更复杂的统计分析方法，如 SVM、决策树、聚类算法等方法。要理解本指南的其余部分，您不需要知道这些特定的关键字😊

特征—样本的单个数据点，或者说，数据样本的特定特征。示例:

• 物体的大小——宽度以米计，高度以厘米计，等等…
• 对一个物体的分类测量——男性\女性、汽车\公共汽车\自行车\卡车等…
• 价格，例如以美元计算的销售价格。
• 一个像素的颜色值(0，0，0)-具有 3 个特征的 RGB
• 1 个时间点的信号测量—声音信号的幅度(1db)等…
• 机器学习的形式-目前的行业趋势定义了几种不同形式的机器学习:
• 特征—样本的单个数据点，或者说，数据样本的特定特征。示例:

技术考虑

TL/DR 版本

• 经验法则——如果一个人在看数据时不能识别一个模式，那么 ML 可能也不能
• 两种类型的算法—需要培训或预培训
• 非监督或异常检测算法很少工作，除非你有非常干净的数据
• 另一方面，标记组的组分离有简单的实现
• 训练数据越多越好，最小数据量随项目要求和实现的算法而变化
• 数据格式化、检查和转换大约占工作的 70%
• 深度学习不会解决你的问题，除非你做视觉\信号处理
• 黑仔特征比算法更重要

经验法则——如果一个人在看数据时不能识别一个模式，那么 ML 可能也不能

在运行机器学习算法之前，如果你能可视化数据，亲眼看到重复的模式，会有所帮助。这可以是图表的形式，显示一个清晰可见的趋势线，如在左边。

我们的一些客户有时会开发基于规则的内部决策机。例如，如果一位顾客买了一张餐桌，他们会意识到他可能也对一把椅子感兴趣，并在软件中输入一条规则，为购买餐桌的顾客提供椅子。这很好，这意味着数据中确实有重复的模式。

机器学习可以帮助你找到更多你错过的模式。或者，细化您找到的模式定义，使模式识别更准确，对您更具可操作性。

训练或使用预先训练的算法

ML 以算法的训练周期而闻名——你提供自己的数据，或一些其他现有的数据集，然后你 训练算法 识别你感兴趣的数据中的模式。有时，人们会使用“受监督的”和“不受监督的”这两个短语:

监督意味着你的训练数据被分类到不同的组。例如，如果你开发了一个算法来识别照片和猫和狗，在监督方法中，你会有猫的照片，标记为猫，狗的图像，标记为狗，你会根据这个训练数据训练一个 ML 算法来识别猫和狗。

无监督表示你有训练数据，但是没有分类。在猫和狗的例子中，你有猫和狗的照片，但是没有猫和狗的标签。你只知道照片的标签有两种可能。在这种情况下，您将训练算法来区分训练数据中的两个组。

注意，监督和非监督方法都需要训练算法。

第二种选择是使用 预训练算法 ，或者不需要训练的算法。这些都是预先准备好的算法，随时可以使用。例如，已经存在用于图像识别的算法，这些算法使用庞大的学术界数据集进行训练，以识别图像中的不同对象。另一个例子是文本索引和搜索软件，尽管不完全是机器学习，而是一种人工智能方法。这些程序具有分析不同语言文本的能力，不需要你提供训练文本样本。

预先培训的方法更通用，可以很容易地在每个公司实施。这种方法的问题是:

1. 许可—有时您无法使用预训练的算法，因为它是使用具有使用许可限制的专有数据训练的。
2. 该算法对您的数据的预测\估计\分类质量可能会更差，因为该算法不是针对您的数据进行训练的。
3. 预训练算法只存在于一组特定的问题和特定的数据结构中，很多时候你可能找不到一个符合你确切需求的预训练算法。相比之下，训练自己的算法是非常通用的，可以用于任何所需的数据分析问题。

最好是使用您自己的特定和自定义数据来训练算法。但是，很多时候，公司没有足够的数据进行训练，所以他们被迫使用预先训练好的算法。

值得一提的是，如果一个算法的实现为另一家公司或另一项研究工作，那么为你的公司做同样的事情可能需要一个完全不同的项目，这完全取决于你拥有的数据集。

非监督或异常检测算法很少工作，除非你有非常干净的数据

这些方法是一种“机器学习魔法”,应该如此对待。正如所料，试图将一堆数据输入算法，希望会有好的结果出现，这是独一无二的。

如果我们试图识别的不同组之间存在真正的差异，并且这种差异清楚地显示在特征中，那么无监督学习就可以工作(参考上面关于人类查看数据的经验法则)。此外，通常我们必须事先知道在数据中我们会遇到多少不同的组。

这里可以看到一个有趣的例子，以一种无监督的方式将手写数字图像聚类到不同的组:

摘自本张量流链接

异常检测 可能会起作用，如果有足够多的我们正在试图识别的独特场合的样本，并且这些样本确实比标准(非异常)情况大得多。

另一方面，标记组的组分离有简单的实现

有时，从不同的组中获得样本并训练机器学习算法来识别来自未知组的新样本可能非常容易。例如，在心理行为研究中，统计学家多年来一直使用这些技术来识别不同行为、行为组合和群体归属之间的相关性。

培训需要多少数据？

在这种情况下，多多益善。更具体地说，它确实随着你试图解决的问题而改变。这通常是算法实现的一部分——检查手头的特定数据、要解决的特定问题，并查看哪些算法可以工作以及需要多少数据。

当有一个大的数据集，但它不是均匀分布时，就会出现一个常见的问题。例如，当一家公司想要识别哪些功能会导致更多的客户销售转换时，该公司可能有关于成千上万潜在客户的信息，但只有少数购买了的客户。在这种情况下，运行任何类型的机器学习算法来带来有意义的结果可能很难，如果不是不可能的话。在另一个例子中，基于声音、压力测量、温度或其他物理测量来识别重型机械故障可能是不可能的，如果当机器工作不正常时有少数样本，而当机器工作良好时有其余样本。

来自我们个人经验的一些基准:

• 在预测和趋势分析中，为了能够识别季节性(年度)趋势，至少需要 f 2 年的样本。这是因为大体上 1 年用于基线估计，另一年用于趋势估计。
• 在 3D 建模中(你可以看看我们的中帖作为例子)——至少需要 5000 个特定物体的 3D 模型(5000 个椅子模型)
• 在视频分析方面——当我们在从事唇读初创公司的工作时，我们发现我们需要至少 70，000 小时的人说话视频(这是大约 10tb 的数据)来让我们的神经网络学习任何东西。

不仅仅是数据量，还有数据的格式

很多时候，一个 ML 项目开始于清理提供的数据，改变它，简化它的结构。在这一阶段，在数据中发现了许多错误和问题。最初准备或保存数据的方式可能存在意外问题，或者数据导出的方式存在其他问题。所有这些都需要时间和努力，并且必须非常小心地完成。因为，否则我们可能会在完全不正确的信息上训练算法，得不到任何好的结果，并将其归咎于算法而不是原始训练数据。

在项目中，70%的实际工作处于数据重新格式化和测试的阶段。

深度学习不会解决你的问题，除非你做视觉\信号处理

有时，客户开始与我们交谈，他们会谈论他们在网上看到的关于深度学习和神经网络的不同事情，他们希望我们为他们实现这些事情。深度学习只是另一种可以尝试的机器学习算法。构建和优化一个深度学习算法来解决一个问题，通常比使用一些更简单的方法，如逻辑回归或正则回归(取决于手头的问题)，需要更多的时间和精力。大多数情况下，实现深度学习是矫枉过正。深度学习是必须的情况是在技术上困难的情况下，例如图像分析、文本分析、信号处理、生物数据分析或其他类型的项目，其中特征很复杂，通常每个数据样本有数千个特征。

黑仔特征比算法更重要

很多时候，更值得做的是开发新功能，测试它们，尝试开发新功能。通常如果你有一个好的特征，最简单的算法就足够了。例如，在上面的例子中，一个顾客在买桌子的同时也会买一把椅子，如果你有这个特征——最后售出的物品的类别(在我们的例子中是桌子)，那么，即使一个简单的逻辑回归模型也可能识别出下一个售出的类别是椅子。

这意味着对于一个 ML 工程师来说，非常擅长简单的数据分析和数据工程比了解所有不同的 ML 算法并实现它们更重要。

时间表、定价和招聘考虑因素

最简单的情况下，初始数据检查至少需要 1 个小时到 2 周的全职工作。

研究特定算法或学术界发布的新算法所需的时间:

1. 至少要花 4 天时间阅读最相关的研究论文和信息。
2. 半天到 2 周的时间来实现基本的开源代码，如果有的话。
3. 根据手头问题的复杂程度、训练数据的质量(或缺乏训练数据)和所需的 KPI，定制算法或对数据进行训练可能需要几个月时间。

在某些情况下，例如异常检测，不可能定义可操作的技术 KPI，因为即使是最好的算法也不知道有多准确。

定制项目可能很贵，价格从每小时 120 美元到 300 美元不等。

通常从小处开始，快速简单地取得胜利，然后如果你看到实现机器学习的价值，就继续前进。在看到任何进展之前，不要花几个月的时间去开发是明智的。尝试 1-2 个月，专注于可实现的短期目标，甚至可能是一份简单的报告，使用简单的工具。如果这行得通，那就前进到更复杂的东西。

如何识别合适的 ML 公司\顾问\雇佣

• 他们告诉你和上面写的一样的东西。
• 他们从向您显示数据的图表和仪表盘开始，而不是深入开发。
• 如果他们认识到数据集不够好，他们会说不，如果你感兴趣，他们会给你一些提示，告诉你如何仍然可以进行机器学习，你需要关注什么。
• 它们很贵。
• 他们用简单易懂的语言解释基本概念，帮助你理解这个项目，它的范围和它的局限性。

关于我们

我们是datask.co——背后的人你问数据，我们答——一家机器学习即服务公司。我们还经营博客 2d3d.ai 和 ML 咨询公司abelians.com

原载于 2020 年 4 月 13 日https://2d3d . ai*。*

针对类别不平衡的机器学习重采样技术

原文：https://towardsdatascience.com/machine-learning-resampling-techniques-for-class-imbalances-30cbe2415867?source=collection_archive---------11-----------------------

如何为一个更好的预测模型期待意想不到的事情

让我们面对现实吧。不平等糟透了。我甚至还没有谈到这样一个事实:尽管非洲裔美国人和西班牙裔美国人占美国总人口的 32%，但他们却占美国监狱人口的 56%；也没有提到 T2 比尔·盖茨、杰夫·贝索斯和沃伦·巴菲特的财富总和比美国最底层的 50%的人的财富总和还要多。

尽管我很想对这些事实感到愤怒，但现在我谈论的是机器学习分类模型背景下的阶级不平衡。根据维基百科的说法，算法偏差“可能由于许多因素而出现，包括但不限于算法的设计，或者与数据编码、收集、选择或用于训练算法的方式有关的无意或意外使用或决策。”使用高度不平衡的数据训练模型可能会偏向多数类，这可能会产生严重的影响。

以 Kaggle 的宫颈癌风险分类数据集为例。

在数据集中包含的所有诊断中，只有 2%被发现是癌症。在执行简单的随机森林分类模型后，该模型的准确率为 99%！

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, recall_score, classification_report
from sklearn.model_selection import train_test_splitX = df.drop('Cancer', axis=1).dropna()
y = df['Cancer'].dropna()X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)random_forest = RandomForestClassifier(n_estimators=500).fit(X_train, y_train)
y_pred = random_forest.predict(X_test)
print('Accuracy score: ' + str(accuracy_score(y_test, y_pred)))
print('Recall score: ' + str(recall_score(y_test, y_pred)))
print(classification_report(y_test, y_pred))

那不太可能。让我们再深入一点。让我们在模型中只包括 36 列中的两列。

X = df.loc[:,['Smokes', 'Hormonal Contraceptives']]
y = df['Cancer'].dropna()X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)
random_forest = RandomForestClassifier(n_estimators=500).fit(X_train, y_train)
y_pred = random_forest.predict(X_test)
print('Accuracy score: ' + str(accuracy_score(y_test, y_pred)))
print('Recall score: ' + str(recall_score(y_test, y_pred)))
print(classification_report(y_test, y_pred))

但是准确率只降到了 97%！我们随机选择的两个特征能够以 97%的准确率预测癌症的可能性非常小。

我们已经知道 2%的患者被诊断患有癌症，但是我们的第二个模型预测没有患者会患有癌症。看到这怎么会成为一个问题了吗？

你应该用什么标准来评估？

在严肃的医疗诊断模型、惩罚性模型如 COMPAS 、累犯风险模型和欺诈检测中，都存在悬而未决的人命问题。在这些情况下，最好谨慎行事，保护尽可能多的人——无论这是否意味着降低误报或漏报的数量。

当考虑如何优化这些类型的模型时，我们可以解读一些指标。

**回想一下:**以宫颈癌风险数据集为例，您可以问自己这个模型— 在所有实际被诊断患有癌症的患者中，我们的模型预测患有癌症的比例是多少？

然而，回忆并不能让你了解全貌。假设你的模型将每个人都归类为患有癌症，包括那些没有患癌症的人，那么你的得分就是 100%。低召回分数表示高数量的假阴性。

Precision: Precision 提出了相反的问题——在所有被模型预测为患有癌症的患者中，有多少人确实患有癌症？

如果你的模型预测 10 名患者患有癌症，如果所有的预测都是正确的，我们的得分将是 100%，即使还有 1000 多名患者没有得到诊断。低精度分数表示高数量的假阳性。

**准确性:**准确性是一个更可靠的评估指标，因为它衡量真实预测的总数，包括正面和负面预测。这是分类任务中最常见的指标。

**F1 得分:**F1 得分是另一个非常有用的指标。因为它衡量的是“精确度和召回率的调和平均值”，如果精确度和召回率都不高，它就不可能高，这表明模型整体表现良好。但是，F1 分数可以格式化，以解决二进制、多类和不平衡分类问题，在sk learn . metrics. F1 _ score 方法中使用以下参数:

• 二进制— 用于二进制分类问题。
• 微— 统计总的真阳性、假阴性和假阳性。
• 宏— 计算所有类别的未加权平均值(对于多类别问题。)
• 加权— 通过对每个类别的真阳性进行加权并取平均分数来说明类别不平衡。
• 样本— 查找每个类的每个指标的平均分。

让我们对抗不平等，一次一个重采样方法！

有了这些信息，我们将优化二进制 F1 分数，因为我们只有两个类。你可能会想“如果我们的数据如此严重不平衡，为什么不使用加权 F1 分数？”这就是重采样方法的用武之地！

我们将探讨三种简单而有用的方法(尽管还有更多)——对多数采样不足、对少数采样过采样和 SMOTE(合成少数采样过采样技术)。我们将使用的每种方法都旨在创建一个对半分布的训练集，因为我们正在处理一个二元分类问题。这些方法可用于为四个类别的多类别问题创建 25–25–25–25 分布，而不考虑类别的初始分布，或其他可能训练您的模型以获得更好结果的比率。

在重新采样之前，请确保将您的数据分成训练集和测试集！ 如果你不这样做，你会因为数据泄露而损害模型的质量，导致过度拟合和泛化能力差。

*# Import the resampling package*
from sklearn.utils import resample*# Split into training and test sets*
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)*# Returning to one dataframe*
training_set = pd.concat([X_train, y_train], axis=1)*# Separating classes*
cancer = training_set[training_set.Cancer == 1]
not_cancer = training_set[training_set.Cancer == 0]

欠采样多数

欠采样可以定义为减少多数类的数量。这种技术最适用于有数千甚至数百万个数据点的数据。通常，您不希望减少正在处理的数据量，但是如果您可以牺牲一些训练数据，这种技术将非常有用。下面是它在宫颈癌数据集上的工作原理:

*# Undersampling the majority*
undersample = resample(not_cancer, 
                       replace=True, 
                       n_samples=len(cancer), #set the number of samples to equal the number of the minority class
                       random_state=42)*# Returning to new training set*
undersample_train = pd.concat([cancer, undersample])undersample_train.Cancer.value_counts(normalize=True)

我们有均匀分布的班级！现在我们可以在随机森林分类器上测试它。

*# Separate undersampled data into X and y sets*
undersample_x_train = undersample_train.drop('Cancer', axis=1)
undersample_y_train = undersample_train.Cancer*# Fit model on undersampled data*
undersample_rf = RandomForestClassifier(n_estimators=500).fit(undersample_x_train, undersample_y_train)*# Make predictions on test sets*
y_pred = random_forest.predict(X_test)print('Accuracy score: ' + str(accuracy_score(y_test, y_pred)))
print('Average Recall score: ' + str(recall_score(y_test, y_pred, average='macro')))
print(classification_report(y_test, y_pred))

不完全是最好的结果，但因为我们减少了多数类的数量，我们只在 28 个实例上训练我们的模型，这对于样本大小来说太小了。接下来，我们将尝试对少数进行过采样。

过采样少数

对少数民族进行过采样将增加少数民族类中的数据点数量，同样旨在均匀分布训练集中的类。我们将重复和以前一样的过程。

*# Oversampling the minority*
oversample = resample(cancer, 
                       replace=True, 
                       n_samples=len(not_cancer), #set the number of samples to equal the number of the majority class
                       random_state=42)*# Returning to new training set*
oversample_train = pd.concat([not_cancer, oversample])oversample_train.Cancer.value_counts(normalize=True)

*# Separate oversampled data into X and y sets*
oversample_x_train = oversample_train.drop('Cancer', axis=1)
oversample_y_train = oversample_train.Cancer*# Fit model on oversampled data*
oversample_rf = RandomForestClassifier(n_estimators=500).fit(oversample_x_train, oversample_y_train)*# Make predictions on test sets*
y_pred = oversample_rf.predict(X_test)
print('Accuracy score: ' + str(accuracy_score(y_test, y_pred)))
print('Average Recall score: ' + str(recall_score(y_test, y_pred, average='macro')))
print(classification_report(y_test, y_pred))

不幸的是，我们的结果只是稍微好一点。我们还有一项技术可以尝试。

SMOTE(合成少数过采样技术)

SMOTE 从现有的少数类池中合成数据点，并将它们添加到数据集中。这种技术通过为模型创建新的、不可见的数据点进行训练，确保了数据泄漏非常少。

*# Import the SMOTE package*
from imblearn.over_sampling import SMOTE*# Synthesize minority class datapoints using SMOTE*
sm = SMOTE(random_state=42, sampling_strategy=’minority’)
smote_x_train, smote_y_train = sm.fit_resample(X_train, y_train)*# Separate into training and test sets*
smote_x_train = pd.DataFrame(smote_x_train, columns = X_train.columns)
smote_y_train = pd.DataFrame(smote_y_train, columns = ['Cancer'])smote = RandomForestClassifier(n_estimators=1000).fit(smote_x_train, smote_y_train)

*# Predict on training set*
smote_preds = smote.predict(X_test)*# Checking accuracy and recall*
print('Accuracy Score: ', accuracy_score(y_test, smote_preds),'\n\n')
print('Averaged Recall Score: ', recall_score(y_test, smote_preds, average='macro'), '\n\n')

print(classification_report(y_test, smote_preds))

准确性和 f1 分数有所提高，但回忆分数略有下降。根据您的模型用例，此时您必须决定哪个模型保护的人最多。

AOC 是美国下层的冠军，但是 ROC AUC 是模型评测的冠军

可视化模型质量的最佳方法之一是检查 ROC 曲线。ROC(受试者工作特性)曲线绘出了真阳性率 TPR 与假阳性率 FPR 的关系。最佳预测将在没有假阳性(成本)和 100%真阳性(收益)的点(0，1)处找到。

包括在图中的是无描述线，它展示了随机猜测，类似于抛硬币的概率。线上的点是“好的”猜测，因为它们在点(0，1)上更接近完美的结果。反之亦然，线以下的点表示预测不佳。

AUC，或曲线下面积，是可分离程度的定量度量。预测越接近理想结果，AUC 就越大。当 AOC 告诉我们不要退而求其次时，她是在告诉我们将 AUC 定在接近 1%或 100%的水平。

这是一个用 SMOTE 重采样训练集训练的随机森林分类器的例子(阅读文档此处):

y_score = smote.fit(smote_x_train, smote_y_train).predict_proba(X_test)[:,1]fpr, tpr, thresholds = roc_curve(y_test, y_score)
print('AUC: {}'.format(auc(fpr, tpr)))

不算太差！仍有很大的改进空间，但我们可以从图中看出这一点:

plt.figure(figsize=(10, 8))
lw = 2
plt.plot(fpr, tpr, color=’darkorange’,
 lw=lw, label=’ROC curve’)
plt.plot([0, 1], [0, 1], color=’navy’, lw=lw, linestyle=’ — ‘)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.yticks([i/20.0 for i in range(21)])
plt.xticks([i/20.0 for i in range(21)])
plt.xlabel(‘False Positive Rate’)
plt.ylabel(‘True Positive Rate’)
plt.title(‘Receiver operating characteristic (ROC) Curve’)
plt.legend(loc=’lower right’)
plt.show()

理想情况下，我们希望看到橙色线更加陡峭，直到它非常接近(0，1)时才会变平，但这是一个很好的起点。

与所有机器学习项目一样，这个过程是迭代的。在您决定采用哪种方法之前，还有其他方法可以对您的模型进行重新采样和验证。彻底考虑哪种性能指标符合您的目的，选择一种适合您的数据类型的算法，并根据部署后危害最小的算法来评估您的模型。

请在下面评论，告诉我你重新采样数据的其他方法！

机器学习路线图——我的旅程和进化

原文：https://towardsdatascience.com/machine-learning-roadmap-my-journey-and-evolution-a76ae656969?source=collection_archive---------12-----------------------

我从机械工程师到机器学习科学家的旅程和职业转型，以及经验教训

尼克·莫里森在 Unsplash 上拍摄的照片

人工智能、机器学习、深度学习、物联网等。是过去几年的流行语。如果有人在战略，商业或 IT 咨询，不知道至少基本的信息技术，那么我想他们是非常多余的。

为了跟上两年前的潮流，我决定熟悉机器学习和深度学习。

我们中的许多人希望转行到机器学习/人工智能领域，或者来自非科学背景，因此发现获得必要的知识具有挑战性。在这篇文章中，我将分享我的旅程和进化，以及帮助我获得这方面知识的资源。我希望它能提供洞察力，帮助你构建你的学习路径。

我的挑战

20 年前我学的是机械工程。工程学位让我能够用理性的方式进行系统思考。我在工程系学过高等微积分和线性代数，这些年来我忘记了大部分概念。很快就变得很明显，我需要学习一些东西作为先决条件，甚至在开始学习机器的 ABC 或深度学习之前。

1. 复习线性代数、微积分和概率的概念
2. 学习基本统计学
3. 选择主要语言
4. 学习地图

我没有精力去读数学课本，因此为了复习，我看了可汗学院和麻省理工学院开放课件上的线性代数、微积分和概率的视频。我将特别推荐吉尔伯特·斯特朗教授的讲座。

[## 麻省理工学院开放式课程|免费在线课程材料

麻省理工学院开放式课程是一个基于网络的出版物，包含了几乎所有的麻省理工学院课程内容。开放式课程是开放的，可供…

ocw.mit.edu](https://ocw.mit.edu/index.htm)

由于大量的库和开发者支持，我将 python 作为我的主要编程语言。

一旦我修改了数学概念，我就开始学习 Python。我以前用 C 语言做过编程，我已经知道了循环、条件语句等概念。

我发现 Eric Matthes 的书《 Python 速成班:基于项目的编程入门 》非常有助于理解语法和基本概念。我用来磨练我的基本 python 技能的另一本书是 Al Sweigart 的用 Python 自动化枯燥的东西，第二版:完全初学者实用编程】。

在对 python 有了一个良好的基础之后，我把重点放在了用于机器学习的 python 包的三位一体上，即 NumPy、pandas 和 matplotlib/seaborn。

用于机器学习的 Python 三位一体库—图片由作者提供

所有三个软件包的官方文档都写得非常好，即使对于初学者也很容易理解。我从 NumPy 开始，然后去了 Pandas，最后去了 matplotlib/seaborn，以获得关于数据可视化的想法。

我花了大约 2 个月的时间，花了大约 3 个小时阅读，才达到这一点。在那之前，我从未学过统计学，我对统计学的全部知识仅限于平均值和众数。

我发现 David Spiegelhalter 的书《统计的艺术:从数据中学习》很有帮助。它不仅帮助我以非数学的方式了解统计学，而且在数据科学可视化方面也有很大帮助。它教会了我如何基于不同的数据可视化，基于相同的数据点传达不同的信息。

带着对基本统计学的概念性理解，我阅读了《数据科学家实用统计学:使用 R 和 Python 的 50+基本概念》一书，以建立程序化的实践知识。**

作者的机器学习地图-按作者分类的图片

经过三个月的学习，我终于准备好开始学习机器学习了。如果我能说出一本书加速了我的学习并解释了从初学者到高级水平的概念，那么它就是 Aurelien Geron 的“用 Scikit-Learn、Keras 和 TensorFlow 进行机器学习:构建智能系统的概念、工具和技术”。

一旦你遵循了我上面提到的从 python 到 pandas 和 matplotlib 的学习路径，那么这本书里没有一行是你不能理解的。这本书里没有数学术语的完整的动手方法对没有高级数学知识的人很有帮助。

我一共花了六个月的时间达到中级机器学习的熟练程度，又花了两个月的时间了解深度学习的基础知识。

我的旅程中的主要收获和收获

机器学习和数据科学的熟练程度取决于对以下领域的扎实知识

• 至少具备中级 python 编程知识
• 关于 Numpy 、 Pandas 和Matplotlib/SeabornPython 库的高级知识

不要急于开始机器学习图书馆和书籍，如果你还没有完全掌握这些图书馆的话。这些领域的全面知识将使你的机器学习变得迅速和愉快。

从线性回归等更简单、更知名的算法开始你的机器学习。不要试图用一个最复杂的鲜为人知的算法来显得博学并给别人留下深刻印象。

Scikit-learn 是一个非常强大和通用的机器学习库。从初学者的角度来看，它也是非常用户友好的，并且是可用的文档最丰富的库之一。我强烈建议从 Scikit-learn 开始，并在转到其他库之前花大量时间熟悉它。

在涉足深度学习世界之前，先熟悉机器学习。在没有很好地理解机器学习的情况下急于进行深度学习，从长远来看是没有帮助的。

从深度学习的 Keras 库开始，你可以把 TensorFlow 放在后面。

最后，在机器和深度学习上利用 Coursera 和 Edx 上的免费学习资源。

我希望开始机器和深度学习之旅的读者能够从本文概述的我的旅程中获得一些关于学习方法的见解，并能够构建他们的学习路径。

我有兴趣知道机器学习的其他专家和学生的学习地图、关键资源和方法。

机器学习:关于交叉验证的一些注意事项

原文：https://towardsdatascience.com/machine-learning-some-notes-about-cross-validation-4a0315599f2?source=collection_archive---------35-----------------------

交叉验证的不同方法概述

制造者在 Unsplash 上 NESA 的照片

简介

如您所知，当我们将数据分为训练集和测试集时，我们的主要目标是了解模型在面对与训练阶段使用的数据不同的新数据时的预测能力。

无论如何，有一个可靠的方法来评估我们的模型的性能。这种方式被称为交叉验证。交叉验证是一种评估泛化性能的统计技术，它比使用分为训练集和测试集的方法更稳定。

在本文中，我们将了解一些交叉验证方法，如 K 倍交叉验证、分层 K 倍交叉验证和留一交叉验证。

第一部分:K 倍交叉验证

k 重交叉验证是最常用的交叉验证方法之一。在这个方法中， k 表示为了测试和训练我的数据，我想要尝试的实验(或折叠)次数。

例如，假设我们想要用由 1000 条记录组成的数据进行 5 次实验(或性能)。因此，在第一个实验中，我们测试或验证前 200 条记录，然后训练剩余的 800 条记录。当第一个实验完成时，我获得了一定的精度。然后，我们进行第二个实验，测试我之前测试的记录之后的 200 条记录，并训练剩余的 800 条记录。

我用一组 200 个记录继续实验，直到我完成所有 5 个实验。请记住，我们总是测试先前记录的下 200 个记录，并训练剩余的记录直到结束。

在我的 5 次实验结束时，我将获得 5 次精度，最终精度将是所有精度的平均值。

下面你可以看到一个直观的例子。

作者图片

交叉验证是在 scikit-learn 中使用来自 model_selecion 模块的 cross_val_score 函数实现的。 cross_val_score 函数的参数是我们想要评估的模型、训练数据和目标。下面是一个逻辑回归的例子:

from **sklearn.model_selection** import **cross_val_score**from **sklearn.linear_model** import **LogisticRegression**logreg = LogisticRegression()scores = cross_val_score(logreg, X,y,cv=5)

第二部分:分层 K 褶交叉验证

考虑到前面 1000 条记录的例子，有时从测试前 200 条记录开始并不总是一个好主意。事实上，在一个数据集中，我们可以发现前三分之一的数据指向同一个类。

假设我们有三个类(0、1 和 2)，如下所示:

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]

可以看到，第一个第三类是 0，第二个是 1，第三个是 2。现在想象做 3 个实验(k=3)。在我们的第一个实验中，测试集只在类 0 中，训练集只在类 1 和 2 中。所以，你可以知道精度是 0。

为了处理这个问题，我们可以使用分层 k 倍交叉验证。在分层交叉验证中，我们对数据进行分割，使每个折叠中的类之间的比例与它们在整个数据集中的比例相同，如下图所示。在该图中，对 k 倍交叉验证和分层交叉验证进行了比较:

作者图片

Scikit-learn 帮助我们进行分层折叠。所以:

from **sklearn.model_selection** import **StratifiedKFold**skf = StratifiedKFold(n_split=5, random_state=None)# X is the feature set and y is the target
for train_index, test_index in skf.split(X,y): 
    print("Train:", train_index, "Test:", test_index) 
    X_train, X_test = X.iloc[train_index], X.iloc[test_index] 
    y_train, y_test = y[train_index], y[test_index]

第三部分:留一交叉验证

另一个有趣的交叉验证方法是**留一法。**这种方法类似于我们之前看到的 k-fold，但是对于每个实验(或表演),我们只取一个样本进行测试，而不是像以前那样取 200 个记录。

下面，我们可以用 LeaveOneOut 在 scikit-learn 中找到实现。

from **sklearn.model_selection** import **LeaveOneOut**loo = LeaveOneOut()cross_val_score(logreg, X, y, cv=loo)

结论

在本文中，您已经看到了机器学习中用于评估模型准确性的最常见的交叉验证方法。无论如何，还有一些其他的方法，如混洗-分裂交叉验证，分组交叉验证和时间序列交叉验证，在某些情况下非常有用。

感谢你阅读这篇文章。您还可以通过其他方式与我保持联系并关注我的工作:

• 订阅我的时事通讯。
• 也可以通过我的电报群 数据科学初学者 联系。

机器学习:循序渐进

原文：https://towardsdatascience.com/machine-learning-step-by-step-6fbde95c455a?source=collection_archive---------1-----------------------

使用随机森林、PCA 和超参数调整的 Python 机器学习分类分步指南——带代码！

图像来源

作为数据科学家，我们有许多选择来创建分类模型。最流行和可靠的方法之一是使用随机森林。我们可以对 随机森林 执行 超参数调整 来尝试优化模型的性能。

在将我们的数据拟合到模型之前，尝试【PCA】也是常见的做法。但是我们为什么还要增加这一步呢？随机森林的全部意义不就是帮助我们容易地解释特征重要性吗？

是的，当我们分析随机森林模型的“特征重要性”时，PCA 会使解释每个“特征”变得更加困难。但是，PCA 执行降维，这可以减少随机森林要处理的要素数量，因此 PCA 可能有助于加快随机森林模型的训练。请注意，计算成本是随机森林的最大缺点之一(运行模型可能需要很长时间)。主成分分析会变得非常重要，尤其是在处理成百上千个预测特征的时候。因此，如果最重要的事情是简单地拥有性能最好的模型，并且可以牺牲解释特征重要性，那么 PCA 可能是有用的尝试。

现在，让我们开始我们的例子。我们将使用 Scikit-learn“乳腺癌”数据集。 我们将创建 3 个模型，并相互比较它们的性能:

• 1.随机森林
• 2.PCA 降维的随机森林
• 3.PCA 降维的随机森林&超参数调整

1.输入数据

首先，我们加载数据并创建一个数据框架。由于这是来自 Scikit-learn 的预先清理过的“玩具”数据集，我们可以继续进行建模过程了。但是，作为最佳实践，我们应该始终做到以下几点:

• 使用 df.head() 浏览新的数据帧，确保它看起来像预期的那样。
• 使用 df.info() 来了解每一列中的数据类型和计数。您可能需要根据需要转换数据类型。
• 使用 df.isna() 来确保没有 NaN 值。您可能需要根据需要估算值或删除行。
• 使用 df.describe() 了解每一列的最小值、最大值、平均值、中值、标准偏差和四分位间距。

名为**“cancer”的列是我们希望使用模型预测的目标变量。“0”表示“没有癌症”，“1”表示“癌症”。**

import pandas as pd
from sklearn.datasets import load_breast_cancercolumns = ['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']dataset = load_breast_cancer()
data = pd.DataFrame(dataset['data'], columns=columns)
data['cancer'] = dataset['target']display(data.head())
display(data.info())
display(data.isna().sum())
display(data.describe())

上面是乳腺癌数据框架的一部分。每一行都有关于患者的观察结果。名为“癌症”的最后一列是我们试图预测的目标变量。 0 表示“没有癌症”，1 表示“癌症”。

2.训练/测试分割

现在，我们使用 Scikit-learn 的“train_test_split”函数分割数据。我们希望为模型提供尽可能多的数据来进行训练。然而，我们还想确保我们有足够的数据让模型进行自我测试。通常，随着数据集中行数的增加，我们可以提供给定型集的数据就越多。

例如，如果我们有数百万行，我们可以有 90%的训练/ 10%的测试分割。然而，我们的数据集只有 569 行，这对于训练或测试来说并不是一个非常大的数据集。因此，为了公平对待训练和测试，我们将数据分成 50%训练和 50%测试。我们设置分层=y 以确保训练集和测试集与原始数据集具有相同比例的 0 和 1。

from sklearn.model_selection import train_test_splitX = data.drop('cancer', axis=1)  
y = data['cancer'] 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.50, random_state = 2020, stratify=y)

3.缩放数据

在建模之前，我们需要通过缩放来“居中”和“标准化”我们的数据。我们按比例控制，因为不同的变量在不同的比例上测量。我们进行缩放，以便每个预测者可以在决定重要性时相互“公平竞争”。见此文。我们还将“y_train”从 Pandas“Series”对象转换为 NumPy 数组，以便模型稍后接受目标训练数据。

import numpy as np
from sklearn.preprocessing import StandardScalerss = StandardScaler()
X_train_scaled = ss.fit_transform(X_train)
X_test_scaled = ss.transform(X_test)
y_train = np.array(y_train)

4.适合“基线”随机森林模型

现在我们创建一个“基线”随机森林模型。该模型使用所有预测功能以及在 Scikit-learn 随机森林分类器文档中定义的默认设置。首先，我们对模型进行实例化，并对缩放后的数据进行拟合。我们可以根据我们的训练数据来衡量模型的准确性。

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import recall_scorerfc = RandomForestClassifier()
rfc.fit(X_train_scaled, y_train)
display(rfc.score(X_train_scaled, y_train))# 1.0

如果我们想知道哪些特征对随机森林模型预测乳腺癌最重要，我们可以通过调用 “feature_importances_” 方法来可视化和量化重要性:

feats = {}
for feature, importance in zip(data.columns, rfc_1.feature_importances_):
    feats[feature] = importanceimportances = pd.DataFrame.from_dict(feats, orient='index').rename(columns={0: 'Gini-Importance'})
importances = importances.sort_values(by='Gini-Importance', ascending=False)
importances = importances.reset_index()
importances = importances.rename(columns={'index': 'Features'})sns.set(font_scale = 5)
sns.set(style="whitegrid", color_codes=True, font_scale = 1.7)
fig, ax = plt.subplots()
fig.set_size_inches(30,15)
sns.barplot(x=importances['Gini-Importance'], y=importances['Features'], data=importances, color='skyblue')
plt.xlabel('Importance', fontsize=25, weight = 'bold')
plt.ylabel('Features', fontsize=25, weight = 'bold')
plt.title('Feature Importance', fontsize=25, weight = 'bold')display(plt.show())
display(importances)

5.主成分分析

现在，我们如何改进我们的基线模型？使用降维，我们可以用更少的变量逼近原始数据集，同时降低运行模型的计算能力。使用主成分分析，我们可以研究这些特征的累积解释方差比率，以了解哪些特征解释了数据中的最大方差。

我们实例化 PCA 函数，并设置我们想要考虑的组件(特征)的数量。我们将它设置为“30 ”,以查看所有生成组件的解释差异，然后决定在哪里进行切割。然后，我们将缩放后的 X_train 数据“拟合”到 PCA 函数。

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.decomposition import PCApca_test = PCA(n_components=30)
pca_test.fit(X_train_scaled)sns.set(style='whitegrid')
plt.plot(np.cumsum(pca_test.explained_variance_ratio_))
plt.xlabel('number of components')
plt.ylabel('cumulative explained variance')
plt.axvline(linewidth=4, color='r', linestyle = '--', x=10, ymin=0, ymax=1)
display(plt.show())evr = pca_test.explained_variance_ratio_
cvr = np.cumsum(pca_test.explained_variance_ratio_)pca_df = pd.DataFrame()
pca_df['Cumulative Variance Ratio'] = cvr
pca_df['Explained Variance Ratio'] = evr
display(pca_df.head(10))

该图显示，超过 10 个成分后，我们没有获得太多的解释方差。

该数据帧显示了累积方差比(解释了数据的总方差)和解释方差比(每个 PCA 成分解释了数据的总方差)。

**看上面的数据框架，当我们使用主成分分析将 30 个预测变量减少到 10 个成分时，我们仍然可以解释超过 95%的方差。**其他 20 个成分解释了不到 5%的方差，因此我们可以剔除它们。使用这个逻辑，我们将使用 PCA 将 X_train 和 X_test 的组件数量从 30 个减少到 10 个。我们将把这些重新创建的“降维”数据集分配给“X_train_scaled_pca”和“X_test_scaled_pca”。

pca = PCA(n_components=10)
pca.fit(X_train_scaled)X_train_scaled_pca = pca.transform(X_train_scaled)
X_test_scaled_pca = pca.transform(X_test_scaled)

每个分量都是原始变量与相应“权重”的线性组合。通过创建数据帧，我们可以看到每个 PCA 成分的“权重”。

pca_dims = []
for x in range(0, len(pca_df)):
    pca_dims.append('PCA Component {}'.format(x))pca_test_df = pd.DataFrame(pca_test.components_, columns=columns, index=pca_dims)
pca_test_df.head(10).T

6.PCA 后适合“基线”随机森林模型

现在，我们可以将我们的 X_train_scaled_pca 和 y_train 数据拟合到另一个“基线”随机森林模型，以查看我们是否对模型的预测有任何改进。

rfc = RandomForestClassifier()
rfc.fit(X_train_scaled_pca, y_train)display(rfc.score(X_train_scaled_pca, y_train))# 1.0

7.第一轮超参数调整:RandomSearchCV

在执行 PCA 之后，我们还可以尝试一些超参数调整来调整我们的随机森林，以获得更好的预测性能。超参数可以被认为是模型的“设置”。一个数据集的完美设置对于另一个数据集是不一样的，所以我们必须“调整”模型。

首先，我们可以从 RandomSearchCV 开始考虑广泛的值。随机森林的所有超参数都可以在 Scikit-learn 随机森林分类器文档中找到。

我们生成一个“param_dist ”,其中包含一系列值，用于尝试每个超参数。RandomSearchCV 被实例化，我们的随机森林模型首先被传入，然后是我们的“param_dist”、要尝试的迭代次数以及要执行的交叉验证的次数。

**“详细”**超参数在模型运行时为您提供或多或少的输出(比如状态更新)。 “n_jobs” 超参数让您决定要使用多少个处理器内核来运行模型。设置“n_jobs = -1”将使模型运行得最快，因为它使用了您所有的计算机核心。

我们将调整这些超参数:

• n_estimators: 我们的随机森林中“树”的数量。
• max_features: 每次分割的特征数量。
• max_depth: 每棵树可以拥有的最大“分裂”数。
• min_samples_split: 树的节点可以自我分裂之前所需的最小观察次数。
• min_samples_leaf: 每棵树末端的每片叶子所需的最小观察次数。
• bootstrap: 是否使用 bootstrap 为随机森林中的每棵树提供数据。(Bootstrapping 是从数据集中随机取样并替换。)

from sklearn.model_selection import RandomizedSearchCVn_estimators = [int(x) for x in np.linspace(start = 100, stop = 1000, num = 10)]max_features = ['log2', 'sqrt']max_depth = [int(x) for x in np.linspace(start = 1, stop = 15, num = 15)]min_samples_split = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]min_samples_leaf = [int(x) for x in np.linspace(start = 2, stop = 50, num = 10)]bootstrap = [True, False]param_dist = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}rs = RandomizedSearchCV(rfc_2, 
                        param_dist, 
                        n_iter = 100, 
                        cv = 3, 
                        verbose = 1, 
                        n_jobs=-1, 
                        random_state=0)rs.fit(X_train_scaled_pca, y_train)
rs.best_params_# {'n_estimators': 700,
# 'min_samples_split': 2,
# 'min_samples_leaf': 2,
# 'max_features': 'log2',
# 'max_depth': 11,
# 'bootstrap': True}

**在 n_iter = 100 和 cv = 3 的情况下，我们创建了 300 个随机森林模型，**随机采样上面输入的超参数的组合。我们可以调用 “best_params_” 来获得性能最好的模型的参数(显示在上面代码框的底部)。然而，这个阶段的“最佳参数”可能不会给我们最好的洞察力来获得一系列参数，以尝试下一轮的超参数调整。为了获得接下来要尝试的一系列值，我们可以很容易地获得 RandomSearchCV 结果的数据框架。

rs_df = pd.DataFrame(rs.cv_results_).sort_values('rank_test_score').reset_index(drop=True)
rs_df = rs_df.drop([
            'mean_fit_time', 
            'std_fit_time', 
            'mean_score_time',
            'std_score_time', 
            'params', 
            'split0_test_score', 
            'split1_test_score', 
            'split2_test_score', 
            'std_test_score'],
            axis=1)
rs_df.head(10)

现在，让我们在 x 轴上创建每个超参数的条形图，以及在每个值上建立的模型的平均得分，以查看平均而言哪些值是最成功的:

fig, axs = plt.subplots(ncols=3, nrows=2)
sns.set(style="whitegrid", color_codes=True, font_scale = 2)
fig.set_size_inches(30,25)sns.barplot(x='param_n_estimators', y='mean_test_score', data=rs_df, ax=axs[0,0], color='lightgrey')
axs[0,0].set_ylim([.83,.93])axs[0,0].set_title(label = 'n_estimators', size=30, weight='bold')sns.barplot(x='param_min_samples_split', y='mean_test_score', data=rs_df, ax=axs[0,1], color='coral')
axs[0,1].set_ylim([.85,.93])axs[0,1].set_title(label = 'min_samples_split', size=30, weight='bold')sns.barplot(x='param_min_samples_leaf', y='mean_test_score', data=rs_df, ax=axs[0,2], color='lightgreen')
axs[0,2].set_ylim([.80,.93])axs[0,2].set_title(label = 'min_samples_leaf', size=30, weight='bold')sns.barplot(x='param_max_features', y='mean_test_score', data=rs_df, ax=axs[1,0], color='wheat')
axs[1,0].set_ylim([.88,.92])axs[1,0].set_title(label = 'max_features', size=30, weight='bold')sns.barplot(x='param_max_depth', y='mean_test_score', data=rs_df, ax=axs[1,1], color='lightpink')
axs[1,1].set_ylim([.80,.93])axs[1,1].set_title(label = 'max_depth', size=30, weight='bold')sns.barplot(x='param_bootstrap',y='mean_test_score', data=rs_df, ax=axs[1,2], color='skyblue')
axs[1,2].set_ylim([.88,.92])
axs[1,2].set_title(label = 'bootstrap', size=30, weight='bold')plt.show()

查看上面的图表，我们可以了解每个超参数的每个值平均表现如何。

n_estimators: 300，500，700 似乎平均得分最高。

min_samples_split: 像 2 和 7 这样的较小值似乎得分较高。23 岁也有高分。我们可以尝试 2 以上的几个值，23 左右的几个值。

min_samples_leaf: 较小的值似乎与较高的分数相关…我们可以尝试 2-7 之间的值。

max _ features:“sqrt”平均分最高。

max_depth: 没有明确的模式，但是数值 2，3，7，11，15 似乎做的不错。

bootstrap: “假”平均分最高。

因此，现在我们可以将这些见解^，并进入第二轮超参数调整，以进一步缩小我们的选择。

8.第二轮超参数调优:GridSearchCV

在使用 RandomSearchCV 之后，我们可以使用 GridSearchCV 对我们的最佳超参数进行更精确的搜索。超参数是相同的，但是现在我们使用 GridSearchCV 执行更“详尽”的搜索。**在 GridSearchCV 中，尝试超参数值的每一个组合，这比 RandomSearchCV 需要更多的计算能力，在 RandomSearchCV 中，我们可以直接控制我们想要尝试的迭代次数。**例如，为我们的 6 个参数中的每一个仅搜索 10 个不同的参数值，使用三重交叉验证将需要 10⁶ x 3 或 3，000，000 次模型拟合！这就是为什么我们在使用 RandomSearchCV 之后执行 GridSearchCV，以帮助我们首先缩小搜索范围。

因此，使用我们从随机搜索 CV 中了解到的信息，让我们插入每个超参数的平均最佳表现范围:

from sklearn.model_selection import GridSearchCVn_estimators = [300,500,700]
max_features = ['sqrt']
max_depth = [2,3,7,11,15]
min_samples_split = [2,3,4,22,23,24]
min_samples_leaf = [2,3,4,5,6,7]
bootstrap = [False]param_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}gs = GridSearchCV(rfc_2, param_grid, cv = 3, verbose = 1, n_jobs=-1)
gs.fit(X_train_scaled_pca, y_train)
rfc_3 = gs.best_estimator_
gs.best_params_# {'bootstrap': False,
# 'max_depth': 7,
# 'max_features': 'sqrt',
# 'min_samples_leaf': 3,
# 'min_samples_split': 2,
# 'n_estimators': 500}

**在^，我们正在对 3x 1 x 5x 6 x 6 x 1 = 540 个模型拟合执行三重交叉验证，总共有 1，620 个模型拟合！**现在，在执行了 RandomizedSearchCV 和 GridSearchCV 之后，我们可以调用“best_params_”来获得一个最佳模型来尝试和预测我们的数据(显示在上面代码框的底部)。

9.根据测试数据评估模型的性能

现在，我们可以评估我们根据测试数据建立的每个模型。请记住，我们正在测试 3 种模型:

• 1.基线随机森林
• 2.PCA 降维的基线随机森林
• 3.使用 PCA 降维的基线随机森林和超参数调整

让我们生成每个模型的预测:

y_pred = rfc.predict(X_test_scaled)
y_pred_pca = rfc.predict(X_test_scaled_pca)
y_pred_gs = gs.best_estimator_.predict(X_test_scaled_pca)

现在，让我们为每个模型创建混淆矩阵，看看每个模型预测乳腺癌的能力如何:

from sklearn.metrics import confusion_matrixconf_matrix_baseline = pd.DataFrame(confusion_matrix(y_test, y_pred), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])conf_matrix_baseline_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_pca), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])conf_matrix_tuned_pca = pd.DataFrame(confusion_matrix(y_test, y_pred_gs), index = ['actual 0', 'actual 1'], columns = ['predicted 0', 'predicted 1'])display(conf_matrix_baseline)
display('Baseline Random Forest recall score', recall_score(y_test, y_pred))
display(conf_matrix_baseline_pca)
display('Baseline Random Forest With PCA recall score', recall_score(y_test, y_pred_pca))
display(conf_matrix_tuned_pca)
display('Hyperparameter Tuned Random Forest With PCA Reduced Dimensionality recall score', recall_score(y_test, y_pred_gs))

下面，我们有我们劳动的最终成果:

我们使用召回作为我们的性能指标，因为我们正在处理癌症诊断，并且最关心的是最小化我们模型中的假阴性预测错误。

考虑到这个^，看起来我们的基线随机森林模型做得最好，具有最高的召回分数 94.97% 。给定我们的测试数据集，基线模型正确预测了总共 179 名实际患有癌症的人中有 170 名患者患有癌症。

这个案例研究提出了一个重要的注意事项:有时，在 PCA 之后，或者甚至在广泛的超参数调优之后，一个调优的模型的性能可能不如一个普通的老式“普通”模型。但是尝试是很重要的。你永远不知道哪种模式会做得最好，除非你都尝试过。就预测癌症而言，模型越好，就能拯救越多的生命。

希望这有所帮助！快乐造型！