MLOps Bootcamp: Mastering AI Operations for Success - AIOps

Learn Python programming for MLOps through hands-on coding, complete a test, and boost your score above 80% to focus on gaps and apply Python skills to business use cases.

Discover how Python powers real-world ML and AI applications, from beginner-friendly syntax to rich libraries and a thriving community. Install and use a Jupyter notebook to start coding today.

Install Anaconda to enable Jupyter Notebook by downloading the Anaconda distribution for your operating system, running the straightforward installer with default settings, and completing the setup.

Launch the Anaconda Navigator, start Jupyter Lab, and run a hello world program in Python to validate your installation. Refer to the official docs or Q&A for help.

Master the Jupyter Lab quick tour by learning the interface, renaming notebooks, and using key shortcuts to execute and save cells, while understanding kernels.

Learn to create and modify variables in Python, assign values with the assignment operator, and use literals and common operators while following naming rules.

Explore variables, comments, and markdown cells through a hands-on Jupyter Lab session launched via Anaconda Navigator, saving notebooks in a dedicated folder and syncing code to GitHub.

Explore Python literals and core data types—integers, floats, complex numbers, booleans, strings, and collections (lists, tuples, dictionaries, sets)—using the type function to identify data types in MLOps context.

Explore Python operators, including arithmetic, comparison, and assignment, plus logical, bitwise, identity, and membership operators, with practical examples and notebook output behavior.

Explore Python strings as a core collection, including single-line and multi-line definitions with single, double, and triple quotes, and apply concatenation, repetition, membership, length, indexing, and slicing.

Explore Python strings through built-in functions like capitalize, isalnum, lower, upper, and strip. See how these string methods handle user input and prepare data for machine learning.

Explore the Python list as a mutable, ordered data structure that holds diverse types, demonstrates creation with square brackets, indexing, slicing, modification, and common operations like append and remove.

Learn how Python tuples are immutable, ordered collections created with parentheses, containing elements of various data types, and how to concatenate, repeat, index, slice, and measure length.

Explore Python dictionaries as mutable key-value stores, learn to create and access entries by keys, update values, and use built-in functions like keys, values, items, and len for MLOps projects.

Explore Python sets as unordered, mutable collections of unique elements, with no duplicates or indexing; create with curly braces, use membership tests, and apply set operations in data science, MLOps.

Explore implicit and explicit casting in Python, learning automatic type conversion and intentional conversions using int, float, and str, plus converting between lists, tuples, and sets.

Read user input with a built-in input function, display a prompt, and return a string, then convert inputs to the data type via explicit casting for operations like summing numbers.

Master string formatting in Python using dot format and f-strings to embed variables like x, y, and yes into placeholders. Compare clarity and conciseness to print formatted messages.

Explore Python conditional statements using if, elif, and else to execute code blocks based on whether conditions are true or false, including multiple branches.

Learn how Python loops automate repeated code execution with for and while loops, the difference between them, and how to control loops with break and continue.

Learn how Python list comprehension provides a concise way to create and transform lists, squaring elements and filtering even numbers with an expression for item in iterable.

Learn how to define and call functions in Python, including def, parameters, return values, and built-in functions, to create reusable, modular code for MLOps workflows.

Explore Python modules as .py files in the MLOps bootcamp, learn to create, import, and access functions and variables, and use built-in modules like math.

Explore Python classes and objects, including object oriented programming concepts, class attributes and methods, constructors, and the self parameter, and learn to instantiate objects and access or modify their attributes.

Learn Python file handling using open with modes r, w, x, a for text or binary, then read, write, and close files, including newline, tab, and backslash.

Learn to create, edit, and run Python scripts with a .py extension, using a script.py file to print hello world, and execute it from the Anaconda prompt or terminal.

Explore Python libraries as collections of modules that provide prewritten, reusable code for ml ops, including pandas for data loading and numpy, seaborn, and matplotlib for data science tasks.

Explore git, a distributed open source version control system that records changes to code, data and configuration files over time, enabling collaboration across teams, branching, CI/CD, and reproducible ML experiments.

Install git on your local system, verify with git version, and set up git bash on Windows or homebrew on macOS; then install VS Code to explore the course repository.

