Wav2vec2 के साथ कार्य करना भाग 1: स्वचालित वाक् पहचान के लिए XLS-R को परिष्कृत करना

परिचय

मेटा एआई ने 2021 के अंत में wav2vec2 XLS-R ("XLS-R") पेश किया। XLS-R क्रॉस-लिंगुअल स्पीच रिप्रेजेंटेशन लर्निंग के लिए एक मशीन लर्निंग ("ML") मॉडल है; और इसे 128 भाषाओं में सार्वजनिक रूप से उपलब्ध स्पीच ऑडियो के 400,000 से अधिक घंटों पर प्रशिक्षित किया गया था। अपनी रिलीज़ के बाद, मॉडल ने मेटा एआई के XLSR-53 क्रॉस-लिंगुअल मॉडल पर एक छलांग का प्रतिनिधित्व किया, जिसे 53 भाषाओं में लगभग 50,000 घंटों के स्पीच ऑडियो पर प्रशिक्षित किया गया था।

यह मार्गदर्शिका एक कागल नोटबुक का उपयोग करके स्वचालित वाक् पहचान ("ASR") के लिए XLS-R को फ़ाइनट्यून करने के चरणों की व्याख्या करती है। मॉडल को चिली स्पैनिश पर फ़ाइनट्यून किया जाएगा, लेकिन सामान्य चरणों का पालन करके आप अपनी इच्छानुसार विभिन्न भाषाओं पर XLS-R को फ़ाइनट्यून कर सकते हैं।

फ़ाइनट्यून्ड मॉडल पर अनुमान चलाने का वर्णन एक साथी ट्यूटोरियल में किया जाएगा, जिससे यह गाइड दो भागों में से पहला भाग बन जाएगा। मैंने एक अलग अनुमान-विशिष्ट गाइड बनाने का फैसला किया क्योंकि यह फ़ाइनट्यूनिंग गाइड थोड़ी लंबी हो गई थी।

यह माना जाता है कि आपके पास पहले से ही एमएल पृष्ठभूमि है और आप बुनियादी एएसआर अवधारणाओं को समझते हैं। शुरुआती लोगों को बिल्ड चरणों का पालन करने/समझने में मुश्किल हो सकती है।

XLS-R पर कुछ पृष्ठभूमि

2020 में पेश किए गए मूल wav2vec2 मॉडल को 960 घंटों के Librispeech डेटासेट स्पीच ऑडियो और ~53,200 घंटों के LibriVox डेटासेट स्पीच ऑडियो पर प्रीट्रेन किया गया था। इसके रिलीज़ होने पर, दो मॉडल आकार उपलब्ध थे: 95 मिलियन पैरामीटर वाला BASE मॉडल और 317 मिलियन पैरामीटर वाला LARGE मॉडल।

दूसरी ओर, XLS-R को 5 डेटासेट से बहुभाषी भाषण ऑडियो पर पूर्व-प्रशिक्षित किया गया था:

• वॉक्सपोपुली : यूरोपीय संसद के 23 यूरोपीय भाषाओं में कुल ~372,000 घंटों का संसदीय भाषण ऑडियो।
• बहुभाषी लाइब्रेरीस्पीच : आठ यूरोपीय भाषाओं में कुल ~50,000 घंटे का भाषण ऑडियो, जिसमें से अधिकांश (~44,000 घंटे) ऑडियो डेटा अंग्रेजी में है।
• कॉमनवॉयस : 60 भाषाओं में कुल ~7,000 घंटों का भाषण ऑडियो।
• वॉक्सलिंगुआ107 : यूट्यूब सामग्री पर आधारित 107 भाषाओं में कुल ~6,600 घंटों का भाषण ऑडियो।
• BABEL : टेलीफोन पर बातचीत के आधार पर 17 अफ्रीकी और एशियाई भाषाओं में कुल ~1,100 घंटों का भाषण ऑडियो।

3 XLS-R मॉडल हैं: XLS-R (0.3B) 300 मिलियन पैरामीटर के साथ, XLS-R (1B) 1 बिलियन पैरामीटर के साथ, और XLS-R (2B) 2 बिलियन पैरामीटर के साथ। यह गाइड XLS-R (0.3B) मॉडल का उपयोग करेगा।

दृष्टिकोण

wav2vev2 मॉडल को कैसे फ़ाइनट्यून किया जाए, इस पर कुछ बेहतरीन लेख हैं, जिनमें से शायद यह एक तरह का "गोल्ड स्टैंडर्ड" हो। बेशक, यहाँ सामान्य दृष्टिकोण वही है जो आपको अन्य गाइड में मिलेगा। आप:

• ऑडियो डेटा और संबंधित पाठ प्रतिलेखन का प्रशिक्षण डेटासेट लोड करें।
• डेटासेट में पाठ प्रतिलेखन से शब्दावली बनाएं।
• एक wav2vec2 प्रोसेसर को प्रारंभ करें जो इनपुट डेटा से फीचर्स निकालेगा, साथ ही पाठ प्रतिलेखन को लेबल के अनुक्रम में परिवर्तित करेगा।
• संसाधित इनपुट डेटा पर wav2vec2 XLS-R को फाइनट्यून करें।

हालाँकि, इस गाइड और अन्य के बीच तीन प्रमुख अंतर हैं:

1. यह गाइड प्रासंगिक एमएल और एएसआर अवधारणाओं पर अधिक "इनलाइन" चर्चा प्रदान नहीं करता है।
   • यद्यपि व्यक्तिगत नोटबुक सेल के प्रत्येक उप-अनुभाग में विशेष सेल के उपयोग/उद्देश्य के बारे में विवरण शामिल होगा, फिर भी यह माना जाता है कि आपके पास पहले से ही एमएल पृष्ठभूमि है और आप बुनियादी एएसआर अवधारणाओं को समझते हैं।
2. आप जो कागल नोटबुक बनाएंगे वह उपयोगिता विधियों को शीर्ष-स्तरीय कक्षों में व्यवस्थित करेगा।
   • जबकि कई फ़ाइनट्यूनिंग नोटबुक में एक तरह का "स्ट्रीम-ऑफ़-कॉन्शियसनेस"-प्रकार का लेआउट होता है, मैंने सभी उपयोगिता विधियों को एक साथ व्यवस्थित करने का चुनाव किया। यदि आप wav2vec2 के लिए नए हैं, तो आपको यह दृष्टिकोण भ्रामक लग सकता है। हालाँकि, दोहराने के लिए, मैं प्रत्येक सेल के समर्पित उप-अनुभाग में प्रत्येक सेल के उद्देश्य को समझाते समय स्पष्ट होने की पूरी कोशिश करता हूँ। यदि आप अभी wav2vec2 के बारे में सीख रहे हैं, तो आपको मेरे HackerNoon लेख wav2vec2 for Automatic Speaking Recognition in Plain English पर एक नज़र डालने से लाभ हो सकता है।
3. यह मार्गदर्शिका केवल फ़ाइनट्यूनिंग के चरणों का वर्णन करती है।
   • जैसा कि परिचय में बताया गया है, मैंने आपके द्वारा जेनरेट किए जाने वाले फ़ाइनट्यून्ड XLS-R मॉडल पर इनफ़रेंस चलाने के तरीके पर एक अलग साथी गाइड बनाने का विकल्प चुना। ऐसा इस गाइड को अत्यधिक लंबा होने से रोकने के लिए किया गया था।

पूर्वापेक्षाएँ और आरंभ करने से पहले

गाइड को पूरा करने के लिए आपके पास ये चीजें होनी चाहिए:

• एक मौजूदा कागल खाता । यदि आपके पास कोई मौजूदा कागल खाता नहीं है, तो आपको एक बनाना होगा।
• एक मौजूदा वजन और पूर्वाग्रह खाता ("WandB") । यदि आपके पास कोई मौजूदा वजन और पूर्वाग्रह खाता नहीं है, तो आपको एक बनाना होगा।
• एक WandB API कुंजी। यदि आपके पास WandB API कुंजी नहीं है, तो यहाँ दिए गए चरणों का पालन करें।
• पायथन का मध्यवर्ती ज्ञान.
• कागल नोटबुक के साथ काम करने का मध्यवर्ती ज्ञान।
• एमएल अवधारणाओं का मध्यवर्ती ज्ञान।
• एएसआर अवधारणाओं का बुनियादी ज्ञान।

