Документация

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [sequences,sequencePerFile] = HelperFeatureVector2Sequence(features,featureVectorsPerSequence,featureVectorOverlap)
    % Copyright 2019 MathWorks, Inc.
    if featureVectorsPerSequence <= featureVectorOverlap
        error('The number of overlapping feature vectors must be less than the number of feature vectors per sequence.')
    end

    hopLength = featureVectorsPerSequence - featureVectorOverlap;
    idx1 = 1;
    sequences = {};
    sequencePerFile = cell(numel(features),1);
    for ii = 1:numel(features)
        sequencePerFile{ii} = floor((size(features{ii},2) - featureVectorsPerSequence)/hopLength) + 1;
        idx2 = 1;
        for j = 1:sequencePerFile{ii}
            sequences{idx1,1} = features{ii}(:,idx2:idx2 + featureVectorsPerSequence - 1); %#ok<AGROW>
            idx1 = idx1 + 1;
            idx2 = idx2 + hopLength;
        end
    end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [trueLabelsCrossFold,predictedLabelsCrossFold] = HelperTrainAndValidateNetwork(varargin)
    % Copyright 2019 The MathWorks, Inc.
    if nargin == 3
        ads = varargin{1};
        augads = varargin{2};
        extractor = varargin{3};
    elseif nargin == 2
        ads = varargin{1};
        augads = varargin{1};
        extractor = varargin{2};
    end
    speaker = categories(ads.Labels.Speaker);
    numFolds = numel(speaker);
    emptyEmotions = categorical(ads.Labels.Emotion);
    emptyEmotions(:) = [];

    % Loop over each fold
    trueLabelsCrossFold = {};
    predictedLabelsCrossFold = {};
    
    for i = 1:numFolds
        
        % 1. Divide the audio datastore into training and validation sets.
        % Convert the data to tall arrays.
        idxTrain           = augads.Labels.Speaker~=speaker(i);
        augadsTrain        = subset(augads,idxTrain);
        augadsTrain.Labels = augadsTrain.Labels.Emotion;
        tallTrain          = tall(augadsTrain);
        idxValidation        = ads.Labels.Speaker==speaker(i);
        adsValidation        = subset(ads,idxValidation);
        adsValidation.Labels = adsValidation.Labels.Emotion;
        tallValidation       = tall(adsValidation);

        % 2. Extract features from the training set. Reorient the features
        % so that time is along rows to be compatible with
        % sequenceInputLayer.
        tallTrain         = cellfun(@(x)x/max(abs(x),[],'all'),tallTrain,"UniformOutput",false);
        tallFeaturesTrain = cellfun(@(x)extract(extractor,x),tallTrain,"UniformOutput",false);
        tallFeaturesTrain = cellfun(@(x)x',tallFeaturesTrain,"UniformOutput",false);  %#ok<NASGU>
        [~,featuresTrain] = evalc('gather(tallFeaturesTrain)'); % Use evalc to suppress command-line output.
        tallValidation         = cellfun(@(x)x/max(abs(x),[],'all'),tallValidation,"UniformOutput",false);
        tallFeaturesValidation = cellfun(@(x)extract(extractor,x),tallValidation,"UniformOutput",false);
        tallFeaturesValidation = cellfun(@(x)x',tallFeaturesValidation,"UniformOutput",false); %#ok<NASGU>
        [~,featuresValidation] = evalc('gather(tallFeaturesValidation)'); % Use evalc to suppress command-line output.

        % 3. Use the training set to determine the mean and standard
        % deviation of each feature. Normalize the training and validation
        % sets.
        allFeatures = cat(2,featuresTrain{:});
        M = mean(allFeatures,2,'omitnan');
        S = std(allFeatures,0,2,'omitnan');
        featuresTrain = cellfun(@(x)(x-M)./S,featuresTrain,'UniformOutput',false);
        for ii = 1:numel(featuresTrain)
            idx = find(isnan(featuresTrain{ii}));
            if ~isempty(idx)
                featuresTrain{ii}(idx) = 0;
            end
        end
        featuresValidation = cellfun(@(x)(x-M)./S,featuresValidation,'UniformOutput',false);
        for ii = 1:numel(featuresValidation)
            idx = find(isnan(featuresValidation{ii}));
            if ~isempty(idx)
                featuresValidation{ii}(idx) = 0;
            end
        end

        % 4. Buffer the sequences so that each sequence consists of twenty
        % feature vectors with overlaps of 10 feature vectors.
        featureVectorsPerSequence = 20;
        featureVectorOverlap = 10;
        [sequencesTrain,sequencePerFileTrain] = HelperFeatureVector2Sequence(featuresTrain,featureVectorsPerSequence,featureVectorOverlap);
        [sequencesValidation,sequencePerFileValidation] = HelperFeatureVector2Sequence(featuresValidation,featureVectorsPerSequence,featureVectorOverlap);

        % 5. Replicate the labels of the train and validation sets so that
        % they are in one-to-one correspondence with the sequences.
        labelsTrain = [emptyEmotions;augadsTrain.Labels];
        labelsTrain = labelsTrain(:);
        labelsTrain = repelem(labelsTrain,[sequencePerFileTrain{:}]);

        % 6. Define a BiLSTM network.
        dropoutProb1 = 0.3;
        numUnits     = 200;
        dropoutProb2 = 0.6;
        layers = [ ...
            sequenceInputLayer(size(sequencesTrain{1},1))
            dropoutLayer(dropoutProb1)
            bilstmLayer(numUnits,"OutputMode","last")
            dropoutLayer(dropoutProb2)
            fullyConnectedLayer(numel(categories(emptyEmotions)))
            softmaxLayer
            classificationLayer];

        % 7. Define training options.
        miniBatchSize       = 512;
        initialLearnRate    = 0.005;
        learnRateDropPeriod = 2;
        maxEpochs           = 3;
        options = trainingOptions("adam", ...
            "MiniBatchSize",miniBatchSize, ...
            "InitialLearnRate",initialLearnRate, ...
            "LearnRateDropPeriod",learnRateDropPeriod, ...
            "LearnRateSchedule","piecewise", ...
            "MaxEpochs",maxEpochs, ...
            "Shuffle","every-epoch", ...
            "Verbose",false);

        % 8. Train the network.
        net = trainNetwork(sequencesTrain,labelsTrain,layers,options);

        % 9. Evaluate the network. Call classify to get the predicted labels
        % for each sequence. Get the mode of the predicted labels of each
        % sequence to get the predicted labels of each file.
        predictedLabelsPerSequence = classify(net,sequencesValidation);
        trueLabels = categorical(adsValidation.Labels);
        predictedLabels = trueLabels;
        idx1 = 1;
        for ii = 1:numel(trueLabels)
            predictedLabels(ii,:) = mode(predictedLabelsPerSequence(idx1:idx1 + sequencePerFileValidation{ii} - 1,:),1);
            idx1 = idx1 + sequencePerFileValidation{ii};
        end
        trueLabelsCrossFold{i} = trueLabels; %#ok<AGROW>
        predictedLabelsCrossFold{i} = predictedLabels; %#ok<AGROW>
    end
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function [logbook,bestFeatures] = HelperSFS(ads,adsAug,extractor,direction)
    % logbook = HelperSFS(ads,adsAug,extractor,direction)
    % returns a table, logbook, that contains the feature configurations tested
    % and associated validation accuracy.
    %   ads       - audioDatastore object that points to the original dataset (used for val).
    %   adsAug    - audioDatastore object that points to the augmented dataset (used for dev).
    %   extractor - audioFeatureExtractor object. Set all features to test to true.
    %   direction - specify as 'forward' or 'backward'
    %
    %[logbook,bestFeatures] = HelperSFS(ads,adsAug,extractor,direction)
    % also returns a struct, bestFeatures, containing the best feature
    % configuration for audioFeatureExtractor.

    % Copyright 2019 The MathWorks, Inc.

    featuresToTest = fieldnames(info(extractor));
    N = numel(featuresToTest);

    % ---------------------------------------------------------------------
    % Set the initial feature configuration: all on for backward selection
    % or all off for forward selection.
    featureConfig  = info(extractor);
    for i = 1:N
        if strcmpi(direction,"backward")
            featureConfig.(featuresToTest{i}) = true;
        else
            featureConfig.(featuresToTest{i}) = false;
        end
    end
    % ---------------------------------------------------------------------

    % Initialize logbook to track feature configuration and accuracy.
    logbook = table(featureConfig,0,'VariableNames',["Feature Configuration","Accuracy"]);

    %% Perform sequential feature evaluation
    wrapperIdx = 1;
    bestAccuracy = 0;
    while wrapperIdx <= N
        % -----------------------------------------------------------------
        % Create a cell array containing all feature configurations to test
        % in the current loop.
        featureConfigsToTest = cell(numel(featuresToTest),1);
        for ii = 1:numel(featuresToTest)
            if strcmpi(direction,"backward")
                featureConfig.(featuresToTest{ii}) = false;
            else
                featureConfig.(featuresToTest{ii}) = true;
            end
            featureConfigsToTest{ii} = featureConfig;
            if strcmpi(direction,"backward")
                featureConfig.(featuresToTest{ii}) = true;
            else
                featureConfig.(featuresToTest{ii}) = false;
            end
        end
        % -----------------------------------------------------------------

        % Loop over every feature set.
        for ii = 1:numel(featureConfigsToTest)

            % -------------------------------------------------------------
            % Determine the current feature configuration to test. Update
            % the feature extractor.
            currentConfig = featureConfigsToTest{ii};
            set(extractor,currentConfig)
            % -------------------------------------------------------------

            % -------------------------------------------------------------
            % Train and get k-fold cross-validation accuracy for current
            % feature configuration.
            [trueLabels,predictedLabels] = HelperTrainAndValidateNetwork(ads,adsAug,extractor);
            trueLabelsMat = cat(1,trueLabels{:});
            predictedLabelsMat = cat(1,predictedLabels{:});
            valAccuracy = mean(trueLabelsMat==predictedLabelsMat)*100;
            % -------------------------------------------------------------

            % Update Logbook ----------------------------------------------
            result = table(currentConfig,valAccuracy, ...
                'VariableNames',["Feature Configuration","Accuracy"]);
            logbook = [logbook;result];
            % -------------------------------------------------------------

        end

        % -----------------------------------------------------------------
        % Determine and print the setting with the best accuracy. If
        % accuracy did not improve, end the run.
        [a,b] = max(logbook{:,'Accuracy'});
        if a <= bestAccuracy
            wrapperIdx = inf;
        else
            wrapperIdx = wrapperIdx + 1;
        end
        bestAccuracy = a;
        % -----------------------------------------------------------------

        % -----------------------------------------------------------------
        % Update the features-to-test based on the most recent winner.
        winner = logbook{b,'Feature Configuration'};
        fn = fieldnames(winner);
        tf = structfun(@(x)(x),winner);
        if strcmpi(direction,"backward")
            featuresToRemove = fn(~tf);
        else
            featuresToRemove = fn(tf);
        end
        for ii = 1:numel(featuresToRemove)
            loc =  strcmp(featuresToTest,featuresToRemove{ii});
            featuresToTest(loc) = [];
            if strcmpi(direction,"backward")
                featureConfig.(featuresToRemove{ii}) = false;
            else
                featureConfig.(featuresToRemove{ii}) = true;
            end
        end
        % -----------------------------------------------------------------

    end
    
    % ---------------------------------------------------------------------
    % Sort the logbook and make it more readable
    logbook(1,:) = []; % Delete placeholder first row
    logbook = sortrows(logbook,{'Accuracy'},{'descend'});
    bestFeatures = logbook{1,'Feature Configuration'};
    m = logbook{:,'Feature Configuration'};
    fn = fieldnames(m);
    myString = strings(numel(m),1);
    for wrapperIdx = 1:numel(m)
        tf = structfun(@(x)(x),logbook{wrapperIdx,'Feature Configuration'});
        myString(wrapperIdx) = strjoin(fn(tf),", ");
    end
    logbook = table(myString,logbook{:,'Accuracy'},'VariableNames',["Features","Accuracy"]);
    % ---------------------------------------------------------------------
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%