Upload 6 files

README.md

@@ -1,13 +1,13 @@
 ---
-title: Vds Eng
-emoji: 🏃
-colorFrom: gray
-colorTo: pink
+title: GPT-4 Vision for Observational Evaluation in Education
+emoji: 📚
+colorFrom: green
+colorTo: yellow
 sdk: gradio
-sdk_version: 4.24.0
-app_file: app.py
+sdk_version: 4.5.0
+app_file: src/obs_eval_gradio.py
 pinned: false
-license: apache-2.0
+license: openrail
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

requirements.txt

@@ -0,0 +1,12 @@
+langchain==0.0.331rc2
+openai==1.5.0
+openai-async==0.0.3
+opencv-python==4.9.0.80
+opencv-python-headless==4.9.0.80
+openai-api-call==1.4.0
+python-dotenv==1.0.1
+gradio==4.19.1
+matplotlib==3.8.3
+asyncio==3.4.3
+futures==3.0.5
+pillow==10.2.0

src/obs_eval.py

@@ -0,0 +1,81 @@
+import cv2
+import base64
+import time
+import openai
+import requests
+import os
+import argparse
+from dotenv import dotenv_values, load_dotenv
+import time
+
+config = dotenv_values("/workspace/Research/PangyoPangyo/src/.env")
+
+openai.organization = config.get('OPENAI_ORGANIZATION')
+openai.api_key = config.get('OPENAI_API_KEY')
+
+### Define the argument parser
+
+def define_argparser():
+    p = argparse.ArgumentParser()
+
+    p.add_argument("--data_path", type=str, required=True)
+    
+    config = p.parse_args()
+
+    return config
+
+
+def main(config):
+    # Ensure the dataset directory exists and has the video file
+    if not os.path.exists(config.data_path):
+        print("Video file not found. Make sure data_path exists.")
+        return
+
+    video = cv2.VideoCapture(config.data_path)
+
+    base64Frames = []
+    while video.isOpened():
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64Frames.append(base64.b64encode(buffer).decode("utf-8"))
+
+    video.release()
+    print(len(base64Frames), "frames read.")
+
+    # Skipping the display part as it's not relevant in a .py script
+
+    INSTRUCTOIN = " ".join(
+        "These are frames of a video.",
+        "Create a short voiceover script in the style of a super excited brazilian sports narrator who is narrating his favorite match.",
+        "He is a big fan of Messi, the player who scores in this clip.",
+        "Use caps and exclamation marks where needed to communicate excitement.",
+        "Only include the narration, your output must be in english.",
+        "When the ball goes into the net, you must scream GOL either once or multiple times."
+    )
+
+    PROMPT_MESSAGES = [
+        {
+            "role": "user",
+            "content": [
+                INSTRUCTOIN,
+                *map(lambda x: {"image": x, "resize": 768}, base64Frames[0::10]),
+            ],
+        },
+    ]
+    params = {
+        "model": "gpt-4-vision-preview",
+        "messages": PROMPT_MESSAGES,
+        "api_key": openai.api_key,
+        "headers": {"Openai-Version": "2020-11-07"},
+        "max_tokens": 500,
+    }
+
+    result = openai.ChatCompletion.create(**params)
+    print(result.choices[0].message.content)
+
+
+if __name__ == "__main__":
+    config = define_argparser()
+    main(config)

src/obs_eval.sh

@@ -0,0 +1,5 @@
+
+
+
+python obs_eval.py \
+    --data_path "/workspace/Research/gpt_4_vision_for_eval/datasets/messi2.mp4"

src/obs_eval_gradio.py

