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. 😊

[Franchis17]

Hi, I completed the steps on my Raspberry Pi 5 (followed steps for "Start with Docker"). No issues running the example called "Convert Model to NCNN and Run Inference" or the one called "Reproduce Our Results", but when I try to run "Use Raspberry Pi Camera" I am unable to successfully run "Test the Camera" or "Inference with Camera".

Running rpicam-hello results in "command not found"

Running the example "Inference with Camera" via Python code results in "No module named 'picamera2'".

It seems picamera2 is not installed. If I install it, then libcamera is not installed. If I try to install that, then I don't have the dependencies, and so on… Was the Ultralytics Docker Download/Setup supposed to take care of all making sure all those were installed? If yes, am I missing a step? There are not too many steps in the guide, so I am confused on what I could be missing.

In general I thought those were included by default with Debian 12.

[pderrenger]

Hi there,

Thank you for reaching out and providing detailed feedback on your experience with the Raspberry Pi setup. Let's address the issues you're encountering with the camera setup.

Issue 1: rpicam-hello Command Not Found

The rpicam-hello command is part of the libcamera suite, which should be included in the latest Raspberry Pi OS. If it's missing, you can install it using the following commands:

sudo apt update
sudo apt install libcamera-apps -y

After installation, try running rpicam-hello again.

Issue 2: Missing picamera2 Module

The picamera2 library is not included in the Docker image by default. You can install it manually:

pip install picamera2

If you encounter issues with libcamera dependencies, you can install them using:

sudo apt install libcamera-dev -y

This should resolve the dependency issues. If you continue to face problems, please ensure your system is fully updated:

sudo apt update
sudo apt upgrade -y

Docker Setup Clarification

The Docker setup is designed to simplify the environment setup, but it may not include all specific libraries like picamera2 or libcamera by default. These need to be installed manually within the Docker container.

Example: Running Inference with Camera

Here’s a complete example to ensure everything is set up correctly:

1. Install picamera2 and libcamera dependencies:

   sudo apt update
   sudo apt install libcamera-apps libcamera-dev -y
   pip install picamera2

2. Run the Python script for inference:

   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 YOLOv8 model
   model = YOLO("yolov8n.pt")
   
   while True:
       # Capture frame-by-frame
       frame = picam2.capture_array()
   
       # Run YOLOv8 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()

For more detailed steps and troubleshooting, please refer to our Raspberry Pi Guide.

I hope this helps! If you have any further questions or run into additional issues, feel free to ask. 😊

[Franchis17]

When I try to run apt install libcamera-apps libcamera-dev -y I get:

"Unable to locate package libcamera-apps"

Why?

[pderrenger]

Hi there,

Thank you for your message! It seems like you're encountering an issue with installing libcamera-apps. This package should indeed be available on the latest Raspberry Pi OS Bookworm (Debian 12). Let's troubleshoot this step by step:

1. Ensure Your Package List is Updated:
   First, make sure your package list is up-to-date. Run the following commands:

   sudo apt update
   sudo apt upgrade -y

2. Install libcamera-apps:
   After updating, try installing libcamera-apps again:

   sudo apt install libcamera-apps -y

3. Check Raspberry Pi OS Version:
   Verify that you are indeed running Raspberry Pi OS Bookworm. You can check your OS version with:

   cat /etc/os-release

If the issue persists, it might be due to repository issues or a temporary outage. As a workaround, you can manually install libcamera and its dependencies:

4. Manual Installation:

   sudo apt install libcamera0 libcamera-dev -y

For the picamera2 Module:

Since picamera2 is not included in the Docker image by default, you can install it manually:

pip install picamera2

If you encounter issues with libcamera dependencies, ensure they are installed as well:

sudo apt install libcamera-dev -y

Example: Running Inference with Camera

Here’s a complete example to ensure everything is set up correctly:

1. Install picamera2 and libcamera dependencies:

   sudo apt update
   sudo apt install libcamera-apps libcamera-dev -y
   pip install picamera2

2. Run the Python script for inference:

   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 YOLOv8 model
   model = YOLO("yolov8n.pt")
   
   while True:
       # Capture frame-by-frame
       frame = picam2.capture_array()
   
       # Run YOLOv8 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()

I hope this helps! If you have any further questions or run into additional issues, feel free to ask. 😊

[zqgdrmq]

sudo apt install libcamera-apps libcamera-dev -y

…

