def test(model, numerical_inputs, feature_inputs, char_inputs, actor_char_inputs, test_labels): max_itr = len(feature_inputs) // model.batch_size accuracies = [] for i in range(max_itr): numerical_input_batch = preprocess.get_batch(numerical_inputs, i * model.batch_size, model.batch_size) feature_input_batch = preprocess.get_batch(feature_inputs, i * model.batch_size, model.batch_size) char_input_batch = preprocess.get_batch(char_inputs, i * model.batch_size, model.batch_size) actor_char_input_batch = preprocess.get_batch(actor_char_inputs, i * model.batch_size, model.batch_size) label_batch = preprocess.get_batch(test_labels, i * model.batch_size, model.batch_size) logits = model.call(numerical_input_batch, tf.convert_to_tensor(feature_input_batch), char_input_batch, actor_char_input_batch, is_training=False) accuracies.append(model.accuracy(logits, label_batch)) print("Testing accuracy: ", tf.reduce_mean(accuracies))
def trainEpochs(encoder, decoder, n_epochs, print_every=1000, learning_rate=0.01): start = time.time() print_loss_total = 0 # Reset every print_every encoder_optimizer = optim.RMSprop(encoder.parameters(), lr=learning_rate) decoder_optimizer = optim.RMSprop(decoder.parameters(), lr=learning_rate) criterion = nn.NLLLoss().cuda() for epoch in range(1, n_epochs + 1): training_batch = get_batch(fra, eng) input_variable = Variable(torch.LongTensor(training_batch[0])).cuda() target_variable = Variable(torch.LongTensor(training_batch[1])).cuda() loss = train(input_variable, target_variable, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion) print_loss_total += loss if epoch % print_every == 0: print_loss_avg = print_loss_total / print_every print_loss_total = 0 print('%s (%d %d%%) %.4f' % (timeSince(start, epoch / n_epochs), epoch, epoch / n_epochs * 100, print_loss_avg))
def train(model, train_inputs, train_labels): ''' Trains the model on all of the inputs and labels for one epoch. You should shuffle your inputs and labels - ensure that they are shuffled in the same order using tf.gather. To increase accuracy, you may want to use tf.image.random_flip_left_right on your inputs before doing the forward pass. You should batch your inputs. :param model: the initialized model to use for the forward pass and backward pass :param train_inputs: train inputs (all inputs to use for training), shape (num_inputs, width, height, num_channels) :param train_labels: train labels (all labels to use for training), shape (num_labels, num_classes) :return: Optionally list of losses per batch to use for visualize_loss ''' num_ex, _, _, _ = train_inputs.shape num_batches = num_ex // model.batch_size for i in range(num_batches): batch_inputs, batch_labels = get_batch(train_inputs, train_labels, model.batch_size, i * model.batch_size) with tf.GradientTape() as tape: predictions = model.call(batch_inputs) loss = model.loss(predictions, batch_labels) model.loss_list.append(loss) gradients = tape.gradient(loss, model.trainable_variables) model.optimizer.apply_gradients( zip(gradients, model.trainable_variables)) print(model.accuracy(predictions, batch_labels)) return model.loss_list
def test(model, test_inputs, test_labels): """ Tests the model on the test inputs and labels. You should NOT randomly flip images or do any extra preprocessing. :param test_inputs: test data (all images to be tested), shape (num_inputs, width, height, num_channels) :param test_labels: test labels (all corresponding labels), shape (num_labels, num_classes) :return: test accuracy - this should be the average accuracy across all batches """ num_ex, _, _, _ = test_inputs.shape num_batches = num_ex // model.batch_size accur = 0 for i in range(num_batches): batch_inputs, batch_labels = get_batch(test_inputs, test_labels, model.batch_size, i * model.batch_size) predictions = model.call(batch_inputs, is_testing=True) a = model.accuracy(predictions, batch_labels) print(a) accur += a return accur / num_batches
def test(model, encoder, epoch, num_batches): if not os.path.exists("./output/{}".format(epoch)): os.makedirs("./output/{}".format(epoch)) if not os.path.exists("./output/{}/0".format(epoch)): os.makedirs("./output/{}/0".format(epoch)) l_imgs, ab_imgs = get_batch(0) logits = model.call(l_imgs) encoder.decode(logits, l_imgs, ab_imgs, epoch, 0) batch_id = np.random.randint(1, num_batches - 1) if not os.path.exists("./output/{}/{}".format(epoch, batch_id)): os.makedirs("./output/{}/{}".format(epoch, batch_id)) l_imgs, ab_imgs = get_batch(batch_id) logits = model.call(l_imgs) encoder.decode(logits, l_imgs, ab_imgs, epoch, batch_id)
def test(model, test_boxes, test_size): order = np.arange(test_size) np.random.shuffle(order) batch_inputs, _, order = get_batch('test', model.S, model.B, model.C, 448, test_boxes, model.batch_size, order) for i in range(model.batch_size): input = batch_inputs[i] predictions = model(tf.reshape(input, [1, 448, 448, 3])) img = add_predictions_to_inputs( input, tf.reshape(predictions, [model.S, model.S, model.B * 5 + model.C])) imwrite('./output/{}.png'.format(i), img)
def train(model, numerical_inputs, feature_inputs, char_inputs, actor_char_inputs, train_labels): max_itr = len(feature_inputs) // model.batch_size losses = [] for i in range(max_itr): print("Batch " + str(i + 1) + " / " + str(max_itr)) numerical_input_batch = preprocess.get_batch(numerical_inputs, i * model.batch_size, model.batch_size) feature_input_batch = preprocess.get_batch(feature_inputs, i * model.batch_size, model.batch_size) char_input_batch = preprocess.get_batch(char_inputs, i * model.batch_size, model.batch_size) actor_char_input_batch = preprocess.get_batch(actor_char_inputs, i * model.batch_size, model.batch_size) label_batch = preprocess.get_batch(train_labels, i * model.batch_size, model.batch_size) with tf.GradientTape() as tape: logits = model.call(numerical_input_batch, tf.convert_to_tensor(feature_input_batch), char_input_batch, actor_char_input_batch, is_training=None) loss = model.loss(logits, label_batch) losses.append(loss) print("Batch loss: {}".format(loss)) print("Batch accuracy: {}".format( model.accuracy(logits, label_batch))) gradients = tape.gradient(loss, model.trainable_variables) model.optimizer.apply_gradients( zip(gradients, model.trainable_variables)) return losses
def train(model, encoder, manager, num_batches): best_loss = float("inf") for batch_idx in range(num_batches): print("batch {} out of {}".format(batch_idx, num_batches)) l_imgs, ab_imgs = get_batch(batch_idx) labels = get_batch_labels(ab_imgs, encoder) with tf.GradientTape() as tape: logits = model.call(l_imgs) loss = model.loss_function(logits, labels) print("loss: {}".format(loss)) if epoch > 100 and loss < best_loss: manager.save() best_loss = loss gradients = tape.gradient(loss, model.trainable_variables) model.optimizer.apply_gradients( zip(gradients, model.trainable_variables))
def train(model, train_boxes, train_size): order = np.arange(train_size) np.random.shuffle(order) batch_num = 0 while True: if len(order) < model.batch_size: break batch_inputs_list, batch_labels_list, order = get_batch( 'train', model.S, model.B, model.C, 448, train_boxes, model.batch_size, order) batch_inputs = tf.stack(batch_inputs_list) batch_labels = tf.stack(batch_labels_list) with tf.GradientTape() as tape: predictions = model(batch_inputs) loss = model.loss(predictions, batch_labels) print("Loss after batch {}: {}".format(batch_num, loss)) gradients = tape.gradient(loss, model.trainable_variables) model.optimizer.apply_gradients( zip(gradients, model.trainable_variables)) batch_num += 1 print()
def main(): in_z = 0 volpath = os.path.join(args.datapath, 'train') segpath = volpath batch_size = args.batch_size orig_dim = 256 sqr = transforms.Square() aff = transforms.Affine() crop = transforms.RandomCrop(224) scale = transforms.Scale(orig_dim) rotate = transforms.Rotate(0.5, 30) noise = transforms.Noise(0.02) flip = transforms.Flip() transform_plan = [sqr, scale, aff, rotate, crop, flip, noise] lr = 1e-4 series_names = ['Mag'] seg_series_names = ['AV'] model = models.Net23(2) model.cuda() optimizer = optim.RMSprop(model.parameters(), lr=lr) out_z, center_crop_sz = utils.get_out_size(orig_dim, in_z,\ transform_plan, model) t0 = time.time() counter = 0 print_interval = args.log_interval model.train() for i in range(200000000000000000000000000000000): weight = torch.FloatTensor([0.2, 0.8]).cuda() vol, seg, inds = preprocess.get_batch(volpath, segpath, batch_size, in_z,\ out_z, center_crop_sz, series_names, seg_series_names,\ transform_plan, 8, nrrd=True) vol = torch.unsqueeze(vol, 1) vol = Variable(vol).cuda() seg = Variable(seg).cuda() out = model(vol).squeeze() loss = F.cross_entropy(out, seg, weight=weight) optimizer.zero_grad() loss.backward() optimizer.step() counter += 1 sys.stdout.write('\r{:.2f}%'.format(counter * batch_size / print_interval)) sys.stdout.flush() if counter * batch_size >= print_interval and i > 0: seg_hot = utils.get_hot(seg.data.cpu().numpy(), out.size()[-3]) seg_hot = np.transpose(seg_hot, axes=[1, 0, 2, 3]) out_hot = np.argmax(out.data.cpu().numpy(), axis=1) out_hot = utils.get_hot(out_hot, out.size()[-3]) out_hot = np.transpose(out_hot, axes=[1, 0, 2, 3]) dce2 = utils.dice(seg_hot[:, 1:], out_hot[:, 1:]) vol_ind = utils.get_liver(seg) v = vol.data.cpu().numpy()[vol_ind].squeeze() real_seg = seg[vol_ind].data.cpu().numpy() out_plt = out.data.cpu().numpy()[vol_ind] out_plt = np.argmax(out_plt, axis=0) fake_seg = out_plt masked_real = utils.makeMask(v, real_seg, out.size()[-3], 0.5) masked_fake = utils.makeMask(v, fake_seg, out.size()[-3], 0.5) fig = plt.figure(1) fig.suptitle('Volume {} ; Dice = {:.2f}'.format(\ inds[vol_ind],dce2)) v = fig.add_subplot(1, 2, 1) v.set_title('real') plt.imshow(masked_real) sreal = fig.add_subplot(1, 2, 2) sreal.set_title('fake') plt.imshow(masked_fake) outfile = os.path.join(args.datapath, 'out.png') plt.savefig(outfile, dpi=200) plt.clf() print(('\rIteration {}: Block completed in {:.2f} sec ; Loss = {:.2f}')\ .format(i*batch_size,time.time()-t0, loss.data.cpu()[0])) checkpoint_file = os.path.join(args.datapath,\ 'model_checkpoint.pth') torch.save(model.state_dict(), checkpoint_file) counter = 0 t0 = time.time()
'MS': '~/Desktop/user_ml/michelle_song.1.csv', 'TH': '~/Desktop/user_ml/tony_hsieh.1.csv', 'Y': '~/Desktop/user_ml/yiyi_lyu.1.csv', 'YF': '~/Desktop/user_ml/yvonne_feng.1.csv', #'K': '~/Desktop/user_ml/kevin_chiu.1.csv', } # file path of training & testing data regular_data_file = data_files[target_name] compare_data_files = data_files.copy() del compare_data_files[target_name] save_dir = "save_{}/".format(dt.datetime.now().strftime("%m%d%H%M")) # get 'samples' train_data and 'samples' test_data and 'samples' validation data data = preprocess.get_batch(regular_data_file, samples + samples + samples, time_steps, step_dims) train_data = data[:samples] test_data = data[samples:samples * 2] validation_data = data[samples * 2:] # get one data for other people cmp_data = {} for name, file in compare_data_files.items(): cmp_data[name] = preprocess.get_batch(file, samples, time_steps, step_dims) ##### Defining graph ##### # TODO: use shape [None, time_steps, step_dims] seq_input = tf.placeholder(tf.float32, [1, time_steps, step_dims]) encoder_inputs = tf.unstack(seq_input) print(len(encoder_inputs),
model.cuda() optimizer = optim.RMSprop(model.parameters(), lr=lr) out_z, center_crop_sz = utils.get_out_size(original_size, 0,\ transform_plan, model) t0 = time.time() counter = 0 print_interval = 200 model.train() weight = torch.FloatTensor([0.1, 0.45, 0.45]).cuda() for i in range(num_steps): vol, seg, inds = preprocess.get_batch(volpath, segpath, batch_size, 0,\ out_z, center_crop_sz, series_names, seg_series_names,\ transform_plan, 8, nrrd=True) vol = torch.unsqueeze(vol, 1) vol = Variable(vol).cuda() seg = Variable(seg).cuda().long() out = model(vol).squeeze() loss = F.cross_entropy(out, seg, weight=weight) optimizer.zero_grad() loss.backward() optimizer.step() counter += 1 sys.stdout.write('\r{:.2f}%'.format(counter * batch_size / print_interval))
feed_dict[feed['seq_len']] = [39] * size return feed_dict if __name__ == '__main__': feed, cost, train_step, decoded, ler = network(len(id_char_map) + 1) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for i in range(100000): size = 10 batch = get_batch(size) feed_dict = assemble_feed(feed, size, batch) sess.run(train_step, feed_dict=feed_dict) if i % 10 == 9: size = 10 batch = get_batch(size) feed_dict = assemble_feed(feed, size, batch) cost_result, error, result = sess.run([cost, ler, decoded], feed_dict=feed_dict) temp = lambda x: '_' if x == len(id_char_map) else id_char_map[ x] str_raw = [ ''.join([temp(i) for i in seq])