Level 3: Advanced Python for Data Science!

import pandas as pd
import numpy as np

class DataProcessor:
    def __init__(self, data):
        self.data = pd.DataFrame(data)

    def clean_column_names(self):
        self.data.columns = self.data.columns.str.lower().str.replace(' ', '_')

    def fill_missing_values(self, column, method='mean', value=None):
        if method == 'mean':
            self.data[column].fillna(self.data[column].mean(), inplace=True)
        elif method == 'median':
            self.data[column].fillna(self.data[column].median(), inplace=True)
        elif method == 'value':
            if value is not None:
                self.data[column].fillna(value, inplace=True)
            else:
                print("Error: Value must be provided for 'value' method.")
        else:
            print("Error: Invalid method for filling missing values.")

    def filter_by_condition(self, column, operator, value):
        if operator == '>':
            return self.data[self.data[column] > value]
        elif operator == '<':
            return self.data[self.data[column] < value]
        elif operator == '==':
            return self.data[self.data[column] == value]
        else:
            print("Error: Invalid operator.")
            return self.data

# Example Usage
complex_data = {'Name': ['Alice', 'Bob', None, 'David', 'Eve'],
                'Age': [25, None, 22, 35, 28],
                'Salary': [50000, 60000, 45000, None, 70000]}
processor = DataProcessor(complex_data)

processor.clean_column_names()
print("Cleaned Column Names:\n", processor.data.columns)

processor.fill_missing_values('Age', method='mean')
processor.fill_missing_values('Salary', method='value', value=0)
print("\nData with Filled Missing Values:\n", processor.data)

filtered_data = processor.filter_by_condition('Age', '>', 25)
print("\nFiltered Data (Age > 25):\n", filtered_data)

Code Explanation

The code defines a DataProcessor class in Python that encapsulates several common data manipulation operations using the Pandas library. Let’s break down each part:

