minhas informações de contato
Correspondência[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Gema 2 Com base no seu antecessor, oferece melhor desempenho e eficiência, bem como uma gama de características inovadoras, tornando-o particularmente atraente tanto para investigação como para aplicações práticas. O que diferencia o Gemma 2 é que ele oferece desempenho comparável a modelos proprietários maiores, mas compacote de softwareProjetado para maior acessibilidade e uso em configurações de hardware mais modestas.
À medida que me aprofundo nas especificações técnicas e na arquitetura do Gemma 2, fico cada vez mais impressionado com a sofisticação do seu design.O modelo incorpora uma variedade de tecnologias avançadas, incluindo novasmecanismo de atençãoe métodos inovadores de estabilidade de treinamento, que contribuem para seu desempenho excepcional.
Neste guia abrangente, o Gemma 2 será explorado em profundidade, analisando sua arquitetura, principais recursos e aplicações práticas. Quer você seja um profissional experiente em IA ou um novato entusiasta na área, este artigo tem como objetivo fornecer informações valiosas sobre como o Gemma 2 funciona e como você pode aproveitar seus recursos em seus próprios projetos.
Gemma 2 é o mais recente código aberto em grande escala do Googlemodelo de linguagem , primorosamente projetado, mas poderoso. Ele é baseado na mesma pesquisa e tecnologia usada para criar os modelos do Google Gemini, oferecendo desempenho de última geração em um pacote mais acessível. Gemma 2 vem em dois tamanhos:
Gema 2 9B: Um modelo de parâmetros de 9 bilhões
Gema 2 27B: Um modelo maior de 27 bilhões de parâmetros
Cada tamanho vem em dois estilos:
modelo básico: Pré-treinamento em grandes quantidades de dados de texto
Modelo de ajuste de instrução (TI): Ajustado para melhor desempenho em tarefas específicas
Acesse modelos no Google AI Studio：Estúdio de IA do Google – Gemma 2
Leia o jornal aqui: Relatório Técnico Gemma 2
Gemma 2 apresenta várias melhorias significativas em relação ao seu antecessor:
Esses modelos foram treinados com mais dados:
Gema 2 27B: Depois de treinar com 13 trilhões de tokens
Gema 2 9B: Depois de treinar com 8 trilhões de tokens
Este conjunto de dados estendido consiste principalmente em dados de rede (principalmente em inglês), código e matemática, ajudando a melhorar o desempenho e a versatilidade de seus modelos.
Gemma 2 implementa um novo método de mecanismo de atenção:
Todas as outras camadas usam um mecanismo de atenção de janela deslizante e o contexto local é de 4.096 tokens.
A camada alternada adota um mecanismo de atenção global totalmente quadrático para todo o contexto do token 8192.
Esta abordagem híbrida visa equilibrar a eficiência com a capacidade de capturar dependências de longo alcance na entrada.
Para melhorar a estabilidade e o desempenho do treinamento, o Gemma 2 introduz um mecanismo de limite superior suave:
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)
Essa técnica evita que os logits se tornem muito grandes sem truncamento rígido, retendo assim mais informações e estabilizando o processo de treinamento.
Cada tamanho vem em dois estilos:
Para o modelo 9B, Gemma 2 utiliza tecnologia de extração de conhecimento:
Esse processo ajuda o modelo menor a capturar com mais eficiência a funcionalidade do modelo maior.
Gemma 2 usa uma nova tecnologia de fusão de modelos chamada Warp, que combina vários modelos em três estágios:
Esta abordagem visa criar um modelo final mais robusto e robusto.
Gemma 2 demonstra desempenho impressionante em uma variedade de benchmarks:
Gemma 2 apresenta uma arquitetura redesenhada projetada para desempenho superior e eficiência de inferência
Para começar a usar o Gemma 2 em seus projetos, você tem as seguintes opções:
Gemma 2 pode ser acessado através do Google AI Studio,Estúdio de Inteligência Artificial do Google.
Gemma 2 e rosto abraçado Integração da biblioteca de transformadores. Veja como usá-lo:
<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)
Para usuários do TensorFlow, o Gemma 2 está disponível por meio do Keras:
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)
Uma aplicação poderosa do Gemma 2 é a construção de sistemas de geração aumentada por recuperação (RAG). Vamos criar um sistema RAG simples e totalmente nativo usando embeddings Gemma 2 e Nomic.
Primeiro, certifique-se de ter as bibliotecas necessárias instaladas:
pip install langchain ollama nomic chromadb
Crie um indexador para processar os documentos:
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()
Agora, crie o sistema RAG usando Gemma 2:
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"])
Este sistema RAG usa Gemma 2 to Ollama como modelo de linguagem e incorporação Nomic para recuperação de documentos. Ele permite que você faça perguntas com base em documentos indexados e forneça respostas contextuais de fontes relevantes.
Para tarefas ou domínios específicos, pode ser necessário ajustar o Gemma 2. Aqui está um exemplo básico usando a biblioteca 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")
Ajuste os parâmetros de treinamento com base em requisitos e recursos de computação específicos.
Embora Gemma 2 ofereça funcionalidades impressionantes, é preciso estar ciente de suas limitações e considerações éticas:
Os recursos avançados do Gemma 2, como atenção de janela deslizante, limites superiores suaves e novas técnicas de fusão de modelos, tornam-no uma ferramenta poderosa para uma ampla gama de tarefas de processamento de linguagem natural.
Ao aproveitar o Gemma 2 em seus projetos, seja por meio de inferência simples, sistemas RAG complexos ou modelos ajustados específicos de domínio, você pode aproveitar o poder da IA SOTA enquanto mantém o controle de seus dados e processos.
Endereço original:https://www.unite.ai/guia-completo-sobre-o-novo-modelo-de-linguagem-aberta-do-google-gemma-2/
Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.
Correspondência[email protected]