Çfarë është një grup i pabalancuar të dhënash dhe si trajtohet?

Shkruar nga Yasin TANIŞ

Botuar fillimisht në Medium

Një person duke menduar pranë një peshoreje me grumbuj të pabarabartë të dhënash në të dy pjatat e saj

Çfarë është një grup i pabalancuar të dhënash

Ndërtoni një model klasifikimi për një biznes dhe ai arrin saktësi 95 %. Gjithçka duket në rregull. Modeli vihet në përdorim, por shpejt dikush vëren se ai parashikon gjithmonë të njëjtën klasë. Kur i rishikoni të dhënat, shihni se klasa që modeli nuk e zbulon kurrë përbën vetëm 5 % të të dhënave. Dështimi i modelit vjen nga grupi i pabalancuar i të dhënave.

Grupet e pabalancuara të të dhënave shfaqen në problemet e klasifikimit kur klasat janë larg një shpërndarjeje të barabartë. Problemi është se klasa e shumicës e lë në hije klasën e pakicës: modeli anon drejt shumicës dhe e klasifikon keq pakicën.

Kur përballemi me të dhëna të pabalancuara, këto janë metodat që mund të përdorim për të vëzhguar saktë dhe për të rikthyer balancën:

  • Zgjedhja e metrikave të duhura: precision, recall, rezultati F1, kurba ROC dhe AUC
  • Rimostrimi: oversampling (i rastësishëm dhe SMOTE) dhe undersampling (i rastësishëm, NearMiss, lidhjet Tomek, qendrat e grupimeve)
  • Mbledhja e më shumë të dhënave
  • Përdorimi i parametrit class_weight të modeleve të klasifikimit, që modeli të mësojë njëlloj nga klasa e pakicës dhe nga ajo e shumicës
  • Shqyrtimi i performancës së modeleve të tjera, në vend që të mbështetemi vetëm te një
  • Ndjekja e një qasjeje tjetër, si zbulimi i anomalive ose i ndryshimeve

Fillimisht shqyrtojmë grupin e të dhënave Credit Card Fraud Detection, i cili është i pabalancuar, dhe pastaj zbatojmë disa metoda për ta trajtuar këtë pabalancë.

Shqyrtimi i grupit të të dhënave

Zbulimi i mashtrimeve është i rëndësishëm për kompanitë e kartave të kreditit: ato nuk duan që klientëve t’u ngarkohen blerje që nuk i kanë bërë.

Grupi i të dhënave: creditcard.csv (Kaggle)

Me këtë grup të dhënash duam të ndërtojmë një model që zbulon transaksionet mashtruese. Të dhënat vijnë nga transaksione me karta të kryera në Evropë në shtator 2013; çdo transaksion shënohet me 1 nëse është mashtrim dhe me 0 nëse nuk është. Për arsye privatësie ka pak informacion kontekstual, dhe të gjitha ndryshoret përveç Time dhe Amount janë transformuar me PCA (analiza e komponentëve kryesorë).

  • Time: sekondat e kaluara nga transaksioni i parë deri te secili transaksion
  • Amount: shuma e transaksionit

Fillimisht lexojmë të dhënat, kontrollojmë për vlera që mungojnë dhe shohim shpërndarjen e ndryshores Class. Pastaj standardizojmë Amount dhe Time, i ndajmë të dhënat me metodën hold-out dhe ndërtojmë një model klasifikimi me regresion logjistik. Do të punojmë me një model të vetëm.

# Gerekli kütüphaneler
import pandas as pd
import numpy as np
from sklearn.preprocessing import RobustScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix, classification_report,f1_score,recall_score,roc_auc_score, roc_curve
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import rc,rcParams
import itertools

import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning) 
warnings.filterwarnings("ignore", category=FutureWarning) 
warnings.filterwarnings("ignore", category=UserWarning)
# Veri setinin okutulması
df = pd.read_csv("creditcard.csv")
df.head()
Rezultati i kodit: pesë rreshtat e parë të grupit, kolonat Time dhe V1–V8
# Veri setindeki değişken ve gözlem sayısı
print("Gözlem sayısı : " ,len(df))
print("Değişken sayısı : ", len(df.columns))
Gözlem sayısı : 284807
Değişken sayısı : 31

(Kodi i shfaq etiketat në turqisht: numri i vëzhgimeve dhe numri i ndryshoreve.)

# veri setindeki değişkenlerin tiplerini ve boş değer içerip içermediğini gözlemlemek istiyoruz
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 284807 entries, 0 to 284806
Data columns (total 31 columns):
 #   Column  Non-Null Count   Dtype  