इससे पहले कि आप नोटबुक बनाना शुरू करें, नीचे दिए गए दो उप-अनुभागों की समीक्षा करना उपयोगी हो सकता है। वे वर्णन करते हैं:

1. प्रशिक्षण डाटासेट.
2. प्रशिक्षण के दौरान प्रयुक्त शब्द त्रुटि दर ("WER") मीट्रिक.

प्रशिक्षण डेटासेट

जैसा कि परिचय में बताया गया है, XLS-R मॉडल को चिली स्पैनिश पर फाइनट्यून किया जाएगा। विशिष्ट डेटासेट ग्वेरा-रुकोज़ एट अल द्वारा विकसित चिली स्पैनिश स्पीच डेटा सेट है। यह ओपनएसएलआर पर डाउनलोड के लिए उपलब्ध है। डेटासेट में दो उप-डेटासेट शामिल हैं: (1) चिली के पुरुष वक्ताओं की 2,636 ऑडियो रिकॉर्डिंग और (2) चिली की महिला वक्ताओं की 1,738 ऑडियो रिकॉर्डिंग।

प्रत्येक उप-डेटासेट में एक line_index.tsv इंडेक्स फ़ाइल शामिल होती है। प्रत्येक इंडेक्स फ़ाइल की प्रत्येक पंक्ति में एक ऑडियो फ़ाइल नाम और संबंधित फ़ाइल में ऑडियो का एक प्रतिलेखन शामिल होता है, उदाहरण के लिए:

 clm_08421_01719502739 Es un viaje de negocios solamente voy por una noche clm_02436_02011517900 Se usa para incitar a alguien a sacar el mayor provecho del dia presente

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

शब्द त्रुटि दर (WER)

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

• प्रतिस्थापन ( S ): प्रतिस्थापन त्रुटि तब दर्ज की जाती है जब पूर्वानुमान में संदर्भ में समानार्थी शब्द से भिन्न कोई शब्द शामिल होता है। उदाहरण के लिए, यह तब होता है जब पूर्वानुमान संदर्भ में किसी शब्द की गलत वर्तनी करता है।

• विलोपन ( D ): विलोपन त्रुटि तब दर्ज की जाती है जब पूर्वानुमान में कोई ऐसा शब्द शामिल होता है जो संदर्भ में मौजूद नहीं होता है।

• सम्मिलन ( I ): सम्मिलन त्रुटि तब दर्ज की जाती है जब पूर्वानुमान में कोई ऐसा शब्द शामिल नहीं होता है जो संदर्भ में मौजूद हो।

  
  

जाहिर है, WER शब्द-स्तर पर काम करता है। WER मीट्रिक का सूत्र इस प्रकार है:

 WER = (S + D + I)/N where: S = number of substition errors D = number of deletion errors I = number of insertion errors N = number of words in the reference

स्पैनिश में WER का एक सरल उदाहरण इस प्रकार है:

 prediction: "Él está saliendo." reference: "Él está saltando."

एक तालिका भविष्यवाणी में त्रुटियों को दर्शाने में मदद करती है:

पूर्वानुमान में 1 प्रतिस्थापन त्रुटि, 0 विलोपन त्रुटियाँ, और 0 सम्मिलन त्रुटियाँ शामिल हैं। तो, इस उदाहरण के लिए WER है:

 WER = 1 + 0 + 0 / 3 = 1/3 = 0.33

यह स्पष्ट होना चाहिए कि शब्द त्रुटि दर हमें यह नहीं बताती कि कौन सी विशिष्ट त्रुटियाँ मौजूद हैं। ऊपर दिए गए उदाहरण में, WER पहचानता है कि WORD 3 में पूर्वानुमानित पाठ में त्रुटि है, लेकिन यह हमें यह नहीं बताता कि पूर्वानुमान में i और e अक्षर गलत हैं। अन्य मीट्रिक, जैसे कि वर्ण त्रुटि दर ("CER"), का उपयोग अधिक सटीक त्रुटि विश्लेषण के लिए किया जा सकता है।

फाइनट्यूनिंग नोटबुक का निर्माण

अब आप फाइनट्यूनिंग नोटबुक का निर्माण शुरू करने के लिए तैयार हैं।

• चरण 1 और चरण 2 आपको अपना कागल नोटबुक वातावरण स्थापित करने में मार्गदर्शन करते हैं।
• चरण 3 आपको नोटबुक बनाने में मार्गदर्शन करता है। इसमें फाइनट्यूनिंग नोटबुक के 32 सेल का प्रतिनिधित्व करने वाले 32 उप-चरण शामिल हैं।
• चरण 4 आपको नोटबुक चलाने, प्रशिक्षण की निगरानी करने और मॉडल को सहेजने में मार्गदर्शन करता है।

चरण 1 - अपनी WandB API कुंजी प्राप्त करें

आपके Kaggle नोटबुक को आपकी WandB API कुंजी का उपयोग करके WandB को प्रशिक्षण रन डेटा भेजने के लिए कॉन्फ़िगर किया जाना चाहिए। ऐसा करने के लिए, आपको इसे कॉपी करना होगा।

1. WandB पर लॉग इन करें www.wandb.com .
2. www.wandb.ai/authorize पर जाएँ।
3. अगले चरण में उपयोग के लिए अपनी API कुंजी की प्रतिलिपि बनाएँ.

चरण 2 - अपना कागल वातावरण स्थापित करना

चरण 2.1 - एक नई कागल नोटबुक बनाना

1. कागल में लॉग इन करें.
2. एक नया कागल नोटबुक बनाएं.
3. बेशक, नोटबुक का नाम इच्छानुसार बदला जा सकता है। यह गाइड नोटबुक नाम xls-r-300m-chilean-spanish-asr उपयोग करता है।

चरण 2.2 - अपनी WandB API कुंजी सेट करना

आपकी WandB API कुंजी को सुरक्षित रूप से संग्रहीत करने के लिए Kaggle Secret का उपयोग किया जाएगा।

1. कागल नोटबुक मुख्य मेनू पर ऐड-ऑन पर क्लिक करें।
2. पॉप-अप मेनू से सीक्रेट का चयन करें.
3. लेबल फ़ील्ड में लेबल WANDB_API_KEY दर्ज करें और मान के लिए अपनी WandB API कुंजी दर्ज करें।
4. सुनिश्चित करें कि WANDB_API_KEY लेबल फ़ील्ड के बाईं ओर संलग्न चेकबॉक्स चेक किया गया है।
5. संपन्न पर क्लिक करें.

चरण 2.3 - प्रशिक्षण डेटासेट जोड़ना

चिली स्पैनिश भाषण डेटा सेट को कागल पर 2 अलग-अलग डेटासेट के रूप में अपलोड किया गया है:

• चिली के पुरुष वक्ताओं की रिकॉर्डिंग

• चिली की महिला वक्ताओं की रिकॉर्डिंग

  
  

इन दोनों डेटासेट को अपने कागल नोटबुक में जोड़ें।

चरण 3 - फ़ाइनट्यूनिंग नोटबुक का निर्माण

निम्नलिखित 32 उप-चरण फाइनट्यूनिंग नोटबुक के 32 कक्षों में से प्रत्येक को क्रम से निर्मित करते हैं।

चरण 3.1 - सेल 1: पैकेज स्थापित करना

फ़ाइनट्यूनिंग नोटबुक का पहला सेल निर्भरताएँ स्थापित करता है। पहले सेल को इस पर सेट करें:

 ### CELL 1: Install Packages ### !pip install --upgrade torchaudio !pip install jiwer

• पहली पंक्ति torchaudio पैकेज को नवीनतम संस्करण में अपग्रेड करती है। torchaudio उपयोग ऑडियो फ़ाइलों को लोड करने और ऑडियो डेटा को पुनः नमूना करने के लिए किया जाएगा।
• दूसरी पंक्ति jiwer पैकेज को स्थापित करती है जो बाद में उपयोग किए जाने वाले HuggingFace Datasets लाइब्रेरी load_metric विधि का उपयोग करने के लिए आवश्यक है।

चरण 3.2 - सेल 2: पायथन पैकेज आयात करना

