Lilgarca/my-model-v02

Cyrah

Modelo Cyrah, creado por Juan Ignacio Robledo.

Arquitectura propia cyrah (CyrahAnyToAnyForConditionalGeneration), entrenada desde cero sobre un decodificador hibrido de 14 capas y 1024 de hidden (236 M de parametros) que unifica en un solo bloque las ideas de atencion, mezcla de expertos y convolucion corta que hoy dominan los modelos abiertos.

Componente	Que aporta
Gated DeltaNet-2	memoria lineal con decaimiento acotado, sin matriz de atencion
Attention Residuals	camino residual por capa sobre la salida de atencion
SwiGLU / SiTU	activacion de la MLP densa y de la mezcla de expertos
RoPE parcial + QK-norm	rotacion solo en la mitad de la cabeza, norma en Q y K
XSA	atencion con estado extra compartido entre cabezas
Convolucion corta dual-gate	mezcla local de 3 pasos con puerta previa y posterior
Ventana deslizante	atencion local alternada con atencion completa
Puerta de salida de atencion	escala aprendida por cabeza sobre la salida
MLA con compresion latente	cache KV comprimido en un latente de baja dimension
MoE sqrtsoftplus / sigmoid	enrutado suave y estable de expertos
Indexador DSA	seleccion dispersa de claves relevantes
RoPE intercalado	pares real/imaginario intercalados en lugar de mitades
K == V	una sola proyeccion para clave y valor
Softcapping de logits	cota tanh sobre los logits finales

Plan de capas: conv (convolucion corta) y full_attention alternadas, con linear_attention (GDN-2) y sliding_attention disponibles por configuracion. La MLP es densa en la primera capa y mezcla de expertos en el resto. El tokenizer de texto se reutiliza tal cual, sin introducir uno nuevo.

Los pesos se entrenan de forma autonoma y continua sobre datasets reales de HF.co (chat, razonamiento, matematicas, tool calling y conocimiento) mas un corpus sintetico de identidad.

Modalidades

Cyrah es omni: no hay cabezas separadas por modalidad. Todo se expresa como tokens en un unico vocabulario plano y una sola cabeza causal los predice, asi que cualquier modalidad puede condicionar a cualquier otra.

Rango	Modalidad	Tamano
0 .. 64031	texto	64032
64032 .. 65055	audio (4 codebooks RVQ x 256)	1024
65056 .. 65311	imagen y video (VQ 256)	256
65312 .. 65439	3D (nubes gaussianas, mallas)	128
65440 .. 65503	senal (series, sensores, acciones)	64
65504 .. 65535	especiales (think, tool, modalidad)	32

El vocabulario total sigue siendo 65536, exactamente el del tokenizer de texto: los rangos de modalidad se recortan de la cola del vocabulario en lugar de anadirse despues, asi que el embedding y la cabeza siguen atados y el modelo ocupa lo mismo que el backbone de texto.

Cuatro codecs neuronales convierten la senal continua a ese vocabulario y de vuelta:

• CyrahAudioCodec — autoencoder convolucional con cuantizacion residual (RVQ) de 8 codebooks. 24 kHz, hop 320, 75 tokens/s por codebook (600 tokens/s en total).
• CyrahImageCodec — autoencoder convolucional con cuantizacion vectorial (VQ) de 8192 entradas. 128x128 px, rejilla 16x16, 256 tokens por imagen.
• CyrahGaussianCodec — VQ sobre nubes de puntos gaussianas de 14 canales (xyz, armónicos esféricos DC, opacidad, escala, cuaternion).
• CyrahSignalCodec — VQ sobre series temporales de 8 canales.

El video se trata como una secuencia de fotogramas codificados con el codec de imagen, y la edicion como continuacion del flujo de tokens con la modalidad marcada. Una modality_embed aprendida (95 filas, una por modalidad) se suma al embedding de token para que la pila sepa que esta leyendo.

model = AutoModelForCausalLM.from_pretrained("lilgarca/my-model-v02", trust_remote_code=True)
model.ensure_codecs()

tokens = model.image_to_tokens(pil_image)          # -> ids del rango imagen
wav    = model.tokens_to_audio(model.audio_to_tokens(waveform))
out    = model.generate_omni(ids, max_new_tokens=256)
model.split_tokens(out[0])                          # -> {texto, audio, imagen}

# any-to-any: la entrada y la salida pueden ser cualquier modalidad
ids, mods = model.generate_any([("text", prompt_ids)], max_new_tokens=256)
model.decode_any(ids, mods)                         # -> {"text": [...], "audio": [...]}

Los codecs se inicializan con el modelo y necesitan su propio entrenamiento de reconstruccion antes de que el audio y las imagenes sean inteligibles; el bucle autonomo ya reserva una pasada para eso.

