[Kaggle] J'ai essayé le sous-échantillonnage en utilisant un apprentissage déséquilibré

0. Introduction

Les données sont souvent déséquilibrées lors de l'apprentissage avec un enseignant ... Je pense plutôt qu'il y a peu de cas où un montant important peut être garanti de manière équilibrée.

Cette fois, je vais vous présenter une bibliothèque appelée ** déséquilibré-learn ** qui peut être utile pour rééchantillonner des données déséquilibrées.

J'ai principalement évoqué les articles suivants.

La Documentation officielle est ici.

1. Installez déséquilibré-learn

Suivez Install and contribution pour installer.

pip install -U imbalanced-learn

Installez avec.

À propos, à partir de mars 2020, les conditions suivantes semblent exister pour les bibliothèques suivantes.

2. Préparez les pseudo données

Préparez les pseudo-données à utiliser cette fois. Si vous avez déjà des données, ignorez-les. J'utilise une fonction appelée make_classification.

In[1]


import pandas as pd
from sklearn.datasets import make_classification
df = make_classification(n_samples=5000, n_features=10, n_informative=2,
                           n_redundant=0, n_repeated=0, n_classes=3,
                           n_clusters_per_class=1, weights=[0.01, 0.05, 0.94],
                           class_sep=0.8, random_state=0)

Il y a deux valeurs de retour dans ce df sous forme de taple. df [0] contient ce que l'on appelle X, df [1] contient le soi-disant y. Par conséquent, stockez-le dans la trame de données par l'opération suivante.

In[2]


df_raw = pd.DataFrame(df[0], columns = ['var1', 'var2', 'var3', 'var4', 'var5', 'var6', 'var7', 'var8', 'var9', 'var10'])
df_raw['Class'] = df[1]
df_raw.head()

image.png

Divisez cela en X et y.

In[3]


X = df_raw.iloc[:, 0:10]
y = df_raw['Class']
y.value_counts()

Out[3]


2    4674
1     261
0      65
Name: Class, dtype: int64

Comme vous pouvez le voir, nous avons une très grande quantité de données pour l'étiquette 2. Ceci termine la préparation des pseudo-données.

3. Divisez les données avec train_test_split

Divisez la trame de données préparée précédemment à l'aide de train_test_split.

In[4]


from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 71, stratify=y)
y_train.value_counts()

Out[4]


2    3272
1     183
0      45
Name: Class, dtype: int64

Il s'agit du nombre de données pour chaque étiquette de données de train après division en train et test. Ici, ** l'extraction de stratification ** est effectuée en spécifiant y dans l'argument stratify de train_test_split. peut faire.

Statistics Web: Exemple de méthode d'extraction

4. Sous-échantillonner avec RandomUnderSampler

C'est finalement le sujet principal. Sous-échantillonner avec RandomUnderSampler. L'API est ici.

Décrit l'argument ** sampling_strategy **. Avec cet argument, vous pouvez déterminer le rapport de chaque classe lors de l'échantillonnage. Il semble que l'argument était ratio dans la version précédente, mais il a été changé de la version 0.6 à sampling_strategy.

Il est possible de donner à cet argument principalement le type float et dictionary.

Pour float, spécifiez une classe minoritaire ÷ classe majoritaire. Cependant, il n'est applicable que pour les problèmes à 2 étiquettes.

Pour le type de dictionnaire, transmettez la taille de l'échantillon de chaque classe comme suit.

In[5]


from imblearn.under_sampling import RandomUnderSampler

positive_count_train = y_train.value_counts()[0]
strategy = {0:positive_count_train, 1:positive_count_train*2, 2:positive_count_train*5}

rus = RandomUnderSampler(random_state=0, sampling_strategy = strategy)
X_resampled, y_resampled = rus.fit_resample(X_train, y_train)
y_resampled.value_counts()

Out[5]


Using TensorFlow backend.
2    225
1     90
0     45
Name: Class, dtype: int64

Vous avez maintenant sous-échantillonné.

6. Bonus

Comme c'est un gros problème, j'aimerais le classer par modèle.

In[6]


from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

model = LogisticRegression()
model.fit(X_resampled, y_resampled)
y_pred = model.predict(X_test)

print('Accuracy(test) : %.5f' %accuracy_score(y_test, y_pred))

