本文是上一篇文章的续文。
微软于2017年6月底发布了一个主要用于嵌入式系统（例如，树莓派，ARM Cortex-M0等）的机器学习库ELL（Embedded Learning Library，嵌入式学习库）。
在之前的文章中，我大费周章，终于在树莓派上把ELL的demo跑起来了，但它实用吗？在本文中，我将简单地测试一下使用Darknet model的inference速度和精度。

『1』对比对象
我之前在树莓派上安装过了TensorFlow on Raspberry Pi（Inception v3 model），估计不会有哪个framework能比它更容易部署在树莓派上了——几乎是弹指一挥间就可以完成的零成本工作。所以我就拿它来和ELL进行简单的对比。
文章来源：https://www.codelast.com/
『2』测试数据
我随便找了10张常见物体的图片来做测试。有人会说这么少的样本量能说明什么问题？首先我只想简单快速地测试一下ELL的效果，其次我也没有时间去做严谨的测试。
下面是10张图片，序号依次从1～10：

『3』测试结果

• 速度

用图片的平均inference时间来计算速度。Tensorflow的model需要预热，我们在预热之后才开始真正算inference时间。同理，ELL的model加载时间也不计算在内。

文章来源：https://www.codelast.com/
可见，ELL+Darknet model在速度上有明显优势。

• 精度

结果有点失望。按输出中概率最大的那个分类来算，ELL使用Darknet model在10张图片上的inference结果非常糟糕，根据人工判断，5张图片分类明显错误，其余5张算是正确——这就有点尴尬了。而相比之下，TensorFlow使用Inception v3 model的情况则好得多，除了一张分类错误，其余9张基本上都算是得出了“比较正确”的结论。
下面是详细的测试结果：

文章来源：https://www.codelast.com/
即使inference速度再快，如此糟糕的准确度也是完全不能接受的。所以，我觉得，要改变这个结果，恐怕我只能用ELL CNTK VGG model再测试一遍了。正如我前面的文章所说，由于我的Ubuntu台式机性能低下，因此，我在台式机上编译ELL CNTK VGG model代码的时候，由于编译任务占用太多OS资源，被kernel自动kill掉了。不得已，我只能使用轻量级的Darknet model。所以在我当前条件下，暂时只能到这里为止了。

『4』结论
在ELL+Darknet model的速度确实比较快，但由于精度低的问题，ELL+Darknet model还需改进提高。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

➤ 在树莓派3上使用微软ELL嵌入式学习库(1)

➤ 在树莓派3上使用微软ELL嵌入式学习库(2)

➤ 在树莓派3上使用微软ELL嵌入式学习库(3)

➤ 在树莓派3上使用微软ELL嵌入式学习库(4)

➤ 在树莓派3上使用微软ELL嵌入式学习库(5)

➤ 在树莓派3上跑ELL的demo报错：ImportError: build/_darknetReference.so: undefined symbol: cblas_sgemm

➤ 执行ELL的demo程序cntkDemo.py时程序僵死的问题

➤ 解决ELL demo的 OpenCV Error: Unspecified error in cvShowImage 错误

