Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

ЛР-8 / lab8_generate

.py
Скачиваний:
0
Добавлен:
15.11.2026
Размер:
14 Кб
Скачать
☆
"""
Лабораторная работа №8 — генерация 1500 комментариев (вариант 10, GitHub Models).

Токен: GITHUB_TOKEN / GITHUB_PAT или файл github_credentials.txt
(PAT с scope models:read — https://github.com/settings/tokens).
Каталог моделей: https://github.com/marketplace/models

Запуск:
  $env:GITHUB_TOKEN = "ghp_..."
  python -m pip install -r lab8_requirements.txt
  python lab8_check.py
  python lab8_generate.py --test
  python lab8_generate.py
  python lab8_generate.py --resume

Параллельно пишется llm_texts_10_<student_id>.txt — по одному комментарию на строку.
"""

from __future__ import annotations

import argparse
import json
import os
import random
import re
import sys
import time
from pathlib import Path

from lab8_github_client import GitHubModelsClient
from lab8_models import pick_model
from lab8_prompts import (
    ANGLE_HINTS,
    ROLES,
    SATURATION_HINTS,
    SCENE_HINTS,
    STYLE_HINTS,
    TOPICS,
    VARIANT_10_ROLE_IDS,
    VARIANT_10_TOPIC_IDS,
    system_prompt,
    user_prompt,
)

VARIANT = 10
STUDENT_ID = "-"
MODEL_LABEL = "deepseek-chat"
DEFAULT_GITHUB_MODEL = "deepseek-v4-flash"

TEXTS_PER_PAIR = 100
MIN_LEN = 100
MAX_LEN = 250

SCRIPT_DIR = Path(__file__).resolve().parent
OUTPUT_JSON = SCRIPT_DIR / f"llm_texts_{VARIANT}_{STUDENT_ID}.json"
OUTPUT_TXT = SCRIPT_DIR / f"llm_texts_{VARIANT}_{STUDENT_ID}.txt"
CHECKPOINT_JSON = SCRIPT_DIR / f"llm_texts_{VARIANT}_checkpoint.json"

SIMILARITY_THRESHOLD = 0.82
PAIR_MEMORY_LIMIT = 30


def normalize_text(raw: str) -> str:
    text = raw.strip()
    text = re.sub(r"^[\"'«»]+|[\"'«»]+$", "", text.strip())
    text = text.replace("\n", " ").replace("\r", " ")
    text = re.sub(r"\s+", " ", text).strip()
    return text


def length_ok(text: str) -> bool:
    return MIN_LEN <= len(text) <= MAX_LEN


def word_set(text: str) -> set[str]:
    return set(re.findall(r"\w+", text.lower()))


def jaccard_similarity(a: str, b: str) -> float:
    wa, wb = word_set(a), word_set(b)
    if not wa or not wb:
        return 0.0
    return len(wa & wb) / len(wa | wb)


def too_similar(text: str, recent: list[str]) -> bool:
    low = text.lower()
    for prev in recent:
        prev_low = prev.lower()
        if low == prev_low:
            return True
        if len(low) > 40 and (low in prev_low or prev_low in low):
            return True
        if jaccard_similarity(text, prev) >= SIMILARITY_THRESHOLD:
            return True
    return False


def variation_for(
    rng: random.Random,
    role_id: int,
    topic_id: int,
    index: int,
) -> tuple[str, str, str, str, str, float]:
    saturation = SATURATION_HINTS[(index + role_id) % len(SATURATION_HINTS)]
    angle = ANGLE_HINTS[(index * 3 + topic_id) % len(ANGLE_HINTS)]
    style = STYLE_HINTS[(index + topic_id * 2) % len(STYLE_HINTS)]
    scene = SCENE_HINTS[(index * 5 + role_id) % len(SCENE_HINTS)]
    session_tag = f"{role_id}-{topic_id}-{index + 1}-{rng.randint(1000, 9999)}"
    temperature = temperature_for_index(index) + rng.uniform(-0.08, 0.12)
    return saturation, angle, style, scene, session_tag, min(1.0, max(0.75, temperature))


def generate_one(
    client: GitHubModelsClient,
    model: str,
    role_id: int,
    topic: str,
    saturation: str,
    angle: str,
    style: str,
    scene: str,
    session_tag: str,
    temperature: float,
    *,
    avoid_phrase: str | None = None,
) -> str:
    messages = [
        {"role": "system", "content": system_prompt(role_id)},
        {
            "role": "user",
            "content": user_prompt(
                role_id,
                topic,
                saturation=saturation,
                angle=angle,
                style=style,
                scene=scene,
                session_tag=session_tag,
                min_len=MIN_LEN,
                max_len=MAX_LEN,
                avoid_phrase=avoid_phrase,
            ),
        },
    ]
    return normalize_text(
        client.chat_completion(
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=400,
        )
    )


