Laptop Fair-Price Analyzer → Laptop Advisor

1. Project objective and motivation

The project started (V1) as a supervised regression problem: given a laptop's hardware specification, what reference price would a model expect, based on historical listings? It estimates a price from specifications, so the exact listing need not exist anywhere, and it can compare a seller's listed price with the model's estimate as a neutral reference point.

While building it, a clear limitation emerged: the training data describes laptops of roughly 2016–2018, so it cannot tell a buyer what to buy today. V2 therefore added Laptop Advisor ("Find My Laptop"): the user describes their course, job, software, games, budget and preferences; the app derives the hardware they need and ranks real, currently listed configurations whose prices and sources were verified. The original model is kept, clearly labelled, as the Price Lab.

2. Two systems, not one

3. The historical dataset and preprocessing ML

Source. The Kaggle dataset Laptop Price by Muhammet Varlı (1,303 laptops, prices in euros). The repository's laptop_data.csv is a widely circulated derivative: all 1,303 rows match across the 10 specification columns, and every price equals Price_euros × 53.28. Columns: Company, TypeName, Inches, ScreenResolution, Cpu, Ram, Memory, Gpu, OpSys, Weight, Price.

Parsing. "8GB" → 8; "2.2kg" → 2.2; the resolution string yields touchscreen and IPS flags plus X_res and Y_res; "Memory" ("256GB SSD + 1TB HDD") is split into SSD and HDD capacities (Flash and Hybrid were dropped after checking correlation); OpSys is grouped into Windows / Mac / Others-No OS-Linux.

4. Exploratory analysis and feature engineering ML

EDA plotted price against every feature (company, type, screen size, touchscreen, IPS, RAM, CPU and GPU brand, OS, weight) and checked correlations. The engineered features:

Final 18 features. Categorical: TypeName, Cpu brand, os, cpu_type, cpu_gen, gpu_tier, Company_grouped. Numerical: Ram, Weight, Touchscreen, Ips, ppi, SSD, HDD, cpu_ghz, Inches, X_res, Y_res. Notebook 04 tested clock speed, CPU power class, CPU generation, GPU tier and rare-company grouping with repeated cross-validation; together they added about +0.02 CV R².

5. Why the model predicts log(Price) ML

Prices are strongly right-skewed (skewness 1.52); on the log scale the skewness is −0.18. Training on raw prices would let a few expensive laptops dominate a squared-error loss. On the log scale, errors become relative: a ₹5,000 error on a ₹30,000 laptop matters more than on a ₹2,00,000 one, which matches how buyers think about price.

Because exp is applied to the predicted mean log price, the back-transformed estimate is closer to a median price than a mean price (no smearing correction was applied). R² is therefore reported on both scales.

6. Model selection and the XGBoost pipeline ML

Notebook 03 compared 13 tuned models plus voting and stacking ensembles (cross-validated grid or random search). These scores are from that earlier random split, before the integrity audit, so they are slightly optimistic:

Notebook 05 re-tuned the three serious candidates (XGBoost, Gradient Boosting, a 4-model voting ensemble) under the clean protocol. Their accuracy was statistically tied, so practicality decided:

Voting − XGBoost on the holdout: R² −0.0010 (95% CI −0.0073 to +0.0051), MAE −₹57 (95% CI −375 to +250). Both intervals include zero, so XGBoost was chosen: same accuracy, about 20× smaller and 30× faster, and the best repeated-CV mean.

Pipeline:  CompanyGrouper(min_count=10)
        →  ColumnTransformer( OneHotEncoder(drop='first', handle_unknown) on 7 categoricals,
                              passthrough on 11 numericals )
        →  XGBRegressor(n_estimators=300, learning_rate=0.02, max_depth=8, subsample=0.8,
                        colsample_bytree=0.4, min_child_weight=1, reg_lambda=0.5,
                        tree_method='hist', random_state=2)

7. Training/testing methodology and leakage prevention ML

Notebook 05 was an integrity audit of the earlier results. The risks found and the fixes:

• Exact duplicates could sit on both sides of a split, so the model would be tested on rows it had memorised. They were removed before splitting.
• Identical configurations at different prices (45 groups) are genuine listings and were kept, but grouped: a configuration is always entirely in train or entirely in test (GroupShuffleSplit by full raw specification, test size 0.20, seed 42 → 1,015 train / 258 holdout rows; 982 / 246 configurations).
• Tuning used group-aware 5-fold CV on the training rows only; the holdout was scored exactly once, after model selection.
• Target leakage made structurally impossible: features are built from a copy of the data with Price removed.
• Fitted transforms (company grouping, one-hot categories) are learned inside the pipeline from training folds only.
• 14 automated integrity checks passed (disjoint indices, no shared configurations, Price not among inputs, folds index only training rows, and so on).