Learn to work with local and remote repositories, understand hosting services like GitHub, GitLab, and Bitbucket, and push code changes from your local repo to a remote repository.

Set up global git configuration by defining user name and email, and set the default branch to main, then verify settings with git config --global --list.

Learn how a local repository is represented by a hidden dot git folder, and initialize it with git init to store changes in version control.

Learn how to convert a project into a local repository with git init, and understand the working directory, staging area, and the commit, along with the commit history.

Master the git workflow in a local repository by turning an untracked file into a staged item with git add, then committing with git commit and checking status and log.

Learn how git uses branches as movable pointers to commits, create and switch branches like main and dev, and track history with git log and head pointers.

Learn how to switch branches in git using switch and checkout, move between main and development, and verify changes with status and log while committing v3.

Explore Git merging, including fast-forward merges and three-way merges, and learn how to combine changes from a feature branch into a main branch, creating a merge commit for divergent changes.

Learn to checkout commits in git by switching the working directory to a specific commit via its hash, manage head and detached head states, and heed uncommitted changes.

Explore git hosting services and learn to set up credentials on GitHub, generate a personal access token, and securely manage access for repositories.

Collaborate by using a remote repository as a central hub for pushing and pulling changes. Gain backup, redundancy, access control, and CI/CD integration with preserved version history.

Learn to clone a git repository, create and push a unit test branch to the origin, and delete branches locally and remotely.

Explore the three-way merge in git, including the common ancestor base commit, two branch tips, and how to resolve conflicts to produce a merge commit.

Master the fundamentals of git and version control, a distributed system for collaboration. Explore local and remote repositories, configuration, branching, merging, and three-way merges from an MLOps perspective.

Learn the basics of YAML, a human readable data serialization language for configuration files, covering syntax, indentation, maps, lists, scalar values, and multi-line strings.

Learn to package machine learning models with modular design, serialization, virtual environments, and Python packaging, and deploy end-to-end from data exploration to model building on a loan eligibility dataset.

Load and explore loan dataset in a Jupyter notebook, preprocess features, encode categoricals, apply log transformation, map the target, split data, and train a logistic regression model to assess accuracy.

Explore productionalizing machine learning models with virtual environments, requirements files, and serialization using joblib or pickle, and converting notebooks to modular Python scripts with tests using py test.

Master modular programming in python by creating packages and modules with __init__.py, organizing subpackages, and importing components for machine learning model deployment.

Master Python package management by finding, installing, and managing libraries with PyPI, pip, and virtual environments. Publish your package to PyPI using twine and manage dependencies with a requirements.txt file.

Learn to create a simple Python package from scratch, including folder structure, setup.py configuration, building a source distribution, and uploading to PyPI using twine in a virtual environment.

Build a reusable, portable ml model package with modular Python files for preprocessing, data handling, and configuration, and enable automation in packaging and testing with setup tools, manifest.in, and readme.md.

Build a data handling module that loads a dataset via config data path, cleans column names, drops loan id, splits features and target, and saves or loads the pipeline.

Build a production-ready sklearn pipeline for data loading, preprocessing, feature engineering, and logistic regression, using custom transformers for column operations and encoding.

Explore how a training pipeline loads data, splits train and test sets, applies domain processing and log transformation, fits a logistic regression model, and saves the trained model.

Explore the prediction pipeline by loading a classification pipeline, generating predictions from test data (test_data.csv), and labeling outputs as uproot or not uproot.

Execute the training pipeline to fit the model and save it as classification.pkl, then run the prediction script on test_data.csv to generate predictions. Validate the package structure.

Create a requirements.txt to list package names and exact versions, enabling consistent collaboration; export installed package versions with pip freeze and prepare a virtual environment for reproducible AI operations.

Learn how to reproduce a machine learning training pipeline by creating and activating a new virtual environment, installing dependencies from requirements.txt, and running the training script to save the model.

Master pytest, a versatile Python testing framework, by exploring its intuitive syntax, fixtures, parameterization, marks, and plugins to streamline test setup, execution, and reporting.

Develop and run basic pytest tests by implementing a simple add(x, y) function and validating a Flask app endpoint to illustrate automated testing in a practical MLOps context.

Learn how pytest fixtures set up the testing environment with the fixture decorator, as shown in calculator add and subtract tests, and see fixtures in action in MLOps workflows.

