Team DiggerFast: Dinger, 李胤祺

Published April 20, 2022

Hardware Accelerated Semantic Segmentation

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

IntermediateFull instructions provided5 hours533

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
}

Credits

Dinger

1 project • 3 followers

李胤祺

2 projects • 2 followers

Hardware Accelerated Semantic Segmentation

Things used in this project

Hardware components

Software apps and online services

Story

Background

The neural network

Quantizing and compiling model using Vitis-AI-1.4

Deployment and application execution on Ultra96v2

Schematics

test images

Code

the jupyter notebook

Credits

Dinger

李胤祺

Comments

Embed the widget on your own site

Hardware Accelerated Semantic Segmentation

Hardware Accelerated Semantic Segmentation

Things used in this project

Hardware components

Software apps and online services

Story

Background

The neural network

Quantizing and compiling model using Vitis-AI-1.4

Deployment and application execution on Ultra96v2

Schematics

test images

Code

the jupyter notebook

Credits

Dinger

李胤祺

Comments

Related channels and tags