def run_epoch(net, train_loader, test_loader, CUDA): train_acc = 0.0 train_loss = 0.0 test_acc = 0.0 test_loss = 0.0 epoch_it = 0 final_it = len(train_loader) t0 = time.perf_counter() for (x, y) in train_loader: x = x.transpose(0, 1).contiguous() x, y = tovar(x, CUDA), tovar(y, CUDA) net.zero_grad() p = net(x) y_pred = p[-1, :, :].view(-1) loss = nn.SoftMarginLoss() val_loss = loss(y_pred, y) val_loss.backward() net.adam.step() with torch.no_grad(): y_pred = np.array([1. if x > 0 else -1. for x in y_pred]) train_acc += sum(y_pred == y.cpu().data.numpy()) / y_pred.shape[0] train_loss += val_loss.cpu().data.numpy() epoch_it += 1 t1 = time.perf_counter() - t0 #load_cb(epoch_it, final_it, 'Training', t1) train_acc /= epoch_it train_loss /= epoch_it # Validation step epoch_it = 0 final_it = len(test_loader) t0 = time.perf_counter() with torch.no_grad(): for (x, y) in test_loader: x = x.transpose(0, 1).contiguous() x, y = tovar(x, CUDA), tovar(y, CUDA) p = net(x) y_pred = p[-1, :, :].view(-1) loss = nn.SoftMarginLoss() val_loss = loss(y_pred, y) test_loss += val_loss.cpu().data.numpy() y_pred = np.array([1. if x > 0 else -1 for x in y_pred]) test_acc += sum(y_pred == y.cpu().data.numpy()) / y_pred.shape[0] epoch_it += 1 t1 = time.perf_counter() - t0 #load_cb(epoch_it, final_it, 'Testing', t1) test_acc /= epoch_it test_loss /= epoch_it return train_acc, train_loss, test_acc, test_loss
def forward(self, distance_matrix, num_batch_classes): num_batch_images = distance_matrix.shape[0] num_images_per_class = num_batch_images // num_batch_classes template = torch.zeros((num_batch_images, num_batch_images)) for x in range(num_batch_images): min = x // num_images_per_class * num_images_per_class max = min + num_images_per_class for y in range(min, max): if x != y: template[x, y] = 1 positive_distance_matrix = distance_matrix.mul(template) # print(positive_distance_matrix[:10,:10]) negative_distance_matrix = distance_matrix - positive_distance_matrix # print(negative_distance_matrix[:10,:10]) positive_distance = torch.amax(positive_distance_matrix, dim=1) # print(positive_distance[:10], positive_distance.shape) negative_distance, _ = torch.sort(negative_distance_matrix) # print(negative_distance[:10, :10]) negative_distance = negative_distance[:, num_images_per_class] # print(negative_distance[:10], negative_distance.shape) one = torch.ones(num_batch_images) one = -one if self.soft_margin: soft_margin_loss = nn.SoftMarginLoss() loss = soft_margin_loss(positive_distance - negative_distance, one) else: losses = positive_distance - negative_distance + self.margin # print(losses[:10], losses.shape) losses = torch.clamp(losses, min=0) # print(losses[:10], losses.shape) loss = torch.mean(losses) return loss
def __init__(self, margin=None, p=2): super(TripletLoss, self).__init__() self.margin = margin if self.margin == 0.0: # use soft-margin self.Loss = nn.SoftMarginLoss() else: self.Loss = nn.TripletMarginLoss(margin=margin, p=p)
def __init__(self, switchNet, weightNet, apply_f, lr=0.001, alpha=0.001, beta=0.001, max_grad=None, log_name=None, silence=True, mtl=False, max_time=30, n_early_stopping=100, print_every=100, plot=True, weight_decay=0, switch_update_every=1, weight_update_every=1): ''' optimizer: optimization method, default to adam alpha: z entropy weight beta: y entropy weight max_grad: gradient clipping max silence: don't output graph and statement mtl: multi-task learning print_every: print every few iterations, if 0 then don't print weight_update_every: update weight every few steps switch_update_every: update switch every few steps ''' switchNet = to_cuda(switchNet) weightNet = to_cuda(weightNet) self.max_time = max_time # max gpu training time self.switchNet = switchNet self.switch_size = switchNet.switch_size self.weightNet = weightNet self.apply_f = apply_f self.n_early_stopping = n_early_stopping self.print_every = print_every self.draw_plot = plot self.weight_update_every = weight_update_every self.switch_update_every = switch_update_every self.mtl = mtl self.silence = silence self.setLogName(log_name) self.optSwitch = torch.optim.Adam(self.switchNet.parameters(), lr=lr, weight_decay=weight_decay) self.optWeight = torch.optim.Adam(self.weightNet.parameters(), lr=lr, weight_decay=weight_decay) self.loss = nn.SoftMarginLoss() # logit loss self.elementwise_loss = logit_elementwise_loss self.max_grad = max_grad self.alpha = alpha self.beta = beta self.z = None
def __init__(self, margin=None): self.margin = margin if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) #评价相似度的损失. loss(x1,x2,y)=max(0,−y∗(x1−x2)+margin). 这里的三个都是标量,y 只能取1 或者-1 else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, device, margin=None): self.margin = margin self.device = device if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, *args, **kwargs): super(WeightedHolE, self).__init__() # self.add_hyperparam('rparam', kwargs.pop('rparam', 0.0)) self.learning_rate = kwargs.get('lr', _DEF_LEARNING_RATE) entity_dim, _, relation_dim = args[0] embed_dim = args[1] self._max_epochs = kwargs.get('max_epochs', _DEF_MAX_EPOCHS) init_relations = kwargs.get('init_relations') if init_relations is not None: self.R = nn.Parameter(init_relations) else: self.R = nn.Parameter(torch.FloatTensor(relation_dim, embed_dim).uniform_(-.1,.1)) self.R.my_name = 'R' self.R.grad = torch.zeros_like(self.R) pretrained_ent = kwargs.get('pretrained_entities') if pretrained_ent is not None: self.E = nn.Parameter(pretrained_ent) else: self.E = nn.Parameter(torch.FloatTensor(entitiy_dim, embed_dim).uniform_(-.1,.1)) self.E.my_name = 'E' self.E.grad = torch.zeros_like(self.E) self.loss_function = nn.SoftMarginLoss(reduction='sum') self.optim = Adagrad(list(self.parameters()), lr=self.learning_rate)
def criterion(self, size_average=None, reduce=None, reduction='mean') -> nn.SoftMarginLoss: return nn.SoftMarginLoss(size_average=size_average, reduce=reduce, reduction=reduction)
def forward(self, input1, input2, gt=None): output1 = self.cnn(input1) #print("output1.shape = " + str(output1.shape)) output2 = self.cnn(input2) #print("output2.shape = " + str(output2.shape)) # define probabilty map dimensions b_size = output1.size()[0] oH = output1.size()[2] - output2.size()[2] + 1 oW = output1.size()[3] - output2.size()[3] + 1 output = Variable(torch.zeros((b_size, 1, oH, oW))) """ output = F.conv2d(output1, output2) """ # perform cross-correlation operation for i in range(oH): for j in range(oW): output[:, :, i, j] = torch.sum( torch.mul(output1[:, :, i:i + 6, j:j + 6], output2)) / output2.nelement() if self.training: self.loss = nn.SoftMarginLoss(size_average=True)(output, gt) #print(type(self.loss)) return output
def __init__(self, margin=None): super(TripletLoss, self).__init__() self.margin = margin if self.margin is None: self.Loss = nn.SoftMarginLoss() else: self.Loss = nn.TripletMarginLoss(margin=margin, p=2)
def __init__(self, margin=None, metric="euclidean"): self.margin = margin self.metric = metric if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, encoder, decoder, discriminator_cnn, discriminator_dense, output_lang, max_length, embedding, input_vocab_size, num_layers=1, batch_size=1): self.encoder = encoder self.decoder = decoder self.discriminator_cnn = discriminator_cnn self.discriminator_dense = discriminator_dense self.output_lang = output_lang self.num_layers = num_layers self.SOS_token = 1 self.EOS_token = 2 self.max_length = max_length self.batch_size = batch_size self.use_cuda = torch.cuda.is_available() self.input_vocab_size = input_vocab_size self.output_vocab_size = embedding.shape[0] self.embedding_length = embedding.shape[1] self.embedding = nn.Embedding(embedding.shape[0], embedding.shape[1]) self.embedding.weight = nn.Parameter(embedding) self.fake_labels = -1*torch.ones(self.batch_size) self.true_labels = torch.ones(self.batch_size) self.final_criterion = nn.MSELoss() self.discriminator_criterion = nn.SoftMarginLoss() if self.use_cuda: self.embedding = self.embedding.cuda() self.fake_labels = self.fake_labels.cuda() self.true_labels = self.true_labels.cuda()
def __init__(self, margin=None): super(TripletLoss, self).__init__() self.margin = margin if self.margin is None: # if no margin assigned, use soft-margin self.Loss = nn.SoftMarginLoss() else: self.Loss = nn.TripletMarginLoss(margin=margin, p=2)
def __init__(self, margin=None, hard_factor=0.0): self.margin = margin self.hard_factor = hard_factor if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=0, num_instances=0, use_semi=True): super(TripletLoss2, self).__init__() self.margin = margin self.use_semi = use_semi #self.ranking_loss = nn.MarginRankingLoss(margin=self.margin) self.ranking_loss = nn.SoftMarginLoss().cuda() self.K = num_instances
def __init__(self, margin=None): self.margin = margin if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss() self.bceloss = nn.BCELoss()
def __init__(self, margin=None, mining_method='batch_hard'): self.margin = margin self.mining_method = mining_method if margin > 0: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=None): self.margin = margin if margin is not None: ## 模拟那个max的过程 self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=0.3): super(TripletLoss, self).__init__() self.margin = margin if margin == 0.: self.ranking_loss = nn.SoftMarginLoss() else: self.ranking_loss = nn.MarginRankingLoss(margin=margin)
def __init__(self, margin=None): self.margin = margin #print(margin) if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=1.0): super().__init__() self.margin = margin if margin is not None: self.loss = nn.MarginRankingLoss(margin=margin) else: self.loss = nn.SoftMarginLoss()
def __init__(self, margin=None): super(TripletLoss_id, self).__init__() self.margin = margin if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, first=nn.CrossEntropyLoss(), second=nn.SoftMarginLoss()): super(new_loss, self).__init__() self.first = first self.second = second self.fc2 = nn.Linear(2, 1) self.sig = nn.Sigmoid()
def __init__(self, margin = None): super(MixedLoss, self).__init__() self.margin = margin if self.margin is None: # use soft-margin self.Loss = nn.SoftMarginLoss() else: self.Loss = nn.TripletMarginLoss(margin = margin, p = 2) self.class_loss = nn.CrossEntropyLoss()
def __init__(self, margin): super().__init__() self.margin = margin if self.margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=self.margin, reduction='mean') else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=0, use_weight=True): super(TripletLoss, self).__init__() self.margin = margin self.use_weight = use_weight self.ranking_loss = nn.MarginRankingLoss(margin=margin, reduce=False) \ if margin != "soft_margin" else nn.SoftMarginLoss(reduce=False) self.softmax = nn.Softmax(dim=1) self.softmin = nn.Softmin(dim=1)
def __init__(self, margin=None, normalize_feature=True): super(TripletLoss, self).__init__() self.margin = margin self.normalize_feature = normalize_feature if self.margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, alpha=0.2): super(ClusterLoss, self).__init__() self.alpha = alpha self.ranking_loss = nn.SoftMarginLoss() self.clusters_sum = [] self.clusters_count = [] self.clusters_labels = []
def __init__(self, margin=None, process_dists=False): super(TripletLoss, self).__init__() self.margin = margin self.process_dists = process_dists if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()
def __init__(self, margin=None,K1=4,K2=4): self.margin = margin self.K1 = K1 self.K2 = K2 if margin is not None: self.ranking_loss = nn.MarginRankingLoss(margin=margin) else: self.ranking_loss = nn.SoftMarginLoss()