| import os |
| import json |
| import asyncio |
| from typing import Dict, Any, List, Optional, Tuple |
| 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:" |
| |
|
|
| 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.getenv("VLLM_BASE_URL", "http://10.100.0.111:8020/v1") |
| VLLM_API_KEY = os.getenv("VLLM_API_KEY", "no-key-needed") |
| TEMPERATURE = float(os.getenv("TEMPERATURE", "0.0")) |
| TOP_P = float(os.getenv("TOP_P", "1.0")) |
| MAX_TOKENS = int(os.getenv("MAX_TOKENS", "1024")) |
| BATCH_SIZE = int(os.getenv("BATCH_SIZE", "4")) |
| NUM_TURNS = int(os.getenv("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": "<string>", |
| "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: Any) -> Optional[str]: |
| if isinstance(role, str): |
| 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 = next( |
| (i for i, t in enumerate(conversation) if _normalize_role(t.get("role")) == "user"), |
| None, |
| ) |
| if start_idx is None: |
| return None |
|
|
| lines: List[str] = [] |
| collected = 0 |
| for turn in conversation[start_idx:]: |
| role = _normalize_role(turn.get("role")) |
| if not role: |
| continue |
| lines.append(f"{role}: { _to_str(turn.get('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 or "").strip() |
| if not raw: |
| return {"explicacao": "Resposta vazia do modelo", "qualidade": "muito ruim"} |
|
|
| try: |
| return json.loads(raw) |
| except json.JSONDecodeError: |
| start, end = raw.find("{"), raw.rfind("}") |
| if start != -1 and end != -1 and end > start: |
| try: |
| return json.loads(raw[start:end+1]) |
| except json.JSONDecodeError: |
| pass |
| return {"explicacao": raw, "qualidade": "invalida"} |
|
|
| async def evaluate_conversation_quality(block: Optional[str], model_id: str) -> Dict[str, Any]: |
| 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"), |
| } |
|
|
| def _load_processed_ids(output_file: str) -> set: |
| 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) |
| seq = rec.get("seq_id") |
| if seq is not None: |
| ids.add(seq) |
| except json.JSONDecodeError: |
| continue |
| return ids |
|
|
| async def process_jsonl_file(input_file: str, output_file: Optional[str] = None): |
| """Adiciona avaliações às conversas do arquivo JSONL, com checkpoint por seq_id.""" |
| if output_file is None: |
| output_file = input_file |
|
|
| processed_ids = _load_processed_ids(output_file) |
|
|
| with open(input_file, "r", encoding="utf-8") as f: |
| lines = [ln.strip() for ln in f if ln.strip()] |
|
|
| 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: List[Tuple[int, Dict[str, Any]]] = [] |
| for j, line in enumerate(batch_lines): |
| try: |
| data = json.loads(line) |
| except json.JSONDecodeError as e: |
| tqdm.write(f"Error parsing line {i+j+1}: {e}") |
| continue |
| seq_id = data.get("seq_id") |
| if seq_id in processed_ids: |
| continue |
| batch_data.append((i + j, data)) |
|
|
| if not batch_data: |
| pbar.update(1) |
| continue |
|
|
| processed_lines: List[str] = [] |
| sem = asyncio.Semaphore(BATCH_SIZE) |
|
|
| async def worker(line_idx: int, data: Dict[str, Any]): |
| async with sem: |
| try: |
| block = build_eval_input(data.get("conversation", []), NUM_TURNS) |
| result = await evaluate_conversation_quality(block, model_id) |
| data["explicacao_qualidade"] = result["explicacao_qualidade"] |
| data["qualidade"] = result["qualidade"] |
| processed_lines.append(json.dumps(data, ensure_ascii=False)) |
| seq = data.get("seq_id") |
| if seq is not None: |
| processed_ids.add(seq) |
| except Exception as e: |
| tqdm.write(f"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)) |
|
|
| await asyncio.gather(*(worker(idx, d) for idx, d in batch_data)) |
|
|
| |
| with open(output_file, "a", encoding="utf-8") as f: |
| for line in processed_lines: |
| f.write(line + "\n") |
|
|
| 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()) |
|
|
