def run_logistic_falkon(dset: Dataset, algorithm: Algorithm, dtype: Optional[DataType], iter_list: List[int], penalty_list: List[float], num_centers: int, kernel_sigma: float, kernel: str, seed: int): import torch import falkon from falkon import kernels from falkon.models import logistic_falkon from falkon.gsc_losses import LogisticLoss from falkon.utils import TicToc torch.manual_seed(seed) np.random.seed(seed) # Data types if dtype is None: dtype = DataType.float64 # Arguments if kernel.lower() == 'gaussian': k = kernels.GaussianKernel(kernel_sigma) elif kernel.lower() == 'laplacian': k = kernels.LaplacianKernel(kernel_sigma) elif kernel.lower() == 'linear': k = kernels.LinearKernel(beta=1.0, sigma=kernel_sigma) else: raise ValueError("Kernel %s not understood for algorithm %s" % (kernel, algorithm)) opt = falkon.FalkonOptions(compute_arch_speed=False, no_single_kernel=True, pc_epsilon_32=1e-6, pc_epsilon_64=1e-13, debug=True) loss = LogisticLoss(kernel=k) flk = logistic_falkon.LogisticFalkon(kernel=k, loss=loss, penalty_list=penalty_list, iter_list=iter_list, M=num_centers, seed=seed, error_fn=None, error_every=1, options=opt) # Error metrics err_fns = get_err_fns(dset) # Load data load_fn = get_load_fn(dset) Xtr, Ytr, Xts, Yts, kwargs = load_fn(dtype=dtype.to_numpy_dtype(), as_torch=True) Xtr = Xtr.pin_memory() Ytr = Ytr.pin_memory() err_fns = [functools.partial(fn, **kwargs) for fn in err_fns] with TicToc("LOGISTIC FALKON ALGORITHM"): flk.error_fn = err_fns[0] print("Starting to train model %s on data %s" % (flk, dset), flush=True) flk.fit(Xtr, Ytr, Xts, Yts) test_model(flk, f"{algorithm} on {dset}", Xts, Yts, Xtr, Ytr, err_fns)
def init_kernel(kernel_name, args_dict): """ Returns a kernels.Kernel. :param kernel_name: str, 'cossim', 'gaussian' or 'lin :param args_dict: dict, arguments passed to kernels.Kernel :return: kernels.Kernel """ if kernel_name == 'cossim': return kernels.CosineSimilarityKernel() if kernel_name == 'gaussian': return kernels.GaussianKernel(sigma=args_dict['hsic_gaussian_sigma']) if kernel_name == 'lin': return kernels.LinearKernel() else: raise NotImplementedError( 'Currently supported kernels for init_kernel:' 'cossim, gaussian, lin, but %s was given' % kernel_name)
# classifies MEG and fMRI subjects in one of the 3 groups (pairwise), and then # try the classification using the combination of data import os import numpy as np home = os.path.expanduser('~') import sys sys.path.append(home + '/research_code/PyKCCA-master/') import kcca, kernels from sklearn import preprocessing from scipy import stats kernel = kernels.LinearKernel() phen = np.recfromcsv(home + '/data/overlap_resting/subjs.csv') out_dir = home + '/data/results/overlap_resting/tmp/' if len(sys.argv) > 10: seed, band = sys.argv[1:] else: seed = 'net6_rSupra' band = [65, 100] #### # open fMRI data #### # load the order of subjects within the data matrix subjs_fname = home + '/data/fmri/joel_all.txt' fid = open(subjs_fname, 'r') subjs = [line.rstrip() for line in fid] fid.close() X_fmri, inatt, hi = [], [], [] print 'Loading fMRI data...'
def run_falkon(dset: Dataset, algorithm: Algorithm, dtype: Optional[DataType], num_iter: int, num_centers: int, kernel_sigma: float, penalty: float, kernel: str, kfold: int, seed: int): import torch from falkon import kernels from falkon.models import falkon from falkon.utils import TicToc torch.manual_seed(seed) np.random.seed(seed) # Data types if dtype is None: dtype = DataType.float64 # Arguments if kernel.lower() == 'gaussian': k = kernels.GaussianKernel(kernel_sigma) elif kernel.lower() == 'laplacian': k = kernels.LaplacianKernel(kernel_sigma) elif kernel.lower() == 'linear': k = kernels.LinearKernel(beta=1.0, sigma=kernel_sigma) else: raise ValueError("Kernel %s not understood for algorithm %s" % (kernel, algorithm)) opt = falkon.FalkonOptions(compute_arch_speed=False, no_single_kernel=True, pc_epsilon_32=1e-6, pc_epsilon_64=1e-13, debug=True) flk = falkon.Falkon(kernel=k, penalty=penalty, M=num_centers, maxiter=num_iter, seed=seed, error_fn=None, error_every=1, options=opt) # Error metrics err_fns = get_err_fns(dset) if kfold == 1: # Load data load_fn = get_load_fn(dset) Xtr, Ytr, Xts, Yts, kwargs = load_fn(dtype=dtype.to_numpy_dtype(), as_torch=True) Xtr = Xtr.pin_memory() Ytr = Ytr.pin_memory() temp_test = torch.empty(3, 3).cuda() del temp_test err_fns = [functools.partial(fn, **kwargs) for fn in err_fns] with TicToc("FALKON ALGORITHM"): flk.error_fn = err_fns[0] print("Starting to train model %s on data %s" % (flk, dset), flush=True) flk.fit(Xtr, Ytr, Xts, Yts) test_model(flk, f"{algorithm} on {dset}", Xts, Yts, Xtr, Ytr, err_fns) else: print("Will train model %s on data %s with %d-fold CV" % (flk, dset, kfold), flush=True) load_fn = get_cv_fn(dset) iteration = 0 test_errs, train_errs = [], [] for Xtr, Ytr, Xts, Yts, kwargs in load_fn(k=kfold, dtype=dtype.to_numpy_dtype(), as_torch=True): err_fns = [functools.partial(fn, **kwargs) for fn in err_fns] with TicToc("FALKON ALGORITHM (fold %d)" % (iteration)): flk.error_every = err_fns[0] flk.fit(Xtr, Ytr, Xts, Yts) iteration += 1 c_test_errs, c_train_errs = test_model(flk, f"{algorithm} on {dset}", Xts, Yts, Xtr, Ytr, err_fns) train_errs.append(c_train_errs) test_errs.append(c_test_errs) print("Full errors: Test %s - Train %s" % (test_errs, train_errs)) print() print("%d-Fold Error Report" % (kfold)) for err_fn_i in range(len(err_fns)): print("Final test errors: %.4f +- %4f" % (np.mean( [e[err_fn_i] for e in test_errs]), np.std([e[err_fn_i] for e in test_errs]))) print("Final train errors: %.4f +- %4f" % (np.mean([e[err_fn_i] for e in train_errs ]), np.std([e[err_fn_i] for e in train_errs]))) print()