Audioklassifikatoren einbinden

Die Audioklassifizierung ist ein häufiger Anwendungsfall des maschinellen Lernens, Geräuschtypen. Beispielsweise kann er die Vogelarten anhand ihres Gesangs identifizieren.

Mit der AudioClassifier Task Library API können benutzerdefinierte Audioinhalte bereitgestellt werden oder vortrainierte Klassifikatoren in Ihre mobile App einbinden.

Wichtige Funktionen der AudioClassifier API

Verarbeitung der Audioeingabe, z.B. PCM-16-Bit-Codierung in PCM konvertieren Float-Codierung und Bearbeitung des Audioring-Zwischenspeichers.
Sprache der Labelzuordnung.
Mehr-Kopf-Klassifizierungsmodell wird unterstützt.
Klassifizierung mit einem und mehreren Labels wird unterstützt.
Punktzahlgrenzwert zum Filtern von Ergebnissen.
Top-K-Klassifizierungsergebnisse.
Zulassungsliste und Sperrliste für Labels.

Unterstützte Audioklassifikatormodelle

Die folgenden Modelle sind garantiert kompatibel mit dem AudioClassifier der API erstellen.

Modelle erstellt von TensorFlow Lite Model Maker für die Audioklassifizierung
Die vortrainierte Klassifizierungsmodelle für Audioereignisse auf TensorFlow Hub.
Benutzerdefinierte Modelle, die den Anforderungen an die Modellkompatibilität.

Inferenz in Java ausführen

Weitere Informationen finden Sie in der Referenz-App zur Audioklassifizierung für ein Beispiel mit AudioClassifier in einer Android-App.

Schritt 1: Gradle-Abhängigkeit und andere Einstellungen importieren

Kopieren Sie die Modelldatei .tflite in das Asset-Verzeichnis des Android-Moduls. in dem das Modell ausgeführt wird. Geben Sie an, dass die Datei nicht komprimiert werden soll, und Fügen Sie der Datei build.gradle des Moduls die TensorFlow Lite-Bibliothek hinzu:

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
    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'
}

Schritt 2: Modell verwenden

// 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);

Weitere Informationen finden Sie in der Quellcode und Javadoc finden Sie weitere Optionen zum Konfigurieren von AudioClassifier.

Inferenzen in iOS ausführen

Schritt 1: Abhängigkeiten installieren

Die Task Library unterstützt die Installation mit CocoaPods. Achten Sie darauf, dass CocoaPods auf Ihrem System installiert ist. In der Installationsanleitung für CocoaPods .

In der CocoaPods-Leitfaden für wie Sie Pods zu einem Xcode-Projekt hinzufügen.

Fügen Sie der Podfile-Datei den Pod TensorFlowLiteTaskAudio hinzu.

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

Achten Sie darauf, dass das .tflite-Modell, das Sie für die Inferenz verwenden, in Ihr App Bundle.

Schritt 2: Modell verwenden

Swift

// 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)
        }
    }
}

Objective-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];

        });
    }
}];

Weitere Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von TFLAudioClassifier.

Inferenz in Python ausführen

Schritt 1: pip-Paket installieren

pip install tflite-support

Linux: Führen Sie sudo apt-get update && apt-get install libportaudio2 aus.
Mac und Windows: PortAudio wird bei der Installation der pip-Paket von tflite-support.

Schritt 2: Modell verwenden

# 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)

Weitere Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von AudioClassifier.

Inferenz in C++ ausführen

// 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();

Weitere Informationen finden Sie in der Quellcode finden Sie weitere Optionen zum Konfigurieren von AudioClassifier.

Anforderungen an die Modellkompatibilität

Die AudioClassifier API erwartet ein TFLite-Modell mit obligatorischen TFLite-Modellmetadaten. Beispiele für Erstellen von Metadaten für Audioklassifikatoren mithilfe der TensorFlow Lite Metadata Writer API

Die kompatiblen Audioklassifikatormodelle müssen die folgenden Anforderungen erfüllen:

Audio-Eingabetensor (kTfLiteFloat32)
- Audioclip der Größe [batch x samples].
- Batch-Inferenz wird nicht unterstützt (batch muss 1 sein).
- Bei Multi-Channel-Modellen müssen die Kanäle verschränkt sein.
Ausgabewerttensor (kTfLiteFloat32)
- Ein [1 x N]-Array mit N stellt die Klassennummer dar.
- Optionale (aber empfohlene) Labelzuordnung(en) als AssociatedFile-s mit dem Typ TENSOR_AXIS_LABELS mit einem Label pro Zeile. Die erste AssociatedFile (falls vorhanden) wird zum Ausfüllen des Felds label verwendet (namens class_name in C++) der Ergebnisse. Das Feld „display_name“ ist ausgefüllt aus der AssociatedFile (falls vorhanden), deren Gebietsschema mit der Feld display_names_locale von AudioClassifierOptions verwendet bei Erstellungszeit (standardmäßig "en", also Englisch). Wenn keiner dieser verfügbar ist, wird nur das Feld index der Ergebnisse gefüllt.