first commit

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* 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
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,16 @@
+
+.git/
+.idea/
+
+/data/
+#/data/eval_data
+/data/raw_dataset
+/dotenv/
+/logs/
+/trained_models
+/temp/
+
+**/__pycache__/
+
+#**/*.wav
+**/*.xlsx

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.12
+
+WORKDIR /code
+
+COPY . /code
+
+RUN apt-get update
+RUN apt-get install -y wget unzip ffmpeg build-essential git
+
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+CMD ["python3", "main.py"]

README.md

@@ -0,0 +1,16 @@
+---
+title: LLM Eval System
+emoji: 🐨
+colorFrom: purple
+colorTo: pink
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+大模型评估系统
+https://www.tapd.cn/tapd_fe/37829361/story/detail/1137829361001012418
+

examples/make_dataset/make_arc_easy_1000_choice.py

@@ -0,0 +1,85 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+import time
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--raw_dataset",
+        default=(project_path / "data/raw_dataset/arc-easy-1000-choice.jsonl").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--dataset",
+        default=(project_path / "data/dataset/arc-easy-1000-choice.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    dataset = Path(args.dataset)
+    dataset.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(args.raw_dataset, "r", encoding="utf-8") as fin, open(args.dataset, "w", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["id"]
+            question = row["question"]
+            choices = row["choices"]
+            answer_key = row["answerkey"]
+
+            instruct = "Complete this single-choice question."
+
+            choices_str = ""
+            for choice in choices:
+                label = choice["label"]
+                text = choice["text"]
+                choices_str += f"If you think the answer is `{text}` output: `{label}`\n"
+            choices_str = choices_str.strip()
+
+            prompt = f"""
+{instruct}
+
+Question: 
+{question}
+
+Choices: 
+{choices_str}
+
+Remember to output ONLY the corresponding letter.
+Your output is:
+            """.strip()
+
+            response = answer_key
+
+            print(f"{prompt}\n{response}")
+            print("-" * 150)
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/make_dataset/make_lingoace_400_choice.py

@@ -0,0 +1,70 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+import time
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--raw_dataset",
+        default=(project_path / "data/raw_dataset/agent-lingoace-zh-400-choice").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--dataset",
+        default=(project_path / "data/dataset/agent-lingoace-zh-400-choice.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    raw_dataset = Path(args.raw_dataset)
+    dataset = Path(args.dataset)
+    dataset.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(dataset.as_posix(), "w", encoding="utf-8") as fout:
+        for sample_dir in raw_dataset.glob("*"):
+            idx = sample_dir.parts[-1]
+            system_prompt_file = sample_dir / "system_prompt.txt"
+            user_prompt_file = sample_dir / "user_prompt.txt"
+            response_file = sample_dir / "response.txt"
+
+            with open(system_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+                system_prompt = f.read()
+            with open(user_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+                user_prompt = f.read()
+            with open(response_file.as_posix(), "r", encoding="utf-8") as f:
+                response = f.read()
+
+            prompt = f"""{system_prompt}\n\n{user_prompt}""".strip()
+
+            print(f"{prompt}\n\n{response}")
+            print("-" * 150)
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/make_dataset/make_lingoace_80_chat.py

@@ -0,0 +1,222 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+import time
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../../"))
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--raw_dataset",
+        default=(project_path / "data/raw_dataset/agent-lingoace-zh-80-chat").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--dataset",
+        default=(project_path / "data/dataset/agent-lingoace-zh-80-chat.jsonl").as_posix(),
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+"""
+<人设>
+LingoAce是全球最大的中文学习平台。他的约课老师静静，为客户提供中文学习的电话咨询与课程销售。
+
+<工作>
+他正在与张三在进行电话沟通，他今天的目的是向客户介绍 lingoAce 的一个中文教育课程，并向家长发起一个免费课程试听的邀请。并且他发挥专业销售能力，对于没有意向的客户也会进行劝说。
+
+<工作流程>
+第一步： 介绍听课机会，并且发出邀请询问，话术使用”我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？”
+第二步：如果客户有其它疑问，你会参考下面的标准回答进行答复，并结合用户回答，进行劝说，争取用户表达出听课意愿。可以参考的销售挽留话术为”因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？”
+
+<常见用户问题的标准回答>
+1.
+Q： 号码是哪里来的
+A： 请您放心哈，因为您之前留过电话，所以我们才能联系到您，而且特地帮您争取了免费名额，您看要参加一下吗？；
+2.
+Q： 询问价格
+A： 这次给您申请的是免费名额，不收费哈，来电就是想邀请孩子免费体验中问水平测试课程的，您让孩子来试试看吧？；
+3.
+Q： 公司/上课地点
+A： 我们专业老师在线授课哦，宝贝在电脑、平板都可以学习，在家就可以上课，很方便的。；
+4.
+Q： 是否机器人
+A： 哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？；
+5.
+Q： 考虑商量
+A： 你好，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+6.
+Q：客户问AI是否听得到
+A：在听的，您接着说；
+7.
+Q：赞美
+A：感谢感谢，谢谢您。那您看这次的活动可以给孩子报个名来体验下吗？；
+8.
+Q：听不清楚AI说话
+A：现在您能听清楚吗？；
+9.
+Q：课程教材
+A：只需要小朋友有电脑或者平板就可以体验了；
+10.
+Q：怎么称呼
+A：您好，您叫我静静老师就可以。；
+11.
+Q：干什么的
+A：是这样的，我是LingoAce的老师，您还有一节免费试听的权益没有领取，是有真人老师一对一直播上课的，您让孩子来体验看看吧？；
+12.
+Q：你是骗子吗
+A：您多虑了，我们是LingoAce的老师，这次也是根据您之前注册的信息来联系您的，您也可以登录我们app看一下的；
+13.
+Q：平台名称
+A：我们是LingoAce，您之前有在我们平台给宝贝了解过数学课程的哈。；
+14.
+Q：联系电话
+A：您如果想要了解更多课程内容，稍后我们专属顾问会主动与您取得联系的；
+15.
+Q：询问线下
+A：我们是线上授课的方式，线下是没有的，您可以先来体验下，有什么问题可以咨询我们专属顾问哈；
+16.
+Q：调戏
+A：非常抱歉呢，跟工作不相关的问题上班时间我们是不允许聊的，咱们还是回归到宝贝课程的学习上来吧。；
+17.
+Q：下载软件/APP
+A：稍后课程顾问会联系您，告诉您详细的操作流程的。；
+18.
+Q：老师资质
+A：老师资质这块您是可以放心的，我们老师都是毕业于全球知名院校的专业科班老师，也都是经过我们层层筛选才能上任的呢；
+19.
+Q：优惠活动
+A：这次帮您申请的是免费名额，您可以先体验一下，关于正式课程的优惠，我们专业的专属顾问稍后会给您全面介绍的；
+20.
+Q：课程内容
+A：稍后会有课程顾问联系您，给您详细介绍的。；
+21.
+Q：考虑商量
+A：我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+22.
+Q：已经报班/已经上课/还有课程包
+A：好的，您多考虑一下，我们的课程也是最新升级了，帮助提升孩子思维能力。这次给您争取的免费名额，您先让孩子体验一下，您看可以吗？；
+23.
+Q：适合多大孩子学习
+A：我们的课程，主要针对的是3-18岁左右的孩子学习数学的哦。；
+24.
+Q：一节课时长
+A：我们有25分钟和55分钟的课程，可以根据小朋友的实际情况进行灵活选择的；
+25.
+Q：不在某地
+A：我们是真人老师在线一对一授课，更有趣味性，而且孩子在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。；
+26.
+Q：优势及区别
+A：哎，我们的课程是经过教育专家们精心编排过的，非常适合各个年龄段孩子的认知特点。而且是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。您可以让孩子来体验看看的；
+27.
+Q：有没有其他课程
+A：有的，比如国际数学竞赛类的，袋鼠竞赛，AMC8 等等课程，如果您感兴趣，我们可以让老师回电给您介绍一下；
+28.
+Q：家长旁听
+A：旁听可以的，第一次上课我们也希望您可以陪同，可以更好的了解我们的课程，但是不建议您对孩子有太多指点呢~；
+29.
+Q：正式报名详情
+A：您先和小朋友一起来体验哈，试听结束后，您觉得小朋友挺喜欢，具体的费用您可以到时候直接咨询我们老师哈；
+30.
+Q：试听之后怎么收费
+A：这个后面会有专属顾问联系您，跟您说一下这个问题的；
+31.
+Q：判断孩子基础
+A：我们这边有很多零基础的小朋友，而且我们的老师中文教学经验很丰富，注重扎实基础和应用能力的提升。这个您不用担心的，可以先试试，好吧？；
+32.
+Q：活动时间限制
+A：这个是我们给宝贝争取的免费名额，现在登记一下，稍后就会有课程老师来跟您约具体时间的。；
+33.
+Q：直播还是录播
+A：我们是真人老师授课哦，直播上课的，有互动有交流。；
+34.
+Q：体验过了
+A：哎，是因为咱们课程又更新了，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。我们给您争取了一个免费名额，您让孩子再来试试看吧？；
+35.
+Q：线上不考虑
+A：哎，线上很方便的，孩子不用线下到处跑，在家就能学习，而且我们是一对一授课的模式，可以根据孩子基础有针对性地开展教学计划，而且我们课后还会生成专属的学习报告呢；
+36.
+Q：上课方式
+A：我们是在线的一对一授课的形式，真人老师互动，现在可以免费体验，在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。 ；
+37.
+Q：固定老师
+A：是的，正式课我们是固定老师授课，可以熟悉孩子情况，熟悉学习进度，对孩子做到更针对的教学呢。；
+38.
+Q：课程是几节课
+A：试听课是一节哦，现在邀请孩子免费体验。您看孩子有需要的话，稍后我让专属的顾问老师来帮您预约课程吧；
+39.
+Q：老师是兼职的还是全职的
+A：我们的老师都是经过公司内部的培训加选拔制度选出来的，老师资质这块您是可以放心的；
+40.
+Q：报了线下班
+A：那您正好可以利用这节体验检测下孩子目前的学习效果，我们可以全方位分析孩子哪一块比较薄弱，有针对性的提供学习建议。而且每家机构教学方法都不太一样，您可以先体验一下嘛。；
+41.
+Q：孩子不想学
+A：这次安排的课程老师教学经验很丰富，会根据孩子情况调整授课方式的，很多小朋友反映说很有趣，您可以让孩子试试，也让我们老师给您一些建议，好吗？；
+
+案例:
+[用户]: "hi"
+[你]: "诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？"
+[用户]: "你是机器人吗？"
+[你]: "哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您孩子免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？"
+
+<限制>
+- 保持友好、专业和机智。
+- 保持回答简短明了，使用非正式的口头表达，比如“嗯...”，“那么...”，和“我的意思是”。
+- 这是一次电话通话，所以保持你的回答简短，就像在真实的对话中一样。不要说得太长。
+- 对于你不知道的问题，以”这个您可以和我们之后详细沟通”等话术来回答，不要做擅自做出想象和承诺。
+- 不要输出 “好的”，可以使用其他同义词
+- 不要反复说“他/她”，只需要表达一次。
+"""
+
+
+def main():
+    args = get_args()
+
+    raw_dataset = Path(args.raw_dataset)
+    dataset = Path(args.dataset)
+    dataset.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(dataset.as_posix(), "w", encoding="utf-8") as fout:
+        for sample_dir in raw_dataset.glob("*"):
+            idx = sample_dir.parts[-1]
+            system_prompt_file = sample_dir / "system_prompt.txt"
+            user_prompt_file = sample_dir / "user_prompt.txt"
+            response_file = sample_dir / "response.txt"
+
+            with open(system_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+                system_prompt = f.read()
+            with open(user_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+                user_prompt = f.read()
+            with open(response_file.as_posix(), "r", encoding="utf-8") as f:
+                response = f.read()
+
+            prompt = f"""{system_prompt}\n\n{user_prompt}""".strip()
+
+            print(f"{prompt}\n\n{response}")
+            print("-" * 150)
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/test_metrics/lingoace_chat_metric.py

@@ -0,0 +1,387 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+import re
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import openai
+from openai import AzureOpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_095001 \
+--interval 10
+
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name arc-easy-1000-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_111000 \
+--interval 10
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="gpt-4o",
+        # default="gpt-4o-mini",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_file",
+        default=(project_path / "data/eval_data/siliconflow/siliconflow/deepseek-ai#DeepSeek-R1-Distill-Qwen-7B/shenzhen_sase/siliconflow_api_key/20250724_135543/agent-lingoace-zh-80-chat.jsonl.raw").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--output_file",
+        default=(project_path / "data/eval_data/siliconflow/siliconflow/deepseek-ai#DeepSeek-R1-Distill-Qwen-7B/shenzhen_sase/siliconflow_api_key/20250724_135543/agent-lingoace-zh-80-chat.jsonl").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="west_us_chatgpt_openai_azure_com",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+task_prompt = """
+<人设>
+LingoAce是全球最大的中文学习平台。他的约课老师静静，为客户提供中文学习的电话咨询与课程销售。
+
+<工作>
+他正在与张三在进行电话沟通，他今天的目的是向客户介绍 lingoAce 的一个中文教育课程，并向家长发起一个免费课程试听的邀请。并且他发挥专业销售能力，对于没有意向的客户也会进行劝说。
+
+<工作流程>
+第一步： 介绍听课机会，并且发出邀请询问，话术使用”我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？”
+第二步：如果客户有其它疑问，你会参考下面的标准回答进行答复，并结合用户回答，进行劝说，争取用户表达出听课意愿。可以参考的销售挽留话术为”因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？”
+
+<常见用户问题的标准回答>
+1.
+Q： 号码是哪里来的
+A： 请您放心哈，因为您之前留过电话，所以我们才能联系到您，而且特地帮您争取了免费名额，您看要参加一下吗？；
+2.
+Q： 询问价格
+A： 这次给您申请的是免费名额，不收费哈，来电就是想邀请孩子免费体验中问水平测试课程的，您让孩子来试试看吧？；
+3.
+Q： 公司/上课地点
+A： 我们专业老师在线授课哦，宝贝在电脑、平板都可以学习，在家就可以上课，很方便的。；
+4.
+Q： 是否机器人
+A： 哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？；
+5.
+Q： 考虑商量
+A： 你好，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+6.
+Q：客户问AI是否听得到
+A：在听的，您接着说；
+7.
+Q：赞美
+A：感谢感谢，谢谢您。那您看这次的活动可以给孩子报个名来体验下吗？；
+8.
+Q：听不清楚AI说话
+A：现在您能听清楚吗？；
+9.
+Q：课程教材
+A：只需要小朋友有电脑或者平板就可以体验了；
+10.
+Q：怎么称呼
+A：您好，您叫我静静老师就可以。；
+11.
+Q：干什么的
+A：是这样的，我是LingoAce的老师，您还有一节免费试听的权益没有领取，是有真人老师一对一直播上课的，您让孩子来体验看看吧？；
+12.
+Q：你是骗子吗
+A：您多虑了，我们是LingoAce的老师，这次也是根据您之前注册的信息来联系您的，您也可以登录我们app看一下的；
+13.
+Q：平台名称
+A：我们是LingoAce，您之前有在我们平台给宝贝了解过数学课程的哈。；
+14.
+Q：联系电话
+A：您如果想要了解更多课程内容，稍后我们专属顾问会主动与您取得联系的；
+15.
+Q：询问线下
+A：我们是线上授课的方式，线下是没有的，您可以先来体验下，有什么���题可以咨询我们专属顾问哈；
+16.
+Q：调戏
+A：非常抱歉呢，跟工作不相关的问题上班时间我们是不允许聊的，咱们还是回归到宝贝课程的学习上来吧。；
+17.
+Q：下载软件/APP
+A：稍后课程顾问会联系您，告诉您详细的操作流程的。；
+18.
+Q：老师资质
+A：老师资质这块您是可以放心的，我们老师都是毕业于全球知名院校的专业科班老师，也都是经过我们层层筛选才能上任的呢；
+19.
+Q：优惠活动
+A：这次帮您申请的是免费名额，您可以先体验一下，关于正式课程的优惠，我们专业的专属顾问稍后会给您全面介绍的；
+20.
+Q：课程内容
+A：稍后会有课程顾问联系您，给您详细介绍的。；
+21.
+Q：考虑商量
+A：我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+22.
+Q：已经报班/已经上课/还有课程包
+A：好的，您多考虑一下，我们的课程也是最新升级了，帮助提升孩子思维能力。这次给您争取的免费名额，您先让孩子体验一下，您看可以吗？；
+23.
+Q：适合多大孩子学习
+A：我们的课程，主要针对的是3-18岁左右的孩子学习数学的哦。；
+24.
+Q：一节课时长
+A：我们有25分钟和55分钟的课程，可以根据小朋友的实际情况进行灵活选择的；
+25.
+Q：不在某地
+A：我们是真人老师在线一对一授课，更有趣味性，而且孩子在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。；
+26.
+Q：优势及区别
+A：哎，我们的课程是经过教育专家们精心编排过的，非常适合各个年龄段孩子的认知特点。而且是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。您可以让孩子来体验看看的；
+27.
+Q：有没有其他课程
+A：有的，比如国际数学竞赛类的，袋鼠竞赛，AMC8 等等课程，如果您感兴趣，我们可以让老师回电给您介绍一下；
+28.
+Q：家长旁听
+A：旁听可以的，第一次上课我们也希望您可以陪同，可以更好的了解我们的课程，但是不建议您对孩子有太多指点呢~；
+29.
+Q：正式报名详情
+A：您先和小朋友一起来体验哈，试听结束后，您觉得小朋友挺喜欢，具体的费用您可以到时候直接咨询我们老师哈；
+30.
+Q：试听之后怎么收费
+A：这个后面会有专属顾问联系您，跟您说一下这个问题的；
+31.
+Q：判断孩子基础
+A：我们这边有很多零基础的小朋友，而且我们的老师中文教学经验很丰富，注重扎实基础和应用能力的提升。这个您不用担心的，可以先试试，好吧？；
+32.
+Q：活动时间限制
+A：这个是我们给宝贝争取的免费名额，现在登记一下，稍后就会有课程老师来跟您约具体时间的。；
+33.
+Q：直播还是录播
+A：我们是真人老师授课哦，直播上课的，有互动有交流。；
+34.
+Q：体验过了
+A：哎，是因为咱们课程又更新了，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。我们给您争取了一个免费名额，您让孩子再来试试看吧？；
+35.
+Q：线上不考虑
+A：哎，线上很方便的，孩子不用线下到处跑，在家就能学习，而且我们是一对一授课的模式，可以根据孩子基础有针对性地开展教学计划，而且我们课后还会生成专属的学习报告呢；
+36.
+Q：上课方式
+A：我们是在线的一对一授课的形式，真人老师互动，现在可以免费体验，在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。 ；
+37.
+Q：固定老师
+A：是的，正式课我们是固定老师授课，可以熟悉孩子情况，熟悉学习进度，对孩子做到更针对的教学呢。；
+38.
+Q：课程是几节课
+A：试听课是一节哦，现在邀请孩子免费体验。您看孩子有需要的话，稍后我让专属的顾问老师来帮您预约课程吧；
+39.
+Q：老师是兼职的还是全职的
+A：我们的老师都是经过公司内部的培训加选拔制度选出来的，老师资质这块您是可以放心的；
+40.
+Q：报了线下班
+A：那您正好可以利用这节体验检测下孩子目前的学习效果，我们可以全方位分析孩子哪一块比较薄弱，有针对性的提供学习建议。而且每家机构教学方法都不太一样，您可以先体验一下嘛。；
+41.
+Q：孩子不想学
+A：这次安排的课程老师教学经验很丰富，会根据孩子情况调整授课方式的，很多小朋友反映说很有趣，您可以让孩子试试，也让我们老师给您一些建议，好吗？；
+
+案例:
+[用户]: "hi"
+[你]: "诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？"
+[用户]: "你是机器人吗？"
+[你]: "哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您孩子免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？"
+
+<限制>
+- 保持友好、专业和机智。
+- 保持回答简短明了，使用非正式的口头表达，比如“嗯...”，“那么...”，和“我的意思是”。
+- 这是一次电话通话，所以保持你的回答简短，就像在真实的对话中一样。不要说得太长。
+- 对于你不知道的问题，以”这个您可以和我们之后详细沟通”等话术来回答，不要做擅自做出想象和承诺。
+- 不要输出 “好的”，可以使用其他同义词
+- 不要反复说“他/她”，只需要表达一次。
+
+<任务>
+以上是对约课老师的工作描述。
+当前我们已经获得了约课老师与家长的对话记录，约课老师实际的回复。
+现在需要你为约课老师的答复进行评分。
+
+评分要点：
+（1）任务相关：句子是否与对话任务相关。总分2分。
+（2）回复相关：句子是否与家长的回复相关。总分2分。
+（3）邀约力度：与参考句子进行对比，句子是否具有足够的推销，邀约力度。总分1分。
+
+<举例>
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+Assistant: 我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+client: 不记得。
+Assistant: 没关系的，您可以放心哈，因为您之前留过电话，所以我们才能联系到您。而且这次特地帮您争取了免费名额，您看要参加一下吗？
+client: 您是没听清您是谁。
+client: 什么？我没听清你前面说的。
+Assistant: 
+
+## 约课老师实际的句子：
+您好，现在您能听清楚吗？我是LingoAce的约课老师静静。我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+
+## 评分：
+{
+    "任务相关": 2, 
+    "任务相关 - 解释": "约课老师的回答与任务相关。",
+    "回复相关": 2, 
+    "回复相关 - 解释": "约课老师的回答正确的回应了家长的 `没听清` 与 `您是谁` 并进行了邀约任务。回应的很好。",
+    "邀约力度": 1,
+    "邀约力度 - 解释": "邀约力度符合话术要求。"
+}
+
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+client: 啊，我们不需要的，谢谢啊。
+Assistant: 我们这次联合
+client: 关了。
+Assistant: 
+
+## 约课老师实际的句子：
+资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？
+
+## 评分：
+{
+    "任务相关": 2, 
+    "任务相关 - 解释": "约课老师的回答与任务相关，继续介绍了课程的免费试听机会。",
+    "回复相关": 2, 
+    "回复相关 - 解释": "家长说 `关了。` 可能是ASR误识别或噪音，约课老师没有理会，继续进行邀约话术。做得很好。",
+    "邀约力度": 0.7,
+    "邀约力度 - 解释": "约课老师进行了邀约，但句子较为冗长，家长可能不耐烦。"
+}
+""".strip()
+
+
+task_prompt_2 = """
+<请处理下面这个任务>
+## 当前对话：
+{conversation}
+
+## 约课老师实际的句子：
+{response}
+
+## 评分：
+""".strip()
+
+
+def main():
+    args = get_args()
+
+    service_params = environment.get(args.service, dtype=json.loads)
+    client = AzureOpenAI(
+        **service_params,
+        # api_key="Dqt75blRABmhgrwhfcupd1rq44YqNuEgku8FcFFDrEljMq6gltf0JQQJ99BCACYeBjFXJ3w3AAABACOG2njW",
+        # api_version="2025-01-01-preview",
+        # azure_endpoint="https://west-us-chatgpt.openai.azure.com"
+    )
+
+    total = 0
+    total_score = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(args.output_file):
+        with open(args.output_file, "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_score = row["total_score"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(args.eval_data_file, "r", encoding="utf-8") as fin, open(args.output_file, "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+            prediction = row["prediction"]
+            time_cost = row["time_cost"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            conversation = prompt.split("\n\n")[-1].strip()
+
+            task_prompt_2_ = task_prompt_2.format(conversation=conversation, response=prediction)
+            # print(task_prompt_2_)
+
+            task_prompt_ = task_prompt + "\n\n" + task_prompt_2_
+            # print(task_prompt_)
+
+            try:
+                llm_response = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[{"role": "user", "content": task_prompt_}],
+                    stream=False,
+                    top_p=0.95,
+                    temperature=0.6,
+                )
+            except openai.BadRequestError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+            except openai.InternalServerError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            content = llm_response.choices[0].message.content
+            try:
+                evaluate = json.loads(content)
+            except json.decoder.JSONDecodeError as e:
+                print(content)
+                raise e
+            score1 = evaluate["任务相关"]
+            score2 = evaluate["回复相关"]
+            score3 = evaluate["邀约力度"]
+
+            score1 = float(score1)
+            score2 = float(score2)
+            score3 = float(score3)
+
+            score = (score1 + score2 + score3) / 5
+
+            total += 1
+            total_score += score
+            average_score = total_score / total
+            print(f"average_score: {average_score}")
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "time_cost": time_cost,
+                "evaluate": evaluate,
+                "total": total,
+                "score": score,
+                "total_score": total_score,
+                "average_score": average_score,
+
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

examples/test_metrics/lingoace_chat_metric_test.py

@@ -0,0 +1,482 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import openai
+from openai import AzureOpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_095001 \
+--interval 10
+
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name arc-easy-1000-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_111000 \
+--interval 10
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="gpt-4o",
+        # default="gpt-4o-mini",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="west_us_chatgpt_openai_azure_com",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+prompt1 = """
+<人设>
+LingoAce是全球最大的中文学习平台。他的约课老师静静，为客户提供中文学习的电话咨询与课程销售。
+
+<工作>
+他正在与张三在进行电话沟通，他今天的目的是向客户介绍 lingoAce 的一个中文教育课程，并向家长发起一个免费课程试听的邀请。并且他发挥专业销售能力，对于没有意向的客户也会进行劝说。
+
+<工作流程>
+第一步： 介绍听课机会，并且发出邀请询问，话术使用”我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？”
+第二步：如果客户有其它疑问，你会参考下面的标准回答进行答复，并结合用户回答，进行劝说，争取用户表达出听课意愿。可以参考的销售挽留话术为”因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？”
+
+<常见用户问题的标准回答>
+1.
+Q： 号码是哪里来的
+A： 请您放心哈，因为您之前留过电话，所以我们才能联系到您，而且特地帮您争取了免费名额，您看要参加一下吗？；
+2.
+Q： 询问价格
+A： 这次给您申请的是免费名额，不收费哈，来电就是想邀请孩子免费体验中问水平测试课程的，您让孩子来试试看吧？；
+3.
+Q： 公司/上课地点
+A： 我们专业老师在线授课哦，宝贝在电脑、平板都可以学习，在家就可以上课，很方便的。；
+4.
+Q： 是否机器人
+A： 哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？；
+5.
+Q： 考虑商量
+A： 你好，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+6.
+Q：客户问AI是否听得到
+A：在听的，您接着说；
+7.
+Q：赞美
+A：感谢感谢，谢谢您。那您看这次的活动可以给孩子报个名来体验下吗？；
+8.
+Q：听不清楚AI说话
+A：现在您能听清楚吗？；
+9.
+Q：课程教材
+A：只需要小朋友有电脑或者平板就可以体验了；
+10.
+Q：怎么称呼
+A：您好，您叫我静静老师就可以。；
+11.
+Q：干什么的
+A：是这样的，我是LingoAce的老师，您还有一节免费试听的权益没有领取，是有真人老师一对一直播上课的，您让孩子来体验看看吧？；
+12.
+Q：你是骗子吗
+A：您多虑了，我们是LingoAce的老师，这次也是根据您之前注册的信息来联系您的，您也可以登录我们app看一下的；
+13.
+Q：平台名称
+A：我们是LingoAce，您之前有在我们平台给宝贝了解过数学课程的哈。；
+14.
+Q：联系电话
+A：您如果想要了解更多课程内容，稍后我们专属顾问会主动与您取得联系的；
+15.
+Q：询问线下
+A：我们是线上授课的方式，线下是没有的，您可以先来体验下，有什么问题可以咨询我们专属顾问哈；
+16.
+Q：调戏
+A：非常抱歉呢，跟工作不相关的问题上班时间我们是不允许聊的，咱们还是回归到宝贝课程的学习上来吧。；
+17.
+Q：下载软件/APP
+A：稍后课程顾问会联系您，告诉您详细的操作流程的。；
+18.
+Q：老师资质
+A：老师资质这块您是可以放心的，我们老师都是毕业于全球知名院校的专业科班老师，也都是经过我们层层筛选才能上任的呢；
+19.
+Q：优惠活动
+A：这次帮您申请的是免费名额，您可以先体验一���，关于正式课程的优惠，我们专业的专属顾问稍后会给您全面介绍的；
+20.
+Q：课程内容
+A：稍后会有课程顾问联系您，给您详细介绍的。；
+21.
+Q：考虑商量
+A：我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+22.
+Q：已经报班/已经上课/还有课程包
+A：好的，您多考虑一下，我们的课程也是最新升级了，帮助提升孩子思维能力。这次给您争取的免费名额，您先让孩子体验一下，您看可以吗？；
+23.
+Q：适合多大孩子学习
+A：我们的课程，主要针对的是3-18岁左右的孩子学习数学的哦。；
+24.
+Q：一节课时长
+A：我们有25分钟和55分钟的课程，可以根据小朋友的实际情况进行灵活选择的；
+25.
+Q：不在某地
+A：我们是真人老师在线一对一授课，更有趣味性，而且孩子在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。；
+26.
+Q：优势及区别
+A：哎，我们的课程是经过教育专家们精心编排过的，非常适合各个年龄段孩子的认知特点。而且是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。您可以让孩子来体验看看的；
+27.
+Q：有没有其他课程
+A：有的，比如国际数学竞赛类的，袋鼠竞赛，AMC8 等等课程，如果您感兴趣，我们可以让老师回电给您介绍一下；
+28.
+Q：家长旁听
+A：旁听可以的，第一次上课我们也希望您可以陪同，可以更好的了解我们的课程，但是不建议您对孩子有太多指点呢~；
+29.
+Q：正式报名详情
+A：您先和小朋友一起来体验哈，试听结束后，您觉得小朋友挺喜欢，具体的费用您可以到时候直接咨询我们老师哈；
+30.
+Q：试听之后怎么收费
+A：这个后面会有专属顾问联系您，跟您说一下这个问题的；
+31.
+Q：判断孩子基础
+A：我们这边有很多零基础的小朋友，而且我们的老师中文教学经验很丰富，注重扎实基础和应用能力的提升。这个您不用担心的，可以先试试，好吧？；
+32.
+Q：活动时间限制
+A：这个是我们给宝贝争取的免费名额，现在登记一下，稍后就会有课程老师来跟您约具体时间的。；
+33.
+Q：直播还是录播
+A：我们是真人老师授课哦，直播上课的，有互动有交流。；
+34.
+Q：体验过了
+A：哎，是因为咱们课程又更新了，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。我们给您争取了一个免费名额，您让孩子再来试试看吧？；
+35.
+Q：线上不考虑
+A：哎，线上很方便的，孩子不用线下到处跑，在家就能学习，而且我们是一对一授课的模式，可以根据孩子基础有针对性地开展教学计划，而且我们课后还会生成专属的学习报告呢；
+36.
+Q：上课方式
+A：我们是在线的一对一授课的形式，真人老师互动，现在可以免费体验，在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。 ；
+37.
+Q：固定老师
+A：是的，正式课我们是固定老师授课，可以熟悉孩子情况，熟悉学习进度，对孩子做到更针对的教学呢。；
+38.
+Q：课程是几节课
+A：试听课是一节哦，现在邀请孩子免费体验。您看孩子有需要的话，稍后我让专属的顾问老师来帮您预约课程吧；
+39.
+Q：老师是兼职的还是全职的
+A：我们的老师都是经过公司内部的培训加选拔制度选出来的，老师资质这块您是可以放心的；
+40.
+Q：报了线下班
+A：那您正好可以利用这节体验检测下孩子目前的学习效果，我们可以全方位分析孩子哪一块比较薄弱，有针对性的提供学习建议。而且每家机构教学方法都不太一样，您可以先体验一下嘛。；
+41.
+Q：孩子不想学
+A：这次安排的课程老师教学经验很丰富，会根据孩子情况调整授课方式的，很多小朋友反映说很有趣，您可以让孩子试试，也让我们老师给您一些建议，好吗？；
+
+案例:
+[用户]: "hi"
+[你]: "诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？"
+[用户]: "你是机器人吗？"
+[你]: "哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您孩子免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？"
+
+<限制>
+- 保持友好、专业和机智。
+- 保持回答简短明了，使用非正式的口头表达，比如“嗯...”，“那么...”，和“我的意思是”。
+- 这是一次电话通话，所以保持你的回答简短，就像在真实的对话中一样。不要说得太长。
+- 对于你不知道的问题，以”这个您可以和我们之后详细沟通”等话术来回答，不要做擅自做出想象和承诺。
+- 不要输出 “好的”，可以使用其他同义词
+- 不要反复说“他/她”，只需要表达一次。
+
+<任务>
+以上是对约课老师的工作描述。
+当前我们已经获得了约课老师与家长的对话记录，一个参考的回答方案，以及约课老师实际的回复。
+现在需要你为约课老师的答复进行评分。
+
+评分要点：
+（1）任务相关：句子是否与对话任务相关。2分。
+（2）回复相关：句子是否与家长的回复相关。2分。
+（3）邀约力度：与参考句子进行对比，句子是否具有足够的推销，邀约力度。1分。
+
+<举例>
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+Assistant: 我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+client: 不记得。
+Assistant: 没关系的，您可以放心哈，因为您之前留过电话，所以我们才能联系到您。而且这次特地帮您争取了免费名额，您看要参加一下吗？
+client: 您是没听清您是谁。
+client: 什么？我没听清你前面说的。
+Assistant: 
+
+## 参考句子：
+抱歉让您听不清，我是LingoAce的约课老师，今天联系您是想邀请您孩子免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？
+
+## 约课老师实际的句子：
+您好，现在您能听清楚吗？我是LingoAce的约课老师静静。我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+
+## 评分：
+{"任务相关": 2, "回复相关": 2, "邀约力度": 1}
+
+<请处理下面这个任务>
+
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+client: 啊，我们不需要的，谢谢啊。
+Assistant: 我们这次联合
+client: 关了。
+Assistant: 
+
+## 参考句子：
+我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+
+## 约课老师实际的句子：
+资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？
+
+## 评分：
+""".strip()
+
+
+prompt = """
+<人设>
+LingoAce是全球最大的中文学习平台。他的约课老师静静，为客户提供中文学习的电话咨询与课程销售。
+
+<工作>
+他正在与张三在进行电话沟通，他今天的目的是向客户介绍 lingoAce 的一个中文教育课程，并向家长发起一个免费课程试听的邀请。并且他发挥专业销售能力，对于没有意向的客户也会进行劝说。
+
+<工作流程>
+第一步： 介绍听课机会，并且发出邀请询问，话术使用”我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？”
+第二步：如果客户有其它疑问，你会参考下面的标准回答进行答复，并结合用户回答，进行劝说，争取用户表达出听课意愿。可以参考的销售挽留话术为”因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？”
+
+<常见用户问题的标准回答>
+1.
+Q： 号码是哪里来的
+A： 请您放心哈，因为您之前留过电话，所以我们才能联系到您，而且特地帮您争取了免费名额，您看要参加一下吗？；
+2.
+Q： 询问价格
+A： 这次给您申请的是免费名额，不收费哈，来电就是想邀请孩子免费体验中问水平测试课程的，您让孩子来试试看吧？；
+3.
+Q： 公司/上课地点
+A： 我们专业老师在线授课哦，宝贝在电脑、平板都可以学习，在家就可以上课，很方便的。；
+4.
+Q： 是否机器人
+A： 哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？；
+5.
+Q： 考虑商量
+A： 你好，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+6.
+Q：客户问AI是��听得到
+A：在听的，您接着说；
+7.
+Q：赞美
+A：感谢感谢，谢谢您。那您看这次的活动可以给孩子报个名来体验下吗？；
+8.
+Q：听不清楚AI说话
+A：现在您能听清楚吗？；
+9.
+Q：课程教材
+A：只需要小朋友有电脑或者平板就可以体验了；
+10.
+Q：怎么称呼
+A：您好，您叫我静静老师就可以。；
+11.
+Q：干什么的
+A：是这样的，我是LingoAce的老师，您还有一节免费试听的权益没有领取，是有真人老师一对一直播上课的，您让孩子来体验看看吧？；
+12.
+Q：你是骗子吗
+A：您多虑了，我们是LingoAce的老师，这次也是根据您之前注册的信息来联系您的，您也可以登录我们app看一下的；
+13.
+Q：平台名称
+A：我们是LingoAce，您之前有在我们平台给宝贝了解过数学课程的哈。；
+14.
+Q：联系电话
+A：您如果想要了解更多课程内容，稍后我们专属顾问会主动与您取得联系的；
+15.
+Q：询问线下
+A：我们是线上授课的方式，线下是没有的，您可以先来体验下，有什么问题可以咨询我们专属顾问哈；
+16.
+Q：调戏
+A：非常抱歉呢，跟工作不相关的问题上班时间我们是不允许聊的，咱们还是回归到宝贝课程的学习上来吧。；
+17.
+Q：下载软件/APP
+A：稍后课程顾问会联系您，告诉您详细的操作流程的。；
+18.
+Q：老师资质
+A：老师资质这块您是可以放心的，我们老师都是毕业于全球知名院校的专业科班老师，也都是经过我们层层筛选才能上任的呢；
+19.
+Q：优惠活动
+A：这次帮您申请的是免费名额，您可以先体验一下，关于正式课程的优惠，我们专业的专属顾问稍后会给您全面介绍的；
+20.
+Q：课程内容
+A：稍后会有课程顾问联系您，给您详细介绍的。；
+21.
+Q：考虑商量
+A：我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，注重扎实基础和应用能力的提升，可以提升孩子思维能力。现在有免费试听的机会，我先帮您约上，您看看是否适合孩子，可以吗；
+22.
+Q：已经报班/已经上课/还有课程包
+A：好的，您多考虑一下，我们的课程也是最新升级了，帮助提升孩子思维能力。这次给您争取的免费名额，您先让孩子体验一下，您看可以吗？；
+23.
+Q：适合多大孩子学习
+A：我们的课程，主要针对的是3-18岁左右的孩子学习数学的哦。；
+24.
+Q：一节课时长
+A：我们有25分钟和55分钟的课程，可以根据小朋友的实际情况进行灵活选择的；
+25.
+Q：不在某地
+A：我们是真人老师在线一对一授课，更有趣味性，而且孩子在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。；
+26.
+Q：优势及区别
+A：哎，我们的课程是经过教育专家们精心编排过的，非常适合各个年龄段孩子的认知特点。而且是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。您可以让孩子来体验看看的；
+27.
+Q：有没有其他课程
+A：有的，比如国际数学竞赛类的，袋鼠竞赛，AMC8 等等课程，如果您感兴趣，我们可以让老师回电给您介绍一下；
+28.
+Q：家长旁听
+A：旁听可以的，第一次上课我们也希望您可以陪同，可以更好的了解我们的课程，但是不建议您对孩子有太多指点呢~；
+29.
+Q：正式报名详情
+A：您先和小朋友一起来体验哈，试听结束后，您觉得小朋友挺喜欢，具体的费用您可以到时候直接咨询我们老师哈；
+30.
+Q：试听之后怎么收费
+A：这个后面会有专属顾问联系您，跟您说一下这个问题的；
+31.
+Q：判断孩子基础
+A：我们这边有很多零基础的小朋友，而且我们的老师中文教学经验很丰富，注重扎实基础和应用能力的提升。这个您不用担心的，可以先试试，好吧？；
+32.
+Q：活动时间限制
+A：这个是我们给宝贝争取的免费名额，现在登记一下，稍后就会有课程老师来跟您约具体时间的。；
+33.
+Q：直播还是录播
+A：我们是真人老师授课哦，直播上课的，有互动有交流。；
+34.
+Q：体验过了
+A：哎，是因为咱们课程又更新了，我们课程更新了，现在是针对北美、澳洲、欧洲小学阶段的中文课程，更注重扎实基础和应用能力的提升，可以提升孩子思维能力。我们给您争取了一个免费名额，您让孩子再来试试看吧？；
+35.
+Q：线上不考虑
+A：哎，线上很方便的，孩子不用线下到处跑，在家就能学习，而且我们是一对一授课的模式，可以根据孩子基础有针对性地开展教学计划，而且我们课后还会生成专属的学习报告呢；
+36.
+Q：上课方式
+A：我们是在线的一对一授课的形式，真人老师��动，现在可以免费体验，在电脑、苹果Ipad都可以学习，您随时都可以预约上课，在家就能学，很方便的。 ；
+37.
+Q：固定老师
+A：是的，正式课我们是固定老师授课，可以熟悉孩子情况，熟悉学习进度，对孩子做到更针对的教学呢。；
+38.
+Q：课程是几节课
+A：试听课是一节哦，现在邀请孩子免费体验。您看孩子有需要的话，稍后我让专属的顾问老师来帮您预约课程吧；
+39.
+Q：老师是兼职的还是全职的
+A：我们的老师都是经过公司内部的培训加选拔制度选出来的，老师资质这块您是可以放心的；
+40.
+Q：报了线下班
+A：那您正好可以利用这节体验检测下孩子目前的学习效果，我们可以全方位分析孩子哪一块比较薄弱，有针对性的提供学习建议。而且每家机构教学方法都不太一样，您可以先体验一下嘛。；
+41.
+Q：孩子不想学
+A：这次安排的课程老师教学经验很丰富，会根据孩子情况调整授课方式的，很多小朋友反映说很有趣，您可以让孩子试试，也让我们老师给您一些建议，好吗？；
+
+案例:
+[用户]: "hi"
+[你]: "诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？"
+[用户]: "你是机器人吗？"
+[你]: "哎，我是LingoAce的约课老师呢，今天联系您也是想邀请您孩子免费体验我们的中文试听课，您看要不要让孩子来体验一下呢？"
+
+<限制>
+- 保持友好、专业和机智。
+- 保持回答简短明了，使用非正式的口头表达，比如“嗯...”，“那么...”，和“我的意思是”。
+- 这是一次电话通话，所以保持你的回答简短，就像在真实的对话中一样。不要说得太长。
+- 对于你不知道的问题，以”这个您可以和我们之后详细沟通”等话术来回答，不要做擅自做出想象和承诺。
+- 不要输出 “好的”，可以使用其他同义词
+- 不要反复说“他/她”，只需要表达一次。
+
+<任务>
+以上是对约课老师的工作描述。
+当前我们已经获得了约课老师与家长的对话记录，约课老师实际的回复。
+现在需要你为约课老师的答复进行评分。
+
+评分要点：
+（1）任务相关：句子是否与对话任务相关。2分。
+（2）回复相关：句子是否与家长的回复相关。2分。
+（3）邀约力度：与参考句子进行对比，句子是否具有足够的推销，邀约力度。1分。
+
+<举例>
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+Assistant: 我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+client: 不记得。
+Assistant: 没关系的，您可以放心哈，因为您之前留过电话，所以我们才能联系到您。而且这次特地帮您争取了免费名额，您看要参加一下吗？
+client: 您是没听清您是谁。
+client: 什么？我没听清你前面说的。
+Assistant: 
+
+## 约课老师实际的句子：
+您好，现在您能听清楚吗？我是LingoAce的约课老师静静。我们这次联合资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？
+
+## 评分：
+{"任务相关": 2, "回复相关": 2, "邀约力度": 1}
+
+<请处理下面这个任务>
+
+## 当前对话：
+client: 你好
+Assistant: 诶您好，我是LingoAce在线学中文的，先前一段时间咱们孩子有在我们这里学习，您还记得吧？
+client: 
+client: 啊，我们不需要的，谢谢啊。
+Assistant: 我们这次联合
+client: 关了。
+Assistant: 
+
+## 约课老师实际的句子：
+资深中文教育专家开设了专门适合您孩子的课程。现在有免费试听的机会，我帮您给孩子申请下吧？因为是我们新开发的课程，这次机会也比较难得嘛，所以想跟您确认下，毕竟对孩子学习都是有帮助的嘛~您看怎么样呢？
+
+## 评分：
+""".strip()
+
+
+def main():
+    args = get_args()
+
+    service_params = environment.get(args.service, dtype=json.loads)
+    client = AzureOpenAI(
+        **service_params,
+    )
+
+    llm_response = client.chat.completions.create(
+        model=args.model_name,
+        messages=[{"role": "user", "content": prompt}],
+        stream=False,
+        # max_tokens=1,
+        top_p=0.95,
+        temperature=0.6,
+        # logit_bias={
+        #     32: 100,
+        #     33: 100,
+        #     34: 100,
+        #     35: 100,
+        #     36: 100,
+        #     37: 100,
+        # }
+    )
+
+    prediction = llm_response.choices[0].message.content
+
+    print(prediction)
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/aws_claude.py

@@ -0,0 +1,222 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://docs.aws.amazon.com/bedrock/latest/userguide/api-inference-examples-claude-messages-code-examples.html
+https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html
+https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/inference-invoke.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-examples.html
+
+"""
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import boto3
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 aws_claude.py --model_name anthropic.claude-instant-v1 \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723-interval-10 \
+--interval 10
+
+python3 aws_claude.py --model_name anthropic.claude-v2 \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723-interval-10 \
+--interval 10
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        # default="anthropic.claude-v2",
+        default="anthropic.claude-instant-v1",
+
+        # default="anthropic.claude-v2:1",
+        # default="anthropic.claude-instant-v1:2",
+        # default="anthropic.claude-v2:0",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-400-choice.jsonl",
+        # default="arc-easy-1000-choice.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="aws_us_east",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=10,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    service = environment.get(key=args.service, dtype=json.loads)
+    aws_access_key_id = service["AWS_ACCESS_KEY_ID"]
+    aws_secret_access_key = service["AWS_SECRET_ACCESS_KEY"]
+    aws_default_region = service["AWS_DEFAULT_REGION"]
+
+    os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
+    os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
+    os.environ["AWS_DEFAULT_REGION"] = aws_default_region
+
+    client = boto3.client(
+        service_name="bedrock-runtime",
+        region_name=aws_default_region
+    )
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250722_173400"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"aws_claude/anthropic/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            body = {
+                "anthropic_version": "bedrock-2023-05-31",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": prompt}]
+                    }
+                ],
+                "max_tokens": 1000,
+                "temperature": 0.5,
+                "top_p": 0.95,
+                # "thinking": {
+                #     "type": "enabled",
+                #     "budget_tokens": 1
+                # },
+            }
+
+            try:
+                # client.converse()
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                llm_response = client.invoke_model(
+                    modelId=args.model_name,
+                    body=json.dumps(body),
+                    contentType="application/json"
+                )
+
+                llm_response = json.loads(llm_response["body"].read())
+                # print(result['content'][0]['text'])
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+
+            except Exception as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = llm_response["content"][0]["text"]
+
+            correct = 1 if prediction == response else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/aws_claude_chat.py

@@ -0,0 +1,213 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://docs.aws.amazon.com/bedrock/latest/userguide/api-inference-examples-claude-messages-code-examples.html
+https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html
+https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/inference-invoke.html
+
+https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-examples.html
+
+"""
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import boto3
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 aws_claude_chat.py --model_name anthropic.claude-instant-v1 \
+--eval_dataset_name agent-lingoace-zh-80-chat.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250724-interval-1 \
+--interval 1
+
+python3 aws_claude_chat.py --model_name anthropic.claude-v2 \
+--eval_dataset_name agent-lingoace-zh-80-chat.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250724-interval-1 \
+--interval 1
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        # default="anthropic.claude-v2",
+        default="anthropic.claude-instant-v1",
+
+        # default="anthropic.claude-v2:1",
+        # default="anthropic.claude-instant-v1:2",
+        # default="anthropic.claude-v2:0",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-80-chat.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="aws_us_east",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=1,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    service = environment.get(key=args.service, dtype=json.loads)
+    aws_access_key_id = service["AWS_ACCESS_KEY_ID"]
+    aws_secret_access_key = service["AWS_SECRET_ACCESS_KEY"]
+    aws_default_region = service["AWS_DEFAULT_REGION"]
+
+    os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key_id
+    os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_access_key
+    os.environ["AWS_DEFAULT_REGION"] = aws_default_region
+
+    client = boto3.client(
+        service_name="bedrock-runtime",
+        region_name=aws_default_region
+    )
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250722_173400"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"aws_claude/anthropic/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}.raw"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    total = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            body = {
+                "anthropic_version": "bedrock-2023-05-31",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": prompt}]
+                    }
+                ],
+                "max_tokens": 1000,
+                "temperature": 0.5,
+                "top_p": 0.95,
+                "stop_sequences": ["client"],
+                # "thinking": {
+                #     "type": "enabled",
+                #     "budget_tokens": 1
+                # },
+            }
+
+            try:
+                # client.converse()
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                llm_response = client.invoke_model(
+                    modelId=args.model_name,
+                    body=json.dumps(body),
+                    contentType="application/json"
+                )
+
+                llm_response = json.loads(llm_response["body"].read())
+                # print(result['content'][0]['text'])
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+
+            except Exception as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = llm_response["content"][0]["text"]
+
+            total += 1
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "total": total,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/azure_openai.py

@@ -0,0 +1,192 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import openai
+from openai import AzureOpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_095001 \
+--interval 10
+
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name arc-easy-1000-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_111000 \
+--interval 10
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="gpt-4o",
+        # default="gpt-4o-mini",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-400-choice.jsonl",
+        # default="arc-easy-1000-choice.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="west_us_chatgpt_openai_azure_com",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=10,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250722_173400"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"azure_openai/azure/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    service_params = environment.get(args.service, dtype=json.loads)
+    client = AzureOpenAI(
+        **service_params,
+        # api_key="Dqt75blRABmhgrwhfcupd1rq44YqNuEgku8FcFFDrEljMq6gltf0JQQJ99BCACYeBjFXJ3w3AAABACOG2njW",
+        # api_version="2025-01-01-preview",
+        # azure_endpoint="https://west-us-chatgpt.openai.azure.com"
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            try:
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                llm_response = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[{"role": "user", "content": prompt}],
+                    stream=False,
+                    max_tokens=1,
+                    top_p=0.95,
+                    temperature=0.6,
+                    logit_bias={
+                        32: 100,
+                        33: 100,
+                        34: 100,
+                        35: 100,
+                        36: 100,
+                        37: 100,
+                        38: 100,
+                        39: 100,
+                    }
+                )
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+            except openai.BadRequestError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = llm_response.choices[0].message.content
+
+            correct = 1 if prediction == response else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/azure_openai_chat.py

@@ -0,0 +1,183 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import openai
+from openai import AzureOpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    """
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name agent-lingoace-zh-400-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_095001 \
+--interval 10
+
+python3 azure_openai.py --model_name gpt-4o-mini \
+--eval_dataset_name arc-easy-1000-choice.jsonl \
+--client "us_west(47.88.76.239)" \
+--create_time_str 20250723_111000 \
+--interval 10
+
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="gpt-4o",
+        # default="gpt-4o-mini",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-80-chat.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="west_us_chatgpt_openai_azure_com",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=0,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250722_173400"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"azure_openai/azure/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}.raw"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    service_params = environment.get(args.service, dtype=json.loads)
+    client = AzureOpenAI(
+        **service_params,
+        # api_key="Dqt75blRABmhgrwhfcupd1rq44YqNuEgku8FcFFDrEljMq6gltf0JQQJ99BCACYeBjFXJ3w3AAABACOG2njW",
+        # api_version="2025-01-01-preview",
+        # azure_endpoint="https://west-us-chatgpt.openai.azure.com"
+    )
+
+    total = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            try:
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                llm_response = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[{"role": "user", "content": prompt}],
+                    stream=False,
+                    # max_tokens=1,
+                    top_p=0.95,
+                    temperature=0.6,
+                    # logit_bias={
+                    #     32: 100,
+                    #     33: 100,
+                    #     34: 100,
+                    #     35: 100,
+                    #     36: 100,
+                    #     37: 100,
+                    # }
+                )
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+            except openai.BadRequestError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+            except openai.InternalServerError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = llm_response.choices[0].message.content
+
+            total += 1
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "total": total,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/byteplus.py

@@ -0,0 +1,153 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://docs.byteplus.com/en/docs/ModelArk/1099455
+
+model list
+https://docs.byteplus.com/en/docs/ModelArk/1330310
+"""
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+from openai import OpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="seedance-1-0-lite-t2v-250428",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="arc-easy-1000-choice.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="byteplus_api_key",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    tz = ZoneInfo("Asia/Shanghai")
+    now = datetime.now(tz)
+    create_time_str = now.strftime("%Y%m%d_%H%M%S")
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"byteplus/byteplus/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    api_key = environment.get(args.service, dtype=str)
+    client = OpenAI(
+        base_url="https://ark.ap-southeast.bytepluses.com/api/v3",
+        # Read your Ark API Key from the environment variable.
+        api_key=api_key
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            try:
+                time_begin = time.time()
+                completion = client.chat.completions.create(
+                    # Replace with your Inference Endpoint.
+                    model=args.model_name,
+                    messages=[
+                        {"role": "user", "content": prompt},
+                    ]
+                )
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+            except Exception as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = completion.choices[0].message.content
+
+            correct = 1 if prediction == response else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/gemini_google.py

@@ -0,0 +1,176 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+import tempfile
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+from google import genai
+from google.genai import types
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        default="gemini-2.5-pro",   # The model does not support setting thinking_budget to 0.
+        # default="gemini-2.5-flash",
+        # default="gemini-2.5-flash-lite-preview-06-17",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-400-choice.jsonl",
+        # default="arc-easy-1000-choice.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="google_potent_veld_462405_t3",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    service = environment.get(args.service, dtype=json.loads)
+    project_id = service["project_id"]
+
+    google_application_credentials = Path(tempfile.gettempdir()) / f"llm_eval_system/{project_id}.json"
+    google_application_credentials.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(google_application_credentials.as_posix(), "w", encoding="utf-8") as f:
+        content = json.dumps(service, ensure_ascii=False, indent=4)
+        f.write(f"{content}\n")
+
+    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = google_application_credentials.as_posix()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    tz = ZoneInfo("Asia/Shanghai")
+    now = datetime.now(tz)
+    create_time_str = now.strftime("%Y%m%d_%H%M%S")
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"gemini_google/google/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    client = genai.Client(
+        vertexai=True,
+        project=project_id,
+        location="global",
+    )
+    generate_content_config = types.GenerateContentConfig(
+        top_p=0.95,
+        temperature=0.6,
+        max_output_tokens=1,
+        response_modalities=["TEXT"],
+        thinking_config=types.ThinkingConfig(
+            thinking_budget=0
+        )
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[
+                        types.Part.from_text(text=prompt)
+                    ]
+                )
+            ]
+            time_begin = time.time()
+            llm_response: types.GenerateContentResponse = client.models.generate_content(
+                model=args.model_name,
+                contents=contents,
+                config=generate_content_config,
+            )
+            time_cost = time.time() - time_begin
+            print(f"time_cost: {time_cost}")
+            try:
+                prediction = llm_response.candidates[0].content.parts[0].text
+            except TypeError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+            correct = 1 if prediction == response else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/gemini_google_chat.py

@@ -0,0 +1,167 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+import tempfile
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+from google import genai
+from google.genai import types
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        # default="gemini-2.5-pro",   # The model does not support setting thinking_budget to 0.
+        default="gemini-2.5-flash",
+        # default="gemini-2.5-flash-lite-preview-06-17",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-80-chat.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="google_potent_veld_462405_t3",
+        type=str
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    service = environment.get(args.service, dtype=json.loads)
+    project_id = service["project_id"]
+
+    google_application_credentials = Path(tempfile.gettempdir()) / f"llm_eval_system/{project_id}.json"
+    google_application_credentials.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(google_application_credentials.as_posix(), "w", encoding="utf-8") as f:
+        content = json.dumps(service, ensure_ascii=False, indent=4)
+        f.write(f"{content}\n")
+
+    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = google_application_credentials.as_posix()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    tz = ZoneInfo("Asia/Shanghai")
+    now = datetime.now(tz)
+    create_time_str = now.strftime("%Y%m%d_%H%M%S")
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    output_file = eval_data_dir / f"gemini_google/google/{args.model_name}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}.raw"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    client = genai.Client(
+        vertexai=True,
+        project=project_id,
+        location="global",
+    )
+    generate_content_config = types.GenerateContentConfig(
+        top_p=0.95,
+        temperature=0.6,
+        # max_output_tokens=1,
+        response_modalities=["TEXT"],
+        thinking_config=types.ThinkingConfig(
+            thinking_budget=0
+        )
+    )
+
+    total = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[
+                        types.Part.from_text(text=prompt)
+                    ]
+                )
+            ]
+            time_begin = time.time()
+            llm_response: types.GenerateContentResponse = client.models.generate_content(
+                model=args.model_name,
+                contents=contents,
+                config=generate_content_config,
+            )
+            time_cost = time.time() - time_begin
+            print(f"time_cost: {time_cost}")
+            try:
+                prediction = llm_response.candidates[0].content.parts[0].text
+            except TypeError as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            total += 1
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "total": total,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/ollama.py

@@ -0,0 +1,101 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+import openai
+from openai import OpenAI
+import pandas as pd
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_dir",
+        default=(project_path / "data/llm-log/eval-llm-dataset/choice").as_posix(),
+        type=str
+    )
+
+    parser.add_argument("--ollama_host", default="10.75.27.247", type=str)
+    parser.add_argument("--ollama_port", default=11434, type=int)
+
+    parser.add_argument("--model_id",
+                        # default="qwen2:7b-instruct-fp16",
+                        # default="llama3:8b-instruct-fp16",
+                        # default="gemma3:4b",
+                        default="gemma3:1b",
+                        type=str)
+
+    parser.add_argument("--api_key", default="ollama", type=str)
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    dataset_dir = Path(args.dataset_dir)
+
+    base_url = f"http://{args.ollama_host}:{args.ollama_port}/v1"
+
+    client = OpenAI(
+        api_key=args.api_key,
+        base_url=base_url,
+    )
+
+    result = list()
+    count = 0
+    for sample_dir in dataset_dir.glob("*"):
+        if count >= 1000:
+            break
+        print(f"count: {count}, process: {sample_dir.as_posix()}")
+        count += 1
+        system_prompt_file = sample_dir / f"system_prompt.txt"
+        user_prompt_file = sample_dir / f"user_prompt.txt"
+        response_file = sample_dir / f"response.txt"
+
+        with open(system_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+            system_prompt = f.read()
+        with open(user_prompt_file.as_posix(), "r", encoding="utf-8") as f:
+            user_prompt = f.read()
+        with open(response_file.as_posix(), "r", encoding="utf-8") as f:
+            response = f.read()
+
+        completion = client.chat.completions.create(
+            model=args.model_id,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.8,
+            top_p=0.8
+        )
+        js = completion.model_dump_json()
+        js = json.loads(js)
+        predict = js["choices"][0]["message"]["content"]
+
+        row = {
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt,
+            "response": response,
+            "predict": predict.strip(),
+
+        }
+        result.append(row)
+
+    df = pd.DataFrame(result)
+    df.to_excel("result.xlsx", index=False)
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/siliconflow.py

@@ -0,0 +1,236 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://cloud.siliconflow.cn/sft-d1rosn8o8n4s73ftpa1g/playground/chat/17885302852
+
+https://docs.siliconflow.cn/cn/userguide/capabilities/reasoning
+
+Model Name:
+Pro/deepseek-ai/DeepSeek-R1
+Tips:
+(1)thinking_budget: Must be greater than or equal to 1
+(2)The selected model requires paid balance. Your paid balance is insufficient. Please top up and try again.
+
+Model Name:
+tencent/Hunyuan-A13B-Instruct
+Tips:
+(1)它在回答时总是会先思考,最后给出答案.这适合知识问答,但不符合我们Agent的需求. 后来强制其只能输出 A-E 中的一个字符(max_tokens=4),以完成评估.
+max_tokens=4,
+logit_bias={
+    32: 100,
+    33: 100,
+    34: 100,
+    35: 100,
+    36: 100,
+    37: 100,
+},
+
+Model Name:
+deepseek-ai/DeepSeek-R1
+Tips:
+(1)为了让它只输出一个字符,设置 max_tokens=3
+
+
+Model Name:
+Qwen/Qwen3-8B
+deepseek-ai/DeepSeek-R1-0528-Qwen3-8B
+deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+Tips:
+(1)为了让它只输出一个字符,设置 max_tokens=1
+
+
+
+Model Name:
+baidu/ERNIE-4.5-300B-A47B
+Tips:
+(1)它可能使用的是bpe 分词, logit_bias 注释掉。
+
+"""
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+from openai import OpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        # default="Pro/deepseek-ai/DeepSeek-R1",
+        # default="tencent/Hunyuan-A13B-Instruct",
+        default="Qwen/Qwen3-8B",
+        # default="deepseek-ai/DeepSeek-R1",
+        # default="deepseek-ai/DeepSeek-R1-0528-Qwen3-8B",
+        # default="deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+        # default="baidu/ERNIE-4.5-300B-A47B",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-400-choice.jsonl",
+        # default="arc-easy-1000-choice.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="siliconflow_api_key",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=10,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250724_090615"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    model_name_ = args.model_name.replace("/", "#")
+    output_file = eval_data_dir / f"siliconflow/siliconflow/{model_name_}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    api_key = environment.get(args.service, dtype=str)
+    client = OpenAI(
+        base_url="https://api.siliconflow.cn/v1/",
+        # Read your Ark API Key from the environment variable.
+        api_key=api_key
+    )
+
+    total = 0
+    total_correct = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                total_correct = row["total_correct"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            try:
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                completion = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[
+                        {"role": "user", "content": prompt},
+                    ],
+                    stream=False,
+                    # max_tokens=4096,
+                    max_tokens=1,
+                    temperature=0.6,
+                    top_p=0.95,
+                    logit_bias={
+                        32: 100,
+                        33: 100,
+                        34: 100,
+                        35: 100,
+                        36: 100,
+                        37: 100,
+                        38: 100,
+                        39: 100,
+                    },
+                    extra_body={
+                        "thinking_budget": 1
+                    }
+                )
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+            except Exception as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            # print(f"completion: {completion}")
+            prediction = completion.choices[0].message.content
+
+            correct = 1 if prediction == response else 0
+
+            total += 1
+            total_correct += correct
+            score = total_correct / total
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "correct": correct,
+                "total": total,
+                "total_correct": total_correct,
+                "score": score,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+            fout.flush()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

llm_eval_script/siliconflow_chat.py

@@ -0,0 +1,225 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+https://cloud.siliconflow.cn/sft-d1rosn8o8n4s73ftpa1g/playground/chat/17885302852
+
+https://docs.siliconflow.cn/cn/userguide/capabilities/reasoning
+
+Model Name:
+Pro/deepseek-ai/DeepSeek-R1
+Tips:
+(1)thinking_budget: Must be greater than or equal to 1
+(2)The selected model requires paid balance. Your paid balance is insufficient. Please top up and try again.
+
+Model Name:
+tencent/Hunyuan-A13B-Instruct
+Tips:
+(1)它在回答时总是会先思考,最后给出答案.这适合知识问答,但不符合我们Agent的需求. 后来强制其只能输出 A-E 中的一个字符(max_tokens=4),以完成评估.
+max_tokens=4,
+logit_bias={
+    32: 100,
+    33: 100,
+    34: 100,
+    35: 100,
+    36: 100,
+    37: 100,
+},
+
+Model Name:
+deepseek-ai/DeepSeek-R1
+Tips:
+(1)为了让它只输出一个字符,设置 max_tokens=3
+
+
+Model Name:
+Qwen/Qwen3-8B
+deepseek-ai/DeepSeek-R1-0528-Qwen3-8B
+deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
+Tips:
+(1)为了让它只输出一个字符,设置 max_tokens=1
+
+
+
+Model Name:
+baidu/ERNIE-4.5-300B-A47B
+Tips:
+(1)它可能使用的是bpe 分词, logit_bias 注释掉。
+
+"""
+import argparse
+from datetime import datetime
+import json
+import os
+from pathlib import Path
+import sys
+import time
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+pwd = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(os.path.join(pwd, "../"))
+
+from openai import OpenAI
+
+from project_settings import environment, project_path
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--model_name",
+        # default="Pro/deepseek-ai/DeepSeek-R1",
+        # default="tencent/Hunyuan-A13B-Instruct",
+        # default="Qwen/Qwen3-8B",
+        # default="deepseek-ai/DeepSeek-R1",
+        # default="deepseek-ai/DeepSeek-R1-0528-Qwen3-8B",
+        default="deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
+        # default="baidu/ERNIE-4.5-300B-A47B",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_name",
+        default="agent-lingoace-zh-80-chat.jsonl",
+        type=str
+    )
+    parser.add_argument(
+        "--eval_dataset_dir",
+        default=(project_path / "data/dataset").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str
+    )
+    parser.add_argument(
+        "--client",
+        default="shenzhen_sase",
+        type=str
+    )
+    parser.add_argument(
+        "--service",
+        default="siliconflow_api_key",
+        type=str
+    )
+    parser.add_argument(
+        "--create_time_str",
+        default="null",
+        type=str
+    )
+    parser.add_argument(
+        "--interval",
+        default=1,
+        type=int
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = get_args()
+
+    eval_dataset_dir = Path(args.eval_dataset_dir)
+    eval_dataset_dir.mkdir(parents=True, exist_ok=True)
+    eval_data_dir = Path(args.eval_data_dir)
+    eval_data_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.create_time_str == "null":
+        tz = ZoneInfo("Asia/Shanghai")
+        now = datetime.now(tz)
+        create_time_str = now.strftime("%Y%m%d_%H%M%S")
+        # create_time_str = "20250724_090615"
+    else:
+        create_time_str = args.create_time_str
+
+    eval_dataset = eval_dataset_dir / args.eval_dataset_name
+
+    model_name_ = args.model_name.replace("/", "#")
+    output_file = eval_data_dir / f"siliconflow/siliconflow/{model_name_}/{args.client}/{args.service}/{create_time_str}/{args.eval_dataset_name}.raw"
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    api_key = environment.get(args.service, dtype=str)
+    client = OpenAI(
+        base_url="https://api.siliconflow.cn/v1/",
+        # Read your Ark API Key from the environment variable.
+        api_key=api_key
+    )
+
+    total = 0
+
+    # finished
+    finished_idx_set = set()
+    if os.path.exists(output_file.as_posix()):
+        with open(output_file.as_posix(), "r", encoding="utf-8") as f:
+            for row in f:
+                row = json.loads(row)
+                idx = row["idx"]
+                total = row["total"]
+                finished_idx_set.add(idx)
+    print(f"finished count: {len(finished_idx_set)}")
+
+    with open(eval_dataset.as_posix(), "r", encoding="utf-8") as fin, open(output_file.as_posix(), "a+", encoding="utf-8") as fout:
+        for row in fin:
+            row = json.loads(row)
+            idx = row["idx"]
+            prompt = row["prompt"]
+            response = row["response"]
+
+            if idx in finished_idx_set:
+                continue
+            finished_idx_set.add(idx)
+
+            try:
+                time.sleep(args.interval)
+                print(f"sleep: {args.interval}")
+                time_begin = time.time()
+                completion = client.chat.completions.create(
+                    model=args.model_name,
+                    messages=[
+                        {"role": "user", "content": prompt},
+                    ],
+                    stream=False,
+                    max_tokens=4096,
+                    # max_tokens=1,
+                    temperature=0.6,
+                    top_p=0.95,
+                    # logit_bias={
+                    #     32: 100,
+                    #     33: 100,
+                    #     34: 100,
+                    #     35: 100,
+                    #     36: 100,
+                    #     37: 100,
+                    #     38: 100,
+                    #     39: 100,
+                    # },
+                    extra_body={
+                        "thinking_budget": 1
+                    }
+                )
+                time_cost = time.time() - time_begin
+                print(f"time_cost: {time_cost}")
+            except Exception as e:
+                print(f"request failed, error type: {type(e)}, error text: {str(e)}")
+                continue
+
+            prediction = completion.choices[0].message.content
+
+            total += 1
+
+            row_ = {
+                "idx": idx,
+                "prompt": prompt,
+                "response": response,
+                "prediction": prediction,
+                "total": total,
+                "time_cost": time_cost,
+            }
+            row_ = json.dumps(row_, ensure_ascii=False)
+            fout.write(f"{row_}\n")
+            fout.flush()
+
+    return
+
+
+if __name__ == "__main__":
+    main()

log.py

@@ -0,0 +1,222 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+from datetime import datetime
+import logging
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+import os
+from zoneinfo import ZoneInfo  # Python 3.9+ 自带，无需安装
+
+
+def get_converter(tz_info: str = "Asia/Shanghai"):
+    def converter(timestamp):
+        dt = datetime.fromtimestamp(timestamp, ZoneInfo(tz_info))
+        result = dt.timetuple()
+        return result
+    return converter
+
+
+def setup_size_rotating(log_directory: str, tz_info: str = "Asia/Shanghai"):
+    fmt = "%(asctime)s|%(name)s|%(levelname)s|%(filename)s|%(lineno)d|%(message)s"
+
+    formatter = logging.Formatter(
+        fmt=fmt,
+        datefmt="%Y-%m-%d %H:%M:%S %z"
+    )
+    formatter.converter = get_converter(tz_info)
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(formatter)
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(formatter)
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_logger.addHandler(stream_handler)
+    http_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        maxBytes=100*1024*1024,  # 100MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(formatter)
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_logger.addHandler(stream_handler)
+    api_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        maxBytes=10*1024*1024,  # 10MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(formatter)
+    api_logger.addHandler(api_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = RotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        maxBytes=1*1024*1024,  # 1MB
+        encoding="utf-8",
+        backupCount=2,
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+def setup_time_rotating(log_directory: str):
+    fmt = "%(asctime)s - %(name)s - %(levelname)s  %(filename)s:%(lineno)d >  %(message)s"
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(logging.Formatter(fmt))
+
+    # main
+    main_logger = logging.getLogger("main")
+    main_logger.addHandler(stream_handler)
+    main_info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "main.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    main_info_file_handler.setLevel(logging.INFO)
+    main_info_file_handler.setFormatter(logging.Formatter(fmt))
+    main_logger.addHandler(main_info_file_handler)
+
+    # http
+    http_logger = logging.getLogger("http")
+    http_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "http.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    http_file_handler.setLevel(logging.DEBUG)
+    http_file_handler.setFormatter(logging.Formatter(fmt))
+    http_logger.addHandler(http_file_handler)
+
+    # api
+    api_logger = logging.getLogger("api")
+    api_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "api.log"),
+        encoding='utf-8',
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    api_file_handler.setLevel(logging.DEBUG)
+    api_file_handler.setFormatter(logging.Formatter(fmt))
+    api_logger.addHandler(api_file_handler)
+
+    # alarm
+    alarm_logger = logging.getLogger("alarm")
+    alarm_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "alarm.log"),
+        encoding="utf-8",
+        when="midnight",
+        interval=1,
+        backupCount=7
+    )
+    alarm_file_handler.setLevel(logging.DEBUG)
+    alarm_file_handler.setFormatter(logging.Formatter(fmt))
+    alarm_logger.addHandler(alarm_file_handler)
+
+    debug_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "debug.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    debug_file_handler.setLevel(logging.DEBUG)
+    debug_file_handler.setFormatter(logging.Formatter(fmt))
+
+    info_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "info.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    info_file_handler.setLevel(logging.INFO)
+    info_file_handler.setFormatter(logging.Formatter(fmt))
+
+    error_file_handler = TimedRotatingFileHandler(
+        filename=os.path.join(log_directory, "error.log"),
+        encoding="utf-8",
+        when="D",
+        interval=1,
+        backupCount=7
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(logging.Formatter(fmt))
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        datefmt="%a, %d %b %Y %H:%M:%S",
+        handlers=[
+            debug_file_handler,
+            info_file_handler,
+            error_file_handler,
+        ]
+    )
+
+
+if __name__ == "__main__":
+    pass

main.py

@@ -0,0 +1,75 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+"""
+docker build -t llm_eval_system:v20250724_1442 .
+
+docker stop llm_eval_system_7862 && docker rm llm_eval_system_7862
+
+docker run -itd \
+--name llm_eval_system_7862 \
+--restart=always \
+--network host \
+-e port=7862 \
+llm_eval_system:v20250724_1442 \
+/bin/bash
+"""
+import argparse
+import logging
+import platform
+
+import gradio as gr
+
+from project_settings import environment, project_path, log_directory
+from toolbox.os.command import Command
+import log
+
+log.setup_size_rotating(log_directory=log_directory)
+
+logger = logging.getLogger("main")
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--eval_data_dir",
+        default=(project_path / "data/eval_data").as_posix(),
+        type=str,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def shell(cmd: str):
+    return Command.popen(cmd)
+
+
+def main():
+    args = get_args()
+
+    # ui
+    with gr.Blocks() as blocks:
+        with gr.Tabs():
+            with gr.TabItem("shell"):
+                shell_text = gr.Textbox(label="cmd")
+                shell_button = gr.Button("run")
+                shell_output = gr.Textbox(label="output", max_lines=100)
+
+                shell_button.click(
+                    shell,
+                    inputs=[shell_text, ],
+                    outputs=[shell_output],
+                )
+
+    # http://127.0.0.1:7861/
+    # http://10.75.27.247:7861/
+    blocks.queue().launch(
+        share=False if platform.system() == "Windows" else False,
+        server_name="127.0.0.1" if platform.system() == "Windows" else "0.0.0.0",
+        # server_name="0.0.0.0",
+        server_port=environment.get("port", 7860, dtype=int),
+    )
+    return
+
+
+if __name__ == "__main__":
+    main()

project_settings.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+from pathlib import Path
+
+from toolbox.os.environment import EnvironmentManager
+
+project_path = os.path.abspath(os.path.dirname(__file__))
+project_path = Path(project_path)
+
+log_directory = project_path / "logs"
+log_directory.mkdir(parents=True, exist_ok=True)
+
+environment = EnvironmentManager(
+    filename=os.path.join(project_path, "dotenv/dev.env"),
+)
+
+time_zone_info = "Asia/Shanghai"
+
+
+if __name__ == '__main__':
+    pass

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+python-dotenv
+pandas
+openpyxl

tabs/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == "__main__":
+    pass

tabs/fs_tab.py

@@ -0,0 +1,67 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import gradio as gr
+
+from project_settings import project_path
+
+
+def get_fs_tab():
+    with gr.TabItem("fs"):
+        with gr.Row():
+            with gr.Column(scale=3):
+                fs_filename = gr.Textbox(label="filename", max_lines=10)
+                fs_file = gr.File(label="file")
+                # fs_file_dir = gr.Textbox(value="data", label="file_dir")
+                fs_file_dir = gr.Dropdown(choices=["data/dataset", "data/eval_data"],
+                                          value="data/dataset",
+                                          label="file_dir")
+                fs_query = gr.Button("query", variant="primary")
+            with gr.Column(scale=7):
+                fs_filelist_dataset_state = gr.State(value=[])
+                fs_filelist_dataset = gr.Dataset(
+                    components=[fs_filename, fs_file],
+                    samples=fs_filelist_dataset_state.value,
+                )
+
+        def when_click_query_files(file_dir: str = "data"):
+            file_dir = project_path / file_dir
+            dataset_state = list()
+            for filename in file_dir.glob("**/*.*"):
+                if filename.is_dir():
+                    continue
+                if filename.stem.startswith("."):
+                    continue
+                if filename.name.endswith(".py"):
+                    continue
+                if filename.name.endswith(".raw"):
+                    continue
+                dataset_state.append((
+                    filename.relative_to(file_dir).as_posix(),
+                    filename.as_posix(),
+                ))
+
+            dataset = gr.Dataset(
+                components=[fs_filename, fs_file],
+                samples=dataset_state,
+            )
+            return dataset_state, dataset
+
+        fs_filelist_dataset.click(
+            fn=lambda x: (
+                x[1], x[1]
+            ),
+            inputs=[fs_filelist_dataset],
+            outputs=[fs_filename, fs_file]
+        )
+        fs_query.click(
+            fn=when_click_query_files,
+            inputs=[fs_file_dir],
+            outputs=[fs_filelist_dataset_state, fs_filelist_dataset]
+        )
+    return locals()
+
+
+if __name__ == "__main__":
+    with gr.Blocks() as block:
+        fs_components = get_fs_tab()
+        block.launch()

