Imbalanced-Learn module in Python - GeeksforGeeks

11 Dec, 2020
Imbalanced-Learn is a Python module that helps in balancing the datasets which are highly skewed or biased towards some classes. Thus, it helps in resampling the classes which are otherwise oversampled or undesampled. If there is a greater imbalance ratio, the output is biased to the class which has a higher number of examples. The following dependencies need to be installed to use imbalanced-learn:
scipy(>=0.19.1)
numpy(>=1.13.3)
scikit-learn(>=0.23)
joblib(>=0.11)
keras 2 (optional)
tensorflow (optional)
To install imbalanced-learn just type in :
pip install imbalanced-learn
The resampling of data is done in 2 parts: 
Estimator: It implements a fit method which is derived from scikit-learn. The data and targets are both in the form of a 2D array
estimator = obj.fit(data, targets)
Resampler: The fit_resample method resample the data and targets into a dictionary with a key-value pair of data_resampled and targets_resampled.
data_resampled, targets_resampled = obj.fit_resample(data, targets)
The Imbalanced Learn module has different algorithms for oversampling and undersampling:
We will use the built-in dataset called the make_classification dataset which return 
x: a matrix of n_samples*n_features and 
y: an array of integer labels.
Click dataset to get the dataset used.
Python3
# import required modulesfrom sklearn.datasets import make_classification  # define datasetx, y = make_classification(n_samples=10000,                            weights=[0.99],                            flip_y=0)print('x:\n', X)print('y:\n', y)
Output:
Below are some programs in which depict how to apply oversampling and undersampling to the dataset:
Random Over Sampler: It is a naive method where classes that have low examples are generated and randomly resampled.
Syntax:
from imblearn.over_sampling import RandomOverSampler
Parameters(optional): sampling_strategy=’auto’, return_indices=False, random_state=None, ratio=None
Implementation:oversample = RandomOverSampler(sampling_strategy=’minority’)X_oversample,Y_oversample=oversample.fit_resample(X,Y)
Return Type:a matrix with the shape of n_samples*n_features
Example:
Python3
# import required modulesfrom sklearn.datasets import make_classificationfrom imblearn.over_sampling import RandomOverSampler  # define datasetx, 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 labelsprint('x_over:\n', x_over)print('y_over:\n', y_over)
Output:
 SMOTE, ADASYN: Synthetic Minority Oversampling Technique (SMOTE)  and the Adaptive Synthetic (ADASYN) are 2 methods used in oversampling. These also generate low examples but ADASYN takes into account the density of distribution to distribute the data points evenly.
Syntax:
from imblearn.over_sampling import SMOTE, ADASYN
Parameters(optional):*, sampling_strategy=’auto’, random_state=None, n_neighbors=5, n_jobs=None
Implementation:smote = SMOTE(ratio=’minority’)X_smote,Y_smote=smote.fit_resample(X,Y)
Return Type:a matrix with the shape of n_samples*n_features
Example:
Python3
# import required modulesfrom sklearn.datasets import make_classificationfrom imblearn.over_sampling import SMOTE  # define datasetx, 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 labelsprint('x_smote:\n', x_smote)print('y_smote:\n', y_smote)
Output:
Edited Nearest Neighbours: This algorithm removes any sample which has labels different from those of its adjoining classes.
Syntax:
from imblearn.under_sampling import EditedNearestNeighbours
Parameters(optional): sampling_strategy=’auto’, return_indices=False, random_state=None, n_neighbors=3, kind_sel=’all’, n_jobs=1, ratio=None
Implementation:en = EditedNearestNeighbours()X_en,Y_en=en.fit_resample(X, y)
Return Type:a matrix with the shape of n_samples*n_features
Example:
Python3
# import required modulesfrom sklearn.datasets import make_classificationfrom imblearn.under_sampling import EditedNearestNeighbours  # define datasetx, 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 labelsprint('x_en:\n', x_en)print('y_en:\n', y_en)
Output:
Random Under Sampler: It involves sampling any random class with or without any replacement.
Syntax:
from imblearn.under_sampling import RandomUnderSamplerParameters(optional): sampling_strategy=’auto’, return_indices=False, random_state=None, replacement=False, ratio=None
Implementation:undersample = RandomUnderSampler()X_under, y_under = undersample.fit_resample(X, y)
Return Type: a matrix with the shape of n_samples*n_features
Example:
Python3
# import required modulesfrom sklearn.datasets import make_classificationfrom imblearn.under_sampling import RandomUnderSampler  # define datasetx, 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 labelsprint('x_under:\n', x_under)print('y_under:\n', y_under)
Output:
python-modules
Python
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Python OOPs Concepts
How to Install PIP on Windows ?
Bar Plot in Matplotlib
Defaultdict in Python
Python Classes and Objects
Deque in Python
Check if element exists in list in Python
How to drop one or multiple columns in Pandas Dataframe
Python - Ways to remove duplicates from list
Class method vs Static method in Python