Beginner to Advanced MLOps on GCP-CI/CD, Kubernetes Jenkins

Introduce a hotel reservation prediction ML project in an MLOps course, covering data ingestion, model training, MLflow experiments, versioning, a Flask UI, and CI/CD deployment with Jenkins on GCP.

Learn the first step of MLOps: database setup with GCP buckets. Create a globally unique bucket, upload the CSV, untick public access, and rename to remove spaces.

Create a self-contained mlops project by establishing a venv, managing dependencies with requirements.txt and setup.py, and organizing code in src with logger and custom exception support.

Learn to ingest data from a gcp bucket into a local project using service accounts, configure yaml, split into train and test sets, and prepare raw, train, and test artifacts.

Explore Jupyter notebook testing in VSCode, install the ipynb kernel, run data prep and EDA, apply label encoding and SMOTE, compare classifiers, and choose lightweight models like LightGBM for production.

Learn to implement data processing in an MLOps pipeline by loading CSV data, applying label encoding, handling skewness and imbalance, selecting features, and saving processed train and test CSVs.

Learn to train a lightgbm model and track experiments with mlflow, combining model training, hyperparameter tuning, evaluation metrics, and saving artifacts for end-to-end mlops.

Develop and run a training pipeline by building it as a package and importing data ingestion, preprocessing, and model training, then enable data and code versioning with GitHub.

Build an interactive hotel reservation prediction app with Flask and HTML forms, leveraging ChatGPT for styling, loading a model with Joblib, and rendering results via a Jinja2 template.

Automate end-to-end ci/cd deployment with Jenkins to Google Cloud Run by integrating GitHub, dockerizing the project, setting up virtual environments, and pushing images to GCR.

Learn to build an animated anime recommender system with MLOps on GCP, covering content-based, user-based, and hybrid approaches, selective data ingestion, end-to-end workflow, and Kubernetes CI/CD deployment with Jenkins.

Create a GCP bucket for the MLOps project two, upload the extracted data files—anime list, anime, and anime with synopsis—and proceed to the project setup.

Set up an MLOps project by creating and activating a virtual environment, preparing requirements and setup.py, and organizing src, artifacts, pipeline, config, utils, templates, and static directories.

Master data ingestion for a GCP-based MLOps project by setting up Google Cloud CLI, service accounts, and config files to selectively ingest three CSV files into a raw artifacts directory.

Build and test a Jupyter notebook workflow for an MLOps recommender from scratch, covering environment setup, IP kernel installation, TensorFlow Keras model creation, data encoding, and training with callbacks.

Explore user-based recommendations, collaborative filtering, and a hybrid recommender system in a Jupyter notebook, blending get user preferences, find similar users, and content-based enhancements for gcp-ci/cd and kubernetes jenkins.

Build a modular data processing pipeline in Python for MLOps, handling loading, filtering, scaling, encoding, and splitting, then saving artifacts with joblib to organized output paths.

Develop and train a model architecture from config.yaml, specify embedding size, loss, optimizer, and metrics; implement base model, load data, apply callbacks, and save weights and model artifacts.

Set up comet ml for online experiment tracking, initialize with API key, project name, and workspace, and log training and validation losses per epoch along with model weights and artifacts.

Build a training pipeline that combines data ingestion, processing, and model training, using DVC artifacts and GCP buckets, while removing data ingestion to save time.

Version data with DVC and code with GitHub by setting a GCP bucket as the DVC remote, then push and pull artifacts for reproducible data integrity using MD5 hashes.

Build and organize helper functions in a MLOps project, loading data via paths, converting csvs to data frames, and implementing get anime frame, get synopsis, and user recommendation functions.

Build a Flask-based user interface for the MLOps prediction pipeline, wiring inputs and hybrid recommendation logic, with ChatGPT-generated HTML, tested and prepared for deployment via CI/CD and Kubernetes.

