Transformers documentation

Синтез речи

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.23.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Синтез речи

Синтез речи (TTS) — это задача создания естественного звучания речи из текста, при этом речь может генерироваться на нескольких языках и для нескольких говорящих. В настоящее время в 🤗 Transformers доступно несколько моделей синтеза речи, таких как Dia, CSM, Bark, MMS, VITS и SpeechT5.

Вы можете легко генерировать аудио с помощью конвейера "text-to-audio" (или его псевдонима — "text-to-speech"). Вот пример использования конвейера "text-to-speech" с CSM:

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-audio", model="sesame/csm-1b")
>>> output = pipe("Hello from Sesame.")

Вот фрагмент кода, который можно использовать для прослушивания полученного аудио в ноутбуке:

>>> from IPython.display import Audio
>>> Audio(output["audio"], rate=output["sampling_rate"])

По умолчанию CSM использует случайный голос. Вы можете выполнить клонирование голоса, передав референсный аудиофайл в качестве части словаря шаблона чата:

>>> import soundfile as sf
>>> import torch
>>> from datasets import Audio, load_dataset
>>> from transformers import pipeline

>>> pipe = pipeline("text-to-audio", model="sesame/csm-1b")

>>> ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=24000))
>>> conversation = [
...     {
...         "role": "0",
...         "content": [
...             {"type": "text", "text": "What are you working on?"},
...             {"type": "audio", "path": ds[0]["audio"]["array"]},
...         ],
...     },
...     {"role": "0", "content": [{"type": "text", "text": "How much money can you spend?"}]},
... ]
>>> output = pipe(conversation)

Некоторые модели, например Dia, также могут генерировать невербальные коммуникации, такие как смех, вздохи и плач, или даже добавлять музыку. Ниже приведен пример:

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-speech", model="nari-labs/Dia-1.6B-0626")
>>> text = "[S1] (clears throat) Hello! How are you? [S2] I'm good, thanks! How about you?"
>>> output = pipe(text)

Обратите внимание, что Dia также принимает теги говорящих, такие как [S1] и [S2], для генерации диалога между уникальными голосами.

Для дополнительных примеров того, что могут делать CSM и другие предобученные модели TTS, обратитесь к нашему курсу по аудио.

Если вы хотите выполнить дообучение модели TTS, то в настоящее время в 🤗 Transformers доступны только следующие модели синтеза речи: SpeechT5, FastSpeech2Conformer, Dia и CSM, однако в будущем их список будет расширен. SpeechT5 предобучен на комбинации данных для задач распознавания речи и синтеза речи, что позволяет модели обучаться в едином пространстве скрытых представлений, общих для текста и речи. Это означает, что одну и ту же предобученную модель можно дообучать для различных задач. Кроме того, SpeechT5 поддерживает несколько говорящих с помощью x-vector встраиваний говорящих.

Остальная часть этого руководства показывает, как:

  1. Доведите до совершенства модель SpeechT5, изначально обученную на английской речи, на нидерландском (nl) подмножестве датасета VoxPopuli.
  2. Используйте улучшенную модель для инференса одним из двух способов: через pipeline или напрямую.

Прежде чем начать, убедитесь, что у вас установлены все необходимые библиотеки:

pip install transformers datasets soundfile torchcodec speechbrain accelerate

Установите 🤗Transformers из исходного кода, так как не все функции SpeechT5 ещё включены в официальную версию:

pip install git+https://github.com/huggingface/transformers.git

Для выполнения этого руководства вам понадобится GPU. Если вы работаете в ноутбуке, выполните следующую строку, чтобы проверить наличие GPU:

!nvidia-smi

или, как альтернатива, для GPU AMD:

!rocm-smi

Мы рекомендуем вам войти в свой аккаунт Hugging Face, чтобы загрузить модель и поделиться ею с сообществом. При появлении запроса введите токен для входа:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Загрузите набор данных

