HF-NLP-FINE-TUNING A PRETRAINED MODEL-Fine-tuning a model with the Trainer API

https://huggingface.co/learn/nlp-course/chapter3/3?fw=pt

Fine-tuning a model with the Trainer API - Hugging Face NLP Course

 

Fine-tuning a model with the Trainer API

 

https://youtu.be/nvBXf7s7vTI?si=7V5gLAt293qhuK67

 

🤗 Transformers provides a Trainer class to help you fine-tune any of the pretrained models it provides on your dataset. Once you’ve done all the data preprocessing work in the last section, you have just a few steps left to define the Trainer. The hardest part is likely to be preparing the environment to run Trainer.train(), as it will run very slowly on a CPU. If you don’t have a GPU set up, you can get access to free GPUs or TPUs on Google Colab.

 

🤗 Transformers는 데이터세트에서 제공하는 사전 훈련된 모델을 미세 조정하는 데 도움이 되는 Trainer 클래스를 제공합니다. 마지막 섹션에서 모든 데이터 전처리 작업을 완료하고 나면 Trainer를 정의하기 위한 몇 단계만 남았습니다. 가장 어려운 부분은 Trainer.train()을 실행하기 위한 환경을 준비하는 것입니다. 왜냐하면 Trainer.train()은 CPU에서 매우 느리게 실행되기 때문입니다. GPU가 설정되어 있지 않은 경우 Google Colab에서 무료 GPU 또는 TPU에 액세스할 수 있습니다.

 

The code examples below assume you have already executed the examples in the previous section. Here is a short summary recapping what you need:

 

아래 코드 예제에서는 이전 섹션의 예제를 이미 실행했다고 가정합니다. 다음은 필요한 사항을 간략하게 요약한 것입니다.

 

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

# MRPC 데이터셋 로드
raw_datasets = load_dataset("glue", "mrpc")

# BERT 모델의 체크포인트를 "bert-base-uncased"로 지정하여 토크나이저 초기화
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

# 사용자 정의 토크나이즈 함수 정의
def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)

# 토큰화된 데이터셋 생성
tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)

# 데이터 콜레이터 초기화
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

 

이 코드는 Hugging Face Transformers 라이브러리를 사용하여 MRPC(Microsoft Research Paraphrase Corpus) 데이터셋을 로드하고, BERT 모델의 토크나이저를 초기화하며, 토큰화 함수와 데이터 콜레이터를 정의하는 예제입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. load_dataset("glue", "mrpc"): Hugging Face의 datasets 라이브러리를 사용하여 MRPC 데이터셋을 로드합니다.
2. AutoTokenizer.from_pretrained(checkpoint): BERT 모델의 체크포인트를 지정하여 해당 모델에 대한 토크나이저를 초기화합니다.
3. def tokenize_function(example): MRPC 데이터셋의 각 예시에 대한 사용자 정의 토크나이즈 함수를 정의합니다. 이 함수는 "sentence1"과 "sentence2" 필드의 문장을 토큰화합니다.
4. raw_datasets.map(tokenize_function, batched=True): map 함수를 사용하여 데이터셋의 각 예시에 대해 토크나이즈 함수를 적용하고, 배치(batch) 단위로 토큰화된 데이터셋을 생성합니다.
5. DataCollatorWithPadding(tokenizer=tokenizer): 데이터 콜레이터를 초기화합니다. 이 데이터 콜레이터는 패딩을 적용하여 배치의 모든 입력 시퀀스를 동일한 길이로 만들어주는 역할을 합니다.

이렇게 초기화된 토크나이저, 토큰화 함수, 데이터 콜레이터는 이후 모델 훈련 또는 추론을 위해 사용될 수 있습니다.

 

 

Training

The first step before we can define our Trainer is to define a TrainingArguments class that will contain all the hyperparameters the Trainer will use for training and evaluation. The only argument you have to provide is a directory where the trained model will be saved, as well as the checkpoints along the way. For all the rest, you can leave the defaults, which should work pretty well for a basic fine-tuning.

 

