?

最大池化。來源（維基百科）

?

皮膚癌 AI 組件

該項目所需的設(shè)備非常簡單，您可以使用計算機和 USB Movidius 神經(jīng)計算棒和 Ultra96 板來完成。

• Ultra96 板
• 內(nèi)窺鏡相機
• Movidius 神經(jīng)計算棒
• 屏幕或監(jiān)視器

?

使用的設(shè)備

?

第 1 步：安裝 PYNQ Linux

Ultra96 是相當新的，但支持小組非常友好地讓基本的 Ubuntu 運行，這很重要，因為這讓我可以在 ultra96 上構(gòu)建不同的平臺。編譯好的debian可以從https://fileserver.linaro.org/owncloud/index.php/s/jTt3MYSuwtLuf9d下載，之后我們可以使用ether之類的工具把它加載到mini-sd卡上。

?

?

啟動后，我們首先必須通過刪除損壞的存儲庫來修復一些錯誤。

sudo rm -r /var/lib/apt/lists/*

這使我們可以根據(jù)需要安裝所有軟件包以使用該平臺。

?

?

第 2 步：安裝 Movidius NCSDK

因此，為了讓 AI 和計算機視覺發(fā)揮作用，我們可以利用 Movidius NCS 來運行我們的項目。Ultra96 沒有演練，所以我們基本上通過 https://movidius.github.io/blog/ncs-apps-on-rpi/ 引用了這個

首先我們必須安裝依賴項，這部分不附帶 PYNQ，所以我們將安裝它們以確保一切正常。

apt-get install libgstreamer1.0-0 gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-doc gstreamer1.0-tools libgstreamer-plugins-base1.0-dev
apt-get install libgtk-3-dev
apt-get install -y libprotobuf-dev libleveldb-dev libsnappy-dev
apt-get install -y  libopencv-dev libhdf5-serial-dev 
apt-get install -y protobuf-compiler byacc libgflags-dev 
apt-get install -y libgoogle-glog-dev liblmdb-dev libxslt-dev 

接下來我們可以安裝 NCSDK SDK，它包含可以將應用程序連接到 NCS 的 API。由于 NCSDK 不是為 Ultra96 構(gòu)建的，我們可以對markjay4k版本的解決方法進行以下修改

cd /home/xilinx/
mkdir -p workspace
cd workspace
git clone https://github.com/markjay4k/ncsdk-aarch64.git
cd ncsdk/api/src
make
make install

這個解決方法應該讓我們使用 Ultra96 和 PYNQ 的 NCSDK API

?

PYNQ 上的 NCSDK

?

接下來我們將嘗試讓 NcAppZoo 和 Hello World 為 Neural Computing Stick 運行，我們需要在 pynq 上重復舊的 python 3.6

cd /home/xilinx/workspace
git clone https://github.com/movidius/ncappzoo
cd ncappzoo/apps/hello_ncs_py
make run

你剛剛讓 NCS 在 aarch64 上運行 :)

?

NCS 在 aarch64 上工作

?

第 3 步：使用 Ultra96 和 NCS 實現(xiàn)邊緣人工智能

我們可以通過多種方式制作觸發(fā)器，因為這是一個基于 AI 的應用程序，我將制作一個基于 AI 的觸發(fā)器。在本指南中，我們將使用經(jīng)過預訓練并使用 Caffe 的 SSD 神經(jīng)網(wǎng)絡(luò)，檢測結(jié)果將是垃圾。因此，我們還將學習如何通過一些工作來利用其他神經(jīng)網(wǎng)絡(luò)。

?

Ultra96 與 Movidius NCS

?

在這一步中，我們之前已經(jīng)訓練了通過 caffe 模型，我們必須在另一臺機器上編譯圖形，因為我們只安裝了 API 而不是工具包，因為它們不是為 aarch64 構(gòu)建的。然而，由于 API 有效，我們可以簡單地在另一臺機器上構(gòu)建它并將圖形文件傳輸?shù)?Ultra96。FPGA 可以處理所有的 CV2，這里的 Movidius NCS 將運行推理以進行對象檢測和圖像分類，如下圖所示，我們將通過在這里進行實時圖像分類來確定基礎(chǔ)。

?

性別的圖像分類

?

第 4 步：收集皮膚癌的圖像數(shù)據(jù)集

我們首先需要皮膚癌數(shù)據(jù)集，雖然有很多地方可以獲取，但 isic-archive 成為最簡單的一個。對于這部分，我們只需要大約 500 張痣、黑色素瘤和脂溢性角化病之間的圖像，以及 500 張其他任何東西的隨機圖像。為了獲得更高的準確性，我們必須使用更多的數(shù)據(jù)，這只是為了開始訓練。獲取數(shù)據(jù)的最簡單方法是通過下面的圖片使用 https://isic-archive.com/#images

?

ISIC 檔案

?

之后，我們可以將圖像標記到一個文件夾中，并將它們命名為 nevus-00.jpg、melanoma-00.jpg 以便我們可以輕松地構(gòu)建我們的 lmdb。

?

從 ISIC 獲取數(shù)據(jù)

?

第 5 步：設(shè)置訓練服務器

機器學習訓練使用了大量的處理能力，因此它們通常成本很高。在本文中，我們將重點介紹面向英特爾 AI Academy成員免費提供的 AI DevCloud。

為了構(gòu)建皮膚癌 AI，我們使用 Caffe 框架，主要是因為英特爾 Movidius NCS 的 AI on the Edge 支持。Caffe 是由伯克利視覺與學習中心 (BVLC) 開發(fā)的深度學習框架，使用 caffe 框架訓練我們的算法模型有 4 個步驟。這樣，Xilinx 的 FPGA 可以專注于 openCV，NCS 可以專注于推理。

• 數(shù)據(jù)準備，我們清理圖像并將它們存儲到 LMDB。
• 模型定義 prototxt 文件，定義參數(shù)并選擇 CNN 架構(gòu)。
• Solver Definition prototxt 文件，定義模型優(yōu)化的求解器參數(shù)
• 模型訓練，我們執(zhí)行caffe命令得到我們的.caffemodel算法文件

在 Devcloud 上，我們可以檢查這些是否可用，只需轉(zhuǎn)到

cd /glob/deep-learning/py-faster-rcnn/caffe-fast-rcnn/build/tools

第 6 步：準備 LMDB 進行訓練

一旦我們設(shè)置好 DevCloud，我們就可以構(gòu)建它

mkdir skincancerai
cd skincancerai
mkdir input
cd input
mkdir train 

從那里我們可以將我們之前設(shè)置的所有數(shù)據(jù)放入文件夾中

scp ./* colfax:/home/[youruser_name]/skincancerai/input/train/

之后，我們可以通過這種方式構(gòu)建我們的 lmdb。我們通過以下幾組來做到這一點

• 數(shù)據(jù)集的 5/6 將用于訓練，1/6 用于驗證，因此我們可以計算模型的準確性
• 我們將所有圖像的大小調(diào)整為 227x227，以遵循與 BVLC 相同的標準
• 直方圖均衡化應用于所有訓練圖像以調(diào)整對比度。
• 并將它們存儲在 train_lmdb 和 validation_lmdb 中
• 使用 make_datum 標記 lmdb 內(nèi)的所有圖像數(shù)據(jù)集

import os
import glob
import random
import numpy as np
import cv2
import caffe
from caffe.proto import caffe_pb2
import lmdb
#We use 227x227 from BVLC
IMAGE_WIDTH = 227
IMAGE_HEIGHT = 227
def transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT):
  img[:, :, 0] = cv2.equalizeHist(img[:, :, 0])
  img[:, :, 1] = cv2.equalizeHist(img[:, :, 1])
  img[:, :, 2] = cv2.equalizeHist(img[:, :, 2])
  img = cv2.resize(img, (img_width, img_height), interpolation = cv2.INTER_CUBIC)
  return img
def make_datum(img, label):
  return caffe_pb2.Datum(
      channels=3,
      width=IMAGE_WIDTH,
      height=IMAGE_HEIGHT,
      label=label,
      data=np.rollaxis(img, 2).tostring())
train_lmdb = '/home/[your_username]/skincancerai/input/train_lmdb'
validation_lmdb = '/home/[youser_username]/skincancerai/input/validation_lmdb'
os.system('rm -rf  ' + train_lmdb)
os.system('rm -rf  ' + validation_lmdb)
train_data = [img for img in glob.glob("./input/train/*jpg")]
random.shuffle(train_data)
print 'Creating train_lmdb'
in_db = lmdb.open(train_lmdb, map_size=int(1e12))
with in_db.begin(write=True) as in_txn:
  for in_idx, img_path in enumerate(train_data):
      if in_idx %  6 == 0:
          continue
      img = cv2.imread(img_path, cv2.IMREAD_COLOR)
      img = transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT)
      if 'none' in img_path:
          label = 0
      elif 'nevus' in img_path:
          label = 1
      elif 'melanoma' in img_path:
          label = 2
      else:
          label = 3
      datum = make_datum(img, label)
      in_txn.put('{:0>5d}'.format(in_idx), datum.SerializeToString())
      print '{:0>5d}'.format(in_idx) + ':' + img_path
in_db.close()
print '\nCreating validation_lmdb'
in_db = lmdb.open(validation_lmdb, map_size=int(1e12))
with in_db.begin(write=True) as in_txn:
  for in_idx, img_path in enumerate(train_data):
      if in_idx % 6 != 0:
          continue
      img = cv2.imread(img_path, cv2.IMREAD_COLOR)
      img = transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT)
      if 'none' in img_path:
          label = 0
      elif 'nevus' in img_path:
          label = 1
      elif 'melanoma' in img_path:
          label = 2
      else:
          label = 3
      datum = make_datum(img, label)
      in_txn.put('{:0>5d}'.format(in_idx), datum.SerializeToString())
      print '{:0>5d}'.format(in_idx) + ':' + img_path
in_db.close()
print '\nFinished processing all images'

之后我們將運行腳本

python2 create_lmdb.py

獲取所有 LMDB。完成后，我們需要獲取訓練數(shù)據(jù)的平均圖像。作為 caffe 的一部分，我們可以通過

cd /glob/deep-learning/py-faster-rcnn/caffe-fast-rcnn/build/toolscompute_image_mean -backend=lmdb /home/[your_user]/skincancerai/input/train_lmdb /home/[your_user]/skincancerai/input/mean.binaryproto

上面的命令將生成訓練數(shù)據(jù)的平均圖像。每個輸入圖像將減去平均圖像，使每個特征像素的均值為零。這是監(jiān)督機器學習預處理中常用的方法。

第 7 步：設(shè)置模型定義和求解器定義

我們現(xiàn)在需要設(shè)置模型定義和求解器定義，在本文中我們將使用 bvlc_reference_net，可以在https://github.com/BVLC/caffe/tree/master/models/bvlc_reference_caffenet看到

下面是 train.prototxt 的修改版本

name: "CaffeNet"
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
  phase: TRAIN
}
transform_param {
  mirror: true
  crop_size: 227
  mean_file: "/home/[your_username]/skincancerai/input/mean.binaryproto"
}
data_param {
  source: "/home/[your_username]/skincancerai/input/train_lmdb"
  batch_size: 128
  backend: LMDB
}
}
layer {
name: "data"
type: "Data"
top: "data"
top: "label"
include {
  phase: TEST
}
transform_param {
  mirror: false
  crop_size: 227
  mean_file: "/home/[your_username]/skincancerai/input/mean.binaryproto"
}
# mean pixel / channel-wise mean instead of mean image
#  transform_param {
#    crop_size: 227
#    mean_value: 104
#    mean_value: 117
#    mean_value: 123
#    mirror: true
#  }
data_param {
  source: "/home/[your_username]/skincancerai/input/validation_lmdb"
  batch_size: 36
  backend: LMDB
}
}
layer {
name: "conv1"
type: "Convolution"
bottom: "data"
top: "conv1"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
convolution_param {
  num_output: 96
  kernel_size: 11
  stride: 4
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 0
  }
}
}
layer {
name: "relu1"
type: "ReLU"
bottom: "conv1"
top: "conv1"
}
layer {
name: "pool1"
type: "Pooling"
bottom: "conv1"
top: "pool1"
pooling_param {
  pool: MAX
  kernel_size: 3
  stride: 2
}
}
layer {
name: "norm1"
type: "LRN"
bottom: "pool1"
top: "norm1"
lrn_param {
  local_size: 5
  alpha: 0.0001
  beta: 0.75
}
}
layer {
name: "conv2"
type: "Convolution"
bottom: "norm1"
top: "conv2"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
convolution_param {
  num_output: 256
  pad: 2
  kernel_size: 5
  group: 2
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 1
  }
}
}
layer {
name: "relu2"
type: "ReLU"
bottom: "conv2"
top: "conv2"
}
layer {
name: "pool2"
type: "Pooling"
bottom: "conv2"
top: "pool2"
pooling_param {
  pool: MAX
  kernel_size: 3
  stride: 2
}
}
layer {
name: "norm2"
type: "LRN"
bottom: "pool2"
top: "norm2"
lrn_param {
  local_size: 5
  alpha: 0.0001
  beta: 0.75
}
}
layer {
name: "conv3"
type: "Convolution"
bottom: "norm2"
top: "conv3"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
convolution_param {
  num_output: 384
  pad: 1
  kernel_size: 3
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 0
  }
}
}
layer {
name: "relu3"
type: "ReLU"
bottom: "conv3"
top: "conv3"
}
layer {
name: "conv4"
type: "Convolution"
bottom: "conv3"
top: "conv4"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
convolution_param {
  num_output: 384
  pad: 1
  kernel_size: 3
  group: 2
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 1
  }
}
}
layer {
name: "relu4"
type: "ReLU"
bottom: "conv4"
top: "conv4"
}
layer {
name: "conv5"
type: "Convolution"
bottom: "conv4"
top: "conv5"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
convolution_param {
  num_output: 256
  pad: 1
  kernel_size: 3
  group: 2
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 1
  }
}
}
layer {
name: "relu5"
type: "ReLU"
bottom: "conv5"
top: "conv5"
}
layer {
name: "pool5"
type: "Pooling"
bottom: "conv5"
top: "pool5"
pooling_param {
  pool: MAX
  kernel_size: 3
  stride: 2
}
}
layer {
name: "fc6"
type: "InnerProduct"
bottom: "pool5"
top: "fc6"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
inner_product_param {
  num_output: 4096
  weight_filler {
    type: "gaussian"
    std: 0.005
  }
  bias_filler {
    type: "constant"
    value: 1
  }
}
}
layer {
name: "relu6"
type: "ReLU"
bottom: "fc6"
top: "fc6"
}
layer {
name: "drop6"
type: "Dropout"
bottom: "fc6"
top: "fc6"
dropout_param {
  dropout_ratio: 0.5
}
}
layer {
name: "fc7"
type: "InnerProduct"
bottom: "fc6"
top: "fc7"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
inner_product_param {
  num_output: 4096
  weight_filler {
    type: "gaussian"
    std: 0.005
  }
  bias_filler {
    type: "constant"
    value: 1
  }
}
}
layer {
name: "relu7"
type: "ReLU"
bottom: "fc7"
top: "fc7"
}
layer {
name: "drop7"
type: "Dropout"
bottom: "fc7"
top: "fc7"
dropout_param {
  dropout_ratio: 0.5
}
}
layer {
name: "fc8"
type: "InnerProduct"
bottom: "fc7"
top: "fc8"
param {
  lr_mult: 1
  decay_mult: 1
}
param {
  lr_mult: 2
  decay_mult: 0
}
inner_product_param {
  num_output: 4
  weight_filler {
    type: "gaussian"
    std: 0.01
  }
  bias_filler {
    type: "constant"
    value: 0
  }
}
}
layer {
name: "accuracy"
type: "Accuracy"
bottom: "fc8"
bottom: "label"
top: "accuracy"
include {
  phase: TEST
}
}
layer {
name: "loss"
type: "SoftmaxWithLoss"
bottom: "fc8"
bottom: "label"
top: "loss"
} 

?

Caffe 模型的可視化表示

?

同時我們可以創(chuàng)建基于 train.prototxt 構(gòu)建的 deploy.prototxt。這可以從 github repo 中看到。我們還將像創(chuàng)建 lmdb 文件一樣創(chuàng)建 label.txt 文件

classes
None
Nevus
Melanoma 
Seborrheic Keratosis

之后我們需要solver.prototxt中的Solver Definition，它用于優(yōu)化訓練模型。因為我們依賴CPU，所以我們需要對下面的求解器定義做一些修改。

net: "/home/[your_username]/skincancerai/model/train.prototxt"
test_iter: 50
test_interval: 50
base_lr: 0.001
lr_policy: "step"
gamma: 0.1
stepsize: 50
display: 50
max_iter: 5000
momentum: 0.9
weight_decay: 0.0005
snapshot: 1000
snapshot_prefix: "/home/[your_username]/skincancerai/model"
solver_mode: CPU 

因為我們在這里處理的數(shù)據(jù)量很小，所以我們可以縮短測試迭代并盡可能快地獲得我們的模型。簡而言之，求解器將使用驗證集每 50 次迭代計算模型的準確性。由于我們沒有大量數(shù)據(jù)，求解器優(yōu)化過程將每 1000 次迭代拍攝一次快照，最多運行 5000 次迭代。lr_policy: "step", stepsize: 2500, base_lr: 0.001 and gamma: 0.1 的當前配置是相當標準的，因為我們也可以通過bvlc 求解器文檔嘗試使用其他配置。

第 8 步：訓練模型

由于我們使用的是免費的 AI DevCloud 并且一切就緒，我們可以使用Intel Caffe ，它使用安裝在集群上的 Intel CPU 進行了優(yōu)化。由于這是一個集群，我們可以使用以下命令簡單地開始訓練。

cd /glob/deep-learning/py-faster-rcnn/caffe-fast-rcnn/build/toolsecho caffe train --solver ~/skincancerai/model/solver.prototxt | qsub -o ~/skincancerai/model/output.txt -e ~/skincancerai/model/train.log

訓練后的模型將是model_iter_1000.caffemodel、model_iter_2000.caffemodel等。使用 ISIC 提供的數(shù)據(jù)，您應該獲得大約 70% 到 80% 的準確度。您可以通過以下命令繪制自己的曲線，

cd ~/skincancerai python2 plot_learning_curve.py ./model/train.log ./model/train.png

?

訓練曲線

?

第 9 步：在具有 NCS 的 Ultra96 上部署和運行

在本文中，我們使用 Ultra96，這樣我們就可以擁有一個可以隨身攜帶的離線設(shè)備。我們已經(jīng)在步驟 3 上運行了示例。由于我們在 aarch64 上沒有激活工具包，我們可以在另一臺機器上運行編譯，然后將其復制到 ultra96

mvNCCompile deploy.prototxt -w 
model_iter_1000.caffemodel,model_iter_2000.caffemodel

這將為您提供圖形文件，復制圖形文件和標簽文件并將其與我們修改的以下代碼一起放在 CancerNet 下，將其復制到 Ultra96。我們現(xiàn)在有一個可以在家中使用的皮膚癌檢測設(shè)備。我們可以在CancerNet下使用圖形文件和categories.txt文件部署以下代碼

#!/usr/bin/python3
# ****************************************************************************
# Copyright(c) 2017 Intel Corporation. 
# License: MIT See LICENSE file in root directory.
# ****************************************************************************
# Perform inference on a LIVE camera feed using DNNs on 
# Intel? Movidius? Neural Compute Stick (NCS)
import os
import cv2
import sys
import numpy
import ntpath
import argparse
import mvnc.mvncapi as mvnc
# Variable to store commandline arguments
ARGS                 = None
# OpenCV object for video capture
camera               = None
# ---- Step 1: Open the enumerated device and get a handle to it -------------
def open_ncs_device():
   # Look for enumerated NCS device(s); quit program if none found.
   devices = mvnc.EnumerateDevices()
   if len( devices ) == 0:
       print( "No devices found" )
       quit()
   # Get a handle to the first enumerated device and open it
   device = mvnc.Device( devices[0] )
   device.OpenDevice()
   return device
# ---- Step 2: Load a graph file onto the NCS device -------------------------
def load_graph( device ):
   # Read the graph file into a buffer
   with open( ARGS.graph, mode='rb' ) as f:
       blob = f.read()
   # Load the graph buffer into the NCS
   graph = device.AllocateGraph( blob )
   return graph
# ---- Step 3: Pre-process the images ----------------------------------------
def pre_process_image( frame ):
   # Resize image [Image size is defined by choosen network, during training]
   img = cv2.resize( frame, tuple( ARGS.dim ) )
   # Extract/crop a section of the frame and resize it
   height, width, channels = frame.shape
   x1 = int( width / 3 )
   y1 = int( height / 4 )
   x2 = int( width * 2 / 3 )
   y2 = int( height * 3 / 4 )
   cv2.rectangle( frame, ( x1, y1 ) , ( x2, y2 ), ( 0, 255, 0 ), 2 )
   img = frame[ y1 : y2, x1 : x2 ]
   # Resize image [Image size if defined by choosen network, during training]
   img = cv2.resize( img, tuple( ARGS.dim ) )
   # Convert BGR to RGB [OpenCV reads image in BGR, some networks may need RGB]
   if( ARGS.colormode == "rgb" ):
       img = img[:, :, ::-1]
   # Mean subtraction & scaling [A common technique used to center the data]
   img = img.astype( numpy.float16 )
   img = ( img - numpy.float16( ARGS.mean ) ) * ARGS.scale
   return img
# ---- Step 4: Read & print inference results from the NCS -------------------
def infer_image( graph, img, frame ):
   # Load the image as a half-precision floating point array
   graph.LoadTensor( img, 'user object' )
   # Get the results from NCS
   output, userobj = graph.GetResult()
   # Find the index of highest confidence 
   top_prediction = output.argmax()
   # Get execution time
   inference_time = graph.GetGraphOption( mvnc.GraphOption.TIME_TAKEN )
   print(  "I am %3.1f%%" % (100.0 * output[top_prediction] ) + " confidant"
           + " it is " + labels[top_prediction]
           + " ( %.2f ms )" % ( numpy.sum( inference_time ) ) )
   displaystring = str(100.0 * output[top_prediction]) + " " + labels[top_prediction]
   # If a display is available, show the image on which inference was performed
   if 'DISPLAY' in os.environ:
       textsize = cv2.getTextSize(displaystring, cv2.FONT_HERSHEY_SIMPLEX, 1, 2)[0]
       textX = (frame.shape[1] - textsize[0])/2
       cv2.putText(frame, displaystring, (int(textX),450), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,0),2)
       cv2.imshow( 'Skin Cancer AI', frame )
# ---- Step 5: Unload the graph and close the device -------------------------
def close_ncs_device( device, graph ):
   graph.DeallocateGraph()
   device.CloseDevice()
   camera.release()
   cv2.destroyAllWindows()
# ---- Main function (entry point for this script ) --------------------------
def main():
   device = open_ncs_device()
   graph = load_graph( device )
   # Main loop: Capture live stream & send frames to NCS
   while( True ):
       ret, frame = camera.read()
       img = pre_process_image( frame )
       infer_image( graph, img, frame )
       # Display the frame for 5ms, and close the window so that the next
       # frame can be displayed. Close the window if 'q' or 'Q' is pressed.
       if( cv2.waitKey( 5 ) & 0xFF == ord( 'q' ) ):
           break
   close_ncs_device( device, graph )
# ---- Define 'main' function as the entry point for this script -------------
if __name__ == '__main__':
   parser = argparse.ArgumentParser(
                        description="Image classifier using \
                        Intel? Movidius? Neural Compute Stick." )
   parser.add_argument( '-g', '--graph', type=str,
                        default='CancerNet/graph',
                        help="Absolute path to the neural network graph file." )
   parser.add_argument( '-v', '--video', type=int,
                        default=0,
                        help="Index of your computer's V4L2 video device. \
                              ex. 0 for /dev/video0" )
   parser.add_argument( '-l', '--labels', type=str,
                        default='./CancerNet/categories.txt',
                        help="Absolute path to labels file." )
   parser.add_argument( '-M', '--mean', type=float,
                        nargs='+',
                        default=[78.42633776, 87.76891437, 114.89584775],
                        help="',' delimited floating point values for image mean." )
   parser.add_argument( '-S', '--scale', type=float,
                        default=1,
                        help="Absolute path to labels file." )
   parser.add_argument( '-D', '--dim', type=int,
                        nargs='+',
                        default=[227, 227],
                        help="Image dimensions. ex. -D 224 224" )
   parser.add_argument( '-c', '--colormode', type=str,
                        default="rgb",
                        help="RGB vs BGR color sequence. This is network dependent." )
   ARGS = parser.parse_args()
   # Create a VideoCapture object
   camera = cv2.VideoCapture( ARGS.video )
   # Set camera resolution
   camera.set( cv2.CAP_PROP_FRAME_WIDTH, 620 )
   camera.set( cv2.CAP_PROP_FRAME_HEIGHT, 480 )
   # Load the labels file
   labels =[ line.rstrip('\n') for line in
             open( ARGS.labels ) if line != 'classes\n']
   main()
# ==== End of file ===========================================================

從這里開始，我們就有了皮膚癌 AI 分類，只需在文件夾中運行以下命令。

python3 live-image-classifier.py 

我們可以檢測到我們自己的痣

?

檢測到常規(guī)痣

?

當有黑色素瘤時

?

檢測到黑色素瘤

?

我們可以看到完整的演示

?