Colab Magia

Questo blocco note introduce i comandi magici di Colab per PaLM. Con Magics è facile sviluppare, testare, confrontare e valutare i prompt all'interno di un blocco note di Colab.

Visualizza su ai.google.dev Esegui in Google Colab Visualizza il codice sorgente su GitHub

Configurazione

Segui le istruzioni qui sotto per installare e testare le magie.

Installazione della magia di PaLM

Per utilizzare i comandi magici PaLM in Colab o in un altro ambiente IPython, devi prima scaricare e installare il pacchetto Python google-generativeai.

%pip install -q google-generativeai

Caricamento della magia di PaLM

Quindi, carica la magia di %%palm usando la magia %load_ext:

%load_ext google.generativeai.notebook

Testa l'installazione

Per verificare la corretta installazione dei comandi magic, esegui %%palm --help. Tieni presente che avrai bisogno anche di una chiave API PaLM, se non ne hai già una (vedi il passaggio successivo).

%%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

Ottenere una chiave API PaLM

Per utilizzare l'API PaLM, devi creare una chiave API. Devi eseguire questo passaggio una sola volta.

Imposta la chiave API nel blocco note

Imposta la chiave API eseguendo la cella riportata di seguito.

%env GOOGLE_API_KEY=YOUR PALM KEY

Comandi magici PaLM: run, compile, compare e evaluate

PaLM Magics fornisce quattro diversi comandi:

  1. run
  2. compile
  3. compare
  4. evaluate

Comando: palm run

Il comando run invia i contenuti della cella al modello.

Dato che l'esecuzione dei prompt è molto comune, PaLM magics utilizza per impostazione predefinita il comando run se non viene fornito alcun comando. Ad esempio, le due celle successive sono identiche.

%%palm run
The opposite of hot is

%%palm
The opposite of hot is

Comprensione dell'output

La colonna Prompt mostra il testo inviato al modello, mentre la colonna text_result mostra il risultato. Le altre colonne verranno introdotte man mano che procedi nella guida.

Modelli di prompt

I prompt non devono essere stringhe fisse. Puoi inserire valori in un prompt utilizzando i segnaposto del modello usando {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

Comprensione dell'output

La colonna Input Num tiene traccia dell'indice della parola di input negli elenchi. In questi esempi, Input Num di 0 è 'hot' e 1 è 'cold'.

Specificare più insiemi di input

Puoi anche specificare più insiemi di input contemporaneamente.

extreme_temperatures = {
    'word': ['hot', 'cold']
}
minor_temperatures = {
    'word': ['warm', 'chilly']
}

%%palm --inputs extreme_temperatures minor_temperatures
The opposite of {word} is

Lettura dei dati da Fogli Google

La magia di PaLM può anche leggere e scrivere su Fogli Google. Per accedere ai dati di Fogli è necessario aver eseguito l'accesso. Questa sezione è incentrata sulla lettura dei dati di Fogli; una sezione successiva mostra come scrivere output in un foglio Google.

Accedi a Fogli e autorizza l'accesso

Formattazione di un foglio di lavoro da utilizzare con la magia di PaLM

Passa l'ID o l'URL di un foglio Google al flag --sheets_input_names per caricarlo come dati di modello.

Utilizza il formato seguente nel foglio di lavoro per usare i dati in un modello di prompt:

  1. Inserisci i nomi delle variabili (del modello di prompt) nella prima riga del foglio.
  2. Inserisci i dati da sostituire per ogni variabile nelle righe seguenti.

Ad esempio, se il modello di prompt ha due variabili da sostituire, name e temperament, scrivi il foglio di lavoro nel seguente modo:

nome temperamento
Milo impertinente
Bigsly rilassato
Subra timido 
%%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.

Fai una prova!

Per fare una prova con i tuoi dati, crea un nuovo foglio e trasmetti l'ID a --sheets_input_names. Oltre a ID e URL, puoi anche cercare nei tuoi fogli per titolo, ad esempio %%palm --sheets_input_names "Animal adjectives".

Combinazione degli input di Fogli con gli input Python

Gli input di Fogli possono anche essere combinati 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 per confrontare l'output di un prompt con dati empirici reali noti.

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:

Output del modello di post-elaborazione

Per eseguire test empirici reali, potrebbe essere necessario post-elaborare l'output del modello.

Le funzioni di post-elaborazione consentono di definire una funzione che elabora l'output del modello. Nel caso del comando eval, nel controllo di uguaglianza finale viene utilizzata solo la colonna dei risultati.

Usa il decorator post_process_replace_fn per definire una funzione da elaborare post-elaborazione dei risultati:

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 funzione extract_and_normalize definita sopra acquisirà l'output dal modello e ridurrà eventuali coppie di lingue ripetute, lasciando solo la prima risposta. Consulta la sezione Post-elaborazione per ulteriori informazioni sulla post-elaborazione.

%%palm eval --inputs test_data --ground_truth ground_truth | extract_and_normalize
English: Hello
French: Bonjour
English: {word}
French:

Comando: palm compile

Usa il comando %%palm compile per convertire un prompt con segnaposto in una funzione richiamabile dall'interno di Python.

Tutti i flag e la post-elaborazione sono "compilati" nella funzione e verranno utilizzati quando vengono richiamati.

In questo esempio, viene creata una funzione denominata translate_en_to_fr utilizzando la funzione di post-elaborazione extract_and_normalize di prima.

%%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})

