Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zadbaj o zgodność train i test po kodowaniu.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wskaż X i y.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. ## Zadanie 5
Porównaj accuracy dla L1 i L2.

Input:
Źródło: 010_regresja_logistyczna.py+010_regresja_logistyczna.md
Checklist: wybierz y binarne; skaluj dane; LogisticRegression; confusion_matrix, precision, recall
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

Output:
1) przygotuj klasy binarne
2) skaluj cechy
3) trenuj LogisticRegression
4) oceń confusion matrix

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
y_pred_l1 = model_l1.predict(X_test)
y_pred_l2 = model_l2.predict(X_test)

accuracy_score(y_test, y_pred_l1), accuracy_score(y_test, y_pred_l2)
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wypisz najważniejsze wyniki na końcu.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dodaj minimalną walidację jakości modelu.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop(columns=["mpg"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, kiedy wynik jest sensowny.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop(columns=["mpg"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. ## Zadanie 8
Porównaj model z PCA i bez PCA.

Input:
Źródło: 012_pca.py+012_pca.md
Checklist: skaluj dane; dopasuj PCA; sprawdź explained_variance_ratio_; dobierz komponenty
Pułapki: Nie wykonuj PCA bez skalowania i nie dopasowuj PCA na danych testowych.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
X_train, X_test, y_train, y_test = train_test_split(
 X_scaled, y,
 test_size=0.2,
 random_state=42
)

model_no_pca = LogisticRegression(max_iter=10000)
model_no_pca.fit(X_train, y_train)
score_no_pca = model_no_pca.score(X_test, y_test)

pca = PCA(n_components=5)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

model_pca = LogisticRegression(max_iter=10000)
model_pca.fit(X_train_pca, y_train)
score_pca = model_pca.score(X_test_pca, y_test)

score_no_pca, score_pca
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zacznij od head(), shape i isna().sum().

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wskaż X i y.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. ## Zadanie 11.

1. Wczytaj dataset Titanic
2. Sprawdź braki danych
3. Uzupełnij kolumnę age medianą
4. Znajdź outliery w kolumnie fare

Input:
Źródło: 002_braki_i_outliery.py+002_braki_i_outliery.md
Checklist: policz braki; uzupełnij medianą/modą; wykryj outliery IQR; rozważ winsoryzację
Pułapki: Nie usuwaj masowo danych bez sprawdzenia skali braków i outlierów.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
df = pd.read_csv(url)

df.isna().sum()

df['age_filled'] = df['age'].fillna(df['age'].median())

fare_q1 = df['fare'].quantile(0.25)
fare_q3 = df['fare'].quantile(0.75)
fare_iqr = fare_q3 - fare_q1

fare_outliers = df[(df['fare'] < fare_q1 - 1.5 * fare_iqr) | (df['fare'] > fare_q3 + 1.5 * fare_iqr)]

fare_outliers.head()
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uwzględnij kolumny numeryczne.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj, co zrobić jeśli dataset ma braki w target.

Output:
1) przygotuj X i y
2) podziel dane
3) trenuj LinearRegression
4) oceń MSE, RMSE i R2

```python
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
print(mse, rmse, r2)
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj, co zrobić jeśli dataset ma braki w target.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo sprawdź typy danych przed preprocessingiem.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie jak w notebooku.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj kolejność działań przed kodem.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uwzględnij kolumny kategoryczne.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo opisz typowe błędy przy tym zadaniu.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop("mpg", axis=1), drop_first=True)
y = df["mpg"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie jak w notebooku.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Zastosuj praktyczny wzorzec z materiału PDF do podobnego datasetu na kolokwium.

Input:
Prefacexviii
We will cover everything from how to organize your ML team, to software development meth-
odologies and best practices, to automating model building through to packaging your ML code,
how to deploy your ML pipelines to a variety of different targets and then on to how to scale your
workloads for large batch runs. We will also discuss, in an entirely new chapter for this second
edition, the exciting world of applying ML engineering and MLOps to deep learning and genera-
tive AI, including how to start building solutions using Large Language Models (LLMs) and the
new field of LLM Operations (LLMOps).
The second edition of Machine Learning Engineering with Python goes into a lot more depth than
the first edition in almost every chapter, with updated examples and more discussion of core
concepts. There is also a far wider selection of tools covered and a lot more focus on open-source
tools and development. The ethos of focusing on core concepts remains, but it is my hope that
this wider view means that the second edition will be an excellent resource for those looking to
gain practical knowledge of machine learning engineering.
Although a far greater emphasis has

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler

num_cols = X.select_dtypes(include="number").columns
cat_cols = X.select_dtypes(include="object").columns

preprocess = ColumnTransformer([
 ("num", StandardScaler(), num_cols),
 ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols),
])
```