Trainer를 정의하기 전 첫 번째 단계는 Trainer가 훈련 및 평가에 사용할 모든 하이퍼파라미터를 포함는 TrainingArguments 클래스를 정의하는 것입니다. 제공해야 하는 유일한 인수는 학습된 모델이 저장될 디렉터리와 그 과정에서 체크포인트입니다. 나머지 모든 사항에 대해서는 기본값을 그대로 두면 기본 미세 조정에 매우 적합합니다.

 

from transformers import TrainingArguments

training_args = TrainingArguments("test-trainer")

 

이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델 훈련에 필요한 훈련 인자(Training Arguments)를 설정하는 예제입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. TrainingArguments: Hugging Face Transformers 라이브러리에서 제공하는 모델 훈련을 위한 인자를 설정하는 클래스입니다.
2. TrainingArguments("test-trainer"): 훈련 인자 객체를 초기화합니다. 여기서 "test-trainer"는 훈련의 이름(디렉토리 이름)을 나타냅니다.

이렇게 초기화된 training_args 객체에는 모델 훈련에 필요한 다양한 설정이 포함되어 있습니다. 훈련 스크립트에서 이 인자들을 참조하여 모델 훈련을 조절할 수 있습니다. 이 예제에서는 가장 기본적인 훈련 인자만 설정되었습니다. 나중에 필요에 따라 추가적인 설정을 적용할 수 있습니다.

 

CoLab에서는 아래와 같은 에러가 남

 

 

pip install transformers[torch] 를 한 후 CoLab을 Restart 한 후 다시 실행하면 됨

 

 

 

💡 If you want to automatically upload your model to the Hub during training, pass along push_to_hub=True in the TrainingArguments. We will learn more about this in Chapter 4

 

💡 훈련 중에 모델을 허브에 자동으로 업로드하려면 TrainingArguments에 push_to_hub=True를 전달하세요. 이에 대한 자세한 내용은 4장에서 알아보겠습니다.

 

The second step is to define our model. As in the previous chapter, we will use the AutoModelForSequenceClassification class, with two labels:

 

두 번째 단계는 모델을 정의하는 것입니다. 이전 장에서와 마찬가지로 두 개의 레이블이 있는 AutoModelForSequenceClassification 클래스를 사용합니다.

 

from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

 

이 코드는 Hugging Face Transformers 라이브러리를 사용하여 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화하는 예제입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. AutoModelForSequenceClassification: Hugging Face Transformers 라이브러리에서 제공하는 시퀀스 분류(sequence classification) 모델을 초기화하는 클래스입니다.
2. from_pretrained(checkpoint, num_labels=2): from_pretrained 메서드를 사용하여 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화합니다. checkpoint는 모델의 체크포인트를 지정하고, num_labels=2는 모델의 출력 클래스의 개수를 나타냅니다. 이 경우에는 이진 분류를 수행하는 모델로서 출력 클래스가 2개인 경우입니다.

이 코드를 실행하면 model 변수에는 초기화된 모델이 저장되어 있습니다. 이 모델은 이진 분류를 수행할 수 있으며, 사전 훈련된 모델을 사용하여 특정 작업에 미세 조정(fine-tuning)을 할 수 있습니다.

 

 

You will notice that unlike in Chapter 2, you get a warning after instantiating this pretrained model. This is because BERT has not been pretrained on classifying pairs of sentences, so the head of the pretrained model has been discarded and a new head suitable for sequence classification has been added instead. The warnings indicate that some weights were not used (the ones corresponding to the dropped pretraining head) and that some others were randomly initialized (the ones for the new head). It concludes by encouraging you to train the model, which is exactly what we are going to do now.

 

2장과 달리 사전 훈련된 모델을 인스턴스화한 후 경고가 표시된다는 점을 알 수 있습니다. 이는 BERT가 문장 쌍을 분류하는 데 사전 학습되지 않았기 때문에 사전 학습된 모델의 헤드를 삭제하고 대신 시퀀스 분류에 적합한 새로운 헤드를 추가했기 때문입니다. 경고는 일부 가중치(삭제된 사전 훈련 헤드에 해당하는 가중치)가 사용되지 않았으며 일부 가중치(새 헤드에 대한 가중치)가 무작위로 초기화되었음을 나타냅니다. 우리가 지금 하려고 하는 것이 바로 모델 훈련을 권장하는 것으로 마무리됩니다.

 

Once we have our model, we can define a Trainer by passing it all the objects constructed up to now — the model, the training_args, the training and validation datasets, our data_collator, and our tokenizer:

 

모델이 있으면 지금까지 구성한 모든 개체(모델, training_args, 훈련 및 검증 데이터 세트, data_collator 및 토크나이저)를 전달하여 Trainer를 정의할 수 있습니다.

 

from transformers import Trainer

trainer = Trainer(
    model,
    training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
)

 

이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델을 훈련하기 위한 Trainer를 초기화하는 예제입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. Trainer: Hugging Face Transformers 라이브러리에서 제공하는 훈련을 관리하는 클래스입니다.
2. model: 훈련에 사용될 모델 객체입니다.
3. training_args: 앞서 설정한 모델 훈련 인자(Training Arguments) 객체입니다.
4. train_dataset=tokenized_datasets["train"]: 훈련에 사용될 데이터셋을 지정합니다. 여기서는 토큰화된 훈련 데이터셋을 사용합니다.
5. eval_dataset=tokenized_datasets["validation"]: 모델의 성능을 평가할 때 사용될 검증 데이터셋을 지정합니다.
6. data_collator=data_collator: 데이터 콜레이터 객체를 지정합니다. 이 객체는 배치를 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다.
7. tokenizer=tokenizer: 토크나이저 객체를 지정합니다. 이 토크나이저는 모델 입력을 토큰화하는 데 사용됩니다.

이렇게 초기화된 Trainer 객체를 사용하면 지정된 모델과 데이터셋으로 모델을 훈련하고 평가할 수 있습니다. Trainer 객체를 사용하여 모델 훈련에 관련된 다양한 작업을 수행할 수 있습니다.

 

Note that when you pass the tokenizer as we did here, the default data_collator used by the Trainer will be a DataCollatorWithPadding as defined previously, so you can skip the line data_collator=data_collator in this call. It was still important to show you this part of the processing in section 2!

 

여기에서 했던 것처럼 토크나이저를 전달하면 Trainer에서 사용하는 기본 data_collator는 이전에 정의한 대로 DataCollatorWithPadding이 되므로 이 호출에서 data_collator=data_collator 줄을 건너뛸 수 있습니다. 섹션 2에서 처리 중 이 부분을 보여주는 것이 여전히 중요했습니다!

 

To fine-tune the model on our dataset, we just have to call the train() method of our Trainer:

 

데이터 세트의 모델을 미세 조정하려면 Trainer의 train() 메서드를 호출하기만 하면 됩니다.

 

trainer.train()

 

이 코드는 Hugging Face Transformers 라이브러리의 Trainer 객체를 사용하여 모델을 훈련하는 메서드를 호출하는 예제입니다.

 

해석:

• trainer: 앞서 초기화한 Trainer 객체입니다.
• train(): Trainer 객체의 train 메서드를 호출합니다. 이 메서드는 모델을 실제로 훈련시키는 역할을 합니다. 메서드가 실행되면 지정된 횟수만큼 모델이 훈련되며, 각 에폭(epoch)마다 훈련 손실(training loss) 및 검증 손실(validation loss) 등의 정보가 출력됩니다.

이 코드를 실행하면 모델이 지정된 횟수만큼 데이터셋에 대해 훈련되며, 훈련 손실 및 검증 손실이 출력됩니다. Trainer 객체는 앞서 설정한 훈련 인자(Training Arguments)에 따라 훈련이 진행되며, 필요한 경우 추가적인 설정을 적용할 수 있습니다.

 

CoLab에서 train() 을 하면 두시간이 걸린다.

 

 

This will start the fine-tuning (which should take a couple of minutes on a GPU) and report the training loss every 500 steps. It won’t, however, tell you how well (or badly) your model is performing. This is because:

 

그러면 미세 조정(GPU에서는 몇 분 정도 소요)이 시작되고 500단계마다 훈련 손실이 보고됩니다. 그러나 모델의 성능이 얼마나 좋은지(또는 나쁜지) 알려주지는 않습니다. 그 이유는 아래와 같습니다.

 

1. We didn’t tell the Trainer to evaluate during training by setting evaluation_strategy to either "steps" (evaluate every eval_steps) or "epoch" (evaluate at the end of each epoch).
   
   training_strategy를 "steps"(모든 eval_steps 평가) 또는 "epoch"(각 epoch 끝에서 평가)로 설정하여 훈련 중에 평가하도록 트레이너에게 지시하지 않았습니다.
   
   
2. We didn’t provide the Trainer with a compute_metrics() function to calculate a metric during said evaluation (otherwise the evaluation would just have printed the loss, which is not a very intuitive number).
   
   우리는 평가 중에 메트릭을 계산하기 위해 Compute_metrics() 함수를 Trainer에 제공하지 않았습니다(그렇지 않으면 평가에서 매우 직관적인 숫자가 아닌 손실만 인쇄했을 것입니다).
   
   
   

Evaluation

 

Let’s see how we can build a useful compute_metrics() function and use it the next time we train. The function must take an EvalPrediction object (which is a named tuple with a predictions field and a label_ids field) and will return a dictionary mapping strings to floats (the strings being the names of the metrics returned, and the floats their values). To get some predictions from our model, we can use the Trainer.predict() command:

 

유용한 Compute_metrics() 함수를 어떻게 구축하고 다음 훈련에 사용할 수 있는지 살펴보겠습니다. 함수는 EvalPrediction 객체(예측 필드와 label_ids 필드가 있는 명명된 튜플)를 가져와야 하며 문자열을 부동 소수점(문자열은 반환된 측정항목의 이름이고 부동 소수점 값)에 매핑하는 사전을 반환합니다. 모델에서 몇 가지 예측을 얻으려면 Trainer.predict() 명령을 사용할 수 있습니다.

 

predictions = trainer.predict(tokenized_datasets["validation"])
print(predictions.predictions.shape, predictions.label_ids.shape)

(408, 2) (408,)

 

이 코드는 Hugging Face Transformers 라이브러리의 Trainer 객체를 사용하여 검증 데이터셋에 대한 예측을 수행하고, 그 결과를 출력하는 예제입니다.

 

해석:

• trainer: 앞서 초기화한 Trainer 객체입니다.
• predict(tokenized_datasets["validation"]): Trainer 객체의 predict 메서드를 호출하여 검증 데이터셋에 대한 예측을 수행합니다. tokenized_datasets["validation"]은 검증 데이터셋의 토큰화된 버전을 나타냅니다.
• predictions.predictions.shape: 예측된 결과의 모양(shape)을 나타냅니다. 예측된 결과는 모델의 출력으로, 각 클래스에 대한 확률 값이 포함된 텐서입니다.
• predictions.label_ids.shape: 실제 레이블(ground truth)의 모양(shape)을 나타냅니다. 이는 검증 데이터셋의 실제 클래스 레이블을 나타내는 텐서입니다.

결과로 출력되는 predictions.predictions.shape와 predictions.label_ids.shape은 각각 예측된 결과의 모양과 실제 레이블의 모양을 나타내므로, 모델의 성능 평가 및 분석에 활용할 수 있습니다. 이를 통해 모델이 얼마나 잘 예측했는지를 확인할 수 있습니다.

 

 

 

The output of the predict() method is another named tuple with three fields: predictions, label_ids, and metrics. The metrics field will just contain the loss on the dataset passed, as well as some time metrics (how long it took to predict, in total and on average). Once we complete our compute_metrics() function and pass it to the Trainer, that field will also contain the metrics returned by compute_metrics().

 

predict () 메서드의 출력은 predict , label_ids 및 메트릭이라는 세 가지 필드가 있는 또 다른 명명된 튜플입니다. 측정항목 필드에는 전달된 데이터 세트의 손실과 일부 시간 측정항목(전체 및 평균으로 예측하는 데 걸린 시간)만 포함됩니다. Compute_metrics() 함수를 완성하고 이를 Trainer에 전달하면 해당 필드에는 Compute_metrics()에서 반환된 측정항목도 포함됩니다.

 

As you can see, predictions is a two-dimensional array with shape 408 x 2 (408 being the number of elements in the dataset we used). Those are the logits for each element of the dataset we passed to predict() (as you saw in the previous chapter, all Transformer models return logits). To transform them into predictions that we can compare to our labels, we need to take the index with the maximum value on the second axis:

 