def fix_length(
    client: GitHubModelsClient,
    model: str,
    text: str,
    role_id: int,
    topic: str,
) -> str:
    if length_ok(text):
        return text
    direction = "сократи" if len(text) > MAX_LEN else "расширь"
    target = MAX_LEN if len(text) > MAX_LEN else MIN_LEN
    messages = [
        {"role": "system", "content": system_prompt(role_id)},
        {
            "role": "user",
            "content": (
                f"Тема «{topic}». Это комментарий: {text}\n"
                f"{direction.capitalize()} до {target} символов (диапазон {MIN_LEN}–{MAX_LEN}). "
                "Только исправленный текст, одна строка, без кавычек."
            ),
        },
    ]
    raw = client.chat_completion(
        model=model,
        messages=messages,
        temperature=0.7,
        max_tokens=400,
    )
    return normalize_text(raw or text)


def is_rate_limit_error(exc: BaseException) -> bool:
    msg = str(exc).lower()
    return (
        "too many requests" in msg
        or "rate limit" in msg
        or "429" in msg
        or "402" in msg
        or "payment required" in msg
        or "insufficient" in msg
        or "quota" in msg
    )


def wait_for_rate_limit(attempt: int, base_delay: float = 5.0) -> None:
    wait = min(120.0, base_delay * (2**attempt))
    print(f"    лимит API, ждём {wait:.0f} с…")
    time.sleep(wait)


def record(text: str, role_id: int, topic_id: int) -> dict:
    return {
        "text": text,
        "model": MODEL_LABEL,
        "role": ROLES[role_id],
        "topic": TOPICS[topic_id],
        "student_id": STUDENT_ID,
        "variant": VARIANT,
    }


def load_checkpoint() -> list[dict]:
    if CHECKPOINT_JSON.exists():
        with CHECKPOINT_JSON.open(encoding="utf-8") as f:
            return json.load(f)
    return []


def save_checkpoint(records: list[dict]) -> None:
    with CHECKPOINT_JSON.open("w", encoding="utf-8") as f:
        json.dump(records, f, ensure_ascii=False, indent=2)


def save_final(records: list[dict]) -> None:
    with OUTPUT_JSON.open("w", encoding="utf-8") as f:
        json.dump(records, f, ensure_ascii=False, indent=2)
    save_txt_all(records)


def save_txt_all(records: list[dict]) -> None:
    with OUTPUT_TXT.open("w", encoding="utf-8") as f:
        for row in records:
            text = normalize_text(row.get("text", ""))
            if text:
                f.write(text + "\n")


def append_txt_line(text: str) -> None:
    with OUTPUT_TXT.open("a", encoding="utf-8") as f:
        f.write(text + "\n")


def count_done_for_pair(records: list[dict], role_id: int, topic_id: int) -> int:
    role_name = ROLES[role_id]
    topic_name = TOPICS[topic_id]
    return sum(
        1
        for r in records
        if r.get("role") == role_name and r.get("topic") == topic_name
    )


def temperature_for_index(i: int) -> float:
    base = [0.85, 0.95, 1.0, 1.05, 1.15, 1.25]
    return base[i % len(base)]


