Criar uma IA treinada em milhares de padrões de material circulante pode parecer uma tarefa assustadora, mas com o poder do Python e da biblioteca Langchain, isso pode ser feito em apenas algumas linhas de código. Aqui, gostaríamos de mostrar dois métodos diferentes: load_qa_chain (menos linhas usam muitos tokens) e retriveal_qa_chain (mais código usa menos token). Os passos iniciais são semelhantes:

Configurando o ambiente

Primeiro, vamos configurar nosso ambiente instalando os pacotes necessários e importando os módulos necessários. Estaremos usando os módulos Langchain e OpenAI, bem como outras ferramentas úteis para processamento de texto e indexação. Aqui estão as linhas de código para fazer isso:

!pip install -q langchain openai chromadb tiktoken pypdf
import os
os.environ["OPENAI_API_KEY"] = "your openai API key here"
from langchain.chains import RetrievalQA #-> for retrieval QA
from langchain.chains.question_answering import load_qa_chain #-> for load QA 
from langchain.indexes import VectorstoreIndexCreator #-> for retrieval QA using vectors index creator. it uses fewer codes with less tokens. So I think this is the best way.

from langchain.document_loaders import TextLoader, PyPDFLoader, DataFrameLoader #-> types of data loader
from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter #-> to splits data to chunks

from langchain.embeddings import OpenAIEmbeddings #embeddings
from langchain.vectorstores import Chroma #to create a db of chunks

from langchain.llms import OpenAI #-> for Large Language Model

import pandas as pd
import numpy as np

Estaremos usando um Pandas DataFrame para armazenar os padrões e filtrá-los com base em uma palavra-chave. Aqui está o código para fazer isso:

df = pd.read_pickle('./standards.pkl')
df['num_chars'] = df['text'].apply(lambda x: len(x))
df = df[df['num_chars'] != 0]

# Choose a topic
keyword = "bogie"

# Filter by keyword
filtered_std = df[df['text'].str.contains(keyword)]

loader = DataFrameLoader(filtered_std, page_content_column="name")

CARREGAR CADEIA DE QA

Agora que temos nosso carregador de documentos, podemos carregar nossa cadeia de controle de qualidade e executar uma consulta. Estaremos usando a função load_qa_chain do Langchain para carregar nossa cadeia QA e o módulo OpenAI para nosso modelo de linguagem. Na cadeia QA, temos a opção de escolher o tipo de cadeia: stuff, map_reduce, refine, map_rerank. explicação veja aqui

Aqui está o código para fazer isso:

chain = load_qa_chain(llm=OpenAI(), chain_type="map_reduce")
query ="what is a bogie?"
chain.run(input_documents=loader.load(), question=query)

' Um bogie é um chassi ou estrutura que transporta rodas, preso a um veículo, servindo assim como um subconjunto modular de rodas e eixos, ou um vagão ou carrinho com rodas, geralmente montado em pares, que suporta a carroceria de um veículo ferroviário e permite o giro movimento relativo aos trilhos principais.'

Recuperação QA CHAIN

Em seguida, usaremos o módulo RetrievalQA da Langchain para criar um sistema de QA baseado em recuperação. Primeiro, vamos dividir nossos documentos em partes menores usando o RecursiveCharacterTextSplitter do Langchain. Em seguida, criaremos embeddings usando o OpenAIEmbeddings do Langchain e um índice usando o módulo Chroma do Langchain. Na verdade, existem maneiras de incorporar que você pode usar, para mais opções, veja aqui . Por fim, criaremos um recuperador usando nosso índice e a função as_retriever do Langchain. Aqui está o código para fazer isso:

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size = 10000,
    chunk_overlap  = 200,
    length_function = len,
)
texts = text_splitter.split_documents(loader.load())

embeddings = OpenAIEmbeddings(model="ada")

db = Chroma.from_documents(texts, embeddings)

retriever = db.as_retriever(search_type="similarity", search_kwargs={"k":5})

from langchain.chains.question_answering import load_qa_chain
qa = RetrievalQA.from_chain_type(
    llm=OpenAI(), chain_type="map_reduce", retriever=retriever, return_source_documents=False)

query = "what are the parameters of a bogie that has to be complied?"
result = qa({"query": query})
result['result']

' O bogie deve atender aos seguintes parâmetros: distância entre eixos, espaçamento entre rodas, bitola, balanço, diâmetro e largura da roda, raio de giro e distância central do bogie, largura, raio de curvatura e distância entre os pivôs do bogie, largura, base do eixo, distância entre eixos , balanço mínimo, balanço máximo, distância entre centros de pivô do bogie, altura da estrutura do bogie acima da superfície do trilho, altura da estrutura do bogie acima do topo do trilho, altura da estrutura do bogie abaixo da parte inferior do trilho, altura da estrutura do bogie abaixo da superfície do trilho , distância mínima entre a superfície do carril e a parte inferior da estrutura do bogie, distância mínima entre a superfície do carril e a parte superior da estrutura do bogie, distância mínima entre a estrutura do bogie e a aba inferior do carril, massa máxima de 10 toneladas , largura máxima de 2,7m, altura máxima de 3,7m e comprimento máximo de 9m.'

Então, o que você acha? imagine se essa IA fosse aplicada a outros setores como direito, médico, etc. As possibilidades são ilimitadas.