Getting Started with TensorFlow on Raspberry Pi

Introduction

This page will guide you on installing TensorFlow on a Raspberry Pi 4 running the 64-bit Bullseye operating system.

TensorFlow is a large software library developed specifically for deep learning, which consumes a lot of resources. You can run TensorFlow on a Raspberry Pi 4, but do not expect miraculous performance. If the model is not too complex, it can run your model, but it cannot train new models or perform so-called transfer learning. Besides running your pre-built deep learning models, you can also use this library to convert so-called frozen TensorFlow models to TensorFlow Lite flat buffer models.

If you only want a preliminary understanding of deep learning, consider installing TensorFlow Lite. It is faster and uses fewer resources since it is designed for small computers like the Raspberry Pi. You can use many ready-made models. For a guide on installation on a 64-bit Raspberry Pi, see here.

Roadmap

TensorFlow is constantly evolving. Each new version requires more resources, supporting software, and libraries. It places an increasing burden on your Raspberry Pi. This explains why the latest versions do not perform well on “old” Raspberry Pi running “outdated” operating systems.

On the other hand, it is not recommended to install very old versions of TensorFlow on the latest Bullseye. You will have to downgrade some system libraries, which will cause other software to malfunction. The motto here is: “Go with the flow.”

Below is an overview. The green checkmark indicates available wheel files. An empty green box indicates no wheel files but can still be installed. A gray box indicates hardware or software limitations that prevent a “normal” installation.

Tips

We frequently receive inquiries about whether there is an SD card image for the Raspberry Pi 4 pre-installed with frameworks and deep learning examples.We are pleased to meet this request. Please find a fully working Raspberry Pi 4 dedicated to deep learning on our GitHub page. Download the zip file from our GDrive site, unzip it, and flash the image onto a 32GB SD card, then enjoy!

https://github.com/Qengineering/RPi-Bullseye-DNN-image

We discussed two installations, one for Python 3 and the other for the C++ API library. Unfortunately, there are no official aarch64 pip3 wheel files available for versions 2.7, 2.6, or 2.5. However, we created wheel files using Bazel and made them available on GitHub for your use.

The last part of this guide discusses the installation of Keras.

Preparation

Numpy

TensorFlow has encountered issues with the latest version of numpy. Porting TensorFlow to numpy 1.20 has become a real challenge. Now, with the release of TensorFlow version 2.8.0, it has finally succeeded. Finally, there are no numpy version conflicts when installing TensorFlow.

However, TensorFlow 2.7.0 still reports some issues. To ensure everything works correctly, please use numpy version 1.19.5 with TF 2.7.0.

libclang 9.0.1

TensorFlow 2.7.0 depends on libclang 9.0.1. Debian 10 does not have an available release for it. That is why TensorFlow 2.7 is only available for Debian 11 (Bullseye). You may be able to install libclang 9.0.1 from scratch on your Buster RPi before installing TensorFlow. Please note that building clang requires enormous resources, over 5GB. It is best to switch to Bullseye and get TensorFlow running within half an hour.

Protobuffer 4.21

The latest version of Protobuffer 4.21.0 has some significant improvements over the previous version 3.20.1. However, TensorFlow does not yet support these changes. To make TensorFlow work, if you have installed 4.21, you need to downgrade your Protobuf to version 3.20.

For more information on how to downgrade, please check our GitHub page.

https://github.com/Qengineering/TensorFlow-Raspberry-Pi_64-bit#tensorflow-2100

tensorflow-io-gcs-filesystem

All dependencies can be installed with one command except for the tensorflow-io-gcs filesystem. Since there is no release for aarch64 machines, we have to build the tensorflow-io-gcs filesystem from scratch. The entire process can be found below and should be completed before installing TensorFlow itself. If you let TensorFlow install io-gcs, it will select the wrong version and will not work.

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# install pip3
$ sudo apt-get install git python3-pip
# install correct version protobuf
$ sudo -H pip3 install --upgrade protobuf==3.20.0
Method 1
# download tensorflow io
$ git clone -b v0.23.1 --depth=1 --recursive https://github.com/tensorflow/io.git
$ cd io
$ python3 setup.py -q bdist_wheel --project tensorflow_io_gcs_filesystem
$ cd dist
$ sudo -H pip3 install tensorflow_io_gcs_filesystem-0.23.1-cp39-cp39-linux_aarch64.whl
$ cd ~
Method 2
# or download wheel
$ git clone https://github.com/Qengineering/Tensorflow-io.git
$ cd Tensorflow-io
$ sudo -H pip3 install tensorflow_io_gcs_filesystem-0.23.1-cp39-cp39-linux_aarch64.whl
$ cd ~

