Machine Translation with Hugging Face🤗

Hugging Face 가 무엇인지, 그리고 Hugging Face 를 사용해서 translation 하는 방법을 정리한다.

Hugging Face?

허깅 페이스는 다양한 트랜스포머 모델 (transformer.models)과 학습 스크립트(transformer.Trainer)를 제공하는 모듈이다. 허깅 페이스는 트랜스포머 모델을 사용할 때 layer, model 등을 선언하거나 학습 스크립트를 구현해야 하는 수고를 덜어준다.

🤗Transformers

🤗Transformers는 SOTA pretrained model들을 쉽게 다운받고 학습할 수 있게 API들과 tool들을 제공한다. pretrained model 을 사용하면 계산 비용도 줄일 수 있고, 서버를 덜 쓰니 carbon footprint도 줄일 수 있고, 처음부터 모델을 학습해야 하는 것에 비해 시간도 자원도 줄일 수 있다.

🤗 Transformers는 PyTorch, TensorFlow, 그리고 JAX 간에 프레임 워크 간 상호 운용성을 지원한다. 모델의 다른 프레임워크 사용에도 유연하게 작동한다.

HuggingFace 를 사용해서 translation 하기

translation은 sequence-to-sequence task 이다. 즉 한 sequence인 문장에서 다른 sequence를 출력한다는 것이다. 두 쌍 혹은 그 이상의 언어 쌍들을 충분히 갖고 있으면 새로운 번역 모델을 처음부터 만들 수 있다. 하지만 이미 만든 번역 모델을 가져와서 fine-tune 하는 것이 더 빠르다. 아래에서는 Marian model 을 가져와서 fine-tune 하는 예시를 보여준다.

1. Preparing data

Fine-tuning 을 하거나 처음부터 모델을 훈련하기 위해서 먼저 데이터가 필요하다. 데이터는 HuggingFace Hub 에 있는 데이터를 로드해서 사용할 수도 있고 또는 내가 가진 custom 데이터를 가져와서 사용할 수 있다. 여기에서는 KDE4 dataset을 로드해서 사용하는 것을 보여준다.

KDE4 dataset

load_dataset() 을 사용해서 데이터를 다운받는다.

from datasets import load_dataset

raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")

다른 언어를 받고싶으면 lang1, lang2 의 code를 바꿔주면 된다. 이 데이터에서 가능한 다른 언어들은 이 dataset card 링크에서 확인해보기!

데이터를 다운받은 raw_datasets 은 다음과 같은 형식이다.

DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 210173
    })
})

하나의 딕셔너리 안에 210,173 pair 문장이 통째로 들어있는데, validation 으로 따로 사용하기 위해서는 데이터를 split 해야한다. 이때 train_test_split() 함수를 사용할 수 있다.

split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
split_datasets

DatasetDict({
    train: Dataset({
        features: ['id', 'translation'],
        num_rows: 189155
    })
    test: Dataset({
        features: ['id', 'translation'],
        num_rows: 21018
    })
})

'test' key 이름을 'validation'으로 바꿔주기 위해 아래와 같이 해준다.

split_datasets["validation"] = split_datasets.pop("test") 

이제 dataset 에서 하나만 확인해보면,

split_datasets["train"][1]["translation"]

{'en': 'Default to expanded threads',
 'fr': 'Par défaut, développer les fils de discussion'}

이렇게 확인할 수 있다! 이제 한 쌍이 된 두 문장이 들어간 dictionary 를 가지게 된다.

Processing the data

text 는 전부 sets of token ID 로 변환되어야 모델이 알아들을 수 있다. 이를 위해 input 과 target 둘 다 tokenize 할 필요가 있다. 이를 위해 tokenizer object 를 만든다. 앞에서 말했 듯 Marian pretrained model 을 사용할 것이다. 다른 언어쌍을 사용하기 위해서는 Helsinki-NLP/opus-mt-{src}-{tgt} 에 언어쌍을 바꿔주면 된다. 또는, 다른 모델을 사용하고 싶으면 model_checkpoint 에 HuggingFace Hub 에 있는 다른 모델을 지정해주거나, 직접 저장한 pretrained model 을 지정해줄 수도 있다.

