P-programowanie P-programowanie
  • Języki programowania
  • Nauka i praca
  • Porady
  • Więcej niż programowanie
ARTYKUŁ: Wprowadzenie do machine learning w Pythonie – pierwsze kroki z scikit-learn
Udostępnij
P-programowanieP-programowanie
Font ResizerAa
Wyszukiwarka
  • Języki programowania
  • Nauka i praca
  • Porady
  • Więcej niż programowanie
Social media
Copyright © P-programowanie.
Języki programowaniaPorady

Wprowadzenie do machine learning w Pythonie – pierwsze kroki z scikit-learn

Miłosz Kenig
przez Miłosz Kenig
Aktualizacja: 2026-11-16
10 min. czytania
Pracownik zatrudniony przez konkurenta do szpiegowania informacji górniczych z serwerów firmy
Udostępnij

Uczenie maszynowe stało się kluczową umiejętnością dla specjalistów danych i inżynierów oprogramowania, którzy chcą wydobywać wartość z danych i budować systemy poprawiające się w czasie.

Spis treści
  • Zrozumienie podstaw uczenia maszynowego
  • Instalacja i konfiguracja scikit-learn
  • Kluczowe koncepcje i terminologia
  • Przepływ pracy uczenia maszynowego w Pythonie
  • Budowa pierwszego modelu ze scikit-learn
  • Przygotowanie i wstępne przetwarzanie danych
  • Najważniejsze algorytmy i modele
  • Ewaluacja i walidacja modeli
  • Typowe błędy i dobre praktyki
  • Budowa systemów uczenia maszynowego gotowych do produkcji

Python dominuje dzięki bogatemu ekosystemowi bibliotek, a scikit-learn wyróżnia się jako przejrzysty framework do budowania, trenowania i oceny modeli. To idealny pierwszy krok dla osób zaczynających praktykę ML w Pythonie.

Zrozumienie podstaw uczenia maszynowego

W ML zamiast pisać reguły, model uczy się wzorców z danych i wykorzystuje je do przewidywania nowych przypadków. To podejście błyszczy tam, gdzie reguły są trudne lub niemożliwe do zaprogramowania (np. obrazy, język, prognozy).

Aby szybko uchwycić fundamenty, zapamiętaj trzy kluczowe pojęcia:

  • cechy (features) – atrybuty wejściowe zawierające informację predykcyjną;
  • etykiety (cele, labels) – wartości, które chcemy przewidywać;
  • inżynieria cech – tworzenie, łączenie i selekcja zmiennych maksymalizujących moc predykcyjną.

Kompromis bias–variance to najważniejsza rama myślowa: zbyt prosty model (wysoki bias) niedouczy się, a zbyt złożony (wysoka wariancja) przeuczy się. Optimum leży pośrodku — uchwycić prawdziwe zależności, ignorując szum.

Instalacja i konfiguracja scikit-learn

Aby zacząć, upewnij się, że spełniasz wymagania i rozumiesz kluczowe zależności biblioteki:

  • Python 3.11+ – minimalna wspierana wersja interpretera;
  • NumPy – szybkie operacje na tablicach i funkcje matematyczne;
  • SciPy – algorytmy naukowe i zaawansowane struktury danych;
  • joblib – efektywne zapisywanie i ładowanie modeli;
  • threadpoolctl – kontrola wielowątkowości operacji numerycznych.

Rekomendujemy instalację w wirtualnym środowisku. Aby zainstalować pakiet poleceniem pip, użyj:

pip install -U scikit-learn

Alternatywnie, korzystając z conda (kanał conda-forge):

conda install -c conda-forge scikit-learn

Po instalacji zweryfikuj środowisko poleceniem:

python -c "import sklearn; sklearn.show_versions()"

Spójna struktura importów ułatwia naukę. Przykład importu:

from sklearn import datasets

Kluczowe koncepcje i terminologia

Scikit-learn opiera się na jednolitym interfejsie estymatorów — każdy komponent inicjalizujesz hiperparametrami, uczysz metodą fit(), a następnie wywołujesz predict() lub transform(). Raz opanowany schemat przenosi się na dziesiątki algorytmów.

