Modele bazowe: zawsze pokonuj DummyClassifier
Zbuduj DummyClassifier jako minimalny model bazowy i potwierdź, że każdy rzeczywisty model musi go przewyższać, aby można go było uznać za użyteczny.
Modele bazowe: zawsze pokonuj DummyClassifier to bezpłatna lekcja Machine Learning Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Machine Learning Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Dlaczego potrzebny jest model bazowy
Jeśli poinformują Państwo, że model osiąga dokładność 92%, ta liczba bez kontekstu nic nie znaczy. Czy 92% to dobry, czy rozczarowujący wynik? Zależy to całkowicie od tego, jaki wynik osiągnęłaby najprostsza możliwa strategia dla tego samego problemu.
Model bazowy wyznacza poziom, który każdy rzeczywisty model musi przekroczyć, aby można go było uznać za użyteczny. Bez modelu bazowego można świętować dokładność 92% na zbiorze danych, na którym model zawsze przewidujący „brak oszustwa” osiągnąłby dokładność 95% — co oznacza, że zaawansowany model ML jest w rzeczywistości gorszy niż brak jakiegokolwiek działania.
DummyClassifier: narzędzie bazowe biblioteki scikit-learn
Biblioteka scikit-learn udostępnia klasę DummyClassifier — minimalny klasyfikator, który generuje predykcje na podstawie prostych reguł, całkowicie ignorując cechy wejściowe. Jest to formalne narzędzie służące do ustalenia modelu bazowego przed rozpoczęciem właściwego modelowania.
DummyClassifier nie jest żartem ani atrapą — stanowi rygorystyczny test poprawności. Jeśli rzeczywisty model nie potrafi pokonać DummyClassifier, oznacza to fundamentalny problem: cechy mogą nie mieć wartości predykcyjnej, potok może zawierać błąd lub problem może być trudniejszy, niż oczekiwano.
from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Most frequent baseline: always predicts the majority class
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_acc = dummy.score(X_test, y_test)
print(f'Baseline accuracy (always predict majority class): {baseline_acc:.3f}')Strategie DummyClassifier
DummyClassifier obsługuje kilka strategii bazowych:
most_frequent: zawsze przewiduje klasę, która najczęściej występuje w danych treningowych. Najlepsza w przypadku niezrównoważonych zbiorów danych.stratified: losowo przewiduje każdą klasę z prawdopodobieństwem równym jej częstości w danych treningowych. Zachowuje rozkład klas.uniform: losowo przewiduje każdą klasę z takim samym prawdopodobieństwem. Przydatna, gdy wszystkie klasy są reprezentowane równie często.constant: zawsze przewiduje określoną stałą klasę. Należy jej użyć, aby sprawdzić, co się stanie, gdy zawsze przewidywana będzie klasa pozytywna.
from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
for strategy in ['most_frequent', 'stratified', 'uniform', 'prior']:
dummy = DummyClassifier(strategy=strategy, random_state=42)
dummy.fit(X_train, y_train)
acc = dummy.score(X_test, y_test)
print(f'strategy={strategy}: accuracy={acc:.3f}')Paradoks dokładności w praktyce
Paradoks dokładności jest najbardziej widoczny w przypadku niezrównoważonych zbiorów danych. Rozważmy oszustwa związane z kartami kredytowymi, gdzie 99% transakcji jest prawidłowych. most_frequent w DummyClassifier przewiduje „brak oszustwa” dla każdej transakcji i osiąga dokładność 99%. Rzeczywisty model ML z dokładnością 97% wyglądałby gorzej od tego modelu bazowego pod względem dokładności — nawet jeśli prawidłowo wykrywałby większość rzeczywistych oszustw.
Dlatego model bazowy DummyClassifier należy oceniać za pomocą tej samej metryki, która będzie używana do oceny rzeczywistego modelu. W przypadku niezrównoważonych problemów należy używać miar F1, precision lub recall, a nie accuracy.
from sklearn.dummy import DummyClassifier
from sklearn.metrics import f1_score, accuracy_score
import numpy as np
# Simulate 99% negative class (not fraud)
np.random.seed(42)
n = 10000
y_true = np.array([0]*9900 + [1]*100)
X_fake = np.random.randn(n, 5) # random features (not predictive)
# Baseline always predicts not-fraud
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_fake, y_true)
y_pred_dummy = dummy.predict(X_fake)
print(f'Dummy Accuracy: {accuracy_score(y_true, y_pred_dummy):.3f}') # 0.990
print(f'Dummy F1-score: {f1_score(y_true, y_pred_dummy):.3f}') # 0.000
print('Dummy catches 0 fraud cases despite 99% accuracy!')DummyRegressor: model bazowy dla regresji
W przypadku problemów regresyjnych biblioteka scikit-learn udostępnia klasę DummyRegressor z następującymi strategiami:
mean: zawsze przewiduje średnią zbioru treningowego. To standardowy model bazowy — R² mierzy, o ile model jest lepszy od prostego przewidywania średniej.median: zawsze przewiduje medianę zbioru treningowego. Jest bardziej odporna na wartości odstające.quantile: zawsze przewiduje określony kwantyl zmiennej docelowej w zbiorze treningowym.constant: zawsze przewiduje określoną stałą.
Model regresyjny z wartością R² poniżej 0 jest w rzeczywistości gorszy od stałego przewidywania średniej — to wyraźny sygnał, że podczas uczenia wystąpił problem.
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
dummy_reg = DummyRegressor(strategy='mean')
dummy_reg.fit(X_train, y_train)
y_pred_d = dummy_reg.predict(X_test)
print(f'DummyRegressor MAE: {mean_absolute_error(y_test, y_pred_d):.3f}')
print(f'DummyRegressor R2: {r2_score(y_test, y_pred_d):.3f}') # exactly 0.0Pański model a model bazowy
Teraz należy porównać rzeczywisty model z modelem bazowym, używając tej samej metryki. Poprawa względem modelu bazowego pokazuje, jaką wartość dodaje model ML. To porównanie powinno być pierwszym wynikiem przedstawianym w każdym projekcie ML.
Jeśli poprawa jest niewielka (np. rzeczywisty model osiąga F1=0.65, a model bazowy F1=0.60), należy zastanowić się, czy złożoność i koszt modelu ML są warte poprawy o 5%. Czasami prosty system oparty na regułach jest tańszy i wystarczająco dokładny.
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import f1_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Baseline
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_f1 = f1_score(y_test, dummy.predict(X_test))
# Real model
pipeline = Pipeline([('scaler', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))])
pipeline.fit(X_train, y_train)
real_f1 = f1_score(y_test, pipeline.predict(X_test))
print(f'Baseline F1: {baseline_f1:.3f}')
print(f'Real model F1: {real_f1:.3f}')
print(f'Improvement over baseline: {real_f1 - baseline_f1:.3f}')Skuteczność na poziomie człowieka jako drugi model bazowy
W przypadku wielu problemów z rzeczywistego świata punkt odniesienia w postaci skuteczności człowieka jest bardziej przydatny niż model bazowy oparty na prostych regułach. Mogą to być na przykład współczynnik błędów radiologa przy wykrywaniu guzów, dokładność człowieka sprawdzającego spam lub błąd wyceny domu popełniany przez eksperta.
Skuteczność człowieka wyznacza górną granicę: jeśli model dorównuje skuteczności człowieka lub ją przewyższa, problem został rozwiązany. Jeśli model znacznie ustępuje człowiekowi, istnieje przestrzeń do poprawy. Jeśli model jest bardzo blisko poziomu człowieka, dalsze jego doskonalenie może wymagać nadzwyczajnych wysiłków przy coraz mniejszych korzyściach.
Poprzedni system jako model bazowy
W praktyce przemysłowej najbardziej miarodajnym punktem odniesienia jest zwykle istniejący system, który Państwa model zastępuje. Jeśli obecny system produkcyjny korzysta z ręcznie tworzonych reguł, to właśnie jego należy pokonać. Jeśli wdrożono już wcześniejszy model ML, jego metryki produkcyjne stanowią punkt odniesienia.
Raportując wyniki interesariuszom, należy zawsze porównywać je z obecnym systemem, a nie tylko z DummyClassifier. Wartość biznesowa wynika z poprawy względem dotychczasowego stanu. Poprawa o 2% względem obecnego systemu może być warta miliony dolarów dzięki ograniczeniu strat wynikających z oszustw, nawet jeśli w wartościach bezwzględnych wydaje się niewielka.
Punkt odniesienia dla klasyfikacji wieloklasowej
W przypadku problemów wieloklasowych punkt odniesienia DummyClassifier zależy od rozkładu klas. Dla K zrównoważonych klas strategia most_frequent osiąga dokładność 1/K. W przypadku niezrównoważonych klas osiąga udział najczęstszej klasy.
W przypadku metryk takich jak uśredniona makro miara F1, która nadaje wszystkim klasom taką samą wagę, klasyfikator losowy uzyska znacznie niższy wynik dla klas rzadkich. Należy zawsze porównywać metryki dla poszczególnych klas między rzeczywistym modelem a punktem odniesienia, aby zrozumieć, skąd wynika poprawa.
from sklearn.dummy import DummyClassifier
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
y_pred = dummy.predict(X_test)
print('DummyClassifier (most_frequent) on Iris:')
print(classification_report(y_test, y_pred,
target_names=['setosa', 'versicolor', 'virginica']))
print('Notice: only the majority class has non-zero precision/recall')Klasyfikator Zero-Rule: najprostszy punkt odniesienia
Jeszcze prostszym rozwiązaniem niż DummyClassifier jest klasyfikator Zero-Rule (ZeroR) — często stosowany punkt odniesienia w konkursach z zakresu data science. W klasyfikacji ZeroR zawsze przewiduje klasę większościową. W regresji zawsze przewiduje średnią. ZeroR wyznacza absolutne minimum, które każdy model musi przekroczyć, aby był użyteczny.
Jeśli nie mogą Państwo pokonać ZeroR, cechy nie zawierają informacji o zmiennej docelowej. Ta diagnostyka jest szybka i bezpłatna obliczeniowo, dlatego powinna zawsze być pierwszym krokiem w każdym nowym projekcie ML, zanim poświęcą Państwo czas na złożone modele.
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# ZeroR: manually compute
majority_class = np.bincount(y_train).argmax()
y_pred_zeror = np.full(len(y_test), majority_class)
print(f'Majority class in training: {majority_class}')
print(f'ZeroR Accuracy: {accuracy_score(y_test, y_pred_zeror):.3f}')
print(f'ZeroR F1 (pos): {f1_score(y_test, y_pred_zeror):.3f}')Punkty odniesienia typu bagging w projektach ML
Kompletny proces oceny punktu odniesienia dla dowolnego projektu ML:
- Obliczyć punkt odniesienia dla DummyClassifier (
most_frequent) lub DummyRegressor (mean). - Jeśli jest dostępny, obliczyć punkt odniesienia dla obecnego systemu, korzystając z jego predykcji dla zbioru testowego.
- Sprawdzić wydajność na poziomie człowieka w benchmarkach lub literaturze.
- Wytrenować pierwszy prosty model ML (regresję logistyczną lub płytkie drzewo decyzyjne) i porównać go ze wszystkimi trzema punktami odniesienia.
- Do złożonych modeli przechodzić tylko wtedy, gdy prosty model pokonuje punkt odniesienia o znaczącą wartość — złożoność powinna być uzasadniona mierzalną poprawą.
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
models = {
'DummyClassifier': DummyClassifier(strategy='most_frequent'),
'LogisticRegression': Pipeline([('sc', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))]),
'DecisionTree(d=5)': DecisionTreeClassifier(max_depth=5),
'RandomForest': RandomForestClassifier(random_state=42),
}
for name, model in models.items():
score = cross_val_score(model, X, y, cv=5, scoring='f1').mean()
print(f'{name}: F1={score:.3f}')Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat koncepcji Machine Learning with Python z tej lekcji.
Podsumowanie lekcji
W tej lekcji nauczyłeś się, że: DummyClassifier wyznacza dolną granicę wydajności, którą każdy rzeczywisty model musi przekroczyć, aby dostarczać wartość, punkty odniesienia oparte na accuracy są mylące w przypadku niezrównoważonych zbiorów danych — do porównania punktu odniesienia z rzeczywistym modelem należy zawsze używać tej samej metryki, a kompletny punkt odniesienia obejmuje trywialny klasyfikator, obecny system produkcyjny oraz wydajność na poziomie człowieka, jeśli jest dostępna. Następnie rozpoczniemy kurs Data Preprocessing Pipeline, zaczynając od systematycznych metod obsługi brakujących wartości z użyciem technik imputacji.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 30
- Lekcje
- 120
Często zadawane pytania
Czy lekcja „Modele bazowe: zawsze pokonuj DummyClassifier” jest bezpłatna?
Tak — pełny tekst „Modele bazowe: zawsze pokonuj DummyClassifier” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Machine Learning Academy, przejdź na CoddyKit PRO. Kurs Machine Learning Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Modele bazowe: zawsze pokonuj DummyClassifier”?
Zbuduj DummyClassifier jako minimalny model bazowy i potwierdź, że każdy rzeczywisty model musi go przewyższać, aby można go było uznać za użyteczny. Ćwiczysz Machine Learning Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Machine Learning Academy?
Nie wymagamy żadnego doświadczenia. Machine Learning Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Modele bazowe: zawsze pokonuj DummyClassifier”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Machine Learning Academy?
Tak. Każda lekcja Machine Learning Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Dlaczego nie można oceniać modelu na danych treningowych
- train_test_split: proporcje, ziarna i stratyfikacja
- Kompromis obciążenie–wariancja: niedouczenie a przeuczenie
- Modele bazowe: zawsze pokonuj DummyClassifier