Created December 6, 2020 © GPL3+

Hardware accelerated Corona detection using X-Rays

We aim to use HW acceleration and the power of AI to detect COVID-19 infection in a jiffy using X-rays.

AdvancedFull instructions provided5 days43

Hardware accelerated Corona detection using X-Rays

Things used in this project

Hardware components

Avnet Ultra96-V2

Webcam, Logitech® HD Pro

UDOO 7inch HDMI/USB Display/Touch

HDMI to mini DP connector (M2M)

Software apps and online services

AMD PetaLinux

VitisAI

AMD Xilinx Software Development Kit

Story

Introduction

During the Corona Pandemic, at around April 2020 DarwinAI, a Deep Learning and AI giant opensourced the COVID-Net, a model trained to identify COVID-19 disease using X-rays only. It is also able to differentiate the differences between patients suffering from other respiratory problems as well from a Corona Patient. The initiative has given birth to numerous models based on similar lines, as mentioned on its official Git repository; all of which have very high accuracy of detecting a corona infection. All of this data is open sourced and so I decided to build a hardware accelerated version of this COVID-net.

Why This topic?

COVID-19 is an ongoing and prevalent issue.
Binary classification such as this (infected with coronavirus or not) can be very efficiently accelerated using FPGAs
AIOT in healthcare is emerging and I feel that such kind of diagnostics will help us to use the real power of AI by using all the data the hospital collects from its patients in real time using an online server and utilize it to train models and make the best predictions, reducing the workload on doctors and maximizing the benefits of AIOT in healthcare.

Research

Before starting to develop my own network and model, I knew that a lot of research and reading was in order for this task. Vitis AI seemed to be not only a very capable software but also a complex one. At the same time, I had to see how exactly the original model detected the COVID-19 disease and which layers could be accelerated by the Ultra96-V2 using the Xilinx Development Tools. Luckily, the best part about COVID-Net is that not only is most of it open sourced, a lot of concepts that went behind actually building this model are explained to the public via this paper that was published by the developers of the model. Hence, I did not have to scram through tens of hours on the internet browsing and reading articles.

According to the paper, The structure of the model was as follows -

COVID-Net

The complexity of the model is significant, and I was expecting that because after all it was trained on 5941 X-ray images of 2839 patients. That meant that the model needed to be of some complexity so that the data did not underfit. But this also meant that the model directly was of no use to me as it could not be HW accelerated as it is. I had to make some changes in it - first of all, I wished to look at a more simpler network architecture. I did some reading and came across another paper, also aimed at detecting COVID-19 using X-rays.

Only this time, the model was significantly simpler because they had used a much smaller dataset of 125 chest X-rays, which the authors say were hastily taken, so that might also have affected its performance. The so called DarkCovidNet model, had the following architecture:

DarkCovidNet based on DarkNet-19

As clearly visible, this model was far more simpler and had many layers that could be accelerated by the DPU that is used by the Vitis AI software.

My Architecture - FastCov Net

It also took me a lot of time to understand how to use my own custom model and implement it on the Ultra96 V2. I eventually figured out how to convert keras models into .elf files. I finally decided to go with a Dense Net based architecture and developed my own model from scratch. After all, there innumerous papers and articles online that have utilized the dense net to detect breast cancer and tumors.

Model description for X-Ray Covid-19 detection:

The number of layers used in the model were made with the compatibility of DPU acceleration kept in mind. That might have reduced the range of layers, but we used various other techniques to compensate for that. As elaborated in the PG338 guide, the DPU can support Convolution, Depthwise Convolution, Deconvolution, Max Pooling, Avg Pooling, Elementwise sum, concat, reorg, Batch Normalisation and FC or flatten+FC layer.

I tried to use the DarkCovidNet mentioned earlier but a few layers gave me warnings and errors, like this one that I got when I tried to use Batch Normalization.

DEPLOY WARNING] Node batch_normalization_5/batchnorm_1/add_1(Type: Add) is not quantized and cannot be deployed to DPU,because it has unquantized input node: batch_normalization_5/batchnorm_1/sub/1cf_1. Please deploy it on CPU. 

[DEPLOY WARNING] Node dense_1/MatMul's weight values are all zeros. This may cause error for DPU compiler, please check your float model.

If I continued, the warnings would turn into errors -

[DNNC][Error] 'Const' op should be fused with current op [Conv2DBackpropInput] by DECENT.

This is because the DPU is able to handle only some specific architectures in the Ultra96 V2. Hence, after a lot of trial and error, I came up with the following architecture and model:

FastCov Net - Based on the Dense Net architecture

Explanation:

The model consists of Conv2d layers to perform CNN. This layer creates a convolution kernel that is convolved with the layer input to produce a tensor of outputs. In image processing kernel is a convolution matrix or a mask which can be used for blurring, sharpening, embossing, edge detection and more by doing a convolution between a kernel and an image. The pooling is being done with the use of max_pooling2d layers. Max pooling operation for 2D spatial data. Dropout layer was used to reduce the extra nodes to avoid overfitting. This allowed us to increase the number of conv2d, pooling pair so we can avoid underfitting as well. The output of the dropout was then flattened by adding an extra dimension using the flatten layer. The output of the flatten layer is feed into the dense layer pair in the end of the model which then makes the logic to distinguish the input images into two classes of COVID-19 and non-covid.

The original plan for the model was to utilize the batch normalization layers but they had some sort of compatibility issues forcing me to use the layer’s impact on the CPU (as shown previously). Due to lack of time we shifted to using maxpooling instead. Batch normalization was preferred in this scenario due to the vast difference in the number of images in both classes in the original dataset. This was overcome by adding additional data and finding a balance between classes.

I aimed at using simpler layers, that could directly be accelerated by the Vitis platform.

Dataset

All the images were feed into the model for training with the shape of (200,200,3). This was to find a uniformity between all the images and also to make sure the images were not too small.

1 / 4

The dataset was obtained from 2 kaggle datasets that can be found here and here. Our dataset consisted of 2 classes, ‘covid’ and normal in which batches were made dynamically. The ‘covid’ class had 69 chest X-Ray images fed into it. The normal class had around 50 images, 15 images provided from the dataset and rest were taken from a different dataset consisting of non-covid patients. Apart from this, for testing two actual X-Ray images from personal contacts were also used. The links to the datasets can be found in the references column.

Installing Vits and Xilinx Tools

To install the Xilinx tools and Vitis AI, use this guide.

Training and Building the model

I used the following methodology to develop and train my model:

Jupyter notebook and python 3.6 was used to train models from scratch using keras framework with tensorflow backend (CUDA enabled). The notebook has been attached in the Codes section (train.ipynb).
The model generated can be found in the model folder of the attached git repository.
SSH was done in the linux machine running ubuntu to execute git related commands.

Model training and test accuracy. It is quite high, as expected since the model is simple and dataset small

The model file in k_model.h5 file (attached in the codes section) was obtained after running the jupyter notebook. As Ultra96 V2 is an FPGA that uses the .elf format (commonly used by microcontrollersand other embedded systems), it is necessary for any model file to be converted into a .elf file before it can be run on the Ultra96 V2 platform. The vitis-ai-tutorials repository was cloned from the corresponding git repository to convert keras model into .elf files.

.h5 to .elf conversion:

The .h5 to .elf conversion is done using a Linux machine running Ubuntu 18.04

1. Start Docker:

./docker_run.sh xilinx/vitis-ai:latest #to start docker

1 / 2 • The Vitis AI docker will ask you for permission to download multitudes of files and libraries that you might use. Just keep pressing enter or Y whenever asked.

2. Environment setup:

source ./0_setenv.sh #initializing many of the parameters for the specific model

Set Vitis AI Environment

3. keras2tf Conversion:

source ./2_keras2tf.sh #starting the keras to tensorflow conversion

1 / 2 • keras to tensorflow conversion

4. Quantization:

source ./4_quant.sh #quantization of the images placed inside the calib_images folder

Quantization output

A custom datagen.py script was written to convert the calib_images into proper format for the model input shape. It is called inside the quantization shell script.

datagen.py

source ./6_compile.sh #compiling the model with path to the dcf and arch json file inside the DOUCZDX8G path

The above command will generated a .elf file if executed without any errors. dpu_densenetx_0.elf

1 / 2 • compile command inside compile.sh

Implementation of the Model on the Ultra96-V2

The Petalinux BSP for Ultra96 V2 provided officially under the Xilinx downloads page here and followed the installation instructions provided on this page. However, to save time, I used one that Mario Bergeron has provided in one of his projects. (Link in references)

My Setup

The DPU runner run.py (attached in the Codes Section) was used to run the .elf model on the Ultra96 V2. It uses the dpu to run the elf model with xrays provided. Threads were used for the static version and no threads were utilized for the live feed version.

The target board being Ultra96V2 obtained the code via git function. The original git repo has been attached in the Codes Section.

To test the model, we used two actual X-Rays of a patient that was tested positive later after his X-Ray was taken. The Results were promising, and the patient was correctly detected as positive.

1 / 2 • Actual Corona X-ray we had access to

The video of our setup and model in action is provided below:

FastCov Net in Action

Comparison with CPU performance

The Hardware acceleration performance increased by more than 6 times just by using the DPU in the Ultra96 V2 compared to using just the CPU. The CPU used was I7 9th Gen, 12 core 6 thread 2.6 GHz.

1 / 2 • CPU execution shows around 20 FPS

I am glad and surprised that I got such a huge boost on the FPS! I am sure if I played around with the Ultra96 V2 some more, it would have an even better performance.

Now that we have this AI model ready, lets combine it with IOT!

AIOT aspect of this project

Unfortunately, due to lack of time and the complexity of the hardware, I could not fully explore all ways in which this model can efficiently utilize IOT to maximize its performance in a healthcare scenario.

How are we going to do this? Well, the main issue with X-Ray based diagnostics is that a doctor has to look at it, then he can guide the patient accordingly, and then that's it - The patient acts on the doctor's recommendations or looks for a second opinion. The doctor may or may not get to know whether all his diagnostic predictions turned out to be true and/or did he miss something. Even if the doctor gets to know, this data will never reach out to other doctors. This is one of the main reasons that medical practice requires far more years of training and study then other professions like engineering and commerce.

Hence, what we can do is make a central server where each doctor stores and uploads a scanned copy of the X-ray of his patient, after making his diagnosis and making sure the uploaded copy is privacy compliant. Then, he also stores his own diagnosis with reasoning and markings on the X-ray. The patient is monitored to check if the doctor's diagnosis turned to be true. Even if it didn't, the actual outcome is stored as the ground truth and the case is saved as an important one since it might be different from the general cases that the doctor might have seen in his career.

AIOT in healthcare to provide diagnostic feedback to all doctors in a hospital based on all cases recorded in the hospital's central server

Data collected in this manner can be accumulated over time and utilized to train the AI model every week or so, and made better with each retraining. The special cases can be used to fine tune the model and help the doctors in their diagnosis, so that they advise their patient not just based on their own experience, but using the collective experience of the entire arsenal of doctors and cases the hospital has. That will be AIOT's true calling.

BOM

Not many components were required for this project, their cost and links are given below:

Ultra96 V2 249$ on Avnet.
Logitech Web Camera 20-50$ on Amazon
7" HDMI Touch Display 50$ on ElectroComps
mini DP to HDMI Adapter M2F (Active) 15$ on Amazon
HDMI to HDMI Cable M2M (Active) 5$ on Amazon

This comes around to be 350$, which is not bad when it comes to Hardware accelerated Binary classification, such as this case.