Learn to implement CI/CD on Google Kubernetes with Jenkins, dockerizing projects, wiring GitHub, building and pushing images to GCR, and deploying scalable apps to a GCP Kubernetes cluster.

Explore an end-to-end Titanic survival prediction project, building ETL pipelines with Astronomer Airflow, feature store with RedisAI, and ML monitoring for data drift and concept drift using Prometheus and Grafana.

Set up a Google Cloud bucket, upload the Titanic CSV, and create a service account with owner, storage object admin, and storage object viewer roles, plus a JSON key.

Set up the MLOps project by creating a virtual environment, configuring requirements and setup.py, building a src package with logger and custom exception, and organizing config and pipeline folders.

Create an ETL pipeline that extracts data from a GCP bucket, transforms CSV to SQL, and loads it into PostgreSQL using Astro Airflow and Docker.

Ingest data from a PostgreSQL database using psycopg2, configure db and path settings, and perform train-test split before saving Titanic data to CSV in the raw directory.

Conduct Jupyter notebook testing with the Titanic dataset, perform preprocessing and feature engineering, handle imbalance, train a tuned random forest, and preview future ETL, feature store, and Grafana Prometheus monitoring.

Build a Redis-backed feature store in a Docker environment, implementing store, get, batch store/get, and entity IDs management with JSON for MLOps workflows.

Build a modular data processing pipeline that loads and preprocesses data, handles imbalance, and stores features in a Redis feature store for verification.

Learn model training with feature extraction by loading data from a feature store (Redis), performing train-test split, tuning a random forest with RandomizedSearchCV, and saving the best model.

Build a training pipeline with data ingestion, data processing, and model training, with import fixes and logs; then set up data and code versioning with git, GitHub, and Docker.

Build the user app UI with a Flask backend, integrate an index.html using templates and a static CSS, and implement a predict route that loads a model and displays results.

Learn to perform data drift detection using lib detect, comparing scaled reference data from a feature store with current data, applying ksd drift, and logging drift events for mlops workflows.

Set up and bridge Grafana and Prometheus with Docker to monitor ML metrics, including custom drift and prediction counters via a Flask app and a metrics endpoint.

This project teaches building a gun-detection object detector with PyTorch, using a custom DVC training pipeline, TensorBoard tracking, Kaggle data, and a FastAPI API tested via Postman.

Set up a complete MLOps project from scratch by creating a venv, configuring dependencies with requirements.txt and setup.py, organizing src and config packages, and preparing for API-driven, customized training pipelines.

Learn to ingest data from Kaggle Hub by downloading the guns object detection dataset, extracting images and labels to artifacts/raw, and running a Python data ingestion pipeline.

Test Jupyter notebooks for a gun object-detection MLOps project on Kaggle GPUs using OpenCV, PyTorch, and torchvision Faster R-CNN, with bounding boxes, visualization, and NMS.

Apply modular data processing in an MLOps workflow using torch and OpenCV Python headless, with a Gun data set class, logger, and custom exception to load images and labels.

Define and implement a Faster R-CNN model architecture using Torchvision in a modular MLOps setup, including initialization, compiling with Adam, training loop, and device handling.

Define and train a faster R-CNN model for gun data using a custom training pipeline with data processing, split data, train and validation loaders, logging, and model saving.

Track machine learning experiments with TensorBoard by logging train loss as scalars, organizing runs in time-stamped log directories, and comparing TensorBoard with MLflow and Comet ML.

Learn to build a customized training pipeline with DVC for data versioning and stage-based workflows, including data ingestion and model training with artifacts raw and trained models.

Learn to version data and code with DVC and GitHub by setting up buckets, configuring remotes on GCP, and pushing and pulling artifacts for reproducible MLOps pipelines.

Learn to build and test a FastAPI object-detection API with uvicorn, pillow, and Postman, using faster-rcnn and SwaggerUI for interactive docs.

Introduce a colorectal cancer patient survival prediction project and an end-to-end MLOps workflow using minikube, Kubeflow pipelines, MLflow with DAGsHub, Docker Hub, and a Flask-based user app.

