diff --git a/nb.ipynb b/nb.ipynb index 4005e9c..0403780 100644 --- a/nb.ipynb +++ b/nb.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -12,11 +12,38 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", + " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(' The following content is provided under a Creative Commons license.', 0.5699582919478416)\n" + ] + } + ], + "source": [ + "model = load_model(ff=True, cut_region=(750,1000))\n", + "transcriptions = transcribe(model, 'test_data/5s/out000.wav')\n", + "print(transcriptions)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "tests = [f'out{i:03d}' for i in range(50)]\n", + "tests = [f'out{i:03d}' for i in range(2)]\n", "audio_paths_30 = [f\"test_data/30s/{t}.wav\" for t in tests]\n", "transcript_paths_30 = [f\"test_transcripts_before/30s/{t}.txt\" for t in tests]\n", "audio_paths_5 = [f\"test_data/5s/{t}.wav\" for t in tests]\n", @@ -25,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -52,16 +79,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "\n", "models = {\n", - " \"5s_with_hueristic\": load_model(\"tiny.en\", ff=True),\n", - " \"5s_without_hueristic\": load_model(\"tiny.en\", ff=False),\n", " \"30s_with_hueristic\": load_model(\"tiny.en\", ff=True),\n", " \"30s_without_hueristic\": load_model(\"tiny.en\", ff=False),\n", + " \"5s_without_hueristic\": load_model(\"tiny.en\", ff=False),\n", + " \"5s_with_hueristic\": load_model(\"tiny.en\", ff=True),\n", "}\n", "\n", "metrics = {}" @@ -69,400 +96,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: 5s_with_hueristic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: The following content is provided under a Creative Commons license.\n", - "Reference: The following content is provided under a Creative Commons license.\n", - "Elapsed time: 0.4717s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: Your support will help MIT OpenCourseWare continue to offer high quality educational reasons.\n", - "Reference: Your support will help MIT OpenCourseWare continue to offer high quality educational reasons.\n", - "Elapsed time: 0.5598s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: sources for free. To make a donation or to view additional materials from hundreds of MIT\n", - "Reference: sources for free. To make a donation or to view additional materials from hundreds of MIT\n", - "Elapsed time: 0.7022s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: courses. Visit MIT OpenCourseWare at ocw.mit.\n", - "Reference: courses. Visit MIT OpenCourseWare at ocw.mit.\n", - "Elapsed time: 0.8253s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: So welcome to...\n", - "Reference: So welcome to...\n", - "Elapsed time: 0.5283s\n", - "WER: 0.0000\n", - "\n", - "Model: 5s_without_hueristic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: The following content is provided under a Creative Commons license.\n", - "Reference: The following content is provided under a Creative Commons license.\n", - "Elapsed time: 0.9272s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: Your support will help MIT OpenCourseWare continue to offer high quality educational reasons.\n", - "Reference: Your support will help MIT OpenCourseWare continue to offer high quality educational reasons.\n", - "Elapsed time: 1.0104s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: sources for free. To make a donation or to view additional materials from hundreds of MIT\n", - "Reference: sources for free. To make a donation or to view additional materials from hundreds of MIT\n", - "Elapsed time: 0.8818s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: courses. Visit MIT OpenCourseWare at ocw.mit.\n", - "Reference: courses. Visit MIT OpenCourseWare at ocw.mit.\n", - "Elapsed time: 0.8554s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: So welcome to...\n", - "Reference: So welcome to...\n", - "Elapsed time: 0.7210s\n", - "WER: 0.0000\n", - "\n", - "Model: 30s_with_hueristic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation or to view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at OCW-U-U-U-U. So welcome to 6172. My name is Charles Leiserson, and I am\n", - "Reference: The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation or to view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at ocw.mit.edu. So welcome to 6172. My name is Charles Lyerson, and I am\n", - "Elapsed time: 3.8808s\n", - "WER: 0.0357\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: One of the two lecturers this term, the other is Professor Julian Schun. We're both in EECS and in C-Sale on the seventh floor of the Gates Building. If you don't know it, you are in Performance Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine Engine I want to start today by talking.\n", - "Reference: One of the two lecturers this term, the other is Professor Julian Shun. We're both in EECS and in C-Sale on the seventh floor of the Gates Building. If you don't know it, you are in performance engineering of software systems. So if this is the wrong, if you found yourself in the wrong place, now's the time to exit. I want to start today by\n", - "Elapsed time: 2.5707s\n", - "WER: 0.3788\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: talking a little bit about why we do performance engineering. And then I'll do a little bit of administration. And then sort of dive into sort of a case study that'll give you a good sense of some of the things that we're gonna do during the term. I'll do the course then it's like why should you listen to the administration, right?\n", - "Reference: talking a little bit about why we do performance engineering. And then I'll do a little bit of administration, and then sort of dive into sort of a case study that'll give you a good sense of some of the things that we're gonna do during the term. I put the administration in the middle, because it's like if you don't, from me telling you about the course, you don't wanna do the course, then it's like why should you listen to the administration, right?\n", - "Elapsed time: 2.0687s\n", - "WER: 0.2941\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: It's like. So let's just dive right in, OK? So the first thing to always understand whenever you're doing something is a perspective on what matters and what you're doing. So we're going to study the whole term we're going to do software performance engineer, engineer, and engineer. And we're going to do software performance engineer. And we're going to do software performance engineer. And our theory of the top of what people are interested in when they're building.\n", - "Reference: It's like, so let's just dive right in, okay? So the first thing to always understand whenever you're doing something is a perspective on what matters and what you're doing. So we're going to study the whole term we're going to do software performance engineering. And so this is kind of interesting because it turns out that performance is usually not at the top of what people are interested in when they're building.\n", - "Elapsed time: 18.0839s\n", - "WER: 0.3288\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: software, okay? What are some of the things that are more important than software? Guess I mean performance? Yeah! D Bye Bye. Ed LIne's? Good. Cost. Correctness. Correctness. Continability. You go to your moose, you go to your moose, you go with which you are going to need. For example, we live in a really good place. But what if we live here in a way that very are more important than performance.\n", - "Reference: software. What are some of the things that are more important than software? That's probably then performance. Yeah. Deadlines. Deadlines. Good. Cost. Correctness. Extensibility. Yeah, I'm going to go on and on. I think that you folks could probably make a pretty long list. I made a short list of all the kinds of things that are more important than performance.\n", - "Elapsed time: 17.8002s\n", - "WER: 0.8033\n", - "\n", - "Model: 30s_without_hueristic\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation or to view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at ocw.mit.edu. So welcome to 6172. My name is Charles Lyerson, and I am\n", - "Reference: The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation or to view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at ocw.mit.edu. So welcome to 6172. My name is Charles Lyerson, and I am\n", - "Elapsed time: 2.5369s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: One of the two lecturers this term, the other is Professor Julian Shun. We're both in EECS and in C-Sale on the seventh floor of the Gates Building. If you don't know it, you are in performance engineering of software systems. So if this is the wrong, if you found yourself in the wrong place, now's the time to exit. I want to start today by\n", - "Reference: One of the two lecturers this term, the other is Professor Julian Shun. We're both in EECS and in C-Sale on the seventh floor of the Gates Building. If you don't know it, you are in performance engineering of software systems. So if this is the wrong, if you found yourself in the wrong place, now's the time to exit. I want to start today by\n", - "Elapsed time: 3.0533s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: talking a little bit about why we do performance engineering. And then I'll do a little bit of administration, and then sort of dive into sort of a case study that'll give you a good sense of some of the things that we're gonna do during the term. I put the administration in the middle, because it's like if you don't, from me telling you about the course, you don't wanna do the course, then it's like why should you listen to the administration, right?\n", - "Reference: talking a little bit about why we do performance engineering. And then I'll do a little bit of administration, and then sort of dive into sort of a case study that'll give you a good sense of some of the things that we're gonna do during the term. I put the administration in the middle, because it's like if you don't, from me telling you about the course, you don't wanna do the course, then it's like why should you listen to the administration, right?\n", - "Elapsed time: 3.7026s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: It's like, so let's just dive right in, okay? So the first thing to always understand whenever you're doing something is a perspective on what matters and what you're doing. So we're going to study the whole term we're going to do software performance engineering. And so this is kind of interesting because it turns out that performance is usually not at the top of what people are interested in when they're building.\n", - "Reference: It's like, so let's just dive right in, okay? So the first thing to always understand whenever you're doing something is a perspective on what matters and what you're doing. So we're going to study the whole term we're going to do software performance engineering. And so this is kind of interesting because it turns out that performance is usually not at the top of what people are interested in when they're building.\n", - "Elapsed time: 4.0838s\n", - "WER: 0.0000\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/emm12/repos/whisper/whisper/transcribe.py:132: UserWarning: FP16 is not supported on CPU; using FP32 instead\n", - " warnings.warn(\"FP16 is not supported on CPU; using FP32 instead\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Transcription: software. What are some of the things that are more important than software? That's probably then performance. Yeah. Deadlines. Deadlines. Good. Cost. Correctness. Extensibility. Yeah, I'm going to go on and on. I think that you folks could probably make a pretty long list. I made a short list of all the kinds of things that are more important than performance.\n", - "Reference: software. What are some of the things that are more important than software? That's probably then performance. Yeah. Deadlines. Deadlines. Good. Cost. Correctness. Extensibility. Yeah, I'm going to go on and on. I think that you folks could probably make a pretty long list. I made a short list of all the kinds of things that are more important than performance.\n", - "Elapsed time: 2.4376s\n", - "WER: 0.0000\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "for model_name, model in models.items():\n", " print(f\"Model: {model_name}\")\n", @@ -478,20 +114,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "# bar chart\n", @@ -509,6 +134,34 @@ "plt.show()" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, diff --git a/util.py b/util.py index 7bf292a..87c4a3c 100644 --- a/util.py +++ b/util.py @@ -3,8 +3,8 @@ import whisper from typing import Tuple import matplotlib.pyplot as plt -def load_model(model_name: str = "tiny.en", ff: bool = False) -> whisper.Whisper: - return whisper.load_model(model_name, ext_feature_flag=ff) +def load_model(model_name: str = "tiny.en", ff: bool = False, cut_region=None) -> whisper.Whisper: + return whisper.load_model(model_name, ext_feature_flag=ff, cut_region=cut_region) def transcribe(model: whisper.Whisper, audio_path: str) -> Tuple[str, float]: diff --git a/whisper/__init__.py b/whisper/__init__.py index 00ef358..ad536ed 100644 --- a/whisper/__init__.py +++ b/whisper/__init__.py @@ -106,6 +106,7 @@ def load_model( download_root: str = None, in_memory: bool = False, ext_feature_flag: bool = False, + cut_region: Optional[tuple] = None, ) -> Whisper: """ Load a Whisper ASR model @@ -152,7 +153,7 @@ def load_model( del checkpoint_file dims = ModelDimensions(**checkpoint["dims"]) - model = Whisper(dims, ext_feat_flag=ext_feature_flag) + model = Whisper(dims, ext_feat_flag=ext_feature_flag, cut_region=cut_region) model.load_state_dict(checkpoint["model_state_dict"]) if alignment_heads is not None: diff --git a/whisper/model.py b/whisper/model.py index eb59b44..3d8d51e 100644 --- a/whisper/model.py +++ b/whisper/model.py @@ -180,20 +180,23 @@ class ResidualAttentionBlock(nn.Module): return x class AudioEncoderTokenPruner(): - def __init__(self, n_extension: int): + def __init__(self, n_extension: int, cut_region: Tuple[int, int]): self.n_extension = n_extension - def prune(self, x: Tensor, positional_embedding: Tensor): - audio_length = int((x.shape[1] + 1) // 2) + def prune(self, x: Tensor, positional_embedding: Tensor, cut_region: Tuple[int, int]=[750, 1000]): + # audio_length = int((x.shape[1] + 1) // 2) + # [0-950, -----, 1300-1500] + pos_emb = torch.concat(( - positional_embedding[:audio_length + self.n_extension, :], - positional_embedding[-self.n_extension:, :]), dim=0, + positional_embedding[:cut_region[0], :], + torch.zeros_like(positional_embedding[cut_region[0]:cut_region[1], :], device=x.device), + positional_embedding[cut_region[1]:,:]), dim=0, ) - # extend the x's first dimension by n_extension x = torch.concat(( - x[:, :audio_length + self.n_extension, :], - x[:, -self.n_extension:, :]), dim=1, + x[:, :cut_region[0], :], + torch.zeros_like(x[:, cut_region[0]:cut_region[1], :], device=x.device), + x[:, cut_region[1]:,:]), dim=1, ) x = (x + pos_emb).to(x.dtype) @@ -202,7 +205,7 @@ class AudioEncoderTokenPruner(): class AudioEncoder(nn.Module): def __init__( - self, n_mels: int, n_ctx: int, n_state: int, n_head: int, n_layer: int, ext_feat_flag: bool = False + self, n_mels: int, n_ctx: int, n_state: int, n_head: int, n_layer: int, ext_feat_flag: bool = False, cut_region: Tuple[int, int]=[750, 1000] ): super().__init__() self.conv1 = Conv1d(n_mels, n_state, kernel_size=3, padding=1) @@ -216,7 +219,7 @@ class AudioEncoder(nn.Module): self.ln_post = LayerNorm(n_state) self.ext_feat_flag = ext_feat_flag if ext_feat_flag: - self.token_pruner = AudioEncoderTokenPruner(n_extension=200) + self.token_pruner = AudioEncoderTokenPruner(n_extension=200, cut_region=cut_region) def forward(self, x: Tensor): """ @@ -287,7 +290,7 @@ class TextDecoder(nn.Module): class Whisper(nn.Module): - def __init__(self, dims: ModelDimensions, ext_feat_flag: bool = False): + def __init__(self, dims: ModelDimensions, ext_feat_flag: bool = False, cut_region: Tuple[int, int]=None): super().__init__() self.dims = dims self.encoder = AudioEncoder( @@ -313,6 +316,10 @@ class Whisper(nn.Module): all_heads[self.dims.n_text_layer // 2 :] = True self.register_buffer("alignment_heads", all_heads.to_sparse(), persistent=False) self.ext_feat_flag = ext_feat_flag + self.cut_region = cut_region + + if self.ext_feat_flag and not self.cut_region: + raise ValueError("cut_region must be specified if ext_feat_flag is True") def set_alignment_heads(self, dump: bytes): array = np.frombuffer(