Colab-Magie

Dieses Notebook stellt magische Colab-Befehle für PaLM vor. Mit Magien lassen sich Prompts innerhalb eines Colab-Notebooks ganz einfach entwickeln, testen, vergleichen und bewerten.

Auf ai.google.dev ansehen In Google Colab ausführen Quelle auf GitHub ansehen

Einrichtung

Folge den Schritten unten, um die magischen Geräte zu installieren und zu testen.

PaLM-Magie installieren

Wenn Sie die magischen PaLM-Befehle in Colab oder einer anderen IPython-Umgebung verwenden möchten, müssen Sie zuerst das Python-Paket google-generativeai herunterladen und installieren.

%pip install -q google-generativeai

PaLM-Magie wird geladen

Laden Sie als Nächstes den magischen %%palm-Befehl mithilfe von %load_ext:

%load_ext google.generativeai.notebook

Installation testen

Führen Sie %%palm --help aus, um zu testen, ob die magischen Befehle korrekt installiert wurden. Sie benötigen außerdem einen PaLM API-Schlüssel, falls Sie noch keinen haben (siehe nächster Schritt).

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

PaLM API-Schlüssel abrufen

Wenn Sie die PaLM API verwenden möchten, müssen Sie einen API-Schlüssel erstellen. Dieser Schritt muss nur einmal ausgeführt werden.

API-Schlüssel im Notebook festlegen

Legen Sie Ihren API-Schlüssel fest, indem Sie die Zelle unten ausführen.

%env GOOGLE_API_KEY=YOUR PALM KEY

Magische PaLM-Befehle: run, compile, compare und evaluate

PaLM-Magien bietet vier verschiedene Befehle:

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

Befehl: palm run

Mit dem Befehl run wird der Inhalt der Zelle an das Modell gesendet.

Da Aufforderungen häufig ausgeführt werden, wird von PaLM Magics standardmäßig der Befehl run verwendet, wenn kein Befehl angegeben wird. Die nächsten beiden Zellen sind beispielsweise identisch.

%%palm run
The opposite of hot is

%%palm
The opposite of hot is

Die Ausgabe verstehen

Die Spalte Prompt zeigt den Text an, der an das Modell gesendet wurde, und die Spalte text_result das Ergebnis. Die anderen Spalten werden im Verlauf dieses Leitfadens eingeführt.

Prompt-Vorlagen

Bei Prompts muss es sich nicht um feste Strings handeln. Mithilfe von {curly braces} können Sie mithilfe von Vorlagenplatzhaltern Werte in einen Prompt einfügen.

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

Die Ausgabe verstehen

Die Spalte Input Num verfolgt den Index des Eingabeworts in den Listen. In diesen Beispielen ist Input Num von 0 'hot' und 1 ist 'cold'.

Mehrere Gruppen von Eingaben angeben

Sie können auch mehrere Gruppen von Eingaben gleichzeitig angeben.

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

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

Daten werden aus Google Tabellen gelesen

Die PaLM-Magie kann auch Daten in Google Tabellen lesen und schreiben. Sie müssen angemeldet sein, um auf Daten aus Google Tabellen zugreifen zu können. In diesem Abschnitt geht es um das Lesen von Daten aus Google Tabellen. In einem weiteren Abschnitt erfahren Sie, wie Sie Ausgaben in eine Google-Tabelle schreiben können.

Anmelden und Zugriff auf Google Tabellen gewähren

Tabellenkalkulationen für die Verwendung mit PaLM-Magie formatieren

Übergeben Sie die ID oder URL einer Google-Tabelle an das Flag --sheets_input_names, um sie als Vorlagendaten zu laden.

Verwenden Sie das folgende Format in Ihrer Tabellenkalkulation, um die Daten in einer Eingabeaufforderungsvorlage zu verwenden:

  1. Geben Sie die Namen der Variablen (Ihrer Eingabeaufforderungsvorlage) in die erste Zeile des Tabellenblatts ein.
  2. Tragen Sie die zu ersetzenden Daten in die Zeilen darunter ein.

Wenn Ihre Aufforderungsvorlage beispielsweise zwei zu ersetzende Variablen enthält, name und temperament, würden Sie Ihre Tabelle wie folgt schreiben:

name Temperament
Milo frech
Bigsly entspannt
Subra schüchtern 
%%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.

Probieren Sie es selbst aus!

Wenn Sie dies mit Ihren eigenen Daten ausprobieren möchten, erstellen Sie eine neue Tabelle und übergeben Sie die ID an --sheets_input_names. Neben ID und URL können Sie Ihre Tabellenblätter auch nach Titel suchen, z.B. „%%palm --sheets_input_names "Animal adjectives"“.

Eingaben aus Google Tabellen mit Python-Eingaben kombinieren

Eingaben in Google Tabellen können auch mit --inputs kombiniert werden:

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.

Befehl: palm eval

Verwenden Sie %%palm eval, um die Ausgabe eines Prompts mit bekannten Ground-Truth-Daten zu vergleichen.

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:

Modellausgaben nach der Verarbeitung

Für Ground-Truth-Tests müssen Sie möglicherweise die Modellausgabe nachbearbeiten.

Mit Funktionen zur Nachbearbeitung können Sie eine Funktion definieren, die die Modellausgabe verarbeitet. Im Fall des Befehls eval wird nur die Ergebnisspalte für die abschließende Gleichheitsprüfung verwendet.

Verwenden Sie den Decorator post_process_replace_fn, um eine Funktion für die Nachbearbeitung von Ergebnissen zu definieren:

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()

Die oben definierte extract_and_normalize-Funktion nimmt die Ausgabe des Modells und schneidet alle wiederholten Sprachpaare ab, sodass nur die erste Antwort zurückbleibt. Im Abschnitt Nachbearbeitung erfahren Sie mehr über die Nachverarbeitung.

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

Befehl: palm compile

Verwenden Sie den Befehl %%palm compile, um einen Prompt mit Platzhaltern in eine Funktion zu konvertieren, die von Python aus aufgerufen werden kann.

Alle Flags und Nachbearbeitung werden in die Funktion „kompiliert“ und werden beim Aufrufen verwendet.

In diesem Beispiel wird eine Funktion namens translate_en_to_fr mit der Nachverarbeitungsfunktion extract_and_normalize aus vor erstellt.

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

Ausgabeformate

Standardmäßig gibt eine „kompilierte“ Funktion die Ausgabe als Objekt zurück, das als Pandas-DataFrame angezeigt wird. Sie können das Ergebnisobjekt jedoch in ein DataFrame- oder Wörterbuch mit .as_dict() bzw. .as_dataframe() konvertieren.

Weitere Informationen finden Sie unter dem 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

Befehl: palm compare

%%palm compare führt kompilierte Prompts aus und erstellt eine Tabelle mit den Vergleichsergebnissen, sodass Sie die Unterschiede untersuchen können.

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

Benutzerdefinierte Vergleichsfunktionen

Standardmäßig prüft compare nur auf Gleichheit in den zurückgegebenen Ergebnissen. Mit dem Flag --compare_fn können Sie jedoch eine oder mehrere benutzerdefinierte Funktionen angeben.

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

Weitere Befehle

Hilfe

Mit dem Flag --help werden die unterstützten Befehle angezeigt, die Sie direkt an %%palm übergeben können

Hängen Sie --help an, um eine detaillierte Dokumentation für jeden Befehl aufzurufen. Beispiel:

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

Modelle

Verwenden Sie das Flag --model, um die PaLM-Modellvariante anzugeben, die Sie verwenden möchten.

Informationen zum Abrufen der unterstützten Modelle können Sie der Methode list_models() entnehmen. Die PaLM-Magie kann mit jedem Modell verwendet werden, das die generateText-Methode unterstützt.

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

