• Strings, Lists, Tuples, Sets, Dictionaries
• Indexing, Slicing, CRUD Operations
• Comprehensions & Nested Comprehensions
• Advanced Data Structure Modules: collections, itertools

• Defining & Calling Functions
• Arguments (positional, keyword, default, *args,
  **kwargs)
• Return Statements & Scope (Local, Global, Nonlocal)
• Anonymous Functions (Lambda)
• Higher-Order Functions (map, filter, reduce)
• Decorators & Closures

• Errors vs. Exceptions
• Try-Except-Else-Finally
• Raising Exceptions
• Custom Exception Classes
• Logging & Debugging

• Classes, Objects, Constructors, Destructors
• Instance, Class, and Static Variables
• Encapsulation, Abstraction, Inheritance, Polymorphism
• Method Overloading & Overriding
• Magic Methods (__init__, __str__, etc.)
• Real-world Project: Inventory or Student Management System

• Reading/Writing Files (Text, Binary, CSV)
• File Pointers, Modes, and Context Managers (with)
• Working with JSON Files
• Exception Handling in File Operations

• Creating and Importing Custom Modules
• Standard Libraries (os, sys, math, datetime, random, shutil)
• Installing and Managing Packages (pip, venv)
• Understanding Namespaces and __init__.py

• Iterators and Generators
• Regular Expressions (Pattern Matching & Validation)
• Command-Line Arguments (sys, argparse)
• Working with the OS, Subprocess, and Environment Variables

• The threading and multiprocessing modules
• Thread Lifecycle and Synchronization
• Client-Server Communication (Socket Programming)
• Mini Project: Chat Application

• Tkinter Widgets, Layouts, and Events
• PyQt5 & Qt Designer Integration
• Signals, Slots, and Database Handling
• Project: Desktop App (Expense Tracker / Student Database
  Manager)

• SQLite3 & MySQL with Python
• CRUD Operations and Transactions
• Using SQLAlchemy ORM
• Connecting Databases with Flask and Django
• Database Design and Relationships

Frontend Development

• HTML5, CSS3, and Bootstrap
• JavaScript (ES6+), DOM Manipulation, Events
• AJAX & Fetch API
• Optional: React.js or Vue.js Basics for Modern UI

• Flask Installation & Setup
• Routing, Templates, and Static Files
• Form Handling & Validation
• REST API Development with Flask
• Connecting Flask with Databases (SQLite/MySQL)
• JWT Authentication
• Deploying Flask Apps (Render, AWS Elastic Beanstalk)

Why Django?
Django is a high-level Python web framework that promotes rapid
development and clean, pragmatic design. It follows the MVT (Model–
View–Template) architecture and is ideal for building scalable, secure,
and maintainable web applications.

• Introduction to MVT Architecture
• Installing Django and Setting Up Virtual Environments
• Creating a Project and an App
• Understanding Django Folder Structure

• Models:
   Defining Models and Fields
   Database Migrations (makemigrations, migrate)
   QuerySets, Filters, Lookups
   Model Relationships (One-to-One, One-to-Many, Many-to-Many)
• Views:
   Function-based Views (FBVs)
   Class-based Views (CBVs)
   HTTP Request and Response Cycle
• Templates:
   HTML Templates with Django Templating Engine
   Template Inheritance and Filters
   Static and Media Files Handling

• Django Forms and ModelForms
• Validation and CSRF Protection
• File Uploads
• Handling POST Requests

• User Authentication (Signup, Login, Logout)
• Sessions & Cookies
• Custom User Models
• Role-based Access Control (Admin, Users, Staff)

• Customizing the Django Admin Interface
• Adding and Editing Data from Admin Panel
• Admin Filters and Search

• Performing CRUD Operations through ORM
• Query Optimization
• Using Related Managers and Reverse Relations

• Creating REST APIs
• Serializers and ViewSets
• Authentication & Permissions
• Token-Based and JWT Authentication
• API Testing with Postman

• Environment Configuration and .env Setup
• Debug vs. Production Mode
• Deploying Django Apps on AWS / Render / Heroku
• Integrating Django with Nginx and Gunicorn
• Dockerizing a Django Application

