Restauración de ruGPT-3 XL para transformers

Convertir y restaurar ruGPT-3 XL para marcos modernos

Los desarrolladores enfrentaron dificultades al ejecutar el modelo de lenguaje obsoleto ai-forever/rugpt3xl (1.3B parámetros) de 2021. Originalmente entrenado desde cero sobre un corpus ruso como variante de GPT-2, se almacena en formato de punto de control Megatron-LM, lo que requiere PyTorch 1.7 y transformers 3.5. Convertirlo al formato Hugging Face abre compatibilidad con herramientas modernas de inferencia y fine-tuning.

El proceso implica extraer los pesos de mp_rank_00_model_states.pt, mapearlos a la estructura GPT2Model y crear clases personalizadas para transformers.

Estructura de pesos: Megatron-LM frente a Hugging Face

Los pesos originales usan una proyección fusionada QKV [6144, 2048], que debe dividirse en matrices separadas Q, K, V de tamaño [2048, 2048]. Mapeo completo:

| Megatron-LM | HuggingFace |

|-------------|-------------|

| word_embeddings.weight | model.embed_tokens.weight |

| position_embeddings.weight | model.embed_positions.weight |

| transformer.layers.{i}.input_layernorm. | model.layers.{i}.input_layernorm. |

| transformer.layers.{i}.attention.query_key_value.weight | model.layers.{i}.self_attn.{q,k,v}_proj.weight |

| transformer.layers.{i}.attention.query_key_value.bias | model.layers.{i}.self_attn.{q,k,v}_proj.bias |

| transformer.layers.{i}.attention.dense. | model.layers.{i}.self_attn.o_proj. |

| transformer.layers.{i}.post_attention_layernorm. | model.layers.{i}.post_attention_layernorm. |

| transformer.layers.{i}.mlp.dense_h_to_4h. | model.layers.{i}.mlp.up_proj. |

| transformer.layers.{i}.mlp.dense_4h_to_h. | model.layers.{i}.mlp.down_proj. |

| transformer.final_layernorm. | model.norm. |

| - | lm_head.weight (copia de embed_tokens) |

El script convert.py transforma el punto de control en safetensors compatible con transformers.

Clases de modelo personalizadas

Se crearon nuevas clases sin dependencias de Megatron-LM ni DeepSpeed:

• RuGPT3XLConfig: hereda PretrainedConfig con parámetros (vocab_size=50264, hidden_size=2048, num_layers=24).
• RuGPT3XLAttention: atención multi-cabeza con Q/K/V separados y DynamicCache.
• RuGPT3XLMLP: bloque MLP (up_proj → GELU → down_proj).
• RuGPT3XLDecoderLayer: capa decodificadora (pre-LN → atención → post-LN → MLP).
• RuGPT3XLModel: embeddings + 24 capas + LN final.
• RuGPT3XLForCausalLM: incluye lm_head.

Mejoras clave:

• forward() estándar para SFTTrainer/LoRA.
• Cache KV mediante DynamicCache.
• Checkpointing de gradientes.
• Funciona en CPU/GPU usando device_map="auto".

El modelo ahora está disponible como evilfreelancer/ruGPT3XL en Hugging Face.

Resultados de pruebas

Generación en RTX 4090 (float16):

• Velocidad promedio: 66.7 tokens/seg (batch_size=1).
• Mantiene contexto en prompts largos.
• Genera texto preciso (recetas, narrativas históricas).

Benchmark MERA (puntuación total: 0.198):

• PARus (sentido común): 0.500
• ruHateSpeech: 0.558
• BPS (código/matemáticas): 0.528
• RWSD (razonamiento): 0.488
• ruTiE (diálogo): 0.502
• ruMMLU: 0.252

El rendimiento en matemáticas y código es cercano al nivel base—esperado para un modelo base sin ajuste por instrucciones.

Conversión a GGUF para llama.cpp

Tras la conversión al formato HF, el script convert_hf_to_gguf.py se adaptó para ruGPT-3 XL. El modelo funciona en llama.cpp sin dependencias de Megatron, soportando cache KV e inferencia moderna.

Esto permite fine-tuning en datasets personalizados mediante LoRA o SFT, integración en pipelines y pruebas en dispositivos de borde.

Conclusiones clave

• Compatibilidad: Funciona con transformers ≥4.x, sin necesidad de pilas antiguas.
• Rendimiento: 66.7 t/s en RTX 4090, soporte de cache KV para generación.
• Entrenabilidad: Listo para LoRA/SFTTrainer con checkpointing de gradientes.
• Benchmark: Fuerte en sentido común y detección de odio (>0.5), más débil en matemáticas/código.
• Formatos: HF + GGUF para amplia compatibilidad en el ecosistema.

— Editorial Team