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 napisz rozwiązanie odporne na nieznane nazwy kolumn.

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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


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

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

```python
import pandas as pd

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

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


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz preprocessing do typów 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/iris.csv"
df = pd.read_csv(url)

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


Instruction:
Wgrywamy tysiące zdjęć
kotów i innych zwierząt, a algorytm sam „nauczy się” , czym różni się kot od psa
czy ptaka, bez konieczności definiowania reguł ręcznie. ## Zadanie 8
Sprawdź jak precision i recall zmieniają się przy zmianie progu.

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
threshold_model = LogisticRegression(max_iter=10000)
threshold_model.fit(X_train, y_train)
y_prob = threshold_model.predict_proba(X_test)[:, 1]

for threshold in [0.3, 0.5, 0.7]:
 y_pred_threshold = (y_prob >= threshold).astype(int)
 print(
 threshold,
 precision_score(y_test, y_pred_threshold),
 recall_score(y_test, y_pred_threshold)
 )
```


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

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

```python
import pandas as pd

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

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


Instruction:
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 dobierz preprocessing do typów 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/diamonds.csv").dropna()
X = pd.get_dummies(df.drop(columns=["price"], errors="ignore"), drop_first=True)

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


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

Input:
ham 0 114
We can calculate the precision for our example:
TP = 114
FP = 14
# FN (0) and TN (12) are not needed in the formuala!
precision = TP / (TP + FP)
print(f"precision: {precision:4.2f}")
Exercise: Before you go on with the text think about what the value precision means. If you look at the
precision measure of our spam filter example, what does it tell you about the quality of the spam filter? What
do the results of the confusion matrix of an ideal spam filter look like? What is worse, high FP or FN values?
You will find the answers indirectly in the following explanations.
Incidentally, the ideal spam filter would have 0 values for both FP and FN.
The previous result means that 11 mailpieces out of a hundred will be classified as ham, even though they are
spam. 89 are correctly classified as ham. This is a point where we should talk about the costs of
misclassification. It is troublesome when a spam mail is not recognized as "spam" and is instead presented to
us as "ham". If the percentage is not too high, it is annoying but not a disaster. In contrast, when a non-spam
message is wrongly labeled as spam, the email will not be shown in many cases or even automatically deleted

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/tips.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz preprocessing do typów 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/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/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo zaproponuj porównanie z drugim podejściem.

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 zaproponuj porównanie z drugim podejściem.

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

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz preprocessing do typów kolumn.

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

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

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

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

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

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 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/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 napisz kod z komentarzami po polsku.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do modelu.

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

```python
import pandas as pd

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. 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 uzasadnij, czy zadanie jest nadzorowane czy nienadzorowane.

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

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

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

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

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

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


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo unikaj dopasowania skalera na danych testowych.

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: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: klasyfikacja wieloklasowa. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: species. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo najpierw rozpoznaj typ problemu.

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

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

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

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

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

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


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

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

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: KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. Zastosuj praktyczny wzorzec z materiału PDF do podobnego datasetu na kolokwium.

Input:
k-nearest neighbor data set with new object to classify
When we choose k = 3, the algorithm will find the three nearest
neighbors of the green heart in order to classify it to either the
diamond
class or the star class.
In our diagram, the three nearest neighbors of the green heart are
one
diamond and two stars. Therefore, the algorithm will classify
the heart
with the star class.

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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: 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 sprawdź brakujące wartości przed modelem.

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:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. ## Zadanie 3

Podziel dane tak aby zbiór testowy miał 30% danych.

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

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

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

X_train.shape, X_test.shape
```


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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/mpg.csv. Problem: czyszczenie danych przed dalszą analizą lub modelowaniem. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo podaj kolejność działań przed kodem.

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

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

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

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

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

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


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

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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:
Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. ## Zadanie 9

Narysuj wykres ważności cech.

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

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

```python
importance.sort_values().plot(kind='barh')

plt.xlabel("importance")
plt.title("Feature importance")
plt.show()
```


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: carat, cut, color, clarity, depth, table, price. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie jak w notebooku.

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

```python
import pandas as pd

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

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


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

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

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

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

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

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


Instruction: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 kolejność działań przed kodem.

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

```python
import pandas as pd

url = "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.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/tips.csv. Problem: przygotowanie cech numerycznych i kategorycznych do modelowania. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz 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/tips.csv").dropna()
X = pd.get_dummies(df.drop("tip", axis=1), drop_first=True)
y = df["tip"]

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

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

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


Instruction: Drzewo decyzyjne uczy się reguł podziału danych na podstawie cech. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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ź brakujące wartości przed modelem.

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

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

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

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

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

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


Instruction:
Wykrywanie klastrów - w problemach grupowania (np. ## Zadanie 3
Porównaj wyniki dla random i k-means++.

Input:
Źródło: 011_klastry.py+011_klastry.md
Checklist: skaluj dane; dobierz K metodą łokcia; KMeans; interpretuj klastry
Pułapki: Nie zakładaj istnienia targetu y i nie interpretuj inertia bez porównania kilku K.

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

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
print("Random inertia:", kmeans_random.inertia_)
print("K-means++ inertia:", kmeans_pp.inertia_)

plt.scatter(X[:, 0], X[:, 1], c=kmeans_random.labels_)
plt.title("init=random")
plt.show()

plt.scatter(X[:, 0], X[:, 1], c=kmeans_pp.labels_)
plt.title("init=k-means++")
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 podaj, co zrobić jeśli dataset ma braki w target.

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:
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 3

Narysuj boxplot dla kolumny `sepal_width`.

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

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

```python
sns.boxplot(x=df['sepal_width'])

plt.show()
```


Instruction:
zbiorów walidacyjnych i testowych, sprawdzianu
krzyżowego. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/diamonds.csv. Problem: regresja wartości ciągłej. Kolumny: carat, cut, color, clarity, depth, table, price. Target: price. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo wyjaśnij, jak dobrać cechy do modelu.

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

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

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

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

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

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


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

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

```python
import pandas as pd

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 napisz kod z komentarzami po polsku.

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

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

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

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

```python
import pandas as pd

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

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


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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. 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 napisz rozwiązanie jak w notebooku.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/iris.csv"
df = pd.read_csv(url)

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


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

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

```python
import pandas as pd

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

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


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

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: eksploracyjna analiza danych przed modelowaniem. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo napisz rozwiązanie odporne na nieznane nazwy 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/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: 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 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/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:
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 napisz rozwiązanie jak w notebooku.

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 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 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/tips.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 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/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:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv. Problem: regresja wartości napiwku albo EDA. Kolumny: total_bill, tip, sex, smoker, day, time, size. Target: tip. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo dobierz właściwą metrykę.

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

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

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

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

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

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


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. ## Zadanie 2
Zredukuj dane do 3 wymiarów.

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

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

```python
pca_3 = PCA(n_components=3)
X_pca_3 = pca_3.fit_transform(X)

X_pca_3.shape
```


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Wybór modelu - Model Selection - na podstawie rodzaju problemu
wybierany jest odpowiedni algorytm, taki jak regresja liniowa, drzewa
decyzyjne czy sieci neuronowe. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 zwróć uwagę na interpretację metryk.

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

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

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

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

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

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

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

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

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


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 wskaż X i y.

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

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

df = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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:
KNN klasyfikuje obserwację na podstawie klas jej najbliższych sąsiadów. ## Zadanie 1

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

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

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

```python
df.shape

df.columns
```


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 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/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: Pierwszym etapem analizy jest wczytanie danych i sprawdzenie ich struktury. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv. Problem: wczytanie i podstawowa eksploracja danych. Kolumny: sepal_length, sepal_width, petal_length, petal_width, species. Target: opcjonalny. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/iris.csv"
df = pd.read_csv(url)

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


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

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

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

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

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

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

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


Instruction: 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 train_test_split z random_state=42.

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. 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 sprawdź brakujące wartości przed modelem.

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

Porównaj wynik z poprzednim modelem.

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

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

```python
# Wyjaśnienie: wykonaj krok i zinterpretuj wynik w komentarzu.
model_score = model.score(X_test, y_test)
gini_score = model_gini.score(X_test, y_test)

model_score, gini_score
```


Instruction:
Składowe uczenia maszynowego
• Dane i wzorce - komputerom dostarcza się dane, które mogą być
obserwacjami, interakcjami lub przykładami. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv. Problem: redukcja wymiaru i analiza wariancji cech. Kolumny: mpg, cylinders, displacement, horsepower, weight, acceleration, origin. Target: opcjonalny, nieużywany w PCA. Wykonaj pełny pipeline ML: wczytanie, EDA, preprocessing, model lub metoda, ocena. Dodatkowo 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/mpg.csv").dropna()
X = pd.get_dummies(df.drop(columns=["mpg"], errors="ignore"), drop_first=True)

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


Instruction:
Wybór reprezentacji danych
• dla obrazu: piksele, histogramy , transformacje (Fouriera, falkowa),
• dla tekstu: wektory TF-IDF , embeddingi,
• dla dźwięku: współczynniki MFCC, energia pasmowa. Masz dataset pod adresem https://raw.githubusercontent.com/mwaskom/seaborn-data/master/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 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/tips.csv")
print(df.head())
print(df.shape)
print(df.isna().sum())

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

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


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

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

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

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

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

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

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


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

Sprawdź rozmiar X i y.

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

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

```python
X.shape

y.shape
```


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

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

```python
import pandas as pd

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

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


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

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

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

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

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

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

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


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

Sprawdź ile cech powstało po transformacji.

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

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

```python
X = transformer.fit_transform(df)

X.shape
```


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

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

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

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

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

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

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