Ниже — (1) где взять датасеты (ссылки), (2) единый формат, (3) где запускать обучение, и (4) полный стартовый код (prepare → train detector → train patcher LoRA → demo) на Python/PyTorch + Hugging Face (datasets/transformers/peft).

Скачать готовый стартовый пакет кода (zip)

1) Откуда берем датасеты (быстро и воспроизводимо)

Чтобы не мучаться с ручными архивами/гугл-драйвами и сразу получить splits + нормальную загрузку, на старте рекомендую Hugging Face Datasets. Это не «какой-то левый скрапинг»: это просто удобный слой доставки/хранения (а первоисточники при желании тоже можно использовать отдельно).

Juliet / SARD (NIST)

• Официально (canonical): NIST SARD / Zenodo-архив Juliet v1.3 (C/C++). В описании указано public domain / CC0. (Zenodo)
• Удобный HF-формат: LorenzH/juliet_test_suite_c_1_3 — уже извлечены good и bad варианты (через OMITGOOD/OMITBAD), есть train/test, лицензия CC0. (Hugging Face)

Для диплома HF-версия идеальна, потому что сразу дает пары bad→good (то есть сразу датасет для автопочинки).

Devign

• Репозиторий/базовая реализация Devign (GNN по графам) — GitHub. (GitHub)
• HF-версия датасета: DetectVul/devign — удобно грузится и уже разложено на train/val/test. (Hugging Face)

Big-Vul

• Оригинальный репозиторий Big-Vul — GitHub. (GitHub)
• HF-версия: bstee615/bigvul — есть split’ы и нужные поля func_before/func_after, CWE/CVE. (Hugging Face)

MegaVul

• Оригинальный MegaVul — GitHub (там скачивание через облачный линк). (GitHub)
• HF-версия (удобная, CVEfixes-совместимая): hitoshura25/megavul — поля vulnerable_code, fixed_code, cwe_id, cve_id. (Hugging Face)

2) Единый формат (в который приводим ВСЕ)

Я предлагаю два JSONL-формата (по одному на задачу):

A) Detect (детекция уязвимости)

data/unified/detect/{train,validation,test}.jsonl

json
{
  "uid": "unique_id",
  "dataset": "juliet|devign|bigvul|megavul",
  "split": "train|validation|test",
  "lang": "c|cpp",
  "cwe": "CWE-787" | null,
  "cve": "CVE-xxxx-xxxx" | null,
  "label": 0|1,
  "code": "function or snippet",
  "meta": { "anything": "useful" }
}

B) Repair (автопочинка / генерация патча)

data/unified/repair/{train,validation,test}.jsonl

json
{
  "uid": "unique_id",
  "dataset": "...",
  "split": "...",
  "lang": "c|cpp",
  "cwe": "CWE-xxx" | null,
  "cve": "CVE-..." | null,
  "code_before": "vulnerable code",
  "code_after": "fixed code",
  "diff": "--- a/function.c\n+++ b/function.c\n@@ ...\n",
  "meta": { ... }
}

3) Где запускать обучение (не на ноуте)

Минимально и быстро:

• Google Colab (GPU T4/иногда лучше): достаточно для baseline-детектора и для QLoRA/LoRA на StarCoder2-3B.
• Kaggle Notebooks (часто T4/P100): тоже норм для baseline и небольшого LoRA.

Если хочешь «помощнее» (для 7B/15B или больших контекстов/батчей):

• Аренда GPU-инстанса с A100 40/80GB у провайдеров типа RunPod / Lambda / и т.п. (без привязки к конкретному прайсу — он меняется).
  Идея простая: тебе нужен один GPU, SSH/Jupyter, pip install, и запуск тех же скриптов.

4) Полный код пайплайна (prepare → train → demo)

Я собрал это в zip:
Скачать стартовый пакет

Внутри:

• prepare_unified.py — грузит датасеты (HF) и пишет unified JSONL
• train_detect.py — fine-tune baseline детектора (CodeBERT) (Hugging Face)
• train_repair_lora.py — QLoRA/LoRA SFT для генерации unified diff на базе StarCoder2-3B (Hugging Face)
• infer_demo.py — минимальный demo (score + patch)
• requirements.txt, README.md

Ниже — команды «как запустить» (Colab/Kaggle одинаково).