Honest caveat recorded in the notebook: the feature set and search spaces were chosen in notebook 04 using CV on the old training rows, so the new holdout is fresh for fitting and tuning but not 100% independent of earlier feature decisions.

Final model. After evaluation, the chosen pipeline was refit on all 1,273 rows. That refit has no independent test score of its own; the holdout metrics are the best estimate of its performance. The production code reproduced the notebook 05 holdout result exactly (R² 0.915952, MAE ₹8,700.48) before refitting.

8. Evaluation metrics and their interpretation ML

Error analysis. Ordinary notebooks are predicted best (MAE ≈ ₹5,988); workstations worst (≈ ₹19,276). Predictions shrink towards the middle: budget laptops are over-predicted (≈ −11% mean signed error) and laptops above ₹1 lakh under-predicted (≈ +12%); the signed error correlates with actual price (r = 0.41). A noise floor exists: identical configurations already differ from their group mean by about 4.1% (median), so no model can be exact.

9. The production pipeline ML

• One source of truth: training, prediction and tests all use src/features.py; the app contains no feature logic.
• Validated interface: invalid input raises InvalidSpecError; unseen categories and out-of-range values produce warnings.
• Dropdowns are limited to values seen in training (117 CPUs, 105 GPUs, 15 resolutions).
• Listed-price comparison is worded neutrally ("x% above this model's estimate"), with no buy/sell advice.
• Environment: saved with XGBoost 3.4.2 (conda, Python 3.11); deployed with Python 3.12 + xgboost-cpu 3.4.1; predictions verified bit-identical on all 1,273 laptops.

10. EUR→INR conversion, and why the model cannot price today's market ML

The rupee prices are not Indian prices: every value is the original euro price × 53.28, a single fixed rate. So the model's "₹" is a rescaled 2016–18 European price. This ignores Indian taxes, import duties, regional pricing and exchange-rate changes since then.

11. Modern laptop recommendation architecture Rules

free text ──► extract_requirements()   regex rules → editable Requirements (workloads, budget, OS, priorities)
          ──► spec_profile()           most demanding min/recommended spec across the selected workloads
          ──► recommend()              hard filters (OS → budget → minimum specs)
                                       → weighted score → diverse top 3 → pros, cons, trade-offs
catalogue/laptops.json ──► load_catalogue()   rejects entries without an allowed source URL or verification date

Everything is deterministic: the same input always gives the same output, every number in a score can be traced to a rule, and no paid AI API or trained model is involved. The user can edit every extracted requirement and the shortlist updates instantly.

12. Natural-language requirement extraction Rules

• Workloads from keyword regexes: courses and professions (CS, mechanical, MBA…), software (SolidWorks, MATLAB, Premiere Pro, PyTorch, Blender…), and games (Valorant → esports; Cyberpunk, GTA V → AAA). Each match is shown as evidence ("valorant" → Esports & casual gaming).
• Budget parsing handles Indian formats: "₹80,000", "80k", "1.2 lakh", "Rs. 80,000/-", "0.8 lakh", ranges ("between 70k and 90k" → upper bound 90,000), and "around 80k" → 88,000 (+10% tolerance). A guard ignores numbers followed by words such as "Hz", "GB" or "display".
• OS rules: software that requires an OS sets a hard requirement (SolidWorks / CATIA / ANSYS → Windows; Final Cut Pro / Logic Pro / Xcode → macOS). "I prefer a Mac" is only a preference.
• Priorities: portability and battery (Low/Medium/High) and screen size from phrases such as "travel a lot" or "light".
• Conflicts are surfaced: e.g. "MacBook" + SolidWorks produces a note explaining why only Windows laptops are considered.

13. Workload-specific minimum and recommended specifications Rules

Each workload has a minimum (hard filter) and a recommended level (scored). CPU and GPU levels are 1–5 class tiers from a documented chip-family rule, not benchmarks. With several workloads, the most demanding value of each spec is used.

GPU tiers: 1 basic integrated; 2 strong integrated (Intel Arc, Radeon 760M–890M, Apple base M-series) or RTX 2050; 3 entry dedicated (RTX 3050/4050/5050) or Apple Pro integrated GPU; 4 mid-range dedicated (RTX 4060/5060); 5 upper-mid (RTX 4070/5070+). The tier is a performance class only. The display label follows the architecture flag, so Apple silicon is never called a dedicated GPU, and only NVIDIA laptops are marked CUDA-capable.