Formati di output

Per impostazione predefinita, una funzione "compilata" restituisce il proprio output come oggetto che verrà visualizzato come Panda DataFrame. Tuttavia, puoi convertire l'oggetto dei risultati in un DataFrame o in un dizionario rispettivamente con .as_dict() o .as_dataframe().

Per maggiori informazioni, consulta il flag --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 esegue prompt compilati e produce una tabella con i risultati del confronto affiancati, in modo che tu possa esaminare le differenze.

%%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

Funzioni di confronto personalizzate

Per impostazione predefinita, compare verifica solo l'uguaglianza nei risultati restituiti. Tuttavia, puoi specificare una o più funzioni personalizzate con il flag --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

Altri comandi

Guida

Il flag --help mostra i comandi supportati che puoi passare direttamente a %%palm

Aggiungi --help per visualizzare la documentazione dettagliata di ciascun comando. Ad esempio:

%%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.

ottimizzabili

Utilizza il flag --model per specificare la variante del modello PaLM che vuoi utilizzare.

Utilizza il metodo list_models() per recuperare i modelli supportati. La magia di PaLM può essere utilizzata con qualsiasi modello che supporta il metodo generateText.

%%palm run --model models/text-bison-001
My favourite color is

Parametri del modello

Puoi anche configurare i parametri del modello, ad esempio --candidate_count e --temperature.

%%palm run --model models/text-bison-001 --temperature 0.5
My favourite color is

Debug: il modello eco

È disponibile anche un modello echo che ti restituirà il prompt. Poiché non effettua chiamate API né consuma la tua quota, può essere un modo semplice e veloce per testare l'output o la post-elaborazione.

%%palm --model_type echo
A duck's quack does not echo.

Esporta output in Python

Oltre a visualizzare un output tabulare, PaLM può salvare l'output del modello in variabili Python, consentendoti di manipolarle ulteriormente o di esportare i risultati.

In questo esempio, l'output viene salvato in una variabile Python: fave_colors

%%palm --outputs fave_colors
The best colors to wear in spring-time are

Le variabili di output sono oggetti personalizzati che vengono visualizzati come DataFrame Panda per impostazione predefinita. Possono essere forzati esplicitamente in un dizionario o in un dataframe Python chiamando 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.']}

Scrivi in Fogli Google

Puoi salvare l'output nuovamente in Fogli Google utilizzando --sheets_output_names. Devi aver eseguito l'accesso e disporre delle autorizzazioni appropriate per accedere a Fogli privati.

Per fare una prova, crea un nuovo foglio e assegnagli il nome Translation results. Come il flag di input, il flag --sheets_output_names accetta anche l'URL o l'ID del foglio al posto del nome testuale.

%%palm --inputs english_words --sheets_output_names "Translation results"
English: Hello
French: Bonjour
English: {word}
French:

I risultati vengono salvati in una nuova scheda e contengono gli stessi dati che vedi qui in Colab.

Esempio di un foglio salvato

Generazione di più candidati

Per generare più di un output per un singolo prompt, puoi passare --candidate_count al modello. Il valore predefinito è 1, che restituisce solo il risultato migliore.

A volte il modello genera lo stesso output tra i candidati. Questi possono essere filtrati con il flag --unique, che deduplica i risultati dal batch dei candidati (ma non in più prompt).

%%palm run --temperature 1.0 --candidate_count 8 --unique
In a single word, my favourite color is

La colonna Result Num consente di distinguere più candidati generati dallo stesso prompt.

Output del modello di post-elaborazione

L'ampia gamma di output e strutture possibili può rendere difficile adattare l'output del modello al dominio del problema. PaLM offre opzioni di post-elaborazione che permettono di modificare o elaborare l'output del modello utilizzando codice Python.

Le funzioni di post-elaborazione possono aggiungere una nuova colonna all'output o modificare la colonna text_result. La colonna text_result è l'ultima colonna ed è utilizzata dai comandi eval e compare per determinare l'output finale.

Di seguito sono riportate alcune funzioni di esempio da utilizzare nella post-elaborazione. Uno aggiunge una nuova colonna e l'altro aggiorna la colonna dei risultati, utilizzando il decorator 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

Per utilizzare queste funzioni, aggiungile al comando %%palm utilizzando l'operatore pipe (|), in questo modo.

%%palm run | word_count | extract_first_sentence
The happiest thing I can imagine is

L'ordine è importante qui. Quando viene richiamato word_count, l'output del modello originale viene utilizzato per calcolare il numero di parole. Se le cambi, il conteggio delle parole sarebbe invece il numero di parole nella prima frase estratta.

Per approfondire