使用深度学习训练语音命令识别模型 -凯发k8网页登录

downloadfolder = matlab.internal.examples.downloadsupportfile("audio","google_speech.zip");
datafolder = tempdir;
unzip(downloadfolder,datafolder)
dataset = fullfile(datafolder,"google_speech");

augmentdataset(dataset)

ads = audiodatastore(fullfile(dataset,"train"), ...
    includesubfolders=true, ...
    fileextensions=".wav", ...
    labelsource="foldernames");

commands = categorical(["yes","no","up","down","left","right","on","off","stop","go"]);
background = categorical("background");
iscommand = ismember(ads.labels,commands);
isbackground = ismember(ads.labels,background);
isunknown = ~(iscommand|isbackground);
includefraction = 0.2; % fraction of unknowns to include.
idx = find(isunknown);
idx = idx(randperm(numel(idx),round((1-includefraction)*sum(isunknown))));
isunknown(idx) = false;
ads.labels(isunknown) = categorical("unknown");
adstrain = subset(ads,iscommand|isunknown|isbackground);
adstrain.labels = removecats(adstrain.labels);

ads = audiodatastore(fullfile(dataset,"validation"), ...
    includesubfolders=true, ...
    fileextensions=".wav", ...
    labelsource="foldernames");
iscommand = ismember(ads.labels,commands);
isbackground = ismember(ads.labels,background);
isunknown = ~(iscommand|isbackground);
includefraction = 0.2; % fraction of unknowns to include.
idx = find(isunknown);
idx = idx(randperm(numel(idx),round((1-includefraction)*sum(isunknown))));
isunknown(idx) = false;
ads.labels(isunknown) = categorical("unknown");
adsvalidation = subset(ads,iscommand|isunknown|isbackground);
adsvalidation.labels = removecats(adsvalidation.labels);

figure(units="normalized",position=[0.2,0.2,0.5,0.5])
tiledlayout(2,1)
nexttile
histogram(adstrain.labels)
title("training label distribution")
ylabel("number of observations")
grid on
nexttile
histogram(adsvalidation.labels)
title("validation label distribution")
ylabel("number of observations")
grid on

if speedupexample
    numuniquelabels = numel(unique(adstrain.labels)); %#ok 
    % reduce the dataset by a factor of 20
    adstrain = spliteachlabel(adstrain,round(numel(adstrain.files) / numuniquelabels / 20));
    adsvalidation = spliteachlabel(adsvalidation,round(numel(adsvalidation.files) / numuniquelabels / 20));
end

if canuseparallelpool && ~speedupexample
    useparallel = true;
    gcp;
else
    useparallel = false;
end

fs = 16e3; % known sample rate of the data set.
segmentduration = 1;
frameduration = 0.025;
hopduration = 0.010;
fftlength = 512;
numbands = 50;
segmentsamples = round(segmentduration*fs);
framesamples = round(frameduration*fs);
hopsamples = round(hopduration*fs);
overlapsamples = framesamples - hopsamples;

afe = audiofeatureextractor( ...
    samplerate=fs, ...
    fftlength=fftlength, ...
    window=hann(framesamples,"periodic"), ...
    overlaplength=overlapsamples, ...
    barkspectrum=true);
setextractorparameters(afe,"barkspectrum",numbands=numbands,windownormalization=false);

transform1 = transform(adstrain,@(x)[zeros(floor((segmentsamples-size(x,1))/2),1);x;zeros(ceil((segmentsamples-size(x,1))/2),1)]);
transform2 = transform(transform1,@(x)extract(afe,x));
transform3 = transform(transform2,@(x){log10(x 1e-6)});

xtrain = readall(transform3,useparallel=useparallel);

numfiles = numel(xtrain)

[numhops,numbands,numchannels] = size(xtrain{1})

xtrain = cat(4,xtrain{:});
[numhops,numbands,numchannels,numfiles] = size(xtrain)

transform1 = transform(adsvalidation,@(x)[zeros(floor((segmentsamples-size(x,1))/2),1);x;zeros(ceil((segmentsamples-size(x,1))/2),1)]);
transform2 = transform(transform1,@(x)extract(afe,x));
transform3 = transform(transform2,@(x){log10(x 1e-6)});
xvalidation = readall(transform3,useparallel=useparallel);
xvalidation = cat(4,xvalidation{:});

ttrain = adstrain.labels;
tvalidation = adsvalidation.labels;

specmin = min(xtrain,[],"all");
specmax = max(xtrain,[],"all");
idx = randperm(numel(adstrain.files),3);
figure(units="normalized",position=[0.2,0.2,0.6,0.6]);
tiledlayout(2,3)
for ii = 1:3
    [x,fs] = audioread(adstrain.files{idx(ii)});
    nexttile(ii)
    plot(x)
    axis tight
    title(string(adstrain.labels(idx(ii))))
    
    nexttile(ii 3)
    spect = xtrain(:,:,1,idx(ii))';
    pcolor(spect)
    clim([specmin specmax])
    shading flat
    
    sound(x,fs)
    pause(2)
