LangChain での強力なチェーンとエージェントの構築の一部

LangChain で強力なチェーンとエージェントを構築する

この包括的なガイドでは、強力なチェーンとエージェントの構築に焦点を当てて、LangChain の世界を深く掘り下げていきます。チェーンの基本の理解から、チェーンを大規模言語モデル (LLM) と組み合わせ、自律的な意思決定のための高度なエージェントの導入まで、すべてをカバーします。

1. チェーンを理解する

1.1 LangChain のチェーンとは何ですか?

LangChain のチェーンは、特定の順序でデータを処理する一連の操作またはタスクです。モジュール式で再利用可能なワークフローが可能になり、複雑なデータ処理や言語タスクの処理が容易になります。チェーンは、高度な AI 駆動システムを作成するための構成要素です。

1.2 チェーンの種類

LangChain は、さまざまなシナリオに適したいくつかのタイプのチェーンを提供します。

1. シーケンシャル チェーン: これらのチェーンはデータを線形順序で処理し、1 つのステップの出力が次のステップの入力として機能します。これらは、簡単な段階的なプロセスに最適です。

2. マップ/リデュース チェーン: これらのチェーンには、一連のデータに関数をマッピングし、結果を 1 つの出力に削減することが含まれます。これらは大規模なデータセットの並列処理に最適です。

3. ルーター チェーン: これらのチェーンは、特定の条件に基づいて入力をさまざまなサブチェーンに送り、より複雑な分岐ワークフローを可能にします。

1.3 カスタムチェーンの作成

カスタム チェーンの作成には、チェーンの一部となる特定の操作または関数の定義が含まれます。カスタムのシーケンシャル チェーンの例を次に示します:

from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

class CustomChain:
    def __init__(self, llm):
        self.llm = llm
        self.steps = []

    def add_step(self, prompt_template):
        prompt = PromptTemplate(template=prompt_template, input_variables=["input"])
        chain = LLMChain(llm=self.llm, prompt=prompt)
        self.steps.append(chain)

    def execute(self, input_text):
        for step in self.steps:
            input_text = step.run(input_text)
        return input_text

# Initialize the chain
llm = OpenAI(temperature=0.7)
chain = CustomChain(llm)

# Add steps to the chain
chain.add_step("Summarize the following text in one sentence: {input}")
chain.add_step("Translate the following English text to French: {input}")

# Execute the chain
result = chain.execute("LangChain is a powerful framework for building AI applications.")
print(result)

この例では、最初に入力テキストを要約してからフランス語に翻訳するカスタム チェーンを作成します。

2. チェーンと LLM の結合

2.1 チェーンとプロンプトおよび LLM の統合

チェーンはプロンプトや LLM とシームレスに統合して、より強力で柔軟なシステムを作成できます。以下に例を示します:

from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI
from langchain.chains import SimpleSequentialChain

llm = OpenAI(temperature=0.7)

# First chain: Generate a topic
first_prompt = PromptTemplate(
    input_variables=["subject"],
    template="Generate a random {subject} topic:"
)
first_chain = LLMChain(llm=llm, prompt=first_prompt)

# Second chain: Write a paragraph about the topic
second_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write a short paragraph about {topic}:"
)
second_chain = LLMChain(llm=llm, prompt=second_prompt)

# Combine the chains
overall_chain = SimpleSequentialChain(chains=[first_chain, second_chain], verbose=True)

# Run the chain
result = overall_chain.run("science")
print(result)

この例では、ランダムな科学トピックを生成し、それに関する段落を記述するチェーンを作成します。

2.2 チェーンと LLM の相互作用のデバッグと最適化

チェーン LLM インタラクションをデバッグおよび最適化するには、verbose パラメーターとカスタム コールバックを使用できます。

from langchain.callbacks import StdOutCallbackHandler
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

