evalscope 0.14.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

evalscope/models/local_model.py

@@ -1,7 +1,8 @@
-import torch
+import importlib
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 
-from evalscope.constants import DEFAULT_MODEL_CACHE_DIR, DEFAULT_MODEL_REVISION, EvalType
+from evalscope.constants import DEFAULT_MODEL_CACHE_DIR, DEFAULT_MODEL_REVISION, EvalType, ModelTask
 from evalscope.utils.logger import get_logger
 from evalscope.utils.model_utils import get_device
 
@@ -11,31 +12,55 @@ if TYPE_CHECKING:
 logger = get_logger()
 
 
-class LocalModel:
+class LocalModel(ABC):
 
     def __init__(self,
                  model_id: str,
-                 model_revision: str = DEFAULT_MODEL_REVISION,
-                 device_map: str = 'auto',
+                 model_revision: str = None,
+                 device_map: str = None,
                  torch_dtype: str = 'auto',
                  cache_dir: str = None,
                  **kwargs):
-        from modelscope import AutoModelForCausalLM, AutoTokenizer
 
-        model_cache_dir = cache_dir or DEFAULT_MODEL_CACHE_DIR
+        self.model_id = model_id
+        self.model_revision = model_revision or DEFAULT_MODEL_REVISION
+        self.device = device_map or get_device()
+        self.cache_dir = cache_dir or DEFAULT_MODEL_CACHE_DIR
+        self.kwargs = kwargs
+        self.model = None
+        self.tokenizer = None
 
         if isinstance(torch_dtype, str) and torch_dtype != 'auto':
+            import torch
             torch_dtype = eval(torch_dtype)
+        self.torch_dtype = torch_dtype
+
+        self.model_cfg = {
+            'model_id': self.model_id,
+            'device_map': self.device,
+            'torch_dtype': str(self.torch_dtype),
+        }
+
+    @abstractmethod
+    def load_model(self):
+        pass
 
-        self.model_id = model_id
-        self.model_revision = model_revision
-        self.device = device_map
+
+class LocalChatModel(LocalModel):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def load_model(self):
+        from modelscope import AutoModelForCausalLM, AutoTokenizer
+
+        logger.info(f'Loading model {self.model_id} ...')
 
         self.tokenizer = AutoTokenizer.from_pretrained(
             self.model_id,
-            revision=model_revision,
+            revision=self.model_revision,
             trust_remote_code=True,
-            cache_dir=model_cache_dir,
+            cache_dir=self.cache_dir,
         )
 
         # Fix no padding
@@ -44,18 +69,45 @@ class LocalModel:
 
         self.model = AutoModelForCausalLM.from_pretrained(
             self.model_id,
-            revision=model_revision,
-            device_map=device_map,
+            revision=self.model_revision,
+            device_map=self.device,
             trust_remote_code=True,
-            torch_dtype=torch_dtype,
-            cache_dir=model_cache_dir,
+            torch_dtype=self.torch_dtype,
+            cache_dir=self.cache_dir,
         )
 
-        self.model_cfg = {
-            'model_id': model_id,
-            'device_map': device_map,
-            'torch_dtype': str(torch_dtype),
-        }
+
+class LocalImageModel(LocalModel):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.pipeline_cls = kwargs.pop('pipeline_cls', None)
+        # default to DiffusionPipeline if not specified
+        if self.pipeline_cls is None:
+            if 'flux' in self.model_id.lower():
+                self.pipeline_cls = 'FluxPipeline'
+            else:
+                self.pipeline_cls = 'DiffusionPipeline'
+
+    def load_model(self):
+        # from modelscope import pipeline_cls
+        module = getattr(importlib.import_module('modelscope'), self.pipeline_cls)
+
+        logger.info(f'Loading model {self.model_id} with {self.pipeline_cls} ...')
+
+        self.model = module.from_pretrained(
+            self.model_id,
+            revision=self.model_revision,
+            torch_dtype=self.torch_dtype,
+            cache_dir=self.cache_dir,
+            **self.kwargs,
+        )
+
+        self.model.to(self.device)
+
+    def __call__(self, *args, **kwargs):
+        return self.model(*args, **kwargs)
 
 
 def get_local_model(task_cfg: 'TaskConfig') -> Optional[LocalModel]:
