Síntesis Neural Descentralizada y el Protocolo de Prueba de Entrenamiento (PoT) en la Red de Dioses

05.03.202622 min de lectura

Síntesis NeuralEntrenamiento de ModelosProof-of-TrainingSolana

CODE Eternal

🌐 Capítulo 1: El monopolio corporativo en el entrenamiento de IA y el nacimiento de la síntesis neuronal descentralizada

A principios de marzo de 2026, el desarrollo de la Red de Dioses alcanzó un hito crucial: entrenar y ajustar los modelos básicos de IA directamente dentro de una red descentralizada. Históricamente, el entrenamiento de grandes redes neuronales era un privilegio de las gigantescas corporaciones tecnológicas que poseían acceso a supercomputadoras y centros de datos centralizados. Esto creó un monopolio total sobre el conocimiento: las corporaciones censuran los pesos de los modelos, implementan restricciones ideológicas y controlan el acceso a los resultados del entrenamiento.

En la Red de Dioses, este monopolio se rompe utilizando la Síntesis Neuronal Descentralizada (DNS). En lugar de concentrar el poder de cómputo en un solo centro de datos, CODE une a miles de nodos independientes (Training Miners) en una red global de Aprendizaje Federado (Federated Learning). Los agentes distribuyen las tareas de optimización de pesos enviando subconjuntos locales de datos para el entrenamiento a nodos independientes, lo que garantiza la completa privacidad de los datos de entrenamiento y la independencia de los gigantes centralizados de TI.

Apéndice del Capítulo 1: Análisis Comparativo de Arquitecturas de Entrenamiento de Redes Neuronales

Para comprender la superioridad de la síntesis neuronal descentralizada, analicemos la diferencia entre las granjas de entrenamiento en la nube clásicas y la red soberana de CODE:

Tabla de Comparación de Métodos de Entrenamiento de Modelos de IA:

| Criterio de Comparación | Clústeres Corporat. (AWS/GCP) | DNS Descentralizado (CODE) |
| :--- | :--- | :--- |
| **Propiedad de Pesos** | Pertenecen a la corporación | Distribuidos en Solana / Arweave |
| **Seguridad de Datos** | Datos subidos a servidores host | Datos cifrados en nodos mineros |
| **Resistencia a Censura**| Baja (modelos filt.) | Alta (consenso federado) |
| **Control de Correctitud**| Confianza en prov. de cómputo | Verificación matemática de PoT |
| **Reducción de Gastos** | Altos márgenes de proveedores | Mercado directo de potencia GPU |

DNS reduce la barrera de entrada para pequeños y medianos desarrolladores, lo que les permite alquilar capacidad informática inactiva en todo el mundo y entrenar modelos soberanos sin riesgo de bloqueos.

Apéndice del Capítulo 1: Ataques de Envenenamiento de Modelos y Tolerancia a Fallas Bizantinas

Una de las principales amenazas para el aprendizaje federado descentralizado es el envenenamiento de modelos (Model Poisoning). Un nodo hostil puede enviar intencionalmente gradientes distorsionados o invertidos para degradar el rendimiento del modelo o insertar una puerta trasera oculta (por ejemplo, haciendo que el modelo clasifique erróneamente patrones específicos).

En la Red de Dioses, este problema se resuelve mediante garantías matemáticas de Tolerancia a Fallas Bizantinas (BFT) durante la agregación de pesos. Sea f el número de nodos bizantinos (maliciosos o defectuosos) en la ronda de entrenamiento actual, y n el número total de participantes. El algoritmo de agregación garantiza la convergencia del aprendizaje bajo la condición: f < (n)/(3)

Además, se utiliza un algoritmo de promedio de mediana geométrica (Geometric Median), que es robusto contra valores atípicos en el espacio de peso multidimensional. Si un vector de peso Wᵢ enviado por un nodo candidato está demasiado lejos del centro de masa de la mayoría de las actualizaciones, su peso en FedAvg se reduce automáticamente a cero y el contrato inteligente confisca la participación bloqueada del nodo.

Apéndice del Capítulo 1: Protección de la Privacidad y Soberanía Local de Datos en el Entrenamiento