References

These are the references that were used in this project:

The petalinux image pre-built was obtained from Mario Bergeron’s project

The code for converting keras model into elf was referred from vitis-ai-tutorials

Code

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Conv2D, SeparableConv2D\n",
    "from keras.layers import MaxPooling2D, AvgPool2D\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import Dense\n",
    "from keras import applications\n",
    "from keras.models import Sequential, Model, load_model\n",
    "from keras import optimizers\n",
    "\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.models import load_model\n",
    "import os\n",
    "from keras.preprocessing import image\n",
    "import numpy as np\n",
    "from keras.layers import Dropout\n",
    "import matplotlib.pyplot as plt\n",
    "from keras.layers import BatchNormalization\n",
    "from keras.layers import Activation\n",
    "from keras.optimizers import SGD\n",
    "from keras.optimizers import Adam\n",
    "from keras.regularizers import l2\n",
    "from time import time\n",
    "from tensorflow.python.keras.callbacks import TensorBoard\n",
    "from ann_visualizer.visualize import ann_viz\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "height, width = 200, 200\n",
    "continue_training = True\n",
    "LOF, MOF, HOF, VHOF = 1, 3, 5, 7     # low order features, medium order features, high order features, very high\n",
    "channels = 3\n",
    "pooling_size = 2\n",
    "output_classes = 4\n",
    "batch_size = 3\n",
    "steps_per_epoch = 1669\n",
    "validation_steps = 400\n",
    "epochs = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    # import sequential model and all the required layers\n",
    "    #make model\n",
    "    model=Sequential()\n",
    "    model.add(Conv2D(filters=16,kernel_size=2,padding=\"same\",activation=\"relu\",input_shape=(200,200,3)))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Conv2D(filters=32,kernel_size=2,padding=\"same\",activation=\"relu\"))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Conv2D(filters=64,kernel_size=2,padding=\"same\",activation=\"relu\"))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Conv2D(filters=64,kernel_size=2,padding=\"same\",activation=\"relu\"))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Conv2D(filters=128,kernel_size=2,padding=\"same\",activation=\"relu\"))\n",
    "    model.add(MaxPooling2D(pool_size=2))\n",
    "    model.add(Dropout(0.2))\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(500,activation=\"relu\"))\n",
    "    model.add(Dropout(0.2))\n",
    "    model.add(Dense(2,activation=\"softmax\"))\n",
    "    model.compile(loss='categorical_crossentropy', optimizer='adam', \n",
    "                  metrics=['accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_validate_model(my_model):\n",
    "    classes = ['covid','normal']\n",
    "\n",
    "    train_datagen = ImageDataGenerator(\n",
    "        rescale=1. / 255,\n",
    "        horizontal_flip=True,\n",
    "        vertical_flip=True,\n",
    "        shear_range=0.2,\n",
    "        zoom_range=0.2\n",
    "    )\n",
    "\n",
    "    training_set = train_datagen.flow_from_directory(\n",
    "        'dataset/',\n",
    "        target_size=(height, width),\n",
    "        batch_size=batch_size,\n",
    "        classes=classes,\n",
    "        class_mode='categorical',\n",
    "        shuffle=True,\n",
    "        subset='training'\n",
    "    )\n",
    "\n",
    "    validation_set = train_datagen.flow_from_directory(\n",
    "        'test_data',\n",
    "        target_size=(height, width),\n",
    "        batch_size=batch_size,\n",
    "        classes=classes,\n",
    "        class_mode='categorical',\n",
    "        shuffle=True\n",
    "    )\n",
    "\n",
    "    history = my_model.fit_generator(\n",
    "        training_set,\n",
    "        epochs=epochs,\n",
    "        steps_per_epoch=steps_per_epoch,\n",
    "        validation_steps=validation_steps,\n",
    "        validation_data=validation_set\n",
    "    )\n",
    "\n",
    "    print('Model score: ')\n",
    "    score = my_model.evaluate_generator(validation_set, steps=100)\n",
    "\n",
    "    print(\"Loss: \", score[0], \"Accuracy: \", score[1])\n",
    "\n",
    "    # Plot training & validation accuracy values\n",
    "    plt.plot(history.history['accuracy'])\n",
    "    plt.plot(history.history['val_accuracy'])\n",
    "    plt.title('Model accuracy')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.legend(['Train', 'Test'], loc='upper left')\n",
    "    plt.show()\n",
    "\n",
    "    # Plot training & validation loss values\n",
    "    plt.plot(history.history['loss'])\n",
    "    plt.plot(history.history['val_loss'])\n",
    "    plt.title('Model loss')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.legend(['Train', 'Test'], loc='upper left')\n",
    "    plt.show()\n",
    "\n",
    "    return my_model\n",
    "\n",
    "\n",
    "def save(my_model):\n",
    "    my_model.save('ir_ident_model2.h5')\n",
    "\n",
    "\n",
    "def load():\n",
    "    return load_model('ir_ident_model.h5')\n",
    "\n",
    "\n",
    "def predict(my_model):\n",
    "\n",
    "    images_list = ['ir_dataset/test/img1.jpg', 'ir_dataset/test/img2.jpg', 'ir_dataset/test/img3.jpg',\n",
    "                   'ir_dataset/test/img4.jpg', 'ir_dataset/test/img5.jpg', 'ir_dataset/test/img6.jpg',\n",
    "                   'ir_dataset/test/img7.jpg', 'ir_dataset/test/img8.jpg', 'ir_dataset/test/img9.jpg',\n",
    "                   'ir_dataset/test/img10.jpg', 'ir_dataset/test/img11.jpg', 'ir_dataset/test/img12.jpg',\n",
    "                   'ir_dataset/test/img13.jpg', 'ir_dataset/test/img14.jpg', 'ir_dataset/test/img15.jpg',\n",
    "                   'ir_dataset/test/img16.jpg', 'ir_dataset/test/img17.jpg', 'ir_dataset/test/img18.jpg',\n",
    "                   'ir_dataset/test/img19.jpg', 'ir_dataset/test/img20.jpg']\n",
    "\n",
    "    for img in images_list:\n",
    "        cur_img = image.load_img(img, target_size=(height, width))\n",
    "        temp = image.img_to_array(cur_img)\n",
    "        temp = np.expand_dims(temp, axis=0)\n",
    "        vstack = np.vstack([temp])\n",
    "        predict_this = my_model.predict_classes(vstack, batch_size=1)\n",
    "        print(predict_this)\n",
    "\n",
    "    print('expected: 0, 3, 1, 1, 2, 2, 2, 0, 0, 3, 1, 2, 0, 1, 3, 0, 2, 0, 3, 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No existing model present, creating/training new model\n",
      "Found 77 images belonging to 2 classes.\n",
      "Found 17 images belonging to 2 classes.\n",
      "Epoch 1/3\n",
      "1669/1669 [==============================] - 153s 92ms/step - loss: 0.1438 - accuracy: 0.9539 - val_loss: 0.0018 - val_accuracy: 0.9541\n",
      "Epoch 2/3\n",
      "1669/1669 [==============================] - 154s 92ms/step - loss: 0.0522 - accuracy: 0.9846 - val_loss: 0.0024 - val_accuracy: 0.9868\n",
      "Epoch 3/3\n",
      "1669/1669 [==============================] - 153s 91ms/step - loss: 0.0278 - accuracy: 0.9923 - val_loss: 0.0590 - val_accuracy: 0.9815\n",
      "Model score: \n",
      "Loss:  0.00018549115338828415 Accuracy:  0.9788732528686523\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved\n",
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 200, 200, 16)      208       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 100, 100, 16)      0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 100, 100, 32)      2080      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 50, 50, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 50, 50, 64)        8256      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_3 (MaxPooling2 (None, 25, 25, 64)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_4 (Conv2D)            (None, 25, 25, 64)        16448     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_4 (MaxPooling2 (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_5 (Conv2D)            (None, 12, 12, 128)       32896     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_5 (MaxPooling2 (None, 6, 6, 128)         0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 6, 6, 128)         0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 4608)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 500)               2304500   \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 500)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 2)                 1002      \n",
      "=================================================================\n",
      "Total params: 2,365,390\n",
      "Trainable params: 2,365,390\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "if os.path.exists('ir_ident_mode.h5'):\n",
    "    print('Existing model found')\n",
    "    model = load()\n",
    "    print('Model loaded')\n",
    "    if continue_training:\n",
    "        model = train_validate_model(model)\n",
    "        save(model)\n",
    "else:\n",
    "    print('No existing model present, creating/training new model')\n",
    "    model = create_model()\n",
    "    mode = train_validate_model(model)\n",
    "    save(model)\n",
    "    print('Model saved')\n",
    "\n",
    "# predict(model)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 24,  24,  24],\n",
       "         [ 21,  21,  21],\n",
       "         [ 18,  18,  18],\n",
       "         ...,\n",
       "         [ 92,  92,  92],\n",
       "         [ 94,  94,  94],\n",
       "         [ 96,  96,  96]],\n",
       "\n",
       "        [[ 22,  22,  22],\n",
       "         [ 21,  21,  21],\n",
       "         [ 18,  18,  18],\n",
       "         ...,\n",
       "         [ 92,  92,  92],\n",
       "         [ 95,  95,  95],\n",
       "         [ 95,  95,  95]],\n",
       "\n",
       "        [[ 22,  22,  22],\n",
       "         [ 21,  21,  21],\n",
       "         [ 18,  18,  18],\n",
       "         ...,\n",
       "         [ 92,  92,  92],\n",
       "         [ 94,  94,  94],\n",
       "         [ 91,  91,  91]],\n",
       "\n",
       "        ...,\n",
       "\n",
       "        [[ 27,  27,  27],\n",
       "         [ 27,  27,  27],\n",
       "         [ 26,  26,  26],\n",
       "         ...,\n",
       "         [ 54,  54,  54],\n",
       "         [ 54,  54,  54],\n",
       "         [ 56,  56,  56]],\n",
       "\n",
       "        [[ 32,  32,  32],\n",
       "         [ 34,  34,  34],\n",
       "         [ 31,  31,  31],\n",
       "         ...,\n",
       "         [ 75,  75,  75],\n",
       "         [ 75,  75,  75],\n",
       "         [ 77,  77,  77]],\n",
       "\n",
       "        [[ 44,  44,  44],\n",
       "         [ 45,  45,  45],\n",
       "         [ 43,  43,  43],\n",
       "         ...,\n",
       "         [109, 109, 109],\n",
       "         [108, 108, 108],\n",
       "         [107, 107, 107]]]], dtype=uint8)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import cv2\n",
    "cur_img = cv2.imread('dataset/normal/IM-0115-0001.jpeg')\n",
    "cur_img = cv2.resize(cur_img,(200,200))\n",
    "cur_img =  np.expand_dims(cur_img, axis=0)\n",
    "cur_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1.]], dtype=float32)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(cur_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes=['covid','normal']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'normal'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes[np.argmax(model.predict(cur_img))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200, 200, 3)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image = cv2.imread('dataset/3.jpeg')\n",
    "image.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4736130"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1330*1187*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = image.reshape(-1,200,200,3).astype('float32')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120000"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "200*200*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras \n",
    "model=load_model('k_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from keras.utils.vis_utils import plot_model\n",
    "plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}

