Abstract class for aggregation. Implement the functions for any + fusion methodology (e.g. late fusion, VLAD, channel concatenation, etc.) + + Properties: + featextractors: cell array with the the feature extractors to be used on + the trials. Each cell contains a featextraction object, and the trials + are given to each of the objects within the Experimenter class + instanceSet: output - the aggregated features. Can be a simple + InstanceSet or the extended FusionInstanceSet + + Functions: +Implement this function to process the trials of each featextraction +object in the cell array featextractors. It should store in the +instanceSet property the features. + obj.aggregate(); +Info & run time so that the experiments are easily documented. configInfo +is a string with the configuration information and time is of type double. + configInfo = obj.getConfigInfo(); + time = obj.getTime();
0001 % Abstract class for aggregation. Implement the functions for any +0002 % fusion methodology (e.g. late fusion, VLAD, channel concatenation, etc.) +0003 % +0004 % Properties: +0005 % featextractors: cell array with the the feature extractors to be used on +0006 % the trials. Each cell contains a featextraction object, and the trials +0007 % are given to each of the objects within the Experimenter class +0008 % instanceSet: output - the aggregated features. Can be a simple +0009 % InstanceSet or the extended FusionInstanceSet +0010 % +0011 % Functions: +0012 %Implement this function to process the trials of each featextraction +0013 %object in the cell array featextractors. It should store in the +0014 %instanceSet property the features. +0015 % obj.aggregate(); +0016 %Info & run time so that the experiments are easily documented. configInfo +0017 %is a string with the configuration information and time is of type double. +0018 % configInfo = obj.getConfigInfo(); +0019 % time = obj.getTime(); +0020 +0021 classdef (Abstract) AggregatorBase < handle +0022 +0023 properties +0024 featextractors; +0025 instanceSet; +0026 end +0027 +0028 methods (Abstract = true) +0029 obj = aggregate(obj); +0030 configInfo = getConfigInfo(obj); +0031 time = getTime(obj); +0032 end +0033 +0034 end +0035
 Master index |
+Index for +eegtoolkit/+aggregation/@AggregatorBase  |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@AggregatorBase |
 AggregatorBase | Abstract class for aggregation. Implement the functions for any |