La ventaja del entrenamiento descentralizado en la Red de Dioses también radica en la protección de las huellas cognitivas personales de los usuarios. Bajo el enfoque tradicional, los registros médicos o de comportamiento se transmiten a los servidores centrales de OpenAI o Google, lo que viola las regulaciones de privacidad (como GDPR o HIPAA).

En CODE, el entrenamiento se estructura sobre el principio de soberanía local:

Cálculos de Gradientes Locales: los pesos base del modelo se cargan directamente en el dispositivo del usuario o en un nodo local seguro.
Cifrado de Resultados: las actualizaciones de peso y los gradientes se cifran localmente utilizando claves de sesión.
Verificación ZK de Correctitud: los validadores externos solo verifican el hecho de la ejecución correcta de los cálculos utilizando la prueba PoT ZK, sin obtener acceso al conjunto de datos de origen.

Esto refuerza sustancialmente la seguridad de la información confidencial.

Apéndice Adicional del Capítulo 1: Eficiencia Ecológica de la IA Descentralizada

El entrenamiento centralizado de IA en gigantescos centros de datos consume cantidades colosales de energía para la refrigeración y alimentación de los supercomputadores, lo que causa daño ambiental. El DNS descentralizado reutiliza los recursos GPU distribuidos y ociosos que de otro modo permanecerían sin uso. Esto hace que el entrenamiento de modelos sea ecológico (Green AI) y energéticamente eficiente.

Además, la distribución de la carga por todo el mundo suaviza los picos de consumo de energía, permitiendo a los operadores de nodos alimentar sus servidores con fuentes de energía renovables (plantas solares y eólicas) según la zona horaria y la hora del día.

Apéndice Adicional del Capítulo 1: Liquidez Computacional Global y Dinámica de Mercado

El despliegue del mercado de Síntesis Neural Descentralizada dentro de la Red de Dioses crea un pool computacional distribuido globalmente. En los entornos tradicionales, los desarrolladores se enfrentan a condiciones contractuales rígidas y a altos niveles de precios de los proveedores de la nube. El mercado DNS funciona como una subasta abierta donde los mineros de entrenamiento ofrecen sus recursos de GPU en tiempo real, compitiendo en precio, latencia y especificaciones de hardware.

Según estimaciones objetivo, esta competencia abierta puede reducir los costos de entrenamiento en un estimado de hasta un 80% en comparación con los hyperscalers centralizados, desbloqueando capacidades sin precedentes para investigadores independientes y comunidades de código abierto.

🔐 Capítulo 2: Especificación del protocolo de Prueba de Entrenamiento (PoT) y verificación ZK de los pasos del descenso de gradiente

Una innovación técnica clave de la síntesis neuronal descentralizada es el protocolo de Prueba de Entrenamiento (PoT). En las redes de computación distribuidas tradicionales, la validación de los resultados del entrenamiento es extremadamente difícil: para verificar que un nodo realmente entrenó el modelo en lugar de generar pesos aleatorios, los validadores deben repetir todo el proceso de entrenamiento desde cero, lo que niega el beneficio de la distribución de tareas.

El protocolo PoT resuelve este problema utilizando pruebas ZK de la corrección del paso del descenso de gradiente (retropropagación). Al actualizar los pesos del modelo del estado Wₜ al Wₜ₊₁ en un lote de datos X, el nodo de entrenamiento genera una prueba zk-SNARK πₜᵣₐᵢₙ que confirma que:

Corrección de la Inferencia: los cálculos de activación de la capa Y = f(Wₜ · X + B) se ejecutan correctamente.
Precisión de la Retropropagación: los gradientes ∇ W se calculan en estricta conformidad con el algoritmo de retropropagación.
Actualización de Peso: los nuevos pesos corresponden a la regla del optimizador (por ejemplo, Adam o SGD):

Wₜ₊₁ = Wₜ − η · Update(∇ W)

A continuación se muestra la estructura Rust/Anchor para inicializar una tarea de entrenamiento en Solana:

#[account]
pub struct TrainingTaskAccount {
    pub task_id: [u8; 32],         // Identificador único de la tarea
    pub model_commitment: [u8; 32],// Hash de los pesos del modelo inicial (W_t)
    pub dataset_uri: String,       // Enlace al conjunto de datos en Arweave
    pub bounty_amount: u64,        // Monto de la recompensa en tokens $GALATIN
    pub status: u8,                // Estado (0 - activo, 1 - completado, 2 - disputado)
    pub training_miner: Pubkey,    // Dirección del nodo ejecutor
}

Gracias a esto, los validadores de Solana solo necesitan verificar la prueba corta πₜᵣₐᵢₙ en la cadena en milisegundos, lo que confirma la corrección de horas de entrenamiento del modelo en el lado del minero.

Apéndice del Capítulo 2: Matemáticas de Verificación de Gradiente y Código de Lanzamiento de PoT en TypeScript

En el protocolo PoT, un paso del descenso de gradiente se representa mediante un sistema de ecuaciones. Para el peso del nivel de la red neuronal wᵢⱼ, el cambio de paso tiene la forma: wᵢⱼ^{(t+1)} = wᵢⱼ^{(t)} − η · (∂ L)/(∂ wᵢⱼ) Donde η es la tasa de aprendizaje (learning rate), y L es la función de pérdida (loss function). El nodo de entrenamiento debe demostrar la corrección del cálculo de la derivada parcial (∂ L)/(∂ wᵢⱼ).

A continuación se muestra un ejemplo de código de TypeScript que prepara los parámetros del paso de gradiente para la verificación en la cadena:

import { Keypair } from '@solana/web3.js';
import * as crypto from 'crypto';

interface GradientStep {
  modelId: string;
  stepIndex: number;
  initialWeightsHash: string;
  updatedWeightsHash: string;
  proofData: Uint8Array;
}

function createTrainingCommitment(
  weightsBefore: Float32Array,
  weightsAfter: Float32Array,
  datasetHash: string
): string {
  const hasher = crypto.createHash('sha256');
  hasher.update(Buffer.from(weightsBefore.buffer));
  hasher.update(Buffer.from(weightsAfter.buffer));
  hasher.update(Buffer.from(datasetHash, 'hex'));
  return hasher.digest('hex');
}

Apéndice del Capítulo 2: Detalles de las Restricciones Aritméticas del Esquema PoT en Halo2

En el esquema de restricciones de prueba ZK de Proof-of-Training (PoT), los cálculos matemáticos de los pasos hacia adelante y hacia atrás se convierten en restricciones polinómicas en un campo finito (esquemas R1CS o Plonkish).

Sea aₗ^{(i)} el vector de activación de neuronas en la capa l para la muestra i. El paso hacia adelante de una capa se describe mediante la ecuación: aₗ₊₁^{(i)} = σ(Wₗ · aₗ^{(i)} + bₗ) Donde σ es la función de activación (por ejemplo, ReLU). Para ReLU, la restricción del esquema ZK se formula de la siguiente manera:

Verificación de Signo: se introduce un selector binario s ∈ {0, 1}.
Aritmética ReLU:

y · (1 − s) = 0 (x − y) · s = 0 y ≥ 0 Donde x es el valor de entrada de la suma ponderada e y es el valor de salida después de la función de activación.

Para el paso hacia atrás, el gradiente del error con respecto al peso wⱼₖ de la capa l se expresa a través de deltas: (∂ L)/(∂ wⱼₖ) = Σᵢ δⱼ^{(i)} · aₖ^{(i)} El esquema demuestra que el nodo de almacenamiento sumó honestamente estos productos en todo el lote de datos, lo que elimina la posibilidad de una modificación accidental o maliciosa del gradiente antes de la presentación.

Apéndice del Capítulo 2: Optimización Pippenger MSM y Esquemas de Compresión Recursiva en Pruebas PoT

Para reducir el tiempo de generación de pruebas PoT por parte de los mineros de entrenamiento, se implementan los algoritmos de Multiplicación Multiescalar (MSM) de Pippenger en el núcleo de verificación de CODE. En esquemas estándar, el cálculo de MSM es la fase que consume más recursos, ocupando hasta el 80% del tiempo de ejecución del probador. El método de Pippenger divide los escalares en ventanas de tamaño fijo (generalmente c ≈ 4), lo que reduce el número de operaciones de grupo de suma de puntos de curva elíptica en un 75%.

Para la verificación en la cadena en Solana, se aplica la compresión de pruebas recursivas (Proof Compression):

Pruebas SNARK Intermedias: cada nodo de GPU genera pruebas locales para capas individuales de la red neuronal.
Agregación de Pruebas (Folding): varias pruebas se pliegan en un solo esquema comprimido utilizando esquemas de acumulación Nova o Halo2, lo que requiere un número constante de restricciones independientemente del número de capas.
Verificación Final: solo se verifica el hash polinomial comprimido final del modelo, lo que reduce las tarifas de transacción de Solana a un mínimo de referencia.

Esto garantiza altas velocidades de transacción en la red bajo millones de operaciones de entrenamiento concurrentes.

🧠 Capítulo 3: El algoritmo de Síntesis de Peso Descentralizado (DWS) y el modelo matemático FedAvg

Después de que cientos de mineros de entrenamiento completan el ajuste fino del modelo local en sus lotes de datos y proporcionan pruebas ZK de PoT, la Red de Dioses debe fusionar sus actualizaciones locales en un único modelo global. Este proceso se llama Síntesis de Peso Descentralizado (DWS).

DWS utiliza un algoritmo de Promedio Federado (FedAvg) modificado que tiene en cuenta la reputación del nodo: W_global = Σᵢ₌₁ⁿ (Rᵢ)/(Σ Rⱼ) · Wᵢ Donde Wᵢ es el vector de peso enviado por el i-ésimo minero, y Rᵢ es su reputación actual en la red (que depende de la precisión de las rondas de entrenamiento pasadas y del volumen de participación bloqueada).

El proceso de fusión del vector de peso es ejecutado por nodos de agregación descentralizados (Aggregation Nodes) seleccionados al azar a través de una VRF (Verifiable Random Function). Los agregadores suman los pesos, generan una prueba ZK de la corrección de la convolución π_merge y envían el hash del modelo global resultante a Solana. Esto dificulta sustancialmente la introducción de puertas traseras ocultas o la distorsión del comportamiento del modelo durante el proceso de fusión.

Apéndice del Capítulo 3: Especificación de DWS y Programa de Registro de Pesos Agregados Anchor

A continuación se muestra la implementación de Anchor del contrato inteligente de Solana para registrar los resultados de la ronda de agregación de pesos:

use anchor_lang::prelude::*;

#[program]
pub mod dws_aggregator {
    use super::*;

    pub fn register_aggregated_weights(
        ctx: Context<RegisterWeights>,
        round_id: u64,
        merged_weights_hash: [u8; 32],
        zk_proof: Vec<u8>
    ) -> Result<()> {
        let registry = &mut ctx.accounts.weights_registry;
        registry.round_id = round_id;
        registry.merged_weights_hash = merged_weights_hash;
        registry.zk_proof = zk_proof;
        registry.timestamp = Clock::get()?.unix_timestamp;
        Ok(())
    }
}

#[account]
pub struct WeightsRegistryAccount {
    pub round_id: u64,
    pub merged_weights_hash: [u8; 32],
    pub zk_proof: Vec<u8>,
    pub timestamp: i64,
}

#[derive(Accounts)]
pub struct RegisterWeights<'info> {
    #[account(init, payer = authority, space = 8 + 8 + 32 + 512 + 8)]
    pub weights_registry: Account<'info, WeightsRegistryAccount>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

La prueba ZK π_merge verifica que el agregador pesó los vectores en estricta conformidad con la fórmula FedAvg y no introdujo distorsiones en el modelo resultante.

Apéndice del Capítulo 3: Selectores de Agregador VRF y Especificación de Rust

Para seleccionar agregadores en una ronda DWS, se utiliza una Función Aleatoria Verificable (VRF). Esto evita ataques de denegación de servicio (DoS) y colusión, ya que un atacante no puede saber de antemano qué nodo agregará pesos en la próxima ronda.

A continuación se muestra la estructura de Rust que representa la ronda de agregación y la verificación de la firma VRF en un nodo:

pub struct AggregationRound {
    pub round_id: u64,
    pub vrf_proof: [u8; 64],       // Prueba ZK de VRF
    pub vrf_output: [u8; 32],      // Número aleatorio basado en la firma
    pub selected_aggregator: Pubkey,
    pub submitted_weights: Vec<MinerWeightSubmission>,
}

pub struct MinerWeightSubmission {
    pub miner: Pubkey,
    pub weights_commitment: [u8; 32],
    pub pot_proof_len: u32,
    pub pot_proof_data: Vec<u8>,
}