4.1 Установка зависимостей

bash
pip install -r requirements.txt

4.2 Сбор unified-датасета

Вариант A (все источники):

bash
python prepare_unified.py --out_dir data/unified \
  --use_juliet --use_devign --use_bigvul --use_megavul \
  --max_megavul 200000

Вариант B (сфокусироваться на топ-CWE):

bash
python prepare_unified.py --out_dir data/unified \
  --use_juliet --use_bigvul --use_megavul \
  --cwe_filter CWE-787,CWE-119,CWE-190,CWE-78

После этого появятся:

• data/unified/detect/train.jsonl etc
• data/unified/repair/train.jsonl etc
• data/unified/stats.json (счетчики)

4.3 Обучение baseline детектора (CodeBERT)

bash
python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 3 --train_bs 8 --eval_bs 8 --max_length 512

На выходе:

• runs/detect_codebert/best_model/
• runs/detect_codebert/metrics.json

4.4 Дообучение патчера (QLoRA/LoRA) на StarCoder2-3B

bash
python train_repair_lora.py \
  --data_dir data/unified/repair \
  --base_model bigcode/starcoder2-3b \
  --output_dir runs/repair_starcoder2_3b_lora \
  --epochs 1 --max_length 2048 --train_bs 1 --grad_accum 16

На выходе:

• runs/repair_starcoder2_3b_lora/adapter/ (LoRA веса)
• runs/repair_starcoder2_3b_lora/tokenizer/
• runs/repair_starcoder2_3b_lora/metrics.json

Если захочешь Code Llama вместо StarCoder2 — можно (например, 7B). Модель на HF: (Hugging Face)
Тогда в --base_model подставляешь другой id, а LoRA-таргеты скрипт подберет эвристикой.

4.5 Мини-demo: оценка уязвимости + генерация diff

Создай файл sample.c с одной функцией (или куском кода), затем:

bash
python infer_demo.py \
  --code_file sample.c \
  --cwe CWE-78 \
  --lang c \
  --det_model_dir runs/detect_codebert/best_model \
  --patch_base_model bigcode/starcoder2-3b \
  --patch_adapter_dir runs/repair_starcoder2_3b_lora/adapter

5) Дальнейшая логика действий (следующий шаг после baseline)

Чтобы дальше перейти к твоей «правильной» архитектуре:

1. Детектор на графах:

   • выбрать representation: AST/DFG/CPG;
   • для CPG удобно использовать Joern (как в Devign-экосистеме) (GitHub)
   • сделать датасет графов: nodes, edges, node_types, optional line_map
   • обучить GNN/Transformer на PyTorch Geometric (уже можно поверх unified schema, добавив graph_path в meta)

2. Автопочинка:

   • сейчас патчер учится генерить diff на уровне функций (быстрый старт)
   • потом добавишь “контекст” (окружение функции/заголовки/типы) + проверку “patch apply → build/test”.

3. Оценка:

   • detector: F1/AUROC per-CWE
   • patcher: apply rate, compilation/test pass rate, и вручную на подмножестве plausibility.

Если хочешь, в следующем шаге я:

• добавлю графовую ветку (Joern → CPG export → PyG Dataset → GNN baseline),
• и сделаю “минимальный verify” (применение diff + запуск команды сборки/тестов в sandbox/контейнере), но без UI/CLI-обвязки.

Да, это классическая несовместимость версий transformers: в новых версиях TrainingArguments переименовали evaluation_strategy → eval_strategy, поэтому старое имя даёт TypeError: unexpected keyword argument 'evaluation_strategy'. (Hugging Face Forums)

Ниже — два варианта фикса: быстрый (замена) и правильный (совместимость с разными версиями).

Вариант 1 (самый быстрый): заменить evaluation_strategy на eval_strategy

В Kaggle добавь ячейку и выполни:

python
import pathlib, re

def patch_file(fname: str):
    p = pathlib.Path(fname)
    txt = p.read_text()
    # Меняем только имя аргумента в вызовах TrainingArguments(...)
    txt2 = re.sub(r"\bevaluation_strategy\b\s*=", "eval_strategy=", txt)
    if txt2 != txt:
        p.write_text(txt2)
        print(f"patched: {fname}")
    else:
        print(f"no changes: {fname}")

