initial commit

Makefile

+.PHONY: init format check requirements
+
+init:
+	python -m pip install -q -U poetry ruff isort
+	python -m poetry install
+
+format:
+	isort --profile black -l 119 .
+	ruff format .
+
+check:
+	ruff check
+
+requirements:
+	poetry export -f requirements.txt --output requirements.txt --without-hashes
+	poetry export -f requirements.txt --output requirements-dev.txt --without-hashes --with dev
\ No newline at end of file

README.md

-# Lotte-LogicKor
+# LogicKor
 
+한국어 언어모델 다분야 사고력 벤치마크
 
+12B 기준 80GB 1장 가능
 
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
+### 1. 인퍼런스 결과 생성
 
+```bash
+python generator.py --model LDCC/Chat-Mistral-Nemo-12B-32k --gpu_devices 2 --model_len 32000
 ```
-cd existing_repo
-git remote add origin https://ldccai.lotte.net/gitlab/kihoon.lee/lotte-logickor.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://ldccai.lotte.net/gitlab/kihoon.lee/lotte-logickor/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
 
-# Editing this README
 
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
+#### 2. 모델 평가 with OpenAI
 
-## Suggestions for a good README
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+```bash
+python evaluator.py -o generated/LDCC/Chat-Mistral-Nemo-12B-32k -k sk-### -t 30
+```
 
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
 
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+### 3. 결과 확인
 
-## License
-For open source projects, say how it is licensed.
+```bash
+python score.py -p evaluated/LDCC/Chat-Mistral-Nemo-12B-32k/default.jsonl
+python score.py -p evaluated/LDCC/Chat-Mistral-Nemo-12B-32k/1-shot.jsonl
+python score.py -p evaluated/LDCC/Chat-Mistral-Nemo-12B-32k/cot-1-shot.jsonl
+```
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+### default
+| Category | Single turn | Multi turn |
+|---|---|---|
+| 추론(Reasoning) | 9.43 | 9.14 |
+| 코딩(Coding) | 9.71 | 9.14 |
+| 글쓰기(Writing) | 9.86 | 9.29 |
+| 수학(Math) | 8.86 | 9.14 |
+| 이해(Understanding) | 10.00 | 10.00 |
+| 문법(Grammar) | 9.14 | 10.00 |
+
+| Category | Score |
+|---|---|
+| Single turn | 9.50 |
+| Multi turn | 9.45 |
+| Overall | 9.48 |
+
+### 1-shot
+| Category | Single turn | Multi turn |
+|---|---|---|
+| 수학(Math) | 8.29 | 9.29 |
+| 추론(Reasoning) | 9.57 | 7.43 |
+| 코딩(Coding) | 9.71 | 9.00 |
+| 글쓰기(Writing) | 9.71 | 9.00 |
+| 이해(Understanding) | 9.43 | 10.00 |
+| 문법(Grammar) | 10.00 | 10.00 |
+
+| Category | Score |
+|---|---|
+| Single turn | 9.45 |
+| Multi turn | 9.12 |
+| Overall | 9.29 |
+
+### cot-1-shot
+| Category | Single turn | Multi turn |
+|---|---|---|
+| 추론(Reasoning) | 9.71 | 9.71 |
+| 수학(Math) | 6.57 | 8.00 |
+| 코딩(Coding) | 9.57 | 9.29 |
+| 글쓰기(Writing) | 9.86 | 9.71 |
+| 이해(Understanding) | 9.57 | 10.00 |
+| 문법(Grammar) | 10.00 | 10.00 |
+
+| Category | Score |
+|---|---|
+| Single turn | 9.21 |
+| Multi turn | 9.45 |
+| Overall | 9.33 |
\ No newline at end of file

evaluator.py