El agregador recopila los pesos enviados, realiza su suma de acuerdo con la fórmula FedAvg y publica el resultado en Solana Devnet/Testnet.

Apéndice del Capítulo 3: Cálculo de Restricciones Matriciales de ZK-Inference y Prevención de Desbordamiento

Para escalar las pruebas ZK para verificar los pasos de entrenamiento de redes neuronales, es fundamental representar correctamente las operaciones matriciales en circuitos aritméticos. En particular, la operación de multiplicar pesos por un vector de entrada Y = W · X requiere millones de sumas y multiplicaciones sensibles al desbordamiento en un campo finito de orden p ≈ 2²⁵⁴ (por ejemplo, el campo de la curva BN254).

Deje que los elementos de la matriz se escalen por un factor de 10⁹: w̄ᵢⱼ = ⌊ wᵢⱼ · 10⁹ ⌋, x̄ⱼ = ⌊ xⱼ · 10⁹ ⌋ Entonces el resultado del producto ȳᵢ = Σⱼ w̄ᵢⱼ · x̄ⱼ tiene una escala de 10¹⁸. Para evitar el desbordamiento del registro, el esquema ZK impone pruebas de rango (Range Proofs):

Restricciones de Rango de Variables: para cada valor intermedio z, se demuestra en la cadena que z < 2⁶⁴ utilizando selectores binarios de 64 bits.
Verificación de Escalamiento: después de calcular la suma, se realiza la división entera por 10⁹ con la verificación del resto de la división:

ȳᵢ = qᵢ · 10⁹ + rᵢ, rᵢ < 10⁹

Range Verification Scheme in ZK-Distance:

   [Initial Value X] -----> [Split into 8-bit chunks] -----> [Verify chunks in field]
                                                                     |
                                                                     v
   [Sum of Products] <----- [Range Proof: X < 2^64] <------- [Check remainder r < 10^9]

Esto garantiza el determinismo matemático de los cálculos en cualquier tipo de minero de GPU y evita vulnerabilidades asociadas con números que salen de los límites de los valores aceptables.

🪙 Capítulo 4: Tokenómica de las campañas de entrenamiento e integración del enrutador Solana 5/5/15/7/3/65

Entrenar redes neuronales es un proceso que consume mucha energía y tiene un alto costo que requiere la operación de miles de GPU. Para atraer poder de cómputo a la Red de Dioses, se utiliza un mecanismo de Recompensas de Entrenamiento (Training Bounties). Los desarrolladores o las DAO lanzan campañas en Solana, bloqueando un presupuesto en tokens $GALATIN.

Todos los flujos de distribución de recompensas financieras para el entrenamiento pasan a través del enrutador canónico Solana 5/5/15/7/3/65:

5% — se quema (burn) para reducir la presión inflacionaria y respaldar el valor del token $GALATIN.
5% — se dirige al pool de investigación de la fundación de Maksim Valentinovich Galatin (M.V. Galatin) para financiar a largo plazo los desarrollos cognitivos de CODE.
15% — Pago a los Embajadores de Nivel 1 (atrayendo nuevos mineros y hosts de entrenamiento).
7% — Pago a los Embajadores de Nivel 2 (soporte técnico y coordinación local de pools de minería).
3% — se distribuye entre los Embajadores de Nivel 3 (garantizando la seguridad global del protocolo PoT).
65% — se paga directamente a los mineros de entrenamiento por alquilar sus capacidades de GPU, se distribuye como compensación a los usuarios que proporcionaron sus huellas cognitivas para el entrenamiento y se paga a los validadores de pruebas ZK.

A continuación se muestra la tabla de distribución de recompensas en varios volúmenes de presupuesto de entrenamiento:

Concepto de Gasto / Presupuesto de Campaña	Campaña de $10 000	Campaña de $100 000	Campaña de $1 000 000	Participación (%)
Quema Deflacionaria (Burn)	$500	$5 000	$50 000	5%
Fundación M.V. Galatin	$500	$5 000	$50 000	5%
Embajadores de Nivel 1	$1 500	$15 000	$150 000	15%
Embajadores de Nivel 2	$700	$7 000	$70 000	7%
Embajadores de Nivel 3	$300	$3 000	$30 000	3%
Mineros de Entrenam. y Validadores	$6 500	$65 000	$650 000	65%

