Résumé du réglage des hyperparamètres d'apprentissage automatique (PySpark ML)

Une tâche importante en ML est la sélection de modèles ou l'utilisation de données pour trouver le meilleur modèle ou les meilleurs paramètres pour une tâche donnée. C'est ce qu'on appelle également le réglage. Vous pouvez régler un seul estimateur, tel que LogisticRegression, ou un pipeline entier comprenant plusieurs algorithmes, caractérisations et autres étapes. Les utilisateurs peuvent régler l'ensemble du pipeline en même temps, plutôt que de régler chaque élément du pipeline individuellement.

Une tâche importante en ML est la sélection de modèles ou l'utilisation de données pour trouver le meilleur modèle ou les meilleurs paramètres pour une tâche donnée. C'est ce qu'on appelle également le réglage. Vous pouvez régler un seul estimateur (tel que LogisticRegression) ou un pipeline entier comprenant plusieurs algorithmes, caractérisations et autres étapes. Les utilisateurs peuvent régler l'ensemble du pipeline en même temps, plutôt que de régler chaque élément du pipeline individuellement.

MLlib prend en charge la sélection de modèles à l'aide d'outils tels que CrossValidator et TrainValidationSplit. Ces outils nécessitent les éléments suivants :

• Estimateur : l'algorithme ou le pipeline à régler
• Un ensemble de paramètres : un ensemble de paramètres sélectionnables, parfois appelé "grille de paramètres" de la recherche
• Évaluateur : ajustement métrique Performance du modèle sur données de test

Voici comment fonctionnent ces outils de sélection de modèles :

• Ils divisent les données d'entrée en ensembles de données d'entraînement et de test distincts.
• Pour chaque paire (formation, test), ils parcourent la collection ParamMap :

Pour chaque ParamMap​, utilisez ces paramètres pour ajuster l'estimateur​, obtenez le modèle ajusté​ et utilisez l'évaluateur​ pour évaluer les performances de le Modèle.

• Ils choisissent le modèle à générer par l'ensemble de paramètres le plus performant.

Pour aider à construire la grille paramétrique, les utilisateurs peuvent utiliser ParamGridBuilder. Par défaut, les jeux de paramètres de la grille de paramètres sont calculés en série. L'évaluation des paramètres peut être effectuée en parallèle en définissant le degré de parallélisme sur 2 ou plus (une valeur de 1 sera en série) avant d'exécuter la sélection de modèle avec CrossValidator ou TrainValidationSplit. La valeur du parallélisme doit être choisie avec soin pour maximiser le parallélisme sans dépasser les ressources du cluster ; des valeurs plus élevées n'améliorent pas nécessairement les performances. De manière générale, une valeur supérieure à 10 devrait suffire pour la plupart des clusters.

Cross Validation

CrossValidator Cross Validator divise d'abord l'ensemble de données en un ensemble d'ensembles de données pliés qui sont utilisés comme ensembles de données de formation et de test distincts. Par exemple, lorsque k = 3 fois, CrossValidator générera 3 paires d'ensembles de données (formation, test), chaque paire d'ensembles de données utilisant 2/3 des données pour la formation et 1/3 des données pour les tests. Pour évaluer un ParamMap spécifique, CrossValidator calcule la métrique d'évaluation moyenne en ajustant 3 modèles produits par Estimator sur 3 paires d'ensembles de données différentes (entraînement, test).

Après avoir déterminé le meilleur ParamMap, CrossValidator réassocie enfin l'estimateur en utilisant le meilleur ParamMap et l'ensemble des données.

from pyspark.ml import Pipeline
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.evaluation import BinaryClassificationEvaluator
from pyspark.ml.feature import HashingTF, Tokenizer
from pyspark.ml.tuning import CrossValidator, ParamGridBuilder

# 准备训练文件，并做好标签。
training = spark.createDataFrame([
(0, "a b c d e spark", 1.0),
(1, "b d", 0.0),
(2, "spark f g h", 1.0),
(3, "hadoop mapreduce", 0.0),
(4, "b spark who", 1.0),
(5, "g d a y", 0.0),
(6, "spark fly", 1.0),
(7, "was mapreduce", 0.0),
(8, "e spark program", 1.0),
(9, "a e c l", 0.0),
(10, "spark compile", 1.0),
(11, "hadoop software", 0.0)
], ["id", "text", "label"])