end

classes = categories(ttrain);
classweights = 1./countcats(ttrain);
classweights = classweights'/mean(classweights);
numclasses = numel(classes);
timepoolsize = ceil(numhops/8);
dropoutprob = 0.2;
numf = 12;
layers = [
    imageinputlayer([numhops,afe.featurevectorlength])
    
    convolution2dlayer(3,numf,padding="same")
    batchnormalizationlayer
    relulayer
    maxpooling2dlayer(3,stride=2,padding="same")
    
    convolution2dlayer(3,2*numf,padding="same")
    batchnormalizationlayer
    relulayer
    maxpooling2dlayer(3,stride=2,padding="same")
    
    convolution2dlayer(3,4*numf,padding="same")
    batchnormalizationlayer
    relulayer
    maxpooling2dlayer(3,stride=2,padding="same")
    
    convolution2dlayer(3,4*numf,padding="same")
    batchnormalizationlayer
    relulayer
    convolution2dlayer(3,4*numf,padding="same")
    batchnormalizationlayer
    relulayer
    maxpooling2dlayer([timepoolsize,1])
    dropoutlayer(dropoutprob)
    fullyconnectedlayer(numclasses)
    softmaxlayer
    classificationlayer(classes=classes,classweights=classweights)];

minibatchsize = 128;
validationfrequency = floor(numel(ttrain)/minibatchsize);
options = trainingoptions("adam", ...
    initiallearnrate=3e-4, ...
    maxepochs=15, ...
    minibatchsize=minibatchsize, ...
    shuffle="every-epoch", ...
    plots="training-progress", ...
    verbose=false, ...
    validationdata={xvalidation,tvalidation}, ...
    validationfrequency=validationfrequency);

trainednet = trainnetwork(xtrain,ttrain,layers,options);

yvalidation = classify(trainednet,xvalidation);
validationerror = mean(yvalidation ~= tvalidation);
ytrain = classify(trainednet,xtrain);
trainerror = mean(ytrain ~= ttrain);
disp(["training error: "   trainerror*100   "%";"validation error: "   validationerror*100   "%"])

figure(units="normalized",position=[0.2,0.2,0.5,0.5]);
cm = confusionchart(tvalidation,yvalidation, ...
    title="confusion matrix for validation data", ...
    columnsummary="column-normalized",rowsummary="row-normalized");
sortclasses(cm,[commands,"unknown","background"])

for ii = 1:100
    x = randn([numhops,numbands]);
    predictiontimer = tic;
    [y,probs] = classify(trainednet,x,executionenvironment="cpu");
    time(ii) = toc(predictiontimer);
end
disp(["network size: "   whos("trainednet").bytes/1024   " kb"; ...
"single-image prediction time on cpu: "   mean(time(11:end))*1000   " ms"])

function augmentdataset(datasetloc)
adsbkg = audiodatastore(fullfile(datasetloc,"background"));
fs = 16e3; % known sample rate of the data set
segmentduration = 1;
segmentsamples = round(segmentduration*fs);
volumerange = log10([1e-4,1]);
numbkgsegments = 4000;
numbkgfiles = numel(adsbkg.files);
numsegmentsperfile = floor(numbkgsegments/numbkgfiles);
fptrain = fullfile(datasetloc,"train","background");
fpvalidation = fullfile(datasetloc,"validation","background");
if ~datasetexists(fptrain)
    % create directories
    mkdir(fptrain)
    mkdir(fpvalidation)
    for backgroundfileindex = 1:numel(adsbkg.files)
        [bkgfile,fileinfo] = read(adsbkg);
        [~,fn] = fileparts(fileinfo.filename);
        % determine starting index of each segment
        segmentstart = randi(size(bkgfile,1)-segmentsamples,numsegmentsperfile,1);
        % determine gain of each clip
        gain = 10.^((volumerange(2)-volumerange(1))*rand(numsegmentsperfile,1)   volumerange(1));
        for segmentidx = 1:numsegmentsperfile
            % isolate the randomly chosen segment of data.
            bkgsegment = bkgfile(segmentstart(segmentidx):segmentstart(segmentidx) segmentsamples-1);
            % scale the segment by the specified gain.
            bkgsegment = bkgsegment*gain(segmentidx);
            % clip the audio between -1 and 1.
            bkgsegment = max(min(bkgsegment,1),-1);
            % create a file name.
            afn = fn   "_segment"   segmentidx   ".wav";
            % randomly assign background segment to either the train or
            % validation set.
            if rand > 0.85 % assign 15% to validation
                dirtowriteto = fpvalidation;
            else % assign 85% to train set.
                dirtowriteto = fptrain;
            end
            % write the audio to the file location.
            ffn = fullfile(dirtowriteto,afn);
            audiowrite(ffn,bkgsegment,fs)
        end
        % print progress
        fprintf('progress = %d (%%)\n',round(100*progress(adsbkg)))
    end
end
end