Tích hợp thuật toán phân loại âm thanh

Phân loại âm thanh là một trường hợp sử dụng phổ biến của công nghệ Học máy để phân loại loại âm thanh. Ví dụ: công cụ này có thể xác định các loài chim theo tiếng hót của chúng.

Bạn có thể dùng API AudioClassifier của Thư viện tác vụ để triển khai âm thanh tuỳ chỉnh thuật toán phân loại hoặc thuật toán được huấn luyện trước vào ứng dụng dành cho thiết bị di động.

Các tính năng chính của AudioClassifier API

• Xử lý âm thanh đầu vào, ví dụ: chuyển đổi mã hoá PCM 16 bit sang PCM Phương thức mã hoá số thực độ chính xác đơn và thao tác đối với vùng đệm vòng âm thanh.

• Ngôn ngữ bản đồ của nhãn.

• Hỗ trợ mô hình phân loại nhiều đầu.

• Hỗ trợ cả phân loại nhãn đơn và nhiều nhãn.

• Ngưỡng điểm để lọc kết quả.

• Kết quả phân loại hàng đầu.

• Hãng nhạc được cho phép và danh sách từ chối.

Các mô hình phân loại âm thanh được hỗ trợ

Các mô hình sau đây được đảm bảo tương thích với AudioClassifier API.

• Mô hình được tạo bởi Trình tạo mô hình TensorFlow Lite để phân loại âm thanh.

• Chiến lược phát hành đĩa đơn các mô hình phân loại sự kiện âm thanh được huấn luyện trước trên TensorFlow Hub.

• Mô hình tuỳ chỉnh đáp ứng yêu cầu về khả năng tương thích với mô hình.

Chạy dự đoán trong Java

Xem Ứng dụng tham khảo Phân loại âm thanh chẳng hạn như cách sử dụng AudioClassifier trong ứng dụng Android.

Bước 1: Nhập phần phụ thuộc Gradle và các chế độ cài đặt khác

Sao chép tệp mô hình .tflite vào thư mục thành phần của mô-đun Android nơi mô hình sẽ chạy. Chỉ định rằng tệp không được nén và thêm thư viện TensorFlow Lite vào tệp build.gradle của mô-đun:

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

Bước 2: Sử dụng mô hình

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

Xem mã nguồn và javadoc để có thêm lựa chọn để định cấu hình AudioClassifier.

Chạy dự đoán trong iOS

Bước 1: Cài đặt phần phụ thuộc

Thư viện Tác vụ hỗ trợ cài đặt bằng CocoaPods. Đảm bảo rằng CocoaPods được cài đặt trên hệ thống của bạn. Vui lòng xem Hướng dẫn cài đặt CocoaPods để được hướng dẫn.

Vui lòng xem Hướng dẫn của CocoaPods cho chi tiết về cách thêm nhóm vào dự án Xcode.

Thêm nhóm TensorFlowLiteTaskAudio trong Podfile.

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

Hãy đảm bảo rằng mô hình .tflite mà bạn sẽ dùng để suy luận có mặt trong gói ứng dụng của bạn.

Bước 2: Sử dụng mô hình

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

        });
    }
}];

Xem mã nguồn để có thêm lựa chọn để định cấu hình TFLAudioClassifier.

Chạy suy luận trong Python

Bước 1: Cài đặt gói pip

pip install tflite-support

• Linux: Chạy sudo apt-get update && apt-get install libportaudio2
• Mac và Windows: PortAudio được cài đặt tự động khi cài đặt Gói tflite-support pip.

Bước 2: Sử dụng mô hình

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

Xem mã nguồn để có thêm lựa chọn để định cấu hình AudioClassifier.

Chạy dự đoán trong 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();

Xem mã nguồn để có thêm lựa chọn để định cấu hình AudioClassifier.

Yêu cầu về khả năng tương thích với mô hình

API AudioClassifier yêu cầu một mô hình TFLite với Siêu dữ liệu mô hình TFLite. Xem ví dụ về tạo siêu dữ liệu cho thuật toán phân loại âm thanh bằng phương pháp TensorFlow Lite Metadata Writer API.

Các mô hình thuật toán phân loại âm thanh tương thích phải đáp ứng các yêu cầu sau:

• Tensor âm thanh đầu vào (kTfLiteFloat32)

  • đoạn âm thanh có kích thước [batch x samples].
  • không hỗ trợ suy luận theo lô (batch phải là 1).
  • đối với mô hình đa kênh, các kênh cần phải được xen kẽ với nhau.

• Tensor điểm đầu ra (kTfLiteFloat32)

  • Mảng [1 x N] có N đại diện cho số lớp.
  • (các) bản đồ nhãn không bắt buộc(nhưng nên dùng) dưới dạng AssociatedFile-s có loại TENSOR_AXIS_LABEL, chứa một nhãn trên mỗi dòng. Sự kiện đầu tiên như vậy AssociatedFile (nếu có) được dùng để điền vào trường label (có tên là class_name trong C++) của kết quả. Trường display_name đã được điền từ AssociatedFile (nếu có) có ngôn ngữ khớp với Trường display_names_locale của AudioClassifierOptions được sử dụng tại thời gian tạo ("en" theo mặc định, tức là tiếng Anh). Nếu không có phương pháp nào nêu trên có sẵn, thì hệ thống sẽ chỉ điền trường index của kết quả.