Skip to content

aldomunaretto/immune_generative_ai

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

32 Commits
data
data
 
 
datasets
datasets
 
 
modelfiles
modelfiles
 
 
notebooks
notebooks
 
 
.env_template
.env_template
 
 
.gitignore
.gitignore
 
 
README.md
README.md
 
 
requirements.txt
requirements.txt
 
 

Repository files navigation

Immune Generative AI

Este repositorio tiene como objetivo introducir los fundamentos de la Inteligencia Artificial Generativa (GenAI) y proporcionar una guía práctica para trabajar con Modelos de Lenguaje de Gran Tamaño (LLMs) usando herramientas de código abierto como Ollama.

📑 Índice de Contenido

🧠 ¿Qué es la Inteligencia Artificial Generativa?

La IA Generativa es un campo de la inteligencia artificial que se centra en la creación de contenido nuevo y original a partir de datos existentes. Esto incluye texto, imágenes, código, música, video y más. Su auge reciente se debe al desarrollo de modelos de deep learning capaces de generar resultados sorprendentes en tareas creativas y cognitivas.

📚 ¿Qué son los LLMs?

Los Large Language Models (LLMs) son redes neuronales entrenadas con grandes cantidades de texto para aprender patrones del lenguaje humano. Estos modelos pueden:

  • Generar texto coherente
  • Resumir documentos
  • Traducir entre idiomas
  • Contestar preguntas
  • Escribir código, entre muchas otras tareas.

🏢 Proveedores Comerciales de LLMs

A continuación se listan algunos de los principales proveedores que ofrecen LLMs accesibles mediante API o servicios cloud:

Proveedor Modelos Destacados (2026) Plataforma/API Notas
OpenAI GPT-5.2, o3, o1-pro, GPT-4o https://platform.openai.com Soporte multimodal, Realtime API
Anthropic Claude 4.5 Opus (Thinking), Claude 4 Sonnet https://www.anthropic.com Foco en seguridad. Excelente en matices lingüísticos y razonamiento complejo con modo "Thinking".
Google Gemini 3 Pro / Nano Banana / Veo3 https://ai.google.dev Contexto largo, multimodal nativo y foco en razonamiento + agentes.
Meta Llama 4 Scout, Llama 4 Maverick (pesos + API) https://ai.meta.com/llama “Open-weight” (con condiciones de licencia), opción de self-hosting + acceso vía API.
Alibaba Qwen3 (familia), Qwen3-Max, (línea Qwen3-Next) https://qwenlm.github.io Mucho empuje en modelos “hybrid reasoning” y escalado; Max aparece como tope de gama.
DeepSeek AI DeepSeek-V3.2, DeepSeek-R1 https://deepseekcoder.github.io Enfocado en razonamiento/código con releases frecuentes (V3.x) y línea R1. Especializado en código.
Mistral Mistral Large 3, Mistral 3 (14B/8B/3B) https://mistral.ai Oferta muy sólida en open models + opciones enterprise; nueva generación “Mistral 3”.
Cohere Command A, Command R / R+. https://cohere.com Orientado a enterprise + RAG + tool use; Cohere recomienda Command A como “latest” frente a R+.
AWS (Bedrock) Amazon Nova (Premier/Pro/Lite/Micro), + Titan (embeddings / image / legacy text) https://aws.amazon.com/bedrock Nova es la línea moderna multimodal/agentic; Titan sigue presente (especialmente embeddings/imágenes) y parte de text se migra hacia Nova.
xAI Grok 4, Grok 3 https://docs.x.ai/ API con modelos versionados/aliases; Grok 4 aparece como oferta actual.
AI21 Labs Jamba, Jamba2 https://docs.ai21.com/ Modelos basados en la línea Claude, con enfoque en NLP avanzado.

🚀 Tendencias Clave de 2026

  • Modelos de Razonamiento (Reasoning): Ya no solo predicen la siguiente palabra; modelos como o3 o Claude 4.5 Thinking utilizan "cadena de pensamiento" interna antes de responder, lo que reduce drásticamente las alucinaciones en tareas lógicas.
  • Agentes Nativos: La mayoría de los modelos actuales (especialmente Llama 4 y GPT-5.2) están diseñados para usar herramientas de forma autónoma, permitiendo crear flujos de trabajo sin intervención humana constante.
  • Eficiencia Extrema: Los modelos "Small" o "Flash" de 2026 son hoy más potentes de lo que era GPT-4 en su lanzamiento, permitiendo inferencia local en dispositivos con gran precisión.

🌍 Modelos de Código Abierto (actualizado 2025)

