> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisper-transcription.md).

# Whisper प्रतिलेखन

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

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

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

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

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

```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](/guides/guides_v2-hi/audio-and-voice/whisperx.md):

```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 मार्गदर्शिका](/guides/guides_v2-hi/audio-and-voice/whisperx.md) स्पीकर डायराइज़ेशन और उन्नत सुविधाओं के लिए।

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

तुरंत परिनियोजन के लिए पूर्व-निर्मित 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`                     | स्ट्रिंग | उपयोग करने वाला मॉडल (डिफ़ॉल्ट: `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 (डिफ़ॉल्ट):**

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

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

**पोर्ट:**

```
22/tcp
```

**कमांड:**

```bash
pip install openai-whisper faster-whisper
```

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

## मूल उपयोग (SSH)

```bash
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
```

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

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

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

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

# फ़ोल्डर अपलोड करें
scp -P <port> -r ./audio_files/ root@<proxy>:/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 कम VRAM उपयोग के साथ 4x तेज़ है:

```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"पता चली भाषा: {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"भाषा: {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      | 1hr ऑडियो |
| -------- | -------- | --------- |
| 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 <port> -r root@<proxy>:/workspace/transcripts/ ./

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

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

{% hint style="danger" %}
**CUDA out of memory**
{% 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisper-transcription.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.