Machine Learning Engineering with Python.pdf


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie jak w notebooku.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do modelu.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: regresja wartości ciągłej z cechami mieszanymi. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: mpg. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uwzględnij kolumny kategoryczne.

Output:
1) przygotuj X i y
2) podziel dane
3) trenuj LinearRegression
4) oceń MSE, RMSE i R2

```python
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop("mpg", axis=1), drop_first=True)
y = df["mpg"]

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
print(mse, rmse, r2)
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wskaż X i y.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj prosty model bazowy.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo rozważ stratify, jeśli problem jest klasyfikacją.

Output:
1) przygotuj X i y
2) przeskaluj cechy
3) porównaj wartości k
4) oceń accuracy

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.neighbors import KNeighborsClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", KNeighborsClassifier(n_neighbors=5)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: carat, cut, color, clarity, depth, table, price. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz kod z komentarzami po polsku.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. ## Zadanie końcowe 12

Stwórz kompletny program, który wykonuje następujące polecenia:

1. skalowanie danych numerycznych
2. kodowanie zmiennych kategorycznych
3. utworzenie finalnej macierzy cech

Input:
Źródło: 003_normalizacja_kodowanie.py+003_normalizacja_kodowanie.md
Checklist: oddziel kolumny numeryczne i kategoryczne; skaluj liczby; koduj kategorie; unikaj leakage
Pułapki: Nie skaluj kolumn tekstowych i nie koduj train/test niespójnie.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler

num_cols = ['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm', 'body_mass_g']
cat_cols = ['species', 'island', 'sex']

transformer = ColumnTransformer([
 ('num', StandardScaler(), num_cols),
 ('cat', OneHotEncoder(), cat_cols)
])

X = transformer.fit_transform(df)

X.shape
```


Instruction:
KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. ## Zadanie 10

Sprawdź metrykę `euclidean`.

Input:
Źródło: 007_knn.py+007_knn.md
Checklist: skaluj dane; dobierz k; trenuj KNN; oceń accuracy
Pułapki: Nie używaj KNN bez skalowania i nie wybieraj k bez porównania wyników.

Output:
1) przygotuj X i y
2) przeskaluj cechy
3) porównaj wartości k
4) oceń accuracy

```python
model = KNeighborsClassifier(n_neighbors=5, metric='euclidean')

model.fit(X_train, y_train)

model.score(X_test, y_test)
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uważaj na data leakage.

Output:
1) przygotuj X i y
2) podziel dane
3) trenuj LinearRegression
4) oceń MSE, RMSE i R2

```python
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
print(mse, rmse, r2)
```


Instruction:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. ## Zadanie 4
Porównaj log_loss dla różnych modeli.

Input:
Źródło: 010_regresja_logistyczna.py+010_regresja_logistyczna.md
Checklist: wybierz y binarne; skaluj dane; LogisticRegression; confusion_matrix, precision, recall
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

Output:
1) przygotuj klasy binarne
2) skaluj cechy
3) trenuj LogisticRegression
4) oceń confusion matrix

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
model_default = LogisticRegression()
model_strong_reg = LogisticRegression(C=0.1)

model_default.fit(X, y)
model_strong_reg.fit(X, y)

loss_default = log_loss(y, model_default.predict_proba(X))
loss_strong_reg = log_loss(y, model_strong_reg.predict_proba(X))

loss_default, loss_strong_reg
```


Instruction: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. Zastosuj praktyczny wzorzec z materiału PDF do podobnego datasetu na kolokwium.

Input:
We will train our articifical data in the following code:
from sklearn.model_selection import train_test_split
data_sets = train_test_split(data,
labels,
train_size=0.8,
test_size=0.2,
random_state=42 # garantees same output fo
r every run
)
train_data, test_data, train_labels, test_labels = data_sets
# import model
from sklearn.neighbors import KNeighborsClassifier
# create classifier
knn = KNeighborsClassifier(n_neighbors=8)
# train
knn.fit(train_data, train_labels)
# test on test data:
calculated_labels = knn.predict(test_data)
calculated_labels
Output: <matplotlib.legend.Legend at 0x7f545b4d6340>
52

Output:
1) przygotuj X i y
2) przeskaluj cechy
3) porównaj wartości k
4) oceń accuracy

