<jupyter_start><jupyter_text>Spark. Алгоритмы машинного обучения Полный список алгоритмов можно посмотреть в официальной документации https://spark.apache.org/docs/latest/ml-classification-regression.html<jupyter_code>%%capture
!pip install pyspark
# import pyspark
# from pyspark.sql import SparkSession
# # В качестве примера используется порт по умолчанию (local)
# conf = pyspark.SparkConf().setAppName('appName').setMaster('local')
# # Развертывание среды Spark с указанными настройками
# sc = pyspark.SparkContext(conf=conf)
# # Запуск Spark-сессии
# spark = SparkSession(sc)
from pyspark.sql import SparkSession
spark = SparkSession.builder.master('local[*]').getOrCreate()
import pandas as pd
import numpy as np
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data[:,:4]
y = iris.target
df = pd.DataFrame(X,columns=iris.feature_names)
df['target'] = y
df.columns = ['sepal_length','sepal_width','petal_length','petal_width','target']
df['name_iris'] = df['target'].apply(lambda _:iris.target_names[_])
print(df.head())
print('---------------------------------------')
print(df.info())
print('---------------------------------------')
print(df.name_iris.value_counts(normalize=True))
df.to_csv('data.csv', index=False)
df = spark.read.csv('data.csv',inferSchema=True,header=True)
df.show(5)
df.printSchema()
from pyspark.ml.feature import VectorAssembler
df_assembler = VectorAssembler(inputCols=['sepal_length','sepal_width','petal_length','petal_width'],outputCol='features')
df = df_assembler.transform(df)
df.select(['features','target']).show(5,False)
model_df = df.select(['features','target'])
model_df_2_class = model_df.filter(model_df.target.isin(0,1))
training_df, test_df = model_df.randomSplit([0.75,0.25])
training_df_2_class, test_df_2_class = model_df_2_class.randomSplit([0.75,0.25])<jupyter_output><empty_output><jupyter_text>GBT-алгоритм GBT (Gradient Boost Tree) – это алгоритм машинного обучения, использующийся для задач классификации и регрессии, который строит модель предсказания величины в форме ансамбля слабых предсказывающих моделей, в частности деревьев решений.<jupyter_code>from pyspark.ml.classification import GBTClassifier
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
gbt = GBTClassifier(labelCol='target',featuresCol='features', maxDepth=10)
model_gbt = gbt.fit(training_df_2_class)
predictions_gbt = model_gbt.transform(test_df_2_class)
predictions_gbt.show(5)
evaluator = MulticlassClassificationEvaluator(
                                            labelCol="target", predictionCol="prediction", metricName="accuracy")
accuracy_gbt = evaluator.evaluate(predictions_gbt)
print("Test Error = %g" % (1.0 - accuracy_gbt))<jupyter_output>Test Error = 0<jupyter_text>Алгоритм One-vs-Rest Алгоритм «Один против всех» (One vs all или One vs Rest) – это модель, которая предоставляет путь решения бинарной классификации из нескольких возможных решений. В течение обучения модель проходит через последовательность бинарных классификаторов (по одному бинарному классификатору для каждого возможного выхода), тренируя каждый их них отвечать на отдельный классификационный вопрос.<jupyter_code>from pyspark.ml.classification import LogisticRegression, OneVsRest
lr = LogisticRegression(maxIter=10, tol=1E-6, fitIntercept=True)
ovr = OneVsRest(classifier=lr,labelCol='target',featuresCol='features')
model_ovr = ovr.fit(training_df)
predictions_ovr = model_ovr.transform(test_df)
evaluator = MulticlassClassificationEvaluator(
                                            labelCol="target", predictionCol="prediction", metricName="accuracy")
accuracy_ovr = evaluator.evaluate(predictions_ovr)
print("Test Error = %g" % (1.0 - accuracy_ovr))<jupyter_output>Test Error = 0.0625<jupyter_text>Алгоритм случайного леса Случайный лес (random forest) – это алгоритм машинного обучения, который заключается в использовании ансамбля (совокупности) деревьев решений (decision trees). Ключевая идея заключается в том, что качество классификации в случайном лесу повышается за счет большого количества ансамблей деревьев решений. Классификация проводится путем голосования деревьев, где каждое дерево относит классифицируемый объект к одному из классов. Побеждает тот класс, за который проголосовало наибольшее число деревьев. Оптимальное число деревьев подбирается таким образом, чтобы минимизировать ошибку классификации на тестовой выборке.<jupyter_code>from pyspark.ml.evaluation import RegressionEvaluator
from pyspark.ml.regression import RandomForestRegressor
rf = RandomForestRegressor(featuresCol="features", labelCol='target', numTrees=10)
model_rf = rf.fit(training_df)
predictions_rf = model_rf.transform(test_df)
evaluator = RegressionEvaluator(
                                labelCol="target", predictionCol="prediction", metricName="rmse")