➤ 解决编译ELL的错误：undefined reference to `cblas_xxx'

➤ 在Ubuntu 14.04系统中为ELL安装Python 3.6——通过miniconda

➤ 在Ubuntu 14.04中安装gcc 6

➤ 升级Ubuntu 14.04上的Open MPI到 libmpi.so.12 版本

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

• 目标及步骤

在上一篇文章中，我在Ubuntu PC上已经编译出了一个 compiled_darknetReference_pi3 目录，并且把它拷贝到了树莓派上。现在要做的，就是用这个目录下的文件，编译出一个Python module（_darknetReference.so），然后就可以在树莓派上跑ELL的image classification demo了。
但是，在编译这个Python module之前，我们有一些准备工作要做——安装必需的软件。
文章来源：https://www.codelast.com/

• 安装Python 3.4——通过miniconda

首先，为什么要在树莓派上安装Python 3.4呢？
因为ELL提供的demo就是一个Python程序，并且它支持的Python版本是3.4。

在前面的一篇文章中，我已经在PC Ubuntu上，通过miniconda安装过了Python 3.6，并且也解释了为什么要通过conda环境来安装Python 3.6，而不是直接在系统里装。
在树莓派上，我们也是出于相同的想法，使用miniconda环境来安装Python 3.4：

wget http://repo.continuum.io/miniconda/Miniconda3-latest-Linux-armv7l.sh
chmod +x Miniconda3-latest-Linux-armv7l.sh
./Miniconda3-latest-Linux-armv7l.sh

非常简单就装好了。
注意：和前面的文章里的做法一样，在安装即将结束的时候，我允许miniconda把PATH路径添加到我的 .bashrc 文件中。

• 在conda环境里安装必需的软件包

可以通过下面的方式，来激活conda环境：

source ~/.bashrc
conda create --name py34 python=3
source activate py34

文章来源：https://www.codelast.com/
在这个conda环境中安装 NumPy 和 OpenCV：

(py34)[root@alarmpi ~]# conda install numpy
(py34)[root@alarmpi ~]# conda install -c microsoft-ell opencv

这个过程基本不会有什么问题和坑。

• 安装OpenBLAS

在正式开始编译Python module之前，我们事实上还需要安装一个依赖软件：OpenBLAS，如果你是Rabpbian系统，那么通过 apt-get install 就可以安装，但不巧，我用的是Arch Linux ARM系统，没有OpenBLAS可以直接通过 pacman -S（相当于Rabpbian的 apt-get install） 安装，为此，我在Arch Linux ARM上搜了一下：

[root@alarmpi ~]# pacman -Ss blas
extra/blas 3.7.1-1
    Basic Linear Algebra Subprograms
extra/cblas 3.7.1-1
    C interface to BLAS
extra/liblastfm 1.0.9-2
    A Qt4 C++ library for the Last.fm webservices

相关的package一共就两个：blas和cblas，如果安装了cblas，会自动把blas也装上，因为cblas依赖于blas。
我到底该装哪个呢？没头绪。于是我把blas和cblas都装了，试试看后面的步骤能不能走下去吧！
（但是我想提前剧透一下，这样做后面的路是走不通的，如果不想等的话可以直接看这个链接里的解决方案）
文章来源：https://www.codelast.com/

• 安装其他依赖软件

除了OpenBLAS，还有其他一些依赖软件要安装，它们都是在我跑demo程序挂了之后，根据错误信息发现的，在你的树莓派上，可能你已经装过了，或者在装其他的软件时把依赖也带进去了：

pacman -S ffmpeg2.8 libpng12

• 编译Python module

还记得我们从PC上拷贝过来的 compiled_darknetReference_pi3 目录吧？现在要进到这个目录下编译了。需要特别注意的是：编译不要在miniconda环境下进行。

cd compiled_darknetReference_pi3
mkdir build
cd build
cmake ..
make

如果一切顺利，就会在build目录下编译出一个30M大的_darknetReference.so文件了。
但这个Python module能work吗？不试你是不知道的，于是跑ELL的demo来测试一下。

• 测试Python module——跑ELL的demo

激活miniconda环境，把USB摄像头插到树莓派的USB接口上，然后run ELL的demo：

(py34)[root@alarmpi ~]# cd compiled_darknetReference_pi3
(py34)[root@alarmpi ~]# python compiledDarknetDemo.py

如果你的运气真的特别好，那么这个demo就能跑起来。
在这里，我要特别提一下，我的树莓派OS Arch Linux ARM是没有安装图形界面的，所以在command line下跑上面的demo，会直接报错：

(frame:12648): Gtk-WARNING **: cannot open display:

ImportError: build/_darknetReference.so: undefined symbol: cblas_sgemm

微软于2017年6月底发布了一个主要用于嵌入式系统（例如，树莓派，ARM Cortex-M0等）的机器学习库ELL（Embedded Learning Library，嵌入式学习库）。
本文主要介绍了在树莓派上跑ELL的demo程序时，遇到的一个“undefined symbol: cblas_sgemm”问题的解决办法。

当我们一切准备工作已经基本完成，在树莓派上跑ELL的demo程序时，可能会报这个错：

(py34)[root@alarmpi compiled_darknetReference_pi3]# python compiledDarknetDemo.py

Traceback (most recent call last):

File "/root/raspberry-pi/ai/ell-related/compiled_darknetReference_pi3/darknetReference.py", line 14, in swig_import_helper

return importlib.import_module(mname)

File "/root/.miniconda3/envs/py34/lib/python3.4/importlib/init.py", line 109, in import_module

return _bootstrap._gcd_import(name[level:], package, level)

File "", line 2254, in _gcd_import

File "", line 2237, in _find_and_load

File "", line 2226, in _find_and_load_unlocked

File "", line 1191, in _load_unlocked

File "", line 1161, in _load_backward_compatible

File "", line 539, in _check_name_wrapper

File "", line 1715, in load_module

File "", line 321, in _call_with_frames_removed

ImportError: build/_darknetReference.so: undefined symbol: cblas_sgemm

 

During handling of the above exception, another exception occurred:

 

Traceback (most recent call last):

File "compiledDarknetDemo.py", line 11, in 

import darknetReference as model

File "/root/raspberry-pi/ai/ell-related/compiled_darknetReference_pi3/darknetReference.py", line 17, in 

_darknetReference = swig_import_helper()

File "/root/raspberry-pi/ai/ell-related/compiled_darknetReference_pi3/darknetReference.py", line 16, in swig_import_helper

return importlib.import_module('_darknetReference')

File "/root/.miniconda3/envs/py34/lib/python3.4/importlib/init.py", line 109, in import_module

return _bootstrap._gcd_import(name[level:], package, level)

ImportError: build/_darknetReference.so: undefined symbol: cblas_sgemm

[root@alarmpi ~]# pacman -Ss blas
extra/blas 3.7.1-1
    Basic Linear Algebra Subprograms
extra/cblas 3.7.1-1
    C interface to BLAS
extra/liblastfm 1.0.9-2
    A Qt4 C++ library for the Last.fm webservices

git clone https://github.com/xianyi/OpenBLAS
cd OpenBLAS
make

pacman -R blas cblas

[root@alarmpi build]# export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/lib/openblas/lib

• 为目标平台（树莓派）编译代码

ELL自带了一个非常酷的神经网络模型编译器，它可以为目标平台生成高度优化的代码，从而可以让model在目标平台上以很快的速度运行。
在前面运行 CNTK demo的时候，细心的你一定会发现，demo运行的同时，在 ELL/build/tutorials/vision/gettingStarted/ 目录下生成了一个 vgg16ImageNet.map 文件（如果你使用的是Darknet，生成的就是 darknetReference.map），这个文件是ELL格式的model文件，之后会用到。
文章来源：https://www.codelast.com/
所以二话不说，直接开始编译：

cd ELL/build
make compiled_vgg16ImageNet_pi3

我以为这个过程会很顺利，结果呢？我试了很多次，每一次编译经过很长时间的等待之后，都以失败告终，错误信息大概类似于下面这样：

(前面还有很多，省略)

[ 85%] Built target trainers

[ 96%] Built target common

[ 98%] Built target compile

[ 98%] Generating /home/codelast/programme/pi/ELL/build/tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.ll;/home/codelast/programme/pi/ELL/build/tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.i;/home/codelast/programme/pi/ELL/build/tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.i.h

OpenBLAS : Your OS does not support AVX instructions. OpenBLAS is using Nehalem kernels as a fallback, which may give poorer performance.

[100%] Compiling vgg16ImageNet.ll to /home/codelast/programme/pi/ELL/build/tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.o for pi3

Killed

make[3]: *** [tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.o] Error 137

make[3]: *** Deleting file `tutorials/vision/gettingStarted/compiled_vgg16ImageNet_pi3/vgg16ImageNet.o'

