Skip to Content
View all events

MLOps/LLMOps Bootcamp

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Scale, automate, and deploy AI

Course outcomes

  • Set up reproducible ML projects using Git for code version control, ensuring clear collaboration and experiment tracking
  • Implement ML model versioning and experiment logging (e.g., with MLflow) to manage multiple model iterations effectively
  • Containerize and deploy ML models using Docker, creating consistent environments from development to production
  • Automate ML workflows with continuous integration and deployment (CI/CD), streamlining model updates and reducing errors
  • Leverage Kubernetes to scale and orchestrate containerized ML services, ensuring high availability under changing loads
  • Apply advanced model monitoring and A/B testing strategies to maintain performance and quickly detect issues in production
  • Operationalize large language models (LLMOps), handling infrastructure, fine-tuning strategies, and performance optimization for next-generation AI
  • Integrate end-to-end MLOps practices to build robust, scalable pipelines that handle real-world data, model drift, and iterative improvements

Course description

In today’s AI-driven applications, building a great model is only the beginning, operationalizing that model (and maintaining it in production) is the real challenge.

Join expert Ammar Mohanna to get a unified, high-level understanding of end-to-end machine learning operations (MLOps), from version-controlling your ML code and tracking experiments to automating pipelines, deploying at scale with containers and Kubernetes, and monitoring models in production. You’ll also learn about LLMOps, the emerging best practices for operationalizing large language models. Over two intensive days, you’ll progress through MLOps foundations, applied MLOps, and advanced MLOps topics, gaining both the conceptual knowledge and practical skills to implement reliable ML pipelines. Expect a mix of lectures and live demonstrations of tools like Git, MLflow, Docker, Kubernetes, and more. You’re encouraged to follow along with the coding exercises to build confidence, but you can also simply watch the demonstrations if you prefer.

NOTE: With today’s registration, you’ll be signed up for both sessions. Although you can attend either of the sessions individually, we recommend participating in both.

What you’ll learn and how you can apply it

  • Learn the stages of taking a model from development to production and the key challenges where MLOps practices are applied
  • Use tools like Git for code and MLflow for experiment tracking to ensure reproducibility and collaborative workflow in ML development
  • Package ML models and their dependencies using Docker, and understand how container orchestration (with Kubernetes) enables scalable and consistent deployments in different environments
  • Automate the testing, integration, and deployment of ML models using continuous integration/continuous deployment practices and tools (e.g., Jenkins, GitHub Actions) tailored for machine learning
  • Implement monitoring solutions to track model performance (accuracy, data drift, etc.) and logging to catch errors or anomalies, ensuring models remain reliable over time in production
  • Design machine learning systems that can handle large-scale data and traffic, including using distributed computing frameworks (like Apache Spark) and advanced Kubernetes techniques for high availability and autoscaling
  • Leverage A/B testing or multi-arm bandit experiments to compare model versions, and establish workflows for continuous improvement (automated retraining, model versioning, and governance)
  • Understand the unique operational challenges of deploying and maintaining LLMs (such as GPT-like models), and learn strategies to integrate LLMs into your MLOps pipeline, including fine-tuning, inference optimization, and managing data for LLMs
  • Synthesize version control, pipelines, CI/CD, containerization, monitoring, and LLMOps techniques into an end-to-end project, demonstrating the ability to manage the full lifecycle of ML models in real-world scenarios

This live event is for you because...

  • You’re a data scientist, ML engineer, DevOps engineer, or software engineer with experience in building ML models, and you need to learn how to deploy and manage those models in production environments reliably.
  • You work with machine learning or AI projects and find it challenging to transition from the prototyping stage (for example, in Jupyter notebooks) to a scalable, maintainable production system.
  • You want to become an MLOps specialist (or improve your ML engineering prowess) by mastering the tools and practices that integrate ML into the software development lifecycle, including emerging LLMOps techniques for large language models.
  • You’re interested in bridging the gap between model development and operations, especially how to handle the new wave of AI models like GPT-4 in production.

Prerequisites

  • A computer with Git installed
  • Docker Desktop (or Docker Engine) installed, set up, and running (if you want to try the containerization demo yourself)
  • Basic Python programming and ML familiarity
  • Prior exposure to training models in Jupyter notebooks or scripts recommended
  • The ability to run simple commands in a terminal on your operating system

