Hur man analyserar dokument med LangChain och OpenAI API

Att extrahera insikter från dokument och data är avgörande för att fatta välgrundade beslut. Däremot uppstår integritetsproblem vid hantering av känslig information. LangChain, i kombination med OpenAI API, låter dig analysera dina lokala dokument utan att behöva ladda upp dem online.

De uppnår detta genom att hålla dina data lokalt, använda inbäddningar och vektorisering för analys och exekvera processer i din miljö. OpenAI använder inte data som lämnas in av kunder via deras API för att träna sina modeller eller förbättra sina tjänster.

Ställa in din miljö

Skapa en ny virtuell Python-miljö. Detta säkerställer att det inte finns några biblioteksversionskonflikter. Kör sedan följande terminalkommando för att installera de nödvändiga biblioteken.

pip install langchain openai tiktoken faiss-cpu pypdf

Här är en uppdelning av hur du kommer att använda varje bibliotek:

• LangChain: Du kommer att använda den för att skapa och hantera språkkedjor för textbearbetning och analys. Det kommer att tillhandahålla moduler för dokumentladdning, textdelning, inbäddningar och vektorlagring.
  instagram viewer
• OpenAI: Du kommer att använda den för att köra frågor och få resultat från en språkmodell.
• tiktoken: Du kommer att använda den för att räkna antalet tokens (textenheter) i en given text. Detta för att hålla reda på antalet token när du interagerar med OpenAI API som tar betalt baserat på antalet tokens du använder.
• FAISS: Du kommer att använda den för att skapa och hantera ett vektorlager, vilket möjliggör snabb hämtning av liknande vektorer baserat på deras inbäddningar.
• PyPDF: Det här biblioteket extraherar text från PDF-filer. Det hjälper till att ladda PDF-filer och extraherar deras text för vidare bearbetning.

När alla bibliotek är installerade är din miljö nu klar.

Skaffa en OpenAI API-nyckel

När du gör förfrågningar till OpenAI API måste du inkludera en API-nyckel som en del av begäran. Denna nyckel låter API-leverantören verifiera att förfrågningarna kommer från en legitim källa och att du har nödvändiga behörigheter för att komma åt dess funktioner.

För att få en OpenAI API-nyckel, fortsätt till OpenAI-plattform.

Klicka sedan på under ditt kontos profil uppe till höger Visa API-nycklar. De API-nycklar sidan kommer att visas.

Klicka på Skapa ny hemlighetnyckel knapp. Namnge din nyckel och klicka på Skapa ny hemlig nyckel. OpenAI kommer att generera din API-nyckel som du bör kopiera och förvara någonstans säkert. Av säkerhetsskäl kommer du inte att kunna se den igen via ditt OpenAI-konto. Om du tappar bort den här hemliga nyckeln måste du skapa en ny.

Den fullständiga källkoden finns tillgänglig i en GitHub-förråd.

Importera de obligatoriska biblioteken

För att kunna använda biblioteken som är installerade i din virtuella miljö måste du importera dem.

from langchain.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

Lägg märke till att du importerar beroendebiblioteken från LangChain. Detta gör att du kan använda specifika funktioner i LangChain-ramverket.

Laddar dokumentet för analys

Börja med att skapa en variabel som innehåller din API-nyckel. Du kommer att använda denna variabel senare i koden för autentisering.

# Hardcoded API key
openai_api_key = "Your API key"

Det rekommenderas inte att hårdkoda din API-nyckel om du planerar att dela din kod med tredje part. För produktionskod som du vill distribuera, använd en miljövariabel istället.

Skapa sedan en funktion som laddar ett dokument. Funktionen ska ladda en PDF eller en textfil. Om dokumentet inte är någondera, bör funktionen höja a ValueError.

defload_document(filename):
if filename.endswith(".pdf"):
 loader = PyPDFLoader(filename)
 documents = loader.load()
elif filename.endswith(".txt"):
 loader = TextLoader(filename)
 documents = loader.load()
else:
raise ValueError("Invalid file type")

