🚀 Google Colab에서 Transformers 모델 학습 시 발생하는 오류 해결

# 현재 GPU 확인
import torch
print(torch.cuda.is_available())    # True면 GPU 사용 가능
print(torch.cuda.get_device_name(0))  # GPU 이름 출력

# 런타임 → 런타임 유형 변경 → GPU 선택

ValueError: metadata-generation-failed

Encountered error while generating package metadata.

See above for output.

note: This is an issue with the package mentioned above, not pip.
hint: See above for details.

# 잘못된 방법
!pip install sklearn

# 올바른 방법
!pip install -U scikit-learn

!pip install transformers torch datasets scikit-learn evaluate accelerate

FileNotFoundError: [Errno 2] No such file or directory: '/content/drive/MyDrive/Dataset/Dataset.json'

from google.colab import drive
drive.mount('/content/drive')

import pandas as pd

# Google Drive에서 파일 읽기
file_path = "/content/drive/MyDrive/Dataset/Dataset.json"
data = pd.read_json(file_path, lines=True)

print(data.head())
print(f"데이터 크기: {data.shape}")

/content/drive/
  MyDrive/          ← 내 드라이브 (본인 파일)
    Dataset/
      Dataset.json
  Shareddrives/     ← 공유 드라이브 (팀 드라이브)

import os

# 경로 존재 확인
path = "/content/drive/MyDrive/Dataset"
if os.path.exists(path):
    print("폴더 존재")
    print(os.listdir(path))
else:
    print("경로 없음 — Drive 마운트 확인 필요")

ValueError: expected sequence of length 128 at dim 1 (got 97)

# 또는
RuntimeError: stack expects each tensor to be equal size, but got [128] at entry 0 and [97] at entry 1

from transformers import DataCollatorWithPadding

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=data_collator,  # 자동 패딩 추가
)

# 전체 토크나이징 예제
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("klue/bert-base")

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,     # 최대 길이 초과 시 자름
        max_length=128,      # 최대 토큰 길이
        # padding은 여기서 하지 않고 DataCollator에서 동적으로 처리
    )

tokenized_dataset = dataset.map(tokenize_function, batched=True)

wandb: (1) Create a W&B account
wandb: (2) Use an existing W&B account
wandb: (3) Don't visualize my results
wandb: Enter your choice:

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    report_to="none"  # wandb 비활성화
)

import os
os.environ["WANDB_DISABLED"] = "true"

import wandb
wandb.login(key="your_api_key_here")

RuntimeError: CUDA out of memory. Tried to allocate 2.00 GiB
(GPU 0; 14.76 GiB total capacity; 12.54 GiB already allocated;
1.20 GiB free; 12.67 GiB reserved in total by PyTorch)

training_args = TrainingArguments(
    output_dir="./results",
    per_device_train_batch_size=4,     # 8 → 4로 줄임
    gradient_accumulation_steps=4,     # 4번 누적해서 실질적으로 배치 16 효과
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    report_to="none",
)

training_args = TrainingArguments(
    output_dir="./results",
    per_device_train_batch_size=4,
    gradient_checkpointing=True,  # 중간 activation을 저장하지 않고 재계산
    fp16=True,                    # 16비트 부동소수점으로 메모리 절반 절약
    report_to="none",
)

training_args = TrainingArguments(
    output_dir="./results",
    fp16=True,   # float32 → float16 (메모리 절반, 속도 1.5~2배)
    # bf16=True, # A100 GPU에서는 bfloat16이 더 안정적
    report_to="none",
)

import torch
import gc

# GPU 캐시 비우기
torch.cuda.empty_cache()

# Python 가비지 컬렉터 실행
gc.collect()

# 현재 GPU 메모리 상태 확인
print(f"할당된 메모리: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")
print(f"캐시된 메모리: {torch.cuda.memory_reserved() / 1024**3:.2f} GB")

from google.colab import drive
drive.mount('/content/drive')

training_args = TrainingArguments(
    # Google Drive에 체크포인트 저장
    output_dir="/content/drive/MyDrive/model_checkpoints",
    
    # 매 에폭마다 저장
    save_strategy="epoch",
    evaluation_strategy="epoch",
    
    # 최대 3개 체크포인트만 보관 (디스크 절약)
    save_total_limit=3,
    
    # 가장 좋은 모델 자동 선택
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    
    report_to="none",
)

# 마지막 체크포인트 경로 확인
import os
checkpoint_dir = "/content/drive/MyDrive/model_checkpoints"
checkpoints = [d for d in os.listdir(checkpoint_dir) if d.startswith("checkpoint")]
latest_checkpoint = sorted(checkpoints)[-1]
checkpoint_path = os.path.join(checkpoint_dir, latest_checkpoint)

print(f"이어 학습할 체크포인트: {checkpoint_path}")

# 체크포인트에서 이어 학습
trainer.train(resume_from_checkpoint=checkpoint_path)