दूसरा सेल आवश्यक पायथन पैकेज आयात करता है। दूसरे सेल को इस पर सेट करें:

 ### CELL 2: Import Python packages ### import wandb from kaggle_secrets import UserSecretsClient import math import re import numpy as np import pandas as pd import torch import torchaudio import json from typing import Any, Dict, List, Optional, Union from dataclasses import dataclass from datasets import Dataset, load_metric, load_dataset, Audio from transformers import Wav2Vec2CTCTokenizer from transformers import Wav2Vec2FeatureExtractor from transformers import Wav2Vec2Processor from transformers import Wav2Vec2ForCTC from transformers import TrainingArguments from transformers import Trainer

• आप शायद इनमें से ज़्यादातर पैकेजों से पहले से ही परिचित हैं। नोटबुक में इनका उपयोग बाद की कोशिकाओं के निर्माण के दौरान समझाया जाएगा।
• यह उल्लेखनीय है कि हगिंगफेस transformers लाइब्रेरी और संबंधित Wav2Vec2* क्लासेस, फाइनट्यूनिंग के लिए प्रयुक्त कार्यक्षमता का आधार प्रदान करते हैं।

चरण 3.3 - सेल 3: WER मीट्रिक लोड करना

तीसरा सेल HuggingFace WER मूल्यांकन मीट्रिक आयात करता है। तीसरे सेल को इस पर सेट करें:

 ### CELL 3: Load WER metric ### wer_metric = load_metric("wer")

• जैसा कि पहले बताया गया है, WER का उपयोग मूल्यांकन/होल्डआउट डेटा पर मॉडल के प्रदर्शन को मापने के लिए किया जाएगा।

चरण 3.4 - सेल 4: WandB में लॉग इन करना

चौथा सेल आपके WANDB_API_KEY सीक्रेट को पुनः प्राप्त करता है जिसे चरण 2.2 में सेट किया गया था। चौथे सेल को इस प्रकार सेट करें:

 ### CELL 4: Login to WandB ### user_secrets = UserSecretsClient() wandb_api_key = user_secrets.get_secret("WANDB_API_KEY") wandb.login(key = wandb_api_key)

• API कुंजी का उपयोग कागल नोटबुक को कॉन्फ़िगर करने के लिए किया जाता है ताकि प्रशिक्षण रन डेटा WandB को भेजा जा सके।

चरण 3.5 - सेल 5: स्थिरांक सेट करना

पाँचवाँ सेल स्थिरांक सेट करता है जिसका उपयोग पूरी नोटबुक में किया जाएगा। पाँचवाँ सेल इस प्रकार सेट करें:

 ### CELL 5: Constants ### # Training data TRAINING_DATA_PATH_MALE = "/kaggle/input/google-spanish-speakers-chile-male/" TRAINING_DATA_PATH_FEMALE = "/kaggle/input/google-spanish-speakers-chile-female/" EXT = ".wav" NUM_LOAD_FROM_EACH_SET = 1600 # Vocabulary VOCAB_FILE_PATH = "/kaggle/working/" SPECIAL_CHARS = r"[\d\,\-\;\!\¡\?\¿\।\'\'\"\–\'\:\/\.\“\”\৷\…\‚\॥\\]" # Sampling rates ORIG_SAMPLING_RATE = 48000 TGT_SAMPLING_RATE = 16000 # Training/validation data split SPLIT_PCT = 0.10 # Model parameters MODEL = "facebook/wav2vec2-xls-r-300m" USE_SAFETENSORS = False # Training arguments OUTPUT_DIR_PATH = "/kaggle/working/xls-r-300m-chilean-spanish-asr" TRAIN_BATCH_SIZE = 18 EVAL_BATCH_SIZE = 10 TRAIN_EPOCHS = 30 SAVE_STEPS = 3200 EVAL_STEPS = 100 LOGGING_STEPS = 100 LEARNING_RATE = 1e-4 WARMUP_STEPS = 800

• नोटबुक इस सेल में हर संभव स्थिरांक को प्रदर्शित नहीं करता है। कुछ मान जिन्हें स्थिरांक द्वारा दर्शाया जा सकता है, उन्हें इनलाइन छोड़ दिया गया है।
• ऊपर बताए गए कई स्थिरांकों का उपयोग स्वतः स्पष्ट होना चाहिए। यदि ऐसा नहीं है, तो उनका उपयोग निम्नलिखित उप-चरणों में समझाया जाएगा।

चरण 3.6 - सेल 6: इंडेक्स फ़ाइलों को पढ़ने, पाठ को साफ़ करने और शब्दावली बनाने के लिए उपयोगिता विधियाँ

छठा सेल डेटासेट इंडेक्स फ़ाइलों को पढ़ने के लिए उपयोगिता विधियों को परिभाषित करता है (ऊपर प्रशिक्षण डेटासेट उप-अनुभाग देखें), साथ ही साथ ट्रांसक्रिप्शन टेक्स्ट को साफ़ करने और शब्दावली बनाने के लिए भी। छठे सेल को इस पर सेट करें:

 ### CELL 6: Utility methods for reading index files, cleaning text, and creating vocabulary ### def read_index_file_data(path: str, filename: str): data = [] with open(path + filename, "r", encoding = "utf8") as f: lines = f.readlines() for line in lines: file_and_text = line.split("\t") data.append([path + file_and_text[0] + EXT, file_and_text[1].replace("\n", "")]) return data def truncate_training_dataset(dataset: list) -> list: if type(NUM_LOAD_FROM_EACH_SET) == str and "all" == NUM_LOAD_FROM_EACH_SET.lower(): return else: return dataset[:NUM_LOAD_FROM_EACH_SET] def clean_text(text: str) -> str: cleaned_text = re.sub(SPECIAL_CHARS, "", text) cleaned_text = cleaned_text.lower() return cleaned_text def create_vocab(data): vocab_list = [] for index in range(len(data)): text = data[index][1] words = text.split(" ") for word in words: chars = list(word) for char in chars: if char not in vocab_list: vocab_list.append(char) return vocab_list

• read_index_file_data विधि एक line_index.tsv डेटासेट इंडेक्स फ़ाइल को पढ़ती है और ऑडियो फ़ाइल नाम और ट्रांसक्रिप्शन डेटा के साथ सूचियों की एक सूची तैयार करती है, उदाहरण के लिए:

  
  

 [ ["/kaggle/input/google-spanish-speakers-chile-male/clm_08421_01719502739", "Es un viaje de negocios solamente voy por una noche"] ... ]

• truncate_training_dataset विधि चरण 3.5 में सेट किए गए NUM_LOAD_FROM_EACH_SET स्थिरांक का उपयोग करके सूची अनुक्रमणिका फ़ाइल डेटा को काटती है। विशेष रूप से, NUM_LOAD_FROM_EACH_SET स्थिरांक का उपयोग प्रत्येक डेटासेट से लोड किए जाने वाले ऑडियो नमूनों की संख्या निर्दिष्ट करने के लिए किया जाता है। इस गाइड के प्रयोजनों के लिए, संख्या 1600 पर सेट की गई है जिसका अर्थ है कि अंततः कुल 3200 ऑडियो नमूने लोड किए जाएंगे। सभी नमूनों को लोड करने के लिए, NUM_LOAD_FROM_EACH_SET को स्ट्रिंग मान all पर सेट करें।
• clean_text विधि का उपयोग प्रत्येक टेक्स्ट ट्रांसक्रिप्शन से उन वर्णों को हटाने के लिए किया जाता है जो स्टेप 3.5 में SPECIAL_CHARS को निर्दिष्ट नियमित अभिव्यक्ति द्वारा निर्दिष्ट किए गए हैं। विराम चिह्नों सहित इन वर्णों को हटाया जा सकता है क्योंकि ऑडियो सुविधाओं और टेक्स्ट ट्रांसक्रिप्शन के बीच मैपिंग सीखने के लिए मॉडल को प्रशिक्षित करते समय वे कोई अर्थपूर्ण मूल्य प्रदान नहीं करते हैं।
• create_vocab विधि स्वच्छ पाठ प्रतिलेखन से शब्दावली बनाती है। सरल शब्दों में, यह स्वच्छ पाठ प्रतिलेखन के सेट से सभी अद्वितीय वर्णों को निकालता है। आप चरण 3.14 में उत्पन्न शब्दावली का एक उदाहरण देखेंगे।