När du har laddat dokumenten skapar du en CharacterTextSplitter. Denna splitter delar upp de laddade dokumenten i mindre bitar baserat på tecken.

 text_splitter = CharacterTextSplitter(chunk_size=1000, 
 chunk_overlap=30, separator="\n")
return text_splitter.split_documents(documents=documents)

Att dela upp dokumentet säkerställer att bitarna har en hanterbar storlek och fortfarande är kopplade till något överlappande sammanhang. Detta är användbart för uppgifter som textanalys och informationssökning.

Fråga efter dokumentet

Du behöver ett sätt att fråga det uppladdade dokumentet för att få insikter från det. För att göra det, skapa en funktion som tar en fråga snöre och en retriever som input. Det skapar sedan en RetrievalQA instans med hjälp av retriever och en instans av OpenAI-språkmodellen.

defquery_pdf(query, retriever):
 qa = RetrievalQA.from_chain_type(llm=OpenAI(openai_api_key=openai_api_key),
 chain_type="stuff", retriever=retriever)
 result = qa.run(query)
 print(result)

Den här funktionen använder den skapade QA-instansen för att köra frågan och skriva ut resultatet.

Skapa huvudfunktionen

Huvudfunktionen kommer att styra det övergripande programflödet. Det kommer att kräva användarinmatning för ett dokumentfilnamn och ladda det dokumentet. Skapa sedan en ÖppnaAIE-inbäddningar exempel för inbäddningar och konstruktion en vektor butik baserat på de laddade dokumenten och inbäddningar. Spara denna vektorbutik till en lokal fil.

Ladda sedan det kvarstående vektorarkivet från den lokala filen. Ange sedan en loop där användaren kan mata in frågor. De huvud funktionen skickar dessa frågor till fråga_pdf funktion tillsammans med den kvarstående vektorbutikens retriever. Slingan kommer att fortsätta tills användaren går in i "exit".

defmain():
 filename = input("Enter the name of the document (.pdf or .txt):\n")
 docs = load_document(filename)
 embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
 vectorstore = FAISS.from_documents(docs, embeddings)
 vectorstore.save_local("faiss_index_constitution")
 persisted_vectorstore = FAISS.load_local("faiss_index_constitution", embeddings)
 query = input("Type in your query (type 'exit' to quit):\n")
while query != "exit":
 query_pdf(query, persisted_vectorstore.as_retriever())
 query = input("Type in your query (type 'exit' to quit):\n")

Inbäddningar fångar semantiska relationer mellan ord. Vektorer är en form där du kan representera bitar av text.

Denna kod omvandlar textdata i dokumentet till vektorer med hjälp av inbäddningar som genereras av ÖppnaAIE-inbäddningar. Den indexerar sedan dessa vektorer med hjälp av FAISS, för effektiv hämtning och jämförelse av liknande vektorer. Detta är vad som möjliggör analysen av det uppladdade dokumentet.

Slutligen, använd __name__ == "__main__"-konstruktionen för att anropa huvudfunktionen om en användare kör programmet fristående:

if __name__ == "__main__":
 main()

Denna app är en kommandoradsapplikation. Som en förlängning kan du använd Streamlit för att lägga till ett webbgränssnitt till appen.

Utföra dokumentanalys

För att utföra dokumentanalys, lagra dokumentet du vill analysera i samma mapp som ditt projekt och kör sedan programmet. Det kommer att fråga efter namnet på dokumentet du vill analysera. Ange dess fullständiga namn och ange sedan frågor som programmet ska analysera.

Skärmdumpen nedan visar resultaten av att analysera en PDF.

Följande utdata visar resultaten av att analysera en textfil som innehåller källkod.

Se till att filerna du vill analysera är i antingen PDF- eller textformat. Om dina dokument är i andra format kan du konvertera dem till PDF-format med hjälp av onlineverktyg.

Förstå tekniken bakom stora språkmodeller

LangChain förenklar skapandet av applikationer med hjälp av stora språkmodeller. Detta betyder också att det abstraherar vad som händer bakom kulisserna. För att förstå exakt hur applikationen du skapar fungerar bör du bekanta dig med tekniken bakom stora språkmodeller.