Sugandh 06701192023
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans
from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder,
StandardScaler,label_binarize
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score, classification_report,
confusion_matrix,roc_auc_score
from sklearn.ensemble import RandomForestClassifier
df=pd.read_csv("train.csv - train.csv.csv")
df.head()
battery_power blue clock_speed dual_sim fc four_g int_memory
m_dep \
0 842 0 2.2 0 1 0 7
0.6
1 1021 1 0.5 1 0 1 53
0.7
2 563 1 0.5 1 2 1 41
0.9
3 615 1 2.5 0 0 0 10
0.8
4 1821 1 1.2 0 13 1 44
0.6
mobile_wt n_cores ... px_height px_width ram sc_h sc_w
talk_time \
0 188 2 ... 20 756 2549 9 7
19
1 136 3 ... 905 1988 2631 17 3
7
2 145 5 ... 1263 1716 2603 11 2
9
3 131 6 ... 1216 1786 2769 16 8
11
4 141 2 ... 1208 1212 1411 8 2
15
three_g touch_screen wifi price_range
0 0 0 1 1
1 1 1 0 2
2 1 1 0 2
3 1 0 0 2
4 1 1 0 1
[5 rows x 21 columns]
df.isnull().sum()
battery_power 0
blue 0
clock_speed 0
dual_sim 0
fc 0
four_g 0
int_memory 0
m_dep 0
mobile_wt 0
n_cores 0
pc 0
px_height 0
px_width 0
ram 0
sc_h 0
sc_w 0
talk_time 0
three_g 0
touch_screen 0
wifi 0
price_range 0
dtype: int64
# Split features and target
X = df.drop("price_range", axis=1) # Independent variables
y = df["price_range"]
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.2, random_state=42, stratify=y)
dt_model = DecisionTreeClassifier(criterion='entropy', max_depth=5,
random_state=42) # You can use 'entropy' instead of 'gini'
dt_model.fit(X_train, y_train)
y_pred = dt_model.predict(X_test)
y_prob_dt = dt_model.predict_proba(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test,
y_pred))
Accuracy: 0.8725
Confusion Matrix:
[[90 10 0 0]
[ 4 89 7 0]
[ 0 11 76 13]
[ 0 0 6 94]]
Classification Report:
precision recall f1-score support
0 0.96 0.90 0.93 100
1 0.81 0.89 0.85 100
2 0.85 0.76 0.80 100
3 0.88 0.94 0.91 100
accuracy 0.87 400
macro avg 0.87 0.87 0.87 400
weighted avg 0.87 0.87 0.87 400
rf_model = RandomForestClassifier(n_estimators=100, random_state=42,
max_depth=10)
rf_model.fit(X_train, y_train)
RandomForestClassifier(max_depth=10, random_state=42)
dt_model = DecisionTreeClassifier(criterion='gini', max_depth=5,
random_state=42) # You can use 'entropy' instead of 'gini'
dt_model.fit(X_train, y_train)
y_pred = dt_model.predict(X_test)
y_prob_dt = dt_model.predict_proba(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test,
y_pred))
Accuracy: 0.83
Confusion Matrix:
[[89 11 0 0]
[ 6 82 12 0]
[ 0 17 75 8]
[ 0 0 14 86]]
Classification Report:
precision recall f1-score support
0 0.94 0.89 0.91 100
1 0.75 0.82 0.78 100
2 0.74 0.75 0.75 100
3 0.91 0.86 0.89 100
accuracy 0.83 400
macro avg 0.83 0.83 0.83 400
weighted avg 0.83 0.83 0.83 400
y_pred_rf = rf_model.predict(X_test)
y_prob_rf = rf_model.predict_proba(X_test)
# Accuracy Score
accuracy = accuracy_score(y_test, y_pred_rf)
print(f"Accuracy: {accuracy:.4f}")
# Classification Report
print("Classification Report:\n", classification_report(y_test,
y_pred_rf))
# Confusion Matrix
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred_rf))
Accuracy: 0.8900
Classification Report:
precision recall f1-score support
0 0.95 0.95 0.95 100
1 0.82 0.84 0.83 100
2 0.84 0.82 0.83 100
3 0.95 0.95 0.95 100
accuracy 0.89 400
macro avg 0.89 0.89 0.89 400
weighted avg 0.89 0.89 0.89 400
Confusion Matrix:
[[95 5 0 0]
[ 5 84 11 0]
[ 0 13 82 5]
[ 0 0 5 95]]
# --- SVM Model with Probability Enabled ---
svm_model = SVC(kernel='rbf', C=1.0, gamma='scale', probability=True)
# Enable predict_proba
svm_model.fit(X_train, y_train)
y_pred_svm = svm_model.predict(X_test)
y_prob_svm = svm_model.predict_proba(X_test) # Now this will work
without error
print("\n--- SVM Results ---")
print("Accuracy:", accuracy_score(y_test, y_pred_svm))
print(confusion_matrix(y_test, y_pred_svm))
print(classification_report(y_test, y_pred_svm))
--- SVM Results ---
Accuracy: 0.9575
[[100 0 0 0]
[ 2 97 1 0]
[ 0 7 89 4]
[ 0 0 3 97]]
precision recall f1-score support
0 0.98 1.00 0.99 100
1 0.93 0.97 0.95 100
2 0.96 0.89 0.92 100
3 0.96 0.97 0.97 100
accuracy 0.96 400
macro avg 0.96 0.96 0.96 400
weighted avg 0.96 0.96 0.96 400
# --- KNN Model ---
knn_model = KNeighborsClassifier(n_neighbors=5)
knn_model.fit(X_train, y_train)
y_pred_knn = knn_model.predict(X_test)
y_prob_knn = knn_model.predict_proba(X_test)
print("\n--- KNN Results ---")
print("Accuracy:", accuracy_score(y_test, y_pred_knn))
print(confusion_matrix(y_test, y_pred_knn))
print(classification_report(y_test, y_pred_knn))
--- KNN Results ---
Accuracy: 0.935
[[99 1 0 0]
[ 2 93 5 0]
[ 0 7 87 6]
[ 0 0 5 95]]
precision recall f1-score support
0 0.98 0.99 0.99 100
1 0.92 0.93 0.93 100
2 0.90 0.87 0.88 100
3 0.94 0.95 0.95 100
accuracy 0.94 400
macro avg 0.93 0.94 0.93 400
weighted avg 0.93 0.94 0.93 400
# Challenges in Traditional Methods:
# Feature Engineering Complexity
# Traditional models like Decision Trees and KNN rely heavily on
manual feature selection.
# Feature importance needs to be analyzed carefully to avoid
irrelevant or redundant features.
# Scalability Issues
# KNN struggles with large datasets due to its computational cost
(O(n^2)) when making predictions.
# Decision Trees may become too deep, leading to overfitting.
# Hyperparameter Sensitivity
# High Computational Cost for Some Models
# SVM and KNN are computationally expensive for large datasets.
# Grid Search for Hyperparameter tuning can be slow without
optimization techniques.
# Model Training and Testing in ML
# Data Preprocessing – Clean and prepare data by handling missing
values, encoding categorical features, and scaling numerical data.
# Train-Test Split – Divide data into training (70-80%) and testing
(20-30%) sets to ensure proper model evaluation.
# Model Training – The model learns patterns from the training data by
adjusting its parameters based on the input features and target
variable.
# Model Testing – The trained model is tested on unseen data (test
set) to evaluate its ability to generalize to new examples.
# Performance Evaluation – The model is assessed using metrics such as
accuracy, precision, recall, F1-score, AUC-ROC, and confusion matrix
to determine its effectiveness.
# Metrics for Evaluating ML Algorithms
# Classification Metrics (for Categorical Targets)
# Accuracy – Measures overall correctness (suitable for balanced
datasets).
# Precision – Measures correctness of positive predictions (useful for
imbalanced datasets).
# Recall (Sensitivity) – Measures how well actual positives are
detected.
# F1-Score – Harmonic mean of precision and recall (best for
imbalanced classes).
# Confusion Matrix – Shows true positives, true negatives, false
positives, and false negatives.
# AUC-ROC (Area Under Curve – Receiver Operating Characteristic) –
Evaluates classification ability across thresholds.
# Binarizing the test set labels only (AFTER splitting)
y_bin_test = label_binarize(y_test, classes=[0, 1, 2, 3])
# --- Accuracy and AUC Calculation ---
models = ['Decision Tree', 'Random Forest', 'SVM', 'KNN']
accuracies = [
accuracy_score(y_test, y_pred),
accuracy_score(y_test, y_pred_rf),
accuracy_score(y_test, y_pred_svm),
accuracy_score(y_test, y_pred_knn)
]
# Multi-class AUC scores using the TEST SET ONLY
auc_scores = [
roc_auc_score(y_bin_test, y_prob_dt, multi_class='ovr'),
roc_auc_score(y_bin_test, y_prob_rf, multi_class='ovr'),
roc_auc_score(y_bin_test, y_prob_svm, multi_class='ovr'),
roc_auc_score(y_bin_test, y_prob_knn, multi_class='ovr')
]
# --- Plotting Accuracy and AUC ---
fig, ax = plt.subplots(1, 2, figsize=(14, 6))
# Accuracy Bar Graph
ax[0].bar(models, accuracies, color='skyblue')
ax[0].set_title('Model Accuracy Comparison')
ax[0].set_ylabel('Accuracy')
ax[0].set_ylim(0, 1)
# AUC Bar Graph
ax[1].bar(models, auc_scores, color='lightgreen')
ax[1].set_title('Model AUC Comparison')
ax[1].set_ylabel('AUC Score')
ax[1].set_ylim(0, 1)
plt.tight_layout()
plt.show()
# --- Print Model Performances ---
print("\n--- Model Performance ---")
for i, model in enumerate(models):
print(f"{model}: Accuracy = {accuracies[i]:.4f}, AUC =
{auc_scores[i]:.4f}")
--- Model Performance ---
Decision Tree: Accuracy = 0.8300, AUC = 0.9459
Random Forest: Accuracy = 0.8900, AUC = 0.9793
SVM: Accuracy = 0.9575, AUC = 0.9988
KNN: Accuracy = 0.9350, AUC = 0.9914
# Recommended Model for Mobile Price Prediction
# Based on your evaluation metrics (accuracy and AUC-ROC), the Support
Vector Machine (SVM) model performs the best with:
# Accuracy: 95.75%
# AUC-ROC: 0.9988
# Best Model: SVM (with RBF Kernel)
# Pros:
# High accuracy and robustness in high-dimensional spaces.
# Works well with non-linear data using the RBF kernel.
# Good generalization with proper hyperparameter tuning.
# Cons:
# Computationally expensive for very large datasets.
