def run(): net = network.bn_inception(pretrained=True) embed.embed(net, sz_embedding=cfg.EMBEDDING_WIDTH, normalize_output=True) if cfg.USE_CUDA == 1: net.cuda() print("Load model params") net.load_state_dict( torch.load(cfg.MODEL_PATH + str(cfg.MARGIN) + str(cfg.EMBEDDING_WIDTH) + str(cfg.DATASET) + str(cfg.METRIC_LOSS_PARAM) + 'x' + str(cfg.METHOD) + str(cfg.CE_LOSS_PARAM) + 'x' + str(cfg.SOFTMAX_METHOD) + str(cfg.K) + str(cfg.POS_SAMPLE_NUM) + ".pkl")) print("Index all dataset") preprocess = Preprocess(root=cfg.DATA_ROOT, use_cuda=cfg.USE_CUDA, test_batch_size=cfg.TEST_BATCH_SIZE, method=cfg.METHOD, dataset_name=cfg.DATASET, with_bounding_box=cfg.WITH_BOUNDING_BOX, download=cfg.DOWNLOAD) print("Done!") if cfg.METHOD == 0: metric = 'cosine' else: metric = 'euclidean' print("embd_size=", cfg.EMBEDDING_WIDTH, "dataset=", cfg.DATASET) if cfg.METHOD == 0: print("tau=", cfg.TAU, "K=", cfg.K, "N=", cfg.N, "N+=", cfg.POS_SAMPLE_NUM, "embd_width=", cfg.EMBEDDING_WIDTH, "batch_size=", cfg.BATCH_SIZE, 'margin=', cfg.MARGIN) print("softmax_rate:", cfg.CE_LOSS_PARAM, "metric_rate:", cfg.METRIC_LOSS_PARAM) preck_test, recallk_test, X1, T1, path1 = val.test(net, preprocess.test_loader, cfg.TEST_K, metric) preck_train, recallk_train, X2, T2, path2 = val.test( net, preprocess.test_train_loader, cfg.TEST_K, metric) data = X1.cpu().numpy() label = T1.cpu().numpy() n_samples = len(path1) n_features = 64 X2.cpu().numpy() print('recall@1 in test set: ', str(recallk_test[0])) print('recall@1 in train set: ', str(recallk_train[0])) print('Computing t-SNE embedding') tsne = TSNE(n_components=2, init='pca', random_state=0) result = tsne.fit_transform(data) fig = plot_embedding(result, path1) fig.savefig("str(cfg.DATASET)+tsne.jpg")
def health_from_file(file_path): text = [] with open(file_path) as file: for line in file: text.append(line) # Reduce logging output. tf.logging.set_verbosity(tf.logging.ERROR) with tf.Session() as session: session.run( [tf.global_variables_initializer(), tf.tables_initializer()]) ave_embed = tf.reduce_mean(embed(text), 0) happy_stat = similarity(happy, ave_embed) - similarity(sad, ave_embed) feminine_stat = similarity(feminine, ave_embed) - similarity( masculine, ave_embed) wealthy_stat = similarity(wealthy, ave_embed) - similarity( poor, ave_embed) yin_stat = similarity(yin, ave_embed) - similarity(yang, ave_embed) liberal_stat = similarity(liberal, ave_embed) - similarity( conservative, ave_embed) future_stat = similarity(future, ave_embed) - similarity( past, ave_embed) anger_stat = similarity(anger, ave_embed) - similarity( peace, ave_embed) stat = tf.stack([ happy_stat, feminine_stat, wealthy_stat, yin_stat, liberal_stat, future_stat, anger_stat ]) computed_stat = session.run(stat) print("happy feminine wealthy yin liberal future anger") print(computed_stat) return computed_stat
def run(flag): print(cfg.NET) if cfg.NET == "bn_inception_v2": net_id = 1 if cfg.NET == "densenet201": net_id = 0 if "CUB" in cfg.DATASET: dataset_id = 0 if "CAR" in cfg.DATASET: dataset_id = 1 if "Online" in cfg.DATASET: dataset_id = 2 prefix = "model_param/paper_result/" net_list = ["densenet201_", "bn_inception_v2_"] dataset_list = ["cub200_2011_", "cars196_", "online_"] method_list = [ "angular", "contrastive", "hardmining", "lifted", "npair", "preck", "proxynca", "samplingmatters", "semihard", "triplet" ] preck_test = [0, 0, 0, 0, 0, 0, 0] recallk_test = [0, 0, 0, 0, 0, 0, 0] nmi, mAP, PR, ROC, F1 = 0, 0, 0, 0, 0 name = prefix + net_list[net_id] + dataset_list[dataset_id] + method_list[ flag] print(name) if cfg.METHOD == 0 or cfg.METHOD == 8: metric = 'cosine' else: metric = 'euclidean' if not os.path.exists(name + '.npz'): if cfg.NET == "bn_inception_v2": net = network.bn_inception(pretrained=True) net_id = 1 if cfg.NET == "densenet201": net = model.densenet201(pretrained=True) net_id = 0 embed.embed(net, sz_embedding=cfg.EMBEDDING_WIDTH, normalize_output=True, net_id=cfg.NET) if cfg.USE_CUDA == 1: net.cuda() print("Load model params") #print(cfg.MODEL_PATH+str(cfg.MARGIN)+str(cfg.EMBEDDING_WIDTH)+str(cfg.DATASET)+str(cfg.METRIC_LOSS_PARAM)+'x'+str(cfg.METHOD)+str(cfg.CE_LOSS_PARAM)+'x'+str(cfg.SOFTMAX_METHOD)+str(cfg.K)+str(cfg.POS_SAMPLE_NUM)+".pkl") #net.load_state_dict(torch.load(cfg.MODEL_PATH+str(cfg.MARGIN)+str(cfg.EMBEDDING_WIDTH)+str(cfg.DATASET)+str(cfg.METRIC_LOSS_PARAM)+'x'+str(cfg.METHOD)+str(cfg.CE_LOSS_PARAM)+'x'+str(cfg.SOFTMAX_METHOD)+str(cfg.K)+str(cfg.POS_SAMPLE_NUM)+".pkl")) net.load_state_dict(torch.load(name + ".pkl")) print("Index all dataset") preprocess = Preprocess(root=cfg.DATA_ROOT, use_cuda=cfg.USE_CUDA, train_batch_size=cfg.BATCH_SIZE, test_batch_size=cfg.TEST_BATCH_SIZE, method=cfg.METHOD, dataset_name=cfg.DATASET, with_bounding_box=cfg.WITH_BOUNDING_BOX, download=cfg.DOWNLOAD, n_pos=cfg.POS_SAMPLE_NUM, N=cfg.N) print("Done!") print("embd_size=", cfg.EMBEDDING_WIDTH, "dataset=", cfg.DATASET) if cfg.METHOD == 0 or cfg.METHOD == 8: print("tau=", cfg.TAU, "K=", cfg.K, "N=", cfg.N, "N+=", cfg.POS_SAMPLE_NUM, "embd_width=", cfg.EMBEDDING_WIDTH, "batch_size=", cfg.BATCH_SIZE, 'margin=', cfg.MARGIN) X1, T1, path1 = val.inference(net, preprocess.test_loader) #X2, T2, path2=val.inference(net,preprocess.test_train_loader) print("inference finished!") X1 = X1.numpy() T1 = T1.numpy() np.savez(name, X1, T1, path1) else: npzfile = np.load(name + '.npz') X1 = npzfile['arr_0'] T1 = npzfile['arr_1'] path1 = npzfile['arr_2'] X1 = torch.from_numpy(X1) T1 = torch.from_numpy(T1) #val.get_some_case(X1, T1, path1, 10, metric) preck_test, recallk_test = val.test(X1, T1, cfg.TEST_K, metric) #print("prec@K:",preck_test,"recall@K:",recallk_test) #preck_train,recallk_train=val.test(X2, T2,cfg.TEST_K,metric) #print("prec@K:",preck_train,"recall@K:",recallk_train) nmi, mAP, PR, ROC, F1 = val.test_some_scores(X1, T1, path1, metric, cfg.TEST_CLASS, name) show_result = name + "&" + str('%.2f' % preck_test[0]) + "&" + str( '%.2f' % preck_test[1]) + "&" + str('%.2f' % preck_test[2]) + "&" + str( '%.2f' % preck_test[3]) + "&" + str( '%.2f' % recallk_test[1]) + "&" + str( '%.2f' % recallk_test[2]) + "&" + str( '%.2f' % recallk_test[3]) + "&" + str( '%.2f' % (nmi * 100)) + "&" + str( '%.2f' % (mAP * 100)) + "&" + str('%.2f' % (F1 * 100)) + "\\\\" print(show_result)
def run(cfg): print(cfg.NET) if cfg.NET=="bn_inception_v2": net = network.bn_inception(pretrained = True) if cfg.NET=="densenet201": net = model.densenet201(pretrained = True) embed.embed(net, sz_embedding=cfg.EMBEDDING_WIDTH,normalize_output = True, net_id = cfg.NET) if cfg.USE_CUDA==1: net.cuda() metric_loss = get_loss(n_input=cfg.N, k=cfg.K, tau=cfg.TAU,n_pos=cfg.POS_SAMPLE_NUM, margin=cfg.MARGIN,input_dim=cfg.EMBEDDING_WIDTH,output_dim=cfg.TRAIN_CLASS,batch_size=cfg.BATCH_SIZE,method=cfg.METHOD).cuda() softmax_loss = get_loss(input_dim=cfg.EMBEDDING_WIDTH,output_dim=cfg.TRAIN_CLASS,margin=cfg.SOFTMAX_MARGIN,method=cfg.SOFTMAX_METHOD).cuda() optimizer = torch.optim.Adam( [ { # embedding parameters 'params': net.embedding_layer.parameters(), 'lr' : cfg.EMBD_LR }, { # softmax loss parameters 'params': softmax_loss.parameters(), 'lr': cfg.SOFTMAX_LOSS_LR }, { # architecture parameters, excluding embedding layer 'params': list( set( net.parameters() ).difference( set(net.embedding_layer.parameters()) ) ), 'lr' : cfg.NET_LR }, { # metric loss parameters 'params': metric_loss.parameters(), 'lr': cfg.METRIC_LOSS_LR }, ], eps = 1e-2, weight_decay = cfg.WEIGHT_DECAY ) #for i in metric_loss.named_parameters(): # print(i) model_name=cfg.MODEL_PATH+str(cfg.MARGIN)+str(cfg.EMBEDDING_WIDTH)+str(cfg.METRIC_LOSS_PARAM)+'x'+str(cfg.METHOD)+str(cfg.CE_LOSS_PARAM)+'x'+str(cfg.SOFTMAX_METHOD)+str(cfg.K)+str(cfg.POS_SAMPLE_NUM)+".pkl" scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, cfg.SCHEDULER_STEP, gamma = cfg.GAMMA) #[10,30,70] print("metric_rate:",cfg.METRIC_LOSS_PARAM,"softmax_rate:",cfg.CE_LOSS_PARAM) if cfg.TRAINING_OLD==1: print("Load model params") net.load_state_dict(torch.load(model_name+"62.95")) preprocess = Preprocess(root=cfg.DATA_ROOT,use_cuda=cfg.USE_CUDA,train_batch_size=cfg.BATCH_SIZE,test_batch_size=cfg.TEST_BATCH_SIZE,method=cfg.METHOD,dataset_name=cfg.DATASET,with_bounding_box=cfg.WITH_BOUNDING_BOX,download=cfg.DOWNLOAD,n_pos=cfg.POS_SAMPLE_NUM,N=cfg.N) if cfg.METHOD==0 or cfg.METHOD==8: metric = 'cosine' else: metric = 'euclidean' print("embd_size=",cfg.EMBEDDING_WIDTH,"dataset=",cfg.DATASET,"batch_size=",cfg.BATCH_SIZE,"GPU ID=",cfg.GPU_NUM) print("EMBD_LR=",cfg.EMBD_LR,"SOFTMAX_LOSS_LR=",cfg.SOFTMAX_LOSS_LR,"NET_LR=",cfg.NET_LR) if cfg.METHOD==0: print("tau=",cfg.TAU,"K=",cfg.K,"N=",cfg.N,"N+=",cfg.POS_SAMPLE_NUM,cfg.BATCH_SIZE,'margin=',cfg.MARGIN) run_num=0 sparsity=0 err_pos=0 old_err_pos=0 total_sparsity=0 total_err_pos=0 totalEpochLoss=0 flag=0 #X1, T1, _=val.inference(net,preprocess.test_loader) #save_log(X1,T1,metric,run_num,totalEpochLoss,total_sparsity,net,model_name) for epoch in range(cfg.EPOCH): #train scheduler.step() train_loader=iter(preprocess.train_loader) for _ in tqdm(range(len(preprocess.train_loader))): if run_num%cfg.SHOW_PER_ITER==cfg.SHOW_PER_ITER-1: X1=0 T1=0 X1, T1, _=val.inference(net,preprocess.test_loader) #X2, T2, _=val.inference(net,preprocess.test_train_loader) # if cfg.MULTI_THREAD == 1: t = threading.Thread(target=save_log,args=(X1,T1,metric,run_num,totalEpochLoss,total_err_pos,net,model_name))#create threading t.setDaemon(True) t.start() else: save_log(X1,T1,metric,run_num,totalEpochLoss,total_sparsity,net,model_name) totalEpochLoss=0 data_ = train_loader.next() batch_img, real_y, img_name = data_ optimizer.zero_grad() out=net(batch_img.cuda()) loss_metric,err_pos,sparsity=metric_loss(out,real_y.cuda()) loss=0#cfg.METRIC_LOSS_PARAM*loss_metric#+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) loss+=loss_metric total_err_pos=err_pos totalEpochLoss=totalEpochLoss+loss.data/cfg.SHOW_PER_ITER if math.isnan(loss.data)==False: loss.backward() optimizer.step() else: print(loss.data) run_num+=1 print("\r\nEpoch:",epoch,"tau:",cfg.TAU)
def run(): net = network.bn_inception(pretrained = True) embed.embed(net, sz_embedding=cfg.EMBEDDING_WIDTH,normalize_output = True) if cfg.USE_CUDA==1: net.cuda() metric_loss = get_loss(n_input=cfg.N, k=cfg.K, tau=cfg.TAU,n_pos=cfg.POS_SAMPLE_NUM, margin=cfg.MARGIN,input_dim=cfg.EMBEDDING_WIDTH,output_dim=cfg.TRAIN_CLASS,batch_size=cfg.BATCH_SIZE,method=cfg.METHOD) softmax_loss = get_loss(input_dim=cfg.EMBEDDING_WIDTH,output_dim=cfg.TRAIN_CLASS,margin=cfg.SOFTMAX_MARGIN,method=cfg.SOFTMAX_METHOD) optimizer = torch.optim.Adam( [ { # embedding parameters 'params': net.embedding_layer.parameters(), 'lr' : cfg.EMBD_LR }, { # softmax loss parameters 'params': softmax_loss.parameters(), 'lr': cfg.SOFTMAX_LOSS_LR }, { # inception parameters, excluding embedding layer 'params': list( set( net.parameters() ).difference( set(net.embedding_layer.parameters()) ) ), 'lr' : cfg.NET_LR } ], eps = 1e-2, weight_decay = cfg.WEIGHT_DECAY ) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, [3, 10, 16],gamma = cfg.GAMMA) if cfg.TRAINING_OLD==1: print("Load model params") net.load_state_dict(torch.load(cfg.MODEL_PATH+str(cfg.MARGIN)+str(cfg.EMBEDDING_WIDTH)+str(cfg.DATASET)+str(cfg.METRIC_LOSS_PARAM)+'x'+str(cfg.METHOD)+str(cfg.CE_LOSS_PARAM)+'x'+str(cfg.SOFTMAX_METHOD)+str(cfg.K)+str(cfg.POS_SAMPLE_NUM)+".pkl")) preprocess = Preprocess(root=cfg.DATA_ROOT,use_cuda=cfg.USE_CUDA,test_batch_size=cfg.TEST_BATCH_SIZE,method=cfg.METHOD,dataset_name=cfg.DATASET,with_bounding_box=cfg.WITH_BOUNDING_BOX,download=cfg.DOWNLOAD) print("Done!") if cfg.METHOD==0: metric = 'cosine' else: metric = 'euclidean' print("embd_size=",cfg.EMBEDDING_WIDTH,"dataset=",cfg.DATASET) if cfg.METHOD==0: print("tau=",cfg.TAU,"K=",cfg.K,"N=",cfg.N,"N+=",cfg.POS_SAMPLE_NUM,"embd_width=",cfg.EMBEDDING_WIDTH,"batch_size=",cfg.BATCH_SIZE,'margin=',cfg.MARGIN) print("softmax_rate:",cfg.CE_LOSS_PARAM,"metric_rate:",cfg.METRIC_LOSS_PARAM) run_num=0 sprarsity=0 err_pos=0 old_err_pos=0 total_sprarsity=0 total_err_pos=0 for epoch in range(cfg.EPOCH): #train scheduler.step() totalEpochLoss=0 if cfg.METHOD==0: iter_num=int(cfg.DATASET_NUM/(cfg.N+1)/cfg.BATCH_SIZE) if cfg.METHOD==1: iter_num=int(cfg.DATASET_NUM/cfg.BATCH_SIZE) if cfg.METHOD==3 or cfg.METHOD==4 or cfg.METHOD==5 or cfg.METHOD==6 or cfg.METHOD==7 or cfg.METHOD==2: iter_num=int(cfg.DATASET_NUM/cfg.BATCH_SIZE/2) for iter in tqdm(range(iter_num)): batch_img,y_,real_y=preprocess.next_train_batch(cfg.POS_SAMPLE_NUM,cfg.N, cfg.BATCH_SIZE) optimizer.zero_grad() if cfg.USE_CUDA==1: out=net(batch_img.cuda()) else: out=net(batch_img) #*****************************************************for prec@k loss******************************************# if cfg.METHOD==0: if cfg.USE_CUDA==1: loss_metric,sprarsity,old_err_pos=metric_loss(out,y_.cuda()) loss=cfg.METRIC_LOSS_PARAM*loss_metric+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(out,y_)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for angular loss******************************************# if cfg.METHOD==4: embed1=out[0:cfg.BATCH_SIZE,:] embed2=out[cfg.BATCH_SIZE:2*cfg.BATCH_SIZE,:] if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for cluster loss******************************************# if cfg.METHOD==2: embed1=out[0:cfg.BATCH_SIZE,:] embed2=out[cfg.BATCH_SIZE:2*cfg.BATCH_SIZE,:] if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(out,real_y.cuda())+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(out,real_y)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for npair loss******************************************# if cfg.METHOD==3: embed1=out[0:cfg.BATCH_SIZE,:] embed2=out[cfg.BATCH_SIZE:2*cfg.BATCH_SIZE,:] if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for lifted loss******************************************# if cfg.METHOD==5: if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(out,y_.cuda())+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(out,y_)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for triplet loss******************************************# if cfg.METHOD==6: embed1=out[0:cfg.BATCH_SIZE,:] embed2=out[cfg.BATCH_SIZE:2*cfg.BATCH_SIZE,:] if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #*****************************************************for contrastive loss******************************************# if cfg.METHOD==7: embed1=out[0:cfg.BATCH_SIZE,:] embed2=out[cfg.BATCH_SIZE:2*cfg.BATCH_SIZE,:] if cfg.USE_CUDA==1: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2,y_.cuda())+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y.cuda()) else: loss=cfg.METRIC_LOSS_PARAM*metric_loss(embed1,embed2,y_)+cfg.CE_LOSS_PARAM*softmax_loss(out,real_y) #**********************************************************end*************************************************# err_pos=old_err_pos totalEpochLoss=totalEpochLoss+loss.data if math.isnan(loss.data)==False: loss.backward() optimizer.step() else: print(loss.data) #res=val.test_training_dataset(out,y_,5,cfg.BATCH_SIZE) total_sprarsity+=sprarsity/cfg.SHOW_PER_ITER total_err_pos+=err_pos/cfg.SHOW_PER_ITER if run_num%cfg.SHOW_PER_ITER==cfg.SHOW_PER_ITER-1: preck_test,recallk_test,_,_,_=val.test(net,preprocess.test_loader,cfg.TEST_K,metric) #preck_train,recallk_train,_,_,_=val.test(net,preprocess.test_train_loader,cfg.TEST_K,metric) print("iter:",run_num,"prec@K:",preck_test,"recall@K:",recallk_test) torch.save(net.state_dict(), cfg.MODEL_PATH+str(cfg.MARGIN)+str(cfg.EMBEDDING_WIDTH)+str(cfg.DATASET)+str(cfg.METRIC_LOSS_PARAM)+'x'+str(cfg.METHOD)+str(cfg.CE_LOSS_PARAM)+'x'+str(cfg.SOFTMAX_METHOD)+str(cfg.K)+str(cfg.POS_SAMPLE_NUM)+".pkl") ''' ratio=total_sprarsity/total_err_pos output = open('m'+str(cfg.MARGIN)+'k'+str(cfg.K)+'n+'+str(cfg.POS_SAMPLE_NUM)+'tau'+str(cfg.TAU)+str(cfg.DATASET)+'.txt', 'a') output.write(str(preck_test[0])) output.write(' ') output.write(str(preck_test[1])) output.write(' ') output.write(str(preck_test[2])) output.write(' ') output.write(str(preck_test[3])) output.write(' ') output.write(str(recallk_test[0])) output.write(' ') output.write(str(recallk_test[1])) output.write(' ') output.write(str(recallk_test[2])) output.write(' ') output.write(str(recallk_test[3])) output.write(str(preck_train[0])) output.write(' ') output.write(str(preck_train[1])) output.write(' ') output.write(str(preck_train[2])) output.write(' ') output.write(str(preck_train[3])) output.write(' ') output.write(str(total_sprarsity)) output.write(' ') output.write(str(ratio)) output.write('\r') output.close() total_sprarsity=0 total_err_pos=0 ''' run_num+=1 print("\r\nEpoch:",epoch,"tau:",cfg.TAU,"avgEpochLoss:",totalEpochLoss/iter_num)