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)