make[2]: *** [tutorials/vision/gettingStarted/CMakeFiles/compiled_vgg16ImageNet_pi3.dir/all] Error 2

make[1]: *** [tutorials/vision/gettingStarted/CMakeFiles/compiled_vgg16ImageNet_pi3.dir/rule] Error 2

make: *** [compiled_vgg16ImageNet_pi3] Error 2

cd build/tutorials/vision/gettingStarted
curl -O https://raw.githubusercontent.com/pjreddie/darknet/master/cfg/darknet.cfg
curl -O https://pjreddie.com/media/files/darknet.weights

cd ELL/build
make compiled_darknetReference_pi3

• 选择模型

至此，我们终于到模型这一步了。
由于训练机器学习模型的时间通常较长，所以，训练模型这个工作肯定不能放在树莓派上干。我们可以使用别人已经预先训练好的模型来节省时间，ELL文档里推荐了两个：CNTK和Darknet。
本文在PC上测试ELL时，将主要使用CNTK；而在树莓派上测试ELL时，出于运行速度等种种原因考虑，不得不使用Darknet（和Darknet相比，CNTK不够轻量级）。

• 安装CNTK相关的软件

在前面的conda环境下，安装CNTK的Python package：

pip install https://cntk.ai/PythonWheel/CPU-Only/cntk-2.0-cp36-cp36m-linux_x86_64.whl

