Artificial Intelligence (AI) Course: live online in India

A live, mentor-led artificial intelligence course that starts from your first line of code and goes all the way to building, fine-tuning and deploying large language models.

  • 37 weeksof AI inside Program Zero
  • 9 PM ISTlive, Mon–Fri · recorded
  • ₹89,999or ₹7,500/month EMI
  • 9 January 2027next batch starts

Artificial Intelligence (AI) Course in Program Zero is taught live by working engineers as part of an 18-month, mentor-led programme. Most "AI courses" teach you to use tools. Program Zero teaches you to build them. After a foundation in programming, data structures and databases, you learn classical machine learning, deep learning with PyTorch, natural language processing and transformers, then build a GPT-style language model from scratch, fine-tune open models with LoRA, ground them with retrieval (RAG) and connect them to tools as agents.

The AI part of the programme runs from week 42 to week 78, after the engineering foundations, because AI work is engineering work: data pipelines, APIs, evaluation and deployment. You finish with a research-grade capstone and a portfolio you can show and explain.

Who it's for

  • Students and graduates from any stream who want to build AI, not just use it
  • Working professionals moving into AI or adding AI to their current role
  • Developers who know some code and want depth in ML, deep learning and LLMs

What you'll be able to do

  • Train and evaluate machine learning models on real data
  • Build neural networks in PyTorch: CNNs, RNNs, transformers
  • Build and train a small GPT-style LLM from scratch
  • Fine-tune open models with LoRA/QLoRA and build RAG apps and agents
  • Deploy models with Docker, CI/CD and monitoring

Syllabus

What the AI course covers, week by week

Taken directly from the Program Zero curriculum. Weeks are counted from the batch start on 9 January 2027.

Phase 6 · weeks 42-47 · 6 weeks

Data Science & Classical Machine Learning

  • NumPy, Pandas, Matplotlib/Seaborn
  • Data cleaning, feature engineering, EDA
  • Supervised learning: linear/logistic regression, decision trees, random forests, SVM, KNN
  • Unsupervised learning: k-means, hierarchical clustering, PCA, DBSCAN
  • Ensembles: bagging, boosting (XGBoost, LightGBM)
  • Model evaluation: cross-validation, confusion matrix, precision/recall/F1, ROC-AUC
  • Hyperparameter tuning: grid/random/Bayesian search
  • scikit-learn pipelines; handling imbalanced data

Project: End-to-end Kaggle-style ML project with simple deployment

Phase 7 · weeks 48-53 · 6 weeks

Deep Learning & Neural Networks

  • ANN: forward pass, backprop from scratch (NumPy)
  • Activation functions, loss functions, optimizers
  • Regularization: dropout, batch norm, L1/L2, early stopping
  • PyTorch (primary) + TensorFlow/Keras basics
  • CNNs: architectures LeNet → ResNet
  • RNN, LSTM, GRU — sequence modeling
  • Autoencoders, GANs (conceptual + hands-on basics)
  • Transfer learning; training on GPUs, mixed precision basics

Project: CNN image classifier + LSTM text generator, trained from scratch

Phase 8 · weeks 54-61 · 8 weeks

NLP, Transformers & Building LLMs (Core)

  • NLP fundamentals: tokenization, TF-IDF, embeddings (Word2Vec, GloVe)
  • Attention mechanism derivation; seq2seq
  • Transformer architecture from scratch: self-attention, multi-head attention, positional encoding, encoder-decoder, layer norm, residuals
  • Tokenizers in depth: BPE, WordPiece, SentencePiece — build a custom tokenizer
  • Build a GPT-style decoder-only LLM from scratch in PyTorch: embeddings → transformer blocks → output head, causal masking, training loop, cross-entropy loss, perplexity
  • Train a small LLM end-to-end on a custom dataset
  • BERT / encoder-only models (masked language modeling)
  • Fine-tuning with HuggingFace Transformers: classification, NER, summarization, Q&A
  • LoRA / QLoRA parameter-efficient fine-tuning
  • RAG: embeddings, vector DBs (FAISS/Chroma/Pinecone), building a RAG pipeline
  • Prompt engineering, chain-of-thought, AI agents/tool use (LangChain/LlamaIndex)
  • Evaluating LLMs: perplexity, BLEU/ROUGE, benchmarks

