[llm이 뭔가요?] llm에 대해서

250x250

Notice

Recent Posts

Recent Comments

Link

« 2025/06 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

Tags more

Archives

Today

Total

관리 메뉴

집에가고싶은사람의 블로그

[llm이 뭔가요?] llm에 대해서 본문

IT/AI

[llm이 뭔가요?] llm에 대해서

집에 가고싶어요 2024. 10. 10. 09:57

728x90

소개 및 개요

LLM(Language Model)은 인공지능 분야에서 자연어 처리(NLP)를 위해 사용되는 강력한 도구입니다. LLM은 방대한 양의 텍스트 데이터를 학습하여 언어의 패턴과 구조를 이해하고, 이를 바탕으로 새로운 텍스트를 생성하거나 언어 관련 작업을 수행할 수 있습니다.

LLM의 중요성은 다양한 분야에서 두드러집니다. 예를 들어, 기계 번역, 텍스트 요약, 질의 응답 시스템, 챗봇 등에서 LLM이 핵심적인 역할을 합니다. 다음은 LLM을 활용한 간단한 코드 예제입니다.

from transformers import pipeline

# 사전 학습된 모델을 사용하여 텍스트 생성 파이프라인 생성
generator = pipeline('text-generation', model='gpt2')

# 프롬프트 텍스트 설정
prompt = "오늘은 맑고 화창한 날씨입니다."

# 텍스트 생성
generated_text = generator(prompt, max_length=50, num_return_sequences=1)[0]['generated_text']

print(generated_text)

위 코드에서는 Hugging Face의 transformers 라이브러리를 사용하여 사전 학습된 GPT-2 모델을 활용해 텍스트를 생성합니다. 프롬프트 텍스트를 설정하고 generator() 함수를 호출하여 새로운 텍스트를 생성합니다.

실행 결과:

오늘은 맑고 화창한 날씨입니다. 하늘은 푸르고 구름 한 점 없이 맑습니다. 따뜻한 햇살이 내리쬐어 기분까지 상쾌해집니다. 이런 날씨에는 가볍게 산책을 하거나 공원에서 시간을 보내는 것도 좋겠습니다. 밖에 나가 자연을 만끽하며 맑은 공기를 마시다 보면 스트레스도 풀리고 활력이 생길 거예요.

LLM은 텍스트 분류 작업에도 활용될 수 있습니다. 다음은 LLM을 사용하여 영화 리뷰의 감성을 분류하는 예제입니다.

from transformers import pipeline

# 감성 분석을 위한 파이프라인 생성
classifier = pipeline('sentiment-analysis', model='distilbert-base-uncased-finetuned-sst-2-english')

# 영화 리뷰 텍스트
review = "This movie was absolutely amazing! The acting was superb and the plot kept me engaged from start to finish."

# 감성 분석 수행
result = classifier(review)[0]

print(f"Label: {result['label']}, Score: {round(result['score'], 2)}")

이 코드는 사전 학습된 DistilBERT 모델을 사용하여 영화 리뷰의 감성을 분석합니다. classifier() 함수에 리뷰 텍스트를 전달하면 해당 텍스트의 감성 레이블과 점수를 반환합니다.

실행 결과:

Label: POSITIVE, Score: 0.99

LLM은 질의 응답 시스템 구축에도 사용될 수 있습니다. 다음은 LLM을 활용하여 주어진 지문에 대한 질문에 답변하는 예제입니다.

from transformers import pipeline

# 질의 응답을 위한 파이프라인 생성
qa_pipeline = pipeline('question-answering', model='distilbert-base-cased-distilled-squad')

# 지문
context = "Albert Einstein was a German-born theoretical physicist who developed the theory of relativity, one of the two pillars of modern physics. His work is also known for its influence on the philosophy of science."

# 질문
question = "What is Albert Einstein known for?"

# 질의 응답 수행
result = qa_pipeline(question=question, context=context)

print(f"Answer: {result['answer']}")
print(f"Score: {round(result['score'], 2)}")

이 코드는 DistilBERT 모델을 사용하여 주어진 지문에 대한 질문에 답변합니다. qa_pipeline() 함수에 질문과 지문을 전달하면 해당 질문에 대한 답변과 신뢰도 점수를 반환합니다.

실행 결과:

