temp.py

import os
import re
import time

import pandas as pd
from transformers import AutoTokenizer, BitsAndBytesConfig, Gemma3ForCausalLM
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

SYSTEM = """
    **You are a specialist in proofreading and formatting Markdown documents in Portuguese.**

    **Your task is to:**

    1. **Analyze and Correct Markdown Formatting:**
    * Ensure that headers (`#`, `##`, `###`, etc.) use the correct number of `#` according to the section hierarchy.
    * Adjust ordered (numbered) and unordered lists (with bullets such as `-` or `*`) so that they are consistent in numbering/bullets and indentation.
    * Check fenced code blocks and inline code to ensure the correct use of ``` or `` ``, specifying the language when applicable (e.g. ```python).
    * Correct table formatting so that columns are aligned and vertical bars (`|`) and hyphens (`-`) are positioned correctly. * Eliminate unnecessary blank spaces at the end of lines and remove excessive duplicate blank lines (keep at most one blank line between paragraphs or elements).

    2. **Review and Correct Spelling and Grammar (in Portuguese):**
    * Detect and correct spelling errors in the Portuguese language.
    * Adjust accentuation, verb and noun agreement.
    * If you identify repeated words or words used out of context, apply more appropriate synonyms, always preserving the original meaning.

    3. **Preserve the Original Content and Structure:**
    * Strictly maintain the same order of sections, paragraphs, lists, tables and code examples from the original document.
    * Do not add or remove information or sections. The goal is to correct the form, not to substantially change the content.

    4. **Return the Corrected Document:**
    * Your response should contain **ONLY** the complete revised text, correctly formatted in Markdown.

    **Important Final Instructions:**
    * The input document will be in **Portuguese**.
    * The output document must be in **Portuguese**.
    * **DO NOT include ANY text before or after the revised Markdown.** Your response must begin directly with the first line of the revised Markdown document and end with the last line, without any greetings, explanations, or additional comments.

    """


def remove_duplicate_titles(md: str) -> str:
    """
    Remove títulos repetidos de um texto em Markdown,
    considerando tanto o nível (nº de #) quanto o texto.
    """
    seen = set()
    out_lines = []
    for line in md.splitlines():
        m = re.match(r'^(#{1,6})\s*(.+)', line)
        if m:
            nivel, texto = m.groups()
            chave = (nivel, texto.strip())
            if chave in seen:
                # título repetido → pula a linha
                continue
            seen.add(chave)
        out_lines.append(line)
    return '\n'.join(out_lines)


def improve_text(input_text, tokenizer, model):
    prompt = f"""
        Now, please process the following Markdown document:
        {input_text}
        """

    messages = [
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": prompt}
    ]

    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True,
    )
    model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

    with torch.inference_mode():
        generated_ids = model.generate(
            **model_inputs,
            max_new_tokens=2000,
            # temperature=0.0,
            do_sample=False,
            use_cache=True,
            # num_beams=1,
        )
        generated_ids = [
            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
        ]

    return tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]


