Как собрать end-to-end AI-конвейер для дизайна белков: обучение mRNA-моделей на 25 видах за $165

Все говорят о дорогой биологии. А вы можете сделать её дешёвой

В 2026 году дизайн терапевтического белка — это не магия, а инженерная задача. Самая большая боль — кодонная оптимизация. Взять ген человека, чтобы он работал в дрожжах. Или адаптировать мышиный белок для клеточной линии CHO. Каждый вид говорит на своём языке кодонов. Раньше для этого нужны были целые лаборатории и месяцы работы. Теперь нужен Python, 55 часов на GPU и $165.

Звучит как реклама? Это результат работы CodonRoBERTa-large-v2 — mRNA языковой модели, которая понимает 25 биологических видов одновременно. Perplexity 4.10. Species-conditioned архитектура. И весь код в открытом доступе.

Эта статья — не обзор исследования, а технический мануал. Покажу, как с нуля собрать end-to-end конвейер, который из сырых FASTA-файлов выдаёт оптимизированные mRNA последовательности. Без академического жаргона. Только код, архитектурные решения и жёсткая экономия ресурсов.

Почему ваш прошлый подход к дизайну белков устарел

Вы качаете пару скриптов с GitHub, пытаетесь fine-tune какую-нибудь общую модель на своих данных. Тратите $500 на облако, получаете сомнительные результаты и бросаете это дело. Знакомо?

Проблема в подходе. mRNA — это не обычный текст. Кодон (три нуклеотида) — это «слово». А каждый биологический вид — это «диалект». Обучать одну модель на всех видах без учёта этого — всё равно что учить китайский, смешивая тексты на мандаринском и кантонском диалектах. Модель запутается.

Решение — species-conditioned трансформер. В начале каждой mRNA последовательности мы добавляем специальный токен, например, [HOMO_SAPIENS] или [MUS_MUSCULUS]. Модель с первых слоёв понимает, с каким видом имеет дело, и активирует соответствующие «нейронные паттерны». Это не мультизадачное обучение, а единое контекстуальное представление. Как если бы у переводчика была кнопка переключения между языками.

Архитектурно CodonRoBERTa взяла за основу RoBERTa-base, но полностью переработала токенизатор под кодоны и встроила механизм conditioning. В версии large-v2 (актуальной на апрель 2026) увеличили контекстное окно и добавили эффективные механизмы внимания, что снизило перплексию с 4.8 до 4.10 на валидационной выборке.

Архитектура, которая не сжигает бюджет: CodonRoBERTa-large-v2 против ModernBERT

ModernBERT — это круто для общего NLP. Но для mRNA он избыточен и неэффективен. Вот прямое сравнение на одних и тех же данных (1.2B токенов, 25 видов):

Разница в 3 раза по стоимости и в 3 раза по качеству. ModernBERT пытается учить отношения между отдельными нуклеотидами (A, U, G, C), а CodonRoBERTa работает сразу с кодонами (AUG, UUC, и т.д.). Это сокращает длину последовательности в 3 раза и убирает шум. Species conditioning добавляет чёткий сигнал, который снижает перплексию ещё на 15%.

Конвейер от FASTA до оптимизированной последовательности: 8 шагов

Теория — это хорошо, но нам нужен работающий pipeline. Вот план, который прошёл проверку на реальных данных для проектов по дизайну белков.

1 Добыча и очистка данных: где взять mRNA 25 видов

Всё начинается с данных. Вам нужны референсные транскриптомы. Основные источники на 2026 год: NCBI RefSeq, Ensembl, и специфичные базы вроде CCDS. Качаем через API или готовые дампы.

# Пример: загрузка списка видов из Ensembl через биопитон
from bio import ensembl

species_list = [
    'homo_sapiens', 'mus_musculus', 'rattus_norvegicus',
    'drosophila_melanogaster', 'caenorhabditis_elegans',
    'saccharomyces_cerevisiae', 'escherichia_coli',
    # ... всего 25 видов
]

