Mobile Price Range Classification using Random Forest

Phone buyers and sellers constantly ask the same question: given a spec sheet, which price bracket does this phone belong to? It is a clean tabular-classification problem — 20 numeric specifications, 4 ordered price classes, no missing values, balanced classes — and exactly the kind of problem Random Forests solve well. Many students, however, train a single model with default settings and report an accuracy number they cannot defend. This project takes the opposite approach: full exploratory analysis of the Kaggle Mobile Price Classification dataset, documented feature engineering, stratified train/validation/test discipline, grid-searched hyperparameters, a forest-vs-baselines comparison, and honest evaluation with a confusion matrix and per-class metrics. A working web demo makes the trained model tangible: enter RAM, battery, cameras, resolution and connectivity, and the app returns the predicted price range with its full class-probability distribution. Everything uses standard tools (Python, scikit-learn, plain HTML/JS), so the student can genuinely explain every part of the pipeline.

1. The 2,000-row Kaggle dataset is loaded (20 numeric features plus the price_range target with 4 classes) and sanity-checked: no missing values, balanced classes.
2. Exploratory analysis (correlation heatmap, distribution plots) confirms RAM and battery power as the strongest price predictors; engineered features such as screen area and pixel density are added.
3. The data is split 80/20 stratified (1,600 train / 400 test) with a validation slice for tuning; numeric features are used as-is since trees need no scaling.
4. The Random Forest trains with bootstrap sampling; grid search selects tree count, maximum depth and minimum split samples via cross-validation.
5. The held-out test set is evaluated once: accuracy, per-class precision/recall/F1 and the 4x4 confusion matrix are generated for the report.
6. In the web demo, entered specs pass through the same preprocessing and the trained forest; per-tree votes become the predicted price range with class probabilities.

Tech stack:

• Python 3, scikit-learn (Random Forest)
• pandas, NumPy (data handling)
• Matplotlib, Seaborn (EDA & plots)
• Jupyter Notebook (training & evaluation)
• HTML/CSS/JavaScript (single-file web demo)

Dataset & model details

• Dataset: Kaggle "Mobile Price Classification" (iabhishekofficial) — 2,000 phone records; 20 numeric features (battery_power, blue, clock_speed, dual_sim, fc, four_g, int_memory, m_dep, mobile_wt, n_cores, pc, px_height, px_width, ram, sc_h, sc_w, talk_time, three_g, touch_screen, wifi); target price_range with 4 classes (0 = low cost, 1 = medium, 2 = high, 3 = very high). No missing values; classes are balanced.
• Task: 4-class tabular classification; input = 20 numeric specification values, output = probability distribution over the 4 price ranges.
• Model: Random Forest classifier (scikit-learn), design 200 trees with grid-tuned max_depth and min_samples_split; bootstrap aggregation with majority voting; feature importances from mean decrease in impurity.
• Metrics: Test accuracy approximately 88% (development target based on published results on this dataset — not a measured claim), per-class precision/recall/F1, 4x4 confusion matrix. Final performance depends on the train/test split and hyperparameters.

• [Random Forest classifier] A scikit-learn RandomForestClassifier (design 200 trees, grid-tuned depth and split settings) trained on all 20 numeric features with stratified train/validation/test discipline.
• [Live spec-to-price web demo] A single-file web app: enter RAM, battery, cameras, screen resolution and connectivity specs, and the embedded classifier returns the predicted price range with per-class probabilities instantly.
• [Full training notebook] Data loading, exploratory analysis, feature engineering, training, hyperparameter search and evaluation in one reproducible Jupyter notebook.
• [Feature-importance analysis] Tree-based importances showing which specs actually drive price — RAM and battery power dominate — visualized as a bar chart for the report and viva.
• [Confusion matrix & per-class metrics] Accuracy, precision, recall and F1 for each of the 4 price ranges, so the viva can address exactly which adjacent ranges the model confuses.
• [Hyperparameter tuning] Grid search over tree count, maximum depth and minimum split samples with cross-validation, so every setting is justified rather than guessed.
• [Baseline comparison] Logistic regression and a single decision tree trained on the same split, proving in numbers why the forest is the final model.
• [Exported trained model] Saved .pkl model plus the exact preprocessing pipeline, so the demo and the notebook classify new phones without retraining.

• Complete training & evaluation Jupyter notebook
• Trained Random Forest model (.pkl) with preprocessing pipeline
• Live spec-to-price web demo with embedded classifier
• EDA plots, feature-importance chart, confusion matrix and metric tables
• Project report PDF (background, dataset, methodology, results)
• PPT presentation for final review
• Viva Q&A preparation document (ensembles, bagging, impurity, evaluation metrics)