Instructions to use Frankenstein-Labs/Cortex-MoE-565M with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Frankenstein-Labs/Cortex-MoE-565M with Transformers:

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

pipe = pipeline("text-generation", model="Frankenstein-Labs/Cortex-MoE-565M")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("Frankenstein-Labs/Cortex-MoE-565M", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Frankenstein-Labs/Cortex-MoE-565M with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Frankenstein-Labs/Cortex-MoE-565M"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-MoE-565M",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/Frankenstein-Labs/Cortex-MoE-565M

SGLang

How to use Frankenstein-Labs/Cortex-MoE-565M 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 "Frankenstein-Labs/Cortex-MoE-565M" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-MoE-565M",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

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 "Frankenstein-Labs/Cortex-MoE-565M" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Frankenstein-Labs/Cortex-MoE-565M",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use Frankenstein-Labs/Cortex-MoE-565M with Docker Model Runner:
```
docker model run hf.co/Frankenstein-Labs/Cortex-MoE-565M
```

Cortex-MoE-565M

Cortex-MoE-565M est un modèle de langage multimodal Mixture-of-Experts construit par Abdoulaye Coumbassa / Frankenstein-Labs, dérivé de GPT-2 base via sparse upcycling.

Dépôt GitHub : https://github.com/Frankenstein-Labs/Cortex
Licence : Cortex License v1.0

Architecture

Composant	Détail
Backbone texte	Transformer post-norm style GPT-2 (12 couches, 768 dim, 12 têtes, ctx 1024)
MoE	8 experts par couche, routage top-2 normalisé
Routeur	`Linear(768, 8)` ; perte d'équilibrage Switch + z-loss ; capacité 1,25
Tour visuelle	ViT léger (6 blocs pré-norm, 768 dim), patches 16×16, 224×224
Projecteur	MLP 2 couches + sous-échantillonnage à 64 tokens d'image
Paramètres	565M total / 181M actifs par token (ratio 0,32)

Origine des poids

Attention, layer-norms, embeddings : poids GPT-2 préservés bit à bit (GPT-2 est distribué par OpenAI sous licence MIT modifiée).
Experts : FFN dense de GPT-2 copié dans les 8 experts de chaque couche.
Routeurs : initialisation aléatoire (neufs).
Tour visuelle et projecteur : initialisation aléatoire (neufs).

Utilisation

import cortex_moe  # enregistre l'architecture "cortex_moe" dans Auto*
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("Frankenstein-Labs/Cortex-MoE-565M")
model = AutoModelForCausalLM.from_pretrained("Frankenstein-Labs/Cortex-MoE-565M")

# Texte seul
inputs = tokenizer("The capital of France is", return_tensors="pt")
generated = model.generate(**inputs, max_new_tokens=32)

# Multimodal (pixel_values : (B, 3, 224, 224), normalisé ImageNet)
import torch
pixel_values = torch.randn(1, 3, 224, 224)
generated = model.generate(**inputs, pixel_values=pixel_values, max_new_tokens=32)

Ou avec l'application de chat locale :

CORTEX_MODEL_DIR=. python app.py   # depuis le dossier du modèle téléchargé

Limites importantes

La tour visuelle est aléatoire : ce checkpoint est un upcycling de GPT-2, pas un modèle vision-langue entraîné. Les réponses fondées sur les images ne sont pas significatives tant que le modèle n'est pas affiné sur des données image-texte (train_cortex_moe.py dans le dépôt GitHub).
Les experts partagent le même FFN initial : la spécialisation n'apparaît qu'avec l'entraînement.
C'est un modèle de continuation de texte (GPT-2 base), pas un assistant instruction-tuné : réponses potentiellement répétitives ou inexactes, surtout en français. Ne pas utiliser comme source fiable pour des décisions importantes.

Entraînement

Le modèle est obtenu par conversion déterministe de gpt2 (sparse upcycling), sans phase d'entraînement supplémentaire. Le script de conversion et le script d'affinage sont dans le dépôt : https://github.com/Frankenstein-Labs/Cortex

Licence

Code et architecture : Cortex License v1.0 © 2026 Abdoulaye Coumbassa / Frankenstein-Labs. Poids dérivés de GPT-2 (© OpenAI, licence MIT modifiée) — la notice d'OpenAI et la licence MIT doivent être conservées dans toute redistribution des poids dérivés.

Downloads last month: -

Safetensors

Model size

0.6B params

Tensor type

F32