from transformers import AutoTokenizer

model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, return_tensors="pt")

데이터를 준비하기 위해서 기억할 한가지가 있다. tokenizer 가 output language 로 target 문장을 처리하는 지 확인해야하는 것! 이를 위해서 tokenizer에 text_target 에 target 을 넘겨주면 된다.
어떻게 동작하는지 직접 한 문장을 해보자~!

en_sentence = split_datasets["train"][1]["translation"]["en"]
fr_sentence = split_datasets["train"][1]["translation"]["fr"]

inputs = tokenizer(en_sentence, text_target=fr_sentence)
inputs

{'input_ids': [47591, 12, 9842, 19634, 9, 0], 'attention_mask': [1, 1, 1, 1, 1, 1], 'labels': [577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]}

output 으로 input_ids 에는 input문장(영어)의 id, labels 에는 target 문장(프랑스어)의 id 가 들어있다. 만약, label 을 tokenize 하는 것을 까먹으면 input tokenizer 로 tokenize 하게 되는데, Marian model의 경우 그러면 이상하게 처리가 된다. 다음을 보자.

wrong_targets = tokenizer(fr_sentence)
print(tokenizer.convert_ids_to_tokens(wrong_targets["input_ids"])) 
print(tokenizer.convert_ids_to_tokens(inputs["labels"]))

['▁Par', '▁dé', 'f', 'aut', ',', '▁dé', 've', 'lop', 'per', '▁les', '▁fil', 's', '▁de', '▁discussion', '</s>']
['▁Par', '▁défaut', ',', '▁développer', '▁les', '▁fils', '▁de', '▁discussion', '</s>']

출력된 결과를 보면 프랑스어 문장을 English tokenizer로 처리하면 tokenizer가 프랑스 단어는 모르기 때문에 더 많은 token 을 만들어낸다.

inputs 는 input IDs, attention mask, 등을 key로 가지고 있는 딕셔너리이다. 마지막으로 우리가 가진 데이터에 적용할 preprocessing function 을 정의한다.

max_length = 128 

def preprocessing_function(examples):
	inputs = [ex["en"] for ex in examples["translation"]]
    targets = [ex["fr"] for ex in examples["translation"]]
    model_inputs = tokenizer(inputs, text_target=targets, max_length=max_length, truncation=True)
	return model_inputs

지금 우리가 사용하는 문장은 짧기 때문에 input과 output 둘 다 같은 maximum length 로 128을 준다.

다음과 같이 데이터에 preprocessing을 적용한다.

tokenized_datasets = split_datasets.map(
	preprocess_function, 
    batched=True,
    remove_columns=split_datases["train"].column_names,

그럼 이제 데이터 전처리를 다 했고 pretrained model에 fine-tune할 준비가 되었다~

2. Fine-tuning the model with Traner API

학습하기 위해서 Seq2SeqTrainer 를 사용할 것이다. Seq2SeqTrainer 는 Trainer 의 subclass 로, input 으로 output 을 예측할 수 있는 generate() method 를 사용해서 evaluation 을 적절히 사용할 수 있다.

먼저 fine-tune 할 모델이 필요하다. 우리는 AutoModel API 를 사용할 것이다.

from transformers import AutoModelForSeq2SeqLM

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

Data collation

dynamic batching 을 위해 padding 을 처리하려면 data collator 가 필요하다. 여기에서는 inputs 뿐만 아니라 labels 도 maximum length 로 pad 되어야 한다. 또한 패딩된 값은 Loss 계산에서 무시되도록 하기 위해 labels 를 채우는데 사용되는 패딩 값은 tokenizer의 패딩 값이 아니라 -100 이어야 한다.

이는 DataCollatorForSeq2Seq 를 사용해서 할 수 있다. DataCollatorWithPadding 과 마찬가지로 input 전처리에 사용되는 tokenizer과 함께 모델도 사용한다. 모델도 입력받는 이유는 data collator 가 시작 부분에 특수 토큰이 있는, label 의 shift 된 버전인 decoder input ID 도 준비하기 때문이다. 이 shift 는 아키텍쳐마다 약간 다르게 수행되기 때문에 DataCollatorForSeq2Seq 는 모델 객체를 알아야 한다.

from transformers import DataCollatorForSeq2Seq

data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)

