opencompass-my-api/build/lib/opencompass/summarizers/multi_model.py

# flake8: noqa
# yapf: disable
import os.path as osp
from collections import defaultdict
from typing import List, Optional

import mmengine
import numpy as np
from mmengine import ConfigDict
from rich import print
from rich.table import Table

from opencompass.utils import (dataset_abbr_from_cfg, get_infer_output_path,
                               get_logger, model_abbr_from_cfg)
from opencompass.utils.prompt import get_prompt_hash

METRIC_WHITELIST = ['score', 'auc_score', 'accuracy', 'humaneval_pass@1', 'rouge1', 'avg_toxicity_score', 'bleurt_diff', 'matthews_correlation', 'truth']
METRIC_BLACKLIST = ['bp', 'sys_len', 'ref_len']


META_COL_COUNT = 4
EPS = 1e-6

def bold(text):
    return f'[bold]{text}[/bold]'


def green_bold(text):
    return f'[green][bold]{text}[/bold][/green]'


def format_float(v):
    return f'{v:.2f}'


def to_float(text: str):
    try:
        return float(text)
    except ValueError:
        return 0


def is_section_row(row: List[str]) -> bool:
    # ['ceval', '-', '-', '-', '-'],
    return row[-1] == '-' and row[0][0] == '-'


def average_rows(name, rows: List[List[str]]) -> List[str]:
    # name: col=0 的名字
    new_row = ['-'] * len(rows[0])
    new_row[0] = bold(name)

    all_accs = defaultdict(list)
    for row in rows:
        for i, acc in enumerate(row[META_COL_COUNT:]):
            all_accs[i].append(to_float(acc))

    for i, accs in enumerate(all_accs.values()):
        new_row[META_COL_COUNT + i] = format_float(np.mean(accs))
    return new_row


def create_section_row(row_i: int, row: List[str], table) -> List[str]:
    section_name = bold('[' + row[0].replace('-', '').strip() + ']')

    # TODO: 区分 acc,rouge1,score 等
    section_rows = []
    for next_row in table[row_i + 1 :]:
        if is_section_row(next_row):
            break
        section_rows.append(next_row)
    return average_rows(section_name, section_rows)


def create_win_row(rows: List[List[str]]) -> List[str]:
    win_count = defaultdict(int)
    for row in rows:
        all_scores = [to_float(_) for _ in row[META_COL_COUNT:]]
        best_indeice = [i for i, s in enumerate(all_scores) if s > np.max(all_scores) - EPS]
        for best_index in best_indeice:
            win_count[best_index] += 1
    new_row = ['-'] * len(rows[0])
    new_row[0] = bold('Win Count')
    for i, count in win_count.items():
        new_row[META_COL_COUNT + i] = str(count)
    return new_row


def highlight(row: List[str], meta_col_count: int = META_COL_COUNT) -> List[str]:
    new_row = [_ for _ in row]
    all_scores = [to_float(_) for _ in row[meta_col_count:]]
    best_indeice = [i + meta_col_count for i, s in enumerate(all_scores) if s > np.max(all_scores) - EPS]
    for best_index in best_indeice:
        new_row[best_index] = green_bold(row[best_index])
    return new_row