TensorFlow Python 3.9 Wheel Files

TensorFlow is installed using a software installer called Bazel developed by Google. Finally, Bazel generates a wheel file to install the Python version of TensorFlow or a tarball file when it comes to installing the C++ version. Both methods are familiar to Raspberry Pi users. We have published the results of Bazel on our GitHub page. Feel free to use these wheel files. The entire TensorFlow installation process takes several hours (about 64 hours for the Python version and about 1 hour for the C++ library version). Since all the tedious work has been done, installing TensorFlow on your Raspberry Pi 64-bit Bullseye only takes a few minutes. For stubborn users, the complete process will be described later in this manual.

The entire shortcut process is as follows. Since the wheel files are too large to be stored on GitHub, Google Drive was used.

TensorFlow 2.14.0

# install TensorFlow 2.14.0
$ sudo -H pip3 install --upgrade tensorflow==2.14.0

TensorFlow 2.13.0

# install TensorFlow 2.13.0
$ sudo -H pip3 install --upgrade tensorflow==2.13.0

TensorFlow 2.12.0

# install TensorFlow 2.12.0
$ sudo -H pip3 install --upgrade tensorflow==2.12.0

TensorFlow 2.11.0

# install TensorFlow 2.11.0
$ sudo -H pip3 install --upgrade tensorflow==2.11.0

TensorFlow 2.10.0

# install gdown to download from Google drive
$ sudo -H pip3 install gdown
# download the wheel
$ gdown https://drive.google.com/uc?id=1G2P-FaHAXJ-UuQAQn_0SYjNwBu0aShpd
# install TensorFlow 2.10.0
$ sudo -H pip3 install tensorflow-2.10.0-cp39-cp39-linux_aarch64.whl

TensorFlow 2.9.1

# install gdown to download from Google drive
$ sudo -H pip3 install gdown
# download the wheel
$ gdown https://drive.google.com/uc?id=1xP6ErBK85SMFnQamUh4ro3jRmdCV_qDU
# install TensorFlow 2.9.1
$ sudo -H pip3 install tensorflow-2.9.1-cp39-cp39-linux_aarch64.whl

TensorFlow 2.8.1

# install gdown to download from Google drive
$ sudo -H pip3 install gdown
# download the wheel
$ gdown https://drive.google.com/uc?id=1YpxNubmEL_4EgTrVMu-kYyzAbtyLis29
# install TensorFlow 2.8.0
$ sudo -H pip3 install tensorflow-2.8.0-cp39-cp39-linux_aarch64.whl

TensorFlow 2.7.0

# utmost important: use only numpy version 1.19.5
# check the version first
$ pip3 list | grep numpy
# if not version 1.19.5, update!
$ sudo -H pip3 install numpy==1.19.5
# (re)install termcolor at the correct location
$ python3 -m pip install termcolor
# install gdown to download from Google drive
$ sudo -H pip3 install gdown
# download the wheel
$ gdown https://drive.google.com/uc?id=1FdVZ1kX5QZgWk2SSgq31C2-CF95QhT58
# install TensorFlow 2.7.0
$ sudo -H pip3 install tensorflow-2.7.0-cp39-cp39-linux_aarch64.whl

When the installation is successful, you should see the following screenshot.

TensorFlow C++ API.

If you plan to program in C++, you will need a build version of TensorFlow’s C++ API instead of the Python version. Using the pre-built tarball file from our GitHub page to install the C++ library can save you a lot of time. Please follow the steps below.

TensorFlow 2.10.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# remove old versions (if found)
$ sudo rm -r /usr/local/lib/libtensorflow*
$ sudo rm -r /usr/local/include/tensorflow
# the dependencies
$ sudo apt-get install wget curl libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatomic1 libatlas-base-dev zip unzip
# install gdown to download from Google drive (if not already done)
$ sudo -H pip3 install gdown
# download the tarball
$ gdown https://drive.google.com/uc?id=1GOC5CiT5Ws2NpiBem4K3g3FRqmGDRcL7
# unpack the ball
$ sudo tar -C /usr/local -xzf libtensorflow_cp39_64OS_2_10_0.tar.gz