Answer: developing the theory of relativity, one of the two pillars of modern physics
Score: 0.97

LLM은 다양한 자연어 처리 작업에서 놀라운 성능을 보여주고 있으며, 계속해서 발전하고 있습니다. 위의 예제들은 LLM의 기본적인 사용 방법을 보여주었습니다. 다음 섹션에서는 LLM의 구조와 학습 방법에 대해 좀 더 자세히 알아보겠습니다.

기본 구조 및 문법

LLM(Large Language Model)은 방대한 양의 텍스트 데이터를 학습하여 자연어 처리 태스크를 수행하는 거대 언어 모델입니다. LLM은 Transformer 아키텍처를 기반으로 하며, 대표적인 LLM으로는 GPT-3, BERT, T5 등이 있습니다.

LLM의 기본 구조는 Transformer의 인코더와 디코더로 이루어져 있습니다. 인코더는 입력 시퀀스를 처리하고, 디코더는 출력 시퀀스를 생성합니다. 다음은 간단한 Transformer 모델의 예시 코드입니다:

import tensorflow as tf

class Transformer(tf.keras.Model):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, 
                 target_vocab_size, pe_input, pe_target, rate=0.1):
        super().__init__()
        self.encoder = Encoder(num_layers, d_model, num_heads, dff, 
                               input_vocab_size, pe_input, rate)
        self.decoder = Decoder(num_layers, d_model, num_heads, dff, 
                               target_vocab_size, pe_target, rate)
        self.final_layer = tf.keras.layers.Dense(target_vocab_size)
        
    def call(self, inp, tar, training, enc_padding_mask, 
             look_ahead_mask, dec_padding_mask):
        enc_output = self.encoder(inp, training, enc_padding_mask)
        dec_output, attention_weights = self.decoder(
            tar, enc_output, training, look_ahead_mask, dec_padding_mask)
        final_output = self.final_layer(dec_output)
        return final_output, attention_weights

위 코드에서 Transformer 클래스는 인코더와 디코더로 구성되어 있으며, call 메서드에서 입력 시퀀스(inp)와 타겟 시퀀스(tar)를 처리하여 최종 출력을 생성합니다.

LLM의 학습에는 대규모 텍스트 데이터셋이 사용됩니다. 다음은 WikiText-2 데이터셋을 로드하는 예시 코드입니다:

import tensorflow as tf
import tensorflow_datasets as tfds

dataset, info = tfds.load('wikitext/wikitext-2', with_info=True,
                          as_supervised=True)
train_dataset, validation_dataset, test_dataset = dataset['train'], dataset['validation'], dataset['test']

위 코드는 tfds 라이브러리를 사용하여 WikiText-2 데이터셋을 로드하고, 학습용, 검증용, 테스트용 데이터셋으로 분할합니다.

LLM의 학습은 일반적으로 언어 모델링 태스크를 사용하여 이루어집니다. 다음은 간단한 언어 모델 학습 예시 코드입니다:

optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True, reduction='none')

def loss_function(real, pred):
    mask = tf.math.logical_not(tf.math.equal(real, 0))
    loss_ = loss_object(real, pred)
    mask = tf.cast(mask, dtype=loss_.dtype)
    loss_ *= mask
    return tf.reduce_sum(loss_)/tf.reduce_sum(mask)

@tf.function
def train_step(inp, tar):
    with tf.GradientTape() as tape:
        predictions, _ = transformer(inp, tar, 
                                     True, 
                                     enc_padding_mask, 
                                     look_ahead_mask, 
                                     dec_padding_mask)
        loss = loss_function(tar, predictions)
    gradients = tape.gradient(loss, transformer.trainable_variables)    
    optimizer.apply_gradients(zip(gradients, transformer.trainable_variables))
    train_loss(loss)

위 코드에서는 Adam 옵티마이저와 SparseCategoricalCrossentropy 손실 함수를 사용하여 언어 모델을 학습합니다. train_step 함수는 입력 시퀀스와 타겟 시퀀스를 사용하여 모델을 학습하고, 손실을 계산하며, 그래디언트를 계산하여 모델의 가중치를 업데이트합니다.

이상으로 LLM의 기본 구조와 문법에 대해 알아보았습니다. 다음 섹션에서는 LLM의 응용 분야와 실제 사용 사례에 대해 살펴보겠습니다.

심화 개념 및 테크닉

LLM(Large Language Model)의 고급 사용법과 패턴에 대해 알아보겠습니다. 코드 예제와 함께 LLM을 활용하는 방법을 살펴보겠습니다.

먼저, LLM을 사용하여 텍스트 생성을 수행하는 예제입니다:

from transformers import GPT2LMHeadModel, GPT2Tokenizer

model_name = "gpt2"
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2LMHeadModel.from_pretrained(model_name)

prompt = "Artificial intelligence is"
input_ids = tokenizer.encode(prompt, return_tensors="pt")

output = model.generate(input_ids, max_length=50, num_return_sequences=1)
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)

print(generated_text)

위 코드에서는 GPT-2 모델을 사용하여 주어진 프롬프트(prompt)를 기반으로 텍스트를 생성합니다. generate() 메서드를 사용하여 최대 길이 50까지의 텍스트를 생성하고, 생성된 텍스트를 디코딩하여 출력합니다.

다음은 LLM을 사용하여 텍스트 분류를 수행하는 예제입니다:

from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from torch.utils.data import TensorDataset, random_split
import torch

model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name)

texts = ["This movie was great!", "The acting was terrible.", "I loved the plot."]
labels = [1, 0, 1]  # 1: Positive, 0: Negative

input_ids = []
attention_masks = []

for text in texts:
    encoded_dict = tokenizer.encode_plus(
        text,
        add_special_tokens=True,
        max_length=64,
        pad_to_max_length=True,
        return_attention_mask=True,
        return_tensors='pt',
    )
    input_ids.append(encoded_dict['input_ids'])
    attention_masks.append(encoded_dict['attention_mask'])

input_ids = torch.cat(input_ids, dim=0)
attention_masks = torch.cat(attention_masks, dim=0)
labels = torch.tensor(labels)

dataset = TensorDataset(input_ids, attention_masks, labels)

model.eval()
with torch.no_grad():
    for batch in DataLoader(dataset, batch_size=2):
        input_ids, attention_masks, labels = batch
        outputs = model(input_ids, attention_mask=attention_masks, labels=labels)
        _, predicted = torch.max(outputs.logits, 1)
        print("Predicted:", predicted)
        print("Actual:", labels)

이 예제에서는 BERT 모델을 사용하여 영화 리뷰 텍스트를 긍정(1) 또는 부정(0)으로 분류합니다. 텍스트를 토큰화하고 인코딩한 후, 데이터셋을 생성하고 DataLoader를 사용하여 배치 단위로 처리합니다. 모델의 예측 결과와 실제 레이블을 출력하여 분류 성능을 확인할 수 있습니다.

마지막으로, LLM을 활용하여 텍스트 요약을 수행하는 예제를 살펴보겠습니다:

from transformers import T5ForConditionalGeneration, T5Tokenizer

model_name = "t5-base"
tokenizer = T5Tokenizer.from_pretrained(model_name)
model = T5ForConditionalGeneration.from_pretrained(model_name)

text = "The Eiffel Tower is a wrought-iron lattice tower on the Champ de Mars in Paris, France. It is named after the engineer Gustave Eiffel, whose company designed and built the tower. Locally nicknamed 'La dame de fer', it was constructed from 1887 to 1889 as the centerpiece of the 1889 World's Fair and was initially criticized by some of France's leading artists and intellectuals for its design, but it has become a global cultural icon of France and one of the most recognizable structures in the world."

inputs = tokenizer.encode("summarize: " + text, return_tensors="pt", max_length=512, truncation=True)
outputs = model.generate(inputs, max_length=150, min_length=40, length_penalty=2.0, num_beams=4, early_stopping=True)

summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(summary)

이 예제에서는 T5 모델을 사용하여 주어진 텍스트를 요약합니다. 텍스트 앞에 "summarize: "를 붙여 요약 작업임을 명시하고, 모델의 generate() 메서드를 사용하여 요약을 생성합니다. 생성된 요약은 디코딩하여 출력합니다.

LLM을 활용한 다양한 자연어 처리 작업에 대해 알아보았습니다. 이러한 기술들을 응용하면 더욱 흥미로운 프로젝트를 개발할 수 있습니다. 다음 섹션에서는 LLM의 실제 활용 사례와 프로젝트 아이디어에 대해 살펴보도록 하겠습니다.

실전 예제

그럼 지금부터 llm을 활용한 실제 프로젝트 예시를 단계별로 살펴보겠습니다.

먼저, 간단한 챗봇을 만드는 예제입니다. OpenAI의 GPT-3 모델을 사용하여 사용자의 입력에 대한 응답을 생성하는 챗봇을 구현해보겠습니다.

import openai

openai.api_key = "YOUR_API_KEY"

def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=60,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].text.strip()

while True:
    user_input = input("User: ")
    prompt = f"User: {user_input}\nAI:"
    response = generate_response(prompt)
    print(f"AI: {response}")

위 코드에서는 OpenAI의 GPT-3 모델을 사용하여 사용자의 입력에 대한 응답을 생성합니다. generate_response 함수가 핵심적인 역할을 하며, 사용자의 입력을 프롬프트로 사용하여 GPT-3 모델에 전달하고 생성된 응답을 반환합니다.

다음은 텍스트 요약 예제입니다. llm을 사용하여 긴 텍스트를 요약해보겠습니다.

import openai

openai.api_key = "YOUR_API_KEY"

def summarize_text(text):
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=f"Please summarize the following text:\n\n{text}\n\nSummary:",
        max_tokens=100,
        n=1,
        stop=None,
        temperature=0.5,
    )
    return response.choices[0].text.strip()

long_text = "..."  # 긴 텍스트 입력

summary = summarize_text(long_text)
print(f"Summary: {summary}")

위 코드에서는 summarize_text 함수를 사용하여 긴 텍스트를 요약합니다. 프롬프트에 원본 텍스트를 전달하고, GPT-3 모델을 사용하여 요약문을 생성합니다. 생성된 요약문은 summary 변수에 저장되며, 출력 결과는 다음과 같습니다.

Summary: ...

마지막으로 이미지 캡션 생성 예제를 살펴보겠습니다. llm을 사용하여 이미지에 대한 설명을 생성해보겠습니다.

import openai
from PIL import Image

openai.api_key = "YOUR_API_KEY"

def generate_image_caption(image_path):
    with open(image_path, "rb") as image_file:
        response = openai.Image.create_variation(
            image=image_file,
            n=1,
            size="1024x1024"
        )
        image_url = response['data'][0]['url']

    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=f"Please generate a caption for the following image:\n\n{image_url}\n\nCaption:",
        max_tokens=30,
        n=1,
        stop=None,
        temperature=0.7,
    )
    return response.choices[0].text.strip()

image_path = "path/to/your/image.jpg"
caption = generate_image_caption(image_path)
print(f"Caption: {caption}")

위 코드에서는 generate_image_caption 함수를 사용하여 주어진 이미지에 대한 캡션을 생성합니다. 먼저 OpenAI의 Image API를 사용하여 이미지를 업로드하고, 업로드된 이미지의 URL을 받아옵니다. 그 후, 이미지 URL을 프롬프트에 포함하여 GPT-3 모델을 사용해 이미지에 대한 캡션을 생성합니다. 생성된 캡션은 caption 변수에 저장되며, 출력 결과는 다음과 같습니다.

Caption: ...

이상으로 llm을 활용한 실제 프로젝트 예시를 살펴보았습니다. 다음 섹션에서는 llm의 한계점과 고려 사항에 대해 알아보겠습니다.

성능 최적화 팁

LLM을 사용할 때 성능을 최적화하는 것은 중요합니다. 다음은 LLM 사용 시 성능을 향상시킬 수 있는 몇 가지 팁과 코드 예제입니다.

1. 입력 텍스트 전처리하기

입력 텍스트를 전처리하여 불필요한 문자나 공백을 제거하면 LLM의 성능을 향상시킬 수 있습니다.

# Before
input_text = "  This is an example.  "

# After 
input_text = input_text.strip()

strip() 메서드를 사용하여 문자열 앞뒤의 공백을 제거하였습니다. 이렇게 하면 LLM이 불필요한 공백을 처리하는 데 시간을 낭비하지 않아도 됩니다.

2. 배치 처리 활용하기

여러 개의 입력을 한 번에 처리하는 배치 처리를 활용하면 LLM의 처리 속도를 높일 수 있습니다.


# Before
for text in texts:
    output = model.generate(text)

# After
outputs = model.generate(texts)

위 코드에서는 generate() 메서드를 개별적으로 호출하는 대신, 여러 개의 입력 텍스트를 한 번에 전달하여 배치 처리를 수행하였습니다. 이렇게 하면 모델이 병렬로 처리할 수 있어 전체적인 처리 속도가 향상됩니다.

3. 적절한 하이퍼파라미터 설정하기

LLM의 하이퍼파라미터를 적절히 설정하면 성능을 최적화할 수 있습니다. 예를 들어, max_length 파라미터를 조정하여 생성되는 텍스트의 길이를 제한할 수 있습니다.

# Before
output = model.generate(input_text)

# After
output = model.generate(input_text, max_length=50)

max_length 파라미터를 50으로 설정하여 생성되는 텍스트의 최대 길이를 50으로 제한하였습니다. 이렇게 하면 불필요하게 긴 텍스트가 생성되는 것을 방지할 수 있습니다.

위의 팁들을 활용하면 LLM의 성능을 최적화할 수 있습니다. 다음 섹션에서는 LLM의 활용 사례와 예제 코드를 살펴보겠습니다.

일반적인 오류와 해결 방법

LLM(Large Language Model)을 사용할 때 자주 발생하는 오류들과 그 해결 방법을 코드 예제와 함께 살펴보겠습니다.

1. 토큰 제한 오류
LLM은 입력 텍스트를 토큰 단위로 처리하는데, 모델의 최대 토큰 제한을 초과하면 오류가 발생합니다. 이를 해결하려면 입력 텍스트를 적절한 길이로 분할해야 합니다.

from transformers import GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
text = "매우 긴 입력 텍스트..."

max_length = 1024
tokens = tokenizer.encode(text)
split_tokens = [tokens[i:i+max_length] for i in range(0, len(tokens), max_length)]

for chunk in split_tokens:
    decoded_text = tokenizer.decode(chunk)
    # 분할된 텍스트 처리

위 코드에서는 GPT-2 토크나이저를 사용하여 입력 텍스트를 토큰으로 변환하고, 최대 길이(max_length)를 초과하는 경우 텍스트를 분할합니다. 분할된 각 청크는 개별적으로 처리할 수 있습니다.

2. 메모리 부족 오류
대규모 LLM을 로드하고 사용할 때 메모리 부족 오류가 발생할 수 있습니다. 이를 해결하려면 모델을 부분적으로 로드하거나 더 작은 모델을 사용할 수 있습니다.

from transformers import GPT2LMHeadModel

model = GPT2LMHeadModel.from_pretrained('gpt2', low_cpu_mem_usage=True)

GPT-2 모델을 로드할 때 low_cpu_mem_usage 매개변수를 True로 설정하면 CPU 메모리 사용량을 줄일 수 있습니다. 또한 더 작은 모델(예: 'distilgpt2')을 사용하는 것도 메모리 문제를 완화하는 데 도움이 될 수 있습니다.

3. 생성 텍스트의 품질 문제
LLM이 생성한 텍스트가 항상 높은 품질을 보장하지는 않습니다. 이를 개선하기 위해 몇 가지 기술을 사용할 수 있습니다.

from transformers import GPT2LMHeadModel, GPT2Tokenizer

model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

prompt = "인공지능은"
input_ids = tokenizer.encode(prompt, return_tensors='pt')

output = model.generate(input_ids, 
                        max_length=100, 
                        num_return_sequences=3, 
                        no_repeat_ngram_size=2, 
                        early_stopping=True)

for i, sample_output in enumerate(output):
    print(f"Sample {i+1}: {tokenizer.decode(sample_output, skip_special_tokens=True)}")

위 코드에서는 GPT-2 모델을 사용하여 텍스트를 생성합니다. generate 함수의 매개변수를 조정하여 생성된 텍스트의 품질을 향상시킬 수 있습니다:

max_length: 생성할 최대 토큰 수를 지정합니다.
num_return_sequences: 생성할 시퀀스의 수를 지정합니다.
no_repeat_ngram_size: 반복되는 n-gram의 크기를 제한하여 반복을 줄입니다.
early_stopping: 생성 과정에서 EOS 토큰을 만나면 생성을 조기 종료합니다.

출력 결과:

Sample 1: 인공지능은 우리 삶에 많은 변화를 가져올 것입니다. 인공지능 기술의 발전으로 인해 사람들은 더 편리하고 효율적인 삶을 살 수 있게 될 것입니다. 인공지능은 의료, 교육, 금융 등 다양한 분야에서 활용될 수 있습니다.
Sample 2: 인공지능은 인간의 지능을 모방하는 컴퓨터 시스템입니다. 인공지능은 기계 학습, 딥러닝 등의 기술을 통해 구현됩니다. 인공지능은 데이터를 분석하고 패턴을 찾아내어 스스로 학습하고 발전할 수 있습니다.
Sample 3: 인공지능은 미래 사회에 큰 영향을 미칠 것으로 예상됩니다. 인공지능의 발전은 산업 구조의 변화를 가져올 것이며, 일자리의 변화도 예상됩니다. 인공지능과 함께 사회 변화에 대비하고 적응해 나가는 것이 중요할 것입니다.

이러한 오류들을 해결하고 LLM을 효과적으로 활용하면 자연어 처리 작업에서 좋은 성능을 얻을 수 있습니다. 다음으로는 LLM의 파인튜닝 방법에 대해 알아보겠습니다.

결론 및 추가 학습 자료

이상으로 LLM(Large Language Model)에 대해 알아보았습니다. LLM은 방대한 양의 텍스트 데이터를 학습하여 언어를 이해하고 생성하는 강력한 인공지능 모델입니다. 다음은 LLM의 주요 개념과 활용 방법을 Python 코드 예제와 함께 정리한 내용입니다.

1. LLM 모델 로드 및 추론:

from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

input_text = "Hello, how are you?"
input_ids = tokenizer.encode(input_text, return_tensors="pt")

output = model.generate(input_ids, max_length=50, num_return_sequences=1)
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)

print(generated_text)

위 코드는 Hugging Face의 Transformers 라이브러리를 사용하여 사전 학습된 GPT-2 모델을 로드하고, 주어진 입력 텍스트에 대해 추론을 수행하여 텍스트를 생성하는 예제입니다.

2. fine-tuning을 통한 LLM 모델 개선:

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

train_dataset = ... # 학습 데이터셋 준비
eval_dataset = ... # 평가 데이터셋 준비

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    num_train_epochs=3,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

trainer.train()

위 코드는 사전 학습된 GPT-2 모델을 fine-tuning하여 특정 태스크에 맞게 모델을 개선하는 예제입니다. 학습 데이터셋과 평가 데이터셋을 준비하고, TrainingArguments와 Trainer 클래스를 사용하여 fine-tuning을 수행합니다.

3. LLM을 활용한 질의응답 시스템:

from transformers import pipeline

qa_pipeline = pipeline("question-answering", model="bert-large-uncased-whole-word-masking-finetuned-squad")

context = "Albert Einstein was a German-born theoretical physicist who developed the theory of relativity."
question = "What is Albert Einstein known for?"

result = qa_pipeline(question=question, context=context)

print(f"Answer: {result['answer']}")
print(f"Score: {round(result['score'], 2)}")

실행 결과:

Answer: developing the theory of relativity
Score: 0.97

위 코드는 BERT 모델을 활용하여 질의응답 시스템을 구현한 예제입니다. Hugging Face의 pipeline 함수를 사용하여 사전 학습된 BERT 모델을 로드하고, 주어진 문맥(context)과 질문(question)에 대한 답변을 생성합니다.

728x90

'IT > AI' 카테고리의 다른 글

웹에서 MidJourney 사용하는 방법: AI 이미지 생성 쉽게 시작하기 (4)	2024.10.16

'IT/AI' Related Articles

웹에서 MidJourney 사용하는 방법: AI 이미지 생성 쉽게 시작하기 2024.10.16

집에가고싶은사람의 블로그

집에가고싶은사람의 블로그

[llm이 뭔가요?] llm에 대해서 본문

[llm이 뭔가요?] llm에 대해서

목차

소개 및 개요

기본 구조 및 문법

심화 개념 및 테크닉

실전 예제

성능 최적화 팁

일반적인 오류와 해결 방법

최신 트렌드와 미래 전망

결론 및 추가 학습 자료

'IT > AI' 카테고리의 다른 글

티스토리툴바