def train(args, model, train_loader, optimizer, epoch, training_step, writer): losses = utils.AverageMeter("Loss", ":.6f") progress = utils.ProgressMeter(len(train_loader), [losses], prefix="Epoch: [{}]".format(epoch)) model.train() for batch_idx, batch in enumerate(train_loader): batch = [tensor.cuda() for tensor in batch] ( obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, non_linear_ped, loss_mask, seq_start_end, ) = batch optimizer.zero_grad() loss = torch.zeros(1).to(pred_traj_gt) l2_loss_rel = [] loss_mask = loss_mask[:, args.obs_len:] if training_step == 1 or training_step == 2: model_input = obs_traj_rel pred_traj_fake_rel = model(model_input, obs_traj, seq_start_end, 1, training_step) l2_loss_rel.append( l2_loss(pred_traj_fake_rel, model_input, loss_mask, mode="raw")) else: model_input = torch.cat((obs_traj_rel, pred_traj_gt_rel), dim=0) for _ in range(args.best_k): pred_traj_fake_rel = model(model_input, obs_traj, seq_start_end, 0) l2_loss_rel.append( l2_loss( pred_traj_fake_rel, model_input[-args.pred_len:], loss_mask, mode="raw", )) l2_loss_sum_rel = torch.zeros(1).to(pred_traj_gt) l2_loss_rel = torch.stack(l2_loss_rel, dim=1) for start, end in seq_start_end.data: _l2_loss_rel = torch.narrow(l2_loss_rel, 0, start, end - start) _l2_loss_rel = torch.sum(_l2_loss_rel, dim=0) # [20] _l2_loss_rel = torch.min(_l2_loss_rel) / ( (pred_traj_fake_rel.shape[0]) * (end - start)) l2_loss_sum_rel += _l2_loss_rel loss += l2_loss_sum_rel losses.update(loss.item(), obs_traj.shape[1]) loss.backward() optimizer.step() if batch_idx % args.print_every == 0: progress.display(batch_idx) writer.add_scalar("train_loss", losses.avg, epoch)
def cal_l2_losses(pred_traj_gt, pred_traj_gt_rel, pred_traj_fake, pred_traj_fake_rel, loss_mask): g_l2_loss_abs = l2_loss(pred_traj_fake, pred_traj_gt, loss_mask, mode='sum') g_l2_loss_rel = l2_loss(pred_traj_fake_rel, pred_traj_gt_rel, loss_mask, mode='sum') return g_l2_loss_abs, g_l2_loss_rel
def build_model(self): print("building model") # Placeholders noisy data self.noise = tf.placeholder(tf.float32, shape=self.input_shape, name='noise') # Placeholders for real training samples self.input_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_real') # Placeholders for fake generated samples self.input_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_fake') # Placeholder for test samples self.input_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_test') self.generation = self.generator(inputs=self.noise, reuse=False, scope_name='generator') self.discrimination = self.discriminator(inputs=self.generation, reuse=False, scope_name='discriminator') # Generator wants to fool discriminator self.generator_loss = l2_loss(y=tf.ones_like(self.discrimination), y_hat=self.discrimination) # Merge the two generators and the cycle loss self.generator_loss = self.generator_loss # Discriminator loss self.discrimination_input_real = self.discriminator(inputs=self.input_real, reuse=True, scope_name='discriminator') self.discrimination_input_fake = self.discriminator(inputs=self.input_fake, reuse=True, scope_name='discriminator') self.discriminator_loss_input_real = l2_loss(y=tf.ones_like(self.discrimination_input_real), y_hat=self.discrimination_input_real) self.discriminator_loss_input_fake = l2_loss(y=tf.zeros_like(self.discrimination_input_fake), y_hat=self.discrimination_input_fake) self.discriminator_loss = (self.discriminator_loss_input_real + self.discriminator_loss_input_fake) / 2 # Merge the two discriminators into one self.discriminator_loss = self.discriminator_loss # Categorize variables because we have to optimize the two sets of the variables separately trainable_variables = tf.trainable_variables() self.discriminator_vars = [var for var in trainable_variables if 'discriminator' in var.name] self.generator_vars = [var for var in trainable_variables if 'generator' in var.name] self.generation_test = self.generator(inputs=self.input_test, reuse=True, scope_name='generator')
def generator_step(batch, generator, discriminator, g_loss_fn, optimizer_g): """This step is similar to Social GAN Code""" if USE_GPU: batch = [tensor.cuda() for tensor in batch] else: batch = [tensor for tensor in batch] (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, loss_mask, seq_start_end, obs_ped_speed, pred_ped_speed) = batch losses = {} loss = torch.zeros(1).to(pred_traj_gt) g_l2_loss_rel = [] loss_mask = loss_mask[:, OBS_LEN:] for _ in range(BEST_K): generator_out = generator(obs_traj, obs_traj_rel, seq_start_end, obs_ped_speed, pred_ped_speed, pred_traj_gt, TRAIN_METRIC, SPEED_TO_ADD) pred_traj_fake_rel = generator_out pred_traj_fake = relative_to_abs(pred_traj_fake_rel, obs_traj[-1]) if L2_LOSS_WEIGHT > 0: g_l2_loss_rel.append(L2_LOSS_WEIGHT * l2_loss( pred_traj_fake_rel, pred_traj_gt_rel, loss_mask, mode='raw')) g_l2_loss_sum_rel = torch.zeros(1).to(pred_traj_gt) if L2_LOSS_WEIGHT > 0: g_l2_loss_rel = torch.stack(g_l2_loss_rel, dim=1) for start, end in seq_start_end.data: _g_l2_loss_rel = g_l2_loss_rel[start:end] _g_l2_loss_rel = torch.sum(_g_l2_loss_rel, dim=0) _g_l2_loss_rel = torch.min(_g_l2_loss_rel) / torch.sum( loss_mask[start:end]) g_l2_loss_sum_rel += _g_l2_loss_rel losses['G_l2_loss_rel'] = g_l2_loss_sum_rel.item() loss += g_l2_loss_sum_rel traj_fake = torch.cat([obs_traj, pred_traj_fake], dim=0) traj_fake_rel = torch.cat([obs_traj_rel, pred_traj_fake_rel], dim=0) ped_speed = torch.cat([obs_ped_speed, pred_ped_speed], dim=0) scores_fake = discriminator(traj_fake, traj_fake_rel, ped_speed, seq_start_end) discriminator_loss = g_loss_fn(scores_fake) loss += discriminator_loss losses['G_discriminator_loss'] = discriminator_loss.item() losses['G_total_loss'] = loss.item() optimizer_g.zero_grad() loss.backward() optimizer_g.step() return losses
def generator_step(batch, generator, discriminator, g_loss_fn, optimizer_g): batch = [tensor.cuda() for tensor in batch] # (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, vgg_list) = batch # (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel) = batch (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, n_l, l_m, V_obs, A_obs, V_pre, A_pre, vgg_list) = batch losses = {} loss = torch.zeros(1).to(pred_traj_gt) g_l2_loss_rel = [] for _ in range(BEST_K): # generator_out = generator(obs_traj, obs_traj_rel, vgg_list) generator_out = generator(obs_traj, obs_traj_rel, V_obs, A_obs, vgg_list) # 生成坐标差 pred_traj_fake_rel = generator_out pred_traj_fake = relative_to_abs(pred_traj_fake_rel, obs_traj[0, :, :, -1]) # 12*3*2 TVC g_l2_loss_rel.append( l2_loss( # 生成坐标差和真实坐标差 n*1 pred_traj_fake_rel, # T V C pred_traj_gt_rel, # N V C T mode='raw')) # 生成了K条轨迹并计算损失 K V npeds = obs_traj.size(1) # V g_l2_loss_sum_rel = torch.zeros(1).to(pred_traj_gt) # 1 g_l2_loss_rel = torch.stack(g_l2_loss_rel, dim=1) # 拼接张量 得v k _g_l2_loss_rel = torch.sum(g_l2_loss_rel, dim=0) # 求和 得 k _g_l2_loss_rel = torch.min(_g_l2_loss_rel) / (npeds * PRED_LEN ) # 取最小的然后取平均 g_l2_loss_sum_rel += _g_l2_loss_rel losses['G_l2_loss_rel'] = g_l2_loss_sum_rel.item() loss += g_l2_loss_sum_rel # 生成轨迹的损失 pred_traj_fake = pred_traj_fake.permute(1, 2, 0) # TVC——VCT pred_traj_fake_rel = pred_traj_fake_rel.permute(1, 2, 0) traj_fake = torch.cat([obs_traj[0], pred_traj_fake], dim=2) # VCT T=20 traj_fake_rel = torch.cat([obs_traj_rel[0], pred_traj_fake_rel], dim=2) scores_fake = discriminator(traj_fake, traj_fake_rel) # 生成轨迹鉴别分数 discriminator_loss = g_loss_fn(scores_fake) loss += discriminator_loss # 加入鉴别器损失 losses['G_discriminator_loss'] = discriminator_loss.item() losses['G_total_loss'] = loss.item() optimizer_g.zero_grad() loss.backward() optimizer_g.step() return losses
def _setup_loss_graph(self, s_output_tbi, s_target_tbi, s_step_size): """ Connect a loss function to the graph See data.py for explanation of the slicing part """ s_sliced_output_tbi = s_output_tbi[-s_step_size :] s_sliced_target_tbi = s_target_tbi[-s_step_size :] if self._options['loss_type'] == 'l2': return l2_loss(s_sliced_output_tbi, s_sliced_target_tbi) if self._options['loss_type'] == 'l1': return l1_loss(s_sliced_output_tbi, s_sliced_target_tbi) if self._options['loss_type'] == 'huber': delta = self._options['huber_delta'] return huber_loss(s_sliced_output_tbi, s_sliced_target_tbi, delta) assert False, 'Invalid loss_type option' return tt.alloc(np.float32(0.))
def generator_step(batch, generator, discriminator, g_loss_fn, optimizer_g): batch = [tensor.cuda() for tensor in batch] (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, vgg_list) = batch losses = {} loss = torch.zeros(1).to(pred_traj_gt) g_l2_loss_rel = [] for _ in range(BEST_K): generator_out = generator(obs_traj, obs_traj_rel, vgg_list) pred_traj_fake_rel = generator_out pred_traj_fake = relative_to_abs(pred_traj_fake_rel, obs_traj[-1, :, 0, :]) g_l2_loss_rel.append( l2_loss(pred_traj_fake_rel, pred_traj_gt_rel, mode='raw')) npeds = obs_traj.size(1) g_l2_loss_sum_rel = torch.zeros(1).to(pred_traj_gt) g_l2_loss_rel = torch.stack(g_l2_loss_rel, dim=1) _g_l2_loss_rel = torch.sum(g_l2_loss_rel, dim=0) _g_l2_loss_rel = torch.min(_g_l2_loss_rel) / (npeds * PRED_LEN) g_l2_loss_sum_rel += _g_l2_loss_rel losses['G_l2_loss_rel'] = g_l2_loss_sum_rel.item() loss += g_l2_loss_sum_rel traj_fake = torch.cat([obs_traj[:, :, 0, :], pred_traj_fake], dim=0) traj_fake_rel = torch.cat([obs_traj_rel[:, :, 0, :], pred_traj_fake_rel], dim=0) scores_fake = discriminator(traj_fake, traj_fake_rel) discriminator_loss = g_loss_fn(scores_fake) loss += discriminator_loss losses['G_discriminator_loss'] = discriminator_loss.item() losses['G_total_loss'] = loss.item() optimizer_g.zero_grad() loss.backward() optimizer_g.step() return losses
def mask_l2_loss(a, b, mask): return l2_loss(a[mask], b[mask])
def build_model(self): if True: self.input_sequence_r = tf.placeholder(tf.float32, shape=[ self.batch_size, self.sequence_maximum, self.input_dimension ], name="inputsequence_r") self.input_sequence_r_2 = tf.placeholder(tf.float32, shape=[ self.batch_size, self.sequence_maximum, self.input_dimension ], name="inputsequence_r_2") self.decoder_input = tf.placeholder(tf.float32, shape=[ self.batch_size, self.sequence_maximum, self.input_dimension ], name="decoder_input") self.input_sequence_original = tf.placeholder( tf.float32, shape=[ self.batch_size, self.sequence_maximum, self.input_dimension ], name="input_sequence_original") self.input_sequence_original_shift = tf.placeholder( tf.float32, shape=[ self.batch_size, self.sequence_maximum + 1, self.input_dimension ], name="input_sequence_original_shift") self.input_mask_r = tf.placeholder( tf.float32, shape=[self.batch_size, self.sequence_maximum + 1], name="inputmask_r") self.sequence_length_r = tf.placeholder(tf.int32, shape=(self.batch_size), name="sequence_length_r") representation_sequence = self.encoder(self.input_sequence_r, self.sequence_length_r) self.y = tf.placeholder(tf.float32, shape=(self.batch_size, self.num_catogory), name="y") self.representation_len_super = int( self.representation_dimention * self.representation_ratio_super) decoder_input_r=tf.expand_dims(representation_sequence\ [:,self.representation_dimention-self.representation_len_super:],axis=1) representation_sequence_temp=tf.expand_dims(representation_sequence\ [:,self.representation_dimention-self.representation_len_super:],axis=1) decoder_input_r = tf.concat([decoder_input_r, self.decoder_input], 1) outputs_decoder_x_r = self.decoder(decoder_input_r, self.sequence_length_r) y_pred_ori, fcn_ori = self.discriminator( self.input_sequence_original, self.sequence_length_r) y_pred_ae, fcn_x_ae = self.discriminator(outputs_decoder_x_r, self.sequence_length_r, reuse=True) self.loss_decoder_WGAN = tf.reduce_mean(-y_pred_ae) self.loss_discriminator_WGAN = tf.reduce_mean(-y_pred_ori + y_pred_ae) supervised_input = representation_sequence[:, 0:self. representation_len_super] supervised_input_len = self.representation_len_super self.representation = supervised_input self.representation_len_super = supervised_input_len if self.fcn_num == 0: y_pred= utils.fcn_layer_scope(supervised_input,\ w_shape=[supervised_input_len,self.num_catogory],b_shape=[self.num_catogory],\ scope="softmax_supervised",\ activation=tf.nn.softmax) elif self.fcn_num == 1: fcn_layer1=utils.fcn_layer_scope(supervised_input,\ w_shape=[supervised_input_len,self.fcn_hiddenunit_num],b_shape=[self.fcn_hiddenunit_num],\ scope="softmax_supervised1",\ activation=tf.nn.tanh) #utils.leaky_relu fcn_layer1_dropout = tf.nn.dropout( fcn_layer1, keep_prob=self.dropout_outkeepratio_fcn) y_pred=utils.fcn_layer_scope(fcn_layer1_dropout,\ w_shape=[self.fcn_hiddenunit_num,self.num_catogory],b_shape=[self.num_catogory],\ scope="softmax_supervised2",\ activation=tf.nn.softmax) else: fcn_layer1=utils.fcn_layer_scope(supervised_input,\ w_shape=[supervised_input_len,self.fcn_hiddenunit_num],b_shape=[self.fcn_hiddenunit_num],\ scope="softmax_supervised1",\ activation=tf.nn.tanh) #utils.leaky_relu fcn_layer1_dropout = tf.nn.dropout(fcn_layer1, keep_prob=0.7) fcn_layer2=utils.fcn_layer_scope(fcn_layer1_dropout,\ w_shape=[self.fcn_hiddenunit_num,self.fcn_hiddenunit_num],b_shape=[self.fcn_hiddenunit_num],\ scope="softmax_supervised2",\ activation=tf.nn.tanh) fcn_layer2_dropout = tf.nn.dropout(fcn_layer2, keep_prob=1.0) y_pred=utils.fcn_layer_scope(fcn_layer2_dropout,\ w_shape=[self.fcn_hiddenunit_num,self.num_catogory],b_shape=[self.num_catogory],\ scope="softmax_supervised3",\ activation=tf.nn.softmax) self.cross_entropy = -tf.reduce_sum( self.y * tf.log(y_pred + 1e-10)) / self.batch_size self.train_op_super = tf.train.AdamOptimizer( self.learning_rate).minimize(self.cross_entropy) correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(self.y, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float')) self.loss_encoder = utils.l2_loss( outputs_decoder_x_r, self.input_sequence_original_shift, self.input_mask_r) / self.batch_size self.loss_semi = self.weight_super * self.cross_entropy self.loss_decoder = self.loss_encoder * ( 1.0 - self.gan_ratio) + self.loss_decoder_WGAN * self.gan_ratio train_variables = tf.trainable_variables() self.encoder_variables = [ v for v in train_variables if "encodernet" in v.name ] self.decoder_variables = [ v for v in train_variables if "decodernet" in v.name ] self.discriminator_variables = [ v for v in train_variables if "discriminatornet" in v.name ] self.softmax_variables = [ v for v in train_variables if "softmax_supervised" in v.name ] self.encoder_train_op = self.optimizer(self.loss_encoder, self.encoder_variables) self.decoder_train_op = self.optimizer(self.loss_decoder, self.decoder_variables) self.discriminator_train_op = self.optimizer( self.loss_discriminator_WGAN, self.discriminator_variables) self.train_op_semi = tf.train.AdamOptimizer( self.learning_rate).minimize(self.loss_semi) self.train_op_softmax = self.optimizer(self.loss_semi, self.softmax_variables)
random.shuffle(tlist) tlist, vlist = tlist[:n_train], tlist[n_train:] min_loss = 1e18 trlog = {} trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['min_loss'] = 0 train_time = conv_time for epoch in range(1, args.max_epoch + 1): glp.train() step_time = time.time() output_vectors = glp(word_vectors, tlist) loss = l2_loss(output_vectors, fc_vectors[tlist]) optimizer.zero_grad() loss.backward() optimizer.step() step_time = time.time() - step_time train_time += step_time glp.eval() output_vectors = glp(word_vectors, tlist) train_loss = l2_loss(output_vectors, fc_vectors[tlist]).item() if v_val > 0: output_vectors = glp(word_vectors, vlist) val_loss = l2_loss(output_vectors, fc_vectors[vlist]).item() loss = val_loss else: val_loss = 0
def generator_step(batch, generator, discriminator, g_loss_fn, optimizer_g): if USE_GPU: batch = [tensor.cuda() for tensor in batch] else: batch = [tensor for tensor in batch] if MULTI_CONDITIONAL_MODEL: (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, loss_mask, seq_start_end, obs_ped_speed, pred_ped_speed, obs_label, pred_label, obs_obj_rel_speed) = batch else: (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, loss_mask, seq_start_end, obs_ped_speed, pred_ped_speed, obs_obj_rel_speed) = batch losses = {} loss = torch.zeros(1).to(pred_traj_gt) g_l2_loss_rel = [] loss_mask = loss_mask[:, OBS_LEN:] for _ in range(BEST_K): if MULTI_CONDITIONAL_MODEL: generator_out, final_enc_h = generator(obs_traj, obs_traj_rel, seq_start_end, obs_ped_speed, pred_ped_speed, pred_traj_gt, TRAIN_METRIC, None, obs_obj_rel_speed, obs_label=obs_label, pred_label=pred_label) else: generator_out, final_enc_h = generator(obs_traj, obs_traj_rel, seq_start_end, obs_ped_speed, pred_ped_speed, pred_traj_gt, TRAIN_METRIC, None, obs_obj_rel_speed, obs_label=None, pred_label=None) pred_traj_fake_rel = generator_out pred_traj_fake = relative_to_abs(pred_traj_fake_rel, obs_traj[-1]) if L2_LOSS_WEIGHT > 0: g_l2_loss_rel.append(L2_LOSS_WEIGHT * l2_loss( pred_traj_fake_rel, pred_traj_gt_rel, loss_mask, mode='raw')) g_l2_loss_sum_rel = torch.zeros(1).to(pred_traj_gt) if L2_LOSS_WEIGHT > 0: g_l2_loss_rel = torch.stack(g_l2_loss_rel, dim=1) for start, end in seq_start_end.data: _g_l2_loss_rel = g_l2_loss_rel[start:end] _g_l2_loss_rel = torch.sum(_g_l2_loss_rel, dim=0) _g_l2_loss_rel = torch.min(_g_l2_loss_rel) / torch.sum(loss_mask[start:end]) g_l2_loss_sum_rel += _g_l2_loss_rel losses['G_l2_loss_rel'] = g_l2_loss_sum_rel.item() loss += g_l2_loss_sum_rel traj_fake = torch.cat([obs_traj, pred_traj_fake], dim=0) traj_fake_rel = torch.cat([obs_traj_rel, pred_traj_fake_rel], dim=0) ped_speed = torch.cat([obs_ped_speed, pred_ped_speed], dim=0) if MULTI_CONDITIONAL_MODEL: label_info = torch.cat([obs_label, pred_label], dim=0) scores_fake = discriminator(traj_fake, traj_fake_rel, ped_speed, label=label_info) else: scores_fake = discriminator(traj_fake, traj_fake_rel, ped_speed, label=None) discriminator_loss = g_loss_fn(scores_fake) loss += discriminator_loss losses['G_discriminator_loss'] = discriminator_loss.item() losses['G_total_loss'] = loss.item() optimizer_g.zero_grad() loss.backward() optimizer_g.step() return losses
def check_accuracy(loader, generator, discriminator, d_loss_fn, limit=False): d_losses = [] # metrics = {} g_l2_losses_abs, g_l2_losses_rel = ([], ) * 2 disp_error = [] # ADE FDE f_disp_error = [] total_traj = 0 mask_sum = 0 generator.eval() with torch.no_grad(): # for batch in loader: batch = [tensor.cuda() for tensor in batch] # (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, vgg_list) = batch # (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel) = batch (obs_traj, pred_traj_gt, obs_traj_rel, pred_traj_gt_rel, n_l, l_m, V_obs, A_obs, V_pre, A_pre, vgg_list) = batch # pred_traj_fake_rel = generator(obs_traj, obs_traj_rel, vgg_list) pred_traj_fake_rel = generator(obs_traj, obs_traj_rel, V_obs, A_obs, vgg_list) # T V C pred_traj_fake = relative_to_abs(pred_traj_fake_rel, obs_traj[0, :, :, -1]) # T V C——V C g_l2_loss_abs = l2_loss(pred_traj_fake, pred_traj_gt, mode='sum') g_l2_loss_rel = l2_loss(pred_traj_fake_rel, pred_traj_gt_rel, mode='sum') ade = displacement_error(pred_traj_fake, pred_traj_gt) # TVC NVCT fde = final_displacement_error(pred_traj_fake[-1], pred_traj_gt[0, :, :, -1]) # VC VC traj_real = torch.cat([obs_traj[:, :, 0, :], pred_traj_gt], dim=0) traj_real_rel = torch.cat( [obs_traj_rel[:, :, 0, :], pred_traj_gt_rel], dim=0) traj_fake = torch.cat([obs_traj[:, :, 0, :], pred_traj_fake], dim=0) traj_fake_rel = torch.cat( [obs_traj_rel[:, :, 0, :], pred_traj_fake_rel], dim=0) scores_fake = discriminator(traj_fake, traj_fake_rel) scores_real = discriminator(traj_real, traj_real_rel) d_loss = d_loss_fn(scores_real, scores_fake) d_losses.append(d_loss.item()) g_l2_losses_abs.append(g_l2_loss_abs.item()) g_l2_losses_rel.append(g_l2_loss_rel.item()) disp_error.append(ade.item()) f_disp_error.append(fde.item()) mask_sum += (pred_traj_gt.size(1) * PRED_LEN) total_traj += pred_traj_gt.size(1) if limit and total_traj >= NUM_SAMPLES_CHECK: break metrics['d_loss'] = sum(d_losses) / len(d_losses) metrics['g_l2_loss_abs'] = sum(g_l2_losses_abs) / mask_sum metrics['g_l2_loss_rel'] = sum(g_l2_losses_rel) / mask_sum metrics['ade'] = sum(disp_error) / (total_traj * PRED_LEN) metrics['fde'] = sum(f_disp_error) / total_traj generator.train() return metrics
def train_step(inputs): with tf.GradientTape() as gen_tape, tf.GradientTape() as dis_tape: outputs = model(inputs) generation_A = outputs[0] generation_B = outputs[1] cycle_A = outputs[2] cycle_B = outputs[3] identity_A = outputs[4] identity_B = outputs[5] discrimination_A_real = outputs[6] discrimination_A_fake = outputs[7] discrimination_B_real = outputs[8] discrimination_B_fake = outputs[9] discrimination_A_dot_real = outputs[10] discrimination_A_dot_fake = outputs[11] discrimination_B_dot_real = outputs[12] discrimination_B_dot_fake = outputs[13] # Cycle loss. cycle_loss = l1_loss(inputs[0], cycle_A) + l1_loss(inputs[1], cycle_B) # Identity loss. identity_loss = l1_loss(inputs[0], identity_A) + l1_loss( inputs[1], identity_B) # Generator loss. generator_loss_A2B = l2_loss(tf.ones_like(discrimination_B_fake), discrimination_B_fake) generator_loss_B2A = l2_loss(tf.ones_like(discrimination_A_fake), discrimination_A_fake) two_step_generator_loss_A = l2_loss( tf.ones_like(discrimination_A_dot_fake), discrimination_A_dot_fake) two_step_generator_loss_B = l2_loss( tf.ones_like(discrimination_B_dot_fake), discrimination_B_dot_fake) generator_loss = generator_loss_A2B + generator_loss_B2A + two_step_generator_loss_A + \ two_step_generator_loss_B + hp.lambda_cycle * cycle_loss + hp.lambda_identity * identity_loss discriminator_loss_A_real = l2_loss( tf.ones_like(discrimination_A_real), discrimination_A_real) discriminator_loss_A_fake = l2_loss( tf.zeros_like(discrimination_A_fake), discrimination_A_fake) discriminator_loss_A = (discriminator_loss_A_real + discriminator_loss_A_fake) / 2 discriminator_loss_B_real = l2_loss( tf.ones_like(discrimination_B_real), discrimination_B_real) discriminator_loss_B_fake = l2_loss( tf.zeros_like(discrimination_B_fake), discrimination_B_fake) discriminator_loss_B = (discriminator_loss_B_real + discriminator_loss_B_fake) / 2 discriminator_loss_A_dot_real = l2_loss( tf.ones_like(discrimination_A_dot_real), discrimination_A_dot_real) discriminator_loss_A_dot_fake = l2_loss( tf.zeros_like(discrimination_A_dot_fake), discrimination_A_dot_fake) discriminator_loss_A_dot = (discriminator_loss_A_dot_real + discriminator_loss_A_dot_fake) / 2 discriminator_loss_B_dot_real = l2_loss( tf.ones_like(discrimination_B_dot_real), discrimination_B_dot_real) discriminator_loss_B_dot_fake = l2_loss( tf.zeros_like(discrimination_B_dot_fake), discrimination_B_dot_fake) discriminator_loss_B_dot = (discriminator_loss_B_dot_real + discriminator_loss_B_dot_fake) / 2 discriminator_loss = discriminator_loss_A + discriminator_loss_B + discriminator_loss_A_dot + \ discriminator_loss_B_dot generator_vars = model.generatorA2B.trainable_variables + model.generatorB2A.trainable_variables discriminator_vars = model.discriminator_A.trainable_variables + model.discriminator_B.trainable_variables + \ model.discriminator_A_dot.trainable_variables + model.discriminator_B_dot.trainable_variables grad_gen = gen_tape.gradient(generator_loss, sources=generator_vars) grad_dis = dis_tape.gradient(discriminator_loss, sources=discriminator_vars) generator_optimizer.apply_gradients(zip(grad_gen, generator_vars)) discriminator_optimizer.apply_gradients(zip(grad_dis, discriminator_vars)) gen_loss(generator_loss) disc_loss(discriminator_loss)
indicator_index = utils.get_indicator_index(reactor, INDICATOR) tau, delta_t = utils.calculate_idt(reactorNetwork, INDICATOR, indicator_index) original_taus.append(tau) # modify mech, calc new predictions, compare with gt and save the best counter = 1 # place holders best_reactions = None best_factors = None best_taus = None # initialize loss with original loss original_loss = utils.l2_loss(idts, original_taus) loss = original_loss print('===============================================================') print('Original loss: %.5f' % loss) # random loop t0 = time.time() while True: # generate a mech t_iteration_0 = time.time() reactions_var = ct.Reaction.listFromFile(INPUT_MECH) # use Gaussian ditribution after 4 loops if counter <= 4: means = None print('Uniform search, ', end='')
def mask_l2_loss(a, b, mask): #good = [127]*len(mask) # print([i for i in range(127,127+40)]) # from IPython import embed;embed();exit(); return l2_loss(a[:127 + 40][mask], b[mask])
def build_model(self): # Placeholders for real training samples self.input_A_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_real') self.input_B_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_real') # Placeholders for fake generated samples self.input_A_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_fake') self.input_B_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_fake') # Placeholder for test samples self.input_A_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_test') self.input_B_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_test') self.generation_B = self.generator(inputs=self.input_A_real, reuse=False, scope_name='generator_A2B') self.cycle_A = self.generator(inputs=self.generation_B, reuse=False, scope_name='generator_B2A') self.generation_A = self.generator(inputs=self.input_B_real, reuse=True, scope_name='generator_B2A') self.cycle_B = self.generator(inputs=self.generation_A, reuse=True, scope_name='generator_A2B') self.generation_A_identity = self.generator(inputs=self.input_A_real, reuse=True, scope_name='generator_B2A') self.generation_B_identity = self.generator(inputs=self.input_B_real, reuse=True, scope_name='generator_A2B') self.discrimination_A_fake = self.discriminator( inputs=self.generation_A, reuse=False, scope_name='discriminator_A') self.discrimination_B_fake = self.discriminator( inputs=self.generation_B, reuse=False, scope_name='discriminator_B') # Cycle loss self.cycle_loss = l1_loss(y=self.input_A_real, y_hat=self.cycle_A) + l1_loss( y=self.input_B_real, y_hat=self.cycle_B) # Identity loss self.identity_loss = l1_loss( y=self.input_A_real, y_hat=self.generation_A_identity) + l1_loss( y=self.input_B_real, y_hat=self.generation_B_identity) # Place holder for lambda_cycle and lambda_identity self.lambda_cycle = tf.placeholder(tf.float32, None, name='lambda_cycle') self.lambda_identity = tf.placeholder(tf.float32, None, name='lambda_identity') # Generator loss # Generator wants to fool discriminator self.generator_loss_A2B = l2_loss(y=tf.ones_like( self.discrimination_B_fake), y_hat=self.discrimination_B_fake) self.generator_loss_B2A = l2_loss(y=tf.ones_like( self.discrimination_A_fake), y_hat=self.discrimination_A_fake) # Merge the two generators and the cycle loss self.generator_loss = self.generator_loss_A2B + self.generator_loss_B2A + self.lambda_cycle * self.cycle_loss + self.lambda_identity * self.identity_loss # Discriminator loss self.discrimination_input_A_real = self.discriminator( inputs=self.input_A_real, reuse=True, scope_name='discriminator_A') self.discrimination_input_B_real = self.discriminator( inputs=self.input_B_real, reuse=True, scope_name='discriminator_B') self.discrimination_input_A_fake = self.discriminator( inputs=self.input_A_fake, reuse=True, scope_name='discriminator_A') self.discrimination_input_B_fake = self.discriminator( inputs=self.input_B_fake, reuse=True, scope_name='discriminator_B') # Discriminator wants to classify real and fake correctly self.discriminator_loss_input_A_real = l2_loss( y=tf.ones_like(self.discrimination_input_A_real), y_hat=self.discrimination_input_A_real) self.discriminator_loss_input_A_fake = l2_loss( y=tf.zeros_like(self.discrimination_input_A_fake), y_hat=self.discrimination_input_A_fake) self.discriminator_loss_A = (self.discriminator_loss_input_A_real + self.discriminator_loss_input_A_fake) / 2 self.discriminator_loss_input_B_real = l2_loss( y=tf.ones_like(self.discrimination_input_B_real), y_hat=self.discrimination_input_B_real) self.discriminator_loss_input_B_fake = l2_loss( y=tf.zeros_like(self.discrimination_input_B_fake), y_hat=self.discrimination_input_B_fake) self.discriminator_loss_B = (self.discriminator_loss_input_B_real + self.discriminator_loss_input_B_fake) / 2 # Merge the two discriminators into one self.discriminator_loss = self.discriminator_loss_A + self.discriminator_loss_B # Categorize variables because we have to optimize the two sets of the variables separately trainable_variables = tf.trainable_variables() self.discriminator_vars = [ var for var in trainable_variables if 'discriminator' in var.name ] self.generator_vars = [ var for var in trainable_variables if 'generator' in var.name ] #for var in t_vars: print(var.name) # Reserved for test self.generation_B_test = self.generator(inputs=self.input_A_test, reuse=True, scope_name='generator_A2B') self.generation_A_test = self.generator(inputs=self.input_B_test, reuse=True, scope_name='generator_B2A')
def build_model(self): # Placeholders for real training samples self.input_A_real = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_A_real') self.input_B_real = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_B_real') # Placeholders for fake generated samples self.input_A_fake = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_A_fake') self.input_B_fake = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_B_fake') # Placeholder for test samples self.input_A_test = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_A_test') self.input_B_test = tf.placeholder(tf.float32, shape = self.input_shape, name = 'input_B_test') self.generation_B = self.generator(inputs = self.input_A_real, reuse = False, scope_name = 'generator_A2B') self.cycle_A = self.generator(inputs = self.generation_B, reuse = False, scope_name = 'generator_B2A') self.generation_A = self.generator(inputs = self.input_B_real, reuse = True, scope_name = 'generator_B2A') self.cycle_B = self.generator(inputs = self.generation_A, reuse = True, scope_name = 'generator_A2B') self.generation_A_identity = self.generator(inputs = self.input_A_real, reuse = True, scope_name = 'generator_B2A') self.generation_B_identity = self.generator(inputs = self.input_B_real, reuse = True, scope_name = 'generator_A2B') self.discrimination_A_fake = self.discriminator(inputs = self.generation_A, reuse = False, scope_name = 'discriminator_A') self.discrimination_B_fake = self.discriminator(inputs = self.generation_B, reuse = False, scope_name = 'discriminator_B') # Cycle loss self.cycle_loss = l1_loss(y = self.input_A_real, y_hat = self.cycle_A) + l1_loss(y = self.input_B_real, y_hat = self.cycle_B) # Identity loss self.identity_loss = l1_loss(y = self.input_A_real, y_hat = self.generation_A_identity) + l1_loss(y = self.input_B_real, y_hat = self.generation_B_identity) # Place holder for lambda_cycle and lambda_identity self.lambda_cycle = tf.placeholder(tf.float32, None, name = 'lambda_cycle') self.lambda_identity = tf.placeholder(tf.float32, None, name = 'lambda_identity') # Generator loss # Generator wants to fool discriminator self.generator_loss_A2B = l2_loss(y = tf.ones_like(self.discrimination_B_fake), y_hat = self.discrimination_B_fake) self.generator_loss_B2A = l2_loss(y = tf.ones_like(self.discrimination_A_fake), y_hat = self.discrimination_A_fake) # Merge the two generators and the cycle loss self.generator_loss = self.generator_loss_A2B + self.generator_loss_B2A + self.lambda_cycle * self.cycle_loss + self.lambda_identity * self.identity_loss # Discriminator loss self.discrimination_input_A_real = self.discriminator(inputs = self.input_A_real, reuse = True, scope_name = 'discriminator_A') self.discrimination_input_B_real = self.discriminator(inputs = self.input_B_real, reuse = True, scope_name = 'discriminator_B') self.discrimination_input_A_fake = self.discriminator(inputs = self.input_A_fake, reuse = True, scope_name = 'discriminator_A') self.discrimination_input_B_fake = self.discriminator(inputs = self.input_B_fake, reuse = True, scope_name = 'discriminator_B') # Discriminator wants to classify real and fake correctly self.discriminator_loss_input_A_real = l2_loss(y = tf.ones_like(self.discrimination_input_A_real), y_hat = self.discrimination_input_A_real) self.discriminator_loss_input_A_fake = l2_loss(y = tf.zeros_like(self.discrimination_input_A_fake), y_hat = self.discrimination_input_A_fake) self.discriminator_loss_A = (self.discriminator_loss_input_A_real + self.discriminator_loss_input_A_fake) / 2 self.discriminator_loss_input_B_real = l2_loss(y = tf.ones_like(self.discrimination_input_B_real), y_hat = self.discrimination_input_B_real) self.discriminator_loss_input_B_fake = l2_loss(y = tf.zeros_like(self.discrimination_input_B_fake), y_hat = self.discrimination_input_B_fake) self.discriminator_loss_B = (self.discriminator_loss_input_B_real + self.discriminator_loss_input_B_fake) / 2 # Merge the two discriminators into one self.discriminator_loss = self.discriminator_loss_A + self.discriminator_loss_B # Categorize variables because we have to optimize the two sets of the variables separately trainable_variables = tf.trainable_variables() self.discriminator_vars = [var for var in trainable_variables if 'discriminator' in var.name] self.generator_vars = [var for var in trainable_variables if 'generator' in var.name] #for var in t_vars: print(var.name) # Reserved for test self.generation_B_test = self.generator(inputs = self.input_A_test, reuse = True, scope_name = 'generator_A2B') self.generation_A_test = self.generator(inputs = self.input_B_test, reuse = True, scope_name = 'generator_B2A')