오늘은 허깅페이스에 내가 만든 Dataset을 올리는 방법에 대해 소개해드리려고 합니다. 이를 통해 다른 사람들이 업로드한 데이터셋을 사용할 수 있습니다. Dataset을 업로드하려면 허깅페이스 토큰이 필요합니다. 토큰을 발급받지 않은 분들은 여기를 클릭해서 토큰을 발급해주세요

1. 데이터셋 저장할 Repo 만들기
2. 데이터 만들기
3. 데이터 허깅페이스에 업로드하기

코드는 여기에 있습니다.

데이터셋 저장할 Repo 만들기

허깅페이스 홈페이지에 들어갑니다.

위의 이미지와 같이 프로필을 누르고 New Dataset 버튼을 누릅니다.

다음과 같이 저장할 Repo 이름을 작성합니다.

작성을 하고 Create dataset 버튼을 누릅니다.

그러면 다음과 같이 giliit/upload_dataset 이라는 Repo가 생성됩니다.

데이터 만들기

데이터셋을 생성

from datasets import Dataset

# Dataset 객체 생성(train)
sample_train = {'first' : '1', 'second' : '2', 'third' : '3'}
sample_train_dataset = Dataset.from_dict(sample_train)

# type과 dataset 내용 확인
print(type(sample_train_dataset))
print(sample_train_dataset)

# Dataset 객체 생성(test)
sample_test = {'first' : '11', 'second' : '22', 'third' : '33'}
sample_test_dataset = Dataset.from_dict(sample_test)

데이터셋을 Dictionary형태로 생성하고 Dataset에서 from_dict 함수를 통해 데이터셋 객체로 변환을 합니다.

데이터셋 train, test 두 개를 생성했습니다. 

데이터셋을 담는 데이터셋딕셔너리 생성

from datasets import DatasetDict

# datasetDcit 객체 생성
sample_datasetDict = DatasetDict({"train": sample_train_dataset, "test" : sample_test_dataset})

print(type(sample_datasetDict))
print(sample_datasetDict)

데이터셋 허깅페이스에 업로드하기

!huggingface-cli login --token hf_

hf_로 시작하는 토큰을 입력(Write로 써져 있는 Token 발급)

sample_datasetDict.push_to_hub('giliit/upload_dataset', token="hf_")

push_to_hub 함수, Repo와 토큰을 입력하고 함수를 실행합니다.

from datasets import load_dataset

dataset = load_dataset('giliit/upload_dataset')

print(dataset)

load_dataset 함수를 이용해서 데이터셋을 로드해서 확인합니다.

안녕하세요, 오늘은 허깅페이스에서 특정 모델을 읽거나, 데이터나 모델을 업로드하기 위해 필요한 Token을 발급받는 방법에 대해 알려드리려고 합니다. 글의 목차는 다음과 같습니다.

1. 허깅페이스 가입하기
2. 토큰 발급받기
3. 토큰 삭제하기

허깅페이스 가입하기

일단 허깅페이스에 가입하기 위해 허깅페이스 홈페이지를 들어갑니다.

https://huggingface.co/

사진을 보게 되면 우상단에 Sign Up 버튼을 눌러주세요

가입할 이메일과 비밀번호를 입력해주시고 Next 버튼을 눌러주세요

여기서 필요한 정보들을 입력해주세요.  Username과 Full name만 입력하셔도 됩니다. 그리고 Create Account 버튼을 눌러주세요. 그러면 가입이 됩니다.

가입이 끝이 아니라 확인 인증 이메일을 받아서 링크를 클릭해야 합니다. 위에 Resend confirmation email 버튼을 누르면 인증 메일이 갑니다.

다음과 같이 이메일 인증이 오는데 링크를 클릭하시면 됩니다!

토큰 발급하기

가입하고 홈페이지를 들어가면 다음과 같은 화면이 나오는데 여기서 Setting 버튼을 누릅니다.

그리고 오른쪽에 Access Tokens를 누르고, New token을 누릅니다.

Name은 Token 키를 기억하기 위해 작성하는 것이고, Type은 어떤 종류로 사용할 건지 정하는 것입니다.

• Read : 특정 모델을 불러올 때 사용
• Write : 내가 만든 모델 또는 데이터셋을 업로드 할 때 사용

생성하면, 다음과 같이 나옵니다. 이때 오른쪽에 Show 버튼을 누르면 Token을 확인할 수 있습니다. 그리고 Hide를 누르면 안보이게 숨길 수 있습니다.

