---
language:
- es
- en
license: apache-2.0
library_name: transformers
tags:
- code
- code-generation
- qwen2
- lora
- gguf
base_model: Qwen/Qwen2.5-Coder-7B-Instruct
model_creator: Korzadi
model_name: Atomic Code 1.1
pipeline_tag: text-generation
---

# Atomic Code 1.1

**Atomic Code 1.1** es la distribución oficial, completa e independiente de la familia de modelos **Atomic**, entrenada por **Korzadi**. Este repositorio unifica la experiencia de despliegue ofreciendo los pesos completos fusionados de alta precisión, el adaptador LoRA original para desarrollo flexible y versiones optimizadas en formato GGUF.

## 🪐 Estructura de la Distribución

Para garantizar la máxima flexibilidad sin colisiones en el ecosistema Hugging Face, el repositorio se organiza de la siguiente manera:

1. **Pesos Consolidados (Modelo Completo):** Ubicados bajo la carpeta `consolidated/` en precisión `bfloat16`/`float16` nativa, listos para cargarse directamente en entornos de producción con `transformers`.
2. **Adaptador LoRA Original:** Ubicado en la raíz (`adapter_model.safetensors` y `adapter_config.json`) para cargas dinámicas usando PEFT con Unsloth sobre `Qwen2.5-Coder-7B-Instruct`.
3. **Cuantizaciones GGUF:** Disponibles en la carpeta `gguf/` para inferencia local rápida en CPU/Edge usando `llama.cpp` u `Ollama`.

---

## 📊 Ficha Técnica y Especificaciones

| Parámetro | Valor de Especificación |
| :--- | :--- |
| **Creador / Autor** | Korzadi |
| **Arquitectura Base** | Qwen2 (`Qwen2ForCausalLM`) |
| **Modelo Base de Origen** | Qwen2.5-Coder-7B-Instruct |
| **Tamaño de Parámetros** | ~7.61 Billones |
| **Dimensión Oculta (Hidden Size)** | 3584 |
| **Tamaño de Vocabulario** | 152064 |
| **Longitud de Contexto** | 32,768 tokens (ampliable) |
| **Formato de Pesos** | Safetensors |
| **Dtype de Inferencia Recomendado** | `bfloat16` o `float16` |

---

## 🛠️ Guía de Uso e Inferencia (Transformers)

### 1. Cargar el Modelo Completo Consolidado

Para ejecutar la versión de pesos consolidados e independientes directamente desde la subcarpeta dedicada:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "Korzadi/Atomic-Code-1.1"

# Carga del tokenizador y el modelo consolidado
tokenizer = AutoTokenizer.from_pretrained(model_id, subfolder="consolidated")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    subfolder="consolidated",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Prompt de ejemplo
prompt = "Escribe una función en Python para validar una dirección IP v4 y v6."
messages = [
    {"role": "system", "content": "Eres Atomic Code, un asistente de programación experto de nivel Senior."},
    {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512)
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)
```

### 2. Cargar como Adaptador PEFT / LoRA

Si deseas utilizar el adaptador ligero cargándolo dinámicamente sobre la base original:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

base_model_id = "Qwen/Qwen2.5-Coder-7B-Instruct"
adapter_id = "Korzadi/Atomic-Code-1.1"

tokenizer = AutoTokenizer.from_pretrained(base_model_id)
base_model = AutoModelForCausalLM.from_pretrained(base_model_id, torch_dtype=torch.bfloat16, device_map="auto")
model = PeftModel.from_pretrained(base_model, adapter_id)
```

---

## 🎛️ Configuración para Ollama y Llama.cpp

Para ejecutar el modelo localmente utilizando el archivo unificado `atomic-code-Q4_K_M.gguf` provisto en el repositorio, crea un archivo `Modelfile`:

```dockerfile
FROM ./gguf/atomic-code-Q4_K_M.gguf

# Configurar parámetros del sistema
PARAMETER temperature 0.2
PARAMETER top_p 0.95
PARAMETER stop <|im_start|>
PARAMETER stop <|im_end|>

TEMPLATE """<|im_start|>system
Eres Atomic Code, un asistente de programación altamente calificado creado por Korzadi.<|im_end|>
<|im_start|>user
{{ .Prompt }}<|im_end|>
<|im_start|>assistant
"""
```

Ejecuta en tu terminal:
```bash
ollama create atomic-code-1.1 -f Modelfile
ollama run atomic-code-1.1
```

---

## 📝 Historial de Versiones e Integridad
- **v1.0 (Free):** Publicación inicial de distribución.
- **v1.1 (Active Adapter):** Ajuste fino de precisión entrenado mediante QLoRA y Unsloth enfocado en el dominio de desarrollo de software.
- **v1.2 (Consolidated):** Fusión completa de pesos consolidados en topología FP16/BF16 para garantizar compatibilidad nativa sin capas de adaptación adicionales.

## 📄 Licencia
Este modelo se distribuye bajo la licencia **Apache 2.0**.

---
*Ficha oficial generada para el ecosistema Korzadi / Atomic.*


## 🚀 Cómo usar Atomic Code 1.1

### Opción 1: Carga del Checkpoint Completo Consolidado (BF16)
Para cargar la versión consolidada y ajustada del modelo completo (sin necesidad de cargar adaptadores por separado), debes apuntar explícitamente a la subcarpeta `consolidated`:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "Korzadi/Atomic-Code-1.1"

# Carga de Tokenizer y Modelo especificando subfolder
tokenizer = AutoTokenizer.from_pretrained(model_id, subfolder="consolidated")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    subfolder="consolidated",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Inferencia
messages = [
    {"role": "system", "content": "You are Atomic Code, an advanced coding assistant."},
    {"role": "user", "content": "Escribe una función de ordenamiento rápido en Python."}
]

formatted_chat = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(formatted_chat, return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512, do_sample=True, temperature=0.7)
print(tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True))
```

### Opción 2: Carga mediante Adaptador LoRA (PEFT)
Si prefieres utilizar el adaptador LoRA sobre el modelo base original de Qwen:

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

base_model_id = "Qwen/Qwen2.5-Coder-7B-Instruct"
adapter_id = "Korzadi/Atomic-Code-1.1"

tokenizer = AutoTokenizer.from_pretrained(base_model_id)
base_model = AutoModelForCausalLM.from_pretrained(
    base_model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

model = PeftModel.from_pretrained(base_model, adapter_id)
```

### Opción 3: Inferencia local con GGUF (llama.cpp)
El modelo de cuantización intermedia recomendado está disponible en:
`gguf/atomic-code-Q4_K_M.gguf`