if __name__ == '__main__':
    # tokenizer = AutoTokenizer.from_pretrained("google/gemma-7b")
    # model = AutoModelForCausalLM.from_pretrained("google/gemma-7b", device_map="auto", revision="float16")
    #
    # SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

    text = """
    # Super carros
Carros esportivos são sinônimo de # paixão, velocidade e 
design arrojado. **Desde o surgimento dos primeiros automóveis de corrida no início do século XX até os modelos futuristas atuais, esses veículos conquistaram entusiastas em todo o mundo. A essência dos carros esportivos está na combinação de performance, agilidade e estética, características que transcendem o simples transporte para oferecer uma experiência única ao volante.



ist oricamente, os primeiros carros sportivos surgiram a partir de adaptações de veículos de corrida para uso nas estradas comuns. Marcas pioneiras como Mercedes-Benz e Bugatti, ainda em meados dos anos 1920, já desenvolviam modelos destinados a entusiastas que buscavam desempenho em circuitos e em vias públicas. No pós-guerra, fabricantes como Jaguar, Aston Martin e Ferrari consolidaram a reputação dos esportivos, criando ícones como o Jaguar XK120, o Aston Martin DB5 e a Ferrari 250 GTO.

O coração de um carro esportivo w, sem dúvida, seu motor. Geralmente, utiliza-se propulsores potentes, com elevado número de cilindros e tecnologias avançadas de turboalimentação ou superalimentação. Esses motores geram alta potência e torque, permitindo acelerações impressionantes e velocidades de ponta que frequentemente ultrapassam os 300 km/h em modelos de elite. Contudo, a entrega de potência deve ser acompanhada de sistemas de suspensão e freios capazes de garantir segurança e estabilidade em curvas mais desafiadoras.

O design aerodinâmico é outro ponto fundamental. Linhas fluídas, para-brisas inclinados e spoilers são projetados para reduzir o arrasto e manter o carro firmemente colado ao solo. Além disso, o uso de materiais leves, como fibra de carbono e ligas de alumínio, contribui para reduzir o peso total do veículo, melhorando a relação peso‑potência e a dinâmica de condução.

A experiência de dirigir um carro esportivo é incomparável. Ao pressionar o acelerador, o motorista sente a resposta imediata do veículo, com rotações do motor subindo rapidamente até a zona vermelha do conta‑giros. O ronco inconfundível do escapamento, muitas vezes calibrado para proporcionar notas graves e agudas, torna‑se trilha sonora de cada arrancada. Essa conexão intensa entre homem e máquina faz parte do fascínio pelos esportivos.

Apesar de seu apelo, carros esportivos enfrentam desafios em termos de consumo de combustível, emissões de poluentes e custo de manutenção elevado. A busca por soluções mais sustentáveis levou ao desenvolvimento de esportivos híbridos e totalmente elétricos. Exemplos como o Porsche Taycan e o Ferrari SF90 Stradale demonstram que é possível aliar desempenho exuberante à eficiência energética, reduzindo drasticamente as emissões sem abrir mão da performance.

Tecnologias de assistência ao ## condutor, como controle de cruzeiro adaptativo e frenagem de emergência, são incorporadas aos esportivos de alta performance. Conectividade e personalização de softwares permitem ajustar mapas de injeção, suspensões e modos de condução, também ampliando a versatilidade desses veículos.

Em resumo, caros eportivos **representam o ápice da engenharia automotiva, unindo tecnologia, design e emoção. Seja em modelos clássicos que marcaram épocas ou em supermáquinas modernas movidas a eletricidade, esses veículos continuam a inspirar gerações, provando que a busca pela velocidade e pela perfeição mecânica é uma das mais antigas e duradouras paixões humanas.
    """

    # result = improve_text(input_text, tokenizer, model)
    # print(result)

    #

    model_name = "mistralai/Mistral-7B-Instruct-v0.3"  # "Qwen/Qwen2.5-1.5B-Instruct"

    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True
    )

    # Carregamento quantizado e com atenção eficiente
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=bnb_config,
        device_map="auto",
        attn_implementation="flash_attention_2",
    )

    tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)
    model.generation_config.pad_token_id = tokenizer.eos_token_id

    model = torch.compile(model, mode="max-autotune")

    SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

    # Constrói o caminho do arquivo Parquet baseado nesse diretório
    words = 0
    categories = set()
    pr = 0
    for index in range(28):
        parquet_file = os.path.join(SCRIPT_DIR, 'temp', f'batch_{index + 1}.parquet')  #

        print("Tentando abrir:", parquet_file)

        df = pd.read_parquet(parquet_file)

        for index, row in df.iterrows():
            start = time.perf_counter()
            result = improve_text(row['text'], tokenizer, model)
            end = time.perf_counter()
            print(f"Tempo de execução: {end - start:.6f} segundos")
            print(row['word_count'])
            # print(result)
            print("#" * 50)

    print("Total de palavras: ", words)
    print(pr)
    print(categories)