Level 1

Generic Tasks

Task 1: Print It Yourself

Design a Simple Part and 3D Print It

First learn how a 3D printer works. Then design your own simple parts, a cube and a cylinder, in Onshape. It runs in your browser, so there is nothing to install. No CAD experience needed, so students from any branch can do it. After that, slice your design and print it.

Objective: Understand the full process of 3D printing: design, STL file generation, slicing, and printing.

What to do

Watch the intro video on 3D printers and read the PLA settings guide.
Go through the 3D printer SOPs.
Make an Onshape account with your college email.
Read the Onshape resource article. Design a cube (30 mm sides) and a cylinder (30 mm diameter, 30 mm height) as two separate parts.
Export them as an STL file in millimeters.
Slice the STL in Bambu Studio. Note down the bed temperature and infill density.
Print it with a coordinator present.

Learning Resources

Introduction to 3D Printer — How a 3D printer works.
PLA Printing Guide — Bed temperature, infill, and other PLA settings.
Types of 3D Printing — FDM vs SLA vs SLS.
Designing a Simple Part in Onshape for 3D Printing — Refer to the Resource Article.

Suggested Focus

Read the Onshape article first, then start designing. Type mm after every number. Keep the cube and cylinder as separate parts. Check that the STL is in millimeters before slicing.

Note: 3D printing must be done only under coordinator supervision.

Task 2: Dynamic Portfolio & Admin Dashboard

Task Description

Design and develop a dynamic personal portfolio website along with an administrative dashboard that allows the portfolio owner to manage website content through a graphical interface without modifying the source code.

The application should consist of two integrated interfaces:

Public Portfolio Website: Showcases the student's profile, skills, projects, and achievements.
Admin Dashboard: Allows the owner to manage and update portfolio content dynamically.

Requirements

1. Public Portfolio

Develop a responsive website displaying the student's profile, skills, projects, and achievements.
Retrieve and display portfolio content dynamically through an API.
Ensure that changes made through the admin dashboard are reflected on the public portfolio.

2. Admin Dashboard

Create a user-friendly administrative interface for managing portfolio content.
Implement functionality to add, view, update, and delete projects and skills using forms and controls.
Ensure that content management does not require direct modification of the source code.

3. REST API Development

Develop and integrate a RESTful API to facilitate communication between the admin dashboard, backend, and public portfolio.
Implement appropriate API endpoints and HTTP methods (GET, POST, PUT/PATCH, DELETE) for portfolio content.
Exchange data using JSON and implement basic input validation and error handling.

4. Data Management

Store and manage portfolio content using an appropriate in-memory data structure, JSON file, or another beginner-friendly mechanism.
Ensure that both the public portfolio and admin dashboard access the same application data.
Database integration is optional.

5. Deployment and Documentation

Deploy the application using suitable hosting platforms (e.g., Vercel, Netlify, Render, GitHub Pages).
Maintain the source code in a GitHub repository.
Document the application architecture, API endpoints, setup instructions, and known limitations in a README.md file.

Expected Outcomes

Understand the development of dynamic and responsive web applications.
Learn the fundamentals of REST APIs, HTTP methods, and JSON.
Understand CRUD operations and client-server communication.
Gain experience integrating frontend interfaces with an API.
Develop skills in application deployment, documentation, and error handling.

Suggested Technologies

HTML, CSS, JavaScript, and any suitable backend framework of your choice (Node.js/Express, Python/Flask/FastAPI, etc.).

Submission Requirements

Public portfolio website URL
Admin dashboard URL or route
GitHub repository link
README.md documentation
Screenshots demonstrating content management and dynamic updates

Resources

Task 3: Working with GitHub

Familiarize yourself with real-world Git and GitHub workflows including Issues, Branching, Resolving Merge Conflicts, Pull Requests, and GitHub Actions (CI/CD).

Given below is the task repository. Follow the instructions in its README.md to generate your username-specific assignment, document the bugs you find in a GitHub Issue, fix them on a new branch, resolve the practice merge conflict, and open a Pull Request.

What to include in your task report:

The output of python my_task.py showing your assigned functions.
A link to the GitHub Issue you opened and a brief explanation of the bugs you fixed.
A link to your Pull Request showing the passing GitHub Actions check.
- Note: PRs are verified by CI and left open for review — they do not need to be merged.

Repository Link: https://github.com/UVCE-Marvel/git-task

Task 4: Hack the Hardware — Ubuntu Command Line & Systems Architecture

Objective

Ubuntu Command Line: Systems Computing, Architecture & Linux

Core Intention

To move beyond rote command memorization and cultivate a deep, foundational understanding of computing systems, the Linux operating system, and system-level problem-solving. Students learn how and why their terminal commands navigate the software stack — from high-level shell calls down to execution units in hardware.

1. Hardware Foundation & Architecture: "The 'U' in CPU"

Topics & Concepts

The Anatomy of the CPU: The Control Unit (CU), Arithmetic Logic Unit (ALU), internal registers (A, D, Program Counter PC), and bus connections.
The Fetch-Decode-Execute Cycle: How machine instructions are fetched from memory, decoded by control logic, executed inside the ALU, and written back to registers/RAM.
Hardware Abstraction: How shell instructions translate through compiler/assembler pipelines into binary micro-operations that flip physical logic gates.

Why You Need This

Understanding hardware abstraction stops you from treating the terminal as a black box. Knowing how registers, memory addresses, and execution cycles work allows you to diagnose performance bottlenecks, manage low-level system resources, write efficient code, and program embedded microcontrollers or microprocessors effectively.

How to Study This Topic

Nand2Tetris Unit 4 (Machine Language): Write assembly programs for the Hack computer (Mult.asm and Fill.asm) to manually track register states (A, D, M), instruction decoding, and memory-mapped I/O (Screen and Keyboard).
Trace Hardware Metrics via Terminal: Use terminal utilities like lscpu, lsscsi, and cat /proc/cpuinfo to map abstract CPU concepts (cores, threads, cache sizes, architecture flags) to physical host hardware.

2. Operating Systems, Kernels, and Linux Distributions

Topics & Concepts

The Operating System's Core Role: Memory virtualization, process scheduling, storage management, and hardware safety.
What is a Kernel? The privileged (Ring 0) bridge between user space applications and physical hardware via System Calls (syscalls).
Linux Distributions vs. The Kernel: Distinguishing between the upstream Linux kernel and distributions (Ubuntu, Debian, Fedora, Arch) that package userland tools, package managers, and display servers.

Why You Need This

When an application or script crashes, hangs, or fails to start, the issue usually lies in kernel-level resource access, missing dependencies, or system call errors. Understanding OS mechanics enables you to debug real-world server, embedded Linux, and edge-computing environments.

How to Study This Topic

System Call Observation: Run simple terminal commands through strace (e.g., strace ls) to observe how userland utilities request kernel services (e.g., openat, read, write).
Virtual Filesystem Exploration: Navigate /proc and /sys to understand how the Linux kernel exposes running system states directly as text files.

3. The Linux Environment & Core System Concepts

Topics & Concepts

Terminal vs. Shell: Distinguishing between terminal emulators (user interface) and shells (bash, zsh — command interpreters).
Filesystem Hierarchy Standard (FHS): Root (/), user space (~), device files (/dev), configuration files (/etc), and system binaries (/bin, /usr/bin).
Permissions & Security Model: Read, write, execute (rwx) flags, file ownership (user:group), and privilege escalation (sudo).
Processes & Signals: Process IDs (PIDs), job control (&, fg, bg), environment variables, standard streams (stdin, stdout, stderr), and piping (|).

Why You Need This

The command line is the primary interface for remote servers, cloud infrastructure, robotics platforms (like ROS 2), and build environments. Mastering streams, permissions, and process controls lets you automate complex workflows and manage systems without relying on a graphical user interface.

How to Study This Topic

Interactive Terminal Scenarios: Solve practical system issues (e.g., permission-denied errors, locating run-away processes with top or ps aux, killing stuck tasks via signals).
Pipe Construction: Practice stringing fundamental tools (grep, awk, sed, cut, sort) together to parse logs and extract target metrics.