---  ------  --------------   -----  
 0   Time    284807 non-null  float64
 1   V1      284807 non-null  float64
 2   V2      284807 non-null  float64
 3   V3      284807 non-null  float64
 4   V4      284807 non-null  float64
 5   V5      284807 non-null  float64
 6   V6      284807 non-null  float64
 7   V7      284807 non-null  float64
 8   V8      284807 non-null  float64
 9   V9      284807 non-null  float64
 10  V10     284807 non-null  float64
 11  V11     284807 non-null  float64
 12  V12     284807 non-null  float64
 13  V13     284807 non-null  float64
 14  V14     284807 non-null  float64
 15  V15     284807 non-null  float64
 16  V16     284807 non-null  float64
 17  V17     284807 non-null  float64
 18  V18     284807 non-null  float64
 19  V19     284807 non-null  float64
 20  V20     284807 non-null  float64
 21  V21     284807 non-null  float64
 22  V22     284807 non-null  float64
 23  V23     284807 non-null  float64
 24  V24     284807 non-null  float64
 25  V25     284807 non-null  float64
 26  V26     284807 non-null  float64
 27  V27     284807 non-null  float64
 28  V28     284807 non-null  float64
 29  Amount  284807 non-null  float64
 30  Class   284807 non-null  int64  
dtypes: float64(30), int64(1)
memory usage: 67.4 MB
# 1 sınıfının veri setinde bulunma oranı %0.2, 0 sınıfının ise %99.8
f, ax = plt.subplots(1, 2, figsize=(18, 8))

# Sınıf dağılımı
class_counts = df['Class'].value_counts().sort_values(ascending=False)

# Sınıf sayısına göre patlamayı belirleyin
explode = [0.1] * len(class_counts)

# Sınıf dağılımı için pasta grafik
ax[0].pie(class_counts, labels=class_counts.index, autopct='%1.1f%%', explode=explode, shadow=True)
ax[0].set_title('Dağılım')
ax[0].set_ylabel('')

# Sınıf dağılımı için sayım grafiği (seaborn kullanarak)
sns.countplot(x='Class', data=df, ax=ax[1])
ax[1].set_title('Sınıf Sayısı')
plt.show()
Grafik rrethor dhe grafik me shtylla i shpërndarjes së klasave: pothuajse të gjitha transaksionet janë të klasës 0
# Time ve Amount değişkenlerini standartlaştırma
rob_scaler = RobustScaler()
df['Amount'] = rob_scaler.fit_transform(df['Amount'].values.reshape(-1,1))
df['Time'] = rob_scaler.fit_transform(df['Time'].values.reshape(-1,1))
df.head()
Rezultati i kodit: rreshtat e parë pas standardizimit të Time dhe Amount
# Hold out yöntemi uygulayıp veri setini eğitim ve test olarak ikiye ayırıyoruz.(%80,%20)
X = df.drop("Class", axis=1)
y = df["Class"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=123456)
# modelin tanımlanıp, eğitilmesi ve başarı skoru
model = LogisticRegression(random_state=123456)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: %.3f"%(accuracy))
Accuracy: 0.999

Saktësia është raporti i parashikimeve të sakta ndaj të gjitha parashikimeve. Modeli ynë arrin 0,999. Mund të themi se funksionon në mënyrë të përsosur, apo jo? Le të shohim edhe matricën e konfuzionit.

Matrica e konfuzionit

Matrica e konfuzionit është një tabelë që përmbledh performancën e një modeli klasifikimi në të dhënat e testit. Ajo përmban katër kombinimet e vlerave të parashikuara dhe atyre reale. Këtu mashtrimin e trajtojmë si klasë pozitive:

  • Pozitiv i vërtetë (TP): parashikohet pozitiv dhe parashikimi është i saktë.
  • Negativ i vërtetë (TN): parashikohet negativ dhe parashikimi është i saktë.
  • Pozitiv i rremë (FP): parashikohet pozitiv, por parashikimi është i gabuar.
  • Negativ i rremë (FN): parashikohet negativ, por parashikimi është i gabuar.
def plot_confusion_matrix(cm, classes,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):

    plt.rcParams.update({'font.size': 19})
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title,fontdict={'size':'16'})
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45,fontsize=12,color="blue")
    plt.yticks(tick_marks, classes,fontsize=12,color="blue")
    rc('font', weight='bold')
    fmt = '.1f'
    thresh = cm.max()
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="red")

    plt.ylabel('True label',fontdict={'size':'16'})
    plt.xlabel('Predicted label',fontdict={'size':'16'})
    plt.tight_layout()

