Dowiedz się o nowościach w zakresie uczenia maszynowego, generatywnej sztucznej inteligencji i nie tylko na Sympozjum WiML 2023. Zarejestruj się

Ta strona została przetłumaczona przez Cloud Translation API.

Switch to English

Zintegruj klasyfikatory audio

Klasyfikacja dźwięku jest częstym przypadkiem użycia uczenia maszynowego do klasyfikowania typów dźwięku. Na przykład potrafi rozpoznać gatunki ptaków po ich śpiewie.

Interfejs API AudioClassifier biblioteki zadań może służyć do wdrażania niestandardowych lub przeszkolonych klasyfikatorów audio w aplikacji mobilnej.

Kluczowe cechy API AudioClassifier

Przetwarzanie sygnału wejściowego audio, np. konwersja kodowania 16-bitowego PCM na kodowanie PCM Float i manipulacja buforem pierścieniowym audio.
Lokalizacja mapy etykiety.
Wspieranie modelu klasyfikacji wielogłowicowej.
Obsługuje zarówno klasyfikację jednoetykietową, jak i wieloetykietową.
Próg punktacji do filtrowania wyników.
Najwyższe wyniki klasyfikacji.
Oznacz listę dozwolonych i odrzuconych.

Obsługiwane modele klasyfikatorów audio

Gwarantujemy zgodność następujących modeli z interfejsem API AudioClassifier .

Modele stworzone przez TensorFlow Lite Model Maker do klasyfikacji dźwięku .
Wstępnie wytrenowane modele klasyfikacji zdarzeń dźwiękowych w TensorFlow Hub .
Modele niestandardowe spełniające wymagania dotyczące zgodności modeli .

Uruchom wnioskowanie w Javie

Zobacz aplikację referencyjną Klasyfikacja dźwięku , aby zapoznać się z przykładem użycia AudioClassifier w aplikacji na Androida.

Krok 1: Importuj zależność Gradle i inne ustawienia

Skopiuj plik modelu .tflite do katalogu asset modułu Android, w którym będzie uruchamiany model. Określ, że plik nie powinien być skompresowany, i dodaj bibliotekę TensorFlow Lite do pliku build.gradle modułu:

android {
    // Other settings

    // Specify that the tflite file should not be compressed when building the APK package.
    aaptOptions {
        noCompress "tflite"
    }
}

dependencies {
    // Other dependencies

    // Import the Audio Task Library dependency (NNAPI is included)
    implementation 'org.tensorflow:tensorflow-lite-task-audio:0.4.4'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.4'
}

Krok 2: Korzystanie z modelu

// Initialization
AudioClassifierOptions options =
    AudioClassifierOptions.builder()
        .setBaseOptions(BaseOptions.builder().useGpu().build())
        .setMaxResults(1)
        .build();
AudioClassifier classifier =
    AudioClassifier.createFromFileAndOptions(context, modelFile, options);

// Start recording
AudioRecord record = classifier.createAudioRecord();
record.startRecording();

// Load latest audio samples
TensorAudio audioTensor = classifier.createInputTensorAudio();
audioTensor.load(record);

// Run inference
List<Classifications> results = audioClassifier.classify(audioTensor);

Zobacz kod źródłowy i javadoc, aby uzyskać więcej opcji konfiguracji AudioClassifier .

Uruchom wnioskowanie w iOS

Krok 1: Zainstaluj zależności

Biblioteka zadań obsługuje instalację za pomocą CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w twoim systemie. Zapoznaj się z instrukcją instalacji CocoaPods, aby uzyskać instrukcje.

Zapoznaj się z przewodnikiem CocoaPods, aby uzyskać szczegółowe informacje na temat dodawania podów do projektu Xcode.

Dodaj TensorFlowLiteTaskAudio pod w pliku Podfile.

target 'MyAppWithTaskAPI' do
  use_frameworks!
  pod 'TensorFlowLiteTaskAudio'
end

Upewnij się, że model .tflite , którego będziesz używać do wnioskowania, znajduje się w pakiecie aplikacji.

Krok 2: Korzystanie z modelu

Szybki

// Imports
import TensorFlowLiteTaskAudio
import AVFoundation

// Initialization
guard let modelPath = Bundle.main.path(forResource: "sound_classification",
                                            ofType: "tflite") else { return }

let options = AudioClassifierOptions(modelPath: modelPath)

// Configure any additional options:
// options.classificationOptions.maxResults = 3

let classifier = try AudioClassifier.classifier(options: options)

// Create Audio Tensor to hold the input audio samples which are to be classified.
// Created Audio Tensor has audio format matching the requirements of the audio classifier.
// For more details, please see:
// https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_tensor/sources/TFLAudioTensor.h
let audioTensor = classifier.createInputAudioTensor()

// Create Audio Record to record the incoming audio samples from the on-device microphone.
// Created Audio Record has audio format matching the requirements of the audio classifier.
// For more details, please see:
https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_record/sources/TFLAudioRecord.h
let audioRecord = try classifier.createAudioRecord()

// Request record permissions from AVAudioSession before invoking audioRecord.startRecording().
AVAudioSession.sharedInstance().requestRecordPermission { granted in
    if granted {
        DispatchQueue.main.async {
            // Start recording the incoming audio samples from the on-device microphone.
            try audioRecord.startRecording()

            // Load the samples currently held by the audio record buffer into the audio tensor.
            try audioTensor.load(audioRecord: audioRecord)

            // Run inference
            let classificationResult = try classifier.classify(audioTensor: audioTensor)
        }
    }
}