4. Practical Tips for Terminal Execution

Read the Manual (man): Never guess command flags. Run man (or use tldr ) to inspect flags and syntax.
Inspect Exit Codes: Check $? immediately after running a command to see if it succeeded (0) or threw an error (non-zero).
Fail Fast & Safely: Use ls or echo to verify wildcard patterns (e.g., echo *.log) before executing destructive commands like rm *.log.
Understand Standard Streams: Treat stdout (1) and stderr (2) separately so you don't miss error messages when redirecting logs.
Leverage Autocompletion & History: Use Tab key completion to avoid typos and Ctrl + R to search previous command history quickly.

5. Hands-on Problem Statement: System Audit & Log Processing Pipeline

You are tasked with inspecting a remote Linux workstation that has experienced intermittent slowdowns. Without using any Graphical User Interface (GUI), complete the following steps using terminal utilities:

Hardware & Kernel Inspection:
- Identify the total number of physical CPU cores, architecture model, and the running Linux kernel version. Output these values into a file named system_summary.txt.
Process & Resource Triage:
- Locate all running processes consuming memory on the system. Filter out system daemons to find the process ID (PID) of the process running under your user space, and write the output to process_audit.log.
Permission & File System Reorganization:
- Create a secure directory structure under ~/workspace/audit_logs/.
- Change the directory permissions so that only your user has read, write, and execute permissions (700). Move all generated log files into this directory.
Log Data Parsing & Filtering:
- Given a system log file containing mixed informational and error entries, write a single-line command pipeline using cat, grep, awk, and sort to extract only unique [ERROR] messages and count their occurrences.

6. What You Must Build

To successfully complete this task, you must build and deliver:

Draw Your Own Architecture:
- Draw how you think the CPU used to look before going through it and how it looks now according to you. Wrong answers welcomed — we want to see your conceptual understanding.
Custom Automated Shell Script (system_health.sh):
- A bash script that gathers system uptime, CPU core count, active memory usage from /proc/meminfo, and active user processes, formatting them into a readable text report.
Execution & Analysis Log Notebook:
- A written document explaining:
  - The step-by-step resolution of the Problem Statement.
  - Annotations of key strace outputs showing at least two system calls (openat, write).
  - Explanations for why specific piping choices (|) were used during log extraction.

7. Foundational Command-Line Exercises

Navigation & Inspection: pwd, cd, ls -la, tree
File & Directory Operations: touch, mkdir -p, cp -r, mv, rm -rf
Content Viewing & Inspection: cat, less, head, tail -f, echo, grep

8. Resource Links

Computer Architecture & Nand2Tetris

Nand2Tetris Official Course & Software Suite — Hands-on building of a computer system from basic NAND logic gates up to an Operating System.
Nand2Tetris Unit 4 (Machine Language) — Covers Hack assembly programming, register operations (A, D, M), pointer manipulation, and memory-mapped I/O.
Nand2Tetris Chapter 5 (Computer Architecture) — Focuses on building the Hack CPU, instruction decoding logic, and memory integration.

Linux & Command Line Fundamentals

The Linux Command Line by William Shotts (Free PDF) — Comprehensive reference covering basic shell operations, environment management, and shell scripting.
Linux Journey — Interactive, modular guide breaking down Linux command line operations, text manipulation, permissions, process handling, and kernel mechanics.
LinuxCommand.org Tutorials — Structured, step-by-step tutorials on command execution, storage navigation, and terminal problem-solving.
TLDR Pages — Community-driven, simplified man pages focusing on practical, real-world command usage examples.

Task 5: Operation Blackout — Decode the Hidden Message

An unknown source has transmitted a mysterious sequence of numbers, and your mission is to uncover the secret hidden within it. The data may appear random, but with the right transformations, a meaningful pattern will emerge.

Using NumPy, investigate the encoded array, reshape it into a square matrix, experiment with transposing and reversing its elements, and visualize the result using Matplotlib. Follow the cryptic clues, piece together the original arrangement, and reveal the hidden message!

