Jak analizować dokumenty za pomocą LangChain i API OpenAI

Czytelnicy tacy jak Ty pomagają wspierać MUO. Kiedy dokonujesz zakupu za pomocą linków na naszej stronie, możemy otrzymać prowizję partnerską. Przeczytaj więcej.

Wyciąganie wniosków z dokumentów i danych ma kluczowe znaczenie przy podejmowaniu świadomych decyzji. Jednakże w przypadku poufnych informacji pojawiają się obawy dotyczące prywatności. LangChain w połączeniu z OpenAI API umożliwia analizę lokalnych dokumentów bez konieczności przesyłania ich online.

Osiągają to poprzez przechowywanie danych lokalnie, wykorzystanie osadzania i wektoryzacji do analizy oraz wykonywanie procesów w Twoim środowisku. OpenAI nie wykorzystuje danych przesłanych przez klientów za pośrednictwem interfejsu API do szkolenia modeli lub ulepszania usług.

Konfigurowanie środowiska

Utwórz nowe środowisko wirtualne Python. Dzięki temu nie będzie konfliktów wersji bibliotek. Następnie uruchom następujące polecenie terminala, aby zainstalować wymagane biblioteki.

 pip install langchain openai tiktoken faiss-cpu pypdf

Oto zestawienie sposobu korzystania z każdej biblioteki:

LangChain: Będziesz go używać do tworzenia i zarządzania łańcuchami językowymi do przetwarzania i analizy tekstu. Zapewni moduły do ładowania dokumentów, dzielenia tekstu, osadzania i przechowywania wektorów.
OpenAI: Będziesz go używać do uruchamiania zapytań i uzyskiwania wyników z modelu językowego.
tiktok: Użyjesz go do zliczenia liczby tokenów (jednostek tekstu) w danym tekście. Ma to na celu śledzenie liczby tokenów podczas interakcji z interfejsem API OpenAI, który pobiera opłaty w oparciu o liczbę używanych tokenów.
FAISS: Będziesz go używać do tworzenia magazynu wektorów i zarządzania nim, umożliwiając szybkie wyszukiwanie podobnych wektorów na podstawie ich osadzania.
PyPDF: Ta biblioteka wyodrębnia tekst z plików PDF. Pomaga ładować pliki PDF i wyodrębniać ich tekst do dalszego przetwarzania.

Po zainstalowaniu wszystkich bibliotek środowisko jest gotowe.

Uzyskiwanie klucza API OpenAI

Kiedy wysyłasz żądania do API OpenAI, musisz dołączyć klucz API jako część żądania. Ten klucz umożliwia dostawcy API sprawdzenie, czy żądania pochodzą z legalnego źródła i czy masz niezbędne uprawnienia, aby uzyskać dostęp do jego funkcji.

Aby uzyskać klucz API OpenAI, przejdź doPlatforma OpenAI.

Następnie pod profilem swojego konta w prawym górnym rogu kliknijWyświetl klucze API. TheKlucze APIpojawi się strona.

Kliknij theUtwórz nowy sekret klawiszprzycisk. Nazwij swój klucz i kliknijUtwórz nowy tajny klucz. OpenAI wygeneruje Twój klucz API, który powinieneś skopiować i przechowywać w bezpiecznym miejscu. Ze względów bezpieczeństwa nie będziesz mógł go ponownie wyświetlić za pośrednictwem swojego konta OpenAI. Jeśli zgubisz ten tajny klucz, będziesz musiał wygenerować nowy.

Pełny kod źródłowy jest dostępny w formacie aRepozytorium GitHuba.

Importowanie wymaganych bibliotek

Aby móc korzystać z bibliotek zainstalowanych w Twoim środowisku wirtualnym, musisz je zaimportować.

 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

Zwróć uwagę, że importujesz biblioteki zależności z LangChain. Dzięki temu możesz korzystać ze specyficznych funkcji frameworka LangChain.

Ładowanie dokumentu do analizy

Zacznij od utworzenia zmiennej przechowującej klucz API. Użyjesz tej zmiennej w dalszej części kodu do uwierzytelnienia.

 # Hardcoded API key
openai_api_key = "Your API key"

