Mengintegrasikan pengklasifikasi audio

Klasifikasi audio adalah kasus penggunaan umum Machine Learning untuk mengklasifikasikan jenis suara. Misalnya, dapat mengidentifikasi spesies burung berdasarkan lagunya.

Task Library AudioClassifier API dapat digunakan untuk men-deploy audio kustom Anda pengklasifikasi atau yang telah dilatih sebelumnya ke dalam aplikasi seluler Anda.

Fitur utama AudioClassifier API

• Input pemrosesan audio, mis. mengubah pengkodean PCM 16 bit menjadi PCM. Encoding mengambang dan manipulasi buffer ring audio.

• Beri label lokalitas peta.

• Mendukung model klasifikasi Multi-kepala.

• Mendukung klasifikasi label tunggal dan multi-label.

• Nilai minimum skor untuk memfilter hasil.

• Hasil klasifikasi Top-k.

• Beri label daftar yang diizinkan dan tolak.

Model pengklasifikasi audio yang didukung

Model berikut dijamin akan kompatibel dengan AudioClassifier Compute Engine API.

• Model yang dibuat oleh Pembuat Model TensorFlow Lite untuk Klasifikasi Audio.

• Tujuan model klasifikasi peristiwa audio terlatih di TensorFlow Hub.

• Model kustom yang memenuhi persyaratan kompatibilitas model.

Menjalankan inferensi di Java

Lihat Aplikasi referensi Klasifikasi Audio misalnya menggunakan AudioClassifier di aplikasi Android.

Langkah 1: Impor dependensi Gradle dan setelan lainnya

Salin file model .tflite ke direktori aset modul Android tempat model akan dijalankan. Tentukan bahwa file tidak boleh dikompresi, dan tambahkan library TensorFlow Lite ke file build.gradle modul:

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

Langkah 2: Menggunakan model

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

Lihat kode sumber dan javadoc guna mendapatkan opsi selengkapnya untuk mengonfigurasi AudioClassifier.

Menjalankan inferensi di iOS

Langkah 1: Instal dependensi

Task Library mendukung penginstalan menggunakan CocoaPods. Pastikan CocoaPods diinstal di sistem Anda. Lihat Panduan pemasangan CocoaPods untuk melihat petunjuk.

Lihat Panduan CocoaPods untuk detail tentang cara menambahkan pod ke project Xcode.

Tambahkan pod TensorFlowLiteTaskAudio di Podfile.

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

Pastikan bahwa model .tflite yang akan Anda gunakan untuk inferensi ada di app bundle Anda.

Langkah 2: Menggunakan model

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

        });
    }
}];

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi TFLAudioClassifier.

Menjalankan inferensi di Python

Langkah 1: Instal paket pip

pip install tflite-support

• Linux: Jalankan sudo apt-get update && apt-get install libportaudio2
• Mac dan Windows: PortAudio diinstal secara otomatis saat menginstal Paket pip tflite-support.

Langkah 2: Menggunakan model

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

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi AudioClassifier.

Menjalankan inferensi di 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();

Lihat kode sumber guna mendapatkan opsi selengkapnya untuk mengonfigurasi AudioClassifier.

Persyaratan kompatibilitas model

AudioClassifier API mengharapkan model TFLite dengan Metadata Model TFLite. Lihat contoh dan membuat metadata untuk pengklasifikasi audio menggunakan TensorFlow Lite Metadata Writer API.

Model pengklasifikasi audio yang kompatibel harus memenuhi persyaratan berikut:

• Memasukkan tensor audio (kTfLiteFloat32)

  • klip audio berukuran [batch x samples].
  • inferensi batch tidak didukung (batch harus 1).
  • untuk model multi-saluran, saluran tersebut harus diselang-seling.

• Tensor skor output (kTfLiteFloat32)

  • Array [1 x N] dengan N mewakili nomor class.
  • peta label opsional (tetapi direkomendasikan) sebagai AssociatedFile-s dengan jenis TENSOR_AXIS_LABEL, berisi satu label per baris. Yang pertama AssociatedFile (jika ada) digunakan untuk mengisi kolom label (dinamai sebagai class_name di C++) dari hasil tersebut. Kolom display_name terisi dari AssociatedFile (jika ada) yang lokalnya cocok dengan Kolom display_names_locale dari AudioClassifierOptions yang digunakan di waktu pembuatan ("en" secara default, yaitu bahasa Inggris). Jika tidak satu pun dari tersedia, hanya kolom index dari hasil yang akan diisi.