보시다시피 예측은 408 x 2 모양의 2차원 배열입니다(408은 우리가 사용한 데이터세트의 요소 수입니다). 이는 우리가 predict  ()에 전달한 데이터 세트의 각 요소에 대한 로짓입니다(이전 장에서 보았듯이 모든 Transformer 모델은 로짓을 반환합니다). 이를 레이블과 비교할 수 있는 predict  으로 변환하려면 두 번째 축에서 최대값을 갖는 인덱스를 가져와야 합니다.

 

import numpy as np

preds = np.argmax(predictions.predictions, axis=-1)

 

이 코드는 NumPy 라이브러리를 사용하여 모델의 예측 결과에서 각 샘플에 대한 최대값을 찾아 클래스를 선택하는 예제입니다.

 

해석:

• predictions.predictions: 모델의 예측 결과로, 각 클래스에 대한 확률 값이 담긴 텐서입니다.
• np.argmax(predictions.predictions, axis=-1): NumPy의 argmax 함수를 사용하여 각 샘플에 대해 가장 높은 확률 값을 가진 클래스의 인덱스를 찾습니다. axis=-1는 가장 안쪽(마지막) 차원을 기준으로 최댓값을 찾도록 지정합니다.

결과로 얻어지는 preds는 각 샘플에 대해 모델이 예측한 클래스의 인덱스를 담은 배열이 됩니다. 이를 통해 각 샘플에 대한 최종 예측 클래스를 확인할 수 있습니다. 예를 들어, 이 배열의 첫 번째 원소는 첫 번째 샘플의 예측 클래스를 나타냅니다.

 

 

We can now compare those preds to the labels. To build our compute_metric() function, we will rely on the metrics from the 🤗 Evaluate library. We can load the metrics associated with the MRPC dataset as easily as we loaded the dataset, this time with the evaluate.load() function. The object returned has a compute() method we can use to do the metric calculation:

 

이제 해당 pred를 레이블과 비교할 수 있습니다. Compute_metric() 함수를 빌드하기 위해 🤗 Evaluate 라이브러리의 메트릭을 사용합니다. 이번에는 estimate.load() 함수를 사용하여 데이터세트를 로드한 것처럼 쉽게 MRPC 데이터세트와 관련된 측정항목을 로드할 수 있습니다. 반환된 객체에는 측정항목 계산을 수행하는 데 사용할 수 있는 Compute() 메서드가 있습니다.

 

import evaluate

metric = evaluate.load("glue", "mrpc")
metric.compute(predictions=preds, references=predictions.label_ids)

 

{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}

 

이 코드는 Hugging Face의 evaluate 모듈을 사용하여 모델의 성능 지표를 계산하는 예제입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. import evaluate: Hugging Face에서 제공하는 evaluate 모듈을 가져옵니다.
2. evaluate.load("glue", "mrpc"): "glue" 데이터셋의 "mrpc" 태스크에 해당하는 성능 지표 메트릭을 로드합니다. 이 메트릭은 해당 태스크에 대한 평가 지표를 계산하는 데 사용됩니다.
3. metric.compute(predictions=preds, references=predictions.label_ids): compute 메서드를 사용하여 모델의 예측값 (preds)과 실제 레이블 (predictions.label_ids)을 입력으로 주어 성능 지표를 계산합니다. 이 메서드는 정확도(accuracy) 및 기타 태스크별 지표를 반환할 수 있습니다.

결과로 얻어지는 값은 해당 데이터셋 및 태스크에 대한 모델의 성능을 나타내며, 필요에 따라 이를 기반으로 모델을 평가하고 비교할 수 있습니다.

 

 

 

The exact results you get may vary, as the random initialization of the model head might change the metrics it achieved. Here, we can see our model has an accuracy of 85.78% on the validation set and an F1 score of 89.97. Those are the two metrics used to evaluate results on the MRPC dataset for the GLUE benchmark. The table in the BERT paper reported an F1 score of 88.9 for the base model. That was the uncased model while we are currently using the cased model, which explains the better result.

 

