# Whisper ट्रांसक्रिप्शन OpenAI के Whisper का उपयोग करके CLORE.AI GPUs पर ऑडियो और वीडियो फ़ाइलों का प्रतिलेखन करें। {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | ------------- | ---------- | ---------------- | | RAM | 8GB | 16GB+ | | VRAM | 4GB (छोटा) | 10GB+ (large-v3) | | नेटवर्क | 200Mbps | 500Mbps+ | | स्टार्टअप समय | \~1-2 मिनट | - | ## Whisper क्या है? OpenAI Whisper एक स्पीच रिकग्निशन मॉडल है जो कर सकता है: * 99 भाषाओं में ऑडियो का प्रतिलेखन करना * अंग्रेजी में अनुवाद करना * टाइमस्टैम्प बनाना * शोर वाले ऑडियो को संभालना ## मॉडल आकार | मॉडल | VRAM | स्पीड | गुणवत्ता | नोट्स | | ------------------ | ------- | --------------------- | ------------- | ------------------------------------------------ | | tiny | 1GB | \~32x वास्तविक समय | बेसिक | सबसे तेज़, सबसे कम सटीकता | | base | 1GB | \~16x वास्तविक समय | अच्छा | त्वरित कार्यों के लिए अच्छा संतुलन | | small | 2GB | \~6x वास्तविक समय | बेहतर | अधिकांश उपयोग मामलों के लिए अनुशंसित | | medium | 5GB | \~2x वास्तविक समय | बहुत अच्छा | उच्च सटीकता, मध्यम गति | | large-v3 | 10GB | \~1x वास्तविक समय | सर्वोत्तम | उच्चतम सटीकता | | **large-v3-turbo** | **6GB** | **\~8x वास्तविक समय** | **सर्वोत्तम** | **large-v3 की तुलना में 8x तेज़, समान गुणवत्ता** | > **💡 सिफारिश:** उपयोग करें `large-v3-turbo` सर्वोत्तम गति/गुणवत्ता संतुलन के लिए। यह तुलनीय सटीकता प्रदान करता है `large-v3` 8x गति पर और कम VRAM आवश्यकताओं के साथ। ### large-v3-turbo का उपयोग करना ```python import whisper # large-v3-turbo लोड करें (large-v3 की तुलना में 8x तेज़, समान गुणवत्ता) model = whisper.load_model("large-v3-turbo", device="cuda") result = model.transcribe("audio.mp3") print(result["text"]) ``` Faster-Whisper के साथ: ```python from faster_whisper import WhisperModel # faster-whisper के माध्यम से large-v3-turbo model = WhisperModel("deepdml/faster-whisper-large-v3-turbo-ct2", device="cuda", compute_type="float16") segments, info = model.transcribe("audio.mp3") for segment in segments: print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}") ``` *** ## WhisperX: संवर्धित विकल्प के लिए **शब्द-स्तरीय टाइमस्टैम्प**, **स्पीकर डायराइज़ेशन**, और **70x तक तेज़** प्रोसेसिंग के लिए विचार करें [WhisperX](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisperx): ```bash pip install whisperx ``` ```python import whisperx model = whisperx.load_model("large-v3-turbo", device="cuda", compute_type="float16") audio = whisperx.load_audio("audio.mp3") result = model.transcribe(audio, batch_size=16) # शब्द-स्तरीय अलाइनमेंट model_a, metadata = whisperx.load_align_model(language_code=result["language"], device="cuda") result = whisperx.align(result["segments"], model_a, metadata, audio, device="cuda") # result["word_segments"] में शब्द-स्तरीय टाइमस्टैम्प होते हैं ``` ➡️ पूरा देखें [WhisperX गाइड](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisperx) स्पीकर डायराइज़ेशन और उन्नत विशेषताओं के लिए। ## त्वरित तैनाती (अनुशंसित) तत्क्षण तैनाती के लिए पूर्व-निर्मित Faster-Whisper सर्वर का उपयोग करें: **Docker इमेज:** ``` fedirz/faster-whisper-server:latest-cuda ``` **पोर्ट:** ``` 22/tcp 8000/http ``` **किसी कमांड की आवश्यकता नहीं** - सर्वर अपने आप शुरू हो जाता है। ### जांचें कि यह काम कर रहा है डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर** और परीक्षण करें: ```bash curl https://your-http-pub.clorecloud.net/ # अपेक्षित: सर्वर जानकारी JSON प्रतिक्रिया ``` {% hint style="warning" %} यदि आपको HTTP 502 मिलता है, तो 1-2 मिनट प्रतीक्षा करें - सेवा अभी भी शुरू हो रही है। {% endhint %} ### API के माध्यम से प्रतिलेखन करें ```bash # ऑडियो फ़ाइल का प्रतिलेखन curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \ -F "file=@audio.mp3" \ -F "model=Systran/faster-whisper-large-v3" \ -F "response_format=json" # टाइमस्टैम्प के साथ curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \ -F "file=@audio.mp3" \ -F "model=Systran/faster-whisper-large-v3" \ -F "response_format=verbose_json" \ -F "timestamp_granularities[]=word" ``` ## पूर्ण API संदर्भ (Faster-Whisper-Server) ### एंडपॉइंट्स | एंडपॉइंट | विधि | विवरण | | -------------------------- | ---- | ----------------------------------------- | | `/v1/audio/transcriptions` | POST | ऑडियो का प्रतिलेखन (OpenAI-अनुकूल) | | `/v1/audio/translations` | POST | ऑडियो का अंग्रेजी में अनुवाद | | `/v1/models` | GET | सभी उपलब्ध मॉडल सूचीबद्ध करें | | `/v1/models/{model_name}` | GET | विशिष्ट मॉडल जानकारी प्राप्त करें | | `/api/ps` | GET | वर्तमान में लोड किए गए मॉडल सूचीबद्ध करें | | `/api/ps/{model_name}` | GET | जांचें कि विशिष्ट मॉडल लोड है या नहीं | | `/api/pull/{model_name}` | POST | एक मॉडल डाउनलोड और लोड करें | | `/health` | GET | हेल्थ चेक एंडपॉइंट | | `/docs` | GET | Swagger UI दस्तावेज़ीकरण | | `/openapi.json` | GET | OpenAPI विनिर्देश | #### उपलब्ध मॉडल सूचीबद्ध करें ```bash curl https://your-http-pub.clorecloud.net/v1/models ``` प्रतिक्रिया: ```json { "data": [ {"id": "Systran/faster-whisper-large-v3", "object": "model"}, {"id": "Systran/faster-whisper-medium", "object": "model"} ] } ``` #### Swagger दस्तावेज़ीकरण इंटरैक्टिव API परीक्षण के लिए ब्राउज़र में खोलें: ``` https://your-http-pub.clorecloud.net/docs ``` ### प्रतिलेखन विकल्प | पैरामीटर | प्रकार | विवरण | | --------------------------- | ------ | -------------------------------------------------------------------- | | `file` | फ़ाइल | प्रतिलेखन के लिए ऑडियो फ़ाइल | | `model` | String | उपयोग करने के लिए मॉडल (डिफ़ॉल्ट: `Systran/faster-whisper-large-v3`) | | `language` | String | विशेष भाषा लॉक करें (उदा., `en`, `ja`, `ru`) | | `response_format` | String | `json`, `text`, `srt`, `vtt`, `verbose_json` | | `temperature` | Float | सैंपलिंग टेम्परेचर (0.0-1.0) | | `timestamp_granularities[]` | Array | `word` या `segment` टाइमस्टैम्प के लिए | #### प्रतिक्रिया स्वरूप **JSON (डिफ़ॉल्ट):** ```json {"text": "Transcribed text here..."} ``` **विस्तृत JSON:** ```json { "text": "पूर्ण प्रतिलेखन...", "segments": [ {"start": 0.0, "end": 2.5, "text": "पहला खंड"}, {"start": 2.5, "end": 5.0, "text": "दूसरा खंड"} ], "language": "en" } ``` **SRT:** ``` 1 00:00:00,000 --> 00:00:02,500 पहला खंड 2 00:00:02,500 --> 00:00:05,000 दूसरा खंड ``` ## वैकल्पिक: मैनुअल इंस्टॉलेशन यदि आपको अधिक नियंत्रण चाहिए, तो मैनुअल इंस्टॉलेशन के साथ तैनात करें: **Docker इमेज:** ``` pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime ``` **पोर्ट:** ``` 22/tcp ``` **कमांड:** ```bash pip install openai-whisper faster-whisper ``` {% hint style="info" %} मैनुअल इंस्टॉलेशन में 3-5 मिनट लगते हैं। तेज़ स्टार्टअप के लिए ऊपर दिया गया पूर्व-निर्मित इमेज अनुशंसित है। {% endhint %} ## बुनियादी उपयोग (SSH) ```bash ssh -p root@ # ऑडियो फ़ाइल का प्रतिलेखन whisper audio.mp3 --model large-v3 --device cuda # विशिष्ट फ़ॉर्मेट में आउटपुट whisper audio.mp3 --model large-v3 --output_format txt # भाषा निर्दिष्ट करें whisper audio.mp3 --model large-v3 --language Japanese ``` ### टाइमस्टैम्प के साथ प्रतिलेखन ```bash whisper audio.mp3 --model large-v3 --word_timestamps True ``` ## ऑडियो फ़ाइलें अपलोड करें ```bash # एकल फ़ाइल अपलोड करें scp -P interview.mp3 root@:/workspace/ # फ़ोल्डर अपलोड करें scp -P -r ./audio_files/ root@:/workspace/ ``` ## Python API ```python import whisper # मॉडल लोड करें (पहली बार उपयोग पर डाउनलोड होता है) model = whisper.load_model("large-v3", device="cuda") # प्रतिलेखन result = model.transcribe("audio.mp3") # टेक्स्ट प्रिंट करें print(result["text"]) # टाइमस्टैंप के साथ प्रिंट करें for segment in result["segments"]: print(f"[{segment['start']:.2f}s -> {segment['end']:.2f}s] {segment['text']}") ``` ## Faster-Whisper (अनुशंसित) Faster-Whisper 4x तेज़ है और कम VRAM उपयोग करता है: ```bash pip install faster-whisper ``` ```python from faster_whisper import WhisperModel # अनुकूलनों के साथ मॉडल लोड करें model = WhisperModel("large-v3", device="cuda", compute_type="float16") # प्रतिलेखन segments, info = model.transcribe("audio.mp3") print(f"Detected language: {info.language}") for segment in segments: print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}") ``` ## भाषा विकल्प ```python from faster_whisper import WhisperModel model = WhisperModel("large-v3", device="cuda") # भाषा का ऑटो-डिटेक्ट segments, info = model.transcribe("audio.mp3") print(f"Language: {info.language} ({info.language_probability:.0%})") # विशेष भाषा लागू करें segments, _ = model.transcribe("audio.mp3", language="ja") ``` ## अंग्रेजी में अनुवाद ```python from faster_whisper import WhisperModel model = WhisperModel("large-v3", device="cuda") segments, _ = model.transcribe("japanese.mp3", task="translate") for segment in segments: print(segment.text) ``` CLI: ```bash whisper japanese.mp3 --model large-v3 --task translate ``` ## सबटाइटल जनरेशन ### SRT फ़ॉर्मैट ```python from faster_whisper import WhisperModel def format_timestamp(seconds): hours = int(seconds // 3600) minutes = int((seconds % 3600) // 60) secs = int(seconds % 60) millis = int((seconds - int(seconds)) * 1000) return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}" model = WhisperModel("large-v3", device="cuda") segments, _ = model.transcribe("video.mp4") with open("subtitles.srt", "w") as f: for i, segment in enumerate(segments, 1): f.write(f"{i}\n") f.write(f"{format_timestamp(segment.start)} --> {format_timestamp(segment.end)}\n") f.write(f"{segment.text.strip()}\n\n") ``` ### VTT फ़ॉर्मैट ```bash whisper video.mp4 --model large-v3 --output_format vtt ``` ## शब्द-स्तरीय टाइमस्टैम्प ```python from faster_whisper import WhisperModel model = WhisperModel("large-v3", device="cuda") segments, _ = model.transcribe("audio.mp3", word_timestamps=True) for segment in segments: for word in segment.words: print(f"[{word.start:.2f}s] {word.word}") ``` ## स्पीकर डायराइज़ेशन किसने क्या कहा (pyannote आवश्यक): ```bash pip install pyannote.audio ``` ```python from faster_whisper import WhisperModel from pyannote.audio import Pipeline # डायराइज़ेशन diarization = Pipeline.from_pretrained( "pyannote/speaker-diarization-3.1", use_auth_token="YOUR_HF_TOKEN" ) diarization_result = diarization("audio.mp3") # प्रतिलेखन whisper = WhisperModel("large-v3", device="cuda") segments, _ = whisper.transcribe("audio.mp3") # मिलाएँ for segment in segments: # सेगमेंट समय पर स्पीकर खोजें speaker = None for turn, _, spk in diarization_result.itertracks(yield_label=True): if turn.start <= segment.start <= turn.end: speaker = spk break print(f"[{speaker}] {segment.text}") ``` ## REST API सर्वर एक प्रतिलेखन API बनाएं: ```python from fastapi import FastAPI, UploadFile from faster_whisper import WhisperModel import tempfile app = FastAPI() model = WhisperModel("large-v3", device="cuda", compute_type="float16") @app.post("/transcribe") async def transcribe(file: UploadFile): with tempfile.NamedTemporaryFile(delete=False) as tmp: tmp.write(await file.read()) tmp_path = tmp.name segments, info = model.transcribe(tmp_path) return { "language": info.language, "text": " ".join([s.text for s in segments]), "segments": [ {"start": s.start, "end": s.end, "text": s.text} for s in segments ] } # चलाएँ: uvicorn server:app --host 0.0.0.0 --port 8000 ``` ## प्रदर्शन बेंचमार्क | मॉडल | GPU | 1घंटे का ऑडियो | | -------- | -------- | -------------- | | large-v3 | RTX 3090 | \~5 मिनट | | large-v3 | RTX 4090 | \~3 मिनट | | large-v3 | A100 | \~2 मिनट | | medium | RTX 3090 | \~2 मिनट | ## मेमोरी-कुशल प्रोसेसिंग बहुत लंबे ऑडियो के लिए: ```python from faster_whisper import WhisperModel model = WhisperModel("large-v3", device="cuda", compute_type="int8") # चंक्स में प्रोसेस करें segments, _ = model.transcribe( "long_audio.mp3", vad_filter=True, # मौन को छोड़ें vad_parameters=dict(min_silence_duration_ms=500) ) ``` ## परिणाम डाउनलोड करें ```bash # प्रतिलिपियाँ डाउनलोड करें scp -P -r root@:/workspace/transcripts/ ./ # सबटाइटल्स डाउनलोड करें scp -P root@:/workspace/subtitles.srt ./ ``` ## समस्याओं का निवारण {% hint style="danger" %} **CUDA में आउट ऑफ मेमोरी** {% endhint %} * छोटा मॉडल उपयोग करें (large के बजाय medium) * उपयोग करें `compute_type="int8"` faster-whisper के लिए * छोटे ऑडियो सेगमेंट प्रोसेस करें ### http\_pub URL पर HTTP 502 सेवा अभी भी शुरू हो रही है। 1-2 मिनट प्रतीक्षा करें और पुनः प्रयास करें: ```bash curl https://your-http-pub.clorecloud.net/ ``` ### खराब सटीकता * बड़ा मॉडल उपयोग करें * भाषा निर्दिष्ट करें: `--language English` * faster-whisper के लिए beam\_size बढ़ाएँ ### धीमा प्रोसेसिंग * सुनिश्चित करें कि GPU उपयोग हो रहा है: `nvidia-smi` * मूल की बजाय faster-whisper का उपयोग करें * मौन छोड़ने के लिए VAD सक्षम करें ## लागत अनुमान सामान्य CLORE.AI मार्केटप्लेस दरें: | GPU | VRAM | प्राइस/दिन | उपयुक्त के लिए | | -------- | ---- | ---------- | ----------------- | | RTX 3060 | 12GB | $0.15–0.30 | small/medium मॉडल | | RTX 3090 | 24GB | $0.30–1.00 | large-v3 | | RTX 4090 | 24GB | $0.50–2.00 | large-v3, तेज़ | | A100 | 40GB | $1.50–3.00 | बैच प्रोसेसिंग | *मूल्य USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — जांचें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।* --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisper-transcription.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.