MLOps Training & Certification

Introduction to Linux

Exploring the fundamentals of the Linux operating system.

Linux Distributions and Architecture

Understanding different distributions and the architecture of Linux.

Command Line Interface (CLI) & Filesystem

Mastering the CLI and navigating the Linux filesystem.

File Management and vi Editor

Managing files and editing them using the vi editor.

Archives and Package Management

Utilizing tar, zip utilities, and managing packages in Linux.

System Installation and Package Managers

Installing software on Ubuntu, using .deb files, and the APT package manager.

Users, Groups, and Permissions

Managing users and groups, and configuring permissions.

Networking Basics: IP Address, Protocols, & Ports Introduction to networking in Linux: IP addresses, protocols, and ports.

Firewalls and Security Measures

Configuring firewalls and understanding basic security measures. Load Balancers

Basics of load balancing in a Linux environment for optimizing performance and reliability

Introduction to Version Control System

Basics of version control and its importance in software development.

Centralised vs Distributed Version Control System

Differences between centralized and distributed systems, with a focus on their advantages and use cases.

Git & GitHub Introduction

Overview of Git and GitHub, and how they revolutionize code management and collaboration.

Git Workflow

Understanding the standard workflow in Git, including stages of code changes and commit practices.

GitHub for Collaboration

Using GitHub features for project collaboration, including issues, forks, and pull requests.

Git Branching Model

Strategies for branching in Git, including feature branches and the master branch.

Git Merging and Pull Requests

Techniques for merging branches and the role of pull requests in collaborative projects.

Git Rebase

Understanding rebase, its advantages, and how it differs from merging.

Handling Detached Head and Undoing Changes

Managing a detached HEAD in Git and various ways to undo changes.

Advanced Git Features: Git Ignore, Tagging

Utilizing .gitignore for excluding files from tracking, and tagging for marking specific points in history.

Introduction to Containerisation

Essentials of container technology and its impact on software development.

Monolithic vs Microservices Architecture

Comparison between traditional monolithic and modern microservices approaches.

Introduction to Virtualisation and Containerisation

Basic concepts of virtualisation and how containerisation offers streamlined deployment.

Docker Architecture

Key components and structure of Docker's system architecture.

Setting up Docker

Guidelines for Docker installation and initial setup on various platforms.

Docker Registry, Images, and Containers

The roles and relationships between Docker Registry, images, and containers.

Running Docker Containers

Fundamentals of managing Docker containers' lifecycle.

Docker Volumes and Networks

Using Docker volumes for data persistence and networks for inter-container communication.

Docker Logs and Tags

Techniques for handling Docker logs and utilizing tags for image management.

Dockerize Applications and Docker

Strategies for containerizing applications and orchestrating with Docker Compose.

Introduction to CI/CD & Github Actions

Basics of Continuous Integration, Continuous Deployment, and how GitHub Actions facilitates

CI/CD within the GitHub repository ecosystem.

Benefits and Requirements of CI/CD

Advantages of CI/CD and what's needed to implement it successfully, emphasizing GitHub's role in version control and collaboration.

Setting Up GitHub Actions

Creating and configuring workflows using YAML files in a GitHub repository.

Build Tools and Repository Management

Overview of build tools (e.g., Make, Gradle, npm) and how GitHub Actions integrates with GitHub repositories for CI.

Workflow Configuration

Defining jobs and steps within a GitHub Actions workflow to automate build, test, and deployment tasks.

Automating with Workflow Triggers

Using events like code pushes, pull requests, or schedules to trigger CI/CD workflows automatically.

GitHub Actions Workflows

Creating workflows that orchestrate CI/CD pipelines, including building, testing, and deploying code.

Utilizing Actions and Reusable Workflows

Leveraging pre-built actions from the GitHub Marketplace and creating custom actions for specific tasks. Creating reusable workflows to modularize CI/CD processes.

Continuous Deployment with GitHub Actions

Strategies and examples of deploying applications to various environments (e.g., staging, production) using GitHub Action

Introduction to High Availability

Understanding the importance of high availability in systems design.

Introduction to Container Orchestration

Exploring the concept and need for container orchestration.

Container Orchestration

Overview of tools available for container orchestration, including Kubernetes.

Overview of Kubernetes

Introduction to Kubernetes and its role in container orchestration. Kubernetes Architecture

