def test(): ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1) o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) o.load_weights('chpt_1700.ckpt') print('recovery data') out = o(ims, labels) with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) #set_trace() i, l = data_generator.sample_batch('train', 100) feed = {ims: i.astype(np.float32), labels: l.astype(np.float32)} pred = sess.run([out], feed) pred = pred[0] #pred = pred.reshape( # -1, FLAGS.num_samples + 1, # FLAGS.num_classes, FLAGS.num_classes) pred = pred[:, -1, :, :].argmax(2) l = l[:, -1, :, :].argmax(2) print("Test Accuracy", (1.0 * (pred == l)).mean())
def train(model, fd_classifier, dataset_path, img_dim, split, epochs, batch_size): try: gen = DataGenerator(dataset_path) data, labels = gen.get_images(img_dim, fd_classifier) # split them manually split = int(len(data) * split / 100) train_x, test_x = data[:split], data[split:] train_y, test_y = labels[:split], labels[split:] lb = LabelBinarizer() train_y = lb.fit_transform(train_y) test_y = lb.transform(test_y) # TODO: PNG problem # train model train_x = np.array(train_x) train_y = np.array(train_y) test_x = np.array(test_x) test_y = np.array(test_y) return lb, model.fit(train_x, train_y, test_x, test_y, epochs, batch_size) except Exception as e: print(e)
def train(): datagenerator = DataGenerator(number_classes, number_samples_xclass) print('Start training') for step in range(50000): _imgs, _labels = datagenerator.sample_batch('train', batch_size) _imgs_tensor, _labels_tensor = torch.tensor(_imgs, dtype=torch.float32, device=device), torch.tensor(_labels, dtype=torch.float32, device=device) output = model(_imgs_tensor, _labels_tensor) optimizer.zero_grad() loss = compute_loss(output, _labels_tensor) loss.backward() optimizer.step() if step%50 == 0: set_trace() _imgs, _labels = datagenerator.sample_batch('test', 100) _imgs_tensor, _labels_tensor = torch.tensor(_imgs, dtype=torch.float32, device=device), torch.tensor(_labels, dtype=torch.float32, device=device) with torch.no_grad(): output_t = model(_imgs_tensor, _labels_tensor) pred_lbls = np.asarray(output_t[:, -1, :,:].argmax(2).to('cpu')) _labels_tn = _labels[:,-1,:,:].argmax(2) accuracy = (_labels_tn == pred_lbls).mean() print('accuracy ->\t{}'.format(accuracy))
def train_with_data_generator(dataset_root_dir=GAN_DATA_ROOT_DIR, weights_file=None): net_name = 'o_net' batch_size = BATCH_SIZE epochs = ONET_EPOCHS learning_rate = ONET_LEARNING_RATE dataset_dir = os.path.join(dataset_root_dir, net_name) pos_dataset_path = os.path.join(dataset_dir, 'pos_shuffle.h5') neg_dataset_path = os.path.join(dataset_dir, 'neg_shuffle.h5') part_dataset_path = os.path.join(dataset_dir, 'part_shuffle.h5') landmarks_dataset_path = os.path.join(dataset_dir, 'landmarks_shuffle.h5') data_generator = DataGenerator(pos_dataset_path, neg_dataset_path, part_dataset_path, landmarks_dataset_path, batch_size, im_size=NET_SIZE['o_net']) data_gen = data_generator.generate() steps_per_epoch = data_generator.steps_per_epoch() callbacks, model_file = create_callbacks_model_file(net_name, epochs) _o_net = train_o_net_with_data_generator(data_gen, steps_per_epoch, initial_epoch=0, epochs=epochs, lr=learning_rate, callbacks=callbacks, weights_file=weights_file) _o_net.save_weights(model_file)
def train_with_data_generator(dataset_root_dir=GAN_DATA_ROOT_DIR, model_file=model_file, weights_file=None): batch_size = 64 * 7 epochs = 30 learning_rate = 0.001 pos_dataset_path = os.path.join(dataset_root_dir, 'pos_shuffle_%s.h5' % (net_name)) neg_dataset_path = os.path.join(dataset_root_dir, 'neg_shuffle_%s.h5' % (net_name)) part_dataset_path = os.path.join(dataset_root_dir, 'part_shuffle_%s.h5' % (net_name)) landmarks_dataset_path = os.path.join( dataset_root_dir, 'landmarks_shuffle_%s.h5' % (net_name)) data_generator = DataGenerator(pos_dataset_path, neg_dataset_path, part_dataset_path, landmarks_dataset_path, batch_size, im_size=12) data_gen = data_generator.generate() steps_per_epoch = data_generator.steps_per_epoch() if net_name == 'Pnet': _net = Pnet() elif net_name == 'Rnet': _net = Rnet() else: _net = Onet() _net_model = _net.model(training=True) _net_model.summary() if weights_file is not None: _net_model.load_weights(weights_file) #sgd = SGD(lr=0.005, momentum=0.8) #_p_net_model.compile(optimizer=sgd, loss=_p_net.loss_func, metrics=[_p_net.accuracy, _p_net.recall]) _net_model.compile(Adam(lr=learning_rate), loss=_net.loss_func, metrics=[_net.accuracy, _net.recall]) _net_model.fit_generator(data_gen, steps_per_epoch=steps_per_epoch, initial_epoch=0, epochs=epochs) _net_model.save_weights(model_file)
def main(): filepath = os.path.dirname(os.path.abspath(__file__)) dataset_root_dir = filepath + '/data/traindata/' pos_dataset_path = os.path.join(dataset_root_dir, 'pos_shuffle.h5') neg_dataset_path = os.path.join(dataset_root_dir, 'neg_shuffle.h5') part_dataset_path = os.path.join(dataset_root_dir, 'part_shuffle.h5') landmarks_dataset_path = os.path.join(dataset_root_dir, 'landmarks_shuffle.h5') data_generator = DataGenerator(pos_dataset_path, neg_dataset_path, part_dataset_path, landmarks_dataset_path, 64*7, im_size=12) data_gen = data_generator.generate() for item in data_gen: print(item[1][:,:1]) exit(0)
def main(): if FLAGS.meta_train == False: orig_meta_batch_size = FLAGS.meta_batch_size # always use meta batch size of 1 when testing. FLAGS.meta_batch_size = 1 # call data_generator and get data with FLAGS.k_shot*2 samples per class data_generator = DataGenerator(FLAGS.n_way, FLAGS.k_shot*2, FLAGS.n_way, FLAGS.k_shot*2, config={'data_folder': FLAGS.data_path}) # set up MAML model dim_output = data_generator.dim_output dim_input = data_generator.dim_input meta_test_num_inner_updates = FLAGS.meta_test_num_inner_updates model = MAML(dim_input, dim_output, meta_test_num_inner_updates=meta_test_num_inner_updates, learn_inner_lr=FLAGS.learn_inner_update_lr) model.construct_model(prefix='maml') model.summ_op = tf.summary.merge_all() saver = loader = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES), max_to_keep=10) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth=True sess = tf.InteractiveSession(config=tf_config) if FLAGS.meta_train == False: # change to original meta batch size when loading model. FLAGS.meta_batch_size = orig_meta_batch_size if FLAGS.meta_train_k_shot == -1: FLAGS.meta_train_k_shot = FLAGS.k_shot if FLAGS.meta_train_inner_update_lr == -1: FLAGS.meta_train_inner_update_lr = FLAGS.inner_update_lr exp_string = 'cls_'+str(FLAGS.n_way)+'.mbs_'+str(FLAGS.meta_batch_size) + '.k_shot_' + str(FLAGS.meta_train_k_shot) + '.inner_numstep' + str(FLAGS.num_inner_updates) + '.inner_updatelr' + str(FLAGS.meta_train_inner_update_lr) if FLAGS.learn_inner_update_lr: exp_string += ".learn_inner_lr" resume_itr = 0 model_file = None tf.global_variables_initializer().run() if FLAGS.resume or not FLAGS.meta_train: model_file = tf.train.latest_checkpoint(FLAGS.logdir + '/' + exp_string) if FLAGS.meta_test_iter > 0: model_file = model_file[:model_file.index('model')] + 'model' + str(FLAGS.meta_test_iter) if model_file: ind1 = model_file.index('model') resume_itr = int(model_file[ind1+5:]) print("Restoring model weights from " + model_file) saver.restore(sess, model_file) if FLAGS.meta_train: meta_train(model, saver, sess, exp_string, data_generator, resume_itr) else: FLAGS.meta_batch_size = 1 meta_test(model, saver, sess, exp_string, data_generator, meta_test_num_inner_updates)
def training_val(train_information, val_information, num_au_labels, val_ratio, num_epochs, batch_size, img_cols, img_rows): # load data folders params = { 'batch_size': batch_size, 'img_cols': img_cols, 'img_rows': img_rows, 'num_au_labels': num_au_labels, 'shuffle': True } training_generator = DataGenerator(train_information, **params) validation_generator = DataGenerator(val_information, **params) patience = 20 model = DRML((img_cols, img_rows, 3), num_au_labels) model.summary() adam = Adam(lr=0.001) model.compile(optimizer=adam, loss='binary_crossentropy', metrics=[ f1_threshold(0.8, 10), multi_label_accuracy_threshold(0.8, 10), f1_threshold(0.5, 10), multi_label_accuracy_threshold(0.5, 10) ]) model.fit_generator( generator=training_generator, epochs=num_epochs, verbose=1, validation_data=validation_generator, callbacks=[ EarlyStopping(patience=patience), ModelCheckpoint( "train_model/DRML_{epoch:03d}-{val_multi_label_accuracy:.5f}.hdf5", save_best_only=True) ]) # evaluation validation data evaluation_val_data(val_information, batch_size, model, img_cols, img_rows, 0.8) evaluation_val_data(val_information, batch_size, model, img_cols, img_rows, 0.5)
def train(): ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1) o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) out = o(ims, labels) loss = loss_function(out, labels) optim = tf.train.AdamOptimizer(0.001) optimizer_step = optim.minimize(loss) checkpoint_path = 'chpt_{}.ckpt' with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) for step in range(50000): i, l = data_generator.sample_batch('train', FLAGS.meta_batch_size) feed = {ims: i.astype(np.float32), labels: l.astype(np.float32)} _, ls = sess.run([optimizer_step, loss], feed) if step % 100 == 0: print("*" * 5 + "Iter " + str(step) + "*" * 5) i, l = data_generator.sample_batch('test', 100) feed = { ims: i.astype(np.float32), labels: l.astype(np.float32) } pred, tls = sess.run([out, loss], feed) print("Train Loss:", ls, "Test Loss:", tls) pred = pred.reshape(-1, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes) pred = pred[:, -1, :, :].argmax(2) l = l[:, -1, :, :].argmax(2) print("Test Accuracy", (1.0 * (pred == l)).mean()) o.save_weights(checkpoint_path.format(step))
def main(epochs=100): params = { "faces_dir": "data/orl_faces", "cifar_file": "data/cifar_10/data_batch_1" } dg = DataGenerator(**params) gen = dg.batch() X = tf.placeholder(tf.float32, [None, 32, 32]) Y = tf.placeholder(tf.float32, [None, 2]) optimizer, cost, acc, probs = model.small_model(X, Y) steps = int(np.ceil(dg.X.shape[0] / dg.batch_size) * epochs) init = tf.global_variables_initializer() saver = tf.train.Saver() with tf.Session() as sess: sess.run(init) s = time.time() for i in range(steps): X_batch, Y_batch = next( gen ) #np.concatenate((np.ones((1,250,250)),np.zeros((1,250,250)))), [[0,1],[1,0]] #update params p, c, a = sess.run([optimizer, cost, acc], feed_dict={ X: X_batch, Y: Y_batch }) print("Step %d Cost %f Accuracy %f" % (steps, c, a)) #evaluate performance if i % 10 == 0: X_eval, Y_eval = dg.eval() eval_a = sess.run([acc], feed_dict={X: X_batch, Y: Y_batch}) print("Eval Accuracy %f" % eval_a[0]) print("Time %f" % (time.time() - s)) saver.save(sess, "models/small/model.ckpt")
x = self.conv3(x) x = nn.functional.leaky_relu(x) x = self.conv4(x) x = nn.functional.leaky_relu(x) x = self.conv5(x) x = nn.functional.leaky_relu(x) x = self.conv6(x) x = nn.functional.leaky_relu(x) x = self.conv7(x) x = nn.functional.leaky_relu(x) x = self.conv8(x) x = self.act_fn(x) return x data_generator = DataGenerator(latent_dim) criterion = nn.BCELoss() real_label = 1 fake_label = 0 netG = Generator().to(device) print(netG) netD = Discriminator().to(device) print(netD) net2D = Discriminator2D().to(device) print(net2D) optimizerD = optim.Adam(netD.parameters(), lr=0.0002, betas=(0.5, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=0.0002, betas=(0.5, 0.999)) optimizer2D = optim.Adam(net2D.parameters(), lr=0.0002, betas=(0.5, 0.999))
""" ############################# #### YOUR CODE GOES HERE #### pass ############################# return out ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1, {'data_folder': FLAGS.data_root}) o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) out = o(ims, labels) loss = loss_function(out, labels) optim = tf.train.AdamOptimizer(0.001) optimizer_step = optim.minimize(loss) with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) for step in range(50000): i, l = data_generator.sample_batch('train', FLAGS.meta_batch_size) feed = {ims: i.astype(np.float32), labels: l.astype(np.float32)}
y, h = self.dense4(y) y, h = self.dense5(y) y = self.dense6(y) y = torch.reshape(y, (batch_size, rf, pose_dim)) if to_print: print("Y IS: " + str(y)) x = x + y return x gen = Generator().to(device) gen.load_state_dict(torch.load(chkpt_path)) gen.eval() from load_data import DataGenerator data_generator = DataGenerator(latent_dim) latent_sample, real_sample = data_generator.sample_depth_batch( 'discriminator', batch_size, rf) #latent_sample = torch.from_numpy(latent_sample).float().to(device) real_sample = torch.from_numpy(real_sample[:, 10, :]).float().to(device) fake = gen(real_sample, False).detach().cpu().numpy() real_sample = real_sample.unsqueeze(1).detach().cpu().numpy() for i in range(batch_size): print("MAKING VIDEO " + str(i)) render_3d_animation(np.expand_dims(real_sample[i], axis=0), ('boneconvdepthreal_{}.mp4').format(i), depth=True, limit=1) render_3d_animation(np.expand_dims(fake[i], axis=0), ('boneconvdepthsampled_{}.mp4').format(i), depth=True,
num_classes, num_support = x_shape[0], x_shape[1] num_queries = q_shape[1] labels_ph = tf.placeholder(tf.float32, [None, None, None]) model = ProtoNet([num_filters]*num_conv_layers, latent_dim) x_latent = model(tf.reshape(x, [-1, im_height, im_width, channels])) q_latent = model(tf.reshape(q, [-1, im_height, im_width, channels])) ce_loss, acc = ProtoLoss(x_latent, q_latent, labels_ph, num_classes, num_support, num_queries) train_op = tf.train.AdamOptimizer().minimize(ce_loss) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth=True sess = tf.InteractiveSession(config=tf_config) init_op = tf.global_variables_initializer() sess.run(init_op) # call DataGenerator with k_shot+n_query samples per class data_generator = DataGenerator(n_way, k_shot+n_query, n_meta_test_way, k_meta_test_shot+n_meta_test_query, config={'data_folder': args.data_path}) for ep in range(n_epochs): for epi in range(n_episodes): ############################# #### YOUR CODE GOES HERE #### # sample a batch of training data and partition into # support and query sets inputs, labels = data_generator.sample_batch('meta_train', batch_size=1, swap=False, shuffle=False) support, query, labels = split_sampled_dataset(inputs, labels) # print(support.shape) # print(query.shape) # print(labels.shape) # support, query, labels = None, None, None
num_classes, num_support = x_shape[0], x_shape[1] num_queries = q_shape[1] labels_ph = tf.placeholder(tf.float32, [None, None, None]) model = ProtoNet([num_filters]*num_conv_layers, latent_dim) x_latent = model(tf.reshape(x, [-1, im_height, im_width, channels])) q_latent = model(tf.reshape(q, [-1, im_height, im_width, channels])) ce_loss, acc = ProtoLoss(x_latent, q_latent, labels_ph, num_classes, num_support, num_queries) train_op = tf.train.AdamOptimizer().minimize(ce_loss) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth=True sess = tf.InteractiveSession(config=tf_config) init_op = tf.global_variables_initializer() sess.run(init_op) # call DataGenerator with k_shot+n_query samples per class data_generator = DataGenerator(n_way, k_shot+n_query, n_meta_test_way, k_meta_test_shot+n_meta_test_query, config={'data_folder': args.data_path}) for ep in range(n_epochs): for epi in range(n_episodes): ############################# #### YOUR CODE GOES HERE #### # sample a batch of training data and partition into # support and query sets # support, query, labels = None, None, None images_batch, labels_batch = data_generator.sample_batch('meta_train', 1) support = images_batch[0, :, :k_shot, :].reshape((n_way, k_shot, im_width, im_height, channels)) query = images_batch[0, :, k_shot:, :].reshape((n_way, n_query, im_width, im_height, channels))
decay=0.0, amsgrad=True) batch_size = 20 epochs = 1000 leave_dataset_index = 3 map_index = 2 #Load Data person_input, expected_output, group_input, scene_input, test_input, test_output = load_data( leave_dataset_index=leave_dataset_index, map_index=map_index) #[0:4] print(len([scene_input, group_input, person_input][1])) #Set data generator train_generator = DataGenerator( data=[scene_input, group_input, person_input], labels=expected_output, batch_size=batch_size, shuffle=False) test_generator = DataGenerator(data=test_input, labels=test_output, batch_size=batch_size, shuffle=False) print('####') print(scene_input.shape) #Compile model model.compile(loss='mse', optimizer=opt) #Setting TensorBoard tbCallback = TensorBoard(log_dir='graph/', histogram_freq=0,
if FLAGS.cnn: ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 28, 28)) else: ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1, config={"flatten": not FLAGS.cnn}) if FLAGS.cnn: o = ConvMANN(FLAGS.num_classes, FLAGS.num_samples + 1, FLAGS.dropout) else: o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1, n_layers=FLAGS.n_layers, layer_units=FLAGS.layer_units) out = o(ims, labels) loss = loss_function(out, labels) optim = tf.train.AdamOptimizer(FLAGS.lr) optimizer_step = optim.minimize(loss)
model_save_freq = conf.getint('model_save_freq') logs_dir = conf['logs_dir'] img_dir, model_dir = init_dirs(logs_dir) print("Loading data...") random_transforms = [transforms.RandomRotation(degrees=5)] transform = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), # transforms.RandomApply(random_transforms, # p=0.5), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) train_data = DataGenerator(database, transform=transform, n_samples=N) train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size, num_workers=4) netG = Generator(128, 32, 3).to(device) netD = Discriminator(3, 48).to(device) criterion = nn.BCELoss() criterionH = nn.MSELoss() optimizerD = optim.Adam(netD.parameters(), lr=lr_d, betas=(beta1, beta2)) optimizerG = optim.Adam(netG.parameters(), lr=lr_g, betas=(beta1, beta2)) lr_schedulerG = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
model = ProtoNet([num_filters] * num_conv_layers, latent_dim) x_latent = model(tf.reshape(x, [-1, im_height, im_width, channels])) q_latent = model(tf.reshape(q, [-1, im_height, im_width, channels])) ce_loss, acc = ProtoLoss(x_latent, q_latent, labels_ph, num_classes, num_support, num_queries) train_op = tf.train.AdamOptimizer().minimize(ce_loss) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True sess = tf.InteractiveSession(config=tf_config) init_op = tf.global_variables_initializer() sess.run(init_op) # call DataGenerator with k_shot+n_query samples per class data_generator = DataGenerator(n_way, k_shot + n_query, n_meta_test_way, k_meta_test_shot + n_meta_test_query, config={'data_folder': args.data_path}) for ep in range(n_epochs): for epi in range(n_episodes): ############################# #### YOUR CODE GOES HERE #### # sample a batch of training data and partition into # support and query sets support, query, labels = None, None, None ############################# _, ls, ac = sess.run([train_op, ce_loss, acc], feed_dict={ x: support,
l_onehot = torch.from_numpy(l_onehot).to(device) l_lbl = torch.from_numpy(l_lbl)[:, -1:].view(-1).to(device) # last_n_step_labels = l_onehot[:, -1:] # last_n_step_labels = last_n_step_labels.squeeze(1).reshape(-1, args.num_classes) # (B * N, N) # l_lbl2 = torch.tensor(last_n_step_labels.argmax(axis=1)).to(device) return i, l_onehot, l_lbl # # if __name__ == '__main__': # # Setup optimization. device = getDevice(torch.cuda.is_available(), 0) args = getInputArgs() data_generator = DataGenerator(args.num_classes, args.num_samples + 1) mann = MANN(args.num_classes, args.num_samples + 1).to(device) optim = torch.optim.Adam(mann.parameters(), 0.001) ce = torch.nn.CrossEntropyLoss() # # Train. pbar = tqdm(range(50000)) for step in pbar: i, l_onehot, l_lbl = sampleBatch(data_generator, 'train', args.meta_batch_size, device, args) out = mann(i, l_onehot) loss = loss_function(ce, out, l_lbl) loss.backward() optim.step() optim.zero_grad()
model = ProtoNet([num_filters] * num_conv_layers, latent_dim) x_latent = model(tf.reshape(x, [-1, im_height, im_width, channels])) q_latent = model(tf.reshape(q, [-1, im_height, im_width, channels])) ce_loss, acc = ProtoLoss(x_latent, q_latent, labels_ph, num_classes, num_support, num_queries) train_op = tf.train.AdamOptimizer().minimize(ce_loss) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth = True sess = tf.InteractiveSession(config=tf_config) init_op = tf.global_variables_initializer() sess.run(init_op) # call DataGenerator with k_shot+n_query samples per class data_generator = DataGenerator(n_way, k_shot + n_query, n_meta_test_way, k_meta_test_shot + n_meta_test_query, config={'data_folder': args.data_path}) experiments = [] exp_filename = 'result_proto_meta_val_acc' + '_n_way' + str( n_way) + '_k_shot' + str(k_shot) + '_n_query' + str(n_query) + '.csv' for ep in range(n_epochs): for epi in range(n_episodes): ############################# #### YOUR CODE GOES HERE #### # sample a batch of training data and partition into # support and query sets # support, query, labels = None, None, None
input_label_scaled = tf.reshape(input_labels, (-1, K * N, N))[:, :-1, :] input_label_scaled = tf.concat( (input_label_scaled, tf.zeros_like(input_label_scaled[:, -1:])), 1) input_label_scaled = tf.dtypes.cast(input_label_scaled, tf.float32) x = tf.concat((input_img_scaled, input_label_scaled), -1) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) out = self.layer_reshape(x) ############################# return out data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1) o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) optim = tf.keras.optimizers.Adam(0.001) def train_step(images, labels): with tf.GradientTape() as tape: pred = o(images, labels) loss = loss_function(pred, labels) gradients = tape.gradient(loss, o.trainable_variables) optim.apply_gradients(zip(gradients, o.trainable_variables)) return loss for step in range(50000): image, label = data_generator.sample_batch('train', FLAGS.meta_batch_size)
Returns: [B, K+1, N, N] predictions """ ############################# #### YOUR CODE GOES HERE #### pass ############################# return #just temporary, uncommend line below after function is implemented #return out ims = tf.placeholder(tf.float32, shape=( None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=( None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator( FLAGS.num_classes, FLAGS.num_samples + 1) #FOR TESTING FLAGS ONLY print(FLAGS.num_samples, FLAGS.num_classes, FLAGS.meta_batch_size) ''' o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) out = o(ims, labels) loss = loss_function(out, labels) optim = tf.train.AdamOptimizer(0.001) optimizer_step = optim.minimize(loss) ''' '''
labels_ph = tf.placeholder(tf.float32, [None, None, None]) model = ProtoNet([num_filters]*num_conv_layers, latent_dim) x_latent = model(tf.reshape(x, [-1, im_height, im_width, channels])) q_latent = model(tf.reshape(q, [-1, im_height, im_width, channels])) ce_loss, acc = ProtoLoss(x_latent, q_latent, labels_ph, num_classes, num_support, num_queries) train_op = tf.train.AdamOptimizer().minimize(ce_loss) tf_config = tf.ConfigProto() tf_config.gpu_options.allow_growth=True sess = tf.InteractiveSession(config=tf_config) init_op = tf.global_variables_initializer() sess.run(init_op) # call DataGenerator with k_shot+n_query samples per class data_generator = DataGenerator(n_way, k_shot+n_query, n_meta_test_way, k_meta_test_shot+n_meta_test_query, config={'data_folder': args.data_path}) for ep in range(n_epochs): for epi in range(n_episodes): # sample a batch of training data and partition into # support and query sets meta_batch = data_generator.sample_batch('meta_train', 1, shuffle=False) support = np.reshape(meta_batch[0][0, :, :k_shot, :], (n_way, k_shot, im_height, im_width, channels)) query = np.reshape(meta_batch[0][0, :, k_shot:, :], (n_way, n_query, im_height, im_width, channels)) labels = meta_batch[1][0, :, k_shot:, :] _, ls, ac = sess.run([train_op, ce_loss, acc], feed_dict={x: support, q: query, labels_ph: labels}) if (epi+1) % 50 == 0:
x = self.layer2(x) # Return original shape [B,K+1,N,N] out = tf.reshape(x, [-1, K, N, N]) ############################# return out #Placeholders for images and labels ims = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, 784)) labels = tf.placeholder(tf.float32, shape=(None, FLAGS.num_samples + 1, FLAGS.num_classes, FLAGS.num_classes)) data_generator = DataGenerator(FLAGS.num_classes, FLAGS.num_samples + 1) o = MANN(FLAGS.num_classes, FLAGS.num_samples + 1) out = o(ims, labels) loss = loss_function(out, labels) print("...tf.trainable_variables():", tf.trainable_variables()) optim = tf.train.AdamOptimizer(0.001) #optim = tf.compat.v1.train.AdamOptimizer(0.001) optimizer_step = optim.minimize(loss) print("...Starts training...") with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer())
import matplotlib.pyplot as plt from load_data import DataGenerator from MANN import MANNCell N = 10 #num_samples K = 2 #num_samples_per_class B = 15 total = N * K * B manncell = MANNCell(rnn_size=128, memory_size=20, memory_vector_dim=4, head_num=2, samples_per_batch=N * K) state = manncell.zero_state(B, tf.float32) data_generator = DataGenerator(num_classes=N, num_samples_per_class=K) inp = Input(shape=(K * N, 784 + N)) controller_output, next_state = manncell(inp, state) with tf.Session() as sess: sess.run(tf.local_variables_initializer()) sess.run(tf.global_variables_initializer()) y_pred_memory = tf.concat([controller_output] + next_state['read_vector_list'], axis=2) state = next_state y_pred_memory = Dense(N, activation='softmax')(y_pred_memory) y_pred = y_pred_memory[:, -1, :N] adam = tf.keras.optimizers.Adam(learning_rate=0.001)