cover photo

COURSE

AI-ML-001

4 Levels · 11 Months

An introductory course on Artificial Intelligence and Machine Learning.

AI-ML-001

Jump to:

Level 1

Generic Tasks

TASK 1: 3D Printing

Understand the working of a 3D printer, check out the online resources. Understand what's an STL file, and then learn to slice it (using ultimaker or creality slicer).Go through the SOP'S regarding the 3d printer. Learn about bed temperature, infill density and other printer settings. Finally get an STL file from the internet, and slice it and put it for print.

Resources:

● Introduction to 3d printer

● PLA settings

● Types of 3D printing

(Note this task is to be done under coordinator supervision.) 3dprinter

TASK 2: API

What is an API? Learn the working of an API and its applications. Using any api of your choice, build an user interface(web app, mobile app, etc), where you can make calls and then display the necessary information. An example weather app is given below, using the open weather api.

● Example

TASK 3: Working with Github

Familiarize yourself with GitHub integrated workflows (GitHub actions), Issues, and pull requests with this task. Given below is a git repository, go check it out and then perform the necessary tasks stated in the readme file.

Check this link for more info: https://github.com/UVCE-Marvel/git-task

TASK 4: Get familiar with the command line on ubuntu and do the following subtasks:

● Create a folder named test.

● cd into that folder.

● Create a blank file without using any text editor.

● list the files in that folder

● create 2600 folders in this folder where each folder is named like . For example, M90 or B56.

● concatenate two text files containing any random text and display them on the terminal.

https://ubuntu.com/tutorials/command-line-for-beginners#1-overview

Task 5 : Build Your Own Brain -Linear Regression from Scratch

Dive into the core of machine learning by implementing Linear Regression from scratch using , and compare its performance with the scikit-learn implementation. Use the California Housing dataset to evaluate your model on real-world data.

Your Task:

  • Implement linear regression manually (without using ML libraries for training).
  • Understand and apply gradient descent to minimize error.
  • Compare your custom model’s performance against sklearn.linear_model.LinearRegression .
  • You should analyze results by:
    • Graph showing line of best fit and the datapoints.
    • Performance metrics: MSE, MAE, R² for both custom and scikit-learn models.
    • Brief comparison between two models.

Download Dataset

Learn Linear Regression:

  1. Understanding :

  2. Coding the linear regression algorithm from scratch:

Expected Outcomes:

  • Grasp how gradient descent optimizes weights in linear regression.
  • Understand the importance of feature scaling.
  • Know how to evaluate regression models using standard metrics.
  • Be able to appreciate the convenience and performance of inbuilt ML libraries.

Precautions:

  • Always normalize or standardize features before training your scratch model, especially if you’re using gradient descent.
  • Be cautious with your learning rate , too small and the model is slow, too large and it may diverge.
  • Initialize weights and bias properly ( small random values or zeros).

Task 6 : The Matrix Puzzle — Decode with NumPy & Reveal the Image

Get hands-on with NumPy and Matplotlib by solving a visual puzzle. You’ll be given a scrambled matrix, and your mission is to decode it into a hidden image using NumPy operations and visualization techniques.

Your Task:

  • Download the scrambled matrix from the link provided.
  • Use your knowledge of NumPy to manipulate, reshape, and reorient the matrix.
  • Reveal the secret image by plotting it using matplotlib.pyplot.imshow() .
  • Scrambled Matrix: Download Here
  • NumPy Learning Doc: Explore Here

Learn NUMPY:

Learn Matplotlib:

Decode the Matrix using these clues and Visualize it :

  • "Try reshaping the encoded array into a square—how many elements are there?"
  • "The structure may be upright, but the data might be sideways. Look at its orientation."
  • "Sometimes the end is actually the beginning."

Expected Outcomes:

  • Gain confidence with NumPy operations like reshaping, slicing, flipping, and transposing.
  • Learn to visualize 2D arrays using Matplotlib.
  • Sharpen your debugging and puzzle-solving skills in a fun context.

