How to Install Python 3.11 and TensorFlow on Raspberry Pi 5

The Raspberry Pi, a versatile and powerful single-board computer, has become a cornerstone for makers, hobbyists, and enthusiasts alike. Its affordability and accessibility have opened the door for exploring a vast array of projects, from basic electronics to sophisticated machine learning applications. Today, we're diving into the world of object detection with TensorFlow Lite, specifically on the latest Raspberry Pi 5, leveraging the power of Python 3.11.

TensorFlow Lite is a lightweight framework designed for deploying machine learning models on devices with limited resources. It's a game-changer for projects where computational power is constrained but deep learning capabilities are desired. By leveraging the capabilities of TensorFlow Lite, we can implement real-time object detection directly on your Raspberry Pi 5, enabling a wide range of innovative applications.

This tutorial will guide you through the process of setting up TensorFlow Lite for object detection on your Raspberry Pi 5, making the most of the updated Raspberry Pi OS Bookworm and Python 3.11.

Step 1: Ensuring a Solid Foundation

Before embarking on this journey, it's essential to ensure your Raspberry Pi 5 is running the latest software updates. This ensures optimal compatibility and avoids potential conflicts.

Open a terminal window and execute the following commands:

sudo apt-get update
sudo apt-get dist-upgrade
    

These commands will update your package lists and upgrade your system to the latest stable versions, providing you with the best possible starting point.

Step 2: The TensorFlow Lite Repository - Your Starting Point

To begin, we'll be working with the TensorFlow Lite object detection project hosted on GitHub. This repository is a treasure trove of code, documentation, and resources to kickstart your object detection journey.

Let's clone the repository to your Raspberry Pi:

git clone https://github.com/EdjeElectronics/TensorFlow-Lite-Object-Detection-on-Android-and-Raspberry-Pi.git
    

For convenience, rename the cloned folder and navigate into it:

mv TensorFlow-Lite-Object-Detection-on-Android-and-Raspberry-Pi tflite
cd tflite
    

Step 3: Creating a Secure Environment

To manage dependencies and avoid conflicts with system-wide packages, we'll set up a virtual environment within the tflite directory.

Create the virtual environment using the following command:

      python -m venv tflite-env
    

Activate the newly created virtual environment:

      source tflite-env/bin/activate
    

Now, any packages you install will be confined to this environment, ensuring a clean and organized development setup.

Step 4: Tailoring the Initialization Script

The get_pi_requirements.sh script is crucial for installing the necessary dependencies. However, we'll need to modify it slightly to accommodate the nuances of Python 3.11 and the latest Raspberry Pi OS.

Open the script in a text editor using the following command:

      nano get_pi_requirements.sh
    

Locate the following line:

      pip3 install opencv-python==3.4.11.41
    

Replace it with:

      ./tflite-env/bin/python3.11 -m pip install opencv-python==3.4.11.41
    

This modification ensures OpenCV is installed correctly within your virtual environment using Python 3.11.

Next, add the following code snippet at the end of the script:

if [ $version == "3.11" ]; then
./tflite-env/bin/python3.11 -m pip install tflite-runtime
fi
    

This ensures the TensorFlow Lite runtime for Python 3.11 is installed.

Save your changes and exit the text editor (Ctrl + X, then Y, and Enter if using nano).

Now, execute the modified initialization script:

      sudo bash get_pi_requirements.sh
    

This will install all the required dependencies for TensorFlow Lite on your Raspberry Pi 5.

Step 5: Downloading Pre-trained Models

To expedite our object detection experiment, we'll utilize a pre-trained model provided by Google. This model is already trained to recognize various common objects, allowing us to focus on the implementation and testing process.

Download the pre-trained model using the following commands:

wget https://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip
unzip coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip -d Sample_TFLite_model
    

The coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip model is a suitable starting point for our experiment, offering detection capabilities for various everyday objects.

Step 6: Adapting the Detection Script

With the release of Raspberry Pi OS Bookworm, the camera libraries have been updated. We'll need to modify the TFLite_detection_webcam.py script to ensure compatibility with the new picamera2 library.

Open the detection script in a text editor:

      nano TFLite_detection_webcam.py
    

Step 6.1: Importing the Necessary Components

At the beginning of the script, add the following import statements:

from threading import Thread, Lock
from picamera2 import Picamera2
    

Step 6.2: Replacing the VideoStream Class

Locate the existing VideoStream class within the script and replace it with the following code:

class VideoStream:
    def __init__(self, resolution=(640, 480), framerate=30):
        self.picam2 = Picamera2()
        config = self.picam2.create_preview_configuration(
            main={"size": resolution, "format": "RGB888"},
            controls={"FrameRate": framerate}
        )
        self.picam2.configure(config)
        self.picam2.start()
        self.frame = self.picam2.capture_array()
        self.stopped = False
        self.read_lock = Lock()

    def start(self):
        Thread(target=self.update, args=(), daemon=True).start()
        return self
    
    def update(self):
        while not self.stopped:
            frame = self.picam2.capture_array()
            with self.read_lock:
                self.frame = frame
        self.picam2.stop()

    def read(self):
        with self.read_lock:
            return self.frame.copy()
        
    def stop(self):
        self.stopped = True
    

This updated VideoStream class utilizes the picamera2 library, ensuring compatibility with the latest Raspberry Pi OS version.

Save your changes and exit the text editor.

Step 7: Witnessing the Results

It's time to put everything together and see our object detection setup in action.

Execute the detection script using the following command:

./tflite-env/bin/python3.11 TFLite_detection_webcam.py --modeldir ./Sample_TFLite_model
    

A window should appear displaying the live video feed from your Raspberry Pi 5 camera. You should observe detected objects within the video frame, highlighted with bounding boxes and labeled with their corresponding classifications.

Conclusion

Congratulations! You've successfully installed TensorFlow Lite on your Raspberry Pi 5, equipped with Python 3.11, and are now ready to embark on object detection adventures. The world of object detection is vast and exciting, and this is merely the starting point.

You can experiment with different pre-trained models, fine-tune existing models to achieve better accuracy for specific object recognition, and delve into the world of custom model training for even more personalized projects. The power of TensorFlow Lite and the Raspberry Pi 5 allows you to bring your machine learning visions to life, opening up a world of possibilities for creative projects, innovative solutions, and a deeper understanding of the power of deep learning.