输出类似于：

Collecting cntk==2.0 from https://cntk.ai/PythonWheel/CPU-Only/cntk-2.0-cp36-cp36m-linux_x86_64.whl

  Downloading https://cntk.ai/PythonWheel/CPU-Only/cntk-2.0-cp36-cp36m-linux_x86_64.whl (109.5MB)
......

Successfully installed cntk-2.0

这一步耗时较长，耐心等待吧。
然后回到ELL代码根目录，切换到gettingStarted目录并下载CNTK的ImageNet推断模型：

cd build/tutorials/vision/gettingStarted
curl -O https://www.cntk.ai/Models/Caffe_Converted/VGG16_ImageNet_Caffe.model

• 测试模型

下面可以测试一下模型了：

(py36) [codelast@ gettingStarted]$ python cntkDemo.py

如果此时报错：

conda install openblas

sudo apt-get install libopenmpi-dev

『1』拿ELL来做什么？
首先，我们要拿ELL来实现一个什么功能？
微软官方给出的一个指导文档是《Getting Started with Computer Vision》，也就是说我们要在嵌入式系统上用ELL实现一个机器视觉的应用，以微软官方提供的下面这个图片为例：

即：用树莓派的摄像头拍摄一个物体，运行在树莓派上的ELL程序可以识别出它“是什么”。
文章来源：https://www.codelast.com/
『2』软硬件准备

• 树莓派3代（OS：Arch Linux ARM）
• 用于树莓派的USB摄像头（也可以用和树莓派配套的那个专用摄像头，但价格比较贵，我手上没有）
• 台式机（OS：Ubuntu 14.04 LTS）

『3』台式机上的准备工作
不要以为我们让模型跑在树莓派上，就没有台式机什么事了。实际上，我们需要先在台式机上做非常多的工作，然后才能在树莓派上跑ELL。
所以，本文讲的就是我们要在台式机上做的那些繁琐工作，切记：本文的所有操作，都是在台式机上运行的，跟树莓派没有关系。

• 下载ELL的代码

首先我们从Github上检出ELL的代码，尽管在网页上看ELL的文档更方便一些，但是后面我们是需要用到这份代码的，所以这一步肯定要做：

git clone https://github.com/Microsoft/ELL.git

• 安装基础软件依赖

除此之外，编译ELL还对系统有很多软件依赖，例如cmake，llvm之类，具体请看这个ELL的文档。整个安装、解决问题的过程真的相当麻烦，要有充分的心理准备。
第1点注意：cmake要装3.3版的，ELL的文档里没有写，如果你用 apt-get install cmake 安装，那么装上去的版本可能不符合要求，最后一定会出问题，导致整个流程走不下去。
所以我是这样装的cmake：

apt-cache show cmake3
sudo apt-get install cmake3

第2点注意：ELL对gcc版本有要求，但ELL的doc里没写。具体请看这篇文章。

文章来源：https://www.codelast.com/

• 安装Python 3.6——通过miniconda

为什么要用Python 3.6？因为ELL的demo程序就是Python 3.6的。
根据ELL文档的建议，我们不应该“直接”在系统里安装Python 3.6，而是通过conda环境来安装，具体请看这篇文章。

• 在miniconda环境下安装必需的软件包

安装好 miniconda 之后，需要安装 curl，numpy 和 opencv（如果没有安装过的话）：

conda install curl
conda install numpy

你一定感觉很奇怪：上面的命令并没有安装OpenCV啊？！没错，这是因为，按照ELL文档的做法（conda install -c conda-forge opencv）安装上的OpenCV是有问题的——至少在我的Ubuntu上不能用。如果你着急的话，可以直接看这篇文章的解决方案；如果你不急的话，可以暂时按ELL文档的说明去安装OpenCV，然后跟着本系列文章的节奏，一点点地发现问题、解决问题（没错，后面的章节还有讲到这个问题）。

• 安装SWIG

