MODEL. DEPLOY.
DEFEND YOUR AI.
Evaluating participants' AI/ML modeling, dataset handling, and deployment skills through beginner-to-flagship level projects spanning classical ML, deep learning, computer vision, NLP, and edge AI.
What Teams Take Away
Four core skills every team builds while working through an AI modeling project.
ML Fundamentals
Build intuition for classical ML models, regression, and evaluation techniques.
Deep Learning & Neural Nets
Design and train CNNs, LSTMs, and transformer-based architectures.
Real-World Deployment
Ship models as usable apps, APIs, or edge deployments.
Teamwork & Time Management
Foster teamwork, innovation, and time management.
What the AI Modeling Challenge Is Built Around
Six technical tracks a project in this arena can draw on.
Classical ML Modeling
Train and evaluate models like Logistic Regression & Naive Bayes.
Computer Vision Projects
Build CNNs, object detectors, and vision-based tools.
NLP & LLM Applications
Work with transformers, summarization, and RAG chatbots.
Edge AI Deployment
Deploy optimized models to devices like Jetson Nano.
Time-Series & Reinforcement Learning
Forecast trends and train agents via Deep Q-Learning.
Team Collaboration & Mentorship
Guided sessions with mentors and technical judges.
Prize Tiers
Great for first-time teams — focus on core modeling and data-handling skills.
Who Can Participate
Standard eligibility rules for the AI Modeling Challenge.
Academic Level
Open to all students, any branch, any year of study.
Team Size
Maximum 5 members per team; solo entries are also welcome.
Project Choice
Pick one of our 5 project ideas, or propose your own project.
Build Deadline
Fully working project must be ready before 30th August.
Registration
One-time team registration through our official website.
Institution
Pan India eligible.
From Sign-Up to the Final Showdown
How every team moves through Techfest.
Team Registration
Register your team of up to 5 on our website.
Choose Your Project
Pick one of our 5 AI modeling ideas, or propose your own.
Submit Elimination PPT
Upload a 10-slide PPT at the time of registration.
PPT Evaluation
Judges review every submitted presentation.
Qualify / Disqualify
Results announced on our website before 30th Aug.
Final Round · 30th Aug
Present full project + PPT live; winners chosen.
Presentation-Only Evaluation
Judged purely on your submitted presentation, no prototype required at this stage.
10-Slide PPT Only
Submitted at the time of registration, no hardware needed yet — format of PPT will be shared.
Problem & Idea
Clearly explain the problem statement and your proposed solution.
Feasibility
Can this realistically be built and completed by 30th August.
Team Plan
Clear role division across your team of up to 5 members.
Originality
Extra weight for teams proposing their own original project idea.
Result
Qualify or disqualify announced on our website before 30th Aug.
Evaluation Criteria
How your live project is scored on final day — listed highest weight first.
Novelty
Uniqueness of the problem framing and solution versus existing tools.
Performance
Accuracy, robustness, and strength of your model's evaluation metrics.
Technical Depth
Soundness of the ML pipeline, architecture choices, and engineering rigor.
UI/UX & Demo
Usability, polish, and clarity of your live demo or deployed app.
Real-World Impact
Practicality, scalability, and readiness for real-world deployment.
Presentation & Q&A
Clarity of explanation and how well the team defends its work.
Choose Your Challenge
Two ways to lock in your project for the AI Modeling Challenge.
Bring Your Own Idea
Have a project in mind? Propose your own original idea during team registration. Briefly describe the problem, your approach, and why it fits an AI modeling challenge. Our faculty coordinators review and confirm it before you start building.
Choose From Our Ideas
Prefer a ready-made option? Pick any one of our 5 official project ideas shared in this deck, each designed to be original yet achievable within 20 days. Simply mention your chosen idea while registering your team — no extra approval needed, so you can start building right away.
The Local Privacy Filter (PII Redactor)
A model trained to instantly identify and mask Personally Identifiable Information from text to sanitize data locally.
Description
- Generate synthetic PII data using a larger teacher model (e.g., Llama 3.3 70B) to act as ground truth.
- Fine-tune a 1B-3B parameter student model (like Llama 3.2 1B) on the synthetic dataset using Unsloth.
- Implement a robust parsing layer to accurately replace detected names, emails, and phone numbers with generic tags.
- Optimize the fine-tuned model via LoRA and export it to a quantized GGUF format for CPU-friendly inference.
- Test the pipeline against messy, real-world data inputs to ensure zero leakage of sensitive information.
- Keep the pipeline lightweight to ensure instantaneous processing before data hits external cloud APIs.
Deliverables
- Trained SLM capable of redacting PII accurately from unstructured text.
- Synthetic dataset used for training, complete with generation prompt scripts.
- Simple Python CLI or local web app that sanitizes user-pasted text.
- Exported GGUF model file and a ready-to-run Ollama Modelfile.
- Documented code detailing the fine-tuning and quantization pipeline.
- Live demo showing real-time text redaction running completely offline.
The Offline Markdown Summarizer
A specialized SLM that reads your personal Obsidian or Notion notes and generates concise bullet points completely offline.
Description
- Extract and parse messy Markdown files, handling edge cases like internal links and custom formatting.
- Create a diverse training dataset of raw notes paired with high-quality, concise summaries generated by a larger model.
- Fine-tune a lightweight model with a focus on retaining key facts while ignoring standard conversational outputs.
- Build a chunking mechanism to allow the SLM to process notes that exceed its native context window.
- Quantize the model using Unsloth to ensure it runs efficiently on a standard laptop without dedicated GPU hardware.
- Package the solution to run locally so private journals and sensitive notes never touch an external server.
Deliverables
- Fine-tuned local model specialized in summarizing unstructured Markdown notes.
- Python script or local app that points to a folder and automatically summarizes the files inside.
- Evaluation report comparing the SLM's summaries to the Teacher model's summaries.
- Quantized GGUF model optimized for fast local execution.
- Documented data-preparation and fine-tuning pipeline.
- Live demo summarizing a long, complex personal note offline.
The Intent Router
A lightweight classifier trained to read incoming customer support emails and accurately bucket them into specific categories.
Description
- Generate a dataset of synthetic customer support emails categorized into buckets like Billing, Tech Support, and Spam.
- Fine-tune a small language model to act purely as a classification engine, stripping out conversational chatter.
- Implement a structured output enforcement step so the model only returns exact category names (e.g., JSON format).
- Integrate a confidence scoring system to flag ambiguous emails for human review.
- Compress the trained model into a GGUF file for fast, continuous batch processing on local hardware.
- Build a mock email pipeline that automatically sorts incoming text into corresponding local folders.
Deliverables
- Specialized SLM that accurately categorizes support tickets or emails.
- Curated synthetic dataset of categorized support emails.
- A test script that feeds a batch of unread emails to the model and sorts them.
- Quantized local model running via Ollama.
- Documentation of the structured-output prompting and training setup.
- Live demo sorting a batch of mock emails in real time.
The Niche Code Translator
A model distilled specifically to translate Python scripts into Rust, running as a hyper-accurate, single-task coding assistant.
Description
- Build a parallel dataset of Python scripts and their highly optimized, idiomatic Rust equivalents using a Teacher model.
- Fine-tune a base coding SLM (like Qwen 1.5B Coder) strictly on this translation task to narrow its focus.
- Aggressively train the model to output raw, valid code without conversational filler or Markdown explanations.
- Implement a local validation loop that checks if the generated Rust code successfully compiles.
- Quantize the model to run fast enough to act as a real-time copilot or CLI tool.
- Test the model on complex logic transitions, ensuring it understands the difference between Python's memory management and Rust's borrow checker.
Deliverables
- Fine-tuned coding SLM specialized entirely in Python-to-Rust translation.
- The synthetic parallel code dataset used for distillation.
- A CLI tool where a user inputs a .py file and receives a .rs file locally.
- Compilation success rate benchmark on a holdout test set.
- Documented training script, specifically showing how conversational filler was penalized.
- Live demo successfully translating a multi-function Python script offline.
The Specialized Game NPC
A tiny model fine-tuned entirely on the lore and speech patterns of a specific fictional universe to act as an interactive character engine.
Description
- Curate a dataset of lore, world-building facts, and specific character dialogue styles using synthetic generation.
- Fine-tune a small model to aggressively adopt the persona, preventing it from breaking character or acting like a helpful AI.
- Inject an explicit system prompt into the training data to enforce constraints on knowledge (e.g., the NPC doesn't know about the real world).
- Quantize the model to 4-bit GGUF so it can run smoothly in the background while a game is actively utilizing the system's GPU.
- Wrap the local model in a simple REST API so a game engine (like Unity or Godot) can send prompts and receive dialogue.
- Test the character against adversarial prompts trying to break its persona.
Deliverables
- Fine-tuned NPC model that adheres strictly to a predefined character and lore.
- Character dialogue dataset covering various conversational scenarios.
- A lightweight local Python API server (e.g., FastAPI) hosting the model.
- Quantized GGUF model file designed for minimal VRAM footprint.
- Documentation of the prompt formatting and persona-locking techniques used during training.
- Live demo having a real-time conversation with the character via the local API.
Ready for Takeoff
Guide your students to choose, build and fly with confidence.
Questions • Discussion • Team Formation