Jak analizować dokumenty za pomocą LangChain i OpenAI API

Wyciąganie wniosków z dokumentów i danych ma kluczowe znaczenie dla podejmowania świadomych decyzji. Jednak w przypadku wrażliwych informacji pojawiają się obawy o prywatność. LangChain, w połączeniu z OpenAI API, pozwala analizować lokalne dokumenty bez konieczności przesyłania ich online.

Dzięki lokalnemu przechowywaniu danych, wykorzystywaniu embeddings i wektoryzacji do badania, a także przeprowadzaniu operacji we własnym systemie, OpenAI skutecznie zachowuje prywatność. Co ważne, informacje przesyłane przez klientów za pośrednictwem ich API nie są wykorzystywane do szkolenia modeli ani ulepszania usług.

Konfiguracja środowiska

Aby utworzyć nowe wirtualne środowisko Pythona i zainstalować niezbędne biblioteki, wykonaj następujące kroki:Po pierwsze, utwórz nowe środowisko Pythona, wykorzystując moduł venv dostarczany z Pythonem 3.x. Zapobiegnie to wszelkim problemom z kompatybilnością między różnymi wersjami zainstalowanych pakietów. Aby to zrobić, otwórz terminal lub wiersz polecenia i przejdź do żądanego katalogu, w którym chcesz utworzyć środowisko wirtualne. Następnie wprowadź następujące polecenie:bashpython -m venv myenvZastąp “myenv” preferowaną nazwą środowiska wirtualnego. Następnie aktywuj nowo utworzone środowisko za pomocą polecenia ./bin/activate (w systemie Windows) lub source bin/activate (w systemie macOS lub Linux). Po aktywacji należy przystąpić do instalacji wymaganych bibliotek, uruchamiając polecenie

 pip install langchain openai tiktoken faiss-cpu pypdf 

Wykorzystanie każdej biblioteki można podsumować w następujący sposób:

LangChain to wszechstronne narzędzie zaprojektowane w celu ułatwienia tworzenia i zarządzania łańcuchami lingwistycznymi do różnych zadań przetwarzania i analizy tekstu. Platforma oferuje szereg funkcji, takich jak ładowanie dokumentów, segmentacja tekstu, generowanie osadzania i przechowywanie wektorów, a wszystko to ma na celu usprawnienie operacji związanych z językiem z łatwością i wydajnością.

Ceniona platforma OpenAI daje użytkownikom możliwość wykonywania zapytań i pobierania odpowiedzi z zaawansowanych modeli lingwistycznych, zapewniając cenne źródło dla osób poszukujących wnikliwej analizy lub pomocy.

TikTokoken służy jako narzędzie do ilościowego określania liczby znaków w określonej części tekstu, umożliwiając dokładne rozliczanie wykorzystania tokena podczas interakcji z Open AI API, gdzie opłaty są określane na podstawie ilości wykorzystanego tekstu.

FAISS to wydajne narzędzie, które umożliwia tworzenie i utrzymywanie repozytorium reprezentacji wektorowych, ułatwiając szybki dostęp do podobnie zakodowanych wektorów poprzez ich osadzanie.

PyPDF2 to pakiet Pythona ułatwiający wyodrębnianie tekstu z plików w formacie Portable Document Format (PDF). Oprogramowanie usprawnia proces ładowania dokumentów PDF i umożliwia pobieranie ich zawartości w celu późniejszej manipulacji lub analizy.

Po zakończeniu instalacji wszystkich bibliotek, przestrzeń robocza jest teraz przygotowana i wyposażona w niezbędne narzędzia do rozpoczęcia pracy.

Uzyskiwanie klucza API OpenAI

Aby móc korzystać z usług świadczonych przez API OpenAI, konieczne jest podanie klucza API w zapytaniu. Takie włączenie umożliwia dostawcy API potwierdzenie autentyczności strony żądającej, a także sprawdzenie, czy nadawca posiada wymagane uprawnienia do uzyskania dostępu do dostępnych funkcji.

Aby uzyskać klucz API OpenAI, przejdź do platformy OpenAI .

Aby uzyskać dostęp do kluczy API, przejdź do sekcji Profil znajdującej się w prawym górnym rogu pulpitu nawigacyjnego konta i wybierz opcję “Wyświetl klucze API”. Ta czynność spowoduje natychmiastowe wyświetlenie strony kluczy API w celu dalszego zarządzania.