A continuación se listan algunos de los LLMs open source más destacados y actualizados:

Modelo Autor/Organización Tamaños Disponibles Versión Actual Licencia
LLaMA Meta 8B, 70B LLaMA 4 Meta RAIL
Qwen Alibaba 0.5B a 110B Qwen 2 Apache 2.0
DeepSeek DeepSeek AI 1.3B a 236B DeepSeek-V2 MIT
Phi Microsoft 3.8B, 7B Phi-3 MIT
Gemma Google 2B, 7B Gemma 1.1 Apache 2.0
Mistral Mistral AI 7B, Mixtral (12.7B MoE) Mistral 7B / Mixtral 8x7B Apache 2.0
Falcon TII (UAE) 7B, 180B Falcon 180B Apache 2.0
Command-R Cohere 35B Command-R+ RAIL

📝 Prompt Engineering

La ingeniería de prompts (Prompt Engineering) es el arte y la ciencia de diseñar entradas (prompts) para LLMs con el fin de obtener salidas más precisas, seguras y previsibles sin alterar los pesos del modelo. Combina diseño de instrucciones, estructuración del contexto, selección de ejemplos y restricciones de formato para alinear la respuesta con requisitos funcionales y de negocio.

Técnicas comunes

  • Mensajes de sistema/rol: separar instrucciones de alto nivel (system) de la petición del usuario.
  • Zero‑shot vs Few‑shot: proporcionar 0 o varios ejemplos para guiar estilo y formato.
  • Prompt templates: plantillas parametrizables y versionadas.
  • Constraints estructurales: schema JSON, regex o formatos esperados para validar salidas.
  • Temperature / sampling: controlar creatividad vs determinismo.
  • Chain-of-Thought (CoT) y pasos intermedios: usar pasos explicativos controlados para tareas de razonamiento (con precaución).
  • Tool‑use / function calling: definir llamadas a herramientas y formatos de intercambio.
  • Robustness: testear contra prompt injection y entradas adversarias.

Ejemplos prácticos

  • Zero‑shot (instrucción clara)
System: Eres un redactor técnico conciso.
User: Resume el siguiente texto en 3 bullets con lenguaje para ejecutivos.
[DOCUMENTO...]
  • Few‑shot (estilo y formato)
User: Ejemplo 1:
Input: ¿Qué es X?
Output: X es... (1-2 frases)

User: Ejemplo 2:
Input: Cómo configurar Y?
Output: 1) Paso A 2) Paso B

User: Ahora haz lo mismo para: [nueva pregunta]
  • Output estructurado (JSON schema)
System: Responde SOLO en JSON con campos: { "summary": string, "impact": "low|medium|high", "actions": [string] }
User: Resume este informe y sugiere acciones.
[INFORME...]
  • Role play / persona
System: Eres un analista de seguridad con 10 años de experiencia.
User: Identifica 3 riesgos clave y una mitigación por cada uno.

Buenas prácticas breves

  • Definir rol, objetivo, audiencia y formato (ROCE).
  • Proveer ejemplos representativos y contraejemplos.
  • Validar y testear con mutaciones adversarias.
  • Versionar templates y registrar prompt final utilizado en producción.
  • Preferir restricciones estructurales (JSON schema) en lugar de solo instrucciones abiertas.

Lecturas y herramientas

Referencias rápidas

  • Guidance, Promptfoo, Promptify — utilidades para crear, testar y versionar prompts.

ROCE — Framework para diseñar prompts

ROCE es un acrónimo que resume cuatro elementos clave para construir prompts claros y efectivos al interactuar con LLMs:

  • R — Rol: indica la perspectiva o identidad del modelo (p. ej. "Eres un analista de seguridad senior").
  • O — Objetivo: define la meta concreta del prompt (p. ej. "Resumir los riesgos en 3 puntos accionables").
  • C — Contexto: aporta datos relevantes, restricciones y cualquier información necesaria (documentos, formato, audiencia).
  • E — Ejemplo: muestra ejemplos de entrada/salida o el formato deseado para guiar la respuesta.

Por qué usar ROCE:

  • Aumenta la precisión y relevancia de las respuestas.
  • Reduce ambigüedad y alucinaciones.
  • Facilita respuestas con formato predecible y verificable.

Plantilla rápida:

# ROLE
Eres un [profesión/experto] con [N años] de experiencia en [área].
Tu especialidad es [skill específico].

# OBJECTIVE
Tu tarea es [acción específica] que cumpla:
- [Criterio 1 de éxito]
- [Criterio 2 de éxito]
- [Criterio 3 de éxito]