Understanding the architectural components of Kubernetes. Components of Kubernetes

Detailed look at core Kubernetes components, including master and node components.

Kubernetes Objects

Introduction to the fundamental objects in Kubernetes.

Types of Machine Learning:
Supervised (Classification, Regression)

Unsupervised (Clustering, Dimensionality Reduction)

Reinforcement Learning (Brief Overview)

Common Algorithm Families & Use Cases:
Linear Models, Tree-Based Models (Random Forest, Gradient Boosting)

Neural Networks basics. Focus on input/output expectations.

The Model Training Loop:
Features & Labels, Data Splitting (Training, Validation, Test sets - importance of hold-out sets)

Loss Functions, Optimization Algorithms (e.g., Gradient Descent)

Model Evaluation:
Key metrics for Classification (Accuracy, Precision, Recall, F1-Score, AUC)

Regression (RMSE, MAE, R-squared)

Why standardized evaluation is critical for automated MLOps pipelines.

Data as Foundation: Understanding the impact of data quality, volume, and relevance on model performance.

Data Acquisition & Storage:
Overview of sources (Databases, Data Lakes, APIs) and formats.

Feature Engineering:
Creating meaningful inputs for models.

How feature engineering choices impact deployment complexity.

Data Preprocessing & Scaling:
Techniques (Normalization, Standardization, Encoding).

Need for consistency between training and inference preprocessing.

Identifying & Preventing Data Leakage:
Understanding how information from the test set can inadvertently influence training.

Model Serialization:
Saving trained models (formats like Pickle, joblib, SavedModel, ONNX).

Pros and cons regarding compatibility and deployment.

Model Signatures & Schemas:
Defining expected input and output formats.

Environment Dependencies:
Capturing required libraries and versions (Python, OS packages).

Underscoring the need for tools like Conda and Docker.

Model Versioning:
The necessity of tracking different iterations of trained models.

Model Size & Inference Performance:
Understanding the trade-offs between model complexity, prediction speed, and resource consumption.

Introduction: Moving Beyond Ad-hoc ML.

Core MLOps Principles:
Automation, Reproducibility, Collaboration, Continuous Monitoring, Governance.

Overview of the Lifecycle Stages:
From Data to Production and Back. Key Differences from Traditional SDLC.

ML Development & Experimentation:
Business Understanding, Data Prep, Feature Engineering, Model Training/Tuning.

MLOps Integration:
Code Versioning (Git), Experiment Tracking Setup, Environment Definition.

Training Operationalization (Continuous Training - CT): Packaging Code/Env (Docker), Automated Training Pipelines.

Data/Model Validation in Pipelines, Experiment Tracking Integration.

Output: Registered Model Candidate.

Model Validation & QA:
Automated Testing (Performance, Robustness).

Responsible AI Checks (Fairness, Explainability), Staging Environments, Quality Gates.

Model Deployment (Continuous Deployment - CD): Packaging for Inference, Defining Deployment Infrastructure (IaC).

Automated Deployment Pipelines, Deployment Strategies (Blue/Green, Canary).

Prediction Serving:
Real-time APIs vs. Batch Inference execution.

Monitoring & Feedback Loop:
System Health Monitoring, Model Performance Monitoring.

Data/Concept Drift Detection, Logging, Alerting, Triggering Retraining.

Iteration & Governance:
Continuous Improvement, Model Lineage Tracking, Compliance.

The Challenge: Managing the Complexity of ML Development.

What is MLflow? An Open Platform for the ML Lifecycle.

MLflow's Core Philosophy: Open Source, Framework Agnostic, API-first.

Overview of MLflow Components (Tracking, Projects, Models, Registry).

Core Concepts: Experiments, Runs, Parameters, Metrics, Artifacts (files, plots, models), Tags.

Logging to MLflow: Using the Client API (Python, R, Java, REST) and CLI.

The Tracking Server: Storing run data (local files, SQLAlchemy compatible DB, remote server).

The MLflow UI: Visualizing, comparing, and searching runs and experiments.

Autologging capabilities for popular libraries.

Standardizing Code Execution: Packaging ML code for reproducibility.

The MLproject File: Defining entry points and environment dependencies (Conda, Docker).

Running Projects: mlflow run command (local execution, remote execution e.g., on Databricks).

