PGP in Artificial Intelligence & Machine Learning

Program: Post Graduate Program in AI & ML Institution: Great Learning (in collaboration with The University of Texas at Austin — McCombs School of Business) Duration: ~12 months (2021 – 2022) Portfolio: eportfolio.mygreatlearning.com/sunil-kunchoor-basavaraju

---

📖 About the Program

The Post Graduate Program in AI & ML is an intensive, industry-focused program delivered by Great Learning in collaboration with The University of Texas at Austin. It covers the full spectrum of modern Artificial Intelligence and Machine Learning — from statistical foundations through to cutting-edge deep learning, computer vision, and natural language processing.

The program combines:

• Live online sessions with industry experts and faculty
• Hands-on projects using real-world datasets
• Mentorship from AI/ML practitioners
• A Capstone Project that integrates learnings across all modules

---

🗺️ Program Structure

#	Module	Key Focus
01	Applied Statistics	Probability, Hypothesis Testing, Statistical Inference
02	Supervised Learning	Regression, Classification, Model Evaluation
03	Ensemble Techniques	Bagging, Boosting, Random Forests, XGBoost
04	Unsupervised Learning	Clustering, Dimensionality Reduction
05	Feature Engineering & Model Tuning	Feature Selection, Hyperparameter Tuning
06	Recommendation Systems	Collaborative Filtering, Content-Based, Hybrid
07	Neural Networks & Deep Learning	ANN, CNN basics, RNN basics
08	CNN Architecture & Transfer Learning	VGG, ResNet, InceptionV3, Fine-Tuning
09	Advanced Computer Vision	YOLO, R-CNN, Segmentation
10	Statistical NLP	BoW, TF-IDF, Word2Vec, LDA
11	Sequential NLP	LSTM, Transformers, BERT
12	Capstone Project	End-to-end AI/ML solution

---

01. Applied Statistics

📁 01_Applied_Statistics/ 📅 Completed: May 2021

Topics Covered:

• Descriptive Statistics — summarising datasets using mean, median, mode, variance, SD, IQR, skewness and kurtosis; visualised via histograms and box plots
• Probability Theory — joint, marginal and conditional probability; Bayes theorem
• Probability Distributions — Binomial (discrete, fixed trials), Poisson (event counts in intervals), Normal (continuous, symmetric); PMF/PDF/CDF using scipy.stats
• Confidence Intervals — margin of error, significance level, effect of sample size
• Hypothesis Testing — H₀ / H₁ definition, p-value interpretation, Type I & II errors
• One & Two Sample Tests — one-sample z/t-test, independent two-sample t-test, paired t-test
• Test of Proportions & Variance — z-test for proportions, F-test for variance equality
• ANOVA — one-way ANOVA for comparing 3+ group means simultaneously
• Chi-Square Test — independence test for categorical variables via contingency tables
• Statistical Power — relationship between sample size, effect size, α and power (1 − β)
• Correlation & Covariance — Pearson r, covariance matrix; correlation ≠ causation
• Central Limit Theorem — sampling distribution of the mean converges to Normal as n → ∞

Project — Applied Statistics:

Part 1 — Probability & Distributions: Solved 6 real-world problems using Binomial, Poisson and Normal distributions. Designed an e-learning question difficulty classifier (Easy 90%, Moderate 60%, Hard 30%) using norm.cdf.

Part 2 — Basketball Team Investment Analysis: EDA and feature engineering (win %, avg baskets per game/tournament) on 61-team dataset. Identified confounding variable (team age) via correlation analysis. Shortlisted 6 investable teams (Team 21, 11, 39, 27, 47, 59) formed 1941–1998.

Part 3 — EU Startup Funding Analysis: Hypothesis testing on Disrupt event funding data. H1: Operating vs Closed funds — t-test, p=0.1932 (fail to reject). H2: Winner vs Contestant operating rate — z-test, p=0.8767 (fail to reject). H3: Funds across NY/SF/EU — one-way ANOVA.

Tools: Python, Pandas, NumPy, SciPy, Matplotlib, Seaborn

---

02. Supervised Learning

📁 02_Supervised_Learning/ 📅 Completed: July 2021

Topics Covered:

• Linear Regression — OLS cost function, gradient descent, R², residual analysis, multicollinearity (VIF)
• Logistic Regression — sigmoid function, log-loss, decision boundary, L1/L2 regularisation, threshold tuning via predict_proba
• K-Nearest Neighbours (KNN) — distance metrics (Euclidean, Manhattan, Minkowski), choosing optimal K, BallTree/KDTree algorithms, mandatory feature scaling
• Naive Bayes — Bayes theorem, Gaussian/Multinomial/Bernoulli variants, Laplace smoothing, independence assumption
• Support Vector Machines (SVM) — maximum-margin hyperplane, C (regularisation) and γ (gamma) parameters, kernel trick (Linear, RBF, Polynomial), multi-class strategies
• Model Evaluation — confusion matrix, accuracy, precision, recall, F1-score, AUC-ROC, balanced accuracy; when NOT to use accuracy (imbalanced classes)
• Class Imbalance — under-sampling, over-sampling, SMOTE (Synthetic Minority Oversampling Technique)
• Hyperparameter Tuning — GridSearchCV with cross-validation, stratified train-test split

Project — Supervised Learning:

Part 1 — Orthopaedic Patient Classification (KNN): Classified patients into Normal / Hernia / Spondylolisthesis using 6 biomechanical features. Applied MinMaxScaler, balanced accuracy scoring (class imbalance), and GridSearchCV. Final model: KNN with K=19, BallTree algorithm, balanced accuracy = 0.756.

Part 2 — Bank Customer Loan Conversion (Logistic Regression + Naive Bayes): Predicted whether a customer would take a loan on their credit card (targeted marketing). Applied SMOTE for class imbalance, StandardScaler, engineered target column from ambiguous data. Final model: Logistic Regression — better recall and F1 than Naive Bayes.

Tools: Python, Pandas, NumPy, Scikit-learn, Imbalanced-learn (SMOTE), Matplotlib, Seaborn

---

03. Ensemble Techniques

📁 03_Ensemble_Techniques/ 📅 Completed: July 2021

Topics Covered:

• Decision Trees (CART) — Gini impurity vs Information Gain splitting, pre/post-pruning, depth and leaf controls
• Bias-Variance Trade-off — bagging reduces variance, boosting reduces bias; total error decomposition
• Bagging — bootstrap sampling of training data, aggregate predictions; decorrelates models to reduce variance
• Random Forest — bagging + random feature subsets per split; OOB error, feature importance via mean decrease in impurity
• AdaBoost — sequential boosting by up-weighting misclassified samples; learning_rate, decision stumps as weak learners
• Gradient Boosting (GBC) — fits each new tree to residuals via gradient descent; subsample for stochastic boosting
• XGBoost — regularised gradient boosting with L1/L2 penalties, native NaN handling, scale_pos_weight for class imbalance
• CatBoost — gradient boosting with native categorical feature handling (no encoding needed), symmetric trees
• Model Comparison — train vs test gap to detect overfitting; ROC AUC as comparison metric
• Class Imbalance (Advanced) — ADASYN, SMOTETomek, SMOTEENN (beyond basic SMOTE)
• Model Serialisation — pickling trained models (.pkl) for deployment; Flask GUI integration

Project — Telecom Customer Churn Prediction:

Predicted customer churn (Yes/No) for a telecom company to drive retention programmes. Dataset: 7,000 customers × 21 features (services, account info, demographics). Applied ADASYN for class imbalance (27% churn), manual categorical encoding, 70:30 train-test split. Trained and tuned 5 ensemble models (Random Forest, AdaBoost, GBC, CatBoost, XGBoost) using GridSearchCV. XGBoost overfit; CatBoost underfit; Gradient Boosting Classifier selected as final model (best train/test balance, highest ROC AUC). Model pickled and deployed as a Flask web app on Heroku.

Tools: Python, Pandas, Scikit-learn, XGBoost, CatBoost, Imbalanced-learn, Pickle, Flask

---

04. Unsupervised Learning

📁 04_Unsupervised_Learning/ 📅 Completed: July 2021

Topics Covered:

• K-Means Clustering — centroid-based partitioning; K-Means++ initialisation; Elbow Method (WCSS/inertia vs K) and Silhouette Score for choosing optimal K; mandatory feature scaling
• Hierarchical / Agglomerative Clustering — builds a dendrogram bottom-up; linkage methods (Single, Complete, Average, Ward); Cophenetic Correlation Coefficient for validation; no need to pre-specify K
• K-Means vs Hierarchical — speed, scalability, reproducibility, and use-case trade-offs
• Clustering for Missing Value Imputation — use cluster centroids to impute missing values contextually, rather than global mean/median
• Synthetic Data Generation — KernelDensity to model data distribution and sample synthetic points
• PCA (Principal Component Analysis) — covariance matrix, eigenvectors/eigenvalues, explained variance ratio, scree plot; reduces features while preserving maximum variance; applied to tabular, image and text data
• Dimensionality Reduction Taxonomy — Linear (PCA, SVD, NMF), Manifold Learning (t-SNE, Isomap, LLE, MDS), Feature Selection (VIF filter, RFE, forward/backward selection)
• t-SNE — non-linear; for 2D/3D visualisation of clusters only; not suitable for model training

Project — Unsupervised Learning (5 Parts):

Part 1 — Car Clustering & Regression: Merged car dataset (mpg, cylinders, horsepower, weight, origin). Cleaned hp column (regex-identified "?" values). K-Means (elbow→k=3) and Hierarchical (average linkage, highest Cophenetic score) both agreed on 3 clusters. Fitted separate Linear Regression per cluster to reveal cluster-specific feature relationships.

Part 2 — Wine Quality Imputation: Used K-Means (k=2, bimodal data) to impute 18 missing quality scores by assigning missing rows to nearest cluster centroid. Bonus: synthetic data generation via KernelDensity.

Part 3 — Vehicle Shape Classification + PCA: SVM on 18 silhouette features → high balanced accuracy. PCA reduced to 6 components (94% variance explained); SVM re-trained on 6 PCs lost only ~8% accuracy with 1/3 the features.

Part 4 — IPL Batsman Ranking: PCA (eigenvalue ranking) + K-Means (k=4 via elbow + silhouette) used to rank 4 player tiers from batting statistics (runs, strike rate, fours, sixes, half-centuries).

Part 5 — Dimensionality Reduction Survey: Catalogued all Python-available techniques (Linear, Manifold, Feature Selection); demonstrated PCA on image data (pixel compression and reconstruction).

Tools: Python, Pandas, NumPy, Scikit-learn, SciPy (hierarchy), Imbalanced-learn, Matplotlib, Seaborn

---

05. Feature Engineering & Model Tuning

📁 05_Feature_Engineering_Model_Tuning/ 📅 Completed: September 2021

Topics Covered:

• Missing Value Treatment — % null analysis per column; drop > threshold, median impute < threshold; why median > mean for skewed data
• Feature Selection — Variance Threshold (drop near-zero variance), Correlation Filter (|r| > 0.8 → drop one), RFE, Forward/Backward selection, feature importance from tree models
• Regularisation — Ridge (L2, shrinks all coefficients), Lasso (L1, drives some to zero = built-in selection), ElasticNet; alpha tuning via cross-validation
• Cross-Validation — K-Fold, Stratified K-Fold (for imbalanced targets), LOOCV, Bootstrapping (confidence interval on performance)
• ROC Curve & Threshold Tuning — AUC-ROC, predict_proba + custom threshold; raising threshold = higher precision, lower recall; tuning based on business cost of FN vs FP
• Hyperparameter Tuning — GridSearchCV (exhaustive), RandomizedSearchCV (efficient for large grids); refit=True, cv_results_ analysis
• Scikit-learn Pipelines — chain scaler + model; prevents data leakage in CV; compatible with GridSearchCV; pickle entire pipeline for deployment
• PCA for High-Dimensional Data — reduce 500+ features to top K components; apply after scaling; small accuracy loss, large speed gain at scale
• Sampling — ADASYN / SMOTE applied only to training fold; under-sampling for very large datasets

Project — Semiconductor Yield Prediction (Pass/Fail):

Dataset: 1,567 records × 591 sensor features. Aggressive cleaning pipeline reduced 591 → 116 usable features: dropped > 5% null columns, median imputed the rest, dropped zero-variance columns (323), removed high-correlation pairs (|r| > 0.8). ADASYN oversampling on training data only. Trained 3 Random Forest variants: (1) default, (2) GridSearchCV-tuned, (3) PCA (87 components) + tuned RF. All had high overall accuracy but low Fail-class recall — threshold tuned via ROC curve to improve detection of failures. Bootstrap validation confirmed model stability across different sample populations. Final pipeline (scaler → RF) pickled for inference on Future_predictions.xlsx.

