Emilie  Okumu

Emilie Okumu


TensorFlow Compiled and Running Properly on The Raspberry Pi

TensorFlow on Raspberry Pi

It's officially supported!

As of TensorFlow 1.9, Python wheels for TensorFlow are being officially supported. As such, this repository is no longer recommended for your TensorFlow on RPi needs; use the official sources!

Pip installation

You can install the official wheel with the following commands, assuming you are using Raspbian 9:

sudo apt install libatlas-base-dev
pip3 install tensorflow

Check out the official TensorFlow website for more information.

It was a fun ride! With Raspberry Pi support now official, I will no longer be looking to update this repository. I'm sorry that I wasn't able to continue maintaining the repo as much as I wanted, but it was amazing watching the community continue to thrive.

Author: samjabrahams
Source code: https://github.com/samjabrahams/tensorflow-on-raspberry-pi


What is GEEK

Buddha Community

TensorFlow Compiled and Running Properly on The Raspberry Pi

TensorFlow Lite Object Detection using Raspberry Pi and Pi Camera

I have not created the Object Detection model, I have just merely cloned Google’s Tensor Flow Lite model and followed their Raspberry Pi Tutorial which they talked about in the Readme! You don’t need to use this article if you understand everything from the Readme. I merely talk about what I did!


  • I have used a Raspberry Pi 3 Model B and PI Camera Board (3D printed a case for camera board). **I had this connected before starting and did not include this in the 90 minutes **(plenty of YouTube videos showing how to do this depending on what Pi model you have. I used a video like this a while ago!)

  • I have used my Apple Macbook which is Linux at heart and so is the Raspberry Pi. By using Apple you don’t need to install any applications to interact with the Raspberry Pi, but on Windows you do (I will explain where to go in the article if you use windows)

#raspberry-pi #object-detection #raspberry-pi-camera #tensorflow-lite #tensorflow #tensorflow lite object detection using raspberry pi and pi camera

Tools and Images to Build a Raspberry Pi n8n server


Tools and Images to Build a Raspberry Pi n8n server


The purpose of this project is to create a Raspberry Pi image preconfigured with n8n so that it runs out of the box.

What is n8n?

n8n is a no-code/low code environment used to connect and automate different systems and services. It is programmed using a series of connected nodes that receive, transform, and then transmit date from and to other nodes. Each node represents a service or system allowing these different entities to interact. All of this is done using a WebUI.

Why n8n-pi?

Whevever a new technology is released, two common barriers often prevent potential users from trying out the technology:

  1. System costs
  2. Installation & configuration challenges

The n8n-pi project eliminates these two roadblocks by preconfiguring a working system that runs on easily available, low cost hardware. For as little as $40 and a few minutes, they can have a full n8n system up and running.


This project would not be possible if it was not for the help of the following:


All documentation for this project can be found at http://n8n-pi.tephlon.xyz.

Download Details:

Author: TephlonDude

GitHub: https://github.com/TephlonDude/n8n-pi

#pi #raspberry pi #raspberry #raspberry-pi

Philian Mateo

Philian Mateo


How to Install TensorFlow and Recognize images using Raspberry Pi


This article demonstrates how to install TensorFlow and recognize images using Raspberry Pi.


  • Raspberry Pi
  • TensorFlow
  • Putty or VNC View

**About TensorFlow **

  • TensorFlow is a free and open-source software library for dataflow
  • It is a symbolic math library.
  • TensorFlow is a computational framework for building machine learning models.

TensorFlow has two components

  • a graph protocol buffer
  • a runtime that executes the (distributed) graph

Types of an image

  • 8-bit COLOR FORMAT
  • 16-bit COLOR FORMAT

A 16-bit color format is divided into three different colors which are Red, Green, and Blue (RGB).

Step 1

Let’s go to install the raspbian stretch operating system and also get the latest version of Python, so open the Linux terminal to update Python.

This is image title

sudo apt-get update    
python --version    
python3 --version    

Installing TensorFlow needs some library file, so Libatlas library is required by the TensorFlow package installation. Once the library file is installed, then install the TensorFlow package.

Before installing TensorFlow, install the Atlas library.

sudo apt install libatlas-base-dev  

Once that is finished install TensorFlow via pip3

pip3 install --user tensorflow  

Nowwe’ve  successfully installed TensorFlowTensorFlow version-1-9-0.

Step 2

Once we install the TensorFlow we’re ready to test the basic TensorFlow script provided by the TensorFlow site and first, you can test the Hello World program. Now, I create a  new Python file like tftest.py,

sudo nano tftest.py  

Next, you have to import the TensorFlow library.

import tensorflow as tf  
hello = tf.constant('Hello, TensorFlow')  
sess = tf.Session()  
print (sess.run(hello))

Just run the code. You can see the hello TensorFlow program is successfully printed.

Run the code from the terminal:

python3 tftest.py   

This is image title

Step 3

Clone the TensorFlow classification script.

git clone https://github.com/tensorflow/models.git  

This is a panda image for reference:

This is image title

Once the script is running the panda image will be recognized.

cd models/tutorials/image/imagenet  
python3 classify_image.py 

Source Code

