En este notebook, se presentan los comandos mágicos de Colab para PaLM. Con los comandos mágicos, es más fácil desarrollar, probar, comparar y evaluar instrucciones desde un notebook de Colab.
 Ver en ai.google.dev
|
 Ejecutar en Google Colab
|
 Ver código fuente en GitHub
|
Instalar
Sigue los pasos que se indican a continuación para instalar y probar los comandos mágicos.
Instala la magia de PaLM
Para usar los comandos mágicos de PaLM en Colab o en otro entorno de IPython, primero debes descargar y, luego, instalar el paquete de Python google-generativeai.
%pip install -q google-generativeai
Carga la magia de PaLM
A continuación, carga el comando mágico %%palm con el comando mágico %load_ext:
%load_ext google.generativeai.notebook
Prueba la instalación
Para probar la instalación correcta de los comandos mágicos, ejecuta %%palm --help. Ten en cuenta que también necesitarás una clave de API de PaLM, si aún no la tienes (consulta el siguiente paso).
%%palm --help
usage: palm [-h] {run,compile,compare,eval} ...
A system for interacting with LLMs.
positional arguments:
{run,compile,compare,eval}
options:
-h, --help show this help message and exit
Cómo obtener una clave de API de PaLM
Para usar la API de PaLM, tendrás que crear una clave de API. (solo debes realizar este paso una vez).
Establece la clave de API en el notebook
Ejecuta la siguiente celda para establecer tu clave de API.
%env GOOGLE_API_KEY=YOUR PALM KEY
Comandos mágicos de PaLM: run, compile, compare y evaluate
Los comandos mágicos de PaLM proporcionan cuatro comandos diferentes:
runcompilecompareevaluate
Comando: palm run
El comando run envía el contenido de la celda al modelo.
Como la ejecución de instrucciones es muy común, los comandos mágicos de PaLM usan el comando run de forma predeterminada si no se da ningún comando. Por ejemplo, las dos celdas siguientes son idénticas.
%%palm run
The opposite of hot is
%%palm
The opposite of hot is
Comprende el resultado
La columna Prompt muestra el texto que se envió al modelo, y la columna text_result muestra el resultado. Las otras columnas se presentarán a medida que avances en esta guía.
Plantillas de instrucciones
No es necesario que las instrucciones sean cadenas fijas. Puedes insertar valores en un mensaje con los marcadores de posición de la plantilla si usas {curly braces}.
english_words = {
# Each value here (hot, cold) will be substituted in for {word} in the prompt
'word': ['hot', 'cold']
}
%%palm --inputs english_words
The opposite of {word} is
Comprende el resultado
La columna Input Num hace un seguimiento del índice de la palabra de entrada en las listas. En estos ejemplos, Input Num de 0 es 'hot' y 1 es 'cold'.
Especifica varios conjuntos de entradas
También puedes especificar varios conjuntos de entradas a la vez.
extreme_temperatures = {
'word': ['hot', 'cold']
}
minor_temperatures = {
'word': ['warm', 'chilly']
}
%%palm --inputs extreme_temperatures minor_temperatures
The opposite of {word} is
Lectura de datos de Hojas de cálculo de Google
La magia de PaLM también puede leer y escribir en Hojas de cálculo de Google. Deberás haber iniciado sesión para acceder a los datos de Hojas de cálculo. Esta sección se centra en la lectura de datos de Hojas de cálculo; en la sección posterior se muestra cómo puedes escribir resultados en una Hoja de cálculo de Google.
Accede y autoriza el acceso a Hojas de cálculo
Formatear una hoja de cálculo para usarla con la magia de PaLM
Pasa el ID o la URL de una hoja de cálculo de Google a la marca --sheets_input_names para cargarla como datos de plantilla.
Usa el siguiente formato en tu hoja de cálculo para usar los datos en una plantilla de instrucción:
- Coloca los nombres de las variables (de la plantilla de instrucción) en la primera fila de la hoja.
- Coloca los datos que van a sustituir cada variable en las filas siguientes.
Por ejemplo, si tu plantilla de instrucción tiene dos variables que sustituir, name y temperament, deberías escribir tu hoja de cálculo de la siguiente manera:
| name | temperamento |
|---|---|
| Milo | descarada |
| Bigsly | relajado |
| Subra | tímido |
%%palm --sheets_input_names https://docs.google.com/spreadsheets/d/1UHfpkmBqIX5RjeJcGXOevIEhMmEoKlf5f9teqwQyHqc/edit
Create a single sentence description of a monkey's personality. The monkey's name is {name} and it has a {temperament} temperament.
Pruébalo.
Para probar esto con tus propios datos, crea una hoja de cálculo nueva y pasa el ID a --sheets_input_names. Además de usar el ID y la URL, también puedes buscar tus hojas por título, p.ej., %%palm --sheets_input_names "Animal adjectives".
Cómo combinar entradas de Hojas de cálculo con entradas de Python
Las entradas de Hojas de cálculo también se pueden combinar con --inputs:
new_monkeys = {
'name': ['Hackerella'],
'temperament': ['clever'],
}
%%palm --inputs new_monkeys --sheets_input_names 1UHfpkmBqIX5RjeJcGXOevIEhMmEoKlf5f9teqwQyHqc 1UHfpkmBqIX5RjeJcGXOevIEhMmEoKlf5f9teqwQyHqc
Create a single sentence description of a monkey's personality. The monkey's name is {name} and it has a {temperament} temperament.
Comando: palm eval
Usa %%palm eval para comparar el resultado de una instrucción con datos de verdad fundamental conocidos.
test_data = {
"word": ["dog", "cat", "house"]
}
ground_truth = ["chien", "chat", "maison"]
%%palm eval --inputs test_data --ground_truth ground_truth
English: Hello
French: Bonjour
English: {word}
French:
Salidas del modelo posterior al procesamiento
Para realizar pruebas de verdad fundamental, es posible que tengas que procesar posteriormente la salida del modelo.
Las funciones de procesamiento posterior te permiten definir una función que procese el resultado del modelo. En el caso del comando eval, solo se usa la columna de resultados en la verificación de igualdad final.
Usa el decorador post_process_replace_fn para definir una función que posprocese los resultados:
from google.generativeai.notebook import magics
# Define a function to extract only the first response.
@magics.post_process_replace_fn
def extract_and_normalize(input):
first_line, *unused = input.split('English:')
return first_line.strip().lower()
La función extract_and_normalize definida anteriormente tomará la salida del modelo y recortará los pares de idiomas repetidos y dejará solo la primera respuesta. Consulta la sección posprocesamiento para obtener más información al respecto.
%%palm eval --inputs test_data --ground_truth ground_truth | extract_and_normalize
English: Hello
French: Bonjour
English: {word}
French:
Comando: palm compile
Usa el comando %%palm compile para convertir un mensaje con marcadores de posición en una función que admita llamadas desde Python.
Todas las marcas y el procesamiento posterior se “compilan” en la función y se usarán cuando se las invoque.
En este ejemplo, se crea una función llamada translate_en_to_fr con la función de procesamiento posterior extract_and_normalize antes.
%%palm compile translate_en_to_fr | extract_and_normalize
English: Hello
French: Bonjour
English: {word}
French:
'Saved function to Python variable: translate_en_to_fr'
en_words = ['cat', 'dog']
translate_en_to_fr({'word': en_words})
Formatos de salida
De forma predeterminada, una función “compilada” muestra su resultado como un objeto que se mostrará como Pandas DataFrame. Sin embargo, puedes convertir el objeto de resultados en una DataFrame o un diccionario con .as_dict() o .as_dataframe(), respectivamente.
Para obtener más información, consulta la marca --outputs.
results = translate_en_to_fr({'word': en_words}).as_dict()
fr_words = results['text_result']
for en, fr in zip(en_words, fr_words):
print(f'{fr} is French for {en}')
chat is French for cat chien is French for dog
Comando: palm compare
%%palm compare ejecuta mensajes compilados y produce una tabla con los resultados de la comparación en paralelo, por lo que puedes inspeccionar las diferencias.
%%palm compile few_shot_prompt
English: Hello
French: Bonjour
English: {word}
French:
'Saved function to Python variable: few_shot_prompt'
%%palm compile zero_shot_prompt
{word} translated to French is:
'Saved function to Python variable: zero_shot_prompt'
words = {
"word": ["dog", "cat", "house"]
}
%%palm compare few_shot_prompt zero_shot_prompt --inputs words
Funciones de comparación personalizadas
De forma predeterminada, compare solo verifica la igualdad en los resultados que se muestran. Sin embargo, puedes especificar una o más funciones personalizadas con la marca --compare_fn.
def average_word_length(lhs, rhs):
"""Count the average number of words used across prompts."""
return (len(lhs.split(' ')) + len(rhs.split(' '))) / 2
def shortest_answer(lhs, rhs):
"""Label the prompt that generated the shortest output."""
if len(lhs) < len(rhs):
return 'first'
elif len(lhs) > len(rhs):
return 'second'
else:
return 'same'
%%palm compare few_shot_prompt zero_shot_prompt --inputs words --compare_fn average_word_length shortest_answer
Otros comandos
Ayuda
La marca --help muestra los comandos compatibles que puedes pasar directamente a %%palm.
Agrega --help para ver la documentación detallada de cada comando. Por ejemplo,
%%palm run --help
usage: palm run [-h] [--model_type {echo,text}] [--temperature TEMPERATURE]
[--model MODEL] [--candidate_count CANDIDATE_COUNT] [--unique]
[--inputs INPUTS [INPUTS ...]]
[--sheets_input_names SHEETS_INPUT_NAMES [SHEETS_INPUT_NAMES ...]]
[--outputs OUTPUTS [OUTPUTS ...]]
[--sheets_output_names SHEETS_OUTPUT_NAMES [SHEETS_OUTPUT_NAMES ...]]
options:
-h, --help show this help message and exit
--model_type {echo,text}, -mt {echo,text}
The type of model to use.
--temperature TEMPERATURE, -t TEMPERATURE
Controls the randomness of the output. Must be
positive. Typical values are in the range: [0.0, 1.0].
Higher values produce a more random and varied
response. A temperature of zero will be deterministic.
--model MODEL, -m MODEL
The name of the model to use. If not provided, a
default model will be used.
--candidate_count CANDIDATE_COUNT, -cc CANDIDATE_COUNT
The number of candidates to produce.
--unique Whether to dedupe candidates returned by the model.
--inputs INPUTS [INPUTS ...], -i INPUTS [INPUTS ...]
Optional names of Python variables containing inputs
to use to instantiate a prompt. The variable must be
either: a dictionary {'key1': ['val1', 'val2'] ...},
or an instance of LLMFnInputsSource such as
SheetsInput.
--sheets_input_names SHEETS_INPUT_NAMES [SHEETS_INPUT_NAMES ...], -si SHEETS_INPUT_NAMES [SHEETS_INPUT_NAMES ...]
Optional names of Google Sheets to read inputs from.
This is equivalent to using --inputs with the names of
variables that are instances of SheetsInputs, just
more convenient to use.
--outputs OUTPUTS [OUTPUTS ...], -o OUTPUTS [OUTPUTS ...]
Optional names of Python variables to output to. If
the Python variable has not already been defined, it
will be created. If the variable is defined and is an
instance of LLMFnOutputsSink, the outputs will be
written through the sink's write_outputs() method.
--sheets_output_names SHEETS_OUTPUT_NAMES [SHEETS_OUTPUT_NAMES ...], -so SHEETS_OUTPUT_NAMES [SHEETS_OUTPUT_NAMES ...]
Optional names of Google Sheets to write inputs to.
This is equivalent to using --outputs with the names
of variables that are instances of SheetsOutputs, just
more convenient to use.
ajustables
Usa la marca --model para especificar la variante del modelo de PaLM que quieres usar.
Consulta el método list_models() para recuperar los modelos compatibles. El comando mágico de PaLM se puede usar con cualquier modelo que admita el método generateText.
%%palm run --model models/text-bison-001
My favourite color is
Parámetros del modelo
También puedes configurar parámetros del modelo, como --candidate_count y --temperature.
%%palm run --model models/text-bison-001 --temperature 0.5
My favourite color is
Depuración: El modelo echo
También hay un modelo echo disponible que te repetirá el mensaje. No realiza llamadas a la API ni consume tu cuota, por lo que puede ser una forma rápida y sencilla de probar resultados o procesamientos posteriores.
%%palm --model_type echo
A duck's quack does not echo.
Exporta el resultado a Python
Además de mostrar resultados tabulares, el comando mágico de PaLM puede guardar la salida del modelo en variables de Python, lo que te permite manipularlas aún más o exportar los resultados.
En este ejemplo, el resultado se guarda en una variable de Python: fave_colors
%%palm --outputs fave_colors
The best colors to wear in spring-time are
Las variables de salida son objetos personalizados que se mostrarán como DataFrame de Pandas de forma predeterminada. Se pueden forzar a un diccionario de Python o a un marco de datos de manera explícita llamando a as_dict() o as_pandas_dataframe().
from pprint import pprint
pprint(fave_colors.as_dict())
{'Input Num': [0],
'Prompt': ['The best colors to wear in spring-time are'],
'Prompt Num': [0],
'Result Num': [0],
'text_result': ['* Pastels: These soft, muted colors are perfect for the '
'springtime, as they are fresh and airy. Some popular pastel '
'colors include baby blue, mint green, and pale pink.\n'
'* Brights: If you want to make a statement, bright colors '
'are a great option for spring. Some popular bright colors '
'include fuchsia, cobalt blue, and yellow.\n'
'* Neutrals: Neutral colors are always a good choice, as they '
'can be easily dressed up or down. Some popular neutrals '
'include beige, gray, and white.\n'
'\n'
'When choosing colors to wear in the spring, it is important '
'to consider the occasion and your personal style. For '
'example, if you are attending a formal event, you may want '
'to choose a more muted color palette, such as pastels or '
'neutrals. If you are going for a more casual look, you may '
'want to choose brighter colors, such as brights or pastels.']}
Escribir en Hojas de cálculo de Google
Puedes volver a guardar los resultados en Hojas de cálculo de Google con --sheets_output_names. Debes acceder a tu cuenta y tener los permisos adecuados para acceder a Hojas de cálculo privadas.
Para probar esto, crea una hoja de cálculo nueva y asígnale el nombre Translation results. Al igual que la marca de entrada, la marca --sheets_output_names también acepta la URL o el ID de la hoja en lugar del nombre textual.
%%palm --inputs english_words --sheets_output_names "Translation results"
English: Hello
French: Bonjour
English: {word}
French:
Los resultados se guardan en una pestaña nueva y contienen los mismos datos que ves aquí en Colab.
Genera varios candidatos
A fin de generar más de un resultado para una sola instrucción, puedes pasar --candidate_count al modelo. Se establece en 1 de forma predeterminada, lo que genera solo el resultado principal.
A veces, el modelo generará el mismo resultado en todos los candidatos. Estos se pueden filtrar con la marca --unique, que anula los resultados duplicados fuera del lote de candidatos (pero no en varios mensajes).
%%palm run --temperature 1.0 --candidate_count 8 --unique
In a single word, my favourite color is
La columna Result Num distingue entre varios candidatos generados a partir de la misma instrucción.
Salida del modelo de procesamiento posterior
La amplia gama de resultados y estructuras posibles puede dificultar la adaptación de la salida del modelo al dominio del problema. La magia de PaLM proporciona opciones de posprocesamiento que te permiten modificar o procesar la salida del modelo con código de Python.
Las funciones de procesamiento posterior pueden agregar una columna nueva al resultado o modificar la columna text_result. La columna text_result es la última, y la usan los comandos eval y compare para determinar el resultado final.
Estas son algunas funciones de muestra que puedes usar en el posprocesamiento. Uno agrega una columna nueva y la otra actualiza la columna de resultados mediante el decorador post_process_replace_fn.
import re
from google.generativeai.notebook import magics
# Add a new column.
def word_count(result):
return len(result.split(' '))
# Modify the text_result column
@magics.post_process_replace_fn
def extract_first_sentence(result):
"""Extracts the first word from the raw result."""
first, *_ = re.split(r'\.\s*', result)
return first
Para usar estas funciones, agrégalos al comando %%palm con el operador de barra vertical (|), de esta manera.
%%palm run | word_count | extract_first_sentence
The happiest thing I can imagine is
El orden es importante aquí. Cuando se invoca word_count, la salida del modelo original se usa para calcular la cantidad de palabras. Si las cambias, el recuento de palabras será el número de palabras de la primera oración extraída.
Lecturas adicionales
- Consulta la guía de conceptos de LLM para obtener más información sobre los LLM.
- Consulta los lineamientos de instrucciones y obtén más información para crear instrucciones y sacar el máximo provecho del trabajo con PaLM.
- Para crear prototipos y experimentar con diferentes indicaciones, consulta Google AI Studio. Además, consulta la guía de inicio rápido de Google AI Studio para obtener más información.