 TensorFlow.org पर देखें |  Google Colab में चलाएं |  गिटहब पर देखें |  नोटबुक डाउनलोड करें |  टीएफ हब मॉडल देखें |
इस नोटबुक में, हम से पूर्व प्रशिक्षित wav2vec2 मॉडल लोड होगा TFHub और फ़ाइन-ट्यून पर यह होगा LibriSpeech डाटासेट हमारे पूर्व प्रशिक्षित मॉडल के शीर्ष पर भाषा मॉडलिंग सिर (एल एम) जोड़कर। अंतर्निहित काम के लिए एक मॉडल बनाने के लिए के लिए स्वत: वाक् पहचान कुछ भाषण, मॉडल पाठ में उसका लिप्यंतरण में सक्षम होना चाहिए दिया अर्थात् है।
की स्थापना
इस नोटबुक चलाने से पहले, कृपया सुनिश्चित करें कि आप GPU क्रम (पर हैं Runtime > Change runtime type > GPU )। निम्नलिखित सेल स्थापित हो जाएगा gsoc-wav2vec2 पैकेज और उसके निर्भरता।
pip3 install -q git+https://github.com/vasudevgupta7/gsoc-wav2vec2@mainsudo apt-get install -y libsndfile1-devpip3 install -q SoundFile
The following packages were automatically installed and are no longer required: linux-gcp-5.4-headers-5.4.0-1040 linux-gcp-5.4-headers-5.4.0-1043 linux-gcp-5.4-headers-5.4.0-1044 linux-gcp-5.4-headers-5.4.0-1049 linux-headers-5.4.0-1049-gcp linux-image-5.4.0-1049-gcp linux-modules-5.4.0-1049-gcp linux-modules-extra-5.4.0-1049-gcp Use 'sudo apt autoremove' to remove them. The following additional packages will be installed: libflac-dev libogg-dev libvorbis-dev libvorbisfile3 The following NEW packages will be installed: libflac-dev libogg-dev libsndfile1-dev libvorbis-dev libvorbisfile3 0 upgraded, 5 newly installed, 0 to remove and 143 not upgraded. Need to get 1040 kB of archives. After this operation, 4481 kB of additional disk space will be used. Get:1 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic/main amd64 libogg-dev amd64 1.3.2-1 [156 kB] Get:2 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic/main amd64 libflac-dev amd64 1.3.2-1 [260 kB] Get:3 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic/main amd64 libvorbisfile3 amd64 1.3.5-4.2 [16.0 kB] Get:4 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic/main amd64 libvorbis-dev amd64 1.3.5-4.2 [321 kB] Get:5 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-updates/main amd64 libsndfile1-dev amd64 1.0.28-4ubuntu0.18.04.2 [287 kB] Fetched 1040 kB in 1s (1041 kB/s) Selecting previously unselected package libogg-dev:amd64. (Reading database ... 282211 files and directories currently installed.) Preparing to unpack .../libogg-dev_1.3.2-1_amd64.deb ... Unpacking libogg-dev:amd64 (1.3.2-1) ... Selecting previously unselected package libflac-dev:amd64. Preparing to unpack .../libflac-dev_1.3.2-1_amd64.deb ... Unpacking libflac-dev:amd64 (1.3.2-1) ... Selecting previously unselected package libvorbisfile3:amd64. Preparing to unpack .../libvorbisfile3_1.3.5-4.2_amd64.deb ... Unpacking libvorbisfile3:amd64 (1.3.5-4.2) ... Selecting previously unselected package libvorbis-dev:amd64. Preparing to unpack .../libvorbis-dev_1.3.5-4.2_amd64.deb ... Unpacking libvorbis-dev:amd64 (1.3.5-4.2) ... Selecting previously unselected package libsndfile1-dev. Preparing to unpack .../libsndfile1-dev_1.0.28-4ubuntu0.18.04.2_amd64.deb ... Unpacking libsndfile1-dev (1.0.28-4ubuntu0.18.04.2) ... Setting up libvorbisfile3:amd64 (1.3.5-4.2) ... Setting up libogg-dev:amd64 (1.3.2-1) ... Setting up libvorbis-dev:amd64 (1.3.5-4.2) ... Setting up libflac-dev:amd64 (1.3.2-1) ... Setting up libsndfile1-dev (1.0.28-4ubuntu0.18.04.2) ... Processing triggers for libc-bin (2.27-3ubuntu1.2) ...
मॉडल सेटअप का उपयोग TFHub
हम कुछ पुस्तकालयों/मॉड्यूल को आयात करके शुरू करेंगे।
import os
import tensorflow as tf
import tensorflow_hub as hub
from wav2vec2 import Wav2Vec2Config
config = Wav2Vec2Config()
print("TF version:", tf.__version__)
TF version: 2.7.0
सबसे पहले, हम TFHub से हमारे मॉडल डाउनलोड करेगा और साथ हमारे मॉडल हस्ताक्षर लपेटो जाएगा hub.KerasLayer किसी अन्य Keras परत की तरह इस मॉडल का उपयोग करने में सक्षम हो। सौभाग्य से, hub.KerasLayer सिर्फ 1 लाइन में दोनों कर सकते हैं।
pretrained_layer = hub.KerasLayer("https://tfhub.dev/vasudevgupta7/wav2vec2/1", trainable=True)
आप इस का उल्लेख कर सकते स्क्रिप्ट मामले में आप मॉडल निर्यात स्क्रिप्ट के इच्छुक हों। वस्तु pretrained_layer की Freezed संस्करण है Wav2Vec2Model । इन पूर्व से प्रशिक्षित वजन HuggingFace PyTorch से बदल रहे थे पहले से प्रशिक्षित वजन का उपयोग कर इस स्क्रिप्ट ।
मूल रूप से, wav2vec2 को एक नकाबपोश भाषा मॉडलिंग दृष्टिकोण के साथ पूर्व-प्रशिक्षित किया गया था, जिसका उद्देश्य एक नकाबपोश समय चरण के लिए वास्तविक मात्राबद्ध अव्यक्त भाषण प्रतिनिधित्व की पहचान करना था। आप कागज में प्रशिक्षण उद्देश्य के बारे में और अधिक पढ़ सकते भाषण प्रतिनिधित्व के स्व-प्रबंधित सीखना के लिए एक फ्रेमवर्क: wav2vec 2.0 ।
अब, हम कुछ स्थिरांक और हाइपर-पैरामीटर परिभाषित करेंगे जो अगले कुछ कक्षों में उपयोगी होंगे। AUDIO_MAXLEN जानबूझकर के लिए सेट है 246000 के रूप में मॉडल हस्ताक्षर केवल के स्थिर अनुक्रम लंबाई स्वीकार करता है 246000 ।
AUDIO_MAXLEN = 246000
LABEL_MAXLEN = 256
BATCH_SIZE = 2
निम्नलिखित सेल में, हम लपेटो जाएगा pretrained_layer साथ और एक घने परत (एल एम सिर) Keras के कार्यात्मक एपीआई ।
inputs = tf.keras.Input(shape=(AUDIO_MAXLEN,))
hidden_states = pretrained_layer(inputs)
outputs = tf.keras.layers.Dense(config.vocab_size)(hidden_states)
model = tf.keras.Model(inputs=inputs, outputs=outputs)
घने परत (ऊपर परिभाषित) का उत्पादन आयाम रहा है vocab_size के रूप में हम हर बार कदम पर शब्दावली में प्रत्येक टोकन की संभावनाओं भविष्यवाणी करने के लिए चाहते हैं।
प्रशिक्षण राज्य की स्थापना
TensorFlow में, मॉडल वेट केवल निर्माण कर रहे हैं जब model.call या model.build पहली बार के लिए कहा जाता है, तो निम्न सेल हमारे लिए मॉडल वेट का निर्माण होगा। इसके अलावा, हम चल रहे हो जाएगा model.summary() trainable मापदंडों की कुल संख्या की जांच करने के लिए।
model(tf.random.uniform(shape=(BATCH_SIZE, AUDIO_MAXLEN)))
model.summary()
Model: "model"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) [(None, 246000)] 0
keras_layer (KerasLayer) (None, 768, 768) 94371712
dense (Dense) (None, 768, 32) 24608
=================================================================
Total params: 94,396,320
Trainable params: 94,396,320
Non-trainable params: 0
_________________________________________________________________
अब, हम परिभाषित करने की जरूरत loss_fn मॉडल प्रशिक्षित करने के लिए सक्षम होने के लिए और अनुकूलक। निम्नलिखित सेल हमारे लिए ऐसा करेगी। हम उपयोग करेंगे Adam सादगी के लिए अनुकूलक। CTCLoss कि (जैसे कार्यों के लिए प्रयोग किया जाता है एक आम नुकसान प्रकार है ASR ) जहां इनपुट उप भागों आसानी से उत्पादन उप भागों के साथ गठबंधन नहीं किया जा सकता। आप इस अद्भुत से सीटीसी-नुकसान के बारे में अधिक पढ़ सकते हैं ब्लॉग पोस्ट ।
CTCLoss (से gsoc-wav2vec2 : पैकेज) 3 तर्क स्वीकार करता है config , model_input_shape और division_factor । यदि division_factor=1 , तो नुकसान बस अभिव्यक्त हो जाएगी, इसलिए पारित division_factor तदनुसार मतलब से अधिक बैच पाने के लिए।
from wav2vec2 import CTCLoss
LEARNING_RATE = 5e-5
loss_fn = CTCLoss(config, (BATCH_SIZE, AUDIO_MAXLEN), division_factor=BATCH_SIZE)
optimizer = tf.keras.optimizers.Adam(LEARNING_RATE)
डेटा लोड हो रहा है और प्री-प्रोसेसिंग डेटा
चलो अब से LibriSpeech डाटासेट डाउनलोड करते हैं आधिकारिक वेबसाइट और इसे सेट अप।
wget https://www.openslr.org/resources/12/dev-clean.tar.gz -P ./data/train/tar -xf ./data/train/dev-clean.tar.gz -C ./data/train/
--2021-11-05 11:43:09-- https://www.openslr.org/resources/12/dev-clean.tar.gz Resolving www.openslr.org (www.openslr.org)... 46.101.158.64 Connecting to www.openslr.org (www.openslr.org)|46.101.158.64|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 337926286 (322M) [application/x-gzip] Saving to: ‘./data/train/dev-clean.tar.gz’ dev-clean.tar.gz 100%[===================>] 322.27M 11.6MB/s in 31s 2021-11-05 11:43:42 (10.3 MB/s) - ‘./data/train/dev-clean.tar.gz’ saved [337926286/337926286]
ls ./data/train/
LibriSpeech/ dev-clean.tar.gz
हमारा डेटासेट लिब्रीस्पीच डायरेक्टरी में है। आइए इन फाइलों के बारे में जानें।
data_dir = "./data/train/LibriSpeech/dev-clean/2428/83705/"
all_files = os.listdir(data_dir)
flac_files = [f for f in all_files if f.endswith(".flac")]
txt_files = [f for f in all_files if f.endswith(".txt")]
print("Transcription files:", txt_files, "\nSound files:", flac_files)
Transcription files: ['2428-83705.trans.txt'] Sound files: ['2428-83705-0015.flac', '2428-83705-0004.flac', '2428-83705-0006.flac', '2428-83705-0026.flac', '2428-83705-0023.flac', '2428-83705-0001.flac', '2428-83705-0005.flac', '2428-83705-0040.flac', '2428-83705-0038.flac', '2428-83705-0042.flac', '2428-83705-0008.flac', '2428-83705-0019.flac', '2428-83705-0021.flac', '2428-83705-0002.flac', '2428-83705-0039.flac', '2428-83705-0034.flac', '2428-83705-0028.flac', '2428-83705-0000.flac', '2428-83705-0029.flac', '2428-83705-0041.flac', '2428-83705-0035.flac', '2428-83705-0032.flac', '2428-83705-0020.flac', '2428-83705-0025.flac', '2428-83705-0010.flac', '2428-83705-0014.flac', '2428-83705-0003.flac', '2428-83705-0031.flac', '2428-83705-0017.flac', '2428-83705-0027.flac', '2428-83705-0012.flac', '2428-83705-0043.flac', '2428-83705-0030.flac', '2428-83705-0022.flac', '2428-83705-0016.flac', '2428-83705-0037.flac', '2428-83705-0011.flac', '2428-83705-0036.flac', '2428-83705-0009.flac', '2428-83705-0013.flac', '2428-83705-0007.flac', '2428-83705-0018.flac', '2428-83705-0024.flac', '2428-83705-0033.flac']
ठीक है, इसलिए प्रत्येक उप-निर्देशिका कई है .flac फ़ाइलें और एक .txt फ़ाइल। .txt फ़ाइल सब भाषण नमूनों के लिए पाठ प्रतिलेखन (यानी शामिल .flac कि उप निर्देशिका में फ़ाइलों) वर्तमान।
हम इस टेक्स्ट डेटा को निम्नानुसार लोड कर सकते हैं:
def read_txt_file(f):
with open(f, "r") as f:
samples = f.read().split("\n")
samples = {s.split()[0]: " ".join(s.split()[1:]) for s in samples if len(s.split()) > 2}
return samples
इसी तरह, हम एक से एक भाषण नमूना लोड करने के लिए एक समारोह परिभाषित करेगा .flac फ़ाइल।
REQUIRED_SAMPLE_RATE पर सेट है 16000 के रूप में wav2vec2 के साथ पहले से प्रशिक्षित किया गया था 16K आवृत्ति और यह आवृत्ति के कारण डेटा वितरण में किसी भी बड़े बदलाव के बिना यह फ़ाइन-ट्यून करने के लिए सिफारिश की है।
import soundfile as sf
REQUIRED_SAMPLE_RATE = 16000
def read_flac_file(file_path):
with open(file_path, "rb") as f:
audio, sample_rate = sf.read(f)
if sample_rate != REQUIRED_SAMPLE_RATE:
raise ValueError(
f"sample rate (={sample_rate}) of your files must be {REQUIRED_SAMPLE_RATE}"
)
file_id = os.path.split(file_path)[-1][:-len(".flac")]
return {file_id: audio}
अब, हम कुछ यादृच्छिक नमूने लेंगे और उनकी कल्पना करने का प्रयास करेंगे।
from IPython.display import Audio
import random
file_id = random.choice([f[:-len(".flac")] for f in flac_files])
flac_file_path, txt_file_path = os.path.join(data_dir, f"{file_id}.flac"), os.path.join(data_dir, "2428-83705.trans.txt")
print("Text Transcription:", read_txt_file(txt_file_path)[file_id], "\nAudio:")
Audio(filename=flac_file_path)
Text Transcription: HE HAS GIVEN US FREE PASSES ALL THE WAY TO THE END OF OUR JOURNEY AND ALL THE WAY BACK AGAIN AND COUPONS FOR FREE BOARD AND LODGING AT THE HOTEL IT'S A WEDDING PRESENT Audio:
अब, हम सभी भाषण और पाठ के नमूनों को जोड़ देंगे और उस उद्देश्य के लिए फ़ंक्शन (अगले सेल में) को परिभाषित करेंगे।
def fetch_sound_text_mapping(data_dir):
all_files = os.listdir(data_dir)
flac_files = [os.path.join(data_dir, f) for f in all_files if f.endswith(".flac")]
txt_files = [os.path.join(data_dir, f) for f in all_files if f.endswith(".txt")]
txt_samples = {}
for f in txt_files:
txt_samples.update(read_txt_file(f))
speech_samples = {}
for f in flac_files:
speech_samples.update(read_flac_file(f))
assert len(txt_samples) == len(speech_samples)
samples = [(speech_samples[file_id], txt_samples[file_id]) for file_id in speech_samples.keys() if len(speech_samples[file_id]) < AUDIO_MAXLEN]
return samples
कुछ नमूने देखने का समय आ गया है ...
samples = fetch_sound_text_mapping(data_dir)
samples[:5]
[(array([ 6.10351562e-05, 9.15527344e-05, 9.15527344e-05, ...,
-3.05175781e-04, -5.79833984e-04, -8.23974609e-04]),
'WHEN SHE HEARD OF MY ENGAGEMENT WITH MARY ANN SHE WROTE AND SUGGESTED THAT WE SHOULD SPEND OUR HONEYMOON IN HER COTTAGE OR PIGSTYE AND THAT I SHOULD PAY HER RENT FOR IT'),
(array([-0.00112915, -0.00131226, -0.00158691, ..., 0.00067139,
0.00091553, 0.00100708]),
"IT MIGHT JUST AS WELL BE SOME ONE ELSE'S WEDDING SO UNIMPORTANT IS THE PART WHICH I AM SET TO PLAY IN IT"),
(array([ 3.05175781e-05, -6.10351562e-05, 2.13623047e-04, ...,
-5.18798828e-04, -2.13623047e-04, -2.74658203e-04]),
'THE ACCIDENT IN QUESTION OCCURRED UPON THE SUNDAY EVENING'),
(array([ 3.05175781e-04, 3.05175781e-05, -1.83105469e-04, ...,
7.62939453e-04, 6.10351562e-04, 5.79833984e-04]),
"OF COURSE THERE ARE SOME PEOPLE WITH WHOM YOU CAN'T BE PERFECTLY PLAIN BUT I SHALL BE AS PLAIN AS I CAN THERE'S A WAY AND A MANNER OF DOING THAT KIND OF THING"),
(array([ 6.10351562e-05, -3.05175781e-05, 0.00000000e+00, ...,
-3.66210938e-04, -7.93457031e-04, -1.19018555e-03]),
'I KNOW WHAT MAMMA CAN AFFORD TO GIVE AND I WILL SEE SHE GIVES IT')]
आइए अब डेटा को प्री-प्रोसेस करें !!!
हम पहले का उपयोग कर tokenizer और प्रोसेसर परिभाषित करेगा gsoc-wav2vec2 पैकेज। फिर, हम बहुत ही सरल प्री-प्रोसेसिंग करेंगे। processor कच्चे भाषण को सामान्य होगा फ्रेम अक्ष और wrto tokenizer (परिभाषित शब्दावली का प्रयोग करके) स्ट्रिंग में हमारे मॉडल आउटपुट में परिवर्तित कर देंगे और (अपने tokenizer कॉन्फ़िगरेशन के आधार पर) विशेष टोकन को हटाने की देखभाल करेंगे।
from wav2vec2 import Wav2Vec2Processor
tokenizer = Wav2Vec2Processor(is_tokenizer=True)
processor = Wav2Vec2Processor(is_tokenizer=False)
def preprocess_text(text):
label = tokenizer(text)
return tf.constant(label, dtype=tf.int32)
def preprocess_speech(audio):
audio = tf.constant(audio, dtype=tf.float32)
return processor(tf.transpose(audio))
Downloading `vocab.json` from https://github.com/vasudevgupta7/gsoc-wav2vec2/raw/main/data/vocab.json ... DONE
अब, हम उपरोक्त कोशिकाओं में परिभाषित प्रीप्रोसेसिंग कार्यों को कॉल करने के लिए पायथन जनरेटर को परिभाषित करेंगे।
def inputs_generator():
for speech, text in samples:
yield preprocess_speech(speech), preprocess_text(text)
की स्थापना tf.data.Dataset
सेल इच्छा सेटअप के बाद tf.data.Dataset अपने का उपयोग कर वस्तु .from_generator(...) विधि। हम का उपयोग किया जाएगा generator वस्तु, हम ऊपर सेल में परिभाषित किया।
आप उल्लेख कर सकते हैं इस स्क्रिप्ट tfrecords में LibriSpeech डेटा कन्वर्ट करने के लिए कैसे के बारे में अधिक जानकारी के लिए।
output_signature = (
tf.TensorSpec(shape=(None), dtype=tf.float32),
tf.TensorSpec(shape=(None), dtype=tf.int32),
)
dataset = tf.data.Dataset.from_generator(inputs_generator, output_signature=output_signature)
BUFFER_SIZE = len(flac_files)
SEED = 42
dataset = dataset.shuffle(BUFFER_SIZE, seed=SEED)
हम डेटासेट को कई बैचों में पास करेंगे, तो चलिए निम्नलिखित सेल में बैच तैयार करते हैं। अब, एक बैच में सभी अनुक्रमों को एक स्थिर लंबाई तक गद्देदार किया जाना चाहिए। हम का उपयोग करेगा .padded_batch(...) उस उद्देश्य के लिए विधि।
dataset = dataset.padded_batch(BATCH_SIZE, padded_shapes=(AUDIO_MAXLEN, LABEL_MAXLEN), padding_values=(0.0, 0))
एक्सेलेरेटर (जैसे जीपीयू/टीपीयू) बहुत तेज होते हैं और अक्सर डेटा-लोडिंग (और प्री-प्रोसेसिंग) प्रशिक्षण के दौरान बाधा बन जाते हैं क्योंकि डेटा-लोडिंग भाग सीपीयू पर होता है। यह प्रशिक्षण के समय को महत्वपूर्ण रूप से बढ़ा सकता है, खासकर जब इसमें बहुत अधिक ऑनलाइन प्री-प्रोसेसिंग शामिल हो या डेटा जीसीएस बकेट से ऑनलाइन स्ट्रीम किया जाता है। उन मुद्दों को संभालने के लिए tf.data.Dataset प्रदान करता है .prefetch(...) विधि। यह विधि अगले कुछ बैचों को समानांतर (सीपीयू पर) तैयार करने में मदद करती है, जबकि मॉडल वर्तमान बैच पर भविष्यवाणियां (जीपीयू/टीपीयू पर) कर रहा है।
dataset = dataset.prefetch(tf.data.AUTOTUNE)
चूंकि यह नोटबुक प्रदर्शन के उद्देश्य से किया जाता है, हम पहले उठाएंगे num_train_batches और होगा प्रदर्शन केवल उस पर प्रशिक्षण। हालांकि आपको संपूर्ण डेटासेट पर प्रशिक्षित करने के लिए प्रोत्साहित किया जाता है। इसी तरह, हम केवल का मूल्यांकन करेंगे num_val_batches ।
num_train_batches = 10
num_val_batches = 4
train_dataset = dataset.take(num_train_batches)
val_dataset = dataset.skip(num_train_batches).take(num_val_batches)
मॉडल प्रशिक्षण
हमारे मॉडल को प्रशिक्षण के लिए, हम सीधे कॉल किया जाएगा .fit(...) के साथ हमारे मॉडल संकलन के बाद विधि .compile(...) ।
model.compile(optimizer, loss=loss_fn)
उपरोक्त सेल हमारे प्रशिक्षण राज्य की स्थापना करेगा। अब हम साथ प्रशिक्षण आरंभ कर सकते हैं .fit(...) विधि।
history = model.fit(train_dataset, validation_data=val_dataset, epochs=3)
history.history
Epoch 1/3
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/ctc_ops.py:1447: alias_inplace_add (from tensorflow.python.ops.inplace_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Prefer tf.tensor_scatter_nd_add, which offers the same functionality with well-defined read-write semantics.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/ctc_ops.py:1447: alias_inplace_add (from tensorflow.python.ops.inplace_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Prefer tf.tensor_scatter_nd_add, which offers the same functionality with well-defined read-write semantics.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/ctc_ops.py:1430: alias_inplace_update (from tensorflow.python.ops.inplace_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Prefer tf.tensor_scatter_nd_update, which offers the same functionality with well-defined read-write semantics.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/ctc_ops.py:1430: alias_inplace_update (from tensorflow.python.ops.inplace_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Prefer tf.tensor_scatter_nd_update, which offers the same functionality with well-defined read-write semantics.
WARNING:tensorflow:Gradients do not exist for variables ['wav2vec2/masked_spec_embed:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?
WARNING:tensorflow:Gradients do not exist for variables ['wav2vec2/masked_spec_embed:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?
WARNING:tensorflow:Gradients do not exist for variables ['wav2vec2/masked_spec_embed:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?
WARNING:tensorflow:Gradients do not exist for variables ['wav2vec2/masked_spec_embed:0'] when minimizing the loss. If you're using `model.compile()`, did you forget to provide a `loss`argument?
10/10 [==============================] - 32s 2s/step - loss: 649.3215 - val_loss: 315.0721
Epoch 2/3
10/10 [==============================] - 17s 2s/step - loss: 242.1202 - val_loss: 336.5721
Epoch 3/3
10/10 [==============================] - 17s 2s/step - loss: 222.1239 - val_loss: 253.0467
{'loss': [649.321533203125, 242.1201629638672, 222.1239013671875],
'val_loss': [315.0721435546875, 336.5721130371094, 253.0466766357422]}
के साथ हमारे मॉडल को बचाने करते हैं .save(...) विधि बाद में अनुमान प्रदर्शन करने के लिए सक्षम होने के लिए। आप निम्न द्वारा TFHub को यह SavedModel निर्यात कर सकते हैं TFHub प्रलेखन ।
save_dir = "finetuned-wav2vec2"
model.save(save_dir, include_optimizer=False)
2021-11-05 11:44:54.280793: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them. WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 855). These functions will not be directly callable after loading. INFO:tensorflow:Assets written to: finetuned-wav2vec2/assets INFO:tensorflow:Assets written to: finetuned-wav2vec2/assets
मूल्यांकन
अब हम सत्यापन डेटासेट पर वर्ड एरर रेट की गणना करेंगे
वर्ड त्रुटि दर (WER) एक स्वचालित भाषण मान्यता प्रणाली के प्रदर्शन को मापने के लिए एक आम मीट्रिक है। WER शब्द स्तर पर काम करते हुए लेवेनशेटिन दूरी से लिया गया है। शब्द त्रुटि दर की गणना तब की जा सकती है: WER = (S + D + I) / N = (S + D + I) / (S + D + C) जहां S प्रतिस्थापन की संख्या है, D विलोपन की संख्या है , मैं सम्मिलन की संख्या है, सी सही शब्दों की संख्या है, एन संदर्भ में शब्दों की संख्या है (एन = एस + डी + सी)। यह मान उन शब्दों के प्रतिशत को इंगित करता है जिनकी गलत भविष्यवाणी की गई थी।
आप उल्लेख कर सकते हैं इस पत्र WER के बारे में अधिक जानने के लिए।
हम का उपयोग करेगा load_metric(...) से समारोह HuggingFace डेटासेट पुस्तकालय। का पहला इंस्टॉल करने दें datasets का उपयोग कर पुस्तकालय pip और फिर परिभाषित metric वस्तु।
!pip3 install -q datasets
from datasets import load_metric
metric = load_metric("wer")
Downloading: 0%| | 0.00/1.95k [00:00<?, ?B/s]
@tf.function(jit_compile=True)
def eval_fwd(batch):
logits = model(batch, training=False)
return tf.argmax(logits, axis=-1)
अब सत्यापन डेटा पर मूल्यांकन चलाने का समय आ गया है।
from tqdm.auto import tqdm
for speech, labels in tqdm(val_dataset, total=num_val_batches):
predictions = eval_fwd(speech)
predictions = [tokenizer.decode(pred) for pred in predictions.numpy().tolist()]
references = [tokenizer.decode(label, group_tokens=False) for label in labels.numpy().tolist()]
metric.add_batch(references=references, predictions=predictions)
0%| | 0/4 [00:00<?, ?it/s] 2021-11-05 11:45:11.575128: W tensorflow/compiler/tf2xla/kernels/random_ops.cc:57] Warning: Using tf.random.uniform with XLA compilation will ignore seeds; consider using tf.random.stateless_uniform instead if reproducible behavior is desired. model/keras_layer/StatefulPartitionedCall/StatefulPartitionedCall/wav2vec2/encoder/layers/0/stochastic_depth/random_uniform/RandomUniform
हम प्रयोग कर रहे हैं tokenizer.decode(...) डिकोडिंग हमारे भविष्यवाणियों और लेबल पाठ में लेने और के लिए मीट्रिक करने के लिए उन्हें जोड़ देगा के लिए विधि WER बाद में गणना।
अब, निम्नलिखित सेल में मीट्रिक मान की गणना करते हैं:
metric.compute()
1.0
अनुमान
अब जब हम और प्रशिक्षण प्रक्रिया से संतुष्ट में मॉडल बचाया है कर रहे हैं save_dir , हम कैसे इस मॉडल अनुमान के लिए इस्तेमाल किया जा सकता देखेंगे।
सबसे पहले, हम हमारे मॉडल का उपयोग कर लोड होगा tf.keras.models.load_model(...) ।
finetuned_model = tf.keras.models.load_model(save_dir)
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually. WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
आइए अनुमान लगाने के लिए कुछ भाषण नमूने डाउनलोड करें। आप निम्नलिखित नमूने को अपने भाषण के नमूने से भी बदल सकते हैं।
wget https://github.com/vasudevgupta7/gsoc-wav2vec2/raw/main/data/SA2.wav
--2021-11-05 11:45:28-- https://github.com/vasudevgupta7/gsoc-wav2vec2/raw/main/data/SA2.wav Resolving github.com (github.com)... 13.114.40.48 Connecting to github.com (github.com)|13.114.40.48|:443... connected. HTTP request sent, awaiting response... 302 Found Location: https://raw.githubusercontent.com/vasudevgupta7/gsoc-wav2vec2/main/data/SA2.wav [following] --2021-11-05 11:45:28-- https://raw.githubusercontent.com/vasudevgupta7/gsoc-wav2vec2/main/data/SA2.wav Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.111.133, 185.199.109.133, ... Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected. HTTP request sent, awaiting response... 200 OK Length: 94252 (92K) [audio/wav] Saving to: ‘SA2.wav’ SA2.wav 100%[===================>] 92.04K --.-KB/s in 0.02s 2021-11-05 11:45:29 (5.38 MB/s) - ‘SA2.wav’ saved [94252/94252]
अब, हम का उपयोग कर भाषण नमूना पढ़ा जाएगा soundfile.read(...) यह करने के लिए और पैड AUDIO_MAXLEN मॉडल हस्ताक्षर को पूरा करने के। फिर हम उस भाषण नमूना सामान्य का उपयोग कर जाएगा Wav2Vec2Processor उदाहरण और मॉडल में यह फीड होगा।
import numpy as np
speech, _ = sf.read("SA2.wav")
speech = np.pad(speech, (0, AUDIO_MAXLEN - len(speech)))
speech = tf.expand_dims(processor(tf.constant(speech)), 0)
outputs = finetuned_model(speech)
outputs
<tf.Tensor: shape=(1, 768, 32), dtype=float32, numpy=
array([[[ 5.5087714 , -1.0872856 , -1.0728477 , ..., -1.3125695 ,
-0.7992846 , -0.94512135],
[ 5.508977 , -1.0873723 , -1.0727195 , ..., -1.3125291 ,
-0.79928476, -0.9449429 ],
[ 5.5091047 , -1.0871643 , -1.0728203 , ..., -1.312533 ,
-0.7992611 , -0.94483167],
...,
[ 5.5094743 , -1.0874028 , -1.0729864 , ..., -1.3126655 ,
-0.7994431 , -0.9449925 ],
[ 5.509465 , -1.0873648 , -1.072943 , ..., -1.3126557 ,
-0.79943836, -0.94500387],
[ 5.509408 , -1.0872416 , -1.0728781 , ..., -1.3125473 ,
-0.7993649 , -0.9449776 ]]], dtype=float32)>
आइए डिकोड नंबर का उपयोग कर पाठ अनुक्रम में वापस Wav2Vec2tokenizer उदाहरण के लिए, हम ऊपर बताया गया है।
predictions = tf.argmax(outputs, axis=-1)
predictions = [tokenizer.decode(pred) for pred in predictions.numpy().tolist()]
predictions
['']
यह भविष्यवाणी काफी यादृच्छिक है क्योंकि इस नोटबुक में मॉडल को कभी भी बड़े डेटा पर प्रशिक्षित नहीं किया गया था (क्योंकि यह नोटबुक पूर्ण प्रशिक्षण करने के लिए नहीं है)। यदि आप इस मॉडल को संपूर्ण लिब्रीस्पीच डेटासेट पर प्रशिक्षित करते हैं तो आपको अच्छी भविष्यवाणियां मिलेंगी।
अंत में, हम इस नोटबुक के अंत में पहुँच गए हैं। लेकिन यह भाषण संबंधित कार्यों के लिए TensorFlow सीखने का एक अंत नहीं है, यह भंडार कुछ और अद्भुत ट्यूटोरियल में शामिल है। मामले में आप इस नोटबुक में किसी भी बग आया, एक मुद्दा बनाने कृपया यहां ।