सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

पर्यावरणीय ध्वनि वर्गीकरण के लिए YAMNet के साथ सीखने को स्थानांतरित करें

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें टीएफ हब मॉडल देखें

YAMNet एक पूर्व प्रशिक्षित गहरी तंत्रिका नेटवर्क है कि से ऑडियो घटनाओं की भविष्यवाणी कर सकते हैं 521 कक्षाएं ऐसी हंसी के रूप में, भौंकने, या एक भोंपू।

इस ट्यूटोरियल में आप सीखेंगे कि कैसे:

  • अनुमान के लिए YAMNet मॉडल लोड करें और उसका उपयोग करें।
  • बिल्ली और कुत्ते की ध्वनियों को वर्गीकृत करने के लिए YAMNet एम्बेडिंग का उपयोग करके एक नया मॉडल बनाएं।
  • अपने मॉडल का मूल्यांकन और निर्यात करें।

TensorFlow और अन्य पुस्तकालयों को आयात करें

स्थापित करके शुरू TensorFlow मैं / हे , जो यह आसान आप डिस्क बंद ऑडियो फाइलों को लोड करने के लिए कर देगा।

pip install tensorflow_io
import os

from IPython import display
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_io as tfio

यमनेट के बारे में

YAMNet एक पूर्व प्रशिक्षित तंत्रिका नेटवर्क है कि रोजगार है MobileNetV1 depthwise-वियोज्य घुमाव के वास्तुकला। यह इनपुट के रूप में एक ऑडियो तरंग का उपयोग करें और से 521 ऑडियो घटनाओं में से प्रत्येक के लिए स्वतंत्र भविष्यवाणियों बना सकते हैं AudioSet कोष।

आंतरिक रूप से, मॉडल ऑडियो सिग्नल से "फ़्रेम" निकालता है और इन फ़्रेमों के बैचों को संसाधित करता है। मॉडल का यह संस्करण 0.96 सेकेंड लंबे फ्रेम का उपयोग करता है और प्रत्येक 0.48 सेकेंड में एक फ्रेम निकालता है।

मॉडल एक 1-डी float32 रेंज में मनमाने ढंग से लंबाई की एक तरंग, एकल चैनल (मोनो) के रूप में प्रतिनिधित्व 16 kHz के नमूने युक्त टेन्सर या NumPy सरणी स्वीकार करता है [-1.0, +1.0] । इस ट्यूटोरियल में WAV फ़ाइलों को समर्थित प्रारूप में बदलने में आपकी मदद करने के लिए कोड है।

मॉडल वर्ग स्कोर, embeddings (जो आप हस्तांतरण सीखने के लिए उपयोग किया जाएगा), और लॉग मेल सहित 3 आउटपुट, रिटर्न spectrogram । आप और अधिक जानकारी प्राप्त कर सकते यहाँ

YAMNet का एक विशिष्ट उपयोग एक उच्च-स्तरीय फीचर एक्सट्रैक्टर के रूप में है - 1,024-आयामी एम्बेडिंग आउटपुट। आप आधार (YAMNet) मॉडल के इनपुट सुविधाओं का उपयोग करें और उन्हें अपने उथले एक छिपा से मिलकर मॉडल में फीड होगा tf.keras.layers.Dense परत। उसके बाद, आप लेबल डेटा का एक बहुत आवश्यकता होती है और अंत से अंत प्रशिक्षण के बिना ऑडियो वर्गीकरण के लिए डेटा की एक छोटी राशि पर नेटवर्क को प्रशिक्षित करेंगे। (यह करने के लिए इसी तरह की है TensorFlow हब के साथ छवि वर्गीकरण के लिए सीखने के लिए स्थानांतरण अधिक जानकारी के लिए।)

सबसे पहले, आप मॉडल का परीक्षण करेंगे और ऑडियो वर्गीकृत करने के परिणाम देखेंगे। फिर आप डेटा प्री-प्रोसेसिंग पाइपलाइन का निर्माण करेंगे।

TensorFlow हब से YAMNet लोड हो रहा है

आप से एक पूर्व प्रशिक्षित YAMNet उपयोग करने के लिए जा रहे हैं Tensorflow हब ध्वनि फ़ाइलों से embeddings निकालने के लिए।