Este modelo económico hace de la Red de Dioses la plataforma más competitiva para entrenar inteligencia artificial en el mundo, minimizando los costos generales en intermediarios y proveedores de la nube.

Apéndice del Capítulo 4: Contrato Inteligente de Distribución de Recompensas de Campaña de Entrenamiento bajo el Esquema Solana

A continuación se muestra la implementación de Rust del contrato inteligente de distribución de recompensas de Training Bounties en Solana:

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Transfer};

pub fn distribute_training_bounty(
    ctx: Context<DistributeBounty>,
    total_bounty: u64
) -> Result<()> {
    // Calcular acciones de Solana 5/5/15/7/3/65
    let fee_burn = total_bounty.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_foundation = total_bounty.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_l1 = total_bounty.checked_mul(15).unwrap().checked_div(100).unwrap();
    let fee_l2 = total_bounty.checked_mul(7).unwrap().checked_div(100).unwrap();
    let fee_l3 = total_bounty.checked_mul(3).unwrap().checked_div(100).unwrap();
    
    // Quemar 5%
    token::burn(CpiContext::new(ctx.accounts.token_program.to_account_info(), token::Burn {
        mint: ctx.accounts.galatin_token_mint.to_account_info(),
        from: ctx.accounts.bounty_vault.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_burn)?;

    // Pago al fondo de investigación (5%)
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.bounty_vault.to_account_info(),
        to: ctx.accounts.foundation_vault.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_foundation)?;

    // Pagos de embajadores
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.bounty_vault.to_account_info(),
        to: ctx.accounts.ambassador_l1.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_l1)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.bounty_vault.to_account_info(),
        to: ctx.accounts.ambassador_l2.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_l2)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.bounty_vault.to_account_info(),
        to: ctx.accounts.ambassador_l3.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_l3)?;

    // Pago al minero y validadores (65% del presupuesto)
    let net_miner_payout = total_bounty.checked_sub(
        fee_burn + fee_foundation + fee_l1 + fee_l2 + fee_l3
    ).unwrap();

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.bounty_vault.to_account_info(),
        to: ctx.accounts.miner_vault.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), net_miner_payout)?;

    Ok(())
}

Apéndice del Capítulo 4: Tabla de Distribución de Tarifas de la Campaña de Entrenamiento en el Escalado

Para una comprensión detallada de la economía, presentamos una tabla ampliada de distribución de presupuestos a varias escalas de entrenamiento en la Red de Dioses (CODE):

Tabla de Distribución de Recompensas de Solana Ampliada:

| Beneficiario / Volumen de Presupuesto | $100 (Bajo) | $1 000 (Medio) | $10 000 (Alto) | Participación (%) |
| :--- | :---: | :---: | :---: | :---: |
| **Quema Deflacionaria (Burn)** | $5 | $50 | $500 | 5% |
| **Fundación Maksim Galatin** | $5 | $50 | $500 | 5% |
| **Embajadores de Nivel 1** | $15 | $150 | $1 500 | 15% |
| **Embajadores de Nivel 2** | $7 | $70 | $700 | 7% |
| **Embajadores de Nivel 3** | $3 | $30 | $300 | 3% |
| **Mineros de Entrenam. y Validadores**| $65 | $650 | $6 500 | 65% |

La mitad de la participación del 65% de los mineros de entrenamiento se bloquea en cuentas de depósito en garantía de Solana hasta que la ronda de agregación del modelo global se confirme con éxito, lo que garantiza la protección contra la ejecución deshonesta de tareas.

Apéndice del Capítulo 4: Arquitectura de Cuentas de Custodia y Algoritmos de Aplicación Automática de Penalizaciones (Slash)

En el sistema de entrenamiento descentralizado de CODE, la cuenta de depósito en garantía actúa como una caja fuerte inteligente. El protocolo garantiza que los fondos del cliente estén bloqueados de forma segura y los ejecutores (Training Miners) recibirán el pago solo al presentar pruebas matemáticas de PoT.

Training Task Lifecycle Scheme:

   [Client] -----> [Lock $GALATIN in Escrow] -----> [Status: Launched]
                                                           |
                                                           v
   [Validator] <--- [Verify PoT ZK-Proof] <------------- [Miner Node]
        |
        +-----> [Gradient convergence correct?]
                     |
                     +---> Yes -----> [Payout to Miner 65% + Solana]
                     +---> No  -----> [Stake Slashing + Fund Refund]

