¡Google I/O es una envoltura! Póngase al día con las sesiones de TensorFlow Ver sesiones

Integrar clasificadores de audio

La clasificación de audio es un caso de uso común de Machine Learning para clasificar los tipos de sonido. Por ejemplo, puede identificar las especies de aves por sus cantos.

La API de AudioClassifier de la biblioteca de tareas se puede utilizar para implementar sus clasificadores de audio personalizados o preentrenados en su aplicación móvil.

Funciones clave de la API de AudioClassifier

  • Procesamiento de entrada de audio, por ejemplo, conversión de codificación PCM de 16 bits a codificación PCM Float y manipulación del búfer circular de audio.

  • Localización del mapa de etiquetas.

  • Compatible con el modelo de clasificación de cabezales múltiples.

  • Admite la clasificación de una sola etiqueta y de múltiples etiquetas.

  • Umbral de puntuación para filtrar resultados.

  • Resultados de la clasificación Top-k.

  • Etiquete la lista de permitidos y la lista de denegados.

Modelos de clasificador de audio compatibles

Se garantiza que los siguientes modelos son compatibles con la API de AudioClassifier .

Ejecutar inferencia en Java

Consulte la aplicación de referencia de clasificación de audio para ver un ejemplo del uso de AudioClassifier en una aplicación de Android.

Paso 1: importar la dependencia de Gradle y otras configuraciones

Copie el archivo del modelo .tflite en el directorio de activos del módulo de Android donde se ejecutará el modelo. Especifica que el archivo no debe comprimirse y agrega la biblioteca TensorFlow Lite al archivo build.gradle del módulo:

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.0'
    // Import the GPU delegate plugin Library for GPU inference
    implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
}

Paso 2: Usando el modelo

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

Consulte el código fuente y javadoc para obtener más opciones para configurar AudioClassifier .

Ejecutar inferencia en Python

Paso 1: Instale el paquete pip

pip install tflite-support
  • Linux: Ejecute sudo apt-get update && apt-get install libportaudio2
  • Mac y Windows: PortAudio se instala automáticamente al instalar el paquete pip tflite-support .

Paso 2: Usando el modelo

# Imports
from tflite_support.task import vision
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)

Consulte el código fuente para obtener más opciones para configurar AudioClassifier .

Ejecutar inferencia en C++

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

// Create input audio buffer from data.
int input_buffer_size = audio_classifier->GetRequiredInputBufferSize();
const std::unique_ptr<AudioBuffer> audio_buffer =
    AudioBuffer::Create(audio_data.get(), input_buffer_size, kAudioFormat).value();

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

Consulte el código fuente para obtener más opciones para configurar AudioClassifier .

Requisitos de compatibilidad de modelos

La API AudioClassifier espera un modelo TFLite con metadatos de modelo TFLite obligatorios. Vea ejemplos de creación de metadatos para clasificadores de audio con la API de escritura de metadatos de TensorFlow Lite .

Los modelos de clasificadores de audio compatibles deben cumplir los siguientes requisitos:

  • Tensor de audio de entrada (kTfLiteFloat32)

    • clip de audio de tamaño [batch x samples] .
    • la inferencia por lotes no es compatible (se requiere que el batch sea 1).
    • para los modelos multicanal, los canales deben intercalarse.

  • Tensor de puntuación de salida (kTfLiteFloat32)

    • La matriz [1 x N] con N representa el número de clase.
    • mapas de etiquetas opcionales (pero recomendados) como AssociatedFile-s con tipo TENSOR_AXIS_LABELS, que contienen una etiqueta por línea. El primer AssociatedFile (si lo hay) se usa para llenar el campo de label (llamado class_name en C++) de los resultados. El campo display_name se rellena con AssociatedFile (si existe) cuya configuración regional coincide con el campo display_names_locale de AudioClassifierOptions utilizado en el momento de la creación ("en" por defecto, es decir, inglés). Si ninguno de estos está disponible, solo se completará el campo de index de los resultados.