def vis_embed(src_model, tgt_model, src_loader, tgt_loader_eval): X, _ = losses.extract_embeddings(src_model, src_loader) Y, _ = losses.extract_embeddings(tgt_model, tgt_loader_eval) Y_labels = np.ones(Y.shape[0]) * 2 X_labels = np.ones(X.shape[0]) * 1 scatter(np.vstack([Y, X]), np.hstack([Y_labels, X_labels]))
def scatter_target(src_model, tgt_model, src_loader, tgt_loader_eval, fname="p3"): X,_ = losses.extract_embeddings(src_model, src_loader) Y,_ = losses.extract_embeddings(tgt_model, tgt_loader_eval) import pylab as plt plt.figure(figsize=(10,10)) plt.scatter(X[:,0], X[:,1], s=8.0, color="C0") plt.scatter(Y[:,0], Y[:,1], s=8.0, color="C1") plt.grid(True) plt.rc('grid', linestyle="--", color='grey') plt.savefig("/mnt/home/issam/Summaries/{}.pdf".format(fname)) plt.close()
def validate(src_model, tgt_model, src_data_loader, tgt_data_loader): """Evaluation for target encoder by source classifier on target dataset.""" # set eval state for Dropout and BN layers with torch.no_grad(): X, y = losses.extract_embeddings(src_model, src_data_loader) Xtest, ytest = losses.extract_embeddings(tgt_model, tgt_data_loader) clf = neighbors.KNeighborsClassifier(n_neighbors=2) clf.fit(X, y) y_pred = clf.predict(Xtest) acc = (y_pred == ytest).mean() # print(acc) return acc
def scatter_source(src_model, tgt_model, src_loader, tgt_loader_eval, fname="p1"): X, _ = losses.extract_embeddings(src_model, src_loader) import pylab as plt plt.figure(figsize=(10, 10)) plt.scatter(X[:, 0], X[:, 1], s=8.0, color="C0") plt.grid(True) plt.rc('grid', linestyle="--", color='grey') plt.savefig("{}.pdf".format(fname)) plt.close()
def fit_center(src_model, tgt_model, src_loader, tgt_loader, opt_tgt, epochs=30): """Train classifier for source domain.""" #################### # 1. setup network # #################### n_classes = tgt_model.n_classes # set train state for Dropout and BN layers src_model.train() tgt_model.train() src_embeddings, _ = losses.extract_embeddings(src_model, src_loader) src_kmeans = KMeans(n_clusters=n_classes) src_kmeans.fit(src_embeddings) #src_centers = torch.FloatTensor(src_kmeans.means_).cuda() src_centers = torch.FloatTensor(src_kmeans.cluster_centers_).cuda() #################### # 2. train network # #################### for epoch in range(epochs): for step, (images, labels) in enumerate(tgt_loader): # make images and labels variable images = images.cuda() labels = labels.squeeze_().cuda() # zero gradients for opt opt_tgt.zero_grad() # compute loss for critic loss = losses.center_loss(tgt_model, { "X": images, "y": labels }, src_model, src_centers, None, src_kmeans, None) # optimize source classifier loss.backward() opt_tgt.step()
def visEmbed(exp_dict): src_loader = datasets.get_loader(exp_dict["src_dataset"], "train", batch_size=exp_dict["src_batch_size"]) tgt_val_loader = datasets.get_loader(exp_dict["tgt_dataset"], "val", batch_size=exp_dict["tgt_batch_size"]) src_model, src_opt = models.get_model(exp_dict["src_model"], exp_dict["n_outputs"]) src_model.load_state_dict(torch.load(exp_dict["path"] + "/model_src.pth")) tgt_model, tgt_opt = models.get_model(exp_dict["tgt_model"], exp_dict["n_outputs"]) tgt_model.load_state_dict(torch.load(exp_dict["path"] + "/model_tgt.pth")) X, X_tgt = losses.extract_embeddings(src_model, src_loader) Y, Y_tgt = losses.extract_embeddings(tgt_model, tgt_val_loader) X, X_tgt = X[:500], X_tgt[:500] Y, Y_tgt = Y[:500], Y_tgt[:500] src_kmeans = KMeans(n_clusters=10) src_kmeans.fit(X) Xc = src_kmeans.cluster_centers_ clf = neighbors.KNeighborsClassifier(n_neighbors=2) clf.fit(X, X_tgt) Xc_tgt = clf.predict(Xc) # acc_tgt = test.validate(src_model, tgt_model, # src_loader, # tgt_val_loader) tsne = manifold.TSNE(n_components=2, init='pca', random_state=0) #tsne.fit(Y[:500]) S_tsne = tsne.fit_transform(np.vstack([Y, X, Xc])) #X_tsne = tsne.transform(X[:500]) Y_tsne = S_tsne[:Y.shape[0]] X_tsne = S_tsne[Y.shape[0]:-10] Xc_tsne = S_tsne[-10:] # plt.mpl.rcParams['grid.color'] = 'k' # plt.mpl.rcParams['grid.linestyle'] = ':' # plt.mpl.rcParams['grid.linewidth'] = 0.5 # Y_labels = Y_labels # X_labels = X_labels # scatter(Y_tsne, Y_tgt+1, win="1", title="target - {}".format(exp_dict["tgt_dataset"])) # scatter(X_tsne, X_tgt+1, win="2",title="source - {}".format(exp_dict["src_dataset"])) colors = [ "b", "g", "r", "c", "m", "y", "gray", "w", "chocolate", "olive", "pink" ] if 1: fig = plt.figure(figsize=(6, 6)) plt.grid(linestyle='dotted') plt.scatter(X_tsne[:, 0], X_tsne[:, 1], alpha=0.6, edgecolors="black") for c in range(10): ind = Xc_tgt == c color = colors[c + 1] plt.scatter(Xc_tsne[ind][:, 0], Xc_tsne[ind][:, 1], s=250, c=color, edgecolors="black", marker="*") # plt.axes().set_aspect('equal', 'datalim') plt.xlabel("t-SNE Feature 2") plt.ylabel("t-SNE Feature 1") title = "Source Dataset ({}) - Center: {} - Adv: {}".format( exp_dict["src_dataset"].upper().replace("BIG", ""), exp_dict["options"]["center"], exp_dict["options"]["disc"]) plt.title(title) fig.tight_layout(rect=[0, 0.03, 1, 0.95]) plt.savefig("src_{}.pdf".format(exp_dict["exp_name"].replace(" ", "")), bbox_inches='tight', transparent=False) plt.savefig("src_{}.png".format(exp_dict["exp_name"]), bbox_inches='tight', transparent=False) # ms.visplot(fig) if 1: fig = plt.figure(figsize=(6, 6)) plt.grid(linestyle='dotted') for c in range(10): ind = Y_tgt == c color = colors[c + 1] plt.scatter(Y_tsne[ind][:, 0], Y_tsne[ind][:, 1], alpha=0.6, c=color, edgecolors="black") for c in range(10): ind = Xc_tgt == c color = colors[c + 1] plt.scatter(Xc_tsne[ind][:, 0], Xc_tsne[ind][:, 1], s=350, c=color, edgecolors="black", marker="*") # plt.axes().set_aspect('equal', 'datalim') plt.xlabel("t-SNE Feature 2") plt.ylabel("t-SNE Feature 1") title = "Target Dataset ({}) - Center: {} - Adv: {}".format( exp_dict["tgt_dataset"].upper().replace("BIG", ""), exp_dict["options"]["center"], exp_dict["options"]["disc"]) plt.title(title) fig.tight_layout(rect=[0, 0.03, 1, 0.95]) plt.savefig("tgt_{}.pdf".format(exp_dict["exp_name"]), bbox_inches='tight', transparent=False) plt.savefig("tgt_{}.png".format(exp_dict["exp_name"]), bbox_inches='tight', transparent=False)
def fit_center(src_model, tgt_model, src_loader, tgt_loader, opt_tgt, epochs=30): """Train classifier for source domain.""" #################### # 1. setup network # #################### #print(type(tgt_model.last.bias.size()[0])) n_classes = tgt_model.last.bias.size()[0] # set train state for Dropout and BN layers src_model.train() tgt_model.train() src_embeddings, _ = losses.extract_embeddings(src_model, src_loader) src_kmeans = KMeans(n_clusters=n_classes) src_kmeans.fit(src_embeddings) #src_centers = torch.FloatTensor(src_kmeans.means_).cuda() src_centers = torch.FloatTensor(src_kmeans.cluster_centers_).cuda() #################### # 2. Doing Domain Adaptation# #################### for epoch in range(epochs): for step, (images, labels) in enumerate(tgt_loader): # make images and labels variable images = images.cuda() labels = labels.squeeze_().cuda() # zero gradients for opt opt_tgt.zero_grad() # compute loss for critic loss = losses.center_loss(tgt_model, { "X": images, "y": labels }, src_model, src_centers, None, src_kmeans, None) # optimize source classifier loss.backward() opt_tgt.step() # Evaluation # video1_test_loader = get_coxs2v_testset(exp_dict['still_dir'], # exp_dict['video1_dir'], # exp_dict['video1_pairs'], # test_folds, # exp_dict["cross_validation_num_fold"], # data_transform, # 50) # # video2_test_loader = get_coxs2v_testset(exp_dict['still_dir'], # exp_dict['video2_dir'], # exp_dict['video2_pairs'], # test_folds, # exp_dict["cross_validation_num_fold"], # data_transform, # 50) # # src_acc = Evaluate(video1_test_loader, # src_model, # device, # 0, # nrof_folds=10)