class CustomHandler(StdOutCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with prompt: {prompts[0]}")

    def on_llm_end(self, response, **kwargs):
        print(f"LLM finished with response: {response.generations[0][0].text}")

llm = OpenAI(temperature=0.7, callbacks=[CustomHandler()])
template = "Tell me a {adjective} joke about {subject}."
prompt = PromptTemplate(input_variables=["adjective", "subject"], template=template)
chain = LLMChain(llm=llm, prompt=prompt, verbose=True)

result = chain.run(adjective="funny", subject="programming")
print(result)

この例では、カスタム コールバック ハンドラーを使用して、LLM の入力と出力に関する詳細情報を提供します。

3. エージェントの紹介

3.1 LangChain のエージェントとは何ですか?

LangChain のエージェントは、ツールを使用し、タスクを達成するための意思決定を行うことができる自律的なエンティティです。 LLM と外部ツールを組み合わせて複雑な問題を解決し、より動的で適応性のある AI システムを可能にします。

3.2 組み込みエージェントとその機能

LangChain は、zero-shot-react-description エージェントなど、いくつかの組み込みエージェントを提供します。

from langchain.agents import load_tools, initialize_agent, AgentType
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
tools = load_tools(["wikipedia", "llm-math"], llm=llm)

agent = initialize_agent(
    tools, 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

result = agent.run("What is the square root of the year Plato was born?")
print(result)

この例では、Wikipedia を使用し、複雑な質問に答えるために数学的計算を実行できるエージェントを作成します。

3.3 カスタムエージェントの作成

独自のツールとエージェント クラスを定義することで、カスタム エージェントを作成できます。これにより、特定のタスクやドメインに合わせてカスタマイズされた高度に専門化されたエージェントが可能になります。

カスタム エージェントの例を次に示します:

from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from typing import List, Union
from langchain.schema import AgentAction, AgentFinish
import re

# Define custom tools
search = SerpAPIWrapper()
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="Useful for answering questions about current events"
    )
]

# Define a custom prompt template
template = """Answer the following questions as best you can:

{input}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: To answer this question, I need to search for current information.
{agent_scratchpad}"""

class CustomPromptTemplate(StringPromptTemplate):
    template: str
    tools: List[Tool]

    def format(self, **kwargs) -> str:
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        kwargs["agent_scratchpad"] = thoughts
        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
        return self.template.format(**kwargs)

prompt = CustomPromptTemplate(
    template=template,
    tools=tools,
    input_variables=["input", "intermediate_steps"]
)

# Define a custom output parser
class CustomOutputParser:
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        if "Final Answer:" in llm_output:
            return AgentFinish(
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )

        action_match = re.search(r"Action: (\w+)", llm_output, re.DOTALL)
        action_input_match = re.search(r"Action Input: (.*)", llm_output, re.DOTALL)

        if not action_match or not action_input_match:
            raise ValueError(f"Could not parse LLM output: `{llm_output}`")

        action = action_match.group(1).strip()
        action_input = action_input_match.group(1).strip(" ").strip('"')

        return AgentAction(tool=action, tool_input=action_input, log=llm_output)

# Create the custom output parser
output_parser = CustomOutputParser()

# Define the LLM chain
llm = OpenAI(temperature=0)
llm_chain = LLMChain(llm=llm, prompt=prompt)

# Define the custom agent
agent = LLMSingleActionAgent(
    llm_chain=llm_chain,
    output_parser=output_parser,
    stop=["\nObservation:"],
    allowed_tools=[tool.name for tool in tools]
)

# Create an agent executor
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, , verbose=True)
# Run the agent
result = agent_executor.run(“What’s the latest news about AI?”)

print(result)

結論

LangChain のチェーンとエージェントは、高度な AI 駆動システムを構築するための堅牢な機能を提供します。大規模言語モデル (LLM) と統合すると、さまざまなタスクに取り組むように設計された、適応性のあるスマートなアプリケーションの作成が可能になります。 LangChain の取り組みを進めていく中で、さまざまなチェーン タイプ、エージェントのセットアップ、カスタム モジュールを自由に試して、フレームワークの可能性を最大限に活用してください。

以上がLangChain での強力なチェーンとエージェントの構築の一部の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。