Parameterizing runs.

Standard Model Format: Packaging models for downstream use.

Model Flavors: Framework-specific formats (e.g., python_function, scikit-learn, TensorFlow, PyTorch, ONNX).

Saving and Loading Models with MLflow.

Built-in Deployment Tools (e.g., local REST server, Spark UDF creation).

Centralized Model Management: Storing, versioning, and governing models.

Key Concepts: Registered Models, Model Versions, Stages (Staging, Production, Archived), Annotations & Descriptions.

Workflow: Registering models, transitioning stages, fetching specific model versions/stages.

What is Kubeflow? The ML Toolkit for Kubernetes.

Why Kubeflow? Solving Portability, Scalability, Composability on K8s.

Architecture: Running as applications/operators on Kubernetes.

Use Cases: End-to-end orchestration, hybrid/multi-cloud ML.

Kubeflow Pipelines: Building, deploying, managing ML workflow DAGs (Python SDK, UI).

KServe (KFServing): Standardized, scalable Model Serving on Kubernetes (Serverless inference, traffic splitting).

Training Operators: Simplifying distributed training (TFJob, PyTorchJob, etc.).

Katib: Automated Hyperparameter Tuning and NAS.

Notebooks: Managed JupyterLab environments integrated with the cluster.

Metadata (MLMD): Artifact and lineage tracking backend.

Other Components (Central Dashboard, Security features).

Installation Overview: Complexity and distribution options.

Interacting with Components (UI, SDKs, kubectl).

Example Workflow: Building a simple pipeline, deploying a model with KServe.

Positioning vs. Managed Services (e.g., Azure ML, SageMaker, Vertex AI): Control vs. Convenience trade-offs.

Challenges: Learning curve, operational overhead.

What is Databricks? Unified platform for Data Engineering, Data Science, and ML.

Key Concepts: Workspaces, Notebooks, Clusters, Databricks File System (DBFS), Delta Lake, Jobs.

Databricks Machine Learning Runtime: Optimized environment with pre-installed libraries.

MLflow as a Managed Service: Hosted Tracking Server & Model Registry per workspace.

Seamless Integration: No separate setup required.

Automatic Logging (Autologging): Simplified tracking for common ML frameworks within Databricks notebooks and jobs.

UI Integration: Accessing MLflow Experiments and Model Registry directly within the Databricks UI.

Tracking from Notebooks and Jobs: Automatic linking of runs to notebook revisions or job IDs.

Managed Model Registry Features: UI-driven workflows, webhooks, integration with Databricks Model Serving.

Databricks Model Serving: Deploying registered MLflow models as scalable REST endpoints (Serverless Real-Time Inference).

Integration with Delta Lake: Tracking data lineage, using Delta tables as data sources.

Integration with Databricks Feature Store: Tracking features used in model training.

Collaboration Features: Sharing experiments and models within the workspace.

Comparison: Managed Databricks MLflow vs. Open Source MLflow deployment.

Introduction to Prometheus

Basics of Prometheus and its role in the monitoring landscape.

Prometheus Architecture

Understanding the components and architecture of Prometheus.

Monitoring with Prometheus

Setting up Prometheus for monitoring infrastructure and application

Scraping Metrics with Prometheus

Techniques for scraping and collecting metrics from various targets.

Prometheus YAML Configs and Node Exporter

Configuring Prometheus and using Node Exporter to gather system

Introduction to Visualization with Grafana

Understanding the importance of data visualization in observability.

Installing Grafana on a Linux Server

Step-by-step installation of Grafana for setting up monitoring

Grafana User Interface Overview

Navigating through Grafana's UI and understanding its features.

Creating Grafana Dashboards

Techniques for creating insightful and interactive dashboards i

Grafana with Docker

Deploying Grafana within Docker containers for flexible and scalable monitoring solutions.

Integrating Prometheus and Grafana

Techniques for integrating Prometheus with Grafana to visualize

Alerting with Prometheus

Setting up alert rules in Prometheus and integrating with notification

Log Management and Analysis

Introduction to log management solutions and integrating them with monitoring tools for full observability.

Tracing and Distributed Tracing Understanding tracing and distributed tracing for in-depth insights

Cloud Monitoring Solutions

Overview of cloud-native monitoring and observability solutions

