คำเตือน: PaLM API ถูกยกเลิกแล้ว Vertex AI PaLM API มีกำหนดการเลิกใช้งานในเดือนตุลาคม 2024 โปรดอัปเกรดเป็น Gemini API ดูข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ในคู่มือการเลิกใช้งาน PaLM API

หน้านี้ได้รับการแปลโดย Cloud Translation API

ความมหัศจรรย์ของ Colab

สมุดบันทึกนี้เปิดตัวคําสั่ง Magic ของ Colab สําหรับ PaLM Magics ช่วยให้พัฒนา ทดสอบ เปรียบเทียบ และประเมินข้อความแจ้งจากใน Colab Notebook ได้อย่างง่ายดาย

ดูใน ai.google.dev

ลองใช้ Colab Notebook

ดูสมุดบันทึกใน GitHub

ตั้งค่า

ทําตามขั้นตอนด้านล่างเพื่อติดตั้งและทดสอบ Magics

การติดตั้ง Magic ของ PaLM

หากต้องการใช้คําสั่ง Magic ของ PaLM ใน Colab หรือสภาพแวดล้อม IPython อื่นๆ คุณจะต้องดาวน์โหลดและติดตั้งแพ็กเกจ Python google-generativeai ก่อน

%pip install -q google-generativeai

กำลังโหลดเวทมนตร์ของ PaLM

ถัดไป ให้โหลดเวทมนตร์ %%palm โดยใช้เวทมนตร์ %load_ext:

%load_ext google.generativeai.notebook

ทดสอบการติดตั้ง

หากต้องการทดสอบการติดตั้งคำสั่งเวทมนตร์อย่างถูกต้อง ให้เรียกใช้ %%palm --help โปรดทราบว่าคุณต้องมีคีย์ PaLM API ด้วย หากยังไม่ได้มี (ดูขั้นตอนถัดไป)

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

หากต้องการใช้ PaLM API คุณจะต้องสร้างคีย์ API (คุณต้องทำขั้นตอนนี้เพียงครั้งเดียว)

ตั้งค่าคีย์ API ในสมุดบันทึก

ตั้งค่าคีย์ API โดยเรียกใช้เซลล์ด้านล่าง

%env GOOGLE_API_KEY=YOUR PALM KEY

คำสั่ง Magic ของ PaLM: `run`, `compile`, `compare` และ `evaluate`

เวทมนตร์ PaLM มีคำสั่ง 4 แบบดังนี้

run
compile
compare
evaluate

คำสั่ง: `palm run`

คำสั่ง run จะส่งเนื้อหาของเซลล์ไปยังโมเดล

เนื่องจากการเรียกใช้ข้อความแจ้งนั้นพบได้ทั่วไป เวทมนตร์ของ PaLM จะใช้คำสั่ง run เป็นค่าเริ่มต้นหากไม่มีการใช้คำสั่ง ตัวอย่างเช่น 2 เซลล์ถัดไปจะเหมือนกัน

%%palm run
The opposite of hot is

%%palm
The opposite of hot is

ทำความเข้าใจผลลัพธ์

คอลัมน์ Prompt จะแสดงข้อความที่ส่งไปยังโมเดล และคอลัมน์ text_result แสดงผลลัพธ์ คอลัมน์อื่นๆ จะแนะนำในขณะที่คุณอ่านคู่มือนี้ไปเรื่อยๆ

เทมเพลตพรอมต์

