Gemma es una familia de modelos abiertos creados a partir de la misma investigación y tecnología utilizada para crear los modelos de Gemini. Los modelos ajustados según las instrucciones se adaptan a un conjunto de datos masivo de instrucciones, por lo que son particularmente adecuados para tareas que requieren seguir indicaciones, como responder preguntas y resumir textos.
En esta entrada de blog, te orientaremos sobre el proceso de creación de un juego de aventuras basado en texto utilizando un modelo Gemma 2 ajustado según las instrucciones. Aunque puedes usar tu propia configuración, elegimos un viaje caprichoso. Te guiará un simpático y servicial compañero de IA conocido como el Narrador. El Narrador describirá paisajes encantadores, te presentará personajes curiosos y creará un cuento basado en tus elecciones. ¡Prepárate para embarcarte en una emocionante aventura en la que tus interacciones con la IA determinarán el resultado del juego!
Link to Youtube Video (visible only when JS is disabled)
En este cautivador juego, despiertas en una isla lejana. Tu único guía y compañero es el Narrador de IA, que te ayudará a superar los desafíos y encontrar una manera de escapar.
Consulta “Configuración de Gemma” para obtener acceso a Gemma en kaggle.com y generar una clave de API de Kaggle.
Si no cuentas con una máquina sólida para la ejecución local de Gemma, considera utilizar Vertex AI como tu app downstream para implementar modelos de Gemma. Vertex AI proporciona una plataforma administrada que permite un desarrollo y escalamiento rápidos de proyectos de aprendizaje automático sin la necesidad de experiencia interna en MLOps.
Primero, encuentra la tarjeta de modelo de Gemma 2 en Model Garden. Después de hacer clic en el botón “Implementar”, puedes elegir las variaciones del modelo y la ubicación donde lo vas a implementar.
Una vez que se complete la implementación, encontrarás el extremo aquí.
Si quieres obtener una secuencia de comandos para adquirir predicciones de tu extremo activo, ve a “Ejemplo de solicitud” y selecciona “Python”.
A continuación, te mostramos un ejemplo de una clase wrapper de chatbot de Gemma local. Puedes explorar más al respecto en “Crear un chatbot con Gemma”.
En nuestra demostración, usamos el modelo Gemma 2 2B. Sin embargo, si tienes hardware con capacidad suficiente, puedes elegir modelos alternativos de Gemma, como 9B o 27B, para obtener un resultado más sólido.
# 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
Si implementaste Gemma en Vertex AI, copia y pega el código de muestra de GitHub en el archivo de tu bot y usa el código que se incluye a continuación. Ten en cuenta que no tienes que inicializar la variable “self.model”, ya que se ejecuta en 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 probar tu bot, usa el siguiente código sencillo. (Asumimos que guardaste el código anterior 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)
Te mostramos un ejemplo de salida del bot.
En caso de que no sepas de qué se trata el bucle del juego, te contamos que es el proceso central que impulsa la funcionalidad y la interactividad del juego. Es un ciclo continuo que se repite durante todo el juego y garantiza que el estado del juego se actualice, la entrada se procese y las imágenes se rendericen en la pantalla.
En nuestro sencillo juego de aventuras basado en texto, implementamos un bucle de juego básico de la siguiente manera:
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 el proceso, diseñamos una clase de interfaz de etapa básica. Puedes ampliar esta clase y establecer tu propia configuración de etapa personalizada si creas una etapa nueva.
Por ejemplo, puedes crear una etapa nueva con una puerta de acero como la siguiente.
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.")
Con Gemma, dominaste la creación de juegos de aventura basados en texto. Puedes aplicar la misma estructura para crear diversos juegos con temas que van desde el steampunk hasta la fantasía.
Además, puedes integrar tus propios conceptos en las mecánicas de juego básicas, como la progresión basada en habilidades, la generación de relaciones o incluso los minijuegos.
Ten en cuenta que esto sirve como punto de partida fundamental. No dudes en combinar, adaptar y ampliar estos elementos para crear una experiencia de juego de aventuras basado en texto genuinamente única y cautivadora.
Considera unirte al servidor de Discord de la comunidad de desarrolladores de Google, donde tendrás la oportunidad de mostrar tus proyectos y forjar conexiones con otros aficionados que comparten tus intereses.
Gracias por leer.
Cómo creamos Purrfect Code: un juego de habilidad mental para desarrolladores
Gemma para transmisión de aprendizaje automático con Dataflow
Todo sobre Gemma: arquitectura PaliGemma
Todo sobre Gemma: arquitectura RecurrentGemma
TensorFlow Lite ahora es LiteRT