• import pandas as pd: Imports the Pandas library, which provides powerful data structures like DataFrames for efficient data manipulation.
• import numpy as np: Imports the NumPy library, which is often used in conjunction with Pandas for numerical operations, though it’s not directly used in this specific code.
• DataProcessor Class:
  • __init__(self, data):
    • The constructor of the class. It takes a dictionary or a Pandas Series/DataFrame as input and initializes the DataProcessor object.
    • self.data = pd.DataFrame(data): Converts the input data into a Pandas DataFrame and stores it in the self.data attribute. This ensures that the data being processed is always in a DataFrame format.
  • clean_column_names(self):
    • This method cleans the column names of the DataFrame.
    • self.data.columns.str.lower(): Converts all column names to lowercase.
    • .str.replace(' ', '_'): Replaces any spaces in the column names with underscores.
    • The cleaned column names are then assigned back to self.data.columns.
  • fill_missing_values(self, column, method='mean', value=None):
    • This method fills missing values (NaNs) in a specified column.
    • column: The name of the column to fill missing values in.
    • method: The method for filling missing values (default is ‘mean’). It can be ‘mean’, ‘median’, or ‘value’.
    • value: The value to use when the method is ‘value’.
    • The method uses a conditional structure (if-elif-else) to determine how to fill the missing values:
      • If method == 'mean': Fills missing values with the mean of the column.
      • If method == 'median': Fills missing values with the median of the column.
      • If method == 'value':
        • If value is not None: Fills missing values with the provided value.
        • Else: Prints an error message indicating that a value must be provided.
      • Else: Prints an error message indicating that the method is invalid.
    • inplace=True: Modifies the DataFrame directly.
  • filter_by_condition(self, column, operator, value):
    • This method filters the DataFrame based on a condition applied to a specified column.
    • column: The name of the column to filter on.
    • operator: The operator to use for filtering (‘>’, ‘<', or '==').
    • value: The value to compare the column values against.
    • The method uses a conditional structure to perform the filtering:
      • If operator == '>': Returns rows where the column values are greater than value.
      • If operator == '<': Returns rows where the column values are less than value.
      • If operator == '==': Returns rows where the column values are equal to value.
      • Else: Prints an error message indicating that the operator is invalid and returns the original dataframe.
• Example Usage:
  • complex_data: A dictionary containing sample data with missing values and different data types.
  • processor = DataProcessor(complex_data): Creates an instance of the DataProcessor class with the sample data.
  • processor.clean_column_names(): Calls the clean_column_names() method to convert column names to lowercase and replace spaces with underscores.
  • print("Cleaned Column Names:\n", processor.data.columns): Prints the cleaned column names.
  • processor.fill_missing_values('Age', method='mean'): Fills missing values in the 'Age' column with the mean age.
  • processor.fill_missing_values('Salary', method='value', value=0): Fills missing values in the 'Salary' column with 0.
  • print("\nData with Filled Missing Values:\n", processor.data): Prints the DataFrame after filling the missing values.
  • filtered_data = processor.filter_by_condition('Age', '>', 25): Filters the DataFrame to get rows where 'Age' is greater than 25.
  • print("\nFiltered Data (Age > 25):\n", filtered_data): Prints the filtered data.

In essence, the DataProcessor class provides a reusable way to perform common data cleaning and preprocessing steps. This promotes better organization and maintainability of your data manipulation code.

# Example: Creating a new feature 'Age_Squared'
processor.data['Age_Squared'] = processor.data['Age'] ** 2
print("\nData with Age Squared Feature:\n", processor.data)

# Example: Creating a categorical feature from a numerical one
bins = [0, 30, 60, 100]
labels = ['Young', 'Adult', 'Senior']
processor.data['Age_Group'] = pd.cut(processor.data['Age'], bins=bins, labels=labels, right=False)
print("\nData with Age Group Feature:\n", processor.data)

# Example: Handling categorical features using one-hot encoding
processor.data = pd.get_dummies(processor.data, columns=['Name', 'City'], drop_first=True)
print("\nData with One-Hot Encoded Features (Illustrative - 'City' column not in initial data):\n", processor.data)

Code Explanation

This code demonstrates three key data preprocessing techniques using the Pandas library: feature engineering, creating categorical features from numerical ones, and handling categorical features with one-hot encoding.

• Feature Engineering: Creating 'Age_Squared'
  • processor.data['Age_Squared'] = processor.data['Age'] ** 2:
    • Creates a new column named 'Age_Squared' in the DataFrame processor.data.
    • Calculates the square of the values in the 'Age' column for each row and assigns the result to the corresponding row in the 'Age_Squared' column.
    • This is a common feature engineering technique used to capture non-linear relationships between a variable (Age) and the target variable. For example, the effect of age on a certain outcome might increase exponentially rather than linearly.
  • print("\nData with Age Squared Feature:\n", processor.data): Prints the DataFrame processor.data to the console, showing the newly created 'Age_Squared' column and its values.
• Creating Categorical Feature from Numerical: 'Age_Group'
  • bins = [0, 30, 60, 100]
labels = ['Young', 'Adult', 'Senior']
processor.data['Age_Group'] = pd.cut(processor.data['Age'], bins=bins, labels=labels, right=False)
    • bins = [0, 30, 60, 100]: Defines the boundaries of the age groups. The values represent the lower bounds of each bin. So, the first bin is `[0, 30)`, the second is `[30, 60)`, and the third is `[60, 100]`.
    • labels = ['Young', 'Adult', 'Senior']: Provides labels for the age groups defined by the `bins`.
    • pd.cut(processor.data['Age'], bins=bins, labels=labels, right=False):
      • pd.cut(): This is a Pandas function used to bin a numerical variable into discrete intervals.
      • processor.data['Age']: Specifies the 'Age' column from the DataFrame to be binned.
      • bins=bins: Uses the `bins` list to define the intervals for binning.
      • labels=labels: Assigns the specified labels to the bins.
      • right=False: This is crucial. It specifies that the bins are left-closed and right-open. This means that a value of 30 will be included in the 'Adult' group, not the 'Young' group. If `right` were `True` (the default), it would be right-closed and left-open, and 30 would be in 'Young'.
    • Creates a new column named 'Age_Group' in the DataFrame, where each person is assigned to a group based on their age.
  • print("\nData with Age Group Feature:\n", processor.data): Prints the DataFrame with the new 'Age_Group' column.
• Handling Categorical Features: One-Hot Encoding
  • processor.data = pd.get_dummies(processor.data, columns=['Name', 'City'], drop_first=True):
    • pd.get_dummies(): This is a Pandas function that converts categorical variables into a set of binary (0 or 1) variables. This process is called one-hot encoding.
    • columns=['Name', 'City']: Specifies the columns to be one-hot encoded. It will create new columns for each unique value in the 'Name' and 'City' columns.
    • drop_first=True: This is important for avoiding multicollinearity in statistical models. When you have a categorical variable with *n* categories, you only need *n-1* dummy variables to represent it. `drop_first=True` drops the first dummy variable, which removes the redundancy.
    • The result is assigned back to processor.data, replacing the original categorical columns with the new binary columns.
  • print("\nData with One-Hot Encoded Features (Illustrative - 'City' column not in initial data):\n", processor.data): Prints the modified DataFrame.

This code snippet demonstrates how to perform common feature engineering tasks: creating new features from existing ones, binning numerical data into categorical groups, and converting categorical variables into a numerical format suitable for machine learning models using one-hot encoding.

import pandas as pd
import numpy as np

class DataProcessor:
    def __init__(self, data):
        self.data = pd.DataFrame(data)

    def clean_column_names(self):
        self.data.columns = self.data.columns.str.lower().str.replace(' ', '_')

    def fill_missing_values(self, column, method='mean', value=None):
        if method == 'mean':
            self.data[column].fillna(self.data[column].mean(), inplace=True)
        elif method == 'median':
            self.data[column].fillna(self.data[column].median(), inplace=True)
        elif method == 'value':
            if value is not None:
                self.data[column].fillna(value, inplace=True)
            else:
                print("Error: Value must be provided for 'value' method.")
        else:
            print("Error: Invalid method for filling missing values.")

    def filter_by_condition(self, column, operator, value):
        if operator == '>':
            return self.data[self.data[column] > value]
        elif operator == '<':
            return self.data[self.data[column] < value]
        elif operator == '==':
            return self.data[self.data[column] == value]
        else:
            print("Error: Invalid operator.")
            return self.data

# Example Usage
complex_data = {'Name': ['Alice', 'Bob', None, 'David', 'Eve'],
                'Age': [25, None, 22, 35, 28],
                'Salary': [50000, 60000, 45000, None, 70000]}
processor = DataProcessor(complex_data)

processor.clean_column_names()
print("Cleaned Column Names:\n", processor.data.columns)

processor.fill_missing_values('age', method='mean')  # Changed 'Age' to 'age'
processor.fill_missing_values('salary', method='value', value=0)  # Changed 'Salary' to 'salary'
print("\nData with Filled Missing Values:\n", processor.data)

filtered_data = processor.filter_by_condition('age', '>', 25)  # Changed 'Age' to 'age'
print("\nFiltered Data (Age > 25):\n", filtered_data)

Code Explanation

The code defines a DataProcessor class in Python that encapsulates several common data manipulation operations using the Pandas library. Let's break down each part:

• import pandas as pd: Imports the Pandas library, which provides powerful data structures like DataFrames for efficient data manipulation.
• import numpy as np: Imports the NumPy library, which is often used in conjunction with Pandas for numerical operations, though it's not directly used in this specific code.
• DataProcessor Class:
  • __init__(self, data):
    • The constructor of the class. It takes a dictionary or a Pandas Series/DataFrame as input and initializes the DataProcessor object.
    • self.data = pd.DataFrame(data): Converts the input data into a Pandas DataFrame and stores it in the self.data attribute. This ensures that the data being processed is always in a DataFrame format.
  • clean_column_names(self):
    • This method cleans the column names of the DataFrame.
    • self.data.columns.str.lower(): Converts all column names to lowercase.
    • .str.replace(' ', '_'): Replaces any spaces in the column names with underscores.
    • The cleaned column names are then assigned back to self.data.columns.
  • fill_missing_values(self, column, method='mean', value=None):
    • This method fills missing values (NaNs) in a specified column.
    • column: The name of the column to fill missing values in.
    • method: The method for filling missing values (default is 'mean'). It can be 'mean', 'median', or 'value'.
    • value: The value to use when the method is 'value'.
    • The method uses a conditional structure (if-elif-else) to determine how to fill the missing values:
      • If method == 'mean': Fills missing values with the mean of the column.
      • If method == 'median': Fills missing values with the median of the column.
      • If method == 'value':
        • If value is not None: Fills missing values with the provided value.
        • Else: Prints an error message indicating that a value must be provided.
      • Else: Prints an error message indicating that the method is invalid.
    • inplace=True: Modifies the DataFrame directly.
  • filter_by_condition(self, column, operator, value):
    • This method filters the DataFrame based on a condition applied to a specified column.
    • column: The name of the column to filter on.
    • operator: The operator to use for filtering ('>', '<', or '==').
    • value: The value to compare the column values against.
    • The method uses a conditional structure to perform the filtering:
      • If operator == '>': Returns rows where the column values are greater than value.
      • If operator == '<': Returns rows where the column values are less than value.
      • If operator == '==': Returns rows where the column values are equal to value.
      • Else: Prints an error message indicating that the operator is invalid and returns the original dataframe.
• Example Usage:
  • complex_data: A dictionary containing sample data with missing values.
  • processor = DataProcessor(complex_data): Creates an instance of the DataProcessor class with the sample data.
  • processor.clean_column_names(): Calls the clean_column_names() method to convert column names to lowercase and replace spaces with underscores.
  • print("Cleaned Column Names:\n", processor.data.columns): Prints the cleaned column names.
  • processor.fill_missing_values('age', method='mean'): Fills missing values in the 'age' column with the mean age.
  • processor.fill_missing_values('salary', method='value', value=0): Fills missing values in the 'salary' column with 0.
  • print("\nData with Filled Missing Values:\n", processor.data): Prints the DataFrame after filling the missing values.
  • filtered_data = processor.filter_by_condition('age', '>', 25): Filters the DataFrame to get rows where 'age' is greater than 25.
  • print("\nFiltered Data (Age > 25):\n", filtered_data): Prints the filtered data.

The code defines a class DataProcessor to handle common data processing tasks using Pandas. The class constructor initializes the data as a Pandas DataFrame. The clean_column_names method converts column names to lowercase and replaces spaces with underscores. The fill_missing_values method fills missing values in a column using either the mean, median, or a specified value. The filter_by_condition method filters the data based on a given condition. The example usage demonstrates how to use this class to clean, fill missing values, and filter a sample dataset.

import pandas as pd
import numpy as np

class DataProcessor:
    def __init__(self, data):
        self.data = pd.DataFrame(data)

    def clean_column_names(self):
        self.data.columns = self.data.columns.str.lower().str.replace(' ', '_')

    def fill_missing_values(self, column, method='mean', value=None):
        if method == 'mean':
            self.data[column].fillna(self.data[column].mean(), inplace=True)
        elif method == 'median':
            self.data[column].fillna(self.data[column].median(), inplace=True)
        elif method == 'value':
            if value is not None:
                self.data[column].fillna(value, inplace=True)
            else:
                print("Error: Value must be provided for 'value' method.")
        else:
            print("Error: Invalid method for filling missing values.")

    def filter_by_condition(self, column, operator, value):
        if operator == '>':
            return self.data[self.data[column] > value]
        elif operator == '<':
            return self.data[self.data[column] < value]
        elif operator == '==':
            return self.data[self.data[column] == value]
        else:
            print("Error: Invalid operator.")
            return self.data

# Example Usage
complex_data = {'Name': ['Alice', 'Bob', None, 'David', 'Eve'],
                'Age': [25, None, 22, 35, 28],
                'Salary': [50000, 60000, 45000, None, 70000]}
processor = DataProcessor(complex_data)

processor.clean_column_names()
print("Cleaned Column Names:\n", processor.data.columns)

processor.fill_missing_values('age', method='mean')  # Changed 'Age' to 'age'
processor.fill_missing_values('salary', method='value', value=0)  # Changed 'Salary' to 'salary'
print("\nData with Filled Missing Values:\n", processor.data)

filtered_data = processor.filter_by_condition('age', '>', 25)  # Changed 'Age' to 'age'
print("\nFiltered Data (Age > 25):\n", filtered_data)

Code Explanation

The code defines a DataProcessor class in Python that encapsulates several common data manipulation operations using the Pandas library. Let's break down each part:

• import pandas as pd: Imports the Pandas library, which provides powerful data structures like DataFrames for efficient data manipulation.
• import numpy as np: Imports the NumPy library, which is often used in conjunction with Pandas for numerical operations, though it's not directly used in this specific code.
• DataProcessor Class:
  • __init__(self, data):
    • The constructor of the class. It takes a dictionary or a Pandas Series/DataFrame as input and initializes the DataProcessor object.
    • self.data = pd.DataFrame(data): Converts the input data into a Pandas DataFrame and stores it in the self.data attribute. This ensures that the data being processed is always in a DataFrame format.
  • clean_column_names(self):
    • This method cleans the column names of the DataFrame.
    • self.data.columns.str.lower(): Converts all column names to lowercase.
    • .str.replace(' ', '_'): Replaces any spaces in the column names with underscores.
    • The cleaned column names are then assigned back to self.data.columns.
  • fill_missing_values(self, column, method='mean', value=None):
    • This method fills missing values (NaNs) in a specified column.
    • column: The name of the column to fill missing values in.
    • method: The method for filling missing values (default is 'mean'). It can be 'mean', 'median', or 'value'.
    • value: The value to use when the method is 'value'.
    • The method uses a conditional structure (if-elif-else) to determine how to fill the missing values:
      • If method == 'mean': Fills missing values with the mean of the column.
      • If method == 'median': Fills missing values with the median of the column.
      • If method == 'value':
        • If value is not None: Fills missing values with the provided value.
        • Else: Prints an error message indicating that a value must be provided.
      • Else: Prints an error message indicating that the method is invalid.
    • inplace=True: Modifies the DataFrame directly.
  • filter_by_condition(self, column, operator, value):
    • This method filters the DataFrame based on a condition applied to a specified column.
    • column: The name of the column to filter on.
    • operator: The operator to use for filtering ('>', '<', or '==').
    • value: The value to compare the column values against.
    • The method uses a conditional structure to perform the filtering:
      • If operator == '>': Returns rows where the column values are greater than value.
      • If operator == '<': Returns rows where the column values are less than value.
      • If operator == '==': Returns rows where the column values are equal to value.
      • Else: Prints an error message indicating that the operator is invalid and returns the original dataframe.
• Example Usage:
  • complex_data: A dictionary containing sample data with missing values.
  • processor = DataProcessor(complex_data): Creates an instance of the DataProcessor class with the sample data.
  • processor.clean_column_names(): Calls the clean_column_names() method to convert column names to lowercase and replace spaces with underscores.
  • print("Cleaned Column Names:\n", processor.data.columns): Prints the cleaned column names.
  • processor.fill_missing_values('age', method='mean'): Fills missing values in the 'age' column with the mean age.
  • processor.fill_missing_values('salary', method='value', value=0): Fills missing values in the 'salary' column with 0.
  • print("\nData with Filled Missing Values:\n", processor.data): Prints the DataFrame after filling the missing values.
  • filtered_data = processor.filter_by_condition('age', '>', 25): Filters the DataFrame to get rows where 'age' is greater than 25.
  • print("\nFiltered Data (Age > 25):\n", filtered_data): Prints the filtered data.

The code defines a class DataProcessor to handle common data processing tasks using Pandas. The class constructor initializes the data as a Pandas DataFrame. The clean_column_names method converts column names to lowercase and replaces spaces with underscores. The fill_missing_values method fills missing values in a column using either the mean, median, or a specified value. The filter_by_condition method filters the data based on a given condition. The example usage demonstrates how to use this class to clean, fill missing values, and filter a sample dataset.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import numpy as np
import warnings
warnings.filterwarnings('ignore')

# 1. Data Preparation
# -----------------
#  Load your data here.  Replace this with your actual data loading.
#  For demonstration, we'll create a sample dataset.
X = np.array([[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5],
             [0, 1], [1, 0], [2, 1], [3, 0], [4, 1], [5, 0]]) # Sample features
y = np.array([0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2])  # Sample target variable

#  Split the data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 2. Pipeline Creation
# ------------------
#  Create a pipeline that first scales the data using StandardScaler,
#  and then trains an SVM classifier.
pipeline = Pipeline([
    ('scaler', StandardScaler()),   # Scale features to have mean=0 and variance=1
    ('svm', SVC(random_state=42))     # Support Vector Machine classifier
])

# 3. Hyperparameter Tuning with GridSearchCV
# ------------------------------------------
#  Define the hyperparameters to search over.
#  'svm__C' refers to the 'C' parameter of the SVC estimator in the pipeline.
#  'svm__gamma' refers to the 'gamma' parameter of the SVC estimator.
param_grid = {
    'svm__C': [0.1, 1, 10, 100],         # Regularization parameter C
    'svm__gamma': ['scale', 'auto', 0.1, 1, 10]  # Kernel coefficient gamma
}

#  Use StratifiedKFold for cross-validation to handle potential class imbalance.
#  Check the number of unique classes in the training data.  If there are fewer
#  than n_splits in any one class, reduce n_splits to the smallest number of
#  samples in any class.
n_splits = min(5, min(np.bincount(y_train))) # changed cv
cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)
#  Perform GridSearchCV to find the best combination of hyperparameters.
#  - 'pipeline': The pipeline we defined earlier.
#  - 'param_grid': The hyperparameters to search over.
#  - 'cv': The cross-validation strategy.
#  - 'scoring': The metric to optimize ('accuracy' in this case).
grid_search = GridSearchCV(pipeline, param_grid, cv=cv, scoring='accuracy', verbose=2, n_jobs=-1)