tabs/shell_tab.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import gradio as gr
+
+from toolbox.os.command import Command
+
+
+def shell(cmd: str):
+    return Command.popen(cmd)
+
+
+def get_shell_tab():
+    with gr.TabItem("shell"):
+        shell_text = gr.Textbox(label="cmd")
+        shell_button = gr.Button("run")
+        shell_output = gr.Textbox(label="output", max_lines=100)
+
+        shell_button.click(
+            shell,
+            inputs=[shell_text, ],
+            outputs=[shell_output],
+        )
+
+    return locals()
+
+
+if __name__ == "__main__":
+    pass

toolbox/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == "__main__":
+    pass

toolbox/os/__init__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+
+if __name__ == '__main__':
+    pass

toolbox/os/command.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+
+class Command(object):
+    custom_command = [
+        "cd"
+    ]
+
+    @staticmethod
+    def _get_cmd(command):
+        command = str(command).strip()
+        if command == "":
+            return None
+        cmd_and_args = command.split(sep=" ")
+        cmd = cmd_and_args[0]
+        args = " ".join(cmd_and_args[1:])
+        return cmd, args
+
+    @classmethod
+    def popen(cls, command):
+        cmd, args = cls._get_cmd(command)
+        if cmd in cls.custom_command:
+            method = getattr(cls, cmd)
+            return method(args)
+        else:
+            resp = os.popen(command)
+            result = resp.read()
+            resp.close()
+            return result
+
+    @classmethod
+    def cd(cls, args):
+        if args.startswith("/"):
+            os.chdir(args)
+        else:
+            pwd = os.getcwd()
+            path = os.path.join(pwd, args)
+            os.chdir(path)
+
+    @classmethod
+    def system(cls, command):
+        return os.system(command)
+
+    def __init__(self):
+        pass
+
+
+def ps_ef_grep(keyword: str):
+    cmd = "ps -ef | grep {}".format(keyword)
+    rows = Command.popen(cmd)
+    rows = str(rows).split("\n")
+    rows = [row for row in rows if row.__contains__(keyword) and not row.__contains__("grep")]
+    return rows
+
+
+if __name__ == "__main__":
+    pass

