在台式机上执行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%)

......

在ELL的tutorial中，有一个步骤是在PC上测试运行一个demo程序来检查ELL能否正常工作，当你选择CNTK model的时候，运行的就是 cntkDemo.py 这个demo程序。

这个demo程序调用了OpenCV来在GUI窗口中显示摄像头拍摄的实时视频，可能会跑不起来，并输出下面这样的错误：

OpenCV Error: Unspecified error (The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Carbon support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script) in cvShowImage, file /feedstock_root/build_artefacts/opencv_1490907195496/work/opencv-3.2.0/modules/highgui/src/window.cpp, ...（后面还有很长的内容）

如果你的PC和我的一样老旧，那么执行 python cntkDemo.py 可能耗时非常长（你可以在一台老爷车上试一下），直到N分钟后才打印出上面的错误，然后程序挂掉，这使得我们解决这个问题非常不方便——每次都要等待超级长的时间，才知道自己的修改是否有效。
文章来源：https://www.codelast.com/
因此，为了能便于debug问题，我们先把和上面那个错误相关的关键代码段提取出来，单独放到一个源代码文件 z.py 中：

import numpy as np
import cv2
cam = cv2.VideoCapture(0)
while True:
    ret, frame = cam.read()
    cv2.imshow('test', frame)
    if cv2.waitKey(1) & 0xFF == 27:
        break

稍后，我们只需要执行 python z.py，不出错的话，就说明我们搞定了以上问题。
注意：这里的程序假设你的Ubuntu PC上至少连接了一个USB摄像头，cv2.VideoCapture(0)里的0就是指第一个摄像头，千万不要傻傻地在没有摄像头的情况下测试。
文章来源：https://www.codelast.com/

conda install -c conda-forge opencv

conda install --channel loopbio --channel conda-forge --channel pkgw-forge gtk2 ffmpeg ffmpeg-feature gtk2-feature opencv

[ 0%] Built target documentation
[ 10%] Built target utilities
[ 11%] Built target math
[ 14%] Built target data
[ 23%] Built target emitters
[ 24%] Built target evaluators
[ 28%] Built target functions
[ 37%] Built target model
[ 39%] Built target predictors
[ 48%] Built target nodes
[ 52%] Built target trainers
[ 59%] Built target common
[ 60%] Built target testing
[ 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::Copy(int, double const*, int, double*, int)': BlasWrapper.cpp:(.text+0x69): undefined reference tocblas_dcopy'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Asum(int, float const*, int)': BlasWrapper.cpp:(.text+0x92): undefined reference tocblas_sasum'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Asum(int, double const*, int)': BlasWrapper.cpp:(.text+0xba): undefined reference tocblas_dasum'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Nrm2(int, float const*, int)': BlasWrapper.cpp:(.text+0xf0): undefined reference tocblas_snrm2'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Nrm2(int, double const*, int)': BlasWrapper.cpp:(.text+0x118): undefined reference tocblas_dnrm2'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Scal(int, float, float*, int)': BlasWrapper.cpp:(.text+0x15b): undefined reference tocblas_sscal'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Scal(int, double, double*, int)': BlasWrapper.cpp:(.text+0x193): undefined reference tocblas_dscal'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Axpy(int, float, float const*, int, float*, int)': BlasWrapper.cpp:(.text+0x1d9): undefined reference tocblas_saxpy'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Axpy(int, double, double const*, int, double*, int)': BlasWrapper.cpp:(.text+0x221): undefined reference tocblas_daxpy'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Dot(int, float const*, int, float const*, int)': BlasWrapper.cpp:(.text+0x259): undefined reference tocblas_sdot'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Dot(int, double const*, int, double const*, int)': BlasWrapper.cpp:(.text+0x290): undefined reference tocblas_ddot'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Gemv(CBLAS_ORDER, CBLAS_TRANSPOSE, int, int, float, float const*, int, float const*, int, float, float*, int)': BlasWrapper.cpp:(.text+0x309): undefined reference tocblas_sgemv'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Gemv(CBLAS_ORDER, CBLAS_TRANSPOSE, int, int, double, double const*, int, double const*, int, double, double*, int)': BlasWrapper.cpp:(.text+0x37c): undefined reference tocblas_dgemv'
../math/libmath.a(BlasWrapper.cpp.o): In function ell::math::Blas::Gemm(CBLAS_ORDER, CBLAS_TRANSPOSE, CBLAS_TRANSPOSE, int, int, int, float, float const*, int, float const*, int, float, float*, int)': BlasWrapper.cpp:(.text+0x3f5): undefined reference tocblas_sgemm'
../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

sudo dpkg -l | grep atlas

然后把这3个package都卸载掉：

sudo apt-get remove libatlas-base-dev libatlas-dev ibatlas3-base

文章来源：https://www.codelast.com/
然后再重新cmake，输出信息如下：

-- The C compiler identification is GNU 6.3.0

-- The CXX compiler identification is GNU 6.3.0

-- Check for working C compiler: /usr/bin/cc

-- Check for working C compiler: /usr/bin/cc -- works

-- Detecting C compiler ABI info

-- Detecting C compiler ABI info - done

-- Detecting C compile features

-- Detecting C compile features - done

-- Check for working CXX compiler: /usr/bin/c++

-- Check for working CXX compiler: /usr/bin/c++ -- works

-- Detecting CXX compiler ABI info

-- Detecting CXX compiler ABI info - done

-- Detecting CXX compile features

-- Detecting CXX compile features - done

-- Looking for pthread.h

-- Looking for pthread.h - found

-- Looking for pthread_create

-- Looking for pthread_create - not found

-- Looking for pthread_create in pthreads

-- Looking for pthread_create in pthreads - not found

-- Looking for pthread_create in pthread

-- Looking for pthread_create in pthread - found

-- Found Threads: TRUE  

-- Blas libraries: /usr/lib/libblas.so

-- Blas linker flags: 

-- Blas include directories: 

-- Using BLAS include path: /usr/include

-- Using BLAS library: /usr/lib/libblas.so

-- Using BLAS DLLs: 

-- Found PythonInterp: /home/codelast/.miniconda3/bin/python (found version "3.6.1") 

-- Found PythonLibs: /home/codelast/.miniconda3/lib/libpython3.6m.so (found version "3.6.1") 

-- Found SWIG: /usr/local/bin/swig (found suitable version "3.0.12", minimum required is "3.0.12") 

-- Creating wrappers for python

-- Creating wrappers for javascript

-- Creating wrappers for xml

-- Using python found at: /home/codelast/.miniconda3/bin/python

-- Using python libraries found at: /home/codelast/.miniconda3/lib/libpython3.6m.so

-- Creating wrappers for python

-- Generated target compiled_vgg16ImageNet_host

-- Generated target compiled_vgg16ImageNet_pi3

-- Generated target compiled_vgg16ImageNet_pi0

-- Generated target compiled_darknetReference_host

-- Generated target compiled_darknetReference_pi3

-- Generated target compiled_darknetReference_pi0

-- Configuring done

-- Generating done

-- Build files have been written to: /home/codelast/programme/pi/ELL/build

Anaconda is the world’s most popular and trusted data science ecosystem.

这句话太大了，没有了解过的人看了也不知道它具体指的是什么。其实anaconda可以理解为一个Python发行版，就像Ubuntu是一个Linux发行版一样。
在anaconda中，你可以用 conda install xxx 命令很方便地安装各种科学计算所需的Python module，就像Ubuntu用 apt-get install xxx 安装各种软件一样容易。
这样的话，我们就无需自己去折腾安装各种Python module的依赖问题了，可以节省大量时间。
而miniconda是anaconda的精简版，就像Ubuntu的某些精简版一样，里面只包含最基本的一些软件，所以，安装miniconda比anaconda占用的磁盘空间要小得多。
文章来源：https://www.codelast.com/
我安装的是miniconda（Python 3.6，64bit版本），安装方法实在太简单，先到这里下载安装程序，然后执行安装程序即可，在安装的过程中会要你指定安装路径，我把它安装到了当前用户的 ~/.miniconda3/ 目录下，并且在安装即将结束的时候，允许miniconda把PATH路径添加到我的 .bashrc 文件中：

# added by Miniconda3 4.3.21 installer
export PATH="/home/codelast/.miniconda3/bin:$PATH"

sudo apt-get update && \
sudo apt-get install build-essential software-properties-common -y && \
sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y && \
sudo apt-get update && \
sudo apt-get install gcc-snapshot -y && \
sudo apt-get update && \
sudo apt-get install gcc-6 g++-6 -y && \
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-6 && \
sudo apt-get install gcc-4.8 g++-4.8 -y && \
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 60 --slave /usr/bin/g++ g++ /usr/bin/g++-4.8;

文章来源：https://www.codelast.com/
安装完成后，使用如下命令选择gcc版本：

sudo update-alternatives --config gcc

会打印出如下提示：

There are 2 choices for the alternative gcc (providing /usr/bin/gcc).

 

  Selection    Path              Priority   Status

------------------------------------------------------------

* 0            /usr/bin/gcc-6     60        auto mode

  1            /usr/bin/gcc-4.8   60        manual mode

  2            /usr/bin/gcc-6     60        manual mode

直接回车就是使用默认的gcc 6.3。
此时，再用 gcc -v 命令检查一下版本，我的输出如下：

Using built-in specs.

COLLECT_GCC=gcc

COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/6/lto-wrapper

Target: x86_64-linux-gnu

Configured with: ...(内容很长，省略)

Thread model: posix

gcc version 6.3.0 20170519 (Ubuntu/Linaro 6.3.0-18ubuntu2~14.04)