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. ## Zadanie 11

1. Wczytaj dataset
2. Narysuj histogram dla `sepal_length`
3. Narysuj scatter plot dla `sepal_length` vs `petal_length`
4. Pokoloruj punkty według `species`

Input:
Źródło: 006_wizualizacja_ml.py+006_wizualizacja_ml.md
Checklist: histogramy; boxploty; scatterplot; korelacje; krótka interpretacja
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

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

```python
plt.hist(df['sepal_length'], bins=20)
plt.show()

sns.scatterplot(data=df, x='sepal_length', y='petal_length', hue='species')
plt.show()
```


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 dodaj krótką interpretację wyniku.

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:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. 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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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/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/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 unikaj dopasowania skalera na danych testowych.

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:
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/diamonds.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zadbaj o zgodność train i test po kodowaniu.

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/diamonds.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/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 zadbaj o zgodność train i test po kodowaniu.

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: 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 zadbaj o zgodność train i test po kodowaniu.

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:
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 1
Sprawdź accuracy dla różnych podziałów danych (zmień random_state).

https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html

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
for state in [0, 1, 42, 100]:
 X_train, X_test, y_train, y_test = train_test_split(
 X, y,
 test_size=0.3,
 random_state=state
 )

 model = LogisticRegression(max_iter=10000)
 model.fit(X_train, y_train)
 y_pred = model.predict(X_test)

 print(state, accuracy_score(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 dobierz preprocessing do typów kolumn.

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/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 wyjaśnij, kiedy wynik jest sensowny.

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 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 wyjaśnij, jak dobrać cechy do modelu.

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:
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 dobierz preprocessing do typów kolumn.

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:
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 wyjaśnij, jak dobrać cechy do modelu.

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 zacznij od head(), shape i isna().sum().

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:
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 sprawdź brakujące wartości przed modelem.

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/diamonds.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zacznij od head(), shape i isna().sum().

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/diamonds.csv").dropna()
X = pd.get_dummies(df.drop(columns=["price"], 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. ## Zadanie 5

Narysuj scatter plot:

`petal_width` vs `petal_length` z kolorami gatunków.

Input:
Źródło: 006_wizualizacja_ml.py+006_wizualizacja_ml.md
Checklist: histogramy; boxploty; scatterplot; korelacje; krótka interpretacja
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

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

```python
sns.scatterplot(
 data=df,
 x='petal_width',
 y='petal_length',
 hue='species'
)
```


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 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/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 napisz rozwiązanie odporne na nieznane nazwy 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/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. Zastosuj praktyczny wzorzec z materiału PDF do podobnego datasetu na kolokwium.

Input:
The Machine Learning Development Process46
You have now added a user story to your work management tool! This allows you to do things such
as create new tasks and link them to this user story or update its status as your project progresses:
Figure 2.7: An example user story in Jira.
The data sources you use are particularly crucial to understand. As you know, garbage in, garbage
out, or even worse, no data, no go! The particular questions you have to answer about the data are
mainly centered around access, technology, quality, and relevance.
For access and technology, you are trying to pre-empt how much work the data engineers have
to do to start their pipeline of work and how much this will hold up the rest of the project. It is
therefore crucial that you get this one right.

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:
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:
Table of Contents xi
Engineering features for machine learning ����������������������������������������������������������������������� 89
Engineering categorical features • 89
Engineering numerical features • 91
Designing your training system ���������������������������������������������������������������������������������������� 94
Training system design options • 95
Train-run • 96
Train-persist • 97
Retraining required ����������������������������������������������������������������������������������������������������������� 98
Detecting data drift • 100
Detecting concept drift • 103
Setting the limits • 105
Diagnosing the drift • 106
Remediating the drift • 108
Other tools for monitoring • 110
Automating training • 114
Hierarchies of automation • 114
Optimizing hyperparameters • 116
Hyperopt • 119
Optuna • 121
AutoML • 124
auto-sklearn • 124
AutoKeras • 126
Persisting your models ����������������������������������������������������������������������������������������������������� 127
Building the model factory with pipelines ����������������������������������������������������������������������� 131
Scikit-learn pipelines • 132
Spark ML pipelines • 136
Summary ������������������

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:
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 uwzględnij kolumny numeryczne.

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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/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", 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:
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. ## Zadanie 8

Narysuj heatmap bez wartości liczbowych (`annot=False`).

Input:
Źródło: 006_wizualizacja_ml.py+006_wizualizacja_ml.md
Checklist: histogramy; boxploty; scatterplot; korelacje; krótka interpretacja
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

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

```python
sns.heatmap(corr, annot=False, cmap='coolwarm')
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. ## Zadanie 11

1. Wczytaj dataset
2. Podziel dane na train/test
3. Naucz model Decision Tree
4. Sprawdź accuracy

Input:
Źródło: 005_podzial_danych.py+005_podzial_danych.md
Checklist: oddziel X/y; train_test_split; użyj random_state; oceń na test lub cross-validation
Pułapki: Nie oceniaj modelu na zbiorze treningowym i nie dopasowuj preprocessingu przed split.

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

```python
X = df.drop('species', axis=1)
y = df['species']

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

model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)

model.score(X_test, y_test)
```


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/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 zacznij od head(), shape i isna().sum().

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/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", 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:
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:
Introduction to ML Engineering6
This can be done using OO programming, functional programming, a mix, or something
else, but it basically helps to take the proof-of-concept work of the data scientist and turn
it into something that is far closer to being trusted in a production environment.
• Architecture: Deployments of any piece of software do not occur in a vacuum and will
always involve lots of integrated parts. This is true of ML solutions as well. The ML engi-
neer has to understand how the appropriate tools and processes link together so that the
models built with the data scientist can do their job and do it at scale.
• Productionization: The ML engineer is focused on delivering a solution and so should
understand the customer’s requirements inside out, as well as be able to understand what
that means for the project development. The end goal of the ML engineer is not to provide
a good model (though that is part of it), nor is it to provide something that basically works.
Their job is to make sure that the hard work on the data science side of things generates
the maximum potential value in a real-world setting.
ML operations engineer
ML engineering will be the foc

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: 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 napisz kod z komentarzami po polsku.

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: 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 dodaj krótką interpretację wyniku.

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:
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 użyj train_test_split z random_state=42.

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: 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 dodaj krótką interpretację wyniku.

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:
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 zadbaj o zgodność train i test po kodowaniu.

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 zwróć uwagę na interpretację metryk.

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/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", 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: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: carat, cut, color, clarity, depth, table, price. 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/diamonds.csv"
df = pd.read_csv(url)

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


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 napisz kod z komentarzami po polsku.

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 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/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", 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: 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 opisz typowe błędy przy tym zadaniu.

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:
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/diamonds.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: carat, cut, color, clarity, depth, table, price. 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/diamonds.csv").dropna()
X = pd.get_dummies(df.drop(columns=["price"], 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:
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 uwzględnij kolumny kategoryczne.

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:
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 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/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 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 wskaż X i y.

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:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. ## Zadanie 9
Zmodyfikuj wykres 3D (np. kolory, punkt widzenia).

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
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(X_pca3[:, 0], X_pca3[:, 1], X_pca3[:, 2], c=y, cmap='viridis')
ax.view_init(elev=25, azim=45)
ax.set_xlabel("PC1")
ax.set_ylabel("PC2")
ax.set_zlabel("PC3")
plt.title("PCA 3D - zmieniony widok")
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/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 zacznij od head(), shape i isna().sum().

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:
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 uwzględnij kolumny numeryczne.

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: 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 najpierw rozpoznaj typ problemu.

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:
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 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/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: 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 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/penguins.csv"
df = pd.read_csv(url)

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


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 wypisz najważniejsze wyniki na końcu.

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 właściwą metrykę.

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/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", 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:
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 opisz typowe błędy przy tym zadaniu.

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/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 kolejność działań przed kodem.

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:
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 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/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:
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 uważaj na data leakage.

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: 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 zadbaj o zgodność train i test po kodowaniu.

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/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 zadbaj o zgodność train i test po kodowaniu.

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:
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 opisz typowe błędy przy tym zadaniu.

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:
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, jak dobrać cechy do 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: 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 wyjaśnij, jak dobrać cechy do modelu.

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:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. 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 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/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: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: carat, cut, color, clarity, depth, table, price. 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) 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/diamonds.csv"
df = pd.read_csv(url)

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


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 opisz typowe błędy przy tym zadaniu.

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 wyjaśnij, jak dobrać cechy do modelu.

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/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", 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:
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 uwzględnij kolumny kategoryczne.

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:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. ## Zadanie 6

Użyj metody `bfill` do uzupełnienia braków.

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_bfill = df.fillna(method='bfill')

df_bfill.head()
```


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 zacznij od head(), shape i isna().sum().

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: 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 wyjaśnij, jak dobrać cechy do modelu.

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:
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 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/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: 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 uważaj na data leakage.

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:
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, jak dobrać cechy do modelu.

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:
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 najpierw rozpoznaj typ problemu.

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: 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 sprawdź brakujące wartości przed modelem.

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:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. ## Zadanie 4
Policz MSE dla nowych danych.

Input:
Źródło: 009_regresja_liniowa.py+009_regresja_liniowa.md
Checklist: wybierz y ciągłe; podziel dane; LinearRegression; oceń MSE, RMSE i R2
Pułapki: Sprawdź typy kolumn i unikaj data leakage.

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

```python
y_more_pred = model_more.predict(X_more)
mse_more = mean_squared_error(y_more, y_more_pred)

mse_more
```


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 zaproponuj porównanie z drugim podejściem.

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/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 najpierw rozpoznaj typ problemu.

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:
Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. ## Zadanie 11

1. Wczytaj dataset `tips`
2. Sprawdź typy danych
3. Wybierz tylko kolumny `total_bill`, `tip`
4. Zapisz wynik do CSV

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
tips = pd.read_csv(url)

tips.dtypes

tips_selected = tips[["total_bill", "tip"]]

tips_selected.to_csv("tips_selected.csv", index=False)
```


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/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 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/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", 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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. 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 opisz typowe błędy przy tym zadaniu.

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/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", 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: 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 użyj train_test_split z random_state=42.

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: 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 dobierz preprocessing do typów kolumn.

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: 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 zwróć uwagę na interpretację metryk.

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: 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 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/titanic.csv"
df = pd.read_csv(url)

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