TensorFlow 2.9.1

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# remove old versions (if found)
$ sudo rm -r /usr/local/lib/libtensorflow*
$ sudo rm -r /usr/local/include/tensorflow
# the dependencies
$ sudo apt-get install wget curl libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatomic1 libatlas-base-dev zip unzip
# install gdown to download from Google drive (if not already done)
$ sudo -H pip3 install gdown
# download the tarball
$ gdown https://drive.google.com/uc?id=1Z83_RQTvCb2jL2BO1Zdez3x4Qx-XheRk
# unpack the ball
$ sudo tar -C /usr/local -xzf libtensorflow_cp39_64OS_2_9_1.tar.gz

TensorFlow 2.8.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# remove old versions (if found)
$ sudo rm -r /usr/local/lib/libtensorflow*
$ sudo rm -r /usr/local/include/tensorflow
# the dependencies
$ sudo apt-get install wget curl libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatomic1 libatlas-base-dev zip unzip
# install gdown to download from Google drive (if not already done)
$ sudo -H pip3 install gdown
# download the tarball
$ gdown https://drive.google.com/uc?id=1dmJKIk8lUi_XCzlVnRgL-UvfVFriRmCG
# unpack the ball
$ sudo tar -C /usr/local -xzf libtensorflow_cp39_64OS_2_8_0.tar.gz

TensorFlow 2.7.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# remove old versions (if found)
$ sudo rm -r /usr/local/lib/libtensorflow*
$ sudo rm -r /usr/local/include/tensorflow
# the dependencies
$ sudo apt-get install wget curl libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatomic1 libatlas-base-dev zip unzip
# install gdown to download from Google drive (if not already done)
$ sudo -H pip3 install gdown
# download the tarball
$ gdown https://drive.google.com/uc?id=1kScCKyj0pr265XbCgYmXqXs77xJFe6p1
# unpack the ball
$ sudo tar -C /usr/local -xzf libtensorflow_cp39_64OS_2_7_0.tar.gz

Finally, your TensorFlow library should be installed in the /usr/local/lib location, and the header files should be located in the /usr/local/include/tensorflow/c folder.

Installation from Scratch

For TensorFlow 2.14 and above

https://qengineering.eu/install-tensorflow-on-raspberry-pi-5.html

Swap Space Size

Building the complete TensorFlow package requires more than 6GB of memory. If you have a Raspberry Pi 4 with 8GB of memory, you can easily handle this. Otherwise, make sure to increase the swap space size to meet this requirement. If your device has 4GB of memory, zram can provide an additional 2GB of space. If you only have 2GB of memory, you cannot rely on zram for more than 2x compression. In this case, you need to reinstall dphys-swapfile to get extra space from the SD card. If you need to install dphys-swapfile, please follow the commands below. When setting up swap space on the Bullseye operating system, the reboot process may take a long time.

# install dphys-swapfile
$ sudo apt-get install dphys-swapfile
# give the required memory size
$ sudo nano /etc/dphys-swapfile
# reboot afterwards
$ sudo reboot

If everything goes smoothly, you should see something similar to the content below.

The image shows the total amount of swap space allocated by dphys-swapfile and zram. Once completed, do not forget to remove dphys-swapfile.

Note: If you have both zram and dphys-swapfile enabled at the same time to reboot the Raspberry Pi, zram will disable dphys-swapfile at boot. You must manually reactivate this service.

# reactivate dphys-swapfile after a reboot
# (when zram and dphys-swapfile are both enabled)
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start

Bazel

Bazel is a free software tool provided by Google for automating the building and testing of software packages. You can compare it to CMake used with OpenCV, but the latter is only for building software and does not have testing capabilities. Bazel is written in Java, which is a platform-independent language that is largely based on C++ syntax. To compile Bazel, we first need to install Java and some other dependencies using the following commands.

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# install pip and pip3
$ sudo apt-get install python3-pip
# install some tools
$ sudo apt-get install zip unzip curl
# install Java
$ sudo apt-get install openjdk-11-jdk

Next, we can download and extract the Bazel software. TensorFlow 2.10 requires Bazel version 5.1.1, so make sure you have the correct version installed.

$ wget https://github.com/bazelbuild/bazel/releases/download/5.1.1/bazel-5.1.1-dist.zip
$ unzip -d bazel bazel-5.1.1-dist.zip
$ cd bazel

