Commit @26cd60a130d50855b0f78df1ca033ec521597497 - yjyoon/whisper_streaming

Dominik Macháček 2023-05-17

model_dir, vad and other updates

@26cd60a130d50855b0f78df1ca033ec521597497

cbd48c2

26cd60a

whisper_online.py

--- whisper_online.py

+++ whisper_online.py


 
 class ASRBase:
 
+    # join transcribe words with this character (" " for whisper_timestamped, "" for faster-whisper because it emits the spaces when neeeded)
     sep = " "
 
-    def __init__(self, modelsize, lan, cache_dir):
+    def __init__(self, lan, modelsize=None, cache_dir=None, model_dir=None):
+        self.transcribe_kargs = {}
         self.original_language = lan 
 
-        self.model = self.load_model(modelsize, cache_dir)
+        self.model = self.load_model(modelsize, cache_dir, model_dir)
 
     def load_model(self, modelsize, cache_dir):
-        raise NotImplemented("mus be implemented in the child class")
+        raise NotImplemented("must be implemented in the child class")
 
     def transcribe(self, audio, init_prompt=""):
-        raise NotImplemented("mus be implemented in the child class")
+        raise NotImplemented("must be implemented in the child class")
+
+    def use_vad(self):
+        raise NotImplemented("must be implemented in the child class")
 
 
 ## requires imports:

         import whisper_timestamped
     """
 
-    def load_model(self, modelsize, cache_dir):
+    def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
+        if model_dir is not None:
+            print("ignoring model_dir, not implemented",file=sys.stderr)
         return whisper.load_model(modelsize, download_root=cache_dir)
 
     def transcribe(self, audio, init_prompt=""):

     def segments_end_ts(self, res):
         return [s["end"] for s in res["segments"]]
 
+    def use_vad(self):
+        raise NotImplemented("Feature use_vad is not implemented for whisper_timestamped backend.")
+
 
 class FasterWhisperASR(ASRBase):
     """Uses faster-whisper library as the backend. Works much faster, appx 4-times (in offline mode). For GPU, it requires installation with a specific CUDNN version.

 
     sep = ""
 
-    def load_model(self, modelsize, cache_dir):
-        # cache_dir is not set, it seemed not working. Default ~/.cache/huggingface/hub is used.
+    def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
+
+        if model_dir is not None:
+            print(f"Loading whisper model from model_dir {model_dir}. modelsize and cache_dir parameters are not used.",file=sys.stderr)
+            model_size_or_path = model_dir
+        elif modelsize is not None:
+            model_size_or_path = modelsize
+        else:
+            raise ValueError("modelsize or model_dir parameter must be set")
+
 
         # this worked fast and reliably on NVIDIA L40
-        model = WhisperModel(modelsize, device="cuda", compute_type="float16")
+        model = WhisperModel(model_size_or_path, device="cuda", compute_type="float16", download_root=cache_dir)
 
         # or run on GPU with INT8
         # tested: the transcripts were different, probably worse than with FP16, and it was slightly (appx 20%) slower

 
         # or run on CPU with INT8
         # tested: works, but slow, appx 10-times than cuda FP16
-        #model = WhisperModel(model_size, device="cpu", compute_type="int8") #, download_root="faster-disk-cache-dir/")
+#        model = WhisperModel(modelsize, device="cpu", compute_type="int8") #, download_root="faster-disk-cache-dir/")
         return model
 
     def transcribe(self, audio, init_prompt=""):
-        wt = False
-        segments, info = self.model.transcribe(audio, language=self.original_language, initial_prompt=init_prompt, beam_size=5, word_timestamps=True, condition_on_previous_text=True)
+        # tested: beam_size=5 is faster and better than 1 (on one 200 second document from En ESIC, min chunk 0.01)
+        segments, info = self.model.transcribe(audio, language=self.original_language, initial_prompt=init_prompt, beam_size=5, word_timestamps=True, condition_on_previous_text=True, **self.transcribe_kargs)
         return list(segments)
 
     def ts_words(self, segments):

 
     def segments_end_ts(self, res):
         return [s.end for s in res]
+
+    def use_vad(self):
+        self.transcribe_kargs["vad_filter"] = True
+
+    def set_translate_task(self):
+        self.transcribe_kargs["task"] = "translate"
 
 
 

             l += len(x)+1
             prompt.append(x)
         non_prompt = self.commited[k:]
-        return " ".join(prompt[::-1]), " ".join(t for _,_,t in non_prompt)
+        return self.asr.sep.join(prompt[::-1]), self.asr.sep.join(t for _,_,t in non_prompt)
 
     def process_iter(self):
         """Runs on the current audio buffer.

 
 ## main:
 
-import argparse
-parser = argparse.ArgumentParser()
-parser.add_argument('audio_path', type=str, help="Filename of 16kHz mono channel wav, on which live streaming is simulated.")
-parser.add_argument('--min-chunk-size', type=float, default=1.0, help='Minimum audio chunk size in seconds. It waits up to this time to do processing. If the processing takes shorter time, it waits, otherwise it processes the whole segment that was received by this time.')
-parser.add_argument('--model', type=str, default='large-v2', help="name of the Whisper model to use (default: large-v2, options: {tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large}")
-parser.add_argument('--model_dir', type=str, default='disk-cache-dir', help="the path where Whisper models are saved (or downloaded to). Default: ./disk-cache-dir")
-parser.add_argument('--lan', '--language', type=str, default='en', help="Language code for transcription, e.g. en,de,cs.")
-parser.add_argument('--start_at', type=float, default=0.0, help='Start processing audio at this time.')
-parser.add_argument('--backend', type=str, default="faster-whisper", choices=["faster-whisper", "whisper_timestamped"],help='Load only this backend for Whisper processing.')
-parser.add_argument('--offline', action="store_true", default=False, help='Offline mode.')
-args = parser.parse_args()
+if __name__ == "__main__":
 
-audio_path = args.audio_path
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('audio_path', type=str, help="Filename of 16kHz mono channel wav, on which live streaming is simulated.")
+    parser.add_argument('--min-chunk-size', type=float, default=1.0, help='Minimum audio chunk size in seconds. It waits up to this time to do processing. If the processing takes shorter time, it waits, otherwise it processes the whole segment that was received by this time.')
+    parser.add_argument('--model', type=str, default='large-v2', choices="tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large".split(","),help="Name size of the Whisper model to use (default: large-v2). The model is automatically downloaded from the model hub if not present in model cache dir.")
+    parser.add_argument('--model_cache_dir', type=str, default=None, help="Overriding the default model cache dir where models downloaded from the hub are saved")
+    parser.add_argument('--model_dir', type=str, default=None, help="Dir where Whisper model.bin and other files are saved. This option overrides --model and --model_cache_dir parameter.")
+    parser.add_argument('--lan', '--language', type=str, default='en', help="Language code for transcription, e.g. en,de,cs.")
+    parser.add_argument('--task', type=str, default='transcribe', choices=["transcribe","translate"],help="Transcribe or translate.")
+    parser.add_argument('--start_at', type=float, default=0.0, help='Start processing audio at this time.')
+    parser.add_argument('--backend', type=str, default="faster-whisper", choices=["faster-whisper", "whisper_timestamped"],help='Load only this backend for Whisper processing.')
+    parser.add_argument('--offline', action="store_true", default=False, help='Offline mode.')
+    parser.add_argument('--vad', action="store_true", default=False, help='Use VAD = voice activity detection, with the default parameters.')
+    args = parser.parse_args()
 
-SAMPLING_RATE = 16000
-duration = len(load_audio(audio_path))/SAMPLING_RATE
-print("Audio duration is: %2.2f seconds" % duration, file=sys.stderr)
+    audio_path = args.audio_path
 
-size = args.model
-language = args.lan
+    SAMPLING_RATE = 16000
+    duration = len(load_audio(audio_path))/SAMPLING_RATE
+    print("Audio duration is: %2.2f seconds" % duration, file=sys.stderr)
 
-t = time.time()
-print(f"Loading Whisper {size} model for {language}...",file=sys.stderr,end=" ",flush=True)
-#asr = WhisperASR(lan=language, modelsize=size)
+    size = args.model
+    language = args.lan
 
-if args.backend == "faster-whisper":
-    from faster_whisper import WhisperModel
-    asr_cls = FasterWhisperASR
-else:
-    import whisper
-    import whisper_timestamped
-#    from whisper_timestamped_model import WhisperTimestampedASR
-    asr_cls = WhisperTimestampedASR
+    t = time.time()
+    print(f"Loading Whisper {size} model for {language}...",file=sys.stderr,end=" ",flush=True)
+    #asr = WhisperASR(lan=language, modelsize=size)
 
-asr = asr_cls(modelsize=size, lan=language, cache_dir=args.model_dir)
-e = time.time()
-print(f"done. It took {round(e-t,2)} seconds.",file=sys.stderr)
-
-
-min_chunk = args.min_chunk_size
-online = OnlineASRProcessor(language,asr,min_chunk)
-
-
-# load the audio into the LRU cache before we start the timer
-a = load_audio_chunk(audio_path,0,1)
-
-# warm up the ASR, because the very first transcribe takes much more time than the other
-asr.transcribe(a)
-
-beg = args.start_at
-start = time.time()-beg
-
-def output_transcript(o):
-    # output format in stdout is like:
-    # 4186.3606 0 1720 Takhle to je
-    # - the first three words are:
-    #    - emission time from beginning of processing, in milliseconds
-    #    - beg and end timestamp of the text segment, as estimated by Whisper model. The timestamps are not accurate, but they're useful anyway
-    # - the next words: segment transcript
-    now = time.time()-start
-    if o[0] is not None:
-        print("%1.4f %1.0f %1.0f %s" % (now*1000, o[0]*1000,o[1]*1000,o[2]),flush=True)
+    if args.backend == "faster-whisper":
+        from faster_whisper import WhisperModel
+        asr_cls = FasterWhisperASR
     else:
-        print(o,file=sys.stderr,flush=True)
+        import whisper
+        import whisper_timestamped
+    #    from whisper_timestamped_model import WhisperTimestampedASR
+        asr_cls = WhisperTimestampedASR
 
-if args.offline: ## offline mode processing (for testing/debugging)
-    a = load_audio(audio_path)
-    online.insert_audio_chunk(a)
-    try:
-        o = online.process_iter()
-    except AssertionError:
-        print("assertion error",file=sys.stderr)
-        pass
-    else:
-        output_transcript(o)
-else: # online = simultaneous mode
-    end = 0
-    while True:
-        now = time.time() - start
-        if now < end+min_chunk:
-            time.sleep(min_chunk+end-now)
-        end = time.time() - start
-        a = load_audio_chunk(audio_path,beg,end)
-        beg = end
+    asr = asr_cls(modelsize=size, lan=language, cache_dir=args.model_cache_dir, model_dir=args.model_dir)
+
+    if args.task == "translate":
+        asr.set_translate_task()
+
+
+    e = time.time()
+    print(f"done. It took {round(e-t,2)} seconds.",file=sys.stderr)
+
+    if args.vad:
+        print("setting VAD filter",file=sys.stderr)
+        asr.use_vad()
+
+    min_chunk = args.min_chunk_size
+    online = OnlineASRProcessor(language,asr,min_chunk)
+
+
+    # load the audio into the LRU cache before we start the timer
+    a = load_audio_chunk(audio_path,0,1)
+
+    # warm up the ASR, because the very first transcribe takes much more time than the other
+    asr.transcribe(a)
+
+    beg = args.start_at
+    start = time.time()-beg
+
+    def output_transcript(o):
+        # output format in stdout is like:
+        # 4186.3606 0 1720 Takhle to je
+        # - the first three words are:
+        #    - emission time from beginning of processing, in milliseconds
+        #    - beg and end timestamp of the text segment, as estimated by Whisper model. The timestamps are not accurate, but they're useful anyway
+        # - the next words: segment transcript
+        now = time.time()-start
+        if o[0] is not None:
+            print("%1.4f %1.0f %1.0f %s" % (now*1000, o[0]*1000,o[1]*1000,o[2]),file=sys.stderr,flush=True)
+            print("%1.4f %1.0f %1.0f %s" % (now*1000, o[0]*1000,o[1]*1000,o[2]),flush=True)
+        else:
+            print(o,file=sys.stderr,flush=True)
+
+    if args.offline: ## offline mode processing (for testing/debugging)
+        a = load_audio(audio_path)
         online.insert_audio_chunk(a)
-
         try:
             o = online.process_iter()
         except AssertionError:

             pass
         else:
             output_transcript(o)
-        now = time.time() - start
-        print(f"## last processed {end:.2f} s, now is {now:.2f}, the latency is {now-end:.2f}",file=sys.stderr)
+    else: # online = simultaneous mode
+        end = 0
+        while True:
+            now = time.time() - start
+            if now < end+min_chunk:
+                time.sleep(min_chunk+end-now)
+            end = time.time() - start
+            a = load_audio_chunk(audio_path,beg,end)
+            beg = end
+            online.insert_audio_chunk(a)
 
-        print(file=sys.stderr,flush=True)
+            try:
+                o = online.process_iter()
+            except AssertionError:
+                print("assertion error",file=sys.stderr)
+                pass
+            else:
+                output_transcript(o)
+            now = time.time() - start
+            print(f"## last processed {end:.2f} s, now is {now:.2f}, the latency is {now-end:.2f}",file=sys.stderr)
 
-        if end >= duration:
-            break
+            print(file=sys.stderr,flush=True)
 
-o = online.finish()
-output_transcript(o)
+            if end >= duration:
+                break
+
+    o = online.finish()
+    output_transcript(o)

Add a comment

Open 0
Closed 0

List

...	...	@@ -22,18 +22,23 @@
22	22
23	23	class ASRBase:
24	24
	25	+ # join transcribe words with this character (" " for whisper_timestamped, "" for faster-whisper because it emits the spaces when neeeded)
25	26	sep = " "
26	27
27		- def __init__(self, modelsize, lan, cache_dir):
	28	+ def __init__(self, lan, modelsize=None, cache_dir=None, model_dir=None):
	29	+ self.transcribe_kargs = {}
28	30	self.original_language = lan
29	31
30		- self.model = self.load_model(modelsize, cache_dir)
	32	+ self.model = self.load_model(modelsize, cache_dir, model_dir)
31	33
32	34	def load_model(self, modelsize, cache_dir):
33		- raise NotImplemented("mus be implemented in the child class")
	35	+ raise NotImplemented("must be implemented in the child class")
34	36
35	37	def transcribe(self, audio, init_prompt=""):
36		- raise NotImplemented("mus be implemented in the child class")
	38	+ raise NotImplemented("must be implemented in the child class")
	39	+
	40	+ def use_vad(self):
	41	+ raise NotImplemented("must be implemented in the child class")
37	42
38	43
39	44	## requires imports:
...	...	@@ -49,7 +54,9 @@
49	54	import whisper_timestamped
50	55	"""
51	56
52		- def load_model(self, modelsize, cache_dir):
	57	+ def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
	58	+ if model_dir is not None:
	59	+ print("ignoring model_dir, not implemented",file=sys.stderr)
