KWT-2024/lab/lab_08.ipynb
2024-04-23 11:15:21 +02:00

16 KiB

Logo 1

Komputerowe wspomaganie tłumaczenia

8. Wykorzystanie tłumaczenia automatycznego we wspomaganiu tłumaczenia [laboratoria]

Rafał Jaworski (2021)

Logo 2

W dzisiejszych czasach, niezwykle ważną techniką wspomagania tłumaczenia jest użycie tłumaczenia maszynowego. Tekst źródłowy do tłumaczenia jest najpierw tłumaczony całkowicie autommatycznie, a następnie tłumacz ludzki dokonuje korekty wyniku. Technologia tłumaczenia maszynowego jest już na tyle dojrzała, że oferuje bardzo wysoką jakość wyników. Coraz częstsze stają się scenariusze, w których ludzka korekta to niemal całkowicie machinalne (sic!) zatwierdzanie wyników tłumaczenia maszynowego. Na dzisiejszych zajęciach poznamy techniki ewaluacji tłumaczenia maszynowego oraz sprawdzania jego przydatności w procesie wspomagania tłumaczenia ludzkiego.

Jakość tłumaczenia maszynowego możemy oceniać na dwóch niezależnych płaszczyznach: dokładność i płynność. Płynność jest subiektywnie odbieranym odczuciem, że czytany tekst jest napisany językiem naturalnym i zrozumiałym. Systemy tłumaczenia maszynowego oparte na uczeniu głębokim z wykorzystaniem sieci neuronowych osiągają duży stopień płynności tłumaczenia. Niestety jednak ich dokładność nie zawsze jest równie wysoka.

Dokładność tłumaczenia maszynowego jest parametrem, który łatwiej zmierzyć. Wartość takich pomiarów daje obraz tego, jaka jest faktyczna jakość tłumaczenia maszynowego i jaka jest jego potencjalna przydatność we wspomaganiu tłumaczenia.

Najczęściej stosowaną techniką oceny tłumaczenia maszynowego jest ocena BLEU. Do obliczenia tej oceny potrzebny jest wynik tłumaczenia maszynowego oraz referencyjne tłumaczenie ludzkie wysokiej jakości.

Ćwiczenie 1: Zaimplementuj program do obliczania oceny BLEU dla korpusu w folderze data. Użyj implementacji BLEU z pakietu nltk. Dodatkowe wymaganie techniczne - napisz program tak, aby nie musiał rozpakwowywać pliku zip z korpusem na dysku.

import zipfile
from nltk.translate.bleu_score import corpus_bleu
import io

def calculate_bleu(zip_path):
    references = []
    candidates = []

    with zipfile.ZipFile(zip_path, 'r') as z:
        with z.open('EMEA.en-pl.en', 'r') as file_ref, z.open('EMEA.en-pl.pl', 'r') as file_trans:
            ref_buffer = io.TextIOWrapper(file_ref, encoding='utf-8')
            trans_buffer = io.TextIOWrapper(file_trans, encoding='utf-8')
            
            for ref_line, trans_line in zip(ref_buffer, trans_buffer):
                ref_tokens = [ref_line.strip().split()]
                trans_tokens = trans_line.strip().split()
                
                references.append(ref_tokens)
                candidates.append(trans_tokens)

    score = corpus_bleu(references, candidates)
    return score
zip_file_path = 'korpusy/emea.zip'
bleu_score = calculate_bleu(zip_file_path)
print(f"Ocena BLEU: {bleu_score}")
Ocena BLEU: 0.05086746137866238

Ćwiczenie 2: Oblicz wartość bleu na różnych fragmentach przykładowego korpusu (np. na pierwszych 100 zdaniach, zdaniach 500-600). Czy w jakimś fragmencie korpusu jakość tłumaczenia znacząco odbiega od średniej?

def analyze_bleu(zip_path, start_end_pairs):
    results = {}
    
    with zipfile.ZipFile(zip_path, 'r') as z:
        with z.open('EMEA.en-pl.en', 'r') as file_ref, z.open('EMEA.en-pl.pl', 'r') as file_trans:
            ref_buffer = io.TextIOWrapper(file_ref, encoding='utf-8')
            trans_buffer = io.TextIOWrapper(file_trans, encoding='utf-8')
            
            references_full = [line.strip().split() for line in ref_buffer]
            candidates_full = [line.strip().split() for line in trans_buffer]

            for label, (start, end) in start_end_pairs.items():

                references_segment = [references_full[i] for i in range(start, min(end, len(references_full)))]
                candidates_segment = [candidates_full[i] for i in range(start, min(end, len(candidates_full)))]
                
                references_segment = [[ref] for ref in references_segment]

                score = corpus_bleu(references_segment, candidates_segment)
                results[label] = score
    
    return results
fragments = {
    "First 100 sentences": (0, 100),
    "Sentences 500-600": (500, 600)
}

bleu_scores = analyze_bleu(zip_file_path, fragments)
for label, score in bleu_scores.items():
    print(f"Ocena BLEU dla {label}: {score}")
Ocena BLEU dla First 100 sentences: 0.03940935286156434
Ocena BLEU dla Sentences 500-600: 1.9718207266585256e-155

Inną metodą oceny jakości tłumaczenia maszynowego jest parametr WER - Word Error Rate. Definiuje się on w następujący sposób:

$WER = \frac{S+D+I}{N}=\frac{S+D+I}{S+D+C}$

gdzie:

  • S - liczba substytucji (słów)
  • D - liczba usunięć
  • I - liczba wstawień
  • C - liczba poprawnych śłów
  • N - liczba słów w tłumaczeniu referencyjnym (N=S+D+C)

