def __init__(self, options, mode): self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.validationdataset_ori = LipreadingDataset( options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.validationdataset = LipreadingDataset_val( options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.tot_data = len(self.validationdataset) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=False, num_workers=options["input"]["numworkers"], drop_last=False) self.mode = mode self.video_dist_label = convert_task3_label_to_video_label() self.average_IOU = 0 self.video_id_cnt = 0 self.time0 = time.time()
def __init__(self, args): augment = False shuffle = False self.channel = args.channel self.batchsize = args.batch_size self.validationdataset = LipreadingDataset(args.dataset, "val", augment=augment, channel=self.channel) self.validationdataloader = DataLoader(self.validationdataset, batch_size=self.batchsize, shuffle=shuffle, num_workers=args.workers, drop_last=True) # self.usecudnn = options["general"]["usecudnn"] self.statsfrequency = args.statsfrequency # self.gpuid = options["general"]["gpuid"] self.log_file = args.logfile self.savedir = args.save_dir self.num_batches = int(len(self.validationdataset) / self.batchsize) self.num_samples = int(len(self.validationdataset)) self.num_frames = args.num_frames self.modelname = args.modelname print_log('loaded validation dataset with %d data' % len(self.validationdataset), log=self.log_file)
def __init__(self, options): self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.statsfrequency = options["training"]["statsfrequency"] self.learningrate = options["training"]["learningrate"] self.modelType = options["training"]["learningrate"] self.weightdecay = options["training"]["weightdecay"] self.momentum = options["training"]["momentum"] self.save_prefix = options["training"]["save_prefix"] self.trainingdataset = LipreadingDataset( options["training"]["data_root"], options["training"]["index_root"], options["training"]["padding"], True) self.trainingdataloader = DataLoader( self.trainingdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=True)
def __init__(self, args): augment = True shuffle = True self.channel = args.channel self.batchsize = args.batch_size self.trainingdataset = LipreadingDataset(args.dataset, "train", augment=augment, channel=self.channel) self.trainingdataloader = DataLoader(self.trainingdataset, batch_size=self.batchsize, shuffle=shuffle, num_workers=args.workers, drop_last=True) # self.usecudnn = options["general"]["usecudnn"] self.statsfrequency = args.statsfrequency # self.gpuid = options["general"]["gpuid"] self.learningrate = args.lr self.weightdecay = args.weight_decay self.momentum = args.momentum self.log_file = args.logfile self.modelsavedir = args.save_dir # _, self.savename, _ = fileparts(self.modelsavedir) self.num_batches = int(len(self.trainingdataset) / self.batchsize) self.num_samples = int(len(self.trainingdataset)) self.num_frames = args.num_frames self.modelname = args.modelname print_log('loaded training dataset with %d data' % len(self.trainingdataset), log=self.log_file) if augment: print_log('using augmentation', log=self.log_file) else: print_log('no data augmentation', log=self.log_file)
def __init__(self, options, mode): self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.validationdataset = LipreadingDataset(options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.tot_data = len(self.validationdataset) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=False) self.mode = mode
def __init__(self, options): self.dataset = LipreadingDataset(options['validation']['data_path'], "val", False, options['model']['landmark']) self.dataloader = DataLoader( self.dataset, batch_size=options["input"]["batch_size"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["num_worker"], drop_last=True ) self.batch_size = options["input"]["batch_size"]
def __init__(self, options, save_dir): self.validationdataset = LipreadingDataset( options["validation"]["dataset"], "val", augment=False, use_frames=options['training']['use_frames']) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=True) self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.save_dir = save_dir
def __init__(self, options): self.validationdataset = LipreadingDataset( "/udisk/pszts-ssd/AV-ASR-data/BBC_Oxford/lipread_mp4", "val", False) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=True) self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.statsfrequency = options["training"]["statsfrequency"] self.gpuid = options["general"]["gpuid"]
def __init__(self, options): self.batchsize = options["input"]["batchsize"] self.validationdataset = LipreadingDataset( options["general"]["dataset"], "val", False) self.validationdataloader = DataLoader( self.validationdataset, batch_size=self.batchsize, shuffle=False, num_workers=options["input"]["numworkers"], drop_last=True) self.usecudnn = options["general"]["usecudnn"] self.statsfrequency = options["training"]["statsfrequency"] self.gpuid = options["general"]["gpuid"] self.log_file = options["general"]["logfile"] self.savedir = options["general"]["modelsavedir"] self.num_batches = int(len(self.validationdataset) / self.batchsize) print_log('loaded validation dataset with %d data' % len(self.validationdataset), log=self.log_file)
def __init__(self, options): self.batchsize = options["input"]["batchsize"] self.trainingdataset = LipreadingDataset(options["general"]["dataset"], "train") self.trainingdataloader = DataLoader( self.trainingdataset, batch_size=self.batchsize, shuffle=options["training"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=True) self.usecudnn = options["general"]["usecudnn"] self.statsfrequency = options["training"]["statsfrequency"] self.gpuid = options["general"]["gpuid"] self.learningrate = options["training"]["learningrate"] # self.modelType = options["training"]["learningrate"] self.weightdecay = options["training"]["weightdecay"] self.momentum = options["training"]["momentum"] self.log_file = options["general"]["logfile"] self.modelsavedir = options["general"]["modelsavedir"] _, self.time_str, _ = fileparts(self.modelsavedir) print_log('loaded training dataset with %d data' % len(self.trainingdataset), log=options["general"]["logfile"])
def __init__(self, options): self.trainingdataset = LipreadingDataset(options["training"]["dataset"], "train", use_frames=options['training']['use_frames']) self.trainingdataloader = DataLoader( self.trainingdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=True ) if len(self.trainingdataset) == 0: print("WARN: no data for training", file=sys.stderr) self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.learningrate = options["training"]["learningrate"] self.modelType = options["training"]["learningrate"] self.weightdecay = options["training"]["weightdecay"] self.momentum = options["training"]["momentum"]
class Validator(): def __init__(self, options, mode): self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.validationdataset = LipreadingDataset(options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.tot_data = len(self.validationdataset) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["numworkers"], drop_last=False) self.mode = mode def __call__(self, model): with torch.no_grad(): print("Starting {}...".format(self.mode)) count = np.zeros((len(self.validationdataset.pinyins))) # print (len(self.validationdataset.pinyins)) # assert (0) validator_function = model.validator_function() model.eval() # if(self.usecudnn): # net = nn.DataParallel(model).cuda() net = model.cuda() num_samples = 0 self.pinyins = self.validationdataset.get_pinyins() #print (self.pinyins) cnt = 0 pinyin_lengh = [] for pinyin in self.pinyins: cnt = cnt + 1 #print (pinyin) pinyin_lengh.append(len(pinyin.split(" "))) #print (len(pinyin.split(" "))) # if cnt > 5: # assert (0) print(max(pinyin_lengh)) #assert (0) all_labels = [] all_predictions = [] for i_batch, sample_batched in enumerate( self.validationdataloader): input = Variable(sample_batched['temporalvolume']).cuda() labels = Variable(sample_batched['label']).cuda() length = Variable(sample_batched['length']).cuda() model = model.cuda() #print(np.shape (input)) outputs = net(input) #print (np.shape (outputs)) #assert (0) (vector, top1) = validator_function(outputs, length, labels) _, maxindices = vector.cpu().max(1) all_labels.extend(labels.cpu().numpy()[:, 0]) all_predictions.extend(maxindices.cpu().numpy()) argmax = (-vector.cpu().numpy()).argsort() for i in range(input.size(0)): p = list(argmax[i]).index(labels[i]) count[p:] += 1 #print (count) num_samples += input.size(0) if i_batch % 50 == 0: print( 'i_batch/tot_batch:{}/{},corret/tot:{}/{},current_acc:{}' .format(i_batch, len(self.validationdataloader), count[0], len(self.validationdataset), 1.0 * count[0] / num_samples)) # print (len(all_labels)) # if len (all_labels) > 100: # break #break # all_labels = np.array(all_labels).flatten() # all_predictions = np.array(all_predictions).flatten() # print (all_labels) # print (all_predictions) all_length_labels = [pinyin_lengh[label] for label in all_labels] all_length_predictions = [ pinyin_lengh[label] for label in all_predictions ] #print () #all_length_labels.append cm = confusion_matrix( all_length_labels, all_length_predictions, ) #np.save ("confusion_matrix.npy", cm) #print (self.pinyins[::-1]) #assert (0) #cm = np.load ("confusion_matrix.npy") print(cm) print(cm.sum(axis=1)) cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] #cm = cm[:100, :100] print(cm) pinyin_lengh_name = [1, 2, 3, 4, 5, 6, 7] #assert (0) trace = go.Heatmap(z=cm, x=pinyin_lengh_name, y=pinyin_lengh_name) #print (self.pinyins) data = [trace] py.iplot(data, filename='labelled-heatmap-length') plot_confusion_matrix(cm, pinyin_lengh_name, "Confusion Matrix for Pinyins") plt.savefig('HAR_cm.png', format='png') plt.show() assert (0) return count / num_samples
def main(): parser = argparse.ArgumentParser() parser.add_argument("-c", "--config", type=str, help="configuration file") parser.add_argument("-s", "--start", type=int, help="start epoch if reload", default=1) parser.add_argument("-t", "--test", type=bool, help="test mode", default=False) parser.add_argument("-b", "--best", type=float, help="best epoch val accuracy", default=0.) parser.add_argument("-e", "--bepoch", type=int, help="the number of bad epoch", default=0) args = parser.parse_args() writer = SummaryWriter() print("Loading options...") with open(args.config, 'r') as optionsFile: options = yaml.load(optionsFile.read()) options['training']['start_epoch'] = args.start - 1 if (options["general"]["usecudnnbenchmark"] and options["general"]["usecudnn"]): print("Running cudnn benchmark...") torch.backends.cudnn.benchmark = True writer.add_text('name', options['name']) #Create the model. model = LipRead(options).cuda() print('lr : ', options['training']['learning_rate']) print('weight_decay : ', options['training']['weight_decay']) print('landmark : ', options['input']['landmark']) print('landmark channel concat : ', not options['input']['landmark_seperate']) print('coord conv : ', options['model']['coord']) print('attention : ', options['model']['attention']) optimizer = optim.Adam(model.parameters(), lr=options['training']['learning_rate'], weight_decay=options['training']['weight_decay']) if options['training']['schedule'] == 'plateau': if args.start > 1 and args.best == 0. and not args.test: print("must have best accuracy") raise plat = True scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer, mode='max', factor=options['training']['lr_decay'], patience=3, verbose=True, threshold=0.003, threshold_mode='abs', ) scheduler.best = args.best scheduler.num_bad_epochs = args.bepoch else: plat = False scheduler = optim.lr_scheduler.MultiStepLR( optimizer, milestones=options['training']['schedule'], gamma=options['training']['lr_decay']) criterion = model.loss() if not os.path.isdir( os.path.join(options["general"]["save_path"], options['name'])): os.mkdir(os.path.join(options["general"]["save_path"], options['name'])) if not os.path.isdir( os.path.join(options["general"]["save_path"], options['name'], 'optimizers')): os.mkdir( os.path.join(options["general"]["save_path"], options['name'], 'optimizers')) if not os.path.isdir( os.path.join(options["general"]["save_path"], options['name'], 'models')): os.mkdir( os.path.join(options["general"]["save_path"], options['name'], 'models')) if (options["general"]['model_load']): path = glob( os.path.join(options["general"]["save_path"], options['name'], 'models', 'model{}.pth'.format(args.start - 1))) #path = sorted(glob(os.path.join(options["general"]["save_path"], options['name'], 'models', '*.pth')), key=lambda name : int(name.split('/')[-1].replace('.pth', '').replace('model', ''))) if path: print('load {} model..'.format(path[-1])) model.load_state_dict(torch.load(path[-1])) #path = sorted(glob(os.path.join(options["general"]["save_path"], options['name'], 'optimizers', '*.pth')), key=lambda name : int(name.split('/')[-1].replace('.pth', '').replace('optimizer', ''))) path = glob( os.path.join(options["general"]["save_path"], options['name'], 'optimizers', 'optimizer{}.pth'.format(args.start - 1))) if path: print('load {} optimizer..'.format(path[-1])) optimizer.load_state_dict(torch.load(path[-1])) train_dataset = LipreadingDataset(options["training"]["data_path"], "train", options['input']['aug'], options['input']['landmark'], options['input']['landmark_seperate']) train_dataloader = DataLoader(train_dataset, batch_size=options["input"]["batch_size"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["num_worker"], drop_last=True) val_dataset = LipreadingDataset(options['validation']['data_path'], "val", False, options['input']['landmark'], options['input']['landmark_seperate']) val_dataloader = DataLoader(val_dataset, batch_size=options["input"]["batch_size"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["num_worker"], drop_last=True) train_size = len(train_dataset) batch_size = options["input"]["batch_size"] stats_frequency = options["training"]["stats_frequency"] if args.test: test_dataset = LipreadingDataset(options['validation']['data_path'], "test", False, options['input']['landmark'], options['input']['landmark_seperate']) test_dataloader = DataLoader( test_dataset, batch_size=options["input"]["batch_size"], shuffle=options["input"]["shuffle"], num_workers=options["input"]["num_worker"], drop_last=True) model.eval() with torch.no_grad(): print("Starting testing...") count = 0 validator_function = model.validator_function() for i_batch, sample_batched in enumerate(test_dataloader): input = sample_batched[0] labels = sample_batched[1] input = input.cuda() labels = labels.cuda() outputs = model(input) count += validator_function(outputs, labels) accuracy = count / len(val_dataset) print('#############test result################') print('correct count: {}, total count: {}, accu: {}'.format( count, len(test_dataset), accuracy)) # with open(os.path.join('./', options['name']+'.txt'), "a") as outputfile: # outputfile.write("\ncorrect count: {}, total count: {} accuracy: {}" .format(count, len(test_dataset), accuracy )) return for epoch in range(options["training"]["start_epoch"], options["training"]["max_epoch"]): model.train() if (options["training"]["train"]): if options['training']['schedule'] and not plat: scheduler.step(epoch) running_loss = 0.0 count = 0 count_bs = 0 startTime = datetime.now() print("Starting training...") for i_batch, sample_batched in enumerate(train_dataloader): optimizer.zero_grad() if options['input']['landmark_seperate']: x = sample_batched[0].cuda() labels = sample_batched[1].cuda() dot_labels = sample_batched[2].float().cuda() else: x = sample_batched[0].cuda() labels = sample_batched[1].cuda() if not options['input']['landmark_seperate']: outputs = model(x) else: outputs = model(x, dot_labels) loss = criterion(outputs, labels) count += model.validator_function()(outputs, labels) count_bs += labels.shape[0] running_loss += loss.item() loss.backward() optimizer.step() if (i_batch % stats_frequency == 0 and i_batch != 0): print('[%d, %5d] loss: %.8f, acc: %f' % (epoch + 1, i_batch + 1, running_loss / stats_frequency, count / count_bs)) writer.add_scalar( 'train/loss', running_loss / stats_frequency, (epoch - 1) * train_size + i_batch * batch_size) writer.add_scalar('train/accuracy', count / count_bs, (epoch - 1) * train_size + i_batch * batch_size) writer.add_scalar('train/true', count, (epoch - 1) * train_size + i_batch * batch_size) writer.add_scalar('train/false', count_bs - count, (epoch - 1) * train_size + i_batch * batch_size) try: print('lr {}, name {}'.format( optimizer.param_groups[-1]['lr'], options['name'])) writer.add_scalar( 'train/lr', optimizer.param_groups[-1]['lr'], (epoch - 1) * train_size + i_batch * batch_size) except Exception as e: print('lr {}, name {}'.format( options['training']['learning_rate'], options['name'])) writer.add_scalar( 'train/lr', options['training']['learning_rate'], (epoch - 1) * train_size + i_batch * batch_size) running_loss = 0.0 count = 0 count_bs = 0 currentTime = datetime.now() output_iteration(i_batch * batch_size, currentTime - startTime, train_size) print("Epoch completed") if options['general']['model_save'] and options['training']['train']: print("saving state..") torch.save( model.state_dict(), os.path.join(options["general"]["save_path"], options['name'], 'models', 'model{}.pth'.format(epoch + 1))) torch.save( optimizer.state_dict(), os.path.join(options["general"]["save_path"], options['name'], 'optimizers', 'optimizer{}.pth'.format(epoch + 1))) model.eval() with torch.no_grad(): if (options["validation"]["validate"]): print("Starting validation...") count = 0 validator_function = model.validator_function() for i_batch, sample_batched in enumerate(val_dataloader): if options['input']['landmark_seperate']: x = sample_batched[0].cuda() labels = sample_batched[1].cuda() dot_labels = sample_batched[2].float().cuda() else: x = sample_batched[0].cuda() labels = sample_batched[1].cuda() if not options['input']['landmark_seperate']: outputs = model(x) else: outputs = model(x, dot_labels) count += validator_function(outputs, labels) accuracy = count / len(val_dataset) if options['training']['schedule'] and plat: scheduler.step(accuracy) writer.add_scalar('val/accuracy', accuracy, epoch) writer.add_scalar('val/true', count, epoch) writer.add_scalar('val/false', len(val_dataset) - count, epoch) print('correct count: {}, total count: {}, accu: {}'.format( count, len(val_dataset), accuracy)) with open(os.path.join('./', options['name'] + '.txt'), "a") as outputfile: outputfile.write( "\ncorrect count: {}, total count: {} accuracy: {}". format(count, len(val_dataset), accuracy))
class Validator(): def __init__(self, options, mode): self.usecudnn = options["general"]["usecudnn"] self.batchsize = options["input"]["batchsize"] self.validationdataset_ori = LipreadingDataset( options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.validationdataset = LipreadingDataset_val( options[mode]["data_root"], options[mode]["index_root"], options[mode]["padding"], False) self.tot_data = len(self.validationdataset) self.validationdataloader = DataLoader( self.validationdataset, batch_size=options["input"]["batchsize"], shuffle=False, num_workers=options["input"]["numworkers"], drop_last=False) self.mode = mode self.video_dist_label = convert_task3_label_to_video_label() self.average_IOU = 0 self.video_id_cnt = 0 self.time0 = time.time() def __call__(self, model): with torch.no_grad(): print("Starting {}...".format(self.mode)) # count = np.zeros((len(self.validationdataset.pinyins))) # print (len(self.validationdataset.pinyins)) self.pinyins = self.validationdataset_ori.get_pinyins() self.video_list = self.validationdataset.get_video_list() video_list_check_list = np.zeros(len(self.video_list)) # assert (0) validator_function_pred = model.validator_function_pred() model.eval() # if(self.usecudnn): # net = nn.DataParallel(model).cuda() net = model.cuda() num_samples = 0 all_labels = [] all_predictions = [] output_list = [] # print (self.video_list) for i_batch, sample_batched in enumerate( self.validationdataloader): input = Variable(sample_batched['temporalvolume']).cuda() # labels = Variable(sample_batched['label']).cuda() length = Variable(sample_batched['length']).cuda() op = sample_batched['op'] ed = sample_batched['ed'] path = sample_batched['path'] video_length = sample_batched['video_length'] # if path == "004499b75f5456aa7f866b7f5252b73c": # continue # assert(0) # print (input[0]) # print (np.shape (input)) model = model.cuda() #print(np.shape (input)) outputs = net(input) #print (np.shape (outputs)) #assert (0) (values, predition, averageEnergies) = validator_function_pred(outputs, length) pre_video_id = None pre_video_length = None # time0 = time.time() for i in range(0, len(predition)): if video_list_check_list[self.video_list.index( path[i])] == 1: # print (path[i]) output_list.append(averageEnergies[i].cpu().numpy()) pre_video_id = path[i] pre_video_length = video_length[i] elif video_list_check_list[self.video_list.index( path[i])] == 0: if len( output_list ) != 0 and pre_video_id != None and pre_video_id in self.video_dist_label.keys( ): self.video_id_cnt = self.video_id_cnt + 1 pred_prob = np.max(output_list, axis=0) np.save( "checkpoint_prob_30/" + pre_video_id + ".npy", np.array(pred_prob)) # pred_word = [self.pinyins[int(i)] for i in np.where (pred_prob > -0.5 )[0]] sorted_index = sorted(enumerate(pred_prob), key=lambda x: x[1]) # print (sorted_index) pred_word = [ self.pinyins[int(i[0])] for i in sorted_index[-int(pre_video_length / 13):] ] # print (pred_word) # print (pred_word) # assert (0) print(set(pred_word)) print(set(self.video_dist_label[pre_video_id])) output = str(pre_video_id) + " " + str(pred_word) print(output) f = open('output_10.txt', 'a') f.write(output + "\n") f.close() x = len( set(pred_word) & set(self.video_dist_label[pre_video_id])) y = len( set(pred_word) | set(self.video_dist_label[pre_video_id])) # print (x) # print (y) print("Num:", self.video_id_cnt, " this_term:", x / y) self.average_IOU = self.average_IOU + (x / y) print("average:", self.average_IOU / self.video_id_cnt, "time needed:", (time.time() - self.time0) / self.video_id_cnt) # time0 = time.time() # print (np.shape (averageEnergies[i].cpu().numpy())) output_list = [averageEnergies[i].cpu().numpy()] video_list_check_list[self.video_list.index( path[i])] = 1 pre_video_id = path[i] pre_video_length = video_length[i] continue # print (values) # predition = [ self.pinyins[label] for label in predition ] # for i in range(0, len(predition)): # if values[i] > -5: # output = str(path[i]) + " " + str(op[i].cpu().numpy()) + " " + str(ed[i].cpu().numpy()) + " " + str(predition[i]) + " " + str(values[i].cpu().numpy()) # f.write(output + "\n" )# print (output) # _, maxindices = vector.cpu().max(1) # all_labels.extend (labels.cpu().numpy()[:,0]) # all_predictions.extend (maxindices.cpu().numpy()) # argmax = (-vector.cpu().numpy()).argsort() # for i in range(input.size(0)): # p = list(argmax[i]).index(labels[i]) # count[p:] += 1 # #print (count) # num_samples += input.size(0) # if i_batch % 50 == 0: # print('i_batch/tot_batch:{}/{},corret/tot:{}/{},current_acc:{}'.format(i_batch,len(self.validationdataloader),count[0],len(self.validationdataset),1.0*count[0]/num_samples)) # print (len(all_labels)) # if len (all_labels) > 100: # break #break # all_labels = np.array(all_labels).flatten() # all_predictions = np.array(all_predictions).flatten() # print (all_labels) # print (all_predictions) assert (0) all_length_labels = [pinyin_lengh[label] for label in all_labels] all_length_predictions = [ pinyin_lengh[label] for label in all_predictions ] #print () #all_length_labels.append cm = confusion_matrix( all_length_labels, all_length_predictions, ) #np.save ("confusion_matrix.npy", cm) #print (self.pinyins[::-1]) #assert (0) #cm = np.load ("confusion_matrix.npy") print(cm) print(cm.sum(axis=1)) cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] #cm = cm[:100, :100] print(cm) pinyin_lengh_name = [1, 2, 3, 4, 5, 6, 7] #assert (0) trace = go.Heatmap(z=cm, x=pinyin_lengh_name, y=pinyin_lengh_name) #print (self.pinyins) data = [trace] py.iplot(data, filename='labelled-heatmap-length') plot_confusion_matrix(cm, pinyin_lengh_name, "Confusion Matrix for Pinyins") plt.savefig('HAR_cm.png', format='png') plt.show() assert (0) return count / num_samples
import math import sys import torch import time import numpy as np with open(sys.argv[1], 'r') as optFile: opt = toml.loads(optFile.read()) if (opt["general"]["usecudnnbenchmark"] and opt["general"]["usecudnn"]): print("Running cudnn benchmark...") torch.backends.cudnn.benchmark = True writer = SummaryWriter(comment=opt["general"]["comment"]) train_dataset = LipreadingDataset(opt["training"]["dataset"], "train") train_dataloader = DataLoader(train_dataset, batch_size=opt["input"]["batchsize"], shuffle=opt["input"]["shuffle"], num_workers=opt["input"]["numworkers"], drop_last=False) val_dataset = LipreadingDataset(opt["validation"]["dataset"], "val") val_dataloader = DataLoader(val_dataset, batch_size=opt["input"]["batchsize"], shuffle=opt["input"]["shuffle"], num_workers=opt["input"]["numworkers"], drop_last=False) model = LRGANModel() model.initialize(opt)
from data import LipreadingDataset_LR as LipreadingDataset from torch.utils.data import DataLoader from tensorboardX import SummaryWriter import torch.nn as nn import os import pdb import math import sys import torch import time import numpy as np with open(sys.argv[1], 'r') as optFile: opt = toml.loads(optFile.read()) val_dataset = LipreadingDataset(opt["validation"]["dataset"], "val") val_dataloader = DataLoader(val_dataset, batch_size=opt["input"]["batchsize"], shuffle=opt["input"]["shuffle"], num_workers=opt["input"]["numworkers"], drop_last=False) model = LRGANModel() model.initialize(opt) print('Start Testing...') model.set_eval() count = np.array([0, 0, 0, 0]) acc = np.array([0.0, 0.0, 0.0, 0.0]) val_loss = np.array([0.0, 0.0, 0.0, 0.0]) len_dataset = len(val_dataloader)