During installation, Bazel will use a predetermined proportion of available working memory. Due to the limited RAM size of the Raspberry Pi, this proportion is too small. To prevent crashes, we must set this memory size to a maximum of 40% of the onboard RAM. For example, for a Raspberry Pi with 2GB RAM, it should be set to 800MB. This can be achieved by adding some extra information to the script file compile.sh. You can add the text -J -Xmx800M to the line that starts with run.. (around line 144). See the screenshot below. Use the common , , to save changes (see the slides above).

$nano scripts/bootstrap/compile.sh -c

Once Bazel’s Java environment is maximized, you can start building the Bazel software using the command below. After completion, copy the binary to the /usr/local/bin location so that bash can find the executable anywhere. The last step is to delete the zip file. The entire build process takes about 33 minutes.

# start the build
$ env EXTRA_BAZEL_ARGS="--host_javabase=@local_jdk//:jdk" bash ./compile.sh
# copy the binary
$ sudo cp output/bazel /usr/local/bin/bazel
# clean up
$ cd ~
$ rm bazel-5.1.1-dist.zip
# if you have a copied bazel to /usr/local/bin you may also
# delete the whole bazel directory, freeing another 500 MByte
$ sudo rm -rf bazel

Installing TensorFlow for Python 3

Once Bazel is running smoothly, we can start building TensorFlow 2.10.0 for Python 3 on our 64-bit Raspberry Pi. This has almost become the standard practice. First, install some dependencies, then download the zip file from GitHub, and finally extract the software. You also need to install the tensorflow_io_gcs filesystem. This can be done by using the precompiled wheel file we obtained from the GitHub repository.

TensorFlow 2.10.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# the dependencies
$ sudo apt-get install zip unzip
$ sudo -H pip3 install keras_applications --no-deps
$ sudo -H pip3 install keras_preprocessing --no-deps
# install correct version protobuf
$ sudo -H pip3 install --upgrade protobuf==3.20.0
# download tensorflow io
$ git clone https://github.com/Qengineering/Tensorflow-io.git
$ cd Tensorflow-io
$ sudo -H pip3 install tensorflow_io_gcs_filesystem-0.23.1-cp39-cp39-linux_aarch64.whl
$ cd ~
# download TensorFlow 2.10.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.10.0.zip
$ unzip tensorflow.zip
$ cd tensorflow-2.10.0
$ ./configure

TensorFlow 2.9.1

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# the dependencies
$ sudo apt-get install zip unzip
$ sudo -H pip3 install keras_applications --no-deps
$ sudo -H pip3 install keras_preprocessing --no-deps
# install correct version protobuf
$ sudo -H pip3 install --upgrade protobuf==3.20.0
# download tensorflow io
$ git clone https://github.com/Qengineering/Tensorflow-io.git
$ cd Tensorflow-io
$ sudo -H pip3 install tensorflow_io_gcs_filesystem-0.23.1-cp39-cp39-linux_aarch64.whl
$ cd ~
# download TensorFlow 2.9.1
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.9.1.zip
$ unzip tensorflow.zip
$ cd tensorflow-2.9.1
$ ./configure

TensorFlow 2.8.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# the dependencies
$ sudo apt-get install zip unzip
$ sudo -H pip3 install keras_applications --no-deps
$ sudo -H pip3 install keras_preprocessing --no-deps
# install correct version protobuf
$ sudo -H pip3 install --upgrade protobuf==3.20.0
$ cd ~
# download TensorFlow 2.8.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.8.0.zip
$ unzip tensorflow.zip
$ cd tensorflow-2.8.0
$ ./configure

TensorFlow 2.7.0

# get a fresh start
$ sudo apt-get update
$ sudo apt-get upgrade
# the dependencies
$ sudo apt-get install zip unzip
$ sudo -H pip3 install keras_applications --no-deps
$ sudo -H pip3 install keras_preprocessing --no-deps
# download TensorFlow 2.7.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.7.0.zip
$ unzip tensorflow.zip
$ cd tensorflow-2.7.0
$ ./configure

The last step before building the Python 3 installation wheel is to configure your build with some environment variables. This is done via the ./configure script file. Set Python 3 as the default Python version and answer “no” to other questions.

