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

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: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/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 wyjaśnij, jak dobrać cechy do modelu.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 wyjaśnij, jak dobrać cechy do modelu.

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

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

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

Sprawdź ile obserwacji jest w każdym gatunku.

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['species'].value_counts()
```


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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 sprawdź typy danych przed preprocessingiem.

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

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

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

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 zacznij od head(), shape i isna().sum().

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

```python
import pandas as pd

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

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


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

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

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

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

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

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


Instruction:
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
Preface xvii
Chapter 1: Introduction to ML Engineering 1
Technical requirements ������������������������������������������������������������������������������������������������������ 2
Defining a taxonomy of data disciplines ����������������������������������������������������������������������������� 4
Data scientist • 4
ML engineer • 5
ML operations engineer • 6
Data engineer • 7
Working as an effective team ���������������������������������������������������������������������������������������������� 8
ML engineering in the real world ���������������������������������������������������������������������������������������� 9
What does an ML solution look like? ��������������������������������������������������������������������������������� 12
Why Python? • 14
High-level ML system design ��������������������������������������������������������������������������������������������� 15
Example 1: Batch anomaly detection service • 15
Example 2: Forecasting API • 22
Example 3: Classification pipeline • 26
Summary �������������������������������������������������������������������������������������������������������������������������� 30
Chapter 2: The Machine Learnin

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: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wypisz najważniejsze wyniki na końcu.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 podaj kolejność działań przed kodem.

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

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

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

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

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

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


Instruction:
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 zwróć uwagę na interpretację 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/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/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie 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/titanic.csv").dropna()
X = pd.get_dummies(df.drop("survived", axis=1), drop_first=True)
y = df["survived"]

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

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

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


Instruction: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: klasyfikacja z cechami numerycznymi i kategorycznymi. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

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

Input:
Python Course
Machine Learning
With Python by
Bernd Klein
Machine Learning Terminology .................................................................................................3
Representation and Visualization of Data ................................................................................15
Loading the Iris Data with Scikit-learn ....................................................................................18
Visualising the Features of the Iris Data Set.............................................................................23
Scatterplot 'Matrices .................................................................................................................27
Datasets in sklearn....................................................................................................................29
Loading Digits Data..................................................................................................................31
Reading the data and conversion back into 'data' and 'labels'...................................................51
Other Interesting Distributions ...............................................................................

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

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

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

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


Instruction: 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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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

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

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

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

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


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

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

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

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

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

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


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

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/titanic.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: age, fare, sex, pclass, embarked, survived. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj, co zrobić jeśli dataset ma braki w target.

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

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

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

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

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


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

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:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. ## Zadanie 6
Porównaj model przed i po skalowaniu.

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

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

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
model_raw = LogisticRegression(max_iter=10000)
model_raw.fit(X, y)
raw_score = model_raw.score(X, y)

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

model_scaled = LogisticRegression(max_iter=10000)
model_scaled.fit(X_scaled, y)
scaled_score = model_scaled.score(X_scaled, y)

raw_score, scaled_score
```


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

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/penguins.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, island, sex, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/penguins.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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:
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 zadbaj o zgodność train i test po kodowaniu.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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:
Braki (missing values) mogą znacząco pogorszyć jakość
modelu. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dodaj krótką interpretację wyniku.

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


Instruction:
W zależności od kontekstu, normalizacja może oznaczać projektowanie
relacyjnych baz danych według reguł form normalnych, lub skalowanie wartości
danych do wspólnej skali w celu przygotowania ich do modeli uczenia
maszynowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do 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/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/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 użyj pipeline tam, gdzie zmniejsza ryzyko błędu.

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

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

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: 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 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/tips.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. 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 zwróć uwagę na interpretację 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/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:
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 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/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:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zwróć uwagę na interpretację metryk.

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

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 sprawdź typy danych przed preprocessingiem.

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

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:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/titanic.csv. Problem: klasyfikacja binarna z brakami danych. Kolumny: age, fare, sex, pclass, embarked, survived. Target: survived. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zacznij od head(), shape i isna().sum().

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

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

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

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

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

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


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

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

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

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: 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 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/mpg.csv")
X = pd.get_dummies(df.dropna(), drop_first=True)

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

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


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

1. Zapisz dataset do pliku `dataset.csv`.
2. Wczytaj go ponownie.
3. Wyświetl ostatnie 5 wierszy.

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

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

```python
df.to_csv("dataset.csv", index=False)

dataset = pd.read_csv("dataset.csv")

dataset.tail(5)
```


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

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

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

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

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

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


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

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

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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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:
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 napisz rozwiązanie odporne na nieznane nazwy kolumn.

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

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

Input:
Confusion
Matrix
Predicted classes
male female
Actual
classes
male 42 8
female 18 32
This means that the classifier correctly predicted a male person in 42 cases and it wrongly predicted 8 male
instances as female. It correctly predicted 32 instances as female. 18 cases had been wrongly predicted as male
instead of female.
ACCURACY (ERROR RATE)
Accuracy is a statistical measure which is defined as the quotient of correct predictions made by a classifier
divided by the sum of predictions made by the classifier.
The classifier in our previous example predicted correctly predicted 42 male instances and 32 female instance.
Therefore, the accuracy can be calculated by:
accuracy = (42 + 32)/(42 + 8 + 18 + 32)
which is 0.72
Let's assume we have a classifier, which always predicts "female". We have an accuracy of 50 % in this case.
Confusion
Matrix
Predicted classes
male female
Actual
classes
male 0 50
female 0 50
We will demonstrate the so-called accuracy paradox.
A spam recogition classifier is described by the following confusion matrix:
4

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

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

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

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