def main(): args = parse_args() cuda = torch.cuda.is_available() and args.cuda torch.set_default_tensor_type( torch.cuda.FloatTensor if cuda else torch.FloatTensor) device = torch.device('cuda' if cuda else 'cpu') print("Using %s for training" % ('GPU' if cuda else 'CPU')) print('Loading dataset...', end='', flush=True) metadata, vocab, train_iter, val_iter, test_iter = dataset_factory( args, device) print('Done.') print('Saving vocab and args...', end='') save_vocab(vocab, args.save_path + os.path.sep + 'vocab') save_object(args, args.save_path + os.path.sep + 'args') print('Done') model = train_model_factory(args, metadata) if cuda and args.multi_gpu: model = nn.DataParallel( model, dim=1) # if we were using batch_first we'd have to use dim=0 print(model) # print models summary optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, amsgrad=True) try: best_val_loss = None for epoch in range(args.max_epochs): start = datetime.now() # calculate train and val loss train_loss = train(model, optimizer, train_iter, metadata, args.gradient_clip) val_loss = evaluate(model, val_iter, metadata) print("[Epoch=%d/%d] train_loss %f - val_loss %f time=%s " % (epoch + 1, args.max_epochs, train_loss, val_loss, datetime.now() - start), end='') # save models if models achieved best val loss (or save every epoch is selected) if args.save_every_epoch or not best_val_loss or val_loss < best_val_loss: print('(Saving model...', end='') save_model(args.save_path, model, epoch + 1, train_loss, val_loss) print('Done)', end='') best_val_loss = val_loss print() except (KeyboardInterrupt, BrokenPipeError): print('[Ctrl-C] Training stopped.') test_loss = evaluate(model, test_iter, metadata) print("Test loss %f" % test_loss)
def get_model(numeric_dataset, model_filename=None): feature = ChainOperator(Resize((128,128)), SpatialHistogram()) #feature = ChainOperator(Resize((128,128)), Fisherfaces()) classifier = NearestNeighbor(dist_metric=NormalizedCorrelation(), k=1) print "kjasnanscal" #classifier = NearestNeighbor(dist_metric=EuclideanDistance(), k=1) inner_model = PredictableModel(feature=feature, classifier=classifier) model = PredictableModelWrapper(inner_model) model.set_data(numeric_dataset) model.compute() if not model_filename is None: save_model(model_filename, model) return model
def run_rec(): # This is where we write the images, if an output_dir is given # in command line: out_dir = None # Now read in the image data. This must be a valid path! [X, y] = read_images('images') # 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 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="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() im = Image.open('search.png') im = im.convert("L") predicted_label = model.predict(im)[0] print(predicted_label) return predicted_label
def run_rec(): # This is where we write the images, if an output_dir is given # in command line: out_dir = None # Now read in the image data. This must be a valid path! [X,y] = read_images('images') # 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 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="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() im = Image.open('search.png') im = im.convert("L") predicted_label = model.predict(im)[0] print(predicted_label) return predicted_label
# 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 = SpatialHistogram() #feature = Fisherfaces() # Define a 1-NN classifier with Euclidean Distance: classifier = NearestNeighbor(dist_metric=NormalizedCorrelation(), k=1) #classifier = SVM() # 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('modelTry.pkl', my_model) model = load_model('modelTry.pkl') # Then turn the first (at most) 16 eigenvectors into grayscale # images (note: eigenvectors are stored by column!) E = [] #for i in range(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()
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 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="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: