在Python中训练OpenCV NormalBayesClassifier

Question

我正在尝试使用NormalBayesClassifier对foscam9821w网络摄像头产生的图像进行分类。它们是1280x720，最初是彩色的，但我要把它们转换成灰阶进行分类。在

{I}每次我尝试调用一个巨大的内存来train}（但是每当我调用一个巨大的内存时，我就会调用一个巨大的内存。在

mock@behemoth:~/OpenFos/code/experiments$ ./cvbayes.py --ham=../training/ham --spam=../training/spam
Image is a <type 'numpy.ndarray'> (720, 1280)
...
*** trying to train with 8 images
responses is [2, 2, 2, 2, 2, 2, 1, 1]
OpenCV Error: Insufficient memory (Failed to allocate 6794772480020 bytes) in OutOfMemoryError, file /build/buildd/opencv-2.3.1/modules/core/src/alloc.cpp, line 52
Traceback (most recent call last):
  File "./cvbayes.py", line 124, in <module>
    classifier = cw.train()
  File "./cvbayes.py", line 113, in train
    classifier.train(matrixData,matrixResp)
cv2.error: /build/buildd/opencv-2.3.1/modules/core/src/alloc.cpp:52: error: (-4) Failed to allocate 6794772480020 bytes in function OutOfMemoryError

我对Python很有经验，但对OpenCV还是个新手，所以我怀疑我错过了一些关键的预处理。在

我想使用它的图像示例在https://mocko.org.uk/choowoos/?m=20130515。我有大量可用的训练数据，但最初我只处理8张图片。在

有人能告诉我我做错了什么让普通的贝叶斯分类器爆炸吗？在

Answer 1

还有一件事需要注意，在最新的OpenCV版本中，您需要创建一个朴素的bayseianClassifier

import cv2

Classifier = cv2.ml.NormalBayesClassifier_create()

训练分类器如下，cv2。ml.ROW_样品指定如何构建数据矩阵，即按行或按列opencV

^{pr2}$

Answer 2

最终发现了问题-我错用了NormalBayesClassifier。它并不意味着要直接提供几十张高清图像：首先应该使用OpenCV的其他算法来获取这些图像。在

我最后做了以下事情： +将图像裁剪到可能包含对象的区域 +将图像转为灰度 +使用cv2.goodFeaturesToTrack（）从裁剪区域收集特征以训练分类器。在

有一小部分功能对我有用，也许是因为我直接裁剪了图像，幸运的是它包含了高对比度的对象，这些对象在一个类中变得模糊。在

以下代码可使95%的人群正确：

#!/usr/bin/env python
# -*- coding: utf-8 -*- 


import cv2
import sys, os.path, getopt
import numpy, random




def _usage():

    print
    print "cvbayes trainer"
    print
    print "Options:"
    print
    print "-m     ham=     path to dir of ham images"
    print "-s     spam=    path to dir of spam images"
    print "-h     help     this help text"
    print "-v     verbose  lots more output"
    print



def _parseOpts(argv):

    """
    Turn options + args into a dict of config we'll follow.  Merge in default conf.
    """

    try:
        opts, args = getopt.getopt(argv[1:], "hm:s:v", ["help", "ham=", 'spam=', 'verbose'])
    except getopt.GetoptError as err:
        print(err) # will print something like "option -a not recognized"
        _usage()
        sys.exit(2)

    optsDict = {}

    for o, a in opts:
        if o == "-v":
            optsDict['verbose'] = True
        elif o in ("-h", " help"):
            _usage()
            sys.exit()
        elif o in ("-m", " ham"):
            optsDict['ham'] = a
        elif o in ('-s', ' spam'):
            optsDict['spam'] = a
        else:
            assert False, "unhandled option"

    for mandatory_arg in ('ham', 'spam'):
        if mandatory_arg not in optsDict:
            print "Mandatory argument '%s' was missing; cannot continue" % mandatory_arg
            sys.exit(0)

    return optsDict     




class ClassifierWrapper(object):

    """
    Setup and encapsulate a naive bayes classifier based on OpenCV's 
    NormalBayesClassifier.  Presently we do not use it intelligently,
    instead feeding in flattened arrays of B&W pixels.
    """

    def __init__(self):
        super(ClassifierWrapper,self).__init__()
        self.classifier     = cv2.NormalBayesClassifier()
        self.data           = []
        self.responses      = []


    def _load_image_features(self, f):
        image_colour    = cv2.imread(f)
        image_crop      = image_colour[327:390, 784:926]        # Use the junction boxes, luke
        image_grey      = cv2.cvtColor(image_crop, cv2.COLOR_BGR2GRAY)
    features        = cv2.goodFeaturesToTrack(image_grey, 4, 0.02, 3)
        return features.flatten()


    def train_from_file(self, f, cl):
        features    = self._load_image_features(f)
        self.data.append(features)
        self.responses.append(cl)


    def train(self, update=False):
        matrix_data     = numpy.matrix( self.data ).astype('float32')
        matrix_resp     = numpy.matrix( self.responses ).astype('float32')
        self.classifier.train(matrix_data, matrix_resp, update=update)
        self.data       = []
        self.responses  = []


    def predict_from_file(self, f):
        features    = self._load_image_features(f)
        features_matrix = numpy.matrix( [ features ] ).astype('float32')
        retval, results = self.classifier.predict( features_matrix )
        return results




if __name__ == "__main__":

    opts = _parseOpts(sys.argv)

    cw = ClassifierWrapper()

    ham     = os.listdir(opts['ham'])
    spam    = os.listdir(opts['spam'])
    n_training_samples  = min( [len(ham),len(spam)])
    print "Will train on %d samples for equal sets" % n_training_samples

    for f in random.sample(ham, n_training_samples):
        img_path    = os.path.join(opts['ham'], f)
        print "ham: %s" % img_path
        cw.train_from_file(img_path, 2)

    for f in random.sample(spam, n_training_samples):
        img_path    = os.path.join(opts['spam'], f)
        print "spam: %s" % img_path
        cw.train_from_file(img_path, 1)

    cw.train()

    print
    print

    # spam dir much bigger so mostly unused, let's try predict() on all of it
    print "predicting on all spam..."
    n_wrong = 0
    n_files = len(os.listdir(opts['spam']))
    for f in os.listdir(opts['spam']):
        img_path    = os.path.join(opts['spam'], f)
        result = cw.predict_from_file(img_path)
        print "%s\t%s" % (result, img_path)
        if result[0][0] == 2:
            n_wrong += 1

    print
    print "got %d of %d wrong = %.1f%%" % (n_wrong, n_files, float(n_wrong)/n_files * 100, )

现在我用垃圾邮件的随机子集来训练它，只是因为它的数量要多得多，而且每个类的训练数据量应该大致相等。如果有更好的数据（例如，当光线不同时，总是包括黎明和黄昏的样本），它可能会更高。在

也许即使是NormalBayesClassifier也不适合这项工作，我应该在连续的帧中进行运动检测实验，但至少现在互联网上有一个例子值得我们去挑选。在

Answer 3

值得注意的是，它试图分配的内存量是（720*1280）^2*8。我想这可能就是它需要的内存量。在

我希望贝叶斯模型能够让您对train（）进行连续调用，所以请尝试缩小大小，然后一次对一个图像调用train（）？在