# magpie_vllm_async.py import os import json import math import asyncio import random from typing import Dict, Any, List, Tuple, Optional from dataclasses import dataclass import re from openai import AsyncOpenAI, BadRequestError from tqdm import tqdm from itertools import count from prompts import CATEGORIES_SYSTEM_PROMPTS # dict: {name: (prompt, prob)} # --------------------------------------------------------------------- # Config vLLM OpenAI-compatible # --------------------------------------------------------------------- VLLM_BASE_URL = os.environ.get("VLLM_BASE_URL", "http://10.100.0.111:8020/v1") VLLM_API_KEY = os.environ.get("VLLM_API_KEY", "no-key-needed") # Decoding (globais) GEN_TEMPERATURE = float(os.environ.get("GEN_TEMPERATURE", "0.7")) GEN_TOP_P = float(os.environ.get("GEN_TOP_P", "1.0")) GEN_MAX_NEW_TOK = int(os.environ.get("GEN_MAX_NEW_TOK", "8192")) STOP_STRINGS = ["<|im_end|>", "<|end_of_text|>"] STOP_TOKEN_IDS = None # Decoding diferenciada (resposta vs pergunta) RESP_TEMPERATURE = float(os.environ.get("RESP_TEMPERATURE", str(GEN_TEMPERATURE if GEN_TEMPERATURE else 0.3))) RESP_TOP_P = float(os.environ.get("RESP_TOP_P", str(min(GEN_TOP_P, 0.9)))) RESP_MAX_TOKENS = int(os.environ.get("RESP_MAX_TOKENS", "8192")) Q_TEMPERATURE = float(os.environ.get("Q_TEMPERATURE", "0.7")) Q_TOP_P = float(os.environ.get("Q_TOP_P", "0.95")) Q_MAX_TOKENS = int(os.environ.get("Q_MAX_TOKENS", "8192")) # --------------------------------------------------------------------- # Controle de execução # --------------------------------------------------------------------- NUM_ROWS = int(os.environ.get("NUM_ROWS", "600000")) BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "16")) N_TURNS = int(os.environ.get("N_TURNS", "3")) OUTPUT_FILE = os.environ.get("OUTPUT_FILE", "magpie_conversations_cemig.jsonl") INCLUDE_SYSTEM = True # (não será salvo no output) LOGITS_PROCESSORS: List[str] = [] # Concorrência MAX_ASYNC_TOTAL = int(os.environ.get("MAX_ASYNC", "256")) CHAT_SHARE = float(os.environ.get("CHAT_SHARE", "0.8")) # 80% chat / 20% qgen MAX_ASYNC_CHAT = max(1, int(MAX_ASYNC_TOTAL * CHAT_SHARE)) MAX_ASYNC_QGEN = max(1, MAX_ASYNC_TOTAL - MAX_ASYNC_CHAT) QUEUE_MAXSIZE = int(os.environ.get("QUEUE_MAXSIZE", str(MAX_ASYNC_CHAT * 4))) # --------------------------------------------------------------------- # Dataset em streaming # --------------------------------------------------------------------- WIKI_DATASET_ID = os.environ.get("WIKI_DATASET_ID", "cemig-ceia/energy_sft_ctx_dataset") WIKI_SUBSET = os.environ.get("WIKI_SUBSET", "default") WIKI_TEXT_FIELD = os.environ.get("WIKI_TEXT_FIELD", "text") WIKI_MAX_CHARS = int(os.environ.get("WIKI_MAX_CHARS", "65000")) WIKI_MIN_CHARS = int(os.environ.get("WIKI_MIN_CHARS", "600")) # --------------------------------------------------------------------- # Estilos de PERGUNTA (mantidos para follow-ups) # --------------------------------------------------------------------- QUESTION_STYLE_PROMPTS: Dict[str, str] = { "objetiva": ( "Siga em pt-BR. Gere UMA pergunta objetiva e específica sobre o tema regulatório discutido, " "apoiada no CONTEXTO, evitando 'o que é' e perguntas de sim/não. " "Foque em critério, requisito, exceção ou definição normativa. Máx. 1 sentença. Termine com '?'." ), "analitica": ( "Siga em pt-BR. Gere UMA pergunta analítica e comparativa, apoiada no CONTEXTO, " "pedindo contraste entre regras, impactos práticos, trade-offs ou efeitos de alteração/revogação. " "Evite sim/não e perguntas vagas. Máx. 1 sentença. Termine com '?'." ), } _DEFAULT_STYLE_PROBS = {"objetiva": 0.5, "analitica": 0.5} QUESTION_STYLE_KERNELS_PT = { "objetiva": ( "Siga em pt-BR. Gere UMA pergunta objetiva e específica ainda não respondida, " "focada em critério, requisito, exceção ou passo procedimental presente no histórico. " "Evite 'o que é', evite sim/não, não repita perguntas. Máx. 1 sentença; termine com '?'." ), "analitica": ( "Siga em pt-BR. Gere UMA pergunta analítica pedindo contraste entre o ato vigente e anteriores " "(diferenças materiais, impactos, justificativas ou riscos). Evite sim/não e generalidades. " "Máx. 1 sentença; termine com '?'." ), } DEFAULT_QUESTION_KERNEL_PT = QUESTION_STYLE_KERNELS_PT["objetiva"] class DropSample(Exception): """Sinaliza que a amostra/conversa deve ser descartada sem interromper o pipeline.""" pass try: QUESTION_STYLE_PROBS = json.loads(os.environ.get("QUESTION_STYLE_PROBS", "")) or _DEFAULT_STYLE_PROBS except Exception: QUESTION_STYLE_PROBS = _DEFAULT_STYLE_PROBS QUESTION_SAMPLES_PER_ROW = int(os.environ.get("QUESTION_SAMPLES_PER_ROW", "2")) def _sample_question_style(k=2) -> List[str]: keys = list(QUESTION_STYLE_PROMPTS.keys()) weights = [QUESTION_STYLE_PROBS.get(k, 0.0) for k in keys] s = sum(weights) weights = [1.0/len(keys)]*len(keys) if s <= 0 else [w/s for w in weights] return random.choices(keys, weights=weights, k=k) # --------------------------------------------------------------------- # Dois estilos para round-robin das conversas iniciais # --------------------------------------------------------------------- from itertools import cycle TWO_STYLES = [s.strip() for s in os.environ.get("TWO_STYLES", "objetiva,instrucional").split(",") if s.strip()] if len(TWO_STYLES) < 2: TWO_STYLES = ["objetiva", "instrucional"] _STYLE_RR = cycle(TWO_STYLES) # --------------------------------------------------------------------- # Client # --------------------------------------------------------------------- client = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY) # --------------------------------------------------------------------- # Utilidades (sem regex) # --------------------------------------------------------------------- def _normalize_spaces(s: str) -> str: return " ".join((s or "").split()) def _truncate_context(txt: str) -> str: if not isinstance(txt, str): return "" t = _normalize_spaces(txt) if len(t) <= WIKI_MAX_CHARS: return t cut = t.rfind(".", 0, WIKI_MAX_CHARS) if cut == -1 or cut < WIKI_MIN_CHARS: return t[:WIKI_MAX_CHARS] return t[:cut+1] def sample_system_prompt_key(prompts_with_probs: Dict[str, Tuple[str, float]]) -> str: keys = list(prompts_with_probs.keys()) probs = [prompts_with_probs[k][1] for k in keys] s = sum(probs) probs = [1.0/len(keys)]*len(keys) if s <= 0 else [p/s for p in probs] return random.choices(keys, weights=probs, k=1)[0] async def get_model_id() -> str: models = await client.models.list() if not models.data: raise RuntimeError("Nenhum modelo disponível no endpoint vLLM.") return models.data[0].id # --------------------------------------------------------------------- # Chat wrappers # --------------------------------------------------------------------- async def chat_call( messages: List[Dict[str, str]], model_id: str, *, use_magpie_user: bool = False, question_style: Optional[str] = None, followup_context_text: Optional[str] = None, extra_body_override: Optional[dict] = None, ) -> str: if use_magpie_user: kernel = QUESTION_STYLE_KERNELS_PT.get(question_style or "", DEFAULT_QUESTION_KERNEL_PT) sys_msgs = [{"role": "system", "content": kernel}] if followup_context_text: sys_msgs.append({ "role": "system", "content": "Se necessário, use APENAS o CONTEXTO a seguir como base factual; " "não cite literalmente.\n\n=== CONTEXTO ===\n" + followup_context_text }) final_messages = sys_msgs + messages temperature = Q_TEMPERATURE top_p = Q_TOP_P max_tokens = Q_MAX_TOKENS else: final_messages = messages temperature = RESP_TEMPERATURE top_p = RESP_TOP_P max_tokens = RESP_MAX_TOKENS extra_body = { "chat_template_kwargs": {"enable_thinking": False}, "stop": STOP_STRINGS, "stop_token_ids": STOP_TOKEN_IDS, "logits_processors": LOGITS_PROCESSORS, } if extra_body_override: for k, v in extra_body_override.items(): extra_body[k] = v resp = await client.chat.completions.create( model=model_id, messages=final_messages, temperature=temperature, top_p=top_p, max_tokens=max_tokens, extra_body=extra_body, ) return resp.choices[0].message.content or "" async def safe_chat_call(*args, **kwargs) -> Optional[str]: try: return await chat_call(*args, **kwargs) except BadRequestError: try: eb = kwargs.pop("extra_body_override", {}) or {} eb2 = {"chat_template_kwargs": {"enable_thinking": True}} eb2.update(eb) return await chat_call(*args, extra_body_override=eb2, **kwargs) except Exception: pass try: eb = kwargs.pop("extra_body_override", {}) or {} eb2 = dict(eb) eb2.pop("chat_template_kwargs", None) return await chat_call(*args, extra_body_override=eb2, **kwargs) except Exception: return None except Exception: return None # --------------------------------------------------------------------- # Parser de atos regulatórios # --------------------------------------------------------------------- @dataclass class Ato: title: str body: str _ATO_CURRENT_HDR = re.compile(r"Ato\s+normativo\s+em\s+vigor:\s*(.+?)\s*\n", re.IGNORECASE | re.UNICODE) _ATO_PASTS_HDR = re.compile(r"Atos\s+normativos\s+que\s+são\s+alterados\s+pelo\s+ato\s+em\s+vigor:\s*", re.IGNORECASE | re.UNICODE) _ATO_NOME_SPLIT = re.compile(r"\n{1,2}Nome:\s*", re.IGNORECASE | re.UNICODE) def parse_ato_tree(txt: str) -> Tuple[Optional[Ato], List[Ato]]: if not isinstance(txt, str) or not txt.strip(): return None, [] m = _ATO_CURRENT_HDR.search(txt) if not m: return None, [] cur_title = m.group(1).strip() start_body = m.end() pasts_hdr = _ATO_PASTS_HDR.search(txt, start_body) cur_body_end = pasts_hdr.start() if pasts_hdr else len(txt) cur_body = txt[start_body:cur_body_end].strip() current = Ato(title=cur_title, body=cur_body) pasts: List[Ato] = [] if not pasts_hdr: return current, pasts pasts_block = txt[pasts_hdr.end():].strip() if not pasts_block: return current, pasts chunks = _ATO_NOME_SPLIT.split(pasts_block) for ch in chunks: ch = ch.strip() if not ch: continue first_nl = ch.find("\n") if first_nl == -1: title = ch.strip() body = "" else: title = ch[:first_nl].strip() body = ch[first_nl+1:].strip() if title: pasts.append(Ato(title=title, body=body)) return current, pasts # --------------------------------------------------------------------- # Job builder: prompts placeholder # --------------------------------------------------------------------- def _mk_prompt_current(cur: Ato) -> str: return ( f"[Interação: Regulamentação atual]\n" f"Ato vigente: {cur.title}\n" "Objetivo: explicar o ato em vigor com base apenas no CONTEXTO.\n" "Entregáveis:\n" "1) finalidade e base legal citada;\n" "2) principais dispositivos/critérios de aplicação;\n" "3) impactos práticos para os agentes afetados.\n" "Se algo não constar do CONTEXTO, responda: 'Informação não encontrada no contexto fornecido.'" ) def _mk_prompt_span_all(cur: Ato, pasts: List[Ato]) -> str: nomes = "; ".join([cur.title] + [p.title for p in pasts]) return ( f"[Interação: Linha do tempo regulatória]\n" f"Abrangência: {nomes}\n" "Objetivo: integrar o histórico entre o ato vigente e os anteriores usando apenas o CONTEXTO.\n" "Entregáveis:\n" "1) cronologia (quem altera/regulamenta/revoga quem);\n" "2) evolução das regras por tema;\n" "3) pontos de consistência e ruptura e seus efeitos práticos.\n" "Se faltar informação no CONTEXTO, declare: 'Informação não encontrada no contexto fornecido.'" ) def _mk_prompt_pair(cur: Ato, past: Ato) -> str: return ( f"[Interação: Comparação entre atos]\n" f"Vigente: {cur.title}\n" f"Anterior: {past.title}\n" "Objetivo: comparar os atos com base apenas no CONTEXTO.\n" "Entregáveis:\n" "1) o que permanece igual;\n" "2) o que mudou (âmbito, critérios, parâmetros de cálculo, prazos, exceções, obrigações, penalidades);\n" "3) implicações práticas para os agentes.\n" "Conclua com um resumo das diferenças materiais.\n" "Se algo não constar do CONTEXTO, responda: 'Informação não encontrada no contexto fornecido.'" ) def build_reg_jobs(context_text: str) -> List[Tuple[str, str, Dict[str, Any]]]: cur, pasts = parse_ato_tree(context_text) if not cur: return [] jobs: List[Tuple[str, str, Dict[str, Any]]] = [] # current-only jobs.append(( _mk_prompt_current(cur), next(_STYLE_RR), {"prompt_type": "current", "current_title": cur.title} )) # span-all if >=2 pasts if len(pasts) >= 2: jobs.append(( _mk_prompt_span_all(cur, pasts), next(_STYLE_RR), {"prompt_type": "span_all", "current_title": cur.title, "past_titles": [p.title for p in pasts]} )) # pairwise for each past for p in pasts: jobs.append(( _mk_prompt_pair(cur, p), next(_STYLE_RR), {"prompt_type": "pair", "current_title": cur.title, "past_title": p.title} )) return jobs # --------------------------------------------------------------------- # Conversa (apenas user/assistant no output) # --------------------------------------------------------------------- async def generate_one_conversation( model_id: str, system_prompt_key: str, system_prompt_text: str, n_turns: int, context_text: str, initial_user: str, question_style: str, ) -> Dict[str, Any]: conversation: List[Dict[str, str]] = [] base_msgs: List[Dict[str, str]] = [] if INCLUDE_SYSTEM and system_prompt_text: base_msgs.append({"role": "system", "content": system_prompt_text}) if context_text: guard = ( "Use PRIORITARIAMENTE o CONTEXTO a seguir. " "Se faltar informação, responda de forma concisa; se não houver dados suficientes, diga: " "'Informação não encontrada no contexto fornecido.'" ) base_msgs.append({"role": "system", "content": f"{guard}\n\n=== CONTEXTO ===\n{context_text}"}) # Turno 1 conversation.append({"role": "user", "content": initial_user}) first_answer = await safe_chat_call(base_msgs + [{"role": "user", "content": initial_user}], model_id, use_magpie_user=False) conversation.append({"role": "assistant", "content": first_answer}) # Follow-ups remaining = max(0, n_turns - 1) hist_msgs = list(base_msgs) + conversation for _ in range(remaining): next_user = await safe_chat_call(hist_msgs, model_id, use_magpie_user=True, question_style=question_style) conversation.append({"role": "user", "content": next_user}) hist_msgs.append({"role": "user", "content": next_user}) next_assistant = await safe_chat_call(hist_msgs, model_id, use_magpie_user=False) conversation.append({"role": "assistant", "content": next_assistant}) hist_msgs.append({"role": "assistant", "content": next_assistant}) return {"conversation": conversation} # --------------------------------------------------------------------- # Streaming do dataset + helpers # --------------------------------------------------------------------- def _wiki_stream_iter(): from datasets import load_dataset # lazy import return load_dataset(WIKI_DATASET_ID, WIKI_SUBSET, split="train", streaming=True) def _extract_context(record: Dict[str, Any]) -> Optional[Dict[str, Any]]: txt = record.get(WIKI_TEXT_FIELD, "") if not isinstance(txt, str): return None context_text = _truncate_context(txt) if len(context_text) < WIKI_MIN_CHARS: return None title = record.get("title", "") return {"context_text": context_text, "title": title} # --- Execução com limite de concorrência (utilitário genérico; opcional) --- async def _execute_with_concurrency(coros: List[asyncio.Future], metas: List[dict], limit: int): sem = asyncio.Semaphore(limit) async def _runner(idx: int, coro): async with sem: res = await coro return idx, res tasks = [asyncio.create_task(_runner(i, c)) for i, c in enumerate(coros)] try: for done in asyncio.as_completed(tasks): i, res = await done yield res, metas[i] finally: for t in tasks: if not t.done(): t.cancel() # --- Resume helpers --- def _read_resume_state(path: str) -> Tuple[int, int]: if not os.path.exists(path) or os.path.getsize(path) == 0: return 0, -1 next_seq_id = 0 last_ctx_id = -1 with open(path, "r", encoding="utf-8") as fin: for line in fin: try: obj = json.loads(line) except Exception: continue if "seq_id" in obj: next_seq_id = max(next_seq_id, int(obj["seq_id"]) + 1) if "context_id" in obj: last_ctx_id = max(last_ctx_id, int(obj["context_id"])) return next_seq_id, last_ctx_id async def _skip_accepted_contexts(ds_iter, n_to_skip: int) -> int: skipped = 0 if n_to_skip <= 0: return 0 for rec in ds_iter: if _extract_context(rec): skipped += 1 if skipped >= n_to_skip: break return skipped # --------------------------------------------------------------------- # Runner com pipeline produtor→fila→consumidores # --------------------------------------------------------------------- async def run(): os.makedirs(os.path.dirname(OUTPUT_FILE) or ".", exist_ok=True) model_id = await get_model_id() # === RESUME === next_seq_id, last_ctx_id = _read_resume_state(OUTPUT_FILE) seq_id = next_seq_id ds_iter = _wiki_stream_iter() _ = await _skip_accepted_contexts(ds_iter, last_ctx_id + 1) start_ctx = (last_ctx_id + 1) if last_ctx_id >= 0 else 0 global_id = count(start_ctx) total_remaining = max(0, NUM_ROWS - seq_id) total_batches = math.ceil(total_remaining / BATCH_SIZE) if BATCH_SIZE > 0 else 0 # Append with open(OUTPUT_FILE, "a", encoding="utf-8") as fout: pbar = tqdm(total=total_batches, desc="Gerando conversas (Magpie + dataset regulatório)") write_lock = asyncio.Lock() while seq_id < NUM_ROWS: # Contextos por batch: simples e estável max_contexts_este_batch = BATCH_SIZE # Coleta contextos aceitos batch_contexts: List[dict] = [] for rec in ds_iter: context_dict = _extract_context(rec) if context_dict: # opcional: filtrar por presença de "Ato normativo em vigor" cur, _pasts = parse_ato_tree(context_dict["context_text"]) if not cur: continue ctx_id = next(global_id) batch_contexts.append({**context_dict, "ctx_sample_id": ctx_id}) if len(batch_contexts) >= max_contexts_este_batch: break if not batch_contexts: break # fim do stream # Estilo da RESPOSTA por batch key = sample_system_prompt_key(CATEGORIES_SYSTEM_PROMPTS) sys_prompt_text = CATEGORIES_SYSTEM_PROMPTS[key][0] # ===== Pipeline ===== conv_queue: asyncio.Queue = asyncio.Queue(maxsize=QUEUE_MAXSIZE) # PRODUTORES: constroem jobs a partir do contexto qgen_sem = asyncio.Semaphore(MAX_ASYNC_QGEN) async def qgen_runner(cinfo: dict): async with qgen_sem: ctx_text = cinfo["context_text"] ctx_id = cinfo["ctx_sample_id"] jobs = build_reg_jobs(ctx_text) # [(prompt, style)] for prompt, q_style, meta in jobs: await conv_queue.put((ctx_id, ctx_text, prompt, q_style, meta)) producers = [asyncio.create_task(qgen_runner(cinfo)) for cinfo in batch_contexts] # CONSUMIDORES (CHAT) async def chat_worker(worker_id: int): nonlocal seq_id while True: item = await conv_queue.get() if item is None: conv_queue.task_done() break ctx_id, ctx_text, question, q_style, meta = item try: async with write_lock: if seq_id >= NUM_ROWS: return r = await generate_one_conversation( model_id=model_id, system_prompt_key=key, system_prompt_text=sys_prompt_text, n_turns=N_TURNS, context_text=ctx_text, initial_user=question, question_style=q_style, ) async with write_lock: if seq_id < NUM_ROWS: record = { "seq_id": seq_id, "conversation": r["conversation"], "question_style": q_style, # follow-up style "prompt_type": meta.get("prompt_type"), # current | span_all | pair "current_title": meta.get("current_title"), "past_title": meta.get("past_title"), # only for pair "past_titles": meta.get("past_titles"), # only for span_all "context_id": ctx_id, } try: fout.write(json.dumps(record, ensure_ascii=False) + "\n") except Exception: pass seq_id += 1 except DropSample: pass except Exception: pass finally: conv_queue.task_done() consumers = [asyncio.create_task(chat_worker(i)) for i in range(MAX_ASYNC_CHAT)] # Aguarda produtores concluírem e envia sentinelas await asyncio.gather(*producers) for _ in range(MAX_ASYNC_CHAT): await conv_queue.put(None) # Aguarda fila esvaziar e consumidores finalizarem await conv_queue.join() await asyncio.gather(*consumers, return_exceptions=True) pbar.update(1) pbar.close() if __name__ == "__main__": asyncio.run(run())