Mengapa Anda Memerlukan Pengkomputeran Teragih untuk Pembelajaran Mesin Dunia Sebenar

Dan Bagaimana PySpark Boleh Membantu Anda Mengendalikan Set Data Besar Seperti Pro

Rangka kerja pembelajaran mesin seperti PyTorch dan TensorFlow adalah hebat untuk membina model. Tetapi realitinya ialah, apabila ia melibatkan projek dunia sebenar-di mana anda berurusan dengan set data yang besar-anda memerlukan lebih daripada sekadar model yang baik. Anda memerlukan cara untuk memproses dan mengurus semua data itu dengan cekap. Di situlah pengkomputeran teragih, seperti PySpark, datang untuk menyelamatkan hari ini.

Mari kita pecahkan sebab pengendalian data besar dalam pembelajaran mesin dunia sebenar bermakna melampaui PyTorch dan TensorFlow, dan cara PySpark membantu anda sampai ke sana.
Masalah Sebenar: Data Besar
Kebanyakan contoh ML yang anda lihat dalam talian menggunakan set data yang kecil dan boleh diurus. Anda boleh memasukkan semuanya ke dalam ingatan, bermain-main dengannya, dan melatih model dalam beberapa minit. Tetapi dalam senario dunia sebenar—seperti pengesanan penipuan kad kredit, sistem pengesyoran atau ramalan kewangan—anda berurusan dengan berjuta-juta malah berbilion-bilion baris. Tiba-tiba, komputer riba atau pelayan anda tidak dapat mengendalikannya.

Jika anda cuba memuatkan semua data itu ke dalam PyTorch atau TensorFlow sekaligus, keadaan akan rosak. Rangka kerja ini direka bentuk untuk latihan model, bukan untuk mengendalikan set data yang besar dengan cekap. Di sinilah pengkomputeran teragih menjadi penting.
Mengapa PyTorch dan TensorFlow Tidak Cukup
PyTorch dan TensorFlow bagus untuk membina dan mengoptimumkan model, tetapi ia gagal apabila menangani tugas data berskala besar. Dua masalah utama:

• Memory Overload: Mereka memuatkan keseluruhan set data ke dalam memori sebelum latihan. Itu berfungsi untuk set data kecil, tetapi apabila anda mempunyai terabait data, permainan akan berakhir.
• Tiada Pemprosesan Data Teragih: PyTorch dan TensorFlow tidak dibina untuk mengendalikan pemprosesan data teragih. Jika anda mempunyai sejumlah besar data yang tersebar merentasi berbilang mesin, ia tidak begitu membantu.

Di sinilah PySpark bersinar. Ia direka bentuk untuk berfungsi dengan data yang diedarkan, memprosesnya dengan cekap merentas berbilang mesin sambil mengendalikan set data yang besar tanpa merosakkan sistem anda.

Contoh Dunia Sebenar: Pengesanan Penipuan Kad Kredit dengan PySpark
Mari kita menyelami contoh. Katakan anda sedang mengusahakan sistem pengesanan penipuan menggunakan data transaksi kad kredit. Dalam kes ini, kami akan menggunakan set data popular daripada Kaggle. Ia mengandungi lebih 284,000 transaksi, dan kurang daripada 1% daripadanya adalah penipuan.

Langkah 1: Sediakan PySpark dalam Google Colab
Kami akan menggunakan Google Colab untuk ini kerana ia membolehkan kami menjalankan PySpark dengan persediaan yang minimum.

!pip install pyspark

Seterusnya, import perpustakaan yang diperlukan dan mulakan sesi 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

mulakan sesi pyspark

spark = SparkSession.builder \
    .appName("FraudDetectionImproved") \
    .master("local[*]") \
    .config("spark.executorEnv.PYTHONHASHSEED", "0") \
    .getOrCreate()

Langkah 2: Muatkan dan Sediakan data

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()

Langkah 3: Mulakan Model

# 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)

Langkah 4: Pasang, Jalankan pengesahan silang dan pilih set parameter terbaik

# 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")))

Langkah 5 Berfungsi untuk mengira ketepatan, mengingat semula dan skor 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

Langkah 6: Cari ambang terbaik untuk model

# 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}")

Langkah7: Nilai pada Data yang tidak kelihatan

# 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}")

KEPUTUSAN

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

Anda kemudian boleh menyimpan model ini (beberapa KB) dan menggunakannya di mana-mana dalam talian paip pyspark

rf_model.save()

Inilah sebabnya PySpark membuat perbezaan yang besar apabila berurusan dengan set data yang besar dalam tugas pembelajaran mesin dunia sebenar:

Ia Skala Dengan Mudah: PySpark boleh mengagihkan tugas merentas kelompok, membolehkan anda memproses terabait data tanpa kehabisan memori.
Pemprosesan Data On-the-Fly: PySpark tidak perlu memuatkan keseluruhan set data ke dalam memori. Ia memproses data mengikut keperluan, yang menjadikannya lebih cekap.
Latihan Model Lebih Pantas: Dengan pengkomputeran teragih, anda boleh melatih model dengan lebih pantas dengan mengagihkan beban kerja pengiraan merentas berbilang mesin.
Fikiran Akhir
PyTorch dan TensorFlow ialah alat yang hebat untuk membina model pembelajaran mesin, tetapi untuk dunia sebenar, tugasan berskala besar, anda memerlukan lebih banyak lagi. Pengkomputeran teragih dengan PySpark membolehkan anda mengendalikan set data yang besar dengan cekap, memproses data dalam masa nyata dan menskalakan saluran pembelajaran mesin anda.

Jadi, pada kali seterusnya anda menggunakan data yang besar—sama ada pengesanan penipuan, sistem pengesyoran atau analisis kewangan—pertimbangkan untuk menggunakan PySpark untuk membawa projek anda ke peringkat seterusnya.

Untuk kod dan hasil penuh, lihat buku nota ini. :
https://colab.research.google.com/drive/1W9naxNZirirLRodSEnHAUWevYd5LH8D4?authuser=5#scrollTo=odmodmqKcY23

__

Saya Swapnil, sila tinggalkan ulasan anda Keputusan dan idea, atau ping saya - swapnil@nooffice.no untuk Data, pertunjukan pembangun perisian dan pekerjaan

Atas ialah kandungan terperinci Mengapa Anda Memerlukan Pengkomputeran Teragih untuk Pembelajaran Mesin Dunia Sebenar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!