ML Model Deployment with FastAPI and Streamlit

Learn how FastAPI serves as an API bridge between data and applications, implement CRUD operations with HTTP verbs, and use uvicorn and Swagger docs for interactive deployment.

Define path parameters in FastAPI endpoints, validate types with annotations, and use async functions for efficient data handling, including enums and docs for predefined values.

Learn to declare query parameters in FastAPI, distinguish them from path parameters, and implement optional defaults like skip and limit to control endpoint responses.

Define a request body with Pydantic for a student and publish a post endpoint in FastAPI to receive name, age, height, weight, compute BMI, and return the updated model.

Learn how to implement input validations in FastAPI endpoints using annotated, query and path parameters, with optional or required parameters and common validations like max length and numeric ranges.

Learn how to combine path, query, and request body parameters in FastAPI using annotated models, with optional fields and field validations for age and name.

Master form-based data intake and file uploads in FastAPI using annotated form fields for username and password, and the file and upload file approaches with validations and metadata.

Use templates with FastAPI to render a user interface for your api by returning html templates and displaying dynamic data such as a student id, with static css support.

Learn to test a FastAPI app using pi test and http by creating a hello world endpoint, asserting 200 status. Use test clients, import app, and run py test.

Build a weather prediction app by connecting a machine learning model to an API that serves any front end, from HTML to Streamlit, with emphasis on docs and debugging.

Develop a time series forecasting API using a Delhi climate dataset, building a project structure with main.py, model.py, and tests.py, and set up a virtual environment and FastAPI installation.

Build a time series ml model with pandas, prophet, and joblib to train on climate data, generate future predictions, and expose y hat outputs for fastapi deployment.

Create model prediction endpoints with FastAPI, using query parameters for weather variables and days. Handle 400 errors for missing models and verify responses through the docs.

Build a web interface with html templates and an index.html that posts to the /predicts endpoint to display ml model predictions via FastAPI.

Test FastAPI app endpoints using a test client to verify responses, status codes, and HTML content types. Validate the predict endpoint with weather variables like temperature to ensure robust deployment.

Explore Streamlit widgets like sliders, text inputs, checkboxes, and select boxes to manipulate data, with session state and dataframe visualizations.

Learn to design layouts by arranging Streamlit widgets in sidebars and canvases, using st.sidebar for select boxes, sliders, and radio buttons, and st.columns for side-by-side panels.

Learn how caching in Streamlit speeds apps by caching data with st dot catch data for data frames and APIs, and st dot catch resource for static resources.

Explain how Streamlit session state saves values between reruns within a single session, stores items like counters and dataframes, and contrasts with caching across sessions.

Explore multi-page design in Streamlit by organizing pages in a pages folder beside main.py, creating page1.py, page2.py, and page3.py, and refreshing to view navigation.

Build a Streamlit UI integrated with FastAPI to forecast weather, featuring a home page with time-series graphs of humidity and wind speed and a forecast page for temperature.

Create a two-folder project with backend and frontend, set up dependencies in requirements.txt, and implement four climate models with a Streamlit interface.

Connect a FastAPI endpoint with a Streamlit frontend by posting a payload with weather variable and days to get predictions, then display the forecast data.

Deploy the FastAPI on Render as its own web service, set host and port, connect a Git repository, install requirements, and launch the Streamlit app to test predictions.

Deploy a Streamlit app using the Streamlit Community Cloud or Render by linking your GitHub repo, with optional Docker or Kubernetes for scaling, while considering pricing.

Build a WhatsApp image generator using Vonage, FastAPI, and OpenAI, with Ngrok to expose your local server, and generate images from text prompts like yellow mango or big fat monkey.

Set up and activate a virtual environment, create key files (.env, main.py, utilities), prepare a requirements.txt with fast api, uvicorn, openai, requests, and Grock, then install them.

Configure Vonage messaging sandbox, securely manage API key and secret via environment variables, and implement a Python function to send image messages to WhatsApp using the Vonage API.

Learn to connect to the OpenAI API by configuring keys and environment variables, generate images with the OpenAI image endpoint, and integrate URL in a FastAPI app for WhatsApp delivery.

Develop a FastAPI app that receives inbound WhatsApp prompts via Vonage, creates images with OpenAI, and returns them through a webhook, using Ngrok, logging, and environment variables.