몇가지 문장으로 테스트 하기 위해 tokenized training set 에 예시 문장의 리스트를 가져온다.

batch = data_collator([tokenized_datasets["train"][i] for i in range(1, 3)])
batch.keys()

dict_keys(['attention_mask', 'input_ids', 'labels', 'decoder_input_ids'])

-100 을 통해 Labels 이 배치의 Maximum length 로 패딩 된 것을 확인 할 수 있다.

batch["labels"]

tensor([[  577,  5891,     2,  3184,    16,  2542,     5,  1710,     0,  -100,
          -100,  -100,  -100,  -100,  -100,  -100],
        [ 1211,     3,    49,  9409,  1211,     3, 29140,   817,  3124,   817,
           550,  7032,  5821,  7907, 12649,     0]])

또한 decoder input ID 를 보았을 때 label 의 shifted version 인 것을 알 수 있다.

batch["decoder_input_ids"]

tensor([[59513,   577,  5891,     2,  3184,    16,  2542,     5,  1710,     0,
         59513, 59513, 59513, 59513, 59513, 59513],
        [59513,  1211,     3,    49,  9409,  1211,     3, 29140,   817,  3124,
           817,   550,  7032,  5821,  7907, 12649]])

다음은 데이터의 첫번째, 두번째 문장에 대한 label 이다.

for i in range(1, 3):
    print(tokenized_datasets["train"][i]["labels"])

[577, 5891, 2, 3184, 16, 2542, 5, 1710, 0]
[1211, 3, 49, 9409, 1211, 3, 29140, 817, 3124, 817, 550, 7032, 5821, 7907, 12649, 0]

이 data_collator 는 Seq2Seq2Trainer 로 보내지게 될 것이다. 다음으로 Metric 을 보자!

Metrics

Seq2SeqTrainer 가 superclass 인 Trainer 에 추가하는 기능은 evaluation 또는 prediction 중에 generate() 메소드를 사용하는 기능이다. 학습하는 동안 모델은 학습 속도를 높이기 위해 예측하려는 토큰 이후에 존재하는 토큰을 사용하지 않도록 하려고 attention masking 과 함께 decoder_input_ids 를 사용한다. Inference 할 때에는 label 이 없기 때문에 이를 사용할 수 없으므로 동일한 설정으로 모델을 평가하는 것이 좋다.

번역에 있어서 전통적인 평가 metric 은 2002년에 Kishore Papineni et al.에 의해 소개된 BLEU score 로 알려져있다. BLEU score 는 번역된 문장이 실제 label 과 얼마나 가까운지 평가한다. 모델의 결과를 얼마나 명료한지 또는 문법적으로 적절한지는 평가하지 않는다. 하지만 출력된 결과에 있는 단어가 target 에도 나타나는지 평가하기 위해 통계적인 방법을 쓴다. 실제 문장에서는 반복이 없는데 모델의 결과에는 같은 단어가 반복되는 경우 패널티를 주고, 실제 문장보다 짧은 문장을 만들어 내는 경우에도 패널티를 준다.

BLEU score 의 약점 중 한가지는 이미 토큰화 된 문장을 대상으로 하기 때문에 다른 tokenizer 를 사용하는 모델 간의 점수를 비교하기 어렵다는 것이다. 따라서 오늘날 번역 모델을 벤치마킹하는데 가장 일반적으로 사용되는 metric 은 토큰화 단계를 표준화하여 이러한 약점을 해결하는 SacreBLEU 다. 이 metric 을 사용하려면 SacreBLEU 라이브러리를 설치해야 한다.

!python3 -m pip install sacrebleu

그 다음은 load_metric() 을 통해 로드할 수 있다.

from datasets import load_metric

metric = load_metric("sacrebleu")

