How victorcabrejos/laptop-price-predictor works
Project type and purpose
• This is a full-stack machine-learning web application (Laptop Price Predictor) built in Python with a FastAPI backend and an HTML/CSS/Chart.js frontend.
• It ingests laptop specs, runs them through interchangeable ML models, and renders predictions and charts.
File structure
• Top-level:
• main.py (FastAPI entrypoint)
• config.json (application configuration)
• laptop_price.csv (dataset)
• Directories:
• models/ – ML model interfaces & implementations, Factory, Prototype, Singleton
• visualizations/ – chart abstractions & Factory, chart manager
• preprocessors/ – data cleaning/preprocessing
• templates/ – Jinja2/HTML pages for index, model info, predictions, visualizations
• static/ – CSS, JS, generated chart images
• docs/ – architecture docs and design pattern tutorials
• Key design patterns:
• Factory for model & visualization instantiation
• Prototype for cloning model configurations
• Singleton for config and manager classes
README for additional insights
• Backend: Python 3.11, FastAPI, scikit-learn
• Frontend: HTML, TailwindCSS, Chart.js
• Visualization libs: Matplotlib, Seaborn
• Planned future phases include an API layer, database persistence, user auth
a. Components
• Client browser (HTML + Chart.js)
• FastAPI web server (main.py)
• Request handlers / Controllers (prediction endpoint, model info endpoint, visualization endpoint)
• DataPreprocessor (preprocessors/data_preprocessor.py)
• Model subsystem:
– ModelFactory (models/model_factory.py)
– ModelManager (models/model_manager.py, singleton)
– Concrete models (linear_regression_model, random_forest_model)
– ModelConfig & Prototype registry (models/model_config*.py)
• Visualization subsystem:
– VisualizationFactory (visualizations/visualization_factory.py)
– VisualizationManager (visualizations/visualization_manager.py, singleton)
– Concrete charts (scatter_plot, bar_plot, histogram_plot)
• Configuration manager (models/config_manager.py, singleton)
• Data store (CSV file)
• Template renderer (Jinja2 via FastAPI)
b. Relationships & data flow
1. User submits laptop specs via HTML form → HTTP POST to FastAPI
2. Controller invokes DataPreprocessor → cleaned feature vector
3. Controller asks ModelFactory (via ModelManager singleton) for the selected model
4. Model uses feature vector → returns price prediction and metrics
5. Controller asks VisualizationManager to build charts → Matplotlib/Seaborn outputs
6. FastAPI renders templates with prediction, metrics, and embedded charts (or Chart.js JSON data)
c. Architectural patterns & principles
• Separate concerns: presentation (templates/static), business logic (controllers, managers), ML logic (models), visualization logic
• Dependency injection via factories
• Centralized configuration via singleton ConfigManager
• Extendibility: add new models or charts by registering in factories
d. Key technologies
• FastAPI (web framework & HTTP routing)
• scikit-learn (ML algorithms)
• Matplotlib, Seaborn (chart generation) + Chart.js (client-side interactive charts)
• TailwindCSS (styling)
Essential elements to capture
• All design patterns (Factory, Prototype, Singleton) as separate modules
• The two distinct subsystems (models vs. visualizations)
• Template rendering and static asset serving
• Data flow paths from user input through to prediction output and chart display
• External dependencies (CSV file, third-party libraries)