def run(
    *,
    test_mode: bool,
    resume: bool,
    delay_sec: float,
    max_retries: int,
) -> None:
    client = GitHubModelsClient()
    try:
        api_model = pick_model(
            client,
            preferred=os.environ.get("GITHUB_MODEL") or DEFAULT_GITHUB_MODEL,
        )
    except RuntimeError as exc:
        print(exc, file=sys.stderr)
        sys.exit(1)
    print(f"Модель API: {api_model}")

    records = load_checkpoint() if resume else []
    seen: set[str] = {normalize_text(r["text"]).lower() for r in records if r.get("text")}
    if records:
        save_txt_all(records)
        print(f"TXT синхронизирован: {len(records)} строк → {OUTPUT_TXT.name}")
    elif not resume and OUTPUT_TXT.exists():
        OUTPUT_TXT.unlink()

    pairs: list[tuple[int, int]] = [
        (role_id, topic_id)
        for role_id in VARIANT_10_ROLE_IDS
        for topic_id in VARIANT_10_TOPIC_IDS
    ]
    texts_per_pair = 3 if test_mode else TEXTS_PER_PAIR
    total_target = len(pairs) * texts_per_pair

    print(f"Вариант {VARIANT} | цель: {total_target} текстов | уже есть: {len(records)}")
    if test_mode:
        print("Режим --test: по 3 текста на пару (всего 45).")

    rng = random.Random(VARIANT)

    for role_id, topic_id in pairs:
        topic_name = TOPICS[topic_id]
        already = count_done_for_pair(records, role_id, topic_id)
        if already >= texts_per_pair:
            print(f"  Пропуск {ROLES[role_id]} × {topic_name}: уже {already}")
            continue

        print(f"\n→ {ROLES[role_id]} | {topic_name} ({already}/{texts_per_pair})")

        pair_recent: list[str] = [
            normalize_text(r["text"])
            for r in records
            if r.get("role") == ROLES[role_id] and r.get("topic") == topic_name and r.get("text")
        ][-PAIR_MEMORY_LIMIT:]

        for i in range(already, texts_per_pair):
            saturation, angle, style, scene, session_tag, temperature = variation_for(
                rng, role_id, topic_id, i
            )
            avoid_phrase = pair_recent[-1] if pair_recent else None

            text = ""
            for attempt in range(max_retries):
                try:
                    text = generate_one(
                        client,
                        api_model,
                        role_id,
                        topic_name,
                        saturation,
                        angle,
                        style,
                        scene,
                        session_tag,
                        temperature,
                        avoid_phrase=avoid_phrase if attempt else None,
                    )
                    if not length_ok(text):
                        text = fix_length(client, api_model, text, role_id, topic_name)
                    key = text.lower()
                    similar = too_similar(text, pair_recent)
                    if length_ok(text) and key not in seen and not similar:
                        break
                    if not length_ok(text):
                        print(f"    [{i+1}] длина {len(text)}, повтор…")
                    elif similar:
                        print(f"    [{i+1}] слишком похож на прошлые, повтор…")
                        avoid_phrase = text[:120]
                    else:
                        print(f"    [{i+1}] дубликат, повтор…")
                except Exception as exc:
                    if is_rate_limit_error(exc):
                        wait_for_rate_limit(attempt)
                    else:
                        print(f"    [{i+1}] ошибка API: {exc}, пауза 5 с…")
                        time.sleep(5)
                    text = ""
            else:
                print(f"    [{i+1}] не удалось за {max_retries} попыток, пропуск")
                continue

            if not length_ok(text):
                print(f"    [{i+1}] итоговая длина {len(text)} вне диапазона, пропуск")
                continue

            seen.add(text.lower())
            pair_recent.append(text)
            if len(pair_recent) > PAIR_MEMORY_LIMIT:
                pair_recent.pop(0)
            records.append(record(text, role_id, topic_id))
            save_checkpoint(records)
            append_txt_line(text)

            if (i + 1) % 10 == 0 or test_mode:
                print(f"    [{i+1}/{texts_per_pair}] len={len(text)} | {text[:60]}…")

            time.sleep(delay_sec + rng.uniform(0, 0.3))

    save_final(records)
    print(f"\nГотово: {len(records)} записей → {OUTPUT_JSON}")
    print(f"         {len(records)} строк   → {OUTPUT_TXT}")
    if len(records) != total_target and not test_mode:
        print(f"Внимание: ожидалось {total_target}, получено {len(records)}")
    if len(records) == 1500:
        print("Checkpoint можно удалить:", CHECKPOINT_JSON.name)


def rebuild_txt_from_disk() -> None:
    source = CHECKPOINT_JSON if CHECKPOINT_JSON.exists() else OUTPUT_JSON
    if not source.exists():
        print(f"Нет файла {CHECKPOINT_JSON.name} или {OUTPUT_JSON.name}", file=sys.stderr)
        sys.exit(1)
    with source.open(encoding="utf-8") as f:
        records = json.load(f)
    save_txt_all(records)
    print(f"TXT: {len(records)} строк → {OUTPUT_TXT}")


def main() -> None:
    parser = argparse.ArgumentParser(description="Генерация JSON для лаб. 8, вариант 10 (GitHub Models)")
    parser.add_argument("--test", action="store_true", help="3 текста на каждую из 15 пар")
    parser.add_argument("--resume", action="store_true", help="Продолжить с checkpoint")
    parser.add_argument(
        "--rebuild-txt",
        action="store_true",
        help="Пересобрать .txt из checkpoint или итогового JSON без API",
    )
    parser.add_argument("--delay", type=float, default=1.5, help="Пауза между запросами (сек)")
    parser.add_argument("--max-retries", type=int, default=4)
    args = parser.parse_args()
    if args.rebuild_txt:
        rebuild_txt_from_disk()
        return
    run(
        test_mode=args.test,
        resume=args.resume,
        delay_sec=args.delay,
        max_retries=args.max_retries,
    )


if __name__ == "__main__":
    main()
Соседние файлы в папке ЛР-8