Kliknij przycisk “Create New Secret Key”, aby rozpocząć proces generowania klucza API do użytku z OpenAI. Po wygenerowaniu klucza należy podać jego nazwę, a następnie kliknąć opcję “Utwórz nowy tajny klucz”, aby zakończyć tworzenie klucza. Ważne jest, aby bezpiecznie zachować wygenerowany klucz API, ponieważ dostęp do niego może nie być dostępny za pośrednictwem konta OpenAI ze względów bezpieczeństwa. W przypadku zgubienia lub utraty tajnego klucza, będziesz musiał utworzyć inny w jego miejsce.

Dostęp do pełnego kodu źródłowego można uzyskać za pośrednictwem repozytorium GitHub, które oferuje użytkownikom możliwość eksploracji i wykorzystania zawartości projektu.

Importowanie wymaganych bibliotek

Aby użytkownik mógł korzystać z pakietów, które zostały zainstalowane w jego wirtualnym środowisku, konieczne jest ich włączenie poprzez importowanie.

 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

Po przeanalizowaniu kodu staje się oczywiste, że proces ten obejmuje importowanie niezbędnych zależności w ramach frameworka LangChain, zapewniając w ten sposób dostęp do szerokiego zakresu funkcjonalności oferowanych przez ten framework.

Wczytywanie dokumentu do analizy

Na początek należy utworzyć zmienną służącą jako repozytorium klucza API. Podmiot ten będzie następnie wykorzystywany w skrypcie do celów walidacji.

 # Hardcoded API key
openai_api_key = "Your API key"

Podczas dystrybucji kodu na poziomie produkcyjnym, który może być udostępniany podmiotom zewnętrznym, zaleca się unikanie włączania poufnych informacji, takich jak klucze API, bezpośrednio do kodu źródłowego. Zamiast wdrażać to podejście, wykorzystanie zmiennej środowiskowej oferuje bezpieczniejsze i bardziej praktyczne rozwiązanie do zarządzania takimi danymi uwierzytelniającymi we współdzielonym kontekście.

Jasne! Oto przykład tego, jak można to zaimplementować w Pythonie przy użyciu biblioteki PyPDF2 do pracy z plikami PDF i wbudowanej funkcji open() do odczytu zwykłych plików tekstowych:pythonimport PyPDF2from io import BytesIOdef load_document(file_path):“““Ładuje dokument z określonej ścieżki pliku.”””# Sprawdź, czy plik istnieje przed próbą jego otwarciatry:if not file_path.endswith(’.pdf’):# Dokument nie jest plikiem PDF, więc zamiast tego spróbuj otworzyć go jako plik tekstowywith open(file_path, ‘r’) as f:return f.read()elif file_path.endswith(’.pdf’):

 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, proces obejmuje utworzenie instancji CharacterTextSplitter . Wspomniany splitter jest odpowiedzialny za podzielenie załadowanej dokumentacji na łatwiejsze do zarządzania części, przy czym każdy podział jest określony przez poszczególne znaki.

    text_splitter = CharacterTextSplitter(chunk_size=1000,
                                          chunk_overlap=30, separator="\n")

   return text_splitter.split_documents(documents=documents)

Przetwarzanie treści na mniejsze, spójne segmenty ułatwia wydajną obsługę i utrzymuje pewien stopień odpowiedniego nakładania się kontekstu, co okazuje się korzystne w przedsięwzięciach takich jak analiza tekstowa i operacje wyszukiwania danych.

Przeszukiwanie dokumentu

Aby wyodrębnić informacje z przesłanego dokumentu, należy opracować funkcję, która akceptuje wyszukiwane hasło wraz z komponentem pobierania danych jako danymi wejściowymi. Funkcja ta będzie wykorzystywać dostarczoną funkcję pobierania w połączeniu z instancją modelu języka naturalnego Open AI w celu utworzenia obiektu RetrievalQA.

 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)

Niniejsza funkcja wykorzystuje instancjonowany model odpowiedzi na pytanie do wykonania zapytania i wyświetlenia wyniku.

Tworzenie funkcji głównej

