function test_suite=test_map_pca
% tests for cosmo_map_pca
%
% # For CoSMoMVPA's copyright information and license terms, #
% # see the COPYING file distributed with CoSMoMVPA. #
try % assignment of 'localfunctions' is necessary in Matlab >= 2016
test_functions=localfunctions();
catch % no problem; early Matlab versions can use initTestSuite fine
end
initTestSuite;
function test_map_pca_exceptions
aet=@(varargin)assertExceptionThrown(@()...
cosmo_map_pca(varargin{:}),'');
ds=cosmo_synthetic_dataset();
pca_params=struct();
pca_params.mu=[0.0864 0.9248 -0.2001 1.2522 1.0349 0.0568];
pca_params.coef=[ 0.0014 0.7569 0.3369 -0.0540 0.3234;...
0.4052 -0.5164 0.4105 -0.3355 -0.0290;...
0.3133 0.0275 0.6618 0.0901 0.1745;...
-0.4294 -0.2190 -0.0420 -0.5306 0.6797;...
0.7090 0.0436 -0.5070 0.0744 0.4815;...
-0.2251 -0.3313 0.1456 0.7677 0.4127];
pca_params.retain=true(1,5);
% test mutually exclusive parameters
aet(ds,'pca_params',pca_params,'pca_explained_count',3);
aet(ds,'pca_explained_ratio',.5,'pca_explained_count',3);
aet(ds,'pca_explained_ratio',.5,'pca_params',pca_params);
% wrong size for coef
bad_pca_params=pca_params;
bad_pca_params.coef=1;
aet(ds,'pca_params',bad_pca_params);
% missing field
bad_pca_params=pca_params;
bad_pca_params=rmfield(bad_pca_params,'mu');
aet(ds,'pca_params',bad_pca_params);
% bad explained_count
aet(ds,'pca_explained_count',-1);
aet(ds,'pca_explained_count',1.5);
aet(ds,'pca_explained_count',7);
% bad explained ratio
aet(ds,'pca_explained_ratio',-1);
aet(ds,'pca_explained_ratio',-.001);
aet(ds,'pca_explained_ratio',1.001);
function test_map_pca_max_feature_count_exceptions()
default_max_feature_count=1000;
nsamples=20;
for max_feature_count=[NaN, ...
round(rand()*10+10), ...
default_max_feature_count]
for delta=(-1:1)
opt=struct();
if isnan(max_feature_count)
nfeatures=default_max_feature_count+delta;
else
nfeatures=max_feature_count+delta;
opt.max_feature_count=max_feature_count;
end
data=randn(nsamples,nfeatures);
expect_exception=delta>0;
for use_struct=[false,true]
if use_struct
ds=struct();
ds.samples=data;
else
ds=data;
end
func_handle=@()cosmo_map_pca(ds,opt);
if expect_exception
assertExceptionThrown(func_handle);
else
% should not raise an exception
func_handle();
end
end
end
end
function test_map_pca_basics
nfeatures=ceil(rand()*10+10);
nsamples_train=ceil(rand()*10+10)+nfeatures;
nsamples_test=ceil(rand()*10+10)+nfeatures;
train_samples=randn(nsamples_train,nfeatures);
test_samples=randn(nsamples_test,nfeatures);
for count=[1 ceil(nfeatures/2) nfeatures ceil(rand()*nfeatures)]
helper_test_map_pca_with_count(train_samples,...
test_samples,count);
end
for ratio=[.1 .5 1 rand()]
helper_test_map_pca_with_ratio(train_samples,...
test_samples,ratio);
end
helper_test_map_pca_with_no_arguments(train_samples,...
test_samples);
function helper_test_map_pca_with_ratio(train_samples,...
test_samples,ratio)
ratio_opt=struct();
ratio_opt.pca_explained_ratio=ratio;
% check that ratio and count give the same output
[unused,param]=cosmo_pca(train_samples);
count=find(cumsum(param.explained)>=ratio*100,1);
if isempty(count)
count=numel(param.explained);
end
count_opt=struct();
count_opt.pca_explained_count=count;
did_throw=true;
try
[samples_ratio,params_ratio]=cosmo_map_pca(train_samples,ratio_opt);
did_throw=false;
end
if did_throw
cosmo_map_pca(train_samples,count_opt)
assertExceptionThrown(@()...
cosmo_map_pca(train_samples,count_opt));
assertExceptionThrown(@()...
helper_test_dataset_samples_correspondence(train_samples,...
ratio_opt));
else
[samples_count,params_count]=cosmo_map_pca(train_samples,...
count_opt);
assert_almost_equal(samples_ratio,samples_count);
assert_almost_equal(params_ratio,params_count);
% verify that raw samples and dataset structures give the same
% result
helper_test_dataset_samples_correspondence(train_samples,...
ratio_opt);
helper_test_dataset_samples_correspondence(test_samples,...
'pca_params',params_ratio);
end
% verify correct result by delegating to count
if ~did_throw
helper_test_map_pca_with_count(train_samples,test_samples,count);
else
assertExceptionThrown(@()...
helper_test_map_pca_with_count(train_samples,test_samples,...
count));
end
function helper_test_map_pca_with_count(train_samples,test_samples,count)
assert(numel(count)==1);
opt=struct();
opt.pca_explained_count=count;
% do PCA in two ways; we assume that cosmo_pca works correctly, and
% compare its result to cosmo_map_pca
[ys,params]=cosmo_map_pca(train_samples,opt);
[pca_samples,pca_params]=cosmo_pca(train_samples,count);
assert_almost_equal(ys,pca_samples);
% verify when using samples
helper_test_dataset_samples_correspondence(train_samples, ...
'pca_explained_count',count);
% verify params
expected_params=struct();
expected_params.mu=pca_params.mu;
expected_params.coef=pca_params.coef;
nfeatures=size(train_samples,2);
expected_params.retain=(1:nfeatures)<=count;
assert_almost_equal(expected_params,params);
[zs,params2]=cosmo_map_pca(test_samples,'pca_params',params);
assertEqual(params2,params);
expected_samples=bsxfun(@minus,test_samples,params.mu)*params.coef;
assert_almost_equal(zs,expected_samples);
helper_test_dataset_samples_correspondence(test_samples,...
'pca_params',params);
function helper_test_map_pca_with_no_arguments(train_samples,test_samples)
[ys,params]=cosmo_map_pca(train_samples);
count=size(train_samples,2);
[ys_count,params_count]=cosmo_map_pca(train_samples,...
'pca_explained_count',count);
assert_almost_equal(ys,ys_count);
assert_almost_equal(params,params_count);
helper_test_dataset_samples_correspondence(train_samples);
helper_test_dataset_samples_correspondence(test_samples,...
'pca_params',params);
function helper_test_dataset_samples_correspondence(samples, varargin)
ds=struct();
ds.samples=samples;
[result_ds,param_ds]=cosmo_map_pca(ds,varargin{:});
[result,param]=cosmo_map_pca(samples,varargin{:});
% verify that output is the same
expected_ds=struct();
expected_ds.samples=result;
expected_ds.fa.comp=1:size(result,2);
expected_ds.a.fdim.labels={'comp'};
expected_ds.a.fdim.values={1:size(samples,2)};
assert_almost_equal(expected_ds,result_ds);
% parameters must be identical
assert_almost_equal(param_ds,param);
function assert_almost_equal(x,y,msg,tol)
% helper that supports structs recursively
if nargin<4
tol=1e-5;
end
if nargin<3
msg='';
end
if isstruct(x)
assertTrue(isstruct(y),[msg ' - x is a struct but y is not']);
fns=fieldnames(x);
assertEqual(sort(fns),sort(fieldnames(y)),...
[msg ' - fieldname mismatch'])
n=numel(fns);
for k=1:n
fn=fns{k};
assert_almost_equal(x.(fn),y.(fn),...
sprintf('%s - mismatch for field %s',msg,fn))
end
elseif iscell(x) && iscell(y)
assertEqual(size(x),size(y),[msg ' - cell size mismatch']);
for k=1:numel(x)
assert_almost_equal(x{k},y{k},...
sprintf(' - cell element %d different',k));
end
elseif ischar(x) && ischar(y)
assertEqual(x,y,sprintf('%s - %s ~= %s',msg,x,y));
elseif islogical(x) && islogical(y)
assertEqual(x,y,sprintf('%s - boolean array mismatch',msg));
elseif isnumeric(x) && isnumeric(y)
if isempty(x) && isempty(y)
return;
end
assertElementsAlmostEqual(x,y,'absolute',tol,[msg ' - different']);
else
error('unsupported data type');
end
function test_pca_map_ratio_unity()
sizes=[4,10;...
10,4;...
4,4];
for k=size(sizes,1);
sz=sizes(k,:);
samples=randn(sz);
[xs,params]=cosmo_map_pca(samples,'pca_explained_ratio',1);
assertEqual(params.retain,true(1,sz(end)-1));
end
