1. Przygotuj listę czterech strategii; przy 'constant' zapamiętaj, że potrzebny jest dodatkowy argument fill_value=0.
2. W pętli po strategiach zbuduj potok: uzupełnianie → skalowanie → regresja logistyczna.
3. Naucz każdy potok na X_ucz[cechy_liczbowe].
4. Dla każdego odczytaj skuteczność testową oraz wartość, którą imputer wstawia w miejsce braków.
5. Zbierz wyniki w tabelę i policz różnicę między najlepszą a najgorszą strategią.

Dlaczego X_ucz[cechy_liczbowe], a nie X_ucz: X_ucz zawiera też kolumnę GrupaWiekowa, która jest tekstem. SimpleImputer i StandardScaler obsługują tylko liczby, więc trzeba wybrać same kolumny liczbowe. Kategoriami zajmiesz się w zadaniu 3.

Co robi każda strategia: 'mean' wstawia średnią kolumny, 'median' medianę, 'most_frequent' wartość najczęstszą, a 'constant' stałą, którą sam podasz.

Krok 1: lista strategii

strategie = [
    ('mean', {}),
    ('median', {}),
    ('most_frequent', {}),
    ('constant', {'fill_value': 0}),
]

Każdy element to para: nazwa strategii i słownik dodatkowych argumentów. Trzy pierwsze nie potrzebują nic więcej, 'constant' wymaga podania wartości. Dzięki tej strukturze pętla obsłuży wszystkie cztery przypadki jednym kodem.

Krok 2-3: potok w pętli

for nazwa, dodatkowe in strategie:
    potok = Pipeline([
        ('uzupelnianie', SimpleImputer(strategy=nazwa, **dodatkowe)),
        ('skalowanie', StandardScaler()),
        ('model', LogisticRegression(max_iter=1000, random_state=42)),
    ])
    potok.fit(X_ucz[cechy_liczbowe], y_ucz)

• Pipeline przyjmuje listę par (nazwa_kroku, obiekt). Nazwy same wybierasz i przydadzą się za chwilę do zajrzenia do środka.
• **dodatkowe rozpakowuje słownik na argumenty nazwane. Przy pustym słowniku nie dodaje nic, przy {'fill_value': 0} dokłada fill_value=0.
• Jedno .fit() uruchamia wszystkie trzy kroki po kolei - imputer uczy się statystyk, skaler swoich, a model trenuje na gotowych danych.

Krok 4: co wstawił imputer

    wstawiona = potok.named_steps['uzupelnianie'].statistics_[
        cechy_liczbowe.index('SerumInsulin')
    ]

• potok.named_steps['uzupelnianie'] wyciąga z potoku krok o tej nazwie.
• .statistics_ to tablica wartości wstawianych - po jednej na kolumnę, w kolejności kolumn wejściowych.
• cechy_liczbowe.index('SerumInsulin') zwraca pozycję tej kolumny na liście, żeby trafić we właściwy element tablicy.

Krok 5: różnica w pacjentach

rozpietosc = tabela['skuteczność testowa'].max() - tabela['skuteczność testowa'].min()
print(f"... {rozpietosc:.4f} ({rozpietosc * len(X_test):.0f} pacjentów na {len(X_test)})")

Przeliczenie różnicy skuteczności na liczbę pacjentów jest ważniejsze, niż wygląda. Ułamek 0,006 brzmi abstrakcyjnie; „12 osób na 2000" mówi, o czym naprawdę rozmawiamy.

# Uwaga: X_ucz zawiera takze kolumne GrupaWiekowa (tekst), a te potoki obsluguja
# wylacznie liczby - dlatego wszedzie wybieramy X_ucz[cechy_liczbowe].

strategie = [
    ('mean', {}),
    ('median', {}),
    ('most_frequent', {}),
    ('constant', {'fill_value': 0}),
]

wyniki = []
for nazwa, dodatkowe in strategie:
    potok = Pipeline([
        ('uzupelnianie', SimpleImputer(strategy=nazwa, **dodatkowe)),
        ('skalowanie', StandardScaler()),
        ('model', LogisticRegression(max_iter=1000, random_state=42)),
    ])
    potok.fit(X_ucz[cechy_liczbowe], y_ucz)

    wstawiona = potok.named_steps['uzupelnianie'].statistics_[
        cechy_liczbowe.index('SerumInsulin')
    ]
    wyniki.append({
        'strategia': nazwa,
        'skuteczność testowa': potok.score(X_test[cechy_liczbowe], y_test),
        'wstawiana wartość (SerumInsulin)': wstawiona,
    })

tabela = pd.DataFrame(wyniki)
print(tabela.to_string(index=False, float_format=lambda v: f"{v:.4f}"))
print()
rozpietosc = tabela['skuteczność testowa'].max() - tabela['skuteczność testowa'].min()
print(f"Różnica między najlepszą a najgorszą strategią: {rozpietosc:.4f} "
      f"({rozpietosc * len(X_test):.0f} pacjentów na {len(X_test)})")

Czego się spodziewać:

    strategia  skuteczność testowa  wstawiana wartość (SerumInsulin)
         mean               0.7835                          140.3152
       median               0.7835                           86.0000
most_frequent               0.7795                           16.0000
     constant               0.7775                            0.0000

Różnica między najlepszą a najgorszą strategią: 0.0060 (12 pacjentów na 2000)

Jak to czytać:

Najpierw druga kolumna: cztery strategie wstawiają wartości od 0 do 140 - różnica rzędu stu czterdziestu jednostek insuliny. To ogromny rozrzut, jeśli chodzi o same wstawiane liczby.

A teraz pierwsza kolumna: skuteczność mieści się w przedziale od 0,7775 do 0,7835. Różnica to 12 pacjentów na 2000.

Co z tego wynika praktycznie: dobór strategii uzupełniania rzadko bywa tym, co decyduje o jakości modelu. Studenci potrafią spędzić nad tym wyborem godzinę, podczas gdy zysk jest w granicach szumu. Warto wybrać medianę (odporna na wartości skrajne) i zająć się rzeczami, które naprawdę mają wpływ.

Odpowiedź na pytanie o 'constant' z zerem: to najgorszy wynik z czwórki i nie jest to przypadek. Wstawiając zero, mówisz modelowi: „ten pacjent miał zerowy poziom insuliny" - a to fizjologicznie niemożliwe. Zamiast przyznać się do braku informacji, wpisujesz informację fałszywą. W ćwiczeniu 02 widziałeś dokładnie ten mechanizm od drugiej strony: tam zera udawały dane i trzeba je było wykryć. Tutaj sam byś je tam wstawił.