Tools: Python, Pandas, Scikit-learn, Imbalanced-learn, Matplotlib, Seaborn, Pickle

---

06. Recommendation Systems

📁 06_Recommendation_Systems/ 📅 Completed: October 2021

Topics Covered:

• Popularity-Based Recommendation — IMDB Weighted Rating formula (W = (R×v + C×m)/(v+m)); corrects for items with few ratings; same recommendations for all users (no personalisation)
• Similarity Measures — Cosine Similarity (direction of preference), Pearson Correlation (corrects for rating scale bias), Euclidean Distance, Jaccard (binary interactions)
• User-User Collaborative Filtering — find similar users, predict unseen ratings as weighted average; KNNWithMeans corrects for per-user mean bias
• Item-Item Collaborative Filtering — item similarity is more stable than user similarity; "customers who bought X also bought Y"; scales better than user-user
• Matrix Factorisation (SVD) — decomposes user-item rating matrix into latent factors (U × Σ × Vᵀ); captures hidden preferences (genre affinity, price sensitivity); outperforms KNN on sparse matrices; SVD++ adds implicit feedback
• Cold Start Problem — new user (no history → popularity fallback) vs new item (no ratings → content-based fallback); hybrid models as solution
• Evaluation — RMSE, MAE, Precision@K, Recall@K; 5-fold cross-validation via Surprise cross_validate()
• Market Basket Analysis (Apriori) — Support, Confidence, Lift; mlxtend library; "frequently bought together" associations
• Surprise Library Taxonomy — Basic, KNN-Based (KNNWithMeans, KNNWithZScore, KNNBaseline), Matrix Factorisation (SVD, SVD++, NMF), Slope One, Co-Clustering

Project — Mobile Phone Recommendation System:

Dataset: 6 CSVs merged → 1.4M ratings → cleaned, deduped, sampled to 1M → filtered users & products with > 50 ratings → 41,892 records × 3 columns (author, product, score). Popularity model used IMDB weighted formula — top recommendation: Apple iPhone 5s 16GB. Collaborative filtering: SVD, KNNWithMeans (user-based and item-based) trained via Surprise. SVD achieved lowest RMSE — selected as final model. Personalised top-5 recommendations generated per user. Cross-validation applied to all 3 models; minimal RMSE improvement confirming stability.

Tools: Python, Pandas, NumPy, Surprise (SVD, KNN, cross_validate), mlxtend (Apriori), Scikit-learn (cosine_similarity), Matplotlib

---

07. Neural Networks & Deep Learning

📁 07_Neural_Networks_Deep_Learning/ 📅 Completed: November 2021

Topics Covered:

• Biological → Artificial Neuron — inputs × weights + bias → activation function → output; single neuron = linear classifier, stacked layers = non-linear
• Architecture — Input, Hidden, Output layers; depth (layers) vs width (neurons per layer)
• Forward Propagation — z = W·x + b → a = f(z); data flows left to right through layers
• Activation Functions — Sigmoid (binary output), Tanh (zero-centred hidden), ReLU (default hidden; avoids vanishing gradient), Leaky ReLU (dying ReLU fix), Softmax (multi-class output)
• Loss Functions — MSE/MAE (regression), Binary Crossentropy (binary classification), Categorical Crossentropy (multi-class)
• Backpropagation — chain rule applied backwards; computes ∂Loss/∂W for every weight; feeds gradient descent
• Optimisers — SGD, Momentum, RMSProp, Adam (default), Adagrad; learning rate scheduling
• Batch Size & Epochs — trade-offs between gradient quality, speed, and generalisation; small batches act as regulariser
• Regularisation — Dropout (random neuron deactivation during training), Batch Normalisation (stabilises, speeds up training), L1/L2 weight penalties, Early Stopping
• TensorFlow/Keras — Sequential API, compile(), fit(), model.save() / load_model(); callbacks (EarlyStopping, ModelCheckpoint)
• CNN Basics — Convolutional layers (learnable filters, shared weights), Pooling (spatial downsampling), Flatten; dramatically fewer parameters than fully-connected on image data
• Image Preprocessing — cropping, Sobel/Gaussian/Laplace filters, pixel normalisation (0–255 → 0–1), channel reshaping, one-hot encoding

Project — Introduction to Neural Networks:

Part 1 — Signal Quality Regression (MLP): Predicted signal quality from 11 measurement parameters (1,599 records). Architecture: BatchNorm → Dense(10, ReLU) → Dense(10, ReLU) → Dense(1). Optimiser: SGD, Loss: MSE. Best config: batch=10, epochs=30; validation loss converged to ~0.4. Model saved with Keras model.save().

Part 2 — SVHN Street Digit Recognition (CNN/MLP): Recognised single digits (0–9) from Google Street View house number images. Data preprocessing pipeline: cropping (reduce multi-digit frames) + Sobel filter (edge sharpening) + normalisation + channel reshape + one-hot encoding. Architecture: Flatten → Dense(256, ReLU) → Dense(128, ReLU) → Dense(10, Softmax). Without preprocessing: 68% accuracy; with cropping + Sobel: **83% accuracy** (+15%). Final config: batch=100, epochs=30.

Tools: Python, TensorFlow, Keras, NumPy, Matplotlib, SciPy (image filters), h5py

---

08. CNN Architecture & Transfer Learning

📁 08_Computer_Vision_CNN_Transfer_Learning/ 📅 Completed: December 2021 📁 Shared resources: 08_09_slides_codes_projects/Project - 1/

Topics Covered:

• Why CNN > SVC/ANN for Images — flattening destroys spatial relationships; CNN convolution preserves and exploits local structure
• Convolutional Layer — learnable filters slide over image; feature maps detect edges/textures/shapes; parameter sharing (same filter across all positions); padding and stride
• Pooling Layer — Max Pooling (strongest activations) and Average Pooling; spatial downsampling; translation invariance
• Typical CNN Pattern — [Conv2D → Activation → MaxPool] × N → Flatten → Dense → Softmax
• Deep Architectures — AlexNet, VGG16/19 (3×3 filters stacked), ResNet50 (skip connections, solves vanishing gradient), InceptionV3 (parallel multi-scale filters), InceptionResNetV2, MobileNet (lightweight depthwise separable convolutions)
• Residual / Skip Connections — learn residual F(x) = H(x)−x; gradients flow directly backwards enabling 50–150+ layer networks
• Transfer Learning — Feature Extraction (freeze pre-trained layers, replace head) vs Fine-tuning (unfreeze + retrain at low LR); ImageNet pre-trained weights as starting point
• ImageDataGenerator & Data Augmentation — batch loading from disk (memory efficient); rotation, flip, zoom, shear augmentations applied on-the-fly

Project — Plant Species Classification (12 classes, 4,767 images):

Compared 3 approaches: SVC (RGB→Grayscale→Flatten→PCA) = ~16%; Feed-Forward ANN = ~14%; Custom CNN (3 Conv+Pool blocks + Dense head, ImageDataGenerator augmentation) = ~80%. CNN dominates because convolution learns spatial leaf features invisible after flattening. Transfer Learning bonus: InceptionResNetV2 fine-tuned for further accuracy improvement.

Tools: Python, TensorFlow, Keras, Scikit-learn (SVC, PCA), Matplotlib, PIL/OpenCV

---

09. Advanced Computer Vision — Object Detection

📁 09_Computer_Vision_Object_Detection/ 📅 Completed: January 2022 📁 Shared resources: 08_09_slides_codes_projects/Project - 2/

Topics Covered:

• Object Detection — R-CNN (region proposals + CNN per region), Fast R-CNN (CNN once, project regions), Faster R-CNN (RPN built-in, end-to-end); IoU, Non-Maximum Suppression, Anchor Boxes
• YOLO (You Only Look Once) — grid-based single forward pass; objectness × class probability; real-time (30+ FPS)
• SSD (Single Shot Detector) — multi-scale feature maps; detects objects at different scales in one pass
• Semantic Segmentation — pixel-level class labels; FCN (fully convolutional), U-Net (encoder-decoder + skip connections between matching resolution layers), Dice Coefficient as evaluation metric
• Instance Segmentation — Mask R-CNN; per-object pixel masks on top of Faster R-CNN
• Face Recognition & Metric Learning — VGGFace embeddings (2,622-dim per face); Euclidean/Cosine distance between embeddings; One-Shot Learning via thresholding
• Siamese Networks — shared-weight twin networks; Contrastive Loss (pairs) and Triplet Loss (anchor-positive-negative) to learn identity-discriminative embedding spaces

Project — Advanced Computer Vision (CV-2):

Part 1 — Face Segmentation (U-Net): Detect and mask faces in movie stills (409 training images). Custom U-Net with skip connections; custom Dice Coefficient metric and Dice Loss. White background + red face overlay gave best Dice score. Limited data constrained generalisation; prediction images successfully masked.

Part 2 — Face Recognition (VGGFace + SVM): Identify individuals from 10,770 images (100 people, Pinterest dataset). Pipeline: load VGGFace pre-trained model → generate (2,622,) embedding per image → LabelEncode + StandardScaler → PCA reduction → SVM classifier. Test accuracy: 95%. Both prediction images correctly identified. Embedding-based approach generalises without retraining for new people.

Tools: Python, TensorFlow, Keras, keras-vggface, Scikit-learn (SVM, PCA), OpenCV, NumPy, Matplotlib

---

10. Statistical NLP

📁 10_Statistical_NLP/ 📅 Completed: January 2022 📁 Shared resources: 10_11_slides_codes_projects/Project-1/

Topics Covered:

• Text Preprocessing Pipeline — language detection (fasttext), special char/number removal (regex), lowercasing, stop word removal, tokenisation, stemming (PorterStemmer, rule-based), lemmatisation (WordNetLemmatizer, vocabulary-based)
• Bag of Words (BoW) — term frequency matrix; each word = one dimension; sparse; ignores word order; CountVectorizer(ngram_range=(1,2))
• TF-IDF — TF x IDF; downweights common words, upweights rare discriminative terms; generally outperforms raw counts; TfidfVectorizer
• HashingVectorizer — fixed-size output via hash function; no vocabulary; memory-efficient for streaming; risk of hash collisions
• Word2Vec — dense word embeddings; CBOW vs Skip-gram; semantic relationships as vector offsets; gensim.Word2Vec
• Multi-Label Classification — single sample can have multiple labels; MultiLabelBinarizer + OneVsRestClassifier; evaluation via F1 + average precision/recall (not raw accuracy)
• Regular Expressions — pattern matching for text cleaning; re.sub(), character classes, capture groups, word boundaries
• Classifiers for Text — Logistic Regression, SVC, Random Forest, XGBoost; ensemble methods scale better to high-dimensional sparse text features

Project — Blog Authorship Multi-Label Classification:

Dataset: Blog Authorship Corpus — 681,288 posts, 19,320 bloggers. Labels: gender + age + topic + astrological sign (combined multi-label). Text cleaned → CountVectorizer / TF-IDF / HashingVectorizer x 4 classifiers (RF, SVC, LR, XGBoost) → 12-combination comparison grid. XGBClassifier + TF-IDF selected as best. Hyperparameter tuning via GridSearchCV — marginal improvement. Key metric: F1-score (not accuracy — multi-label problem).

Tools: Python, NLTK, fasttext, Scikit-learn, XGBoost, Gensim (Word2Vec), Matplotlib, WordCloud

---

11. Sequential NLP — RNNs & LSTMs

📁 11_Sequential_NLP/ 📅 Completed: February 2022 📁 Shared resources: 10_11_slides_codes_projects/Project-2/

Topics Covered:

• Why Sequential Models — BoW/TF-IDF lose word order; RNNs maintain hidden state as memory passing context from step to step
• RNN — ht = tanh(Wx.xt + Wh.ht-1 + b); shared weights across time steps; problems: vanishing/exploding gradients for long sequences
• LSTM — adds cell state + 3 gates (Forget: erase irrelevant memory, Input: write new info, Output: expose relevant state); handles long-range dependencies
• GRU — simplified LSTM with 2 gates (Reset + Update); fewer parameters; often comparable performance
• Bidirectional LSTM — processes sequence left-to-right AND right-to-left; concatenates both hidden states; full context for each token; ideal for classification
• Sequence Padding — pad_sequences(maxlen, padding='pre'); pre-padding keeps actual text nearest LSTM output; truncates long sequences
• Embedding Layer — learned dense word vectors trained end-to-end; Embedding(vocab_size, dim, input_length)
• GloVe Pre-trained Embeddings — global word co-occurrence vectors; initialise Embedding layer with GloVe weights; helps with limited training data
• Attention Mechanism — instead of fixed context vector, decoder attends to all encoder states weighted by relevance; basis of the Transformer
• NMT with Attention — encoder LSTM outputs all hidden states; attention weights compute context vector per decoder step; overcomes seq2seq bottleneck
• Advanced LMs (Overview) — ELMo (contextual bidirectional LM), BERT (masked LM + next sentence prediction, bidirectional transformer), GPT (autoregressive), Transformer (multi-head self-attention, parallelisable)

Project — Sequential NLP:

Part 1 — IMDB Sentiment Analysis (LSTM): 50,000 movie reviews; vocab=10,000; maxlen=500; pre-padded. Embedding → LSTM → Dense(1, sigmoid). Training ~98%, test ~85%; slight overfitting. Tuning (longer maxlen, more units, stop word removal) showed minimal uplift — main gain requires more data.

Part 2 — News Headline Sarcasm Detection (Bidirectional LSTM + GloVe): 28,619 headlines (The Onion vs HuffPost). Preprocessing: tokenisation + lemmatisation + stemming + WordCloud EDA. GloVe weight matrix → Bidirectional LSTM. Architecture designed for 10–15 epoch training for full accuracy.

Tools: Python, TensorFlow, Keras (LSTM, GRU, Bidirectional, Embedding), NLTK, GloVe, NumPy, Matplotlib, WordCloud

---

12. Capstone Project

📁 12_Capstone_Project_AIML/

An end-to-end AI/ML project integrating skills from all prior modules:

• Problem definition and business case framing
• Data collection, exploration, and preprocessing
• Feature engineering and model selection
• Model training, evaluation, and optimisation
• Presentation of insights and recommendations

---

🛠️ Technologies & Tools

Data Science & ML Libraries

Category	Libraries
Data Manipulation	Pandas, NumPy
Visualisation	Matplotlib, Seaborn, Plotly
Machine Learning	Scikit-learn, XGBoost, LightGBM
Deep Learning	TensorFlow, Keras
NLP	NLTK, spaCy, Gensim, HuggingFace Transformers
Computer Vision	OpenCV, PIL/Pillow
Recommendation Systems	Surprise

Development Tools

Tool	Purpose
Jupyter Notebook	Exploratory analysis and prototyping
Google Colab	GPU-accelerated training
Git & GitHub	Version control
Python	Primary language

---

🏆 Projects Summary

Project	Module	Description
Statistical Analysis	Applied Statistics	Hypothesis testing and EDA on real datasets
Predictive Modelling	Supervised Learning	Classification and regression models
Customer Segmentation	Unsupervised Learning	K-Means & PCA for market segmentation
Movie Recommendation	Recommendation Systems	Collaborative filtering engine
Image Classifier	CNN & Transfer Learning	Fine-tuned ResNet50 for image classification
Object Detection	Advanced CV	YOLO-based object detection pipeline
Sentiment Analysis	Statistical NLP	NLP pipeline for product review sentiment
Text Generation	Sequential NLP	LSTM-based language model
Capstone	Capstone	End-to-end business AI/ML solution

---

📂 Repository Structure

pgp-ai-ml/
├── README.md                                   ← You are here
├── 01_Applied_Statistics/
│   └── README.md                               ← Module notes & projects
├── 02_Supervised_Learning/
│   └── README.md
├── 03_Ensemble_Techniques/
│   └── README.md
├── 04_Unsupervised_Learning/
│   └── README.md
├── 05_Feature_Engineering_Model_Tuning/
│   └── README.md
├── 06_Recommendation_Systems/
│   └── README.md
├── 07_Neural_Networks_Deep_Learning/
│   └── README.md
├── 08_Computer_Vision_CNN_Transfer_Learning/
│   └── README.md
├── 09_Computer_Vision_Object_Detection/
│   └── README.md
├── 10_Statistical_NLP/
│   └── README.md
├── 11_Sequential_NLP/
│   └── README.md
└── 12_Capstone_Project_AIML/
    └── README.md

---

🚀 How to Use This Repository

1. Browse by module — Navigate into any numbered folder to find notes, notebooks, and project files.
2. Load into NotebookLM — Upload this README and module READMEs into NotebookLM to generate summaries, Q&A, and study guides.
3. Add your materials — Drop slides, notebooks (.ipynb), PDFs, or notes into each module folder and update the module README.

---

📜 Certification

• Post Graduate Program in AI & ML — Great Learning / UT Austin McCombs School of Business
• Portfolio: https://eportfolio.mygreatlearning.com/sunil-kunchoor-basavaraju

---

Last updated: June 2026