Oto trzy główne rodziny estymatorów:

  • estymatory nadzorowane – implementują fit(X, y) i predict(X) (np. klasyfikatory, regresory);
  • estymatory nienadzorowane – implementują fit(X) i często predict(X) (np. klasteryzacja);
  • transformery – implementują fit(X, y) i transform(X) do przetwarzania wstępnego.

Rozróżniaj parametry (uczone z danych) i hiperparametry (ustawienia procesu uczenia). Skuteczne strojenie hiperparametrów często przesądza o jakości rozwiązania.

Train–test split chroni przed zawyżoną oceną: trenujesz na treningu, a jakość mierzysz na odłożonym zbiorze testowym. Typowy podział to 70–80% trening i 20–30% test.

Przepływ pracy uczenia maszynowego w Pythonie

Poniżej znajdziesz klarowną ścieżkę od problemu do wdrożenia:

  1. Krok 1 – definicja problemu i danych: doprecyzuj typ zadania (klasyfikacja, regresja, klasteryzacja), kryteria sukcesu oraz źródła danych;
  2. Krok 2 – eksploracyjna analiza danych (EDA): sprawdź rozkłady, braki, odstające, zależności i wizualizacje, by zrozumieć strukturę;
  3. Krok 3 – przygotowanie i wstępne przetwarzanie: imputacja braków, kodowanie kategorii, skalowanie liczb, usuwanie zbędnych cech; to etap o największym wpływie na końcowe wyniki;
  4. Krok 4 – inżynieria cech: twórz nowe cechy i selekcjonuj najistotniejsze, by poprawić jakość i wydajność;
  5. Krok 5 – wybór i trening modelu: zacznij prosto (regresja liniowa/logistyczna, drzewa), potem stopniowo zwiększaj złożoność;
  6. Krok 6 – ewaluacja: oceniaj na zbiorze testowym i walidacji krzyżowej właściwymi metrykami;
  7. Krok 7 – strojenie hiperparametrów: grid/randomized search z walidacją krzyżową, monitoruj przeuczenie;
  8. Krok 8 – końcowa ocena i wdrożenie: test na odłożonych danych, dokumentacja, kontrola wersji i publikacja modelu.

Budowa pierwszego modelu ze scikit-learn

Na start użyj zbioru Iris — jest czysty, mały i wbudowany w scikit-learn. Najpierw wczytaj dane i podejrzyj ich strukturę:

from sklearn.datasets import load_iris
import numpy as np

iris = load_iris()
X = iris.data # cechy: pomiary kwiatów
y = iris.target # cel: etykiety gatunków

print("Nazwy cech:", iris.feature_names)
print("Nazwy klas:", iris.target_names)
print("Kształt danych:", X.shape) # 150 próbek, 4 cechy

Następnie podziel dane na trening i test, aby uczciwie mierzyć generalizację:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

Teraz utwórz i wytrenuj model:

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

RandomForestClassifier łączy wiele drzew decyzyjnych, co zwykle zwiększa stabilność i dokładność.

Na końcu dokonaj predykcji i oceń wyniki:

from sklearn.metrics import accuracy_score, classification_report

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print(f"Trafność: {accuracy:.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Raport klasyfikacji pokazuje precision, recall i F1 dla każdej klasy — daje pełniejszy obraz niż sama trafność.

Przygotowanie i wstępne przetwarzanie danych

Przygotowanie danych często zajmuje 60–80% czasu projektu i w największym stopniu determinuje końcowe wyniki.

Najważniejsze zadania przetwarzania warto ująć w krótką checklistę:

  • obsługa braków – usuwanie wybranych obserwacji lub imputacja (średnia, mediana, k‑NN, wielokrotna imputacja);
  • skalowanie i normalizacja – StandardScaler (średnia 0, odchylenie 1) lub MinMaxScaler (np. [0, 1]);
  • kodowanie kategorii – label encoding (ryzyko porządku), one‑hot encoding (bez porządku, rośnie wymiar), ewentualnie target encoding;
  • selekcja cech – metryki statystyczne i podejścia oparte na modelach dla lepszej jakości i mniejszego kosztu.

Przykład bezpiecznego skalowania (bez przecieku informacji):

from sklearn.preprocessing import StandardScaler
import numpy as np

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train) # uczymy skalera na treningu
X_test_scaled = scaler.transform(X_test) # stosujemy te same parametry do testu