```python
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("knn", KNeighborsClassifier(n_neighbors=5)),
])
model.fit(X_train, y_train)
print("Accuracy:", accuracy_score(y_test, model.predict(X_test)))
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wypisz najważniejsze wyniki na końcu.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zadbaj o zgodność train i test po kodowaniu.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: regresja wartości ciągłej. Kolumny: carat, cut, color, clarity, depth, table, price. Target: price. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo opisz typowe błędy przy tym zadaniu.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wypisz najważniejsze wyniki na końcu.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do modelu.

Output:
1) przygotuj klasy binarne
2) skaluj cechy
3) trenuj LogisticRegression
4) oceń confusion matrix

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, precision_score, recall_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("logreg", LogisticRegression(max_iter=10000)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(confusion_matrix(y_test, y_pred))
print(precision_score(y_test, y_pred))
print(recall_score(y_test, y_pred))
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uwzględnij kolumny kategoryczne.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop(columns=["species"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, kiedy wynik jest sensowny.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wypisz najważniejsze wyniki na końcu.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zwróć uwagę na interpretację metryk.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz kod z komentarzami po polsku.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop(columns=["mpg"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction:
Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. ## Zadanie 7

Narysuj drzewo dla modelu `model_entropy`.

Input:
Źródło: 008_drzewa_decyzyjne.py+008_drzewa_decyzyjne.md
Checklist: trenuj DecisionTree; porównaj max_depth; oceń accuracy; sprawdź ważność cech
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
plt.figure(figsize=(12, 8))

plot_tree(
 model_entropy,
 feature_names=X.columns,
 class_names=model_entropy.classes_,
 filled=True
)

plt.show()
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: regresja wartości ciągłej z cechami mieszanymi. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: mpg. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

Output:
1) przygotuj X i y
2) podziel dane
3) trenuj LinearRegression
4) oceń MSE, RMSE i R2

```python
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop("mpg", axis=1), drop_first=True)
y = df["mpg"]

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
print(mse, rmse, r2)
```


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz preprocessing do typów kolumn.

Output:
1) przygotuj dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. Zastosuj praktyczny wzorzec z materiału PDF do podobnego datasetu na kolokwium.

Input:
EVALUATION METRICS
INTRODUCTION
Not only in machine learning but also in
general life, especially business life, you
will hear questiones like "How accurate is
your product?" or "How precise is your
machine?". When people get replies like
"This is the most accurate product in its
field!" or "This machine has the highest
imaginable precision!", they feel
fomforted by both answers. Shouldn't
they? Indeed, the terms accurate and
precise are very often used
interchangeably. We will give exact
definitions later in the text, but in a
nutshell, we can say: Accuracy is a
measure for the closeness of some
measurements to a specific value, while
precision is the closeness of the measurements to each other.
These terms are also of extreme importance in Machine Learning. We need them for evaluating ML
algorithms or better their results.
We will present in this chapter of our Python Machine Learning Tutorial four important metrics. These metrics
are used to evaluate the results of classifications. The metrics are:
• Accuracy
• Precision
• Recall
• F1-Score
We will introduce each of these metrics and we will discuss the pro and cons of each of them. Each metric
measures something different about

Output:
1) przygotuj klasy binarne
2) skaluj cechy
3) trenuj LogisticRegression
4) oceń confusion matrix

```python
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, precision_score, recall_score

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("logreg", LogisticRegression(max_iter=10000)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(confusion_matrix(y_test, y_pred))
print(precision_score(y_test, y_pred))
print(recall_score(y_test, y_pred))
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dodaj minimalną walidację jakości modelu.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: carat, cut, color, clarity, depth, table, price. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction:
Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. ## Zadanie

1. Zapisz dane do tabeli `tips2`
2. Wczytaj je ponownie z SQL

Input:
Źródło: 001_pozyskiwanie_danych.py+001_pozyskiwanie_danych.md
Checklist: wczytaj dane; sprawdź head, shape, dtypes; policz braki; wybierz lub zapisz wynik
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
df.to_sql("tips2", conn, if_exists="replace", index=False)

tips2 = pd.read_sql("SELECT * FROM tips2", conn)

tips2.head()
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uwzględnij kolumny numeryczne.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv").dropna()
X = pd.get_dummies(df.drop(columns=["mpg"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dodaj krótką interpretację wyniku.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop("species", axis=1), drop_first=True)
y = df["species"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wskaż X i y.

Output:
1) skaluj dane
2) dopasuj PCA
3) sprawdź wariancję
4) wybierz liczbę komponentów

