Deploy YOLOv5 Instance Segmentation Models to Raspberry Pi
Set up your Raspberry Pi, run YOLOv5 Instance Segmentation on images and video with Roboflow Inference, and build it into a Workflow.
Overview
To deploy a YOLOv5 Instance Segmentation model to a Raspberry Pi, you will:
- Set up your Raspberry Pi and start the Inference Server
- Run a pretrained RF-DETR model to check the setup
- Get your YOLOv5 Instance Segmentation model's ID from Roboflow
- Run your model on an image
- Run your model on video
- Run a Workflow that uses your model
- Deploy with a coding agent
Step 1: Set Up Your Raspberry Pi
Use a Raspberry Pi 4 or 5 with the 64-bit Raspberry Pi OS, and install Docker (opens in a new tab). Raspberry Pi OS manages its own Python, so install the Inference CLI in a virtual environment, then start the server. It pulls roboflow/roboflow-inference-server-cpu, which is built for the Pi's 64-bit ARM processor:
python3 -m venv ~/inference-env
source ~/inference-env/bin/activate
pip install inference-cli
inference server startInference does not use hardware acceleration on the Pi yet. Expect about 1 frame per second on a Pi 4 and 4 on a Pi 5 with a nano-sized detection model, so use the smallest model that is accurate enough. For faster video or larger models, use an NVIDIA Jetson.
Step 2: Run RF-DETR on Your Device
Check the setup with RF-DETR trained on the Microsoft COCO dataset (opens in a new tab), which detects 80 everyday objects. Install the client libraries on the machine that calls the server:
pip install inference-sdk supervision pillowSet the ROBOFLOW_API_KEY environment variable to your Roboflow API key (opens in a new tab) first. Then run:
import os
from inference_sdk import InferenceHTTPClient
from PIL import Image
import supervision as sv
client = InferenceHTTPClient(
api_url="http://localhost:9001",
api_key=os.environ["ROBOFLOW_API_KEY"],
)
image = Image.open("image.jpg")
results = client.infer(image, model_id="rfdetr-seg-nano")
detections = sv.Detections.from_inference(results)
annotated = sv.MaskAnnotator().annotate(scene=image.copy(), detections=detections)
annotated = sv.LabelAnnotator().annotate(scene=annotated, detections=detections)
annotated.save("annotated.jpg")The first request downloads the model weights, so it takes longer than the ones after. annotated.jpg shows what RF-DETR found.
Step 3: Use Your YOLOv5 Instance Segmentation Model
Roboflow no longer accepts new YOLOv5 Instance Segmentation weight uploads. A YOLOv5 Instance Segmentation model you uploaded before, or trained in Roboflow, still deploys with the steps below. For a new model, train one in Roboflow (RF-DETR and YOLO26 both train there), or train YOLO26 yourself and upload its weights (Upload Custom Weights (opens in a new tab)).
You need the model's project ID and version number for the next step (where to find them (opens in a new tab)).
Step 4: Run Your Model on an Image
Point the same code at your own model by its project ID and version:
import os
from inference_sdk import InferenceHTTPClient
from PIL import Image
import supervision as sv
client = InferenceHTTPClient(
api_url="http://localhost:9001",
api_key=os.environ["ROBOFLOW_API_KEY"],
)
image = Image.open("image.jpg")
results = client.infer(image, model_id="YOUR_PROJECT_ID/1")
detections = sv.Detections.from_inference(results)
annotated = sv.MaskAnnotator().annotate(scene=image.copy(), detections=detections)
annotated = sv.LabelAnnotator().annotate(scene=annotated, detections=detections)
annotated.save("annotated.jpg")sv.Detections.from_inference turns the response into detections you can count, filter, track or draw with supervision (opens in a new tab).
Step 5: Run Your Model on Video
Stream video to the server with the WebRTC client, which keeps one session open instead of sending a request per frame:
pip install "inference-sdk[webrtc]"import os
from inference_sdk import InferenceHTTPClient
from inference_sdk.webrtc import VideoFileSource
import supervision as sv
client = InferenceHTTPClient(
api_url="http://localhost:9001",
api_key=os.environ["ROBOFLOW_API_KEY"],
)
session = client.webrtc.stream(
source=VideoFileSource("video.mp4"),
model_id="YOUR_PROJECT_ID/1",
)
@session.on_frame
def on_frame(frame, data):
if data is None:
return
detections = sv.Detections.from_inference(data)
print(f"{len(detections)} objects in frame")
session.run()VideoFileSource reads a file. Use WebcamSource() for a camera on the machine running the script, or RTSPSource("rtsp://...") for a network camera the server can reach.
Step 6: Run a Workflow
A Workflow chains models with the logic around them, such as counting, tracking, filtering by zone or sending results to your own systems, and runs on your Raspberry Pi like a single model does. Build one in the Roboflow app with your model in it, then run it by its workspace and Workflow ID:
import os
from inference_sdk import InferenceHTTPClient
client = InferenceHTTPClient(
api_url="http://localhost:9001",
api_key=os.environ["ROBOFLOW_API_KEY"],
)
result = client.run_workflow(
workspace_name="YOUR_WORKSPACE",
workflow_id="YOUR_WORKFLOW_ID",
images={"image": "image.jpg"},
)
print(result[0])The result has one entry per image, holding every output the Workflow defines. To run the Workflow on video, pass workflow and workspace to client.webrtc.stream() in place of model_id (video with Workflows (opens in a new tab)). See Deploy a Workflow (opens in a new tab) for the other ways to run one.
Step 7: Deploy with a Coding Agent
The Roboflow MCP server (opens in a new tab) gives a coding agent such as Claude Code or Cursor access to your Roboflow workspace. It can list your models, run one on a test image, build and run a Workflow, and write the deployment code for your Raspberry Pi. Add it to Claude Code:
claude mcp add -s user roboflow --transport http https://mcp.roboflow.com/mcpThe first time the agent uses it, you sign in to Roboflow in your browser. In Cursor, add https://mcp.roboflow.com/mcp under mcpServers in ~/.cursor/mcp.json. Then ask the agent, for example: "Deploy my YOLOv5 Instance Segmentation model to a Raspberry Pi with Roboflow Inference and write a script that runs it on my camera stream."