रैंडम अंडरसैंपलिंग और ClusterCentroids

from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05],
                            n_features=10, random_state=42)

print('Before undersampling:', np.bincount(y))

rus = RandomUnderSampler(sampling_strategy=1.0, random_state=42)
X_res, y_res = rus.fit_resample(X, y)

print('After undersampling:', np.bincount(y_res))
print('New total samples:', len(y_res))

from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=10000, weights=[0.99, 0.01], random_state=42)
print('Original:', np.bincount(y))

for ratio in [1.0, 0.5, 0.2]:
    rus = RandomUnderSampler(sampling_strategy=ratio, random_state=0)
    _, y_r = rus.fit_resample(X, y)
    counts = np.bincount(y_r)
    print(f'ratio={ratio}: {counts} ({counts[1]/counts[0]:.2f} min:maj)')

from imblearn.under_sampling import ClusterCentroids
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.9, 0.1],
                            n_features=5, random_state=42)

print('Before:', np.bincount(y))

cc = ClusterCentroids(sampling_strategy=1.0, random_state=42)
X_cc, y_cc = cc.fit_resample(X, y)

print('After ClusterCentroids:', np.bincount(y_cc))
print('Note: synthetic centroids replace real majority samples')

from imblearn.under_sampling import RandomUnderSampler, ClusterCentroids
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import f1_score
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

sc = StandardScaler()
X_tr = sc.fit_transform(X_train)
X_te = sc.transform(X_test)

for name, sampler in [('None', None),
                       ('RUS', RandomUnderSampler(random_state=0)),
                       ('ClusterCentroids', ClusterCentroids(random_state=0))]:
    if sampler:
        Xr, yr = sampler.fit_resample(X_tr, y_train)
    else:
        Xr, yr = X_tr, y_train
    lr = LogisticRegression().fit(Xr, yr)
    f1 = f1_score(y_test, lr.predict(X_te))
    print(f'{name:20s}: F1={f1:.4f}  n_train={len(yr)}')

from imblearn.combine import SMOTETomek
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
print('Before:', np.bincount(y))

st = SMOTETomek(random_state=42)
X_res, y_res = st.fit_resample(X, y)
print('After SMOTETomek:', np.bincount(y_res))

from imblearn.under_sampling import NearMiss
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.9, 0.1], random_state=42)
print('Before:', np.bincount(y))

for version in [1, 2, 3]:
    nm = NearMiss(version=version)
    _, y_nm = nm.fit_resample(X, y)
    print(f'NearMiss-{version}:', np.bincount(y_nm))

from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.under_sampling import RandomUnderSampler
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)

pipe = ImbPipeline([
    ('sc', StandardScaler()),
    ('rus', RandomUnderSampler(random_state=42)),
    ('lr', LogisticRegression())
])

scores = cross_val_score(pipe, X, y, cv=5, scoring='f1')
print(f'CV F1 (RUS): {np.mean(scores):.4f} +/- {np.std(scores):.4f}')

from sklearn.metrics import classification_report
from imblearn.under_sampling import RandomUnderSampler
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

sc = StandardScaler()
X_train_s = sc.fit_transform(X_train)
X_test_s = sc.transform(X_test)

rus = RandomUnderSampler(random_state=0)
X_r, y_r = rus.fit_resample(X_train_s, y_train)

lr = LogisticRegression().fit(X_r, y_r)
# Evaluate on ORIGINAL imbalanced test set
print(classification_report(y_test, lr.predict(X_test_s)))