process/infer_template.py

import json
import random
from pathlib import Path
from typing import Sequence, Callable

import fire
import h5py
import numpy as np
from tqdm import tqdm

from infer_eval_utils import (
    read_time_series_data,
    GENERATION_TASK_IDS, 
    CLASSIFICATION_TASK_IDS, 
    EVENT_DETECTION_TASK_IDS, 
    ANOMALY_DETECTION_TASK_IDS,
    MCQ_TASK_IDS, 
    IMPUTATION_TASK_IDS
)


def read_raw_data(path: str | None) -> Sequence:
    if path is None:
        return []

    return read_time_series_data(path)


def transform_raw_data_single_channel(raw_data: list | np.ndarray,
                                      dataset_id: str) -> str:

    if dataset_id in GENERATION_TASK_IDS:
        data_str_list = []
        for x in raw_data:
            if x != "X":
                data_str_list.append(f"{float(x):.3f}")
            else:
                data_str_list.append(x)
        data_text = " ".join(data_str_list)
    else:
        data_text = " ".join([f"{float(x):.3f}" for x in raw_data])

    return data_text


def transform_raw_data_to_text(raw_data: list | np.ndarray, dataset_id: str,
                               channel_detail: list[str]) -> str:

    if isinstance(raw_data, np.ndarray):
        if raw_data.ndim > 1 and raw_data.shape[1] > 1 and len(
                channel_detail) == 0:
            channel_detail = [f"channel {i}" for i in range(raw_data.shape[1])]

        if len(channel_detail) <= 1:
            data_text = transform_raw_data_single_channel(raw_data, dataset_id)
        else:
            data_text = ""
            for channel_idx, channel_name in enumerate(channel_detail):
                channel_data = raw_data[:, channel_idx]
                channel_data_text = transform_raw_data_single_channel(
                    channel_data, dataset_id)
                data_text += f"{channel_name}: {channel_data_text} "
    else:
        data_text = transform_raw_data_single_channel(raw_data, dataset_id)
    return data_text


def transform_gt_data_to_text(gt_data: list | np.ndarray,
                              dataset_id: str) -> str:
    gt_data = np.array(gt_data)
    if gt_data.ndim == 1:
        data_text = transform_raw_data_single_channel(gt_data, dataset_id)
    else:
        data_text = ""
        for channel_idx in range(gt_data.shape[1]):
            channel_data = gt_data[:, channel_idx]
            channel_data_text = transform_raw_data_single_channel(
                channel_data, dataset_id)
            data_text += f"{channel_data_text}\n"

    return data_text


def get_extra_instruction(dataset_id: str, ) -> str:
    extra_instruction = ""
    if dataset_id == "ASU01_ASG02":
        extra_instruction = "Answer yes or no in the first line. If the Gravitational Wave is detected, answer the index of the starting time point in the second line."
    elif dataset_id == "EAU01_EAG02":
        extra_instruction = "Answer yes or no in the first line. If an Earthquake event is detected, answer the starting time point index of the P-wave in the second line, " \
                            "answer the starting time point index of the S-wave in the third line."
    elif dataset_id == "MFU01_MFU02":
        extra_instruction = "Output the diameter in the first line, and the position in the second line."
    elif dataset_id == "PHU01":
        extra_instruction = "Give each answer in a line. For example, if the answer is ['NORM', 'MI'], you should output: NORM\nMI."
    elif dataset_id == "MAG01":
        extra_instruction = "Give answer of each channel in a line so the number of predicted time points in each line should match the given one. For example, if " \
            "it is required to predict the next 5 time points, and the predicted x0, x1, x2 are [[0.1, 0.2, 0.3, 0.4, 0.5], [0.4, 0.5, 0.6, 0.7, 0.8], [0.7, 0.8, 0.9, 0.1, 0.2]], " \
            "you should output: 0.1 0.2 0.3 0.4 0.5\n0.4 0.5 0.6 0.7 0.8\n0.7 0.8 0.9 0.1 0.2."
    elif dataset_id in ANOMALY_DETECTION_TASK_IDS:
        extra_instruction = "Answer yes if anomaly points are detected, and no if there are only normal points."
    elif dataset_id in GENERATION_TASK_IDS:
        extra_instruction = "Output the values separated by spaces."
    return extra_instruction


def extract_gt(data: dict, dataset_id: str) -> str | dict | Path:
    if dataset_id in CLASSIFICATION_TASK_IDS:
        gt = data["gt_result"]["gt_class"]
        if isinstance(gt, dict) and len(gt) == 1:
            gt = gt["default"]
        if isinstance(gt, list) and len(gt) == 1:
            gt = gt[0]
    elif dataset_id in GENERATION_TASK_IDS:
        gt = data["gt_ts"]["path"].strip("/")
    elif dataset_id in EVENT_DETECTION_TASK_IDS:
        gt = data["gt_result"]
    elif dataset_id in ANOMALY_DETECTION_TASK_IDS:
        gt = data["gt_result"]["contain"]
    elif dataset_id in MCQ_TASK_IDS:
        gt = data["gt_result"]["answer"]
    else:
        raise ValueError(f"Unsupported dataset id: {dataset_id}")
    return gt


def initialize_model() -> Callable:
    """
    Initialize the model here. The model can be called by:
    
    ```python
    response = model(prompt) 
    # or
    response = model(prompt, max_tokens=max_tokens)  # to limit the response length
    ```
    """
    pass


