Problem Statements for Intel® Unnati Industrial Training 2025
Problem Statement 1
Bug Detection and Fixing
Build a machine learning model that can automatically identify bugs (or potential errors) in a given piece
of code and suggest fixes. This project requires designing, training, and evaluating an ML model that can
parse source code, classify bug types, and generate fix recommendations.
Key Objectives
1. Data Extraction & Preparation:
o Collect code snippets from various programming languages (at least one or two
languages to start with).
o Label them as “buggy” or “bug-free” and, if buggy, include the correct “fixed” version of
the code.
2. Model Architecture:
o Build or fine-tune an existing model (e.g., Transformer-based, BERT-like, or an LLM-based
model) to detect code smells or errors.
o Incorporate a suggestion system that either completes or rectifies the code.
3. Evaluation & Testing:
o Use standard metrics such as precision, recall, F1-score for bug detection.
o Measure the accuracy and relevance of the fixes suggested.
Prerequisites
• Proficiency in Python.
• Understanding of Machine Learning (particularly natural language processing and code analysis
models).
• Basic knowledge of software debugging and version control (to handle various versions of code).
Challenges
• Data Requirements:
o The main challenge is assembling a sufficiently large and diverse dataset of buggy and
fixed code.
o Quality of labeled data is crucial: incorrect labels or partial fixes will degrade model
performance.
• Model Complexity:
o Code is more structured than natural language. Parsing abstract syntax trees (ASTs) or
using token-based approaches needs careful design.
• Overfitting & Generalization:
o Ensuring the model generalizes to unseen code from different domains or libraries.
Expected Outcome
• Bug Detection: A model or pipeline that, given a code snippet, highlights potential bugs.
• Fix Recommendation: The system proposes a fix or correction for the detected bug.
• Metrics & Reporting: A dashboard or report showcasing how the model performs on various
types of bugs.
• Suggested Tools/Technologies:
o Python for main development.
o ML Frameworks such as TensorFlow, PyTorch, or Scikit-learn.
o Data Storage can be done using SQL or NoSQL databases.
o Version Control with Git/GitHub for collaboration.
o Deployment & Testing: Containerization (Docker) or cloud platforms (AWS, Azure, GCP)
for hosting the final model.
• Collaboration & Project Management:
o Use Agile methodology or a similar iterative approach.
o Regular checkpoints/sprints to track progress and adjust scope.
• Evaluation Criteria:
o Technical Accuracy: Correctness and quality of the ML models.
o Innovativeness: Novel approaches to data handling, model architecture, or user
experience.
o Scalability & Robustness: How well the solution can handle diverse or increasing data
loads.
o User Experience: The intuitiveness and utility of the final system from a learner’s or
developer’s perspective.
Problem Statement 2
GenAI Interactive Learning Games
Develop an educational game platform that uses Generative AI to create dynamic content, challenges,
and scenarios. The goal is to make learning more engaging by providing game elements (e.g., puzzles,
quizzes) that adapt in real-time based on players’ performance and interests.
Key Objectives
1. Content Generation:
o Use a GenAI model (e.g., GPT-based, BERT-based) to generate questions, mini-stories, or
puzzles dynamically.
o Adjust difficulty and topics based on learner progress.
2. Game Mechanics:
o Design interactive elements (e.g., leveling up, badges, leaderboards) that reward
mastery of concepts.
o Integrate real-time feedback loops for player performance.
3. Adaptive Learning Paths:
o Implement a recommendation system that chooses subsequent game levels or
educational content based on user inputs and performance.
Prerequisites
• Knowledge of Python and ML libraries (PyTorch, TensorFlow, etc.).
• Experience with data processing and analytics for user interaction tracking.
• Familiarity with basic game design principles or frameworks (e.g., Pygame, Unity, or web-based
frameworks).
Challenges
• Data Requirements:
o A dataset of educational materials, questions, and possible solutions.
o Continuous data collection from user interactions to further refine the model.
• Model Integration:
o Ensuring seamless integration of generative models within a game environment.
• Real-time Adaptation:
o The system must efficiently update the difficulty or type of content without causing
performance lags or user dissatisfaction.
Expected Outcome
• Dynamic Educational Content: The game provides fresh, relevant questions or scenarios each
time a user interacts.
• Personalized Gameplay: The difficulty and content adapt to each user’s performance and
learning pace.
• Metrics & Insights: Track user engagement, learning outcomes, and feedback to refine the
model’s content generation capabilities.
Suggested Tools/Technologies:
o Python for main development.
o ML Frameworks such as TensorFlow, PyTorch, or Scikit-learn.
o Data Storage can be done using SQL or NoSQL databases.
o Version Control with Git/GitHub for collaboration.
o Deployment & Testing: Containerization (Docker) or cloud platforms (AWS, Azure, GCP)
for hosting the final model.
2. Collaboration & Project Management:
o Use Agile methodology or a similar iterative approach.
o Regular checkpoints/sprints to track progress and adjust scope.
3. Evaluation Criteria:
o Technical Accuracy: Correctness and quality of the ML models.
o Innovativeness: Novel approaches to data handling, model architecture, or user
experience.
o Scalability & Robustness: How well the solution can handle diverse or increasing data
loads.
o User Experience: The intuitiveness and utility of the final system from a learner’s or
developer’s perspective.
Problem Statement 3
AI-Powered Personal Tutor: A Scalable, Adaptive Learning System for Enhanced Student
Engagement
In the rapidly evolving educational landscape, personalized learning has become a key
driver in improving student outcomes. However, traditional tutoring methods are limited
by resources, scalability, and accessibility. The challenge is to develop an intelligent,
scalable AI-powered personal tutor system that can provide tailored learning experiences
to students in real-time, addressing individual needs and learning styles, while ensuring
secure and personalized access through user authentication.
Participants are encouraged to leverage Intel’s offerings, including hardware, software,
and AI technologies, to build and optimize the solution for maximum performance,
scalability, and efficiency.
Objective:
The goal is to create an AI-based personal tutor system capable of:
1. Personalized Learning: The system should adapt to the unique learning
pace and style of each student, recommending customized learning paths and exercises.
2. Real-Time Assistance: Provide immediate assistance for academic queries,
with AI-powered chat or voice interaction, simulating a human tutor experience.
3. Progress Tracking & Feedback: Continuously assess student performance
and provide feedback to guide improvement, identify areas for growth, and motivate
students.
4. Content Recommendation: Suggest additional resources, such as videos,
articles, and quizzes, based on the student’s current progress and interests.
5. User Authentication: Implement a secure user authentication mechanism
to ensure that students’ learning data is private and personalized. The system should allow
users to sign up, log in, and manage their profiles while safeguarding their progress and
preferences.
6. Scalability and Accessibility: Ensure the system can handle multiple users
and be accessible across various devices, creating an inclusive learning experience.
Encouraged Use of Intel Technologies:
Participants are encouraged to integrate the following Intel offerings into their solution:
• Intel® CPUs and GPUs: Leverage Intel’s high-performance processors for
fast computation, AI model training, and real-time interaction.
• Intel® Distribution of OpenVINO™ Toolkit: Use OpenVINO™ to optimize AI
model inference, particularly for edge devices, improving speed and efficiency.
• Intel® DevCloud: Utilize Intel’s cloud platform for testing, simulating, and
optimizing your solution on Intel’s infrastructure.
• Intel® AI Analytics Toolkit: Implement machine learning algorithms and
data analytics using Intel’s AI libraries and frameworks.
• Intel® Security Technologies: Enhance the user authentication process and
secure data storage using Intel’s security offerings.
Expected Outcome:
By the end of the training program, students should develop a prototype of an AI-powered
personal tutor system that demonstrates key functionalities such as adaptive learning
paths, real-time assistance, progress tracking, personalized content recommendations,
and secure user authentication. The solution should be optimized for performance using
Intel’s offerings, including hardware, AI technologies, and cloud infrastructure, to create a
scalable, user-centric, and secure educational tool.
Problem Statement 4
Enhancing Customer Experience with AI-Driven Insights
Objective: Create an AI system that leverages real-time video analytics and customer
behavior data to personalize in-store experiences.
Prerequisites:
• Basic understanding of computer vision and video analytics.
• Knowledge of AI/ML frameworks such as TensorFlow or PyTorch.
• Experience with Python programming and handling large datasets.
• Familiarity with real-time video processing tools like OpenCV.
Problem Description:
Brick-and-mortar retail stores face increasing competition from e-commerce platforms
due to the lack of personalized experiences. The goal is to develop a smart AI system that:
1. Tracks customer movement in real-time using in-store camera feeds.
2. Analyzes customer behavior to identify high-traffic areas and customer preferences.
3. Provides actionable insights for product placements, promotional strategies, and
restocking shelves.
Expected Outcomes:
• A functional prototype capable of tracking and analyzing real-time video feeds.
• Real-time alerts for restocking or customer assistance in under-served areas.
• Insights for optimal product placement and promotion strategies based on behavior
patterns.
Challenges Involved:
• Processing multiple real-time video streams with minimal latency.
• Ensuring accurate detection of customer behavior in varying lighting and crowded
conditions.
• Handling and analyzing large-scale data without overloading system resources.
Tools & Resources:
• Hardware: Intel AI PC with GPU and NPU for real-time processing / any Intel Hardware.
• Software: OpenCV, TensorFlow/PyTorch, and video analytics libraries.
• Datasets: Publicly available customer behavior datasets or synthetic data generated using
simulation tools.
Problem Statement 5
Design and Implementation of an Automated Sorting System Using Mechatronics Principles
Background:
In modern manufacturing and logistics industries, sorting items efficiently and accurately is crucial
for optimizing workflows and reducing human error. Automation technologies, particularly
mechatronics systems, are widely used to improve the speed, precision, and reliability of sorting
systems. This problem statement challenges you to design an automated sorting system that can
distinguish between different items and sort them based on predetermined criteria using a
combination of sensors, actuators, and control systems.
Problem Statement:
You are tasked with developing an automated sorting system that sorts objects into three distinct
categories based on their color (e.g., red, blue, and green). The system should include the
following key components:
1. Sensor System:
o Implement a vision-based or color-sensing system (e.g., a camera or a color sensor)
that can accurately detect the color of objects passing through the sorting area.
o Optionally, integrate other types of sensors (e.g., proximity, weight, or size sensors)
for additional sorting capabilities.
2. Actuation System:
o Design a robotic arm or conveyor belt system that can move the objects to
different bins or sections based on the detected color.
o The system should have actuators (motors, servos, or pneumatic cylinders) for
precise and reliable movement of objects.
3. Control System:
o Develop a control algorithm that processes sensor data and triggers the actuators
accordingly.
o Implement a microcontroller (e.g., Arduino, Raspberry Pi, or a PLC) to control the
system.
o Ensure that the sorting process is automated, and the system can handle variable
item speeds and positions.
4. System Integration:
o Design and integrate all components into a functional system with an intuitive user
interface (if applicable) to set sorting parameters (e.g., sorting categories, speed
adjustments).
o Provide real-time feedback on system status, such as the number of items sorted
and any errors that may occur.
Deliverables:
1. A detailed design document including system architecture, component selection, and
functional specifications.
2. A working prototype that demonstrates the ability to automatically detect and sort
objects based on their color.
3. A report or presentation explaining the implementation process, challenges faced, and
how the system meets the requirements.
Evaluation Criteria:
• Functionality: Does the sorting system correctly detect and sort objects based on their
color?
• Accuracy and Reliability: How accurate and reliable is the sorting process under various
conditions?
• Efficiency: How well does the system perform in terms of speed and throughput?
• Innovation: Are there any innovative design choices or improvements made to the
system?
• Documentation: Is the design well-documented with clear explanations and diagrams?
Additional Challenges (Optional):
• Implement an adaptive sorting mechanism that can learn to sort based on additional
parameters, such as shape or size, using machine learning or advanced sensor integration.
• Design the system for scalability so that it can handle different object sizes, speeds, and
material types.
Problem Statement 6
ComicCrafter AI is a generative AI based comic generator running locally on edge devices that
generates a comic style story based on the input prompts given by the user.
Pre-requisites
1. Knowledge of Large Language Models (LLMs): Understanding of how LLMs work, including
prompt engineering and deploying with hardware acceleration on local computing
devices.
2. Familiarity with Image Generation Tools: Experience with tools like Stable Diffusion, or
similar platforms for generating images which can be deployed on the edge via
opensource projects like comfy UI or Intel AI Playground.
3. Programming Skills: Proficiency in Python or other relevant programming languages.
4. Edge Computing: Basic knowledge of deploying AI models on edge devices.
5. App Development: Experience in developing applications, preferably with a focus on
integrating multiple AI services.
Problem Description
The objective of this project is to develop an application that generates a comic book-
style short story based on a user-provided prompt. The story will be divided into four
parts: introduction, storyline, climax, and moral of the story. The project will be
executed in four phases:
1. Phase 1: LLM Story Generation using Prompting
o Develop a module that uses LLMs to generate a coherent story based on the user’s
prompt.
o The story should be divided into four distinct parts: introduction, storyline, climax,
and moral.
2. Phase 2: Image Generation
o Create a module that generates images corresponding to each part of the story
using AI-based image generation tools.
o Ensure that the images align with the narrative.
3. Phase 3: Merging Story Prompts and Images
o Develop a system to merge the generated text and images into a cohesive comic
book format.
o Ensure that the text and images are appropriately aligned and formatted.
4. Phase 4: Integration into an App
o Integrate the story generation, image generation, and merging modules into a
single web application.
o Ensure the app is user-friendly and can run efficiently on edge devices.
Outcomes Expected
1. Functional Application: A fully functional app that can generate comic book-style stories
based on user prompts.
2. User Engagement: An engaging user interface that allows users to input prompts and view
the generated comic book.
3. Edge Deployment: Successful deployment of the application on edge devices, ensuring
efficient performance.
Challenges Involved
1. Story Coherence: Ensuring that the LLM generates a coherent and engaging story based
on the user’s prompt.
2. Image Relevance: Generating images that accurately represent the story and are in a
comic book style.
3. Integration: Seamlessly integrating the text and images into a cohesive comic book
format.
4. Edge Deployment: Optimizing the application to run efficiently on edge devices with
limited resources.
Tools & Resources to be Used
1. LLMs: Use latest open weight models e.g Llama, Deepseek, Mistral etc, evaluate the best
model for this requirement.
2. Image Generation Tools: Use open weights Stable Diffusion, or similar platforms for
generating images which can be deployed on the edge via opensource projects like comfy
UI or Intel AI Playground.
3. Programming Languages: Python for developing the modules.
4. Edge Devices: Intel-based edge devices for deploying the application.
5. App Development Frameworks: Use python based web app framework like streamlit for
integration the all parts in to a easy to use web UI.
Submission Format
A fully open-source GitHub repo consisting of the following:
1. Project Report: A detailed report covering the problem statement, methodology,
challenges faced, and solutions implemented.
2. Source Code: Well-documented source code for all modules and the integrated
application.
3. Demo Video: A video demonstrating the functionality of the application.
4. User Manual: A manual explaining how to use the application, including installation and
usage instructions.
Problem Statement 7
Visual Search using VLM's
Develop a visual search engine that leverages vision-language models (VLMs) to retrieve
relevant images based on textual queries or sample images. The system should embed both text
and images into a shared representation space, allowing users to search via keywords, natural
language descriptions, or example images.
Objectives
1. Shared Embedding Space
o Utilize a state-of-the-art VLM (e.g., CLIP, BLIP, ALIGN) to generate embeddings for
both images and text.
o Ensure that semantically similar images and textual descriptions occupy nearby
regions in the embedding space.
2. Indexing & Retrieval
o Create an efficient indexing pipeline (e.g., using FAISS, Annoy, or Milvus) to store
and retrieve image embeddings at scale.
o Implement fast similarity search methods (k-nearest neighbors, approximate
nearest neighbors) to handle large datasets.
3. Multi-Modal Querying
o Support multiple query types:
▪ Text Query: “Show me images of a sunset over water.”
▪ Image Query: Find visually similar images to a given example.
o Optionally, handle more advanced or compositional queries (e.g., “red shoes
with white laces”).
4. Evaluation & Metrics
o Assess retrieval performance using common image retrieval metrics
(precision@k, recall@k, mean average precision).
o Perform qualitative analysis of retrieval quality (do the returned images match
the query context?).
Prerequisites
• ML & Data Analytics: Familiarity with Python-based ML libraries (PyTorch, TensorFlow)
and data manipulation (NumPy, Pandas).
• Computer Vision Basics: Understanding of image processing and representation
(convolutional neural networks, feature extraction).
• NLP Fundamentals: Comfort with text embedding concepts and how language encoders
work.
• Search Systems: Basic knowledge of indexing structures (e.g., inverted indices, ANN
search libraries).
Challenges
1. Embedding Alignment
o Ensuring robust alignment between text embeddings and image embeddings.
o Handling domain shifts (e.g., if the training data is very different from the test
set).
2. Data Acquisition & Diversity
o Curating a sufficiently large and diverse image dataset for meaningful search
results.
o Balancing coverage (varied image categories) with label accuracy or textual
annotations.
3. Scalability & Performance
o Managing large-scale image datasets (tens of thousands to millions of images).
o Optimizing latency for real-time or near real-time search experiences.
4. Semantic Granularity
o Handling nuanced or complex descriptions (e.g., “a cat wearing sunglasses next
to a beach”).
o Dealing with subtle visual differences (e.g., distinguishing between multiple
shades of a color or similar product variants).
5. User Experience
o Designing intuitive interfaces for multi-modal searches.
o Providing clear feedback mechanisms when queries fail or return irrelevant
results.
Expected Outcomes
• Functional Visual Search Engine
o Users can input textual queries (short phrases or detailed descriptions) or
provide an image sample.
o The system returns the most semantically similar images from the indexed
dataset.
• Quantitative Performance
o Demonstrable retrieval performance improvements over baseline or keyword-
only systems.
o Clear metrics (precision@k, recall@k) to gauge effectiveness on test queries.
• Scalable Deployment
o Ability to handle growth in dataset size without significant drops in retrieval
speed or accuracy.
o Potential integration into a cloud-based environment or a containerized solution
(e.g., Docker) for easy scaling.
• Extensibility
o Potential to incorporate user feedback (e.g., relevance feedback, “more like this”)
to refine search results over time.
o Easy adaptation to various domains, such as e-commerce product search, photo
library management, or art/creative exploration.
Implementation Tips
• Choose the Right Model: Start with a pre-trained VLM (e.g., OpenAI’s CLIP) and fine-
tune if domain-specific data is available.
• Efficient Indexing: Experiment with approximate nearest neighbor libraries (FAISS,
Annoy, Milvus) for large-scale performance.
• Iterative Approach: Begin with a small, well-labeled dataset to validate the pipeline,
then scale up.
• User Testing: Incorporate user feedback early—visual search is subjective, and real-
world feedback can guide improvements.