transcriptomes = {}
for species in species_list:
    transcripts = ensembl.get_transcript_sequences(species)
    # Фильтруем только protein-coding, удаляем дубликаты
    filtered = filter_coding_transcripts(transcripts)
    transcriptomes[species] = filtered

Важный нюанс: данные нужно балансировать. Если у человека 100 тысяч транскриптов, а у дрожжей — 6 тысяч, модель перекосится. Используйте стратифицированную выборку или искусственное ограничение количества последовательностей на вид.

2 Токенизация кодонов: создание custom tokenizer

Стандартный BPE-токенизатор разобьёт последовательность на случайные куски. Нам же нужно чётко по три нуклеотида. Пишем свой.

class CodonTokenizer:
    """Токенизатор, который разбивает mRNA последовательность на кодоны."""
    def __init__(self):
        # Все возможные кодоны (64 штуки) + специальные токены
        self.vocab = {f'[CODON_{i:03d}]': i for i in range(64)}
        self.vocab['[UNK]'] = 64
        self.vocab['[CLS]'] = 65
        self.vocab['[SEP]'] = 66
        # Добавляем токены видов, например:
        self.vocab['[HOMO_SAPIENS]'] = 67
        self.vocab['[MUS_MUSCULUS]'] = 68
        # ... и так для всех 25 видов
        
    def encode(self, sequence: str, species: str) -> List[int]:
        """Кодирует последовательность. Добавляет токен вида в начало."""
        species_token = f'[{species.upper()}]'
        token_ids = [self.vocab[species_token]]
        
        # Разбиваем на кодоны (по 3 символа)
        for i in range(0, len(sequence), 3):
            codon = sequence[i:i+3]
            if codon in self.vocab:
                token_ids.append(self.vocab[codon])
            else:
                token_ids.append(self.vocab['[UNK]'])
        return token_ids

3 Сборка датасета для PyTorch

Теперь упакуем всё в Dataset. Используем Hugging Face Datasets для эффективной работы.

from datasets import Dataset, DatasetDict
import pandas as pd

# Предположим, у нас есть словарь transcriptomes
records = []
for species, sequences in transcriptomes.items():
    for seq in sequences:
        records.append({'sequence': seq, 'species': species})

df = pd.DataFrame(records)
dataset = Dataset.from_pandas(df)

# Разделяем на train/val/test (80/10/10)
dataset_dict = dataset.train_test_split(test_size=0.2)
val_test = dataset_dict['test'].train_test_split(test_size=0.5)
dataset_dict = DatasetDict({
    'train': dataset_dict['train'],
    'validation': val_test['train'],
    'test': val_test['test']
})

4 Модель: реализация species-conditioned transformer

Берём архитектуру RoBERTa, но модифицируем эмбеддинг. Токен вида должен влиять на представление всех кодонов в последовательности.

import torch
import torch.nn as nn
from transformers import RobertaConfig, RobertaModel

class SpeciesConditionedRoberta(nn.Module):
    def __init__(self, num_species=25, codon_vocab_size=64, model_name='roberta-base'):
        super().__init__()
        self.species_embedding = nn.Embedding(num_species, 768)  # Размерность как у RoBERTa
        self.roberta = RobertaModel.from_pretrained(model_name)
        # Заменяем эмбеддинг токенов на наш, с учётом кодонов
        self.roberta.embeddings.word_embeddings = nn.Embedding(codon_vocab_size, 768)
        
    def forward(self, input_ids, species_ids, attention_mask=None):
        # input_ids: [batch_size, seq_len] - кодоны
        # species_ids: [batch_size] - ID вида для каждого примера в батче
        species_emb = self.species_embedding(species_ids)  # [batch_size, 768]
        
        # Получаем эмбеддинги кодонов
        codon_emb = self.roberta.embeddings.word_embeddings(input_ids)  # [batch_size, seq_len, 768]
        
        # Добавляем embedding вида к эмбеддингу первого токена (или ко всем?)
        # В CodonRoBERTa-large-v2 species embedding конкатенируется с эмбеддингом [CLS]
        # Упрощённо: расширяем species_emb до размеров codon_emb и складываем
        species_emb_expanded = species_emb.unsqueeze(1).expand(-1, codon_emb.size(1), -1)
        combined_emb = codon_emb + species_emb_expanded
        
        # Пропускаем через остальные слои RoBERTa
        outputs = self.roberta(inputs_embeds=combined_emb, attention_mask=attention_mask)
        return outputs

