AI Training in Nepal with Python: Machine Learning, Deep Learning & Generative AI

• What is Artificial Intelligence: definition and scope
• Narrow AI vs. General AI: conceptual distinction
• AI vs. Machine Learning vs. Deep Learning: how the fields relate
• Brief history and evolution of AI (rule-based systems to modern ML/DL)
• Types of Machine Learning: supervised, unsupervised, reinforcement (conceptual)
• Data-driven vs. rule-based systems
• The standard ML workflow: data -> features -> model -> evaluation -> deployment
• Real-world AI applications across industries
• Ethical considerations and limitations of AI systems

• Definition of supervised learning and the labeled-data requirement
• Components: features (X), labels/targets (y), hypothesis function, loss function
• Regression vs. classification as the two core supervised problem types
• Parametric vs. non-parametric models
• The training process: minimizing a loss function via optimization
• Model capacity, overfitting, and underfitting: conceptual explanation
• Train/validation/test splits and why they matter
• Common supervised algorithms recap (linear/logistic regression, SVM,trees, kNN)
• How a model generalizes to unseen data

Practical
Run a supervised learning (Regression and classification) workflow end-to-end (split, train, evaluate) and compare training vs. test performance across models of increasing complexity.

• Definition of unsupervised learning and why labels aren't required
• Core tasks: clustering, dimensionality reduction, density estimation
• Similarity and distance metrics (Euclidean, cosine, Manhattan)
• How clustering algorithms find structure without supervision
• K-Means: centroids, iterative assignment, and convergence
• Hierarchical clustering: conceptual overview
• Dimensionality reduction intuition (PCA recap)
• Association rule mining: conceptual introduction
• Evaluating unsupervised results without ground truth (silhouette score, inertia)
• When to use unsupervised vs. supervised approaches

Practical
Apply K-Means clustering to an unlabeled dataset, use the elbow method to choose K, and evaluate cluster quality using the silhouette score.

• Bagging vs. boosting: how ensemble methods improve performance
• Random Forest recap and key hyperparameters
• AdaBoost: weighted error and iterative reweighting
• Gradient Boosting Machines (GBM)
• XGBoost, LightGBM, and CatBoost overview
• Stacking and blending models
• Voting classifiers/regressors (hard vs. soft voting)
• Choosing an ensemble strategy for a given problem

Practical
Train and compare Random Forest, XGBoost, and LightGBM models on the same dataset.

• Cross-validation strategies (k-fold, stratified, time series split)
• Nested cross-validation for unbiased model selection
• Hyperparameter tuning: Grid Search, Random Search, Bayesian Optimization
• AutoML: conceptual overview
• Model interpretability with SHAP and LIME
• Feature importance and partial dependence plots
• Individual Conditional Expectation (ICE) plots
• Avoiding overfitting during tuning

Practical
Tune a chosen model using Bayesian optimization and explain its predictions using SHAP.

• Challenges of imbalanced datasets
• Oversampling (SMOTE) and undersampling techniques
• Borderline-SMOTE and ADASYN variants
• Cost-sensitive learning
• Anomaly detection framing for rare-event problems (Isolation Forest overview)
• Advanced evaluation: PR-AUC, F-beta score, Matthews correlation coefficient
• Threshold tuning
• Business-driven metric selection

Practical
Apply SMOTE and cost-sensitive learning to an imbalanced classification dataset and compare results.

• Trend, seasonality, and stationarity
• Time series feature engineering (lags, rolling windows)
• ARIMA and exponential smoothing: conceptual introduction
• Facebook Prophet for business forecasting
• Forecasting with ML models (gradient boosting for time series)
• Walk-forward validation and backtesting
• Multi-step forecasting: conceptual overview
• Forecast evaluation (MAE, RMSE, MAPE)

Practical
Build a time series forecasting model for a sales or demand dataset.

• Types of recommender systems: content-based, collaborative filtering, hybrid
• User-based vs. item-based collaborative filtering
• Matrix factorization (SVD): conceptual introduction
• Implicit vs. explicit feedback
• The cold-start problem and mitigation strategies
• Evaluation metrics: precision@k, recall@k, NDCG
• Popularity bias and diversity in recommendations
• Real-world considerations: scalability and freshness

Practical
Build a feedforward neural network with a high-level framework (Keras/PyTorch) and plot how loss decreases over training epochs, relating it back to the forward/backward pass theory.

• Biological inspiration and the artificial neuron (perceptron)
• Network components: input layer, hidden layers, output layer, weights, biases
• Activation functions: sigmoid, tanh, ReLU, and why non-linearity is essential
• Forward propagation: how input becomes prediction, layer by layer
• Loss functions: measuring prediction error (MSE, cross-entropy)
• Backpropagation: how error signals flow backward to update weights (conceptual)
• Gradient descent: how weights are updated to reduce loss
• The universal approximation theorem: conceptual understanding
• Epochs, batches, and the training loop
• Why depth (multiple layers) lets networks learn complex patterns

