Hardware Accelerated Semantic Segmentation

Real-time semantic segmentation using a deep neural network running on the ULTRA96V2.

IntermediateFull instructions provided5 hours556

Hardware Accelerated Semantic Segmentation

Things used in this project

Hardware components

Avnet Ultra96-V2

Software apps and online services

AMD-Xilinx Xilinx Vitis-AI

Story

Background

Semantic segmentation is a classical problem in the field of computer vision, and it is also one of the main ways for the application of computer vision algorithms in practice. This problem is quite challenging and is a key problem for computers to recognize the real world. Nowadays, with the development of deep learning, the effect of semantic segmentation is getting better and better, and its application range is becoming wider and wider. In many applications of artificial intelligence technology, such as driverless technology, virtual reality and augmented reality, human-computer interaction and so on, speech segmentation plays a more and more excellent role. Behind the prosperity and development, an important problem of semantic segmentation has been exposed, that is, the speed of training and reasoning. Therefore, in this project, we alleviate this problem through hardware acceleration, and use ultra96 development board as the hardware acceleration platform to accelerate the speech segmentation network.

The neural network

The neural network model used in this project is ERFNet, and the github address of its project is https://github.com/Eromera/erfnet. The network is similar to U-Net. After downsampling, the convolutional layer is used for feature extraction, and then up-sampling is performed, and finally the segmentation result is output. The network is divided into two parts: decoding and encoding. First, in the encoding part, the first layer is the original image with the input size of 1024x512x3. After downsampling by a convolutional layer, it is converted into a feature layer of 512x256x16 size, and then through the A convolutional layer is down-sampled so that the size of the feature layer is converted to 256x128x64, and then processed by five Non-bottleneck-1D layers. The Non-bottleneck-1D layer is a convolutional layer combined with residual blocks, which enables the neural network to learn the identity mapping well and effectively alleviates the problems of gradient explosion and gradient disappearance that often occur in deep neural networks. The structure diagram is shown below:

After the above processing, downsampling is performed again to convert the size of the feature map to 128x64x128, and then the feature extraction process is performed through eight layers of Non-bottleneck-1D layers. So far, the above network structure constitutes the coding part of the entire ERFNet. In the decoding part, the size of the feature map is first converted to 256x128x64 through an upsampling layer, and then the feature extraction process is performed through two layers of Non-bottleneck-1D layers. It is then processed by an upsampling layer and two Non-bottleneck-1D layers, and the feature map size at this time is 512x256x16. Finally, go through an upsampling layer, so that the feature map is converted into a state where the width and height are equal to the original image and the number of channels is customized. The overall schematic diagram of the neural network is as follows:

Quantizing and compiling model using Vitis-AI-1.4

step1:set up thelocal dockerenvironment of Vitis-AI

Follow the installation steps in the following URL to set up the local environment

https://github.com/Xilinx/Vitis-AI/tree/v1.4

Clone the Vitis-AI repository to obtain the examples, reference code, and scripts from git, then, download the latest Vitis AI Docker.

The image file that needs to be pulled may be very large and time-consuming. If possible, you can copy the file directly from the cloud disk others shared.

After completing all installation steps, you can start in the installation directory by following the command below:

./docker_run.sh xilinx/vitis-ai-cpu:latest

Then you can see the following screen:

We can now start compiling the AI-model with the local environment.

2:compilingmodel with the help of PYNQand AI-Model-Zoo

AI-Model-Zoo includes optimized deep learning models to speed up the deployment of deep learning inference on Xilinx™ platforms. These models cover different applications, including but not limited to ADAS/AD, medical, video surveillance, robotics, data center, etc. You can get started with these free pre-trained models to enjoy the benefits of deep learning acceleration.

We use DPU-PYNQ to help us building machine learning models for dpu

Cloned the repository onto your host machine:

git clone --recursive --shallow-submodules https://github.com/Xilinx/DPU-PYNQ.git

Modify the relevant json files according to your hardware.

Our arch.json file for Ultra96 DPU configuration has content:

{"fingerprint":"0x1000020F2014404"}

The above process can refer to the following URL：

https://github.com/Xilinx/DPU-PYNQ/tree/master/host

Then we can buile dpu models from Vitis-AI-Model-Zoo

cd DPU-PYNQ/host
mkdir -p ./setup/docker/docker/
cp -rf ../vitis-ai-git/docker_run.sh .
cp -rf ../vitis-ai-git/setup/docker/docker/PROMPT.txt ./setup/docker/docker/
chmod u+x docker_run.sh
./docker_run.sh xilinx/vitis-ai-cpu:latest

Once you are in the docker environment, you can adjust the appropriate conda enviroment in docker and run the compile.sh script to compile our ERFNet model using the following command:

./compile.sh Ultra96 tf2_erfnet_cityscapes_512_1024_54G_1.4

After the compiling process you can see the following screen:

The compiled model can be found in the folder directory of the same name, then the compiling process of this project is finished.

Deployment and application execution on Ultra96v2

Follow this guild to build the pynq environment. Use your browser to open the jupyter notebook.

Upload the tf2_erfnet.xmodel file to any floder of your choice.

The Cityscapes dataset, which can be downloaded here. You can use any other images.

Upload our ipynb, change your xmodel and image path and run. You will see the following output.

As we can see, it achieves 2.09 frames per second. As a reference, NVIDIA TEGRA TX1 achieves 1.9 fps and NVIDIA TITAN X achieves 11.4 fps.

Code

the jupyter notebook

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DPU example: tf2_erfnet\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aim/s\n",
    "* This notebooks shows an example of DPU applications. The application,as well as the DPU IP, is pulled from the official \n",
    "[Vitis AI Github Repository](https://github.com/Xilinx/Vitis-AI).\n",
    "\n",
    "## References\n",
    "* [Vitis AI Github Repository](https://www.xilinx.com/products/design-tools/vitis/vitis-ai.html).\n",
    "\n",
    "## Last revised\n",
    "* Mar 3, 2021\n",
    "    * Initial revision\n",
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Prepare the overlay\n",
    "We will download the overlay onto the board. \n",
    "\n",
    "The `load_model()` method will automatically prepare the `graph`\n",
    "which is used by VART."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pynq_dpu import DpuOverlay\n",
    "overlay = DpuOverlay(\"dpu.bit\")\n",
    "overlay.load_model(\"tf2_erfnet.xmodel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-heading alert-info\">\n",
    "Starting from Vitis AI 1.3, xmodel files will be used as the models\n",
    "instead of elf files.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Utility functions\n",
    "\n",
    "In this section, we will prepare a few functions for later use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first define a few useful preprocessing functions. These functions\n",
    "will make sure the DPU can take input images with arbitrary sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "_R_MEAN = 123.68\n",
    "_G_MEAN = 116.78\n",
    "_B_MEAN = 103.94\n",
    "\n",
    "MEANS = [_B_MEAN,_G_MEAN,_R_MEAN]\n",
    "\n",
    "label_to_color = {\n",
    "    0: [128, 64,128],\n",
    "    1: [244, 35,232],\n",
    "    2: [ 70, 70, 70],\n",
    "    3: [102,102,156],\n",
    "    4: [190,153,153],\n",
    "    5: [153,153,153],\n",
    "    6: [250,170, 30],\n",
    "    7: [220,220,  0],\n",
    "    8: [107,142, 35],\n",
    "    9: [152,251,152],\n",
    "    10: [ 70,130,180],\n",
    "    11: [220, 20, 60],\n",
    "    12: [255,  0,  0],\n",
    "    13: [  0,  0,142],\n",
    "    14: [  0,  0, 70],\n",
    "    15: [  0, 60,100],\n",
    "    16: [  0, 80,100],\n",
    "    17: [  0,  0,230],\n",
    "    18: [119, 11, 32],\n",
    "    19: [0, 0, 0],\n",
    "    }\n",
    "\n",
    "def resize_shortest_edge(image, size):\n",
    "    H, W = image.shape[:2]\n",
    "    if H >= W:\n",
    "        nW = size\n",
    "        nH = int(float(H)/W * size)\n",
    "    else:\n",
    "        nH = size\n",
    "        nW = int(float(W)/H * size)\n",
    "    return cv2.resize(image,(nW,nH))\n",
    "\n",
    "def mean_image_subtraction(image, means):\n",
    "    B, G, R = cv2.split(image)\n",
    "    B = B - means[0]\n",
    "    G = G - means[1]\n",
    "    R = R - means[2]\n",
    "    image = cv2.merge([R, G, B])\n",
    "    return image\n",
    "\n",
    "def BGR2RGB(image):\n",
    "    B, G, R = cv2.split(image)\n",
    "    image = cv2.merge([R, G, B])\n",
    "    return image\n",
    "\n",
    "def central_crop(image, crop_height, crop_width):\n",
    "    image_height = image.shape[0]\n",
    "    image_width = image.shape[1]\n",
    "    offset_height = (image_height - crop_height) // 2\n",
    "    offset_width = (image_width - crop_width) // 2\n",
    "    return image[offset_height:offset_height + crop_height, offset_width:\n",
    "                 offset_width + crop_width, :]\n",
    "\n",
    "def normalize(image):\n",
    "    image=image / 255.0\n",
    "    # image=image-0.5\n",
    "    # image=image*2\n",
    "    return image\n",
    "\n",
    "def preprocess_fn(image):\n",
    "    image = BGR2RGB(image)\n",
    "    H, W = image.shape[:2]\n",
    "    image = cv2.resize(image, (W//2, H//2))\n",
    "    image = mean_image_subtraction(image, MEANS)\n",
    "    image = normalize(image)\n",
    "    return image\n",
    "\n",
    "def label_softmax_to_color(softmax):\n",
    "    z = np.squeeze(softmax)\n",
    "    img = np.argmax(z, axis=2)\n",
    "    print(img.shape)\n",
    "\n",
    "    img_height, img_width = img.shape\n",
    "    img_color = np.zeros((img_height, img_width, 3))\n",
    "    for row in range(img_height):\n",
    "        for col in range(img_width):\n",
    "            label = img[row, col]\n",
    "            if (label < 0 or label > 19):\n",
    "                print(label)\n",
    "            img_color[row, col] = np.array(label_to_color[label])\n",
    "    return img_color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also define a few functions to calculate softmax and provide \n",
    "the output class after running a DPU task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keep in mind that our original images are 640x480 so we need to preprocess them\n",
    "later to make sure it fits our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_folder = 'city_imgs'\n",
    "original_images = [i for i in os.listdir(image_folder) if i.endswith(\"png\")]\n",
    "total_images = len(original_images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Use VART\n",
    "Now we should be able to use VART to do image classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dpu = overlay.runner\n",
    "\n",
    "inputTensors = dpu.get_input_tensors()\n",
    "outputTensors = dpu.get_output_tensors()\n",
    "\n",
    "shapeIn = tuple(inputTensors[0].dims)\n",
    "shapeOut = tuple(outputTensors[0].dims)\n",
    "outputSize = int(outputTensors[0].get_data_size() / shapeIn[0])\n",
    "\n",
    "softmax = np.empty(outputSize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a few buffers to store input and output data. They will be reused\n",
    "during multiple runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 512, 1024, 3)\n",
      "(1, 512, 1024, 20)\n",
      "(1, 512, 1024, 3)\n"
     ]
    }
   ],
   "source": [
    "output_data = [np.empty(shapeOut, dtype=np.float32, order=\"C\")]\n",
    "input_data = [np.empty(shapeIn, dtype=np.float32, order=\"C\")]\n",
    "image = input_data[0]\n",
    "print(shapeIn)\n",
    "print(shapeOut)\n",
    "print(image.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that we have a list of `original_images`. \n",
    "We can now define a new function `run()` which takes the image index as \n",
    "the input, and calculate the softmax as the classification result.\n",
    "With the argument `display` set to `True`, the original image as well as the\n",
    "predicted label can be rendered.\n",
    "\n",
    "It is obvious that the range of `image_index` should be [0, `total_images`-1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(512, 1024)\n",
      "Performance: 2.094271852634664 FPS tested in 14 images\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f844ce710>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def run(i, display=False):\n",
    "    cv_img = cv2.imread(\n",
    "        os.path.join(image_folder, original_images[i]))\n",
    "    preprocessed = preprocess_fn(cv_img)\n",
    "    image[0,...] = preprocessed.reshape(shapeIn[1:])\n",
    "    time1 = time.time()\n",
    "    job_id = dpu.execute_async(input_data, output_data)\n",
    "    dpu.wait(job_id)\n",
    "    time2 = time.time()\n",
    "    softmax = output_data[0]\n",
    "    if (display):\n",
    "        _, ax = plt.subplots(2)\n",
    "        _ = ax[0].imshow(cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB))\n",
    "        result_image = label_softmax_to_color(softmax)\n",
    "        _ = ax[1].imshow(result_image)\n",
    "    return time2 - time1\n",
    "\n",
    "run(0, True)\n",
    "all_times = 0.0\n",
    "for i in range(total_images):\n",
    "    all_times = all_times + run(i)\n",
    "fps = total_images / all_times\n",
    "print(\"Performance: {} FPS tested in {} images\".format(fps, total_images))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run it for 1 image and print out the predicted label."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also run it for multiple images as shown below. In this example\n",
    "we have only used 1 thread; in principle, users should be able to boost\n",
    "the performance by employing more threads."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will need to remove references to `vart.Runner` and let Python garbage-collect\n",
    "the unused graph objects. This will make sure we can run other notebooks without\n",
    "any issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "del overlay\n",
    "del dpu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "Copyright (C) 2021 Xilinx, Inc\n",
    "\n",
    "SPDX-License-Identifier: Apache-2.0 License\n",
    "\n",
    "----\n",
    "\n",
    "----"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}