Python: prétraitement en machine learning: gestion des données manquantes / aberrantes / déséquilibrées
Traitement des valeurs manquantes
Mécanisme des valeurs manquantes
Dans le prétraitement de l'apprentissage automatique, il peut être nécessaire de traiter des données contenant des valeurs manquantes, comme indiqué ci-dessous.
Si vous ne répondez pas correctement aux valeurs manquantes dans ces données, les problèmes suivants se produiront.
1, impossible d'obtenir des informations statistiques telles que la valeur moyenne et l'écart type Il n'est pas possible de calculer la moyenne ou l'écart type des valeurs d'évaluation des six personnes en utilisant les données qui incluent les valeurs manquantes. Cela rend difficile la réalisation de diverses analyses.
- Si vous supprimez simplement les données contenant des valeurs manquantes, les données seront biaisées. Si vous supprimez les données qui contiennent même un NaN des données précédentes, le nombre de données sera de deux. Dans ce cas, certaines données seront gaspillées et les données restantes peuvent être biaisées. Par conséquent, vous ne pourrez peut-être pas obtenir les informations que vous souhaitiez initialement connaître par l'analyse des données.
Pour ces raisons, il est nécessaire de traiter les valeurs manquantes de manière appropriée, mais afin de les traiter de manière appropriée, il est nécessaire de confirmer le mécanisme par lequel les valeurs manquantes se produisent.
Il existe les trois modèles suivants pour le mécanisme par lequel les valeurs manquantes se produisent.
MCAR Abréviation de Missing Completely At Random, lorsque la probabilité de manquer une valeur de données n'est pas pertinente pour toutes les données.
Expliquer avec l'exemple de données ci-dessus, par exemple, lorsque l'élément manquant est causé par un défaut dans le fichier qui enregistre le résultat du questionnaire, quels que soient l'âge, le sexe ou l'évaluation, ou le résultat du questionnaire manuscrit. Par exemple, lorsque le papier disparaît accidentellement en raison du frottement pendant le transport.
MAR Abréviation de manquant au hasard, lorsque certaines données sont observées, la probabilité qu'un élément soit manquant ne peut être estimée qu'à partir des éléments de données observés autres que l'élément manquant.
Cette définition abstraite est difficile à comprendre, mais si vous expliquez avec l'exemple de données ci-dessus, par exemple, si le sexe est une femme, la probabilité de répondre à l'âge dans le questionnaire tombe à un certain niveau, et s'il s'agit d'un homme, elle est différente de la femme. C'est une situation où vous répondez à l'âge avec la probabilité de. Aussi, pour être un MAR, il est nécessaire de supposer que l'âge lui-même n'affecte pas la carence en âge dans cette situation. Dans ce cas, s'il existe des données sur le sexe, il existe une certaine probabilité que l'âge soit perdu au hasard dans cette condition.
NMAR Abréviation de Ne pas manquer au hasard, lorsque la probabilité qu'un élément soit manquant dépend de l'élément lui-même et que le taux de manquant de l'élément manquant ne peut pas être estimé à partir d'éléments de données autres que cet élément.
Expliquer avec l'exemple de données ci-dessus, plus vous vieillissez, moins vous répondez sur l'âge, et de plus, si vous êtes un homme ou une femme n'affecte pas votre déficit en âge, et vous ne pouvez pas prédire à partir de la valeur du sexe. S'il y a une perte due à NMAR, il peut ne pas être possible de la résoudre par la méthode de substitution décrite plus loin, il est donc nécessaire de considérer le rappel des données.
Comment gérer les valeurs manquantes
Nous avons constaté qu'il existe trois mécanismes par lesquels les valeurs manquantes se produisent: MCAR, MAR et NMAR.
Maintenant, je vais vous expliquer comment traiter les défauts qui se produisent dans chaque mécanisme.
MCAR Dans le cas de MCAR, les valeurs manquantes sont générées de manière aléatoire, donc même si vous effectuez une suppression par liste (une méthode pour supprimer toutes les lignes de données contenant des valeurs manquantes) introduite dans le cours de nettoyage des données, les données seront supprimées. Il n'y a pas de parti pris. Cependant, il est également possible de compléter les valeurs manquantes à l'aide de la méthode de substitution décrite plus loin, par exemple lorsque le nombre d'éléments de données devient extrêmement petit par suppression.
MAR Dans le cas de MAR, si les données contenant des valeurs manquantes sont supprimées, les données seront biaisées. Par exemple, si une personne de sexe féminin a tendance à ne pas répondre à l'âge et que les données contenant la valeur manquante de l'âge sont supprimées, le résultat de l'analyse des données reflètera fortement le contenu de la réponse masculine. Je vais finir. Dans ce cas, envisagez de compléter la valeur manquante avec une méthode de substitution (expliquée plus loin) qui prédit la valeur vraie qui devrait être incluse dans la valeur manquante des données observées.
NMAR Dans le cas de NMAR, la suppression de données contenant des valeurs manquantes entraîne un biais dans les données, et comme l'élément de données manquant lui-même affecte la valeur manquante, la valeur manquante est différente des autres éléments de données observés. Ne peut pas être prédit. Par conséquent, vous devriez essentiellement envisager de vous souvenir des données.
Méthode de substitution des valeurs manquantes
Il existe deux méthodes principales pour attribuer des valeurs manquantes.
Méthode de substitution unique
Il s'agit d'une méthode qui utilise la méthode de substitution de valeur moyenne (voir le nettoyage des données), la méthode de substitution de régression probabiliste, la méthode hot deck, etc. pour compléter les valeurs manquantes et créer un seul ensemble de données complet.
Méthode d'affectation multiple
Un ensemble est un état dans lequel les valeurs manquantes sont prédites et complétées à partir des données observées. Créez plusieurs (c'est-à-dire plusieurs) ensembles de ceci et construisez un modèle analytique pour chaque ensemble C'est la dernière méthode pour intégrer les modèles construits individuellement.
Visualisation des valeurs manquantes
Lorsque vous envisagez de traiter les valeurs manquantes, vous devez d'abord savoir s'il y a des valeurs manquantes dans vos données.
Pour ça,
pandas est nul()Comment vérifier facilement en utilisant
Il existe une méthode pour visualiser et saisir la valeur manquante comme le package missingno.
Lorsque vous utilisez isnull () avec des données contenant des valeurs manquantes telles que celles introduites précédemment,
Par exemple
import pandas as pd
data = pd.read_csv('./8000_data_preprocessing_data/missing_data_3_1_3.csv')
data.isnull().sum()
Si vous exécutez la méthode isnull () de dataFrame en combinaison avec la méthode sum () qui calcule la valeur totale de chaque colonne, vous obtiendrez le résultat suivant et vous pourrez voir combien de valeurs manquantes se trouvent dans quelle colonne. Je vais.
#Résultat de sortie
rate 1
age 2
sex 2
dtype: int64
Avec missingno, vous pouvez facilement visualiser l'état général des valeurs manquantes. Si vous spécifiez le DataFrame des pandas à la fonction de matrice de missingno comme suit,
import missingno as msno
%matplotlib inline
data = pd.read_csv('./8000_data_preprocessing_data/missing_data_3_1_3.csv')
msno.matrix(data)
Où la partie blanche de l'image a une valeur manquante Sur le côté droit de l'image, le nombre d'éléments de données non manquants contenus dans cette ligne est affiché dans un graphique linéaire vertical.
Des nombres affichés sur le graphique de ligne de pliage Le numéro de gauche est la ligne avec le plus Les chiffres de droite correspondent au nombre d'éléments de données non manquants dans la ligne avec le moins de pertes. Dans le cas des données affichées dans l'image, le nombre d'éléments de données non manquants dans la ligne avec le plus manquant est "3". Par conséquent, vous pouvez voir qu'une ligne manque au plus l'un des quatre éléments de données. Vous obtiendrez l'image suivante.
Méthode de substitution unique (méthode hot deck)
La méthode de substitution unique est utilisée correctement selon l'objectif suivant.
1, lorsque seule la valeur moyenne des éléments de données manquants doit être connue
Dans ce cas, il est introduit dans le nettoyage des données Utilisez la méthode de substitution de valeur moyenne. Mais dans ce cas Plus il y a de données ayant une valeur moyenne, plus la distribution des éléments de données cibles est petite. Non disponible si vous souhaitez prendre en compte la variance ou l'erreur pour l'analyse.
2, si vous souhaitez prendre en compte la variance des éléments de données manquants dans votre analyse de données Dans ce cas, utilisez une méthode de substitution de régression probabiliste ou autre pour inclure le terme d'erreur en tenant compte de la variance de la valeur de substitution.
3, lorsqu'il y a beaucoup de données qualitatives et qu'il est difficile de calculer la valeur de substitution de manière paramétrique en raison de la régression, etc. Dans ce cas, une méthode non paramétrique appelée méthode hot deck (sans aucune hypothèse sur les paramètres) est utilisée. Utilisation. Dans la méthode hot deck, la valeur manquante de la ligne de données (appelée destinataire) contenant la valeur manquante est calculée. Complétez avec la valeur d'une autre ligne de données (appelée le donneur) qui a la valeur de cet élément de données manquant.
Lors de la recherche de donateurs pour compléter un destinataire, la proximité des données est déterminée par les voisins les plus proches. Utilisez la valeur d'un donateur proche.
ici
knnimpute
knnimpute.knn_impute_few_observed(matrix, missing_mask, k)Une fonction
J'expliquerai la méthode d'affectation unique par la méthode hot deck utilisée.
Les principaux arguments de la fonction knn_impute_few_observed (matrix, missing_mask, k) sont Il y en a trois ci-dessous. Voir la docstring sur la page officielle pour plus d'informations.
matrice: c'est le np de numpy.Spécifiez les données de type de matrice.
missing_mask:Il s'agit de données matricielles montrant où dans la matrice les valeurs manquantes sont contenues dans le type booléen. Doit avoir la même forme que l'argument matrice.
k :C'est KNN(Apprendre avec un enseignant(Classification)référence)Représente un point proche à prendre en compte.
Flux de la méthode d'affectation multiple
Dans la plupart des cas, après avoir rempli les valeurs manquantes dans les données avec la méthode de substitution, ce que vous voulez faire à la fin est Je pense que c'est une estimation de paramètre du modèle analytique utilisant l'ensemble des données, y compris les valeurs complétées.
Par exemple, dans le cas d'un modèle de régression, le coefficient de régression est prédit. Même avec d'autres modèles d'apprentissage automatique, vous souhaitez estimer certains paramètres.
Lors de l'utilisation de la méthode d'affectation unique, les valeurs manquantes sont littéralement incorporées à une seule valeur. Vous pouvez ensuite utiliser les données complétées pour créer un modèle analytique. De là, vous pourrez estimer les valeurs des paramètres du modèle analytique.
Cependant, la valeur complétée par la méthode de substitution unique est la valeur prédite, et il devrait y avoir une incertitude (c'est-à-dire l'erreur de la valeur prédite). Si vous prédisez les paramètres du modèle analytique sans en tenir compte Le résultat ne reflète pas l'incertitude d'origine de ce paramètre Une analyse insuffisante ou des conclusions trompeuses peuvent se produire.
Dans la méthode d'affectation multiple, la complétion des données est effectuée plusieurs fois pour résoudre ce problème. Créez plusieurs jeux de données et estimez les paramètres du modèle analytique séparément pour les multiples jeux de données Enfin, combinez les résultats en un seul.
Le flux d'analyse de la méthode d'affectation multiple lorsque trois ensembles de données sont créés en complétant trois fois est illustré ci-dessous.
Méthode d'affectation multiple (MICE)
Effectuons en fait la méthode d'affectation multiple avec un exemple de modèle de régression multiple linéaire.
Comme données incluant les valeurs manquantes, utilisez les données suivantes visualisées dans «Visualisation des valeurs manquantes».
Ces données sont en dessous du prix de la maison et des éléments liés au prix (distance de la gare, âge, taille (㎡)) Il y a quatre données.
Pour utiliser la méthode d'affectation multiple
Des modèles de statistiques
MICE(Multiple imputation by Chained Equations)Est pratique à utiliser.
Dans cet exercice, nous allons prédire le prix par régression multiple linéaire à partir des données de distance de la gare, d'âge et de taille.
Lors de l'écriture de ce modèle de régression multiple linéaire dans statsmodels, utilisez le nom de colonne du DataFrame Écrivez comme suit dans une chaîne de caractères.
'price ~ distance + age + m2'
Pour expliquer brièvement comment écrire ce modèle, ici la variable objective est le prix. Il existe trois variables explicatives: la distance, l'âge et le m2.
Les variables explicatives sont des modèles liés linéairement avec +. Vous n'avez pas besoin d'inclure les coefficients lors de l'écriture du modèle. Entre la variable objective et la variable explicative, ~ est décrit, et le prix est prédit par les trois variables à droite de ~. Pour plus de détails sur la façon d'écrire un modèle dans statsmodels, consultez le site officiel de statsmodels.
Dans MICE de statsmodels, les fonctions sont exécutées dans l'ordre suivant pour exécuter la méthode d'affectation multiple.
Dans le cas d'un modèle de régression multiple tel que «y ~ x1 + x2 + x3 + x4», l'exemple de code qui exécute l'ordre ci-dessus est le suivant.
imp_data = mice.MICEData(data)
formula = 'y ~ x1 + x2 + x3 + x4'
model = mice.MICE(formula, sm.OLS, imp_data)
results = model.fit(10, 10)
print(results.summary())
Les détails sont comme ça.
imp_data = mice.MICEData(data)
# 1,Souris un objet MICEData pour gérer des données complémentaires.MICEData(data)Créé avec une fonction
formula = 'y ~ x1 + x2 + x3 + x4'
# 2,Créer une formule pour le modèle linéaire(Le prix que j'ai expliqué plus tôt~ distance + age +Expression comme m2)
model = mice.MICE(formula, sm.OLS, imp_data)
# 3,mice.MICE(formula, optimizer, imp_data)Modèle analytique avec fonction(Objet MICE)Créer
# (Ici, puisqu'il s'agit d'une régression multiple, sm pour l'optimiseur.Utiliser OLS)
results = model.fit(10, 10) #Traitement complémentaire 10 fois,Nombre d'ensembles de données 10
# 4,Ajustement de l'objet MICE(n_burnin, n_imputation)En utilisant la méthode,
#Résultats en optimisant le modèle analytique des données(Objet MICEResults)Avoir
# (Le premier argument de la méthode fit est le nombre de fois que le processus est répété pour un achèvement, et le deuxième argument est le nombre d'ensembles de données à créer par achèvement.)
print(results.summary())
# 5,Récapitulatif du contenu de résultat optimisé de l'objet MICEResult()Confirmer avec la méthode
L'échantillon résultant ressemble à ceci:
Results: MICE
=================================================================
Method: MICE Sample size: 1000
Model: OLS Scale 1.00
Dependent variable: y Num. imputations 10
-----------------------------------------------------------------
Coef. Std.Err. t P>|t| [0.025 0.975] FMI
-----------------------------------------------------------------
Intercept -0.0234 0.0318 -0.7345 0.4626 -0.0858 0.0390 0.0128
x1 1.0305 0.0578 17.8342 0.0000 0.9172 1.1437 0.0309
x2 -0.0134 0.0162 -0.8282 0.4076 -0.0451 0.0183 0.0236
x3 -1.0260 0.0328 -31.2706 0.0000 -1.0903 -0.9617 0.0169
x4 -0.0253 0.0336 -0.7520 0.4521 -0.0911 0.0406 0.0269
=================================================================
Le résultat final est un paramètre estimé en intégrant plusieurs jeux de données complémentaires. Cet exemple donne les résultats de la corrélation des poids x1, x2, x3 et x4 avec y.
Détection des valeurs aberrantes
Problèmes causés par des valeurs aberrantes
Les valeurs aberrantes sont des données qui s'écartent considérablement des autres données. Si les valeurs aberrantes sont mélangées, les problèmes suivants se produiront.
- Le résultat de l'analyse est différent du résultat original
- Au cours du processus d'apprentissage du modèle d'apprentissage automatique, l'influence des valeurs aberrantes apparaîtra, ce qui rendra difficile la poursuite de l'apprentissage.
Cette section décrit comment détecter et exclure les valeurs aberrantes.
Visualisation des valeurs aberrantes
Il est facile de voir s'il existe des valeurs aberrantes en effectuant d'abord une simple visualisation des données.
Pour cette visualisation
Vous pouvez utiliser le box plot seaborn.
boxplot est une fonction qui dessine un soi-disant diagramme de moustaches de boîte, comme le montre la figure suivante. La valeur aberrante est affichée avec une marque de diamant.
Les principaux arguments de la fonction boxplot sont:
Dans le cas de la figure précédente, il est précisé comme suit.
import pandas as pd
import seaborn as sns
data = pd.read_csv('outlier_322.csv')
sns.boxplot(y=data['height'])
Si les données sont bidimensionnelles
L'utilisation d'un tracé conjoint permet de voir facilement s'il existe des valeurs aberrantes.
jointplot n'a pas de fonction pour afficher les valeurs aberrantes avec une marque en losange. Vérifiez visuellement tout ce qui semble être en panne. Les principaux arguments de la fonction jointplot sont:
Voici un script qui affiche un tracé conjoint sur un jeu de données iris bien connu:
import pandas as pd
import seaborn as sns
#Lire les données d'iris
iris = sns.load_dataset("iris")
sns.jointplot('sepal_width', 'petal_length', data=iris)
Détection des valeurs aberrantes par LOF
Quelles données sont les valeurs aberrantes afin d'exclure la valeur aberrante Il doit être détecté selon une certaine norme. Il existe différentes méthodes de détection.
Tout d'abord, nous allons introduire LOF (Local Outlier Factor), qui détecte les valeurs aberrantes en fonction de la densité des données.
LOF a les caractéristiques suivantes.
- Considérez que le nombre de points de données à proximité est une valeur aberrante.
- Estimer la densité des données en utilisant k points voisins
- Un point où la densité ci-dessus est relativement faible avec l'environnement est considéré comme une valeur aberrante.
Le jugement des valeurs aberrantes par LOF est scikit-Vous pouvez facilement le faire en utilisant la fonction d'apprentissage.
Dans le LOF de scikit-learn, utilisez d'abord la fonction LocalOutlierFactor. Créez un modèle de classification avec des paramètres.
Le paramètre spécifie principalement le nombre de points de voisinage à utiliser (n_neighbors). (Consultez la documentation officielle pour les paramètres détaillés). Décrivez comme suit.
clf = LocalOutlierFactor(n_neighbors=20)
prochain
#Du modèle
fit_predict(data)
#La méthode entraîne les données pour détecter les valeurs aberrantes.
Vous pouvez directement passer un pandas DataFrame aux données d'argument.
predictions = clf.fit_predict(data)
array([ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1,
1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
-1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
La valeur est -1 pour la ligne de données considérée comme une valeur aberrante et 1 pour la ligne de données considérée comme une valeur normale.
En utilisant ce résultat, si vous spécifiez les données comme suit Vous pouvez obtenir les lignes considérées comme des valeurs aberrantes dans les données d'origine.
data[predictions == -1]
La figure suivante représente les données d'iris prédites comme étant une valeur aberrante à k = 20. La valeur de retour de la méthode fit_predict () sera un tableau comme celui ci-dessous.
Cliquez ici pour des exemples d'utilisation
import numpy as np
import pandas as pd
from sklearn.neighbors import LocalOutlierFactor
np.random.seed(0)
data = pd.read_csv('./8000_data_preprocessing_data/outlier_ex.csv')
clf = LocalOutlierFactor(n_neighbors=20)
predictions = clf.fit_predict(data)
data[predictions == -1]
Détection des valeurs aberrantes par isolationForest
LOF était une méthode qui utilisait la densité des points de données pour le jugement. Ici, comme une autre méthode
Isolation Forest ()J'aimerais présenter_______
Isolation Forest présente les caractéristiques suivantes.
- Aucun coût pour calculer ces indicateurs car cela ne dépend pas de la distance ou de la densité
- Calcul compliqué et économie de mémoire
- Calculs faciles à mettre à l'échelle même pour les données volumineuses
Dans l'exemple de la détection des valeurs aberrantes de l'iris, l'algorithme peut être brièvement expliqué comme suit.
- Diviser les données de façon aléatoire par élément de données spécifique (ici, près de 2,1 sur l'axe des y)
- Divisez aléatoirement les données (ici, environ 2,7 sur l'axe des x) avec une donnée différente de 1.
-
Les données qui ne peuvent plus être divisées (point rouge en bas à gauche de la figure) peuvent être créées en deux divisions, alors enregistrez la profondeur comme 2.
-
Répétez 1-3 pour calculer la profondeur moyenne de chaque point
Ensuite, plus il y a de valeurs aberrantes, plus la profondeur moyenne est petite (il y a une forte possibilité qu'elle puisse être facilement séparée des autres points). Les points de données avec une faible profondeur peuvent être considérés comme des valeurs aberrantes.
Isolation Forest peut également utiliser scikit-learn pour prédire les valeurs aberrantes, similaire à LOF.
Tout d'abord, créez un modèle de classification avec la fonction IsolationForest ().
clf = IsolationForest()
Ensuite, entraînez les données avec la méthode fit () du modèle.
clf.fit(data)
Après cela, la méthode prédire () est utilisée pour déterminer et prédire les valeurs aberrantes.
predictions = clf.predict(data)
En tant que valeur de retour de la méthode predict (), le tableau suivant est obtenu.
array([ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1,
1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
1, 1, 1, 1, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
-1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
La valeur est -1 pour la ligne de données considérée comme une valeur aberrante et 1 pour la ligne de données considérée comme une valeur normale.
En utilisant ce résultat, vous pouvez spécifier les données comme suit pour obtenir les lignes considérées comme des valeurs aberrantes dans les données d'origine.
data[predictions == -1]
les données d'iris devraient être une valeur aberrante par Isolation Forest L'intrigue ressemble à la figure suivante.
import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest
np.random.seed(0)
data = pd.read_csv('./8000_data_preprocessing_data/outlier_ex.csv')
#Exemple d'utilisation.
clf = IsolationForest()
clf.fit(data)
predictions = clf.predict(data)
data[predictions == -1]
Ajustement des données de déséquilibre
Problèmes causés par des données déséquilibrées
Les données déséquilibrées se produisent lorsqu'il existe des éléments de données catégoriques ou binaires au lieu de types numériques. Certaines valeurs de cet élément sont soit trop élevées, soit trop faibles, ce qui entraîne un déséquilibre dans la fréquence des valeurs de données.
Plus précisément, lorsqu'un élément de données spécifique a des valeurs de 0 et 1, 990 sur 1000 données sont 1 Lorsque 10 cas sont comme 0.
Dans un tel cas, si vous prédisez la valeur de l'élément de données, si vous le prédisez toujours comme 1, il y a 99% de chances que la prédiction soit correcte. Cependant, si la prédiction d'un cas zéro était une exigence importante, ce modèle de prédiction n'a aucun sens.
Par conséquent, avant d'entraîner les données déséquilibrées dans le modèle d'apprentissage automatique, Pour éviter les fausses prédictions causées par des données déséquilibrées Les données peuvent être ajustées.
La première chose à faire avant d'ajuster les données déséquilibrées est de vérifier l'existence de données déséquilibrées.
Pour ça
valeur pandas_counts()Il est facile d'utiliser la méthode.
Si vous souhaitez vérifier la fréquence des données de survie du célèbre Titanic, écrivez comme suit.
titanic['survived'].value_counts()
Ensuite, vous pouvez connaître la fréquence de chaque valeur comme suit.
0 549
1 342
Name: survived, dtype: int64
Il existe trois méthodes de réglage comme suit.
Suréchantillonnage
Une méthode de duplication et d'augmentation des données contenant des valeurs peu fréquentes parmi les observations que vous souhaitez prédire. Dans l'exemple précédent, les données contenant 0, qui n'est que de 1%, sont dupliquées et augmentées.
Sous-échantillonnage
Comment réduire les données contenant des valeurs fréquentes dans les cas que vous souhaitez prédire. Dans l'exemple précédent, nous réduirons les données contenant 1, soit 99%.
Une méthode qui combine le suréchantillonnage et le sous-échantillonnage
Dans l'exemple précédent, nous allons réduire les données contenant 1 et augmenter les données contenant 0.
Sous-échantillonnage des données déséquilibrées
Dans le cas où vous souhaitez prédire quel type de données sera 1 lorsque vous achetez une voiture et 0 lorsque vous ne l'avez pas achetée. Ce sera comme suit.
Exemple positif:Ligne de données avec achat 1 dans les données d'entraînement
Exemple négatif:Lignes de données qui n'ont pas été achetées et sont 0
Dans les données d'entraînement, ces exemples positifs et négatifs sont déséquilibrés. Lorsqu'il y a peu de cas positifs et très majoritairement de cas négatifs (lorsqu'il y a beaucoup de données non achetées) En supprimant et en réduisant au hasard cet exemple négatif, il est possible d'atténuer le déséquilibre des données.
Sous-échantillonnage.
Pour sous-échantillonner des données déséquilibrées
imbalanced-C'est facile à utiliser pour apprendre.
Il existe plusieurs méthodes, mais ici
Envisagez d'utiliser RandomUnderSampler pour supprimer des données de manière aléatoire.
Si vous souhaitez réduire le rapport de RandomUnderSampler Spécifiez la majorité (fréquemment) dans le ratio d'argument comme indiqué dans l'exemple de code suivant.
Pour le ratio, vous pouvez également spécifier d'autres ratios fins au format dictionnaire. Veuillez vous référer au document officiel pour les valeurs qui peuvent être spécifiées pour le ratio.
rus = RandomUnderSampler(ratio = 'majority')
Après avoir créé RandomUnderSampler, Passez les données divisées en variable objective et en variable explicative à l'avance comme argument comme suit Obtenez les données après le sous-échantillonnage.
X_resampled, y_resampled = rus.fit_sample(X, y)
import numpy as np
import pandas as pd
from imblearn.under_sampling import RandomUnderSampler
np.random.seed(0)
data = pd.read_csv('./8000_data_preprocessing_data/imbalanced_ex.csv')
y = data['purchased']
X = data.loc[:, ['income', 'age', 'num_of_children']]
#Cliquez ici pour des exemples d'utilisation
rus = RandomUnderSampler(ratio = 'majority')
X_resampled, y_resampled = rus.fit_sample(X, y)
(X_resampled, y_resampled)
Suréchantillonnage des données équilibrées
En sous-échantillonnage, le déséquilibre a été résolu en réduisant le grand nombre de cas négatifs. Inversement, éliminer les déséquilibres en augmentant le nombre d'exemples positifs est appelé suréchantillonnage.
Le sous-échantillonnage a uniquement supprimé les données existantes Le suréchantillonnage nécessite quelques étapes pour augmenter les données.
Il existe plusieurs façons d'augmenter cela, mais le moyen le plus simple de l'augmenter Il existe un moyen de gonfler au hasard les données existantes.
Pour gonfler les données au hasard
imbalanced-Learn utilise RandomOverSampler.
RandomOverSampler C'est presque la même chose que la façon d'utiliser Random UnderSampler utilisé pour le sous-échantillonnage. Utilisez-le comme suit.
La seule différence est que cela augmente le nombre d'exemples peu fréquents.
au ratio'minority'Est de préciser.
Comme avec RandomUnderSampler, vous pouvez spécifier un rapport fin pour le rapport. Veuillez vous référer au document officiel pour le modèle détaillé de spécification des arguments.
ros = RandomOverSampler(ratio = 'minority')
X_resampled, y_resampled = ros.fit_sample(X, y)
import numpy as np
import pandas as pd
from imblearn.over_sampling import RandomOverSampler
np.random.seed(0)
data = pd.read_csv('./8000_data_preprocessing_data/imbalanced_ex.csv')
y = data['purchased']
X = data.loc[:, ['income', 'age', 'num_of_children']]
#Cliquez ici pour des exemples d'utilisation
ros = RandomOverSampler(ratio = 'minority')
X_resampled, y_resampled = ros.fit_sample(X, y)
(X_resampled, y_resampled)
Réglage des données déséquilibrées avec SMOTE-ENN
Suréchantillonnage et sous-échantillonnage lors de l'ajustement de données déséquilibrées Il existe également une méthode pour utiliser les deux, pas une seule.
imbalanced-En apprendre
Pour le suréchantillonnage
SMOTE(Synthetic minority over-sampling technique)
Pour sous-échantillonnage
ENN(Edited Nearest Neighbours)utilisation
SMOTE-Vous pouvez utiliser ENN.
SMOTE a les caractéristiques suivantes.
- Pour un exemple positif, au lieu de gonfler tel quel, utilisez la méthode du plus proche voisin (kNN) pour estimer la valeur des données à augmenter à partir des points voisins et effectuer un suréchantillonnage.
ENN a les caractéristiques suivantes.
- Lors de la suppression d'exemples négatifs, tenez compte des points à proximité de chaque point de données et du sous-échantillon afin qu'il y ait moins de données à proximité.
Comment utiliser SMOTE-ENN Similaire à RandomUnderSampler et RandomOverSampler
La différence est que vous spécifiez les valeurs de k_neighbours utilisées dans SMOTE et n_neighbors utilisées dans ENN. Pour d'autres explications détaillées sur les paramètres optionnels, veuillez consulter la documentation officielle. L'exemple de code est le suivant.
sm_enn = SMOTEENN(smote=SMOTE(k_neighbors=3), enn=EditedNearestNeighbours(n_neighbors=3))
X_resampled, y_resampled = sm_enn.fit_sample(X, y)
import numpy as np
import pandas as pd
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import EditedNearestNeighbours
from imblearn.combine import SMOTEENN
np.random.seed(0)
data = pd.read_csv('./8000_data_preprocessing_data/imbalanced_ex.csv')
y = data['purchased']
X = data.loc[:, ['income', 'age', 'num_of_children']]
#L'utilisation de base est comme ça
sm_enn = SMOTEENN(smote=SMOTE(k_neighbors=3), enn=EditedNearestNeighbours(n_neighbors=3))
X_resampled, y_resampled = sm_enn.fit_sample(X, y)
(X_resampled, y_resampled)
Recommended Posts