2.NLP

import torch, importlib.util

print("torch:", torch.__version__)
print("cuda:", torch.cuda.is_available(), torch.version.cuda)
print("mps:", getattr(getattr(torch.backends, "mps", None), "is_available", lambda: False)())
print("torch_npu:", bool(importlib.util.find_spec("torch_npu")))
print("directml:", bool(importlib.util.find_spec("torch_directml")))

try:
    import openvino as ov
    print("openvino devices:", ov.Core().available_devices)
except Exception as e:
    print("openvino:", e)

import os, sys, json, torch, numpy as np
from scipy.io import wavfile

HOYO_MODEL = r"D:/workspace/longevity-world-text/tmp/models/hoyoTTS"
HOYO_CODE  = r"D:/workspace/longevity-world-text/tmp/models/hoyoTTS-code"
BERT       = r"D:/workspace/longevity-world-text/tmp/models/chinese-roberta-wwm-ext-large"

# 本地化 snapshot_download
import modelscope
_orig = modelscope.snapshot_download
def _local(mid, *a, k):
    mid = str(mid)
    if "hoyoTTS" in mid:
        return HOYO_MODEL
    if "chinese-roberta" in mid:
        return BERT
    return _orig(mid, *a, k)
modelscope.snapshot_download = _local

sys.path.insert(0, HOYO_CODE)
from text.symbols import symbols
from text.cleaner import clean_text
from text import cleaned_text_to_sequence, get_bert
from models import SynthesizerTrn
import commons, utils

def pick_device():
    if torch.cuda.is_available():
        return torch.device("cuda")
    if getattr(getattr(torch.backends, "mps", None), "is_available", lambda: False)():
        return torch.device("mps")
    return torch.device("cpu")

DEVICE = pick_device()
print("TTS device:", DEVICE)

hps = utils.get_hparams_from_dir(HOYO_MODEL)
net = SynthesizerTrn(
    len(symbols),
    hps.data.filter_length // 2 + 1,
    hps.train.segment_size // hps.data.hop_length,
    n_speakers=hps.data.n_speakers,
    hps.model
).to(DEVICE)
utils.load_checkpoint(f"{HOYO_MODEL}/G_78000.pth", net, None, skip_optimizer=True)
net.eval()
sr = hps.data.sampling_rate

def synth(text, sid, out_wav="out.wav",
          sdp_ratio=0.2, noise_scale=0.667, noise_scale_w=0.8,
          length_scale=1.0, seed=42):
    torch.manual_seed(seed)
    if DEVICE.type == "cuda":
        torch.cuda.manual_seed_all(seed)

    norm_text, phone, tone, word2ph = clean_text(text, "ZH")
    phone, tone, lang = cleaned_text_to_sequence(phone, tone, "ZH")

    if hps.data.add_blank:
        phone = commons.intersperse(phone, 0)
        tone = commons.intersperse(tone, 0)
        lang = commons.intersperse(lang, 0)
        for i in range(len(word2ph)):
            word2ph[i] = word2ph[i] * 2
        word2ph[0] += 1

    bert = get_bert(norm_text, word2ph, "ZH").to(DEVICE)
    assert bert.shape[-1] == len(phone)

    with torch.no_grad():
        audio = net.infer(
            phone.unsqueeze(0).to(DEVICE),
            torch.LongTensor([phone.size(0)]).to(DEVICE),
            torch.LongTensor([sid]).to(DEVICE),
            tone.unsqueeze(0).to(DEVICE),
            lang.unsqueeze(0).to(DEVICE),
            bert.unsqueeze(0),
            sdp_ratio=sdp_ratio,
            noise_scale=noise_scale,
            noise_scale_w=noise_scale_w,
            length_scale=length_scale,
        )[0][0, 0].data.cpu().float().numpy()

    wavfile.write(out_wav, sr, (np.clip(audio, -1, 1) * 32767).astype(np.int16))
    return out_wav

import torch
print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))

# 固定 shape 时开 cudnn benchmark；文本长度变化大时未必有益
torch.backends.cudnn.benchmark = True

# 混合精度（先测音质，Bert-VITS2 对精度敏感）
with torch.autocast("cuda", dtype=torch.float16):
    ...

DEVICE = torch.device("mps")

import torch_directml
DEVICE = torch_directml.device()
net.to(DEVICE)

PARAM_GRID = [
    dict(sdp=0.0, noise=0.667, noise_w=0.8),
    dict(sdp=0.2, noise=0.3,   noise_w=0.3),
    dict(sdp=0.4, noise=0.667, noise_w=0.8),
    dict(sdp=0.0, noise=0.3,   noise_w=0.3),
    dict(sdp=0.1, noise=0.5,   noise_w=0.5),
]