from ctypes import *
import cv2
import numpy as np
import runner
import os
import math
import threading
import time
import argparse
import json
import xir.graph 
import xir.subgraph
import pathlib
# correct solution:
def softmax(x):
    """Compute softmax values for each sets of scores in x."""
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0) # only difference


def get_subgraph (g):
    sub = []
    root = g.get_root_subgraph()
    sub = [ s for s in root.children
    if s.metadata.get_attr_str ("device") == "DPU"]
    return sub

'''
run CNN with batch
dpu: dpu runner
img: imagelist to be run
'''
def runDPU(id,start,dpu,img,listImage):

    """get tensor"""
    inputTensors = dpu.get_input_tensors()
    outputTensors = dpu.get_output_tensors()
    outputHeight = outputTensors[0].dims[1]
    outputWidth = outputTensors[0].dims[2]
    outputChannel = outputTensors[0].dims[3]
    # tensorformat = dpu.get_tensor_format()
    # if tensorformat == dpu.TensorFormat.NCHW:
    #     outputHeight = outputTensors[0].dims[2]
    #     outputWidth = outputTensors[0].dims[3]
    #     outputChannel = outputTensors[0].dims[1]
    # elif tensorformat == dpu.TensorFormat.NHWC:
    #     outputHeight = outputTensors[0].dims[1]
    #     outputWidth = outputTensors[0].dims[2]
    #     outputChannel = outputTensors[0].dims[3]
    # else:
    #     exit("Format error")
    outputSize = outputHeight*outputWidth*outputChannel
    #softmax = np.empty(outputSize)

    batchSize = inputTensors[0].dims[0]
    n_of_images = len(img)
    count = 0
    write_index = start
    while count < n_of_images:
        # print(listImage[count])
        if (count+batchSize<=n_of_images):
            runSize=batchSize
        else:
            runSize=n_of_images-count

 
        shapeIn = (runSize,) + tuple([inputTensors[0].dims[i] for i in range(inputTensors[0].ndim)][1:])
        
        """ prepare batch input/output """
        outputData = []
        inputData = []
        outputData.append(np.empty((runSize,outputHeight,outputWidth,outputChannel), dtype = np.float32, order = 'C'))
        inputData.append(np.empty((shapeIn), dtype = np.float32, order = 'C'))
        
        """ init input image to input buffer """
        for j in range(runSize):
            imageRun = inputData[0]
            imageRun[j,...] = img[(count+j)% n_of_images].reshape(inputTensors[0].dims[1],inputTensors[0].dims[2],inputTensors[0].dims[3])

        """ run with batch """
        job_id = dpu.execute_async(inputData,outputData)
        
        dpu.wait(job_id)

        predictions = outputData[0][0]
        print(predictions)
        predictions = predictions[0][0]
        predictions = softmax(predictions)
        # print("predictions shape: ",predictions.shape)
        y = np.argmax(predictions)
        classes = {
            0 : 'covid',
            1 : 'normal'
         }
        print("detected object is : "+str(classes[y]))
        count = count + runSize
        
        
    return



