AutoGML

Note: This platform was originally conceived and developed as my college final year capstone project. Born out of a vision to simplify machine learning workflows, this ambitious project is now actively maintained as a portfolio showcase and an educational resource demonstrating end-to-end Automated Machine Learning (AutoML) pipelines.

Overview

AutoGML is an Automated Machine Learning (AutoML) web application built using Python and Django. It provides a visual, user-friendly interface to build, train, evaluate, and test machine learning models for multiple domains without writing code.

Purpose

The project simplifies the machine learning lifecycle by automating data preprocessing, feature selection, model training, hyperparameter tuning, and model export for developers, data scientists, and non-technical users.

Features

• Tabular ML (tables): Auto-cleans CSV data (imputes missing values, encodes categories) and trains regression/classification models (Random Forest, LightGBM, XGBoost, etc.).
• Image Classification (imgclf): Fine-tunes pre-trained models (e.g. ResNet50) on custom image folders.
• Object Detection (obj_Detection): Integrates custom object detection training and inference using YOLOv5.
• Face Recognition (face_Recognition): Trains and runs custom facial recognition models on captured/uploaded image datasets.

Motivation

Providing an accessible, gui-driven alternative to complex scripting pipelines, allowing rapid prototyping of machine learning workloads.

---

Architecture

AutoGML is structured as a modular Django application. Each machine learning domain is decoupled into its own independent Django app.

Major Modules

• AutoGMLTest - Core project configuration (settings, main routing, middleware).
• main - User authentication, login/signup, and project management landing dashboard.
• tables - Tabular ML training, CSV parsing, data visualization, and ML model inference.
• imgclf - Image uploading, dataset organization, CNN model training, and predictions.
• obj_Detection - YOLOv5-based custom object training, testing, and real-time inference.
• face_Recognition - Webcam feeding, face encoding matching, and database-driven face training.
• docs - Built-in help guides and instructions for each of the AutoML modes.

Execution Flow

graph TD
    A[User Sign Up & Login] --> B[Dashboard / Select Domain]
    B --> C1[Tabular ML]
    B --> C2[Image Classification]
    B --> C3[Object Detection]
    B --> C4[Face Recognition]

    C1 --> D1[Upload CSV] --> E1[Data Preprocessing & Schema Mapping] --> F1[AutoML Model Training]
    C2 --> D2[Upload Class folders ZIP] --> E2[Image Resizing & Dataset Split] --> F2[Fine-tune CNN Model]
    C3 --> D3[Upload YOLO Annotated ZIP] --> E3[Start YOLOv5 Training Pipeline] --> F3[Save PyTorch weights]
    C4 --> D4[Capture/Upload Face Images] --> E4[Extract Encodings] --> F4[Save Encodings Model]

    F1 --> G1[Download .sav Model / Batch Inference]
    F2 --> G2[Download .h5 Model / Interactive Predict]
    F3 --> G3[Download .pt Model / Bounding Box Check]
    F4 --> G4[Live Webcam Streaming Recognition]

Loading

1. User Sign Up & Login: Authenticate to initialize project workspaces.
2. Select Domain & Create Project: Create a workspace for Tabular, Image Classifier, Object Detection, or Face Recognition.
3. Data Import: Upload a CSV file or a ZIP file containing structured folders of images.
4. Data Prep / Schema Selection: (For Tabular) Map targets and select clean-up strategies.
5. Model Training: Starts asynchronous background training using custom training functions, displaying live progress.
6. Model Evaluation & Testing: Download the trained weights (.sav, .h5, or .pt) or perform interactive inference (single prediction, batch uploading, or camera streaming).

---

Technologies

• Backend: Python 3.10+ / Django 3.x
• Frontend: HTML5, Vanilla CSS, JS (jQuery, Bootstrap, Owl Carousel, select2)
• Tabular ML: pandas, numpy, scikit-learn, XGBoost, LightGBM, matplotlib, seaborn
• Deep Learning: TensorFlow, PyTorch
• Computer Vision: OpenCV, face-recognition (dlib-based)

---

Installation

Local Setup

1. Clone the repository:

   git clone <repository-url>
   cd autogml

2. Create and activate a virtual environment:

   python -m venv venv
   # On Windows:
   venv\Scripts\activate
   # On macOS/Linux:
   source venv/bin/activate

3. Install Dependencies:

   pip install -r requirements.txt

   Note: For the Face Recognition module, you must install CMake and Visual Studio C++ Build Tools (Windows) before installing the optional face-recognition package.

4. Run Migrations:

   python manage.py migrate

5. Start the server:

   python manage.py runserver

Docker Setup

Docker is highly recommended because it encapsulates all C++ extensions (like dlib) and system dependencies for computer vision (OpenCV) automatically.

1. Build and start container:

   docker-compose up --build

2. Open http://localhost:8000 in your browser.

Configuration

Copy .env.example to .env and configure:

• SECRET_KEY: Private Django cryptographic key.
• DEBUG: Set to True for development, False for production.
• ALLOWED_HOSTS: Space-separated list of allowed domains.

---

Usage

1. Tabular Machine Learning

• Upload a CSV dataset (e.g. containing house prices).
• Select target column to predict (e.g. price).
• Click Train to automatically search for the best regressor (e.g. Random Forest, ElasticNet, Gradient Boosting).
• Export/Download the .sav model.

2. Object Detection (YOLOv5)

• Upload a ZIP file containing image annotations in YOLO format.
• Train a custom model for your objects.
• Upload test images to visually verify the bounding boxes.

---

Folder Structure

e:/autogml/
├── AutoGMLTest/        # Core Django settings, wsgi, and urls
├── docs/               # In-app user guides and documentation templates
├── face_Recognition/   # Camera interfaces and face encoding pipelines
├── imgclf/             # CNN training and prediction routines
├── main/               # Auth, landing page, and project management
├── obj_Detection/      # YOLOv5 object detection pipeline
├── project/            # Data storage directory for running AutoML runs (gitignored)
├── tables/             # Tabular ML parsing, data prep, and model selection
├── manage.py           # Django administrative script
├── db.sqlite3          # Pre-configured SQLite Database
├── Dockerfile          # Container specification
├── docker-compose.yml  # Local multi-service orchestration
└── requirements.txt    # Python package manifest

---

Development Guide

Install

Set up environment variables and run pip install -r requirements.txt.

Run

To test and execute locally, run python manage.py runserver.

Debug

Use Django logging or run python manage.py check to scan for configuration anomalies.

Database

AutoGML comes preloaded with db migrations. To reset the database, delete db.sqlite3 and run:

python manage.py makemigrations
python manage.py migrate

---

Troubleshooting

1. CMake / dlib installation error during local setup on Windows

• Issue: Installing face-recognition fails due to C++ compilation requirements for dlib.
• Fix: Install the CMake package and C++ Build Tools from Visual Studio installer, or use the Docker setup which comes preloaded with all compilation dependencies.

2. Missing 'project' directory errors

• Issue: The application cannot find paths to store model data.
• Fix: Ensure the project/ directory is present in the workspace root. (The repository includes a project/.gitkeep file to ensure this directory is created on checkout).