0001 classdef ChannelAveraging < eegtoolkit.aggregation.AggregatorBase; +0002 +0003 properties +0004 end +0005 +0006 methods +0007 +0008 function CA = ChannelAveraging(CA) +0009 end +0010 +0011 function CA = aggregate(CA) +0012 numExtr = length(CA.featextractors); +0013 numInstances = CA.featextractors{1}.getInstanceSet.getNumInstances; +0014 numFeatures = CA.featextractors{1}.getInstanceSet.getNumFeatures; +0015 fused = zeros(numInstances,numFeatures,numExtr); +0016 for i=1:numExtr +0017 fused(:,:,i) = CA.featextractors{i}.getInstances; +0018 end +0019 fusedMean = mean(fused,3); +0020 CA.instanceSet = eegtoolkit.util.InstanceSet(fusedMean,CA.featextractors{1}.getLabels); +0021 end +0022 +0023 function configInfo = getConfigInfo(CA) +0024 configInfo = 'ChannelAveraging'; +0025 end +0026 +0027 function time = getTime(CA) +0028 time = 0; +0029 end +0030 end +0031 +0032 end +0033
| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelAveraging |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelAveraging |
| ChannelAveraging |
0001 classdef ChannelConcat < eegtoolkit.aggregation.AggregatorBase; +0002 +0003 properties +0004 end +0005 +0006 methods +0007 +0008 function CC = ChannelConcat(CC) +0009 end +0010 +0011 function CC = aggregate(CC) +0012 numExtract = length(CC.featextractors); +0013 fused = []; +0014 for i=1:numExtract +0015 fused = horzcat(fused,CC.featextractors{i}.getInstances); +0016 end +0017 % [~,y] = size(fused); +0018 % ind = randperm(y); +0019 % fused = fused(:,ind); +0020 CC.instanceSet = eegtoolkit.util.InstanceSet(fused,CC.featextractors{1}.getLabels); +0021 end +0022 +0023 function configInfo = getConfigInfo(CC) +0024 configInfo = 'ChannelConcat'; +0025 end +0026 +0027 +0028 function time = getTime(CC) +0029 time = 0; +0030 end +0031 end +0032 +0033 end +0034
| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelConcat |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelConcat |
| ChannelConcat |
0001 classdef ChannelRatio < eegtoolkit.aggregation.AggregatorBase; +0002 +0003 properties +0004 end +0005 +0006 methods +0007 +0008 function CR = ChannelRatio(CR) +0009 end +0010 +0011 function CR = aggregate(CR) +0012 numExtract = length(CR.featextractors); +0013 if numExtract ~=2 +0014 error ('ChannelRatio: Number of transformers should be 2'); +0015 end +0016 in1 = CR.featextractors{1}.getInstances; +0017 in2 = CR.featextractors{2}.getInstances; +0018 ratio = in1./in2; +0019 CR.instanceSet = eegtoolkit.util.InstanceSet(ratio,CR.featextractors{1}.getLabels); +0020 end +0021 +0022 function configInfo = getConfigInfo(CR) +0023 configInfo = 'ChannelRatio'; +0024 end +0025 +0026 +0027 function time = getTime(CR) +0028 time = 0; +0029 end +0030 end +0031 +0032 end +0033
| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelRatio |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@ChannelRatio |
| ChannelRatio |
0001 classdef Fisher < eegtoolkit.aggregation.AggregatorBase +0002 properties +0003 codebookInfo; +0004 numClusters; +0005 means; +0006 covariances; +0007 priors; +0008 pcanum; +0009 end +0010 +0011 methods +0012 function FA = Fisher(codebookfilename,pcanum) +0013 load(codebookfilename); +0014 FA.means = means; +0015 FA.covariances = covariances; +0016 FA.priors = priors; +0017 FA.numClusters = length(priors); +0018 FA.codebookInfo = codebookInfo; +0019 FA.pcanum = pcanum; +0020 end +0021 +0022 function FA = aggregate(FA) +0023 numExtract = length(FA.featextractors); +0024 numFeatures = FA.featextractors{1}.instanceSet.getNumFeatures; +0025 numTrials = length(FA.featextractors{1}.trials); +0026 instances = zeros(numTrials,numExtract,numFeatures); +0027 pcainstances = zeros(numTrials,numExtract,FA.pcanum); +0028 if FA.pcanum > 0 +0029 fishers = zeros(numTrials, FA.numClusters * FA.pcanum *2); +0030 else +0031 fishers = zeros(numTrials,FA.numClusters*numFeatures*2); +0032 end +0033 for i=1:numExtract +0034 instances(:,i,:) = FA.featextractors{i}.getInstances; +0035 if FA.pcanum > 0 +0036 [~,pcainstances(:,i,:),~,~,~] = pca(squeeze(instances(:,i,:)),'NumComponents',FA.pcanum); +0037 end +0038 end +0039 for i=1:numTrials +0040 if FA.pcanum > 0 +0041 dataToBeEncoded = squeeze(pcainstances(i,:,:)); +0042 else +0043 dataToBeEncoded = squeeze(instances(i,:,:)); +0044 end +0045 fishers(i,:) = vl_fisher(dataToBeEncoded', FA.means, FA.covariances, FA.priors); +0046 end +0047 FA.instanceSet = eegtoolkit.util.InstanceSet(fishers,FA.featextractors{1}.getLabels); +0048 end +0049 +0050 function configInfo = getConfigInfo(FA) +0051 configInfo = sprintf('Fisher:\tcodebook:%s',FA.codebookInfo); +0052 end +0053 +0054 function time = getTime(FA) +0055 time = 0; +0056 end +0057 end +0058 +0059 methods (Static) +0060 function [] = trainCodebook(session, channels, numCenters, codebookfilename,pcanum) +0061 nfft = 512; +0062 extractors = {}; +0063 numChannels = length(channels); +0064 numTrials = length(session.trials); +0065 numFeatures = nfft/2+1; +0066 instances = zeros(numTrials,numChannels,numFeatures); +0067 h = waitbar(0,'message'); +0068 for i=1:length(channels) +0069 waitbar(i/(length(channels)+10),h,sprintf('Computing channel:%d',channels(i))); +0070 extractors{i} = eegtoolkit.featextraction.PWelch; +0071 extractors{i}.trials = session.trials; +0072 extractors{i}.channel = channels(i); +0073 extractors{i}.nfft = nfft; +0074 extractors{i}.seconds = 5; +0075 extractors{i}.extract; +0076 instances(:,i,:) = extractors{i}.getInstances; +0077 end +0078 instances = reshape(instances,numTrials*numChannels,numFeatures); +0079 waitbar(i/(length(channels)+10),h,'Computing gmm..'); +0080 if(pcanum > 0) +0081 [~,instances,~,~,~] = pca(instances,'NumComponents',pcanum); +0082 end +0083 [means, covariances, priors] = vl_gmm(instances', numCenters); +0084 waitbar(i+5/(length(channels)+10),h,'Saving variables..'); +0085 codebookInfo = sprintf('filename:%s\tnumClusters:%d\tnumPCA:%d\tchannels:',codebookfilename, numCenters, pcanum); +0086 for i=1:length(channels) +0087 codebookInfo = sprintf('%s%d ',codebookInfo,channels(i)); +0088 end +0089 save(codebookfilename,'means','covariances','priors','codebookInfo'); +0090 close(h); +0091 end +0092 +0093 +0094 end +0095 +0096 end +0097
| Master index |
+Index for +eegtoolkit/+aggregation/@Fisher |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@Fisher |
| Fisher |
0001 classdef LateFusion < eegtoolkit.aggregation.AggregatorBase; +0002 +0003 properties +0004 end +0005 +0006 methods +0007 +0008 function LFA = LateFusion(LFA) +0009 end +0010 +0011 function LFA = aggregate(LFA) +0012 numTransf = length(LFA.featextractors); +0013 LFA.instanceSet = eegtoolkit.util.FusionInstanceSet(LFA.featextractors{1}.instanceSet); +0014 +0015 for i=1:numTransf +0016 LFA.instanceSet = LFA.instanceSet.addInstanceSet(LFA.featextractors{i}.instanceSet); +0017 end +0018 end +0019 +0020 function configInfo = getConfigInfo(LFA) +0021 configInfo = 'LateFusion'; +0022 end +0023 +0024 +0025 function time = getTime(LFA) +0026 time = 0; +0027 end +0028 end +0029 +0030 end +0031
| Master index |
+Index for +eegtoolkit/+aggregation/@LateFusion |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@LateFusion |
| LateFusion |
0001 classdef VLAD < eegtoolkit.aggregation.AggregatorBase; +0002 +0003 properties +0004 kdtree; +0005 centers; +0006 codebookInfo; +0007 numClusters; +0008 end +0009 +0010 methods +0011 +0012 function VA = VLAD(codebookfilename) +0013 load(codebookfilename); +0014 VA.kdtree = kdtree; +0015 VA.centers = centers; +0016 VA.codebookInfo = codebookInfo; +0017 [~,VA.numClusters] = size(centers); +0018 end +0019 +0020 function VA = aggregate(VA) +0021 numExtract = length(VA.transformers); +0022 numFeatures = VA.featextractors{1}.instanceSet.getNumFeatures; +0023 numTrials = length(VA.featextractors{1}.trials); +0024 instances = zeros(numTrials,numExtract,numFeatures); +0025 vlads = zeros(numTrials,VA.kdtree.numData*numFeatures); +0026 for i=1:numExtract +0027 instances(:,i,:) = VA.featextractors{i}.getInstances; +0028 end +0029 for i=1:numTrials +0030 dataToBeEncoded = squeeze(instances(i,:,:)); +0031 nn = vl_kdtreequery(VA.kdtree, VA.centers, dataToBeEncoded'); +0032 assignments = zeros(VA.numClusters, numExtract); +0033 assignments(sub2ind(size(assignments), nn, 1:length(nn))) = 1; +0034 vlads(i,:) = vl_vlad(dataToBeEncoded',VA.centers,assignments); +0035 end +0036 VA.instanceSet = eegtoolkit.util.InstanceSet(vlads,VA.featextractors{1}.getLabels); +0037 end +0038 +0039 function configInfo = getConfigInfo(VA) +0040 configInfo = sprintf('VLAD:\tcodebook:%s',VA.codebookInfo); +0041 end +0042 +0043 +0044 function time = getTime(VA) +0045 time = 0; +0046 end +0047 end +0048 +0049 methods (Static) +0050 function [] = trainCodebook(session, channels, numCenters, codebookfilename) +0051 nfft = 512; +0052 extractors = {}; +0053 numChannels = length(channels); +0054 numTrials = length(session.trials); +0055 numFeatures = nfft/2+1; +0056 instances = zeros(numTrials,numChannels,numFeatures); +0057 h = waitbar(0,'message'); +0058 for i=1:length(channels) +0059 waitbar(i/(length(channels)+10),h,sprintf('Computing channel:%d',channels(i))); +0060 extractors{i} = eegtoolkit.transformer.PWelchTransformer; +0061 extractors{i}.trials = session.trials; +0062 extractors{i}.channel = channels(i); +0063 extractors{i}.nfft = nfft; +0064 extractors{i}.seconds = 5; +0065 extractors{i}.transform; +0066 instances(:,i,:) = extractors{i}.getInstances; +0067 end +0068 instances = reshape(instances,numTrials*numChannels,numFeatures); +0069 waitbar(i/(length(channels)+10),h,'Clustering..'); +0070 centers = vl_kmeans(instances',numCenters); +0071 waitbar(i+4/(length(channels)+10),h,'Building kdtree..'); +0072 kdtree = vl_kdtreebuild(centers); +0073 waitbar(i+5/(length(channels)+10),h,'Saving variables..'); +0074 codebookInfo = sprintf('filename:%s\tnumClusters:%d\tchannels:',codebookfilename, numCenters); +0075 for i=1:length(channels) +0076 codebookInfo = sprintf('%s%d ',codebookInfo,channels(i)); +0077 end +0078 save(codebookfilename,'centers','kdtree','codebookInfo'); +0079 close(h); +0080 end +0081 end +0082 end +0083
| Master index |
+Index for +eegtoolkit/+aggregation/@VLAD |
+
+| Master index |
+Index for +eegtoolkit/+aggregation/@VLAD |
| VLAD |
0001 classdef Adaboost < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 Method % AdaboostM2 (default), TotalBoost, LPBoost, Subspace, etc +0009 NLearn % Number of learners (default 100) +0010 Learners % Tree (default), KNN (only for Subspace), Discriminant(recommended for subspace), Custom +0011 models; +0012 totalTime; +0013 totalCount; +0014 end +0015 +0016 methods (Access = public) +0017 function BOOST = Adaboost(instanceSet, Method, NLearn, Learners) +0018 %set default parameters +0019 BOOST.Method = 'AdaBoostM2'; +0020 BOOST.NLearn=100; +0021 BOOST.Learners = 'Tree'; +0022 if nargin > 0 +0023 BOOST.instanceSet = instanceSet; +0024 end +0025 if nargin > 1 +0026 BOOST.Method = Method; +0027 end +0028 if nargin > 2 +0029 BOOST.NLearn=NLearn; +0030 end +0031 if nargin > 3 +0032 BOOST.Learners = Learners; +0033 end +0034 BOOST.totalTime = 0; +0035 BOOST.totalCount = 0; +0036 end +0037 +0038 function BOOST = build(BOOST) +0039 %clear all from previous calls to "build" +0040 BOOST.reset; +0041 numLabels = BOOST.instanceSet.getNumLabels; +0042 uniqueLabels = unique(BOOST.instanceSet.getLabels); +0043 +0044 % ---- Multi-Class ----- % +0045 instances=BOOST.instanceSet.instances; +0046 labels=BOOST.instanceSet.labels; +0047 +0048 BOOST.models{1} = fitensemble(instances,labels,BOOST.Method, BOOST.NLearn, BOOST.Learners,... +0049 'Type','Classification'); +0050 +0051 % for i=1:numLabels +0052 % currentLabel = uniqueLabels(i); +0053 % labels = zeros(BOOST.instanceSet.getNumInstances,1)-1; +0054 % labels(BOOST.instanceSet.getInstanceIndicesForLabel(currentLabel)) = 1; +0055 % instances = sparse(BOOST.instanceSet.getInstances); +0056 % N = length(labels); % X training labels +0057 % W = 1/N * ones(N,1); %Weights initialization +0058 % M = 10; % Number of boosting iterations +0059 % for m=1:M +0060 % C = 1; %The cost parameters of the linear SVM, you can... +0061 % % perform a grid search for the optimal value as well +0062 % +0063 % %Calculate the error and alpha in adaBoost with cross validation +0064 % cmd = ['-c ', num2str(C), ' -b 1']; +0065 % model = svmtrain(W,labels, instances, cmd); +0066 % [Xout, acc, ~] = svmpredict(labels, instances,model); +0067 % +0068 % err = sum(.5 * W .* acc * N)/sum(W); +0069 % alpha = log( (1-err)/err ); +0070 % +0071 % % update the weight +0072 % W = W.*exp( - alpha.*Xout.*X ); +0073 % W = W/norm(W); +0074 % end +0075 % BOOST.models{i} = model; +0076 % +0077 % end +0078 +0079 end +0080 +0081 function [output, probabilities, ranking] = classifyInstance(BOOST,instance) +0082 %input = instance matrix rows = instances, cols = attributes +0083 %output = predicted class +0084 %probabilities = probability for predicted class +0085 %ranking = propabilities for all classes (e.g. to use with mAP) +0086 +0087 +0088 %TODO:should print an error if 'build' has not been called +0089 numModels = length(BOOST.models); +0090 [numinstance, ~] = size(instance); +0091 scores = zeros(numModels,numinstance); +0092 +0093 % ---- Multi-class ----- % +0094 tic +0095 [label,scores] = predict(BOOST.models{1},instance); +0096 BOOST.totalTime = BOOST.totalTime + toc; +0097 BOOST.totalCount = BOOST.totalCount + numinstance; +0098 +0099 output = zeros(numinstance,1); +0100 probabilities = zeros(numinstance,1); +0101 %we need these for ranking metrics (e.g. mAP) +0102 ranking = scores; +0103 for i=1:numinstance +0104 %select the class with the highest probability +0105 [prob, idx] = max(scores(i,:)); +0106 uniqueLabels = unique(BOOST.instanceSet.getLabels); +0107 %output the label with highest probability +0108 output(i,1) = uniqueLabels(idx); +0109 %return the probability for the output label +0110 probabilities(i,1) = prob; +0111 end +0112 end +0113 +0114 function BOOST = reset(BOOST) +0115 %delete all stored models +0116 BOOST.models = {}; +0117 end +0118 +0119 function configInfo = getConfigInfo(BOOST) +0120 configInfo = sprintf('Adaboost: Method: %s NLearn: %d Learners: %s',... +0121 BOOST.Method, BOOST.NLearn, BOOST.Learners); +0122 end +0123 +0124 +0125 function time = getTime(BOOST) +0126 time = BOOST.totalTime / BOOST.totalCount; +0127 end +0128 +0129 end +0130 end +0131
| Master index |
+Index for +eegtoolkit/+classification/@Adaboost |
+
+| Master index |
+Index for +eegtoolkit/+classification/@Adaboost |
| Adaboost |
0001 classdef CSPFilterBankWrapper < eegtoolkit.classification.ClassifierBase; +0002 properties (Constant) +0003 +0004 end +0005 properties +0006 baseClassifier; +0007 channel; +0008 cspFilters; +0009 filterBanks; +0010 samplingRate; +0011 end +0012 +0013 methods (Access = public) +0014 function CSPFB = CSPFilterBankWrapper(filterBanks, samplingRate) +0015 CSPFB.cspFilters = {}; +0016 CSPFB.filterBanks = filterBanks; +0017 CSPFB.samplingRate = samplingRate; +0018 %filter_banks=[8 12; 12 16; 16 20;20 24;24 28]; +0019 % if(isa(instanceSet,'eegtoolkit.util.RawSignalSet') +0020 % CSP.instanceSet = instanceSet; +0021 % else +0022 % error('RawSignal extractor should be used with CSPWrapper'); +0023 % end +0024 end +0025 +0026 +0027 function CSPFB = build(CSPFB) +0028 % Builds the classification models +0029 CSPFB.learnCSPMatrix(CSPFB.instanceSet.sMatrix,CSPFB.instanceSet.labels); +0030 instanceLocal = CSPFB.extract(CSPFB.instanceSet.sMatrix); +0031 CSPFB.baseClassifier.instanceSet = eegtoolkit.util.InstanceSet(instanceLocal,CSPFB.instanceSet.labels); +0032 CSPFB.baseClassifier.build; +0033 CSPFB.reset; +0034 end +0035 +0036 function [output, probabilities, ranking] = classifyInstance(CSPFB,instance) +0037 +0038 % instance = CSP.extract +0039 %input = instance matrix rows = instances, cols = attributes +0040 %output = predicted class +0041 %probabilities = probability for predicted class +0042 %ranking = propabilities for all classes (e.g. to use with mAP) +0043 +0044 %TODO:should print an error if 'build' has not been called +0045 testInstances = CSPFB.extract(instance); +0046 [output, probabilities, ranking] = CSPFB.baseClassifier.classifyInstance(testInstances); +0047 % numModels = length(LSVM.models); +0048 % [numinstance, ~] = size(testInstances); +0049 % scores = zeros(numModels,numinstance); +0050 % for i=1:numModels +0051 % %predict using the stored models +0052 % [~, ~, t] = svmpredict(eye(numinstance,1),testInstances, LSVM.models{i},'-b 1 -q'); +0053 % %store probability for each class +0054 % scores(i,:) = t(:,1); +0055 % end +0056 % output = zeros(numinstance,1); +0057 % probabilities = zeros(numinstance,1); +0058 % ranking = scores; +0059 % for i=1:numinstance +0060 % %select the class with the highest probability +0061 % [prob, idx] = max(scores(:,i)); +0062 % uniqueLabels = unique(LSVM.instanceSet.getLabels); +0063 % %output the label with highest probability +0064 % output(i,1) = uniqueLabels(idx); +0065 % %return the probability for the output label +0066 % probabilities(i,1) = prob; +0067 % end +0068 end +0069 +0070 function CSPFB = reset(CSPFB) +0071 % 'Resets' the classifier. +0072 % CSP.models = {}; +0073 end +0074 +0075 function configInfo = getConfigInfo(CSPFB) +0076 configInfo = '\n'; +0077 end +0078 +0079 +0080 function time = getTime(CSPFB) +0081 time = 0; +0082 end +0083 end +0084 methods (Access = private) +0085 function [] = learnCSPMatrix(CSPFB, sMatrix, labels) +0086 %[trialsMat,labels] = ssveptoolkit.util.Trial.trialsCellToMat(in); +0087 [numTrials,numChannels,numSamples] = size(sMatrix); +0088 % numTrials = length(CSPFB.trials); +0089 % [numChannels,numSamples] = size(CSPFB.trials{1}.signal); +0090 % samplingRate = CSPFB.trials{1}.samplingRate; +0091 filter_banks= CSPFB.filterBanks; +0092 [nfb, mfb] = size(filter_banks); +0093 +0094 for iter_fb=1:nfb +0095 +0096 [b,a]=butter(3,filter_banks(iter_fb)/(CSPFB.samplingRate/2)); +0097 % labels = zeros(numTrials,1); +0098 %numTrials X numChannels X numSamples +0099 trialsMat = permute(sMatrix,[2,3,1]); +0100 % trialsMat = zeros(numChannels,numSamples,numTrials); +0101 % for i = 1 : length(CSP_Feat.trials) +0102 % for i_ch = 1:numChannels +0103 % trialsMat(i_ch,:,i) = filtfilt(b,a,CSP_Feat.trials{i}.signal(i_ch,:)); +0104 % end +0105 % labels(i) = CSP_Feat.trials{i}.label; +0106 % end +0107 +0108 trialsMat = permute(trialsMat,[2 1 3]); +0109 [N1, Nch1, Ntr1] = size(trialsMat); +0110 for i = 1:Nch1 +0111 for j = 1:Ntr1 +0112 trialsMat(:,i,j) = (trialsMat(:,i,j) - mean(trialsMat(:,i,j))); +0113 end +0114 end +0115 x_train = trialsMat;%(:,:,CSP_Feat.trainIdx); +0116 y_train = labels;%(CSP_Feat.trainIdx); +0117 [N, Nch, Ntr] = size(x_train); +0118 trialCov=zeros(Nch,Nch,Ntr); +0119 for t=1:length(y_train) +0120 E = x_train(:,:,t)'; +0121 EE = E * E'; +0122 trialCov(:,:,t) = EE ./ trace(EE); +0123 end +0124 for c=1:2 +0125 covMat{c} = mean(trialCov(:,:,y_train == c),3); +0126 end +0127 [U, D] = eig(covMat{1},covMat{2},'qz'); +0128 eigenvalues = diag(D); +0129 [~, ind] = sort(eigenvalues, 'descend'); +0130 U = U(:,ind); +0131 CSPFB.cspFilters{iter_fb} = U'; +0132 % CSP_Filter = U'; +0133 end +0134 %trialsMat2=zeros(N,3,Ntr); +0135 +0136 end +0137 +0138 function instances = extract(CSPFB,sMatrix) +0139 trialsMat = permute(sMatrix,[2,3,1]); +0140 trialsMat = permute(trialsMat,[2,1,3]); +0141 [numTrials,numChannels,~] = size(sMatrix); +0142 final_instances = zeros(numTrials, numChannels*length(CSPFB.filterBanks)); +0143 for iter_fb=1:length(CSPFB.cspFilters) +0144 for j = 1:size(trialsMat,3) +0145 trialsMat(:,:,j) = (CSPFB.cspFilters{iter_fb}*trialsMat(:,:,j)')'; +0146 end +0147 +0148 instances = zeros(numTrials, numChannels); +0149 %labels = zeros(numTrials,1); +0150 +0151 for i=1:numTrials +0152 +0153 projectedTrial = trialsMat(:,:,i);%Filter * CSP_Feat.trials{i}.signal(:,i);% EEGSignals.x(:,:,t)'; +0154 %generating the features as the log variance of the projected signals +0155 variances = var(projectedTrial,0,1); +0156 instances(i,:) = log(variances)'; +0157 %labels(i,1) = floor(CSP_Feat.trials{i}.label); +0158 end +0159 final_instances(:,numChannels*(iter_fb-1)+1:numChannels*iter_fb) = instances; +0160 % CSP_Feat.avgTime = toc/numTrials; +0161 % CSP_Feat.instanceSet = ssveptoolkit.util.InstanceSet(final_instances,labels); +0162 end +0163 instances = final_instances; +0164 end +0165 +0166 +0167 +0168 end +0169 % [numTrials,numChannels,~] = size(sMatrix); +0170 % sMatrix = permute(sMatrix,[3,2,1]); +0171 % for i=1:size(sMatrix,3); +0172 % sMatrix(:,:,i) = (CSPFB.cspFilter*sMatrix(:,:,i)')'; +0173 % end +0174 % instances = zeros(numTrials,numChannels); +0175 % for i=1:numTrials +0176 % projectedTrial = sMatrix(:,:,i); +0177 % variances = var(projectedTrial,0,1); +0178 % instances(i,:) = log(variances)'; +0179 % end +0180 % % instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0181 % end +0182 %end +0183 end +0184
| Master index |
+Index for +eegtoolkit/+classification/@CSPFilterBankWrapper |
+
+| Master index |
+Index for +eegtoolkit/+classification/@CSPFilterBankWrapper |
| CSPFilterBankWrapper |
0001 classdef CSPWrapper < eegtoolkit.classification.ClassifierBase; +0002 properties (Constant) +0003 +0004 end +0005 properties +0006 baseClassifier; +0007 channel; +0008 cspFilter; +0009 end +0010 +0011 methods (Access = public) +0012 function CSP = CSPWrapper(instanceSet) +0013 % if(isa(instanceSet,'eegtoolkit.util.RawSignalSet') +0014 % CSP.instanceSet = instanceSet; +0015 % else +0016 % error('RawSignal extractor should be used with CSPWrapper'); +0017 % end +0018 end +0019 +0020 +0021 function CSP = build(CSP) +0022 % Builds the classification models +0023 CSP.learnCSPMatrix(CSP.instanceSet.sMatrix,CSP.instanceSet.labels); +0024 instanceLocal = CSP.extract(CSP.instanceSet.sMatrix); +0025 CSP.baseClassifier.instanceSet = eegtoolkit.util.InstanceSet(instanceLocal,CSP.instanceSet.labels); +0026 CSP.baseClassifier.build; +0027 CSP.reset; +0028 end +0029 +0030 function [output, probabilities, ranking] = classifyInstance(CSP,instance) +0031 % instance = CSP.extract +0032 %input = instance matrix rows = instances, cols = attributes +0033 %output = predicted class +0034 %probabilities = probability for predicted class +0035 %ranking = propabilities for all classes (e.g. to use with mAP) +0036 +0037 %TODO:should print an error if 'build' has not been called +0038 testInstances = CSP.extract(instance); +0039 [output, probabilities, ranking] = CSP.baseClassifier.classifyInstance(testInstances); +0040 % numModels = length(LSVM.models); +0041 % [numinstance, ~] = size(testInstances); +0042 % scores = zeros(numModels,numinstance); +0043 % for i=1:numModels +0044 % %predict using the stored models +0045 % [~, ~, t] = svmpredict(eye(numinstance,1),testInstances, LSVM.models{i},'-b 1 -q'); +0046 % %store probability for each class +0047 % scores(i,:) = t(:,1); +0048 % end +0049 % output = zeros(numinstance,1); +0050 % probabilities = zeros(numinstance,1); +0051 % ranking = scores; +0052 % for i=1:numinstance +0053 % %select the class with the highest probability +0054 % [prob, idx] = max(scores(:,i)); +0055 % uniqueLabels = unique(LSVM.instanceSet.getLabels); +0056 % %output the label with highest probability +0057 % output(i,1) = uniqueLabels(idx); +0058 % %return the probability for the output label +0059 % probabilities(i,1) = prob; +0060 % end +0061 end +0062 +0063 function CSP = reset(CSP) +0064 % 'Resets' the classifier. +0065 % CSP.models = {}; +0066 end +0067 +0068 function configInfo = getConfigInfo(CSP) +0069 configInfo = '\n'; +0070 end +0071 +0072 +0073 function time = getTime(CSP) +0074 time = 0; +0075 end +0076 end +0077 methods (Access = private) +0078 function [] = learnCSPMatrix(CSP, sMatrix, labels) +0079 [numTrials,numChannels,~] = size(sMatrix); +0080 % labels = CSP.instanceSet.getLabels; +0081 % sMatrix = permute(sMatrix,[2,3,1]); +0082 % sMatrix = permute(sMatrix,[2 1 3]); +0083 sMatrix = permute(sMatrix,[3,2,1]); +0084 for i=1:numChannels +0085 for j=1:numTrials +0086 sMatrix(:,i,j) = (sMatrix(:,i,j) - mean(sMatrix(:,i,j))); +0087 end +0088 end +0089 trialCov = zeros(numChannels,numChannels,numTrials); +0090 for t=1:length(labels) +0091 E = sMatrix(:,:,t)'; +0092 EE = E * E'; +0093 trialCov(:,:,t) = EE ./trace(EE); +0094 end +0095 %TODO: works only for 2 labels, [1,2] +0096 for c=1:2 +0097 covMat{c} = mean(trialCov(:,:,labels == c),3); +0098 end +0099 [U, D] = eig(covMat{1},covMat{2},'qz'); +0100 eigenvalues = diag(D); +0101 [~,ind] = sort(eigenvalues,'descend'); +0102 U = U(:,ind); +0103 CSP.cspFilter = U'; +0104 % for i=1:size(sMatrix,3); +0105 % sMatrix(:,:,i) = (cspFilter*sMatrix(:,:,i)')'; +0106 % end +0107 % instances = zeros(numTrials,numChannels); +0108 % for i=1:numTrials +0109 % projectedTrial = sMatrix(:,:,i); +0110 % variances = var(projectedTrial,0,1); +0111 % instances(i,:) = log(variances)'; +0112 % end +0113 % instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0114 end +0115 +0116 function instances = extract(CSP,sMatrix) +0117 +0118 [numTrials,numChannels,~] = size(sMatrix); +0119 sMatrix = permute(sMatrix,[3,2,1]); +0120 for i=1:size(sMatrix,3); +0121 sMatrix(:,:,i) = (CSP.cspFilter*sMatrix(:,:,i)')'; +0122 end +0123 instances = zeros(numTrials,numChannels); +0124 for i=1:numTrials +0125 projectedTrial = sMatrix(:,:,i); +0126 variances = var(projectedTrial,0,1); +0127 instances(i,:) = log(variances)'; +0128 end +0129 % instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0130 end +0131 end +0132 end +0133
| Master index |
+Index for +eegtoolkit/+classification/@CSPWrapper |
+
+| Master index |
+Index for +eegtoolkit/+classification/@CSPWrapper |
| CSPWrapper |
Abstract class for classification. Implement the functions for any + classifier (e.g. LibSVM, LDA, MLR, RFs, Adaboost, etc.) + + Properties: + instanceSet: the training/test set in an InstanceSet structure + + Functions: +Implement this function to train the classification models. Each +implementation should define the type of models that are to be trained by +the build function. + obj = obj.build(); +Implement this function to apply the classification models to the provided +instance, where instance is a matrix #instances x #features including the +instances. The function should return the following three outputs; 1) +output, the classified labels of the instances (#instances x 1), 2) +probabilities, the probabilities for the output label (instances x 1) and +3) ranking, a matrix #instances x #classes with the probabilities of each +instance for each class (used for multiclass classification). + [output, probabilities, ranking] = obj.classifyInstance(instance); +Implement this function to reset the classifier (e.g. delete the stored +classification models + obj.reset(); +Info & run time so that the experiments are easily documented. configInfo +is a string with the configuration information and time is of type double. + configInfo = obj.getConfigInfo(); + time = obj.getTime();
0001 % Abstract class for classification. Implement the functions for any +0002 % classifier (e.g. LibSVM, LDA, MLR, RFs, Adaboost, etc.) +0003 % +0004 % Properties: +0005 % instanceSet: the training/test set in an InstanceSet structure +0006 % +0007 % Functions: +0008 %Implement this function to train the classification models. Each +0009 %implementation should define the type of models that are to be trained by +0010 %the build function. +0011 % obj = obj.build(); +0012 %Implement this function to apply the classification models to the provided +0013 %instance, where instance is a matrix #instances x #features including the +0014 %instances. The function should return the following three outputs; 1) +0015 %output, the classified labels of the instances (#instances x 1), 2) +0016 %probabilities, the probabilities for the output label (instances x 1) and +0017 %3) ranking, a matrix #instances x #classes with the probabilities of each +0018 %instance for each class (used for multiclass classification). +0019 % [output, probabilities, ranking] = obj.classifyInstance(instance); +0020 %Implement this function to reset the classifier (e.g. delete the stored +0021 %classification models +0022 % obj.reset(); +0023 %Info & run time so that the experiments are easily documented. configInfo +0024 %is a string with the configuration information and time is of type double. +0025 % configInfo = obj.getConfigInfo(); +0026 % time = obj.getTime(); +0027 +0028 classdef (Abstract) ClassifierBase < handle +0029 +0030 properties +0031 instanceSet; +0032 end +0033 +0034 methods (Abstract = true) +0035 [output, probabilities, ranking] = classifyInstance(obj,instance); +0036 obj = build(obj); +0037 obj = reset(obj); +0038 configInfo = getConfigInfo(obj); +0039 time = getTime(obj); +0040 end +0041 +0042 end
| Master index |
+Index for +eegtoolkit/+classification/@ClassifierBase |
+
+| Master index |
+Index for +eegtoolkit/+classification/@ClassifierBase |
| ClassifierBase | Abstract class for classification. Implement the functions for any |
0001 classdef CombiCCA < eegtoolkit.classification.ClassifierBase; +0002 %COMBICCA Summary of this class goes here +0003 % Detailed explanation goes here +0004 % fprintf('CombitCCA Processing TW %fs, No.crossvalidation %d \n',TW(tw_length),run); +0005 % it=cell(12,1); +0006 % for iN = 1:nClasses +0007 % it{iN} = mean(SSVEPdata(chan_used,1:TW_p(tw_length),idx_traindata,iN),3); +0008 % end +0009 % % recognize SSVEP +0010 properties +0011 individualTemplates; +0012 refSignals; +0013 % sti_f; +0014 baseClassifier; +0015 end +0016 +0017 methods +0018 function CoCCA = CombiCCA( sti_f, numHarmonics, sampleLength, samplingRate) +0019 % CoCCA.sti_f = sti_f; +0020 % CoCCA.numHarmonics = numHarmonics; +0021 CoCCA.refSignals = CoCCA.ck_signalTrans(sti_f,sampleLength, samplingRate, numHarmonics); +0022 end +0023 +0024 function CoCCA = build(CoCCA) +0025 numLabels = length(unique(CoCCA.instanceSet.labels)); +0026 CoCCA.individualTemplates = cell(numLabels,1); +0027 unLabels = unique(CoCCA.instanceSet.labels); +0028 for i=1:numLabels +0029 trialsIndices = CoCCA.instanceSet.labels==unLabels(i); +0030 CoCCA.individualTemplates{i} = squeeze(mean(CoCCA.instanceSet.sMatrix(trialsIndices,:,:),1)); +0031 end +0032 +0033 end +0034 +0035 function [output, probabilities, ranking] = classifyInstance(CoCCA,instance) +0036 testInstances = CoCCA.extract(instance); +0037 [output, probabilities, ranking] = CoCCA.baseClassifier.classifyInstance(testInstances); +0038 end +0039 +0040 function CSP = reset(CSP) +0041 % 'Resets' the classifier. +0042 % CSP.models = {}; +0043 end +0044 +0045 function configInfo = getConfigInfo(CSP) +0046 configInfo = '\n'; +0047 end +0048 +0049 +0050 function time = getTime(CSP) +0051 time = 0; +0052 end +0053 +0054 end +0055 methods (Access = private) +0056 +0057 function [Wx, Wy, r] = cca(CCA,X,Y) +0058 % +0059 % CCA calculate canonical correlations +0060 % +0061 % [Wx Wy r] = cca(X,Y) where Wx and Wy contains the canonical correlation +0062 +0063 % vectors as columns and r is a vector with corresponding canonical +0064 % correlations. The correlations are sorted in descending order. X and Y +0065 % are matrices where each column is a sample. Hence, X and Y must have +0066 % the same number of columns. +0067 % +0068 % Example: If X is M*K and Y is N*K there are L=MIN(M,N) solutions. Wx is +0069 % then M*L, Wy is N*L and r is L*1. +0070 % +0071 % +0072 % ?? 2000 Magnus Borga, Link?pings universitet +0073 +0074 % --- Calculate covariance matrices ---?????????????? +0075 +0076 z = [X;Y]; +0077 C = cov(z.'); +0078 sx = size(X,1); %X??????(??), +0079 sy = size(Y,1); +0080 Cxx = C(1:sx, 1:sx) + 10^(-8)*eye(sx); +0081 Cxy = C(1:sx, sx+1:sx+sy); +0082 Cyx = Cxy'; +0083 Cyy = C(sx+1:sx+sy, sx+1:sx+sy) + 10^(-8)*eye(sy);%eye()???????? +0084 invCyy = inv(Cyy); +0085 +0086 % --- Calcualte Wx and r --- +0087 +0088 [Wx,r] = eig(inv(Cxx)*Cxy*invCyy*Cyx); % Basis in X eig???????????? +0089 r = sqrt(real(r)); % Canonical correlations +0090 +0091 % --- Sort correlations --- +0092 +0093 V = fliplr(Wx); % reverse order of eigenvectors??????????????????????i??????????i?????? +0094 r = flipud(diag(r)); % extract eigenvalues and reverse their order +0095 [r,I]= sort((real(r))); % sort reversed eigenvalues in ascending order +0096 r = flipud(r); % restore sorted eigenvalues into descending order?????????????? +0097 for j = 1:length(I) +0098 Wx(:,j) = V(:,I(j)); % sort reversed eigenvectors in ascending order +0099 end +0100 Wx = fliplr(Wx); % restore sorted eigenvectors into descending order +0101 +0102 % --- Calcualte Wy --- +0103 +0104 Wy = invCyy*Cyx*Wx; % Basis in Y +0105 % Wy = Wy./repmat(sqrt(sum(abs(Wy).^2)),sy,1); % Normalize Wy +0106 +0107 end +0108 function instancesOutput = extract(CoCCA,sMatrix) +0109 numClasses = length(CoCCA.individualTemplates); +0110 numInstances = size(sMatrix,1); +0111 instancesOutput = zeros(numInstances,numClasses); +0112 for i=1:numInstances +0113 for j=1:numClasses +0114 [wxit,wyit,rit] = CoCCA.cca(squeeze(sMatrix(i,:,:)),CoCCA.individualTemplates{j}); +0115 [wxref,wyref,rref] = CoCCA.cca(squeeze(sMatrix(i,:,:)),CoCCA.refSignals(:,:,j)); +0116 [wxitref,wyitref,ritref] = CoCCA.cca(CoCCA.individualTemplates{j},CoCCA.refSignals(:,:,j)); +0117 q1 = squeeze(sMatrix(i,:,:))'*wxref; +0118 q2 = CoCCA.refSignals(:,:,j)'*wyref; +0119 q3 = squeeze(sMatrix(i,:,:))'*wxit; +0120 q4 = CoCCA.individualTemplates{j}'*wxit; +0121 q5 = q1; +0122 q6 = CoCCA.individualTemplates{j}'*wxref; +0123 q7 = squeeze(sMatrix(i,:,:))'*wxitref; +0124 q8 = CoCCA.individualTemplates{j}'*wxitref; +0125 r_n = [corr(q1(:),q2(:)) corr(q3(:),q4(:)) corr(q5(:),q6(:)) corr(q7(:), q8(:))]; +0126 rho_n = sum(sign(r_n).*r_n.^2); +0127 instancesOutput(i,j) = rho_n; +0128 end +0129 end +0130 end +0131 % for j=1:nClasses +0132 % tempvec=zeros(nClasses,1); +0133 % for jj=1:nClasses +0134 % [wxit,wyit,rit ]=cca(SSVEPdata(chan_used,1:TW_p(tw_length),run,j),it{jj}(:,1:TW_p(tw_length))); +0135 % [wxref,wyref,rref ]=cca(SSVEPdata(chan_used,1:TW_p(tw_length),run,j),sc{jj}(:,1:TW_p(tw_length))); +0136 % [wxitref,wyitref,ritref ]=cca(it{jj}(:,1:TW_p(tw_length)),sc{jj}(:,1:TW_p(tw_length))); +0137 % q1 = SSVEPdata(chan_used,1:TW_p(tw_length),run,j)'*wxref; +0138 % q2 = sc{jj}(:,1:TW_p(tw_length))'*wyref; +0139 % q3 = SSVEPdata(chan_used,1:TW_p(tw_length),run,j)'*wxit; +0140 % q4 = it{jj}(:,1:TW_p(tw_length))'*wxit; +0141 % q5 = q1; +0142 % q6 = it{jj}(:,1:TW_p(tw_length))'*wxref; +0143 % q7 = SSVEPdata(chan_used,1:TW_p(tw_length),run,j)'*wxitref; +0144 % q8 = it{jj}(:,1:TW_p(tw_length))'*wxitref; +0145 % r_n = [corr(q1(:),q2(:)) corr(q3(:),q4(:)) corr(q5(:),q6(:)) corr(q7(:),q8(:))]; +0146 % rho_n = sum(sign(r_n).*r_n.^2); +0147 % tempvec(jj) = rho_n;%max(r1); +0148 % end +0149 % +0150 % [v,idx]=max(tempvec); +0151 % sub_lab(mth,(run-1)*nClasses+j,tw_length)=idx; +0152 % if idx==j +0153 % n_correct(tw_length,mth)=n_correct(tw_length,mth)+1; +0154 % end +0155 % end +0156 function refSignal=ck_signalTrans(CCA,f,mLen,FreqSamp,NumHarm) +0157 +0158 p=mLen;%1250; +0159 fs=FreqSamp;%250; +0160 TP=1/fs:1/fs:p/fs; +0161 for j=1:length(f) +0162 tempComp=[]; +0163 for k=1:NumHarm +0164 Sinh1=sin(2*pi*k*f(j)*TP); +0165 Cosh1=cos(2*pi*k*f(j)*TP); +0166 tempComp = [tempComp; Sinh1;Cosh1;]; +0167 end +0168 refSignal(:,:,j)=tempComp; +0169 end +0170 end +0171 end +0172 end +0173
| Master index |
+Index for +eegtoolkit/+classification/@CombiCCA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@CombiCCA |
| CombiCCA |
0001 classdef FusionClassifierWrapper < eegtoolkit.classification.ClassifierBase & eegtoolkit.experiment.Experimenter; +0002 +0003 properties +0004 baseClassifier; +0005 classifiers; +0006 end +0007 +0008 methods +0009 function FCW = FusionClassifierWrapper(baseClassifier, fusionInstanceSet) +0010 if nargin>0 +0011 FCW.baseClassifier = baseClassifier; +0012 end +0013 if nargin>1 +0014 FCW.instanceSet = fusionInstanceSet; +0015 end +0016 end +0017 +0018 function FCW = build(FCW) +0019 numFusion = FCW.instanceSet.numFusion; +0020 FCW.reset; +0021 if ~isa(FCW.baseClassifier,'eegtoolkit.classification.LIBSVM') +0022 error ('Only LIBSVMClassifier supported as base classifier'); +0023 else +0024 for i=1:numFusion +0025 FCW.classifiers{i} = FCW.baseClassifier.copy; +0026 FCW.classifiers{i} = eegtoolkit.classification.LIBSVM; +0027 FCW.classifiers{i}.instanceSet = FCW.instanceSet.instanceSets{i}; +0028 FCW.classifiers{i}.build; +0029 end +0030 end +0031 end +0032 +0033 function [output, probabilities, ranking] = classifyInstance(FCW,instance) +0034 [numInstances,~] = size(instance); +0035 numClass = length(FCW.classifiers); +0036 out = zeros(numInstances,numClass); +0037 output = zeros(numInstances,1); +0038 for i=1:length(FCW.classifiers) +0039 [out(:,i), probabilities, ranking] = FCW.classifiers{i}.classifyInstance(instance(:,:,i)); +0040 end +0041 for i=1:numInstances +0042 x = out(i,:); +0043 [a,b] = hist(x,unique(x)); +0044 [~,idx] = max(a); +0045 output(i,:) = b(idx); +0046 end +0047 probabilities = []; +0048 ranking = []; +0049 %TODO:***** +0050 +0051 end +0052 +0053 function configInfo = getConfigInfo(FCW) +0054 configInfo = 'FusionClassifierWrapper'; +0055 end +0056 +0057 +0058 function time = getTime(FCW) +0059 time = 0; +0060 end +0061 +0062 function FCW = reset(FCW) +0063 FCW.classifiers = {}; +0064 end +0065 +0066 +0067 +0068 end +0069 +0070 end +0071
| Master index |
+Index for +eegtoolkit/+classification/@FusionClassifierWrapper |
+
+| Master index |
+Index for +eegtoolkit/+classification/@FusionClassifierWrapper |
| FusionClassifierWrapper |
0001 classdef ITCCA < eegtoolkit.classification.ClassifierBase; +0002 % instanceStruct = struct('sMatrix',sMatrix, 'labels', labels); +0003 % it=cell(12,1); +0004 % for iN = 1:nClasses +0005 % it{iN} = mean(SSVEPdata(chan_used,1:TW_p(tw_length),idx_traindata,iN),3); +0006 % end +0007 % % recognize SSVEP +0008 % for j=1:nClasses +0009 % tempvec=zeros(nClasses,1); +0010 % for jj=1:nClasses +0011 % [wx1,wy1,r1]=cca(SSVEPdata(chan_used,1:TW_p(tw_length),run,j),it{jj}(:,1:TW_p(tw_length))); +0012 % tempvec(jj) = max(r1); +0013 % end +0014 % +0015 % [v,idx]=max(tempvec); +0016 % sub_lab(mth,(run-1)*nClasses+j,tw_length)=idx; +0017 % if idx==j +0018 % n_correct(tw_length,mth)=n_correct(tw_length,mth)+1; +0019 % end +0020 % end +0021 properties (Constant) +0022 +0023 end +0024 properties +0025 baseClassifier; +0026 individualTemplates; +0027 end +0028 +0029 methods (Access = public) +0030 function IT = ITCCA(instanceSet) +0031 % if(isa(instanceSet,'eegtoolkit.util.RawSignalSet') +0032 % CSP.instanceSet = instanceSet; +0033 % else +0034 % error('RawSignal extractor should be used with CSPWrapper'); +0035 % end +0036 end +0037 +0038 +0039 function IT = build(IT) +0040 % Builds the classification models +0041 % IT.learnCSPMatrix(IT.instanceSet.sMatrix,IT.instanceSet.labels); +0042 numLabels = length(unique(IT.instanceSet.labels)); +0043 IT.individualTemplates = cell(numLabels,1); +0044 unLabels = unique(IT.instanceSet.labels); +0045 for i = 1:numLabels +0046 trialsIndices = IT.instanceSet.labels==unLabels(i); +0047 IT.individualTemplates{i} = squeeze(mean(IT.instanceSet.sMatrix(trialsIndices,:,:),1)); +0048 end +0049 % instances = IT.extract(IT.instanceSet.sMatrix); +0050 % instanceSet = eegtoolkit.util.InstanceSet(instances,IT.instanceSet.labels); +0051 % IT.baseClassifier.instanceSet = instanceSet; +0052 % IT.baseClassifier.build(); +0053 end +0054 +0055 function [output, probabilities, ranking] = classifyInstance(CSP,instance) +0056 % for j=1:nClasses +0057 % tempvec=zeros(nClasses,1); +0058 % for jj=1:nClasses +0059 % [wx1,wy1,r1]=cca(SSVEPdata(chan_used,1:TW_p(tw_length),run,j),it{jj}(:,1:TW_p(tw_length))); +0060 % tempvec(jj) = max(r1); +0061 % end +0062 % +0063 % [v,idx]=max(tempvec); +0064 % sub_lab(mth,(run-1)*nClasses+j,tw_length)=idx; +0065 % if idx==j +0066 % n_correct(tw_length,mth)=n_correct(tw_length,mth)+1; +0067 % end +0068 % end +0069 % instance = CSP.extract +0070 %input = instance matrix rows = instances, cols = attributes +0071 %output = predicted class +0072 %probabilities = probability for predicted class +0073 %ranking = propabilities for all classes (e.g. to use with mAP) +0074 +0075 %TODO:should print an error if 'build' has not been called +0076 testInstances = CSP.extract(instance); +0077 [output, probabilities, ranking] = CSP.baseClassifier.classifyInstance(testInstances); +0078 % numModels = length(LSVM.models); +0079 % [numinstance, ~] = size(testInstances); +0080 % scores = zeros(numModels,numinstance); +0081 % for i=1:numModels +0082 % %predict using the stored models +0083 % [~, ~, t] = svmpredict(eye(numinstance,1),testInstances, LSVM.models{i},'-b 1 -q'); +0084 % %store probability for each class +0085 % scores(i,:) = t(:,1); +0086 % end +0087 % output = zeros(numinstance,1); +0088 % probabilities = zeros(numinstance,1); +0089 % ranking = scores; +0090 % for i=1:numinstance +0091 % %select the class with the highest probability +0092 % [prob, idx] = max(scores(:,i)); +0093 % uniqueLabels = unique(LSVM.instanceSet.getLabels); +0094 % %output the label with highest probability +0095 % output(i,1) = uniqueLabels(idx); +0096 % %return the probability for the output label +0097 % probabilities(i,1) = prob; +0098 % end +0099 end +0100 +0101 function CSP = reset(CSP) +0102 % 'Resets' the classifier. +0103 % CSP.models = {}; +0104 end +0105 +0106 function configInfo = getConfigInfo(CSP) +0107 configInfo = '\n'; +0108 end +0109 +0110 +0111 function time = getTime(CSP) +0112 time = 0; +0113 end +0114 end +0115 +0116 +0117 methods (Access = private) +0118 function [Wx, Wy, r] = cca(CCA,X,Y) +0119 % +0120 % CCA calculate canonical correlations +0121 % +0122 % [Wx Wy r] = cca(X,Y) where Wx and Wy contains the canonical correlation +0123 +0124 % vectors as columns and r is a vector with corresponding canonical +0125 % correlations. The correlations are sorted in descending order. X and Y +0126 % are matrices where each column is a sample. Hence, X and Y must have +0127 % the same number of columns. +0128 % +0129 % Example: If X is M*K and Y is N*K there are L=MIN(M,N) solutions. Wx is +0130 % then M*L, Wy is N*L and r is L*1. +0131 % +0132 % +0133 % ?? 2000 Magnus Borga, Link?pings universitet +0134 +0135 % --- Calculate covariance matrices ---?????????????? +0136 +0137 z = [X;Y]; +0138 C = cov(z.'); +0139 sx = size(X,1); %X??????(??), +0140 sy = size(Y,1); +0141 Cxx = C(1:sx, 1:sx) + 10^(-8)*eye(sx); +0142 Cxy = C(1:sx, sx+1:sx+sy); +0143 Cyx = Cxy'; +0144 Cyy = C(sx+1:sx+sy, sx+1:sx+sy) + 10^(-8)*eye(sy);%eye()???????? +0145 invCyy = inv(Cyy); +0146 +0147 % --- Calcualte Wx and r --- +0148 +0149 [Wx,r] = eig(inv(Cxx)*Cxy*invCyy*Cyx); % Basis in X eig???????????? +0150 r = sqrt(real(r)); % Canonical correlations +0151 +0152 % --- Sort correlations --- +0153 +0154 V = fliplr(Wx); % reverse order of eigenvectors??????????????????????i??????????i?????? +0155 r = flipud(diag(r)); % extract eigenvalues and reverse their order +0156 [r,I]= sort((real(r))); % sort reversed eigenvalues in ascending order +0157 r = flipud(r); % restore sorted eigenvalues into descending order?????????????? +0158 for j = 1:length(I) +0159 Wx(:,j) = V(:,I(j)); % sort reversed eigenvectors in ascending order +0160 end +0161 Wx = fliplr(Wx); % restore sorted eigenvectors into descending order +0162 +0163 % --- Calcualte Wy --- +0164 +0165 Wy = invCyy*Cyx*Wx; % Basis in Y +0166 % Wy = Wy./repmat(sqrt(sum(abs(Wy).^2)),sy,1); % Normalize Wy +0167 +0168 end +0169 +0170 +0171 function instancesOutput = extract(IT,sMatrix) +0172 +0173 numClasses = length(IT.individualTemplates); +0174 numInstances = size(sMatrix,1); +0175 tempvec=zeros(numClasses,1); +0176 instancesOutput = zeros(numInstances,numClasses); +0177 for i=1:numInstances +0178 for j=1:numClasses +0179 [~,~,r1] = IT.cca(squeeze(sMatrix(i,:,:)),IT.individualTemplates{j}); +0180 % [wx1,wy1,r1]=cca(SSVEPdata(chan_used,1:TW_p(tw_length),run,j),IT.individualTemplates{j}); +0181 instancesOutput(i,j) = max(r1); +0182 end +0183 end +0184 +0185 % [v,idx]=max(tempvec); +0186 % sub_lab(mth,(run-1)*nClasses+j,tw_length)=idx; +0187 % if idx==j +0188 % n_correct(tw_length,mth)=n_correct(tw_length,mth)+1; +0189 % end +0190 % +0191 % [numTrials,numChannels,~] = size(sMatrix); +0192 % sMatrix = permute(sMatrix,[3,2,1]); +0193 % for i=1:size(sMatrix,3); +0194 % sMatrix(:,:,i) = (CSP.cspFilter*sMatrix(:,:,i)')'; +0195 % end +0196 % instances = zeros(numTrials,numChannels); +0197 % for i=1:numTrials +0198 % projectedTrial = sMatrix(:,:,i); +0199 % variances = var(projectedTrial,0,1); +0200 % instances(i,:) = log(variances)'; +0201 % end +0202 % instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0203 end +0204 end +0205 end +0206
| Master index |
+Index for +eegtoolkit/+classification/@ITCCA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@ITCCA |
| ITCCA |
0001 classdef L1MCCA< eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 properties +0007 samplingRate; +0008 numHarmonics; +0009 numSeconds; +0010 stimulusFrequencies; +0011 models; +0012 maxIterations; +0013 nProjectionComponents; +0014 lambda; +0015 end +0016 +0017 properties (Access = private) +0018 referenceSignals; +0019 optimalReferenceSignals; +0020 projections; +0021 end +0022 +0023 methods (Access = public) +0024 function L1MCCA = L1MCCA(samplingRate,numSeconds,numHarmonics,stimulusFrequencies) +0025 L1MCCA.samplingRate = samplingRate; +0026 L1MCCA.numSeconds = numSeconds; +0027 L1MCCA.numHarmonics = numHarmonics; +0028 L1MCCA.stimulusFrequencies = stimulusFrequencies; +0029 +0030 L1MCCA.maxIterations = 200; +0031 L1MCCA.nProjectionComponents = 1; +0032 L1MCCA.lambda = 0.02; +0033 +0034 L1MCCA.referenceSignals = {}; +0035 L1MCCA.projections = {}; +0036 L1MCCA.optimalReferenceSignals = {}; +0037 +0038 end +0039 +0040 function L1MCCA = build(L1MCCA) +0041 L1MCCA.reset; +0042 n_sti = length(L1MCCA.stimulusFrequencies); +0043 TW = 0.5:0.5:L1MCCA.numSeconds; +0044 TW_p = round(TW*L1MCCA.samplingRate); +0045 +0046 for i=1:n_sti +0047 L1MCCA.referenceSignals{i} = L1MCCA.squarewave(L1MCCA.stimulusFrequencies(i)... +0048 ,L1MCCA.samplingRate,L1MCCA.numSeconds*L1MCCA.samplingRate,L1MCCA.numHarmonics); +0049 end +0050 for i=1:n_sti +0051 a = L1MCCA.instanceSet.matrix4D(:,:,L1MCCA.instanceSet.labelss==i); +0052 [~,~,numIns] = size(a); +0053 iniw3 = ones(numIns,1); +0054 L1MCCA.projections{i} = {}; +0055 [L1MCCA.projections{i}{1},L1MCCA.projections{i}{2},L1MCCA.projections{i}{3}] = L1MCCA.smcca(L1MCCA.referenceSignals{i},... +0056 a,L1MCCA.maxIterations,iniw3,L1MCCA.nProjectionComponents,L1MCCA.lambda); +0057 end +0058 for i=1:n_sti +0059 L1MCCA.optimalReferenceSignals{i} = ttm(tensor(L1MCCA.instanceSet.matrix4D(:,:,L1MCCA.instanceSet.labelss==i)),L1MCCA.projections{i}{2}',3); +0060 L1MCCA.optimalReferenceSignals{i} = tenmat(L1MCCA.optimalReferenceSignals{i},1); +0061 L1MCCA.optimalReferenceSignals{i} = L1MCCA.optimalReferenceSignals{i}.data; +0062 L1MCCA.optimalReferenceSignals{i} = L1MCCA.projections{i}{1}'*L1MCCA.optimalReferenceSignals{i}; +0063 end +0064 end +0065 +0066 function [output, probabilities, ranking] = classifyInstance(L1MCCA,instance) +0067 %input = instance matrix rows = instances, cols = attributes +0068 %output = predicted class +0069 %probabilities = probability for predicted class +0070 %ranking = propabilities for all classes (e.g. to use with mAP) +0071 +0072 %TODO:should print an error if 'build' has not been called +0073 [~, ~,numInstance] = size(instance); +0074 numLabels = length(L1MCCA.optimalReferenceSignals); +0075 output = zeros(numInstance,1); +0076 scores = zeros(numLabels,numInstance); +0077 for i=1:numInstance +0078 for j=1:numLabels +0079 [~,~,r] = L1MCCA.cca(instance(:,:,i),L1MCCA.optimalReferenceSignals{j}); +0080 scores(j,i) = max(r); +0081 +0082 end +0083 [~,output(i,1)] = max(scores(:,i)); +0084 end +0085 ranking = scores; +0086 probabilities = max(scores); +0087 end +0088 +0089 function L1MCCA = reset(L1MCCA) +0090 % 'Resets' the classifier. +0091 L1MCCA.referenceSignals = {}; +0092 L1MCCA.projections = {}; +0093 L1MCCA.optimalReferenceSignals = {}; +0094 end +0095 +0096 function configInfo = getConfigInfo(L1MCCA) +0097 % Prints the parameters of the classifier +0098 configInfo = 'L1MCCA'; +0099 end +0100 +0101 function [Wx, Wy, r] = cca(L1MCCA,X,Y) +0102 +0103 % CCA calculate canonical correlations +0104 % +0105 % [Wx Wy r] = cca(X,Y) where Wx and Wy contains the canonical correlation +0106 % vectors as columns and r is a vector with corresponding canonical +0107 % correlations. The correlations are sorted in descending order. X and Y +0108 % are matrices where each column is a sample. Hence, X and Y must have +0109 % the same number of columns. +0110 % +0111 % Example: If X is M*K and Y is N*K there are L=MIN(M,N) solutions. Wx is +0112 % then M*L, Wy is N*L and r is L*1. +0113 % +0114 % +0115 % ?? 2000 Magnus Borga, Link?pings universitet +0116 +0117 % --- Calculate covariance matrices --- +0118 +0119 z = [X;Y]; +0120 C = cov(z.'); +0121 sx = size(X,1); +0122 sy = size(Y,1); +0123 Cxx = C(1:sx, 1:sx) + 10^(-8)*eye(sx); +0124 Cxy = C(1:sx, sx+1:sx+sy); +0125 Cyx = Cxy'; +0126 Cyy = C(sx+1:sx+sy, sx+1:sx+sy) + 10^(-8)*eye(sy); +0127 invCyy = inv(Cyy); +0128 +0129 % --- Calcualte Wx and r --- +0130 +0131 [Wx,r] = eig(inv(Cxx)*Cxy*invCyy*Cyx); % Basis in X +0132 r = sqrt(real(r)); % Canonical correlations +0133 +0134 % --- Sort correlations --- +0135 +0136 V = fliplr(Wx); % reverse order of eigenvectors +0137 r = flipud(diag(r)); % extract eigenvalues and reverse their order +0138 [r,I]= sort((real(r))); % sort reversed eigenvalues in ascending order +0139 r = flipud(r); % restore sorted eigenvalues into descending order +0140 for j = 1:length(I) +0141 Wx(:,j) = V(:,I(j)); % sort reversed eigenvectors in ascending order +0142 end +0143 Wx = fliplr(Wx); % restore sorted eigenvectors into descending order +0144 +0145 % --- Calcualte Wy --- +0146 +0147 Wy = invCyy*Cyx*Wx; % Basis in Y +0148 % Wy = Wy./repmat(sqrt(sum(abs(Wy).^2)),sy,1); % Normalize Wy +0149 end +0150 function [w1,w3,v1] = smcca(L1MCCA,refdata,traindata,max_iter,iniw3,n_comp,lmbda) +0151 % L1-regualrized (Sparse) Multiway CCA +0152 % traindata: channel x time x trial +0153 % refdata: references by sine-cosine waveforms +0154 % +0155 % Rerefence: +0156 % [1] Y. Zhang, G. Zhou, J. Jin, M. Wang, X. Wang, A. Cichocki. +0157 % L1-regularized multiway canonical correlation analysis for SSVEP-based BCI. +0158 % IEEE Trans. Neural Syst. Rehabil. Eng., 21(6): 887-896 (2013) +0159 % [2] T.K. Kim, R. Cipolla. Canonical correlation analysis of video volume tensor for +0160 % action categorization and detection. IEEE Trans. PAMI, 31(8): 1415-1428 (2009) +0161 % +0162 % +0163 % by Yu Zhang, ECUST, 2014.4.29 +0164 % +0165 +0166 iter=1; +0167 w3=iniw3; +0168 w3=w3./norm(w3); +0169 traindata=tensor(traindata); +0170 refdata=tensor(refdata); +0171 +0172 er=0.00001; % error for iteration stop +0173 +0174 while iter<max_iter +0175 projx3=ttm(traindata,w3',3); +0176 projx3=tenmat(projx3,1); % unfolding each trial tensor into i-mode matrix +0177 projx3=projx3.data; +0178 [v1,w1,r1]=L1MCCA.cca(refdata.data,projx3); +0179 v1=v1(:,1:n_comp); w1=w1(:,1:n_comp); +0180 v1=v1./norm(v1); w1=w1./norm(w1); +0181 projx1=ttm(traindata,w1',1); +0182 projx1=tenmat(projx1,3); % unfolding each trial tensor into i-mode matrix +0183 projx1=projx1.data; +0184 projref1=ttm(refdata,v1',1); +0185 projref1=projref1.data(:)'; +0186 w3=lasso(projx1',projref1','Lambda',lmbda); +0187 w3=w3./norm(w3); +0188 if iter>1 +0189 if all(sign(w1)==-sign(prew1)) +0190 errw(1,iter-1)=norm(w1+prew1); +0191 else +0192 errw(1,iter-1)=norm(w1-prew1); +0193 end +0194 if all(sign(w3)==-sign(prew3)) +0195 errw(2,iter-1)=norm(w3+prew3); +0196 else +0197 errw(2,iter-1)=norm(w3-prew3); +0198 end +0199 if all(sign(v1)==-sign(prev1)) +0200 errw(3,iter-1)=norm(v1+prev1); +0201 else +0202 errw(3,iter-1)=norm(v1-prev1); +0203 end +0204 if errw(1,iter-1)<er && errw(2,iter-1)<er && errw(3,iter-1)<er +0205 break +0206 end +0207 end +0208 prew1=w1; +0209 prew3=w3; +0210 prev1=v1; +0211 iter=iter+1; +0212 end +0213 +0214 fprintf('L1MCCA Iteration is %d \n',iter); +0215 end +0216 +0217 +0218 function y=squarewave(L1MCCA,f, S, T, H) +0219 +0220 % f-- the fundermental frequency +0221 % S-- the sampling rate +0222 % T-- the number of sampling points +0223 % H-- the number of harmonics +0224 +0225 +0226 for i=1:H +0227 for j=1:T +0228 t= j/S; +0229 y(2*i-1,j)=sin(2*pi*(i*f)*t); +0230 y(2*i,j)=cos(2*pi*(i*f)*t); +0231 end +0232 end +0233 end +0234 +0235 function time = getTime(L1MCCA) +0236 time = 0; +0237 end +0238 end +0239 end
| Master index |
+Index for +eegtoolkit/+classification/@L1MCCA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@L1MCCA |
| L1MCCA |
0001 classdef LDA < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties (Access = public) +0008 W_LDA; +0009 PCA_mat; +0010 trainFeat; +0011 end +0012 +0013 methods (Access = public) +0014 function LDA = LDA(instanceSet) +0015 if nargin > 0 +0016 LDA.instanceSet = instanceSet; +0017 end +0018 +0019 end +0020 +0021 function LDA = build(LDA) +0022 LDA.reset(); +0023 data = LDA.instanceSet.getInstances; +0024 data = data'; +0025 labels = LDA.instanceSet.getLabels; +0026 unique(labels) +0027 numTrials = length(labels); +0028 +0029 PCA_W=pca_func(data); +0030 % PCA_W=eye(8000); +0031 train_Data=PCA_W'*data; +0032 +0033 Par.mode = 'LDA'; +0034 dim = length(unique(labels))-1; +0035 [W,Wp] = SGE_GraphConstruct(labels,Par); +0036 [TransMatrix,~] = SGE_Mapping(train_Data,dim,W,Wp); +0037 LDA.W_LDA = TransMatrix; +0038 LDA.PCA_mat=PCA_W; +0039 mtrainFeat=SGE_Projection(train_Data,1:dim,TransMatrix); +0040 LDA.trainFeat=mtrainFeat; +0041 % figure,gplotmatrix(mtrainFeat',[],labels) +0042 end +0043 +0044 function [output, probabilities, ranking] = classifyInstance(LDA,instance) +0045 +0046 N = size(instance,1); +0047 instance = instance'; +0048 +0049 test_Data=LDA.PCA_mat'*instance; +0050 % test_Data=[ones(1,N);test_Data]; +0051 +0052 testFeat=LDA.W_LDA'*test_Data; +0053 X = LDA.trainFeat; +0054 y = LDA.instanceSet.getLabels; +0055 [~,output] = SGE_Classification(X,y',testFeat,0,'euc'); +0056 output = output(1,:)'; +0057 probabilities=zeros(N,1); +0058 ranking=zeros(N,1); +0059 % figure,gplotmatrix(testFeat',[],output) +0060 +0061 end +0062 +0063 function LDA = reset(LDA) +0064 %delete all stored models +0065 LDA.W_LDA=[]; +0066 LDA.PCA_mat=[]; +0067 LDA.trainFeat=[]; +0068 end +0069 +0070 function configInfo = getConfigInfo(LDA) +0071 configInfo = sprintf('MLR_Classifier'); +0072 end +0073 +0074 +0075 function time = getTime(LDA) +0076 +0077 end +0078 +0079 end +0080 end +0081
| Master index |
+Index for +eegtoolkit/+classification/@LDA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@LDA |
| LDA |
LIBSVMCLASSIFIER class + Wrapper class of the libsvm library (libsvm) .mex files must be added to + your matlab path before using this class
0001 +0002 % LIBSVMCLASSIFIER class +0003 % Wrapper class of the libsvm library (libsvm) .mex files must be added to +0004 % your matlab path before using this class +0005 classdef LIBSVM < eegtoolkit.classification.ClassifierBase +0006 +0007 properties (Constant) +0008 KERNEL_LINEAR = 0; +0009 % KERNEL_POLYNOMIAL = 1; not supported yet +0010 KERNEL_RBF = 2; +0011 % KERNEL_SIGMOID = 3; not supported yet +0012 end +0013 properties +0014 kernel; % The svm kernel +0015 cost; % The cost parameter +0016 gamma; % The gamma parameter (used only with rbf kernel) +0017 models; % The trained models +0018 end +0019 +0020 methods (Access = public) +0021 function LSVM = LIBSVM(instanceSet) +0022 if nargin > 0 +0023 LSVM.kernel = LSVM.KERNEL_LINEAR; +0024 LSVM.cost = 1.0; +0025 LSVM.instanceSet = instanceSet; +0026 LSVM.gamma = 1/instanceSet.getNumFeatures; +0027 else +0028 LSVM.kernel = LSVM.KERNEL_LINEAR; +0029 LSVM.cost = 1.0; +0030 LSVM.gamma = 1; +0031 end +0032 end +0033 +0034 function LSVM = build(LSVM) +0035 % Builds the classification models +0036 LSVM.reset; +0037 numLabels = LSVM.instanceSet.getNumLabels; +0038 uniqueLabels = unique(LSVM.instanceSet.getLabels); +0039 for i=1:numLabels +0040 currentLabel = uniqueLabels(i); +0041 labels = zeros(LSVM.instanceSet.getNumInstances,1)-1; +0042 labels(LSVM.instanceSet.getInstanceIndicesForLabel(currentLabel)) = 1; +0043 instances = sparse(LSVM.instanceSet.getInstances); +0044 if LSVM.kernel == LSVM.KERNEL_LINEAR; +0045 %store the models in an instance variable +0046 LSVM.models{i} = svmtrain(labels, instances, sprintf('-t %d -c %f -q', LSVM.kernel, LSVM.cost)); +0047 elseif LSVM.kernel == LSVM.KERNEL_RBF; +0048 LSVM.models{i} = svmtrain(labels, instances, sprintf('-t %d -c %f -g %f -q', LSVM.kernel, LSVM.cost, LSVM.gamma)); +0049 else +0050 error('invalid kernel parameter'); +0051 end +0052 end +0053 end +0054 +0055 function [output, probabilities, ranking] = classifyInstance(LSVM,instance) +0056 %input = instance matrix rows = instances, cols = attributes +0057 %output = predicted class +0058 %probabilities = probability for predicted class +0059 %ranking = propabilities for all classes (e.g. to use with mAP) +0060 +0061 %TODO:should print an error if 'build' has not been called +0062 numModels = length(LSVM.models); +0063 [numinstance, ~] = size(instance); +0064 scores = zeros(numModels,numinstance); +0065 for i=1:numModels +0066 %predict using the stored models +0067 [~, ~, t] = svmpredict(eye(numinstance,1),instance, LSVM.models{i},' -q'); +0068 %store probability for each class +0069 scores(i,:) = t(:,1); +0070 end +0071 output = zeros(numinstance,1); +0072 probabilities = zeros(numinstance,1); +0073 ranking = scores'; +0074 for i=1:numinstance +0075 %select the class with the highest probability +0076 [prob, idx] = max(scores(:,i)); +0077 uniqueLabels = unique(LSVM.instanceSet.getLabels); +0078 %output the label with highest probability +0079 output(i,1) = uniqueLabels(idx); +0080 %return the probability for the output label +0081 probabilities(i,1) = prob; +0082 end +0083 end +0084 +0085 function LSVM = reset(LSVM) +0086 % 'Resets' the classifier. +0087 LSVM.models = {}; +0088 end +0089 +0090 function configInfo = getConfigInfo(LSVM) +0091 % Prints the parameters of the classifier +0092 switch LSVM.kernel +0093 case LSVM.KERNEL_LINEAR +0094 configInfo = sprintf('LIBSVM\tkernel:linear\tcost:%d', LSVM.cost); +0095 case LSVM.KERNEL_RBF +0096 configInfo = sprintf('LIBSVM\tkernel:rbf\tcost:%d\tgamma:%d', LSVM.cost, LSVM.gamma); +0097 otherwise +0098 configInfo = 'Error in configuration (only linear and rbf kernels supported for now)'; +0099 end +0100 end +0101 +0102 function newLSVM = copy(LSVM) +0103 newLSVM = eegtoolkit.classification.LIBSVM; +0104 newLSVM.kernel = LSVM.kernel; +0105 newLSVM.cost = LSVM.cost; +0106 newLSVM.gamma = LSVM.gamma; +0107 end +0108 +0109 +0110 function time = getTime(LSVM) +0111 time = 0; +0112 end +0113 end +0114 end
| Master index |
+Index for +eegtoolkit/+classification/@LIBSVM |
+
+| Master index |
+Index for +eegtoolkit/+classification/@LIBSVM |
| LIBSVM | LIBSVMCLASSIFIER class |
0001 classdef LIBSVMFast < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 properties +0007 kernel; +0008 cost; +0009 gamma; +0010 models; +0011 Ktrain; +0012 Ktest; +0013 maxlag; +0014 scaleopt; +0015 predictTotalTime; +0016 predictCount; +0017 end +0018 +0019 methods (Access = public) +0020 function LSVM = LIBSVMFast (instanceSet,kernel,cost,gamma,maxlag,scaleopt) +0021 %set default parameters +0022 LSVM.predictTotalTime = 0; +0023 LSVM.predictCount = 0; +0024 LSVM.kernel = 'linear'; +0025 LSVM.cost = 1.0; +0026 LSVM.gamma = 0.01; +0027 LSVM.maxlag = 150; +0028 LSVM.scaleopt = 'coeff'; +0029 if nargin > 0 +0030 LSVM.instanceSet = instanceSet; +0031 LSVM.gamma = 1/instanceSet.getNumFeatures; +0032 end +0033 if nargin > 1 +0034 LSVM.kernel = kernel; +0035 end +0036 if nargin > 2 +0037 LSVM.cost = cost; +0038 end +0039 if nargin > 3 +0040 LSVM.gamma = gamma; +0041 end +0042 if nargin > 4 +0043 LSVM.maxlag = maxlag; +0044 end +0045 if nargin > 5 +0046 LSVM.scaleopt = scaleopt; +0047 end +0048 end +0049 +0050 function LSVM = build(LSVM) +0051 %clear all from previous calls to "build" +0052 LSVM.reset; +0053 numLabels = LSVM.instanceSet.getNumLabels; +0054 uniqueLabels = unique(LSVM.instanceSet.getLabels); +0055 for i=1:numLabels +0056 currentLabel = uniqueLabels(i); +0057 labels = zeros(LSVM.instanceSet.getNumInstances,1)-1; +0058 labels(LSVM.instanceSet.getInstanceIndicesForLabel(currentLabel)) = 1; +0059 LSVM.models{i} = svmtrain(labels, [(1:size(LSVM.Ktrain,1))', ... +0060 LSVM.Ktrain+eye(size(LSVM.Ktrain,1))*realmin], ... +0061 sprintf(' -t 4 -c %f -b 1 -q', LSVM.cost)); +0062 end +0063 end +0064 +0065 function [output, probabilities, ranking] = classifyInstance(LSVM) +0066 %input = instance matrix rows = instances, cols = attributes +0067 %output = predicted class +0068 %probabilities = probability for predicted class +0069 %ranking = propabilities for all classes (e.g. to use with mAP) +0070 +0071 %TODO:should print an error if 'build' has not been called +0072 numModels = length(LSVM.models); +0073 [numinstance, ~] = size(LSVM.Ktest); +0074 scores = zeros(numModels,numinstance); +0075 for i=1:numModels +0076 %predict using the stored models +0077 tic +0078 [~, ~, t] = svmpredict(eye(numinstance,1),... +0079 [(1:numinstance)', LSVM.Ktest], LSVM.models{i},'-b 1 -q'); +0080 LSVM.predictTotalTime = LSVM.predictTotalTime + toc; +0081 LSVM.predictCount = LSVM.predictCount + numinstance; +0082 %svmpredict(labels(~idx), [(1:sum(~idx))', K(~idx,idx)], model); +0083 %store probability for each class +0084 scores(i,:) = t(:,1); +0085 end +0086 output = zeros(numinstance,1); +0087 probabilities = zeros(numinstance,1); +0088 %we need these for ranking metrics (e.g. mAP) +0089 ranking = scores; +0090 for i=1:numinstance +0091 %select the class with the highest probability +0092 [prob, idx] = max(scores(:,i)); +0093 uniqueLabels = unique(LSVM.instanceSet.getLabels); +0094 %output the label with highest probability +0095 output(i,1) = uniqueLabels(idx); +0096 %return the probability for the output label +0097 probabilities(i,1) = prob; +0098 end +0099 end +0100 +0101 function LSVM = reset(LSVM) +0102 %delete all stored models +0103 LSVM.models = {}; +0104 end +0105 +0106 function configInfo = getConfigInfo(LSVM) +0107 switch LSVM.kernel +0108 case {'linear','spearman','correlation','cosine'} +0109 configInfo = sprintf('LIBSVMFast\tkernel:%s\tcost:%d', LSVM.kernel, LSVM.cost); +0110 case 'xcorr' +0111 configInfo = sprintf('LIBSVMFast\tkernel:%s\tcost:%d\tgamma:%d\tmaxlag:%d\tscaleopt:%s', LSVM.kernel, LSVM.cost, LSVM.maxlag,LSVM.scaleopt); +0112 otherwise +0113 configInfo = sprintf('LIBSVMFast\tkernel:%s\tcost:%d\tgamma:%d', LSVM.kernel, LSVM.cost, LSVM.gamma); +0114 % otherwise +0115 % configInfo = 'Error in configuration (only linear and rbf kernels supported for now)'; +0116 end +0117 end +0118 +0119 function time = getTime(LSVM) +0120 time = LSVM.predictTotalTime/LSVM.predictCount; +0121 end +0122 end +0123 end +0124
| Master index |
+Index for +eegtoolkit/+classification/@LIBSVMFast |
+
+| Master index |
+Index for +eegtoolkit/+classification/@LIBSVMFast |
| LIBSVMFast |
0001 classdef MLDA < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 DiscrimType; % 'linear' (default) | 'quadratic' | 'diagLinear' | 'diagQuadratic' | 'pseudoLinear' | 'pseudoQuadratic' +0009 Delta % 0 (default) | nonnegative scalar value that acts as a linear coefficient threshold. Delta must be 0 for quadratic discriminant models. +0010 Gamma % scalar value in the range [0,1]. Parameter for regularizing the correlation matrix of predictors. +0011 FillCoeffs % on (default) Coeffs property flag, specified as the comma-separated pair consisting of 'FillCoeffs' and 'on' or 'off +0012 ScoreTransform % 'none' (default). Score transform function. Check http://www.mathworks.com/help/stats/fitcdiscr.html +0013 Prior % 'empirical' (default) or 'uniform'. Prior probabilities for each class. +0014 models; +0015 totalTime; +0016 totalCount; +0017 end +0018 +0019 methods (Access = public) +0020 function MLDA = MLDA(instanceSet, discrimType, delta, gamma, fillCoeffs, scoreTransform,prior) +0021 %set default parameters +0022 if nargin > 0 +0023 MLDA.instanceSet = instanceSet; +0024 end +0025 if nargin > 1 +0026 MLDA.DiscrimType = discrimType; +0027 end +0028 if nargin > 2 +0029 MLDA.Delta=delta; +0030 end +0031 if nargin > 3 +0032 MLDA.Gamma = gamma; +0033 end +0034 if nargin > 4 +0035 MLDA.FillCoeffs = fillCoeffs; +0036 end +0037 if nargin > 5 +0038 MLDA.ScoreTransform = scoreTransform; +0039 end +0040 if nargin > 6 +0041 MLDA.Prior = prior; +0042 end +0043 end +0044 +0045 function MLDA = build(MLDA) +0046 %clear all from previous calls to "build" +0047 MLDA.reset; +0048 numLabels = MLDA.instanceSet.getNumLabels; +0049 uniqueLabels = unique(MLDA.instanceSet.getLabels); +0050 +0051 % ---- Multi-Class ----- % +0052 instances=MLDA.instanceSet.instances; +0053 labels=MLDA.instanceSet.labels; +0054 +0055 %LDA.models{1}=fitcecoc(instances,labels,'Coding','ternarycomplete'); +0056 MLDA.models{1} = fitcdiscr(instances,labels,'DiscrimType',MLDA.DiscrimType,'Delta',MLDA.Delta,'Gamma',MLDA.Gamma,'FillCoeffs',MLDA.FillCoeffs,'ScoreTransform',MLDA.ScoreTransform, 'Prior',MLDA.Prior); +0057 +0058 % ---- One (vs) All ----- % +0059 % for i=1:numLabels +0060 % currentLabel = uniqueLabels(i); +0061 % labels = zeros(LDA.instanceSet.getNumInstances,1)-1; +0062 % labels(LDA.instanceSet.getInstanceIndicesForLabel(currentLabel)) = 1; +0063 % instances = sparse(LDA.instanceSet.getInstances); +0064 % LDA.models{i} = libsvmtrain(labels,instances, '-t 0 -c 1 -b 1'); +0065 % if LDA.kernel == LDA.KERNEL_LINEAR; +0066 % %store the models in an instance variable +0067 % LDA.models{i} = libsvmtrain(labels, instances, sprintf('-t %d -c %f -b 1 -q', LDA.kernel, LDA.cost)); +0068 % elseif LDA.kernel == LDA.KERNEL_RBF; +0069 % LDA.models{i} = libsvmtrain(labels, instances, sprintf('-t %d -c %f -g %f -b 1 -q', LDA.kernel, LDA.cost, LDA.gamma)); +0070 % else +0071 % error('invalid kernel parameter'); +0072 % end +0073 % end +0074 end +0075 +0076 function [output, probabilities, ranking] = classifyInstance(MLDA,instance) +0077 %input = instance matrix rows = instances, cols = attributes +0078 %output = predicted class +0079 %probabilities = probability for predicted class +0080 %ranking = propabilities for all classes (e.g. to use with mAP) +0081 +0082 +0083 %TODO:should print an error if 'build' has not been called +0084 numModels = length(MLDA.models); +0085 [numinstance, ~] = size(instance); +0086 scores = zeros(numModels,numinstance); +0087 +0088 % ---- Multi-class ----- % +0089 tic +0090 [label,scores,cost] = predict(MLDA.models{1},instance); +0091 MLDA.totalTime = MLDA.totalTime + toc; +0092 MLDA.totalCount = MLDA.totalCount + numinstance; +0093 % ---- One (vs) All -----% +0094 % for i=1:numModels +0095 % %predict using the stored models +0096 % [label,score,cost] = predict(LDA.models{i},instance); +0097 % %libsvmpredict(eye(numinstance,1),instance, LSVM.models{i},'-b 1 -q'); +0098 % %store probability for each class +0099 % scores(i,:) = score(:,1); +0100 % end +0101 +0102 output = zeros(numinstance,1); +0103 probabilities = zeros(numinstance,1); +0104 %we need these for ranking metrics (e.g. mAP) +0105 ranking = scores; +0106 for i=1:numinstance +0107 %select the class with the highest probability +0108 [prob, idx] = max(scores(i,:)); +0109 uniqueLabels = unique(MLDA.instanceSet.getLabels); +0110 %output the label with highest probability +0111 output(i,1) = uniqueLabels(idx); +0112 %return the probability for the output label +0113 probabilities(i,1) = prob; +0114 end +0115 end +0116 +0117 function MLDA = reset(MLDA) +0118 %delete all stored models +0119 MLDA.models = {}; +0120 end +0121 +0122 function configInfo = getConfigInfo(MLDA) +0123 configInfo = sprintf('MLDA\tdiscrimtype:%s\tdelta:%f\tgamma:%f\tfillcoeffs:%d\tscoretransform:%s\tprior:%s',MLDA.DiscrimType, MLDA.Delta, MLDA.Gamma, MLDA.FillCoeffs, MLDA.ScoreTransform, MLDA.Prior); +0124 end +0125 +0126 +0127 function time = getTime(MLDA) +0128 time = MLDA.totalTime/MLDA.totalCount; +0129 end +0130 +0131 end +0132 end +0133
| Master index |
+Index for +eegtoolkit/+classification/@MLDA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@MLDA |
| MLDA |
0001 classdef MLR < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 W_mlr; +0009 PCA_mat; +0010 trainFeat; +0011 end +0012 +0013 methods (Access = public) +0014 function MLR = MLR(instanceSet) +0015 if nargin > 0 +0016 MLR.instanceSet = instanceSet; +0017 end +0018 +0019 end +0020 +0021 function MLR = build(MLR) +0022 MLR.reset(); +0023 data = MLR.instanceSet.getInstances; +0024 data = data'; +0025 labels = MLR.instanceSet.getLabels; +0026 numTrials = length(labels); +0027 train_Y = zeros(length(unique(labels)),numTrials); +0028 for i = 1 : numTrials +0029 train_Y(labels(i),i) = 1; +0030 end +0031 [Ydim,Num]=size(train_Y); +0032 PCA_W=MLR.pca_func(data); +0033 train_Data=PCA_W'*data; +0034 train_Data=[ones(1,numTrials);train_Data]; +0035 MLR.W_mlr = MLR.MultiLR(train_Data,train_Y);%inv(train_Data*train_Data')*train_Data*train_Y';%(train_Data'*train_Data)\train_Data'*train_Y;%MultiLR(train_Data,train_Y); +0036 MLR.PCA_mat=PCA_W; +0037 mtrainFeat=MLR.W_mlr'*train_Data; +0038 MLR.trainFeat=mtrainFeat; +0039 end +0040 +0041 function [output, probabilities, ranking] = classifyInstance(MLR,instance) +0042 +0043 N = size(instance,1); +0044 instance = instance'; +0045 test_Data=MLR.PCA_mat'*instance; +0046 test_Data=[ones(1,N);test_Data]; +0047 testFeat=MLR.W_mlr'*test_Data; +0048 output=knnclassify(testFeat',MLR.trainFeat',MLR.instanceSet.getLabels,5,'euclidean'); +0049 probabilities=zeros(N,1); +0050 ranking=zeros(N,1); +0051 +0052 end +0053 +0054 function MLR = reset(MLR) +0055 %delete all stored models +0056 MLR.W_mlr=[]; +0057 MLR.PCA_mat=[]; +0058 MLR.trainFeat=[]; +0059 end +0060 +0061 function configInfo = getConfigInfo(MLR) +0062 configInfo = sprintf('MLR'); +0063 end +0064 +0065 +0066 function time = getTime(MLR) +0067 time = 0; +0068 end +0069 +0070 end +0071 +0072 methods (Access = private) +0073 function Proj_W=pca_func(MLR,data) +0074 Proj_W=[]; +0075 meanData=mean(data,2); +0076 data=data-repmat(meanData,1,size(data,2)); +0077 % stdVar=std(data')'; +0078 % staData=(data-repmat(meanData,1,size(data,2)))./repmat(stdVar,1,size(data,2)); +0079 % data=staData; +0080 [V,S]=eig(data'*data); +0081 [sorted_diagS,sorted_rank]=sort(diag(S),'descend'); +0082 sorted_S=diag(sorted_diagS); +0083 V=V(:,sorted_rank); +0084 r=rank(sorted_S); +0085 S1=sorted_S(1:r,1:r); +0086 V1=V(:,1:r); +0087 U=data*V1*S1^(-0.5); +0088 %[sorted_S,sorted_rank]=sort(diag(S),'descend'); +0089 All_energy=sum(diag(S1)); +0090 sorted_energy=diag(S1); +0091 for j=1:r +0092 if (sum(sorted_energy(1:j))/All_energy)>0.99 +0093 break +0094 end +0095 end +0096 Proj_W=U(:,1:j); +0097 end +0098 function W_mlr=MultiLR(MLR,train_Feat,train_Y) +0099 +0100 % Multiple linear regression +0101 % train_Feat: training samples +0102 % train_Y: label matrix +0103 +0104 [U,Sigma,V]=svd(train_Feat,'econ'); +0105 r=rank(Sigma); +0106 U1=U(:,1:r); +0107 V1=V(:,1:r); +0108 Sigma_r=diag(Sigma(1:r, 1:r)); +0109 W_mlr=U1*diag(1./Sigma_r)*V1'*train_Y'; +0110 +0111 +0112 end +0113 end +0114 end +0115
| Master index |
+Index for +eegtoolkit/+classification/@MLR |
+
+| Master index |
+Index for +eegtoolkit/+classification/@MLR |
| MLR |
0001 classdef MLTREE < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 AlgorithmForCategorical; % Algorithm for best categorical predictor split 'Exact' | 'PullLeft' | 'PCA' | 'OVAbyClass' +0009 MaxNumSplits; % Maximal number of decision splits. size(X,1) - 1 (default) | positive integer +0010 MinLeafSize; % Minimum number of leaf node observations 1 (default) | positive integer value +0011 MinParentSize; % Minimum number of branch node observations 10 (default) | positive integer value +0012 NumVariablesToSample; % Number of predictors to select at random for each split 'all' | positive integer value +0013 ScoreTransform % 'none' (default). Score transform function. Check http://www.mathworks.com/help/stats/fitcdiscr.html +0014 Prior; % Prior probabilities 'empirical' (default) | 'uniform' | vector of scalar values | structure +0015 models; +0016 totalTime; +0017 totalCount; +0018 end +0019 +0020 methods (Access = public) +0021 function MLTREE = MLTREE(instanceSet, algorithmForCategorical, maxNumSplits, minLeafSize, minParentSize, numVariablesToSample, scoreTransform, prior) +0022 %set default parameters +0023 if nargin > 0 +0024 MLTREE.instanceSet = instanceSet; +0025 end +0026 if nargin > 1 +0027 MLTREE.AlgorithmForCategorical = algorithmForCategorical; +0028 end +0029 if nargin > 2 +0030 MLTREE.MaxNumSplits=maxNumSplits; +0031 end +0032 if nargin > 3 +0033 MLTREE.MinLeafSize = minLeafSize; +0034 end +0035 if nargin > 4 +0036 MLTREE.MinParentSize = minParentSize; +0037 end +0038 if nargin > 5 +0039 MLTREE.NumVariablesToSample = numVariablesToSample; +0040 end +0041 if nargin > 6 +0042 MLTREE.ScoreTransform = scoreTransform; +0043 end +0044 if nargin > 7 +0045 MLTREE.Prior = prior; +0046 end +0047 MLTREE.totalTime = 0; +0048 MLTREE.totalCount = 0; +0049 end +0050 +0051 function MLTREE = build(MLTREE) +0052 %clear all from previous calls to "build" +0053 MLTREE.reset; +0054 numLabels = MLTREE.instanceSet.getNumLabels; +0055 uniqueLabels = unique(MLTREE.instanceSet.getLabels); +0056 +0057 % ---- Multi-Class ----- % +0058 instances=MLTREE.instanceSet.instances; +0059 labels=MLTREE.instanceSet.labels; +0060 +0061 %LDA.models{1}=fitcecoc(instances,labels,'Coding','ternarycomplete'); +0062 MLTREE.models{1} = fitctree(instances,labels,'AlgorithmForCategorical',MLTREE.AlgorithmForCategorical,'MaxNumSplits',MLTREE.MaxNumSplits,'MinLeafSize',MLTREE.MinLeafSize,'MinParentSize',MLTREE.MinParentSize,'NumVariablesToSample', MLTREE.NumVariablesToSample,'ScoreTransform',MLTREE.ScoreTransform, 'Prior',MLTREE.Prior); +0063 +0064 +0065 % ---- One (vs) All ----- % +0066 % for i=1:numLabels +0067 % currentLabel = uniqueLabels(i); +0068 % labels = zeros(LDA.instanceSet.getNumInstances,1)-1; +0069 % labels(LDA.instanceSet.getInstanceIndicesForLabel(currentLabel)) = 1; +0070 % instances = sparse(LDA.instanceSet.getInstances); +0071 % LDA.models{i} = libsvmtrain(labels,instances, '-t 0 -c 1 -b 1'); +0072 % if LDA.kernel == LDA.KERNEL_LINEAR; +0073 % %store the models in an instance variable +0074 % LDA.models{i} = libsvmtrain(labels, instances, sprintf('-t %d -c %f -b 1 -q', LDA.kernel, LDA.cost)); +0075 % elseif LDA.kernel == LDA.KERNEL_RBF; +0076 % LDA.models{i} = libsvmtrain(labels, instances, sprintf('-t %d -c %f -g %f -b 1 -q', LDA.kernel, LDA.cost, LDA.gamma)); +0077 % else +0078 % error('invalid kernel parameter'); +0079 % end +0080 % end +0081 end +0082 +0083 function [output, probabilities, ranking] = classifyInstance(MLTREE,instance) +0084 %input = instance matrix rows = instances, cols = attributes +0085 %output = predicted class +0086 %probabilities = probability for predicted class +0087 %ranking = propabilities for all classes (e.g. to use with mAP) +0088 +0089 +0090 %TODO:should print an error if 'build' has not been called +0091 numModels = length(MLTREE.models); +0092 [numinstance, ~] = size(instance); +0093 scores = zeros(numModels,numinstance); +0094 +0095 % ---- Multi-class ----- % +0096 tic +0097 [label,scores,cost] = predict(MLTREE.models{1},instance); +0098 MLTREE.totalTime = MLTREE.totalTime + toc; +0099 MLTREE.totalCount = MLTREE.totalCount + numinstance; +0100 % ---- One (vs) All -----% +0101 % for i=1:numModels +0102 % %predict using the stored models +0103 % [label,score,cost] = predict(LDA.models{i},instance); +0104 % %libsvmpredict(eye(numinstance,1),instance, LSVM.models{i},'-b 1 -q'); +0105 % %store probability for each class +0106 % scores(i,:) = score(:,1); +0107 % end +0108 +0109 output = zeros(numinstance,1); +0110 probabilities = zeros(numinstance,1); +0111 %we need these for ranking metrics (e.g. mAP) +0112 ranking = scores; +0113 for i=1:numinstance +0114 %select the class with the highest probability +0115 [prob, idx] = max(scores(i,:)); +0116 uniqueLabels = unique(MLTREE.instanceSet.getLabels); +0117 %output the label with highest probability +0118 output(i,1) = uniqueLabels(idx); +0119 %return the probability for the output label +0120 probabilities(i,1) = prob; +0121 end +0122 end +0123 +0124 function MLTREE = reset(MLTREE) +0125 %delete all stored models +0126 MLTREE.models = {}; +0127 end +0128 +0129 function configInfo = getConfigInfo(MLTREE) +0130 configInfo = 'MLTREE (Config info not supported yet)'; +0131 end +0132 +0133 +0134 function time = getTime(MLTREE) +0135 time = MLTREE.totalTime/MLTREE.totalCount; +0136 end +0137 +0138 end +0139 end +0140
| Master index |
+Index for +eegtoolkit/+classification/@MLTREE |
+
+| Master index |
+Index for +eegtoolkit/+classification/@MLTREE |
| MLTREE |
0001 classdef MLTboxMulticlass < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 Learners; %'discriminant': Discriminant analysis. | 'knn': k-nearest neighbors. | 'naivebayes': Naive Bayes. +0009 % 'svm': SVM. | 'tree': Classification trees. | any Matlab template classifier +0010 Coding; % Coding design 'onevsall' (default) | 'allpairs' | 'binarycomplete' | 'denserandom' | 'onevsone' | 'ordinal' | 'sparserandom' | 'ternarycomplete' | numeric matrix +0011 FitPosterior; % Flag indicating whether to transform scores to posterior probabilities false or 0 (default) | true or 1 +0012 Prior % 'empirical' (default) or 'uniform'. Prior probabilities for each class. +0013 models; +0014 totalTime; +0015 totalCount; +0016 end +0017 +0018 methods (Access = public) +0019 function MLC = MLTboxMulticlass(instanceSet, learners, coding, fitPosterior, prior) +0020 %set default parameters +0021 MLC.Learners = 'svm'; +0022 MLC.Coding='onevsall'; +0023 MLC.FitPosterior='off'; +0024 MLC.Prior='empirical'; +0025 +0026 if nargin > 0 +0027 MLC.instanceSet = instanceSet; +0028 end +0029 if nargin > 1 +0030 MLC.Learners = learners; +0031 end +0032 if nargin > 2 +0033 MLC.Coding=coding; +0034 end +0035 if nargin > 3 +0036 MLC.FitPosterior=fitPosterior; +0037 end +0038 if nargin > 4 +0039 MLC.Prior=prior; +0040 end +0041 MLC.totalTime = 0; +0042 MLC.totalCount = 0; +0043 end +0044 +0045 function MLC = build(MLC) +0046 %clear all from previous calls to "build" +0047 MLC.reset; +0048 numLabels = MLC.instanceSet.getNumLabels; +0049 uniqueLabels = unique(MLC.instanceSet.getLabels); +0050 +0051 % ---- Multi-Class ----- % +0052 instances=MLC.instanceSet.instances; +0053 labels=MLC.instanceSet.labels; +0054 +0055 %t=templateSVM('KernelFunction','linear'); +0056 MLC.models{1}=fitcecoc(instances,labels,'Coding', MLC.Coding,'FitPosterior', MLC.FitPosterior,'Prior',MLC.Prior,'Learners',MLC.Learners); +0057 end +0058 +0059 function [output, probabilities, ranking] = classifyInstance(MLC,instance) +0060 +0061 %TODO:should print an error if 'build' has not been called +0062 numModels = length(MLC.models); +0063 [numinstance, ~] = size(instance); +0064 %scores = zeros(numModels,numinstance); +0065 +0066 % ---- Multi-class ----- % +0067 tic +0068 [label,scores,loss] = predict(MLC.models{1},instance); +0069 MLC.totalTime = MLC.totalTime + toc; +0070 MLC.totalCount = MLC.totalCount + numinstance; +0071 output = zeros(numinstance,1); +0072 probabilities = zeros(numinstance,1); +0073 %we need these for ranking metrics (e.g. mAP) +0074 ranking = scores; +0075 for i=1:numinstance +0076 %select the class with the highest probability +0077 [prob, idx] = max(scores(i,:)); +0078 uniqueLabels = unique(MLC.instanceSet.getLabels); +0079 %output the label with highest probability +0080 output(i,1) = uniqueLabels(idx); +0081 %return the probability for the output label +0082 probabilities(i,1) = prob; +0083 end +0084 end +0085 +0086 function MLC = reset(MLC) +0087 %delete all stored models +0088 MLC.models = {}; +0089 end +0090 +0091 function configInfo = getConfigInfo(MLC) +0092 configInfo=sprintf('MLTboxMulticlass\tCoding:%s\tFitPosterior:%s\tPrior:%s\n\tLearners:', MLC.Coding, MLC.FitPosterior,MLC.Prior); +0093 disp(MLC.Learners) +0094 %configInfo = 'MLSVMClassifier (Config info not supported yet)'; +0095 end +0096 +0097 +0098 function time = getTime(MLC) +0099 time = MLC.totalTime/MLC.totalCount; +0100 end +0101 +0102 end +0103 end +0104
| Master index |
+Index for +eegtoolkit/+classification/@MLTboxMulticlass |
+
+| Master index |
+Index for +eegtoolkit/+classification/@MLTboxMulticlass |
| MLTboxMulticlass |
0001 classdef MaxChooser < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 +0009 end +0010 +0011 methods (Access = public) +0012 function MaxChooser =MaxChooser(instanceSet) +0013 if nargin > 0 +0014 MaxChooser.instanceSet = instanceSet; +0015 end +0016 +0017 end +0018 +0019 function MaxChooser = build(MaxChooser) +0020 +0021 end +0022 +0023 function [output, probabilities, ranking] = classifyInstance(MaxChooser,instance) +0024 +0025 dd_ins=instance; +0026 N = size(instance,1); +0027 pred_lab=zeros(N,1); +0028 for i=1:N +0029 [v,idx]=max(dd_ins(i,:)); +0030 pred_lab(i)=idx; +0031 ranking(i,:) = dd_ins(i,:); +0032 end +0033 +0034 output = pred_lab;%sum(pred_lab)/length(pred_lab) +0035 probabilities=zeros(N,1); +0036 % ranking=zeros(N,1); +0037 end +0038 +0039 function MaxChooser = reset(MaxChooser) +0040 %delete all stored models +0041 end +0042 +0043 function configInfo = getConfigInfo(MaxChooser) +0044 configInfo = sprintf('MaxChooser'); +0045 end +0046 +0047 +0048 function time = getTime(MaxChooser) +0049 time = 0; +0050 end +0051 +0052 end +0053 end +0054
| Master index |
+Index for +eegtoolkit/+classification/@MaxChooser |
+
+| Master index |
+Index for +eegtoolkit/+classification/@MaxChooser |
| MaxChooser |
0001 classdef SBLR < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties +0008 %Coding; % Coding design 'onevsall' (default) | 'allpairs' | 'binarycomplete' | 'denserandom' | 'onevsone' | 'ordinal' | 'sparserandom' | 'ternarycomplete' | numeric matrix +0009 %FitPosterior; % Flag indicating whether to transform scores to posterior probabilities false or 0 (default) | true or 1 +0010 %Prior % 'empirical' (default) or 'uniform'. Prior probabilities for each class. +0011 models; +0012 Wmatrix; +0013 end +0014 +0015 methods (Access = public) +0016 function SBLR = SBLR(instanceSet) +0017 %set default parameters +0018 if nargin > 0 +0019 SBLR.instanceSet = instanceSet; +0020 end +0021 end +0022 +0023 function SBLR = build(SBLR) +0024 %clear all from previous calls to "build" +0025 SBLR.reset; +0026 numLabels = SBLR.instanceSet.getNumLabels; +0027 uniqueLabels = unique(SBLR.instanceSet.getLabels); +0028 +0029 % ---- Multi-Class ----- % +0030 instances=SBLR.instanceSet.instances; +0031 labels=SBLR.instanceSet.labels; +0032 [~,Nfeat] = size(instances) +0033 size(instances) +0034 %X = instances*instances; +0035 %[w, ix_eff, W, AX] = slr_learning_var2(labels, instances,'nlearn', 100, 'nstep', 10); +0036 [w, ix_eff, W, AXall] = smlr_learning(labels, instances, Nfeat,'nlearn', 0,'gamma0', 0);%,... +0037 %'wdisp_mode', 'off', 'nlearn',10,'mean_mode', 'none', 'scale_mode', 'none');%, ... +0038 %'wdisplay', wdisp_mode, 'wmaxiter', wmaxiter', 'nlearn', Nlearn, 'nstep', Nstep,... +0039 %'amax', AMAX, 'isplot', isplot', 'gamma0', gamma0); +0040 +0041 SBLR.Wmatrix = reshape(w, [Nfeat, 5]); +0042 +0043 end +0044 +0045 function [output, probabilities, ranking] = classifyInstance(SBLR,instance) +0046 %input = instance matrix rows = instances, cols = attributes +0047 %output = predicted class +0048 %probabilities = probability for predicted class +0049 %ranking = propabilities for all classes (e.g. to use with mAP) +0050 +0051 +0052 %TODO:should print an error if 'build' has not been called +0053 % numModels = length(MLSVM.models); +0054 [numinstance, ~] = size(instance); +0055 %scores = zeros(numModels,numinstance); +0056 +0057 [output, Pte] = calc_label(instance, SBLR.Wmatrix); +0058 % ---- One (vs) All -----% +0059 % for i=1:numModels +0060 % %predict using the stored models +0061 % [label,score,cost] = predict(LDA.models{i},instance); +0062 % %libsvmpredict(eye(numinstance,1),instance, LSVM.models{i},'-b 1 -q'); +0063 % %store probability for each class +0064 % scores(i,:) = score(:,1); +0065 % end +0066 +0067 ranking=zeros(5,1)'; +0068 probabilities=0; +0069 end +0070 +0071 function SBLR = reset(SBLR) +0072 %delete all stored models +0073 SBLR.models = {}; +0074 SBLR.Wmatrix=[]; +0075 end +0076 +0077 function configInfo = getConfigInfo(SBLR) +0078 +0079 configInfo = 'SBLR_Classifier (Config info not supported yet)'; +0080 end +0081 +0082 function time = getTime(MLR_Classifier) +0083 time = 0; +0084 end +0085 +0086 end +0087 end +0088
| Master index |
+Index for +eegtoolkit/+classification/@SBLR |
+
+| Master index |
+Index for +eegtoolkit/+classification/@SBLR |
| SBLR |
0001 classdef SMFA < eegtoolkit.classification.ClassifierBase +0002 +0003 properties (Constant) +0004 +0005 end +0006 +0007 properties (Access = public) +0008 W_SMFA; +0009 PCA_mat; +0010 trainFeat; +0011 NumSubclasses; +0012 SigmaCoeff; +0013 kInt; +0014 kPen; +0015 end +0016 +0017 methods (Access = public) +0018 function SMFA = SMFA(instanceSet,NumS,S,kInt,kPen)%,NumSubclasses,SigmaCoeff,kInt,kPen) +0019 if nargin == 1 +0020 SMFA.instanceSet = instanceSet; +0021 else +0022 SMFA.NumSubclasses = NumS; +0023 SMFA.SigmaCoeff = S; +0024 SMFA.kInt = kInt; +0025 SMFA.kPen = kPen; +0026 end +0027 +0028 end +0029 +0030 +0031 function SMFA = build(SMFA) +0032 SMFA.reset(); +0033 data = SMFA.instanceSet.getInstances; +0034 data = data'; +0035 labels = SMFA.instanceSet.getLabels; +0036 unique(labels) +0037 numTrials = length(labels); +0038 +0039 PCA_W=SMFA.pca_func(data); +0040 % PCA_W=eye(size(data,1)); +0041 train_Data=PCA_W'*data; +0042 +0043 % Sigma = SMFA_Classifier.SigmaCoeff; +0044 NSubClasses = SMFA.NumSubclasses; +0045 D=pdist2(train_Data',train_Data'); +0046 % STrain = SGE_GramMatrix(train_Data,'gau',Sigma*mean(D(:))); +0047 STrain = 1-(D/max(D(:))); +0048 +0049 pt=0; +0050 ct=0; +0051 ClustersOfClasses = SGE_SubclassExtract(train_Data,labels,NSubClasses,pt,ct); +0052 [yyTrain,~,~] = SGE_SubclassLabels(ClustersOfClasses,labels); +0053 +0054 +0055 Par.mode = 'SMFA'; +0056 Par.SimilMatrix = STrain; +0057 Par.kInt = SMFA.kInt; +0058 Par.kPen = SMFA.kPen; +0059 dim = min([Par.kPen,size(train_Data,1)]); +0060 +0061 [W,Wp] = SGE_GraphConstruct(yyTrain,Par); +0062 [TransMatrix,~] = SGE_Mapping(train_Data,dim,W,Wp); +0063 SMFA.W_SMFA = TransMatrix; +0064 SMFA.PCA_mat=PCA_W; +0065 mtrainFeat=SGE_Projection(train_Data,1:dim,TransMatrix); +0066 SMFA.trainFeat=mtrainFeat; +0067 % figure,gplotmatrix(mtrainFeat',[],labels) +0068 end +0069 +0070 function [output, probabilities, ranking] = classifyInstance(SMFA,instance) +0071 +0072 N = size(instance,1); +0073 instance = instance'; +0074 +0075 test_Data=SMFA.PCA_mat'*instance; +0076 % test_Data=[ones(1,N);test_Data]; +0077 testFeat=SMFA.W_SMFA'*test_Data; +0078 % output=knnclassify(testFeat',SMFA_Classifier.trainFeat',SMFA_Classifier.instanceSet.getLabels,5,'euclidean'); +0079 X = SMFA.trainFeat; +0080 y = SMFA.instanceSet.getLabels; +0081 +0082 %Nearest Centroid +0083 [~,output] = SGE_Classification(X,y',testFeat,0,'euc'); +0084 +0085 % %SVM Linear +0086 % [~,output] = SGE_Classification(X,y',testFeat,[1,1,1,0,1],'euc'); +0087 +0088 % %SVM RBF +0089 % [~,output] = SGE_Classification(X,y',testFeat,[2,3,2/size(X,1),0,1],'euc'); +0090 +0091 output = output(1,:)'; +0092 probabilities=zeros(N,1); +0093 ranking=zeros(N,1); +0094 % figure,gplotmatrix(testFeat',[],output) +0095 +0096 end +0097 +0098 function SMFA = reset(SMFA) +0099 %delete all stored models +0100 SMFA.W_SMFA=[]; +0101 SMFA.PCA_mat=[]; +0102 SMFA.trainFeat=[]; +0103 end +0104 +0105 function configInfo = getConfigInfo(SMFA) +0106 configInfo = sprintf('MLR_Classifier'); +0107 end +0108 +0109 +0110 function time = getTime(SMFA) +0111 +0112 end +0113 +0114 end +0115 methods (Access = private) +0116 function Proj_W=pca_func(MLR,data) +0117 Proj_W=[]; +0118 meanData=mean(data,2); +0119 data=data-repmat(meanData,1,size(data,2)); +0120 % stdVar=std(data')'; +0121 % staData=(data-repmat(meanData,1,size(data,2)))./repmat(stdVar,1,size(data,2)); +0122 % data=staData; +0123 [V,S]=eig(data'*data); +0124 [sorted_diagS,sorted_rank]=sort(diag(S),'descend'); +0125 sorted_S=diag(sorted_diagS); +0126 V=V(:,sorted_rank); +0127 r=rank(sorted_S); +0128 S1=sorted_S(1:r,1:r); +0129 V1=V(:,1:r); +0130 U=data*V1*S1^(-0.5); +0131 %[sorted_S,sorted_rank]=sort(diag(S),'descend'); +0132 All_energy=sum(diag(S1)); +0133 sorted_energy=diag(S1); +0134 for j=1:r +0135 if (sum(sorted_energy(1:j))/All_energy)>0.99 +0136 break +0137 end +0138 end +0139 Proj_W=U(:,1:j); +0140 end +0141 end +0142 end +0143
| Master index |
+Index for +eegtoolkit/+classification/@SMFA |
+
+| Master index |
+Index for +eegtoolkit/+classification/@SMFA |
| SMFA |
EXPERIMENTER class
+ Wraps all the necessary objects for performing an experiment.
+Before running an experiment all the required properties must be set.
+ Required:
+ - session
+ - featextraction
+ - evalMethod
+ - classification
+ Optional:
+ - featselection
+ - aggregator
+ - preprocessing
+
+ to run the experiment execute the "run()" method.
+ Example:
+ experiment = eegtoolkit.experiment.Experimenter;
+ experiment.session = eegtoolkit.util.Session;
+ experiment.session.loadSubject(1);
+ experiment.transformer = eegtoolkit.featextraction.PWelch;
+ experiment.extractor = eegtoolkit.featselection.FEAST;
+ experiment.classification = eegtoolkit.classification.LIBSVM;
+ experiment.evalMethod = experiment.evalMethod.EVAL_METHOD_LOSO;
+ experiment.run;
+ results = experiment.results;
+ confmatrix = results{1}.getConfusionMatrix;0001 % EXPERIMENTER class +0002 % Wraps all the necessary objects for performing an experiment. +0003 %Before running an experiment all the required properties must be set. +0004 % Required: +0005 % - session +0006 % - featextraction +0007 % - evalMethod +0008 % - classification +0009 % Optional: +0010 % - featselection +0011 % - aggregator +0012 % - preprocessing +0013 % +0014 % to run the experiment execute the "run()" method. +0015 % Example: +0016 % experiment = eegtoolkit.experiment.Experimenter; +0017 % experiment.session = eegtoolkit.util.Session; +0018 % experiment.session.loadSubject(1); +0019 % experiment.transformer = eegtoolkit.featextraction.PWelch; +0020 % experiment.extractor = eegtoolkit.featselection.FEAST; +0021 % experiment.classification = eegtoolkit.classification.LIBSVM; +0022 % experiment.evalMethod = experiment.evalMethod.EVAL_METHOD_LOSO; +0023 % experiment.run; +0024 % results = experiment.results; +0025 % confmatrix = results{1}.getConfusionMatrix; +0026 classdef Experimenter < handle +0027 properties (Constant) +0028 EVAL_METHOD_LOOCV = 0; % Leave One Out Cross-Validation +0029 EVAL_METHOD_LOSO = 1; % Leave One Subject Out +0030 EVAL_METHOD_LOBO = 2; +0031 EVAL_METHOD_SPLIT = 3; +0032 EVAL_METHOD_XFOLD_CV = 4; +0033 EVAL_METHOD_LOSO_LOBO = 5; +0034 end +0035 +0036 properties (Access = public) +0037 session; % The Session object. Trials must be loaded before run() is executed +0038 preprocessing; +0039 featextraction; % A transformer object +0040 aggregator; +0041 featselection; % An extractor object +0042 evalMethod; % The evaluation method +0043 classification; % A classifier object +0044 results; % A cell array containing objects of the 'ResultEvaluator' class. +0045 trainresults; +0046 subjectids; +0047 sessionids; +0048 end +0049 +0050 methods +0051 function E = Experimenter(evalMethod) +0052 if nargin > 0 +0053 E.evalMethod = evalMethod; +0054 else E.evalMethod = 0; +0055 end +0056 E.results = {}; +0057 end +0058 function E = run(E,varargin) +0059 if(length(varargin)==1) +0060 numFolds = varargin{1}; +0061 elseif(length(varargin)==2) +0062 trainIDx = varargin{1}; +0063 testIDx = varargin{2}; +0064 end +0065 % Runs an experiment +0066 E.checkCompatibility; +0067 E.subjectids = E.session.subjectids; +0068 E.sessionids = E.session.sessionids; +0069 trials = {}; +0070 for i=1:length(E.session.trials) +0071 trials{i} = eegtoolkit.util.Trial(E.session.trials{i}.signal,... +0072 E.session.trials{i}.label,E.session.trials{i}.samplingRate,E.session.trials{i}.subjectid,E.session.trials{i}.sessionid,E.session.trials{i}.type); +0073 end +0074 if ~isempty(E.preprocessing) +0075 for i=1:length(E.preprocessing) +0076 if isa(E.preprocessing{i},'eegtoolkit.preprocessing.Windsorize') +0077 E.preprocessing{i}.subjectids = E.subjectids; +0078 end +0079 trials = E.preprocessing{i}.process(trials); +0080 end +0081 end +0082 disp('feature extraction ...'); +0083 if iscell(E.featextraction) +0084 numExtract = length(E.featextraction); +0085 for i=1:numExtract +0086 E.featextraction{i}.trials = trials; +0087 E.featextraction{i}.extract; +0088 end +0089 E.aggregator.featextractors = E.featextraction; +0090 E.aggregator.aggregate; +0091 instanceSet = E.aggregator.instanceSet; +0092 else +0093 E.featextraction.trials = trials; +0094 E.featextraction.extract; +0095 instanceSet = E.featextraction.getInstanceSet; +0096 end +0097 if ~isempty(E.featselection) +0098 E.featselection.originalInstanceSet = instanceSet; +0099 disp('feature selection ...'); +0100 E.featselection.compute; +0101 E.classification.instanceSet = E.featselection.filteredInstanceSet; +0102 else +0103 E.classification.instanceSet = instanceSet; +0104 end +0105 disp('evaluating..'); +0106 switch E.evalMethod +0107 case E.EVAL_METHOD_LOOCV +0108 E.leaveOneOutCV(); +0109 case E.EVAL_METHOD_LOSO +0110 subjects = unique(E.subjectids); +0111 instanceSet = E.classification.instanceSet; +0112 if isa(E.classification,'eegtoolkit.classification.LIBSVMFast') +0113 instanceSet.K = instanceSet.computeKernel(E.classification.kernel,E.classification.gamma,E.classification.maxlag,E.classification.scaleopt); +0114 end +0115 for i=1:length(subjects) +0116 fprintf('leaving subject #%d out\n', i); +0117 if isa(E.classification,'eegtoolkit.classification.LIBSVMFast') +0118 E.leaveOneSubjectOutFast(subjects(i), instanceSet); +0119 else +0120 +0121 E.leaveOneSubjectOut(subjects(i), instanceSet); +0122 end +0123 +0124 end +0125 case E.EVAL_METHOD_LOBO +0126 sessions = unique(E.sessionids); +0127 instanceSet = E.classification.instanceSet; +0128 for i=1:length(sessions) +0129 fprintf('leaving session #%d out\n', i); +0130 E.leaveOneSessionOut(sessions(i), instanceSet); +0131 end +0132 case E.EVAL_METHOD_SPLIT +0133 instanceSet = E.classification.instanceSet; +0134 E.splitTest(trainIDx,testIDx,instanceSet); +0135 case E.EVAL_METHOD_XFOLD_CV +0136 instanceSet = E.classification.instanceSet; +0137 E.kfoldCrossValidation(instanceSet,numFolds); +0138 case E.EVAL_METHOD_LOSO_LOBO +0139 instanceSet = E.classification.instanceSet; +0140 E.leaveOneSubjectOutLeaveOneBlockOut(instanceSet); +0141 otherwise +0142 error ('eval method not set or invalid'); +0143 end +0144 end +0145 +0146 function itrs = getITR(E) +0147 for i=1:length(E.preprocessing) +0148 if isa(E.preprocessing{i},'eegtoolkit.preprocessing.SampleSelection') +0149 %T = time in seconds; +0150 T = (E.preprocessing{i}.sampleRange(2)-E.preprocessing{i}.sampleRange(1)+1)/E.preprocessing{i}.samplingRate; +0151 end +0152 end +0153 if isempty(T) +0154 error('to calculate ITR the SampleSelection preprocessing step must be added to the experiment'); +0155 end +0156 for i=1:length(E.results) +0157 itrs(i) = E.results{i}.getITR(T); +0158 end +0159 end +0160 function time = getTime(E) +0161 info = 'Average time elapsed for trial:\n'; +0162 total = 0; +0163 if ~isempty(E.preprocessing) +0164 info = strcat(info, 'Preprocessing:\n'); +0165 for i=1:length(E.preprocessing) +0166 info = strcat(info, num2str(E.preprocessing{i}.getTime)); +0167 total = total + E.preprocessing{i}.getTime; +0168 info = strcat(info, '\n'); +0169 end +0170 end +0171 if ~isempty(E.featextraction) +0172 info = strcat(info, 'Feature Extraction:\n'); +0173 if ~iscell(E.featextraction) +0174 info = strcat(info, num2str(E.featextraction.getTime)); +0175 total = total + E.featextraction.getTime; +0176 info = strcat(info, '\n'); +0177 else +0178 for i=1:length(E.featextraction) +0179 info = strcat(info, num2str(E.featextraction{i}.getTime)); +0180 total = total + E.featextraction{i}.getTime; +0181 info = strcat(info,'\n'); +0182 end +0183 end +0184 end +0185 if ~isempty(E.aggregator) +0186 info = strcat(info, 'Aggregation:\n'); +0187 info = strcat(info, num2str(E.aggregator.getTime)); +0188 total = total + E.aggregator.getTime; +0189 info = strcat(info, '\n'); +0190 end +0191 if ~isempty(E.featselection) +0192 info = strcat(info, 'FeatureSelection:\n'); +0193 info = strcat(info, num2str(E.featselection.getTime)); +0194 total = total + E.featselection.getTime; +0195 info = strcat(info, '\n'); +0196 end +0197 if ~isempty(E.classification) +0198 info = strcat(info, 'Classification (Prediction):\n'); +0199 info = strcat(info, num2str(E.classification.getTime)); +0200 total = total + E.classification.getTime; +0201 info = strcat(info, '\n'); +0202 end +0203 info = strcat(info, 'Total:\n'); +0204 info = strcat(info, num2str(total)); +0205 time = sprintf(info); +0206 end +0207 +0208 function info = getExperimentInfo(E) +0209 % Prints the configuration info of the experiment +0210 info = 'Experiment Configuration:\n'; +0211 if ~isempty(E.preprocessing) +0212 for i=1:length(E.preprocessing) +0213 info = strcat(info, E.preprocessing{i}.getConfigInfo); +0214 info = strcat(info,'\n'); +0215 end +0216 end +0217 if ~isempty(E.featextraction) +0218 if ~iscell(E.featextraction) +0219 info = strcat(info, E.featextraction.getConfigInfo); +0220 info = strcat(info,'\n'); +0221 else +0222 for i=1:length(E.featextraction) +0223 info = strcat(info, E.featextraction{i}.getConfigInfo); +0224 info = strcat(info,'\n'); +0225 end +0226 end +0227 end +0228 if ~isempty(E.aggregator) +0229 info = strcat(info, E.aggregator.getConfigInfo); +0230 info = strcat(info, '\n'); +0231 end +0232 if ~isempty(E.featselection) +0233 info = strcat(info, E.featselection.getConfigInfo); +0234 info = strcat(info, '\n'); +0235 end +0236 if ~isempty(E.classification) +0237 info = strcat(info, E.classification.getConfigInfo); +0238 info = strcat(info, '\n'); +0239 end +0240 info = sprintf(info); +0241 end +0242 +0243 end +0244 +0245 methods (Access = private) +0246 +0247 function E = checkCompatibility(E) +0248 if iscell(E.featextraction) +0249 if isempty(E.aggregator) +0250 error ('Provided many feature extractors but not an Aggregator'); +0251 end +0252 end +0253 if isa(E.classification,'eegtoolkit.classification.LIBSVMFast') && E.evalMethod == 0 +0254 error('LIBSVMFast not supported for LOOCV eval method'); +0255 end +0256 end +0257 +0258 function E = leaveOneOutCV(E) +0259 %leave one out cross validation +0260 instanceSet = E.classification.instanceSet; +0261 numInstances = instanceSet.getNumInstances; +0262 outputLabels = zeros(numInstances,1); +0263 outputScores = zeros(numInstances,1); +0264 outputRanking = zeros(numInstances, instanceSet.getNumLabels); +0265 h = waitbar(0,'Cross-validating..'); +0266 for i=1:numInstances +0267 waitbar(i/numInstances,h,sprintf('Cross-validating fold: %d/%d', i, numInstances)); +0268 %train the classifier without 1 instance +0269 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(i); +0270 E.classification.build(); +0271 %predict the label of the omitted instance +0272 [outputLabels(i,1), outputScores(i,1), outputRanking(i,:)] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(i)); +0273 end +0274 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDataset, outputLabels, outputScores, outputRanking); +0275 E.results{length(E.results)+1} = eegtoolkit.experiment.ResultEvaluator(resultSet); +0276 close(h); +0277 end +0278 +0279 function E = kfoldCrossValidation(E,instanceSet,numFolds) +0280 numInstances = instanceSet.getNumInstances; +0281 indices = crossvalind('Kfold', numInstances, numFolds); +0282 outputLabels = zeros(numInstances,1); +0283 outputScores = zeros(numInstances,1); +0284 outputRanking = zeros(numInstances,instanceSet.getNumLabels); +0285 h = waitbar(0,'Cross-validating..'); +0286 for i=1:numFolds +0287 waitbar(i/numFolds,h,sprintf('Cross-validating fold: %d/%d',i,numFolds)); +0288 testSet = find(indices==i); +0289 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(testSet); +0290 E.classification.build(); +0291 +0292 [outputLabels(testSet,1), outputScores(testSet,1), outputRanking(testSet,:)] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(testSet)); +0293 end +0294 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDataset, outputLabels, outputScores, outputRanking); +0295 E.results{length(E.results)+1} = eegtoolkit.experiment.ResultEvaluator(resultSet); +0296 close(h); +0297 end +0298 +0299 function resultSet = leaveOneSubjectOut(E, subjectid, instanceSet) +0300 testingset = find(E.subjectids == subjectid); +0301 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(testingset); +0302 E.classification.build(); +0303 [outputLabels, outputScores, outputRanking] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(testingset)); +0304 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(testingset), outputLabels, outputScores, outputRanking); +0305 E.results{length(E.results)+1} = eegtoolkit.experiment.ResultEvaluator(resultSet); +0306 end +0307 +0308 +0309 function resultSet = leaveOneSubjectOutLeaveOneBlockOut(E, instanceSet) +0310 subjects = unique(E.subjectids); +0311 sessions = unique(E.sessionids); +0312 for i=1:length(subjects) +0313 numInstancesForSubject = sum(E.subjectids==subjects(i)); +0314 outputLabels = zeros(numInstancesForSubject,1); +0315 outputScores = zeros(numInstancesForSubject,1); +0316 outputRanking = zeros(numInstancesForSubject,instanceSet.getNumLabels()); +0317 for j=1:length(sessions) +0318 % tempResults{j} = E.leaveOneSessionOut(sessions(j),tempInstanceSet); +0319 sessionidsSubset = E.sessionids(E.subjectids==subjects(i)); +0320 testIndices = sessionidsSubset==sessions(j); +0321 numInstancesForSession = sum(E.sessionids==sessions(j)&E.subjectids==subjects(i)); +0322 testingset = find(E.sessionids==sessions(j)&E.subjectids==subjects(i)); +0323 nottrainset = find(E.sessionids==sessions(j)|E.subjectids~=subjects(i)); +0324 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(nottrainset); +0325 E.classification.build(); +0326 [outputLabels(testIndices,:), outputScores(testIndices,:), outputRanking(testIndices,:)] = ... +0327 E.classification.classifyInstance(instanceSet.getInstancesWithIndices(testingset)); +0328 +0329 end +0330 sIndices = find(E.subjectids==subjects(i)); +0331 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(sIndices),outputLabels,outputScores,outputRanking); +0332 E.results{length(E.results)+1} = eegtoolkit.experiment.ResultEvaluator(resultSet); +0333 %merge the results +0334 end +0335 end +0336 +0337 +0338 function resultSet = leaveOneSessionOut(E, sessionId, instanceSet) +0339 testingset = find(E.sessionids == sessionId); +0340 trainset = find(E.sessionids ~= sessionId); +0341 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(testingset); +0342 E.classification.build(); +0343 [outputLabels, outputScores, outputRanking] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(testingset)); +0344 [trainoutputLabels, trainoutputScores, trainoutputRanking] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(trainset)); +0345 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(testingset), outputLabels, outputScores, outputRanking); +0346 trainresultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(trainset), trainoutputLabels, trainoutputScores, trainoutputRanking); +0347 E.results{length(E.results)+1} = eegtoolkit.experiment.ResultEvaluator(resultSet); +0348 E.trainresults{length(E.trainresults)+1} = eegtoolkit.experiment.ResultEvaluator(trainresultSet); +0349 end +0350 +0351 function resultSet = leaveOneSubjectOutFast(E, subjectid, instanceSet) +0352 testingset = E.subjectids == subjectid; +0353 E.classification.Ktrain = instanceSet.getTrainKernel(~testingset); +0354 E.classification.Ktest = instanceSet.getTestKernel(~testingset,testingset); +0355 testingset = find(E.subjectids == subjectid); +0356 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(testingset); +0357 E.classification.build(); +0358 [outputLabels, outputScores, outputRanking] = E.classification.classifyInstance(); +0359 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(testingset), outputLabels, outputScores, outputRanking); +0360 resultEvaluator = eegtoolkit.experiment.ResultEvaluator(resultSet); +0361 resultEvaluator.subjectid = E.subjectids(E.subjectids==subjectid); +0362 resultEvaluator.sessionid = E.session.sessionids(E.subjectids==subjectid); +0363 E.results{length(E.results)+1} = resultEvaluator; +0364 end +0365 +0366 function resultSet = splitTest(E,trainIDx,testIDx, instanceSet) +0367 E.classification.instanceSet = instanceSet.removeInstancesWithIndices(testIDx); +0368 E.classification.build(); +0369 [outputLabels, outputScores, outputRanking] = E.classification.classifyInstance(instanceSet.getInstancesWithIndices(testIDx)); +0370 resultSet = eegtoolkit.util.ResultSet(instanceSet.getDatasetWithIndices(testIDx), outputLabels, outputScores, outputRanking); +0371 resultEvaluator = eegtoolkit.experiment.ResultEvaluator(resultSet); +0372 E.results{length(E.results) + 1} = resultEvaluator; +0373 end +0374 +0375 +0376 +0377 +0378 end +0379 +0380 end +0381
| Master index |
+Index for +eegtoolkit/+experiment/@Experimenter |
+
+| Master index |
+Index for +eegtoolkit/+experiment/@Experimenter |
| Experimenter | EXPERIMENTER class |
RESULTEVALUATOR class + Parses the results of an experiment and calculates various metrics
0001 % RESULTEVALUATOR class +0002 % Parses the results of an experiment and calculates various metrics +0003 classdef ResultEvaluator < handle +0004 properties +0005 resultSet; % A 'ResultSet' object containing the results of an experiment +0006 subjectid; % The subject ids corresponding +0007 sessionid; +0008 end +0009 +0010 methods +0011 function RE = ResultEvaluator(resultSet) +0012 if nargin > 0 +0013 RE.resultSet = resultSet; +0014 end +0015 end +0016 +0017 function acc = getAccuracy(RE) +0018 conf = RE.resultSet.confusionMatrix; +0019 acc = sum(diag(conf))/sum(sum(conf))*100; +0020 end +0021 +0022 function confusionMatrix = getConfusionMatrix(RE) +0023 %Returns the confusion matrix with labels as the last row +0024 %if you want the confusion matrix without labels then +0025 %access the confusionMatrix property of the resultSet directly +0026 labels = unique(RE.resultSet.getLabels); +0027 confusionMatrix = horzcat(RE.resultSet.confusionMatrix, labels); +0028 end +0029 +0030 function acc = getAccuracyForSession(RE,session) +0031 conf = RE.resultSet.subset(RE.sessionid==session).confusionMatrix; +0032 acc = sum(diag(conf))/sum(sum(conf))*100; +0033 end +0034 +0035 function accuracies = getAccuracyBySession(RE) +0036 unsessions = unique(RE.sessionid); +0037 for i=1:length(unsessions) +0038 accuracies(i) = RE.getAccuracyForSession(unsessions(i)); +0039 end +0040 end +0041 +0042 function accuracies = getAccuracyByLabel(RE) +0043 [rows,~] = size(RE.resultSet.confusionMatrix); +0044 for i=1:rows +0045 accuracies(i) = RE.resultSet.confusionMatrix(i,i)/sum(RE.resultSet.confusionMatrix(i,:))*100; +0046 end +0047 end +0048 +0049 +0050 function ITR = getITR(RE,T) +0051 P = RE.getAccuracy/100; +0052 M = RE.resultSet.getNumLabels; +0053 % fprintf('T = %f',T); +0054 % fprintf('P = %f',P); +0055 % fprintf('M = %f',M); +0056 % fprintf('\n'); +0057 ITR = (log2(M) + P*log2(P)+(1-P)*log2((1-P)/(M-1)))/T; +0058 end +0059 +0060 % function TP = getNumTruePositives(RE) +0061 % conf = RE.resultSet.confusionMatrix; +0062 % TP = diag(conf)'; +0063 % end +0064 % +0065 % function TN = getNumTrueNegatives(RE) +0066 % numInstances = RE.resultSet.getNumInstances; +0067 % FN = RE.getNumFalseNegatives; +0068 % TP = RE.getNumTruePositives; +0069 % FP = RE.getNumFalsePositives; +0070 % TN = numInstances - FN - TP - FP; +0071 % end +0072 % +0073 % function FP = getNumFalsePositives(RE) +0074 % conf = RE.resultSet.confusionMatrix; +0075 % FP = sum(conf') - diag(conf)'; +0076 % end +0077 % +0078 % function FN = getNumFalseNegatives(RE) +0079 % conf = RE.resultSet.confusionMatrix; +0080 % FN = sum(conf) - diag(conf)'; +0081 % end +0082 +0083 end +0084 end +0085
| Master index |
+Index for +eegtoolkit/+experiment/@ResultEvaluator |
+
+| Master index |
+Index for +eegtoolkit/+experiment/@ResultEvaluator |
| ResultEvaluator | RESULTEVALUATOR class |
0001 classdef CCA < eegtoolkit.featextraction.PSDExtractionBase%FeatureExtractionBase +0002 % +0003 % works only on our datasets, for other datasets needs modifications +0004 % +0005 properties (Access = public) +0006 channel; +0007 avgTime; +0008 stimulus_freqs; +0009 FreqSamp; +0010 NumHarm; +0011 allFeatures; +0012 end +0013 methods (Access = public) +0014 function CCA = CCA(sti_f,chans,fs,numH) +0015 if ( nargin ~= 4 ) +0016 error('It is needed to define the simulus freqs, the channels, frequency sampling and number of harmonics'); +0017 else +0018 CCA.stimulus_freqs = sti_f; +0019 CCA.channel = chans; +0020 CCA.FreqSamp = fs; +0021 CCA.NumHarm = numH; +0022 CCA.allFeatures = 0; +0023 end +0024 end +0025 +0026 function extract(CCA) +0027 sti_f = CCA.stimulus_freqs; +0028 mLen=size(CCA.trials{1}.signal,2); +0029 refSignals=CCA.ck_signalTrans(sti_f,mLen,CCA.FreqSamp,CCA.NumHarm); +0030 NumStim = size(refSignals,3); +0031 numTrials = length(CCA.trials); +0032 for i=1:numTrials +0033 data = CCA.trials{i}.signal(CCA.channel,:); +0034 if(CCA.allFeatures == 1) +0035 features=NaN*ones(NumStim,min(rank(data),CCA.NumHarm*2)); +0036 for j=1:NumStim +0037 [wx1,wy1,r1] = canoncorr(data',refSignals(:,:,j)'); +0038 features(j,:) = r1; +0039 end +0040 tempfeatures = features(1,:); +0041 for j=2:NumStim +0042 tempfeatures = horzcat(tempfeatures,features(j,:)); +0043 end +0044 instances(i,:) = tempfeatures(:); +0045 labels(i,1) = floor(CCA.trials{i}.label); +0046 else +0047 features=NaN*ones(NumStim,1); +0048 for j=1:NumStim +0049 % [wx1,wy1,r1] = CCA.cca(data,refSignals(:,:,j)); +0050 [wx1,wy1,r1] = canoncorr(data',refSignals(:,:,j)'); +0051 features(j) = max(r1); +0052 end +0053 instances(i,:) = features(:); +0054 labels(i,1) = floor(CCA.trials{i}.label); +0055 end +0056 end +0057 % unique(labels) +0058 if (sum(unique(labels)) == 41) +0059 labels(labels==6)=1; +0060 labels(labels==7)=2; +0061 labels(labels==8)=3; +0062 labels(labels==9)=4; +0063 labels(labels==11)=5; +0064 end +0065 % unique(labels) +0066 CCA.instanceSet = eegtoolkit.util.InstanceSet(instances, labels); +0067 end +0068 +0069 function configInfo = getConfigInfo(CCA) +0070 configInfo = sprintf('CCA'); +0071 end +0072 +0073 % function [Wx, Wy, r] = cca(CCA,X,Y) +0074 % +0075 % % CCA calculate canonical correlations +0076 % % +0077 % % [Wx Wy r] = cca(X,Y) where Wx and Wy contains the canonical correlation +0078 % +0079 % % vectors as columns and r is a vector with corresponding canonical +0080 % % correlations. The correlations are sorted in descending order. X and Y +0081 % % are matrices where each column is a sample. Hence, X and Y must have +0082 % % the same number of columns. +0083 % % +0084 % % Example: If X is M*K and Y is N*K there are L=MIN(M,N) solutions. Wx is +0085 % % then M*L, Wy is N*L and r is L*1. +0086 % % +0087 % % +0088 % % ?? 2000 Magnus Borga, Link?pings universitet +0089 % +0090 % % --- Calculate covariance matrices ---?????????????? +0091 % +0092 % z = [X;Y]; +0093 % C = cov(z.'); +0094 % sx = size(X,1); %X??????(??), +0095 % sy = size(Y,1); +0096 % Cxx = C(1:sx, 1:sx) + 10^(-8)*eye(sx); +0097 % Cxy = C(1:sx, sx+1:sx+sy); +0098 % Cyx = Cxy'; +0099 % Cyy = C(sx+1:sx+sy, sx+1:sx+sy) + 10^(-8)*eye(sy);%eye()???????? +0100 % invCyy = inv(Cyy); +0101 % +0102 % % --- Calcualte Wx and r --- +0103 % +0104 % [Wx,r] = eig(inv(Cxx)*Cxy*invCyy*Cyx); % Basis in X eig???????????? +0105 % r = sqrt(real(r)); % Canonical correlations +0106 % +0107 % % --- Sort correlations --- +0108 % +0109 % V = fliplr(Wx); % reverse order of eigenvectors??????????????????????i??????????i?????? +0110 % r = flipud(diag(r)); % extract eigenvalues and reverse their order +0111 % [r,I]= sort((real(r))); % sort reversed eigenvalues in ascending order +0112 % r = flipud(r); % restore sorted eigenvalues into descending order?????????????? +0113 % for j = 1:length(I) +0114 % Wx(:,j) = V(:,I(j)); % sort reversed eigenvectors in ascending order +0115 % end +0116 % Wx = fliplr(Wx); % restore sorted eigenvectors into descending order +0117 % +0118 % % --- Calcualte Wy --- +0119 % +0120 % Wy = invCyy*Cyx*Wx; % Basis in Y +0121 % % Wy = Wy./repmat(sqrt(sum(abs(Wy).^2)),sy,1); % Normalize Wy +0122 % +0123 % end +0124 +0125 function refSignal=ck_signalTrans(CCA,f,mLen,FreqSamp,NumHarm) +0126 +0127 p=mLen;%1250; +0128 fs=FreqSamp;%250; +0129 TP=1/fs:1/fs:p/fs; +0130 for j=1:length(f) +0131 tempComp=[]; +0132 for k=1:NumHarm +0133 Sinh1=sin(2*pi*k*f(j)*TP); +0134 Cosh1=cos(2*pi*k*f(j)*TP); +0135 tempComp = [tempComp; Sinh1;Cosh1;]; +0136 end +0137 refSignal(:,:,j)=tempComp; +0138 end +0139 end +0140 function time = getTime(CCA) +0141 time = CCA.avgTime; +0142 end +0143 end +0144 +0145 end
| Master index |
+Index for +eegtoolkit/+featextraction/@CCA |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@CCA |
| CCA |
0001 classdef DWT < eegtoolkit.featextraction.FeatureExtractionBase +0002 +0003 properties (Access = public) +0004 channel; +0005 seconds; +0006 levelWT; +0007 WavFamily; +0008 avgTime; +0009 end +0010 +0011 methods (Access = public) +0012 function mDWT = DWT(trials, seconds, channel,levWT,WavFam) +0013 if nargin == 0 +0014 mDWT.seconds = 0; +0015 mDWT.channel = 1; +0016 mDWT.levelWT = 5; +0017 mDWT.WavFamily = 'db1'; +0018 elseif nargin == 1 +0019 mDWT.trials = trials; +0020 mDWT.seconds = 0; +0021 mDWT.channel = 1; +0022 mDWT.levelWT = 5; +0023 mDWT.WavFamily = 'db1'; +0024 elseif nargin == 2 +0025 mDWT.trials = trials; +0026 mDWT.channel = 1; +0027 mDWT.seconds = seconds; +0028 mDWT.levelWT = 5; +0029 mDWT.WavFamily = 'db1'; +0030 elseif nargin == 3 +0031 mDWT.trials = trials; +0032 mDWT.channel = channel; +0033 mDWT.seconds = seconds; +0034 mDWT.levelWT = 5; +0035 mDWT.WavFamily = 'db1'; +0036 elseif nargin == 4 +0037 mDWT.trials = trials; +0038 mDWT.channel = channel; +0039 mDWT.seconds = seconds; +0040 mDWT.levelWT = levWT; +0041 mDWT.WavFamily = 'db1'; +0042 elseif nargin ==5 +0043 mDWT.trials = trials; +0044 mDWT.channel = channel; +0045 mDWT.seconds = seconds; +0046 mDWT.levelWT = levWT; +0047 mDWT.WavFamily = WavFam; +0048 else +0049 error('invalid number of arguments'); +0050 end +0051 mDWT.avgTime = 0; +0052 end +0053 +0054 function extract(mDWT) +0055 if length(mDWT.seconds)==1 +0056 numsamples = mDWT.trials{1}.samplingRate * mDWT.seconds; +0057 if (numsamples == 0) +0058 numsamples = size(mDWT.trials{1}.signal(mDWT.channel,:),2); +0059 end +0060 numTrials = length(mDWT.trials); +0061 +0062 [C L] = wavedec(mDWT.trials{1}.signal(mDWT.channel, 1:numsamples),mDWT.levelWT,mDWT.WavFamily); +0063 instances = zeros(numTrials, length(C)); +0064 labels = zeros(numTrials,1); +0065 elseif length(mDWT.seconds) == 2 +0066 sampleA = mDWT.trials{1}.samplingRate * mDWT.seconds(1) + 1; +0067 sampleB = mDWT.trials{1}.samplingRate * mDWT.seconds(2); +0068 numTrials = length(mDWT.trials); +0069 [C L] = wavedec(mDWT.trials{1}.signal(mDWT.channel, sampleA:sampleB),mDWT.levelWT,mDWT.WavFamily); +0070 instances = zeros(numTrials, length(C)); +0071 labels = zeros(numTrials,1); +0072 else +0073 error('invalid seconds parameter'); +0074 end +0075 tic +0076 for i=1:numTrials +0077 if length(mDWT.seconds) == 1 +0078 numsamples = mDWT.trials{i}.samplingRate * mDWT.seconds; +0079 if(numsamples == 0) +0080 y = mDWT.trials{i}.signal(mDWT.channel,:); +0081 else +0082 y = mDWT.trials{i}.signal(mDWT.channel, 1:numsamples); +0083 end +0084 % zero padding to nearest power of 2 +0085 if isa(mDWT.filter,'dfilt.df2sos') +0086 y = filter(mDWT.filter,y); +0087 elseif isa(mDWT.filter,'dfilt.dffir') +0088 y = filtfilt(mDWT.filter.Numerator,1,y); +0089 end +0090 [C L] = wavedec(y,mDWT.levelWT,mDWT.WavFamily);%pwelch(y,[],[],512,mDWT.trials{i}.samplingRate,'onesided'); +0091 elseif length(mDWT.seconds) == 2 +0092 sampleA = mDWT.trials{i}.samplingRate * mDWT.seconds(1) + 1; +0093 sampleB = mDWT.trials{i}.samplingRate * mDWT.seconds(2); +0094 y = mDWT.trials{i}.signal(mDWT.channel,sampleA:sampleB); +0095 if isa(mDWT.filter,'dfilt.df2sos') || isa(mDWT.filter,'dfilt.df2') +0096 y = filter(mDWT.filter,y); +0097 elseif isa(mDWT.filter,'dfilt.dffir') +0098 y = filtfilt(mDWT.filter.Numerator,1,y); +0099 end +0100 [C L] = wavedec(y,mDWT.levelWT,mDWT.WavFamily);%pwelch(y,[],[],512,mDWT.trials{i}.samplingRate,'onesided'); +0101 else +0102 error('invalid seconds parameter'); +0103 end +0104 instances(i,:) = C; +0105 labels(i,1) = floor(mDWT.trials{i}.label); +0106 end +0107 mDWT.avgTime = toc/numTrials; +0108 mDWT.instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0109 end +0110 +0111 function configInfo = getConfigInfo(mDWT) +0112 configInfo = sprintf('DWT\tchannel:%d\tseconds:%d\tlevelWT:%d\tWavFamily:%s',mDWT.channel,mDWT.seconds,mDWT.levelWT,mDWT.WavFamily); +0113 end +0114 +0115 +0116 function time = getTime(mDWT) +0117 time = mDWT.avgTime; +0118 end +0119 end +0120 +0121 end
| Master index |
+Index for +eegtoolkit/+featextraction/@DWT |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@DWT |
| DWT |
0001 classdef ERRPFeatures < eegtoolkit.featextraction.PSDExtractionBase%FeatureExtractionBase +0002 properties (Access = public) +0003 channel; +0004 avgTime; +0005 % downSampleFactor; +0006 end +0007 methods (Access = public) +0008 function ERRP = ERRPFeatures() +0009 % ERRP.downSampleFactor = 8; +0010 ERRP.channel = 1; +0011 end +0012 +0013 function extract(ERRP) +0014 +0015 numTrials = length(ERRP.trials); +0016 [~,numSamples] = size(ERRP.trials{1}.signal(ERRP.channel,:)); +0017 % numFeatures = floor(numSamples/ERRP.downSampleFactor); +0018 instances = zeros(numTrials,numSamples); +0019 labels = zeros(numTrials,1); +0020 for i=1:numTrials +0021 instances(i,:) = ERRP.trials{i}.signal(ERRP.channel,:); +0022 labels(i) = ERRP.trials{i}.label; +0023 end +0024 ERRP.instanceSet = eegtoolkit.util.InstanceSet(instances, labels); +0025 end +0026 +0027 function configInfo = getConfigInfo(ERRP) +0028 configInfo = sprintf('ERRP features'); +0029 end +0030 +0031 function time = getTime(ERRP) +0032 time = ERRP.avgTime; +0033 end +0034 end +0035 +0036 end
| Master index |
+Index for +eegtoolkit/+featextraction/@ERRPFeatures |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@ERRPFeatures |
| ERRPFeatures |
0001 classdef FFT < eegtoolkit.featextraction.FeatureExtractionBase +0002 +0003 properties (Access = public) +0004 channel; +0005 seconds; +0006 nfft; +0007 avgTime; +0008 end +0009 +0010 methods (Access = public) +0011 function mFFT = FFT(trials, seconds, channel,nfft) +0012 if nargin == 0 +0013 mFFT.seconds = 0; +0014 mFFT.channel = 1; +0015 mFFT.nfft = 512; +0016 elseif nargin == 1 +0017 mFFT.trials = trials; +0018 mFFT.seconds = 0; +0019 mFFT.channel = 1; +0020 mFFT.nfft = 512; +0021 elseif nargin == 2 +0022 mFFT.trials = trials; +0023 mFFT.channel = 1; +0024 mFFT.seconds = seconds; +0025 mFFT.nfft = 512; +0026 elseif nargin == 3 +0027 mFFT.trials = trials; +0028 mFFT.channel = channel; +0029 mFFT.seconds = seconds; +0030 mFFT.nfft = 512; +0031 elseif nargin == 4 +0032 mFFT.trials = trials; +0033 mFFT.channel = channel; +0034 mFFT.seconds = seconds; +0035 mFFT.nfft = nfft; +0036 error('invalid number of arguments'); +0037 end +0038 end +0039 +0040 function extract(mFFT) +0041 NUM_FEATURES = mFFT.nfft/2+1; +0042 numTrials = length(mFFT.trials); +0043 instances = zeros(numTrials, NUM_FEATURES); +0044 labels = zeros(numTrials,1); +0045 tic +0046 for i=1:numTrials +0047 if length(mFFT.seconds) == 1 +0048 numsamples = mFFT.trials{i}.samplingRate * mFFT.seconds; +0049 if(numsamples == 0) +0050 y = mFFT.trials{i}.signal(mFFT.channel,:); +0051 else +0052 y = mFFT.trials{i}.signal(mFFT.channel, 1:numsamples); +0053 end +0054 elseif length(mFFT.seconds) == 2 +0055 sampleA = mFFT.trials{i}.samplingRate * mFFT.seconds(1) + 1; +0056 sampleB = mFFT.trials{i}.samplingRate * mFFT.seconds(2); +0057 y = mFFT.trials{i}.signal(mFFT.channel, sampleA:sampleB); +0058 else +0059 +0060 error ('invalid seconds parameter'); +0061 end +0062 if isa(mFFT.filter,'dfilt.df2sos') || isa(mFFT.filter,'dfilt.df2') +0063 y = filter(mFFT.filter,y); +0064 elseif isa(mFFT.filter,'dfilt.dffir') +0065 y = filtfilt(mFFT.filter.Numerator,1,y); +0066 end +0067 %Y = fft(y,(NUM_FEATURES-1)*2)/((NUM_FEATURES-1)*2); +0068 %f = Fs/2*linspace(0,1,NFFT/2+1); +0069 %pyy = abs(Y(1:(NUM_FEATURES-1)*2/2+1)).^2; +0070 [pyy,f] = periodogram(y,[],mFFT.nfft,mFFT.trials{i}.samplingRate); +0071 instances(i,:) = pyy; +0072 labels(i,1) = floor(mFFT.trials{i}.label); +0073 end +0074 mFFT.avgTime = toc/numTrials; +0075 mFFT.instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0076 end +0077 +0078 function configInfo = getConfigInfo(mFFT) +0079 configInfo = sprintf('FFT\tchannel:%d\tseconds:%d\tnfft:%d',mFFT.channel,mFFT.seconds,mFFT.nfft); +0080 end +0081 +0082 +0083 function time = getTime(mFFT) +0084 time = mFFT.avgTime; +0085 end +0086 end +0087 +0088 end +0089
| Master index |
+Index for +eegtoolkit/+featextraction/@FFT |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@FFT |
| FFT |
Abstract class for feature extraction. Implement the functions for any + feature extractor (e.g. PWelch, FFT, DWT, PYAR, etc.) + + Properties: + instanceSet: Output - the features in an InstanceSet structure + trials: Input - the signals in a cell of Trial structures + + Functions: +Implement this function to extract the features from the input Trials +and return the features in an instanceSet + out = obj.extract(in); +Info & run time so that the experiments are easily documented. configInfo +is a string with the configuration information and time is of type double. + configInfo = obj.getConfigInfo(); + time = obj.getTime();
0001 % Abstract class for feature extraction. Implement the functions for any +0002 % feature extractor (e.g. PWelch, FFT, DWT, PYAR, etc.) +0003 % +0004 % Properties: +0005 % instanceSet: Output - the features in an InstanceSet structure +0006 % trials: Input - the signals in a cell of Trial structures +0007 % +0008 % Functions: +0009 %Implement this function to extract the features from the input Trials +0010 %and return the features in an instanceSet +0011 % out = obj.extract(in); +0012 %Info & run time so that the experiments are easily documented. configInfo +0013 %is a string with the configuration information and time is of type double. +0014 % configInfo = obj.getConfigInfo(); +0015 % time = obj.getTime(); +0016 +0017 +0018 classdef (Abstract) FeatureExtractionBase < handle +0019 %Base class for a feature transformer +0020 %For writing your own FeatureTransformer extend this class and +0021 %implement the 'transform' function +0022 properties (Access = public) +0023 instanceSet; % Output: The dataset +0024 trials;% Input: The trial signals +0025 filter; +0026 end +0027 +0028 methods (Abstract = true) +0029 obj = extract(obj); +0030 configInfo = getConfigInfo(obj); +0031 time = getTime(obj); +0032 end +0033 +0034 methods (Access = public) +0035 function instances = getInstances(obj) +0036 %Get the instances (no class labels) +0037 instances = obj.instanceSet.getInstances; +0038 end +0039 function labels = getLabels(obj) +0040 %Get the labels +0041 labels = obj.instanceSet.getLabels; +0042 end +0043 +0044 function dataset = getDataset(obj) +0045 % same with getInstances but includes the labels as the last +0046 % row +0047 dataset = obj.instanceSet.getDataset; +0048 end +0049 +0050 function instanceSet = getInstanceSet(obj) +0051 % Get the dataset as an 'InstanceSet' class object +0052 instanceSet = obj.instanceSet; +0053 end +0054 function writeCSV(obj, csvname) +0055 % write the dataset to a csv file +0056 % Example: +0057 % obj.writeCSV('data.csv'); +0058 obj.instanceSet.writeCSV(csvname); +0059 end +0060 function writeArff(obj, fname) +0061 % write the dataset to a weka-readable file (arff) +0062 % Caution: filename without extension +0063 % Example: +0064 % obj.writeArff('data') +0065 obj.instanceSet.writeArff(fname); +0066 end +0067 end +0068 end
| Master index |
+Index for +eegtoolkit/+featextraction/@FeatureExtractionBase |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@FeatureExtractionBase |
| FeatureExtractionBase | Abstract class for feature extraction. Implement the functions for any |
0001 classdef Goertzel < eegtoolkit.featextraction.FeatureExtractionBase +0002 %Computes the psd using the welch method +0003 %Usage: +0004 % session = eegtoolkit.util.Session(); +0005 % session.loadSubject(1); +0006 % pwt = ssveptolkit.transform.PWelchTransformer(session.trials); +0007 %Specify the channel to be used (default = 126) +0008 % pwt.channel = 150; +0009 %Specify the number of seconds to be used (default = 0, use all signal) +0010 % pwt.seconds = 3; +0011 %Specify the nfft parameter (default = 512, computes 257 features) +0012 % pwt.nfft = 512; +0013 %Transform the signal +0014 % pwt.transform(); +0015 properties (Access = public) +0016 channel; +0017 seconds; +0018 nfft; +0019 pff; +0020 avgTime; +0021 end +0022 +0023 methods (Access = public) +0024 function GT = Goertzel(trials, seconds, channel, nfft) +0025 % if ~iscell(trials) +0026 % error('trials must be cell array of Trial object'); +0027 % end +0028 if nargin == 0 +0029 GT.trials = {}; +0030 GT.seconds = 0; +0031 GT.channel = 1; +0032 GT.nfft = 512; +0033 elseif nargin == 1 +0034 GT.trials = trials; +0035 GT.seconds = 0; +0036 GT.channel = 1; +0037 GT.nfft = 512; +0038 elseif nargin == 2 +0039 GT.trials = trials; +0040 GT.channel = 1; +0041 GT.seconds = seconds; +0042 GT.nfft = 512; +0043 elseif nargin == 3 +0044 GT.trials = trials; +0045 GT.channel = channel; +0046 GT.seconds = seconds; +0047 GT.nfft = 512; +0048 elseif nargin == 4 +0049 GT.trials = trials; +0050 GT.channel = channel; +0051 GT.seconds = seconds; +0052 GT.nfft = nfft; +0053 else +0054 % error('invalid number of arguments'); +0055 end +0056 end +0057 +0058 function extract(GT) +0059 +0060 numFeatures = length(GT.nfft); +0061 numTrials = length(GT.trials); +0062 instances = zeros(numTrials, numFeatures); +0063 labels = zeros(numTrials,1); +0064 % PWT.instances = zeros(numTrials, numFeatures); +0065 % PWT.labels = zeros(numTrials,1); +0066 tic; +0067 for i=1:numTrials +0068 numsamples = GT.trials{i}.samplingRate * GT.seconds; +0069 if(numsamples == 0) +0070 y = GT.trials{i}.signal(GT.channel,:); +0071 else +0072 y = GT.trials{i}.signal(GT.channel, 1:numsamples); +0073 end +0074 % N = (length(y)+1)/2; +0075 % f = (PWT.trials{i}.samplingRate/2)/N*(0:N-1); +0076 % indxs = find(f>1.2e3 & f<1.3e3); +0077 % X = goertzel(x,indxs); +0078 freq_indices = round(GT.nfft/GT.trials{i}.samplingRate*length(y)) + 1; +0079 % ff = [0:1/512:1/2]*250; +0080 % freq_indices = round(ff/PWT.trials{i}.samplingRate*length(y))+1 +0081 dft_data = goertzel(y,freq_indices);%goertzel(y,freq_indices); general_shortened +0082 instances(i,:) = abs(dft_data) ./ length(y); +0083 labels(i,1) = floor(GT.trials{i}.label); +0084 end +0085 GT.avgTime = toc/numTrials; +0086 GT.instanceSet = eegtoolkit.util.InstanceSet(instances, labels); +0087 GT.pff = GT.nfft; +0088 end +0089 +0090 function configInfo = getConfigInfo(GT) +0091 configInfo = sprintf('Goertzel\tchannel:%d\tseconds:%d\tfreq range:%.3f to %.3f',GT.channel,GT.seconds,GT.nfft(1),GT.nfft(end)); +0092 end +0093 +0094 function time = getTime(GT) +0095 time = GT.avgTime; +0096 end +0097 end +0098 +0099 end +0100
| Master index |
+Index for +eegtoolkit/+featextraction/@Goertzel |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@Goertzel |
| Goertzel |
0001 classdef L1MCCA < eegtoolkit.featextraction.PSDExtractionBase%FeatureExtractionBase +0002 % +0003 % works only on our datasets, for other datasets needs modifications +0004 % +0005 properties (Access = public) +0006 channel; +0007 avgTime; +0008 stimulus_freqs; +0009 FreqSamp; +0010 NumHarm; +0011 end +0012 methods (Access = public) +0013 function L1MCCA = L1MCCA() +0014 end +0015 +0016 function extract(L1MCCA) +0017 L1MCCA.instanceSet = eegtoolkit.util.L1MCCAInstanceSet(L1MCCA.trials); +0018 end +0019 +0020 function configInfo = getConfigInfo(L1MCCA) +0021 configInfo = sprintf('L1MCCA'); +0022 end +0023 function time = getTime(L1MCCA) +0024 time = 0; +0025 end +0026 end +0027 end
| Master index |
+Index for +eegtoolkit/+featextraction/@L1MCCA |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@L1MCCA |
| L1MCCA |
0001 classdef MLR_Transf < eegtoolkit.featextraction.PSDExtractionBase%FeatureExtractionBase +0002 %Computes the psd using the welch method +0003 %Usage: +0004 % session = eegtoolkit.util.Session(); +0005 % session.loadSubject(1); +0006 % pwt = ssveptolkit.transform.PWelchTransformer(session.trials); +0007 %Specify the channel to be used (default = 126) +0008 % pwt.channel = 150; +0009 %Specify the number of seconds to be used (default = 0, use all signal) +0010 % pwt.seconds = 3; +0011 %Specify the nfft parameter (default = 512, computes 257 features) +0012 % pwt.nfft = 512; +0013 %Transform the signal +0014 % pwt.transform(); +0015 properties (Access = public) +0016 channel; +0017 avgTime; +0018 end +0019 methods (Access = public) +0020 function PWT = MLR_Transf(chns) +0021 if nargin == 1 +0022 PWT.trials = {}; +0023 PWT.channel = [1:length(chns)]; +0024 else +0025 error('invalid number of arguments'); +0026 end +0027 end +0028 +0029 function extract(PWT) +0030 +0031 numTrials = length(PWT.trials); +0032 [m n]=size(PWT.trials{1}.signal(PWT.channel,:)); +0033 data = zeros(m,n,numTrials); +0034 labels = zeros(numTrials,1); +0035 +0036 for i = 1 : numTrials % +0037 for j=1:m +0038 data(j,:,i) = PWT.trials{i}.signal(j,:);%data(j,:,i)./norm(data(j,:,i)); +0039 data(j,:,i) = (data(j,:,i) - mean(data(j,:,i)))./std(data(j,:,i)); +0040 % data(j,:,i) = data(j,:,i)./norm(data(j,:,i)); +0041 end% +0042 labels(i) = floor(PWT.trials{i}.label); +0043 end +0044 %data= reshape(data,m*n,size(data,3)); +0045 for i=1:numTrials +0046 newData(i,:) = [data(1,:,i) data(2,:,i)]; +0047 end +0048 % MeanTrainData=mean(data,2); +0049 % data=data-repmat(MeanTrainData,1,numTrials); +0050 data = newData; +0051 PWT.instanceSet = eegtoolkit.util.InstanceSet(data, labels); +0052 end +0053 +0054 function configInfo = getConfigInfo(PWT) +0055 configInfo = sprintf('MLR_Transf_rawdata'); +0056 end +0057 +0058 function time = getTime(PWT) +0059 time = PWT.avgTime; +0060 end +0061 end +0062 +0063 end +0064
| Master index |
+Index for +eegtoolkit/+featextraction/@MLR_Transf |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@MLR_Transf |
| MLR_Transf |
0001 classdef (Abstract) PSDExtractionBase < eegtoolkit.featextraction.FeatureExtractionBase +0002 %Base class for a feature transformer based on power spectral density +0003 %estimates +0004 properties (Access = public) +0005 pff; % The frequencies of the spectrum +0006 end +0007 end
| Master index |
+Index for +eegtoolkit/+featextraction/@PSDExtractionBase |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@PSDExtractionBase |
| PSDExtractionBase |
0001 classdef PWelch < eegtoolkit.featextraction.PSDExtractionBase +0002 %Computes the psd using the welch method +0003 %Usage: +0004 % session = eegtoolkit.util.Session(); +0005 % session.loadSubject(1); +0006 % pwt = ssveptolkit.transform.PWelchTransformer(session.trials); +0007 %Specify the channel to be used (default = 126) +0008 % pwt.channel = 150; +0009 %Specify the number of seconds to be used (default = 0, use all signal) +0010 % pwt.seconds = 3; +0011 %Specify the nfft parameter (default = 512, computes 257 features) +0012 % pwt.nfft = 512; +0013 %Transform the signal +0014 % pwt.transform(); +0015 properties (Access = public) +0016 channel; +0017 seconds; +0018 nfft; +0019 avgTime; +0020 end +0021 +0022 methods (Access = public) +0023 function PW = PWelch(trials, seconds, channel, nfft) +0024 % if ~iscell(trials) +0025 % error('trials must be cell array of Trial object'); +0026 % end +0027 if nargin == 0 +0028 PW.trials = {}; +0029 PW.seconds = 0; +0030 PW.channel = 1; +0031 PW.nfft = 512; +0032 elseif nargin == 1 +0033 PW.trials = trials; +0034 PW.seconds = 0; +0035 PW.channel = 1; +0036 PW.nfft = 512; +0037 elseif nargin == 2 +0038 PW.trials = trials; +0039 PW.channel = 1; +0040 PW.seconds = seconds; +0041 PW.nfft = 512; +0042 elseif nargin == 3 +0043 PW.trials = trials; +0044 PW.channel = channel; +0045 PW.seconds = seconds; +0046 PW.nfft = 512; +0047 elseif nargin == 4 +0048 PW.trials = trials; +0049 PW.channel = channel; +0050 PW.seconds = seconds; +0051 PW.nfft = nfft; +0052 else +0053 % error('invalid number of arguments'); +0054 end +0055 end +0056 +0057 function extract(PW) +0058 if length(PW.nfft)==1 +0059 numFeatures = PW.nfft/2+1; +0060 else +0061 numFeatures = length(PW.nfft); +0062 end +0063 numTrials = length(PW.trials); +0064 instances = zeros(numTrials, numFeatures); +0065 labels = zeros(numTrials,1); +0066 % PWT.instances = zeros(numTrials, numFeatures); +0067 % PWT.labels = zeros(numTrials,1); +0068 tic; +0069 for i=1:numTrials +0070 if length(PW.seconds) == 1 +0071 numsamples = PW.trials{i}.samplingRate * PW.seconds; +0072 if(numsamples == 0) +0073 y = PW.trials{i}.signal(PW.channel,:); +0074 else +0075 y = PW.trials{i}.signal(PW.channel, 1:numsamples); +0076 end +0077 elseif length(PW.seconds) == 2 +0078 sampleA = PW.trials{i}.samplingRate*PW.seconds(1) +1; +0079 sampleB = PW.trials{i}.samplingRate*PW.seconds(2); +0080 y = PW.trials{i}.signal(PW.channel, sampleA:sampleB); +0081 else +0082 error('invalid seconds parameter'); +0083 end +0084 if isa(PW.filter,'dfilt.df2sos') || isa(PW.filter,'dfilt.df2') +0085 y = filter(PW.filter,y); +0086 elseif isa(PW.filter,'dfilt.dffir') +0087 y = filtfilt(PW.filter.Numerator,1,y); +0088 end +0089 if length(PW.nfft>1) +0090 [pxx, pff]=pwelch(y,[],[],PW.nfft,PW.trials{i}.samplingRate); +0091 else +0092 [pxx, pff]=pwelch(y,[],[],PW.nfft,PW.trials{i}.samplingRate,'onesided'); +0093 end +0094 instances(i,:) = pxx; +0095 labels(i,1) = floor(PW.trials{i}.label); +0096 end +0097 total = toc; +0098 PW.avgTime = total/numTrials; +0099 PW.instanceSet = eegtoolkit.util.InstanceSet(instances, labels); +0100 PW.pff = pff; +0101 end +0102 +0103 function configInfo = getConfigInfo(PW) +0104 if length(PW.nfft)>1 +0105 configInfo = sprintf('PWelch\tchannel:%d\tseconds:%d\t freq range:%.3f to %.3f',PW.channel,PW.seconds,PW.nfft(1),PW.nfft(end)); +0106 else +0107 configInfo = sprintf('PWelch\tchannel:%d\tseconds:%d\tnfft:%d',PW.channel,PW.seconds,PW.nfft); +0108 end +0109 end +0110 +0111 function time = getTime(PW) +0112 time = PW.avgTime; +0113 end +0114 end +0115 +0116 end +0117
| Master index |
+Index for +eegtoolkit/+featextraction/@PWelch |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@PWelch |
| PWelch |
0001 classdef PWelchExperimental < eegtoolkit.featextraction.FeatureExtractionBase +0002 %Computes the psd using the welch method +0003 %Usage: +0004 % session = eegtoolkit.util.Session(); +0005 % session.loadSubject(1); +0006 % pwt = ssveptolkit.transform.PWelchTransformer(session.trials); +0007 %Specify the channel to be used (default = 126) +0008 % pwt.channel = 150; +0009 %Specify the number of seconds to be used (default = 0, use all signal) +0010 % pwt.seconds = 3; +0011 %Specify the nfft parameter (default = 512, computes 257 features) +0012 % pwt.nfft = 512; +0013 %Transform the signal +0014 % pwt.transform(); +0015 properties (Access = public) +0016 channel; +0017 seconds; +0018 nfft; +0019 pff; +0020 win_len; +0021 over_len; +0022 avgTime; +0023 end +0024 +0025 methods (Access = public) +0026 function PWT = PWelchExperimental(trials, seconds, channel, nfft,win_len,over_len) +0027 % if ~iscell(trials) +0028 % error('trials must be cell array of Trial object'); +0029 % end +0030 if nargin == 0 +0031 PWT.trials = {}; +0032 PWT.seconds = 0; +0033 PWT.channel = 1; +0034 PWT.nfft = 512; +0035 PWT.win_len=[]; +0036 PWT.over_len=[]; +0037 elseif nargin == 1 +0038 PWT.trials = trials; +0039 PWT.seconds = 0; +0040 PWT.channel = 1; +0041 PWT.nfft = 512; +0042 PWT.win_len=[]; +0043 PWT.over_len=[]; +0044 elseif nargin == 2 +0045 PWT.trials = trials; +0046 PWT.channel = 1; +0047 PWT.seconds = seconds; +0048 PWT.nfft = 512; +0049 PWT.win_len=[]; +0050 PWT.over_len=[]; +0051 elseif nargin == 3 +0052 PWT.trials = trials; +0053 PWT.channel = channel; +0054 PWT.seconds = seconds; +0055 PWT.nfft = 512; +0056 PWT.win_len=[]; +0057 PWT.over_len=[]; +0058 elseif nargin == 4 +0059 PWT.trials = trials; +0060 PWT.channel = channel; +0061 PWT.seconds = seconds; +0062 PWT.nfft = nfft; +0063 PWT.win_len=[]; +0064 PWT.over_len=[]; +0065 elseif nargin == 5 +0066 PWT.trials = trials; +0067 PWT.channel = channel; +0068 PWT.seconds = seconds; +0069 PWT.nfft = nfft; +0070 PWT.win_len=win_len; +0071 PWT.over_len=[]; +0072 elseif nargin == 6 +0073 PWT.trials = trials; +0074 PWT.channel = channel; +0075 PWT.seconds = seconds; +0076 PWT.nfft = nfft; +0077 PWT.win_len=win_len; +0078 PWT.over_len=over_len; +0079 else +0080 % error('invalid number of arguments'); +0081 end +0082 end +0083 +0084 function extract(PWT) +0085 if length(PWT.nfft)==1 +0086 numFeatures = PWT.nfft/2+1; +0087 else +0088 numFeatures = length(PWT.nfft); +0089 end +0090 numTrials = length(PWT.trials); +0091 instances = zeros(numTrials, numFeatures); +0092 labels = zeros(numTrials,1); +0093 % PWT.instances = zeros(numTrials, numFeatures); +0094 % PWT.labels = zeros(numTrials,1); +0095 tic; +0096 for i=1:numTrials +0097 numsamples = PWT.trials{i}.samplingRate * PWT.seconds; +0098 if(numsamples == 0) +0099 y = PWT.trials{i}.signal(PWT.channel,:); +0100 else +0101 y = PWT.trials{i}.signal(PWT.channel, 1:numsamples); +0102 end +0103 % if length(PWT.nfft>1) +0104 % [pxx, pff]=pwelch(y,[],[],PWT.nfft,PWT.trials{i}.samplingRate); +0105 % else +0106 [pxx, pff]=pwelch(y,PWT.win_len,round(PWT.over_len*PWT.win_len),PWT.nfft,PWT.trials{i}.samplingRate,'onesided'); +0107 % end +0108 %xv = [1 -2 1 zeros(1,length(pxx)-3)]; +0109 % xv = [1/5 1/5 1/5 1/5 1/5 zeros(1,length(pxx)-5)]; +0110 % A = gallery('circul',xv); +0111 instances(i,:) = pxx; +0112 labels(i,1) = floor(PWT.trials{i}.label); +0113 end +0114 PWT.avgTime = toc/numTrials; +0115 PWT.instanceSet = eegtoolkit.util.InstanceSet(instances, labels); +0116 PWT.pff = pff; +0117 end +0118 +0119 function configInfo = getConfigInfo(PWT) +0120 if length(PWT.nfft)>1 +0121 configInfo = sprintf('PWelchExperimental\tchannel:%d\tseconds:%d\t freq range:%.3f to %.3f',PWT.channel,PWT.seconds,PWT.nfft(1),PWT.nfft(end)); +0122 else +0123 configInfo = sprintf('PWelchExperimental\tchannel:%d\tseconds:%d\tnfft:%d',PWT.channel,PWT.seconds,PWT.nfft); +0124 end +0125 end +0126 +0127 function time = getTime(PWT) +0128 time = PWT.avgTime; +0129 end +0130 end +0131 +0132 end +0133
| Master index |
+Index for +eegtoolkit/+featextraction/@PWelchExperimental |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@PWelchExperimental |
| PWelchExperimental |
0001 classdef PYAR < eegtoolkit.featextraction.FeatureExtractionBase +0002 +0003 properties (Access = public) +0004 channel; +0005 seconds; +0006 order; +0007 nfft; +0008 avgTime; +0009 end +0010 +0011 methods (Access = public) +0012 function mAR = PYAR(trials, seconds, channel,m_ord, nfft) +0013 if nargin == 0 +0014 mAR.seconds = 0; +0015 mAR.channel = 1; +0016 mAR.order = 20; +0017 mAR.nfft = 512; +0018 elseif nargin == 1 +0019 mAR.trials = trials; +0020 mAR.seconds = 0; +0021 mAR.channel = 1; +0022 mAR.order = 20; +0023 mAR.nfft = 512; +0024 elseif nargin == 2 +0025 mAR.trials = trials; +0026 mAR.channel = 1; +0027 mAR.seconds = seconds; +0028 mAR.order = 20; +0029 mAR.nfft = 512; +0030 elseif nargin == 3 +0031 mAR.trials = trials; +0032 mAR.channel = channel; +0033 mAR.seconds = seconds; +0034 mAR.order=20; +0035 mAR.nfft = 512; +0036 elseif nargin == 4 +0037 mAR.trials = trials; +0038 mAR.channel = channel; +0039 mAR.seconds = seconds; +0040 mAR.order = m_ord; +0041 mAR.nfft = 512; +0042 elseif nargin == 5 +0043 mAR.trials = trials; +0044 mAR.channel = channel; +0045 mAR.seconds = seconds; +0046 mAR.order = m_ord; +0047 mAR.nfft = nfft; +0048 else +0049 error('invalid number of arguments'); +0050 end +0051 end +0052 +0053 function extract(mAR) +0054 NUM_FEATURES = mAR.nfft/2+1; +0055 numTrials = length(mAR.trials); +0056 instances = zeros(numTrials, NUM_FEATURES); +0057 labels = zeros(numTrials,1); +0058 tic +0059 for i=1:numTrials +0060 if length(mAR.seconds) ==1 +0061 numsamples = mAR.trials{i}.samplingRate * mAR.seconds; +0062 if(numsamples == 0) +0063 y = mAR.trials{i}.signal(mAR.channel,:); +0064 else +0065 y = mAR.trials{i}.signal(mAR.channel, 1:numsamples); +0066 end +0067 elseif length(mAR.seconds) ==2 +0068 sampleA = mAR.trials{i}.samplingRate*mAR.seconds(1) + 1; +0069 sampleB = mAR.trials{i}.samplingRate*mAR.seconds(2); +0070 else +0071 error('invalid seconds parameter'); +0072 end +0073 if isa(mAR.filter,'dfilt.df2sos') || isa(mAR.filter,'dfilt.df2') +0074 y = filter(mAR.filter,y); +0075 elseif isa(mAR.filter,'dfilt.dffir') +0076 y = filtfilt(mAR.filter.Numerator,1,y); +0077 end +0078 [pyy pff] = pyulear(y,mAR.order,mAR.nfft,mAR.trials{i}.samplingRate); +0079 instances(i,:) = pyy; +0080 labels(i,1) = floor(mAR.trials{i}.label); +0081 end +0082 mAR.avgTime = toc/numTrials; +0083 mAR.instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0084 end +0085 +0086 function configInfo = getConfigInfo(mAR) +0087 configInfo = sprintf('PYAR\tchannel:%d\tseconds:%d\tnfft:%d\torder:%d',mAR.channel,mAR.seconds,mAR.nfft,mAR.order); +0088 end +0089 +0090 +0091 function time = getTime(mAR) +0092 time = mAR.avgTime; +0093 end +0094 end +0095 +0096 end +0097
| Master index |
+Index for +eegtoolkit/+featextraction/@PYAR |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@PYAR |
| PYAR |
0001 classdef RawSignal < eegtoolkit.featextraction.FeatureExtractionBase +0002 %RAWSIGNAL Summary of this class goes here +0003 % Detailed explanation goes here +0004 +0005 properties (Access = public) +0006 end +0007 +0008 methods (Access = public) +0009 function RS = RawSignal() +0010 % RS.instanceSet = eegtoolkit.util.RawSignalSet(RS.trials); +0011 end +0012 +0013 function RS = extract(RS) +0014 RS.instanceSet = eegtoolkit.util.RawSignalSet(RS.trials); +0015 end +0016 +0017 function configInfo = getConfigInfo(RS) +0018 configInfo = '\n'; +0019 end +0020 +0021 function time = getTime(RS) +0022 time = 0; +0023 end +0024 end +0025 +0026 end +0027
| Master index |
+Index for +eegtoolkit/+featextraction/@RawSignal |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@RawSignal |
| RawSignal |
0001 classdef STFT < eegtoolkit.featextraction.FeatureExtractionBase +0002 +0003 properties (Access = public) +0004 channel; +0005 seconds; +0006 Frange; +0007 avgTime; +0008 end +0009 +0010 methods (Access = public) +0011 function mSTFT = STFT(trials, seconds, channel,rangeFreq) +0012 if nargin == 0 +0013 mSTFT.seconds = 0; +0014 mSTFT.channel = 1; +0015 mSTFT.Frange(1) = 0; +0016 % mSTFT.Frange(2) = mSTFT.trials{1}.samplingRate; +0017 elseif nargin == 1 +0018 mSTFT.trials = trials; +0019 mSTFT.seconds = 0; +0020 mSTFT.channel = 1; +0021 mSTFT.Frange(1) = 0; +0022 mSTFT.Frange(2) = mSTFT.trials{1}.samplingRate; +0023 elseif nargin == 2 +0024 mSTFT.trials = trials; +0025 mSTFT.channel = 1; +0026 mSTFT.seconds = seconds; +0027 mSTFT.Frange(1) = 0; +0028 mSTFT.Frange(2) = mSTFT.trials{1}.samplingRate; +0029 elseif nargin == 3 +0030 mSTFT.trials = trials; +0031 mSTFT.channel = channel; +0032 mSTFT.seconds = seconds; +0033 mSTFT.Frange(1) = 0; +0034 mSTFT.Frange(2) = mSTFT.trials{1}.samplingRate; +0035 elseif nargin==4 +0036 +0037 mSTFT.trials = trials; +0038 +0039 if prod(size(rangeFreq)) ~=2 +0040 error('vector for frequency range must has two elements') +0041 end +0042 if rangeFreq(1)>=rangeFreq(2) +0043 error('first element must be smaller.'); +0044 end +0045 if (rangeFreq(1)<0 || rangeFreq(2)>mSTFT.trials{1}.samplingRate) +0046 error('invalid values for frequency range'); +0047 end +0048 +0049 mSTFT.channel = channel; +0050 mSTFT.seconds = seconds; +0051 mSTFT.Frange(1) = rangeFreq(1); +0052 mSTFT.Frange(2) = rangeFreq(2); +0053 else +0054 error('invalid number of arguments'); +0055 end +0056 end +0057 +0058 function extract(mSTFT) +0059 mSTFT.Frange(2) = mSTFT.trials{1}.samplingRate; +0060 numsamples = mSTFT.trials{1}.samplingRate * mSTFT.seconds; +0061 if (numsamples == 0) +0062 numsamples = size(mSTFT.trials{1}.signal(mSTFT.channel,:),2); +0063 end +0064 tic +0065 numTrials = length(mSTFT.trials); +0066 y = mSTFT.trials{1}.signal(mSTFT.channel, 1:numsamples); +0067 [S,F,T,P]=spectrogram(y,[],[],[mSTFT.Frange(1):0.5:mSTFT.Frange(2)],mSTFT.trials{1}.samplingRate); +0068 instances = zeros(numTrials, length(P(:))); +0069 labels = zeros(numTrials,1); +0070 for i=1:numTrials +0071 numsamples = mSTFT.trials{i}.samplingRate * mSTFT.seconds; +0072 if(numsamples == 0) +0073 y = mSTFT.trials{i}.signal(mSTFT.channel,:); +0074 else +0075 y = mSTFT.trials{i}.signal(mSTFT.channel, 1:numsamples); +0076 end +0077 +0078 [S,F,T,P]=spectrogram(y,[],[],[mSTFT.Frange(1):0.5:mSTFT.Frange(2)],mSTFT.trials{i}.samplingRate); +0079 instances(i,:) = P(:); +0080 labels(i,1) = floor(mSTFT.trials{i}.label); +0081 end +0082 mSTFT.avgTime = toc/numTrials; +0083 mSTFT.instanceSet = eegtoolkit.util.InstanceSet(instances,labels); +0084 end +0085 +0086 function configInfo = getConfigInfo(mSTFT) +0087 if length(mSTFT.Frange) == 2 +0088 configInfo = sprintf('STFT\tchannel:%d\tseconds:%d\tfrange1:%d\tfrange2:%d',mSTFT.channel,mSTFT.seconds,mSTFT.Frange(1),mSTFT.Frange(2)); +0089 else +0090 configInfo = sprintf('STFT\tchannel:%d\tseconds:%d\tfrange1:%d\tfrange2:unset',mSTFT.channel,mSTFT.seconds,mSTFT.Frange(1)); +0091 end +0092 end +0093 +0094 +0095 function time = getTime(mSTFT) +0096 time = mSTFT.avgTime; +0097 end +0098 end +0099 +0100 end +0101
| Master index |
+Index for +eegtoolkit/+featextraction/@STFT |
+
+| Master index |
+Index for +eegtoolkit/+featextraction/@STFT |
| STFT |
0001 classdef FEAST < eegtoolkit.featselection.FeatureSelectionBase +0002 properties (Constant) +0003 ALGORITHM_MIM = 'mim'; +0004 ALGORITHM_MRMR = 'mrmr'; +0005 ALGORITHM_CMIM = 'cmim'; +0006 ALGORITHM_JMI = 'jmi'; +0007 ALGORITHM_DISR = 'disr'; +0008 ALGORITHM_CIFE = 'cife'; +0009 ALGORITHM_ICAP = 'icap'; +0010 ALGORITHM_CONDRED = 'condred'; +0011 ALGORITHM_CMI = 'cmi'; +0012 ALGORITHM_RELIEF = 'relief'; +0013 ALGORITHM_MIFS = 'mifs' %beta parameter required +0014 ALGORITHM_BETAGAMMA = 'betagamma'; %beta and gamma parameters required +0015 ALGORITHM_FCBF = 'fcbf'; %threshold parameter required +0016 end +0017 properties (Access = public) +0018 algorithm; +0019 numToSelect; +0020 parameter1; +0021 parameter2; +0022 avgTime; +0023 end +0024 +0025 methods +0026 function FF = FEAST(instanceSet,algorithm, numtoSelect, param1, param2) +0027 if nargin == 0 +0028 FF.algorithm = 'icap'; +0029 FF.numToSelect = 85; +0030 end +0031 if nargin > 1 +0032 FF.originalInstanceSet = instanceSet; +0033 FF.algorithm = algorithm; +0034 end +0035 if nargin > 2 +0036 FF.numToSelect = numtoSelect; +0037 end +0038 if nargin > 3 +0039 FF.parameter1 = param1; +0040 end +0041 if nargin > 4 +0042 FF.parameter2 = param2; +0043 end +0044 end +0045 +0046 function FF = compute(FF) +0047 tic +0048 if (strcmp(FF.algorithm,FF.ALGORITHM_MIFS) == 1) || (strcmp(FF.algorithm, FF.ALGORITHM_FCBF) == 1) +0049 indices = feast(FF.algorithm, FF.numToSelect, FF.originalInstanceSet.getInstances, FF.originalInstanceSet.getLabels, FF.parameter1); +0050 elseif strcmp(FF.algorithm, FF.ALGORITHM_BETAGAMMA) == 1 +0051 indices = feast(FF.algorithm, FF.numToSelect, FF.originalInstanceSet.getInstances, FF.originalInstanceSet.getLabels, FF.parameter1, FF.parameter2); +0052 else +0053 indices = feast(FF.algorithm, FF.numToSelect, FF.originalInstanceSet.getInstances, FF.originalInstanceSet.getLabels); +0054 end +0055 dataset = FF.originalInstanceSet.getInstances; +0056 [inst, ~] = size(dataset); +0057 FF.avgTime = toc/inst; +0058 FF.filteredInstanceSet = eegtoolkit.util.InstanceSet([dataset(:,indices) FF.originalInstanceSet.getLabels]); +0059 end +0060 +0061 function configInfo = getConfigInfo(FF) +0062 if (strcmp(FF.algorithm,FF.ALGORITHM_MIFS) == 1) || (strcmp(FF.algorithm, FF.ALGORITHM_FCBF) == 1) +0063 configInfo = sprintf('FEAST\talgorithm:%s\tnumtoselect:%d\tparam1:%d',FF.algorithm, FF.numToSelect, FF.parameter1); +0064 elseif strcmp(FF.algorithm, FF.ALGORITHM_BETAGAMMA) == 1 +0065 configInfo = sprintf('FEAST\talgorithm:%s\tnumtoselect:%d\tparam1:%d\tparam2:%d',FF.algorithm, FF.numToSelect, FF.parameter1, FF.parameter2); +0066 else +0067 configInfo = sprintf('FEAST\talgorithm:%s\tnumtoselect:%d',FF.algorithm, FF.numToSelect); +0068 end +0069 end +0070 +0071 function time = getTime(FF) +0072 time = FF.avgTime; +0073 end +0074 end +0075 +0076 end
| Master index |
+Index for +eegtoolkit/+featselection/@FEAST |
+
+| Master index |
+Index for +eegtoolkit/+featselection/@FEAST |
| FEAST |
Abstract class for feature selection. Implement the functions for any + feature selection method (e.g. PCA, SVD, FEAST, etc.) + + Properties: + originalInstanceSet: Input - the original instanceSet with the features + filteredInstanceSet: Output - the filtered instanceSet + + Functions: +Implement this function to process the originalInstanceSet trials and +return the filteredInstanceSet + obj.compute(); +Info & run time so that the experiments are easily documented. configInfo +is a string with the configuration information and time is of type double. + configInfo = obj.getConfigInfo(); + time = obj.getTime();
0001 % Abstract class for feature selection. Implement the functions for any +0002 % feature selection method (e.g. PCA, SVD, FEAST, etc.) +0003 % +0004 % Properties: +0005 % originalInstanceSet: Input - the original instanceSet with the features +0006 % filteredInstanceSet: Output - the filtered instanceSet +0007 % +0008 % Functions: +0009 %Implement this function to process the originalInstanceSet trials and +0010 %return the filteredInstanceSet +0011 % obj.compute(); +0012 %Info & run time so that the experiments are easily documented. configInfo +0013 %is a string with the configuration information and time is of type double. +0014 % configInfo = obj.getConfigInfo(); +0015 % time = obj.getTime(); +0016 +0017 classdef (Abstract) FeatureSelectionBase < handle +0018 +0019 properties +0020 originalInstanceSet; % Input: The original dataset +0021 filteredInstanceSet; % Output: The filtered dataset +0022 end +0023 +0024 methods (Abstract = true) +0025 obj = compute(obj); +0026 configInfo = getConfigInfo(obj); +0027 time = getTime(obj); +0028 end +0029 +0030 end +0031
| Master index |
+Index for +eegtoolkit/+featselection/@FeatureSelectionBase |
+
+| Master index |
+Index for +eegtoolkit/+featselection/@FeatureSelectionBase |
| FeatureSelectionBase | Abstract class for feature selection. Implement the functions for any |
0001 classdef PCA < eegtoolkit.featselection.FeatureSelectionBase +0002 properties (Access = public) +0003 componentNum; +0004 avgTime; +0005 end +0006 methods +0007 function PCA = PCA(instanceSet,componentNum) +0008 if nargin == 0 +0009 PCA.componentNum = 50; +0010 else +0011 PCA.componentNum = componentNum; +0012 PCA.originalInstanceSet = instanceSet; +0013 end +0014 end +0015 +0016 function PCA = compute(PCA) +0017 ins = PCA.originalInstanceSet.getInstances; +0018 [numInst,~] = size(ins); +0019 tic +0020 [~,score,~,~,~] = pca(ins,'NumComponents',PCA.componentNum); +0021 PCA.avgTime = toc/numInst; +0022 PCA.filteredInstanceSet = eegtoolkit.util.InstanceSet(score,PCA.originalInstanceSet.getLabels); +0023 end +0024 function configInfo = getConfigInfo(PCA) +0025 configInfo = sprintf('PCA\tcomponents:%d', PCA.componentNum); +0026 end +0027 +0028 function time = getTime(PCA) +0029 time = PCA.avgTime; +0030 end +0031 end +0032 end
| Master index |
+Index for +eegtoolkit/+featselection/@PCA |
+
+| Master index |
+Index for +eegtoolkit/+featselection/@PCA |
| PCA |
0001 classdef SVD < eegtoolkit.featselection.FeatureSelectionBase; +0002 properties (Access = public) +0003 modes; +0004 avgTime; +0005 end +0006 methods +0007 function SVD = SVD(instanceSet,modes) +0008 if nargin == 0 +0009 SVD.modes = 80; +0010 else +0011 SVD.modes = modes; +0012 SVD.originalInstanceSet = instanceSet; +0013 end +0014 end +0015 +0016 function SVD = compute(SVD) +0017 tic +0018 [U, S, V] = svd(SVD.originalInstanceSet.getInstances); +0019 data_svd = U*S(:,1:SVD.modes)*V(1:SVD.modes,1:SVD.modes)'; +0020 [numInst, ~] = size(data_svd); +0021 SVD.avgTime = toc/numInst; +0022 SVD.filteredInstanceSet = eegtoolkit.util.InstanceSet(data_svd, SVD.originalInstanceSet.getLabels); +0023 end +0024 function configInfo = getConfigInfo(SVD) +0025 configInfo = sprintf('SVD\tmodes:%d', SVD.modes); +0026 end +0027 +0028 function time = getTime(SVD) +0029 time = SVD.avgTime; +0030 end +0031 end +0032 end
| Master index |
+Index for +eegtoolkit/+featselection/@SVD |
+
+| Master index |
+Index for +eegtoolkit/+featselection/@SVD |
| SVD |
0001 classdef Amuse < eegtoolkit.preprocessing.PreprocessingBase +0002 +0003 properties +0004 first; +0005 last; +0006 avgTime; +0007 end +0008 +0009 methods +0010 function AM = Amuse() +0011 AM.first = 2; +0012 AM.last = 256; +0013 end +0014 +0015 function out = process(AM,in ) +0016 out = {}; +0017 total = 0; +0018 for i=1:length(in) +0019 % i +0020 % in{i}.signal(end,:) = []; +0021 tic +0022 signal = in{i}.signal; +0023 % signal(end,:) = []; +0024 [W,~,yest] = AM.amuse(signal); +0025 signal = pinv(W(AM.first:AM.last,:))*yest(AM.first:AM.last,: ); +0026 total = total + toc; +0027 in{i}.signal = signal; +0028 % out{i} = eegtoolkit.util.Trial(signal,in{i}.label,in{i}.samplingRate,in{i}.subjectid); +0029 end +0030 out = in; +0031 % total = toc; +0032 AM.avgTime = total/length(in); +0033 end +0034 +0035 function configInfo = getConfigInfo(AM) +0036 configInfo = sprintf('Amuse:\t%d-%d',AM.first,AM.last); +0037 end +0038 +0039 function time = getTime(AM) +0040 time = AM.avgTime; +0041 end +0042 end +0043 +0044 methods (Access = private) +0045 function [W,D1,y] = amuse(AM,X) +0046 % BSS using eigenvalue value decomposition +0047 % Program written by A. Cichocki and R. Szupiluk +0048 % +0049 % X [m x N] matrix of observed (measured) signals, +0050 % W separating matrix, +0051 % y estimated separated sources +0052 % p time delay used in computation of covariance matrices +0053 % optimal time-delay default p= 1 +0054 % +0055 % First stage: Standard prewhitening +0056 +0057 [m,N]=size(X); +0058 if nargin==2, +0059 n=m; % +0060 end; +0061 +0062 Rxx=(X*X')/N; +0063 +0064 [Ux,Dx,Vx]=svd(Rxx); +0065 Dx=diag(Dx); +0066 % n=xxx; +0067 if n<m, % under assumption of additive white noise and +0068 %when the number of sources are known or can a priori estimated +0069 Dx=Dx-real((mean(Dx(n+1:m)))); +0070 Q= diag(real(sqrt(1./Dx(1:n))))*Ux(:,1:n)'; +0071 % +0072 else % under assumption of no additive noise and when the +0073 % number of sources is unknown +0074 n=max(find(Dx>1e-199)); %Detection the number of sources +0075 Q= diag(real(sqrt(1./Dx(1:n))))*Ux(:,1:n)'; +0076 end; +0077 +0078 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +0079 % Second stage: Fast separation using sorting EVD +0080 % notation the same as used in the Chapter 4 +0081 Xb=Q*X; +0082 p=1; +0083 % paramter p can take here value different than 1 +0084 % for example -1 or 2. +0085 N=max(size(Xb)); +0086 Xb=Xb-kron(mean(Xb')',ones(1,N)); +0087 +0088 Rxbxbp=(Xb(:,1:N-1)*Xb(:,2:N)')/(N-1); +0089 Rxbxbp= Rxbxbp+Rxbxbp'; +0090 [Vxb Dxb]=eig(Rxbxbp); +0091 [D1 perm]=sort(diag(Dxb)); +0092 D1=flipud(D1); +0093 Vxb=Vxb(:,flipud(perm)); +0094 W = Vxb'*Q; +0095 y = Vxb' * Xb;%change Xb instead of x1 +0096 end +0097 end +0098 +0099 +0100 +0101 end +0102
| Master index |
+Index for +eegtoolkit/+preprocessing/@Amuse |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@Amuse |
| Amuse |
0001 classdef DigitalFilter < eegtoolkit.preprocessing.PreprocessingBase +0002 properties +0003 filt; +0004 info; +0005 avgTime; +0006 end +0007 +0008 methods +0009 function DF = DigitalFilter(filt) +0010 if(nargin > 0) +0011 DF.filt = filt; +0012 end +0013 end +0014 +0015 function out = process(DF,in ) +0016 tic; +0017 for i=1:length(in) +0018 % i +0019 signal = in{i}.signal; +0020 [numChannels, ~] = size(signal); +0021 for j=1:numChannels +0022 if isa(DF.filt,'dfilt.df2sos') || isa(DF.filt,'dfilt.df2') +0023 % signal(j,:) = filter(DF.filt,signal(j,:)); +0024 signal(j,:) = filtfilt(DF.filt.sosMatrix,DF.filt.ScaleValues,signal(j,:)); +0025 elseif isa(DF.filt,'dfilt.dffir') +0026 signal(j,:) = filtfilt(DF.filt.Numerator,1,signal(j,:)); +0027 end +0028 end +0029 in{i}.signal = signal; +0030 end +0031 out = in; +0032 total = toc; +0033 DF.avgTime = total/length(in); +0034 end +0035 +0036 function configInfo = getConfigInfo(DF) +0037 if isempty(DF.info) +0038 configInfo = 'DigitalFilter'; +0039 else +0040 configInfo = strcat('DigitalFilter:\t',info); +0041 end +0042 end +0043 +0044 function time = getTime(DF) +0045 time = DF.avgTime; +0046 end +0047 end +0048 +0049 end +0050
| Master index |
+Index for +eegtoolkit/+preprocessing/@DigitalFilter |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@DigitalFilter |
| DigitalFilter |
0001 classdef FastICA < eegtoolkit.preprocessing.PreprocessingBase +0002 +0003 properties +0004 first; +0005 last; +0006 avgTime; +0007 end +0008 +0009 methods +0010 function ICA = FastICA() +0011 ICA.first = 2; +0012 ICA.last = 256; +0013 end +0014 +0015 function out = process(ICA,in ) +0016 out = {}; +0017 total = 0; +0018 for i=1:length(in) +0019 i +0020 % in{i}.signal(end,:) = []; +0021 tic +0022 signal = in{i}.signal; +0023 % signal(end,:) = []; +0024 % [W,~,yest] = amuse(signal); +0025 % signal = pinv(W(ICA.first:ICA.last,:))*yest(ICA.first:ICA.last,: ); +0026 [icasig, A, W] = fastica (signal); +0027 signal = A(:,ICA.first:end)*icasig(ICA.first:end,:); +0028 total = total + toc; +0029 % in{i}.signal = signal; +0030 out{i} = eegtoolkit.util.Trial(signal,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid,in{i}.type); +0031 end +0032 % out = in; +0033 % total = toc; +0034 ICA.avgTime = total/length(in); +0035 end +0036 +0037 function configInfo = getConfigInfo(ICA) +0038 configInfo = sprintf('FastICA:\t%d-%d',ICA.first,ICA.last); +0039 end +0040 +0041 function time = getTime(ICA) +0042 time = ICA.avgTime; +0043 end +0044 end +0045 +0046 end +0047
| Master index |
+Index for +eegtoolkit/+preprocessing/@FastICA |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@FastICA |
| FastICA |
Abstract class for preprocessing. Implement the functions for any + preprocessing step (e.g. filtering, artifact removal, sub-sampling, + rereferencing, etc. + + Properties: + originalTrials: cell array with the trials to be processed + processedTrials: the processed trials to be returned + + Functions: +Implement this function to process the in trials and return the processed +trials (out) + out = obj.process(in); +Info & run time so that the experiments are easily documented. configInfo +is a string with the configuration information and time is of type double. + configInfo = obj.getConfigInfo(); + time = obj.getTime();
0001 % Abstract class for preprocessing. Implement the functions for any +0002 % preprocessing step (e.g. filtering, artifact removal, sub-sampling, +0003 % rereferencing, etc. +0004 % +0005 % Properties: +0006 % originalTrials: cell array with the trials to be processed +0007 % processedTrials: the processed trials to be returned +0008 % +0009 % Functions: +0010 %Implement this function to process the in trials and return the processed +0011 %trials (out) +0012 % out = obj.process(in); +0013 %Info & run time so that the experiments are easily documented. configInfo +0014 %is a string with the configuration information and time is of type double. +0015 % configInfo = obj.getConfigInfo(); +0016 % time = obj.getTime(); +0017 +0018 classdef PreprocessingBase < handle +0019 +0020 properties +0021 originalTrials; +0022 processedTrials; +0023 end +0024 +0025 methods (Abstract = true) +0026 out = process(obj,in); +0027 configInfo = getConfigInfo(obj); +0028 time = getTime(obj); +0029 end +0030 +0031 end +0032
| Master index |
+Index for +eegtoolkit/+preprocessing/@PreprocessingBase |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@PreprocessingBase |
| PreprocessingBase | Abstract class for preprocessing. Implement the functions for any |
0001 classdef Rereferencing < eegtoolkit.preprocessing.PreprocessingBase +0002 +0003 properties +0004 %meanSignal=1: Subtract the mean from the signal +0005 %meanSignal=2: Average rereferencing +0006 meanSignal; +0007 avgTime; +0008 end +0009 +0010 methods +0011 function RR = Rereferencing() +0012 RR.meanSignal = 1; +0013 end +0014 +0015 function out = process(RR,in) +0016 out = {}; +0017 tic; +0018 for i=1:length(in) +0019 if RR.meanSignal == 1 +0020 [numChannels,~] = size(in{i}.signal); +0021 for j=1:numChannels +0022 in{i}.signal(j,:) = in{i}.signal(j,:) - mean(in{i}.signal(j,:)); +0023 end +0024 elseif RR.meanSignal == 2 +0025 meanChann = mean(in{i}.signal); +0026 in{i}.signal = in{i}.signal-repmat(meanChann,257,1); +0027 end +0028 out = in; +0029 end +0030 RR.avgTime = toc/length(in); +0031 end +0032 +0033 function configInfo = getConfigInfo(RR) +0034 configInfo = sprintf('Rereferencing:\tmeanSignal:%d',RR.meanSignal); +0035 end +0036 +0037 +0038 function time = getTime(RR) +0039 time = RR.avgTime; +0040 end +0041 +0042 end +0043 +0044 end +0045
| Master index |
+Index for +eegtoolkit/+preprocessing/@Rereferencing |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@Rereferencing |
| Rereferencing |
0001 classdef SampleSelection < eegtoolkit.preprocessing.PreprocessingBase +0002 properties +0003 channels; +0004 sampleRange; +0005 samplingRate; +0006 end +0007 +0008 methods +0009 function CS = SampleSelection(channels,sampleRange) +0010 if(nargin == 0) +0011 CS.channels = 126; +0012 CS.sampleRange = [1,1250]; +0013 end +0014 if(nargin > 0) +0015 CS.channels = channels; +0016 end +0017 if nargin > 1 +0018 CS.sampleRange = sampleRange; +0019 end +0020 end +0021 +0022 function out = process(CS,in) +0023 out = {}; +0024 CS.samplingRate = in{1}.samplingRate; +0025 for i=1:length(in) +0026 if(length(CS.channels) > 0) +0027 if(length(CS.sampleRange) > 2) +0028 signal = in{i}.signal(CS.channels,CS.sampleRange); +0029 out{i} = eegtoolkit.util.Trial(signal ... +0030 ,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid); +0031 elseif(length(CS.sampleRange) > 0) +0032 %channels AND sampleRange +0033 signal = in{i}.signal(CS.channels,CS.sampleRange(1):CS.sampleRange(2)); +0034 out{i} = eegtoolkit.util.Trial(signal ... +0035 ,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid); +0036 else +0037 %ONLY channels +0038 signal = in{i}.signal(CS.channels,:); +0039 out{i} = eegtoolkit.util.Trial(signal ... +0040 ,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid); +0041 end +0042 else +0043 if(length(CS.sampleRange) > 2) +0044 signal = in{i}.signal(:,CS.sampleRange); +0045 out{i} = eegtoolkit.util.Trial(signal ... +0046 ,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid); +0047 elseif(length(CS.sampleRange) > 0) +0048 %ONLY sampleRange +0049 signal = in{i}.signal(:,CS.sampleRange(1):CS.sampleRange(2)); +0050 out{i} = eegtoolkit.util.Trial(signal ... +0051 ,in{i}.label,in{i}.samplingRate,in{i}.subjectid,in{i}.sessionid); +0052 else +0053 %NOTHING (?) +0054 disp('Warning: No parameter specified for SampleSelection, using all channels and samples'); +0055 end +0056 end +0057 end +0058 end +0059 +0060 function configInfo = getConfigInfo(CS) +0061 if(length(CS.channels) > 0) +0062 if(length(CS.sampleRange) > 0) +0063 configInfo = 'SampleSelection\tChannels:'; +0064 for i=1:length(CS.channels) +0065 configInfo = strcat(configInfo,sprintf('%d+',CS.channels(i))); +0066 end +0067 configInfo = strcat(configInfo,sprintf('\tsampleRange:%d-%d',CS.sampleRange(1),CS.sampleRange(2))); +0068 else +0069 configInfo = 'SampleSelection\tChannels:'; +0070 for i=1:length(CS.channels) +0071 configInfo = strcat(configInfo,sprintf('%d+',CS.channels(i))); +0072 end +0073 end +0074 else +0075 if(length(CS.sampleRange) > 0) +0076 configInfo = sprintf('SampleSelection\tSampleRange:%d-%d',CS.sampleRange(1),CS.sampleRange(2)); +0077 %ONLY sampleRange +0078 else +0079 %NOTHING (?) +0080 configInfo = sprintf('SampleSelection\tNothing specified'); +0081 end +0082 end +0083 end +0084 +0085 +0086 function time = getTime(CS) +0087 time = 0; +0088 end +0089 +0090 end +0091 +0092 end +0093
| Master index |
+Index for +eegtoolkit/+preprocessing/@SampleSelection |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@SampleSelection |
| SampleSelection |
0001 classdef Windsorize < eegtoolkit.preprocessing.PreprocessingBase +0002 properties +0003 limit_l; +0004 limit_h; +0005 subjectids; +0006 end +0007 +0008 methods +0009 function obj = Windsorize(low,high) +0010 if nargin == 0 +0011 obj.limit_l = 0.05; +0012 obj.limit_h = 0.95; +0013 elseif nargin == 2 +0014 obj.limit_l = low; +0015 obj.limit_h = high; +0016 else +0017 error('2 inputs are required for windsorize, the low and high limits'); +0018 end +0019 end +0020 +0021 function trials = process(obj,trials) +0022 subs = unique(obj.subjectids); +0023 nchannels = size(trials{1}.signal,1); +0024 trial_length = size(trials{1}.signal,2); +0025 for i=1:numel(subs) +0026 ids = find(obj.subjectids == subs(i)); +0027 ntrials = numel(ids); +0028 % Concatenate signal +0029 signal = []; +0030 for j=1:numel(ids) +0031 signal = [signal trials{ids(j)}.signal]; +0032 end +0033 %windsorize +0034 sorted_sig = sort(signal,2); +0035 upbound = sorted_sig(:,round(obj.limit_h*size(signal,2))); +0036 uprep = sorted_sig(:,round(obj.limit_h*size(signal,2))-1); +0037 lowbound = sorted_sig(:,round(obj.limit_l*size(signal,2))); +0038 lowrep = sorted_sig(:,round(obj.limit_l*size(signal,2))+1); +0039 for ch=1:nchannels +0040 signal(ch,signal(ch,:)>upbound(ch)) = uprep(ch); +0041 signal(ch,signal(ch,:)<lowbound(ch)) = lowrep(ch); +0042 end +0043 temp = mat2cell(signal,nchannels,trial_length*ones(ntrials,1)); +0044 for j=1:numel(ids) +0045 trials{ids(j)}.signal = temp{j}; +0046 end +0047 end +0048 +0049 end +0050 +0051 +0052 function configInfo = getConfigInfo(CS) +0053 configInfo = sprintf('Windsorizing\tLow limit: %f, High limit: %f',CS.limit_l,CS.limit_l); +0054 end +0055 +0056 +0057 function time = getTime(CS) +0058 time = 0; +0059 end +0060 +0061 end +0062 +0063 end +0064
| Master index |
+Index for +eegtoolkit/+preprocessing/@Windsorize |
+
+| Master index |
+Index for +eegtoolkit/+preprocessing/@Windsorize |
| Windsorize |
0001 classdef FusionInstanceSet < eegtoolkit.util.InstanceSet +0002 properties +0003 numFusion; +0004 instanceSets; +0005 end +0006 +0007 methods +0008 function FIS = FusionInstanceSet(baseInstanceSet) +0009 FIS = FIS@eegtoolkit.util.InstanceSet(baseInstanceSet.getDataset); +0010 FIS.numFusion = 0; +0011 FIS.instanceSets = {}; +0012 end +0013 +0014 function FIS = addInstanceSet(FIS, instanceSet) +0015 FIS.numFusion = FIS.numFusion + 1; +0016 FIS.instanceSets{FIS.numFusion} = instanceSet; +0017 end +0018 +0019 function FIS = removeInstancesWithIndices(FIS, indices) +0020 for i=1:length(FIS.instanceSets) +0021 FIS.instanceSets{i} = FIS.instanceSets{i}.removeInstancesWithIndices(indices); +0022 end +0023 end +0024 +0025 function instances = getInstancesWithIndices(FIS, indices) +0026 instances = zeros(length(indices),FIS.getNumFeatures,FIS.numFusion); +0027 for i=1:length(FIS.instanceSets) +0028 instances(:,:,i) = FIS.instanceSets{i}.getInstancesWithIndices(indices); +0029 end +0030 end +0031 end +0032 +0033 end
| Master index |
+Index for +eegtoolkit/+util/@FusionInstanceSet |
+
+| Master index |
+Index for +eegtoolkit/+util/@FusionInstanceSet |
| FusionInstanceSet |
A class for describing a set of instances and labels + + Properties: + -instances : a m x n matrix where m = # instances and n = + # features + -labels: a m x 1 matrix containing the labels for each + instance + -K: a m x m matrix containing the kernel of the instances + required only for the Fast vesrion of LibSVM + + Functions: +Construct an instanceSet + IS = eegtoolkit.util.InstanceSet(instances, labels) +Compute the kernel + K = IS.computeKernel(kernel, gamma, maxlag, scaleopt) + kernel can be one of 'linear' (default),'rbf','chi','xcorr','spearman', + 'correlation','cosine','euclidean','seuclidean','mahalanobis' +Get the training kernel with indexes in the trainidx vector + Ktrain = IS.getTrainKernel(trainidx) +Get the test kernel with test indexes testidx and train indexes trainidx + Ktest = IS.getTestKernel(trainidx, testidx) +Get instances of specific indices in vector idx + instance = IS.getInstancesWithIndices(idx) +Get the instances of a specific label + instances = IS.getInstancesForLabel(label) +Get the indices corresponding to a specific label + indices = IS.getInstanceIndicesForLabel(label) +Get the instances including the labels as the last row + dataset = getDataset(IS) +Get the instances with specific indices. The last column of the matrix +will contain the label. + dataset = IS.getDatasetWithIndices(idx) +Remove instances with specific indices. A new InstanceSet object is +returned by this function without the specified instances + IS = IS.removeInstancesWithIndices(idx) + Write the dataset to a csv file + IS.writeCSV(csvname) +Write the dataset to a weka-readable file (arff). The whole dataset is +written if the indices are not given (function called with 1 argument) + IS.writeArff(fname, indices)
0001 % A class for describing a set of instances and labels +0002 % +0003 % Properties: +0004 % -instances : a m x n matrix where m = # instances and n = +0005 % # features +0006 % -labels: a m x 1 matrix containing the labels for each +0007 % instance +0008 % -K: a m x m matrix containing the kernel of the instances +0009 % required only for the Fast vesrion of LibSVM +0010 % +0011 % Functions: +0012 %Construct an instanceSet +0013 % IS = eegtoolkit.util.InstanceSet(instances, labels) +0014 %Compute the kernel +0015 % K = IS.computeKernel(kernel, gamma, maxlag, scaleopt) +0016 % kernel can be one of 'linear' (default),'rbf','chi','xcorr','spearman', +0017 % 'correlation','cosine','euclidean','seuclidean','mahalanobis' +0018 %Get the training kernel with indexes in the trainidx vector +0019 % Ktrain = IS.getTrainKernel(trainidx) +0020 %Get the test kernel with test indexes testidx and train indexes trainidx +0021 % Ktest = IS.getTestKernel(trainidx, testidx) +0022 %Get instances of specific indices in vector idx +0023 % instance = IS.getInstancesWithIndices(idx) +0024 %Get the instances of a specific label +0025 % instances = IS.getInstancesForLabel(label) +0026 %Get the indices corresponding to a specific label +0027 % indices = IS.getInstanceIndicesForLabel(label) +0028 %Get the instances including the labels as the last row +0029 % dataset = getDataset(IS) +0030 %Get the instances with specific indices. The last column of the matrix +0031 %will contain the label. +0032 % dataset = IS.getDatasetWithIndices(idx) +0033 %Remove instances with specific indices. A new InstanceSet object is +0034 %returned by this function without the specified instances +0035 % IS = IS.removeInstancesWithIndices(idx) +0036 % Write the dataset to a csv file +0037 % IS.writeCSV(csvname) +0038 %Write the dataset to a weka-readable file (arff). The whole dataset is +0039 %written if the indices are not given (function called with 1 argument) +0040 % IS.writeArff(fname, indices) +0041 +0042 classdef InstanceSet +0043 properties (Access = public) +0044 instances; % the instances +0045 labels; % the labels +0046 K; % the kernel of the instances +0047 end +0048 +0049 methods +0050 function IS = InstanceSet(instances, labels) +0051 % obj = InstanceSet(instances, labels) +0052 +0053 if nargin == 1 +0054 [~, cols] = size(instances); +0055 IS.instances = instances(:,1:cols-1); +0056 IS.labels = instances(:,cols); +0057 elseif nargin==2 +0058 IS.instances = instances; +0059 IS.labels = floor(labels); +0060 end +0061 % for i=1:size(IS.instances,1) +0062 % IS.instances(i,:) = IS.instances(i,:)./norm(IS.instances(i,:)); +0063 % end +0064 end +0065 +0066 function instances = getInstances(IS) +0067 % get the instances +0068 instances = IS.instances; +0069 end +0070 +0071 function K = computeKernel(IS,kernel, gamma, maxlag, scaleopt) +0072 switch kernel +0073 case 'linear' +0074 K = IS.instances*IS.instances'; +0075 case 'rbf' +0076 dist = pdist2(IS.instances,IS.instances).^2; +0077 % N = size(IS.instances,1); +0078 % dist = repmat(sum(IS.instances.^2, 2)', [N 1])' + ... +0079 % repmat(sum(IS.instances.^2,2)', [N 1]) - ... +0080 % 2.*IS.instances*IS.instances'; +0081 K = exp(-gamma.*dist); +0082 case 'chi' +0083 m = size(IS.instances,1); +0084 n = size(IS.instances,1); +0085 mOnes = ones(1,m); D = zeros(m,n); +0086 for i=1:n +0087 yi = IS.instances(i,:); yiRep = yi( mOnes, : ); +0088 s = yiRep + IS.instances; d = yiRep - IS.instances; +0089 D(:,i) = sum( d.^2 ./ (s+eps), 2 ); +0090 end +0091 D = D/2; +0092 K = exp(-gamma.*D); +0093 % error('chi kernel not implemented yet'); +0094 case 'xcorr' +0095 K = zeros(size(IS.instances,1)); +0096 if size(IS.instances,2) < 500 % if memory allows it go for the vectorized version +0097 a = xcorr(IS.instances',maxlag,scaleopt); +0098 c = reshape(a, 2*maxlag+1, size(IS.instances,1), size(IS.instances,1)); +0099 if size(c,1) == 1 % no max is required +0100 K = squeeze(c); +0101 else +0102 K = squeeze(max(c)); +0103 end +0104 else +0105 for i=1:size(IS.instances,1) +0106 for j=i:size(IS.instances,1) +0107 K(i,j)=max(xcorr(IS.instances(i,:),IS.instances(j,:),maxlag,scaleopt)); +0108 K(j,i)=K(i,j); +0109 end +0110 end +0111 end +0112 case {'spearman','correlation','cosine'} +0113 dist = pdist2(IS.instances,IS.instances,kernel); +0114 K = 1-dist; +0115 case {'euclidean','seuclidean','mahalanobis'} +0116 dist = pdist2(IS.instances,IS.instances,kernel).^2; +0117 K = exp(-gamma.*dist); +0118 otherwise % if not one of the above, it can either be any value of distance in pdist2 or a function handle +0119 dist = pdist2(IS.instances,IS.instances,kernel); +0120 K = exp(-gamma.*dist); +0121 end +0122 end +0123 +0124 function Ktrain = getTrainKernel(IS, trainidx) +0125 Ktrain = IS.K(trainidx,trainidx); +0126 end +0127 +0128 function Ktest = getTestKernel(IS, trainidx, testidx) +0129 Ktest = IS.K(testidx,trainidx); +0130 end +0131 +0132 function instance = getInstancesWithIndices(IS, idx) +0133 % get instances of specific indices +0134 instance = IS.instances(idx,:); +0135 end +0136 function labels = getLabels(IS) +0137 % get the labels +0138 labels = IS.labels; +0139 end +0140 +0141 function numLabels = getNumLabels(IS) +0142 % get the number of labels +0143 numLabels = length(unique(IS.getLabels())); +0144 end +0145 +0146 function numInstances = getNumInstances(IS) +0147 % get the number of instances +0148 [numInstances,~] = size(IS.instances); +0149 end +0150 +0151 function numFeatures = getNumFeatures(IS) +0152 % get the number of features +0153 [~, numFeatures] = size(IS.instances); +0154 end +0155 +0156 +0157 function instances = getInstancesForLabel(IS, label) +0158 % get the instances of a specific label +0159 indices = IS.getInstanceIndicesForLabel(label); +0160 instances = IS.getInstances(); +0161 instances = instances(indices,:); +0162 end +0163 +0164 function indices = getInstanceIndicesForLabel(IS,label) +0165 % get the indices corresponding to a specific label +0166 [indices, ~] = find(IS.getDataset()==label); +0167 end +0168 +0169 function dataset = getDataset(IS) +0170 % same with getInstances but includes the labels as the last +0171 % row +0172 dataset = horzcat(IS.instances,IS.labels); +0173 end +0174 +0175 function dataset = getDatasetWithIndices(IS,idx) +0176 % get the instances with specific indices. The last column of +0177 % the matrix will contain the label. +0178 instance = IS.instances(idx,:); +0179 label = IS.labels(idx,:); +0180 dataset = horzcat(instance,label); +0181 end +0182 function IS = removeInstancesWithIndices(IS, idx) +0183 % remove instances with specific indices. A new InstanceSet +0184 % object is returned by this functioned without the specified +0185 % instances +0186 IS.instances(idx,:) = []; +0187 IS.labels(idx,:) = []; +0188 end +0189 function writeCSV(IS, csvname) +0190 % write the dataset to a csv file +0191 % Example: +0192 % obj.writeCSV('data.csv'); +0193 csvwrite(csvname, IS.getDataset()); +0194 end +0195 function writeArff(IS, fname, indices) +0196 % write the dataset to a weka-readable file (arff) +0197 % Caution: filename without extension +0198 % Example: +0199 % obj.writeArff('data') +0200 if nargin==3 +0201 data1 = IS.getDatasetWithIndices(indices); +0202 is1 = eegtoolkit.util.InstanceSet(data1); +0203 data2 = IS.getDatasetWithIndices(~indices); +0204 is2 = eegtoolkit.util.InstanceSet(data2); +0205 is1.writeArff(sprintf('test%s', fname)); +0206 is2.writeArff(sprintf('train%s',fname)); +0207 return; +0208 else +0209 data = IS.getDataset(); +0210 end +0211 % data = horzcat(IS.instances,floor(IS.labels)); +0212 sss=size(data,2)-1; +0213 filename1=strcat(fname,'.arff'); +0214 out1 = fopen (filename1, 'w+'); +0215 aa1=strcat('@relation',{' '},fname,'-weka.filters.unsupervised.attribute.NumericToNominal-Rlast'); +0216 fprintf (out1, '%s\n', char(aa1)); +0217 for jj=1:sss +0218 fprintf (out1, '@attribute %s numeric\n',num2str(jj)); +0219 end +0220 n_classes=max(unique(data(:,end))); +0221 txt1=strcat('@attribute',{' '},num2str(sss+1),{' {'}); +0222 +0223 for ii=1:n_classes +0224 txt1=strcat(txt1,num2str(ii),{','}); +0225 end +0226 txt1=strcat(txt1,{'}'}); +0227 +0228 fprintf (out1, '%s\n\n',char(txt1)); +0229 fprintf (out1,'@data\n'); +0230 +0231 fclose(out1); +0232 +0233 dlmwrite (filename1, data, '-append' ); +0234 end +0235 end +0236 +0237 end +0238
| Master index |
+Index for +eegtoolkit/+util/@InstanceSet |
+
+| Master index |
+Index for +eegtoolkit/+util/@InstanceSet |
| InstanceSet | A class for describing a set of instances and labels |
RESULTSET class + Stores the results of an experiment
0001 % RESULTSET class +0002 % Stores the results of an experiment +0003 classdef L1MCCAInstanceSet < eegtoolkit.util.InstanceSet +0004 +0005 properties +0006 matrix4D; +0007 labelss; +0008 end +0009 +0010 methods +0011 function L1 = L1MCCAInstanceSet(trials) +0012 %Constructor method +0013 %Input: +0014 %(InstanceSet object): the original instanceSet +0015 %Labels: a vector containing the output labels of the +0016 %experiment +0017 %Proababilities: a vector containing the probabilities of each +0018 %label +0019 %Ranking (optional): a matrix containing a score for each label +0020 L1 = L1@eegtoolkit.util.InstanceSet(zeros(1,1000),ones(1,1000)); +0021 if(nargin>0) +0022 numTrials = length(trials); +0023 lbls = zeros(numTrials,1); +0024 for i=1:numTrials +0025 lbls(i) = trials{i}.label; +0026 end +0027 +0028 L1.labelss = lbls; +0029 [numChannels, numSamples] = size(trials{1}.signal); +0030 +0031 L1.matrix4D = zeros(numChannels,numSamples,numTrials,1); +0032 +0033 for i=1:numTrials +0034 L1.matrix4D(:,:,i) = trials{i}.signal; +0035 end +0036 end +0037 +0038 end +0039 +0040 function newL1 = removeInstancesWithIndices(L1,indices) +0041 newL1 = eegtoolkit.util.L1MCCAInstanceSet; +0042 newL1.labelss = L1.labelss; +0043 newL1.labelss(indices) = []; +0044 newL1.matrix4D = L1.matrix4D; +0045 newL1.matrix4D(:,:,indices) = []; +0046 end +0047 +0048 function instances = getInstancesWithIndices(L1,indices) +0049 instances = L1.matrix4D(:,:,indices); +0050 end +0051 +0052 function dataset = getDatasetWithIndices(L1,indices) +0053 instances = zeros(length(indices),1000); +0054 labels = L1.labelss(indices); +0055 dataset = horzcat(instances,labels); +0056 end +0057 +0058 function numInstances = getNumInstances(L1) +0059 [~,~,numInstances] = size(L1.matrix4D); +0060 end +0061 +0062 function dataset = getDataset(L1) +0063 instances = zeros(L1.getNumInstances,1000); +0064 labels = L1.labelss; +0065 dataset = horzcat(instances,labels); +0066 end +0067 +0068 function numLabels = getNumLabels(L1) +0069 numLabels = length(unique(L1.labelss)); +0070 end +0071 end +0072 +0073 end +0074
| Master index |
+Index for +eegtoolkit/+util/@L1MCCAInstanceSet |
+
+| Master index |
+Index for +eegtoolkit/+util/@L1MCCAInstanceSet |
| L1MCCAInstanceSet | RESULTSET class |
0001 classdef LSLWrapper < handle +0002 %LSLWRAPPER Summary of this class goes here +0003 % Detailed explanation goes here +0004 +0005 properties +0006 lib; +0007 datastreaminfo; +0008 datainlet; +0009 dataoutlet; +0010 eventstreaminfo; +0011 eventinlet; +0012 eventoutlet; +0013 preprocessing; +0014 featextraction; +0015 results; +0016 trials; +0017 classification; %pre-trained object required +0018 end +0019 +0020 properties (Access = private) +0021 streamsOK; +0022 samplingRate; +0023 end +0024 +0025 methods +0026 function LSL = LSLWrapper() +0027 LSL.lib = lsl_loadlib; +0028 LSL.streamsOK = 0; +0029 end +0030 +0031 function LSL = resolveStreams(LSL,datastream,maxbuffer,eventstream) +0032 LSL.datastreaminfo = lsl_resolve_byprop(LSL.lib, 'name', datastream); +0033 LSL.eventstreaminfo = lsl_resolve_byprop(LSL.lib, 'name', eventstream); +0034 %get samplingRate from stream info +0035 %samplingRate = ? +0036 if(length(LSL.datastreaminfo) > 0) +0037 LSL.datainlet = lsl_inlet(LSL.datastreaminfo{1},maxbuffer); +0038 LSL.datainlet.pull_chunk; +0039 else +0040 error('Cannot resolve data stream'); +0041 end +0042 if(length(LSL.eventstreaminfo) > 0) +0043 LSL.eventinlet = lsl_inlet(LSL.eventstreaminfo{1},1); +0044 else +0045 error('Cannot resolve event stream'); +0046 end +0047 eventoutletInfo = lsl_streaminfo(LSL.lib,'CommandStream','Markers',1,0,'cf_int32','myuniquesourceid23442'); +0048 LSL.eventoutlet = lsl_outlet(eventoutletInfo); +0049 LSL.samplingRate = LSL.datastreaminfo{1}.nominal_srate; +0050 LSL.streamsOK = 1; +0051 end +0052 function LSL = runExperiment(LSL) +0053 if(LSL.streamsOK ~=1) +0054 error('error: Did you call \"resolveStreams\"?'); +0055 end +0056 strings = {'abstract','concept','objectives','structure','consortium'}; +0057 labels = {4,2,3,5,1,2,5,4,2,3,1,5,4,3,2,4,1,2,5,3,4,1,3,1,3}; +0058 [12 6.66 7.5 8.57 10]; +0059 8.57,6.66,7.5,10,12 +0060 %structure,concept,objectives,consortiu,abstract +0061 LSL.trials = {}; +0062 [y,Fs] = audioread('beep-07.wav'); +0063 tts('get ready'); +0064 pause(10); +0065 for i=1:length(labels) +0066 tts(strings{labels{i}}); +0067 pause(1); +0068 sound(y,Fs); +0069 pause(5); +0070 +0071 chunk = LSL.datainlet.pull_chunk; +0072 trial = eegtoolkit.util.Trial(chunk,0,LSL.samplingRate,0,0); +0073 LSL.trials{length(LSL.trials)+1} = trial; +0074 tts('ok'); +0075 pause(4); +0076 end +0077 end +0078 %EBNeuro_BePLusLTM_192.168.171.81 +0079 function LSL = visualizeDataStream(LSL,windowlength,datastreamname,channel) +0080 % import java.util.Qu +0081 LSL.datastreaminfo = lsl_resolve_byprop(LSL.lib, 'name', datastreamname); +0082 LSL.datainlet = lsl_inlet(LSL.datastreaminfo{1},windowlength/LSL.datastreaminfo{1}.nominal_srate); +0083 % LSL.eventstreaminfo = lsl_resolve_byprop(LSL.lib,'name',eventstreamname); +0084 +0085 % buffer = eegtoolkit.util.CQueue(windowlength); +0086 % % buffer.capacity = windowlength; +0087 buffer = zeros(1,windowlength); +0088 timestampBuffer = zeros(1,windowlength); +0089 eventBuffer = zeros(1,windowlength); +0090 indices = 1:windowlength; +0091 t = 0 ; +0092 x = 0 ; +0093 startSpot = 0; +0094 % interv = windowlength; % considering 1000 samples +0095 step = 0.1 ; % lowering step has a number of cycles and then acquire more data +0096 k =1; +0097 firstTimestamp = []; +0098 while ( 1 ) +0099 % sample = LSL.datainlet.pull_sample; +0100 [samples,timestamps] = LSL.datainlet.pull_chunk; +0101 if isempty(firstTimestamp) +0102 firstTimestamp = timestamps; +0103 end +0104 [~,numPulled] = size(samples); +0105 if(numPulled==0) +0106 continue; +0107 end +0108 % buffer.push(sample(1)); +0109 % buffermat = cell2mat(buffer.content); +0110 buffer = circshift(buffer,[1,-numPulled]); +0111 timestampBuffer = circshift(timestampBuffer,[1,-numPulled]); +0112 buffer(windowlength-numPulled+1:end) = samples(channel,:); +0113 timestampBuffer(windowlength-numPulled+1:end) = timestamps-firstTimestamp; +0114 % buffer(windowlength) = sample(1); +0115 minBuff = min(buffer(buffer~=0)); +0116 maxBuff = max(buffer(buffer~=0)); +0117 plot(timestampBuffer,buffer); +0118 axis([ timestampBuffer(1), timestampBuffer(end)+1, minBuff , maxBuff+1 ]); +0119 xlabel('Seconds'); +0120 % axis([ timestampBuffer(1), timestampBuffer(end), minBuff , maxBuff ]); +0121 grid +0122 +0123 t = t + step; +0124 drawnow; +0125 k = k+1; +0126 % indices = indices + 1; +0127 % pause(0.01) +0128 end +0129 end +0130 +0131 function streams = findStreams(LSL,timeout) +0132 streams = {}; +0133 if(nargin>1) +0134 allInfo = lsl_resolve_all(LSL.lib,timeout); +0135 else +0136 allInfo = lsl_resolve_all(LSL.lib); +0137 end +0138 for i=1:length(allInfo) +0139 streams{i} = allInfo{i}.name; +0140 end +0141 end +0142 function LSL = runSSVEP(LSL,eventStopCode) +0143 if (LSL.streamsOK ~=1) +0144 error('error: Did you call \"resolveStreams\" ?'); +0145 end +0146 while 1 +0147 sample = LSL.eventinlet.pull_sample; +0148 disp(['sample = ', num2str(sample)]); +0149 if(sample==eventStopCode) +0150 % disp('Collecting signal...'); +0151 pause(5); +0152 % disp('Processing...'); +0153 chunk = LSL.datainlet.pull_chunk; +0154 trial = {eegtoolkit.util.Trial(chunk,0,LSL.samplingRate,0,0)}; +0155 for i=1:length(LSL.preprocessing) +0156 trial = LSL.preprocessing{i}.process(trial); +0157 end +0158 LSL.featextraction.trials = trial; +0159 LSL.featextraction.extract; +0160 [output, prob, rank] = LSL.classification.classifyInstance(LSL.featextraction.getInstances); +0161 result = 0; +0162 % plot(chunk') +0163 rank +0164 LSL.results = [LSL.results,output]; +0165 disp(['classif output = ', num2str(output)]); +0166 % LSL.eventoutlet.push_sample(output); +0167 LSL.eventoutlet.push_sample(output-1); +0168 % disp(['prob = ', num2str(prob)]); +0169 end +0170 end +0171 end +0172 +0173 end +0174 +0175 methods(Access = private) +0176 function wav = tts(txt,voice,pace,fs) +0177 %TTS text to speech. +0178 % TTS (TXT) synthesizes speech from string TXT, and speaks it. The audio +0179 % format is mono, 16 bit, 16k Hz by default. +0180 % +0181 % WAV = TTS(TXT) does not vocalize but output to the variable WAV. +0182 % +0183 % TTS(TXT,VOICE) uses the specific voice. Use TTS('','List') to see a +0184 % list of availble voices. Default is the first voice. +0185 % +0186 % TTS(...,PACE) set the pace of speech to PACE. PACE ranges from +0187 % -10 (slowest) to 10 (fastest). Default 0. +0188 % +0189 % TTS(...,FS) set the sampling rate of the speech to FS kHz. FS must be +0190 % one of the following: 8000, 11025, 12000, 16000, 22050, 24000, 32000, +0191 % 44100, 48000. Default 16. +0192 % +0193 % This function requires the Microsoft Win32 Speech API (SAPI). +0194 % +0195 % Examples: +0196 % % Speak the text; +0197 % tts('I can speak.'); +0198 % % List availble voices; +0199 % tts('I can speak.','List'); +0200 % % Do not speak out, store the speech in a variable; +0201 % w = tts('I can speak.',[],-4,44100); +0202 % wavplay(w,44100); +0203 % +0204 % See also WAVREAD, WAVWRITE, WAVPLAY. +0205 +0206 % Written by Siyi Deng; 12-21-2007; +0207 +0208 if ~ispc, error('Microsoft Win32 SAPI is required.'); end +0209 if ~ischar(txt), error('First input must be string.'); end +0210 +0211 SV = actxserver('SAPI.SpVoice'); +0212 TK = invoke(SV,'GetVoices'); +0213 +0214 if nargin > 1 +0215 % Select voice; +0216 for k = 0:TK.Count-1 +0217 if strcmpi(voice,TK.Item(k).GetDescription) +0218 SV.Voice = TK.Item(k); +0219 break; +0220 elseif strcmpi(voice,'list') +0221 disp(TK.Item(k).GetDescription); +0222 end +0223 end +0224 % Set pace; +0225 if nargin > 2 +0226 if isempty(pace), pace = 0; end +0227 if abs(pace) > 10, pace = sign(pace)*10; end +0228 SV.Rate = pace; +0229 end +0230 end +0231 +0232 if nargin < 4 || ~ismember(fs,[8000,11025,12000,16000,22050,24000,32000,... +0233 44100,48000]), fs = 16000; end +0234 +0235 if nargout > 0 +0236 % Output variable; +0237 MS = actxserver('SAPI.SpMemoryStream'); +0238 MS.Format.Type = sprintf('SAFT%dkHz16BitMono',fix(fs/1000)); +0239 SV.AudioOutputStream = MS; +0240 end +0241 +0242 invoke(SV,'Speak',txt); +0243 +0244 if nargout > 0 +0245 % Convert uint8 to double precision; +0246 wav = reshape(double(invoke(MS,'GetData')),2,[])'; +0247 wav = (wav(:,2)*256+wav(:,1))/32768; +0248 wav(wav >= 1) = wav(wav >= 1)-2; +0249 delete(MS); +0250 clear MS; +0251 end +0252 +0253 delete(SV); +0254 clear SV TK; +0255 pause(0.2); +0256 +0257 end % TTS; +0258 end +0259 end +0260
| Master index |
+Index for +eegtoolkit/+util/@LSLWrapper |
+
+| Master index |
+Index for +eegtoolkit/+util/@LSLWrapper |
| LSLWrapper |
0001 classdef RawSignalSet < eegtoolkit.util.InstanceSet +0002 %RAWSIGNALSET Summary of this class goes here +0003 % Detailed explanation goes here +0004 +0005 properties +0006 %numTrials X numChannels X numSamples +0007 signalMatrix; +0008 end +0009 +0010 methods +0011 function RSS = RawSignalSet(trials) +0012 % RSS = RSS@eegtoolkit.util.InstanceSet(zeros(1,1000),ones(1,1000)); +0013 if(nargin~=1) +0014 error('trials parameter not set'); +0015 end +0016 % if(nargin>0) +0017 numTrials = length(trials); +0018 labels = zeros(numTrials,1); +0019 for i=1:numTrials +0020 labels(i) = trials{i}.label; +0021 end +0022 [numChannels, numSamples] = size(trials{i}.signal); +0023 sMatrix = zeros(numTrials,numChannels,numSamples); +0024 for i=1:numTrials +0025 sMatrix(i,:,:) = trials{i}.signal; +0026 end +0027 RSS = RSS@eegtoolkit.util.InstanceSet(squeeze(sMatrix(:,1,:)),labels); +0028 RSS.signalMatrix = sMatrix; +0029 % end +0030 end +0031 +0032 function sMatrix = get(indices) +0033 sMatrix = squeeze(RSS.signalMatrix(indices,:,:)); +0034 end +0035 +0036 function sMatrix = getInstancesWithIndices(RSS,indices) +0037 sMatrix = RSS.signalMatrix(indices,:,:); +0038 end +0039 +0040 function instanceStruct = removeInstancesWithIndices(RSS,indices) +0041 % newRSS = eegtoolkit.util.RawSignalSet; +0042 % newRSS.labels = RSS.labels; +0043 % newRSS.labels(indices) = []; +0044 % newRSS.signalMatrix = RSS.signalMatrix; +0045 % newRSS.signalMatrix(indices,:,:) = []; +0046 sMatrix = RSS.signalMatrix; +0047 sMatrix(indices,:,:) = []; +0048 +0049 labels = RSS.labels; +0050 labels(indices) = []; +0051 instanceStruct = struct('sMatrix',sMatrix, 'labels', labels); +0052 end +0053 +0054 function numInstances = getNumInstances(RSS) +0055 [numInstances,~,~] = size(RSS.signalMatrix); +0056 end +0057 +0058 end +0059 +0060 +0061 end +0062
| Master index |
+Index for +eegtoolkit/+util/@RawSignalSet |
+
+| Master index |
+Index for +eegtoolkit/+util/@RawSignalSet |
| RawSignalSet |
RESULTSET class + Stores the results of an experiment
0001 % RESULTSET class +0002 % Stores the results of an experiment +0003 classdef ResultSet < eegtoolkit.util.InstanceSet +0004 +0005 properties +0006 outputLabels; % The output labels +0007 outputProbabilities; % Probabilities +0008 outputRanking; % Confidence scores +0009 confusionMatrix; % The Confusion Matrix +0010 end +0011 +0012 methods +0013 function RS = ResultSet(instanceSet, labels, probabilities, ranking) +0014 %Constructor method +0015 %Input: +0016 %(InstanceSet object): the original instanceSet +0017 %Labels: a vector containing the output labels of the +0018 %experiment +0019 %Proababilities: a vector containing the probabilities of each +0020 %label +0021 %Ranking (optional): a matrix containing a score for each label +0022 +0023 RS = RS@eegtoolkit.util.InstanceSet(instanceSet); +0024 RS.outputLabels = labels; +0025 +0026 %compute the confusion matrix +0027 labels = unique(RS.getLabels); +0028 numLabels = length(labels); +0029 RS.confusionMatrix = zeros(numLabels); +0030 trueLabels = RS.getLabels; +0031 numInstances = RS.getNumInstances; +0032 for k=1:numInstances +0033 idx1 = find(labels==RS.outputLabels(k,1)); +0034 idx2 = find(labels==trueLabels(k,1)); +0035 RS.confusionMatrix(idx1,idx2) = RS.confusionMatrix(idx1,idx2)+ 1; +0036 end +0037 RS.confusionMatrix = RS.confusionMatrix'; +0038 %if classifier supports ranking/probabilities +0039 if nargin > 2 +0040 RS.outputProbabilities = probabilities; +0041 RS.outputRanking = ranking; +0042 end +0043 end +0044 +0045 function RSSubset = subset(RS,indices) +0046 sOutputLabels = RS.outputLabels(indices); +0047 sOutputProbabilities = RS.outputProbabilities(indices); +0048 sInstanceSet = RS.getDatasetWithIndices(indices); +0049 if isempty(RS.outputProbabilities) +0050 RSSubset = eegtoolkit.util.ResultSet(sInstanceSet,sOutputLabels,sOutputProbabilities); +0051 else +0052 sOutputRanking = RS.outputRanking(indices); +0053 RSSubset = eegtoolkit.util.ResultSet(sInstanceSet,sOutputLabels,sOutputProbabilities,sOutputRanking); +0054 end +0055 end +0056 +0057 end +0058 +0059 end +0060
| Master index |
+Index for +eegtoolkit/+util/@ResultSet |
+
+| Master index |
+Index for +eegtoolkit/+util/@ResultSet |
| ResultSet | RESULTSET class |
SESSION class + Session I/O, splitting sessions into trials and applying filters + + Properties: + trials: A cell array with the Trials of the loaded sessions. + filt: Filter to be applied when data is loaded + sessions: Cell array with the filenames of the dataset + subjectids: Vector with the subject ids corresponding to the loaded trials + sessionids: Vector with the session ids corresponding to the loaded trials + + Functions: +init a session + session = eegtoolkit.util.Session(); +init a session with a filter (created with 'filterbuilder') + session = eegtoolkit.util.Session(filt); +load trials for a subject + session.loadSubject(subjectid); +load a specific session + session.loadSubjectSession(subjectid,sessionid); +load everything + session.loadAll(); +clear loaded data + session.clearData; +apply a filter that was created with 'filterbuilder' + session.applyFilter(filt); + + +DATASETS +1. SSVEP Dataset I (SINGLE) +2. SSVEP Dataset II (MULTI) +3. SSVEP Dataset III (EPOC-MULTI) +4. SSVEP Dataset SCCN +5. ERRP Dataset +6. MI Dataset
0001 % SESSION class +0002 % Session I/O, splitting sessions into trials and applying filters +0003 % +0004 % Properties: +0005 % trials: A cell array with the Trials of the loaded sessions. +0006 % filt: Filter to be applied when data is loaded +0007 % sessions: Cell array with the filenames of the dataset +0008 % subjectids: Vector with the subject ids corresponding to the loaded trials +0009 % sessionids: Vector with the session ids corresponding to the loaded trials +0010 % +0011 % Functions: +0012 %init a session +0013 % session = eegtoolkit.util.Session(); +0014 %init a session with a filter (created with 'filterbuilder') +0015 % session = eegtoolkit.util.Session(filt); +0016 %load trials for a subject +0017 % session.loadSubject(subjectid); +0018 %load a specific session +0019 % session.loadSubjectSession(subjectid,sessionid); +0020 %load everything +0021 % session.loadAll(); +0022 %clear loaded data +0023 % session.clearData; +0024 %apply a filter that was created with 'filterbuilder' +0025 % session.applyFilter(filt); +0026 % +0027 % +0028 %DATASETS +0029 %1. SSVEP Dataset I (SINGLE) +0030 %2. SSVEP Dataset II (MULTI) +0031 %3. SSVEP Dataset III (EPOC-MULTI) +0032 %4. SSVEP Dataset SCCN +0033 %5. ERRP Dataset +0034 %6. MI Dataset +0035 +0036 classdef Session < handle +0037 +0038 properties (Constant) +0039 THRESHOLD_SPLIT_MILLIS = 2000; %Threshold for splitting the trials based on DIN data +0040 end +0041 properties (Access = public) +0042 trials = {}; % Trials of the loaded sessions. +0043 filt; % Filter to be applied when data is loaded +0044 sessions; % Filenames of the dataset +0045 subjectids; % The subject ids corresponding to the loaded trials +0046 sessionids; +0047 end +0048 +0049 +0050 methods (Access = public) +0051 function S = Session() +0052 %S = eegtoolkit.util.Session(); +0053 %Constructs a session object +0054 % +0055 %S = eegtoolkit.util.Session(filt); +0056 %Constructs a session object. A filter will applied to all +0057 %loaded trials +0058 %Dataset I +0059 S.sessions{1,1,1} = 'S001a'; +0060 S.sessions{1,1,2} = 'S001b'; +0061 S.sessions{1,1,3} = 'S001c'; +0062 S.sessions{1,2,1} = 'S002a'; +0063 S.sessions{1,2,2} = 'S002b'; +0064 S.sessions{1,2,3} = 'S002c'; +0065 S.sessions{1,2,4} = 'S002d'; +0066 S.sessions{1,2,5} = 'S002e'; +0067 S.sessions{1,3,1} = 'S003a'; +0068 S.sessions{1,3,2} = 'S003b'; +0069 S.sessions{1,3,3} = 'S003c'; +0070 S.sessions{1,4,1} = 'S004a'; +0071 S.sessions{1,4,2} = 'S004b'; +0072 S.sessions{1,4,3} = 'S004c'; +0073 S.sessions{1,4,4} = 'S004d'; +0074 S.sessions{1,5,1} = 'S005a'; +0075 S.sessions{1,5,2} = 'S005b'; +0076 S.sessions{1,5,3} = 'S005c'; +0077 S.sessions{1,5,4} = 'S005d'; +0078 S.sessions{1,5,5} = 'S005e'; +0079 S.sessions{1,6,1} = 'S006a'; +0080 S.sessions{1,6,2} = 'S006b'; +0081 S.sessions{1,6,3} = 'S006c'; +0082 S.sessions{1,6,4} = 'S006d'; +0083 S.sessions{1,6,5} = 'S006e'; +0084 S.sessions{1,7,1} = 'S007a'; +0085 S.sessions{1,7,2} = 'S007b'; +0086 S.sessions{1,7,3} = 'S007c'; +0087 S.sessions{1,7,4} = 'S007d'; +0088 S.sessions{1,7,5} = 'S007e'; +0089 S.sessions{1,8,1} = 'S008a'; +0090 S.sessions{1,8,2} = 'S008b'; +0091 S.sessions{1,8,3} = 'S008c'; +0092 S.sessions{1,9,1} = 'S009a'; +0093 S.sessions{1,9,2} = 'S009b'; +0094 S.sessions{1,9,3} = 'S009c'; +0095 S.sessions{1,9,4} = 'S009d'; +0096 S.sessions{1,9,5} = 'S009e'; +0097 S.sessions{1,10,1} = 'S010a'; +0098 S.sessions{1,10,2} = 'S010b'; +0099 S.sessions{1,10,3} = 'S010c'; +0100 S.sessions{1,10,4} = 'S010d'; +0101 S.sessions{1,10,5} = 'S010e'; +0102 S.sessions{1,11,1} = 'S013a'; +0103 S.sessions{1,11,2} = 'S013b'; +0104 S.sessions{1,11,3} = 'S013c'; +0105 S.sessions{1,11,4} = 'S013d'; +0106 S.sessions{1,11,5} = 'S013e'; +0107 +0108 %Dataset II +0109 S.sessions{2,1,1} = 'T001a'; +0110 S.sessions{2,1,2} = 'T001b'; +0111 S.sessions{2,1,3} = 'T001c'; +0112 S.sessions{2,1,4} = 'T001d'; +0113 S.sessions{2,1,5} = 'T001e'; +0114 S.sessions{2,2,1} = 'T002a'; +0115 S.sessions{2,2,2} = 'T002b'; +0116 S.sessions{2,2,3} = 'T002c'; +0117 S.sessions{2,2,4} = 'T002d'; +0118 S.sessions{2,2,5} = 'T002e'; +0119 S.sessions{2,3,1} = 'T003a'; +0120 S.sessions{2,3,2} = 'T003b'; +0121 S.sessions{2,3,3} = 'T003c'; +0122 S.sessions{2,3,4} = 'T003d'; +0123 S.sessions{2,3,5} = 'T003e'; +0124 S.sessions{2,4,1} = 'T004a'; +0125 S.sessions{2,4,2} = 'T004b'; +0126 S.sessions{2,4,3} = 'T004c'; +0127 S.sessions{2,4,4} = 'T004d'; +0128 S.sessions{2,4,5} = 'T004e'; +0129 S.sessions{2,5,1} = 'T005a'; +0130 S.sessions{2,5,2} = 'T005b'; +0131 S.sessions{2,5,3} = 'T005c'; +0132 S.sessions{2,5,4} = 'T005d'; +0133 S.sessions{2,5,5} = 'T005e'; +0134 S.sessions{2,6,1} = 'T006a'; +0135 S.sessions{2,6,2} = 'T006b'; +0136 S.sessions{2,6,3} = 'T006c'; +0137 S.sessions{2,6,4} = 'T006d'; +0138 S.sessions{2,6,5} = 'T006e'; +0139 S.sessions{2,7,1} = 'T007a'; +0140 S.sessions{2,7,2} = 'T007b'; +0141 S.sessions{2,7,3} = 'T007c'; +0142 S.sessions{2,7,4} = 'T007d'; +0143 S.sessions{2,7,5} = 'T007e'; +0144 S.sessions{2,8,1} = 'T008a'; +0145 S.sessions{2,8,2} = 'T008b'; +0146 S.sessions{2,8,3} = 'T008c'; +0147 S.sessions{2,8,4} = 'T008d'; +0148 S.sessions{2,8,5} = 'T008e'; +0149 S.sessions{2,9,1} = 'T009a'; +0150 S.sessions{2,9,2} = 'T009b'; +0151 S.sessions{2,9,3} = 'T009c'; +0152 S.sessions{2,9,4} = 'T009d'; +0153 S.sessions{2,9,5} = 'T009e'; +0154 S.sessions{2,10,1} = 'T010a'; +0155 S.sessions{2,10,2} = 'T010b'; +0156 S.sessions{2,10,3} = 'T010c'; +0157 S.sessions{2,10,4} = 'T010d'; +0158 S.sessions{2,10,5} = 'T010e'; +0159 S.sessions{2,11,1} = 'T013a'; +0160 S.sessions{2,11,2} = 'T013b'; +0161 S.sessions{2,11,3} = 'T013c'; +0162 S.sessions{2,11,4} = 'T013d'; +0163 S.sessions{2,11,5} = 'T013e'; +0164 +0165 %Dataset III (Epoc) +0166 S.sessions{3,1,1} = 'U001a'; +0167 S.sessions{3,1,2} = 'U001b'; +0168 S.sessions{3,1,3} = 'U001c'; +0169 S.sessions{3,1,4} = 'U001d'; +0170 S.sessions{3,1,5} = 'U001e'; +0171 S.sessions{3,2,1} = 'U002a'; +0172 S.sessions{3,2,2} = 'U002b'; +0173 S.sessions{3,2,3} = 'U002c'; +0174 S.sessions{3,2,4} = 'U002d'; +0175 S.sessions{3,2,5} = 'U002e'; +0176 S.sessions{3,3,1} = 'U003a'; +0177 S.sessions{3,3,2} = 'U003b'; +0178 S.sessions{3,3,3} = 'U003c'; +0179 S.sessions{3,3,4} = 'U003d'; +0180 S.sessions{3,3,5} = 'U003e'; +0181 S.sessions{3,4,1} = 'U004a'; +0182 S.sessions{3,4,2} = 'U004b'; +0183 S.sessions{3,4,3} = 'U004c'; +0184 S.sessions{3,4,4} = 'U004d'; +0185 S.sessions{3,4,5} = 'U004e'; +0186 S.sessions{3,5,1} = 'U005a'; +0187 S.sessions{3,5,2} = 'U005b'; +0188 S.sessions{3,5,3} = 'U005c'; +0189 S.sessions{3,5,4} = 'U005d'; +0190 S.sessions{3,5,5} = 'U005e'; +0191 S.sessions{3,6,1} = 'U006a'; +0192 S.sessions{3,6,2} = 'U006b'; +0193 S.sessions{3,6,3} = 'U006c'; +0194 S.sessions{3,6,4} = 'U006d'; +0195 S.sessions{3,6,5} = 'U006e'; +0196 S.sessions{3,7,1} = 'U007a'; +0197 S.sessions{3,7,2} = 'U007b'; +0198 S.sessions{3,7,3} = 'U007c'; +0199 S.sessions{3,7,4} = 'U007d'; +0200 S.sessions{3,7,5} = 'U007e'; +0201 S.sessions{3,8,1} = 'U008a'; +0202 S.sessions{3,8,2} = 'U008b'; +0203 S.sessions{3,8,3} = 'U008c'; +0204 S.sessions{3,8,4} = 'U008d'; +0205 S.sessions{3,8,5} = 'U008e'; +0206 S.sessions{3,9,1} = 'U009a'; +0207 S.sessions{3,9,2} = 'U009b'; +0208 S.sessions{3,9,3} = 'U009c'; +0209 S.sessions{3,9,4} = 'U009d'; +0210 S.sessions{3,9,5} = 'U009e'; +0211 S.sessions{3,10,1} = 'U010a'; +0212 S.sessions{3,10,2} = 'U010b'; +0213 S.sessions{3,10,3} = 'U010c'; +0214 S.sessions{3,10,4} = 'U010d'; +0215 S.sessions{3,10,5} = 'U010e'; +0216 S.sessions{3,11,1} = 'U011a'; +0217 S.sessions{3,11,2} = 'U011b'; +0218 S.sessions{3,11,3} = 'U011c'; +0219 S.sessions{3,11,4} = 'U011d'; +0220 S.sessions{3,11,5} = 'U011e'; +0221 +0222 %SCCN dataset +0223 S.sessions{4,1,1} = 's1'; +0224 S.sessions{4,2,1} = 's2'; +0225 S.sessions{4,3,1} = 's3'; +0226 S.sessions{4,4,1} = 's4'; +0227 S.sessions{4,5,1} = 's5'; +0228 S.sessions{4,6,1} = 's6'; +0229 S.sessions{4,7,1} = 's7'; +0230 S.sessions{4,8,1} = 's8'; +0231 S.sessions{4,9,1} = 's9'; +0232 S.sessions{4,10,1} = 's10'; +0233 +0234 %ERRP dataset +0235 S.sessions{5,1,1} = 'EEG_s1.mat'; +0236 S.sessions{5,2,1} = 'EEG_s2.mat'; +0237 S.sessions{5,3,1} = 'EEG_s3.mat'; +0238 S.sessions{5,4,1} = 'EEG_s4.mat'; +0239 S.sessions{5,5,1} = 'EEG_s5.mat'; +0240 S.sessions{5,6,1} = 'EEG_s6.mat'; +0241 S.sessions{5,7,1} = 'EEG_s7.mat'; +0242 S.sessions{5,8,1} = 'EEG_s8.mat'; +0243 +0244 S.sessions{6,1,1} = 'dataset_BCIcomp1.mat'; +0245 +0246 S.sessions{7,1,1} = 'B01T.mat'; +0247 S.sessions{7,1,2} = 'B01T.mat'; +0248 S.sessions{7,2,1} = 'B02T.mat'; +0249 S.sessions{7,2,2} = 'B02T.mat'; +0250 S.sessions{7,3,1} = 'B03T.mat'; +0251 S.sessions{7,3,2} = 'B03T.mat'; +0252 S.sessions{7,4,1} = 'B04T.mat'; +0253 S.sessions{7,4,2} = 'B04T.mat'; +0254 S.sessions{7,5,1} = 'B05T.mat'; +0255 S.sessions{7,5,2} = 'B05T.mat'; +0256 S.sessions{7,6,1} = 'B06T.mat'; +0257 S.sessions{7,6,2} = 'B06T.mat'; +0258 S.sessions{7,7,1} = 'B07T.mat'; +0259 S.sessions{7,7,2} = 'B07T.mat'; +0260 S.sessions{7,8,1} = 'B08T.mat'; +0261 S.sessions{7,8,2} = 'B08T.mat'; +0262 S.sessions{7,9,1} = 'B09T.mat'; +0263 S.sessions{7,9,2} = 'B09T.mat'; +0264 +0265 %MI dataset +0266 % S.sessions{6,1,1} = ; +0267 +0268 +0269 S.subjectids = []; +0270 S.sessionids = []; +0271 end +0272 function S = loadAll(S,experiment) +0273 %loads everything +0274 [~,l,~] = size(S.sessions); +0275 h = waitbar(0,'Loading...'); +0276 for i=1:l +0277 waitbar(i/l,h,'Loading...'); +0278 S.loadSubject(experiment,i); +0279 end +0280 close(h); +0281 end +0282 +0283 function S = loadSubject(S,experiment,subject) +0284 %loads all trials for a specific subject +0285 % +0286 %Example: +0287 % session.loadSubject(1); +0288 %loads all the trials of the 1st subject +0289 [~,~, y] = size(S.sessions); +0290 for i=1:y +0291 if ~isempty(S.sessions{experiment,subject,i}) +0292 S.loadSubjectSession(experiment,subject,i); +0293 end +0294 end +0295 end +0296 function S = loadSubjectSession(S,experiment,subject,session) +0297 %loads all trials for a specific session +0298 % +0299 %Example: +0300 % session.loadSubjectSession(1,2); +0301 %loads the 2nd session of the 1st subject +0302 % +0303 switch(experiment) +0304 case 1 +0305 %Load Dataset I (SINGLE) +0306 load(S.sessions{experiment,subject,session}); +0307 signal = eval('eeg'); +0308 numTrials = length(S.trials) + 1; +0309 curTrials = S.split(signal,DIN_1,subject,session); +0310 for i=1:length(curTrials) +0311 S.trials{numTrials} = curTrials{i}; +0312 numTrials = numTrials + 1; +0313 end +0314 case 2 +0315 %Load Dataset II (MULTI) +0316 load(S.sessions{experiment,subject,session}); +0317 signal = eval('eeg'); +0318 numTrials = length(S.trials) + 1; +0319 curTrials = S.split(signal,DIN_1,subject,session,labels); +0320 for i=1:length(curTrials) +0321 S.trials{numTrials} = curTrials{i}; +0322 numTrials = numTrials + 1; +0323 end +0324 case 3 +0325 %Dataset III (EPOC-MULTI) +0326 SAMPLING_RATE = 128; +0327 load(strcat(S.sessions{experiment,subject,session},'i')); +0328 events = eval('events'); +0329 marks = events(events(:,2)==32779,3); +0330 stops = events(events(:,2)==32780,3); +0331 numTrials = length(S.trials) + 1; +0332 labels = {4,2,3,5,1,2,5,4,2,3,1,5}; +0333 for i=1:length(marks) +0334 signal = eeg(:,marks(i):stops(i) -1); +0335 label = labels{i}; +0336 S.trials{numTrials} = eegtoolkit.util.Trial(signal,label,SAMPLING_RATE,subject,session,eegtoolkit.util.Trial.SSVEP); +0337 numTrials = numTrials + 1; +0338 S.subjectids = [S.subjectids subject]; +0339 S.sessionids = [S.sessionids session]; +0340 end +0341 %load part 2 +0342 load(strcat(S.sessions{experiment,subject,session},'ii')); +0343 events = eval('events'); +0344 marks = events(events(:,2)==32779,3); +0345 stops = events(events(:,2)==32780,3); +0346 numTrials = length(S.trials) + 1; +0347 labels = {4,3,2,4,1,2,5,3,4,1,3,1,3}; +0348 for i=1:length(marks) +0349 signal = eeg(:,marks(i):stops(i) -1); +0350 label = labels{i}; +0351 S.trials{numTrials} = eegtoolkit.util.Trial(signal,label,SAMPLING_RATE,subject,session,eegtoolkit.util.Trial.SSVEP); +0352 numTrials = numTrials + 1; +0353 S.subjectids = [S.subjectids subject]; +0354 S.sessionids = [S.sessionids session]; +0355 end +0356 case 4 +0357 %SCCN Dataset +0358 SAMPLING_RATE = 256; +0359 load(S.sessions{experiment,subject,session}); +0360 [x,y,z,zz] = size(eeg); +0361 numTrials = length(S.trials) + 1; +0362 for i=1:x +0363 for j=1:zz +0364 S.trials{numTrials} = eegtoolkit.util.Trial(squeeze(eeg(i,:,:,j)),i,SAMPLING_RATE,subject,j); +0365 numTrials = numTrials+1; +0366 S.subjectids = [S.subjectids subject]; +0367 S.sessionids = [S.sessionids j]; +0368 end +0369 end +0370 case 5 +0371 %ERRP Dataset +0372 SAMPLING_RATE = 256; +0373 %range of trial in milliseconds based on the stimulus +0374 %event +0375 range = [200,800]; +0376 xstart = round(range(1)*SAMPLING_RATE/1000)-1500; +0377 xend = round(range(2)*SAMPLING_RATE/1000); +0378 load(S.sessions{experiment,subject,session}); +0379 events = {'correct_movement', 'error_movement'}; +0380 numTrials = length(S.trials) + 1; +0381 for ev=1:length(events) +0382 idxev = find(strcmp(EEG.events.name, events{ev})); +0383 epochs.(events{ev}) = zeros(length(xstart:xend), size(EEG.signal,2), length(idxev)); +0384 for i=1:length(idxev) +0385 epochs.(events{ev})(:,:,i) = EEG.signal(EEG.events.position(idxev(i))+xstart:EEG.events.position(idxev(i))+xend,:); +0386 end +0387 GrandAverages.(events{ev}) = mean(epochs.(events{ev}),3); +0388 end +0389 [~,~,numCorrect] = size(epochs.correct_movement); +0390 [~,~,numError] = size(epochs.error_movement); +0391 for i=1:numCorrect +0392 S.trials{numTrials} = eegtoolkit.util.Trial(squeeze(epochs.correct_movement(:,:,i))',1,SAMPLING_RATE,subject,session,eegtoolkit.util.Trial.ERRP); +0393 numTrials = numTrials + 1; +0394 S.subjectids = [S.subjectids subject]; +0395 S.sessionids = [S.sessionids session]; +0396 +0397 end +0398 for i=1:numError +0399 S.trials{numTrials} = eegtoolkit.util.Trial(squeeze(epochs.error_movement(:,:,i))',2,SAMPLING_RATE,subject,session,eegtoolkit.util.Trial.ERRP); +0400 numTrials = numTrials + 1; +0401 S.subjectids = [S.subjectids subject]; +0402 S.sessionids = [S.sessionids session]; +0403 end +0404 case 6 +0405 load(S.sessions{experiment,subject,session}); +0406 [~,~,n] = size(x_train); +0407 numTrials = length(S.trials) + 1; +0408 for i=1:n +0409 signal = squeeze(x_train(:,:,i)); +0410 label = y_train(i); +0411 S.trials{numTrials} = eegtoolkit.util.Trial(signal',label,128,1,1,eegtoolkit.util.Trial.MI); +0412 S.subjectids = [S.subjectids subject]; +0413 S.sessionids = [S.sessionids session]; +0414 numTrials = numTrials + 1; +0415 end +0416 case 7 +0417 load(S.sessions{experiment,subject,session}); +0418 [trialsegm,labels] = segmentGratzB(data{session},0.5,2.5,250); +0419 [n,~,~] = size(trialsegm); +0420 numTrials = length(S.trials) + 1; +0421 for i=1:n +0422 signal = squeeze(trialsegm(i,:,:)); +0423 label = labels(i); +0424 S.trials{numTrials} = eegtoolkit.util.Trial(signal',label,250,subject,session,eegtoolkit.util.Trial.MI); +0425 S.subjectids = [S.subjectids subject]; +0426 S.sessionids = [S.sessionids session]; +0427 numTrials = numTrials + 1; +0428 end +0429 otherwise +0430 error('invalid experiment id'); +0431 end +0432 end +0433 +0434 function S = clearData(S) +0435 %clears loaded data +0436 S.trials = {}; +0437 S.subjectids = []; +0438 S.sessionids = []; +0439 end +0440 end +0441 +0442 methods (Access = private) +0443 function trials = split(S, signal, dins, subjectid, session,labels) +0444 SAMPLING_RATE = 250; +0445 timestamps = cell2mat(dins(2,:)); +0446 samples = cell2mat(dins(4,:)); +0447 [a numDins ]= size(dins); +0448 sampleA= samples(1); +0449 timeA = timestamps(1); +0450 previous = timestamps(1); +0451 ranges = []; +0452 freqs = []; +0453 times = []; +0454 sum = 0; +0455 count = 0; +0456 i=2; +0457 for i=2:numDins +0458 current = timestamps(i); +0459 if(current - previous) > S.THRESHOLD_SPLIT_MILLIS; +0460 sampleB = samples(i-1); +0461 timeB = timestamps(i-1); +0462 freqs = [freqs; (sum/count)]; +0463 % don't ask why +0464 if(sampleB - sampleA>382) +0465 ranges = [ranges ; [sampleA (sampleA+1249)]]; +0466 times = [times; [timeA timeB]]; +0467 end +0468 sampleA = samples(i); +0469 timeA = timestamps(i); +0470 sum = 0; +0471 count = 0; +0472 else +0473 sum = sum + (current-previous); +0474 count = count +1; +0475 end +0476 previous = timestamps(i); +0477 end +0478 % if(isempty(labels)) +0479 sampleB = samples(i-1); +0480 timeB = timestamps(i-1); +0481 freqs = [freqs; (sum/count)]; +0482 ranges = [ranges; [sampleA sampleA+1249]]; +0483 times = [times; [timeA timeB]]; +0484 freqs = freqs*2; +0485 freqs = 1000./freqs; +0486 % end +0487 [numSplits a] = size(ranges); +0488 trials = {}; +0489 i = 1; +0490 for i=1:numSplits +0491 if(nargin>5) +0492 trials{i} = eegtoolkit.util.Trial(signal(:, ranges(i,1):ranges(i,2)), labels{i},SAMPLING_RATE, subjectid,session,eegtoolkit.util.Trial.SSVEP); +0493 S.subjectids = [S.subjectids subjectid]; +0494 S.sessionids = [S.sessionids session]; +0495 else +0496 trials{i} = eegtoolkit.util.Trial(signal(:,ranges(i,1):ranges(i,2)), freqs(i), SAMPLING_RATE, subjectid,session,eegtoolkit.util.Trial.SSVEP); +0497 S.subjectids = [S.subjectids subjectid]; +0498 S.sessionids = [S.sessionids session]; +0499 end +0500 end +0501 end +0502 +0503 +0504 end +0505 end +0506
| Master index |
+Index for +eegtoolkit/+util/@Session |
+
+| Master index |
+Index for +eegtoolkit/+util/@Session |
| Session | SESSION class |
A class that defines a Trial + + Properties: + signal: the signal of the trial, matrix m x n, where m is the channels + and n the samples + label: a label for the trial (typically assigned with the frequency that is calculated using DIN data) + duration: the duration of the trial in seconds + samplingRate: the samling rate used to capture the signal + subjectid: the subject from whom the trial was recorded + sessionid: the session id + type: the type of the trial. Supported types of trials: + SSVEP = 1; + ERRP = 2; + MI = 3;
0001 % A class that defines a Trial +0002 % +0003 % Properties: +0004 % signal: the signal of the trial, matrix m x n, where m is the channels +0005 % and n the samples +0006 % label: a label for the trial (typically assigned with the frequency that is calculated using DIN data) +0007 % duration: the duration of the trial in seconds +0008 % samplingRate: the samling rate used to capture the signal +0009 % subjectid: the subject from whom the trial was recorded +0010 % sessionid: the session id +0011 % type: the type of the trial. Supported types of trials: +0012 % SSVEP = 1; +0013 % ERRP = 2; +0014 % MI = 3; +0015 +0016 classdef Trial < handle +0017 +0018 +0019 properties (Constant) +0020 %Type of trial +0021 SSVEP = 1; +0022 ERRP = 2; +0023 MI = 3; +0024 end +0025 +0026 properties (Access = public) +0027 signal; % the signal of the trial +0028 label; % a label for the trial (typically assigned with the frequency that is calculated using DIN data) +0029 duration; % the duration of the trial in seconds +0030 samplingRate; % the samling rate used to capture the signal +0031 subjectid; %the subject from +0032 sessionid; %the session id +0033 type; +0034 end +0035 +0036 methods (Access = public) +0037 function T = Trial(signal, label, samplingRate, subjectID, sessionID,type) +0038 T.signal = signal; +0039 T.label = label; +0040 T.samplingRate = samplingRate; +0041 T.duration = length(signal)/samplingRate; +0042 T.subjectid = subjectID; +0043 T.sessionid = sessionID; +0044 if nargin>5 +0045 T.type = type; +0046 end +0047 end +0048 +0049 end +0050 +0051 end +0052
| Master index |
+Index for +eegtoolkit/+util/@Trial |
+
+| Master index |
+Index for +eegtoolkit/+util/@Trial |
| Trial | A class that defines a Trial |
Search Results | \n";
+ echo " |
| ".matches_text(0)." | \n"; + echo "|
| ".matches_text($numDocs); + echo "\n"; + echo " | \n"; + echo "|
| $num. | "; + echo "".$doc["name"]." | \n"; + echo "
| Matches: "; + foreach ($doc["words"] as $wordInfo) + { + $word = $wordInfo["word"]; + $matchRight = substr($wordInfo["match"],strlen($word)); + echo "$word$matchRight(".$wordInfo["freq"].") "; + } + echo " | \n"; + echo "
0001 sess = eegtoolkit.util.Session; +0002 sess.loadAll(6); +0003 % +0004 +0005 % load('testingMotorVag1'); +0006 % % load +0007 % sess = eegtoolkit.util.Session; +0008 % % sess.loadMOTOR(labels,trials); +0009 % sess.loadVag(trials,labels); +0010 +0011 ss = eegtoolkit.preprocessing.SampleSelection; +0012 ss.channels = [1,3]; +0013 ss.sampleRange = [384,896]; +0014 +0015 [z,p,k]=butter(3,[8,16]/64); +0016 [s,g]=zp2sos(z,p,k); +0017 Hd = dfilt.df2sos(s,g); +0018 df = eegtoolkit.preprocessing.DigitalFilter; % +0019 df.filt = Hd; +0020 +0021 refer = eegtoolkit.preprocessing.Rereferencing; +0022 refer.meanSignal = 1; +0023 +0024 extr = eegtoolkit.featextraction.RawSignal; +0025 +0026 classif = eegtoolkit.classification.CSPWrapper; +0027 classif.baseClassifier = eegtoolkit.classification.LIBSVM; +0028 +0029 experiment = eegtoolkit.experiment.Experimenter; +0030 experiment.session = sess; +0031 experiment.preprocessing = {ss,refer,df}; +0032 experiment.featextraction = extr; +0033 experiment.classification = classif; +0034 experiment.evalMethod = experiment.EVAL_METHOD_LOOCV; +0035 % experiment.run(); +0036 % experiment.evalMethod = experiment.EVAL_METHOD_XFOLD_CV; +0037 experiment.run(3); +0038 accuracy = experiment.results{1}.getAccuracy(); +0039
0001 m_secs = 0.5:0.5:4; +0002 for ii=1:8 +0003 for jj = 1:8 +0004 sess = eegtoolkit.util.Session; +0005 % sess.loadAll(4); +0006 % sess.loadAll(4); +0007 sess.loadSubject(4,ii); +0008 +0009 ss = eegtoolkit.preprocessing.SampleSelection; +0010 ss.channels = 1:8; +0011 % ss.sampleRange = [75,1024+74]; +0012 ss.sampleRange = [75,74+256*m_secs(jj)]; +0013 % ss.sampleRange = [1,1140]; +0014 % 75:1024+74 +0015 [z,p,k]=butter(3,[6,80]/128); +0016 [s,g]=zp2sos(z,p,k); +0017 Hd = dfilt.df2sos(s,g); +0018 df = eegtoolkit.preprocessing.DigitalFilter; % +0019 df.filt = Hd; +0020 +0021 refer = eegtoolkit.preprocessing.Rereferencing; +0022 refer.meanSignal = 1; +0023 +0024 extr = eegtoolkit.featextraction.RawSignal; +0025 sti_f = [9.25, 11.25, 13.25, 9.75, 11.75, 13.75, 10.25, 12.25, 14.25, 10.75, 12.75, 14.75]; +0026 classif = eegtoolkit.classification.CombiCCA(sti_f,4,256*m_secs(jj),256); +0027 classif.baseClassifier = eegtoolkit.classification.MaxChooser; +0028 +0029 experiment = eegtoolkit.experiment.Experimenter; +0030 experiment.session = sess; +0031 experiment.preprocessing = {ss,refer,df}; +0032 experiment.featextraction = extr; +0033 experiment.classification = classif; +0034 % experiment.evalMethod = experiment.EVAL_METHOD_LOOCV; +0035 % experiment.run(); +0036 experiment.evalMethod = experiment.EVAL_METHOD_LOBO; +0037 experiment.run(); +0038 for i=1:length(experiment.results) +0039 accuracy(i) = experiment.results{i}.getAccuracy(); +0040 end +0041 acc2(ii,jj) = mean(accuracy); +0042 +0043 % accuracy = experiment.results{1}.getAccuracy(); +0044 end +0045 end
Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(1); %Loads dataset I
0001 % Load the data. Call this once outside of the script so you dont have to +0002 % load the data again and again. Make sure the dataset is included in your +0003 % Matlab path +0004 % sess = eegtoolkit.util.Session; +0005 % sess.loadAll(1); %Loads dataset I +0006 +0007 %Load a filter from the samples +0008 load filters/filt_IIRElliptic.mat; +0009 +0010 %Extract features with the pwelch method +0011 extr = eegtoolkit.featextraction.PWelch; +0012 +0013 refer = eegtoolkit.preprocessing.Rereferencing; +0014 %Subtract the mean from the signal +0015 refer.meanSignal = 1; +0016 +0017 ss = eegtoolkit.preprocessing.SampleSelection; +0018 ss.sampleRange = [1,1250]; % Specify the sample range to be used for each Trial +0019 ss.channels = 126; % Specify the channel(s) to be used +0020 +0021 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0022 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0023 +0024 %Configure the classifier +0025 classif = eegtoolkit.classification.LIBSVMFast; +0026 +0027 %Set the Experimenter wrapper class +0028 experiment = eegtoolkit.experiment.Experimenter; +0029 experiment.session = sess; +0030 % Add the preprocessing steps (order is taken into account) +0031 experiment.preprocessing = {ss,refer,df}; +0032 experiment.featextraction = extr; +0033 experiment.classification = classif; +0034 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0035 experiment.run(); +0036 for i=1:length(experiment.results) +0037 accuracies(i) = experiment.results{i}.getAccuracy(); +0038 end +0039 +0040 accuracies' +0041 %mean accuracy for all subjects +0042 fprintf('mean acc = %f\n', mean(accuracies)); +0043 %get the configuration used (for reporting) +0044 experiment.getExperimentInfo +0045 experiment.getTime
Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(3); %its best to do this once, outside the script (too much + time)
0001 % Load the data. Call this once outside of the script so you dont have to +0002 % load the data again and again. Make sure the dataset is included in your +0003 % Matlab path +0004 % sess = eegtoolkit.util.Session; +0005 % sess.loadAll(3); %its best to do this once, outside the script (too much +0006 % time) +0007 +0008 %Load a filter from the samples +0009 load filters/epocfilter; +0010 % 7 = O1 +0011 % 8 = O2 +0012 +0013 % Stimulus frequencies for generating the CCA reference signals +0014 sti_f = [12,10,8.57,7.5,6.66]; +0015 +0016 % CCA feat extraction method +0017 extr = eegtoolkit.featextraction.CCA(sti_f,1:4,128,4); +0018 extr.allFeatures = 1; +0019 +0020 refer = eegtoolkit.preprocessing.Rereferencing; +0021 %Subtract the mean from the signal +0022 refer.meanSignal = 1; +0023 +0024 ss = eegtoolkit.preprocessing.SampleSelection; +0025 ss.sampleRange = [64,640]; % Specify the sample range to be used for each Trial +0026 ss.channels = 6:9; % Specify the channel(s) to be used +0027 +0028 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0029 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0030 +0031 %Configure the classifier +0032 classif = eegtoolkit.classification.LIBSVM; +0033 +0034 %Set the Experimenter wrapper class +0035 experiment = eegtoolkit.experiment.Experimenter; +0036 experiment.session = sess; +0037 % Add the preprocessing steps (order is taken into account) +0038 experiment.preprocessing = {ss,df}; +0039 experiment.featextraction = extr; +0040 experiment.classification = classif; +0041 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0042 experiment.run(); +0043 for i=1:length(experiment.results) +0044 accuracies(i) = experiment.results{i}.getAccuracy(); +0045 end +0046 +0047 accuracies' +0048 %mean accuracy for all subjects +0049 fprintf('mean acc = %f\n', mean(accuracies)); +0050 %get the configuration used (for reporting) +0051 % experiment.getExperimentInfo +0052 % experiment.getTime
d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter');0001 % d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter'); +0002 +0003 sess = eegtoolkit.util.Session; +0004 sess.loadSubject(5,6); +0005 +0006 [z,p,k]=butter(3,[6,40]/128); +0007 [s,g]=zp2sos(z,p,k); +0008 Hd = dfilt.df2sos(s,g); +0009 df = eegtoolkit.preprocessing.DigitalFilter; % +0010 df.filt = Hd; +0011 +0012 ss = eegtoolkit.preprocessing.SampleSelection; +0013 ss.channels = [4,9,14]; +0014 ss.sampleRange = 1500:1:1655; +0015 +0016 extr = {}; +0017 for i=1:3 +0018 extr{i} = eegtoolkit.featextraction.ERRPFeatures; +0019 extr{i}.channel = 1; +0020 end +0021 +0022 aggr = eegtoolkit.aggregation.ChannelConcat; +0023 +0024 classif = eegtoolkit.classification.LIBSVM; +0025 +0026 %Setup experiment +0027 experiment = eegtoolkit.experiment.Experimenter; +0028 experiment.session = sess; +0029 experiment.preprocessing = {df,ss}; +0030 experiment.featextraction = extr; +0031 experiment.aggregator = aggr; +0032 experiment.classification = classif; +0033 experiment.evalMethod = experiment.EVAL_METHOD_XFOLD_CV; +0034 +0035 experiment.run(10); +0036 +0037 accuracies = []; +0038 for i=1:length(experiment.results) +0039 accuracies(i) = experiment.results{i}.getAccuracy(); +0040 end +0041 +0042 accuracies' +0043 fprintf('mean acc = %.2f\n',mean(accuracies));
d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter');0001 % d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter'); +0002 +0003 sess = eegtoolkit.util.Session; +0004 sess.loadSubjectSession(8,5,2); +0005 +0006 [z,p,k]=butter(3,[1,10]/64); +0007 [s,g]=zp2sos(z,p,k); +0008 Hd = dfilt.df2sos(s,g); +0009 df = eegtoolkit.preprocessing.DigitalFilter; % +0010 df.filt = Hd; +0011 +0012 ss = eegtoolkit.preprocessing.SampleSelection; +0013 ss.channels = [1:14]; +0014 ss.sampleRange = [1:6:200]; +0015 +0016 extr = {}; +0017 for i=1:3 +0018 extr{i} = eegtoolkit.featextraction.PWelch; +0019 extr{i}.channel = 1; +0020 end +0021 +0022 aggr = eegtoolkit.aggregation.ChannelConcat; +0023 +0024 classif = eegtoolkit.classification.LIBSVM; +0025 classif.kernel = classif.KERNEL_RBF; +0026 classif.gamma = 1/9; +0027 classif.cost = 1; +0028 +0029 %Setup experiment +0030 experiment = eegtoolkit.experiment.Experimenter; +0031 experiment.session = sess; +0032 experiment.preprocessing = {df,ss}; +0033 experiment.featextraction = extr; +0034 experiment.aggregator = aggr; +0035 experiment.classification = classif; +0036 experiment.evalMethod = experiment.EVAL_METHOD_XFOLD_CV; +0037 +0038 experiment.run(10); +0039 +0040 accuracies = []; +0041 for i=1:length(experiment.results) +0042 accuracies(i) = experiment.results{i}.getAccuracy(); +0043 end +0044 +0045 accuracies' +0046 fprintf('mean acc = %.2f\n',mean(accuracies));
Leave one subject out testing + load filtMAMEM; % load a filter + sess = eegtoolkit.util.Session(Hhp); + sess.loadAll(1); %its best to do this once, outside the script (too much + time) + transf = eegtoolkit.transformer.PWelchTransformer(); + Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(1); %Loads dataset I
0001 % Leave one subject out testing +0002 % load filtMAMEM; % load a filter +0003 % sess = eegtoolkit.util.Session(Hhp); +0004 % sess.loadAll(1); %its best to do this once, outside the script (too much +0005 % time) +0006 % transf = eegtoolkit.transformer.PWelchTransformer(); +0007 % Load the data. Call this once outside of the script so you dont have to +0008 % load the data again and again. Make sure the dataset is included in your +0009 % Matlab path +0010 % sess = eegtoolkit.util.Session; +0011 % sess.loadAll(1); %Loads dataset I +0012 +0013 %Load a filter from the samples +0014 load filters/filt_IIRElliptic; +0015 +0016 +0017 +0018 refer = eegtoolkit.preprocessing.Rereferencing; +0019 %Subtract the mean from the signal +0020 refer.meanSignal = 1; +0021 +0022 ss = eegtoolkit.preprocessing.SampleSelection; +0023 ss.sampleRange = [1,1250]; % Specify the sample range to be used for each Trial +0024 ss.channels = [138,139,150]; % Specify the channel(s) to be used +0025 +0026 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0027 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0028 +0029 +0030 %Extract features with the pwelch method +0031 extr1 = eegtoolkit.featextraction.PWelch; +0032 extr1.channel = 1; %will use channel 138 +0033 +0034 extr2 = eegtoolkit.featextraction.PWelch; +0035 extr2.channel = 2; %will use channel 139 +0036 +0037 extr3 = eegtoolkit.featextraction.PWelch; +0038 extr3.channel = 3; %will use channel 150 +0039 +0040 extr = {extr1,extr2,extr3}; +0041 % Average all three channels so as to get a new feature vector +0042 aggr = eegtoolkit.aggregation.ChannelAveraging; +0043 %Configure the classifier +0044 classif = eegtoolkit.classification.LIBSVM; +0045 +0046 %Set the Experimenter wrapper class +0047 experiment = eegtoolkit.experiment.Experimenter; +0048 experiment.session = sess; +0049 % Add the preprocessing steps (order is taken into account) +0050 experiment.preprocessing = {ss,refer,df}; +0051 experiment.featextraction = {extr1,extr2,extr3}; +0052 experiment.aggregator = aggr; +0053 experiment.classification = classif; +0054 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0055 experiment.run(); +0056 for i=1:length(experiment.results) +0057 accuracies(i) = experiment.results{i}.getAccuracy(); +0058 end +0059 +0060 accuracies' +0061 %mean accuracy for all subjects +0062 fprintf('mean acc = %f\n', mean(accuracies)); +0063 %get the configuration used (for reporting) +0064 experiment.getExperimentInfo +0065 experiment.getTime
Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(3); %its best to do this once, outside the script (too much + time)
0001 % Load the data. Call this once outside of the script so you dont have to +0002 % load the data again and again. Make sure the dataset is included in your +0003 % Matlab path +0004 % sess = eegtoolkit.util.Session; +0005 % sess.loadAll(3); %its best to do this once, outside the script (too much +0006 % time) +0007 +0008 %Load a filter from the samples +0009 load filters/epocfilter; +0010 % 7 = O1 +0011 % 8 = O2 +0012 +0013 % Stimulus frequencies. The order corresponds to the label id (12Hz=1, +0014 % 10Hz=2, 8.57Hz=3, 7.5Hz=4, 6.66Hz=5) +0015 % If the order is wrong, then the "Max" classifier will not work properly +0016 sti_f = [12,10,8.57,7.5,6.66]; +0017 +0018 % CCA feat extraction method +0019 extr = eegtoolkit.featextraction.CCA(sti_f,1:4,128,4); +0020 +0021 refer = eegtoolkit.preprocessing.Rereferencing; +0022 %Subtract the mean from the signal +0023 refer.meanSignal = 1; +0024 +0025 ss = eegtoolkit.preprocessing.SampleSelection; +0026 ss.sampleRange = [64,640]; % Specify the sample range to be used for each Trial +0027 ss.channels = 6:9; % Specify the channel(s) to be used +0028 +0029 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0030 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0031 +0032 %Configure the classifier +0033 classif = eegtoolkit.classification.MaxChooser; +0034 +0035 %Set the Experimenter wrapper class +0036 experiment = eegtoolkit.experiment.Experimenter; +0037 experiment.session = sess; +0038 % Add the preprocessing steps (order is taken into account) +0039 experiment.preprocessing = {ss,df}; +0040 experiment.featextraction = extr; +0041 experiment.classification = classif; +0042 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0043 experiment.run(); +0044 for i=1:length(experiment.results) +0045 accuracies(i) = experiment.results{i}.getAccuracy(); +0046 end +0047 +0048 accuracies' +0049 %mean accuracy for all subjects +0050 fprintf('mean acc = %f\n', mean(accuracies)); +0051 %get the configuration used (for reporting) +0052 % experiment.getExperimentInfo +0053 % experiment.getTime
0001 m_secs = 0.5:0.5:4; +0002 for ii=1:8 +0003 for jj = 1:8 +0004 sess = eegtoolkit.util.Session; +0005 % sess.loadAll(4); +0006 % sess.loadAll(4); +0007 sess.loadSubject(4,ii); +0008 ss = eegtoolkit.preprocessing.SampleSelection; +0009 ss.channels = 1:8; +0010 ss.sampleRange = [75,74+256*m_secs(jj)]; +0011 % ss.sampleRange = [1,1140]; +0012 % 75:1024+74 +0013 h = fdesign.bandpass('N,F3dB1,F3dB2',10,6,80,256); +0014 d1 = design(h,'butter'); +0015 df = eegtoolkit.preprocessing.DigitalFilter; % +0016 df.filt = d1; +0017 +0018 refer = eegtoolkit.preprocessing.Rereferencing; +0019 refer.meanSignal = 1; +0020 +0021 extr = eegtoolkit.featextraction.RawSignal; +0022 +0023 classif = eegtoolkit.classification.ITCCA; +0024 classif.baseClassifier = eegtoolkit.classification.MaxChooser; +0025 +0026 experiment = eegtoolkit.experiment.Experimenter; +0027 experiment.session = sess; +0028 experiment.preprocessing = {ss,refer,df}; +0029 experiment.featextraction = extr; +0030 experiment.classification = classif; +0031 % experiment.evalMethod = experiment.EVAL_METHOD_LOOCV; +0032 % experiment.run(); +0033 experiment.evalMethod = experiment.EVAL_METHOD_LOBO; +0034 experiment.run(); +0035 for i=1:length(experiment.results) +0036 accuracy(i) = experiment.results{i}.getAccuracy(); +0037 end +0038 acc2(ii,jj) = mean(accuracy); +0039 % accuracy = experiment.results{1}.getAccuracy(); +0040 +0041 end +0042 end
0001 +0002 sess = eegtoolkit.util.Session; +0003 sess.loadSubject(4,1); +0004 % load filters/epocfilter; +0005 +0006 sti_f = [9.25, 11.25, 13.25, 9.75, 11.75, 13.75, 10.25, 12.25, 14.25, 10.75, 12.75, 14.75];%Reference signals - +0007 extr = eegtoolkit.featextraction.L1MCCA; +0008 +0009 refer = eegtoolkit.preprocessing.Rereferencing; +0010 refer.meanSignal = 1; +0011 +0012 [z,p,k]=butter(3,[6,80]/128); +0013 % [z,p,k]=butter(3,[5,48]/125); +0014 [s,g]=zp2sos(z,p,k); +0015 Hd = dfilt.df2sos(s,g); +0016 +0017 m_secs = 5; +0018 ss = eegtoolkit.preprocessing.SampleSelection; +0019 ss.sampleRange = [1,1114]; % Specify the sample range to be used for each Trial +0020 ss.channels = [1:8];%Specify the channel(s) to be used +0021 % +0022 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0023 df.filt = Hd; % Hbp is a filter built with "filterbuilder" matlab function +0024 +0025 lcca = eegtoolkit.classification.L1MCCA(256,1114/256,4,sti_f); +0026 +0027 experiment = eegtoolkit.experiment.Experimenter; +0028 experiment.session = sess; +0029 experiment.preprocessing = {ss,refer,df};% Order of preprocessing steps matters. +0030 experiment.featextraction = extr; +0031 experiment.classification = lcca; +0032 experiment.evalMethod = experiment.EVAL_METHOD_LOBO; % specify that you want a "leave one subject out" (default is LOOCV) +0033 %run the experiment +0034 experiment.run(); +0035 accuracies = []; +0036 for i=1:length(experiment.results) +0037 accuracies(i) = experiment.results{i}.getAccuracy(); +0038 end +0039 accuracies' +0040 %mean accuracy for all subjects +0041 fprintf('mean acc = %.2f\n', mean(accuracies));
Add dependencies to the Matlab path, LibLSL is required for this example +to work
0001 %Add dependencies to the Matlab path, LibLSL is required for this example +0002 %to work +0003 addpath liblsl-Matlab\; +0004 addpath liblsl-Matlab\bin\; +0005 addpath liblsl-Matlab\mex\; +0006 %Initialize LSL Wrapper class +0007 lsl = eegtoolkit.util.LSLWrapper; +0008 %Declare the name of the stream that will contain the EEG data +0009 datastream = 'EMOTIVStream'; +0010 %Declare the name of the stream through which the events will be +0011 %communicated +0012 eventstream = 'MyEventStream'; +0013 %Size of signal that will be used for the recognition task +0014 bufferSize = 5; %in seconds +0015 %The event code that will trigger the recognition task +0016 eventCode = 100; +0017 +0018 +0019 % RECOGNITION ALGORITHM CONFIGURATION +0020 +0021 %Indicate the number of stimuli (5) and their frequencies +0022 stimulus_frequencies = [12 10 8.57 7.5 6.66]; +0023 +0024 %Filtering the eeg data +0025 % df = eegtoolkit.preprocessing.DigitalFilter; +0026 % %This filter was created via the 'filterbuilder' method of Matlab +0027 % df.filt = Hbp; +0028 +0029 %Indicate which channels of the data (different electrodes) will be used +0030 ss = eegtoolkit.preprocessing.SampleSelection; +0031 %We will use all EPOC channels for this example +0032 channels = 1:1:14; +0033 ss.channels = channels; +0034 ss.sampleRange = [1,128]; +0035 +0036 %Sampling rate for the EPOC headset is 128Hz +0037 samplingRate = 128; +0038 +0039 %Another required parameter for the CCA algorithm +0040 numberOfHarmonics = 4; +0041 %Initialize the Canonical Correlation Analysis class for the stimuli +0042 %recognition +0043 cca = eegtoolkit.featextraction.CCA(stimulus_frequencies,channels,samplingRate,numberOfHarmonics); +0044 +0045 %Simple classifier that uses the max value of the features to assign the +0046 %label +0047 maxC = eegtoolkit.classification.MaxChooser; +0048 +0049 %Assign the algorithm configuration to the LSL Wrapper class +0050 lsl.preprocessing = {ss}; +0051 lsl.featextraction = cca; +0052 lsl.classification = maxC; +0053 +0054 %Find the streams in the network +0055 lsl.resolveStreams(datastream,bufferSize,eventstream); +0056 %Pause for 5 seconds to allow the stream to gather some data +0057 pause(bufferSize); +0058 %Run the recognition task. The task runs indefinetely until is specifically +0059 %interrupted +0060 lsl.runSSVEP(eventCode);
Leave one subject out testing + load filtMAMEM; % load a filter + sess = eegtoolkit.util.Session(Hhp); + sess.loadAll(1); %its best to do this once, outside the script (too much + time) + transf = eegtoolkit.transformer.PWelchTransformer(); + Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(1); %Loads dataset I
0001 % Leave one subject out testing +0002 % load filtMAMEM; % load a filter +0003 % sess = eegtoolkit.util.Session(Hhp); +0004 % sess.loadAll(1); %its best to do this once, outside the script (too much +0005 % time) +0006 % transf = eegtoolkit.transformer.PWelchTransformer(); +0007 % Load the data. Call this once outside of the script so you dont have to +0008 % load the data again and again. Make sure the dataset is included in your +0009 % Matlab path +0010 % sess = eegtoolkit.util.Session; +0011 % sess.loadAll(1); %Loads dataset I +0012 +0013 %Load a filter from the samples +0014 load filters/filt_IIRElliptic; +0015 +0016 +0017 +0018 refer = eegtoolkit.preprocessing.Rereferencing; +0019 %Subtract the mean from the signal +0020 refer.meanSignal = 1; +0021 +0022 ss = eegtoolkit.preprocessing.SampleSelection; +0023 ss.sampleRange = [1,1250]; % Specify the sample range to be used for each Trial +0024 ss.channels = [138,139,150]; % Specify the channel(s) to be used +0025 +0026 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0027 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0028 +0029 +0030 %Extract features with the pwelch method +0031 extr1 = eegtoolkit.featextraction.PWelch; +0032 extr1.channel = 1; % will use channel 138 +0033 +0034 extr2 = eegtoolkit.featextraction.PWelch; +0035 extr2.channel = 2; % will use channel 139 +0036 +0037 extr3 = eegtoolkit.featextraction.PWelch; +0038 extr3.channel = 3; % will use channel 150 +0039 +0040 extr = {extr1,extr2,extr3}; +0041 % Generate a special feature vector to be used with fusion classifier +0042 aggr = eegtoolkit.aggregation.LateFusion; +0043 %Configure the classifier +0044 % Generate 3 instances of the "baseClassifier" and output the label by +0045 % majority vote +0046 classif = eegtoolkit.classification.FusionClassifierWrapper; +0047 classif.baseClassifier = eegtoolkit.classification.LIBSVM; +0048 +0049 %Set the Experimenter wrapper class +0050 experiment = eegtoolkit.experiment.Experimenter; +0051 experiment.session = sess; +0052 % Add the preprocessing steps (order is taken into account) +0053 experiment.preprocessing = {ss,refer,df}; +0054 experiment.featextraction = {extr1,extr2,extr3}; +0055 experiment.aggregator = aggr; +0056 experiment.classification = classif; +0057 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0058 experiment.run(); +0059 for i=1:length(experiment.results) +0060 accuracies(i) = experiment.results{i}.getAccuracy(); +0061 end +0062 +0063 accuracies' +0064 %mean accuracy for all subjects +0065 fprintf('mean acc = %f\n', mean(accuracies)); +0066 %get the configuration used (for reporting) +0067 experiment.getExperimentInfo +0068 experiment.getTime
0001 sess = eegtoolkit.util.Session; +0002 sess.loadAll(6); +0003 % +0004 +0005 % load('testingMotorVag1'); +0006 % % load +0007 % sess = eegtoolkit.util.Session; +0008 % % sess.loadMOTOR(labels,trials); +0009 % sess.loadVag(trials,labels); +0010 +0011 ss = eegtoolkit.preprocessing.SampleSelection; +0012 ss.channels = [1,3]; +0013 ss.sampleRange = [384,896]; +0014 +0015 extr1 = eegtoolkit.featextraction.PWelch; +0016 extr1.channel = 1; +0017 +0018 extr2 = eegtoolkit.featextraction.PWelch; +0019 extr2.channel = 2; +0020 +0021 aggr = eegtoolkit.aggregation.ChannelConcat; +0022 +0023 classif = eegtoolkit.classification.MLR; +0024 experiment = eegtoolkit.experiment.Experimenter; +0025 experiment.session = sess; +0026 experiment.preprocessing = {ss}; +0027 experiment.featextraction = {extr1, extr2}; +0028 experiment.aggregator = aggr; +0029 experiment.classification = classif; +0030 experiment.evalMethod = experiment.EVAL_METHOD_LOOCV; +0031 % experiment.run(); +0032 % experiment.evalMethod = experiment.EVAL_METHOD_XFOLD_CV; +0033 experiment.run(); +0034 accuracy = experiment.results{1}.getAccuracy(); +0035
Load the data. Call this once outside of the script so you dont have to + load the data again and again. Make sure the dataset is included in your + Matlab path + sess = eegtoolkit.util.Session; + sess.loadAll(1); %Loads dataset I
0001 % Load the data. Call this once outside of the script so you dont have to +0002 % load the data again and again. Make sure the dataset is included in your +0003 % Matlab path +0004 % sess = eegtoolkit.util.Session; +0005 % sess.loadAll(1); %Loads dataset I +0006 +0007 %Load a filter from the samples +0008 load filters/filt_IIRElliptic; +0009 +0010 extr = eegtoolkit.featextraction.PWelchExperimental; +0011 extr.nfft = 512; +0012 extr.over_len = 0.75; +0013 extr.win_len = 350; +0014 +0015 amu = eegtoolkit.preprocessing.Amuse; +0016 amu.first = 15; +0017 amu.last = 252; +0018 +0019 refer = eegtoolkit.preprocessing.Rereferencing; +0020 %Subtract the mean from the signal +0021 refer.meanSignal = 1; +0022 +0023 ss = eegtoolkit.preprocessing.SampleSelection; +0024 ss.sampleRange = [1,1250]; % Specify the sample range to be used for each Trial +0025 ss.channels = 138; % Specify the channel(s) to be used +0026 +0027 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0028 df.filt = Hbp; % Hbp is a filter built with "filterbuilder" matlab function +0029 +0030 svd = eegtoolkit.featselection.SVD; +0031 svd.modes = 90; +0032 +0033 %Configure the classifier +0034 classif = eegtoolkit.classification.LIBSVMFast; +0035 +0036 %Set the Experimenter wrapper class +0037 experiment = eegtoolkit.experiment.Experimenter; +0038 experiment.session = sess; +0039 % Add the preprocessing steps (order is taken into account) +0040 experiment.preprocessing = {amu,ss,refer,df}; +0041 experiment.featselection = svd; +0042 experiment.featextraction = extr; +0043 experiment.classification = classif; +0044 experiment.evalMethod = experiment.EVAL_METHOD_LOSO; % specify that you want a "leave one subject out" (default is LOOCV) +0045 experiment.run(); +0046 for i=1:length(experiment.results) +0047 accuracies(i) = experiment.results{i}.getAccuracy(); +0048 end +0049 +0050 accuracies' +0051 %mean accuracy for all subjects +0052 fprintf('mean acc = %f\n', mean(accuracies)); +0053 %get the configuration used (for reporting) +0054 experiment.getExperimentInfo +0055 experiment.getTime
0001 clear +0002 +0003 % fileID = fopen('SMFA_Results.txt','a'); +0004 for subn=1:10 +0005 +0006 %Dataset 4 +0007 sess = eegtoolkit.util.Session; +0008 % sess.loadAll(4); +0009 sess.loadSubject(4,subn); +0010 +0011 % %Dataset 2 +0012 % sess = ssveptoolkit.util.Session; +0013 % sess.loadAll(2); +0014 +0015 load filters/filt_IIRElliptic; +0016 +0017 %Dataset 4 +0018 % sti_f = [9.25, 11.25, 13.25, 9.75, 11.75, 13.75, 10.25, 12.25, 14.25, 10.75, 12.75, 14.75]; +0019 % extr = ssveptoolkit.featextraction.CCA(sti_f,[1:8],256,4); +0020 +0021 extr = eegtoolkit.featextraction.MLR_Transf(1:8); +0022 % sti_f = [9.25, 9.75, 10.25, 10.75, 11.25, 11.75, 12.25, 12.75, 13.25, 13.75, 14.25, 14.75]; +0023 % extr = ssveptoolkit.featextraction.CCA(sti_f,1:8,256,4); +0024 +0025 %%Dataset 2 +0026 % sti_f = [12 10 8.57 7.50 6.66]; +0027 % sti_f = [6.66 7.5 8.57 10 12]; +0028 % extr = ssveptoolkit.featextraction.CCA(sti_f,[1:2],250,4); +0029 +0030 % extr = ssveptoolkit.featextraction.OMP(sti_f,[1:2],250,4,16,0); +0031 %sti_f: reference signals +0032 %[1:2]: input=2 channels. Depends on what you set on "ss.channels" e.g. if +0033 %you select 10 channels you need to set "[1:10]" +0034 %250: sampling rate (Dataset 1&2=250) +0035 %4: number of harmonics of the reference signals +0036 +0037 % %Dataset 2 +0038 % amu = ssveptoolkit.preprocessing.Amuse; +0039 % amu.first = 15; +0040 % amu.last = 252; +0041 +0042 refer = eegtoolkit.preprocessing.Rereferencing; +0043 %Subtract the mean from the signal +0044 refer.meanSignal = 1; +0045 +0046 %Dataset 4 +0047 % m_secs = 2; +0048 +0049 % %Dataset 2 +0050 % m_secs = 5; +0051 +0052 ss = eegtoolkit.preprocessing.SampleSelection; +0053 +0054 %Dataset 4 +0055 onset=39; +0056 %delay of the visual system +0057 visual_delay = 35; +0058 ss.sampleRange = [onset+visual_delay+1,onset+visual_delay+1*256]; +0059 ss.channels = 1:8; +0060 % ss.channels = 7; +0061 +0062 % %Dataset 2 +0063 % ss.sampleRange = [1,250*m_secs]; % Specify the sample range to be used for each Trial +0064 % % ss.channels = [116,126,137,138,139,147,150];%[126,138]%Specify the channel(s) to be used +0065 % ss.channels = [126,138]; +0066 +0067 %Dataset 4 +0068 df = eegtoolkit.preprocessing.DigitalFilter; % Apply a filter to the raw data +0069 [z,p,k]=butter(3,[6,80]/128); +0070 [s,g]=zp2sos(z,p,k); +0071 Hd = dfilt.df2sos(s,g); +0072 df.filt = Hd; +0073 +0074 Res = zeros(length(1:4:10),length(1:4:100)); +0075 +0076 % Set parameter grid to search +0077 % for qq=1:10 +0078 % for ww=1:25 +0079 +0080 %Number of subclasses per class +0081 NumS = 2*ones(1,12); +0082 +0083 S = 0.4; +0084 % kInt = qq; +0085 % kPen = 4*(ww-1)+1; +0086 kInt = 3; +0087 kPen = 50; +0088 classif = eegtoolkit.classification.SMFA(0,NumS,S,kInt,kPen); +0089 +0090 experiment = eegtoolkit.experiment.Experimenter; +0091 experiment.session = sess; +0092 +0093 %Dataset 4 +0094 experiment.preprocessing = {ss,refer,df}; +0095 +0096 % %Dataset 2 +0097 % experiment.preprocessing = {amu,ss,refer,df};% Order of preprocessing steps matters. +0098 +0099 experiment.featextraction = extr; +0100 experiment.classification = classif; +0101 experiment.evalMethod = experiment.EVAL_METHOD_LOBO; % specify that you want a "leave one subject out" (default is LOOCV) +0102 % experiment.evalMethod = experiment.EVAL_METHOD_LOOCV; +0103 +0104 %run the experiment +0105 experiment.run(); +0106 accuracies = []; +0107 for i=1:length(experiment.results) +0108 accuracies(i) = experiment.results{i}.getAccuracy(); +0109 end +0110 % accuracies' +0111 % mean accuracy for all subjects +0112 % fprintf('mean acc = %.2f\n', mean(accuracies)); +0113 subaccuracies(subn) = mean(accuracies); +0114 end +0115 fprintf('mean acc for all subjects %.2f\n',mean(subaccuracies));
 Master index |
+Index for .  |
+
+| Master index |
+Index for . |
 exampleCSP | |
| exampleCombiCCA | |
| exampleDefault | Load the data. Call this once outside of the script so you dont have to |
| exampleEPOCCCASVM | Load the data. Call this once outside of the script so you dont have to |
| exampleERRP | d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter'); |
| exampleERRPSSVEPDemo | d2 = designfilt('bandpassiir', 'SampleRate', 256, 'FilterOrder', 8 ,'HalfPowerFrequency1', 1, 'HalfPowerFrequency2', 10,'DesignMethod', 'butter'); |
| exampleEarlyFusion | Leave one subject out testing |
| exampleEpoc | Load the data. Call this once outside of the script so you dont have to |
| exampleITCCA | |
| exampleL1MCCA | |
| exampleLSL | Add dependencies to the Matlab path, LibLSL is required for this example |
| exampleLateFusion | Leave one subject out testing |
| exampleMotorPWelch | |
| exampleOptimal | Load the data. Call this once outside of the script so you dont have to |
| exampleSMFA |