# CONTEXT
- Audiencia: [descripción detallada]
- Formato: [estructura específica]
- Tono: [estilo de comunicación]
- Restricciones: [límites claros]
- NO hacer: [prohibiciones explícitas]

# EXAMPLE
[Muestra concreta del output deseado]

Consejos prácticos:

  • Sé explícito y conciso en cada elemento.
  • Proporciona ejemplos representativos.
  • Itera: refina rol, contexto o ejemplos si la salida no coincide con lo esperado.
  • Combínalo con técnicas como few-shot, instrucciones de sistema y constraints (JSON schema, límites de tokens) para mayor robustez.

📝 Context Engineering

El Context Engineering consiste en diseñar cuidadosamente los prompts y la información de entrada para optimizar las respuestas de un LLM sin necesidad de modificar sus pesos. Se centra en:

  • Estructuración de prompts y templates.
  • Inserción de context windows con ejemplos o instrucciones previas.
  • Uso de técnicas como Chain-of-Thought (CoT), Few-Shot Prompting y ReAct.

📖 Lecturas sobre Context Engineering:

🔧 Librerías comunes:

🎯 Fine-tuning

El Fine-tuning es el proceso de ajustar los parámetros de un modelo previamente entrenado usando un conjunto de datos específico para una tarea concreta. Se utiliza para:

  • Mejorar rendimiento en dominios especializados.
  • Adaptar el estilo o formato de salida.
  • Crear instruction-tuned models para casos concretos.

🔧 Librerías y frameworks:

🪢 Datasets para entrenamiento y ajuste fino (Fine-Tuning) de LLMs:

📄 Formatos para Fine Tuning: Alpaca vs ShareGPT

Los formatos Alpaca y ShareGPT son los más utilizados para el fine‑tuning supervisado de LLMs, especialmente con frameworks como LLaMA‑Factory y Unsloth.

🧪 Formato Alpaca

📂 Estructura típica (JSON)

{
  "instruction": "...",    
  "input": "...",          
  "output": "...",         
  "system": "...",         
  "history": [             
    ["instrucción anterior", "respuesta anterior"]
  ]
}
  • instruction: Pregunta o instrucción del humano (requerido).
  • input: Contexto adicional (opcional).
  • output: Respuesta esperada del modelo (requerido).
  • system: Mensaje del sistema (opcional).
  • history: Rondas anteriores en conversaciones multironda (opcional).
✅ Ventajas
  • Muy simple y ampliamente adoptado.
  • Ideal para datasets de instrucción-respuesta de una sola ronda.
