[Projeto] Com algums modificações de bibliotecas e modelo rodou bonitinho

!pip install langchain langchain-google-genai sentence-transformers scikit-learn langchain-community

import os
import time
import numpy as np
from google.colab import userdata

os.environ["GOOGLE_API_KEY"] = userdata.get('GEMINI_API_KEY_TEMP')


from langchain_google_genai import GoogleGenerativeAIEmbeddings
from langchain_community.embeddings import HuggingFaceEmbeddings
from sklearn.metrics.pairwise import cosine_similarity
import time

# Textos de exemplo para nosso teste
textos_teste = [
    "Qual é a política de férias da nossa empresa?",
    "Preciso de um relatório de despesas de viagem.",
    "Como configuro o acesso à rede privada virtual (VPN)?",
    "Onde encontro o código de conduta da organização?",
    "Quero entender o processo de avaliação de performance."
]

## Google Gemnini Embeddings

gemini_embeddings = GoogleGenerativeAIEmbeddings(model="gemini-embedding-001", output_dimensionality=768)

start_time = time.time()
embeddings_gemini = gemini_embeddings.embed_documents(textos_teste) #você pode otimizar aqui para tipos de tarefa, como retrieval, classificatrion, Q&A, clustering, semantica similarity
end_time = time.time()

print(f"Tempo de processamento: {end_time - start_time} segundos")
print(f"  - Dimensões do vetor: {len(embeddings_gemini[0])}")


minilm_embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
start_time = time.time()
embeddings_minilm = minilm_embeddings.embed_documents(textos_teste)
end_time = time.time()

print(f"Tempo de processamento: {end_time - start_time} segundos")
print(f"  - Dimensões do vetor: {len(embeddings_minilm[0])}")

print(f"  - Dimensões do vetor: {len(embeddings_minilm[0])}")



#embeddings_minilm

# BGE-Large

bge_embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-large-en-v1.5")


start_time = time.time()
embeddings_bge = bge_embeddings.embed_documents(textos_teste)
end_time = time.time()

print(f"Tempo de processamento: {end_time - start_time} segundos")
print(f"  - Dimensões do vetor: {len(embeddings_bge[0])}")



pergunta = "Quero tirar uns dias de folga do trabalho."

emb_pergunta_gemini = gemini_embeddings.embed_query(pergunta)
emb_pergunta_minilm = minilm_embeddings.embed_query(pergunta)
emb_pergunta_bge = bge_embeddings.embed_query(pergunta)

modelos = {
    "Gemini": (emb_pergunta_gemini, embeddings_gemini),
    "MiniLM": (emb_pergunta_minilm, embeddings_minilm),
    "BGE-large": (emb_pergunta_bge, embeddings_bge)
}

print(pergunta)

for nome, (emb_q, emb_docs) in modelos.items():
  similaridades = cosine_similarity([emb_q], emb_docs)[0]
  doc_e_similaridade = sorted(
      zip(textos_teste, similaridades), key=lambda x: x[1], reverse=True
  )
  print(f"--- Ranking para o modelo {nome} ---")
  for i, (doc, sim) in enumerate(doc_e_similaridade[:3], 1):
    print(f"  {i}. (Score: {sim:.3f}) {doc}")
  print()

# Instalação
!pip install -U langchain langchain-core langchain-classic langchain-google-genai

from langchain_classic.embeddings import CacheBackedEmbeddings
from langchain_classic.storage import LocalFileStore


# Diretório onde os embeddings serão armazenados
store = LocalFileStore("./cache/")


# Embedding principal
embedder_principal = GoogleGenerativeAIEmbeddings(
    model="gemini-embedding-001"
)


# Embedding com cache
cache_embeddings = CacheBackedEmbeddings.from_bytes_store(
    embedder_principal,
    store,
    namespace="gemini_cache"
)

# Configura o armazenamento local no disco do Colab
store = LocalFileStore("./cache/")

# Inicializa o modelo de embeddings do Gemini
embedder_principal = GoogleGenerativeAIEmbeddings(
    model="gemini-embedding-001"
)

# Cria o gerenciador de cache
cache_embeddings = CacheBackedEmbeddings.from_bytes_store(
    embedder_principal,
    store,
    namespace="gemini_cache"
)

textos_para_cache = ["Olá, mundo!", "Testando o cache de embeddings.", "Olá, mundo!"]

start_time = time.time()
embeddings_result_1 = cache_embeddings.embed_documents(textos_para_cache)
end_time = time.time()

print(f"  - Tempo de execução: {end_time - start_time:.4f} segundos.")



documentos_grandes = [f"Este é o documento de teste número {i}." for i in range(1000)]

bge_embedder = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-en-v1.5",
    model_kwargs={"device": "cpu"},
    encode_kwargs={"normalize_embeddings": True}
)

batch_sizes = [1, 32, 64, 128]

for batch_size in batch_sizes:
    start_time = time.time()
    num_batches = len(documentos_grandes) // batch_size
    tempo_estimado = num_batches * (0.1 * batch_size) + (len(documentos_grandes) % batch_size) * 0.1
    tempo_real = bge_embedder.client.encode(documentos_grandes, batch_size=batch_size)
    end_time = time.time()

    print(f"  - Batch Size: {batch_size:<4} -> Tempo: {end_time - start_time:.2f}s")