Fejlessze az Amazon Lex-et LLM-ekkel, és javítsa a GYIK-élményt az URL-feldolgozás segítségével | Amazon webszolgáltatások

A mai digitális világban a legtöbb fogyasztó szívesebben választ magának ügyfélszolgálati kérdéseire, ahelyett, hogy időt szánna a vállalkozások és/vagy szolgáltatók megkeresésére. Ez a blogbejegyzés egy innovatív megoldást mutat be egy kérdés-válasz chatbot felépítésére Amazon Lex amely a webhelyén található GYIK-et használja. Ez a mesterséges intelligencia alapú eszköz gyors, pontos válaszokat tud adni valós kérdésekre, lehetővé téve az ügyfelek számára, hogy gyorsan és egyszerűen önállóan oldják meg a gyakori problémákat.

Egyetlen URL feldolgozás

Sok vállalat honlapján közzétett válaszkészlet található az ügyfelei számára feltett GYIK-re. Ebben az esetben szeretnénk kínálni az ügyfeleknek egy chatbotot, amely válaszolni tud a kérdéseikre a közzétett GYIK-ből. című blogbejegyzésben Bővítse az Amazon Lexet társalgási GYIK funkcióival az LLM-ek segítségével, bemutattuk, hogyan használhatja az Amazon Lex és a LlamaIndex kombinációját a meglévő tudásforrásaiból, például PDF- vagy Word-dokumentumaiból működő chatbot létrehozásához. A GYIK-t tartalmazó webhelyen alapuló egyszerű GYIK támogatásához létre kell hoznunk egy feldolgozási folyamatot, amely képes feltérképezni a webhelyet, és olyan beágyazásokat hozhat létre, amelyeket a LlamaIndex használhat az ügyfelek kérdéseinek megválaszolására. Ebben az esetben a -ban létrehozott botra fogunk építeni előző blogbejegyzés, amely lekérdezi azokat a beágyazásokat a felhasználó megnyilatkozásával, és visszaadja a választ a webhely GYIK-ből.

A következő diagram bemutatja, hogyan működik együtt a feldolgozási folyamat és az Amazon Lex bot a megoldásunkban.

A megoldási munkafolyamat során a GYIK-et tartalmazó webhely a következőn keresztül valósul meg AWS Lambda. Ez a Lambda funkció feltérképezi a webhelyet, és a kapott szöveget egy Amazon egyszerű tárolási szolgáltatás (Amazon S3) vödör. Az S3 vödör ezután elindít egy Lambda funkciót, amely a LlamaIndex segítségével hozza létre az Amazon S3-ban tárolt beágyazásokat. Amikor egy végfelhasználótól kérdés érkezik, például „Mi a visszaküldési szabályzata?”, az Amazon Lex bot a Lambda funkcióját használja a beágyazások lekérdezésére a LlamaIndex RAG-alapú megközelítésével. Erről a megközelítésről és az előfeltételekről további információt a blogbejegyzésben talál, Bővítse az Amazon Lexet társalgási GYIK funkcióival az LLM-ek segítségével.

Miután a fent említett blog előfeltételei elkészültek, az első lépés az, hogy a GYIK-et be kell tölteni egy dokumentumtárba, amelyet a LlamaIndex vektorizálhat és indexelhet. A következő kód megmutatja, hogyan kell ezt elérni:

import logging
import sys
import requests
import html2text
from llama_index.readers.schema.base import Document
from llama_index import GPTVectorStoreIndex
from typing import List logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) class EZWebLoader: def __init__(self, default_header: str = None): self._html_to_text_parser = html2text() if default_header is None: self._default_header = {"User-agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.80 Safari/537.36"} else: self._default_header = default_header def load_data(self, urls: List[str], headers: str = None) -> List[Document]: if headers is None: headers = self._default_header documents = [] for url in urls: response = requests.get(url, headers=headers).text response = self._html2text.html2text(response) documents.append(Document(response)) return documents url = "http://www.zappos.com/general-questions"
loader = EZWebLoader()
documents = loader.load_data([url])
index = GPTVectorStoreIndex.from_documents(documents)

Az előző példában egy előre meghatározott GYIK webhely URL-jét veszünk a Zappostól, és feldolgozzuk a EZWebLoader osztály. Ezzel az osztállyal az URL-re navigáltunk, és az oldalon található összes kérdést betöltöttük egy indexbe. Most feltehetünk egy olyan kérdést, mint „Van-e Zappos ajándékutalvány?” és kapja meg a válaszokat közvetlenül a webhelyen található GYIK-ből. A következő képernyőképen az Amazon Lex botteszt konzolja látható, amely a GYIK-ből válaszol erre a kérdésre.

Ezt azért tudtuk elérni, mert az első lépésben feltérképeztük az URL-t, és létrehoztunk beágyazásokat, amelyek segítségével a LlamaIndex megkereshette a választ a kérdésünkre. A robotunk Lambda-függvénye megmutatja, hogyan fut le ez a keresés, amikor visszatér a tartalék szándék:

import time
import json
import os
import logging
import boto3
from llama_index import StorageContext, load_index_from_storage logger = logging.getLogger()
logger.setLevel(logging.DEBUG) def download_docstore(): # Create an S3 client s3 = boto3.client('s3') # List all objects in the S3 bucket and download each one
try: bucket_name = 'faq-bot-storage-001' s3_response = s3.list_objects_v2(Bucket=bucket_name) if 'Contents' in s3_response: for item in s3_response['Contents']: file_name = item['Key'] logger.debug("Downloading to /tmp/" + file_name) s3.download_file(bucket_name, file_name, '/tmp/' + file_name) logger.debug('All files downloaded from S3 and written to local filesystem.') except Exception as e: logger.error(e)
raise e #download the doc store locally
download_docstore() storage_context = StorageContext.from_defaults(persist_dir="/tmp/")
# load index
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine() def lambda_handler(event, context): """
Route the incoming request based on intent.
The JSON body of the request is provided in the event slot. """ # By default, treat the user request as coming from the America/New_York time zone. os.environ['TZ'] = 'America/New_York' time.tzset() logger.debug("===== START LEX FULFILLMENT ====") logger.debug(event) slots = {} if "currentIntent" in event and "slots" in event["currentIntent"]: slots = event["currentIntent"]["slots"] intent = event["sessionState"]["intent"] dialogaction = {"type": "Delegate"} message = [] if str.lower(intent["name"]) == "fallbackintent": #execute query from the input given by the user response = str.strip(query_engine.query(event["inputTranscript"]).response) dialogaction["type"] = "Close" message.append({'content': f'{response}', 'contentType': 'PlainText'}) final_response = { "sessionState": { "dialogAction": dialogaction, "intent": intent }, "messages": message } logger.debug(json.dumps(final_response, indent=1)) logger.debug("===== END LEX FULFILLMENT ====") return final_response

Ez a megoldás akkor működik jól, ha egyetlen weboldalon minden válasz megtalálható. A legtöbb GYIK oldal azonban nem egyetlen oldalra épül fel. Például a Zappos példánkban, ha feltesszük a kérdést: „Van-e áregyeztetési szabályzata?”, akkor kevésbé kielégítő választ kapunk, amint az a következő képernyőképen látható.

Az előző interakció során az áregyeztetési irányelvre adott válasz nem hasznos felhasználónk számára. Ez a válasz rövid, mert a hivatkozott GYIK egy adott oldalra mutató hivatkozás, amely az áregyeztetési szabályzattal foglalkozik, és webes feltérképezésünk csak egy oldalra vonatkozott. A jobb válaszok elérése a linkek feltérképezését is jelenti. A következő rész bemutatja, hogyan kaphat választ azokra a kérdésekre, amelyek két vagy több szintű oldalmélységet igényelnek.

N-szintű kúszás

Amikor egy weboldalt feltérképezünk a GYIK-értesítés érdekében, a kívánt információ megtalálható a hivatkozott oldalakon. Például a Zappos példánkban feltesszük a kérdést: „Van áregyeztetési szabályzata?” és a válasz: „Igen kérem látogasson el többet tanulni." Ha valaki azt kérdezi: „Mi az Ön áregyeztetési politikája?” akkor a házirenddel teljes választ akarunk adni. Ennek elérése azt jelenti, hogy be kell járnunk a linkeket, hogy a végfelhasználó számára a tényleges információkat megkapjuk. A betöltési folyamat során a webbetöltőnk segítségével megtalálhatjuk a más HTML-oldalakra mutató horgonyhivatkozásokat, majd bejárhatjuk azokat. A webrobotunk következő kódmódosítása lehetővé teszi számunkra, hogy linkeket találjunk az általunk feltérképezett oldalakon. Ezenkívül tartalmaz néhány további logikát a körkörös feltérképezés elkerülése érdekében, és lehetővé teszi az előtag alapján történő szűrést.

import logging
import requests
import html2text
from llama_index.readers.schema.base import Document
from typing import List
import re def find_http_urls_in_parentheses(s: str, prefix: str = None): pattern = r'((https?://[^)]+))' urls = re.findall(pattern, s) matched = [] if prefix is not None: for url in urls: if str(url).startswith(prefix): matched.append(url) else: matched = urls return list(set(matched)) # remove duplicates by converting to set, then convert back to list class EZWebLoader: def __init__(self, default_header: str = None): self._html_to_text_parser = html2text if default_header is None: self._default_header = {"User-agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.80 Safari/537.36"} else: self._default_header = default_header def load_data(self, urls: List[str], num_levels: int = 0, level_prefix: str = None, headers: str = None) -> List[Document]: logging.info(f"Number of urls: {len(urls)}.") if headers is None: headers = self._default_header documents = [] visited = {} for url in urls: q = [url] depth = num_levels for page in q: if page not in visited: #prevent cycles by checking to see if we already crawled a link logging.info(f"Crawling {page}") visited[page] = True #add entry to visited to prevent re-crawling pages response = requests.get(page, headers=headers).text response = self._html_to_text_parser.html2text(response) #reduce html to text documents.append(Document(response)) if depth > 0: #crawl linked pages ingest_urls = find_http_urls_in_parentheses(response, level_prefix) logging.info(f"Found {len(ingest_urls)} pages to crawl.") q.extend(ingest_urls) depth -= 1 #reduce the depth counter so we go only num_levels deep in our crawl else: logging.info(f"Skipping {page} as it has already been crawled") logging.info(f"Number of documents: {len(documents)}.") return documents url = "http://www.zappos.com/general-questions"
loader = EZWebLoader()
#crawl the site with 1 level depth and prefix of "/c/" for customer service root
documents = loader.load_data([url], num_levels=1, level_prefix="https://www.zappos.com/c/")
index = GPTVectorStoreIndex.from_documents(documents)

Az előző kódban bemutatjuk az N szint mélységű feltérképezésének lehetőségét, és adunk egy előtagot, amely lehetővé teszi, hogy a feltérképezést csak olyan dolgokra korlátozzuk, amelyek egy bizonyos URL-mintával kezdődnek. Zappos példánkban az ügyfélszolgálati oldalak mindegyike innen származik zappos.com/c, ezért ezt előtagként adjuk meg, hogy feltérképezéseinket egy kisebb és relevánsabb részhalmazra korlátozzuk. A kód megmutatja, hogyan tudunk akár két szint mélységig lenyelni. A robotunk Lambda logikája változatlan marad, mivel semmi sem változott azon kívül, hogy a bejáró több dokumentumot vesz fel.

Most már minden dokumentumot indexeltünk, és feltehetünk egy részletesebb kérdést. A következő képernyőképen a robotunk a helyes választ adja a „Van áregyeztetési szabályzata?” kérdésre.

Most teljes választ kaptunk az áregyeztetéssel kapcsolatos kérdésünkre. Ahelyett, hogy egyszerűen azt mondanák, hogy „Igen, lásd az irányelveinket”, a második szintű feltérképezés részleteit adja meg.

Tisztítsuk meg

A jövőbeni kiadások elkerülése érdekében folytassa a gyakorlat részeként telepített összes erőforrás törlésével. Elkészítettünk egy szkriptet a Sagemaker végpont kecses leállításához. A használat részletei a README-ban találhatók. Ezenkívül az összes többi futtatható erőforrás eltávolításához cdk destroy ugyanabban a könyvtárban, mint a többi cdk parancs a veremben lévő összes erőforrás leválasztásához.

Következtetés

Az a képesség, hogy egy GYIK-készletet beépíthet egy chatbotba, lehetővé teszi ügyfelei számára, hogy egyszerű, természetes nyelvű lekérdezések segítségével választ találjanak kérdéseikre. Ha az Amazon Lex beépített támogatását a tartalék kezeléshez egy RAG-megoldással, például a LlamaIndex-szel kombináljuk, ügyfeleink számára gyors utat biztosítunk, hogy kielégítő, válogatott és jóváhagyott válaszokat kapjanak a GYIK-re. Ha N-szintű bejárást alkalmazunk megoldásunkban, olyan válaszokat tudunk adni, amelyek több GYIK linkre is kiterjedhetnek, és mélyebb válaszokat adnak ügyfeleink kérdéseire. Ha követi ezeket a lépéseket, zökkenőmentesen beépítheti a hatékony LLM-alapú Q és A képességeket, valamint a hatékony URL-feldolgozást az Amazon Lex chatbotjába. Ez pontosabb, átfogóbb és környezettudatosabb interakciót eredményez a felhasználókkal.

A szerzőkről

Max Henkel-Wallace az AWS Lex szoftverfejlesztő mérnöke. Élvezi a technológiát az ügyfelek sikerének maximalizálása érdekében. A munkán kívül szenvedélyes a főzés, a barátokkal való időtöltés és a hátizsákos túrázás.

Song Feng az AWS AI Labs vezető alkalmazott tudósa, természetes nyelvi feldolgozásra és mesterséges intelligenciára szakosodott. Kutatásai e területek különböző aspektusait kutatják, beleértve a dokumentumalapú párbeszéd modellezést, a feladatorientált párbeszédek érvelését és az interaktív szöveggenerálást multimodális adatok felhasználásával.

John Baker az AWS vezető SDE-je, ahol természetes nyelvi feldolgozáson, nagy nyelvi modelleken és más, ML/AI-val kapcsolatos projekteken dolgozik. Több mint 9 éve dolgozik az Amazonnál, és dolgozott az AWS-en, az Alexán és az Amazon.com-on. Szabadidejében John élvezi a síelést és más szabadtéri tevékenységeket a Csendes-óceán északnyugati részén.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Autóipar / elektromos járművek, Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• BlockOffsets. A környezetvédelmi ellentételezési tulajdon korszerűsítése. Hozzáférés itt.
• Forrás: https://aws.amazon.com/blogs/machine-learning/enhance-amazon-lex-with-llms-and-improve-the-faq-experience-using-url-ingestion/