TensorFlow हब से एक मॉडल लोड हो रहा है स्पष्ट है: मॉडल चुनें, अपने यूआरएल को कॉपी, और प्रयोग load समारोह।

yamnet_model_handle = 'https://tfhub.dev/google/yamnet/1'
yamnet_model = hub.load(yamnet_model_handle)

साथ मॉडल लोड, आप का अनुसरण कर सकते YAMNet मूल उपयोग ट्यूटोरियल और निष्कर्ष को चलाने के लिए एक नमूना WAV फ़ाइल डाउनलोड करें।

testing_wav_file_name = tf.keras.utils.get_file('miaow_16k.wav',
                                                'https://storage.googleapis.com/audioset/miaow_16k.wav',
                                                cache_dir='./',
                                                cache_subdir='test_data')

print(testing_wav_file_name)
Downloading data from https://storage.googleapis.com/audioset/miaow_16k.wav
221184/215546 [==============================] - 0s 0us/step
./test_data/miaow_16k.wav

आपको ऑडियो फ़ाइलों को लोड करने के लिए एक फ़ंक्शन की आवश्यकता होगी, जिसका उपयोग बाद में प्रशिक्षण डेटा के साथ काम करते समय भी किया जाएगा। (में ऑडियो फ़ाइलें और उनके लेबल को पढ़ने के बारे में और जानें सरल ऑडियो मान्यता

# Utility functions for loading audio files and making sure the sample rate is correct.

@tf.function
def load_wav_16k_mono(filename):
    """ Load a WAV file, convert it to a float tensor, resample to 16 kHz single-channel audio. """
    file_contents = tf.io.read_file(filename)
    wav, sample_rate = tf.audio.decode_wav(
          file_contents,
          desired_channels=1)
    wav = tf.squeeze(wav, axis=-1)
    sample_rate = tf.cast(sample_rate, dtype=tf.int64)
    wav = tfio.audio.resample(wav, rate_in=sample_rate, rate_out=16000)
    return wav
testing_wav_data = load_wav_16k_mono(testing_wav_file_name)

_ = plt.plot(testing_wav_data)

# Play the audio file.
display.Audio(testing_wav_data,rate=16000)
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/parallel_for/pfor.py:2382: calling gather (from tensorflow.python.ops.array_ops) with validate_indices is deprecated and will be removed in a future version.
Instructions for updating:
The `validate_indices` argument has no effect. Indices are always validated on CPU and never validated on GPU.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/parallel_for/pfor.py:2382: calling gather (from tensorflow.python.ops.array_ops) with validate_indices is deprecated and will be removed in a future version.
Instructions for updating:
The `validate_indices` argument has no effect. Indices are always validated on CPU and never validated on GPU.
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample

पीएनजी

क्लास मैपिंग लोड करें

उन वर्ग नामों को लोड करना महत्वपूर्ण है जिन्हें YAMNet पहचानने में सक्षम है। मैपिंग फ़ाइल में मौजूद है yamnet_model.class_map_path() एस वी प्रारूप में।

class_map_path = yamnet_model.class_map_path().numpy().decode('utf-8')
class_names =list(pd.read_csv(class_map_path)['display_name'])

for name in class_names[:20]:
  print(name)
print('...')
Speech
Child speech, kid speaking
Conversation
Narration, monologue
Babbling
Speech synthesizer
Shout
Bellow
Whoop
Yell
Children shouting
Screaming
Whispering
Laughter
Baby laughter
Giggle
Snicker
Belly laugh
Chuckle, chortle
Crying, sobbing
...

अनुमान चलाएँ

YAMNet फ़्रेम-स्तरीय क्लास-स्कोर प्रदान करता है (अर्थात, प्रत्येक फ़्रेम के लिए 521 स्कोर)। क्लिप-स्तरीय पूर्वानुमानों को निर्धारित करने के लिए, स्कोर को प्रति-वर्ग फ़्रेमों में एकत्रित किया जा सकता है (उदाहरण के लिए, माध्य या अधिकतम एकत्रीकरण का उपयोग करके)। यह द्वारा नीचे किया जाता है scores_np.mean(axis=0) । अंत में, क्लिप-स्तर पर शीर्ष-स्कोर वाले वर्ग को खोजने के लिए, आप अधिकतम 521 कुल स्कोर लेते हैं।

scores, embeddings, spectrogram = yamnet_model(testing_wav_data)
class_scores = tf.reduce_mean(scores, axis=0)
top_class = tf.argmax(class_scores)
inferred_class = class_names[top_class]

print(f'The main sound is: {inferred_class}')
print(f'The embeddings shape: {embeddings.shape}')
The main sound is: Animal
The embeddings shape: (13, 1024)

ESC-50 डेटासेट

ESC-50 डाटासेट ( Piczak 2015 ) 2,000 पांच सेकंड लंबा पर्यावरण ऑडियो रिकॉर्डिंग की एक लेबल संग्रह है। डेटासेट में प्रति वर्ग 40 उदाहरणों के साथ 50 वर्ग होते हैं।

डेटासेट डाउनलोड करें और इसे निकालें।

_ = tf.keras.utils.get_file('esc-50.zip',
                        'https://github.com/karoldvl/ESC-50/archive/master.zip',
                        cache_dir='./',
                        cache_subdir='datasets',
                        extract=True)
Downloading data from https://github.com/karoldvl/ESC-50/archive/master.zip
645701632/Unknown - 41s 0us/step

डेटा का अन्वेषण करें

प्रत्येक फ़ाइल के लिए मेटाडाटा में csv फ़ाइल में निर्दिष्ट किया जाता है ./datasets/ESC-50-master/meta/esc50.csv

और सभी ऑडियो फाइलों में हैं ./datasets/ESC-50-master/audio/

आप एक पांडा पैदा करेगा DataFrame मानचित्रण और उपयोग के साथ कि डेटा का स्पष्ट स्थिति है।

esc50_csv = './datasets/ESC-50-master/meta/esc50.csv'
base_data_path = './datasets/ESC-50-master/audio/'

pd_data = pd.read_csv(esc50_csv)
pd_data.head()

डेटा फ़िल्टर करें

अब जब कि डेटा में संग्रहित है DataFrame , कुछ परिवर्तनों लागू होते हैं:

  • पंक्तियों को फ़िल्टर करने और केवल चयनित वर्गों का उपयोग करें - dog और cat । यदि आप किसी अन्य वर्ग का उपयोग करना चाहते हैं, तो यह वह जगह है जहाँ आप उन्हें चुन सकते हैं।
  • पूरा पथ प्राप्त करने के लिए फ़ाइल नाम में संशोधन करें। इससे बाद में लोडिंग आसान हो जाएगी।
  • एक विशिष्ट सीमा के भीतर होने के लिए लक्ष्य बदलें। इस उदाहरण में, dog पर रहेगा 0 , लेकिन cat बन जाएगा 1 के अपने मूल मूल्य के बजाय 5
my_classes = ['dog', 'cat']
map_class_to_id = {'dog':0, 'cat':1}

filtered_pd = pd_data[pd_data.category.isin(my_classes)]

class_id = filtered_pd['category'].apply(lambda name: map_class_to_id[name])
filtered_pd = filtered_pd.assign(target=class_id)

full_path = filtered_pd['filename'].apply(lambda row: os.path.join(base_data_path, row))
filtered_pd = filtered_pd.assign(filename=full_path)

filtered_pd.head(10)

ऑडियो फ़ाइलें लोड करें और एम्बेडिंग पुनर्प्राप्त करें

यहाँ आप लागू कर देंगे load_wav_16k_mono और मॉडल के लिए WAV डेटा तैयार करते हैं।

जब WAV डेटा से embeddings निकालने, आप आकार की एक सरणी मिल (N, 1024) जहां N कि YAMNet पाया फ्रेम की संख्या (ऑडियो के हर 0.48 सेकंड के लिए एक) है।

आपका मॉडल प्रत्येक फ्रेम को एक इनपुट के रूप में उपयोग करेगा। इसलिए, आपको एक नया कॉलम बनाने की जरूरत है जिसमें प्रति पंक्ति एक फ्रेम हो। तुम भी और लेबल का विस्तार करने की जरूरत fold उचित करने के लिए स्तंभ इन नई पंक्तियों को दर्शाते हैं।

विस्तार fold स्तंभ मूल मूल्यों रहता है। आप फ़्रेम को मिक्स नहीं कर सकते हैं, क्योंकि स्प्लिट्स करते समय, आप एक ही ऑडियो के कुछ हिस्सों को अलग-अलग स्प्लिट्स पर रख सकते हैं, जो आपके सत्यापन और परीक्षण चरणों को कम प्रभावी बना देगा।

filenames = filtered_pd['filename']
targets = filtered_pd['target']
folds = filtered_pd['fold']

main_ds = tf.data.Dataset.from_tensor_slices((filenames, targets, folds))
main_ds.element_spec
(TensorSpec(shape=(), dtype=tf.string, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None))
def load_wav_for_map(filename, label, fold):
  return load_wav_16k_mono(filename), label, fold

main_ds = main_ds.map(load_wav_for_map)
main_ds.element_spec
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample
(TensorSpec(shape=<unknown>, dtype=tf.float32, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None))
# applies the embedding extraction model to a wav data
def extract_embedding(wav_data, label, fold):
  ''' run YAMNet to extract embedding from the wav data '''
  scores, embeddings, spectrogram = yamnet_model(wav_data)
  num_embeddings = tf.shape(embeddings)[0]
  return (embeddings,
            tf.repeat(label, num_embeddings),
            tf.repeat(fold, num_embeddings))

# extract embedding
main_ds = main_ds.map(extract_embedding).unbatch()
main_ds.element_spec
(TensorSpec(shape=(1024,), dtype=tf.float32, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None),
 TensorSpec(shape=(), dtype=tf.int64, name=None))

डेटा विभाजित करें

आप का उपयोग करेगा fold ट्रेन, सत्यापन और परीक्षण सेट में डाटासेट विभाजित करने के लिए स्तंभ।

ESC-50 पांच समान रूप से आकार पार सत्यापन में व्यवस्थित किया जाता है fold है, ऐसी है कि एक ही मूल स्रोत से क्लिप एक ही में हमेशा से रहे fold - में और अधिक जानकारी प्राप्त ESC: पर्यावरण ध्वनि वर्गीकरण के लिए डेटासेट कागज।

अंतिम चरण के दूर करने के लिए है fold के बाद से आप प्रशिक्षण के दौरान इसका इस्तेमाल करने नहीं जा रहे हैं डाटासेट से स्तंभ।

cached_ds = main_ds.cache()
train_ds = cached_ds.filter(lambda embedding, label, fold: fold < 4)
val_ds = cached_ds.filter(lambda embedding, label, fold: fold == 4)
test_ds = cached_ds.filter(lambda embedding, label, fold: fold == 5)

# remove the folds column now that it's not needed anymore
remove_fold_column = lambda embedding, label, fold: (embedding, label)

train_ds = train_ds.map(remove_fold_column)
val_ds = val_ds.map(remove_fold_column)
test_ds = test_ds.map(remove_fold_column)

train_ds = train_ds.cache().shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)
val_ds = val_ds.cache().batch(32).prefetch(tf.data.AUTOTUNE)
test_ds = test_ds.cache().batch(32).prefetch(tf.data.AUTOTUNE)