// 브라우저 콘솔에서 실행
function ClickConnect(){
  console.log("연결 유지 클릭");
  document.querySelector("colab-connect-button").click()
}
setInterval(ClickConnect, 60000)  // 1분마다 실행

ValueError: You are trying to use a fast tokenizer, which is not supported by this model.
# 또는
RuntimeError: The size of tensor a (30522) must match the size of tensor b (32000)
    at non-singleton dimension 1

from transformers import AutoTokenizer, AutoModelForSequenceClassification

model_name = "klue/bert-base"  # 동일한 모델 이름 사용

# 올바른 방법: 같은 이름으로 로드
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=2  # 분류할 클래스 수
)

# 잘못된 방법: 다른 모델의 토크나이저 사용
# tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")  # 영문 BERT
# model = AutoModelForSequenceClassification.from_pretrained("klue/bert-base")  # 한국어 BERT

KeyError: 'label'
# 또는
ValueError: The model did not return a loss from the inputs,
only the following keys: logits. For reference, the inputs it received are: input_ids, attention_mask.

import pandas as pd
from datasets import Dataset

# 원본 데이터 (컬럼명이 다를 수 있음)
df = pd.DataFrame({
    "review": ["정말 좋아요", "별로예요", "괜찮네요"],
    "sentiment": [1, 0, 1]
})

# 컬럼명을 Trainer가 기대하는 이름으로 변경
df = df.rename(columns={
    "review": "text",
    "sentiment": "label"
})

# Pandas DataFrame을 HuggingFace Dataset으로 변환
dataset = Dataset.from_pandas(df)
print(dataset)
# Dataset({
#     features: ['text', 'label'],
#     num_rows: 3
# })

from datasets import Dataset, DatasetDict

# 80/20 분리
split = dataset.train_test_split(test_size=0.2, seed=42)
dataset_dict = DatasetDict({
    "train": split["train"],
    "test": split["test"],
})

print(dataset_dict)

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        max_length=128,
    )

tokenized_dataset = dataset_dict.map(
    tokenize_function,
    batched=True,
    remove_columns=["text"],  # 원본 텍스트 컬럼 제거 (Trainer가 모르는 컬럼 제거)
)

print(tokenized_dataset["train"].column_names)
# ['label', 'input_ids', 'attention_mask', 'token_type_ids']

# 학습 중 진행 상황 출력으로 "활성 상태" 신호 보내기
from transformers import TrainerCallback

class ProgressCallback(TrainerCallback):
    def on_epoch_end(self, args, state, control, **kwargs):
        print(f"에폭 {state.epoch:.0f}/{args.num_train_epochs} 완료")
        print(f"현재 손실: {state.log_history[-1].get('loss', 'N/A')}")

# 학습 완료 후 Drive에 저장
save_path = "/content/drive/MyDrive/my_model"
model.save_pretrained(save_path)
tokenizer.save_pretrained(save_path)
print(f"모델 저장 완료: {save_path}")

# GPU 메모리에 맞는 최대 배치 크기 찾기
def find_max_batch_size(model, tokenizer, start=32):
    batch_size = start
    while batch_size > 1:
        try:
            # 테스트 배치로 Forward pass 시도
            inputs = tokenizer(
                ["테스트 문장"] * batch_size,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=128
            ).to("cuda")
            with torch.no_grad():
                model(**inputs)
            print(f"배치 크기 {batch_size}: 성공")
            return batch_size
        except RuntimeError:
            batch_size //= 2
            print(f"OOM 발생 → 배치 크기 {batch_size}로 줄임")
            torch.cuda.empty_cache()
    return 1

# 실시간 GPU 메모리 확인
def print_gpu_status():
    if torch.cuda.is_available():
        allocated = torch.cuda.memory_allocated() / 1024**3
        reserved = torch.cuda.memory_reserved() / 1024**3
        total = torch.cuda.get_device_properties(0).total_memory / 1024**3
        print(f"GPU 메모리 — 사용: {allocated:.2f}GB / 캐시: {reserved:.2f}GB / 총: {total:.2f}GB")
    else:
        print("GPU 없음 (CPU 모드)")

print_gpu_status()

# ===== 1. 라이브러리 설치 =====
# !pip install transformers torch datasets scikit-learn evaluate accelerate

# ===== 2. 필요 라이브러리 임포트 =====
import os
import torch
import numpy as np
import pandas as pd
from datasets import Dataset, DatasetDict
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer,
    DataCollatorWithPadding,
)
import evaluate

# ===== 3. Google Drive 마운트 =====
from google.colab import drive
drive.mount('/content/drive')

# ===== 4. GPU 확인 =====
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"사용 디바이스: {device}")
if device == "cuda":
    print(f"GPU: {torch.cuda.get_device_name(0)}")

