Intelligente documentverwerking (IDP) is een technologie die de verwerking van grote hoeveelheden ongestructureerde gegevens, waaronder tekst, afbeeldingen en video's, automatiseert. IDP biedt een aanzienlijke verbetering ten opzichte van handmatige methoden en verouderde OCR-systemen (optical character recognition) door uitdagingen zoals kosten, fouten, lage nauwkeurigheid en beperkte schaalbaarheid aan te pakken, wat uiteindelijk leidt tot betere resultaten voor organisaties en belanghebbenden.

Natuurlijke taalverwerking (NLP) is een van de recente ontwikkelingen in IDP die de nauwkeurigheid en gebruikerservaring heeft verbeterd. Ondanks deze vooruitgang zijn er echter nog steeds uitdagingen te overwinnen. Veel IDP-systemen zijn bijvoorbeeld niet gebruiksvriendelijk of intuïtief genoeg om gemakkelijk door gebruikers te worden overgenomen. Bovendien missen verschillende bestaande oplossingen het vermogen om zich aan te passen aan veranderingen in gegevensbronnen, regelgeving en gebruikersvereisten door middel van continue verbetering en updates.

Het verbeteren van ontheemden door middel van dialoog omvat het opnemen van dialoogmogelijkheden in ontheemdensystemen. Door gebruikers in staat te stellen om op een meer natuurlijke en intuïtieve manier met IDP-systemen te communiceren, door middel van multi-round dialoog door onnauwkeurige informatie aan te passen of ontbrekende informatie toe te voegen met behulp van taakautomatisering, kunnen deze systemen efficiënter, nauwkeuriger en gebruiksvriendelijker worden.

In dit bericht verkennen we een innovatieve benadering van IDP die gebruikmaakt van een dialooggestuurde query-oplossing met behulp van Amazon Foundation-modellen en SageMaker JumpStart.

Overzicht oplossingen

Deze innovatieve oplossing combineert OCR voor informatie-extractie, een lokaal ingezet groot taalmodel (LLM) voor dialoog en autonome taken, VectorDB voor het inbedden van subtaken en op LangChain gebaseerde taakautomatisering voor integratie met externe gegevensbronnen om de manier waarop bedrijven documenten verwerken en analyseren te transformeren. contexten. Door gebruik te maken van generatieve AI-technologieën kunnen organisaties IDP-workflows stroomlijnen, de gebruikerservaring verbeteren en de algehele efficiëntie verhogen.

De volgende video belicht het dialooggestuurde IDP-systeem door middel van verwerking een artikel geschreven door de Raad van gouverneurs van de Federal Reserve, over de ineenstorting van Silicon Valley Bank in maart 2023.

Het systeem is in staat om afbeeldingen, grote pdf's en documenten in een ander formaat te verwerken en vragen te beantwoorden die zijn afgeleid van de inhoud via interactieve tekst- of spraakinvoer. Als een gebruiker buiten de context van het document moet informeren, kan de dialooggestuurde IDP een reeks taken maken op basis van de tekstprompt en vervolgens verwijzen naar externe en up-to-date gegevensbronnen voor relevante antwoorden. Bovendien ondersteunt het gesprekken met meerdere rondes en is het geschikt voor meertalige uitwisselingen, allemaal beheerd via dialoog.

Implementeer uw eigen LLM met behulp van Amazon-basismodellen

Een van de meest veelbelovende ontwikkelingen in generatieve AI is de integratie van LLM's in dialoogsystemen, waardoor nieuwe wegen worden geopend voor meer intuïtieve en zinvolle uitwisselingen. Een LLM is een type AI-model dat is ontworpen om mensachtige tekst te begrijpen en te genereren. Deze modellen zijn getraind op enorme hoeveelheden gegevens en bestaan ​​uit miljarden parameters, waardoor ze verschillende taalgerelateerde taken met hoge nauwkeurigheid kunnen uitvoeren. Deze transformatieve benadering maakt een meer natuurlijke en productieve interactie mogelijk en overbrugt de kloof tussen menselijke intuïtie en machine-intelligentie. Een belangrijk voordeel van lokale LLM-implementatie ligt in de mogelijkheid om gegevensbeveiliging te verbeteren zonder gegevens naar externe API's te sturen. Bovendien kunt u de door u gekozen LLM verfijnen met domeinspecifieke gegevens, wat resulteert in een meer accurate, contextbewuste en natuurlijke taalbegripervaring.