Dopasowuj transformacje wyłącznie na zbiorze treningowym i stosuj na testowym — to krytyczne dla uniknięcia przecieku danych.

Najważniejsze algorytmy i modele

Poniżej szybka ściąga doboru algorytmu do problemu:

  • regresja liniowa – punkt odniesienia dla wartości ciągłych, współczynniki łatwe do interpretacji;
  • regresja logistyczna – klasyfikacja z probabilistycznym wyjściem; dobrze działa przy (quasi)liniowych zależnościach;
  • drzewa decyzyjne – interpretowalne, małe wymagania co do przygotowania; podatne na przeuczenie bez ograniczeń głębokości;
  • lasy losowe – uśrednianie wielu drzew zwiększa stabilność i dokładność, zwykle niewiele strojenia;
  • maszyny wektorów nośnych (SVM) – maksymalizacja marginesu, jądra obsługują nieliniowość; wymagają skalowania;
  • k‑najbliższych sąsiadów (k‑NN) – proste, bez uczenia parametrów; wrażliwe na skalę i wybór k, wolniejsze przy predykcji;
  • naiwny Bayes – szybki, skuteczny zwłaszcza w tekście i dużej wymiarowości;
  • gradient boosting – sekwencyjne korygowanie błędów, często topowa dokładność; kosztem strojenia i czasu.

Ewaluacja i walidacja modeli

Rzetelna ewaluacja decyduje o zaufaniu do modelu i gotowości produkcyjnej.

W klasyfikacji stosuj adekwatne metryki do charakteru danych:

  • accuracy – odsetek poprawnych predykcji; mylące przy niezbalansowanych klasach;
  • precision – ile pozytywnych predykcji jest trafnych; ważne, gdy koszt false positive jest wysoki;
  • recall – jaka część rzeczywistych pozytywów została wykryta; krytyczne np. w medycynie;
  • F1 – średnia harmoniczna precision i recall, dobry kompromis jednej liczby;
  • ROC‑AUC – zdolność do porządkowania przykładów pozytywnych wyżej od negatywnych, niezależnie od progu.

Przykład obliczeń metryk (dla problemów wieloklasowych dodaj parametr average):

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report, confusion_matrix

y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')

print(f"Trafność: {accuracy:.4f}")
print(f"Precyzja: {precision:.4f}")
print(f"Recall: {recall:.4f}")
print(f"F1: {f1:.4f}")
print("\n", classification_report(y_test, y_pred))

Walidacja krzyżowa (np. k=5 lub 10) daje stabilniejsze estymaty niż pojedynczy podział; używaj wersji stratyfikowanej dla klas i specjalnych podziałów dla szeregów czasowych.

Krzywe walidacji i krzywe uczenia pomagają diagnozować niedouczenie/przeuczenie i ocenić, czy warto zbierać więcej danych.

Typowe błędy i dobre praktyki

Unikaj najczęstszych potknięć — to na nich upada wiele projektów:

  • przeciek danych – dopasowanie transformacji przed podziałem lub użycie informacji z testu zawyża wyniki; transformacje zawsze dopasowuj na treningu;
  • niezbalansowane klasy – model faworyzuje większość; stosuj właściwe metryki (precision, recall, F1, AUC) i resampling;
  • złe przetwarzanie cech – brak skalowania, nieprawidłowe kodowanie, ignorowanie braków degraduje wyniki;
  • niedopasowana złożoność – zbyt proste modele niedouczają, zbyt złożone przeuczają; zwiększaj złożoność stopniowo, monitoruj walidację;
  • ignorowanie wiedzy domenowej – ekspert domenowy oceni sensowność wyników i wskaże ważne cechy.

Budowa systemów uczenia maszynowego gotowych do produkcji

Wdrożenie to nie tylko dobry wynik na teście — liczy się odtwarzalność, spójność i monitoring.

Zapewnij trwałość modeli i pełną odtwarzalność: zapisuj nie tylko model, ale też metadane (wersje bibliotek, sumy kontrolne danych, parametry przetwarzania, metryki).

