Daimon-R / README.md

Upload README.md with huggingface_hub

dcdc5cf verified about 2 months ago

10.5 kB

license: apache-2.0
base_model: Qwen/Qwen3-4B-Instruct-2507
language:
  - es
  - en
tags:
  - daimon
  - lora
  - tool-calling
  - agent
  - code
  - spanish
library_name: gguf

🇪🇸 Español

daimon r es el cerebro razonador (4B) de Daimon, un asistente personal local-first: corre en tu máquina, no en la nube. Fine-tune LoRA de Qwen/Qwen3-4B-Instruct-2507 para el núcleo de Daimon: acciones de agente (tool-calling JSON), código y conversación en español nativo.

Qué es exactamente: el modelo base Qwen/Qwen3-4B-Instruct-2507 (GGUF cuantizado, intacto) + un LoRA de ~66MB que lo especializa como cerebro de agente. Es un modelo estándar: funciona con llama.cpp / LM Studio / cualquier stack GGUF, sin necesidad del software de Daimon — abajo está el contrato completo de prompts para usarlo standalone.

📊 Benchmark (medido, reproducible)

Métrica (198 casos held-out)	Base Qwen3-4B-Instruct-2507	daimon r
JSON válido / valid JSON	100.0%	100.0%	➖ empata
Acción correcta / correct action	75.3%	100.0%	✅ gana
Acción + campos correctos / correct fields	47.5%	100.0%	✅ gana

Benchmark objetivo y reproducible: 198 escenarios sintéticos held-out (vocabulario disjunto del entrenamiento, cero solapamiento textual), calificados determinísticamente — JSON parseable, acción esperada, campos correctos (ref/path/command/…). Sin juez LLM. Medido sobre estos GGUF exactos servidos con llama.cpp. Script: agent_actions_eval.py — los JSONs de resultados se generan antes de cada publicación.

🔍 Benchmarks de la comunidad (independientes de nuestro propio bench)

Además del benchmark de agent-actions de arriba (que es nuestro propio esquema), corrimos Qwen3-4B-Instruct-2507 y este modelo contra benchmarks ESTÁNDAR de la comunidad, en las mismas condiciones exactas (misma cuantización GGUF, mismo serving, mismo harness) para que la comparación sea justa:

Benchmark	Base Qwen3-4B-Instruct-2507	Este modelo
HumanEval	74.4%	72.0%	❌ pierde
MBPP	82.5%	75.8%	❌ pierde
MMLU (subset)	68.4%	68.4%	➖ empata
BFCL-lite (tool-calling estandar)	76.0%	77.0%	✅ gana

HumanEval/MBPP: pass@1 con ejecución real de tests ocultos (no similitud de texto). MMLU: subset de 15 materias, precisión 0-shot. BFCL-lite: subset AST del Berkeley Function-Calling Leaderboard v3 (simple/multiple/parallel/ parallel_multiple/irrelevance) — mide tool-calling en un esquema DISTINTO al nuestro.

El trade-off, explícito: este LoRA es un especialista de agente, no un fine-tune general-purpose. Los puntos que cede en código/conocimiento general son el costo deliberado de la ganancia enorme en su tarea núcleo (la tabla de arriba: de ~47% a ~100% en acciones correctas). Para programar "a mano" usá el modelo base; para operar como agente de Daimon, este. Si una dimensión pierde, se muestra perdiendo — preferimos que la card sea creíble a que sea linda.

🧠 Con qué se entrenó (por contribución)

Acciones de agente (in-house, sintético) — escenarios browser/computer/code con el esquema JSON exacto de producción de Daimon ({"thought": …, "action": "click", "ref": …}), generados por construcción (la respuesta correcta se conoce con certeza, sin teacher API). Es lo que mueve las tres métricas de arriba.
Comportamiento e identidad Daimon (in-house) — 231 seeds: persona en primera persona, honestidad ante lo que no sabe, registro rioplatense conciso, convención de canvas HTML.
El código, el razonamiento y el multilingüe vienen del modelo base (por eso el LoRA es chico y el nivel de código se mantiene intacto). Probamos también mezclas grandes con datasets públicos (xLAM, ToolACE, código, español nativo) y fine-tunes sobre el historial real de commits — ninguna de esas variantes le ganó a esta en el gate, así que no se publicaron. Solo publicamos lo que gana una comparación pre-registrada contra el base.

💻 Requisitos de hardware

Recurso	Requisito
Disco	~2.6 GB (base GGUF + LoRA)
RAM	8 GB mínimo
GPU / memoria unificada	≥ 4 GB VRAM (ej. GTX 1650) o Apple Silicon ≥ 8 GB de memoria unificada

✅ Probalo vos mismo (verificable)

huggingface-cli download lucas-mella/Daimon-R --local-dir ./daimon
llama-server -m ./daimon/Qwen3-4B-Instruct-2507-Q4_K_M.gguf --lora ./daimon/daimon-r-lora-f16.gguf -c 4096

Después probá una acción de agente (el núcleo de lo que se entrenó — este es un caso real del set de evaluación, verificado contra estos pesos exactos antes de publicar):