이 metric 은 텍스트를 input 과 target 으로 사용한다. 같은 문장에 대해 가능한 번역 결과가 여러개 있기 때문에 여러 개의 가능한 대상을 입력받도록 설계되었다. NLP에서 여러 문장을 label로 제공하는 데이터셋들도 많이 존재하기 때문에 predictions 는 문장 리스트여야 하지만 refenrences 는 문자 리스트의 리스트 이어야 한다.

예시를 보자.

predictions = [
    "This plugin lets you translate web pages between several languages automatically."
]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 46.750469682990165,
 'counts': [11, 6, 4, 3],
 'totals': [12, 11, 10, 9],
 'precisions': [91.67, 54.54, 40.0, 33.33],
 'bp': 0.9200444146293233,
 'sys_len': 12,
 'ref_len': 13}

BLEU score 로 46.75 를 보여주는데 꽤 괜찮은 결과다. 반면에 아래에는 반복되고 짧은 문장으로 평가했을 때 나쁜 결과를 보여주는 예시이다.

predictions = ["This This This This"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 1.683602693167689,
 'counts': [1, 0, 0, 0],
 'totals': [4, 3, 2, 1],
 'precisions': [25.0, 16.67, 12.5, 12.5],
 'bp': 0.10539922456186433,
 'sys_len': 4,
 'ref_len': 13}

predictions = ["This plugin"]
references = [
    [
        "This plugin allows you to automatically translate web pages between several languages."
    ]
]
metric.compute(predictions=predictions, references=references)

{'score': 0.0,
 'counts': [2, 1, 0, 0],
 'totals': [2, 1, 0, 0],
 'precisions': [100.0, 100.0, 0.0, 0.0],
 'bp': 0.004086771438464067,
 'sys_len': 2,
 'ref_len': 13}

score 는 클수록 좋은 것이다.

모델 출력에서 metric 이 사용할 수 있는 텍스트로 변환하기 위해 tokenizer.batch_decode() 메소드를 사용한다. label 에서는 모든 -100을 제거하면 된다. (토크나이저는 패딩 토큰에 대해 자동으로 동일한 작업을 수행함)

import numpy as np 

def compute_metrics(eval_preds):
	preds, labels = eval_preds 
    # In case the model returns more than the prediction logits 
    if ininstance(preds, tuple):
    	preds = preds[0] 
    
    decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
    
    # Replace -100s in the labels as we can't decode them 
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id) 
    decoded_labels = tokenizer.batch_decode(labels, skip_spacial_tokens=True) 
    
    # Some simple post-processing 
    decoded_preds = [pred.strip() for pred in decoded_preds]
    decoded_labels = [[label.strip()] for label in decoded_labels]
    
    result = metric.compute(predictions=decoded_preds, references=decoded_labels) 
    return {"bleu": result["score"]}
    

Fine-tuning the model

모델을 미세조정하기 위해 먼저 Seq2SeqTrainingArguments 를 정의한다.

from transformers import Seq2SeqTrainingArguments 

args = Seq2SeqTrainingArguments(
	f"marian-finetuned-kde4-en-to-fr",
    evaluation_strategy="no",
    save_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    weight_decay=0.01,
    save_total_limit=3,
    num_train_epochs=3,
    predict_with_generate=True,
    fp16=True,
    push_to_hub=True,
)

일반적인 hyperparameter (learning rate, num of epochs, batch size, weight decay) 를 제외하고, 여기에서는 조금 변화를 준다.

• regular evaluation 을 설정하지 않는다. training 하기 전이나 후에 evaluate 한다.

• fp16=True 로 설정해서 GPU 로 training 하는 속도를 높인다.

• predict_with_generate=True 으로 한다.

• push_to_hub=True 를 사용해서 각 epoch 가 끝날 때 Hub 에 모델을 업로드한다.

hub_model_id 을 사용하면 푸쉬하려는 저장소의 전체 이름을 지정할 수 있다. 예를 들어 모델을 huggingface-course 에 푸쉬할 때, hub_model_id="huggingface-course/marian-finetuned-kde4-en-to-fr" 를 Seq2SeqTrainingArguments 에 추가하면 된다.

