Random Oversampling and Undersampling for Imbalanced Classification

Tweet Share Share

Last bijgewerkt op 5 januari 2021

Ibalanced datasets zijn datasets waarbij er een ernstige scheefheid is in de klassenverdeling, zoals 1:100 of 1:1000 voorbeelden in de minderheidsklasse ten opzichte van de meerderheidsklasse.

Deze vertekening in de trainingsdataset kan veel algoritmen voor machinaal leren beïnvloeden, waardoor sommige algoritmen de minderheidsklasse volledig negeren. Dit is een probleem omdat het typisch de minderheidsklasse is waarop voorspellingen het belangrijkst zijn.

Eén benadering om het probleem van klassenonevenwichtigheid aan te pakken, is het willekeurig opnieuw bemonsteren van de trainingsdataset. De twee belangrijkste benaderingen voor het willekeurig opnieuw bemonsteren van een onevenwichtige dataset zijn het verwijderen van voorbeelden uit de meerderheidsklasse, undersampling genoemd, en het dupliceren van voorbeelden uit de minderheidsklasse, oversampling genoemd.

In deze zelfstudiegids ontdekt u random oversampling en undersampling voor onevenwichtige classificatie

Na het voltooien van deze zelfstudiegids weet u:

  • Random resampling biedt een naïeve techniek voor het opnieuw in evenwicht brengen van de klassenverdeling voor een onevenwichtige dataset.
  • Random oversampling dupliceert voorbeelden uit de minderheidsklasse in de trainingsdataset en kan resulteren in overfitting voor sommige modellen.
  • Random undersampling verwijdert voorbeelden uit de meerderheidsklasse en kan resulteren in het verlies van informatie die van onschatbare waarde is voor een model.

Start je project met mijn nieuwe boek Ongebalanceerde classificatie met Python, inclusief stap-voor-stap tutorials en de Python broncodebestanden voor alle voorbeelden.

Let’s get started.

  • Bijgewerkt in jan/2021: Bijgewerkte links voor API-documentatie.
Random Oversampling and Undersampling for Imbalanced Classification

Random Oversampling and Undersampling for Imbalanced Classification
Foto door RichardBH, sommige rechten voorbehouden.

Tutorial Overview

Deze tutorial is onderverdeeld in vijf delen; deze zijn:

  1. Random Resampling Imbalanced Datasets
  2. Imbalanced-Learn Library
  3. Random Oversampling Imbalanced Datasets
  4. Random Undersampling Imbalanced Datasets
  5. Combining Random Oversampling and Undersampling

Random Resampling Imbalanced Datasets

Resampling houdt in dat een nieuwe getransformeerde versie van de trainingsdataset wordt gemaakt waarin de geselecteerde voorbeelden een andere klasseverdeling hebben.

Dit is een eenvoudige en effectieve strategie voor onevenwichtige classificatieproblemen.

Herbemonsteringsstrategieën toepassen om een evenwichtigere gegevensverdeling te verkrijgen, is een effectieve oplossing voor het onevenwichtigheidsprobleem

– A Survey of Predictive Modelling under Imbalanced Distributions, 2015.

De eenvoudigste strategie is om voorbeelden voor de getransformeerde dataset willekeurig te kiezen, random resampling genoemd.

Er zijn twee hoofdbenaderingen voor random resampling voor onevenwichtige classificatie; het zijn oversampling en undersampling.

  • Random Oversampling: Willekeurig dupliceren van voorbeelden in de minderheidsklasse.
  • Willekeurige Undersampling: Willekeurig voorbeelden uit de meerderheidsklasse verwijderen.

Random oversampling houdt in dat voorbeelden uit de minderheidsklasse willekeurig worden geselecteerd, met vervanging, en aan de trainingsdataset worden toegevoegd. Random undersampling houdt in dat voorbeelden uit de meerderheidsklasse willekeurig worden geselecteerd en uit de trainingsdataset worden verwijderd.