Miara ta jest zwykle używana w do oceny systemów automatycznego rozpoznawania mowy, jednak w kontekście wspomagania tłumaczenia może być rozumiana jako wielkość nakładu pracy tłumacza nad poprawieniem tłumaczenia maszynowego.

Ćwiczenie 3: Oblicz wartość WER dla przykładowego korpusu. Skorzystaj z gotowej implementacji WER.

import jiwer

def calculate_wer(zip_path):
    def wer(reference, hypothesis):
        ref_words = reference.split()
        hyp_words = hypothesis.split()
        R = len(ref_words)
        H = len(hyp_words)
        cost_matrix = [[0] * (H + 1) for _ in range(R + 1)]

        for i in range(1, R + 1):
            cost_matrix[i][0] = i
        for j in range(1, H + 1):
            cost_matrix[0][j] = j

        for i in range(1, R + 1):
            for j in range(1, H + 1):
                substitution_cost = 0 if ref_words[i - 1] == hyp_words[j - 1] else 1
                cost_matrix[i][j] = min(
                    cost_matrix[i - 1][j] + 1,
                    cost_matrix[i][j - 1] + 1,
                    cost_matrix[i - 1][j - 1] + substitution_cost
                )

        i, j = R, H
        substitutions = insertions = deletions = correct = 0
        while i > 0 and j > 0:
            if ref_words[i - 1] == hyp_words[j - 1]:
                correct += 1
                i -= 1
                j -= 1
            elif cost_matrix[i][j] == cost_matrix[i - 1][j - 1] + 1:
                substitutions += 1
                i -= 1
                j -= 1
            elif cost_matrix[i][j] == cost_matrix[i][j - 1] + 1:
                insertions += 1
                j -= 1
            else:
                deletions += 1
                i -= 1

        N = substitutions + deletions + correct
        WER = (substitutions + deletions + insertions) / N if N > 0 else 0
        return WER

    total_wer = 0
    num_sentences = 0

    with zipfile.ZipFile(zip_path, 'r') as z:
        with z.open('EMEA.en-pl.en', 'r') as file_ref, z.open('EMEA.en-pl.pl', 'r') as file_trans:
            ref_buffer = io.TextIOWrapper(file_ref, encoding='utf-8')
            trans_buffer = io.TextIOWrapper(file_trans, encoding='utf-8')

            for ref_line, hyp_line in zip(ref_buffer, trans_buffer):
                total_wer += wer(ref_line.strip(), hyp_line.strip())
                num_sentences += 1

    average_wer = total_wer / num_sentences if num_sentences > 0 else 0
    return average_wer
zip_file_path = 'korpusy/emea.zip'
wer_result = calculate_wer(zip_file_path)
print(f"WER (Word Error Rate): {wer_result:.2%}")
WER (Word Error Rate): 82.13%

Poza wymienionymi powyżej, stosować można jeszcze inne miary oparte na porównywaniu tłumaczenia maszynowego z ludzkim. Przypomnijmy sobie jedną, którą stosowaliśmy wcześniej.

Ćwiczenie 4: Oblicz średnią wartość dystansu Levenshteina pomiędzy zdaniami przetłumaczonymi automatycznie oraz przez człowieka. Użyj implementacji z ćwiczeń nr 2.

import Levenshtein as lev

def calculate_levenshtein(zip_path):
    total_distance = 0
    num_sentences = 0

    with zipfile.ZipFile(zip_path, 'r') as z:
        with z.open('EMEA.en-pl.en', 'r') as file_ref, z.open('EMEA.en-pl.pl', 'r') as file_trans:
            ref_buffer = io.TextIOWrapper(file_ref, encoding='utf-8')
            trans_buffer = io.TextIOWrapper(file_trans, encoding='utf-8')

            for ref_line, hyp_line in zip(ref_buffer, trans_buffer):
                distance = lev.distance(ref_line.strip(), hyp_line.strip())
                total_distance += distance
                num_sentences += 1

    average_distance = total_distance / num_sentences if num_sentences > 0 else 0
    return average_distance
average_distance = calculate_levenshtein(zip_file_path)
print(f"Średnia wartość dystancu Levenshteina: {average_distance:.2f}")
Średnia wartość dystancu Levenshteina: 61.29

A teraz sprawdźmy coś jeszcze. W danych przykładowego korpusu znajduje się także angielski tekst źródłowy. Teoretycznie, dobre tłumaczenie niemieckie powinno zawierać jak najwięcej słów z angielskiego źródła. Wykonajmy najstępujący eksperyment:

Ćwiczenie 5: Dla każdej trójki zdań z korpusu przykładowego wykonaj następujące kroki:

  • Przetłumacz każde angielskie słowo na niemiecki przy użyciu modułu PyDictionary.
  • Sprawdź, które z niemieckich tłumaczeń zawiera więcej spośród tych przetłumaczonych słów - automatyczne, czy ludzkie. Następnie wypisz statystyki zbiorcze. Które tłumaczenie zawiera więcej słownikowych tłumaczeń słów ze źródła?
from PyDictionary import PyDictionary

def translate_corpus(zip_path, filename):
    dictionary = PyDictionary()
    translations = {}

    with zipfile.ZipFile(zip_path, 'r') as z:
        with z.open(filename, 'r') as file:
            buffer = io.TextIOWrapper(file, encoding='utf-8')

            for line in buffer:
                words = line.strip().split()
                for word in words:
                    if word not in translations:
                        try:
                            german_translation = dictionary.translate(word, "German")
                            translations[word] = german_translation
                        except Exception as e:
                            print(f"Error translating {word}: {str(e)}")
                            translations[word] = None

    return translations