Calidad seleccionable

La resolucion de cada modalidad no esta fijada en el codigo: se elige por peticion con el parametro quality (auto, minimo, bajo, medio, alto, maximo). auto la deduce del hardware disponible. Cada nivel ajusta audio_codebooks, image_grid, video_frames, video_fps, gaussian_tokens, signal_tokens, top_k y el numero de pasos de entrenamiento.

ids, mods = model.generate_any(
    [("text", prompt_ids)], quality="maximo", max_new_tokens=512)

Capacidades

• Identidad propia: responde que se llama Cyrah y que su creador es Juan Ignacio Robledo.
• Razonamiento explicito con thinking ... </think>.
• Tool calling con <|tool_call_start|>[fn(arg='valor')]<|tool_call_end|>.
• 95 modalidades en un solo flujo de tokens, agrupadas en texto, audio, imagen, video, 3D, ciencia, meta y conversiones.
• Texto, codigo, matematicas, traduccion, OCR, tablas y grafos.
• Audio: voz (TTS), musica, efectos y edicion de audio.
• Imagen: generacion, edicion, inpaint, upscale, restauracion, estilo, profundidad, normales, segmentacion, deteccion y pose.
• Video: generacion, edicion, tracking, movimiento y modelos de mundo.
• 3D: nubes gaussianas, mallas, nubes de puntos y avatares.
• Ciencia: moleculas, proteinas, ADN, series temporales, sensores y acciones.
• Meta: embeddings, VQA y evaluacion.
• 49 conversiones explicitas entre modalidades (txt2img, img2vid, vid2audio, audio2music, 3d2mesh, sig2action, ...).
• Edicion: la salida se genera condicionada al contenido de entrada.
• Calidad seleccionable por peticion (auto, minimo ... maximo).

Arquitecturas descubiertas en HF.co

El bucle lee el config.json real de modelos publicados de cada modalidad y pliega el consenso de sus hiperparametros en la configuracion de Cyrah. Ultimo barrido: 11 modelos en 6 modalidades.

Modalidad	Modelo	Tipo	Hidden	Capas	Codebook	Hz
texto	HuggingFaceTB/SmolLM2-360M	llama	960	32	-	-
texto	Qwen/Qwen2.5-1.5B	qwen2	1536	28	-	-
audio	facebook/encodec_24khz	encodec	128	-	1024	24000
audio	facebook/encodec_32khz	encodec	128	-	2048	32000
musica	facebook/musicgen-small	encodec	128	24	2048	32000
musica	facebook/musicgen-melody	encodec	128	48	2048	32000
imagen	stabilityai/sd-vae-ft-mse	-	-	-	-	-
imagen	stabilityai/sd-vae-ft-ema	-	-	-	-	-
video	Wan-AI/Wan2.1-T2V-1.3B	t2v	-	-	-	-
omni	Qwen/Qwen2.5-Omni-3B	qwen2_5_omni	896	24	-	-
omni	google/gemma-3n-E4B-it	gemma3n_audio	1536	35	-	-

Uso por modalidad

Cada modalidad se invoca con el mismo modelo y el mismo tokenizer. Despliega la que necesites:

Texto, razonamiento y tool calling

from transformers import AutoModelForCausalLM, AutoTokenizer

tok = AutoTokenizer.from_pretrained("lilgarca/my-model-v02")
model = AutoModelForCausalLM.from_pretrained("lilgarca/my-model-v02", trust_remote_code=True)

msgs = [{"role": "user", "content": "Como te llamas?"}]
ids = tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt")
print(tok.decode(model.generate(ids, max_new_tokens=128)[0][ids.shape[-1]:],
                 skip_special_tokens=False))

Para razonamiento explicito pide thinking ... </think>; para herramientas el modelo emite <|tool_call_start|>[fn(arg='valor')]<|tool_call_end|>.

Texto a audio (TTS)

model.ensure_codecs()
ids, mods = model.generate_any(
    [("text", tok("Di: hola, soy Cyrah.").input_ids)],
    max_new_tokens=600, quality="alto")
wav = model.tokens_to_audio(model.decode_any(ids, mods)["audio"][0])
# wav: tensor float32 a model.config.audio_sample_rate (24 kHz)

Texto a musica

ids, mods = model.generate_any(
    [("text", tok("Genera 8 segundos de musica lo-fi con piano.").input_ids)],
    max_new_tokens=1200, quality="maximo")
wav = model.tokens_to_audio(model.decode_any(ids, mods)["audio"][0])

Texto a imagen

ids, mods = model.generate_any(
    [("text", tok("Un faro al atardecer, oleo.").input_ids)],
    max_new_tokens=256, quality="alto")