Funkcja główna zarządza ogólnym postępem programu, akceptując dane wejściowe podane przez użytkownika dla nazwy pliku dokumentu, a następnie ładując określony dokument. Następnie tworzy instancję OpenAIEmbeddings przeznaczoną do osadzania słów i buduje repozytorium wektorów w oparciu o wcześniej przetworzony dokument i odpowiadające mu osadzenia słów. Ostatecznie zbudowana wektorowa baza danych jest zapisywana na lokalnym nośniku danych w postaci pliku.

Po zainicjowaniu warstwy trwałości i załadowaniu wszelkich niezbędnych danych, system przechodzi do fazy iteracyjnej, w której użytkownicy są proszeni o przesyłanie zapytań za pośrednictwem interfejsu tekstowego. Podczas tego procesu podstawowa funkcjonalność jest delegowana do metody query_pdf , która jest wywoływana wraz z odpowiedzialnym repozytorium wektorowym uzyskanym podczas inicjalizacji. Cykl ten trwa w nieskończoność, dopóki użytkownik nie zdecyduje się zakończyć sesji, wpisując słowo “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")

Embeddings zawierają skomplikowane wzajemne powiązania między elementami leksykalnymi, służąc jako abstrakcyjna reprezentacja języka pisanego lub mówionego w formacie numerycznym. Innymi słowy, wektory oferują metodę przedstawiania fragmentów tekstu za pomocą serii wartości liczbowych, umożliwiając w ten sposób obliczeniowe przetwarzanie i analizę danych językowych.

Niniejszy kod przekształca zawartość tekstową w dokumencie w reprezentacje wektorowe wykorzystujące osadzenia utworzone przez OpenAIEmbeddings, a następnie indeksuje te reprezentacje wektorowe za pomocą FAISS (Facebook AI Similarity Search), aby ułatwić szybkie wyszukiwanie i porównywanie podobnych wzorców wektorowych. Umożliwia to analizę przesłanego dokumentu.

Włączenie atrybutu __name__ z odpowiadającą mu wartością "__main__" jest niezbędnym krokiem do wykonania głównej funkcji, gdy skrypt jest uruchamiany jako samodzielny program. Zastosowanie tej konstrukcji pozwala na płynne wykonanie głównej funkcji po interakcji użytkownika bez konieczności zewnętrznych monitów lub interwencji.

 if __name__ == "__main__":
   main() 

Ten program działa jako narzędzie terminalowe. Jako rozszerzenie można zastosować Streamlit, aby włączyć graficzny interfejs użytkownika do aplikacji przez Internet.

Wykonywanie analizy dokumentów

Aby wykonać analizę dokumentu, umieść dokument, który zamierzasz zbadać w katalogu swojego projektu, a następnie uruchom aplikację. System poprosi o identyfikację konkretnego dokumentu, który ma zostać przeanalizowany, za pomocą monitu o wprowadzenie jego pełnego oznaczenia. Następnie należy podać serię terminów zapytania, które narzędzie ma przetworzyć podczas procedury badania.

Graficzna reprezentacja przedstawiona w niniejszym dokumencie przedstawia wyniki uzyskane podczas przetwarzania pliku Portable Document Format (PDF), jak pokazano na zrzucie ekranu znajdującym się pod tym oświadczeniem.

Poniższa ilustracja przedstawia wyniki analizy dokumentu zawierającego kod programistyczny.

Aby zapewnić dokładną analizę żądanych plików, ważne jest, aby były one w formacie PDF lub tekstowym. Jeśli dokumenty są w alternatywnych typach plików, dostępne są różne zasoby online do konwersji tych plików do odpowiedniego formatu PDF w celu dokładnego zbadania i interpretacji.

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

LangChain usprawnia proces tworzenia aplikacji wykorzystujących zaawansowane możliwości języka naturalnego, abstrahując od złożonych kwestii technicznych, pozwalając użytkownikom skupić się na zamierzonej funkcjonalności bez zbytniego zagłębiania się w zawiłości modelowania języka opartego na sztucznej inteligencji. Ważne jest, aby mieć kompleksowe zrozumienie podstawowych technologii, które umożliwiają te modele, aby w pełni zrozumieć działanie konkretnej opracowywanej aplikacji.