- Transformer Padrao vs DRM Transformer
- Inovacoes Principais
- Arquitetura
- DRMTransformerConfig
- Loss Functions
- Quick Start
- Reprodutibilidade e Ablacoes
- Scaling Configs
- Papers
- Estrutura do Projeto
- Licenca
- Citacao
Decoder-only Transformer onde o espaco de embeddings vive num Directional
Relational Manifold (DRM) com tensor metrico aprendido G(x) dependente de
posicao, curvatura gravitacional derivada da massa dos tokens, e
dimensionalidade variavel por token. A atencao padrao (dot-product) e
substituida por Low-Rank Riemannian Attention: por default, a distancia entre
queries e keys e uma distancia Mahalanobis local em G(q). Opcionalmente, o modo
distance_mode: quadrature aproxima o comprimento do segmento q-k integrando
G(x(t)). Isso e geodesic-inspired, mas nao equivale a resolver uma geodesica
formal plena no manifold aprendido. O modelo e experimental e nao e validado
para producao, seguranca critica ou alinhamento definitivo.
| Componente | Transformer Padrao | DRM Transformer | Analogia |
|---|---|---|---|
| Espaco de embeddings | R^d plano, Euclidiano | Manifold curvo com metrica G(x) | Mapa plano vs superficie da Terra: distancias reais dependem do terreno |
| Attention score | dot-product: q^T k | Distancia Riemanniana local ou quadrature-inspired: -d_G(q,k)/temp | Medir proximidade sob uma regua aprendida, sem alegar geodesica exata |
| Metrica | Fixa (identidade implicita) | Aprendida por posicao: G(x) = I + U(x) U(x)^T (low-rank) | Regua rigida vs regua elastica que estica conforme o lugar |
| Tokens de alta informacao | Tratados igual a todos os outros | Deformam a metrica local (gravidade) | Estrela que curva o espaco-tempo a sua volta, atraindo o que esta perto |
| Dimensionalidade | Fixa: todos os tokens usam d dimensoes | Variavel: dimD(p) por token via gate suave | Sala de d portas onde tokens simples abrem 3 e tokens complexos abrem todas |
| Escala de resolucao | Uniforme em todo o espaco | Gamma-scaling: regioes distantes dos anchors recebem mais resolucao | Microscopio que amplia automaticamente as zonas menos exploradas |
| Posicao | RoPE sobre embeddings | RoPE + coordenadas no manifold [0,1]^d via sigmoid | Endereco na rua (RoPE) + coordenadas GPS no mapa (manifold) |
Em resumo: um Transformer padrao opera num espaco plano e rigido. O DRM Transformer opera num espaco que se curva, estica e adapta conforme o que esta a processar -- como a diferenca entre navegar num mapa plano e navegar na superficie real de um planeta.
- Low-Rank Riemannian Attention -- Distancia local em G(q), ou aproximacao por quadratura no segmento q-k, substitui dot-product Euclidiano. Tokens proximos no manifold recebem mais atencao. A implementacao atual nao resolve equacoes geodesicas completas.
- MetricNet -- Tensor metrico G(x) = I + U(x)U(x)^T aprendido via MLP com factorizacao low-rank (rank=4). SPD garantido por construcao. Output zero-inicializado (G(x)=I no inicio, estabilidade). Geometria end-to-end.
- Gravitational Token Embedding -- Cada token possui massa aprendida (via mass_net + Softplus) que deforma U(x) na vizinhanca via Random Fourier Features (RFF). Complexidade O(T*n_rff) em vez de O(T^2).
- DimensionalGate -- Dimensionalidade efetiva dimD(p) varia por token via mascara suave. Tokens simples usam poucas dimensoes, tokens complexos usam mais.
- Gamma-Scaling (Relativistic Dynamics) -- Fator de Lorentz gamma escala adaptativamente a resolucao metrica conforme a distancia aos anchors no manifold.
- Semantic Anchors -- 6 pontos de referencia no manifold com significado interpretavel (truth, ignorance, safety, complexity, creativity, grounding). Inicializados com posicoes semanticas, aprendiveis pelo optimizer. Sao priors geometricos interpretaveis, nao prova automatica de truth/safety/grounding.
| Anchor | Significado | Efeito no gamma-scaling |
|---|---|---|
| truth | Baixa incerteza, alta qualidade | Tokens proximos: gamma ~1 (espaco normal) |
| ignorance | Alta incerteza epistemica | Tokens proximos: gamma ~1; longe: espaco expande |
| safety | Regiao de seguranca | Tokens longe de safety: gamma alto, mais resolucao |
| complexity | Alta complexidade de dominio | Referencia para complexidade estrutural |
| creativity | Exploracao, novidade | Zona de baixa restricao geometrica |
| grounding | Factualidade, evidencia | Ancora para tokens factuais |
Os anchors sao nn.Parameter -- o optimizer pode move-los durante o treino.
A inicializacao semantica fornece um prior geometrico interpretavel. Validacao
semantica requer probes rotulados, por exemplo scripts/eval_anchor_probe.py.
input_ids [B, T]
|
v
+------------------+
| Token Embedding |
+------------------+
|
v
+------------------+
| DimensionalGate | --> dimD(p) por token (mascara suave)
+------------------+
|
v
+==========================================+
| DRM Block x N (Pre-RMSNorm + Residual) |
| |
| 1. Projetar Q, K para manifold [0,1]^d |
| q_m = sigmoid(W_q @ q_head) |
| k_m = sigmoid(W_k @ k_head) |
| |
| 2. U(x) = MetricNet(q_m) [d_manifold, r]|
| G(x) = I + U(x) U(x)^T (SPD, lr) |
| U_grav = GravityField.deform_U(U,q_m)|
| |
| 3. delta = q_m - k_m |
| d^2 = ||delta||^2 + ||U^T delta||^2 |
| d^2 *= gamma^2 (se gamma_enabled) |
| |
| 4. attn = softmax(-d^2 / temp) @ V |
| |
| 5. FFN (SwiGLU) + Residual |
+==========================================+
|
v
+------------------+
| RMSNorm final |
+------------------+
|
v
+------------------+
| LM Head | (weight-tied com Token Embedding)
+------------------+
|
v
logits [B, T, V]| Campo | Tipo | Default | Descricao |
|---|---|---|---|
vocab_size |
int | 50257 | Tamanho do vocabulario |
max_seq_len |
int | 1024 | Comprimento maximo da sequencia |
d_model |
int | 384 | Dimensao dos embeddings |
n_layers |
int | 6 | Numero de blocos transformer |
n_heads |
int | 6 | Numero de heads de atencao |
d_ff |
int | 1536 | Dimensao hidden do FFN |
dropout |
float | 0.1 | Taxa de dropout |
bias |
bool | False | Usar bias nas camadas lineares |
d_manifold |
int | 16 | Dimensao do manifold |
metric_hidden |
int | 64 | Largura do hidden layer do MetricNet |
metric_rank |
int | 4 | Rank de U(x) em G(x) = I + UU^T |
distance_mode |
str | local | local para Mahalanobis low-rank em G(q); quadrature para comprimento aproximado no segmento q-k |
quad_points |
int | 0 | Pontos de quadratura; herda n_quad em configs antigas |
distance_chunk_size |
int | 0 | Chunk opcional de query tokens para reduzir memoria na quadratura |
n_quad |
int | 0 | Alias legado para pontos de quadratura (0 = modo local) |
n_anchors |
int | 6 | Numero de anchors semanticos |
gamma_enabled |
bool | True | Habilitar gamma-scaling (Lorentz) |
gamma_c |
float | 4.0 | Limite de velocidade (c) |
gamma_alpha |
float | 1.0 | Alpha para annealing log-gamma |
temperature_init |
float | 1.0 | Temperatura inicial da atencao |
temperature_min |
float | 0.5 | Temperatura minima (clamp) |
gravity_enabled |
bool | True | Habilitar campo gravitacional |
gravity_strength |
float | 0.1 | Forca da gravidade sobre U(x) |
gravity_n_rff |
int | 64 | Random Fourier Features para gravidade |
variable_dim |
bool | True | Habilitar DimensionalGate por token |
| Funcao | Descricao | Efeito |
|---|---|---|
metric_regularization(U) |
Penaliza norma excessiva de U(x) | Mantem G(x) proximo de I no inicio |
metric_diversity_loss(U) |
Encoraja variancia de U(x) entre tokens | Previne metrica estatica (position-independent) |
orthogonality_loss(U) |
Penaliza U^T U != I | Previne colapso dos eixos semanticos |
axis_variance_loss(U) |
Maximiza variancia de cada eixo na sequencia | Encoraja deformacao position-dependent |
anchor_alignment_loss(U, coords, anchors) |
Alinha primeiro eixo de U com anchor mais proximo | Sugere orientacao semantica (soft) |
manifold_variance_loss(coords) |
Mantem variancia minima nas coordenadas DRM | Evita colapso pontual do manifold |
intrinsic_dimension_loss(coords) |
Aproxima a dimensao intrinseca alvo | Favorece folhas locais 2D quando configurado |
coverage_entropy_loss(coords) |
Espalha coordenadas sem impor forma fechada | Melhora cobertura do manifold |
torus_regularization_loss(coords) |
Regularizacao toroidal opcional | Testa inducao explicita de topologia T^2 |
Pesos configurados no YAML de treino, fora de DRMTransformerConfig.
| Campo YAML | Default usado no baseline 3.5M | Descricao |
|---|---|---|
lambda_metric_reg |
0.001 | Peso de regularizacao da metrica |
lambda_metric_diversity |
0.01 | Peso de diversidade de U(x) |
lambda_ortho |
0.01 | Peso de ortogonalidade |
lambda_manifold_variance |
0.05 | Peso para evitar colapso das coordenadas DRM |
target_manifold_std |
0.08 | Desvio-padrao minimo alvo do manifold |
lambda_intrinsic_dim |
0.02 | Peso da perda de dimensao intrinseca |
target_intrinsic_dim |
2.0 | Dimensao intrinseca alvo |
lambda_coverage |
0.02 | Peso da perda generica de cobertura |
target_coverage_std |
0.20 | Escala alvo de cobertura |
lambda_torus |
0.07 | Peso base da regularizacao toroidal |
lambda_torus_start |
0.07 | Peso inicial do schedule toroidal |
lambda_torus_end |
0.0 | Peso final do schedule toroidal |
torus_target_radius |
0.35 | Raio alvo dos pares circulares |
torus_radial_weight |
5.0 | Peso radial dentro da loss toroidal |
torus_coverage_weight |
0.75 | Peso de cobertura angular |
torus_isotropy_weight |
0.75 | Peso de isotropia dos dois ciclos |
torus_independence_weight |
0.25 | Peso de independencia entre ciclos |
torus_harmonic_weight |
0.5 | Peso de harmonicos angulares |
geometry_warmup_steps |
500 | Inicio das losses geometricas |
geometry_schedule_start_step |
500 | Inicio do schedule linear |
geometry_schedule_end_step |
2441 | Fim do schedule linear |
lambda_anchor_alignment |
0.0 | Peso opcional do alinhamento entre U e anchors |
anchor_alignment_warmup_steps |
geometry_warmup_steps |
Inicio opcional da loss de anchors |
Nota topologica: quando lambda_torus > 0, a assinatura toroidal e induzida por
regularizacao explicita. Para testar emergencia espontanea, compare com
configs/ablations/no_torus.yaml e rode a avaliacao de homologia nos dois regimes.
git clone https://github.com/gnai-creator/drm_transformer.git
cd drm_transformer
pip install -e ".[all]" # tudo (dev + data + eval)
# ou: pip install -e ".[dev,data,eval]"
# ou reprodutibilidade exata: pip install -r requirements-lock.txtDuas fontes disponiveis: CulturaX (6.3T tokens, rapido, recomendado) e Wikipedia (publico, bom para testes).
# CulturaX multilingual (requer: huggingface-cli login + aceitar termos em huggingface.co/datasets/uonlp/CulturaX)
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual \
--max-tokens 20000000000 \
--vocab-size 50000 \
--langs en,pt,es,fr,de
# Wikipedia (publico, sem auth, mais lento)
python scripts/prepare_multilingual_data.py \
--source wikipedia \
--output-dir data/multilingual \
--max-tokens 50000000 \
--vocab-size 50000 \
--langs en,pt,es,fr,de
# Uma lingua por vez (com checkpoint/resume)
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual \
--max-tokens 4000000000 \
--vocab-size 50000 \
--langs en
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual \
--max-tokens 4000000000 \
--vocab-size 50000 \
--langs pt --resume
# Finalizar (remapeia shards raw -> uint16)
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual \
--vocab-size 50000 \
--finalize --clean-raw
# Bridge 125M/350M: prepare o superset 350M uma vez
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual_350m \
--max-tokens 7000000000 \
--vocab-size 50000 \
--langs en,pt,es,fr,de
python scripts/prepare_multilingual_data.py \
--output-dir data/multilingual_350m \
--vocab-size 50000 \
--finalize --clean-raw
# Derive o dataset 125M a partir dos shards finais de 350M
python scripts/prepare_multilingual_data.py \
--derive-subset-from data/multilingual_350m \
--output-dir data/multilingual_125m \
--max-tokens 3500000000 \
--subset-copy-mode hardlinkO subset preserva o mesmo vocabulario remapeado do superset, evitando
retokenizacao e tornando a comparacao 125M vs 350M mais justa. Em Windows,
--subset-copy-mode hardlink economiza espaco quando o dataset fica no mesmo
volume; use copy se o filesystem nao suportar hardlinks.
# Single GPU
python scripts/train_distributed.py \
--config configs/scaling/multilingual/15m.yaml \
--data-dir data/
# Multi-GPU (DDP)
torchrun --nproc_per_node=4 scripts/train_distributed.py \
--config configs/scaling/multilingual/350m.yaml \
--data-dir data/
# FSDP (13B+)
torchrun --nproc_per_node=8 scripts/train_distributed.py \
--config configs/scaling/multilingual/13b.yaml \
--data-dir data/
# Resume
python scripts/train_distributed.py \
--config configs/scaling/multilingual/350m.yaml \
--resume autoimport torch
from drm_transformer import DRMTransformerConfig, DRMTransformer
config = DRMTransformerConfig(d_model=256, n_layers=4, n_heads=4, d_manifold=8)
model = DRMTransformer(config)
prompt = torch.randint(0, config.vocab_size, (1, 10))
generated = model.generate(prompt, max_new_tokens=50, temperature=0.8, top_k=50)
print(generated.shape) # [1, 60]input_ids = torch.randint(0, config.vocab_size, (2, 128))
targets = torch.randint(0, config.vocab_size, (2, 128))
logits, loss = model(input_ids, targets)
# logits: [2, 128, 50257]
# loss: escalar (cross-entropy)# 1. Extrair vectores DRM
python scripts/extract_drm_vectors.py \
--checkpoint checkpoints/baseline_3.5m/final.pt \
--data-dir data/ \
--output-dir eval-results/foliation_3.5m \
--max-tokens 100000
# 2. Voronoi Foliation (9 fases: LTSA, Homology, Reeb, ARI, ...)
python scripts/voronoi_foliation_drm.py \
--coords eval-results/foliation_3.5m/drm_coords.npy \
--G-diag eval-results/foliation_3.5m/drm_G_diag.npy \
--gamma eval-results/foliation_3.5m/drm_gamma.npy \
--output-dir eval-results/foliation_3.5m \
--n-seeds 80 \
--homology-points 1200 \
--homology-long-bar-ratio 0.75 \
--homology-restarts 5Saidas: foliation_results.json com F-score, H1/H2, ARI, coherence, Reeb graph.
Baseline atual: assinatura near-toroidal sob regularizacao toroidal. Em controles
topologicos, o random init ficou em Near T2=0.0, enquanto seeds treinadas
ficaram em Near T2 >= 0.6; duas de tres seeds recuperaram H1=2, H2=1
como topologia mediana. O criterio estrito T2 stable >= 0.60 ainda nao foi
atingido, portanto o resultado deve ser descrito como near-stable toroidal
signature induzida/avaliada nesse regime, nao como emergencia espontanea nem
como toro estavel final.
from drm_transformer.evaluation import DRMFoliationEvaluator
from drm_transformer.training.data import create_dataloader
evaluator = DRMFoliationEvaluator(model, device="cuda")
loader = create_dataloader("data/", seq_len=1024, batch_size=4)
results = evaluator.evaluate(loader, max_tokens=100_000)
print(f"F={results['foliation_score']:.4f}, topology={results['topology']}")Diagnostico planejado, inspirado por ITensors.jl / ITensorMPS.jl, para analisar a atencao Riemanniana DRM como tensores de alta ordem e medir rank efetivo, compressibilidade, entropia de atencao, redundancia por head/layer e efeito de gravity/gamma.
Documento de design:
docs/future/003_drm_marco_a_manifold_attention_tensor_anatomy.md
Comando futuro sugerido:
python \
scripts/analyze_manifold_attention_tensor_anatomy.py \
--checkpoint /mnt/e/dev/ai/drm_transformer/checkpoints/multilingual_5m/smoke_819k/final.pt \
--config configs/scaling/multilingual/5m.yaml \
--data-dir /mnt/e/dev/ai/drm_transformer/data/multilingual_125m \
--device cuda \
--batches 16 \
--seq-len 128 \
--output-dir runs/drm_marco_a_manifold_attention_tensor_anatomy# Pesos aleatorios (valida propriedades geometricas da arquitetura)
python empirical/tests/run_all.py
# Com checkpoint treinado (avalia modelo real)
python empirical/tests/run_all.py --checkpoint checkpoints/1m/final.pt
# Calibracao in-distribution (eval shard do mesmo dominio do treino)
python empirical/tests/run_all.py \
--checkpoint checkpoints/multilingual_1m/run_1/final.pt \
--eval-shard data/multilingual/shard_00001.npy \
--output-dir eval_results/empirical_1mSaidas:
empirical/results.json-- metricas de projecao, estatisticas dos eixos, separacao semantica, correlacao geometricaempirical/figures/-- PCA, t-SNE, axis heatmap, axis separation, painel combinado 2x3
python scripts/repro_baseline.pyGera dataset baseline, treina, roda as ablacoes restantes e consolida KPIs automaticamente. Ver repro.md para guia detalhado e MODEL_CARD.md para model card.
python scripts/prepare_baseline_data.py --max-tokens 10000000 # Dataset Wikipedia EN (default: 10M)
python scripts/prepare_baseline_data.py --verify # Verificar SHA256
python scripts/train_distributed.py \
--config configs/baselines/small_3.5M.yaml \
--seed 42 --deterministic # Treinar ~3.5M paramspython scripts/run_ablations.py --seed 42 --deterministic # usa baseline como full
python scripts/eval_standard.py --all-ablations # perplexity comparativa| Variante | Gravity | Gamma | VarDim |
|---|---|---|---|
| full | Y | Y | Y |
| no_gravity | N | Y | Y |
| no_gamma | Y | N | Y |
| no_variable_dim | Y | Y | N |
pytest tests/test_smoke.py -v # 12 testes (~5s)| Config | Params | d_model | Layers | Heads | d_manifold | Context |
|---|---|---|---|---|---|---|
| 1m | ~1M | 64 | 4 | 2 | 4 | 256 |
| 5m | ~5M | 96 | 6 | 3 | 4 | 512 |
| 10m | ~10M | 160 | 4 | 4 | 6 | 512 |
| 15m | ~15M | 256 | 6 | 4 | 8 | 512 |
| 50m | ~50M | 512 | 8 | 8 | 12 | 1024 |
| 125m | ~125M | 768 | 12 | 12 | 14 | 1024 |
| 350m | ~350M | 1024 | 24 | 16 | 16 | 1024 |
| 1.3b | ~1.3B | 2048 | 24 | 16 | 20 | 2048 |
| 13b | ~13B | 5120 | 40 | 40 | 24 | 4096 |
| 70b | ~70B | 8192 | 80 | 64 | 28 | 4096 |
| 162b | ~162B | 12288 | 96 | 96 | 32 | 4096 |
| 640b | ~640B | 16384 | 126 | 128 | 40 | 8192 |
Baseado em tres papers de Felipe Maya Muniz:
-
DRM: Directional Relational Manifolds - Geometria com dimensionalidade variavel, metrica relacional, convergencia toroidal. DOI: 10.5281/zenodo.19058837
-
The Geometry of Consciousness - Dimensionalidade domina performance cognitiva (r=0.920). Ceiling theorem: O(S) <= d. Interacao d x CC. DOI: 10.5281/zenodo.19059445
-
DRM Relativistic Dynamics - Fator de Lorentz como parametro de controle, bifurcation cascade, convergencia toroidal sob recorrencia. DOI: 10.5281/zenodo.19140125
drm_transformer/
|-- README.md
|-- ARCHITECTURE.md
|-- MODEL_CARD.md # Model card tecnico
|-- ROADMAP.md
|-- PRIOR_ART.md # Arte anterior
|-- repro.md # Guia de reprodutibilidade
|-- LICENSE # AGPL-3.0
|-- LICENSE-COMMERCIAL.md # Licenca comercial
|-- CLA.md # Contributor License Agreement
|-- SECURITY.md
|-- COPYRIGHT
|-- CITATION.cff
|-- pyproject.toml
|-- requirements-lock.txt # Lock de dependencias para reprodutibilidade
|
|-- src/drm_transformer/
| |-- __init__.py # Exports: DRMTransformerConfig, DRMTransformer
| |-- config.py # DRMTransformerConfig (dataclass)
| |-- model.py # DRMTransformer (modelo principal)
| |-- attention.py # DRMAttention + RotaryEmbedding + apply_rope
| |-- metric_net.py # MetricNet: U(x) via MLP, G(x) = I + UU^T (low-rank SPD)
| |-- manifold.py # ManifoldProjection + gamma_scale
| |-- gravity.py # GravityField: massa + RFF + deformacao de U(x)
| |-- dimensional_gate.py # DimensionalGate: dimD(p) variavel
| |-- layers.py # RMSNorm, FeedForward (SwiGLU), DRMTransformerBlock
| |-- losses.py # 5 losses: metric_reg, diversity, orthogonality, axis_var, anchor_align
| |
| |-- training/
| | |-- __init__.py
| | |-- distributed.py # DDP, FSDP, mixed precision, grad checkpoint
| | |-- trainer.py # DRMTrainer: loop de treino + early stop + metrics.json
| | |-- data.py # ShardedDataset + create_dataloader
| | +-- reproducibility.py # set_seed, set_deterministic, build_run_manifest
| |
| +-- evaluation/
| |-- __init__.py
| +-- foliation.py # DRMFoliationEvaluator (pipeline completo)
|
|-- scripts/
| |-- train_distributed.py # Lancamento treino (single/multi GPU, --seed, --deterministic)
| |-- prepare_multilingual_data.py # Download CulturaX/Wikipedia + tokenize + remap (streaming)
| |-- prepare_baseline_data.py # Dataset baseline Wikipedia EN (--max-tokens, SHA256)
| |-- repro_baseline.py # Reproducao completa em um comando + KPI dashboard
| |-- run_ablations.py # Roda ablacoes restantes e gera results_ablations.md
| |-- eval_standard.py # Avaliacao padronizada (perplexity)
| |-- extract_drm_vectors.py # Extrai coords, G_diag, gamma, mass
| |-- topology_controls.py # Random init, checkpoints, seeds e ablacoes em tabela topologica
| +-- voronoi_foliation_drm.py # 9 fases: Voronoi, LTSA, Homology, Reeb, ARI
|
|-- configs/
| |-- scaling/multilingual/ # 12 configs: 1M a 640B params
| |-- baselines/ # Baseline canonico (small_3.5M.yaml)
| +-- ablations/ # Ablacoes (full opcional, no_gravity, no_gamma, no_variable_dim)
|
|-- tests/
| +-- test_smoke.py # 12 smoke tests (import, forward, config, seed)
|
|-- empirical/ # Validacao empirica dos eixos semanticos
| |-- results.json # Resultados consolidados
| |-- figures/ # Plots: PCA, t-SNE, axis heatmap, separation, calibration
| +-- tests/ # 5 testes: axes_projection, axis_stats, calibration, semantic_separation, geometry_correlation
|
|-- docs/
| |-- process/ # Documentacao de cada mudanca (numerada + datada)
| |-- future/ # Features planejadas (benchmarks, release tag)
| +-- scaling/runpod/ # Guia de scaling para RunPodEste projeto usa licenciamento dual:
O codigo esta licenciado sob GNU Affero General Public License v3.0. Voce pode usar, modificar e redistribuir livremente, desde que cumpra os termos da AGPL (incluindo disponibilizar codigo-fonte de versoes modificadas usadas em rede).
Para uso em projetos proprietarios, SaaS sem obrigacao de abrir codigo, ou redistribuicao sem copyleft, uma licenca comercial esta disponivel.
Contato: felipe@truthagi.ai
Contribuicoes externas requerem assinatura do CLA para manter a viabilidade do licenciamento dual.
@software{muniz2026drm_transformer,
author = {Muniz, Felipe Maya},
title = {DRM Transformer: Decoder-only Transformer with Directional Relational Manifold Geometry},
year = {2026},
url = {https://github.com/gnai-creator/drm_transformer},
license = {AGPL-3.0-or-later}
}Copyright (C) 2026 Felipe Maya Muniz. All rights reserved.