1. Napisz funkcję budującą potok, która przyjmuje skaler (albo None, gdy skalowania ma nie być).
2. Zbuduj trzy warianty: StandardScaler, MinMaxScaler i bez skalowania.
3. Naucz każdy, przechwytując ostrzeżenia o zbieżności.
4. Wypisz skuteczność, liczbę iteracji i liczbę ostrzeżeń dla każdego wariantu.
5. Wyciągnij z obu skalerów statystyki, których się nauczyły, i zestaw je w tabeli.

Czym różnią się oba skalery: StandardScaler odejmuje średnią i dzieli przez odchylenie standardowe - po przekształceniu cecha ma średnią 0 i odchylenie 1. MinMaxScaler ściska wartości do przedziału od 0 do 1, biorąc pod uwagę wyłącznie wartość najmniejszą i największą.

Dlaczego to ma znaczenie dla MinMaxScaler: skoro patrzy tylko na dwie skrajne wartości, jedna wartość odstająca ustawia całą skalę. StandardScaler jest pod tym względem odporniejszy.

Krok 1: funkcja budująca potok

def zbuduj(skaler):
    kroki = [('uzupelnianie', SimpleImputer(strategy='median'))]
    if skaler is not None:
        kroki.append(('skalowanie', skaler))
    kroki.append(('model', LogisticRegression(max_iter=1000, random_state=42)))
    return Pipeline(kroki)

Budujesz listę kroków stopniowo i dokładasz skalowanie tylko wtedy, gdy jest potrzebne. Dzięki temu jedna funkcja obsługuje wszystkie trzy warianty, łącznie z tym bez skalera.

Krok 3: przechwytywanie ostrzeżeń

with warnings.catch_warnings(record=True) as zlapane:
    warnings.simplefilter('always')
    potok.fit(X_ucz[cechy_liczbowe], y_ucz)
    ostrzezenia = [w for w in zlapane if issubclass(w.category, ConvergenceWarning)]

• catch_warnings(record=True) zbiera ostrzeżenia do listy zamiast wypisywać je na ekran.
• simplefilter('always') wyłącza domyślne zachowanie Pythona, który to samo ostrzeżenie pokazuje tylko raz.
• Filtrowanie po ConvergenceWarning wyłuskuje wyłącznie te dotyczące zbieżności.

Bez tego zabiegu ostrzeżenia z trzech wariantów zlałyby się w jedną kupkę i nie wiedziałbyś, który wariant je wywołał.

Krok 4: liczba iteracji

liczba_iteracji = potok.named_steps['model'].n_iter_[0]

n_iter_ mówi, ile kroków algorytm optymalizacji potrzebował, żeby się zatrzymać. To najciekawsza liczba w tym zadaniu - patrz niżej.

Krok 5: czego nauczyły się skalery

std = warianty['StandardScaler'].named_steps['skalowanie']
mm = warianty['MinMaxScaler'].named_steps['skalowanie']

statystyki = pd.DataFrame({
    'Standard: mean_': std.mean_,
    'Standard: scale_': std.scale_,
    'MinMax: data_min_': mm.data_min_,
    'MinMax: data_max_': mm.data_max_,
}, index=cechy_liczbowe)

Podkreślnik na końcu nazwy (mean_, scale_, data_min_) to konwencja scikit-learn: tak oznacza się to, czego obiekt nauczył się z danych. Atrybuty bez podkreślnika to ustawienia, które sam podałeś.

import warnings
from sklearn.exceptions import ConvergenceWarning

def zbuduj(skaler):
    kroki = [('uzupelnianie', SimpleImputer(strategy='median'))]
    if skaler is not None:
        kroki.append(('skalowanie', skaler))
    kroki.append(('model', LogisticRegression(max_iter=1000, random_state=42)))
    return Pipeline(kroki)

warianty = {
    'StandardScaler': zbuduj(StandardScaler()),
    'MinMaxScaler': zbuduj(MinMaxScaler()),
    'bez skalowania': zbuduj(None),
}

for nazwa, potok in warianty.items():
    # Przechwytujemy ostrzezenia, zeby bylo widac, KTORY wariant ich nie lubi
    with warnings.catch_warnings(record=True) as zlapane:
        warnings.simplefilter('always')
        potok.fit(X_ucz[cechy_liczbowe], y_ucz)
        ostrzezenia = [w for w in zlapane if issubclass(w.category, ConvergenceWarning)]

    wynik = potok.score(X_test[cechy_liczbowe], y_test)
    liczba_iteracji = potok.named_steps['model'].n_iter_[0]
    print(f"{nazwa:<16} skuteczność {wynik:.4f} | iteracji: {liczba_iteracji:>4} "
          f"| ostrzeżeń o zbieżności: {len(ostrzezenia)}")

# Czego nauczyl sie kazdy ze skalerow
std = warianty['StandardScaler'].named_steps['skalowanie']
mm = warianty['MinMaxScaler'].named_steps['skalowanie']

statystyki = pd.DataFrame({
    'Standard: mean_': std.mean_,
    'Standard: scale_': std.scale_,
    'MinMax: data_min_': mm.data_min_,
    'MinMax: data_max_': mm.data_max_,
}, index=cechy_liczbowe)

print(statystyki.round(3).to_string())
print()
print("Wszystkie te liczby zostały policzone WYŁĄCZNIE ze zbioru uczącego -")
print("potok nie miał okazji zobaczyć X_test podczas fit.")

Czego się spodziewać:

StandardScaler   skuteczność 0.7835 | iteracji:    6 | ostrzeżeń o zbieżności: 0
MinMaxScaler     skuteczność 0.7855 | iteracji:   19 | ostrzeżeń o zbieżności: 0
bez skalowania   skuteczność 0.7835 | iteracji:  134 | ostrzeżeń o zbieżności: 0

Jak to czytać - odpowiedź na pytanie 3 jest inna, niż sugeruje treść zadania:

Regresja logistyczna zbiegła się we wszystkich trzech wariantach i nie wypisała ani jednego ostrzeżenia. Skuteczność bez skalowania (0,7835) jest identyczna jak ze StandardScaler. Gdyby patrzeć tylko na pierwszą kolumnę, można by uznać, że skalowanie jest zbędne.