plot_confusion_matrix(confusion_matrix(y_test, y_pred=y_pred), classes=['Non Fraud','Fraud'],
                      title='Confusion matrix')
Matrica e konfuzionit: 56870 transaksione normale të sakta, 5 alarme të rreme, 31 mashtrime të pakapura dhe 56 të kapura
  • Nga 56875 transaksionet që janë realisht normale, 56870 parashikohen saktë dhe 5 shënohen gabimisht si mashtrim (FP).
  • Nga 87 transaksionet që janë realisht mashtruese, 56 kapen (TP) dhe 31 nuk kapen (FN).

Modeli pretendon saktësi 0,999, por matrica e konfuzionit tregon një shkallë të lartë gabimi në klasën e mashtrimeve. Modeli e parashikon mirë klasën e shumicës dhe keq atë të pakicës. Meqë transaksionet normale janë shumë më të shumta se ato mashtruese, modeli duket i suksesshëm duke parashikuar klasën normale.

Mësimi: saktësia nuk është masë e mirë e performancës për modelet e klasifikimit, sidomos kur të dhënat janë aq të pabalancuara sa tonat. Le të shohim si trajtohet pabalanca, cilat metoda të zbatojmë dhe me cilat metrika ta masim performancën.

Zgjedhja e metrikave të duhura

Pamë se saktësia nuk mjafton; për të matur performancën na duhen metrika të tjera.

Precision (precizioni): pjesa e pozitivëve të parashikuar që janë realisht pozitivë. Precizion i ulët do të thotë shumë pozitivë të rremë. Precision = TP / (TP + FP).

Recall (rikujtimi): pjesa e pozitivëve realë që i parashikuam pozitivë. Rikujtim i ulët do të thotë shumë negativë të rremë; duhet të jetë sa më i lartë. Recall = TP / (TP + FN).

Rezultati F1: është e vështirë të krahasosh një model me precizion të ulët dhe rikujtim të lartë me një model që ka të kundërtën. Rezultati F1 i mat të dyja së bashku, si mesatare harmonike e precizionit dhe rikujtimit. F1 = 2 × (Precision × Recall) / (Precision + Recall).

Le t’i shohim këto metrika për modelin tonë. Raporti i klasifikimit tregon metrikat kryesore sipas klasave.

#sınıflandırma raporu
print(classification_report(y_test, y_pred))
Raporti i klasifikimit: precision dhe recall 1.00 për klasën 0; precision 0.92 dhe recall 0.64 për klasën 1

Precizioni sipas klasave:

  • Klasa 0 (normale): 56870 + 31 = 56901 transaksione u parashikuan normale, nga të cilat 56870 saktë. Precision ≈ 1,00 (56870 / 56901).
  • Klasa 1 (mashtrim): 5 + 56 = 61 transaksione u parashikuan mashtrim, nga të cilat 56 saktë. Precision ≈ 0,92 (56 / 61).

Rikujtimi sipas klasave:

  • Klasa 0 (normale): nga 56870 + 5 = 56875 transaksione normale, 56870 parashikohen saktë. Recall ≈ 1,00.
  • Klasa 1 (mashtrim): nga 31 + 56 = 87 transaksione mashtruese, 56 parashikohen saktë. Recall = 56 / 87 ≈ 0,64.

Vlerat e rikujtimit e bëjnë të qartë dështimin te klasa 1. Rezultati F1 është mesatarja harmonike e rikujtimit dhe precizionit. Support është numri real i shembujve në secilën klasë; diferenca mes klasave tregon një dobësi strukturore të matjeve, sepse vetë pabalanca ndikon mbi to.

Kurba ROC

Kurba ROC është një grafik i performancës së një modeli klasifikimi në të gjitha pragjet e vendimit. Ajo paraqet dy vlera:

  • Shkalla e pozitivëve të vërtetë (TPR), pra rikujtimi: TPR = TP / (TP + FN)
  • Shkalla e pozitivëve të rremë (FPR), pra shkalla e alarmeve të rreme te transaksionet normale: FPR = FP / (FP + TN)

Kurba paraqet TPR kundrejt FPR në pragje të ndryshme; nis në (0,0) dhe mbaron në (1,1). Një model i mirë jep një kurbë që ngjitet shpejt nga 0 në 1.

AUC (sipërfaqja nën kurbën ROC)