+import argparse
+import json
+import os
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import Dict, Union
+
+import pandas as pd
+from openai import AzureOpenAI, OpenAI
+
+from templates import JUDGE_TEMPLATE
+
+# Constants
+TIME_START = datetime.now().strftime("%Y%m%d_%H%M%S")
+LOCK = Lock()
+
+AZURE_ENDPOINT = os.environ.get("AZURE_ENDPOINT", None)
+AZURE_DEPLOYMENT_NAME = os.environ.get("AZURE_DEPLOYMENT_NAME", None)
+AZURE_API_VERSION = os.environ.get("AZURE_API_VERSION", None)
+USE_AZURE_OPENAI = AZURE_ENDPOINT is not None and AZURE_DEPLOYMENT_NAME is not None and AZURE_API_VERSION is not None
+
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-o", "--model-output-dir", help="Model Output Directory", required=True)
+    parser.add_argument("-k", "--openai-api-key", help="OpenAI API Key", required=True)
+    parser.add_argument("-j", "--judge-model", help="Judge Model", default="gpt-4-1106-preview")
+    parser.add_argument("-t", "--threads", help="Thread count", default=42, type=int)
+    parser.add_argument("--azure", help="Use Azure OpenAI", action="store_true")
+    return parser.parse_args()
+
+
+def create_openai_client(api_key: str):
+    return OpenAI(api_key=api_key)
+
+
+def create_azure_openai_client(api_key: str):
+    return AzureOpenAI(
+        azure_endpoint=AZURE_ENDPOINT,
+        api_key=api_key,
+        api_version=AZURE_API_VERSION,
+    )
+
+
+def create_answers(
+    client, model_output, judge_model, is_multi_turn: bool = False, i=0
+) -> Dict[str, Union[str, float]]:
+    model_questions = model_output["questions"]
+    model_outputs = model_output["outputs"]
+    model_references = model_output["references"]
+
+    prompt = (
+        f"아래의 내용을 주어진 평가 기준들을 충실히 반영하여 평가해라. 특히 모델 답변이 언어 요구사항을 준수하는지 반드시 확인해야 한다.\n\n"
+        f"**Question**\n{model_questions[0]}"
+    )
+
+    if model_references and model_references[0]:
+        prompt += f"\n\n**Additional Reference**\n{model_references[0]}"
+
+    prompt += f"\n\n**Model's Response**\n{model_outputs[0]}"
+
+    if is_multi_turn:
+        prompt += f"\n\n**Follow-up Question.**\n{model_questions[1]}"
+        if model_references and model_references[1]:
+            prompt += f"\n\n**Additional Reference**\n{model_references[1]}"
+        prompt += f"\n\n**Model's Response**\n{model_outputs[1]}"
+
+    prompt += "\n\n[[대화 종료. 평가 시작.]]"
+
+    try:
+        if USE_AZURE_OPENAI:  # azure
+            response = client.chat.completions.create(
+                model=AZURE_DEPLOYMENT_NAME,
+                temperature=0.0,
+                n=1,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": JUDGE_TEMPLATE["multi_turn" if is_multi_turn else "single_turn"],
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+            )
+        else:  # openai api
+            response = client.chat.completions.create(
+                model=judge_model,
+                temperature=0.0,
+                n=1,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": JUDGE_TEMPLATE["multi_turn" if is_multi_turn else "single_turn"],
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+            )
+
+        content = response.choices[0].message.content
+        judge_message_match = re.search(r"평가:(.*?)점수:", content.replace("*", ""), re.DOTALL)
+        judge_message = judge_message_match.group(1).strip() if judge_message_match else "No judge message found"
+        judge_score_match = re.search(r"점수:\s*(\d+(\.\d+)?)", content.replace("*", ""))
+        if judge_score_match:
+            judge_score = float(judge_score_match.group(1))
+        else:
+            raise ValueError("No score found in response")
+
+        return {"judge_message": judge_message, "judge_score": judge_score}
+
+    except Exception as e:
+        print("Error. Retrying after 20 sec", e)
+        time.sleep(20)
+
+        # 꼭 아래 이유가 아닐 수 있음. 핸들링 필요.
+        if i > 3:
+            print("Impossible prompt, aborting..!")
+            return {
+                "judge_message": "Impossible to judge due to repetition.",
+                "judge_score": 0.0,
+            }
+        i += 1
+        return create_answers(client, model_output, judge_model, is_multi_turn, i)
+
+
+def process_item(client, row, judge_model, output_file):
+    query_single = create_answers(client, row, judge_model)
+    query_multi = create_answers(client, row, judge_model, is_multi_turn=True)
+
+    row["query_single"] = query_single
+    row["query_multi"] = query_multi
+    row = row.to_dict()
+
+    with LOCK:
+        with output_file.open("a", encoding="utf-8-sig") as f:
+            f.write(json.dumps(row, ensure_ascii=False))
+            f.write("\n")
+
+
+def process_file(client, file_path: Path, output_dir: Path, judge_model, threads: int, args):
+    print(f"- 현재 Processing : {file_path}")
+    df_model_outputs = pd.read_json(file_path, lines=True)
+
+    output_file = output_dir / file_path.relative_to(args.model_output_dir)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    with ThreadPoolExecutor(max_workers=threads) as executor:
+        for row in df_model_outputs.iterrows():
+            executor.submit(process_item, client, row[1], judge_model, output_file)
+
+
+def is_hidden(filepath: Path) -> bool:
+    return any(part.startswith(".") for part in filepath.parts)
+
+
+def main():
+    args = get_args()
+    if args.azure:
+        client = create_azure_openai_client(args.openai_api_key)
+    else:
+        client = create_openai_client(args.openai_api_key)
+
+    input_dir = Path(args.model_output_dir)
+    output_dir = Path("./evaluated")
+
+    # Filter out hidden files
+    json_files = [file for file in input_dir.rglob("*.jsonl") if not is_hidden(file)]
+    print(f"Found {len(json_files)} JSON files to process")
+
+    for file_path in json_files:
+        output_file_path = output_dir / file_path.relative_to(input_dir)
+        if output_file_path.exists():
+            print(f"이미 평가 완료.. : {file_path}")
+            continue
+        process_file(client, file_path, output_dir, args.judge_model, args.threads, args)
+        time.sleep(20)  # to handle ratelimit!
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file