चरण 3.7 - सेल 7: ऑडियो डेटा लोड करने और रीसैंपलिंग के लिए उपयोगिता विधियाँ

सातवाँ सेल ऑडियो डेटा को लोड करने और रीसैंपल करने के लिए torchaudio का उपयोग करके उपयोगिता विधियों को परिभाषित करता है। सातवें सेल को इस पर सेट करें:

 ### CELL 7: Utility methods for loading and resampling audio data ### def read_audio_data(file): speech_array, sampling_rate = torchaudio.load(file, normalize = True) return speech_array, sampling_rate def resample(waveform): transform = torchaudio.transforms.Resample(ORIG_SAMPLING_RATE, TGT_SAMPLING_RATE) waveform = transform(waveform) return waveform[0]

• read_audio_data विधि एक निर्दिष्ट ऑडियो फ़ाइल लोड करती है और ऑडियो डेटा का एक torch.Tensor बहु-आयामी मैट्रिक्स लौटाती है, साथ ही ऑडियो की नमूना दर भी। प्रशिक्षण डेटा में सभी ऑडियो फ़ाइलों की नमूना दर 48000 हर्ट्ज है। यह "मूल" नमूना दर चरण 3.5 में स्थिर ORIG_SAMPLING_RATE द्वारा कैप्चर की जाती है।
• resample विधि का उपयोग ऑडियो डेटा को 48000 से 16000 की सैंपलिंग दर से डाउनसैंपल करने के लिए किया जाता है। wav2vec2 को 16000 हर्ट्ज पर सैंपल किए गए ऑडियो पर प्रीट्रेन किया जाता है। तदनुसार, फ़ाइनट्यूनिंग के लिए उपयोग किए जाने वाले किसी भी ऑडियो में समान सैंपलिंग दर होनी चाहिए। इस मामले में, ऑडियो उदाहरणों को 48000 हर्ट्ज से 16000 हर्ट्ज तक डाउनसैंपल किया जाना चाहिए। 16000 हर्ट्ज को चरण 3.5 में स्थिरांक TGT_SAMPLING_RATE द्वारा कैप्चर किया जाता है।

चरण 3.8 - सेल 8: प्रशिक्षण के लिए डेटा तैयार करने की उपयोगिता विधियाँ

आठवां सेल उपयोगिता विधियों को परिभाषित करता है जो ऑडियो और ट्रांसक्रिप्शन डेटा को प्रोसेस करते हैं। आठवें सेल को इस पर सेट करें:

 ### CELL 8: Utility methods to prepare input data for training ### def process_speech_audio(speech_array, sampling_rate): input_values = processor(speech_array, sampling_rate = sampling_rate).input_values return input_values[0] def process_target_text(target_text): with processor.as_target_processor(): encoding = processor(target_text).input_ids return encoding

• process_speech_audio विधि, दिए गए प्रशिक्षण नमूने से इनपुट मान लौटाती है।
• process_target_text विधि प्रत्येक टेक्स्ट ट्रांसक्रिप्शन को लेबल की सूची के रूप में एनकोड करती है - यानी शब्दावली में वर्णों को संदर्भित करने वाली सूचकांकों की सूची। आप चरण 3.15 में एक नमूना एनकोडिंग देखेंगे।

चरण 3.9 - सेल 9: शब्द त्रुटि दर की गणना करने की उपयोगिता विधि

नौवां सेल अंतिम उपयोगिता विधि सेल है और इसमें संदर्भ प्रतिलेखन और पूर्वानुमानित प्रतिलेखन के बीच शब्द त्रुटि दर की गणना करने की विधि शामिल है। नौवें सेल को इस पर सेट करें:

 ### CELL 9: Utility method to calculate Word Error Rate def compute_wer(pred): pred_logits = pred.predictions pred_ids = np.argmax(pred_logits, axis = -1) pred.label_ids[pred.label_ids == -100] = processor.tokenizer.pad_token_id pred_str = processor.batch_decode(pred_ids) label_str = processor.batch_decode(pred.label_ids, group_tokens = False) wer = wer_metric.compute(predictions = pred_str, references = label_str) return {"wer": wer}

चरण 3.10 - सेल 10: प्रशिक्षण डेटा पढ़ना

दसवाँ सेल चरण 3.6 में परिभाषित read_index_file_data विधि का उपयोग करके पुरुष वक्ताओं की रिकॉर्डिंग और महिला वक्ताओं की रिकॉर्डिंग के लिए प्रशिक्षण डेटा इंडेक्स फ़ाइलों को पढ़ता है। दसवें सेल को इस पर सेट करें:

 ### CELL 10: Read training data ### training_samples_male_cl = read_index_file_data(TRAINING_DATA_PATH_MALE, "line_index.tsv") training_samples_female_cl = read_index_file_data(TRAINING_DATA_PATH_FEMALE, "line_index.tsv")

• जैसा कि देखा गया है, इस समय प्रशिक्षण डेटा को दो लिंग-विशिष्ट सूचियों में प्रबंधित किया जाता है। डेटा को चरण 3.12 में छंटनी के बाद संयोजित किया जाएगा।

चरण 3.11 - सेल 11: प्रशिक्षण डेटा को ट्रंकेट करना

ग्यारहवाँ सेल चरण 3.6 में परिभाषित truncate_training_dataset विधि का उपयोग करके प्रशिक्षण डेटा सूचियों को छोटा करता है। ग्यारहवें सेल को इस पर सेट करें:

 ### CELL 11: Truncate training data ### training_samples_male_cl = truncate_training_dataset(training_samples_male_cl) training_samples_female_cl = truncate_training_dataset(training_samples_female_cl)

• याद रखें, चरण 3.5 में सेट किया गया NUM_LOAD_FROM_EACH_SET स्थिरांक प्रत्येक डेटासेट से रखे जाने वाले नमूनों की मात्रा को परिभाषित करता है। इस गाइड में स्थिरांक को कुल 3200 नमूनों के लिए 1600 पर सेट किया गया है।

चरण 3.12 - सेल 12: प्रशिक्षण नमूना डेटा का संयोजन

बारहवाँ सेल काटे गए प्रशिक्षण डेटा सूचियों को जोड़ता है। बारहवें सेल को इस पर सेट करें:

 ### CELL 12: Combine training samples data ### all_training_samples = training_samples_male_cl + training_samples_female_cl

चरण 3.13 - सेल 13: सफाई प्रतिलेखन परीक्षण

तेरहवीं सेल प्रत्येक प्रशिक्षण डेटा नमूने पर पुनरावृत्ति करती है और चरण 3.6 में परिभाषित clean_text विधि का उपयोग करके संबंधित प्रतिलेखन पाठ को साफ़ करती है। तेरहवीं सेल को इस पर सेट करें:

 for index in range(len(all_training_samples)): all_training_samples[index][1] = clean_text(all_training_samples[index][1])

चरण 3.14 - सेल 14: शब्दावली बनाना

चौदहवाँ सेल पिछले चरण से साफ़ किए गए प्रतिलेखन और चरण 3.6 में परिभाषित create_vocab विधि का उपयोग करके शब्दावली बनाता है। चौदहवें सेल को इस पर सेट करें:

 ### CELL 14: Create vocabulary ### vocab_list = create_vocab(all_training_samples) vocab_dict = {v: i for i, v in enumerate(vocab_list)}

• शब्दावली को शब्दकोश के रूप में संग्रहीत किया जाता है, जिसमें अक्षर कुंजी के रूप में तथा शब्दावली सूचकांक मान के रूप में होते हैं।

• आप vocab_dict प्रिंट कर सकते हैं, जिससे निम्नलिखित आउटपुट प्राप्त होगा:

  
  

 {'l': 0, 'a': 1, 'v': 2, 'i': 3, 'g': 4, 'e': 5, 'n': 6, 'c': 7, 'd': 8, 't': 9, 'u': 10, 'r': 11, 'j': 12, 's': 13, 'o': 14, 'h': 15, 'm': 16, 'q': 17, 'b': 18, 'p': 19, 'y': 20, 'f': 21, 'z': 22, 'á': 23, 'ú': 24, 'í': 25, 'ó': 26, 'é': 27, 'ñ': 28, 'x': 29, 'k': 30, 'w': 31, 'ü': 32}