53	60	return whisper.load_model(modelsize, download_root=cache_dir)
54	61
55	62	def transcribe(self, audio, init_prompt=""):
...	...	@@ -68,6 +75,9 @@
68	75	def segments_end_ts(self, res):
69	76	return [s["end"] for s in res["segments"]]
70	77
	78	+ def use_vad(self):
	79	+ raise NotImplemented("Feature use_vad is not implemented for whisper_timestamped backend.")
	80	+
71	81
72	82	class FasterWhisperASR(ASRBase):
73	83	"""Uses faster-whisper library as the backend. Works much faster, appx 4-times (in offline mode). For GPU, it requires installation with a specific CUDNN version.
...	...	@@ -78,11 +88,19 @@
78	88
79	89	sep = ""
80	90
81		- def load_model(self, modelsize, cache_dir):
82		- # cache_dir is not set, it seemed not working. Default ~/.cache/huggingface/hub is used.
	91	+ def load_model(self, modelsize=None, cache_dir=None, model_dir=None):
	92	+
	93	+ if model_dir is not None:
	94	+ print(f"Loading whisper model from model_dir {model_dir}. modelsize and cache_dir parameters are not used.",file=sys.stderr)
	95	+ model_size_or_path = model_dir
	96	+ elif modelsize is not None:
	97	+ model_size_or_path = modelsize
	98	+ else:
	99	+ raise ValueError("modelsize or model_dir parameter must be set")
	100	+
83	101
84	102	# this worked fast and reliably on NVIDIA L40
85		- model = WhisperModel(modelsize, device="cuda", compute_type="float16")
	103	+ model = WhisperModel(model_size_or_path, device="cuda", compute_type="float16", download_root=cache_dir)
86	104
87	105	# or run on GPU with INT8
88	106	# tested: the transcripts were different, probably worse than with FP16, and it was slightly (appx 20%) slower
...	...	@@ -90,12 +108,12 @@
90	108
91	109	# or run on CPU with INT8
92	110	# tested: works, but slow, appx 10-times than cuda FP16
93		- #model = WhisperModel(model_size, device="cpu", compute_type="int8") #, download_root="faster-disk-cache-dir/")
	111	+# model = WhisperModel(modelsize, device="cpu", compute_type="int8") #, download_root="faster-disk-cache-dir/")
94	112	return model
95	113
96	114	def transcribe(self, audio, init_prompt=""):
97		- wt = False
98		- segments, info = self.model.transcribe(audio, language=self.original_language, initial_prompt=init_prompt, beam_size=5, word_timestamps=True, condition_on_previous_text=True)
	115	+ # tested: beam_size=5 is faster and better than 1 (on one 200 second document from En ESIC, min chunk 0.01)
	116	+ segments, info = self.model.transcribe(audio, language=self.original_language, initial_prompt=init_prompt, beam_size=5, word_timestamps=True, condition_on_previous_text=True, **self.transcribe_kargs)
99	117	return list(segments)
100	118
101	119	def ts_words(self, segments):
...	...	@@ -110,6 +128,12 @@
110	128
111	129	def segments_end_ts(self, res):
112	130	return [s.end for s in res]
	131	+
	132	+ def use_vad(self):
	133	+ self.transcribe_kargs["vad_filter"] = True
	134	+
	135	+ def set_translate_task(self):
	136	+ self.transcribe_kargs["task"] = "translate"
113	137
114	138
115	139
...	...	@@ -225,7 +249,7 @@
225	249	l += len(x)+1
226	250	prompt.append(x)
227	251	non_prompt = self.commited[k:]
228		- return " ".join(prompt[::-1]), " ".join(t for _,_,t in non_prompt)
	252	+ return self.asr.sep.join(prompt[::-1]), self.asr.sep.join(t for _,_,t in non_prompt)
229	253
230	254	def process_iter(self):
231	255	"""Runs on the current audio buffer.
...	...	@@ -398,92 +422,88 @@
398	422
399	423	## main:
400	424
401		-import argparse
402		-parser = argparse.ArgumentParser()
403		-parser.add_argument('audio_path', type=str, help="Filename of 16kHz mono channel wav, on which live streaming is simulated.")
404		-parser.add_argument('--min-chunk-size', type=float, default=1.0, help='Minimum audio chunk size in seconds. It waits up to this time to do processing. If the processing takes shorter time, it waits, otherwise it processes the whole segment that was received by this time.')
405		-parser.add_argument('--model', type=str, default='large-v2', help="name of the Whisper model to use (default: large-v2, options: {tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large}")
406		-parser.add_argument('--model_dir', type=str, default='disk-cache-dir', help="the path where Whisper models are saved (or downloaded to). Default: ./disk-cache-dir")
407		-parser.add_argument('--lan', '--language', type=str, default='en', help="Language code for transcription, e.g. en,de,cs.")
408		-parser.add_argument('--start_at', type=float, default=0.0, help='Start processing audio at this time.')
409		-parser.add_argument('--backend', type=str, default="faster-whisper", choices=["faster-whisper", "whisper_timestamped"],help='Load only this backend for Whisper processing.')
410		-parser.add_argument('--offline', action="store_true", default=False, help='Offline mode.')
411		-args = parser.parse_args()
	425	+if __name__ == "__main__":
412	426
413		-audio_path = args.audio_path
	427	+ import argparse
	428	+ parser = argparse.ArgumentParser()
	429	+ parser.add_argument('audio_path', type=str, help="Filename of 16kHz mono channel wav, on which live streaming is simulated.")
	430	+ parser.add_argument('--min-chunk-size', type=float, default=1.0, help='Minimum audio chunk size in seconds. It waits up to this time to do processing. If the processing takes shorter time, it waits, otherwise it processes the whole segment that was received by this time.')
	431	+ parser.add_argument('--model', type=str, default='large-v2', choices="tiny.en,tiny,base.en,base,small.en,small,medium.en,medium,large-v1,large-v2,large".split(","),help="Name size of the Whisper model to use (default: large-v2). The model is automatically downloaded from the model hub if not present in model cache dir.")
	432	+ parser.add_argument('--model_cache_dir', type=str, default=None, help="Overriding the default model cache dir where models downloaded from the hub are saved")
	433	+ parser.add_argument('--model_dir', type=str, default=None, help="Dir where Whisper model.bin and other files are saved. This option overrides --model and --model_cache_dir parameter.")
	434	+ parser.add_argument('--lan', '--language', type=str, default='en', help="Language code for transcription, e.g. en,de,cs.")
	435	+ parser.add_argument('--task', type=str, default='transcribe', choices=["transcribe","translate"],help="Transcribe or translate.")
	436	+ parser.add_argument('--start_at', type=float, default=0.0, help='Start processing audio at this time.')
	437	+ parser.add_argument('--backend', type=str, default="faster-whisper", choices=["faster-whisper", "whisper_timestamped"],help='Load only this backend for Whisper processing.')
	438	+ parser.add_argument('--offline', action="store_true", default=False, help='Offline mode.')
	439	+ parser.add_argument('--vad', action="store_true", default=False, help='Use VAD = voice activity detection, with the default parameters.')
	440	+ args = parser.parse_args()
414	441
415		-SAMPLING_RATE = 16000
416		-duration = len(load_audio(audio_path))/SAMPLING_RATE
417		-print("Audio duration is: %2.2f seconds" % duration, file=sys.stderr)
	442	+ audio_path = args.audio_path
418	443
419		-size = args.model
420		-language = args.lan
	444	+ SAMPLING_RATE = 16000
	445	+ duration = len(load_audio(audio_path))/SAMPLING_RATE
	446	+ print("Audio duration is: %2.2f seconds" % duration, file=sys.stderr)
421	447
422		-t = time.time()
423		-print(f"Loading Whisper {size} model for {language}...",file=sys.stderr,end=" ",flush=True)
424		-#asr = WhisperASR(lan=language, modelsize=size)
	448	+ size = args.model
	449	+ language = args.lan
425	450
426		-if args.backend == "faster-whisper":
427		- from faster_whisper import WhisperModel
428		- asr_cls = FasterWhisperASR
429		-else:
430		- import whisper
431		- import whisper_timestamped
432		-# from whisper_timestamped_model import WhisperTimestampedASR
433		- asr_cls = WhisperTimestampedASR
	451	+ t = time.time()
	452	+ print(f"Loading Whisper {size} model for {language}...",file=sys.stderr,end=" ",flush=True)
	453	+ #asr = WhisperASR(lan=language, modelsize=size)
434	454
435		-asr = asr_cls(modelsize=size, lan=language, cache_dir=args.model_dir)
436		-e = time.time()
437		-print(f"done. It took {round(e-t,2)} seconds.",file=sys.stderr)
438		-
439		-
440		-min_chunk = args.min_chunk_size
441		-online = OnlineASRProcessor(language,asr,min_chunk)
442		-
443		-
444		-# load the audio into the LRU cache before we start the timer
445		-a = load_audio_chunk(audio_path,0,1)
446		-
447		-# warm up the ASR, because the very first transcribe takes much more time than the other
448		-asr.transcribe(a)
449		-
450		-beg = args.start_at
451		-start = time.time()-beg
452		-
453		-def output_transcript(o):
454		- # output format in stdout is like:
455		- # 4186.3606 0 1720 Takhle to je
456		- # - the first three words are:
457		- # - emission time from beginning of processing, in milliseconds
458		- # - beg and end timestamp of the text segment, as estimated by Whisper model. The timestamps are not accurate, but they're useful anyway
459		- # - the next words: segment transcript
460		- now = time.time()-start
461		- if o[0] is not None:
462		- print("%1.4f %1.0f %1.0f %s" % (now1000, o[0]1000,o[1]*1000,o[2]),flush=True)
	455	+ if args.backend == "faster-whisper":
	456	+ from faster_whisper import WhisperModel
	457	+ asr_cls = FasterWhisperASR
463	458	else:
464		- print(o,file=sys.stderr,flush=True)
	459	+ import whisper
	460	+ import whisper_timestamped
	461	+ # from whisper_timestamped_model import WhisperTimestampedASR
	462	+ asr_cls = WhisperTimestampedASR
465	463
466		-if args.offline: ## offline mode processing (for testing/debugging)
467		- a = load_audio(audio_path)
468		- online.insert_audio_chunk(a)
469		- try:
470		- o = online.process_iter()
471		- except AssertionError:
472		- print("assertion error",file=sys.stderr)
473		- pass
474		- else:
475		- output_transcript(o)
476		-else: # online = simultaneous mode
477		- end = 0
478		- while True:
479		- now = time.time() - start
480		- if now < end+min_chunk:
481		- time.sleep(min_chunk+end-now)
482		- end = time.time() - start
483		- a = load_audio_chunk(audio_path,beg,end)
484		- beg = end
	464	+ asr = asr_cls(modelsize=size, lan=language, cache_dir=args.model_cache_dir, model_dir=args.model_dir)
	465	+
	466	+ if args.task == "translate":
	467	+ asr.set_translate_task()
	468	+
	469	+
	470	+ e = time.time()
	471	+ print(f"done. It took {round(e-t,2)} seconds.",file=sys.stderr)
	472	+
	473	+ if args.vad:
	474	+ print("setting VAD filter",file=sys.stderr)
	475	+ asr.use_vad()
	476	+
	477	+ min_chunk = args.min_chunk_size
	478	+ online = OnlineASRProcessor(language,asr,min_chunk)
	479	+
	480	+
	481	+ # load the audio into the LRU cache before we start the timer
	482	+ a = load_audio_chunk(audio_path,0,1)
	483	+
	484	+ # warm up the ASR, because the very first transcribe takes much more time than the other
	485	+ asr.transcribe(a)
	486	+
	487	+ beg = args.start_at
	488	+ start = time.time()-beg
	489	+
	490	+ def output_transcript(o):
	491	+ # output format in stdout is like:
	492	+ # 4186.3606 0 1720 Takhle to je
	493	+ # - the first three words are:
	494	+ # - emission time from beginning of processing, in milliseconds
	495	+ # - beg and end timestamp of the text segment, as estimated by Whisper model. The timestamps are not accurate, but they're useful anyway
	496	+ # - the next words: segment transcript
	497	+ now = time.time()-start
	498	+ if o[0] is not None:
	499	+ print("%1.4f %1.0f %1.0f %s" % (now1000, o[0]1000,o[1]*1000,o[2]),file=sys.stderr,flush=True)
	500	+ print("%1.4f %1.0f %1.0f %s" % (now1000, o[0]1000,o[1]*1000,o[2]),flush=True)
	501	+ else:
	502	+ print(o,file=sys.stderr,flush=True)
	503	+
	504	+ if args.offline: ## offline mode processing (for testing/debugging)
	505	+ a = load_audio(audio_path)
485	506	online.insert_audio_chunk(a)
486		-
487	507	try:
488	508	o = online.process_iter()
489	509	except AssertionError:
...	...	@@ -491,13 +511,31 @@
491	511	pass
492	512	else:
493	513	output_transcript(o)
494		- now = time.time() - start
495		- print(f"## last processed {end:.2f} s, now is {now:.2f}, the latency is {now-end:.2f}",file=sys.stderr)
	514	+ else: # online = simultaneous mode
	515	+ end = 0
	516	+ while True:
	517	+ now = time.time() - start
	518	+ if now < end+min_chunk:
	519	+ time.sleep(min_chunk+end-now)
	520	+ end = time.time() - start
	521	+ a = load_audio_chunk(audio_path,beg,end)
	522	+ beg = end
	523	+ online.insert_audio_chunk(a)
496	524
497		- print(file=sys.stderr,flush=True)
	525	+ try:
	526	+ o = online.process_iter()
	527	+ except AssertionError:
	528	+ print("assertion error",file=sys.stderr)
	529	+ pass
	530	+ else:
	531	+ output_transcript(o)
	532	+ now = time.time() - start
	533	+ print(f"## last processed {end:.2f} s, now is {now:.2f}, the latency is {now-end:.2f}",file=sys.stderr)
498	534
499		- if end >= duration:
500		- break
	535	+ print(file=sys.stderr,flush=True)
501	536
502		-o = online.finish()
503		-output_transcript(o)
	537	+ if end >= duration:
	538	+ break
	539	+
	540	+ o = online.finish()
	541	+ output_transcript(o)

Delete comment