В реальной CodonRoBERTa-large-v2 механизм сложнее: species embedding проходит через отдельный трансформерный слой перед взаимодействием с кодонами. Но для старта хватит и этого.

5 Обучение: стратегия, которая укладывается в $165

Секрет дешевизны — не в дешёвом железе, а в умной стратегии. Используем градиентный аккумуляция, смешанную точность (AMP) и early stopping.

# Запуск обучения на 8x A100 (через AWS или Lambda Labs)
# Используем PyTorch + DeepSpeed (актуально на 2026 год)
export GPUS=8
export BATCH_SIZE_PER_GPU=16
export GRAD_ACCUM=4  # Эффективный batch size = 8 * 16 * 4 = 512

python -m torch.distributed.launch --nproc_per_node=$GPUS \
    train_codon_roberta.py \
    --model_name ./model_config \
    --dataset_path ./mrna_dataset \
    --output_dir ./checkpoints \
    --per_device_train_batch_size $BATCH_SIZE_PER_GPU \
    --gradient_accumulation_steps $GRAD_ACCUM \
    --fp16 \
    --learning_rate 1e-4 \
    --num_train_epochs 10 \
    --save_steps 5000 \
    --logging_steps 100

На облачном провайдере вроде Lambda Labs (партнёрская ссылка) аренда 8x A100 на 55 часов обойдётся примерно в $165 по тарифам 2026 года. Важно: выбирайте инстансы с быстрым меж-GPU соединением (NVLink), иначе градиентный аккумуляция будет тормозить.

6 Валидация и метрики: perplexity — это не всё

Perplexity 4.10 — отлично. Но для дизайна белков нужны практические метрики. Добавьте:

• Codon Adaptation Index (CAI): Насколько предсказанные последовательности оптимизированы под целевой вид.
• Вероятность стоп-кодона: Модель не должна генерировать преждевременные стоп-кодоны.
• Дивергенция от референса: Если вы редизайните существующий ген, изменения должны быть минимальными и осмысленными.

def calculate_cai(sequence, species):
    """Вычисляет индекс адаптации кодонов."""
    # Загружаем таблицу частот кодонов для вида
    codon_table = load_codon_table(species)
    cai_values = [codon_table.get(codon, 0) for codon in split_into_codons(sequence)]
    return np.exp(np.mean(np.log(cai_values)))

7 Интеграция в конвейер дизайна белков

Обученная модель — это только ядро. Вам нужен конвейер, который принимает аминокислотную последовательность белка и выдаёт оптимизированную mRNA. Используйте beam search или nucleus sampling для генерации.