चरण 3.15 - कक्ष 15: शब्दावली में शब्द विभाजक जोड़ना

पंद्रहवाँ सेल शब्दावली में शब्द विभाजक वर्ण | जोड़ता है। पंद्रहवें सेल को इस प्रकार सेट करें:

 ### CELL 15: Add word delimiter to vocabulary ### vocab_dict["|"] = len(vocab_dict)

• शब्द सीमांकक वर्ण का उपयोग टेक्स्ट ट्रांसक्रिप्शन को लेबल की सूची के रूप में टोकनाइज़ करते समय किया जाता है। विशेष रूप से, इसका उपयोग किसी शब्द के अंत को परिभाषित करने के लिए किया जाता है और इसका उपयोग Wav2Vec2CTCTokenizer वर्ग को आरंभ करते समय किया जाता है, जैसा कि चरण 3.17 में देखा जाएगा।

• उदाहरण के लिए, निम्नलिखित सूची चरण 3.14 से शब्दावली का उपयोग करके no te entiendo nada एनकोड करती है:

  
  

 # Encoded text [6, 14, 33, 9, 5, 33, 5, 6, 9, 3, 5, 6, 8, 14, 33, 6, 1, 8, 1] # Vocabulary {'l': 0, 'a': 1, 'v': 2, 'i': 3, 'g': 4, 'e': 5, 'n': 6, 'c': 7, 'd': 8, 't': 9, 'u': 10, 'r': 11, 'j': 12, 's': 13, 'o': 14, 'h': 15, 'm': 16, 'q': 17, 'b': 18, 'p': 19, 'y': 20, 'f': 21, 'z': 22, 'á': 23, 'ú': 24, 'í': 25, 'ó': 26, 'é': 27, 'ñ': 28, 'x': 29, 'k': 30, 'w': 31, 'ü': 32, '|': 33}

• एक सवाल जो स्वाभाविक रूप से उठ सकता है वह है: "शब्द सीमांकक वर्ण को परिभाषित करना क्यों आवश्यक है?" उदाहरण के लिए, लिखित अंग्रेजी और स्पेनिश में शब्दों के अंत को रिक्त स्थान द्वारा चिह्नित किया जाता है, इसलिए रिक्त स्थान वर्ण को शब्द सीमांकक के रूप में उपयोग करना एक सरल मामला होना चाहिए। याद रखें कि अंग्रेजी और स्पेनिश हजारों भाषाओं में से केवल दो भाषाएँ हैं; और सभी लिखित भाषाएँ शब्द सीमाओं को चिह्नित करने के लिए रिक्त स्थान का उपयोग नहीं करती हैं।

चरण 3.16 - सेल 16: शब्दावली निर्यात करना

सोलहवाँ सेल शब्दावली को फ़ाइल में डंप करता है। सोलहवें सेल को इस प्रकार सेट करें:

 ### CELL 16: Export vocabulary ### with open(VOCAB_FILE_PATH + "vocab.json", "w", encoding = "utf8") as vocab_file: json.dump(vocab_dict, vocab_file)

• शब्दावली फ़ाइल का उपयोग अगले चरण, चरण 3.17 में, Wav2Vec2CTCTokenizer वर्ग को आरंभ करने के लिए किया जाएगा।

चरण 3.17 - सेल 17: टोकनाइज़र को प्रारंभ करें

सत्रहवाँ सेल Wav2Vec2CTCTokenizer का एक इंस्टेंस आरंभ करता है। सत्रहवें सेल को इस पर सेट करें:

 ### CELL 17: Initialize tokenizer ### tokenizer = Wav2Vec2CTCTokenizer( VOCAB_FILE_PATH + "vocab.json", unk_token = "[UNK]", pad_token = "[PAD]", word_delimiter_token = "|", replace_word_delimiter_char = " " )

• टोकेनाइजर का उपयोग पाठ प्रतिलेखन को एनकोड करने और लेबल की सूची को वापस पाठ में डिकोड करने के लिए किया जाता है।

• ध्यान दें कि tokenizer [UNK] के साथ आरंभ किया जाता है जिसे unk_token को और [PAD] pad_token को सौंपा जाता है, जिसमें पहला टेक्स्ट ट्रांसक्रिप्शन में अज्ञात टोकन को दर्शाने के लिए उपयोग किया जाता है और दूसरा अलग-अलग लंबाई वाले ट्रांसक्रिप्शन के बैच बनाते समय पैड ट्रांसक्रिप्शन के लिए उपयोग किया जाता है। ये दोनों मान टोकनाइज़र द्वारा शब्दावली में जोड़े जाएँगे।

• इस चरण में टोकेनाइजर को आरंभ करने से शब्दावली में दो अतिरिक्त टोकेन भी जुड़ जाएंगे, अर्थात् <s> और /</s> , जिनका उपयोग क्रमशः वाक्यों के आरंभ और अंत को चिह्नित करने के लिए किया जाता है।

• इस चरण में | को word_delimiter_token को स्पष्ट रूप से असाइन किया गया है ताकि यह दर्शाया जा सके कि चरण 3.15 में शब्दावली में वर्ण जोड़ने के अनुसार शब्दों के अंत को सीमांकित करने के लिए पाइप प्रतीक का उपयोग किया जाएगा। | प्रतीक word_delimiter_token के लिए डिफ़ॉल्ट मान है। इसलिए, इसे स्पष्ट रूप से सेट करने की आवश्यकता नहीं थी, लेकिन स्पष्टता के लिए ऐसा किया गया था।

• इसी तरह word_delimiter_token के साथ, replace_word_delimiter_char को एक सिंगल स्पेस स्पष्ट रूप से असाइन किया गया है, जो दर्शाता है कि पाइप सिंबल | का उपयोग टेक्स्ट ट्रांसक्रिप्शन में रिक्त स्थान वर्णों को बदलने के लिए किया जाएगा। रिक्त स्थान replace_word_delimiter_char के लिए डिफ़ॉल्ट मान है। इसलिए, इसे भी स्पष्ट रूप से सेट करने की आवश्यकता नहीं थी, लेकिन स्पष्टता के लिए ऐसा किया गया था।

• आप tokenizer पर get_vocab() विधि को कॉल करके पूर्ण टोकनाइज़र शब्दावली प्रिंट कर सकते हैं।

  
  

 vocab = tokenizer.get_vocab() print(vocab) # Output: {'e': 0, 's': 1, 'u': 2, 'n': 3, 'v': 4, 'i': 5, 'a': 6, 'j': 7, 'd': 8, 'g': 9, 'o': 10, 'c': 11, 'l': 12, 'm': 13, 't': 14, 'y': 15, 'p': 16, 'r': 17, 'h': 18, 'ñ': 19, 'ó': 20, 'b': 21, 'q': 22, 'f': 23, 'ú': 24, 'z': 25, 'é': 26, 'í': 27, 'x': 28, 'á': 29, 'w': 30, 'k': 31, 'ü': 32, '|': 33, '<s>': 34, '</s>': 35, '[UNK]': 36, '[PAD]': 37}

चरण 3.18 - सेल 18: फ़ीचर एक्सट्रैक्टर को आरंभ करना

अठारहवाँ सेल Wav2Vec2FeatureExtractor का एक इंस्टेंस आरंभ करता है। अठारहवें सेल को इस पर सेट करें:

 ### CELL 18: Initialize feature extractor ### feature_extractor = Wav2Vec2FeatureExtractor( feature_size = 1, sampling_rate = 16000, padding_value = 0.0, do_normalize = True, return_attention_mask = True )

