기술나눔

Gemma2 - Google의 새로운 오픈 소스 대규모 언어 모델을 위한 완벽한 애플리케이션 가이드

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

0 서문

젬마 2 이전 버전을 기반으로 향상된 성능과 효율성은 물론 다양한 혁신적인 기능을 제공하므로 연구 및 실제 응용 분야 모두에서 특히 매력적입니다. Gemma 2를 차별화하는 점은 더 큰 독점 모델에 필적하는 성능을 제공한다는 것입니다.소프트웨어 패키지더 넓은 접근성과 보다 적절한 하드웨어 설정에서 사용하도록 설계되었습니다.

Gemma 2의 기술 사양과 아키텍처를 자세히 살펴보면서 디자인의 정교함에 점점 더 깊은 인상을 받았습니다.이 모델에는 새로운 기술을 포함한 다양한 첨단 기술이 통합되어 있습니다.주의 메커니즘혁신적인 훈련 안정성 방법은 모두 뛰어난 성능에 기여합니다.

이 포괄적인 가이드에서는 Gemma 2의 아키텍처, 주요 기능 및 실제 애플리케이션을 살펴보며 심도 깊게 살펴보겠습니다. 숙련된 AI 실무자이든 해당 분야의 열정적인 초보자이든 관계없이 이 기사는 Gemma 2의 작동 방식과 자신의 프로젝트에서 해당 기능을 활용할 수 있는 방법에 대한 귀중한 통찰력을 제공하는 것을 목표로 합니다.

1. 젬마2란 무엇인가요?

Gemma 2는 Google의 최신 오픈소스 대규모언어 모델 , 정교하게 디자인되었지만 강력합니다. Google Gemini 모델을 만드는 데 사용된 것과 동일한 연구 및 기술을 기반으로 구축되어 보다 접근하기 쉬운 패키지로 최첨단 성능을 제공합니다. Gemma 2는 두 가지 크기로 제공됩니다.

젬마 2 9B: 90억 개의 매개변수 모델
젬마 2 27B: 더 큰 270억 개의 매개변수 모델

각 크기는 두 가지 스타일로 제공됩니다.

기본 모델: 대용량 텍스트 데이터에 대한 사전 학습
IT(명령어 튜닝) 모델: 특정 작업에서 더 나은 성능을 발휘하도록 미세 조정됨

Google AI Studio의 모델에 액세스：Google AI Studio – Gemma 2
여기에서 논문을 읽어보세요: Gemma 2 기술 보고서

2.주요 기능 및 개선 사항

Gemma 2는 이전 버전에 비해 몇 가지 중요한 개선 사항을 도입했습니다.

2.1. 훈련 데이터 추가

이 모델은 더 많은 데이터에 대해 학습되었습니다.

젬마 2 27B: 13조 토큰으로 훈련 후
젬마 2 9B: 8조 토큰으로 훈련 후

이 확장된 데이터 세트는 주로 네트워크 데이터(주로 영어), 코드 및 수학으로 구성되어 모델의 성능과 다양성을 향상시키는 데 도움이 됩니다.

2.2. 슬라이딩 윈도우 주의

Gemma 2는 새로운 주의 메커니즘 방법을 구현합니다.

다른 모든 레이어는 슬라이딩 윈도우 주의 메커니즘을 사용하며 로컬 컨텍스트는 4096개의 토큰입니다.
교대 레이어는 전체 8192 토큰 컨텍스트에 대해 완전 2차 전역 주의 메커니즘을 채택합니다.

이 하이브리드 접근 방식은 효율성과 입력의 장거리 종속성을 포착하는 능력의 균형을 맞추는 것을 목표로 합니다.

2.3. 소프트캡

훈련 안정성과 성능을 향상시키기 위해 Gemma 2는 소프트 상한 메커니즘을 도입했습니다.

def soft_cap(x, cap):
    return cap * torch.tanh(x / cap)
# Applied to attention logits
attention_logits = soft_cap(attention_logits, cap=50.0)
# Applied to final layer logits
final_logits = soft_cap(final_logits, cap=30.0)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

이 기술은 하드 잘림 없이 로짓이 너무 커지는 것을 방지하여 훈련 프로세스를 안정화하는 동시에 더 많은 정보를 유지합니다.

  1. 젬마 2 9B: 90억개 매개변수 모델
  2. 젬마 2 27B: 더 큰 270억 개의 매개변수 모델

