synthgen/evaluate_v4.py

import os
import json
import asyncio
from typing import Dict, Any, List, Optional, Tuple
from openai import AsyncOpenAI, BadRequestError
from tqdm import tqdm

# Evaluation instructions
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:"

# - 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

GUIDELINES = """
Regras para considerar na avaliação:
- A conversa é um usuário pedindo um resumo de um texto de cunho juridico.
- 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
- O resumo deve conter todas as partes importantes do texto. Se ele faltar alguma informação critica, a qualidade caí.
"""

# Config vLLM - using same as summary.py
VLLM_BASE_URL = os.environ.get("VLLM_BASE_URL", "http://10.100.0.111:8026/v1")
VLLM_API_KEY = os.environ.get("VLLM_API_KEY", "no-key-needed")

# Decoding parameters - using summary.py's working values
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.0"))
TOP_P = float(os.environ.get("TOP_P", "0.9"))
MAX_TOKENS = int(os.environ.get("MAX_TOKENS", "8192"))
STOP_STRINGS = ["<|im_end|>", "<|end_of_text|>"]
STOP_TOKEN_IDS = None
LOGITS_PROCESSORS: List[str] = []

# Execution control
NUM_TURNS = int(os.environ.get("NUM_TURNS", "1"))
BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "4"))

client = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY)

# Combined prompt template (no separate system prompt)
EVALUATION_PROMPT_TEMPLATE = """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:

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 de forma satisfatoria e todas as dúvidas foram sanadas
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"
}}

Query do Usuário (primeiros {n} turns):
{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

    # primeiro turno do user
    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

# Using summary.py's working chat_call pattern
async def chat_call(
    messages: List[Dict[str, str]],
    model_id: str,
    *,
    extra_body_override: Optional[dict] = None,
) -> str:
    temperature = TEMPERATURE
    top_p = TOP_P
    max_tokens = 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=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 as e:
        tqdm.write(f"BadRequestError: {str(e)}")
        try:
            eb = kwargs.pop("extra_body_override", {}) or {}
            eb2 = dict(eb)
            eb2.pop("chat_template_kwargs", None)
            tqdm.write(f"Retrying without chat_template_kwargs...")
            result = await chat_call(*args, extra_body_override=eb2, **kwargs)
            tqdm.write(f"Success without chat_template_kwargs")
            return result
        except Exception as e2:
            tqdm.write(f"Failed without chat_template_kwargs: {type(e2).__name__}: {str(e2)}")
            return None
    except Exception as e:
        tqdm.write(f"Unexpected error: {type(e).__name__}: {str(e)}")
        return None

async def evaluate_query(query_block: str, model_id: str) -> Dict[str, Any]:
    # Everything in user message, no system prompt
    user_content = EVALUATION_PROMPT_TEMPLATE.format(n=NUM_TURNS, input=query_block)
    
    messages = [
        {"role": "user", "content": user_content}
    ]
    
    raw = await safe_chat_call(messages, model_id)
    
    if not raw:
        return {"explicacao": "Resposta vazia do modelo", "qualidade": "muito ruim"}

    raw = raw.strip()
    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]
        # prepara dados brutos ignorando já processados
        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))

        # checkpoint do batch
        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(
        "./cemig_cleaned/magpie_conversations_cemig_v1_objetiva.jsonl",
        "./cemig_filtered/magpie_conversations_cemig_v1_objetiva.jsonl",
    )

if __name__ == "__main__":
    asyncio.run(main())