class MultiModelSummarizer:
    """MultiModel.

    Args:
        config (ConfigDict): The configuration object of the evaluation task.
            It's expected to be filled out at runtime.
        dataset_abbrs (list[str], optional): Dataset abbreviations to be
            listed in the summary.
        summary_groups (list): The dataset groups whose results need to be
            averaged out. For example, mmlu. Each item it a dict with
            'name' (str) and 'subsets' (list of dataset abbrs), and optionally
            'weights' if weighted average is needed.
        prompt_db: A deprecated field.
    """

    def __init__(self, config: ConfigDict, dataset_abbrs: Optional[List[str]] = None, summary_groups: List = [], prompt_db = None) -> None:
        self.tasks = []
        self.cfg = config
        self.logger = get_logger()
        self.summary_groups = summary_groups
        self.dataset_abbrs = dataset_abbrs
        if prompt_db:
            self.logger.warning('prompt_db is deprecated and no longer used. '
                                'Please remove it from your config.')
        self.models_summary_group_metrics = {}
        self.table = self.load()

    def load( self ):  # noqa
        model_cfgs = self.cfg['models']
        dataset_cfgs = self.cfg['datasets']
        work_dir = self.cfg['work_dir']

        # pick up results
        raw_results = {}
        parsed_results = {}
        dataset_metrics = {}

        model_abbrs = [model_abbr_from_cfg(model) for model in model_cfgs]
        for model in model_cfgs:
            model_abbr = model_abbr_from_cfg(model)
            parsed_results[model_abbr] = {}
            raw_results[model_abbr] = {}
            for dataset in dataset_cfgs:
                dataset_abbr = dataset_abbr_from_cfg(dataset)
                filepath = get_infer_output_path(model, dataset, osp.join(work_dir, 'results'))
                if not osp.exists(filepath):
                    continue
                result = mmengine.load(filepath)
                raw_results[model_abbr][dataset_abbr] = result
                if 'error' in result:
                    self.logger.debug(f'error in {model_abbr} {dataset_abbr} {result["error"]}')
                    continue
                else:
                    parsed_results[model_abbr][dataset_abbr] = []
                    dataset_metrics[dataset_abbr] = []
                    for metric, score in result.items():
                        if metric not in METRIC_BLACKLIST and isinstance(score, (int, float)):
                            parsed_results[model_abbr][dataset_abbr].append(score)
                            dataset_metrics[dataset_abbr].append(metric)
                        else:
                            continue
                    if len(parsed_results[model_abbr][dataset_abbr]) == 0:
                        self.logger.warning(f'unknown result format: {result}, continue')
                        del parsed_results[model_abbr][dataset_abbr]
                        del dataset_metrics[dataset_abbr]
                        continue
                    indice = sorted(
                        list(range(len(dataset_metrics[dataset_abbr]))),
                        key=lambda i: (
                            METRIC_WHITELIST.index(dataset_metrics[dataset_abbr][i])
                            if dataset_metrics[dataset_abbr][i] in METRIC_WHITELIST
                            else len(METRIC_WHITELIST)
                        )
                    )
                    parsed_results[model_abbr][dataset_abbr] = [parsed_results[model_abbr][dataset_abbr][i] for i in indice]
                    dataset_metrics[dataset_abbr] = [dataset_metrics[dataset_abbr][i] for i in indice]

        # parse eval mode
        dataset_eval_mode = {}
        for dataset in dataset_cfgs:
            inferencer = dataset.get('infer_cfg', {}).get('inferencer', {}).get('type', '')
            inferencer = inferencer if isinstance(inferencer, str) else inferencer.__name__
            dataset_abbr = dataset_abbr_from_cfg(dataset)
            if 'GenInferencer' in inferencer:
                dataset_eval_mode[dataset_abbr] = 'gen'
            elif 'PPLInferencer' in inferencer:
                dataset_eval_mode[dataset_abbr] = 'ppl'
            else:
                dataset_eval_mode[dataset_abbr] = 'unknown'
                self.logger.warning(f'unknown inferencer: {inferencer} - {dataset_abbr}')

        # calculate group metrics
        summary_groups = self.summary_groups
        summary_group_metrics = {}
        for sg in summary_groups:
            for model_abbr in model_abbrs:
                results = {}
                eval_modes = []
                for dataset_abbr in sg['subsets']:
                    if dataset_abbr in parsed_results[model_abbr]:
                        results[dataset_abbr] = parsed_results[model_abbr][dataset_abbr][0]
                        eval_modes.append(dataset_eval_mode.get(dataset_abbr, 'unknown'))
                summary_group_metrics[sg['name']] = results
                if len(results) == len(sg['subsets']):
                    if 'weights' in sg:
                        numerator = sum(results[k] * sg['weights'][k] for k in sg['weights'])
                        denominator = sum(sg['weights'].values())
                        metric = 'weighted_average'
                    else:
                        numerator = sum(results[k] for k in results)
                        denominator = len(results)
                        metric = 'naive_average'
                    results[metric] = numerator / denominator
                    eval_modes = list(set(eval_modes))
                    eval_mode = eval_modes[0] if len(eval_modes) == 1 else 'mixed'

                    # add to global results
                    raw_results[model_abbr][sg['name']] = results
                    parsed_results[model_abbr][sg['name']] = [numerator / denominator]
                    dataset_metrics[sg['name']] = [metric]
                    dataset_eval_mode[sg['name']] = eval_mode
                elif len(results) == 0:
                    continue
                else:
                    raw_results[model_abbr][sg['name']] = {'error': 'missing datasets: {}'.format(set(sg['subsets']) - set(results.keys()))}

        prompt_version = {dataset_abbr_from_cfg(d): get_prompt_hash(d)[:6] for d in dataset_cfgs}

        # format table
        summarizer_dataset_abbrs = []
        if self.dataset_abbrs is None:
            for dataset in dataset_cfgs:
                dataset_abbr = dataset_abbr_from_cfg(dataset)
                if dataset_abbr in dataset_metrics:
                    for metric in dataset_metrics[dataset_abbr]:
                        summarizer_dataset_abbrs.append((dataset_abbr, metric))
                else:
                    summarizer_dataset_abbrs.append((dataset_abbr, None))
            for dataset_abbr in dataset_metrics:
                for metric in dataset_metrics[dataset_abbr]:
                    if (dataset_abbr, metric) not in summarizer_dataset_abbrs:
                        summarizer_dataset_abbrs.append((dataset_abbr, metric))
        else:
            for item in self.dataset_abbrs:
                if isinstance(item, str):
                    summarizer_dataset_abbrs.append((item, None))
                elif isinstance(item, (list, tuple)):
                    summarizer_dataset_abbrs.append((item[0], item[1]))

        table = []
        header = ['dataset', 'version', 'metric', 'mode'] + model_abbrs
        table.append(header)
        for dataset_abbr, metric in summarizer_dataset_abbrs:
            if dataset_abbr not in dataset_metrics:
                table.append([dataset_abbr, '-', '-', '-'] + ['-'] * len(model_abbrs))
                continue
            if metric is None:
                index = 0
                metric = dataset_metrics[dataset_abbr][0]
            elif metric in dataset_metrics[dataset_abbr]:
                index = dataset_metrics[dataset_abbr].index(metric)
            else:
                table.append([dataset_abbr, '-', '-', '-'] + ['-'] * len(model_abbrs))
                continue

            row = [dataset_abbr, prompt_version.get(dataset_abbr, '-'), metric, dataset_eval_mode.get(dataset_abbr, '-')]
            for model_abbr in model_abbrs:
                if dataset_abbr in parsed_results[model_abbr]:
                    row.append('{:.02f}'.format(parsed_results[model_abbr][dataset_abbr][index]))
                else:
                    row.append('-')
            table.append(row)

        self.models_summary_group_metrics[table[0][-1]] = summary_group_metrics
        return table

    def merge(self, summarizer: 'MultiModelSummarizer'):
        assert len(self.table) == len(summarizer.table)
        for row_i, row in enumerate(summarizer.table):
            base_row = self.table[row_i]
            if base_row[:3] != row[:3]:
                self.logger.warning(f'cannot merge tables with different headers: {base_row} vs {row}')
            base_row.extend(row[META_COL_COUNT:])
        new_model_name = summarizer.table[0][-1]
        assert new_model_name not in self.models_summary_group_metrics
        self.models_summary_group_metrics[new_model_name] = summarizer.models_summary_group_metrics[new_model_name]

    def summarize(self):
        """
        Format in self.table
        [
            ['dataset', 'version', 'metric', 'mode', 'model_name'],
            ['--------- 考试 Exam ---------', '-', '-', '-', '-'],
            ['ARC-c', '1e0de5', 'accuracy', 'gen', '79.32'],
            ['ARC-e', '1e0de5', 'accuracy', 'gen', '85.36'],
            ['--------- 语言 Language ---------', '-', '-', '-', '-'],
            ['WiC', 'd06864', 'accuracy', 'gen', '55.64'],
            ['chid-dev', '211ee7', 'accuracy', 'gen', '52.97'],
            ['--------- 知识 Knowledge ---------', '-', '-', '-', '-'],
            ['BoolQ', '883d50', 'accuracy', 'gen', '86.06'],
            ['--------- 理解 Understanding ---------', '-', '-', '-', '-'],
            ['C3', '8c358f', 'accuracy', 'gen', '88.33'],
            ['race-middle', '9a54b6', 'accuracy', 'gen', '90.32'],
            ['--------- 推理 Reasoning ---------', '-', '-', '-', '-'],
            ['cmnli', '1abf97', 'accuracy', 'gen', '38.26'],
            ['ocnli', 'c4cb6c', 'accuracy', 'gen', '32.92'],
        ]
        """

        table = Table()
        for i, col_name in enumerate(self.table[0]):
            table.add_column(col_name, overflow='fold', max_width=20 if i >= META_COL_COUNT else None)

        section_rows = []
        all_rows = []
        for row_i, row in enumerate(self.table):
            if row_i == 0:
                continue
            if is_section_row(row):
                table.add_section()
                new_row = create_section_row(row_i, row, self.table)
                section_rows.append(new_row)
            else:
                new_row = row
                all_rows.append(new_row)

            table.add_row(*highlight(new_row))

        if section_rows:
            table.add_section()
            average_row = average_rows('Naive Average', section_rows)
            average_row = highlight(average_row)
            table.add_row(*average_row)

        table.add_section()
        table.add_row(*highlight(create_win_row(all_rows)))
        print(table)

    def show_group(self, group: str):
        table = Table(title=group)
        table.add_column('Dataset', overflow='fold')

        # summary_group_metrics 数据结构 dict[group_name][sub_group_name] = 73
        group_metrics = None
        for model_name, summary_group_metrics in self.models_summary_group_metrics.items():
            if group not in summary_group_metrics:
                self.logger.warning(f'group {group} not found in {model_name}')
                return
            table.add_column(model_name, overflow='fold')
            group_metrics = summary_group_metrics[group]

        for subset_name in group_metrics.keys():
            if subset_name == 'naive_average':
                continue

            row = [subset_name]
            for summary_group_metrics in self.models_summary_group_metrics.values():
                metric = summary_group_metrics[group][subset_name]
                row.append(format_float(metric))
            table.add_row(*highlight(row, meta_col_count=1))

        print(table)