1. Pogrupuj wiersze według kolumny Diabetic - chcesz osobno zdrowych (0) i chorych (1).
2. Dla każdej grupy policz medianę wszystkich cech.
3. Odwróć tabelę, żeby cechy były w wierszach, a grupy w kolumnach - tak się to czyta o wiele łatwiej.
4. Dodaj kolumnę z różnicą median między grupami.
5. Dodaj kolumnę z różnicą względną, czyli różnicą podzieloną przez medianę zdrowych.
6. Posortuj tabelę malejąco według różnicy względnej.

Dlaczego mediana, a nie średnia: mediana to wartość środkowa - połowa pacjentów ma mniej, połowa więcej. W odróżnieniu od średniej nie daje się zaburzyć pojedynczym skrajnym wynikiem. Przy danych medycznych, gdzie zdarzają się bardzo wysokie pomiary, to istotna różnica.

Dlaczego różnica względna, a nie zwykła: SerumInsulin różni się o 101 jednostek, a DiabetesPedigree o 0,04. Porównywanie tych liczb wprost nie ma sensu, bo są w zupełnie innych skalach. Dzielenie przez wartość wyjściową sprowadza je do wspólnego mianownika: „o ile procent więcej".

Krok 1-2: grupowanie i mediana

mediany = dane.groupby(ETYKIETA)[cechy].median()

• dane.groupby(ETYKIETA) dzieli wiersze na grupy według wartości w kolumnie Diabetic - powstaną dwie grupy: 0 i 1.
• [cechy] ogranicza działanie do kolumn z cechami. cechy to lista zdefiniowana wcześniej w notatniku, bez PatientID i bez Diabetic.
• .median() liczy medianę każdej kolumny osobno w każdej grupie.

Krok 3: odwrócenie tabeli

mediany = dane.groupby(ETYKIETA)[cechy].median().T
mediany.columns = ['zdrowi (0)', 'chorzy (1)']

• .T to transpozycja - zamienia wiersze z kolumnami. Bez niej masz 2 wiersze i 8 kolumn, po niej 8 wierszy i 2 kolumny.
• mediany.columns = [...] nadaje kolumnom czytelne nazwy zamiast 0 i 1.

Krok 4-5: obie różnice

mediany['różnica'] = mediany['chorzy (1)'] - mediany['zdrowi (0)']
mediany['różnica względna'] = mediany['różnica'] / mediany['zdrowi (0)']

Przypisanie do nieistniejącej kolumny tworzy ją. Odejmowanie i dzielenie działają tu na całych kolumnach naraz, wiersz po wierszu - nie potrzebujesz pętli.

Krok 6: sortowanie

mediany.sort_values('różnica względna', key=abs, ascending=False)

• key=abs sortuje według wartości bezwzględnej. Bez tego cecha, która u chorych jest niższa (różnica ujemna), wylądowałaby na końcu, choć różnica może być duża.
• ascending=False układa od największej do najmniejszej.

mediany = dane.groupby(ETYKIETA)[cechy].median().T
mediany.columns = ['zdrowi (0)', 'chorzy (1)']
mediany['różnica'] = mediany['chorzy (1)'] - mediany['zdrowi (0)']
mediany['różnica względna'] = mediany['różnica'] / mediany['zdrowi (0)']

print(mediany.sort_values('różnica względna', key=abs, ascending=False)
             .to_string(float_format=lambda v: f"{v:.3f}"))

print()
print("Pełne describe() dla grupy chorych:")
dane[dane[ETYKIETA] == 1][cechy].describe().T.round(2)

Czego się spodziewać - tabela uszeregowana mniej więcej tak:

                        zdrowi (0)  chorzy (1)  różnica  różnica względna
Pregnancies                  1.000       5.000    4.000             4.000
SerumInsulin                53.000     154.000  101.000             1.906
Age                         23.000      37.000   14.000             0.609
DiabetesPedigree             0.193       0.231    0.038             0.198
BMI                         28.623      33.883    5.260             0.184
PlasmaGlucose               96.000     108.000   12.000             0.125
TricepsThickness            31.000      29.000   -2.000            -0.065
DiastolicBloodPressure      69.000      73.000    4.000             0.058

Jak to czytać:

• Odpowiedź na pytanie z zadania to Pregnancies: mediana rośnie z 1 do 5, czyli o 400%. Żadna inna cecha nie zbliża się do tego.
• TricepsThickness ma różnicę ujemną - u chorych jest niższa. Właśnie dlatego sortujesz przez key=abs.
• Porównaj ten ranking z korelacjami z sekcji 5. Kolejność jest podobna, ale nie identyczna - korelacja i różnica median to dwie różne miary i nie muszą się zgadzać co do joty.

