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

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

पायथन ऑडियो ट्रांसक्रिप्शन कैसे काम करता है: बेसिक वर्कफ़्लो

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

यहाँ वह बुनियादी वर्कफ़्लो दिया गया है जिसका अधिकांश पायथन ऑडियो ट्रांसक्रिप्शन सिस्टम पालन करते हैं:

1. ऑडियो फ़ाइल तैयार या होस्ट करें

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

1. आवश्यकता पड़ने पर ऑडियो फ़ॉर्मेट को नॉर्मलाइज़ करें

ऑडियो फ़ाइलें अक्सर अलग-अलग फ़ॉर्मेट, बिटरेट, सैंपल रेट और चैनल लेआउट में आती हैं। API को भेजने से पहले, यदि आवश्यक हो तो फ़ाइल को नॉर्मलाइज़ करें। एक सामान्य और सुरक्षित फ़ॉर्मेट मोनो, 16 kHz, 16-बिट WAV है, विशेष रूप से तब जब आप विभिन्न रिकॉर्डिंग्स में एक समान ट्रांसक्रिप्शन गुणवत्ता चाहते हैं। यह चरण असमर्थित फ़ॉर्मेट, स्टीरियो चैनल के भ्रम, या शोरगुल वाले कन्वर्जन के कारण होने वाली समस्याओं को कम करने में मदद करता है।

1. फ़ाइल या URL को ट्रांसक्रिप्शन API पर भेजें

ऑडियो तैयार हो जाने के बाद, आपकी पायथन स्क्रिप्ट इसे स्पीच-टू-टेक्स्ट API पर भेजती है। स्थानीय फ़ाइल के लिए, इसका मतलब आमतौर पर ऑडियो बाइट्स को पढ़ना और उन्हें एक POST रिक्वेस्ट में भेजना होता है। होस्ट किए गए ऑडियो के लिए, आप JSON पेलोड में सार्वजनिक या हस्ताक्षरित URL भेजते हैं। दोनों मामलों में, आपकी रिक्वेस्ट में प्रमाणीकरण (ऑथेंटिकेशन) शामिल होना चाहिए, जो आमतौर पर एक पर्यावरण चर (environment variable) में संग्रहीत API कुंजी के माध्यम से होता है।

1. भाषा, डायराइजेशन, टाइमस्टैम्प और फ़ॉर्मेटिंग विकल्प पास करें

अधिकांश ट्रांसक्रिप्शन API आपको यह नियंत्रित करने की अनुमति देते हैं कि आउटपुट कैसे जनरेट किया जाना चाहिए। उदाहरण के लिए, आप en जैसा भाषा कोड पास कर सकते हैं, कई वक्ताओं वाली बातचीत के लिए स्पीकर डायराइजेशन सक्षम कर सकते हैं, शब्द-स्तरीय टाइमस्टैम्प का अनुरोध कर सकते हैं, या स्वचालित भाषा पहचान की अनुमति दे सकते हैं। ये विकल्प महत्वपूर्ण हैं क्योंकि ये प्रभावित करते हैं कि अंतिम ट्रांसक्रिप्ट खोज, कैप्शन, एनालिटिक्स, QA या डाउनस्ट्रीम ऑटोमेशन के लिए कितना उपयोगी होगा।

1. स्ट्रक्चर्ड JSON प्राप्त करें

एक अच्छा स्पीच-टू-टेक्स्ट API केवल सादा टेक्स्ट वापस नहीं करता है। यह आमतौर पर स्ट्रक्चर्ड JSON लौटाता है जिसमें पूरा ट्रांसक्रिप्ट, शब्द-स्तरीय टाइमिंग, पहचानी गई भाषा, विश्वसनीयता स्कोर (कॉन्फिडेंस स्कोर) और डायराइजेशन सक्षम होने पर स्पीकर की जानकारी शामिल होती है। यही संरचना एक ट्रांसक्रिप्ट को एक साधारण टेक्स्ट ब्लॉक से ऐसे डेटा में बदल देती है जिसके साथ आपका एप्लिकेशन काम कर सकता है।

1. ट्रांसक्रिप्ट, वर्ड टाइमस्टैम्प, स्पीकर लेबल और कॉन्फिडेंस मेटाडेटा निकालें

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

1. ट्रांसक्रिप्ट को स्टोर या पोस्ट-प्रोसेस करें

अंत में, ट्रांसक्रिप्ट और मेटाडेटा को अपने डेटाबेस, ऑब्जेक्ट स्टोरेज, CRM, QA प्लेटफ़ॉर्म, BI टूल या सर्च इंडेक्स में स्टोर करें। आप पोस्ट-प्रोसेसिंग चरण भी चला सकते हैं जैसे कि विराम चिह्न सुधार, संपादन (रेडैक्शन), सारांश, कीवर्ड निष्कर्षण, स्पीकर फ़ॉर्मेटिंग, या विषय टैगिंग। यहीं पर ट्रांसक्रिप्शन केवल कच्चे टेक्स्ट से आगे बढ़कर वास्तव में उपयोगी बन जाता है: यह खोजने योग्य कॉल आर्काइव, मीटिंग सारांश, सपोर्ट QA, कैप्शन, अनुपालन समीक्षा या वॉयस एनालिटिक्स को सशक्त बना सकता है।

एक साधारण पायथन ट्रांसक्रिप्शन वर्कफ़्लो आमतौर पर इस तरह दिखता है:

1. ऑडियो तैयार या होस्ट करें

audio_path = "preprocessed_audio.wav"

audio_path = "preprocessed_audio.wav"

audio_path = "preprocessed_audio.wav"

2. ऑडियो को ट्रांसक्रिप्शन API पर भेजें

response = transcribe_audio(audio_path)

response = transcribe_audio(audio_path)

response = transcribe_audio(audio_path)

3. स्ट्रक्चर्ड फ़ील्ड निकालें

transcript = response.get("transcription", "")
words = response.get("words", [])
utterances = response.get("utterances", [])
language = response.get("language", "unknown")

transcript = response.get("transcription", "")
words = response.get("words", [])
utterances = response.get("utterances", [])
language = response.get("language", "unknown")

transcript = response.get("transcription", "")
words = response.get("words", [])
utterances = response.get("utterances", [])
language = response.get("language", "unknown")

4. परिणामों को स्टोर या पोस्ट-प्रोसेस करें

print("Transcript:", transcript)
print("Detected language:", language)
print("Word count:", len(words))
print("Speaker turns:", len(utterances))

print("Transcript:", transcript)
print("Detected language:", language)
print("Word count:", len(words))
print("Speaker turns:", len(utterances))

print("Transcript:", transcript)
print("Detected language:", language)
print("Word count:", len(words))
print("Speaker turns:", len(utterances))

यह वर्कफ़्लो वास्तविक कार्यान्वयन में जाने से पहले आपको एक स्पष्ट वैचारिक समझ प्रदान करता है।

API स्तर पर 'ऑडियो को टेक्स्ट में ट्रांसक्राइब करना' वास्तव में क्या मायने रखता है

पायथन लिखने से पहले, यह समझना मददगार होता है कि जब आप "ट्रांसक्राइब" पर क्लिक करते हैं तो स्पीच-टू-टेक्स्ट API वास्तव में क्या कर रहा होता है। आप किसी ब्लैक बॉक्स में फ़ाइल भेजकर केवल एक पैराग्राफ वापस नहीं पा रहे होते हैं। सर्विस आमतौर पर ऑडियो को एक ध्वनिक मॉडल (ध्वनि से फोनेम्स), एक भाषा मॉडल (संदर्भ में फोनेम्स से संभावित शब्द), और फिर एक पोस्ट-प्रोसेसिंग लेयर के माध्यम से चलाती है जो विराम चिह्नों, बड़े अक्षरों (कैपिटलाइज़ेशन) और कभी-कभी स्पीकर लेबल के साथ चीजों को व्यवस्थित करती है।

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

रॉ ऑडियो से लेकर स्ट्रक्चर्ड ट्रांसक्रिप्ट तक, एक आधुनिक स्पीच-टू-टेक्स्ट API की आंतरिक पाइपलाइन

अपना पायथन वातावरण सेट अप करना

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

अपना वातावरण तैयार करने के लिए इन कमांड्स को चलाएँ:

python -m venv stt-env
# macOS / Linux
source stt-env/bin/activate
# Windows
stt-env\Scripts\activate
pip install requests python-dotenv pydub

python -m venv stt-env
# macOS / Linux
source stt-env/bin/activate
# Windows
stt-env\Scripts\activate
pip install requests python-dotenv pydub

python -m venv stt-env
# macOS / Linux
source stt-env/bin/activate
# Windows
stt-env\Scripts\activate
pip install requests python-dotenv pydub

अपनी API कुंजी को कोड में सीधे लिखने के बजाय `.env` फ़ाइल में रखें। यह बुनियादी सुरक्षा नियम है, और जब आप स्थानीय परीक्षण से प्रोडक्शन में जाते हैं तो यह कुंजी रोटेशन को भी आसान बनाता है। `.env` में `SMALLEST_API_KEY=your_api_key_here` जोड़ें, फिर इसे नीचे दिए गए स्निपेट के साथ लोड करें।

SMALLEST_API_KEY=your_api_key_here
from dotenv import load_dotenv

SMALLEST_API_KEY=your_api_key_here
from dotenv import load_dotenv

SMALLEST_API_KEY=your_api_key_here
from dotenv import load_dotenv

ऑडियो प्रीप्रोसेसिंग: वह चरण जिसे अधिकांश ट्यूटोरियल छोड़ देते हैं

कई ट्रांसक्रिप्शन ट्यूटोरियल एक बिल्कुल साफ़ WAV फ़ाइल से शुरू होते हैं और ऐसा दिखाते हैं जैसे यह सामान्य बात हो। ऐसा नहीं है। फ़ोन रिकॉर्डिंग अक्सर 8 kHz पर आती हैं, जो 16 kHz की उम्मीद करने वाले मॉडल के लिए सही नहीं होती हैं। वीडियो MP4 या MKV के रूप में आते हैं जिनमें ऑडियो एक कंटेनर के अंदर छिपा होता है। ज़ूम एक्सपोर्ट में प्रति स्पीकर अलग-अलग मोनो ट्रैक शामिल हो सकते हैं, जिससे यह बदल जाता है कि आपको मॉडल में ऑडियो कैसे इनपुट करना चाहिए।

pydub बिना किसी परेशानी के अधिकांश जटिल फ़ॉर्मेट कार्यों को संभाल लेता है। यहाँ एक छोटा प्रीप्रोसेसिंग फ़ंक्शन है जो ऑडियो को उस रूप में परिवर्तित करता है जिसे अधिकांश API पसंद करते हैं:

from pydub import AudioSegment

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Convert a file to mono, 16 kHz, 16-bit PCM WAV."""
    audio = AudioSegment.from_file(input_path)
    audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2)
    audio.export(output_path, format="wav")
    return output_path

from pydub import AudioSegment

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Convert a file to mono, 16 kHz, 16-bit PCM WAV."""
    audio = AudioSegment.from_file(input_path)
    audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2)
    audio.export(output_path, format="wav")
    return output_path

from pydub import AudioSegment

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Convert a file to mono, 16 kHz, 16-bit PCM WAV."""
    audio = AudioSegment.from_file(input_path)
    audio = audio.set_channels(1).set_frame_rate(16000).set_sample_width(2)
    audio.export(output_path, format="wav")
    return output_path

व्यावहारिक रूप से, API को कॉल करने से पहले सभी फ़ाइलों को इसके ज़रिए प्रोसेस करें। केवल रीसैंपलिंग ही परिणामों में काफ़ी सुधार कर सकती है, खासकर जब मूल रिकॉर्डिंग टेलीफ़ोन-ग्रेड की हो। जैसा कि Mozilla के Common Voice दस्तावेज़ में उल्लेख किया गया है, 16 kHz मोनो WAV कई ओपन-सोर्स और कमर्शियल स्पीच मॉडल में मानक इनपुट फ़ॉर्मेट है।

ट्रांसक्रिप्शन API को भेजने से पहले ऑडियो को प्रीप्रोसेस करने से सटीकता में काफ़ी सुधार होता है

पायथन में अपना पहला ट्रांसक्रिप्शन API कॉल करना

एक बार जब आपके पास साफ़ ऑडियो फ़ाइल हो जाए, तो API कॉल करना सीधा और आसान है। नीचे दिया गया उदाहरण Smallest.ai के Pulse का उपयोग करता है, जो कम-विलंबता (लो-लेटेंसी), उच्च-सटीकता वाले ट्रांसक्रिप्शन के उद्देश्य से बनाया गया एक स्पीच-टू-टेक्स्ट API है, जिसमें रीयल-टाइम परिदृश्यों के लिए स्ट्रीमिंग समर्थन शामिल है। 

import os
import requests

def transcribe_audio(file_path: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    with open(file_path, "rb") as audio_file:
        audio_data = audio_file.read()
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

import os
import requests

def transcribe_audio(file_path: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    with open(file_path, "rb") as audio_file:
        audio_data = audio_file.read()
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

import os
import requests

def transcribe_audio(file_path: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    with open(file_path, "rb") as audio_file:
        audio_data = audio_file.read()
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

यहाँ दो विवरण दिखने से कहीं अधिक महत्वपूर्ण हैं। raise_for_status HTTP विफलताओं को अपवादों (exceptions) में बदल देता है, जिससे आप केवल एक खाली स्ट्रिंग प्रिंट करके उसे "पूर्ण" मानने के बजाय स्पष्ट रूप से त्रुटियों को संभालते हैं। और word_timestamps=true आपको शब्द-स्तरीय समय प्रदान करता है, जिसकी आपको उस समय आवश्यकता होगी जब आपको वीडियो के साथ टेक्स्ट सिंक करना हो, खोज परिणामों को हाइलाइट करना हो, या किसी भी प्रकार का उपयोगी ऑडियो इंडेक्स बनाना हो। यदि आप एक अधिक समृद्ध पाइपलाइन बना रहे हैं, तो स्पीच-टू-टेक्स्ट डेवलपर गाइड स्ट्रीमिंग और रीयल-टाइम पैटर्न पर अधिक विस्तार से चर्चा करती है। 

होस्ट किए गए ऑडियो URL को ट्रांसक्राइब करना

import os
import requests

def transcribe_audio_url(audio_url: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    audio = requests.get(audio_url, timeout=30)
    audio.raise_for_status()
    audio_data = audio.content
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

import os
import requests

def transcribe_audio_url(audio_url: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    audio = requests.get(audio_url, timeout=30)
    audio.raise_for_status()
    audio_data = audio.content
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

import os
import requests

def transcribe_audio_url(audio_url: str, language: str = "en") -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['SMALLEST_API_KEY']}",
        "Content-Type": "application/octet-stream",
    }
    audio = requests.get(audio_url, timeout=30)
    audio.raise_for_status()
    audio_data = audio.content
    response = requests.post(
        "https://api.smallest.ai/waves/v1/stt/",
        params={"model": "pulse", "language": language, "word_timestamps": "true"},
        headers=headers,
        data=audio_data,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()

API रिस्पॉन्स को संभालना और स्ट्रक्चर्ड डेटा निकालना

एक ट्रांसक्रिप्शन रिस्पॉन्स आमतौर पर एकल ट्रांसक्रिप्ट फ़ील्ड से कहीं अधिक होता है। अच्छे API संरचित डेटा लौटाते हैं: शब्द की टाइमिंग, विश्वसनीयता स्कोर (कॉन्फिडेंस स्कोर), पहचानी गई भाषा और कभी-कभी वक्ता का मेटाडेटा। यहाँ एक विशिष्ट रिस्पॉन्स का प्रारूप और उपयोगी भागों को निकालने का एक सरल तरीका दिया गया है:

def parse_transcript(response: dict) -> None:
    print(f"Transcript: {response.get('transcription', '')}")
    for word in response.get("words", []):
        print(word.get("start"), word.get("end"), word.get("word"), word.get("confidence"))
    print(f"Detected language: {response.get('language', 'unknown')}")

def parse_transcript(response: dict) -> None:
    print(f"Transcript: {response.get('transcription', '')}")
    for word in response.get("words", []):
        print(word.get("start"), word.get("end"), word.get("word"), word.get("confidence"))
    print(f"Detected language: {response.get('language', 'unknown')}")

def parse_transcript(response: dict) -> None:
    print(f"Transcript: {response.get('transcription', '')}")
    for word in response.get("words", []):
        print(word.get("start"), word.get("end"), word.get("word"), word.get("confidence"))
    print(f"Detected language: {response.get('language', 'unknown')}")

language = response.get("language", "unknown")
print(f"Detected language: {language}")

कॉन्फिडेंस स्कोर को एक रूटिंग सिग्नल के रूप में देखें, न कि किसी मामूली जानकारी के रूप में। जब किसी शब्द का स्कोर ~0.7 से नीचे चला जाता है, तो मॉडल आपको यह बता रहा होता है कि वह अनुमान लगा रहा है, अक्सर शोर, किसी अपरिचित संज्ञा, या एक साथ बोलने के कारण। प्रोडक्शन में, अनिश्चितता को डाउनस्ट्रीम सिस्टम में जाने देने के बजाय कम कॉन्फिडेंस वाले हिस्सों के लिए मानव समीक्षा ट्रिगर करना एक अच्छा तरीका है।

https://framerusercontent.com/images/dtDKjP7q5nU1Oh0VCEyezcE20.png%22>" data-framer-link="Link:{"url":"https://framerusercontent.com/images/dtDKjP7q5nU1Oh0VCEyezcE20.png%22>https://framerusercontent.com/images/dtDKjP7q5nU1Oh0VCEyezcE20.png%22>https://framerusercontent.com/images/dtDKjP7q5nU1Oh0VCEyezcE20.png">> dir="ltr">ट्रांसक्रिप्शन API रिस्पॉन्स की शारीरिक रचना (एनाटॉमी): ट्रांसक्रिप्ट, शब्द-स्तरीय टाइमस्टैम्प, और कॉन्फिडेंस स्कोर

स्पीकर डायराइजेशन: यह जानना कि किसने क्या कहा

एकल-वक्ता ऑडियो आसान काम है। मीटिंग्स, पॉडकास्ट और सपोर्ट कॉल्स वे जगहें हैं जहाँ चीजें दिलचस्प हो जाती हैं, क्योंकि केवल "क्या कहा गया था" पर्याप्त नहीं होता, आपको "यह किसने कहा" की भी आवश्यकता होती है। इसे ही डायराइजेशन कहते हैं, और आप आमतौर पर इसे अपने रिक्वेस्ट पैरामीटर्स में diarize: True के साथ सक्षम करते हैं।

जब डायराइजेशन सक्षम होता है, तो Pulse शब्द-स्तरीय और कथन-स्तरीय आउटपुट में स्पीकर लेबल जोड़ता है, ताकि आप ट्रांसक्रिप्ट को एक बातचीत के रूप में फिर से तैयार कर सकें।

def format_diarized_transcript(response: dict) -> str:
    lines = []
    for utterance in response.get("utterances", []):
        text = utterance.get("text", "").strip()
        if text:
            lines.append(f"[{utterance.get('start', 0):.1f}s] {utterance.get('speaker', 'unknown')}: {text}")
    return "\n".join(lines)

def format_diarized_transcript(response: dict) -> str:
    lines = []
    for utterance in response.get("utterances", []):
        text = utterance.get("text", "").strip()
        if text:
            lines.append(f"[{utterance.get('start', 0):.1f}s] {utterance.get('speaker', 'unknown')}: {text}")
    return "\n".join(lines)

def format_diarized_transcript(response: dict) -> str:
    lines = []
    for utterance in response.get("utterances", []):
        text = utterance.get("text", "").strip()
        if text:
            lines.append(f"[{utterance.get('start', 0):.1f}s] {utterance.get('speaker', 'unknown')}: {text}")
    return "\n".join(lines)

return "\n".join(lines)

एक पेंच यह है: जब लोग एक-दूसरे के ऊपर बोलते हैं तो डायराइजेशन की गुणवत्ता प्रभावित होती है। कॉल-सेंटर ऑडियो में, बीच में टोकना आम बात है, और सबसे साफ़ समाधान अक्सर अपस्ट्रीम होता है (जब आपके पास हों तो अलग चैनल रखें, फिर ट्रांसक्राइब करें) बजाय इसके कि मॉडल से ओवरलैपिंग बातचीत को पूरी तरह से सुलझाने की उम्मीद की जाए। स्पीकर डायराइजेशन पाइपलाइन्स गाइड बहु-वक्ता रणनीतियों पर अधिक गहराई से जानकारी देती है।

लंबी ऑडियो फ़ाइलों को संभालना और चंकिंग रणनीतियाँ

ट्रांसक्रिप्शन API आमतौर पर फ़ाइल आकार या अवधि पर सीमाएं लगाते हैं। भले ही आपके API में ऐसी सीमा न हो, एक ही रिक्वेस्ट के माध्यम से 90 मिनट की रिकॉर्डिंग भेजना जोखिम भरा होता है: एक टाइमआउट और आप वापस शून्य पर आ जाते हैं। लंबी ऑडियो फ़ाइलों को छोटे टुकड़ों (चंक) में विभाजित करना पाइपलाइन को लचीला बनाए रखने का मानक तरीका है।

लंबी ऑडियो फ़ाइलों के लिए एक मज़बूत चंकिंग रणनीति:

• pydub की make_chunks विधि का उपयोग करके ऑडियो को 30-60 सेकंड के सेगमेंट में विभाजित करें

• किनारों पर शब्दों को कटने से बचाने के लिए चंक्स के बीच 1-2 सेकंड का ओवरलैप जोड़ें

• प्रत्येक चंक को स्वतंत्र रूप से ट्रांसक्राइब करें और परिणामों को क्रमवार एकत्रित करें

• एक साधारण स्ट्रिंग अलाइनमेंट जांच का उपयोग करके ओवरलैप क्षेत्र में डुप्लिकेट शब्दों को हटाकर ट्रांसक्रिप्ट्स को मर्ज करें

• मूल फ़ाइल में प्रत्येक चंक की शुरुआत स्थिति से उसके शब्द टाइमस्टैम्प को ऑफ़सेट करके वैश्विक टाइमस्टैम्प सुरक्षित रखें

from pathlib import Path
from pydub import AudioSegment

def split_audio_with_overlap(input_path: str, output_dir: str, chunk_length_ms: int = 60_000, overlap_ms: int = 2_000) -> list[str]:
    if not 0 <= overlap_ms < chunk_length_ms:
        raise ValueError("Overlap must be smaller than the chunk length")
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    audio = AudioSegment.from_file(input_path)
    paths = []
    start = 0
    while start < len(audio):
        end = min(start + chunk_length_ms, len(audio))
        path = str(Path(output_dir) / f"chunk_{len(paths):04d}.wav")
        audio[start:end].export(path, format="wav")
        paths.append(path)
        if end == len(audio):
            break
        start = end - overlap_ms
    return paths

from pathlib import Path
from pydub import AudioSegment

def split_audio_with_overlap(input_path: str, output_dir: str, chunk_length_ms: int = 60_000, overlap_ms: int = 2_000) -> list[str]:
    if not 0 <= overlap_ms < chunk_length_ms:
        raise ValueError("Overlap must be smaller than the chunk length")
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    audio = AudioSegment.from_file(input_path)
    paths = []
    start = 0
    while start < len(audio):
        end = min(start + chunk_length_ms, len(audio))
        path = str(Path(output_dir) / f"chunk_{len(paths):04d}.wav")
        audio[start:end].export(path, format="wav")
        paths.append(path)
        if end == len(audio):
            break
        start = end - overlap_ms
    return paths

from pathlib import Path
from pydub import AudioSegment

def split_audio_with_overlap(input_path: str, output_dir: str, chunk_length_ms: int = 60_000, overlap_ms: int = 2_000) -> list[str]:
    if not 0 <= overlap_ms < chunk_length_ms:
        raise ValueError("Overlap must be smaller than the chunk length")
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    audio = AudioSegment.from_file(input_path)
    paths = []
    start = 0
    while start < len(audio):
        end = min(start + chunk_length_ms, len(audio))
        path = str(Path(output_dir) / f"chunk_{len(paths):04d}.wav")
        audio[start:end].export(path, format="wav")
        paths.append(path)
        if end == len(audio):
            break
        start = end - overlap_ms
    return paths