AI Training with Python: Machine Learning, Deep Learning & Generative AI (LLMs) Training

• Data Types & Variables (String, Integer, Float, Complex, Boolean, None)
• Input and Output Functions
• Working with the format() method, f-strings, & escape sequences
• Basic Arithmetic & Operators
• Type casting, type checking, & validation

• Conditional Statements (if, else, elif)
• Loops (for, while)
• Looping over tuples, strings, & dictionaries
• Special loops in Python (for/else)
• Using nested loops and flow control through conditions
• Resolving real-world problems to improve skills
• Special Statements: pass, continue, break

AI Tool:

• Google Colab - Gemini

Lists:

• Overview & fundamental operations
• Indexing, slicing, & negative indexing
• Looping through lists & conditions
• List methods like .insert(), .append(), .remove(), .sort(), etc.
• List comprehension with conditions

Tuples:

• Introduction & operations
• Indexing, slicing, & looping
• List versus Tuple
• Switching between lists and tuples
• Tuple unpacking

Sets:

• Introduction & set operations
• Adding, removing, & discarding items
• Set operations: union, intersection, and difference
• Frozenset versus set

Dictionaries:

• Introduction to dictionaries & methods like .get(), .update(), .keys(), .pop(), etc.
• Dictionary comprehension
• Nested dictionaries

AI Tool:

• Gemini or Codeium

• Defining functions through def keyword
• Parameters, Arguments, & Return Statements
• Returning multiple values
• Default & keyword arguments
• Anonymous functions (lambda)
• Nested functions & closures
• Scopes in Python: Local and Global

Text File Operations:

• Reading & writing text files
• Modes of file (r, w, a, rb, wb)
• File path handling with the os module

Working with CSV Files:

• Basics of CSV format and operations
• Reading & writing CSV files with csv.reader & csv.writer
• Using dictionaries in CSV files

Working with JSON:

• Introduction to JSON & its structure
• Reading & writing JSON data with the json module
• Parsing JSON strings

AI Tool:

• Using ChatGPT for prompt engineering

• Classes & Objects
• Class versus Object attributes
• Initializing object attributes with __init__()
• self keyword
• Inheritance: single, multiple, and multi-level
• Polymorphism & operator overloading
• Function overriding & encapsulation

AI Tools:

• Pythontutor.com

• Try-except blocks
• Catching specific exceptions
• Using else & finally
• Generating and creating custom exceptions
• Problem-solving strategies

• Lambda Functions
• Generators & Iterators
• List Comprehensions
• Working with *args & **kwargs

Standard Libraries: os, random, math, functools, etc.

Data Manipulation with Pandas

• Working with DataFrames
• Reading & writing CSV files
• Data manipulation techniques

Data Visualization

• Using Matplotlib, Seaborn, and Plotly

AI Tools

• Pandas Profiling

• Designing and changing databases and tables
• CRUD operations (CREATE, SELECT, UPDATE, DELETE)
• Filtering data with the WHERE clause

AI Tools for SQL

• DBeaver for SQL queries
• Optimizing & explaining SQL queries with ChatGPT

• Introduction to APIs and HTTP methods (GET, POST, PUT, DELETE requests)
• Sending parameters, headers, and JSON data
• Handling responses and status codes
• API authentication (API keys, tokens)
• Error handling and exceptions
• Working with sessions and pagination
• Consuming public APIs (practical examples)

• Functions as first-class objects
• Closures and nested functions
• Creating and using decorators
• Decorators with arguments
• Using functools.wraps
• Built-in decorators (@staticmethod, @classmethod, @property)
• Practical use cases (logging, timing, authorization)

• Introduction to type annotations
• Function and variable type hints
• Built-in and collection types
• typing module (Optional, Union, Any)
• Type hints in classes and methods
• Static type checking basics (mypy)
• Best practices for clean and safe code

• Installing & configuring Git
• Setting up local & remote repositories
• Making commits & branching
• Integrating local repositories to GitHub
• Pushing changes & cloning repositories

AI Tools

• GitHub Copilot for Git commands

1. Web Scraping + Database + File Operations: Scrape data, store it in SQL, & export to CSV/JSON
2. Desktop Application (Data Entry System): Develop an application to manage data in JSON/CSV format
3. CLI Application with CRUD Operations: Design a CLI app with basic CRUD operations & database integration

• 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.

• 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

• 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.

• 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.

• 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.

• 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.