Upload 3 files

utils.py

@@ -0,0 +1,54 @@
+import os
+import re
+import pdb
+import logging
+import subprocess
+
+def format_time(seconds):
+    hours = seconds // 3600
+    minutes = (seconds // 60) % 60
+    seconds = seconds % 60
+    return f"{hours}:{minutes:02d}:{seconds:02d}"
+
+def extract_info_from_url(url):
+    if 'bilibili.com/video/' in url:
+        # 如果 URL 是 Bilibili 的视频链接，提取 BV 号
+        match = re.search(r'/video/(BV\w+)', url)
+        if match:
+            return match.group(1)
+        else:
+            return "BV ID not found!"
+    else:
+        # 如果 URL 是博客链接等，提取最后一段路径
+        match = re.search(r'/([^/]+)/?$', url)
+        if match:
+            return match.group(1)
+        else:
+            return "URL address is wired!"
+    
+def download_video(url, save_dir='./examples', size=768):
+    filename = extract_info_from_url(url)
+    save_path = f'{save_dir}/{filename}.mp4'
+    #cmd = f'yt-dlp -S ext:mp4:m4a --throttled-rate 5M -f "best[width<={size}][height<={size}]" --output {save_path} --merge-output-format mp4 https://www.youtube.com/embed/{url}'
+    # $ you-get -o ~/Videos -O zoo.webm 'https://www.youtube.com/watch?v=jNQXAC9IVRw'
+    cmd = f'you-get -o {save_dir} -O {filename} {url}'
+    if not os.path.exists(save_path):
+        try:
+            subprocess.call(cmd, shell=True)
+        except:
+            return None
+    return save_path
+
+def logger_creator(video_id):
+    # set up logger
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    handler = logging.FileHandler(f'./examples/{video_id}.log', mode='w')
+    handler.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+if __name__ == "__main__":
+    download_video('outcGtbnMuQ', save_dir='./examples', size=768)

vlog4chat.py

@@ -0,0 +1,327 @@
+import os
+import cv2
+import pdb
+import sys
+import time
+import numpy as np
+from PIL import Image
+from transformers import logging
+logging.set_verbosity_error()
+
+from models.kts_model import VideoSegmentor
+from models.clip_model import FeatureExtractor
+from models.blip2_model import ImageCaptioner
+from models.grit_model import DenseCaptioner
+from models.whisper_model import AudioTranslator
+from models.gpt_model import LlmReasoner
+from utils.utils import logger_creator, format_time
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM, LlamaForCausalLM, LlamaTokenizer, AutoModelForSeq2SeqLM
+
+import together
+import warnings
+from together import Together
+from langchain.prompts import PromptTemplate
+from langchain.llms.base import LLM
+from langchain.chains import ConversationalRetrievalChain
+from langchain_core.output_parsers import StrOutputParser
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.llms import HuggingFacePipeline
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain_community.document_loaders import TextLoader
+from langchain.document_loaders import UnstructuredFileLoader
+from langchain_community.vectorstores import FAISS
+from langchain.utils import get_from_dict_or_env
+from langchain_core.runnables import RunnablePassthrough, RunnableParallel
+from pydantic.v1 import Extra, Field, root_validator
+from typing import Any, Dict, List, Mapping, Optional
+from langchain.memory import ConversationBufferMemory
+from langchain import LLMChain, PromptTemplate
+from paddleocr import PaddleOCR, draw_ocr
+
+sys.path.append('/root/autodl-tmp/recognize-anything')
+
+from ram.models import ram
+from ram.models import tag2text
+from ram import inference_ram as inference
+#from ram import inference_tag2text as inference
+from ram import get_transform
+
+warnings.filterwarnings("ignore", category=UserWarning)
+B_INST, E_INST = "[INST]", "[/INST]"
+B_SYS, E_SYS = "<<SYS>>\n", "\n<</SYS>>\n\n"
+
+DEFAULT_SYSTEM_PROMPT = ""
+
+instruction = """You are an AI assistant designed for answering questions about a video.
+You are given a document and a question, the document records what people see and hear from this video.
+Try to connet these information and provide a conversational answer.
+Question: {question}
+=========
+{context}
+=========
+"""
+
+system_prompt = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question.
+You can assume the discussion is about the video content.
+Chat History:
+{chat_history}
+Follow Up Input: {question}
+Standalone question:"""
+
+os.environ['HF_HOME'] = '/root/autodl-tmp/cache/'
+os.environ["TOGETHER_API_KEY"] = "48bf2536f85b599c7d5d7f9921cc9ee7056f40ed535fd2174d061e1b9abcf8af"
+
+def get_prompt(instruction, new_system_prompt=DEFAULT_SYSTEM_PROMPT ):
+    SYSTEM_PROMPT = B_SYS + new_system_prompt + E_SYS
+    prompt_template =  B_INST + SYSTEM_PROMPT + instruction + E_INST
+    return prompt_template
+
+template = get_prompt(instruction, system_prompt)
+
+prompt = PromptTemplate(
+    input_variables=["chat_history", "user_input"], template=template
+)
+
+class TogetherLLM(LLM):
+    """Together large language models."""
+
+    model: str = "togethercomputer/llama-2-70b-chat"
+    """model endpoint to use"""
+
+    together_api_key: str = os.environ["TOGETHER_API_KEY"]
+    """Together API key"""
+
+    temperature: float = 0.7
+    """What sampling temperature to use."""
+
+    max_tokens: int = 512
+    """The maximum number of tokens to generate in the completion."""
+
+    class Config:
+        extra = Extra.forbid
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that the API key is set."""
+        api_key = get_from_dict_or_env(
+            values, "together_api_key", "TOGETHER_API_KEY"
+        )
+        values["together_api_key"] = api_key
+        return values
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of LLM."""
+        return "together"
+
+    def _call(
+        self,
+        prompt: str,
+        **kwargs: Any,
+    ) -> str:
+        """Call to Together endpoint."""
+        together.api_key = self.together_api_key
+        output = together.Complete.create(prompt,
+                                          model=self.model,
+                                          max_tokens=self.max_tokens,
+                                          temperature=self.temperature,
+                                          top_p=0.7,
+                                          top_k=50,
+                                          repetition_penalty=1,
+                                          stop=["</s>"],
+                                          )
+        text = output['choices'][0]['text']
+        return text
+
+class Vlogger4chat :
+    def __init__(self, args):
+        self.args = args
+        self.alpha = args.alpha
+        self.beta = args.beta
+        self.data_dir = args.data_dir,
+        self.tmp_dir = args.tmp_dir
+        self.models_flag = False
+        self.init_llm()
+        self.init_tag2txt()
+        self.history = []
+        if not os.path.exists(self.tmp_dir):
+            os.makedirs(self.tmp_dir)
+        
+    def init_models(self): 
+        print('\033[1;34m' + "Welcome to the our Vlog toolbox...".center(50, '-') + '\033[0m')
+        print('\033[1;33m' + "Initializing models...".center(50, '-') + '\033[0m')
+        print('\033[1;31m' + "This may time-consuming, please wait...".center(50, '-') + '\033[0m')
+        self.ocr = PaddleOCR(lang='ch')  # need to run only once to download and load model into memory
+        self.feature_extractor = FeatureExtractor(self.args)
+        self.video_segmenter = VideoSegmentor(alpha=self.alpha, beta=self.beta)
+        self.image_captioner = ImageCaptioner(model_name=self.args.captioner_base_model, device=self.args.image_captioner_device)
+        self.dense_captioner = DenseCaptioner(device=self.args.dense_captioner_device)
+        self.audio_translator = AudioTranslator(model=self.args.audio_translator, device=self.args.audio_translator_device)
+        print('\033[1;32m' + "Model initialization finished!".center(50, '-') + '\033[0m')
+        # 翻译文档
+        # 初始化 tokenizer 和 model
+        model_name = 'Helsinki-NLP/opus-mt-en-zh' #'Helsinki-NLP/opus-mt-zh-en'
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
+        self.my_embedding = HuggingFaceEmbeddings(model_name='BAAI/bge-m3', model_kwargs={'device': 'cuda'} ,encode_kwargs={'normalize_embeddings': True}) 
+    
+    def init_llm(self):
+        print('\033[1;33m' + "Initializing LLM Reasoner...".center(50, '-') + '\033[0m')
+        self.llm = TogetherLLM(
+            model= "microsoft/WizardLM-2-8x22B",
+            temperature=0.1,
+            max_tokens=768
+        )
+        print('\033[1;32m' + "LLM initialization finished!".center(50, '-') + '\033[0m')
+        
+        if not self.models_flag:
+            self.init_models()
+            self.models_flag = True
+            
+    def init_tag2txt(self):
+        self.transform = get_transform(image_size=384)
+
+        # delete some tags that may disturb captioning
+        # 127: "quarter"; 2961: "back", 3351: "two"; 3265: "three"; 3338: "four"; 3355: "five"; 3359: "one"
+        delete_tag_index = [127,2961, 3351, 3265, 3338, 3355, 3359]
+
+        #######load model
+        #self.tag2txt_model = tag2text(pretrained='/root/autodl-tmp/recognize-anything/pretrained/tag2text_swin_14m.pth',
+        #                              image_size=384, vit='swin_b', delete_tag_index=delete_tag_index)
+        self.ram_model = ram(pretrained='/root/autodl-tmp/recognize-anything/pretrained/ram_swin_large_14m.pth',
+                             image_size=384,
+                             vit='swin_l')
+        #self.tag2txt_model.threshold = 0.68  # threshold for tagging
+        #self.tag2txt_model.eval()
+        self.ram_model.eval()
+
+        #self.tag2txt_model = self.tag2txt_model.to(device=self.args.dense_captioner_device)
+        self.ram_model = self.ram_model.to(device=self.args.dense_captioner_device)
+        
+    def exist_videolog(self, video_id):
+        if isinstance(self.data_dir, tuple):
+            self.data_dir = self.data_dir[0]  # 或者根据实际情况选择合适的索引
+        if isinstance(video_id, tuple):
+            video_id = video_id[0]  # 或者根据实际情况选择合适的索引
+        log_path = os.path.join(self.data_dir, f"{video_id}.log")
+        #print(f"log_path: {log_path}\n")
+
+        if os.path.exists(log_path):
+            #print("existing log path!!!\n")
+            loader = UnstructuredFileLoader(log_path)
+            raw_documents = loader.load()
+            if not raw_documents:
+                print("The log file is empty or could not be loaded.")
+                return False # 如果 raw_documents 为空或所有内容都为空白，直接返回
+            # Split text
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+            chunks = text_splitter.split_documents(raw_documents)
+            self.vector_storage = FAISS.from_documents(chunks, self.my_embedding)    
+            self.chain = ConversationalRetrievalChain.from_llm(self.llm, self.vector_storage.as_retriever(), return_source_documents=True)
+            return True
+        return False
+    
+    def create_videolog(self, video_id):
+        video_id = os.path.basename(self.video_path).split('.')[0]
+        log_path = os.path.join(self.data_dir, video_id + '.log')
+        loader = UnstructuredFileLoader(log_path)
+        raw_documents = loader.load()
+        # Split text
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
+        chunks = text_splitter.split_documents(raw_documents)
+        self.vector_storage = FAISS.from_documents(chunks, self.my_embedding)
+        self.chain = ConversationalRetrievalChain.from_llm(self.llm, self.vector_storage.as_retriever(), return_source_documents=True)
+        
+    def video2log(self, video_path): 
+        self.video_path = video_path
+        video_id = os.path.basename(video_path).split('.')[0]  
+        
+        if self.exist_videolog(video_id):
+            return self.printlog(video_id)
+
+        if not self.models_flag:
+            self.init_models()
+            self.models_flag = True
+            
+        logger = logger_creator(video_id)
+        clip_features, video_length = self.feature_extractor(video_path, video_id)
+        seg_windows = self.video_segmenter(clip_features, video_length)
+        
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        audio_results = self.audio_translator(video_path)
+
+        for start_sec, end_sec in seg_windows:
+            middle_sec = (start_sec + end_sec) // 2
+            middle_frame_idx = int(middle_sec * fps)
+            cap.set(cv2.CAP_PROP_POS_FRAMES, middle_frame_idx)
+            ret, frame = cap.read()
+            
+            if ret:
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                image_caption = self.image_captioner.image_caption(frame)
+                dense_caption = self.dense_captioner.image_dense_caption(frame)
+                image = self.transform(Image.fromarray(frame)).unsqueeze(0).to(device=self.args.dense_captioner_device)
+                #tag2txt = inference(image, self.tag2txt_model, 'None')
+                ram = inference(image, self.ram_model)
+                audio_transcript = self.audio_translator.match(audio_results, start_sec, end_sec)
+                OCR_result = self.ocr.ocr(frame)
+                # 提取所有文本块中的所有行的文字
+                texts = []
+                for block in OCR_result:
+                    if block is not None:  # 检查 block 是否为 None
+                        for line in block:
+                            if line is not None:  # 检查 line 是否为 None
+                                text = line[1][0]  # 提取文字部分
+                                texts.append(text)
+                # 将列表中的所有文字合并成一个字符串
+                OCR_result_str = ' '.join(texts)
+                    
+                logger.info(f"When {format_time(start_sec)} - {format_time(end_sec)}")
+                chinese_image_caption = self.translate_text(image_caption, self.tokenizer, self.model)
+                #chinese_tag2txt = self.translate_text(tag2txt[2], self.tokenizer, self.model)
+                chinese_dense_caption = self.translate_text(dense_caption, self.tokenizer, self.model)
+                logger.info(f"我看到这些画面：\"{chinese_image_caption}\"")
+                #logger.info(f"我看见 {chinese_tag2txt}.")
+                logger.info(f"我发现这些内容：\"{chinese_dense_caption}\"")
+                logger.info(f"我检测到这些标签：\"{ram[1]}.\"")
+                logger.info(f"我识别到这些文字：\"{OCR_result_str}\"")
+                    
+                if len(audio_transcript) > 0:
+                    #english_audio_text = self.translate_text(audio_transcript, self.tokenizer, self.model)
+                    logger.info(f"我听到有人说：\"{audio_transcript}\"")
+                logger.info("\n")
+        
+        cap.release()
+        self.create_videolog(video_id)
+        return self.printlog(video_id)
+        
+    def printlog(self, video_id):
+        log_list = []
+        log_path = os.path.join(self.data_dir, video_id + '.log')
+        with open(log_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                log_list.append(line.strip())
+        return log_list
+    
+    def translate_text(self, text, tokenizer, model):
+        # 编码文本
+        encoded_text = tokenizer.prepare_seq2seq_batch([text], return_tensors='pt')
+
+        # 生成翻译
+        translated = model.generate(**encoded_text)
+
+        # 解码翻译后的文本
+        translated_text = tokenizer.batch_decode(translated, skip_special_tokens=True)[0]
+        return translated_text
+
+    def chat2video(self, question):
+        print(f"Question: {question}")
+        
+        response = self.chain({"question": "请用中文回答："+question, "chat_history": self.history})['answer']
+        self.history.append((question, response))
+        return response
+
+    def clean_history(self):
+        self.history = []
+        return

vlog4debate.py

@@ -0,0 +1,235 @@
+"""
+MAD: Multi-Agent Debate with Large Language Models
+Copyright (C) 2023  The MAD Team
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import os
+import json
+import random
+# random.seed(0)
+from Agent import Agent
+
+os.environ["TOGETHER_API_KEY"] = "48bf2536f85b599c7d5d7f9921cc9ee7056f40ed535fd2174d061e1b9abcf8af"
+
+NAME_LIST=[
+    "Affirmative side",
+    "Negative side",
+    "Moderator",
+]
+
+class DebatePlayer(Agent):
+    def __init__(self, model_name: str, name: str, temperature:float, openai_api_key: str, sleep_time: float) -> None:
+        """Create a player in the debate
+
+        Args:
+            model_name(str): model name
+            name (str): name of this player
+            temperature (float): higher values make the output more random, while lower values make it more focused and deterministic
+            openai_api_key (str): As the parameter name suggests
+            sleep_time (float): sleep because of rate limits
+        """
+        super(DebatePlayer, self).__init__(model_name, name, temperature, sleep_time)
+        self.openai_api_key = openai_api_key
+
+
+class Debate:
+    def __init__(self,
+            model_name: str='Qwen/Qwen1.5-72B-Chat', 
+            temperature: float=0, 
+            num_players: int=3, 
+            openai_api_key: str=os.environ["TOGETHER_API_KEY"],
+            config: dict=None,
+            max_round: int=3,
+            sleep_time: float=0
+        ) -> None:
+        """Create a debate
+
+        Args:
+            model_name (str): openai model name
+            temperature (float): higher values make the output more random, while lower values make it more focused and deterministic
+            num_players (int): num of players
+            openai_api_key (str): As the parameter name suggests
+            max_round (int): maximum Rounds of Debate
+            sleep_time (float): sleep because of rate limits
+        """
+
+        self.model_name = model_name
+        self.temperature = temperature
+        self.num_players = num_players
+        self.openai_api_key = openai_api_key
+        self.config = config
+        self.max_round = max_round
+        self.sleep_time = sleep_time
+        self.initial_debate = ''
+        self.init_prompt()
+
+        # creat&init agents
+        self.creat_agents()
+        self.init_agents()
+
+
+    def init_prompt(self):
+        def prompt_replace(key):
+            self.config[key] = self.config[key].replace("##debate_topic##", self.config["debate_topic"])
+        prompt_replace("player_meta_prompt")
+        prompt_replace("moderator_meta_prompt")
+        prompt_replace("affirmative_prompt")
+        prompt_replace("judge_prompt_last2")
+
+    def creat_agents(self):
+        # creates players
+        self.players = [
+            DebatePlayer(model_name=self.model_name, name=name, temperature=self.temperature, openai_api_key=self.openai_api_key, sleep_time=self.sleep_time) for name in NAME_LIST
+        ]
+        self.affirmative = self.players[0]
+        self.negative = self.players[1]
+        self.moderator = self.players[2]
+
+    def init_agents(self):
+        # start: set meta prompt
+        self.affirmative.set_meta_prompt(self.config['player_meta_prompt'])
+        self.negative.set_meta_prompt(self.config['player_meta_prompt'])
+        self.moderator.set_meta_prompt(self.config['moderator_meta_prompt'])
+        
+        # start: first round debate, state opinions
+        print(f"===== Start Debate Round =====\n")
+        self.affirmative.add_event(self.config['affirmative_prompt'])
+        self.aff_ans = self.affirmative.ask()
+        self.affirmative.add_memory(self.aff_ans)
+        self.config['base_answer'] = self.aff_ans
+        affirm_side = "\n\n正方观点：" + self.aff_ans
+        self.initial_debate += affirm_side
+
+        self.negative.add_event(self.config['negative_prompt'].replace('##aff_ans##', self.aff_ans))
+        self.neg_ans = self.negative.ask()
+        self.negative.add_memory(self.neg_ans)
+        neg_side = "\n\n反方观点：" + self.neg_ans
+        self.initial_debate += neg_side
+
+        self.moderator.add_event(self.config['moderator_prompt'].replace('##aff_ans##', self.aff_ans).replace('##neg_ans##', self.neg_ans).replace('##round##', 'first'))
+        self.mod_ans = self.moderator.ask()
+        self.moderator.add_memory(self.mod_ans)
+        self.mod_ans = eval(self.mod_ans)
+
+    def round_dct(self, num: int):
+        dct = {
+            1: 'first', 2: 'second', 3: 'third', 4: 'fourth', 5: 'fifth', 6: 'sixth', 7: 'seventh', 8: 'eighth', 9: 'ninth', 10: 'tenth'
+        }
+        return dct[num]
+
+    def print_answer(self):
+        print("\n\n===== Debate Done! =====")
+        print("\n----- Debate Topic -----")
+        print(self.config["debate_topic"])
+        print("\n----- Base Answer -----")
+        print(self.config["base_answer"])
+        print("\n----- Debate Answer -----")
+        print(self.config["debate_answer"])
+        print("\n----- Debate Reason -----")
+        print(self.config["Reason"])
+
+    def broadcast(self, msg: str):
+        """Broadcast a message to all players. 
+        Typical use is for the host to announce public information
+
+        Args:
+            msg (str): the message
+        """
+        # print(msg)
+        for player in self.players:
+            player.add_event(msg)
+
+    def speak(self, speaker: str, msg: str):
+        """The speaker broadcast a message to all other players. 
+
+        Args:
+            speaker (str): name of the speaker
+            msg (str): the message
+        """
+        if not msg.startswith(f"{speaker}: "):
+            msg = f"{speaker}: {msg}"
+        # print(msg)
+        for player in self.players:
+            if player.name != speaker:
+                player.add_event(msg)
+
+    def ask_and_speak(self, player: DebatePlayer):
+        ans = player.ask()
+        player.add_memory(ans)
+        self.speak(player.name, ans)
+
+
+    def run(self):
+        for round in range(self.max_round - 1):
+
+            if self.mod_ans["debate_answer"] != '':
+                break
+            else:
+                print(f"===== Debate Round-{round+1} =====\n")
+                self.affirmative.add_event(self.config['debate_prompt'].replace('##oppo_ans##', self.neg_ans))
+                self.aff_ans = self.affirmative.ask()
+                self.affirmative.add_memory(self.aff_ans)
+
+                self.negative.add_event(self.config['debate_prompt'].replace('##oppo_ans##', self.aff_ans))
+                self.neg_ans = self.negative.ask()
+                self.negative.add_memory(self.neg_ans)
+
+                self.moderator.add_event(self.config['moderator_prompt'].replace('##aff_ans##', self.aff_ans).replace('##neg_ans##', self.neg_ans).replace('##round##', self.round_dct(round+2)))
+                self.mod_ans = self.moderator.ask()
+                self.moderator.add_memory(self.mod_ans)
+                self.mod_ans = eval(self.mod_ans)
+
+        if self.mod_ans["debate_answer"] != '':
+            self.config.update(self.mod_ans)
+            self.config['success'] = True
+
+        # ultimate deadly technique.
+        else:
+            judge_player = DebatePlayer(model_name=self.model_name, name='Judge', temperature=self.temperature, openai_api_key=self.openai_api_key, sleep_time=self.sleep_time)
+            aff_ans = self.affirmative.memory_lst[2]['content']
+            neg_ans = self.negative.memory_lst[2]['content']
+
+            judge_player.set_meta_prompt(self.config['moderator_meta_prompt'])
+
+            # extract answer candidates
+            judge_player.add_event(self.config['judge_prompt_last1'].replace('##aff_ans##', aff_ans).replace('##neg_ans##', neg_ans))
+            ans = judge_player.ask()
+            judge_player.add_memory(ans)
+
+            # select one from the candidates
+            judge_player.add_event(self.config['judge_prompt_last2'])
+            ans = judge_player.ask()
+            judge_player.add_memory(ans)
+            
+            ans = eval(ans)
+            if ans["debate_answer"] != '':
+                self.config['success'] = True
+                # save file
+            self.config.update(ans)
+            self.players.append(judge_player)
+
+        self.print_answer()
+        combined_string = ''.join([
+            self.config["debate_topic"],
+            self.initial_debate,
+            f"\n\n经过{self.max_round}轮辩论......",
+            "\n\n仲裁观点：",
+            self.config["debate_answer"],
+            "\n\n仲裁理由：",
+            self.config["Reason"]
+        ])
+
+        return combined_string