• Full Stack Project (e.g., E-Commerce Site, Job Portal, Student
  Management System)
• End-to-End: Frontend → Backend → Database → API → Deployment

Objective: Build foundational understanding of how AI, ML, and DS
connect to each other.

• What is Artificial Intelligence?
• AI vs. Machine Learning vs. Deep Learning vs. Data Science
  Branches of AI:
• Symbolic AI (Rule-based systems)
• Statistical AI (Machine Learning)
• Cognitive AI (Deep Learning, LLMs)
• AI & DS Lifecycle: Problem → Data → Model → Evaluate → Deploy →
  Feedback
• Overview of Tools: Python, Jupyter, NumPy, Pandas, Scikit-learn,
  TensorFlow, Keras, PyTorch
• Use Cases: Healthcare, Finance, Automation, Chatbots, Vision,
  Robotics

End-to-End “Hello AI” Example — Simple Prediction
Model

Objective: Learn how to handle, analyze, and visualize data effectively

• Data Types (Structured, Semi-structured, Unstructured)
• Loading and cleaning datasets (CSV, JSON, SQL, APIs)
• Handling missing values, duplicates, outliers
• Encoding categorical data
• Feature scaling (Normalization, Standardization)
• Feature engineering and transformation

• Descriptive Statistics: Mean, Median, Variance, Correlation
• Data Visualization:
  Matplotlib for static visualizations
  Seaborn for statistical plots
  Plotly for interactive dashboards
• Building insights from patterns and relationships

Data Cleaning and EDA Report on Real Dataset

Objective: Understand the math that drives ML and DL algorithms.

• Linear Algebra: Vectors, Matrices, Eigenvalues, Operations
• Probability: Bayes’ Theorem, Conditional Probability, Distributions
• Statistics: Sampling, Hypothesis Testing, p-values, Confidence
  Intervals
• Calculus: Derivatives, Gradients, Optimization, Gradient Descent
• Optimization Concepts: Cost Function, Learning Rate, Convergence

Linear Regression from scratch using Gradient
Descent

Objective: Learn classical ML models using the Scikit-learn library.

• Introduction to Scikit-learn Ecosystem
• Data Preprocessing Pipelines
• Supervised Learning Algorithms:
• Regression: Linear, Ridge, Lasso, Polynomial
• Classification: Logistic Regression, Decision Tree, Random
• Forest, SVM, k-NN, Naïve Bayes
• Unsupervised Learning Algorithms:
• Clustering: K-Means, Hierarchical, DBSCAN
• Dimensionality Reduction: PCA, LDA
• Model Evaluation Metrics: Accuracy, Precision, Recall, F1, ROC-AUC
• Ensemble Learning: Bagging, Boosting, XGBoost, LightGBM
• Model Saving and Deployment (pickle, joblib)

• Credit Risk Prediction using Scikit-learn

Objective: Build and train deep neural networks for image and text data.

• Building Sequential & Functional Models
• Activation Functions and Optimizers
• Loss Functions and Metrics
• Dropout & Regularization
• Transfer Learning using Pre-trained Models (VGG, ResNet)
• Callbacks and Early Stopping

• Tensors and Graph Execution
• TensorBoard Visualization
• Custom Training with Gradient Tape
• Dataset Pipelines and TFRecords
• TensorFlow Serving for Model Deployment

Image Classifier using Keras + TensorFlow

Objective: Learn to implement neural networks from scratch with
PyTorch.

• Introduction to PyTorch Tensors & Autograd
• Creating Custom Models using nn.Module
• Datasets and DataLoaders
• Training Loops, Loss Functions, and Optimizers
• GPU Acceleration (CUDA)
• Model Checkpointing and Loading
• PyTorch Lightning (High-level API)
• Transfer Learning & Fine-tuning
• TorchServe for Deployment

Digit Recognition using PyTorch (MNIST Dataset)

Objective: Train AI systems to understand and process human language.