Prawdziwa różnica siedzi w kolumnie iteracji:

Bez skalowania algorytm potrzebuje ponad dwudziestu razy więcej kroków, żeby dojść do tego samego miejsca. Przy max_iter=1000 starczyło zapasu. Przy domyślnym max_iter=100 nie starczyłoby - i wtedy zobaczyłbyś ostrzeżenie oraz gorszy wynik.

Wniosek: skalowanie przy regresji logistycznej nie tyle poprawia wynik, co sprawia, że model w ogóle daje się wytrenować w rozsądnym czasie. Przy większych zbiorach i trudniejszych danych ta różnica przestaje być akademicka.

Druga rzecz do zauważenia - w tabeli statystyk SerumInsulin ma data_max_ równe 796, przy średniej 121. Jedna skrajna wartość ustawia całą skalę MinMaxScaler: po przekształceniu typowy pacjent wyląduje w okolicach 0,13, a cały dolny zakres zostanie ściśnięty. To jest praktyczny powód, dla którego StandardScaler jest domyślnym wyborem.

1. Zbuduj gałąź liczbową: uzupełnianie medianą + StandardScaler.
2. Wariant A: ColumnTransformer z dwiema gałęziami - liczbową i kategoryczną z OneHotEncoder.
3. Wariant B: zamień GrupaWiekowa na kolejne liczby przez .cat.codes i potraktuj wszystko jedną gałęzią liczbową.
4. Dla wariantu B potrzebny jest osobny podział danych, bo X ma inny zestaw kolumn.
5. Wypisz nazwy kolumn, które widzi model w wariancie A, oraz skuteczność obu wariantów.

Na czym polega problem: OneHotEncoder zamienia jedną kolumnę z czterema kategoriami na cztery kolumny zero-jedynkowe - po jednej na kategorię. Wariant B wpisuje zamiast tego liczby 0, 1, 2, 3, przez co model zakłada, że odległość między „młody" a „senior" wynosi 3, a między „młody" a „średni" - 1.

Krok 2: ColumnTransformer

przygotowanie_A = ColumnTransformer([
    ('liczbowe', galaz_liczbowa, cechy_liczbowe),
    ('kategoryczne', Pipeline([
        ('uzupelnianie', SimpleImputer(strategy='most_frequent')),
        ('kodowanie', OneHotEncoder(handle_unknown='ignore')),
    ]), cechy_kategoryczne),
])

• ColumnTransformer przyjmuje trójki: (nazwa, co_zrobić, na_których_kolumnach). To jego cała idea - różne kolumny, różne traktowanie.
• Dla kategorii uzupełniasz 'most_frequent', bo średniej z tekstu policzyć się nie da.
• handle_unknown='ignore' zabezpiecza przed kategorią, która pojawi się dopiero w danych testowych. Bez tego OneHotEncoder rzuciłby wyjątkiem w najmniej odpowiednim momencie - już po wdrożeniu.

Krok 3: wariant B

X_B = dane[cechy_liczbowe].copy()
X_B['GrupaWiekowa_kod'] = dane['GrupaWiekowa'].cat.codes

.cat.codes działa na kolumnach typu kategorycznego i zwraca numer każdej kategorii zgodnie z kolejnością ustaloną przy jej tworzeniu. Tutaj kolejność pochodzi z pd.cut, więc kody to młody=0, średni=1, starszy=2, senior=3.

.copy() jest istotne: bez niego dopisywałbyś kolumnę do wycinka oryginalnej ramki, co kończy się ostrzeżeniem SettingWithCopyWarning.

Krok 4: osobny podział

X_B_ucz, X_B_test, y_B_ucz, y_B_test = train_test_split(
    X_B, y, test_size=0.2, stratify=y, random_state=42
)

X_B ma inny zestaw kolumn niż X, więc potrzebuje własnego podziału. Te same stratify i random_state gwarantują, że do zbioru testowego trafią ci sami pacjenci - inaczej porównywałbyś dwie rzeczy naraz.

Krok 5: nazwy kolumn

print(potok_A.named_steps['przygotowanie'].get_feature_names_out().tolist())

get_feature_names_out() pokazuje, co naprawdę dostaje model po wszystkich przekształceniach. Warto to wywołać za każdym razem, gdy budujesz ColumnTransformer - to jedyny sposób, żeby zobaczyć efekt zamiast go sobie wyobrażać.

galaz_liczbowa = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='median')),
    ('skalowanie', StandardScaler()),
])

# --- WARIANT A: kodowanie zero-jedynkowe (poprawnie) ---
przygotowanie_A = ColumnTransformer([
    ('liczbowe', galaz_liczbowa, cechy_liczbowe),
    ('kategoryczne', Pipeline([
        ('uzupelnianie', SimpleImputer(strategy='most_frequent')),
        ('kodowanie', OneHotEncoder(handle_unknown='ignore')),
    ]), cechy_kategoryczne),
])

potok_A = Pipeline([('przygotowanie', przygotowanie_A),
                    ('model', LogisticRegression(max_iter=1000, random_state=42))])
potok_A.fit(X_ucz, y_ucz)

# --- WARIANT B: kategorie zamienione na kolejne liczby (podejscie, ktorego unikamy) ---
# .cat.codes nadaje kody zgodnie z kolejnoscia kategorii ustalona w pd.cut,
# czyli mlody=0, sredni=1, starszy=2, senior=3. To mapowanie jest STALE -
# nie jest niczego uczone z danych, wiec nie tworzy przecieku.
X_B = dane[cechy_liczbowe].copy()
X_B['GrupaWiekowa_kod'] = dane['GrupaWiekowa'].cat.codes

X_B_ucz, X_B_test, y_B_ucz, y_B_test = train_test_split(
    X_B, y, test_size=0.2, stratify=y, random_state=42
)

potok_B = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='median')),
    ('skalowanie', StandardScaler()),
    ('model', LogisticRegression(max_iter=1000, random_state=42)),
])
potok_B.fit(X_B_ucz, y_B_ucz)

print("Kolumny, które widzi model w wariancie A:")
print(" ", potok_A.named_steps['przygotowanie'].get_feature_names_out().tolist())
print()
print(f"A - OneHotEncoder (poprawnie):        {potok_A.score(X_test, y_test):.4f}")
print(f"B - kategorie jako 0/1/2/3 (unikamy): {potok_B.score(X_B_test, y_B_test):.4f}")
print()
print("Mapowanie użyte w wariancie B:")
print(dict(enumerate(dane['GrupaWiekowa'].cat.categories)))