마지막으로 모든 걸 Seq2SeqTrainer 에 전달한다.

from transformers import Seq2SeqTrainer

trainer = Seq2SeqTrainer(
    model,
    args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics,
)

학습하기 전에 먼저 초기 모델이 얻는 점수를 보고, fine-tuning 으로 혹시 더 악화되는 것은 아닌지 확인해본다. 아래 명령은 좀 오래 걸린다.

trainer.evaluate(max_length=max_target_length)

{'eval_loss': 1.6964408159255981,
 'eval_bleu': 39.26865061007616,
 'eval_runtime': 965.8884,
 'eval_samples_per_second': 21.76,
 'eval_steps_per_second': 0.341}

BLEU score 39 는 나쁘지 않다. 우리가 선택한 모델이 이미 영어-프랑스어 문장을 잘 번역한다는 것이다.

다음으로 본격적으로 학습을 한다. 시간이 오래 걸릴 것이다.

trainer.train()

학습이 진행되는 동안 모델이 저장될 때마다 (여기선 epoch 마다) 백그라운드에서 모델이 허브에 업로드된다. 이런 방식으로 다른 머신에서 학습을 다시 시작할 수도 있다.

학습이 완료되면 다시 평가해보자.

trainer.evaluate(max_length=max_target_length)

{'eval_loss': 0.8558505773544312,
 'eval_bleu': 52.94161337775576,
 'eval_runtime': 714.2576,
 'eval_samples_per_second': 29.426,
 'eval_steps_per_second': 0.461,
 'epoch': 3.0}

거의 14 점이 올랐다!

마지막으로 push_to_hub() 메서드를 사용해서 최신 버전의 모델을 업로드했는지 확인한다. Trainer 는 모든 평가 결과가 포함된 모델 카드의 초안을 작성해서 업로드한다. 이 모델 카드에는 Model Hub 가 inference 데모용 위젯을 선택하는데 도움이 되는 메타데이터가 포함되어있다. 일반적으로 모델 클래스에서 올바른 위젯을 유추할 수 있으므로 아무것도 할 필요가 없지만, 이 경우 동일한 모델 클래스를 모든 종류의 sequence-to-sequence 문제에 사용할 수 있으므로 번역모델이라고 지정한다.

trainer.push_to_hub(tags="tanslation", commit_message="Training complete")

위 명령은 아래와 같이 방금 한 커밋의 URL 을 반환한다.

'https://huggingface.co/sgugger/marian-finetuned-kde4-en-to-fr/commit/3601d621e3baae2bc63d3311452535f8f58f6ef3'

이제 모델을 테스트하기 위해 Model Hub 의 inference widget 을 사용할 수 있고 공유할 수도 있다. 드디어 성공적으로 번역 테스크를 하는 모델을 fine-tune 완료했다!

학습 루프에 대해 좀 더 자세히 알고 싶다면 이제 🤗Accelerate를 사용하여 동일한 작업을 수행하는 방법을 아래에서 보여준다.

3. A custom training loop

이제 full training loop 를 보고, 필요할 때 원하는 부분만 커스텀 해서 사용할 수 있게 공부해보자.

Preparing everything for training

먼저 데이터셋을 torch 로 포멧한 다음, 데이터 셋을 가지고 DataLoaders 를 만든다.

from torch.utils.data import DataLoader 

tokenized_datasets.set_format("torch")
train_dataloader = DataLoader(
	tokenized_datasets["train"], 
    shuffle=True, 
    collate_fn=data_collator,
    batch_size=8,
)
eval_dataloader = DataLoader(
	tokenized_datasets[], collate_fn=data_collator, batch_size=8
)

다음으로 모델을 reinstantiate 해서 pretrained model 에서 시작한다.

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

그런 다음 optmizer 도 만든다.

from transformers import AdamW 

optimizer = AdamW(model.parameters(), lr=2e-5)

이렇게 만들면 accelerator.prepare() 메소드에 보낼 수 있다.

from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)