14. Hard budget and operating-system filters Rules

1. OS: the required OS (from software), or the preferred OS if one was chosen. A laptop on the wrong OS is never returned.
2. Budget: price must be ≤ the budget; a laptop whose price is not verified never "fits" a budget.
3. Minimum specs: RAM, CPU tier, GPU tier and storage must meet the workload minimums.

Honest fallbacks. If nothing passes all three, the app says so: "below minimum" shows the closest in-budget options with their shortfalls listed; "over budget" shows no cards, names the cheapest verified option and keeps the spec recommendations visible.

15. Weighted scoring and ranking Rules

Weights are set from the user's Low/Medium/High priorities and renormalised to sum to 1. Ties are broken by lower price. A diversity step skips near-identical variants (same brand and series) while other good options exist, so the top three are genuinely different.

def workload_fit(lap, p):
    parts = [clamp(lap.ram_gb / p.rec_ram), clamp(lap.cpu_tier / p.rec_cpu),
             clamp(lap.gpu_tier / p.rec_gpu), clamp(lap.storage_gb / p.rec_storage)]
    if p.prefer_cuda:
        parts.append(1.0 if lap.cuda else 0.0)
    if p.prefer_refresh:
        parts.append(clamp((lap.refresh_hz or 60) / p.prefer_refresh))
    return sum(parts) / len(parts)

16. Explanation generation and trade-offs Rules

• "Why it fits" lists only facts that pass a rule: RAM meets the recommendation, GPU meets the level, CPU in the recommended class, high refresh rate, required OS.
• "What you give up" lists shortfalls: RAM only at the minimum, GPU below the recommendation, no CUDA for ML, weight over 2 kg, small SSD, high-power hardware that hurts battery, weight or battery "not stated".
• Trade-off line for options 2 and 3 compares them with the top pick (for example "₹80,000 cheaper, 0.14 kg lighter, weaker graphics").
• Score breakdown ("How this score was built") shows each component and its weight; Compare can show "Meets your recommended specs" when a brief is active.

17. The 67-laptop verified catalogue Rules

Collected honestly: only from structured data published on official product pages (JSON-LD price, availability and specification lists), respecting robots.txt and without bypassing anti-bot measures. Colour variants and duplicate part numbers were removed. load_catalogue() rejects any record that lacks an allowed URL prefix, an ISO verification date (not in the future), valid 1–5 tiers or positive numbers, or that claims CUDA without a dedicated GPU. It also rejects duplicate IDs, part numbers and URLs.

18. Handling missing or uncertain product information Rules

• Never guessed: weight, battery capacity and price may be null; the UI says "not stated".
• Neutral scoring: unknown weight and battery score 0.5, neither rewarded nor penalised, and the cons list flags them.
• Unknown price: excluded whenever a budget is set and given zero value for money.
• Exact CPU not stated by the retailer: recorded as "(exact model not stated)", and the lower, low-power tier is assumed.
• Dated prices: every price shows its source and verification date, with a reminder to confirm on the seller page.

19. The 91 automated tests

The first 37 (pipeline + app) date from V1 and were kept unchanged; V2 added 54. All 91 pass, run with python -m unittest discover -s tests.

20. Streamlit application and Railway deployment

• App (V2): one Streamlit file with five sections: Find, Explore (a filterable board of all 67 laptops), Compare (2–4 side by side), Price Lab, and How it works. Original SVG laptop illustrations are generated from each laptop's real screen size, aspect ratio, category and brand (no product photos, for rights reasons). All catalogue and user text is HTML-escaped.
• Deployment: Railway service built by Railpack from the GitHub branch laptop-advisor-v2 (auto-deploy on push); Python 3.12 pinned by .python-version; start command streamlit run app.py --server.port $PORT --server.address 0.0.0.0 --server.headless true; health check /_stcore/health; 1 vCPU / 1 GB.
• Final production deploy: commit 8c97b42 → deployment SUCCESS; checked live in a real headless browser at 1440, 768, 390 and 360 px.
• V1 remains on Streamlit Community Cloud from main, unchanged.

21. Strengths, limitations and future improvements

Future improvements: quantile models for calibrated price ranges; retraining on recent Indian listings; benchmark-based CPU/GPU scores; scheduled re-verification of catalogue prices and availability; more retailers and brands; an optional, constrained language model only for parsing, with the rule engine still deciding.

22. Viva questions with answers

Part A · The ML price estimator

Part B · The rule-based recommender

Engineering, testing and deployment

23. Quick-revision cheat sheet