Create and run Python tests for ml projects by using pytest to validate predictions, check non-None outputs, and ensure numpy int64 results with a test fixture.

Configure manifest.in to include all project files in the source distribution by using include patterns, recursive include, and exclude rules for data sets, models, and scripts.

Create a version file inside the prediction_model folder, set version to 1.0.0 following major.minor.micro, read it into __version__ on import, and prepare to include it in the manifest and setup.

Create a setup.py to package a python project with setuptools, read dependencies from requirements.txt and the version from a version file, and use README for long description.

Explore MLflow, an open source platform for managing the machine learning lifecycle, including tracking experiments, packaging code, deploying models, and maintaining a centralized model registry.

Create and activate a conda-based python 3.10 environment, install mlflow, and launch the mlflow ui to track experiments, runs, and custom columns on localhost:5000.

Explore MLflow tracking, an API and UI, that logs parameters, code versions, metrics, and artifacts for experiments, using set tracking uri and start run.

Explore MLflow tracking basics by creating a dummy script of demo.py that logs two inputs as parameters, a computed metric, and an artifact. See the MLflow UI for results.

Log experiments with MLflow by running demo scripts, set an experiment, and track metrics, parameters, and artifacts; compare runs and explore tags to organize AI experiments.

Create a basic machine learning model in Python, load data from a URL, train an elastic-net regressor, and track experiments in MLflow by logging parameters, metrics, and the trained model.

build a loan prediction model in python, train logistic regression, random forest, and decision tree, and log results, grid search tuning, and artifacts with mlflow.

Package code and dependencies with MLflow projects to enable reproducible, reusable runs across platforms, storing and logging runs in a SQL database via GitHub repositories, Conda environments, and entry points.

Package models with mlflow to support Python function, scikit-learn, and Spark MLlib formats. Log models with mlflow, creating a directory containing conda.yaml, model.pkl, and requirements.txt for reproducible predictions.

Set up a local MySQL environment for MLflow by installing the MySQL community server and MySQL Workbench, configuring a root password, and connecting through Workbench to manage MLflow data.

Log model metrics to a local MySQL server with MLflow, explore the model registry's registered models, versions, and stages via the MLflow UI.

Register and manage MLflow models, version them, and move between staging and production, then serve the chosen version with MLflow model serve using the correct tracking uri.

Explore MLflow’s role in the machine learning lifecycle, including experiment tracking, deployment of models, MySQL logging, GitHub project execution, and a centralized model registry for version management.

Learn how Docker packages code and dependencies for machine learning projects into containers, enabling repeatable deployments across development, staging, and production environments, with container communication and DevOps benefits.

Learn how Docker uses OS virtualization to package apps into lightweight containers with all dependencies, enabling portable, isolated deployment across environments.

Download and install Docker Desktop for Mac, Windows, or Linux from docker.com, enable the Windows WSL2 backend, and verify with docker --version.

Install and verify Docker locally, pull hello world and BusyBox images, run containers, and list images and containers with Docker images and Docker ps.

Deploy a web app from the docker hub image manifold learning/cat gif by running in detached mode, mapping host ports to container 5000, and using docker ps and docker stop.

Build and run a flask app with a dockerfile using a python 3.8 base, copy files, install dependencies from requirements.txt, expose port 5000, and run app.py.

Log into docker, tag the built image, and push it to docker hub, then verify the push on the docker registry and prepare for pulling and sharing.

Explore what an api is, a software gateway that exposes a machine learning application's capabilities to users, and how rest api uses http to build web services.

Explore how rest api treats every entity as a resource identified by a uri and uses http methods like get and post to enable stateless communication with json responses.

Explore FastAPI, a modern, high-performance Python web framework for building RESTful APIs with minimal code, automatic API documentation, type-hinted validation, async support, and secure, extensible integrations for machine learning apps.

Master a crash course on fast api by setting up a virtual environment, installing dependencies, building a fast api app, and using uvicorn with Swagger UI docs.

Learn to validate and parse incoming data for machine learning deployments using the Pydantic library, ensuring right data formats and custom validation for RESTful APIs.

Deploy a machine learning model with FastAPI by loading the trained pipeline, shaping input as a single-row data frame, and exposing loan-application predictions on port 8080.