""" Synthetic conversation generator (vLLM via OpenAI-compatible API). Pipeline summary: 1) Stream dataset records. 2) For each record, use its dataset idx as context_id. 3) For each context_id, generate exactly one conversation per question style in ALL_STYLES. 4) Existing JSONL output is scanned to learn which (context_id, style) pairs already exist, and only missing pairs are generated on reruns. """ import os import json import math import asyncio from typing import Dict, Any, List, Tuple, Optional from openai import AsyncOpenAI from tqdm import tqdm from prompts_cemig import ( RESPONSE_PROMPTS, QUESTION_STYLE_PROMPTS, QGEN_SYSTEM_PROMPT, QGEN_SYSTEM_PROMPT_FIRST, QGEN_SYSTEM_PROMPT_JSON, QGEN_SYSTEM_PROMPT_JSON_FIRST, DEFAULT_QUESTION_KERNEL_PT, ALL_STYLES, ) VLLM_BASE_URL = os.environ.get("VLLM_BASE_URL", "http://10.100.0.111:8021/v1") VLLM_API_KEY = os.environ.get("VLLM_API_KEY", "no-key-needed") GEN_TEMPERATURE = float(os.environ.get("GEN_TEMPERATURE", "0.7")) GEN_TOP_P = float(os.environ.get("GEN_TOP_P", "1.0")) STOP_STRINGS = ["<|im_end|>", "<|end_of_text|>"] STOP_TOKEN_IDS = None 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")) NUM_ROWS = int(os.environ.get("NUM_ROWS", "60000000")) BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "32")) N_TURNS = int(os.environ.get("N_TURNS", "3")) OUTPUT_FILE = os.environ.get("OUTPUT_FILE", "magpie_conversations_cemig_v2_preproc_objetiva.jsonl") INCLUDE_SYSTEM = True LOGITS_PROCESSORS: List[str] = [] MAX_ASYNC_TOTAL = int(os.environ.get("MAX_ASYNC", "24")) CHAT_SHARE = float(os.environ.get("CHAT_SHARE", "0.8")) 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))) # WIKI_DATASET_ID = os.environ.get("WIKI_DATASET_ID", "cemig-ceia/energy_dataset_v1") WIKI_DATASET_ID = os.environ.get("WIKI_DATASET_ID", "cemig-ceia/energy_dataset_preproc_v2") 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", "15000")) WIKI_MIN_CHARS = int(os.environ.get("WIKI_MIN_CHARS", "600")) idx_col_name = os.environ.get("IDX_COL_NAME", "idx") client = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY) def _normalize_spaces(s: str) -> str: """Collapse whitespace.""" return " ".join((s or "").split()) def _truncate_context(txt: str) -> str: """ Limit context size by cutting at a sentence boundary near WIKI_MAX_CHARS when possible. If no good boundary exists, fall back to a hard cut. """ 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 _wiki_stream_iter(): """Return a streaming iterator over the dataset.""" from datasets import load_dataset return load_dataset(WIKI_DATASET_ID, WIKI_SUBSET, split="train", streaming=True) def _get_train_num_examples() -> Optional[int]: """ Get split size from dataset metadata without iterating the dataset. Returns None if the metadata is not available. """ from datasets import load_dataset_builder builder = load_dataset_builder(WIKI_DATASET_ID, WIKI_SUBSET) splits = getattr(builder.info, "splits", None) if not splits or "train" not in splits: raise RuntimeError("Dataset metadata missing train split size (num_examples).") n = getattr(splits["train"], "num_examples", None) if n is None: raise RuntimeError("Dataset train split size (num_examples) is None; cannot size tqdm without scanning.") return int(n) def _extract_context(record: Dict[str, Any]) -> Optional[Dict[str, Any]]: """ Extract and validate the text used as context. Records can be rejected (None) if: - text is missing or not a string - text is too short after normalization and truncation """ 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} def _skip_until_idx(ds_iter, start_idx: int) -> Optional[Dict[str, Any]]: """ Advance a streaming iterator until record[idx_col_name] >= start_idx. Returns the first matching record so the caller can process it; iterators cannot be rewound, so without returning it, that record would be lost. """ if start_idx <= 0: return None for rec in ds_iter: rid = rec.get(idx_col_name) if rid is None: continue try: rid_int = int(rid) except Exception: continue if rid_int >= start_idx: return rec return None def _read_next_seq(path: str) -> int: """ Compute the next seq_id by scanning the output JSONL. seq_id is only a running counter for output rows. Resume logic for content is based on (context_id, question_style), not seq_id. """ if not os.path.exists(path) or os.path.getsize(path) == 0: return 0 next_seq_id = 0 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) return next_seq_id def _build_existing_index(path: str) -> Tuple[int, Dict[int, set]]: """ Scan OUTPUT_FILE and build: - present_by_ctx: context_id -> set(question_style) already written - first_incomplete_ctx: earliest idx that needs work Because idx is assumed sequential 0..n-1: - A gap means the missing context_id has zero styles and must be resumed first. - Otherwise, resume at the first context_id missing at least one style. - If everything up to the last seen id is complete, resume at (last + 1). """ present: Dict[int, set] = {} if not os.path.exists(path) or os.path.getsize(path) == 0: return 0, present with open(path, "r", encoding="utf-8") as fin: for line in fin: try: obj = json.loads(line) except Exception: continue ctx = obj.get("context_id") sty = obj.get("question_style") if ctx is None or sty is None: continue try: ctx = int(ctx) except Exception: continue present.setdefault(ctx, set()).add(sty) if not present: return 0, present expected = 0 for ctx_id in sorted(present.keys()): if ctx_id > expected: return expected, present if len(present[ctx_id]) < len(ALL_STYLES): return ctx_id, present expected = ctx_id + 1 return expected, present async def get_model_id() -> str: """Pick the first model exposed by the vLLM endpoint.""" models = await client.models.list() if not models.data: raise RuntimeError("Nenhum modelo disponível no endpoint vLLM.") return models.data[0].id 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, ) -> str: """ Single entry point for LLM calls. Two modes: - Assistant response mode: send messages as-is. - User mode: generate the next user question using the full history and the same context_text to keep the conversation grounded. """ if use_magpie_user: kernel = QUESTION_STYLE_PROMPTS.get(question_style or "", DEFAULT_QUESTION_KERNEL_PT) system_content = f"{QGEN_SYSTEM_PROMPT}\n\n{kernel}" hist_txt = "\n".join( f"{(m.get('role', '') or '').upper()}: {m.get('content', '')}" for m in messages ) user_text = ( f"CONTEXTO:\n{followup_context_text}\n\n" f"HISTÓRICO:\n{hist_txt}\n\n" "Gere uma nova pergunta que um usuário faria para continuar a conversa." ) final_messages = [ {"role": "system", "content": system_content}, {"role": "user", "content": user_text}, ] temperature, top_p, max_tokens = Q_TEMPERATURE, Q_TOP_P, Q_MAX_TOKENS else: final_messages = messages temperature, top_p, max_tokens = RESP_TEMPERATURE, RESP_TOP_P, RESP_MAX_TOKENS extra_body = { "chat_template_kwargs": {"enable_thinking": False}, "stop": STOP_STRINGS, "stop_token_ids": STOP_TOKEN_IDS, "logits_processors": LOGITS_PROCESSORS, } 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]: """ Swallows exceptions and returns None. This can be used to later identify failed requests and clean them. """ try: return await chat_call(*args, **kwargs) except Exception: return None async def _qgen_single(model_id: str, context_text: str, style: str) -> str: """ Generate one user question for a given style. Used as a fallback when batching fails. """ system_content = f"{QGEN_SYSTEM_PROMPT_FIRST}\n\n{QUESTION_STYLE_PROMPTS[style]}" msg = [ {"role": "system", "content": system_content}, {"role": "user", "content": f"CONTEXTO:\n{context_text}"}, ] r = await client.chat.completions.create( model=model_id, messages=msg, temperature=Q_TEMPERATURE, top_p=Q_TOP_P, max_tokens=Q_MAX_TOKENS, extra_body={"chat_template_kwargs": {"enable_thinking": False}}, ) return (r.choices[0].message.content or "").strip() async def generate_user_questions_pair(model_id: str, context_text: str, styles: List[str]) -> List[str]: """ Generate two questions per context when possible, to reduce LLM calls. - If the two styles are identical: request n=2 completions in a single call. - Otherwise: request a strict JSON object {"q1": "...", "q2": "..."} that carries both questions with different style requirements in one response. - If anything fails fall back to two independent _qgen_single calls. """ s0, s1 = styles[0], styles[1] if s0 == s1: try: system_content = f"{QGEN_SYSTEM_PROMPT_FIRST}\n\n{QUESTION_STYLE_PROMPTS[s0]}" msg = [ {"role": "system", "content": system_content}, {"role": "user", "content": f"CONTEXTO:\n{context_text}"}, ] resp = await client.chat.completions.create( model=model_id, messages=msg, temperature=Q_TEMPERATURE, top_p=Q_TOP_P, max_tokens=Q_MAX_TOKENS, n=2, extra_body={"chat_template_kwargs": {"enable_thinking": False}}, ) outs = [(c.message.content or "").strip() for c in resp.choices] if len(outs) == 2 and all(outs): return outs except Exception: pass try: style_block = ( f"q1_style: {QUESTION_STYLE_PROMPTS[s0]}\n" f"q2_style: {QUESTION_STYLE_PROMPTS[s1]}" ) system_content = f"{QGEN_SYSTEM_PROMPT_JSON_FIRST}\n\n{style_block}" msg = [ {"role": "system", "content": system_content}, {"role": "user", "content": f"CONTEXTO:\n{context_text}"}, ] resp = await client.chat.completions.create( model=model_id, messages=msg, temperature=Q_TEMPERATURE, top_p=Q_TOP_P, max_tokens=Q_MAX_TOKENS * 2, extra_body={"chat_template_kwargs": {"enable_thinking": False}}, ) txt = (resp.choices[0].message.content or "").strip() # Some models wrap JSON in fences; strip them defensively. if txt.startswith("```"): lines = [l for l in txt.split("\n") if not l.strip().startswith("```")] txt = "\n".join(lines).strip() q1 = q2 = None try: obj = json.loads(txt) q1 = (obj.get("q1") or "").strip() q2 = (obj.get("q2") or "").strip() except Exception: parts = [p.strip() for p in txt.split("\n") if p.strip()] if len(parts) >= 2: q1, q2 = parts[0], parts[1] if q1 and q2: return [q1, q2] except Exception: pass q1, q2 = await asyncio.gather( _qgen_single(model_id, context_text, s0), _qgen_single(model_id, context_text, s1), ) return [q1, q2] async def generate_one_conversation( model_id: str, system_prompt_text: str, n_turns: int, context_text: str, initial_user: str, question_style: str, ) -> Dict[str, Any]: """ Generate a multi-turn conversation for a single (context_id, question_style). """ 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}) first_user_content = f"CONTEXTO:\n{context_text}\n\n{initial_user}" if context_text else initial_user conversation.append({"role": "user", "content": initial_user}) first_answer = await safe_chat_call( base_msgs + [{"role": "user", "content": first_user_content}], model_id, use_magpie_user=False, ) conversation.append({"role": "assistant", "content": first_answer}) remaining = max(0, n_turns - 1) hist_msgs = list(base_msgs) + [ {"role": "user", "content": first_user_content}, {"role": "assistant", "content": first_answer}, ] for _ in range(remaining): next_user = await safe_chat_call( hist_msgs, model_id, use_magpie_user=True, question_style=question_style, followup_context_text=context_text, ) 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} async def run(): """ Main loop: generate up to NUM_ROWS output records in JSONL. Concurrency model: - Producers generate initial questions for missing styles and enqueue them. - Consumers generate full conversations from queued items and write JSONL records. - write_lock protects seq_id allocation and file writes. """ os.makedirs(os.path.dirname(OUTPUT_FILE) or ".", exist_ok=True) model_id = await get_model_id() first_incomplete_ctx, present_by_ctx = _build_existing_index(OUTPUT_FILE) seq_id = _read_next_seq(OUTPUT_FILE) ds_iter = iter(_wiki_stream_iter()) pending_rec = _skip_until_idx(ds_iter, first_incomplete_ctx) dataset_n = _get_train_num_examples() total_remaining = max(0, NUM_ROWS - seq_id) remaining_ctx = max(0, dataset_n - first_incomplete_ctx) max_possible_rows = remaining_ctx * len(ALL_STYLES) # Cap tqdm plan to dataset size total_remaining = min(total_remaining, max_possible_rows) contexts_per_batch = max( 1, min(BATCH_SIZE, math.ceil(total_remaining / max(1, len(ALL_STYLES)))), ) total_batches = ( math.ceil(total_remaining / (contexts_per_batch * max(1, len(ALL_STYLES)))) if BATCH_SIZE > 0 else 0 ) with open(OUTPUT_FILE, "a", encoding="utf-8") as fout: pbar = tqdm(total=total_batches, desc="Gerando conversas (Magpie + dataset)") write_lock = asyncio.Lock() while seq_id < NUM_ROWS: batch_contexts: List[dict] = [] while len(batch_contexts) < contexts_per_batch: if pending_rec is not None: rec = pending_rec pending_rec = None else: try: rec = next(ds_iter) except StopIteration: rec = None if rec is None: break rid = rec.get(idx_col_name) if rid is None: continue try: ctx_id = int(rid) except Exception: continue # Skip fully complete contexts to avoid wasted work on reruns. if len(present_by_ctx.get(ctx_id, set())) >= len(ALL_STYLES): continue context_dict = _extract_context(rec) if context_dict: batch_contexts.append({**context_dict, "ctx_sample_id": ctx_id}) if not batch_contexts: break conv_queue: asyncio.Queue = asyncio.Queue(maxsize=QUEUE_MAXSIZE) qgen_sem = asyncio.Semaphore(MAX_ASYNC_QGEN) async def qgen_runner(cinfo: dict): """ Producer for one context. Enqueues work items of shape: (context_id, context_text, initial_question, style) """ async with qgen_sem: ctx_text = cinfo["context_text"] ctx_id = cinfo["ctx_sample_id"] already = present_by_ctx.get(ctx_id, set()) missing = [s for s in ALL_STYLES if s not in already] if not missing: return pairs: List[Tuple[str, Optional[str]]] = [] i = 0 while i < len(missing): if i + 1 < len(missing): pairs.append((missing[i], missing[i + 1])) i += 2 else: pairs.append((missing[i], None)) i += 1 for s0, s1 in pairs: try: if s1 is None: q = await _qgen_single(model_id, ctx_text, s0) await conv_queue.put((ctx_id, ctx_text, q, s0)) else: q1, q2 = await generate_user_questions_pair(model_id, ctx_text, [s0, s1]) await conv_queue.put((ctx_id, ctx_text, q1, s0)) await conv_queue.put((ctx_id, ctx_text, q2, s1)) except Exception: import traceback traceback.print_exc() producers = [asyncio.create_task(qgen_runner(cinfo)) for cinfo in batch_contexts] async def chat_worker(): """ Consumer that turns queued items into JSONL records. None sentinel values are used to stop workers after producers finish. """ 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 = item try: async with write_lock: if seq_id >= NUM_ROWS: return r = await generate_one_conversation( model_id=model_id, system_prompt_text=RESPONSE_PROMPTS[q_style], 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, "context_id": ctx_id, } fout.write(json.dumps(record, ensure_ascii=False) + "\n") fout.flush() present_by_ctx.setdefault(ctx_id, set()).add(q_style) seq_id += 1 except Exception: import traceback traceback.print_exc() finally: conv_queue.task_done() consumers = [asyncio.create_task(chat_worker()) for _ in range(MAX_ASYNC_CHAT)] await asyncio.gather(*producers) for _ in range(MAX_ASYNC_CHAT): await conv_queue.put(None) await conv_queue.join() await asyncio.gather(*consumers, return_exceptions=True) pbar.update(1) pbar.close() if __name__ == "__main__": asyncio.run(run())