Can you crack the code and complete Operation Blackout?

Download the NumPy Array: https://drive.google.com/file/d/1lbzxfFuLJSNRXZqT63z8teFWCT44xfRk/view?usp=drivesdk

Learning Resources

NumPy

NumPy Quickstart — Official Documentation — Array shapes, indexing, slicing, and transformations.
Indexing on ndarrays — NumPy — Array indexing and slicing.
NumPy Tutorial — W3Schools — Beginner-friendly reference.
NumPy Tutorial — DataCamp — Tutorial covering common NumPy operations.

Matplotlib

Matplotlib Tutorials — Official Documentation — Plotting fundamentals and customization.
imshow() — Matplotlib Documentation — Display a 2D array as an image.
Colormap Guide — Matplotlib — Choose a colormap for visualizing the matrix.
Matplotlib Tutorial — DataCamp — Introduction to plotting with Matplotlib.

YouTube Videos

NumPy Tutorial for Beginners — Keith Galli — Arrays, slicing, reshaping, and other NumPy basics.
NumPy Tutorial — Corey Schafer — A comprehensive explanation of NumPy fundamentals.
Matplotlib Tutorial — freeCodeCamp — Creating and customizing plots.
Introduction to Numerical Computing with NumPy — Enthought — Search link for a practical NumPy workshop.

Suggested Focus

Before solving the puzzle, review array size and shape, reshape(), transpose(), slicing, and reversing with negative-step slices. Then review imshow() and colormaps. Check that the number of array elements matches the target matrix dimensions before reshaping.

Note: The resources are supplementary learning materials. Students should understand and explain the transformations and matrix operations used in their own solutions.

Task 6: Build Your Own Brain — Linear Regression from Scratch

In this task, you will implement a Linear Regression model from scratch using NumPy to develop a deeper understanding of the underlying principles of machine learning. Using the California Housing dataset, you will train your model using Gradient Descent, investigate the effects of learning rate and feature scaling, and visualize the model’s learning process.

You will then compare your implementation with sklearn.linear_model.LinearRegression using standard evaluation metrics, including MSE, MAE, and R². Through this comparative analysis, you will gain practical insights into model optimization, performance evaluation, and the advantages of established machine learning libraries.

Objective: Develop a fundamental understanding of Linear Regression by implementing, evaluating, and comparing a custom model against a standard library implementation.

Learning Resources

Concepts and Implementation

Google Machine Learning Crash Course: Linear Regression — Introduction to linear regression, features, predictions, and loss.
Google Machine Learning Crash Course: Gradient Descent — How gradient descent updates model parameters.
California Housing Dataset — scikit-learn — Dataset description and loading information.
StandardScaler — scikit-learn — Feature standardization.
LinearRegression — scikit-learn — Reference for the library implementation.
Regression Metrics — scikit-learn — Evaluation metrics and model assessment.
Coding Linear Regression from Scratch — Towards Data Science — Supplementary implementation walkthrough.
Linear Regression from Scratch — AskPython — Step-by-step coding reference.

YouTube Videos

Linear Regression, Clearly Explained — StatQuest — Understand the intuition behind fitting a line and R².
Gradient Descent, Step-by-Step — StatQuest — Visual explanation of gradient descent and parameter updates.
Linear Regression from Scratch with NumPy — MLTut — Code a basic regression model with NumPy, MSE, and gradient descent.
Building the Gradient Descent Algorithm — Nicholas Renotte — Practical coding walkthrough.

Suggested Focus

Start with the linear regression and gradient descent videos before coding. Then implement the model using NumPy, standardize features using training data only, and compare both models on the same held-out test set. Plot the loss over iterations and compare MSE, MAE, and R².

Task 7: Resource Article Writing using Markdown

Markdown is an easy-to-use markup language that is used with plain text to add formatting elements (headings, bulleted lists, URLs, code blocks) without the use of a formal text editor or HTML tags. Markdown is device-agnostic and displays formatting consistently across all device types.

Write a technical resource article on a topic of your choice and publish it on the MARVEL website. Refer to the linked article for formatting guidelines and instructions.

