Teil des Aufbaus leistungsstarker Ketten und Agenten in LangChain

Aufbau leistungsstarker Ketten und Agenten in LangChain

In diesem umfassenden Leitfaden tauchen wir tief in die Welt von LangChain ein und konzentrieren uns auf den Aufbau leistungsstarker Ketten und Agenten. Wir werden alles abdecken, vom Verständnis der Grundlagen von Ketten über deren Kombination mit großen Sprachmodellen (LLMs) bis hin zur Einführung anspruchsvoller Agenten für autonome Entscheidungsfindung.

1. Ketten verstehen

1.1 Was sind Ketten in LangChain?

Ketten in LangChain sind Abfolgen von Vorgängen oder Aufgaben, die Daten in einer bestimmten Reihenfolge verarbeiten. Sie ermöglichen modulare und wiederverwendbare Arbeitsabläufe und erleichtern so die Bewältigung komplexer Datenverarbeitungs- und Sprachaufgaben. Ketten sind die Bausteine ​​für die Erstellung anspruchsvoller KI-gesteuerter Systeme.

1.2 Arten von Ketten

LangChain bietet verschiedene Arten von Ketten an, die jeweils für unterschiedliche Szenarien geeignet sind:

1. Sequentielle Ketten: Diese Ketten verarbeiten Daten in einer linearen Reihenfolge, wobei die Ausgabe eines Schritts als Eingabe für den nächsten dient. Sie eignen sich ideal für unkomplizierte, schrittweise Prozesse.

2. Ketten zuordnen/reduzieren: Bei diesen Ketten wird eine Funktion über einen Datensatz abgebildet und die Ergebnisse dann auf eine einzelne Ausgabe reduziert. Sie eignen sich hervorragend für die parallele Verarbeitung großer Datenmengen.

3. Routerketten: Diese Ketten leiten Eingaben basierend auf bestimmten Bedingungen an verschiedene Unterketten weiter und ermöglichen so komplexere, verzweigte Arbeitsabläufe.

1.3 Benutzerdefinierte Ketten erstellen

Beim Erstellen benutzerdefinierter Ketten müssen bestimmte Vorgänge oder Funktionen definiert werden, die Teil der Kette sein werden. Hier ist ein Beispiel einer benutzerdefinierten sequentiellen Kette:

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)

In diesem Beispiel wird eine benutzerdefinierte Kette erstellt, die zunächst einen Eingabetext zusammenfasst und ihn dann ins Französische übersetzt.

2. Kombination von Ketten und LLMs

2.1 Integration von Ketten mit Eingabeaufforderungen und LLMs

Ketten können nahtlos in Eingabeaufforderungen und LLMs integriert werden, um leistungsfähigere und flexiblere Systeme zu schaffen. Hier ist ein Beispiel:

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)

In diesem Beispiel wird eine Kette erstellt, die ein zufälliges wissenschaftliches Thema generiert und dann einen Absatz darüber schreibt.

2.2 Debuggen und Optimieren von Chain-LLM-Interaktionen

Um Chain-LLM-Interaktionen zu debuggen und zu optimieren, können Sie den ausführlichen Parameter und benutzerdefinierte Rückrufe verwenden:

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)

In diesem Beispiel wird ein benutzerdefinierter Callback-Handler verwendet, um detaillierte Informationen über die Eingabe und Ausgabe des LLM bereitzustellen.

3. Vorstellung von Agenten

3.1 Was sind Agenten in LangChain?

Agenten in LangChain sind autonome Einheiten, die Tools nutzen und Entscheidungen treffen können, um Aufgaben zu erledigen. Sie kombinieren LLMs mit externen Tools, um komplexe Probleme zu lösen und so dynamischere und anpassungsfähigere KI-Systeme zu ermöglichen.

3.2 Eingebaute Agenten und ihre Fähigkeiten

LangChain bietet mehrere integrierte Agenten, wie zum Beispiel den Zero-Shot-React-Description-Agenten:

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)

In diesem Beispiel wird ein Agent erstellt, der Wikipedia verwenden und mathematische Berechnungen durchführen kann, um komplexe Fragen zu beantworten.

3.3 Erstellen benutzerdefinierter Agenten

Sie können benutzerdefinierte Agenten erstellen, indem Sie Ihre eigenen Tools und Agentenklassen definieren. Dies ermöglicht hochspezialisierte Agenten, die auf bestimmte Aufgaben oder Domänen zugeschnitten sind.

Hier ist ein Beispiel für einen benutzerdefinierten Agenten:

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)

Abschluss

Die Ketten und Agenten von LangChain bieten robuste Funktionen für den Aufbau anspruchsvoller KI-gesteuerter Systeme. Wenn sie in große Sprachmodelle (LLMs) integriert werden, ermöglichen sie die Erstellung anpassungsfähiger, intelligenter Anwendungen, die für die Bewältigung einer Vielzahl von Aufgaben konzipiert sind. Im weiteren Verlauf Ihrer LangChain-Reise können Sie gerne mit verschiedenen Kettentypen, Agent-Setups und benutzerdefinierten Modulen experimentieren, um das Potenzial des Frameworks voll auszuschöpfen.

Das obige ist der detaillierte Inhalt vonTeil des Aufbaus leistungsstarker Ketten und Agenten in LangChain. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!