Out[6]


Accuracy(test) : 0.97533

Sortons la matrice de confusion sous forme de carte thermique.

In[7]


from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

cm = confusion_matrix(y_test, y_pred)

sns.heatmap(cm)

image.png

La carte thermique était également difficile à voir car les données de test étaient déséquilibrées ...

7. Résumé

Cette fois, j'ai essayé le sous-échantillonnage.

En faisant des recherches sur diverses choses en écrivant cet article, j'ai constaté qu'il existe différentes méthodes de sous-échantillonnage et de suréchantillonnage.

** SMOTE ** semble intéressant, je vais donc l'étudier.

Nous sommes toujours à la recherche d'articles, de commentaires, etc.

Recommended Posts

[Kaggle] J'ai essayé le sous-échantillonnage en utilisant un apprentissage déséquilibré
[Kaggle] J'ai essayé l'apprentissage d'ensemble avec LightGBM
J'ai essayé d'utiliser paramétré
J'ai essayé d'utiliser argparse
J'ai essayé d'utiliser la mimesis
J'ai essayé d'utiliser aiomysql
J'ai essayé d'utiliser Summpy
J'ai essayé d'utiliser Pipenv
J'ai essayé d'utiliser matplotlib
J'ai essayé d'utiliser ESPCN
J'ai essayé d'utiliser openpyxl
J'ai essayé d'utiliser Ipython
J'ai essayé d'utiliser PyCaret
J'ai essayé d'utiliser cron
J'ai essayé d'utiliser ngrok
J'ai essayé d'utiliser face_recognition
J'ai essayé d'utiliser Jupyter
J'ai essayé d'utiliser doctest
J'ai essayé d'utiliser du folium
J'ai essayé d'utiliser jinja2
J'ai essayé d'utiliser du folium
J'ai essayé d'utiliser la fenêtre de temps
[J'ai essayé d'utiliser Pythonista 3] Introduction
J'ai essayé d'utiliser easydict (mémo).
J'ai essayé la reconnaissance faciale avec Face ++
J'ai essayé d'utiliser RandomForest
J'ai essayé d'utiliser BigQuery ML
J'ai essayé d'utiliser Amazon Glacier
J'ai essayé d'utiliser git inspector
J'ai essayé d'utiliser magenta / TensorFlow
J'ai essayé d'utiliser AWS Chalice
J'ai essayé d'utiliser l'émojinateur Slack
J'ai essayé d'utiliser Rotrics Dex Arm
J'ai essayé d'utiliser GrabCut d'OpenCV
J'ai essayé d'utiliser Thonny (Python / IDE)
J'ai essayé de communiquer avec le client serveur en utilisant tmux
J'ai essayé l'apprentissage par renforcement avec PyBrain
J'ai essayé d'utiliser le notebook jupyter d'une manière ou d'une autre
J'ai essayé de photographier une vague de tortue en utilisant OpenPose
J'ai essayé d'utiliser l'API checkio
J'ai essayé le traitement asynchrone en utilisant asyncio
J'ai essayé d'utiliser Amazon SQS avec django-celery
J'ai essayé d'utiliser Azure Speech to Text.
J'ai essayé de jouer au jeu ○ ✕ en utilisant TensorFlow
J'ai essayé d'utiliser l'API de données YOUTUBE V3
J'ai essayé d'utiliser du sélénium avec du chrome sans tête
J'ai essayé de dessiner une ligne en utilisant une tortue
J'ai essayé d'apprendre avec le Titanic de Kaggle (kaggle②)
J'ai essayé d'utiliser PyEZ et JSNAPy. Partie 2: J'ai essayé d'utiliser PyEZ
J'ai essayé d'utiliser l'optimisation bayésienne de Python
J'ai essayé de classer le texte en utilisant TensorFlow
J'ai essayé d'utiliser la recherche sélective comme R-CNN
J'ai essayé d'utiliser l'API UnityCloudBuild de Python
J'ai essayé d'utiliser Headless Chrome de Selenium
J'ai essayé d'utiliser pipenv, alors prenez note
[Visualisation] J'ai essayé d'utiliser Bokeh / plotly! 【mémorandum】
J'ai essayé d'utiliser l'API BigQuery Storage