Diffusion Simon Botrylloides Regeneration Group (master) Browse

classify_species.m
273481ed69b2master

classify_species.m
View Options

			% CLASSIFY_SPECIES identifies a list of characteristics able to classify
			% different categories, namely species.
			%
			% [DECISIONS] = CLASSIFY_SPECIES(CHARACTERISTICS, SCORE, PARAMS) will return
			% a list of indexes DECISIONS represented the ordered list of CHARACTERISTICS
			% used to classify the input catergories. CHARACTERISTICS is a NxM numeric
			% matrix whith N characteristics and M categories. Values 0 indicate that
			% no information is avaiable for this characteristic/category pair. Values
			% with floating-values indicate a group of characteristics with possible
			% confusion, the most-likely category is encoded by the decimal part. SCORE
			% is a function handle of the form SCORE(CHARACTERISTICS, INDEXS, PARAMS)
			% allowing to quantify the discriminative power of each CHARACTERISTICS.
			% INDEXS are the IDs of the current categories (for sub-graphs) and PARAMS
			% are parameters specific for the SCORE function (e.g. weights).
			%
			% [DECISIONS, ITERATIONS] = CLASSIFY_SPECIES(...) returns in addition the
			% list of discriminated categories until identification followed during the
			% classification process.
			%
			% Blanchoud Group, UNIFR
			% Simon Blanchoud
			% 24/06/2020
			function [decis, iters] = classify_species(data, scoring_func, params)

			% Get the dimensions of the data
			[nvect, nclass] = size(data);

			% Identify the possible classification groups assigned by the characteristics
			groups = unique(round(data(:)));
			ngrps = length(groups);

			% Check if we have unknown values and conflicting ones
			has_unknown = (groups(1)==0);
			has_conflict = unique(round(data(~ismember(data, groups))));

			% Prepare the data based on the most-likely values for conflicting data
			data2 = round(data);
			tmp = round(mod(data, 1)*10);
			data2(ismember(data2, has_conflict)) = tmp(ismember(data2, has_conflict));

			% Here we pre-process which classification group is assigned to which
			% category by each characteristic
			isgrp = bsxfun(@eq, data2, reshape(groups, [1 1 ngrps]));

			% Prepare the output data
			iters = cell(nvect, 1);
			decis = zeros(nvect, 1);

			% Prepare the data required to keep track of the classification process
			identified = zeros(1, nclass); % Initially no category is identified
			categorized = zeros(1, nclass); % No category was classified yet
			indexes = [1:nvect].'; % We can still use all characteristics
			classes = {[1:nclass]}; % All categories are in the same element

			% The main loop, we can run it at the maximum nvect times
			% as we use one per iteration
			for i=1:nvect

			% Step 1: first of all we need to select one characteristic to use

			% The current number of classification elements
			nelems = length(classes);

			% Compute the cumulative score of the remaining characteristics
			weights = zeros(length(indexes), 1);
			for j=1:nelems
			% The score is computed on each classification element separately
			subdata = data(indexes, classes{j});
			weights = weights + scoring_func(subdata, indexes, params);
			end

			% Select the highest-scoring characteristic
			[values, indx] = max(weights);
			indx = indexes(indx);

			% Prepare temporary variables to handle the new classification
			new_classes = cell(1, nelems*ngrps);
			new_unknowns = cell(1, nelems*ngrps);

			% Step 2: second we use the selected characteristic to separate the
			% categories based on the characteristics' groups

			% We process each classification element separately
			for j=1:nelems

			% Pre-compute the current index basis
			refj = (j-1)*ngrps;

			% Use a temporary variable to record newly categorized elements
			new_categorized = zeros(1, nclass);

			% We extract for each possible group which category is assigned
			% to it by the selected category.
			% So here we split the categories based on the values of the
			% categories table.
			for k=1:ngrps
			new_classes{refj + k} = classes{j}(isgrp(indx,classes{j},k));

			% We acknowledge the categorization
			new_categorized(new_classes{refj + k}) = 1;
			end

			% If we have an unknown group, isolate it and propagate it to the whole
			% set of classification elements (as we don't know to which they belong)
			if (has_unknown)
			new_unknowns(refj+1:jngrps) = new_classes((refj + 1)ones(1,ngrps));
			new_classes{(refj+1)} = [];

			% We need to remove the unknowns from our newly categorized elements
			new_categorized(new_unknowns{refj+1}) = 0;
			end

			% We store the information
			categorized = categorized \| new_categorized;
			end

			% Step 3: we find and remove "identified" categories, those are categories
			% alone in their classification element as this means that we can identify
			% them unambiguously.

			% Record the current number of identified categories to see if we progress
			nid = sum(identified);

			% At the most, we need to check all categories
			for k=1:nclass

			% Get the number of elements in each classification element and unknowns
			sizes = cellfun('numel', new_classes);
			sunkn = cellfun('numel', new_unknowns);

			% New identifications are categories alone in their element, without
			% potential unknowns attached to it
			alones = cat(2, new_classes{sizes==1 & sunkn==0});

			% Set these new identifications
			identified(alones) = 1;

			% Next we remove these newly identified categories from other elements
			% and unknowns
			for j=1:nelems*ngrps

			% We want to keep the new "alones" so we don't delete single elements
			if (sizes(j)>1 \|\| (sizes(j)==1 && sunkn(j)>0))
			new_classes{j} = new_classes{j}(~identified(new_classes{j}));
			end

			% We also remove them from the unknowns
			if (sunkn(j)>0)
			new_unknowns{j} = new_unknowns{j}(~identified(new_unknowns{j}));
			end
			end

			% We check if we were able to increse the number of identified categories
			new_nid = sum(identified);

			% If not, we stop here. Otherwise we repeat the whole process
			if (new_nid == nid)
			break
			end

			% Update the counts for the next iteration
			nid = new_nid;
			end

			% Step 4: We update the categories to include the unknowns
			if (has_unknown)

			% We extract the number of categories in each element
			sizes = cellfun('numel', new_classes);
			sunkn = cellfun('numel', new_unknowns);
			for j=1:nelems

			% Pre-compute the current index basis
			refj = (j-1)*ngrps;

			% In case we have no more categories in any group, we need
			% to insert the unknowns in at least one of them to avoid loosing them
			if (all(sizes(refj+[1:ngrps])==0))
			if (sunkn(refj+ngrps)~=0)

			% We move the unknowns into the last group, it could be any other
			new_classes{refj+ngrps} = new_unknowns{refj+ngrps};

			% In the case of single-element unknowns, we have also identified
			% it by elimination. This assumption could be wrong in the special
			% case where this element was only classified by the unknown class.
			% Hopefully this is rather rare and unlikely. We just report it.
			if (sunkn(refj+ngrps)==1)
			identified(new_unknowns{refj+ngrps}) = 1;

			if (~categorized(new_unknowns{refj+ngrps}))
			disp(['Category ' num2str(new_unknowns{refj+ngrps}) ...
			' was marked as identified but never categorized!']);
			end
			end
			end

			% Otherwise, we append to the non-empty elements the corresponding
			% unknown ones
			else
			for k=1:ngrps
			if (sizes(refj+k)>0 && sunkn(refj+k)>0)
			new_classes{refj+k} = [new_classes{refj+k} new_unknowns{refj+k}];
			end
			end
			end
			end
			end

			% Step 5: we remove "identified" categories once more in case they were
			% identified indirectly

			% At the most, we need to check all categories
			for k=1:nclass

			% Get the number of elements in each classification element
			sizes = cellfun('numel', new_classes);
			nid = sum(identified);

			% We remove the identified categories from other elements
			for j=1:nelems*ngrps

			% We still want to keep the identified elements
			if (sizes(j)>1)
			new_classes{j} = new_classes{j}(~identified(new_classes{j}));
			end
			end

			% New identifications are categories alone in their element
			sizes = cellfun('numel', new_classes);
			alones = cat(2, new_classes{sizes==1});

			% Set these new identifications
			identified(alones) = 1;

			% We check if we were able to increse the number of identified categories
			new_nid = sum(identified);

			% If not, we stop here. Otherwise we repeat the whole process
			if (new_nid == nid)
			break
			end
			end

			% Step 6: Cleanup and prepare for the next iteration

			% Get the number of categories in each element
			sizes = cellfun('numel', new_classes);

			% We keep only the non-empty ones
			new_classes = new_classes(sizes>0);
			sizes = sizes(sizes>0);

			% Check if we have actually classified some categories
			new_elems = length(new_classes);

			% If we didn't, that means the selected characteristic had no discriminative
			% value, so we don't store it
			if (nelems ~= new_elems)
			decis(i) = indx;
			end

			% Keep track of the classification process
			iters{i} = new_classes;

			% Remove the used characteristic and the identified elements
			indexes = indexes(indexes ~= indx);
			classes = new_classes(sizes>1);

			% If we have identified all the categories, we can then stop here
			if (all(identified))
			break;
			end
			end

			% Keep only the discriminating steps
			iters = iters(decis > 0);
			decis = decis(decis > 0);

			% Notify if there was an error
			if (~all(identified))
			disp(['Classification did not complete, some categories' ...
			'couldn'' be classified.'])

			return;
			end

SiBoRG/process_results/classify_species.m273481ed69b2master

classify_species.mView Options

SiBoRG/process_results/classify_species.m
273481ed69b2master

classify_species.m
View Options