각 크기는 두 가지 스타일로 제공됩니다.

  • 기본 모델: 대량의 텍스트 데이터에 대해 사전 학습됨
  • IT(명령어 조정) 모델: 특정 작업에서 더 나은 성능을 위해 미세 조정됨

2.4. 지식 증류

9B 모델의 경우 Gemma 2는 지식 추출 기술을 사용합니다.

  • 사전 훈련: 9B 모델은 초기 훈련 중에 더 큰 교사 모델로부터 학습합니다.
  • 훈련 후: 9B 및 27B 모델 모두 온라인 정책 증류를 사용하여 성능을 향상시킵니다.

이 프로세스는 작은 모델이 큰 모델의 기능을 보다 효과적으로 포착하는 데 도움이 됩니다.

2.5. 모델 병합

Gemma 2는 여러 모델을 3단계로 결합하는 Warp라는 새로운 모델 병합 기술을 사용합니다.

  1. 강화 학습 미세 조정 중 지수 이동 평균(EMA)
  2. 여러 전략으로 미세 조정한 후의 구형 선형 보간(SLERP)
  3. 최종 단계인 LITI(선형 보간 초기화)

이 접근 방식은 보다 강력하고 강력한 최종 모델을 만드는 것을 목표로 합니다.

3. 성능 벤치마크

Gemma 2는 다양한 벤치마크에서 인상적인 성능을 보여줍니다.

Gemma 2는 탁월한 성능과 추론 효율성을 위해 재설계된 아키텍처를 갖추고 있습니다.

6. Gemma 2 시작하기

프로젝트에서 Gemma 2 사용을 시작하려면 다음 옵션이 있습니다.

6.1. 구글 인공지능 스튜디오

Gemma 2는 Google AI Studio를 통해 접속할 수 있으며,구글 인공지능 스튜디오.

6.2. 껴안는 얼굴

젬마 2와 포옹하는 얼굴 Transformers 라이브러리 통합. 사용 방법은 다음과 같습니다.

<div class="relative flex flex-col rounded-lg">
<div class="text-text-300 absolute pl-3 pt-2.5 text-xs">
from transformers import AutoTokenizer, AutoModelForCausalLM
# Load the model and tokenizer
model_name = "google/gemma-2-27b-it" # or "google/gemma-2-9b-it" for the smaller version
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# Prepare input
prompt = "Explain the concept of quantum entanglement in simple terms."
inputs = tokenizer(prompt, return_tensors="pt")
# Generate text
outputs = model.generate(**inputs, max_length=200)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

6.3.텐서플로우/케라스

TensorFlow 사용자의 경우 Keras를 통해 Gemma 2를 사용할 수 있습니다.

import tensorflow as tf
from keras_nlp.models import GemmaCausalLM
# Load the model
model = GemmaCausalLM.from_preset("gemma_2b_en")
# Generate text
prompt = "Explain the concept of quantum entanglement in simple terms."
output = model.generate(prompt, max_length=200)
print(output)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

7. 고급 사용법: Gemma 2를 사용하여 로컬 RAG 시스템 구축

Gemma 2의 강력한 응용 프로그램은 검색 증강 생성(RAG) 시스템을 구축하는 것입니다. Gemma 2 및 Nomic 임베딩을 사용하여 간단하고 완전한 기본 RAG 시스템을 만들어 보겠습니다.

1단계: 환경 설정

먼저, 필요한 라이브러리가 설치되어 있는지 확인하세요.

pip install langchain ollama nomic chromadb

  • 1

2단계: 문서 색인화

문서를 처리하기 위한 인덱서를 만듭니다.

import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
class Indexer:
    def __init__(self, directory_path):
    self.directory_path = directory_path
    self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
    self.embeddings = HuggingFaceEmbeddings(model_name="nomic-ai/nomic-embed-text-v1")
  
def load_and_split_documents(self):
    loader = DirectoryLoader(self.directory_path, glob="**/*.txt")
    documents = loader.load()
    return self.text_splitter.split_documents(documents)
def create_vector_store(self, documents):
    return Chroma.from_documents(documents, self.embeddings, persist_directory="./chroma_db")
def index(self):
    documents = self.load_and_split_documents()
    vector_store = self.create_vector_store(documents)
    vector_store.persist()
    return vector_store
# Usage
indexer = Indexer("path/to/your/documents")
vector_store = indexer.index()

  • 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

3단계: RAG 시스템 설정