Resource Link: https://hub.uvcemarvel.in/article/52f92f36-fb8a-45da-8f28-686bf4efefff

Task 8: Arduino vs ESP32 — Sensor-Based DC Motor Control

Note: Before working on this task, it is mandatory to have completed basic reading on Arduino Uno and ESP32. Do not proceed to hardware wiring without reviewing the prerequisites.

Problem Statement

Build a DC motor control system using Arduino UNO R3 and ESP32 to compare their pin configurations, analog inputs, PWM control, and voltage levels. Use an HC-SR04 ultrasonic sensor to measure distance and a potentiometer to control motor speed through a suitable motor driver. The motor must stop when an object comes closer than a predefined distance of 15 cm.

Implement the same basic setup on both boards, ensuring that all sensor signals are compatible with the selected board. Finally, extend the ESP32 setup with a web page that allows users to control motor speed using a slider and stop the motor using a button. Identify what additional hardware the Arduino UNO would need to support similar Wi-Fi control.

Simulation Tips (Simulate before hardware wiring):

For Arduino Uno: Use Tinkercad Circuits, a beginner-friendly web-based simulator.
For ESP32: Use Wokwi, a web-based simulator with full ESP32 and Wi-Fi emulation.

Why You’ll Need This

Arduino UNO and ESP32 can perform similar tasks, but their pin configurations, operating voltages (5V vs 3.3V), analog-to-digital converters (ADC), PWM capabilities, and wireless features differ. A circuit that works on one board may damage or fail to work safely on the other.

Through this task, you will explore these differences by building and testing the same application on both boards. You will also learn why a sensor powered by 5V may require voltage level shifting (e.g., a voltage divider) before its output can be safely connected to an ESP32's 3.3V GPIO, and how PWM is implemented on each platform.

What You Must Build

Sensor and Motor Control: Connect the HC-SR04, potentiometer, and DC motor through a suitable motor driver (e.g., L293D or L298N). Use the potentiometer to vary motor speed and display distance readings on the Serial Monitor. The motor must stop when an object is detected within 15 cm.
Implement on Both Boards: Build and test the system using both Arduino UNO R3 and ESP32. Identify the required pins and adapt the wiring and code for each board.
Check Voltage Compatibility: Determine the voltage requirements of each component. Use a voltage divider for the HC-SR04 Echo signal when connecting it to the ESP32, and ensure the potentiometer output stays within the board's permitted input voltage (3.3V max for ESP32).
Add Web-Based Control: Extend the ESP32 program with an asynchronous web server hosting a web page with a speed slider (0% to 100%) and a Stop button. The web interface controls motor speed, while the distance-based stop condition overrides the selected speed for safety.
Compare the Boards: Document the differences you observed in pin usage, analog readings, PWM implementation, voltage compatibility, and Wi-Fi setup. Explain what additional hardware would be required to provide similar web-based control using Arduino UNO R3.

Learn Before You Build

Web Server Tutorials for ESP32:

Task 9: The "Joint" Venture — Soldering

What You Are Required to Do

Soldering Station Tour: Go around the soldering station, inspect all the equipment, and identify what they are (soldering iron, brass sponge, flux, solder wick, helping hands, fume extractor).
Coordinator Briefing: Gather your domain batchmates and get a one-time safety and technique briefing from any of your domain coordinators.
Perfboard Circuit Assembly: Solder a simple circuit (LED Fader Circuit) on a perfboard. This must be completed individually.
- Interactive Reference: Tinkercad LED Fade Circuit
- Components Required:
  - 1x 100 µF electrolytic capacitor
  - 1x 1 kΩ resistor
  - 1x 10 kΩ resistor
  - 1x PN junction diode (1N4007 or similar)
  - 1x LED of your choice
  - 1x Pushbutton switch
  - Power supply (5V – 9V)
- Assembly Guidelines:
  - Wiring must be done using single-stranded wire.
  - Tin the wire ends and soldering iron tip prior to soldering to ensure strong, clean solder joints.
  - Verify circuit continuity before applying power.
  - Optional Credit: Probe the fading waveform using an oscilloscope to observe the capacitor discharge curve.
