import os import json import asyncio from typing import Dict, Any, List, Optional from openai import AsyncOpenAI from pydantic import BaseModel from tqdm import tqdm INICIAL_INSTRUCTION = "Você é um avaliador da qualidade de queries de usuários sobre leis da ANEEL. Avalie a conversa com base em sua clareza, especificidade e coerência. Também considere as seguintes regras:" # INICIAL_INSTRUCTION = "Você é um avaliador da qualidade de queries de usuários. Avalie APENAS a primeira query do usuário com base em sua clareza, especificidade e coerência." GUIDELINES = """ Regras para considerar na avaliação: - Se o assistant em algum momento fala "de acordo com o contexto", "com base no texto fornecido" ou algo do tipo, a qualidade da conversa é muito ruim - Se o user começa a repetir textos do assistente sem progredir a conversa ou fazer uma nova pergunta para o assistente, a qualidade da conversa é muito ruim. - Não necessariamente uma pergunta e resposta pequena é ruim. Não tem problema dado que está respondendo a pergunta """ 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") TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.0")) TOP_P = float(os.environ.get("TOP_P", "1.0")) MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "1024")) BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "4")) QUEUE_MAXSIZE = int(os.environ.get("QUEUE_MAXSIZE", "256")) NUM_TURNS = int(os.environ.get("NUM_TURNS", "3")) client = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY) class EvalSchema(BaseModel): explicacao: str qualidade: str OUTPUT_SCHEMA = EvalSchema.model_json_schema() SYSTEM_PROMPT = f""" {INICIAL_INSTRUCTION} {GUIDELINES} Escala de avaliação: - muito ruim: A query é obscura, vaga ou incoerente. Faltam informações e contexto essenciais. - ruim: A query é um tanto obscura ou carece de detalhes importantes. Requer esclarecimentos significativos. - média: A query é moderadamente clara e específica. Pode exigir algumas informações adicionais para uma compreensão completa. - boa: A query é clara, específica e, na maior parte, bem formulada. Fornece contexto suficiente para entender a intenção do usuário. - excelente: A query é muito clara, específica e bem articulada. Contém todas as informações e contexto necessários para fornecer uma resposta abrangente. Formato de saída OBRIGATÓRIO (JSON estrito, sem texto extra, sem crases): {{ "explicacao": "", "qualidade": "muito ruim" | "ruim" | "média" | "boa" | "excelente" }} """.strip() USER_PROMPT = "Query do Usuário (primeiros {n} turns):\n{input}" 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 def _normalize_role(role: str) -> Optional[str]: if role is None: return None r = role.lower() if r in ("user", "assistant"): return r return None def _to_str(x: Any) -> str: if isinstance(x, str): return x return json.dumps(x, ensure_ascii=False) if x is not None else "" def build_eval_input(conversation: List[Dict[str, Any]], num_turns: int) -> Optional[str]: if not conversation or num_turns <= 0: return None start_idx = None for idx, turn in enumerate(conversation): if _normalize_role(turn.get("role")) == "user": start_idx = idx break if start_idx is None: return None lines = [] collected = 0 for turn in conversation[start_idx:]: role = _normalize_role(turn.get("role")) if role is None: continue content = _to_str(turn.get("content", "")) lines.append(f"{role}: {content}") collected += 1 if collected >= num_turns: break return "\n".join(lines) if lines else None async def evaluate_query(query_block: str, model_id: str) -> Dict[str, Any]: messages = [ {"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": USER_PROMPT.format(n=NUM_TURNS, input=query_block)}, ] resp = await client.chat.completions.create( model=model_id, messages=messages, temperature=TEMPERATURE, top_p=TOP_P, max_tokens=MAX_TOKENS, ) raw = resp.choices[0].message.content try: return json.loads(raw) except json.JSONDecodeError: start, end = raw.find("{"), raw.rfind("}") if start != -1 and end != -1: return json.loads(raw[start:end+1]) return {"explicacao": raw, "qualidade": "invalida"} async def evaluate_conversation_quality(conversation: List[Dict[str, Any]], model_id: str) -> Dict[str, Any]: block = build_eval_input(conversation, NUM_TURNS) if not block: return {"explicacao_qualidade": "Nenhuma query de usuário encontrada", "qualidade": "muito ruim"} result = await evaluate_query(block, model_id) return { "explicacao_qualidade": result.get("explicacao", ""), "qualidade": result.get("qualidade", "invalida"), } async def process_jsonl_file(input_file: str, output_file: str = None): """Adiciona avaliações às conversas do arquivo JSONL, com checkpoint por seq_id.""" if output_file is None: output_file = input_file # ✅ 1. Load already processed seq_ids (for resume) processed_ids = set() if os.path.exists(output_file): with open(output_file, 'r', encoding='utf-8') as f: for line in f: try: rec = json.loads(line) if "seq_id" in rec: processed_ids.add(rec["seq_id"]) except json.JSONDecodeError: continue print(f"Found {len(processed_ids)} already processed entries. Resuming...") with open(input_file, 'r', encoding='utf-8') as f: lines = f.readlines() processed_lines = [] model_id = await get_model_id() print(f"Starting process (NUM_TURNS={NUM_TURNS})") total_batches = (len(lines) + BATCH_SIZE - 1) // BATCH_SIZE pbar = tqdm(total=total_batches, desc="Processing conversations") for i in range(0, len(lines), BATCH_SIZE): batch_lines = lines[i:i + BATCH_SIZE] batch_data = [] # ✅ 2. Skip already processed seq_ids for j, line in enumerate(batch_lines): line = line.strip() if not line: continue try: data = json.loads(line) seq_id = data.get("seq_id") if seq_id in processed_ids: continue batch_data.append((i + j, data)) except json.JSONDecodeError as e: tqdm.write(f"Error parsing line {i+j+1}: {e}") continue if not batch_data: pbar.update(1) continue conv_queue: asyncio.Queue = asyncio.Queue(maxsize=QUEUE_MAXSIZE) async def producer(): for line_idx, data in batch_data: conversation = data.get("conversation", []) block = build_eval_input(conversation, NUM_TURNS) if block: await conv_queue.put((line_idx, data, block)) else: data["explicacao_qualidade"] = "Nenhuma query de usuário encontrada" data["qualidade"] = "muito ruim" processed_lines.append(json.dumps(data, ensure_ascii=False)) for _ in range(BATCH_SIZE): await conv_queue.put(None) async def consumer(worker_id: int): while True: item = await conv_queue.get() if item is None: conv_queue.task_done() break line_idx, data, block = item try: result = await evaluate_conversation_quality(data.get("conversation", []), model_id) data["explicacao_qualidade"] = result["explicacao_qualidade"] data["qualidade"] = result["qualidade"] processed_lines.append(json.dumps(data, ensure_ascii=False)) processed_ids.add(data.get("seq_id")) except Exception as e: tqdm.write(f"Worker {worker_id}: Error processing line {line_idx+1}: {e}") data["explicacao_qualidade"] = "Erro na avaliação" data["qualidade"] = "muito ruim" processed_lines.append(json.dumps(data, ensure_ascii=False)) finally: conv_queue.task_done() # run batch producer_task = asyncio.create_task(producer()) consumer_tasks = [asyncio.create_task(consumer(i)) for i in range(BATCH_SIZE)] await asyncio.gather(producer_task, *consumer_tasks) # ✅ 3. Save results after each batch (checkpoint) with open(output_file, 'a', encoding='utf-8') as f: for line in processed_lines: f.write(line + '\n') processed_lines.clear() pbar.update(1) pbar.close() print(f"Processing complete. Updated file: {output_file}") async def main(): await process_jsonl_file("./magpie_conversations_cemig_cleaned.jsonl", "./magpie_conversations_cemig_cleaned_evaled.jsonl") if __name__ == "__main__": asyncio.run(main())