Practical
Build a feedforward neural network with a high-level framework (Keras/PyTorch) and plot how loss decreases over training epochs, relating it to the forward/backward pass theory.

• Advanced optimizers: SGD with momentum, RMSProp, Adam
• Learning rate schedules and warm-up
• Mixed precision training: conceptual overview
• Batch normalization
• Dropout and weight decay
• Label smoothing
• Early stopping and checkpointing
• Diagnosing training issues (vanishing/exploding gradients)

Practical
Train the same network with different optimizers and learning rate schedules and compare convergence.

• Autoencoder architecture and use cases
• Denoising autoencoders
• Variational Autoencoders (VAE): conceptual introduction
• Learned embeddings and representation learning
• Contrastive learning: conceptual introduction (SimCLR)
• Self-supervised learning: conceptual overview
• Anomaly detection with autoencoders

Practical
Build an autoencoder for anomaly detection or dimensionality reduction on a chosen dataset.

• Recurrent Neural Networks (RNN): architecture and limitations
• Long Short-Term Memory (LSTM) and GRU networks
• Bidirectional RNNs
• Sequence padding, masking, and batching
• Teacher forcing during training
• Applications: time series and text sequence modeling
• Bridging into Transformer-based approaches

Practical
Build an LSTM model for a sequence prediction task (e.g., text or time series).

• Why model compression matters for production
• Pruning: removing unnecessary weights or neurons (conceptual overview)
• Quantization: reducing numeric precision for smaller, faster models (conceptual overview)
• Knowledge distillation: teacher-student framework
• Exporting models with ONNX: conceptual overview
• Benchmarking model size, latency, and accuracy trade-offs
• Hardware considerations: CPU vs. GPU vs. edge devices
• Choosing a compression strategy for a deployment target

• Reading, displaying, and manipulating images with OpenCV
• Color spaces and channels
• Image filtering, edge detection, and thresholding
• Contours and basic shape detection
• Classical feature descriptors: SIFT and ORB (conceptual overview)
• Histogram of Oriented Gradients (HOG): conceptual overview
• Image augmentation techniques

Practical
Build an OpenCV pipeline to preprocess and augment a set of images.

• Review of CNN building blocks (convolution, pooling, feature maps)
• Popular architectures: VGG, ResNet, Inception, EfficientNet overview
• Residual connections: how ResNet addressed vanishing gradients
• Depthwise separable convolutions and lightweight architectures (MobileNet overview)
• Batch normalization within CNNs
• Architecture trade-offs: accuracy vs. latency vs. model size
• Visualizing CNN feature maps and filters

Practical
Fine-tune a pretrained CNN (e.g., ResNet) on a custom image classification dataset.

• Feature extraction vs. fine-tuning
• Freezing and progressively unfreezing layers
• Choosing a pretrained backbone (ImageNet-pretrained models)
• Handling small datasets with transfer learning
• Data augmentation strategies for fine-tuning (MixUp, CutMix: conceptual overview)
• Avoiding catastrophic forgetting
• Evaluating transfer learning effectiveness

• Object detection formulation: bounding boxes, anchors, IoU
• Two-stage detectors: Faster R-CNN (conceptual overview)
• One-stage detectors: the YOLO family (conceptual overview)
• Non-maximum suppression (NMS)
• Evaluation: mAP and precision-recall curves for detection
• Training a custom object detector
• Real-time detection considerations

• Semantic vs. instance segmentation
• U-Net architecture and encoder-decoder design
• Segmentation evaluation: IoU and Dice coefficient
• Pose estimation: conceptual overview (keypoint detection)
• Video understanding: conceptual overview (tracking, action recognition)
• Choosing the right vision task formulation for a business problem

Practical
Run a pretrained YOLO model on a set of images and evaluate its detections.

• Face detection and recognition: conceptual overview
• Optical Character Recognition (OCR)
• Vision Transformers (ViT): conceptual overview as an alternative to CNNs
• Building a computer vision inference pipeline
• Model optimization for inference: conceptual overview
• Deploying a CV model behind an API

Practical
Build an end-to-end CV application (e.g., face detection or OCR) with an inference script.

• Tokenization strategies: word, character, and subword tokenization (conceptual overview)
• Bag-of-Words and TF-IDF representations
• Word embeddings: Word2Vec (CBOW and Skip-gram): conceptual overview
• GloVe embeddings: conceptual overview
• Embedding evaluation: analogy and similarity tasks
• Handling out-of-vocabulary words
• Choosing a text representation for a given task

• Self-attention and multi-head attention
• Positional encoding
• Encoder-only vs. decoder-only vs. encoder-decoder architectures
• Why Transformers replaced RNNs for many NLP tasks
• Computational considerations of Transformers

Practical
Trace through a self-attention calculation on a small worked example.

• BERT and encoder-only models
• GPT and decoder-only models
• Fine-tuning vs. feature extraction
• Parameter-efficient fine-tuning: adapters and LoRA (conceptual overview)
• Fine-tuning a pretrained model for text classification or NER
• Model selection based on task type