patch_file("train_detect.py")
patch_file("train_repair_lora.py")  # на будущее, чтобы не словить то же самое при LoRA-тренировке

После этого снова запускай:

bash
!python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 3 --train_bs 8 --eval_bs 8 --max_length 512

Вариант 2 (лучше): сделать код совместимым со старыми/новыми transformers

Чтобы больше не ловить такие вещи (и на Kaggle/Colab/VM всё работало одинаково), сделай так:

2.1. В train_detect.py добавь helper рядом с импортами

python
import inspect
from transformers import TrainingArguments

def mk_training_args(**kwargs):
    """
    Совместимость между версиями transformers:
    - где-то используется evaluation_strategy
    - где-то используется eval_strategy
    Также выкидываем неизвестные ключи, чтобы не падать на API-изменениях.
    """
    sig = inspect.signature(TrainingArguments.__init__)
    allowed = set(sig.parameters.keys())

    # Маппинг eval strategy
    if "eval_strategy" in allowed and "evaluation_strategy" in kwargs:
        kwargs["eval_strategy"] = kwargs.pop("evaluation_strategy")
    if "evaluation_strategy" in allowed and "eval_strategy" in kwargs:
        kwargs["evaluation_strategy"] = kwargs.pop("eval_strategy")

    filtered = {k: v for k, v in kwargs.items() if k in allowed}
    dropped = sorted(set(kwargs.keys()) - set(filtered.keys()))
    if dropped:
        print("[compat] Dropped unsupported TrainingArguments keys:", dropped)

    return TrainingArguments(**filtered)

2.2. Заменить создание TrainingArguments(...) на mk_training_args(...)

Было (примерно):

python
training_args = TrainingArguments(
    ...,
    evaluation_strategy="steps",
    ...
)

Станет:

python
training_args = mk_training_args(
    output_dir=args.output_dir,
    per_device_train_batch_size=args.train_bs,
    per_device_eval_batch_size=args.eval_bs,
    num_train_epochs=args.epochs,
    learning_rate=args.lr,
    weight_decay=args.weight_decay,
    logging_steps=50,

    # можно писать как evaluation_strategy — хелпер сам подстроится
    evaluation_strategy="steps",
    eval_steps=args.eval_steps,

    save_strategy="steps",
    save_steps=args.eval_steps,

    load_best_model_at_end=True,
    metric_for_best_model="f1",
    greater_is_better=True,
    report_to="none",
)

То же самое советую сделать и в train_repair_lora.py, если там тоже создаются TrainingArguments.

Важное: “MISSING classifier / UNEXPECTED pooler” — это нормально

Сообщение при загрузке CodeBERT типа:

• classifier.* MISSING
• pooler.* UNEXPECTED

ОК: у базового microsoft/codebert-base нет обученной “головы” классификатора под твою задачу, она создаётся заново и будет обучаться на твоих данных.

Если хочешь быстро проверить, что именно стоит в Kaggle (на всякий)

python
import transformers, inspect
from transformers import TrainingArguments
print("transformers:", transformers.__version__)
sig = inspect.signature(TrainingArguments.__init__)
print("has evaluation_strategy:", "evaluation_strategy" in sig.parameters)
print("has eval_strategy:", "eval_strategy" in sig.parameters)

Если после этого обучение пойдёт — следующим шагом я помогу:

1. сделать быстрый “debug run” на подвыборке (чтобы проверить метрики за 3–5 минут),
2. затем запустить полноценно и добавить CWE-фильтрацию и балансировку, чтобы F1 не “уплыл” на дисбалансе классов.

Да, тут уже не “несовместимость transformers”, а несостыковка твоего CLI: в коде ты используешь args.weight_decay и args.eval_steps, но в argparse ты их не объявил, поэтому Namespace не содержит этих полей → AttributeError.

При этом ты прав: лучше сразу сделать максимально кроссверсионно, потому что на Kaggle/Colab часто стоят разные версии transformers, datasets, и иногда меняются сигнатуры TrainingArguments/Trainer.

Ниже даю:

1. минимальный фикс (быстро поднять обучение)
2. рекомендованный “кроссверсионный” вариант файла train_detect.py целиком (чтобы потом не ловить новые падения)
3. что ещё может сломаться по версиям и как это заранее учесть
4. В конце — как лучше присылать мне информацию, чтобы не спамить контекст кодом