下一步，你需要安装用于生成language binding（语言绑定）的SWIG软件（和conda环境无关）。比如我们要用Python来调用ELL，那么就需要Python binding，诸如此类。
在Ubuntu 14.04上，用 apt-get install swig3.0 安装上的SWIG是3.0.2版本，满足不了ELL要求的“version 3.0.12 or later”，所以，我们只能自己下载、编译SWIG了：

wget https://nchc.dl.sourceforge.net/project/swig/swig/swig-3.0.12/swig-3.0.12.tar.gz
tar zxf swig-3.0.12.tar.gz
cd swig-3.0.12
./configure --without-pcre && make && sudo make install

• 编译ELL

下面可以开始编译ELL了。这里的编译过程不要在conda环境下执行。
回到之前检出的ELL代码的根目录下，执行下面的命令：

mkdir build
cd build
cmake ..
make

如果不出错，那表明你运气是真的好。
我记得我是编译到61％的时候挂掉的，错误信息如下：

[ 0%] Built target documentation

......

[ 61%] Linking CXX executable common_test

../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Copy(int, float const*, int, float*, int)': BlasWrapper.cpp:(.text+0x31): undefined reference tocblas_scopy'

......

../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Gemm(CBLAS_ORDER, CBLAS_TRANSPOSE, CBLAS_TRANSPOSE, int, int, int, double, double const*, int, double const*, int, double, double*, int)': BlasWrapper.cpp:(.text+0x471): undefined reference tocblas_dgemm'

collect2: error: ld returned 1 exit status

make[2]: *** [libraries/common/common_test] Error 1

make[1]: *** [libraries/common/CMakeFiles/common_test.dir/all] Error 2

make: *** [all] Error 2

• 生成Python binding

接下来，需要配置miniconda里的Python环境：

# Create the environment
conda create -n py36 anaconda python=3
# Activate the environment
source activate py36
# ELL requires gcc 5 and above for C++14. Upgrade anaconda's environment to support it.
conda install libgcc

注意：第二句命令是 source activate py36，而ELL的文档里是 activate py36，一执行就报错，会提示你要在前面加source。
这一步耗时较长，等它完成之后，我们就可以生成Python binding了。在同一个命令行窗口里（刚激活了py36环境），到之前检出的ELL代码的根目录下，执行下面的命令（其实前3行命令前面已经执行过了，如果没有删除build目录的话可以不再重新执行）：

mkdir build
cd build
cmake ..
make _ELL_python 

如果不出错的话，Python binding就生成成功了，但是你如果在 cmake 那一步遇到这样的错误：

CMake Error at CMakeLists.txt:5 (cmake_minimum_required):

  CMake 3.3 or higher is required.  You are running version 2.8.12.2

-- Configuring incomplete, errors occurred!

这就是本文前面的章节说过的cmake版本过低导致的，前面已经说过了如何安装高版本的cmake，这里不再复述。
然后再重新执行cmake及其后步骤，OK的话，就可以测试一下Python binding是否能正常工作。回到ELL代码的根目录，然后：

(py36) [codelast@ ELL]$ cd build/interfaces/python/test
(py36) [codelast@ test]$ python test.py

注意：一定要cd到 build/interface/python/test/ 这个目录下跑test！之所以强调这一点，是因为在ELL代码根目录下，还有一个一模一样的 interfaces/python/test/ 目录，如果你弄错了，到这个目录下跑test，会发现console没有任何输出信息，很迷惑人。
正常的test输出信息类似于下面这样：

OpenBLAS : Your OS does not support AVX instructions. OpenBLAS is using Nehalem kernels as a fallback, which may give poorer performance.

Testing HingeLoss.Evaluate(2, 1) ... Passed

Testing HingeLoss.Evaluate(-2, -1) ... Passed

（中间还有很多，此处省略）

Testing SquaredLoss.GetDerivative(4, 2) ... Passed

Testing SquaredLoss.GetDerivative(2, 4) ... Passed

functions_test passed

[1] One subgraph

    Subgraph Vertices Edges Cycles

    0        6        8     3    

[2] One subgraph

    Subgraph Vertices Edges Cycles

    0        6        6     1    

（中间还有很多，此处省略）
[tree_3] One subgraph

    Subgraph Vertices Edges Cycles

    0        101      126   26   

model_test passed

Model 1 size: 6