#  Fit the GridSearchCV object to the training data.  This will perform the hyperparameter search.
grid_search.fit(X_train, y_train)

#  Print the best hyperparameters found by GridSearchCV.
print("Best Hyperparameters:", grid_search.best_params_)

#  Print the best cross-validation score achieved with the best hyperparameters.
print("Best Cross-Validation Score:", grid_search.best_score_)

# 4. Model Evaluation
# ------------------
#  Get the best model from the GridSearchCV object.  This is the model trained with the
#  optimal hyperparameters found during the search.
best_model = grid_search.best_estimator_

#  Make predictions on the test set using the best model.
y_pred = best_model.predict(X_test)

#  Evaluate the performance of the best model on the test set.
print("Test Accuracy:", accuracy_score(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))

Code Explanation

This code demonstrates how to build and evaluate a Support Vector Machine (SVM) classifier using scikit-learn, incorporating best practices like data scaling, pipeline construction, hyperparameter tuning, and stratified cross-validation. Here's a step-by-step explanation:

• from sklearn.pipeline import Pipeline: Imports the Pipeline class, which allows you to chain multiple data transformations and an estimator into a single object.
• from sklearn.preprocessing import StandardScaler: Imports the StandardScaler, used for scaling numerical features to have a mean of 0 and a standard deviation of 1.
• from sklearn.model_selection import GridSearchCV, StratifiedKFold:
  • GridSearchCV: Imports the GridSearchCV class, used for performing an exhaustive search over a grid of hyperparameter values for an estimator.
  • StratifiedKFold: Imports the StratifiedKFold class, a cross-validation technique that ensures each fold has the same proportion of samples from each class. This is important for imbalanced datasets.