Precautions:

  • Check the shape of the array before applying imshow() - wrong dimensions will throw errors.
  • Ensure that your reshaped matrix has the correct number of elements (it's likely a square!).

TASK 7: Create a Portfolio Webpage

Create a website to showcase your portfolio - about yourself, interests, projects, social media profiles and more. It has to be responsive and also pushed to the git repository. CSS can be of your choice and any framework can be used.

TASK 8: Writing Resource Article using Markdown

Markdown is an easy-to-use markup language that is used with plain text to add formatting elements (headings, bulleted lists, URLs) to plain text without the use of a formal text editor or the use of HTML tags. Markdown is device agnostic and displays the writing format consistently across device type. Write a technical resource article on a topic of your choice and post it on the MARVEL website. Refer to the linked article for further details

Link

TASK 9: Tinkercad

Create a tinkercad account, get familiar with the application, understand the example circuits given and simulate a simple circuit using an ultrasonic sensor to estimate the distance between an obstacle and the sensor. Display the results on the serial monitor.

Create a radar system utilising an ultrasonic sensor and servo motor to detect objects within a certain range. The ultrasonic sensor emits sound waves and measures the time taken for them to bounce back, while the servo motor rotates the sensor to cover a wider area, providing a simple yet effective detection mechanism. RESOURCE: https://youtu.be/NwmcNCvUcDc?si=x2LAYMFiqs1SzLfI TASK OUTCOME: introduction to- · TINKERCAD · Working of ultrasonic sensor and servo motor · Radar technology PRECAUTIONS/SAFETY MEASURES- NOT ANY

TASK 10: Speed Control of DC Motor

Explore basic techniques for controlling DC motors, understand the control DC motors using the L298N motor driver and the Arduino board. Using an UNO and H-Bridge L298N motor driver, control the speed of a 5V BO motor, try simulating this on tinkercad and then perform it on the hardware, Record videos of you doing the same.

Reference

TASK 11: LED Toggle Using ESP32

Learn the working of an ESP32 and create a standalone web server with an ESP32 that controls the LED connected with ESP32 GPIOs. Use the arduino IDE to code and upload the program to the ESP32. Learn to configure the IDE to upload code to an ESP32.

Reference

TASK 12: Soldering Prerequisites

(Soldering is to be done in presence of a coordinator)

Learn about the soldering equipment present in our lab, the solder, the soldering iron, soldering wick, flux, etc. Learn to use them and perform basic soldering on a perf board, for example a LED circuit in the presence of a coordinator and document the same.

Reference

TASK 13:

Design a 555 astable multivibrator with duty cycle 60%, rig up the circuit on a breadboard and by using the probes observe the output of your circuit on the DSO. Resources:

● Circuit

TASK 14: Karnaugh Maps and Deriving the logic circuit

Description: For 4 cases, based on door lock/open and key pressed/not pressed. Determine the karnaugh map and make a burglar alarm using simple logic circuits. The buzzer or led blinks when certain conditions are met, you can use push buttons for the door and key.

(Tip: use logic gates, use k-maps to figure out the working conditions.)

TASK 15: Active Participation:

Take part in any technical event, inter or intra college and submit the issued certificate of participation.

Enroll for a MOOC and complete the course.

TASK 16: Datasheets report writing:

Topics: 1)MQ135 Gas sensor 2)L293D motor driver Task Description: Study the datasheet of any one of the above and write a report on it. Specify about the ICs used in L293D, PWM, H-bridge etc. In case of MQ 135, specify the calibrations for different gases and the Freundlich Absorption Theorem Graph.

Task 17: Introduction to VR

Familiarise yourself with what Virtual Reality is. Make a detailed study about what's the difference between VR and AR. Mention about the trends in the space and technology stack being developed. Make about Indian companies in this space. Make the report with detail. Using generative AI to generate this study can lead to disqualification.

vrlol

TASK 18: Sad servers - "Like LeetCode for Linux"

Sadservers is an excellent ground to test your Linux troubleshooting skills. Here is a troubleshooting scenario: Command Line Murders. Troubleshoot and Make Sad Servers Happy!

Command line murder
Linux commands
Linux commands

