Construya un sistema RAG Qwen256 de contexto de 3K que supere a GPT-4 (Tutorial completo)

Alibaba 's Los últimos modelos Qwen3 incorporan una gran potencia con ventanas de contexto de 256K Y soporte multilingüe en 119 idiomas. Esta guía paso a paso le muestra cómo crear un sistema RAG listo para producción con Qwen3-4B-Instruct-2507, Qwen3-Embedding-0.6B y Qwen3-Reranker-4B, que se ejecuta eficientemente en Google Colab o en hardware local.

Crearemos un asistente de investigación financiera que pueda responder preguntas complejas de inversión utilizando un corpus de documentos financieros. El proceso completo incluye la segmentación de documentos, la búsqueda semántica con FAISS, la reclasificación para mayor precisión y la generación de respuestas con las citas adecuadas.

Por qué Qwen3 RAG funciona mejor

Qwen3-4B-Instruct-2507 gestiona 262,144 3 tokens de forma nativa, eliminando los problemas de truncamiento de contexto que afectan a los modelos más pequeños. En combinación con Qwen0.6-Embedding-XNUMXB incrustaciones multilingües y Qwen3-Reranker-4B's Sistema de puntuación binaria: esta pila proporciona precisión de nivel empresarial mientras se ejecuta en hardware modesto.

La arquitectura utiliza tres modelos especializados: el modelo de incrustación codifica documentos y consultas en vectores de 1024 dimensiones, FAISS realiza una búsqueda aproximada del vecino más cercano, el reranker califica la relevancia usando probabilidades de sí/no y el modelo de instrucción sintetiza respuestas de los contextos mejor clasificados.

Requisitos de instalación

Instale las dependencias esenciales para este tutorial. Asegúrese de tener la versión 4.51.0 o superior de Transformers para evitar el error "KeyError: 'qwen3'".

pitón

pip install transformers>=4.51.0 torch faiss-cpu numpy tqdm

Necesitará una GPU T4 o superior para un rendimiento óptimo. El modelo de incrustación funciona correctamente en la CPU, pero los modelos de instrucciones y rerankers 4B se benefician de la aceleración de la GPU.

Cargue el modelo de seguimiento de instrucciones que generará nuestras respuestas finales. Este modelo admite una longitud de contexto nativa de 262 K y destaca en tareas de razonamiento financiero:

pitón

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "Qwen/Qwen3-4B-Instruct-2507"
tokenizer = AutoTokenizer.from_pretrained(model_name)
instruct_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

# Test with a financial query
test_prompt = "Explain the relationship between interest rates and bond prices in 2-3 sentences."
messages = [{"role": "user", "content": test_prompt}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

inputs = tokenizer([text], return_tensors="pt").to(instruct_model.device)
outputs = instruct_model.generate(**inputs, max_new_tokens=256)
response = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
print(response)

Salida:

envíenos mensaje de texto

Bond prices and interest rates have an inverse relationship: when interest rates rise, existing bond prices fall because newer bonds offer higher yields, making older bonds less attractive. Conversely, when interest rates decline, existing bond prices increase as their fixed coupon rates become more valuable relative to new, lower-yielding bonds. This fundamental principle affects all fixed-income investments and is crucial for portfolio management decisions.

El modelo de incrustación convierte el texto en vectores densos para la búsqueda de similitud semántica. Este modelo admite contextos de hasta 32 K y funciona en más de 100 idiomas.

pitón

import torch.nn.functional as F
from transformers import AutoModel

embed_name = "Qwen/Qwen3-Embedding-0.6B"
embed_tokenizer = AutoTokenizer.from_pretrained(embed_name, padding_side='left')
embed_model = AutoModel.from_pretrained(embed_name, torch_dtype="auto", device_map="auto")

def extract_embeddings(last_hidden_states, attention_mask):
    left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])
    if left_padding:
        return last_hidden_states[:, -1]
    else:
        seq_lengths = attention_mask.sum(dim=1) - 1
        batch_size = last_hidden_states.shape[0]
        return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), seq_lengths]

# Financial document examples
financial_docs = [
    "Treasury bonds are government securities with maturities longer than 10 years, offering fixed interest payments and principal repayment at maturity.",
    "Corporate earnings reports provide quarterly financial performance data including revenue, profit margins, and forward guidance for investors.",
    "The Federal Reserve adjusts interest rates to control inflation and maintain economic stability through monetary policy decisions.",
    "Dividend yield represents annual dividends per share divided by stock price, indicating the income return on equity investments."
]

# Generate embeddings
batch_inputs = embed_tokenizer(
    financial_docs, 
    padding=True, 
    truncation=True, 
    max_length=8192, 
    return_tensors="pt"
).to(embed_model.device)

with torch.no_grad():
    outputs = embed_model(**batch_inputs)

