Next-Generation LLM Engineering: Custom Model Training, Alignment & Deployment

Aim

Workshop Objectives

Workshop Structure

Day 1: LLM Foundations, Model Adaptation & Custom Dataset Engineering

Session focus: Understand modern open-source LLMs, choose an appropriate customization strategy and prepare high-quality data for model training.

Topics covered

• Modern foundation models and open-source LLM ecosystem: Llama, Mistral, Qwen and Phi.
• Transformer architecture, self-attention, tokenization and context windows.
• Base models vs instruction-tuned models and domain-specific LLMs.
• Full fine-tuning vs Parameter-Efficient Fine-Tuning (PEFT).
• Introduction to LoRA, QLoRA and DoRA: concepts, use cases and trade-offs.
• Custom instruction datasets, conversational data and chat-template formats.
• Dataset preprocessing, cleaning, deduplication and quality filtering.
• Synthetic data generation and dataset augmentation for specialized tasks.
• Training, validation and test splits; data leakage and overfitting prevention.

Hands-on activities

• Explore and load a selected open-source LLM using Hugging Face Transformers.
• Inspect model configuration and tokenizer behaviour.
• Compare a base model with an instruction-tuned model.
• Prepare a small domain-specific instruction dataset in JSON or chat format.
• Clean and validate sample records and create training/validation splits.
• Review a model-adaptation plan and select an appropriate fine-tuning approach.

Tools: Python, Google Colab, PyTorch, Hugging Face Transformers, Hugging Face Datasets, Pandas and JSONL.

Practical output: Model-selection worksheet, prepared custom dataset and a ready-to-use training-data pipeline.

Day 2: Hands-On LLM Fine-Tuning, Model Alignment & Performance Evaluation

Session focus: Customize an open-source model using efficient fine-tuning methods, then assess the quality and performance of its outputs.

Topics covered

• End-to-end LLM fine-tuning workflow and training pipeline.
• Configure models using Hugging Face Transformers, PEFT, TRL and Unsloth.
• LoRA: rank, alpha, target modules and adapter configuration.
• QLoRA and 4-bit quantization for memory-efficient training.
• Introduction to DoRA and advanced adapter methods.
• Supervised Fine-Tuning (SFT) using custom instruction datasets.
• Training configuration: learning rate, batch size, epochs and gradient accumulation.
• Monitor training loss, validation behaviour and checkpoints.
• Introduction to preference optimization and Direct Preference Optimization (DPO).
• Model evaluation: task-specific benchmarks, perplexity and suitable text-generation metrics.
• LLM-as-a-Judge and human evaluation for response quality.
• Compare base and fine-tuned model outputs; identify hallucinations and common failure modes.
• Introduction to adapter management, model merging and quantization for inference.

Hands-on activities

• Load the selected model and configure LoRA or QLoRA.
• Run a guided supervised fine-tuning exercise using the Day 1 dataset.
• Monitor training progress and save adapter weights.
• Generate responses from the fine-tuned model.
• Compare base-model and fine-tuned outputs using a small evaluation set.
• Review a preference-optimization/DPO example and discuss when it is appropriate.

Tools: Transformers, PEFT, TRL, Unsloth, bitsandbytes, PyTorch, Hugging Face Evaluate and Google Colab.

Practical output: A fine-tuned model or adapter, training notebook, sample outputs and a model-evaluation comparison.

Day 3: Model Optimization, RAG Integration & Production LLM Deployment

Session focus: Prepare the customized model for practical use and connect it to a simple application, retrieval workflow or tool-based interaction.

Topics covered

• Preparing fine-tuned models for inference and deployment.
• Adapter merging, model export and quantization concepts: 4-bit, 8-bit and GGUF.
• Local model serving with Ollama and introduction to vLLM for high-throughput inference.
• Build an LLM-powered API using Python and FastAPI.
• Retrieval-Augmented Generation (RAG): architecture and when to use it with fine-tuning.
• Embeddings, semantic search and vector database fundamentals.
• Introduction to FAISS or Chroma for retrieval.
• Connect a customized LLM to external tools and APIs.
• Function calling, structured outputs and introductory Agentic AI workflows.
• LLMOps fundamentals: model versioning, monitoring and performance tracking.
• Deployment testing, data privacy, security and responsible AI considerations.

Hands-on activities

• Load a fine-tuned or instructor-provided model for inference.
• Explore a quantized model or deployment-ready model format.
• Build a simple FastAPI endpoint for model interaction.
• Connect the model to a small knowledge base using a guided RAG workflow.
• Demonstrate a basic tool-calling workflow where time and environment permit.

Test the final application with domain-specific prompts and review its limitations.

Tools: Hugging Face, Ollama, vLLM (demonstration where appropriate), FastAPI, FAISS or Chroma, Python and LangChain (optional).

Practical output: A working demonstration of a customized LLM application with an API and a basic RAG or tool-integration workflow.

Important Dates

Workshop Outcomes

Fee Structure