Model 2 size: 6

Model 3 size: 8

Tree 0 size: 17

Tree 1 size: 45

Tree 2 size: 73

Tree 3 size: 101

Loading file ../../../examples/data/model_1.model

Loading file ../../../examples/data/model_2.model

common_test passed

trainers_test.test -- TBD

trainers_test passed

predictors_test.test -- TBD

predictors_test passed

nodes_test.test -- TBD

nodes_test passed

linear_test.test -- TBD

linear_test passed

evaluators_test.test -- TBD

evaluators_test passed

Testing ModelBuilder ... Passed

modelbuilder_test passed

这说明Python binding可以正常工作了。
下面，我们将进入和模型相关的测试，请看后一篇文章。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

在台式机上执行ELL的demo程序 cntkDemo.py 时，可能会遇到程序僵死的问题。
cntkDemo.py 这个程序会调用OpenCV，在一个GUI窗口中显示USB摄像头拍摄的实时视频流，而僵死的现象正是：执行到弹出GUI窗口显示摄像头拍摄的视频流的代码的时候，程序进入僵死状态，不能执行后续逻辑。此时，只能Ctrl+C终止掉程序。

我的Ubuntu 14.04是一台老爷机，性能非常差，我觉得这有可能程序僵死的原因之一？我试了几次都是这样，于是我打算换一个思路来跑这个demo，不再纠结于解决窗口僵死的问题。
文章来源：https://www.codelast.com/
先来看一下原版的 cntkDemo.py 部分代码：

    while (True):
        # Grab next frame
        ret, frame = cap.read()

        # Prepare the image to send to the model.
        # This involves scaling to the required input dimension and re-ordering from BGR to RGB
        data = helper.prepare_image_for_predictor(frame)

        # Get the model to classify the image, by returning a list of probabilities for the classes it can detect
        predictions = model.Predict(data)

        # Get the (at most) top 5 predictions that meet our threshold. This is returned as a list of tuples,
        # each with the text label and the prediction score.
        top5 = helper.get_top_n(predictions, 5)

        # Turn the top5 into a text string to display
        text = "".join([str(element[0]) + "(" + str(int(100*element[1])) + "%)  " for element in top5])

        # Draw the text on the frame
        frameToShow = frame
        helper.draw_label(frameToShow, text)
        helper.draw_fps(frameToShow)

        # Show the new frame
        cv2.imshow('frame', frameToShow)

        # Wait for Esc key
        if cv2.waitKey(1) & 0xFF == 27:
            break

这段代码的注释非常清晰，它的功能是：在一个无限循环中，不断地去抓取USB摄像头拍摄的一帧图像，然后用model预测其分类及概率，最后再把预测结果叠加显示在GUI窗口中，类似于下面这样：

既然 cntkDemo.py 主要是为了测试model能不能正常跑，那么我在命令行以文字形式显示预测结果也是一样的啊，没有必要非得在GUI窗口中展示。
文章来源：https://www.codelast.com/
于是我把程序改成了下面这样（完整程序）：

import sys
import os
import numpy as np
import cv2
import time

import findEll
import cntk_to_ell
import modelHelper as mh

def get_ell_predictor(modelConfig):
    """Imports a model and returns an ELL.Predictor."""
    return cntk_to_ell.predictor_from_cntk_model(modelConfig.model_files[0])

def main():

    if (not os.path.exists('VGG16_ImageNet_Caffe.model')):
        print("Please download the 'VGG16_ImageNet_Caffe.model' file, see README.md")
        sys.exit(1)
        
    # ModelConfig for VGG16 model from CNTK Model Gallery
    # Follow the instructions in README.md to download the model if you intend to use it.
    helper = mh.ModelHelper("VGG16ImageNet", ["VGG16_ImageNet_Caffe.model"], "cntkVgg16ImageNetLabels.txt", scaleFactor=1.0)

    # Import the model
    model = get_ell_predictor(helper)

    # Save the model
    helper.save_ell_predictor_to_file(model, "vgg16ImageNet.map")

    camera = 0
    if (len(sys.argv) > 1):
        camera = int(sys.argv[1]) 

    # Start video capture device
    cap = cv2.VideoCapture(camera)

    while (True):
        print('Read a frame from camera...')
        ret, frame = cap.read()

        # Prepare the image to send to the model.
        # This involves scaling to the required input dimension and re-ordering from BGR to RGB
        data = helper.prepare_image_for_predictor(frame)

        # Get the model to classify the image, by returning a list of probabilities for the classes it can detect
        predictions = model.Predict(data)

        # Get the (at most) top 5 predictions that meet our threshold. This is returned as a list of tuples,
        # each with the text label and the prediction score.
        top5 = helper.get_top_n(predictions, 5)

        # Turn the top5 into a text string to display
        text = "".join([str(element[0]) + "(" + str(int(100*element[1])) + "%)  " for element in top5])

        # Output the text on command line
        print(text)

if __name__ == "__main__":
    main()

其中最关键的是，不再用 cv2.imshow() 的方式来弹出GUI窗口，而是用 print(text) 的方式把结果打印到command line。
经过实测，在我的老爷机上这个程序就完全不会僵死了。此时，你把摄像头对准哪个物体，它拍摄的就是哪个物体的图像，model也就是对这个物体的图像进行分类预测。
文章来源：https://www.codelast.com/
下面是我的一次test的command line输出：

OpenBLAS : Your OS does not support AVX instructions. OpenBLAS is using Nehalem kernels as a fallback, which may give poorer performance.

Read a frame from camera, time 1

Frame 1 saved to disk

Read a frame from camera, time 2

Frame 2 saved to disk

Read a frame from camera, time 3

Frame 3 saved to disk

Read a frame from camera, time 4

Frame 4 saved to disk

Read a frame from camera, time 5

Frame 5 saved to disk

Loading...

Selected CPU as the process wide default device.

 

Finished loading.

Pre-processing...

 

Will not process Dropout - skipping this layer as irrelevant.

 

Will not process Dropout - skipping this layer as irrelevant.

 

Will not process Combine - skipping this layer as irrelevant.

Convolution :  226x226x3  ->  224x224x64 | padding  1

ReLU :  224x224x64  ->  226x226x64 | padding  0

Convolution :  226x226x64  ->  224x224x64 | padding  1

ReLU :  224x224x64  ->  224x224x64 | padding  0

Pooling :  224x224x64  ->  114x114x64 | padding  0

Convolution :  114x114x64  ->  112x112x128 | padding  1

ReLU :  112x112x128  ->  114x114x128 | padding  0

Convolution :  114x114x128  ->  112x112x128 | padding  1

ReLU :  112x112x128  ->  112x112x128 | padding  0

Pooling :  112x112x128  ->  58x58x128 | padding  0

Convolution :  58x58x128  ->  56x56x256 | padding  1

ReLU :  56x56x256  ->  58x58x256 | padding  0

Convolution :  58x58x256  ->  56x56x256 | padding  1

ReLU :  56x56x256  ->  58x58x256 | padding  0

Convolution :  58x58x256  ->  56x56x256 | padding  1

ReLU :  56x56x256  ->  56x56x256 | padding  0

Pooling :  56x56x256  ->  30x30x256 | padding  0

Convolution :  30x30x256  ->  28x28x512 | padding  1

ReLU :  28x28x512  ->  30x30x512 | padding  0

Convolution :  30x30x512  ->  28x28x512 | padding  1

ReLU :  28x28x512  ->  30x30x512 | padding  0

Convolution :  30x30x512  ->  28x28x512 | padding  1

ReLU :  28x28x512  ->  28x28x512 | padding  0

Pooling :  28x28x512  ->  16x16x512 | padding  0

Convolution :  16x16x512  ->  14x14x512 | padding  1

ReLU :  14x14x512  ->  16x16x512 | padding  0

Convolution :  16x16x512  ->  14x14x512 | padding  1

ReLU :  14x14x512  ->  16x16x512 | padding  0

Convolution :  16x16x512  ->  14x14x512 | padding  1

ReLU :  14x14x512  ->  14x14x512 | padding  0

Pooling :  14x14x512  ->  7x7x512 | padding  0

linear :  7x7x512  ->  1x1x4096 | padding  0

ReLU :  1x1x4096  ->  1x1x4096 | padding  0

linear :  1x1x4096  ->  1x1x4096 | padding  0

ReLU :  1x1x4096  ->  1x1x4096 | padding  0

linear :  1x1x4096  ->  1x1x1000 | padding  0

Softmax :  1x1x1000  ->  1x1x1000 | padding  0

 

