To be able to compile and run the examples included in this book, you will need to configure a particular development environment. All code examples have been tested with the Arch and Ubuntu 18.04 Linux distributions. The following list outlines the packages you'll need to install on the Ubuntu platform:

• build-essential
• unzip
• git
• cmake
• cmake-curses-gui
• python
• python-pip
• libblas-dev
• libopenblas-dev
• libatlas-base-dev
• liblapack-dev
• libboost-all-dev
• libopencv-core3.2
• libopencv-imgproc3.2
• libopencv-dev
• libopencv-highgui3.2
• libopencv-highgui-dev
• protobuf-compiler
• libprotobuf-dev
• libhdf5-dev
• libjson-c-dev
• libx11-dev
• openjdk-8-jdk
• wget
• ninja-build

Also, you need to install the following additional packages for Python:

• pyyaml
• typing

Besides the development environment, you'll have to check out requisite third-party libraries' source code samples and build them. Most of these libraries are actively developed and don't have strict releases, so it's easier to check out a particular commit from the development tree and build it than downloading the latest official release. The following table shows you the libraries you have to check out, their repository URLs, and the hash number of the commit to check out:

Also, for the last chapter, you'll have to install the Android Studio IDE. You can download it from the official site at https://developer.android.com/studio. Besides the IDE, you'll also need to install and configure the Android SDK. The respective example in this book was developed and tested with this SDK, which can be downloaded from https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip. To configure this SDK, you have to unzip it and install particular packages. The following script shows how to do it:

mkdir /android 
cd /android 

wget https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip 
unzip sdk-tools-linux-4333796.zip 

yes | ./tools/bin/sdkmanager --licenses 
yes | ./tools/bin/sdkmanager "platform-tools" 
yes | ./tools/bin/sdkmanager "platforms;android-25" 
yes | ./tools/bin/sdkmanager "build-tools;25.0.2" 
yes | ./tools/bin/sdkmanager "system-images;android-25;google_apis;armeabi-v7a" 
yes | ./tools/bin/sdkmanager --install "ndk;20.0.5594570" 

export ANDROID_NDK=/android/ndk/20.0.5594570 
export ANDROID_ABI='armeabi-v7a'

Another way to configure the development environment is through the use of Docker. Docker allows you to configure a lightweight virtual machine with particular components. You can install Docker from the official Ubuntu package repository. Then, use the scripts provided with this book to automatically configure the environment. You will find the docker folder in the examples package. The following steps show how to use Docker configuration scripts:

1. Run the following commands to create the image, run it, and configure the environment:

cd docker 
docker build -t buildenv:1.0 . 
docker run -it buildenv:1.0 bash 
cd /development 
./install_env.sh
./install_android.sh
exit

2. Use the following command to save our Docker container with the configured libraries and packages into a new Docker image:

docker commit [container id]

3. Use the following command to rename the updated Docker image:

docker tag [image id] [new name] 

4. Use the following command to start a new Docker container and share the book examples sources to it:

docker run -it -v [host_examples_path]:[container_examples_path] [tag name] bash

After running the preceding command, you will be in the command-line environment with the necessary configured packages, compiled third-party libraries, and with access to the programming examples package. You can use this environment to compile and run the code examples in this book. Each programming example is configured to use the CMake build system so you will be able to build them all in the same way. The following script shows a possible scenario of building a code example:

cd [example folder name]
mkdir build
cd build
cmake ..
cmake --build . --target all

Also, you can configure your local machine environment to share X Server with a Docker container to be able to run graphical UI applications from this container. It will allow you to use, for example, the Android Studio IDE or a C++ IDE (such as Qt Creator) from the Docker container, without local installation. The following script shows how to do this:

xhost +local:root 
docker run --net=host -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix -it -v [host_examples_path]:[container_examples_path] [tag name] bash

If you are using the digital version of this book, we advise you to type the code yourself or access the code via the GitHub repository (link available in the following section). Doing so will help you avoid any potential errors related to the copying and pasting of code.

To be more comfortable with understanding and building the code examples, we recommend you carefully read the documentation for each third-party library, and take some time to learn the basics of the Docker system and of development for the Android platform. Also, we assume that you have sufficient working knowledge of the C++ language and compilers, and that you are familiar with the CMake build system.

You can download the example code files for this book from your account at www.packt.com. If you purchased this book elsewhere, you can visit www.packtpub.com/support and register to have the files emailed directly to you.

You can download the code files by following these steps:

1. Log in or register at www.packt.com.
2. Select the Support tab.
3. Click on Code Downloads.
4. Enter the name of the book in the Search box and follow the onscreen instructions.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

• WinRAR/7-Zip for Windows
• Zipeg/iZip/UnRarX for Mac
• 7-Zip/PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Hands-On-Machine-Learning-with-CPP. In case there's an update to the code, it will be updated on the existing GitHub repository.

We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here: http://www.packtpub.com/sites/default/files/downloads/9781789955330_ColorImages.pdf.

There are a number of text conventions used throughout this book.

CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "We downloaded a pre-trained model with the torch.hub.load() function."

A block of code is set as follows:

class Network {
    public:
        Network(const std::string& snapshot_path,
                const std::string& synset_path,
                torch::DeviceType device_type);
        std::string Classify(const at::Tensor& image);
    private:
        torch::DeviceType device_type_;
        Classes classes_;
        torch::jit::script::Module model_;
};

Any command-line input or output is written as follows:

cd ~/[DEST_PATH]/server
mkdir build
cd build
cmake .. -DCMAKE_PREFIX_PATH=~/dev/server/third-party/libtorch
cmake --build . --target all 

Bold: Indicates a new term, an important word, or words that you see onscreen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: " Start it by clicking the Start button at the top of the page. "