diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..58e9e6f Binary files /dev/null and b/.DS_Store differ diff --git a/README.md b/README.md index 6677777..9e0c30c 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,8 @@ -# MMD-reg-OT -MMD regularized OT. +# MMD-OT: +#### Algorithms + - [Code for solving the MMD-OT plan using Accelerated PGD](./ot_mmd/mmdot.py) + - [Code for computing a batch of MMD-OT problems parallely](./ot_mmd/b_mmdot.py) + - [Code for solving the MMD-OT barycenter problem using Accelerated PGD](./ot_mmd/barycenter.py) +#### [Examples](./examples) + - [OT plan between Gaussians](./examples/synthetic/OTplan.ipynb) + - [Barycenter between Gaussians](./examples/synthetic/barycenter_with_imq.ipynb) diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..749ec81 --- /dev/null +++ b/__init__.py @@ -0,0 +1,2 @@ +from mmdot import * +from utils import * \ No newline at end of file diff --git a/examples/.DS_Store b/examples/.DS_Store new file mode 100644 index 0000000..3058f38 Binary files /dev/null and b/examples/.DS_Store differ diff --git a/examples/barycenter_ScRNA/data/EB_t0.pickle b/examples/barycenter_ScRNA/data/EB_t0.pickle new file mode 100644 index 0000000..e88f8ea Binary files /dev/null and b/examples/barycenter_ScRNA/data/EB_t0.pickle differ diff --git a/examples/barycenter_ScRNA/data/EB_t1.pickle b/examples/barycenter_ScRNA/data/EB_t1.pickle new file mode 100644 index 0000000..db8d033 Binary files /dev/null and b/examples/barycenter_ScRNA/data/EB_t1.pickle differ diff --git a/examples/barycenter_ScRNA/data/EB_t2.pickle b/examples/barycenter_ScRNA/data/EB_t2.pickle new file mode 100644 index 0000000..e571143 Binary files /dev/null and b/examples/barycenter_ScRNA/data/EB_t2.pickle differ diff --git a/examples/barycenter_ScRNA/data/EB_t3.pickle b/examples/barycenter_ScRNA/data/EB_t3.pickle new file mode 100644 index 0000000..e267c20 Binary files /dev/null and b/examples/barycenter_ScRNA/data/EB_t3.pickle differ diff --git a/examples/barycenter_ScRNA/data/EB_t4.pickle b/examples/barycenter_ScRNA/data/EB_t4.pickle new file mode 100644 index 0000000..32a95b4 Binary files /dev/null and b/examples/barycenter_ScRNA/data/EB_t4.pickle differ diff --git a/examples/barycenter_ScRNA/kluot.py b/examples/barycenter_ScRNA/kluot.py new file mode 100644 index 0000000..b730ed9 --- /dev/null +++ b/examples/barycenter_ScRNA/kluot.py @@ -0,0 +1,89 @@ +from ot_mmd.utils import createLogHandler, get_t, get_dist, get_G +import os +import argparse +import joblib +import torch +from kluot_bary import solve_md + +parser = argparse.ArgumentParser(description="_") +parser.add_argument("--t_pred", required=True, type=int) +parser.add_argument("--best_lda", type=float, default=None) +parser.add_argument("--best_hp", type=float, default=None) +parser.add_argument("--save_as", default="") +args = parser.parse_args() + +device = torch.device("cuda" if torch.cuda.is_available else "cpu") +dtype = torch.float64 +t_predict = args.t_pred +max_itr = 1000 + +logger = createLogHandler(f"{args.save_as}.csv", str(os.getpid())) + +if args.best_lda is None: + valt_predict = list(set([1, 2, 3]).symmetric_difference(set([t_predict]))) + best_score = torch.inf + val = {} + for lda in [10, 1e-1, 1]: + val[lda] = {} + for hp in [1e-1, 1e-2, 1e-3, 1e-4, 1e-5]: + val[lda][hp] = [] + for t in valt_predict: + init_tstep = t-1 + final_tstep = t+1 + + data_tpredict = get_t(joblib.load(f"data/EB_t{t}.pickle"), device=device) + + data_init = get_t(joblib.load(f"data/EB_t{init_tstep}.pickle"), device=device) + data_final = get_t(joblib.load(f"data/EB_t{final_tstep}.pickle"), device=device) + + data_all = torch.vstack([data_init, data_final]) + C = {1: get_dist(x=data_init, y=data_all, p=1), + 2: get_dist(x=data_final, y=data_all, p=1)} + + a = (torch.ones(data_init.shape[0])/data_init.shape[0]).to(dtype).to(device) + b = (torch.ones(data_final.shape[0])/data_final.shape[0]).to(dtype).to(device) + + bary, _ = solve_md({1: a, 2: b}, C, {1: lda, 2: lda}, max_itr, coeff_entr=hp) + + gt = (torch.ones(data_tpredict.shape[0])/data_tpredict.shape[0]).to(dtype).to(device) + data_cat = torch.vstack([data_tpredict, data_all]) + G = get_G(ktype="rbf", x=data_cat, y=data_cat) + vec = torch.cat([gt, -bary]) + val[lda][hp].append(torch.mv(G, vec).dot(vec).item()) + + logger.info(f", {lda}, {hp}, {sum(val[lda][hp])}") + if sum(val[lda][hp]) < best_score: + best_score = sum(val[lda][hp]) + best_config = {"lda": lda, "hp": hp} + + lda = best_config["lda"] + hp = best_config["hp"] +else: + lda = args.best_lda + hp = args.best_hp + +t = t_predict + +init_tstep = t-1 +final_tstep = t+1 + +data_tpredict = get_t(joblib.load(f"data/EB_t{t}.pickle"), device=device) + +data_init = get_t(joblib.load(f"data/EB_t{init_tstep}.pickle"), device=device) +data_final = get_t(joblib.load(f"data/EB_t{final_tstep}.pickle"), device=device) + +data_all = torch.vstack([data_init, data_final]) +C = {1: get_dist(x=data_init, y=data_all, p=1), + 2: get_dist(x=data_final, y=data_all, p=1)} + +a = (torch.ones(data_init.shape[0])/data_init.shape[0]).to(dtype).to(device) +b = (torch.ones(data_final.shape[0])/data_final.shape[0]).to(dtype).to(device) + +bary, _ = solve_md({1: a, 2: b}, C, {1: lda, 2: lda}, max_itr, coeff_entr=hp) + +gt = (torch.ones(data_tpredict.shape[0])/data_tpredict.shape[0]).to(dtype).to(device) +data_cat = torch.vstack([data_tpredict, data_all]) +G = get_G(ktype="rbf", x=data_cat, y=data_cat) +vec = torch.cat([gt, -bary]) +val_chosen = torch.sqrt(torch.mv(G, vec).dot(vec)).item() +logger.info(f"KL-UOT, {t}, {val_chosen}") diff --git a/examples/barycenter_ScRNA/kluot_bary.py b/examples/barycenter_ScRNA/kluot_bary.py new file mode 100644 index 0000000..21d5dcc --- /dev/null +++ b/examples/barycenter_ScRNA/kluot_bary.py @@ -0,0 +1,109 @@ +import torch +from ot_mmd.utils import get_marginals + + +def get_kl(v1, v2, case, eps=1e-10): + v1 = v1 + eps + v2 = v2 + eps + kl = torch.sum(torch.where(v1 != 0, v1*torch.log(v1/v2), 0)) + if case == "unb": + kl = kl-v1.sum() + v2.sum() + return kl + +def get_entropy(alpha, case, eps=1e-10): + alpha = alpha + eps + entropy = torch.sum(torch.where(alpha != 0, alpha * torch.log(alpha), 0)) + if case == "unb": + entropy = entropy - alpha.sum() + return entropy + +def get_obj(alpha, bary, v, C, lda, coeff_entr, rho={1: 0.5, 2: 0.5}, case="bal"): + cost_part = rho[1]*torch.tensordot(alpha[1], C[1]) + rho[2]*torch.tensordot(alpha[2], C[2]) + + alpha1_1, alpha1_T1 = get_marginals(alpha[1]) + alpha2_1, alpha2_T1 = get_marginals(alpha[2]) + + lda1_part = rho[1]*get_kl(alpha1_1, v[1], case) + rho[2]*get_kl(alpha2_1, v[2], case) + lda2_part = rho[1]*get_kl(alpha1_T1, bary, case) + rho[2]*get_kl(alpha2_T1, bary, case) + + obj = cost_part + lda[1]*lda1_part + lda[2]*lda2_part + obj += coeff_entr*(rho[1]*get_entropy(alpha[1], case)+rho[2]*get_entropy(alpha[2], case)) + return obj + +def get_grd(alpha, bary, v, C, lda, coeff_entr, rho={1: 0.5, 2: 0.5}, case="bal"): + eps = 1e-10 + + alpha[1] = alpha[1] + eps + alpha[2] = alpha[2] + eps + bary = bary + eps + + alpha1_1, alpha1_T1 = get_marginals(alpha[1]) + alpha2_1, alpha2_T1 = get_marginals(alpha[2]) + + grd_bary = -lda[2]*(rho[1]*alpha1_T1 + rho[2]*alpha2_T1)/bary + grd_1 = grd_2 = 0 + if rho[1]>0: + term1 = torch.log(alpha1_1)-torch.log(v[1]) + term2 = torch.log(alpha1_T1)-torch.log(bary) + if case == "bal": + term1 += 1 + term2 += 1 + grd_1 = rho[1]*(C[1] + lda[1]*term1[:, None] + lda[2]*term2) + + if rho[2]>0: + term1 = torch.log(alpha2_1)-torch.log(v[2]) + term2 = torch.log(alpha2_T1)-torch.log(bary) + if case == "bal": + term1 += 1 + term2 += 1 + grd_2 = rho[2]*(C[2] + lda[1]*term1[:, None] + lda[2]*term2) + + grd_1 += rho[1]*coeff_entr*(1+torch.log(alpha[1])) if case == "bal" else rho[1]*coeff_entr*torch.log(alpha[1]) + grd_2 += rho[2]*coeff_entr*(1+torch.log(alpha[2])) if case == "bal" else rho[2]*coeff_entr*torch.log(alpha[2]) + + return grd_1, grd_2, grd_bary + + +def solve_md(v, C, lda, max_itr, coeff_entr, rho={1: 0.5, 2: 0.5}, case="bal"): + + def update_vars(var, grd, case): + s = 1/torch.norm(grd, torch.inf) + var = var*torch.exp(-grd*s) + if case == "bal": + var = var/var.sum() + return var + + alpha = {1: torch.ones_like(C[1])/C[1].numel(), + 2: torch.ones_like(C[2])/C[2].numel()} + bary = (torch.ones(C[1].shape[1])/C[1].shape[1]).to(C[1].dtype).to(C[1].device) + obj_itr = [] + bary_best = None + best_itr = None + + for itr in range(max_itr): + obj_itr.append(get_obj(alpha, bary, v, C, lda, coeff_entr, rho)) + if best_itr is None or obj_itr[best_itr] > obj_itr[-1]: + best_itr = itr + bary_best = bary.clone() + grd_1, grd_2, grd_bary = get_grd(alpha, bary, v, C, lda, coeff_entr, rho) + if rho[1] > 0: + try: # error triggered when optimality has been reached + alpha[1] = update_vars(alpha[1], grd_1, case) + except Exception as e: + print(e) + pass + + if rho[2] > 0: + try: # error triggered when optimality has been reached + alpha[2] = update_vars(alpha[2], grd_2, case) + except Exception as e: + print(e) + pass + + try: # error triggered when optimality has been reached + bary = update_vars(bary, grd_bary, case) + except Exception as e: + print(e) + pass + + return bary_best, obj_itr diff --git a/examples/barycenter_ScRNA/mmd.py b/examples/barycenter_ScRNA/mmd.py new file mode 100644 index 0000000..b5d9ee4 --- /dev/null +++ b/examples/barycenter_ScRNA/mmd.py @@ -0,0 +1,41 @@ +from ot_mmd.utils import createLogHandler, get_t, get_G +import os +import argparse +import joblib +import torch + +parser = argparse.ArgumentParser(description="_") +parser.add_argument("--t_pred", required=True, type=int) +parser.add_argument("--save_as", default="") +args = parser.parse_args() + +device = torch.device("cuda" if torch.cuda.is_available else "cpu") +dtype = torch.float64 +t_predict = args.t_pred + +logger = createLogHandler(f"{args.save_as}.csv", str(os.getpid())) + +t = t_predict + +init_tstep = t-1 +final_tstep = t+1 + +data_tpredict = get_t(joblib.load(f"data/EB_t{t}.pickle"), device=device) + +data_init = get_t(joblib.load(f"data/EB_t{init_tstep}.pickle"), device=device) +data_final = get_t(joblib.load(f"data/EB_t{final_tstep}.pickle"), device=device) + +data_all = torch.vstack([data_init, data_final]) + +a = (torch.ones(data_init.shape[0])/data_init.shape[0]).to(dtype).to(device) +b = (torch.ones(data_final.shape[0])/data_final.shape[0]).to(dtype).to(device) + +bary = torch.cat([a, b])/2 + +gt = (torch.ones(data_tpredict.shape[0])/data_tpredict.shape[0]).to(dtype).to(device) +data_cat = torch.vstack([data_tpredict, data_all]) +G = get_G(ktype="rbf", x=data_cat, y=data_cat) +vec = torch.cat([gt, -bary]) +val_chosen = torch.sqrt(torch.mv(G, vec).dot(vec)).item() +logger.info(f"Method, tstep, MMD (lower is better)") +logger.info(f"MMD, {t}, {val_chosen}") diff --git a/examples/barycenter_ScRNA/proposed.py b/examples/barycenter_ScRNA/proposed.py new file mode 100644 index 0000000..bfc8b21 --- /dev/null +++ b/examples/barycenter_ScRNA/proposed.py @@ -0,0 +1,98 @@ +from ot_mmd.barycenter import solve_apgd +from ot_mmd.utils import createLogHandler, get_t, get_dist, get_G +import os +import argparse +import joblib +import torch + +parser = argparse.ArgumentParser(description="_") +parser.add_argument("--t_pred", required=True, type=int) +parser.add_argument("--best_lda", type=float, default=None) +parser.add_argument("--best_hp", type=float, default=None) +parser.add_argument("--save_as", default="") +args = parser.parse_args() + +device = torch.device("cuda" if torch.cuda.is_available else "cpu") +dtype = torch.float64 +max_itr = 1000 +ktype = "imq_v2" +t_predict = args.t_pred + +logger = createLogHandler(f"{args.save_as}.csv", str(os.getpid())) + +if args.best_lda is None: + valt_predict = list(set([1, 2, 3]).symmetric_difference(set([t_predict]))) + best_score = torch.inf + val = {} + for lda in [10, 1e-1, 1]: + val[lda] = {} + for khp in [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, None]: + val[lda][khp] = [] + for t in valt_predict: + init_tstep = t-1 + final_tstep = t+1 + + data_tpredict = get_t(joblib.load(f"data/EB_t{t}.pickle"), device=device) + + data_init = get_t(joblib.load(f"data/EB_t{init_tstep}.pickle"), device=device) + data_final = get_t(joblib.load(f"data/EB_t{final_tstep}.pickle"), device=device) + + data_all = torch.vstack([data_init, data_final]) + C = {1: get_dist(x=data_init, y=data_all, p=1), + 2: get_dist(x=data_final, y=data_all, p=1)} + + G_all = get_G(ktype=ktype, khp=khp, x=data_all, y=data_all) + m1 = data_init.shape[0] + G = {1: G_all[:m1, :m1], 2: G_all[m1:, m1:], 'all': G_all} + + a = (torch.ones(data_init.shape[0])/data_init.shape[0]).to(dtype).to(device) + b = (torch.ones(data_final.shape[0])/data_final.shape[0]).to(dtype).to(device) + + bary, _ = solve_apgd(C, G, {1: a, 2: b}, max_itr, {1: lda, 2: lda}, case="bal") + + gt = (torch.ones(data_tpredict.shape[0])/data_tpredict.shape[0]).to(dtype).to(device) + data_cat = torch.vstack([data_tpredict, data_all]) + G = get_G(ktype="rbf", x=data_cat, y=data_cat) + vec = torch.cat([gt, -bary]) + val[lda][khp].append(torch.mv(G, vec).dot(vec).item()) + + logger.info(f", {lda}, {khp}, {sum(val[lda][khp])}") + if sum(val[lda][khp]) < best_score: + best_score = sum(val[lda][khp]) + best_config = {"lda": lda, "khp": khp} + + lda = best_config["lda"] + khp = best_config["khp"] +else: + lda = args.best_lda + khp = args.best_hp + +t = t_predict + +init_tstep = t-1 +final_tstep = t+1 + +data_tpredict = get_t(joblib.load(f"data/EB_t{t}.pickle"), device=device) + +data_init = get_t(joblib.load(f"data/EB_t{init_tstep}.pickle"), device=device) +data_final = get_t(joblib.load(f"data/EB_t{final_tstep}.pickle"), device=device) + +data_all = torch.vstack([data_init, data_final]) +C = {1: get_dist(x=data_init, y=data_all, p=1), + 2: get_dist(x=data_final, y=data_all, p=1)} + +G_all = get_G(ktype=ktype, khp=khp, x=data_all, y=data_all) +m1 = data_init.shape[0] +G = {1: G_all[:m1, :m1], 2: G_all[m1:, m1:], 'all': G_all} + +a = (torch.ones(data_init.shape[0])/data_init.shape[0]).to(dtype).to(device) +b = (torch.ones(data_final.shape[0])/data_final.shape[0]).to(dtype).to(device) + +bary, _ = solve_apgd(C, G, {1: a, 2: b}, max_itr, {1: lda, 2: lda}, case="bal") + +gt = (torch.ones(data_tpredict.shape[0])/data_tpredict.shape[0]).to(dtype).to(device) +data_cat = torch.vstack([data_tpredict, data_all]) +G = get_G(ktype="rbf", x=data_cat, y=data_cat) +vec = torch.cat([gt, -bary]) +val_chosen = torch.sqrt(torch.mv(G, vec).dot(vec)).item() +logger.info(f"UOT-MMD, {t}, {val_chosen}") diff --git a/examples/barycenter_ScRNA/results.csv b/examples/barycenter_ScRNA/results.csv new file mode 100644 index 0000000..82caf73 --- /dev/null +++ b/examples/barycenter_ScRNA/results.csv @@ -0,0 +1,12 @@ +2023-06-27 22:20:17; , Method, tstep, MMD (lower is better) +2023-06-27 22:20:17; , MMD, 1, 0.37495047828375055 +2023-06-27 22:20:53; , KL-UOT, 1, 0.3906461023303901 +2023-06-27 22:21:47; , UOT-MMD, 1, 0.33371626328939424 +2023-06-27 22:21:53; , Method, tstep, MMD (lower is better) +2023-06-27 22:21:53; , MMD, 2, 0.19001395396118076 +2023-06-27 22:22:57; , KL-UOT, 2, 0.18436960477258085 +2023-06-27 22:24:35; , UOT-MMD, 2, 0.17922341489550467 +2023-06-27 22:24:42; , Method, tstep, MMD (lower is better) +2023-06-27 22:24:42; , MMD, 3, 0.12121269628920549 +2023-06-27 22:25:30; , KL-UOT, 3, 0.13796316453091137 +2023-06-27 22:26:41; , UOT-MMD, 3, 0.1164323020279007 diff --git a/examples/barycenter_ScRNA/run.sh b/examples/barycenter_ScRNA/run.sh new file mode 100755 index 0000000..9be49cb --- /dev/null +++ b/examples/barycenter_ScRNA/run.sh @@ -0,0 +1,11 @@ +python mmd.py --t_pred 1 --save_as results +python kluot.py --t_pred 1 --best_lda 10 --best_hp 0.01 --save_as results +python proposed.py --t_pred 1 --best_lda 1 --best_hp 0.1 --save_as results + +python mmd.py --t_pred 2 --save_as results +python kluot.py --t_pred 2 --best_lda 1 --best_hp 0.1 --save_as results +python proposed.py --t_pred 2 --best_lda 1 --save_as results + +python mmd.py --t_pred 3 --save_as results +python kluot.py --t_pred 3 --best_lda 1 --best_hp 0.1 --save_as results +python proposed.py --t_pred 3 --best_lda 1 --save_as results diff --git a/examples/jumbot/.DS_Store b/examples/jumbot/.DS_Store new file mode 100644 index 0000000..6b0b2bd Binary files /dev/null and b/examples/jumbot/.DS_Store differ diff --git a/examples/jumbot/digits/.DS_Store b/examples/jumbot/digits/.DS_Store new file mode 100644 index 0000000..8f6e57e Binary files /dev/null and b/examples/jumbot/digits/.DS_Store differ diff --git a/examples/jumbot/digits/kluot/.DS_Store b/examples/jumbot/digits/kluot/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/examples/jumbot/digits/kluot/.DS_Store differ diff --git a/examples/jumbot/digits/kluot/jumbot.py b/examples/jumbot/digits/kluot/jumbot.py new file mode 100644 index 0000000..83f12d9 --- /dev/null +++ b/examples/jumbot/digits/kluot/jumbot.py @@ -0,0 +1,184 @@ +""" +Dependances : +- python (3.8.0) +- numpy (1.19.2) +- torch (1.7.1) +- POT (0.7.0) +- Cuda + +command: +python3 train.py +""" + + +import numpy as np +import torch +import torch.nn as nn +import torch.utils.data +import itertools +import torch.nn.functional as F + +import ot +import os + +from jumbot_utils import model_eval + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +class Jumbot(object): + """Jumbot class""" + def __init__(self, save_as, model_g, model_f, n_class, eta1=0.001, eta2=0.0001, tau=1., epsilon=0.1): + """ + Initialize jumbot method. + args : + - model_g : feature exctrator (torch.nn) + - model_f : classification layer (torch.nn) + - n_class : number of classes (int) + - eta_1 : feature comparison coefficient (float) + - eta_2 : label comparison coefficient (float) + - tau : marginal coeffidient (float) + - epsilon : entropic regularization (float) + """ + self.save_as = save_as + self.model_g = model_g # target model + self.model_f = model_f + self.n_class = n_class + self.eta1 = eta1 # weight for the alpha term + self.eta2 = eta2 # weight for target classification + self.tau = tau + self.epsilon = epsilon + print('eta1, eta2, tau, epsilon: ', self.eta1, self.eta2, self.tau, self.epsilon) + + def fit(self, source_loader, target_loader, test_loader, n_epochs, criterion=nn.CrossEntropyLoss()): + """ + Run jumbot method. + args : + - source_loader : source dataset + - target_loader : target dataset + - test_loader : test dataset + - n_epochs : number of epochs (int) + - criterion : source loss (nn) + + return: + - trained model + """ + target_loader_cycle = itertools.cycle(target_loader) + optimizer_g = torch.optim.Adam(self.model_g.parameters(), lr=2e-4) + optimizer_f = torch.optim.Adam(self.model_f.parameters(), lr=2e-4) + + for id_epoch in range(n_epochs): + self.model_g.train() + self.model_f.train() + for i, data in enumerate(source_loader): + ### Load data + xs_mb, ys = data + xs_mb, ys = xs_mb.cuda(), ys.cuda() + xt_mb, _ = next(target_loader_cycle) + xt_mb = xt_mb.cuda() + + g_xs_mb = self.model_g(xs_mb.cuda()) + f_g_xs_mb = self.model_f(g_xs_mb) + g_xt_mb = self.model_g(xt_mb.cuda()) + f_g_xt_mb = self.model_f(g_xt_mb) + pred_xt = F.softmax(f_g_xt_mb, 1) + + # import pdb; pdb.set_trace() + + ### loss + s_loss = criterion(f_g_xs_mb, ys.cuda()) + + ### Ground cost + embed_cost = torch.cdist(g_xs_mb, g_xt_mb)**2 + + ys = F.one_hot(ys, num_classes=self.n_class).float() + t_cost = - torch.mm(ys, torch.transpose(torch.log(pred_xt), 0, 1)) + + total_cost = self.eta1 * embed_cost + self.eta2 * t_cost + + #OT computation + a, b = ot.unif(g_xs_mb.size()[0]), ot.unif(g_xt_mb.size()[0]) + pi = ot.unbalanced.sinkhorn_knopp_unbalanced(a, b, total_cost.detach().cpu().numpy(), + self.epsilon, self.tau) + # To get DeepJDOT (https://arxiv.org/abs/1803.10081) comment the line above + # and uncomment the following line: + #pi = ot.emd(a, b, total_cost.detach().cpu().numpy()) + pi = torch.from_numpy(pi).float().cuda() + + # train the model + optimizer_g.zero_grad() + optimizer_f.zero_grad() + + da_loss = torch.sum(pi * total_cost) + tot_loss = s_loss + da_loss + tot_loss.backward() + + optimizer_g.step() + optimizer_f.step() + + # print('epoch, loss : ', id_epoch, s_loss.item(), da_loss.item()) + # if id_epoch%10 == 0: + # source_acc = self.evaluate(source_loader) + # target_acc = self.evaluate(test_loader) + # print('source and test accuracies : ', source_acc, target_acc) + + torch.save(self.model_g, os.path.join(self.save_as, "model_g.pt")) + torch.save(self.model_f, os.path.join(self.save_as, "model_f.pt")) + return tot_loss + + def source_only(self, source_loader, criterion=nn.CrossEntropyLoss()): + """ + Run source only. + args : + - source_loader : source dataset + - criterion : source loss (nn) + + return: + - trained model + """ + optimizer_g = torch.optim.Adam(self.model_g.parameters(), lr=2e-4) + optimizer_f = torch.optim.Adam(self.model_f.parameters(), lr=2e-4) + + for id_epoch in range(10): + self.model_g.train() + self.model_f.train() + for i, data in enumerate(source_loader): + ### Load data + xs_mb, ys = data + xs_mb, ys = xs_mb.cuda(), ys.cuda() + + g_xs_mb = self.model_g(xs_mb.cuda()) + f_g_xs_mb = self.model_f(g_xs_mb) + + ### loss + s_loss = criterion(f_g_xs_mb, ys.cuda()) + + # train the model + optimizer_g.zero_grad() + optimizer_f.zero_grad() + + tot_loss = s_loss + tot_loss.backward() + + optimizer_g.step() + optimizer_f.step() + + return tot_loss + + + def evaluate(self, data_loader): + score = model_eval(data_loader, self.model_g, self.model_f) + return score diff --git a/examples/jumbot/digits/kluot/jumbot_utils.py b/examples/jumbot/digits/kluot/jumbot_utils.py new file mode 100644 index 0000000..1899886 --- /dev/null +++ b/examples/jumbot/digits/kluot/jumbot_utils.py @@ -0,0 +1,143 @@ +""" +Dependances : +- python (3.8.0) +- numpy (1.19.2) +- torch (1.7.1) +- POT (0.7.0) +- Cuda + +command: +python3 train.py +""" + + +import torch +import torch.nn.functional as F +import torch.utils.data +import random +import numpy as np + +from torch.utils.data.sampler import BatchSampler + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + +#-------- Eval function -------- + +def model_eval(dataloader, model_g, model_f): + """ + Model evaluation function + args: + - dataloader : considered dataset + - model_g : feature exctrator (torch.nn) + - model_f : classification layer (torch.nn) + """ + model_g.eval() + model_f.eval() + total_samples =0 + correct_prediction = 0 + with torch.no_grad(): + for img, label in dataloader: + img = img.to(device) + label = label.long().to(device) + gen_output = model_g(img) + pred = F.softmax(model_f(gen_output), 1) + correct_prediction += torch.sum(torch.argmax(pred,1)==label) + total_samples += pred.size(0) + accuracy = correct_prediction.cpu().data.numpy()/total_samples + return accuracy + + + +#--------SAMPLER------- + +class BalancedBatchSampler(torch.utils.data.sampler.BatchSampler): + """ + BatchSampler - from a MNIST-like dataset, samples n_samples for each of the n_classes. + Returns batches of size n_classes * (batch_size // n_classes) + Taken from https://github.com/criteo-research/pytorch-ada/blob/master/adalib/ada/datasets/sampler.py + """ + + def __init__(self, labels, batch_size): + classes = sorted(set(labels.numpy())) + print(classes) + + n_classes = len(classes) + self._n_samples = batch_size // n_classes + if self._n_samples == 0: + raise ValueError( + f"batch_size should be bigger than the number of classes, got {batch_size}" + ) + + self._class_iters = [ + InfiniteSliceIterator(np.where(labels == class_)[0], class_=class_) + for class_ in classes + ] + + batch_size = self._n_samples * n_classes + self.n_dataset = len(labels) + self._n_batches = self.n_dataset // batch_size + if self._n_batches == 0: + raise ValueError( + f"Dataset is not big enough to generate batches with size {batch_size}" + ) + print("K=", n_classes, "nk=", self._n_samples) + print("Batch size = ", batch_size) + + def __iter__(self): + for _ in range(self._n_batches): + indices = [] + for class_iter in self._class_iters: + indices.extend(class_iter.get(self._n_samples)) + np.random.shuffle(indices) + yield indices + + for class_iter in self._class_iters: + class_iter.reset() + + def __len__(self): + return self._n_batches + + +class InfiniteSliceIterator: + def __init__(self, array, class_): + assert type(array) is np.ndarray + self.array = array + self.i = 0 + self.class_ = class_ + + def reset(self): + self.i = 0 + + def get(self, n): + len_ = len(self.array) + # not enough element in 'array' + if len_ < n: + print(f"there are really few items in class {self.class_}") + self.reset() + np.random.shuffle(self.array) + mul = n // len_ + rest = n - mul * len_ + return np.concatenate((np.tile(self.array, mul), self.array[:rest])) + + # not enough element in array's tail + if len_ - self.i < n: + self.reset() + + if self.i == 0: + np.random.shuffle(self.array) + i = self.i + self.i += n + return self.array[i : self.i] diff --git a/examples/jumbot/digits/kluot/mmnist.py b/examples/jumbot/digits/kluot/mmnist.py new file mode 100644 index 0000000..079e951 --- /dev/null +++ b/examples/jumbot/digits/kluot/mmnist.py @@ -0,0 +1,136 @@ +from __future__ import print_function + +import errno +import os + +import torch +import torch.utils.data as data +from PIL import Image + + +class MNISTM(data.Dataset): + """`MNIST-M Dataset.""" + + url = "https://github.com/VanushVaswani/keras_mnistm/releases/download/1.0/keras_mnistm.pkl.gz" + + raw_folder = "raw" + processed_folder = "processed" + training_file = "mnist_m_train.pt" + test_file = "mnist_m_test.pt" + + def __init__(self, root, mnist_root="data", train=True, transform=None, target_transform=None, download=False): + """Init MNIST-M dataset.""" + super(MNISTM, self).__init__() + self.root = os.path.expanduser(root) + self.mnist_root = os.path.expanduser(mnist_root) + self.transform = transform + self.target_transform = target_transform + self.train = train # training set or test set + + if download: + self.download() + + if not self._check_exists(): + raise RuntimeError("Dataset not found." + " You can use download=True to download it") + + if self.train: + self.train_data, self.train_labels = torch.load( + os.path.join(self.root, self.processed_folder, self.training_file) + ) + else: + self.test_data, self.test_labels = torch.load( + os.path.join(self.root, self.processed_folder, self.test_file) + ) + + def __getitem__(self, index): + """Get images and target for data loader. + Args: + index (int): Index + Returns: + tuple: (image, target) where target is index of the target class. + """ + if self.train: + img, target = self.train_data[index], self.train_labels[index] + else: + img, target = self.test_data[index], self.test_labels[index] + + # doing this so that it is consistent with all other datasets + # to return a PIL Image + img = Image.fromarray(img.squeeze().numpy(), mode="RGB") + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = self.target_transform(target) + + return img, target + + def __len__(self): + """Return size of dataset.""" + if self.train: + return len(self.train_data) + else: + return len(self.test_data) + + def _check_exists(self): + return os.path.exists(os.path.join(self.root, self.processed_folder, self.training_file)) and os.path.exists( + os.path.join(self.root, self.processed_folder, self.test_file) + ) + + def download(self): + """Download the MNIST data.""" + # import essential packages + from six.moves import urllib + import gzip + import pickle + from torchvision import datasets + + # check if dataset already exists + if self._check_exists(): + return + + # make data dirs + try: + os.makedirs(os.path.join(self.root, self.raw_folder)) + os.makedirs(os.path.join(self.root, self.processed_folder)) + except OSError as e: + if e.errno == errno.EEXIST: + pass + else: + raise + + # download pkl files + print("Downloading " + self.url) + filename = self.url.rpartition("/")[2] + file_path = os.path.join(self.root, self.raw_folder, filename) + if not os.path.exists(file_path.replace(".gz", "")): + data = urllib.request.urlopen(self.url) + with open(file_path, "wb") as f: + f.write(data.read()) + with open(file_path.replace(".gz", ""), "wb") as out_f, gzip.GzipFile(file_path) as zip_f: + out_f.write(zip_f.read()) + os.unlink(file_path) + + # process and save as torch files + print("Processing...") + + # load MNIST-M imag + with open(file_path.replace(".gz", ""), "rb") as f: + mnist_m_data = pickle.load(f, encoding="bytes") + mnist_m_train_data = torch.ByteTensor(mnist_m_data[b"train"]) + mnist_m_test_data = torch.ByteTensor(mnist_m_data[b"test"]) + + # get MNIST labels + mnist_train_labels = datasets.MNIST(root=self.mnist_root, train=True, download=True).train_labels + mnist_test_labels = datasets.MNIST(root=self.mnist_root, train=False, download=True).test_labels + + # save MNIST-M dataset + training_set = (mnist_m_train_data, mnist_train_labels) + test_set = (mnist_m_test_data, mnist_test_labels) + with open(os.path.join(self.root, self.processed_folder, self.training_file), "wb") as f: + torch.save(training_set, f) + with open(os.path.join(self.root, self.processed_folder, self.test_file), "wb") as f: + torch.save(test_set, f) + + print("Done!") \ No newline at end of file diff --git a/examples/jumbot/digits/kluot/models.py b/examples/jumbot/digits/kluot/models.py new file mode 100644 index 0000000..88ec9bc --- /dev/null +++ b/examples/jumbot/digits/kluot/models.py @@ -0,0 +1,106 @@ +# -*- coding: utf-8 -*- +""" +Dependances : +- python (3.8.0) +- numpy (1.19.2) +- torch (1.7.1) +- POT (0.7.0) +- Cuda + +command: +python3 train.py +""" + + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np + + +class Classifier2(nn.Module): + ''' Classifier class''' + def __init__(self, nclass=None): + super(Classifier2, self).__init__() + assert nclass!=None + self.fc2 = nn.Linear(128, 10) + + def forward(self, x): + x = self.fc2(x) + return x + + +def weights_init(m): + ''' Weight init function for layers ''' + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + m.weight.data.normal_(0.0, 0.02) + elif classname.find('BatchNorm') != -1: + m.weight.data.normal_(1.0, 0.02) + m.bias.data.fill_(0) + elif classname.find('Linear') != -1: + m.weight.data.normal_(0.0, 0.1) + m.bias.data.fill_(0) + + +def call_bn(bn, x): + ''' call batch norm layer ''' + return bn(x) + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + + +class Cnn_generator(nn.Module): + '''9 layer CNN feature extractor class''' + def __init__(self, input_channel=3, n_outputs=10, dropout_rate=0.25, momentum=0.1): + self.momentum = momentum + super(Cnn_generator, self).__init__() + self.c1=nn.Conv2d(input_channel, 32,kernel_size=3, stride=1, padding=1) + self.c2=nn.Conv2d(32,32,kernel_size=3, stride=1, padding=1) + self.c3=nn.Conv2d(32,64,kernel_size=3, stride=1, padding=1) + self.c4=nn.Conv2d(64,64,kernel_size=3, stride=1, padding=1) + self.c5=nn.Conv2d(64,128,kernel_size=3, stride=1, padding=1) + self.c6=nn.Conv2d(128,128,kernel_size=3, stride=1, padding=1) + self.linear1=nn.Linear(128*4*4, 128) + self.bn1=nn.BatchNorm2d(32) + self.bn2=nn.BatchNorm2d(32) + self.bn3=nn.BatchNorm2d(64) + self.bn4=nn.BatchNorm2d(64) + self.bn5=nn.BatchNorm2d(128) + self.bn6=nn.BatchNorm2d(128) + self.dropout = nn.Dropout2d(dropout_rate) + + def forward(self, x): + h=x + h=self.c1(h) + h=F.relu(call_bn(self.bn1, h)) + h=self.c2(h) + h=F.relu(call_bn(self.bn2, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h=self.c3(h) + h=F.relu(call_bn(self.bn3, h)) + h=self.c4(h) + h=F.relu(call_bn(self.bn4, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h=self.c5(h) + h=F.relu(call_bn(self.bn5, h)) + h=self.c6(h) + h=F.relu(call_bn(self.bn6, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h = h.view(h.size(0), -1) + logit=torch.sigmoid(self.linear1(h)) + return logit \ No newline at end of file diff --git a/examples/jumbot/digits/kluot/run_kl.sh b/examples/jumbot/digits/kluot/run_kl.sh new file mode 100755 index 0000000..45afe2e --- /dev/null +++ b/examples/jumbot/digits/kluot/run_kl.sh @@ -0,0 +1,15 @@ +python train.py --source_dset mnist --target_dset usps > "m2u.txt" + +python train.py --source_dset svhn --target_dset usps > "s2u.txt" + +python train.py --source_dset usps --target_dset mnist > "u2m.txt" + +python train.py --source_dset mmnist --target_dset usps > "mm2u.txt" + +python train.py --source_dset mmnist --target_dset mnist > "mm2m.txt" + +python train.py --source_dset svhn --target_dset mmnist > "s2mm.txt" + +python train.py --source_dset mnist --target_dset mmnist > "m2mm.txt" + +python train.py --source_dset svhn --target_dset mnist > "s2m.txt" diff --git a/examples/jumbot/digits/kluot/train.py b/examples/jumbot/digits/kluot/train.py new file mode 100644 index 0000000..192aff3 --- /dev/null +++ b/examples/jumbot/digits/kluot/train.py @@ -0,0 +1,152 @@ +import numpy as np +import torch +import torch.nn as nn +from torchvision import datasets, transforms +from torch.utils.data import DataLoader +torch.multiprocessing.set_sharing_strategy('file_system') + +import torch.nn.functional as F +from models import Classifier2, weights_init, Cnn_generator + +from jumbot_utils import * +from jumbot import Jumbot +import logging, os, yaml +#_____________________________ +import argparse +parser = argparse.ArgumentParser() + +parser.add_argument("--source_dset", required=True, type = str, help = "source dset") +parser.add_argument("--target_dset", required=True, type = str, help = "target dset") +parser.add_argument("--log", type=str, default="KLUOT") +args = parser.parse_args() + +source_dset = args.source_dset +target_dset = args.target_dset + +task = "{}2{}".format(source_dset, target_dset) +#_____________________________ + + +logger_fname = f'[{args.log}]_{task}' + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + + +batch_size = 500 +nclass = 10 + +set_seed(1980) + +# pre-processing to tensor, and mean subtraction + +def get_transform(dset): + if dset == "usps": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mnist": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mmnist": + transform = transforms.Compose( + [ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ] + ) + elif dset == "svhn": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + return transform + +def get_dset(train, dset, transform): + if dset == "usps": + tset = datasets.USPS('../data', train = train, download=True, + transform= transform) + elif dset == "mnist": + tset = datasets.MNIST('../data', train=train, download=True, + transform=transform) + elif dset == "mmnist": + import mmnist + tset = mmnist.MNISTM("../mnistm", train=train, download=True, + transform=transform) + elif dset == "svhn": + if train: + tset = datasets.SVHN('../data', split='train', download=True, + transform=transform) + else: + tset = datasets.SVHN('../data', split='test', download=True, + transform=transform) + return tset + +transform_source = get_transform(source_dset) + +train_source_trainset = get_dset(True, source_dset, transform_source) + +# print('nb source data : ', len(train_source_trainset)) + +source_data = torch.zeros((len(train_source_trainset), 3, 32, 32)) +source_labels = torch.zeros((len(train_source_trainset))) + +for i, data in enumerate(train_source_trainset): + source_data[i] = data[0] + source_labels[i] = data[1] + +train_batch_sampler = BalancedBatchSampler(source_labels, batch_size=batch_size) +train_source_loader = torch.utils.data.DataLoader(train_source_trainset, batch_sampler=train_batch_sampler) + +transform_target = get_transform(target_dset) + +train_target_trainset = get_dset(True, target_dset, transform_target) + +train_target_loader = torch.utils.data.DataLoader(train_target_trainset, batch_size=batch_size, shuffle=True) + +### TEST sets +test_source_loader = torch.utils.data.DataLoader(get_dset(False, source_dset, transform_source), batch_size=batch_size, shuffle=False) + +test_target_loader = torch.utils.data.DataLoader(get_dset(False, target_dset, transform_target), batch_size=batch_size, shuffle=False) + + +####### Main + +model_g = Cnn_generator().cuda().apply(weights_init) +model_f = Classifier2(nclass=nclass).cuda().apply(weights_init) + +eta1 = 0.1 +eta2 = 0.1 +tau = 1.0 +epsilon = 0.1 + +model_g.train() +model_f.train() + +save_as = f"models_{task}" +os.makedirs(save_as, exist_ok=1) + +jumbot = Jumbot(save_as, model_g, model_f, n_class=nclass, eta1=eta1, eta2=eta2, tau=tau, epsilon=epsilon) +loss = jumbot.source_only(train_source_loader) +loss = jumbot.fit(train_source_loader, train_target_loader, test_target_loader, n_epochs=100) + +source_acc = jumbot.evaluate(test_source_loader) +target_acc = jumbot.evaluate(test_target_loader) +print ("Method = {}, Task = {}, target_acc = {}".format(args.log, task, target_acc)) diff --git a/examples/jumbot/digits/kluot/tsne.py b/examples/jumbot/digits/kluot/tsne.py new file mode 100644 index 0000000..91171b3 --- /dev/null +++ b/examples/jumbot/digits/kluot/tsne.py @@ -0,0 +1,180 @@ +import numpy as np +import torch +import torch.nn as nn +from torchvision import datasets, transforms +from torch.utils.data import DataLoader +torch.multiprocessing.set_sharing_strategy('file_system') + +import matplotlib.pyplot as plt +import matplotlib.cm as cm +from sklearn.manifold import TSNE + +import torch.nn.functional as F +from models import Classifier2, weights_init, Cnn_generator + +from jumbot_utils import * +import argparse +parser = argparse.ArgumentParser() +parser.add_argument("--source_dset", required=True, type = str, help = "source dset") +parser.add_argument("--target_dset", required=True, type = str, help = "target dset") +args = parser.parse_args() +source_dset = args.source_dset +target_dset = args.target_dset +log = "KLUOT" + +task = "{}2{}".format(source_dset, target_dset) +#_____________________________ + + +logger_fname = f'[{log}]_{task}' + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +batch_size = 500 +nclass = 10 + +set_seed(1980) + +def feature_extraction(model, dataloader): + embed_list = [] + label_list = [] + + with torch.no_grad(): + for img, label in dataloader: + img = img.to(device) + embed = model(img) + label_list.append(label) + embed_list.append(embed) + + return torch.cat(embed_list).cpu().numpy(), torch.cat(label_list).cpu().numpy() + +# pre-processing to tensor, and mean subtraction + +def get_transform(dset): + if dset == "usps": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mnist": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mmnist": + transform = transforms.Compose( + [ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ] + ) + elif dset == "svhn": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + return transform + +def get_dset(train, dset, transform): + if dset == "usps": + tset = datasets.USPS('../data', train = train, download=True, + transform= transform) + elif dset == "mnist": + tset = datasets.MNIST('../data', train=train, download=True, + transform=transform) + elif dset == "mmnist": + import mmnist + tset = mmnist.MNISTM("../mnistm", train=train, download=True, + transform=transform) + elif dset == "svhn": + if train: + tset = datasets.SVHN('../data', split='train', download=True, + transform=transform) + else: + tset = datasets.SVHN('../data', split='test', download=True, + transform=transform) + return tset + +transform_source = get_transform(source_dset) + +transform_target = get_transform(target_dset) + +### TEST sets +test_source_loader = torch.utils.data.DataLoader(get_dset(False, source_dset, transform_source), batch_size=batch_size, shuffle=False) + +test_target_loader = torch.utils.data.DataLoader(get_dset(False, target_dset, transform_target), batch_size=batch_size, shuffle=False) + + +####### Main + +model_g = Cnn_generator().cuda().apply(weights_init) +model_f = Classifier2(nclass=nclass).cuda().apply(weights_init) + +eta1 = 0.1 +eta2 = 0.1 +tau = 1.0 +epsilon = 0.1 + +fig = plt.figure(figsize=(20, 5)) +TICK_SIZE = 14 +TITLE_SIZE = 20 +MARKER_SIZE = 50 +NUM_SAMPLES = 2000 + +ax = fig.add_subplot() +title = "KL-UOT" + +# model_g.load_state_dict(torch.load(f"models_{source_dset}2{target_dset}/model_g.pt")) +model_g = torch.load(f"models_{source_dset}2{target_dset}/model_g.pt") + +source_embed, source_label = feature_extraction(model_g, test_source_loader) +target_embed, target_label = feature_extraction(model_g, test_target_loader) + +combined_imgs = np.vstack([source_embed[0:NUM_SAMPLES, :], target_embed[0:NUM_SAMPLES, :]]) +combined_labels = np.concatenate([source_label[0:NUM_SAMPLES], target_label[0:NUM_SAMPLES]]) +combined_labels = combined_labels.astype("int") +tsne = TSNE(perplexity=30, n_components=2, init="pca", n_iter=3000) +source_only_tsne = tsne.fit_transform(combined_imgs) +ax.scatter( + source_only_tsne[:NUM_SAMPLES, 0], + source_only_tsne[:NUM_SAMPLES, 1], + c=combined_labels[:NUM_SAMPLES], + s=MARKER_SIZE, + alpha=0.5, + marker="o", + cmap=cm.jet, + label="source", +) +ax.scatter( + source_only_tsne[NUM_SAMPLES:, 0], + source_only_tsne[NUM_SAMPLES:, 1], + c=combined_labels[NUM_SAMPLES:], + s=MARKER_SIZE, + alpha=0.5, + marker="+", + cmap=cm.jet, + label="target", +) +ax.set_xlim(-125, 125) +ax.set_ylim(-125, 125) +ax.tick_params(axis="both", which="major", labelsize=TICK_SIZE) +ax.set_title(title, fontsize=TITLE_SIZE) +ax.legend(loc="upper right") + +plt.savefig(f"{source_dset}2{target_dset}.jpg") +plt.close() diff --git a/examples/jumbot/digits/proposed/.DS_Store b/examples/jumbot/digits/proposed/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/examples/jumbot/digits/proposed/.DS_Store differ diff --git a/examples/jumbot/digits/proposed/jumbot.py b/examples/jumbot/digits/proposed/jumbot.py new file mode 100644 index 0000000..94392d2 --- /dev/null +++ b/examples/jumbot/digits/proposed/jumbot.py @@ -0,0 +1,186 @@ +import numpy as np +import torch +import torch.nn as nn +import torch.utils.data +import itertools +import torch.nn.functional as F +import pdb +from ot_mmd.mmdot import solve_apgd +from ot_mmd.utils import get_G, get_t +import ot +import os +# import wandb +from jumbot_utils import model_eval + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + +class Jumbot(object): + """Jumbot class""" + def __init__(self, model_g, model_f, n_class, reg_type, lda, max_itr, khp, verbose, ktype, eta1, eta2, case, ridge, wd, crit, save_as=""): + """ + Initialize jumbot method. + args : + - model_g : feature exctrator (torch.nn) + - model_f : classification layer (torch.nn) + - n_class : number of classes (int) + - eta_1 : feature comparison coefficient (float) + - eta_2 : label comparison coefficient (float) + - lda : marginal coeffidient (float) + - epsilon : entropic regularization (float) + """ + self.save_as = save_as + self.model_g = model_g # target model + self.model_f = model_f + self.n_class = n_class + self.eta1 = eta1 # weight for the alpha term + self.eta2 = eta2 # weight for target classification + self.lda = lda + self.khp = khp + self.ktype = ktype + self.reg_type = reg_type + self.verbose = verbose + self.max_itr = max_itr + self.case = case + self.ridge = ridge + self.crit = crit + self.wd = wd + + def fit(self, source_loader, target_loader, test_loader, n_epochs, criterion=nn.CrossEntropyLoss()): + """ + Run jumbot method. + args : + - source_loader : source dataset + - target_loader : target dataset + - test_loader : test dataset + - n_epochs : number of epochs (int) + - criterion : source loss (nn) + + return: + - trained model + """ + target_loader_cycle = itertools.cycle(target_loader) + optimizer_g = torch.optim.Adam(self.model_g.parameters(), lr=2e-4) + optimizer_f = torch.optim.Adam(self.model_f.parameters(), lr=2e-4) + + for id_epoch in range(n_epochs): + + self.model_g.train() + self.model_f.train() + + for i, data in enumerate(source_loader): + # print('___batchid_{}'.format(i)) + ### Load data + + xs_mb, ys = data + xs_mb, ys = xs_mb.to(device), ys.to(device) + xt_mb, _ = next(target_loader_cycle) + xt_mb = xt_mb.to(device) + + g_xs_mb = self.model_g(xs_mb) + f_g_xs_mb = self.model_f(g_xs_mb) + g_xt_mb = self.model_g(xt_mb) + f_g_xt_mb = self.model_f(g_xt_mb) + pred_xt = F.softmax(f_g_xt_mb, 1) + + ### loss + s_loss = criterion(f_g_xs_mb, ys) + + ### Ground cost + embed_cost = torch.cdist(g_xs_mb, g_xt_mb)**2 + + ys = F.one_hot(ys, num_classes=self.n_class).float() + t_cost = - torch.mm(ys, torch.transpose(torch.log(pred_xt), 0, 1)) + + total_cost = self.eta1 * embed_cost + self.eta2 * t_cost + + + detached_gxs = g_xs_mb.detach().to(total_cost.dtype) + detached_gxt = g_xt_mb.detach().to(total_cost.dtype) + cost = total_cost.detach() + + G1 = get_G(x=detached_gxs, y=detached_gxs, ktype=self.ktype, khp=self.khp, ridge=self.ridge) + G2 = get_G(x=detached_gxt, y=detached_gxt, ktype=self.ktype, khp=self.khp, ridge=self.ridge) + + #OT computation + a, b = get_t(ot.unif(g_xs_mb.size()[0]), device=device, dtype=total_cost.dtype), get_t(ot.unif(g_xt_mb.size()[0]), device=device, dtype=total_cost.dtype) + + pi, _ = solve_apgd(cost, {1: G1, 2: G2}, {1: a, 2: b}, self.max_itr, self.lda, case=self.case, crit=self.crit) + + optimizer_g.zero_grad() + optimizer_f.zero_grad() + + da_loss = torch.tensordot(pi, total_cost) + tot_loss = s_loss + da_loss + tot_loss.backward() + + optimizer_g.step() + optimizer_f.step() + + # print('epoch, loss : ', id_epoch, s_loss.item(), da_loss.item()) + # if id_epoch%10 == 0: + # source_acc = self.evaluate(source_loader) + # target_acc = self.evaluate(test_loader) + # wandb.Table(columns=["epoch", "tgt_acc", "source_acc", "lambda", "max_itr", "khp", "ktype", "case", "crit", "reg_type"], + # data=[[id_epoch, target_acc, source_acc, self.lda, self.max_itr, self.khp, self.ktype, self.case, self.crit, self.reg_type]]) + # wandb.log({"epoch": id_epoch, "tgt_acc": target_acc, "src_acc": source_acc}) + torch.save(self.model_g, os.path.join(self.save_as, "model_g.pt")) + torch.save(self.model_f, os.path.join(self.save_as, "model_f.pt")) + return tot_loss + + def source_only(self, source_loader, criterion=nn.CrossEntropyLoss()): + """ + Run source only. + args : + - source_loader : source dataset + - criterion : source loss (nn) + + return: + - trained model + """ + optimizer_g = torch.optim.Adam(self.model_g.parameters(), lr=2e-4) + optimizer_f = torch.optim.Adam(self.model_f.parameters(), lr=2e-4) + + for id_epoch in range(10): + self.model_g.train() + self.model_f.train() + for i, data in enumerate(source_loader): + ### Load data + xs_mb, ys = data + xs_mb, ys = xs_mb.to(device), ys.to(device) + + g_xs_mb = self.model_g(xs_mb.to(device)) + f_g_xs_mb = self.model_f(g_xs_mb) + + ### loss + s_loss = criterion(f_g_xs_mb, ys.to(device)) + + # train the model + optimizer_g.zero_grad() + optimizer_f.zero_grad() + + tot_loss = s_loss + tot_loss.backward() + + optimizer_g.step() + optimizer_f.step() + + return tot_loss + + + def evaluate(self, data_loader): + score = model_eval(data_loader, self.model_g, self.model_f) + return score diff --git a/examples/jumbot/digits/proposed/jumbot_utils.py b/examples/jumbot/digits/proposed/jumbot_utils.py new file mode 100644 index 0000000..1899886 --- /dev/null +++ b/examples/jumbot/digits/proposed/jumbot_utils.py @@ -0,0 +1,143 @@ +""" +Dependances : +- python (3.8.0) +- numpy (1.19.2) +- torch (1.7.1) +- POT (0.7.0) +- Cuda + +command: +python3 train.py +""" + + +import torch +import torch.nn.functional as F +import torch.utils.data +import random +import numpy as np + +from torch.utils.data.sampler import BatchSampler + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + +#-------- Eval function -------- + +def model_eval(dataloader, model_g, model_f): + """ + Model evaluation function + args: + - dataloader : considered dataset + - model_g : feature exctrator (torch.nn) + - model_f : classification layer (torch.nn) + """ + model_g.eval() + model_f.eval() + total_samples =0 + correct_prediction = 0 + with torch.no_grad(): + for img, label in dataloader: + img = img.to(device) + label = label.long().to(device) + gen_output = model_g(img) + pred = F.softmax(model_f(gen_output), 1) + correct_prediction += torch.sum(torch.argmax(pred,1)==label) + total_samples += pred.size(0) + accuracy = correct_prediction.cpu().data.numpy()/total_samples + return accuracy + + + +#--------SAMPLER------- + +class BalancedBatchSampler(torch.utils.data.sampler.BatchSampler): + """ + BatchSampler - from a MNIST-like dataset, samples n_samples for each of the n_classes. + Returns batches of size n_classes * (batch_size // n_classes) + Taken from https://github.com/criteo-research/pytorch-ada/blob/master/adalib/ada/datasets/sampler.py + """ + + def __init__(self, labels, batch_size): + classes = sorted(set(labels.numpy())) + print(classes) + + n_classes = len(classes) + self._n_samples = batch_size // n_classes + if self._n_samples == 0: + raise ValueError( + f"batch_size should be bigger than the number of classes, got {batch_size}" + ) + + self._class_iters = [ + InfiniteSliceIterator(np.where(labels == class_)[0], class_=class_) + for class_ in classes + ] + + batch_size = self._n_samples * n_classes + self.n_dataset = len(labels) + self._n_batches = self.n_dataset // batch_size + if self._n_batches == 0: + raise ValueError( + f"Dataset is not big enough to generate batches with size {batch_size}" + ) + print("K=", n_classes, "nk=", self._n_samples) + print("Batch size = ", batch_size) + + def __iter__(self): + for _ in range(self._n_batches): + indices = [] + for class_iter in self._class_iters: + indices.extend(class_iter.get(self._n_samples)) + np.random.shuffle(indices) + yield indices + + for class_iter in self._class_iters: + class_iter.reset() + + def __len__(self): + return self._n_batches + + +class InfiniteSliceIterator: + def __init__(self, array, class_): + assert type(array) is np.ndarray + self.array = array + self.i = 0 + self.class_ = class_ + + def reset(self): + self.i = 0 + + def get(self, n): + len_ = len(self.array) + # not enough element in 'array' + if len_ < n: + print(f"there are really few items in class {self.class_}") + self.reset() + np.random.shuffle(self.array) + mul = n // len_ + rest = n - mul * len_ + return np.concatenate((np.tile(self.array, mul), self.array[:rest])) + + # not enough element in array's tail + if len_ - self.i < n: + self.reset() + + if self.i == 0: + np.random.shuffle(self.array) + i = self.i + self.i += n + return self.array[i : self.i] diff --git a/examples/jumbot/digits/proposed/mmnist.py b/examples/jumbot/digits/proposed/mmnist.py new file mode 100644 index 0000000..079e951 --- /dev/null +++ b/examples/jumbot/digits/proposed/mmnist.py @@ -0,0 +1,136 @@ +from __future__ import print_function + +import errno +import os + +import torch +import torch.utils.data as data +from PIL import Image + + +class MNISTM(data.Dataset): + """`MNIST-M Dataset.""" + + url = "https://github.com/VanushVaswani/keras_mnistm/releases/download/1.0/keras_mnistm.pkl.gz" + + raw_folder = "raw" + processed_folder = "processed" + training_file = "mnist_m_train.pt" + test_file = "mnist_m_test.pt" + + def __init__(self, root, mnist_root="data", train=True, transform=None, target_transform=None, download=False): + """Init MNIST-M dataset.""" + super(MNISTM, self).__init__() + self.root = os.path.expanduser(root) + self.mnist_root = os.path.expanduser(mnist_root) + self.transform = transform + self.target_transform = target_transform + self.train = train # training set or test set + + if download: + self.download() + + if not self._check_exists(): + raise RuntimeError("Dataset not found." + " You can use download=True to download it") + + if self.train: + self.train_data, self.train_labels = torch.load( + os.path.join(self.root, self.processed_folder, self.training_file) + ) + else: + self.test_data, self.test_labels = torch.load( + os.path.join(self.root, self.processed_folder, self.test_file) + ) + + def __getitem__(self, index): + """Get images and target for data loader. + Args: + index (int): Index + Returns: + tuple: (image, target) where target is index of the target class. + """ + if self.train: + img, target = self.train_data[index], self.train_labels[index] + else: + img, target = self.test_data[index], self.test_labels[index] + + # doing this so that it is consistent with all other datasets + # to return a PIL Image + img = Image.fromarray(img.squeeze().numpy(), mode="RGB") + + if self.transform is not None: + img = self.transform(img) + + if self.target_transform is not None: + target = self.target_transform(target) + + return img, target + + def __len__(self): + """Return size of dataset.""" + if self.train: + return len(self.train_data) + else: + return len(self.test_data) + + def _check_exists(self): + return os.path.exists(os.path.join(self.root, self.processed_folder, self.training_file)) and os.path.exists( + os.path.join(self.root, self.processed_folder, self.test_file) + ) + + def download(self): + """Download the MNIST data.""" + # import essential packages + from six.moves import urllib + import gzip + import pickle + from torchvision import datasets + + # check if dataset already exists + if self._check_exists(): + return + + # make data dirs + try: + os.makedirs(os.path.join(self.root, self.raw_folder)) + os.makedirs(os.path.join(self.root, self.processed_folder)) + except OSError as e: + if e.errno == errno.EEXIST: + pass + else: + raise + + # download pkl files + print("Downloading " + self.url) + filename = self.url.rpartition("/")[2] + file_path = os.path.join(self.root, self.raw_folder, filename) + if not os.path.exists(file_path.replace(".gz", "")): + data = urllib.request.urlopen(self.url) + with open(file_path, "wb") as f: + f.write(data.read()) + with open(file_path.replace(".gz", ""), "wb") as out_f, gzip.GzipFile(file_path) as zip_f: + out_f.write(zip_f.read()) + os.unlink(file_path) + + # process and save as torch files + print("Processing...") + + # load MNIST-M imag + with open(file_path.replace(".gz", ""), "rb") as f: + mnist_m_data = pickle.load(f, encoding="bytes") + mnist_m_train_data = torch.ByteTensor(mnist_m_data[b"train"]) + mnist_m_test_data = torch.ByteTensor(mnist_m_data[b"test"]) + + # get MNIST labels + mnist_train_labels = datasets.MNIST(root=self.mnist_root, train=True, download=True).train_labels + mnist_test_labels = datasets.MNIST(root=self.mnist_root, train=False, download=True).test_labels + + # save MNIST-M dataset + training_set = (mnist_m_train_data, mnist_train_labels) + test_set = (mnist_m_test_data, mnist_test_labels) + with open(os.path.join(self.root, self.processed_folder, self.training_file), "wb") as f: + torch.save(training_set, f) + with open(os.path.join(self.root, self.processed_folder, self.test_file), "wb") as f: + torch.save(test_set, f) + + print("Done!") \ No newline at end of file diff --git a/examples/jumbot/digits/proposed/models.py b/examples/jumbot/digits/proposed/models.py new file mode 100644 index 0000000..88ec9bc --- /dev/null +++ b/examples/jumbot/digits/proposed/models.py @@ -0,0 +1,106 @@ +# -*- coding: utf-8 -*- +""" +Dependances : +- python (3.8.0) +- numpy (1.19.2) +- torch (1.7.1) +- POT (0.7.0) +- Cuda + +command: +python3 train.py +""" + + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np + + +class Classifier2(nn.Module): + ''' Classifier class''' + def __init__(self, nclass=None): + super(Classifier2, self).__init__() + assert nclass!=None + self.fc2 = nn.Linear(128, 10) + + def forward(self, x): + x = self.fc2(x) + return x + + +def weights_init(m): + ''' Weight init function for layers ''' + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + m.weight.data.normal_(0.0, 0.02) + elif classname.find('BatchNorm') != -1: + m.weight.data.normal_(1.0, 0.02) + m.bias.data.fill_(0) + elif classname.find('Linear') != -1: + m.weight.data.normal_(0.0, 0.1) + m.bias.data.fill_(0) + + +def call_bn(bn, x): + ''' call batch norm layer ''' + return bn(x) + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + + +class Cnn_generator(nn.Module): + '''9 layer CNN feature extractor class''' + def __init__(self, input_channel=3, n_outputs=10, dropout_rate=0.25, momentum=0.1): + self.momentum = momentum + super(Cnn_generator, self).__init__() + self.c1=nn.Conv2d(input_channel, 32,kernel_size=3, stride=1, padding=1) + self.c2=nn.Conv2d(32,32,kernel_size=3, stride=1, padding=1) + self.c3=nn.Conv2d(32,64,kernel_size=3, stride=1, padding=1) + self.c4=nn.Conv2d(64,64,kernel_size=3, stride=1, padding=1) + self.c5=nn.Conv2d(64,128,kernel_size=3, stride=1, padding=1) + self.c6=nn.Conv2d(128,128,kernel_size=3, stride=1, padding=1) + self.linear1=nn.Linear(128*4*4, 128) + self.bn1=nn.BatchNorm2d(32) + self.bn2=nn.BatchNorm2d(32) + self.bn3=nn.BatchNorm2d(64) + self.bn4=nn.BatchNorm2d(64) + self.bn5=nn.BatchNorm2d(128) + self.bn6=nn.BatchNorm2d(128) + self.dropout = nn.Dropout2d(dropout_rate) + + def forward(self, x): + h=x + h=self.c1(h) + h=F.relu(call_bn(self.bn1, h)) + h=self.c2(h) + h=F.relu(call_bn(self.bn2, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h=self.c3(h) + h=F.relu(call_bn(self.bn3, h)) + h=self.c4(h) + h=F.relu(call_bn(self.bn4, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h=self.c5(h) + h=F.relu(call_bn(self.bn5, h)) + h=self.c6(h) + h=F.relu(call_bn(self.bn6, h)) + h=F.max_pool2d(h, kernel_size=2, stride=2) + + h = h.view(h.size(0), -1) + logit=torch.sigmoid(self.linear1(h)) + return logit \ No newline at end of file diff --git a/examples/jumbot/digits/proposed/run_prp.sh b/examples/jumbot/digits/proposed/run_prp.sh new file mode 100755 index 0000000..8f76290 --- /dev/null +++ b/examples/jumbot/digits/proposed/run_prp.sh @@ -0,0 +1,8 @@ +python train.py --lda 100 --source_dset usps --target_dset mnist --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_u2m.txt" +python train.py --lda 100 --source_dset mmnist --target_dset usps --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_mm2u.txt" +python train.py --lda 100 --source_dset mmnist --target_dset mnist --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_mm2m.txt" +python train.py --lda 100 --source_dset svhn --target_dset mmnist --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_s2mm.txt" +python train.py --lda 100 --source_dset mnist --target_dset mmnist --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_m2mm.txt" +python train.py --lda 100 --source_dset svhn --target_dset mnist --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_s2m.txt" +python train.py --lda 100 --source_dset mnist --target_dset usps --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_m2u.txt" +python train.py --lda 100 --source_dset svhn --target_dset usps --khp 1e-2 --ktype imq_v2 --case bal --crit rgrad > "new_s2u.txt" \ No newline at end of file diff --git a/examples/jumbot/digits/proposed/train.py b/examples/jumbot/digits/proposed/train.py new file mode 100644 index 0000000..1a593a6 --- /dev/null +++ b/examples/jumbot/digits/proposed/train.py @@ -0,0 +1,170 @@ +import numpy as np +import torch +import torch.nn as nn +from torchvision import datasets, transforms +from torch.utils.data import DataLoader +torch.multiprocessing.set_sharing_strategy('file_system') +import torch.nn.functional as F +from models import Classifier2, weights_init, Cnn_generator +from jumbot_utils import * +from jumbot import Jumbot +# import wandb +import logging, os, yaml +#_____________________________ +import argparse +parser = argparse.ArgumentParser() +parser.add_argument("--source_dset", required=True, type = str, help = "source dset") +parser.add_argument("--target_dset", required=True, type = str, help = "target dset") +parser.add_argument("--lda", type=float, default = 1e-1) +parser.add_argument("--max_itr", type=int, default=100) +parser.add_argument("--khp", type = float, default=None) +parser.add_argument("--ktype", type=str, default="imq_v2") +parser.add_argument("--case", type=str, default="unb") +parser.add_argument("--crit", type=str, default=None) +parser.add_argument("--reg_type", type=str, default="vanilla") +parser.add_argument("--eta1", type=float, default=0.1) +parser.add_argument("--eta2", type=float, default=0.1) +parser.add_argument("--ridge", type=float, default=1e-10) +parser.add_argument("--log", type=str, default="MMDOT") + +args = parser.parse_args() + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +set_seed(1980) + +source_dset = args.source_dset +target_dset = args.target_dset + +task = "{}2{}".format(source_dset, target_dset) +#_____________________________ + +reg_type = args.reg_type +lda = args.lda +max_itr = args.max_itr +khp = args.khp +ktype = args.ktype +case = args.case +crit = args.crit + +logger_fname = f'[{args.log}]_{task}' + +# wandb.login() +# run = wandb.init(project=logger_fname) + +batch_size = 500 +nclass = 10 + +# pre-processing to tensor, and mean subtraction +#1)TRANSFORM SOURCE +def get_transform(dset): + if dset == "usps": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mnist": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mmnist": + transform = transforms.Compose( + [ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ] + ) + elif dset == "svhn": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + return transform + +def get_dset(train, dset, transform): + if dset == "usps": + tset = datasets.USPS('../data', train = train, download=True, + transform= transform) + elif dset == "mnist": + tset = datasets.MNIST('../data', train=train, download=True, + transform=transform) + elif dset == "mmnist": + import mmnist + tset = mmnist.MNISTM("../mnistm", train=train, download=True, + transform=transform) + elif dset == "svhn": + if train: + tset = datasets.SVHN('../data', split='train', download=True, + transform=transform) + else: + tset = datasets.SVHN('../data', split='test', download=True, + transform=transform) + return tset + +transform_source = get_transform(source_dset) + +train_source_trainset = get_dset(True, source_dset, transform_source) + +# print('nb source data : ', len(train_source_trainset)) + +source_data = torch.zeros((len(train_source_trainset), 3, 32, 32)) +source_labels = torch.zeros((len(train_source_trainset))) + +for i, data in enumerate(train_source_trainset): + source_data[i] = data[0] + source_labels[i] = data[1] + +train_batch_sampler = BalancedBatchSampler(source_labels, batch_size=batch_size) +train_source_loader = torch.utils.data.DataLoader(train_source_trainset, batch_sampler=train_batch_sampler) + +transform_target = get_transform(target_dset) + +train_target_trainset = get_dset(True, target_dset, transform_target) + +train_target_loader = torch.utils.data.DataLoader(train_target_trainset, batch_size=batch_size, shuffle=True) + +### TEST sets +test_source_loader = torch.utils.data.DataLoader(get_dset(False, source_dset, transform_source), batch_size=batch_size, shuffle=False) + +test_target_loader = torch.utils.data.DataLoader(get_dset(False, target_dset, transform_target), batch_size=batch_size, shuffle=False) + + +####### Main + +model_g = Cnn_generator().cuda().apply(weights_init) +model_f = Classifier2(nclass=nclass).cuda().apply(weights_init) + +eta1 = args.eta1 +eta2 = args.eta2 + +model_g.train() +model_f.train() + + +save_as = f"models_{task}" +os.makedirs(save_as, exist_ok=1) + +jumbot = Jumbot(model_g, model_f, save_as=save_as, n_class = nclass, reg_type=reg_type, lda=lda, max_itr=max_itr, khp=khp,\ + verbose=True, ktype=ktype, ridge=args.ridge, wd=0, eta1=eta1, eta2=eta2, case=case, crit=crit) +loss = jumbot.source_only(train_source_loader) +loss = jumbot.fit(train_source_loader, train_target_loader, test_target_loader, n_epochs=100) + +source_acc = jumbot.evaluate(test_source_loader) +target_acc = jumbot.evaluate(test_target_loader) +print ("Method = {}, Task = {}, target_acc = {}".format(args.log, task, target_acc)) diff --git a/examples/jumbot/digits/proposed/tsne.py b/examples/jumbot/digits/proposed/tsne.py new file mode 100644 index 0000000..7f2a14d --- /dev/null +++ b/examples/jumbot/digits/proposed/tsne.py @@ -0,0 +1,181 @@ +import numpy as np +import torch +import torch.nn as nn +from torchvision import datasets, transforms +from torch.utils.data import DataLoader +torch.multiprocessing.set_sharing_strategy('file_system') + +import matplotlib.pyplot as plt +import matplotlib.cm as cm +from sklearn.manifold import TSNE + +import torch.nn.functional as F +from models import Classifier2, weights_init, Cnn_generator + +from jumbot_utils import * +#_____________________________ +import argparse +parser = argparse.ArgumentParser() +parser.add_argument("--source_dset", required=True, type = str, help = "source dset") +parser.add_argument("--target_dset", required=True, type = str, help = "target dset") +args = parser.parse_args() +source_dset = args.source_dset +target_dset = args.target_dset +log = "MMDOT" + +task = "{}2{}".format(source_dset, target_dset) +#_____________________________ + + +logger_fname = f'[{log}]_{task}' + +def set_seed(seed): + import random + torch.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(seed) + random.seed(seed) + import os + os.environ['main_phd'] = str(seed) + +batch_size = 500 +nclass = 10 + +set_seed(1980) + +def feature_extraction(model, dataloader): + embed_list = [] + label_list = [] + + with torch.no_grad(): + for img, label in dataloader: + img = img.to(device) + embed = model(img) + label_list.append(label) + embed_list.append(embed) + + return torch.cat(embed_list).cpu().numpy(), torch.cat(label_list).cpu().numpy() + +# pre-processing to tensor, and mean subtraction + +def get_transform(dset): + if dset == "usps": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mnist": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.Lambda(lambda x: x.convert("RGB")), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + elif dset == "mmnist": + transform = transforms.Compose( + [ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), + ] + ) + elif dset == "svhn": + transform = transforms.Compose([ + transforms.Resize(32), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) + ]) + return transform + +def get_dset(train, dset, transform): + if dset == "usps": + tset = datasets.USPS('../data', train = train, download=True, + transform= transform) + elif dset == "mnist": + tset = datasets.MNIST('../data', train=train, download=True, + transform=transform) + elif dset == "mmnist": + import mmnist + tset = mmnist.MNISTM("../mnistm", train=train, download=True, + transform=transform) + elif dset == "svhn": + if train: + tset = datasets.SVHN('../data', split='train', download=True, + transform=transform) + else: + tset = datasets.SVHN('../data', split='test', download=True, + transform=transform) + return tset + +transform_source = get_transform(source_dset) + +transform_target = get_transform(target_dset) + +### TEST sets +test_source_loader = torch.utils.data.DataLoader(get_dset(False, source_dset, transform_source), batch_size=batch_size, shuffle=False) + +test_target_loader = torch.utils.data.DataLoader(get_dset(False, target_dset, transform_target), batch_size=batch_size, shuffle=False) + + +####### Main + +model_g = Cnn_generator().cuda().apply(weights_init) +model_f = Classifier2(nclass=nclass).cuda().apply(weights_init) + +eta1 = 0.1 +eta2 = 0.1 +tau = 1.0 +epsilon = 0.1 + +fig = plt.figure(figsize=(20, 5)) +TICK_SIZE = 14 +TITLE_SIZE = 20 +MARKER_SIZE = 50 +NUM_SAMPLES = 2000 + +ax = fig.add_subplot() +title = "Proposed" + +# model_g.load_state_dict(torch.load(f"models_{source_dset}2{target_dset}/model_g.pt")) +model_g = torch.load(f"models_{source_dset}2{target_dset}/model_g.pt") + +source_embed, source_label = feature_extraction(model_g, test_source_loader) +target_embed, target_label = feature_extraction(model_g, test_target_loader) + +combined_imgs = np.vstack([source_embed[0:NUM_SAMPLES, :], target_embed[0:NUM_SAMPLES, :]]) +combined_labels = np.concatenate([source_label[0:NUM_SAMPLES], target_label[0:NUM_SAMPLES]]) +combined_labels = combined_labels.astype("int") +tsne = TSNE(perplexity=30, n_components=2, init="pca", n_iter=3000) +source_only_tsne = tsne.fit_transform(combined_imgs) +ax.scatter( + source_only_tsne[:NUM_SAMPLES, 0], + source_only_tsne[:NUM_SAMPLES, 1], + c=combined_labels[:NUM_SAMPLES], + s=MARKER_SIZE, + alpha=0.5, + marker="o", + cmap=cm.jet, + label="source", +) +ax.scatter( + source_only_tsne[NUM_SAMPLES:, 0], + source_only_tsne[NUM_SAMPLES:, 1], + c=combined_labels[NUM_SAMPLES:], + s=MARKER_SIZE, + alpha=0.5, + marker="+", + cmap=cm.jet, + label="target", +) +ax.set_xlim(-125, 125) +ax.set_ylim(-125, 125) +ax.tick_params(axis="both", which="major", labelsize=TICK_SIZE) +ax.set_title(title, fontsize=TITLE_SIZE) +ax.legend(loc="upper right") + +plt.savefig(f"{source_dset}2{target_dset}.jpg") +plt.close() diff --git a/examples/synthetic/.DS_Store b/examples/synthetic/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/examples/synthetic/.DS_Store differ diff --git a/examples/synthetic/OTplan.ipynb b/examples/synthetic/OTplan.ipynb new file mode 100644 index 0000000..ba24952 --- /dev/null +++ b/examples/synthetic/OTplan.ipynb @@ -0,0 +1,159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import ot\n", + "from ot.datasets import make_1D_gauss as gauss\n", + "from ot_mmd.mmdot import solve_apgd\n", + "from ot_mmd.utils import get_cost_G, set_seed\n", + "import ot.plot\n", + "import matplotlib.pyplot as plt\n", + "\n", + "set_seed(0)\n", + "\n", + "m, n = 100, 100\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\n", + "dtype = torch.float32\n", + "x = torch.arange(m, device=device, dtype=dtype)\n", + "y = torch.arange(n, device=device, dtype=dtype)\n", + "\n", + "a = torch.from_numpy(gauss(m, 20, 5)).float().to(device)\n", + "b = torch.from_numpy(gauss(n, 60, 10)).float().to(device)\n", + "v = {1: a, 2: b}\n", + "\n", + "max_itr = 1000" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Balanced Case" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lda = 10000\n", + "C, G = get_cost_G(x=x, y=y, khp=0.5, ktype=\"imq\")\n", + "\n", + "alpha, obj_itr = solve_apgd(C, G, v, max_itr, lda, crit=\"obj\")\n", + "plt.plot([i.item() for i in obj_itr])\n", + "\n", + "plt.figure(2, figsize=(5, 5))\n", + "ot.plot.plot1D_mat(v[1].cpu().numpy(), v[2].cpu().numpy(), alpha.cpu().numpy(), \"ot-mmd gamma\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Unbalanced Case" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lda = 10000\n", + "C, G = get_cost_G(x=x, y=y, khp=0.1, ktype=\"imq\")\n", + "\n", + "alpha, obj_itr = solve_apgd(C, G, v, max_itr, lda, crit=\"obj\", case=\"unb\")\n", + "plt.plot([i.item() for i in obj_itr])\n", + "\n", + "plt.figure(2, figsize=(5, 5))\n", + "ot.plot.plot1D_mat(v[1].cpu().numpy(), v[2].cpu().numpy(), alpha.cpu().numpy(), \"ot-mmd gamma\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main_phd", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c3d680260d6014bb8937807d07766c52e3de9a29136c40f6e77d246151ac2f0c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/synthetic/__init__.py b/examples/synthetic/__init__.py new file mode 100644 index 0000000..fd58c87 --- /dev/null +++ b/examples/synthetic/__init__.py @@ -0,0 +1,2 @@ +from ot_mmd.mmdot import * +from ot_mmd.utils import * \ No newline at end of file diff --git a/examples/synthetic/barycenter_with_imq.ipynb b/examples/synthetic/barycenter_with_imq.ipynb new file mode 100644 index 0000000..b6379d8 --- /dev/null +++ b/examples/synthetic/barycenter_with_imq.ipynb @@ -0,0 +1,421 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ot\n", + "import torch\n", + "from ot_mmd.utils import get_cost_G\n", + "from ot_mmd.barycenter import solve_apgd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "n = 100\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\n", + "dtype = torch.float64\n", + "\n", + "x = torch.arange(n, device=device, dtype=dtype)\n", + "\n", + "a1 = torch.from_numpy(ot.datasets.make_1D_gauss(n, m=20, s=5)).to(dtype).to(device)\n", + "a2 = torch.from_numpy(ot.datasets.make_1D_gauss(n, m=60, s=8)).to(dtype).to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficient 0.5, 0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"balanced case\"\"\"\n", + "\n", + "rho={1: 0.5, 2: 0.5}\n", + "ktype = \"imq\"\n", + "khp = 0.1\n", + "lda1 = 100\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"unbalanced case\"\"\"\n", + "\n", + "rho={1: 0.5, 2: 0.5}\n", + "ktype = \"imq\"\n", + "khp = 0.1\n", + "lda1 = 100\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficient 0, 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"balanced case\"\"\"\n", + "rho={1: 0, 2: 1}\n", + "ktype = \"imq\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"unbalanced case\"\"\"\n", + "rho={1: 0, 2: 1}\n", + "ktype = \"imq\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficient 1, 0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"balanced case\"\"\"\n", + "rho={1: 1, 2: 0}\n", + "ktype = \"imq\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"unbalanced case\"\"\"\n", + "rho={1: 1, 2: 0}\n", + "ktype = \"imq\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\", crit=\"obj\", tol=1e-6)\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main_phd", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c3d680260d6014bb8937807d07766c52e3de9a29136c40f6e77d246151ac2f0c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/synthetic/barycenter_with_rbf.ipynb b/examples/synthetic/barycenter_with_rbf.ipynb new file mode 100644 index 0000000..79bb3db --- /dev/null +++ b/examples/synthetic/barycenter_with_rbf.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook visualizes the barycenter between Gaussian distributions with MMD-regularized UOT.\n", + "- RBF kernel is used for MMD.\n", + "- Results are shown for two cases: when we solve with a simplex constraint (balanced case) and when we solve with a non-negativity constraint (unbalanced case)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import ot\n", + "import torch\n", + "from ot_mmd.utils import get_cost_G\n", + "from ot_mmd.barycenter import solve_apgd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "n = 100\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\n", + "dtype = torch.float64\n", + "\n", + "x = torch.arange(n, device=device, dtype=dtype)\n", + "\n", + "a1 = torch.from_numpy(ot.datasets.make_1D_gauss(n, m=20, s=5)).to(dtype).to(device)\n", + "a2 = torch.from_numpy(ot.datasets.make_1D_gauss(n, m=60, s=8)).to(dtype).to(device)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficients 0.5, 0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the unbalanced case\"\"\"\n", + "rho={1: 0.5, 2: 0.5}\n", + "ktype = \"rbf\"\n", + "khp = 0.1\n", + "lda1 = 500\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the balanced case\"\"\"\n", + "rho={1: 0.5, 2: 0.5}\n", + "ktype = \"rbf\"\n", + "khp = 0.1\n", + "lda1 = 500\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficients 0, 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the unbalanced case\"\"\"\n", + "rho={1: 0, 2: 1}\n", + "ktype = \"rbf\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEICAYAAAC55kg0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAY7klEQVR4nO3dfZBc1X3m8e8zM3rBSFhSNGIlIRDYimPlxViWsUh2vVQwCVJiK3ElDkpsyZSzMmtg47yLZKuW7K63CBXbuxgiWba1hhjzEkyMTJRgCofYrhiMlMUYIWQmvFiDZGlkG4F4kzTz2z/uGXS7587M1WiknpnzfKq6uvvcc+49ZwT99D33dLciAjMzy1NbqztgZmat4xAwM8uYQ8DMLGMOATOzjDkEzMwy5hAwM8uYQ8DGFElXS/rCENu3S7rg5PWoHkkHJZ3TwuP/B0k7W3V8G78cAnZSSfqgpO9KeknSDyStlzSjbvuI+OmIuP/E9XBkImJaRDwJIOnzkv7niTyepJD0xtLxvxERbzqRx7SJySFgJ42kPwT+Evhj4PXAMuAs4F5Jk1vZt7okdUyEY5j1cwjYSSHpNOAvgCsj4h8j4nBEPA28jyII3l+qPlXSbZJekPSvkt5S2s/Tkt41yDFeL+kmST2SnpH0XyW1SZoi6TlJP1Oq2ynpZUlz0vNflfRwqvcvkn6u6Zh/KukR4MWqF+n+d+aS1gK/A/xJmiL6Sto+T9KXUt+ekvRfSm2vlnSHpC9Ieh74oKTzJH0r9WePpOv7g1LS11PT76Rj/JakCyR1l/b5Zkn3p/bbJb2ntO3zkm6Q9Pfpb/ygpDekbZL0SUn7JB2Q9Ej572YTj0PATpafB6YCd5YLI+Ig8A/ARaXilcDfArOALwJfljSpxjE+RXGGcQ7wH4HVwKUR8Wo67qpS3fcB/xwR+yQtATYBHwZ+Avg0sFnSlFL9VcCvADMi4shgHYiIjcDNwLVpiujdktqArwDfAeYDFwIflfTLTWO+A5iR2vcCvw/MBs5PbT6SjvHO1OYt6Ri3lfuQ/lZfAb4KzAGuBG6WVJ4uWkURyjOBLuBjqfyXgHcCP5n68lvADwcbr41/DgE7WWYD+wd5Ad2TtvfbFhF3RMRh4BMU4bFsqJ1Laqd4wboqIl5IZxkfBz6QqnyRxhD47VQG8J+AT0fEgxHRGxE3Aq82HfO6iNgVES/XGGuztwOdEfHfI+JQunbwGeCSUp1vRcSXI6IvIl6OiG0R8UBEHElj+TRFsNWxDJgGXJOO9zXgbhrHf2dEfDv9e9wMnJvKDwPTgZ8CFBE7ImLPCMZs44TnHu1k2Q/MltRREQRz0/Z+u/ofRERfmuaYN8z+ZwOTgWdKZc9QvPMG+BpwiqR3AD+geNH7u7TtLGCNpCtLbSc3HXMXI3cWME/Sc6WyduAbg+1f0k9SBOBS4HUU/69uq3m8ecCuiOgrlZX/FlD8Dfq9RBEaRMTXJF0P3ACcKenvgD+KiOdrHtvGGZ8J2MnyLYp31+8tF0o6FVgO3FcqXlDa3gacAeweZv/7Kd7FnlUqOxN4FoowAW6neDf828DdEfFCqrcL+FhEzCjdXhcRt5T2dSxft9tcdxfwVNP+p0fEiiHarAceBxZFxGnAnwGqefzdwIL0t+v32t9i2M5HXBcRbwN+mmJa6I9rHtfGIYeAnRQRcYBiDvpTki6WNEnSQoq5/27gb0rV3ybpvekC7EcpwuOBYfbfS/Ei/zFJ0yWdBfwBUP7MwRcppox+h6NTQVBMzVwm6R3pwuipkn5F0vQRDncvxXWJft8Gnk8Xl0+R1C7pZyS9fYh9TAeeBw5K+ingPw9zjLIHgRcpLk5PUvG5incDtw7XcUlvT3+HSWkfr1Bcn7AJyiFgJ01EXEvxjvavKF7gHqR4l3xhunjb7y6KF+sfU8zpvzddHxjOlRQvXE8C36R4od9UOn7/i+M8iovR/eVbKa4LXJ+O2QV8cCRjTD4HLE4rc76cAurdFFNQT1GctXyW4iL2YP6I4ozlBYqQuq1p+9XAjekY7ytviIhDwHsozrD2A38NrI6Ix2v0/bR0vB9TTCH9kOLfyyYo+UdlbDyR9H3g/RHx9WErm9mwfCZg44akTqATeLrFXTGbMBwCNi6k+fMngE9FxPdb3R+zicLTQWZmGfOZgJlZxsbVh8Vmz54dCxcubHU3zMzGlW3btu2PiM6qbeMqBBYuXMjWrVtb3Q0zs3FF0jODbfN0kJlZxhwCZmYZcwiYmWXMIWBmljGHgJlZxhwCZmYZcwiYmWUsixC4b8de/vr+rlZ3w8xszMkiBO7f2cNnv/FUq7thZjbmZBECZmZWzSFgZpaxbELAX5ltZjZQFiEgtboHZmZjUxYhYGZm1bIJAU8GmZkNlEUIeDbIzKxaFiFgZmbVHAJmZhnLJgS8QtTMbKBaISDpYkk7JXVJWlexXZKuS9sfkbQklS+Q9E+SdkjaLun3Sm1mSbpX0hPpfuboDWtA/07Urs3MxrVhQ0BSO3ADsBxYDKyStLip2nJgUbqtBdan8iPAH0bEm4FlwOWltuuA+yJiEXBfem5mZidRnTOB84CuiHgyIg4BtwIrm+qsBG6KwgPADElzI2JPRPwrQES8AOwA5pfa3Jge3wj82vENZWj+xLCZ2UB1QmA+sKv0vJujL+S160haCLwVeDAVnR4RewDS/Zyqg0taK2mrpK09PT01umtmZnXVCYGqCfXmt9VD1pE0DfgS8NGIeL5+9yAiNkbE0ohY2tnZeSxNzcxsGHVCoBtYUHp+BrC7bh1JkygC4OaIuLNUZ6+kuanOXGDfsXXdzMyOV50QeAhYJOlsSZOBS4DNTXU2A6vTKqFlwIGI2KNiWc7ngB0R8YmKNmvS4zXAXSMeRQ2+ImBmNlDHcBUi4oikK4B7gHZgU0Rsl3RZ2r4B2AKsALqAl4BLU/NfAD4AfFfSw6nszyJiC3ANcLukDwHfB35z1EbVxCtEzcyqDRsCAOlFe0tT2YbS4wAur2j3TQb56p6I+CFw4bF01szMRlc2nxj2fJCZ2UBZhID8PaJmZpWyCAEzM6vmEDAzy1g2IeBLAmZmA2URAl4iamZWLYsQMDOzatmEgL9F1MxsoCxCwLNBZmbVsggBMzOr5hAwM8tYNiHgKwJmZgNlEQJeImpmVi2LEDAzs2rZhIBXiJqZDZRFCMjzQWZmlbIIATMzq+YQMDPLWDYhEF4kamY2QBYh4CsCZmbVsggBMzOr5hAwM8tYNiHgzwmYmQ2URwj4ooCZWaU8QsDMzCplEwKeDTIzGyiLEJDng8zMKmURAmZmVs0hYGaWsXxCwBcFzMwGyCIE/E3SZmbVsggBMzOrlk0I+FtEzcwGyiIEPBtkZlYtixAwM7NqDgEzs4xlEwL+FlEzs4FqhYCkiyXtlNQlaV3Fdkm6Lm1/RNKS0rZNkvZJerSpzdWSnpX0cLqtOP7hDNb/E7VnM7PxbdgQkNQO3AAsBxYDqyQtbqq2HFiUbmuB9aVtnwcuHmT3n4yIc9NtyzH23czMjlOdM4HzgK6IeDIiDgG3Aiub6qwEborCA8AMSXMBIuLrwI9Gs9Mj4dkgM7OB6oTAfGBX6Xl3KjvWOlWuSNNHmyTNrKogaa2krZK29vT01NhlxT68SNTMrFKdEKh6BW1+Y12nTrP1wBuAc4E9wMerKkXExohYGhFLOzs7h9mlmZkdizoh0A0sKD0/A9g9gjoNImJvRPRGRB/wGYppJzMzO4nqhMBDwCJJZ0uaDFwCbG6qsxlYnVYJLQMORMSeoXbaf80g+XXg0cHqjobwGlEzswE6hqsQEUckXQHcA7QDmyJiu6TL0vYNwBZgBdAFvARc2t9e0i3ABcBsSd3Af4uIzwHXSjqXYtroaeDDozesRl4iamZWbdgQAEjLN7c0lW0oPQ7g8kHarhqk/AP1u2lmZidCPp8YbnUHzMzGoCxCwLNBZmbVsggBMzOr5hAwM8tYNiHgFaJmZgPlEQJeI2pmVimPEDAzs0oOATOzjGURAp4MMjOrlkUImJlZNYeAmVnGsgoBf5OomVmjLELAK0TNzKplEQJmZlbNIWBmlrGsQsCXBMzMGmURAvInBczMKmURAmZmVi2rEPBskJlZoyxCwEtEzcyqZRECZmZWzSFgZpaxrELAXxthZtYoixDwJQEzs2pZhICZmVXLKgQ8GWRm1iiLEPASUTOzalmEgJmZVXMImJllLKsQ8ApRM7NGWYSAfFHAzKxSFiFgZmbVsgqB8CJRM7MGWYWAmZk1cgiYmWXMIWBmlrGsQsBLRM3MGtUKAUkXS9opqUvSuortknRd2v6IpCWlbZsk7ZP0aFObWZLulfREup95/MMZrP8nas9mZuPbsCEgqR24AVgOLAZWSVrcVG05sCjd1gLrS9s+D1xcset1wH0RsQi4Lz03M7OTqM6ZwHlAV0Q8GRGHgFuBlU11VgI3ReEBYIakuQAR8XXgRxX7XQncmB7fCPzaCPpvZmbHoU4IzAd2lZ53p7JjrdPs9IjYA5Du51RVkrRW0lZJW3t6emp0t2If/lkZM7NKdUKg6hW0+RJrnTojEhEbI2JpRCzt7OwcjV2amVlSJwS6gQWl52cAu0dQp9ne/imjdL+vRl/MzGwU1QmBh4BFks6WNBm4BNjcVGczsDqtEloGHOif6hnCZmBNerwGuOsY+j0iXiJqZtZo2BCIiCPAFcA9wA7g9ojYLukySZelaluAJ4Eu4DPAR/rbS7oF+BbwJkndkj6UNl0DXCTpCeCi9PyE8BJRM7NqHXUqRcQWihf6ctmG0uMALh+k7apByn8IXFi7p2ZmNury+sSwv0XUzKxBFiHg2SAzs2pZhICZmVVzCJiZZSyrEPASUTOzRlmEgJeImplVyyIEzMysWlYh4NkgM7NGWYWAmZk1yiIE/FXSZmbVsggBMzOrllUIhNeImpk1yCIEvETUzKxaFiFgZmbVHAJmZhnLKgR8RcDMrFFWIWBmZo0cAmZmGcsqBLxC1MysURYhIK8RNTOrlEUImJlZNYeAmVnG8goBXxMwM2uQRQj4ioCZWbUsQsDMzKplFQLh+SAzswZZhEBbmg/y5wTMzBrlEQIpBfqcAmZmDbIIgf4Pi/U5A8zMGmQRAkeng5wCZmZlmYSAzwTMzKpkEgLFva8JmJk1yiIEjl4TcAiYmZVlEQL900HOADOzRpmEQHHf64sCZmYNsgiBdn9OwMysUhYh4M8JmJlVqxUCki6WtFNSl6R1Fdsl6bq0/RFJS4ZrK+lqSc9KejjdVozOkAby5wTMzKoNGwKS2oEbgOXAYmCVpMVN1ZYDi9JtLbC+ZttPRsS56bbleAczGH9OwMysWp0zgfOAroh4MiIOAbcCK5vqrARuisIDwAxJc2u2PeH8OQEzs2p1QmA+sKv0vDuV1akzXNsr0vTRJkkzqw4uaa2krZK29vT01Ohu5T4Ah4CZWbM6IVD1w1zNr6aD1Rmq7XrgDcC5wB7g41UHj4iNEbE0IpZ2dnbW6O5A/pyAmVm1jhp1uoEFpednALtr1pk8WNuI2NtfKOkzwN21e32MPB1kZlatzpnAQ8AiSWdLmgxcAmxuqrMZWJ1WCS0DDkTEnqHapmsG/X4dePQ4xzIoXxg2M6s27JlARByRdAVwD9AObIqI7ZIuS9s3AFuAFUAX8BJw6VBt066vlXQuxfTQ08CHR3FcDeQzATOzSnWmg0jLN7c0lW0oPQ7g8rptU/kHjqmnx+HoNQGHgJlZWRafGPZ0kJlZtUxCoLjvcwqYmTXIIgT83UFmZtWyCAF/d5CZWbU8QqDNZwJmZlXyCAEvETUzq5RFCPi7g8zMqmURAm0OATOzSpmEQHHf19fafpiZjTWZhECRAr0+EzAza5BFCHS0p+kgLw8yM2uQRQhMai+GeajX80FmZmVZhMDk/hA44hAwMyvLIgT6zwQO93o6yMysLIsQmNzRHwI+EzAzK8siBCalC8MOATOzRpmEgC8Mm5lVySsEfGHYzKxBFiHQ3iba2+TpIDOzJlmEABTLRL06yMysUTYhMKldng4yM2uSTQhM7mjzhWEzsyb5hEB7G68edgiYmZVlEwKnTungpUNHWt0NM7MxJZsQmDa1g4OvOgTMzMqyCYHpUyfx/CsOATOzsnxCYEoHB1853OpumJmNKdmEwLQpng4yM2uWTwhM7eAFTweZmTXIJgRmnTqZlw71eoWQmVlJNiEwf8YpAOx+7uUW98TMbOzIJgTmpRB49rlXWtwTM7OxI5sQOHPW6wB4qudgi3tiZjZ2ZBMCp582hTnTp/Dwruda3RUzszEjmxCQxHlnz+KbXfs54i+SMzMDMgoBgPe8ZR77Dx7i77+7p9VdMTMbE7IKgXe9+XTePPc0/sfdj/HU/hdb3R0zs5arFQKSLpa0U1KXpHUV2yXpurT9EUlLhmsraZakeyU9ke5njs6QBtfWJj616q30Bay8/pt88t7vseeAl4yaWb4UMfRPLkpqB74HXAR0Aw8BqyLisVKdFcCVwArgHcD/iYh3DNVW0rXAjyLimhQOMyPiT4fqy9KlS2Pr1q0jHOpRXfsOcu0/Ps5XH9sLwPSpHcyfcQrzZpzCvBlTmTfjFP7daVOZ0tHOpHYxuaONye1tTOpoo02iI/1mcXtb4+PieRttbdDR1jawjkRbm467/2Zmx0LStohYWrWto0b784CuiHgy7exWYCXwWKnOSuCmKBLlAUkzJM0FFg7RdiVwQWp/I3A/MGQIjJY3zpnGxtVL6dp3kG880cPT+1/k2edeYfdzL7PtmR9z4OUT90VzEnS0aUCYtLe10V4KD9XMirqRoho7rB1PLejbsezPbCL6X+/9Wd6+cNao77dOCMwHdpWed1O82x+uzvxh2p4eEXsAImKPpDlVB5e0FlgLcOaZZ9bobn1vnDONN86ZNqD84KtH6HnhVQ4d6eNwbx+Hevtee9zbF/RFcKQ36O0LeqO4P9JbetwX9KX73r4+evugt6+vqfxo3df203u0TR1Dn8OV6tWoWH9f9WrW3V/dilF/j2YT0imT2k/IfuuEQNUbsOb/IwerU6ftkCJiI7ARiumgY2k7UtOmdDBtSp0/jZnZ+FbnwnA3sKD0/Axgd806Q7Xdm6aMSPf76nfbzMxGQ50QeAhYJOlsSZOBS4DNTXU2A6vTKqFlwIE01TNU283AmvR4DXDXcY7FzMyO0bBzHhFxRNIVwD1AO7ApIrZLuixt3wBsoVgZ1AW8BFw6VNu062uA2yV9CPg+8JujOjIzMxvWsEtEx5LRWiJqZpaToZaIZvWJYTMza+QQMDPLmEPAzCxjDgEzs4yNqwvDknqAZ0bYfDawfxS7Mx54zHnwmPNwPGM+KyI6qzaMqxA4HpK2DnZ1fKLymPPgMefhRI3Z00FmZhlzCJiZZSynENjY6g60gMecB485DydkzNlcEzAzs4FyOhMwM7MmDgEzs4xlEQKD/dj9eCNpgaR/krRD0nZJv5fKZ0m6V9IT6X5mqc1Vadw7Jf1yqfxtkr6btl2nur/x2CKS2iX9P0l3p+cTeszpJ1rvkPR4+vc+P4Mx/3767/pRSbdImjrRxixpk6R9kh4tlY3aGCVNkXRbKn9Q0sJhOxURE/pG8RXW/wacA0wGvgMsbnW/RjiWucCS9Hg68D1gMXAtsC6VrwP+Mj1enMY7BTg7/R3a07ZvA+dT/PrbPwDLWz2+Ycb+B8AXgbvT8wk9Zorf3f7d9HgyMGMij5nip2ifAk5Jz28HPjjRxgy8E1gCPFoqG7UxAh8BNqTHlwC3DdunVv9RTsIf/XzgntLzq4CrWt2vURrbXcBFwE5gbiqbC+ysGivF7zqcn+o8XipfBXy61eMZYpxnAPcBv8jREJiwYwZOSy+IaiqfyGPu/z3yWRS/c3I38EsTcczAwqYQGLUx9tdJjzsoPmGsofqTw3RQ1Y/dz29RX0ZNOs17K/AgcHoUv+RGup+Tqg029vnpcXP5WPW/gT8B+kplE3nM5wA9wP9NU2CflXQqE3jMEfEs8FcUPzC1h+LXCb/KBB5zyWiO8bU2EXEEOAD8xFAHzyEEjvvH7scaSdOALwEfjYjnh6paURZDlI85kn4V2BcR2+o2qSgbV2OmeAe3BFgfEW8FXqSYJhjMuB9zmgdfSTHtMQ84VdL7h2pSUTauxlzDSMZ4zOPPIQSG+rH7cUfSJIoAuDki7kzFeyXNTdvnAvtS+WBj706Pm8vHol8A3iPpaeBW4BclfYGJPeZuoDsiHkzP76AIhYk85ncBT0VET0QcBu4Efp6JPeZ+oznG19pI6gBeD/xoqIPnEAJD/dj9uJJWAHwO2BERnyht2gysSY/XUFwr6C+/JK0YOBtYBHw7nXK+IGlZ2ufqUpsxJSKuiogzImIhxb/d1yLi/UzsMf8A2CXpTanoQuAxJvCYKaaBlkl6XerrhcAOJvaY+43mGMv7+g2K/1+GPhNq9UWSk3QhZgXFSpp/A/681f05jnH8e4pTu0eAh9NtBcWc333AE+l+VqnNn6dx76S0SgJYCjyatl3PMBePxsINuICjF4Yn9JiBc4Gt6d/6y8DMDMb8F8Djqb9/Q7EqZkKNGbiF4prHYYp37R8azTECU4G/BbooVhCdM1yf/LURZmYZy2E6yMzMBuEQMDPLmEPAzCxjDgEzs4w5BMzMMuYQMDPLmEPAzCxj/x8rioWtZa6ocgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the balanced case\"\"\"\n", + "rho={1: 0, 2: 1}\n", + "ktype = \"rbf\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Coefficients 1, 0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the unbalanced case\"\"\"\n", + "rho={1: 1, 2: 0}\n", + "ktype = \"rbf\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"unb\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"Solving the balanced case\"\"\"\n", + "rho={1: 1, 2: 0}\n", + "ktype = \"rbf\"\n", + "khp = 0.05\n", + "lda1 = 0.1\n", + "lda2 = lda1\n", + "max_itr = 10000\n", + "\n", + "C1, G = get_cost_G(x=x, y=x, khp=khp, ktype=ktype, p=2)\n", + "lda = {1: lda1, 2: lda2}\n", + "\n", + "bary, obj_itr = solve_apgd({1: C1, 2: C1}, {1: G[1], 2: G[2], 'all': G[1]}, {1: a1, 2: a2}, max_itr, lda,\\\n", + " rho, case=\"bal\")\n", + "\n", + "plt.clf()\n", + "plt.plot([val.item() for val in obj_itr])\n", + "plt.title(\"Obj over iterations\")\n", + "plt.show()\n", + "\n", + "plt.clf()\n", + "plt.plot(a1.cpu().numpy(), label='source')\n", + "plt.plot(a2.cpu().numpy(), label='target')\n", + "plt.plot(bary.cpu().numpy(), label='Proposed barycenter')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main_phd", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c3d680260d6014bb8937807d07766c52e3de9a29136c40f6e77d246151ac2f0c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/synthetic/level_sets/__init__.py b/examples/synthetic/level_sets/__init__.py new file mode 100644 index 0000000..fd58c87 --- /dev/null +++ b/examples/synthetic/level_sets/__init__.py @@ -0,0 +1,2 @@ +from ot_mmd.mmdot import * +from ot_mmd.utils import * \ No newline at end of file diff --git a/examples/synthetic/level_sets/contour_utils.py b/examples/synthetic/level_sets/contour_utils.py new file mode 100644 index 0000000..5f9d692 --- /dev/null +++ b/examples/synthetic/level_sets/contour_utils.py @@ -0,0 +1,64 @@ +import numpy as np +import ot +import matplotlib.pyplot as plt + + +def get_square_indices(dat): + ix = [] + ix.append(dat) + ix.append(tuple(-1*np.array(dat))) + ix.append(tuple(np.array([-1, 1])*np.array(dat))) + ix.append(tuple(np.array([1, -1])*np.array(dat))) + return ix + +def mirrored(maxval, inc=1): + x = np.arange(inc, maxval, inc) + if x[-1] != maxval: + x = np.r_[x, maxval] + return np.r_[-x[::-1], 0, x] + +def get_data(d, intv): + x = mirrored(d, intv) + y = mirrored(d, intv) + xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij') + nx = x.shape[0] + ny = y.shape[0] + data = [] + for i in range(nx): + for j in range(ny): + data.append([xv[i, j], yv[i, j]]) + data = np.array(data) + return data + +def get_distr_Q(dq, data_Q): + distr_Q = np.zeros(data_Q.shape[0]) + ix = [np.where((data_Q == (-dq, -dq)).all(axis = 1))[0][0], np.where((data_Q == (dq, dq)).all(axis = 1))[0][0]] + distr_Q[ix] = 0.5 + return distr_Q + +def get_distr_P(data_P, dat): + distr_P = np.zeros(data_P.shape[0]) + ix = [np.where((data_P == dat).all(axis = 1))[0][0], np.where((data_P == tuple(-1*np.array(dat))).all(axis = 1))[0][0]] + distr_P[ix] = 0.5 + if dat == (0, 0): + ix = np.where(distr_P>0) + distr_P[ix] = 1 + return distr_P + +def get_emd(M, wa, wb): + G = ot.emd(wa, wb, M) + dist = np.sum(G * M) + return dist, G + +def plot_fn(xv, yv, Z, intv, save_as, tot_l = 10): + fig, ax = plt.subplots(1, 1) + cpf = ax.contourf(xv, yv, Z, tot_l, cmap="hot") + colours = ['w' if level<0 else 'k' for level in cpf.levels] + ax.contour(xv, yv, Z, tot_l, colors = colours, linewidths = 0.5) + plt.colorbar(cpf) + start, end = ax.get_xlim() + ax.xaxis.set_ticks(np.arange(start, end+intv, intv)) + ax.yaxis.set_ticks(np.arange(start, end+intv, intv)) + if save_as is not None: + plt.savefig(save_as, bbox_inches='tight', pad_inches=0.1) + plt.show() diff --git a/examples/synthetic/level_sets/proposed.ipynb b/examples/synthetic/level_sets/proposed.ipynb new file mode 100644 index 0000000..aeef443 --- /dev/null +++ b/examples/synthetic/level_sets/proposed.ipynb @@ -0,0 +1,123 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from ot_mmd.mmdot import solve_apgd\n", + "from ot_mmd.utils import get_cost_G, get_t\n", + "from contour_utils import *\n", + "\n", + "dtype = torch.float64\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\n", + "\n", + "def get_Z(xv, yv, data_P, distr_Q, C, G, max_itr, lda, case=\"unb\"):\n", + " nx = xv.shape[0]\n", + " ny = yv.shape[0]\n", + " Z = np.empty((nx, ny))\n", + " for i in range(nx):\n", + " for j in range(ny):\n", + " # solve the OT problem for distributions indexed by i, j\n", + " distr_P = torch.from_numpy(get_distr_P(data_P, (xv[i, j], yv[i, j]))).to(dtype).to(device)\n", + " v = {1: distr_P, 2: distr_Q}\n", + " _, obj_itr = solve_apgd(C, G, v, max_itr, lda, case=case)\n", + " \n", + " Z[i, j] = obj_itr[-1].item()\n", + " return Z\n", + "\n", + "def nor_min_max(a):\n", + " return (a-a.min())/(a.max()-a.min())\n", + "\n", + "dq = 2\n", + "dp = 1\n", + "intv = 0.2\n", + "tot_l = 20\n", + "\n", + "khp = 10\n", + "ktype = \"rbf\"\n", + "lda = 1\n", + "max_itr = 1000\n", + "\n", + "data_Q = get_data(dq, intv)\n", + "distr_Q = get_t(get_distr_Q(dq, data_Q), device=device)\n", + "\n", + "data_Q = get_t(data_Q, device=device)\n", + "data_P = get_data(dp, intv)\n", + "\n", + "x = mirrored(dp, intv)\n", + "y = mirrored(dp, intv)\n", + "xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')\n", + "\n", + "C, G = get_cost_G(get_t(data_P, device=device), data_Q, khp, ktype)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for case in [\"unb\", \"bal\"]:\n", + " Z = get_Z(xv, yv, data_P, distr_Q, C, G, max_itr, lda, case=case)\n", + " plot_fn(xv, yv, nor_min_max(Z), 0.5, f\"proposed_{case}.jpg\", tot_l = tot_l)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main_phd", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "c3d680260d6014bb8937807d07766c52e3de9a29136c40f6e77d246151ac2f0c" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/synthetic/level_sets/proposed_bal.jpg b/examples/synthetic/level_sets/proposed_bal.jpg new file mode 100644 index 0000000..023542d Binary files /dev/null and b/examples/synthetic/level_sets/proposed_bal.jpg differ diff --git a/examples/synthetic/level_sets/proposed_unb.jpg b/examples/synthetic/level_sets/proposed_unb.jpg new file mode 100644 index 0000000..2a8220e Binary files /dev/null and b/examples/synthetic/level_sets/proposed_unb.jpg differ diff --git a/examples/two_sample_test/Fake_MNIST_data_EP100_N10000.pckl b/examples/two_sample_test/Fake_MNIST_data_EP100_N10000.pckl new file mode 100644 index 0000000..0918cd7 Binary files /dev/null and b/examples/two_sample_test/Fake_MNIST_data_EP100_N10000.pckl differ diff --git a/examples/two_sample_test/emd.py b/examples/two_sample_test/emd.py new file mode 100644 index 0000000..bb6030d --- /dev/null +++ b/examples/two_sample_test/emd.py @@ -0,0 +1,154 @@ +import argparse +import numpy as np +import pickle +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader +from torchvision import datasets +import ot +from ot_mmd.utils import get_dist + +seed1 = 1102 +seed2 = 819 +np.random.seed(seed2) +torch.manual_seed(seed2) +torch.cuda.manual_seed(seed2) +torch.backends.cudnn.deterministic = True + +parser = argparse.ArgumentParser() + +parser.add_argument('--method', type=str, default='emd') + +parser.add_argument("--batch_size", type=int, default=100, help="size of the batches") +parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension") +parser.add_argument("--channels", type=int, default=1, help="number of image channels") +parser.add_argument("--n", type=int, default=100, help="number of samples in one set") +parser.add_argument('--start_trial', type=int, default=0) +parser.add_argument('--end_trial', type=int, default=10) +parser.add_argument('--gpu_idx', type=int, default=0) + +opt = parser.parse_args() +dtype = torch.cuda.DoubleTensor if torch.cuda.is_available else torch.DoubleTensor +device = torch.device(f"cuda:{opt.gpu_idx}") if torch.cuda.is_available else torch.device("cpu") + +N_per = 100 +N1 = opt.n +method = opt.method + + +alpha = 0.05 +N = 100 +tot_N = 4000 + + +def run_test(S_v): + s1 = S_v[:N1, :] + s2 = S_v[N1:, :] + + s_all = torch.vstack([s1, s2]) + C_all = get_dist(s_all, s_all, p=1) + + C = C_all[:s1.shape[0], s1.shape[0]:] + C = C/C.max() + + mu, nu = torch.from_numpy(ot.unif(s1.shape[0])).to(device), torch.from_numpy(ot.unif(s2.shape[0])).to(device) + orig_value = ot.emd2(mu, nu, C).item() + perm_vals = [] + nxy = S_v.shape[0] + for r in range(N_per): + ind = np.random.choice(nxy, nxy, replace=False) + indx, indy = ind[:N1], ind[N1:] + + C_per = C_all[np.ix_(indx, indy)] + C_per = C_per/C_per.max() + perm_vals.append(ot.emd2(mu, nu, C_per).item()) + + perm_vals = np.sort(perm_vals) + threshold = perm_vals[np.int32(np.ceil(N_per * (1 - alpha)))] + h = 1 if orig_value > threshold else 0 + return h, threshold, orig_value + + +dataloader_FULL = DataLoader( + datasets.MNIST( + "./data/mnist", + train=True, + download=True, + transform=transforms.Compose( + [transforms.Resize(opt.img_size), transforms.ToTensor(), + transforms.Normalize([0.5], [0.5])] + ), + ), + batch_size=60000, + shuffle=True, +) + +for i, (imgs, Labels) in enumerate(dataloader_FULL): + data_all = imgs +data_all = data_all.to(device) + +Fake_MNIST = pickle.load(open('./Fake_MNIST_data_EP100_N10000.pckl', 'rb')) +ind_all = np.arange(tot_N) +ind_M_all = np.arange(tot_N) + +score_trial = [] +ntrials = opt.end_trial-opt.start_trial+1 + +print(f"Method: {method}. n: {opt.n}") + +for kk in range(opt.start_trial, opt.end_trial): + res = 0 + + torch.manual_seed(kk * 19 + N1) + torch.cuda.manual_seed(kk * 19 + N1) + np.random.seed(seed=seed2 * (kk + 9) + N1) + + # 1)--with the seeds for the trial, sample indices train-test + + # load real mnist data + ind_M_tr = np.random.choice(tot_N, N1, replace=False) + ind_M_te = np.delete(ind_M_all, ind_M_tr) + + # load fake mnist data + + ind_tr = np.random.choice(tot_N, N1, replace=False) + ind_te = np.delete(ind_all, ind_tr) + + # 2)--with the sampled indices for train-test, get train & test MNIST data + + Fake_MNIST_tr = torch.from_numpy(Fake_MNIST[0][ind_tr]).to(device) + Fake_MNIST_te = torch.from_numpy(Fake_MNIST[0][ind_te]).to(device) + + np.random.seed(seed=seed1) + torch.manual_seed(seed1) + torch.cuda.manual_seed(seed1) + + # 3)--The above seeds seem useless + + # Run 2-sample test on training set + # fetch training data + s1 = data_all[ind_M_tr] + s2 = Fake_MNIST_tr.type(dtype) + S = torch.cat([s1, s2], dim=0) # NOTE: removed .cpu() + S_v = S.view(2*N1, -1) + + np.random.seed(seed1) + for k in range(N): # NOTE: changed their seed + # 4)--With the seed for trial index, dataset index; sample test indices for both real, fake + np.random.seed(seed=seed1*(k+1) + 2*kk + N1) + ind_M = np.random.choice(len(ind_M_te), N1, replace=False) + s1 = data_all[ind_M_te[ind_M]] + + np.random.seed(seed=seed2*(k+3) + 2*kk + N1) + ind_F = np.random.choice(len(Fake_MNIST_te), N1, replace=False) + s2 = Fake_MNIST_te[ind_F].type(dtype) + + S = torch.cat([s1, s2], dim=0) + S_v = S.view(2*N1, -1) + + h, thr, val = run_test(S_v) + + res += h + score_trial.append(res) + print(f"--------n {opt.n}, trial {kk}, trial-score {score_trial[-1]}") +print({"n":opt.n, "mean across trials": np.sum(score_trial)/(ntrials*N)}) diff --git a/examples/two_sample_test/kl.py b/examples/two_sample_test/kl.py new file mode 100644 index 0000000..ccb635d --- /dev/null +++ b/examples/two_sample_test/kl.py @@ -0,0 +1,220 @@ +from ot.unbalanced import sinkhorn_unbalanced2 as klot +import argparse +import numpy as np +import os +import pickle +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader +from torchvision import datasets +import ot +# import wandb +from ot_mmd.utils import get_dist + +seed1 = 1102 +seed2 = 819 +np.random.seed(seed2) +torch.manual_seed(seed2) +torch.cuda.manual_seed(seed2) +torch.backends.cudnn.deterministic = True + +parser = argparse.ArgumentParser() +parser.add_argument("--ldas", nargs="+", type=float, default=100) +parser.add_argument("--ohps", nargs="+", type=float, default=-1.0) +parser.add_argument('--method', type=str, default='kluot') + +parser.add_argument("--batch_size", type=int, default=100, help="size of the batches") +parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension") +parser.add_argument("--channels", type=int, default=1, help="number of image channels") +parser.add_argument("--n", type=int, default=100, help="number of samples in one set") +parser.add_argument('--start_trial', type=int, default=0) +parser.add_argument('--end_trial', type=int, default=10) +parser.add_argument('--gpu_idx', type=int, default=0) + +opt = parser.parse_args() +Tensor = torch.cuda.DoubleTensor if torch.cuda.is_available else torch.DoubleTensor +device = torch.device(f"cuda:{opt.gpu_idx}") if torch.cuda.is_available else torch.device("cpu") + +N_per = 100 +N1 = opt.n +list_lda = opt.ldas +list_ohp = opt.ohps +method = opt.method + +# wandb.login() +# run = wandb.init( +# project=f"[VAL_P1_{method}]_TST_{ktype}_{case}_{crit}_{max_iter}_{opt.log_msg}") + +if isinstance(list_lda, float) or isinstance(list_lda, int): + list_lda = [list_lda] +else: + list_lda = list(list_lda) + +if isinstance(list_ohp, float) or isinstance(list_ohp, int): + list_ohp = [list_ohp] +else: + list_ohp = list(list_ohp) + +alpha = 0.05 +N = 100 +tot_N = 4000 + + +def validate(S_v, list_lda, list_ohp): + num_correct = {} # no. of correct by each hp + nor_margin = {} # the normalized margin by each hp + + best = {"lda": 1, "ohp": 0.1, "nc": None, "nm": None} # default lambda as 1, sigma for median heuristic + + for ohp in list_ohp: + # initializing + num_correct[ohp] = {} + nor_margin[ohp] = {} + for lda in list_lda: + num_correct[ohp][lda] = 0 + nor_margin[ohp][lda] = 0 + + for lda in list_lda: + hp = {"lda": lda, "ohp": ohp} + h, thr, val = run_test(S_v, hp) + + nor_margin[ohp][lda] += (val-thr)/(val + 1e-15) + + if h == 1: + num_correct[ohp][lda] += 1 + + # update best hp if ... + if (best["nc"] is None or best["nc"] < num_correct[ohp][lda]) or (best["nc"] == num_correct[ohp][lda] and best["nm"] < nor_margin[ohp][lda]): # (1st hp or this hp gets max correct) or (the nor_margin is max in case of a tie in num_correct) + best["lda"] = lda + best["ohp"] = ohp + best["nc"] = num_correct[ohp][lda] + best["nm"] = nor_margin[ohp][lda] + + best_hp = {"lda": best["lda"], "ohp": best["ohp"]} + return best_hp + +def run_test(S_v, hp): + ohp = hp["ohp"] + lda = hp["lda"] + + s1 = S_v[:N1, :] + s2 = S_v[N1:, :] + + s_all = torch.vstack([s1, s2]) + C_all = get_dist(s_all, s_all, p=1) + + C = C_all[:s1.shape[0], s1.shape[0]:] + C = C/C.max() + + mu, nu = torch.from_numpy(ot.unif(s1.shape[0])).to(device), torch.from_numpy(ot.unif(s2.shape[0])).to(device) + + orig_value = klot(mu, nu, C, ohp, lda, method='sinkhorn_stabilized').item() + perm_vals = [] + nxy = S_v.shape[0] + for r in range(N_per): + ind = np.random.choice(nxy, nxy, replace=False) + indx, indy = ind[:N1], ind[N1:] + + C_per = C_all[np.ix_(indx, indy)] + C_per = C_per/C_per.max() + + perm_vals.append(klot(mu, nu, C_per, ohp, lda, method='sinkhorn_stabilized').item()) + + perm_vals = np.sort(perm_vals) + threshold = perm_vals[np.int32(np.ceil(N_per * (1 - alpha)))] + h = 1 if orig_value > threshold else 0 + return h, threshold, orig_value + +def get_hp(kk, method): + if "kl" in method: + if kk == 2: + return {"lda": 10, "ohp": 0.001} + elif kk == 9: + return {"lda": 0.1, "ohp": 0.1} + return {"lda": 1, "ohp": 0.1} + +dataloader_FULL = DataLoader( + datasets.MNIST( + "./data/mnist", + train=True, + download=True, + transform=transforms.Compose( + [transforms.Resize(opt.img_size), transforms.ToTensor(), + transforms.Normalize([0.5], [0.5])] + ), + ), + batch_size=60000, + shuffle=True, +) + +for i, (imgs, Labels) in enumerate(dataloader_FULL): + data_all = imgs +data_all = data_all.to(device) + +Fake_MNIST = pickle.load(open('./Fake_MNIST_data_EP100_N10000.pckl', 'rb')) +ind_all = np.arange(tot_N) +ind_M_all = np.arange(tot_N) + +score_trial = [] +ntrials = opt.end_trial-opt.start_trial+1 + +print(f"Method: {method}. n: {opt.n}") + +for kk in range(opt.start_trial, opt.end_trial): + res = 0 + + torch.manual_seed(kk * 19 + N1) + torch.cuda.manual_seed(kk * 19 + N1) + np.random.seed(seed=seed2 * (kk + 9) + N1) + + # 1)--with the seeds for the trial, sample indices train-test + + # load real mnist data + ind_M_tr = np.random.choice(tot_N, N1, replace=False) + ind_M_te = np.delete(ind_M_all, ind_M_tr) + + # load fake mnist data + + ind_tr = np.random.choice(tot_N, N1, replace=False) + ind_te = np.delete(ind_all, ind_tr) + + # 2)--with the sampled indices for train-test, get train & test MNIST data + + Fake_MNIST_tr = torch.from_numpy(Fake_MNIST[0][ind_tr]).to(device) + Fake_MNIST_te = torch.from_numpy(Fake_MNIST[0][ind_te]).to(device) + + np.random.seed(seed=seed1) + torch.manual_seed(seed1) + torch.cuda.manual_seed(seed1) + + # 3)--The above seeds seem useless + + # Run 2-sample test on training set + # fetch training data + s1 = data_all[ind_M_tr] + s2 = Fake_MNIST_tr.type(Tensor) + S = torch.cat([s1, s2], dim=0) # NOTE: removed .cpu() + S_v = S.view(2*N1, -1) + + best_hp = get_hp(kk, method) # validate(S_v, list_lda, list_ohp) + + np.random.seed(seed1) + for k in range(N): # NOTE: changed their seed + # 4)--With the seed for trial index, dataset index; sample test indices for both real, fake + np.random.seed(seed=seed1*(k+1) + 2*kk + N1) + ind_M = np.random.choice(len(ind_M_te), N1, replace=False) + s1 = data_all[ind_M_te[ind_M]] + + np.random.seed(seed=seed2*(k+3) + 2*kk + N1) + ind_F = np.random.choice(len(Fake_MNIST_te), N1, replace=False) + s2 = Fake_MNIST_te[ind_F].type(Tensor) + + S = torch.cat([s1, s2], dim=0) + S_v = S.view(2*N1, -1) + + h, thr, val = run_test(S_v, best_hp) + + res += h + score_trial.append(res) + print(f"--------n {opt.n}, trial {kk}, trial-score {score_trial[-1]}") +print({"n":opt.n, "mean across trials": np.sum(score_trial)/(ntrials*N)}) diff --git a/examples/two_sample_test/mmd.py b/examples/two_sample_test/mmd.py new file mode 100644 index 0000000..9e64f67 --- /dev/null +++ b/examples/two_sample_test/mmd.py @@ -0,0 +1,234 @@ +import argparse +import numpy as np +import pickle +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader +from torchvision import datasets +import ot +from ot_mmd.utils import get_dist + +seed1 = 1102 +seed2 = 819 +np.random.seed(seed2) +torch.manual_seed(seed2) +torch.cuda.manual_seed(seed2) +torch.backends.cudnn.deterministic = True + +parser = argparse.ArgumentParser() +parser.add_argument("--ohps", nargs="+", type=float, default=-1.0) +parser.add_argument('--ktype', type=str, default='rbf') +parser.add_argument('--method', type=str, default='MMD') + +parser.add_argument("--batch_size", type=int, default=100, help="size of the batches") +parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension") +parser.add_argument("--channels", type=int, default=1, help="number of image channels") +parser.add_argument("--n", type=int, default=100, help="number of samples in one set") +parser.add_argument('--start_trial', type=int, default=0) +parser.add_argument('--end_trial', type=int, default=10) +parser.add_argument('--gpu_idx', type=int, default=0) + +opt = parser.parse_args() +Tensor = torch.cuda.DoubleTensor if torch.cuda.is_available else torch.DoubleTensor +device = torch.device(f"cuda:{opt.gpu_idx}") if torch.cuda.is_available else torch.device("cpu") + +N_per = 100 +N1 = opt.n +list_ohp = opt.ohps +ktype = opt.ktype +method = opt.method + +if isinstance(list_ohp, float) or isinstance(list_ohp, int): + list_ohp = [list_ohp] +else: + list_ohp = list(list_ohp) + +list_ohp = list_ohp + [None] # for median heuristic + +alpha = 0.05 +N = 100 +tot_N = 4000 + +def eye_like(G): + return torch.eye(*G.shape,out=torch.empty_like(G)) + +def get_rbf_G(khp=None, x=None, y=None, ridge=1e-10): + """ + # NOTE: if dist is not None, it should be cost matrix**2. + If it is None, the function automatically computes euclidean**2. + """ + if khp == None or khp == -1: # take median heuristic + khp = 0.5*torch.median(get_dist(x, y, p=1).view(-1)) + + dist = get_dist(x, y) + G = torch.exp(-dist/khp**2) + if G.shape[0] == G.shape[1]: + G = (G + G.T)/2 + G = G + ridge*eye_like(G) + return G + +def get_val(s1_t, s2_t, hp, G=None, indx=None, indy=None, call1=0): + # returns obj value for a given hp + ohp = hp["ohp"] + + if G is None: + data_cat = torch.vstack([s1_t, s2_t]) + G = get_rbf_G(khp=ohp, x=data_cat, y=data_cat) + indx = np.arange(s1_t.shape[0]) + indy = np.arange(s1_t.shape[0], data_cat.shape[0]) + + G1 = G[np.ix_(indx, indx)] + G2 = G[np.ix_(indy, indy)] + G12 = G[np.ix_(indx, indy)] + + a = torch.from_numpy(ot.unif(s1_t.shape[0])).to(device) + b = torch.from_numpy(ot.unif(s2_t.shape[0])).to(device) + + val = np.sqrt((a.dot(torch.mv(G1, a)) + b.dot(torch.mv(G2, b)) - 2*a.dot(torch.mv(G12, b))).item()) + if call1: + return val, G + return val + +def run_test(S_v, hp): + s1 = S_v[:N1, :] + s2 = S_v[N1:, :] + + orig_value, G = get_val(s1, s2, hp, call1=1) + perm_vals = [] + nxy = S_v.shape[0] + for r in range(N_per): + ind = np.random.choice(nxy, nxy, replace=False) + indx, indy = ind[:N1], ind[N1:] + + perm_vals.append(get_val(S_v[indx], S_v[indy], hp, G, indx, indy)) + + perm_vals = np.sort(perm_vals) + threshold = perm_vals[np.int32(np.ceil(N_per * (1 - alpha)))] + h = 1 if orig_value > threshold else 0 + return h, threshold, orig_value + +def validate(S_v, list_lda, list_ohp): + num_correct = {} # no. of correct by each hp + nor_margin = {} # the normalized margin by each hp + + best = {"lda": 1, "ohp": -1, "nc": None, "nm": None} # default lambda as 1, sigma for median heuristic + + for ohp in list_ohp: + # initializing + num_correct[ohp] = {} + nor_margin[ohp] = {} + for lda in list_lda: + num_correct[ohp][lda] = 0 + nor_margin[ohp][lda] = 0 + + for lda in list_lda: + hp = {"lda": lda, "ohp": ohp} + h, thr, val = run_test(S_v, hp) + + nor_margin[ohp][lda] += (val-thr)/(val + 1e-15) + + if h == 1: + num_correct[ohp][lda] += 1 + + # update best hp if ... + if (best["nc"] is None or best["nc"] < num_correct[ohp][lda]) or (best["nc"] == num_correct[ohp][lda] and best["nm"] < nor_margin[ohp][lda]): # (1st hp or this hp gets max correct) or (the nor_margin is max in case of a tie in num_correct) + best["lda"] = lda + best["ohp"] = ohp + best["nc"] = num_correct[ohp][lda] + best["nm"] = nor_margin[ohp][lda] + + best_hp = {"lda": best["lda"], "ohp": best["ohp"]} + return best_hp + +def get_hp(kk, method): + if method == "MMD": + return {"lda": -1, "ohp": -1} + +dataloader_FULL = DataLoader( + datasets.MNIST( + "./data/mnist", + train=True, + download=True, + transform=transforms.Compose( + [transforms.Resize(opt.img_size), transforms.ToTensor(), + transforms.Normalize([0.5], [0.5])] + ), + ), + batch_size=60000, + shuffle=True, +) + +for i, (imgs, Labels) in enumerate(dataloader_FULL): + data_all = imgs +data_all = data_all.to(device) + +Fake_MNIST = pickle.load(open('./Fake_MNIST_data_EP100_N10000.pckl', 'rb')) +ind_all = np.arange(tot_N) +ind_M_all = np.arange(tot_N) + +score_trial = [] +ntrials = opt.end_trial-opt.start_trial+1 + +print(f"Method: {method}. n: {opt.n}") + +for kk in range(opt.start_trial, opt.end_trial): + res = 0 + + torch.manual_seed(kk * 19 + N1) + torch.cuda.manual_seed(kk * 19 + N1) + np.random.seed(seed=seed2 * (kk + 9) + N1) + + # 1)--with the seeds for the trial, sample indices train-test + + # load real mnist data + ind_M_tr = np.random.choice(tot_N, N1, replace=False) + ind_M_te = np.delete(ind_M_all, ind_M_tr) + + # load fake mnist data + + ind_tr = np.random.choice(tot_N, N1, replace=False) + ind_te = np.delete(ind_all, ind_tr) + + # 2)--with the sampled indices for train-test, get train & test MNIST data + + Fake_MNIST_tr = torch.from_numpy(Fake_MNIST[0][ind_tr]).to(device) + Fake_MNIST_te = torch.from_numpy(Fake_MNIST[0][ind_te]).to(device) + + np.random.seed(seed=seed1) + torch.manual_seed(seed1) + torch.cuda.manual_seed(seed1) + + # 3)--The above seeds seem useless + + # Run 2-sample test on training set + # fetch training data + s1 = data_all[ind_M_tr] + s2 = Fake_MNIST_tr.type(Tensor) + S = torch.cat([s1, s2], dim=0) # NOTE: removed .cpu() + S_v = S.view(2*N1, -1) + + # best_hp = get_hp(kk, method) # uncomment this to directly get the validated hp + best_hp = validate(S_v, [-1], list_ohp) # TODO: comment this. + + # print(best_hp) + + np.random.seed(seed1) + for k in range(N): # NOTE: changed their seed + # 4)--With the seed for trial index, dataset index; sample test indices for both real, fake + np.random.seed(seed=seed1*(k+1) + 2*kk + N1) + ind_M = np.random.choice(len(ind_M_te), N1, replace=False) + s1 = data_all[ind_M_te[ind_M]] + + np.random.seed(seed=seed2*(k+3) + 2*kk + N1) + ind_F = np.random.choice(len(Fake_MNIST_te), N1, replace=False) + s2 = Fake_MNIST_te[ind_F].type(Tensor) + + S = torch.cat([s1, s2], dim=0) + S_v = S.view(2*N1, -1) + + h, thr, val = run_test(S_v, best_hp) + + res += h + score_trial.append(res) + print(f"--------n {opt.n}, trial {kk}, trial-score {score_trial[-1]}") +print({"n":opt.n, "mean across trials": np.sum(score_trial)/(ntrials*N)}) diff --git a/examples/two_sample_test/mmdot.py b/examples/two_sample_test/mmdot.py new file mode 100644 index 0000000..eb4ce1b --- /dev/null +++ b/examples/two_sample_test/mmdot.py @@ -0,0 +1,261 @@ +import argparse +import numpy as np +import os +import pickle +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader +from torchvision import datasets +import ot +from ot_mmd.mmdot import solve_apgd +from ot_mmd.utils import get_dist + +seed1 = 1102 +seed2 = 819 +np.random.seed(seed2) +torch.manual_seed(seed2) +torch.cuda.manual_seed(seed2) +torch.backends.cudnn.deterministic = True + +parser = argparse.ArgumentParser() +parser.add_argument("--ldas", nargs="+", type=float, default=100) +parser.add_argument("--ohps", nargs="+", type=float, default=-1.0) +parser.add_argument('--case', type=str, default='unb') +parser.add_argument('--max_iter', type=int, default=100) +parser.add_argument('--ktype', type=str, default='rbf') +parser.add_argument('--method', type=str, default='mmdot') +parser.add_argument('--only_validation', type=int, default=0) +parser.add_argument('--crit', default=None) +parser.add_argument('--log_msg', default="") +parser.add_argument('--p', type=int) + +parser.add_argument("--batch_size", type=int, default=100, help="size of the batches") +parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension") +parser.add_argument("--channels", type=int, default=1, help="number of image channels") +parser.add_argument("--n", type=int, default=100, help="number of samples in one set") +parser.add_argument('--start_trial', type=int, default=0) +parser.add_argument('--end_trial', type=int, default=10) +parser.add_argument('--gpu_idx', type=int, default=0) + +opt = parser.parse_args() +Tensor = torch.cuda.DoubleTensor if torch.cuda.is_available else torch.DoubleTensor +device = torch.device(f"cuda:{opt.gpu_idx}") if torch.cuda.is_available else torch.device("cpu") + +N_per = 100 +N1 = opt.n +list_lda = opt.ldas +list_ohp = opt.ohps +only_validation = opt.only_validation +ktype = opt.ktype +case = opt.case +max_iter = opt.max_iter +method = opt.method +crit = opt.crit + + +if isinstance(list_lda, float) or isinstance(list_lda, int): + list_lda = [list_lda] +else: + list_lda = list(list_lda) + +if isinstance(list_ohp, float) or isinstance(list_ohp, int): + list_ohp = [list_ohp] +else: + list_ohp = list(list_ohp) + +list_ohp = list_ohp + [None] # for median heuristic + +alpha = 0.05 +N = 100 +tot_N = 4000 + +def eye_like(G): + return torch.eye(*G.shape,out=torch.empty_like(G)) + +def get_rbf_G(khp=None, x=None, y=None, ridge=1e-10): + """ + # NOTE: if dist is not None, it should be cost matrix**2. + If it is None, the function automatically computes euclidean**2. + """ + if khp == None or khp == -1: # take median heuristic + khp = 0.5*torch.median(get_dist(x, y, p=1).view(-1)) + + dist = get_dist(x, y) + G = torch.exp(-dist/khp**2) + if G.shape[0] == G.shape[1]: + G = (G + G.T)/2 + G = G + ridge*eye_like(G) + return G + +def get_val(s1_t, s2_t, hp, G=None, C=None, indx=None, indy=None, call1=0, p=1): + # returns obj value for a given hp + lda = hp["lda"] + ohp = hp["ohp"] + + if G is None: + data_cat = torch.vstack([s1_t, s2_t]) + G = get_rbf_G(khp=ohp, x=data_cat, y=data_cat) + indx = np.arange(s1_t.shape[0]) + indy = np.arange(s1_t.shape[0], data_cat.shape[0]) + C = get_dist(data_cat, data_cat, p=p) + C = C/C.max() + + G1 = G[np.ix_(indx, indx)] + G2 = G[np.ix_(indy, indy)] + + C_per = C[np.ix_(indx, indy)] + + a = torch.from_numpy(ot.unif(s1_t.shape[0])).to(device) + b = torch.from_numpy(ot.unif(s2_t.shape[0])).to(device) + v = {1: a, 2: b} + + _, obj_itr = solve_apgd(C_per, {1: G1, 2: G2}, v, max_iter, lda, crit=crit, tol=1e-6) + + val = obj_itr[-1].item() + if call1: + return val, G, C + return val + +def run_test(S_v, hp, p=opt.p): + s1 = S_v[:N1, :] + s2 = S_v[N1:, :] + + orig_value, G, C = get_val(s1, s2, hp, call1=1, p=p) + perm_vals = [] + nxy = S_v.shape[0] + for r in range(N_per): + ind = np.random.choice(nxy, nxy, replace=False) + indx, indy = ind[:N1], ind[N1:] + + perm_vals.append(get_val(S_v[indx], S_v[indy], hp, G, C, indx, indy, p=p)) + + perm_vals = np.sort(perm_vals) + threshold = perm_vals[np.int32(np.ceil(N_per * (1 - alpha)))] + h = 1 if orig_value > threshold else 0 + return h, threshold, orig_value + + +def get_hp(kk, method): + if method == "mmdot": + if kk == opt.end_trial-1: + return {"lda": 0.1, "ohp": 60} + return {"lda": 1, "ohp": -1} + +def validate(S_v, list_lda, list_ohp): + num_correct = {} # no. of correct by each hp + nor_margin = {} # the normalized margin by each hp + + best = {"lda": 1, "ohp": -1, "nc": None, "nm": None} # default lambda as 1, sigma for median heuristic + + for ohp in list_ohp: + # initializing + num_correct[ohp] = {} + nor_margin[ohp] = {} + for lda in list_lda: + num_correct[ohp][lda] = 0 + nor_margin[ohp][lda] = 0 + + for lda in list_lda: + hp = {"lda": lda, "ohp": ohp} + h, thr, val = run_test(S_v, hp) + + nor_margin[ohp][lda] += (val-thr)/(val + 1e-15) + + if h == 1: + num_correct[ohp][lda] += 1 + + # update best hp if ... + if (best["nc"] is None or best["nc"] < num_correct[ohp][lda]) or (best["nc"] == num_correct[ohp][lda] and best["nm"] < nor_margin[ohp][lda]): # (1st hp or this hp gets max correct) or (the nor_margin is max in case of a tie in num_correct) + best["lda"] = lda + best["ohp"] = ohp + best["nc"] = num_correct[ohp][lda] + best["nm"] = nor_margin[ohp][lda] + + best_hp = {"lda": best["lda"], "ohp": best["ohp"]} + return best_hp + +dataloader_FULL = DataLoader( + datasets.MNIST( + "./data/mnist", + train=True, + download=True, + transform=transforms.Compose( + [transforms.Resize(opt.img_size), transforms.ToTensor(), + transforms.Normalize([0.5], [0.5])] + ), + ), + batch_size=60000, + shuffle=True, +) + +for i, (imgs, Labels) in enumerate(dataloader_FULL): + data_all = imgs +data_all = data_all.to(device) + +Fake_MNIST = pickle.load(open('./Fake_MNIST_data_EP100_N10000.pckl', 'rb')) +ind_all = np.arange(tot_N) +ind_M_all = np.arange(tot_N) + +score_trial = [] +ntrials = opt.end_trial-opt.start_trial+1 + +print(f"Method: {method}. n: {opt.n}") + +for kk in range(opt.start_trial, opt.end_trial): + res = 0 + + torch.manual_seed(kk * 19 + N1) + torch.cuda.manual_seed(kk * 19 + N1) + np.random.seed(seed=seed2 * (kk + 9) + N1) + + # 1)--with the seeds for the trial, sample indices train-test + + # load real mnist data + ind_M_tr = np.random.choice(tot_N, N1, replace=False) + ind_M_te = np.delete(ind_M_all, ind_M_tr) + + # load fake mnist data + + ind_tr = np.random.choice(tot_N, N1, replace=False) + ind_te = np.delete(ind_all, ind_tr) + + # 2)--with the sampled indices for train-test, get train & test MNIST data + + Fake_MNIST_tr = torch.from_numpy(Fake_MNIST[0][ind_tr]).to(device) + Fake_MNIST_te = torch.from_numpy(Fake_MNIST[0][ind_te]).to(device) + + np.random.seed(seed=seed1) + torch.manual_seed(seed1) + torch.cuda.manual_seed(seed1) + + # 3)--The above seeds seem useless + + # Run 2-sample test on training set + # fetch training data + s1 = data_all[ind_M_tr] + s2 = Fake_MNIST_tr.type(Tensor) + S = torch.cat([s1, s2], dim=0) # NOTE: removed .cpu() + S_v = S.view(2*N1, -1) + + best_hp = {"lda": 1, "ohp": -1} # validate(S_v, list_lda, list_ohp) + + np.random.seed(seed1) + for k in range(N): # NOTE: changed their seed + # 4)--With the seed for trial index, dataset index; sample test indices for both real, fake + np.random.seed(seed=seed1*(k+1) + 2*kk + N1) + ind_M = np.random.choice(len(ind_M_te), N1, replace=False) + s1 = data_all[ind_M_te[ind_M]] + + np.random.seed(seed=seed2*(k+3) + 2*kk + N1) + ind_F = np.random.choice(len(Fake_MNIST_te), N1, replace=False) + s2 = Fake_MNIST_te[ind_F].type(Tensor) + + S = torch.cat([s1, s2], dim=0) + S_v = S.view(2*N1, -1) + + h, thr, val = run_test(S_v, best_hp) + + res += h + score_trial.append(res) + print(f"--------n {opt.n}, trial {kk}, trial-score {score_trial[-1]}") +print({"n":opt.n, "mean across trials": np.sum(score_trial)/(ntrials*N)}) diff --git a/examples/two_sample_test/run_emd.sh b/examples/two_sample_test/run_emd.sh new file mode 100755 index 0000000..620bc8d --- /dev/null +++ b/examples/two_sample_test/run_emd.sh @@ -0,0 +1,6 @@ +GPU_IDX=$1 + +for n in 40 60 80 100 200 300 400 500 1000 +do +python emd.py --n ${n} --gpu_idx ${GPU_IDX} >> emd.txt +done diff --git a/examples/two_sample_test/run_kl.sh b/examples/two_sample_test/run_kl.sh new file mode 100755 index 0000000..c254359 --- /dev/null +++ b/examples/two_sample_test/run_kl.sh @@ -0,0 +1,6 @@ +GPU_IDX=$1 + +for n in 20 40 60 80 100 200 300 400 500 1000 +do +python kl.py --n ${n} > "kl_${n}.txt" --gpu_idx ${GPU_IDX} >> klot.txt +done diff --git a/examples/two_sample_test/run_mmd.sh b/examples/two_sample_test/run_mmd.sh new file mode 100755 index 0000000..6b286a1 --- /dev/null +++ b/examples/two_sample_test/run_mmd.sh @@ -0,0 +1,6 @@ +GPU_IDX=$1 + +for n in 40 60 80 100 200 300 400 500 1000 +do +python mmd.py --n ${n} --gpu_idx ${GPU_IDX} >> mmd.txt +done diff --git a/examples/two_sample_test/run_mmdot.sh b/examples/two_sample_test/run_mmdot.sh new file mode 100755 index 0000000..2a81aa6 --- /dev/null +++ b/examples/two_sample_test/run_mmdot.sh @@ -0,0 +1,6 @@ +GPU_IDX=$1 + +for n in 40 60 80 100 200 300 400 500 1000 +do +python mmdot.py --max_iter 100 --ktype rbf --case unb --n ${n} --p 2 --gpu_idx ${GPU_IDX} >> mmdot.txt +done diff --git a/examples/two_sample_test/run_w2.sh b/examples/two_sample_test/run_w2.sh new file mode 100755 index 0000000..d3ddbea --- /dev/null +++ b/examples/two_sample_test/run_w2.sh @@ -0,0 +1,6 @@ +GPU_IDX=$1 + +for n in 40 60 80 100 200 300 400 500 1000 +do +python w2.py --n ${n} --gpu_idx ${GPU_IDX} >> w2.txt +done diff --git a/examples/two_sample_test/w2.py b/examples/two_sample_test/w2.py new file mode 100644 index 0000000..3acda55 --- /dev/null +++ b/examples/two_sample_test/w2.py @@ -0,0 +1,154 @@ +import argparse +import numpy as np +import pickle +import torch +import torchvision.transforms as transforms +from torch.utils.data import DataLoader +from torchvision import datasets +import ot +from ot_mmd.utils import get_dist + +seed1 = 1102 +seed2 = 819 +np.random.seed(seed2) +torch.manual_seed(seed2) +torch.cuda.manual_seed(seed2) +torch.backends.cudnn.deterministic = True + +parser = argparse.ArgumentParser() +parser.add_argument('--method', type=str, default='w2') + +parser.add_argument("--batch_size", type=int, default=100, help="size of the batches") +parser.add_argument("--img_size", type=int, default=32, help="size of each image dimension") +parser.add_argument("--channels", type=int, default=1, help="number of image channels") +parser.add_argument("--n", type=int, default=100, help="number of samples in one set") +parser.add_argument('--start_trial', type=int, default=0) +parser.add_argument('--end_trial', type=int, default=10) +parser.add_argument('--gpu_idx', type=int, default=0) + +opt = parser.parse_args() +dtype = torch.cuda.DoubleTensor if torch.cuda.is_available else torch.DoubleTensor +device = torch.device(f"cuda:{opt.gpu_idx}") if torch.cuda.is_available else torch.device("cpu") + +N_per = 100 + +N1 = opt.n +method = opt.method + + +alpha = 0.05 +N = 100 +tot_N = 4000 + + +def run_test(S_v): + s1 = S_v[:N1, :] + s2 = S_v[N1:, :] + + s_all = torch.vstack([s1, s2]) + C_all = get_dist(s_all, s_all) + + C = C_all[:s1.shape[0], s1.shape[0]:] + C = C/C.max() + + mu, nu = torch.from_numpy(ot.unif(s1.shape[0])).to(device), torch.from_numpy(ot.unif(s2.shape[0])).to(device) + orig_value = np.sqrt(ot.emd2(mu, nu, C).item()) + perm_vals = [] + nxy = S_v.shape[0] + for r in range(N_per): + ind = np.random.choice(nxy, nxy, replace=False) + indx, indy = ind[:N1], ind[N1:] + + C_per = C_all[np.ix_(indx, indy)] + C_per = C_per/C_per.max() + perm_vals.append(np.sqrt(ot.emd2(mu, nu, C_per).item())) + + perm_vals = np.sort(perm_vals) + threshold = perm_vals[np.int32(np.ceil(N_per * (1 - alpha)))] + h = 1 if orig_value > threshold else 0 + return h, threshold, orig_value + + +dataloader_FULL = DataLoader( + datasets.MNIST( + "./data/mnist", + train=True, + download=True, + transform=transforms.Compose( + [transforms.Resize(opt.img_size), transforms.ToTensor(), + transforms.Normalize([0.5], [0.5])] + ), + ), + batch_size=60000, + shuffle=True, +) + +for i, (imgs, Labels) in enumerate(dataloader_FULL): + data_all = imgs +data_all = data_all.to(device) + +Fake_MNIST = pickle.load(open('./Fake_MNIST_data_EP100_N10000.pckl', 'rb')) +ind_all = np.arange(tot_N) +ind_M_all = np.arange(tot_N) + +score_trial = [] +ntrials = opt.end_trial-opt.start_trial+1 + +print(f"Method: {method}. n: {opt.n}") + +for kk in range(opt.start_trial, opt.end_trial): + res = 0 + + torch.manual_seed(kk * 19 + N1) + torch.cuda.manual_seed(kk * 19 + N1) + np.random.seed(seed=seed2 * (kk + 9) + N1) + + # 1)--with the seeds for the trial, sample indices train-test + + # load real mnist data + ind_M_tr = np.random.choice(tot_N, N1, replace=False) + ind_M_te = np.delete(ind_M_all, ind_M_tr) + + # load fake mnist data + + ind_tr = np.random.choice(tot_N, N1, replace=False) + ind_te = np.delete(ind_all, ind_tr) + + # 2)--with the sampled indices for train-test, get train & test MNIST data + + Fake_MNIST_tr = torch.from_numpy(Fake_MNIST[0][ind_tr]).to(device) + Fake_MNIST_te = torch.from_numpy(Fake_MNIST[0][ind_te]).to(device) + + np.random.seed(seed=seed1) + torch.manual_seed(seed1) + torch.cuda.manual_seed(seed1) + + # 3)--The above seeds seem useless + + # Run 2-sample test on training set + # fetch training data + s1 = data_all[ind_M_tr] + s2 = Fake_MNIST_tr.type(dtype) + S = torch.cat([s1, s2], dim=0) # NOTE: removed .cpu() + S_v = S.view(2*N1, -1) + + np.random.seed(seed1) + for k in range(N): # NOTE: changed their seed + # 4)--With the seed for trial index, dataset index; sample test indices for both real, fake + np.random.seed(seed=seed1*(k+1) + 2*kk + N1) + ind_M = np.random.choice(len(ind_M_te), N1, replace=False) + s1 = data_all[ind_M_te[ind_M]] + + np.random.seed(seed=seed2*(k+3) + 2*kk + N1) + ind_F = np.random.choice(len(Fake_MNIST_te), N1, replace=False) + s2 = Fake_MNIST_te[ind_F].type(dtype) + + S = torch.cat([s1, s2], dim=0) + S_v = S.view(2*N1, -1) + + h, thr, val = run_test(S_v) + + res += h + score_trial.append(res) + print(f"--------n {opt.n}, trial {kk}, trial-score {score_trial[-1]}") +print({"n":opt.n, "mean across trials": np.sum(score_trial)/(ntrials*N)}) diff --git a/ot_mmd/b_mmdot.py b/ot_mmd/b_mmdot.py new file mode 100644 index 0000000..67477d3 --- /dev/null +++ b/ot_mmd/b_mmdot.py @@ -0,0 +1,58 @@ +import torch +from torch import sqrt +from torch.linalg import norm +from ot_mmd.utils import get_marginals, get_mmdsq_reg, proj_simplex +import numpy as np + + +def get_obj(C, G, lda, v, alpha, same_supp=1): + alpha1, alphaT1 = get_marginals(alpha) + reg_1, reg_2 = get_mmdsq_reg(alpha1, alphaT1, v, G, same_supp) + E_c = torch.sum(alpha * C, dim=(1, 2)) + obj = E_c + lda*(reg_1 + reg_2) + return obj + +def get_grd(C, G, lda, v, alpha, same_supp): + alpha1, alphaT1 = get_marginals(alpha) + if same_supp: + grd_1 = torch.matmul(G[1], (alpha1-v[1]).unsqueeze(-1)) + grd_2 = torch.matmul(G[2], (alphaT1-v[2]).unsqueeze(-1)).permute(0, 2, 1) + else: + raise NotImplementedError + grd = C + 2*lda*(grd_1 + grd_2) + return grd + +def solve_apgd(C, G, v, max_itr, lda, crit=None, tol=None, same_supp=1, case="unb", verbose=0): + if crit is not None: + assert NotImplementedError # TODO: + b = C.shape[0] + m, n = C[0].shape + + y = torch.ones_like(C)/(m*n) + x_old = y + + t = 1 + G1_sqnorms = torch.norm(G[1], dim=(1, 2))**2 + G1_sums = torch.sum(G[1], dim=(1, 2)) + + G2_sqnorms = torch.norm(G[2], dim=(1, 2))**2 + G2_sums = torch.sum(G[2], dim=(1, 2)) + + ss = 1/(2*lda*(sqrt(n**2*G1_sqnorms + m**2*G2_sqnorms + 2*(G2_sums*G1_sums)))) + + ss = ss.unsqueeze(-1).unsqueeze(-1) + obj_init = get_obj(C, G, lda, v, y, same_supp) + + for itr in range(max_itr): + grd = get_grd(C, G, lda, v, y, same_supp) + if case =="unb": + x_i = torch.clamp(y-ss*grd, min=0) + else: + x_i = proj_simplex(y-ss*grd) + t_new = (1+np.sqrt(1+4*t**2))/2 + y = x_i + (t-1)*(x_i-x_old)/t_new + x_old = x_i.clone() + t = t_new + obj_final = get_obj(C, G, lda, v, x_i, same_supp) + assert torch.all(obj_init > obj_final), "No optimization! Obj_final={} Obj_initial={}".format(obj_final, obj_init) + return x_i diff --git a/ot_mmd/barycenter.py b/ot_mmd/barycenter.py new file mode 100644 index 0000000..a138e87 --- /dev/null +++ b/ot_mmd/barycenter.py @@ -0,0 +1,123 @@ +import torch +from torch import sqrt +from torch.linalg import norm +from ot_mmd.utils import test_conv, get_nrm_rgrad, get_marginals, get_mmdsq_reg, proj_simplex +import numpy as np + + +def get_obj(C, G, lda, v, alpha, rho): + cost_part = rho[1]*torch.tensordot(C[1], alpha[1]) + rho[2]*torch.tensordot(C[2], alpha[2]) + + alpha1_1, alpha1_T1 = get_marginals(alpha[1]) + alpha2_1, alpha2_T1 = get_marginals(alpha[2]) + + avg_alphaT1 = rho[1]*alpha1_T1+rho[2]*alpha2_T1 + + reg1_1, reg1_2 = get_mmdsq_reg(alpha1_1, alpha1_T1, {1: v[1], 2: avg_alphaT1}, {1: G[1], 2: G['all']}, same_supp=1) + reg2_1, reg2_2 = get_mmdsq_reg(alpha2_1, alpha2_T1, {1: v[2], 2: avg_alphaT1}, {1: G[2], 2: G['all']}, same_supp=1) + + lda1_part = rho[1]*reg1_1 + rho[2]*reg2_1 + lda2_part = rho[1]*reg1_2 + rho[2]*reg2_2 + + obj = cost_part + lda[1]*lda1_part + lda[2]*lda2_part + return obj + +def get_grd(C, G, lda, v, alpha, rho): + # returns gradients wrt the two alpha variables. + alpha1_1, alpha1_T1 = get_marginals(alpha[1]) + alpha2_1, alpha2_T1 = get_marginals(alpha[2]) + + avg_alphaT1 = rho[1]*alpha1_T1+rho[2]*alpha2_T1 + + grd_1 = 0 + if rho[1]>0: + grd_1 = rho[1]*C[1] + 2*lda[1]*rho[1]*torch.mv(G[1], alpha1_1-v[1])[:, None] + \ + 2*lda[2]*rho[1]*(1-rho[1])*torch.mv(G['all'], alpha1_T1-avg_alphaT1) + \ + 2*lda[2]*rho[2]*(-rho[1])*torch.mv(G['all'], alpha2_T1-avg_alphaT1) + + grd_2 = 0 + if rho[2]>0: + grd_2 = rho[2]*C[2] + 2*lda[1]*rho[2]*torch.mv(G[2], alpha2_1-v[2])[:, None] + \ + 2*lda[2]*rho[2]*(1-rho[2])*torch.mv(G['all'], alpha2_T1-avg_alphaT1) + \ + 2*lda[2]*rho[1]*(-rho[2])*torch.mv(G['all'], alpha1_T1-avg_alphaT1) + + return grd_1, grd_2 + + +def solve_apgd(C, G, v, max_itr, lda, rho={1: 0.5, 2: 0.5}, crit=None, tol=1e-3, case="bal", verbose=0): + """ + Args: + a : source distribution. + b : target distribution. + C : dictionary of cost matrices such that C[1] is over source samples & union of source & target samples. + C[2] is over target samples & union of source & target samples. + G : dictionary of Gram matrices such that G[1] is over source-source samples. + G[2] is over target-target samples. + G['all'] is over the union of samples. + lda : dictionary such that lda[1], lda[2] are regularization coefficients. + rho : dictionary such that rho[1], rho[2] are the coefficients. + crit (str, optional): stopping criteria. + tol (_float_, optional): threshold for riemannian gradient based stopping criteria. + case (str, optional): balanced or unbalanced measure. + verbose (boolean, optional): whether to display convergence information. + + Returns: + barycenter distribution supported over the union of source & target samples. + """ + m1, m2 = C[1].shape[0], C[2].shape[0] + m = m1+m2 + y = {1: torch.ones_like(C[1])/(m1*m), 2: torch.ones_like(C[2])/(m2*m)} + x_old = y + + t = 1 + eta_1 = lda[2]*(1-rho[1]) + eta_2 = lda[2]*(1-rho[2]) + ss = {1: 1/(2*rho[1]*(sqrt((lda[1]*m)**2*norm(G[1])**2 + (eta_1*m1)**2 + * norm(G['all'])**2 + 2*lda[1]*eta_1*(G[1].sum()* + G['all'].sum())))) if rho[1] else 0, + \ + 2: 1/(2*rho[2]*(sqrt((lda[1]*m)**2*norm(G[2])**2 + (eta_2*m2)**2 + * norm(G['all'])**2 + 2*lda[1]*eta_2*(G[2].sum()* + G['all'].sum())))) if rho[2] else 0} + + obj_itr = [] + obj_init = get_obj(C, G, lda, v, y, rho) + opt1 = opt2 = max_itr + for itr in range(max_itr): + # update + grd1, grd2 = get_grd(C, G, lda, v, y, rho) + if not itr: + x_i = {1: torch.clamp(y[1]-ss[1]*grd1, min=0) if case == "unb" else proj_simplex(y[1]-ss[1]*grd1), + 2: torch.clamp(y[2]-ss[2]*grd2, min=0) if case == "unb" else proj_simplex(y[2]-ss[2]*grd2)} + else: + if opt1 == max_itr: + x_i[1] = torch.clamp(y[1]-ss[1]*grd1, min=0) if case == "unb" else proj_simplex(y[1]-ss[1]*grd1) + if opt2 == max_itr: + x_i[2] = torch.clamp(y[2]-ss[2]*grd2, min=0) if case == "unb" else proj_simplex(y[2]-ss[2]*grd2) + + obj_itr.append(get_obj(C, G, lda, v, x_i, rho)) + # check for convergence + if crit == "obj" and itr>1 and test_conv(obj_itr, tol): + break + elif crit == "rgrad": + grd1_xi, grd2_xi = get_grd(C, G, lda, v, x_i, rho) + if get_nrm_rgrad(x_i[1], grd1_xi) < tol: + opt1 = itr + if get_nrm_rgrad(x_i[2], grd2_xi) < tol: + opt2 = itr + # update intermediate variables + t_new = (1+np.sqrt(1+4*t**2))/2 + y = {1: x_i[1] + (t-1)*(x_i[1]-x_old[1])/t_new, + 2: x_i[2] + (t-1)*(x_i[2]-x_old[2])/t_new} + x_old = {1: x_i[1].clone(), 2: x_i[2].clone()} + t = t_new + if verbose: + if opt1 < max_itr: + print(f"Convergence for alpha1 in {opt1+1} iterations.") + if opt2 < max_itr: + print(f"Convergence for alpha2 in {opt2+1} iterations.") + obj_final = obj_itr[-1] if crit == "obj" else get_obj(C, G, lda, v, x_i, rho) + assert obj_final < obj_init, "No optimization! Obj_final={} Obj_initial={}".format(obj_final, obj_init) + + bary = rho[1]*x_i[1].sum(axis=0) + rho[2]*x_i[2].sum(axis=0) + return bary, obj_itr diff --git a/ot_mmd/mmdot.py b/ot_mmd/mmdot.py new file mode 100644 index 0000000..e1938cb --- /dev/null +++ b/ot_mmd/mmdot.py @@ -0,0 +1,87 @@ +import torch +from torch import sqrt +from torch.linalg import norm +from ot_mmd.utils import test_conv, get_nrm_rgrad, get_marginals, get_mmdsq_reg, proj_simplex +import numpy as np + + +def get_obj(C, G, lda, v, alpha, same_supp=1): + alpha1, alphaT1 = get_marginals(alpha) + reg_1, reg_2 = get_mmdsq_reg(alpha1, alphaT1, v, G, same_supp) + E_c = torch.tensordot(alpha, C) + obj = E_c + lda*(reg_1+reg_2) + return obj + + +def get_grd(C, G, lda, v, alpha, same_supp=1): + alpha1, alphaT1 = get_marginals(alpha) + if same_supp: + grd_1 = torch.matmul(G[1], alpha1-v[1])[:, None] + grd_2 = torch.matmul(G[2], alphaT1-v[2]) + else: + m = v[1].shape[0] + G_r, G_l = G[:, m:], G[:, :m] + grd_1 = (torch.matmul(G, alpha1) - torch.matmul(G_l, v[1]))[:, None] + grd_2 = torch.matmul(G, alphaT1) - torch.matmul(G_r, v[2]) + grd = C+2*lda*(grd_1+grd_2) + return grd + + +def solve_apgd(C, G, v, max_itr, lda, crit=None, tol=1e-3, same_supp=1, case="bal", verbose=0): + """solve via accelerated projected gd + + Args: + C (_array_like_): cost matrix between source and target. + G (_array_like_): Gram matrix with samples from source. + v (_vector_): source distribution over samples. + max_itr (_int_): for APGD. + lda (_float_): lambda regularization hyperparameter. + crit (str, optional): stopping criteria. + tol (_float_, optional): threshold for riemannian gradient based stopping criteria. + same_supp (int, optional): If supports match or not. Defaults to 1. + case (str, optional): balanced or unbalanced measure. + verbose (boolean, optional): whether to display convergence information. + + Returns: + x_i (FloatTensor): OT plan + obj_itr (list): objective over iterations, returned if verbose is 1. + """ + if case == "unb": + assert crit != "rgrad", "Not yet implemented Riemmanian gradient based criteria for unbalanced" + + m, n = C.shape + y = torch.ones_like(C)/(m*n) + x_old = y + + t = 1 + ss = 1/(2*lda*(sqrt(n**2*norm(G[1])**2 + m**2 + * norm(G[2])**2 + 2*(G[1].sum()* + G[2].sum())))) + obj_itr = [] + obj_init = get_obj(C, G, lda, v, y, same_supp) + + for itr in range(max_itr): + # update + grd = get_grd(C, G, lda, v, y, same_supp) + if case =="unb": + x_i = torch.clamp(y-ss*grd, min=0) + else: + x_i = proj_simplex(y-ss*grd) + obj_itr.append(get_obj(C, G, lda, v, x_i, same_supp)) + # check for convergence + if crit == "obj" and itr>1 and test_conv(obj_itr, tol): + break + elif crit == "rgrad": # based on the norm of Riemannian gradient + grd_xi = get_grd(C, G, lda, v, x_i, same_supp) + if get_nrm_rgrad(x_i, grd_xi) < tol: + break + # update intermediate variables + t_new = (1+np.sqrt(1+4*t**2))/2 + y = x_i + (t-1)*(x_i-x_old)/t_new + x_old = x_i.clone() + t = t_new + if verbose and itr < max_itr-1: + print(f"Converged in {itr+1} iterations.") + obj_final = obj_itr[-1] if crit == "obj" else get_obj(C, G, lda, v, x_i, same_supp) + assert obj_final < obj_init, "No optimization! Obj_final={} Obj_initial={}".format(obj_final, obj_init) + return x_i, obj_itr diff --git a/ot_mmd/utils.py b/ot_mmd/utils.py new file mode 100644 index 0000000..7e16bda --- /dev/null +++ b/ot_mmd/utils.py @@ -0,0 +1,194 @@ +import logging, ot, torch +import numpy as np +from sklearn import preprocessing +from ot.utils import proj_simplex as pot_proj_simplex + + +def set_seed(env, SEED=0): + if SEED is None: + return + import random + torch.manual_seed(SEED) + torch.cuda.manual_seed(SEED) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + np.random.seed(SEED) + random.seed(SEED) + + +def get_t(arr, normalize=0, device=torch.device("cuda"), dtype=torch.float64, norm='l1'): + if normalize: + if len(arr.shape) > 2: + b = arr.shape[0] + for i in range(b): + arr.append(preprocessing.normalize(arr[i], norm=norm)) + return torch.Tensor(arr, device=device, dtype=dtype) + arr = preprocessing.normalize(arr, norm=norm) + return torch.from_numpy(arr).to(dtype).to(device) + + +def test_conv(obj_itr, tol=1e-3): + cur_obj = obj_itr[-1] + prv_obj = obj_itr[-2] + rel_dec = abs(prv_obj-cur_obj)/(abs(prv_obj)+1e-10) + if rel_dec < tol: + return 1 + return 0 + + +def createLogHandler(log_file, job_name="_"): + logger = logging.getLogger(job_name) + logger.setLevel(logging.INFO) + + handler = logging.FileHandler(log_file, mode='a') + handler.setLevel(logging.INFO) + + formatter = logging.Formatter("%(asctime)s; , %(message)s", "%Y-%m-%d %H:%M:%S") + handler.setFormatter(formatter) + logger.addHandler(handler) + return logger + + +def get_nrm_rgrad(x, grd): + xegrad = x*grd + lda = -torch.sum(xegrad, dim=[-1, -2]) + if x.dim() == 3: + lda = lda.unsqueeze(-1).unsqueeze(-1) + rgrad = xegrad + lda*x + nrm_rgrad = torch.sum(torch.nan_to_num(rgrad**2/x), dim=[-1, -2]) + return nrm_rgrad + + +def sq_mnorm(vec, G): + if G.dim() == 2: + return torch.dot(torch.matmul(G, vec), vec) + + vec = vec.unsqueeze(-1) + Gv = torch.matmul(G, vec) + return torch.einsum("bmo,bmo->b", Gv, vec) + + +def get_marginals(b_alpha): + b_alpha1 = torch.sum(b_alpha, axis=-1) + b_alphaT1 = torch.sum(b_alpha, axis=-2) + return b_alpha1, b_alphaT1 + + +def get_mmdsq_reg(alpha1, alphaT1, v, G, same_supp): + if same_supp: + reg_1 = sq_mnorm(alpha1-v[1], G[1]) + reg_2 = sq_mnorm(alphaT1-v[2], G[2]) + else: + if G.dim() == 3: # TODO: vectorized version for this. + raise NotImplemented + m = v[1].shape[0] + G1 = G[:m, :m] + G_1 = G[:, :m] + G2 = G[m:, m:] + G_2 = G[:, m:] + reg_1 = sq_mnorm(alpha1, G) + sq_mnorm(v[1], G1) - 2*alpha1.dot(torch.mv(G_1, v[1])) + reg_2 = sq_mnorm(alphaT1, G) + sq_mnorm(v[2], G2) - 2*alphaT1.dot(torch.mv(G_2, v[2])) + return reg_1, reg_2 + + +def eye_like(G): + if(len(G.shape) == 3): + return torch.eye(*G.shape[-2:], out=torch.empty_like(G)).repeat(G.shape[0], 1, 1) + else: + return torch.eye(*G.shape,out=torch.empty_like(G)) + + +def get_dist(x, y, p=2, dtype="euc", khp=None): + x = x.unsqueeze(1) if x.dim() == 1 else x + y = y.unsqueeze(1) if y.dim() == 1 else y + + C = torch.cdist(x, y) + + if p == 2 or "ker" in dtype: + C = C**2 + if "rbf" in dtype: + C = 2-2*get_G(dist=C, ktype="rbf", khp=khp, x=x, y=y) + if "imq" in dtype: + C = 2/khp**(0.5)-2*get_G(dist=C, ktype="imq", khp=khp, x=x, y=y) + if "ker" in dtype and p == 1: + C = C**(0.5) + return C + + +def get_G(dist=None, ktype="rbf", khp=None, x=None, y=None, ridge=1e-10): + """ + # NOTE: if dist is not None, it should be cost matrix**2. + If it is None, the function automatically computes euclidean**2. + """ + if ktype in ["rbf", "imq", "imq_v2"]: + if khp == None or khp == -1: # take median heuristic + khp = 0.5*torch.median(get_dist(x, y).view(-1)) + if dist is None: + dist = get_dist(x, y) + if ktype == "lin": + if x.dim() == 2: + G = torch.einsum('md,nd->mn', x, y) + else: + G = torch.einsum('bmd,nd->bmn', x, y) + elif ktype == "rbf": + G = torch.exp(-dist/(2*khp)) + elif ktype == "imq": + G = (khp + dist)**(-0.5) + elif ktype == "imq_v2": + G = ((1+dist)/khp)**(-0.5) + + if(len(G.shape)==2): + if G.shape[0] == G.shape[1]: + G = (G + G.T)/2 + elif(G.shape[1] == G.shape[2]): + G = (G + G.permute(0, 2, 1))/2 + G = G + ridge*eye_like(G) + return G + +def get_cost_G(x, y, khp, ktype, p=2): + # None means taking median-heuristic + C = get_dist(x, y, p) + C = C/C.max() + + G1 = get_G(x=x, y=x, khp=khp, ktype=ktype) + G2 = get_G(x=y, y=y, khp=khp, ktype=ktype) + G = {1: G1, 2: G2} + return C, G + +def proj_simplex(v): + # TODO: vectorize algo for proj_simplex. + if v.dim() == 3: + b = v.shape[0] + proj_vs = [] + for i in range(b): + shape = v[i].shape + proj_vs.extend(pot_proj_simplex(v[i].view(-1, 1)).view(shape)) + return proj_vs + shape = v.shape + return pot_proj_simplex(v.view(-1, 1)).view(shape) + +def get_genw_tv(case, v, C, lda): + def get_A(m1, m2): + ix1 = np.arange(m1*m2) + a1 = np.zeros((m1, m1*m2)) + for i in range(m1): + a1[i, ix1[m2*i:m2*(i+1)]] = 1 # for sum(axis = 1) + a2 = np.zeros((m2, m1*m2)) + for i in range(m2): + a2[i, ix1[i:m1*m2+1:m2]] = 1 # for sum(axis = 0) + A = np.vstack([a1, a2]) + return A + from scipy.optimize import linprog + m1 = v[1].shape[0] + m2 = v[2].shape[0] + + A_ub = get_A(m1, m2) + if case == "bal": + bounds = (0, 1) + else: + bounds = (0, None) + b_ub = np.hstack([v[1], v[2]]) + cost = C.reshape(-1)-2*lda*np.ones(m1*m2) + res = linprog(c = cost, A_ub=A_ub, b_ub = b_ub, bounds = bounds) + assert (not res.status) and (res.success) + return res diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..ee564fa --- /dev/null +++ b/requirements.txt @@ -0,0 +1,11 @@ +cvxpy==1.2.1 +joblib==1.1.0 +matplotlib==3.5.1 +numpy==1.22.4 +POT==0.9.0 +scikit_learn==1.1.1 +scipy==1.7.3 +setuptools==61.2.0 +# NOTE: please install the torch, torchvision packages via `conda install pytorch==1.13.1 torchvision==0.14.1 pytorch-cuda=11.6 -c pytorch -c nvidia` +# torch==1.13.1 +# torchvision==0.14.1 diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..5dd4a5b --- /dev/null +++ b/setup.py @@ -0,0 +1,20 @@ +from setuptools import setup, find_packages + + +def readme(): + with open("README.md", encoding="utf-8") as f: + return f.read() + + +def required(): + with open("requirements.txt") as f: + return f.read().splitlines() + + +setup( + name = 'ot_mmd', + packages = find_packages(), + version = "0.0.0", + description = "PyTorch based library for conditional optimal transport.", + license = "MIT", +) \ No newline at end of file