अपना मॉडल बनाएं

आपने ज्यादातर काम किया! इसके बाद, एक बहुत ही सरल परिभाषित अनुक्रमिक एक छिपा हुआ परत और दो आउटपुट के साथ मॉडल ध्वनियों से बिल्लियों और कुत्तों पहचान करने के लिए।

my_model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(1024), dtype=tf.float32,
                          name='input_embedding'),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(len(my_classes))
], name='my_model')

my_model.summary()
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
Model: "my_model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense (Dense)                (None, 512)               524800    
_________________________________________________________________
dense_1 (Dense)              (None, 2)                 1026      
=================================================================
Total params: 525,826
Trainable params: 525,826
Non-trainable params: 0
_________________________________________________________________
my_model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                 optimizer="adam",
                 metrics=['accuracy'])

callback = tf.keras.callbacks.EarlyStopping(monitor='loss',
                                            patience=3,
                                            restore_best_weights=True)
history = my_model.fit(train_ds,
                       epochs=20,
                       validation_data=val_ds,
                       callbacks=callback)
Epoch 1/20
15/15 [==============================] - 5s 25ms/step - loss: 0.7833 - accuracy: 0.8000 - val_loss: 0.6789 - val_accuracy: 0.8687
Epoch 2/20
15/15 [==============================] - 0s 16ms/step - loss: 0.5082 - accuracy: 0.8958 - val_loss: 0.3775 - val_accuracy: 0.8813
Epoch 3/20
15/15 [==============================] - 0s 17ms/step - loss: 0.3210 - accuracy: 0.8750 - val_loss: 0.5043 - val_accuracy: 0.8750
Epoch 4/20
15/15 [==============================] - 0s 17ms/step - loss: 0.2146 - accuracy: 0.9021 - val_loss: 0.3757 - val_accuracy: 0.8750
Epoch 5/20
15/15 [==============================] - 0s 17ms/step - loss: 0.2113 - accuracy: 0.9062 - val_loss: 0.2740 - val_accuracy: 0.8750
Epoch 6/20
15/15 [==============================] - 0s 17ms/step - loss: 0.2672 - accuracy: 0.9167 - val_loss: 0.4483 - val_accuracy: 0.8750
Epoch 7/20
15/15 [==============================] - 0s 17ms/step - loss: 0.2386 - accuracy: 0.9333 - val_loss: 0.5775 - val_accuracy: 0.8687
Epoch 8/20
15/15 [==============================] - 0s 17ms/step - loss: 0.1639 - accuracy: 0.9229 - val_loss: 0.4539 - val_accuracy: 0.8750
Epoch 9/20
15/15 [==============================] - 0s 18ms/step - loss: 0.3539 - accuracy: 0.9250 - val_loss: 0.2091 - val_accuracy: 0.9187
Epoch 10/20
15/15 [==============================] - 0s 18ms/step - loss: 0.2705 - accuracy: 0.9271 - val_loss: 0.2505 - val_accuracy: 0.9062
Epoch 11/20
15/15 [==============================] - 0s 17ms/step - loss: 0.2582 - accuracy: 0.9312 - val_loss: 0.2182 - val_accuracy: 0.9250