• फ़ीचर एक्सट्रैक्टर का उपयोग इनपुट डेटा से फ़ीचर निकालने के लिए किया जाता है जो निश्चित रूप से इस उपयोग के मामले में ऑडियो डेटा है। आप चरण 3.20 में प्रत्येक प्रशिक्षण डेटा नमूने के लिए ऑडियो डेटा लोड करेंगे।
• Wav2Vec2FeatureExtractor इनिशियलाइज़र को दिए गए पैरामीटर मान सभी डिफ़ॉल्ट मान हैं, return_attention_mask के अपवाद के साथ जो डिफ़ॉल्ट रूप से False होता है। स्पष्टता के लिए डिफ़ॉल्ट मान दिखाए/पास किए जाते हैं।
• feature_size पैरामीटर इनपुट फ़ीचर (यानी ऑडियो डेटा फ़ीचर) के आयाम आकार को निर्दिष्ट करता है। इस पैरामीटर का डिफ़ॉल्ट मान 1 है।
• sampling_rate फीचर एक्सट्रैक्टर को वह सैंपलिंग दर बताता है जिस पर ऑडियो डेटा को डिजिटल किया जाना चाहिए। जैसा कि चरण 3.7 में चर्चा की गई है, wav2vec2 16000 हर्ट्ज पर सैंपल किए गए ऑडियो पर प्रीट्रेन्ड है और इसलिए 16000 इस पैरामीटर के लिए डिफ़ॉल्ट मान है।
• padding_value पैरामीटर वह मान निर्दिष्ट करता है जिसका उपयोग ऑडियो डेटा को पैड करते समय किया जाता है, जैसा कि अलग-अलग लंबाई के ऑडियो नमूनों को बैच करते समय आवश्यक होता है। डिफ़ॉल्ट मान 0.0 है।
• do_normalize उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि इनपुट डेटा को मानक सामान्य वितरण में परिवर्तित किया जाना चाहिए या नहीं। डिफ़ॉल्ट मान True है। Wav2Vec2FeatureExtractor वर्ग दस्तावेज़ नोट करता है कि "[सामान्यीकरण] कुछ मॉडलों के प्रदर्शन को महत्वपूर्ण रूप से बेहतर बनाने में मदद कर सकता है।"
• return_attention_mask पैरामीटर निर्दिष्ट करता है कि ध्यान मास्क पास किया जाना चाहिए या नहीं। इस उपयोग मामले के लिए मान True पर सेट किया गया है।

चरण 3.19 - सेल 19: प्रोसेसर को प्रारंभ करना

उन्नीसवीं सेल Wav2Vec2Processor का एक इंस्टेंस आरंभ करती है। उन्नीसवीं सेल को इस पर सेट करें:

 ### CELL 19: Initialize processor ### processor = Wav2Vec2Processor(feature_extractor = feature_extractor, tokenizer = tokenizer)

• Wav2Vec2Processor वर्ग क्रमशः चरण 3.17 और चरण 3.18 से tokenizer और feature_extractor एकल प्रोसेसर में संयोजित करता है।

• ध्यान दें कि प्रोसेसर कॉन्फ़िगरेशन को Wav2Vec2Processor क्लास इंस्टेंस पर save_pretrained विधि को कॉल करके सहेजा जा सकता है।

  
  

 processor.save_pretrained(OUTPUT_DIR_PATH)

चरण 3.20 - सेल 20: ऑडियो डेटा लोड करना

बीसवाँ सेल all_training_samples सूची में निर्दिष्ट प्रत्येक ऑडियो फ़ाइल को लोड करता है। बीसवाँ सेल इस पर सेट करें:

 ### CELL 20: Load audio data ### all_input_data = [] for index in range(len(all_training_samples)): speech_array, sampling_rate = read_audio_data(all_training_samples[index][0]) all_input_data.append({ "input_values": speech_array, "labels": all_training_samples[index][1] })

• ऑडियो डेटा को torch.Tensor के रूप में लौटाया जाता है और all_input_data में शब्दकोशों की सूची के रूप में संग्रहीत किया जाता है। प्रत्येक शब्दकोश में ऑडियो के टेक्स्ट ट्रांसक्रिप्शन के साथ-साथ किसी विशेष नमूने के लिए ऑडियो डेटा होता है।
• ध्यान दें कि read_audio_data विधि ऑडियो डेटा की सैंपलिंग दर भी लौटाती है। चूँकि हम जानते हैं कि इस उपयोग मामले में सभी ऑडियो फ़ाइलों के लिए सैंपलिंग दर 48000 हर्ट्ज़ है, इसलिए इस चरण में सैंपलिंग दर को अनदेखा किया जाता है।

चरण 3.21 - सेल 21: all_input_data Pandas डेटाफ़्रेम में परिवर्तित करना

इक्कीसवाँ सेल all_input_data सूची को Pandas DataFrame में परिवर्तित करता है, जिससे डेटा में हेरफेर करना आसान हो जाता है। इक्कीसवाँ सेल इस प्रकार सेट करें:

 ### CELL 21: Convert audio training data list to Pandas DataFrame ### all_input_data_df = pd.DataFrame(data = all_input_data)

चरण 3.22 - सेल 22: ऑडियो डेटा और टेक्स्ट ट्रांस्क्रिप्शन का प्रसंस्करण

बीस-सेकंड सेल प्रत्येक ऑडियो डेटा सैंपल से फीचर निकालने और प्रत्येक टेक्स्ट ट्रांसक्रिप्शन को लेबल की सूची के रूप में एनकोड करने के लिए चरण 3.19 में आरंभ किए गए processor उपयोग करता है। बीस-सेकंड सेल को इस पर सेट करें:

 ### CELL 22: Process audio data and text transcriptions ### all_input_data_df["input_values"] = all_input_data_df["input_values"].apply(lambda x: process_speech_audio(resample(x), 16000)) all_input_data_df["labels"] = all_input_data_df["labels"].apply(lambda x: process_target_text(x))

चरण 3.23 - सेल 23: इनपुट डेटा को प्रशिक्षण और सत्यापन डेटासेट में विभाजित करना

तेईसवाँ सेल , स्टेप 3.5 से SPLIT_PCT स्थिरांक का उपयोग करके all_input_data_df डेटाफ़्रेम को प्रशिक्षण और मूल्यांकन (सत्यापन) डेटासेट में विभाजित करता है। तेईसवें सेल को इस पर सेट करें:

 ### CELL 23: Split input data into training and validation datasets ### split = math.floor((NUM_LOAD_FROM_EACH_SET * 2) * SPLIT_PCT) valid_data_df = all_input_data_df.iloc[-split:] train_data_df = all_input_data_df.iloc[:-split]

• इस गाइड में SPLIT_PCT मान 0.10 है, जिसका अर्थ है कि सभी इनपुट डेटा का 10% मूल्यांकन के लिए रखा जाएगा और 90% डेटा का उपयोग प्रशिक्षण/फाइनट्यूनिंग के लिए किया जाएगा।
• चूंकि कुल 3,200 प्रशिक्षण नमूने हैं, 320 नमूनों का उपयोग मूल्यांकन के लिए किया जाएगा तथा शेष 2,880 नमूनों का उपयोग मॉडल को परिष्कृत करने के लिए किया जाएगा।

चरण 3.24 - सेल 24: प्रशिक्षण और सत्यापन डेटासेट को Dataset ऑब्जेक्ट में परिवर्तित करना

चौबीसवाँ सेल train_data_df और valid_data_df डेटाफ़्रेम को Dataset ऑब्जेक्ट में परिवर्तित करता है। चौबीसवाँ सेल इस प्रकार सेट करें:

 ### CELL 24: Convert training and validation datasets to Dataset objects ### train_data = Dataset.from_pandas(train_data_df) valid_data = Dataset.from_pandas(valid_data_df)

• Dataset ऑब्जेक्ट्स का उपयोग हगिंगफेस Trainer क्लास इंस्टेंस द्वारा किया जाता है, जैसा कि आप चरण 3.30 में देखेंगे।

• इन ऑब्जेक्ट्स में डेटासेट के साथ-साथ स्वयं डेटासेट के बारे में मेटाडेटा भी होता है।

• आप दोनों Dataset ऑब्जेक्ट्स के मेटाडेटा को देखने के लिए train_data और valid_data प्रिंट कर सकते हैं।

  
  

 print(train_data) print(valid_data) # Output: Dataset({ features: ['input_values', 'labels'], num_rows: 2880 }) Dataset({ features: ['input_values', 'labels'], num_rows: 320 })

चरण 3.25 - सेल 25: प्रीट्रेन्ड मॉडल को आरंभ करना

पच्चीसवाँ सेल प्रीट्रेन्ड XLS-R (0.3) मॉडल को आरंभ करता है। पच्चीसवाँ सेल इस पर सेट करें:

 ### CELL 25: Initialize pretrained model ### model = Wav2Vec2ForCTC.from_pretrained( MODEL, ctc_loss_reduction = "mean", pad_token_id = processor.tokenizer.pad_token_id, vocab_size = len(processor.tokenizer) )