1. Utwórz figurę z jedną osią (fig, ax = plt.subplots(...)).
2. Wybierz wiersze zdrowych pacjentów i narysuj z nich histogram na tej osi.
3. Wybierz wiersze chorych i narysuj drugi histogram na tej samej osi.
4. Dodaj legendę, podpis osi i tytuł.
5. Powtórz całość dla cechy, która rozróżnia klasy najsłabiej. Nie wpisuj jej nazwy z pamięci - wylicz ją z danych.

Co to jest histogram: wykres pokazujący, ile obserwacji wpada w kolejne przedziały wartości. Słupek przy wartości 100 o wysokości 400 znaczy „400 pacjentów miało wynik w okolicy 100". Dwa nałożone histogramy pozwalają zobaczyć, czy chorzy i zdrowi mają różne rozkłady - a to jest dokładnie to, co model będzie próbował wykorzystać.

Krok 1: figura i oś

fig, ax = plt.subplots(figsize=(8, 5))

plt.subplots() zwraca dwie rzeczy: figurę (całe płótno) i oś (jeden układ współrzędnych). Rysujesz zawsze na osi, czyli na ax.

Krok 2-3: dwa histogramy na jednej osi

ax.hist(dane.loc[dane[ETYKIETA] == 0, 'PlasmaGlucose'],
        bins=30, alpha=0.6, label='zdrowi')
ax.hist(dane.loc[dane[ETYKIETA] == 1, 'PlasmaGlucose'],
        bins=30, alpha=0.6, label='chorzy')

Rozłóżmy pierwszą linię na części:

• dane[ETYKIETA] == 0 daje kolumnę wartości True/False - True tam, gdzie pacjent jest zdrowy.
• dane.loc[maska, 'PlasmaGlucose'] wybiera te wiersze, w których maska jest True, i z nich tylko kolumnę PlasmaGlucose.
• bins=30 dzieli zakres wartości na 30 przedziałów. Za mało przedziałów ukryje kształt, za dużo zamieni wykres w grzebień.
• alpha=0.6 to przezroczystość. Bez niej drugi histogram całkowicie zasłoni pierwszy - to najczęstszy błąd w tym zadaniu.
• label= to podpis, który pojawi się w legendzie.

Krok 4: opisy

ax.set_xlabel('PlasmaGlucose')
ax.set_ylabel('liczba pacjentów')
ax.legend()

ax.legend() musi być wywołane, inaczej podpisy z label= nigdzie się nie pojawią.

Krok 5: najsłabsza cecha - wyliczona, nie zgadnięta

najslabsza = macierz[ETYKIETA].drop(ETYKIETA).abs().idxmin()

• macierz[ETYKIETA] bierze kolumnę korelacji z etykietą.
• .drop(ETYKIETA) usuwa korelację etykiety z samą sobą (zawsze równą 1).
• .abs() bierze wartości bezwzględne - interesuje nas siła związku, nie jego kierunek.
• .idxmin() zwraca nazwę cechy o najmniejszej wartości, a nie samą wartość.

Żeby nie powtarzać kodu dwa razy, opłaca się zamknąć rysowanie w funkcji przyjmującej nazwę kolumny i oś.

def histogram_wg_klas(kolumna, ax):
    ax.hist(dane.loc[dane[ETYKIETA] == 0, kolumna], bins=30, alpha=0.6,
            color='#4C72B0', label='zdrowi', edgecolor='white')
    ax.hist(dane.loc[dane[ETYKIETA] == 1, kolumna], bins=30, alpha=0.6,
            color='#C44E52', label='chorzy', edgecolor='white')
    ax.set_xlabel(kolumna)
    ax.set_ylabel('liczba pacjentów')
    ax.set_title(f"{kolumna} (korelacja z etykietą: {macierz.loc[kolumna, ETYKIETA]:+.3f})")
    ax.legend()
    ax.grid(alpha=0.3)


# Cecha najslabiej rozrozniajaca klasy - wybieramy ja z danych, nie z pamieci
najslabsza = macierz[ETYKIETA].drop(ETYKIETA).abs().idxmin()
print("Najsłabiej skorelowana z etykietą:", najslabsza)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 4.5))
histogram_wg_klas('PlasmaGlucose', ax1)
histogram_wg_klas(najslabsza, ax2)
plt.tight_layout()
plt.show()

Czego się spodziewać:

• Wydruk: Najsłabiej skorelowana z etykietą: DiastolicBloodPressure (korelacja +0,087).
• Dwa wykresy obok siebie.

Jak to czytać - to jest pointa zadania:

• Przy PlasmaGlucose oba rozkłady są przesunięte względem siebie. Widać, że chorzy mają wyższe wartości - nakładają się, ale nie pokrywają.
• Przy DiastolicBloodPressure oba rozkłady leżą niemal jeden na drugim. Gdybyś dostał sam pomiar ciśnienia, nie potrafiłbyś zgadnąć, czy pacjent jest chory.
• Dokładnie to oznacza „cecha rozróżnia klasy słabo". Korelacja 0,087 to ta sama informacja podana liczbą - wykres pokazuje ją tak, że się ją rozumie.

1. Policz macierz korelacji samych cech, bez etykiety.
2. Zostaw tylko górny trójkąt macierzy, bez przekątnej.
3. Zamień macierz na listę par (cecha A, cecha B, korelacja).
4. Dodaj kolumnę z wartością bezwzględną korelacji.
5. Posortuj i wypisz trzy najsilniejsze oraz trzy najsłabsze pary.

Dlaczego górny trójkąt: macierz korelacji jest symetryczna - korelacja BMI z Age jest tą samą liczbą co korelacja Age z BMI. Gdybyś wziął całą macierz, każda para pojawiłaby się dwa razy. Na przekątnej są same jedynki (korelacja cechy z samą sobą), które zawsze wygrałyby ranking i zaśmieciły wynik.

Krok 1: korelacje bez etykiety

tylko_cechy = dane[cechy].corr()

Zwróć uwagę: dane[cechy], a nie dane[cechy + [ETYKIETA]]. Zadanie pyta o korelacje między cechami, nie o ich związek z etykietą.

Krok 2: górny trójkąt

import numpy as np
gorny = tylko_cechy.where(np.triu(np.ones(tylko_cechy.shape), k=1).astype(bool))

To jedna gęsta linia, więc od środka:

• np.ones(tylko_cechy.shape) tworzy tablicę 8x8 wypełnioną jedynkami.
• np.triu(..., k=1) zeruje wszystko poniżej przekątnej oraz samą przekątną (to robi k=1). Zostaje górny trójkąt.
• .astype(bool) zamienia 1 na True, a 0 na False.
• .where(maska) zostawia wartości tam, gdzie maska jest True, a w pozostałych miejscach wstawia NaN.

Krok 3: z macierzy na listę par

pary = (gorny.stack()
             .rename('korelacja')
             .reset_index()
             .rename(columns={'level_0': 'cecha A', 'level_1': 'cecha B'}))

• .stack() „rozkłada" tabelę na jedną długą kolumnę, w której indeks to para (wiersz, kolumna). Pomija przy tym NaN, więc dolny trójkąt znika sam.
• .reset_index() zamienia ten indeks w zwykłe kolumny, domyślnie nazwane level_0 i level_1.
• .rename(columns=...) nadaje im czytelne nazwy.

Krok 4-5: sortowanie

pary['|korelacja|'] = pary['korelacja'].abs()
pary.sort_values('|korelacja|', ascending=False).head(3)
pary.sort_values('|korelacja|').head(3)

Osobna kolumna z wartością bezwzględną jest wygodniejsza od key=abs, bo chcesz ją też zobaczyć w wyniku.

tylko_cechy = dane[cechy].corr()

# Bierzemy gorny trojkat bez przekatnej - kazda para dokladnie raz
gorny = tylko_cechy.where(np.triu(np.ones(tylko_cechy.shape), k=1).astype(bool))

pary = (gorny.stack()
             .rename('korelacja')
             .reset_index()
             .rename(columns={'level_0': 'cecha A', 'level_1': 'cecha B'}))
pary['|korelacja|'] = pary['korelacja'].abs()

print("Trzy najsilniej skorelowane pary cech:")
print(pary.sort_values('|korelacja|', ascending=False).head(3).to_string(index=False))
print()
print("Trzy najsłabiej skorelowane pary cech:")
print(pary.sort_values('|korelacja|').head(3).to_string(index=False))

Czego się spodziewać:

Trzy najsilniej skorelowane pary cech:
    cecha A      cecha B  korelacja  |korelacja|
Pregnancies          Age   0.144361     0.144361
Pregnancies SerumInsulin   0.115830     0.115830
Pregnancies          BMI   0.098109     0.098109

Odpowiedź na pytanie z zadania jest przecząca - i to jest najważniejsze w tym zadaniu.

Najsilniejsza para w całym zbiorze ma korelację 0,144. To bardzo mało. Za próg, przy którym w ogóle rozważa się usunięcie jednej z cech, przyjmuje się zwykle 0,8-0,9. Żadnej cechy nie należy tu usuwać.