모델 헤드의 무작위 초기화로 인해 얻은 측정항목이 변경될 수 있으므로 얻을 수 있는 정확한 결과는 다를 수 있습니다. 여기서 우리 모델의 검증 세트 정확도는 85.78%이고 F1 점수는 89.97임을 알 수 있습니다. 이는 GLUE 벤치마크에 대한 MRPC 데이터 세트의 결과를 평가하는 데 사용되는 두 가지 측정항목입니다. BERT 논문의 표는 기본 모델의 F1 점수가 88.9라고 보고했습니다. 우리가 현재 케이스를 씌운 모델을 사용하고 있는 동안 그것은 케이스가 없는 모델이었습니다. 이것이 더 나은 결과를 설명합니다.

 

Wrapping everything together, we get our compute_metrics() function:

 

모든 것을 하나로 묶으면 Compute_metrics() 함수를 얻게 됩니다.

 

 

def compute_metrics(eval_preds):
    metric = evaluate.load("glue", "mrpc")
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

 

이 코드는 모델의 평가를 위해 사용되는 사용자 정의 메트릭을 계산하는 함수를 정의한 예제입니다. 코드를 단계별로 설명하겠습니다.

 

 

해석:

1. compute_metrics 함수 정의: 사용자가 정의한 평가 메트릭을 계산하는 함수입니다.
2. metric = evaluate.load("glue", "mrpc"): "glue" 데이터셋의 "mrpc" 태스크에 해당하는 성능 지표 메트릭을 로드합니다.
3. logits, labels = eval_preds: eval_preds는 평가 중에 생성된 모델의 예측값(logits)과 실제 레이블(labels)을 포함하는 튜플입니다.
4. predictions = np.argmax(logits, axis=-1): 모델의 예측값인 logits에서 각 샘플에 대한 최대값을 가진 클래스의 인덱스를 찾아 predictions 배열에 저장합니다.
5. return metric.compute(predictions=predictions, references=labels): 로드한 메트릭을 사용하여 예측값과 실제 레이블을 입력으로 주어 성능 지표를 계산하고 반환합니다.

이렇게 정의된 compute_metrics 함수는 모델을 평가할 때 사용되며, 평가 결과에 대한 성능 지표를 반환합니다. 사용자는 필요에 따라 이 함수를 수정하여 다양한 성능 지표를 계산할 수 있습니다.

 

And to see it used in action to report metrics at the end of each epoch, here is how we define a new Trainer with this compute_metrics() function:

 

그리고 각 에포크가 끝날 때 지표를 보고하기 위해 실제로 사용되는 것을 확인하기 위해 이 Compute_metrics() 함수를 사용하여 새 Trainer를 정의하는 방법은 다음과 같습니다.

 

training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch")
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

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

 

이 코드는 Hugging Face Transformers 라이브러리를 사용하여 모델 훈련을 설정하는 부분입니다. 코드를 단계별로 설명하겠습니다.

 

해석:

1. TrainingArguments("test-trainer", evaluation_strategy="epoch"): 훈련 인자(Training Arguments) 객체를 초기화합니다. 여기서는 훈련의 이름(디렉토리 이름)을 "test-trainer"로 지정하고, evaluation_strategy="epoch"를 통해 검증을 에폭(epoch) 단위로 수행하도록 설정합니다.
2. AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2): 사전 훈련된 모델을 불러오거나 새로운 모델을 초기화합니다. checkpoint는 모델의 체크포인트를 지정하고, num_labels=2는 모델의 출력 클래스의 개수를 나타냅니다. 이 경우에는 이진 분류를 수행하는 모델로서 출력 클래스가 2개인 경우입니다.
3. Trainer(...): 훈련을 관리하는 Trainer 객체를 초기화합니다.
   • model: 훈련에 사용될 모델 객체입니다.
   • training_args: 앞서 초기화한 훈련 인자 객체입니다.
   • train_dataset=tokenized_datasets["train"]: 훈련에 사용될 데이터셋을 지정합니다. 여기서는 토큰화된 훈련 데이터셋을 사용합니다.
   • eval_dataset=tokenized_datasets["validation"]: 모델의 성능을 평가할 때 사용될 검증 데이터셋을 지정합니다.
   • data_collator=data_collator: 데이터 콜레이터 객체를 지정합니다. 이 객체는 배치를 처리하여 패딩을 추가하고 동일한 길이로 만들어주는 역할을 합니다.
   • tokenizer=tokenizer: 토크나이저 객체를 지정합니다. 이 토크나이저는 모델 입력을 토큰화하는 데 사용됩니다.
   • compute_metrics=compute_metrics: 사용자 정의 메트릭을 계산하는 함수를 지정합니다.

이렇게 초기화된 Trainer 객체를 사용하면 모델을 지정된 횟수만큼 데이터셋에 대해 훈련하고, 검증을 에폭 단위로 수행할 수 있습니다. 필요에 따라 추가적인 설정을 적용할 수 있습니다.

 

Note that we create a new TrainingArguments with its evaluation_strategy set to "epoch" and a new model — otherwise, we would just be continuing the training of the model we have already trained. To launch a new training run, we execute:

 

Evaluation_strategy가 "epoch"로 설정된 새로운 TrainingArguments와 새 모델을 생성합니다. 그렇지 않으면 이미 훈련한 모델의 훈련을 계속할 것입니다. 새로운 훈련 실행을 시작하기 위해 다음을 실행합니다.

 

trainer.train()

 

 

This time, it will report the validation loss and metrics at the end of each epoch on top of the training loss. Again, the exact accuracy/F1 score you reach might be a bit different from what we found, because of the random head initialization of the model, but it should be in the same ballpark.

 

이번에는 훈련 손실 외에 각 에포크가 끝날 때마다 검증 손실과 측정항목을 보고합니다. 다시 말하지만, 도달한 정확한 정확도/F1 점수는 모델의 무작위 헤드 초기화로 인해 우리가 찾은 것과 약간 다를 수 있지만 동일한 기준점에 있어야 합니다.

 

The Trainer will work out of the box on multiple GPUs or TPUs and provides lots of options, like mixed-precision training (use fp16 = True in your training arguments). We will go over everything it supports in Chapter 10.

 

Trainer는 여러 GPU 또는 TPU에서 즉시 작동하며 혼합 정밀도 교육과 같은 다양한 옵션을 제공합니다(교육 인수에서 fp16 = True 사용). 10장에서 지원되는 모든 내용을 살펴보겠습니다.

 

This concludes the introduction to fine-tuning using the Trainer API. An example of doing this for most common NLP tasks will be given in Chapter 7, but for now let’s look at how to do the same thing in pure PyTorch.

 

이것으로 Trainer API를 사용한 미세 조정에 대한 소개를 마칩니다. 가장 일반적인 NLP 작업에 대해 이 작업을 수행하는 예는 7장에서 제공되지만 지금은 순수한 PyTorch에서 동일한 작업을 수행하는 방법을 살펴보겠습니다.

 

✏️ Try it out! Fine-tune a model on the GLUE SST-2 dataset, using the data processing you did in section 2.

 

✏️ 한번 사용해 보세요! 섹션 2에서 수행한 데이터 처리를 사용하여 GLUE SST-2 데이터 세트에서 모델을 미세 조정합니다.

 

Summary

 

지난 단원에서는 데이터를 로드하고 미세조정 하기 위해 텍스트 데이터를 토큰화하고 정수화 하고 길이 등을 맞춰 training을 준비 했다면 이번 단원에서는 그 준비된 데이터로 실제 training을 진행하는 과정을 설명 함.

 

Training을 하기 위해서는 Huggingface의 Trainer class를 사용한다.

처음으로 TrainingArguments를 사용해 Arguments를 세팅하고 Trainer를 사용해 지금까지 준비한 모든 것을 Model에 전달하기 위한 정의를 마친다.

그 다음 train() 메소드를 실행하면 실제로 training이 이루어 진다.

training이 끝나면 validation 데이터로 predict을 한다. predict()

그리고 이 predict 한 내용을 evaluate 한다.

 

이것이 전체 training 과정 임.

 

참고로 training() 은 시간이 오래 걸리는데 이 때 더 자세한 정보가 나오도록 하기 위해 compute_metrics() 함수를 만들어 Trainer() 에 추가 했음. (compute() 메소드를 사용해서 추가 정보가 나오도록 했음)

 

def compute_metrics(eval_preds):
    metric = evaluate.load("glue", "mrpc")
    logits, labels = eval_preds
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

training_args = TrainingArguments("test-trainer", evaluation_strategy="epoch")
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

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