> 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-ru/audio-i-golos/whisper-transcription.md).

# Whisper Transcription

Транскрибируйте аудио- и видеофайлы с помощью Whisper от OpenAI на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Требования к серверу

| Параметр      | Минимум          | Рекомендуется     |
| ------------- | ---------------- | ----------------- |
| ОЗУ           | 8 ГБ             | 16 ГБ+            |
| VRAM          | 4 ГБ (маленький) | 10 ГБ+ (large-v3) |
| Сеть          | 200 Мбит/с       | 500 Мбит/с+       |
| Время запуска | \~1–2 минуты     | -                 |

## Что такое Whisper?

OpenAI Whisper — это модель распознавания речи, которая может:

* Транскрибировать аудио на 99 языках
* Переводить на английский
* Генерировать временные метки
* Обрабатывать шумное аудио

## Размеры моделей

| Модель             | VRAM     | Скорость                    | Качество        | Примечания                                               |
| ------------------ | -------- | --------------------------- | --------------- | -------------------------------------------------------- |
| tiny               | 1 ГБ     | \~32x в реальном времени    | Базовый         | Самый быстрый, с наименьшей точностью                    |
| base               | 1 ГБ     | \~16x в реальном времени    | Хорошо          | Хороший баланс для быстрых задач                         |
| small              | 2 ГБ     | \~6x в реальном времени     | Лучше           | Рекомендуется для большинства случаев использования      |
| medium             | 5 ГБ     | \~2x в реальном времени     | Отлично         | Высокая точность, умеренная скорость                     |
| large-v3           | 10 ГБ    | \~1x в реальном времени     | Лучше всего     | Наивысшая точность                                       |
| **large-v3-turbo** | **6 ГБ** | **\~8x в реальном времени** | **Лучше всего** | **В 8 раз быстрее, чем large-v3, сопоставимое качество** |

> **💡 Рекомендация:** Используйте `large-v3-turbo` для наилучшего баланса скорости и качества. Он обеспечивает сопоставимую точность с `large-v3` при скорости в 8 раз выше и меньших требованиях к VRAM.

### Использование large-v3-turbo

```python
import whisper

# Загружаем large-v3-turbo (в 8 раз быстрее, чем large-v3, сопоставимое качество)
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

# large-v3-turbo через faster-whisper
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: улучшенная альтернатива

Для **временных меток на уровне слов**, **диаризации говорящих**, и **до 70 раз быстрее** обработки, рассмотрите [WhisperX](/guides/guides_v2-ru/audio-i-golos/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-ru/audio-i-golos/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` или `segment` для временных меток                                   |

#### Форматы ответа

**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 работает в 4 раза быстрее и использует меньше 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")

Обнаруженный язык: {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")
Язык: {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 <port> -r root@<proxy>:/workspace/transcripts/ ./

# Скачать субтитры
scp -P <port> root@<proxy>:/workspace/subtitles.srt ./
```

## Устранение неполадок

{% hint style="danger" %}
**CUDA out of memory**
{% endhint %}

* Используйте меньшую модель (medium вместо large)
* Используйте `compute_type="int8"` для faster-whisper
* Обрабатывайте более короткие сегменты аудио

### HTTP 502 на URL http\_pub

Сервис всё ещё запускается. Подождите 1–2 минуты и повторите:

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

### Низкая точность

* Используйте более крупную модель
* Укажите язык: `--language English`
* Увеличьте beam\_size для faster-whisper

### Медленная обработка

* Убедитесь, что используется GPU: `nvidia-smi`
* Используйте faster-whisper вместо оригинальной версии
* Включите VAD, чтобы пропускать тишину

## Оценка стоимости

Типичные расценки маркетплейса CLORE.AI:

| GPU      | VRAM  | Цена/день  | Подходит для         |
| -------- | ----- | ---------- | -------------------- |
| RTX 3060 | 12GB  | $0.15–0.30 | моделей small/medium |
| RTX 3090 | 24 ГБ | $0.30–1.00 | large-v3             |
| RTX 4090 | 24 ГБ | $0.50–2.00 | large-v3, быстро     |
| A100     | 40 ГБ | $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-ru/audio-i-golos/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.