def checkAudio(path): rnn = RNN(input_size, hidden_size, num_layers, num_classes) rnn.load_state_dict(torch.load('./rnn.pth')) sample_rate,waveform = wa.read(path) mfcc_feature = mfcc(waveform, sample_rate, nfft= 1256) test_data = torch.Tensor(mfcc_feature) test_data = test_data.type(torch.float32) #test_data, test_labels = test_data, test_labels test_pred = rnn(test_data.view(-1, 1,13)) test_pred = test_pred[0] prob = torch.nn.functional.softmax(test_pred) pre_cls = torch.argmax(prob) if pre_cls == torch.tensor(0): answer = '望门投止思张俭' elif pre_cls == torch.tensor(1): answer = '忍死须臾待杜根' elif pre_cls == torch.tensor(2): answer = '我自横刀向天笑' else: answer = '去留肝胆两昆仑' return answer
def sample(out_len, tweet): with open('models/word2vec.p', 'rb') as f: word2vec = pickle.load(f) word2vec = torch.tensor(word2vec) with open('models/translators.p', 'rb') as f: translators = pickle.load(f) inx2word = {int(k): v for k, v in translators['inx2word'].items()} word2inx = {k: int(v) for k, v in translators['word2inx'].items()} dict_size = len(inx2word) if torch.cuda.is_available(): device = torch.device("cuda") else: device = torch.device("cpu") model = RNN(embedding_matrix=word2vec, dict_size=dict_size, hidden_dim=100, n_layers=1) model.load_state_dict(torch.load('models/rnn', map_location=device)) model.eval() model = model.to(device) size = out_len - len(tweet) # Now pass in the previous characters and get a new one for _ in range(size): word, h = predict(model, tweet, device, inx2word, word2inx) if word != '<UNK>': tweet.append(word) h = h.to(device) return ' '.join(tweet)
def test_model(args): # Hyper Parameters sequence_length = args.seq_len input_size = args.input_size hidden_size = args.hidden_size num_layers = args.num_layers num_classes = args.num_classes batch_size = args.batch_size num_epochs = args.num_epochs learning_rate = args.learning_rate dropout = args.dropout # Load back the best performing model rnn = RNN('LSTM', input_size, hidden_size, num_layers, num_classes, dropout) if args.cuda: rnn = rnn.cuda() rnn.load_state_dict(torch.load(args.model_path)) # train_dataset = create_dataset('data/train/', timesteps=sequence_length) # train_loader = dataloader(train_dataset, batch_size=batch_size) test_dataset = create_dataset('data/test/', timesteps=sequence_length) test_loader = dataloader(test_dataset, batch_size=batch_size) print('-' * 50) # print('training accuracy = %.4f, test accuracy = %.4f' % (eval_model(rnn, train_loader), eval_model(rnn, test_loader))) # print('training accuracy = %.4f' % eval_model(rnn, train_loader)) print('test accuracy = %.4f' % eval_model(rnn, test_loader)) # print('test f1-score = %.4f' % get_f1score(rnn, test_loader)) print_confusion_matrix(rnn, test_loader)
def load_model(model_path, input_stoi): model = RNN( len(set(input_stoi.values())), 100, 256, 1, 2, True, 0.5, input_stoi['<pad>'] ) model.load_state_dict(torch.load(model_path)) model = model.eval() return model
class Sampler: """ Samples all the detections for a given video and query """ def __init__(self, input_size=600, hidden_size=256, weights_path='models/best/model-epoch-last.pth', num_descriptors=10): self.model = RNN(num_descriptors=num_descriptors, hidden_size=hidden_size, lstm_in_size=input_size) self.model.load_state_dict(torch.load(weights_path)) self.num_descriptors = num_descriptors if torch.cuda.is_available(): self.model.cuda() self.model.eval() def sample_video(self, query, video_name, descriptors_path='extracted_descriptors_100', print_sorted_files=False): self.model.eval() files = glob( os.path.join( descriptors_path, 'descriptors_top' + str(self.num_descriptors) + '_' + video_name + '_' + query + '_*')) files = sorted(files) if print_sorted_files: print( os.path.join( descriptors_path, 'descriptors_top' + str(self.num_descriptors) + '_' + video_name + '_' + query + '_*')) print(files) predictions = None for desc_file in files: descriptors = np.load(desc_file) descriptors = torch.from_numpy(descriptors).type(torch.FloatTensor)\ .reshape((1, descriptors.shape[1], int(descriptors.shape[2]/6), 6)) if torch.cuda.is_available(): descriptors = descriptors.cuda() preds = self.model(descriptors) if predictions is None: predictions = preds else: predictions = torch.cat((predictions, preds), 1) return predictions
def main(): args = parse_args() config = parse_config(args) if args.gpu and torch.cuda.is_available(): torch.cuda.manual_seed_all(config.seed) device = torch.device('cuda') else: device = torch.device('cpu') # Create character-level RNN for data of the form in dataset dataset = StudentInteractionsDataset( csv_file='data/naive_c5_q50_s4000_v1.csv', root_dir='data/') rnn = RNN(voc_len=dataset.voc_len, voc_freq=dataset.voc_freq, embedding_dim=config.embedding_dim, num_lstm_units=config.num_lstm_units, num_lstm_layers=config.num_lstm_layers, device=device) if args.train: # Split data into train and test sets train_size = int(0.8 * dataset.data.shape[0]) test_size = dataset.data.shape[0] - train_size train_set, test_set = random_split(dataset, [train_size, test_size]) # Create train and test dataloaders train_loader = DataLoader(dataset=train_set, batch_size=config.batch_size, shuffle=True) test_loader = DataLoader(dataset=test_set, batch_size=config.batch_size, shuffle=True) train(args, rnn, train_loader, test_loader) else: rnn.load_state_dict( torch.load(os.path.join(args.checkpoint_dir, 'model-07150.pt'), map_location=device)) print("RNN weights restored.") samples = [] for i in range(args.num_samples): samples.append(rnn.sample(SAMPLE_SEQ_LEN)) samples = pd.DataFrame(samples) file_path = "data/generated/samples_" + str(args.num_samples) + ".csv" samples.to_csv(file_path, index=False)
class Train( object ): def __init__( self, model_name, target, sn=False ): # Device configuration self.device = torch.device( 'cuda:0' if torch.cuda.is_available() else 'cpu' ) # Hyper-parameters self.__sequence_length = 50 self.__input_size = 78 self.__hidden_size = 256 self.__num_layers = 3 self.__num_classes = 7 self.__batch_size = 3 #256 self.model = RNN( self.__input_size, self.__hidden_size, self.__num_layers, self.__num_classes, sn ).to( self.device ) self.param = torch.load( model_name ) self.model.load_state_dict( self.param ) self.data_load( target ) def data_load( self, target ): # load data print( "Test target : {}".format( target ) ) val_list = dataloader.make_datapath_list( phase=target ) val_dataset = dataloader.LoadDataset( file_list=val_list, phase=target ) self.val_loader = torch.utils.data.DataLoader( val_dataset, batch_size=self.__batch_size, shuffle=True ) def test( self ): # Test the model with torch.no_grad(): correct = 0 total = 0 for images, labels in self.val_loader: images = images.reshape( -1, self.__sequence_length, self.__input_size ).to( self.device ) labels = labels.to( self.device ) outputs = self.model( images, self.device ) _, predicted = torch.max( outputs.data, 1 ) total += labels.size(0) correct += ( predicted == labels ).sum().item() #print(f'predicted={predicted}') #print(f'labels={labels}') print('Test Accuracy of the model on the {} test data: {} %'.format(total, 100 * correct / total))
def predict(cfg, model_path, loader, device, save_path): print(f'Saving predictions @ {save_path}') # define model model = RNN(cfg.model_type, cfg.input_dim, cfg.hidden_dim, cfg.n_layers, cfg.drop_p, cfg.output_dim, cfg.bi_dir) model = model.to(device) # load the model model.load_state_dict(torch.load(model_path)) # just to be sure model.eval() predictions = { 'Object': [], 'Sequence': [], } for c in range(cfg.output_dim): predictions[f'{cfg.task}_prob_{c}'] = [] for batch in loader: inputs = batch['inputs'].to(device) with torch.set_grad_enabled(False): outputs, hiddens = model(inputs) _, preds = torch.max(outputs, 1) softmaxed = torch.nn.functional.softmax(outputs, dim=-1) for i in range(len(batch['paths'])): sequence = pathlib.Path(batch['paths'][i]).stem.replace( '_audio', '') predictions['Object'].append(batch['containers'][i]) predictions['Sequence'].append(sequence.replace('_vggish', '')) for c in range(cfg.output_dim): predictions[f'{cfg.task}_prob_{c}'].append(softmaxed[i, c].item()) predictions_dataset = pd.DataFrame.from_dict(predictions).sort_values( ['Object', 'Sequence']) predictions_dataset.to_csv(save_path, index=False) # returning the dataset because it will be useful for test-time prediction averaging return predictions_dataset
def main(FLAGS): data_path = DATA_PATH debug = FLAGS.debug unrolling_factor = FLAGS.unroll batch_size = FLAGS.batch_size # Initialize Models CNN_model = CNN(FLAGS.batch_size, FLAGS.unroll).to(device) RNN_model = RNN(CNN_OUTPUT_SIZE, FLAGS.unroll, FLAGS.batch_size, False).to(device) # Stateless LSTM for training criterion = nn.MSELoss() # Only skip connection parameters need to be learned skip_conv_params = list(CNN_model.skip_conv3.parameters()) + list( CNN_model.skip_conv2.parameters()) + list( CNN_model.skip_conv1.parameters()) prelu_params = list(CNN_model.prelu1.parameters()) + list( CNN_model.prelu2.parameters()) + list(CNN_model.prelu3.parameters()) # Network parameters that needs to be learnt by training params = list(RNN_model.parameters()) + prelu_params + skip_conv_params # Initialize optimizer , added weight decay optimizer = torch.optim.Adam(params, lr=FLAGS.learning_rate) # Load Checkpoint if present epoch = 0 # TODO: Manually copy the checkpoint to this path and has to be renamed as below checkpoint_name = './final_checkpoint/re3_final_checkpoint.pth' if debug: print("Checkpoint name is %s" % checkpoint_name) if os.path.isfile(checkpoint_name): checkpoint = torch.load(checkpoint_name) CNN_model.load_state_dict(checkpoint['cnn_model_state_dict']) RNN_model.load_state_dict(checkpoint['rnn_model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch'] print("Checkpoint loaded") if debug: print("Data folder is present in %s" % data_path) # Training data path train_data_path = data_path + '/data/train/Data/' train_annot_path = data_path + '/data/train/Annotations/' list_id, folder_start_pos = prepare_for_dataset(train_data_path, unrolling_factor) train_dataset = TrackerDataset(train_data_path, train_annot_path, list_id, folder_start_pos, (CROP_SIZE, CROP_SIZE, 3), unrolling_factor, debug) # img,labels = train_dataset.__getitem__(1) train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) count = 0 total_step = len(train_loader) # Loss accumulator loss_sum = 0.0 #Start training ckpt_path = 'trained_checkpoints' # TODO: The checkpoints are saved in one folder and loaded from another folder. # TODO : By this way there is freedom to see model`s performance across different checkpoints. for epoch in range(epoch, FLAGS.num_epochs): for minibatch, (images, gt_labels) in enumerate(train_loader): try: # Converting (batch_size x 2*unroll x C x H x W ) to (batch_size*unroll*2 x C x H x W ) images = images.view(-1, 3, CROP_SIZE, CROP_SIZE).to(device) gt_labels = gt_labels.view(-1, 4).to(device) #Forward, backward and optimize CNN_features = CNN_model(images) pred_labels = RNN_model(CNN_features) loss = criterion(pred_labels, gt_labels) CNN_model.zero_grad() RNN_model.zero_grad() loss.backward() optimizer.step() loss_sum += loss.item() if minibatch % 20 == 0: print('Epoch [{}/{}],Step [{}/{}], Loss {:4f}\n'.format( epoch, FLAGS.num_epochs, minibatch, total_step, loss.item())) except Exception as e: print(e) print(images.size()) average_loss = loss_sum / total_step loss_sum = 0.0 flog.write('Epoch [{}/{}],Avg Loss {:4f}\n'.format( epoch, FLAGS.num_epochs, average_loss)) print('Epoch [{}/{}],Avg Loss {:4f}\n'.format(epoch, FLAGS.num_epochs, average_loss)) if (epoch) % 10 == 0: # Save the model checkpoint torch.save( { 'epoch': epoch, 'cnn_model_state_dict': CNN_model.state_dict(), 'rnn_model_state_dict': RNN_model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), }, ckpt_path + '/checkpoint_' + str(epoch) + '.pth')
torch.set_default_tensor_type('torch.FloatTensor') weights = args.weights n_hidden = 128 batch_size = args.batch_size num_workers = args.num_workers log_iters = args.log_iters weights = PROJECT_DIR + args.weights print('Loading weights...') rnn = RNN(N_LETTERS, n_hidden, N_GENDERS) if args.cuda: rnn = rnn.cuda() rnn.load_state_dict(torch.load(weights)) rnn.eval() def _evaluate(name_tensor): hidden = rnn.init_hidden() for letter_tensor in name_tensor: letter_tensor.data.unsqueeze_(0) output, hidden = rnn(letter_tensor, hidden) return output def predict(name, n_predictions=2): output = _evaluate(Variable(name_to_tensor(name, args.cuda)))
def train(cfg, datasets, dataloaders, device, save_model_path): model = RNN(cfg.model_type, cfg.input_dim, cfg.hidden_dim, cfg.n_layers, cfg.drop_p, cfg.output_dim, cfg.bi_dir) model = model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=3e-4) criterion = torch.nn.CrossEntropyLoss() # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1) best_metric = 0.0 best_epoch = 0 best_model_wts = copy.deepcopy(model.state_dict()) for epoch in range(cfg.num_epochs): for phase in ['train', 'valid']: if phase == 'train': model.train() # Set model to training mode else: model.eval() # Set model to evaluate mode running_loss = 0.0 # running_corrects = 0 y_pred = [] y_true = [] # Iterate over data. for batch in dataloaders[phase]: inputs = batch['inputs'].to(device) targets = batch['targets'][cfg.task].to(device) # zero the parameter gradients optimizer.zero_grad() # forward # track history if only in train with torch.set_grad_enabled(phase == 'train'): outputs, hiddens = model(inputs) _, preds = torch.max(outputs, 1) loss = criterion(outputs, targets) # backward + optimize only if in training phase if phase == 'train': loss.backward() optimizer.step() # statistics running_loss += loss.item() * inputs.size(0) # running_corrects += torch.sum(preds == targets.data) y_pred.extend(preds.tolist()) y_true.extend(targets.tolist()) # if phase == 'train': # scheduler.step() # epoch_acc = running_corrects.double() / len(datasets[phase]) epoch_loss = running_loss / len(datasets[phase]) f1_ep = f1_score(y_true, y_pred, average='weighted') precision_ep = precision_score(y_true, y_pred, average='weighted') recall_ep = recall_score(y_true, y_pred, average='weighted') accuracy_ep = accuracy_score(y_true, y_pred) # print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc)) print( f'({phase} @ {epoch+1}): L: {epoch_loss:3f}; A: {accuracy_ep:3f}; R: {recall_ep:3f}; ' + f'P: {precision_ep:3f}; F1: {f1_ep:3f}') # deep copy the model if phase == 'valid' and f1_ep > best_metric: best_metric = f1_ep best_epoch = epoch best_model_wts = copy.deepcopy(model.state_dict()) print(f'Best val Metric {best_metric:3f} @ {best_epoch+1}\n') # load best model weights and saves it model.load_state_dict(best_model_wts) torch.save(model.state_dict(), save_model_path) print(f'model is saved @ {save_model_path}') return best_metric
if valid_acc > best_valid_acc: save_checkpoint({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'valid_acc': valid_acc }, True) secs = int(time.time() - start_time) mins = secs / 60 secs = secs % 60 writer.add_scalars("Loss", { 'train': train_loss, 'valid': valid_loss }, epoch) writer.add_scalars("Acc", { 'train': train_acc, 'valid': valid_acc }, epoch) print("Epoch: %d" % (epoch + 1), " | time in %d minutes, %d seconds" % (mins, secs)) print(f"\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)") print(f"\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)") # test saved_params = torch.load("%s/%s" % (args.save_model, model_name)) print("epoch:%s best_valid_acc:%s" % (saved_params['epoch'], saved_params['valid_acc'])) model.load_state_dict(saved_params['state_dict']) loss, acc = test(args.test) print("test set loss: %s" % loss) print("test set acc: %s" % acc)
args.mlp_arc_size, args.mlp_label_size, pos_to_index, xpos_to_index, rel_to_index, args.cuda, batch_first=True) print(model) #load model print("===> Loading pretrained model ...") if args.cuda: checkpoint = torch.load(args.model) else: checkpoint = torch.load(args.model, map_location="cpu") model.load_state_dict(checkpoint['model_state_dict']) if args.cuda: model.cuda() # switch to evaluate mode model.eval() arcs_preds = [] labels_preds = [] start = time.time() for i, (word_tensor, ext_word_ids, char_ids, pos_tensor, xpos_tensor, head_targets, rel_targets, seq_lengths, perm_idx) in enumerate(test_loader):
def train(args, labeled, resume_from, ckpt_file): print("========== In the train step ==========") iterator, TEXT, LABEL, tabular_dataset = load_data(stage="train", args=args, indices=labeled) print("Created the iterators") INPUT_DIM = len(TEXT.vocab) OUTPUT_DIM = 1 BIDIRECTIONAL = True PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token] model = RNN( INPUT_DIM, args["EMBEDDING_DIM"], args["HIDDEN_DIM"], OUTPUT_DIM, args["N_LAYERS"], BIDIRECTIONAL, args["DROPOUT"], PAD_IDX, ) model = model.to(device=device) pretrained_embeddings = TEXT.vocab.vectors model.embedding.weight.data.copy_(pretrained_embeddings) unk_idx = TEXT.vocab.stoi["<unk>"] pad_idx = TEXT.vocab.stoi["<pad>"] model.embedding.weight.data[unk_idx] = torch.zeros(args["EMBEDDING_DIM"]) model.embedding.weight.data[pad_idx] = torch.zeros(args["EMBEDDING_DIM"]) optimizer = optim.Adam(model.parameters()) criterion = nn.BCEWithLogitsLoss() model = model.to("cuda") criterion = criterion.to("cuda") if resume_from is not None: ckpt = torch.load(os.path.join(args["EXPT_DIR"], resume_from + ".pth")) model.load_state_dict(ckpt["model"]) optimizer.load_state_dict(ckpt["optimizer"]) else: getdatasetstate(args) model.train() # turn on dropout, etc for epoch in tqdm(range(args["train_epochs"]), desc="Training"): running_loss = 0 i = 0 for batch in iterator: # print("Batch is", batch.review[0]) text, text_length = batch.review labels = batch.sentiment text = text.cuda() text_length = text_length.cuda() optimizer.zero_grad() output = model(text, text_length) loss = criterion(torch.squeeze(output).float(), labels.float()) loss.backward() optimizer.step() running_loss += loss.item() if i % 10: print( "epoch: {} batch: {} running-loss: {}".format( epoch + 1, i + 1, running_loss / 1000), end="\r", ) running_loss = 0 i += 1 print("Finished Training. Saving the model as {}".format(ckpt_file)) ckpt = {"model": model.state_dict(), "optimizer": optimizer.state_dict()} torch.save(ckpt, os.path.join(args["EXPT_DIR"], ckpt_file + ".pth")) return
# Load preprocessing parameters if not os.path.isfile('/tmp/params.pkl'): s3_client.download_file(BUCKET_NAME, 'params.pkl', '/tmp/params.pkl') with open('/tmp/params.pkl', 'rb') as pkl: params = pickle.load(pkl) all_categories = params['all_categories'] n_categories = params['n_categories'] all_letters = params['all_letters'] n_letters = params['n_letters'] # Check if models are available # Download model from S3 if model is not already present if not os.path.isfile('/tmp/model.pth'): s3_client.download_file(BUCKET_NAME, 'model.pth', '/tmp/model.pth') rnn = RNN(n_letters, 128, n_letters, n_categories=n_categories) rnn.load_state_dict(torch.load("/tmp/model.pth")) rnn.eval() def inputTensor(line): tensor = torch.zeros(len(line), 1, n_letters) for li in range(len(line)): letter = line[li] tensor[li][0][all_letters.find(letter)] = 1 return tensor def categoryTensor(category): li = all_categories.index(category) tensor = torch.zeros(1, n_categories) tensor[0][li] = 1
def infer(args, unlabeled, ckpt_file): print("========== In the inference step ==========") iterator, TEXT, LABEL, tabular_dataset = load_data(stage="infer", args=args, indices=unlabeled) INPUT_DIM = len(TEXT.vocab) OUTPUT_DIM = 1 BIDIRECTIONAL = True PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token] model = RNN( INPUT_DIM, args["EMBEDDING_DIM"], args["HIDDEN_DIM"], OUTPUT_DIM, args["N_LAYERS"], BIDIRECTIONAL, args["DROPOUT"], PAD_IDX, ) model.load_state_dict( torch.load(os.path.join(args["EXPT_DIR"], ckpt_file + ".pth"))["model"]) model = model.to(device=device) model.eval() predix = 0 predictions = {} truelabels = {} n_val = len(tabular_dataset) with tqdm(total=n_val, desc="Inference round", unit="batch", leave=False) as pbar: for batch in iterator: text, text_length = batch.review labels = batch.sentiment with torch.no_grad(): text = text.to(device) text_length = text_length.to(device) prediction = model(text, text_length) for logit in prediction: predictions[unlabeled[predix]] = {} sig_prediction = torch.sigmoid(logit) prediction = 0 if sig_prediction > 0.5: prediction = 1 predictions[unlabeled[predix]]["prediction"] = prediction predictions[unlabeled[predix]]["pre_softmax"] = [[ logit_fn(sig_prediction.cpu()), logit_fn(1 - sig_prediction.cpu()) ]] # print(predictions[unlabeled[predix]]["pre_softmax"]) predix += 1 pbar.update() print("The predictions are", predictions) return {"outputs": predictions}
# Load preprocessing parameters if not os.path.isfile('/tmp/params.pkl'): s3_client.download_file(BUCKET_NAME, 'params.pkl', '/tmp/params.pkl') with open('/tmp/params.pkl', 'rb') as pkl: params = pickle.load(pkl) all_categories = params['all_categories'] n_categories = params['n_categories'] all_letters = params['all_letters'] n_letters = params['n_letters'] # Check if models are available # Download model from S3 if model is not already present if not os.path.isfile('/tmp/model.pth'): s3_client.download_file(BUCKET_NAME, 'model.pth', '/tmp/model.pth') rnn = RNN(n_letters, 128, n_letters, n_categories=n_categories) rnn.load_state_dict(torch.load('/tmp/model.pth')) rnn.eval() def inputTensor(line): tensor = torch.zeros(len(line), 1, n_letters) for li in range(len(line)): letter = line[li] tensor[li][0][all_letters.find(letter)] = 1 return tensor def categoryTensor(category): li = all_categories.index(category) tensor = torch.zeros(1, n_categories) tensor[0][li] = 1
best_val_loss = None if torch.cuda.is_available(): state_dict = torch.load(args.model_path) else: state_dict = torch.load(args.model_path, map_location='cpu') # obtain the sparse mask state_mask_dict = sparsify_model(state_dict) retrained_model_path = args.model_path + '.retrain' try: for epoch in range(1, args.epochs + 1): puring_model(state_dict, state_mask_dict) model.load_state_dict(state_dict) # retrain train(1, h_sp=args.h_sp, h_th=args.h_th, block=-1) val_loss = evaluate(h_sp=args.h_sp, h_th=args.h_th, block=args.size_block) if not best_val_loss or val_loss < best_val_loss: puring_model(state_dict, state_mask_dict) model.load_state_dict(state_dict) torch.save(model.state_dict(), retrained_model_path) best_val_loss = val_loss # else: # decrease the learning rate if needed # reload the model
with open('input.pickle', 'rb') as f: input_lang = pickle.load(f) with open('target.pickle', 'rb') as f: target_lang = pickle.load(f) with open('../assets/SMSSpamCollection.txt') as f: lines = f.readlines() pairs = [[normalize_string(s) for s in line.split('\t')] for line in lines] # modelのロード hidden_size = 256 model = RNN(input_lang.n_words, target_lang.n_words, hidden_size).to(device) param = torch.load("model_data/model4.pth") for p in model.parameters(): print(p) model.load_state_dict(param) print("-" * 50) for p in model.parameters(): print(p) input_tensor = tensor_from_sentence(input_lang, pairs[1][1]).to(device) hidden = model.init_hidden().to(device) output = torch.zeros(target_lang.n_words).to(device) for i in range(input_tensor.size(0)): output = model(input_tensor[i], hidden) print(output) print(tensor_from_sentence(target_lang, pairs[1][0]))
criterion = nn.CrossEntropyLoss() criterionsq = nn.MSELoss() # k_fold, para = 5, [99,99,97,99,98] # k_fold, para = 3, [99,99,96] # k_fold, para = 3, [95,98,99] k_fold, para = 5, [99,99,98,99,98] num_epoch = 100 group = 10 acc = [] for g in range(group): for k in range(k_fold): epoch = para[k] model.reset_parameters() # model.load_state_dict(torch.load('para/'+str(k)+'_dl_'+str(para[k])+'.pt')) model.load_state_dict(torch.load(f'./para{k_fold}/{g}/{k}_dl.pt')) model.eval() running_loss, running_acc = 0.0, 0.0 for i, (data, label, labelsq) in enumerate(test_dataloader): data = Variable(data).to(device) label = Variable(label).to(device) labelsq = Variable(labelsq).to(device).squeeze() with torch.no_grad(): out1, out2 = model(data) loss = Loss(criterionsq, criterion, out1, out2, labelsq, label) running_loss += loss.data.item() * label.size(0) _, pred = torch.max(F.log_softmax(out2, dim=1), 1) num_correct = (pred == label).sum() running_acc += num_correct.data.item() num = len(test_data)
EMBEDDING_DIM = 100 HIDDEN_DIM = 32 OUTPUT_DIM = 1 N_LAYERS = 2 BIDIRECTIONAL = True DROPOUT = 0.2 N_EPOCHS = 5 BATCH_SIZE = 1 INPUT_DIM = len(vocab) PAD_IDX = vocab['<pad>'] model = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, BIDIRECTIONAL, DROPOUT) path = 'tut2-model.pt' model.load_state_dict(torch.load(path)) model = model.to(device) model.eval() def get_perturbed_text(text): #print("Getting the perturbed text") with torch.no_grad(): ori_op = predict(model, text, vocab) ranking = {} original_text = text for word in nlp(text): if word.text not in string.punctuation and word.text not in stop_words: new_text = original_text.replace(word.text, '') new_op = predict(model, new_text, vocab) ranking[word.text] = {
from config import PARAMS, DEVICE data_type = 'T' epochs, look_back, hidden_layer, output_size, num_layers, lr, input_feature_size, out_feature_size = PARAMS datas, min, max = get_global_temp(predict=True, type=data_type) if len(datas.shape) == 1: input_feature_size = 1 else: input_feature_size = datas.shape[1] datas = torch.from_numpy(datas).to(DEVICE).float() datas = datas.reshape(1, input_feature_size, look_back) # load model model = RNN(look_back, hidden_layer, output_size, num_layers).to(DEVICE) model.load_state_dict(torch.load('./model.pkl')) predict_result = [] for i in range(25): result = model(datas) datas[:, :, 0:look_back - 1] = datas[:, :, 1:look_back] datas[:, :, look_back - 1] = result[:, :, 0] result = result.view(-1, input_feature_size).data.cpu().numpy() predict_result.append(result) predict_result = np.concatenate(predict_result, 0) predict_result = predict_result * (max - min) + min predict_result = pd.DataFrame(predict_result) predict_result.to_csv('./predict_{}.csv'.format(data_type))
import torch from model import RNN from data import lineToTensor, all_categories, n_letters, n_categories n_hidden = 128 rnn = RNN(n_letters, n_hidden, n_categories) rnn.load_state_dict(torch.load('char-rnn-classification.pth')) rnn.eval() # Just return an output given a line def evaluate(line_tensor): hidden = rnn.initHidden() for i in range(line_tensor.size()[0]): output, hidden = rnn(line_tensor[i], hidden) return output def predict(line, n_predictions=3): output = evaluate(lineToTensor(line)) # Get top N categories topv, topi = output.data.topk(n_predictions, 1, True) topv = torch.exp(topv) predictions = [] for i in range(n_predictions): value = topv[0][i] category_index = topi[0][i]
embedding_size=MODEL_EMBEDDING_SIZE_MULTI, embeddings_dropout=MODEL_EMBEDDINGS_DROPOUT_MULTI, lstm_dropout=MODEL_LSTM_DROPOUT_MULTI, num_decode_layers=MODEL_NUM_HIDDEN_LAYERS_MULTI) rnn.eval() # Load state dict try: if USE_MULTI_TASK: state_dict_path = STATE_DICT_PATH_MULTI else: state_dict_path = STATE_DICT_PATH state_dict, epoch, batch, best_loss = load_state_dict( device, state_dict_path) rnn.load_state_dict(state_dict) print("Successfully loaded model state from {}.".format(state_dict_path)) print("Loaded model at epoch {}, batch {}.".format(epoch, batch)) print("Best recorded loss was {}.".format(best_loss)) except FileNotFoundError: print("Failed to load model state.") sys.exit(1) print() # Use the cut down data to evaluate if not USE_MULTI_TASK: tag_dataset = DatasetManagerTag(save_path=DATASET_TAG_INFO_PATH) tag_dataset.load() new_data = tag_dataset.get_data(partition=VALIDATION_DATA, include_tags=False)
def test(args, ckpt_file): print("========== In the test step ==========") iterator, TEXT, LABEL, tabular_dataset = load_data(stage="test", args=args, indices=None) INPUT_DIM = len(TEXT.vocab) OUTPUT_DIM = 1 BIDIRECTIONAL = True PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token] model = RNN( INPUT_DIM, args["EMBEDDING_DIM"], args["HIDDEN_DIM"], OUTPUT_DIM, args["N_LAYERS"], BIDIRECTIONAL, args["DROPOUT"], PAD_IDX, ) model.load_state_dict( torch.load(os.path.join(args["EXPT_DIR"], ckpt_file + ".pth"))["model"]) model = model.to(device=device) model.eval() predix = 0 predictions = {} truelabels = {} n_val = len(tabular_dataset) with tqdm(total=n_val, desc="Testing round", unit="batch", leave=False) as pbar: for batch in iterator: text, text_length = batch.review labels = batch.sentiment with torch.no_grad(): text = text.to(device) text_length = text_length.to(device) labels = labels.to(device) prediction = model(text, text_length) for logit, label in zip(prediction, labels): # print("logit",logit) # print("label",label) # print("logit.cpu()",logit.cpu()) predictions[predix] = torch.sigmoid(logit.cpu()) truelabels[predix] = label.cpu().numpy().tolist() predix += 1 pbar.update() truelabels_ = [] predictions_ = [] for key in predictions: if predictions[key][0] > 0.5: predictions_.append(1) else: predictions_.append(0) for key in truelabels: truelabels_.append(truelabels[key]) truelabels = truelabels_ predictions = predictions_ return {"predictions": predictions, "labels": truelabels}
max_length = 20 WEIGHT_PATH = "./weights/text_gen11.23178537686666.pth" device = "cuda" if torch.cuda.is_available() else "cpu" all_letters = string.ascii_letters + " .,;'-" n_letters = len(all_letters) + 1 categories = [ 'Arabic', 'Chinese', 'Korean', 'Japanese', 'French', 'English', 'Czech', 'Irish', 'Portuguese', 'German', 'Scottish', 'Polish', 'Italian', 'Vietnamese', 'Dutch', 'Spanish', 'Russian', 'Greek' ] n_categories = len(categories) cate2index = {v: i for i, v in enumerate(categories)} rnn = RNN(categories, n_letters, 128, n_letters) checkpoint = torch.load(WEIGHT_PATH, map_location=torch.device('cpu')) rnn.load_state_dict(checkpoint) rnn.to(device) # Sample from a category and starting letter def sample(category, start_letter='A', rnn=rnn): with torch.no_grad(): # no need to track history in sampling category_tensor = categoryTensor(cate2index[category]) input = inputTensor(start_letter) hidden = rnn.initHidden() output_name = start_letter for i in range(max_length): output, hidden = rnn(category_tensor, input[0], hidden) topv, topi = output.topk(1) topi = topi[0][0]
def main(): start_epoch = 0 max_loss = math.inf epochs_since_improvement = 0 dataset = GaitSequenceDataset(root_dir=data_dir, longest_sequence=85, shortest_sequence=55) train_sampler, validation_sampler = generate_train_validation_samplers( dataset, validation_split=0.2) print('Building dataloaders..') train_dataloader = data.DataLoader(dataset, batch_size=batch_size, sampler=train_sampler) validation_dataloader = data.DataLoader(dataset, batch_size=1, sampler=validation_sampler, drop_last=True) model = RNN(num_features, hidden_dimension, num_classes, num_layers=2).to(device) if load_pretrained is True: print('Loading pretrained model..') checkpoint = torch.load(checkpoint_path) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] model.load_state_dict(checkpoint['model_state_dict']) optimizer = checkpoint['optimizer'] else: print('Creating model..') optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) criterion = nn.CrossEntropyLoss().to(device) if mode == 'train': summary = SummaryWriter() #summary = None model.to(device) print('########### ', model) for epoch in range(start_epoch, start_epoch + num_epochs): if epochs_since_improvement == 20: break if epochs_since_improvement > 0 and epochs_since_improvement % 4 == 0: adjust_learning_rate(optimizer, 0.8) train(model, train_dataloader, optimizer, criterion, clip_gradient, device, epoch, num_epochs, summary, loss_display_interval) current_loss = validate(model, validation_dataloader, criterion, device, epoch, num_epochs, summary, loss_display_interval) is_best = max_loss > current_loss max_loss = min(max_loss, current_loss) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 save_checkpoint(epoch, epochs_since_improvement, model, optimizer, is_best) print('Current loss : ', current_loss, ' Max loss : ', max_loss) else: print('testing...') model = RNN(num_features, hidden_dimension, num_classes, num_layers=2) checkpoint = torch.load(checkpoint_path) model.load_state_dict(checkpoint['model_state_dict']) model.to(device) print(model) for batch_idx, val_data in enumerate(validation_dataloader): sequence = val_data['sequence'].permute(1, 0, 2).to(device) piano_roll = val_data['piano_roll'].permute(1, 0, 2).squeeze(1).to('cpu') sequence_length = val_data['sequence_length'] file_name = val_data['file_name'] frame = val_data['frame'] leg = val_data['leg'] sonify_sequence(model, sequence, sequence_length) plt.imshow(piano_roll) plt.show() print(file_name, frame, leg) break
class Inference(object): def __init__(self, model_name, sn=False): # Device configuration self.device = torch.device( 'cuda:0' if torch.cuda.is_available() else 'cpu') # Hyper-parameters self.__sequence_length = 50 self.__input_size = 78 self.__hidden_size = 256 self.__num_layers = 3 self.__num_classes = 7 # min_max-parameters self.__x_min = -2259.0780484289285 self.__x_max = 2548.842436486494 self.__y_min = -1186.3449394557435 self.__y_max = 939.5449823147761 self.__z_min = 1000.04 self.__z_max = 3323.48 self.__v_min = np.array([self.__x_min, self.__y_min, self.__z_min]) self.__v_max = np.array([self.__x_max, self.__y_max, self.__z_max]) self.__max_min = self.__v_max - self.__v_min self.model = RNN(self.__input_size, self.__hidden_size, self.__num_layers, self.__num_classes, sn).to(self.device) self.param = torch.load(model_name) self.model.load_state_dict(self.param) def loading_file(self, name): with open(name) as f: data = [] reader = csv.reader(f) for j, row in enumerate(reader): if j != 0 and j <= 50: data += row else: item = row return np.array( data, dtype='float32') # data.shape: list[50*26*3] 1 demension vector def normalization(self, input_data): mins = np.reshape(self.__v_min.tolist() * int(input_data.shape[0] / 3), input_data.shape) output_data = (input_data - mins) / (np.array( self.__max_min.tolist() * int(input_data.shape[0] / 3))) return output_data.astype(np.float32) def compute(self, test_name): data = self.loading_file(test_name) normalized_data = self.normalization(data) input_data = torch.from_numpy(normalized_data) with torch.no_grad(): data = input_data.reshape(-1, self.__sequence_length, self.__input_size).to(self.device) outputs = self.model(data, self.device) tmp = outputs.data * 1000.0 print(tmp.int() / 1000.0) _, predicted = torch.max(outputs.data, 1) return predicted
def load_model(): decoder = RNN(n_chars, hidden_size, n_chars, n_layers) decoder.load_state_dict(t.load('0.0011890831945547417_3.pth')) return decoder
from torch.utils.tensorboard import SummaryWriter from utils import * from model import RNN import time import math import unicodedata import string from io import open import glob import os rnn = RNN(57, 128, 18) rnn.load_state_dict(torch.load("out.net")) def evaluate(line_tensor): hidden = rnn.initHidden() for i in range(line_tensor.size()[0]): output, hidden = rnn(line_tensor[i], hidden) return output def predict(input_line, n_predictions=3): print('\n> %s' % input_line) with torch.no_grad(): output = evaluate(lineToTensor(input_line)) m = nn.Softmax(dim=1)