guides/raspberry-pi/

[giscus[bot]]

guides/raspberry-pi/

Quick start guide to setting up YOLO on a Raspberry Pi with a Pi Camera using the libcamera stack. Detailed comparison between Raspberry Pi 3, 4 and 5 models.

https://docs.ultralytics.com/guides/raspberry-pi/

[RunningMike]

Hi, I am getting stuck on step 4. I am using a Raspberry Pi 3 and I am getting:

"Error: Could not find a version that satisfies the requirement torch>=1.11.0"
"Error: No matching distribution found for torch>=1.11.0"

Note, this is after I have changed the versions in "requirements.txt" to torch>=1.11.0 and torchvision>=0.12.0. I got the same type of error message with the original torch>=1.18.0 and torchvision>=0.9.0.

Any ideas?

PS. My intention is to try to run this on a Raspberry Pi 5 (4 GB), but my PiCam didn´t fit in the Pi 5. DS

[glenn-jocher]

Hey there! 👋 It seems like you're facing an issue with installing PyTorch on your Raspberry Pi 3. The error you're encountering typically happens when the PyTorch version you're trying to install isn't available for your platform.

For Raspberry Pi 3, you might need to install a version of PyTorch that's compatible with ARM processors. You can try installing a pre-built PyTorch wheel that's suitable for your device. Here's a command that might work for you:

pip3 install https://github.com/KumaTea/pytorch-aarch64/releases/download/v1.11.0/torch-1.11.0a0%2Bgit36449ea-cp37-cp37m-linux_aarch64.whl

Make sure to replace the URL with the correct wheel file for your Python version if it's different from cp37 (Python 3.7).

Regarding your Raspberry Pi 5 and the PiCam compatibility issue, it's possible that you might need an adapter or a different cable if the connectors have changed in the newer Pi model. It's always a good idea to check the official Raspberry Pi documentation or forums for compatibility guidance.

Hope this helps you get back on track! Let me know if you have any more questions. 😊

[RunningMike]

Hi again,
sorry for my late reply.
I have now tried to install PyTorch with the altered URL. I still can not get it to work. I changed it according to my python 3.9.2 version as follows:

raspberrypi@raspberrypi:~ $ python3 -V
Python 3.9.2

raspberrypi@raspberrypi:~ $ pip3 install https://github.com/KumaTea/pytorch-aarch64/releases/download/v1.9.0/torch-1.9.0-cp39-cp39-linux_aarch64.whl

Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
ERROR: torch-1.9.0-cp39-cp39-linux_aarch64.whl is not a supported wheel on this platform.

//Best Regards

[glenn-jocher]

@RunningMike hi there,

It seems like you're encountering a compatibility issue with the PyTorch wheel for your specific platform. The error message indicates that the wheel you're trying to install is not supported on your platform, which could be due to a mismatch between the wheel's requirements and your Raspberry Pi's architecture or Python version.

Here are a couple of suggestions:

1. Verify the Wheel Compatibility: Ensure that the wheel is compatible with both the architecture of your Raspberry Pi and your Python version. You can check for available wheels that match your setup on the KumaTea PyTorch GitHub releases.

2. Try a Different Installation Method: If the direct wheel installation continues to fail, consider using a different method. For Raspberry Pi, you might find success using a more general installation command that targets ARM architectures, like:

   pip3 install torch==1.9.0+cpu torchvision==0.10.0+cpu torchaudio==0.9.0 -f https://download.pytorch.org/whl/torch_stable.html

   Adjust the versions as necessary to match the ones compatible with your project requirements.

3. Check Python Compatibility: Double-check that your Python version is compatible with the PyTorch version you're trying to install. Sometimes, newer versions of libraries may not support older Python versions.

If you're planning to use the Raspberry Pi 5, you might also consider waiting until you have the appropriate adapter for the PiCam, as the newer hardware might provide better support and performance for your applications.

Best regards!

[Aditya9246]

Hi,
I am getting stuck on "Perform YOLOv5 Inference" step. I am using a Raspberry Pi 4 Model B.

The output I am getting is: ModuleNotFoundError: No module named 'torch'

Any help would be appreciated.

[glenn-jocher]

Hey there! 👋 It looks like you're facing an issue with the PyTorch installation on your Raspberry Pi 4. The error ModuleNotFoundError: No module named 'torch' typically indicates that PyTorch isn't installed in your Python environment.

Here's a quick fix you can try:

1. Open your terminal.
2. Run the following command to install PyTorch:

   pip3 install torch torchvision

   This should install the latest versions of both torch and torchvision that are compatible with your system.

If you're still having trouble or need a specific version of PyTorch, you can find more detailed installation instructions on the PyTorch website.

Let me know if this helps or if you have any more questions! 😊

[anassheriff]

(no module named ultralytics) shown after running the ultralytics

[pderrenger]

Hey there! It looks like you're encountering an issue with the ultralytics package not being found. This usually happens if the package hasn't been installed correctly or if you're running the command from a different environment where the package isn't available. 😊

To resolve this, you can try installing the ultralytics package directly using pip. Here's how you can do it:

pip install ultralytics

Or, if you're using a specific version of Python and pip (like pip3 for Python 3), you might want to use:

pip3 install ultralytics

Make sure you're in the correct environment where you intend to use the package. If you're using a virtual environment, activate it first before running the install command.

If you've already installed the package and still see the error, double-check your environment and the Python version you're using. Sometimes, running Python with python3 instead of python (or vice versa) can make a difference based on how your system is set up.

Hope this helps! Let us know if you're still facing any issues. 🚀

[anassheriff]

that what i was doing the last month and still it doesn't work, actually idk other installation methods

[pderrenger]

@anassheriff hey there! 😊 It sounds like you've been having a tough time getting things set up. No worries, let's try a different approach that might help. Since you're working with a Raspberry Pi, our Quick Start Guide specifically tailored for Raspberry Pi setups could be just what you need. Here's a simplified version to get you started:

1. Update your Raspberry Pi:

   sudo apt-get update
   sudo apt-get upgrade -y
   sudo apt-get autoremove -y

2. Install the ultralytics package:

   pip3 install ultralytics

3. Start a TCP stream with Libcamera (make sure your Pi Camera is connected):

   libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888

4. Run YOLOv8 inference:

   from ultralytics import YOLO
   
   model = YOLO('yolov8n.pt')
   results = model('tcp://127.0.0.1:8888', stream=True)
   
   for result in results:
       print(result.boxes, result.probs)

This guide is designed to be straightforward and should help you get up and running with YOLO on your Raspberry Pi. If you encounter any issues, feel free to reach out! 🚀

[DaJuan07]

Hello!
I just want to know how can I still have the live video feedback when I run the yolov5 detection. Because after alternating the detect.py and running the detection it works but it doesn't give me a live video feedback of the detection anymore unlike using the default camera which is source 0

Thanks in advance!

[glenn-jocher]

@DaJuan07 I don't quite understand your question, but yes using source 0 will run inference on your local webcam with YOLOv5 or YOLOv8.

[MuhammadNauvalFirdaus]

hello, how do I not have to run TCP Stream in the command prompt every time I want to run code.

[pderrenger]

@MuhammadNauvalFirdaus hi there! 😊

To avoid manually starting the TCP Stream each time, you can automate it by creating a simple script that starts the stream for you and then runs your code afterward. Here’s a quick example on how to do it:

1. Create a start_stream_and_run_yolo.sh script:

#!/bin/bash
# Start the TCP stream
libcamera-vid -n -t 0 --width 1280 --height 960 --framerate 1 --inline --listen -o tcp://127.0.0.1:8888 &
# Wait a bit for the stream to initialize
sleep 5
# Now run your YOLO code
python3 your_yolo_script.py

2. Make your script executable:

chmod +x start_stream_and_run_yolo.sh

3. Now, instead of manually starting the TCP stream and then running your code, you can just run this script:

./start_stream_and_run_yolo.sh

This way, your TCP Stream is started automatically, and your YOLO code runs right after, all in one go! 🚀

Remember, this is just a basic example. Modify it according to your exact needs, like adjusting the sleep duration or including any other preliminary steps you might have.

Hope that helps!

[MohamedSaliim]