VoxPopuli — это крупномасштабный многоязычный корпус речевых данных, собранных из записей мероприятий Европейского парламента за 2009–2020 годы. Он содержит размеченные данные аудио и транскрипций для 15 европейских языков. В этом руководстве используется подмножество на нидерландском языке, но вы можете выбрать любое другое.

Обратите внимание, что VoxPopuli или любой другой автоматический набор данных для распознавания речи (ASR) может не быть оптимальным вариантом для обучения моделей TTS. Характеристики, которые полезны для ASR, например, избыточный фоновый шум, как правило, нежелательны для TTS. Однако найти высококачественные многоязычные наборы данных TTS с несколькими дикторами может быть довольно сложно.

Загрузим данные:

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("qmeeus/voxpopuli", "nl", split="train")
>>> len(dataset)
20968

20968 примеров должно быть достаточно для дообучения. SpeechT5 ожидает, что аудиоданные имеют частоту дискретизации 16 кГц, поэтому убедитесь, что примеры в наборе данных соответствуют этому требованию:

dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))

Предобработка данных

Начнём с определения контрольной точки модели и загрузки соответствующего процессора:

>>> from transformers import SpeechT5Processor

>>> checkpoint = "microsoft/speecht5_tts"
>>> processor = SpeechT5Processor.from_pretrained(checkpoint)

Очистка текста для токенизации SpeechT5

Начните с очистки текстовых данных. Для обработки текста вам понадобится компонент токенизатора в составе процессора:

>>> tokenizer = processor.tokenizer

Примеры в наборе данных содержат функцию text с транскрипцией. Обратите внимание, что токенизатор SpeechT5 не имеет токенов для чисел, поэтому любые числа в тексте будут преобразованы в токены <unk>. Если ваш набор данных содержит числа, рассмотрите возможность их нормализации в текстовую форму.

Поскольку SpeechT5 обучался на английском языке, он может не распознавать некоторые символы в датасете на нидерландском языке. Если оставить их как есть, эти символы будут преобразованы в токены <unk>. Однако в нидерландском языке для обозначения ударения в слогах используются, например, символы вроде à. Чтобы сохранить смысл текста, мы можем заменить этот символ на обычный a.

Чтобы определить неподдерживаемые токены, извлеките все уникальные символы в наборе данных с помощью SpeechT5Tokenizer, который работает с символами как с токенами. Для этого напишите функцию отображения extract_all_chars, которая объединяет транскрипты из всех примеров в одну строку и преобразует её в множество символов. Убедитесь, что в dataset.map() установлены параметры batched=True и batch_size=-1, чтобы все транскрипты были доступны одновременно для функции отображения.

>>> def extract_all_chars(batch):
...     all_text = " ".join(batch["text"])
...     vocab = list(set(all_text))
...     return {"vocab": [vocab], "all_text": [all_text]}


>>> vocabs = dataset.map(
...     extract_all_chars,
...     batched=True,
...     batch_size=-1,
...     keep_in_memory=True,
...     remove_columns=dataset.column_names,
... )

>>> dataset_vocab = set(vocabs["vocab"][0])
>>> tokenizer_vocab = {k for k, _ in tokenizer.get_vocab().items()}

Теперь у вас есть два набора символов: один — с лексиконом из набора данных, а другой — с лексиконом из токенизатора. Чтобы определить неподдерживаемые токенизатором символы в наборе данных, можно вычислить разность этих двух множеств. Полученное множество будет содержать символы, присутствующие в наборе данных, но отсутствующие в лексиконе токенизатора.

>>> dataset_vocab - tokenizer_vocab
{' ', 'à', 'ç', 'è', 'ë', 'í', 'ï', 'ö', 'ü'}

Чтобы обработать неподдерживаемые символы, выявленные на предыдущем шаге, определите функцию, которая сопоставляет эти символы с допустимыми токенами. Обратите внимание, что пробелы уже заменены на ▁ в токенизаторе и не требуют отдельной обработки.

