Whisper ट्रांसक्रिप्शन

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

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

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

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

पैरामीटर	न्यूनतम	अनुशंसित
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 का उपयोग करना

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 "[email protected]" \
  -F "model=Systran/faster-whisper-large-v3" \
  -F "response_format=json"

# टाइमस्टैम्प के साथ
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \
  -F "[email protected]" \
  -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	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 (डिफ़ॉल्ट):

{"text": "Transcribed text here..."}

विस्तृत 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

कमांड:

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

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"Detected language: {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"Language: {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	1घंटे का ऑडियो
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 में आउट ऑफ मेमोरी

• छोटा मॉडल उपयोग करें (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 मार्केटप्लेस वर्तमान दरों के लिए।