Reconnaissance d’objets

Installation de TensorFlow

$ mkdir tf
$ cd tf
$ pip3 install tensorflow
$ sudo apt-get install libatlas-base-dev
$ sudo pip3 install pillow lxml jupyter matplotlib cython
$ sudo apt-get install python-tk

Installation d’OpenCV

$ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
$ sudo apt-get install libxvidcore-dev libx264-dev
$ sudo apt-get install qt4-dev-tools
$ pip3 install opencv-python

Installation de Protobuf

$ sudo apt-get install autoconf automake libtool curl
$ wget
$ tar -zxvf protobuf-all-3.10.1.tar.gz
$ cd protobuf-3.10.1/
$ ./configure
$ make
$ sudo make install
$ cd python/
$ export LD_LIBRARY_PATH=../src/.libs
$ python3 build --cpp_implementation
$ python3 test --cpp_implementation
$ sudo python3 install --cpp_implementation 
$ sudo ldconfig

On peut tester en lançant la commande :

$ protoc
 Usage: protoc [OPTION] PROTO_FILES
 Parse PROTO_FILES and generate output based on the options given:
   -IPATH, --proto_path=PATH   Specify the directory in which to search for
                               imports.  May be specified multiple times;
                               directories will be searched in order.  If not
                               given, the current working directory is used.
                               If not found in any of the these directories,
                               the --descriptor_set_in descriptors will be
                               checked for required proto file.
   --version                   Show version info and exit.
   -h, --help                  Show this text and exit.
   --encode=MESSAGE_TYPE       Read a text-format message of the given type
                               from standard input and write it in binary
                               to standard output.  The message type must
                               be defined in PROTO_FILES or their imports.
   --decode=MESSAGE_TYPE       Read a binary message of the given type from
                               standard input and write it in text format
                               to standard output.  The message type must
                               be defined in PROTO_FILES or their imports.
   --decode_raw                Read an arbitrary protocol message from
                               standard input and write the raw tag/value
                               pairs in text format to standard output.  No
                               PROTO_FILES should be given when using this
   --descriptor_set_in=FILES   Specifies a delimited list of FILES
                               each containing a FileDescriptorSet (a
                               protocol buffer defined in descriptor.proto).
                               The FileDescriptor for each of the PROTO_FILES
                               provided will be loaded from these
                               FileDescriptorSets. If a FileDescriptor
                               appears multiple times, the first occurrence
                               will be used.
   -oFILE,                     Writes a FileDescriptorSet (a protocol buffer,
     --descriptor_set_out=FILE defined in descriptor.proto) containing all of
                               the input files to FILE.
   --include_imports           When using --descriptor_set_out, also include
                               all dependencies of the input files in the
                               set, so that the set is self-contained.
   --include_source_info       When using --descriptor_set_out, do not strip
                               SourceCodeInfo from the FileDescriptorProto.
                               This results in vastly larger descriptors that
                               include information about the original
                               location of each decl in the source file as
                               well as surrounding comments.
   --dependency_out=FILE       Write a dependency output file in the format
                               expected by make. This writes the transitive
                               set of input file paths to FILE
   --error_format=FORMAT       Set the format in which to print errors.
                               FORMAT may be 'gcc' (the default) or 'msvs'
                               (Microsoft Visual Studio format).
   --print_free_field_numbers  Print the free field numbers of the messages
                               defined in the given proto files. Groups share
                               the same field number space with the parent
                               message. Extension ranges are counted as
                               occupied fields numbers.
     --plugin=EXECUTABLE         Specifies a plugin executable to use.
                               Normally, protoc searches the PATH for
                               plugins, but you may specify additional
                               executables not in the path using this flag.
                               Additionally, EXECUTABLE may be of the form
                               NAME=PATH, in which case the given plugin name
                               is mapped to the given executable even if
                               the executable's own name differs.
   --cpp_out=OUT_DIR           Generate C++ header and source.
   --csharp_out=OUT_DIR        Generate C# source file.
   --java_out=OUT_DIR          Generate Java source file.
   --js_out=OUT_DIR            Generate JavaScript source.
   --objc_out=OUT_DIR          Generate Objective C header and source.
   --php_out=OUT_DIR           Generate PHP source file.
   --python_out=OUT_DIR        Generate Python source file.
   --ruby_out=OUT_DIR          Generate Ruby source file.
   @                 Read options and filenames from file. If a
                               relative file path is specified, the file
                               will be searched in the working directory.
                               The --proto_path option will not affect how
                               this argument file is searched. Content of
                               the file will be expanded in the position of
                               @ as in the argument list. Note
                               that shell expansion is not applied to the
                               content of the file (i.e., you cannot use
                               quotes, wildcards, escapes, commands, etc.).
                               Each line corresponds to a single argument,
                               even if it contains spaces.

Redémarrer la Raspberry PI, avec :

$ sudo reboot now

Puis poursuivre :

$ mkdir tensorflow
$ cd tensorflow/
$ git clone --recurse-submodules

Editer ./bashrc avec nano :

$ sudo nano ~/.bashrc

et ajouter à la dernière ligne

export PYTHONPATH=$PYTHONPATH:/home/pi/tensorflow1/models/research:/home/pi/tensorflow1/models/research/slim

Redémarrer la session pour permettre la prise en compte du PYTHONPATH :

$ cd tensorflow1/models/research/object_detection/

Aller sur la page GitHub :
et choisir le module : ssdlite_mobilenet_v2_coco et copier son url.

$ wget
$ tar -xzvf ssdlite_mobilenet_v2_coco_2018_05_09.tar.gz
$ cd ~/tensorflow1/models/research/
$ protoc object_detection/protos/*.proto --python_out=.

Détection des objets

Suite à @ 14:50