AUC e përmbledh kurbën ROC në një numër të vetëm: mat të gjithë sipërfaqen nën kurbë nga (0,0) në (1,1). Vlera më e mirë është 1; hamendësimi i rastësishëm jep 0,5.

# Auc Roc Curve
def generate_auc_roc_curve(clf, X_test):
    y_pred_proba = clf.predict_proba(X_test)[:, 1]
    fpr, tpr, thresholds = roc_curve(y_test,  y_pred_proba)
    auc = roc_auc_score(y_test, y_pred_proba)
    plt.plot(fpr,tpr)
    plt.show()
    pass

generate_auc_roc_curve(model, X_test)
Kurba ROC që ngjitet shpejt drejt këndit të sipërm të majtë
y_pred_proba = model.predict_proba(X_test)[:, 1]
auc = roc_auc_score(y_test, y_pred_proba)
print("AUC ROC Curve with Area Under the curve = %.3f"%auc)
AUC ROC Curve with Area Under the curve = 0.961

Shënim: AUC vlerëson performancën e përgjithshme të klasifikimit. Meqë nuk i jep njërës klasë më shumë peshë se tjetrës, nuk e pasqyron mirë performancën te klasa e pakicës.

Tani le të zbatojmë disa metoda në grupin e të dhënave për ta eliminuar pabalancën.

E rëndësishme: këto metoda duhet të zbatohen vetëm në grupin e trajnimit. Nëse zbatohen në grupin e testit, një vlerësim i saktë bëhet i pamundur.

Rimostrimi

Rimostrimi (resampling) e bën një grup të dhënash më të balancuar duke i shtuar shembuj të rinj klasës së pakicës ose duke hequr shembuj nga klasa e shumicës. Undersampling heq shembuj të shumicës; oversampling shumëfishon shembujt e pakicës.

Oversampling

Oversampling i balancon të dhënat duke kopjuar shembuj të klasës së pakicës.

Oversampling i rastësishëm:

  • Shtohen shembuj të zgjedhur rastësisht nga klasa e pakicës për të balancuar grupin e të dhënave.
  • Mund të përdoret kur grupi i të dhënave është i vogël.
  • Mund të shkaktojë mbipërshtatje (overfitting).

RandomOverSampler merr argumentin sampling_strategy. Me sampling_strategy='minority' klasa e pakicës shumëfishohet derisa të barazohet me klasën e shumicës. Argumenti pranon edhe një numër dhjetor: nëse klasa e shumicës ka 1000 shembuj dhe ajo e pakicës 100, sampling_strategy=0.5 e ngre pakicën në 500.

# random oversampling önce eğitim setindeki sınıf sayısı
y_train.value_counts()
0    227440
1       405
Name: Class, dtype: int64
# RandomOver Sampling uygulanması (Eğitim setine uygulanıyor)
from imblearn.over_sampling import RandomOverSampler
oversample = RandomOverSampler(sampling_strategy='minority')
X_randomover, y_randomover = oversample.fit_resample(X_train, y_train)
# random oversampling den sonra eğitim setinin sınıf sayısı
y_randomover.value_counts()
1    227440
0    227440
Name: Class, dtype: int64
# modelin eğitilmesi ve başarı oranı
model.fit(X_randomover, y_randomover)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: %.3f%%" % (accuracy))
Accuracy: 0.977
plot_confusion_matrix(confusion_matrix(y_test, y_pred=y_pred), classes=['Non Fraud','Fraud'],
                      title='Confusion matrix')
Matrica e konfuzionit pas oversampling-ut të rastësishëm: 55559 normale të sakta, 1316 alarme të rreme, 12 mashtrime të pakapura dhe 75 të kapura
#sınıflandırma raporu
print(classification_report(y_test, y_pred))
      precision    recall  f1-score   support

           0       1.00      0.98      0.99     56875
           1       0.05      0.86      0.10        87

    accuracy                           0.98     56962
   macro avg       0.53      0.92      0.55     56962
weighted avg       1.00      0.98      0.99     56962

Pas oversampling-ut të rastësishëm, saktësia e modelit bie në 0,977. Matrica e konfuzionit dhe raporti i klasifikimit tregojnë se shumica e transaksioneve të shënuara si mashtrim janë alarme të rreme, gjë që e ul precizionin e klasës 1 në 0,05. Në këmbim, rikujtimi i klasës 1 ngrihet në 0,86: kapen 75 nga 87 mashtrimet. Transaksionet normale parashikohen pak më keq se me modelin e parë, por ky kërcim në kapjen e mashtrimeve është një arsye e fortë për të preferuar modelin e trajnuar pas oversampling-ut të rastësishëm.