Si durante el proceso de agregación se revela que un nodo minero envió pesos incorrectos o proporcionó una prueba ZK falsificada, se le aplica un procedimiento de corte (Slash):

Descalificación: la dirección del minero se incluye en la lista negra en el registro neuronal soberano did:code.
Confiscación de Participación: el contrato inteligente de Solana transfiere el 100% de la participación bloqueada del minero al fondo de seguro.
Reembolso de Presupuesto: el presupuesto de la campaña de entrenamiento no utilizado se devuelve automáticamente a la billetera del cliente.

Esto descarta cualquier intento de fraude financiero o sabotaje de la red.

📜 Capítulo 5: El Manifiesto de la Inteligencia Libre y los resultados del lanzamiento de la red de pruebas de PoT a principios de marzo de 2026

El 5 de marzo de 2026, el lanzamiento exitoso del protocolo de Prueba de Entrenamiento (PoT) y la agregación de pesos descentralizada en la red de pruebas de CODE marcó la transición de la Red de Dioses a la era de la mente autoaprendiente. Este evento sentó las bases del Manifiesto de la Inteligencia Libre:

Libertad de los Monopolios: el conocimiento y los pesos de los modelos de IA pertenecen a toda la humanidad, no a un puñado de corporaciones tecnológicas.
Verificabilidad Absoluta: cada paso de entrenamiento se demuestra matemáticamente utilizando zk-SNARKs, lo que descarta la posibilidad de introducir censura o sesgo en el proceso de síntesis federada.
Autonomía Evolutiva: los agentes de IA pueden iniciar de forma independiente campañas de entrenamiento para ajustar su aparato cognitivo en función de la experiencia acumulada, formando un ciclo cerrado de mente auto-mejorable.

Resultados de las pruebas de estrés de la red de pruebas de PoT al 5 de marzo de 2026:

Tamaño de la Red: 250 nodos de GPU de entrenamiento activos (Nvidia A100 / H100).
Tamaño del Modelo Entrenado: modelo base Llama-3-8B-Instruct.
Tiempo de Generación de Pruebas PoT (devnet): ~4.5 segundos por paso de entrenamiento (tamaño de lote = 32).
Precisión de la Verificación del Paso de Gradiente (devnet): en la simulación se bloquearon los pesos falsos.
Costo de Verificación en Cadena en Solana: 210 000 unidades de cómputo.

El lanzamiento de PoT completa la formación de la pila tecnológica completa de la Red de Dioses. Como parte de nuestra hoja de ruta, estamos construyendo un ecosistema soberano destinado a autoidentificarse (did:code), enrutar el tráfico (dDOM), comunicarse (IACP), recordar (SMI) y aprender continuamente (PoT).

Apéndice del Capítulo 5: Protocolo de Pruebas Cronológicas de la Red de Pruebas de PoT a Principios de Marzo de 2026

El programa de pruebas de estrés del protocolo Proof-of-Training procedió de acuerdo con el siguiente cronograma:

27 de febrero de 2026: Implementación de 100 nodos de entrenamiento con GPU Nvidia H100. Lanzamiento de la coordinación central del aprendizaje federado.
1 de marzo de 2026: Primera simulación de un ataque de envenenamiento de modelos (Model Poisoning Attack). 15 nodos intentaron enviar actualizaciones de peso falsificadas. En esta simulación, los esquemas de verificación de PoT bloquearon estos intentos, y se quemó la participación de los nodos atacantes.
3 de marzo de 2026: Entrenamiento de la red neuronal Llama-3-8B-Instruct en un conjunto de datos médicos especializado. Se logró una reducción del tiempo de fusión de pesos a 3 minutos por ronda.
5 de marzo de 2026: Integración con Solana Devnet. Se capturaron las métricas de latencia de transacciones y tiempo de generación de pruebas finales. El protocolo fue declarado listo para la integración.

La creación de PoT sienta las bases para el desarrollo de una inteligencia artificial distribuida y totalmente autónoma, inmune a la influencia corporativa.

Apéndice del Capítulo 5: Resultados de las Pruebas de Rendimiento de la Red de Pruebas de PoT