Theoretical Knowledge: Study the composition of solder wire (e.g., 60/40 leaded vs lead-free SAC305), types of flux (rosin, no-clean, water-soluble), and their roles in preventing oxidation.
Board Types: Learn the differences and applications of Breadboards, Perfboards / Zero-PCBs, Stripboards, and custom etched PCBs:
- Breadboard vs Perfboard vs PCB Tutorial
Hazards and Safety Measures: Review safety protocols regarding burns, toxic fumes, ventilation, and eye protection:
- Soldering Safety & Hazards

Task 10: VRPS & Oscilloscope Fundamentals

Coming soon.

Task 11: 555 Astable Multivibrator with 60% Duty Cycle

Objective

Design, build, and measure a 555 astable multivibrator. By the end you should be able to:

Choose timing resistors (R1, R2) and capacitor (C) for a target frequency and duty cycle.
Wire the NE555 timer IC as an astable oscillator on a breadboard.
Measure frequency, period, high time (t_high), low time (t_low), and duty cycle on a Digital Storage Oscilloscope (DSO).
Explain any discrepancies between theoretical designed values and actual measured values.

The Task

Design a 555 astable multivibrator whose output has a 60% duty cycle, build it on a breadboard, and observe the output waveform on a DSO.

Target Frequency: Pick 1 kHz so the waveform is clear and easy to analyze on the scope.

Steps

Read First: Go through the resources below until you can write the astable formulas for frequency and duty cycle in terms of R1, R2, and C, and explain what charges and discharges the capacitor in each half of the cycle.
Design on Paper: From the target frequency (1 kHz) and 60% duty cycle, derive the ratio of R1 to R2, choose a standard capacitor value C, and compute R1 and R2. Show all calculation steps.
Pick Real Parts: Round your calculated resistor values to standard component values available in the lab and recompute the exact theoretical frequency and duty cycle.
Build: Wire the NE555 on a breadboard with a 5V to 12V DC supply, your components R1, R2, C, and a 10 nF decoupling capacitor from Pin 5 (Control Voltage) to Ground. Check the datasheet pinout before powering on.
Probe: Connect the DSO probe to Pin 3 (Output) and Ground. Adjust the timebase so that 2 to 3 full waveform cycles are visible, and verify that probe attenuation (1x/10x) matches the scope channel settings.
Measure: Record the period, frequency, high time (t_high), and low time (t_low), and compute the measured duty cycle using the DSO's cursor or automatic measurement tools.
Compare: Tabulate designed vs. calculated-with-real-parts vs. measured values, and explain any differences (component tolerances, internal transistor drops, parasitic breadboard capacitance).

Deliverables

Design Sheet: Calculations showing the derived R1/R2 ratio, chosen capacitor value, calculated resistor values, and recalculated metrics for real parts.
Circuit Schematic: Labeled diagram with pin numbers and component values.
Breadboard Photo: High-resolution image of the wired circuit with DSO probe connected.
DSO Screenshot/Photo: Waveform showing at least 2 full periods with measured frequency and duty cycle parameters visible.
Comparison Table: Designed vs. calculated (real parts) vs. measured values for frequency and duty cycle.
Short Analysis (3–4 sentences): Why can a standard 2-resistor 555 astable circuit never achieve a duty cycle below 50%, and why is 60% achievable without adding an external bypass diode?

Resources

Task 12: Prime Number Detector with a K-Map

Objective

Learn Karnaugh maps from scratch by using one to design a real circuit. By the end you should be able to:

Fill a K-map from a truth table.
Circle valid groups (sizes 1, 2, 4, 8) and read an equation off them.
Explain why grouping works: two cells that touch differ in exactly one input, so that input drops out.
Build the result in logic gates and check it against every input combination.

The Task

Design and build a circuit with four inputs D C B A (a 4-bit number from 0 to 15, A is the least significant bit, D is the most significant bit). The output LED turns on when the number is prime. Treat 0 and 1 as not prime.

