# Транскрипция Whisper

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

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

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

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

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

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

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

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

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

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

### Использование 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: улучшенная альтернатива

Для **меток времени на уровне слов**, **диаризации говорящих**, и **до 70x быстрее** обработки, рассмотрите [WhisperX](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/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-ru/audio-i-golos/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`                     | Строка                    | Модель для использования (по умолчанию: `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.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 <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 раза быстрее с меньшим использованием видеопамяти:

```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      | 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 — недостаточно памяти**
{% endhint %}

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

### HTTP 502 на http\_pub URL

Сервис ещё запускается. Подождите 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 | малые/medium модели |
| RTX 3090 | 24 ГБ | $0.30–1.00 | large-v3            |
| RTX 4090 | 24 ГБ | $0.50–2.00 | large-v3, быстрый   |
| A100     | 40GB  | $1.50–3.00 | пакетная обработка  |

*Цены в USD/день. Тарифы зависят от провайдера — проверьте* [*CLORE.AI Marketplace*](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-ru/audio-i-golos/whisper-transcription.md?ask=<question>
```

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.