def evaluate(self, carray, issame, nrof_folds=5, tta=False): self.net.eval() idx = 0 embeddings = np.zeros([len(carray), self.embedding_dim]) with torch.no_grad(): while idx + self.batch_size <= len(carray): batch = torch.tensor(carray[idx:idx + self.batch_size]) if tta: fliped = hflip_batch(batch) emb_batch = self.net(batch.to(self.device)) + self.net( fliped.to(self.device)) embeddings[idx:idx + self.batch_size] = l2_norm(emb_batch) else: embeddings[idx:idx + self.batch_size] = self.net( batch.to(self.device)).cpu() idx += self.batch_size if idx < len(carray): batch = torch.tensor(carray[idx:]) if tta: fliped = hflip_batch(batch) emb_batch = self.net(batch.to(self.device)) + self.net( fliped.to(self.device)) embeddings[idx:] = l2_norm(emb_batch) else: embeddings[idx:] = self.net(batch.to(self.device)).cpu() tpr, fpr, accuracy, best_thresholds = evaluate(embeddings, issame, nrof_folds) buf = gen_plot(fpr, tpr) roc_curve = Image.open(buf) roc_curve_tensor = trans.ToTensor()(roc_curve) self.net.train() return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor
def nearest_neighbors(self, word: str, N=10): ''' Get the `N` nearest neighbors of `word`, and their distances. Parameters ------------ word: str N: int number of nearest neighbors to compute. Returns ----------- (nearest_words, nearest_words_distances) ''' word_idx = self.word2index[word] word_embedding = self.index2embedding[word_idx] if word_idx < 3 or l2_norm(word_embedding) <= self.blacklist_threshold: # word is too close to zero vector return [], np.array([]) distances = np.array(len(self.index2word) * [0.0]) for index, embedding in enumerate(self.index2embedding): if index < 3 or l2_norm(embedding) <= self.blacklist_threshold: # ignore <PAD>, <UNK> and blacklisted words distance = np.inf else: distance = l2_norm(word_embedding - embedding) distances[index] = distance # get N nearest indexes, ignore word_idx nearest_indexes = np.argsort(distances)[1:N + 1] nearest_words = [self.index2word[idx] for idx in nearest_indexes] nearest_words_distances = distances[nearest_indexes] return nearest_words, nearest_words_distances
def perform_val(embedding_size, batch_size, model, carray, issame, nrof_folds=10, is_ccrop=False, is_flip=True): """perform val""" embeddings = np.zeros([len(carray), embedding_size]) for idx in tqdm.tqdm(range(0, len(carray), batch_size)): batch = carray[idx:idx + batch_size] batch = np.transpose(batch, [0, 2, 3, 1]) * 0.5 + 0.5 if is_ccrop: batch = ccrop_batch(batch) if is_flip: fliped = hflip_batch(batch) emb_batch = model(batch) + model(fliped) embeddings[idx:idx + batch_size] = l2_norm(emb_batch) else: batch = ccrop_batch(batch) emb_batch = model(batch) embeddings[idx:idx + batch_size] = l2_norm(emb_batch) tpr, fpr, accuracy, best_thresholds = evaluate(embeddings, issame, nrof_folds) return accuracy.mean(), best_thresholds.mean()
def forward_mf(self, inp, weights, name="mf_model"): """ :param inp: batch of (user_id, item_id) :param weights: :param reuse: :param lamb_u: :param lamb_v: :param learning_r: :param name: :return: """ U = weights['users'] V = weights['items'] with tf.name_scope(name): with tf.name_scope("batch_embeddings"): with tf.name_scope('batch_ids'): u_indices = inp[:, 0] v_indices = inp[:, 1] with tf.name_scope('batch_embeddings'): u_batch = tf.nn.embedding_lookup(U, u_indices) v_batch = tf.nn.embedding_lookup(V, v_indices) with tf.name_scope('preds'): predict_score = tf.reduce_sum(tf.multiply(u_batch, v_batch), axis=1, name='preds') # calculate loss with tf.name_scope("regularization"): reg = FLAGS.lamb_u * l2_norm(u_batch) + FLAGS.lamb_v * l2_norm( v_batch) return predict_score, reg
def evaluate(self, cfg, carray, issame, nrof_folds=5, tta=False): self.model.eval() idx = 0 embeddings = np.zeros([len(carray), cfg.MODEL.HEADS.EMBEDDING_DIM]) batch_size = cfg.SOLVER.IMS_PER_BATCH with torch.no_grad(): while idx + batch_size <= len(carray): batch = torch.tensor(carray[idx:idx + batch_size]) if tta: fliped = hflip_batch(batch) emb_batch = self.model(batch.to(self.device)) + self.model( fliped.to(self.device)) embeddings[idx:idx + batch_size] = l2_norm(emb_batch) else: embeddings[idx:idx + batch_size] = self.model( batch.to(self.device)).cpu() idx += batch_size if idx < len(carray): batch = torch.tensor(carray[idx:]) if tta: fliped = hflip_batch(batch) emb_batch = self.model(batch.to(self.device)) + self.model( fliped.to(self.device)) embeddings[idx:] = l2_norm(emb_batch) else: embeddings[idx:] = self.model(batch.to(self.device)).cpu() tpr, fpr, accuracy, best_thresholds = scores(embeddings, issame, nrof_folds) buf = gen_plot(fpr, tpr) roc_curve = Image.open(buf) roc_curve_tensor = trans.ToTensor()(roc_curve) return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor
def train(model, classifier, criterion, optimizer, trainloader, use_gpu, num_classes, epoch, args): model.train() losses = AverageMeter() if args.plot: all_features, all_labels = [], [] for batch_idx, (data, labels) in enumerate(trainloader): if use_gpu: data, labels = data.cuda(), labels.cuda() features = model(data) outputs, _ = classifier(features, labels) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() losses.update(loss.item(), labels.size(0)) if args.plot_normalized: features = l2_norm(features) if args.plot: if use_gpu: all_features.append(features.data.cpu().numpy()) all_labels.append(labels.data.cpu().numpy()) else: all_features.append(features.data.numpy()) all_labels.append(labels.data.numpy()) if (batch_idx + 1) % args.print_freq == 0: print("Batch {}/{}\t Loss {:.6f} ({:.6f})" .format(batch_idx + 1, len(trainloader), losses.val, losses.avg)) if args.plot: weights = None centers = classifier.weight.data if args.plot_normalized: centers = l2_norm(classifier.weight.data) all_features = np.concatenate(all_features, 0) all_labels = np.concatenate(all_labels, 0) plot_features(all_features, weights, centers.cpu().numpy(), all_labels, num_classes, epoch, prefix='train', args=args)
def main(): df = pd.read_csv(os.path.join(OUTPUT_DIR, 'features.csv')).sort_values('prediction') value_counts = df['prediction'].value_counts().to_dict() # compute positions border_index = (df['prediction'] == 0).sum() clothe_y = border_index // 2 person_y = border_index + (len(df) - border_index) // 2 x = df.shape[0] // 2 text_props = dict(fontdict={ 'color': 'grey', 'alpha': 0.3, 'size': 30 }, horizontalalignment='center', verticalalignment='center') for layer in ['l2', 'l3', 'avgp']: print(f'Processing: {layer}') use_cols = [col for col in df.columns if col.startswith(layer)] vectors = l2_norm(df[use_cols].values[:, :]) fig, ax = plt.subplots() ax = sns.heatmap(vectors, cmap='YlGnBu', ax=ax) ax.axhline(border_index) ax.text(x, clothe_y, 'Clothe ({})'.format(value_counts[0]), **text_props) ax.text(x, person_y, 'Person ({})'.format(value_counts[1]), **text_props) ax.set_xticks([]) ax.set_yticks([]) plt.savefig(os.path.join(OUTPUT_DIR, f'heatmap_{layer}.png'), dpi=1000)
def forward(self, x, label=None): x = self.relu1_1(self.conv1_1(x)) x = x + self.relu1_3(self.conv1_3(self.relu1_2(self.conv1_2(x)))) x = self.relu2_1(self.conv2_1(x)) x = x + self.relu2_3(self.conv2_3(self.relu2_2(self.conv2_2(x)))) x = x + self.relu2_5(self.conv2_5(self.relu2_4(self.conv2_4(x)))) x = self.relu3_1(self.conv3_1(x)) x = x + self.relu3_3(self.conv3_3(self.relu3_2(self.conv3_2(x)))) x = x + self.relu3_5(self.conv3_5(self.relu3_4(self.conv3_4(x)))) x = x + self.relu3_7(self.conv3_7(self.relu3_6(self.conv3_6(x)))) x = x + self.relu3_9(self.conv3_9(self.relu3_8(self.conv3_8(x)))) x = self.relu4_1(self.conv4_1(x)) x = x + self.relu4_3(self.conv4_3(self.relu4_2(self.conv4_2(x)))) x = x.view(x.size(0), -1) x = self.fc5(x) x = l2_norm(x) if label is None: return x else: x = self.am_softmax(x, label) return x
def infer(self, faces, target_embs, tta=False): ''' faces : list of PIL Image target_embs : [n, 512] computed embeddings of faces in facebank names : recorded names of faces in facebank tta : test time augmentation (hfilp, that's all) ''' embs = [] for img in faces: if tta: mirror = trans.functional.hflip(img) emb = self.model( self.test_transform(img).to(self.device).unsqueeze(0)) emb_mirror = self.model( self.test_transform(mirror).to(self.device).unsqueeze(0)) embs.append(l2_norm(emb + emb_mirror)) else: embs.append( self.model( self.test_transform(img).to(self.device).unsqueeze(0))) source_embs = torch.cat(embs) if isinstance(target_embs, list): tmp = [] for img in target_embs: if tta: mirror = trans.functional.hflip(img) tmp = self.model( self.test_transform(img).to(self.device).unsqueeze(0)) tmp_mirror = self.model( self.test_transform(mirror).to( self.device).unsqueeze(0)) tmp.append(l2_norm(tmp + tmp_mirror)) else: tmp.append( self.model( self.test_transform(img).to( self.device).unsqueeze(0))) target_embs = torch.cat(tmp) diff = source_embs.unsqueeze(-1) - target_embs.transpose( 1, 0).unsqueeze(0) dist = torch.sum(torch.pow(diff, 2), dim=1) minimum, min_idx = torch.min(dist, dim=1) min_idx[minimum > self.threshold] = -1 # if no match, set idx to -1 return min_idx, minimum
def label_projection(self, label_vec, img_data, site=-1, left_to_right=True, normalize_phi_rn=True): """""" if site < 0: site = img_data.rnb idx = site if left_to_right else site - 1 sl_in_left_rn = bool(idx > self.__w.sl) sl_in_right_rn = bool(idx + 1 < self.__w.sl) scale = [1., 1., 1., 1.] if normalize_phi_rn: scale[0] = inv_phi_rn( img_data.phi_rn[idx - 1]) if sl_in_left_rn else ( 1. / l2_norm(img_data.phi_rn[idx - 1])) scale[1] = (1. / l2_norm(img_data.phi[idx])) scale[2] = (1. / l2_norm(img_data.phi[idx + 1])) scale[3] = inv_phi_rn( img_data.phi_rn[idx + 2]) if sl_in_right_rn else ( 1. / l2_norm(img_data.phi_rn[idx + 2])) if sl_in_left_rn: net = self.net["bt_project_sll"] scale[0].transpose() net.putTensor("LAB", label_vec) net.putTensor("PHIL", scale[0]) net.putTensor("PHII", img_data.phi[idx] * scale[1]) net.putTensor("PHIJ", img_data.phi[idx + 1] * scale[2]) net.putTensor("PHIR", img_data.phi_rn[idx + 2] * scale[3]) elif sl_in_right_rn: net = self.net["bt_project_slr"] scale[3].transpose() net.putTensor("LAB", label_vec) net.putTensor("PHIL", img_data.phi_rn[idx - 1] * scale[0]) net.putTensor("PHII", img_data.phi[idx] * scale[1]) net.putTensor("PHIJ", img_data.phi[idx + 1] * scale[2]) net.putTensor("PHIR", scale[3]) else: net = self.net["label_projection"] net.putTensor("LAB", label_vec) net.putTensor("PHIL", img_data.phi_rn[idx - 1] * scale[0]) net.putTensor("PHII", img_data.phi[idx] * scale[1]) net.putTensor("PHIJ", img_data.phi[idx + 1] * scale[2]) net.putTensor("PHIR", img_data.phi_rn[idx + 2] * scale[3]) proj = net.launch() return proj
def __kernel_matrix(learner_seq, expert_seq, kernel_bandwidth): """ Construct kernel matrix based on learn sequence and expert sequence, each entry of the matrix is the distance between two data points in learner_seq or expert_seq. return two matrix, left_mat is the distances between learn sequence and learn sequence, right_mat is the distances between learn sequence and expert sequence. """ # calculate l2 distances learner_learner_mat = utils.l2_norm( learner_seq, learner_seq) # [batch_size*seq_len, batch_size*seq_len] expert_learner_mat = utils.l2_norm( expert_seq, learner_seq) # [batch_size*seq_len, batch_size*seq_len] # exponential kernel learner_learner_mat = tf.exp(-learner_learner_mat / kernel_bandwidth) expert_learner_mat = tf.exp(-expert_learner_mat / kernel_bandwidth) return learner_learner_mat, expert_learner_mat
def forward_bpr(self, inp, weights, name="bpr_model"): with tf.name_scope(name=name): u, i, j = inp[:, 0], inp[:, 1], inp[:, 2] U = weights['users'] V = weights['items'] u_batch = tf.nn.embedding_lookup(U, u) i_batch = tf.nn.embedding_lookup(V, i) j_batch = tf.nn.embedding_lookup(V, j) # print(u_batch.shape) ui = tf.reduce_sum(tf.multiply(u_batch, i_batch), axis=1) uj = tf.reduce_sum(tf.multiply(u_batch, j_batch), axis=1) # print(uj) uij = ui - uj # print(uij.shape) reg = FLAGS.lamb_u * l2_norm(u_batch) + FLAGS.lamb_v * ( l2_norm(i_batch) + l2_norm(j_batch)) return uij, reg
def _optimize_actor(self, batch): pi = self.model.actor(batch.state) new_actions = pi.rsample() reg = utils.l2_norm(self.model.actor.named_parameters()) value = (1. - batch.done) * self.model.critic(batch.state, new_actions).squeeze(-1) return (-value).mean(), { "actor/value": value.mean().detach(), "actor/loc": pi.mean.mean(), "actor/reg": reg.mean(), "actor/scale": pi.variance.mean() }
def get_embeds(img): start_time = time.time() # print("[*] Encode {} to ./output_embeds.npy".format(FLAGS.img_path)) #img = cv2.imread(FLAGS.img_path) img = cv2.resize(img, (cfg['input_size'], cfg['input_size'])) img = img.astype(np.float32) / 255. if len(img.shape) == 3: img = np.expand_dims(img, 0) embeds = l2_norm(model(img)) #np.save('./output_embeds.npy', embeds) print("time taken: ", end=" ") print((time.time() - start_time)) return embeds
def evaluate(model, classifier, criterion, testloader, use_gpu, num_classes, epoch, args): model.eval() correct, total = 0, 0 if args.plot: all_features, all_labels = [], [] with torch.no_grad(): for data, labels in testloader: if use_gpu: data, labels = data.cuda(), labels.cuda() features = model(data) _, cosine = classifier(features, labels) predictions = cosine.data.max(1)[1] total += labels.size(0) correct += (predictions == labels.data).sum() if args.plot_normalized: features = l2_norm(features) if args.plot: if use_gpu: all_features.append(features.data.cpu().numpy()) all_labels.append(labels.data.cpu().numpy()) else: all_features.append(features.data.numpy()) all_labels.append(labels.data.numpy()) if args.plot: all_features = np.concatenate(all_features, 0) all_labels = np.concatenate(all_labels, 0) weights = None centers = classifier.weight.data if args.plot_normalized: centers = l2_norm(classifier.weight.data) plot_features(all_features, weights, centers.cpu().numpy(), all_labels, num_classes, epoch, prefix='test', args=args) acc = correct * 100. / total err = 100. - acc return acc, err
def mp_ef_projection(args): """""" sample_start, sample_end, site, sl_on_left, normalize_phi_rn = args idx = site if sl_on_left else site - 1 netd = shared.NET["decision_fn_left"] if sl_on_left else shared.NET[ "decision_fn_right"] netp = shared.NET["label_projection"] dB = UniTensor() for s in xrange(sample_start, sample_end): netd.putTensor("WI", shared.W[idx]) netd.putTensor("WJ", shared.W[idx + 1]) netd.putTensor("PHIL", shared.PHI_RN[s][idx - 1]) netd.putTensor("PHII", shared.PHI[s][idx]) netd.putTensor("PHIJ", shared.PHI[s][idx + 1]) netd.putTensor("PHIR", shared.PHI_RN[s][idx + 2]) df = netd.launch() # df.permute(1) # Mysteriously, sometimes Pool.map mess up the final permute in launch! ef = shared.TL[s] + (-1.) * df scale = [1., 1., 1., 1.] if normalize_phi_rn: scale[0] = (1. / l2_norm(shared.PHI_RN[s][idx - 1])) scale[1] = (1. / l2_norm(shared.PHI[s][idx])) scale[2] = (1. / l2_norm(shared.PHI[s][idx + 1])) scale[3] = (1. / l2_norm(shared.PHI_RN[s][idx + 2])) netp.putTensor("LAB", ef) netp.putTensor("PHIL", shared.PHI_RN[s][idx - 1] * scale[0]) netp.putTensor("PHII", shared.PHI[s][idx] * scale[1]) netp.putTensor("PHIJ", shared.PHI[s][idx + 1] * scale[2]) netp.putTensor("PHIR", shared.PHI_RN[s][idx + 2] * scale[3]) proj = netp.launch() try: dB += proj except: dB = proj return exportElem(dB)
def label_projection(self, label_vec, img_data, site=-1, sl_on_left=True, normalize_phi_rn=True): """""" if site < 0: site = self.__w.sl idx = site if sl_on_left else site - 1 scale = [1., 1., 1., 1.] if normalize_phi_rn: scale[0] = (1. / l2_norm(img_data.phi_rn[idx - 1])) scale[1] = (1. / l2_norm(img_data.phi[idx])) scale[2] = (1. / l2_norm(img_data.phi[idx + 1])) scale[3] = (1. / l2_norm(img_data.phi_rn[idx + 2])) net = self.net["label_projection"] net.putTensor("LAB", label_vec) net.putTensor("PHIL", img_data.phi_rn[idx - 1] * scale[0]) net.putTensor("PHII", img_data.phi[idx] * scale[1]) net.putTensor("PHIJ", img_data.phi[idx + 1] * scale[2]) net.putTensor("PHIR", img_data.phi_rn[idx + 2] * scale[3]) proj = net.launch() return proj
def struct_embeddings(self, config, vocab): emb_list = [] with tf.device("/cpu:0"): l1_norm = tf.zeros([]) l2_norm = tf.zeros([]) self.struct_embeddings = [] for i, (feat, dims) in enumerate(config.mimic_embeddings.items()): if dims <= 0: continue try: vocab_aux = len(vocab.aux_list[feat]) except KeyError: vocab_aux = 2 # binary with tf.device("/cpu:0"): vocab_dims = vocab_aux if feat in config.var_len_features: vocab_dims -= 1 embedding = tf.get_variable("struct_embedding."+feat, [vocab_dims, config.mimic_embeddings[feat]], initializer=tf.random_uniform_initializer(-1.0, 1.0)) self.struct_embeddings.append(embedding) l1_norm += utils.l1_norm(embedding) l2_norm += utils.l2_norm(embedding) if feat in config.var_len_features: embedding = tf.concat(0, [tf.zeros([1, config.mimic_embeddings[feat]]), embedding], name='struct_concat.'+feat) val_embedding = tf.nn.embedding_lookup(embedding, self.aux_data[feat], name='struct_embedding_lookup.'+feat) if config.inspect == 'struct': val_embedding *= self.struct_enable[feat] if feat in config.var_len_features: if config.training and config.struct_keep_prob < 1: # drop random structured info items entirely val_embedding = tf.nn.dropout(val_embedding, config.struct_keep_prob, noise_shape=tf.pack([config.batch_size, tf.shape(val_embedding)[1], 1]), name='struct_dropout_varlen.'+feat) reduced = tf.reduce_sum(val_embedding, 1, name='sum_struct_val_embeddings.'+feat) if config.mean_varlen_embs: reduced /= tf.reshape(tf.maximum(self.aux_data_len[feat], 1), [config.batch_size, 1], name='struct_mean_reshape') else: reduced = tf.squeeze(val_embedding, [1]) if config.training and config.struct_keep_prob < 1: reduced = tf.nn.dropout(reduced, config.struct_keep_prob, noise_shape=[config.batch_size, 1, 1], name='struct_dropout_fixlen.'+feat) emb_list.append(reduced) return tf.concat(1, emb_list), l1_norm, l2_norm
def forward(self, embbedings, label): kernel_norm = l2_norm(self.kernel, axis=0) cos_theta = torch.mm(embbedings, kernel_norm) cos_theta = cos_theta.clamp(-1, 1) # for numerical stability phi = cos_theta - self.m label = label.view(-1, 1) #size=(B,1) index = cos_theta.data * 0.0 #size=(B,Classnum) index.scatter_(1, label.data.view(-1, 1), 1) index = index.byte() index = Variable(index) output = cos_theta * 1.0 output[index] = phi[index] #only change the correct predicted output output *= self.s # scale up in order to make softmax work, first introduced in normface return output
def forward(self, x): x = self.backbone.layer0(x) x = self.backbone.layer1(x) x = self.backbone.layer2(x) x = self.backbone.layer3(x) x = self.backbone.layer4(x) # print(x.size()) x = self.backbone.avg_pool(x) # print(x.size()) x = x.view(x.size(0), -1) x = self.fc(x) # x = self.backbone.last_linear(x) x = l2_norm(x) return x
def build_model(options, params): # inputs to the model users_id = T.ivector('users_id') items_id = T.ivector('items_id') y = T.fvector('y') # predictons y_hat = get_predictons(options, params, users_id, items_id) # cost mse = T.mean(T.sqr(y - y_hat)) cost = mse if 'l2_coeff' in options and options['l2_coeff'] > 0.: cost += options['l2_coeff'] * sum([l2_norm(p) for p in params.values()]) return users_id, items_id, y, y_hat, mse, cost
def forward(self, x): x = self.backbone.conv1(x) x = self.backbone.bn1(x) x = self.backbone.relu(x) x = self.backbone.maxpool(x) x = self.backbone.layer1(x) x = self.backbone.layer2(x) x = self.backbone.layer3(x) x = self.backbone.layer4(x) x = self.backbone.avgpool(x) x = self.conv_last(x) x = x.view(x.size(0), -1) x = l2_norm(x) return (x)
def word_distance(self, word1, word2): ''' Return the L2 distance between `word1` and `word2`. Parameters ---------------- word1: str word2: str Returns ---------- float ''' index1 = self.word2index[word1] index2 = self.word2index[word2] return l2_norm(self.index2embedding[index1] - self.index2embedding[index2])
def extract(skel): """Extract. timestep x 2 x num_joints (25) x 3""" timestep = skel.shape[0] keep_joints = [1, 4, 6, 8, 10, 12, 14, 16, 18, 20, 21] skel = skel[:, :, [keep_joint - 1 for keep_joint in keep_joints]] skel = skel.reshape(timestep, -1, 3) # timestep x 22 x 3 num_joints = len(keep_joints) jjd, jjv = [], [] for t in range(timestep): jjd_t, jjv_t = [], [] for i in range(num_joints): for j in range(i, num_joints, 1): # joint-joint distance jjd_t.append(utils.l2_norm(skel[t, i], skel[t, j])) # joint-joint vector jjv_t.append(skel[t, i] - skel[t, j]) jjd.append(jjd_t) jjv.append(jjv_t)
def _optimize_critic(self, batch): with torch.no_grad(): v_t = self.model.baseline(batch.next_state).squeeze() v_tm1 = self.model.baseline(batch.state).squeeze() q_tm1 = self.model.critic(batch.state, batch.action).squeeze() discount_t = (1 - batch.done) * self.gamma r_t = batch.reward vtrace_target = rlego.vtrace_td_error_and_advantage( v_tm1.detach(), v_t, r_t, discount_t, rho_tm1=torch.ones_like(discount_t)) q_loss = (vtrace_target.q_estimate - q_tm1) * (1 - config.gamma) + utils.l2_norm( self.model.critic.named_parameters()) td_loss = (vtrace_target.target_tm1 - v_tm1) * (1 - config.gamma) loss = 0.5 * q_loss.pow(2) + 0.5 * td_loss.pow(2) return loss.mean(), { "critic/td": td_loss.mean().detach(), "critic/q_loss": q_loss.mean().detach() }
def build_model(options, params): # inputs to the model users_id = T.ivector('users_id') items_id = T.ivector('items_id') bow = T.fmatrix('bow') y = T.fvector('y') alpha = options['alpha'] # predictons y_pred, bow_pred = get_predictons(options, params, users_id, items_id) # LF model cost mse = T.mean(T.sqr(y - y_pred)) # BOW negative-log-likelihood cost nll = T.mean(T.nnet.categorical_crossentropy(bow_pred, bow)) cost = alpha * mse + (1-alpha) * nll if 'l2_coeff' in options and options['l2_coeff'] > 0.: cost += options['l2_coeff'] * sum([l2_norm(p) for p in params.values()]) return users_id, items_id, bow, y, y_pred, bow_pred, mse, nll, cost
def decompose(self): """ Starting initially with Gram-Schmidt. """ self.Q = np.array(self.A) self.R = np.zeros_like(self.A) M, N = self.Q.shape # for each column for i in range(N): # for each column on the left of current for j in range(i): # calculate projection of ith col on jth col p = proj(self.Q[:, i], self.Q[:, j]) self.Q[:, i] -= p # normalize ith colum self.Q[:, i] /= l2_norm(self.Q[:, i]) # compute R self.R = np.dot(self.Q.T, self.A) return self.Q, self.R
device = torch.device('cuda') model_pool = get_model_pool(device) print('----models load over----') faces = os.listdir('securityAI_round1_images') faces.sort(key=lambda x: int(x[:-4])) vectors_list = [] for model in model_pool: vectors = [] for face in faces: face = utils.to_torch_tensor( Image.open('securityAI_round1_images/' + face)) face = face.unsqueeze_(0).to(device) vectors.append(utils.l2_norm(model(face)).detach_()) vectors_list.append(vectors) print('----vectors calculate over----') confusion_matrixes = [] for vectors in vectors_list: s = torch.FloatTensor(len(vectors), len(vectors)) for i, vector1 in enumerate(vectors): for j, vector2 in enumerate(vectors[i + 1:]): tmp = (vector1 * vector2).sum().item() # print(i,j + i + 1,tmp) s[i, j + i + 1] = tmp s[j + i + 1, i] = tmp for i in range(712): s[i, i] = 0 print(s)
subjects = id_list label_int = source_id embed_list = [] label_list = [] for subject in tqdm(subjects): template_paths = glob(dataset_path + subject + "/*")[0] img_paths = glob(template_paths + "/*") for img_path in img_paths: img = cv2.imread(img_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = cv2.resize(img, (112, 112)) img = img.astype(np.float32) / 255. if len(img.shape) == 3: img = np.expand_dims(img, 0) embeds = l2_norm(model(img, training=False)) embed_list.append(embeds[0].numpy()) label_list.append(label_int[subjects.index(subject)]) embed_list = np.asarray(embed_list) label_list = np.asarray(label_list) save_path = "/raid/workspace/jbpark/IJB-C/numpy/" if projection_head: save_name = f'ms1m_{backbone_type}_{head_type}_ProjectionHead/' else: save_name = f'ms1m_{backbone_type}_{head_type}/' Path(f'{save_path}{save_name}').mkdir(parents=True, exist_ok=True) np.save(f'{save_path}{save_name}ijbc_gallery_vectors.npy', embed_list) np.save(f'{save_path}{save_name}ijbc_gallery_labels.npy', label_list) dataset_path = "/raid/workspace/jbpark/IJB-C/Probes/"
def struct_embeddings(self, config, vocab): emb_list = [] with tf.device("/cpu:0"): l1_norm = tf.zeros([]) l2_norm = tf.zeros([]) self.struct_embeddings = [] for i, (feat, dims) in enumerate(config.mimic_embeddings.items()): if dims <= 0: continue try: vocab_aux = len(vocab.aux_list[feat]) except KeyError: vocab_aux = 2 # binary with tf.device("/cpu:0"): vocab_dims = vocab_aux if feat in config.var_len_features: vocab_dims -= 1 embedding = tf.get_variable( "struct_embedding." + feat, [vocab_dims, config.mimic_embeddings[feat]], initializer=tf.random_uniform_initializer(-1.0, 1.0)) self.struct_embeddings.append(embedding) l1_norm += utils.l1_norm(embedding) l2_norm += utils.l2_norm(embedding) if feat in config.var_len_features: embedding = tf.concat(0, [ tf.zeros([1, config.mimic_embeddings[feat]]), embedding ], name='struct_concat.' + feat) val_embedding = tf.nn.embedding_lookup( embedding, self.aux_data[feat], name='struct_embedding_lookup.' + feat) if config.inspect == 'struct': val_embedding *= self.struct_enable[feat] if feat in config.var_len_features: if config.training and config.struct_keep_prob < 1: # drop random structured info items entirely val_embedding = tf.nn.dropout( val_embedding, config.struct_keep_prob, noise_shape=tf.pack([ config.batch_size, tf.shape(val_embedding)[1], 1 ]), name='struct_dropout_varlen.' + feat) reduced = tf.reduce_sum(val_embedding, 1, name='sum_struct_val_embeddings.' + feat) if config.mean_varlen_embs: reduced /= tf.reshape(tf.maximum( self.aux_data_len[feat], 1), [config.batch_size, 1], name='struct_mean_reshape') else: reduced = tf.squeeze(val_embedding, [1]) if config.training and config.struct_keep_prob < 1: reduced = tf.nn.dropout( reduced, config.struct_keep_prob, noise_shape=[config.batch_size, 1, 1], name='struct_dropout_fixlen.' + feat) emb_list.append(reduced) return tf.concat(1, emb_list), l1_norm, l2_norm