curl -s http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
  "temperature": 0,
  "messages": [
    {"role": "system", "content": "Sos el navegador autónomo de Daimon. En cada paso recibís el objetivo, la página actual (elementos interactivos con su ref + texto visible) y el historial. Respondé SOLO con un objeto JSON de esta forma:\n{\"thought\":\"...\",\"action\":\"navigate|click|fill|scroll|back|done\",\"ref\":<n>,\"text\":\"...\",\"url\":\"...\"}"},
    {"role": "user", "content": "Objetivo: poné 'gatos' en 'Email'\n\nURL: https://un-sitio-de-noticias.test/\nTítulo: Un Sitio De Noticias\nElementos:\n  [0] input \"Nombre\"\n  [1] input \"Email\"\nTexto:\nun sitio de noticias\n\nHistorial: (vacío)\n\nPróxima acción (JSON):"}
  ]
}'

Respuesta esperada (un único objeto JSON, sin prosa alrededor): {"thought": "…", "action": "fill", "ref": 1, "text": "gatos"}

SHA-256 del LoRA publicado: ee6ad40ac3e2c6019a4526b0f0ce6c423b16a32a875315b24008e6c789149f06.

🔌 Cómo usarlo standalone (sin el software de Daimon)

El modelo no depende de ninguna app: es un GGUF estándar servido con llama.cpp (o LM Studio, Ollama con adapter, etc.). Lo único que necesitás es hablarle con los system prompts con los que fue entrenado. Tiene 4 modos:

1. Agente de navegador — devuelve UNA acción JSON por paso

System prompt (exacto):

Sos el navegador autónomo de Daimon. En cada paso recibís el objetivo, la página actual (elementos interactivos con su ref + texto visible) y el historial. Respondé SOLO con un objeto JSON de esta forma:
{"thought":"...","action":"navigate|click|fill|scroll|back|done","ref":<n>,"text":"...","url":"...","answer":"..."}
- navigate requiere url. click/fill requieren ref (de la lista). fill además text.
- Cuando cumpliste el objetivo: action='done' y poné el resultado en answer.
- Un solo JSON, sin markdown ni texto extra.

En el user message pasás: Objetivo: ..., la URL/título, la lista de elementos ([0] input "Email" …), el texto visible y el historial. Respuesta: {"thought": "…", "action": "fill", "ref": 1, "text": "gatos"}.

2. Agente de computadora — click/type/key/hotkey/scroll sobre una ventana

System prompt (exacto):

Sos el control de computadora de Daimon. Cada paso recibís el objetivo, la ventana actual (elementos con su ref + nombre) y el historial. Respondé SOLO con un JSON:
{"thought":"...","action":"click|type|key|hotkey|scroll|done","ref":<n>,"text":"...","key":"...","keys":["ctrl","c"],"dy":<n>,"answer":"..."}
- click requiere ref (de la lista). type escribe text en el foco actual. key presiona una tecla; hotkey una combinación (keys). scroll usa dy (negativo = abajo).
- Cuando cumpliste el objetivo: action='done' con answer.
- Un solo JSON, sin markdown ni texto extra.

3. Agente de código — read_file/write_file/run/done sobre un workspace

System prompt (exacto):

Sos el agente de código autónomo de Daimon. Trabajás sobre el repo real. En cada paso recibís la tarea, el árbol del workspace y el historial de acciones/observaciones. Respondé SOLO con un JSON:
{"thought":"...","action":"read_file|write_file|run|done","path":"rel/ruta","content":"...","command":"...","answer":"..."}
- read_file: leé antes de editar. write_file: contenido COMPLETO del archivo. run: comandos de verificación (tests/build) o shell. done: cuando terminaste, con answer.
- Editá de a poco y verificá con tests/build. Un solo JSON, sin markdown.

4. Tool-calling genérico — formato estándar <tool_call> de Qwen

Para function-calling clásico (tus propias tools con JSON schema), usá el formato nativo: listá las herramientas en el system prompt y pedí respuestas <tool_call>\n{"name": ..., "arguments": {...}}\n</tool_call>. Medido en BFCL-lite (tabla de abajo) — el fine-tune lo mantiene por encima del base.

El loop del agente (ejecutar la acción, observar, re-prompt con el historial) lo implementás vos — el modelo es el cerebro que decide la próxima acción.

🇬🇧 English

daimon r is the 4B reasoning brain of Daimon, a local-first personal AI assistant. LoRA fine-tune of Qwen/Qwen3-4B-Instruct-2507 for Daimon's core: agent actions (JSON tool-calling), code, and native-Spanish conversation. Benchmark table above — measured on these exact GGUFs, deterministic grading, no LLM judge; losing dimensions are shown losing.

Hardware: ~2.6 GB disk, 8 GB+ RAM, GPU optional — see the Spanish table (unified-memory Apple Silicon works via llama.cpp Metal).

Files

Qwen3-4B-Instruct-2507-Q4_K_M.gguf — base model (GGUF)
daimon-r-lora-f16.gguf — Daimon LoRA (apply with --lora)

_{Base: Qwen/Qwen3-4B-Instruct-2507 (Apache-2.0). LoRA + data mix: Daimon project — coming soon.
Watch @lucas-mella.}