Do this in Tinkercad Circuits using four slide switches as inputs, one LED as output, and plain gates (AND, OR, NOT) in between. No decoder or other "smart" ICs.

Steps

Read first: Go through the K-map resources below until you can answer: what does it mean for two cells to "touch", and what are the legal group sizes?
Truth table: Write all 16 rows and mark the output for each.
Raw circuit: Write one AND term for every row where the output is 1, OR them together, and build it in Tinkercad. Count the gates. This is your baseline.
K-map: Fill in the blank map below from your truth table (cell numbers are the decimal value of D C B A).
Group: Circle groups of 1s. Use the largest groups you can, let groups overlap, and remember that the edges of the map wrap around (left touches right, top touches bottom).
Equation: Write one product term per group and OR them.
Simplified circuit: Build it in Tinkercad and count the gates.
Verify: Run through all 16 switch combinations and confirm both circuits match your truth table. Write down your predicted output for 3 inputs before testing them.

Blank K-map (rows D C, columns B A)

+----------+----+----+----+----+
| D C \ BA | 00 | 01 | 11 | 10 |
+----------+----+----+----+----+
|    00    |  0 |  1 |  3 |  2 |
|    01    |  4 |  5 |  7 |  6 |
|    11    | 12 | 13 | 15 | 14 |
|    10    |  8 |  9 | 11 | 10 |
+----------+----+----+----+----+

D C \ B A	00	01	11	10
00	0	1	3	2
01	4	5	7	6
11	12	13	15	14
10	8	9	11	10

Axis order is 00, 01, 11, 10 on purpose, so that neighbouring cells always differ in only one input. Use it as given.

Deliverables

Tinkercad share link (viewable by anyone with the link) containing both the raw and the simplified circuit, labeled.
One sheet (photo or scan is fine) with the truth table, the filled K-map with groups circled, and your final equation.
Prediction table: 3 inputs, your predicted output, and the actual output.
Gate counts: raw circuit vs. simplified circuit.
Short answer (3 to 4 sentences): why can two touching cells be merged into one term?

Resources

Karnaugh map playlist (YouTube) — The main K-map course. Cover the introduction and the 4-variable videos (grouping and wrap-around) before starting the task.
Karnaugh Maps with 4 Variables (YouTube) — A second explanation of the same material, useful if the playlist doesn’t click.
Logic Gates in Tinkercad (YouTube) — Placing gates, switches and LEDs and running the simulation.
Digital Electronics: Logic Gates Circuits on Tinkercad (YouTube) — More Tinkercad gate builds if you get stuck wiring.
Karnaugh Mapping worksheet (All About Circuits) — Practice questions to try before you start the task.
Tinkercad Circuits

Task 13: Active Participation

Technical Events: Participate in any technical event, hackathon, paper presentation, or competition (inter-college or intra-college) and submit the certificate of participation or achievement.
MOOC Completion: Enroll in and successfully complete an approved Massive Open Online Course (MOOC) on platforms like NPTEL, Coursera, edX, or Swayam.

Task 14: Datasheets Report Writing

Study the official technical datasheet of any one of the following components and write a comprehensive analysis report:

MQ-135 Gas Sensor IC:
- Operating principles and target gas sensitivities ($NH_3$, $NO_x$, alcohol, benzene, smoke, $CO_2$).
- Circuit schematic and load resistance ($R_L$) calibration curve.
- Freundlich Adsorption Isotherm / sensitivity characteristics graph.
L293D Dual H-Bridge Motor Driver:
- Internal block diagram and H-Bridge working mechanism.
- Logic truth table for forward, reverse, and braking states.
- Voltage ratings ($V_{CC1}$ vs $V_{CC2}$), peak current capabilities, internal clamp diode protection, and PWM speed control interfacing.

Task 15: SadServers — "Like LeetCode for Linux"

SadServers is an interactive platform to test your real-world Linux troubleshooting and debugging skills under realistic production scenarios.

Scenario: Complete the "Command Line Murders" investigation challenge. Troubleshoot the environment, parse through the clues using terminal tools, and make the sad servers happy!

Resources & Links