>>> replacements = [
...     ("à", "a"),
...     ("ç", "c"),
...     ("è", "e"),
...     ("ë", "e"),
...     ("í", "i"),
...     ("ï", "i"),
...     ("ö", "o"),
...     ("ü", "u"),
... ]


>>> def cleanup_text(inputs):
...     for src, dst in replacements:
...         inputs["text"] = inputs["text"].replace(src, dst)
...     return inputs


>>> dataset = dataset.map(cleanup_text)

Теперь, когда вы разобрались со специальными символами в тексте, пора переключить внимание на аудиоданные.

Спикеры

Набор данных VoxPopuli содержит речь нескольких говорящих, но сколько именно говорящих представлено в наборе? Чтобы определить это, мы можем подсчитать количество уникальных говорящих и количество примеров, которые каждый из них вносит в набор данных. При общем количестве 20 968 примеров в наборе эта информация позволит лучше понять распределение говорящих и примеров в данных.

>>> from collections import defaultdict

>>> speaker_counts = defaultdict(int)

>>> for speaker_id in dataset["speaker_id"]:
...     speaker_counts[speaker_id] += 1

Построив гистограмму, можно оценить, сколько данных приходится на каждого спикера.

>>> import matplotlib.pyplot as plt

>>> plt.figure()
>>> plt.hist(speaker_counts.values(), bins=20)
>>> plt.ylabel("Speakers")
>>> plt.xlabel("Examples")
>>> plt.show()
Speakers histogram

Гистограмма показывает, что примерно у трети говорящих в наборе данных меньше 100 примеров, а у десятка говорящих — более 500 примеров. Чтобы повысить эффективность обучения и сбалансировать набор данных, мы можем ограничить данные говорящими, у которых от 100 до 400 примеров.

>>> def select_speaker(speaker_id):
...     return 100 <= speaker_counts[speaker_id] <= 400


>>> dataset = dataset.filter(select_speaker, input_columns=["speaker_id"])

Проверим, сколько спикеров осталось:

>>> len(set(dataset["speaker_id"]))
42

Посмотрим, сколько примеров осталось:

>>> len(dataset)
9973

Вам остаётся чуть менее 10 000 примеров от примерно 40 уникальных говорящих, чего должно быть достаточно.

Обратите внимание, что у некоторых говорящих с небольшим количеством примеров может оказаться больше аудио, если сами примеры длинные. Однако для определения общего объёма аудио для каждого говорящего необходимо просканировать весь датасет, что является трудоёмким процессом, требующим загрузки и декодирования каждого аудиофайла. Поэтому мы решили пропустить этот шаг.

Встраивания говорящих

Чтобы модель TTS могла различать нескольких говорящих, необходимо создать speaker embedding для каждого примера. Speaker embedding — это дополнительный вход модели, который фиксирует характеристики голоса конкретного говорящего. Для генерации этих speaker embeddings используйте предобученную модель spkrec-xvect-voxceleb из SpeechBrain.

Создайте функцию create_speaker_embedding(), которая принимает входную аудиоволну и возвращает вектор из 512 элементов, содержащий соответствующее встраивание говорящего.

>>> import os
>>> import torch
>>> from speechbrain.inference.classifiers import EncoderClassifier
>>> from accelerate import Accelerator

>>> spk_model_name = "speechbrain/spkrec-xvect-voxceleb"
>>> device = Accelerator().device
>>> speaker_model = EncoderClassifier.from_hparams(
...     source=spk_model_name,
...     run_opts={"device": device},
...     savedir=os.path.join("/tmp", spk_model_name),
... )


>>> def create_speaker_embedding(waveform):
...     with torch.no_grad():
...         speaker_embeddings = speaker_model.encode_batch(torch.tensor(waveform))
...         speaker_embeddings = torch.nn.functional.normalize(speaker_embeddings, dim=2)
...         speaker_embeddings = speaker_embeddings.squeeze().cpu().numpy()
...     return speaker_embeddings

Важно отметить, что модель speechbrain/spkrec-xvect-voxceleb обучалась на английской речи из набора данных VoxCeleb, тогда как примеры обучения в этом руководстве представлены на нидерландском языке. Мы полагаем, что эта модель всё равно будет генерировать разумные эмбеддинги говорящих для нашего нидерландского набора данных, однако это предположение может не выполняться во всех случаях.

Для получения оптимальных результатов мы рекомендуем сначала обучить модель X-vector на целевой речи. Это позволит модели лучше улавливать уникальные характеристики голоса, характерные для нидерландского языка.

Обработка набора данных

Наконец, давайте преобразуем данные в формат, который ожидает модель. Создайте функцию prepare_dataset, которая принимает один пример и использует объект SpeechT5Processor для токенизации входного текста и загрузки целевого аудио в виде лог-мел-спектрограммы. Также следует добавить эмбеддинги говорящего в качестве дополнительного входа.

>>> def prepare_dataset(example):
...     audio = example["audio"]

...     example = processor(
...         text=example["text"],
...         audio_target=audio["array"],
...         sampling_rate=audio["sampling_rate"],
...         return_attention_mask=False,
...     )

...     # strip off the batch dimension
...     example["labels"] = example["labels"][0]

...     # use SpeechBrain to obtain x-vector
...     example["speaker_embeddings"] = create_speaker_embedding(audio["array"])

...     return example

Проверьте правильность обработки, рассмотрев один пример:

>>> processed_example = prepare_dataset(dataset[0])
>>> list(processed_example.keys())
['input_ids', 'labels', 'stop_labels', 'speaker_embeddings']

Вектор встраивания говорящего должен состоять из 512 элементов:

>>> processed_example["speaker_embeddings"].shape
(512,)

Метки должны представлять собой лог-мел-спектрограмму с 80 мел-бинами.

>>> import matplotlib.pyplot as plt

>>> plt.figure()
>>> plt.imshow(processed_example["labels"].T)
>>> plt.show()
Log-mel spectrogram with 80 mel bins

Примечание: если эта спектрограмма кажется вам запутанной, возможно, это связано с привычкой размещать низкие частоты внизу графика, а высокие — вверху. Однако при построении спектрограмм в виде изображения с использованием библиотеки matplotlib ось y инвертируется, из-за чего спектрограммы отображаются вверх ногами.

Теперь примените функцию обработки ко всему набору данных. Это займёт от 5 до 10 минут.

>>> dataset = dataset.map(prepare_dataset, remove_columns=dataset.column_names)

Вы увидите предупреждение о том, что некоторые примеры в наборе данных длиннее максимальной длины входных данных, которую может обработать модель (600 токенов). Удалите эти примеры из набора данных. Здесь мы идём ещё дальше: чтобы позволить использовать более крупные размеры батчей, мы удаляем всё, что превышает 200 токенов.

>>> def is_not_too_long(input_ids):
...     input_length = len(input_ids)
...     return input_length < 200


>>> dataset = dataset.filter(is_not_too_long, input_columns=["input_ids"])
>>> len(dataset)
8259

Далее создайте базовое разбиение на обучающую и тестовую выборки:

>>> dataset = dataset.train_test_split(test_size=0.1)

Коллатор данных

Чтобы объединить несколько примеров в батч, необходимо определить собственный data collator. Этот collator дополняет более короткие последовательности padding-токенами, обеспечивая одинаковую длину для всех примеров. Для меток спектрограммы дополненные участки заменяются специальным значением -100. Это специальное значение указывает модели игнорировать соответствующую часть спектрограммы при вычислении spectrogram loss.

>>> from dataclasses import dataclass
>>> from typing import Any, Dict, List, Union


>>> @dataclass
... class TTSDataCollatorWithPadding:
...     processor: Any

...     def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
...         input_ids = [{"input_ids": feature["input_ids"]} for feature in features]
...         label_features = [{"input_values": feature["labels"]} for feature in features]
...         speaker_features = [feature["speaker_embeddings"] for feature in features]

...         # collate the inputs and targets into a batch
...         batch = processor.pad(input_ids=input_ids, labels=label_features, return_tensors="pt")

...         # replace padding with -100 to ignore loss correctly
...         batch["labels"] = batch["labels"].masked_fill(batch.decoder_attention_mask.unsqueeze(-1).ne(1), -100)

...         # not used during fine-tuning
...         del batch["decoder_attention_mask"]

...         # round down target lengths to multiple of reduction factor
...         if model.config.reduction_factor > 1:
...             target_lengths = torch.tensor([len(feature["input_values"]) for feature in label_features])
...             target_lengths = target_lengths.new(
...                 [length - length % model.config.reduction_factor for length in target_lengths]
...             )
...             max_length = max(target_lengths)
...             batch["labels"] = batch["labels"][:, :max_length]

...         # also add in the speaker embeddings
...         batch["speaker_embeddings"] = torch.tensor(speaker_features)

...         return batch

В SpeechT5 вход в декодер модели сокращается в 2 раза. Иными словами, из целевой последовательности отбрасывается каждый второй временной шаг. Затем декодер предсказывает последовательность вдвое большей длины. Поскольку длина исходной целевой последовательности может быть нечётной, data collator округляет максимальную длину батча вниз до кратного 2.

>>> data_collator = TTSDataCollatorWithPadding(processor=processor)

Обучение модели

Загрузите предобученную модель из того же контрольного пункта, который вы использовали для загрузки процессора:

>>> from transformers import SpeechT5ForTextToSpeech

>>> model = SpeechT5ForTextToSpeech.from_pretrained(checkpoint)

Параметр use_cache=True несовместим с проверкой градиентов (gradient checkpointing). Отключите его для обучения.

>>> model.config.use_cache = False

Определим аргументы обучения. В процессе обучения мы не вычисляем метрики оценки. Вместо этого мы будем смотреть только на потерю:

>>> from transformers import Seq2SeqTrainingArguments

>>> training_args = Seq2SeqTrainingArguments(
...     output_dir="speecht5_finetuned_voxpopuli_nl",  # change to a repo name of your choice
...     per_device_train_batch_size=4,
...     gradient_accumulation_steps=8,
...     learning_rate=1e-5,
...     warmup_steps=500,
...     max_steps=4000,
...     gradient_checkpointing=True,
...     fp16=True,
...     eval_strategy="steps",
...     per_device_eval_batch_size=2,
...     save_steps=1000,
...     eval_steps=1000,
...     logging_steps=25,
...     report_to="trackio",
...     load_best_model_at_end=True,
...     greater_is_better=False,
...     label_names=["labels"],
...     push_to_hub=True,
... )

Создайте объект Trainer и передайте в него модель, набор данных и data collator.

>>> from transformers import Seq2SeqTrainer

>>> trainer = Seq2SeqTrainer(
...     args=training_args,
...     model=model,
...     train_dataset=dataset["train"],
...     eval_dataset=dataset["test"],
...     data_collator=data_collator,
...     processing_class=processor,
... )

Итак, вы готовы приступить к обучению! Обучение займёт несколько часов. В зависимости от вашей GPU при запуске обучения может возникнуть ошибка CUDA «out-of-memory». В этом случае можно постепенно уменьшать per_device_train_batch_size в 2 раза и увеличивать gradient_accumulation_steps в 2 раза для компенсации.

>>> trainer.train()

Чтобы использовать контрольную точку с конвейером, убедитесь, что вы сохранили процессор вместе с контрольной точкой:

>>> processor.save_pretrained("YOUR_ACCOUNT_NAME/speecht5_finetuned_voxpopuli_nl")

Загрузите итоговую модель в 🤗 Hub:

>>> trainer.push_to_hub()

Вывод

Вывод с использованием конвейера

Отлично, теперь, когда вы дообучили модель, вы можете использовать её для инференса! Сначала посмотрим, как можно использовать её с соответствующим пайплайном. Создадим пайплайн "text-to-speech" с вашим чекпоинтом:

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-speech", model="YOUR_ACCOUNT_NAME/speecht5_finetuned_voxpopuli_nl")

Выберите фрагмент текста на нидерландском языке, который вы хотите озвучить, например:

>>> text = "hallo allemaal, ik praat nederlands. groetjes aan iedereen!"

Чтобы использовать SpeechT5 с pipeline, вам понадобится speaker embedding. Получим его из примера в тестовом наборе данных:

>>> example = dataset["test"][304]
>>> speaker_embeddings = torch.tensor(example["speaker_embeddings"]).unsqueeze(0)

Теперь вы можете передать в pipeline текстовые и спикерские эмбеддинги, и он сам займётся остальным:

>>> forward_params = {"speaker_embeddings": speaker_embeddings}
>>> output = pipe(text, forward_params=forward_params)
>>> output
{'audio': array([-6.82714235e-05, -4.26525949e-04,  1.06134125e-04, ...,
        -1.22392643e-03, -7.76011671e-04,  3.29112721e-04], dtype=float32),
 'sampling_rate': 16000}

Затем вы можете прослушать результат:

>>> from IPython.display import Audio
>>> Audio(output['audio'], rate=output['sampling_rate'])

Запуск вывода вручную

Вы можете получить те же результаты инференса без использования pipeline, однако потребуется выполнить больше шагов.

Загрузите модель из 🤗 Hub:

>>> model = SpeechT5ForTextToSpeech.from_pretrained("YOUR_ACCOUNT/speecht5_finetuned_voxpopuli_nl")

Выберите пример из тестового набора данных и получите вложение спикера.

>>> example = dataset["test"][304]
>>> speaker_embeddings = torch.tensor(example["speaker_embeddings"]).unsqueeze(0)

Определите входной текст и токенизируйте его.

>>> text = "hallo allemaal, ik praat nederlands. groetjes aan iedereen!"
>>> inputs = processor(text=text, return_tensors="pt")

Создайте спектрограмму с помощью вашей модели:

>>> spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)

Визуализируйте спектрограмму, если хотите:

>>> plt.figure()
>>> plt.imshow(spectrogram.T)
>>> plt.show()
Generated log-mel spectrogram

Наконец, используйте вокодер, чтобы преобразовать спектрограмму в звук.

>>> with torch.no_grad():
...     speech = vocoder(spectrogram)

>>> from IPython.display import Audio

>>> Audio(speech.numpy(), rate=16000)

По нашему опыту, получение удовлетворительных результатов с этой моделью может быть затруднительным. Качество встраиваний говорящих, по-видимому, является значимым фактором. Поскольку SpeechT5 был предварительно обучен на английских x-vectors, он показывает наилучшие результаты при использовании встраиваний английских говорящих. Если синтезированная речь звучит плохо, попробуйте использовать другое встраивание говорящего.

Увеличение длительности обучения, вероятно, также повысит качество результатов. Тем не менее речь явно на нидерландском, а не на английском языке, при этом она передаёт характеристики голоса говорящего (сравните с исходным аудио в примере). Ещё один параметр, с которым можно поэкспериментировать, — это конфигурация модели. Например, попробуйте использовать config.reduction_factor = 1, чтобы проверить, улучшит ли это результаты.

Наконец, важно учитывать этические аспекты. Хотя технология TTS имеет множество полезных применений, её также можно использовать во вредоносных целях, например, для имитации голоса человека без его ведома или согласия. Пожалуйста, используйте TTS с умом и ответственностью.

Update on GitHub