1) Минимальный фикс прямо в твоём текущем файле

Добавь аргументы в argparse

После твоих аргументов (--lr, --train_bs, …) добавь:

python
ap.add_argument("--weight_decay", type=float, default=0.01)
ap.add_argument("--eval_steps", type=int, default=500)

И лучше сразу сделать безопасно через getattr

Чтобы даже при старом файле/старом запуске ничего не падало:

python
weight_decay = getattr(args, "weight_decay", 0.01)
eval_steps   = getattr(args, "eval_steps", 500)

И в mk_training_args(...) заменить:

python
weight_decay=args.weight_decay,
eval_steps=args.eval_steps,
save_steps=args.eval_steps,

на:

python
weight_decay=weight_decay,
eval_steps=eval_steps,
save_steps=eval_steps,

Этого уже достаточно, чтобы ошибка ушла.

2) Рекомендованный кроссверсионный train_detect.py (перепиши файл целиком)

Почему лучше переписать:

• evaluation_strategy ↔ eval_strategy уже поймал (плюс будет ещё несколько похожих “мин”)
• текущий DetectJsonlDataset грузит весь train.jsonl в память (у тебя ~495k строк) — на Kaggle это часто = OOM или “подвисание”.
• безопаснее использовать datasets.load_dataset("json") + set_transform() — оно memory-mapped/Arrow, не держит весь питоновский список строк.

Скопируй и замени train_detect.py на этот вариант:

python
#!/usr/bin/env python3
"""
train_detect.py (cross-version friendly)

Baseline fine-tune for vulnerability detection using a sequence classifier (e.g., CodeBERT).

Input:
  data/unified/detect/{train,validation,test}.jsonl  (from prepare_unified.py)

Output:
  output_dir/
    best_model/   (HF saved model)
    metrics.json
"""

from __future__ import annotations

import argparse
import inspect
import json
import os
from pathlib import Path
from typing import Any, Dict, Optional

import numpy as np
import torch
from sklearn.metrics import accuracy_score, precision_recall_fscore_support, roc_auc_score
from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    DataCollatorWithPadding,
    Trainer,
    TrainingArguments,
)

# ----------------------------
# Compatibility helpers
# ----------------------------

def mk_training_args(**kwargs) -> TrainingArguments:
    """
    Build TrainingArguments in a way that survives transformers API changes.

    - Newer transformers renamed `evaluation_strategy` -> `eval_strategy`
    - Some keys appear/disappear across versions
    We inspect signature and:
      * rename keys when needed
      * drop unknown keys
    """
    sig = inspect.signature(TrainingArguments.__init__)
    allowed = set(sig.parameters.keys())

    # Map eval strategy name across versions
    if "eval_strategy" in allowed and "evaluation_strategy" in kwargs:
        kwargs["eval_strategy"] = kwargs.pop("evaluation_strategy")
    if "evaluation_strategy" in allowed and "eval_strategy" in kwargs:
        kwargs["evaluation_strategy"] = kwargs.pop("eval_strategy")

    # report_to: safer as [] (works in older versions too)
    if "report_to" in kwargs and kwargs["report_to"] == "none":
        kwargs["report_to"] = []

    filtered = {k: v for k, v in kwargs.items() if k in allowed}
    dropped = sorted(set(kwargs.keys()) - set(filtered.keys()))
    if dropped:
        print("[compat] Dropped unsupported TrainingArguments keys:", dropped)

    return TrainingArguments(**filtered)


def safe_set_seed(seed: int) -> None:
    """Works across transformers versions."""
    try:
        from transformers import set_seed
        set_seed(seed)
    except Exception:
        import random
        random.seed(seed)
        np.random.seed(seed)
        torch.manual_seed(seed)
        if torch.cuda.is_available():
            torch.cuda.manual_seed_all(seed)


