Använd en generativ AI-grundmodell för att sammanfatta och svara på frågor med dina egna data | Amazon webbtjänster

Stora språkmodeller (LLM) kan användas för att analysera komplexa dokument och ge sammanfattningar och svar på frågor. Inlägget Domänanpassning Finjustering av grundmodeller i Amazon SageMaker JumpStart på finansiell data beskriver hur du finjusterar en LLM med din egen datauppsättning. När du väl har en solid LLM, vill du exponera den LLM för affärsanvändare för att bearbeta nya dokument, som kan vara hundratals sidor långa. I det här inlägget visar vi hur man konstruerar ett användargränssnitt i realtid för att låta affärsanvändare bearbeta ett PDF-dokument av godtycklig längd. När filen är bearbetad kan du sammanfatta dokumentet eller ställa frågor om innehållet. Provlösningen som beskrivs i det här inlägget är tillgänglig på GitHub.

Arbeta med ekonomiska dokument

Finansiella rapporter som kvartalsvisa resultatrapporter och årsrapporter till aktieägare är ofta tiotals eller hundratals sidor långa. Dessa dokument innehåller en hel del beskrivningsspråk som ansvarsfriskrivningar och juridiskt språk. Om du vill extrahera nyckeldatapunkterna från ett av dessa dokument behöver du både tid och lite förtrogenhet med standardspråket så att du kan identifiera intressanta fakta. Och naturligtvis kan du inte ställa frågor till en LLM om ett dokument som den aldrig har sett.

LLM som används för sammanfattning har en gräns för antalet tokens (tecken) som skickas in i modellen, och med vissa undantag är dessa vanligtvis inte mer än några tusen tokens. Det utesluter normalt möjligheten att sammanfatta längre dokument.

Vår lösning hanterar dokument som överskrider en LLM:s maximala tokensekvenslängd, och gör det dokumentet tillgängligt för LLM för att besvara frågor.

Lösningsöversikt

Vår design har tre viktiga delar:

• Den har en interaktiv webbapplikation för företagsanvändare att ladda upp och bearbeta PDF-filer
• Den använder langchain-biblioteket för att dela upp en stor PDF i mer hanterbara bitar
• Den använder tekniken för återvinning förstärkt generation för att låta användare ställa frågor om ny data som LLM inte har sett tidigare

Som visas i följande diagram använder vi ett gränssnitt implementerat med React JavaScript värd i en Amazon enkel lagringstjänst (Amazon S3) skopa frontad av Amazon CloudFront. Front-end-applikationen låter användare ladda upp PDF-dokument till Amazon S3. När uppladdningen är klar kan du utlösa ett textextraktionsjobb som drivs av amazontext. Som en del av efterbearbetningen, en AWS Lambda funktionen infogar speciella markörer i texten som indikerar sidgränser. När det jobbet är klart kan du anropa ett API som sammanfattar texten eller svarar på frågor om den.

Eftersom vissa av dessa steg kan ta lite tid, använder arkitekturen ett frikopplat asynkront tillvägagångssätt. Till exempel, anropet att sammanfatta ett dokument anropar en Lambda-funktion som skickar ett meddelande till en Amazon enkel kötjänst (Amazon SQS) kö. En annan lambdafunktion tar upp det meddelandet och startar en Amazon Elastic Container Service (Amazon ECS) AWS Fargate uppgift. Fargate-uppgiften kallar Amazon SageMaker slutpunkt. Vi använder en Fargate-uppgift här eftersom att sammanfatta en mycket lång PDF-fil kan ta mer tid och minne än vad en Lambda-funktion har tillgänglig. När sammanfattningen är klar kan front-end-applikationen hämta resultaten från en Amazon DynamoDB tabell.

För sammanfattning använder vi AI21:s Summarize-modell, en av grundmodellerna som finns tillgängliga genom Amazon SageMaker JumpStart. Även om den här modellen hanterar dokument på upp till 10,000 40 ord (cirka 10,000 sidor) använder vi langchains textdelare för att se till att varje summeringsanrop till LLM inte är mer än XNUMX XNUMX ord långt. För textgenerering använder vi Coheres Medium-modell, och vi använder GPT-J för inbäddningar, båda via JumpStart.

Sammanfattningsbearbetning

När vi hanterar större dokument måste vi definiera hur dokumentet ska delas upp i mindre bitar. När vi får tillbaka textextraktionsresultaten från Amazon Textract, infogar vi markörer för större bitar av text (ett konfigurerbart antal sidor), enskilda sidor och radbrytningar. Langchain kommer att delas baserat på dessa markörer och sammanställa mindre dokument som är under token-gränsen. Se följande kod:

text_splitter = RecursiveCharacterTextSplitter( separators = ["<CHUNK>", "<PAGE>", "n"], chunk_size = int(chunk_size), chunk_overlap = int(chunk_overlap)) with open(local_path) as f: doc = f.read() texts = text_splitter.split_text(doc) print(f"Number of splits: {len(texts)}") llm = SageMakerLLM(endpoint_name = endpoint_name) responses = [] for t in texts: r = llm(t) responses.append(r) summary = "n".join(responses)

LLM i sammanfattningskedjan är ett tunt omslag runt vår SageMaker-slutpunkt:

class SageMakerLLM(LLM): endpoint_name: str @property
def _llm_type(self) -> str: return "summarize" def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str: response = ai21.Summarize.execute( source=prompt, sourceType="TEXT", sm_endpoint=self.endpoint_name ) return response.summary 

Frågesvar

I metoden för att hämta utökad generering delade vi först upp dokumentet i mindre segment. Vi skapar inbäddningar för varje segment och lagrar dem i Chroma vektordatabasen med öppen källkod via langchains gränssnitt. Vi sparar databasen i en Amazon Elastic File System (Amazon EFS) filsystem för senare användning. Se följande kod:

documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size = 500, chunk_overlap = 0)
texts = text_splitter.split_documents(documents)
print(f"Number of splits: {len(texts)}") embeddings = SMEndpointEmbeddings( endpoint_name=endpoint_name,
)
vectordb = Chroma.from_documents(texts, embeddings, persist_directory=persist_directory)
vectordb.persist()

När inbäddningarna är klara kan användaren ställa en fråga. Vi söker i vektordatabasen efter de textbitar som bäst matchar frågan:

embeddings = SMEndpointEmbeddings( endpoint_name=endpoint_embed
)
vectordb = Chroma(persist_directory=persist_directory, embedding_function=embeddings)
docs = vectordb.similarity_search_with_score(question)

Vi tar den närmast matchande biten och använder den som sammanhang för textgenereringsmodellen för att svara på frågan:

cohere_client = Client(endpoint_name=endpoint_qa)
context = docs[high_score_idx][0].page_content.replace("n", "")
qa_prompt = f'Context={context}nQuestion={question}nAnswer='
response = cohere_client.generate(prompt=qa_prompt, max_tokens=512, temperature=0.25, return_likelihoods='GENERATION')
answer = response.generations[0].text.strip().replace('n', '')

Användare erfarenhet

Även om LLM:er representerar avancerad datavetenskap, involverar de flesta användningsfallen för LLM:er i slutändan interaktion med icke-tekniska användare. Vår exempelwebbapplikation hanterar ett interaktivt användningsfall där företagsanvändare kan ladda upp och bearbeta ett nytt PDF-dokument.

Följande diagram visar användargränssnittet. En användare börjar med att ladda upp en PDF. Efter att dokumentet har lagrats i Amazon S3 kan användaren starta textextraktionsjobbet. När det är klart kan användaren anropa sammanfattningsuppgiften eller ställa frågor. Användargränssnittet visar några avancerade alternativ som chunkstorlek och chunköverlappning, vilket skulle vara användbart för avancerade användare som testar applikationen på nya dokument.

Nästa steg

LLM:er ger betydande ny informationsinhämtning. Affärsanvändare behöver bekväm tillgång till dessa funktioner. Det finns två riktningar för framtida arbete att överväga:

• Dra nytta av de kraftfulla LLM som redan finns i Jumpstart-grundmodeller. Med bara några rader kod kan vår exempelapplikation distribuera och använda avancerade LLM:er från AI21 och Cohere för textsammanfattning och generering.
• Gör dessa funktioner tillgängliga för icke-tekniska användare. En förutsättning för att bearbeta PDF-dokument är att extrahera text från dokumentet, och sammanfattningsjobb kan ta flera minuter att köra. Det kräver ett enkelt användargränssnitt med asynkrona backend-bearbetningsmöjligheter, som är lätt att designa med hjälp av molnbaserade tjänster som Lambda och Fargate.

Vi noterar också att ett PDF-dokument är semistrukturerad information. Viktiga ledtrådar som avsnittsrubriker är svåra att identifiera programmatiskt eftersom de förlitar sig på teckenstorlekar och andra visuella indikatorer. Att identifiera den underliggande informationsstrukturen hjälper LLM att bearbeta data mer exakt, åtminstone tills LLM:er kan hantera indata av obegränsad längd.

Slutsats

I det här inlägget visade vi hur man bygger en interaktiv webbapplikation som låter företagsanvändare ladda upp och bearbeta PDF-dokument för sammanfattning och svar på frågor. Vi såg hur man kan dra nytta av Jumpstarts grundmodeller för att komma åt avancerade LLM:er, och använda tekniker för utökad generering av textdelning och hämtning för att bearbeta längre dokument och göra dem tillgängliga som information till LLM.

Vid denna tidpunkt finns det ingen anledning att inte göra dessa kraftfulla funktioner tillgängliga för dina användare. Vi uppmuntrar dig att börja använda Jumpstart foundation modeller i dag.

Om författaren

Randy DeFauw är Senior Principal Solutions Architect på AWS. Han har en MSEE från University of Michigan, där han arbetade med datorseende för autonoma fordon. Han har också en MBA från Colorado State University. Randy har haft en mängd olika positioner inom teknikområdet, allt från mjukvaruteknik till produkthantering. In gick in i Big Data-utrymmet 2013 och fortsätter att utforska det området. Han arbetar aktivt med projekt inom ML-området och har presenterat på ett flertal konferenser inklusive Strata och GlueCon.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Fordon / elbilar, Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• BlockOffsets. Modernisera miljökompensation ägande. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/use-a-generative-ai-foundation-model-for-summarization-and-question-answering-using-your-own-data/