Modellparameter

Sie können auch Modellparameter wie --candidate_count und --temperature konfigurieren.

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

Fehlerbehebung: Echo-Modell

Es ist auch ein echo-Modell verfügbar, das die Aufforderung an Sie zurückgibt. Er führt keine API-Aufrufe durch und verbraucht keine Kontingente, sodass Sie die Ausgabe oder Nachbearbeitung schnell und einfach testen können.

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

Ausgabe nach Python exportieren

Mit der PaLM-Magie können Sie nicht nur eine tabellarische Ausgabe anzeigen, sondern die Modellausgabe auch in Python-Variablen speichern. So können Sie sie weiter bearbeiten oder die Ergebnisse exportieren.

In diesem Beispiel wird die Ausgabe in einer Python-Variablen gespeichert: fave_colors

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

Ausgabevariablen sind benutzerdefinierte Objekte, die standardmäßig als Pandas-DataFrames angezeigt werden. Sie können explizit in ein Python-Wörterbuch oder -DataFrame erzwungen werden, indem as_dict() oder as_pandas_dataframe() aufgerufen wird.

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.']}

In Google Tabellen schreiben

Sie können die Ausgabe mit --sheets_output_names wieder in Google Tabellen speichern. Sie müssen angemeldet sein und die entsprechenden Berechtigungen haben, um auf private Tabellen zugreifen zu können.

Um dies auszuprobieren, erstellen Sie eine neue Tabelle und nennen Sie sie Translation results. Wie das Eingabe-Flag kann auch das Flag --sheets_output_names anstelle des Textnamens die Tabellen-URL oder -ID angeben.

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

Die Ergebnisse werden auf einem neuen Tab gespeichert und enthalten dieselben Daten, die Sie hier in Colab sehen.

Beispiel für ein gespeichertes Tabellenblatt

Mehrere Kandidaten generieren

Wenn Sie mehr als eine Ausgabe für einen einzelnen Prompt generieren möchten, können Sie --candidate_count an das Modell übergeben. Diese ist standardmäßig auf 1 eingestellt, wodurch nur das beste Ergebnis ausgegeben wird.

Manchmal generiert das Modell für alle Kandidaten die gleiche Ausgabe. Diese können mit dem Flag --unique gefiltert werden, das Ergebnisse aus dem Kandidaten-Batch dedupliziert (aber nicht über mehrere Prompts hinweg).

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

Die Spalte Result Num unterscheidet mehrere Kandidaten, die über denselben Prompt generiert werden.

Modellausgabe nach der Verarbeitung

Aufgrund des breiten Spektrums möglicher Ausgaben und Strukturen kann es schwierig sein, die Ausgabe des Modells an Ihren Problembereich anzupassen. Die PaLM-Magie bietet Nachbearbeitungsoptionen, mit denen Sie die Modellausgabe mit Python-Code ändern oder verarbeiten können.

Nachbearbeitungsfunktionen können entweder der Ausgabe eine neue Spalte hinzufügen oder die Spalte text_result ändern. Die Spalte text_result ist die letzte Spalte. Sie wird von den Befehlen eval und compare verwendet, um die Endausgabe zu bestimmen.

Hier sind einige Beispielfunktionen für die Nachbearbeitung. Der eine fügt eine neue Spalte hinzu und der andere aktualisiert die Ergebnisspalte mithilfe des Decorators 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

Um diese Funktionen zu verwenden, hängen Sie sie wie hier mit dem Pipe-Operator (|) an den Befehl %%palm an.

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

Hier können Sie Sachverhalte ordnen. Wenn word_count aufgerufen wird, wird die Anzahl der Wörter anhand der ursprünglichen Modellausgabe berechnet. Wenn Sie sie vertauschen, entspricht die Wortzahl stattdessen der Anzahl der Wörter im extrahierten ersten Satz.

Weitere Informationen