Traducere documente Word cu AI, fără să-ți strici formatarea

Traducere documente Word cu AI, cu formatarea păstrată, înseamnă să lucrezi pe structura fișierului. Extragi fiecare paragraf, celulă de tabel, casetă de text și formă din slide, cu poziția ei, traduci textul pe bucăți, cu context și glosar, apoi scrii fiecare rezultat înapoi în aceleași run-uri, adică fragmentele de text cu aceeași formatare, ca îngroșarea, cursivele, fonturile și culorile să rămână. PDF-urile sunt mai grele: cer extragere de text, sau OCR pentru scanări, și ajung de obicei un document reconstruit.

De ce strică formatarea copy-paste în chatbot?

O fereastră de chat lucrează cu text simplu și Markdown. Un fișier Word stochează paragrafe, run-uri, stiluri, tabele, antete, subsoluri, casete de text și câmpuri. Lipirea aplatizează tot. Tabelele își pierd grila, casetele de text și antetele sunt sărite dacă nu le lipești separat, iar răspunsul lipit înapoi vine cu stiluri noi. Fișierele lungi depășesc fereastra de context a modelului, așa că le tai de mână, iar fiecare bucată își pierde vecinii, motiv pentru care un termen ajunge tradus în trei feluri. Nimic nu numerotează segmentele, deci o propoziție sărită sau comasată trece neobservată. Iar tot documentul ajunge la un serviciu terț.

Cum stochează textul un fișier Word sau PowerPoint?

Documentația python-docx descrie modelul. Un paragraf conține unul sau mai multe run-uri, fiecare cu o parte din textul paragrafului, iar formatarea caracterelor, precum fontul, dimensiunea, îngroșarea, cursiva și sublinierea, se aplică la nivel de run. O propoziție cu un singur cuvânt îngroșat înseamnă deci trei run-uri. Run-urile se pot rupe și în mijlocul unui cuvânt după editări, așa că le unești înainte de traducere. Celulele de tabel au propriile paragrafe. Antetele și subsolurile aparțin fiecărei secțiuni. Casetele de text își țin paragrafele în elemente w:txbxContent, pe care referința Open XML de la Microsoft le numește container de conținut pentru casetă de text formatat.

PowerPoint urmează același tipar. În python-pptx lanțul este formă, cadru de text, paragrafe, run-uri. Formele automate și celulele de tabel pot conține text, celelalte forme nu, iar formatarea caracterelor stă pe font-ul run-ului. Formele grupate conțin forme-copil, deci un traducător trebuie să intre recursiv în ele.

Cum ar trebui să funcționeze traducerea AI a documentelor?

1. Extrage segmentele. Parcurge fișierul și notează fiecare paragraf, celulă, casetă de text și formă cu un ID și o locație, de exemplu slide 4, forma 7, paragraful 2.
2. Unește run-urile. Alătură run-urile unui paragraf într-o singură unitate de traducere și păstrează un marcaj oriunde se schimbă formatarea.
3. Adaugă context. Trimite fiecare bucată cu segmentele vecine, titlul documentului și un glosar, dimensionate să încapă în fereastra de context a modelului.
4. Cere structură. Cere rezultat indexat după ID-ul segmentului, de pildă un obiect JSON, și respinge orice altceva.
5. Validează. Verifică dacă s-a întors fiecare ID, dacă numerele, datele și substituenții se potrivesc cu sursa și dacă niciun segment nu e gol.
6. Scrie înapoi. Pune fiecare paragraf tradus în run-urile lui originale.
7. Corectează. Opțional, rulează o a doua trecere cu alt prompt sau alt model.
8. Verifică așezarea în pagină. Textul tradus e adesea mai lung sau mai scurt decât sursa, deci caută depășiri în slide-uri, celule de tabel și antete.

Pasul 6 are trei strategii posibile pentru un paragraf cu formatare mixtă. Dacă pui tot textul în primul run, e simplu și pierzi accentele din interiorul paragrafului. Dacă înconjori fiecare run cu o etichetă numerotată, ceri modelului să păstreze etichetele și împarți răspunsul înapoi pe run-uri, păstrezi accentele, iar prima strategie poate servi drept rezervă când etichetele lipsesc. Împărțirea după numărul de caractere e fragilă, pentru că ordinea cuvintelor și lungimea se schimbă între limbi, așa că evită-o.