In de random undersampling worden de voorbeelden uit de meerderheidsklasse willekeurig verwijderd totdat een evenwichtiger verdeling is bereikt.

– Pagina 45, Imbalanced Learning: Foundations, Algorithms, and Applications, 2013

Beide benaderingen kunnen worden herhaald totdat de gewenste klassenverdeling in de trainingsdataset is bereikt, zoals een gelijke verdeling over de klassen.

Ze worden “naïeve resampling”-methoden genoemd omdat ze niets over de gegevens veronderstellen en er geen heuristieken worden gebruikt. Daardoor zijn ze eenvoudig te implementeren en snel uit te voeren, wat wenselijk is voor zeer grote en complexe datasets.

Beide technieken kunnen worden gebruikt voor classificatieproblemen van twee klassen (binair) en classificatieproblemen van meerdere klassen met een of meer meerderheids- of minderheidsklassen.

Belangrijk is dat de verandering in de klassenverdeling alleen wordt toegepast op de trainingsdataset. De bedoeling is de fit van de modellen te beïnvloeden. De resampling wordt niet toegepast op de test- of holdout-dataset die wordt gebruikt om de prestaties van een model te evalueren.

In het algemeen kunnen deze naïeve methoden effectief zijn, hoewel dat afhangt van de specifieke kenmerken van de betrokken dataset en modellen.

Laten we eens nader kijken naar elke methode en hoe ze in de praktijk kunnen worden gebruikt.

Imbalanced-Learn Library

In deze voorbeelden zullen we de implementaties gebruiken die worden geleverd door de imbalanced-learn Python-bibliotheek, die als volgt via pip kan worden geïnstalleerd:

1
sudo pip install imbalanced-learn

U kunt bevestigen dat de installatie geslaagd is door de versie van de geïnstalleerde bibliotheek af te drukken:

1
2
3

# controleer het versienummer
importeer imblearn
print(imblearn.__version__)

Het uitvoeren van het voorbeeld zal het versienummer van de geïnstalleerde bibliotheek afdrukken; bijvoorbeeld:

1
0.5.0

Wil je aan de slag met onbalansclassificatie?

Doe nu mee aan mijn gratis 7-daagse spoedcursus per e-mail (met voorbeeldcode).

Klik op aanmelden en ontvang ook een gratis PDF-ebookversie van de cursus.

Download uw GRATIS mini-cursus

Random Oversampling Onevenwichtige Datasets

Random oversampling houdt in dat voorbeelden uit de minderheidsklasse willekeurig worden gedupliceerd en aan de trainingsdataset worden toegevoegd.

Voorbeelden uit de trainingsdataset worden willekeurig geselecteerd met vervanging. Dit betekent dat voorbeelden uit de minderheidsklasse meerdere keren kunnen worden gekozen en toegevoegd aan de nieuwe “evenwichtigere” trainingsdataset; ze worden geselecteerd uit de oorspronkelijke trainingsdataset, toegevoegd aan de nieuwe trainingsdataset en vervolgens teruggestuurd of “vervangen” in de oorspronkelijke dataset, waardoor ze opnieuw kunnen worden geselecteerd.

Deze techniek kan effectief zijn voor die machine-learningalgoritmen die worden beïnvloed door een scheve verdeling en waarbij meerdere duplicaatvoorbeelden voor een bepaalde klasse de pasvorm van het model kunnen beïnvloeden. Dit kan algoritmen omvatten die iteratief coëfficiënten leren, zoals kunstmatige neurale netwerken die stochastische gradiëntafdaling gebruiken. Het kan ook van invloed zijn op modellen die een goede verdeling van de gegevens zoeken, zoals support vector machines en decision trees.

