Estrategias de división para textos largos
Enfoques de división por tamaño fijo, límites de oración y significado semántico.
Estrategias de división para textos largos es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
Por qué los documentos largos suponen un desafío
Los LLM tienen una ventana de contexto: un número máximo de tokens que pueden procesar a la vez. GPT-4 admite 128k tokens y Claude admite 200k, pero muchos documentos superan incluso estos límites. Además, las investigaciones muestran que la precisión del modelo suele disminuir en contextos muy largos. La fragmentación consiste en dividir los documentos en partes más pequeñas antes de procesarlos.
Fragmentación de tamaño fijo
La fragmentación de tamaño fijo divide el texto cada N tokens (o caracteres), independientemente de los límites del contenido. Es la estrategia más sencilla y no requiere comprensión semántica.
El tamaño habitual de un fragmento es de 500–1000 tokens. Los fragmentos son fáciles de indexar y recuperar, pero pueden dividir las oraciones por la mitad y perder significado en los límites.
import tiktoken
def fixed_chunk(text, max_tokens=1000):
enc = tiktoken.get_encoding('cl100k_base')
tokens = enc.encode(text)
chunks = []
for i in range(0, len(tokens), max_tokens):
chunk_tokens = tokens[i:i + max_tokens]
chunks.append(enc.decode(chunk_tokens))
return chunks
chunks = fixed_chunk(long_document)
print(f'Total chunks: {len(chunks)}')Ventajas y desventajas de la fragmentación de tamaño fijo
Ventajas:
- Fácil de implementar; no requiere NLP
- Tamaños de fragmento predecibles; facilita la gestión de los costes de la API
- Procesamiento rápido
Desventajas:
- Atraviesa los límites de oraciones y párrafos
- Una oración dividida entre varios fragmentos pierde contexto durante la recuperación
- No es adecuada para resumir: el fragmento puede terminar a mitad de un argumento
Fragmentación en los límites de las oraciones
La fragmentación en los límites de las oraciones divide el texto en pausas naturales entre oraciones o párrafos. Cada fragmento termina en un punto, lo que garantiza que ninguna oración se corte por la mitad. Así se obtienen fragmentos más legibles y coherentes.
Use un tokenizador de oraciones (spaCy o NLTK) para detectar los límites y, después, agrupe las oraciones hasta que el fragmento alcance el tamaño objetivo.
import spacy
nlp = spacy.load('en_core_web_sm')
def sentence_chunk(text, max_tokens=1000):
doc = nlp(text)
sentences = [sent.text.strip() for sent in doc.sents]
chunks, current, count = [], [], 0
for sent in sentences:
word_count = len(sent.split())
if count + word_count > max_tokens and current:
chunks.append(' '.join(current))
current, count = [], 0
current.append(sent)
count += word_count
if current:
chunks.append(' '.join(current))
return chunksFragmentación semántica
La fragmentación semántica va un paso más allá: divide el texto cuando cambia el tema. Al generar embeddings de oraciones adyacentes y medir la similitud coseno, podemos detectar cuándo la conversación pasa a un tema nuevo.
Cuando la similitud cae por debajo de un umbral, inserte un límite de fragmento. Así se obtienen fragmentos cohesionados temáticamente, ideales para la generación aumentada por recuperación (RAG).
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
model = SentenceTransformer('all-MiniLM-L6-v2')
def semantic_chunk(sentences, threshold=0.75):
embeddings = model.encode(sentences)
chunks, current = [], [sentences[0]]
for i in range(1, len(sentences)):
sim = cosine_similarity(
[embeddings[i-1]], [embeddings[i]]
)[0][0]
if sim < threshold:
chunks.append(' '.join(current))
current = []
current.append(sentences[i])
if current:
chunks.append(' '.join(current))
return chunksComparación de las tres estrategias
A continuación se muestra una comparación directa para ayudarle a elegir:
- Tamaño fijo: límites más rápidos y menos precisos; úsela para procesos sencillos
- Límites de las oraciones: conserva la integridad de las oraciones; úsela cuando la coherencia sea importante
- Semántica: ofrece la mejor cohesión temática; úsela con RAG cuando la precisión de la recuperación sea crítica
En la práctica, la fragmentación semántica añade latencia debido al cálculo de embeddings. Elija la estrategia según los requisitos de precisión de la recuperación.
Fragmentación para tareas de recuperación
En la generación aumentada por recuperación (RAG), los fragmentos se convierten en la unidad de búsqueda. Se genera el embedding de una consulta del usuario, se recuperan los fragmentos más similares y se incorporan al prompt.
Los fragmentos más pequeños (200–400 tokens) mejoran la precisión de la recuperación: cada fragmento contiene una idea concreta. Los fragmentos más grandes (800–1000 tokens) proporcionan más contexto, pero pueden incluir contenido irrelevante junto al pasaje pertinente.
import openai
import numpy as np
client = openai.OpenAI(api_key='sk-...')
def embed(text):
resp = client.embeddings.create(
model='text-embedding-3-small',
input=text
)
return np.array(resp.data[0].embedding)
def retrieve(query, chunks, top_k=3):
q_emb = embed(query)
scores = [(i, np.dot(q_emb, embed(c))) for i, c in enumerate(chunks)]
scores.sort(key=lambda x: x[1], reverse=True)
return [chunks[i] for i, _ in scores[:top_k]]Fragmentación para tareas de resumen
Para la generación de resúmenes, los fragmentos deben ser lo bastante grandes como para contener un argumento o una sección completos. Los fragmentos de 600–800 tokens definidos por los límites de las oraciones funcionan bien.
Cada fragmento se resume de forma independiente (el paso map) y, después, los resúmenes se combinan en un resumen final (el paso reduce). Este es el patrón clásico de map-reduce, que se explica en la lección siguiente.
Solapamiento: conexión entre los límites de los fragmentos
Una técnica práctica para reducir los errores en los límites consiste en añadir solapamiento entre los fragmentos. Los últimos 100–200 tokens del fragmento N se repiten al principio del fragmento N+1.
El solapamiento garantiza que una oración que atraviesa un límite aparezca completa al menos en un fragmento. Esto es especialmente importante para la recuperación: una consulta sobre un tema que se extiende entre dos fragmentos coincidirá con el fragmento solapado.
def fixed_chunk_with_overlap(text, max_tokens=1000, overlap=200):
enc = tiktoken.get_encoding('cl100k_base')
tokens = enc.encode(text)
chunks = []
step = max_tokens - overlap
for i in range(0, len(tokens), step):
chunk_tokens = tokens[i:i + max_tokens]
chunks.append(enc.decode(chunk_tokens))
if i + max_tokens >= len(tokens):
break
return chunksEnriquecimiento de metadatos por fragmento
Cada fragmento debe incluir metadatos para que los pasos posteriores puedan consultar su origen:
source: nombre del archivo o URLpage: número de páginachunk_index: posición en el documentosection: capítulo o encabezado
Estos metadatos se almacenan junto con el embedding en una base de datos vectorial (Pinecone, Chroma, Weaviate) y se devuelven con los fragmentos recuperados para que el LLM pueda citar las fuentes.
def chunk_with_metadata(text, source='doc.pdf', page=1):
chunks = fixed_chunk_with_overlap(text)
return [
{
'text': chunk,
'metadata': {
'source': source,
'page': page,
'chunk_index': i
}
}
for i, chunk in enumerate(chunks)
]Elección de la estrategia adecuada
Guía rápida para tomar una decisión:
- La velocidad es prioritaria y el contenido es prosa: fragmentación en los límites de las oraciones
- La precisión de la recuperación es crítica: fragmentación semántica con fragmentos pequeños (300 tokens)
- Para resumir un libro o informe: fragmentación en los límites de las oraciones, fragmentos más grandes (800 tokens) y map-reduce
- Documentos jurídicos o técnicos: fragmentación semántica para mantener unidas las cláusulas
Mida siempre el recall de recuperación con un conjunto representativo de consultas antes de comprometerse con una estrategia.
Comprobación de conocimientos
¿Qué estrategia de segmentación divide el texto cuando la similitud coseno entre los embeddings de oraciones adyacentes cae por debajo de un umbral?
Recapitulación: estrategias de segmentación
Ha aprendido tres estrategias principales de segmentación:
- Tamaño fijo: dividir cada N tokens: rápido, sencillo y sin tener en cuenta los límites
- Límites de oración: dividir en los puntos naturales de separación entre oraciones: coherente y de complejidad moderada
- Semántica: dividir cuando cambian los temas mediante la similitud entre embeddings: mayor precisión y mayor coste
Añada solapamiento entre los fragmentos para reducir los errores en los límites y adjunte siempre metadatos (fuente, página e índice) para habilitar las citas y la trazabilidad. En la próxima lección se aborda el patrón de resumido map-reduce.
Aprende AI Prompt Engineering con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 53
- Lecciones
- 199
Preguntas frecuentes
¿La lección «Estrategias de división para textos largos» es gratis?
Sí — el texto completo de «Estrategias de división para textos largos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «Estrategias de división para textos largos»?
Enfoques de división por tamaño fijo, límites de oración y significado semántico. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Estrategias de división para textos largos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Estrategias de división para textos largos
- Patrón de resumen Map-Reduce
- Resumen jerárquico
- Mantener el contexto entre fragmentos