def infer_dataset(model: Callable, dataset_data: list, scits_dir: Path,
                  dataset_id: str, output_path: Path):
    print(f"Inferring {dataset_id}")

    if dataset_id in GENERATION_TASK_IDS:
        ext = "h5"
    else:
        ext = "jsonl"

    output_path = Path(output_path) / f"{dataset_id}.{ext}"
    output_path.parent.mkdir(parents=True, exist_ok=True)
    completed_ids = []

    if str(output_path).endswith(".jsonl"):
        has_metadata = False

    if output_path.exists():
        if str(output_path).endswith(".jsonl"):
            with open(output_path, 'r') as f:
                for line in f.readlines():
                    data = json.loads(line)
                    if "id" in data:
                        completed_ids.append(data["id"])
                    else:
                        has_metadata = True
        elif str(output_path).endswith(".h5"):
            with h5py.File(output_path, 'r') as f:
                completed_ids = list(f.keys())

    completed_ids = set(completed_ids)
    random.shuffle(dataset_data)
    dataset_data = dataset_data[:10]

    try:
        seq_length = dataset_data[0]["input_ts"]["length"]
    except:
        seq_length = None

    for sample in tqdm(dataset_data):
        id = sample["id"].replace(
            "/", "%2F")  # to avoid errors related to "/" in hdf5

        if id in completed_ids:
            continue

        # Load raw data
        if sample["input_ts"] is None:
            raw_data_path = None
            channel_detail = None
        else:
            raw_data_path = scits_dir / sample["input_ts"]["path"].strip("/")
            channel_detail = sample["input_ts"]["channel_detail"]

        raw_data = read_raw_data(raw_data_path)
        raw_data_text = transform_raw_data_to_text(raw_data, dataset_id,
                                                   channel_detail)

        gt = extract_gt(sample, dataset_id)
        extra_instruction = get_extra_instruction(dataset_id)

        if dataset_id in GENERATION_TASK_IDS:
            # give max_tokens to save cost for generation tasks
            gt_data = read_time_series_data(scits_dir / gt)
            gt_data_text = transform_gt_data_to_text(
                gt_data, dataset_id)
            max_tokens = len(gt_data_text)
        else:
            max_tokens = None

        prompt_text = f'{sample["input_text"]} {extra_instruction} Give me the answer directly, ' \
                    f'without any other extra content (including punctuation). ' \
                    f'{raw_data_text}'
        output_text = model(text=prompt_text, max_tokens=max_tokens)
        # print(f"output_text: {output_text}")

        if dataset_id not in GENERATION_TASK_IDS:
            with open(output_path, 'a') as writer:
                if not has_metadata:
                    metadata = {}
                    if dataset_id in EVENT_DETECTION_TASK_IDS:
                        metadata["seq_length"] = seq_length
                    writer.write(json.dumps(metadata) + "\n")
                    has_metadata = True

                pred_results = output_text
                if "class_list" in sample["gt_result"] and isinstance(
                        sample["gt_result"]["class_list"], dict) and len(
                            sample["gt_result"]["class_list"]) > 1:
                    if len(output_text.split("\n")) != len(
                            sample["gt_result"]["class_list"]):
                        pred_results = "NA"
                    else:
                        pred_results = {}
                        for class_name, pred_result in zip(
                                sample["gt_result"]["class_list"],
                                output_text.split("\n")):
                            pred_results[class_name] = pred_result
                writer.write(
                    json.dumps({
                        "id": id,
                        "output": pred_results,
                        "ground_truth": gt
                    }) + "\n")
        else:
            if "\n" not in output_text:
                pred_result = np.fromstring(output_text.strip(),
                                            dtype=np.float32,
                                            sep=' ')
            else:
                try:
                    pred_result = np.vstack([
                        np.fromstring(x.strip(), dtype=np.float32, sep=' ')
                        for x in output_text.split("\n")
                    ]).transpose()
                except ValueError:
                    pred_result = np.array([])

            with h5py.File(output_path, 'a') as writer:
                writer[f"{id}/pred_result"] = pred_result
                writer[f"{id}/gt_path"] = gt.__str__().encode("utf-8")
                if dataset_id in IMPUTATION_TASK_IDS:
                    writer[f"{id}/input_ts_path"] = sample["input_ts"][
                        "path"].strip("/").encode("utf-8")
                if "base_path" not in writer:
                    writer["base_path"] = scits_dir.__str__().encode("utf-8")



def infer(
    scits_dir: str,
    output_dir: str,
):

    # Initialize caller
    model: Callable = initialize_model()

    scits_dir = Path(scits_dir)
    output_dir = Path(output_dir)
    dataset_data = []
    prev_dataset_id = None
    with open(scits_dir / "meta_data.jsonl", 'r') as f:
        for line in f.readlines():
            sample = json.loads(line)
            dataset_id = "_".join(sample["task_id"])

            if dataset_id != prev_dataset_id:
                if prev_dataset_id is not None:
                    infer_dataset(model, dataset_data, scits_dir, prev_dataset_id,
                                  output_dir)
                dataset_data = []
                prev_dataset_id = dataset_id
            dataset_data.append(sample)

    infer_dataset(model, dataset_data, scits_dir, prev_dataset_id, output_dir)


if __name__ == '__main__':
    fire.Fire(infer)