from __future__ import absolute_import  
from __future__ import division  
from __future__ import print_function  
import argparse  
import os.path  
import re  
import sys  
import tarfile  
import numpy as np  
from six.moves import urllib  
import tensorflow as tf  
FLAGS = None  
DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'  
class NodeLookup(object):  
  def __init__(self,  
    if not label_lookup_path:  
      label_lookup_path = os.path.join(  
          FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt')  
    if not uid_lookup_path:  
      uid_lookup_path = os.path.join(  
          FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt')  
    self.node_lookup = self.load(label_lookup_path, uid_lookup_path)  
  def load(self, label_lookup_path, uid_lookup_path):  
    if not tf.gfile.Exists(uid_lookup_path):  
      tf.logging.fatal('File does not exist %s', uid_lookup_path)  
    if not tf.gfile.Exists(label_lookup_path):  
      tf.logging.fatal('File does not exist %s', label_lookup_path)  
    proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()  
    uid_to_human = {}  
    p = re.compile(r'[n\d]*[ \S,]*')  
    for line in proto_as_ascii_lines:  
      parsed_items = p.findall(line)  
      uid = parsed_items[0]  
      human_string = parsed_items[2]  
      uid_to_human[uid] = human_string  
    node_id_to_uid = {}  
    proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines()  
    for line in proto_as_ascii:  
      if line.startswith('  target_class:'):  
        target_class = int(line.split(': ')[1])  
      if line.startswith('  target_class_string:'):  
        target_class_string = line.split(': ')[1]  
        node_id_to_uid[target_class] = target_class_string[1:-2]  
    node_id_to_name = {}  
    for key, val in node_id_to_uid.items():  
      if val not in uid_to_human:  
        tf.logging.fatal('Failed to locate: %s', val)  
      name = uid_to_human[val]  
      node_id_to_name[key] = name  
    return node_id_to_name 
  def id_to_string(self, node_id):  
    if node_id not in self.node_lookup:  
      return ''  
    return self.node_lookup[node_id]  
def create_graph():  
  with tf.gfile.FastGFile(os.path.join(  
      FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:  
    graph_def = tf.GraphDef()  
    _ = tf.import_graph_def(graph_def, name='')  
def run_inference_on_image(image):   
  if not tf.gfile.Exists(image):  
    tf.logging.fatal('File does not exist %s', image)  
  image_data = tf.gfile.FastGFile(image, 'rb').read() 
  with tf.Session() as sess:  
    softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')  
    predictions = sess.run(softmax_tensor,  
                           {'DecodeJpeg/contents:0': image_data})  
    predictions = np.squeeze(predictions)  
 .  node_lookup = NodeLookup()  
    top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]  
    for node_id in top_k:  
      human_string = node_lookup.id_to_string(node_id)  
      score = predictions[node_id]  
      print('%s (score = %.5f)' % (human_string, score))  
def maybe_download_and_extract():  
  dest_directory = FLAGS.model_dir  
  if not os.path.exists(dest_directory):  
  filename = DATA_URL.split('/')[-1]  
  filepath = os.path.join(dest_directory, filename)  
  if not os.path.exists(filepath):  
    def _progress(count, block_size, total_size):  
      sys.stdout.write('\r>> Downloading %s %.1f%%' % (  
          filename, float(count * block_size) / float(total_size) * 100.0))  
    filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)  
    statinfo = os.stat(filepath)  
    print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')  
  tarfile.open(filepath, 'r:gz').extractall(dest_directory)  
def main(_):  
  image = (FLAGS.image_file if FLAGS.image_file else  
           os.path.join(FLAGS.model_dir, 'cropped_panda.jpg'))  
if __name__ == '__main__':  
  parser = argparse.ArgumentParser()  
      help='Absolute path to image file.'  
      help='Display this many predictions.'  
  FLAGS, unparsed = parser.parse_known_args()  
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)  


This is image title

The same method is used to classify the external images like the following terminal command.

python3 classify_image.py --image_file=/PATH/  

This is the very beginning of the TensorFlow Raspberry pi, just install the TensorFlow and Classify the image.


In this article, you learned how to install TensorFlow and do image recognition using TensorFlow and Raspberry Pi.

Thank you for reading!

#tensorflow #python #raspberry pi #raspberry-pi

The Raspberry Pi 400 - A full computer in a keyboard!

The Raspberry Pi 400 has arrived in the studio, and in this video I’ll give it a review. I’ll show an unboxing of the Personal Computer Kit from Canakit, which is a great way to get started on the Pi 400. Then I’ll show off the hardware, as well as the out-of-box experience.

#raspberry pi #pi #raspberry-pi

How to run Joystick with Raspberry Pi | Raspberry Pi Ultimate Robot

In this video we are going to learn how to install and run the Ps4 joystick in raspberry pi. We will also created a module out of this so that we can run it with the motor module that we created in the previous video.

Part 1: Hardware Build: https://youtu.be/Zdv4cOmOmb8
Part 2: Motor Module: https://youtu.be/0lXY87NwVIc
Part 3: Keyboard Module: https://youtu.be/YEYBbFdus-Q

#raspberry-pi #pi #programming