Course Outline
Module 1: Core Python for Machine Learning Workflows
• Course initiation and environment setup
Establish objectives and configure a reproducible Python ML workspace.
• Python language essentials (fast-track)
Review syntax, control flow, functions, and patterns prevalent in ML codebases.
• Data structures for machine learning
Utilize lists, dictionaries, sets, and tuples for managing features, labels, and metadata.
• Comprehensions and functional tools
Express complex transformations using comprehensions and higher-order functions.
• Object-oriented Python for ML developers
Explore classes, methods, composition, and practical design decisions.
• dataclasses and lightweight modelling
Create typed containers for configuration, examples, and results.
• Decorators and context managers
Implement patterns for timing, caching, logging, and resource-safe execution.
• Working with files and paths
Manage robust dataset handling and serialization formats.
• Exceptions and defensive programming
Write ML scripts that fail safely and transparently.
• Modules, packages, and project structure
Organize reusable ML codebases effectively.
• Typing and code quality
Implement type hints, documentation, and lint-friendly structures.
Module 2: Numerical Python, SciPy, and Data Handling
• NumPy foundations for vectorised computing
Master efficient array operations and performance-aware coding.
• Indexing, slicing, broadcasting, and shapes
Ensure safe tensor manipulation and shape reasoning.
• Linear algebra essentials with NumPy and SciPy
Perform stable matrix operations and decompositions common in ML.
• SciPy deep dive
Explore statistics, optimization, curve fitting, and sparse matrices.
• Pandas for tabular ML data
Clean, join, aggregate, and prepare datasets.
• scikit-learn deep dive
Utilize the estimator interface, pipelines, and reproducible workflows.
• Visualisation essentials
Create diagnostic plots for data exploration and model behavior analysis.
Module 3: Programming Patterns for Building ML Applications
• From notebook to maintainable project
Refactor exploratory code into structured packages.
• Configuration management
Handle externalized parameters and startup validation.
• Logging, warnings, and observability
Implement structured logging for debuggable ML systems.
• Reusable components with OOP and composition
Design extensible transformers and predictors.
• Practical design patterns
Apply Pipeline, Factory or Registry, Strategy, and Adapter patterns.
• Data validation and schema checks
Prevent silent data issues through rigorous validation.
• Performance and profiling
Identify bottlenecks and apply optimization techniques.
• Model I/O and inference interfaces
Ensure safe persistence and clean prediction interfaces.
• End-to-end mini build
Construct a production-style ML pipeline with configuration and logging.
Module 4: Statistical Learning for Tabular, Text, and Image
• Evaluation foundations
Manage train/validation splits, ensure honest cross-validation, and align with business metrics.
• Advanced tabular ML
Utilize regularized GLMs, tree ensembles, and leakage-free preprocessing.
• Calibration and uncertainty
Apply Platt scaling, isotonic regression, bootstrap, and conformal prediction.
• Classical NLP methods
Navigate tokenization trade-offs, TF-IDF, linear models, and Naive Bayes.
• Topic modelling
Understand LDA fundamentals and practical limitations.
• Classical computer vision
Explore HOG, PCA, and feature-based pipelines.
• Error analysis
Detect bias, label noise, and spurious correlations.
• Hands-on labs
Build a leakage-proof tabular pipeline, compare text baselines, and perform structured failure analysis on classical vision models.
Module 5: Neural Networks for Tabular, Text, and Image
• Training loop mastery
Create clean PyTorch loops utilizing AMP, clipping, and reproducibility measures.
• Optimization and regularization
Master initialization, normalization, optimizers, and schedulers.
• Mixed precision and scaling
Implement gradient accumulation and checkpointing strategies.
• Tabular neural networks
Use categorical embeddings, feature crosses, and conduct ablation studies.
• Text neural networks
Work with embeddings, CNNs, BiLSTMs/GRUs, and sequence handling.
• Vision neural networks
Understand CNN fundamentals and ResNet-style architectures.
• Hands-on labs
Develop a reusable training framework, compare Tabular NN vs boosting, and experiment with CNN augmentation and scheduling.
Module 6: Advanced Neural Architectures
• Transfer learning strategies
Apply freeze/unfreeze patterns and discriminative learning rates.
• Transformer architectures for text
Explore self-attention internals and fine-tuning approaches.
• Vision backbones and dense prediction
Study ResNet, EfficientNet, Vision Transformers, and U-Net concepts.
• Advanced tabular architectures
Investigate TabTransformer, FT-Transformer, and Deep and Cross networks.
• Time series considerations
Handle temporal splits and detect covariate shift.
• PEFT and efficiency techniques
Analyze LoRA, distillation, and quantization trade-offs.
• Hands-on labs
Fine-tune pretrained text and vision models, and compare tabular transformers with GBDT.
Module 7: Generative AI Systems
• Prompting fundamentals
Master structured prompting and controlled generation.
• LLM foundations
Understand tokenization, instruction tuning, and hallucination mitigation.
• Retrieval-Augmented Generation (RAG)
Implement chunking, embeddings, hybrid search, and evaluation metrics.
• Fine-tuning strategies
Apply LoRA and QLoRA with strict data quality controls.
• Diffusion models
Grasp latent diffusion intuition and practical adaptation.
• Synthetic tabular data
Create synthetic data using CTGAN while considering privacy.
• Hands-on labs
Build a production-style RAG mini-application, enforce schema validation for structured outputs, and optionally experiment with diffusion.
Module 8: AI Agents and MCP
• Agent loop design
Design loops that observe, plan, act, reflect, and persist.
• Agent architectures
Implement ReAct, plan-and-execute, and multi-agent coordination.
• Memory management
Utilize episodic, semantic, and scratchpad approaches.
• Tool integration and safety
Establish tool contracts, sandboxing, and defenses against prompt injection.
• Evaluation frameworks
Create replayable traces, task suites, and regression testing routines.
• MCP and protocol-based interoperability
Design MCP servers with secure tool exposure.
• Hands-on labs
Build an agent from scratch, expose tools via an MCP-style server, and create an evaluation harness with safety constraints.
Requirements
Participants must possess a practical working knowledge of Python programming.
This programme is designed for technical professionals at intermediate to advanced levels.
Testimonials (3)
I really liked the end where we took the time to play around with CHAT GPT. The room was not set up the best for this- instead of one large table a couple of small ones so we could get into small groups and brainstorm would have helped
Nola - Laramie County Community College
Course - Artificial Intelligence (AI) Overview
Working from first principles in a focused way, and moving to applying case studies within the same day
Maggie Webb - Department of Jobs, Regions, and Precincts
Course - Artificial Neural Networks, Machine Learning, Deep Thinking
That it was applying real company data. Trainer had a very good approach by making trainees participate and compete
