new build

.gitattributes

@@ -8,6 +8,8 @@
 *.h5 filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
 *.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
 *.msgpack filter=lfs diff=lfs merge=lfs -text
@@ -33,3 +35,25 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -153,3 +153,9 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
+
+# macOS
+.DS_Store
+
+# Ruff
+.ruff_cache/

README.md

@@ -1,14 +1,14 @@
 ---
 title: TransformerRanker
-emoji: ⚖️
+emoji: 🎯🧩
 colorFrom: yellow
-colorTo: yellow
+colorTo: purple
 sdk: gradio
-sdk_version: 4.44.1
-app_file: app.py
+sdk_version: 5.44.0
+app_file: demo/app.py
 pinned: false
 license: mit
-short_description: Efficiently find the best-suited LM for your NLP task
----
+short_description: Efficient LM Ranking for Downstream Tasks
+--- 
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py → demo/app.py

@@ -1,127 +1,113 @@
 import gradio as gr
 from datasets import disable_caching, load_dataset
-from transformer_ranker import TransformerRanker, prepare_popular_models
-import traceback
+from transformer_ranker import TransformerRanker
 
-from utils import (
-    DISABLED_BUTTON_VARIANT, ENABLED_BUTTON_VARIANT, CSS, HEADLINE, FOOTER,
-    EmbeddingProgressTracker, check_dataset_exists, check_dataset_is_loaded,
-    compute_ratio, ensure_one_lm_selected, get_dataset_info
+from demo.config import SAMPLE_SIZE, MAX_SAMPLE_SIZE, ALL_LMS, PRESELECTED_LMS, GRADIO_THEME
+from demo.utils import (
+    BANNER, FOOTER, CSS, UNSET,
+    EmbeddingProgressTracker, compute_ratio,
+    validate_dataset, preprocess_dataset, ensure_dataset_is_loaded
 )
 
-disable_caching()
-
-THEME = "pseudolab/huggingface-korea-theme"
-DEFAULT_SAMPLES = 1000
-MAX_SAMPLES = 5000
-LANGUAGE_MODELS = prepare_popular_models('base') + prepare_popular_models('large')
 
-# Add a tiny model for demonstration on CPU
-LANGUAGE_MODELS = ['prajjwal1/bert-tiny'] + list(dict.fromkeys(LANGUAGE_MODELS))
-LANGUAGE_MODELS.insert(LANGUAGE_MODELS.index("bert-base-cased") + 1, "bert-base-uncased")
+disable_caching()
 
-# Preselect some small models
-DEFAULT_MODELS = [
-    "prajjwal1/bert-tiny", "google/electra-small-discriminator", 
-    "distilbert-base-cased", "sentence-transformers/all-MiniLM-L12-v2"
-]
+with gr.Blocks(css=CSS, theme=None) as demo:
 
+    gr.Markdown(BANNER)
 
-with gr.Blocks(css=CSS, theme=THEME) as demo:
+    ##### 1. Load from datasets #####
 
-    ########## STEP 1: Load the Dataset ##########
+    gr.Markdown("## Load Downstream Dataset")
 
-    gr.Markdown(HEADLINE)
+    gr.Markdown(
+        "Select a dataset from the Hugging Face Hub such as `trec`. "
+        "This defines your downstream task."
+    )
 
-    gr.Markdown("## Step 1: Load a Dataset")
     with gr.Group():
         dataset = gr.State(None)
 
-        dataset_name = gr.Textbox(
-            label="Enter the name of your dataset",
-            placeholder="Examples: trec, ag_news, sst2, conll2003, leondz/wnut_17",
+        dataset_id = gr.Textbox(
+            label="Dataset name",
+            placeholder="try: trec, conll2003, ag_news",
             max_lines=1,
         )
-        select_dataset_button = gr.Button(
-            value="Load dataset", interactive=False, variant=DISABLED_BUTTON_VARIANT
-        )
 
-        # Activate the "Load dataset" button if dataset was found
-        dataset_name.change(
-            check_dataset_exists, inputs=dataset_name, outputs=select_dataset_button
-        )
+        load_dataset_button = gr.Button(value="Load data", variant="primary", interactive=True,)
+
+        # enable loading if dataset exists on hub
+        dataset_id.change(validate_dataset, inputs=dataset_id, outputs=load_dataset_button)
 
     gr.Markdown(
-        "*The number of samples that can be used in this demo is limited to save resources. "
-        "To run an estimate on the full dataset, check out the "
-        "[library](https://github.com/flairNLP/transformer-ranker).*"
+        "Settings auto-configured. "
+        "Adjust the downsampling ratio in Dataset Setup, "
+        "or use the complete dataset with the [framework](https://github.com/flairNLP/transformer-ranker)."
     )
 
-    ########## Step 1.1 Dataset preprocessing ##########
+    ##### data preprocessing #####
 
-    with gr.Accordion("Dataset settings", open=False) as dataset_config:
+    with gr.Accordion("Dataset Setup", open=False) as dataset_config:
         with gr.Row() as dataset_details:
-            dataset_name_label = gr.Label("", label="Dataset Name")
+            dataset_id_label = gr.Label("", label="Dataset")
             num_samples = gr.State(0)
-            num_samples_label = gr.Label("", label="Number of Samples")
+            num_samples_label = gr.Label("", label="Dataset size")
             num_samples.change(
                 lambda x: str(x), inputs=[num_samples], outputs=[num_samples_label]
             )
 
         with gr.Row():
             text_column = gr.Dropdown("", label="Text Column")
-            text_pair_column = gr.Dropdown("", label="Text Pair Column")
+            text_pair_column = gr.Dropdown("", label="Text Pair")
 
         with gr.Row():
-            label_column = gr.Dropdown("", label="Label Column")
-            task_category = gr.Dropdown("", label="Task Type")
+            label_column = gr.Dropdown("", label="Labels")
+            task_category = gr.Dropdown("", label="Downstream Task")
 
         with gr.Group():
             downsample_ratio = gr.State(0.0)
-            num_samples_to_use = gr.Slider(
-                20, MAX_SAMPLES, label="Samples to use", value=DEFAULT_SAMPLES, step=1
+            sampling_rate = gr.Slider(
+                20, MAX_SAMPLE_SIZE, label="Sampling rate", value=SAMPLE_SIZE, step=1
             )
-            downsample_ratio_label = gr.Label("", label="Ratio of dataset to use")
+            downsample_ratio_label = gr.Label("", label="Sampling rate")
             downsample_ratio.change(
                 lambda x: f"{x:.1%}",
                 inputs=[downsample_ratio],
                 outputs=[downsample_ratio_label],
             )
 
-            num_samples_to_use.change(
+            sampling_rate.change(
                 compute_ratio,
-                inputs=[num_samples_to_use, num_samples],
+                inputs=[sampling_rate, num_samples],
                 outputs=downsample_ratio,
             )
             num_samples.change(
                 compute_ratio,
-                inputs=[num_samples_to_use, num_samples],
+                inputs=[sampling_rate, num_samples],
                 outputs=downsample_ratio,
             )
 
-    # Download the dataset and show details
-    def select_dataset(dataset_name):
+    # load and show details
+    def load_hf_dataset(dataset_id):
         try:
-            dataset = load_dataset(dataset_name, trust_remote_code=True)
-            dataset_info = get_dataset_info(dataset)
-        except ValueError:
-            gr.Warning("Dataset collections are not supported. Please use a single dataset.")
+            dataset = load_dataset(dataset_id, trust_remote_code=True)
+            dataset_details = preprocess_dataset(dataset)
+        except ValueError as e:
+            gr.Warning("Collections not supported. Load one dataset only.")
 
         return (
-            gr.update(value="Loaded", interactive=False, variant=DISABLED_BUTTON_VARIANT),
-            gr.Accordion(open=True),
-            dataset_name,
+            gr.update(value="Loaded"),
+            dataset_id,
             dataset,
-            *dataset_info
+            *dataset_details
         )
 
-    select_dataset_button.click(
-        select_dataset,
-        inputs=[dataset_name],
+    load_dataset_button.click(
+        load_hf_dataset,
+        inputs=[dataset_id],
         outputs=[
-            select_dataset_button,
-            dataset_config,
-            dataset_name_label,
+            load_dataset_button,
+            dataset_id_label,
             dataset,
             task_category,
             text_column,
@@ -132,53 +118,65 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
         scroll_to_output=True,
     )
 
-    ########## STEP 2 ##########
+    ########## 2. Select LMs ##########
+
+    gr.Markdown("## Select Language Models")
+
+    gr.Markdown(
+        "Add two or more pretrained models for ranking. "
+        "Go with small models since this demo runs on CPU."
+    )
 
-    gr.Markdown("## Step 2: Select a List of Language Models")
     with gr.Group():
         model_options = [
             (model_handle.split("/")[-1], model_handle)
-            for model_handle in LANGUAGE_MODELS
+            for model_handle in ALL_LMS
         ]
         models = gr.CheckboxGroup(
-            choices=model_options, label="Select Models", value=DEFAULT_MODELS
+            choices=model_options, label="Model List", value=PRESELECTED_LMS
         )
 
-    ########## STEP 3: Run Language Model Ranking ##########
+    ########## 3. Run ranking ##########
 
-    gr.Markdown("## Step 3: Rank LMs")
+    gr.Markdown("## Rank Language Models")
+
+    gr.Markdown(
+        "Rank models by transferability to your downstream task. "
+        "Adjust the metric and layer aggregation in Advanced Settings."
+    )
 
     with gr.Group():
-        with gr.Accordion("Advanced settings", open=False):
+
+        submit_button = gr.Button("Run ranking", variant="primary", interactive=False)
+
+        with gr.Accordion("Advanced Settings", open=False):
             with gr.Row():
                 estimator = gr.Dropdown(
                     choices=["hscore", "logme", "knn"],
                     label="Transferability metric",
                     value="hscore",
                 )
-                layer_pooling_options = ["lastlayer", "layermean", "bestlayer"]
-                layer_pooling = gr.Dropdown(
+                layer_aggregator = gr.Dropdown(
                     choices=["lastlayer", "layermean", "bestlayer"],
-                    label="Layer pooling",
+                    label="Layer aggregation",
                     value="layermean",
                 )
-        submit_button = gr.Button("Run Ranking", interactive=False, variant=DISABLED_BUTTON_VARIANT)
 
-        # Make button active if the dataset is loaded
+        # ranking button works after dataset loads
         dataset.change(
-            check_dataset_is_loaded,
+            ensure_dataset_is_loaded,
             inputs=[dataset, text_column, label_column, task_category],
             outputs=submit_button
         )
 
         label_column.change(
-            check_dataset_is_loaded,
+            ensure_dataset_is_loaded,
             inputs=[dataset, text_column, label_column, task_category],
             outputs=submit_button
         )
 
         text_column.change(
-            check_dataset_is_loaded,
+            ensure_dataset_is_loaded,
             inputs=[dataset, text_column, label_column, task_category],
             outputs=submit_button
         )
@@ -187,7 +185,7 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
         dataset,
         downsample_ratio,
         selected_models,
-        layer_pooling,
+        layer_aggregator,
         estimator,
         text_column,
         text_pair_column,
@@ -196,18 +194,18 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
         progress=gr.Progress(),
     ):
 
-        if text_column == "-":
+        if text_column == UNSET:
             raise gr.Error("Text column is not set.")
 
-        if label_column == "-":
+        if label_column == UNSET:
             raise gr.Error("Label column is not set.")
 
-        if task_category == "-":
+        if task_category == UNSET:
             raise gr.Error(
-                "Task category is not set. The dataset must support classification or regression tasks."
+                "Task category not set. Dataset must support classification or regression."
             )
 
-        if text_pair_column == "-":
+        if text_pair_column == UNSET:
             text_pair_column = None
 
         progress(0.0, "Starting")
@@ -225,7 +223,7 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
 
                 results = ranker.run(
                     models=selected_models,
-                    layer_aggregator=layer_pooling,
+                    layer_aggregator=layer_aggregator,
                     estimator=estimator,
                     batch_size=64,
                     tracker=tracker,
@@ -238,11 +236,16 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
                     (i + 1, model, score) for i, (model, score) in enumerate(sorted_results)
                 ]
             except Exception as e:
-                gr.Error("The dataset is not supported.")
+                print(e)
+                gr.Warning(f"Ranking issue: {e}")
+                return []
+
+    gr.Markdown("Ranking table → higher scores indicate better downstream performance.")
 
-    gr.Markdown("## Results")
     ranking_results = gr.Dataframe(
-        headers=["Rank", "Model", "Score"], datatype=["number", "str", "number"]
+        headers=["Rank", "Model", "Score"],
+        datatype=["number", "str", "number"],
+        value=[["-", "-", "-"]]
     )
 
     submit_button.click(
@@ -251,7 +254,7 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
             dataset,
             downsample_ratio,
             models,
-            layer_pooling,
+            layer_aggregator,
             estimator,
             text_column,
             text_pair_column,
@@ -262,13 +265,12 @@ with gr.Blocks(css=CSS, theme=THEME) as demo:
         scroll_to_output=True,
     )
 
-    gr.Markdown(
-        "*The results are ranked by their transferability score, with the most suitable model listed first. "
-        "This ranking allows focusing on the higher-ranked models for further exploration and fine-tuning.*"
-    )
-
     gr.Markdown(FOOTER)
 
 if __name__ == "__main__":
+
+    # run up to 3 requests at once
     demo.queue(default_concurrency_limit=3)
+
+    # run with 6 workers
     demo.launch(max_threads=6)

demo/config.py

@@ -0,0 +1,22 @@
+SAMPLE_SIZE = 1000
+MAX_SAMPLE_SIZE = 5000
+GRADIO_THEME = None
+
+ALL_LMS = [
+    # tiny
+    "prajjwal1/bert-tiny", "arnir0/Tiny-LLM",
+    "sentence-transformers/all-MiniLM-L12-v2", "google/electra-small-discriminator",
+    "distilbert-base-cased", "typeform/distilroberta-base-v2",
+
+    # small
+    "bert-base-cased", "roberta-base", "google/electra-base-discriminator", "microsoft/deberta-v3-base",
+    "KISTI-AI/scideberta", "sentence-transformers/all-mpnet-base-v2", "huggingface/CodeBERTa-small-v1",
+    "FacebookAI/xlm-roberta-base", "microsoft/mdeberta-v3-base", "HuggingFaceTB/SmolLM2-135M"
+]
+
+PRESELECTED_LMS = [
+    "prajjwal1/bert-tiny",
+    "sentence-transformers/all-MiniLM-L12-v2",
+    "arnir0/Tiny-LLM",
+    "google/electra-small-discriminator",
+]

utils.py → demo/utils.py

@@ -1,118 +1,118 @@
+import math
+
 import gradio as gr
 from datasets import concatenate_datasets
 from huggingface_hub import HfApi
 from huggingface_hub.errors import HFValidationError
 from requests.exceptions import HTTPError
-from transformer_ranker import Result
 from transformer_ranker.datacleaner import DatasetCleaner, TaskCategory
 from transformer_ranker.embedder import Embedder
-import math
 
-DISABLED_BUTTON_VARIANT = "huggingface"
-ENABLED_BUTTON_VARIANT = "primary"
+BANNER = """
+<h1 align="center">🔥 TransformerRanker 🔥</h1>
 
-HEADLINE = """
-<h1 align="center">TransformerRanker</h1>
 <p align="center" style="max-width: 560px; margin: auto;">
-    A very simple library that helps you find the best-suited language model for your NLP task.
-    All you need to do is to select a dataset and a list of pre-trained language models (LMs) from the 🤗 HuggingFace Hub.
-    TransformerRanker will quickly estimate which of these LMs will perform best on the given dataset!
+    Find the best language model for your downstream task.
+    Load a dataset, select models from the 🤗 Hub, and rank them by <strong>transferability</strong>.
 </p>
+
 <p align="center" style="font-weight: bold; margin-top: 20px; display: flex; justify-content: center; gap: 10px;">
     <a href="https://github.com/flairNLP/transformer-ranker">
-        <img src="https://img.shields.io/badge/Repository-black?style=flat&logo=github" alt="GitHub Repo">
+        <img src="https://img.shields.io/badge/Code Repo-black?style=flat&logo=github" alt="repository">
+    </a>
+    <a href="https://opensource.org/licenses/MIT">
+        <img src="https://img.shields.io/badge/License-MIT-brightgreen?style=flat" alt="license">
     </a>
     <a href="https://pypi.org/project/transformer-ranker/">
-        <img src="https://img.shields.io/badge/Package-orange?style=flat&logo=python" alt="Package Badge">
+        <img src="https://img.shields.io/badge/Package-orange?style=flat&logo=python" alt="package">
     </a>
-    <a href="https://github.com/flairNLP/transformer-ranker/blob/main/examples/01-walkthrough.md">
-        <img src="https://img.shields.io/badge/Tutorials-blue?style=flat&logo=readthedocs&logoColor=white" alt="Tutorials Badge">
+    <a href="https://github.com/flairNLP/transformer-ranker/blob/main/docs/01-walkthrough.md">
+        <img src="https://img.shields.io/badge/Tutorials-blue?style=flat&logo=readthedocs&logoColor=white" alt="tutorials">
     </a>
-    <img src="https://img.shields.io/badge/license-MIT-green?style=flat" alt="License: MIT">
 </p>
+
 <p align="center">Developed at <a href="https://www.informatik.hu-berlin.de/en/forschung-en/gebiete/ml-en/">Humboldt University of Berlin</a>.</p>
 """
 
 FOOTER = """
-**Note:** This demonstration currently runs on a CPU and is suited for smaller models only.  
-**Developers:** [@plonerma](https://huggingface.co/plonerma) and [@lukasgarbas](https://huggingface.co/lukasgarbas). 
-For feedback, suggestions, or contributions, reach out via GitHub or leave a message in the [discussions](https://huggingface.co/spaces/lukasgarbas/transformer-ranker/discussions).
+**Note:** CPU-only quick demo. **Built by:** @lukasgarbas & @plonerma
+**Questions?** Open a [GitHub issue](https://github.com/flairNLP/transformer-ranker/issues) 🔫.
 """
 
 CSS = """
-.gradio-container{max-width: 800px !important}
-a {color: #ff9d00;}
-@media (prefers-color-scheme: dark) { a {color: #be185d;} }
+.gradio-container {
+    max-width: 800px;
+    margin: auto;
+}
 """
 
+UNSET = "-"
 
 hf_api = HfApi()
+preprocessing = DatasetCleaner()
 
 
-def check_dataset_exists(dataset_name):
-    """Update loading button if dataset can be found"""
+def validate_dataset(dataset_name):
+    """Enable if dataset exists on Hub."""
     try:
-        hf_api.dataset_info(dataset_name)
-        return gr.update(interactive=True, variant=ENABLED_BUTTON_VARIANT)
+        hf_api.dataset_info(dataset_name)  # quick dataset info call
+        return gr.update(interactive=True)
 
     except (HTTPError, HFValidationError):
-        return gr.update(value="Load dataset", interactive=False, variant=DISABLED_BUTTON_VARIANT)
-
-def check_dataset_is_loaded(dataset, text_column, label_column, task_category):
-    if dataset and text_column != "-" and label_column != "-" and task_category != "-":
-        return gr.update(interactive=True, variant=ENABLED_BUTTON_VARIANT)
-    else:
-        return gr.update(interactive=False, variant=DISABLED_BUTTON_VARIANT)
+        return gr.update(value="Load data", interactive=False)
 
 
-def get_dataset_info(dataset):
-    """Show information for dataset settings"""
-    joined_dataset = concatenate_datasets(list(dataset.values()))
-    datacleaner = DatasetCleaner()
+def preprocess_dataset(dataset):
+    """Use data preprocessing to find text/label columns and task category."""
+    data = concatenate_datasets(list(dataset.values()))
 
     try:
-        text_column = datacleaner._find_column(joined_dataset, "text column")
+        text_column = preprocessing._find_column(data, "text column")
     except ValueError:
-        gr.Warning("Text column can not be found. Select it in the dataset settings.")
-        text_column = "-"
+        gr.Warning("Text column not auto-detected — select in settings.")
+        text_column = UNSET
 
     try:
-        label_column = datacleaner._find_column(joined_dataset, "label column")
+        label_column = preprocessing._find_column(data, "label column")
     except ValueError:
-        gr.Warning("Label column can not be found. Select it in the dataset settings.")
-        label_column = "-"
+        gr.Warning("Label column not auto-detected — select in settings.")
+        label_column = UNSET
 
-    task_category = "-"
-    if label_column != "-":
+    task_category = UNSET
+    if label_column != UNSET:
         try:
-            # Find or set the task_category
-            task_category = datacleaner._find_task_category(joined_dataset, label_column)
+            task_category = preprocessing._find_task_category(data, label_column)
         except ValueError:
-            gr.Warning(
-                "Task category could not be determined. The dataset must support classification or regression tasks.",
-            )
-            pass
+            gr.Warning("Task category not auto-detected — framework supports classification, regression.")
 
-    num_samples = len(joined_dataset)
+    text_column = gr.update(value=text_column, choices=data.column_names, interactive=True)
+    label_column = gr.update(value=label_column, choices=data.column_names, interactive=True)
+    text_pair  = gr.update(value=UNSET, choices=[UNSET, *data.column_names], interactive=True)
+    task_category = gr.update(value=task_category, choices=[str(t) for t in TaskCategory], interactive=True)
+    sample_size = len(data)
 
+    return task_category, text_column, text_pair, label_column, sample_size
+
+"""
     return (
+        text_column,
         gr.update(
             value=task_category,
             choices=[str(t) for t in TaskCategory],
             interactive=True,
         ),
         gr.update(
-            value=text_column, choices=joined_dataset.column_names, interactive=True
+            value=text_column, choices=data.column_names, interactive=True
         ),
         gr.update(
-            value="-", choices=["-", *joined_dataset.column_names], interactive=True
+            value=UNSET, choices=[UNSET, *data.column_names], interactive=True
         ),
         gr.update(
-            value=label_column, choices=joined_dataset.column_names, interactive=True
+            value=label_column, choices=data.column_names, interactive=True
         ),
         num_samples,
     )
-
+"""
 
 def compute_ratio(num_samples_to_use, num_samples):
     if num_samples > 0:
@@ -121,13 +121,20 @@ def compute_ratio(num_samples_to_use, num_samples):
         return 0.0
 
 
+def ensure_dataset_is_loaded(dataset, text_column, label_column, task_category):
+    if dataset and text_column != UNSET and label_column != UNSET and task_category != UNSET:
+        return gr.update(interactive=True)
+    else:
+        return gr.update(interactive=False)
+
+
 def ensure_one_lm_selected(checkbox_values, previous_values):
     if not any(checkbox_values):
         return previous_values
     return checkbox_values
 
 
-# Apply monkey patch to enable callbacks
+# apply monkey patch to enable callbacks
 _old_embed = Embedder.embed
 
 def _new_embed(embedder, sentences, batch_size: int = 32, **kw):
@@ -202,4 +209,3 @@ class EmbeddingProgressTracker:
             progress += (self.batches_complete / self.batches_total) / self.total
 
         self.progress_bar(progress=progress, desc=description)
-

requirements.txt

@@ -1,2 +1,5 @@
-gradio>=4.44.1
+gradio>=5.0
 transformer-ranker==0.1.2
+transformers==4.41.0
+datasets==3.6
+protobuf

runtime.txt

@@ -0,0 +1 @@
+python-3.12