⚠️ Limitaciones
  • No tiene estructura nativa para roles múltiples o multironda avanzada.
  • Se apoya en tokens de separación (### o EOS).

🧵 ShareGPT

📂 Estructura típica (JSON)
{
  "conversations": [
    { "from": "human", "value": "…instrucción humana…" },
    { "from": "gpt",   "value": "…respuesta del modelo…" },
    { "from": "function_call", "value": "…argumentos de herramienta…" },
    { "from": "observation",   "value": "…resultado de herramienta…" }
  ],
  "system": "...",
  "tools": "..."
}
  • Permite múltiples roles: human, gpt, function_call, observation.
  • Diseñado para conversaciones multironda y llamadas a funciones.
✅ Ventajas
  • Soporta roles y contextos complejos.
  • Ideal para datasets de diálogo real y herramientas.
⚠️ Limitaciones
  • Más complejo de preparar que Alpaca Format.

📦 Soporte en Frameworks

  • LLaMA‑Factory: Soporta ambos formatos mediante configuración en dataset_info.json.
  • Unsloth:
    • Permite convertir con standardize_sharegpt().
    • Ofrece conversation_extension para simular multironda desde Alpaca.

📊 Comparativa Rápida

Aspecto Alpaca Format ShareGPT Format
Instrucción + respuesta ✅ ✅
Multi-turno ⚠️ Opcional, sin estructura fija ✅ Nativo
Roles adicionales ❌ ✅ function_call, observation, etc.
Complejidad 🔹 Baja 🔹 Media-Alta
Conversión disponible 🔸 Limitada ✅ Via Unsloth

🧠 ¿Cuál elegir?

  • Alpaca → Para datasets simples de instrucciones/respuestas.
  • ShareGPT → Para diálogos multironda, roles múltiples y escenarios con herramientas.

📄 Lecturas:

📂 Retrieval-Augmented Generation (RAG)

El RAG combina la generación de texto con la recuperación de información externa en tiempo real. En lugar de confiar solo en el conocimiento interno del LLM, recupera documentos relevantes y los pasa como contexto al modelo antes de generar la respuesta.

🔧 Librerías comunes:

Casos de uso:

  • Chatbots empresariales con documentos privados.
  • Búsqueda semántica combinada con LLMs.
  • Sistemas de soporte y asistencia con información actualizada.

Estrategias avanzadas:

  • Hybrid Search (BM25 + vector)
  • Re-rankers (Cross-Encoder, ColBERT)
  • Chunking adaptativo (basado en densidad semántica)
  • Caching semántico (embedding cache)
  • Context compression (resúmenes jerárquicos)

🧪 Evaluación y Métricas

La evaluación consistente evita regresiones.

Tipos:

  • Automática: BLEU, ROUGE (limitado), BERTScore, COMET.
  • Basada en LLM-as-a-Judge: pares A/B, escalas Likert.
  • Métricas específicas:
    • Context hit rate (RAG)
    • Hallucination rate
    • Latencia P50/P95/P99
    • Costo por 1K tokens útiles
    • Tasa de tool success (agentes)

Herramientas:

🔐 Seguridad, Alineación y Riesgos

Aspectos:

  • Prompt Injection
  • Data Exfiltration
  • Jailbreaks
  • Leakage de PII
  • Output Filtering / Red Teaming

Mitigaciones:

  • Sanitización de entradas
  • Separación de roles (system vs user)
  • Clasificadores de seguridad (moderation endpoints)
  • Guardrails: [NeMo Guardrails], [Guardrails-AI], [Azure Content Filters]

💰 Optimización de Costos

Estrategias:

  • Seleccionar modelo por tarea (routing / cascadas)
  • Cuantización local (4-bit, QLoRA)
  • Prompt trimming y compresión semántica
  • Reutilizar embeddings (cache)
  • Streaming parcial
  • Batch inference

KPIs:

  • Tokens por intención
  • Tokens contextuales redundantes
  • Costo por sesión resuelta

🛰️ Observabilidad y Trazabilidad

Qué capturar:

  • Prompt final compilado
  • Versionado de plantillas
  • Latencia end-to-end
  • Tool calls y resultados
  • Evaluaciones post-hoc

Herramientas:

  • [LangSmith], [Weights & Biases], Arize, [Helicone], [E2B sandbox], [PromptLayer]

🧪 Testing de Prompts

Tipos:

  • Regresión (snapshot expected outputs)
  • Sensibilidad (mutaciones adversarias)
  • Robustez (ruido / reorder)
  • Factualidad (verificador externo)

Pipeline:

  1. Dataset representativo
  2. Definición de aserciones (regex, JSON schema, LLM judge)
  3. Score agregado (>= umbral)
  4. Gate CI/CD

🧵 Gestión de Contexto Extendido

Técnicas:

  • Chunking semántico adaptativo
  • Resúmenes jerárquicos (map → reduce → refine)
  • Sliding window + focal retrieval
  • Embedding + graph enrichment
  • Long-context distillation (partial fine-tune)

Riesgos: context rot, dilución de señal, latencia.

🛣️ Roadmap de Aprendizaje Sugerido

  1. Fundamentos: prompts + inferencia local (Ollama)
  2. RAG básico
  3. Evaluación y métricas
  4. Fine-tuning PEFT
  5. Tool use / agentes
  6. Optimización costo-rendimiento
  7. Observabilidad + seguridad
  8. Orquestación avanzada (LangGraph / DSPy)

🤗 Hugging Face

Hugging Face es una de las plataformas más influyentes en el ecosistema de inteligencia artificial moderna. Su propósito es democratizar el acceso a modelos de IA, datasets y herramientas para investigación, desarrollo y despliegue de soluciones basadas en machine learning.

¿Qué ofrece Hugging Face?

  • Un hub centralizado de modelos entrenados y datasets etiquetados.
  • Librerías como transformers, datasets, peft, diffusers y evaluate.
  • Espacios (Spaces) para ejecutar y compartir demos interactivas.
  • La Hugging Face Hub API para integrar modelos en producción.
  • Herramientas de fine-tuning, inferencia, cuantización y más.
  • Una comunidad colaborativa activa de investigadores, empresas y desarrolladores.

Usos comunes:

  • Integrar LLMs como LLaMA, Mistral o Phi en apps.
  • Entrenar modelos personalizados.
  • Evaluar y comparar arquitecturas de IA.
  • Desplegar servicios de inferencia desde Hugging Face Inference Endpoints.
  • Explorar nuevos modelos generativos, como Diffusion Models para imagen y audio.

🧰 Ollama

Ollama es una herramienta sencilla para ejecutar modelos LLM localmente, con soporte para múltiples modelos open-source preconfigurados.

Requisitos

  • macOS, Linux o Windows (con soporte WSL)
  • Docker NO es necesario
  • CPU moderna o GPU con soporte para aceleración (opcional)

📖 Documentación y APIs

🖥️ LM Studio

LM Studio es una aplicación de escritorio que permite interactuar con modelos de lenguaje de manera local y visual. Funciona como una interfaz gráfica para Ollama y llama.cpp, y está pensada para usuarios no técnicos o que prefieren una experiencia similar a ChatGPT, pero con modelos locales.

Características destacadas:

  • Descargar y ejecutar modelos directamente desde la app.
  • Soporte para múltiples modelos open-source (LLaMA, Mistral, Phi, etc.).
  • Personalización de temperatura, longitud de respuesta y formato.
  • Compatible con macOS, Windows y Linux.

Ideal para experimentación, redacción de contenido, aprendizaje y evaluación rápida de modelos sin escribir código.

🧩 AnythingLLM

AnythingLLM es una plataforma de código abierto que permite crear un asistente privado impulsado por LLMs, capaz de trabajar con tus propios datos, documentos y fuentes de conocimiento.
🐙 GitHub Repository

¿Qué puedes hacer con AnythingLLM?

  • Subir archivos (PDF, DOCX, TXT, etc.) y hacer preguntas sobre su contenido.
  • Conectar fuentes externas como Notion, GitHub repos, sitios web y más.
  • Utilizar diferentes backends como OpenAI, Ollama, Mistral, Hugging Face, entre otros.
  • Desplegarlo en local, en servidores personales o en la nube.
  • Administrar múltiples espacios y usuarios con control de acceso.

Una solución ideal para construir un chat corporativo privado, motores de búsqueda internos o asistentes personales de conocimiento con arquitectura plug-and-play.

📚 Msty

Msty es una herramienta especializada en la visualización y análisis interno de modelos de lenguaje.
🐙 GitHub Repository

Te permite explorar:

  • Tokens generados en cada paso
  • Embeddings vectoriales y distancias semánticas
  • Probabilidades de predicción token a token

Ideal para investigadores, educadores y quienes quieren entender cómo "piensa" un modelo. Msty puede ayudarte a explicar errores, mejorar prompts o hacer debugging de outputs inesperados.

🌐 Gradio

Gradio es una librería de Python que permite construir interfaces web para modelos de machine learning y deep learning en minutos. Ideal para prototipos, demos y validación con usuarios.

Usos principales:

  • Crear formularios o chatbots con LLMs.
  • Visualizar outputs de modelos de imagen, audio o NLP.
  • Integrar con Hugging Face Spaces o notebooks.

Con unas pocas líneas de código puedes desplegar una interfaz intuitiva y compartible con cualquier persona.

📊 Streamlit

Streamlit es un framework en Python para crear aplicaciones web interactivas de forma rápida, ideal para prototipar interfaces con modelos de IA.

🔧 Características clave

  • Interfaz muy sencilla basada en Python puro (sin necesidad de HTML/CSS/JS).
  • Ideal para dashboards, demos de modelos y visualización de datos.
  • Integración directa con librerías como pandas, plotly, matplotlib y APIs de LLMs.
  • Permite desplegar aplicaciones fácilmente en la nube mediante Streamlit Community Cloud.

🗣️ ElevenLabs

ElevenLabs es una plataforma líder en generación de voz mediante IA.
Permite crear voces sintéticas realistas en múltiples idiomas y estilos, siendo ampliamente usada para aplicaciones de:

  • Narración de audiolibros y podcasts.
  • Generación de diálogos en videojuegos.
  • Conversión de texto a voz (TTS) en asistentes virtuales.
  • Creación de personajes con voces personalizadas.

🔧 Características clave

  • Modelos de voz de alta fidelidad y expresividad.
  • Soporte multilingüe y clonación de voz.
  • API sencilla para integraciones en aplicaciones web y móviles.
  • Planes de uso gratuito y de pago según volumen de caracteres.

📚 Librerías y SDKs

  • ElevenLabs Python SDK
  • API REST para integración con cualquier lenguaje.
  • Plugins y conectores para aplicaciones de contenido multimedia.

🔗 Recursos adicionales

📚 Documentación y Comparativas

⚙️ Frameworks y Librerías

Personas de Interes

Enlaces Útiles

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

2 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages