def grid_search(model, X, y, C_range=(-5, 15, 2), gamma_range=(3, -15, -2), k=5, num_cores=1): if not isinstance(model, PredictableModel): raise TypeError( "GridSearch expects a PredictableModel. If you want to perform optimization on raw data use facerec.feature.Identity to pass unpreprocessed data!" ) if not isinstance(model.classifier, SVM): raise TypeError( "GridSearch expects a SVM as classifier. Please use a facerec.classifier.SVM!" ) logger = logging.getLogger("facerec.svm.gridsearch") logger.info("Performing a Grid Search.") # best parameter combination to return best_parameter = svm_parameter("-q") best_parameter.kernel_type = model.classifier.param.kernel_type best_parameter.nu = model.classifier.param.nu best_parameter.coef0 = model.classifier.param.coef0 # either no gamma given or kernel is linear (only C to optimize) if (gamma_range is None) or (model.classifier.param.kernel_type == LINEAR): gamma_range = (0, 0, 1) # best validation error so far best_accuracy = np.finfo('float').min # create grid (cartesian product of ranges) g = grid([C_range, gamma_range]) results = [] for p in g: C, gamma = p C, gamma = 2**C, 2**gamma model.classifier.param.C, model.classifier.param.gamma = C, gamma # perform a k-fold cross validation cv = KFoldCrossValidation(model=model, k=k) cv.validate(X, y) # append parameter into list with accuracies for all parameter combinations results.append([C, gamma, cv.accuracy]) # store best parameter combination if cv.accuracy > best_accuracy: logger.info("best_accuracy=%s" % (cv.accuracy)) best_accuracy = cv.accuracy best_parameter.C, best_parameter.gamma = C, gamma logger.info("%d-CV Result = %.2f." % (k, cv.accuracy)) # set best parameter combination to best found return best_parameter, results
def entrenarModelo(dirImagenes = None, arcModelo = arcModelo): if dirImagenes is None: print dirImagenes return 0 [X,y,clases] = read_images(sys.argv[2]) modelo = PredictableModel(feature=Fisherfaces(), classifier=NearestNeighbor(dist_metric=EuclideanDistance(), k=1)) #configuración del modelo modelo.compute(X, y) pkl = open(arcModelo, 'wb') cPickle.dump([modelo,clases,tamanioCara],pkl) #se usa cPickle directamente en vez de save_model para poder insertar metadata pkl.close() validacion = KFoldCrossValidation(modelo, k=10) validacion.validate(X, y) validacion.print_results()
def grid_search(model, X, y, C_range=(-5, 15, 2), gamma_range=(3, -15, -2), k=5, num_cores=1): if not isinstance(model, PredictableModel): raise TypeError( "GridSearch expects a PredictableModel. If you want to perform optimization on raw data use facerec.feature.Identity to pass unpreprocessed data!" ) if not isinstance(model.classifier, SVM): raise TypeError("GridSearch expects a SVM as classifier. Please use a facerec.classifier.SVM!") logger = logging.getLogger("facerec.svm.gridsearch") logger.info("Performing a Grid Search.") # best parameter combination to return best_parameter = svm_parameter("-q") best_parameter.kernel_type = model.classifier.param.kernel_type best_parameter.nu = model.classifier.param.nu best_parameter.coef0 = model.classifier.param.coef0 # either no gamma given or kernel is linear (only C to optimize) if (gamma_range is None) or (model.classifier.param.kernel_type == LINEAR): gamma_range = (0, 0, 1) # best validation error so far best_accuracy = np.finfo("float").min # create grid (cartesian product of ranges) g = grid([C_range, gamma_range]) results = [] for p in g: C, gamma = p C, gamma = 2 ** C, 2 ** gamma model.classifier.param.C, model.classifier.param.gamma = C, gamma # perform a k-fold cross validation cv = KFoldCrossValidation(model=model, k=k) cv.validate(X, y) # append parameter into list with accuracies for all parameter combinations results.append([C, gamma, cv.accuracy]) # store best parameter combination if cv.accuracy > best_accuracy: logger.info("best_accuracy=%s" % (cv.accuracy)) best_accuracy = cv.accuracy best_parameter.C, best_parameter.gamma = C, gamma logger.info("%d-CV Result = %.2f." % (k, cv.accuracy)) # set best parameter combination to best found return best_parameter, results
def train(train_path): # Now read in the image data. This must be a valid path! [X, y, class_names] = read_images(train_path) print X, y, class_names # Then set up a handler for logging: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:, i].reshape(X[0].shape) E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) # Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(X, y) # And print the result: cv.print_results() save_model('model.pkl', model, class_names) return [model, class_names]
def train(train_path): # Now read in the image data. This must be a valid path! [X,y,class_names] = read_images(train_path) print X,y,class_names # Then set up a handler for logging: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:,i].reshape(X[0].shape) E.append(minmax_normalize(e,0,255, dtype=np.uint8)) # Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(X, y) # And print the result: cv.print_results() save_model('model.pkl', model, class_names) return [model,class_names]
handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = SVM() # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute a model: model.compute(X, y) # Save the Model using joblib: save_model('model.pkl', model) # Perform a Grid Search for the Set of Parameters: tuned_parameters = [{ 'kernel': ['rbf'], 'gamma': [1e-3, 1e-4], 'C': [1, 10, 100, 1000] }, { 'kernel': ['linear'], 'C': [1, 10, 100, 1000] }] # Find a good set of parameters: grid_search(model, X, y, tuned_parameters) # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(X, y) # And print the result: cv.print_results()
[X,y] = read_images(sys.argv[1]) # Then set up a handler for logging: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Define the Fisherfaces as Feature Extraction method: feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): model.compute(X, y) # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:,i].reshape(X[0].shape) E.append(minmax_normalize(e,0,255, dtype=np.uint8)) # Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.png") # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(X, y) # And print the result: print cv
subject_names=subject_dictionary) if options.numfolds: print "Validating model with %s folds..." % options.numfolds handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) crossval = KFoldCrossValidation(model, k=options.numfolds) crossval.validate(images, labels) crossval.print_results() print "Computing the model..." model.compute(images, labels) print "Saving the model..." save_model(model_filename, model) else: print "Loading the model..." model = load_model(model_filename) if not isinstance(model, ExtendedPredictableModel): print "[Error] The given model is not of type '%s'." % "ExtendedPredictableModel" sys.exit()
# load a dataset random.seed() dataSet = DataSet("/Users/gsj987/Desktop/毕设资料/faces_girls") #dataSet.shuffle() #idx = np.argsort([random.random() for i in xrange(len(dataSet.labels))]) #dataSet.labels = dataSet.labels[idx] for ind in range(20, 400, 20): # define a 1-NN classifier with Euclidean Distance classifier = SVM(svm_parameter("-t 1 -c 1 -g 1 -r 262144 -q")) # define Fisherfaces as feature extraction method feature = ChainOperator(HistogramEqualization(), PCA(ind)) #print feature.compute(dataSet.data, dataSet.labels) # now stuff them into a PredictableModel model = PredictableModel(feature=feature, classifier=classifier) # show fisherfaces model.compute(dataSet.data,dataSet.labels) #print model.feature.model2.eigenvectors.shape, dataSet.data #es = model.feature.model2.eigenvectors #img = smp.toimage(np.dot(es,dd[0]).reshape(120,120)) #img.save("pca100.jpg") #plot_eigenvectors(model.feature.model2.eigenvectors, 9, sz=dataSet.data[0].shape, filename=None) # perform a 5-fold cross validation cv = KFoldCrossValidation(model, 5) cv.validate(dataSet.data, dataSet.labels) print ind,cv.tp, cv.fp, "%.4f" %(cv.tp/(cv.tp+cv.fp+0.0001))
# the Detection & Recognition part starts: if options.numfolds: print "Validating model with %s folds..." % options.numfolds # We want to have some log output, so set up a new logging handler # and point it to stdout: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add a handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Perform the validation & print results: crossval = KFoldCrossValidation(model, k=options.numfolds) crossval.validate(images, labels) crossval.print_results() # Compute the model: print "Computing the model..." model.compute(images, labels) # And save the model, which uses Pythons pickle module: print "Saving the model..." save_model(model_filename, model) else: print "Loading the model..." model = load_model(model_filename) # We operate on an ExtendedPredictableModel. Quit the application if this # isn't what we expect it to be: if not isinstance(model, ExtendedPredictableModel): print "[Error] The given model is not of type '%s'." % "ExtendedPredictableModel" sys.exit()
def Init(self): from optparse import OptionParser # model.pkl is a pickled (hopefully trained) PredictableModel, which is # used to make predictions. You can learn a model yourself by passing the # parameter -d (or --dataset) to learn the model from a given dataset. usage = "usage: %prog [options] model_filename" # Add options for training, resizing, validation and setting the camera id: parser = OptionParser(usage=usage) parser.add_option( "-r", "--resize", action="store", type="string", dest="size", default="100x100", help= "Resizes the given dataset to a given size in format [width]x[height] (default: 100x100)." ) parser.add_option( "-v", "--validate", action="store", dest="numfolds", type="int", default=None, help= "Performs a k-fold cross validation on the dataset, if given (default: None)." ) parser.add_option("-t", "--train", action="store", dest="dataset", type="string", default=None, help="Trains the model on the given dataset.") parser.add_option("-i", "--id", action="store", dest="camera_id", type="int", default=0, help="Sets the Camera Id to be used (default: 0).") parser.add_option( "-c", "--cascade", action="store", dest="cascade_filename", default="haarcascade_frontalface_default.xml", help= "Sets the path to the Haar Cascade used for the face detection part (default: haarcascade_frontalface_alt2.xml)." ) # Show the options to the user: parser.print_help() print "Press [ESC] to exit the program!" print "Script output:" # Parse arguments: (options, args) = parser.parse_args() print(options, args) # Check if a model name was passed: my_model = 'my_model.pk' ''' if len(args) == 0: print "[Error] No prediction model was given." sys.exit() ''' # This model will be used (or created if the training parameter (-t, --train) exists: #model_filename = args[0] model_filename = my_model options.dataset = 'faces' # Check if the given model exists, if no dataset was passed: if (options.dataset is None) and (not os.path.exists(model_filename)): print "[Error] No prediction model found at '%s'." % model_filename sys.exit() # Check if the given (or default) cascade file exists: if not os.path.exists(options.cascade_filename): print "[Error] No Cascade File found at '%s'." % options.cascade_filename sys.exit() # We are resizing the images to a fixed size, as this is neccessary for some of # the algorithms, some algorithms like LBPH don't have this requirement. To # prevent problems from popping up, we resize them with a default value if none # was given: try: image_size = (int(options.size.split("x")[0]), int(options.size.split("x")[1])) except: print "[Error] Unable to parse the given image size '%s'. Please pass it in the format [width]x[height]!" % options.size sys.exit() # We have got a dataset to learn a new model from: if options.dataset: print('data set') print(options.dataset) # Check if the given dataset exists: if not os.path.exists(options.dataset): print "[Error] No dataset found at '%s'." % dataset_path sys.exit() # Reads the images, labels and folder_names from a given dataset. Images # are resized to given size on the fly: print "Loading dataset..." [images, labels, subject_names] = read_images(options.dataset, image_size) # Zip us a {label, name} dict from the given data: list_of_labels = list(xrange(max(labels) + 1)) subject_dictionary = dict(zip(list_of_labels, subject_names)) # Get the model we want to compute: model = get_model(image_size=image_size, subject_names=subject_dictionary) # Sometimes you want to know how good the model may perform on the data # given, the script allows you to perform a k-fold Cross Validation before # the Detection & Recognition part starts: if options.numfolds: print "Validating model with %s folds..." % options.numfolds # We want to have some log output, so set up a new logging handler # and point it to stdout: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add a handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Perform the validation & print results: crossval = KFoldCrossValidation(model, k=options.numfolds) crossval.validate(images, labels) crossval.print_results() # Compute the model: print "Computing the model..." model.compute(images, labels) # And save the model, which uses Pythons pickle module: print "Saving the model..." save_model(model_filename, model) else: print "Loading the model..." model = load_model(model_filename) # We operate on an ExtendedPredictableModel. Quit the application if this # isn't what we expect it to be: if not isinstance(model, ExtendedPredictableModel): print "[Error] The given model is not of type '%s'." % "ExtendedPredictableModel" sys.exit() # Now it's time to finally start the Application! It simply get's the model # and the image size the incoming webcam or video images are resized to: print "Starting application..." self.__faceRecognizer = recognizer( model=model, camera_id=options.camera_id, cascade_filename=options.cascade_filename)
for w in [8]: for r in range(1,2): #convert_table = RadiusInvariantUniformLBP.build_convert_table(w) #lbp_operator = RadiusInvariantUniformLBP(r,w) for s in range(8,9): #classifier = SVM(svm_parameter('-t 1 -c 2 -g 2 -r 262144 -q')) classifier = AdaBoost(NearestNeighbor(EuclideanDistance(),10), 50) # define Fisherfaces as feature extraction method #feature = ChainOperator(HistogramEqualization(), LBP(sz=(s,s))) model1 = MulitiScalesLBP(sz=(s,s)) data1 = model1.compute(dataSet.data, dataSet.labels) feature = PCA(200) #feature = ChainOperator(model1, model2) # now stuff them into a PredictableModel model = PredictableModel(feature=feature, classifier=classifier) # show fisherfaces model.compute(data1,dataSet.labels) #print model.feature.model2.eigenvectors.shape, dataSet.data #es = model.feature.model2.eigenvectors #plot_eigenvectors(model.feature, 9, sz=dataSet.data[0].shape, filename=None) # perform a 5-fold cross validation cv = KFoldCrossValidation(model, 5) cv.validate(data1, dataSet.labels) print s, r, w,cv.tp, cv.fp, "%.4f" %(cv.tp/(cv.tp+cv.fp+0.001))
logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) dataSet = DataSet("/home/philipp/facerec/data/yalefaces_recognition") feature = Fisherfaces() classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) model = PredictableModel(feature=feature, classifier=classifier) model.compute(dataSet.data, dataSet.labels) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:, i].reshape(dataSet.data[0].shape) E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) subplot(title="Fisherfaces", images=E, rows=4, cols=4, sptitle="Fisherface", colormap=cm.jet, filename="fisherfaces.pdf") cv = KFoldCrossValidation(model, k=10) cv.validate(dataSet.data, dataSet.labels) cv.print_results()
def start(): from optparse import OptionParser # model.pkl is a pickled (hopefully trained) PredictableModel, which is # used to make predictions. You can learn a model yourself by passing the # parameter -d (or --dataset) to learn the model from a given dataset. usage = "usage: %prog [options] model_filename" # Add options for training, resizing, validation and setting the camera id: parser = OptionParser(usage=usage) parser.add_option("-r", "--resize", action="store", type="string", dest="size", default="100x100", help="Resizes the given dataset to a given size in format [width]x[height] (default: 100x100).") parser.add_option("-v", "--validate", action="store", dest="numfolds", type="int", default=None, help="Performs a k-fold cross validation on the dataset, if given (default: None).") parser.add_option("-t", "--train", action="store", dest="dataset", type="string", default=None, help="Trains the model on the given dataset.") parser.add_option("-i", "--id", action="store", dest="camera_id", type="int", default=0, help="Sets the Camera Id to be used (default: 0).") parser.add_option("-c", "--cascade", action="store", dest="cascade_filename", default="haarcascade_frontalface_alt2.xml", help="Sets the path to the Haar Cascade used for the face detection part (default: haarcascade_frontalface_alt2.xml).") # Show the options to the user: parser.print_help() print "Press [ESC] to exit the program!" print "Script output:" # Parse arguments: (options, args) = parser.parse_args() # Check if a model name was passed: dataset = "C:\\Users\\newbie\\PycharmProjects\\duinobot\\scripts\\test" cascade_filename = "C:\\Users\\newbie\\PycharmProjects\\duinobot\\scripts\\haarcascade_frontalface_alt2.xml" if len(args) == 0: print "[Error] No prediction model was given." sys.exit() # This model will be used (or created if the training parameter (-t, --train) exists: model_filename = args[0] # Check if the given model exists, if no dataset was passed: if (dataset is None) and (not os.path.exists(model_filename)): print "[Error] No prediction model found at '%s'." % model_filename sys.exit() # Check if the given (or default) cascade file exists: if not os.path.exists(cascade_filename): print "[Error] No Cascade File found at '%s'." % cascade_filename sys.exit() # We are resizing the images to a fixed size, as this is neccessary for some of # the algorithms, some algorithms like LBPH don't have this requirement. To # prevent problems from popping up, we resize them with a default value if none # was given: try: image_size = (int(options.size.split("x")[0]), int(options.size.split("x")[1])) except: print "[Error] Unable to parse the given image size '%s'. Please pass it in the format [width]x[height]!" % options.size sys.exit() # We have got a dataset to learn a new model from: if dataset: # Check if the given dataset exists: if not os.path.exists(dataset): print "[Error] No dataset found at '%s'." % dataset_path sys.exit() # Reads the images, labels and folder_names from a given dataset. Images # are resized to given size on the fly: print "Loading dataset..." [images, labels, subject_names] = read_images(dataset, image_size) # Zip us a {label, name} dict from the given data: list_of_labels = list(xrange(max(labels) + 1)) subject_dictionary = dict(zip(list_of_labels, subject_names)) # Get the model we want to compute: model = get_model(image_size=image_size, subject_names=subject_dictionary) # Sometimes you want to know how good the model may perform on the data # given, the script allows you to perform a k-fold Cross Validation before # the Detection & Recognition part starts: if options.numfolds: print "Validating model with %s folds..." % options.numfolds # We want to have some log output, so set up a new logging handler # and point it to stdout: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) # Add a handler to facerec modules, so we see what's going on inside: logger = logging.getLogger("facerec") logger.addHandler(handler) logger.setLevel(logging.DEBUG) # Perform the validation & print results: crossval = KFoldCrossValidation(model, k=options.numfolds) crossval.validate(images, labels) crossval.print_results() # Compute the model: print "Computing the model..." model.compute(images, labels) # And save the model, which uses Pythons pickle module: print "Saving the model..." save_model(model_filename, model) else: print "Loading the model..." model = load_model(model_filename) # We operate on an ExtendedPredictableModel. Quit the application if this # isn't what we expect it to be: if not isinstance(model, ExtendedPredictableModel): print "[Error] The given model is not of type '%s'." % "ExtendedPredictableModel" sys.exit() # Now it's time to finally start the Application! It simply get's the model # and the image size the incoming webcam or video images are resized to: print "Starting application..." App(model=model, camera_id=options.camera_id, cascade_filename=cascade_filename).run()
feature = PCA() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) # Define the model as the combination my_model = PredictableModel(feature=feature, classifier=classifier) # Compute the Fisherfaces on the given data (in X) and labels (in y): my_model.compute(X, y) # We then save the model, which uses Pythons pickle module: save_model('model.pkl', my_model) model = load_model('model.pkl') # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] for i in xrange(min(model.feature.eigenvectors.shape[1], 16)): e = model.feature.eigenvectors[:, i].reshape(X[0].shape) E.append(minmax_normalize(e, 0, 255, dtype=np.uint8)) # Plot them and store the plot to "python_fisherfaces_fisherfaces.pdf" subplot(title="PCA", images=E, rows=4, cols=4, sptitle="PCA", colormap=cm.jet, filename="pca_%s.png" % sys.argv[2]) # Perform a 10-fold cross validation cv = KFoldCrossValidation(model, k=10) cv.validate(Tx, ty) # cv.validate(X, y) # And print the result: cv.print_results()