Project: Small GPT trained from scratch on a custom corpus; LoRA fine-tune of an open model (Llama/Mistral/Qwen family)

Phase 9 · weeks 62-69 · 8 weeks

Advanced LLM Engineering (Research Level)

  • Web-scale data collection (Common Crawl-style), deduplication (MinHash + LSH), quality filtering (heuristic + classifier-based), toxicity/PII filtering
  • Data mixing ratios, curriculum ordering; tokenizer training at scale
  • Build a full pipeline: raw data → clean → dedupe → filter → tokenize → shard
  • DDP internals, gradient sync, communication overhead
  • FSDP and DeepSpeed ZeRO (stages 1/2/3) — sharding optimizer states/gradients/parameters
  • Tensor parallelism & pipeline parallelism (Megatron-LM style); 3D parallelism
  • Gradient checkpointing, mixed precision (fp16/bf16) at scale
  • NCCL basics, multi-node orchestration (Slurm/Kubernetes training jobs), checkpointing & fault tolerance for long runs
  • Kaplan et al. and Chinchilla scaling laws
  • Compute-optimal trade-offs: model size vs. data size vs. compute budget
  • Estimating cost/time before committing a training run; designing an ablation plan
  • RoPE, ALiBi (why they replaced sinusoidal encoding)
  • Grouped-Query Attention (GQA), Multi-Query Attention (MQA)
  • Sliding-window/sparse attention, long-context techniques
  • Mixture-of-Experts (MoE): routing, load balancing, sparse activation
  • Reading/implementing components from Llama, Mistral, DeepSeek, Qwen papers
  • KV-cache management; quantization: GPTQ, AWQ, GGUF/llama.cpp, int8/int4
  • Speculative decoding, continuous batching
  • Production serving: vLLM, TensorRT-LLM, TGI
  • Latency/throughput/cost-per-token trade-offs
  • SFT pipeline design and instruction-data curation
  • Reward model training: preference data, Bradley-Terry loss
  • PPO implementation for RLHF (hands-on)
  • DPO and modern alternatives — implementation
  • Red-teaming methodology, safety evaluation, constitutional AI concepts, guardrail design
  • Reading and reproducing a research paper end-to-end
  • Designing and running ablation studies; rigorous experiment comparison
  • Writing a technical report on a training run/ablation
  • Keeping up with the field critically: key labs, papers, benchmarks

Project: Execute a full, faithful (small-scale) pretraining run — build the data pipeline, choose an architecture variant, run compute-optimal sizing analysis, train with a real distributed setup (2–8 GPUs), run an SFT + DPO alignment pass, then serve the model with an optimized inference stack. Written up as a technical report exactly as a research team would produce.

Phase 10 · weeks 70-73 · 4 weeks

Cloud, MLOps & Deployment

  • Cloud fundamentals: AWS/GCP/Azure — compute, storage, IAM
  • Docker: containerization, Dockerfiles, docker-compose
  • Kubernetes basics: pods, deployments, services, scaling
  • CI/CD: GitHub Actions, automated testing/deployment
  • Model serving: FastAPI/Flask APIs, TorchServe, Triton
  • MLOps: experiment tracking (MLflow/W&B), model/data versioning (DVC)
  • Serverless functions, API gateways
  • Monitoring/logging (Prometheus/Grafana basics)
  • Cost optimization for AI workloads (GPU cost awareness, quantization for cost/inference)

Project: Deploy the Phase 8/9 LLM work + RAG chatbot with a CI/CD pipeline; containerize the full-stack app

Phase 11 · weeks 74-75 · 2 weeks

Security — App, Network, Data & AI

  • OWASP Top 10 and prevention (SQLi, XSS, CSRF, broken auth, etc.)
  • HTTPS/TLS, encryption basics, hashing vs encryption
  • Auth best practices, secure password storage, MFA
  • API security: rate limiting, API keys, CORS, input validation
  • Network security basics: firewalls, VPNs, DDoS awareness
  • Encryption at rest/in transit, secrets management
  • Privacy regulation awareness (GDPR, data minimization)
  • Secure database practices
  • Prompt injection attacks & defenses
  • Adversarial examples, model theft/extraction awareness
  • Data poisoning, bias & fairness in training data
  • Responsible AI: hallucination mitigation, safety layers, guardrails

Project: Security audit + hardening of their capstone systems (pen-test style checklist)

Phase 12 · weeks 76-78 · 3 weeks

Final Combined Capstone & Demo Day

  • AI Capstone (Research-Grade): The Phase 9 pretraining pipeline (data → distributed training → alignment → optimized serving), fully polished, documented, and demoed — plus a fine-tuned/RAG-enabled application layer on top with a simple UI.
  • Full-Stack Capstone: The real-time social/messaging app (feed + chat + notifications + media + auth) from Phase 4, deployed to cloud, containerized, and security-hardened — mobile version included.
  • A GitHub portfolio (clean, documented, reproducible)
  • A written system design doc including a "How this scales to production" section — describing exactly what changes (more GPUs, sharded DBs, CDN, load balancers, a larger team) to take the same design to real-world scale, proving the student already knows how and only needs the resources
  • A live demo day presentation

Project: Final combined capstone

How you're taught
Live classesMonday to Friday, 9:00–10:30 PM IST, every class recorded
PracticeSaturday assignments and live projects, reviewed by mentors
HelpSunday 11:00 AM–1:00 PM doubt-clearing session
AssessmentA cumulative test every 3 months (retest a week later); certificates on merit
Fee₹89,999 one-time, or ₹7,500 × 15 months by EMI (₹1,12,500 total), inclusive of all taxes, covering every subject

Book your seat

How to join in 4 steps

  1. 1 Create your account Sign up with your name, email and Indian mobile number.
  2. 2 Verify your email Enter the 6-digit code we email you.
  3. 3 Pay the membership fee Pay ₹89,999 one-time, or ₹7,500 to start an EMI plan (₹7,500 × 15 months), securely with Razorpay (UPI, cards, net banking).
  4. 4 Join the first live class Classes start on 9 January 2027, Monday to Friday, 9:00–10:30 PM IST.

Book your seat

Questions

Artificial Intelligence (AI) Course: questions

Is this AI course suitable for complete beginners?

Yes. Program Zero starts from how a computer works and your first Python program. The AI phases come after programming, DSA and databases, so beginners arrive ready.

What does the AI course cover?

Machine learning (regression, trees, ensembles, evaluation), deep learning (backprop from scratch, PyTorch, CNNs, RNNs, GANs), NLP and transformers, building a GPT-style LLM, LoRA/QLoRA fine-tuning, RAG, AI agents, advanced LLM engineering, MLOps and AI security.

How long is the AI course and how is it taught?

It is part of the 18-month Program Zero, taught live Monday to Friday, 9:00–10:30 PM IST, with recordings, Saturday projects and a Sunday doubt session.

How much does the AI course cost?

Artificial Intelligence (AI) Course is part of Program Zero: ₹89,999 one-time for all 18 months, or ₹7,500 × 15 months by EMI (₹1,12,500 in total), inclusive of all taxes. Every other subject is included.

When does the next AI batch start?

The next batch starts on 9 January 2027. Live classes run Monday to Friday, 9:00–10:30 PM IST.

Learn AI live, from 9 January 2027.

₹89,999 one-time or ₹7,500/month · seats are limited.

Book Your Seat

Install Program Zero on iPhone or iPad

  1. Open zero.careersninza.com in Safari.
  2. Tap the Share button .
  3. Scroll down and tap Add to Home Screen, then Add.

The app opens full-screen from your home screen, just like an App Store app.

Install Program Zero on Android

  1. Open zero.careersninza.com in Chrome.
  2. Tap the ⋮ menu at the top right.
  3. Tap Install app (or Add to Home screen), then Install.

You're already using the app

Program Zero is installed on this device.