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()
