# Fish Speech 1.4：开源多语言语音合成与克隆解决方案

## 项目概述

**Fish Speech 1.4** 是一个领先的开源多语言语音合成模型，具备语音克隆功能。该模型基于大量的音频数据训练而成，支持多种语言，并且可以轻松部署和集成到各种应用中。

- **项目地址**: [GitHub - fishaudio/fish-speech](https://github.com/fishaudio/fish-speech)
- **许可证**: CC-BY-NC-SA-4.0（模型）和 BSD-3-Clause（源代码）





## 主要特性

### 多语言支持

Fish Speech 1.4 支持以下8种语言，覆盖了全球主要的语言需求：

- **英语 (English)**: ~300,000小时
- **中文 (Chinese)**: ~300,000小时
- **德语 (German)**: ~20,000小时
- **日语 (Japanese)**: ~20,000小时
- **法语 (French)**: ~20,000小时
- **西班牙语 (Spanish)**: ~20,000小时
- **韩语 (Korean)**: ~20,000小时
- **阿拉伯语 (Arabic)**: ~20,000小时

丰富的多语言支持使得 Fish Speech 1.4 能够满足全球不同用户的需求，广泛应用于跨语言的应用场景中。

### 语音克隆

除了基本的文本转语音功能，Fish Speech 1.4 还具备语音克隆能力。用户可以通过提供少量的目标语音样本，克隆出个性化的语音模型，实现更加自然和个性化的语音输出。

### 大规模训练数据

Fish Speech 1.4 基于 **700,000小时** 的音频数据进行训练，确保了模型的高质量和广泛适应性。庞大的训练数据量使得模型在不同语言和不同语境下都能表现出色。

### 易于部署

项目提供了完善的 Docker 支持，简化了本地部署的流程。开发者可以通过 Docker 容器快速启动和运行 Fish Speech 1.4，轻松集成到现有系统中。

### 活跃的社区与持续更新

Fish Speech 项目在 GitHub 上拥有 **11.9k 星**，**906 个 Fork**，并且有 **43 位贡献者**。团队和社区成员不断优化和更新项目，确保其在技术前沿保持领先。


## 微调项目实战

https://speech.fish.audio/zh/


### 打包一个镜像

以下实现都要魔法：

```bash
# 进自己的目录
cd /root/xiedong/tts

# 拉代码
git clone https://github.com/fishaudio/fish-speech.git

# 进入项目
cd fish-speech/

# 拉模型
huggingface-cli download fishaudio/fish-speech-1.4 --local-dir checkpoints/fish-speech-1.4

# china 拉模型这么拉
HF_ENDPOINT=https://hf-mirror.com huggingface-cli download fishaudio/fish-speech-1.4 --local-dir checkpoints/fish-speech-1.4

# 运行镜像
docker run -it --shm-size=16g --env=is_half=False --gpus all --net host -v /root/xiedong/tts:/root/xiedong/tts pytorch/pytorch:2.4.1-cuda12.1-cudnn9-devel bash

# 进入
mv /root/xiedong/tts/fish-speech/

cd /workspace/fish-speech

# 安装 fish-speech
pip3 install -e .[stable]

# (Ubuntu / Debian 用户) 安装 sox + ffmpeg
apt update && apt install libsox-dev ffmpeg -y


apt update && apt install vim wget curl -y


echo 'export LD_LIBRARY_PATH=/opt/conda/lib/python3.11/site-packages/torch/lib:$LD_LIBRARY_PATH' >> ~/.bashrc


apt-get update && apt-get install -y locales
locale-gen zh_CN.UTF-8
echo 'export LANG=zh_CN.UTF-8' >> ~/.bashrc


apt-get clean && \
rm -rf /var/lib/apt/lists/* && \
# 清理 pip 缓存
rm -rf /root/.cache/pip

```

推入镜像，以后这样操作就可以：

```bash
docker run -it --shm-size=16g --env=is_half=False --gpus all --net host -v /root/xiedong/tts:/root/xiedong/tts kevinchina/deeplearning:pytorch-2.4.1-cuda12.1-cudnn9-devel-fish1.4 bash

cd /workspace/fish-speech
```

### 数据准备

要创建一个这样的数据集放data里：

```bash
.
├── SPK1
│   ├── 21.15-26.44.lab
│   ├── 21.15-26.44.mp3
│   ├── 27.51-29.98.lab
│   ├── 27.51-29.98.mp3
│   ├── 30.1-32.71.lab
│   └── 30.1-32.71.mp3
└── SPK2
    ├── 38.79-40.85.lab
    └── 38.79-40.85.mp3
```



![image.png](/static/img/a882cf8b3740c839b67c3a0fa3024589.image.webp)

### 量提取语义 token

该命令会在 fishdata 目录下创建 .npy 文件。

```bash
cd /workspace/fish-speech

python tools/vqgan/extract_vq.py /root/xiedong/tts/datasets2/fishdata \
    --num-workers 1 --batch-size 16 \
    --config-name "firefly_gan_vq" \
    --checkpoint-path "checkpoints/fish-speech-1.4/firefly-gan-vq-fsq-8x1024-21hz-generator.pth"
```


![image.png](/static/img/1e4cec2dc0597a10f3e8bc6e6335ed53.image.webp)


### 打包数据集为 protobuf


```bash
cd /workspace/fish-speech

python tools/llama/build_dataset.py \
    --input "/root/xiedong/tts/datasets2/fishdata" \
    --output "/root/xiedong/tts/datasets2/fishdata/protos" \
    --text-extension .lab \
    --num-workers 16
```


![image.png](/static/img/de6a279a9fcd648b7b6e2e9bbd4b1b99.image.webp)


### 使用 LoRA 进行微调


```bash
cd /workspace/fish-speech



vim fish_speech/configs/text2semantic_finetune.yaml # 修改自己的数据路径为/root/xiedong/tts/datasets2/fishdata/protos

export project=shiyu_fish

python fish_speech/train.py --config-name text2semantic_finetune \
    project=$project \
    +lora@model.model.lora_config=r_8_alpha_16
```

text2semantic_finetune.yaml是这样的，要根据自己需要改 batch_size, gradient_accumulation_steps，data/protos


```bash
# 默认配置列表，首先应用 `base` 配置，然后应用当前文件自身的配置
defaults:
  - base
  - _self_

# 项目名称，指定为 `text2semantic_finetune_dual_ar`
project: text2semantic_finetune_dual_ar

# 模型的最大输入长度，设置为 4096
max_length: 4096

# 预训练模型的检查点路径，指向 `checkpoints/fish-speech-1.4`
pretrained_ckpt_path: checkpoints/fish-speech-1.4

# Lightning Trainer 配置部分
trainer:
  # 累积的梯度批次数，设置为 1
  accumulate_grad_batches: 1
  # 梯度裁剪的阈值，设置为 1.0
  gradient_clip_val: 1.0
  # 梯度裁剪的算法，使用 "norm"
  gradient_clip_algorithm: "norm"
  # 最大训练步数，设置为 1000
  max_steps: 1000
  # 训练精度，使用 bf16 格式并启用
  precision: bf16-true
  # 限制验证批次数，设置为 10
  limit_val_batches: 10
  # 验证检查间隔步数，设置为 100
  val_check_interval: 100

# 分词器配置部分
tokenizer:
  # 指定分词器的目标类，从预训练模型中加载分词器
  _target_: transformers.AutoTokenizer.from_pretrained
  # 预训练模型的名称或路径，引用 `pretrained_ckpt_path`
  pretrained_model_name_or_path: ${pretrained_ckpt_path}

# 训练数据集配置
train_dataset:
  # 指定训练数据集的目标类
  _target_: fish_speech.datasets.semantic.AutoTextSemanticInstructionDataset
  # 原型文件路径列表
  proto_files:
    - data/protos
  # 使用的分词器，引用 `tokenizer`
  tokenizer: ${tokenizer}
  # 是否使用因果关系，设置为 true
  causal: true
  # 最大输入长度，引用 `max_length`
  max_length: ${max_length}
  # 是否使用说话者信息，设置为 false
  use_speaker: false
  # 交互概率，设置为 0.7
  interactive_prob: 0.7

# 验证数据集配置
val_dataset:
  # 指定验证数据集的目标类
  _target_: fish_speech.datasets.semantic.AutoTextSemanticInstructionDataset
  # 原型文件路径列表
  proto_files:
    - data/protos
  # 使用的分词器，引用 `tokenizer`
  tokenizer: ${tokenizer}
  # 是否使用因果关系，设置为 true
  causal: true
  # 最大输入长度，引用 `max_length`
  max_length: ${max_length}
  # 是否使用说话者信息，设置为 false
  use_speaker: false
  # 交互概率，设置为 0.7
  interactive_prob: 0.7

# 数据模块配置
data:
  # 指定数据模块的目标类
  _target_: fish_speech.datasets.semantic.SemanticDataModule
  # 训练数据集，引用 `train_dataset`
  train_dataset: ${train_dataset}
  # 验证数据集，引用 `val_dataset`
  val_dataset: ${val_dataset}
  # 数据加载时使用的工作线程数，设置为 4
  num_workers: 4
  # 批量大小，设置为 8
  batch_size: 8
  # 使用的分词器，引用 `tokenizer`
  tokenizer: ${tokenizer}
  # 最大输入长度，引用 `max_length`
  max_length: ${max_length}

# 模型配置部分
model:
  # 指定模型的目标类
  _target_: fish_speech.models.text2semantic.lit_module.TextToSemantic
  model:
    # 指定底层模型的目标类，从预训练模型中加载
    _target_: fish_speech.models.text2semantic.llama.BaseTransformer.from_pretrained
    # 预训练模型的路径，引用 `pretrained_ckpt_path`
    path: ${pretrained_ckpt_path}
    # 是否加载权重，设置为 true
    load_weights: true
    # 最大输入长度，引用 `max_length`
    max_length: ${max_length}
    # LoRA 配置，设置为 null（不使用）
    lora_config: null

  # 优化器配置
  optimizer:
    # 指定优化器的目标类，使用 AdamW
    _target_: torch.optim.AdamW
    # 部分参数化，设置为 true
    _partial_: true
    # 学习率，设置为 1e-4
    lr: 1e-4
    # 权重衰减，设置为 0
    weight_decay: 0
    # Adam 优化器的 beta 参数
    betas: [0.9, 0.95]
    # Adam 优化器的 epsilon 参数
    eps: 1e-5

  # 学习率调度器配置
  lr_scheduler:
    # 指定学习率调度器的目标类，使用 LambdaLR
    _target_: torch.optim.lr_scheduler.LambdaLR
    # 部分参数化，设置为 true
    _partial_: true
    # 学习率变化函数
    lr_lambda:
      # 指定学习率变化函数的目标类
      _target_: fish_speech.scheduler.get_constant_schedule_with_warmup_lr_lambda
      # 部分参数化，设置为 true
      _partial_: true
      # 预热步数，设置为 10
      num_warmup_steps: 10

# 回调函数配置
callbacks:
  # 模型检查点回调配置
  model_checkpoint:
    # 每隔多少训练步保存一次检查点，引用 `trainer.val_check_interval`
    every_n_train_steps: ${trainer.val_check_interval}

```



![image.png](/static/img/f5b5d5475c9c57c77d7366886517f542.image.webp)






### 使用 LoRA 进行微调的反思


官网说的这个：

> 默认配置下, 基本只会学到说话人的发音方式, 而不包含音色, 你依然需要使用 prompt 来保证音色的稳定性.
> 如果你想要学到音色, 请将训练步数调大, 但这有可能会导致过拟合.

分布式后端为 nccl。模型类型为 DualARTransformer，总参数量为 499M，其中可训练参数为 5.1M，不可训练参数为 494M。Md这和不开源有啥区别？？？


### 合并Lora权重进行推理


```bash
cd /workspace/fish-speech

export project=shiyu_fish

python tools/llama/merge_lora.py \
    --lora-config r_8_alpha_16 \
    --base-weight checkpoints/fish-speech-1.4 \
    --lora-weight results/$project/checkpoints/step_000000700.ckpt \
    --output checkpoints/fish-speech-1.4-yth-lora3/
```

### WebUI 推理

克隆了说话人的音色，效果听起来还是可以。

```bash
cd /workspace/fish-speech

export project=shiyu_fish

python -m tools.webui \
    --llama-checkpoint-path "checkpoints/fish-speech-1.4-yth-lora3" \
    --decoder-checkpoint-path "checkpoints/fish-speech-1.4/firefly-gan-vq-fsq-8x1024-21hz-generator.pth" \
    --decoder-config-name firefly_gan_vq
```

### HTTP API 推理

开服务：

```bash
cd /workspace/fish-speech

python -m tools.api \
    --listen 0.0.0.0:8080 \
    --llama-checkpoint-path "checkpoints/fish-speech-1.4-yth-lora3" \
    --decoder-checkpoint-path "checkpoints/fish-speech-1.4/firefly-gan-vq-fsq-8x1024-21hz-generator.pth" \
    --decoder-config-name firefly_gan_vq
```

 可以一次使用多个 参考音频路径 和 参考音频的文本内容。在命令里用空格隔开即可。
 
 
```bash
cd /workspace/fish-speech

conda install pyaudio

python -m tools.post_api \
    --text "要输入的文本" \
    --reference_audio "参考音频路径1" "参考音频路径2" \
    --reference_text "参考音频的文本内容1" "参考音频的文本内容2"\
    --streaming False \
    --output "generated" \
    --format "mp3"
```

比如，会有很多幻觉读音：

```bash
conda install pyaudio


python -m tools.post_api \
    --text "要输入的文本" \
    --reference_audio "/root/xiedong/tts/datasets2/shiyuv2_vk2/3206.wav.reformatted_vocals.wav_main_vocal.wav" "/root/xiedong/tts/datasets2/shiyuv2_vk2/3209.wav.reformatted_vocals.wav_main_vocal.wav" \
    --reference_text "我猛地从沙发上站起来，心跳在胸腔里狂跳，仿佛要跳出喉咙。" "你怎么可以这么不小心我几乎是咆哮着说出这句话，声音里满是失望和愤怒。" \
    --output "generated" \
    --format "wav" --play False

```

## 总结

有太多幻觉，不玩了，没啥用。

【深度学习】语音TTS，微调训练 fishaudio / fish-speech-1.4 

## 什么是强化学习？

强化学习（Reinforcement Learning，RL）是一种机器学习范式，旨在研究智能体（Agent）如何在环境（Environment）中通过试错（Trial and Error）学习策略，以最大化累积奖励（Cumulative Reward）。与监督学习和无监督学习不同，强化学习强调通过序列决策实现长期目标。





## 强化学习的基础知识

### 智能体与环境

- **智能体（Agent）**：在环境中执行动作的实体，学习如何选择最优动作。
- **环境（Environment）**：智能体交互的外部系统，提供状态和奖励反馈。
- **状态（State，$S$）**：环境在某一时刻的具体情况，描述当前情境。
- **动作（Action，$A$）**：智能体在给定状态下可以采取的行为集合。
- **奖励（Reward，$R$）**：环境对智能体动作的反馈信号，用于指导学习过程。

### 马尔可夫过程（Markov Process）

马尔可夫过程是一种具有马尔可夫性质的随机过程，即当前状态完全决定未来状态，与过去状态无关。形式化定义为状态序列 $\{S_t\}$ 满足：

$$
P(S_{t+1} = s' | S_t = s) = P(S_{t+1} = s' | S_t = s, S_{t-1}, \dots, S_0)
$$

### 马尔可夫奖励过程（Markov Reward Process）

在马尔可夫过程的基础上添加奖励函数，形成马尔可夫奖励过程，定义为五元组 $\langle S, P, R, \gamma \rangle$，其中：

- $S$：状态空间
- $P$：状态转移概率矩阵
- $R$：奖励函数，$R(s) = \mathbb{E}[R_{t+1} | S_t = s]$
- $\gamma$：折扣因子，$0 \leq \gamma \leq 1$

### 马尔可夫决策过程（Markov Decision Process, MDP）

强化学习通常通过马尔可夫决策过程来建模，MDP 是一个五元组 $\langle S, A, P, R, \gamma \rangle$，其中：

1. **状态空间（State Space，$S$）**：所有可能状态的集合。
2. **动作空间（Action Space，$A$）**：所有可能动作的集合。
3. **转移概率（Transition Probability，$P$）**：在状态 $s$ 下采取动作 $a$ 后转移到状态 $s'$ 的概率，表示为 $P(s' | s, a)$。
4. **奖励函数（Reward Function，$R$）**：在状态 $s$ 下采取动作 $a$ 所获得的即时奖励，表示为 $R(s, a)$。
5. **折扣因子（Discount Factor，$\gamma$）**：衡量未来奖励的重要性，取值范围为 $0 \leq \gamma \leq 1$。

### 策略（Policy，$\pi$）

策略是智能体在给定状态下选择动作的规则，定义为从状态到动作的映射：

- **确定性策略（Deterministic Policy）**：$\pi(s) = a$，在状态 $s$ 下总是选择动作 $a$。
- **随机性策略（Stochastic Policy）**：$\pi(a|s) = P(A_t = a | S_t = s)$，在状态 $s$ 下以概率 $\pi(a|s)$ 选择动作 $a$。

### 价值函数（Value Function）

价值函数评估在某一状态或状态-动作对下，智能体能够获得的期望累积奖励。

- **状态价值函数（State Value Function，$V^\pi(s)$）**：

  $$
  V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{k=0}^{\infty} \gamma^k R_{t+k+1} \Big| S_t = s \right]
  $$

- **动作价值函数（Action Value Function，$Q^\pi(s, a)$）**：

  $$
  Q^\pi(s, a) = \mathbb{E}_\pi \left[ \sum_{k=0}^{\infty} \gamma^k R_{t+k+1} \Big| S_t = s, A_t = a \right]
  $$

### 贝尔曼方程（Bellman Equation）

贝尔曼方程描述了价值函数的递归性质。

- **状态价值函数的贝尔曼方程**：

  $$
  V^\pi(s) = \sum_{a \in A} \pi(a|s) \left[ R(s, a) + \gamma \sum_{s' \in S} P(s'|s, a) V^\pi(s') \right]
  $$

- **动作价值函数的贝尔曼方程**：

  $$
  Q^\pi(s, a) = R(s, a) + \gamma \sum_{s' \in S} P(s'|s, a) \sum_{a' \in A} \pi(a'|s') Q^\pi(s', a')
  $$






## 状态价值函数的贝尔曼方程

### 定义

状态价值函数 $ V^\pi(s) $ 表示在策略 $ \pi $ 下，智能体从状态 $ s $ 开始所能获得的期望累积奖励。贝尔曼方程为状态价值函数提供了一种递归的计算方法。

### 贝尔曼方程

状态价值函数的贝尔曼方程定义如下：

$$
V^\pi(s) = \sum_{a \in A} \pi(a|s) \left[ R(s, a) + \gamma \sum_{s' \in S} P(s'|s, a) V^\pi(s') \right]
$$

### 公式解析

重写后的公式使用Markdown公式样式如下：

- **$V^\pi(s)$**：在策略 $ \pi $ 下，状态 $ s $ 的价值，即从 $ s $ 开始，遵循策略 $ \pi $ 所能获得的期望累积奖励。
- **$\sum_{a \in A} \pi(a|s)$**：对所有可能的动作 $ a $ 进行加权求和，权重是策略 $ \pi $ 在状态 $ s $ 下选择动作 $ a $ 的概率。
- **$R(s, a)$**：在状态 $ s $ 下采取动作 $ a $ 所获得的即时奖励。
- **$\gamma$**：折扣因子，介于 0 和 1 之间，用于衡量未来奖励的重要性。较大的 $ \gamma $ 强调长期奖励，较小的 $ \gamma $ 强调短期奖励。
- **$\sum_{s' \in S} P(s'|s, a) V^\pi(s')$**：在状态 $ s $ 下采取动作 $ a $ 后，转移到下一个状态 $ s' $ 的概率 $ P(s'|s, a) $ 与该状态的价值 $ V^\pi(s') $ 的加权和。

### 直观理解

贝尔曼方程表明，当前状态 $ s $ 的价值等于在该状态下，所有可能动作的预期价值之和。每个动作的预期价值由以下两部分组成：

1. **即时奖励 $ R(s, a) $**：执行动作 $ a $ 后立即获得的奖励。
2. **未来状态的价值 $ \gamma \sum_{s'} P(s'|s, a) V^\pi(s') $**：执行动作 $ a $ 后，转移到下一个状态 $ s' $ 并继续按照策略 $ \pi $ 行动，所能获得的折扣累积奖励的期望值。

### 示例

假设有一个简单的迷宫环境，状态空间 $ S = \{s_1, s_2\} $，动作空间 $ A = \{a_1, a_2\} $，策略 $ \pi $ 在每个状态下均匀随机选择动作，即 $ \pi(a_1|s) = \pi(a_2|s) = 0.5 $。

假设奖励函数和转移概率如下：

- $ R(s_1, a_1) = 5 $，$ P(s_2|s_1, a_1) = 1 $
- $ R(s_1, a_2) = 10 $，$ P(s_2|s_1, a_2) = 1 $
- $ R(s_2, a_1) = 0 $，$ P(s_1|s_2, a_1) = 1 $
- $ R(s_2, a_2) = 0 $，$ P(s_1|s_2, a_2) = 1 $

设折扣因子 $ \gamma = 0.9 $，则贝尔曼方程可表示为：

对于状态 $ s_1 $：

$$
V^\pi(s_1) = 0.5 \cdot [5 + 0.9 \cdot V^\pi(s_2)] + 0.5 \cdot [10 + 0.9 \cdot V^\pi(s_2)]
$$

简化后：

$$
V^\pi(s_1) = 7.5 + 0.9 \cdot V^\pi(s_2)
$$

对于状态 $ s_2 $：

$$
V^\pi(s_2) = 0.5 \cdot [0 + 0.9 \cdot V^\pi(s_1)] + 0.5 \cdot [0 + 0.9 \cdot V^\pi(s_1)]
$$

简化后：

$$
V^\pi(s_2) = 0.9 \cdot V^\pi(s_1)
$$

$$
V^\pi(s_1) = 0.5 \left[ 5 + 0.9 V^\pi(s_2) \right] + 0.5 \left[ 10 + 0.9 V^\pi(s_2) \right]
$$

$$
V^\pi(s_2) = 0.5 \left[ 0 + 0.9 V^\pi(s_1) \right] + 0.5 \left[ 0 + 0.9 V^\pi(s_1) \right] = 0.9 V^\pi(s_1)
$$

通过联立方程，可以解得：

$$
V^\pi(s_1) = 0.5 \times 5 + 0.5 \times 10 + 0.9 \times 0.9 V^\pi(s_1)
$$

$$
V^\pi(s_1) = 2.5 + 5 + 0.81 V^\pi(s_1)
$$

$$
V^\pi(s_1) - 0.81 V^\pi(s_1) = 7.5
$$

$$
0.19 V^\pi(s_1) = 7.5 \Rightarrow V^\pi(s_1) = 39.47
$$

$$
V^\pi(s_2) = 0.9 \times 39.47 = 35.52
$$

---
## 动作价值函数的贝尔曼方程

### 定义

动作价值函数 $Q^\pi(s, a)$ 表示在策略 $\pi$ 下，从状态 $s$ 开始，采取动作 $a$ 后所能获得的期望累积奖励。贝尔曼方程为动作价值函数提供了一种递归的计算方法。

### 贝尔曼方程

动作价值函数的贝尔曼方程定义如下：

$$
Q^\pi(s, a) = R(s, a) + \gamma \sum_{s' \in S} P(s'|s, a) \sum_{a' \in A} \pi(a'|s') Q^\pi(s', a')
$$

### 公式解析

- **$Q^\pi(s, a)$**：在策略 $\pi$ 下，状态 $s$ 采取动作 $a$ 后的价值，即从 $s$ 开始，首先采取动作 $a$，然后遵循策略 $\pi$ 所能获得的期望累积奖励。
- **$R(s, a)$**：在状态 $s$ 下采取动作 $a$ 所获得的即时奖励。
- **$\gamma$**：折扣因子，介于 0 和 1 之间，用于衡量未来奖励的重要性。
- **$\sum_{s' \in S} P(s'|s, a)$**：在状态 $s$ 下采取动作 $a$ 后，转移到下一个状态 $s'$ 的概率。
- **$\sum_{a' \in A} \pi(a'|s') Q^\pi(s', a')$**：在新状态 $s'$ 下，按照策略 $\pi$ 选择动作 $a'$ 并获得相应价值的期望值。

### 直观理解

贝尔曼方程表明，动作 $a$ 在状态 $s$ 下的价值等于：

1. **即时奖励 $R(s, a)$**：执行动作 $a$ 后立即获得的奖励。
2. **未来价值 $\gamma \sum_{s'} P(s'|s, a) \sum_{a'} \pi(a'|s') Q^\pi(s', a')$**：执行动作 $a$ 后，转移到下一个状态 $s'$，并按照策略 $\pi$ 继续行动，所能获得的折扣累积奖励的期望值。

### 示例

继续使用前面的迷宫环境示例，状态空间 $S = \{s_1, s_2\}$，动作空间 $A = \{a_1, a_2\}$，策略 $\pi$ 均匀随机选择动作，即 $\pi(a_1|s) = \pi(a_2|s) = 0.5$。

贝尔曼方程为动作价值函数：

$$
Q^\pi(s_1, a_1) = 5 + 0.9 \times \sum_{s'} P(s'|s_1, a_1) \sum_{a'} \pi(a'|s') Q^\pi(s', a')
$$

$$
Q^\pi(s_1, a_1) = 5 + 0.9 \times 1 \times \left[ 0.5 Q^\pi(s_2, a_1) + 0.5 Q^\pi(s_2, a_2) \right]
$$

$$
Q^\pi(s_1, a_2) = 10 + 0.9 \times 1 \times \left[ 0.5 Q^\pi(s_2, a_1) + 0.5 Q^\pi(s_2, a_2) \right]
$$

$$
Q^\pi(s_2, a_1) = 0 + 0.9 \times 1 \times \left[ 0.5 Q^\pi(s_1, a_1) + 0.5 Q^\pi(s_1, a_2) \right]
$$

$$
Q^\pi(s_2, a_2) = 0 + 0.9 \times 1 \times \left[ 0.5 Q^\pi(s_1, a_1) + 0.5 Q^\pi(s_1, a_2) \right]
$$

通过联立上述方程，可以求解 $Q^\pi(s, a)$ 的值。

---

## 状态价值函数与动作价值函数的关系

贝尔曼方程展示了状态价值函数和动作价值函数之间的内在联系。具体而言：

- **状态价值函数** 是在给定策略 $\pi$ 下，对状态的期望价值评估，它是动作价值函数的加权和：

$$
V^\pi(s) = \sum_{a \in A} \pi(a|s) Q^\pi(s, a)
$$

- **动作价值函数** 提供了在特定状态下采取特定动作的期望价值评估，可以看作是对状态价值函数的进一步细化。

这种关系使得我们可以通过优化动作价值函数来间接优化状态价值函数，进而优化策略 $\pi$。

### 最优价值函数与最优策略

- **最优状态价值函数**：

  $$
  V^*(s) = \max_\pi V^\pi(s)
  $$

- **最优动作价值函数**：

  $$
  Q^*(s, a) = \max_\pi Q^\pi(s, a)
  $$

最优策略 $\pi^*$ 满足：

$$
\pi^*(s) = \arg\max_a Q^*(s, a)
$$

## 强化学习的关键算法

### 动态规划（Dynamic Programming）

动态规划利用贝尔曼方程，通过迭代计算价值函数和策略，适用于已知环境模型的情况。



### 蒙特卡洛方法（Monte Carlo Methods）

蒙特卡洛方法基于模拟多个完整的序列（Episode），通过平均化累积奖励来估计价值函数。

### 时序差分学习（Temporal Difference Learning）

时序差分结合了动态规划和蒙特卡洛方法的特点，通过单步更新来估计价值函数。

- **TD(0) 更新规则**：

  $$
  V(S_t) \leftarrow V(S_t) + \alpha [R_{t+1} + \gamma V(S_{t+1}) - V(S_t)]
  $$

## 深度强化学习与损失函数

### 深度Q网络（Deep Q-Network, DQN）

DQN 使用神经网络近似 Q 函数，解决了高维状态空间下的 Q 学习问题。

### 损失函数的定义

在深度强化学习中，损失函数用于衡量当前 Q 网络与目标 Q 网络之间的差距，从而指导网络参数的更新。

- **DQN 的均方误差损失函数**：

  $$
  L(\theta) = \mathbb{E}_{(s,a,r,s') \sim \mathcal{D}} \left[ \left( y - Q(s, a; \theta) \right)^2 \right]
  $$

  其中，目标值 $y$ 定义为：

  $$
  y = r + \gamma \max_{a'} Q(s', a'; \theta^-)
  $$

  - $\theta$：当前 Q 网络的参数。
  - $\theta^-$：目标 Q 网络的参数，定期更新为 $\theta$ 的副本。
  - $\mathcal{D}$：经验回放缓冲区，存储过往的交互数据。

### 改进的损失函数

- **双重 DQN（Double DQN）**：

  解决 DQN 中的过度估计问题，损失函数的目标值修改为：

  $$
  y = r + \gamma Q(s', \arg\max_{a'} Q(s', a'; \theta); \theta^-)
  $$

- **优先经验回放（Prioritized Experience Replay）**：

  根据 TD 误差对样本进行加权，提高学习效率。

- **策略梯度方法的损失函数**：

  在策略梯度方法中，优化的目标是最大化策略的期望回报，其损失函数通常定义为负的期望回报：

  $$
  L(\theta) = -\mathbb{E}_{\pi_\theta} \left[ \sum_{t=0}^{\infty} \gamma^t R_{t+1} \right]
  $$

  使用梯度上升更新参数：

  $$
  \theta \leftarrow \theta + \alpha \nabla_\theta L(\theta)
  $$

### 损失函数代码实现

以下是 DQN 损失函数的 PyTorch 实现示例，包含了双重 DQN 的改进：

```python
import torch
import torch.nn as nn
import torch.optim as optim

# 假设 Q 网络和目标网络已经定义
policy_net = QNetwork(state_size, action_size)
target_net = QNetwork(state_size, action_size)
optimizer = optim.Adam(policy_net.parameters(), lr=1e-3)
criterion = nn.MSELoss()

def compute_loss(batch, gamma):
    states, actions, rewards, next_states, dones = batch

    # 当前 Q 值
    q_values = policy_net(states).gather(1, actions.unsqueeze(1)).squeeze(1)

    # 使用策略网络选择下一个动作
    next_actions = policy_net(next_states).max(1)[1].unsqueeze(1)
    # 使用目标网络评估下一个状态的 Q 值
    next_q_values = target_net(next_states).gather(1, next_actions).squeeze(1)

    # 目标 Q 值
    target_q_values = rewards + gamma * next_q_values * (1 - dones)

    # 计算损失
    loss = criterion(q_values, target_q_values.detach())
    return loss

# 训练步骤示例
def train_step(batch, gamma):
    optimizer.zero_grad()
    loss = compute_loss(batch, gamma)
    loss.backward()
    optimizer.step()
```

## 马尔可夫链详解

### 马尔可夫链（Markov Chain）

马尔可夫链是最简单的马尔可夫过程，状态和转移概率构成了整个过程，没有奖励和动作的概念。其定义为二元组 $\langle S, P \rangle$，其中：

- $S$：有限的状态空间。
- $P$：状态转移概率矩阵，$P(s'|s)$ 表示从状态 $s$ 转移到状态 $s'$ 的概率。

### 马尔可夫性质

马尔可夫链满足无记忆性，即未来状态只依赖于当前状态，与过去的状态无关。

### 状态转移矩阵

状态转移矩阵 $P$ 是一个 $|S| \times |S|$ 的矩阵，元素 $P_{ij}$ 表示从状态 $s_i$ 转移到状态 $s_j$ 的概率。

### 应用

马尔可夫链被广泛应用于随机过程的建模，如天气预测、股市分析和页面排名算法（如 PageRank）。

## 强化学习在游戏中的应用

### AlphaGo

由 DeepMind 开发的 AlphaGo 通过结合深度神经网络和蒙特卡洛树搜索，成功击败了世界顶级围棋选手。其主要技术亮点包括：

- **策略网络**：预测下一步最有可能的动作。
- **价值网络**：评估当前局面的胜率。
- **自我对弈**：通过与自身对弈生成大量高质量数据。

### OpenAI Five

OpenAI Five 是一个能够在《Dota 2》中与人类专业玩家对抗的 AI 系统。其特点包括：

- **多智能体协作**：需要五个智能体协同作战。
- **长时间序列决策**：游戏时间长，状态空间巨大。
- **策略优化**：使用了 PPO（Proximal Policy Optimization）算法。

### Atari 游戏

DeepMind 使用 DQN 在多款 Atari 2600 游戏中达到了超越人类的表现。关键技术包括：

- **像素输入**：直接从原始像素图像学习。
- **经验回放**：打破数据相关性，提升学习稳定性。
- **目标网络**：稳定 Q 值的估计，防止震荡。

## 参考资料

- [Richard S. Sutton 和 Andrew G. Barto 著作《强化学习：导论》](http://incompleteideas.net/book/the-book.html)
- [DeepMind 强化学习论文](https://www.deepmind.com/research)
- [OpenAI 强化学习资源](https://openai.com/research/)

## 结论

强化学习作为机器学习的重要分支，融合了控制理论、神经网络和优化等多个领域的知识。通过对马尔可夫决策过程、价值函数和策略的深入理解，结合深度学习技术，强化学习在游戏、机器人控制和自动驾驶等领域取得了显著成果。希望本文能帮助读者全面了解强化学习的核心概念和前沿应用，激发进一步探索的兴趣。

# 参考代码

以下是一个基于策略梯度方法的强化学习算法（REINFORCE）的实现示例：

```python
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

class PolicyNetwork(nn.Module):
    def __init__(self, state_size, action_size):
        super(PolicyNetwork, self).__init__()
        self.fc1 = nn.Linear(state_size, 128)
        self.fc2 = nn.Linear(128, action_size)
    
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.softmax(self.fc2(x), dim=1)
        return x

policy_net = PolicyNetwork(state_size, action_size)
optimizer = optim.Adam(policy_net.parameters(), lr=1e-3)

def select_action(state):
    state = torch.from_numpy(state).float().unsqueeze(0)
    probs = policy_net(state)
    m = torch.distributions.Categorical(probs)
    action = m.sample()
    return action.item(), m.log_prob(action)

# 存储一次完整的回合
saved_log_probs = []
rewards = []

def finish_episode(gamma):
    R = 0
    policy_loss = []
    returns = []
    # 计算折扣回报
    for r in rewards[::-1]:
        R = r + gamma * R
        returns.insert(0, R)
    returns = torch.tensor(returns)
    # 标准化
    returns = (returns - returns.mean()) / (returns.std() + 1e-5)
    # 计算损失
    for log_prob, R in zip(saved_log_probs, returns):
        policy_loss.append(-log_prob * R)
    optimizer.zero_grad()
    policy_loss = torch.cat(policy_loss).sum()
    policy_loss.backward()
    optimizer.step()
    # 清空存储
    del rewards[:]
    del saved_log_probs[:]
```

【深度学习】强化学习介绍

# 深入了解磁盘使用分析工具：`dust`、`dua` 与 `ncdu`

在日常的系统管理和开发工作中，了解和管理磁盘空间的使用情况至关重要。随着项目的不断增长，磁盘空间可能会迅速被各种文件和目录占据，导致系统性能下降或存储不足。为了有效监控和优化磁盘使用，众多工具应运而生，其中最受欢迎的包括 `dust`、`dua` 和 `ncdu`。本文将详细介绍这三个工具，分析它们的特点和优势，帮助您选择最适合自己需求的磁盘使用分析工具。







## 工具概览

### `dust`

- **语言**：Rust
- **类型**：命令行工具
- **简介**：`dust` 是一个用 Rust 编写的 `du` 命令替代工具，旨在提供更高性能和更友好的输出格式。它通过并行处理加快了目录扫描速度，并以人类可读的格式显示结果，适合快速获取目录大小。

### `dua` (Disk Usage Analyzer)

- **语言**：Rust
- **类型**：命令行工具
- **简介**：`dua` 是一个高性能的磁盘使用分析工具，优化了扫描速度并提供了丰富的功能，如过滤、排序和多种输出格式。适合需要深入分析磁盘使用情况的用户。

### `ncdu`

- **语言**：C
- **类型**：交互式文本用户界面 (TUI) 工具
- **简介**：`ncdu` 是一个广受欢迎的交互式磁盘使用分析工具，允许用户通过键盘导航、浏览目录结构并管理文件。虽然性能不及 `dust` 和 `dua`，但其直观的界面和文件管理功能使其成为许多用户的首选。

## 功能对比

| 特性 / 工具        | `dust`                             | `dua`                              | `ncdu`                             |
|--------------------|------------------------------------|------------------------------------|------------------------------------|
| **性能**           | 非常高，适合大规模文件系统         | 极高，优化扫描速度                 | 较高，但不及 `dust` 和 `dua`        |
| **输出格式**       | 人类可读，树状图                   | 多种格式（如 JSON），可定制化       | 交互式文本界面                      |
| **交互性**         | 命令行输出，适合脚本化使用         | 命令行输出，适合集成和自动化任务   | 高度交互，支持浏览和管理            |
| **功能丰富度**     | 基本的磁盘使用分析                 | 丰富的过滤、排序和统计功能         | 文件浏览、删除等管理功能            |
| **易用性**         | 简单易用，命令直观                 | 功能强大但可能需要更多学习         | 直观的交互界面，易于上手            |
| **安装与依赖**     | Rust 编译的二进制文件，轻量         | Rust 编译的二进制文件，轻量         | 基于 C，广泛可用，安装简单          |
| **适用场景**       | 快速扫描和脚本化任务               | 深入分析和集成自动化任务           | 交互式管理和清理磁盘空间            |

## 各工具的优势

### `dust` 的优势

- **速度快**：利用 Rust 的高性能，`dust` 在扫描大规模文件系统时表现尤为出色，比传统的 `du` 更加高效。
- **输出友好**：默认以人类可读的格式显示，并使用树状图增强可读性，适合快速查看目录大小。
- **轻量级**：安装和使用简单，非常适合需要快速获取磁盘使用情况的场景。
- **并行处理**：支持并行计算，提高了处理速度，特别是在多核处理器上。

### `dua` 的优势

- **极高的性能**：通过优化算法，实现了比 `dust` 更快的扫描速度，适合极大文件系统的深入分析。
- **丰富的功能**：支持多种过滤和排序选项，可以根据文件类型、大小、修改时间等多维度进行分析。
- **多样的输出格式**：支持 JSON 输出，方便与其他工具集成或进行进一步的数据处理。
- **详细统计信息**：提供更全面的磁盘使用统计，适合需要深入了解磁盘使用情况的高级用户。

### `ncdu` 的优势

- **交互式界面**：提供直观的文本用户界面，用户可以通过键盘导航，浏览目录结构，查看和管理文件。
- **文件管理功能**：允许用户直接在工具中删除不需要的文件或目录，简化了磁盘清理过程。
- **广泛的兼容性**：基于 C 编写，几乎可以在所有 Unix-like 系统上运行，安装简单。
- **稳定性和成熟度**：作为一个长期存在的工具，`ncdu` 拥有稳定的性能和广泛的社区支持。

## 适用场景推荐

### 使用 `dust` 的场景

- **快速扫描**：需要快速获取当前目录或大规模文件系统的磁盘使用情况。
- **脚本化任务**：需要将磁盘使用分析集成到自动化脚本或系统监控中。
- **轻量级需求**：不需要复杂的交互或深入的分析，只需简洁的输出。

### 使用 `dua` 的场景

- **深入分析**：需要详细的磁盘使用统计信息，多维度的过滤和排序。
- **集成与自动化**：需要将磁盘使用数据与其他工具或系统集成，利用其多样的输出格式。
- **处理极大文件系统**：面对极大规模的文件系统，`dua` 提供更优的性能和功能。

### 使用 `ncdu` 的场景

- **交互式管理**：需要通过交互界面浏览和管理文件系统，方便进行磁盘清理。
- **用户友好**：适合不熟悉命令行复杂选项的用户，通过简单的键盘操作完成任务。
- **稳定性需求**：需要一个成熟稳定的工具，适用于各种 Unix-like 系统环境。

## 安装与使用指南

### 安装 `dust`

#### 通过 `.deb` 包安装（适用于 Ubuntu 22）

1. **下载 `.deb` 包**  
   假设您已经下载了 `du-dust_1.1.1-1_amd64.deb`。

2. **安装 `.deb` 包**  
   打开终端，导航到下载目录并执行安装：
   ```bash
   cd ~/Downloads
   sudo apt update
   sudo apt install ./du-dust_1.1.1-1_amd64.deb
   ```

3. **验证安装**
   ```bash
   /usr/bin/dust --version
   ```
   应显示类似于 `dust 1.1.1` 的版本信息。

#### 通过 Cargo 安装（适用于有 Rust 环境的用户）

1. **安装 Rust 和 Cargo**
   ```bash
   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   source $HOME/.cargo/env
   ```

2. **使用 Cargo 安装 `dust`**
   ```bash
   cargo install dust
   ```

3. **确保 Cargo 的 bin 目录在 PATH 中**
   ```bash
   echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc
   source ~/.bashrc
   ```

4. **验证安装**
   ```bash
   dust --version
   ```

### 安装 `dua`

#### 通过预编译的二进制文件安装

1. **下载最新版本**
   访问 [dua-cli Releases 页面](https://github.com/Byron/dua-cli/releases) 并下载适用于 Linux 的最新版本，例如 `dua-linux-amd64.tar.gz`。

2. **解压并移动到 PATH**
   ```bash
   wget https://github.com/Byron/dua-cli/releases/download/v1.4.0/dua-linux-amd64.tar.gz
   tar -xzf dua-linux-amd64.tar.gz
   sudo mv dua /usr/local/bin/
   ```

3. **验证安装**
   ```bash
   dua --version
   ```

#### 通过 Cargo 安装

1. **安装 Rust 和 Cargo（如上）**

2. **使用 Cargo 安装 `dua`**
   ```bash
   cargo install dua-cli
   ```

3. **确保 Cargo 的 bin 目录在 PATH 中（如上）**

4. **验证安装**
   ```bash
   dua --version
   ```

### 安装 `ncdu`

#### 通过包管理器安装（适用于 Ubuntu 22）

1. **更新包列表并安装 `ncdu`**
   ```bash
   sudo apt update
   sudo apt install ncdu
   ```

2. **验证安装**
   ```bash
   ncdu --version
   ```

## 使用示例

### `dust` 的使用

1. **在当前目录下显示磁盘使用情况**
   ```bash
   dust
   ```

2. **限制扫描深度为 1**
   ```bash
   dust --max-depth 1
   ```

3. **指定扫描目录**
   ```bash
   dust /var
   ```

### `dua` 的使用

1. **在当前目录下显示磁盘使用情况**
   ```bash
   dua
   ```

2. **限制扫描深度为 2**
   ```bash
   dua --max-depth 2
   ```

3. **以 JSON 格式输出**
   ```bash
   dua --json
   ```

### `ncdu` 的使用

1. **在根目录启动交互式界面**
   ```bash
   ncdu /
   ```

2. **浏览和管理文件**
   - 使用箭头键导航。
   - 按 `d` 删除选中的文件或目录。
   - 按 `q` 退出。

## 总结

在选择适合自己的磁盘使用分析工具时，了解每个工具的特点和优势至关重要：

- **`dust`**：适合需要快速、简洁地获取磁盘使用情况的用户，尤其适用于脚本化和自动化任务。
- **`dua`**：提供更强大的功能和更高的性能，适合需要深入分析和集成的高级用户。
- **`ncdu`**：以其交互式界面和文件管理功能，成为需要直观管理和清理磁盘空间用户的理想选择。

根据您的具体需求和使用场景，选择最合适的工具可以显著提升工作效率和用户体验。无论是 `dust` 的高性能，`dua` 的丰富功能，还是 `ncdu` 的交互式界面，它们都能在不同的使用场景中发挥出色的作用。希望本文能帮助您更好地理解和选择适合自己的磁盘使用分析工具。

Linux磁盘使用分析工具：dust、dua 与 ncdu

在文本到语音（Text-to-Speech, TTS）系统的开发中，选择合适的音频格式至关重要。不同的音频格式在编码方式、压缩率、音质和用途上各有优劣，直接影响着系统的性能和用户体验。本文将通过解析一个TTS接口中的代码，详细介绍四种常见音频格式——OGG、RAW、WAV和AAC，并探讨它们各自的特点及应用场景。





## 1. OGG（Ogg Vorbis）

### 编码方式
- **有损压缩**：通过去除人耳不易察觉的声音信息，减小文件体积。

### 特点
- **压缩效率高**：相比无损格式（如WAV），OGG文件体积更小。
- **音质优良**：在相同比特率下，OGG通常提供比MP3更好的音质。
- **开源免费**：OGG是开放的、免版权的格式，适合各种应用。

### 用途
适用于需要节省存储空间或带宽，同时保持较高音质的场景，如在线流媒体、游戏音效等。

### 代码实现
使用 `soundfile` 库将音频数据写入 OGG 格式的文件中。

```python
def pack_ogg(io_buffer: BytesIO, data: np.ndarray, rate: int):
    with sf.SoundFile(io_buffer, mode='w', samplerate=rate, channels=1, format='ogg') as audio_file:
        audio_file.write(data)
    return io_buffer
```

## 2. RAW（原始PCM数据）

### 编码方式
- **无压缩**：直接存储原始的PCM（脉冲编码调制）数据。

### 特点
- **文件体积大**：由于不进行压缩，文件体积与音频长度和采样率直接相关。
- **无损音质**：保留了原始音频的全部信息，没有任何损失。
- **高度灵活**：适用于需要对音频数据进行进一步处理或转换的场景。

### 用途
常用于音频处理和分析的中间步骤，或者在对音质要求极高且存储空间充足的情况下使用。

### 代码实现
直接将Numpy数组转换为字节并写入缓冲区。

```python
def pack_raw(io_buffer: BytesIO, data: np.ndarray, rate: int):
    io_buffer.write(data.tobytes())
    return io_buffer
```

## 3. WAV（Waveform Audio File Format）

### 编码方式
- **无压缩或有损压缩**：通常为无压缩的PCM，也可以支持压缩格式。

### 特点
- **广泛支持**：几乎所有音频播放和编辑软件都支持WAV格式。
- **高音质**：无压缩情况下，音质与原始音频一致。
- **文件体积大**：与RAW类似，未压缩的WAV文件体积较大，但相比RAW多了文件头信息。

### 用途
适用于音频编辑、存档和需要高音质的应用场景。

### 代码实现
使用 `soundfile` 库将音频数据写入 WAV 格式的文件中。

```python
def pack_wav(io_buffer: BytesIO, data: np.ndarray, rate: int):
    io_buffer = BytesIO()
    sf.write(io_buffer, data, rate, format='wav')
    return io_buffer
```

## 4. AAC（Advanced Audio Coding）

### 编码方式
- **有损压缩**：通过去除人耳不易察觉的声音信息，减小文件体积。

### 特点
- **高压缩效率**：在较低比特率下，AAC通常比MP3提供更好的音质。
- **广泛应用**：被许多流媒体平台（如YouTube、Apple Music）采用。
- **支持高级功能**：如多声道音频、错误隐藏等。

### 用途
适用于需要高压缩率且保持较高音质的场景，如在线流媒体、移动设备音频播放等。

### 代码实现
使用 `ffmpeg` 通过子进程将原始PCM数据转换为AAC格式。配置了采样率、通道数、比特率等参数，并将输出以ADTS（Audio Data Transport Stream）格式写入缓冲区。

```python
def pack_aac(io_buffer: BytesIO, data: np.ndarray, rate: int):
    process = subprocess.Popen([
        'ffmpeg',
        '-f', 's16le',  # 输入16位有符号小端整数PCM
        '-ar', str(rate),  # 设置采样率
        '-ac', '1',  # 单声道
        '-i', 'pipe:0',  # 从管道读取输入
        '-c:a', 'aac',  # 音频编码器为AAC
        '-b:a', '192k',  # 比特率
        '-vn',  # 不包含视频
        '-f', 'adts',  # 输出AAC数据流格式
        'pipe:1'  # 将输出写入管道
    ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    out, _ = process.communicate(input=data.tobytes())
    io_buffer.write(out)
    return io_buffer
```

## 综合比较

| 格式 | 压缩类型 | 文件大小 | 音质 | 适用场景 |
| --- | --- | --- | --- | --- |
| **OGG** | 有损 | 较小 | 高 | 在线流媒体、游戏音效 |
| **RAW** | 无压缩 | 最大 | 无损 | 音频处理、分析 |
| **WAV** | 无压缩或有损 | 大 | 高（无压缩） | 音频编辑、存档 |
| **AAC** | 有损 | 较小 | 高 | 在线流媒体、移动设备 |

## 选择建议

- **需要高音质且不考虑文件大小**：选择 **WAV** 或 **RAW**。WAV适合广泛的应用和良好的兼容性，而RAW更适合进一步的音频处理。
- **需要在保持较好音质的同时节省存储或带宽**：选择 **OGG** 或 **AAC**。OGG适用于开放且免版权的需求，AAC则在许多流媒体平台上表现优异。
- **进行音频处理或转换**：**RAW** 格式更为灵活，适合作为中间步骤。
- **兼容性和广泛支持**：**WAV** 和 **AAC** 在大多数平台上都有良好支持，适合需要广泛兼容性的应用。

## 结论

在TTS系统中，选择合适的音频格式需要综合考虑音质、文件大小、压缩效率和应用场景。无论是需要高保真音质的音频编辑，还是需要高压缩率的在线流媒体，了解每种格式的特点和适用场景都是至关重要的。通过本文对OGG、RAW、WAV和AAC四种常见音频格式的详细解析，开发者可以根据具体需求，做出最合适的选择，从而优化TTS系统的性能和用户体验。



# 标签

TTS, 音频格式, OGG, RAW, WAV, AAC, 音频处理, 开发者指南

音频格式：OGG、RAW、WAV与AAC的区别

# 如何测试 ONNX Runtime 是否使用了 GPU 进行推理

在使用 `onnxruntime-gpu` 时，我们常常需要确认推理过程中是否使用了 GPU，而不是回退到 CPU。本文将介绍如何创建一个简单的 ONNX 模型，并使用 `onnxruntime-gpu` 进行推理，确保其在 GPU 上运行。我们还会通过一个简单的循环让程序等待，以便我们有时间检查 GPU 的显存占用情况。





### 安装 ONNX Runtime GPU 版

首先，你需要安装 `onnxruntime-gpu`。

我是cuda12.1，我下载这里的whl文件安装了：

https://anaconda.org/search?q=onnxruntime


![image.png](/static/img/fc1c54ca826b3244c2db93078d553cf2.image.webp)


```bash
wget https://aiinfra.pkgs.visualstudio.com/PublicPackages/_apis/packaging/feeds/d3daa2b0-aa56-45ac-8145-2c3dc0661c87/pypi/packages/ort-nightly-gpu/versions/1.17.dev20240118002/ort_nightly_gpu-1.17.0.dev20240118002-cp310-cp310-manylinux_2_28_x86_64.whl/content
mv content ort_nightly_gpu-1.17.0.dev20240118002-cp310-cp310-manylinux_2_28_x86_64.whl
pip install ort_nightly_gpu-1.17.0.dev20240118002-cp310-cp310-manylinux_2_28_x86_64.whl
pip install onnx
```


## 一个测试代码，执行后看显存即可


```python
import onnx
import onnxruntime as ort
import numpy as np
import torch

# 创建一个简单的 ONNX 模型
def create_random_model(input_size, output_size, model_path):
    # 使用 PyTorch 构建一个简单的线性模型
    class SimpleModel(torch.nn.Module):
        def __init__(self):
            super(SimpleModel, self).__init__()
            self.fc = torch.nn.Linear(input_size, output_size)

        def forward(self, x):
            return self.fc(x)

    model = SimpleModel()
    dummy_input = torch.randn(1, input_size)  # 创建一个随机输入
    torch.onnx.export(model, dummy_input, model_path, input_names=['input'], output_names=['output'])

# 创建并保存随机模型
model_path = "random_model.onnx"
input_size = 10  # 输入维度
output_size = 5  # 输出维度
create_random_model(input_size, output_size, model_path)

# 加载 ONNX 模型并使用 onnxruntime 测试是否在 GPU 上运行
def test_onnxruntime_gpu(model_path):
    # 创建会话，使用 GPU 执行提供者
    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
    session = ort.InferenceSession(model_path, providers=providers)

    # 打印当前使用的执行提供者
    print("Execution providers:", session.get_providers())

    # 生成一个随机输入
    input_data = np.random.randn(1, input_size).astype(np.float32)
    inputs = {session.get_inputs()[0].name: input_data}

    # 推理
    result = session.run(None, inputs)

    # 输出结果，确认模型运行成功
    print("Model output:", result)

    # 进入一个循环等待用户输入以退出
    input("模型已加载并运行完毕，按下任意键退出程序...")

# 测试 GPU
test_onnxruntime_gpu(model_path)

```


![image.png](/static/img/64298a4c069a1e81fa87dbfb17517c4b.image.webp)




### 创建一个简单的 ONNX 模型

为了测试，我们将使用 PyTorch 创建一个简单的全连接线性模型，并导出为 ONNX 格式。即使你没有现成的 ONNX 模型，也可以通过这种方式生成一个供测试使用的模型。

这段代码使用 PyTorch 创建了一个线性模型，并生成了一个随机输入。接着，我们使用 `torch.onnx.export()` 将模型保存为 ONNX 格式文件。

### 使用 ONNX Runtime 测试 GPU 推理

接下来，我们使用 `onnxruntime` 来加载这个模型，并进行推理。我们会打印出 ONNX Runtime 当前使用的执行提供者，以确认是否使用了 GPU。


### 解析代码

1. **选择执行提供者**：通过 `providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']` 指定优先使用 GPU 执行。如果没有 GPU 或无法使用 `CUDAExecutionProvider`，则会自动回退到 CPU。
   
2. **确认执行提供者**：通过 `session.get_providers()` 打印当前的执行提供者，能够确认是否成功使用了 GPU。如果输出中包含 `CUDAExecutionProvider`，说明推理正在 GPU 上进行。

3. **随机输入与推理**：我们生成一个随机输入，并通过 `session.run()` 进行推理，结果会打印出来。

4. **等待用户输入**：为了让你有时间检查显存占用情况，程序在推理结束后会进入一个等待状态，直到你按下任意键退出程序。这段时间你可以使用 `nvidia-smi` 命令查看 GPU 的显存使用情况。

### 如何检查 GPU 显存使用情况

在程序运行时，你可以打开一个新的终端窗口，运行以下命令来检查显存占用情况：

```bash
nvidia-smi
```

如果推理过程中显存占用增加，说明 GPU 正在被使用；否则，说明模型可能是在 CPU 上运行。

### 总结

通过这个简单的例子，我们可以轻松测试 ONNX Runtime 是否在 GPU 上运行模型，并通过显存占用情况进一步确认 GPU 是否参与推理。这种方法特别适合在开发环境中快速验证 GPU 的使用情况。

希望这篇博客能帮助你了解如何在 `onnxruntime-gpu` 中测试 GPU 推理，并为你的项目提供参考。如果你有任何问题，欢迎在评论区讨论！

如何测试 ONNX Runtime 是否使用了 GPU 进行推理

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。

Fish Speech 1.4：开源多语言语音合成与克隆解决方案

项目概述

什么是强化学习？

深入了解磁盘使用分析工具：dust、dua 与 ncdu

如何测试 ONNX Runtime 是否使用了 GPU 进行推理

深入了解磁盘使用分析工具：`dust`、`dua` 与 `ncdu`