ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

ถ่ายทอดการเรียนรู้ด้วย YAMNet เพื่อการจำแนกเสียงสิ่งแวดล้อม

ดูบน TensorFlow.org ทำงานใน Google Colab ดูบน GitHub ดาวน์โหลดโน๊ตบุ๊ค ดูรุ่น TF Hub

YAMNet เป็นก่อนการฝึกอบรมเครือข่ายประสาทลึกที่สามารถทำนายเหตุการณ์เสียงจาก 521 ชั้นเรียน เช่นเสียงหัวเราะเห่าหรือไซเรน

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธี:

  • โหลดและใช้โมเดล YAMNet สำหรับการอนุมาน
  • สร้างโมเดลใหม่โดยใช้การฝัง YAMNet เพื่อจำแนกเสียงแมวและสุนัข
  • ประเมินและส่งออกแบบจำลองของคุณ

นำเข้า TensorFlow และไลบรารีอื่นๆ

เริ่มต้นด้วยการติดตั้ง TensorFlow I / O ซึ่งจะทำให้มันง่ายขึ้นสำหรับคุณที่จะโหลดไฟล์เสียงออกจากดิสก์

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

YAMNet เป็นก่อนการฝึกอบรมเครือข่ายประสาทที่มีพนักงาน MobileNetV1 สถาปัตยกรรมบิด depthwise-แยกกันไม่ออก มันสามารถใช้รูปแบบของคลื่นเสียงเป็น input และทำให้การคาดการณ์ที่เป็นอิสระสำหรับแต่ละเหตุการณ์ 521 เสียงจาก AudioSet คลัง

ภายใน โมเดลจะแยก "เฟรม" ออกจากสัญญาณเสียงและประมวลผลแบทช์ของเฟรมเหล่านี้ โมเดลเวอร์ชันนี้ใช้เฟรมที่มีความยาว 0.96 วินาที และแยกหนึ่งเฟรมทุกๆ 0.48 วินาที

รูปแบบการยอมรับ 1-D float32 Tensor หรือ NumPy อาร์เรย์ที่มีรูปแบบของคลื่นของความยาวโดยพลการแสดงเป็นช่องทางเดียว (ขาวดำ) 16 ตัวอย่างเฮิร์ทซ์ในช่วง [-1.0, +1.0] บทช่วยสอนนี้มีโค้ดที่จะช่วยคุณแปลงไฟล์ WAV ให้อยู่ในรูปแบบที่รองรับ

รูปแบบผลตอบแทน 3 ผลรวมถึงคะแนนระดับ embeddings (ซึ่งคุณจะใช้สำหรับการเรียนรู้การถ่ายโอน) และบันทึกเมล spectrogram คุณสามารถค้นหารายละเอียดเพิ่มเติมได้ ที่นี่

การใช้งานเฉพาะของ YAMNet คือการเป็นตัวแยกคุณลักษณะระดับสูง - เอาต์พุตการฝัง 1,024 มิติ คุณจะใช้ฐาน (YAMNet) นำเข้าแบบจำลองให้บริการและให้อาหารพวกเขาในรูปแบบตื้นของคุณประกอบด้วยซ่อนหนึ่ง tf.keras.layers.Dense ชั้น จากนั้นคุณจะอบรมเครือข่ายเกี่ยวกับจำนวนเงินขนาดเล็กของข้อมูลสำหรับการจำแนกเสียงโดยไม่ต้องมีข้อมูลจำนวนมากที่มีข้อความและการฝึกอบรมแบบ end-to-end (นี้จะคล้ายกับ การถ่ายโอนการเรียนรู้สำหรับการจัดหมวดหมู่ภาพด้วย TensorFlow Hub สำหรับข้อมูลเพิ่มเติม.)

ขั้นแรก คุณจะทดสอบโมเดลและดูผลการจำแนกเสียง จากนั้นคุณจะสร้างไปป์ไลน์การประมวลผลข้อมูลล่วงหน้า

กำลังโหลด YAMNet จาก TensorFlow Hub

คุณกำลังจะไปใช้ก่อนได้รับการฝึกฝนจาก YAMNet Tensorflow Hub เพื่อดึง embeddings จากไฟล์เสียง

โหลดโมเดลจาก TensorFlow Hub คือตรงไปตรงมา: เลือกรูปแบบการคัดลอก URL ของตนและใช้ 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

png

โหลด class mapping

สิ่งสำคัญคือต้องโหลดชื่อคลาสที่ YAMNet สามารถจดจำได้ แฟ้มการทำแผนที่เป็นปัจจุบันที่ yamnet_model.class_map_path() ในรูปแบบรูปแบบ CSV

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 บันทึกเสียงที่ห้าวินาทีสิ่งแวดล้อมยาว ชุดข้อมูลประกอบด้วย 50 คลาส โดยมี 40 ตัวอย่างต่อคลาส

ดาวน์โหลดชุดข้อมูลและแตกไฟล์

_ = 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 สำหรับรูปแบบ

เมื่อแยก embeddings จากข้อมูล WAV คุณจะได้รับอาร์เรย์ของรูปร่าง (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 s เช่นว่าคลิปจากต้นฉบับเดียวกันอยู่เสมอในเดียวกัน 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 วิธีการเกี่ยวกับข้อมูลการทดสอบเพียงเพื่อให้แน่ใจว่าไม่มีการอิง

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)

png

โหลดโมเดลที่บันทึกไว้เพื่อตรวจสอบว่าใช้งานได้ตามที่คาดไว้

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]

png

# 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 บนโซเชียลมีเดีย!