rmse_rf = evaluator.evaluate(predictions_rf)
print("Root Mean Squared Error (RMSE) on test data = %g" % rmse_rf)<jupyter_output>Root Mean Squared Error (RMSE) on test data = 0.177658<jupyter_text>Метод опорных векторов Метод опорных векторов (support vector machine, SVM) — алгоритм классификации, в основе которого лежит определяемая разделяющая гиперплоскость (линия, прямая, многомерные плоскости). Другими словами, при заданных тренировочных данных алгоритм находит такую гиперплоскость, которая разделяет данные, принадлежащие разным классам, самым оптимальным способом. В двухмерном пространстве гиперплоскостью служит прямая линия.<jupyter_code>from pyspark.ml.classification import LinearSVC
from pyspark.ml.evaluation import BinaryClassificationEvaluator
lsvc = LinearSVC(labelCol="target", regParam=0.1)
model_lsvc = lsvc.fit(training_df_2_class)
print("Coefficients:", model_lsvc.coefficients)
print("Intercept:", model_lsvc.intercept)
predictions_lsvc = model_lsvc.transform(test_df_2_class)
evaluator = BinaryClassificationEvaluator(labelCol="target")
accuracy_lsvc = evaluator.evaluate(predictions_lsvc)
print(f"Test Error =", (1.0 - accuracy_lsvc))<jupyter_output>Test Error = 0.0<jupyter_text>Наивный байесовский классификатор Наивный байесовский классификатор (Naive Bayes) — это алгоритм машинного обучения, предназначенный для многоклассовой классификации данных с независимыми признаками. За один проход вычисляется условная вероятность каждого признака, затем применяется теорема Байеса для нахождения распределения вероятности наблюдений. Полиномиальный байесовский классификаторБернуллевский байесовский классификаторДополняющий байесовский классификаторГауссовский байесовский классификатор<jupyter_code>from pyspark.ml.classification import NaiveBayes
nb = NaiveBayes(modelType="multinomial",labelCol='target')
model_nb = nb.fit(training_df)
predictions_nb = model_nb.transform(test_df)
predictions_nb.show(5)
evaluator = MulticlassClassificationEvaluator(
    labelCol="target", 
    predictionCol="prediction",
    metricName="accuracy"
)
accuracy_nb = evaluator.evaluate(predictions_nb)
print(f"Test Error =", (1.0 - accuracy_nb))<jupyter_output>Test Error = 0.0625<jupyter_text>Градиентный бустинг Градиентный бустинг, он же Gradient Boosting, Gradient Boosted-Tree, более правильно будет назвать ансамбль деревьев решений, обученный с использованием градиентного бустинга.Градиентный бустинг представляет собой ансамбль деревьев решений. В основе данного алгоритма лежит итеративное обучение деревьев решений с целью минимизировать функцию потерь. Благодаря особенностям деревьев решений градиентный бустинг способен работать с категориальными признаками , справляться с нелинейностями.В Spark Ml градиентный бустинг поддерживает бинарную классификацию и регрессию с использованием как непрерывных признаков, так и категориальных. Gradient-Boosted Trees не поддерживает многоклассовую классификацию. Если вам она нужна, то используйте случайный лес (Random Forest). В Spark Ml для градиентного бустинга предусмотрены три функции потерь: для классификации - Логистическая потеря (log loss) и для регрессии - Квадратическая ошибка и Абсолютная ошибка.<jupyter_code>from pyspark.ml.classification import GBTClassifier
from pyspark.ml.regression import GBTRegressor<jupyter_output><empty_output><jupyter_text>Деревья решений Деревья решений (Decision trees) являются одним из самых популярных алгоритмов машинного обучения и используются для задач классификации (бинарной и многоклассовой) и регрессии. Деревья решений простоты, понятны, они хорошо обрабатывают категориальные значения, а также могут находить нелинейные связи.   Логистическая регрессия<jupyter_code>from pyspark.ml.classification import LogisticRegression
lr = LogisticRegression(maxIter=10, regParam=0.3, elasticNetParam=0.8, labelCol='target')
model_lr = lr.fit(training_df)
print("Coefficients: \n" + str(model_lr.coefficientMatrix))
print("Intercept: " + str(model_lr.interceptVector))
predictions_lr = model_lr.transform(test_df)
evaluator = MulticlassClassificationEvaluator(
    labelCol="target", 
    predictionCol="prediction",
    metricName="accuracy"
)
accuracy_lr = evaluator.evaluate(predictions_lr)
print(f"Test Error =", (1.0 - accuracy_lr))<jupyter_output>Test Error = 0.0
{'fraction_non_alphanumeric': 0.09283673917820259, 'fraction_numerical': 0.008239947264337508, 'mean_word_length': 6.833907056798623, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 27, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '160949', 'license': 'MIT', 'n_tokens_mistral': 3284, 'n_tokens_neox': 3667, 'n_words': 699, 'path': 'ml/google_colab_spark_ml_all_algorithms.ipynb', 'repo_name': 'GrishenkovP/Spark', 'size': '9102'}