vggish

Нейронная сеть VGGish

    Синтаксис

    Описание

    пример

    net = vggish возвращает предварительно обученную модель VGGish.

    Эта функция требует и Audio Toolbox™ и Deep Learning Toolbox™.

    Примеры

    свернуть все

    Загрузите и разархивируйте модель Audio Toolbox™ для VGGish.

    Введите vggish в Командном окне. Если модель Audio Toolbox для VGGish не установлена, то функция обеспечивает ссылку на местоположение сетевых весов. Чтобы загрузить модель, щелкните по ссылке. Разархивируйте файл к местоположению на пути MATLAB.

    В качестве альтернативы выполните эти команды, чтобы загрузить и разархивировать модель VGGish к вашей временной директории.

    downloadFolder = fullfile(tempdir,'VGGishDownload');
    loc = websave(downloadFolder,'https://ssd.mathworks.com/supportfiles/audio/vggish.zip');
    VGGishLocation = tempdir;
    unzip(loc,VGGishLocation)
    addpath(fullfile(VGGishLocation,'vggish'))

    Проверяйте, что установка успешна путем ввода vggish в Командном окне. Если сеть установлена, то функция возвращает SeriesNetwork Объект (Deep Learning Toolbox).

    vggish
    ans = 
      SeriesNetwork with properties:
    
             Layers: [24×1 nnet.cnn.layer.Layer]
         InputNames: {'InputBatch'}
        OutputNames: {'regressionoutput'}
    
    

    Загрузите предварительно обученную сверточную нейронную сеть VGGish и исследуйте слои и классы.

    Используйте vggish загружать предварительно обученную сеть VGGish. Выход net SeriesNetwork Объект (Deep Learning Toolbox).

    net = vggish
    net = 
      SeriesNetwork with properties:
    
             Layers: [24×1 nnet.cnn.layer.Layer]
         InputNames: {'InputBatch'}
        OutputNames: {'regressionoutput'}
    
    

    Просмотрите сетевую архитектуру с помощью Layers свойство. Сеть имеет 24 слоя. Существует девять слоев с learnable весами, из которых шесть сверточные слои, и три полносвязные слоя.

    net.Layers
    ans = 
      24×1 Layer array with layers:
    
         1   'InputBatch'         Image Input         96×64×1 images
         2   'conv1'              Convolution         64 3×3×1 convolutions with stride [1  1] and padding 'same'
         3   'relu'               ReLU                ReLU
         4   'pool1'              Max Pooling         2×2 max pooling with stride [2  2] and padding 'same'
         5   'conv2'              Convolution         128 3×3×64 convolutions with stride [1  1] and padding 'same'
         6   'relu2'              ReLU                ReLU
         7   'pool2'              Max Pooling         2×2 max pooling with stride [2  2] and padding 'same'
         8   'conv3_1'            Convolution         256 3×3×128 convolutions with stride [1  1] and padding 'same'
         9   'relu3_1'            ReLU                ReLU
        10   'conv3_2'            Convolution         256 3×3×256 convolutions with stride [1  1] and padding 'same'
        11   'relu3_2'            ReLU                ReLU
        12   'pool3'              Max Pooling         2×2 max pooling with stride [2  2] and padding 'same'
        13   'conv4_1'            Convolution         512 3×3×256 convolutions with stride [1  1] and padding 'same'
        14   'relu4_1'            ReLU                ReLU
        15   'conv4_2'            Convolution         512 3×3×512 convolutions with stride [1  1] and padding 'same'
        16   'relu4_2'            ReLU                ReLU
        17   'pool4'              Max Pooling         2×2 max pooling with stride [2  2] and padding 'same'
        18   'fc1_1'              Fully Connected     4096 fully connected layer
        19   'relu5_1'            ReLU                ReLU
        20   'fc1_2'              Fully Connected     4096 fully connected layer
        21   'relu5_2'            ReLU                ReLU
        22   'fc2'                Fully Connected     128 fully connected layer
        23   'EmbeddingBatch'     ReLU                ReLU
        24   'regressionoutput'   Regression Output   mean-squared-error
    

    Используйте analyzeNetwork (Deep Learning Toolbox), чтобы визуально исследовать сеть.

    analyzeNetwork(net)

    Сеть VGGish требует, чтобы вы предварительно обработали и извлекли функции из звуковых сигналов путем преобразования их в частоту дискретизации, сеть была обучена на, и затем извлекающий журнал mel спектрограммы. Этот пример обходы посредством необходимой предварительной обработки и извлечения признаков, чтобы совпадать с предварительной обработкой и извлечением признаков раньше обучал VGGish. vggishFeatures функция выполняет эти шаги для вас.

    Читайте в звуковом сигнале классифицировать. Передискретизируйте звуковой сигнал к 16 кГц и затем преобразуйте его в одинарную точность.

    [audioIn,fs0] = audioread('Ambiance-16-44p1-mono-12secs.wav');
    
    фс = 16e3;
    audioIn = передискретизируют (audioIn, фс, fs0);
    
    audioIn = один (audioIn);

    Задайте mel параметры спектрограммы и затем извлеките функции с помощью melSpectrogram функция.

    FFTLength = 512;
    numBands = 64;
    frequencyRange = [125 7500];
    windowLength = 0.025*fs;
    overlapLength = 0.015*fs;
    
    melSpect = melSpectrogram(audioIn,fs, ...
        'Window',hann(windowLength,'periodic'), ...
        'OverlapLength',overlapLength, ...
        'FFTLength',FFTLength, ...
        'FrequencyRange',frequencyRange, ...
        'NumBands',numBands, ...
        'FilterBankNormalization','none', ...
        'WindowNormalization',false, ...
        'SpectrumType','magnitude', ...
        'FilterBankDesignDomain','warped');

    Преобразуйте mel спектрограмму в логарифмическую шкалу.

    melSpect = log(melSpect + single(0.001));

    Переориентируйте mel спектрограмму так, чтобы время приехало первая размерность как строки.

    melSpect = melSpect.';
    [numSTFTWindows,numBands] = size(melSpect)
    numSTFTWindows = 1222
    
    numBands = 64
    

    Разделите спектрограмму в системы координат длины 96 с перекрытием 48. Поместите системы координат по четвертому измерению.

    frameWindowLength = 96;
    frameOverlapLength = 48;
    
    hopLength = frameWindowLength - frameOverlapLength;
    numHops = floor((numSTFTWindows - frameWindowLength)/hopLength) + 1;
    
    frames = zeros(frameWindowLength,numBands,1,numHops,'like',melSpect);
    for hop = 1:numHops
        range = 1 + hopLength*(hop-1):hopLength*(hop - 1) + frameWindowLength;
        frames(:,:,1,hop) = melSpect(range,:);
    end

    Создайте сеть VGGish.

    net = vggish;

    Вызовите predict извлекать вложения функции из изображений спектрограммы. Вложения функции возвращены как numFrames- 128 матриц, где numFrames количество отдельных спектрограмм, и 128 число элементов в каждом характеристическом векторе.

    features = predict(net,frames);
    
    [numFrames,numFeatures] = size(features)
    numFrames = 24
    
    numFeatures = 128
    

    Сравните визуализацию mel спектрограммы и вложения функции VGGish.

    melSpectrogram(audioIn,fs, ...
        'Window',hann(windowLength,'periodic'), ...
        'OverlapLength',overlapLength, ...
        'FFTLength',FFTLength, ...
        'FrequencyRange',frequencyRange, ...
        'NumBands',numBands, ...
        'FilterBankNormalization','none', ...
        'WindowNormalization',false, ...
        'SpectrumType','magnitude', ...
        'FilterBankDesignDomain','warped');

    surf(features,'EdgeColor','none')
    view([90,-90])
    axis([1 numFeatures 1 numFrames])
    xlabel('Feature')
    ylabel('Frame')
    title('VGGish Feature Embeddings')

    В этом примере вы передаете изучение в модели регрессии VGGish к аудио задаче классификации.

    Загрузите и разархивируйте экологический звуковой набор данных классификации. Этот набор данных состоит из записей, помеченных как один из 10 различных аудио звуковых классов (ESC-10).

    url = 'http://ssd.mathworks.com/supportfiles/audio/ESC-10.zip';
    downloadFolder = fullfile(tempdir,'ESC-10');
    datasetLocation = tempdir;
    
    if ~exist(fullfile(tempdir,'ESC-10'),'dir')
        loc = websave(downloadFolder,url);
        unzip(loc,fullfile(tempdir,'ESC-10'))
    end

    Создайте audioDatastore объект управлять данными и разделить это в обучается и наборы валидации. Вызовите countEachLabel отобразить распределение звуковых классов и количество уникальных меток.

    ads = audioDatastore(downloadFolder,'IncludeSubfolders',true,'LabelSource','foldernames');
    labelTable = countEachLabel(ads)
    labelTable=10×2 table
            Label         Count
        ______________    _____
    
        chainsaw           40  
        clock_tick         40  
        crackling_fire     40  
        crying_baby        40  
        dog                40  
        helicopter         40  
        rain               40  
        rooster            38  
        sea_waves          40  
        sneezing           40  
    
    

    Определите общее количество классов.

    numClasses = size(labelTable,1);

    Вызовите splitEachLabel разделять набор данных в наборы обучения и валидации. Смотрите распределение меток в наборах обучения и валидации.

    [adsTrain, adsValidation] = splitEachLabel(ads,0.8);
    
    countEachLabel(adsTrain)
    ans=10×2 table
            Label         Count
        ______________    _____
    
        chainsaw           32  
        clock_tick         32  
        crackling_fire     32  
        crying_baby        32  
        dog                32  
        helicopter         32  
        rain               32  
        rooster            30  
        sea_waves          32  
        sneezing           32  
    
    
    countEachLabel(adsValidation)
    ans=10×2 table
            Label         Count
        ______________    _____
    
        chainsaw            8  
        clock_tick          8  
        crackling_fire      8  
        crying_baby         8  
        dog                 8  
        helicopter          8  
        rain                8  
        rooster             8  
        sea_waves           8  
        sneezing            8  
    
    

    Сеть VGGish ожидает, что аудио будет предварительно обработано в журнал mel спектрограммы. Функция поддержки vggishPreprocess берет audioDatastore возразите и процент перекрытия между журналом mel спектрограммы, как введено, и возвращает матрицы предикторов и ответов, подходящих, как введено к сети VGGish.

    overlapPercentage = 75;
    
    [trainFeatures, trainLabels] = vggishPreprocess (adsTrain, overlapPercentage);
    [validationFeatures, validationLabels, segmentsPerFile] = vggishPreprocess (adsValidation, overlapPercentage);

    Загрузите модель VGGish и преобразуйте ее в layerGraph Объект (Deep Learning Toolbox).

    net = vggish;
    
    lgraph = layerGraph(net.Layers);

    Используйте removeLayers (Deep Learning Toolbox), чтобы удалить итоговую регрессию выходной слой из графика. После того, как вы удалите слой регрессии, новый последний слой графика является слоем ReLU под названием 'EmbeddingBatch'.

    lgraph = removeLayers(lgraph,'regressionoutput');
    lgraph.Layers(end)
    ans = 
      ReLULayer with properties:
    
        Name: 'EmbeddingBatch'
    
    

    Используйте addLayers (Deep Learning Toolbox), чтобы добавить fullyConnectedLayer (Deep Learning Toolbox), softmaxLayer (Deep Learning Toolbox) и classificationLayer (Deep Learning Toolbox) к графику.

    lgraph = addLayers(lgraph,fullyConnectedLayer(numClasses,'Name','FCFinal'));
    lgraph = addLayers(lgraph,softmaxLayer('Name','softmax'));
    lgraph = addLayers(lgraph,classificationLayer('Name','classOut'));

    Используйте connectLayers (Deep Learning Toolbox), чтобы добавить полностью связанный, softmax, и слои классификации к графику слоев.

    lgraph = connectLayers(lgraph,'EmbeddingBatch','FCFinal');
    lgraph = connectLayers(lgraph,'FCFinal','softmax');
    lgraph = connectLayers(lgraph,'softmax','classOut');

    Чтобы задать опции обучения, используйте trainingOptions (Deep Learning Toolbox).

    miniBatchSize = 128;
    options = trainingOptions('adam', ...
        'MaxEpochs',5, ...
        'MiniBatchSize',miniBatchSize, ...
        'Shuffle','every-epoch', ...
        'ValidationData',{validationFeatures,validationLabels}, ...
        'ValidationFrequency',50, ...
        'LearnRateSchedule','piecewise', ...
        'LearnRateDropFactor',0.5, ...
        'LearnRateDropPeriod',2);

    Чтобы обучить сеть, используйте trainNetwork (Deep Learning Toolbox).

    [trainedNet, netInfo] = trainNetwork(trainFeatures,trainLabels,lgraph,options);
    Training on single GPU.
    |======================================================================================================================|
    |  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Validation  |  Mini-batch  |  Validation  |  Base Learning  |
    |         |             |   (hh:mm:ss)   |   Accuracy   |   Accuracy   |     Loss     |     Loss     |      Rate       |
    |======================================================================================================================|
    |       1 |           1 |       00:00:00 |       10.94% |       26.03% |       2.2253 |       2.0317 |          0.0010 |
    |       2 |          50 |       00:00:05 |       93.75% |       83.75% |       0.1884 |       0.7001 |          0.0010 |
    |       3 |         100 |       00:00:10 |       96.88% |       80.07% |       0.1150 |       0.7838 |          0.0005 |
    |       4 |         150 |       00:00:15 |       92.97% |       81.99% |       0.1656 |       0.7612 |          0.0005 |
    |       5 |         200 |       00:00:20 |       92.19% |       79.04% |       0.1738 |       0.8192 |          0.0003 |
    |       5 |         210 |       00:00:21 |       95.31% |       80.15% |       0.1389 |       0.8581 |          0.0003 |
    |======================================================================================================================|
    

    Каждый звуковой файл был разделен в несколько сегментов, чтобы питаться в сеть VGGish. Объедините предсказания для каждого файла в наборе валидации с помощью решения принципа большинства.

    validationPredictions = classify(trainedNet,validationFeatures);
    
    idx = 1;
    validationPredictionsPerFile = categorical;
    for ii = 1:numel(adsValidation.Files)
        validationPredictionsPerFile(ii,1) = mode(validationPredictions(idx:idx+segmentsPerFile(ii)-1));
        idx = idx + segmentsPerFile(ii);
    end

    Используйте confusionchart (Deep Learning Toolbox), чтобы оценить эффективность сети на наборе валидации.

    figure('Units','normalized','Position',[0.2 0.2 0.5 0.5]);
    cm = confusionchart(adsValidation.Labels,validationPredictionsPerFile);
    cm.Title = sprintf('Confusion Matrix for Validation Data \nAccuracy = %0.2f %%',mean(validationPredictionsPerFile==adsValidation.Labels)*100);
    cm.ColumnSummary = 'column-normalized';
    cm.RowSummary = 'row-normalized';

    Вспомогательные Функции

    function [predictor,response,segmentsPerFile] = vggishPreprocess(ads,overlap)
    % This function is for example purposes only and may be changed or removed
    % in a future release.
    
    % Create filter bank
    FFTLength = 512;
    numBands = 64;
    fs0 = 16e3;
    filterBank = designAuditoryFilterBank(fs0, ...
        'FrequencyScale','mel', ...
        'FFTLength',FFTLength, ...
        'FrequencyRange',[125 7500], ...
        'NumBands',numBands, ...
        'Normalization','none', ...
        'FilterBankDesignDomain','warped');
    
    % Define STFT parameters
    windowLength = 0.025 * fs0;
    hopLength = 0.01 * fs0;
    win = hann(windowLength,'periodic');
    
    % Define spectrogram segmentation parameters
    segmentDuration = 0.96; % seconds
    segmentRate = 100; % hertz
    segmentLength = segmentDuration*segmentRate; % Number of spectrums per auditory spectrograms
    segmentHopDuration = (100-overlap) * segmentDuration / 100; % Duration (s) advanced between auditory spectrograms
    segmentHopLength = round(segmentHopDuration * segmentRate); % Number of spectrums advanced between auditory spectrograms
    
    % Preallocate cell arrays for the predictors and responses
    numFiles = numel(ads.Files);
    predictor = cell(numFiles,1);
    response = predictor;
    segmentsPerFile = zeros(numFiles,1);
    
    % Extract predictors and responses for each file
    for ii = 1:numFiles
        [audioIn,info] = read(ads);
    
        x = single(resample(audioIn,fs0,info.SampleRate));
    
        Y = stft(x, ...
            'Window',win, ...
            'OverlapLength',windowLength-hopLength, ...
            'FFTLength',FFTLength, ...
            'FrequencyRange','onesided');
        Y = abs(Y);
    
        logMelSpectrogram = log(filterBank*Y + single(0.01))';
        
        % Segment log-mel spectrogram
        numHops = floor((size(Y,2)-segmentLength)/segmentHopLength) + 1;
        segmentedLogMelSpectrogram = zeros(segmentLength,numBands,1,numHops);
        for hop = 1:numHops
            segmentedLogMelSpectrogram(:,:,1,hop) = logMelSpectrogram(1+segmentHopLength*(hop-1):segmentLength+segmentHopLength*(hop-1),:);
        end
    
        predictor{ii} = segmentedLogMelSpectrogram;
        response{ii} = repelem(info.Label,numHops);
        segmentsPerFile(ii) = numHops;
    end
    
    % Concatenate predictors and responses into arrays
    predictor = cat(4,predictor{:});
    response = cat(2,response{:});
    end

    Выходные аргументы

    свернуть все

    Предварительно обученная нейронная сеть VGGish, возвращенная как SeriesNetwork Объект (Deep Learning Toolbox).

    Ссылки

    [1] Gemmeke, Джортом Ф., Дэниелом П. В. Эллисом, Диланом Фридменом, не Является Янсен, Уэйд Лоуренс, Р. Ченнинг Мур, Мэнодж Плэкэл и Марвин Риттер. 2017. “Аудио Набор: Онтология и Помеченный Человеком Набор данных для Аудио Событий”. На 2 017 Международных конференциях IEEE по вопросам Акустики, Речи и Обработки сигналов (ICASSP), 776–80. Новый Орлеан, LA: IEEE. https://doi.org/10.1109/ICASSP.2017.7952261.

    [2] Херши, Шон, Кисловатый Chaudhuri, Дэниел П. В. Эллис, Джорт Ф. Джеммек, не Является Янсен, Р. Ченнинг Мур, Manoj Plakal, и др. 2017. “Архитектуры CNN для Крупномасштабной Аудио Классификации”. На 2 017 Международных конференциях IEEE по вопросам Акустики, Речи и Обработки сигналов (ICASSP), 131–35. Новый Орлеан, LA: IEEE. https://doi.org/10.1109/ICASSP.2017.7952132.

    Расширенные возможности

    Введенный в R2020b