Python Machine Learning - pierwszy model w 30 minut

Python Machine Learning — pierwszy model w 30 minut

Machine learning brzmi jak coś zarezerwowanego dla naukowców z doktoratami i potężnych korporacji. Nic bardziej mylnego! Dzięki ekosystemowi Pythona, który oferuje gotowe biblioteki i obszerne dokumentacje, każdy programista — nawet początkujący — może zbudować swój pierwszy model uczenia maszynowego w bardzo krótkim czasie. Dziś pokażemy Ci, jak to zrobić krok po kroku.

Co będziemy budować?

Na potrzeby tego tutorialu stworzymy model klasyfikacji, który na podstawie cech kwiatu irys będzie przewidywał jego gatunek. To klasyczne zadanie w świecie machine learningu — zbiór danych Iris jest prosty, dobrze opisany i idealny do nauki. Użyjemy algorytmu k-nearest neighbors (KNN), który jest intuicyjny i świetnie nadaje się do pierwszych kroków.

Po ukończeniu tego poradnika będziesz wiedzieć:

Jak zainstalować i zaimportować potrzebne biblioteki
Jak wczytać i przeanalizować zbiór danych
Jak podzielić dane na zbiór treningowy i testowy
Jak wytrenować model i ocenić jego skuteczność
Jak dokonać pierwszej predykcji

Krok 1 — Instalacja bibliotek (2 minuty)

Zanim zaczniemy kodować, musimy zainstalować niezbędne narzędzia. Otwórz terminal i wpisz poniższe polecenie:

pip install numpy pandas scikit-learn matplotlib seaborn

Oto krótki opis każdej z bibliotek:

NumPy — obsługa operacji matematycznych i tablic wielowymiarowych
Pandas — wczytywanie i przetwarzanie danych w formie tabelarycznej
Scikit-learn — główna biblioteka do machine learningu; zawiera gotowe algorytmy, narzędzia do oceny modeli i przetwarzania danych
Matplotlib i Seaborn — wizualizacja danych i wyników

Jeśli korzystasz z Anacondy lub środowiska Jupyter Notebook, większość tych bibliotek jest już zainstalowana. Sprawdź to poleceniem conda list.

Krok 2 — Importowanie bibliotek i wczytanie danych (3 minuty)

Stwórz nowy plik Pythona (np. my_first_model.py) lub otwórz nowy notatnik Jupyter. Zacznij od importów:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

Teraz wczytajmy dane:

# Wczytanie zbioru danych Iris
iris = load_iris()

# Przekształcenie do DataFrame dla wygody
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
df['target'] = iris.target
df['species'] = df['target'].map({0: 'setosa', 1: 'versicolor', 2: 'virginica'})

print(df.head(10))

Po uruchomieniu tego kodu zobaczysz pierwsze 10 wierszy zbioru danych. Każdy kwiat opisany jest przez 4 cechy: długość i szerokość płatka (petal) oraz działki kielicha (sepal).

Krok 3 — Eksploracja danych (5 minut)

Zanim zbudujesz model, warto poznać swoje dane. To kluczowy etap w każdym projekcie machine learningowym:

# Podstawowe statystyki
print(df.describe())

# Liczba próbek każdego gatunku
print(df['species'].value_counts())

# Sprawdzenie brakujących danych
print(df.isnull().sum())

Zbiór Iris zawiera po 50 próbek każdego z trzech gatunków — jest idealnie zbalansowany, co rzadko zdarza się w prawdziwych projektach. Nie ma też żadnych brakujących wartości.

Warto też stworzyć szybką wizualizację:

# Pairplot — relacje między cechami
sns.pairplot(df, hue='species', vars=iris.feature_names)
plt.suptitle('Relacje między cechami irysów', y=1.02)
plt.show()

Ten wykres pokazuje, które cechy najlepiej rozróżniają gatunki. Zauważysz, że petal length i petal width są szczególnie diagnostyczne — gatunek setosa wyraźnie odróżnia się od pozostałych.

Krok 4 — Przygotowanie danych (5 minut)

Machine learning wymaga podziału danych na dwie części: zbiór treningowy (na którym model się uczy) i zbiór testowy (na którym sprawdzamy jego skuteczność). To fundamentalna zasada — nigdy nie testujemy modelu na tych samych danych, na których był trenowany!

# Cechy (X) i etykiety (y)
X = iris.data
y = iris.target

# Podział 80% trening, 20% test
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

print(f"Dane treningowe: {X_train.shape}")
print(f"Dane testowe: {X_test.shape}")

Parametr random_state=42 zapewnia reprodukowalność wyników — za każdym uruchomieniem skryptu dostaniesz ten sam podział. Parametr stratify=y gwarantuje, że w obu zbiorach zachowana jest proporcjonalna reprezentacja każdego gatunku.

Krok 5 — Trening modelu (5 minut)

Czas na serce naszego projektu — trening modelu KNN. Algorytm ten działa na prostej zasadzie: aby sklasyfikować nowy punkt, sprawdza k najbliższych sąsiadów w przestrzeni cech i przypisuje klasę najczęściej występującą wśród nich.

# Stworzenie i trening modelu
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

print("Model wytrenowany!")

To wszystko! Biblioteka scikit-learn sprawia, że trening modelu sprowadza się do jednej linii kodu. Parametr n_neighbors=5 oznacza, że model będzie brał pod uwagę 5 najbliższych sąsiadów przy każdej klasyfikacji.

Krok 6 — Ocena modelu (7 minut)

Teraz sprawdźmy, jak dobrze nasz model radzi sobie z danymi, których nigdy wcześniej nie widział:

# Predykcje na zbiorze testowym
y_pred = model.predict(X_test)

# Dokładność (accuracy)
accuracy = accuracy_score(y_test, y_pred)
print(f"Dokładność modelu: {accuracy * 100:.2f}%")

# Szczegółowy raport klasyfikacji
print("\nRaport klasyfikacji:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Powinieneś zobaczyć dokładność na poziomie 96–100% — to świetny wynik! Raport klasyfikacji zawiera dodatkowe metryki:

Precision — ile spośród wszystkich predykcji danej klasy było poprawnych
Recall — ile spośród wszystkich rzeczywistych przypadków danej klasy zostało wykrytych
F1-score — harmoniczna średnia precision i recall

Warto też zwizualizować macierz pomyłek (confusion matrix):

# Macierz pomyłek
cm = confusion_matrix(y_test, y_pred)

plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=iris.target_names,
            yticklabels=iris.target_names)
plt.title('Macierz pomyłek')
plt.ylabel('Rzeczywista klasa')
plt.xlabel('Predykowana klasa')
plt.show()

Macierz pomyłek pokazuje Ci, które gatunki były mylone ze sobą. Jedynki lub zera poza przekątną oznaczają błędy klasyfikacji.

Krok 7 — Pierwsza predykcja (3 minuty)

Mamy działający model — czas go użyć do prawdziwej predykcji! Wyobraź sobie, że mierzysz kwiat i chcesz dowiedzieć się, jakiego jest gatunku:

# Nowa próbka: sepal_length, sepal_width, petal_length, petal_width (w cm)
nowy_kwiat = np.array([[5.1, 3.5, 1.4, 0.2]])

# Predykcja
predykcja = model.predict(nowy_kwiat)
gatunek = iris.target_names[predykcja[0]]

print(f"Predykowany gatunek: {gatunek}")

# Prawdopodobieństwo każdej klasy
prawdopodobienstwa = model.predict_proba(nowy_kwiat)
for nazwa, prob in zip(iris.target_names, prawdopodobienstwa[0]):
    print(f"  {nazwa}: {prob * 100:.1f}%")

Metoda predict_proba() zwraca prawdopodobieństwo przynależności do każdej klasy — to przydatna informacja, gdy chcemy ocenić pewność modelu.

Co dalej? Kierunki rozwoju

Gratulacje — właśnie zbudowałeś swój pierwszy model machine learningowego! To dopiero początek drogi. Oto kilka kierunków, w których możesz się rozwijać:

Inne algorytmy klasyfikacji

Scikit-learn oferuje dziesiątki gotowych algorytmów. Warto wypróbować:

Decision Tree — drzewo decyzyjne, łatwe do interpretacji
Random Forest — las losowy, często dający świetne wyniki
Support Vector Machine (SVM) — skuteczny przy mniejszych zbiorach danych
Logistic Regression — mimo nazwy, świetna do klasyfikacji

Własne zbiory danych

Spróbuj wczytać własne dane z pliku CSV przy użyciu pd.read_csv(). Na platformach takich jak Kaggle znajdziesz tysiące darmowych zbiorów danych do ćwiczeń — od przewidywania cen nieruchomości po klasyfikację zdjęć.

Tuning hiperparametrów

Parametr n_neighbors=5 wybraliśmy arbitralnie. Scikit-learn oferuje narzędzia takie jak GridSearchCV, które automatycznie przeszukują przestrzeń parametrów i znajdą optymalne ustawienia:

from sklearn.model_selection import GridSearchCV

param_grid = {'n_neighbors': range(1, 21)}
grid_search = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)
grid_search.fit(X_train, y_train)
print(f"Najlepsza liczba sąsiadów: {grid_search.best_params_}")

Normalizacja danych

W naszym przykładzie pominęliśmy normalizację, ponieważ dane Iris mają podobne skale. W prawdziwych projektach często konieczne jest skalowanie cech przy użyciu StandardScaler lub MinMaxScaler.

Podsumowanie

W ciągu zaledwie 30 minut przeszedłeś przez cały cykl życia projektu machine learningowego: od instalacji narzędzi, przez eksplorację danych, trening modelu, aż po ocenę jego skuteczności i dokonanie pierwszej predykcji. To fundament, na którym możesz budować bardziej zaawansowane projekty.

Kluczowe lekcje z tego ćwiczenia:

Machine learning nie musi być skomplikowany — scikit-learn ukrywa złożoność za prostym interfejsem
Zawsze dziel dane na zbiór treningowy i testowy
Eksploracja danych przed modelowaniem to nie opcja — to konieczność
Accuracy to nie jedyna miara sukcesu — zawsze patrz na precision, recall i F1

Świat machine learningu stoi przed Tobą otworem. Zrób kolejny krok i spróbuj swojego modelu na prawdziwym problemie — na przykład przewidywania cen mieszkań lub klasyfikacji opinii klientów. Powodzenia!

Python Machine Learning - pierwszy model w 30 minut