Distinguishing Classification from Clustering

• Classification is a supervised learning method, while clustering is unsupervised.
• Classification algorithms predict labels for new samples, whereas clustering reveals inherent structures within existing data.

Standardization and Normalization

numeric_features = df.select_dtypes(exclude=['object']).columns.tolist()
numeric_features.remove('outcome')  # Exclude target variable

# Standardization
# Custom function approach
def standardize_series(s):
    return (s - s.mean()) / s.std()

for col in numeric_features:
    df[col] = standardize_series(df[col])

# Library function approach
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaled_values = scaler.fit_transform(df[numeric_features])
scaled_df = pd.DataFrame(scaled_values, columns=numeric_features)
df[numeric_features] = scaled_df

# Normalization
def normalize_series(s):
    return (s - s.min()) / (s.max() - s.min())

df[numeric_features] = df[numeric_features].apply(normalize_series)

Dimensionality Reduction

from sklearn.decomposition import PCA
import numpy as np

def reduce_dimensions(dataframe, variance_threshold=0.95):
    initial_pca = PCA()
    initial_pca.fit(dataframe)
    cumulative_variance = np.cumsum(initial_pca.explained_variance_ratio_)
    
    component_count = 0
    for idx, variance in enumerate(cumulative_variance):
        if variance >= variance_threshold:
            component_count = idx + 1
            break
    
    final_pca = PCA(n_components=component_count)
    reduced_data = final_pca.fit_transform(dataframe)
    return pd.DataFrame(reduced_data)

features = df.drop('target', axis=1)
labels = df['target']
reduced_features = reduce_dimensions(features)

Splitting Data in to Training and Testing Sets

# Feature selection approaches
# Direct column selection
predictors = df[['feature_1', 'feature_2', 'feature_3']]
target = df['response']

# Column exclusion method
predictors = df.drop(['id', 'orientation', 'label'], axis=1)
target = df['label']

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    predictors, target, test_size=0.3, random_state=42
)

Classification Algorithms

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC, LinearSVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB

classifiers = {
    'Logistic Regression': LogisticRegression(),
    'Random Forest': RandomForestClassifier(),
    'SVC': SVC(),
    'Linear SVC': LinearSVC(),
    'Gradient Boosting': GradientBoostingClassifier(),
    'K-Nearest Neighbors': KNeighborsClassifier(),
    'Gaussian Naive Bayes': GaussianNB()
}

for name, clf in classifiers.items():
    clf.fit(X_train, y_train)
    accuracy = clf.score(X_test, y_test)
    print(f'{name} accuracy: {accuracy:.4f}')

Regression Models

from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.tree import DecisionTreeRegressor

regressors = {
    'Linear Regression': LinearRegression(),
    'Random Forest Regressor': RandomForestRegressor(),
    'Decision Tree Regressor': DecisionTreeRegressor()
}

for name, reg in regressors.items():
    reg.fit(X_train, y_train)
    r2_score = reg.score(X_test, y_test)
    print(f'{name} R² score: {r2_score:.4f}')

Model Evaluation Metrics

from sklearn.metrics import mean_squared_error, r2_score

predictions = model.predict(X_test)
mse_value = mean_squared_error(y_test, predictions)
r2_value = r2_score(y_test, predictions)

print(f'Mean Squared Error: {mse_value:.4f}')
print(f'R² Score: {r2_value:.4f}')

Hyperparameter Tuning with Grid Search

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV

base_model = RandomForestRegressor()
base_model.fit(X_train, y_train)
initial_score = base_model.score(X_test, y_test)
print(f'Initial model R²: {initial_score:.4f}')

parameter_grid = [
    {'n_estimators': [10, 50, 100], 'max_features': [4, 8, 12]},
    {'bootstrap': [False], 'n_estimators': [10, 30], 'max_features': [3, 6, 9]}
]

grid_search = GridSearchCV(
    base_model, parameter_grid, cv=5, scoring='neg_mean_squared_error'
)
grid_search.fit(X_train, y_train)

print('Optimal parameters:', grid_search.best_params_)
print('Best estimator:', grid_search.best_estimator_)

cv_results = grid_search.cv_results_
for score, params in zip(cv_results['mean_test_score'], cv_results['params']):
    print(f'RMSE: {np.sqrt(-score):.4f}, Parameters: {params}')

optimized_model = grid_search.best_estimator_
final_predictions = optimized_model.predict(X_test)
final_mse = mean_squared_error(y_test, final_predictions)
final_r2 = r2_score(y_test, final_predictions)
print(f'Optimized MSE: {final_mse:.4f}')
print(f'Optimized R²: {final_r2:.4f}')

Clustering Implementation

cluster_count = 4
max_iterations = 500

from sklearn.cluster import KMeans
clustering_model = KMeans(
    n_clusters=cluster_count, n_init=10, max_iter=max_iterations
)
clustering_model.fit(normalized_data)

# Assign cluster labels to original data
clustered_data = original_data.copy()
clustered_data['cluster_label'] = clustering_model.labels_

# Visualization function for cluster density plots
import matplotlib.pyplot as plt

def plot_cluster_density(dataframe, cluster_id):
    plt.figure(figsize=(12, 8))
    cluster_subset = dataframe[dataframe['cluster_label'] == cluster_id]
    numeric_cols = cluster_subset.select_dtypes(include=[np.number]).columns
    
    for idx, column in enumerate(numeric_cols, 1):
        plt.subplot(3, 4, idx)
        cluster_subset[column].plot(kind='kde', linewidth=2)
        plt.title(f'{column}')
        plt.xlabel('')
    
    plt.suptitle(f'Cluster {cluster_id} (Size: {len(cluster_subset)})', y=1.02)
    plt.tight_layout()
    return plt

# Generate density plots for each cluster
for cluster_num in range(cluster_count):
    plot = plot_cluster_density(clustered_data, cluster_num)
    plot.savefig(f'cluster_density_{cluster_num}.png')
    plot.close()

Machine Learning Workflow

1. Problem Definition
2. Data Understanidng
   • Data collection
   • Data import
   • Exploratory analysis
     • Descriptive statistics with describe()
     • Data structure with info()
3. Data Preparation
   • Data cleaning
     • Missing value imputation with fillna()
     • Outlier removal with dropna()
   • Feature engineering
     • Feature encoding (one-hot encoding with get_dummies(), mapping functions)
     • Feature selection (correlation analysis with corr())
4. Model Development
   • Train-test split
   • Algorithm selection
5. Model Evaluation
   • Performance scoring
6. Implementation
   • Analysis reporting