2023年的深度学习入门指南(24) - 处理音频的大模型 OpenAI Whisper
在这一讲之前,我们所用的大模型都是针对文本的。这一讲我们增加一个新的领域,即音频。我们将介绍OpenAI的Whisper模型,它是一个处理音频的大模型。
Whisper模型的用法
Whisper是OpenAI开源的模型。它的用法非常简单,只要安装好相关的库,就可以直接用命令行来调用了。
安装就一个库:
pip install -U openai-whisper
然后就可以直接用命令行来调用了:
whisper va1.mp3 --language Chinese
我们还可以用model参数来选择模型,比如有10GB以上显存就可以选择使用large模型:
whisper va2.mp3 --model large --language Chinese
默认是small模型。还可以选择tiny, base, medium, large-v1和large-v2.
如果是遇到视频的话,那么就用ffmpeg工具将视频中的音频部分提取出来。
比如我们有一个视频02.vob,我们不知道其音频流格式是什么,我们可以通过ffmpeg命令来查看:
ffmpeg -i 02.vob
我们可以看到下面的信息:
Input #0, mpeg, from '02.VOB':Duration: 00:34:26.64, start: 0.290633, bitrate: 3807 kb/sStream #0:0[0x1bf]: Data: dvd_nav_packetStream #0:1[0x1e0]: Video: mpeg2video (Main), yuv420p(tv, bottom first), 720x576 [SAR 16:15 DAR 4:3], 25 fps, 25 tbr, 90k tbnSide data:cpb: bitrate max/min/avg: 9610000/0/0 buffer size: 1835008 vbv_delay: N/AStream #0:2[0x1c0]: Audio: mp2, 48000 Hz, stereo, s16p, 224 kb/s
从中可以看到,02.vob总时长为 00:34:26.64,起始时间为 0.290633,比特率为 3807 kb/s。这个文件包含三个流:
流 #0:0 是 DVD 导航数据包。
流 #0:1 是视频流,编码格式为 MPEG-2,使用了 YUV420P 颜色空间,分辨率为 720x576 像素,采样宽高比(SAR)为 16:15,显示宽高比(DAR)为 4:3。视频帧率为 25 帧/秒,时间基数(tbn)为 90k。
流 #0:2 是音频流,编码格式为 MP2,采样率为 48000 Hz,立体声,采样位数为 s16p,比特率为 224 kb/s。
既然编码格式为mp2,那么我们就将其保存为mp2格式的音频:
ffmpeg -i 02.VOB -vn -acodec copy 02.mp2
输出如下:
ffmpeg version 6.0-full_build-www.gyan.dev Copyright (c) 2000-2023 the FFmpeg developersbuilt with gcc 12.2.0 (Rev10, Built by MSYS2 project)configuration: --enable-gpl --enable-version3 --enable-static --disable-w32threads --disable-autodetect --enable-fontconfig --enable-iconv --enable-gnutls --enable-libxml2 --enable-gmp --enable-bzlib --enable-lzma --enable-libsnappy --enable-zlib --enable-librist --enable-libsrt --enable-libssh --enable-libzmq --enable-avisynth --enable-libbluray --enable-libcaca --enable-sdl2 --enable-libaribb24 --enable-libdav1d --enable-libdavs2 --enable-libuavs3d --enable-libzvbi --enable-librav1e --enable-libsvtav1 --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxavs2 --enable-libxvid --enable-libaom --enable-libjxl --enable-libopenjpeg --enable-libvpx --enable-mediafoundation --enable-libass --enable-frei0r --enable-libfreetype --enable-libfribidi --enable-liblensfun --enable-libvidstab --enable-libvmaf --enable-libzimg --enable-amf --enable-cuda-llvm --enable-cuvid --enable-ffnvcodec --enable-nvdec --enable-nvenc --enable-d3d11va --enable-dxva2 --enable-libvpl --enable-libshaderc --enable-vulkan --enable-libplacebo --enable-opencl --enable-libcdio --enable-libgme --enable-libmodplug --enable-libopenmpt --enable-libopencore-amrwb --enable-libmp3lame --enable-libshine --enable-libtheora --enable-libtwolame --enable-libvo-amrwbenc --enable-libilbc --enable-libgsm --enable-libopencore-amrnb --enable-libopus --enable-libspeex --enable-libvorbis --enable-ladspa --enable-libbs2b --enable-libflite --enable-libmysofa --enable-librubberband --enable-libsoxr --enable-chromaprintlibavutil 58. 2.100 / 58. 2.100libavcodec 60. 3.100 / 60. 3.100libavformat 60. 3.100 / 60. 3.100libavdevice 60. 1.100 / 60. 1.100libavfilter 9. 3.100 / 9. 3.100libswscale 7. 1.100 / 7. 1.100libswresample 4. 10.100 / 4. 10.100libpostproc 57. 1.100 / 57. 1.100
Input #0, mpeg, from '02.VOB':Duration: 00:34:26.64, start: 0.290633, bitrate: 3807 kb/sStream #0:0[0x1bf]: Data: dvd_nav_packetStream #0:1[0x1e0]: Video: mpeg2video (Main), yuv420p(tv, bottom first), 720x576 [SAR 16:15 DAR 4:3], 25 fps, 25 tbr, 90k tbnSide data:cpb: bitrate max/min/avg: 9610000/0/0 buffer size: 1835008 vbv_delay: N/AStream #0:2[0x1c0]: Audio: mp2, 48000 Hz, stereo, s16p, 224 kb/s
Output #0, mp2, to '02.mp2':Metadata:encoder : Lavf60.3.100Stream #0:0: Audio: mp2, 48000 Hz, stereo, s16p, 224 kb/s
Stream mapping:Stream #0:2 -> #0:0 (copy)
Press [q] to stop, [?] for help
size= 56510kB time=00:34:26.64 bitrate= 224.0kbits/s speed=76.8x
video:0kB audio:56510kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.000000%
最后生成02.mp2。我们不用转码,直接用whisper去处理:
whisper 02.mp2 --model large --language Chinese
默认情况下,whisper会输出5种格式的文本,分别是txt纯文本格式的,vtt(Web Video Text Tracks)字幕格式的,srt - SubRip Subtitle字幕格式的,tsv制表符分隔,以及json格式的。我们可以通过--output_format
来指定。如果全要输出则不用指定,或者指定all.
whisper也可以直接处理wav文件。
我们再看一个从mp4视频中提取aac音频的例子。
我们有一个mp4文件,信息如下:
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '20230801_170327.mp4':Metadata:major_brand : mp42minor_version : 0compatible_brands: mp42isomcreation_time : 2023-08-01T09:03:27.000000ZDuration: 00:01:51.00, start: 0.000000, bitrate: 901 kb/sStream #0:0[0x1](und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(progressive), 1920x1080, 762 kb/s, 25.26 fps, 30 tbr, 10k tbn (default)Metadata:creation_time : 2023-08-01T09:03:27.000000Zvendor_id : [0][0][0][0]encoder : JVT/AVC CodingStream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 135 kb/s (default)Metadata:creation_time : 2023-08-01T09:03:27.000000Zvendor_id : [0][0][0][0]
我们可以知道下面的视频信息:
文件名:‘20230801_170327.mp4’
创建日期:2023年8月1日,UTC时间09:03:27
视频码率:总体码率为901 kb/s
视频长度:1分钟51秒
视频开始时间:从0秒开始
视频流:
编码:h264 (High),这是一种常见的视频编码格式
帧率:大约每秒25.26帧
分辨率:1920x1080,也就是常说的1080p或全高清
码率:762 kb/s
创建日期:2023年8月1日,UTC时间09:03:27
编码器:JVT/AVC Coding
音频流:
编码:aac (LC),这是一种常见的音频编码格式
采样率:44100 Hz,这是CD质量音频的标准采样率
音频通道:立体声
码率:135 kb/s
创建日期:2023年8月1日,UTC时间09:03:27
我们用ffmpeg提取aac音频:
ffmpeg -i 20230801_170327.mp4 -vn -acodec copy 01.aac
输出如下:
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '20230801_170327.mp4':Metadata:major_brand : mp42minor_version : 0compatible_brands: mp42isomcreation_time : 2023-08-01T09:03:27.000000ZDuration: 00:01:51.00, start: 0.000000, bitrate: 901 kb/sStream #0:0[0x1](und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(progressive), 1920x1080, 762 kb/s, 25.26 fps, 30 tbr, 10k tbn (default)Metadata:creation_time : 2023-08-01T09:03:27.000000Zvendor_id : [0][0][0][0]encoder : JVT/AVC CodingStream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 135 kb/s (default)Metadata:creation_time : 2023-08-01T09:03:27.000000Zvendor_id : [0][0][0][0]
Output #0, adts, to '01.aac':Metadata:major_brand : mp42minor_version : 0compatible_brands: mp42isomencoder : Lavf60.3.100Stream #0:0(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 135 kb/s (default)Metadata:creation_time : 2023-08-01T09:03:27.000000Zvendor_id : [0][0][0][0]
Stream mapping:Stream #0:1 -> #0:0 (copy)
Press [q] to stop, [?] for help
size= 1865kB time=00:01:50.94 bitrate= 137.7kbits/s speed=2.84e+03x
video:0kB audio:1833kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 1.782703%
最后,将获取的01.aac文件直接送给Whisper去处理:
whisper 01.aac --model large-v2 --language Chinese --output_format txt
Whisper模型代码分析
虽然从表象上,声音和文本还是非常不同的。但是到了模型这一层,一切又回到了我们熟悉的样子。
首先是层归一化:
class LayerNorm(nn.LayerNorm):def forward(self, x: Tensor) -> Tensor:return super().forward(x.float()).type(x.dtype)
只做了一件事情,就是将泛型的x转成浮点数再前向计算。
再看它的全连接网络,就是PyTorch的线性网络的一个马甲:
class Linear(nn.Linear):def forward(self, x: Tensor) -> Tensor:return F.linear(x,self.weight.to(x.dtype),None if self.bias is None else self.bias.to(x.dtype),)
这段代码定义了一个名为 Linear 的类,它继承自 nn.Linear 类。这个类重写了父类的 forward 方法,该方法接受一个张量 x 作为输入,并返回一个张量作为输出。
在 forward 方法中,首先调用了 F.linear 函数,该函数接受三个参数:输入张量 x,权重矩阵 self.weight.to(x.dtype) 和偏置向量 self.bias.to(x.dtype)。其中,权重矩阵和偏置向量都被转换为与输入张量相同的数据类型。
如果偏置向量为 None,则第三个参数传递的是 None。否则,传递转换后的偏置向量。
然后是对卷积的封装:
class Conv1d(nn.Conv1d):def _conv_forward(self, x: Tensor, weight: Tensor, bias: Optional[Tensor]) -> Tensor:return super()._conv_forward(x, weight.to(x.dtype), None if bias is None else bias.to(x.dtype))
跟上面是一样复刻的,就不多解释了。
接着,熟悉的东西来了,位置嵌入:
def sinusoids(length, channels, max_timescale=10000):"""Returns sinusoids for positional embedding"""assert channels % 2 == 0log_timescale_increment = np.log(max_timescale) / (channels // 2 - 1)inv_timescales = torch.exp(-log_timescale_increment * torch.arange(channels // 2))scaled_time = torch.arange(length)[:, np.newaxis] * inv_timescales[np.newaxis, :]return torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], dim=1)
代码中使用了一个断言语句来确保 channels 是偶数。然后计算出 log_timescale_increment,它表示对数时间尺度的增量。接下来,使用 torch.exp 函数和 torch.arange 函数计算出逆时间尺度 inv_timescales。
然后,代码计算出缩放后的时间 scaled_time,它是一个二维张量,其中每一行都是一个时间序列。最后,使用 torch.cat 函数将缩放后的时间的正弦值和余弦值拼接在一起,并返回结果。
再然后,多头注意力果然就登场了:
class MultiHeadAttention(nn.Module):def __init__(self, n_state: int, n_head: int):super().__init__()self.n_head = n_headself.query = Linear(n_state, n_state)self.key = Linear(n_state, n_state, bias=False)self.value = Linear(n_state, n_state)self.out = Linear(n_state, n_state)def forward(self,x: Tensor,xa: Optional[Tensor] = None,mask: Optional[Tensor] = None,kv_cache: Optional[dict] = None,):q = self.query(x)if kv_cache is None or xa is None or self.key not in kv_cache:# hooks, if installed (i.e. kv_cache is not None), will prepend the cached kv tensors;# otherwise, perform key/value projections for self- or cross-attention as usual.k = self.key(x if xa is None else xa)v = self.value(x if xa is None else xa)else:# for cross-attention, calculate keys and values once and reuse in subsequent calls.k = kv_cache[self.key]v = kv_cache[self.value]wv, qk = self.qkv_attention(q, k, v, mask)return self.out(wv), qkdef qkv_attention(self, q: Tensor, k: Tensor, v: Tensor, mask: Optional[Tensor] = None):n_batch, n_ctx, n_state = q.shapescale = (n_state // self.n_head) ** -0.25q = q.view(*q.shape[:2], self.n_head, -1).permute(0, 2, 1, 3) * scalek = k.view(*k.shape[:2], self.n_head, -1).permute(0, 2, 3, 1) * scalev = v.view(*v.shape[:2], self.n_head, -1).permute(0, 2, 1, 3)qk = q @ kif mask is not None:qk = qk + mask[:n_ctx, :n_ctx]qk = qk.float()w = F.softmax(qk, dim=-1).to(q.dtype)return (w @ v).permute(0, 2, 1, 3).flatten(start_dim=2), qk.detach()
看了这么多版的多头注意力,这个就不用多解释了吧。
然后是将多头注意力封装为残差块。如果不记得什么是残差块的,我们复习一下结构图:
class ResidualAttentionBlock(nn.Module):def __init__(self, n_state: int, n_head: int, cross_attention: bool = False):super().__init__()self.attn = MultiHeadAttention(n_state, n_head)self.attn_ln = LayerNorm(n_state)self.cross_attn = (MultiHeadAttention(n_state, n_head) if cross_attention else None)self.cross_attn_ln = LayerNorm(n_state) if cross_attention else Nonen_mlp = n_state * 4self.mlp = nn.Sequential(Linear(n_state, n_mlp), nn.GELU(), Linear(n_mlp, n_state))self.mlp_ln = LayerNorm(n_state)def forward(self,x: Tensor,xa: Optional[Tensor] = None,mask: Optional[Tensor] = None,kv_cache: Optional[dict] = None,):x = x + self.attn(self.attn_ln(x), mask=mask, kv_cache=kv_cache)[0]if self.cross_attn:x = x + self.cross_attn(self.cross_attn_ln(x), xa, kv_cache=kv_cache)[0]x = x + self.mlp(self.mlp_ln(x))return x
Whisper的编码器,编进来的是语音:
class AudioEncoder(nn.Module):def __init__(self, n_mels: int, n_ctx: int, n_state: int, n_head: int, n_layer: int):super().__init__()self.conv1 = Conv1d(n_mels, n_state, kernel_size=3, padding=1)self.conv2 = Conv1d(n_state, n_state, kernel_size=3, stride=2, padding=1)self.register_buffer("positional_embedding", sinusoids(n_ctx, n_state))self.blocks: Iterable[ResidualAttentionBlock] = nn.ModuleList([ResidualAttentionBlock(n_state, n_head) for _ in range(n_layer)])self.ln_post = LayerNorm(n_state)def forward(self, x: Tensor):"""x : torch.Tensor, shape = (batch_size, n_mels, n_ctx)the mel spectrogram of the audio"""x = F.gelu(self.conv1(x))x = F.gelu(self.conv2(x))x = x.permute(0, 2, 1)assert x.shape[1:] == self.positional_embedding.shape, "incorrect audio shape"x = (x + self.positional_embedding).to(x.dtype)for block in self.blocks:x = block(x)x = self.ln_post(x)return x
编码器这边,初始化了2个卷积层conv1和conv2,用于降维和下采样语音数据。
然后初始化了一个positional_embedding,这是个位置编码,用来表示时间步信息。
再初始化了多个残差自注意力模块ResidualAttentionBlock,把编码通过自注意力块传递。
forward过程:
- 将语音数据传入conv1、conv2提取特征
- 加上positional_embedding表示时间步
- 传入自注意力ResidualAttentionBlock
- LayerNorm归一化
- 输出编码结果
而解码器是输出的文本,就没有卷积网络什么事儿了,就是残差多头注意力块:
class TextDecoder(nn.Module):def __init__(self, n_vocab: int, n_ctx: int, n_state: int, n_head: int, n_layer: int):super().__init__()self.token_embedding = nn.Embedding(n_vocab, n_state)self.positional_embedding = nn.Parameter(torch.empty(n_ctx, n_state))self.blocks: Iterable[ResidualAttentionBlock] = nn.ModuleList([ResidualAttentionBlock(n_state, n_head, cross_attention=True)for _ in range(n_layer)])self.ln = LayerNorm(n_state)mask = torch.empty(n_ctx, n_ctx).fill_(-np.inf).triu_(1)self.register_buffer("mask", mask, persistent=False)def forward(self, x: Tensor, xa: Tensor, kv_cache: Optional[dict] = None):"""x : torch.LongTensor, shape = (batch_size, <= n_ctx)the text tokensxa : torch.Tensor, shape = (batch_size, n_mels, n_audio_ctx)the encoded audio features to be attended on"""offset = next(iter(kv_cache.values())).shape[1] if kv_cache else 0x = (self.token_embedding(x)+ self.positional_embedding[offset : offset + x.shape[-1]])x = x.to(xa.dtype)for block in self.blocks:x = block(x, xa, mask=self.mask, kv_cache=kv_cache)x = self.ln(x)logits = (x @ torch.transpose(self.token_embedding.weight.to(x.dtype), 0, 1)).float()return logits
简而言之,文本解码器由下面几层网络组成:
- 一个将 token 转换为隐藏状态的词嵌入层
- 一个添加位置信息的 positional embedding 层
- 一个由 residual attention blocks 组成的堆栈
- 一个对隐藏状态进行归一化的层 normalization 层
- 一个计算输出 logits 的线性层
最后,将音频编码器与文本解码器组合在一起,就是一个Whipser:
class Whisper(nn.Module):def __init__(self, dims: ModelDimensions):super().__init__()self.dims = dimsself.encoder = AudioEncoder(self.dims.n_mels,self.dims.n_audio_ctx,self.dims.n_audio_state,self.dims.n_audio_head,self.dims.n_audio_layer,)self.decoder = TextDecoder(self.dims.n_vocab,self.dims.n_text_ctx,self.dims.n_text_state,self.dims.n_text_head,self.dims.n_text_layer,)# use the last half layers for alignment by default; see `set_alignment_heads()` belowall_heads = torch.zeros(self.dims.n_text_layer, self.dims.n_text_head, dtype=torch.bool)all_heads[self.dims.n_text_layer // 2 :] = Trueself.register_buffer("alignment_heads", all_heads.to_sparse(), persistent=False)def set_alignment_heads(self, dump: bytes):array = np.frombuffer(gzip.decompress(base64.b85decode(dump)), dtype=bool).copy()mask = torch.from_numpy(array).reshape(self.dims.n_text_layer, self.dims.n_text_head)self.register_buffer("alignment_heads", mask.to_sparse(), persistent=False)def embed_audio(self, mel: torch.Tensor):return self.encoder(mel)def logits(self, tokens: torch.Tensor, audio_features: torch.Tensor):return self.decoder(tokens, audio_features)def forward(self, mel: torch.Tensor, tokens: torch.Tensor) -> Dict[str, torch.Tensor]:return self.decoder(tokens, self.encoder(mel))@propertydef device(self):return next(self.parameters()).device@propertydef is_multilingual(self):return self.dims.n_vocab == 51865def install_kv_cache_hooks(self, cache: Optional[dict] = None):cache = {**cache} if cache is not None else {}hooks = []def save_to_cache(module, _, output):if module not in cache or output.shape[1] > self.dims.n_text_ctx:# save as-is, for the first token or cross attentioncache[module] = outputelse:cache[module] = torch.cat([cache[module], output], dim=1).detach()return cache[module]def install_hooks(layer: nn.Module):if isinstance(layer, MultiHeadAttention):hooks.append(layer.key.register_forward_hook(save_to_cache))hooks.append(layer.value.register_forward_hook(save_to_cache))self.decoder.apply(install_hooks)return cache, hooksdetect_language = detect_language_functiontranscribe = transcribe_functiondecode = decode_function
在 init 方法中,首先初始化了一个 AudioEncoder 对象作为音频编码器,并初始化了一个 TextDecoder 对象作为文本解码器。然后创建了一个全零张量,表示所有的注意力头都不用于对齐。接下来,代码将张量的后一半设置为 True,表示默认使用后一半的注意力头进行对齐。最后,将张量注册为稀疏缓冲区。
接下来是 set_alignment_heads 方法,它接受一个字节串作为输入。这个方法用于设置用于对齐的多头注意力。首先使用 base85 解码和 gzip 解压缩对输入字节串进行处理,然后将其转换为布尔型数组。接下来,使用 torch.from_numpy 函数将数组转换为张量,并调整其形状。最后,将张量注册为稀疏缓冲区。
接下来是 embed_audio 方法,它接受一个声音频谱作为输入,并返回音频编码器的输出。然后是 logits 方法,它接受两个张量作为输入:文本令牌和音频特征。这个方法返回文本解码器的输出。
接下来是 forward 方法,它接受两个张量作为输入:声音频谱和文本令牌。这个方法首先使用音频编码器对声音频谱进行编码,然后将结果传递给文本解码器,并返回结果。
最后是一些属性和方法。其中 device 属性返回模型所在的设备;is_multilingual 属性返回模型是否支持多语言;install_kv_cache_hooks 方法用于安装键值缓存钩子;detect_language、transcribe 和 decode 分别是检测语言、转录和解码的函数。
小结
这是我们首次接触多模态的Transformer模型。其实,除了编码器和解码器跟媒体数据不同而有不同之外,其它用的知识点跟我们之前学习的大模型别无二致。
这也正是大模型能力强大之处。