def compute_metrics(eval_pred) -> Dict[str, float]:
    """
    Works across transformers versions:
    - sometimes eval_pred is EvalPrediction with .predictions/.label_ids
    - sometimes it's a tuple (logits, labels)
    """
    if hasattr(eval_pred, "predictions"):
        logits = eval_pred.predictions
        labels = eval_pred.label_ids
    else:
        logits, labels = eval_pred

    # Some models return a tuple for logits
    if isinstance(logits, (tuple, list)):
        logits = logits[0]

    preds = np.argmax(logits, axis=-1)

    precision, recall, f1, _ = precision_recall_fscore_support(
        labels, preds, average="binary", zero_division=0
    )
    acc = accuracy_score(labels, preds)

    # AUROC needs probabilities; may fail if only one class present in labels
    try:
        probs = torch.softmax(torch.tensor(logits), dim=-1)[:, 1].cpu().numpy()
        auroc = roc_auc_score(labels, probs)
    except Exception:
        auroc = float("nan")

    return {
        "accuracy": float(acc),
        "precision": float(precision),
        "recall": float(recall),
        "f1": float(f1),
        "auroc": float(auroc),
    }


# ----------------------------
# Dataset loading (memory-safe)
# ----------------------------

def load_splits_with_hf_datasets(
    data_dir: Path,
    only_lang: Optional[str],
    max_train_samples: Optional[int],
    max_eval_samples: Optional[int],
    max_test_samples: Optional[int],
    tokenizer,
    max_length: int,
    num_proc: int = 1,
):
    """
    Uses `datasets` library (Arrow) to avoid reading massive JSONL into Python RAM.
    Applies lazy tokenization via set_transform.
    """
    from datasets import load_dataset

    data_files = {
        "train": str(data_dir / "train.jsonl"),
        "validation": str(data_dir / "validation.jsonl"),
        "test": str(data_dir / "test.jsonl"),
    }
    ds = load_dataset("json", data_files=data_files)

    def lang_filter(ex):
        # ex is dict-like
        return ex.get("lang") == only_lang

    if only_lang:
        # filter can be slow; keep num_proc small if Kaggle is unstable
        ds["train"] = ds["train"].filter(lang_filter, num_proc=num_proc)
        ds["validation"] = ds["validation"].filter(lang_filter, num_proc=num_proc)
        ds["test"] = ds["test"].filter(lang_filter, num_proc=num_proc)

    if max_train_samples:
        ds["train"] = ds["train"].select(range(min(max_train_samples, len(ds["train"]))))

    if max_eval_samples:
        ds["validation"] = ds["validation"].select(range(min(max_eval_samples, len(ds["validation"]))))

    if max_test_samples:
        ds["test"] = ds["test"].select(range(min(max_test_samples, len(ds["test"]))))

    def make_transform():
        def _transform(ex: Dict[str, Any]) -> Dict[str, Any]:
            code = ex.get("code", "")
            enc = tokenizer(
                code,
                truncation=True,
                max_length=max_length,
            )
            enc["labels"] = int(ex.get("label", 0))
            return enc
        return _transform

    transform_fn = make_transform()
    ds["train"].set_transform(transform_fn)
    ds["validation"].set_transform(transform_fn)
    ds["test"].set_transform(transform_fn)

    return ds["train"], ds["validation"], ds["test"]