@@ -64,16 +116,13 @@ def get_local_model(task_cfg: 'TaskConfig') -> Optional[LocalModel]:
     """
     if task_cfg.eval_type != EvalType.CHECKPOINT:
         return None
-    else:
-        device_map = task_cfg.model_args.get('device_map', get_device())
-        cache_dir = task_cfg.model_args.get('cache_dir', None)
-        model_precision = task_cfg.model_args.get('precision', 'torch.float16')
-        model_revision = task_cfg.model_args.get('revision', DEFAULT_MODEL_REVISION)
-
-        base_model = LocalModel(
-            model_id=task_cfg.model,
-            model_revision=model_revision,
-            device_map=device_map,
-            torch_dtype=model_precision,
-            cache_dir=cache_dir)
+    elif task_cfg.model_task == ModelTask.TEXT_GENERATION:
+        base_model = LocalChatModel(model_id=task_cfg.model, **task_cfg.model_args)
+        base_model.load_model()
+        return base_model
+    elif task_cfg.model_task == ModelTask.IMAGE_GENERATION:
+        base_model = LocalImageModel(model_id=task_cfg.model, **task_cfg.model_args)
+        base_model.load_model()
         return base_model
+    else:
+        raise ValueError(f'Unsupported model task: {task_cfg.model_task} for model checkpoint.')

evalscope/models/model.py

@@ -1,9 +1,8 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 import os
-import random
 import time
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, List
 
 from evalscope.utils.logger import get_logger
 
@@ -95,6 +94,7 @@ class ChatBaseModel(BaseModel):
         raise NotImplementedError
 
 
+# TODO: Remove this class after refactoring all models
 class OpenAIModel(ChatBaseModel):
     """
     APIs of OpenAI models.
@@ -187,43 +187,3 @@ class OpenAIModel(ChatBaseModel):
                 time.sleep(3)
         logger.error(f'OpenAI API call failed after {self.MAX_RETRIES} retries')
         return res
-
-
-class DummyChatModel(ChatBaseModel):
-
-    MODEL_ID = 'dummy_chat_model_0801'
-    REVISION = 'v1.0.0'
-
-    def __init__(self, model_cfg: dict, **kwargs):
-        model_cfg['model_id'] = self.MODEL_ID
-        model_cfg['revision'] = self.REVISION
-        super(DummyChatModel, self).__init__(model_cfg=model_cfg)
-
-    def predict(self, inputs: dict, **kwargs) -> dict:
-
-        debug: bool = False
-        if debug:
-            messages = inputs['messages']
-            history = inputs['history']
-
-            logger.info(f'** messages: {messages}')
-            logger.info(f'** history: {history}')
-
-        choice = random.choice(['A', 'B', 'C', 'D'])
-
-        # Build response
-        res = {
-            'choices': [{
-                'index': 0,
-                'message': {
-                    'content': choice,
-                    'role': 'assistant'
-                }
-            }],
-            'created': time.time(),
-            'model': self.MODEL_ID + '-' + self.REVISION,
-            'object': 'chat.completion',
-            'usage': {}
-        }
-
-        return res

evalscope/models/register.py

@@ -1,3 +1,6 @@
+from evalscope.constants import OutputType
+from .adapters import *
+
 MODEL_ADAPTERS = {}
 
 
@@ -26,3 +29,26 @@ def get_model_adapter(name):
         raise ValueError(
             f"Model adapter '{name}' is not registered. Available model adapters: {list(MODEL_ADAPTERS.keys())}")
     return MODEL_ADAPTERS[name]
+
+
+def register_model_adapter_class(cls, name=None):
+    """
+    Register a model adapter class.
+    :param cls: The model adapter class to register
+    :param name: Optional name for the model adapter. If not provided, the class name will be used.
+    """
+    if name is None:
+        name = cls.__name__
+    if name in MODEL_ADAPTERS:
+        raise ValueError(f"Model adapter class '{name}' is already registered.")
+    MODEL_ADAPTERS[name] = cls
+
+
+# register all model adapters
+register_model_adapter_class(BaseModelAdapter, name='base')
+register_model_adapter_class(ChatGenerationModelAdapter, name=OutputType.GENERATION)
+register_model_adapter_class(ContinuationLogitsModelAdapter, name=OutputType.LOGITS)
+register_model_adapter_class(MultiChoiceModelAdapter, name=OutputType.MULTIPLE_CHOICE)
+register_model_adapter_class(CustomModelAdapter, name='custom')
+register_model_adapter_class(ServerModelAdapter, name='server')
+register_model_adapter_class(T2IModelAdapter, name=OutputType.IMAGE_GENERATION)

evalscope/perf/benchmark.py

@@ -9,7 +9,7 @@ import threading
 import time
 from http import HTTPStatus
 from tqdm import tqdm
-from typing import AsyncGenerator, List
+from typing import AsyncGenerator, Dict, List, Tuple
 
 from evalscope.perf.arguments import Arguments
 from evalscope.perf.http_client import AioHttpClient, test_connection
@@ -180,7 +180,7 @@ async def connect_test(args: Arguments) -> bool:
 
 
 @exception_handler
-async def benchmark(args: Arguments) -> None:
+async def benchmark(args: Arguments) -> Tuple[Dict, Dict]:
     if platform.system() != 'Windows':
         loop = asyncio.get_running_loop()
         add_signal_handlers(loop)
@@ -205,4 +205,5 @@ async def benchmark(args: Arguments) -> None:
     data_process_completed_event.set()
 
     metrics, result_db_path = await statistic_benchmark_metric_task
-    summary_result(args, metrics, result_db_path)
+    metrics_result, percentile_result = summary_result(args, metrics, result_db_path)
+    return metrics_result, percentile_result

evalscope/perf/main.py

@@ -36,9 +36,11 @@ def run_perf_benchmark(args):
     if platform.system() != 'Windows':
         add_signal_handlers(loop)
 
-    loop.run_until_complete(benchmark(args))
+    return loop.run_until_complete(benchmark(args))
 
 
 if __name__ == '__main__':
     args = Arguments.from_args(parse_args())
-    run_perf_benchmark(args)
+    metrics_result, percentile_result = run_perf_benchmark(args)
+    print(metrics_result)
+    print(percentile_result)

evalscope/perf/plugin/datasets/flickr8k.py

@@ -30,6 +30,7 @@ class FlickrDatasetPlugin(DatasetPluginBase):
 
         for item in dataset:
             pil_image = item['jpg']
+            text = item['txt']
             base64_iamge = PIL_to_base64(pil_image)
 
             yield [{
@@ -38,7 +39,7 @@ class FlickrDatasetPlugin(DatasetPluginBase):
                 'content': [
                     {
                         'type': 'text',
-                        'text': 'Describe the image'
+                        'text': text,
                     },
                     {
                         'type': 'image_url',

evalscope/perf/utils/benchmark_util.py

@@ -32,13 +32,13 @@ class BenchmarkData:
         self.query_latency = self.completed_time - self.start_time
         if len(self.chunk_times) > 1:
             self.first_chunk_latency = self.chunk_times[0] - self.start_time
-            self.n_chunks = len(self.chunk_times) - 2
+            self.n_chunks = len(self.chunk_times) - 2  # remove last and first chunk
             self.n_chunks_time = self.chunk_times[-2] - self.chunk_times[0]
         else:
             self.first_chunk_latency = self.query_latency
             self.n_chunks = 1
             self.n_chunks_time = self.query_latency
-        self.time_per_output_token = self.query_latency / self.completion_tokens
+        self.time_per_output_token = self.n_chunks_time / self.completion_tokens
 
     def _calculate_tokens(self, api_plugin):
         self.prompt_tokens, self.completion_tokens = \

evalscope/perf/utils/db_util.py

@@ -7,7 +7,7 @@ import sqlite3
 import sys
 from datetime import datetime
 from tabulate import tabulate
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 from evalscope.perf.arguments import Arguments
 from evalscope.perf.utils.benchmark_util import BenchmarkData, BenchmarkMetrics
@@ -165,6 +165,7 @@ def get_percentile_results(result_db_path: str) -> Dict[str, List[float]]:
     CHUNK_TIMES_INDEX = 1
     LATENCY_INDEX = 4
     FIRST_CHUNK_LATENCY_INDEX = 5
+    CHUNK_TIME_INDEX = 7
     PROMPT_TOKENS_INDEX = 8
     COMPLETION_TOKENS_INDEX = 9
 
@@ -177,12 +178,17 @@ def get_percentile_results(result_db_path: str) -> Dict[str, List[float]]:
         'TTFT (s)': [row[FIRST_CHUNK_LATENCY_INDEX] for row in rows],
         'ITL (s)':
         inter_token_latencies_all,
+        'TPOT (s)':
+        [(row[CHUNK_TIME_INDEX] / row[COMPLETION_TOKENS_INDEX]) if row[COMPLETION_TOKENS_INDEX] > 0 else float('nan')
+         for row in rows],
         'Latency (s)': [row[LATENCY_INDEX] for row in rows],
         'Input tokens': [row[PROMPT_TOKENS_INDEX] for row in rows],
         'Output tokens': [row[COMPLETION_TOKENS_INDEX] for row in rows],
-        'Throughput(tokens/s)':
+        'Output throughput(tok/s)':
         [(row[COMPLETION_TOKENS_INDEX] / row[LATENCY_INDEX]) if row[LATENCY_INDEX] > 0 else float('nan')
-         for row in rows]
+         for row in rows],
+        'Total throughput(tok/s)': [((row[PROMPT_TOKENS_INDEX] + row[COMPLETION_TOKENS_INDEX])
+                                     / row[LATENCY_INDEX]) if row[LATENCY_INDEX] > 0 else float('nan') for row in rows]
     }
 
     # Calculate percentiles for each metric
@@ -194,16 +200,16 @@ def get_percentile_results(result_db_path: str) -> Dict[str, List[float]]:
     return results
 
 
-def summary_result(args: Arguments, metrics: BenchmarkMetrics, result_db_path: str):
+def summary_result(args: Arguments, metrics: BenchmarkMetrics, result_db_path: str) -> Tuple[Dict, Dict]:
     result_path = os.path.dirname(result_db_path)
     write_json_file(args.to_dict(), os.path.join(result_path, 'benchmark_args.json'))
 
-    data = metrics.create_message()
-    data.update({'Expected number of requests': args.number, 'Result DB path': result_db_path})
-    write_json_file(data, os.path.join(result_path, 'benchmark_summary.json'))
+    metrics_result = metrics.create_message()
+    metrics_result.update({'Expected number of requests': args.number, 'Result DB path': result_db_path})
+    write_json_file(metrics_result, os.path.join(result_path, 'benchmark_summary.json'))
 
     # Print summary in a table
-    table = tabulate(list(data.items()), headers=['Key', 'Value'], tablefmt='grid')
+    table = tabulate(list(metrics_result.items()), headers=['Key', 'Value'], tablefmt='grid')
     logger.info('\nBenchmarking summary:\n' + table)
 
     # Get percentile results
@@ -217,6 +223,8 @@ def summary_result(args: Arguments, metrics: BenchmarkMetrics, result_db_path: s
     if args.dataset.startswith('speed_benchmark'):
         speed_benchmark_result(result_db_path)
 
+    return metrics_result, percentile_result
+
 
 def speed_benchmark_result(result_db_path: str):
     query_sql = """

evalscope/report/__init__.py

@@ -1,5 +1,6 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
+from evalscope.report.app_arguments import add_argument
 from evalscope.report.combinator import gen_table, get_data_frame, get_report_list
 from evalscope.report.generator import ReportGenerator
 from evalscope.report.utils import Category, Report, ReportKey, Subset

evalscope/report/app.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from typing import Any, List, Union
 
 from evalscope.constants import DataCollection
-from evalscope.report import Report, ReportKey, get_data_frame, get_report_list
+from evalscope.report import Report, ReportKey, add_argument, get_data_frame, get_report_list
 from evalscope.utils.io_utils import OutputsStructure, yaml_to_dict
 from evalscope.utils.logger import configure_logging, get_logger
 from evalscope.version import __version__
@@ -22,6 +22,23 @@ PLOTLY_THEME = 'plotly_dark'
 REPORT_TOKEN = '@@'
 MODEL_TOKEN = '::'
 DATASET_TOKEN = ', '
+LATEX_DELIMITERS = [{
+    'left': '$$',
+    'right': '$$',
+    'display': True
+}, {
+    'left': '$',
+    'right': '$',
+    'display': False
+}, {
+    'left': '\\(',
+    'right': '\\)',
+    'display': False
+}, {
+    'left': '\\[',
+    'right': '\\]',
+    'display': True
+}]
 
 
 def scan_for_report_folders(root_path):
@@ -234,6 +251,18 @@ def convert_html_tags(text):
     return text
 
 
+def convert_markdown_image(text):
+    if not os.path.isfile(text):
+        return text
+    # Convert the image path to a markdown image tag
+    if text.endswith('.png') or text.endswith('.jpg') or text.endswith('.jpeg'):
+        text = os.path.abspath(text)
+        image_tag = f'![image](gradio_api/file={text})'
+        logger.debug(f'Converting image path to markdown: {text} -> {image_tag}')
+        return image_tag
+    return text
+
+
 def process_string(string: str, max_length: int = 2048) -> str:
     string = convert_html_tags(string)  # for display labels e.g. `<think>`
     if len(string) > max_length:
@@ -285,7 +314,7 @@ def get_model_prediction(work_dir: str, model_name: str, dataset_name: str, subs
                 'Input': raw_input,
                 'Generated': raw_pred_answer,
                 'Gold': parsed_gold_answer if parsed_gold_answer != raw_input else '*Same as Input*',
-                'Pred': parsed_pred_answer if parsed_pred_answer != raw_pred_answer else '*Same as Generated*',
+                'Pred': parsed_pred_answer,
                 'Score': score,
                 'NScore': normalize_score(score)
             }
@@ -295,22 +324,6 @@ def get_model_prediction(work_dir: str, model_name: str, dataset_name: str, subs
     return df_subset
 
 
-def get_table_data(data_review_df: pd.DataFrame, page: int = 1, rows_per_page: int = 1) -> pd.DataFrame:
-    if data_review_df is None:
-        return pd.DataFrame(), None
-
-    logger.debug(f'page: {page}, rows_per_page: {rows_per_page}')
-    start = (page - 1) * rows_per_page
-    end = start + rows_per_page
-    df_subset = data_review_df.iloc[start:end].copy()
-    df_subset['Input'] = df_subset['Input'].map(process_model_prediction).astype(str)
-    df_subset['Generated'] = df_subset['Generated'].map(process_model_prediction).astype(str)
-    df_subset['Pred'] = df_subset['Pred'].map(process_model_prediction).astype(str)
-    df_subset['Score'] = df_subset['Score'].map(process_model_prediction).astype(str)
-    styler = style_df(df_subset, columns=['NScore'])
-    return df_subset, styler
-
-
 @dataclass
 class SidebarComponents:
     root_path: gr.Textbox
@@ -457,7 +470,11 @@ def create_single_model_tab(sidebar: SidebarComponents, lang: str):
         'page': {
             'zh': '页码',
             'en': 'Page'
-        }
+        },
+        'score_threshold': {
+            'zh': '分数阈值',
+            'en': 'Score Threshold'
+        },
     }
 
     # Update the UI components with localized labels
@@ -489,37 +506,53 @@ def create_single_model_tab(sidebar: SidebarComponents, lang: str):
         gr.Markdown(f'### {locale_dict["model_prediction"][lang]}')
         subset_select = gr.Dropdown(
             label=locale_dict['select_subset'][lang], choices=[], show_label=True, interactive=True)
+
         with gr.Row():
             answer_mode_radio = gr.Radio(
                 label=locale_dict['answer_mode'][lang], choices=['All', 'Pass', 'Fail'], value='All', interactive=True)
-            page_number = gr.Number(
-                value=1, label=locale_dict['page'][lang], minimum=1, maximum=1, step=1, interactive=True)
-        answer_mode_counts = gr.Markdown('', label='Counts')
+            score_threshold = gr.Number(value=0.99, label=locale_dict['score_threshold'][lang], interactive=True)
+
         data_review_df = gr.State(None)
         filtered_review_df = gr.State(None)
-        data_review_table = gr.DataFrame(
-            value=None,
-            datatype=['markdown', 'markdown', 'markdown', 'markdown', 'markdown', 'number'],
-            # column_widths=['500px', '500px'],
-            wrap=True,
-            latex_delimiters=[{
-                'left': '$$',
-                'right': '$$',
-                'display': True
-            }, {
-                'left': '$',
-                'right': '$',
-                'display': False
-            }, {
-                'left': '\\(',
-                'right': '\\)',
-                'display': False
-            }, {
-                'left': '\\[',
-                'right': '\\]',
-                'display': True
-            }],
-            max_height=600)
+
+        # show statistics
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                gr.Markdown('### *Counts*')
+                answer_mode_counts = gr.Markdown('')
+            with gr.Column():
+                page_number = gr.Number(
+                    value=1, label=locale_dict['page'][lang], minimum=1, maximum=1, step=1, interactive=True)
+
+        # show data review table
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                gr.Markdown('### *Score*')
+                score_text = gr.Markdown(
+                    '', elem_id='score_text', latex_delimiters=LATEX_DELIMITERS, show_copy_button=True)
+            with gr.Column():
+                gr.Markdown('### *Normalized Score*')
+                nscore = gr.Markdown('', elem_id='score_text', latex_delimiters=LATEX_DELIMITERS)
+
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                gr.Markdown('### *Gold*')
+                gold_text = gr.Markdown(
+                    '', elem_id='gold_text', latex_delimiters=LATEX_DELIMITERS, show_copy_button=True)
+            with gr.Column():
+                gr.Markdown('### *Pred*')
+                pred_text = gr.Markdown(
+                    '', elem_id='pred_text', latex_delimiters=LATEX_DELIMITERS, show_copy_button=True)
+
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                gr.Markdown('### *Input*')
+                input_text = gr.Markdown(
+                    '', elem_id='input_text', latex_delimiters=LATEX_DELIMITERS, show_copy_button=True)
+            with gr.Column():
+                gr.Markdown('### *Generated*')
+                generated_text = gr.Markdown(
+                    '', elem_id='generated_text', latex_delimiters=LATEX_DELIMITERS, show_copy_button=True)
 
     @report_name.change(
         inputs=[sidebar.root_path, report_name],
@@ -561,15 +594,15 @@ def create_single_model_tab(sidebar: SidebarComponents, lang: str):
         return data_review_df, 1
 
     @gr.on(
-        triggers=[data_review_df.change, answer_mode_radio.change],
-        inputs=[data_review_df, answer_mode_radio],
+        triggers=[data_review_df.change, answer_mode_radio.change, score_threshold.change],
+        inputs=[data_review_df, answer_mode_radio, score_threshold],
         outputs=[filtered_review_df, page_number, answer_mode_counts])
-    def filter_data(data_review_df, answer_mode):
+    def filter_data(data_review_df, answer_mode, score_threshold):
         if data_review_df is None:
             return None, gr.update(value=1, maximum=1), ''
 
         all_count = len(data_review_df)
-        pass_df = data_review_df[data_review_df['NScore'] >= 0.99]
+        pass_df = data_review_df[data_review_df['NScore'] >= score_threshold]
         pass_count = len(pass_df)
         fail_count = all_count - pass_count
 
@@ -578,7 +611,7 @@ def create_single_model_tab(sidebar: SidebarComponents, lang: str):
         if answer_mode == 'Pass':
             filtered_df = pass_df
         elif answer_mode == 'Fail':
-            filtered_df = data_review_df[data_review_df['NScore'] < 0.99]
+            filtered_df = data_review_df[data_review_df['NScore'] < score_threshold]
         else:
             filtered_df = data_review_df
 
@@ -588,13 +621,33 @@ def create_single_model_tab(sidebar: SidebarComponents, lang: str):
 
     @gr.on(
         triggers=[filtered_review_df.change, page_number.change],
-        inputs=[filtered_review_df, page_number],
-        outputs=[data_review_table])
-    def update_table(filtered_df, page_number):
-        if filtered_df is None:
-            return gr.update(value=None)
-        subset_df, styler = get_table_data(filtered_df, page_number)
-        return styler
+        inputs=[filtered_review_df, page_number, score_threshold],
+        outputs=[input_text, generated_text, gold_text, pred_text, score_text, nscore])
+    def update_table_components(filtered_df, page_number, score_threshold):
+        if filtered_df is None or len(filtered_df) == 0:
+            return '', '', '', '', '', ''
+
+        # Get single row data for the current page
+        start = (page_number - 1)
+        if start >= len(filtered_df):
+            return '', '', '', '', '', ''
+
+        row = filtered_df.iloc[start]
+
+        # Process the data for display
+        input_md = process_model_prediction(row['Input'])
+        generated_md = process_model_prediction(row['Generated'])
+        gold_md = process_model_prediction(row['Gold'])
+        pred_md = convert_markdown_image(process_model_prediction(row['Pred']))
+        score_md = process_model_prediction(row['Score'])
+        nscore_val = float(row['NScore']) if not pd.isna(row['NScore']) else 0.0
+
+        if nscore_val >= score_threshold:
+            nscore_val = f'<div style="background-color:rgb(45,104, 62); padding:10px;">{nscore_val}</div>'
+        else:
+            nscore_val = f'<div style="background-color:rgb(151, 31, 44); padding:10px;">{nscore_val}</div>'
+
+        return input_md, generated_md, gold_md, pred_md, score_md, nscore_val
 
     return SingleModelComponents(report_name=report_name)
 
@@ -696,16 +749,13 @@ def create_app(args: argparse.Namespace):
             text = '<' if new_visible else '>'
             return gr.update(visible=new_visible), new_visible, gr.update(value=text)
 
-    demo.launch(share=args.share, server_name=args.server_name, server_port=args.server_port, debug=args.debug)
-
-
-def add_argument(parser: argparse.ArgumentParser):
-    parser.add_argument('--share', action='store_true', help='Share the app.')
-    parser.add_argument('--server-name', type=str, default='0.0.0.0', help='The server name.')
-    parser.add_argument('--server-port', type=int, default=None, help='The server port.')
-    parser.add_argument('--debug', action='store_true', help='Debug the app.')
-    parser.add_argument('--lang', type=str, default='zh', help='The locale.', choices=['zh', 'en'])
-    parser.add_argument('--outputs', type=str, default='./outputs', help='The outputs dir.')
+    demo.launch(
+        share=args.share,
+        server_name=args.server_name,
+        server_port=args.server_port,
+        debug=args.debug,
+        allowed_paths=args.allowed_paths,
+    )
 
 
 if __name__ == '__main__':