synthgen/legacy_scripts/evaluate.py

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": "<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: 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())