ऑडियो की कैटगरी तय करने वाले एल्गोरिदम को इंटिग्रेट करें

आम तौर पर, ऑडियो की कैटगरी तय करने वाली टेक्नोलॉजी, मशीन लर्निंग की मदद से बनाई जाती है. साउंड का टाइप. उदाहरण के लिए, यह पक्षियों की प्रजातियों को उनके गानों से पहचान सकता है.

टास्क लाइब्रेरी AudioClassifier एपीआई का इस्तेमाल, अपनी पसंद के मुताबिक ऑडियो को डिप्लॉय करने के लिए किया जा सकता है क्लासिफ़ायर या पहले से ट्रेन किए गए डेटा को आपके मोबाइल ऐप्लिकेशन में शामिल कर सकते हैं.

AudioClassifier एपीआई की मुख्य सुविधाएं

• इनपुट ऑडियो प्रोसेसिंग, उदाहरण PCM 16 बिट एन्कोडिंग को PCM में परिवर्तित करना फ़्लोट एन्कोडिंग और ऑडियो रिंग बफ़र में बदलाव.

• मैप स्थान-भाषा को लेबल करें.

• मल्टी-हेड क्लासिफ़िकेशन मॉडल के साथ काम करता है.

• सिंगल-लेबल और मल्टी-लेबल क्लासिफ़िकेशन, दोनों का इस्तेमाल किया जा सकता है.

• नतीजों को फ़िल्टर करने के लिए, स्कोर थ्रेशोल्ड.

• टॉप-k क्लासिफ़िकेशन के नतीजे.

• अनुमति वाली सूची और ब्लॉकलिस्ट को लेबल करें.

इस्तेमाल किए जा सकने वाले ऑडियो की कैटगरी तय करने वाले मॉडल

ये मॉडल, AudioClassifier के साथ काम करते हैं एपीआई.

• इनके बनाए गए मॉडल ऑडियो क्लासिफ़िकेशन के लिए TensorFlow Lite Model Maker.

• कॉन्टेंट बनाने TensorFlow हब पर पहले से ट्रेन किए गए ऑडियो इवेंट की कैटगरी तय करने वाले मॉडल.

• शर्तें पूरी करने वाले कस्टम मॉडल मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तें.

Java में अनुमान चलाएं

ज़्यादा जानकारी के लिए, ऑडियो क्लासिफ़िकेशन रेफ़रंस ऐप्लिकेशन उदाहरण के लिए, Android ऐप्लिकेशन में AudioClassifier का इस्तेमाल करके.

पहला चरण: Gradle डिपेंडेंसी और अन्य सेटिंग इंपोर्ट करना

.tflite मॉडल फ़ाइल को, Android मॉड्यूल की ऐसेट डायरेक्ट्री में कॉपी करें जहां मॉडल को चलाया जाएगा. तय करें कि फ़ाइल कंप्रेस नहीं की जानी चाहिए, और मॉड्यूल की build.gradle फ़ाइल में TensorFlow Lite लाइब्रेरी जोड़ें:

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

दूसरा चरण: मॉडल का इस्तेमाल करना

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

ज़्यादा जानकारी के लिए, सोर्स कोड और javadoc AudioClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

iOS में अनुमान चलाएं

पहला चरण: डिपेंडेंसी इंस्टॉल करना

टास्क लाइब्रेरी में, CocoaPods का इस्तेमाल करके इंस्टॉल किए जा सकते हैं. पक्का करें कि CocoaPods आपके सिस्टम पर इंस्टॉल हो. कृपया CocoaPods को इंस्टॉल करने की गाइड देखें.

कृपया इनके लिए CocoaPods की गाइड Xcode प्रोजेक्ट में पॉड जोड़ने के बारे में जानकारी.

Podfile में TensorFlowLiteTaskAudio पॉड जोड़ें.

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

पक्का करें कि अनुमान के लिए, जिस .tflite मॉडल का इस्तेमाल करना है वह इसमें मौजूद हो आपका ऐप्लिकेशन बंडल.

दूसरा चरण: मॉडल का इस्तेमाल करना

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

        });
    }
}];

ज़्यादा जानकारी के लिए, सोर्स कोड TFLAudioClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

Python में इन्फ़रेंस चलाना

पहला चरण: पीआईपी पैकेज इंस्टॉल करना

pip install tflite-support

• Linux: sudo apt-get update && apt-get install libportaudio2 चलाएं
• Mac और Windows: tflite-support पीआईपी पैकेज.

दूसरा चरण: मॉडल का इस्तेमाल करना

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

ज़्यादा जानकारी के लिए, सोर्स कोड AudioClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

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

ज़्यादा जानकारी के लिए, सोर्स कोड AudioClassifier को कॉन्फ़िगर करने के ज़्यादा विकल्पों के बारे में जानें.

मॉडल के साथ काम करने से जुड़ी ज़रूरी शर्तें

AudioClassifier API के लिए, TFLite मॉडल ज़रूरी है. TFLite मॉडल का मेटाडेटा. इसके उदाहरण देखें हम ऑडियो की कैटगरी तय करने वाले टूल के लिए मेटाडेटा तैयार करना चाहते हैं. TensorFlow Lite Metadata Writer API.

काम करने वाले ऑडियो क्लासिफ़ायर मॉडल को इन ज़रूरी शर्तों को पूरा करना होगा:

• इनपुट ऑडियो टेंसर (kTfLiteFloat32)

  • [batch x samples] साइज़ की ऑडियो क्लिप.
  • बैच का अनुमान काम नहीं करता (batch को 1 होना ज़रूरी है).
  • अगर मल्टी-चैनल मॉडल के लिए, चैनलों को शामिल करना है, तो उन्हें शामिल करना होगा.

• आउटपुट स्कोर टेंसर (kTfLiteFloat32)

  • [1 x N] कलेक्शन में N है. इससे क्लास नंबर पता चलता है.
  • प्रकार के साथ AssociatedFile-s के रूप में वैकल्पिक (लेकिन सुझाया गया) लेबल मैप TENSOR_AXIS_LABEL, जिसमें हर लाइन में एक लेबल होना चाहिए. इस तरह का पहला label फ़ील्ड को भरने के लिए AssociatedFile (अगर कोई है) का इस्तेमाल किया जाता है (इसका नाम class_name (C++ में)). display_name फ़ील्ड भर गया है AssociatedFile (अगर कोई हो) से, जिसका स्थान AudioClassifierOptions में से display_names_locale फ़ील्ड का इस्तेमाल किया गया बनाने का समय (डिफ़ॉल्ट रूप से "hi"), जैसे कि अंग्रेज़ी. अगर इनमें से कोई भी उपलब्ध है, तो नतीजों का सिर्फ़ index फ़ील्ड भरा जाएगा.