pi@raspberrypi:~/tensorflow-2.10.0 $ ./configure
You have bazel 5.1.1- (@non-git) installed.
Please specify the location of python. [Default is /usr/bin/python3]: <enter>
Found possible Python library paths: /usr/lib/python3/dist-packages /usr/local/lib/python3.9/dist-packages
Please input the desired Python library path to use.  Default is [/usr/lib/python3/dist-packages] <enter>
Do you wish to build TensorFlow with ROCm support? [y/N]: n
No ROCm support will be enabled for TensorFlow.
Do you wish to build TensorFlow with CUDA support? [y/N]: n
No CUDA support will be enabled for TensorFlow.
Do you wish to download a fresh release of clang? (Experimental) [y/N]: n
Clang will not be downloaded.
Please specify optimization flags to use during compilation when bazel option "--config=opt" is specified [Default is -Wno-sign-compare]: <enter>
Would you like to interactively configure ./WORKSPACE for Android builds? [y/N]: n
Not configuring the WORKSPACE for Android builds.
Preconfigured Bazel build configs. You can use any of the below by adding "--config=<>" to your build command. See .bazelrc for more details.
--config=mkl          # Build with MKL support.
--config=mkl_aarch64 # Build with oneDNN and Compute Library for the Arm Architecture (ACL).
--config=monolithic   # Config for mostly static monolithic build.
--config=numa         # Build with NUMA support.
--config=dynamic_kernels # (Experimental) Build kernels into separate shared objects.
--config=v2           # Build TensorFlow 2.x instead of 1.x.
Preconfigured Bazel build configs to DISABLE default on features:
--config=noaws        # Disable AWS S3 filesystem support.
--config=nogcp        # Disable GCP support.
--config=nohdfs       # Disable HDFS support.
--config=nonccl       # Disable NVIDIA NCCL support.
Configuration finished

Now that the script file is set up, you can start executing a large-scale build using the command below. -Xmx1624m sets the memory size for Bazel’s Java environment. Allocate as much space as possible. We recommend allocating 80% of your Raspberry Pi’s memory size. In our case, the onboard memory is 2 Gbyte, so 1624 Mbyte leaves enough space for other threads besides Bazel.

Another point is the number of cores used by Basel. It is best to use one core. Better to be slightly slower than to crash (always at the last moment) and restart.

Close all other applications during the build process. The fewer other processes running, the faster the compilation speed.

$ sudo bazel clean
$ sudo bazel --host_jvm_args=-Xmx1624m build \
             --config=opt \
             --config=noaws \
             --config=nogcp \
             --config=nohdfs \
             --config=nonccl \
             --config=monolithic \
             --config=v2 \
             --local_cpu_resources=1 \
             --define=tflite_pip_with_flex=true \
             --copt=-ftree-vectorize \
             --copt=-funsafe-math-optimizations \
             --copt=-ftree-loop-vectorize \
             --copt=-fomit-frame-pointer \
             //tensorflow/tools/pip_package:build_pip_package

After compiling for 41 hours (or longer!), hopefully, you will see the following screen.

Now we need to generate the wheel file and install it. This can be done with the command below. The installation process takes only a few minutes.

TensorFlow 2.10.0

# synthesize the wheel
$ sudo bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
$ cd ~
# go to the folder where the wheel is located and install tensorflow
$ cd /tmp/tensorflow_pkg
$ sudo -H pip3 install tensorflow-2.10.0-cp39-cp39-linux_aarch64.whl

TensorFlow 2.9.1

# synthesize the wheel
$ sudo bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
$ cd ~
# go to the folder where the wheel is located and install tensorflow
$ cd /tmp/tensorflow_pkg
$ sudo -H pip3 install tensorflow-2.9.1-cp39-cp39-linux_aarch64.whl

TensorFlow 2.8.0

# synthesize the wheel
$ sudo bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
$ cd ~
# go to the folder where the wheel is located and install tensorflow
$ cd /tmp/tensorflow_pkg
$ sudo -H pip3 install tensorflow-2.8.0-cp39-cp39-linux_aarch64.whl

TensorFlow 2.7.0

# synthesize the wheel
$ sudo bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
$ cd ~
# go to the folder where the wheel is located and install tensorflow
$ cd /tmp/tensorflow_pkg
$ sudo -H pip3 install tensorflow-2.7.0-cp39-cp39-linux_aarch64.whl

Installing TensorFlow C++ API

As mentioned before, you can quickly install the TensorFlow C++ API by accessing the tarball file on our GitHub page without going through the lengthy installation process. For those who want to build the API themselves, here is the installation guide.