De Jurassic-2-serie van AI21 Labs, die is gebaseerd op de op instructies afgestemde Jurassic-178 LLM met 1 miljard parameters, is een integraal onderdeel van de Amazon-basismodellen die beschikbaar zijn via Amazonebodem. De Jurassic-2 instruct is speciaal getraind om prompts te beheren die alleen instructies zijn, ook wel bekend als nul-schot, zonder dat er voorbeelden nodig zijn, of paar schot. Deze methode biedt de meest intuïtieve interactie met LLM's en is de beste manier om de ideale uitvoer voor uw taak te begrijpen zonder dat u voorbeelden nodig hebt. U kunt de vooraf getrainde J2-jumbo-instruct, of andere Jurassic-2-modellen die beschikbaar zijn op AWS Marketplace, efficiënt implementeren in uw eigen virtual private cloud (VPC) met behulp van Amazon Sage Maker. Zie de volgende code:

import ai21, sagemaker # Define endpoint name
endpoint_name = "sagemaker-soln-j2-jumbo-instruct"
# Define real-time inference instance type. You can also choose g5.48xlarge or p4de.24xlarge instance types
# Please request P instance quota increase via <a href="https://console.aws.amazon.com/servicequotas/home" target="_blank" rel="noopener">Service Quotas console</a> or your account manager
real_time_inference_instance_type = ("ml.p4d.24xlarge") # Create a Sgaemkaer endpoint then deploy a pre-trained J2-jumbo-instruct-v1 model from AWS Market Place.
model_package_arn = "arn:aws:sagemaker:us-east-1:865070037744:model-package/j2-jumbo-instruct-v1-0-20-8b2be365d1883a15b7d78da7217cdeab"
model = ModelPackage(
role=sagemaker.get_execution_role(),
model_package_arn=model_package_arn,
sagemaker_session=sagemaker.Session()
) # Deploy the model
predictor = model.deploy(1, real_time_inference_instance_type,
endpoint_name=endpoint_name,
model_data_download_timeout=3600,
container_startup_health_check_timeout=600,
)

Nadat het eindpunt met succes is geïmplementeerd binnen uw eigen VPC, kunt u een deductietaak starten om te controleren of de geïmplementeerde LLM werkt zoals verwacht:

response_jumbo_instruct = ai21.Completion.execute(
sm_endpoint=endpoint_name,
prompt="Explain deep learning algorithms to 8th graders",
numResults=1,
maxTokens=100,
temperature=0.01 #subject to reduce “hallucination” by using common words.
)

Documentverwerking, inbedding en indexering

We verdiepen ons in het proces van het bouwen van een efficiënte en effectieve zoekindex, die de basis vormt voor intelligente en responsieve dialogen om documentverwerking te begeleiden. Om te beginnen zetten we documenten van verschillende formaten om in tekstinhoud met behulp van OCR en Amazon T-extract. Vervolgens lezen we deze inhoud en fragmenteren we deze in kleinere stukjes, idealiter elk ter grootte van een zin. Deze gedetailleerde benadering zorgt voor nauwkeurigere en relevantere zoekresultaten, omdat zoekopdrachten beter kunnen worden vergeleken met afzonderlijke segmenten van een pagina in plaats van met het hele document. Om het proces verder te verbeteren, gebruiken we inbeddingen zoals de zinstransformatorenbibliotheek van Hugging Face, die vectorrepresentaties (codering) van elke zin genereert. Deze vectoren dienen als een compacte en betekenisvolle weergave van de originele tekst, waardoor een efficiënte en nauwkeurige semantische matching-functionaliteit mogelijk is. Ten slotte slaan we deze vectoren op in een vectordatabase voor het zoeken naar overeenkomsten. Deze combinatie van technieken legt de basis voor een nieuw raamwerk voor documentverwerking dat nauwkeurige en intuïtieve resultaten oplevert voor gebruikers. Het volgende diagram illustreert deze workflow.

OCR dient als een cruciaal element in de oplossing, waardoor tekst uit gescande documenten of afbeeldingen kan worden opgehaald. We kunnen Amazon Textract gebruiken voor het extraheren van tekst uit PDF- of afbeeldingsbestanden. Deze beheerde OCR-service is in staat om tekst in documenten met meerdere pagina's te identificeren en te onderzoeken, inclusief documenten in PDF-, JPEG- of TIFF-indeling, zoals facturen en kwitanties. De verwerking van documenten met meerdere pagina's vindt asynchroon plaats, wat het voordelig maakt voor het verwerken van omvangrijke documenten met meerdere pagina's. Zie de volgende code:

def pdf_2_text(input_pdf_file, history):
history = history or []
key = 'input-pdf-files/{}'.format(os.path.basename(input_pdf_file.name))
try:
response = s3_client.upload_file(input_pdf_file.name, default_bucket_name, key)
except ClientError as e:
print("Error uploading file to S3:", e)
s3_object = {'Bucket': default_bucket_name, 'Name': key}
response = textract_client.start_document_analysis(
DocumentLocation={'S3Object': s3_object},
FeatureTypes=['TABLES', 'FORMS']
)
job_id = response['JobId']
while True:
response = textract_client.get_document_analysis(JobId=job_id)
status = response['JobStatus']
if status in ['SUCCEEDED', 'FAILED']:
break
time.sleep(5) if status == 'SUCCEEDED':
with open(output_file, 'w') as output_file_io:
for block in response['Blocks']:
if block['BlockType'] in ['LINE', 'WORD']:
output_file_io.write(block['Text'] + 'n')
with open(output_file, "r") as file:
first_512_chars = file.read(512).replace("n", "").replace("r", "").replace("[", "").replace("]", "") + " [...]"
history.append(("Document conversion", first_512_chars))
return history, history