Cel C

// Imports
#import <TensorFlowLiteTaskAudio/TensorFlowLiteTaskAudio.h>
#import <AVFoundation/AVFoundation.h>

// Initialization
NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"sound_classification" ofType:@"tflite"];

TFLAudioClassifierOptions *options =
    [[TFLAudioClassifierOptions alloc] initWithModelPath:modelPath];

// Configure any additional options:
// options.classificationOptions.maxResults = 3;

TFLAudioClassifier *classifier = [TFLAudioClassifier audioClassifierWithOptions:options
                                                                          error:nil];

// Create Audio Tensor to hold the input audio samples which are to be classified.
// Created Audio Tensor has audio format matching the requirements of the audio classifier.
// For more details, please see:
// https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_tensor/sources/TFLAudioTensor.h
TFLAudioTensor *audioTensor = [classifier createInputAudioTensor];

// Create Audio Record to record the incoming audio samples from the on-device microphone.
// Created Audio Record has audio format matching the requirements of the audio classifier.
// For more details, please see:
https://github.com/tensorflow/tflite-support/blob/master/tensorflow_lite_support/ios/task/audio/core/audio_record/sources/TFLAudioRecord.h
TFLAudioRecord *audioRecord = [classifier createAudioRecordWithError:nil];

// Request record permissions from AVAudioSession before invoking -[TFLAudioRecord startRecordingWithError:].
[[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) {
    if (granted) {
        dispatch_async(dispatch_get_main_queue(), ^{
            // Start recording the incoming audio samples from the on-device microphone.
            [audioRecord startRecordingWithError:nil];

            // Load the samples currently held by the audio record buffer into the audio tensor.
            [audioTensor loadAudioRecord:audioRecord withError:nil];

            // Run inference
            TFLClassificationResult *classificationResult =
                [classifier classifyWithAudioTensor:audioTensor error:nil];

        });
    }
}];

Zobacz kod źródłowy, aby uzyskać więcej opcji konfiguracji TFLAudioClassifier .

Uruchom wnioskowanie w Pythonie

Krok 1: Zainstaluj pakiet pip

pip install tflite-support

Linux: Uruchom sudo apt-get update && apt-get install libportaudio2
Mac i Windows: PortAudio jest instalowany automatycznie podczas instalacji tflite-support pip.

Krok 2: Korzystanie z modelu

# Imports
from tflite_support.task import audio
from tflite_support.task import core
from tflite_support.task import processor

# Initialization
base_options = core.BaseOptions(file_name=model_path)
classification_options = processor.ClassificationOptions(max_results=2)
options = audio.AudioClassifierOptions(base_options=base_options, classification_options=classification_options)
classifier = audio.AudioClassifier.create_from_options(options)

# Alternatively, you can create an audio classifier in the following manner:
# classifier = audio.AudioClassifier.create_from_file(model_path)

# Run inference
audio_file = audio.TensorAudio.create_from_wav_file(audio_path, classifier.required_input_buffer_size)
audio_result = classifier.classify(audio_file)

Zobacz kod źródłowy, aby uzyskać więcej opcji konfiguracji AudioClassifier .

Uruchom wnioskowanie w C++

// Initialization
AudioClassifierOptions options;
options.mutable_base_options()->mutable_model_file()->set_file_name(model_path);
std::unique_ptr<AudioClassifier> audio_classifier = AudioClassifier::CreateFromOptions(options).value();

// Create input audio buffer from your `audio_data` and `audio_format`.
// See more information here: tensorflow_lite_support/cc/task/audio/core/audio_buffer.h
int input_size = audio_classifier->GetRequiredInputBufferSize();
const std::unique_ptr<AudioBuffer> audio_buffer =
    AudioBuffer::Create(audio_data, input_size, audio_format).value();

// Run inference
const ClassificationResult result = audio_classifier->Classify(*audio_buffer).value();

Zobacz kod źródłowy, aby uzyskać więcej opcji konfiguracji AudioClassifier .

Wymagania dotyczące zgodności modelu

Interfejs API AudioClassifier oczekuje modelu TFLite z obowiązkowymi metadanymi modelu TFLite . Zobacz przykłady tworzenia metadanych dla klasyfikatorów audio przy użyciu interfejsu API TensorFlow Lite Metadata Writer .

Zgodne modele klasyfikatorów audio powinny spełniać następujące wymagania:

Tensor wejściowy dźwięku (kTfLiteFloat32)
- klip audio o rozmiarze [batch x samples] .
- wnioskowanie o partiach nie jest obsługiwane ( batch musi wynosić 1).
- w przypadku modeli wielokanałowych kanały muszą być przeplatane.
Tensor wyniku wyjściowego (kTfLiteFloat32)
- Tablica [1 x N] z N reprezentuje numer klasy.
- opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s o typie TENSOR_AXIS_LABELS, zawierające jedną etykietę w wierszu. Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola label (o nazwie class_name w C++) wyników. Pole display_name jest wypełniane z AssociatedFile (jeśli istnieje), którego ustawienia regionalne są zgodne z polem display_names_locale w AudioClassifierOptions używanym w czasie tworzenia (domyślnie "en", tj. angielski). Jeśli żaden z nich nie jest dostępny, wypełnione zostanie tylko pole index wyników.