AI320: LLM Engineering Bootcamp: From Data to Production NEW

Agenda:

• Understand architecture & set up data strategy
  • Transformers “under the hood”
    • Self-attention, multi-head attention, positional information (embeddings/encodings)
      Why these building blocks matter (context, scaling, parallelization)
      
      
  • Architecture variants compared
    • Encoder-only vs. decoder-only vs. encoder-decoder
    • Which variant for what: generation, translation, summarization, extraction, classification
      
      
  • Data selection & data preparation
    • Public corpora vs. internal data: benefits, risks, quality criteria
    • Licensing/copyright, PII/data protection, duplicates/spam/boilerplate, data provenance
      
      
  • Tokenization – basic principles
    • Subword tokenization (BPE family / SentencePiece logic), vocabulary size, trade-offs
      
      
  • Hands-on lab
    • Prepare a mini corpus (cleaning, normalization, splits)
    • Tokenizer training on an example corpus + brief analysis of token statistics
    • Outlook: how data is structured for larger training runs
      
      
      
• Mini Transformer & training pipeline
  • A minimal Transformer as a reference
    • Core layers: attention, feed-forward, residual/norm
    • Configuration parameters: model width, depth, heads, context length
      
      
  • Training setup & hyperparameter basics
    • Batch/sequence lengths, learning rate & schedules, optimizer fundamentals
    • Stability & performance: mixed precision, gradient clipping, checkpointing
      
      
  • Experiment tracking & reproducibility
    • Versioning of data/config/code, making runs comparable
      
      
  • Hands-on lab
    • Start a training run on a small text dataset
    • Monitor loss/speed, simple sample generation, initial diagnostic checks
      
      
      
• Adaptation, evaluation & RAG fundamentals
  • Training from scratch vs. fine-tuning
    • When which approach makes sense (data volume, domain distance, cost, risk)
    • Fine-tuning patterns
      
      
  • Evaluation in practice
    • Model-near metrics (e.g., perplexity/token quality) and task-near metrics
    • Evaluation design: baselines, test sets, robustness
      
      
  • RAG (Retrieval-Augmented Generation) – design & building blocks
    • Chunking/embeddings/retrieval/re-ranking, prompt composition
    • When RAG is better than further fine-tuning (and when it is not)
      
      
  • Hands-on lab
    • Fine-tune a small model on a dataset
    • Build a mini RAG demo: “Retrieve → Compose → Generate” including simple quality checks
      
      
      
• Efficiency, scaling patterns & multimodal extension
  • Efficiency methods
    • Parameter-efficient adaptation (PEFT principles), saving memory and compute
    • Quantization, checkpoint strategies, cost/latency trade-offs
      
      
  • Scaling patterns (transfer to larger models)
    • Gradient accumulation, distributed training principles, bottlenecks & failure modes
      
      
  • Multimodal positioning
    • Core idea: vision encoder + language decoder, typical use cases
    • Limits/complexity: data, evaluation, compute
      
      
  • Hands-on lab
    • Efficiency experiment: save memory (e.g., PEFT or quantization) and measure impact
    • Simple image/text coupling
      
      
      
• Production-ready: serving, monitoring, security & capstone project
  • Deployment & serving options
    • Serving patterns (batch/real-time), latency drivers, caching, streaming responses
    • Scaling: concurrency, queuing, resource profiles (GPU/CPU), cost control
      
      
  • Observability
    • Monitoring core metrics, logging & tracing mindset
    • Operations: rollouts, A/B comparisons, fallback strategies, incident basics
      
      
  • Security & governance
    • Prompt-injection risks, guardrails principles, content/policy checks
    • Data protection/on-prem considerations, handling sensitive data, documentation requirements
      
      
  • Capstone project
    • Optionally:
      • “Small custom LLM setup” (train/fine-tune + evaluation report)
        “RAG system” (retriever + prompting + quality measurement)
        “Multimodal mini prototype” (text+image building block)
        
        
    • Presentation: approach, results, limitations, next steps as a project plan
      
      
      
  • Next steps
    • Open-source models & ecosystem (positioning), infrastructure/HPC realities, decision guide “build vs. buy”

Objectives:

• Explain Transformer mechanics and architecture variants and select them for use cases
• Make well-founded decisions on data strategy and tokenization (
• Set up a reproducible training/fine-tuning pipeline
• Choose fine-tuning vs. RAG appropriately and implement a mini RAG as a prototype
• Classify and test efficiency levers (PEFT/quantization)
• Think LLM systems production-ready: serving, monitoring, security & governance

Target audience:

The training AI320 LLM Engineering Bootcamp: From Data to Production is targeted at:

• ML/AI Engineers, Data Scientists (engineering focus)
• Software Engineers/Tech Leads with responsibility for LLM integration
• MLOps/platform/architecture roles shaping LLM pipelines, deployment, and operations

Prerequisites:

For participation in the course AI320 LLM Engineering Bootcamp: From Data to Production the following prerequisites are required:

• Basic knowledge of Python
• Basic understanding of ML (train/test, overfitting, loss/metrics)

Description:

The course AI320 LLM Engineering Bootcamp: From Data to Production is a continuous, hands-on deep dive for teams that want not only to “use” Large Language Models (LLMs), but to technically understand, adapt, and operate them productively. Participants build knowledge and artifacts along a realistic end-to-end chain: from Transformer fundamentals and architecture variants through data strategy, tokenization, and training pipelines to fine-tuning, evaluation, Retrieval-Augmented Generation (RAG), efficiency optimization, and production readiness (serving, monitoring, security & governance).

The focus is on engineering pragmatism: We deliberately train and experiment with small, well-controlled models and data slices to make every building block traceable—and then transfer the patterns to larger setups (scaling, cost, distributed training, infrastructure decisions). The course AI320 LLM Engineering Bootcamp: From Data to Production thus delivers both a solid architectural understanding and concrete approaches, checklists, and project blueprints that can be applied directly within your own organization.