Set up the MLOps project by creating a virtual environment, configuring setup.py and requirements.txt, and organizing src with Kubeflow pipelines and MLflow.

Practice Jupyter notebook testing in VSCode to load, preprocess, encode features, and analyze a colorectal cancer dataset, then apply chi-square feature selection and a gradient boosting classifier with accuracy.

builds a python data processing pipeline that loads raw data, encodes categorical features, scales data, selects top features via chi-squared tests, and saves train-test splits and the scaler.

Train a gradient boosting classifier using processed data, save the model with joblib, and evaluate with accuracy, precision, recall, F1, and ROC AUC while logging results.

Learn to track experiments with MLflow and DAGsHub, logging accuracy, precision, recall, F1, and ROC AUC, while enabling data and code versioning and online tracking via dag server.

Build a Flask and ChatGPT powered user app for MLOps, collecting healthcare cost, tumor size, mortality rate, treatment type, and diabetes, then scale inputs and display predictions.

Install and configure minikube and kubectl to run Kubeflow locally. Follow Windows/macOS/Linux steps, ensure docker is off, and access the pipelines UI on port 8080.

Build a Kubeflow training pipeline, dockerize the app, push the image to Docker Hub, and deploy a two-step workflow of data processing and model training on the Kubeflow dashboard.

Contrast small iris dataset projects with Circleci, GitLab CI, and GitHub action against the larger Australia weather rain prediction to teach scalable MLOps on GCP and Kubernetes.

Learn to build an end-to-end MLOps project with CircleCI for CI/CD on Google Cloud Kubernetes. Containerize with Docker, push to GCR, and deploy to GKE, using GitHub for versioning.

Set up an mlops project with artifacts, src and pipeline packages, a flask app scaffolding, and a virtual environment to install dependencies from setup.py and requirements.txt for circle CI deployment.

Set up Jupyter notebook testing in VS Code, install ipykernel, load Iris data, handle outliers with IQR imputation, and train a decision tree with evaluation metrics.

Create modular data processing using a dedicated data_processing.py that reads raw data, handles outliers, splits training and testing data, and saves x/y train/test artifacts with joblib.

Demonstrates the model training step: load preprocessed data with joblib, train a decision tree classifier, evaluate with accuracy, precision, recall, and F1, and save the model and confusion matrix plot.

Build a Flask app that loads a model with Joblib, collects sepal length, sepal width, petal length, and petal width from an HTML form, and displays the predicted iris species.

Set up a training pipeline, implement data and code versioning with GitHub, and integrate CircleCI deployment to automate training, logging, and artifact management.

Learn CI/CD deployment to Google Kubernetes Engine with CircleCI, Docker images, and Kubernetes YAML, including cluster setup, artifact registry, and deployment.

This note contrasts minor projects using iris data plus CircleCI, GitLab CI, GitHub Actions for learning, with the major Australia weather rain prediction using two lakh rows.

Explore MLOps with GitLab for data and code versioning, SCM, and CI/CD deployment on GCP using Docker, GCR, and GKE, plus a practical GitLab vs GitHub and Jenkins comparison.

Create a structured MLOps project with artifacts, src, pipeline, and a flask app with templates and static files, then set up setup.py, requirements, a virtual environment, and enable CircleCI.

Install the VS Code Jupyter extension, create iris.ipy, run cells with an ipy kernel, and test a multiclass iris classifier via a decision tree with data cleaning and evaluation.

Create a modular python data processing pipeline using a data_processing class to load data, handle outliers, split data with train_test_split, and save artifacts with joblib, plus logging and custom exceptions.

Begin by building a model-training module that loads data, trains a decision-tree classifier, evaluates it with accuracy, precision, recall, and F1 score, and saves the model and confusion matrix image.

Build a Flask web app that loads a model with joblib, accepts sepal and petal measurements via an HTML form, and displays predictions with a Jinja2 template.

