为什么现实世界的机器学习需要分布式计算

学习文章要努力，但是不要急！今天的这篇文章《为什么现实世界的机器学习需要分布式计算》将会介绍到等等知识点，如果你想深入学习文章，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

pyspark 如何帮助您像专业人士一样处理庞大的数据集

pytorch 和 tensorflow 等机器学习框架非常适合构建模型。但现实是，当涉及到现实世界的项目时（处理巨大的数据集），您需要的不仅仅是一个好的模型。您需要一种有效处理和管理所有数据的方法。这就是像 pyspark 这样的分布式计算可以拯救世界的地方。

让我们来分析一下为什么在现实世界的机器学习中处理大数据意味着超越 pytorch 和 tensorflow，以及 pyspark 如何帮助您实现这一目标。
真正的问题：大数据
您在网上看到的大多数机器学习示例都使用小型、易于管理的数据集。您可以将整个事情放入内存中，进行尝试，并在几分钟内训练模型。但在现实场景中（例如信用卡欺诈检测、推荐系统或财务预测），您要处理数百万甚至数十亿行。突然间，您的笔记本电脑或服务器无法处理它。

如果您尝试将所有数据一次性加载到 pytorch 或 tensorflow 中，事情就会崩溃。这些框架是为模型训练而设计的，而不是为了有效处理巨大的数据集。这就是分布式计算变得至关重要的地方。
为什么 pytorch 和 tensorflow 还不够
pytorch 和 tensorflow 非常适合构建和优化模型，但在处理大规模数据任务时却表现不佳。两个主要问题：

• 内存过载：他们在训练之前将整个数据集加载到内存中。这适用于小型数据集，但当您拥有 tb 级的数据时，游戏就结束了。
• 无分布式数据处理：pytorch 和 tensorflow 并不是为处理分布式数据处理而构建的。如果您有大量数据分布在多台机器上，那么它们并没有真正的帮助。

这就是 pyspark 的闪光点。它旨在处理分布式数据，在多台机器上高效处理数据，同时处理大量数据集，而不会导致系统崩溃。

真实示例：使用 pyspark 检测信用卡欺诈
让我们深入研究一个例子。假设您正在开发使用信用卡交易数据的欺诈检测系统。在本例中，我们将使用 kaggle 的流行数据集。它包含超过 284,000 笔交易，其中不到 1% 是欺诈交易。

第 1 步：在 google colab 中设置 pyspark
为此，我们将使用 google colab，因为它允许我们以最少的设置运行 pyspark。

!pip install pyspark

接下来，导入必要的库并启动 spark 会话。

import os
from pyspark.sql import sparksession
from pyspark.sql.functions import col, sum, udf
from pyspark.ml.feature import vectorassembler, stringindexer, minmaxscaler
from pyspark.ml.classification import randomforestclassifier, gbtclassifier
from pyspark.ml.tuning import paramgridbuilder, crossvalidator
from pyspark.ml.evaluation import binaryclassificationevaluator, multiclassclassificationevaluator
from pyspark.ml.linalg import vectors
import numpy as np
from pyspark.sql.types import floattype

启动 pyspark 会话

spark = sparksession.builder \
    .appname("frauddetectionimproved") \
    .master("local[*]") \
    .config("spark.executorenv.pythonhashseed", "0") \
    .getorcreate()

第 2 步：加载和准备数据

data = spark.read.csv('creditcard.csv', header=true, inferschema=true)
data = data.orderby("time")  # ensure data is sorted by time
data.show(5)
data.describe().show()

# check for missing values in each column
data.select([sum(col(c).isnull().cast("int")).alias(c) for c in data.columns]).show()

# prepare the feature columns
feature_columns = data.columns
feature_columns.remove("class")  # removing "class" column as it is our label

# assemble features into a single vector
assembler = vectorassembler(inputcols=feature_columns, outputcol="features")
data = assembler.transform(data)
data.select("features", "class").show(5)

# split data into train (60%), test (20%), and unseen (20%)
train_data, temp_data = data.randomsplit([0.6, 0.4], seed=42)
test_data, unseen_data = temp_data.randomsplit([0.5, 0.5], seed=42)

# print class distribution in each dataset
print("train data:")
train_data.groupby("class").count().show()

print("test and parameter optimisation data:")
test_data.groupby("class").count().show()

print("unseen data:")
unseen_data.groupby("class").count().show()

第 3 步：初始化模型

# initialize randomforestclassifier
rf = randomforestclassifier(labelcol="class", featurescol="features", probabilitycol="probability")

# create paramgrid for cross validation
paramgrid = paramgridbuilder() \
    .addgrid(rf.numtrees, [10, 20 ]) \
    .addgrid(rf.maxdepth, [5, 10]) \
    .build()

