Sebahagian Membina Rantaian dan Ejen Berkuasa di LangChain

Membina Rantaian dan Ejen yang Berkuasa di LangChain

Dalam panduan komprehensif ini, kami akan menyelami dunia LangChain, memfokuskan pada membina rantaian dan ejen yang berkuasa. Kami akan merangkumi segala-galanya daripada memahami asas rantai hingga menggabungkannya dengan model bahasa besar (LLM) dan memperkenalkan ejen canggih untuk membuat keputusan autonomi.

1. Memahami Rantai

1.1 Apakah Rantaian dalam LangChain?

Rantai dalam LangChain ialah urutan operasi atau tugasan yang memproses data dalam susunan tertentu. Mereka membenarkan aliran kerja modular dan boleh guna semula, menjadikannya lebih mudah untuk mengendalikan pemprosesan data dan tugas bahasa yang kompleks. Rantaian ialah bahan binaan untuk mencipta sistem dipacu AI yang canggih.

1.2 Jenis Rantai

LangChain menawarkan beberapa jenis rantai, setiap satu sesuai untuk senario yang berbeza:

1. Rantai Berjujukan: Rantaian ini memproses data dalam susunan linear, di mana output satu langkah berfungsi sebagai input untuk langkah seterusnya. Ia sesuai untuk proses langkah demi langkah yang mudah.

2. Peta/Kurangkan Rantaian: Rantaian ini melibatkan pemetaan fungsi ke atas set data dan kemudian mengurangkan keputusan kepada satu output. Ia bagus untuk pemprosesan selari bagi set data yang besar.

3. Rantai Penghala: Rantaian ini mengarahkan input ke sub-rantai yang berbeza berdasarkan syarat tertentu, membolehkan aliran kerja bercabang yang lebih kompleks.

1.3 Mencipta Rantaian Tersuai

Mencipta rantai tersuai melibatkan penentuan operasi atau fungsi tertentu yang akan menjadi sebahagian daripada rantai. Berikut ialah contoh rantai jujukan tersuai:

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)

Contoh ini mencipta rantaian tersuai yang mula-mula meringkaskan teks input dan kemudian menterjemahkannya ke bahasa Perancis.

2. Menggabungkan Rantaian dan LLM

2.1 Mengintegrasikan Rantaian dengan Gesaan dan LLM

Rantai boleh disepadukan dengan lancar dengan gesaan dan LLM untuk mencipta sistem yang lebih berkuasa dan fleksibel. Berikut ialah contoh:

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)

Contoh ini mencipta rantaian yang menjana topik sains rawak dan kemudian menulis perenggan mengenainya.

2.2 Nyahpepijat dan Mengoptimumkan Interaksi Rantaian-LLM

Untuk nyahpepijat dan mengoptimumkan interaksi rantai-LLM, anda boleh menggunakan parameter verbose dan panggil balik tersuai:

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)

Contoh ini menggunakan pengendali panggil balik tersuai untuk memberikan maklumat terperinci tentang input dan output LLM.

3. Memperkenalkan Ejen

3.1 Apakah itu Ejen dalam LangChain?

Agen dalam LangChain ialah entiti autonomi yang boleh menggunakan alatan dan membuat keputusan untuk menyelesaikan tugas. Mereka menggabungkan LLM dengan alat luaran untuk menyelesaikan masalah yang kompleks, membolehkan sistem AI yang lebih dinamik dan boleh disesuaikan.

3.2 Ejen Terbina dalam dan Keupayaan Mereka

LangChain menyediakan beberapa ejen terbina dalam, seperti ejen 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)

Contoh ini mencipta ejen yang boleh menggunakan Wikipedia dan melakukan pengiraan matematik untuk menjawab soalan yang rumit.

3.3 Mewujudkan Ejen Tersuai

Anda boleh mencipta ejen tersuai dengan menentukan alatan dan kelas ejen anda sendiri. Ini membolehkan ejen yang sangat khusus disesuaikan dengan tugas atau domain tertentu.

Berikut ialah contoh ejen tersuai:

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)

Kesimpulan

Rantaian dan ejen LangChain menawarkan keupayaan teguh untuk membina sistem dipacu AI yang canggih. Apabila disepadukan dengan model bahasa besar (LLM), ia membolehkan penciptaan aplikasi pintar yang boleh disesuaikan dan direka untuk menangani pelbagai tugas. Sambil anda meneruskan perjalanan LangChain anda, jangan ragu untuk bereksperimen dengan pelbagai jenis rangkaian, persediaan ejen dan modul tersuai untuk memanfaatkan sepenuhnya potensi rangka kerja.

Atas ialah kandungan terperinci Sebahagian Membina Rantaian dan Ejen Berkuasa di LangChain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!