Recommended preparation:

  • Familiarize yourself with basic Git commands (git clone, git pull) to retrieve updates (Optional) Install a local single-node Kubernetes solution like Minikube or KIND (if you wish to experiment with Kubernetes hands-on)
  • Clone the course GitHub repository and read the README before the course or at the start of the workshop https://github.com/AmmarMohanna/oreilly-mlops-bootcamp
  • Test that you can run a Jupyter notebook and execute a simple Python script in your environment
  • Verify Docker is installed correctly (e.g., run docker --version) to avoid technical issues during the live sessions

Recommended follow-up:

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

Day 1: MLOps Foundations

Introduction to MLOps and LLMOps (45 minutes)

  • Presentation: Overview of the ML lifecycle and production challenges; where LLMOps fits—unique operational considerations for large language models
  • Group discussion: Challenges in deploying ML models

Version control with Git (55 minutes)

  • Presentation: Best practices for managing ML code, notebooks, and model versions in a team
  • Hands-on exercises: Initializing a Git repo, creating branches, and committing changes
  • Break

Experiment tracking (45 minutes)

  • Presentation: Importance of logging hyperparameters and metrics for reproducibility; introduction to MLflow for experiment tracking
  • Hands-on exercises: Training a simple model, recording parameters/results, comparing experiments using MLflow

Containerization basics with Docker (50 minutes)

  • Presentation: How Docker containers create consistent environments across dev/prod
  • Hands-on exercises: Building and running a Docker image for a basic ML inference service (e.g., Flask API plus trained model)
  • Break

Designing end-to-end ML pipelines (35 minutes)

  • Presentation and demonstration: Data ingestion, training, validation, deployment, and monitoring; simple Python or MLflow pipeline from data prep to model artifact

CI/CD for machine learning (40 minutes)

  • Presentation and demonstration: Continuous integration and deployment concepts for ML (testing data changes, retraining triggers); using GitHub Actions to test and deploy a model automatically

Wrap-up and Q&A (30 minutes)

Day 2: Applied MLOps

LLMOps spotlight—part I (15 minutes)

  • Presentation: Incorporating LLMs into your pipelines (text generation or Q&A); model checkpoints, GPU requirements

Orchestrating ML workloads with Kubernetes (55 minutes)

  • Presentation and demonstration: Deploying containerized ML services at scale (Pods, services, scaling); deploying the Dockerized ML model to a local K8s cluster
  • Break

Model monitoring and logging (30 minutes)

  • Presentation: Monitoring data drift, performance metrics, alerting; LLMOps—specialized metrics (e.g., perplexity); user feedback loops

Scaling ML systems (35 minutes)

  • Presentation: Challenges with high-throughput inference, big data, or multimodel serving; LLMOps—resource management for GPU/TPU clusters
  • Break

Advanced Kubernetes for ML deployments (30 minutes)

  • Presentation and demonstration: High availability, auto-scaling, resource quotas; simulating load on an ML API and using a horizontal pod autoscaler

ML workflow orchestration (20 minutes)

  • Presentation: A deeper look at Kubeflow Pipelines or Apache Airflow; LLMOps—pipeline steps for prompt engineering or fine-tuning tasks

Advanced experimentation (A/B testing and model validation) (35 minutes)

  • Presentation and demonstration: Canary releases, multi-armed bandit strategies, safe rollout; deploying two model versions and tracking performance
  • Break

LLMOps spotlight—part II (15 minutes)

  • Presentation: Operational challenges for LLMs: memory footprint, GPU scheduling, user feedback
  • Group discussion: How LLM deployment differs from smaller models

Model lifecycle management and governance (15 minutes)

  • Presentation: Model registries, provenance, retraining triggers, and compliance; multiple versions of large language models; checkpoint management

Integrating MLOps end-to-end (20 minutes)

  • Demonstration: Updating a model with new data, building a Docker image, deploying to K8s; small LLM update scenario (partial fine-tuning or inference pipeline)

Wrap-up and Q&A (30 minutes)

Your Instructor

  • Ammar Mohanna

    Ammar Mohanna is a seasoned AI expert, educator, and entrepreneur with extensive experience spanning academia, industry consulting, and technology innovation. He teaches advanced courses in AI and machine learning at the American University of Lebanon, helping shape the next generation of AI professionals. As a consultant, Ammar leads initiatives focused on integrating AI and generative AI into educational technologies, collaborating closely with cloud technologies. Previously, Ammar cofounded and was AI lead at Assentify, a company dedicated to providing specialized AI solutions, training, and consultancy. His professional expertise includes machine learning, MLOps, explainable AI (XAI), Kubernetes, and microservices architecture. He holds a PhD in edge artificial intelligence from the University of Genoa, Italy. Ammar lives in Beirut, Lebanon, and is fluent in Arabic, English, and French, with intermediate proficiency in Italian.

Skill covered

MLOps