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 użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

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

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. 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 sprawdź typy danych przed preprocessingiem.

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

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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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. ## Zadanie końcowe 12

Wykonaj eksploracyjną analizę danych:

1. histogramy
2. boxploty
3. scatter plot
4. macierz korelacji
5. heatmap

Spróbuj zinterpretować wyniki.

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
df.hist(figsize=(10, 8))
plt.show()

sns.boxplot(data=df)
plt.xticks(rotation=45)
plt.show()

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

corr = df.corr(numeric_only=True)
print(corr)

sns.heatmap(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/titanic.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

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

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


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 podaj, co zrobić jeśli dataset ma braki w target.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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/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 uwzględnij kolumny numeryczne.

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

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/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 sprawdź typy danych przed preprocessingiem.

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

Narysuj boxplot dla kolumny `age`.

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
import seaborn as sns
import matplotlib.pyplot as plt

sns.boxplot(x=df['age'])

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 sprawdź typy danych przed preprocessingiem.

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

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

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

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

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


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

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

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

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

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

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

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

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


Instruction:
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 użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

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

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

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

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

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

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


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

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

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:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do modelu.

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

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

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

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

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

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


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 wyjaśnij, kiedy wynik jest sensowny.

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:
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 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/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/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 dobierz właściwą metrykę.

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 sprawdź typy danych przed preprocessingiem.

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

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

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

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

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

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

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

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


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

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: 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 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/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/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) 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: Wykrywanie klastrów - w problemach grupowania (np. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: uczenie nienadzorowane: segmentacja danych bez używania etykiety. Kolumny: carat, cut, color, clarity, depth, table, price. Target: brak targetu. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz kod z komentarzami po polsku.

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

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

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

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. ## Zadanie 9
Zinterpretuj wykres reszt.

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
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)

print("MSE:", mean_squared_error(y_test, y_pred))
print("R2:", r2_score(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 uwzględnij kolumny numeryczne.

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

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


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

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: 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 sprawdź typy danych przed preprocessingiem.

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:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. ## Zadanie 6
Sprawdź R² dla innych 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
r2_more = r2_score(y_more, y_more_pred)

r2_more
```


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

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

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/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:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj, co zrobić jeśli dataset ma braki w target.

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 podaj kolejność działań przed kodem.

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: 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 podaj, co zrobić jeśli dataset ma braki w target.

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 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/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. 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 minimalną walidację jakości modelu.

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

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: 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 napisz rozwiązanie jak w notebooku.

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:
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 xiii
Microservices • 207
Event-based designs • 208
Batching • 209
Containerizing ����������������������������������������������������������������������������������������������������������������� 211
Hosting your own microservice on AWS �������������������������������������������������������������������������� 214
Pushing to ECR • 216
Hosting on ECS • 217
Building general pipelines with Airflow ������������������������������������������������������������������������� 232
Airflow • 232
Airflow on AWS • 235
Revisiting CI/CD for Airflow • 244
Building advanced ML pipelines ������������������������������������������������������������������������������������� 246
Finding your ZenML • 246
Going with the Kubeflow • 258
Selecting your deployment strategy �������������������������������������������������������������������������������� 267
Summary ������������������������������������������������������������������������������������������������������������������������ 269
Chapter 6: Scaling Up 271
Technical requirements �������������������������������������������������������������������������������������������������� 272
Scaling with Spark �������������������������������������

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

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

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

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

Machine Learning Engineering with Python.pdf


Instruction:
Wybór 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/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 napisz rozwiązanie jak w notebooku.

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/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:
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 podaj, co zrobić jeśli dataset ma braki w target.

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

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

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.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/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 dane
2) trenuj DecisionTree
3) porównaj głębokości
4) oceń accuracy i ważność cech

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 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/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/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 najpierw rozpoznaj typ problemu.

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

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: 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 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/tips.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 kategoryczne.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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: 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 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/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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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:
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 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/diamonds.csv").dropna()
X = pd.get_dummies(df.drop("price", axis=1), drop_first=True)
y = df["price"]

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

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

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


Instruction:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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:
Introduction to ML Engineering8
Data engineers spend a lot of time and effort and use their considerable skills to ensure
that data pipelines are robust, reliable, and can be trusted to deliver when promised.
• Access: Finally, the aim of getting data from A to B is for it to be used by applications,
analyses, and ML models, so the nature of B is important. The data engineer will have a
variety of technologies to hand to surface data and should work with the data consumers
(our data scientists and ML engineers, among others) to define and create appropriate
data models within these solutions:
Figure 1.1: A diagram showing the relationships between data science, ML engineering,
and data engineering.
As mentioned previously, this book focuses on the work of the ML engineer and how you can
learn some of the skills useful for that role, but it is important to remember that you will not be
working in a vacuum. Always keep in mind the profiles of the other roles (and many more not
covered here that will exist in your project team) so that you work most effectively together. Data
is a team sport after all!
Now that you understand the key roles in a modern data team and how they

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

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

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

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

Machine Learning Engineering with Python.pdf


Instruction:
Wybór 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 właściwą metrykę.

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

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

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

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

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. ## Zadanie 1
Dodaj więcej punktów danych i sprawdź jak zmienia się linia regresji.

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
X_more = np.array([[1], [2], [3], [4], [5], [6], [7], [8]])
y_more = np.array([2, 4, 5, 4, 5, 7, 8, 9])

model_more = LinearRegression()
model_more.fit(X_more, y_more)

y_more_pred = model_more.predict(X_more)

plt.scatter(X_more, y_more)
plt.plot(X_more, y_more_pred, color='red')
plt.title("Regresja liniowa - wiecej punktow")
plt.show()
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie odporne na nieznane nazwy kolumn.

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

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

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

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

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

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


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 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/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. ## Zadanie 1

1. Wczytaj dataset.
2. Sprawdź rozmiar datasetu (`shape`).
3. Wyświetl nazwy kolumn.

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

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

```python
df.shape

df.columns
```