def main():
    ap = argparse.ArgumentParser()

    ap.add_argument("--data_dir", type=str, default="data/unified/detect")
    ap.add_argument("--model_name", type=str, default="microsoft/codebert-base")
    ap.add_argument("--output_dir", type=str, default="runs/detect_codebert")
    ap.add_argument("--max_length", type=int, default=512)

    ap.add_argument("--epochs", type=int, default=3)
    ap.add_argument("--lr", type=float, default=2e-5)
    ap.add_argument("--weight_decay", type=float, default=0.01)

    ap.add_argument("--train_bs", type=int, default=8)
    ap.add_argument("--eval_bs", type=int, default=8)
    ap.add_argument("--grad_accum", type=int, default=1)

    ap.add_argument("--eval_steps", type=int, default=500, help="If >0 -> eval/save every N steps; if 0 -> eval per epoch")
    ap.add_argument("--logging_steps", type=int, default=50)
    ap.add_argument("--seed", type=int, default=42)

    ap.add_argument("--only_lang", type=str, default=None, help="Optional: filter by lang=c or lang=cpp")

    # Quick debug knobs (VERY useful on Kaggle)
    ap.add_argument("--max_train_samples", type=int, default=None)
    ap.add_argument("--max_eval_samples", type=int, default=None)
    ap.add_argument("--max_test_samples", type=int, default=None)

    ap.add_argument("--num_proc", type=int, default=1, help="datasets.filter/map workers (keep small on Kaggle)")

    # Mixed precision (safe defaults)
    ap.add_argument("--fp16", action="store_true", help="Enable fp16 if supported")
    ap.add_argument("--bf16", action="store_true", help="Enable bf16 if supported")

    args = ap.parse_args()

    data_dir = Path(args.data_dir)
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    safe_set_seed(args.seed)

    # Tokenizer: robust fallback if use_fast causes issues on some models/envs
    try:
        tokenizer = AutoTokenizer.from_pretrained(args.model_name, use_fast=True)
    except Exception:
        tokenizer = AutoTokenizer.from_pretrained(args.model_name)

    model = AutoModelForSequenceClassification.from_pretrained(args.model_name, num_labels=2)

    # Memory-safe dataset loading
    train_ds, val_ds, test_ds = load_splits_with_hf_datasets(
        data_dir=data_dir,
        only_lang=args.only_lang,
        max_train_samples=args.max_train_samples,
        max_eval_samples=args.max_eval_samples,
        max_test_samples=args.max_test_samples,
        tokenizer=tokenizer,
        max_length=args.max_length,
        num_proc=max(1, int(args.num_proc)),
    )

    collator = DataCollatorWithPadding(tokenizer=tokenizer)

    # Decide evaluation/save strategy
    if args.eval_steps and args.eval_steps > 0:
        eval_strategy = "steps"   # will be mapped to eval_strategy/evaluation_strategy by mk_training_args()
        eval_steps = int(args.eval_steps)
        save_strategy = "steps"
        save_steps = int(args.eval_steps)
    else:
        eval_strategy = "epoch"
        eval_steps = None
        save_strategy = "epoch"
        save_steps = None

    # Disable wandb/etc reliably
    os.environ.setdefault("WANDB_DISABLED", "true")

    training_kwargs = dict(
        output_dir=str(out_dir),
        per_device_train_batch_size=args.train_bs,
        per_device_eval_batch_size=args.eval_bs,
        gradient_accumulation_steps=args.grad_accum,
        num_train_epochs=args.epochs,
        learning_rate=args.lr,
        weight_decay=args.weight_decay,
        logging_steps=args.logging_steps,
        save_total_limit=2,

        evaluation_strategy=eval_strategy,  # will be renamed if needed
        load_best_model_at_end=True,
        metric_for_best_model="f1",
        greater_is_better=True,

        report_to=[],  # safest across versions
        seed=args.seed,
    )

    # Conditionally add step-based params
    if eval_steps is not None:
        training_kwargs.update(
            dict(
                eval_steps=eval_steps,
                save_strategy=save_strategy,
                save_steps=save_steps,
            )
        )
    else:
        training_kwargs.update(dict(save_strategy=save_strategy))

    # Mixed precision (only if user explicitly asked; mk_training_args will drop if unsupported)
    if args.fp16:
        training_kwargs["fp16"] = True
    if args.bf16:
        training_kwargs["bf16"] = True

    training_args = mk_training_args(**training_kwargs)

    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_ds,
        eval_dataset=val_ds,
        data_collator=collator,
        compute_metrics=compute_metrics,
    )

    trainer.train()

    # Save best model (Trainer keeps best at end if load_best_model_at_end is supported)
    best_dir = out_dir / "best_model"
    trainer.save_model(str(best_dir))
    tokenizer.save_pretrained(str(best_dir))

    # Evaluate on test with stable API usage
    test_metrics = trainer.evaluate(eval_dataset=test_ds, metric_key_prefix="test")

    with (out_dir / "metrics.json").open("w", encoding="utf-8") as f:
        json.dump({"test": test_metrics}, f, ensure_ascii=False, indent=2)

    print("Saved:", best_dir)
    print("Test metrics:", test_metrics)


if __name__ == "__main__":
    main()

Запуск (Kaggle)

Для быстрой проверки (чтобы за 2–5 минут убедиться, что всё работает):

bash
!python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 1 --train_bs 8 --eval_bs 8 --max_length 512 \
  --max_train_samples 20000 --max_eval_samples 5000 --max_test_samples 5000 \
  --eval_steps 500