Version data and code with GitLab, build a training pipeline with data processing and model training, and implement CI/CD deployment to Kubernetes for the MLOps project.

Enable key GCP APIs such as Kubernetes Engine, Container Registry, Compute Engine, IAM, Cloud Build, and Cloud Storage, then set up artifact registry and a ci/cd deployment service account.

Deploy a machine learning application with gitlab ci/cd on gcp, building a docker image, pushing to artifact registry, and deploying to kubernetes via deployment yaml.

Contrast three minor iris data projects with CircleCI, GitLab CI, and GitHub Actions against the Australia weather rain prediction project, showing learning technology versus applying a real use case.

Explore a production ready MLOps workflow using GitHub Actions to implement CI/CD, dockerize the project, and deploy on a GKE cluster in GCP with a GCR artifact repository.

Set up a complete ml ops project structure for ci cd with circle ci, creating artifacts, src, and pipeline packages, preparing data in artifacts/raw and scaffolding a flask app.

Master Jupyter notebook testing in VS Code with the Jupyter extension and ipy kernel, then load iris data, clean, visualize, and train a decision tree classifier.

Demonstrate modular data processing in python, loading csvs with pandas, handling outliers, splitting data with train_test_split, and saving artifacts with joblib for model training.

Train a decision tree model from loaded processed data, evaluate accuracy, precision, recall, and f1, plot a confusion matrix, and save the model and matrix.

Build a flask app that loads a joblib model and predicts iris species from sepal and petal measurements via an html form, numpy input, and jinja2 rendering.

Set up GCP for MLOps by enabling APIs, creating an artifact registry repository named my-repo, configuring a CI/CD service account with artifact registry access, and provisioning a us-central Kubernetes cluster.

Create a training pipeline with two steps: data processing and model training, using GitHub for data and code versioning, and deploy via GitHub Actions in an MLOps workflow on GCP.

Automate mlops deployment on gcp by building a dockerized app with a dockerfile, then use GitHub Actions ci-cd to push images to artifact registry and deploy to gke kubernetes.

Explore a 3-in-1 mlops project on GCP with Kubernetes and Jenkins to predict tomorrow's rain in Australia, deploying via GitHub Actions, CircleCI, and GitLab CI/CD.

Set up an end-to-end mlops project by creating a virtual environment, configuring requirements and setup.py, organizing src with logger and custom exception, and preparing artifacts and data.

Develop jupyter notebook testing workflows by setting up kernels and ipykernel, load and preprocess weather data, perform basic eda, encode categoricals, fill missing values, and train an XGBoost classifier.

Develop data processing steps that load data, preprocess the data, apply label encoding, split data, and save Xtrain, Xtest, Ytrain, and Ytest artifacts for CI/CD.

Build and evaluate a model training pipeline in an MLOps workflow on GCP, loading data with joblib, training an XGBoost model, saving artifacts, and reporting accuracy, precision, recall, and F1.

Build a Flask-based user app to run a trained model, using templates and static files, with a dynamic HTML form for 25 features, Joblib model loading, and yes/no predictions.

Learn to set up gcp for mlops by enabling kubernetes engine, container registry, and other essential apis, creating an artifact registry, and configuring a ci/cd service account and kubernetes cluster.

Build and deploy a Flask app on GCP Kubernetes by creating a Dockerfile and a deployment YAML, then version code and data with GitHub for CircleCI and GitHub Actions workflows.

Learn how to implement a CI/CD deployment pipeline with GitHub Actions for a GKE cluster on GCP, including secret management, building and pushing Docker images, and kubectl deployment.

Learn to implement CircleCI deployment by configuring config.yaml in dot circleci, integrating with GitHub, and deploying via docker executor to GKE.

Learn to configure GitLab CI/CD to build and push a Google Cloud SDK image, authenticate with a base64-encoded service account key, and deploy to a GCP Kubernetes cluster.