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)