AI & Machine Learning

• AI vs machine learning vs deep learning vs Generative AI: how they relate, with real product examples
• Types of learning: supervised, unsupervised, self-supervised and reinforcement learning (overview)
• Environment setup: Python, conda and virtual environments, Jupyter Notebook / JupyterLab, VS Code, Google Colab and Kaggle Notebooks
• Python refresher for ML: data types, functions, comprehensions, modules and working with files
• NumPy: arrays, vectorized operations, broadcasting, indexing, slicing and random number generation
• pandas: Series and DataFrames, loading CSV/Excel data, selecting, filtering, sorting, groupby, merge/join and dates
• Visualization with Matplotlib and Seaborn: histograms, box plots, scatter and pair plots, heatmaps; interactive charts with Plotly (intro)
• Exploratory data analysis (EDA) workflow on a real public dataset

Outcome: You can set up a reproducible ML workspace and run a complete exploratory analysis on an unfamiliar dataset.

• Linear algebra: vectors, matrices, dot products, matrix multiplication, transpose, inverse and norms
• Geometric intuition: distance, cosine similarity and projections, and why they matter for k-NN and embeddings
• Eigenvalues and eigenvectors (intuition), laying the groundwork for PCA
• Probability: random variables, conditional probability, independence and Bayes' theorem
• Distributions: normal, binomial, Poisson and uniform; the central limit theorem (intuition)
• Statistics with SciPy: mean, median, variance, standard deviation, correlation vs causation, sampling, confidence intervals and hypothesis testing basics
• Calculus for ML: derivatives, partial derivatives, the chain rule and gradients
• Gradient descent from scratch in NumPy: learning rate, convergence and loss surfaces

Outcome: You can explain the mathematics behind core models and implement gradient descent from first principles.

• Framing an ML problem: target variable, features, baseline model and success metric
• The end-to-end ML project lifecycle, from business question to monitored model
• Data cleaning: missing values (deletion, simple and model-based imputation), outliers and duplicates
• Encoding categorical variables: one-hot, ordinal and target encoding, and the pitfalls of each
• Feature scaling: standardization vs min-max normalization, and which algorithms need it
• Train/validation/test splits, stratified splits and time-based splits
• Data leakage: target leakage and train–test contamination, and how to detect and prevent them
• scikit-learn essentials: estimators, transformers, fit/transform/predict, Pipeline and ColumnTransformer

Outcome: You can turn raw data into a clean, leak-free scikit-learn pipeline that is ready for modeling.

• Linear regression: ordinary least squares, assumptions, interpreting coefficients and residual analysis
• Polynomial features and regularization: Ridge, Lasso and Elastic Net
• Regression metrics: MAE, MSE, RMSE and R-squared, and when each is appropriate
• Logistic regression: the sigmoid function, log-loss, decision boundaries and probability outputs
• Multiclass classification: one-vs-rest and softmax
• k-Nearest Neighbors: distance metrics, choosing k, the role of scaling and the curse of dimensionality
• Naive Bayes classifiers for text and categorical data
• Use cases: predicting house prices (real estate) and loan default risk (finance)

Outcome: You can build, interpret and compare linear, logistic, k-NN and Naive Bayes models on real data.

• Decision trees: Gini impurity, entropy and information gain, depth control and pruning
• Random forests: bagging, feature randomness, out-of-bag error and feature importance
• Boosting: AdaBoost and gradient boosting, and how boosting differs from bagging
• XGBoost and LightGBM: key hyperparameters, early stopping and built-in handling of missing values
• Support Vector Machines: maximum and soft margins, kernels (linear, polynomial, RBF), and the C and gamma parameters
• Imbalanced data: class weights, under- and over-sampling, and SMOTE with imbalanced-learn
• Choosing an algorithm: trade-offs between interpretability, accuracy, training speed and data size
• Use case: credit-card fraud detection in finance

Outcome: You can train and tune tree ensembles and SVMs, and handle imbalanced classification problems correctly.

• Confusion matrix, accuracy, precision, recall, F1-score, ROC-AUC and PR-AUC
• Choosing metrics that reflect real-world costs (for example, missed fraud vs false alarms) and setting decision thresholds
• Cross-validation: k-fold, stratified k-fold and time-series splits
• Bias–variance trade-off, underfitting vs overfitting, and learning and validation curves
• Hyperparameter tuning: grid search, randomized search and Bayesian optimization with Optuna (intro)
• Feature engineering: date-time features, binning, interaction terms, aggregations and domain-driven features
• Feature selection: filter, wrapper and embedded methods (L1 regularization, tree-based importance)
• Model interpretation: permutation importance and SHAP values

Outcome: You can evaluate models rigorously, tune them efficiently and explain which features drive their predictions.

• When unsupervised learning is the right tool: similarity, distance and evaluation without labels
• k-means clustering: the algorithm, k-means++ initialization, the elbow method and silhouette score
• Hierarchical clustering: agglomerative methods, linkage criteria and dendrograms
• Density-based clustering with DBSCAN (overview)
• Principal Component Analysis (PCA): explained variance, choosing components and reconstruction
• Visualizing high-dimensional data with t-SNE and UMAP (intro)
• Anomaly detection with Isolation Forest (intro)
• Use case: customer segmentation and marketing personas in retail
• Mid-course checkpoint: guided-project review and capstone proposal (problem, dataset and success metric)

Outcome: You can segment data, reduce its dimensionality and explain the resulting clusters in business terms.

• From the perceptron to multi-layer neural networks
• Activation functions: sigmoid, tanh, ReLU and softmax
• Loss functions, forward propagation and backpropagation, with a worked example
• Optimizers: SGD, momentum, RMSprop and Adam; learning-rate schedules
• Regularization: dropout, weight decay, batch normalization and early stopping
• Weight initialization and the vanishing/exploding gradient problem
• TensorFlow/Keras: Sequential and Functional APIs, callbacks and model checkpoints
• PyTorch fundamentals: tensors, autograd, Dataset/DataLoader and a custom training loop
• Training on cloud GPUs with Google Colab

Outcome: You can build, train and debug neural networks in both TensorFlow/Keras and PyTorch.

• Image data: pixels and channels, loading and preprocessing with Pillow and OpenCV
• Convolutional neural networks (CNNs): convolution, filters, stride, padding and pooling
• Landmark CNN architectures (LeNet, VGG, ResNet) and why skip connections work
• Data augmentation and strategies for small image datasets
• Transfer learning and fine-tuning pre-trained models (such as ResNet, MobileNet and EfficientNet) with Keras or torchvision
• Visualizing what CNNs learn: feature maps and Grad-CAM
• Object detection and image segmentation: an overview of real-world vision systems
• Sequence data and recurrent neural networks (RNNs); LSTM and GRU gates and long-term dependencies
• Use cases: medical image classification (healthcare) and time-series forecasting with an LSTM

Outcome: You can build image classifiers with CNNs and transfer learning, and model sequential data with LSTMs.

• Text preprocessing with NLTK and spaCy: tokenization, normalization, stop words, stemming and lemmatization
• Text representations: bag-of-words, n-grams and TF-IDF; a classical sentiment-analysis baseline
• Word and sentence embeddings: Word2Vec and GloVe intuition, Sentence Transformers
• Attention and the transformer architecture: self-attention, encoders and decoders (overview)
• Hugging Face Transformers: pipelines, tokenizers and fine-tuning a small pre-trained model for text classification
• How large language models work at a high level: pre-training, next-token prediction, instruction tuning and alignment
• Prompt engineering: zero-shot, few-shot, role and structured-output prompting; hallucinations and their limits
• Retrieval-augmented generation (RAG): chunking, embeddings, vector search with FAISS or Chroma, and grounding answers in sources
• Using LLM APIs responsibly: API-key security, cost and rate limits, data privacy and evaluating outputs

Outcome: You can solve NLP tasks with classical and transformer models and build a small, grounded RAG application.

• Saving and loading models: joblib/pickle, Keras model files and PyTorch state dictionaries
• Serving predictions as a REST API with FastAPI (and Flask), including input validation
• Building interactive ML demos with Streamlit
• Reproducibility: Git and GitHub, requirements files and virtual environments
• MLOps concepts: experiment tracking with MLflow (intro), containers with Docker (overview), monitoring and data drift
• Responsible AI: sources of bias, fairness checks, privacy and data protection, explainability (SHAP, LIME) and human oversight
• Case studies, healthcare and finance: diagnosis support and triage; credit scoring and fraud prevention
• Case studies, retail and education: recommendations and demand forecasting; adaptive learning and early-warning systems
• Capstone build sprint: modeling and evaluation review with the trainer

Outcome: You can deploy a model as an API or web app and evaluate an AI system for fairness, privacy and explainability.

• Capstone completion: data pipeline, model, evaluation and deployed demo
• Capstone presentation: problem, approach, results, limitations and next steps
• Documenting your work: project README, model card and a polished GitHub portfolio
• Interview preparation, ML theory: bias–variance, regularization, metrics, tree ensembles, gradient descent and overfitting
• Interview preparation, deep learning and Generative AI: backpropagation, CNNs, transformers, embeddings and RAG
• Case discussions: how would you design a fraud detector, a recommender or a churn model end to end?
• Coding practice: Python, pandas and implementing algorithms from scratch
• Resume and professional-profile guidance for ML roles, plus mock interview practice
• Course revision and a personal learning roadmap for what to study next

Outcome: You complete and present an end-to-end capstone and can answer common ML interview questions with clarity and confidence.