Hi , I have a trained model and I saved it on my PC what is the best way to export and it an excutable to run on Raspberry pi 4 model B 8GB

[MohamedSaliim]

make it*

[glenn-jocher]

Hey there! 🚀 To deploy your trained model on a Raspberry Pi 4 model B 8GB, you can export it as an ONNX file, which is a popular and efficient format for model deployment. Here's a quick guide:

1. First, ensure you've installed the necessary packages on your Raspberry Pi:

sudo apt-get update
sudo apt-get upgrade
pip3 install ultralytics onnx opencv-python-headless

2. Next, export your model to the ONNX format using the following command on your PC (adjust path/to/your/model.pt to your model's location):

yolo export model=path/to/your/model.pt format=onnx

3. Transfer the exported .onnx file to your Raspberry Pi.

4. On your Raspberry Pi, you can now use the model for inference. Here's a simple example in Python:

from ultralytics import YOLO

# Load your ONNX model
model = YOLO('path/to/your/model.onnx')

# Run inference on an image or video stream
results = model('path/to/your/image/or/video')

# Process the results...

This setup would allow you to run your model directly on the Raspberry Pi with decent performance, especially on the 4B model with 8GB RAM. 🎉

For a more detailed guide and optimizations, consider checking out the Ultralytics docs for Raspberry Pi, especially the sections on setting up YOLOv8 with a Pi Camera. Good luck with your project!

[DaJuan07]

how can i use my owned trained model exported from google collab
I already have my .pt file, I tried running this code

broc@raspberrypi:~/yolov5 $ python3 detect.py --weights /home/broc/yolov5/trained_data.pt --source=tcp://127.0.0.1:8888

but gave me this error
RuntimeError: PytorchStreamReader failed reading zip archive: failed finding central directory

im running this on Raspberri Pi 4 model B 4GB

[zoldaten]

hi !
actually you do not need stream to capture. use picamera2 instead.

from picamera2 import MappedArray, Picamera2, Preview
model_yolov5 = torch.hub.load('yolov5', 'custom', path='yolov5m_Objects365.onnx', source='local', force_reload=False)
model_yolov5.conf = 0.3  # NMS confidence threshold

camera = Picamera2(tuning="/usr/share/libcamera/ipa/rpi/vc4/imx477_noir.json")#tuning="/usr/share/libcamera/ipa/rpi/vc4/ov5647_noir.json"
preview_config = camera.create_still_configuration(main={"size": (720, 1280),"format": "RGB888"}) #1080, 1920
camera.configure(preview_config)
camera.start()

def yolov5_work(frame):
    start_time = time.time()
    # Inference
    results = model_yolov5(frame, size=640)  # includes NMS
    #results.print()    
    r=results.pandas().xyxy[0]
    if r.empty==True: 
        return
    r=set(r['name'].to_string(index=False).split('\n'))
    
    for i in r:
        print(i.strip())
        
    print("--- %s seconds ---" % (time.time() - start_time))
    
def yolov5_cap(): 
        np_array = camera.capture_array()
        np_array = cv2.resize(np_array, dsize=(640, 640), interpolation=cv2.INTER_CUBIC)
        np_array = cv2.flip(cv2.transpose(np_array),0)
        yolov5_work(np_array)

while True:
    yolov5_cap()

[glenn-jocher]

Hey there! 😊 It looks like you've got a great setup with Picamera2 and Torch for running YOLO! Using Picamera2 for your camera management is indeed a streamlined approach, especially for Raspberry Pi projects, as it's tailored for the Pi's hardware.

For others reading this comment and looking to integrate YOLO with Picamera2, here's a concise guide:

1. Ensure you have torch and picamera2 installed.
2. Use the provided code snippet to load your YOLO model and set the confidence threshold:

   model_yolov5 = torch.hub.load('ultralytics/yolov5', 'custom', path='your_model_path.pt', source='local')
   model_yolov5.conf = 0.3  # Confidence threshold

3. Initialize Picamera2, and configure it based on your Pi Camera version.
4. Capture frames using camera.capture_array(), preprocess them as needed (resize, flip), and then pass them to your YOLO model.

Make sure to adjust the image preprocessing steps (cv2.resize, cv2.flip, cv2.transpose) based on your specific requirements and the orientation of your Raspberry Pi Camera.

This approach lets you harness the powerful capabilities of YOLO for real-time object detection, directly integrating with the Pi's camera hardware. 📸

For more in-depth information on Pi Camera and YOLO usage, especially for different Raspberry Pi models, don't forget to check out the Ultralytics Docs Page on Raspberry Pi setup. It's filled with tips and steps to ensure a smooth setup on your end.

Happy coding, and can't wait to see what awesome projects you'll create with this! 🚀

[zoldaten]

@glenn-jocher by the way, why there is so much difference in inference time with yolov8 ? :

i see

image 1/1 /home/pi/Desktop/test/temp.png: 640x640 1 Door, 1 Window, 2164.9ms
Speed: 553.4ms preprocess, 2164.9ms inference, 190.6ms postprocess per image at shape (1, 3, 640, 640)

when use this code provided:

from ultralytics import YOLO

model_yolov8 = YOLO('yolov8/yolov8n-oiv7.onnx')
model_yolov8.conf = 0.3  # NMS confidence threshold
model_yolov8.imgsz=480
results = model_yolov8('temp.png')

and much faster in console:

image 1/1 /home/pi/Desktop/test/yolov8/temp.png: 480x480 2 Doors, 2 Windows, 658.2ms
Speed: 14.3ms preprocess, 658.2ms inference, 17.1ms postprocess per image at shape (1, 3, 480, 480)

using this:
yolo predict data=open-images-v7.yaml imgsz=480 model=yolov8n-oiv7.onnx source='temp.png'

[glenn-jocher]

@zoldaten hi there! 🙌 The difference in inference time you're observing between the Python code and console command likely stems from a couple of factors:

1. Image Size: In the python code, the image size is manually set to 480 after loading the model, which might not affect the inference if the model has already locked in another size on loading. The console command explicitly sets imgsz=480, ensuring that this size is used for inference.

2. Processing Path: Running through the console uses highly optimized pathways, including potential hardware accelerations and optimizations in loading and inference not explicitly invoked in your Python script.

To harmonize the performance and ensure you're comparing apples to apples, make sure the image size (imgsz) and any other configurations like the confidence threshold (conf) are consistent across both methods. Adjusting the Python code to match the console command exactly in terms of arguments passed might help you get closer timings.

For Python, ensure you're adjusting the image size directly before inference like so:

from ultralytics import YOLO

model = YOLO('yolov8/yolov8n-oiv7.onnx')
model.conf = 0.3  # NMS confidence threshold
model.imgsz = (480, 480)  # Set image size as a tuple
results = model('temp.png')

And keep the console command as is, since it seems to be optimized. By mirroring the settings, the inference time should get more consistent across the two methods. Hope this helps! 😊

[sishort]

Hi, I really excited to get started with using YOLO and learning a lot along the way, but I'm struggling with the environment setup guidance that you have here for a Raspberry Pi.
I'm using a new Raspberry Pi 5 and a fresh install of Pi OS 64.
All of the updates are complete
sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get autoremove -y

Step 2 however isn't allowed
pip3 install ultralytics

results in error
error: externally-managed-environment

Do you recommend creating a virtual environment or override the error with the following?
sudo rm /usr/lib/python3.11/EXTERNALLY-MANAGED

Either way, I want to get past basic setup so I can start playing with yolov8, but seemingly something is going wrong with the most recent Pi.

thanks and sorry if this is a basic question

[pderrenger]

Hey there! 👋

The error you're encountering does seem related to the image format. The assertion error suggests that the image passed to the Annotator is not contiguous in memory, which is a requirement for certain image processing operations. To fix this, you can apply numpy.ascontiguousarray() to your image before passing it to the object counting method.

Here's a quick fix:

frame = np.ascontiguousarray(frame)  # Make frame contiguous

Insert this line right before you call model.track(frame, persist=True, ...).

In practice, your updated code snippet should look like this:

...
# Capture image from camera
frame = camera.capture_array()
# Ensure the frame has only 3 channels (RGB)
if frame.shape[2] == 4:  # Check if there are 4 channels
    frame = frame[:, :, :3]  # Keep only the first 3 channels

frame = np.ascontiguousarray(frame)  # Add this line here

# Perform object tracking
...

This should make the image data contiguous in memory and resolve the error. Let me know if this helps or if you come across any more issues. Happy to assist further! 🚀

[sishort]

That doesn't seem to have done the trick unfortunately.

Traceback (most recent call last):
  File "/home/name/env/getting_there.py", line 54, in <module>
    for object_name, count in object_counts.items():
AttributeError: 'numpy.ndarray' object has no attribute 'items'`

[pderrenger]

Hi there! 👋 It seems like the issue is because object_counts is expected to be a dictionary but is actually a numpy array in this context, which doesn't have an .items() method. This can happen if the output of counter.start_counting() isn't returning what's expected.

Could you double-check the return value of counter.start_counting(frame, tracks)? It's supposed to return a dictionary of object counts, where keys are object names and values are their counts. If it's returning something else (like a numpy array), that might explain the error.

If adjustments to the object_counter.py script or the model's tracking output are needed, you might want to ensure that object_counts gets correctly populated as a dict. For debugging, you could temporarily print out the object_counts right before the for-loop to see what's actually being returned.

Feel free to reach out if you need more help or if there's anything specific you're unclear about! 🚀

[sishort]

Hi Paula, Thank you again, this help is great.

Definitely getting an array from object_counts, I think this is because we made the variable 'frame' a contiguous array?

[pderrenger]

Hey there! 😊 It looks like the mix-up is not directly tied to making the 'frame' contiguous but more about how the object_counts is being managed or returned in the code snippet you're working with. The object_counts from counter.start_counting should ideally be in a dictionary format where object_name serves as the key and count as the value. If it's coming through as an array, there might be an issue with how the results are being processed or interpreted in your implementation.

Without seeing the exact workings of object_counter, it's challenging to pinpoint the issue, but here's a generic way to handle object_counts if it's indeed a numpy array with an expected structure:

# Assuming object_counts is an array with a known structure
# For illustration, let's say [object_id, count]

for i in range(len(object_counts)):
    object_name = model.names[int(object_counts[i, 0])]  # Converting object ID to name
    count = object_counts[i, 1]
    csv_writer.writerow([datetime.datetime.now().isoformat(), object_name, count])

This is assuming object_counts is a 2D array with rows representing objects and the first column as the object ID and the second column as the count. Make sure to adjust this according to the actual structure of object_counts.

For a more precise solution, you might need to review the output structure of counter.start_counting or consider revising how results are processed to fit the expected dictionary format. 🚀

[ragulsubha54]

Hai , I am using Raspberry pi 4B. I wanted to deploy my yolov8 detection model in Raspberry pi. When my webcam turn ON to initiate detection, the frame rate is soooooooo slowwwww:(. Is there any solution to solve this

[pderrenger]

Hey there! 👋

It seems like you're encountering frame rate issues with your webcam-connected YOLOv8 model on the Raspberry Pi 4B. A common challenge, but not to worry, here are a couple of suggestions to boost your frame rate:

1. Reduce Image Size: Lowering the imgsz parameter can significantly improve frame rates as it decreases the amount of data to process.

   yolo detect predict model=yolov8n.pt source=0 imgsz=320  # Example with image size of 320

2. Optimize Model: Consider using a more lightweight model if your current one is too heavy. YOLOv8 offers several versions optimized for a balance between speed and accuracy.

3. Hardware Acceleration: Enable hardware acceleration (if not already done), which can provide a boost in processing speed.

4. Check for Background Processes: Ensure no heavy background processes are running on your Raspberry Pi that could slow down inference.

I hope these tips help! If you have further issues or need more detailed assistance, feel free to ask. 🚀

[ragulsubha54]

Thank you so much :)

[pderrenger]

@ragulsubha54 hey there! 🌟

It's fantastic to hear you're diving into deploying your YOLOv8 model on a Raspberry Pi 4B! 🛠 If you're experiencing slow frame rates with your webcam, here's a quick tip that might help boost performance:

Consider reducing the input image size (imgsz) when running your model prediction. This can significantly speed up the inference time. For example:

from ultralytics import YOLO

# Assuming 'yolov8n.pt' is your trained model
model = YOLO('yolov8n.pt')
results = model.predict(source='0', imgsz=320, stream=True)  # You can adjust 'imgsz' based on your needs

This reduces the resolution the model has to process, hopefully making the frame rate smoother without sacrificing too much accuracy. 🚀

Do keep in mind, finding the right balance between speed and accuracy might require some experimenting. Good luck, and hope this helps!

[Anandukc]

How to deploy a custom model best.pt

[pderrenger]

@Anandukc hey there! 🚀

To deploy your custom best.pt model, you can use the following Python code snippet:

from ultralytics import YOLO

# Load your custom trained model
model = YOLO('path/to/best.pt')

# Now you can make predictions
results = model('path/to/your/image.jpg')

# For visualizing the results
results.show()

If you're looking to run predictions on a stream, such as a camera feed, you can do this:

results = model('tcp://127.0.0.1:8888', stream=True)

for result in results:
    result.show()  # Or any other processing

Make sure to adjust 'path/to/best.pt' and sources like 'path/to/your/image.jpg' or stream URLs to match your setup. Happy detecting! 🎉

P.S. If you're interested in deploying on a Raspberry Pi, we have a dedicated guide that might help streamline the process. Check it out!

[Anandukc]

How to do object detection with web cam connect with pi 4 using USB port. How can I access this camera through opencv?

[pderrenger]

Hey there! 😊 To access a USB-connected webcam on your Pi 4 through OpenCV in Python, you can use the following code snippet:

import cv2

# Initialize the webcam at index 0 (you may need to change this)
# For USB cameras, the index is usually 0 or 1 depending on how many cams are connected
cap = cv2.VideoCapture(0)

# Check if the webcam is opened successfully
if not cap.isOpened():
    print("Error: Could not open webcam.")
    exit()

while True:
    # Capture frame-by-frame
    ret, frame = cap.read()

    # If frame is read correctly 'ret' is True
    if not ret:
        print("Can't receive frame (stream end?). Exiting ...")
        break

    # Display the captured frame
    cv2.imshow('WebCam Frame', frame)

    # Break the loop with 'q'
    if cv2.waitKey(1) == ord('q'):
        break

# When everything is done, release the capture
cap.release()
cv2.destroyAllWindows()

This will open your webcam and display the video feed in a window. Make sure you have OpenCV installed (pip3 install opencv-python-headless) on your Raspberry Pi. To stop the video feed, just press "q".

For object detection with YOLO on video streams, replace the webcam display part with your YOLO inference code. If you're using YOLO with Ultralytics, check out the Quick Start Guide for Raspberry Pi for setup instructions.

Good luck and have fun detecting objects with your webcam! 🚀

[zqgdrmq]

When I follow the docker instructions I continually fail.

yolo predict model=yolov8n.pt source="tcp://127.0.0.1:8888"
In the container I get the following error:
Connection to tcp://127.0.0.1:8888 failed: Connection refused

This is my docker container & image:
sudo docker run -it --ipc=host --device=/dev/video0 -p 127.0.0.1:8080:8888 ultralytics/ultralytics:latest-arm64

4552de20307c ultralytics/ultralytics:latest-arm64 "bash" 22 hours ago Up 22 hours 127.0.0.1:8080->8888/tcp xenodochial_kepler

Any idea what am I doing wrong?

[pderrenger]

Hello,

It looks like there might be a mismatch in the port forwarding configuration in your Docker command. You've mapped the host's port 8080 to the container's port 8888, but your application inside the container is trying to connect to tcp://127.0.0.1:8888. This setup expects the service to be available on port 8888 inside the container.

To resolve this, you can either:

1. Change the port forwarding in your Docker command to -p 8888:8888 to match the internal service port.
2. Adjust your application to connect to tcp://127.0.0.1:8080 if you prefer to keep the current Docker port mapping.

Try updating your Docker run command like this:

sudo docker run -it --ipc=host --device=/dev/video0 -p 8888:8888 ultralytics/ultralytics:latest-arm64

This should align the ports correctly. Let me know if this helps or if you encounter any further issues! 😊

[zqgdrmq]

I appreciate your reply but still not getting the correct outcome [notice I changed everything to 0.0.0.0 as you did not specify localhost]

docker - sudo docker run -it --ipc=host --device=/dev/video0 -p 8888:8888 ultralytics/ultralytics:latest-arm64
camera - rpicam-vid --inline --listen -o tcp://0.0.0.0:8888 -> ** failed to bind listen socket **
yolo predict model=yolov8n.pt source="tcp://0.0.0.0:8888" -> ConnectionError: 1/1: tcp://0.0.0.0:8888... Failed to open tcp://0.0.0.0:8888

[pderrenger]

@zqgdrmq hello,

It seems like the issue is related to the binding of the TCP socket on 0.0.0.0:8888. This error typically occurs when the address is already in use or the program does not have permission to bind to the specified port.

Here are a few steps to troubleshoot and resolve the issue:

1. Check for Port Availability: Ensure that no other service is using port 8888. You can check this with the command:

   sudo lsof -i :8888

   If there is another service using the port, either stop that service or choose a different port for your application.

2. Run as Root: Sometimes, binding to a port requires root privileges. Try running the command with sudo to see if it resolves the issue.

3. Use a Different Port: If port 8888 is not available, you can try using a different port. Make sure to update the port in both the rpicam-vid command and the Docker command.

4. Firewall Settings: Ensure that your firewall settings are not blocking connections to the chosen port.

5. Docker Network Settings: Since you are running inside a Docker container, make sure that the Docker network settings allow for binding to the desired ports. You might need to use --network="host" in your Docker command if the network settings are restrictive.

Here is an example command with adjusted network settings and using a different port if necessary:

sudo docker run -it --ipc=host --device=/dev/video0 --network="host" ultralytics/ultralytics:latest-arm64

Please try these adjustments and let me know if the issue persists. We're here to help!

[zqgdrmq]

So helpful - thank you. Definitely getting closer!! What are your recommendations for the next steps now that I am producing a results .avi file?

[pderrenger]

@zqgdrmq that's great to hear you're making progress! 🎉 With your results file ready, here are a few next steps you might consider:

1. Analyze the Results: Review the .avi file to ensure the detections meet your expectations. Check for accuracy, missed detections, and false positives.

2. Optimize the Model: If the results aren't as accurate as you'd like, consider retraining the model with different parameters, more data, or by fine-tuning the existing model.

3. Integrate with Applications: Depending on your project, you might want to integrate this model into a larger system, such as a real-time monitoring system or an automated alert system.

4. Expand to Other Platforms: If you're running on a Raspberry Pi and looking for more performance, consider deploying the model on more powerful hardware or exploring cloud-based solutions.

5. Share Your Findings: Consider sharing your results, challenges, and solutions with the community. This could be through a blog post, a GitHub repository, or a presentation at a meetup.

If you have specific questions or need further guidance on any of these steps, feel free to ask. Happy building! 🚀

[smhty]

Works great on Raspberry Pi 5.
A tutorial for the AI kit that comes with Raspberry Pi 5 would be great as well: https://www.raspberrypi.com/products/ai-kit/

[glenn-jocher]

Hi there!

Thank you for your feedback and for sharing your positive experience with YOLOv8 on the Raspberry Pi 5! 😊

Creating a tutorial for the AI kit that comes with the Raspberry Pi 5 is a fantastic idea. In the meantime, you can refer to our comprehensive Quick Start Guide for Raspberry Pi with Ultralytics YOLOv8, which provides detailed instructions on setting up and running YOLOv8 on Raspberry Pi devices, including performance benchmarks.

For those interested in using the AI kit, the setup process should be quite similar. Here’s a quick overview to get you started:

1. Flash Raspberry Pi OS: Ensure you have the latest Raspberry Pi OS Bookworm (Debian 12) installed. Follow the Getting Started Documentation by Raspberry Pi to prepare your device.

2. Set Up Ultralytics:

   • With Docker:

     t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t

   • Without Docker:

     sudo apt update
     sudo apt install python3-pip -y
     pip install -U pip
     pip install ultralytics[export]
     sudo reboot

3. Use NCNN for Best Performance: Convert your YOLOv8 model to NCNN format for optimal performance on Raspberry Pi:

   from ultralytics import YOLO
   
   # Load a YOLOv8n PyTorch model
   model = YOLO("yolov8n.pt")
   
   # Export the model to NCNN format
   model.export(format="ncnn")  # creates 'yolov8n_ncnn_model'
   
   # Load the exported NCNN model
   ncnn_model = YOLO("yolov8n_ncnn_model")
   
   # Run inference
   results = ncnn_model("https://ultralytics.com/images/bus.jpg")

4. Using the Raspberry Pi Camera: For real-time video feeds, you can use the picamera2 library or set up a TCP stream:

   • Using picamera2:

     import cv2
     from picamera2 import Picamera2
     from ultralytics import YOLO
     
     picam2 = Picamera2()
     picam2.preview_configuration.main.size = (1280, 720)
     picam2.preview_configuration.main.format = "RGB888"
     picam2.preview_configuration.align()
     picam2.configure("preview")
     picam2.start()
     
     model = YOLO("yolov8n.pt")
     
     while True:
         frame = picam2.capture_array()
         results = model(frame)
         annotated_frame = results[0].plot()
         cv2.imshow("Camera", annotated_frame)
         if cv2.waitKey(1) == ord("q"):
             break
     
     cv2.destroyAllWindows()

   • Using TCP Stream:

     rpicam-vid -n -t 0 --inline --listen -o tcp://127.0.0.1:8888

     from ultralytics import YOLO
     
     model = YOLO("yolov8n.pt")
     results = model("tcp://127.0.0.1:8888")

We hope this helps you get started with the AI kit on your Raspberry Pi 5. For more detailed instructions and additional resources, please visit our Raspberry Pi Guide.

Happy coding! 🚀

[RhongoAlter]

Hi, I don't know if I'm stuck or it just takes hours to install. I installed Ultralytics without docker and currently its on this

Building wheels for collected packages: psutil, tensorflow-decision-forests, tensorstore
Building wheel for psutil (pyproject.toml) ... done
Created wheel for psutil: filename=psutil-5.9.8-cp311-abi3-linux_aarch64.whl size=285616 sha256=11c923255fa37e0aaa8316039e4a4bff393bb1d42e26c553b2a2264a61dea007
Stored in directory: /home/pi/.cache/pip/wheels/a6/1e/65/fb0ad37886dca3f25a0aa8e50f4903c5bdbde4bb8a9b1e27de
Building wheel for tensorflow-decision-forests (pyproject.toml) ... done
Created wheel for tensorflow-decision-forests: filename=tensorflow_decision_forests-1.8.1-cp311-cp311-linux_aarch64.whl size=15337168 sha256=03d18654668776cdcf2a95d05aa515fd50a549db79aec814cdf91f2d0df8be48
Stored in directory: /home/pi/.cache/pip/wheels/3b/7a/d4/5ace9bca6f1e0b8a2409d1921d1f40bb66951c0df254eb9094
Building wheel for tensorstore (pyproject.toml) ... /

The last line Building wheel for tensorstore (pyproject.toml) ... / have been running for hours now and I don't know if I'm stuck or this just takes a lot of time to load.

Any ideas?

[pderrenger]

@RhongoAlter hi there!

It looks like you're experiencing a prolonged build time while installing the Ultralytics package on your Raspberry Pi. This can sometimes happen due to the limited processing power of the Raspberry Pi, especially when building wheels for larger packages.

Here are a few steps you can take to troubleshoot and potentially resolve this issue:

1. Ensure Latest Versions: First, make sure you are using the latest versions of torch and ultralytics. You can upgrade them using the following commands:

   pip install --upgrade torch ultralytics

2. Check System Resources: Verify that your Raspberry Pi has enough free memory and CPU resources. You can use the htop command to monitor system resources in real-time.

3. Increase Swap Space: If your Raspberry Pi is running out of memory, increasing the swap space might help. You can do this by editing the /etc/dphys-swapfile file and increasing the CONF_SWAPSIZE value. After editing, restart the swap service:

   sudo /etc/init.d/dphys-swapfile stop
   sudo /etc/init.d/dphys-swapfile start

4. Install Pre-built Wheels: Sometimes, installing pre-built wheels can save time. You can try installing pre-built wheels for the packages that are taking a long time to build:

   pip install psutil tensorflow-decision-forests tensorstore

5. Use Docker: If the above steps don't resolve the issue, consider using Docker to run Ultralytics YOLOv8. This method uses a pre-built Docker image optimized for Raspberry Pi, which can save you from the hassle of building packages. Here’s the command to pull and run the Docker container:

   t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t

For more detailed instructions on setting up Ultralytics YOLOv8 on Raspberry Pi, you can refer to our Quick Start Guide.

If you continue to face issues, please provide a minimum reproducible example of your setup and the exact steps you followed. This will help us better understand the problem and provide a more accurate solution. You can find more information on creating a minimum reproducible example here.

I hope this helps! Feel free to reach out if you have any more questions. 😊

[sophiedkk]

Hey there!

I can either plot or run inference from the webcam, but not at the same time. The RPi has 8GB of RAM so that should not be a limit. Does anyone have any ideas for testing? I feel like I've tried everything...

import cv2
from ultralytics import YOLO

import settings as s


def capture_and_process_frames(device: cv2.VideoCapture, model: YOLO):
    success, img = device.read()
    if not success:
        return
        
    results = model(img, stream=True, conf=s.MINIMUM_CONFIDENCE, imgsz=(s.IMAGE_HEIGHT, s.IMAGE_WIDTH))
    for r in results:
        boxes = r.boxes

        for box in boxes:
            x1, y1, x2, y2 = [int(value) for value in box.xyxy[0]]
            box_class = s.CLASS_NAMES[int(box.cls[0])]

            cv2.rectangle(img, (x1, y1), (x2, y2), color=(214, 66, 71), thickness=3)
            cv2.putText(img, text=f"{box_class}: {box.conf[0] * 100:.0f}%", org=[x1, y1], fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                        fontScale=1, color=(255, 86, 180), thickness=2)

    #cv2.imshow("Webcam", img)


if __name__ == "__main__":
    video_capture = cv2.VideoCapture(-1)
    video_capture.set(3, s.IMAGE_HEIGHT)
    video_capture.set(4, s.IMAGE_WIDTH)

    yolo_model = YOLO(s.MODEL, task="detect")

    # Event loop
    while True:
        capture_and_process_frames(video_capture, yolo_model)

        if cv2.waitKey(1) == ord("q"):
            break

    # Cleanup
    video_capture.release()
    cv2.destroyAllWindows()

If I uncomment the cv2.imshow it just hangs...
Best,
Sophie

[sophiedkk]

So in the end I just reinstalled the OS and now it works :)

[pderrenger]

@sophiedkk hi Sophie,

Thank you for sharing your experience and the code snippet! It's great to hear that reinstalling the OS resolved your issue. Sometimes a fresh start can clear up underlying problems that are hard to diagnose.

For future reference, if you encounter similar issues, here are a few troubleshooting steps you might find helpful:

1. Check OpenCV and Display Compatibility: Ensure that your OpenCV installation is compatible with your display settings. Sometimes, issues with cv2.imshow can stem from display driver problems or mismatched OpenCV versions.

2. Resource Management: Even though your RPi has 8GB of RAM, it's good practice to monitor resource usage. You can use tools like htop to check CPU and memory usage while running your script.

3. Streamlining Inference and Display: To ensure smooth operation, you might want to separate the inference and display logic into different threads. This can help in managing the workload more efficiently.

Here's an example of how you can use threading to handle inference and display concurrently:

import cv2
import threading
from ultralytics import YOLO

import settings as s

def capture_frames(device: cv2.VideoCapture, frame_queue):
    while True:
        success, img = device.read()
        if success:
            frame_queue.append(img)
        if cv2.waitKey(1) == ord("q"):
            break

def process_frames(frame_queue, model: YOLO):
    while True:
        if frame_queue:
            img = frame_queue.pop(0)
            results = model(img, stream=True, conf=s.MINIMUM_CONFIDENCE, imgsz=(s.IMAGE_HEIGHT, s.IMAGE_WIDTH))
            for r in results:
                boxes = r.boxes
                for box in boxes:
                    x1, y1, x2, y2 = [int(value) for value in box.xyxy[0]]
                    box_class = s.CLASS_NAMES[int(box.cls[0])]
                    cv2.rectangle(img, (x1, y1), (x2, y2), color=(214, 66, 71), thickness=3)
                    cv2.putText(img, text=f"{box_class}: {box.conf[0] * 100:.0f}%", org=(x1, y1), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                                fontScale=1, color=(255, 86, 180), thickness=2)
            cv2.imshow("Webcam", img)

if __name__ == "__main__":
    video_capture = cv2.VideoCapture(-1)
    video_capture.set(3, s.IMAGE_HEIGHT)
    video_capture.set(4, s.IMAGE_WIDTH)

    yolo_model = YOLO(s.MODEL, task="detect")

    frame_queue = []

    capture_thread = threading.Thread(target=capture_frames, args=(video_capture, frame_queue))
    process_thread = threading.Thread(target=process_frames, args=(frame_queue, yolo_model))

    capture_thread.start()
    process_thread.start()

    capture_thread.join()
    process_thread.join()

    video_capture.release()
    cv2.destroyAllWindows()

This approach uses two threads: one for capturing frames and another for processing them. It helps in balancing the load and ensuring that both tasks run smoothly.

For more detailed guidance on deploying YOLOv8 on Raspberry Pi, you can refer to our Raspberry Pi Quick Start Guide.

Feel free to reach out if you have any more questions or need further assistance. Happy coding! 😊

[KevenDuan]

Hello！
I'm running the following code on a Raspberry Pi 4 and I'm getting an error: ModuleNotFoundError: No module named 'ncnn'

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model to NCNN format
model.export(format="ncnn")  # creates 'yolov8n_ncnn_model'

# Load the exported NCNN model
ncnn_model = YOLO("yolov8n_ncnn_model")

# Run inference
results = ncnn_model("https://ultralytics.com/images/bus.jpg")

How can I solve this problem?

[pderrenger]

@KevenDuan hello! The error you're encountering indicates that the ncnn module is not found. This usually happens when the necessary dependencies for NCNN are not installed. Please ensure you have followed the setup instructions for installing the Ultralytics package with optional dependencies on your Raspberry Pi. Specifically, run:

sudo apt update
sudo apt install python3-pip -y
pip install -U pip
pip install ultralytics[export]
sudo reboot

After rebooting, try running your code again. If the issue persists, please check if the latest version of the Ultralytics package is installed. For more details, you can refer to the Raspberry Pi setup guide.

[KevenDuan]

After updating to the latest version, running found a new issue: ModuleNotFoundError: No module named 'ultralytics.nn.modules.conv'; 'ultralytics.nn.modules' is not a package.But I use the older version and it shows NCNN not found.How can this be solved?

[pderrenger]

@KevenDuan it seems like you're encountering issues with module imports. First, ensure you're using the latest version of the Ultralytics package. If the error persists, try reinstalling the package with the optional dependencies using pip install ultralytics[export]. For the NCNN issue, make sure all dependencies are correctly installed and the environment is properly set up. If the problem continues, please check the detailed setup instructions in the Raspberry Pi guide. This should help resolve the module-related errors.

[Hans530]

Hi!

first time for me using Yolo and a Raspberry Pi. I tried the quick start guide but unfortunatly I can't execute the python code:

`from ultralytics import YOLO

Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

Export the model to NCNN format
model.export(format="ncnn") # creates 'yolov8n_ncnn_model'

Load the exported NCNN model
ncnn_model = YOLO("yolov8n_ncnn_model")

Run inference
results = ncnn_model("https://ultralytics.com/images/bus.jpg")`

The error is: Illegal instruction
Trying to run python on the Pi already the first line produces the error.

I have tried this on Raspberry Pi 4 and Zero 2W with the lite 64Bit OS and on the Zero 2W with the non lite version. I don't know if its worth mentioning but the lite version required me to use sudo apt-get install libgl1-mesa-glx first otherwise I would get the Import Error: [libGl.so](http://libgl.so/).1: cannot open shared object file: No such file or directory

I have tried to downgrade torch and torchvision versions since I have read somewhere that torch 1.8.0 would resolve this but I was not successful installing the required earlier Python version (mine is 3.11.2).

Any help would be greatly appreciated!

[pderrenger]

It seems the issue is related to the compatibility of the PyTorch version with your Raspberry Pi. The "Illegal instruction" error often indicates that the software is trying to execute an instruction not supported by the CPU. Please ensure you are using the latest versions of the Ultralytics package and its dependencies. If the issue persists, you might want to try using a different version of PyTorch that is known to be compatible with your Raspberry Pi model. Alternatively, using the NCNN format for model inference on Raspberry Pi is highly recommended for better performance. For more detailed steps, please refer to our Raspberry Pi guide.

[Hans530]

@pderrenger Thank you very much for your support. I was able to get YoloV8 running by downgrading torch.

In case anyone encounters similar issues here are the versions I was able to work with:

1. I got an image of the legacy Pi OS (lite) 64Bit from 23-05-2023. This gives me Python 3.9.2 which from my understanding is necessary to support torch < 2.0.0
2. sudo apt install python3-pip -y, pip install -U pip
3. pip install ultralytics[export]
4. pip uninstall torch - My guess is 2.4.0 is not supported for Raspberry Pi 4
5. pip install torch==1.8.0 - which is succesful but also gives the error of incompatibility with torch vision 0.19.0
6. therefore pip uninstall torchvision
7. and pip install torchvision==0.9.1
8. sudo reboot
9. sudo apt-get install libgl1-mesa-glx gives to following error: E: Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?
10. sudo apt-get update
11. repeat 8
12. from there creating the path Documents/YOLO, followed by cd Documents/YOLO and yolo predict model='yolov8n' source='https://ultralytics.com/images/bus.jpg' should work

My guess from previous testing is that steps 9 to 11 are only necessary when choosing the LITE OS.

I am sure the commands are not best practice but at least these versions are running for me today.

[pderrenger]

@Hans530 thank you for sharing your solution. It's great to hear you got YOLOv8 running by downgrading torch. For others facing similar issues, using the legacy Pi OS and compatible torch versions can indeed help. If you encounter further issues, please ensure you're using the latest Ultralytics package and dependencies. For more detailed steps, you can refer to our Raspberry Pi guide.

[mobiden]

This advice worked for me. Thanks!

[glenn-jocher]

I'm glad to hear the advice worked for you! If you encounter any further issues or need additional guidance, feel free to refer to the Ultralytics documentation for more detailed information.

[Huzaifa71]

Iam using rasberry pi 4 model B in which i have install debian 12 and python version 3.11.2 a default python version but after too many efforts I have install ultralytics library by creating environment and when I run the code
from ultralytics import YOLO --> it won't give any error but when i write code
model= YOLO("yolov8s.pt") --> the code only execute and no output.
Another i have used it with python different versions python 3.8.0, 3.9.2, 3.9.6, 3.11.2 and 3.12.4 still not running the code.
Additionally then i used "sudo pip install ultralytics --break-system-packages" --> the package is installed but still not running what should i do i have spend 4 days on the same issue please guide me its urgent to deliver the project

[Huzaifa71]

Help me please 😓

[glenn-jocher]

@Huzaifa71 it sounds like you've put in a lot of effort already. Let's try a few more steps. First, ensure you're using the latest version of the Ultralytics package. You can update it with pip install --upgrade ultralytics. If the issue persists, try running the code with a different model, such as yolov8n.pt, to see if the problem is specific to yolov8s.pt. Additionally, check if any errors are logged in the terminal when you run the code. For more detailed guidance, visit our Raspberry Pi guide.

[KY-wwang]

hi!

I'm trying to use raspberry pi zero w to load the yolov8 model for image inspection, there seems to be no conda version for this board, so I created a virtual environment directly using venv and python version 3.9. But I'm having problems configuring the yolo environment for it.

I'm using pip install ultralytics[export] or pip install ultralytics doesn't work, I've already used sudo apt update, and pip install -U pip to update, what should I do?

[glenn-jocher]

@KY-wwang hi! For setting up Ultralytics YOLOv8 on a Raspberry Pi Zero W, ensure you have updated your packages and pip. Then, try installing with pip install ultralytics[export]. If issues persist, please refer to our detailed guide at https://docs.ultralytics.com/guides/raspberry-pi/.

[wodeyuzhou]

Hi!

I noticed an error in your guide and wanted to let you know.
To reproduce the Ultralytics benchmarks on all export formats, need to run this code:

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml", imgsz=640)

The error occurs at results = model.benchmarks(data="coco8.yaml", imgsz=640)
where it raises an AttributeError: 'YOLO' object has no attribute 'benchmarks'. Did you mean: 'benchmark'?

So we need to correct this code to:

results = model.benchmark(data="coco8.yaml", imgsz=640)

[glenn-jocher]

@wodeyuzhou thank you for catching that error. You're correct; the method should be benchmark instead of benchmarks. I've updated the guide accordingly. If you have any more questions, feel free to ask!

[feiwenxiong]

Use NCNN for Best Performance: Convert your YOLOv8 model to NCNN format for optimal performance on Raspberry Pi,but how should i adjust iou or conf as in normal model ?

[glenn-jocher]

@feiwenxiong to adjust the IOU or confidence settings for an NCNN model on Raspberry Pi, you can modify these parameters during inference using the conf and iou arguments in your code. For more details, please refer to the Raspberry Pi guide.

[Hancke]

YOLOv11 Installation and Training Issue on Raspberry Pi 5
Hi everyone,

I'm trying to train a YOLOv11 model on my PC for the Raspberry Pi 5. I've run into a couple of issues:

Installing Ultralytics: When I use pip install ultralytics, it seems to install YOLOv8 instead of YOLOv11. Is there a way to specifically install YOLOv11?

Training Error: I'm trying to train with the following code:
from ultralytics import YOLO
model = YOLO("yolov11n-obb.yaml")
results = model.train(data="my_dataset.yaml", epochs=100, imgsz=640)

But I'm getting this error:
FileNotFoundError: 'yolov11n-obb.yaml' does not exist

Where can I find the correct YAML file for YOLOv11?

Any help would be greatly appreciated!

Thanks,
Carlo

[glenn-jocher]

@Hancke hi Carlo,

To install YOLOv11, ensure you're using the latest Ultralytics package. For the YAML file, please check the Ultralytics repository for the correct configuration files. If you encounter further issues, feel free to explore our Raspberry Pi guide for additional setup details.

[Hancke]

YOLOv11 Installation and Training Issue on Raspberry Pi 5

Hi everyone,

I'm trying to train a YOLOv11 model on my PC for the Raspberry Pi 5. I've run into a couple of issues:

Installing Ultralytics: When I use pip install ultralytics, it seems to install YOLOv8 instead of YOLOv11. Is there a way to specifically install YOLOv11?

Training Error: I'm trying to train with the following code:
from ultralytics import YOLO
model = YOLO("yolov11n-obb.yaml")
results = model.train(data="my_dataset.yaml", epochs=100, imgsz=640)

But I'm getting this error:
FileNotFoundError: 'yolov11n-obb.yaml' does not exist

Where can I find the correct YAML file for YOLOv11?

Any help would be greatly appreciated!

Thanks,
Carlo

[glenn-jocher]

To install YOLOv11, ensure you're using the latest Ultralytics package. For the YAML file error, please verify the file path and name. You can find more details on setting up YOLO on Raspberry Pi here: https://docs.ultralytics.com/guides/raspberry-pi/.

[amits26]

Hi,

I am trying to install Ultralytics on Raspberry Pi zero 2w with Bookworm 32bit lite version. I am following below steps (without docker)

sudo apt update
sudo apt install python3-pip -y
pip install -U pip

pip install ultralytics[export]

I am getting below error after running above command.

(.venv) astropi2w@mypi2w:~ $ pip install ultralytics[export]
Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
Collecting ultralytics[export]
Downloading ultralytics-8.3.25-py3-none-any.whl.metadata (35 kB)
Requirement already satisfied: numpy>=1.23.0 in /usr/lib/python3/dist-packages (from ultralytics[export]) (1.24.2)
Collecting matplotlib>=3.3.0 (from ultralytics[export])
Downloading https://www.piwheels.org/simple/matplotlib/matplotlib-3.9.2-cp311-cp311-linux_armv7l.whl (7.8 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 7.8/7.8 MB 1.6 MB/s eta 0:00:00
Collecting opencv-python>=4.6.0 (from ultralytics[export])
Downloading opencv-python-4.10.0.84.tar.gz (95.1 MB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 95.1/95.1 MB 2.4 MB/s eta 0:00:00
Installing build dependencies ... error
error: subprocess-exited-with-error

× pip subprocess to install build dependencies did not run successfully.
│ exit code: 1
╰─> [103 lines of output]
Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple, https://www.piwheels.org/simple
Ignoring numpy: markers 'python_version == "3.6" and platform_machine != "aarch64" and platform_machine != "arm64"' don't match your environment
Ignoring numpy: markers 'python_version == "3.7" and platform_machine != "aarch64" and platform_machine != "arm64"' don't match your environment
Ignoring numpy: markers 'python_version == "3.8" and platform_machine != "aarch64" and platform_machine != "arm64"' don't match your environment
Ignoring numpy: markers 'python_version < "3.9" and sys_platform == "linux" and platform_machine == "aarch64"' don't match your environment
Ignoring numpy: markers 'python_version < "3.9" and sys_platform == "darwin" and platform_machine == "arm64"' don't match your environment
Collecting cmake>=3.1
Downloading cmake-3.30.5.tar.gz (31 kB)
Installing build dependencies: started
Installing build dependencies: finished with status 'done'
Getting requirements to build wheel: started
Getting requirements to build wheel: finished with status 'done'
Installing backend dependencies: started
Installing backend dependencies: finished with status 'error'
error: subprocess-exited-with-error

    × pip subprocess to install backend dependencies did not run successfully.
    │ exit code: 2
    ╰─> [74 lines of output]
        Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple, https://www.piwheels.org/simple, https://www.piwheels.org/simple
        Collecting ninja>=1.5
          Downloading https://www.piwheels.org/simple/ninja/ninja-1.11.1.1-cp311-cp311-linux_armv7l.whl (134 kB)
        Collecting cmake
          Using cached cmake-3.30.5.tar.gz (31 kB)
        ERROR: Exception:
        Traceback (most recent call last):
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/cli/base_command.py", line 105, in _run_wrapper
            status = _inner_run()
                     ^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/cli/base_command.py", line 96, in _inner_run
            return self.run(options, args)
                   ^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/cli/req_command.py", line 67, in wrapper
            return func(self, options, args)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/commands/install.py", line 379, in run
            requirement_set = resolver.resolve(
                              ^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/resolver.py", line 95, in resolve
            result = self._result = resolver.resolve(
                                    ^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/resolvers.py", line 546, in resolve
            state = resolution.resolve(requirements, max_rounds=max_rounds)
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/resolvers.py", line 397, in resolve
            self._add_to_criteria(self.state.criteria, r, parent=None)
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/resolvers.py", line 173, in _add_to_criteria
            if not criterion.candidates:
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/structs.py", line 156, in __bool__
            return bool(self._sequence)
                   ^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", line 174, in __bool__
            return any(self)
                   ^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", line 162, in <genexpr>
            return (c for c in iterator if id(c) not in self._incompatible_ids)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py", line 53, in _iter_built
            candidate = func()
                        ^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/factory.py", line 187, in _make_candidate_from_link
            base: Optional[BaseCandidate] = self._make_base_candidate_from_link(
                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/factory.py", line 233, in _make_base_candidate_from_link
            self._link_candidate_cache[link] = LinkCandidate(
                                               ^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/candidates.py", line 304, in __init__
            super().__init__(
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/candidates.py", line 159, in __init__
            self.dist = self._prepare()
                        ^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/candidates.py", line 236, in _prepare
            dist = self._prepare_distribution()
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/resolution/resolvelib/candidates.py", line 315, in _prepare_distribution
            return preparer.prepare_linked_requirement(self._ireq, parallel_builds=True)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/operations/prepare.py", line 527, in prepare_linked_requirement
            return self._prepare_linked_requirement(req, parallel_builds)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/operations/prepare.py", line 642, in _prepare_linked_requirement
            dist = _get_prepared_distribution(
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/operations/prepare.py", line 71, in _get_prepared_distribution
            with build_tracker.track(req, tracker_id):
          File "/usr/lib/python3.11/contextlib.py", line 137, in __enter__
            return next(self.gen)
                   ^^^^^^^^^^^^^^
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/operations/build/build_tracker.py", line 136, in track
            self.add(req, tracker_id)
          File "/home/astropi2w/.venv/lib/python3.11/site-packages/pip/_internal/operations/build/build_tracker.py", line 102, in add
            raise LookupError(message)
        LookupError: https://files.pythonhosted.org/packages/5b/b9/25938832b55a1ee59f11c55068107edeab9abdb2db873721c9aa405108f3/cmake-3.30.5.tar.gz (from https://pypi.org/simple/cmake/) (requires-python:>=3.7) is already being built: cmake>=3.1 from https://files.pythonhosted.org/packages/5b/b9/25938832b55a1ee59f11c55068107edeab9abdb2db873721c9aa405108f3/cmake-3.30.5.tar.gz
        [end of output]
  
    note: This error originates from a subprocess, and is likely not a problem with pip.
  error: subprocess-exited-with-error
  
  × pip subprocess to install backend dependencies did not run successfully.
  │ exit code: 2
  ╰─> See above for output.
  
  note: This error originates from a subprocess, and is likely not a problem with pip.
  [end of output]

note: This error originates from a subprocess, and is likely not a problem with pip.
error: subprocess-exited-with-error

× pip subprocess to install build dependencies did not run successfully.
│ exit code: 1
╰─> See above for output.

note: This error originates from a subprocess, and is likely not a problem with pip.

Can I get some help ?

Thanks
Amit S

[glenn-jocher]

@amits26 it seems you're encountering an issue with installing dependencies on the Raspberry Pi Zero 2W. This might be due to resource constraints or compatibility issues with certain packages. I recommend trying to install the packages individually to identify the problematic one, or consider using a pre-built Docker image for easier setup. For more detailed guidance, please refer to our Raspberry Pi setup guide at https://docs.ultralytics.com/guides/raspberry-pi/.

[amits26]

I was able to figure out the issue. Re-installing everything from scratch resolved the issue. Thanks.

now I am getting following error when I tried running code.

Traceback (most recent call last):
File "/home/astropi2w/piobjectdetection.py", line 14, in
from ultralytics import YOLO
ModuleNotFoundError: No module named 'ultralytics'

Ultralytics was successfully installed.

Thanks

[glenn-jocher]

It seems like the ultralytics module isn't being recognized. Please ensure that the virtual environment where you installed Ultralytics is activated when running your script. If the issue persists, try reinstalling the package within the active environment.

[Charlie2802]

Hi, Do you have a tutorial to run, yolo models on ncnn? using c++

[glenn-jocher]

@Charlie2802 currently, we do not have a specific C++ tutorial for running YOLO models on NCNN. However, you can refer to the Ultralytics documentation for guidance on exporting models to NCNN format: Use NCNN on Raspberry Pi. For C++ usage, you might need to explore the NCNN documentation or community resources for further integration details.

[danielbob32]

Hi,

1. Is there any benefit of using the raspberry pi Ai camera compared to the model 3 camera, and is it compatible with the model?
2. For running the model on the live stream, any recommendation on a "must have" hardware to accommodate the pi 5?
3. What are the effects of setting 'imgsz' from 640 to (1288,720 if i recall this is the maximum?), i always though that if i set the parameters to its default it wont work on the whole frame, am i correct ? and how does it affects the performance?
4. Is the segmentation model available here and can i go beyond nano?

thank you very much!

[glenn-jocher]

@danielbob32 1. The Raspberry Pi AI Camera provides on-chip AI processing, which enhances performance by reducing latency and addressing privacy concerns, but it requires compatibility checks with your hardware. The Model 3 Camera is simpler and sufficient for standard use cases.
2. For Raspberry Pi 5, using an SSD via the PCIe connector is recommended for better performance and durability over SD cards.
3. Increasing imgsz beyond 640 improves detail but may reduce inference speed and increase memory usage. The model processes the entire frame regardless of the imgsz setting, resizing it during preprocessing.
4. Segmentation models are available, and you can use larger models like YOLO11s if your hardware supports them.

Let me know if you need further clarification!

[danielbob32]

Thank you so much for the quick response!
What is the minimum hardware required then to run the model on it? To be more specific, is the basic Raspberry 5 board enough or should I add the Pi AI HAT+ ?
Also, just a wild thought, can I try to run the model on the Pi Zero 2, not a live stream but on a single image in intervals ?

[glenn-jocher]

The basic Raspberry Pi 5 board is sufficient to run YOLO11 models, especially with optimizations like the NCNN format. Adding the AI HAT+ can enhance performance for specific use cases. Running inference on the Pi Zero 2 with single images at intervals is feasible for lightweight models like YOLO11n, but expect slower processing times due to limited hardware capabilities. For more details, refer to the Raspberry Pi guide. Let us know if you need further assistance!

[Kemchik51]

Hi,
I am using raspberry pi 5 4 gb. How can I make real time video to detect object with YOLO 11 custom model (best.onnx) ?
I would be very glad if you could help me.

[glenn-jocher]

@Kemchik51 to perform real-time object detection using your custom YOLO11 model (best.onnx) on Raspberry Pi 5, you can use ONNX runtime for inference. Ensure you have the ONNX model and install the necessary dependencies using:

pip install onnxruntime

Then, use a library like OpenCV to process real-time video and feed frames to the ONNX model. For detailed guidance, refer to the Ultralytics Raspberry Pi Guide. Let us know if you need further assistance!

[Kemchik51]

Thank you for your help but I have also some questions with code:
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

Initialize the Picamera2

picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()

Load the YOLO11 model

model = YOLO("yolo11n.pt")

while True:
# Capture frame-by-frame
frame = picam2.capture_array()

# Run YOLO11 inference on the frame
results = model(frame)

# Visualize the results on the frame
annotated_frame = results[0].plot()

# Display the resulting frame
cv2.imshow("Camera", annotated_frame)

# Break the loop if 'q' is pressed
if cv2.waitKey(1) == ord("q"):
    break

Release resources and close windows

cv2.destroyAllWindows()

Should I just change model = YOLO("yolo11n.pt") to path with my .onnx model ?

[Kemchik51]

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
onnxruntime 1.17.3 requires numpy>=1.24.2, but you have numpy 1.23.5 which is incompatible.

[glenn-jocher]

The error indicates a version conflict between onnxruntime and numpy. To resolve this, update numpy to a compatible version (>=1.24.2) by running:

pip install --upgrade numpy

After updating, retry your installation. Let me know if you encounter further issues!

[chaudhariraj]

Hi,
I am using a Raspberry Pi 4 Model B with 4GB RAM and have deployed a custom YOLO detection model (best.pt) on it. The camera is accessed using the Picamera2 library, and while it works, the camera feed lags significantly.

I believe the lag is primarily due to the heavy best.pt model and the limited processing power of the Raspberry Pi. Despite adjusting the frame rate and resolution of the Picamera2 feed, the performance remains slow and laggy.

Here are the training parameters I used for the YOLO model:
model.train(
data="data.yaml", # Path to the data configuration file
epochs=100, # Number of training epochs
imgsz=640, # Image size
batch=16 # Batch size
)

Camera initialization and inference code snippet:

Load YOLO Custom model

model = YOLO("models/best.pt")

Initialize Picamera2

picam2 = Picamera2()
camera_config = picam2.create_preview_configuration(main={"size": (640, 480)})
picam2.configure(camera_config)
picam2.start()

while True:
# Capture frame from camera
frame = picam2.capture_array()

# Run YOLO model on the frame
results = model(frame, imgsz=320, verbose=False)

# Get the class names from the model
class_names = model.names

# Draw results on the frame
annotated_frame = frame.copy()
# Further processing...

How can I improve the performance and resolve the camera lag issue effectively? What is the best approach to deploy a YOLO custom model (best.pt) on a Raspberry Pi 4 Model B with 4GB RAM?

[glenn-jocher]

Thank you for the update! For achieving higher frame rates like 25 FPS, consider using a lighter model such as YOLO11n or YOLO11s, as they are optimized for better performance on devices like Raspberry Pi. For NCNN-related bounding box processing challenges, you can refer to the NCNN documentation for guidance and examples. If your current hardware still underperforms, upgrading to Raspberry Pi 5 or NVIDIA Jetson Nano would be a good choice for enhanced computational power. Let me know how it goes!

[chaudhariraj]

@glenn-jocher Sure! What if I convert best.pt to TensorFlow Lite? It seems like a better option for deployment on edge devices. Could you guide me through the steps to convert the YOLOv8 best.pt model to TFLite and use it in a script for real-time object detection on a Raspberry Pi 4 Model B device? I have experience with TensorFlow and deploying models on the Pi, but I’m unsure how to convert best.pt to TFLite specifically for use on the Raspberry Pi. Can you provide detailed step-by-step guidance?

[glenn-jocher]

@chaudhariraj to convert your YOLOv8 best.pt model to TensorFlow Lite (TFLite) for deployment on a Raspberry Pi 4, follow these steps:

1. Install the required dependencies:

   pip install ultralytics tensorflow

2. Use the export function to convert the model:

   from ultralytics import YOLO
   
   # Load the YOLOv8 model
   model = YOLO("best.pt")
   
   # Export the model to TFLite format
   model.export(format="tflite")  # Creates 'best_float32.tflite'

3. Deploy the TFLite model on your Raspberry Pi using TensorFlow Lite's Interpreter for inference. If you encounter challenges, refer to the TFLite documentation for additional support.

Let me know if you need further assistance!

[chaudhariraj]

@glenn-jocher, thank you! I’ve already tried converting the yolov8 best.pt model into formats like best.onnx, best_float32.tflite, and best.ncnn. However, these models only work correctly when used with Ultralytics and not independently with frameworks like TensorRT, NCNN, or ONNX.
When deployed on an edge device, such as the Raspberry Pi 4 Model B, the converted models work but are slow and laggy. On the other hand, a custom TensorFlow Lite model performs much better and runs without lag compared to the converted best_float32.tflite model, which does not work as expected.

Here’s converted model works with Ultralytics:
With NCNN:
from ultralytics import YOLO

Load the exported NCNN model

ncnn_model = YOLO("yolo11n_ncnn_model")

Run inference

results = ncnn_model("https://ultralytics.com/images/bus.jpg")

With Onnx:
from ultralytics import YOLO

Load the exported ONNX model

onnx_model = YOLO("yolo11n.onnx")

Run inference

results = onnx_model("https://ultralytics.com/images/bus.jpg")

With tflite:
from ultralytics import YOLO

Load the exported TFLite model

tflite_model = YOLO("yolo11n_float32.tflite")

Run inference

results = tflite_model("https://ultralytics.com/images/bus.jpg")

How can I use these converted models independently, without requiring Ultralytics, and optimize them for better performance and usability on the Raspberry Pi 4 Model B?

[glenn-jocher]

@chaudhariraj to use the converted models independently without Ultralytics, you'll need to leverage the respective frameworks (e.g., TensorFlow Lite Interpreter, ONNX Runtime, or NCNN SDK) for inference. For better performance on a Raspberry Pi 4, consider using a lighter model like YOLO11n or optimizing with quantization during export (e.g., full integer quantization for TFLite). Refer to the TFLite guide and NCNN documentation for framework-specific implementation details. Let us know if further assistance is needed!

[AmndanDwii]

Hello, currently I have a Raspberry Pi 4 and when I run Yolo I only get a few fps, now I'm confused whether it's better to buy a Pi Camera AI / buy a Raspberry Pi 5, so I can get better fps ?

[glenn-jocher]

@AmndanDwii to improve FPS, upgrading to a Raspberry Pi 5 is recommended as it offers significant performance improvements, including a faster CPU (2.4GHz vs. 1.8GHz), improved memory bandwidth, and PCIe support for SSDs. Additionally, using NCNN format for YOLO11 models can further optimize inference speed. Refer to the Raspberry Pi guide for setup and benchmarks.