Wprowadzenie do Machine Learning — fundament

🤖 Czym jest Machine Learning?

Machine Learning (ML) to dziedzina informatyki, która pozwala komputerom uczyć się i podejmować decyzje na podstawie danych, bez konieczności programowania każdej reguły z góry.

💡 Intuicja

Zamiast pisać kod “jeśli temperatura > 25°C, to będzie słonecznie”, ML pozwala algorytmowi samemu odkryć te zależności z historycznych danych pogodowych.

📊 Główne rodzaje ML

1) Supervised Learning (Uczenie nadzorowane)

Mamy dane + znamy prawidłowe odpowiedzi

# Przykład: predykcja ceny domu
# Dane wejściowe: powierzchnia, lokalizacja, rok budowy
# Cel: przewidzieć cenę

import pandas as pd
from sklearn.linear_model import LinearRegression

# Przykładowe dane
data = pd.DataFrame({
    'powierzchnia': [50, 75, 100, 120, 150],
    'rok_budowy': [1990, 2000, 2010, 2015, 2020],
    'cena': [300000, 400000, 550000, 650000, 800000]  # znamy prawdziwe ceny!
})

# Trenowanie modelu
model = LinearRegression()
X = data[['powierzchnia', 'rok_budowy']]
y = data['cena']
model.fit(X, y)

# Predykcja dla nowego domu
nowy_dom = [[90, 2005]]
przewidywana_cena = model.predict(nowy_dom)

# Zapisz wyniki do zmiennych dla expandera
dane_treningowe = data.to_string()
wynik_predykcji = f"Przewidywana cena: {przewidywana_cena[0]:.0f} zł"

print("Dane treningowe:")
print(dane_treningowe)
print(f"\nPredykcja dla domu 90m², rok 2005:")
print(wynik_predykcji)

Pokaż wyniki predykcji cen

Dane treningowe:
   powierzchnia  rok_budowy    cena
0            50        1990  300000
1            75        2000  400000
2           100        2010  550000
3           120        2015  650000
4           150        2020  800000

Predykcja dla domu 90m², rok 2005:
Przewidywana cena: 493819 zł

Real-world zastosowania:

Predykcja cen akcji/nieruchomości
Diagnoza medyczna (klasyfikacja chorób)
Filtrowanie spamu w emailach
Rozpoznawanie mowy/obrazów

2) Unsupervised Learning (Uczenie nienadzorowane)

Mamy tylko dane, szukamy ukrytych wzorców

# Przykład: segmentacja klientów sklepu
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Dane klientów: wiek i wydatki miesięczne
klienci = pd.DataFrame({
    'wiek': [25, 30, 35, 22, 28, 45, 50, 55, 60, 65],
    'wydatki': [2000, 2500, 3000, 1800, 2200, 4000, 4500, 3500, 3000, 2800]
})

# Grupowanie klientów w 3 segmenty
kmeans = KMeans(n_clusters=3, random_state=42)
klienci['segment'] = kmeans.fit_predict(klienci[['wiek', 'wydatki']])

# Przygotuj wyniki do wyświetlenia
dane_klientow = klienci.head().to_string()
segmenty_info = []
for i in range(3):
    segment = klienci[klienci['segment'] == i]
    segmenty_info.append(f"Segment {i}: średni wiek {segment['wiek'].mean():.0f}, średnie wydatki {segment['wydatki'].mean():.0f}")

przyklad_predykcji = kmeans.predict([[30, 2500]])[0]

print("Dane klientów:")
print(dane_klientow)
print("\nSegmenty klientów:")
for info in segmenty_info:
    print(info)
print(f"\nPrzykład: klient 30 lat, wydaje 2500zł -> segment {przyklad_predykcji}")

Pokaż wyniki segmentacji klientów

Dane klientów:
   wiek  wydatki  segment
0    25     2000        0
1    30     2500        2
2    35     3000        2
3    22     1800        0
4    28     2200        0

Segmenty klientów:
Segment 0: średni wiek 25, średnie wydatki 2000
Segment 1: średni wiek 50, średnie wydatki 4000
Segment 2: średni wiek 48, średnie wydatki 2825

Przykład: klient 30 lat, wydaje 2500zł -> segment 2

Real-world zastosowania:

Segmentacja klientów (marketing)
Wykrywanie anomalii (cyberbezpieczeństwo)
Analiza koszykowa (co kupują razem)
Kompresja danych

3) Reinforcement Learning (Uczenie ze wzmocnieniem)

Agent uczy się przez interakcję i nagrody/kary

# Przykład koncepcyjny: optymalizacja reklam
class SimpleAgent:
    def __init__(self):
        # Jakie reklamy pokazywać: ["sportowe", "technologiczne", "modowe"]
        self.ad_types = ["sportowe", "technologiczne", "modowe"]
        self.rewards = [0, 0, 0]  # nagrody za każdy typ
        self.counts = [0, 0, 0]   # ile razy pokazane
    
    def choose_ad(self):
        # Wybierz reklamę z najwyższą średnią nagrodą
        avg_rewards = [r/max(c,1) for r, c in zip(self.rewards, self.counts)]
        return avg_rewards.index(max(avg_rewards))
    
    def update_reward(self, ad_type, clicked):
        # Aktualizuj nagrody na podstawie kliknięć
        self.counts[ad_type] += 1
        if clicked:
            self.rewards[ad_type] += 1
    
    def get_stats(self):
        stats_list = []
        for i, ad_type in enumerate(self.ad_types):
            rate = self.rewards[i] / max(self.counts[i], 1) * 100
            stats_list.append(f"{ad_type}: {self.counts[i]} pokazań, {self.rewards[i]} kliknięć ({rate:.1f}%)")
        return stats_list

# Symulacja
import numpy as np
np.random.seed(42)

agent = SimpleAgent()
symulacja_wyniki = []
symulacja_wyniki.append("🎯 Symulacja optymalizacji reklam:")
symulacja_wyniki.append("Agent uczy się, które reklamy działają najlepiej...")

for day in range(10):
    ad = agent.choose_ad()
    # Różne prawdopodobieństwa kliknięć dla różnych typów reklam
    click_probs = [0.1, 0.3, 0.2]  # technologiczne najlepsze
    clicked = np.random.random() < click_probs[ad]
    agent.update_reward(ad, clicked)
    symulacja_wyniki.append(f"Dzień {day+1}: pokazano {agent.ad_types[ad]}, kliknięta: {clicked}")

koncowe_statystyki = agent.get_stats()

for wynik in symulacja_wyniki:
    print(wynik)
print("\n📊 Końcowe statystyki:")
for stat in koncowe_statystyki:
    print(stat)

Pokaż symulację agenta reklamowego

🎯 Symulacja optymalizacji reklam:
Agent uczy się, które reklamy działają najlepiej...
Dzień 1: pokazano sportowe, kliknięta: False
Dzień 2: pokazano sportowe, kliknięta: False
Dzień 3: pokazano sportowe, kliknięta: False
Dzień 4: pokazano sportowe, kliknięta: False
Dzień 5: pokazano sportowe, kliknięta: False
Dzień 6: pokazano sportowe, kliknięta: False
Dzień 7: pokazano sportowe, kliknięta: True
Dzień 8: pokazano sportowe, kliknięta: False
Dzień 9: pokazano sportowe, kliknięta: False
Dzień 10: pokazano sportowe, kliknięta: False

📊 Końcowe statystyki:
sportowe: 10 pokazań, 1 kliknięć (10.0%)
technologiczne: 0 pokazań, 0 kliknięć (0.0%)
modowe: 0 pokazań, 0 kliknięć (0.0%)

Real-world zastosowania:

Gry komputerowe (AI graczy)
Autonomiczne pojazdy
Optymalizacja reklam online
Roboty przemysłowe

🎯 Jak wybrać odpowiedni typ ML?

Sytuacja	Typ ML	Przykład
Masz dane z prawidłowymi odpowiedziami	Supervised	Spam/nie-spam w emailach
Chcesz znaleźć ukryte grupы	Unsupervised	Segmentacja klientów
System ma się uczyć przez trial & error	Reinforcement	Bot do gier

🔧 Podstawowe kroki projektu ML

# Kompletny workflow ML na przykładzie klasyfikacji iris
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 1. Załaduj i poznaj dane
iris = load_iris()
data = pd.DataFrame(iris.data, columns=iris.feature_names)
data['target'] = iris.target
target_names = iris.target_names

