def train(device, dataset, dataloader, model):
print("in train")
model = model.to(device)
model.train()
optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)
# Training loop
images_per_batch = {}
batch_count, images_per_batch['train'], images_per_batch[
'test'] = 0, [], []
with tqdm(dataloader, total=config.num_batches) as pbar:
for batch_idx, batch in enumerate(pbar):
model.zero_grad()
train_inputs, train_targets = batch['train']
train_inputs = train_inputs.to(device=device)
train_targets = train_targets.to(device=device)
train_embeddings = model(train_inputs)
test_inputs, test_targets = batch['test']
test_inputs = test_inputs.to(device=device)
test_targets = test_targets.to(device=device)
test_embeddings = model(test_inputs)
prototypes = get_prototypes(train_embeddings, train_targets,
dataset.num_classes_per_task)
loss = prototypical_loss(prototypes, test_embeddings, test_targets)
loss.backward()
optimizer.step()
#Just keeping the count here
batch_count += 1
images_per_batch['train'].append(train_inputs.shape[1])
images_per_batch['test'].append(test_inputs.shape[1])
with torch.no_grad():
accuracy = get_accuracy(prototypes, test_embeddings,
test_targets)
pbar.set_postfix(accuracy='{0:.4f}'.format(accuracy.item()))
if batch_idx >= config.num_batches:
break
print("Number of batches in the dataloader: ", batch_count)
# Save model
if check_dir() is not None:
filename = os.path.join(
'saved_models',
'protonet_cifar_fs_{0}shot_{1}way.pt'.format(config.k, config.n))
with open(filename, 'wb') as f:
state_dict = model.state_dict()
torch.save(state_dict, f)
print("Model saved")
return batch_count, images_per_batch
def test_model(cfg, model=None, to_file=False):
if to_file and os.path.exists('./results.txt'):
os.remove('./results.txt')
transforms = build_transforms(is_train=False)
data_loader = build_data_loader(cfg.dataset,
1,
cfg.workers,
transforms,
is_train=False)
if model is None:
model = build_model(data_loader.dataset.num_of_classes)
model = model.to(device)
load_dict(cfg, model, cfg.load_name)
model.eval()
running_loss, running_corrects, running_all, running_all_correct = 0., 0., 0., 0.
with torch.no_grad():
running_loss, running_corrects, running_all, running_all_correct = 0., 0., 0., 0.
for batch_idx, (data, targets,
target_lengths) in enumerate(data_loader):
data = data.to(device)
target_lengths = target_lengths.to(device)
predicted = model(data)
loss = loss_calculation(predicted,
torch.cat(targets, dim=0).to(device),
target_lengths)
running_loss += loss.item() * data.size(0)
running_corrects += get_accuracy(predicted, targets,
data_loader.dataset.ind_to_class,
to_file)
running_all_correct += torch.sum(target_lengths).item()
#print('sum : ', running_all_correct)
if to_file:
# print(data.cpu().numpy().squeeze().transpose(1,2,0))
# print(data.cpu()*255)
# torchvision.utils.save_image(data.cpu()*255, './test/{}.jpg'.format(batch_idx))
cv2.imwrite(
'./test/{}.jpg'.format(batch_idx),
data.cpu().numpy().squeeze().transpose(1, 2, 0) * 255)
running_all += len(data)
if batch_idx == 0:
since = time.time()
elif (batch_idx == len(data_loader) -
1): #batch_idx % cfg.interval == 0 or
print(
'Process: [{:5.0f}/{:5.0f} ({:.0f}%)]\tLoss: {:.4f}\tAcc:{:.4f}\tCost time:{:5.0f}s\tEstimated time:{:5.0f}s\r'
.format(running_all, len(data_loader.dataset),
100. * batch_idx / (len(data_loader) - 1),
running_loss / running_all,
running_corrects / running_all_correct,
time.time() - since, (time.time() - since) *
(len(data_loader) - 1) / batch_idx -
(time.time() - since))),
return running_corrects / running_all_correct
def train_model(cfg):
transforms = build_transforms(is_train=True)
data_loader = build_data_loader(cfg.dataset,
cfg.batch_size,
cfg.workers,
transforms,
is_train=True)
model = build_model(data_loader.dataset.num_of_classes)
model = model.to(device)
model.train()
optimizer = get_optimizer(cfg, model)
if cfg.start_epoch > 0:
load_dict(cfg, model, cfg.start_epoch - 1, optimizer)
best_accu = 0.
for epoch in range(cfg.start_epoch, cfg.epochs):
model.train()
running_loss, running_corrects, running_all, running_all_correct = 0., 0., 0., 0.
for batch_idx, (data, targets,
target_lengths) in enumerate(data_loader):
data = data.to(device)
target_lengths = target_lengths.to(device)
predicted = model(data)
loss = loss_calculation(predicted,
torch.cat(targets, dim=0).to(device),
target_lengths)
optimizer.zero_grad()
loss.backward()
optimizer.step()
with torch.no_grad():
running_loss += loss.item() * data.size(0)
running_corrects += get_accuracy(
predicted, targets, data_loader.dataset.ind_to_class)
running_all_correct += torch.sum(target_lengths).item()
#print('sum : ', running_all_correct)
running_all += len(data)
if batch_idx == 0:
since = time.time()
elif batch_idx % cfg.interval == 0 or (batch_idx
== len(data_loader) - 1):
print(
'Process: [epoch {} {:5.0f}/{:5.0f} ({:.0f}%)]\tLoss: {:.4f}\tAcc:{:.4f}\tCost time:{:5.0f}s\tEstimated time:{:5.0f}s\r'
.format(epoch, running_all, len(data_loader.dataset),
100. * batch_idx / (len(data_loader) - 1),
running_loss / running_all,
running_corrects / running_all_correct,
time.time() - since, (time.time() - since) *
(len(data_loader) - 1) / batch_idx -
(time.time() - since))),
val_accu = test_model(cfg, model)
if val_accu > best_accu:
best_accu = val_accu
save_state(cfg, model, optimizer, 'best', best_accu)
save_state(cfg, model, optimizer, cfg.epochs, val_accu)
def main():
if len(sys.argv) != 7:
print(
"Usage: {0} <data directory> <hidden layer size> <min song length> <steps> <epochs> <batch_size>"
.format(sys.argv[0]))
exit(2)
path = sys.argv[1]
hidden_size = int(sys.argv[2])
min_len = int(sys.argv[3])
steps = int(sys.argv[4])
epochs = int(sys.argv[5])
batch_size = int(sys.argv[6])
all_songs = get_songs(path)
print('Preprocessed Songs')
total_songs = len(all_songs)
input_size = all_songs[0].shape[1]
output_size = input_size
rnn_units = hidden_size
learning_rate = 0.001
keep_probability = 0.6
disp = 1
print(total_songs, input_size)
print(all_songs[0].shape)
model_inputs, model_targets, keep_prob, lr = model_placeholders(
input_size, output_size, steps)
parameters = model_parameters(output_size, hidden_size) #w1, b1
final_outputs, prediction = rnn_layer(model_inputs, parameters, rnn_units,
keep_prob, steps)
loss = get_loss(final_outputs, model_targets)
optimizer = get_optimizer(loss, lr)
accuracy = get_accuracy(model_targets, prediction)
init = tf.global_variables_initializer()
session = tf.Session()
print('Start Training')
with session as sess:
sess.run(init)
for epoch in range(epochs):
inputs, targets = generate_batches(all_songs, batch_size, steps,
input_size, output_size)
feed_dict = {
model_inputs: inputs,
model_targets: targets,
keep_prob: keep_probability,
lr: learning_rate
}
sess.run(optimizer, feed_dict=feed_dict)
if epoch % disp == 0 or epoch == 10:
l, a = sess.run([loss, accuracy], feed_dict=feed_dict)
s = 'Epoch: {}, Loss: {:.4f}, Accuracy: {:.3f} \n'.format(
epoch, l, a)
logger(epoch, epochs, s=s)
# Generate new midi files
get_random = False
idx = 11 if get_random else np.random.randint(total_songs)
song = all_songs[idx][:steps].tolist()
print('Sampling new music')
for i in range(100):
initial = np.array([song[-steps]])
sample = sess.run(prediction, feed_dict={model_inputs, initial})
new_songs = sample_music(sample, output_size, song)
sample_midi(new_songs, name='gen_1')
sample_midi(all_songs[idx], name='base_1')
image_train, label_train = getdata.get_batch(image_queue,
label_queue,
train_size,
capacity=100,
min_after_dequeue=50)
with tf.name_scope('data_test'):
image_test, label_test = getdata.get_batch(image_queue,
label_queue,
test_size,
capacity=500,
min_after_dequeue=50)
# 构建神经网络
pretiction = model.get_prediction(image_placeholder)
train_step = model.get_train_step(pretiction, label_placeholder)
accuracy = model.get_accuracy(pretiction, label_placeholder)
# 创建保存器
saver = tf.train.Saver()
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
# 开启训练批队列进程
threads = tf.train.start_queue_runners(sess=sess)
# 打包程序中所有的结构
merged = tf.summary.merge_all()
# 创建tensorboard文件
writer = tf.summary.FileWriter('logs/', sess.graph) # 'logs/'为目标event文件路径
