허깅페이스 트렌스포머 활용강좌, 데이터세트 클래스 생성

이번 강좌에서는 허깅페이스(Hugging Face)트랜스포머(Transformers) 라이브러리를 활용하여 데이터세트 클래스를 생성하는 방법에 대해 다룰 것입니다. 허깅페이스 트랜스포머는 자연어 처리(NLP) 작업을 위한 필수 도구 중 하나로, 다양한 사전 훈련된 모델과 데이터셋을 제공합니다. 이러한 모델을 효과적으로 활용하기 위해서는 사용자 정의 데이터세트를 생성하는 것이 중요합니다.

1. 허깅페이스 트랜스포머란?

허깅페이스 트랜스포머 라이브러리는 머신러닝의 자연어 처리 분야에서 가장 많이 사용되는 라이브러리 중 하나로, BERT, GPT-2, T5와 같은 최신 모델을 포함하고 있습니다. 이 라이브러리는 모델의 훈련, 미세 조정(fine-tuning), 예측 등을 간편하게 구현할 수 있도록 도와줍니다.

2. 데이터셋 클래스란?

데이터셋 클래스는 모델 훈련 및 평가에 사용될 데이터의 구조를 정의하는 클래스입니다. 데이터셋 클래스를 사용하면 사용자 정의 데이터를 쉽게 로드하고 전처리할 수 있습니다. 허깅페이스 트랜스포머에서는 datasets 라이브러리를 통해 데이터를 쉽게 다룰 수 있는 기능을 제공합니다.

3. 데이터셋 클래스 생성 방법

이번 섹션에서는 Python을 사용하여 데이터셋 클래스를 생성하는 방법을 다루겠습니다. 구체적으로는 torch.utils.data.Dataset 클래스를 상속받아 사용자 정의 데이터셋 클래스를 만들고 이를 허깅페이스 트랜스포머와 통합하는 방법을 설명하겠습니다.

3.1 준비하기

먼저, 필요한 라이브러리를 설치하고 임포트합니다. 아래의 코드를 사용하여 transformersdatasets 라이브러리를 설치합니다.

!pip install transformers datasets torch

3.2 사용자 정의 데이터셋 클래스 만들기

여기에서 데이터셋 클래스를 생성하는 방법을 보여드리겠습니다.

import torch
from torch.utils.data import Dataset

class MyDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=512):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]

        # 토큰화 및 인덱스 변환
        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_length,
            return_token_type_ids=False,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt'
        )

        return {
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

위의 클래스는 텍스트와 라벨을 입력으로 받아서 해당 텍스트를 토큰화 하고 라벨을 텐서로 반환하는 데이터셋입니다. torch.utils.data.Dataset 클래스를 상속받아 __len____getitem__ 메소드를 구현하였습니다.

3.3 데이터셋 사용하기

이제 사용자 정의 데이터셋을 어떻게 사용할 수 있는지 살펴봅시다. 데이터를 준비하고 데이터로더를 생성하는 예는 다음과 같습니다.

from transformers import AutoTokenizer

# 토크나이저 준비
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

# 데이터 준비
texts = ["Hello, how are you?", "I am fine, thank you."]
labels = [0, 1] # 예시 라벨

# 데이터셋 인스턴스 생성
dataset = MyDataset(texts, labels, tokenizer)

# 데이터 로더 생성
from torch.utils.data import DataLoader

dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

for batch in dataloader:
    print(batch)

위 코드는 작은 데이터셋을 만든 후에 데이터로더를 생성하여 배치 단위로 데이터를 반환하는 예입니다. 데이터 로더는 훈련 중 데이터 샘플을 무작위로 선택하여 배치 단위로 반환할 수 있게 해줍니다.

4. 데이터셋 클래스 확장

이제 사용자 정의 데이터셋 클래스를 확장하여 여러 기능을 추가하는 방법을 보여드리겠습니다. 예를 들어, 데이터 전처리 과정 추가, 여러 형식의 입력을 처리하기 등 다양한 기능을 포함할 수 있습니다.

4.1 데이터 전처리

데이터 전처리는 모델의 성능을 높이는 중요한 단계입니다. 필요한 경우, __init__ 메소드에 전처리 기능을 구현할 수 있습니다.

def preprocess(self, text):
        # 여기에 전처리 로직을 추가하세요
        return text.lower().strip()

이 메소드를 __getitem__에서 호출하여 데이터를 반환하기 전에 전처리를 수행할 수 있습니다.

4.2 여러 형식의 입력 처리

데이터셋이 다양한 입력 형식을 처리해야 할 경우 조건문을 사용하여 다르게 처리할 수 있습니다. 입력 텍스트의 형식에 따라 조건을 추가하면 됩니다.

if isinstance(text, list):
    text = " ".join(text)  # 리스트 텍스트 합치기

5. 결론

이번 강좌에서는 허깅페이스 트랜스포머의 데이터셋 클래스를 생성하고 사용하는 방법을 알아보았습니다. 사용자 정의 데이터셋은 모델 훈련 및 평가에 있어 매우 중요한 요소입니다. 이를 통해 우리는 다양한 형식의 데이터를 효율적으로 처리하고, 원하는 방식으로 모델을 훈련할 수 있습니다.

앞으로 더 많은 자연어 처리 문제를 해결하기 위해 허깅페이스를 활용해 보세요. 그리고 자신만의 데이터셋 클래스를 만들어 보며 실력을 쌓아보시기 바랍니다. 감사합니다!

허깅페이스 트렌스포머 활용강좌, 구글 코랩 환경 설정

딥러닝과 자연어 처리(NLP)의 발전에 따라 효율적이고 강력한 변환 모델들이 등장하였습니다. 그 중 하나가 허깅페이스(Hugging Face)의 트랜스포머(transformers) 라이브러리입니다. 이 강좌에서는 구글 코랩 환경에서 허깅페이스의 트랜스포머 라이브러리를 사용하는 방법과 기본적인 예제, 그리고 실제 코드 활용 방법에 대해 설명하겠습니다.

1. 허깅페이스 트랜스포머란?

허깅페이스 트랜스포머 라이브러리는 다양한 최첨단 자연어 처리(NLP) 모델을 제공하는 오픈 소스 라이브러리입니다. BERT, GPT-2, RoBERTa, T5 등과 같은 모델을 쉽게 사용할 수 있으며, 이러한 모델들은 사전 훈련(pre-trained)되어 있어, 적은 데이터로도 높은 성능을 낼 수 있습니다. 이 라이브러리는 PyTorch와 TensorFlow 두 가지의 딥러닝 프레임워크를 지원합니다.

2. 구글 코랩 개요

구글 코랩(Google Colaboratory)은 클라우드 기반의 Jupyter 노트북 서비스입니다. 무료 GPU 리소스를 제공하여 사용자가 딥러닝 모델을 훈련하고 실행하기에 매우 유용한 환경을 제공합니다. 이 과정을 통해 구글 코랩을 활용하여 허깅페이스 트랜스포머 라이브러리를 사용하는 방법을 배워보겠습니다.

3. 구글 코랩 환경 설정하기

3.1 구글 코랩 접속하기

구글 코랩에 접속하려면 웹 브라우저에서 Google Colab을 방문하십시오. 구글 계정으로 로그인하면 새로운 노트북을 만들 수 있는 화면이 나타납니다.

3.2 새로운 노트북 만들기

오른쪽 상단의 ‘새 노트북(New Notebook)’ 버튼을 클릭하여 새로운 Jupyter 노트북을 생성합니다. 노트북의 이름을 설정하여 작업을 구분해줍니다.

3.3 런타임 유형 설정하기

구글 코랩에서는 GPU를 사용하여 모델을 훈련할 수 있습니다. 이를 위해 상단 메뉴에서 런타임(> Runtime) -> 런타임 유형 변경(> Change runtime type)을 선택합니다. ‘하드웨어 가속기(Hardware accelerator)’에서 ‘GPU’를 선택한 후 저장(Save) 버튼을 클릭합니다.

4. 허깅페이스 트랜스포머 라이브러리 설치하기

이제 코랩 환경에서 허깅페이스 트랜스포머 라이브러리를 설치해야 합니다. 아래의 코드를 입력하고 실행하여 라이브러리를 설치합니다.

!pip install transformers

5. 기본적인 활용 예시

설치가 완료되면 허깅페이스의 트랜스포머 라이브러리를 활용하여 텍스트 분류 작업을 수행해보겠습니다.

5.1 라이브러리 임포트 및 모델 초기화

import torch
from transformers import BertTokenizer, BertForSequenceClassification

# BERT 모델과 토크나이저 초기화
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

5.2 입력문장 토크나이징 및 예측 수행

모델에 입력할 문장을 정의하고 이를 토크나이징하여 예측을 수행합니다.

# 입력 문장 정의
input_sentence = "I love programming with Python!"

# 문장을 토크나이징
inputs = tokenizer(input_sentence, return_tensors="pt")

# 모델 예측
with torch.no_grad():
    logits = model(**inputs).logits

# 예측 결과 출력
predicted_class = torch.argmax(logits, dim=1)
print(f"Predicted class: {predicted_class.item()}")

6. 결론

이번 강좌에서는 구글 코랩에서 허깅페이스 트랜스포머 라이브러리를 활용하는 방법에 대해 알아보았습니다. 환경 설정부터 기본적인 텍스트 분류 예제까지 모든 과정을 수행해보았으며, 이를 통해 NLP 모델을 쉽게 사용할 수 있는 방법을 배웠습니다. 허깅페이스의 트랜스포머 라이브러리는 다른 많은 기능도 제공하므로, 이를 바탕으로 다양한 프로젝트를 진행할 수 있을 것입니다.

7. 참고 자료

허깅페이스 트렌스포머 활용강좌, 다중 클래스 분류용 BERT 사전학습 모델 불러오기

다중 클래스 분류용 BERT 사전학습 모델 불러오기

BERT(Bidirectional Encoder Representations from Transformers)는 구글에서 제안한 자연어 처리 모델로, 문맥 이해를 위해 양방향 Transformer 구조를 활용합니다. BERT는 사전 학습(pre-training) 및 미세 조정(fine-tuning) 단계를 통해 다양한 자연어 처리 태스크에 적용될 수 있습니다. 이번 강좌에서는 허깅페이스(Hugging Face) 트랜스포머 라이브러리를 사용하여 사전학습된 BERT 모델을 불러와 다중 클래스 분류 문제를 해결하는 방법을 소개하겠습니다.

1. 환경 설정

본 강좌에서는 다음의 라이브러리가 필요합니다:

  • transformers
  • torch (PyTorch)
  • numpy
  • pandas

다음 명령어를 통해 필요한 라이브러리를 설치할 수 있습니다:

!pip install transformers torch numpy pandas

2. 데이터 준비

우선, 다중 클래스 분류 문제를 위한 데이터셋을 준비해야 합니다. 예시로, 간단한 텍스트와 라벨을 가진 데이터프레임을 만들어 보겠습니다.

import pandas as pd

data = {
    'text': [
        '나는 자연어 처리가 좋아요.',
        'PyTorch와 TensorFlow가 인기 있어요.',
        '딥러닝은 머신러닝의 한 분야입니다.',
        '대화형 AI는 많은 관심을 받고 있어요.',
        '텍스트 분류는 중요한 작업입니다.'
    ],
    'label': [0, 1, 1, 2, 0]
}

df = pd.DataFrame(data)

3. 데이터 전처리

BERT 모델의 입력 형식에 맞게 데이터를 전처리합니다. BERT Tokenizer를 사용하여 텍스트를 토큰화하고, 입력 아이디와 어텐션 마스크를 생성합니다.

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# 토큰화 및 입력 아이디, 어텐션 마스크 생성
def encode_data(text):
    return tokenizer(text, padding='max_length', truncation=True, max_length=128, return_tensors='pt')

encoded_texts = [encode_data(text)['input_ids'] for text in df['text']]
attention_masks = [encode_data(text)['attention_mask'] for text in df['text']]

4. 데이터셋 분할

데이터를 학습용과 검증용으로 분할합니다. 여기서는 데이터의 80%를 학습 데이터로, 20%를 검증 데이터로 사용합니다.

from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(
    df['text'],
    df['label'],
    test_size=0.2,
    random_state=42
)

5. 데이터 로더 생성

PyTorch의 DataLoader를 사용하여 배치 처리를 위한 데이터 로더를 생성합니다.

import torch
from torch.utils.data import Dataset, DataLoader

class TextDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts = texts
        self.labels = labels

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        text = encode_data(self.texts[idx])
        return {
            'input_ids': text['input_ids'].squeeze(),
            'attention_mask': text['attention_mask'].squeeze(),
            'labels': torch.tensor(self.labels[idx])
        }

train_dataset = TextDataset(X_train.tolist(), y_train.tolist())
val_dataset = TextDataset(X_val.tolist(), y_val.tolist())

train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=2, shuffle=False)

6. 모델 불러오기

허깅페이스의 Transformers 라이브러리에서 사전 학습된 BERT 모델을 불러옵니다. 여기에 분류기를 추가하여 다중 클래스 분류 문제를 해결합니다.

from transformers import BertForSequenceClassification

model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=3)

7. 모델 학습

모델을 학습하기 위해 오차 함수와 최적화 알고리즘을 설정하고, 단순한 학습 루프를 작성해 봅니다.

from transformers import AdamW
from tqdm import tqdm

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

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

# 모델 학습
model.train()
for epoch in range(3):  # 에포크 수
    for batch in tqdm(train_loader):
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

    print(f'Epoch {epoch+1} Loss: {loss.item()}')

8. 검증 및 성능 평가

검증 데이터를 사용하여 모델의 성능을 평가합니다. 여기서는 정확도를 측정합니다.

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch in val_loader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        outputs = model(input_ids, attention_mask=attention_mask)
        _, predicted = torch.max(outputs.logits, dim=1)

        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = correct / total
print(f'Accuracy: {accuracy:.2f}') 

9. 결론

이번 강좌에서는 허깅페이스 트랜스포머 라이브러리를 이용하여 사전 학습된 BERT 모델을 다중 클래스 분류 문제에 활용하는 방법을 배웠습니다. BERT는 강력한 성능을 보이므로, 분석하고자 하는 많은 자연어 처리 문제에 적용할 수 있습니다. 실제 프로젝트에 사용하는 과정에서 여러 실험과 튜닝을 통해 최적의 결과를 얻을 수 있도록 해야 합니다. 트렌스포머 모델들은 빠르게 발전하고 있으므로, 지속적인 학습이 필요합니다.

더 궁금한 점이 있다면 언제든지 질문해 주세요!

허깅페이스 트렌스포머 활용강좌, 감성 분석

이번 글에서는 자연어 처리(NLP)에서 자주 사용되는 허깅페이스 트랜스포머(Hugging Face Transformers) 라이브러리를 활용하여 감성 분석을 수행하는 방법에 대해 알아보겠습니다. 감성 분석은 텍스트 데이터를 통해 감정이나 감성을 추출하는 기술로, 다양한 분야에서 유용하게 사용됩니다.

1. 허깅페이스 트랜스포머란?

허깅페이스 트랜스포머 라이브러리는 다양한 사전 학습된 자연어 처리 모델을 쉽게 사용할 수 있게 해주는 파이썬 라이브러리입니다. BERT, GPT-2, T5 등 여러 종류의 모델을 지원하며, 특히 Fine-tuning이 용이하여 다양한 작업에 맞게 모델을 조정할 수 있습니다.

2. 감성 분석의 개요

감성 분석은 주로 아래와 같은 작업을 포함합니다:

  • 문서의 전반적인 감정 상태(긍정, 부정, 중립)
  • 제품 리뷰의 세부 감정
  • 소셜 미디어 포스트의 감정 추적

감성 분석은 머신러닝, 딥러닝의 기법을 통해 구현할 수 있으며, 학습 데이터의 품질과 양이 결과에 큰 영향을 미칩니다.

3. 환경 설정

이 강좌를 진행하기 위해 필요한 라이브러리를 설치하겠습니다. 아래의 명령어를 사용하여 허깅페이스 트랜스포머와 토큰화 라이브러리인 transformerstorch를 설치하세요.

pip install transformers torch

4. 데이터셋 준비하기

감성 분석을 위한 데이터셋으로는 유명한 IMDb 영화 리뷰 데이터셋을 사용할 것입니다. 이 데이터셋은 영화에 대한 긍정적 또는 부정적인 리뷰를 포함하고 있습니다.

from sklearn.datasets import fetch_openml

data = fetch_openml('IMDb', version=1)
texts, labels = data['data'], data['target']

5. 데이터 전처리

데이터를 모델에 입력할 수 있도록 전처리하겠습니다. 텍스트를 정제하고, 레이블을 숫자로 변환하는 과정이 필요합니다.

import pandas as pd

df = pd.DataFrame({'text': texts, 'label': labels})
df['label'] = df['label'].apply(lambda x: 1 if x == 'pos' else 0)
texts = df['text'].tolist()
labels = df['label'].tolist()

6. 모델 불러오기

감성 분석을 위한 사전 학습된 BERT 모델을 불러오겠습니다. 또한, 텍스트를 토큰화하고 모델에 입력할 수 있는 형식으로 변환합니다.

from transformers import AutoTokenizer, AutoModelForSequenceClassification

model_name = 'nlptown/bert-base-multilingual-uncased-sentiment'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

7. 텍스트 토큰화

모델에 입력할 수 있도록 텍스트를 토큰화합니다. 각 리뷰를 모델에 입력하기 위해서 적절한 형태로 변환하는 과정입니다.

encodings = tokenizer(texts, truncation=True, padding=True, max_length=128, return_tensors="pt")

8. 모델 학습

모델을 학습시키기 위해서는 주어진 데이터로 Fine-tuning을 수행해야 합니다. 이제 PyTorch의 데이터 로더를 사용하여 데이터셋을 구성하겠습니다.

import torch
from torch.utils.data import DataLoader, Dataset

class SentimentDataset(Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

dataset = SentimentDataset(encodings, labels)
train_loader = DataLoader(dataset, batch_size=16, shuffle=True)

9. 모델 훈련

모델을 훈련하기 위해 손실 함수와 옵티마이저를 정의하고, 에포크에 걸쳐 훈련을 진행합니다.

from transformers import AdamW

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

model.train()
for epoch in range(3):
    for batch in train_loader:
        optimizer.zero_grad()
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        print(f'Epoch: {epoch}, Loss: {loss.item()}')

10. 모델 평가

모델을 평가하여 성능을 확인해보겠습니다. 검증 데이터셋을 사용하여 정확도와 손실을 측정합니다.

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for batch in train_loader:
        outputs = model(**batch)
        predictions = outputs.logits.argmax(dim=-1)
        correct += (predictions == batch['labels']).sum().item()
        total += batch['labels'].size(0)

accuracy = correct / total
print(f'Accuracy: {accuracy}')

11. 예측하기

모델이 학습이 완료되면 새로운 데이터에 대한 예측을 진행할 수 있습니다. 아래는 실제 예측을 하는 예제 코드입니다.

def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True, max_length=128)
    with torch.no_grad():
        outputs = model(**inputs)
    prediction = outputs.logits.argmax(dim=-1)
    return '긍정' if prediction.item() == 1 else '부정'

test_text = "이 영화는 정말 재미있었습니다!"
print(f'예측: {predict_sentiment(test_text)}')

12. 결론

이 글에서는 허깅페이스 트랜스포머 라이브러리를 활용하여 감성 분석을 수행하는 전 과정을 살펴보았습니다. 모델을 Fine-tuning하고 실제 데이터를 예측하는 과정을 통해 딥러닝 모델의 활용 가능성을 확인할 수 있었습니다. 앞으로도 다양한 자연어 처리 작업에 허깅페이스 트랜스포머를 응용할 수 있을 것입니다.

13. 참고 문헌

허깅페이스 트렌스포머 활용강좌, Wav2Vec2 자동 음성 인식 실행

오늘은 허깅페이스(Hugging Face)에서 제공하는 트렌스포머(Transformers) 라이브러리를 활용하여 Wav2Vec2 모델을 이용한 자동 음성 인식(ASR) 기능을 구현해보겠습니다. Wav2Vec2는 음성 인식 모델로, 연속 음성 인식에서 뛰어난 성능을 보이는 최신 딥러닝 모델 중 하나입니다. 우리는 이 모델을 사용하여 음성 데이터를 텍스트로 변환하는 과정을 자세히 알아보겠습니다.

1. Wav2Vec2 모델 이해하기

Wav2Vec2는 Facebook AI에서 개발한 음성 인식 모델입니다. 이 모델은 비지도 학습을 통해 음성 데이터를 이해하고, 자기지도 학습을 통해 성능을 크게 향상시킵니다. Wav2Vec2는 음성 신호를 입력으로 받아들이고, 이를 텍스트로 변환하는 과정을 수행합니다. 특히, 전통적인 음성 인식 방법에 비해 더 적은 양의 레이블이 있는 데이터로도 학습할 수 있는 장점이 있습니다.

1.1 Wav2Vec2의 구조

Wav2Vec2 모델은 두 가지 주요 구성 요소로 나뉩니다:

  • 인코더: 입력 음성 신호를 인코딩하여 고차원 표현을 생성합니다.
  • 디코더: 인코더에서 얻은 표현을 기반으로 텍스트를 생성합니다.

이 과정에서 모델은 많은 음성 샘플과 해당 텍스트 레이블로 학습됩니다.

2. 환경 설정

Wav2Vec2를 사용하기 위해서는 먼저 필요한 라이브러리를 설치해야 합니다. 다음 코드를 사용하여 transformers, torchaudio, torch 라이브러리를 설치합니다:

!pip install transformers torchaudio torch

3. Wav2Vec2 모델 불러오기

모델이 설치되었다면, 다음으로 Wav2Vec2 모델을 불러와야 합니다. 허깅페이스의 transformers 라이브러리를 사용하면 손쉽게 사용할 수 있습니다:

from transformers import Wav2Vec2ForCTC, Wav2Vec2Tokenizer
model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h")
tokenizer = Wav2Vec2Tokenizer.from_pretrained("facebook/wav2vec2-large-960h")

위 코드에서 우리는 facebook/wav2vec2-large-960h라는 사전 훈련된 모델을 가져옵니다. 이 모델은 960시간의 영어 음성을 학습한 데이터로 훈련되어 있습니다.

4. 음성 파일 준비하기

Wav2Vec2 모델을 사용하기 위해서는 음성 파일이 필요합니다. 지원되는 음성 형식으로는 WAV가 있습니다. 음성 파일을 읽어오기 위해 torchaudiolibrosa 같은 라이브러리를 사용할 수 있습니다. 다음은 torchaudio를 사용하여 음성 파일을 로드하는 코드입니다:

import torchaudio

# 음성 파일 경로
audio_file = "path_to_your_audio_file.wav"
# 음성 파일 로드
waveform, sample_rate = torchaudio.load(audio_file)

5. 음성 인식 수행하기

이제 Wav2Vec2 모델을 사용하여 음성 인식을 수행할 준비가 되었습니다. 우리는 로드한 음성 파일을 모델에 전달하여 텍스트로 변환할 수 있습니다. 모델에 입력하기 전에 오디오 샘플의 샘플레이트를 맞춰주어야 합니다:

# 샘플레이트 변경
waveform = waveform.squeeze().numpy()  # (채널, 시간) -> (시간,)
inputs = tokenizer(waveform, return_tensors="pt", padding="longest")

이제 모델을 통해 인식을 수행할 수 있습니다:

with torch.no_grad():
    logits = model(inputs["input_values"]).logits
    
# 가장 높은 확률을 가진 인덱스를 찾음
predicted_ids = torch.argmax(logits, dim=-1)
# 인덱스를 텍스트로 변환
transcription = tokenizer.batch_decode(predicted_ids)[0]

여기서 transcription 변수에는 음성의 텍스트 변환 결과가 저장됩니다.

6. 전체 코드 예제

위의 모든 단계를 하나의 코드 블록으로 통합하여 전체 음성 인식 과정을 정리해보겠습니다:

import torchaudio
import torch
from transformers import Wav2Vec2ForCTC, Wav2Vec2Tokenizer

# 모델과 토크나이저 불러오기
model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h")
tokenizer = Wav2Vec2Tokenizer.from_pretrained("facebook/wav2vec2-large-960h")

# 음성 파일 경로
audio_file = "path_to_your_audio_file.wav"
# 음성 파일 로드
waveform, sample_rate = torchaudio.load(audio_file)

# 샘플레이트 변경
waveform = waveform.squeeze().numpy()  # (채널, 시간) -> (시간,)
inputs = tokenizer(waveform, return_tensors="pt", padding="longest")

# 인식 수행
with torch.no_grad():
    logits = model(inputs["input_values"]).logits
    predicted_ids = torch.argmax(logits, dim=-1)

# 텍스트로 변환
transcription = tokenizer.batch_decode(predicted_ids)[0]
print(transcription)

7. 결과 확인하기

위 코드를 실행하면 주어진 음성 파일에 대한 텍스트 결과를 출력합니다. 이는 Wav2Vec2 모델을 활용한 간단한 자동 음성 인식 시스템의 구현입니다. 음성 파일의 음질이나 길이에 따라서 결과의 정확도가 달라질 수 있습니다.

8. 마무리

허깅페이스 트렌스포머 라이브러리를 활용하여 Wav2Vec2 모델을 이용한 자동 음성 인식 시스템을 구현해보았습니다. 이번 예제를 통해 딥러닝 모델을 활용한 음성 인식의 기본적인 과정과 Wav2Vec2의 강력한 성능을 실험해볼 수 있었습니다. 음성 인식 기술은 다양한 분야에서 활용 가능성이 높기 때문에, 이 분야에 관심이 있는 분들은 더욱 깊이 있는 학습을 통해 전문성을 키우는 것이 좋습니다.

9. 추가 자료

더 많은 정보를 원하시는 분들은 다음의 자료를 참조하시기 바랍니다: