Update app.py

app.py

@@ -84,54 +84,6 @@ def runSingleFileAnalysis(
     )
 
 
-def runBatchAnalysis(
-    output_path,
-    confidence,
-    sensitivity,
-    overlap,
-    species_list_choice,
-    species_list_file,
-    lat,
-    lon,
-    week,
-    use_yearlong,
-    sf_thresh,
-    custom_classifier_file,
-    output_type,
-    locale,
-    batch_size,
-    threads,
-    input_dir,
-    progress=gr.Progress(),
-):
-    validate(input_dir, "Please select a directory.")
-    batch_size = int(batch_size)
-    threads = int(threads)
-
-    if species_list_choice == _CUSTOM_SPECIES:
-        validate(species_list_file, "Please select a species list.")
-
-    return runAnalysis(
-        None,
-        output_path,
-        confidence,
-        sensitivity,
-        overlap,
-        species_list_choice,
-        species_list_file,
-        lat,
-        lon,
-        week,
-        use_yearlong,
-        sf_thresh,
-        custom_classifier_file,
-        output_type,
-        "en" if not locale else locale,
-        batch_size if batch_size and batch_size > 0 else 1,
-        threads if threads and threads > 0 else 4,
-        input_dir,
-        progress,
-    )
 
 
 def runAnalysis(
@@ -431,147 +383,6 @@ def select_directory(collect_files=True):
     return dir_name[0] if dir_name else None
 
 
-def start_training(
-    data_dir,
-    crop_mode,
-    crop_overlap,
-    output_dir,
-    classifier_name,
-    epochs,
-    batch_size,
-    learning_rate,
-    hidden_units,
-    use_mixup,
-    upsampling_ratio,
-    upsampling_mode,
-    model_format,
-    progress=gr.Progress(),
-):
-    """Starts the training of a custom classifier.
-
-    Args:
-        data_dir: Directory containing the training data.
-        output_dir: Directory for the new classifier.
-        classifier_name: File name of the classifier.
-        epochs: Number of epochs to train for.
-        batch_size: Number of samples in one batch.
-        learning_rate: Learning rate for training.
-        hidden_units: If > 0 the classifier contains a further hidden layer.
-        progress: The gradio progress bar.
-
-    Returns:
-        Returns a matplotlib.pyplot figure.
-    """
-    validate(data_dir, "Please select your Training data.")
-    validate(output_dir, "Please select a directory for the classifier.")
-    validate(classifier_name, "Please enter a valid name for the classifier.")
-
-    if not epochs or epochs < 0:
-        raise gr.Error("Please enter a valid number of epochs.")
-
-    if not batch_size or batch_size < 0:
-        raise gr.Error("Please enter a valid batch size.")
-
-    if not learning_rate or learning_rate < 0:
-        raise gr.Error("Please enter a valid learning rate.")
-
-    if not hidden_units or hidden_units < 0:
-        hidden_units = 0
-
-    if progress is not None:
-        progress((0, epochs), desc="Loading data & building classifier", unit="epoch")
-
-    cfg.TRAIN_DATA_PATH = data_dir
-    cfg.SAMPLE_CROP_MODE = crop_mode
-    cfg.SIG_OVERLAP = crop_overlap
-    cfg.CUSTOM_CLASSIFIER = str(Path(output_dir) / classifier_name)
-    cfg.TRAIN_EPOCHS = int(epochs)
-    cfg.TRAIN_BATCH_SIZE = int(batch_size)
-    cfg.TRAIN_LEARNING_RATE = learning_rate
-    cfg.TRAIN_HIDDEN_UNITS = int(hidden_units)
-    cfg.TRAIN_WITH_MIXUP = use_mixup
-    cfg.UPSAMPLING_RATIO = min(max(0, upsampling_ratio), 1)
-    cfg.UPSAMPLING_MODE = upsampling_mode
-    cfg.TRAINED_MODEL_OUTPUT_FORMAT = model_format
-
-    def progression(epoch, logs=None):
-        if progress is not None:
-            if epoch + 1 == epochs:
-                progress((epoch + 1, epochs), total=epochs, unit="epoch", desc=f"Saving at {cfg.CUSTOM_CLASSIFIER}")
-            else:
-                progress((epoch + 1, epochs), total=epochs, unit="epoch")
-
-    history = trainModel(on_epoch_end=progression)
-
-    if len(history.epoch) < epochs:
-        gr.Info("Stopped early - validation metric not improving.")
-
-    auprc = history.history["val_AUPRC"]
-
-    import matplotlib.pyplot as plt
-
-    fig = plt.figure()
-    plt.plot(auprc)
-    plt.ylabel("Area under precision-recall curve")
-    plt.xlabel("Epoch")
-
-    return fig
-
-
-def extract_segments(audio_dir, result_dir, output_dir, min_conf, num_seq, seq_length, threads, progress=gr.Progress()):
-    validate(audio_dir, "No audio directory selected")
-
-    if not result_dir:
-        result_dir = audio_dir
-
-    if not output_dir:
-        output_dir = audio_dir
-
-    if progress is not None:
-        progress(0, desc="Searching files ...")
-
-    # Parse audio and result folders
-    cfg.FILE_LIST = segments.parseFolders(audio_dir, result_dir)
-
-    # Set output folder
-    cfg.OUTPUT_PATH = output_dir
-
-    # Set number of threads
-    cfg.CPU_THREADS = int(threads)
-
-    # Set confidence threshold
-    cfg.MIN_CONFIDENCE = max(0.01, min(0.99, min_conf))
-
-    # Parse file list and make list of segments
-    cfg.FILE_LIST = segments.parseFiles(cfg.FILE_LIST, max(1, int(num_seq)))
-
-    # Add config items to each file list entry.
-    # We have to do this for Windows which does not
-    # support fork() and thus each process has to
-    # have its own config. USE LINUX!
-    flist = [(entry, max(cfg.SIG_LENGTH, float(seq_length)), cfg.getConfig()) for entry in cfg.FILE_LIST]
-
-    result_list = []
-
-    # Extract segments
-    if cfg.CPU_THREADS < 2:
-        for i, entry in enumerate(flist):
-            result = extractSegments_wrapper(entry)
-            result_list.append(result)
-
-            if progress is not None:
-                progress((i, len(flist)), total=len(flist), unit="files")
-    else:
-        with concurrent.futures.ProcessPoolExecutor(max_workers=cfg.CPU_THREADS) as executor:
-            futures = (executor.submit(extractSegments_wrapper, arg) for arg in flist)
-            for i, f in enumerate(concurrent.futures.as_completed(futures), start=1):
-                if progress is not None:
-                    progress((i, len(flist)), total=len(flist), unit="files")
-                result = f.result()
-
-                result_list.append(result)
-
-    return [[os.path.relpath(r[0], audio_dir), r[1]] for r in result_list]
 
 
 def sample_sliders(opened=True):
@@ -761,269 +572,6 @@ if __name__ == "__main__":
 
             single_file_analyze.click(runSingleFileAnalysis, inputs=inputs, outputs=output_dataframe)
 
-    def build_multi_analysis_tab():
-        with gr.Tab("Multiple files"):
-            input_directory_state = gr.State()
-            output_directory_predict_state = gr.State()
-            with gr.Row():
-                with gr.Column():
-                    select_directory_btn = gr.Button("Select directory (recursive)")
-                    directory_input = gr.Matrix(interactive=False, elem_classes="mh-200", headers=["Subpath", "Length"])
-
-                    def select_directory_on_empty():
-                        res = select_directory()
-
-                        return res if res[1] else [res[0], [["No files found"]]]
-
-                    select_directory_btn.click(
-                        select_directory_on_empty, outputs=[input_directory_state, directory_input], show_progress=True
-                    )
-
-                with gr.Column():
-                    select_out_directory_btn = gr.Button("Select output directory.")
-                    selected_out_textbox = gr.Textbox(
-                        label="Output directory",
-                        interactive=False,
-                        placeholder="If not selected, the input directory will be used.",
-                    )
-
-                    def select_directory_wrapper():
-                        return (select_directory(collect_files=False),) * 2
-
-                    select_out_directory_btn.click(
-                        select_directory_wrapper,
-                        outputs=[output_directory_predict_state, selected_out_textbox],
-                        show_progress=False,
-                    )
-
-            confidence_slider, sensitivity_slider, overlap_slider = sample_sliders()
-
-            (
-                species_list_radio,
-                species_file_input,
-                lat_number,
-                lon_number,
-                week_number,
-                sf_thresh_number,
-                yearlong_checkbox,
-                selected_classifier_state,
-            ) = species_lists()
-
-            output_type_radio = gr.Radio(
-                list(OUTPUT_TYPE_MAP.keys()),
-                value="Raven selection table",
-                label="Result type",
-                info="Specifies output format.",
-            )
-
-            with gr.Row():
-                batch_size_number = gr.Number(
-                    precision=1, label="Batch size", value=1, info="Number of samples to process at the same time."
-                )
-                threads_number = gr.Number(precision=1, label="Threads", value=4, info="Number of CPU threads.")
-
-            locale_radio = locale()
-
-            start_batch_analysis_btn = gr.Button("Analyze")
-
-            result_grid = gr.Matrix(headers=["File", "Execution"], elem_classes="mh-200")
-
-            inputs = [
-                output_directory_predict_state,
-                confidence_slider,
-                sensitivity_slider,
-                overlap_slider,
-                species_list_radio,
-                species_file_input,
-                lat_number,
-                lon_number,
-                week_number,
-                yearlong_checkbox,
-                sf_thresh_number,
-                selected_classifier_state,
-                output_type_radio,
-                locale_radio,
-                batch_size_number,
-                threads_number,
-                input_directory_state,
-            ]
-
-            start_batch_analysis_btn.click(runBatchAnalysis, inputs=inputs, outputs=result_grid)
-
-    def build_train_tab():
-        with gr.Tab("Train"):
-            input_directory_state = gr.State()
-            output_directory_state = gr.State()
-
-            with gr.Row():
-                with gr.Column():
-                    select_directory_btn = gr.Button("Training data")
-                    directory_input = gr.List(headers=["Classes"], interactive=False, elem_classes="mh-200")
-                    select_directory_btn.click(
-                        select_subdirectories, outputs=[input_directory_state, directory_input], show_progress=False
-                    )
-
-                with gr.Column():
-                    select_directory_btn = gr.Button("Classifier output")
-
-                    with gr.Column():
-                        classifier_name = gr.Textbox(
-                            "CustomClassifier",
-                            visible=False,
-                            info="The name of the new classifier.",
-                        )
-                        output_format = gr.Radio(
-                            ["tflite", "raven", "both"],
-                            value="tflite",
-                            label="Model output format",
-                            info="Format for the trained classifier.",
-                            visible=False,
-                        )
-
-                    def select_directory_and_update_tb():
-                        dir_name = _WINDOW.create_file_dialog(webview.FOLDER_DIALOG)
-
-                        if dir_name:
-                            return (
-                                dir_name[0],
-                                gr.Textbox.update(label=dir_name[0] + "\\", visible=True),
-                                gr.Radio.update(visible=True, interactive=True),
-                            )
-
-                        return None, None
-
-                    select_directory_btn.click(
-                        select_directory_and_update_tb,
-                        outputs=[output_directory_state, classifier_name, output_format],
-                        show_progress=False,
-                    )
-
-            with gr.Row():
-                epoch_number = gr.Number(100, label="Epochs", info="Number of training epochs.")
-                batch_size_number = gr.Number(32, label="Batch size", info="Batch size.")
-                learning_rate_number = gr.Number(0.01, label="Learning rate", info="Learning rate.")
-
-            with gr.Row():
-                crop_mode = gr.Radio(
-                    ["center", "first", "segments"],
-                    value="center",
-                    label="Crop mode",
-                    info="Crop mode for training data.",
-                )
-                crop_overlap = gr.Number(0.0, label="Crop overlap", info="Overlap of training data segments", visible=False)
-
-                def on_crop_select(new_crop_mode):
-                    return gr.Number.update(visible=new_crop_mode == "segments", interactive=new_crop_mode == "segments")
-
-                crop_mode.change(on_crop_select, inputs=crop_mode, outputs=crop_overlap)
-
-            with gr.Row():
-                upsampling_mode = gr.Radio(
-                    ["repeat", "mean", "smote"],
-                    value="repeat",
-                    label="Upsampling mode",
-                    info="Balance data through upsampling.",
-                )
-                upsampling_ratio = gr.Slider(
-                    0.0, 1.0, 0.0, step=0.01, label="Upsampling ratio", info="Balance train data and upsample minority classes."
-                )
-
-            with gr.Row():
-                hidden_units_number = gr.Number(
-                    0, label="Hidden units", info="Number of hidden units. If set to >0, a two-layer classifier is used."
-                )
-                use_mixup = gr.Checkbox(False, label="Use mixup", info="Whether to use mixup for training.", show_label=True)
-
-            train_history_plot = gr.Plot()
-
-            start_training_button = gr.Button("Start training")
-
-            start_training_button.click(
-                start_training,
-                inputs=[
-                    input_directory_state,
-                    crop_mode,
-                    crop_overlap,
-                    output_directory_state,
-                    classifier_name,
-                    epoch_number,
-                    batch_size_number,
-                    learning_rate_number,
-                    hidden_units_number,
-                    use_mixup,
-                    upsampling_ratio,
-                    upsampling_mode,
-                    output_format,
-                ],
-                outputs=[train_history_plot],
-            )
-
-    def build_segments_tab():
-        with gr.Tab("Segments"):
-            audio_directory_state = gr.State()
-            result_directory_state = gr.State()
-            output_directory_state = gr.State()
-
-            def select_directory_to_state_and_tb():
-                return (select_directory(collect_files=False),) * 2
-
-            with gr.Row():
-                select_audio_directory_btn = gr.Button("Select audio directory (recursive)")
-                selected_audio_directory_tb = gr.Textbox(show_label=False, interactive=False)
-                select_audio_directory_btn.click(
-                    select_directory_to_state_and_tb,
-                    outputs=[selected_audio_directory_tb, audio_directory_state],
-                    show_progress=False,
-                )
-
-            with gr.Row():
-                select_result_directory_btn = gr.Button("Select result directory")
-                selected_result_directory_tb = gr.Textbox(
-                    show_label=False, interactive=False, placeholder="Same as audio directory if not selected"
-                )
-                select_result_directory_btn.click(
-                    select_directory_to_state_and_tb,
-                    outputs=[result_directory_state, selected_result_directory_tb],
-                    show_progress=False,
-                )
-
-            with gr.Row():
-                select_output_directory_btn = gr.Button("Select output directory")
-                selected_output_directory_tb = gr.Textbox(
-                    show_label=False, interactive=False, placeholder="Same as audio directory if not selected"
-                )
-                select_output_directory_btn.click(
-                    select_directory_to_state_and_tb,
-                    outputs=[selected_output_directory_tb, output_directory_state],
-                    show_progress=False,
-                )
-
-            min_conf_slider = gr.Slider(
-                minimum=0.1, maximum=0.99, step=0.01, label="Minimum confidence", info="Minimum confidence threshold."
-            )
-            num_seq_number = gr.Number(
-                100, label="Max number of segments", info="Maximum number of randomly extracted segments per species."
-            )
-            seq_length_number = gr.Number(3.0, label="Sequence length", info="Length of extracted segments in seconds.")
-            threads_number = gr.Number(4, label="Threads", info="Number of CPU threads.")
-
-            extract_segments_btn = gr.Button("Extract segments")
-
-            result_grid = gr.Matrix(headers=["File", "Execution"], elem_classes="mh-200")
-
-            extract_segments_btn.click(
-                extract_segments,
-                inputs=[
-                    audio_directory_state,
-                    result_directory_state,
-                    output_directory_state,
-                    min_conf_slider,
-                    num_seq_number,
-                    seq_length_number,
-                    threads_number,
-                ],
-                outputs=result_grid,
-            )
 
     with gr.Blocks(
         css=r".d-block .wrap {display: block !important;} .mh-200 {max-height: 300px; overflow-y: auto !important;} footer {display: none !important;} #single_file_audio, #single_file_audio * {max-height: 81.6px; min-height: 0;}",
@@ -1031,11 +579,8 @@ if __name__ == "__main__":
         analytics_enabled=False,
     ) as demo:
         build_single_analysis_tab()
-        #build_multi_analysis_tab()
-        #build_train_tab()
-       # build_segments_tab()
 
-    demo.launch()
+    demo.launch(show_api=True)
     #url = demo.queue(api_open=False).launch(prevent_thread_lock=True, quiet=True)[1]
     #_WINDOW = webview.create_window("BirdNET-Analyzer", url.rstrip("/") + "?__theme=light", min_size=(1024, 768))