Добавил:
omninoy
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:ЛР-8 / lab8_generate
.py"""
Лабораторная работа №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