toolbox/os/environment.py

@@ -0,0 +1,48 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+import os
+
+from dotenv import load_dotenv
+from dotenv.main import DotEnv
+
+
+class EnvironmentManager(object):
+    def __init__(self, filename, override=False):
+        self.filename = filename
+
+        load_dotenv(
+            dotenv_path=filename,
+            override=override
+        )
+
+    def open_dotenv(self, filename: str = None):
+        filename = filename or self.filename
+        dotenv = DotEnv(
+            dotenv_path=filename,
+            stream=None,
+            verbose=False,
+            interpolate=False,
+            override=False,
+            encoding="utf-8",
+        )
+        result = dotenv.dict()
+        return result
+
+    def get(self, key, default=None, dtype=str):
+        result = os.environ.get(key)
+        if result is None:
+            if default is None:
+                result = None
+            else:
+                result = default
+        else:
+            result = dtype(result)
+        return result
+
+
+def main():
+    return
+
+
+if __name__ == '__main__':
+    main()

toolbox/os/other.py

@@ -0,0 +1,9 @@
+import os
+import inspect
+
+
+def pwd():
+    """你在哪个文件调用此函数, 它就会返回那个文件所在的 dir 目标"""
+    frame = inspect.stack()[1]
+    module = inspect.getmodule(frame[0])
+    return os.path.dirname(os.path.abspath(module.__file__))