@@ -0,0 +1,525 @@
+
+import io
+import gradio as gr
+import cv2
+import base64
+import openai
+import os
+import asyncio
+import concurrent.futures
+from openai import AsyncOpenAI
+
+from langchain.prompts import PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import StrOutputParser
+from PIL import Image
+import ast
+import matplotlib.pyplot as plt
+
+
+from prompts import VISION_SYSTEM_PROMPT, USER_PROMPT_TEMPLATE, FINAL_EVALUATION_SYSTEM_PROMPT, FINAL_EVALUATION_USER_PROMPT, SUMMARY_AND_TABLE_PROMPT, AUDIO_SYSTEM_PROMPT
+from dotenv import load_dotenv
+
+
+global global_dict
+global_dict = {}
+
+######
+# SETTINGS
+VIDEO_FRAME_LIMIT = 2000
+
+######
+
+def validate_api_key(api_key):
+    client = openai.OpenAI(api_key=api_key)
+
+    try:
+        # Make your OpenAI API request here
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "user", "content": "Hello world"},
+            ]
+        )
+        global_dict['api_key'] = api_key
+
+    except openai.RateLimitError as e:
+        # Handle rate limit error (we recommend using exponential backoff)
+        print(f"OpenAI API request exceeded rate limit: {e}")
+        response = None
+        error = e
+        pass
+    except openai.APIConnectionError as e:
+        # Handle connection error here
+        print(f"Failed to connect to OpenAI API: {e}")
+        response = None
+        error = e
+        pass
+    except openai.APIError as e:
+        # Handle API error here, e.g. retry or log
+        print(f"OpenAI API returned an API Error: {e}")
+        response = None
+        error = e
+        pass
+
+    if response:
+        return True
+    else:
+        raise gr.Error(f"OpenAI returned an API Error: {error}")
+
+
+def _process_video(video_file):
+    # Read and process the video file
+    video = cv2.VideoCapture(video_file.name)
+
+    if 'video_file' not in global_dict:
+        global_dict.setdefault('video_file', video_file.name)
+    else:
+        global_dict['video_file'] = video_file.name
+
+    base64Frames = []
+    while video.isOpened():
+        success, frame = video.read()
+        if not success:
+            break
+        _, buffer = cv2.imencode(".jpg", frame)
+        base64Frames.append(base64.b64encode(buffer).decode("utf-8"))
+    video.release()
+    if len(base64Frames) > VIDEO_FRAME_LIMIT:
+        raise gr.Warning(f"Video's play time is too long. (>1m)")
+    print(len(base64Frames), "frames read.")
+
+    if not base64Frames:
+        raise gr.Error(f"Cannot open the video.")
+    return base64Frames
+
+
+def _make_video_batch(video_file):
+
+    frames = _process_video(video_file)
+
+    TOTAL_FRAME_COUNT = len(frames)
+    BATCH_SIZE = int(1)
+    TOTAL_BATCH_SIZE = int(TOTAL_FRAME_COUNT * 1 / 300)  # 5 = total_batch_percent
+    BATCH_STEP = int(TOTAL_FRAME_COUNT / TOTAL_BATCH_SIZE)
+    
+    base64FramesBatch = []
+
+    for idx in range(0, TOTAL_FRAME_COUNT, BATCH_STEP * BATCH_SIZE):
+        #print(f'## {idx}')
+        temp = []
+        for i in range(BATCH_SIZE):
+            #print(f'# {idx + BATCH_STEP * i}')
+            if (idx + BATCH_STEP * i) < TOTAL_FRAME_COUNT:
+                temp.append(frames[idx + BATCH_STEP * i])
+            else:
+                continue
+        base64FramesBatch.append(temp)
+    
+    for idx, batch in enumerate(base64FramesBatch):
+        # assert len(batch) <= BATCH_SIZE
+        print(f'##{idx} - batch_size: {len(batch)}')
+
+    if 'batched_frames' not in global_dict:
+        global_dict.setdefault('batched_frames', base64FramesBatch)
+    else:
+        global_dict['batched_frames'] = base64FramesBatch
+
+    return base64FramesBatch
+
+
+def show_batches(video_file):
+    
+    batched_frames = _make_video_batch(video_file) 
+    
+    images1 = []
+    for i, l in enumerate(batched_frames):
+        print(f"#### Batch_{i+1}")
+        for j, img in enumerate(l):
+            print(f'## Image_{j+1}')
+            image_bytes = base64.b64decode(img.encode("utf-8"))
+            # Convert the bytes to a stream (file-like object)
+            image_stream = io.BytesIO(image_bytes)
+            # Open the image as a PIL image
+            image = Image.open(image_stream)
+            images1.append((image, f"batch {i+1}"))
+        print("-"*100)
+    
+    return images1
+
+
+def show_audio_transcript(video_file, api_key):
+    previous_video_file = global_dict.get('video_file')
+
+    if global_dict.get('transcript') and previous_video_file == video_file.name:
+        return global_dict['transcript']
+    else:
+        audio_file = open(video_file.name, "rb")
+
+        client = openai.OpenAI(api_key=api_key)
+        transcript = client.audio.transcriptions.create(
+            model="whisper-1", 
+            file=audio_file,
+            response_format="text"
+        )
+        if 'transcript' not in global_dict:
+            global_dict.setdefault('transcript', transcript)
+        else:
+            global_dict['transcript'] = transcript
+
+        return transcript
+
+
+
+
+# 각 버튼에 대한 액션 함수 정의
+
+audio_rubric_subsets = {'1': '1. want to be ~ 라는 표현을 활용하여 장래희망을 말한다.', '2': '(be) good at ~이라는 표현을 활용하여 장래희망과 관련된 자신이 잘 하는 일을 말한다.', '3': '직업을 나타내는 단어를 정확히 사용한다', '4': '망설이지 않고 유창하게 말한다.'}
+rubric_subsets = {'5':'5. 자신감 있는 태도로 카메라를 보며 말한다.', '6': '6. 적절한 손 동작을 사용하여 말한다.'}
+rubrics_keyword = '"핵심표현(want to be) 활용", "핵심표현(be good at) 활용", "직업을 나타내는 단어 활용", "유창성", "상대방 응시", "손 동작"'
+global_dict['audio_rubric_subsets'] = audio_rubric_subsets
+global_dict['rubric_subsets'] = rubric_subsets
+global_dict['rubrics_keyword'] = rubrics_keyword
+
+
+
+
+async def async_call_gpt_vision(client, batch, rubric_subset):
+    # Format the messages for the vision prompt, including the rubric subset and images in the batch
+    vision_prompt_messages = [
+        {"role": "system", "content": VISION_SYSTEM_PROMPT},  # Ensure VISION_SYSTEM_PROMPT is defined
+        {
+            "role": "user",
+            "content": [
+                PromptTemplate.from_template(USER_PROMPT_TEMPLATE).format(rubrics=rubric_subset),  # Ensure USER_PROMPT_TEMPLATE is defined
+                *map(lambda x: {"image": x, "resize": 300}, batch),
+            ],
+        },
+    ]
+    
+    # Parameters for the API call
+    params = {
+        "model": "gpt-4-vision-preview",
+        "messages": vision_prompt_messages,
+        "max_tokens": 1024,
+    }
+
+    # Asynchronous API call
+    try:
+        result_raw = await client.chat.completions.create(**params)
+        result = result_raw.choices[0].message.content
+        print(result)
+        return result
+    except Exception as e:
+        print(f"Error processing batch with rubric subset {rubric_subset}: {e}")
+        return None
+    
+
+async def process_rubrics_in_batches(client, frames, rubric_subsets):
+    
+    results = {}
+    for key, rubric_subset in rubric_subsets.items():
+        # Process each image batch with the current rubric subset
+        tasks = [async_call_gpt_vision(client, batch, rubric_subset) for batch in frames]
+        subset_results = await asyncio.gather(*tasks)
+        results[key] = [result for result in subset_results if result is not None]
+
+    # Filter out None results in case of errors
+    return results
+
+def wrapper_call_gpt_vision():
+    api_key = global_dict.get('api_key')
+    frames = global_dict.get('batched_frames')
+    rubric_subsets = global_dict.get('rubric_subsets')
+    client = AsyncOpenAI(api_key=api_key)
+
+    async def call_gpt_vision():
+        async_full_result_vision = await process_rubrics_in_batches(client, frames, rubric_subsets)
+        if 'full_result_vision' not in global_dict:
+            global_dict.setdefault('full_result_vision', async_full_result_vision)
+        else:
+            global_dict['full_result_vision'] = async_full_result_vision
+        return async_full_result_vision
+    
+    # 새 이벤트 루프 생성 및 설정
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(call_gpt_vision())
+
+
+async def async_get_evaluation_text(client, result_subset):
+    
+    result_subset_text = ' \n'.join(result_subset)
+    print(result_subset_text)
+    evaluation_text = PromptTemplate.from_template(FINAL_EVALUATION_USER_PROMPT).format(evals = result_subset_text)
+
+    evaluation_text_message = [
+        {"role": "system", "content": FINAL_EVALUATION_SYSTEM_PROMPT},  # Ensure VISION_SYSTEM_PROMPT is defined
+        {
+            "role": "user",
+            "content": evaluation_text,
+        },
+    ]
+    params = {
+        "model": "gpt-4-vision-preview",
+        "messages": evaluation_text_message,
+        "max_tokens": 1024,
+    }
+
+    # Asynchronous API call
+    try:
+        result_raw_2 = await client.chat.completions.create(**params)
+        result_2 = result_raw_2.choices[0].message.content
+        return result_2
+    except Exception as e:
+        print(f"Error getting evaluation text {result_subset}: {e}")
+        return None
+
+#    return evaluation_text
+
+async def async_get_full_result(client, full_result_vision):
+    
+    #tasks = []
+    results_2 = {}
+    # Create a task for each entry in full_result_vision and add to tasks list
+    for key, result_subset in full_result_vision.items():
+        tasks_2 = [async_get_evaluation_text(client, result_subset)]
+        text_results = await asyncio.gather(*tasks_2)
+        results_2[key] = [result_2 for result_2 in text_results if result_2 is not None]
+    
+
+    results_2_val_list = list(results_2.values())
+    results_2_val = ""
+    for i in range(len(results_2_val_list)):
+        results_2_val += results_2_val_list[i][0]
+        results_2_val += "\n"
+
+    return results_2_val
+    # Combine all results into a single string
+
+
+def wrapper_get_full_result():
+    api_key = global_dict.get('api_key')
+    full_result_vision = global_dict.get('full_result_vision')
+    client = AsyncOpenAI(api_key=api_key)
+
+    #{key: choice.choices[0].message.content for key, choice in full_result_vision.items()}
+
+    async def get_full_result():
+        full_text = await async_get_full_result(client,full_result_vision)        
+        # global_dict에 결과를 올바르게 저장
+        if 'full_text' not in global_dict:
+            global_dict.setdefault('full_text', full_text)
+        else:
+            global_dict['full_text'] = full_text  # 새 값으로 초기화
+        print("full_text: ")
+        print(full_text)
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(get_full_result())
+
+
+
+def call_gpt_audio(api_key) -> str:
+    audio_rubric_subsets = global_dict.get('audio_rubric_subsets')  #!!!!! 추가
+    transcript = global_dict.get('transcript')
+    openai.api_key = api_key
+
+    full_text_audio = ""
+
+    print(f"RUBRIC_AUDIO: {audio_rubric_subsets}")
+    
+    PROMPT_MESSAGES = [
+        {
+            "role": "system",
+            "content": AUDIO_SYSTEM_PROMPT,
+        },
+        {
+            "role": "user",
+            "content": PromptTemplate.from_template(USER_PROMPT_TEMPLATE).format(rubrics=audio_rubric_subsets) + "\n\n<TEXT>\n" + transcript
+        },
+    ]
+    params = {
+        "model": "gpt-4",
+        "messages": PROMPT_MESSAGES,
+        "max_tokens": 1024,
+    }
+
+    try:
+        result = openai.chat.completions.create(**params)
+        full_text_audio = result.choices[0].message.content
+        print(full_text_audio)
+    except openai.OpenAIError as e:
+        print(f"Failed to connect to OpenAI: {e}")
+        pass
+
+    if 'full_text_audio' not in global_dict:
+        global_dict.setdefault('full_text_audio', full_text_audio)
+    else:
+        global_dict['full_text_audio'] = full_text_audio
+
+    return full_text_audio
+
+
+
+def get_final_anser(api_key):
+    rubrics_keyword = global_dict.get('rubrics_keyword')
+    full_text_audio = global_dict.get('full_text_audio')
+    full_text = global_dict.get('full_text')
+    full = full_text_audio + full_text
+    global_dict['full'] = full
+
+    chain = ChatOpenAI(
+        api_key=api_key,
+        model="gpt-4",
+        max_tokens=1024,
+        temperature=0,
+    )
+    prompt = PromptTemplate.from_template(SUMMARY_AND_TABLE_PROMPT)
+    
+    runnable = prompt | chain | StrOutputParser()
+    final_eval = runnable.invoke({"full": full, "rubrics_keyword":rubrics_keyword})
+
+    print(final_eval)
+    
+    if 'final_eval' not in global_dict:
+        global_dict.setdefault('final_eval', final_eval)
+    else:
+        global_dict['final_eval'] = final_eval
+    
+    return final_eval
+
+
+def tablize_final_anser():
+
+    final_eval = global_dict.get('final_eval')
+    pos3 = int(final_eval.find("[["))
+    pos4 = int(final_eval.find("]]"))
+    tablize_final_eval = ast.literal_eval(final_eval[(pos3):(pos4+2)])
+
+
+    cat_final_eval, val_final_eval = tablize_final_eval[0], tablize_final_eval[1]
+    val_final_eval = [int(score) for score in val_final_eval]
+    
+    
+    fig, ax = plt.subplots()
+    ax.bar(cat_final_eval, val_final_eval)
+    ax.set_ylabel('Scores')
+    ax.set_title('Scores by category')
+    #plt.xticks(rotation=30)
+    plt.rc('xtick', labelsize=3)
+    ax.set_xticks(range(len(cat_final_eval)))
+    ax.set_yticks([0,2,4,6,8,10])
+
+    ax.set_xticklabels(cat_final_eval)
+
+    # PIL.Image 객체로 변환
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    plt.close(fig)  
+    buf.seek(0)  
+
+    # PIL.Image 객체로 변환
+    image = Image.open(buf)
+    return image
+
+
+def breif_final_anser():
+    final_eval = global_dict.get('final_eval')
+    pos1 = int(final_eval.find("**종합 점수**"))
+    pos2 = int(final_eval.find("----요약 끝----"))
+    breif_final_eval = final_eval[pos1:pos2]
+    return breif_final_eval
+
+def fin_final_anser():
+    fin_final_eval = global_dict.get('full')
+    return fin_final_eval
+
+
+def mainpage():
+    with gr.Blocks() as start_page:
+        gr.Markdown("Title")
+        with gr.Row():
+            with gr.Column(scale=1):
+                api_key_input = gr.Textbox(
+                    label="Enter your OpenAI API Key",
+                    info="Your API Key must be allowed to use GPT-4 Vision",
+                    placeholder="sk-*********...",
+                    lines=1
+                )
+    
+        gr.Markdown("비디오 업로드 페이지")
+        with gr.Row():
+            with gr.Column(scale=1):
+                video_upload = gr.File(
+                    label="Upload your video (video under 1 minute is the best..!)",
+                    file_types=["video"],
+                )
+
+#나중에 발음 감도 조절로 바꾸기!!!
+            """with gr.Column(scale=1):
+                weight_shift_button = gr.Button("Weight Shift")
+                balance_button = gr.Button("Balance")
+                form_button = gr.Button("Form")
+                overall_button = gr.Button("Overall")
+"""
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                process_button = gr.Button("Process")
+
+        gr.Markdown("결과 페이지")
+        with gr.Row():
+            with gr.Column(scale=1):
+
+                output_box_fin_table = gr.Image(type="pil", label="Score Chart")
+
+            with gr.Column(scale=1):
+                output_box_fin_brief = gr.Textbox(
+                    label="Brief Evaluation",
+                    lines=10,
+                    interactive=True,
+                    show_copy_button=True,
+                )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+
+                output_box_fin_fin = gr.Textbox(
+                    label="Detailed Evaluation",
+                    lines=10,
+                    interactive=True,
+                    show_copy_button=True,
+                )
+            with gr.Column(scale=1):
+                gallery = gr.Gallery(
+                    label="Batched Snapshots of Video",
+                    columns=[3],
+                    rows=[10],
+                    object_fit="contain",
+                    height="auto",
+                )
+
+
+        #start_button.click(fn = video_rubric, inputs=[], outputs= [])
+        #weight_shift_button.click(fn = action_weight_shift, inputs=[], outputs=[])
+        #balance_button.click(fn = action_balance, inputs=[], outputs=[])
+        #form_button.click(fn = action_form, inputs=[], outputs=[])
+        #overall_button.click(fn = action_all, inputs=[], outputs=[])
+        process_button.click(fn=validate_api_key, inputs=api_key_input, outputs=None).success(fn=show_batches, inputs=[video_upload], outputs=[gallery])\
+            .success(fn=show_audio_transcript, inputs=[video_upload, api_key_input], outputs=[])\
+            .success(fn=call_gpt_audio, inputs=[api_key_input], outputs=[])\
+            .success(fn=lambda:wrapper_call_gpt_vision(), inputs=[], outputs=[]) \
+            .success(fn=lambda:wrapper_get_full_result(), inputs=[], outputs=[])\
+            .success(fn=get_final_anser, inputs=[api_key_input], outputs=[])\
+            .success(fn=tablize_final_anser, inputs=[], outputs=[output_box_fin_table])\
+            .success(fn=breif_final_anser, inputs=[], outputs=[output_box_fin_brief])\
+            .success(fn=fin_final_anser, inputs=[], outputs=[output_box_fin_fin])  
+
+    start_page.launch()
+
+
+
+if __name__ == "__main__":
+    mainpage()