Het kan nuttig zijn om de verdeling van de doelklassen af te stemmen. In sommige gevallen kan het streven naar een evenwichtige verdeling voor een sterk onevenwichtige dataset ertoe leiden dat de betrokken algoritmen de minderheidsklasse overfitten, wat leidt tot een grotere generalisatiefout. Het effect kan een betere prestatie op de trainingsdataset zijn, maar een slechtere prestatie op de holdout- of testdataset.

… de random oversampling kan de kans op overfitting vergroten, aangezien er exacte kopieën van de voorbeelden van de minderheidsklasse worden gemaakt. Op die manier kan een symbolische classificeerder bijvoorbeeld regels opstellen die ogenschijnlijk nauwkeurig zijn, maar in werkelijkheid betrekking hebben op één gekopieerd voorbeeld.

– Blz. 83, Learning from Imbalanced Data Sets, 2018.

Om inzicht te krijgen in de impact van de methode, is het dus een goed idee om de prestaties op zowel de train- als de testdataset na het oversamplen te controleren en de resultaten te vergelijken met hetzelfde algoritme op de oorspronkelijke dataset.

De toename van het aantal voorbeelden voor de minderheidsklasse, vooral als de klassenscheefheid groot was, kan ook resulteren in een duidelijke toename van de computerkosten bij het aanpassen van het model, vooral omdat het model steeds weer dezelfde voorbeelden in de trainingsdataset te zien krijgt.

… bij random oversampling wordt een willekeurige reeks kopieën van voorbeelden uit de minderheidsklasse aan de gegevens toegevoegd. Dit kan de kans op overfitting vergroten, vooral bij hogere overbemonsteringspercentages. Bovendien kunnen de prestaties van de classificator afnemen en neemt de rekenintensiteit toe.

– A Survey of Predictive Modelling under Imbalanced Distributions, 2015.

Random oversampling kan worden geïmplementeerd met de klasse RandomOverSampler.

De klasse kan worden gedefinieerd en neemt een argument voor sampling_strategy dat kan worden ingesteld op “minority” om de minderheidsklasse automatisch in evenwicht te brengen met de meerderheidsklasse of -klassen.

Voorbeeld:

1
2
3

# definieer oversampling-strategie
oversample = RandomOverSampler(sampling_strategy=’minority’)

Dit betekent dat als de meerderheidsklasse 1000 voorbeelden zou hebben en de minderheidsklasse 100, deze strategie een oversampling van de minderheidsklasse zou uitvoeren, zodat deze 1000 voorbeelden heeft.

Een drijvende kommawaarde kan worden opgegeven om de verhouding aan te geven tussen de minderheidsklasse en de meerderheidsvoorbeelden in de getransformeerde dataset. Bijvoorbeeld:

1
2
3

# definieer oversampling-strategie
oversample = RandomOverSampler(sampling_strategy=0.5)

Dit zou ervoor zorgen dat de minderheidsklasse oversampled wordt om de helft van het aantal voorbeelden te hebben als de meerderheidsklasse, voor binaire classificatieproblemen. Dit betekent dat als de meerderheidsklasse 1000 voorbeelden had en de minderheidsklasse 100, de getransformeerde dataset 500 voorbeelden van de minderheidsklasse zou bevatten.

De klasse lijkt op een scikit-learn-transformatieobject in die zin dat het wordt gepast op een dataset en vervolgens wordt gebruikt om een nieuwe of getransformeerde dataset te genereren. In tegenstelling tot de scikit-learn transforms, zal het het aantal voorbeelden in de dataset veranderen, niet alleen de waarden (zoals een scaler) of het aantal kenmerken (zoals een projectie).

Het kan bijvoorbeeld in één stap worden aangepast en toegepast door de functie fit_sample() aan te roepen:

1
2
3

# fit en pas de transformatie toe
X_over, y_over = oversample.fit_resample(X, y)

We kunnen dit demonstreren aan de hand van een eenvoudig synthetisch binair classificatieprobleem met een klassenonevenwichtigheid van 1:100.

1
2
3

# definieer dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)

