Integrare classificatori audio

La classificazione audio è un caso d'uso comune del machine learning per classificare tipi di suono. Ad esempio, è in grado di identificare la specie di uccelli tramite il loro canto.

L'API AudioClassifier della libreria attività può essere utilizzata per eseguire il deployment dell'audio personalizzato di classificazione o preaddestrati nella tua app mobile.

Funzionalità chiave dell'API AudioClassifier

• Elaborazione audio di input, ad esempio conversione della codifica PCM a 16 bit in PCM Codifica in virgola mobile e manipolazione del buffer di anello audio.

• Assegna un'etichetta alle impostazioni internazionali della mappa.

• Supporto del modello di classificazione multi-testa.

• Supporto sia per la classificazione con etichetta singola che con più etichette.

• Soglia di punteggio per filtrare i risultati.

• Risultati della classificazione Top-K.

• Lista consentita e lista bloccata di etichette.

Modelli di classificatori audio supportati

La compatibilità dei seguenti modelli è garantita con AudioClassifier tramite Google Cloud CLI o tramite l'API Compute Engine.

• Modelli creati da Model Maker di TensorFlow Lite per la classificazione audio.

• La modelli di classificazione di eventi audio preaddestrati su TensorFlow Hub.

• Modelli personalizzati che soddisfano requisiti di compatibilità dei modelli.

Esegui l'inferenza in Java

Consulta le App di riferimento per la classificazione audio per un esempio di utilizzo di AudioClassifier in un'app per Android.

Passaggio 1: importa la dipendenza da Gradle e altre impostazioni

Copia il file del modello .tflite nella directory degli asset del modulo per Android in cui verrà eseguito il modello. Specifica che il file non deve essere compresso. aggiungi la libreria TensorFlow Lite al file build.gradle del modulo:

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

Passaggio 2: utilizzo del modello

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

Consulta le codice sorgente e javadoc per altre opzioni di configurazione di AudioClassifier.

Esegui l'inferenza in iOS

Passaggio 1: installa le dipendenze

La libreria attività supporta l'installazione tramite CocoaPods. Assicurati che CocoaPods sia installata sul sistema. Consulta le Guida all'installazione di CocoaPods per istruzioni.

Consulta le Guida di CocoaPods per dettagli sull'aggiunta di pod a un progetto Xcode.

Aggiungi il pod TensorFlowLiteTaskAudio al podfile.

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

Assicurati che il modello .tflite che utilizzerai per l'inferenza sia presente nella dell'app bundle.

Passaggio 2: utilizzo del modello

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

        });
    }
}];

Consulta le codice sorgente per altre opzioni di configurazione di TFLAudioClassifier.

Esegui l'inferenza in Python

Passaggio 1: installa il pacchetto pip

pip install tflite-support

• Linux: esegui sudo apt-get update && apt-get install libportaudio2
• Mac e Windows: PortAudio viene installato automaticamente durante l'installazione del tflite-support pacchetto pip.

Passaggio 2: utilizzo del modello

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

Consulta le codice sorgente per altre opzioni di configurazione di AudioClassifier.

Esegui l'inferenza in 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();

Consulta le codice sorgente per altre opzioni di configurazione di AudioClassifier.

Requisiti di compatibilità del modello

L'API AudioClassifier prevede un modello TFLite con requisiti obbligatori Metadati del modello TFLite. Vedi esempi di creando metadati per i classificatori audio utilizzando API TensorFlow Lite Metadata Writer.

I modelli di classificatori audio compatibili devono soddisfare i seguenti requisiti:

• Tensore audio di input (kTfLiteFloat32)

  • clip audio di dimensioni [batch x samples].
  • l'inferenza batch non è supportata (batch deve essere 1).
  • per i modelli multicanale, i canali devono essere interleali.

• Tensore del punteggio di output (kTfLiteFloat32)

  • L'array [1 x N] con N rappresenta il numero di classe.
  • mappe di etichette facoltative (ma consigliate) come AssociatedFile-s con tipo TENSOR_AXIS_LABELS, contenente un'etichetta per riga. Il primo esempio Se presente, il file associato viene utilizzato per compilare il campo label (denominato come class_name in C++) dei risultati. Il campo display_name è compilato dall'AssociatedFile (se presente) le cui impostazioni internazionali corrispondono Campo display_names_locale di AudioClassifierOptions utilizzato alle data e ora di creazione ("en" per impostazione predefinita, ad es. inglese). Se nessuna di queste opzioni disponibile, verrà compilato solo il campo index dei risultati.