Update app.py

app.py

@@ -101,125 +101,125 @@ class App:
             cb_translate = gr.Checkbox(value=whisper_params["is_translate"], label="Translate to English",interactive=True)
             cb_timestamp = gr.Checkbox(value=whisper_params["add_timestamp"], label="Add timestamp to output file",interactive=True, visible=True)
             dd_file_format = gr.Dropdown(choices=["TXT","SRT"], value="TXT", label="Output format", visible=False, info="Output preview format")
-
-        with gr.Accordion("test", open=False, visible=True):
-            with gr.Accordion("test2", open=False, visible=True):
-                cb_diarize = gr.Checkbox(value=diarization_params["is_diarize"], label="Speaker diarization (HuggingFace token required)",interactive=True)
-        
-        with gr.Accordion("Diarization options", open=False, visible=True):
+                
+        with gr.Row():
+            cb_diarize = gr.Checkbox(value=diarization_params["is_diarize"], label="Speaker diarization (HuggingFace token required)",interactive=True)
             tb_hf_token = gr.Text(label="HuggingFace Token", value=diarization_params["hf_token"],
                                   info="This is only needed the first time you download the model. If you already have"
                                        " models, you don't need to enter. To download the model, you must manually go "
                                        "to https://huggingface.co/pyannote/speaker-diarization-3.1 and agree to"
                                        " their requirement.")
-            dd_diarization_device = gr.Dropdown(label="Device",
-                                                choices=self.whisper_inf.diarizer.get_available_device(),
-                                                value=self.whisper_inf.diarizer.get_device())
-                                                
-        with gr.Accordion("Advanced options", open=False):
-            nb_beam_size = gr.Number(label="Beam Size", value=whisper_params["beam_size"], precision=0, interactive=True,
-                                     info="Beam size to use for decoding.")
-            nb_log_prob_threshold = gr.Number(label="Log Probability Threshold", value=whisper_params["log_prob_threshold"], interactive=True,
-                                              info="If the average log probability over sampled tokens is below this value, treat as failed.")
-            nb_no_speech_threshold = gr.Number(label="No Speech Threshold", value=whisper_params["no_speech_threshold"], interactive=True,
-                                               info="If the no speech probability is higher than this value AND the average log probability over sampled tokens is below 'Log Prob Threshold', consider the segment as silent.")
-            dd_compute_type = gr.Dropdown(label="Compute Type", choices=self.whisper_inf.available_compute_types,
-                                          value=self.whisper_inf.current_compute_type, interactive=True,
-                                          allow_custom_value=True,
-                                          info="Select the type of computation to perform.")
-            nb_best_of = gr.Number(label="Best Of", value=whisper_params["best_of"], interactive=True,
-                                   info="Number of candidates when sampling with non-zero temperature.")
-            nb_patience = gr.Number(label="Patience", value=whisper_params["patience"], interactive=True,
-                                    info="Beam search patience factor.")
-            cb_condition_on_previous_text = gr.Checkbox(label="Condition On Previous Text", value=whisper_params["condition_on_previous_text"],
-                                                        interactive=True,
-                                                        info="Condition on previous text during decoding.")
-            sld_prompt_reset_on_temperature = gr.Slider(label="Prompt Reset On Temperature", value=whisper_params["prompt_reset_on_temperature"],
-                                                        minimum=0, maximum=1, step=0.01, interactive=True,
-                                                        info="Resets prompt if temperature is above this value."
-                                                             " Arg has effect only if 'Condition On Previous Text' is True.")
-            tb_initial_prompt = gr.Textbox(label="Initial Prompt", value=None, interactive=True,
-                                           info="Initial prompt to use for decoding.")
-            sd_temperature = gr.Slider(label="Temperature", value=whisper_params["temperature"], minimum=0.0,
-                                       step=0.01, maximum=1.0, interactive=True,
-                                       info="Temperature for sampling. It can be a tuple of temperatures, which will be successively used upon failures according to either `Compression Ratio Threshold` or `Log Prob Threshold`.")
-            nb_compression_ratio_threshold = gr.Number(label="Compression Ratio Threshold", value=whisper_params["compression_ratio_threshold"],
-                                                       interactive=True,
-                                                       info="If the gzip compression ratio is above this value, treat as failed.")
-            nb_chunk_length = gr.Number(label="Chunk Length (s)", value=lambda: whisper_params["chunk_length"],
-                                        precision=0,
-                                        info="The length of audio segments. If it is not None, it will overwrite the default chunk_length of the FeatureExtractor.")
-            with gr.Group(visible=isinstance(self.whisper_inf, FasterWhisperInference)):
-                nb_length_penalty = gr.Number(label="Length Penalty", value=whisper_params["length_penalty"],
-                                              info="Exponential length penalty constant.")
-                nb_repetition_penalty = gr.Number(label="Repetition Penalty", value=whisper_params["repetition_penalty"],
-                                                  info="Penalty applied to the score of previously generated tokens (set > 1 to penalize).")
-                nb_no_repeat_ngram_size = gr.Number(label="No Repeat N-gram Size", value=whisper_params["no_repeat_ngram_size"],
-                                                    precision=0,
-                                                    info="Prevent repetitions of n-grams with this size (set 0 to disable).")
-                tb_prefix = gr.Textbox(label="Prefix", value=lambda: whisper_params["prefix"],
-                                       info="Optional text to provide as a prefix for the first window.")
-                cb_suppress_blank = gr.Checkbox(label="Suppress Blank", value=whisper_params["suppress_blank"],
-                                                info="Suppress blank outputs at the beginning of the sampling.")
-                tb_suppress_tokens = gr.Textbox(label="Suppress Tokens", value=whisper_params["suppress_tokens"],
-                                                info="List of token IDs to suppress. -1 will suppress a default set of symbols as defined in the model config.json file.")
-                nb_max_initial_timestamp = gr.Number(label="Max Initial Timestamp", value=whisper_params["max_initial_timestamp"],
-                                                     info="The initial timestamp cannot be later than this.")
-                cb_word_timestamps = gr.Checkbox(label="Word Timestamps", value=whisper_params["word_timestamps"],
-                                                 info="Extract word-level timestamps using the cross-attention pattern and dynamic time warping, and include the timestamps for each word in each segment.")
-                tb_prepend_punctuations = gr.Textbox(label="Prepend Punctuations", value=whisper_params["prepend_punctuations"],
-                                                     info="If 'Word Timestamps' is True, merge these punctuation symbols with the next word.")
-                tb_append_punctuations = gr.Textbox(label="Append Punctuations", value=whisper_params["append_punctuations"],
-                                                    info="If 'Word Timestamps' is True, merge these punctuation symbols with the previous word.")
-                nb_max_new_tokens = gr.Number(label="Max New Tokens", value=lambda: whisper_params["max_new_tokens"],
-                                              precision=0,
-                                              info="Maximum number of new tokens to generate per-chunk. If not set, the maximum will be set by the default max_length.")
-                nb_hallucination_silence_threshold = gr.Number(label="Hallucination Silence Threshold (sec)",
-                                                               value=lambda: whisper_params["hallucination_silence_threshold"],
-                                                               info="When 'Word Timestamps' is True, skip silent periods longer than this threshold (in seconds) when a possible hallucination is detected.")
-                tb_hotwords = gr.Textbox(label="Hotwords", value=lambda: whisper_params["hotwords"],
-                                         info="Hotwords/hint phrases to provide the model with. Has no effect if prefix is not None.")
-                nb_language_detection_threshold = gr.Number(label="Language Detection Threshold", value=lambda: whisper_params["language_detection_threshold"],
-                                                            info="If the maximum probability of the language tokens is higher than this value, the language is detected.")
-                nb_language_detection_segments = gr.Number(label="Language Detection Segments", value=lambda: whisper_params["language_detection_segments"],
-                                                           precision=0,
-                                                           info="Number of segments to consider for the language detection.")
-            with gr.Group(visible=isinstance(self.whisper_inf, InsanelyFastWhisperInference)):
-                nb_batch_size = gr.Number(label="Batch Size", value=whisper_params["batch_size"], precision=0)
-
-        with gr.Accordion("Background Music Remover Filter", open=False):
-            cb_bgm_separation = gr.Checkbox(label="Enable Background Music Remover Filter", value=uvr_params["is_separate_bgm"],
+
+        with gr.Accordion("Advanced options", open=False, visible=True):
+            with gr.Accordion("Advanced diarization options", open=False, visible=True):    
+                dd_diarization_device = gr.Dropdown(label="Device",
+                                                    choices=self.whisper_inf.diarizer.get_available_device(),
+                                                    value=self.whisper_inf.diarizer.get_device())
+                                                    
+            with gr.Accordion("Advanced processing options", open=False):
+                nb_beam_size = gr.Number(label="Beam Size", value=whisper_params["beam_size"], precision=0, interactive=True,
+                                         info="Beam size to use for decoding.")
+                nb_log_prob_threshold = gr.Number(label="Log Probability Threshold", value=whisper_params["log_prob_threshold"], interactive=True,
+                                                  info="If the average log probability over sampled tokens is below this value, treat as failed.")
+                nb_no_speech_threshold = gr.Number(label="No Speech Threshold", value=whisper_params["no_speech_threshold"], interactive=True,
+                                                   info="If the no speech probability is higher than this value AND the average log probability over sampled tokens is below 'Log Prob Threshold', consider the segment as silent.")
+                dd_compute_type = gr.Dropdown(label="Compute Type", choices=self.whisper_inf.available_compute_types,
+                                              value=self.whisper_inf.current_compute_type, interactive=True,
+                                              allow_custom_value=True,
+                                              info="Select the type of computation to perform.")
+                nb_best_of = gr.Number(label="Best Of", value=whisper_params["best_of"], interactive=True,
+                                       info="Number of candidates when sampling with non-zero temperature.")
+                nb_patience = gr.Number(label="Patience", value=whisper_params["patience"], interactive=True,
+                                        info="Beam search patience factor.")
+                cb_condition_on_previous_text = gr.Checkbox(label="Condition On Previous Text", value=whisper_params["condition_on_previous_text"],
+                                                            interactive=True,
+                                                            info="Condition on previous text during decoding.")
+                sld_prompt_reset_on_temperature = gr.Slider(label="Prompt Reset On Temperature", value=whisper_params["prompt_reset_on_temperature"],
+                                                            minimum=0, maximum=1, step=0.01, interactive=True,
+                                                            info="Resets prompt if temperature is above this value."
+                                                                 " Arg has effect only if 'Condition On Previous Text' is True.")
+                tb_initial_prompt = gr.Textbox(label="Initial Prompt", value=None, interactive=True,
+                                               info="Initial prompt to use for decoding.")
+                sd_temperature = gr.Slider(label="Temperature", value=whisper_params["temperature"], minimum=0.0,
+                                           step=0.01, maximum=1.0, interactive=True,
+                                           info="Temperature for sampling. It can be a tuple of temperatures, which will be successively used upon failures according to either `Compression Ratio Threshold` or `Log Prob Threshold`.")
+                nb_compression_ratio_threshold = gr.Number(label="Compression Ratio Threshold", value=whisper_params["compression_ratio_threshold"],
+                                                           interactive=True,
+                                                           info="If the gzip compression ratio is above this value, treat as failed.")
+                nb_chunk_length = gr.Number(label="Chunk Length (s)", value=lambda: whisper_params["chunk_length"],
+                                            precision=0,
+                                            info="The length of audio segments. If it is not None, it will overwrite the default chunk_length of the FeatureExtractor.")
+                with gr.Group(visible=isinstance(self.whisper_inf, FasterWhisperInference)):
+                    nb_length_penalty = gr.Number(label="Length Penalty", value=whisper_params["length_penalty"],
+                                                  info="Exponential length penalty constant.")
+                    nb_repetition_penalty = gr.Number(label="Repetition Penalty", value=whisper_params["repetition_penalty"],
+                                                      info="Penalty applied to the score of previously generated tokens (set > 1 to penalize).")
+                    nb_no_repeat_ngram_size = gr.Number(label="No Repeat N-gram Size", value=whisper_params["no_repeat_ngram_size"],
+                                                        precision=0,
+                                                        info="Prevent repetitions of n-grams with this size (set 0 to disable).")
+                    tb_prefix = gr.Textbox(label="Prefix", value=lambda: whisper_params["prefix"],
+                                           info="Optional text to provide as a prefix for the first window.")
+                    cb_suppress_blank = gr.Checkbox(label="Suppress Blank", value=whisper_params["suppress_blank"],
+                                                    info="Suppress blank outputs at the beginning of the sampling.")
+                    tb_suppress_tokens = gr.Textbox(label="Suppress Tokens", value=whisper_params["suppress_tokens"],
+                                                    info="List of token IDs to suppress. -1 will suppress a default set of symbols as defined in the model config.json file.")
+                    nb_max_initial_timestamp = gr.Number(label="Max Initial Timestamp", value=whisper_params["max_initial_timestamp"],
+                                                         info="The initial timestamp cannot be later than this.")
+                    cb_word_timestamps = gr.Checkbox(label="Word Timestamps", value=whisper_params["word_timestamps"],
+                                                     info="Extract word-level timestamps using the cross-attention pattern and dynamic time warping, and include the timestamps for each word in each segment.")
+                    tb_prepend_punctuations = gr.Textbox(label="Prepend Punctuations", value=whisper_params["prepend_punctuations"],
+                                                         info="If 'Word Timestamps' is True, merge these punctuation symbols with the next word.")
+                    tb_append_punctuations = gr.Textbox(label="Append Punctuations", value=whisper_params["append_punctuations"],
+                                                        info="If 'Word Timestamps' is True, merge these punctuation symbols with the previous word.")
+                    nb_max_new_tokens = gr.Number(label="Max New Tokens", value=lambda: whisper_params["max_new_tokens"],
+                                                  precision=0,
+                                                  info="Maximum number of new tokens to generate per-chunk. If not set, the maximum will be set by the default max_length.")
+                    nb_hallucination_silence_threshold = gr.Number(label="Hallucination Silence Threshold (sec)",
+                                                                   value=lambda: whisper_params["hallucination_silence_threshold"],
+                                                                   info="When 'Word Timestamps' is True, skip silent periods longer than this threshold (in seconds) when a possible hallucination is detected.")
+                    tb_hotwords = gr.Textbox(label="Hotwords", value=lambda: whisper_params["hotwords"],
+                                             info="Hotwords/hint phrases to provide the model with. Has no effect if prefix is not None.")
+                    nb_language_detection_threshold = gr.Number(label="Language Detection Threshold", value=lambda: whisper_params["language_detection_threshold"],
+                                                                info="If the maximum probability of the language tokens is higher than this value, the language is detected.")
+                    nb_language_detection_segments = gr.Number(label="Language Detection Segments", value=lambda: whisper_params["language_detection_segments"],
+                                                               precision=0,
+                                                               info="Number of segments to consider for the language detection.")
+                with gr.Group(visible=isinstance(self.whisper_inf, InsanelyFastWhisperInference)):
+                    nb_batch_size = gr.Number(label="Batch Size", value=whisper_params["batch_size"], precision=0)
+    
+            with gr.Accordion("Background Music Remover Filter", open=False):
+                cb_bgm_separation = gr.Checkbox(label="Enable Background Music Remover Filter", value=uvr_params["is_separate_bgm"],
+                                                interactive=True,
+                                                info="Enabling this will remove background music by submodel before"
+                                                     " transcribing ")
+                dd_uvr_device = gr.Dropdown(label="Device", value=self.whisper_inf.music_separator.device,
+                                            choices=self.whisper_inf.music_separator.available_devices)
+                dd_uvr_model_size = gr.Dropdown(label="Model", value=uvr_params["model_size"],
+                                                choices=self.whisper_inf.music_separator.available_models)
+                nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"], precision=0)
+                cb_uvr_save_file = gr.Checkbox(label="Save separated files to output", value=uvr_params["save_file"])
+                cb_uvr_enable_offload = gr.Checkbox(label="Offload sub model after removing background music",
+                                                    value=uvr_params["enable_offload"])
+    
+            with gr.Accordion("Voice Detection Filter", open=False):
+                cb_vad_filter = gr.Checkbox(label="Enable Silero VAD Filter", value=vad_params["vad_filter"],
                                             interactive=True,
-                                            info="Enabling this will remove background music by submodel before"
-                                                 " transcribing ")
-            dd_uvr_device = gr.Dropdown(label="Device", value=self.whisper_inf.music_separator.device,
-                                        choices=self.whisper_inf.music_separator.available_devices)
-            dd_uvr_model_size = gr.Dropdown(label="Model", value=uvr_params["model_size"],
-                                            choices=self.whisper_inf.music_separator.available_models)
-            nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"], precision=0)
-            cb_uvr_save_file = gr.Checkbox(label="Save separated files to output", value=uvr_params["save_file"])
-            cb_uvr_enable_offload = gr.Checkbox(label="Offload sub model after removing background music",
-                                                value=uvr_params["enable_offload"])
-
-        with gr.Accordion("Voice Detection Filter", open=False):
-            cb_vad_filter = gr.Checkbox(label="Enable Silero VAD Filter", value=vad_params["vad_filter"],
-                                        interactive=True,
-                                        info="Enable this to transcribe only detected voice parts by submodel.")
-            sd_threshold = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Speech Threshold",
-                                     value=vad_params["threshold"],
-                                     info="Lower it to be more sensitive to small sounds.")
-            nb_min_speech_duration_ms = gr.Number(label="Minimum Speech Duration (ms)", precision=0,
-                                                  value=vad_params["min_speech_duration_ms"],
-                                                  info="Final speech chunks shorter than this time are thrown out")
-            nb_max_speech_duration_s = gr.Number(label="Maximum Speech Duration (s)",
-                                                 value=vad_params["max_speech_duration_s"],
-                                                 info="Maximum duration of speech chunks in \"seconds\".")
-            nb_min_silence_duration_ms = gr.Number(label="Minimum Silence Duration (ms)", precision=0,
-                                                   value=vad_params["min_silence_duration_ms"],
-                                                   info="In the end of each speech chunk wait for this time"
-                                                        " before separating it")
-            nb_speech_pad_ms = gr.Number(label="Speech Padding (ms)", precision=0, value=vad_params["speech_pad_ms"],
-                                         info="Final speech chunks are padded by this time each side")
+                                            info="Enable this to transcribe only detected voice parts by submodel.")
+                sd_threshold = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Speech Threshold",
+                                         value=vad_params["threshold"],
+                                         info="Lower it to be more sensitive to small sounds.")
+                nb_min_speech_duration_ms = gr.Number(label="Minimum Speech Duration (ms)", precision=0,
+                                                      value=vad_params["min_speech_duration_ms"],
+                                                      info="Final speech chunks shorter than this time are thrown out")
+                nb_max_speech_duration_s = gr.Number(label="Maximum Speech Duration (s)",
+                                                     value=vad_params["max_speech_duration_s"],
+                                                     info="Maximum duration of speech chunks in \"seconds\".")
+                nb_min_silence_duration_ms = gr.Number(label="Minimum Silence Duration (ms)", precision=0,
+                                                       value=vad_params["min_silence_duration_ms"],
+                                                       info="In the end of each speech chunk wait for this time"
+                                                            " before separating it")
+                nb_speech_pad_ms = gr.Number(label="Speech Padding (ms)", precision=0, value=vad_params["speech_pad_ms"],
+                                             info="Final speech chunks are padded by this time each side")
 
         #dd_model.change(fn=self.on_change_models, inputs=[dd_model], outputs=[cb_translate])