First, if you have not installed Bazel yet, please do so. The process is also described above. Once Bazel is running smoothly, you can install dependencies and download TensorFlow (if these steps were not done during the Python 3 installation).

TensorFlow 2.10.0

# the dependencies
$ sudo apt-get install build-essential make cmake wget zip unzip
$ sudo apt-get install libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatlas-base-dev
# download TensorFlow 2.10.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.10.0.zip
# unpack the folder
$ unzip tensorflow.zip
$ cd tensorflow-2.10.0
$ ./configure

TensorFlow 2.9.1

# the dependencies
$ sudo apt-get install build-essential make cmake wget zip unzip
$ sudo apt-get install libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatlas-base-dev
# download TensorFlow 2.9.1
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.9.1.zip
# unpack the folder
$ unzip tensorflow.zip
$ cd tensorflow-2.9.1
$ ./configure

TensorFlow 2.8.0

# the dependencies
$ sudo apt-get install build-essential make cmake wget zip unzip
$ sudo apt-get install libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatlas-base-dev
# download TensorFlow 2.8.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.8.0.zip
# unpack the folder
$ unzip tensorflow.zip
$ cd tensorflow-2.8.0
$ ./configure

TensorFlow 2.7.0

# the dependencies
$ sudo apt-get install build-essential make cmake wget zip unzip
$ sudo apt-get install libhdf5-dev libc-ares-dev libeigen3-dev
$ sudo apt-get install libatlas-base-dev
# download TensorFlow 2.7.0
$ wget -O tensorflow.zip https://github.com/tensorflow/tensorflow/archive/v2.7.0.zip
# unpack the folder
$ unzip tensorflow.zip
$ cd tensorflow-2.7.0
$ ./configure

Again, before the actual build starts, we need to configure Bazel. Although we are building the C++ API, the Bazel script file needs to set Python 3 as the default Python version and answer “no” to all other questions. Once all questions in the script file are answered, you will get the same output screen as above.

The last step is the command line with options. This is almost the same as the command used before. The most important point here is the –config=monolithic flag. Without this instruction, TensorFlow will not work with OpenCV (and vice versa). Just like pip compilation, the memory of the Java environment (-Xmx1624m) needs to be maximized to 80% of the Raspberry Pi’s onboard memory. The last line indicates the tarball library build, not the pip wheel.

$ sudo bazel --host_jvm_args=-Xmx1624m build \
             --config=opt \
             --config=noaws \
             --config=nogcp \
             --config=nohdfs \
             --config=nonccl \
             --config=monolithic \
             --config=v2 \
             --local_cpu_resources=1 \
             --copt=-ftree-vectorize \
             --copt=-funsafe-math-optimizations \
             --copt=-ftree-loop-vectorize \
             --copt=-fomit-frame-pointer \
             //tensorflow/tools/lib_package:libtensorflow

After a long wait of 12 hours, hopefully, you will see the screen below.

The last step is to install the tarball. This can be done with the command below.

# clean up the whole bazel cache
$ sudo rm -rf ~/.cache/bazel

After installation, you must have the same folders as shown at the beginning of this page (/usr/local/lib and /usr/local/include/tensorflow/c).

Cleanup

After a successful installation, many files will no longer be needed. The intermediate target files generated by bazel take up about 6 GB of space on your disk. Deleting these files will not harm the system.

# clean up the whole bazel cache
$ sudo rm -rf ~/.cache/bazel

If you have previously reinstalled dphys-swapfile, now is the time to uninstall it again. Doing so will extend the life of your SD card.

# remove the dphys-swapfile (if installed)
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo apt-get remove --purge dphys-swapfile

Installing Keras on Raspberry Pi 64 OS

After installing TensorFlow, you can load Keras. Keras is a high-level shell running on top of TensorFlow. It claims to be more user-friendly than TensorFlow, providing a more intuitive set of abstractions for easily developing deep learning models. Installation is done with just one command.

$ pip3 install keras

Raspberry Pi products can be purchased directly from the Raspberry Pi agent:

1. Scan the QR code to add Yang Gong for consultation and purchase.

2. Send us your contact information via private message to place an order directly.

3. Consult and order on the Raspberry Pi agent’s official website:https://www.edatec.cn/cn

Getting Started with TensorFlow on Raspberry Pi

We will update regularly~

Follow Raspberry Pi developers~

Learn more about Raspberry Pi related content~

Related posts

Leave a Comment Cancel reply