• from sklearn.svm import SVC: Imports the SVC class, which implements the Support Vector Machine classifier.
• from sklearn.model_selection import train_test_split: Imports the train_test_split function to split the dataset into training and testing sets.
• from sklearn.metrics import accuracy_score, classification_report: Imports functions for evaluating the model's performance:
  • accuracy_score: Calculates the accuracy of the classifier.
  • classification_report: Generates a detailed report including precision, recall, F1-score, and support for each class.
• import numpy as np: Imports the NumPy library for numerical computations.
• import warnings: Imports the warnings module to manage warning messages.
• warnings.filterwarnings('ignore'): This line suppresses warning messages. It's often used to keep the output clean, but it's generally recommended to address warnings rather than suppress them.
• 1. Data Preparation:
  • X = np.array([[0, 0], [1, 1], ..., [5, 0]]): Creates a sample feature matrix X using NumPy. Each row represents a sample, and each column represents a feature.
  • y = np.array([0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2]): Creates a sample target variable array y, where each element corresponds to the class label of the respective sample in X.
  • X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42): Splits the data into training and testing sets using train_test_split.
    • test_size=0.2: 20% of the data is reserved for testing.
    • random_state=42: Ensures the split is reproducible.
• 2. Pipeline Creation:
  • pipeline = Pipeline([...]): Creates a Pipeline object.
  • ('scaler', StandardScaler()): The first step in the pipeline is to scale the features using StandardScaler. This is crucial for SVMs, as they are sensitive to the scale of the input features.
  • ('svm', SVC(random_state=42)): The second step is to train an SVM classifier (SVC). random_state ensures reproducibility.