• Wav2Vec2ForCTC पर कॉल की गई from_pretrained विधि निर्दिष्ट करती है कि हम निर्दिष्ट मॉडल के लिए पूर्व प्रशिक्षित भार लोड करना चाहते हैं।
• MODEL स्थिरांक को चरण 3.5 में निर्दिष्ट किया गया था और XLS-R (0.3) मॉडल को दर्शाते हुए facebook/wav2vec2-xls-r-300m पर सेट किया गया था।
• ctc_loss_reduction पैरामीटर कनेक्शनिस्ट टेम्पोरल क्लासिफिकेशन ("CTC") लॉस फ़ंक्शन के आउटपुट पर लागू होने वाले रिडक्शन के प्रकार को निर्दिष्ट करता है। CTC लॉस का उपयोग निरंतर इनपुट, इस मामले में ऑडियो डेटा, और एक लक्ष्य अनुक्रम, इस मामले में टेक्स्ट ट्रांसक्रिप्शन के बीच लॉस की गणना करने के लिए किया जाता है। मान को mean पर सेट करके, इनपुट के बैच के लिए आउटपुट लॉस को लक्ष्य लंबाई से विभाजित किया जाएगा। फिर बैच पर माध्य की गणना की जाती है और लॉस मानों पर रिडक्शन लागू किया जाता है।
• pad_token_id बैचिंग के दौरान पैडिंग के लिए उपयोग किए जाने वाले टोकन को निर्दिष्ट करता है। इसे स्टेप 3.17 में टोकेनाइज़र को आरंभ करते समय [PAD] आईडी पर सेट किया जाता है।
• vocab_size पैरामीटर मॉडल के शब्दावली आकार को परिभाषित करता है। यह चरण 3.17 में टोकेनाइज़र के आरंभीकरण के बाद शब्दावली का आकार है और नेटवर्क के आगे के हिस्से के आउटपुट लेयर नोड्स की संख्या को दर्शाता है।

चरण 3.26 - सेल 26: फ़ीचर एक्सट्रैक्टर वज़न को स्थिर करना

छब्बीसवाँ सेल फ़ीचर एक्सट्रैक्टर के प्रीट्रेन्ड वेट को फ़्रीज़ कर देता है। छब्बीसवें सेल को इस पर सेट करें:

 ### CELL 26: Freeze feature extractor ### model.freeze_feature_extractor()

चरण 3.27 - सेल 27: प्रशिक्षण तर्क सेट करना

सत्ताईसवाँ सेल प्रशिक्षण तर्कों को आरंभ करता है जिन्हें Trainer इंस्टेंस में पास किया जाएगा। सत्ताईसवाँ सेल इस प्रकार सेट करें:

 ### CELL 27: Set training arguments ### training_args = TrainingArguments( output_dir = OUTPUT_DIR_PATH, save_safetensors = False, group_by_length = True, per_device_train_batch_size = TRAIN_BATCH_SIZE, per_device_eval_batch_size = EVAL_BATCH_SIZE, num_train_epochs = TRAIN_EPOCHS, gradient_checkpointing = True, evaluation_strategy = "steps", save_strategy = "steps", logging_strategy = "steps", eval_steps = EVAL_STEPS, save_steps = SAVE_STEPS, logging_steps = LOGGING_STEPS, learning_rate = LEARNING_RATE, warmup_steps = WARMUP_STEPS )

• TrainingArguments वर्ग 100 से अधिक पैरामीटर स्वीकार करता है.
• जब save_safetensors पैरामीटर False तो यह निर्दिष्ट करता है कि फाइनट्यून्ड मॉडल को safetensors प्रारूप का उपयोग करने के बजाय pickle फ़ाइल में सहेजा जाना चाहिए।
• जब group_by_length पैरामीटर True तो यह इंगित करता है कि लगभग समान लंबाई के नमूनों को एक साथ समूहीकृत किया जाना चाहिए। इससे पैडिंग कम हो जाती है और प्रशिक्षण दक्षता में सुधार होता है।
• per_device_train_batch_size प्रति प्रशिक्षण मिनी-बैच में नमूनों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट TRAIN_BATCH_SIZE स्थिरांक के माध्यम से 18 पर सेट किया गया है। इसका अर्थ है प्रति युग 160 चरण।
• per_device_eval_batch_size प्रति मूल्यांकन (होल्डआउट) मिनी-बैच के लिए नमूनों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट EVAL_BATCH_SIZE स्थिरांक के माध्यम से 10 पर सेट किया गया है।
• num_train_epochs प्रशिक्षण युगों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट TRAIN_EPOCHS स्थिरांक के माध्यम से 30 पर सेट किया गया है। इसका मतलब है कि प्रशिक्षण के दौरान कुल 4,800 चरण होंगे।
• जब gradient_checkpointing पैरामीटर True तो ग्रेडिएंट गणनाओं को चेकपॉइंट करके मेमोरी बचाने में मदद मिलती है, लेकिन इसके परिणामस्वरूप पिछड़े पास की प्रक्रिया धीमी हो जाती है।
• evaluation_strategy पैरामीटर को जब steps पर सेट किया जाता है तो इसका मतलब है कि मूल्यांकन पैरामीटर eval_steps द्वारा निर्दिष्ट अंतराल पर प्रशिक्षण के दौरान किया जाएगा और लॉग किया जाएगा।
• जब logging_strategy पैरामीटर को steps पर सेट किया जाता है तो इसका मतलब है कि प्रशिक्षण रन के आँकड़े logging_steps पैरामीटर द्वारा निर्दिष्ट अंतराल पर लॉग किए जाएंगे।
• जब save_strategy पैरामीटर को steps पर सेट किया जाता है, तो इसका अर्थ है कि फाइनट्यून्ड मॉडल का चेकपॉइंट, save_steps पैरामीटर द्वारा निर्दिष्ट अंतराल पर सहेजा जाएगा।
• eval_steps होल्डआउट डेटा के मूल्यांकन के बीच चरणों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट EVAL_STEPS स्थिरांक के माध्यम से 100 पर सेट किया गया है।
• save_steps उन चरणों की संख्या निर्धारित करता है जिसके बाद फ़ाइनट्यून्ड मॉडल का चेकपॉइंट सहेजा जाता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट SAVE_STEPS स्थिरांक के माध्यम से 3200 पर सेट किया गया है।
• logging_steps प्रशिक्षण रन सांख्यिकी के लॉग के बीच चरणों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट LOGGING_STEPS स्थिरांक के माध्यम से 100 पर सेट किया गया है।
• learning_rate पैरामीटर प्रारंभिक सीखने की दर निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट LEARNING_RATE स्थिरांक के माध्यम से 1e-4 पर सेट किया गया है।
• warmup_steps पैरामीटर लर्निंग दर को 0 से learning_rate द्वारा निर्धारित मान तक रैखिक रूप से वार्मअप करने के लिए चरणों की संख्या निर्धारित करता है। यह पैरामीटर चरण 3.5 में निर्दिष्ट WARMUP_STEPS स्थिरांक के माध्यम से 800 पर सेट किया गया है।

चरण 3.28 - सेल 28: डेटा कोलेटर लॉजिक को परिभाषित करना

अट्ठाईसवाँ सेल गतिशील रूप से इनपुट और लक्ष्य अनुक्रमों को पैड करने के लिए तर्क को परिभाषित करता है। अट्ठाईसवें सेल को इस पर सेट करें:

 ### CELL 28: Define data collator logic ### @dataclass class DataCollatorCTCWithPadding: processor: Wav2Vec2Processor padding: Union[bool, str] = True max_length: Optional[int] = None max_length_labels: Optional[int] = None pad_to_multiple_of: Optional[int] = None pad_to_multiple_of_labels: Optional[int] = None def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]: input_features = [{"input_values": feature["input_values"]} for feature in features] label_features = [{"input_ids": feature["labels"]} for feature in features] batch = self.processor.pad( input_features, padding = self.padding, max_length = self.max_length, pad_to_multiple_of = self.pad_to_multiple_of, return_tensors = "pt", ) with self.processor.as_target_processor(): labels_batch = self.processor.pad( label_features, padding = self.padding, max_length = self.max_length_labels, pad_to_multiple_of = self.pad_to_multiple_of_labels, return_tensors = "pt", ) labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100) batch["labels"] = labels return batch

• प्रशिक्षण और मूल्यांकन इनपुट-लेबल जोड़े को मिनी-बैच में Trainer इंस्टेंस में पास किया जाता है जिसे चरण 3.30 में क्षण भर में आरंभ किया जाएगा। चूंकि इनपुट अनुक्रम और लेबल अनुक्रम प्रत्येक मिनी-बैच में लंबाई में भिन्न होते हैं, इसलिए कुछ अनुक्रमों को पैड किया जाना चाहिए ताकि वे सभी समान लंबाई के हों।
• DataCollatorCTCWithPadding क्लास गतिशील रूप से मिनी-बैच डेटा को पैड करता है। padding पैरामीटर जब True पर सेट किया जाता है तो यह निर्दिष्ट करता है कि छोटे ऑडियो इनपुट फ़ीचर अनुक्रम और लेबल अनुक्रम की लंबाई मिनी-बैच में सबसे लंबे अनुक्रम के समान होनी चाहिए।
• चरण 3.18 में फ़ीचर एक्सट्रैक्टर को आरंभ करते समय ऑडियो इनपुट फ़ीचर को 0.0 मान के साथ पैड किया जाता है।
• स्टेप 3.17 में टोकेनाइजर को आरंभ करते समय लेबल इनपुट को पहले पैडिंग मान के साथ पैड किया जाता है। इन मानों को -100 से बदल दिया जाता है ताकि WER मीट्रिक की गणना करते समय इन लेबलों को अनदेखा किया जा सके।

चरण 3.29 - सेल 29: डेटा कोलेटर का इंस्टेंस आरंभ करना

उनतीसवाँ सेल पिछले चरण में परिभाषित डेटा कोलेटर के इंस्टेंस को आरंभ करता है। उनतीसवें सेल को इस पर सेट करें:

 ### CELL 29: Initialize instance of data collator ### data_collator = DataCollatorCTCWithPadding(processor = processor, padding = True)

चरण 3.30 - सेल 30: प्रशिक्षक को आरंभ करना

तीसवाँ सेल Trainer क्लास का एक इंस्टेंस आरंभ करता है। तीसवाँ सेल इस पर सेट करें:

 ### CELL 30: Initialize trainer ### trainer = Trainer( model = model, data_collator = data_collator, args = training_args, compute_metrics = compute_wer, train_dataset = train_data, eval_dataset = valid_data, tokenizer = processor.feature_extractor )

• जैसा कि देखा गया है, Trainer वर्ग को इस प्रकार आरंभ किया जाता है:
  • पूर्व प्रशिक्षित model चरण 3.25 में आरंभ किया गया।
  • डेटा कोलेटर को चरण 3.29 में आरंभ किया गया.
  • प्रशिक्षण तर्क चरण 3.27 में आरंभ किये गये.
  • चरण 3.9 में परिभाषित WER मूल्यांकन विधि.
  • चरण 3.24 से train_data Dataset ऑब्जेक्ट.
  • चरण 3.24 से valid_data Dataset ऑब्जेक्ट.
• tokenizer पैरामीटर को processor.feature_extractor को सौंपा गया है और यह data_collator के साथ मिलकर प्रत्येक मिनी-बैच के अधिकतम-लंबाई इनपुट में इनपुट को स्वचालित रूप से पैड करता है।

चरण 3.31 - सेल 31: मॉडल को परिष्कृत करना

तीसवाँ सेल मॉडल को फ़ाइनट्यून करने के लिए Trainer क्लास इंस्टेंस पर train विधि को कॉल करता है। तीसवाँ सेल इस पर सेट करें:

 ### CELL 31: Finetune the model ### trainer.train()

चरण 3.32 - सेल 32: फ़ाइनट्यून्ड मॉडल को सेव करें

तीस-सेकंड सेल आखिरी नोटबुक सेल है। यह Trainer इंस्टेंस पर save_model विधि को कॉल करके फ़ाइनट्यून्ड मॉडल को सहेजता है। तीस-सेकंड सेल को इस पर सेट करें:

 ### CELL 32: Save the finetuned model ### trainer.save_model(OUTPUT_DIR_PATH)

चरण 4 - मॉडल का प्रशिक्षण और संरक्षण

चरण 4.1 - मॉडल का प्रशिक्षण

अब जबकि नोटबुक के सभी सेल बन चुके हैं, तो अब समय है फाइनट्यूनिंग शुरू करने का।

1. Kaggle नोटबुक को NVIDIA GPU P100 एक्सिलरेटर के साथ चलाने के लिए सेट करें।

2. नोटबुक को Kaggle पर सबमिट करें।

3. अपने WandB खाते में लॉग इन करके और संबंधित रन का पता लगाकर प्रशिक्षण रन डेटा की निगरानी करें।

   
   

NVIDIA GPU P100 त्वरक का उपयोग करके 30 युगों से अधिक प्रशिक्षण में ~5 घंटे लगने चाहिए। प्रशिक्षण के अंत में होल्डआउट डेटा पर WER ~0.15 तक गिर जाना चाहिए। यह बिल्कुल अत्याधुनिक परिणाम नहीं है, लेकिन फ़ाइनट्यून्ड मॉडल अभी भी कई अनुप्रयोगों के लिए पर्याप्त रूप से उपयोगी है।

चरण 4.2 - मॉडल को सहेजना

फ़ाइनट्यून्ड मॉडल को चरण 3.5 में निर्दिष्ट स्थिरांक OUTPUT_DIR_PATH द्वारा निर्दिष्ट कागल निर्देशिका में आउटपुट किया जाएगा। मॉडल आउटपुट में निम्नलिखित फ़ाइलें शामिल होनी चाहिए:

 pytorch_model.bin config.json preprocessor_config.json vocab.json training_args.bin

इन फ़ाइलों को स्थानीय रूप से डाउनलोड किया जा सकता है। इसके अतिरिक्त, आप मॉडल फ़ाइलों का उपयोग करके एक नया कागल मॉडल बना सकते हैं। फ़ाइनट्यून्ड मॉडल पर अनुमान चलाने के लिए कागल मॉडल का उपयोग साथी अनुमान गाइड के साथ किया जाएगा।

1. अपने Kaggle खाते में लॉग इन करें। मॉडल > नया मॉडल पर क्लिक करें।
2. मॉडल शीर्षक फ़ील्ड में अपने फ़ाइनट्यून मॉडल के लिए शीर्षक जोड़ें.
3. मॉडल बनाएं पर क्लिक करें.
4. मॉडल विवरण पृष्ठ पर जाएँ पर क्लिक करें।
5. मॉडल विविधताओं के अंतर्गत नया भिन्नता जोड़ें पर क्लिक करें।
6. फ्रेमवर्क चयन मेनू से ट्रांसफॉर्मर्स का चयन करें।
7. नया बदलाव जोड़ें पर क्लिक करें.
8. अपनी फ़ाइनट्यून्ड मॉडल फ़ाइलों को अपलोड डेटा विंडो में खींचें और छोड़ें। वैकल्पिक रूप से, फ़ाइल एक्सप्लोरर विंडो खोलने के लिए ब्राउज़ फ़ाइलें बटन पर क्लिक करें और अपनी फ़ाइनट्यून्ड मॉडल फ़ाइलों का चयन करें।
9. एक बार जब फ़ाइलें Kaggle पर अपलोड हो जाएं, तो Kaggle मॉडल बनाने के लिए Create पर क्लिक करें।

निष्कर्ष

wav2vec2 XLS-R को फ़ाइनट्यून करने के लिए बधाई! याद रखें कि आप अपनी इच्छानुसार अन्य भाषाओं पर मॉडल को फ़ाइनट्यून करने के लिए इन सामान्य चरणों का उपयोग कर सकते हैं। इस गाइड में जेनरेट किए गए फ़ाइनट्यून मॉडल पर अनुमान लगाना काफी सरल है। अनुमान के चरणों को इस गाइड के लिए एक अलग साथी गाइड में रेखांकित किया जाएगा। साथी गाइड को खोजने के लिए कृपया मेरे HackerNoon उपयोगकर्ता नाम पर खोजें।