```python
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv").dropna()
X = pd.get_dummies(df.drop(columns=["species"], errors="ignore"), drop_first=True)

X_scaled = StandardScaler().fit_transform(X)
pca = PCA()
pca.fit(X_scaled)
cum_var = np.cumsum(pca.explained_variance_ratio_)
n_components = np.argmax(cum_var >= 0.95) + 1
X_pca = PCA(n_components=n_components).fit_transform(X_scaled)
print(n_components)
print(X_pca.shape)
```


Instruction: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: carat, cut, color, clarity, depth, table, price. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo sprawdź typy danych przed preprocessingiem.

Output:
1) wybierz cechy
2) skaluj dane
3) dobierz K metodą łokcia
4) trenuj KMeans

```python
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

inertia = []
for k in range(1, 10):
 pipe = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=k, random_state=42)),
 ])
 pipe.fit(X)
 inertia.append(pipe.named_steps["kmeans"].inertia_)

model = Pipeline([
 ("scaler", StandardScaler()),
 ("kmeans", KMeans(n_clusters=4, random_state=42)),
])
labels = model.fit_predict(X)
print(labels[:10])
```


Instruction:
KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. ## Zadanie 3

Podziel dane w proporcji 70/30.

Input:
Źródło: 007_knn.py+007_knn.md
Checklist: skaluj dane; dobierz k; trenuj KNN; oceń accuracy
Pułapki: Nie używaj KNN bez skalowania i nie wybieraj k bez porównania wyników.

Output:
1) przygotuj X i y
2) przeskaluj cechy
3) porównaj wartości k
4) oceń accuracy

```python
X_train, X_test, y_train, y_test = train_test_split(
 X, y,
 test_size=0.3,
 random_state=42
)
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo opisz typowe błędy przy tym zadaniu.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dodaj krótką interpretację wyniku.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. ## Zadanie 8

Spróbuj użyć innych dwóch cech.

Input:
Źródło: 007_knn.py+007_knn.md
Checklist: skaluj dane; dobierz k; trenuj KNN; oceń accuracy
Pułapki: Nie używaj KNN bez skalowania i nie wybieraj k bez porównania wyników.

Output:
1) przygotuj X i y
2) przeskaluj cechy
3) porównaj wartości k
4) oceń accuracy

```python
X_alt = df[['sepal_length', 'sepal_width']]

sns.scatterplot(x=X_alt['sepal_length'], y=X_alt['sepal_width'], hue=y)
```


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zwróć uwagę na interpretację metryk.

Output:
1) sprawdź rozkłady
2) narysuj boxplot/scatter
3) policz korelacje
4) zinterpretuj wykresy

```python
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

df.hist(figsize=(10, 8))
plt.show()

num_df = df.select_dtypes(include="number")
sns.heatmap(num_df.corr(), annot=True, cmap="coolwarm")
plt.show()
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zwróć uwagę na interpretację metryk.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj kolejność działań przed kodem.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: regresja wartości ciągłej. Kolumny: carat, cut, color, clarity, depth, table, price. Target: price. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo najpierw rozpoznaj typ problemu.

Output:
1) przygotuj X i y
2) podziel dane
3) trenuj LinearRegression
4) oceń MSE, RMSE i R2

```python
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
print(mse, rmse, r2)
```


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

Output:
1) policz braki
2) uzupełnij wartości
3) wyznacz IQR
4) usuń lub przytnij outliery

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo uważaj na data leakage.

Output:
1) oddziel X i y
2) podziel train/test
3) wytrenuj model
4) oceń test i opcjonalnie CV

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wskaż X i y.

Output:
1) oddziel X i y
2) podziel dane
3) trenuj klasyfikator
4) oceń raport klasyfikacji

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj, co zrobić jeśli dataset ma braki w target.

Output:
1) oddziel X i y
2) wykryj typy kolumn
3) skaluj numeryczne
4) zakoduj kategoryczne

```python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.tree import DecisionTreeClassifier

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

model = Pipeline([
 ("scaler", StandardScaler()),
 ("model", DecisionTreeClassifier(max_depth=3, random_state=42)),
])
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz właściwą metrykę.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

Output:
1) wczytaj dane
2) sprawdź head, shape i typy
3) policz braki
4) zwróć lub zapisz wynik

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv"
df = pd.read_csv(url)

print(df.head())
print(df.shape)
print(df.dtypes)
print(df.isna().sum())
```