Lesson Materials

Hardware Components

Jetson Nano 2GB with SD Card Inserted
USB to MicroUSB Data Cable
USBC Power Supply
USB WebCam
Ethernet Cable

Write Your Own Classification Program

One of the things that the Nano does really effectively is running machine learning models and getting output. This is because of the black box on the back of the Nano. This black box is a GPU. A graphics processing unit (GPU) is the part of the computer that renders graphics. In order to do this effectively, GPUs have to do a lot of math very quickly. The kind of math that GPUs do is similar to the kind of math that is done when a machine learning model is used. Thus, they are really efficient at doing machine learning.

In order to utilize this strength, you are going to practice writing code that utilizes some of the networks on your Nano. This program is an example of how to get an image file from the command line, run it through a network, and print the output. This will help you get familiar with what the process is for using networks in python code.

Writing Your Own Recognition Code

Follow these instructions to begin to write your own code.

Connect to your Nano in VSCode.
If you are in the jetson-inference directory, click File>Open Folder, and open the home folder.
Use the New Folder icon to create a new directory called my-recognition.
Use the New File icon to create a new file called my-recognition.py.
At the top add a shebang sequence to automatically use the python interpreter.
```
#!/usr/bin/python3
```
Import the jetson modules used for recognizing and loading images. Also, import argparse to parse the command line.
```
import jetson.inference
import jetson.utils

import argparse
```

Add this code to parse the image file name and select a network.

parser = argparse.ArgumentParser()
parser.add_argument("filename", type=str, help="filename of the image to process")
parser.add_argument("--network", type=str, default="googlenet", help="model to use, can be:  googlenet, resnet-18, ect. (see --help for others)")
opt = parser.parse_args()

Load the image from the disk using the loadImage function. This line will use the image name from the command line.
```
img = jetson.utils.loadImage(opt.filename)
```
Load the recognition network as specified in the command line.
```
net = jetson.inference.imageNet(opt.network)
```
Now it's time to classify the image. In order to do this, you will run the imageNet.Classify() function. You will get the index of the class the image is, and the confidence.
```
class_idx, confidence = net.Classify(img)
```
Finally, you will get the class description and print out the results.
class_desc = net.GetClassDesc(class_idx)
print("image is recognized as '{:s}' (class #{:d}) with {:f}% confidence".format(class_desc, class_idx, confidence * 100))
Save your work with Ctrl + S.
Select terminal>New Terminal to open a new terminal. In this terminal, you can run all the same commands as in a terminal on your Nano.
Change directories into your my-recognition directory.
Download an image of a polar bear using this command:
wget https://github.com/dusty-nv/jetson-inference/raw/master/data/images/polar_bear.jpg
Run your image recognition program on it like this.
python3 my-recognition.py polar_bear.jpg