img = model.tokens_to_image(model.decode_any(ids, mods)["image"][0])
img.save("salida.png")

Imagen a imagen (edicion, estilo, upscale, inpaint)

from PIL import Image
src = Image.open("entrada.png").convert("RGB")

prefix = [("image", model.image_to_tokens(src))]
head   = tok("Convierte a acuarela.").input_ids
ids, mods = model.generate_any(prefix + [("text", head)],
                               max_new_tokens=256, quality="alto")
model.tokens_to_image(model.decode_any(ids, mods)["image"][0]).save("editada.png")

Texto a video

ids, mods = model.generate_any(
    [("text", tok("Olas rompiendo en una playa, 8 fotogramas.").input_ids)],
    max_new_tokens=2048, quality="medio")
frames = model.tokens_to_video(model.decode_any(ids, mods)["image"][0],
                               frames=8)
# frames: lista de PIL.Image; guarda como gif o mp4
frames[0].save("salida.gif", save_all=True, append_images=frames[1:], duration=125)

Video a video

import imageio.v3 as iio
src = [Image.fromarray(f) for f in iio.imread("entrada.mp4")]

prefix = [("image", model.video_to_tokens(src))]
ids, mods = model.generate_any(prefix + [("text", tok("Ponlo en blanco y negro.").input_ids)],
                               max_new_tokens=2048, quality="medio")
frames = model.tokens_to_video(model.decode_any(ids, mods)["image"][0],
                               frames=len(src))

Texto a 3D (nubes gaussianas, mallas)

ids, mods = model.generate_any(
    [("text", tok("Una taza de cafe en 3D.").input_ids)],
    max_new_tokens=512, quality="alto")
prims = model.tokens_to_gaussian(model.decode_any(ids, mods)["3d"][0])
model.to_ply(prims, "salida.ply")     # abre en cualquier visor de splats

Imagen a 3D

prefix = [("image", model.image_to_tokens(Image.open("objeto.png").convert("RGB")))]
ids, mods = model.generate_any(prefix, max_new_tokens=512, quality="alto")
model.to_ply(model.tokens_to_gaussian(model.decode_any(ids, mods)["3d"][0]),
             "objeto.ply")

Texto a senal (series temporales, sensores, acciones)

ids, mods = model.generate_any(
    [("text", tok("Una senal senoidal de 8 canales con ruido.").input_ids)],
    max_new_tokens=128, quality="medio")
sig = model.tokens_to_signal(model.decode_any(ids, mods)["signal"][0])
# sig: tensor (8, N)

Audio a audio (limpieza, cambio de estilo)

import soundfile as sf
wav, sr = sf.read("entrada.wav", dtype="float32")

prefix = [("audio", model.audio_to_tokens(wav))]
ids, mods = model.generate_any(prefix + [("text", tok("Quita el ruido.").input_ids)],
                               max_new_tokens=600, quality="alto")
out = model.tokens_to_audio(model.decode_any(ids, mods)["audio"][0])
sf.write("limpio.wav", out.numpy(), sr)

Audio a texto (transcripcion)

prefix = [("audio", model.audio_to_tokens(wav))]
ids, mods = model.generate_any(prefix + [("text", tok("Transcribe.").input_ids)],
                               max_new_tokens=256)
print(tok.decode(model.decode_any(ids, mods)["text"][0], skip_special_tokens=True))

Imagen a texto (caption, OCR, VQA)

prefix = [("image", model.image_to_tokens(Image.open("foto.png").convert("RGB")))]
ids, mods = model.generate_any(prefix + [("text", tok("Describe la imagen.").input_ids)],
                               max_new_tokens=256)
print(tok.decode(model.decode_any(ids, mods)["text"][0], skip_special_tokens=True))

Any-to-any (el modelo elige la salida)

# sin decir la modalidad de salida: el router decide
ids, mods = model.generate_any(
    [("text", tok("Explicame la fotosintesis y ponlo en audio.").input_ids)],
    max_new_tokens=800, quality="auto")
for modality, chunks in model.decode_any(ids, mods).items():
    print(modality, len(chunks))

Inspeccionar la configuracion en tiempo de ejecucion

print(model.describe())          # modalidades, rangos, codecs, calidad
print(model.config.token_layout())

configuration_cyrah.py y modeling_cyrah.py definen la arquitectura cyrah / CyrahAnyToAnyForConditionalGeneration; con trust_remote_code=True se cargan solos.

GGUF

llama.cpp no incluye convertidor para la arquitectura cyrah, asi que este repo se publica en formato transformers (safetensors + modeling_cyrah.py).

Entrenamiento

• Ciclo: 1
• Ejemplos del dataset: 34947
• Actualizado: 2026-11-08 01:05:55