Scal przetwarzanie i model w jeden przepływ, aby uniknąć rozjazdu między treningiem a predykcją:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
('scaler', StandardScaler()),
('classifier', LogisticRegression())
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

Śledź eksperymenty (np. MLflow, Neptune): zapisuj hiperparametry, metryki i artefakty. Monitoruj wydajność po wdrożeniu, aby wykrywać dryf danych i w porę uruchamiać retrening.

Powiązane wpisy:

  1. Jak pracować z bazami danych w Pythonie – ORM i surowe zapytania
  2. Język programowania SAS – jak wykorzystać jego potencjał w analizie danych i raportowaniu?
  3. Język programowania Vala/Genie – historia, cechy i praktyczne zastosowania z GTK i bibliotekami C
  4. Język programowania Elm – korzyści, narzędzia i szkolenia dla twórców aplikacji webowych
Podziel się artykułem
Facebook Kopiuj link Drukuj
przezMiłosz Kenig
Follow:
Miłosz Kenig to absolwent informatyki na Politechnice Warszawskiej, który po ukończeniu studiów zdobył ponad 6 lat doświadczenia zawodowego jako programista full-stack w kilku firmach technologicznych. W swojej karierze pracował z szerokim spektrum technologii, sprawnie poruszając się między 5 różnymi językami programowania, w tym Java, Python i JavaScript. Jako autor tekstów na blogu P-programowanie.pl, Miłosz wykorzystuje swoje praktyczne doświadczenie zdobyte przy realizacji ponad 15 komercyjnych projektów technologicznych.
Poprzedni Wesołych Świąt i Szczęśliwego Nowego Roku ilustracja koncepcja Event-driven architecture – programowanie zdarzeniowe w praktyce
Brak komentarzy

Dodaj komentarz Anuluj pisanie odpowiedzi

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *


- Reklama -
Opanuj dowolny język programowaniaOpanuj dowolny język programowania
Najnowsze
Pracownik zatrudniony przez konkurenta do szpiegowania informacji górniczych z serwerów firmy
Wprowadzenie do machine learning w Pythonie – pierwsze kroki z scikit-learn
2026-11-16
Wesołych Świąt i Szczęśliwego Nowego Roku ilustracja koncepcja
Event-driven architecture – programowanie zdarzeniowe w praktyce
2026-11-13
Dwóch mężczyzn tworzących programy
Testowanie oprogramowania – rodzaje testów i kiedy je stosować
2026-11-05
Złożony obraz widoku z tyłu bizneswoman dotykającego interfejsu podczas trzymania czegoś
Jak prowadzić efektywne code review – wskazówki dla zespołów
2026-10-27
Git branching – strategie gałęzi w zespołowych projektach
2026-10-22

P-programowanie

Darmowa wiedza o programowaniu dla każdego.

Przeczytaj też

Język programowania
Języki programowania

Język programowania Dart – tworzenie aplikacji mobilnych i webowych

22 min. czytania
Two women working together on software programming indoors, focusing on code.
Porady

Jak programowanie proceduralne zwiększa czytelność i konserwację kodu? Zalety, wady i zastosowania

9 min. czytania
Język programowania
Języki programowania

Język programowania Solidity – klucz do rozwoju inteligentnych kontraktów i rewolucji w DeFi oraz NFT

14 min. czytania
Język programowania
Języki programowania

Język programowania Python – popularny w analizie danych i tworzeniu aplikacji

14 min. czytania

Twoja wiedza o programowaniu

Szczerze o programowaniu dla każdego.
P-programowanie P-programowanie

O programowaniu bez tajemnic. Blog informacjami, poradnikami, przeglądami dla obecnych i przyszłych programistów.

Strony

  • Strona główna
  • O P-programowanie
  • Polityka prywatności
  • Kontakt

Kategorie

  • Języki programowania
  • Nauka i praca
  • Porady
  • Więcej niż programowanie

100+ języków programowania

Poznaj ponad setkę najpopularniejszych języków programowania w na świecie.
Języki programowania
Welcome Back!

Sign in to your account

Username or Email Address
Password

Lost your password?