Gdyby któraś para miała korelację rzędu 0,95, obie kolumny niosłyby praktycznie tę samą informację. Model dostawałby ją podwójnie, a jego współczynniki stawałyby się niestabilne - to zjawisko nazywa się współliniowością (ang. multicollinearity).

Warto zapamiętać, że negatywny wynik też jest wynikiem. Sprawdziłeś realne ryzyko i wykluczyłeś je pomiarem, zamiast zakładać.

1. Przygotuj listę mnożników do sprawdzenia: 1,0, 1,5, 2,0 i 3,0.
2. Dla każdego mnożnika wywołaj gotową funkcję granice_iqr na kolumnie SerumInsulin.
3. Policz, ile wartości wypada poza wyznaczone granice.
4. Policz, jaki to procent wszystkich wierszy.
5. Zbierz wyniki w tabelę i ją wypisz.

Przypomnienie reguły IQR: bierzesz pierwszy kwartyl Q1 (25% danych jest poniżej) i trzeci kwartyl Q3 (75% poniżej). Ich różnica to rozstęp międzykwartylowy IQR. Granice to Q1 - mnożnik * IQR i Q3 + mnożnik * IQR. Im większy mnożnik, tym szersze granice i tym mniej wartości uznanych za odstające.

Krok 1-2: pętla po mnożnikach

wiersze = []
for mnoznik in [1.0, 1.5, 2.0, 3.0]:
    dol, gora = granice_iqr(dane['SerumInsulin'], mnoznik)

granice_iqr zwraca dwie wartości naraz, więc możesz je od razu rozpakować do dwóch zmiennych.

Krok 3: liczenie odstających

    odstajace = (dane['SerumInsulin'] < dol) | (dane['SerumInsulin'] > gora)
    liczba = odstajace.sum()

• Każde porównanie daje kolumnę True/False.
• | to „lub" działające element po elemencie. Musi być w nawiasach, bo | ma w Pythonie wyższy priorytet niż < i bez nawiasów dostaniesz błąd.
• .sum() na kolumnie True/False liczy True jako 1 - dostajesz liczbę odstających.

Krok 4: procent

    udzial = odstajace.mean()

.mean() na tej samej kolumnie daje od razu udział (średnia z zer i jedynek to właśnie udział jedynek). Nie musisz dzielić przez len(dane).

Krok 5: tabela

    wiersze.append({
        'mnożnik': mnoznik,
        'dolna granica': round(dol, 1),
        'górna granica': round(gora, 1),
        'liczba odstających': int(odstajace.sum()),
        'udział': f"{odstajace.mean():.2%}",
    })

print(pd.DataFrame(wiersze).to_string(index=False))

Budowanie listy słowników, a na końcu jedno pd.DataFrame(...), jest szybsze i czytelniejsze niż doklejanie wierszy do tabeli w pętli.

to_string(index=False) ukrywa numery wierszy 0-3, które niczego tu nie wnoszą.

wiersze = []
for mnoznik in [1.0, 1.5, 2.0, 3.0]:
    dol, gora = granice_iqr(dane['SerumInsulin'], mnoznik)
    odstajace = (dane['SerumInsulin'] < dol) | (dane['SerumInsulin'] > gora)
    wiersze.append({
        'mnożnik': mnoznik,
        'dolna granica': round(dol, 1),
        'górna granica': round(gora, 1),
        'liczba odstających': int(odstajace.sum()),
        'udział': f"{odstajace.mean():.2%}",
    })

print(pd.DataFrame(wiersze).to_string(index=False))

Czego się spodziewać:

 mnożnik  dolna granica  górna granica  liczba odstających udział
     1.0         -119.0          355.0                 699  6.99%
     1.5         -198.0          434.0                 448  4.48%
     2.0         -277.0          513.0                 267  2.67%
     3.0         -435.0          671.0                  77  0.77%

Jak to czytać:

• Liczba odstających spada z 699 do 77 - dziewięciokrotnie - a dane się nie zmieniły. Zmienił się wyłącznie próg, który sam sobie ustawiłeś.
• Dolna granica jest ujemna w każdym wariancie. Insulina nie może być ujemna, więc reguła IQR nie wykryje tu żadnej wartości „za niskiej". Wszystkie odstające to wartości za wysokie.

Odpowiedź na pytanie „skąd 1,5": to konwencja, a nie wynik matematyczny. Zaproponował ją John Tukey przy okazji wykresu pudełkowego, bo dla rozkładu normalnego daje około 0,7% odstających, co uznał za rozsądny próg. Nie ma tu żadnej konieczności - liczba 1,5 jest wyborem, nie prawem.

To ważniejsze, niż wygląda: „wartość odstająca" nie jest własnością danych, tylko skutkiem progu, który ktoś przyjął. Zmiana progu zmienia odpowiedź, a dane zostają te same.