Bij het omgaan met grote documenten is het van cruciaal belang om ze op te splitsen in beter hanteerbare stukken om ze gemakkelijker te kunnen verwerken. In het geval van LangChain betekent dit dat elk document wordt opgedeeld in kleinere segmenten, zoals 1,000 tokens per stuk met een overlap van 100 tokens. Om dit soepel te laten verlopen, maakt LangChain gebruik van gespecialiseerde splitters die speciaal voor dit doel zijn ontworpen:

from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import TextLoader
separator = 'n'
overlap_count = 100. # overlap count between the splits
chunk_size = 1000 # Use a fixed split unit size
loader = TextLoader(output_file)
documents = loader.load()
text_splitter = CharacterTextSplitter(separator=separator, chunk_overlap=overlap_count, chunk_size=chunk_size, length_function=len)
texts = text_splitter.split_documents(documents)

De duur die nodig is voor het insluiten kan fluctueren op basis van de grootte van het document; het kan bijvoorbeeld ongeveer 10 minuten duren om te voltooien. Hoewel dit tijdsbestek misschien niet substantieel is wanneer het om een ​​enkel document gaat, worden de gevolgen duidelijker wanneer honderden gigabytes worden geïndexeerd in plaats van slechts honderden megabytes. Om het inbeddingsproces te versnellen, kunt u sharding implementeren, wat parallellisatie mogelijk maakt en bijgevolg de efficiëntie verbetert:

from langchain.document_loaders import ReadTheDocsLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from sentence_transformers import SentenceTransformer
import numpy as np
import ray
from embeddings import LocalHuggingFaceEmbeddings # Define number of splits
db_shards = 10 loader = TextLoader(output_file)
text_splitter = RecursiveCharacterTextSplitter(
chunk_size = 1000,
chunk_overlap  = 100,
length_function = len,
) @ray.remote()
def process_shard(shard):
embeddings = LocalHuggingFaceEmbeddings('multi-qa-mpnet-base-dot-v1')
result = Chroma.from_documents(shard, embeddings)
return result # Read the doc content and split them into chunks.
chunks = text_splitter.create_documents([doc.page_content for doc in documents], metadatas=[doc.metadata for doc in documents])
# Embed the doc chunks into vectors.
shards = np.array_split(chunks, db_shards)
futures = [process_shard.remote(shards[i]) for i in range(db_shards)]
texts = ray.get(futures)

Nu we de kleinere segmenten hebben verkregen, kunnen we ze blijven weergeven als vectoren door middel van inbedding. Inbeddingen, een techniek in NLP, genereren vectorrepresentaties van tekstprompts. De Embedding-klasse dient als een uniforme interface voor interactie met verschillende inbeddingsproviders, zoals SageMaker, Samenhangen, Gezicht knuffelen en OpenAI, waarmee het proces op verschillende platforms wordt gestroomlijnd. Deze inbeddingen zijn numerieke weergaven van ideeën die zijn omgezet in nummerreeksen, waardoor computers moeiteloos de verbanden tussen deze ideeën kunnen begrijpen. Zie de volgende code:

# Choose a SageMaker deployed local LLM endpoint for embedding
llm_embeddings = SagemakerEndpointEmbeddings(
endpoint_name=<endpoint_name>,
region_name=<region>,
content_handler=content_handler
)

Nadat we de inbeddingen hebben gemaakt, moeten we een vectorstore gebruiken om de vectoren op te slaan. Vectorwinkels zoals Chroma zijn speciaal ontworpen om indexen te construeren voor snelle zoekopdrachten in hoog-dimensionale ruimtes later, waardoor ze perfect geschikt zijn voor onze doelstellingen. Als alternatief kunt u gebruiken FAISS, een open-source vectorclusteringsoplossing voor het opslaan van vectoren. Zie de volgende code:

from langchain.vectorstores import Chroma
# Store vectors in Chroma vectorDB
docsearch_chroma = Chroma.from_documents(texts, llm_embeddings)
# Alternatively you can choose FAISS vectorstore
from langchain.vectorstores import FAISS
docsearch_faiss = FAISS.from_documents(texts, llm_embeddings)

U kunt ook gebruik maken van Amazon Kendra om bedrijfsinhoud te indexeren en nauwkeurige antwoorden te produceren. Als een volledig beheerde service biedt Amazon Kendra kant-en-klare semantische zoekfuncties voor geavanceerde rangschikking van documenten en passages. Met de zeer nauwkeurige zoekfunctie in Amazon Kendra kunt u de meest relevante inhoud en documenten verkrijgen om de kwaliteit van uw lading te optimaliseren. Dit resulteert in superieure LLM-reacties in vergelijking met traditionele of op trefwoorden gerichte zoekmethoden. Voor meer informatie, zie Bouw snel zeer nauwkeurige generatieve AI-applicaties op bedrijfsgegevens met behulp van Amazon Kendra, LangChain en grote taalmodellen.

Interactieve meertalige spraakinvoer

Het opnemen van interactieve spraakinvoer in het zoeken naar documenten biedt een groot aantal voordelen die de gebruikerservaring verbeteren. Door gebruikers in staat te stellen zoektermen verbaal te articuleren, wordt het zoeken naar documenten natuurlijker en intuïtiever, waardoor het voor gebruikers eenvoudiger en sneller wordt om de informatie te vinden die ze nodig hebben. Spraakinvoer kan de nauwkeurigheid van zoekresultaten vergroten, omdat gesproken zoektermen minder vatbaar zijn voor spel- of grammaticale fouten. Interactieve spraakinvoer maakt het zoeken naar documenten inclusiever en richt zich op een breder spectrum van gebruikers met verschillende taalsprekers en culturele achtergrond.

De Amazon Transcribe Streaming-SDK stelt u in staat om audio-naar-spraakherkenning uit te voeren door rechtstreeks te integreren met Amazon Transcribe, eenvoudig met een stroom audiobytes en een basishandler. Als alternatief kunt u de fluister-groot lokaal modelleren vanuit Hugging Face met behulp van SageMaker, die verbeterde gegevensbeveiliging en betere prestaties biedt. Raadpleeg voor meer informatie de voorbeeld notebook gepubliceerd op de GitHub-repo.

# Choose ASR using a locally deployed Whisper-large model from Hugging Face
image = sagemaker.image_uris.retrieve(
framework='pytorch',
region=region,
image_scope='inference',
version='1.12',
instance_type='ml.g4dn.xlarge',
) model_name = f'sagemaker-soln-whisper-model-{int(time.time())}'
whisper_model_sm = sagemaker.model.Model(
model_data=model_uri,
image_uri=image,
role=sagemaker.get_execution_role(),
entry_point="inference.py",
source_dir='src',
name=model_name,
) # Audio transcribe
transcribe = whisper_endpoint.predict(audio.numpy())

De bovenstaande demonstratievideo laat zien hoe spraakopdrachten, in combinatie met tekstinvoer, de taak van het samenvatten van documenten door middel van interactieve gesprekken kunnen vergemakkelijken.

Begeleiden van NLP-taken door middel van gesprekken met meerdere rondes

Geheugen in taalmodellen handhaaft een toestandsconcept tijdens de interacties van een gebruiker. Dit omvat het verwerken van een reeks chatberichten om kennis te extraheren en te transformeren. Geheugentypen variëren, maar elk kan worden begrepen met behulp van zelfstandige functies en binnen een keten. Het geheugen kan meerdere gegevenspunten retourneren, zoals recente berichten of berichtsamenvattingen, in de vorm van tekenreeksen of lijsten. Dit bericht richt zich op de eenvoudigste geheugenvorm, buffergeheugen, waarin alle eerdere berichten worden opgeslagen en het gebruik ervan wordt gedemonstreerd met modulaire hulpprogramma's en ketens.

De LangChains ChatBerichtenGeschiedenis class is een cruciaal hulpprogramma voor geheugenmodules en biedt handige methoden om menselijke en AI-berichten op te slaan en op te halen door alle eerdere chatinteracties te onthouden. Het is ideaal voor het extern beheren van geheugen vanuit een keten. De volgende code is een voorbeeld van het toepassen van een eenvoudig concept in een keten door te introduceren Gespreksbuffergeheugen, een wikkel voor ChatMessageHistory. Deze wrapper extraheert berichten in een variabele, waardoor ze kunnen worden weergegeven als een tekenreeks:

from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(return_messages=True)

LangChain werkt met veel populaire LLM-providers zoals AI21 Labs, OpenAI, Cohere, Hugging Face en meer. Voor dit voorbeeld gebruiken we een lokaal geïmplementeerde AI21 Labs' Jurassic-2 LLM-wrapper met behulp van SageMaker. AI21 Studio biedt ook API-toegang tot Jurassic-2 LLM's.

from langchain import PromptTemplate, SagemakerEndpoint
from langchain.llms.sagemaker_endpoint import ContentHandlerBase
from langchain.chains.question_answering import load_qa_chain prompt= PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
) class ContentHandler(ContentHandlerBase):
content_type = "application/json"
accepts = "application/json"
def transform_input(self, prompt: str, model_kwargs: Dict) -- bytes:
input_str = json.dumps({prompt: prompt, **model_kwargs})
return input_str.encode('utf-8') def transform_output(self, output: bytes) -- str:
response_json = json.loads(output.read().decode("utf-8"))
return response_json[0]["generated_text"]
content_handler = ContentHandler()
llm_ai21=SagemakerEndpoint(
endpoint_name=endpoint_name,
credentials_profile_name=f'aws-credentials-profile-name',
region_name="us-east-1",
model_kwargs={"temperature":0},
content_handler=content_handler) qa_chain = VectorDBQA.from_chain_type(
llm=llm_ai21,
chain_type='stuff',
vectorstore=docsearch,
verbose=True,
memory=ConversationBufferMemory(return_messages=True)
) response = qa_chain(
{'query': query_input},
return_only_outputs=True
)

In het geval dat het proces niet in staat is om een ​​passend antwoord uit de originele documenten te vinden als antwoord op een vraag van een gebruiker, verbetert de integratie van een URL van een derde partij of idealiter een taakgestuurde autonome agent met externe gegevensbronnen de mogelijkheid van het systeem om toegang tot een breed scala aan informatie, waardoor uiteindelijk de context wordt verbeterd en nauwkeurigere en actuelere resultaten worden geleverd.

Met de vooraf geconfigureerde Summarize-runmethode van AI21 kan een query toegang krijgen tot een vooraf bepaalde URL, de inhoud ervan condenseren en vervolgens vraag- en antwoordtaken uitvoeren op basis van de samengevatte informatie:

# Call AI21 API to query the context of a specific URL for Q&A
ai21.api_key = "<YOUR_API_KEY>"
url_external_source = "<your_source_url>"
response_url = ai21.Summarize.execute(
source=url_external_source,
sourceType="URL" )
context = "<concate_document_and_response_url>"
question = "<query>"
response = ai21.Answer.execute(
context=context,
question=question,
sm_endpoint=endpoint_name,
maxTokens=100,
)

Raadpleeg voor aanvullende details en codevoorbeelden de LangChain LLM-integratiedocument alsmede de taakspecifieke API-documenten geleverd door AI21.

Taakautomatisering met behulp van BabyAGI

Dankzij het taakautomatiseringsmechanisme kan het systeem complexe vragen verwerken en relevante antwoorden genereren, wat de validiteit en authenticiteit van documentverwerking aanzienlijk verbetert. BabyAGI van LangCain is een krachtig door AI aangedreven taakbeheersysteem dat autonoom taken kan creëren, prioriteren en uitvoeren. Een van de belangrijkste kenmerken is de mogelijkheid om te communiceren met externe informatiebronnen, zoals internet, databases en API's. Een manier om deze functie te gebruiken, is door BabyAGI te integreren met Serpapi, een zoekmachine-API die toegang biedt tot zoekmachines. Door deze integratie kan BabyAGI op het web zoeken naar informatie met betrekking tot taken, waardoor BabyAGI toegang heeft tot een schat aan informatie die verder gaat dan de invoerdocumenten.

De autonome taakcapaciteit van BabyAGI wordt gevoed door een LLM, een vectorzoekdatabase, een API-wrapper voor externe links en het LangChain-framework, waardoor het een breed spectrum aan taken in verschillende domeinen kan uitvoeren. Hierdoor kan het systeem proactief taken uitvoeren op basis van gebruikersinteracties, waardoor de documentverwerkingspijplijn die externe bronnen bevat, wordt gestroomlijnd en een efficiëntere, soepelere ervaring wordt gecreëerd. Het volgende diagram illustreert het taakautomatiseringsproces.

Dit proces omvat de volgende onderdelen:

• Geheugen – Het geheugen slaat alle informatie op die BabyAGI nodig heeft om zijn taken uit te voeren. Dit omvat de taak zelf, evenals eventuele tussentijdse resultaten of gegevens die BabyAGI heeft gegenereerd.
• Uitvoerende agent – De uitvoeringsagent is verantwoordelijk voor het uitvoeren van de taken die in het geheugen zijn opgeslagen. Het doet dit door toegang te krijgen tot het geheugen, de relevante informatie op te halen en vervolgens de nodige stappen te ondernemen om de taak te voltooien.
• Agent voor het maken van taken – De agent voor het maken van taken is verantwoordelijk voor het genereren van nieuwe taken die BabyAGI moet voltooien. Het doet dit door de huidige toestand van het geheugen te analyseren en eventuele hiaten in kennis of begrip te identificeren. Wanneer een hiaat is geïdentificeerd, genereert de agent voor het maken van taken een nieuwe taak die BabyAGI zal helpen dat hiaat op te vullen.
• Taken wachtrij – De taakwachtrij is een lijst van alle taken die aan BabyAGI zijn toegewezen. De taken worden aan de wachtrij toegevoegd in de volgorde waarin ze zijn ontvangen.
• Agent voor taakprioritering – De agent voor taakprioritering is verantwoordelijk voor het bepalen van de volgorde waarin BabyAGI zijn taken moet uitvoeren. Het doet dit door de taken in de wachtrij te analyseren en de taken te identificeren die het belangrijkst of urgent zijn. De taken die het belangrijkst zijn, worden vooraan in de wachtrij geplaatst en de taken die het minst belangrijk zijn, worden achteraan in de wachtrij geplaatst.

Zie de volgende code:

from babyagi import BabyAGI
from langchain.docstore import InMemoryDocstore
import faiss
# Set temperatur=0 to generate the most frequent words, instead of more “poetically free” behavior.
new_query = """
What happened to the First Republic Bank? Will the FED take the same action as it did on SVB's failure? """
# Enable verbose logging and use a fixed embedding size.
verbose = True
embedding_size = 1536 # Using FAISS vector cluster for vectore store
index = faiss.IndexFlatL2(embedding_size)
vectorstore = FAISS(llm_embeddings.embed_query, index, InMemoryDocstore({}), {}) # Choose 1 iteration for demo and 1>N>10 for real. If None, it will loop indefinitely
max_iterations: Optional[int] = 2 # Call bayagi class for task automation
baby_agi = BabyAGI.from_llm(
llm=llm_embedding, vectorstore=vectorstore, verbose=verbose, max_iterations=max_iterations<br />) response = baby_agi({"objective": new_query})

Laten we eens kijken naar de verzamelde taken en hun resultaten van een enkele iteratie, gebruikt voor demonstratiedoeleinden, om het doel te bereiken in antwoord op de vraag van de gebruiker. BabyAGI werkt via een continue cyclus van de volgende stappen:

1. Een agent voor het maken van taken formuleert een nieuwe taak.
2. De nieuwe taak wordt opgenomen in de taakwachtrij.
3. De agent voor taakprioritering stelt de volgorde vast waarin taken moeten worden aangepakt.
4. De run-agent volbrengt de taak.
5. Het resultaat van de taak wordt in het geheugen opgeslagen.
6. De cyclus herhaalt zich.

Dit iteratieve proces stelt BabyAGI in staat om in de loop van de tijd te leren en zich te ontwikkelen. Naarmate het een toenemend aantal taken met succes voltooit, breidt BabyAGI's kennis en begrip van de wereld zich uit. Bijgevolg kan het meer ingewikkelde en geavanceerde taken genereren en efficiënt uitvoeren. Door het aantal iteraties te vergroten, kunt u de uitkomst verbeteren door de takenlijst te reorganiseren, die zich richt op het doel en de uitkomst van voorgaande taken, wat uiteindelijk leidt tot meer relevante en preciezere antwoorden.

Zie de volgende voorbeelduitvoer:

*****TASK LIST*****
1: Make a todo list
*****NEXT TASK*****
1: Make a todo list
> Entering new AgentExecutor chain...
Thought: I need to research the First Republic Bank and the FED's action
Action: Search
Action Input: What happened to the First Republic Bank? Will the FED take the same action as it did on SVB's failure?
Observation: First Republic's failure was due to a run on deposits following the collapse of Silicon Valley Bank and Signature Bank. JPMorgan Chase acquired
First Republic Bank on May 1, 2023. If you had insured or uninsured money in First Republic accounts, your funds are safe and now managed by JPMorgan Chase.
Thought: I need to research the FED's action on SVB's failure
Action: Search
Action Input: What action did the FED take on SVB's failure?
Observation: The Hutchins Center explains how the Federal Reserve has responded to the March 2023 failures of Silicon Valley Bank and Signature Bank.
Thought: I now know the final answer
Final Answer: The FED responded to the March 2023 failures of Silicon Valley Bank and <br />Signature Bank by providing liquidity to the banking system. JPMorgan Chase acquired First Republic Bank on May 1, 2023, and if you had insured or uninsured money in First Republic accounts, your funds are safe and now managed by JPMorgan Chase.
> Finished chain.
*****TASK RESULT*****
The Federal Reserve responded to the March 2023 failures of Silicon Valley Bank and Signature Bank by providing liquidity to the banking system. It is unclear what action the FED will take in response to the failure of First Republic Bank. ***TASK LIST*** 2: Research the timeline of First Republic Bank's failure.
3: Analyze the Federal Reserve's response to the failure of Silicon Valley Bank and Signature Bank.
4: Compare the Federal Reserve's response to the failure of Silicon Valley Bank and Signature Bank to the Federal Reserve's response to the failure of First Republic Bank.
5: Investigate the potential implications of the Federal Reserve's response to the failure of First Republic Bank.
6: Identify any potential risks associated with the Federal Reserve's response to the failure of First Republic Bank.<br />*****NEXT TASK***** 2: Research the timeline of First Republic Bank's failure. > Entering new AgentExecutor chain...
Will the FED take the same action as it did on SVB's failure?
Thought: I should search for information about the timeline of First Republic Bank's failure and the FED's action on SVB's failure.
Action: Search
Action Input: Timeline of First Republic Bank's failure and FED's action on SVB's failure
Observation: March 20: The FDIC decides to break up SVB and hold two separate auctions for its traditional deposits unit and its private bank after failing ...
Thought: I should look for more information about the FED's action on SVB's failure.
Action: Search
Action Input: FED's action on SVB's failure
Observation: The Fed blamed failures on mismanagement and supervisory missteps, compounded by a dose of social media frenzy.
Thought: I now know the final answer.
Final Answer: The FED is likely to take similar action on First Republic Bank's failure as it did on SVB's failure, which was to break up the bank and hold two separate auctions for its traditional deposits unit and its private bank.</p><p>&gt; Finished chain. *****TASK RESULT*****
The FED responded to the March 2023 failures of ilicon Valley Bank and Signature Bank by providing liquidity to the banking system. JPMorgan Chase acquired First Republic Bank on May 1, 2023, and if you had insured or uninsured money in First Republic accounts, your funds are safe and now managed by JPMorgan Chase.*****TASK ENDING*****

Met BabyAGI voor taakautomatisering demonstreerde het dialooggestuurde IDP-systeem zijn effectiviteit door verder te gaan dan de context van het originele document om de vraag van de gebruiker te beantwoorden over de mogelijke acties van de Federal Reserve met betrekking tot het faillissement van de First Republic Bank, dat plaatsvond eind april 2023, 1 maand na de voorbeeldpublicatie, in vergelijking met het falen van de SVB. Om dit te bereiken, genereerde het systeem een ​​takenlijst en voltooide de taken opeenvolgend. Het onderzocht de omstandigheden rond het faillissement van de First Republic Bank, identificeerde mogelijke risico's verbonden aan de reactie van de Federal Reserve en vergeleek deze met de reactie op het faillissement van de SVB.

Hoewel BabyAGI een werk in uitvoering blijft, belooft het een revolutie teweeg te brengen in machine-interacties, inventief denken en probleemoplossing. Naarmate het leren en verbeteren van BabyAGI aanhoudt, zal het in staat zijn om nauwkeurigere, inzichtelijkere en inventievere reacties te produceren. Door machines in staat te stellen autonoom te leren en te evolueren, zou BabyAGI hun hulp kunnen vergemakkelijken bij een breed spectrum aan taken, variërend van alledaagse klusjes tot ingewikkelde probleemoplossing.

Beperkingen en beperkingen

Dialooggestuurde IDP biedt een veelbelovende aanpak om de efficiëntie en effectiviteit van documentanalyse en -extractie te verbeteren. We moeten echter de huidige beperkingen en beperkingen erkennen, zoals de noodzaak om databias te vermijden, hallucinaties te verminderen, de uitdaging van het omgaan met complexe en dubbelzinnige taal, en moeilijkheden bij het begrijpen van de context of het behouden van samenhang in langere gesprekken.

Bovendien is het belangrijk om rekening te houden met verzinsels en hallucinaties in door AI gegenereerde reacties, wat kan leiden tot het creëren van onnauwkeurige of verzonnen informatie. Om deze uitdagingen het hoofd te bieden, richten voortdurende ontwikkelingen zich op het verfijnen van LLM's met betere natuurlijke taalbegrippen, het integreren van domeinspecifieke kennis en het ontwikkelen van robuustere contextbewuste modellen. Het helemaal opnieuw opbouwen van een LLM kan kostbaar en tijdrovend zijn; u kunt echter verschillende strategieën gebruiken om bestaande modellen te verbeteren:

• Verfijning van een vooraf getrainde LLM op specifieke domeinen voor nauwkeurigere en relevantere resultaten
• Integratie van externe gegevensbronnen waarvan bekend is dat ze veilig zijn tijdens inferentie voor beter contextueel begrip
• Het ontwerpen van betere prompts om nauwkeurigere reacties uit het model te halen
• Ensemblemodellen gebruiken om output van meerdere LLM's te combineren, fouten te middelen en de kans op hallucinatie te minimaliseren
• Het bouwen van vangrails om te voorkomen dat modellen in ongewenste gebieden terechtkomen, terwijl ervoor wordt gezorgd dat apps reageren met nauwkeurige en geschikte informatie
• Gesuperviseerde fijnafstemming uitvoeren met menselijke feedback, het model iteratief verfijnen voor meer nauwkeurigheid en minder hallucinaties.