이제 Gemma 2를 사용하여 RAG 시스템을 만듭니다.

from langchain.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
class RAGSystem:
    def __init__(self, vector_store):
        self.vector_store = vector_store
        self.llm = Ollama(model="gemma2:9b")
        self.retriever = self.vector_store.as_retriever(search_kwargs={"k": 3})
self.template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {question}
Answer: """
self.qa_prompt = PromptTemplate(
template=self.template, input_variables=["context", "question"]
)
self.qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type="stuff",
retriever=self.retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": self.qa_prompt}
)
def query(self, question):
return self.qa_chain({"query": question})
# Usage
rag_system = RAGSystem(vector_store)
response = rag_system.query("What is the capital of France?")
print(response["result"])

  • 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

이 RAG 시스템은 언어 모델로 Ollama에 대한 Gemma 2를 사용하고 문서 검색을 위해 Nomic 임베딩을 사용합니다. 색인된 문서를 기반으로 질문하고 관련 소스로부터 상황에 맞는 답변을 제공할 수 있습니다.

미세 조정 Gemma 2

특정 작업이나 도메인의 경우 Gemma 2를 미세 조정해야 할 수도 있습니다. 다음은 Hugging Face Transformers 라이브러리를 사용하는 기본 예입니다.

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
from datasets import load_dataset
# Load model and tokenizer
model_name = "google/gemma-2-9b-it"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
# Prepare dataset
dataset = load_dataset("your_dataset")
def tokenize_function(examples):
return tokenizer(examples["text"], padding="max_length", truncation=True)
tokenized_datasets = dataset.map(tokenize_function, batched=True)
# Set up training arguments
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
warmup_steps=500,
weight_decay=0.01,
logging_dir="./logs",
)
# Initialize Trainer
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets["train"],
eval_dataset=tokenized_datasets["test"],
)
# Start fine-tuning
trainer.train()
# Save the fine-tuned model
model.save_pretrained("./fine_tuned_gemma2")
tokenizer.save_pretrained("./fine_tuned_gemma2")

  • 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
  • 31
  • 32
  • 33

특정 요구 사항 및 컴퓨팅 리소스에 따라 훈련 매개변수를 조정합니다.

윤리적 고려 사항 및 제한 사항

Gemma 2는 인상적인 기능을 제공하지만 제한 사항과 윤리적 고려 사항을 알고 있어야 합니다.

  • 편견 : 모든 언어 모델과 마찬가지로 Gemma 2는 훈련 데이터에 존재하는 편향을 반영할 수 있습니다. 항상 그 결과를 비판적으로 평가하십시오.
  • 사실적 정확성 : Gemma 2는 강력하지만 때로는 부정확하거나 일관성이 없는 정보를 생성합니다. 신뢰할 수 있는 출처를 통해 중요한 사실을 확인하시기 바랍니다.
  • 컨텍스트 길이 : Gemma 2의 컨텍스트 길이는 8192 토큰입니다. 긴 문서나 대화의 경우 상황을 효과적으로 관리하기 위한 전략을 구현해야 할 수도 있습니다.
  • 컴퓨팅 리소스: 특히 27B 모델의 경우 효과적인 추론과 미세 조정을 위해서는 상당한 컴퓨팅 리소스가 필요할 수 있습니다.
  • 책임감 있는 사용: Google의 책임 있는 AI 관행을 준수하고 Gemma 2 사용이 윤리적인 AI 원칙에 부합하는지 확인하세요.

8.결론

슬라이딩 윈도우 어텐션, 소프트 상한, 새로운 모델 병합 기술과 같은 Gemma 2의 고급 기능은 광범위한 자연어 처리 작업을 위한 강력한 도구입니다.

간단한 추론, 복잡한 RAG 시스템 또는 도메인별 미세 조정 모델을 통해 프로젝트에서 Gemma 2를 활용하면 데이터 및 프로세스에 대한 제어를 유지하면서 SOTA AI의 기능을 활용할 수 있습니다.

원래 주소:https://www.unite.ai/gemma-2-googles-new-open-large-language-model-완전-가이드/

개인 프로필

그는 30년 이상 기술 연구에 전념해 왔으며, java, linux, javascript, php, css 등 다양한 언어에 능숙하며, 오픈 소스 분야에 많은 공헌을 했습니다. 나중에 참조할 수 있도록 기술 개발의 일부 문제를 공유하는 개발자 문서 스테이션입니다.

내 연락처 정보

우편