Task 19: Make a Web app

Using express create a resource library website where you can browse the resource articles, books etc which are available and also manage your account
Reference

Domain Specific Tasks

Task 20 : Notebook Ninja – Getting Started with Jupyter

Familiarize yourself with Jupyter Notebook as a tool for both coding and communication.This task is designed to build confidence in writing clean, readable, and well-structured notebooks using both code and Markdown.

Your Task:

Complete the following challenges inside a single Jupyter notebook.

Quest 1: Markdown & Presentation Skills

  • Use Markdown to structure and beautify your notebook:
  • Add a title and section headers ( # , ## )
  • Create a bullet list of 3 things you want to learn
  • Format text using bold, italics, and insert a horizontal line ( --- )
  • Embed an image
  • Include a code snippet using triple backticks

Quest 2: Python Coding & Visualization

  • Demonstrate Python coding and Jupyter features:
  • Declare two variables, do a calculation, and print the result
  • Plot a simple graph using Matplotlib (e.g., line plot)
  • Wrap it all into a mini-report with an intro and a closing summary

Expected Outcomes:

  • Know how to structure a professional, readable Jupyter notebook.
  • Understand Markdown basics for data storytelling.
  • Build confidence in combining code, comments, and visualizations.
  • Develop the habit of documenting your thought process clearly.

Precautions:

  • Don’t mix up code and markdown cells , switch cell types appropriately.
  • Don’t clutter , use whitespace and headers to maintain readability.
  • Keep your notebook clean by remove unused cells or redundant outputs.

Learn to Install and use Jupyter:

Task 21: Watch & Reflect – Intro to Machine Learning

Understand foundational ML concepts and data preparation techniques by watching two beginner-friendly videos and writing an article.

Watch the following videos:

  1. A Gentle Introduction to Machine Learning by StatQuest
  1. How is Data Prepared for Machine Learning? by AltexSoft

Your Task:

Write a resource article (300–500 words) summarizing the contents of the two videos and your understanding of it , and upload it in the resource articles page of the MARVEL website

Level 2

System Requirements:

  • Jupyter Notebook(installed or set up)
  • Python IDE( (VS Code or PyCharm).
  • Python Libraries installed (numpy , pandas, matplotlib , sci-kit learn , seaborn , joblib)

TASK 1 : MATLAB ML Onramp Course

Gain hands-on experience with Machine Learning fundamentals using MATLAB. This task is designed to introduce you to practical ML workflows through interactive and guided lessons on the MATLAB Machine Learning Onramp Course .

Your Task:

Enroll in and complete the MATLAB Machine Learning Onramp course.

Expected Outcomes:

Understand the end-to-end flow of a machine learning project. Gain exposure to supervised learning techniques in a new tool. Learn data handling, model training, validation, and performance assessments. Be able to compare MATLAB’s workflow with Python-based tools like scikit-learn

Precautions:

Ensure stable internet as your progress might be lost if page resets .

TASK 2 : Kaggle Crafter - Build & Publish Your Own Dataset

Learn the essentials of data curation, documentation, and publishing by creating and sharing your own dataset on Kaggle. This task will help you understand what makes a dataset usable, discoverable, and valuable to the data science community.

Your Task:

  • Create a dataset of your choice - it can be real or synthetic or fake , but should be cleanly organized.
  • Upload the dataset to Kaggle with proper metadata and formatting.
  • Your dataset should meet the following usability criteria (total score ≥ 8.5):

Usability Factors:

1. Completeness

Add a subtitle, tags, description, and a cover image

2. Credibility

  • Mention source/provenance (or clarify it’s synthetic
  • Add a public notebook demonstrating use (if applicable)
  • State the update frequency clearly

3. Compatibility

  • Choose a proper license (like CC0 or CC BY)
  • Ensure it’s in a compatible format ( .csv , .xlsx , .json , etc.)
  • Write clear descriptions for the file and columns

Expected Outcomes:

  • Understand what makes a dataset useful, trustworthy, and user-friendly
  • Practice data storytelling through documentation and presentation
  • Build visibility on Kaggle with a well-structured contribution
  • Gain confidence in preparing and sharing data professionally

Precautions:

  • Avoid sensitive, personal, or plagiarized data
  • Keep your dataset clean and minimal

Learn how to create Fake Datasets in Python:

Learn how to upload Dataset to Kaggle :

Article

TASK 3 : Data Detox - Data Cleaning using Pandas

Learn how to preprocess and clean raw, messy datasets using Pandas for better machine learning outcomes.

Your Task:

  1. Load the dataset and explore the types of issues present.
  2. Handle missing values by either dropping or imputing them.
  3. Fix inconsistencies in text or categorical columns (e.g., case mismatches, typos).
  4. Format column correctly (e.g., dates as datetime , numbers as int / float ).
  5. Remove duplicate rows, if any.
  6. Save the cleaned dataset as a new CSV.

Expected Outcomes:

  • Understand real-world data cleaning challenges.
  • Gain hands-on experience with Pandas data cleaning methods.
  • Learn to prepare data for analysis or modeling.

Precautions:

  • Always inspect the data before applying changes.
  • Don’t blindly drop nulls-understand their significance.
  • Keep a backup of raw data before applying transformations.

Download Dataset

Learn Pandas:
Learn to clean dataset using Pandas:

TASK 4 : Anomaly Detection

G-Flix Inc. suspects a breach , but not from the outside. Your job as a Data Forensics Officer is to detect unusual patterns in user activity logs using anomaly detection techniques. The twist? You don’t know what the anomaly looks like , it’s hidden in plain sight.

Your Task:

  • Load and explore the provided dataset.
  • Identify normal behavior trends using visualizations.
  • Apply at least two anomaly detection techniques:
    • Statistical (e.g., Z-score, IQR)
    • Unsupervised ML (e.g., Isolation Forest, DBSCAN)
  • Compare flagged anomalies from each method.
  • Prepare a final report with your top 5 suspects and evidence.

Expected Outcomes:

  • Understand real-world applications of anomaly detection.
  • Gain hands-on experience with unsupervised ML methods.
  • Learn how to differentiate between outliers and genuine anomalies.
  • Build effective visualizations for behavior profiling.
  • Develop investigative storytelling and reporting skills.

Precautions:

  • Scale your data before applying distance-based algorithms.
  • Don’t assume every outlier is an anomaly : context is key.
  • Use multiple features to justify suspicious behavior.
  • Validate anomalies through both visual and algorithmic evidence.

Download Dataset

Understand the concept and implementation:
Learn to implement Different Anomaly Detection Algorithms :

TASK 5 : Logistic Regression from Scratch

Understand binary classification through hands-on experience by building a logistic regression model from scratch and comparing it with a standard library implementation. The chosen use-case: predicting heart disease.

Your Task:

  • Implement Logistic Regression from Scratch
  • Implement Logistic Regression Using scikit-learn
  • Compare Models
  • Use metrics: accuracy, precision, recall, F1-score
  • Discuss:
    • Performance differences
    • Training time
    • Implementation difficulty and interpretability

Download Dataset

Expected Outcomes :

  • Master the inner mechanics of logistic regression
  • Practice matrix operations and gradient descent
  • Learn how scikit-learn abstracts complexity
  • Build confidence in choosing the right level of abstraction for ML tasks

Precautions

  • Watch out for issues like vanishing gradients and poor convergence.
  • Ensure your dataset is normalized.

Understand Logistic Regression:
Implement Logistic Regression From Scratch:

TASK 6 : Battle-Test Your Model - Support Vector Machines

Understand and implement Support Vector Machines (SVM) using scikit-learn , then stress-test your model by injecting noise into the data to observe how its performance deteriorates. Use Red Wine quality Dataset.

Your Task:

  • Implement SVM Using scikit-learn
  • Noise Robustness Experiment: * Gradually add Gaussian/random noise to the dataset: * Begin with small noise levels (e.g., ±1%) * Increase progressively (e.g., ±5%, ±10%, etc.)
  • At each level: * Retrain the model * Evaluate and log the metrics * Identify the breakdown point - the level of noise where the model starts to fail.

Visualize the Results

  • Create a line plot of performance metrics vs. noise level
  • Highlight the threshold where model performance drops sharply

Download Dataset

Expected Outcomes:

  • Be able to apply SVMs to real-world datasets
  • Understand how robust your model is to data corruption
  • Gain insight into hyperparameter tuning, model evaluation, and noise handling

Precautions:

  • Check for and handle missing or duplicate data.
  • Add noise only to features, not labels.
  • Gradually increase noise in small steps (e.g., std dev: 0.01 → 0.5).
  • Avoid complex kernels with small datasets.
Understand SVMs:
Implement SVMs:

TASK 7 : Fairness Meets Functionality

Use the Utrecht Fairness Recruitment Dataset from Kaggle, which contains anonymized recruitment data including age, gender, education, experience, and whether a candidate was hired.

Investigate potential biases in the model by analyzing its predictions across demographic groups such as gender and age. Use fairness metrics like demographic parity and equal opportunity to measure disparities. Discuss any unfair discrimination found and explore possible reasons behind it.

Your Task:

  • Build a Decision Tree from Scratch using ID3 Algorithm
  • Evaluate Model Performance
  • Use performance metrics: * Accuracy * Precision * Recall * F1-score
  • Analyze feature importance: * Which features were most influential in the tree? * Do these make intuitive or ethical sense?
  • Conduct a Fairness Analysis * Slice the data by demographic groups: * Gender (Male/Female/Other) * Age brackets (e.g., <25, 25–35, 35+)

Discuss:

  • Demographic Parity: Are hiring decisions independent of gender or age?
  • Equal Opportunity: Are qualified candidates from all groups equally likely to be hired?

Expected Outcomes:

  • Understand decision tree fundamentals and implementation
  • Learn how model decisions are formed
  • Gain awareness of bias detection techniques in machine learning
  • Explore responsible AI practices and ethical model deployment

Precautions:

  • Limit tree depth and set minimum samples per split.
  • Handle missing demographic info appropriately.
  • Clearly define demographic groups (e.g., gender, age brackets).
  • Watch for proxy variables causing indirect bias.
Understanding Decision Trees
Understand ID3 :
Implement ID3 :

TASK 8 : KNN with Ablation Study

In this task, you'll build a K-Nearest Neighbors (KNN) classifier using the Breast Cancer Wisconsin dataset. The goal is to not only train and evaluate the classifier, but also to conduct a feature ablation study to determine which features are most important for accurate classification. By removing one feature at a time and observing the effect on model performance, you'll identify which features significantly contribute to the model’s prediction.

Your Task:

  • Preprocess Data: * Drop id , encode diagnosis (M=1,$ $,B=0)$ , and normalize features.
  • Train KNN Model: * Use KNeighborsClassifier (e.g., $k=5)$ , train-test split, and evaluate.
  • Feature Ablation: * Remove one feature at a time, retrain, record metrics (accuracy, precision, recall, F1score).
  • Analyze Impact: * Identify features whose removal drops performance the most.

Expected Outcomes

  • Understand how KNN works and why feature scaling is essential.
  • Gain hands-on experience in evaluating model performance.
  • Learn how removing features affects model behavior and accuracy.
  • Discover which features are most informative in medical datasets.
  • Appreciate the value of feature selection and ablation studies in ML pipelines.

Precautions

  • Normalize data before KNN.
  • Use consistent k-value for fair comparison.
  • Compare all 4 metrics, not just accuracy.
  • Ensure only one feature is removed at a time.
Understand KNN :
Implementation:

TASK 9 : Evaluation Metrics - Pick the Best Performer!

You will receive 5 pretrained ML models saved as .pkl files. Your goal is to evaluate and compare them using a test dataset and identify the best-performing model.

Your Task:

  • Load the test dataset using pandas .
  • Load each pickle file using joblib .
  • Use the model to predict on the test set.
  • Evaluate: * Classification: accuracy, precision, recall, F1-score. * Regression: MSE, RMSE, R².
  • Compare all scores and conclude which model performs best, with reasons

Expected Outcomes:

  • Learn how to load and evaluate saved models.
  • Understand different evaluation metrics and their significance.
  • Develop critical analysis by comparing models based on real performance.
  • Gain experience in handling multiple model types efficiently.
  • Learn to make informed decisions on model selection.

Precautions:

  • Ensure consistent preprocessing (scaling, encoding) between training and testing.
  • Check if model type matches the dataset (classification vs regression).
  • Handle exceptions if a model fails to load or predict.
  • Verify test data shape matches model input requirements.

Download Pickle Files

Install Joblib

Learn how to use Joblib for machine learning:
Evaluation Metrics:

Level 3

Task 1 — Naive Bayes Classifier

Objective: Understand probabilistic classification and implement the Naive Bayes algorithm.

Concepts

  • Bayes theorem
  • Conditional probability
  • Prior and posterior probability
  • Independence assumption
  • Laplace smoothing

Implementation

  1. Implement Naive Bayes from scratch using Python and NumPy.
  2. Apply it to a text classification problem such as spam detection or sentiment analysis.
  3. Compare the implementation with scikit-learn's Naive Bayes classifier.

Deliverables

  • From-scratch implementation
  • Accuracy, precision, recall and F1 score
  • Confusion matrix
  • Comparison with the scikit-learn implementation

Links

Task 2 — Ensemble Learning and Tree-Based Models

Objective: Understand how combining multiple models improves predictive performance.

Algorithms

  • Random Forest
  • Gradient Boosting Machine (GBM)
  • XGBoost

Dataset: Titanic survival dataset.

Implementation

  1. Preprocess the dataset and create train/test splits.
  2. Train Random Forest, GBM and XGBoost models.
  3. Evaluate using accuracy, precision, recall and F1 score.
  4. Visualize and interpret feature importance.

Deliverables

  • Model comparison table
  • Performance metrics
  • Feature-importance plots
  • Short analysis of model differences

Links

Task 3 — Hyperparameter Tuning

Objective: Understand how hyperparameters affect model performance and generalization.

Concepts

  • Hyperparameters vs parameters
  • Cross-validation
  • Model selection

Methods

  • Grid Search
  • Random Search
  • Bayesian Search (introduction)

Implementation

Select a model such as Random Forest, XGBoost or SVM and tune parameters such as:

  • Tree depth
  • Number of estimators
  • Learning rate
  • Regularization parameters

Deliverables

  • Hyperparameter search results
  • Best parameter configuration
  • Performance comparison before and after tuning

Links

Task 4 — Image Clustering using K-Means

Objective: Apply unsupervised learning techniques to image data.

Concepts

  • Clustering
  • Cluster centroids
  • Euclidean distance
  • Within-cluster variance

Dataset: MNIST handwritten digits.

Implementation

  1. Load and preprocess the images.
  2. Flatten images into feature vectors.
  3. Apply K-Means clustering.
  4. Assign clusters and compare them with the true digit labels.

Deliverables

  • Cluster visualization
  • Estimated clustering accuracy
  • Interpretation of clusters

Links

Task 5 — Introduction to PyTorch

Objective: Learn the fundamentals of building and training neural networks using PyTorch.

Concepts

  • Tensors and tensor operations
  • Automatic differentiation (Autograd)
  • Neural network modules
  • Training loops

Implementation
Part A — Tensor Operations

  • Create and manipulate tensors
  • Perform matrix operations
  • Run computations on GPU when available

Part B — Linear Regression

  • Build a linear regression model
  • Implement forward pass, loss calculation and optimization

Deliverables

  • Working PyTorch implementations
  • Training/loss curves
  • Model evaluation

Links

Task 6 — Deep Learning Fundamentals

Objective: Understand the core components involved in training deep neural networks.

Activation Functions

  • Sigmoid
  • Tanh
  • ReLU
  • Leaky ReLU

Loss Functions

  • Mean Squared Error
  • Binary Cross Entropy
  • Categorical Cross Entropy

Optimizers

  • Gradient Descent
  • SGD
  • RMSProp
  • Adam

Regularization

  • Dropout
  • Batch Normalization
  • Early Stopping

Implementation

  1. Compare different activation functions using the feedforward network from Task 5.
  2. Compare SGD and Adam.
  3. Observe the effect of dropout on overfitting.

Deliverables

  • Training and validation curves
  • Optimizer comparison
  • Activation-function comparison
  • Short analysis of observations

Links

Task 7 — CNN from Scratch and Transfer Learning

Objective: Understand convolutional neural networks and feature extraction for image classification.

Concepts

  • Convolution
  • Feature maps
  • Pooling
  • Representation learning
  • Transfer learning

Dataset: CIFAR-10.

Implementation

Part A — CNN from Scratch

Build and train a CNN using PyTorch. Example:

Conv → ReLU → MaxPool → Conv → ReLU → MaxPool → Conv → ReLU → MaxPool → Flatten → Dense

Part B — Transfer Learning

  • Use a pretrained architecture such as ResNet or VGG16.
  • Freeze feature-extraction layers and train the classifier.

Deliverables

  • CNN architecture
  • Training curves
  • Comparison between the from-scratch and transfer-learning approaches

Links

Task 8 — Sequence Modeling using RNN and LSTM

Objective: Understand neural networks designed for sequential data.

Concepts

  • Sequential data
  • Hidden states
  • Vanishing gradient problem
  • Long-term dependencies

Models

  • Vanilla RNN
  • LSTM

Dataset options: IMDB movie reviews, a text-generation dataset, or a suitable time-series dataset.

Implementation

  1. Prepare sequential input data.
  2. Train both RNN and LSTM models.
  3. Compare their performance and training behavior.

Deliverables

  • Training results
  • RNN vs LSTM comparison
  • Analysis of sequence-learning behavior

Links

Task 9 — Transformer-Based NLP

Objective: Understand modern transformer architectures and fine-tuning for NLP.

Model

  • DistilBERT

Concepts

  • Tokenization
  • Embeddings
  • Self-attention
  • Positional encoding
  • Fine-tuning

Implementation

  1. Fine-tune DistilBERT for a text-classification task such as sentiment analysis or fake-news detection.
  2. Compare its performance with the LSTM model from Task 8.

Deliverables

  • Fine-tuned transformer model
  • Performance evaluation
  • LSTM vs DistilBERT comparison

Links

Task 10 — Generative AI using GANs

Objective: Understand generative modeling through adversarial training.

Concepts

  • Generator network
  • Discriminator network
  • Adversarial loss
  • Latent space

Dataset: CIFAR-10 or CelebA.

Implementation

  1. Design a generator that maps random latent vectors to images.
  2. Design a discriminator that distinguishes real from generated images.
  3. Train the generator and discriminator adversarially.
  4. Monitor training stability and generated-image quality.

Deliverables

  • Generated image samples
  • Generator and discriminator loss curves
  • Analysis of training behavior

Links

Task 11 — PDF Question Answering using LangChain

Objective: Build a Retrieval-Augmented Generation (RAG) system that answers questions from PDF documents.

Concepts

  • PDF parsing
  • Text chunking
  • Embeddings
  • Vector databases
  • Semantic search
  • Retrieval-Augmented Generation (RAG)

Implementation

  1. Extract text from PDF documents.
  2. Split text into suitable chunks.
  3. Generate embeddings for the chunks.
  4. Store embeddings in a vector database.
  5. Retrieve relevant passages for a user query.
  6. Generate an answer using an LLM.

Deliverables

  • Working PDF Question Answering system
  • Sample queries and responses
  • System architecture and workflow documentation

Links

Level 4

Task 1: Create a end to end mini project using the skills you have learnt.

Here's an outline of the steps we'll follow:

  • Set up Environment: Install necessary libraries and dependencies.
  • Collect Data: Obtain a dataset of recipes and their ingredients.
  • Train Model: Train a simple machine learning model to recommend recipes based on input ingredients.
  • Deploy: Deploy the chatbot web interface to a platform like Heroku.

UVCE,
K. R Circle,
Bengaluru 01

Social Media
Useful links