Python as a Scripting Language

Overview of Python and its use as a powerful scripting language.

Python Collections and Sequences

Introduction to Python's data structures: lists, dictionaries, sets, and tuples, for organizing and storing data.

Working with Python Collections

Practical exercises on manipulating lists, dictionaries, sets, and tuples.

Python Functional Programming

Understanding functional programming paradigms in Python, including lambda functions, higher-order functions, and list comprehensions.

Python File Handling

Techniques for reading from and writing to files in Python scripts, including working with CSV and JSON files.

Python Modules and Packages

Utilizing modules and packages to organize and reuse code efficiently. Includes creating custom modules and using the Python Package Index (PyPI).

Classes in Python

Fundamentals of defining and using classes in Python. Includes inheritance, encapsulation, and polymorphism.

Object-Oriented Programming (OOP) in Python

Exploring Python's OOP features, including magic methods and class attributes, for more complex script development.

Exception Handling

Techniques for handling and raising exceptions to manage errors gracefully. Includes try...except blocks, finally clauses, and custom exceptions.

Python Decorators and

Leveraging decorators to modify function behavior and generators for efficient iteration.

Automation through Scripting Languages

The role of scripting languages like Python in automation efforts.

Automating File System Operations

Using Python scripts to manage file and directory operations, including copying, moving, and deleting files.

Web Scraping with Python

Techniques for extracting data from web pages using Python libraries like Beautiful Soup and Scrapy.

Automating Network Tasks

Scripting network operations for automation with Python libraries, including Paramiko and Netmiko.

Automating API Interactions

Using Python libraries like Requests to interact with and automate tasks using APIs. Includes handling authentication and API pagination.

Building Python

Best practices and methodologies for developing robust Python applications, including using frameworks like Flask and Django.

Testing Python Applications

Introduction to unit testing and test automation in Python using libraries like pytest and unittest.

Python Application Deployment

Strategies for deploying Python applications, including web and standalone applications, using tools like Docker and Kubernetes.

CI/CD for Python Applications

Implementing Continuous Integration and Continuous Deployment workflows for Python projects using tools like GitHub Actions and Jenkins.

Virtual Environments and Package Management\

Managing Python environments and dependencies using tools like virtualenv, conda, and pip for project isolation and reproducibility.

Python in CI/CD Pipelines

Integrating Python scripts and applications in CI/CD workflows.

Automating Builds and Tests with Python

Using Python for automated testing, including unit tests, integration t

Python for Deployment Automation

Version Control Automation with

Scripting deployment processes, including application packaging, distribution, and configuration management.

Monitoring and Logging with Python Version Control Automation with

Implementing monitoring and logging solutions in Python

Version Control Automation with

Automating version control workflows with Git using Python libraries

Introduction to Generative AI

1. What is Generative AI?

2. Key Applications:

Text (ChatGPT, Claude, LLaMA)

Images (DALL·E, MidJourney, Stable Diffusion)

Audio (Music Generation, Voice Cloning)

Code (GitHub Copilot, Cursor)

3. Evolution of GenAI:

Rule-Based → Deep Learning → Transformers

GANs vs. VAEs vs. LLMs

1. Effective Prompt Design

Instruction-Based, Few-Shot, Zero-Shot

2. Advanced Techniques:

Chain-of-Thought (CoT) Prompting

Self-Consistency & Iterative Refinement

Hands-on:

Transformer Architecture

1. Why Transformers? (Limitations of RNNs/LSTMs)

2. Key Components:

Self-Attention & Multi-Head Attention

Encoder-Decoder (BERT vs. GPT)

3. Evolution: BERT → GPT → T5 → Mixture of Experts

4. Large Language Models (LLMs)

5. Pre-training vs. Fine-tuning

6. Popular Architectures:

GPT-4, Claude, Gemini, LLaMA 3

BERT (Encoder-based) vs. T5 (Text-to-Text

Introduction to AI Agents

1. What are AI Agents?

2. vs. Traditional AI:

3. Applications:

AI Agent Frameworks

1. CrewAI (Multi-Agent Collaboration):

2. n8n (Workflow Automation):

Designing AI Agents

CrewAI + n8n: Automating Business Workflows

Multi-Agent Systems: Collaboration & Specialization

Real-World Applications

Case Studies:

AI Customer Support Agents