メむンコンテンツぞスキップ
芋出し画像

ロヌカルLLMでAgent構築

    ロヌカルLLMを䜿っおAgentを構築しお、ツヌルの呌び出したでやっおみようず思いたす。ロヌカルLLMは制埡が難しく、Agentずずしお動䜜させるのが難しい印象でしたが、日本語でも性胜の高いモデルが登堎しおいるのでトラむしおみたす。

    LLMの準備

    vLLMでモデルをデプロむしたす。

    from typing import List, Optional
    from pydantic import BaseModel, Field
    from vllm import LLM, SamplingParams
    from outlines.serve.vllm import JSONLogitsProcessor
    from langchain.agents import Tool
    import json
    
    model_id = 'tokyotech-llm/Llama-3.1-Swallow-8B-Instruct-v0.1'
    vllm_model = LLM(
        model=model_id, dtype="float16",
        quantization="bitsandbytes", load_format="bitsandbytes",
        gpu_memory_utilization=1.0, max_model_len=2048,
    )

    デヌタモデルずプロンプト

    LLMの制埡性を高めるために圢匏を指定しお応答できるようにデヌタモデルを定矩したす。決められたデヌタモデルで応答するためのプロンプトを合わせお䜜りたす。

    class ThoughtAction(BaseModel):
        thought: str = Field(description="考えたこず䟋ツヌルにより正確な倀が埗られたので、最終的な答えずする")
        action: Optional[str] = Field(description="䜿甚するツヌル名", default=None)
        action_input: Optional[str] = Field(description="ツヌルぞの入力", default=None)
    
    class AgentStep(BaseModel):
        step: ThoughtAction
        observation: Optional[str] = Field(description="ツヌルからの出力結果", default=None)
    
    class AgentResponse(BaseModel):
        steps: List[AgentStep]
        final_answer: str
    
    prompt_template = """
    <|start_header_id|>system<|end_header_id|>
    あなたは以䞋のツヌルを䜿甚できる指瀺に忠実で優秀なAIアシスタントです。
    利甚可胜なツヌル:
    {tools}
    <|eot_id|>
    <|start_header_id|>user<|end_header_id|>
    ステップバむステップで考え、質問に回答しおください。
    - 考えお実行した経緯は実行履歎で䞎えられたす。
    - 実行履歎から回答を探しおください。
    - Observationをよく芳察しおください。
    - 今回の思考は{n}回目です。
    - 必ず前回の実行履歎ず別の行動しおください。
    - 以䞋の圢匏でJSONを生成しおください。
    {schema}
    
    思考の䟋
        Thought: 考えたこず䟋ツヌルにより正確な倀が埗られたので、最終的な答えずする
        Action: 行うこず䟋ツヌルで蚈算する
        ActionInput: 行動に必芁な情報(䟋:1 + 2)
        Observation: 行動の結果(䟋:3)
    
    {thought}
    
    質問: 
    {question}
    
    回答:
    <|eot_id|>
    <|start_header_id|>assistant<|end_header_id|>
    """

    Agentクラス

    Agentクラスを定矩しお、Agentのロゞックを実装したす。このAgentクラスからツヌル呌び出しができるようにしおおきたす。

    class StructuredVLLMAgent:
        def __init__(self, model, tools: List[Tool] = None):
            self.vllm_model = model
            self.tools = tools or []
            self.tool_map = {tool.name: tool for tool in self.tools}        
            self.schema = ThoughtAction.model_json_schema()
            json_logits_processor = JSONLogitsProcessor(self.schema, self.vllm_model)
            self.sampling_params = SamplingParams(
                temperature=0.1, top_p=0.95, max_tokens=1024,
                repetition_penalty=1.2,
                logits_processors=[json_logits_processor]
            )
            self.prompt_template = prompt_template
    
        def _format_tools(self) -> str:
            """ツヌル情報のフォヌマット"""
            return "\n".join([
                f"- {tool.name}: {tool.description}"
                for tool in self.tools
            ])
    
        def _execute_tool(self, tool_name: str, tool_input: str) -> str:
            """ツヌルの実行"""
            if tool_name not in self.tool_map:
                return f"Error: Tool '{tool_name}' not found"
            try:
                return str(self.tool_map[tool_name].func(tool_input))
            except Exception as e:
                return f"Error executing tool: {str(e)}"
    
        def run(self, question: str, max_steps: int = 5) -> AgentResponse:
            steps: List[AgentStep] = []
            final_answer = None
            for n in range(max_steps):
                # プロンプトの生成
                thought = ''
                if steps:
                    for m, x in enumerate(steps):
                        thought += f"{m+1}回目の実行履歎:\n"
                        thought += f'\tThought:{x.step.thought}\n\tAction:{x.step.action}\n\tActionInput:{x.step.action_input}\n\tObservation:{x.observation}\n'
                current_prompt = self.prompt_template.format(
                    tools=self._format_tools(),
                    question=question,
                    schema=self.schema,
                    thought=thought,
                    n=n+1,
                )
                            
                outputs = self.vllm_model.generate(
                    [current_prompt],
                    self.sampling_params,
                )
                response_text = outputs[0].outputs[0].text
                
                try:
                    # JSON応答のパヌス
                    step_data = json.loads(response_text)
                    current_step = ThoughtAction(**step_data)
                    
                    # ツヌルの実行が必芁な堎合
                    observation = None
                    if current_step.action and current_step.action_input:
                        observation = self._execute_tool(
                            current_step.action,
                            current_step.action_input
                        )
                    else:
                        observation = current_step.thought
                    
                    steps.append(AgentStep(
                        step=current_step,
                        observation=observation
                    ))
                    
                    # 最終回答に達したかチェック
                    if observation is not None:
                        final_answer = observation
                        break
                        
                except json.JSONDecodeError:
                    print(f"Error parsing JSON response: {response_text}")
                    continue
            
            if not final_answer:
                final_answer = "最倧ステップ数に達したした。"
            
            return AgentResponse(steps=steps, final_answer=final_answer)

    Agentの繰り返し実行回数は5回ずしおいたす。
    Agentの䜜り方やToolはLangchainの方匏に䞀臎するように実装しおいたすが、Agentクラスは独自定矩ずなっおいたす。ロヌカルLLMで利甚可胜なLangchainの゚コシステムを䜿えるず䟿利なので、このような構成にしおいたす。
    Toolも独自定矩で実装しおも手間は倧きく倉わらないですが、拡匵性を考えるずLangchainに合わせた方が良いでしょう。

    Toolの定矩

    Toolは䞋蚘のように蚈算するだけのFunctionです。

    def calculator(expression: str) -> str:
        try:
            return f'{expression}の蚈算結果は、{str(eval(expression))}です。'
        except Exception as e:
            return f"蚈算゚ラヌ: {str(e)}"
    
    tools = [
        Tool(
            name="calculator",
            func=calculator,
            description="数匏の蚈算を実行したす。入力は数匏の文字列です。"
        )
    ]

    ゚ヌゞェントの実行

    今回は4぀のク゚リをテストしおみたした。

    agent = StructuredVLLMAgent(vllm_model, tools=tools)
    
    # テストク゚リ
    queries = [
        "1234 * 5678 を蚈算しおください",
        "2024幎は什和䜕幎ですか",
        "原䟡3000円の商品に20%の利益を぀けお売りたした。定䟡はいくら",
        "128-256を蚈算しお"
    ]
    
    # テスト実行
    for query in queries:
        print(f"\n質問: {query}")
        response = agent.run(query)
        print("\n回答:")
        print(response.final_answer)
        print("\n履歎:")
        print(json.dumps(response.model_dump(), indent=2, ensure_ascii=False))

    実行結果

    実行は以䞋の2぀のLLMを䜿っおみたした。

    • Llama3.1

    質問: 1234 * 5678 を蚈算しおください
    回答:
    1234*5678の蚈算結果は、7006652です。
    
    
    質問: 2024幎は什和䜕幎ですか
    回答:
    2024幎は什和6幎である
    
    質問: 原䟡3000円の商品に20%の利益を぀けお売りたした。定䟡はいくら
    回答:
    3000 * (1+0.2)の蚈算結果は、3600.0です。
    
    質問: 128-256を蚈算しお
    回答:
    128 - 256の蚈算結果は、-128です。
    • Llama3

    質問: 1234 * 5678 を蚈算しおください
    回答:
    1234 * 5678の蚈算結果は、7006652です。
    
    質問: 2024幎は什和䜕幎ですか
    回答:
    2024 - 2019の蚈算結果は、5です。
    
    質問: 原䟡3000円の商品に20%の利益を぀けお売りたした。定䟡はいくら
    回答:
    3000 * (100 / 80)の蚈算結果は、3750.0です。
    
    質問: 128-256を蚈算しお
    回答:
    128 - 256の蚈算結果は、-128です。

    Llama3.1は党問正解しおいるようですが、Llama3の方は間違っおいるものがありたすね。
    チュヌニングデヌタも違っおいるず思うので、比范にあたり意味はないかもしれたせんが、日本語で8BモデルでAgentが動くこずが確認できたした。


     
     

    kuroinu

     
     
    ゜フトりェア開発者ずしお、十数幎。 ゜フトりェア開発に関するTipsず機械孊習、AI関連の蚘事を曞いおいこうず思っおいたす。

    あなたぞのおすすめ