1. Zdefiniuj funkcję o trzech parametrach: ramka danych, lista kolumn i próg (domyślnie 0,01).
2. W środku przejdź po kolumnach i dla każdej policz udział zer.
3. Zatrzymaj tylko te kolumny, w których udział przekracza próg.
4. Posortuj wynik malejąco i zwróć go.
5. Uruchom funkcję na dane_surowe, potem na dane, i porównaj wyniki.

Po co pisać funkcję, a nie jednorazowy kod: bo ten test będziesz chciał uruchomić na każdym nowym zbiorze danych, jaki dostaniesz. Kod wklejony raz do notatnika ginie; funkcja zostaje i daje się przenieść.

Krok 1: nagłówek funkcji

def raport_zer(ramka, kolumny, prog=0.01):

prog=0.01 to wartość domyślna. Możesz wywołać raport_zer(dane, cechy) i próg wyniesie 0,01, albo raport_zer(dane, cechy, prog=0.05) i użyty zostanie 0,05.

Krok 2: udział zer w kolumnie

    udzialy = {}
    for kolumna in kolumny:
        udzialy[kolumna] = (ramka[kolumna] == 0).mean()

(ramka[kolumna] == 0) daje kolumnę True/False, a .mean() zamienia ją od razu na udział - ten sam chwyt co w zadaniu 4.

Krok 3-4: filtr, sortowanie i druga kolumna

    wynik = (pd.Series(udzialy)
               .loc[lambda s: s > prog]
               .sort_values(ascending=False)
               .rename('udział zer')
               .to_frame())
    wynik['liczba zer'] = [(ramka[k] == 0).sum() for k in wynik.index]
    return wynik

• pd.Series(słownik) robi z niego kolumnę z nazwami kolumn jako indeksem.
• .loc[lambda s: s > prog] zostawia tylko pozycje powyżej progu. Zapis z lambda znaczy „weź to, co właśnie powstało w łańcuchu, i zastosuj do tego warunek" - dzięki temu nie trzeba przerywać łańcucha i zapisywać wyniku do zmiennej pomocniczej.
• .rename('udział zer') nadaje kolumnie nazwę, a .to_frame() zamienia pojedynczą kolumnę w tabelę - bez tego nie dałoby się dołożyć drugiej kolumny.
• Ostatnia linia dokłada liczby bezwzględne. Sam udział bywa mylący: 5% z dziesięciu wierszy to zupełnie inna sytuacja niż 5% z dziesięciu tysięcy.
• Funkcja zwraca wynik zamiast go drukować - dzięki temu da się go dalej użyć w kodzie, a nie tylko obejrzeć.

Krok 5: dwa uruchomienia

r_surowe = raport_zer(dane_surowe, cechy)
print(r_surowe.to_string(float_format=lambda v: f"{v:.3f}") if len(r_surowe)
      else "brak kolumn powyżej progu")

Przekazujesz cechy, a nie wszystkie kolumny - inaczej funkcja zgłosi też Diabetic, gdzie 66% zer to poprawna wartość etykiety, a nie brak danych.

Sprawdzenie if len(r_surowe) jest potrzebne, bo to_string() na pustej tabeli daje mylący wydruk samych nagłówków. Funkcja, która nic nie znalazła, powinna powiedzieć to wprost.

def raport_zer(ramka, kolumny, prog=0.01):
    # Zwraca kolumny, w ktorych udzial zer przekracza prog, posortowane malejaco.
    udzialy = {k: (ramka[k] == 0).mean() for k in kolumny}
    wynik = (pd.Series(udzialy)
               .loc[lambda s: s > prog]
               .sort_values(ascending=False)
               .rename('udział zer')
               .to_frame())
    wynik['liczba zer'] = [(ramka[k] == 0).sum() for k in wynik.index]
    return wynik


print("=== dane_surowe (symulowany wadliwy eksport) ===")
r_surowe = raport_zer(dane_surowe, cechy)
print(r_surowe.to_string(float_format=lambda v: f"{v:.3f}") if len(r_surowe)
      else "brak kolumn powyżej progu")

print()
print("=== dane (plik oryginalny) ===")
r_czyste = raport_zer(dane, cechy)
print(r_czyste.to_string(float_format=lambda v: f"{v:.3f}") if len(r_czyste)
      else "brak kolumn powyżej progu")

Czego się spodziewać:

=== dane_surowe (symulowany wadliwy eksport) ===
                        udział zer  liczba zer
SerumInsulin                 0.355        3555
Pregnancies                  0.288        2879
TricepsThickness             0.197        1967
DiastolicBloodPressure       0.048         482