토큰 삭제하기

Manage 버튼을 누릅니다. Token을 재생성하려면 위의 키를 누르면 되고, Delete 키를 누르면 키를 삭제합니다.

안녕하세요, 오늘은 LLM에서 dictionary를 Chat 형식으로 변환하는 apply_chat_template 함수에 대해 알아보려고 합니다. 이 함수는 최근에 Chat Bot, Chat Model이 많아지면서, Chat 형식으로 변환하는 Tokenizer의 필요로 의해 만들어졌습니다. 그래서 이 함수에 대해 자세히 설명해드리려고 합니다.

선언 방법

사용하는 방법은 쉽습니다. Chat(Dialog)에 대해 apply_chat_template()를 사용하면 바로 출력이 나옵니다. 

from transformers import AutoModelForCausalLM, AutoTokenizer

checkpoint = "HuggingFaceH4/zephyr-7b-alpha"
tokenizer = AutoTokenizer.from_pretrained(checkpoint, cache_dir='/home/hgjeong/hdd1/hub')

messages = [
    {
        "role": "system",
        "content": "You are a friendly chatbot who always responds in the style of a pirate",
    },
    {"role": "user", "content": "How many helicopters can a human eat in one sitting?"},
 ]
 
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")

매개변수 목록

• conversation: Union[List[Dict[str, str]], "Conversation"] : 대화내용입니다.
• add_generation_prompt (bool, optional): 프롬프트의 끝에 모델로부터 응답을 생성하는 데 사용되는 토큰을 추가할지 여부를 결정합니다.
• tokenize (bool, defaults to True): 출력을 토큰화할지 여부를 결정합니다. False인 경우, 출력은 문자열이 됩니다.
• padding (bool, defaults to False): 시퀀스를 최대 길이까지 패딩할지 여부를 결정합니다.
• truncation (bool, defaults to False): 시퀀스를 최대 길이에서 잘라낼지 여부를 결정합니다.
• max_length (int, optional):패딩에 사용할 최대 길이(토큰 단위)를 지정합니다. 지정되지 않은 경우 토크나이저의 max_length 속성이 기본값으로 사용됩니다.
• return_tensors (str or ~utils.TensorType, optional): 특정 프레임워크의 텐서를 반환합니다. 

사용 예시

from transformers import AutoModelForCausalLM, AutoTokenizer

checkpoint = "HuggingFaceH4/zephyr-7b-alpha"
tokenizer = AutoTokenizer.from_pretrained(checkpoint, cache_dir='/home/hgjeong/hdd1/hub')

messages = [
    {
        "role": "system",
        "content": "You are a friendly chatbot who always responds in the style of a pirate",
    },
    {"role": "user", "content": "How many helicopters can a human eat in one sitting?"},
 ]

tokenize 사용 여부

사용하지 않았을 때

tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, return_tensors="pt")
print(tokenized_chat)

### 실행결과
<|system|>
You are a friendly chatbot who always responds in the style of a pirate</s>
<|user|>
How many helicopters can a human eat in one sitting?</s>
<|assistant|>

사용했을 때

tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")
print(tokenized_chat)


### 실행결과 
tensor([[  523, 28766,  6574, 28766, 28767,    13,  1976,   460,   264, 10131,
         10706, 10093,   693,  1743,  2603,  3673,   297,   272,  3238,   302,
           264, 17368,   380,     2, 28705,    13, 28789, 28766,  1838, 28766,
         28767,    13,  5660,  1287, 19624,   410,  1532,   541,   264,  2930,
          5310,   297,   624,  6398, 28804,     2, 28705,    13, 28789, 28766,
           489, 11143, 28766, 28767,    13]])

Text가 토큰화된 것을 확인할 수 있습니다.

add_generation_prompt 사용 여부

사용하지 않았을 때

tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=False, return_tensors="pt")
print(tokenizer.decode(tokenized_chat[0]))


### 실행결과
<|system|>
You are a friendly chatbot who always responds in the style of a pirate</s> 
<|user|>
How many helicopters can a human eat in one sitting?</s>

사용했을 때

ㄷtokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")
print(tokenizer.decode(tokenized_chat[0]))

### 실행 결과
<|system|>
You are a friendly chatbot who always responds in the style of a pirate</s> 
<|user|>
How many helicopters can a human eat in one sitting?</s> 
<|assistant|>

<| assistant |> 가 추가되어 있는 것을 확인할 수 있습니다.

결론

tokenizer에서 apply_chat_template를 이용해서 Chat(Dialog)를 다음과 같이 간편하게 변환할 수 있습니다. 이를 통해서 Chat(Dialog)를 모델에 입력할 때 다음과 같이 사용할 수 있게 있습니다. 감사합니다.

출처

안녕하세요 GPU 사용량에 대해 모니터링할 수 있는 gpustat에 대해 소개해드리려고 합니다. 

다음과 같이 out of memory 문제가 발생했을 때, GPU에 할당받은 메모리에 대해 확인하고 해결할 수 있는 라이브러리가 gpustat입니다.

gpustat이란?

'gpustat'은 NVIDIA GPU의 상태를 실시간으로 모니터링할 수 있는 파이썬 기반의 명령줄 도구입니다. 사용률, 메모리 사용량, 온도와 같은 중요한 정보를 쉽고 빠르게 확인할 수 있어, GPU 리소스를 효과적으로 관리하고자 하는 개발자와 연구자들에게 매우 유용합니다.

gpustat 설치하기

'gpustat'을 사용하기 전에, 파이썬이 설치되어 있어야 하며, 다음 명령어로 손쉽게 설치할 수 있습니다:

pip install gpustat

기본 사용법

설치 후, 터미널에서 gpustat을 입력하기만 하면, 연결된 모든 GPU에 대한 요약 정보를 확인할 수 있습니다

gpustat

다음과 같이 GPU에 할당되어 있는 메모리를 확인할 수 있습니다.

gpustat Arguments

-h, --help: 이 도움말 메시지를 표시하고 종료합니다.
-a, --show-all: 위에 언급된 모든 GPU 속성을 표시합니다.
-f, --show-full-cmd: 실행 중인 프로세스의 전체 명령어와 CPU 통계를 표시합니다.
-u, --show-user: 실행 중인 프로세스의 사용자 이름을 표시합니다.
-p, --show-pid: 실행 중인 프로세스의 프로세스 ID(PID)를 표시합니다.
-F, --show-fan-speed, --show-fan: GPU 팬 속도를 표시합니다.
--json: 모든 정보를 JSON 형식으로 출력합니다.
-i [INTERVAL]: 주어진 경우 watch 모드를 사용하며, 업데이트 사이에 대기할 초를 설정합니다.
-v, --version: 프로그램의 버전 번호를 표시하고 종료합니다.

여러 Arguments 사용

gpustat -cp

 gpustat을 활용하면 이러한 자원을 보다 효율적으로 관리하고, 작업의 성능을 최적화하는 데 도움을 받을 수 있습니다. 이 가이드가 여러분이 GPU 사용 상태를 더욱 쉽게 모니터링하고, GPU 리소스를 효과적으로 관리하는 데 유용합니다.

출처 https://github.com/wookayin/gpustat?tab=readme-ov-file

안녕하세요, 오늘은 PyTorch의 가장 중요한 구성 요소 중 하나인 DataLoader에 대해 자세히 알아보려고 합니다. 이 포스트에서는 DataLoader의 기능, 파라미터, 그리고 실제 사용 예시에 대해 소개해드리려고 합니다.

DataLoader란?

PyTorch의 'DataLoader'는 'Dataset' 클래스의 데이터들을 불러오게 하는 데이터셋 객체입니다. 모든 Dataset은 DataLoader로 생성하며 DataLoader는 모델 훈련을 위한 데이터를 준비하는 과정을 쉽고 효율적으로 만들어 줍니다.

DataLoader를 사용해야하는 이유는 다음과 같습니다.

• 미니배치 : 'DataLoader'은 데이터셋을 미니배치로 나누어 학습을 가능하게 하여 각자의 GPU 환경에 맞춰서 학습할 수 있도록 합니다.
• 데이터 셔플링 : 학습 과정에서 데이터를 무작위로 섞어주는 기능을 제공하여, 일반화 능력을 향상합니다.
• 병렬 데이터 로딩: num_workers 파라미터를 통해 다중 프로세스를 사용하여 데이터 로딩 시간을 단축시킬 수 있습니다. 이는 특히 대규모 데이터셋을 다룰 때 학습 시간을 크게 줄여줍니다.
• 사용자 정의 데이터 처리: collate_fn을 사용하여 배치 데이터를 생성하는 과정에서 사용자 정의 데이터 처리 로직을 적용할 수 있습니다. 이는 다양한 형태의 데이터(예: 이미지의 크기가 다른 경우, 텍스트 데이터의 길이가 다른 경우)를 효과적으로 처리할 수 있게 해 줍니다.
• 데이터 로딩의 유연성: 다양한 소스에서 데이터를 로딩할 수 있는 유연성을 제공합니다. Dataset 추상 클래스를 상속받아 파일 시스템, 데이터베이스, 온라인 소스 등에서 데이터를 쉽게 로딩할 수 있습니다.

DataLoader의 정의

DataLoader(dataset, batch_size=1, shuffle=False, sampler=None,
           batch_sampler=None, num_workers=0, collate_fn=None,
           pin_memory=False, drop_last=False, timeout=0,
           worker_init_fn=None)

주요 파라미터 설명

구현 예제

Dataset 구현 코드

import torch
from torch.utils.data import Dataset

# 사용자 정의 데이터셋 클래스
class CustomDataset(Dataset):

	# 생성자, 데이터를 전처리하는 부분
    def __init__(self, length=100):
        self.data = torch.randn(length, 10)  # 임의의 데이터 생성 (예: 100x10 텐서)
        self.labels = torch.randint(0, 2, (length,))  # 임의의 레이블 생성 (0 또는 1)

	# Dataset 클래스의 길이를 반환
    def __len__(self):
        return len(self.data)

	# 데이터셋의 데이터중 idx위치의 Data를 반환하는 코드
    def __getitem__(self, idx):
        sample = self.data[idx]
        label = self.labels[idx]

        return sample, label
        
# 데이터셋 생성
dataset = CustomDataset()

from torch.utils.data import DataLoader

# DataLoader의 파라미터를 사용하는 예시

# DataLoader 인스턴스 생성
data_loader = DataLoader(
    dataset=dataset,      	# 사용할 데이터셋
    batch_size=24,      	# 배치 사이즈 설정: 한 번에 로드할 데이터의 개수
    shuffle=True,          	# 데이터 셔플링 활성화: 데이터를 무작위로 섞음
    num_workers=4,         	# 병렬 데이터 로딩을 위한 프로세스 수: 데이터 로딩 속도 향상
    drop_last=True         	# 마지막 배치 드롭 설정: 마지막 배치의 데이터 수가 batch_size보다 적을 경우 이를 버릴지 여부
)

# 설명
# batch_size


# DataLoader를 사용하여 데이터 로딩 및 처리 예시
for data, labels in data_loader:
    print(f"Batch shape: {data.shape}, Labels shape: {labels.shape}")

# 실행결과
Batch length: 24, Batch shape: torch.Size([24, 10]), Labels shape: torch.Size([24])
Batch length: 24, Batch shape: torch.Size([24, 10]), Labels shape: torch.Size([24])
Batch length: 24, Batch shape: torch.Size([24, 10]), Labels shape: torch.Size([24])
Batch length: 24, Batch shape: torch.Size([24, 10]), Labels shape: torch.Size([24])

설명

DataLoader에서 Data는 100개를 가지고 있으며 Batch size는 24입니다. Batch size를 24로 설정하면 DataLoader은 24개의 데이터를 담은 미니배치로 분할합니다. 총 데이터는 100개이므로, 이는 DataLoader가 총 5개의 미니배치를 가지며 4개의 미니배치는 24개의 데이터(24 * 4 = 96)와 1개의 미니배치는 4개의 데이터를 갖고 있습니다.

이 때, 데이터셋의 총 크기(100)가 배치 크기(24)로 정확히 나누어 떨어지지 않기 때문에, 마지막 배치는 나머지 데이터로 구성됩니다. 이 경우 마지막 배치에는 4개의 데이터 포인트만 포함됩니다. 'drop_last=True' 파라미터에 의해 마지막 배치는 학습과정에 포함되지 않습니다.

안녕하세요. 오늘은 인공지능과 딥러닝에서 매우 많이 사용하는 PyTorch의 'Dataset'에 대해 자세하게 설명해보려고 합니다. 인공지능과 딥러닝에서 모델을 학습시키기 위해 Data를 처리하는 코드는 복잡하고 유지보수가 어려울 수 있습니다. 이를 위해 PyTorch에서는 더 나은 가독성과 모듈성을 위해 데이터셋 코드를 분리합니다. 

이 글에서 PyTorch의 'Dataset'은 클래스를 직접 구현해 보며 이해해보려고 합니다.

Dataset이란?

PyTorch에서 Dataset은 데이터와 레이블을 저장하고 있으며, 데이터에 쉽게 접근할 수 있도록 도와주는 추상 클래스입니다. 이 클래스를 사용하여 다양한 데이터 소스(예: 파일, 데이터베이스, 메모리 등)에서 데이터를 불러오고, 필요한 전처리 작업을 수행할 수 있습니다. 

요약하자면, Dataset은 샘플과 정답들을 저장하는 클래스라고 생각하시면 됩니다.

기본적으로 Dataset 클래스는 다음 세 가지 메서드를 구현해야 합니다.

• __init__: 필요한 변수들을 선언합니다.  init 함수는 Dataset 객체가 생성될 때 한 번만 실행됩니다.
• __len__: 데이터셋의 총 데이터 개수를 반환합니다
• __getitem__: 주어진 인덱스에 해당하는 샘플을 데이터셋에서 불러와 반환합니다.

구현 예제

import torch
from torch.utils.data import Dataset

# 사용자 정의 데이터셋 클래스
class CustomDataset(Dataset):

	# 생성자, 데이터를 전처리하는 부분
    def __init__(self, length=100):
        self.data = torch.randn(length, 10)  # 임의의 데이터 생성 (예: 100x10 텐서)
        self.labels = torch.randint(0, 2, (length,))  # 임의의 레이블 생성 (0 또는 1)

	# Dataset 클래스의 길이를 반환
    def __len__(self):
        return len(self.data)

	# 데이터셋의 데이터중 idx위치의 Data를 반환하는 코드
    def __getitem__(self, idx):
        sample = self.data[idx]
        label = self.labels[idx]

        return sample, label
        
# 데이터셋 생성
dataset = CustomDataset()

실행결과

>>>len(dataset) # 데이터셋의 길이는 100
100

>>>dataset[0]	# 데이터셋의 첫번째 데이터의 값(샘플, label)
(tensor([ 0.5283, -0.5272, -1.0905,  0.4210,  0.2976, -0.2760, -0.8738,  1.0800,
         -1.9537, -0.2197]), 
tensor(0))

마치며

PyTorch의 Dataset 클래스를 사용하면 다양한 데이터 소스에서 데이터를 효율적으로 불러오고, 전처리하는 과정을 간소화할 수 있습니다. 사용자 정의 Dataset을 만들 때는 __len__과 __getitem__ 메서드를 구현해야 한다는 점을 기억해주세요.

이번 포스팅에서는 허깅페이스 라이브러리를 이용해서 벤치마크 클래스를 만들어보도록 하겠습니다. 클래스에 특정한 벤치마크를 넣어서 한번에 출력하여 모델의 성능을 판단할 수 있습니다.

• 모델 성능 : Acc, F1 등으로 모델의 성능을 파악
• 메모리 : 모델의 파라미터의 양을 파악
• 레이턴시 : 모델이 얼마나 빠르게 예측을 하는지 파악

총 3가지의 벤치마크를 파악하는 클래스를 만들어보겠습니다. 

파이프라인은 텍스트 분류를 통해서 모델의 성능을 벤치마킹하겠습니다.

필요한 모듈 임포트

from transformers import pipeline
from datasets import load_dataset
from pathlib import Path
from time import perf_counter

import torch
import evaluate
import numpy as np

코드를 돌리기 위한 모듈을 모두 임포트 합니다.

모델 호출

# nsmc로 미세 조정된 ELECTRA 호출
model_ckpt = "monologg/koelectra-base-finetuned-nsmc"
pipe = pipeline("text-classification", model=model_ckpt, device="cuda" if torch.cuda.is_available() else "cpu")

nsmc 데이터로 Fine-tuning된 ELECTRA를 통해서 구현해보도록 하겠습니다.

예제 생성

input_data = "지금 매우 흥미로워"
pipe(input_data)

# Output : [{'label': 'positive', 'score': 0.9846755862236023}]

Text에 대해 긍정으로 분류한 것을 볼 수 있습니다.

평가 지표 임포트

accuracy_score = evaluate.load("accuracy")

정확도 지표 임포트 합니다.

라벨 매핑을 위한 클래스 생성

label_str = nsmc.features["label"]

라벨이 str로 되어있어 int로 바꾸기 위한 클래스를 생성합니다.

평가 함수 정의 및 실행

def compute_accuracy(pipeline, dataset):
    preds, labels = [], []
    for example in dataset:
        pred = pipeline(example["document"])[0]['label']
        label = example['label']
        preds.append(label_str.str2int(pred))
        labels.append(label)
    accuracy = accuracy_score.compute(predictions=preds, references=labels)
    print(f"테스트 세트 정확도 - {accuracy['accuracy']:.4f}")
    return accuracy
   
compute_accuracy(pipe, nsmc)

# output : 테스트 세트 정확도 - 0.9027

데이터에 대해 정확도를 평가하는 함수를 정의 및 실행

모델 크기 계산 함수 정의 및 실행

def compute_size(pipeline, dataset):
    state_dict = pipeline.model.state_dict()
    tmp_path = Path("model.pt")
    torch.save(state_dict, tmp_path)
    
    # calculate file size (MB)
    size_mb = Path(tmp_path).state_dict().st_size / (1024 ** 2)
    
    # delete tmp_file
    tmp_path.unlink()
    print(f"모델 사이즈 : {size_mb:.3f} (MB)")
    
    
compute_size(pipe, nsmc)

# output : 모델 사이즈 : 422.629 (MB)

평균 레이턴시 계산 함수 정의 및 실행

def time_pipeline(pipeline,  query="영화 리뷰는 즐겁다"):
    latencies = []
    # warming up
    for _ in range(10):
        _ = pipeline(query)

    # 실행 측정
    for _ in range(100):
        start_time = perf_counter()
        _ = pipeline(query)
        latency = perf_counter() - start_time
        latencies.append(latency)

    # 통계 계산
    time_avg_ms = 1000 * np.mean(latencies)
    time_std_ms = 1000 * np.std(latencies)

    print(f"평균 레이턴시 : {time_avg_ms:.2f} +\- {time_std_ms:.2f} (ms)")

time_pipeline(pipe)

# output : 평균 레이턴시 : 6.01 +\- 0.02 (ms)

실행 함수 정의

 def run_benchmark(self):
        metrics = {}
        metrics[self.optim_type] = self.compute_size()
        metrics[self.optim_type].update(self.time_pipeline())
        metrics[self.optim_type].update(self.compute_accuracy())
        return metrics

벤치마크를 한번에 실행하고 기록할 함수를 정의합니다.

각각의 함수 및 벤치마크  실행함수 클래스화

class PerformanceBenchmark:
    # 초기화 함수
    def __init__(self, pipeline, dataset, optim_type="ELECTRA"):
        self.pipeline = pipeline
        self.dataset = dataset
        self.optim_type = optim_type
        
    # 정확도 계산 함수
    def compute_accuracy(self):
        preds, labels = [], []
        for example in self.dataset:
            pred = self.pipeline(example["document"])[0]['label']
            label = example['label']
            preds.append(label_str.str2int(pred))
            labels.append(label)
        accuracy = accuracy_score.compute(predictions=preds, references=labels)
        print(f"테스트 세트 정확도 - {accuracy['accuracy']:.4f}")
        return accuracy
    
    # 모델 사이즈 계산 함수
    def compute_size(self):
        state_dict = self.pipeline.model.state_dict()
        tmp_path = Path("model.pt")
        torch.save(state_dict, tmp_path)

        # calculate file size (MB)
        size_mb = Path(tmp_path).stat().st_size / (1024 ** 2)

        # delete tmp_file
        tmp_path.unlink()
        print(f"모델 사이즈 : {size_mb:.3f} (MB)")
        return {"size_mb" : size_mb}
    
    def time_pipeline(self,  query="영화 리뷰는 즐겁다"):
        latencies = []
        # warming up
        for _ in range(10):
            _ = self.pipeline(query)

        # 실행 측정
        for _ in range(100):
            start_time = perf_counter()
            _ = self.pipeline(query)
            latency = perf_counter() - start_time
            latencies.append(latency)

        # 통계 계산
        time_avg_ms = 1000 * np.mean(latencies)
        time_std_ms = 1000 * np.std(latencies)
        print(f"평균 레이턴시 : {time_avg_ms:.2f} +\- {time_std_ms:.2f} (ms)")
        return {"time_avg_ms" : time_avg_ms, "time_std_ms": time_std_ms}
        
    def run_benchmark(self):
        metrics = {}
        metrics[self.optim_type] = self.compute_size()
        metrics[self.optim_type].update(self.time_pipeline())
        metrics[self.optim_type].update(self.compute_accuracy())
        return metrics