ข้อความแจ้งไม่จำเป็นต้องเป็นสตริงคงที่ คุณสามารถแทรกค่าลงในพรอมต์ได้โดยใช้ตัวยึดตำแหน่งของเทมเพลตโดยใช้ {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

ทำความเข้าใจผลลัพธ์

คอลัมน์ Input Num จะติดตามดัชนีของคำที่ป้อนในรายการ ใน ตัวอย่างเหล่านี้ Input Num จาก 0 คือ 'hot' และ 1 คือ 'cold'

การระบุชุดอินพุตหลายชุด

นอกจากนี้ คุณยังระบุอินพุตหลายชุดในครั้งเดียวได้ด้วย

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

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

กำลังอ่านข้อมูลจาก Google ชีต

นอกจากนี้ ฟีเจอร์ PaLM ยังอ่านและเขียนไปยัง Google ชีตได้ด้วย คุณจะต้องเข้าสู่ระบบเพื่อเข้าถึงข้อมูลชีต ส่วนนี้มุ่งเน้นที่การอ่านข้อมูลจากชีต ส่วนต่อไปจะแสดงวิธีเขียนเอาต์พุตลงใน Google ชีต

ลงชื่อเข้าสู่ระบบและให้สิทธิ์เข้าถึงชีต

from google.colab import auth
auth.authenticate_user()

import google.auth
creds, _ = google.auth.default()

from google.generativeai.notebook import magics
magics.authorize(creds)

การจัดรูปแบบสเปรดชีตเพื่อใช้กับ PaLM

ส่งต่อรหัสหรือ URL ของ Google ชีตไปยังแฟล็ก --sheets_input_names เพื่อโหลดเป็นข้อมูลเทมเพลต

ใช้รูปแบบต่อไปนี้ในสเปรดชีตเพื่อใช้ข้อมูลในเทมเพลตพรอมต์

ใส่ชื่อตัวแปร (ของเทมเพลตพรอมต์) ในแถวแรกของชีต
ป้อนข้อมูลแทนตัวแปรแต่ละตัวในแถวด้านล่าง

เช่น หากเทมเพลตพรอมต์มีตัวแปร 2 ตัวที่จะมาแทนที่ คือ name และ temperament คุณจะเขียนสเปรดชีตดังนี้

ชื่อ	อุปนิสัย
ไมโล	ทะเล้น
Bigsly	ผ่อนคลาย
ซูบรา	อาย

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

ทดลองด้วยตัวคุณเอง

หากต้องการลองใช้งานโดยใช้ข้อมูลของคุณเอง ให้สร้างชีตใหม่และส่งรหัสไปที่ --sheets_input_names นอกจากรหัสและ URL แล้ว คุณยังค้นหาชีตตามชื่อได้ด้วย เช่น %%palm --sheets_input_names "Animal adjectives"

การรวมอินพุตของชีตกับอินพุต Python

อินพุตของชีตจะรวมเข้ากับ --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.

คำสั่ง: `palm eval`

ใช้ %%palm eval เพื่อเปรียบเทียบเอาต์พุตของพรอมต์กับข้อมูลจากการสังเกตการณ์โดยตรง

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:

เอาต์พุตของโมเดลหลังการประมวลผล

ในการทดสอบข้อมูลจากการสังเกตการณ์โดยตรง คุณอาจต้องประมวลผลเอาต์พุตของโมเดลหลังการประมวลผล

ฟังก์ชันหลังการประมวลผลช่วยให้คุณกำหนดฟังก์ชันที่ประมวลผลเอาต์พุตของโมเดลได้ ในกรณีของคำสั่ง eval การตรวจสอบความเท่าเทียมกันจะใช้เฉพาะคอลัมน์ผลลัพธ์เท่านั้น

ใช้เติมแต่ง post_process_replace_fn เพื่อกำหนดฟังก์ชันสำหรับประมวลผลผลลัพธ์หลังการประมวลผล

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

ฟังก์ชัน extract_and_normalize ที่กำหนดด้านบนจะรับเอาต์พุตจากโมเดลและตัดคู่ภาษาที่ซ้ำกันออก เหลือเพียงคำตอบแรกเท่านั้น ดูข้อมูลเพิ่มเติมเกี่ยวกับหลังการประมวลผลได้ในส่วนการประมวลผลหลังการประมวลผล

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

คำสั่ง: `palm compile`

ใช้คำสั่ง %%palm compile เพื่อแปลงพรอมต์ที่มีตัวยึดตำแหน่งเป็นฟังก์ชันที่เรียกใช้ได้จากภายใน Python

การแจ้งว่าไม่เหมาะสมและการประมวลผลภายหลังทั้งหมดจะถูก "คอมไพล์" ลงในฟังก์ชันและจะใช้เมื่อเรียกใช้

ในตัวอย่างนี้ มีการสร้างฟังก์ชันที่ชื่อว่า translate_en_to_fr โดยใช้ฟังก์ชันการประมวลผลหลังการประมวลผล extract_and_normalize จากก่อน

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

รูปแบบเอาต์พุต

โดยค่าเริ่มต้น แท็ก "คอมไพล์" จะแสดงผลเอาต์พุตเป็นออบเจ็กต์ที่จะแสดงเป็น Pandas DataFrame แต่คุณสามารถแปลงออบเจ็กต์ผลลัพธ์เป็น DataFrame หรือพจนานุกรมด้วย .as_dict() หรือ .as_dataframe() ตามลำดับ

ดูข้อมูลเพิ่มเติมได้ที่แฟล็ก --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

คำสั่ง: `palm compare`

%%palm compare เรียกใช้ข้อความแจ้งที่คอมไพล์แล้วสร้างตารางที่มีผลลัพธ์การเปรียบเทียบควบคู่กัน เพื่อให้คุณตรวจสอบความแตกต่างได้

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

ฟังก์ชันเปรียบเทียบแบบกำหนดเอง

โดยค่าเริ่มต้น compare จะตรวจสอบความเท่าเทียมในผลลัพธ์ที่แสดง แต่คุณระบุฟังก์ชันที่กําหนดเองได้อย่างน้อย 1 รายการด้วยแฟล็ก --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

คำสั่งอื่นๆ

ความช่วยเหลือ

แฟล็ก --help จะแสดงคำสั่งที่รองรับที่คุณส่งไปยัง %%palm ได้โดยตรง

เพิ่ม --help เพื่อดูเอกสารประกอบโดยละเอียดสำหรับแต่ละคำสั่ง ตัวอย่างเช่น

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

โมเดล

ใช้ Flag --model เพื่อระบุตัวแปรโมเดล PaLM ที่ต้องการใช้

ดูเมธอด list_models() เพื่อเรียกข้อมูลโมเดลที่รองรับ เวทมนตร์ PaLM สามารถใช้กับโมเดลใดก็ได้ที่รองรับเมธอด generateText

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

พารามิเตอร์โมเดล

คุณกำหนดค่าพารามิเตอร์โมเดล เช่น --candidate_count และ --temperature ได้ด้วย

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

การแก้ไขข้อบกพร่อง: โมเดลเสียงสะท้อน

นอกจากนี้ยังมีโมเดล echo ซึ่งจะก้องข้อความแจ้งกลับไปด้วย โดยจะไม่เรียก API หรือใช้โควต้าของคุณ จึงเป็นวิธีที่ง่ายและรวดเร็วในการทดสอบเอาต์พุตหรือการประมวลผลหลังการประมวลผล

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

ส่งออกเอาต์พุตไปยัง Python

นอกจากการแสดงเอาต์พุตแบบตารางแล้ว เวทมนตร์ของ PaLM ยังบันทึกเอาต์พุตโมเดลลงในตัวแปร Python ได้ ซึ่งจะช่วยให้คุณจัดการผลลัพธ์เพิ่มเติมหรือส่งออกผลลัพธ์ได้

ในตัวอย่างนี้ ระบบจะบันทึกเอาต์พุตไปยังตัวแปร Python: fave_colors

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

ตัวแปรเอาต์พุตเป็นออบเจ็กต์ที่กําหนดเองซึ่งจะแสดงเป็น DataFrame ของ Pandas โดยค่าเริ่มต้น ซึ่งสามารถเปลี่ยนเป็นพจนานุกรม Python หรือ DataFrame อย่างชัดแจ้งได้โดยเรียกใช้ as_dict() หรือ 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.']}

เขียนไปยัง Google ชีต

คุณบันทึกเอาต์พุตกลับไปยัง Google ชีตได้โดยใช้ --sheets_output_names คุณต้องลงชื่อเข้าสู่ระบบและต้องมีสิทธิ์ที่เหมาะสมในการเข้าถึงชีตส่วนตัว

หากต้องการลองใช้งาน ให้สร้างชีตใหม่และตั้งชื่อว่า Translation results ธง --sheets_output_names ยังยอมรับ URL หรือรหัสของชีตแทนชื่อแบบข้อความ เช่นเดียวกับธงอินพุต

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

ระบบจะบันทึกผลลัพธ์ในแท็บใหม่และมีข้อมูลเดียวกันกับที่คุณเห็นใน Colab

ตัวอย่างชีตที่บันทึกไว้

การสร้างคำที่รอพิจารณาหลายรายการ

หากต้องการสร้างเอาต์พุตมากกว่า 1 รายการสำหรับพรอมต์เดียว คุณสามารถส่ง --candidate_count ไปยังโมเดลได้ ค่านี้ถูกตั้งค่าเป็น 1 โดยค่าเริ่มต้น ซึ่งจะแสดงผลลัพธ์อันดับต้นๆ เท่านั้น

บางครั้งโมเดลจะสร้างเอาต์พุตเดียวกันในตัวเลือกต่างๆ คุณกรองผลลัพธ์เหล่านี้ได้ด้วยแฟล็ก --unique ซึ่งจะนำผลลัพธ์ที่ซ้ำกันออกจากกลุ่มทดสอบ (แต่ไม่ใช่ในพรอมต์หลายรายการ)

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

คอลัมน์ Result Num จะแยกความแตกต่างระหว่างคำที่รอพิจารณาหลายรายการซึ่งสร้างจากข้อความแจ้งเดียวกัน

เอาต์พุตโมเดลหลังการประมวลผล

เอาต์พุตและโครงสร้างที่เป็นไปได้หลากหลายอาจทำให้ปรับเอาต์พุตของโมเดลให้เข้ากับโดเมนที่เป็นปัญหาได้ยาก เวทมนตร์ของ PaLM มีตัวเลือกการประมวลผลภายหลังที่ช่วยให้คุณแก้ไขหรือประมวลผลเอาต์พุตของโมเดลโดยใช้โค้ด Python ได้

ฟังก์ชันหลังการประมวลผลอาจเพิ่มคอลัมน์ใหม่ลงในเอาต์พุตหรือแก้ไขคอลัมน์ text_result ก็ได้ คอลัมน์ text_result เป็นคอลัมน์สุดท้าย และใช้โดยคำสั่ง eval และ compare เพื่อกำหนดเอาต์พุตสุดท้าย

ตัวอย่างฟังก์ชันที่จะใช้ในขั้นตอนหลังการประมวลผลมีดังนี้ คนหนึ่งเพิ่มคอลัมน์ใหม่และอีกคนหนึ่งอัปเดตคอลัมน์ผลลัพธ์โดยใช้เติมแต่ง 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

หากต้องการใช้ฟังก์ชันเหล่านี้ ให้ต่อท้ายด้วยคำสั่ง %%palm โดยใช้โอเปอเรเตอร์ไปป์ (|) ดังนี้

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

คำสั่งซื้อมีความสำคัญ เมื่อมีการเรียกใช้ word_count ระบบจะใช้เอาต์พุตโมเดลเดิมเพื่อคำนวณจำนวนคำ หากสลับไปมา จำนวนคำจะเป็นจำนวนคำในประโยคแรกที่ดึงมา

อ่านเพิ่มเติม

โปรดดูคำแนะนำแนวคิด LLM เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับ LLM
ดูข้อมูลเพิ่มเติมเกี่ยวกับการสร้างพรอมต์เพื่อให้ใช้ประโยชน์จาก PaLM ได้ในหลักเกณฑ์ข้อความแจ้ง
หากต้องการสร้างต้นแบบและทดลองกับพรอมต์ต่างๆ โปรดดู Google AI Studio นอกจากนี้ โปรดดูข้อมูลเพิ่มเติมที่การเริ่มต้นใช้งาน Google AI Studio อย่างรวดเร็ว

ความมหัศจรรย์ของ Colab

ตั้งค่า

การติดตั้ง Magic ของ PaLM

กำลังโหลดเวทมนตร์ของ PaLM

ทดสอบการติดตั้ง

การรับคีย์ PaLM API

ตั้งค่าคีย์ API ในสมุดบันทึก

คำสั่ง Magic ของ PaLM: run, compile, compare และ evaluate

คำสั่ง: palm run

ทำความเข้าใจผลลัพธ์

เทมเพลตพรอมต์

ทำความเข้าใจผลลัพธ์

การระบุชุดอินพุตหลายชุด

กำลังอ่านข้อมูลจาก Google ชีต

ลงชื่อเข้าสู่ระบบและให้สิทธิ์เข้าถึงชีต

การจัดรูปแบบสเปรดชีตเพื่อใช้กับ PaLM

ทดลองด้วยตัวคุณเอง

การรวมอินพุตของชีตกับอินพุต Python

คำสั่ง: palm eval

เอาต์พุตของโมเดลหลังการประมวลผล

คำสั่ง: palm compile

รูปแบบเอาต์พุต

คำสั่ง: palm compare

ฟังก์ชันเปรียบเทียบแบบกำหนดเอง

คำสั่งอื่นๆ

ความช่วยเหลือ

โมเดล

พารามิเตอร์โมเดล

การแก้ไขข้อบกพร่อง: โมเดลเสียงสะท้อน

ส่งออกเอาต์พุตไปยัง Python

เขียนไปยัง Google ชีต

การสร้างคำที่รอพิจารณาหลายรายการ

เอาต์พุตโมเดลหลังการประมวลผล

อ่านเพิ่มเติม

คำสั่ง Magic ของ PaLM: `run`, `compile`, `compare` และ `evaluate`

คำสั่ง: `palm run`

คำสั่ง: `palm eval`

คำสั่ง: `palm compile`

คำสั่ง: `palm compare`