Deploy ML Model in Production with FastAPI and Docker

Load and prepare data for a linear regression model by creating a notebook, building a dataset of hours studied and test scores, and performing a train-test split.

Train a linear regression model on scaled training data, inspect its coefficient and intercept, and use it to predict scores for new, scaled inputs.

Evaluate the regression model on the test set with mean square error and R-squared, then save and load the model and scaler to make predictions in production.

Explore how Streamlit lets you quickly build and test data apps for machine learning projects with minimal coding. Create interactive widgets and dashboards using Python, and deploy from GitHub.

Learn to build a Streamlit app that loads a pre-trained linear regression model and scaler with joblib, inputs hours studied, scales data, predicts a test score, and handles errors.

Learn to deploy a machine learning app with Streamlit by preparing your project, installing git, pushing to GitHub, and deploying the app on Streamlit with a custom domain.

Explore FastAPI fundamentals, its API architecture, and automatic OpenAPI documentation, then learn how Python typing, asynchronous support, and speed enable microservices, ML deployments, and rapid prototyping.

Set up a development environment with Visual Studio Code, create a simple FastAPI app in app.py, define a get / endpoint returning hello world, and run with uvicorn at localhost:8000.

Define routes and endpoints in FastAPI using get, post, put, and delete methods, backed by a Pydantic item model, tested via Swagger UI and Uvicorn.

Explore managing request bodies and response formatting in FastAPI using Pydantic models, with path, query, and body parameters, to support a machine learning model endpoint.

Set up a fast api application to serve a linear regression model, loading the saved model and scaler with joblib and defining a prediction request for hours studied.

Build a FastAPI app with a home endpoint and a post prediction endpoint, validating input with Pydantic and returning a prediction from a pre-trained linear regression model.

Test FastAPI endpoints locally by setting up a virtual environment, installing FastAPI, uvicorn, joblib, numpy, pandas, and scikit-learn, and running the app with uvicorn.

Preprocesses wine quality data by reclassifying quality into categories to improve model performance and handle imbalance, then trains and evaluates models in a Jupyter notebook for deployment via FastAPI.

Scale features with a minmax scaler, split data, train and evaluate multiple models, tune the best random forest with grid search, and save the model and scaler for FastAPI deployment.

Build a FastAPI app to serve a wine quality classifier by loading trained model and scalar, validating 11 wine features with pydantic, scaling inputs with numpy, and predicting via JSON.

Test fastapi endpoints locally by launching the app, validating the home and predict routes with Swagger UI, and installing required packages in a virtual environment with uvicorn.

Preload the model and scalar at startup in a fastapi app to reduce latency, enabling global access for inference while prepping for docker deployment and production.

Implement robust request handling, error responses, and logging in a FastAPI deployment, using HTTP exceptions, input validation, and Python's logging to ensure graceful failures and traceability.

Configure environment variables to separate configuration from code and enable flexible deployment. Create and load a .env file, define model and scalar paths, and test the FastAPI endpoint with uvicorn.

Create a simple frontend for model serving using FastAPI static files to serve index.html and predict.html, with a static directory, CSS, JavaScript, and a post endpoint form for hours studied.

Explore how containers provide isolated, portable, and fast environments for applications, compare containers with virtual machines, and learn Docker basics—images, containers, daemon, and Docker Hub.

Learn to build and run a docker image locally for a fastapi app, using dockerfile, docker build -t, and docker run -d -p 8000:8000, then test endpoints.

Learn to write a dockerfile to containerize a fastapi app that serves a machine learning model, install dependencies, copy project files, and run with uvicorn on port 8000.

Build and run Docker images locally to test a FastAPI machine learning model. Containerize with a Dockerfile and map port 8000 for local access.

Test and validate model API endpoints in a FastAPI app using pytest and the FastAPI test client, covering home and predict routes, HTML responses, and 400 invalid input handling.

Train an iris flower classifier using four features and a multi-class SVM, encode the target, split data 60/40, achieve about 97% accuracy, and save the model for FastAPI deployment.

Build a FastAPI app to serve an iris SVM model: define a Pydantic input, load the model with Joblib, and create home and predict endpoints mapping predictions to iris species.

Set up a virtual environment, install dependencies, and run uvicorn to start the fast api app. Test the home and predict endpoints locally to verify the iris svm model serves.

Create a front end for a fast api model-serving app using html, css, and javascript. Load static files, implement a form that posts to the predict endpoint, and display results.

Mount static files in FastAPI, serve index.html and predict.html, and switch input handling from json to form data to feed a pandas data frame for front-end communication.

Prepare a production-ready FastAPI app by containerizing the application and implementing logging with the logging module and requests, monitoring model loading and prediction endpoints.

Dockerize a FastAPI production deployment by building a docker image from Python 3.9-slim, installing dependencies, and serving the iris classifier with uvicorn on port 8000.

Write unit and integration tests for a FastAPI model API using pytest and test client, validate home and predict endpoints, and integrate tests into dockerized ci/cd pipelines.