Het volledige voorbeeld van het definiëren van de dataset en het uitvoeren van willekeurige oversampling om de klassenverdeling in evenwicht te brengen, staat hieronder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# voorbeeld van willekeurige oversampling om de klassenverdeling in evenwicht te brengen
from collections import Counter
from sklearn.datasets import make_classification
from imblearn.over_sampling import RandomOverSampler
# definieer dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# vat de klassenverdeling samen
print(Counter(y))
# definieer oversampling-strategie
oversample = RandomOverSampler(sampling_strategy=’minority’)
# fit en pas de transformatie toe
X_over, y_over = oversample.fit_resample(X, y)
# vat de klasseverdeling samen
print(Counter(y_over))

Het uitvoeren van het voorbeeld creëert eerst de dataset en vat vervolgens de klassenverdeling samen. We zien dat er bijna 10.000 voorbeelden zijn in de meerderheidsklasse en 100 voorbeelden in de minderheidsklasse.

Daarna wordt de random oversample-transformatie gedefinieerd om de minderheidsklasse in evenwicht te brengen, en vervolgens aangepast en toegepast op de dataset. De klassenverdeling voor de getransformeerde dataset wordt gerapporteerd, waaruit blijkt dat de minderheidsklasse nu hetzelfde aantal voorbeelden heeft als de meerderheidsklasse.

1
2

Counter({0: 9900, 1: 100})
Counter({0: 9900, 1: 9900})

Deze transformatie kan worden gebruikt als onderdeel van een pijplijn om ervoor te zorgen dat deze alleen op de trainingsdataset wordt toegepast als onderdeel van elke splitsing in een k-voudige kruisvalidatie.

Een traditionele scikit-learn Pipeline kan niet worden gebruikt; in plaats daarvan kan een Pipeline uit de ongebalanceerde-learn-bibliotheek worden gebruikt. Bijvoorbeeld:

1
2
3
4

# pijplijn
stappen =
pijplijn = pijplijn(stappen=stappen)

Het onderstaande voorbeeld geeft een compleet voorbeeld van het evalueren van een beslisboom op een onevenwichtige dataset met een klasseverdeling van 1:100.

Het model wordt geëvalueerd met behulp van herhaalde 10-voudige kruisvalidatie met drie herhalingen, en de oversampling wordt binnen elke vouw afzonderlijk uitgevoerd op de trainingsdataset, zodat er geen gegevens weglekken, zoals het geval zou kunnen zijn als de oversampling vóór de kruisvalidatie werd uitgevoerd.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# voorbeeld van het evalueren van een beslisboom met random oversampling
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.tree import DecisionTreeClassifier
from imblearn.pipeline import Pipeline
from imblearn.over_sampling import RandomOverSampler
# define dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# definieer pijplijn
stappen =
pijplijn = pijplijn(stappen=stappen)
# evalueer pijplijn
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(pijplijn, X, y, scoring=’f1_micro’, cv=cv, n_jobs=-1)
score = gemiddelde(scores)
print(‘F1 Score: %.3f’ % score)

Het uitvoeren van het voorbeeld evalueert het beslisboommodel op de ongebalanceerde dataset met oversampling.

Het gekozen model en de resampling-configuratie zijn willekeurig, bedoeld om een sjabloon te bieden dat u kunt gebruiken om undersampling te testen met uw dataset en leeralgoritme, in plaats van de synthetische dataset optimaal op te lossen.

Note: uw resultaten kunnen afwijken door de stochastische aard van het algoritme of de evaluatieprocedure, of door verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.

De standaard oversampling strategie wordt gebruikt, die de minderheidsklassen in evenwicht brengt met de meerderheidsklasse. De F1-score, gemiddeld over elke vouw en elke herhaling, wordt gerapporteerd.

1
F1 Score: 0.990

Nu we bekend zijn met oversampling, laten we eens kijken naar undersampling.

Random Undersampling Ongebalanceerde Datasets

