def DAGH_algo(code_length, dataname): os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu torch.manual_seed(0) torch.cuda.manual_seed(0) ''' parameter setting ''' max_iter = opt.max_iter epochs = opt.epochs batch_size = opt.batch_size learning_rate = opt.learning_rate weight_decay = 5 * 10**-4 num_anchor = opt.num_anchor lambda_1 = opt.lambda_1 lambda_2 = opt.lambda_2 lambda_3 = opt.lambda_3 record['param']['opt'] = opt record['param']['description'] = '[Comment: learning rate decay]' logger.info(opt) logger.info(code_length) logger.info(record['param']['description']) ''' dataset preprocessing ''' nums, dsets, labels = _dataset(dataname) num_database, num_test = nums dset_database, dset_test = dsets database_labels, test_labels = labels ''' model construction ''' beta = 2 model = cnn_model.CNNNet(opt.arch, code_length) model.cuda() cudnn.benchmark = True DAGH_loss = dl.DAGHLoss(lambda_1, lambda_2, lambda_3, code_length) L1_criterion = nn.L1Loss() L2_criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay) B = np.sign(np.random.randn(code_length, num_database * 2)) model.train() for iter in range(max_iter): iter_time = time.time() trainloader = DataLoader(dset_database, batch_size=batch_size, shuffle=True, num_workers=4) F = np.zeros((num_database * 2, code_length), dtype=np.float) if iter == 0: ''' initialize the feature of all images to build dist graph ''' ini_Features = np.zeros((num_database * 2, 4096), dtype=np.float) ini_F = np.zeros((num_database * 2, 12), dtype=np.float) for iteration, (train_input, train_input2, train_label, batch_ind) in enumerate(trainloader): train_all = torch.cat((train_input, train_input2), dim=0) train_all = Variable(train_all.cuda()) output = model(train_all) batch_ind2 = batch_ind + num_database batch_all = torch.cat((batch_ind, batch_ind2), dim=0) ini_Features[batch_all, :] = output[0].cpu().data.numpy() ini_F[batch_all, :] = output[1].cpu().data.numpy() print('initialization dist graph forward done!') dist_graph = get_dist_graph(ini_Features, num_anchor) # dist_graph = np.random.rand(num_database,num_anchor) # bf = np.sign(ini_F) Z = calc_Z(dist_graph, s=3) elif (iter % 3) == 0: dist_graph = get_dist_graph(Features, num_anchor) Z = calc_Z(dist_graph, s=3) print('calculate dist graph forward done!') inv_A = inv(np.diag(Z.sum(0))) # m X m Z_T = Z.transpose() # m X n left = np.dot(B, np.dot(Z, inv_A)) # k X m if iter == 0: loss_ini = calc_loss(B, ini_F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) # loss_ini2 = calc_all_loss(B,F,Z,inv_A,Z1,Z2,Y1,Y2,rho1,rho2,lambda_1,lambda_2) print(loss_ini) ''' learning deep neural network: feature learning ''' Features = np.zeros((num_database * 2, 4096), dtype=np.float) for epoch in range(epochs): for iteration, (train_input, train_input2, train_label, batch_ind) in enumerate(trainloader): train_all = torch.cat((train_input, train_input2), dim=0) train_all = Variable(train_all.cuda()) output = model(train_all) batch_ind2 = batch_ind + num_database batch_all = torch.cat((batch_ind, batch_ind2), dim=0) Features[batch_all, :] = output[0].cpu().data.numpy() F[batch_all, :] = output[1].cpu().data.numpy() batch_grad = get_batch_gard(B, left, Z_T, batch_all) / (1 * batch_size) batch_grad = Variable( torch.from_numpy(batch_grad).type( torch.FloatTensor).cuda()) optimizer.zero_grad() output[1].backward(batch_grad, retain_graph=True) B_cuda = Variable( torch.from_numpy(B[:, batch_all]).type( torch.FloatTensor).cuda()) # optimizer.zero_grad () other_loss = DAGH_loss(output[1].t(), B_cuda) one_vectors = Variable(torch.ones(output[1].size()).cuda()) L1_loss = L1_criterion(torch.abs(output[1]), one_vectors) # L2_loss = L2_criterion (output[1],B_cuda.t()) All_loss = other_loss + lambda_3 * L1_loss All_loss.backward() optimizer.step() if (iteration % 500) == 0: print('iteration:' + str(iteration)) #print (model.features[0].weight.data[1, 1, :, :]) #print (model.features[18].weight.data[1, 1, :, :]) #print (model.classifier[6].weight.data[:, 1]) adjusting_learning_rate(optimizer, iter) ''' learning binary codes: discrete coding ''' # bf = np.sign (F) # F = np.random.randn (num_database, 12) loss_before = calc_loss(B, F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) B = B_step(F, Z, inv_A) iter_time = time.time() - iter_time loss_ = calc_loss(B, F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) logger.info( '[Iteration: %3d/%3d][Train Loss: before:%.4f, after:%.4f]', iter, max_iter, loss_before, loss_) record['train loss'].append(loss_) record['iter time'].append(iter_time) ''' training procedure finishes, evaluation ''' model.eval() testloader = DataLoader(dset_test, batch_size=batch_size, shuffle=False, num_workers=4) trainloader2 = DataLoader(dset_database, batch_size=batch_size, shuffle=False, num_workers=4) qB = encode(model, testloader, num_test, code_length) rB_sy = encode(model, trainloader2, num_database, code_length) rB_asy = B[:, 0:num_database].transpose() map_sy = calc_hr.calc_map(qB, rB_sy, test_labels.numpy(), database_labels.numpy()) map_asy = calc_hr.calc_map(qB, rB_asy, test_labels.numpy(), database_labels.numpy()) top_map_sy = calc_hr.calc_topMap(qB, rB_sy, test_labels.numpy(), database_labels.numpy(), 2000) top_map_asy = calc_hr.calc_topMap(qB, rB_asy, test_labels.numpy(), database_labels.numpy(), 2000) logger.info('[Evaluation: mAP_sy: %.4f]', map_sy) logger.info('[Evaluation: topK_mAP_sy: %.4f]', top_map_sy) logger.info('[Evaluation: mAP_asy: %.4f]', map_asy) logger.info('[Evaluation: topK_mAP_asy: %.4f]', top_map_asy) record['rB_sy'] = rB_sy record['rB_asy'] = rB_asy record['qB'] = qB record['map_sy'] = map_sy record['map_asy'] = map_asy record['topK_map_sy'] = top_map_sy record['topK_map_asy'] = top_map_asy record['F'] = F filename = os.path.join(logdir, str(code_length) + 'bits-record.pkl') _save_record(record, filename)
def DAGH_algo(code_length, dataname): os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu torch.manual_seed(0) torch.cuda.manual_seed(0) # code_length=8 ''' parameter setting ''' max_iter = opt.max_iter epochs = opt.epochs batch_size = opt.batch_size learning_rate = opt.learning_rate weight_decay = 5 * 10**-4 num_anchor = opt.num_anchor lambda_1 = float(opt.lambda_1) lambda_2 = float(opt.lambda_2) lambda_3 = float(opt.lambda_3) rho1 = opt.rho1 rho2 = opt.rho2 beta1 = float(opt.beta_1) beta2 = float(opt.beta_2) gamma = opt.gamma record['param']['opt'] = opt record['param']['description'] = '[Comment: learning rate decay]' logger.info(opt) logger.info(code_length) logger.info(record['param']['description']) ''' dataset preprocessing ''' nums, dsets, labels = load_dataset(dataname) num_database, num_test = nums dset_database, dset_test = dsets database_labels, test_labels = labels ''' model construction ''' model = cnn_model.CNNNet(opt.arch, code_length) model.cuda() cudnn.benchmark = True DAGH_loss = dl.DAGHLoss(lambda_1, lambda_2, lambda_3, code_length) L1_criterion = nn.L1Loss() # optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay) # optimizer = optim.SGD (model.parameters (), lr=learning_rate, weight_decay=weight_decay, momentum=0.9) #### # optimizer = optim.RMSprop (model.parameters (), lr=learning_rate, weight_decay=weight_decay) # optimizer = optim.RMSprop (model.parameters (), lr=learning_rate, weight_decay=weight_decay, momentum=0.9) # optimizer = optim.Adadelta (model.parameters (), weight_decay=weight_decay) # optimizer = optim.Adam (model.parameters ()) hash_params = list(map(id, model.hash.parameters())) base_params = filter(lambda p: id(p) not in hash_params, model.parameters()) params = [ { "params": model.hash.parameters(), "lr": learning_rate * 10 }, { "params": base_params, "lr": learning_rate }, ] optimizer = optim.SGD(params, weight_decay=weight_decay, momentum=0.9) B = np.sign(np.random.randn(code_length, num_database)) model.train() for iter in range(max_iter): iter_time = time.time() trainloader = DataLoader(dset_database, batch_size=batch_size, shuffle=True, num_workers=4) if iter == 0: ''' initialize the feature of all images to build dist graph ''' ini_Features = np.zeros((num_database, 4096), dtype=np.float) ini_F = np.zeros((num_database, code_length), dtype=np.float) for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda()) output = model(train_input) ini_Features[batch_ind, :] = output[0].cpu().data.numpy() ini_F[batch_ind, :] = output[1].cpu().data.numpy() print('initialization dist graph forward done!') s1_time = time.time() dist_graph = get_dist_graph(ini_Features, num_anchor) # dist_graph = np.random.rand(num_database,num_anchor) # bf = np.sign(ini_F) Z = calc_Z(dist_graph) S_time = time.time() - s1_time # B = np.sign (ini_F.transpose ()) # elif ((iter % 3) == 0) | (iter == max_iter - 1): else: s1_time = time.time() dist_graph = get_dist_graph(Features, num_anchor) Z = calc_Z(dist_graph) print('reset dist graph!') S_time = time.time() - s1_time inv_A = inv(np.diag(Z.sum(0))) # m X m Z_T = Z.transpose() # m X n left = np.dot(B, np.dot(Z, inv_A)) # k X m if iter == 0: loss_ini = calc_loss(B, ini_F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) print('ini_loss' + str(loss_ini)) ''' learning deep neural network: feature learning ''' # B = B4_step (B, ini_F, Z, inv_A, lambda_1, lambda_2, rho1, rho2, gamma) n1_time = time.time() for epoch in range(epochs): F = np.zeros((num_database, code_length), dtype=np.float) running_loss = 0.0 adjusting_learning_rate2(optimizer, iter, epoch) print(optimizer.param_groups[0]['lr']) print(optimizer.param_groups[1]['lr']) for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda()) output = model(train_input) F[batch_ind, :] = output[1].cpu().data.numpy() batch_grad = get_batch_gard( B, left, Z_T, batch_ind) / (code_length * batch_size) batch_grad = Variable( torch.from_numpy(batch_grad).type( torch.FloatTensor).cuda()) optimizer.zero_grad() output[1].backward(batch_grad, retain_graph=True) # output[1].backward (batch_grad) B_cuda = Variable( torch.from_numpy(B[:, batch_ind]).type( torch.FloatTensor).cuda()) other_loss = DAGH_loss(output[1].t(), B_cuda) one_vectors = Variable(torch.ones(output[1].size()).cuda()) L1_loss = L1_criterion(torch.abs(output[1]), one_vectors) # L2_loss = L2_criterion (output[1],B_cuda.t()) All_loss = other_loss + lambda_3 * L1_loss / code_length All_loss.backward() optimizer.step() running_loss += All_loss.data[0] if (iteration % 50) == 49: # print ('iteration:' + str (iteration)) print('[%d, %5d] loss: %.5f' % (epoch + 1, iteration + 1, running_loss / 50)) running_loss = 0.0 Tr_BLF = cal_BLF(B, Z, inv_A, F) print('[%d] Tr_BLF loss: %.5f' % (epoch + 1, Tr_BLF)) # adjusting_learning_rate (optimizer, iter) n_time = time.time() - n1_time trainloader2 = DataLoader(dset_database, batch_size=batch_size, shuffle=False, num_workers=4) F = get_F(model, trainloader2, num_database, code_length) Features = get_fearture(model, trainloader2, num_database, code_length) ''' learning binary codes: discrete coding ''' B_new = np.sign(F).transpose() B_random = np.sign(np.random.randn(code_length, num_database)) # F = np.random.randn (num_datasbase, 12) loss_before = calc_loss(B, F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) # B = B_step (F, Z, inv_A) b1_time = time.time() B = B4_step(B_random, np.sign(F), Z, inv_A, beta1, beta2, rho1, rho2, gamma) b_time = time.time() - b1_time iter_time = time.time() - iter_time loss_ = calc_loss(B, F, Z, inv_A, lambda_1, lambda_2, lambda_3, code_length) # loss_ = calc_R1_loss (B, F, Z, inv_A, lambda_1, lambda_2, lambda_3, beta1, beta2, code_length) logger.info( '[Iteration: %3d/%3d][Train Loss: before:%.4f, after:%.4f]', iter, max_iter, loss_before, loss_) record['train loss'].append(loss_) record['iter time'].append(iter_time) print(S_time) record['stime'].append(S_time) record['btime'].append(b_time) record['ntime'].append(n_time) ''' training procedure finishes, evaluation ''' model.eval() retrievalloader = DataLoader(dset_database, batch_size=batch_size, shuffle=False, num_workers=4) testloader = DataLoader(dset_test, batch_size=batch_size, shuffle=False, num_workers=4) qB = encode(model, testloader, num_test, code_length) rB_sy = encode(model, retrievalloader, num_database, code_length) rB_asy = B.transpose() topKs = np.arange(1, 500, 50) top_ndcg = 100 # map = calc_hr.calc_map (qB, rB, test_labels.numpy (), database_labels.numpy ()) # top_map = calc_hr.calc_topMap (qB, rB, test_labels.numpy (), database_labels.numpy (), 2000) Pres_asy = calc_hr.calc_topk_pres(qB, rB_asy, test_labels.numpy(), database_labels.numpy(), topKs) ndcg_asy = calc_hr.cal_ndcg_k(qB, rB_asy, test_labels.numpy(), database_labels.numpy(), top_ndcg) Pres_sy = calc_hr.calc_topk_pres(qB, rB_sy, test_labels.numpy(), database_labels.numpy(), topKs) ndcg_sy = calc_hr.cal_ndcg_k(qB, rB_sy, test_labels.numpy(), database_labels.numpy(), top_ndcg) map_sy = calc_hr.calc_map(qB, rB_sy, test_labels.numpy(), database_labels.numpy()) map_asy = calc_hr.calc_map(qB, rB_asy, test_labels.numpy(), database_labels.numpy()) top_map_sy = calc_hr.calc_topMap(qB, rB_sy, test_labels.numpy(), database_labels.numpy(), 2000) top_map_asy = calc_hr.calc_topMap(qB, rB_asy, test_labels.numpy(), database_labels.numpy(), 2000) logger.info('[lambda_1: %.4f]', lambda_1) logger.info('[lambda_2: %.4f]', lambda_2) logger.info('[lambda_3: %.4f]', lambda_3) logger.info('[Evaluation: mAP_sy: %.4f]', map_sy) logger.info('[Evaluation: mAP_asy: %.4f]', map_asy) logger.info('[Evaluation: topK_mAP_sy: %.4f]', top_map_sy) logger.info('[Evaluation: topK_mAP_asy: %.4f]', top_map_asy) logger.info('[Evaluation: Pres_sy: %.4f]', Pres_sy[0]) print Pres_sy logger.info('[Evaluation: Pres_asy: %.4f]', Pres_asy[0]) print Pres_asy logger.info('[Evaluation: topK_ndcg_sy: %.4f]', ndcg_sy) logger.info('[Evaluation: topK_ndcg_asy: %.4f]', ndcg_asy) record['rB_sy'] = rB_sy record['rB_asy'] = rB_asy record['qB'] = qB record['map_sy'] = map_sy record['map_asy'] = map_asy record['topK_map_sy'] = top_map_sy record['topK_map_asy'] = top_map_asy record['topK_ndcg_sy'] = ndcg_sy record['topK_ndcg_asy'] = ndcg_asy record['Pres_sy'] = Pres_sy record['Pres_asy'] = Pres_asy record['F'] = F filename = os.path.join(logdir, str(code_length) + 'bits-record.pkl') _save_record(record, filename) return top_map_sy
def DAGH_algo(code_length, dataname): os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu torch.manual_seed(0) torch.cuda.manual_seed(0) # code_length=8 ''' parameter setting ''' max_iter = opt.max_iter epochs = opt.epochs batch_size = opt.batch_size learning_rate = opt.learning_rate weight_decay = 5 * 10**-4 num_anchor = opt.num_anchor lambda_1 = float(opt.lambda_1) lambda_2 = float(opt.lambda_2) lambda_3 = float(opt.lambda_3) lambda_ba = float(opt.lambda_ba) record['param']['opt'] = opt record['param']['description'] = '[Comment: learning rate decay]' logger.info(opt) logger.info(code_length) logger.info(record['param']['description']) ''' dataset preprocessing ''' nums, dsets, labels = _dataset(dataname) num_database, num_test = nums dset_database, dset_test = dsets database_labels, test_labels = labels ''' model construction ''' model = cnn_model.CNNNet(opt.arch, code_length) model.cuda() cudnn.benchmark = True DAGH_sample_loss = dl.DAGH_sample_loss(lambda_1, lambda_2, lambda_3, code_length) L1_criterion = nn.L1Loss() optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay) B = np.sign(np.random.randn(code_length, num_database)) model.train() for iter in range(max_iter): iter_time = time.time() trainloader = DataLoader(dset_database, batch_size=batch_size, shuffle=True, num_workers=4) F = np.zeros((num_database, code_length), dtype=np.float) Features = np.zeros((num_database, 4096), dtype=np.float) # W = np.random.randn (num_database, num_database) if (iter % 3) == 0: for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda(), volatile=True) output = model(train_input) Features[batch_ind, :] = output[0].cpu().data.numpy() F[batch_ind, :] = output[1].cpu().data.numpy() print('initialization dist graph forward done!') dist_graph = get_dist_graph(Features, num_anchor) Z = calc_Z(dist_graph) inv_A = inv(np.diag(Z.sum(0))) # m X m W = calc_WZ(Z, inv_A) print('calculate W done!') if iter == 0: loss_ini = calc_loss(B, F, W, lambda_1, lambda_2, lambda_3, code_length) print(loss_ini) ''' learning deep neural network: feature learning ''' for epoch in range(epochs): for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda()) output = model(train_input) F[batch_ind, :] = output[1].cpu().data.numpy() optimizer.zero_grad() B_cuda = Variable( torch.from_numpy(B[:, batch_ind]).type( torch.FloatTensor).cuda()) w_batch = Variable( torch.from_numpy(W[batch_ind][:, batch_ind]).type( torch.FloatTensor).cuda()) other_loss = DAGH_sample_loss(w_batch, output[1].t(), B_cuda) one_vectors = Variable(torch.ones(output[1].size()).cuda()) L1_loss = L1_criterion(torch.abs(output[1]), one_vectors) # L2_loss = L2_criterion (output[1],B_cuda.t()) All_loss = other_loss + lambda_3 * L1_loss All_loss.backward() optimizer.step() if (iteration % 200) == 0: print('iteration:' + str(iteration)) #print (model.features[0].weight.data[1, 1, :, :]) #print (model.features[18].weight.data[1, 1, :, :]) #print (model.classifier[6].weight.data[:, 1]) adjusting_learning_rate(optimizer, iter) ''' learning binary codes: discrete coding ''' # bf = np.sign (F) # F = np.random.randn (num_database, 12) loss_before = calc_loss(B, F, W, lambda_1, lambda_2, lambda_3, code_length) B = B_step(F, W) iter_time = time.time() - iter_time loss_ = calc_loss(B, F, W, lambda_1, lambda_2, lambda_3, code_length) logger.info( '[Iteration: %3d/%3d][Train Loss: before:%.4f, after:%.4f]', iter, max_iter, loss_before, loss_) record['train loss'].append(loss_) record['iter time'].append(iter_time) ''' training procedure finishes, evaluation ''' model.eval() testloader = DataLoader(dset_test, batch_size=batch_size, shuffle=False, num_workers=4) qB = encode(model, testloader, num_test, code_length) rB = B.transpose() map = calc_hr.calc_map(qB, rB, test_labels.numpy(), database_labels.numpy()) top_map = calc_hr.calc_topMap(qB, rB, test_labels.numpy(), database_labels.numpy(), 2000) logger.info('[lambda_1: %.4f]', lambda_1) logger.info('[lambda_2: %.4f]', lambda_2) logger.info('[lambda_3: %.4f]', lambda_3) logger.info('[Evaluation: mAP: %.4f]', map) logger.info('[Evaluation: topK_mAP: %.4f]', top_map) record['rB'] = rB record['qB'] = qB record['map'] = map record['topK_map'] = top_map record['F'] = F filename = os.path.join(logdir, str(code_length) + 'bits-record.pkl') _save_record(record, filename) return top_map
def DAGH_algo(code_length): os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu torch.manual_seed(0) torch.cuda.manual_seed(0) ''' parameter setting ''' max_iter = opt.max_iter epochs = opt.epochs batch_size = opt.batch_size learning_rate = opt.learning_rate weight_decay = 5 * 10**-4 num_anchor = opt.num_anchor lambda_1 = opt.lambda_1 lambda_2 = opt.lambda_2 record['param']['opt'] = opt record['param']['description'] = '[Comment: learning rate decay]' logger.info(opt) logger.info(code_length) logger.info(record['param']['description']) ''' dataset preprocessing ''' nums, dsets, labels = _dataset() num_database, num_test = nums dset_database, dset_test = dsets database_labels, test_labels = labels ''' model construction ''' model = cnn_model.CNNNet(opt.arch, code_length) model.cuda() # DAGH_loss = dl.DAGHLoss (lambda_1, lambda_2, code_length) optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay) B = np.sign(np.random.randn(code_length, num_database)) model.train() for iter in range(max_iter): iter_time = time.time() trainloader = DataLoader( dset_database, batch_size=batch_size, shuffle=True, ) F = np.zeros((num_database, code_length), dtype=np.float) if iter == 0: ''' initialize the feature of all images to build dist graph ''' ini_Features = np.zeros((num_database, 4096), dtype=np.float) ini_F = np.zeros((num_database, 12), dtype=np.float) for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda()) output = model(train_input) ini_Features[batch_ind, :] = output[0].cpu().data.numpy() ini_F[batch_ind, :] = output[1].cpu().data.numpy() print('initialization dist graph forward done!') P, Q = calc_W(ini_Features) bf = np.sign(ini_F) elif (iter % 3) == 0: P, Q = calc_W(Features) print('calculate dist graph forward done!') if iter == 0: loss_ini = calc_loss(B, ini_F, P, Q, lambda_1, lambda_2, code_length) # #loss_ini2 = calc_all_loss(B,F,Z,inv_A,Z1,Z2,Y1,Y2,rho1,rho2,lambda_1,lambda_2) print(loss_ini) ''' learning deep neural network: feature learning ''' Features = np.zeros((num_database, 4096), dtype=np.float) for epoch in range(epochs): for iteration, (train_input, train_label, batch_ind) in enumerate(trainloader): train_input = Variable(train_input.cuda()) output = model(train_input) Features[batch_ind, :] = output[0].cpu().data.numpy() F[batch_ind, :] = output[1].cpu().data.numpy() batch_grad = get_batch_gard(B, P, Q, batch_ind) / (0.5 * batch_size) batch_grad = Variable( torch.from_numpy(batch_grad).type( torch.FloatTensor).cuda()) optimizer.zero_grad() output[1].backward(batch_grad, retain_graph=True) B_cuda = Variable( torch.from_numpy(B[:, batch_ind]).type( torch.FloatTensor).cuda()) # optimizer.zero_grad () loss2 = DAGH_loss(output[1].t(), B_cuda) #loss = criterion (output[1],B_cuda.t()) loss2.backward() optimizer.step() if (iteration % 200) == 0: print('iteration:' + str(iteration)) #print (model.features[0].weight.data[1, 1, :, :]) #print (model.features[18].weight.data[1, 1, :, :]) #print (model.classifier[6].weight.data[:, 1]) adjusting_learning_rate(optimizer, iter) ''' learning binary codes: discrete coding ''' # bf = np.sign (F) # F = np.random.rand (num_database, 12) loss_before = calc_loss(B, F, P, Q, lambda_1, lambda_2, code_length) B = B_step(F, P, Q) iter_time = time.time() - iter_time loss_ = calc_loss(B, F, P, Q, lambda_1, lambda_2, code_length) logger.info( '[Iteration: %3d/%3d][Train Loss: before:%.4f, after:%.4f]', iter, max_iter, loss_before, loss_) record['train loss'].append(loss_) record['iter time'].append(iter_time) ''' training procedure finishes, evaluation ''' model.eval() testloader = DataLoader(dset_test, batch_size=batch_size, shuffle=False, num_workers=4) qB = encode(model, testloader, num_test, code_length) rB = B.transpose() map = calc_hr.calc_map(qB, rB, test_labels.numpy(), database_labels.numpy()) top_map = calc_hr.calc_topMap(qB, rB, test_labels.numpy(), database_labels.numpy(), 2000) logger.info('[Evaluation: mAP: %.4f]', map) logger.info('[Evaluation: topK_mAP: %.4f]', top_map) record['rB'] = rB record['qB'] = qB record['map'] = map record['topK_map'] = top_map filename = os.path.join(logdir, str(code_length) + 'bits-record.pkl') _save_record(record, filename)