=== dane (plik oryginalny) ===
             udział zer  liczba zer
Pregnancies       0.288        2879

Jak to czytać:

• W zepsutych danych funkcja wskazała cztery kolumny, w prawdziwych - jedną.
• Trzy kolumny, które zniknęły z drugiej listy (SerumInsulin, TricepsThickness, DiastolicBloodPressure), to dokładnie te, które wcześniej celowo zepsuto. Funkcja znalazła je nie wiedząc o tym.

Odpowiedź na pytanie o Pregnancies: 28,79% zer występuje w obu wersjach danych, także w nieuszkodzonej. I słusznie - zero przebytych ciąż to prawdziwa, sensowna wartość.

Czego to dowodzi o automatycznym wykrywaniu problemów: narzędzie wskazuje podejrzanych, ale nie wydaje wyroku. Żeby rozstrzygnąć, czy zero jest wartością, czy zakamuflowanym brakiem, trzeba wiedzieć, co dana kolumna znaczy w rzeczywistości. Tej wiedzy nie ma w pliku CSV - masz ją Ty albo lekarz, z którym rozmawiasz. Automat, który sam usuwałby wszystkie kolumny z zerami, wyrzuciłby tu poprawną cechę.

1. Weź kolumnę TricepsThickness z ramki dane_surowe i policz jej średnią oraz odchylenie standardowe.
2. Zrób kopię tej kolumny z zerami zamienionymi na NaN i policz te same dwie statystyki.
3. Policz je również dla prawdziwej kolumny z ramki dane.
4. Policz, o ile procent średnia „z zerami" różni się od prawdziwej.
5. Narysuj wykres pudełkowy trzech wersji obok siebie.

Czym jest NaN: skrót od not a number, czyli „tu nie ma wartości". Pandas traktuje NaN inaczej niż zero - pomija go przy liczeniu średniej zamiast wliczać jako 0. Na tym polega cała różnica w tym zadaniu.

Krok 1: statystyki z zerami

kolumna = 'TricepsThickness'
z_zerami = dane_surowe[kolumna]
print(z_zerami.mean(), z_zerami.std())

Krok 2: zamiana zer na NaN

po_naprawie = dane_surowe[kolumna].replace(0, np.nan)

.replace(0, np.nan) zwraca nową kolumnę i nie zmienia dane_surowe. To dobrze - oryginał zostaje nienaruszony do porównania.

Krok 3: wartości prawdziwe

prawdziwe = dane[kolumna]

Krok 4: błąd względny

blad_z_zerami = (z_zerami.mean() - prawdziwe.mean()) / prawdziwe.mean()
print(f"Błąd średniej Z ZERAMI: {blad_z_zerami:+.1%}")

:+.1% w f-stringu robi dwie rzeczy naraz: mnoży przez 100 i dokleja znak procenta, a + wymusza wypisanie znaku. Od razu widać, czy błąd zaniża, czy zawyża.

Do tabeli warto dołożyć jeszcze mediana i liczba wartości - ta druga jest tu najciekawsza. .count() liczy wartości pomijając NaN, więc pokaże, ilu pomiarów naprawdę brakuje.

Krok 5: wykres pudełkowy

fig, ax = plt.subplots(figsize=(8, 5))
ax.boxplot([prawdziwe, z_zerami, po_naprawie.dropna()], patch_artist=True)
ax.set_xticklabels(['prawdziwe', 'z zerami', 'po zamianie\nna NaN'])

• .dropna() jest konieczne - boxplot nie poradzi sobie z NaN w danych wejściowych.
• Etykiety ustawiaj przez ax.set_xticklabels(...), a nie argumentem labels=. Ten drugi został wycofany w Matplotlib 3.9 i wypisuje ostrzeżenie.

kolumna = 'TricepsThickness'

prawdziwe = dane[kolumna]
z_zerami = dane_surowe[kolumna]
po_naprawie = dane_surowe[kolumna].replace(0, np.nan)

zestawienie = pd.DataFrame({
    'średnia': [prawdziwe.mean(), z_zerami.mean(), po_naprawie.mean()],
    'odch. std': [prawdziwe.std(), z_zerami.std(), po_naprawie.std()],
    'mediana': [prawdziwe.median(), z_zerami.median(), po_naprawie.median()],
    'liczba wartości': [prawdziwe.count(), z_zerami.count(), po_naprawie.count()],
}, index=['dane prawdziwe', 'z zerami', 'po zamianie 0 na NaN'])

print(zestawienie.round(2).to_string())
print()
blad_z_zerami = (z_zerami.mean() - prawdziwe.mean()) / prawdziwe.mean()
blad_po_naprawie = (po_naprawie.mean() - prawdziwe.mean()) / prawdziwe.mean()
print(f"Błąd średniej Z ZERAMI:          {blad_z_zerami:+.1%}")
print(f"Błąd średniej PO ZAMIANIE NA NaN: {blad_po_naprawie:+.1%}")

fig, ax = plt.subplots(figsize=(8, 5))
ax.boxplot([prawdziwe, z_zerami, po_naprawie.dropna()],
           patch_artist=True)
ax.set_xticklabels(['prawdziwe', 'z zerami', 'po zamianie\nna NaN'])
ax.set_ylabel(kolumna)
ax.set_title('Skutek nierozpoznanych zer - ten sam pomiar, trzy wersje')
ax.grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.show()

Czego się spodziewać:

                      średnia  odch. std  mediana  liczba wartości
dane prawdziwe          28.82      14.51     31.0            10000
z zerami                23.15      17.32     23.0            10000
po zamianie 0 na NaN    28.82      14.50     31.0             8033

Błąd średniej Z ZERAMI:          -19.7%
Błąd średniej PO ZAMIANIE NA NaN: -0.0%

Jak to czytać - i dlaczego to jest groźne:

• Średnia „z zerami" jest zaniżona o 19,7%. Gdyby to była grubość fałdu skórnego w badaniu klinicznym, pomyliłbyś się o jedną piątą - i nic by o tym nie krzyknęło.
• Odchylenie standardowe rośnie z 14,5 do 17,3. Zera dorzucają sztuczne skupisko przy zerze, więc dane wyglądają na bardziej rozrzucone, niż są.
• Po zamianie zer na NaN średnia wraca do wartości prawdziwej, a błąd spada do -0,0% - nie dlatego, że coś zgadliśmy, tylko dlatego, że przestaliśmy wliczać nieistniejące pomiary.
• Kolumna liczba wartości pokazuje cenę tej naprawy: z 10 000 pomiarów zostaje 8033. Prawie 2000 wierszy nie ma tej cechy w ogóle - wcześniej udawały zera i wyglądały jak dane.
• Mediana spada z 31 do 23 i wraca do 31. Zera przesuwają nawet miarę, która z założenia jest odporna na wartości skrajne - bo tu nie chodzi o pojedynczy odstający wynik, tylko o jedną piątą zbioru.

Na wykresie pudełkowym środkowe pudełko jest rozciągnięte w dół, a jego wąs sięga zera. Dwa pozostałe wyglądają praktycznie identycznie.

1. Napisz funkcję, która dostaje ramkę danych i opis, a zwraca skuteczność modelu i liczbę wierszy uczących.
2. W środku: wydziel X (bez PatientID i Diabetic) oraz y (sama kolumna Diabetic).
3. Podziel dane na część uczącą i testową.
4. Zbuduj potok: skalowanie + regresja logistyczna, i naucz go na części uczącej.
5. Policz skuteczność na części testowej.
6. Przygotuj trzy warianty danych (A, B, C) i przepuść każdy przez tę funkcję.
7. Zestaw wyniki w jednej tabeli.

Po co potok (make_pipeline): regresja logistyczna działa źle, gdy cechy mają bardzo różne skale - SerumInsulin sięga setek, a DiabetesPedigree jest poniżej jedynki. StandardScaler sprowadza je do wspólnej skali. Potok łączy skalowanie i model w jeden obiekt, dzięki czemu skalowanie jest uczone tylko na danych uczących - inaczej doszłoby do przecieku informacji ze zbioru testowego.

Krok 1-2: funkcja i podział na X oraz y

def ocen(ramka, opis):
    X = ramka.drop(columns=[IDENTYFIKATOR, ETYKIETA])
    y = ramka[ETYKIETA]

• X to cechy, czyli wszystko poza identyfikatorem i etykietą. PatientID musi wypaść - to numer z rejestracji, a model potrafiłby się go nauczyć na pamięć.
• y to kolumna, którą przewidujemy.

Krok 3: podział

    X_ucz, X_test, y_ucz, y_test = train_test_split(
        X, y, test_size=0.2, stratify=y, random_state=42
    )

• test_size=0.2 odkłada 20% danych na test.
• stratify=y pilnuje, żeby proporcja chorych do zdrowych była taka sama w obu częściach. Bez tego mógłbyś dostać zbiór testowy o innym składzie niż uczący i porównanie straciłoby sens.
• random_state=42 sprawia, że losowanie jest powtarzalne. Przy porównywaniu trzech wariantów jest to konieczne - inaczej nie wiedziałbyś, czy różnica bierze się z danych, czy z innego losowania.

Krok 4: potok i trenowanie

    model = make_pipeline(
        StandardScaler(),
        LogisticRegression(max_iter=1000, random_state=42)
    )
    model.fit(X_ucz, y_ucz)

max_iter=1000 podnosi limit iteracji - przy wartości domyślnej algorytm często nie zdąży się zbiec i wypisze ostrzeżenie.

Krok 5: ocena i zwrócenie wyniku

    return {
        'wariant': opis,
        'wierszy razem': len(ramka),
        'wierszy uczących': len(X_ucz),
        'skuteczność testowa': m.score(X_test, y_test),
    }

m.score(...) dla klasyfikatora zwraca skuteczność, czyli udział poprawnych predykcji.

Kolumna wierszy razem jest tu równie ważna jak skuteczność. Bez niej porównanie wariantów wygląda na remis - a to właśnie ona pokazuje, ile wariant C zapłacił za swój wynik.

Krok 6: trzy warianty

dane_c = dane_surowe.copy()
podejrzane = ['SerumInsulin', 'TricepsThickness', 'DiastolicBloodPressure']
dane_c[podejrzane] = dane_c[podejrzane].replace(0, np.nan)
dane_c = dane_c.dropna()

.dropna() usuwa cały wiersz, jeśli choć jedna z tych trzech kolumn jest pusta. Zaraz zobaczysz, ile to kosztuje.

def ocen(ramka, opis):
    X = ramka.drop(columns=[IDENTYFIKATOR, ETYKIETA])
    y = ramka[ETYKIETA]
    X_ucz, X_test, y_ucz, y_test = train_test_split(
        X, y, test_size=0.2, stratify=y, random_state=42
    )
    m = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000, random_state=42))
    m.fit(X_ucz, y_ucz)
    return {
        'wariant': opis,
        'wierszy razem': len(ramka),
        'wierszy uczących': len(X_ucz),
        'skuteczność testowa': m.score(X_test, y_test),
    }


# C: zamieniamy podejrzane zera na NaN i usuwamy takie wiersze
podejrzane = ['SerumInsulin', 'TricepsThickness', 'DiastolicBloodPressure']
dane_c = dane_surowe.copy()
dane_c[podejrzane] = dane_c[podejrzane].replace(0, np.nan)
dane_c = dane_c.dropna()

wyniki = pd.DataFrame([
    ocen(dane, 'A - dane prawdziwe'),
    ocen(dane_surowe, 'B - z zerami, wrzucone jak leci'),
    ocen(dane_c, 'C - zera na NaN, wiersze usunięte'),
])

print(wyniki.to_string(index=False, float_format=lambda v: f"{v:.4f}"))
print()
print(f"Wariant C stracił {len(dane) - len(dane_c)} wierszy "
      f"({1 - len(dane_c) / len(dane):.1%} zbioru).")

Czego się spodziewać:

                          wariant  wierszy razem  wierszy uczących  skuteczność testowa
               A - dane prawdziwe          10000              8000               0.7880
  B - z zerami, wrzucone jak leci          10000              8000               0.7775
C - zera na NaN, wiersze usunięte           4925              3940               0.7787

Wariant C stracił 5075 wierszy (50.8% zbioru).

Odpowiedzi na trzy pytania z zadania:

1. Czy B wypada zauważalnie gorzej od A? Różnica to 1 punkt procentowy (0,7880 wobec 0,7775). Bez wariantu A obok nikt by jej nie zauważył. Wynik 77,75% wygląda całkowicie normalnie - i to jest sedno sprawy.

2. Ile kosztowało podejście C? 50,8% danych - z 10 000 wierszy zostało 4925. W zamian skuteczność wzrosła o 0,12 punktu procentowego względem B, czyli praktycznie o nic. To zła cena. Przy takim udziale braków sensowniejsze jest uzupełnianie wartości (ang. imputation) niż wyrzucanie wierszy - wrócisz do tego w ćwiczeniu 03.

3. Który wariant jest najbardziej niebezpieczny? Wariant B - mimo że to nie on ma najniższą skuteczność.

Powód: B jest jedynym wariantem, w którym nie wiesz, że masz problem. Model działa, wyniki wyglądają zdrowo, nic się nie wysypuje. C jest jawnie kosztowny - od razu widzisz, że straciłeś połowę danych, i możesz o tym zdecydować świadomie. B po cichu uczy model, że jedna trzecia pacjentów miała zerową insulinę.

To jest pointa całego ćwiczenia: model nie zgłasza problemów z danymi. On się na nich uczy i zwraca liczbę, która wygląda wiarygodnie. Jedyny moment, w którym takie rzeczy da się złapać, to spojrzenie na dane własnymi oczami - czyli EDA.