Whisper प्रतिलेखन

Clore.ai GPUs पर OpenAI Whisper के साथ ऑडियो और वीडियो ट्रांसक्राइब करें

CLORE.AI GPU पर OpenAI के Whisper का उपयोग करके ऑडियो और वीडियो फ़ाइलों का प्रतिलेखन करें।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
RAM	8GB	16GB+
VRAM	4GB (small)	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 का उपयोग

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 के साथ:

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:

pip install whisperx

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 मार्गदर्शिका स्पीकर डायराइज़ेशन और उन्नत सुविधाओं के लिए।

त्वरित परिनियोजन (अनुशंसित)

तुरंत परिनियोजन के लिए पूर्व-निर्मित Faster-Whisper सर्वर का उपयोग करें:

Docker इमेज:

fedirz/faster-whisper-server:latest-cuda

पोर्ट:

22/tcp
8000/http

किसी कमांड की आवश्यकता नहीं - सर्वर स्वतः प्रारंभ हो जाता है.

सत्यापित करें कि यह काम कर रहा है

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर और परीक्षण करें:

curl https://your-http-pub.clorecloud.net/

# अपेक्षित: सर्वर जानकारी JSON प्रतिक्रिया

यदि आपको HTTP 502 मिलता है, तो 1-2 मिनट प्रतीक्षा करें - सेवा अभी भी प्रारंभ हो रही है।

API के माध्यम से प्रतिलेखन करें

# ऑडियो फ़ाइल का प्रतिलेखन करें
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 विशिष्टीकरण

उपलब्ध मॉडल सूचीबद्ध करें

curl https://your-http-pub.clorecloud.net/v1/models

प्रतिक्रिया:

{
  "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	स्ट्रिंग	उपयोग करने वाला मॉडल (डिफ़ॉल्ट: Systran/faster-whisper-large-v3)
language	स्ट्रिंग	विशिष्ट भाषा को बाध्य करें (जैसे, en, ja, ru)
response_format	स्ट्रिंग	json, text, srt, vtt, verbose_json
temperature	फ़्लोट	सैंपलिंग तापमान (0.0-1.0)
timestamp_granularities[]	सरणी	word या सेगमेंट टाइमस्टैम्प के लिए

प्रतिक्रिया प्रारूप

JSON (डिफ़ॉल्ट):

{"text": "प्रतिलिखित पाठ यहाँ..."}

विस्तृत 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.11.0-cuda12.8-cudnn9-runtime

पोर्ट:

22/tcp

कमांड:

pip install openai-whisper faster-whisper

मैन्युअल स्थापना में 3-5 मिनट लगते हैं। तेज़ स्टार्टअप के लिए ऊपर दी गई पूर्व-निर्मित छवि अनुशंसित है।

मूल उपयोग (SSH)

ssh -p <port> root@<proxy>

# ऑडियो फ़ाइल का प्रतिलेखन करें
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

टाइमस्टैम्प के साथ प्रतिलेखन करें

whisper audio.mp3 --model large-v3 --word_timestamps True

ऑडियो फ़ाइलें अपलोड करें

# एकल फ़ाइल अपलोड करें
scp -P <port> interview.mp3 root@<proxy>:/workspace/

# फ़ोल्डर अपलोड करें
scp -P <port> -r ./audio_files/ root@<proxy>:/workspace/

Python API

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 कम VRAM उपयोग के साथ 4x तेज़ है:

pip install faster-whisper

from faster_whisper import WhisperModel

# अनुकूलनों के साथ मॉडल लोड करें
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

# प्रतिलेखन करें
segments, info = model.transcribe("audio.mp3")

print(f"पता चली भाषा: {info.language}")
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

भाषा विकल्प

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")

# भाषा स्वतः पहचानें
segments, info = model.transcribe("audio.mp3")
print(f"भाषा: {info.language} ({info.language_probability:.0%})")

# विशिष्ट भाषा बाध्य करें
segments, _ = model.transcribe("audio.mp3", language="ja")

अंग्रेज़ी में अनुवाद

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:

whisper japanese.mp3 --model large-v3 --task translate

उपशीर्षक निर्माण

SRT प्रारूप

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 प्रारूप

whisper video.mp4 --model large-v3 --output_format vtt

शब्द-स्तरीय टाइमस्टैम्प

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 आवश्यक है):

pip install pyannote.audio

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 बनाएँ:

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	1hr ऑडियो
large-v3	RTX 3090	~5 मिनट
large-v3	RTX 4090	~3 मिनट
large-v3	A100	~2 मिनट
medium	RTX 3090	~2 मिनट

मेमोरी-कुशल प्रसंस्करण

बहुत लंबे ऑडियो के लिए:

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)
)

परिणाम डाउनलोड करें

# ट्रांसक्रिप्ट डाउनलोड करें
scp -P <port> -r root@<proxy>:/workspace/transcripts/ ./

# उपशीर्षक डाउनलोड करें
scp -P <port> root@<proxy>:/workspace/subtitles.srt ./

समस्या निवारण

CUDA out of memory

• छोटा मॉडल उपयोग करें (large के बजाय medium)

• उपयोग करें compute_type="int8" faster-whisper के लिए

• छोटे ऑडियो खंडों को प्रोसेस करें

http_pub URL पर HTTP 502

सेवा अभी भी प्रारंभ हो रही है। 1-2 मिनट प्रतीक्षा करें और पुनः प्रयास करें:

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 मार्केटप्लेस वर्तमान दरों के लिए।