# create 5-fold crossvalidator
crossval = crossvalidator(estimator=rf,
                          estimatorparammaps=paramgrid,
                          evaluator=binaryclassificationevaluator(labelcol="class", metricname="areaunderroc"),
                          numfolds=5)

第 4 步：拟合、运行交叉验证，并选择最佳参数集

# run cross-validation, and choose the best set of parameters
rf_model = crossval.fit(train_data)

# make predictions on test data
predictions_rf = rf_model.transform(test_data)

# evaluate random forest model
binary_evaluator = binaryclassificationevaluator(labelcol="class", rawpredictioncol="rawprediction", metricname="areaunderroc")
pr_evaluator = binaryclassificationevaluator(labelcol="class", rawpredictioncol="rawprediction", metricname="areaunderpr")

auc_rf = binary_evaluator.evaluate(predictions_rf)
auprc_rf = pr_evaluator.evaluate(predictions_rf)
print(f"random forest - auc: {auc_rf:.4f}, auprc: {auprc_rf:.4f}")

# udf to extract positive probability from probability vector
extract_prob = udf(lambda prob: float(prob[1]), floattype())
predictions_rf = predictions_rf.withcolumn("positive_probability", extract_prob(col("probability")))

第 5 步计算精确率、召回率和 f1 分数的函数

# function to calculate precision, recall, and f1-score
def calculate_metrics(predictions):
    tp = predictions.filter((col("class") == 1) & (col("prediction") == 1)).count()
    fp = predictions.filter((col("class") == 0) & (col("prediction") == 1)).count()
    fn = predictions.filter((col("class") == 1) & (col("prediction") == 0)).count()

    precision = tp / (tp + fp) if (tp + fp) != 0 else 0
    recall = tp / (tp + fn) if (tp + fn) != 0 else 0
    f1_score = (2 * precision * recall) / (precision + recall) if (precision + recall) != 0 else 0

    return precision, recall, f1_score

第 6 步：找到模型的最佳阈值

# find the best threshold for the model
best_threshold = 0.5
best_f1 = 0
for threshold in np.arange(0.1, 0.9, 0.1):
    thresholded_predictions = predictions_rf.withcolumn("prediction", (col("positive_probability") > threshold).cast("double"))
    precision, recall, f1 = calculate_metrics(thresholded_predictions)

    if f1 > best_f1:
        best_f1 = f1
        best_threshold = threshold

print(f"best threshold: {best_threshold}, best f1-score: {best_f1:.4f}")

第七步：评估未见过的数据

# evaluate on unseen data
predictions_unseen = rf_model.transform(unseen_data)
auc_unseen = binary_evaluator.evaluate(predictions_unseen)
print(f"unseen data - auc: {auc_unseen:.4f}")

precision, recall, f1 = calculate_metrics(predictions_unseen)
print(f"unseen data - precision: {precision:.4f}, recall: {recall:.4f}, f1-score: {f1:.4f}")

area_under_roc = binary_evaluator.evaluate(predictions_unseen)
area_under_pr = pr_evaluator.evaluate(predictions_unseen)
print(f"unseen data - auc: {area_under_roc:.4f}, auprc: {area_under_pr:.4f}")

结果

best threshold: 0.30000000000000004, best f1-score: 0.9062
unseen data - auc: 0.9384
unseen data - precision: 0.9655, recall: 0.7568, f1-score: 0.8485
unseen data - auc: 0.9423, auprc: 0.8618

然后您可以保存此模型（几kb）并在 pyspark 管道中的任何地方使用它

rf_model.save()

这就是 pyspark 在处理现实机器学习任务中的大型数据集时产生巨大差异的原因：

轻松扩展：pyspark 可以跨集群分配任务，让您能够在不耗尽内存的情况下处理 tb 级的数据。
动态数据处理：pyspark 不需要将整个数据集加载到内存中。它根据需要处理数据，这使得它更加高效。
更快的模型训练：借助分布式计算，您可以通过在多台机器上分配计算工作负载来更快地训练模型。
最后的想法
pytorch 和 tensorflow 是构建机器学习模型的绝佳工具，但对于现实世界的大规模任务，您需要更多。使用 pyspark 进行分布式计算可让您高效处理庞大数据集、实时处理数据并扩展机器学习管道。

因此，下次您处理海量数据时（无论是欺诈检测、推荐系统还是财务分析），请考虑使用 pyspark 将您的项目提升到一个新的水平。

有关完整的代码和结果，请查看此笔记本。 :
https://colab.research.google.com/drive/1w9naxnzirirlrodsenhauwevyd5lh8d4?authuser=5#scrollto=odmodmqkcy23

__

我是 swapnil，请随意留下您的评论、结果和想法，或者联系我 - swapnil@nooffice.no 获取数据、软件开发工作和工作

好了，本文到此结束，带大家了解了《为什么现实世界的机器学习需要分布式计算》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！