Klasyfikacja dźwięku jest częstym przypadkiem użycia uczenia maszynowego do klasyfikowania typów dźwięków. Może na przykład rozpoznać gatunki ptaków po ich śpiewie.
Interfejs API AudioClassifier
biblioteki zadań może służyć do wdrażania niestandardowych lub wstępnie wytrenowanych klasyfikatorów audio w aplikacji mobilnej.
Kluczowe cechy interfejsu API AudioClassifier
Przetwarzanie wejściowego sygnału audio, np. konwersja 16-bitowego kodowania PCM na kodowanie PCM Float i manipulowanie buforem pierścieniowym audio.
Oznacz lokalizację mapy.
Obsługa modelu klasyfikacji wielogłowicowej.
Obsługa klasyfikacji jednoetykietowej i wieloetykietowej.
Próg punktacji do filtrowania wyników.
Wyniki klasyfikacji z najwyższej półki.
Oznacz listę dozwolonych i odrzuconych etykiet.
Obsługiwane modele klasyfikatorów audio
Gwarantujemy kompatybilność następujących modeli z interfejsem API AudioClassifier
.
Modele stworzone przez TensorFlow Lite Model Maker do klasyfikacji audio .
Wstępnie przeszkolone modele klasyfikacji zdarzeń audio w TensorFlow Hub .
Modele niestandardowe spełniające wymagania dotyczące kompatybilności modeli .
Uruchom wnioskowanie w Javie
Zobacz aplikację referencyjną do klasyfikacji audio , aby zapoznać się z przykładem użycia AudioClassifier
w aplikacji na Androida.
Krok 1: Zaimportuj zależność Gradle i inne ustawienia
Skopiuj plik modelu .tflite
do katalogu zasobów modułu Android, w którym model będzie uruchamiany. Określ, że plik nie powinien być kompresowany 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 systemie iOS
Krok 1: Zainstaluj zależności
Biblioteka zadań obsługuje instalację przy użyciu CocoaPods. Upewnij się, że CocoaPods jest zainstalowany w twoim systemie. Instrukcje znajdziesz w instrukcji instalacji CocoaPods .
Szczegółowe informacje na temat dodawania kapsuł do projektu Xcode można znaleźć w przewodniku CocoaPods .
Dodaj moduł TensorFlowLiteTaskAudio
do 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 pakietu pip
tflite-support
.
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 kompatybilnoś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 narzędzia do zapisywania metadanych TensorFlow Lite .
Kompatybilne modele klasyfikatorów audio powinny spełniać następujące wymagania:
Tensor sygnału wejściowego audio (kTfLiteFloat32)
- klip audio o rozmiarze
[batch x samples]
. - wnioskowanie wsadowe nie jest obsługiwane (wymagana jest
batch
1). - w przypadku modeli wielokanałowych kanały muszą być przeplatane.
- klip audio o rozmiarze
Tensor wyniku wyjściowego (kTfLiteFloat32)
- Tablica
[1 x N]
, w którejN
reprezentuje numer klasy. - opcjonalne (ale zalecane) mapy etykiet jako AssociatedFile-s typu TENSOR_AXIS_LABELS, zawierające jedną etykietę w linii. Pierwszy taki AssociatedFile (jeśli istnieje) jest używany do wypełnienia pola
label
(nazwanego jakoclass_name
w C++) wyników. Poledisplay_name
jest wypełniane z pliku AssociatedFile (jeśli istnieje), którego ustawienia regionalne odpowiadają poludisplay_names_locale
AudioClassifierOptions
użytej w czasie tworzenia (domyślnie „en”, tj. angielski). Jeśli żadne z nich nie jest dostępne, wypełnione zostanie jedynie poleindex
wyników.
- Tablica