Random undersampling houdt in dat voorbeelden uit de meerderheidsklasse willekeurig worden geselecteerd om uit de trainingsdataset te verwijderen.

Dit heeft tot gevolg dat het aantal voorbeelden in de meerderheidsklasse in de getransformeerde versie van de trainingsdataset wordt verminderd. Dit proces kan worden herhaald totdat de gewenste klassenverdeling is bereikt, zoals een gelijk aantal voorbeelden voor elke klasse.

Deze aanpak kan meer geschikt zijn voor die datasets waar er een klassenonevenwichtigheid is, hoewel een voldoende aantal voorbeelden in de minderheidsklasse, zodat een bruikbaar model kan worden fit.

Een beperking van undersampling is dat voorbeelden uit de meerderheidsklasse worden verwijderd die nuttig, belangrijk of misschien cruciaal kunnen zijn voor het fitten van een robuuste beslissingsgrens. Aangezien voorbeelden willekeurig worden verwijderd, is er geen manier om “goede” of informatierijkere voorbeelden uit de meerderheidsklasse te detecteren of te behouden.

… bij willekeurige under-sampling (potentieel) worden enorme hoeveelheden gegevens verwijderd. Dit kan zeer problematisch zijn, aangezien het verlies van dergelijke gegevens het moeilijker kan maken om de beslissingsgrens tussen minderheids- en meerderheidsvoorbeelden te leren, waardoor de classificatie slechter wordt.

– Pagina 45, Imbalanced Learning: Foundations, Algorithms, and Applications, 2013

De random undersampling-techniek kan worden geïmplementeerd met behulp van de klasse RandomUnderSampler imbalanced-learn.

De klasse kan net zo worden gebruikt als de klasse RandomOverSampler in de vorige sectie, behalve dat de strategieën van invloed zijn op de meerderheidsklasse in plaats van de minderheidsklasse. Door bijvoorbeeld het argument voor de bemonsteringsstrategie op “majority” in te stellen, wordt de meerderheidsklasse, die wordt bepaald door de klasse met het grootste aantal voorbeelden, onderbemonsterd.

1
2
3

# definieer undersample-strategie
undersample = RandomUnderSampler(sampling_strategy=’majority’)

Een dataset met 1000 voorbeelden in de meerderheids- en 100 voorbeelden in de minderheidsklasse wordt bijvoorbeeld zodanig undersampled dat beide klassen 100 voorbeelden in de getransformeerde trainingsdataset zouden hebben.

We kunnen het argument sampling_strategy ook instellen op een drijvendekommawaarde die een percentage is ten opzichte van de minderheidsklasse, namelijk het aantal voorbeelden in de minderheidsklasse gedeeld door het aantal voorbeelden in de meerderheidsklasse. Bijvoorbeeld, als we sampling_strategy instellen op 0,5 in een ongebalanceerde dataset met 1000 voorbeelden in de meerderheidsklasse en 100 voorbeelden in de minderheidsklasse, dan zouden er 200 voorbeelden voor de meerderheidsklasse in de getransformeerde dataset zijn (of 100/200 = 0.5).

1
2
3

# definieer undersample-strategie
undersample = RandomUnderSampler(sampling_strategy=0.5)

Dit kan de voorkeur hebben om ervoor te zorgen dat de resulterende dataset groot genoeg is om een redelijk model te passen en dat niet te veel nuttige informatie van de meerderheidsklasse wordt weggegooid.

Bij random under-sampling kan worden geprobeerd een evenwichtige klassenverdeling te creëren door 90 gevallen uit de meerderheidsklasse willekeurig te selecteren en te verwijderen. De resulterende dataset zal dan uit 20 instanties bestaan: 10 (willekeurig overblijvende) gevallen uit de meerderheidsklasse en (de oorspronkelijke) 10 gevallen uit de minderheidsklasse.

– Pagina 45, Imbalanced Learning: Foundations, Algorithms, and Applications, 2013