Cum arată înlocuirea la nivel de run în python-docx?

Un fapt din documentația python-docx dictează designul. Atribuirea către Paragraph.text înlocuiește tot conținutul cu un singur run și elimină formatarea de la nivel de run. Atribuirea către Run.text păstrează formatarea run-ului. Schița de mai jos folosește a doua formă, cu strategia etichetelor și rezerva pe primul run. Funcția translate este a ta, deci apelează din ea un model local sau un API.

import re
from docx import Document

TAG = re.compile(r"<r(\d+)>(.*?)</r\1>", re.S)

def translate_paragraph(par, translate):
    runs = [r for r in par.runs if r.text]
    if not runs:
        return
    tagged = "".join(f"<r{i}>{r.text}</r{i}>" for i, r in enumerate(runs))
    out = translate(tagged)                  # apelul tău către model; trebuie să păstreze etichetele
    parts = dict(TAG.findall(out))
    if len(parts) == len(runs):              # s-au întors toate run-urile
        for i, run in enumerate(runs):
            run.text = parts[str(i)]         # Run.text păstrează îngroșarea, cursiva, fontul, culoarea
    else:                                    # etichete pierdute: revenim la primul run
        runs[0].text = re.sub(r"</?r\d+>", "", out)
        for run in runs[1:]:
            run.text = ""

def translate_table(table, translate):
    seen = set()
    for row in table.rows:
        for cell in row.cells:
            if cell._tc in seen:             # celulele îmbinate se repetă în row.cells
                continue
            seen.add(cell._tc)
            for par in cell.paragraphs:
                translate_paragraph(par, translate)
            for nested in cell.tables:
                translate_table(nested, translate)

def header_footer_paragraphs(section):
    for part in (section.header, section.first_page_header, section.even_page_header,
                 section.footer, section.first_page_footer, section.even_page_footer):
        if not part.is_linked_to_previous:   # părțile legate aparțin unei secțiuni anterioare
            yield from part.paragraphs

def translate_document(src, dst, translate):
    doc = Document(src)
    for par in doc.paragraphs:
        translate_paragraph(par, translate)
    for table in doc.tables:
        translate_table(table, translate)
    for section in doc.sections:
        for par in header_footer_paragraphs(section):
            translate_paragraph(par, translate)
    doc.save(dst)

Trei detalii vin din testarea pe un fișier de probă. O celulă îmbinată apare în row.cells o dată pentru fiecare coloană de grilă pe care o acoperă, deci mulțimea seen o oprește să fie tradusă de două ori. Un antet legat de secțiunea anterioară întoarce paragrafele acelei secțiuni, lucru pe care verificarea is_linked_to_previous îl evită. Iar python-docx nu oferă un obiect de nivel înalt pentru casete de text, deci paragrafele din w:txbxContent cer o căutare proprie în XML.

Pentru o prezentare, bucla își schimbă forma, dar logica de run rămâne aceeași. Funcția de mai jos parcurge formele cu text, celulele de tabel și formele grupate.

from pptx import Presentation

def walk(shapes):
    for shape in shapes:
        if shape.has_text_frame:
            yield from shape.text_frame.paragraphs
        if shape.has_table:
            for row in shape.table.rows:
                for cell in row.cells:
                    yield from cell.text_frame.paragraphs
        if shape.shape_type == 6:            # formă grupată: intrăm recursiv în copiii ei
            yield from walk(shape.shapes)

for slide in Presentation("deck.pptx").slides:
    for par in walk(slide.shapes):
        ...                                  # aceeași logică de run ca la Word

Cum faci traducere PDF cu AI?

Un PDF stochează fragmente de text poziționate. Nu are paragrafe, run-uri sau structură de tabel în care să scrii înapoi. PyMuPDF poate extrage textul simplu, ca blocuri sau cuvinte cu informații de poziție ori ca dicționar detaliat de linii și spans, așa că poți regăsi unde stătea fiecare bucată. Apoi ai patru căi.

• Tradu sursa. Dacă mai ai fișierul Word sau PowerPoint, tradu-l pe acela și exportă un PDF nou. Dă cea mai bună așezare în pagină, la mare distanță.
• Convertește, tradu, exportă. Convertește PDF-ul în DOCX, tradu-l ca mai sus și exportă din nou. Calitatea depinde de convertor, deci verifică întâi tabelele.
• Reconstruiește pe blocuri. Extrage blocuri de text cu coordonate, tradu-le și pune rezultatele în aceleași casete pe o pagină nouă. Ai nevoie de reguli pentru textul care nu mai încape, cum ar fi un font mai mic.
• Scanări. O pagină scanată nu are strat de text, deci rulezi mai întâi OCR. OCRmyPDF adaugă un strat de text în PDF-urile scanate folosind Tesseract. Corectează rezultatul OCR înainte de traducere, pentru că greșelile din nume și cifre trec direct în traducere.

Fixează așteptările pentru orice lucrare cu PDF. Rezultatul este de obicei o așezare reconstruită și simplificată, nu o copie identică pixel cu pixel.

Model local sau din cloud pentru documente confidențiale?

Termenii contează. Termenii API-ului Gemini spun că ce trimiți către Unpaid Services poate fi folosit pentru îmbunătățirea produselor Google și citit de evaluatori umani și îți cer să nu trimiți acolo informații sensibile, confidențiale sau personale. Pentru Paid Services, Google afirmă că nu folosește prompturile sau răspunsurile pentru a-și îmbunătăți produsele. Alți furnizori diferă, așa că citește termenii de date ai celui ales, iar dacă documentele conțin date personale, verifică și obligațiile tale legale.

Funcționează bine o variantă hibridă, cu modele locale pentru fișierele sensibile și modele din cloud pentru restul. Poți înlocui numele și identificatorii cu substituenți înainte de trimitere și îi poți readuce după. Traducerea în cloud a fișierelor lungi consumă multe tokenuri, așa că ideile de grupare și cache din cum am redus costurile LLM cu 99% se aplică și aici.

Cum îmbunătățesc glosarele și corectura calitatea?

• Glosar. Ține o listă de termeni sursă și traducerile lor aprobate, adaugă-o în promptul fiecărei bucăți, apoi verifică dacă fiecare termen sursă dintr-un segment apare cu echivalentul aprobat. Adaugă o listă de nume care nu se traduc, pentru mărci și produse.
• Consecvență. Păstrează traducerile în cache după textul sursă exact, ca o propoziție repetată să fie tradusă o singură dată și să sune la fel peste tot.
• Registru. Spune care e publicul și dacă tonul e formal sau informal. Româna, de exemplu, are forme de adresare formale și informale pe care modelele le pot amesteca.
• Trecere de corectură. Trimite traducerea unui al doilea prompt sau model care întoarce doar corecturi după ID-ul segmentului. Cere-i să caute fragmente netraduse, greșeli de gramatică, formate de numere și date și etichete rupte.
• Revizuire umană. Pentru contracte, texte medicale sau juridice, tratează rezultatul drept ciornă pe care o aprobă o persoană calificată.

Ce construiește AI Translator Pro?

AI Translator Pro este o aplicație desktop Danube Labs aflată în dezvoltare. Are cod închis și nu a fost lansată, deci rândurile de față descriu ce este construită să facă. Traduce fișiere DOCX, PPTX, PDF și TXT cu modele locale (llama.cpp sau Transformers) sau cu API-uri din cloud (Gemini, OpenRouter), alese pentru fiecare sarcină. Extrage paragrafe, celule de tabel, casete de text și forme din slide-uri, le traduce pe bucăți și le reconstruiește cu îngroșarea, cursivele, culorile și fonturile lor. O a doua trecere opțională folosește un model de corectură. OCR cu EasyOCR și OpenCV acoperă imaginile, clipboard-ul și paginile PDF scanate. Un editor de text formatat cu copiere în Word păstrează formatarea, iar modul batch, pauza și oprirea ajută la sarcinile lungi.

Ai nevoie de traducere de documente construită pe fișierele tale?

Dacă ai nevoie de traducere de documente sau de alt flux AI construit în jurul fișierelor tale, vezi sisteme AI sau programează un apel introductiv gratuit. Dacă sursa ta este o înregistrare, începe cu ghidul nostru despre transcrierea locală cu Whisper.