def run(self): # Data loading code print("Loading data") test_dir = self.config['Dataset']['TestPath'] pred_result_dir = os.path.join(test_dir, 'pred_result_info') utils.mkdir(pred_result_dir) dataset_test = torchvision.datasets.ImageFolder( test_dir, transforms.Compose([transforms.ToTensor()])) test_sampler = torch.utils.data.SequentialSampler(dataset_test) data_loader_test = torch.utils.data.DataLoader(dataset_test, batch_size=1, sampler=test_sampler, num_workers=1, pin_memory=True) print("Creating model") model = getModels(model_name=self.config['Model']['Name'], num_classes=self.config['Model']['NumClass']) model.to(self.device) checkpoint = torch.load(os.path.join( self.output_model_path, self.config['Misc']['BestModelName']), map_location='cpu') model.load_state_dict(checkpoint['model']) correct_1 = 0.0 model.eval() print(dataset_test.class_to_idx) with torch.no_grad(): for i, (image, label) in enumerate(data_loader_test): image = image.to(self.device, non_blocking=True) label = label.to(self.device, non_blocking=True) output = model(image) _, pred = output.topk(1, 1, largest=True, sorted=True) label = label.view(label.size(0), -1).expand_as(pred) correct = pred.eq(label) correct_1 += correct[:, :1].sum() for key in dataset_test.class_to_idx: if dataset_test.class_to_idx[key] == label: label_info = key if dataset_test.class_to_idx[key] == pred: pred_info = key src_img = cv2.imread(dataset_test.imgs[i][0], 1) cv2.putText(src_img, 'label: {}'.format(label_info), (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 1) cv2.putText(src_img, 'pred: {}'.format(pred_info), (20, 60), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 20), 1) if label_info != pred_info: shutil.move(dataset_test.imgs[i][0], pred_result_dir) # cv2.imwrite(os.path.join(pred_result_dir, '{}.png'.format(i)), src_img) cv2.imshow('img', src_img) cv2.waitKey(33) print("acc: ", correct_1 / len(data_loader_test.dataset))
def export_as_tf(): print "exporting" from keras import backend as K from keras.models import load_model autoencoder, encoder, decoder = getModels() autoencoder.load_weights(modelsPath + modelName) saver = tf.train.Saver() sess = K.get_session() save_path = saver.save(sess, "Models/tf_modi")
def testModel(stream_output=False): # Create models print("Creating Autoencoder, Encoder and Generator...") autoencoder, encoder, decoder = getModels() # Load Autoencoder weights print("Loading weights...") autoencoder.load_weights(modelsPath + modelName) # Load dataset to test print("Loading dataset...") if "aug" in modelName: X_train, X_test, Y_train = loadDatasetAugmented(imSize) else: X_train, X_test, Y_train = loadDatasetLabelled(imSize) name_list = np.unique(Y_train) print(X_train.shape) # print(name_list) # Visualization functions #visualizeReconstructedImages(X_train[:180],X_test[:20], autoencoder) # computeTSNEProjectionOfPixelSpace(X_test[:1000], display=True) # computeTSNEProjectionOfLatentSpace(X_train[:1000], encoder, display=True) lkst = likeliest scrub = 0 seed = (id * 20) + gesture_selection[likeliest] # seed = (id*20) + (likeliest*4) scrub_destination = seed + 4 name = Y_train[seed] ri = getInterpolatedFrames(X_train[randint(0, X_train.shape[0])], X_train[randint(0, X_train.shape[0])], encoder, decoder, save=False, nbSteps=nsteps) # ri = getInterpolatedFrames(X_train[seed], X_train[scrub_destination], encoder, decoder, save=False, nbSteps=nsteps) # return while likeliest == lkst: osc_server.recv(10) if (smudge_enabled): if (scrub_input.shape[0] > 0): frame_buffer = [ri[sc] for sc in scrub_input] img_out = layer_images(frame_buffer, smudge_amt) else: continue else: img_out = ri[int(math.floor(scrub_position * (nsteps - 1)))] if (stream_output): png_bytes = pyImageStreamer.get_jpeg_image_bytes(img_out) if len(cl) > 0: cl[-1].write_message(png_bytes, binary=True) else: cv2.imshow('Moving_Digits', img_out) cv2.waitKey(2) if cv2.waitKey(1) & 0xFF == ord('q'): return testModel(stream_output)
def testModel(): # Create models print("Creating Autoencoder, Encoder and Generator...") autoencoder, encoder, decoder = getModels() # Load Autoencoder weights print("Loading weights...") autoencoder.load_weights(modelsPath + modelName) # Load dataset to test print("Loading dataset...") X_train, X_test = loadDataset() # Visualization functions visualizeReconstructedImages(X_train[:16], X_test[:16], autoencoder, save=True)
def testModel(): # Create models print("Creating Autoencoder, Encoder and Generator...") autoencoder, encoder, decoder = getModels() # Load Autoencoder weights print("Loading weights...") autoencoder.load_weights(modelsPath+modelName) # Load dataset to test print("Loading dataset...") X_train, X_test = loadDataset() # Visualization functions #visualizeReconstructedImages(X_train[:16],X_test[:16], autoencoder) # computeTSNEProjectionOfPixelSpace(X_test[:1000], display=True) # computeTSNEProjectionOfLatentSpace(X_test[:1000], encoder, display=True) # while 1: visualizeInterpolation(X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], encoder, decoder, save=False, nbSteps=5) while 1 :visualizeArithmetics(X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], X_test[randint(0,X_test.shape[0])], encoder, decoder)
def __init__(self): # 加载配置文件 self.config = utils.loadYaml('../config/config.yaml') # 训练结果保存路径 self.output_model_path = os.path.join('../output/', self.config['Misc']['OutputFolderName']) # gpu使用 self.device = utils.set_gpu(self.config) self.img_shape = (256, 256) self.overlap_piexl = 200 self.imgs_index_dict, self.rois_start_xy_index_dict, self.rois_xyxy_index_dict = self.getRefInfo( ref_img_path='/home/pi/Desktop/df1b_dataset/20191024/ref_deploy') print(self.imgs_index_dict) print("Creating model") self.model = getModels(model_name=self.config['Model']['Name'], num_classes=self.config['Model']['NumClass']).to(self.device) checkpoint = torch.load(os.path.join(self.output_model_path, self.config['Misc']['BestModelName']), map_location='cpu') self.model.load_state_dict(checkpoint['model']) self.model.eval()
def trainModel(startEpoch=0): # Create models print("Creating Autoencoder...") autoencoder, _, _ = getModels() autoencoder.compile(optimizer=RMSprop(lr=0.00025), loss="mse") # From which we start if startEpoch > 0: # Load Autoencoder weights print("Loading weights...") autoencoder.load_weights(modelsPath + modelName) print("Loading dataset...") X_train, X_test = loadDataset() # Compute number of batches nbBatch = int(X_train.shape[0] / batchSize) # Train the Autoencoder on dataset print( "Training Autoencoder for {} epochs with {} batches per epoch and {} samples per batch." .format(nbEpoch, nbBatch, batchSize)) print("Run id: {}".format(runID)) # Debug utils writer writer = tf.summary.FileWriter("/tmp/logs/" + runID) batchTimes = [0. for i in range(5)] # For each epoch for epoch in range(startEpoch, nbEpoch): # For each batch for batchIndex in range(nbBatch): batchStartTime = time.time() # Get batch X = X_train[batchIndex * batchSize:(batchIndex + 1) * batchSize] # Train on batch autoencoderLoss = autoencoder.train_on_batch(X, X) trainingSummary = tf.Summary.Value( tag="Loss", simple_value=float(autoencoderLoss)) # Compute ETA batchTime = time.time() - batchStartTime batchTimes = batchTimes[1:] + [batchTime] eta = getETA( sum(batchTimes) / len(batchTimes), nbBatch, batchIndex, nbEpoch, epoch) # Save reconstructions on train/test samples if batchIndex % 2 == 0: visualizeReconstructedImages(X_train[:16], X_test[:16], autoencoder, save=True, label="{}_{}".format( epoch, batchIndex)) # Validation & Tensorboard Debug if batchIndex % 20 == 0: validationLoss = autoencoder.evaluate(X_test[:512], X_test[:512], batch_size=256, verbose=0) validationSummary = tf.Summary.Value( tag="Validation Loss", simple_value=float(validationLoss)) summary = tf.Summary( value=[trainingSummary, validationSummary]) print( "Epoch {}/{} - Batch {}/{} - Loss: {:.3f}/{:.3f} - ETA:". format(epoch + 1, nbEpoch, batchIndex + 1, nbBatch, autoencoderLoss, validationLoss), eta) else: print( "Epoch {}/{} - Batch {}/{} - Loss: {:.3f} - ETA:".format( epoch + 1, nbEpoch, batchIndex + 1, nbBatch, autoencoderLoss), eta) summary = tf.Summary(value=[ trainingSummary, ]) writer.add_summary(summary, epoch * nbBatch + batchIndex) #Save model every epoch print("Saving autoencoder...") autoencoder.save_weights(modelsPath + modelName, overwrite=True)
def run(self): dataset = Datalayer(self.config, transform=tf.Compose([ tf.ToTensor(), ])) data_loader = DataLoader( dataset=dataset, shuffle=True, batch_size=self.config['Dataset']['BatchSize'], num_workers=self.config['Dataset']['NumWorkers'], pin_memory=True) # 创建模型 model = getModels(self.config['Model']['Name'], num_classes=self.config['Model']['NumClass'], pretrained=self.config['Model']['IsPretrained']).to( self.device) # 创建损失函数 criterion = getLossFuns() # 创建优化器 optimizer = make_optimizer(cfg=self.config, model=model) lr_scheduler = GeneralLR_Scheduler(optimizer, self.config, max_iter=len(data_loader) * self.config['Dataset']['Epochs']) start_epoch = 0 # 恢复训练 if self.config['Model']['IsResume']: checkpoint = torch.load(os.path.join( self.output_model_path, self.config['Misc']['BestModelName']), map_location='cpu') model.load_state_dict(checkpoint['model']) optimizer.load_state_dict(checkpoint['optimizer']) lr_scheduler.load_state_dict(checkpoint['lr_scheduler']) start_epoch = checkpoint['epoch'] + 1 # 开始训练 print("Start training") for epoch in range(start_epoch, self.config['Dataset']['Epochs']): self.train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader, self.device, epoch, print_freq=10) if self.output_model_path: checkpoint = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'lr_scheduler': lr_scheduler.state_dict(), 'epoch': epoch } utils.save_on_master( checkpoint, os.path.join(self.output_model_path, self.config['Misc']['BestModelName'])) if epoch % self.config['Model']['OutputFreq'] == 0: utils.save_on_master( checkpoint, os.path.join(self.output_model_path, 'model_{}.pth'.format(epoch)))