De transformatie kan vervolgens in één stap worden aangepast en toegepast op een dataset door de functie fit_resample() op te roepen en de niet-getransformeerde dataset als argumenten door te geven.

1
2
3

# fit en pas de transformatie toe
X_over, y_over = undersample.fit_resample(X, y)

We kunnen dit demonstreren op een dataset met een klassenonevenwichtigheid van 1:100.

Het volledige voorbeeld staat hieronder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# voorbeeld van willekeurige undersampling om de klassenverdeling in evenwicht te brengen
from collections import Counter
from sklearn.datasets import make_classification
from imblearn.under_sampling import RandomUnderSampler
# definieer dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# vat de klassenverdeling samen
print(Counter(y))
# definieer undersample-strategie
undersample = RandomUnderSampler(sampling_strategy=’majority’)
# fit en pas de transformatie toe
X_over, y_over = undersample.fit_resample(X, y)
# vat de klasseverdeling samen
print(Counter(y_over))

Het uitvoeren van het voorbeeld creëert eerst de dataset en rapporteert de ongebalanceerde klassenverdeling.

De transformatie wordt fit en toegepast op de dataset en de nieuwe klassenverdeling wordt gerapporteerd. We kunnen zien dat de meerderheidsklasse is undersampled om hetzelfde aantal voorbeelden te hebben als de minderheidsklasse.

Oordelen en empirische resultaten zullen moeten worden gebruikt om te bepalen of een trainingsdataset met slechts 200 voorbeelden voldoende zou zijn om een model te trainen.

1
2

Counter({0: 9900, 1: 100})
Counter({0: 100, 1: 100})

Deze undersampling-transformatie kan ook worden gebruikt in een Pipeline, net als de oversampling-transformatie uit de vorige sectie.

Dit maakt het mogelijk de transformatie alleen toe te passen op de trainingsdataset met gebruikmaking van evaluatieschema’s zoals k-fold cross-validatie, waardoor wordt voorkomen dat gegevens weglekken bij de evaluatie van een model.

1
2
3
4

# definieer pijplijn
stappen =
pijplijn = pijplijn(stappen=stappen)

We kunnen een voorbeeld definiëren van het aanpassen van een beslisboom op een ongebalanceerde classificatiedataset met de undersampling-transformatie toegepast op de trainingsdataset op elke split van een herhaalde 10-voudige kruisvalidatie.

Het volledige voorbeeld staat hieronder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# voorbeeld van het evalueren van een beslisboom met willekeurige undersampling
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.tree import DecisionTreeClassifier
from imblearn.pipeline import Pipeline
from imblearn.under_sampling import RandomUnderSampler
# define dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# definieer pijplijn
stappen =
pijplijn = pijplijn(stappen=stappen)
# evalueer pijplijn
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(pijplijn, X, y, scoring=’f1_micro’, cv=cv, n_jobs=-1)
score = gemiddelde(scores)
print(‘F1 Score: %.3f’ % score)

Het uitvoeren van het voorbeeld evalueert het beslisboommodel op de ongebalanceerde dataset met undersampling.

Het gekozen model en de resampling-configuratie zijn willekeurig, bedoeld om een sjabloon te bieden dat u kunt gebruiken om undersampling te testen met uw dataset en leeralgoritme, in plaats van de synthetische dataset optimaal op te lossen.

Merk op: uw resultaten kunnen afwijken door de stochastische aard van het algoritme of de evaluatieprocedure, of door verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.

De standaard undersampling strategie wordt gebruikt, die de meerderheidsklassen in evenwicht brengt met de minderheidsklasse. De F1-score, gemiddeld over elke vouw en elke herhaling, wordt gerapporteerd.

1
F1 Score: 0.889

Combining Random Oversampling and Undersampling

Interessante resultaten kunnen worden bereikt door zowel random oversampling als undersampling te combineren.

Er kan bijvoorbeeld een bescheiden hoeveelheid oversampling worden toegepast op de minderheidsklasse om de bias naar deze voorbeelden te verbeteren, terwijl er ook een bescheiden hoeveelheid undersampling wordt toegepast op de meerderheidsklasse om de bias op die klasse te verminderen.

Dit kan resulteren in betere algemene prestaties in vergelijking met het uitvoeren van een of de andere technieken afzonderlijk.

Als we bijvoorbeeld een dataset hadden met een klassenverdeling van 1:100, zouden we eerst oversampling kunnen toepassen om de verhouding te verhogen tot 1:10 door voorbeelden uit de minderheidsklasse te dupliceren, en vervolgens undersampling toepassen om de verhouding verder te verbeteren tot 1:2 door voorbeelden uit de meerderheidsklasse te verwijderen.

Dit kan worden geïmplementeerd met ongebalanceerd-leren door een RandomOverSampler te gebruiken met sampling_strategy ingesteld op 0,1 (10%), en vervolgens een RandomUnderSampler te gebruiken met sampling_strategy ingesteld op 0,5 (50%). Bijvoorbeeld:

1
2
3
4
5
6
7
8
9

# definieer oversampling-strategie
over = RandomOverSampler(sampling_strategy=0.1)
# fit en pas de transformatie toe
X, y = over.fit_resample(X, y)
# definieer undersampling-strategie
under = RandomUnderSampler(sampling_strategy=0.5)
# fit en pas de transformatie toe
X, y = under.fit_resample(X, y)

We kunnen dit demonstreren op een synthetische dataset met een klasseverdeling van 1:100. Het volledige voorbeeld staat hieronder:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# voorbeeld van het combineren van random oversampling en undersampling voor ongebalanceerde data
from collections import Counter
from sklearn.datasets import make_classification
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler
# define dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# summarize class distribution
print(Counter(y))
# definieer oversampling-strategie
over = RandomOverSampler(sampling_strategy=0.1)
# fit en pas de transformatie toe
X, y = over.fit_resample(X, y)
# klasseverdeling samenvatten
print(Counter(y))
# definieer undersampling-strategie
under = RandomUnderSampler(sampling_strategy=0.5)
# fit en pas de transformatie toe
X, y = under.fit_resample(X, y)
# vat de klasseverdeling samen
print(Teller(y))

Het uitvoeren van het voorbeeld creëert eerst de synthetische dataset en vat de klassenverdeling samen, waarbij een klassenverdeling van ongeveer 1:100 wordt getoond.

Dan wordt oversampling toegepast, waarbij de verdeling wordt verhoogd van ongeveer 1:100 tot ongeveer 1:10. Tenslotte wordt undersampling toegepast, waardoor de klassenverdeling nog verder wordt verbeterd van 1:10 tot ongeveer 1:2

1
2
3

Counter({0: 9900, 1: 100})
Counter({0: 9900, 1: 990})
Counter({0: 1980, 1: 990})

We zouden deze hybride aanpak ook kunnen toepassen wanneer we een model evalueren met behulp van k-voudige kruisvalidatie.

Dit kan worden bereikt door een pijplijn te gebruiken met een reeks transformaties die eindigt met het model dat wordt geëvalueerd; bijvoorbeeld:

1
2
3
4
5
6

# definieer pijplijn
over = RandomOverSampler(sampling_strategy=0.1)
under = RandomUnderSampler(sampling_strategy=0.5)
steps =
pipeline = Pipeline(steps=steps)

We kunnen dit demonstreren met een beslisboommodel op dezelfde synthetische dataset.