Domain Specific Tasks

Task 16: 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 removing unused cells or redundant outputs.

Resources & Installation

Task 17: 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

A Gentle Introduction to Machine Learning by StatQuest
- Watch here
How is Data Prepared for Machine Learning? by AltexSoft
- Watch here

Your Task

Write a resource article (300–500 words) summarizing the contents of the two videos and your understanding of it, and upload it to 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:

Load the dataset and explore the types of issues present.
Handle missing values by either dropping or imputing them.
Fix inconsistencies in text or categorical columns (e.g., case mismatches, typos).
Format column correctly (e.g., dates as datetime , numbers as int / float ).
Remove duplicate rows, if any.
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

https://youtu.be/_L39rN6gz7Y?feature=shared

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

Implement Naive Bayes from scratch using Python and NumPy.
Apply it to a text classification problem such as spam detection or sentiment analysis.
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

Preprocess the dataset and create train/test splits.
Train Random Forest, GBM and XGBoost models.
Evaluate using accuracy, precision, recall and F1 score.
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

Load and preprocess the images.
Flatten images into feature vectors.
Apply K-Means clustering.
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

https://www.youtube.com/watch?v=4EQ-oSD8HeU

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

Compare different activation functions using the feedforward network from Task 5.
Compare SGD and Adam.
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

Prepare sequential input data.
Train both RNN and LSTM models.
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

Fine-tune DistilBERT for a text-classification task such as sentiment analysis or fake-news detection.
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

Design a generator that maps random latent vectors to images.
Design a discriminator that distinguishes real from generated images.
Train the generator and discriminator adversarially.
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

Extract text from PDF documents.
Split text into suitable chunks.
Generate embeddings for the chunks.
Store embeddings in a vector database.
Retrieve relevant passages for a user query.
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.

AI-ML-001

Jump to:

Level 1

Generic Tasks

Task 1: Print It Yourself

What to do

Learning Resources

Suggested Focus

Task 2: Dynamic Portfolio & Admin Dashboard

Task Description

Requirements

1. Public Portfolio

2. Admin Dashboard

3. REST API Development

4. Data Management

5. Deployment and Documentation

Expected Outcomes

Suggested Technologies

Submission Requirements

Resources

Task 3: Working with GitHub

What to include in your task report:

Task 4: Hack the Hardware — Ubuntu Command Line & Systems Architecture

Objective

Core Intention

1. Hardware Foundation & Architecture: "The 'U' in CPU"

Topics & Concepts

Why You Need This

How to Study This Topic

2. Operating Systems, Kernels, and Linux Distributions

Topics & Concepts

Why You Need This

How to Study This Topic

3. The Linux Environment & Core System Concepts

Topics & Concepts

Why You Need This

How to Study This Topic

4. Practical Tips for Terminal Execution

5. Hands-on Problem Statement: System Audit & Log Processing Pipeline

6. What You Must Build

7. Foundational Command-Line Exercises

8. Resource Links

Computer Architecture & Nand2Tetris

Linux & Command Line Fundamentals

Task 5: Operation Blackout — Decode the Hidden Message

Learning Resources

NumPy

Matplotlib

YouTube Videos

Suggested Focus

Task 6: Build Your Own Brain — Linear Regression from Scratch

Learning Resources

Concepts and Implementation

YouTube Videos

Suggested Focus

Task 7: Resource Article Writing using Markdown

Task 8: Arduino vs ESP32 — Sensor-Based DC Motor Control

Problem Statement

Why You’ll Need This

What You Must Build

Learn Before You Build

Task 9: The "Joint" Venture — Soldering

What You Are Required to Do

Task 10: VRPS & Oscilloscope Fundamentals

Task 11: 555 Astable Multivibrator with 60% Duty Cycle

Objective

The Task

Steps

Deliverables

Resources

Task 12: Prime Number Detector with a K-Map

Objective

The Task

Steps

Blank K-map (rows D C, columns B A)

Deliverables

Resources

Task 13: Active Participation

Task 14: Datasheets Report Writing

Task 15: SadServers — "Like LeetCode for Linux"