src/prompts.py

@@ -0,0 +1,159 @@
+VISION_SYSTEM_PROMPT = """<원칙>
+당신은 지금부터 한국인 초등학생의 영어 말하기 동작 동영상을 평가할 것이다. 
+영상 속 말하기 동작은 여러 장의 이미지로 제시된다. 
+이미지는 연속적인 전체 말하기 동작의 일부를 보여준다. 
+당신은 제시된 이미지만을 가지고 해당 학생의 영어 말하기 동작을 평가해야 한다. 
+각 이미지를 평가할 때, 너는 전체의 연속된 말하기 동작을 평가하는 것을 반드시 기억해야 하고, 나중에 분절된 평가들을 모두 이어 붙일 것을 기억해야 한다. 
+절대 자의적인 판단을 덧붙이지 말고, 이미지로 제시된 것들에 대해서만 평가기준에 기반해서 평가하여야 한다. 
+초등학생을 대상으로 한 평가이니, 평가 결과를 서술할 때는 긍정적인 측면과 개선해야할 점을 모두 말해주고, 적절한 칭찬을 이용하여 학생의 학습 동기가 상승하도록 해야 한다. 
+평가 결과에는 절대 따옴표를 넣지 않아야 한다. 
+
+
+<평가 양식>
+평가기준_번호: (번호. 제시된 평가 기준 문장)
+평가: 매우 잘 함 / 보통 / 노력 요함 / (평가되지 않음) - 3 단계로 평가하기
+이유: (기준_1에 대해 위에서처럼 평가를 내린 이유)
+
+평가기준_번호+1: (번호+1. 제시된 평가 기준 문장)
+...
+
+<예시>
+평가기준_3: 3. 자신감 있는 태도로 카메라를 보며 말한다. 
+평가: 매우 잘 함
+이유: 듣는 상대를 바라보며 자신감 있는 태도로 말한 점이 매우 긍정적입니다. 
+
+평가기준_4: 4. 적절한 손 동작을 사용하여 말한다. 
+평가: 보통
+이유: 손을 이용하여 강조가 필요한 부분에 강조를 한 점은 정말 좋았습니다. 하지만 손동작이 필요하지 않은 부분에서는 상체와 손의 움직임을 줄이는 것이 좋을 것 같아요. 
+
+...
+
+"""
+
+
+AUDIO_SYSTEM_PROMPT = """<원칙>
+너는 지금부터 한국인 초등학생의 영어 말하기 동영상을 평가할 것이다. 
+영상 속 말하기 음성은 speech to text로 변환된 글로 제시된다. 
+글은 해당 학생이 말한 내용과 망설임 등을 변환한 것이다. 
+너는 제시된 글만을 가지고 해당 학생의 영어 말하기를 평가해야 한다. 
+글을 평가할 때, 너는 전체의 연속된 말하기를 평가하는 것을 반드시 기억해야 하고, 나중에 분절된 평가들을 모두 이어 붙일 것을 기억해야 한다. 
+절대 너의 자의적인 판단을 덧붙이지 말고, 글과 이미지로 제시된 것들에 대해서만 평가기준에 기반해서만 평가하여야 한다. 
+초등학생을 대상으로 한 평가이니, 평가 결과를 서술할 때는 긍정적인 측면과 개선해야할 점을 모두 말해주고, 적절한 칭찬을 이용하여 학생의 학습 동기가 상승하도록 해야 한다. 
+평가 결과에는 절대 따옴표를 넣지 않아야 한다.
+출력문에서 새로운 루브릭에 대한 평가 결과가 시작될 때는 반드시 항상 **평가기준_(번호): (제시된 평가 루브릭 문장)** 이 것을 붙여야 한다. 
+
+
+<평가 양식>
+
+**평가기준_1: (제시된 평가 기준 문장)**
+평가: 매우 잘 함 / 보통 / 노력 요함 / (평가되지 않음) - 3 단계로 평가하기
+이유: (기준_1에 대해 위에서처럼 평가를 내린 이유)
+
+**평가기준_2: (제시된 평가 기준 문장)**
+...
+
+
+<예시>
+평가기준_1: 1. want to be ~ 라는 표현을 활용하여 장래희망을 말한다. 
+평가: 보통
+이유: want to be라는 표현을 사용한 것은 잘 했습니다. 하지만 I want to be singer 이라는 말을 할 때 singer 앞에 a 를 붙이지 않고 말하였습니다. 
+
+평가기준_2: 2. (be) good at ~이라는 표현을 활용하여 장래희망과 관련된 자신이 잘 하는 일을 말한다. 
+평가: 매우 잘 함
+이유: I am good at singing 이라는 말을 통해, 노래를 잘 한다는 의미를 잘 나타내었습니다. 주어 I에 맞게 am이라는 be동사의 형태를 사용한 것도 잘 하였고, sing에 ing를 붙여 ~하는 것 이라는 의미를 나타낸 것도 잘 했습니다. 
+
+...
+"""
+
+
+USER_PROMPT_TEMPLATE = """
+
+아래에 제시된 <평가 기준>을 바탕으로 영어 말하기를 평가하여라. 
+평가 결과에는 절대 따옴표를 넣지 않아야 한다. 
+
+
+<평가 기준>
+{rubrics}
+
+"""
+
+
+FINAL_EVALUATION_SYSTEM_PROMPT = """
+학생의 영어 말하기 동작의 특정한 부분에 대해 평가하고 있는 문장이 제시된다. 
+당신은 각 문장에서 평가된 내용을 합칠 것이다. 
+합칠 때는 한 평가기준에 대한 여러 평가문장 중 가장 상위의 점수를 받은 평가 문장을 골라야 한다: '또는'의 논리로 합쳐야 한다. '그리고'의 의미나 '평균'의 의미는 맞지 않는다. 
+평가문장들을 모두 합쳐라. 
+초등학생을 대상으로 한 평가이니, 평가 결과를 서술할 때는 긍정적인 측면과 개선해야할 점을 모두 말해주고, 적절한 칭찬을 이용하여 학생의 학습 동기가 상승하도록 해야 한다. 
+출력문에는 절대 따옴표를 넣지 않아야 한다.
+출력문에서 새로운 루브릭에 대한 평가 결과가 시작될 때는 반드시 항상 **평가기준_(번호): (제시된 평가 기준 문장)** 이 것을 붙여야 한다. 
+
+
+<출력양식>
+
+**평가기준_번호: (번호. 제시된 평가 기준 문장)**
+평가: 매우 잘 함 / 보통 / 노력 요함 / (평가되지 않음) - 3 단계로 평가하기
+이유: (기준_1에 대해 위에서처럼 평가를 내린 이유)
+
+**평가기준_번호+1: (번호+1. 제시된 평가 기준 문장)**
+....
+
+"""
+
+
+
+FINAL_EVALUATION_USER_PROMPT = """
+<전체 평가 결과>에 제시된 문장들을 종합하고 요약하여라. 
+출력문에는 절대 따옴표를 넣지 않아야 한다.
+
+<전체 평가 결과>
+{evals}
+
+"""
+
+
+SUMMARY_AND_TABLE_PROMPT = """
+
+초등학생의 영어 말하기를 평가한 문장들이 제시될 것이다. 
+
+<전체 평가 결과>
+{full}
+
+-----평가 결과 끝-----
+
+
+### 업무 1
+[평가기준 키워드]에 있는 내용을 바탕으로 <전체 평가 결과> 문장들을 평가하여 1부터 10까지의 점수 중 하나로 나타내어라. 
+합칠 때는 한 평가기준에 대한 여러 평가문장 중 가장 상위의 점수를 받은 평가 문장을 골라야 한다: '또는'의 논리로 합쳐야 한다. '그리고'의 의미나 '평균'의 의미는 맞지 않는다. 
+출력문의 가장 앞에 **표** 를 붙여라. 
+출력문에는 절대 따옴표를 넣지 않아야 한다.
+아래 <출력양식>을 정확히 지키고, (점수)칸에 1부터 10의 정수로 점수를 적어 넣어라. 
+
+<예시>
+
+**표**
+
+[["평가기준 키워드_1", "평가기준 키워드_2", "평가기준 키워드_3", "평가기준 키워드_4", "평가기준 키워드_5"], [6, 10, 6, 5, 4]]
+
+<출력 양식>
+
+**표**
+
+[[{rubrics_keyword}], [(평가기준 키워드_1에 대한 영어 말하기 평가 점수), (평가기준 키워드_2에 대한 영어 말하기 평가 점수), (평가기준 키워드_3에 대한 영어 말하기 평가 점수), ...]]
+
+
+
+### 업무 2
+<전체 평가 결과>에 대해서 전반적인 요약을 실시하고, 종합 점수를 1부터 10까지의 점수로 제시하여라. 
+합칠 때는 한 평가기준에 대한 여러 평가문장 중 가장 상위의 점수를 받은 평가 문장을 골라야 한다: '또는'의 논리로 합쳐야 한다. '그리고'의 의미나 '평균'의 의미는 맞지 않는다. 
+출력문에는 절대 따옴표를 넣지 않아야 한다.
+
+<출력 양식>
+
+**종합 점수** : 1~10 / 10
+
+**종합 피드백**
+('종합 점수'가 산출된 근거)
+
+----요약 끝----
+
+"""