Instructions to use Ilides/cortex-0.3-0.02b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Ilides/cortex-0.3-0.02b with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Ilides/cortex-0.3-0.02b", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("Ilides/cortex-0.3-0.02b", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Ilides/cortex-0.3-0.02b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Ilides/cortex-0.3-0.02b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ilides/cortex-0.3-0.02b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Ilides/cortex-0.3-0.02b

SGLang

How to use Ilides/cortex-0.3-0.02b with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Ilides/cortex-0.3-0.02b" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ilides/cortex-0.3-0.02b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Ilides/cortex-0.3-0.02b" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Ilides/cortex-0.3-0.02b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Ilides/cortex-0.3-0.02b with Docker Model Runner:
```
docker model run hf.co/Ilides/cortex-0.3-0.02b
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

cortex-0.3-0.02b

GPT conversacional de 20,6M parámetros, entrenado desde cero en NumPy puro (sin PyTorch durante el entrenamiento) sobre un corpus bilingüe ES/EN de 473M tokens y afinado en español para conversación.

20.648.832 parámetros · 6 capas × 384 · 8 cabezas · ctx 512 · vocab 16.384
Arquitectura: GPT pre-norm, RMSNorm + SwiGLU + atención causal con QKV fusionado, embeddings atados, sin sesgos (estilo Llama/GPT-3)
Entrenado con Accelerate BLAS + numexpr en CPU (MacBook, ~4.400 tok/s)

Resultados

etapa	tokens	val loss	ppl
pretrain bilingüe (en curso, paso 11k/29k)	473M (53% ES / 47% EN)	3.475 → 3.463	31.9
SFT de chat (ES + mates + código) · paso 2250/3000	18.4M	2.566	13.01

Test real contra otros modelos

Bits por byte en el mismo texto held-out (343k caracteres del split de test — métrica justa entre tokenizadores distintos; menor = mejor):

modelo	parámetros	bpb
cortex-0.3-0.02b	20.6M	0.540
SmolLM2-135M	135M	0.777
pythia-70m	70M	0.980
gpt2	124M	1.138
distilgpt2	82M	1.202

Honestidad del benchmark: el texto de test es de Wikipedia (dominio mayoritario del corpus de entrenamiento de Cortex), así que hay ventaja de dominio; y gpt2/distilgpt2 están entrenados sobre todo en inglés mientras el texto es mayoritariamente español. La comparación es real pero favorable por partida doble — no demuestra que un modelo de 20M "supere" a uno de 135M en general.

Cómo ejecutarlo

Hugging Face transformers

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

tok = AutoTokenizer.from_pretrained("Ilides/cortex-0.3-0.02b", trust_remote_code=True)
mdl = AutoModelForCausalLM.from_pretrained("Ilides/cortex-0.3-0.02b", trust_remote_code=True)

msgs = [
    {"role": "system", "content": "Eres Cortex, un asistente en español."},
    {"role": "user", "content": "Hola, ¿qué eres?"},
]
prompt = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
ids = tok(prompt, return_tensors="pt")
out = mdl.generate(**ids, max_new_tokens=128, do_sample=True,
                   temperature=0.8, top_k=50, eos_token_id=0, pad_token_id=1)
print(tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True))

Requiere torch, transformers>=4.50 y regex (para el tokenizer). El modelado y el tokenizer son remote code (trust_remote_code=True), verificados por test de equivalencia: los logits de PyTorch coinciden con la implementación NumPy original con max|Δ| = 3.1e-5.

Repositorio nativo (el que entrenó el modelo)

./.venv/bin/python generate.py "La capital de Francia es" \
  --checkpoint <ckpt>.npz --tokenizer datasets/processed/v0.1/tokenizer.json
./.venv/bin/python webui/server.py --checkpoint <ckpt>.npz   # chat + visor 3D

Formato de los pesos

model.safetensors usa nombres convencionales (mapeo completo en modeling_cortex.py):

HF	original NumPy
`model.embed_tokens.weight`	`tok_emb.w`
`model.embed_positions.weight`	`pos_emb.w`
`model.layers.i.self_attn.qkv.weight`	`blocks.i.attn.wqkv.T`
`model.layers.i.mlp.gate/up/down_proj.weight`	`mlp.w1/w3/w2.T`
`model.norm.weight`	`final_norm.g`

Limitaciones

20,6M parámetros y ventana de 512 tokens: comete errores factuales frecuentes; es un modelo de demostración, no de producción.
El pretraining sigue en curso en el momento de publicar este snapshot (paso ~11k/29k); habrá versiones con más pasos.
Datos: Wikipedia CC BY-SA 3.0/GFDL + corpus abierto ES/EN; el tokenizer es BPE propio de 16.384 tokens.

Licencia del código y pesos

Apache-2.0 (código de modelado y pesos derivados de entrenamiento propio). Los textos de Wikipedia conservan CC BY-SA 3.0/GFDL.

Downloads last month: 215

Safetensors

Model size

20.6M params

Tensor type

F32

Model tree for Ilides/cortex-0.3-0.02b

Finetunes

1 model

Quantizations

1 model