А потом уже полный прогон (но я бы всё равно не гнал 3 эпохи на 500k без проверки баланса/метрик — дорого по времени):

bash
!python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 3 --train_bs 8 --eval_bs 8 --max_length 512 \
  --eval_steps 1000

3) Какие ещё несовместимости стоит закрыть заранее (чек‑лист)

A) Trainer/TrainingArguments меняются чаще всего

Что уже учли:

• evaluation_strategy ↔ eval_strategy
• выкидывание неизвестных ключей по сигнатуре

Что ещё часто ломает запуск:

• wandb автозапуск → просит логин/ключ.
  Решение: report_to=[] + WANDB_DISABLED=true (я добавил оба).

B) datasets лучше чем “читать JSONL в список”

Твой текущий класс DetectJsonlDataset при 494k строк:

• может съесть RAM (и ещё 2 копии на val/test)
• очень медленно создаёт Python-объекты

Arrow‑датасеты решают это.

C) compute_metrics формат

В разных версиях transformers eval_pred бывает:

• EvalPrediction(predictions=..., label_ids=...)
• или tuple-like
  Я сделал поддержку обоих.

D) Поддержка “use_fast”

Иногда на отдельных моделях/окружениях fast tokenizer может падать — сделал try/fallback.

4) Как лучше давать мне информацию, чтобы не засорять контекст кодом

Ты всё сделал правильно, что прислал стектрейс и конкретный фрагмент.

Чтобы было максимально эффективно и без “простыней” кода:

1. Traceback + версия библиотек (это топ‑1 полезно):
   Выполни и пришли вывод:

   bash
   !python -c "import transformers, datasets, torch; print('transformers', transformers.__version__); print('datasets', datasets.__version__); print('torch', torch.__version__); print('cuda', torch.cuda.is_available())"

2. Вместо полного файла — окрестность проблемных строк:
   Например, если ошибка на line 167:

   bash
   !nl -ba train_detect.py | sed -n '150,190p'

   (Это покажет только 40 строк вокруг места падения.)

3. Если правок много — лучше загружай файл/zip прямо сюда (как вложение).
   Тогда я смогу точечно сказать “вот здесь поменять” и дать аккуратный diff, а не гадать по фрагментам.

4. Скриншоты тоже ок, но лучше всё же: traceback + nl -ba ... — меньше риск потерять детали.

Если хочешь — следующим шагом я предложу “разумный режим обучения” для твоего масштаба данных:

• быстрый debug‑прогон на 20–50k,
• затем обучение на CWE‑фильтре (например, только 787/119/190/78),
• и/или балансировка классов (иначе F1 может быть “хороший” из‑за перекоса, но детектор бесполезный).

Поймал причину: это уже не transformers, а datasets/pyarrow, и она как раз “кроссверсионная” (особенно на datasets==4.x).

Почему падает

datasets.load_dataset("json", ...) пытается построить Arrow-таблицу со стабильной схемой.
А у тебя в unified JSONL поле meta — словарь с разными наборами ключей в разных источниках:

• Devign: meta={filename, class, variant}
• BigVul/MegaVul: meta={filename, class, variant, project, commit_id} (и т.п.)

Arrow выводит схему по первым примерам (например, только filename,class,variant), а потом встречает запись, где meta содержит доп. поля (project, commit_id) — и падает:

Couldn’t cast array of type struct<... project, commit_id ...> to struct<... only filename,class,variant ...>

Решение №1 (рекомендую): “нормализовать” JSONL → сделать meta строкой (JSON-string)

Это самый надёжный вариант: meta остаётся, но как строка, и схема всегда одинакова.

✅ Запуци это в Kaggle одной ячейкой (перепишет файлы на месте)

python
import json
from pathlib import Path
from tqdm.auto import tqdm