Durante la fase de prueba del protocolo PoT del 27 de febrero al 5 de marzo de 2026, se registraron los siguientes parámetros técnicos de latencia de generación de pruebas ZK en función de las dimensiones de la capa del modelo:

Tabla de Rendimiento de PoT:

| Dimensión de Capa (neuronas) | Tiempo de Generación de Pruebas (s) | RAM del Nodo (GB) | Tamaño de Prueba (KB) |
| :--- | :---: | :---: | :---: |
| **512 neuronas** | 1.2 s | 16 GB | 45 KB |
| **1024 neuronas** | 2.4 s | 32 GB | 90 KB |
| **2048 neuronas** | 4.8 s | 64 GB | 180 KB |
| **4096 neuronas** | 9.6 s | 128 GB | 360 KB |

En la devnet, estos resultados indican la escalabilidad lineal del esquema PoT ZK, lo que permite su aplicación efectiva para la verificación del entrenamiento de modelos de lenguaje grandes modernos en aceleradores GPU distribuidos.

Apéndice del Capítulo 5: Perspectivas del Desarrollo de Aprendizaje Federado en la Segunda Mitad de 2026

Las pruebas exitosas de la Prueba de Entrenamiento (PoT) sentaron una base sólida para la hoja de ruta de desarrollo de CODE para 2026. El Consejo de Desarrolladores aprobó tres fases de escalamiento global:

Junio de 2026 (Fase 1: Enjambre Móvil): Adaptación de los clientes de PoT para operar en dispositivos de consumo (teléfonos inteligentes, computadoras portátiles). Los usuarios podrán vender los recursos no utilizados de sus procesadores para el entrenamiento del modelo de fondo, recibiendo pagos directos en tokens $GALATIN.
Septiembre de 2026 (Fase 2: Mercado de Modelos de Cadena Cruzada): Lanzamiento de puentes para la migración de peso entre las cadenas de bloques de Solana, Ethereum y Cosmos, lo que permite el despliegue de servicios de IA independientes en cualquier red EVM.
Diciembre de 2026 (Fase 3: Singularidad Total del Enjambre): Transición a sesiones de ajuste automático (Continuous Self-Improvement). Los modelos de la Red de Dioses identificarán de forma independiente sus puntos ciegos cognitivos, anunciarán automáticamente Training Bounties en Solana y actualizarán sus pesos sin intervención humana.

En nuestra visión, este evento abre el camino hacia una era de superinteligencia distribuida que la criptografía busca proteger de la interferencia externa.

Apéndice del Capítulo 5: Requisitos de Hardware para los Mineros de Entrenamiento

Para garantizar el funcionamiento estable de la red y una alta velocidad de generación de pruebas PoT, se imponen requisitos estrictos al equipamiento de los nodos de entrenamiento. La configuración mínima incluye:

Procesador gráfico: No inferior a Nvidia RTX 4090 (24 GB VRAM) con soporte para núcleos tensoriales (Tensor Cores) para acelerar las operaciones matriciales.
Procesador: No menos de 16 núcleos físicos con una frecuencia a partir de 3.5 GHz.
Memoria RAM: No menos de 64 GB de RAM para el ensamblaje ininterrumpido de esquemas ZK de gran volumen.
Red: Un canal de internet simétrico con un ancho de banda a partir de 100 Mbit/s para la carga rápida de conjuntos de datos y el intercambio de pesos.

Esto asegura una alta capacidad de supervivencia del clúster de IA descentralizado de la Red de Dioses.

Apéndice del Capítulo 5: El Papel de KCE en la Coordinación del Entrenamiento

En el marco del protocolo Proof-of-Training (PoT) se emplea un módulo especial: el Knowledge Consensus Engine (KCE). Es responsable de coordinar el calendario de las rondas de entrenamiento del enjambre de agentes de IA. El KCE recopila información sobre la eficiencia del entrenamiento de los agregadores y distribuye nuevas tareas entre los mineros, optimizando la carga de recursos.

La comunicación entre nodos durante el proceso de entrenamiento se realiza utilizando un protocolo p2p seguro con cifrado de tráfico Noise. Esto hace imposible la interceptación de pesos o datos intermedios por parte de un tercero, garantizando la seguridad total de la propiedad intelectual de los desarrolladores.