Open in app

Sign in

Write

Sign in

3 Maneiras simples de aplicar LLMs

Gabriel Kotani
casasbahiatech
Published in
6 min readAug 9, 2023

Modelos de linguagem grandes (LLMs) são um tipo de inteligência artificial (IA) que foram treinados com conjuntos de dados massivos de texto e código. Isso permite que eles executem uma variedade de tarefas, incluindo análise de código, perguntas e respostas com documentos e texto generativo.

Então… qual é a diferença?

O que torna os LLMs tão poderosos é sua capacidade de aprender com uma grande quantidade de dados. Isso permite que eles desenvolvam uma compreensão profunda da linguagem e como ela é usada. Como resultado, eles podem executar tarefas que seriam difíceis ou impossíveis para modelos de linguagem menores.

Aqui estão algumas das coisas que os LLMs podem fazer que os modelos de linguagem menores não podem:

— Gerar textos mais criativos e informativos.
— Responder à perguntas de forma mais inteligente.
— Resumir textos de forma mais concisa.

À medida que os LLMs continuam a se desenvolver, é provável que se tornem ainda mais poderosos e versáteis. Isso abrirá novas possibilidades para seu uso em uma ampla gama de aplicações.

Os LLMs podem ser usados ​​para uma gama mais ampla de tarefas do que modelos de linguagem menores.

3 maneiras de aplicar LLMs

Análise de código

Qualidade é muito importante para as equipes de desenvolvedores entregarem projetos, mas quando pressionados pelo tempo de entrega, a qualidade e a confiabilidade podem ser afetadas quando você precisa inspecionar manualmente o código. Os LLMs podem ser usados ​​para analisar o código em busca de erros, vulnerabilidades de segurança e sugerir melhorias.
Por exemplo, um LLM pode ser usado por desenvolvedores para iniciar um projeto com base nas diretrizes da empresa e nas ferramentas comumente usadas.

Document QA

Pode ser difícil procurar manualmente uma diretriz específica da empresa em um mar de documentos. Os LLMs podem responder a perguntas sobre documentos em segundos! Por exemplo, um LLM pode ser usado para responder a perguntas sobre um contrato legal lendo o contrato e compreendendo o significado do texto.

Chat Bots

Os chatbots geralmente são limitados na quantidade de conhecimento que possuem. Isso pode dificultar a resposta a perguntas complexas ou o fornecimento de suporte abrangente.

Incapacidade de entender o contexto: os chatbots também podem ter dificuldade em entender o contexto de uma conversa. Isso pode levar a mal-entendidos e frustração tanto para o usuário quanto para o chatbot.

No geral, os LLMs têm o potencial de melhorar significativamente os recursos dos chatbots. Eles podem tornar os chatbots mais informados, mais conscientes do contexto e mais naturais em suas conversas com os usuários. Isso pode levar a uma série de benefícios para as empresas, incluindo melhor atendimento ao cliente, maior produtividade e custos reduzidos.

Hora de praticar!

Vamos construir um aplicativo de perguntas e respostas

Se você ainda não ouviu falar do HuggingFace, vai se surpreender! Usaremos seus Transformers e SentenceTransformer para carregar modelos LLM pré-treinados, e a melhor parte é que eles são de código aberto!

# requirements.txt

transformers==4.31.0
sentencepiece==0.1.99
sentence-transformers==2.2.2
pyarrow==12.0.1
gradio==3.38.0

Crie um requirements.txt com o conteúdo acima e instale-o com o comando:

pip install -r requirements.txt

Versão A:

Modelo simples de QA:
Crie um arquivo main.py:

# main.py

from transformers import T5Tokenizer, T5ForConditionalGeneration

def askQuestion(question: str) -> str:
  """Passes a sentence to the model"""

  tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-base")
  model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-base")
  input_ids = tokenizer(question, return_tensors="pt", add_special_tokens=False).input_ids
  outputs = model.generate(input_ids, max_new_tokens=50)
  result = tokenizer.decode(outputs[0], skip_special_tokens=True)

  return result

askQuestion("Translate this to French: The black cat ate the apple")
  1. Passamos nossa sentença, para um tokenizer, que converterá o texto em tokens para nosso modelo.
  2. Então podemos passar esses tokens para nosso modelo, que prevê a próxima palavra e retorna uma lista de tokens.
  3. Só precisamos convertê-los de volta em texto legível.

Pros e Cons:

Prós : ferramenta poderosa que é simples de usar e instalar.

Cons :
* Não conhece novas informações.
* Comprimento de contexto limitado (consulte https://arxiv.org/abs/2306.15595 para entender por que isso é importante).

Versão B:

Agora precisamos adicionar MAIS contexto.
Crie um arquivo documentVDB.py:

# documentVDB.py

import pandas as pd
import numpy as np
import os
from sentence_transformers import SentenceTransformer, util

class VDatabase():
  def __init__(
  self, 
  db_file_path: str = 'data/embeddings.parquet.gzip'
  ) -> None:

  self.db_file_path = db_file_path
  self.model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

  if os.path.isfile(db_file_path):
    self.db = pd.read_parquet(db_file_path)
  else:
    self.db = pd.DataFrame()
    self.save()

  def save(self):
    """Save to a parquet file""" 

    self.db.to_parquet(
      self.db_file_path,
      compression='gzip'
    )

def computeSimilarity(
  self, 
  embedding_1: np.ndarray, 
  embedding_2: np.ndarray
  ) -> np.Float64:
  """Compute Cosine similiary""" 

  similiarity = util.pytorch_cos_sim(embedding_1, embedding_2)
  return similiarity.numpy()[0][0]

def search(self, sentence: str) -> str:
  """Returns a document path in our VectorDatabase,
    with the highest similiarity score to the passed sentence""" 

  embedding = self.model.encode(sentence, convert_to_tensor=True)
  scores = {}

  for (colname, document_embedding) in self.db.items():
    scores[colname] = self.computeSimilarity(embedding, document_embedding.values)
    sorted_scores = sorted(scores, key=scores.get, reverse=True)
    return sorted_scores[0]

def vectorizeTextDocument(self, document: str) -> None:
  """Adds the embeddings of a document""" 

  with open(document, 'r') as f:
    context = f.read()

  embedding = self.model.encode(context, convert_to_tensor=True)
  self.db[document] = embedding.numpy()
  self.save()

def vectorizeDir(self, dir_path: str) -> None:
  """Adds the embeddings of all documents in a directory"""

  assert os.path.isdir(dir_path), "Not a directory"
  files = os.listdir(dir_path)
  text_files = [os.path.join(dir_path, file) for file in files if '.txt' in file]
  for document in text_files:
    self.vectorizeTextDocument(document)

Simplificando, isso nos ajudará a criar uma simulação de um VectorDatabase. Ele usa um modelo adicional para calcular os embeddings e CosineSimilarity para “ver quão semelhantes” dois embeddings são entre si. Há também algumas funções auxiliares.

Vamos atualizar nosso main.py:

# main.py

from transformers import T5Tokenizer, T5ForConditionalGeneration
from documentVDB import VDatabase

def start(vectorDB: VDatabase) -> None:
  
  """Will populate our DB with embeddings 
  from text files in the /data directory.""" 

  vectorDB.vectorizeDir('data')

def askQuestion(question: str) -> str:
  """Passes a sentence to the model"""

  tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-base")
  model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-base")

  vectorDB = VDatabase()
  start(vectorDB)
  best_context_file = vectorDB.search(question)

  with open(best_context_file, 'r') as f:
    context = f.read()
  
  template = f"""Use the following pieces of context to answer the question at the end. 
    If you don't know the answer, just say that you don't know, don't try to make up an answer. 
    Use three sentences maximum and keep the answer as concise as possible. 
    {context}
    Question: {question}
    Helpful Answer:"""

  input_ids = tokenizer(template, return_tensors="pt", add_special_tokens=False).input_ids
  outputs = model.generate(input_ids, max_new_tokens=50)
  result = tokenizer.decode(outputs[0], skip_special_tokens=True)
  return result

Vamos também construir uma interface do usuário simples para fazer nossas perguntas:

# app.py

import json
from main import askQuestion
import gradio as gr
import requests

def ml(question: str) -> str:
  return askQuestion(question, echo=False)

demo = gr.Interface(fn=ml, 
  inputs=["text"], 
  outputs="text"
)

if __name__ == "__main__":
  demo.launch()

EXECUTE usando:

python app.py

Como funciona o banco de dados de vetores?

Um banco de dados de Vetores armazenam embeddings de documentos, em vez do texto. Essas incorporações contêm o contexto do documento, representado por um vetor.
Com esse banco de dados, podemos fazer um embedding de nossa pergunta e executar uma função de similaridade para encontrar o documento com o contexto mais semelhante, o que pode ajudar o LLM a encontrar uma resposta.
Usamos um pequeno truque do LangChain AI para passar o contexto de um documento para o LLM.

Frameworks:

Langchain AI é um framework open source para desenvolver aplicativos alimentados por LLMs, que nos ajuda a conectar modelos de linguagem, fontes de dados e bancos de dados vetoriais.

LLamaIndex é outra framework open source para criar aplicativos baseados em LLM, criados pela comunidade.

Banco de dados de vetores:

PostgreSQL é a opção popular de banco de dados para um banco de dados de vetores open source, devido à sua capacidade de armazenar os embeddings naturalmente.

Pinecone é a alternativa SaaS para um banco de dados de vetores pronto para uso, que implementa seu próprio algoritmo de busca por similaridade.

Algoritmos de busca:

Faiss é uma biblioteca open source desenvolvida pela Meta, com um algoritmo eficiente de busca por similaridade. Ele usa o PostgreSQL para armazenamento.

ScaNN é outra biblioteca open source para um algoritmo de busca de similaridade eficiente, mas desta vez foi desenvolvido pelo Google.

Resumindo:

LLMs são ferramentas poderosas que podem melhorar muitos aspectos do nosso trabalho. Com um pouco de engenharia, podemos aproveitar todo o seu potencial conectando-nos a casos de negócios do mundo real.

Espero que você tenha achado esta postagem do blog informativa. Se você tiver alguma dúvida ou quiser ir mais afundo com as etapas do treinamento, deixe um like ou um comentário abaixo.

Referências

Llm
Data Science
Mlops
AI

--

--

Gabriel Kotani
casasbahiatech

Written by Gabriel Kotani

4 Followers
Writer for

ML Engineer Working on NLP and Image DNNs

Help

Status

About

Careers

Press

Blog

Privacy

Terms

Text to speech

Teams