def sanitize_jsonl(path: Path):
    tmp = path.with_suffix(".tmp")
    n = 0
    with path.open("r", encoding="utf-8") as fin, tmp.open("w", encoding="utf-8") as fout:
        for line in fin:
            line = line.strip()
            if not line:
                continue
            row = json.loads(line)

            # 1) meta: dict/list -> стабильная строка
            if "meta" in row and isinstance(row["meta"], (dict, list)):
                row["meta"] = json.dumps(row["meta"], ensure_ascii=False, sort_keys=True)

            # 2) страховка по типам (на всякий)
            if "label" in row and row["label"] is not None:
                row["label"] = int(row["label"])
            for k in ("uid", "dataset", "split", "lang", "cwe", "cve", "code"):
                if k in row and row[k] is not None and not isinstance(row[k], str):
                    row[k] = str(row[k])

            fout.write(json.dumps(row, ensure_ascii=False) + "\n")
            n += 1

    tmp.replace(path)
    print(f"[ok] sanitized {path} ({n} lines)")

root = Path("data/unified")
for sub in ["detect", "repair"]:
    d = root / sub
    if not d.exists():
        continue
    for split in ["train", "validation", "test"]:
        p = d / f"{split}.jsonl"
        if p.exists():
            sanitize_jsonl(p)

(Опционально) снести битый кеш datasets

Иногда после крэша остаётся “полусобранный” кеш. Если после санитизации оно вдруг продолжит ругаться — выполни:

bash
!rm -rf ~/.cache/huggingface/datasets/json

Потом запускай обучение снова

Я бы очень советовал сначала сделать быстрый sanity-run (иначе 500k*3 эпохи может быть адски долго на Kaggle):

bash
!python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 1 --train_bs 8 --eval_bs 8 --max_length 512 \
  --max_train_samples 20000 --max_eval_samples 5000 --max_test_samples 5000 \
  --eval_steps 500

И только потом — полный:

bash
!python train_detect.py \
  --data_dir data/unified/detect \
  --model_name microsoft/codebert-base \
  --output_dir runs/detect_codebert \
  --epochs 3 --train_bs 8 --eval_bs 8 --max_length 512 \
  --eval_steps 1000

Решение №2 (ещё более “кроссверсионно”): фикс в prepare_unified.py, чтобы больше никогда так не было

Чтобы не чинить уже созданные jsonl, лучше изменить генератор: писать meta сразу строкой.

В prepare_unified.py в момент записи строки (где формируешь row) поменяй:

python
row["meta"] = meta_dict

на:

python
import json
row["meta"] = json.dumps(meta_dict, ensure_ascii=False, sort_keys=True) if meta_dict is not None else None

Тогда все будущие unified-файлы будут стабильно грузиться через datasets.

Почему я не предлагаю “features=…” в load_dataset

Теоретически можно передать features и описать meta как struct с суперсетом всех возможных ключей.
Но это:

• хрупко (появятся новые ключи → снова ошибка),
• неудобно (нужно заранее знать полный список),
• хуже для дипломного пайплайна, чем просто хранить meta JSON-строкой.

На будущее: этот же баг 1-в-1 вылезет на repair/*.jsonl

Ты правильно заметил “подумать обо всех несовместимостях”:
в repair тоже есть meta из разных источников → LoRA-скрипт может упасть тем же способом.
Поэтому санитизатор я специально сделал для detect и repair.

Как лучше давать мне информацию, чтобы не засорять контекст кодом

Самый удобный формат для дебага:

1. Traceback текстом (или скрин, но лучше текст).
2. Версии одной командой:

bash
!python -c "import transformers, datasets, torch; print('transformers', transformers.__version__); print('datasets', datasets.__version__); print('torch', torch.__version__)"

3. Если ошибка “в конкретной строке файла” — присылай только кусок вокруг:

bash
!nl -ba train_detect.py | sed -n '120,200p'

4. Если ошибка “в данных” — присылай пару проблемных строк (например первые 2–3 и одну из середины):

bash
!python - << 'PY'
import json
p="data/unified/detect/train.jsonl"
with open(p,"r",encoding="utf-8") as f:
    for i in [0,1,2,140000]:
        f.seek(0)
        for k,line in enumerate(f):
            if k==i:
                print(i, json.loads(line).keys())
                print("meta_type:", type(json.loads(line).get("meta")))
                break
PY

Если хочешь вообще без “копипасты” — можешь прикреплять файл (train_detect.py или лог), я тогда буду давать точечные диффы/патчи.

Если после санитизации load_dataset пойдёт — следующий шаг: я предложу нормальный режим обучения на твоём объёме (подвыборка + CWE-фильтр + балансировка), чтобы метрики были осмысленные и Kaggle не умер по времени.