Bruk en generativ AI-grunnmodell for oppsummering og spørsmålssvar ved å bruke dine egne data | Amazon Web Services

Store språkmodeller (LLM) kan brukes til å analysere komplekse dokumenter og gi sammendrag og svar på spørsmål. Posten Domenetilpasning Finjustering av grunnmodeller i Amazon SageMaker JumpStart på økonomiske data beskriver hvordan du finjusterer en LLM ved å bruke ditt eget datasett. Når du har en solid LLM, vil du vise den LLM for forretningsbrukere for å behandle nye dokumenter, som kan være hundrevis av sider lange. I dette innlegget viser vi hvordan man konstruerer et sanntidsbrukergrensesnitt for å la forretningsbrukere behandle et PDF-dokument av vilkårlig lengde. Når filen er behandlet, kan du oppsummere dokumentet eller stille spørsmål om innholdet. Prøveløsningen beskrevet i dette innlegget er tilgjengelig på GitHub.

Arbeid med økonomiske dokumenter

Regnskap som kvartalsvise resultatrapporter og årlige rapporter til aksjonærer er ofte titalls eller hundrevis av sider lange. Disse dokumentene inneholder mye standardspråk som ansvarsfraskrivelser og juridisk språk. Hvis du ønsker å trekke ut nøkkeldatapunktene fra et av disse dokumentene, trenger du både tid og litt kjennskap til standardspråket slik at du kan identifisere de interessante faktaene. Og selvfølgelig kan du ikke stille spørsmål til en LLM om et dokument den aldri har sett.

LLM-er som brukes til oppsummering har en grense på antall tokens (tegn) som sendes inn i modellen, og med noen unntak er disse vanligvis ikke mer enn noen få tusen tokens. Det utelukker vanligvis muligheten til å oppsummere lengre dokumenter.

Vår løsning håndterer dokumenter som overskrider en LLMs maksimale tokensekvenslengde, og gjør det dokumentet tilgjengelig for LLM for spørsmålssvar.

Løsningsoversikt

Vårt design har tre viktige deler:

• Den har en interaktiv nettapplikasjon for forretningsbrukere for å laste opp og behandle PDF-er
• Den bruker langchain-biblioteket til å dele opp en stor PDF i mer håndterbare biter
• Den bruker teknikken for gjenoppretting for å la brukere stille spørsmål om nye data som LLM ikke har sett før

Som vist i følgende diagram bruker vi et grensesnitt implementert med React JavaScript som er vert i en Amazon enkel lagringstjeneste (Amazon S3) bøtte foran Amazon CloudFront. Front-end-applikasjonen lar brukere laste opp PDF-dokumenter til Amazon S3. Etter at opplastingen er fullført, kan du utløse en tekstutvinningsjobb drevet av amazontekst. Som en del av etterbehandlingen vil en AWS Lambda funksjonen setter inn spesielle markører i teksten som indikerer sidegrenser. Når den jobben er gjort, kan du påkalle en API som oppsummerer teksten eller svarer på spørsmål om den.

Fordi noen av disse trinnene kan ta litt tid, bruker arkitekturen en frakoblet asynkron tilnærming. For eksempel, kallet til å oppsummere et dokument påkaller en Lambda-funksjon som legger ut en melding til en Amazon enkel køtjeneste (Amazon SQS) kø. En annen Lambda-funksjon fanger opp den meldingen og starter en Amazon Elastic Container Service (Amazon ECS) AWS Fargate oppgave. Fargate-oppgaven kaller Amazon SageMaker sluttpunkt. Vi bruker en Fargate-oppgave her fordi oppsummering av en veldig lang PDF kan ta mer tid og minne enn en Lambda-funksjon har tilgjengelig. Når oppsummeringen er ferdig, kan front-end-applikasjonen hente resultatene fra en Amazon DynamoDB tabellen.

For oppsummering bruker vi AI21s Summarize-modell, en av grunnmodellene som er tilgjengelig gjennom Amazon SageMaker JumpStart. Selv om denne modellen håndterer dokumenter på opptil 10,000 40 ord (omtrent 10,000 sider), bruker vi langchains tekstsplitter for å sikre at hvert oppsummeringsanrop til LLM ikke er mer enn XNUMX XNUMX ord langt. For tekstgenerering bruker vi Coheres Medium-modell, og vi bruker GPT-J for innbygging, både via JumpStart.

Oppsummeringsbehandling

Når vi håndterer større dokumenter, må vi definere hvordan vi deler opp dokumentet i mindre biter. Når vi får tekstutvinningsresultatene tilbake fra Amazon Textract, setter vi inn markører for større tekstbiter (et konfigurerbart antall sider), individuelle sider og linjeskift. Langchain vil dele opp basert på disse markørene og sette sammen mindre dokumenter som er under token-grensen. Se følgende kode:

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 oppsummeringskjeden er en tynn innpakning rundt SageMaker-endepunktet vårt:

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 

Svar på spørsmål

I metoden for gjenoppretting av gjenvinning deler vi først dokumentet i mindre segmenter. Vi lager innbygginger for hvert segment og lagrer dem i åpen kildekode Chroma vektordatabasen via langchains grensesnitt. Vi lagrer databasen i en Amazon elastisk filsystem (Amazon EFS) filsystem for senere bruk. Se følgende kode:

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 innbyggingene er klare, kan brukeren stille et spørsmål. Vi søker i vektordatabasen etter tekstbitene som samsvarer best med spørsmålet:

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 delen som passer best og bruker den som kontekst for tekstgenereringsmodellen for å svare på spørsmålet:

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', '')

Brukeropplevelse

Selv om LLM-er representerer avansert datavitenskap, involverer de fleste brukstilfellene for LLM-er til slutt interaksjon med ikke-tekniske brukere. Eksempelnettapplikasjonen vår håndterer en interaktiv brukssak der forretningsbrukere kan laste opp og behandle et nytt PDF-dokument.

Følgende diagram viser brukergrensesnittet. En bruker starter med å laste opp en PDF. Etter at dokumentet er lagret i Amazon S3, kan brukeren starte tekstutvinningsjobben. Når det er fullført, kan brukeren starte oppsummeringsoppgaven eller stille spørsmål. Brukergrensesnittet viser noen avanserte alternativer som chunk-størrelse og chunk-overlapping, noe som vil være nyttig for avanserte brukere som tester applikasjonen på nye dokumenter.

Neste trinn

LLM-er gir betydelige nye funksjoner for informasjonsinnhenting. Bedriftsbrukere trenger enkel tilgang til disse egenskapene. Det er to retninger for fremtidig arbeid å vurdere:

• Dra nytte av de kraftige LLM-ene som allerede er tilgjengelige i Jumpstart-fundamentmodeller. Med bare noen få linjer med kode kan prøveapplikasjonen vår distribuere og bruke avanserte LLM-er fra AI21 og Cohere for tekstoppsummering og generering.
• Gjør disse egenskapene tilgjengelige for ikke-tekniske brukere. En forutsetning for å behandle PDF-dokumenter er å trekke ut tekst fra dokumentet, og oppsummeringsjobber kan ta flere minutter å kjøre. Det krever et enkelt brukergrensesnitt med asynkrone backend-behandlingsmuligheter, som er lett å designe ved å bruke skybaserte tjenester som Lambda og Fargate.

Vi legger også merke til at et PDF-dokument er semistrukturert informasjon. Viktige signaler som seksjonsoverskrifter er vanskelige å identifisere programmatisk, fordi de er avhengige av skriftstørrelser og andre visuelle indikatorer. Å identifisere den underliggende informasjonsstrukturen hjelper LLM med å behandle dataene mer nøyaktig, i det minste inntil LLM-er kan håndtere input av ubegrenset lengde.

konklusjonen

I dette innlegget viste vi hvordan man bygger en interaktiv nettapplikasjon som lar bedriftsbrukere laste opp og behandle PDF-dokumenter for oppsummering og svar på spørsmål. Vi så hvordan vi kunne dra nytte av Jumpstart-grunnlagsmodeller for å få tilgang til avanserte LLM-er, og bruke teknikker for utvidet generering av tekstdeling og gjenfinning for å behandle lengre dokumenter og gjøre dem tilgjengelige som informasjon for LLM.

På dette tidspunktet er det ingen grunn til ikke å gjøre disse kraftige funksjonene tilgjengelige for brukerne dine. Vi oppfordrer deg til å begynne å bruke Jumpstart-fundamentmodeller i dag.

Om forfatteren

Randy DeFauw er Senior Principal Solutions Architect hos AWS. Han har en MSEE fra University of Michigan, hvor han jobbet med datasyn for autonome kjøretøy. Han har også en MBA fra Colorado State University. Randy har hatt en rekke stillinger innen teknologiområdet, alt fra programvareutvikling til produktadministrasjon. In gikk inn i Big Data-området i 2013 og fortsetter å utforske det området. Han jobber aktivt med prosjekter i ML-området og har presentert på en rekke konferanser inkludert Strata og GlueCon.

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
• PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
• PlatoESG. Bil / elbiler, Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• BlockOffsets. Modernisering av eierskap for miljøkompensasjon. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/use-a-generative-ai-foundation-model-for-summarization-and-question-answering-using-your-own-data/