Nie zaleca się kodowania klucza API na stałe, jeśli planujesz udostępniać swój kod stronom trzecim. W przypadku kodu produkcyjnego, który chcesz rozpowszechniać, użyj zamiast tego zmiennej środowiskowej.

Następnie utwórz funkcję ładującą dokument. Funkcja powinna załadować plik PDF lub plik tekstowy. Jeśli dokument nie jest żadnym z nich, funkcja powinna wywołać aBłąd wartości.

 def load_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")

Po załadowaniu dokumentów utwórz plikRozdzielacz tekstu znaków. Ten rozdzielacz podzieli załadowane dokumenty na mniejsze części w oparciu o znaki.

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

Podział dokumentu gwarantuje, że fragmenty będą miały rozsądny rozmiar i nadal będą połączone pewnym nakładającym się kontekstem. Jest to przydatne do zadań takich jak analiza tekstu i wyszukiwanie informacji.

Zapytanie o dokument

Potrzebujesz sposobu, aby wysłać zapytanie do przesłanego dokumentu, aby uzyskać z niego szczegółowe informacje. Aby to zrobić, utwórz funkcję, która przyjmuje azapytaniesznurek i aaporterjako wejście. Następnie tworzyPobieranieQAprzykład za pomocąaporteroraz instancja modelu języka OpenAI.

 def query_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)

Ta funkcja wykorzystuje utworzoną instancję kontroli jakości do uruchomienia zapytania i wydrukowania wyniku.

Tworzenie funkcji głównej

Główna funkcja będzie kontrolować ogólny przebieg programu. Pobiera dane wejściowe użytkownika dotyczące nazwy pliku dokumentu i ładuje ten dokument. Następnie utwórzOpenAIEmbeddingsprzykład osadzania i konstruowania asklep wektorowyna podstawie załadowanych dokumentów iosadzania. Zapisz ten magazyn wektorów w pliku lokalnym.

Następnie załaduj utrwalony magazyn wektorów z pliku lokalnego. Następnie wejdź w pętlę, w której użytkownik może wprowadzać zapytania. Thegłównyfunkcja przekazuje te zapytania dozapytanie_pdffunkcję wraz z modułem pobierania utrwalonego magazynu wektorów. Pętla będzie kontynuowana, dopóki użytkownik nie wybierze „exit”.

 def main():
   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")

Osadzanie rejestruje relacje semantyczne między słowami. Wektory to forma, w której możesz przedstawić fragmenty tekstu.

Ten kod konwertuje dane tekstowe w dokumencie na wektory przy użyciu osadzania wygenerowanego przezOpenAIEmbeddings. Następnie indeksuje te wektory za pomocąFAISS, w celu wydajnego wyszukiwania i porównywania podobnych wektorów. Dzięki temu możliwa jest analiza przesłanego dokumentu.

Na koniec użyj konstrukcji __name__ == „__main__”, aby wywołać funkcję główną, jeśli użytkownik uruchomi program samodzielnie:

 if __name__ == "__main__":
   main()

Ta aplikacja jest aplikacją wiersza poleceń. Jako rozszerzenie możesz użyć Streamlit, aby dodać interfejs sieciowy do aplikacji.

Przeprowadzanie analizy dokumentów

Aby przeprowadzić analizę dokumentu, przechowuj dokument, który chcesz analizować, w tym samym folderze, co projekt, a następnie uruchom program. Zapyta o nazwę dokumentu, który chcesz przeanalizować. Wpisz jego pełną nazwę, następnie wprowadź zapytania dla programu do analizy.

Poniższy zrzut ekranu przedstawia wyniki analizy pliku PDF.

Poniższe dane wyjściowe przedstawiają wyniki analizy pliku tekstowego zawierającego kod źródłowy.

Upewnij się, że pliki, które chcesz analizować, są w formacie PDF lub tekstowym. Jeśli Twoje dokumenty są w innych formatach, możesz je przekonwertować do formatu PDF za pomocą narzędzi online.

Zrozumienie technologii stojącej za dużymi modelami językowymi

LangChain upraszcza tworzenie aplikacji przy użyciu dużych modeli językowych. Oznacza to również, że abstrahuje to, co dzieje się za kulisami. Aby dokładnie zrozumieć, jak działa tworzona aplikacja, powinieneś zapoznać się z technologią stojącą za dużymi modelami językowymi.