Door deze benaderingen toe te passen, kunnen door AI gegenereerde antwoorden betrouwbaarder en waardevoller worden gemaakt.

De taakgestuurde autonome agent biedt een aanzienlijk potentieel voor verschillende toepassingen, maar het is van vitaal belang om de belangrijkste risico's te overwegen voordat u de technologie toepast. Deze risico's omvatten:

• Inbreuken op gegevensprivacy en beveiliging door afhankelijkheid van de geselecteerde LLM-provider en vectorDB
• Ethische zorgen die voortvloeien uit het genereren van vooringenomen of schadelijke inhoud
• Afhankelijkheid van modelnauwkeurigheid, wat kan leiden tot ineffectieve taakvoltooiing of ongewenste resultaten
• Problemen met systeemoverbelasting en schaalbaarheid als het genereren van taken sneller gaat dan voltooien, waardoor een juiste taakvolgorde en parallel beheer nodig zijn
• Verkeerde interpretatie van taakprioritering op basis van het inzicht van de LLM in taakbelang
• De authenticiteit van de gegevens die het van internet heeft ontvangen

Het aanpakken van deze risico's is cruciaal voor een verantwoorde en succesvolle toepassing, waardoor we de voordelen van door AI aangedreven taalmodellen kunnen maximaliseren en potentiële risico's kunnen minimaliseren.

Conclusies

De dialooggestuurde oplossing voor IDP biedt een baanbrekende benadering van documentverwerking door OCR, automatische spraakherkenning, LLM's, taakautomatisering en externe gegevensbronnen te integreren. Deze uitgebreide oplossing stelt bedrijven in staat om hun documentverwerkingsworkflows te stroomlijnen, waardoor ze efficiënter en intuïtiever worden. Door deze geavanceerde technologieën te integreren, kunnen organisaties niet alleen een revolutie teweegbrengen in hun documentbeheerprocessen, maar ook de besluitvormingsmogelijkheden versterken en de algehele productiviteit aanzienlijk verhogen. De oplossing biedt bedrijven een transformerende en innovatieve manier om het volledige potentieel van hun documentworkflows te benutten, wat uiteindelijk leidt tot groei en succes in het tijdperk van generatieve AI. Verwijzen naar SageMaker-startpagina voor andere oplossingen en Amazonebodem voor extra generatieve AI-modellen.

De auteurs willen Ryan Kilpatrick, Ashish Lal en Kristine Pearce oprecht bedanken voor hun waardevolle input en bijdragen aan dit werk. Ze erkennen ook Clay Elmore voor het codevoorbeeld op Github.

Over de auteurs

Alfred Schen is een Senior AI/ML-specialist bij AWS. Hij heeft in Silicon Valley gewerkt en bekleedde technische en leidinggevende functies in diverse sectoren, waaronder de gezondheidszorg, financiën en hightech. Hij is een toegewijde toegepaste AI/ML-onderzoeker, die zich concentreert op CV, NLP en multimodaliteit. Zijn werk is tentoongesteld in publicaties zoals EMNLP, ICLR en Public Health.

Dr Vivek Madan is een Applied Scientist bij het Amazon SageMaker JumpStart-team. Hij promoveerde aan de Universiteit van Illinois in Urbana-Champaign en was een postdoctoraal onderzoeker bij Georgia Tech. Hij is een actief onderzoeker op het gebied van machine learning en algoritmeontwerp en heeft artikelen gepubliceerd op EMNLP-, ICLR-, COLT-, FOCS- en SODA-conferenties.

Dokter Li Zhang is Principal Product Manager-Technical voor Amazon SageMaker JumpStart en Ingebouwde algoritmen van Amazon SageMaker, een service die datawetenschappers en beoefenaars van machine learning helpt om aan de slag te gaan met het trainen en implementeren van hun modellen en toepassingen versterking van leren met Amazon SageMaker. Zijn eerdere werk als hoofdonderzoeker en hoofduitvinder bij IBM Research heeft de prijs gewonnen test van tijd papier award bij IEEE INFOCOM.

Dr Changsha Ma is AI/ML-specialist bij AWS. Ze is een technoloog met een doctoraat in computerwetenschappen, een masterdiploma in onderwijspsychologie en jarenlange ervaring in datawetenschap en onafhankelijk advies in AI/ML. Ze is gepassioneerd door het onderzoeken van methodologische benaderingen voor machine- en menselijke intelligentie. Buiten haar werk houdt ze van wandelen, koken, op voedsel jagen, studenten begeleiden in ondernemerschap en tijd doorbrengen met vrienden en familie.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoAiStream. Web3 gegevensintelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Koop en verkoop aandelen in PRE-IPO-bedrijven met PREIPO®. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/dialogue-guided-intelligent-document-processing-with-foundation-models-on-amazon-sagemaker-jumpstart/