С чего все начиналось?

Сама идея возникла еще год назад.Хотелось создать LLM, которая будет больше всего приближена к AGI.В октябре 2024 было разработано и продумано несколько систем претрейна моделей,а также их дообучение и reinforcement learning системы.Также была разработана новая система декодера на основе декодировщика ROPE.Но к сожалению ресурсов на внедрение таких технологий хватало лишь на модели до 20M параметров,что означало и маленький набор данных для обучения,поэтому смысла в этом ине было.

В апреле был разработан опенсорс агент на основе гемини,который с помощью технологии нескольких вариантов ответа и их анализа был по качеству намного лучше grmini 2.5 pro, хотя агент был разработан на основе gemini 2.0.Агент был назван LiberalMind 1.0

Как я обучал LiberalMind 1.5?

Теперь перейдем именно к этой модели.Обучение построено на технологии GMPO-( Generative Model Policy Optimization ).Кратко опишу как он работает.

это современный метод в Reinforcement Learning, особенно актуальный в задачах offline RL и обучения генеративных политик (например, для языковых моделей).

Он был предложен как более простой, интерпретируемый и эффективный способ RL-обучения без сложных градиентов или value-функций.

Вместо того чтобы использовать классические методы, такие как:

• PPO (Proximal Policy Optimization) — с критиком и актором;

• QLearning / SAC / DDPG — с обучением функции ценности (value),

GMPO использует advantage-weighted supervised learning — регрессию на действия, взвешенную по преимуществу (advantage), без value-функции.

Формально:

где:

• — преимущество (advantage), может быть заранее посчитано;

• — весовая функция, например:

• ​ — параметризованная политика.

⚙️ Как работает GMPO (по шагам)

1. Сбор данных из offline датасета: (s,a,r)(s, a, r)(s,a,r).

2. Оценка advantages для каждого действия (например, с использованием reward или других техник).

3. Переобучение политики: политика обучается имитировать действия из набора, взвешивая их по преимуществу.

4. Регуляризация — можно использовать KL-дивергенцию к начальной политике.

В чем суть моего метода обучения?

1. Архитектура и роли моделей

1. Политика (Actor)

   • Генеративный трансформер с параметрами задаётся низкоранговыми LoRA‑модулями.

   • На входе состояние , на выходе распределение действий .

2. Генеративный Критик (Generative Critic)

   • Тот же тип архитектуры (трансформер) с параметрами — LoRA‑модули критика.

   • Принимает на вход:

     1. Состояние (контекст или префикс).

     2. Предсказание актёра aa.

     3. Истинный ("правильный") ответ

   • Выдаёт объяснение ошибки в виде текста и числовую оценку . Именно эта модель генерирует числовые параметры:

     • Награду .

     • Базовую линию (скаляр, усреднённое по батчу).

     • Преимущество Локальную температуру (при необходимости динамически адаптируемую).

2. Вычисление и генерация параметров критиком

1. Награда  — скаляр, который критик выводит как функцию от текста объяснения.

2. Базовая линия  — агрегатная статистика (mean), которую критик суммирует по нескольким сгенерированным ответам на тот же ss. Также рассчитана и выведена моделью.

3. Преимущество  — разница, рассчитанная внутри критика.

4. Весовая функция:

   ,

   где  — либо фиксированная гиперпараметрическая температура, либо динамическая величина, тоже сгенерированная критиком на основе центральной дисперсии .

Важно: Все эти числовые величины — результаты работы генеративного критика. Их можно логировать и анализировать отдельно.

3. LoRA‑fine‑tuning: интеграция параметров в веса

1. Низкоранговая адаптация

   • В каждом слое трансформера (политики и критика) присутствуют дополнительные матрицы

   • Полные параметры: , аналогично для

