def train_copy_task():
num_words = 11
criterion = nn.NLLLoss(ignore_index=0, reduction='sum')
model = full_model.make_model(num_words, num_words, emb_size=32, hidden_size=64)
optim = torch.optim.Adam(model.parameters(), lr=0.0003)
eval_data = list(data_gen(num_words=num_words, batch_size=1, num_batches=100))
dev_perplexities = []
if init.USE_CUDA:
model.cuda()
for epoch in range(10):
print("Epoch %d" % epoch)
model.train()
data = data_gen(num_words=num_words, batch_size=32, num_batches=100)
train.run_epoch(data, model,
train.SimpleLossCompute(model.generator, criterion, optim))
model.eval()
with torch.no_grad():
perplexity = train.run_epoch(eval_data, model,
train.SimpleLossCompute(model.generator, criterion, None))
print("Evaluation perplexity: %f" % perplexity)
dev_perplexities.append(perplexity)
return dev_perplexities
def main(_):
# if not FLAGS.data_path:
# raise ValueError("Must set --data_path to data directory")
config = Config()
eval_config = Config()
if FLAGS.data_path:
config.data_path = FLAGS.data_path
eval_config.data_path = FLAGS.data_path
raw_data = proc_raw_data(config)
train_data, test_data = raw_data
valid_data = train_data[:160, :]
with tf.Graph().as_default():
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
with tf.name_scope("Train"):
train_input = ProcInput(data=train_data, config=config, name="TrainInput")
with tf.variable_scope("Model", reuse=None, initializer=initializer):
m = ProcModel(is_training=True, config=config, input_=train_input)
tf.summary.scalar("Training Loss", m.cost)
tf.summary.scalar("Learning Rate", m.lr)
with tf.name_scope("Valid"):
valid_input = ProcInput(data=valid_data, config=config, name="ValidInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mvalid = ProcModel(is_training=False, config=config, input_=valid_input)
# tf.summary.scalar("Validation Loss", mvalid.cost)
with tf.name_scope("Test"):
test_input = ProcInput(config=eval_config, data=test_data, name="TestInput")
with tf.variable_scope("Model", reuse=True, initializer=initializer):
mtest = ProcModel(is_training=False, config=eval_config,
input_=test_input)
sv = tf.train.Supervisor(logdir=FLAGS.save_path)
with sv.managed_session() as session:
for i in range(config.max_max_epoch):
lr_decay = config.lr_decay ** max(i + 1 - config.max_epoch, 0.0)
m.assign_lr(session, config.learning_rate * lr_decay)
print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr)))
train_entrophy = run_epoch(session, m, eval_op=m.train_op,
verbose=True)
# train_perplexity = run_epoch(session, m, eval_op=m.train_op,
# verbose=True)
print("Epoch: %d Train Entrophy: %.3f" % (i + 1, train_entrophy))
valid_accuracy = run_epoch(session, mvalid, get_acc=True)
print("Epoch: %d Valid Accuracy: %.3f" % (i + 1, valid_accuracy))
test_accuracy = run_epoch(session, mtest, get_acc=True)
print("Test Accuracy: %.3f" % test_accuracy)
if FLAGS.save_path:
print("Saving model to %s." % FLAGS.save_path)
sv.saver.save(session, FLAGS.save_path, global_step=sv.global_step)
def evaluate(net,
video_ids,
anns_path,
batch_size=64,
experiment_dir=None,
use_anns=False,
balance=False):
segments_df = dataframe_from_video_ids(video_ids,
anns_path,
use_anns=use_anns)
test_data_loader = get_test_data_loaders(segments_df,
batch_size,
balance=balance)
criterion = nn.BCELoss()
optimizer = None
net.eval()
val_accuracy, y_true, y_score, results = run_epoch(test_data_loader, net,
optimizer, criterion, 0)
df = pd.DataFrame(results)
df = df.drop_duplicates(subset=['video_id', 'start_seconds'], keep=False)
print(df)
save_results(results, experiment_dir, 0, mode='inference')
def main(cfg):
net = SPRINSeg(6, cfg.fps_n).to("cuda")
net.load_state_dict(
torch.load(hydra.utils.to_absolute_path('sprin/epoch250.pt')))
pcs_test, segs_centered_test, segs_test = read_data(
hydra.utils.to_absolute_path(
"shapenet_part_seg_hdf5_data/ply_data_test*"))
print(len(pcs_test))
run_epoch(net,
pcs_test,
segs_centered_test,
segs_test,
None,
1,
train=False,
ds=cfg.npoints,
batchsize=1)
def _get_delta(self, indices, label_manager):
"""Try adding indices to the labeled set, train on labeled set, and return change in val metric after M epochs"""
if type(indices) != list: indices = [indices]
label_manager.reveal_labels(indices)
labeled_dict = configure_split_dict(
data=label_manager.get_labeled_subset(),
split="labeled_test",
split_name="labeled_test",
get_train=True,
verbose=False,
grouper=self.grouper,
batch_size=self.config.batch_size,
config=self.config)
unlabeled_dict = configure_split_dict(
data=label_manager.get_unlabeled_subset(),
split="unlabeled_test",
split_name="unlabeled_test",
get_eval=True,
grouper=None,
verbose=False,
batch_size=self.config.unlabeled_batch_size,
config=self.config)
temp_model = copy.deepcopy(self.uncertainty_model)
temp_model.train()
for epoch in range(self.M):
run_epoch(temp_model,
labeled_dict,
None,
epoch,
self.config,
train=True)
res, _ = run_epoch(temp_model,
unlabeled_dict,
None,
0,
self.config,
train=False)
del temp_model
label_manager.hide_labels(indices)
return res[self.config.val_metric]
def train_phoneme(num_layers, lr, batch_size, hidden,
numepoch, dropout, inputfeeding, cuda, maxlen, soft=True):
dataset = Dataload(maxlen=maxlen)
criterion = nn.NLLLoss(ignore_index=0, reduction='sum')
model = full_model.make_model(dataset.src_num, dataset.trg_num, emb_size=32,
hidden_size=hidden, num_layers=num_layers, dropout=dropout,
inputfeeding=inputfeeding, soft=soft)
optim = torch.optim.Adam(model.parameters(), lr=lr)
eval_data = list(dataset.data_gen(batch_size=1, num_batches=100, eval=True))
dev_perplexities = []
if init.USE_CUDA and cuda:
model.cuda()
min_perplexity = 100
minp_iter = 0
max_accuracy = 0
maxa_iter = 0
for epoch in range(numepoch):
print("Epoch %d" % epoch)
model.train()
data = dataset.data_gen(batch_size=batch_size, num_batches=100, eval=True)
train.run_epoch(data, model,
train.SimpleLossCompute(model.generator, criterion, optim))
model.eval()
with torch.no_grad():
perplexity, accuracy = train.run_epoch(eval_data, model,
train.SimpleLossCompute(model.generator, criterion, None))
if perplexity < min_perplexity:
min_perplexity = perplexity
minp_iter = epoch
if accuracy > max_accuracy:
max_accuracy = accuracy
maxa_iter = epoch
print("Evaluation perplexity: %f" % perplexity)
print("Evaluation accuracy: %f" % accuracy)
dev_perplexities.append(perplexity)
print_e.print_examples(eval_data, dataset, model, n=2, max_len=maxlen)
print("min perplexity: %f at %d iterations" % (min_perplexity, minp_iter))
print("max accuracy: %f at %d iterations" % (max_accuracy, maxa_iter))
return dev_perplexities
def run_test(model,
basename,
batch_size,
criterion,
subset,
outname,
device,
inputdir_type0,
inputdir_type1,
num_examples_to_plot=100,
num_workers=32):
# For either multi or binary classifier use:
testset = ActionOrNot(type0_pathname=inputdir_type0,
type1_pathname=inputdir_type1)
loader = torch.utils.data.DataLoader(testset,
batch_size=batch_size,
shuffle=False,
pin_memory=True,
num_workers=num_workers)
print('Testing %d image examples..' % len(testset))
if subset is not None:
type1 = np.asarray(testset.inds_type1_examples) # all pos
type0 = np.random.choice(testset.inds_type0_examples,
subset) # subset neg
loader = torch.utils.data.DataLoader(
testset,
batch_size=batch_size,
sampler=torch.utils.data.sampler.SubsetRandomSampler(
np.concatenate((type1, type0))),
shuffle=False,
pin_memory=True,
num_workers=num_workers)
test_loss, test_acc, test_auc, misc = run_epoch(epoch=1,
loader=loader,
optimizer=None,
model=model,
criterion=criterion,
device=device,
prefix='Testing')
test_total_outputs_class, test_total_gt_labels, test_total_filenames = misc[
0], misc[1], misc[2]
filename = os.path.join(outname, 'misclassifications_{}'.format(basename))
eval_model(test_total_outputs_class,
test_total_gt_labels,
test_total_filenames,
outname=filename,
num_examples_to_plot=num_examples_to_plot)
def evaluate(net, batch_size=64, experiment_dir=None, num_videos=10):
writer = SummaryWriter(experiment_dir)
anns_path = "data/v0.3.1-anns-5sec.csv"
train_data_loader, val_data_loader = get_train_val_data_loaders(anns_path, batch_size)
criterion = nn.BCELoss()
optimizer = None
print(set(list(train_data_loader.dataset.df['video_name'])))
print(set(list(val_data_loader.dataset.df['video_name'])))
net.eval()
val_accuracy, y_true, y_score, results = run_epoch(val_data_loader, net, optimizer, criterion, 0)
df = pd.DataFrame(results)
print(df)
save_results(results, '', 0)
def main():
# Carregar os dados de treinamento e teste
# X: SOC SPKF, KPI BA, KPI BR, KPI TA, KPI TR
# Y: SOC REAL
num_classes = 10
X_train = np.loadtxt('../Datasets/x45.txt')
y_train = np.loadtxt('../Datasets/y45.txt')
X_test = np.loadtxt('../Datasets/x45.txt')
y_test = np.loadtxt('../Datasets/y45.txt')
##############################################################################
# Vetores do eixo x para plotar os gráficos
time_train = len(y_train) + 1
train = np.arange(1, time_train, 1)
time_test = len(y_test) + 1
test = np.arange(1, time_test, 1)
# Plotando os dados y de treinamento e teste de entrada da Rede Neural
plt.plot(train, y_train, 'r', label='train')
plt.plot(test, y_test, 'b', label='test')
plt.title('Neural Networks Output')
plt.ylabel('SOC')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
# Plotando os dados X de treinamento de entrada da Rede Neural
plt.plot(train, X_train[:,0], 'b', label='train')
plt.plot(train, X_train, 'b', label='train')
plt.title('Neural Networks Input')
plt.ylabel('SOC')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
plt.plot(train, X_train[:,1], 'r', label='Aggression train')
plt.plot(train, X_train[:,2], 'b', label='Release train')
plt.title('Neural Networks Input')
plt.ylabel('Brake KPI')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
plt.plot(train, X_train[:,3], 'r', label='Aggression train')
plt.plot(train, X_train[:,4], 'b', label='Release train')
plt.title('Neural Networks Input')
plt.ylabel('Throttle KPI')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
# Plotando os dados X de teste de entrada da Rede Neural
plt.plot(test, X_test[:,0], 'b', label='test')
plt.title('Neural Networks Input')
plt.ylabel('SOC')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
plt.plot(test, X_test[:,1], 'r', label='Aggression test')
plt.plot(test, X_test[:,2], 'b', label='Release test')
plt.title('Neural Networks Input')
plt.ylabel('Brake KPI')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
plt.plot(test, X_test[:,3], 'r', label='Aggression test')
plt.plot(test, X_test[:,4], 'b', label='Release test')
plt.title('Neural Networks Input')
plt.ylabel('Throttle KPI')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
##############################################################################
# Dividir os dados de treinamento em validação (10%) e treinamento (90%)
dev_split_index = int(9 * len(X_train) / 10)
X_val = X_train[dev_split_index:]
y_val = y_train[dev_split_index:]
X_train = X_train[:dev_split_index]
y_train = y_train[:dev_split_index]
# Randomizar os dados de treinamento para inserir na rede
# permutation = np.array([i for i in range(len(X_train))])
# np.random.shuffle(permutation) #MODIFICAR
# X_train = [X_train[i] for i in permutation]
# y_train = [y_train[i] for i in permutation]
# Dividindo os dados em batches para o treinamento
batch_size_train = 8
batch_size_test = 1
train_batches = batchify_data(X_train, y_train, batch_size_train)
val_batches = batchify_data(X_val, y_val, batch_size_train)
test_batches = batchify_data(X_test, y_test, batch_size_test)
##############################################################################
# Definindo modelo sequencial da Rede Neural Artifical Profunda
model = nn.Sequential(
nn.Linear(5, 10),
nn.Hardtanh(),
nn.Linear(10, 10), #hidden layer 1
nn.Hardtanh(),
nn.Linear(10, 1),
)
lr=0.05
momentum=0
##############################################################################
# Treinando o modelo com os batches de validação e treinamento no modelo
train_model(train_batches, val_batches, model, lr=lr, momentum=momentum)
# Validando o modelo com os dados de teste UDDS A123 a 25°C
# Calculando loss, error, accuracy e SOC estimado do modelo
loss, accuracy, error, sochat = run_epoch(test_batches, model.eval(), None)
print ("Loss on test set:" + str(loss) + " Accuracy on test set: " + str(accuracy))
loss_spkf, accuracy_spkf, error_spkf = spkf_parameters(X_test[:,0], y_test)
print ("Loss on SPKF set:" + str(loss_spkf) + " Accuracy on SPKF set: " + str(accuracy_spkf))
sochat = np.concatenate( sochat, axis=0 )
##############################################################################
# Plotando os resultados da Rede Neural Artificial Profunda
plt.plot(range(len(error)), error)
plt.ylabel('Lost Function')
plt.xlabel('Iteration number')
plt.show()
plt.plot(range(len(error)), sochat)
plt.ylabel('SOC Function')
plt.xlabel('Iteration number')
plt.show()
#plt.plot(range(len(test)), y_test, 'r', label='Real SOC')
plt.plot(range(len(y_test)), y_test, 'r', label='Real SOC')
#plt.plot(range(len(test)), sochat, 'b', label='ANN SOC Estimator')
plt.plot(range(len(sochat)), sochat, 'b', label='ANN SOC Estimator')
#plt.plot(range(len(test)), X_test[:,0], 'g', label='SPKF SOC Estimator')
plt.plot(range(len(y_test)), X_test[:,0], 'g', label='SPKF SOC Estimator')
plt.title('Neural Networks Output')
plt.ylabel('SOC')
plt.xlabel('time')
plt.legend(framealpha=1, frameon=True);
plt.show()
plt.plot(range(len(error)), sochat)
plt.ylabel('SOC Function')
plt.xlabel('Iteration number')
plt.show()
sort_key=lambda x: (len(x.src), len(x.trg)),
batch_size_fn=batch_size_fn,
train=True)
valid_iter = MyIterator(val,
batch_size=BATCH_SIZE,
device=0,
repeat=False,
sort_key=lambda x: (len(x.src), len(x.trg)),
batch_size_fn=batch_size_fn,
train=False)
model_par = nn.DataParallel(model, device_ids=devices)
model_opt = NoamOpt(
model.src_emb[0].d_model, 1, 2000,
torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98),
eps=1e-9))
for epoch in range(10):
model_par.train()
run_epoch((rebatch(pad_idx, b) for b in train_iter), model_par,
MultiGPULossCompute(model.generator,
criterion,
devices=devices,
opt=None))
model_par.eval()
loss = run_epoch((rebatch(pad_idx, b) for b in valid_iter), model_par,
MultiGPULossCompute(model.generator,
criterion,
devices=devices,
opt=None))
print(loss)
torch.optim.Adam(
model.parameters(),
lr = 0,
betas = (0.9, 0.98),
eps = 1e-9
)
)
for epoch in range(10):
model.train()
run_epoch(
data_gen(
V, 30, 20
),
model,
SimpleLossCompute(
model.generator,
criterion,
model_opt
)
)
model.eval()
print(
run_epoch(
data_gen(
V,
30,
5
),
model,
SimpleLossCompute(
train.source_w2i, train.source_i2w = train.load_vocabs(config.source_vocab_path)
train.target_w2i, train.target_i2w = train.load_vocabs(config.target_vocab_path)
config.source_vocab_size = len(train.source_w2i)
config.target_vocab_size = len(train.target_w2i)
source_test = train.read_docs_to_seqs(config.source_test_path, train.source_w2i)
target_test = train.read_docs_to_seqs(config.target_test_path, train.target_w2i)
test_pairs = [(s_seq, t_seq) for s_seq, t_seq in zip(source_test, target_test)]
source_batch, source_lengths, target_batch, target_lengths = train.get_batch(test_pairs, None)
encoder = torch.load(checkpoint_path+"/encoder.model.iter"+str(iter_num)+".pth")
decoder = torch.load(checkpoint_path+"/decoder.model.iter"+str(iter_num)+".pth")
precision, preds = train.run_epoch(source_batch, source_lengths, target_batch, target_lengths, encoder, decoder, TRAIN=False)
print precision
fout = open("predict.result","w")
for i in range(len(preds)):
fout.write(" ".join([train.source_i2w[j] for j in source_test[i]])+"\n")
fout.write(" ".join([train.target_i2w[j] for j in target_test[i]])+"\n")
fout.write(" ".join([train.target_i2w[j] for j in preds[i]])+"\n")
fout.write(str(preds[i] == target_test[i])+"\n")
fout.write("\n")
fout.close()
def train_model(config, verbose=True):
print("\nLoading training data ...")
train_data, valid_data = load_train_valid_data(config, verbose)
if config.start_date is not None:
print("Training start date: ", config.start_date)
if config.start_date is not None:
print("Training end date: ", config.end_date)
tf_config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False,
device_count={'GPU': 0})
with tf.Graph().as_default(), tf.Session(config=tf_config) as session:
if config.seed is not None:
tf.set_random_seed(config.seed)
print("\nConstructing model ...")
model = model_utils.get_model(session, config, verbose=verbose)
if config.data_scaler is not None:
start_time = time.time()
print("Calculating scaling parameters ...", end=' ')
sys.stdout.flush()
scaling_params = train_data.get_scaling_params(config.data_scaler)
model.set_scaling_params(session, **scaling_params)
print("done in %.2f seconds." % (time.time() - start_time))
if config.early_stop is not None:
print("Training will early stop without "
"improvement after %d epochs." % config.early_stop)
train_history = list()
valid_history = list()
lr = model.set_learning_rate(session, config.learning_rate)
train_data.cache(verbose=verbose)
valid_data.cache(verbose=verbose)
for i in range(config.max_epoch):
(train_mse, valid_mse) = run_epoch(session,
model,
train_data,
valid_data,
keep_prob=config.keep_prob,
passes=config.passes,
verbose=verbose)
if verbose:
print(('Epoch: %d Train MSE: %.6f Valid MSE: %.6f Learning'
'rate: %.4f') % (i + 1, train_mse, valid_mse, lr))
sys.stdout.flush()
train_history.append(train_mse)
valid_history.append(valid_mse)
if re.match("Gradient|Momentum", config.optimizer):
lr = model_utils.adjust_learning_rate(session, model, lr,
config.lr_decay,
train_history)
return train_history, valid_history
raise ValueError("Requested optimizer not recognized:", params.optimizer)
scheduler = lr_scheduler.StepLR(
optimizer,
step_size=20,
gamma=0.5)
time_train_start = time.time()
for epoch in range(params.num_epochs):
for phase in ['train', 'val']:
epoch_loss = run_epoch(
params=params,
phase=phase,
num_batches=params.steps_per_epoch,
model=model,
optimizer=optimizer,
scheduler=scheduler,
dataloader=dataloader[phase],
device=device)
dates = time.localtime()
datestring = "-".join([str(dates.tm_year), str(dates.tm_mon), str(dates.tm_mday)])
timestring = ":".join([str(dates.tm_hour), str(dates.tm_min), str(dates.tm_min)])
plotter.plot(var_name='loss over epoch',
split_name=phase,
title_name='loss over epoch',
x=epoch,
y=epoch_loss)
if __name__ == '__main__':
window_size = 40
batch_size = 512
text = load_file('../data/horoscope_2011.csv')
text_idx, itos, stoi = preprocess_data(text)
vocab_size = len(itos)
src, tgt = make_arrays(text_idx, window_size)
criterion = LabelSmoothing(size=vocab_size, padding_idx=0, smoothing=0.1)
model = make_model(vocab_size, vocab_size, N=2)
model_opt = NoamOpt(
model.src_embed[0].d_model, 1, 400,
torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98),
eps=1e-9))
for epoch in range(10):
model.train()
run_epoch(batch_generator(src, tgt, batch_size), model,
SimpleLossCompute(model.generator, criterion, model_opt))
# BOS_WORD = '<s>'
# EOS_WORD = '</s>'
# BLANK_WORD = '<blank>'
# SRC = data.Field(
# sequential = True,
# tokenize = tokenize_en,
# lower = True,
# pad_token = BLANK_WORD
# )
# TGT = data.Field(
# sequential = True,
# tokenize = tokenize_en,
# lower = True,
# init_token = BOS_WORD,