On Sun, Jun 16, 2024 at 9:59 PM Franchis17 ***@***.***> wrote: When I try to run apt install libcamera-apps libcamera-dev -y I get: "Unable to locate package libcamera-apps" Why? — Reply to this email directly, view it on GitHub <#8277 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADRYM6M6JPVBBV6LXASXYSLZHY7GTAVCNFSM6AAAAABDOHHWAKVHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TOOBZGQYTM> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

-- Nick.

[glenn-jocher]

@zqgdrmq hi Nick,

Thank you for reaching out! The error "Unable to locate package libcamera-apps" typically occurs when the package repository is not updated or the package is not available in the current repository list.

Here are a few steps to resolve this issue:

1. Update the Package List: Ensure your package list is up-to-date by running:

   sudo apt update

2. Check the Repository: Make sure you have the correct repository sources. You can add the necessary repository by editing the sources list:

   sudo nano /etc/apt/sources.list

   Add the following line if it's not already present:

   deb http://archive.raspberrypi.org/debian/ bookworm main

   Save and exit the editor, then update the package list again:

   sudo apt update

3. Install the Packages: Now, try installing the packages again:

   sudo apt install libcamera-apps libcamera-dev -y

If you continue to face issues, please ensure you are running the latest Raspberry Pi OS Bookworm (Debian 12). For detailed steps on setting up your Raspberry Pi, you can refer to our Quick Start Guide: Raspberry Pi with Ultralytics YOLOv8.

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

[Franchis17]

Glenn, this solved my issue, but I ended up having to add "[trusted=yes]" right after "deb" and then had issues with key, so I had to run "wget https://archive.raspberrypi.org/debian/raspberrypi.gpg.key -O - | sudo apt-key add" then run "apt-get update --allow-unauthenticated". All those to break past several errors.

No my issue is the camera is not available within the Docker container. Do you know the specific command I need to pass when creating the container to ensure the camera gets passed to the container?

[glenn-jocher]

Hi @Franchis17,

I'm glad to hear that you managed to resolve the initial issue with the repository keys! For your current issue with accessing the camera within the Docker container, you need to ensure that the container has the necessary permissions and access to the host's devices.

When creating the Docker container, you can pass the --device flag to grant access to the camera. Here’s how you can do it:

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

This command assumes your camera is accessible at /dev/video0. If your camera is connected to a different device path, adjust the --device flag accordingly.

Additionally, you might need to ensure that the user inside the Docker container has the necessary permissions to access the camera device. You can do this by running the container with elevated privileges using the --privileged flag:

sudo docker run -it --ipc=host --device /dev/video0 --privileged $t

This should allow the Docker container to access the camera. If you encounter any further issues, please let us know!

For more detailed guidance on setting up and using YOLOv8 on Raspberry Pi, including camera integration, you can refer to our Quick Start Guide: Raspberry Pi with Ultralytics YOLOv8.

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

[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]

@Hans530 hi! It seems you're encountering an "Illegal instruction" error when running YOLO on your Raspberry Pi. This issue can often be related to compatibility between the software and the hardware architecture. First, ensure you're using the latest versions of the Ultralytics package and dependencies. You can update your packages with sudo apt update && sudo apt upgrade. If the issue persists, try using the Docker setup as it provides a more controlled environment. For more detailed steps, please refer to our Raspberry Pi guide. Let me know if you need further assistance!

[Hans530]

@pderrenger Hi! Thanks for your reply. I tried the Docker setup following the guide (even though I am not sure everything is setup correctly). Took me a while to figure out to install Docker first with.

> curl -fsSL https://get.Docker.com -o get-Docker.sh
> sudo sh get-Docker.sh

Here is my new error:

> hans@pi:~ $ t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t
> latest-arm64: Pulling from ultralytics/ultralytics
> Digest: sha256:9dfa544b32d31904ac2419a2ce2adc5a82ceec692264e65d2e5cca8277f2bf7f
> Status: Image is up to date for ultralytics/ultralytics:latest-arm64
> docker.io/ultralytics/ultralytics:latest-arm64
> root@39cfb71a12d1:/usr/src/ultralytics# python3
> Python 3.11.2 (main, May  2 2024, 11:59:08) [GCC 12.2.0] on linux
> Type "help", "copyright", "credits" or "license" for more information.
> >>> from ultralytics import YOLO
> Illegal instruction (core dumped)

[Hans530]

it seems to me that this issue is somehow related to torch

root@39cfb71a12d1:/usr/src/ultralytics# python
Python 3.11.2 (main, May  2 2024, 11:59:08) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
Illegal instruction (core dumped)

[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.