Dans ce guide, nous allons d'abord voir la démarche puis prédire l'AVC de chaque personne en analysant pas à pas les données.
Régression logistique
La régression logistique, également appelée « modèle Logit », est utilisée dans l'analyse prédictive pour les problèmes de classification. Il s'agit d'un modèle de Machine Learning qui ne fonctionne que sur la classification pour classer les classes (catégories). Par exemple, il y a deux catégories dans notre scénario (une personne affectée par un AVC et une personne qui n'est pas affectée par un AVC). Les meilleures applications du modèle sont la prédiction des maladies cardiaques, la prédiction du sexe, la prédiction de la durée de vie des cultures, etc.
Pas:
1. Collecte de données : Les données sont nécessaires pour effectuer des prévisions/analyses. Il peut être sous forme de CSV/XLSX, entre autres. Nous pouvons le charger dans l'environnement Spark (DataFrame) à l'aide de la méthode spark.read.csv().
2. Analyse des données : L'analyse des attributs/colonnes est appelée « analyse des données ». Les colonnes qui aident à prédire la classe sont appelées 'attributs indépendants'. La colonne qui aboutit à la prédiction est appelée 'attribut dépendant ou cible'. Dans ce scénario, nous pouvons utiliser la propriété columns pour afficher toutes les colonnes. La méthode distinct() est utilisée pour voir les valeurs uniques.
3. Prétraitement des données : Le filtrage des valeurs nulles/manquantes est appelé 'prétraitement'. Nous supprimons toutes les valeurs manquantes à cette étape. La machine ne connaît que le langage binaire. Ainsi, toutes les catégories de chaînes doivent être converties en valeurs catégorielles numériques. Dans PySpark, nous pouvons utiliser le 'StringIndexer' qui est la classe disponible dans le module pyspark.ml.feature pour convertir les catégories de chaînes en numériques. Il les convertit automatiquement en interne. Nous n'avons pas besoin de fournir les valeurs. Vous pouvez utiliser la syntaxe suivante :
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,sortieCol= 'Nouveau_nom_de_colonne' )
4. Assemblage de vecteur : Maintenant, vous avez les données que la machine peut comprendre. Dans cette étape, tous les attributs indépendants doivent être vectorisés dans une seule colonne. Cela peut être fait en utilisant la classe VectorAssembler. Il prend deux paramètres : Le premier paramètre est le inputCols qui prend une liste d'attributs indépendants. Le deuxième paramètre est le outputCol qui vectorise tous les inputCols dans cette variable.
assembleur=VectorAssembler(inputCols=[columns…],outputCol=vectorized_data)5. Transformation : Maintenant, préparez vos données en transformant les colonnes mises à jour (étape 3) à l'aide de la fonction transform().
assembleur.transform(inxed_data)
6. Préparation des données pour la formation et les tests : Dans cette étape, nous divisons les données en « formation » et « tests ». Ce sera mieux si nous divisons les 70 % de données pour former le modèle et les 30 % de données pour tester le modèle. Ceci peut être réalisé en utilisant la méthode randomSplit(). Il prend une liste qui contient deux valeurs flottantes : une pour le fractionnement du test et une autre pour le fractionnement du train.
train_data,test_data=final_data.select([ 'caractéristiques' ,colonne_cible]).randomSplit([0.70.0.30])7. Ajustement et évaluation du modèle : Il est temps d'ajuster le modèle de régression logistique. Le modèle de régression logistique est disponible dans le module pyspark.ml.classification. Il prend la colonne étiquette de classe/cible. Cela se traduit par des colonnes rawPrediction, probabilité et prédiction. Nos résultats sont stockés dans la colonne de prédiction.
# Ajustement du modèlelogistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# Évaluation du modèle
train_results=logistic_regression_model.evaluate(train_data).predictions
8. Précision et résultats : Il s'agit de la dernière étape où nous testons la précision du modèle à l'aide de toutes les techniques de test.
Regardons le projet suivant où nous prédisons si une personne est affectée par un AVC ou non en utilisant le modèle de régression logistique.
Prédiction d'AVC
9. Installez le module PySpark dans votre environnement. Voici la commande à installer :
pip installer pyspark 
10. Créons un PySpark DataFrame avec 10 enregistrements liés aux détails de l'AVC de 10 personnes. Pour la démonstration, nous créons un DataFrame sans CSV. Il y a 7 colonnes dans ce DataFrame. 'Gender', 'Glucose_level', 'married', 'age', 'heart_disease', 'hyper_tension' sont des attributs indépendants et 'Stroke' est l'étiquette de classe ou l'attribut dépendant. Cela signifie que l'AVC d'une personne dépend de ces attributs indépendants.
importer pysparkdepuis pyspark.sql importer SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'Indice Linux' ).getOrCreate()
stoke_data =[
{ 'Genre' : 'Femme' , 'âge' : cinquante , 'cardiopathie' : 'Oui' ,
'hypertension' : 'Oui' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 130 , 'Accident vasculaire cérébral' : 1 },
{ 'Genre' : 'Homme' , 'âge' : vingt , 'cardiopathie' : 'Non' ,
'hypertension' : 'Oui' , 'marié' : 'Non' , 'Niveau_de_glycémie' : 97 , 'Accident vasculaire cérébral' : 0 },
{ 'Genre' : 'Homme' , 'âge' : 12 , 'cardiopathie' : 'Non' ,
'hypertension' : 'Non' , 'marié' : 'Non' , 'Niveau_de_glycémie' : 98 , 'Accident vasculaire cérébral' : 0 },
{ 'Genre' : 'Femme' , 'âge' : 90 , 'cardiopathie' : 'Non' ,
'hypertension' : 'Non' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 170 , 'Accident vasculaire cérébral' : 1 },
{ 'Genre' : 'Homme' , 'âge' : 43 , 'cardiopathie' : 'Oui' ,
'hypertension' : 'Oui' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 150 , 'Accident vasculaire cérébral' : 1 },
{ 'Genre' : 'Femme' , 'âge' : vingt-et-un , 'cardiopathie' : 'Non' ,
'hypertension' : 'Non' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 110 , 'Accident vasculaire cérébral' : 0 },
{ 'Genre' : 'Femme' , 'âge' : cinquante , 'cardiopathie' : 'Oui' ,
'hypertension' : 'Non' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 100 , 'Accident vasculaire cérébral' : 0 },
{ 'Genre' : 'Homme' , 'âge' : 3. 4 , 'cardiopathie' : 'Non' ,
'hypertension' : 'Oui' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 190 , 'Accident vasculaire cérébral' : 1 },
{ 'Genre' : 'Homme' , 'âge' : dix , 'cardiopathie' : 'Non' ,
'hypertension' : 'Non' , 'marié' : 'Non' , 'Niveau_de_glycémie' : 90 , 'Accident vasculaire cérébral' : 0 },
{ 'Genre' : 'Femme' , 'âge' : 56 , 'cardiopathie' : 'Oui' ,
'hypertension' : 'Oui' , 'marié' : 'Oui' , 'Niveau_de_glycémie' : 145 , 'Accident vasculaire cérébral' : 1 }
]
# créer le dataframe à partir des données ci-dessus
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# Réel stoke_df
stroke_df.show()
Sortir:
11. Affichez les colonnes indépendantes à l'aide de la méthode select().
# Afficher les attributs indépendantsstroke_df.select(stroke_df[ 'Genre' ],stroke_df[ 'Niveau_de_glycémie' ],stroke_df[ 'marié' ],stroke_df[ 'âge' ],stroke_df[ 'cardiopathie' ],stroke_df[ 'hypertension' ]).montrer()
Sortir:
12. Affichez les valeurs uniques qui sont présentes dans l'attribut cible (Stroke).
# valeurs uniques d'attribut ciblestroke_df.select(stroke_df[ 'Accident vasculaire cérébral' ]).distinct().show()
Sortir:
13. Renvoyez le type de données de toutes les colonnes à l'aide de la fonction printSchema().
# Renvoie le type de données de toutes les colonnes.stroke_df.printSchema()
Sortir:
Nous pouvons voir que 4 colonnes sont de type chaîne. Convertissons-les en valeurs numériques catégorielles.
14. Convertissons les valeurs catégorielles de chaîne en valeurs catégorielles numériques à l'aide de StringIndexer dans les colonnes 'Gender', 'heart_disease', 'hyper_tension' et 'married' et écrivons-les dans les colonnes Categotical_Gender, Categotical_heart_disease, Categotical_hyper_tension et Categotical_married. Stockez les colonnes dans le DataFrame indexed_data à l'aide de la méthode fit().
à partir de pyspark.ml.feature importer StringIndexer# Convertissez les valeurs catégorielles de chaîne en valeurs catégorielles numériques dans la colonne 'Sexe'.
indexer_data=StringIndexer(inputCol= 'Genre' ,sortieCol= 'Categotical_Gender' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# Convertir les valeurs catégorielles de chaîne en valeurs catégorielles numériques dans la colonne 'heart_disease'.
indexer_data=StringIndexer(inputCol= 'cardiopathie' ,sortieCol= 'Categotical_heart_disease' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Convertir les valeurs catégorielles de chaîne en valeurs catégorielles numériques dans la colonne 'hyper_tension'.
indexer_data=StringIndexer(inputCol= 'hypertension' ,sortieCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Convertir les valeurs catégorielles de chaîne en valeurs catégorielles numériques dans la colonne 'marié'.
indexer_data=StringIndexer(inputCol= 'marié' ,sortieCol= 'Categotical_married' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Afficher la mise à jour
indexed_data.show()
Sortir:
15. Convertissez les colonnes indépendantes en un vecteur à l'aide de l'assembleur de vecteurs. Le nom du vecteur est 'fonctionnalités'.
à partir de pyspark.ml.feature importer VectorAssemblerassembleur= VecteurAssembleur(inputCols=[ 'Categotical_Gender' , 'Categotical_heart_disease' , 'Categotical_hyper_tension' , 'Categotical_married' , 'âge' ,
'Niveau_de_glycémie' ],sortieCol= 'caractéristiques' )
16. Transformez les données précédentes en un DataFrame final à l'aide de la fonction transform() et affichez-les à l'aide de la fonction show().
Sortir:
17. Préparez les données pour la formation et les tests en les divisant en 70-30. Les « caractéristiques » sont stockées dans le train_data et « Stroke » est stocké dans le test_data.
# Préparer les données pour la formation et les teststrain_data,test_data=final.select([ 'caractéristiques' , 'Accident vasculaire cérébral' ]).randomSplit([ 0,70 , 0,30 ])
18. Ajustez le modèle de régression logistique et évaluez-le.
à partir de pyspark.ml.classification importer LogisticRegression# Ajustement du modèle
logistique_regression_model=Régression Logistique(labelCol= 'Accident vasculaire cérébral' ).fit(train_data)
# Évaluation du modèle
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
Sortir:
19. Utilisez BinaryClassificationEvaluator pour vérifier la précision du modèle. Nous pouvons voir que notre modèle est précis à 100 %.
à partir de pyspark.ml.evaluation importer BinaryClassificationEvaluator# appeler le BinaryClassificationEvaluator
résultats = BinaryClassificationEvaluator(rawPredictionCol= 'prédiction' ,labelCol= 'Accident vasculaire cérébral' )
ROC_AUC = résultats.évaluer(train_results)
imprimer(ROC_AUC * 100 , '% Précision' )
Conclusion
Vous pouvez prédire le problème de classification des tuiles réelles à l'aide du modèle de régression logistique dans PySpark. La suppression des valeurs nulles/manquantes est importante car elles diminuent l'évaluation et la précision du modèle. Le prétraitement est une étape nécessaire avant d'adapter un modèle d'apprentissage automatique. Assurez-vous que vous effectuez cette étape correctement et avec précision.