# 配置一个ML管道，它由树stages组成:tokenizer、hashingTF和lr。
tokenizer = Tokenizer(inputCol="text", outputCol="words")
hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol="features")
lr = LogisticRegression(maxIter=10)
pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])

# 我们现在将Pipeline作为一个Estimator，将其包装在CrossValidator实例中。
# 这将允许我们共同选择所有管道阶段的参数。
# 交叉验证器需要一个Estimator、一组Estimator ParamMaps和一个Evaluator。
# 我们使用ParamGridBuilder来构造一个用于搜索的参数网格。
# hashingTF.numFeatures 的3个值, lr.regParam的2个值，
# 这个网格将有3 x 2 = 6的参数设置供CrossValidator选择。

 
paramGrid = ParamGridBuilder() 
.addGrid(hashingTF.numFeatures, [10, 100, 1000]) 
.addGrid(lr.regParam, [0.1, 0.01]) 
.build()

crossval = CrossValidator(estimator=pipeline,
estimatorParamMaps=paramGrid,
evaluator=BinaryClassificationEvaluator(),
numFolds=2)# 使用3+ folds

# 运行交叉验证，并选择最佳参数集。
cvModel = crossval.fit(training)

# 准备测试未标注的文件
test = spark.createDataFrame([
(4, "spark i j k"),
(5, "l m n"),
(6, "mapreduce spark"),
(7, "apache hadoop")
], ["id", "text"])

# 对测试文档进行预测, cvModel使用发现的最佳模型(lrModel)。
prediction = cvModel.transform(test)
selected = prediction.select("id", "text", "probability", "prediction")
for row in selected.collect():
print(row)

Train Validation Split

En plus de CrossValidator, Spark fournit également TrainValidationSplit pour le réglage des hyperparamètres. TrainValidationSplit ne calcule chaque combinaison de paramètres qu'une seule fois, contre k fois dans le cas de CrossValidator . Par conséquent, elle est moins coûteuse, mais elle ne produit pas de résultats fiables lorsque l’ensemble de données d’entraînement n’est pas suffisamment volumineux.

Contrairement à CrossValidator, TrainValidationSplit crée une seule paire d'ensembles de données (entraînement, test). Il utilise le paramètre trainRatio pour diviser l'ensemble de données en ces deux parties. Par exemple, lorsque trainRatio = 0,75, TrainValidationSplit générera une paire d'ensembles de données d'entraînement et de test avec 75 % des données utilisées pour la formation et 25 % pour la validation.

Comme CrossValidator, TrainValidationSplit utilise en fin de compte le meilleur ParamMap et l'estimateur correspondant pour l'ensemble de données.

from pyspark.ml.evaluation import RegressionEvaluator
from pyspark.ml.regression import LinearRegression
from pyspark.ml.tuning import ParamGridBuilder, TrainValidationSplit

# Prepare training and test data.
data = spark.read.format("libsvm")
.load("data/mllib/sample_linear_regression_data.txt")
train, test = data.randomSplit([0.9, 0.1], seed=12345)

lr = LinearRegression(maxIter=10)

# 我们使用ParamGridBuilder来构造一个用于搜索的参数网格。
# TrainValidationSplit将尝试所有值的组合，并使用评估器确定最佳模型。
paramGrid = ParamGridBuilder()
.addGrid(lr.regParam, [0.1, 0.01]) 
.addGrid(lr.fitIntercept, [False, True])
.addGrid(lr.elasticNetParam, [0.0, 0.5, 1.0])
.build()

# 在这种情况下，估计器是简单的线性回归。
# TrainValidationSplit需要一个Estimator、一组Estimator ParamMaps 和一个 Evaluator。
tvs = TrainValidationSplit(estimator=lr,
 estimatorParamMaps=paramGrid,
 evaluator=RegressionEvaluator(),
 # 80%的数据将用于培训，20%用于验证。
 trainRatio=0.8)

# 运行TrainValidationSplit，并选择最佳参数集。
model = tvs.fit(train)

# 对测试数据进行预测。模型是参数组合后性能最好的模型。
model.transform(test)
.select("features", "label", "prediction")
.show()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!