Practical
Fine-tune a pretrained BERT model on a text classification or NER task.

• Named Entity Recognition (NER): the BIO tagging scheme
• Part-of-speech (POS) tagging: conceptual overview
• Relation extraction: conceptual overview
• Using Transformer-based models for token classification
• Building a custom entity extraction pipeline
• Evaluation: precision, recall, F1 at the entity level
• Applications: document processing, knowledge graph construction

• Sequence-to-sequence architecture
• Text summarization approaches
• Machine translation: conceptual overview
• Decoding strategies: greedy search, beam search, sampling
• Evaluation metrics (ROUGE, BLEU): conceptual introduction
• Handling long documents: chunking strategies

Practical
Build a text summarization pipeline using a pretrained sequence-to-sequence model.

• Combining preprocessing, model inference, and post-processing
• Batch vs. real-time NLP inference
• Cross-lingual and multilingual models: conceptual overview
• Monitoring NLP model performance over time
• Handling noisy or informal text (social media, chat)
• Packaging an NLP pipeline for reuse

Practical
Build a complete NLP pipeline (e.g., classification + NER) that takes raw text and returns structured results.

• Generator and discriminator architecture
• Adversarial training process
• Common GAN challenges (mode collapse, training instability)
• Evaluation: Inception Score and FID (conceptual overview)
• Applications of GANs (image generation, data augmentation)
• Popular GAN variants: conceptual overview (DCGAN, StyleGAN)

Practical
Train a simple GAN on a small image dataset and review the generated samples.

• Variational Autoencoders (VAE) revisited for generation
• Diffusion models: conceptual introduction
• Classifier-free guidance: conceptual overview
• Comparing GANs, VAEs, and diffusion models
• Applications in image and audio generation
• Ethical considerations in generative media

Practical
Generate samples using a pretrained diffusion or VAE model and compare outputs qualitatively.

• Scaling laws: how model size, data, and compute affect performance (conceptual overview)
• Evolution of GPT-style architectures: conceptual overview
• Open-weight LLMs: LLaMA, Mistral (conceptual overview)
• Pretraining, supervised fine-tuning, and alignment: conceptual overview of the pipeline
• Context length and its practical implications
• Evaluating LLMs: benchmarks and known limitations

• Zero-shot, one-shot, and few-shot prompting
• Chain-of-thought prompting for reasoning tasks
• Role-based and system prompts
• Prompt chaining for multi-step tasks
• Structured output generation (JSON mode): conceptual overview
• Prompt injection risks and basic mitigation
• Evaluating and iterating on prompts systematically

• When to fine-tune vs. prompt an LLM
• Full fine-tuning: costs and risks
• Parameter-efficient fine-tuning (LoRA): conceptual introduction
• Instruction tuning for following natural language instructions
• Preparing an instruction-tuning dataset
• Evaluating fine-tuned models for quality
• Choosing the right adaptation strategy for a use case

Practical
Compare a prompted pretrained LLM response with a fine-tuned (or simulated fine-tuned) response for the same task.

• Embeddings and vector databases (FAISS, ChromaDB)
• Retrieval-Augmented Generation (RAG) architecture
• Building RAG pipelines with LangChain
• AI agents: reasoning, planning, and tool use (conceptual overview)
• Evaluating RAG output quality
• Responsible AI: hallucinations, bias, and data privacy

Practical
Build a RAG-based Q&A application over a custom document set.

• Streamlit app architecture and execution model (script rerun behavior)
• Session state: managing application state across reruns
• Caching strategies: st.cache_data vs. st.cache_resource
• Multi-page applications and navigation
• Custom forms, input validation, and file uploads
• Theming and layout customization

• Deploying ML, CV, and NLP models in Streamlit
• Handling model loading efficiently with caching
• Streaming LLM responses in real time
• Building chat interfaces (st.chat_message, st.chat_input)
• Displaying images, predictions, and visualizations
• Handling long-running inference with progress feedback

Practical
Build a multi-page Streamlit app that showcases an ML, CV, or NLP model.

• FastAPI application structure and routing
• Path, query, and body parameters
• Request and response models with Pydantic
• Async endpoints and when they matter for I/O-bound work
• Auto-generated documentation with Swagger UI

• Dependency injection for shared logic (auth, shared resources)
• Serving ML/DL models through an API
• Error handling and custom exception responses
• Testing APIs with pytest and FastAPI's TestClient
• Logging and basic monitoring for APIs

Practical
Build a FastAPI service that serves predictions from a trained model.

• Connecting a Streamlit front-end to a FastAPI backend
• Designing a clean API contract between front-end and backend
• Environment and configuration management
• Logging and monitoring across a full-stack application
• Deployment options: conceptual overview
• Building a deployment checklist for AI applications

Practical
Connect a Streamlit front-end to a FastAPI backend serving a trained model.