O Gemma é uma família de modelos abertos criados a partir da mesma pesquisa e tecnologia utilizada para criar os modelos Gemini. O ajuste por instruções dos modelos ocorre em um enorme conjunto de dados de instruções, tornando o modelo particularmente adequado para tarefas que requerem seguir instruções, como respostas a perguntas e o resumo de texto.
Nesta postagem do blog, guiaremos você pelo processo de criação de um jogo de aventura baseado em texto usando um modelo Gemma 2 ajustado por instruções. Embora você possa usar sua própria configuração, escolhemos uma jornada pitoresca. Você terá como guia um amigável e prestativo companheiro de IA conhecido como Storyteller (contador de histórias). O Storyteller descreverá cenários encantadores, apresentará personagens curiosos e tecerá um conto com base nas suas escolhas! Prepare-se para embarcar em uma aventura emocionante, na qual suas interações com a IA determinarão o resultado do jogo!
Link to Youtube Video (visible only when JS is disabled)
Neste jogo cativante, você, o jogador, desperta em uma ilha remota. Seu único guia e companheiro é a IA Storyteller, que ajudará você a navegar pelos desafios e encontrar uma maneira de escapar.
Consulte "Gemma setup" para obter acesso ao Gemma no kaggle.com e gerar uma chave de API do Kaggle.
Se você não tiver uma máquina robusta para a execução local do Gemma, considere utilizar a Vertex AI como aplicativo de downstream para implantar os modelos Gemma. A Vertex AI fornece uma plataforma gerenciada que permite o rápido desenvolvimento e escalonamento de projetos de aprendizado de máquina sem a necessidade de experiência interna em MLOps.
Primeiro, localize o cartão de modelo Gemma 2 no Model Garden. Depois de clicar no botão "Deploy", você poderá escolher as variações do modelo e o local de implantação.
Quando a implantação for concluída, você poderá encontrar seu ponto de extremidade aqui.
Para obter um script para adquirir previsões de seu ponto de extremidade ativo, navegue para "Sample Request" e selecione "Python".
Segue um exemplo de uma classe wrapper de bot de chat do Gemma local. Você pode saber mais sobre isso em "Como criar um bot de chat com o Gemma".
Em nossa demonstração, empregamos o modelo 2B do Gemma 2. No entanto, se você tiver recursos de hardware suficientes, poderá optar por modelos Gemma alternativos, como 9B ou 27B, para obter um resultado mais robusto.
# Gemma local
import keras
import keras_nlp
model_name = "gemma2_instruct_2b_en"
class GemmaBot():
__START_TURN_USER__ = "<start_of_turn>user\n"
__START_TURN_MODEL__ = "<start_of_turn>model\n"
__END_TURN__ = "<end_of_turn>\n"
def __init__(self, system=""):
self.model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)
self.system = system
self.history = []
def add_to_history_as_user(self, message):
self.history.append(self.__START_TURN_USER__ + message + self.__END_TURN__)
def add_to_history_as_model(self, message):
self.history.append(self.__START_TURN_MODEL__ + message)
def get_history(self):
return "".join([*self.history])
def get_full_prompt(self):
prompt = self.get_history() + self.__START_TURN_MODEL__
if len(self.system)>0:
prompt = self.system + "\n" + prompt
return prompt
def ask(self, message):
self.add_to_history_as_user(message)
prompt = self.get_full_prompt()
response = self.model.generate(prompt, max_length=2048)
result = response.replace(prompt, "") # Extract only the new response
self.add_to_history_as_model(result)
return result
Se você tiver implantado o Gemma na Vertex AI, copie e cole o exemplo de código no Github em seu arquivo de bot e use o código abaixo. Observe que você não precisa inicializar a variável "self.model" porque ela está em execução no Google Cloud.
def __init__(self, system=""):
self.system = system
self.history = []
:
<-- skip -->
:
def ask(self, message):
self.add_to_history_as_user(message)
prompt = self.get_full_prompt()
response = predict_custom_trained_model_sample(
project="<YOUR_PROJECT_ID>",
endpoint_id="<YOUR_ENDPONT_ID>",
location="<YOUR_LOCATION>",
api_endpoint="<YOUR_LOCATION>-aiplatform.googleapis.com",
instances={ "inputs": prompt, "max_tokens": 2048 }
)
result = response.replace(prompt, "") # Extract only the new response
self.add_to_history_as_model(result)
return result
Para testar o bot, use o código direto a seguir. (Supondo-se que você tenha salvado o código acima como "gemma.py".)
from gemma import GemmaBot
gemma_bot = GemmaBot("You are the Storyteller, guide on this remote island.")
text = gemma_bot.ask("Who are you?")
print(text)
Este é um exemplo de saída do bot.
Caso você não tenha familiaridade com o loop de jogo, ele é o processo central que orienta a funcionalidade e interatividade do jogo. Trata-se de um ciclo contínuo que se repete durante a jogabilidade, garantindo que o estado do jogo seja atualizado, a entrada seja processada e os recursos visuais sejam renderizados na tela.
Em nosso jogo de aventura simples baseado em texto, implementamos um loop de jogo básico da seguinte forma:
import StageIntro
current_stage = StageIntro.StageIntro()
def game_loop():
if current_stage.bot is None:
# stage type that has no bot
current_stage.process()
return
resp = ""
print("-"*80)
print(f"Type \"{current_stage.cmd_exit}\" if you want to end the conversation.")
print("-"*80)
if current_stage.preamble != "":
print(current_stage.preamble)
while resp != current_stage.cmd_exit:
if resp == "":
text = current_stage.intro
current_stage.bot.add_to_history_as_model(text)
else:
text = current_stage.bot.ask(resp)
print(text)
resp = input("\n> ")
prompt(admin_bot.judge(current_stage.bot.get_history()))
def check_end_condition():
if not current_stage.pass_check():
check = admin_bot.end_of_game()
print("Succeed to escape?")
print(check)
if check.lower().startswith("true"):
print("Congratulations! You escaped the island.")
exit(0)
next_stage = current_stage.next()
if next_stage is None:
print("End Of Game")
exit(0)
return next_stage
while True:
game_loop()
current_stage = check_end_condition()
input("Press ENTER to move forward")
Para simplificar o processo, projetamos uma classe básica de interface de cenário. Você pode estender essa classe e estabelecer sua própria configuração de cenário personalizada criando um novo cenário.
Por exemplo, você pode criar um novo cenário com um portão de aço, como abaixo.
from stage import IStage
from gemma import GemmaBot
class StageGate(IStage):
def __init__(self):
self.preamble = "The steel gate looms before you, a formidable barrier separating you from the path ahead. Vines crawl along its rusted bars, and the air hums with a faint electrical current.\nThe Storyteller appears beside you, a shimmering presence in the dappled sunlight."
self.intro = "Greetings! I am the Storyteller, your guide on this island.\nWe've come to a gate... what will you do?"
self.bot = GemmaBot("You are the Storyteller, a friendly and helpful AI guide on a mysterious island. Your role is to help the player navigate challenges and find a way to escape. You are currently standing before a large steel gate.")
Com o Gemma, você dominou a criação de jogos de aventura baseados em texto. Você pode aplicar a mesma estrutura para criar diversos jogos com temas que vão do steampunk à fantasia.
E você ainda pode integrar seus próprios conceitos para a mecânica central do jogo, como progressão baseada em habilidades, construção de relacionamentos ou até mesmo minijogos.
Tenha em mente que isto serve como um ponto de partida. Sinta-se à vontade para combinar, adaptar e expandir esses elementos a fim de criar uma experiência de jogo de aventura baseado em texto genuinamente única e cativante.
Considere participar do servidor Discord da comunidade de desenvolvedores do Google, onde você terá a oportunidade de apresentar projetos e estabelecer conexões com outros entusiastas que compartilham interesses semelhantes.
Agradecemos a leitura.
Gemma para ML de streaming com o Dataflow
Explicação sobre o Gemma: arquitetura do PaliGemma
Como criamos o Purrfect Code: um quebra-cabeças para desenvolvedores
O TensorFlow Lite agora se chama LiteRT
Explicação sobre o Gemma: arquitetura do RecurrentGemma