IML_Assignments/Assignment1/s.faizullin@innopolis.university (2).ipynb

📌 Machine Learning Assignment 1 - Instructions & Guidelines

📝 General Guidelines

Welcome to Machine Learning Assignment 1! This assignment will test your understanding of regression and classification models, including data preprocessing, hyperparameter tuning, and model evaluation.

Follow the instructions carefully, and ensure your implementation is correct, well-structured, and efficient.

🔹 Submission Format:

• Your submission must be a single Jupyter Notebook (.ipynb) file.
• File Naming Convention:
  • Use your university email as the filename, e.g.,

    j.doe@innopolis.university.ipynb
    

  • Do NOT modify this format, or your submission may not be graded.

🔹 Assignment Breakdown:

Task	Description	Points
Task 1.1	Linear Regression	20
Task 1.2	Polynomial Regression	20
Task 2.1	Data Preprocessing	15
Task 2.2	Model Comparison	45
Total	-	100

---

📂 Dataset & Assumptions

The dataset files are stored in the datasets/ folder.

• Regression Dataset: datasets/task1_data.csv
• Classification Dataset: datasets/pokemon_modified.csv

Each dataset is structured as follows:

🔹 task1_data.csv (for regression tasks)

• Contains X_train, y_train, X_test, and y_test.
• The goal is to fit linear and polynomial regression models and evaluate their performance.

🔹 pokemon_modified.csv (for classification tasks)

• Contains Pokémon attributes, with is_legendary as the binary target variable (0 or 1).
• Some features contain missing values and categorical variables, requiring preprocessing.

---

🚀 How to Approach the Assignment

1. Start with Regression (Task 1)

   • Implement linear regression and polynomial regression.
   • Use GridSearchCV for polynomial regression to find the best degree.
   • Evaluate using MSE, RMSE, MAE, and R² Score.

2. Move to Data Preprocessing (Task 2.1)

   • Load and clean the Pokémon dataset.
   • Handle missing values correctly.
   • Encode categorical variables properly.
   • Ensure no data leakage when doing the preprocessing.

3. Train and Evaluate Classification Models (Task 2.2)

   • Train Logistic Regression, KNN, and Naive Bayes.
   • Use GridSearchCV for hyperparameter tuning.
   • Evaluate models using Accuracy, Precision, Recall, and F1-score.

---

📌 Grading & Evaluation

• Your notebook will be autograded, so ensure:
  • Your function names exactly match the given specifications.
  • Your output format matches the expected results.
• Partial credit will be given where applicable.

🔹 Need Help?

• If you have any questions, refer to the assignment markdown instructions in each task before asking for clarifications.
• You can post your question on this Google sheet

🚀 Good luck! Happy coding! 🎯

FAQ

1) Should we include the lines to import the libraries?

• Answer:
  It doesn't matter if you include extra import lines, as the grader will only call the specified functions.

2) Is it okay to submit my file with code outside of the functions?

• Answer:
  Yes, you can include additional code outside of the functions as long as the entire script runs correctly when converted to a .py file.

Important Clarification:

• The grader will first convert the Jupyter Notebook (.ipynb) into a Python file (.py) and then run it.
• Note: Please do not include any commands like !pip install numpy because they may break the conversion process and therefore the submission will not be graded.

Task 1: Linear and Polynomial Regression (30 Points)

Task 1.1 - Linear Regression (15 Points)

Instructions

1. Load the dataset from datasets/task1_data.csv.
2. Extract training and testing data from the following columns:
   • "X_train": Training feature values.
   • "y_train": Training target values.
   • "X_test": Testing feature values.
   • "y_test": Testing target values.
3. Train a linear regression model on X_train and y_train.
4. Use the trained model to predict y_test values.
5. Compute and return the following evaluation metrics as a dictionary:
   • Mean Squared Error (MSE)
   • Root Mean Squared Error (RMSE)
   • Mean Absolute Error (MAE)
   • R² Score
6. The function signature should match:

   def task1_linear_regression() -> Dict[str, float]:
   

Please do not use any other libraries except for the ones imported below.

In [21]:

# Standard Library Imports
import os
import importlib.util
import nbformat
from tempfile import NamedTemporaryFile
from typing import Tuple, Dict

# Third-Party Library Imports
import numpy as np
import pandas as pd

from nbconvert import PythonExporter

# Scikit-Learn Imports
from sklearn.preprocessing import MinMaxScaler, StandardScaler, PolynomialFeatures, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
                             mean_squared_error, mean_absolute_error, r2_score)
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB

In [22]:

def task1_linear_regression() -> Dict[str, float]:
    """
    Performs linear regression on a predefined dataset and returns performance metrics.

    **Dataset Assumption:**
    - The dataset is located at `"datasets/task1_data.csv"`.
    - It should contain the following columns:
      - `"X_train"`: Training feature values (numerical).
      - `"y_train"`: Training target values.
      - `"X_test"`: Testing feature values (numerical).
      - `"y_test"`: Testing target values.

    **Process:**
    1. Load the dataset from `"datasets/task1_data.csv"`.
    2. Extract training and testing data.
    3. Train a linear regression model on `X_train, y_train`.
    4. Use the trained model to predict `y_test` values.
    5. Compute evaluation metrics: **MSE, RMSE, MAE, R² Score**.

    **Output (Dictionary with Regression Metrics):**
    ```python
    {
        "MSE": <Mean Squared Error>,
        "RMSE": <Root Mean Squared Error>,
        "MAE": <Mean Absolute Error>,
        "R2": <R² Score>
    }
    ```
    """
    df = pd.read_csv('datasets/task1_data.csv')
    X_train, y_train, X_test, y_test = df['X_train'].to_numpy().reshape((-1, 1)), df['y_train'], df['X_test'].to_numpy().reshape((-1, 1)), df['y_test']
    model = LinearRegression()
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    return {
        'MSE': mean_squared_error(y_test, y_pred),
        'RMSE': mean_squared_error(y_test, y_pred) ** 0.5,
        'MAE': mean_absolute_error(y_test, y_pred),
        'R2': r2_score(y_test, y_pred),
    }

Task 1.2 - Polynomial Regression (15 Points)

Instructions

1. Load the dataset from datasets/task1_data.csv.
2. Extract training and testing data from the following columns:
   • "X_train": Training feature values.
   • "y_train": Training target values.
   • "X_test": Testing feature values.
   • "y_test": Testing target values.
3. Define a pipeline that includes:
   • Polynomial feature transformation (degree range: 2 to 10).
   • Linear regression model.
4. Use GridSearchCV with 8-fold cross-validation to determine the best polynomial degree.
5. Train the model with the best polynomial degree and evaluate it on the test set.
6. Compute and return the following results as a dictionary:
   • Best polynomial degree (best_degree)
   • Mean Squared Error (MSE)

Function Signature

def task1_polynomial_regression() -> Dict[str, float]:

In [23]:

def task1_polynomial_regression() -> Dict[str, float]:
    """
    Performs polynomial regression using GridSearchCV to find the best polynomial degree.


    **Process:**
    1. Load the dataset and extract `X_train, y_train, X_test, y_test`.
    2. Define a **pipeline** with polynomial feature transformation and linear regression.
    3. Use **GridSearchCV** (with 8-fold cross-validation) to determine the best polynomial degree (range: **2 to 10**).
    4. Train the best polynomial regression model and evaluate its performance.
    5. Compute and return:
       - **Best polynomial degree (`best_degree`)**
       - **Mean Squared Error (MSE)**

     **Expected Output:**
    ```
    {
        "best_degree": <Optimal Polynomial Degree>,
        "MSE": <Mean Squared Error>
    }
    ```
    """
    df = pd.read_csv('datasets/task1_data.csv')
    X_train, y_train, X_test, y_test = df['X_train'].to_numpy().reshape((-1, 1)), df['y_train'], df['X_test'].to_numpy().reshape((-1, 1)), df['y_test']
    pipeline = Pipeline([
        ('polynomial', PolynomialFeatures()),
        ('linear', LinearRegression())
    ])
    grid_search = GridSearchCV(pipeline, {
        'polynomial__degree': range(2, 11)
    }, cv=8)
    grid_search.fit(X_train, y_train)


    return {
        'best_degree': grid_search.best_params_['polynomial__degree'],
        'MSE': mean_squared_error(y_test, grid_search.best_estimator_.predict(X_test)),
    }

Task 2: Classification with Data Preprocessing (70 Points)

Task 2.1 - Data Preprocessing (30 Points)

Instructions

1. Load the dataset from datasets/pokemon_modified.csv.
2. Look at the data and study the provided features
3. Remove the two redundant features
4. Handle missing values:
   • Use mean imputation for "height_m" and "weight_kg".
   • Use median imputation for "percentage_male".
5. Perform one-hot encoding for the categorical column "type1".
6. Ensure the target variable ("is_legendary") is present.
7. Split the data into training and testing sets (80%-20% split). Is it balanced?
8. Apply feature scaling using StandardScaler or MinMaxScaler.
9. Return the following:
   • X_train_scaled: Processed training features.
   • X_test_scaled: Processed testing features.
   • y_train: Training labels.
   • y_test: Testing labels.

Function Signature

def task2_preprocessing() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series, pd.Series]:

In [24]:

def task2_preprocessing() -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series, pd.Series]:
    """
    Preprocesses the Pokémon dataset by handling missing values, encoding categorical data,
    and applying feature scaling before returning train-test splits, ensuring class balance.

    **Dataset Assumption:**
    - The dataset is located at `"datasets/pokemon_modified.csv"`.

    **Process:**
    1. Load the dataset and remove redundant columns.
    2. Handle missing values:
       - Mean imputation for **"height_m"** and **"weight_kg"**.
       - Median imputation for **"percentage_male"**.
    3. Perform **one-hot encoding** on `"type1"`.
    4. Ensure **"is_legendary"** is present as the target variable.
    5. Split the dataset into **80% training, 20% testing** using **stratification** to maintain class balance.
    6. Apply feature scaling (**StandardScaler**).
    7. Return the preprocessed train-test splits.
    """
    df2 = pd.read_csv('datasets/pokemon_modified.csv')
    y = df2.is_legendary
    df2 = df2.drop(['is_legendary', 'name', 'classification'], axis=1)

    mean_imputation = SimpleImputer(strategy='mean')
    mean_imputation.fit(df2[['height_m', 'weight_kg']])
    df2[['height_m', 'weight_kg']] = mean_imputation.transform(df2[['height_m', 'weight_kg']])

    median_imputation = SimpleImputer(strategy='median')
    median_imputation.fit(df2[['percentage_male']])
    df2[['percentage_male']] = median_imputation.transform(df2[['percentage_male']])

    ohe = OneHotEncoder(sparse_output=False, drop='first')
    ohe.fit(df2[['type1']])
    df2 = np.concatenate([df2.drop('type1', axis=1), ohe.transform(df2[['type1']])], axis=1)
    X_train, X_test, y_train, y_test = train_test_split(df2, y, test_size=0.2, stratify=y)

    scaler = StandardScaler()
    X_train = scaler.fit_transform(X_train)
    X_test = scaler.transform(X_test)


    return pd.DataFrame(X_train), pd.DataFrame(X_test), y_train, y_test

Task 2.2 - Model Comparison (40 Points)

Instructions

1. Train three classification models on the preprocessed dataset:
   • Logistic Regression
   • K-Nearest Neighbors (KNN)
   • Gaussian Naive Bayes (GNB)
2. Use GridSearchCV for hyperparameter tuning on:
   • Logistic Regression: Regularization strength (C) and penalty (l1, l2).
   • KNN: Number of neighbors (n_neighbors), weight function, and distance metric.
3. Train each model on the training set and evaluate on the test set.
4. Compute the following evaluation metrics:
   • Accuracy
   • Precision
   • Recall
   • F1 Score
5. Return a dictionary containing the evaluation metrics for each model.

Function Signature

def task2_model_comparison() -> Dict[str, Dict[str, float]]:

In [25]:

def task2_model_comparison() -> Dict[str, Dict[str, float]]:
    """
    Trains and evaluates three classification models using GridSearchCV for hyperparameter tuning.

    **Dataset Assumption:**
    - The preprocessed dataset is obtained from `task2_preprocessing()`, which returns:
      - `X_train`: Training features (scaled)
      - `X_test`: Testing features (scaled)
      - `y_train`: Training labels
      - `y_test`: Testing labels

    **Process:**
    1. Load the preprocessed dataset from `task2_preprocessing()`.
    2. Train the following models:
       - **Logistic Regression** (Hyperparameters: `C`, `penalty`, `solver`).
       - **K-Nearest Neighbors (KNN)** (Hyperparameters: `n_neighbors`, `weights`, `metric`).
       - **Gaussian Naive Bayes** (No hyperparameter tuning required).
    3. Evaluate the models using the following metrics:
       - **Accuracy**
       - **Precision**
       - **Recall**
       - **F1 Score**
    4. Return a dictionary with model names as keys and evaluation metrics as values.

    **Expected Output:**
    ```python
    {
        "Logistic Regression": {"accuracy": <float>, "precision": <float>, "recall": <float>, "f1_score": <float>},
        "KNN": {"accuracy": <float>, "precision": <float>, "recall": <float>, "f1_score": <float>},
        "Naive Bayes": {"accuracy": <float>, "precision": <float>, "recall": <float>, "f1_score": <float>}
    }
    ```
    """
    X_train, X_test, y_train, y_test = task2_preprocessing()

    log_reg = GridSearchCV(LogisticRegression(), {
        'C': [10 ** i for i in range(-10, 11)],
        'penalty': ['l1', 'l2'],
        'solver': ['liblinear'],
        # 'solver': ['lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga']
    })
    log_reg.fit(X_train, y_train)

    knn = GridSearchCV(KNeighborsClassifier(), {
        'n_neighbors': range(1, 15),
        'weights': ['uniform', 'distance'],
        'metric': ['minkowski', 'euclidean', 'manhattan', 'cosine', 'chebyshev']
    })
    knn.fit(X_train, y_train)

    gnb = GaussianNB()
    gnb.fit(X_train, y_train)

    return {
        "Logistic Regression": {"accuracy": accuracy_score(y_test, log_reg.predict(X_test)), "precision": precision_score(y_test, log_reg.predict(X_test)), "recall": recall_score(y_test, log_reg.predict(X_test)), "f1_score": f1_score(y_test, log_reg.predict(X_test))},
        "KNN": {"accuracy": accuracy_score(y_test, knn.predict(X_test)), "precision": precision_score(y_test, knn.predict(X_test)), "recall": recall_score(y_test, knn.predict(X_test)), "f1_score": f1_score(y_test, knn.predict(X_test))},
        "Naive Bayes": {"accuracy": accuracy_score(y_test, gnb.predict(X_test)), "precision": precision_score(y_test, gnb.predict(X_test)), "recall": recall_score(y_test, gnb.predict(X_test)), "f1_score": f1_score(y_test, gnb.predict(X_test))}
    }
task2_model_comparison()

Out [25]:

{'Logistic Regression': {'accuracy': 0.9937888198757764,
  'precision': 1.0,
  'recall': 0.9285714285714286,
  'f1_score': 0.9629629629629629},
 'KNN': {'accuracy': 0.9813664596273292,
  'precision': 0.9230769230769231,
  'recall': 0.8571428571428571,
  'f1_score': 0.8888888888888888},
 'Naive Bayes': {'accuracy': 0.8385093167701864,
  'precision': 0.34210526315789475,
  'recall': 0.9285714285714286,
  'f1_score': 0.5}}