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文件路径