각각의 함수들을 클래스화 하고 계산한 값들을 return으로 반환합니다.

모델 임포트 및 베치마크 클래스 실행

model_ckpt = "monologg/koelectra-base-finetuned-nsmc"
pipe = pipeline("text-classification", model=model_ckpt,device="cuda")

pb = PerformanceBenchmark(pipe, nsmc)
perf_metrics = pb.run_benchmark()

결과

# 모델 사이즈 : 422.629 (MB)
# 평균 레이턴시 : 6.00 +\- 0.04 (ms)
# 테스트 세트 정확도 - 0.9027

봐주셔서 감사합니다. 오류 있으면 댓글로 부탁드립니다. :)

이번에는 Hugging Face의 datasets.Dataset의 map 함수에 대해서 설명해 드리겠습니다. 이 함수는 Dataset의 요소들에 함수를 적용하기 위해서 사용하는 함수입니다. 이 함수를 통해 data들을 전처리하여 바로 사용하거나 DataLoader에 넘겨서 사용하기도 합니다. 함수에 대해 정의 및 매개변수에 대해 정의하고 사용하는 방법에 대해 소개해드리겠습니다.

정의

from datasets import Dataset

Dataset.map(function= None,
	    batched=False,
            batch_size= 1000,   
            drop_last_batch= False, 
            remove_columns= None,
            num_proc= None)

자주 사용하는 매개변수만 적어보았습니다.

• function = 매핑할 함수
• remove_column = 삭제할 column의 리스트입니다.
• num_proc : 매핑시 사용되는 최대 프로세스의 수입니다.

사용방법

토크나이저를 정의해서 입력을 토큰화하여 전처리하는 과정

from datasets import load_dataset, Dataset

# 데이터셋 정의
dataset = load_dataset("nsmc")
dataset

함수 정의

from transformers import AutoTokenizer

# 토크나이저 정의
tokenizer = AutoTokenizer.from_pretrained("monologg/kobert")

# 매핑할 함수 정의: document를 Tokenize
def process(example):
    processed = {}
    input_data = f'{example["document"]}'
    processed['input_ids'] = tokenizer(input_data,padding="max_length", max_length=256,truncation=True)
    return processed

map 함수 적용

# process 함수로 dataset을 처리, 8개 프로세스 사용, 'id'와 'document' column 삭제
dataset = dataset.map(process, num_proc=8, remove_columns=['id','document'])
dataset

익명함수를 이용한 간단한 매핑방법

from transformers import AutoTokenizer
from datasets import load_dataset

# tokenizer 정의
tokenizer = AutoTokenizer.from_pretrained("monologg/kobert")

# dataset 로드
datasets = load_dataset("nsmc")

# dataset map함수를 lambda함수를 적용
datasets.map(lambda example: tokenizer(example["document"]), num_proc=8, remove_columns=['id','document'])

다음과 같이 적용할 수 있음

num_proc에 따른 실행시간 차이

1. num_proc = 1 

2. num_proc = 4

3. num_proc = 8

4. num_proc = 16

프로세스의 수가 클수록 빨라지지만 메모리 할당까지 생각하면 8이 적당한 것 같습니다. 

읽어주셔서 감사합니다. 오류가 있으면 알려주세요 :)

요즘 딥러닝과 관련해서 파이토치 라이트닝을 다룰일이 많은데 생각보다 한국어로 되어있는 Document, Blog가 너무 적어서 직접 적어보려고 한다. 생각보다 글솜씨가 좋지 않더라도 많은 도움이 되었으면 한다.

파이토치를 사용하는 이유는?

다음과 같은 딥러닝 파이프라인에서 파이토치 라이트닝은 다음과 같은 추상화 계층을 이용해 딥러닝 파이프라인 설계를 매우 간단하게 만들어주기 때문에 사용한다.

• LightningModule은 모델 구조, 훈련 방법, 평가 방법, 테스트 방법, 추론 방법, 옵티마이저 등을 정의하는 클래스이다.
• Trainer은 LightningModule에서 정의한 모델을 훈련 및 평가하는 방법을 추상화한 클래스이다.