# 2. Przygotuj dane (czyszczenie, encoding)
X = data.drop('target', axis=1)
y = data['target']

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Podziel na train/test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# 4. Wybierz i wytrenuj model
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

# 5. Oceń wyniki
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)

# Przykład predykcji
sample_flower = X_test[0:1]
predicted_class = model.predict(sample_flower)[0]
predicted_name = target_names[predicted_class]
actual_name = target_names[y_test.iloc[0]]

# Przygotuj wyniki do wyświetlenia
wyniki_workflow = []
wyniki_workflow.append("🔬 Kompletny workflow projektu ML")
wyniki_workflow.append("=" * 40)
wyniki_workflow.append("1️⃣ Dane załadowane:")
wyniki_workflow.append(f"Kształt: {data.shape}")
wyniki_workflow.append(f"Klasy: {target_names}")
wyniki_workflow.append(f"Pierwsze 3 wiersze:\n{data.head(3).to_string()}")
wyniki_workflow.append(f"\n2️⃣ Dane przeskalowane (pierwsze 3 cechy pierwszej próbki):")
wyniki_workflow.append(f"Przed: {X.iloc[0, :3].values}")
wyniki_workflow.append(f"Po: {X_scaled[0, :3]}")
wyniki_workflow.append(f"\n3️⃣ Podział danych:")
wyniki_workflow.append(f"Train: {len(X_train)} próbek")
wyniki_workflow.append(f"Test: {len(X_test)} próbek")
wyniki_workflow.append(f"\n4️⃣ Model wytrenowany: RandomForestClassifier")
wyniki_workflow.append(f"\n5️⃣ Wyniki:")
wyniki_workflow.append(f"Dokładność: {accuracy:.2%}")
wyniki_workflow.append(f"\nPrzykład predykcji:")
wyniki_workflow.append(f"Przewidywana klasa: {predicted_name}")
wyniki_workflow.append(f"Rzeczywista klasa: {actual_name}")
wyniki_workflow.append("✅ Poprawnie!" if predicted_name == actual_name else "❌ Błąd")

for wynik in wyniki_workflow:
    print(wynik)

Pokaż kompletny workflow ML

🔬 Kompletny workflow projektu ML
========================================
1️⃣ Dane załadowane:
Kształt: (150, 5)
Klasy: ['setosa' 'versicolor' 'virginica']
Pierwsze 3 wiersze:
   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  target
0                5.1               3.5                1.4               0.2       0
1                4.9               3.0                1.4               0.2       0
2                4.7               3.2                1.3               0.2       0

2️⃣ Dane przeskalowane (pierwsze 3 cechy pierwszej próbki):
Przed: [5.1 3.5 1.4]
Po: [-0.90068117  1.01900435 -1.34022653]

3️⃣ Podział danych:
Train: 120 próbek
Test: 30 próbek

4️⃣ Model wytrenowany: RandomForestClassifier

5️⃣ Wyniki:
Dokładność: 100.00%

Przykład predykcji:
Przewidywana klasa: versicolor
Rzeczywista klasa: versicolor
✅ Poprawnie!

💡 Najważniejsze biblioteki Python dla ML

# Podstawowe przetwarzanie danych
import pandas as pd      # DataFrames, CSV, analiza
import numpy as np       # obliczenia numeryczne

# Machine Learning
from sklearn import *    # algorytmy ML, preprocessing, metryki
import xgboost as xgb   # zaawansowane drzewa decyzyjne

# Wizualizacja
import matplotlib.pyplot as plt  # wykresy
import seaborn as sns           # piękne wykresy statystyczne

# Deep Learning
import tensorflow as tf  # sieci neuronowe (Google)
import torch            # sieci neuronowe (Facebook)

🎯 Pro tips dla początkujących

Zacznij od prostych algorytmów - Linear Regression, Decision Trees
80% czasu to przygotowanie danych - czyszczenie, eksploracja, feature engineering
Zawsze sprawdź czy model nie jest overfitted - użyj validation set
Rozumiej swoje dane przed wyborem algorytmu
Praktyka > teoria - rób dużo projektów na różnych danych!

Następna ściągawka: Linear Regression w praktyce 🚀