Czego się spodziewać:

A - OneHotEncoder (poprawnie):        0.7920
B - kategorie jako 0/1/2/3 (unikamy): 0.7860

Mapowanie użyte w wariancie B:
{0: 'młody', 1: 'średni', 2: 'starszy', 3: 'senior'}

Kolumn po kodowaniu jest dwanaście: osiem liczbowych plus cztery zero-jedynkowe, po jednej na grupę wiekową.

Jak to czytać - i dlaczego wynik zaskakuje:

Wariant B wypadł gorzej, ale tylko o 0,6 punktu procentowego. Skoro robimy coś „źle", czemu kara jest tak mała?

Odpowiedź tkwi w pytaniu zadanym w treści: czy te kategorie mają naturalny porządek? Mają. Grupy wiekowe układają się w ciąg: młody < średni < starszy < senior. Kodując je jako 0, 1, 2, 3, przypadkiem powiedziałeś modelowi prawdę - że senior jest „dalej" od młodego niż średni.

Kiedy ten sam zabieg jest naprawdę groźny: gdy kategorie porządku nie mają. Zakoduj województwo jako 0-15, a model uzna, że dolnośląskie (0) i kujawsko-pomorskie (1) są sobie bliskie, a dolnośląskie i zachodniopomorskie (15) - odległe. To czysty wymysł, którego w danych nie ma.

Praktyczna zasada: OneHotEncoder stosuj domyślnie. Kodowanie numeryczne wolno zastosować tylko wtedy, gdy porządek istnieje naprawdę i gdy odstępy między kolejnymi kategoriami są sensownie porównywalne. W tym zadaniu uszło na sucho - ale uszło, a nie było poprawne.

1. Podziel cechy liczbowe na dwie grupy: skośne (SerumInsulin, TricepsThickness) i pozostałe.
2. Zbuduj trzy gałęzie: skośną (mediana + StandardScaler), pozostałą (średnia + MinMaxScaler) i kategoryczną (most_frequent + OneHotEncoder).
3. Złóż je w jeden ColumnTransformer.
4. Dołóż model i naucz cały potok.
5. Wypisz liczbę kolumn przed i po przygotowaniu, ich nazwy oraz skuteczność - i porównaj ją z wynikiem z zadania 3.

Dlaczego skośne osobno: SerumInsulin i TricepsThickness mają najwięcej braków i rozkłady z długim ogonem w prawo. Przy takim rozkładzie mediana jest uczciwszą „wartością typową" niż średnia, którą ogon zawyża.

Krok 1: podział cech na grupy

skosne = ['SerumInsulin', 'TricepsThickness']
pozostale = [k for k in cechy_liczbowe if k not in skosne]

Drugą listę wyliczasz, zamiast wypisywać ręcznie. Gdyby lista cech się zmieniła, kod nadal będzie poprawny - a wypisana ręcznie lista po cichu przestałaby się zgadzać.

Krok 2-3: trzy gałęzie w jednym transformatorze

przygotowanie = ColumnTransformer([
    ('skosne', galaz_skosna, skosne),
    ('pozostale', galaz_pozostala, pozostale),
    ('kategoryczne', galaz_kategoryczna, cechy_kategoryczne),
])

Każda gałąź to osobny Pipeline, a ColumnTransformer kieruje do niej wskazane kolumny. Wyniki wszystkich gałęzi zostają potem sklejone obok siebie w jedną tablicę - w kolejności, w jakiej wymieniłeś gałęzie.

Kolumny niewymienione w żadnej gałęzi są odrzucane. To domyślne zachowanie (remainder='drop') i warto o nim pamiętać: łatwo zgubić kolumnę, o której się zapomniało.

Krok 5: kontrola, co weszło i co wyszło

nazwy = potok_trzy_galezie.named_steps['przygotowanie'].get_feature_names_out()

print(f"Kolumn na wejściu:       {X_ucz.shape[1]}")
print(f"Kolumn po przygotowaniu: {len(nazwy)}")

Ta para liczb to najtańsza możliwa kontrola poprawności. Wchodzi 9 kolumn, wychodzi 12 - bo jedna kolumna kategoryczna zamieniła się w cztery. Gdyby wyszło mniej, znaczyłoby to, że któraś kolumna wypadła po drodze.

Prefiksy w nazwach (skosne__, pozostale__, kategoryczne__) pochodzą od nazw gałęzi i pozwalają sprawdzić, że każda kolumna trafiła tam, gdzie miała.

skosne = ['SerumInsulin', 'TricepsThickness']
pozostale = [k for k in cechy_liczbowe if k not in skosne]

galaz_skosna = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='median')),
    ('skalowanie', StandardScaler()),
])

galaz_pozostala = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='mean')),
    ('skalowanie', MinMaxScaler()),
])

galaz_kategoryczna = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='most_frequent')),
    ('kodowanie', OneHotEncoder(handle_unknown='ignore')),
])

przygotowanie = ColumnTransformer([
    ('skosne', galaz_skosna, skosne),
    ('pozostale', galaz_pozostala, pozostale),
    ('kategoryczne', galaz_kategoryczna, cechy_kategoryczne),
])

potok_trzy_galezie = Pipeline([
    ('przygotowanie', przygotowanie),
    ('model', LogisticRegression(max_iter=1000, random_state=42)),
])

potok_trzy_galezie.fit(X_ucz, y_ucz)

nazwy = potok_trzy_galezie.named_steps['przygotowanie'].get_feature_names_out()

print(f"Kolumn na wejściu:       {X_ucz.shape[1]}")
print(f"Kolumn po przygotowaniu: {len(nazwy)}")
print()
print("Kolumny trafiające do modelu (w kolejności gałęzi):")
for n in nazwy:
    print("  -", n)
print()
print(f"Skuteczność testowa (trzy gałęzie): {potok_trzy_galezie.score(X_test, y_test):.4f}")
print(f"Dla porównania - jedna gałąź liczbowa (zadanie 3, wariant A): "
      f"{potok_A.score(X_test, y_test):.4f}")

Czego się spodziewać:

Kolumn na wejściu:       9
Kolumn po przygotowaniu: 12

Skuteczność testowa (trzy gałęzie): 0.7925
Dla porównania - jedna gałąź liczbowa (zadanie 3, wariant A): 0.7920

Jak to czytać:

Trzy starannie dobrane gałęzie dały 0,0005 przewagi - czyli jednego pacjenta na dwa tysiące. Praktycznie nic.

To nie jest porażka zadania, tylko jego pointa. Warto z niej wyciągnąć dwie rzeczy:

1. Umiesz już zbudować dowolnie złożone przygotowanie danych. ColumnTransformer z trzema gałęziami, z których każda jest osobnym potokiem, to konstrukcja, która w prawdziwym projekcie obsłuży dane mieszane: liczby, kategorie, daty, tekst.

2. Złożoność nie jest sama w sobie zaletą. Ten potok jest trudniejszy do napisania, trudniejszy do przeczytania i trudniejszy do naprawienia, gdy coś przestanie działać - a daje tyle samo. Zanim dołożysz kolejną gałąź, warto sprawdzić prostszą wersję i mieć liczbę do porównania.

Są dane, przy których taki podział daje realną przewagę - zwykle wtedy, gdy kolumny różnią się naprawdę zasadniczo (ceny obok ocen w skali 1-5 obok znaczników zero-jedynkowych). Tutaj wszystkie cechy to pomiary medyczne o zbliżonym charakterze, więc jednolite traktowanie im wystarcza.

1. Przepisz kod z zadania bez zmian - tak, żeby dało się go uruchomić i zmierzyć.
2. Napisz wersję poprawną: najpierw podział, potem Pipeline z tymi samymi krokami.
3. Uruchom obie i wypisz wyniki oraz różnicę.
4. Wyciągnij z obu imputerów wartość, której się nauczyły dla SerumInsulin, i porównaj je.

Gdzie są te dwa przecieki: imputer.fit_transform(X_zle) i skaler.fit_transform(X_zle) wykonują się przed train_test_split. Każde fit uczy się czegoś z danych - imputer uczy się mediany, skaler średniej i odchylenia. Skoro liczą je z całego zbioru, to do przekształcenia danych uczących trafia informacja pochodząca z wierszy, które później znajdą się w zbiorze testowym.

Dlaczego to nazywamy przeciekiem, a nie błędem obliczeniowym: kod wykonuje się poprawnie i daje sensowny wynik. Problem polega na tym, że ten wynik jest zawyżony w sposób niemożliwy do odtworzenia na prawdziwie nowych danych - bo tam nikt nie da Ci wcześniej zajrzeć do przyszłych pomiarów.

Krok 2: wersja poprawna

X_ok_u, X_ok_t, y_ok_u, y_ok_t = train_test_split(X_ok, y_ok, test_size=0.2,
                                                  stratify=y_ok, random_state=42)

potok_ok = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='median')),
    ('skalowanie', StandardScaler()),
    ('model', LogisticRegression(max_iter=1000, random_state=42)),
])
potok_ok.fit(X_ok_u, y_ok_u)

Zwróć uwagę na kolejność: podział, potem potok. Pipeline sam zadba o resztę - podczas .fit() uczy imputer i skaler wyłącznie na danych uczących, a podczas .score() stosuje te same wyuczone wartości do danych testowych, bez ponownego uczenia.

Na tym polega cała wartość potoku. Nie chodzi o skrócenie zapisu, tylko o to, że nie da się w nim przypadkiem nauczyć czegoś na danych testowych.

Krok 4: porównanie statystyk

i_zly = imputer.statistics_[cechy_liczbowe.index('SerumInsulin')]
i_ok = potok_ok.named_steps['uzupelnianie'].statistics_[cechy_liczbowe.index('SerumInsulin')]

To jest właściwy dowód w tym zadaniu. Porównujesz nie wyniki modeli, tylko liczby, których nauczyły się imputery - jeden z całego zbioru, drugi tylko z części uczącej.

# --- WERSJA Z PRZECIEKIEM (kod z zadania, przepisany bez zmian) ---
X_zle = dane[cechy_liczbowe]
y_zle = dane[ETYKIETA]

imputer = SimpleImputer(strategy='median')
X_zle = pd.DataFrame(imputer.fit_transform(X_zle), columns=cechy_liczbowe)

skaler = StandardScaler()
X_zle = pd.DataFrame(skaler.fit_transform(X_zle), columns=cechy_liczbowe)

X_u, X_t, y_u, y_t = train_test_split(X_zle, y_zle, test_size=0.2,
                                      stratify=y_zle, random_state=42)

model_zly = LogisticRegression(max_iter=1000, random_state=42)
model_zly.fit(X_u, y_u)
wynik_zly = model_zly.score(X_t, y_t)

# --- WERSJA POPRAWNA: najpierw podzial, potem Pipeline ---
X_ok = dane[cechy_liczbowe]
y_ok = dane[ETYKIETA]

X_ok_u, X_ok_t, y_ok_u, y_ok_t = train_test_split(X_ok, y_ok, test_size=0.2,
                                                  stratify=y_ok, random_state=42)

potok_ok = Pipeline([
    ('uzupelnianie', SimpleImputer(strategy='median')),
    ('skalowanie', StandardScaler()),
    ('model', LogisticRegression(max_iter=1000, random_state=42)),
])
potok_ok.fit(X_ok_u, y_ok_u)
wynik_ok = potok_ok.score(X_ok_t, y_ok_t)

print(f"Z przeciekiem: {wynik_zly:.4f}")
print(f"Poprawnie:     {wynik_ok:.4f}")
print(f"Różnica:       {wynik_zly - wynik_ok:+.4f}")
print()
print("Statystyki wyuczone przez oba imputery (SerumInsulin):")
i_zly = imputer.statistics_[cechy_liczbowe.index('SerumInsulin')]
i_ok = potok_ok.named_steps['uzupelnianie'].statistics_[cechy_liczbowe.index('SerumInsulin')]
print(f"  z całego zbioru (przeciek):  {i_zly:.4f}")
print(f"  tylko ze zbioru uczącego:    {i_ok:.4f}")
print(f"  różnica:                     {abs(i_zly - i_ok):.4f}")

Czego się spodziewać:

Z przeciekiem: 0.7835
Poprawnie:     0.7835
Różnica:       +0.0000

Statystyki wyuczone przez oba imputery (SerumInsulin):
  z całego zbioru (przeciek):  86.0000
  tylko ze zbioru uczącego:    86.0000
  różnica:                     0.0000