# ===== 5. 데이터 준비 =====
# 예시: Naver 영화 리뷰 데이터셋
# 실제로는 자신의 데이터를 사용하거나 HuggingFace datasets에서 로드
file_path = "/content/drive/MyDrive/Dataset/nsmc_train.txt"

try:
    df = pd.read_csv(file_path, sep="\t")
    df = df.dropna()  # 결측값 제거
    df = df.rename(columns={"document": "text", "label": "label"})
    print(f"데이터 로드 완료: {df.shape}")
    print(df.head())
except FileNotFoundError:
    # 샘플 데이터로 대체
    print("파일 없음 — 샘플 데이터 사용")
    df = pd.DataFrame({
        "text": [
            "정말 재미있는 영화였어요", "별로였어요 시간 낭비",
            "최고의 작품입니다", "기대 이하였습니다",
            "강력 추천합니다", "다시는 안 볼 거예요",
        ],
        "label": [1, 0, 1, 0, 1, 0]
    })

# ===== 6. Dataset 객체 생성 및 분리 =====
dataset = Dataset.from_pandas(df[["text", "label"]])
split = dataset.train_test_split(test_size=0.1, seed=42)
dataset_dict = DatasetDict({
    "train": split["train"],
    "validation": split["test"],
})
print(f"학습: {len(dataset_dict['train'])}개, 검증: {len(dataset_dict['validation'])}개")

# ===== 7. 토크나이저 및 모델 로드 =====
model_name = "klue/bert-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=2,
)
model = model.to(device)

# ===== 8. 토크나이징 =====
def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        max_length=128,
    )

tokenized_dataset = dataset_dict.map(
    tokenize_function,
    batched=True,
    remove_columns=["text"],
)
print("토크나이징 완료")
print(tokenized_dataset)

# ===== 9. Data Collator 설정 =====
data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

# ===== 10. 평가 함수 설정 =====
accuracy_metric = evaluate.load("accuracy")
f1_metric = evaluate.load("f1")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    accuracy = accuracy_metric.compute(
        predictions=predictions, references=labels
    )["accuracy"]
    f1 = f1_metric.compute(
        predictions=predictions, references=labels, average="binary"
    )["f1"]
    return {"accuracy": accuracy, "f1": f1}

# ===== 11. 학습 설정 =====
output_dir = "/content/drive/MyDrive/sentiment_model"

training_args = TrainingArguments(
    output_dir=output_dir,
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    learning_rate=2e-5,
    weight_decay=0.01,
    warmup_ratio=0.1,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    fp16=(device == "cuda"),           # GPU에서만 fp16 사용
    gradient_accumulation_steps=2,
    save_total_limit=2,
    report_to="none",                  # wandb 비활성화
    logging_steps=50,
)

# ===== 12. Trainer 초기화 및 학습 =====
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["validation"],
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
)

print("학습 시작!")
trainer.train()

# ===== 13. 최종 평가 =====
results = trainer.evaluate()
print(f"\n최종 평가 결과:")
print(f"  Accuracy: {results['eval_accuracy']:.4f}")
print(f"  F1 Score: {results['eval_f1']:.4f}")

# ===== 모델 저장 =====
save_path = "/content/drive/MyDrive/sentiment_model_final"

# 모델 가중치 저장
model.save_pretrained(save_path)

# 토크나이저 저장 (추론 시 필요)
tokenizer.save_pretrained(save_path)

print(f"모델 저장 완료: {save_path}")
print(f"저장된 파일: {os.listdir(save_path)}")
# ['config.json', 'model.safetensors', 'tokenizer.json', 'tokenizer_config.json', ...]

# ===== 모델 불러오기 =====
from transformers import pipeline

# 저장된 모델로 파이프라인 생성
classifier = pipeline(
    "text-classification",
    model=save_path,
    tokenizer=save_path,
    device=0 if device == "cuda" else -1,
)

# 추론 테스트
test_texts = [
    "이 영화 정말 감동적이었어요!",
    "돈이 아까운 영화였습니다.",
    "배우들 연기가 최고였어요.",
]

for text in test_texts:
    result = classifier(text)
    label = "긍정" if result[0]["label"] == "LABEL_1" else "부정"
    score = result[0]["score"]
    print(f"'{text}' → {label} ({score:.2%})")

# ===== Hub에 업로드 =====
from huggingface_hub import notebook_login

# HuggingFace 로그인 (토큰 필요: https://huggingface.co/settings/tokens)
notebook_login()

# 모델 업로드
model.push_to_hub("your-username/klue-bert-sentiment")
tokenizer.push_to_hub("your-username/klue-bert-sentiment")

print("HuggingFace Hub 업로드 완료!")
print("모델 주소: https://huggingface.co/your-username/klue-bert-sentiment")

from transformers import pipeline

classifier = pipeline(
    "text-classification",
    model="your-username/klue-bert-sentiment"
)
result = classifier("정말 재미있는 영화였어요!")