def runApp(batchSize, threads, image_dir,model):


    listImage=os.listdir(image_dir)

    runTotal = len(listImage)
    
    global out_q
    out_q = [None] * runTotal
    g = xir.graph.Graph.deserialize(pathlib.Path(model))
    subgraphs = get_subgraph(g)
    assert len(subgraphs) == 1
    all_dpu_runners = []
    for i in range(threads):
        all_dpu_runners.append(runner.Runner(subgraphs[0],"run"))
    

    """ pre-process all images """
    img = []
    print(listImage)
    for i in range(len(listImage)):
        
        image = cv2.imread(os.path.join(image_dir,listImage[i]))
        cv2.imshow('test',image)
        cv2.waitKey()
        # image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
        # image = cv2.resize(image,200,200)
        image = image.reshape(-1,200,200,3).astype('float32')
        image = image/255.0
        img.append(image)


    """run with batch """
    threadAll = []
   
    start = 0
    
    for i in range(threads):
        if (i==threads-1):
            end = len(img)
        else:
            end = start + (len(img)//threads)
        in_q = img[start:end]
        t1 = threading.Thread(target=runDPU, args=(i,start,all_dpu_runners[i],in_q,listImage))
        threadAll.append(t1)
        start = end
    time1 = time.time()
    for x in threadAll:
        x.start()
    for x in threadAll:
        x.join()
    time2 = time.time()
    timetotal = time2 - time1
    
    fps = float(runTotal/timetotal)
    print("FPS=%.2f, total frames = %.0f , time = %.4f seconds" %(fps,runTotal,timetotal))
    
    return


def main():

    # command line arguments
    ap = argparse.ArgumentParser()
    
    ap.add_argument('-m','--model', type=str,
                    default='/home/root/DPU_Covid_19_detection_target/dpu_densenetx_0.elf'
                    )
    
    ap.add_argument('-i', '--image_dir',
                    type=str,
                    default='images',
  	                help='Path of images folder. Default is ./images')
    ap.add_argument('-t', '--threads',
                    type=int,
                    default=1,
  	                help='Number of threads. Default is 1')
    ap.add_argument('-b', '--batchsize',
                    type=int,
                    default=1,
  	                help='Input batchsize. Default is 1')
    args = ap.parse_args()


    runApp(args.batchsize, args.threads, args.image_dir,args.model)

    
if __name__ == '__main__':
    main()

import os
import numpy as np
from PIL import Image
import cv2
calib_images_path = './calib_images'
calib_batch_size = 47

def get_calib_data(iter):
    """
    Function provides calibration images to the quantizer from the training set
    """

    frames = os.listdir(calib_images_path)
    # np.random.shuffle(frames)
    num_frames = len(frames)
    print("number of calibration images : ", num_frames)

    out_train_x_normalized = np.zeros((calib_batch_size, 200, 200, 3))

    frame_indices = list(range(iter*calib_batch_size, calib_batch_size + (iter * calib_batch_size)))
    print(frame_indices)
    for i, frame in enumerate(frame_indices):
        f_path = calib_images_path + '/' + frames[frame]
        print(f_path)
        im = cv2.imread(f_path) #Image.open(f_path)
        file = cv2.resize(im,(200,200))# np.array(im)
        # file = file[0: 200, 0: 200, :]
        out_train_x_normalized[i] = np.expand_dims(file, axis=0)  # depth channel
        out_train_x_normalized /= np.max(out_train_x_normalized)  # normalize
    
    return {"conv2d_1_input": out_train_x_normalized}
    

if __name__ == "__main__":
    # keras_convert(keras_json=None, tf_ckpt=None, keras_hdf5='/home/sambit/Xilinx_Works/Vitis-AI-Tutorials-DenseNetX_DPUv2/files/from_docker_tf/trained_unet_1ch_input.h5')
    for i in range(10):
        get_calib_data(i)

Credits

Harshil Suvarna

1 project • 2 followers

Hardware accelerated Corona detection using X-Rays

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Why This topic?

Research

My Architecture - FastCov Net

Installing Vits and Xilinx Tools

Training and Building the model

.h5 to .elf conversion:

Implementation of the Model on the Ultra96-V2

Comparison with CPU performance

AIOT aspect of this project

BOM

References

Schematics

Setup

Code

train.ipynb

run.py

dpu_densenetx_0.elf

datagen.py

k_model.h5

Main repository

Credits

Harshil Suvarna

Comments

Embed the widget on your own site

Hardware accelerated Corona detection using X-Rays

Hardware accelerated Corona detection using X-Rays

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Why This topic?

Research

My Architecture - FastCov Net

Installing Vits and Xilinx Tools

Training and Building the model

.h5 to .elf conversion:

Implementation of the Model on the Ultra96-V2

Comparison with CPU performance

AIOT aspect of this project

BOM

References

Schematics

Setup

Code

train.ipynb

run.py

dpu_densenetx_0.elf

datagen.py

k_model.h5

Main repository

Credits

Harshil Suvarna

Comments

Related channels and tags