के चलाते हैं evaluate परीक्षण डेटा पर विधि सिर्फ यकीन है कि वहाँ कोई overfitting है किया जाना है।

loss, accuracy = my_model.evaluate(test_ds)

print("Loss: ", loss)
print("Accuracy: ", accuracy)
5/5 [==============================] - 0s 4ms/step - loss: 0.6575 - accuracy: 0.8125
Loss:  0.657511293888092
Accuracy:  0.8125

तुमने यह किया!

अपने मॉडल का परीक्षण करें

इसके बाद, केवल YAMNet का उपयोग करके पिछले परीक्षण से एम्बेडिंग पर अपने मॉडल का प्रयास करें।

scores, embeddings, spectrogram = yamnet_model(testing_wav_data)
result = my_model(embeddings).numpy()

inferred_class = my_classes[result.mean(axis=0).argmax()]
print(f'The main sound is: {inferred_class}')
The main sound is: cat

एक मॉडल सहेजें जो सीधे WAV फ़ाइल को इनपुट के रूप में ले सकता है

जब आप इसे इनपुट के रूप में एम्बेडिंग देते हैं तो आपका मॉडल काम करता है।

वास्तविक दुनिया के परिदृश्य में, आप प्रत्यक्ष इनपुट के रूप में ऑडियो डेटा का उपयोग करना चाहेंगे।

