CodeGemma: IA para auxiliar no desenvolvimento de códigos
CodeGemma é um poderoso conjunto de modelos de IA desenvolvido pelo Google. Pertencentes à família Gemma, os novos modelos foram projetados especificamente para tarefas de geração e conclusão de códigos. Treinados em mais de 500 bilhões de tokens formados principalmente por documentos em inglês, códigos e matemática, o conjunto de modelos CodeGemma alcança desempenho de última geração. Seus modelos oferecem suporte a várias linguagens de programação, incluindo Python, JavaScript, Java e outras.
Além dessas vantagens, os modelos CodeGemma possuem um recurso especializado de preenchimento do meio (fill-in-the-middle, FIM). Eles podem inserir códigos com base no contexto circundante, antes e depois da posição do cursor.
O CodeGemma pode ser facilmente integrado a frameworks populares de IA como o KerasNLP. Isso o torna bastante acessível a desenvolvedores já familiarizados com essas ferramentas.
Ao contrário de alguns assistentes de codificação de IA proprietários, o CodeGemma é de código aberto. Porém, para usar os modelos da família, é preciso concordar com os termos de uma licença específica criada pelo Google.
Os modelos CodeGemma podem ser obtidos em vários locais incluindo Hugging Face e Ollama.
Três versões de modelos
A família possui três variantes principais:
CodeGemma 2B: modelo otimizado para conclusão e geração rápidas de código, adequado para sugestões de código em tempo real.
CodeGemma 7B: modelo pré-treinado para conclusão e geração de códigos. Ele se caracteriza por seu forte desempenho superando os modelos básicos do conjunto Gemma em termos de tarefas de codificação.
CodeGemma 7B Instruction-Tuned: versão ajustada para seguir instruções e codificar conversas. Essa variante permite interações em linguagem natural, facilitando a geração de código a partir de descrições em inglês.
CodeGemma com Hugging Face Transformers em Python
O uso do CodeGemma varia com a versão do modelo. Para as versões sem ajuste para instruções, ele funciona principalmente completando e gerando códigos. Os prompts para essas tarefas seguem padrões bem específicos. Os modelos CodeGemma com instruções aceitam prompts linguísticos. Para usar as versões sem ajuste para instruções, é preciso utilizar códigos equivalentes a esse:
from transformers import GemmaTokenizer, AutoModelForCausalLM
import torch
model_id = "google/codegemma-2b"
tokenizer = GemmaTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.float16
).to("cuda:0")
prompt = '''
<|fim_prefix|>import datetime
def calculate_age(birth_year):
"""Calculates a person's age based on their birth year."""
current_year = datetime.date.today().year
<|fim_suffix|>
return age<|fim_middle|>
'''
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
prompt_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0][prompt_len:]))
Esse código executa o CodeGemma 2B obtido na Hugging Face. Para utilizá-lo, consulte a documentação sobre os requisitos de instalação (transformers, PyTorch, etc).
No exemplo acima, o prompt utilizado é um trecho de código que o modelo deve completar. Os seguintes tokens são usados para separar as diferentes partes do prompt:
<|fim_prefix|> precede o contexto antes da conclusão que queremos executar.
<|fim_suffix|> precede o sufixo. Você precisa colocar esse token exatamente onde o cursor seria posicionado em um editor, pois esse é o local que será concluído pelo modelo.
<|fim_middle|> é o prompt que convida o modelo a executar a geração.
<|file_separator|> é usado para fornecer contextos de vários arquivos.
CodeGemma com Ollama em Python
Para usar um dos modelos com Ollama, a versão desejada precisa ser baixada. Por exemplo, para utilizar o modelo 2B, o comando para baixá-lo é:
ollama pull codegemma:2b
O uso do modelo 2B com Ollama é equivalente ao demonstrado com Hugging Face Transformers. Ele possui os mesmos parâmetros. Veja um exemplo abaixo usando o mesmo prompt mostrado anteriormente:
import ollama
# Inicia o modelo
model = ollama.Client()
# Define um prompt
prompt = '''
<|fim_prefix|>import datetime
def calculate_age(birth_year):
"""Calculates a person's age based on their birth year."""
current_year = datetime.date.today().year
<|fim_suffix|>
return age<|fim_middle|>
'''
# Gera resposta
response = model.generate(
model='codegemma:2b',
prompt=prompt,
options={
'num_predict': 128,
'temperature': 0,
'top_p': 0.9,
'stop': ['<|file_separator|>'],
}
)
# Imprime resposta obtida
print(response['response'])
# resultado
# <|fim_prefix|>
# import datetime
# def calculate_age(birth_year):
# """Calculates a person's age based on their birth year."""
# current_year = datetime.date.today().year
# age = current_year - birth_year
# return age
# def main():
# """Main function to run the program."""
# birth_year = int(input("Enter your birth year: "))
# age = calculate_age(birth_year)
# print(f"You are {age} years old.")
# if __name__ == "__main__":
Para conhecer mais sobre os modelos CodeGemma, uma boa fonte é o artigo oficial descrevendo a família.
