Upload folder using huggingface_hub

README.md

@@ -0,0 +1,43 @@
+---
+library_name: mlx
+pipeline_tag: text-generation
+license: apache-2.0
+base_model: Ilides/cortex-0.3-0.02b
+tags:
+  - cortex
+  - mlx
+  - apple-silicon
+---
+
+# cortex-0.3-0.02b · MLX (Apple Silicon)
+
+Versión **MLX** (Metal) de [Ilides/cortex-0.3-0.02b](https://huggingface.co/Ilides/cortex-0.3-0.02b), el GPT conversacional de 20.6 M parámetros entrenado desde cero en NumPy puro. Ejecuta nativamente en Apple Silicon sin PyTorch.
+
+## Requisitos
+
+```bash
+pip install mlx safetensors transformers regex
+```
+
+## Uso
+
+```bash
+# batería de prompts de prueba (por defecto)
+python generate_mlx.py
+
+# una pregunta
+python generate_mlx.py "¿Qué eres?" --max-new 128
+
+# chat interactivo (escribe "salir" para terminar)
+python generate_mlx.py --interactive --temperature 0.8
+```
+
+Bundle autocontenido: `weights.safetensors` (45 tensores) + `model.py` (arquitectura) + `generate_mlx.py` (CLI) + tokenizer. No depende de `mlx-lm` ni de código externo del Hub.
+
+## Verificación
+
+Paridad de logits MLX vs NumPy (implementación de referencia): **max|Δ| = 3.65e-05** (< 1e-4). Tokens EOS efectivos: `{0, 6}`.
+
+## Arquitectura
+
+`cortex`: embeddings de posición aprendidos (sin RoPE), RMSNorm + atención multi-cabeza + SwiGLU, embeddings atados (`tie_word_embeddings`). Contexto 512, 6 capas, d_model 192, vocab 16384 (BPE byte-level).

config.json

@@ -0,0 +1,25 @@
+{
+  "_name_or_path": "cortex-0.3-0.02b",
+  "architectures": [
+    "CortexForCausalLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_cortex.CortexConfig",
+    "AutoModelForCausalLM": "modeling_cortex.CortexForCausalLM",
+    "AutoTokenizer": "tokenization_cortex.CortexTokenizer"
+  },
+  "bos_token_id": 0,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "hidden_size": 384,
+  "initializer_std": 0.02,
+  "intermediate_size": 1536,
+  "max_position_embeddings": 512,
+  "model_type": "cortex",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 6,
+  "pad_token_id": 1,
+  "rms_norm_eps": 1e-05,
+  "transformers_version": "4.57.6",
+  "vocab_size": 16384
+}

generate_mlx.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Chat con Cortex-1 en MLX (Apple Silicon, Metal).
+
+Uso:
+    python generate_mlx.py                      # batería de prueba
+    python generate_mlx.py "tu pregunta"        # one-shot
+    python generate_mlx.py --interactive        # REPL
+Requisitos: pip install mlx transformers regex safetensors
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+import mlx.core as mx
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+from model import Model
+from tokenization_cortex import CortexTokenizer
+
+SYSTEM = "Eres Cortex, un asistente en español. Habla claro y conciso."
+BATERIA = [
+    "Hola, ¿qué eres y quién te creó?",
+    "Explícame la fotosíntesis en dos frases.",
+    "¿Cuánto es 17 × 24? Razona paso a paso.",
+    "Escribe una frase creativa sobre un robot que aprende a pintar.",
+    "What is the capital of France? Answer in English.",
+]
+
+
+def construir_prompt(tok, pregunta: str) -> str:
+    return (f"<|system|>\n{SYSTEM}\n<|end|>\n"
+            f"<|user|>\n{pregunta}\n<|end|>\n"
+            f"<|assistant|>\n")
+
+
+def responder(model, tok, pregunta, temp=0.8, top_k=50, max_new=160):
+    prompt = construir_prompt(tok, pregunta)
+    ids = np.array([tok.encode(prompt, add_special_tokens=False)], dtype=np.int64)
+    out_ids = []
+    for _ in range(max_new):
+        logits = np.asarray(model.logits(mx.array(ids[:, -512:]))[0, -1])
+        if out_ids and out_ids[-1] == 0:
+            break
+        if temp <= 0:
+            nxt = int(np.argmax(logits))
+        else:
+            logits = logits / temp
+            if top_k > 0:
+                kth = np.partition(logits, -top_k)[-top_k]
+                logits = np.where(logits < kth, -np.inf, logits)
+            p = np.exp(logits - logits.max())
+            p /= p.sum()
+            nxt = int(np.random.choice(len(p), p=p))
+        out_ids.append(nxt)
+        ids = np.concatenate([ids, [[nxt]]], axis=1)
+        if nxt == 0:
+            break
+    return tok.decode(out_ids, skip_special_tokens=True).strip()
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("prompt", nargs="*")
+    ap.add_argument("--interactive", action="store_true")
+    ap.add_argument("--temperature", type=float, default=0.8)
+    ap.add_argument("--top-k", type=int, default=50)
+    ap.add_argument("--max-new", type=int, default=160)
+    args = ap.parse_args()
+
+    print(f"cargando modelo MLX desde {HERE} …", flush=True)
+    model = Model.load(HERE)
+    tok = CortexTokenizer(vocab_file=os.path.join(HERE, "vocab.json"),
+                          merges_file=os.path.join(HERE, "merges.txt"),
+                          model_max_length=512, unk_token="<|unk|>",
+                          bos_token="</s>", eos_token="</s>",
+                          pad_token="<|pad|>")
+    print("listo (MLX/Metal). Escribe 'salir' para terminar.\n", flush=True)
+
+    if args.interactive:
+        while True:
+            try:
+                q = input("TÚ > ").strip()
+            except (EOFError, KeyboardInterrupt):
+                break
+            if not q or q == "salir":
+                break
+            print("CORTEX >", responder(model, tok, q, args.temperature,
+                                        args.top_k, args.max_new), "\n")
+        return 0
+
+    for q in args.prompt or BATERIA:
+        print(f"TÚ > {q}")
+        r = responder(model, tok, q, args.temperature, args.top_k, args.max_new)
+        print(f"CORTEX > {r}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

model.py

@@ -0,0 +1,96 @@
+"""Cortex-1 en MLX (Apple Silicon) — equivalente a la implementación NumPy/PyTorch.
+
+Misma arquitectura: GPT pre-norm, RMSNorm, atención causal con QKV fusionado,
+SwiGLU, embeddings de posición aprendidos, lm_head atado al embedding.
+Paridad verificada: max|Δ logits| < 1e-4 vs el modelo NumPy original.
+
+Uso:  python generate_mlx.py "La capital de Francia es"
+"""
+from __future__ import annotations
+
+import json
+import os
+
+import mlx.core as mx
+import mlx.nn as nn
+
+MODEL_FILE = "weights.safetensors"
+
+
+class Attention(nn.Module):
+    def __init__(self, d: int, n_heads: int):
+        super().__init__()
+        self.n_heads = n_heads
+        self.d_head = d // n_heads
+        self.scale = self.d_head ** -0.5
+        self.qkv = nn.Linear(d, 3 * d, bias=False)
+        self.proj = nn.Linear(d, d, bias=False)
+
+    def __call__(self, x: mx.array) -> mx.array:
+        B, T, d = x.shape
+        qkv = self.qkv(x).reshape(B, T, 3, self.n_heads, self.d_head)
+        q, k, v = (qkv[:, :, i].transpose(0, 2, 1, 3) for i in range(3))
+        att = (q @ k.transpose(0, 1, 3, 2)) * self.scale          # (B,H,T,T)
+        mask = mx.triu(mx.full((T, T), -mx.inf, dtype=att.dtype), k=1)
+        att = mx.softmax(att + mask, axis=-1)
+        y = (att @ v).transpose(0, 2, 1, 3).reshape(B, T, d)
+        return self.proj(y)
+
+
+class MLP(nn.Module):
+    def __init__(self, d: int, d_ff: int):
+        super().__init__()
+        self.gate_proj = nn.Linear(d, d_ff, bias=False)
+        self.up_proj = nn.Linear(d, d_ff, bias=False)
+        self.down_proj = nn.Linear(d_ff, d, bias=False)
+
+    def __call__(self, x: mx.array) -> mx.array:
+        return self.down_proj(nn.silu(self.gate_proj(x)) * self.up_proj(x))
+
+
+class Block(nn.Module):
+    def __init__(self, d: int, n_heads: int, d_ff: int, eps: float):
+        super().__init__()
+        self.input_layernorm = nn.RMSNorm(d, eps=eps)
+        self.self_attn = Attention(d, n_heads)
+        self.post_attention_layernorm = nn.RMSNorm(d, eps=eps)
+        self.mlp = MLP(d, d_ff)
+
+    def __call__(self, x):
+        x = x + self.self_attn(self.input_layernorm(x))
+        return x + self.mlp(self.post_attention_layernorm(x))
+
+
+class Model(nn.Module):
+    def __init__(self, cfg: dict):
+        super().__init__()
+        d = cfg["hidden_size"]
+        self.cfg = cfg
+        self.embed_tokens = nn.Embedding(cfg["vocab_size"], d)
+        self.embed_positions = nn.Embedding(cfg["max_position_embeddings"], d)
+        self.layers = [Block(d, cfg["num_attention_heads"],
+                             cfg["intermediate_size"], cfg["rms_norm_eps"])
+                       for _ in range(cfg["num_hidden_layers"])]
+        self.norm = nn.RMSNorm(d, eps=cfg["rms_norm_eps"])
+
+    def __call__(self, input_ids: mx.array) -> mx.array:
+        T = input_ids.shape[1]
+        h = self.embed_tokens(input_ids) + self.embed_positions(mx.arange(T))
+        for layer in self.layers:
+            h = layer(h)
+        return self.norm(h)
+
+    def logits(self, input_ids: mx.array) -> mx.array:
+        """(B,T) int -> (B,T,V); lm_head atado = embed_tokens."""
+        h = self(input_ids)
+        w = self.embed_tokens.weight            # (V, d)
+        return h @ w.T
+
+    @classmethod
+    def load(cls, repo: str) -> "Model":
+        with open(os.path.join(repo, "config.json")) as f:
+            cfg = json.load(f)
+        model = cls(cfg)
+        weights = mx.load(os.path.join(repo, MODEL_FILE))
+        model.load_weights(list(weights.items()), strict=True)
+        return model

special_tokens_map.json

@@ -0,0 +1,14 @@
+{
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "pad_token": "<|pad|>",
+  "unk_token": "<|unk|>",
+  "additional_special_tokens": [
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>",
+    "<|end|>",
+    "<|doc|>",
+    "<|code|>"
+  ]
+}

tokenization_cortex.py

@@ -0,0 +1,129 @@
+"""Tokenizer de Cortex-1 para Hugging Face (equivalente exacto al BPE byte-level propio)."""
+import json
+import regex
+from transformers import PreTrainedTokenizer
+
+PRETOKEN = regex.compile(
+    r"""'(?:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]++[\r\n]*|\s*[\r\n]|\s+(?!\S)|\s+"""
+)
+
+
+def bytes_to_unicode():
+    """Tabla GPT-2: byte -> carácter imprimible (idéntica a la del modelo propio)."""
+    bs = (list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1))
+          + list(range(ord("®"), ord("ÿ") + 1)))
+    cs = bs[:]
+    n = 0
+    for b in range(256):
+        if b not in bs:
+            bs.append(b)
+            cs.append(256 + n)
+            n += 1
+    return dict(zip(bs, (chr(c) for c in cs)))
+
+
+_B2U = bytes_to_unicode()
+_U2B = {v: k for k, v in _B2U.items()}
+
+
+class CortexTokenizer(PreTrainedTokenizer):
+    """BPE byte-level idéntico a ``cortex.tokenizer.encoder.BPETokenizer``.
+
+    El pre-tokenizador usa el MISMO regex (poseedores y lookahead incluidos,
+    vía librería ``regex``) y los merges se aplican por orden de aprendizaje;
+    el test de paridad encode(tok propio) == encode(tok HF) lo verifica.
+    """
+
+    vocab_files_names = {"vocab_file": "vocab.json", "merges_file": "merges.txt"}
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(self, vocab_file=None, merges_file=None, **kwargs):
+        with open(vocab_file, encoding="utf-8") as f:
+            self._vocab = json.load(f)          # {token: id}
+        with open(merges_file, encoding="utf-8") as f:
+            merge_lines = [ln.strip() for ln in f if ln.strip() and not ln.startswith("#")]
+        self._merges = {tuple(ln.split()): i for i, ln in enumerate(merge_lines)}
+        self._id2tok = {i: t for t, i in self._vocab.items()}
+        self._cache = {}
+        super().__init__(vocab_file=vocab_file, merges_file=merges_file, **kwargs)
+
+    @property
+    def vocab_size(self):
+        return len(self._vocab)
+
+    def get_vocab(self):
+        """Requerido por transformers (_add_tokens lo llama en __init__)."""
+        return dict(self._vocab)
+
+    # ------------------------------------------------------------ tokenización
+    def _bpe(self, word: str):
+        if word in self._cache:
+            return self._cache[word]
+        parts = list(word)
+        while len(parts) > 1:
+            pairs = list(zip(parts, parts[1:]))
+            best = min(pairs, key=lambda p: self._merges.get(p, float("inf")))
+            if best not in self._merges:
+                break
+            out, i = [], 0
+            while i < len(parts):
+                if i < len(parts) - 1 and (parts[i], parts[i + 1]) == best:
+                    out.append(parts[i] + parts[i + 1])
+                    i += 2
+                else:
+                    out.append(parts[i])
+                    i += 1
+            parts = out
+        self._cache[word] = parts
+        return parts
+
+    def _split_specials(self, text: str):
+        """Parte el texto conservando literales <|x|> como tokens (ids 0-8)."""
+        sp = sorted((s for s in self._vocab if s.startswith("<|") and s.endswith("|>")),
+                    key=len, reverse=True)
+        out, i, buf = [], 0, ""
+        while i < len(text):
+            hit = next((s for s in sp if text.startswith(s, i)), None)
+            if hit:
+                if buf:
+                    out.append(("text", buf)); buf = ""
+                out.append(("special", hit)); i += len(hit)
+            else:
+                buf += text[i]; i += 1
+        if buf:
+            out.append(("text", buf))
+        return out
+
+    def _tokenize(self, text):
+        tokens = []
+        for kind, chunk in self._split_specials(text):
+            if kind == "special":
+                tokens.append(chunk)
+                continue
+            for word in PRETOKEN.findall(chunk):
+                encoded = "".join(_B2U[b] for b in word.encode("utf-8"))
+                tokens.extend(self._bpe(encoded))
+        return tokens
+
+    # ------------------------------------------------------------ conversión
+    def _convert_token_to_id(self, token):
+        return self._vocab.get(token, self._vocab.get("<|unk|>", 0))
+
+    def _convert_id_to_token(self, index):
+        return self._id2tok.get(index, "<|unk|>")
+
+    def convert_tokens_to_string(self, tokens):
+        return "".join(tokens)
+
+    def _decode(self, token_ids, skip_special_tokens=False, **kwargs):
+        pieces = []
+        for i in token_ids:
+            tok = self._id2tok.get(int(i))
+            if tok is None:
+                continue
+            if skip_special_tokens and tok in self.all_special_tokens:
+                continue
+            pieces.append(tok)
+        raw = "".join(pieces)
+        data = bytes(_U2B[c] for c in raw if c in _U2B)
+        return data.decode("utf-8", errors="replace")

tokenizer_config.json

@@ -0,0 +1,27 @@
+{
+  "tokenizer_class": "CortexTokenizer",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_cortex.CortexTokenizer",
+      null
+    ]
+  },
+  "model_max_length": 512,
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "pad_token": "<|pad|>",
+  "unk_token": "<|unk|>",
+  "additional_special_tokens": [
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>",
+    "<|end|>",
+    "<|doc|>",
+    "<|code|>"
+  ],
+  "chat_template": "{% for message in messages %}{% if message['role'] == 'system' %}<|system|>\n{{ message['content'] }}\n<|end|>\n{% elif message['role'] == 'user' %}<|user|>\n{{ message['content'] }}\n<|end|>\n{% else %}<|assistant|>\n{{ message['content'] }}\n<|end|>\n{% endif %}{% endfor %}{% if add_generation_prompt %}<|assistant|>\n{% endif %}",
+  "tokenizer_files": [
+    "vocab.json",
+    "merges.txt"
+  ]
+}

weights.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c6de87791adce6695e426f7b6aa5d29ac6005c5391da34ff7f82f639d870d72
+size 82599888