Análisis de datos con Ollama

Qué cubre este artículo sobre análisis de datos con Ollama

• Qué tareas de análisis puede asumir Ollama.
• Cómo evaluar textos, tablas y registros.
• Cómo obtener salidas estructuradas.
• Ejemplos de clasificación, extracción e informes.
• Consejos para calidad, rendimiento y protección de datos.

Introducción: Análisis de datos con Ollama

Los modelos de lenguaje no solo generan texto, sino que también lo analizan. Ollama es especialmente adecuado para esto porque los datos permanecen locales y el contenido sensible no necesita enviarse a servicios externos. Correos electrónicos, tickets de soporte, archivos de registro, contratos o descripciones de productos se pueden clasificar, resumir o convertir en datos estructurados de forma automática.

Este artículo muestra qué tareas de análisis de datos puede realizar Ollama y cómo implementarlas en la práctica.

Términos clave

• Clasificación: asignación de un texto a una categoría.
• Extracción: filtrado de información específica.
• Resumen: compresión de un texto.
• Análisis de sentimiento: detección del tono emocional.
• Structured Output: salida en un formato definido.
• Prompt Template: estructura de entrada recurrente.
• Named Entity Recognition: reconocimiento de nombres, lugares o términos.
• Batch: procesamiento de varios elementos simultáneamente.

Casos de uso

• Ordenar correos o tickets por categoría.
• Evaluar comentarios de clientes por sentimiento.
• Buscar contratos por palabras clave.
• Verificar registros de error en patrones.
• Estructurar descripciones de productos.
• Resumir documentos.
• Extraer entidades como personas o empresas.
• Derivar tablas a partir de textos.

Clasificación

Un prompt simple para categorización:

import requests

def classify(text, model="llama3.1"):
    url = "http://localhost:11434/api/generate"
    prompt = f"""Klassifiziere den folgenden Text als eine der Kategorien:
    - Technisch
    - Finanziell
    - Persönlich
    - Spam

    Text: {text}

    Antwort nur mit der Kategorie."""

    response = requests.post(url, json={
        "model": model,
        "prompt": prompt,
        "stream": False
    })
    return response.json()["response"].strip()

print(classify("Meine Rechnung ist falsch."))

Resumen

def summarize(text, model="llama3.1"):
    prompt = f"Fasse den folgenden Text in drei Sätzen zusammen:\n\n{text}"
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Extracción

def extract_entities(text, model="llama3.1"):
    prompt = f"""Extrahiere aus dem folgenden Text die Personennamen, Orte und Organisationen.
    Gib die Antwort als JSON zurück:

    {{"persons": [], "locations": [], "organizations": []}}

    Text: {text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Análisis de tablas

Ollama también puede evaluar tablas en formato CSV o Markdown:

def analyze_table(table_text, model="llama3.1"):
    prompt = f"""Analysiere die folgende Tabelle und nenne die drei wichtigsten Erkenntnisse:

    {table_text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Análisis de registros

def analyze_log(log_text, model="llama3.1"):
    prompt = f"""Analysiere die folgenden Logeinträge und nenne die häufigsten Fehlertypen:

    {log_text}"""

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return response.json()["response"]

Salidas estructuradas

Para obtener resultados estructurados se requiere un formato claro:

Gib die Antwort ausschliesslich als JSON zurück:

{
  "category": "Technisch",
  "confidence": 0.9,
  "keywords": ["Netzwerk", "Fehler"]
}

Sin embargo, los modelos no siempre devuelven JSON válido. Por eso las salidas deben validarse.

Procesamiento por lotes

import json

texts = ["Text eins", "Text zwei", "Text drei"]

results = []
for text in texts:
    result = classify(text)
    results.append({"text": text, "category": result})

with open("ergebnisse.json", "w") as f:
    json.dump(results, f, indent=2, ensure_ascii=False)

Consejos

• Define las categorías de forma clara y mutuamente excluyente.
• Incluye ejemplos en el prompt cuando sea necesario.
• Mantén la temperatura baja para una clasificación consistente.
• Analiza y valida las salidas.
• Utiliza modelos con buena comprensión textual.
• Para documentos largos, fragmenta primero.
• Mantén los datos sensibles locales, no los envíes a servicios externos.

Trampas comunes

• Salidas inconsistentes: el modelo devuelve a veces JSON, a veces texto libre.
• Demasiadas categorías: el modelo rechaza categorías incorrectas.
• Documentos largos: la ventana de contexto es insuficiente.
• Formato incorrecto: el análisis falla.
• El modelo alucina: extrae datos que no existen.
• Temperatura demasiado alta: resultados inestables.
• Prompt muy genérico: la clasificación resulta imprecisa.

Enlaces y recursos adicionales

• BotServ.de Comandos Ollama
• BotServ.de Librerías API de Ollama
• BotServ.de Automatización con Ollama
• BotServ.de Ingeniería de prompts en Ollama

FAQ: Análisis de datos con Ollama

¿Puede Ollama entender tablas? Sí, especialmente cuando están en formato Markdown o CSV.

¿Es fiable la clasificación? Para categorías simples generalmente sí, para dominios complejos es mejor hacer pruebas.

¿Cuántos textos puedo analizar? Tantos como lo permitan el hardware y el tiempo disponible. El procesamiento por lotes es posible.

¿Necesito salida en JSON? No es obligatorio, pero facilita el procesamiento posterior.

¿Cuál es el mejor modelo para análisis? llama3.1, qwen2.5 o mistral son buenas opciones versátiles.

Fuentes y lecturas adicionales

• Ollama API: https://github.com/ollama/ollama/blob/main/docs/api.md
• Descripción general de NER: https://en.wikipedia.org/wiki/Named-entity_recognition
• Validación JSON en Python: https://docs.python.org/3/library/json.html

Resumen: Análisis de datos con Ollama

Ollama es una herramienta eficaz para análisis de datos local. Los textos se pueden clasificar, resumir, evaluar y estructurar. Con prompts claros, scripts simples y procesamiento por lotes se pueden automatizar tareas de análisis recurrentes. Lo importante es definir categorías, validar salidas y elegir el modelo adecuado. Quien analiza datos localmente cumple con la protección de datos y puede evaluar contenido sensible sin riesgo.