Het volledige voorbeeld staat hieronder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# voorbeeld van het evalueren van een model met random oversampling en undersampling
from numpy import mean
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.tree import DecisionTreeClassifier
from imblearn.pipeline import Pipeline
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler
# define dataset
X, y = make_classification(n_samples=10000, weights=, flip_y=0)
# define pipeline
over = RandomOverSampler(sampling_strategy=0.1)
under = RandomUnderSampler(sampling_strategy=0.5)
stappen =
pijplijn = pijplijn(stappen=stappen)
# evalueer pijplijn
cv = RepeatedStratifiedKFold(n_splits=10, n_herhalingen=3, random_state=1)
scores = cross_val_score(pipeline, X, y, scoring=’f1_micro’, cv=cv, n_jobs=-1)
score = gemiddelde(scores)
print(‘F1 Score: %.3f’ % score)

Het uitvoeren van het voorbeeld evalueert een beslisboommodel met behulp van herhaalde k-voudige kruisvalidatie waarbij de trainingsdataset wordt getransformeerd, eerst met behulp van oversampling en vervolgens met undersampling, voor elke uitgevoerde splitsing en herhaling. De F1-score, gemiddeld over elke vouw en elke herhaling, wordt gerapporteerd.

Note: Uw resultaten kunnen afwijken door de stochastische aard van het algoritme of de evaluatieprocedure, of door verschillen in numerieke precisie. Overweeg het voorbeeld een paar keer uit te voeren en vergelijk de gemiddelde uitkomst.

Het gekozen model en de resampling-configuratie zijn willekeurig, ontworpen om een sjabloon te bieden dat u kunt gebruiken om undersampling te testen met uw dataset en leeralgoritme in plaats van de synthetische dataset optimaal op te lossen.

1
F1 Score: 0.985

Verder lezen

Dit gedeelte biedt meer bronnen over het onderwerp als u op zoek bent naar meer diepgang.

Boeken

  • Hoofdstuk 5 Data Level Preprocessing Methods, Learning from Imbalanced Data Sets, 2018.
  • Hoofdstuk 3 Ongebalanceerde datasets: From Sampling to Classifiers, Onevenwichtig leren: Foundations, Algorithms, and Applications, 2013.

Papers

  • A Study Of The Behavior Of Several Methods For Balancing Machine Learning Training Data, 2004.
  • A Survey of Predictive Modelling under Imbalanced Distributions, 2015.

API

  • Imbalanced-Learn Documentation.
  • imbalanced-learn, GitHub.
  • imblearn.over_sampling.RandomOverSampler API.
  • imblearn.pipeline.Pipeline API.
  • imblearn.under_sampling.RandomUnderSampler API.

Artikelen

  • Oversampling en undersampling in data-analyse, Wikipedia.

Samenvatting

In deze tutorial ontdekte u random oversampling en undersampling voor ongebalanceerde classificatie

In het bijzonder leerde u:

  • Random resampling biedt een naïeve techniek voor het opnieuw in evenwicht brengen van de klassenverdeling voor een ongebalanceerde dataset.
  • Random oversampling dupliceert voorbeelden uit de minderheidsklasse in de trainingsdataset en kan resulteren in overfitting voor sommige modellen.
  • Random undersampling verwijdert voorbeelden uit de meerderheidsklasse en kan resulteren in het verlies van informatie die van onschatbare waarde is voor een model.

Heeft u nog vragen?
Stel uw vragen in de opmerkingen hieronder en ik zal mijn best doen om ze te beantwoorden.

Krijg grip op ongebalanceerde classificatie!

Ongebalanceerde classificatie met Python

Ontwikkel ongebalanceerde leermodellen in enkele minuten

…met slechts een paar regels pythoncode

Ontdek hoe in mijn nieuwe Ebook:
Imbalanced Classification with Python

Het biedt zelfstudie-tutorials en eind-tot-eindprojecten over:
Prestatiemetingen, Undersampling-methodes, SMOTE, Threshold Moving, Probability Calibration, Kostengevoelige algoritmen
en nog veel meer…

Breng onevenwichtige classificatiemethoden naar uw Machine Learning-projecten

Bekijk de inhoud

Tweet Share Share

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.