이제 train_dataloader 를 accelerator.prepare() 로 보내고, 이 길이를 training step 의 수를 계산할 때 사용할 수 있다.

from transformers import get_scheduler

num_train_epochs = 3
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps,
)

우리가 만든 모델을 Hub 에 올리려면 Repository 객체를 만들어야 한다. 로그인 한 상태가 아니라면 일단 Hugging Face Hub 에 로그인 부터 한다. 그리고 model ID 로 레포지토리의 이름을 정해준다.

from huggingface_hub import Repository, get_full_repo_name

model_name = "marian-finetuned-kde4-en-to-fr-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name

'sgugger/marian-finetuned-kde4-en-to-fr-accelerate'

Training loop

이제 full training loop 를 쓸 준비가 되었다. evaluation 부분을 간단하게 하기 위해, predictions 와 labels 를 metric 이 사용하기 쉽게 변환하는 postprocess() 함수이다.

def postprocess(predictions, labels):
    predictions = predictions.cpu().numpy()
    labels = labels.cpu().numpy()

    decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)

    # Replace -100 in the labels as we can't decode them.
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)

    # Some simple post-processing
    decoded_preds = [pred.strip() for pred in decoded_preds]
    decoded_labels = [[label.strip()] for label in decoded_labels]
    return decoded_preds, decoded_labels

from tqdm.auto import tqdm
import torch

progress_bar = tqdm(range(num_training_steps))

for epoch in range(num_train_epochs):
    # Training
    model.train()
    for batch in train_dataloader:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)

    # Evaluation
    model.eval()
    for batch in tqdm(eval_dataloader):
        with torch.no_grad():
            generated_tokens = accelerator.unwrap_model(model).generate(
                batch["input_ids"],
                attention_mask=batch["attention_mask"],
                max_length=128,
            )
        labels = batch["labels"]

        # Necessary to pad predictions and labels for being gathered
        generated_tokens = accelerator.pad_across_processes(
            generated_tokens, dim=1, pad_index=tokenizer.pad_token_id
        )
        labels = accelerator.pad_across_processes(labels, dim=1, pad_index=-100)

        predictions_gathered = accelerator.gather(generated_tokens)
        labels_gathered = accelerator.gather(labels)

        decoded_preds, decoded_labels = postprocess(predictions_gathered, labels_gathered)
        metric.add_batch(predictions=decoded_preds, references=decoded_labels)

    results = metric.compute()
    print(f"epoch {epoch}, BLEU score: {results['score']:.2f}")

    # Save and upload
    accelerator.wait_for_everyone()
    unwrapped_model = accelerator.unwrap_model(model)
    unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
    if accelerator.is_main_process:
        tokenizer.save_pretrained(output_dir)
        repo.push_to_hub(
            commit_message=f"Training in progress epoch {epoch}", blocking=False
        )

epoch 0, BLEU score: 53.47
epoch 1, BLEU score: 54.24
epoch 2, BLEU score: 54.44

Using the fine-tuned model

pipeline 으로 fine-tuned 모델을 사용하기 위해서는 model identifier 만 잘 지정해주면 된다.

from transformers import pipeline

# Replace this with your own checkpoint
model_checkpoint = "huggingface-course/marian-finetuned-kde4-en-to-fr"
translator = pipeline("translation", model=model_checkpoint)
translator("Default to expanded threads")

[{'translation_text': 'Par défaut, développer les fils de discussion'}]

이제 pretrained model 이 fine-tune 한 corpus 에 맞게 예측한다. 영어 단어 "threads" 로 그냥 두지 않고, 프랑스어 단어로 번역한다.
domain adaptation 의 또 다른 예이다.

translator(
    "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
)

[{'translation_text': "Impossible d'importer %1 en utilisant le module externe d'importation OFX. Ce fichier n'est pas le bon format."}]

---

코드에 틀린부분이 있는데 아직 수정 안함. 정확하게는 아래 레퍼 참고 하기...

[reference]

https://huggingface.co/learn/nlp-course/chapter7/4?fw=pt#translation

https://wikidocs.net/166832