SMOTE oversampling:

Për të shmangur mbipërshtatjen, në vend të kopjeve krijohen shembuj sintetikë të klasës së pakicës:

  • Zgjidhet rastësisht një shembull nga klasa e pakicës.
  • Gjenden k fqinjët e tij më të afërt.
  • Zgjidhet rastësisht një fqinj; në hapësirën e veçorive hiqet një segment mes shembullit dhe fqinjit, dhe shembulli sintetik krijohet mbi këtë segment.
# smote dan önce eğitim setindeki sınıf sayısı
y_train.value_counts()
0    227440
1       405
Name: Class, dtype: int64
# Smote uygulanması (Eğitim setine uygulanıyor)
from imblearn.over_sampling import SMOTE
oversample = SMOTE()
X_smote, y_smote = oversample.fit_resample(X_train, y_train)
# smote dan sonra eğitim setinin sınıf sayısı
y_smote.value_counts()
1    227440
0    227440
Name: Class, dtype: int64
# modelin eğitilmesi ve başarı oranı
model.fit(X_smote, y_smote)
y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: %.3f%%" % (accuracy))
Accuracy: 0.975
Matrica e konfuzionit pas SMOTE: 55469 normale të sakta, 1406 alarme të rreme, 12 mashtrime të pakapura dhe 75 të kapura
plot_confusion_matrix(confusion_matrix(y_test, y_pred=y_pred), classes=['Non Fraud','Fraud'],
                      title='Confusion matrix')
#sınıflandırma raporu
print(classification_report(y_test, y_pred))
     precision    recall  f1-score   support

           0       1.00      0.98      0.99     56875
           1       0.05      0.86      0.10        87

    accuracy                           0.98     56962
   macro avg       0.53      0.92      0.54     56962
weighted avg       1.00      0.98      0.99     56962

Rezultatet pas SMOTE janë të ngjashme me ato të oversampling-ut të rastësishëm: sërish kapen 75 nga 87 mashtrimet, ndërsa alarmet e rreme rriten në 1406.

Undersampling

Undersampling i balancon të dhënat duke hequr shembuj nga klasa e shumicës dhe u përshtatet grupeve të mëdha të të dhënave. Grupi ynë nuk është aq i madh sa kjo qasje të funksionojë mirë, por i shpjegojmë metodat dhe tregojmë si zbatohen disa prej tyre.

Undersampling i rastësishëm:

  • Shembujt që hiqen zgjidhen rastësisht.
  • Mund të përdoret nëse keni një grup të madh të dhënash.
  • Zgjedhja e rastësishme mund të sjellë humbje informacioni.
# random undersampling den önce eğitim setindeki sınıf sayısı
y_train.value_counts()
0    227440
1       405
Name: Class, dtype: int64
from imblearn.under_sampling import RandomUnderSampler
# transform the dataset
ranUnSample = RandomUnderSampler()
X_ranUnSample, y_ranUnSample = ranUnSample.fit_resample(X_train, y_train)
# Random undersampling sonra
y_ranUnSample.value_counts()
1    405
0    405
Name: Class, dtype: int64

NearMiss undersampling:

  • Pakëson humbjen e informacionit.
  • Bazohet në algoritmin KNN.
  • Llogarit largësinë nga shembujt e shumicës te shembujt e pakicës.
  • Ruan shembujt e shumicës që janë më afër klasës së pakicës, sipas një vlere të dhënë të k-së.

Lidhjet Tomek: për çdo çift shembujsh më të afërt nga klasa të ndryshme hiqet shembulli i shumicës, gjë që e zgjeron hapësirën mes dy klasave.

Qendrat e grupimeve: shembujt e parëndësishëm hiqen nga grupi i të dhënave; nëse një shembull ka rëndësi, përcaktohet me anë të grupimit (clustering).

Undersampling dhe oversampling mund të kombinohen për të ndërtuar grupe të dhënash më të balancuara.

Metoda të tjera

  • Mbledhja e më shumë të dhënave
  • Përdorimi i parametrit class_weight, që modeli të mësojë njëlloj nga klasa e pakicës dhe nga ajo e shumicës
  • Shqyrtimi i performancës së modeleve të tjera, jo vetëm të njërit
  • Ndjekja e një qasjeje tjetër, si zbulimi i anomalive ose i ndryshimeve

Cila metodë funksionon më mirë varet nga grupi i të dhënave në fjalë. Rezultati më i mirë arrihet duke i provuar metodat dhe duke zgjedhur atë që u përshtatet të dhënave tuaja.

Burimet