Módulo de aprendizaje desequilibrado en Python

Imbalanced-Learn es un módulo de Python que ayuda a equilibrar los conjuntos de datos que están muy sesgados o sesgados hacia algunas clases. Por lo tanto, ayuda a volver a muestrear las clases que, de lo contrario, están sobremuestreadas o no muestreadas. Si hay una mayor relación de desequilibrio, la salida está sesgada a la clase que tiene un mayor número de ejemplos. Es necesario instalar las siguientes dependencias para usar el aprendizaje desequilibrado:

• scipy(>=0.19.1)
• numpy(>=1.13.3)
• scikit-aprender(>=0.23)
• joblib(>=0.11)
• Keras 2 (opcional)
• tensorflow (opcional)

Para instalar el aprendizaje desequilibrado simplemente escriba:

pip install imbalanced-learn

El remuestreo de datos se realiza en 2 partes: 

Estimador: implementa un método de ajuste que se deriva de scikit-learn . Los datos y los objetivos tienen la forma de una array 2D

estimator = obj.fit(data, targets)

Remuestreador : el método fit_resample vuelve a muestrear los datos y objetivos en un diccionario con un par clave-valor de data_resampled y targets_resampled .

data_resampled, targets_resampled = obj.fit_resample(data, targets)

El módulo Imbalanced Learn tiene diferentes algoritmos para el sobremuestreo y el submuestreo:

Usaremos el conjunto de datos incorporado llamado conjunto de datos make_classification que devuelve 

• x: una array de n_samples*n_features y 
• y: una array de etiquetas de enteros.

Haga clic en conjunto de datos para obtener el conjunto de datos utilizado.

# import required modules
from sklearn.datasets import make_classification
  
# define dataset
x, y = make_classification(n_samples=10000, 
                           weights=[0.99], 
                           flip_y=0)
print('x:\n', X)
print('y:\n', y)

Producción:

A continuación se muestran algunos programas en los que se muestra cómo aplicar el sobremuestreo y el submuestreo al conjunto de datos:

sobremuestreo

• Random Over Sampler: es un método ingenuo en el que las clases que tienen pocos ejemplos se generan y se vuelven a muestrear aleatoriamente.

Sintaxis:

de imblearn.over_sampling importar RandomOverSampler

Parámetros (opcional): sampling_strategy=’auto’, return_indices=False, random_state=Ninguno, ratio=Ninguno

Implementación:
oversample = RandomOverSampler(sampling_strategy=’minority’)
X_oversample,Y_oversample=oversample.fit_resample(X,Y)

Tipo de devolución: una array con la forma de n_samples*n_features

Ejemplo:

# import required modules
from sklearn.datasets import make_classification
from imblearn.over_sampling import RandomOverSampler
  
# define dataset
x, y = make_classification(n_samples=10000, 
                           weights=[0.99], 
                           flip_y=0)
  
oversample = RandomOverSampler(sampling_strategy='minority')
x_over, y_over = oversample.fit_resample(x, y)
  
# print the features and the labels
print('x_over:\n', x_over)
print('y_over:\n', y_over)

Producción:

•  SMOTE, ADASYN: La Técnica de Sobremuestreo Minoritario Sintético (SMOTE) y el Sintético Adaptativo (ADASYN) son 2 métodos utilizados en el sobremuestreo. Estos también generan ejemplos bajos, pero ADASYN tiene en cuenta la densidad de distribución para distribuir los puntos de datos de manera uniforme.

Sintaxis:

de imblearn.over_sampling importar SMOTE, ADASYN

Parámetros (opcional): *, sampling_strategy=’auto’, random_state=Ninguno, n_neighbors=5, n_jobs=Ninguno

Implementación:
smote = SMOTE(ratio=’minoría’)
X_smote,Y_smote=smote.fit_resample(X,Y)

Tipo de devolución: una array con la forma de n_samples*n_features

Ejemplo:

# import required modules
from sklearn.datasets import make_classification
from imblearn.over_sampling import SMOTE
  
# define dataset
x, y = make_classification(n_samples=10000, weights=[0.99], flip_y=0)
smote = SMOTE()
x_smote, y_smote = smote.fit_resample(x, y)
  
# print the features and the labels
print('x_smote:\n', x_smote)
print('y_smote:\n', y_smote)

Producción:

submuestreo

• Vecinos más cercanos editados: este algoritmo elimina cualquier muestra que tenga etiquetas diferentes a las de sus clases adyacentes.

Sintaxis:

de imblearn.under_sampling import EditedNearestNeighbours

Parámetros (opcional): sampling_strategy=’auto’, return_indices=False, random_state=Ninguno, n_neighbors=3, kind_sel=’all’, n_jobs=1, ratio=Ninguno

Implementación:
en = EditedNearestNeighbours()
X_en,Y_en=en.fit_resample(X, y)

Tipo de devolución: una array con la forma de n_samples*n_features

Ejemplo:

# import required modules
from sklearn.datasets import make_classification
from imblearn.under_sampling import EditedNearestNeighbours
  
# define dataset
x, y = make_classification(n_samples=10000, weights=[0.99], flip_y=0)
en = EditedNearestNeighbours()
x_en, y_en = en.fit_resample(x, y)
  
# print the features and the labels
print('x_en:\n', x_en)
print('y_en:\n', y_en)

Producción:

• Random Under Sampler: implica muestrear cualquier clase aleatoria con o sin reemplazo.

Sintaxis:

de imblearn.under_sampling import
Parámetros RandomUnderSampler (opcional): sampling_strategy=’auto’, return_indices=False, random_state=Ninguno, replace=False, ratio=Ninguno

Implementación:
undersample = RandomUnderSampler()
X_under, y_under = undersample.fit_resample(X, y)

Tipo de devolución: una array con la forma de n_samples*n_features

Ejemplo:

# import required modules
from sklearn.datasets import make_classification
from imblearn.under_sampling import RandomUnderSampler
  
# define dataset
x, y = make_classification(n_samples=10000, 
                           weights=[0.99], 
                           flip_y=0)
undersample = RandomUnderSampler()
x_under, y_under = undersample.fit_resample(x, y)
  
# print the features and the labels
print('x_under:\n', x_under)
print('y_under:\n', y_under)

Producción: