move files to utils and delete unused functions

app.py

@@ -5,7 +5,7 @@ import gradio as gr
 from app_debug import get_demo as get_demo_debug
 from app_leaderboard import get_demo as get_demo_leaderboard
 from app_text_classification import get_demo as get_demo_text_classification
-from run_jobs import start_process_run_job, stop_thread
+from utils.run_jobs import start_process_run_job, stop_thread
 
 try:
     with gr.Blocks(theme=gr.themes.Soft(primary_hue="green")) as demo:

app_debug.py

@@ -4,8 +4,8 @@ import html
 
 import gradio as gr
 
-import pipe
-from io_utils import get_logs_file
+import utils.pipe as pipe
+from utils.io_utils import get_logs_file
 
 LOG_PATH = "./tmp"
 CONFIG_PATH = "./cicd/configs/"

app_leaderboard.py

@@ -5,10 +5,10 @@ import gradio as gr
 import pandas as pd
 import datetime
 
-from fetch_utils import (check_dataset_and_get_config,
+from utils.fetch_utils import (check_dataset_and_get_config,
                          check_dataset_and_get_split)
 
-import leaderboard
+import utils.leaderboard as leaderboard
 logger = logging.getLogger(__name__)
 global update_time 
 update_time = datetime.datetime.fromtimestamp(0)

app_text_classification.py

@@ -2,22 +2,21 @@ import uuid
 
 import gradio as gr
 
-from io_utils import read_scanners, write_scanners
-from text_classification_ui_helpers import (
+from utils.io_utils import read_scanners, write_scanners
+from utils.ui_helpers import (
     get_related_datasets_from_leaderboard,
     align_columns_and_show_prediction,
     check_dataset,
+    show_hf_token_info,
     precheck_model_ds_enable_example_btn,
     try_submit,
+    empty_column_mapping,
     write_column_mapping_to_config,
+    enable_run_btn,
 )
 
-from text_classification import (
-  get_example_prediction, 
-  check_hf_token_validity, 
-  HuggingFaceInferenceAPIResponse
-)
-from wordings import (
+import logging
+from utils.wordings import (
   CONFIRM_MAPPING_DETAILS_MD, 
   INTRODUCTION_MD, 
   USE_INFERENCE_API_TIP, 
@@ -30,7 +29,7 @@ MAX_FEATURES = 20
 
 EXAMPLE_MODEL_ID = "cardiffnlp/twitter-roberta-base-sentiment-latest"
 CONFIG_PATH = "./config.yaml"
-
+logger = logging.getLogger(__name__)
 
 def get_demo():
     with gr.Row():
@@ -40,7 +39,7 @@ def get_demo():
         )
     with gr.Row():
         model_id_input = gr.Textbox(
-            label="Hugging Face model id",
+            label="Hugging Face Model id",
             placeholder=EXAMPLE_MODEL_ID + " (press enter to confirm)",
         )
 
@@ -57,12 +56,12 @@ def get_demo():
         dataset_split_input = gr.Dropdown(label="Dataset Split", visible=False, allow_custom_value=True)
 
     with gr.Row():
-        first_line_ds = gr.DataFrame(label="Dataset preview", visible=False)
+        first_line_ds = gr.DataFrame(label="Dataset Preview", visible=False)
     with gr.Row():
         loading_status = gr.HTML(visible=True)
     with gr.Row():
         example_btn = gr.Button(
-            "Validate model & dataset",
+            "Validate Model & Dataset",
             visible=True,
             variant="primary",
             interactive=False,
@@ -104,7 +103,7 @@ def get_demo():
         inference_token_info = gr.HTML(value=HF_TOKEN_INVALID_STYLED, visible=False)
 
         inference_token.change(
-            lambda token: gr.update(visible=lambda: check_hf_token_validity(token)),
+            fn=show_hf_token_info,
             inputs=[inference_token],
             outputs=[inference_token_info],
         )
@@ -160,6 +159,12 @@ def get_demo():
         outputs=[dataset_config_input, dataset_split_input, loading_status]
     )
 
+    gr.on(
+        triggers=[model_id_input.change, dataset_id_input.change, dataset_config_input.change],
+        fn=empty_column_mapping,
+        inputs=[uid_label]
+    )
+
     gr.on(
         triggers=[label.change for label in column_mappings],
         fn=write_column_mapping_to_config,
@@ -237,21 +242,6 @@ def get_demo():
         outputs=[run_btn, logs, uid_label],
     )
 
-    def enable_run_btn(run_inference, inference_token, model_id, dataset_id, dataset_config, dataset_split):
-        if not run_inference or inference_token == "":
-            return gr.update(interactive=False)
-        if model_id == "" or dataset_id == "" or dataset_config == "" or dataset_split == "":
-            return gr.update(interactive=False)
-        if not column_mapping_accordion.visible:
-            return gr.update(interactive=False)
-        _, prediction_response = get_example_prediction(
-            model_id, dataset_id, dataset_config, dataset_split, inference_token
-        )
-        if not isinstance(prediction_response, HuggingFaceInferenceAPIResponse):
-            gr.warning("Your HF token is invalid. Please check your token.")
-            return gr.update(interactive=False)
-        return gr.update(interactive=True)
-
     gr.on(
         triggers=[
             run_inference.input,
@@ -260,6 +250,7 @@ def get_demo():
         ],
         fn=enable_run_btn,
         inputs=[
+            uid_label,
             run_inference, 
             inference_token, 
             model_id_input, 
@@ -274,6 +265,7 @@ def get_demo():
         triggers=[label.input for label in column_mappings],
         fn=enable_run_btn,
         inputs=[
+            uid_label,
             run_inference, 
             inference_token, 
             model_id_input, 

isolated_env.py

@@ -1,7 +1,7 @@
 import os
 import subprocess
 
-from io_utils import write_log_to_user_file
+from utils.io_utils import write_log_to_user_file
 
 
 def prepare_venv(execution_id, deps):

utils.py

@@ -1,29 +0,0 @@
-import sys
-
-import yaml
-
-
-# read scanners from yaml file
-# return a list of scanners
-def read_scanners(path):
-    scanners = []
-    with open(path, "r") as f:
-        config = yaml.load(f, Loader=yaml.FullLoader)
-        scanners = config.get("detectors", None)
-    return scanners
-
-
-# convert a list of scanners to yaml file
-def write_scanners(scanners):
-    with open("./scan_config.yaml", "w") as f:
-        # save scanners to detectors in yaml
-        yaml.dump({"detectors": scanners}, f)
-
-
-# convert column mapping dataframe to json
-def convert_column_mapping_to_json(df, label=""):
-    column_mapping = {}
-    column_mapping[label] = []
-    for _, row in df.iterrows():
-        column_mapping[label].append(row.tolist())
-    return column_mapping

run_jobs.py → utils/run_jobs.py

@@ -6,7 +6,7 @@ import threading
 import time
 from pathlib import Path
 
-import pipe
+import utils.pipe as pipe
 from app_env import (
     HF_GSK_HUB_HF_TOKEN,
     HF_GSK_HUB_KEY,
@@ -17,9 +17,9 @@ from app_env import (
     HF_SPACE_ID,
     HF_WRITE_TOKEN,
 )
-from io_utils import LOG_FILE, get_yaml_path, write_log_to_user_file
+from utils.io_utils import LOG_FILE, get_yaml_path, write_log_to_user_file
 from isolated_env import prepare_venv
-from leaderboard import LEADERBOARD
+from utils.leaderboard import LEADERBOARD
 
 is_running = False
 

text_classification.py → utils/text_classification.py

@@ -1,17 +1,14 @@
-import json
 import logging
 
 import datasets
 import huggingface_hub
-import pandas as pd
-from transformers import pipeline
 import requests
 import os
 
-logger = logging.getLogger(__name__)
-HF_WRITE_TOKEN = "HF_WRITE_TOKEN"
+from app_env import HF_WRITE_TOKEN
 
-logger = logging.getLogger(__file__)
+logger = logging.getLogger(__name__)
+AUTH_CHECK_URL = "https://huggingface.co/api/whoami-v2"
 
 class HuggingFaceInferenceAPIResponse:
     def __init__(self, message):
@@ -93,165 +90,6 @@ def preload_hf_inference_api(model_id):
     hf_token = os.environ.get(HF_WRITE_TOKEN, default="")
     hf_inference_api(model_id, hf_token, payload)
 
-def check_model_pipeline(model_id):
-    try:
-        task = huggingface_hub.model_info(model_id).pipeline_tag
-    except Exception:
-        return None
-
-    try:
-        ppl = pipeline(task=task, model=model_id)
-
-        return ppl
-    except Exception:
-        return None
-
-
-def text_classificaiton_match_label_case_unsensative(id2label_mapping, label):
-    for model_label in id2label_mapping.keys():
-        if model_label.upper() == label.upper():
-            return model_label, label
-    return None, label
-
-
-def text_classification_map_model_and_dataset_labels(id2label, dataset_features):
-    id2label_mapping = {id2label[k]: None for k in id2label.keys()}
-    dataset_labels = None
-    for feature in dataset_features.values():
-        if not isinstance(feature, datasets.ClassLabel):
-            continue
-        if len(feature.names) != len(id2label_mapping.keys()):
-            continue
-
-        dataset_labels = feature.names
-        # Try to match labels
-        for label in feature.names:
-            if label in id2label_mapping.keys():
-                model_label = label
-            else:
-                # Try to find case unsensative
-                model_label, label = text_classificaiton_match_label_case_unsensative(
-                    id2label_mapping, label
-                )
-            if model_label is not None:
-                id2label_mapping[model_label] = label
-            else:
-                print(f"Label {label} is not found in model labels")
-
-    return id2label_mapping, dataset_labels
-
-
-"""
-params:
-    column_mapping: dict
-    example: {
-        "text": "sentences",
-        "label": {
-            "label0": "LABEL_0",
-            "label1": "LABEL_1"
-        }
-    }
-    ppl: pipeline
-"""
-
-
-def check_column_mapping_keys_validity(column_mapping, ppl):
-    # get the element in all the list elements
-    column_mapping = json.loads(column_mapping)
-    if "data" not in column_mapping.keys():
-        return True
-    user_labels = set([pair[0] for pair in column_mapping["data"]])
-    model_labels = set([pair[1] for pair in column_mapping["data"]])
-
-    id2label = ppl.model.config.id2label
-    original_labels = set(id2label.values())
-
-    return user_labels == model_labels == original_labels
-
-
-"""
-params:
-    column_mapping: dict
-    dataset_features: dict
-    example: {
-        'text': Value(dtype='string', id=None), 
-        'label': ClassLabel(names=['negative', 'neutral', 'positive'], id=None)
-    }
-"""
-
-
-def infer_text_input_column(column_mapping, dataset_features):
-    # Check whether we need to infer the text input column
-    infer_text_input_column = True
-    feature_map_df = None
-
-    if "text" in column_mapping.keys():
-        dataset_text_column = column_mapping["text"]
-        if dataset_text_column in dataset_features.keys():
-            infer_text_input_column = False
-        else:
-            logging.warning(f"Provided {dataset_text_column} is not in Dataset columns")
-
-    if infer_text_input_column:
-        # Try to retrieve one
-        candidates = [
-            f for f in dataset_features if dataset_features[f].dtype == "string"
-        ]
-        feature_map_df = pd.DataFrame(
-            {"Dataset Features": [candidates[0]], "Model Input Features": ["text"]}
-        )
-        if len(candidates) > 0:
-            logging.debug(f"Candidates are {candidates}")
-            column_mapping["text"] = candidates[0]
-
-    return column_mapping, feature_map_df
-
-
-"""
-params:
-    column_mapping: dict
-    id2label_mapping: dict
-    example:
-    id2label_mapping: {
-        'negative': 'negative', 
-        'neutral': 'neutral', 
-        'positive': 'positive'
-        }
-"""
-
-
-def infer_output_label_column(
-    column_mapping, id2label_mapping, id2label, dataset_labels
-):
-    # Check whether we need to infer the output label column
-    if "data" in column_mapping.keys():
-        if isinstance(column_mapping["data"], list):
-            # Use the column mapping passed by user
-            for user_label, model_label in column_mapping["data"]:
-                id2label_mapping[model_label] = user_label
-    elif None in id2label_mapping.values():
-        column_mapping["label"] = {i: None for i in id2label.keys()}
-        return column_mapping, None
-
-    if "data" not in column_mapping.keys():
-        # Column mapping should contain original model labels
-        column_mapping["label"] = {
-            str(i): id2label_mapping[label]
-            for i, label in zip(id2label.keys(), dataset_labels)
-        }
-
-    id2label_df = pd.DataFrame(
-        {
-            "Dataset Labels": dataset_labels,
-            "Model Prediction Labels": [
-                id2label_mapping[label] for label in dataset_labels
-            ],
-        }
-    )
-
-    return column_mapping, id2label_df
-
-
 def check_dataset_features_validity(d_id, config, split):
     # We assume dataset is ok here
     ds = datasets.load_dataset(d_id, config, split=split, trust_remote_code=True)
@@ -335,48 +173,6 @@ def get_sample_prediction(ppl, df, column_mapping, id2label_mapping):
     return prediction_input, prediction_result
 
 
-def text_classification_fix_column_mapping(column_mapping, ppl, d_id, config, split):
-    # load dataset as pd DataFrame
-    # get features column from dataset
-    df, dataset_features = check_dataset_features_validity(d_id, config, split)
-
-    column_mapping, feature_map_df = infer_text_input_column(
-        column_mapping, dataset_features
-    )
-    if feature_map_df is None:
-        # dataset does not have any features
-        return None, None, None, None, None
-
-    # Retrieve all labels
-    id2label = ppl.model.config.id2label
-
-    # Infer labels
-    id2label_mapping, dataset_labels = text_classification_map_model_and_dataset_labels(
-        id2label, dataset_features
-    )
-    column_mapping, id2label_df = infer_output_label_column(
-        column_mapping, id2label_mapping, id2label, dataset_labels
-    )
-    if id2label_df is None:
-        # does not able to infer output label column
-        return column_mapping, None, None, None, feature_map_df
-
-    # Get a sample prediction
-    prediction_input, prediction_result = get_sample_prediction(
-        ppl, df, column_mapping, id2label_mapping
-    )
-    if prediction_result is None:
-        # does not able to get a sample prediction
-        return column_mapping, prediction_input, None, id2label_df, feature_map_df
-
-    return (
-        column_mapping,
-        prediction_input,
-        prediction_result,
-        id2label_df,
-        feature_map_df,
-    )
-
 def strip_model_id_from_url(model_id):
     if model_id.startswith("https://huggingface.co/"):
         return "/".join(model_id.split("/")[-2])
@@ -387,9 +183,9 @@ def check_hf_token_validity(hf_token):
         return False
     if not isinstance(hf_token, str):
         return False
-    # use inference api to check the token
-    payload = {"inputs": "This is a test", "options": {"use_cache": True}}
-    response = hf_inference_api("cardiffnlp/twitter-roberta-base-sentiment-latest", hf_token, payload)
-    if "error" in response:
+    # use huggingface api to check the token
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    response = requests.get(AUTH_CHECK_URL, headers=headers)
+    if response.status_code != 200:
         return False
     return True

text_classification_ui_helpers.py → utils/ui_helpers.py

@@ -7,18 +7,19 @@ import datasets
 import gradio as gr
 import pandas as pd
 
-import leaderboard
-from io_utils import read_column_mapping, write_column_mapping
-from run_jobs import save_job_to_pipe
-from text_classification import (
+import utils.leaderboard as leaderboard
+from utils.io_utils import read_column_mapping, write_column_mapping
+from utils.run_jobs import save_job_to_pipe
+from utils.text_classification import (
     strip_model_id_from_url,
     check_model_task,
     preload_hf_inference_api,
     get_example_prediction,
     get_labels_and_features_from_dataset,
+    check_hf_token_validity,
     HuggingFaceInferenceAPIResponse,
 )
-from wordings import (
+from utils.wordings import (
     CHECK_CONFIG_OR_SPLIT_RAW,
     CONFIRM_MAPPING_DETAILS_FAIL_RAW,
     MAPPING_STYLED_ERROR_WARNING,
@@ -26,6 +27,7 @@ from wordings import (
     UNMATCHED_MODEL_DATASET_STYLED_ERROR,
     CHECK_LOG_SECTION_RAW,
     get_styled_input,
+    get_dataset_fetch_error_raw,
 )
 import os
 
@@ -35,6 +37,9 @@ MAX_FEATURES = 20
 ds_dict = None
 ds_config = None
 
+logger = logging.getLogger(__file__)
+
+
 def get_related_datasets_from_leaderboard(model_id):
     records = leaderboard.records
     model_id = strip_model_id_from_url(model_id)
@@ -46,18 +51,14 @@ def get_related_datasets_from_leaderboard(model_id):
     
     return gr.update(choices=datasets_unique, value="")
 
-
-logger = logging.getLogger(__file__)
-
-
 def check_dataset(dataset_id):
     logger.info(f"Loading {dataset_id}")
     try:
         configs = datasets.get_dataset_config_names(dataset_id, trust_remote_code=True)
         if len(configs) == 0:
             return (
-                gr.update(),
-                gr.update(),
+                gr.update(visible=False),
+                gr.update(visible=False),
                 ""
             )
         splits = datasets.get_dataset_split_names(
@@ -70,13 +71,18 @@ def check_dataset(dataset_id):
         )
     except Exception as e:
         logger.warn(f"Check your dataset {dataset_id}: {e}")
+        if "doesn't exist" in str(e):
+            gr.Warning(get_dataset_fetch_error_raw(e))
+        if "forbidden" in str(e).lower(): # GSK-2770
+            gr.Warning(get_dataset_fetch_error_raw(e))
         return (
-            gr.update(),
-            gr.update(),
+            gr.update(visible=False),
+            gr.update(visible=False),
             ""
         )
 
-
+def empty_column_mapping(uid):
+    write_column_mapping(None, uid)
 
 def write_column_mapping_to_config(uid, *labels):
     # TODO: Substitute 'text' with more features for zero-shot
@@ -95,7 +101,6 @@ def write_column_mapping_to_config(uid, *labels):
 
     write_column_mapping(all_mappings, uid)
 
-
 def export_mappings(all_mappings, key, subkeys, values):
     if key not in all_mappings.keys():
         all_mappings[key] = dict()
@@ -111,7 +116,6 @@ def export_mappings(all_mappings, key, subkeys, values):
             all_mappings[key][subkey] = values[i % len(values)]
     return all_mappings
 
-
 def list_labels_and_features_from_dataset(ds_labels, ds_features, model_labels, uid):
     all_mappings = read_column_mapping(uid)
     # For flattened raw datasets with no labels
@@ -160,19 +164,20 @@ def list_labels_and_features_from_dataset(ds_labels, ds_features, model_labels,
 
     return lables + features
 
-
 def precheck_model_ds_enable_example_btn(
     model_id, dataset_id, dataset_config, dataset_split
 ):
+    if model_id == "" or dataset_id == "":
+        return (gr.update(interactive=False), gr.update(visible=False), "")
     model_id = strip_model_id_from_url(model_id)
     model_task = check_model_task(model_id)
     preload_hf_inference_api(model_id)
     if model_task is None or model_task != "text-classification":
         gr.Warning(NOT_TEXT_CLASSIFICATION_MODEL_RAW)
-        return (gr.update(), gr.update(),"")
-
+        return (gr.update(interactive=False), gr.update(visible=False), "")
+    
     if dataset_config is None or dataset_split is None or len(dataset_config) == 0:
-        return (gr.update(), gr.update(), "")
+        return (gr.update(interactive=False), gr.update(visible=False), "")
     
     try:
         ds = datasets.load_dataset(dataset_id, dataset_config, trust_remote_code=True)
@@ -304,12 +309,31 @@ def align_columns_and_show_prediction(
 def check_column_mapping_keys_validity(all_mappings):
     if all_mappings is None:
         gr.Warning(CONFIRM_MAPPING_DETAILS_FAIL_RAW)
-        return (gr.update(interactive=True), gr.update(visible=False))
+        return False
 
     if "labels" not in all_mappings.keys():
         gr.Warning(CONFIRM_MAPPING_DETAILS_FAIL_RAW)
-        return (gr.update(interactive=True), gr.update(visible=False))
+        return False
 
+    return True
+
+def enable_run_btn(uid, run_inference, inference_token, model_id, dataset_id, dataset_config, dataset_split):
+    if not run_inference or inference_token == "":
+        logger.warn("Inference API is not enabled")
+        return gr.update(interactive=False)
+    if model_id == "" or dataset_id == "" or dataset_config == "" or dataset_split == "":
+        logger.warn("Model id or dataset id is not selected")
+        return gr.update(interactive=False)
+    
+    all_mappings = read_column_mapping(uid)
+    if not check_column_mapping_keys_validity(all_mappings):
+        logger.warn("Column mapping is not valid")
+        return gr.update(interactive=False)
+
+    if not check_hf_token_validity(inference_token):
+        logger.warn("HF token is not valid")
+        return gr.update(interactive=False)
+    return gr.update(interactive=True)
 
 def construct_label_and_feature_mapping(all_mappings, ds_labels, ds_features):
     label_mapping = {}
@@ -328,9 +352,16 @@ def construct_label_and_feature_mapping(all_mappings, ds_labels, ds_features):
     feature_mapping = all_mappings["features"]
     return label_mapping, feature_mapping
 
+def show_hf_token_info(token):
+    valid = check_hf_token_validity(token)
+    if not valid:
+        return gr.update(visible=True)
+    return gr.update(visible=False)
+
 def try_submit(m_id, d_id, config, split, inference, inference_token, uid):
     all_mappings = read_column_mapping(uid)
-    check_column_mapping_keys_validity(all_mappings)
+    if not check_column_mapping_keys_validity(all_mappings):
+        return (gr.update(interactive=True), gr.update(visible=False))
 
     # get ds labels and features again for alignment
     ds = datasets.load_dataset(d_id, config, split=split, trust_remote_code=True)

wordings.py → utils/wordings.py

@@ -1,28 +1,28 @@
 INTRODUCTION_MD = """
                 <h1 style="text-align: center;">
-                🐢Giskard Evaluator
+                🐢Giskard Evaluator - Text Classification
                 </h1>
-                Welcome to Giskard Evaluator Space! Get your report immediately by simply input your model id and dataset id below. Follow our leads and improve your model.
+                Welcome to the Giskard Evaluator Space! Get a model vulnerability report immediately by simply sharing your model and dataset id below.
                 """
 CONFIRM_MAPPING_DETAILS_MD = """
                             <h1 style="text-align: center;">
                             Confirm Pre-processing Details
                             </h1>
-                            Please confirm the pre-processing details below. Align the column names of your model in the <b>dropdown</b> menu to your dataset's. If you are not sure, please double check your model and dataset.
+                            Make sure the output variable's labels and the input variable's name are accurately mapped across both the dataset and the model.
                             """
 CONFIRM_MAPPING_DETAILS_FAIL_MD = """
                             <h1 style="text-align: center;">
                             Confirm Pre-processing Details
                             </h1>
-                            Sorry, we cannot align the input/output of your dataset with the model. <b>Pleaser double check your model and dataset.</b>
+                            We're unable to automatically map the input variable's name and output variable's labels of your dataset with the model's. <b>Please manually check the mapping below.</b>
                             """
 
 CONFIRM_MAPPING_DETAILS_FAIL_RAW = """
-                            Sorry, we cannot auto-align the input/output of your dataset with the model.
+                            We're unable to automatically map the input variable's name and output variable's labels of your dataset with the model's. <b>Please manually check the mapping below.</b>
                             """
 
 CHECK_CONFIG_OR_SPLIT_RAW = """
-                            Please check your dataset config or split.
+                            We're unanle to extract labels or features from your dataset. Please check your dataset config or split selection.
                             """
 
 CHECK_LOG_SECTION_RAW = """
@@ -33,18 +33,18 @@ PREDICTION_SAMPLE_MD = """
                         <h1 style="text-align: center;">
                         Model Prediction Sample
                         </h1>
-                        Here is a sample prediction from your model based on your dataset.
+                        Here's a sample of your model's prediction on an example from the dataset.
                         """
 
 MAPPING_STYLED_ERROR_WARNING = """
                         <h3 style="text-align: center;color: orange; background-color: #fff0f3; border-radius: 8px; padding: 10px; ">
-                        Sorry, we cannot auto-align the labels/features of your dataset and model. Please double check.
+                        ⚠️ We're unable to automatically map the input variable's name and output variable's labels of your dataset with the model's. <b>Please manually check the mapping below.</b>
                         </h3>
                         """
 
 UNMATCHED_MODEL_DATASET_STYLED_ERROR = """
                         <h3 style="text-align: center;color: #fa5f5f; background-color: #fbe2e2; border-radius: 8px; padding: 10px; ">
-                        Your model and dataset have different numbers of labels. Please double check your model and dataset.
+                        ❌ Your model and dataset have different numbers of labels. Please double check your model and dataset.
                         </h3>
                         """
 
@@ -53,30 +53,22 @@ NOT_TEXT_CLASSIFICATION_MODEL_RAW = """
                       """
 
 USE_INFERENCE_API_TIP = """
-                We recommend to use
+                To speed up the evaluation, we recommend using the
                 <a href="https://huggingface.co/docs/api-inference/detailed_parameters#text-classification-task">
                     Hugging Face Inference API
                 </a>
-                for the evaluation,
-                which requires your <a href="https://huggingface.co/settings/tokens">HF token</a>.
-                <br/>
-                Otherwise, an
-                <a href="https://huggingface.co/docs/transformers/main_classes/pipelines#transformers.TextClassificationPipeline">
-                    HF pipeline 
-                </a>
-                will be created and run in this Space. It takes more time to get the result.
-                <br/>
-                <b>
-                Do not worry, your HF token is only used in this Space for your evaluation.
-                </b>
+                . Please input your <a href="https://huggingface.co/settings/tokens">Hugging Face token</a> to do so.
             """
 
 HF_TOKEN_INVALID_STYLED= """
-                <h3 style="text-align: center;color: #fa5f5f; background-color: #fbe2e2; border-radius: 8px; padding: 10px; ">
+                <p style="text-align: left;color: red; ">
                 Your Hugging Face token is invalid. Please double check your token.
-                </h3>
+                </p>
                 """
 
+def get_dataset_fetch_error_raw(error):
+    return f"""Sorry you cannot use this dataset because {error}. Contact HF team to support this dataset."""
+
 def get_styled_input(input):
     return f"""<h3 style="text-align: center;color: #4ca154; background-color: #e2fbe8; border-radius: 8px; padding: 10px; ">
             Your model and dataset have been validated! <br /> Sample input: {input}