# Транскрипция 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) *для текущих тарифов.*