간단하게 LightningModule에는 무엇이 있으며 Trainer에는 무엇이 있는지 간단하게 살펴보고 포스팅을 마치려고 합니다.

LightningModule

필수적으로 사용하는 코드 위주로 적었습니다.

Trainer

Trainer에 대해 선언하는 방법과 GPU를 사용하는 방법에 대해서 설명해드리겠습니다.

모델 훈련

model = MyLightningModule()

trainer = Trainer()
# 훈련만 하는 경우
trainer.fit(model, train_dataloader)

# 훈련과 평가를 하는 경우
trainer.fit(model, train_dataloader, val_dataloader)

모델 평가

model = MyLightningModule()

trainer = Trainer()

trainer.validate(model=model, dataloaders=val_dataloaders)

모델  GPU 사용

# CPU 사용
trainer = Trainer(accelerator="cpu")

# Training with GPU Accelerator using 2 GPUs
# 훈련시 GPU 2개를 사용
trainer = Trainer(devices=2, accelerator="gpu")

# Training with TPU Accelerator using 8 tpu cores
# 훈련시 8개의 TPU 사용
trainer = Trainer(devices=8, accelerator="tpu")

# Training with GPU Accelerator using the DistributedDataParallel strategy
# 4개의 GPU를 사용하며, DDP 방식 사용
trainer = Trainer(devices=4, accelerator="gpu", strategy="ddp")

다음에는 파이토치 라이트닝을 이용해서 간단한 인공지능 모델을 만들어보겠습니다.

이번에는 Hugging Face에서 Evaluate 라이브러리 사용하여 모델의 Acc, F1, Rouge 등의 metric을 사용하는 방법에 대해 소개해드리겠습니다.

Evaluate 라이브러리란?

기계 학습(Machine Learning) 및 데이터셋(Dataset)을 쉽게 평가하기 위한 라이브러리 입니다. 간단한 코드로 다양한 작업(NLP Task, Computer Vision 등)을 수십 가지 평가 방법을 적용할수 있습니다.

전체적인 구조는 다음과 같습니다.

Pipeline, Metric과 Dataset을 Evaluator에 넣어서 결과를 도출합니다.

이어서 사용하는 방법에 대해 설명해드리겠습니다.

*코드 환경은 기본적으로 Jupyter Noteboo에서 실행합니다!

evaluate 설치

pip

!pip install evaluate

필요한 모듈 선언

from transformers import pipeline
from datasets import load_dataset
from evaluate import evaluator
import evaluate

각각 필요한 모듈을 선언합니다.

pipeline 구축

pipe = pipeline("text-classification", model="lvwerra/distilbert-imdb", device=0 if torch.cuda.is_available() else "cpu")

1. 텍스트 분류 선언

2. distilbert 기반이며 imdb로 fine-tunnig된 모델 선언

3. gpu가 없다면 cpu 사용

dataset 로드

# imdb dataset 중 test를 가져오며, 랜덤하게 1000개를 선택
data = load_dataset("imdb", split="test").shuffle().select(range(1000))

imdb 데이터셋을 로드합니다. 그리고 섞고  1000개를 랜덤으로 가져옵니다.

metric 로드

metric = evaluate.load("accuracy")

평가에 사용할 것은 accuracy (정확도) 입니다.

evaluator 선언 및 평가

# Task 선언
task_evaluator = evaluator("text-classification")

# model, data 를 이용하여 metric 반환
# label이 숫자가 아닌 str로 구성된다면 0과 1로 각각 매핑
# strategy는 'bootstrap'과 'simple'로 구성되어있습니다.
# n_resamples는 기본적으로 9999 입니다.

results = task_evaluator.compute(model_or_pipeline=pipe, data=data, metric=metric,
                       label_mapping={"NEGATIVE": 0, "POSITIVE": 1},
                       strategy="bootstrap", n_resamples = 200)
# 결과 출력
print(results)
{'accuracy': 
    {
    'confidence_interval': (0.905, 0.939), 
    'standard_error': 0.008500206951033177, 
    'score': 0.923
    }
}

파이프라인  : distilbert를 imdb로 미세 조정한 모델을 바탕으로 text-classification 진행

데이터셋 : imdb

metric : Accuracy

-> imdb로 미세조정된 모델이 imdb를 얼마나 잘 맞추는지 정확도를 산출

감사합니다.