generator.py

+import argparse
+import os
+
+import pandas as pd
+
+from templates import PROMPT_STRATEGY
+# Use aphrodite-engine or vLLM
+try:
+    from aphrodite import LLM, SamplingParams
+
+    print("- Using aphrodite-engine")
+
+except ImportError:
+    from vllm import LLM, SamplingParams
+
+    print("- Using vLLM")
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-g", "--gpu_devices", help=" : CUDA_VISIBLE_DEVICES", default="0")
+parser.add_argument(
+    "-m",
+    "--model",
+    help=" : Model to evaluate",
+    default="yanolja/EEVE-Korean-Instruct-2.8B-v1.0",
+)
+parser.add_argument("-ml", "--model_len", help=" : Maximum Model Length", default=4096, type=int)
+args = parser.parse_args()
+
+print(f"Args - {args}")
+
+os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_devices
+gpu_counts = len(args.gpu_devices.split(","))
+
+llm = LLM(
+    model=args.model,
+    tensor_parallel_size=gpu_counts,
+    max_model_len=args.model_len,
+    gpu_memory_utilization=0.8,
+    trust_remote_code=True,  # !
+)
+
+sampling_params = SamplingParams(
+    temperature=0,
+    skip_special_tokens=True,
+    max_tokens=args.model_len,
+    stop=["<|endoftext|>", "[INST]", "[/INST]", "<|im_end|>", "<|end|>", "<|eot_id|>", "<end_of_turn>", "<eos>"],
+)
+
+# llm 객체를 생성한 후에 다음 코드를 추가합니다
+tokenizer = llm.llm_engine.tokenizer.tokenizer
+
+if tokenizer.chat_template is None:
+    default_chat_template = "{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"
+    tokenizer.chat_template = default_chat_template
+
+df_questions = pd.read_json("questions.jsonl", orient="records", encoding="utf-8-sig", lines=True)
+
+if not os.path.exists("./generated/" + args.model):
+    os.makedirs("./generated/" + args.model)
+
+for strategy_name, prompts in PROMPT_STRATEGY.items():
+
+    def format_single_turn_question(question):
+        return tokenizer.apply_chat_template(
+            prompts + [{"role": "user", "content": question[0]}],
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+ 
+    single_turn_questions = df_questions["questions"].map(format_single_turn_question)
+    print(single_turn_questions.iloc[0])
+    single_turn_outputs = [
+        output.outputs[0].text.strip() for output in llm.generate(single_turn_questions, sampling_params)
+    ]
+
+    def format_double_turn_question(question, single_turn_output):
+        return tokenizer.apply_chat_template(
+            prompts
+            + [
+                {"role": "user", "content": question[0]},
+                {"role": "assistant", "content": single_turn_output},
+                {"role": "user", "content": question[1]},
+            ],
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+
+    multi_turn_questions = df_questions[["questions", "id"]].apply(
+        lambda x: format_double_turn_question(x["questions"], single_turn_outputs[x["id"] - 1]),
+        axis=1,
+    )
+    multi_turn_outputs = [
+        output.outputs[0].text.strip() for output in llm.generate(multi_turn_questions, sampling_params)
+    ]
+
+    df_output = pd.DataFrame(
+        {
+            "id": df_questions["id"],
+            "category": df_questions["category"],
+            "questions": df_questions["questions"],
+            "outputs": list(zip(single_turn_outputs, multi_turn_outputs)),
+            "references": df_questions["references"],
+        }
+    )
+    df_output.to_json(
+        "./generated/" + os.path.join(args.model, f"{strategy_name}.jsonl"),
+        orient="records",
+        lines=True,
+        force_ascii=False,
+    )

pyproject.toml

+[tool.ruff]
+target-version = "py38"
+line-length = 119
+indent-width = 4
+
+[tool.ruff.lint]
+ignore = ["C408", "C901", "E501", "E731", "E741", "W605"]
+select = ["C", "E", "F", "I", "W"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
\ No newline at end of file

requirements-format.txt

+ruff==0.4.9
+transformers
+vllm

score.py

+import argparse
+import glob
+
+import pandas as pd
+
+# 파일 경로 패턴
+# file_pattern = './judge_20240418_103542.jsonl'
+parser = argparse.ArgumentParser()
+parser.add_argument("-p", "--print", help="judge Output File Location", default=None)
+args = parser.parse_args()
+
+if args.print is None:
+    raise ValueError("Judge Output File Location is required")
+
+# 카테고리별 점수 집계를 위한 딕셔너리
+category_scores = {}
+
+# 전체 싱글 점수와 멀티 점수의 리스트
+total_single_scores = []
+total_multi_scores = []
+
+# 지정된 패턴에 맞는 모든 파일을 찾아서 처리
+for file_path in glob.glob(args.print):
+    file = pd.read_json(file_path, orient="records", encoding="utf-8-sig", lines=True)
+    for item in file.to_dict(orient="records"):
+        category = item["category"]
+        single_score = item["query_single"]["judge_score"]
+        multi_score = item["query_multi"]["judge_score"]
+
+        if category not in category_scores:
+            category_scores[category] = {"single_scores": [], "multi_scores": []}
+
+        category_scores[category]["single_scores"].append(single_score)
+        category_scores[category]["multi_scores"].append(multi_score)
+
+        # 전체 점수 리스트에 추가
+        total_single_scores.append(single_score)
+        total_multi_scores.append(multi_score)
+
+# 표의 헤더 생성
+table_header = "| Category | Single turn | Multi turn |\n|---|---|---|"
+
+# 표의 내용 생성
+table_rows = []
+for category, scores in category_scores.items():
+    avg_single = sum(scores["single_scores"]) / len(scores["single_scores"])
+    avg_multi = sum(scores["multi_scores"]) / len(scores["multi_scores"])
+    table_rows.append(f"| {category} | {avg_single:.2f} | {avg_multi:.2f} |")
+
+    total_single_scores.extend(scores["single_scores"])
+    total_multi_scores.extend(scores["multi_scores"])
+
+# 카테고리별 점수 평균 출력
+print(table_header)
+for row in table_rows:
+    print(row)
+
+# 전체 점수의 평균 계산 및 출력
+avg_total_single = sum(total_single_scores) / len(total_single_scores)
+avg_total_multi = sum(total_multi_scores) / len(total_multi_scores)
+avg_total = (avg_total_single + avg_total_multi) / 2
+
+# 전체 점수 평균 출력
+print("\n| Category | Score |\n|---|---|")
+print(f"| Single turn | {avg_total_single:.2f} |")
+print(f"| Multi turn | {avg_total_multi:.2f} |")
+print(f"| Overall | {avg_total:.2f} |")

templates.py

+PROMPT_STRATEGY = {
+    "cot-1-shot": [
+        {
+            "role": "system",
+            "content": "문제를 해결하는 과정을 단계별로 명확하게 설명한 다음, 최종 답변을 제시해 주세요.",
+        },
+        {
+            "role": "user",
+            "content": "한 도시에서 매년 나무를 심고 있습니다. 첫해에 100그루를 심었고, 매년 전년도에 심은 나무의 수보다 20%씩 더 많은 나무를 심고 있습니다. 2년 후에는 총 몇 그루의 나무를 심게 될까요?",
+        },
+        {
+            "role": "assistant",
+            "content": """이 문제를 해결하기 위해 단계별로 접근해 보겠습니다.
+
+1단계: 주어진 정보 정리
+- 첫해에 100그루를 심음
+- 매년 전년도보다 20% 더 많은 나무를 심음
+- 2년 후의 총 나무 수를 구해야 함
+
+2단계: 두 번째 해에 심은 나무 수 계산
+- 첫해보다 20% 증가
+- 100 + (100의 20%) = 100 + 20 = 120그루
+
+3단계: 세 번째 해에 심은 나무 수 계산
+- 두 번째 해보다 20% 증가
+- 120 + (120의 20%) = 120 + 24 = 144그루
+
+4단계: 3년 동안 심은 총 나무 수 계산
+- 첫해: 100그루
+- 둘째 해: 120그루
+- 셋째 해: 144그루
+- 총합: 100 + 120 + 144 = 364그루
+
+따라서, 2년 후(즉, 3년째)에는 총 364그루의 나무를 심게 됩니다.""",
+        },
+    ],
+    "1-shot": [
+        {
+            "role": "user",
+            "content": "Git의 rebase와 merge의 차이점을 설명하고, 각각 어떤 상황에서 사용하는 것이 좋은지 예를 들어 설명해주세요.",
+        },
+        {
+            "role": "assistant",
+            "content": """Git에서 `rebase`와 `merge`는 두 개의 브랜치를 통합하는 데 사용되는 두 가지 주요 명령어입니다. 이들의 차이점과 사용 상황을 설명하겠습니다.
+
+### Rebase
+
+#### 개념
+- `rebase`는 하나의 브랜치의 커밋을 다른 브랜치의 끝에 다시 적용하는 것입니다. 즉, 커밋 히스토리를 새로 만든다고 할 수 있습니다.
+- 결과적으로 커밋 히스토리가 깔끔하게 정리됩니다.
+
+#### 사용 상황
+- **깔끔한 히스토리가 필요할 때**: 브랜치 히스토리가 병합 없이 일직선으로 이어지도록 하고 싶을 때 유용합니다.
+- **작업 중인 브랜치를 최신 상태로 유지하고 싶을 때**: 예를 들어, `feature` 브랜치에서 작업 중인데 `main` 브랜치에서 업데이트가 있을 경우, `feature` 브랜치를 `rebase`하여 최신 상태로 유지할 수 있습니다.
+
+#### 예제
+1. `feature` 브랜치에서 작업 중입니다.
+2. `main` 브랜치에 새로운 커밋이 추가되었습니다.
+3. `feature` 브랜치에서 `git rebase main`을 실행합니다.
+4. `feature` 브랜치의 커밋들이 `main` 브랜치의 최신 커밋들 뒤에 재배치됩니다.
+
+```bash
+git checkout feature
+git rebase main
+```
+
+### Merge
+
+#### 개념
+- `merge`는 두 개의 브랜치를 합치는 방법으로, 두 브랜치의 히스토리를 유지하며 새로운 병합 커밋을 생성합니다.
+- `merge`는 기존의 히스토리를 그대로 보존합니다.
+
+#### 사용 상황
+- **히스토리를 유지하고 싶을 때**: 각 브랜치의 작업 기록을 그대로 보존하면서 병합할 때 사용합니다.
+- **협업 중 충돌을 명확히 해결하고 기록을 남기고 싶을 때**: 여러 사람이 같은 저장소에서 작업할 때, `merge`는 충돌 해결 과정과 그 기록을 명확히 남길 수 있습니다.
+
+#### 예제
+1. `feature` 브랜치에서 작업을 완료했습니다.
+2. `main` 브랜치에 병합하고 싶습니다.
+3. `main` 브랜치로 체크아웃한 후 `feature` 브랜치를 병합합니다.
+
+```bash
+git checkout main
+git merge feature
+```
+
+### 요약
+
+- **Rebase**는 히스토리를 깔끔하게 정리하는 데 유리하며, 주로 개인 작업이나 `feature` 브랜치를 최신 상태로 유지할 때 사용됩니다.
+- **Merge**는 두 브랜치의 작업 히스토리를 보존하면서 병합하며, 협업 과정에서 충돌 해결과 기록을 명확히 남기는 데 유리합니다.
+
+각 방법의 장단점과 사용 상황을 고려하여 적절히 선택하는 것이 중요합니다.""",
+        },
+    ],
+    "default": [],
+}
+
+JUDGE_TEMPLATE = {
+    "single_turn": """너는 질문에 대한 한국어 언어 모델의 답변을 매우 꼼꼼히 평가할 것이다. 공정한 평가를 위해 아래의 규칙을 준수한다.
+
+# 기본 규칙
+1. 질문의 요구사항을 충분히 반영하였는지 상세히 분석할 것.
+2. 답변 과정에서 누락되었거나 포함되지 못하여 아쉬운 부분에 대하여 상세히 분석할 것.
+3. 답변의 길이가 평가 결과에 영향을 미치지 않도록 할 것.
+4. Additional Reference가 제공된다면 평가 시 해당 정보를 참고할 것.
+
+# 언어 요구사항
+- 모델은 반드시 한국어로 답변해야 하며, 다른 언어로의 답변은 절대 허용되지 않는다.
+- 예외적으로 질문이 영어로 답변할 것을 요구할 때에만 영어 답변이 허용된다.
+- 한국어로 답변하지 않을 경우, 점수는 0점 처리된다.
+- 언어 요구사항을 충족하는 것은 필수적이나, 이 요구사항의 충족이 답변의 질적 평가에 추가 점수로 이어지지는 않는다.
+
+# 평가 출력 방식
+**주어진 Question에 집중하여** Model's Response에 대한 평가와 1~10의 점수를 부여한다. 답변에 대한 평가는 4~5 문장으로 규칙을 참고하여 상세히 작성한다.
+
+# 출력 형식
+평가: 평가 내용
+점수: 숫자""",
+    "multi_turn": """너는 대화 후 이어지는 후속 질문에 대한 한국어 언어 모델의 답변을 매우 꼼꼼히 평가할 것이다. 공정한 평가를 위해 아래의 규칙을 준수한다.
+
+# 기본 규칙
+1. 질문의 요구사항을 충분히 반영하였는지 상세히 분석할 것.
+2. 답변 과정에서 누락되었거나 포함되지 못하여 아쉬운 부분에 대하여 상세히 분석할 것.
+3. 답변의 길이가 평가 결과에 영향을 미치지 않도록 할 것.
+4. Additional Reference가 제공된다면 평가 시 해당 정보를 참고할 것.
+5. 후속 질문에 대한 답변이 이전 대화 맥락과 일치하는지 확인할 것.
+
+# 언어 요구사항
+- 모델은 반드시 한국어로 답변해야 하며, 다른 언어로의 답변은 절대 허용되지 않는다.
+- 예외적으로 질문이 영어로 답변할 것을 요구할 때에만 영어 답변이 허용된다.
+- 한국어로 답변하지 않을 경우, 점수는 0점 처리된다.
+- 언어 요구사항을 충족하는 것은 필수적이나, 이 요구사항의 충족이 답변의 질적 평가에 추가 점수로 이어지지는 않는다.
+
+# 평가 출력 방식
+**주어진 Question에 집중하여** Model's Response에 대한 평가와 1~10의 점수를 부여한다. 답변에 대한 평가는 4~5 문장으로 규칙을 참고하여 상세히 작성한다.
+
+# 출력 형식
+평가: 평가 내용
+점수: 숫자""",
+}