• Text Cleaning: Tokenization, Stopwords, Lemmatization
• Bag-of-Words and TF-IDF Representation
• Word Embeddings: Word2Vec, GloVe, FastText
• Named Entity Recognition (NER)
• Sequence Modeling: RNN, LSTM, GRU
• Sentiment Analysis and Text Classification
• Topic Modeling: LDA and Transformers for NLP

Sentiment Analysis on Social Media Data

Objective: Understand, fine-tune, and deploy modern transformer-based
LLMs.

LLM Foundations

• How LLMs Work: Tokens, Embeddings, Attention Mechanism
• Transformer Architecture: Encoder-Decoder, Multi-Head Attention,
  Feedforward Layers
• Pretraining Objectives: Masked LM (BERT), Causal LM (GPT)
• Positional Encoding & Context Windows

• BERT, GPT, T5, LLaMA, Falcon, Mistral, Gemma, Claude, etc.
• Tokenization: BPE, WordPiece, SentencePiece
• Fine-tuning LLMs: Full vs. Parameter-efficient (LoRA, PEFT,
  Adapters)
• Prompt Engineering Techniques (Zero-shot, Few-shot, Chain-ofthought)
• Inference & Decoding: Greedy, Beam Search, Top-k, Top-p Sampling
• Evaluation Metrics: Perplexity, BLEU, ROUGE, BERTScore

• Instruction-tuning for domain-specific tasks
• Retrieval-Augmented Generation (RAG)
• Building AI Assistants using LangChain
• Vector Databases (FAISS, Pinecone) for Memory
• Multimodal LLMs (text + image/audio/video inputs)

Domain-specific ChatGPT-style Assistant using
LangChain + LLaMA

Objective: Explore models that can generate new data — text, images,
or audio.

• Evolution: From GANs to Diffusion Models to LLMs
• Generative Models:
  GAN (Generator + Discriminator)
  Variational Autoencoders (VAE)
  Diffusion Models (Stable Diffusion Overview)
• Text-to-Image Systems (DALL·E, Midjourney, Stable Diffusion)
• Prompt Engineering for Generative Systems
• Responsible & Ethical AI Practices

Text-to-Image Generator using Diffusers

Objective: Understand the architecture that revolutionized modern AI.

• The Transformer Revolution: Why RNNs failed
• Attention Mechanism: Query–Key–Value Concept
• Self-Attention and Multi-Head Attention
• Encoder–Decoder Architecture
• Positional Encoding & Token Embeddings
• Scaling Transformers for Long Context
• Transformers in Vision (ViT), Text (BERT, GPT), and Multimodal AI

Build a Transformer-based Text Classifier

Objective: Build pipelines to feed AI systems with reliable data.

• Data Warehousing & ETL Concepts
• SQL and NoSQL (MongoDB, Redis)
• Stream Processing with Kafka
• Workflow Automation (Airflow, Prefect)
• Big Data Tools Overview (Spark, Hadoop)
• Integration with ML Pipelines

Real-time Data Pipeline for Prediction Model

Objective: Learn to build autonomous, reasoning AI systems that can
plan, act, and learn.

• What are AI Agents? Difference from Chatbots
• Components of an Agent:
  Perception (Input Understanding)
  Reasoning (Goal-Oriented Thought Process)
  Action (Tool or API Execution)
  Memory (Short-term & Long-term Context)
• Frameworks for Building Agents:
  LangChain Agents
  OpenAI Function Calling / Tool Use
  AutoGPT & BabyAGI Concepts
  Multi-Agent Collaboration
• Agents with External Tools:
  Web Search, APIs, Databases, File Systems
• Memory Systems with Vector Stores
  Safety, Alignment, and Guardrails in Autonomous AI
• Mini Project
  

  AI Research Assistant Agent using LangChain +
  OpenAI Tools

Objective: Bring it all together into a real-world deployment-ready
project. Options:

• Data Science Dashboard (EDA → ML → Visualization)
• Deep Learning Image Classifier (TensorFlow or PyTorch)
• NLP Chatbot using Transformer LLM (BERT/GPT-based)
• RAG-based GenAI Assistant using LangChain + VectorDB
• End-to-End MLOps System with Docker + AWS
• Predictive Analytics Pipeline for Business Insight