Finished pre-processing.

 

Constructing equivalent ELL layers from CNTK...

Converting layer  conv1_1: Convolution(data: Tensor[3,224,224]) -> Tensor[64,224,224]

Converting layer  relu1_1: ReLU(conv1_1: Tensor[64,224,224]) -> Tensor[64,224,224]

Converting layer  conv1_2: Convolution(relu1_1: Tensor[64,224,224]) -> Tensor[64,224,224]

Converting layer  relu1_2: ReLU(conv1_2: Tensor[64,224,224]) -> Tensor[64,224,224]

Converting layer  pool1: Pooling(relu1_2: Tensor[64,224,224]) -> Tensor[64,112,112]

Converting layer  conv2_1: Convolution(pool1: Tensor[64,112,112]) -> Tensor[128,112,112]

Converting layer  relu2_1: ReLU(conv2_1: Tensor[128,112,112]) -> Tensor[128,112,112]

Converting layer  conv2_2: Convolution(relu2_1: Tensor[128,112,112]) -> Tensor[128,112,112]

Converting layer  relu2_2: ReLU(conv2_2: Tensor[128,112,112]) -> Tensor[128,112,112]

Converting layer  pool2: Pooling(relu2_2: Tensor[128,112,112]) -> Tensor[128,56,56]

Converting layer  conv3_1: Convolution(pool2: Tensor[128,56,56]) -> Tensor[256,56,56]

Converting layer  relu3_1: ReLU(conv3_1: Tensor[256,56,56]) -> Tensor[256,56,56]

Converting layer  conv3_2: Convolution(relu3_1: Tensor[256,56,56]) -> Tensor[256,56,56]

Converting layer  relu3_2: ReLU(conv3_2: Tensor[256,56,56]) -> Tensor[256,56,56]

Converting layer  conv3_3: Convolution(relu3_2: Tensor[256,56,56]) -> Tensor[256,56,56]

Converting layer  relu3_3: ReLU(conv3_3: Tensor[256,56,56]) -> Tensor[256,56,56]

Converting layer  pool3: Pooling(relu3_3: Tensor[256,56,56]) -> Tensor[256,28,28]

Converting layer  conv4_1: Convolution(pool3: Tensor[256,28,28]) -> Tensor[512,28,28]

Converting layer  relu4_1: ReLU(conv4_1: Tensor[512,28,28]) -> Tensor[512,28,28]

Converting layer  conv4_2: Convolution(relu4_1: Tensor[512,28,28]) -> Tensor[512,28,28]

Converting layer  relu4_2: ReLU(conv4_2: Tensor[512,28,28]) -> Tensor[512,28,28]

Converting layer  conv4_3: Convolution(relu4_2: Tensor[512,28,28]) -> Tensor[512,28,28]

Converting layer  relu4_3: ReLU(conv4_3: Tensor[512,28,28]) -> Tensor[512,28,28]

Converting layer  pool4: Pooling(relu4_3: Tensor[512,28,28]) -> Tensor[512,14,14]

Converting layer  conv5_1: Convolution(pool4: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  relu5_1: ReLU(conv5_1: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  conv5_2: Convolution(relu5_1: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  relu5_2: ReLU(conv5_2: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  conv5_3: Convolution(relu5_2: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  relu5_3: ReLU(conv5_3: Tensor[512,14,14]) -> Tensor[512,14,14]

Converting layer  pool5: Pooling(relu5_3: Tensor[512,14,14]) -> Tensor[512,7,7]

Converting layer  fc6: linear(pool5: Tensor[512,7,7]) -> Tensor[4096]

Converting layer  relu6: ReLU(fc6: Tensor[4096]) -> Tensor[4096]

Converting layer  fc7: linear(drop6: Tensor[4096]) -> Tensor[4096]

Converting layer  relu7: ReLU(fc7: Tensor[4096]) -> Tensor[4096]

Converting layer  fc8: linear(drop7: Tensor[4096]) -> Tensor[1000]

Converting layer  prob: Softmax(fc8: Tensor[1000]) -> Tensor[1000]

 

...Finished constructing ELL layers.

lighter, light, igniter, ignitor(28%)  

lighter, light, igniter, ignitor(28%)  

 

lighter, light, igniter, ignitor(32%)  

lighter, light, igniter, ignitor(30%)

......