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

• 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

• 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

• 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

• 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

• 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

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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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