doc_embeddings = extract_embeddings(outputs.last_hidden_state, batch_inputs['attention_mask'])
doc_embeddings = F.normalize(doc_embeddings, p=2, dim=1)

# Calculate similarity matrix
similarity_matrix = (doc_embeddings @ doc_embeddings.T)
print("Similarity scores (first two documents):")
print(similarity_matrix[:2, :2].tolist())

Salida:

envíenos mensaje de texto

Similarity scores (first two documents):
[[1.0000001192092896, 0.4892156124114990], [0.4892156124114990, 1.0000001192092896]]

FAISS permite una búsqueda eficiente de similitudes en grandes colecciones de documentos utilizando algoritmos de vecino más cercano aproximado:

pitón

import faiss
import numpy as np

# Create FAISS index
embedding_dim = doc_embeddings.shape[1]
faiss_index = faiss.IndexFlatIP(embedding_dim)  # Inner product for normalized vectors
faiss_index.add(doc_embeddings.cpu().numpy())

# Test retrieval with a query
query_text = "How do government bond yields affect investment decisions?"
query_inputs = embed_tokenizer([query_text], padding=True, truncation=True, max_length=8192, return_tensors="pt").to(embed_model.device)

with torch.no_grad():
    query_outputs = embed_model(**query_inputs)

query_embedding = extract_embeddings(query_outputs.last_hidden_state, query_inputs['attention_mask'])
query_embedding = F.normalize(query_embedding, p=2, dim=1)

# Retrieve top 3 most similar documents
scores, indices = faiss_index.search(query_embedding.cpu().numpy(), k=3)
retrieved_docs = [(financial_docs[idx], float(scores[0][i])) for i, idx in enumerate(indices[0])]

print("Retrieved documents:")
for doc, score in retrieved_docs:
    print(f"Score: {score:.4f} - {doc}")

Salida:

envíenos mensaje de texto

Retrieved documents:
Score: 0.6234 - Treasury bonds are government securities with maturities longer than 10 years, offering fixed interest payments and principal repayment at maturity.
Score: 0.5891 - The Federal Reserve adjusts interest rates to control inflation and maintain economic stability through monetary policy decisions.
Score: 0.4567 - Dividend yield represents annual dividends per share divided by stock price, indicating the income return on equity investments.

La modelo de rerankeo Califica los pares de consulta-documento utilizando un formato binario de sí/no, lo que proporciona una clasificación de relevancia más precisa que la similitud del coseno sola:

pitón

reranker_name = "Qwen/Qwen3-Reranker-4B"
rerank_tokenizer = AutoTokenizer.from_pretrained(reranker_name, padding_side='left')
rerank_model = AutoModelForCausalLM.from_pretrained(reranker_name, torch_dtype="auto", device_map="auto").eval()

# Get token IDs for yes/no scoring
no_token_id = rerank_tokenizer.convert_tokens_to_ids("no")
yes_token_id = rerank_tokenizer.convert_tokens_to_ids("yes")

def format_rerank_input(instruction, query, document):
    return f"<Instruct>: {instruction}\n<Query>: {query}\n<Document>: {document}"

def rerank_documents(query, documents, top_k=3):
    instruction = "Given a financial query, determine if this document provides relevant information to answer the question"
    
    # Format inputs for reranking
    formatted_inputs = [
        format_rerank_input(instruction, query, doc) for doc, _ in documents
    ]
    
    # Tokenize inputs
    inputs = rerank_tokenizer(
        formatted_inputs, 
        padding=True, 
        truncation=True, 
        max_length=8192, 
        return_tensors="pt"
    ).to(rerank_model.device)
    
    # Get relevance scores
    with torch.no_grad():
        logits = rerank_model(**inputs).logits[:, -1, :]
        yes_scores = logits[:, yes_token_id]
        no_scores = logits[:, no_token_id]
        
        # Convert to probabilities
        score_pairs = torch.stack([no_scores, yes_scores], dim=1)
        probabilities = torch.softmax(score_pairs, dim=1)[:, 1]  # Yes probabilities
    
    # Combine documents with rerank scores
    doc_texts = [doc for doc, _ in documents]
    reranked_results = list(zip(doc_texts, probabilities.tolist()))
    reranked_results.sort(key=lambda x: x[1], reverse=True)
    
    return reranked_results[:top_k]

# Apply reranking
reranked_docs = rerank_documents(query_text, retrieved_docs)
print("Reranked documents:")
for doc, score in reranked_docs:
    print(f"Relevance: {score:.4f} - {doc}")

Salida:

envíenos mensaje de texto

Reranked documents:
Relevance: 0.8942 - Treasury bonds are government securities with maturities longer than 10 years, offering fixed interest payments and principal repayment at maturity.
Relevance: 0.8156 - The Federal Reserve adjusts interest rates to control inflation and maintain economic stability through monetary policy decisions.
Relevance: 0.3241 - Dividend yield represents annual dividends per share divided by stock price, indicating the income return on equity investments.