ऐसा करने के लिए, आप अपने मॉडल के साथ YAMNet को एक एकल मॉडल में संयोजित करेंगे जिसे आप अन्य अनुप्रयोगों के लिए निर्यात कर सकते हैं।

यह आसान मॉडल के परिणाम का उपयोग करने के लिए, अंतिम परत एक हो जाएगा reduce_mean आपरेशन। सेवा के लिए इस मॉडल का उपयोग करते समय (जिसके बारे में आप बाद में ट्यूटोरियल में जानेंगे), आपको अंतिम परत के नाम की आवश्यकता होगी। यदि आप एक को परिभाषित नहीं करते हैं, तो TensorFlow एक वृद्धिशील को स्वतः परिभाषित कर देगा जिससे परीक्षण करना कठिन हो जाता है, क्योंकि जब भी आप मॉडल को प्रशिक्षित करते हैं तो यह हर बार बदलता रहेगा। कच्चे TensorFlow ऑपरेशन का उपयोग करते समय, आप इसे एक नाम निर्दिष्ट नहीं कर सकते। इस मुद्दे के समाधान के लिए, आपको लागू होने वाला एक कस्टम परत बना देंगे reduce_mean और इसे कहते 'classifier'

class ReduceMeanLayer(tf.keras.layers.Layer):
  def __init__(self, axis=0, **kwargs):
    super(ReduceMeanLayer, self).__init__(**kwargs)
    self.axis = axis

  def call(self, input):
    return tf.math.reduce_mean(input, axis=self.axis)
saved_model_path = './dogs_and_cats_yamnet'

input_segment = tf.keras.layers.Input(shape=(), dtype=tf.float32, name='audio')
embedding_extraction_layer = hub.KerasLayer(yamnet_model_handle,
                                            trainable=False, name='yamnet')
_, embeddings_output, _ = embedding_extraction_layer(input_segment)
serving_outputs = my_model(embeddings_output)
serving_outputs = ReduceMeanLayer(axis=0, name='classifier')(serving_outputs)
serving_model = tf.keras.Model(input_segment, serving_outputs)
serving_model.save(saved_model_path, include_optimizer=False)
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.
INFO:tensorflow:Assets written to: ./dogs_and_cats_yamnet/assets
INFO:tensorflow:Assets written to: ./dogs_and_cats_yamnet/assets
tf.keras.utils.plot_model(serving_model)

पीएनजी

अपने सहेजे गए मॉडल को यह सत्यापित करने के लिए लोड करें कि यह अपेक्षा के अनुरूप काम करता है।

reloaded_model = tf.saved_model.load(saved_model_path)

और अंतिम परीक्षण के लिए: कुछ ध्वनि डेटा दिया गया है, क्या आपका मॉडल सही परिणाम देता है?

reloaded_results = reloaded_model(testing_wav_data)
cat_or_dog = my_classes[tf.argmax(reloaded_results)]
print(f'The main sound is: {cat_or_dog}')
The main sound is: cat

यदि आप अपने नए मॉडल को एक सर्विंग सेटअप पर आज़माना चाहते हैं, तो आप 'serving_default' हस्ताक्षर का उपयोग कर सकते हैं।

serving_results = reloaded_model.signatures['serving_default'](testing_wav_data)
cat_or_dog = my_classes[tf.argmax(serving_results['classifier'])]
print(f'The main sound is: {cat_or_dog}')
The main sound is: cat

(वैकल्पिक) कुछ और परीक्षण

मॉडल तैयार है।

आइए इसकी तुलना परीक्षण डेटासेट पर YAMNet से करें।

test_pd = filtered_pd.loc[filtered_pd['fold'] == 5]
row = test_pd.sample(1)
filename = row['filename'].item()
print(filename)
waveform = load_wav_16k_mono(filename)
print(f'Waveform values: {waveform}')
_ = plt.plot(waveform)

display.Audio(waveform, rate=16000)
./datasets/ESC-50-master/audio/5-212454-A-0.wav
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample
WARNING:tensorflow:Using a while_loop for converting IO>AudioResample
Waveform values: [-8.8849301e-09  2.6603255e-08 -1.1731625e-08 ... -1.3478296e-03
 -1.0509168e-03 -9.1038318e-04]

पीएनजी

# Run the model, check the output.
scores, embeddings, spectrogram = yamnet_model(waveform)
class_scores = tf.reduce_mean(scores, axis=0)
top_class = tf.argmax(class_scores)
inferred_class = class_names[top_class]
top_score = class_scores[top_class]
print(f'[YAMNet] The main sound is: {inferred_class} ({top_score})')

reloaded_results = reloaded_model(waveform)
your_top_class = tf.argmax(reloaded_results)
your_inferred_class = my_classes[your_top_class]
class_probabilities = tf.nn.softmax(reloaded_results, axis=-1)
your_top_score = class_probabilities[your_top_class]
print(f'[Your model] The main sound is: {your_inferred_class} ({your_top_score})')
[YAMNet] The main sound is: Animal (0.9570276141166687)
[Your model] The main sound is: dog (0.9999711513519287)

अगला कदम

आपने एक मॉडल बनाया है जो कुत्तों या बिल्लियों की आवाज़ों को वर्गीकृत कर सकता है। एक ही विचार है और एक अलग डाटासेट के साथ आप उदाहरण के लिए, कोशिश कर सकते हैं, एक के निर्माण के पक्षियों की ध्वनिक पहचानकर्ता उनके गायन पर आधारित है।

सोशल मीडिया पर TensorFlow टीम के साथ अपना प्रोजेक्ट साझा करें!