2. Обучение LoRA‑весов

   • Градиенты поступают только в LoRA‑модули. Базовая модель θ0,ϕ0\theta_0, \phi_0 остаётся замороженной.

   • LoRA‑модули обучаются методом SGD/Adam с малыми learning rate (обычно , что позволяет:

     • Сохранять языковые и генеративные способности исходной модели.

     • Быстро адаптироваться под специфические reward‑сигналы.

3. Встраивание critic‑параметров

   • Значения используются как масштабные коэффициенты в терминах потерь:

     

   • Градиент этой функции порождает обновления LoRA‑матриц пропорционально critic‑оценкам.

4. Практические детали

   • Размерность LoRA: обычно r=4r=4–1616 в зависимости от бюджета.

   • Частота обновлений: каждые N шагов актёр-генерации (например, N=1–4).

   • Механизм накопления: critic может запоминать статистики , в буфере, чтобы динамически регулировать .

4. Обновлённые функции потерь и алгоритм

Алгоритм на каждой итерации:

1. Сэмплировать батч

2. Генерировать

3. Критик выдаёт

4. Обновить LoRA-критика по Обновить LoRA-политику по

Deep Research и Multi-Agent system

Как вы наверное слышали-Grok 4 прошел бенчмарк Humanity Last Exam с помощью мультиагентной системы.Я реализовал для моей модели тоже самое.Сначала модель парралельно генерирует 4 разных ответа, потом также модель критик совмещает лучшее из всех 4 ответов.Также был разработан Deep Research для этой модели.Код этих методов есть на hf карточки моей модели.

Набор обучающих данных

Я использовал набор данных из тысячи вопросов по разным научным сферам-технические, естественно научные, гуманитарные.Далее я создал мета промпт на тысячи строк и по обучению модель снова просматривала этот набор данных из вопросов и понимала как лучше отвечать на них.

Бенчмарки

Тесты проводились открыто,IMO 2025 и USAMO 2025 с сайта https://matharena.ai/, оценивал ответ LLM судья Chatgpt o4,вы также можете протестировать.Далее скачиваете мою модель: https://huggingface.co/liberalusa/LiberalMind_v1.5

Далее доступен код там вы можете вставить специальный промпт и количество токенов.Для решения этих задач было использовано 10 тысяч токенов и промпт в несколько строк.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Загрузка модели и токенизатора
model_name = "liberalusa/LiberalMind_v1.5"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
model.eval()

def get_user_input():
    """Функция для получения ввода от пользователя"""
    print("\n" + "="*50)
    role = input("Введите роль модели  ")
    prompt = input("Введите ваш промпт: ")
    
    while True:
        try:
            max_tokens = int(input("Введите максимальное количество токенов для генерации (рекомендуется 100-1000): "))
            if max_tokens <= 0:
                print("Количество токенов должно быть положительным числом!")
                continue
            break
        except ValueError:
            print("Пожалуйста, введите целое число!")
    
    return role, prompt, max_tokens

def generate_text(role, prompt, max_tokens):
    """Генерация текста с учетом роли"""
    full_prompt = f"Ты {role}. {prompt}"
    
    inputs = tokenizer.encode(full_prompt, return_tensors="pt", truncation=True, max_length=2048)
    
    # Проверка длины ввода
    input_length = inputs.shape[1]
    available_tokens = model.config.max_position_embeddings - input_length
    actual_max_tokens = min(max_tokens, available_tokens)
    
    print(f"\nИспользуется {input_length} токенов для ввода")
    print(f"Можно сгенерировать до {available_tokens} токенов")
    print(f"Будет сгенерировано {actual_max_tokens} токенов")
    
    if actual_max_tokens <= 0:
        return "Ошибка: ваш промпт слишком длинный для модели!"
    
    with torch.no_grad():
        outputs = model.generate(
            inputs,
            max_new_tokens=actual_max_tokens,
            temperature=0.7,
            top_k=50,
            pad_token_id=tokenizer.eos_token_id,
            do_sample=True
        )
    
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Основной цикл программы
print("LiberalMind v1.5 - Генератор текста")
print("="*50)
print(f"Модель поддерживает до {model.config.max_position_embeddings} токенов контекста")

while True:
    role, prompt, max_tokens = get_user_input()
    response = generate_text(role, prompt, max_tokens)
    
    print("\n" + "="*50)
    print("Результат:")
    print(response)
    
    continue_flag = input("\nПродолжить? (y/n): ").lower()
    if continue_flag != 'y':
        break

Итог

Проделана огромная работа усовершенствования метода GMPO.Если вас заинтересовала данная работа, то можете написать мне в телеграмме @Quloneco.По работе или что-либо еще.

Спасибо за прочтение!