GPT-SoVITS-For-Intelを使って音声を生成しよう（ファインチューニング編）

#!/bin/bash

#インストールに必要なライブラリ等をインストール
sudo apt update
sudo apt install git
sudo apt install curl
sudo apt install build-essential cmake

# uvをcurlでインストール
curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env

#GPT-SoVITS-For-Intelのインストール
cd ~
mkdir -p install
cd install
git clone https://github.com/IzayoiSakuya16/GPT-SoVITS-For-Intel.git
cd GPT-SoVITS-For-Intel

#uvでpython3.10環境を作る
uv venv --python 3.10 --seed

# uv環境を有効化
source .venv/bin/activate

#IPEXのインストール（torch.xpuではありません）
python -m pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/xpu
python -m pip install intel-extension-for-pytorch==2.8.10+xpu --extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/
python -m pip install oneccl_bind_pt==2.8.0+xpu --index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/

#音声データの文字起こしをするため「faster_whisper」をuv環境にインストール
uv pip install faster_whisper

# 「GPT-SoVITS-For-Intel」のrequirements.txtを実行
uv pip install -r requirements.txt

#モデルファイルのダウンロードと配置(git-lfs)
sudo apt install git-lfs
git lfs install
cd ~/install/GPT-SoVITS-For-Intel/GPT_SoVITS/pretrained_models/
git clone https://huggingface.co/lj1995/GPT-SoVITS
cp -r GPT-SoVITS/* .

#configファイルの配置（「GPT-SoVITS-For-Intel」には何故かこれらのファイルが存在しませんので、本家から拝借しています）
cd ~/install/GPT-SoVITS-For-Intel/GPT_SoVITS/configs/
git clone https://github.com/RVC-Boss/GPT-SoVITS.git
cd GPT-SoVITS/GPT_SoVITS
cp -r configs/* ~/install/GPT-SoVITS-For-Intel/GPT_SoVITS/configs/
cd ~/install//GPT-SoVITS-For-Intel

import warnings
warnings.filterwarnings("ignore")
import os
import utils
import logging
import torch
import pathlib
import torch.distributed as dist
from torch.nn import functional as F
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from tqdm import tqdm
from random import randint

# PyTorch 2.6+ セキュリティ対策
torch.serialization.add_safe_globals([pathlib.PosixPath])

# --- Intel GPU (IPEX) 対応 ---
try:
    import intel_extension_for_pytorch as ipex
except ImportError:
    pass

from torch.amp import autocast
def get_grad_scaler(device_type, enabled):
    try:
        return torch.amp.GradScaler(device_type, enabled=enabled)
    except:
        return torch.cuda.amp.GradScaler(enabled=enabled)
# ----------------------------

from module import commons
from module.data_utils import (
    DistributedBucketSampler,
    TextAudioSpeakerCollate,
    TextAudioSpeakerLoader,
)
from module.losses import discriminator_loss, feature_loss, generator_loss, kl_loss
from module.mel_processing import mel_spectrogram_torch, spec_to_mel_torch
from module.models import (
    MultiPeriodDiscriminator,
    SynthesizerTrn,
)
from process_ckpt import savee

logging.getLogger("matplotlib").setLevel(logging.INFO)
logging.getLogger("h5py").setLevel(logging.INFO)
logging.getLogger("numba").setLevel(logging.INFO)

hps = utils.get_hparams(stage=2)
os.environ["CUDA_VISIBLE_DEVICES"] = hps.train.gpu_numbers.replace("-", ",")

torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = False
torch.set_float32_matmul_precision("medium")

global_step = 0
device_type = "xpu" if torch.xpu.is_available() else ("cuda" if torch.cuda.is_available() else "cpu")

def main():
    # --- 安定化の核心: マルチプロセスを使わず直接 run を呼ぶ ---
    n_gpus = 1 
    os.environ["MASTER_ADDR"] = "localhost"
    os.environ["MASTER_PORT"] = str(randint(20000, 55555))
    run(0, n_gpus, hps)

def run(rank, n_gpus, hps):
    global global_step
    curr_device = f"{device_type}:{rank}" if device_type != "cpu" else "cpu"

    if rank == 0:
        logger = utils.get_logger(hps.data.exp_dir)
        writer = SummaryWriter(log_dir=hps.s2_ckpt_dir)
        writer_eval = SummaryWriter(log_dir=os.path.join(hps.s2_ckpt_dir, "eval"))

    # 通信の初期化（シングルプロセスでも DDP 互換のために必要）
    dist.init_process_group(backend="gloo", init_method="env://?use_libuv=False", world_size=n_gpus, rank=rank)
    
    torch.manual_seed(hps.train.seed)
    if device_type == "xpu": torch.xpu.set_device(rank)
    elif device_type == "cuda": torch.cuda.set_device(rank)

    train_dataset = TextAudioSpeakerLoader(hps.data)
    train_sampler = DistributedBucketSampler(train_dataset, hps.train.batch_size, [32, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900], num_replicas=n_gpus, rank=rank, shuffle=True)
    train_loader = DataLoader(train_dataset, num_workers=6, shuffle=False, pin_memory=True, collate_fn=TextAudioSpeakerCollate(), batch_sampler=train_sampler, persistent_workers=True, prefetch_factor=4)

    net_g = SynthesizerTrn(hps.data.filter_length // 2 + 1, hps.train.segment_size // hps.data.hop_length, n_speakers=hps.data.n_speakers, **hps.model).to(curr_device)
    net_d = MultiPeriodDiscriminator(hps.model.use_spectral_norm).to(curr_device)

    # Optimizer
    te_p = list(map(id, net_g.enc_p.text_embedding.parameters())); et_p = list(map(id, net_g.enc_p.encoder_text.parameters())); mrte_p = list(map(id, net_g.enc_p.mrte.parameters()))
    base_params = filter(lambda p: id(p) not in te_p + et_p + mrte_p and p.requires_grad, net_g.parameters())
    optim_g = torch.optim.AdamW([{"params": base_params, "lr": hps.train.learning_rate}, {"params": net_g.enc_p.text_embedding.parameters(), "lr": hps.train.learning_rate * hps.train.text_low_lr_rate}, {"params": net_g.enc_p.encoder_text.parameters(), "lr": hps.train.learning_rate * hps.train.text_low_lr_rate}, {"params": net_g.enc_p.mrte.parameters(), "lr": hps.train.learning_rate * hps.train.text_low_lr_rate}], hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps)
    optim_d = torch.optim.AdamW(net_d.parameters(), hps.train.learning_rate, betas=hps.train.betas, eps=hps.train.eps)

    # ロード処理
    try:
        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path("%s/logs_s2_%s" % (hps.data.exp_dir, hps.model.version), "D_*.pth"), net_d, optim_d)
        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path("%s/logs_s2_%s" % (hps.data.exp_dir, hps.model.version), "G_*.pth"), net_g, optim_g)
        epoch_str += 1; global_step = (epoch_str - 1) * len(train_loader)
    except:
        epoch_str = 1; global_step = 0
        if hps.train.pretrained_s2G: net_g.load_state_dict(torch.load(hps.train.pretrained_s2G, map_location="cpu")["weight"], strict=False)
        if hps.train.pretrained_s2D: net_d.load_state_dict(torch.load(hps.train.pretrained_s2D, map_location="cpu")["weight"])

    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=-1)
    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=-1)
    for _ in range(epoch_str): scheduler_g.step(); scheduler_d.step()

    scaler = get_grad_scaler(device_type, enabled=hps.train.fp16_run)

    print(f"start training on {curr_device} from epoch {epoch_str}")
    for epoch in range(epoch_str, hps.train.epochs + 1):
        train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d], scaler, [train_loader, None], logger if rank==0 else None, [writer, writer_eval] if rank==0 else None, curr_device)
        scheduler_g.step(); scheduler_d.step()

        # --- 保存処理 (必ずこのループの中にインデントして入れる必要があります) ---
        if rank == 0 and epoch % hps.train.save_every_epoch == 0:
            save_path = os.path.join(hps.data.exp_dir, f"logs_s2_{hps.model.version}")
            os.makedirs(save_path, exist_ok=True)
            utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch, os.path.join(save_path, f"G_{global_step if hps.train.if_save_latest==0 else 233333333333}.pth"))
            
            if hps.train.if_save_every_weights:
                target_model = net_g.module if hasattr(net_g, 'module') else net_g
                ckpt = target_model.state_dict()
                savee(ckpt, hps.name + f"_e{epoch}_s{global_step}", epoch, global_step, hps)

def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, scaler, loaders, logger, writers, curr_device):
    net_g, net_d = nets; optim_g, optim_d = optims; train_loader, _ = loaders
    if writers: writer, writer_eval = writers
    train_loader.batch_sampler.set_epoch(epoch)
    global global_step

    net_g.train(); net_d.train()
    for batch_idx, (ssl, ssl_lengths, spec, spec_lengths, y, y_lengths, text, text_lengths) in enumerate(tqdm(train_loader)):
        spec, spec_lengths = spec.to(curr_device, non_blocking=True), spec_lengths.to(curr_device, non_blocking=True)
        y, y_lengths = y.to(curr_device, non_blocking=True), y_lengths.to(curr_device, non_blocking=True)
        ssl = ssl.to(curr_device, non_blocking=True)
        text, text_lengths = text.to(curr_device, non_blocking=True), text_lengths.to(curr_device, non_blocking=True)

        with autocast(device_type=device_type, enabled=hps.train.fp16_run):
            y_hat, kl_ssl, ids_slice, x_mask, z_mask, (z, z_p, m_p, logs_p, m_q, logs_q), stats_ssl = net_g(ssl, spec, spec_lengths, text, text_lengths)
            spec_sliced = commons.slice_segments(spec, ids_slice, hps.train.segment_size // hps.data.hop_length)
            y_mel = spec_to_mel_torch(spec_sliced, hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.mel_fmin, hps.data.mel_fmax)
            y_hat_mel = mel_spectrogram_torch(y_hat.squeeze(1), hps.data.filter_length, hps.data.n_mel_channels, hps.data.sampling_rate, hps.data.hop_length, hps.data.win_length, hps.data.mel_fmin, hps.data.mel_fmax)
            y_sliced = commons.slice_segments(y, ids_slice * hps.data.hop_length, hps.train.segment_size)

            y_d_hat_r, y_d_hat_g, _, _ = net_d(y_sliced, y_hat.detach())
            with autocast(device_type=device_type, enabled=False):
                loss_disc, _, _ = discriminator_loss(y_d_hat_r, y_d_hat_g)
        
        optim_d.zero_grad()
        scaler.scale(loss_disc).backward()
        scaler.unscale_(optim_d)
        scaler.step(optim_d)

        with autocast(device_type=device_type, enabled=hps.train.fp16_run):
            y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y_sliced, y_hat)
            with autocast(device_type=device_type, enabled=False):
                loss_mel = F.l1_loss(y_mel, y_hat_mel) * hps.train.c_mel
                loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, z_mask) * hps.train.c_kl
                loss_fm = feature_loss(fmap_r, fmap_g)
                loss_gen, _ = generator_loss(y_d_hat_g)
                loss_gen_all = loss_gen + loss_fm + loss_mel + kl_ssl + loss_kl

        optim_g.zero_grad()
        scaler.scale(loss_gen_all).backward()
        scaler.unscale_(optim_g)
        scaler.step(optim_g)
        scaler.update()

        if rank == 0 and global_step % hps.train.log_interval == 0:
            logger.info(f"Epoch: {epoch} Step: {global_step} Loss: {loss_gen_all.item():.4f}")
        
        global_step += 1

if __name__ == "__main__":
    main()

私はとある男のUbuntuというブログの管理人をしています。

私は、とある男のUbuntuという、ブログの管理人をしています。

ルドルフ一世の死とともに、帝国の各地で共和主義者による叛乱が続発した。ルドルフの指導力と個性を喪失したいま、帝国はすぐにも崩壊するものと思われたのだが、それは楽観的にすぎた。ルドルフが４０年の歳月をかけ、腹心として育成した貴族、軍隊、官僚の三位一体体制は、共和主義者たちの希望的観測よりはるかに強固であったのだ。
それを統率したのは皇父であり帝国宰相であったノイエ・シュタウフェン公ヨアヒムである。彼はルドルフが婿としてえらんだ人物だけあって沈着冷静な指導力を発揮し、もともと劣勢であった叛乱軍を、卵の殻でも踏みつけるように粉砕した。
叛乱に参加した５億余人が殺され、その家族など１００億人以上が市民権を剥奪されて農奴階級におとされた。反対勢力を圧殺するに仮借するなかれ、との帝国の国是は忠実に遵守されたのである。
共和主義者たちはふたたび冬の時代をたえねばならなかった。
強力な専制政治の前に、厳しい冬は永遠に続くかと思われた。ヨアヒムの死後、シギスムントが親政をおこない、その没後を長子リヒャルトが継ぎ、その後に長子オトフリートが立った。至高の権力をえるのはルドルフの子孫にかぎられ、世襲だけが権力の移動のあるべき姿になったかにみえた。

cd ~/install/GPT-SoVITS-For-Intel
source .venv/bin/activate
python ./webui.py