Jak to czytać - i uwaga, to jest najtrudniejszy wniosek w tym notatniku:

Przeciek nie zmienił absolutnie nic. Ani jednej cyfry. Mediana policzona z 10 000 wierszy i mediana policzona z 8000 wierszy wyszły identyczne - obie równe 86.

Odpowiedź na pytanie z treści („czy różnica jest na tyle duża, żeby ją zauważyć?") brzmi więc: nie, i to jest dokładnie powód, dla którego przecieki są groźne.

Trzy rzeczy, które trzeba stąd wynieść:

1. To, że nie widać skutku, nie znaczy, że kod jest poprawny. Kod jest błędny metodologicznie niezależnie od tego, jaką liczbę wypisał. Przy 10 000 wierszy i medianie zabrakło po prostu miejsca, żeby błąd się ujawnił.

2. Nie da się wykryć przecieku przez porównanie wyników. Gdybyś nie miał wersji poprawnej obok, nie miałbyś żadnego sygnału. Przecieki wykrywa się czytając kod, a konkretnie: szukając każdego fit wykonanego przed podziałem danych.

3. Ta sama pomyłka przy innych danych kosztuje naprawdę. Zmień medianę na średnią, zmniejsz zbiór do dwustu wierszy albo dołóż selekcję cech przed podziałem, a różnica zrobi się wyraźna. Zadanie 7 pokazuje dokładnie, od czego to zależy.

Zasada praktyczna: każde fit, fit_transform albo fit_predict wykonane przed train_test_split to przeciek - niezależnie od tego, czy widać go w wynikach.

1. Znajdź wiersze, w których SerumInsulin jest brakiem.
2. Odczytaj prawdziwe wartości tych wierszy z dane_czyste.
3. Dla strategii 'mean' i 'median' sprawdź, jaką wartość wstawia imputer.
4. Policz błąd bezwzględny każdej wstawionej wartości względem prawdy: średni, medianę i największy.
5. Policz odchylenie standardowe prawdziwych wartości i wyraź w nim średni błąd.
6. Narysuj histogram prawdy z zaznaczonymi wartościami wstawianymi przez obie strategie.

Uwaga metodologiczna: tutaj dopasowujesz imputer na całej kolumnie, co w zwykłym potoku byłoby przeciekiem. Tu jest w porządku, bo nie budujesz modelu - prowadzisz analizę diagnostyczną jakości samego uzupełniania. Gdyby wynik miał trafić do modelu, obowiązywałby fit wyłącznie na zbiorze uczącym.

Dlaczego to rzadka okazja: normalnie nie znasz wartości, których brakuje - gdybyś je znał, nie byłyby brakami. Tutaj zostały usunięte sztucznie, więc możesz sprawdzić, jak daleko od prawdy jest uzupełnienie.

Krok 1-2: braki i prawda

maska_brakow = dane['SerumInsulin'].isna()
prawda = dane_czyste.loc[maska_brakow, 'SerumInsulin'].to_numpy()

• .isna() daje kolumnę True/False - True tam, gdzie jest brak.
• Ta sama maska zastosowana do dane_czyste wybiera te same wiersze, ale z wersji sprzed uszkodzenia. Obie ramki mają identyczny indeks, więc wiersze odpowiadają sobie co do jednego.
• .to_numpy() zamienia wynik na tablicę, żeby dalsze odejmowanie odbywało się po pozycjach, bez dopasowywania po indeksie.

Krok 3-4: błędy

for strategia in ['mean', 'median']:
    imp = SimpleImputer(strategy=strategia).fit(dane[['SerumInsulin']])
    wstawiona = imp.statistics_[0]
    blad = np.abs(prawda - wstawiona)

• dane[['SerumInsulin']] z podwójnym nawiasem daje ramkę z jedną kolumną, a nie pojedynczą kolumnę. SimpleImputer oczekuje dwuwymiarowego wejścia.
• prawda - wstawiona odejmuje jedną liczbę od całej tablicy naraz. np.abs bierze wartość bezwzględną, bo interesuje nas wielkość pomyłki, nie jej kierunek.
• Poza średnią warto policzyć medianę błędu (odporna na skrajne przypadki) i największy błąd (pokazuje najgorszy scenariusz).

Krok 5: błąd w jednostkach naturalnej zmienności

odchylenie = prawda.std()
print(f"średni błąd to {w['średni błąd bezwzględny'] / odchylenie:.2f} odchylenia standardowego cechy")

To najważniejsze przeliczenie w zadaniu. Sam błąd „96 jednostek" nic nie mówi, dopóki nie wiesz, jak bardzo ta cecha się waha. Podzielenie przez odchylenie standardowe daje liczbę, którą da się zinterpretować.

# Uwaga metodologiczna: tutaj NIE budujemy modelu, tylko oceniamy jakosc samego
# uzupelniania. Dlatego wolno dopasowac imputer na calej kolumnie - to analiza
# diagnostyczna, a nie czesc procedury uczenia. Gdyby wynik mial trafic do modelu,
# obowiazywalby fit wylacznie na zbiorze uczacym.

maska_brakow = dane['SerumInsulin'].isna()
prawda = dane_czyste.loc[maska_brakow, 'SerumInsulin'].to_numpy()

print(f"Braków w SerumInsulin: {maska_brakow.sum()} z {len(dane)} "
      f"({maska_brakow.mean():.1%})")
print()

wiersze = []
for strategia in ['mean', 'median']:
    imp = SimpleImputer(strategy=strategia).fit(dane[['SerumInsulin']])
    wstawiona = imp.statistics_[0]
    blad = np.abs(prawda - wstawiona)
    wiersze.append({
        'strategia': strategia,
        'wstawiana wartość': wstawiona,
        'średni błąd bezwzględny': blad.mean(),
        'mediana błędu': np.median(blad),
        'największy błąd': blad.max(),
    })

odchylenie = prawda.std()
srednia_prawdy = prawda.mean()

tabela_bledow = pd.DataFrame(wiersze)
print(tabela_bledow.to_string(index=False, float_format=lambda v: f"{v:.2f}"))
print()
print(f"Prawdziwe wartości w brakujących komórkach: średnia {srednia_prawdy:.2f}, "
      f"odchylenie standardowe {odchylenie:.2f}")
print(f"Zakres: od {prawda.min():.2f} do {prawda.max():.2f}")
print()
for w in wiersze:
    print(f"  strategia '{w['strategia']}': średni błąd to "
          f"{w['średni błąd bezwzględny'] / odchylenie:.2f} odchylenia standardowego cechy")

# Obrazek, ktory domyka to zadanie: prawda kontra to, co wstawilismy
fig, ax = plt.subplots(figsize=(9, 5))
ax.hist(prawda, bins=40, color='#55A868', edgecolor='white',
        label='prawdziwe wartości brakujących komórek')
for w, kolor in zip(wiersze, ['#4C72B0', '#C44E52']):
    ax.axvline(w['wstawiana wartość'], color=kolor, linestyle='--', linewidth=2,
               label=f"wstawiane przez strategy='{w['strategia']}'")
ax.set_xlabel('SerumInsulin')
ax.set_ylabel('liczba pacjentów')
ax.set_title('Jedna liczba zamiast całego rozkładu')
ax.legend()
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Czego się spodziewać:

Braków w SerumInsulin: 3555 z 10000 (35.5%)

strategia  wstawiana wartość  średni błąd bezwzględny  mediana błędu  największy błąd
     mean             140.11                   101.85          93.89           654.89
   median              86.00                    96.38          62.00           709.00

Prawdziwe wartości w brakujących komórkach: średnia 137.67, odchylenie standardowe 133.55
Zakres: od 14.00 do 795.00

  strategia 'mean': średni błąd to 0.76 odchylenia standardowego cechy
  strategia 'median': średni błąd to 0.72 odchylenia standardowego cechy

Jak to czytać - odpowiedź na pytanie końcowe:

Średni błąd wynosi około 0,72-0,76 odchylenia standardowego cechy. To bardzo dużo. Dla porównania: gdybyś zamiast uzupełniać, losował wartość z rozkładu tej cechy, błąd wyniósłby około 1,0 odchylenia. Uzupełnianie jedną liczbą jest więc lepsze od losowania o jakieś 25% - i to wszystko.

Największy pojedynczy błąd to 709 jednostek, przy prawdziwym zakresie od 14 do 795. Dla tego jednego pacjenta wstawiona wartość nie ma nic wspólnego z rzeczywistością.

Na wykresie widać to jeszcze wyraźniej: prawdziwe wartości rozkładają się szeroko od 14 do 795, a obie strategie zastępują cały ten rozkład jedną pionową kreską.

Co to mówi o wartości informacyjnej uzupełnionych komórek:

Uzupełnianie nie odzyskuje informacji. Ono tylko pozwala modelowi dalej działać - wypełnia dziurę czymś, co nie wywróci obliczeń. Po uzupełnieniu 35,5% wierszy w tej kolumnie jedna trzecia wartości jest zmyślona, choć wygląda dokładnie jak reszta.

Praktyczne konsekwencje:

• Przy tak dużym udziale braków warto rozważyć dodatkową kolumnę zero-jedynkową „ta wartość była brakiem" (SimpleImputer(add_indicator=True)). Sam fakt braku bywa informacją: badania nie zlecono, bo pacjent nie budził podejrzeń.
• Mediana wypada nieco lepiej od średniej (0,72 wobec 0,76 odchylenia), co zgadza się z tym, co wiesz o rozkładzie skośnym.
• Najlepszym rozwiązaniem problemu braków jest ich niepowstanie. Rozmowa z osobą zbierającą dane bywa skuteczniejsza od każdej strategii uzupełniania.

1. Ustal siatkę ustawień: cztery rozmiary zbioru i trzy udziały braków.
2. Dla każdej kombinacji wykonaj co najmniej 40 powtórzeń z różnymi ziarnami.
3. Dla każdego powtórzenia policz różnicę: wynik z przeciekiem minus wynik poprawny.
4. Zapisz średnią różnicę, jej odchylenie standardowe i błąd standardowy średniej.
5. Policz, ile błędów standardowych ma średnia różnica - to mówi, czy w ogóle coś zmierzyłeś.
6. Narysuj wykres ze słupkami błędu.

Czym jest błąd standardowy średniej: odchylenie standardowe podzielone przez pierwiastek z liczby powtórzeń. Mówi, jak bardzo sama średnia mogłaby się zmienić, gdybyś powtórzył cały eksperyment. Jeśli średnia różnica jest mniejsza niż jeden-dwa błędy standardowe, nie masz podstaw twierdzić, że różnica istnieje.

Uwaga na czas: 4 × 3 × 40 = 480 eksperymentów, każdy trenuje dwa modele. Na typowym laptopie to od jednej do trzech minut.

Krok 2-3: powtórzenia i różnice

pary = np.array([eksperyment_przeciek(n, udzial, z) for z in range(POWTORZENIA)])
roznice = pary[:, 1] - pary[:, 0]          # z przeciekiem minus poprawnie

• Funkcja zwraca parę wyników, więc pary jest tablicą o kształcie (40, 2).
• pary[:, 0] to kolumna wyników poprawnych, pary[:, 1] - z przeciekiem. Odejmowanie działa wiersz po wierszu, więc dostajesz 40 różnic z tego samego podziału danych.
• Porównywanie w parach jest tu kluczowe: obie wersje dostają identyczne dane, więc różnica pochodzi wyłącznie z przecieku, a nie z innego losowania.

Krok 4: trzy miary rozrzutu

'srednia_roznica': roznice.mean(),
'odchylenie_roznic': roznice.std(ddof=1),
'blad_standardowy': roznice.std(ddof=1) / np.sqrt(POWTORZENIA),

ddof=1 to poprawka na to, że liczysz odchylenie z próbki, a nie z całej populacji. Przy 40 powtórzeniach różnica jest niewielka, ale to poprawny zapis.

Krok 5: czy to w ogóle pomiar

siatka['ile_bledow_std'] = siatka['srednia_roznica'] / siatka['blad_standardowy']

Ta jedna kolumna decyduje o wnioskach z całego zadania. Wartość poniżej 2 oznacza, że zmierzona różnica mieści się w zwykłym rozrzucie - czyli nie masz prawa twierdzić, że cokolwiek wykryłeś.

Krok 6: słupki błędu

ax.errorbar(czesc['n_probek'], czesc['srednia_roznica'],
            yerr=czesc['blad_standardowy'], marker='o', capsize=4, ...)
ax.axhline(0, color='gray', linewidth=1)

errorbar rysuje punkt wraz z pionowym odcinkiem niepewności. Pozioma linia w zerze jest tu niezbędna: słupek przecinający zero znaczy „brak dowodu na różnicę".

# UWAGA NA CZAS: 4 rozmiary x 3 udzialy brakow x 40 powtorzen = 480 eksperymentow,
# a kazdy trenuje dwa modele. Na typowym laptopie to okolo 1-3 minut.
# Gdyby bylo za wolno, ogranicz POWTORZENIA do 40 (minimum z tresci zadania)
# albo usun 2000 z listy rozmiarow.

ROZMIARY = [60, 120, 400, 2000]
UDZIALY = [0.1, 0.3, 0.6]
POWTORZENIA = 40

wiersze = []
for n in ROZMIARY:
    for udzial in UDZIALY:
        pary = np.array([eksperyment_przeciek(n, udzial, z) for z in range(POWTORZENIA)])
        roznice = pary[:, 1] - pary[:, 0]          # z przeciekiem minus poprawnie
        wiersze.append({
            'n_probek': n,
            'udzial_brakow': udzial,
            'poprawnie': pary[:, 0].mean(),
            'z_przeciekiem': pary[:, 1].mean(),
            'srednia_roznica': roznice.mean(),
            'odchylenie_roznic': roznice.std(ddof=1),
            'blad_standardowy': roznice.std(ddof=1) / np.sqrt(POWTORZENIA),
        })

siatka = pd.DataFrame(wiersze)

# Prosta miara "czy to w ogole pomiar": ile bledow standardowych ma srednia roznica
siatka['ile_bledow_std'] = siatka['srednia_roznica'] / siatka['blad_standardowy']

print(siatka.to_string(index=False, float_format=lambda v: f"{v:.4f}"))

fig, ax = plt.subplots(figsize=(9, 5.5))
for udzial in UDZIALY:
    czesc = siatka[siatka['udzial_brakow'] == udzial]
    ax.errorbar(czesc['n_probek'], czesc['srednia_roznica'],
                yerr=czesc['blad_standardowy'], marker='o', capsize=4,
                label=f'braki: {udzial:.0%}')

ax.axhline(0, color='gray', linewidth=1)
ax.set_xscale('log')
ax.set_xlabel('liczba próbek (skala logarytmiczna)')
ax.set_ylabel('średnia różnica: z przeciekiem minus poprawnie')
ax.set_title('Skala przecieku maleje wraz z wielkością zbioru')
ax.legend()
ax.grid(alpha=0.3)
plt.tight_layout()
plt.show()

print("Słupki błędu to błąd standardowy średniej. Tam, gdzie słupek przecina zero,")
print("nie ma podstaw, żeby twierdzić, że cokolwiek zmierzono.")

Czego się spodziewać:

 n_probek  udzial_brakow  poprawnie  z_przeciekiem  srednia_roznica  odchylenie_roznic  blad_standardowy  ile_bledow_std
       60         0.1000     0.7556         0.7583           0.0028             0.0176            0.0028          1.0000
       60         0.3000     0.7583         0.7611           0.0028             0.0216            0.0034          0.8130
       60         0.6000     0.7556         0.7639           0.0083             0.0268            0.0042          1.9640
      120         0.1000     0.7444         0.7438          -0.0007             0.0117            0.0019         -0.3739
      120         0.3000     0.7389         0.7410           0.0021             0.0097            0.0015          1.3556
      120         0.6000     0.7326         0.7312          -0.0014             0.0153            0.0024         -0.5725
      400         0.1000     0.7656         0.7650          -0.0006             0.0029            0.0005         -1.3556
      400         0.3000     0.7640         0.7635          -0.0004             0.0032            0.0005         -0.8130
      400         0.6000     0.7629         0.7637           0.0008             0.0032            0.0005          1.6690
     2000         0.1000     0.7769         0.7769           0.0000             0.0008            0.0001          0.0000
     2000         0.3000     0.7745         0.7744          -0.0001             0.0008            0.0001         -0.6276
     2000         0.6000     0.7707         0.7703          -0.0004             0.0014            0.0002         -1.8829

Jak to czytać - i uwaga, wnioski są ostrożniejsze, niż sugeruje treść zadania:

Pytanie 1 - czy przeciek rośnie, gdy danych jest mniej? Najsilniejszy efekt wystąpił przy n=60 i 60% braków: różnica +0,0083 przy ile_bledow_std = 1,96. To jedyny wiersz zbliżający się do progu wiarygodności. Kierunek zgadza się z oczekiwaniem, ale jeden wiersz na dwanaście to za mało, żeby ogłosić prawidłowość.

Pytanie 2 - czy rośnie z udziałem braków? Przy n=60 owszem: 0,0028 → 0,0028 → 0,0083. Przy pozostałych rozmiarach nie widać żadnego porządku, a połowa różnic jest ujemna - czyli wersja z przeciekiem wypadła gorzej, co nie ma sensu merytorycznego i jest po prostu szumem.

Pytanie 3 - kiedy różnica przestaje być odróżnialna od szumu? Praktycznie od razu. Tylko jeden z dwunastu wierszy przekracza 1,9 błędu standardowego; w pozostałych jedenastu słupek błędu przecina zero.

Najważniejszy wniosek - i nie jest to wniosek o przecieku:

Uczciwa odpowiedź na to zadanie brzmi: przy tych ustawieniach nie udało się wiarygodnie zmierzyć skutku przecieku. Widać jedynie słabą przesłankę, że przy bardzo małych zbiorach i dużym udziale braków efekt istnieje.

To jest prawdziwy wynik, a nie porażka. Kolumna odchylenie_roznic pokazuje, dlaczego: przy n=60 pojedyncze pomiary rozrzucone są o 0,027, czyli trzy razy mocniej niż mierzony efekt. Przy 40 powtórzeniach szum nie zdąży się uśrednić.

Gdybyś wypisał samą kolumnę srednia_roznica i ogłosił „przeciek zawyża wynik o 0,8 punktu procentowego przy małych zbiorach", popełniłbyś błąd, który w nauce zdarza się nagminnie: podanie średniej bez informacji o jej niepewności.

I nie zmienia to niczego w ocenie samego przecieku. Nie unikamy go dlatego, że zawyża wynik o mierzalną wartość - tylko dlatego, że procedura pomiaru przestaje być uczciwa. Zadanie 5 pokazało przeciek o efekcie dokładnie zerowym i nadal był to błąd.