Framework do tworzenia aplikacji opartych na modelach językowych.

Jak zainstalować i skonfigurować środowisko dla LangChain?

Zainstaluj Langchaina.

!pip install langchain

Pomyśl o LangChain jako o pomoście, dzięki któremu LLM są dostępne dla programistów. Tak więc LangChain zwykle wymaga integracji z jednym lub kilkoma dostawcami modeli, magazynami danych, interfejsami API itp.
Konieczne jest skonfigurowanie środowiska dla dostawcy, a do wyboru jest wielu dostawców.

Tak więc wszystkie z nich wymagają ustawienia środowiska przed użyciem ich modelu. Skonfigurujmy więc jeden, pip zainstaluj dowolny LLM z dostępnego w LangChain. Następnie idź dalej i stwórz środowisko.

pip install openai
import os
os.environ["OPENAI_API_KEY"] = "hshhhtotogjgjkhk"

Modele językowe zwykle przyjmują tekst jako dane wejściowe, tekst ten jest określany jako zachęta. Szablony monitów w Langchain zostały stworzone, aby ułatwić konstruowanie podpowiedzi z dynamicznymi danymi wejściowymi.

from langchain import PromptTemplate
template = """ hdhfkfgdvjkdkdld             
sdhjdllgllhllkhkhk               #pass prompt of your chosing here .
llsldpppeppptoyoouououp {uio}""" 
prompt = PromptTemplate(input_variables=["uio"],template=template)

Jest to jedna z kluczowych cech LangChain — pozwala łączyć ze sobą wiele LLM i Prompts.

Ta zdolność do łączenia wielu komponentów w jedną całość może się przydać, gdy możemy utworzyć łańcuch, który przyjmuje dane wejściowe użytkownika, formatuje je za pomocą szablonu PromptTemplate, a następnie przekazuje sformatowaną odpowiedź do LLM.
Dostępne są więc różne łańcuchy: proste łańcuchy LLM, łańcuchy związane z indeksem, a także mogą tworzyć niestandardowe łańcuchy.

from langchain import LLMChain
llmchain=LLMChain(prompt=prompt,llm=llm)
question ="-----------" #pass a question of your chosing here .
print(llmchain.run(question))

Istnieją różne łańcuchy, których można użyć w określonych scenariuszach w ramach łańcuchów:

Agenci używają LLM, aby określić, które działania należy podjąć iw jakiej kolejności. Akcją może być użycie narzędzia i obserwowanie jego wyników lub powrót do użytkownika.

Aby osiągnąć ten wynik, musimy rozróżnić narzędzia i LLM, które są używane do zadania agentów. Więc, Narzędzie jest funkcją spełniającą określone zadanie. Mogą to być takie rzeczy jak: wyszukiwarka Google, wyszukiwanie w bazie danych, Python REPL, Wikipedia, ChatGPTPlugin i inne łańcuchy. LLM jest modelem językowym zasilającym agenta.

Obecnie agenci mają cztery różne typy:
zero-shot-react-description , react-docstore ,self-ask-with-search , conversational-react-description .

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.llms import OpenAI
llm = OpenAI(temperature=0)
tools = load_tools(["wikipedia", "llm-math"], llm=llm) #!pip install wikipedia for this 
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("--------------") #put the question in here . 

Domyślnie łańcuchy i agenci są bezstanowi, tzn. niezależnie traktują każde przychodzące zapytanie/podpowiedź. Na przykład chatboty, które nie mają możliwości zapamiętywania niczego.

Bardzo ważne jest pamiętanie o wcześniejszych interakcjach, zarówno krótkoterminowych, jak i długoterminowych. Koncepcja „pamięci” istnieje właśnie po to.

Tutaj za każdym razem, gdy wprowadzasz dane do pliku konwersacja.predict (input=” ”) model odpowie z odpowiednimi informacjami. A kiedy podano inne dane wejściowe rozmowa.przewidywanie model będzie miał tendencję do zapamiętywania poprzednich danych wejściowych i udzielania odpowiedzi, uwzględniając również związek z poprzednimi danymi wejściowymi.

from langchain.llms import OpenAI
from langchain.chains import ConversationChain
llm = OpenAI(temperature=0)
conversation = ConversationChain(llm=llm,verbose=True)
conversation.predict(input="-----------")

Łączenie modeli językowych z własnymi danymi tekstowymi to skuteczny sposób na ich rozróżnienie. Pierwszym krokiem w tym celu jest załadowanie danych do „Dokumentów” — fantazyjnego sposobu na powiedzenie niektórych fragmentów tekstu. Ładowarka dokumentów ma to ułatwić.

Zasadniczo możesz przesłać swoje dokumenty tekstowe i sprawić, by model działał na nich tak, jakby to były podane dane wejściowe.

Są one szeroko stosowane, ale obsługują również usługi w chmurze Notions, Obsidian, GCP, AWS, Git i Figma jako zastrzeżony zbiór danych.

from langchain.document_loaders.csv_loader import CSVLoader
loader = CSVLoader(file_path='---------.csv')
data = loader.load()

Aby programy ładujące dokumenty działały wydajnie, potrzebują indeksów, ponieważ indeksy lepiej porządkują pliki, aby modele były interaktywne.

Indeksy odnoszą się do sposobów strukturyzowania dokumentów, tak aby LLM mogły z nimi najlepiej współdziałać. Ten moduł zawiera funkcje narzędziowe do pracy z dokumentami.

Aby przeprowadzić ten proces, należy zrozumieć 3 rzeczy:
Osadzenia— Jest numeryczną reprezentacją użytego pliku/dokumentu/dźwięku.
Rozdzielacze tekstu — Gdy mamy do czynienia z dużymi plikami, konieczne jest podzielenie ich na mniejsze fragmenty.
Sklepy wektorowe — Te osadzenia wektorów przechowują i indeksują z zastosowanego modelu NLP.

Pobierz program ładujący dokumenty, aby załadować plik wejściowy, a następnie podziel załadowany plik za pomocą rozdzielacza tekstu.

from langchain.text_splitter import CharacterTextSplitter
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

Następnie skonfiguruj osadzenia, czasami mogą wymagać zainstalowania pakietów innych firm, więc zrób to. Tutaj zainstalowany sent_transformer dla tego zadania.

from langchain.embeddings import HuggingFaceEmbeddings 
embeddings = HuggingFaceEmbeddings()

Następnie skonfiguruj sklep wektorowy, jest wiele do wyboru z wielu dostępnych usług w długim łańcuchu.
Zadaj dowolne pytanie związane z przesłanym dokumentem/plikiem i pozwól modelowi wyszukać informacje za Ciebie.

from langchain.vectorstores import FAISS
db = FAISS.from_documents(texts, embeddings)
query = "--------------"
qa.run(query)
qa.similarity_seacrh(query) # finds similiar content as the query from the doc .

To jest LangChain i jego ważne cechy.