• 3. Hyperparameter Tuning with GridSearchCV:
  • param_grid = {...}: Defines the hyperparameters to tune:
    • 'svm__C': The regularization parameter for the SVM (C). Smaller values of C lead to a wider margin, allowing some misclassifications, while larger values enforce a narrower margin with fewer misclassifications.
    • 'svm__gamma': The kernel coefficient gamma. It defines how much influence a single training example has. Small gamma means a large radius of similarity, and high gamma means a small radius. 'scale' and 'auto' are special values that automatically determine gamma based on the data.
  • n_splits = min(5, min(np.bincount(y_train)))): Calculates the number of splits for StratifiedKFold. It ensures that the number of splits does not exceed the number of samples in the smallest class.
  • cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42): Creates a StratifiedKFold object for cross-validation.
    • n_splits=n_splits: Uses the calculated number of splits.
    • shuffle=True: Shuffles the data before splitting to reduce the risk of bias.
    • random_state=42: Ensures reproducible splits.
  • grid_search = GridSearchCV(pipeline, param_grid, cv=cv, scoring='accuracy', verbose=2, n_jobs=-1): Creates a GridSearchCV object.
    • pipeline: The pipeline to tune.
    • param_grid: The hyperparameters to search over.
    • cv=cv: The cross-validation strategy.
    • scoring='accuracy': The metric to optimize.
    • verbose=2: Controls the verbosity of the output (higher value, more output).
    • n_jobs=-1: Uses all available cores for parallel processing.
  • grid_search.fit(X_train, y_train): Fits the GridSearchCV object to the training data. This performs the hyperparameter search and cross-validation.
  • print("Best Hyperparameters:", grid_search.best_params_): Prints the best hyperparameters found.
  • print("Best Cross-Validation Score:", grid_search.best_score_): Prints the best cross-validation score.
• 4. Model Evaluation:
  • best_model = grid_search.best_estimator_: Gets the best trained model from the GridSearchCV object.
  • y_pred = best_model.predict(X_test): Makes predictions on the test set using the best model.
  • print("Test Accuracy:", accuracy_score(y_test, y_pred)): Prints the accuracy on the test set.
  • print("Classification Report:\n", classification_report(y_test, y_pred)): Prints a detailed classification report.

This code demonstrates a robust approach to building an SVM classifier, including data preprocessing, model selection, and evaluation. Key concepts include:

• Pipelines for organizing and standardizing workflows.
• StandardScaler for feature scaling.
• GridSearchCV for hyperparameter tuning.
• StratifiedKFold for cross-validation, especially important for imbalanced data.
• Evaluation using accuracy and a classification report.