def design_mrna(protein_sequence, target_species, model, tokenizer, beam_width=5):
    """Конвертирует аминокислоты в mRNA с оптимизацией кодонов."""
    # 1. Аминокислоты -> возможные кодоны (вырожденность генетического кода)
    candidate_codons = amino_acid_to_codons(protein_sequence)
    
    # 2. Инициализируем beam search с токеном вида
    beams = [{'seq': [tokenizer.species_token(target_species)], 'score': 0.0}]
    
    # 3. Итеративно генерируем кодоны, используя модель для предсказания вероятностей
    for position in range(len(candidate_codons)):
        new_beams = []
        for beam in beams:
            input_ids = torch.tensor([beam['seq']])
            with torch.no_grad():
                outputs = model(input_ids)
                logits = outputs.logits[0, -1, :]  # Логиты для следующего токена
                probabilities = torch.softmax(logits, dim=-1)
            
            # Оцениваем только допустимые кодоны для этой аминокислоты
            allowed_codon_indices = [tokenizer.vocab[c] for c in candidate_codons[position]]
            top_k = torch.topk(probabilities[allowed_codon_indices], beam_width)
            
            for score, idx in zip(top_k.values, top_k.indices):
                codon_idx = allowed_codon_indices[idx]
                new_beams.append({
                    'seq': beam['seq'] + [codon_idx],
                    'score': beam['score'] + torch.log(score).item()
                })
        # Сортируем и оставляем топ-beam_width
        beams = sorted(new_beams, key=lambda x: x['score'], reverse=True)[:beam_width]
    
    # 4. Возвращаем лучшую последовательность
    best = beams[0]
    mrna_sequence = tokenizer.decode(best['seq'][1:])  # Пропускаем токен вида
    return mrna_sequence

8 Деплой и мониторинг: как не сломать продакшен

Выгружать модель в ONNX, обернуть в FastAPI и запустить за брандмауэром — это банально. Главная проблема — дрейф данных. Вирусы мутируют, появляются новые изоформы генов. Ваш конвейер должен уметь дообучаться на лету.

Настройте пайплайн, который раз в месяц качает свежие данные из Ensembl, проводит инкрементальное обучение и A/B тестирует новую модель против старой. Используйте фреймворки типа MLflow или Kubeflow для оркестрации. Подробнее о выводе AI в продакшен почти бесплатно — в статье «От нейрошизы до продакшена».

Типичные грабли, на которые наступают все (и как их обойти)

• Грабли №1: Слишком маленький vocabulary. 64 кодона — это минимум. В реальности есть модифицированные нуклеотиды, регуляторные элементы в UTR. В large-v2 добавили специальные токены для часто встречающихся мотивов, что дало прирост в 0.15 по perplexity.
• Грабли №2: Игнорирование длины последовательности. mRNA бывают очень длинными. Обучение на последовательностях из 10k кодонов убьёт память. Используйте сегментацию с перекрытием (sliding window) и positional embeddings, которые умеют в экстраполяцию.
• Грабли №3: Слепая вера в perplexity. Модель может достичь низкой перплексии, просто запоминая частые шаблоны. Всегда проверяйте генерацию на реалистичность с помощью внешних инструментов, например, симуляторов рибосомального скольжения.
• Грабли №4: Экономия на валидации. Выделите отдельный тестовый вид (например, Danio rerio — zebrafish), который не участвовал в обучении. Если модель хорошо справляется с ним, значит, она действительно обобщает, а не заучивает.

Что дальше? Конвейер — это только начало

Обученная модель CodonRoBERTa — это мощный строительный блок. Его можно встроить в более крупные системы. Например, соединить с Genome AI для предсказания экспрессии не только на уровне mRNA, но и на уровне белка. Или использовать для предобучения модели, которая будет предсказывать иммуногенность пептидов — это следующий хайп в терапевтике.

Главный тренд 2026 года — не увеличение параметров, а увеличение эффективности. Квантованные модели и TinyML позволяют запускать такие конвейеры не в облаке, а на портативном секвенаторе прямо в лаборатории. Следующий шаг — сжать CodonRoBERTa-large-v2 до 50 млн параметров без потери качества и зашить в FPGA.

И последний совет, который сэкономит вам неделю: не пытайтесь воспроизвести всё в точности как в статье. Биология хаотична. Ваши данные будут отличаться. Архитектуру нужно подкручивать. Начните с 5 видов, а не с 25. Возьмите готовые веса с Hugging Face OpenMed и сделайте тонкую настройку под свой конкретный вид. Итерация быстрее, чем перфекционизм.

Подписаться на канал