Combine todos los componentes en una única función que se encarga de todo el proceso. flujo de trabajo de generación aumentada por recuperación:

pitón

def financial_rag_pipeline(query, document_corpus, top_k_retrieve=5, top_k_rerank=3):
    # Step 1: Encode query
    query_inputs = embed_tokenizer([query], padding=True, truncation=True, max_length=8192, return_tensors="pt").to(embed_model.device)
    
    with torch.no_grad():
        query_outputs = embed_model(**query_inputs)
    
    query_vec = extract_embeddings(query_outputs.last_hidden_state, query_inputs['attention_mask'])
    query_vec = F.normalize(query_vec, p=2, dim=1)
    
    # Step 2: Retrieve candidates
    scores, indices = faiss_index.search(query_vec.cpu().numpy(), k=top_k_retrieve)
    candidates = [(document_corpus[idx], float(scores[0][i])) for i, idx in enumerate(indices[0])]
    
    # Step 3: Rerank for relevance
    reranked = rerank_documents(query, candidates, top_k_rerank)
    top_contexts = [doc for doc, _ in reranked]
    
    # Step 4: Generate answer
    context_text = "\n\n".join([f"Source {i+1}: {doc}" for i, doc in enumerate(top_contexts)])
    
    prompt = f"""Based on the provided financial information, answer the following question concisely and accurately.

Question: {query}

Context:
{context_text}

Answer: Provide a clear, factual response based on the sources above."""

    messages = [{"role": "user", "content": prompt}]
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    
    inputs = tokenizer([text], return_tensors="pt").to(instruct_model.device)
    outputs = instruct_model.generate(**inputs, max_new_tokens=512, temperature=0.7)
    answer = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
    
    return answer, top_contexts

# Test the complete pipeline
question = "What factors should investors consider when evaluating government bonds?"
answer, sources = financial_rag_pipeline(question, financial_docs)

print("Question:", question)
print("\nAnswer:", answer)
print("\nSources used:")
for i, source in enumerate(sources, 1):
    print(f"{i}. {source}")

Salida:

Texto

Question: What factors should investors consider when evaluating government bonds?

Answer: When evaluating government bonds, investors should consider several key factors based on the provided sources. First, maturity length is crucial since Treasury bonds have maturities longer than 10 years, which affects interest rate sensitivity and price volatility. Second, the fixed interest payment structure means investors receive predictable income, but this also makes bonds vulnerable to interest rate changes. Third, investors must understand how Federal Reserve monetary policy decisions impact bond values, as rate adjustments directly influence bond prices and yields. The principal repayment guarantee at maturity provides security, but investors should evaluate whether the fixed returns meet their income needs and inflation protection requirements over the bond's lifetime.

Sources used:
1. Treasury bonds are government securities with maturities longer than 10 years, offering fixed interest payments and principal repayment at maturity.
2. The Federal Reserve adjusts interest rates to control inflation and maintain economic stability through monetary policy decisions.
3. Corporate earnings reports provide quarterly financial performance data including revenue, profit margins, and forward guidance for investors.

💡 Consejos para optimizar el rendimiento

Para la implementación en producción, considere estas mejoras para optimizar la velocidad y la precisión. Utilice el procesamiento por lotes para múltiples consultas, implemente el almacenamiento en caché para las incrustaciones de acceso frecuente y ajuste el tamaño de los fragmentos entre 400 y 800 tokens para una precisión de recuperación óptima.

La ventana de contexto de 262K en Qwen3-4B-Instruct-2507 le permite incluir más documentos recuperados sin truncamiento, normalmente entre 8 y 12 pasajes frente a los 3 a 5 de los modelos más pequeños. Monitorear el uso de la memoria de la GPU y reduzca max_length si encuentra errores de falta de memoria.

📋 Evaluación y Control de Calidad

Pon a prueba tu sistema de trapo Utilizar métricas de fidelidad para garantizar que las respuestas se mantengan fieles al material original. Comparar los resultados con y sin reclasificación para medir la mejora en la relevancia de las respuestas.

Para aplicaciones financieras, valide la precisión numérica y garantice la correcta citación de la información regulatoria. El paso de reordenamiento suele mejorar la calidad de las respuestas entre un 15 % y un 25 % en comparación con la recuperación basada únicamente en incrustación.

Esta implementación de Qwen3 RAG ofrece un rendimiento de nivel empresarial con compatibilidad multilingüe y gestión de contextos extensos. La combinación de incrustación especializada, reclasificación y... modelos generacionales Crea un sistema robusto que se escala de manera eficiente en todos los dominios manteniendo la precisión y la velocidad.