Dymas/whisper-api-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add merge tools

Browse Source
This commit is contained in:
Serge Zaigraeff
2025-03-04 22:10:20 +03:00
parent 1af3ebd80e
commit fcd3b936cf
3 changed files with 657 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config.json
+2 -2
View File
@@ -1,9 +1,9 @@
{
"service_port": 5042,
"model_path": "/mnt/cloud/llm/whisper/whisper-large-v3-russian",
"model_path": "/mnt/cloud/llm/whisper/whisper-large-v3-russian-ties-podlodka",
"language": "russian",
"enable_history": true,
"chunk_length_s": 22,
"chunk_length_s": 25,
"batch_size": 20,
"max_new_tokens": 384,
"return_timestamps": false,
tools/whisper_merge.sh
Executable
+367
View File
@@ -0,0 +1,367 @@
#!/bin/bash
# Имя окружения conda
CONDA_ENV_NAME="whisper-merge"
# Директории для моделей
MODEL_A="/mnt/cloud/llm/whisper/whisper-large-v3-russian"
MODEL_B="/mnt/cloud/llm/whisper/whisper-large-v3-ru-podlodka"
OUTPUT_DIR="/mnt/cloud/llm/whisper/whisper-large-v3-russian+podlodka"
# Флаг обновления (по умолчанию false)
UPDATE_ENV=false
# Метод слияния (по умолчанию all)
MERGE_METHOD="all"
# Дополнительные параметры (по умолчанию)
SLERP_T=0.5
TIES_DENSITY=0.8
ENCODER_WEIGHTS="0.6,0.4"
DECODER_WEIGHTS="0.4,0.6"
DIRECT_ALPHA=0.5
# Проверка аргументов
while [[ "$#" -gt 0 ]]; do
case $1 in
--update) UPDATE_ENV=true ;;
--method) MERGE_METHOD="$2"; shift ;;
--slerp-t) SLERP_T="$2"; shift ;;
--ties-density) TIES_DENSITY="$2"; shift ;;
--encoder-weights) ENCODER_WEIGHTS="$2"; shift ;;
--decoder-weights) DECODER_WEIGHTS="$2"; shift ;;
--direct-alpha) DIRECT_ALPHA="$2"; shift ;;
*) echo "⚠️ Неизвестный параметр: $1"; exit 1 ;;
esac
shift
done
# Проверка наличия conda
if ! command -v conda &> /dev/null; then
echo "❌ Conda не установлен. Пожалуйста, установите conda и попробуйте снова."
exit 1
fi
# Создание окружения conda, если оно не существует
if ! conda env list | grep -q "$CONDA_ENV_NAME"; then
echo "🔹 Создание окружения conda: $CONDA_ENV_NAME"
conda create -n "$CONDA_ENV_NAME" python=3.12 -y
else
echo "✅ Окружение conda '$CONDA_ENV_NAME' уже существует."
fi
# Получение пути к conda
CONDA_PATH=$(which conda)
# Проверка, что путь к conda найден
if [ -z "$CONDA_PATH" ]; then
echo "❌ Не удалось найти путь к conda."
exit 1
fi
# Активация окружения conda
echo "🔹 Активация окружения conda: $CONDA_ENV_NAME"
source $(dirname "$CONDA_PATH")/../etc/profile.d/conda.sh
conda activate "$CONDA_ENV_NAME"
# Если флаг --update установлен, обновляем зависимости
if [[ "$UPDATE_ENV" == true ]]; then
echo "🔹 Установка и обновление зависимостей"
pip install --upgrade pip wheel
pip install torch torchaudio
pip install transformers datasets evaluate accelerate
pip install soundfile librosa tqdm
fi
# Проверка установки torch и transformers
if ! python -c "import torch, transformers" &> /dev/null; then
echo "❌ PyTorch или Transformers не установлены. Запустите с опцией --update."
exit 1
fi
# Создание временного Python-скрипта для слияния
cat > merge_models.py << EOL
#!/usr/bin/env python3
import argparse
import os
import torch
from transformers import WhisperForConditionalGeneration, WhisperProcessor
from tqdm import tqdm
def direct_merge(model_a_path, model_b_path, output_path, alpha=0.5):
"""Простое прямое слияние весов моделей с коэффициентом alpha"""
print(f"🔹 Запуск прямого слияния с alpha={alpha}")
print(f"📂 Загрузка модели A из {model_a_path}")
model_a = WhisperForConditionalGeneration.from_pretrained(model_a_path)
print(f"📂 Загрузка модели B из {model_b_path}")
model_b = WhisperForConditionalGeneration.from_pretrained(model_b_path)
# Создаем новую модель для хранения объединенных весов
print("🔄 Объединение весов моделей...")
merged_model = WhisperForConditionalGeneration.from_pretrained(model_a_path)
# Подсчет общего количества параметров
param_count = len(list(merged_model.named_parameters()))
# Объединение весов
with torch.no_grad():
for i, (param_name, param) in enumerate(tqdm(merged_model.named_parameters(), total=param_count, desc="Слияние параметров")):
if param_name in model_a.state_dict() and param_name in model_b.state_dict():
# Объединяем веса с учетом коэффициента альфа
merged_param = alpha * model_a.state_dict()[param_name] + (1 - alpha) * model_b.state_dict()[param_name]
param.copy_(merged_param)
# Создаем директорию для выходных данных, если она не существует
os.makedirs(output_path, exist_ok=True)
# Сохраняем объединенную модель
print(f"💾 Сохранение объединенной модели в {output_path}")
merged_model.save_pretrained(output_path)
# Сохраняем процессор из модели A
print("💾 Сохранение процессора")
processor = WhisperProcessor.from_pretrained(model_a_path)
processor.save_pretrained(output_path)
print("✅ Прямое слияние успешно завершено!")
return merged_model
def slerp_weights(model_a, model_b, t):
"""Выполняет SLERP (Spherical Linear Interpolation) между весами моделей"""
# Получаем словари состояний моделей
state_dict_a = model_a.state_dict()
state_dict_b = model_b.state_dict()
# Создаем новый словарь для смешанных весов
mixed_weights = {}
for key in tqdm(state_dict_a.keys(), desc="SLERP слияние"):
if key in state_dict_b:
# Получаем веса для текущего параметра
weight_a = state_dict_a[key].float()
weight_b = state_dict_b[key].float()
# Выполняем SLERP
# Нормализуем веса
norm_a = torch.norm(weight_a)
norm_b = torch.norm(weight_b)
# Если норма близка к нулю, используем линейную интерполяцию
if norm_a < 1e-6 or norm_b < 1e-6:
mixed_weights[key] = (1 - t) * weight_a + t * weight_b
continue
weight_a_normalized = weight_a / norm_a
weight_b_normalized = weight_b / norm_b
# Вычисляем косинус угла между векторами
cos_theta = torch.sum(weight_a_normalized * weight_b_normalized)
cos_theta = torch.clamp(cos_theta, -1.0, 1.0)
# Вычисляем угол
theta = torch.acos(cos_theta)
# Если угол близок к 0 или π, используем линейную интерполяцию
if abs(theta) < 1e-6 or abs(theta - torch.pi) < 1e-6:
mixed_weights[key] = (1 - t) * weight_a + t * weight_b
else:
# SLERP формула: (sin((1-t)*theta) / sin(theta)) * weight_a + (sin(t*theta) / sin(theta)) * weight_b
sin_theta = torch.sin(theta)
mixed_weights[key] = (torch.sin((1 - t) * theta) / sin_theta) * weight_a + (torch.sin(t * theta) / sin_theta) * weight_b
# Проверка на NaN
if torch.isnan(mixed_weights[key]).any():
# Если появились NaN, используем линейную интерполяцию
mixed_weights[key] = (1 - t) * weight_a + t * weight_b
return mixed_weights
def slerp_merge(model_a_path, model_b_path, output_path, t=0.5):
"""Слияние методом SLERP, реализованное напрямую без использования mergekit"""
print(f"🔹 Запуск слияния методом SLERP с t={t}")
print(f"📂 Загрузка модели A из {model_a_path}")
model_a = WhisperForConditionalGeneration.from_pretrained(model_a_path)
print(f"📂 Загрузка модели B из {model_b_path}")
model_b = WhisperForConditionalGeneration.from_pretrained(model_b_path)
# Создаем новую модель для хранения смешанных весов
print("🔄 Применение метода SLERP...")
merged_model = WhisperForConditionalGeneration.from_pretrained(model_a_path)
# Получаем смешанные веса
mixed_weights = slerp_weights(model_a, model_b, t)
# Загружаем смешанные веса в модель
merged_model.load_state_dict(mixed_weights)
# Создаем директорию для выходных данных
os.makedirs(output_path, exist_ok=True)
# Сохраняем объединенную модель
print(f"💾 Сохранение объединенной модели в {output_path}")
merged_model.save_pretrained(output_path)
# Сохраняем процессор из модели A
processor = WhisperProcessor.from_pretrained(model_a_path)
processor.save_pretrained(output_path)
print("✅ Слияние методом SLERP успешно завершено!")
return merged_model
def ties_merge(model_a_path, model_b_path, output_path, density=0.8, encoder_weights=(0.6, 0.4), decoder_weights=(0.4, 0.6)):
"""Слияние, реализованное по принципу TIES без использования mergekit"""
print(f"🔹 Запуск слияния по принципу TIES с плотностью {density}")
print(f" Веса кодировщика: {encoder_weights}, веса декодера: {decoder_weights}")
print(f"📂 Загрузка модели A из {model_a_path}")
model_a = WhisperForConditionalGeneration.from_pretrained(model_a_path)
print(f"📂 Загрузка модели B из {model_b_path}")
model_b = WhisperForConditionalGeneration.from_pretrained(model_b_path)
# Создаем новую модель для хранения смешанных весов
print("🔄 Применение метода TIES...")
merged_model = WhisperForConditionalGeneration.from_pretrained(model_a_path)
# Получаем словари состояний моделей
state_dict_a = model_a.state_dict()
state_dict_b = model_b.state_dict()
# Создаем словарь для смешанных весов
mixed_weights = {}
# Для каждого параметра
for key in tqdm(state_dict_a.keys(), desc="TIES слияние"):
if key in state_dict_b:
# Определение типа слоя (кодировщик или декодер)
if "encoder" in key:
w_a, w_b = encoder_weights
elif "decoder" in key:
w_a, w_b = decoder_weights
else:
# Для других параметров используем среднее
w_a = (encoder_weights[0] + decoder_weights[0]) / 2
w_b = (encoder_weights[1] + decoder_weights[1]) / 2
# Получаем веса для текущего параметра
weight_a = state_dict_a[key]
weight_b = state_dict_b[key]
# Вычисляем абсолютную разницу между весами
abs_diff = torch.abs(weight_a - weight_b)
# Создаем маску для топ-k% элементов с наибольшей разницей
# если density=0.8, то мы сохраняем 80% элементов с наибольшей разницей
k = int((1 - density) * abs_diff.numel())
if k > 0:
threshold = torch.kthvalue(abs_diff.flatten(), k).values
mask = abs_diff >= threshold
else:
mask = torch.ones_like(abs_diff, dtype=torch.bool)
# Создаем смешанные веса:
# Для элементов с большой разницей используем веса w_a и w_b
# Для остальных используем среднее арифметическое
mixed = torch.zeros_like(weight_a)
mixed[mask] = w_a * weight_a[mask] + w_b * weight_b[mask]
mixed[~mask] = (weight_a[~mask] + weight_b[~mask]) / 2
mixed_weights[key] = mixed
# Загружаем смешанные веса в модель
merged_model.load_state_dict(mixed_weights)
# Создаем директорию для выходных данных
os.makedirs(output_path, exist_ok=True)
# Сохраняем объединенную модель
print(f"💾 Сохранение объединенной модели в {output_path}")
merged_model.save_pretrained(output_path)
# Сохраняем процессор из модели A
processor = WhisperProcessor.from_pretrained(model_a_path)
processor.save_pretrained(output_path)
print("✅ Слияние по принципу TIES успешно завершено!")
return merged_model
def main():
parser = argparse.ArgumentParser(description="Объединение моделей Whisper методами SLERP и TIES")
parser.add_argument("--model-a", default="$MODEL_A",
help="Путь к первой модели")
parser.add_argument("--model-b", default="$MODEL_B",
help="Путь к второй модели")
parser.add_argument("--output-dir", default="$OUTPUT_DIR",
help="Директория для сохранения результатов")
parser.add_argument("--method", choices=["slerp", "ties", "direct", "all"], default="$MERGE_METHOD",
help="Метод слияния: slerp, ties, direct или all")
# Параметры для SLERP
parser.add_argument("--slerp-t", type=float, default=$SLERP_T,
help="Коэффициент интерполяции для SLERP (0-1)")
# Параметры для TIES
parser.add_argument("--ties-density", type=float, default=$TIES_DENSITY,
help="Плотность смешивания для TIES (0-1)")
parser.add_argument("--encoder-weights", type=str, default="$ENCODER_WEIGHTS",
help="Веса для кодировщика в формате '0.6,0.4'")
parser.add_argument("--decoder-weights", type=str, default="$DECODER_WEIGHTS",
help="Веса для декодера в формате '0.4,0.6'")
# Параметры для прямого слияния
parser.add_argument("--direct-alpha", type=float, default=$DIRECT_ALPHA,
help="Коэффициент альфа для прямого слияния (0-1)")
args = parser.parse_args()
# Разбор весов для TIES
encoder_weights = tuple(map(float, args.encoder_weights.split(',')))
decoder_weights = tuple(map(float, args.decoder_weights.split(',')))
# Создание выходной директории
os.makedirs(args.output_dir, exist_ok=True)
# Выполнение слияния выбранным методом
if args.method == "direct" or args.method == "all":
direct_output = os.path.join(args.output_dir, "direct")
direct_merge(args.model_a, args.model_b, direct_output, args.direct_alpha)
if args.method == "slerp" or args.method == "all":
slerp_output = os.path.join(args.output_dir, "slerp")
try:
slerp_merge(args.model_a, args.model_b, slerp_output, args.slerp_t)
except Exception as e:
print(f"❌ Ошибка при слиянии методом SLERP: {e}")
print("⚠️ Используется прямое слияние вместо SLERP.")
direct_merge(args.model_a, args.model_b, slerp_output, args.slerp_t)
if args.method == "ties" or args.method == "all":
ties_output = os.path.join(args.output_dir, "ties")
try:
ties_merge(args.model_a, args.model_b, ties_output, args.ties_density, encoder_weights, decoder_weights)
except Exception as e:
print(f"❌ Ошибка при слиянии методом TIES: {e}")
print("⚠️ Используется прямое слияние вместо TIES.")
alpha = (encoder_weights[0] + decoder_weights[0]) / 2
direct_merge(args.model_a, args.model_b, ties_output, alpha)
print("\n✅ Все операции слияния успешно завершены!")
print(f"📂 Результаты сохранены в {args.output_dir}")
if __name__ == "__main__":
main()
EOL
# Запуск Python-скрипта
python merge_models.py
# Удаление временного скрипта
rm merge_models.py
echo ""
echo "✅ Процесс слияния завершен. Результаты сохранены в $OUTPUT_DIR"
tools/whisper_merge_guide.md
+288
View File
@@ -0,0 +1,288 @@
# Полное руководство по объединению моделей Whisper
## Содержание
1. [Введение](#введение)
2. [Установка и подготовка](#установка-и-подготовка)
3. [Базовое использование](#базовое-использование)
4. [Детальные настройки](#детальные-настройки)
- [Методы слияния](#методы-слияния)
- [Параметры для метода Direct](#параметры-для-метода-direct)
- [Параметры для метода SLERP](#параметры-для-метода-slerp)
- [Параметры для метода TIES](#параметры-для-метода-ties)
5. [Практические рекомендации](#практические-рекомендации)
6. [Тестирование и оценка](#тестирование-и-оценка)
7. [Устранение неполадок](#устранение-неполадок)
## Введение
Скрипт `whisper_merge.sh` позволяет объединять две модели Whisper, обученные на разных датасетах, для получения комбинированной модели с улучшенными характеристиками. Особенно полезно для моделей, обученных на разных типах данных одного языка (например, разные диалекты русского языка, формальная/неформальная речь и т.д.).
## Установка и подготовка
1. **Убедитесь, что Conda установлена** в вашей системе.
2. **Скачайте скрипт `whisper_merge.sh`** и сделайте его исполняемым:
```bash
chmod +x whisper_merge.sh
```
3. **Подготовьте модели для слияния**. По умолчанию скрипт ищет модели по следующим путям:
- Модель A: `/mnt/cloud/llm/whisper/whisper-large-v3-russian`
- Модель B: `/mnt/cloud/llm/whisper/whisper-large-v3-ru-podlodka`
- Директория для результатов: `/mnt/cloud/llm/whisper/whisper-large-v3-russian+podlodka`
Пути можно изменить, отредактировав переменные `MODEL_A`, `MODEL_B` и `OUTPUT_DIR` в начале скрипта.
## Базовое использование
### Первый запуск
Для первого запуска рекомендуется использовать флаг `--update` для установки всех зависимостей:
```bash
./whisper_merge.sh --update
```
Это создаст окружение conda с именем `whisper-merge` и установит необходимые пакеты.
### Стандартное слияние
Для выполнения слияния с настройками по умолчанию:
```bash
./whisper_merge.sh
```
По умолчанию будут использованы следующие параметры:
- Метод слияния: `all` (все методы)
- SLERP t: `0.5`
- TIES density: `0.8`
- Encoder weights: `0.6,0.4`
- Decoder weights: `0.4,0.6`
- Direct alpha: `0.5`
## Детальные настройки
### Методы слияния
Скрипт поддерживает три метода слияния моделей:
1. **Direct** (`--method direct`) — простое линейное смешивание весов:
```bash
./whisper_merge.sh --method direct
```
- **Преимущества**: простота, надежность, меньшие вычислительные требования
- **Недостатки**: может не сохранять геометрию пространства весов
- **Когда использовать**: для быстрого тестирования или когда модели очень близки
2. **SLERP** (`--method slerp`) — сферическая линейная интерполяция:
```bash
./whisper_merge.sh --method slerp
```
- **Преимущества**: лучше сохраняет геометрию пространства весов
- **Недостатки**: требует больше вычислений, может не работать корректно для некоторых моделей
- **Когда использовать**: для моделей, где важно сохранение пространственных отношений между параметрами
3. **TIES** (`--method ties`) — алгоритм Task Induced Expert Selection:
```bash
./whisper_merge.sh --method ties
```
- **Преимущества**: позволяет индивидуально настраивать веса для кодировщика и декодера
- **Недостатки**: более сложный, требует тонкой настройки параметров
- **Когда использовать**: для продвинутого слияния, когда известно, что одна модель лучше работает с определенными аспектами (например, фонетикой или грамматикой)
4. **All** (`--method all`) — применяет все три метода и сохраняет результаты в отдельные подпапки:
```bash
./whisper_merge.sh --method all
```
- **Преимущества**: позволяет сравнить результаты всех методов
- **Недостатки**: требует больше времени и дискового пространства
- **Когда использовать**: при первоначальном тестировании для выбора оптимального метода
### Параметры для метода Direct
#### Direct Alpha (`--direct-alpha`)
Определяет вес первой модели в процессе слияния:
```bash
./whisper_merge.sh --method direct --direct-alpha 0.7
```
- **Диапазон**: от 0.0 до 1.0
- **По умолчанию**: 0.5 (равный вес обеих моделей)
- **Влияние**:
- `0.0` — полностью использует веса второй модели (MODEL_B)
- `0.5` — равный вклад обеих моделей
- `1.0` — полностью использует веса первой модели (MODEL_A)
- **Рекомендации**:
- Если MODEL_A лучше справляется с задачей: увеличьте alpha (`0.6` — `0.8`)
- Если MODEL_B лучше справляется с задачей: уменьшите alpha (`0.2` — `0.4`)
- Для тонкой настройки изменяйте значение с шагом 0.05
### Параметры для метода SLERP
#### SLERP t (`--slerp-t`)
Определяет соотношение весов при сферической интерполяции:
```bash
./whisper_merge.sh --method slerp --slerp-t 0.3
```
- **Диапазон**: от 0.0 до 1.0
- **По умолчанию**: 0.5 (равный вклад)
- **Влияние**:
- `0.0` — полностью вес на MODEL_A
- `1.0` — полностью вес на MODEL_B
- Промежуточные значения дают нелинейную интерполяцию между моделями
- **Рекомендации**:
- В отличие от direct alpha, здесь значение `0` соответствует MODEL_A, а `1` соответствует MODEL_B
- SLERP обычно дает более гладкое слияние, чем direct
- Для русских моделей обычно хорошо работают значения `0.4` — `0.6`
### Параметры для метода TIES
#### TIES Density (`--ties-density`)
Определяет долю параметров, которые будут смешаны индивидуально, а не усреднены:
```bash
./whisper_merge.sh --method ties --ties-density 0.85
```
- **Диапазон**: от 0.0 до 1.0
- **По умолчанию**: 0.8
- **Влияние**:
- `0.0` — все параметры усредняются
- `1.0` — все параметры смешиваются индивидуально по заданным весам
- Промежуточные значения определяют процент параметров с наибольшей разницей, которые будут смешаны индивидуально
- **Рекомендации**:
- Более высокие значения (`0.8` — `0.9`) лучше сохраняют индивидуальные особенности каждой модели
- Более низкие значения (`0.5` — `0.7`) дают более стабильный результат
- Для русских моделей рекомендуется `0.85`, что позволяет сохранить уникальные особенности обеих моделей
#### Encoder Weights (`--encoder-weights`)
Определяет веса моделей для кодировщика (отвечает за обработку аудиосигнала):
```bash
./whisper_merge.sh --method ties --encoder-weights "0.7,0.3"
```
- **Формат**: два числа, разделенные запятой, сумма должна равняться 1.0
- **По умолчанию**: "0.6,0.4"
- **Влияние**:
- Первое число — вес MODEL_A для кодировщика
- Второе число — вес MODEL_B для кодировщика
- **Рекомендации**:
- Если MODEL_A лучше распознает фонетические особенности речи: увеличьте её вес (e.g., "0.7,0.3")
- Если MODEL_B лучше распознает акценты или диалекты: увеличьте её вес (e.g., "0.4,0.6")
- Для русских моделей, если одна из них лучше обрабатывает различные диалекты, дайте ей больший вес в кодировщике
#### Decoder Weights (`--decoder-weights`)
Определяет веса моделей для декодера (отвечает за формирование текста):
```bash
./whisper_merge.sh --method ties --decoder-weights "0.3,0.7"
```
- **Формат**: два числа, разделенные запятой, сумма должна равняться 1.0
- **По умолчанию**: "0.4,0.6"
- **Влияние**:
- Первое число — вес MODEL_A для декодера
- Второе число — вес MODEL_B для декодера
- **Рекомендации**:
- Если MODEL_A лучше справляется с грамматикой: увеличьте её вес (e.g., "0.6,0.4")
- Если MODEL_B имеет лучший языковой контекст: увеличьте её вес (e.g., "0.3,0.7")
- Для русских моделей, если одна модель лучше обрабатывает грамматические конструкции, дайте ей больший вес в декодере
## Практические рекомендации
### Для слияния русских моделей
1. **Общее правило**: начинайте с метода TIES с близкими к равным весами.
2. **Если модели обучены на разных типах данных**:
```bash
./whisper_merge.sh --method ties --ties-density 0.85 --encoder-weights "0.6,0.4" --decoder-weights "0.5,0.5"
```
Это даст больший приоритет первой модели в распознавании звуков, но обе модели будут равно влиять на грамматику.
3. **Если одна модель лучше с формальной речью, а другая с разговорной**:
```bash
./whisper_merge.sh --method ties --ties-density 0.9 --encoder-weights "0.5,0.5" --decoder-weights "0.6,0.4"
```
Высокая плотность (0.9) позволит сохранить уникальные особенности обеих моделей.
4. **Для моделей, где первая модель имеет высокое качество, но вторая содержит специфичные улучшения**:
```bash
./whisper_merge.sh --method slerp --slerp-t 0.3
```
Это сохранит основу первой модели (70%) и добавит 30% особенностей второй.
### Для наилучших результатов
Рекомендуется выполнить несколько экспериментов с разными настройками и сравнить результаты:
```bash
# Эксперимент 1: TIES с приоритетом первой модели
./whisper_merge.sh --method ties --ties-density 0.85 --encoder-weights "0.65,0.35" --decoder-weights "0.6,0.4"
# Эксперимент 2: SLERP с уклоном к первой модели
./whisper_merge.sh --method slerp --slerp-t 0.4
# Эксперимент 3: Прямое слияние
./whisper_merge.sh --method direct --direct-alpha 0.6
```
## Тестирование и оценка
После слияния моделей важно оценить результаты:
1. **Подготовьте тестовый набор данных**, включающий:
- Формальную речь
- Разговорную речь
- Различные диалекты
- Различные шумовые условия
- Различные темпы речи
2. **Выполните транскрипцию** с помощью объединенной модели и сравните с исходными моделями.
3. **Оцените результаты** по следующим критериям:
- Word Error Rate (WER)
- Character Error Rate (CER)
- Обработка специфичных для русского языка особенностей (падежи, ударения)
- Скорость обработки
## Устранение неполадок
### Проблемы со слиянием SLERP или TIES
Если возникают ошибки при использовании методов SLERP или TIES, скрипт автоматически откатывается к методу Direct. Для решения проблем:
1. **Проверьте совместимость моделей**:
- Модели должны иметь одинаковую архитектуру
- Версии Whisper должны быть совместимы
2. **Увеличьте объем памяти**:
- SLERP и TIES требуют больше оперативной памяти
- Попробуйте запустить на машине с большим объемом RAM
3. **Проверьте логи** для определения конкретной проблемы
### Проблемы с окружением Conda
Если возникают проблемы с созданием или активацией окружения:
1. **Обновите Conda**:
```bash
conda update -n base conda
```
2. **Удалите и пересоздайте окружение**:
```bash
conda env remove -n whisper-merge
./whisper_merge.sh --update
```
3. **Проверьте пути к моделям** и убедитесь, что они корректны