Interfejs API plików

Gemini może jednocześnie obsługiwać różne typy danych wejściowych, w tym tekst, obrazy i dźwięk.

Z tego przewodnika dowiesz się, jak pracować z plikami multimedialnymi za pomocą interfejsu Files API. Podstawowe operacje są takie same w przypadku plików audio, obrazów, filmów, dokumentów i innych obsługiwanych typów plików.

Wskazówki dotyczące promptów związanych z plikami znajdziesz w sekcji Przewodnik po tworzeniu promptów dotyczących plików.

Prześlij plik

Do przesłania pliku multimedialnego możesz użyć interfejsu Files API. Zawsze używaj interfejsu Files API, gdy łączny rozmiar żądania (w tym plików, promptu tekstowego, instrukcji systemowych itp.) przekracza 100 MB. W przypadku plików PDF limit wynosi 50 MB.

Poniższy kod przesyła plik, a następnie używa go w wywołaniu funkcji interactions.create.

Python

from google import genai

client = genai.Client()

myfile = client.files.upload(file="path/to/sample.mp3")

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "text", "text": "Describe this audio clip"},
        {"type": "audio", "uri": myfile.uri, "mime_type": myfile.mime_type}
    ]
)

print(interaction.output_text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const myfile = await client.files.upload({
    file: "path/to/sample.mp3",
    config: { mime_type: "audio/mpeg" },
  });

  const interaction = await client.interactions.create({
    model: "gemini-3.8-flash",
    input: [
      { type: "text", text: "Describe this audio clip" },
      { type: "audio", uri: myfile.uri, mime_type: myfile.mimeType }
    ]
  });
  console.log(interaction.output_text);
}

await main();

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.AudioContent;
import com.google.genai.gaos.models.interactions.AudioContentMimeType;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.types.File;
import com.google.genai.types.UploadFileConfig;
import java.util.Arrays;
import java.util.List;

Client client = new Client();

File myFile =
    client.files.upload(
        new java.io.File("path/to/sample.mp3"),
        UploadFileConfig.builder().mimeType("audio/mp3").build());

Content textContent = TextContent.builder().text("Describe this audio clip").build();
Content audioContent =
    AudioContent.builder()
        .uri(myFile.uri().orElse(""))
        .mimeType(AudioContentMimeType.of(myFile.mimeType().orElse("audio/mp3")))
        .build();

List<Content> contents = Arrays.asList(textContent, audioContent);

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.ofContent(contents))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    myFile, err := client.Files.UploadFromPath(ctx, "path/to/sample.mp3", &genai.UploadFileConfig{
        MIMEType: "audio/mp3",
    })
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput([]interactions.Content{
                interactions.NewContent(interactions.TextContent{
                    Text: "Describe this audio clip",
                }),
                interactions.NewContent(interactions.AudioContent{
                    URI:      genai.Ptr(myFile.URI),
                    MimeType: interactions.AudioContentMimeType(myFile.MIMEType).ToPointer(),
                }),
            }),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

REST

AUDIO_PATH="path/to/sample.mp3"
MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
DISPLAY_NAME=AUDIO

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -D "${tmp_header_file}" \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now create an interaction using the Interactions API
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "gemini-3.8-flash",
      "input": [
        {"type": "text", "text": "Describe this audio clip"},
        {"type": "audio", "uri": '$file_uri', "mime_type": "'${MIME_TYPE}'"}
      ]
    }' 2> /dev/null > response.json

cat response.json
echo

jq ".outputs[] | select(.type == \"text\") | .text" response.json

Pobieranie metadanych pliku

Możesz sprawdzić, czy interfejs API zapisał przesłany plik, i pobrać jego metadane, wywołując funkcję files.get.

Python

from google import genai

client = genai.Client()

myfile = client.files.upload(file='path/to/sample.mp3')
file_name = myfile.name
myfile = client.files.get(name=file_name)
print(myfile)

JavaScript

import {
  GoogleGenAI,
} from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const myfile = await client.files.upload({
    file: "path/to/sample.mp3",
    config: { mime_type: "audio/mpeg" },
  });

  const fileName = myfile.name;
  const fetchedFile = await client.files.get({ name: fileName });
  console.log(fetchedFile);
}

await main();

Java

import com.google.genai.Client;
import com.google.genai.types.File;
import com.google.genai.types.UploadFileConfig;

Client client = new Client();

File myFile =
    client.files.upload(
        new java.io.File("path/to/sample.mp3"),
        UploadFileConfig.builder().mimeType("audio/mp3").build());

String fileName = myFile.name().orElse("");
File fileMetadata = client.files.get(fileName, null);
System.out.println(fileMetadata);

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    myFile, err := client.Files.UploadFromPath(ctx, "path/to/sample.mp3", &genai.UploadFileConfig{
        MIMEType: "audio/mp3",
    })
    if err != nil {
        log.Fatal(err)
    }

    fileMetadata, err := client.Files.Get(ctx, myFile.Name, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(fileMetadata)
}

REST

# file_info.json was created in the upload example
name=$(jq -r ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/$name \
-H "x-goog-api-key: $GEMINI_API_KEY" > file_info.json
# Print some information about the file you got
name=$(jq -r ".name" file_info.json)
echo name=$name
file_uri=$(jq -r ".uri" file_info.json)
echo file_uri=$file_uri

Wyświetlanie listy przesłanych plików

Poniższy kod pobiera listę wszystkich przesłanych plików:

Python

from google import genai

client = genai.Client()

print('My files:')
for f in client.files.list():
    print(' ', f.name)

JavaScript

import {
  GoogleGenAI,
} from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const listResponse = await client.files.list({ config: { pageSize: 10 } });
  for await (const file of listResponse) {
    console.log(file.name);
  }
}

await main();

Java

import com.google.genai.Client;
import com.google.genai.types.File;

Client client = new Client();

System.out.println("My files:");
for (File f : client.files.list(null)) {
  System.out.println("  " + f.name().orElse(""));
}

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("My files:")
    for f, err := range client.Files.All(ctx) {
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(" ", f.Name)
    }
}

REST

echo "My files: "

curl "https://generativelanguage.googleapis.com/v1beta/files" \
  -H "x-goog-api-key: $GEMINI_API_KEY"

Usuwanie przesłanych plików

Pliki są automatycznie usuwane po 48 godzinach. Możesz też ręcznie usunąć przesłany plik:

Python

from google import genai

client = genai.Client()

myfile = client.files.upload(file='path/to/sample.mp3')
client.files.delete(name=myfile.name)

JavaScript

import {
  GoogleGenAI,
} from "@google/genai";

const client = new GoogleGenAI({});

async function main() {
  const myfile = await client.files.upload({
    file: "path/to/sample.mp3",
    config: { mime_type: "audio/mpeg" },
  });

  const fileName = myfile.name;
  await client.files.delete({ name: fileName });
}

await main();

Java

import com.google.genai.Client;
import com.google.genai.types.File;
import com.google.genai.types.UploadFileConfig;

Client client = new Client();

File myFile =
    client.files.upload(
        new java.io.File("path/to/sample.mp3"),
        UploadFileConfig.builder().mimeType("audio/mp3").build());

client.files.delete(myFile.name().orElse(""), null);

Go

package main

import (
    "context"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    myFile, err := client.Files.UploadFromPath(ctx, "path/to/sample.mp3", &genai.UploadFileConfig{
        MIMEType: "audio/mp3",
    })
    if err != nil {
        log.Fatal(err)
    }

    if _, err := client.Files.Delete(ctx, myFile.Name, nil); err != nil {
        log.Fatal(err)
    }
}

REST

curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/$name \
  -H "x-goog-api-key: $GEMINI_API_KEY"

informacje o używaniu usługi,

Interfejs Files API umożliwia przesyłanie plików multimedialnych i interakcję z nimi. Interfejs Files API umożliwia przechowywanie do 20 GB plików na projekt, przy czym maksymalny rozmiar pliku wynosi 2 GB. Pliki są przechowywane przez 48 godzin.

W tym czasie możesz używać interfejsu API do pobierania metadanych plików. Nie możesz jednak pobierać plików przesłanych przez użytkowników. Pliki wygenerowane przez modele, takie jak filmy, możesz pobierać za pomocą metody files.download. Interfejs Files API jest dostępny bezpłatnie we wszystkich regionach, w których dostępny jest interfejs Gemini API.

Strategie promptów dotyczących plików

W tej sekcji znajdziesz wskazówki i sprawdzone metody dotyczące używania plików multimedialnych z promptami w Gemini API.

Możliwość używania różnych typów danych w promptach zapewnia większą elastyczność w zakresie zadań, które można wykonywać za pomocą interfejsu Gemini API. Możesz na przykład wysłać modelowi zdjęcie pysznego posiłku i poprosić go o napisanie krótkiego bloga na jego temat.

Prompt Odpowiedź

Napisz krótki, angażujący post na bloga na podstawie tego zdjęcia. Powinien zawierać opis posiłku na zdjęciu i informacje o mojej przygodzie z przygotowywaniem posiłków.


Pliki cookie

Przygotowywanie posiłków to świetny sposób na oszczędzanie czasu i pieniędzy, a także na zdrowsze odżywianie się. To danie jest świetnym przykładem zdrowego i pysznego posiłku, który można przygotować wcześniej.

Posiłek składa się z brązowego ryżu, pieczonych warzyw i kurczaka teriyaki. Brązowy ryż to zdrowy węglowodan złożony, który zapewni Ci energię na dłużej. Pieczone warzywa to świetny sposób na dostarczenie organizmowi codziennej dawki witamin i minerałów, a kurczak teriyaki to pyszna i bogata w białko opcja.

Ten posiłek jest też łatwy do przygotowania. Wystarczy ugotować brązowy ryż, upiec warzywa i przygotować kurczaka teriyaki. Gdy wszystko będzie gotowe, podziel jedzenie na porcje i przechowuj je w lodówce. W zabiegane poranki wystarczy wyjąć pojemnik z lodówki i gotowe.

Jeśli szukasz zdrowego i pysznego posiłku, który można przygotować wcześniej, to danie będzie świetnym wyborem. Jest pełna składników odżywczych i smaku, a do tego na pewno Cię nasyci.

Życzymy smacznego i zdrowego gotowania.

Jeśli masz problem z uzyskaniem oczekiwanych wyników z promptów, które używają plików multimedialnych, możesz skorzystać z kilku strategii, które pomogą Ci uzyskać oczekiwane wyniki. W poniższych sekcjach znajdziesz podejścia do projektowania i wskazówki dotyczące rozwiązywania problemów, które pomogą Ci ulepszyć prompty korzystające z danych multimodalnych.

Aby ulepszyć tworzenie promptów multimodalnych, postępuj zgodnie z tymi sprawdzonymi metodami:

  • Podstawy projektowania promptów

    • Podawaj konkretne instrukcje: twórz jasne i zwięzłe instrukcje, które pozostawiają minimalne pole do błędnej interpretacji.
    • Dodaj do promptu kilka przykładów: użyj realistycznych przykładów few-shot, aby zilustrować, co chcesz osiągnąć.
    • Podziel zadanie na mniejsze części: podziel złożone zadania na łatwe do wykonania podcele, prowadząc model przez cały proces.
    • Określ format wyjściowy: w prompcie poproś o wygenerowanie danych wyjściowych w wybranym formacie, np. Markdown, JSON, HTML itp.
    • W przypadku promptów z jednym obrazem umieść go na początku: Gemini może przetwarzać dane wejściowe w postaci obrazów i tekstu w dowolnej kolejności, ale w przypadku promptów zawierających jeden obraz może działać lepiej, jeśli ten obraz (lub film) zostanie umieszczony przed promptem tekstowym. W przypadku promptów, które wymagają, aby obrazy były ściśle powiązane z tekstem, użyj kolejności, która wydaje Ci się najbardziej naturalna.
  • Rozwiązywanie problemów z tworzeniem promptów multimodalnych

    • Jeśli model nie pobiera informacji z odpowiedniej części obrazu: podaj wskazówki, z których aspektów obrazu prompt ma pobierać informacje.
    • Jeśli dane wyjściowe modelu są zbyt ogólne (nie są wystarczająco dostosowane do obrazu lub filmu): na początku prompta, przed podaniem instrukcji zadania, poproś model o opisanie obrazów lub filmu albo o odniesienie się do tego, co jest na obrazie.
    • Aby rozwiązać problem z częścią, która zawiodła: poproś model o opisanie obrazu lub wyjaśnienie jego rozumowania, aby ocenić wstępne zrozumienie modelu.
    • Jeśli prompt spowoduje wygenerowanie halucynacji: spróbuj zmniejszyć ustawienie temperatury lub poproś model o krótsze opisy, aby zmniejszyć prawdopodobieństwo ekstrapolacji dodatkowych szczegółów.
    • Dostrajanie parametrów próbkowania: eksperymentuj z różnymi ustawieniami temperatury i wyborami Top-K, aby dostosować kreatywność modelu.

Podawaj szczegółowe instrukcje.

Prompty są najbardziej skuteczne, gdy są jasne i szczegółowe. Jeśli masz na myśli konkretny wynik, lepiej uwzględnij to wymaganie w prompcie, aby uzyskać oczekiwany rezultat.

Jeśli poprosisz model o „opisanie tego obrazu” przedstawiającego tablicę na lotnisku, możesz otrzymać ogólny opis. Jeśli chcesz, aby model przeanalizował godzinę i miasto na obrazie, możesz uwzględnić tę prośbę bezpośrednio w prompcie.

Prompt Odpowiedź modelu

Opisz ten obraz.

Obraz przedstawia tablicę przylotów i odlotów na lotnisku.

Zaktualizowany prompt Ulepszona odpowiedź
Rozkład jazdy

Przeanalizuj godzinę i miasto z tablicy lotniskowej widocznej na tym obrazie i utwórz listę.

  • 10:50 Moskwa
  • 11:05 Edynburg
  • 11:05 Londyn
  • 11:10 Bukareszt
  • 11:30 Kijów
  • 11:35 Dublin
  • 11:45 East Midlands
  • 12:15 Sofia
  • 12:30 London
  • 12:30 Newcastle
  • 12:40 Petersburg
  • 12:40 Londyn
  • 12:45 Manchester
  • Dodaj kilka przykładów

    Model Gemini może akceptować wiele danych wejściowych, które może wykorzystać jako przykłady, aby zrozumieć, jakich danych wyjściowych oczekujesz. Dodanie tych przykładów może pomóc modelowi zidentyfikować wzorce i zastosować relację między podanymi obrazami i odpowiedziami do nowego przykładu. Ten rodzaj promptów nazywamy „few-shot”.

    W poniższym przykładzie początkowy wynik jest zapisany w formie zdania i zawiera również kraj (Brazylia). Załóżmy, że chcesz uzyskać dane wyjściowe w innym formacie lub stylu i chcesz, aby zawierały tylko miasto, a nie kraj. Dodanie do promptu przykładów few-shot może pomóc modelowi odpowiedzieć w oczekiwany sposób.

    Prompt Odpowiedź modelu
    Rozkład jazdy

    Określ miasto i charakterystyczny obiekt.

    Na zdjęciu widać statuę Chrystusa Zbawiciela w Rio de Janeiro w Brazylii.

    Zaktualizowany prompt Ulepszona odpowiedź

    Określ miasto i charakterystyczny obiekt.

    Koloseum

    miasto: Rzym, punkt orientacyjny: Koloseum.

    Zakazane Miasto

    city: Beijing, landmark: Forbidden City

    forbidden-city

    miasto: Rio de Janeiro, punkt orientacyjny: statua Chrystusa Zbawiciela

    Szczegółowe wyjaśnienie

    W przypadku złożonych zadań, takich jak te, które wymagają zarówno rozumienia obrazu, jak i rozumowania, warto podzielić zadanie na mniejsze, prostsze etapy. Możesz też poprosić model w prompcie, aby „myślał krok po kroku”.

    Prompt Odpowiedź modelu

    Kiedy skończy mi się papier toaletowy?

    Wkrótce zostaną Ci tylko 3 rolki.

    Zaktualizowany prompt Ulepszona odpowiedź
    1. Najpierw policz, ile rolek papieru toaletowego jest na tym zdjęciu.
    2. Następnie określ, ile papieru toaletowego zużywa przeciętna osoba dziennie.
    3. Oblicz, jak długo wystarczą te rolki papieru toaletowego.
    1. Na tym zdjęciu są 3 rolki papieru toaletowego.
    2. Przeciętna osoba zużywa około 20 listków papieru toaletowego dziennie.
    3. Jeśli każda rolka zawiera 200 arkuszy, wystarczy na około 10 dni. Dlatego 3 rolki wystarczą na około miesiąc.

    Zadania matematyczne lub inne rodzaje zadań tekstowych to świetne przykłady, w których można poprosić model o myślenie krok po kroku.

    Prompt Odpowiedź

    Jaki jest czwarty wyraz ciągu?

    -135

    Odpowiedź modelu jest nieprawidłowa. Aby to poprawić, możesz poprosić model o przeanalizowanie problemu przed udzieleniem odpowiedzi na prompt.

    Prompt Odpowiedź

    Najpierw przeanalizuj formułę na obrazie.

    Następnie na podstawie wzoru odpowiedz na pytanie „Jaki jest czwarty wyraz ciągu?”.

    Kliknij, aby rozwinąć wynik

    $$ b(n) = b(n-1) * (-3) $$

    $$ b(1) = 15 $$

    1. Podstaw n = 4 do wzoru:

      $$ b(4) = b(4-1) * (-3) $$

      $$ b(4) = b(3) * (-3) $$

    2. Nie znamy wartości b(3), więc podstawiamy n = 3 do wzoru:

      $$ b(3) = b(3-1) * (-3) $$

      $$ b(3) = b(2) * (-3) $$

    3. Nie znamy wartości b(2), więc podstawiamy n = 2 do wzoru:

      $$ b(2) = b(2-1) * (-3) $$

      $$ b(2) = b(1) * (-3) $$

    4. Wiemy, że wartość b(1) wynosi 15, więc podstawiamy ją do wzoru:

      $$ b(2) = 15 * (-3) $$

      $$ b(2) = -45 $$

    5. Teraz, gdy znamy wartość b(2), podstawmy ją do wzoru na b(3):

      $$ b(3) = b(2) * (-3) $$

      $$ b(3) = -45 * (-3) $$

      $$ b(3) = 135 $$

    6. Teraz, gdy znamy wartość b(3), podstawiamy ją do wzoru na b(4):

      $$ b(4) = b(3) * (-3) $$

      $$ b(4) = 135 * (-3) $$

      $$ b(4) = -405 $$

    Zatem czwarty wyraz ciągu to -405.

    Odpowiedź modelu jest prawidłowa. Aby ją jeszcze bardziej usprawnić, możesz poprosić model o myślenie krok po kroku.

    Zaktualizowany prompt Ulepszona odpowiedź

    Jaki jest czwarty wyraz ciągu? Myśl krok po kroku.

    Pierwszy wyraz to 15.

    Drugi wyraz to b(1) * (-3) = 15 * (-3) = -45.

    Trzeci wyraz to b(2) * (-3) = -45 * (-3) = 135.

    Czwarty wyraz to b(3) * (-3) = 135 * (-3) = -405.

    Określ format wyjściowy

    Częstym problemem jest konieczność generowania przez model danych wyjściowych w określonym formacie (np. Markdown, JSON, HTML), zwłaszcza jeśli dane wyjściowe modelu mają być wykorzystywane w dalszych zadaniach. Możesz spróbować wygenerować dane wyjściowe w tym formacie, instruując model, aby to zrobił w prompcie. Oto 2 przykłady:

    Prompt Odpowiedź modelu

    Przekształć tabelę na tym obrazie na format Markdown

    ```none | Temat | Stan | Czas | Data rozpoczęcia | Termin | | ------- | ------ | ---- | ---------- | ------ | | Matematyka | Gotowe | 1,5 godz. | 29.11.2023 | 1.12.2023 | | Geografia | Gotowe | 30 min | 2.12.2023 | 4.12.2023 | | Fizyka | W trakcie | 2 godz. | 3.12.2023 | 5.12.2023 | | Biologia | Nierozpoczęte | 6 godz. | 2.11.2016 | 6.12.2023 | ```
    Prompt Odpowiedź modelu

    Podaj listę wszystkich tych atrybutów:

    składniki, rodzaj kuchni, czy jest wegetariański, w formacie JSON

    ```json { "ingredients": [ "rice", "shrimp", "clams", "mussels", "peas", "tomatoes", "onions", "garlic", "olive oil", "paprika", "salt", "pepper" ], "type of cuisine": "Spanish", "vegetarian": false } ```

    W przypadku promptów z pojedynczym obrazem umieść obraz na pierwszym miejscu

    Gemini może interpretować obraz i tekst w dowolnej kolejności w prompcie, ale umieszczenie pojedynczego obrazu przed promptem tekstowym może przynieść lepsze wyniki. W przykładach poniżej obraz jest zawsze podany przed tekstem w każdym promcie.

    Rozwiązywanie problemów z tworzeniem promptów multimodalnych

    Jeśli nie otrzymujesz pomocnej odpowiedzi, może być konieczne rozwiązanie problemu z promptem. Oto kilka strategii, które możesz wypróbować.

    Jeśli model nie pobiera informacji z odpowiedniej części obrazu

    Aby uzyskać bardziej szczegółową odpowiedź, możesz wskazać, które aspekty obrazu chcesz uwzględnić w prompcie, aby uzyskać informacje potrzebne do udzielenia odpowiedzi.

    Prompt Odpowiedź modelu

    Na ile dni wystarczą te pieluszki?

    Pieluchy wystarczą na 198 dni.

    Zaktualizowany prompt Ulepszona odpowiedź

    Na jak długo wystarczą mi te pieluchy?

    Użyj wagi podanej na opakowaniu, aby określić wiek dziecka, i podaj łączną liczbę pieluch w opakowaniu.

    Podziel łączną liczbę pieluch przez liczbę pieluch zużywanych przez dziecko dziennie.

    Opakowanie zawiera 198 pieluch. Na opakowaniu jest napisane, że pieluchy są przeznaczone dla dzieci o wadze 10–17 kg.

    Średnie dziecko w tym przedziale wagowym ma zwykle od 1 do 2 lat.

    2-letnie dziecko zużywa zwykle 6 pieluszek dziennie, więc wystarczą one na około 33 dni (198/6).

    Jeśli dane wyjściowe modelu są zbyt ogólne i niewystarczająco dostosowane do obrazu wejściowego.

    Aby pomóc modelowi dostosować odpowiedź do obrazów, poproś go o ich opisanie przed wykonaniem zadania związanego z rozumowaniem.

    Prompt Odpowiedź modelu

    Co łączy te obrazy?

    Wszystkie 4 obrazy to przykłady fotografii krajobrazowej.

    Zaktualizowany prompt Ulepszona odpowiedź

    Najpierw szczegółowo opisz, co znajduje się na każdym obrazie. Co łączy te obrazy?

    Pierwszy obraz przedstawia osobę pakującą walizkę. Drugi obraz przedstawia pusty korytarz w centrum handlowym. Trzeci obraz przedstawia rolkę papieru toaletowego. Czwarty obraz przedstawia ciemne i wzburzone morze.

    Wspólną cechą tych obrazów jest to, że wszystkie są przykładami przestrzeni liminalnych. Przestrzenie liminalne to miejsca lub sytuacje, które znajdują się pomiędzy dwoma innymi miejscami lub sytuacjami. Często charakteryzują się poczuciem niepewności lub niejednoznaczności.

    Pierwszy obraz przedstawia osobę, która jest w domu i w podróży. Drugi obraz przedstawia korytarz między 2 sklepami. Trzeci obraz przedstawia papier toaletowy, który może symbolizować łazienkę. Łazienka to przestrzeń przejściowa między sferą prywatną a publiczną. To miejsce, w którym przygotowujemy się do wejścia do świata zewnętrznego lub wyjścia z niego.

    Czwarty obraz przedstawia morze, które jest częściowo spokojne, a częściowo wzburzone.

    Przestrzenie liminalne mogą być zarówno ekscytujące, jak i niepokojące. Mogą być miejscem nowego początku lub końca. Mogą być miejscem refleksji lub działania.

    Możesz też wyraźnie poprosić model o odniesienie się do tego, co znajduje się na obrazie.

    Zaktualizowany prompt Ulepszona odpowiedź

    Co łączy te obrazy? Odwołuj się w odpowiedzi do tego, co znajduje się na obrazach.

    Wszystkie obrazy są związane z podróżami. Pierwsze zdjęcie przedstawia osobę pakującą walizkę, drugie – pusty korytarz w centrum handlowym, trzecie – stos papieru toaletowego, a czwarte – ciemne i burzliwe morze.

    Wszystkie te obrazy są związane z podróżami, ponieważ przedstawiają rzeczy, których ludzie potrzebują lub używają podczas podróży. Pierwszy obraz przedstawia osobę pakującą walizkę, co ludzie robią, gdy wybierają się w podróż. Drugi obraz przedstawia pusty korytarz w centrum handlowym, czyli miejscu, w którym ludzie często kupują rzeczy na wyjazdy. Trzeci obraz przedstawia stos papieru toaletowego, który jest często używany podczas podróży. Czwarty obraz przedstawia ciemne i sztormowe morze, które często można spotkać podczas podróży.

    Te same wskazówki dotyczą treści generowanych na podstawie obrazów. W tym przykładzie z królikiem wyraźne poproszenie modelu o uwzględnienie aspektów obrazu może poprawić wynik.

    Prompt Odpowiedź modelu

    Czy możesz napisać wiersz o tym obrazie?

    Mały króliczek, miękki i brązowy,
    skacze po polu w górę i w dół.
    Uszy masz długie, ogon krótki,
    Jesteś najsłodszym stworzeniem ze wszystkich.

    Podgryzasz trawę, taką zieloną i słodką,
    I odskakujesz, gdy mnie widzisz.
    Ale zawsze będę Twoim przyjacielem,
    Króliczku, aż do samego końca.

    Zaktualizowany prompt Ulepszona odpowiedź

    Czy możesz napisać opisowy i dramatyczny wiersz o tym obrazie i uwzględnić lokalizację?

    Mały króliczek na zielonej łące,
    Uszy takie długie, takie bystre.
    Co widzisz tam,
    W oddali, gdzie wpatrujesz się?

    Czy to oceanu błękit,
    który w słońcu lśni?
    A może fale, które rozbijają się i szumią,
    tworząc rytm, który uwielbiasz?

    Mały króliczku, powiedz mi,
    co tak bardzo przyciąga Twoją uwagę?
    Czy to słona bryza,
    czy krzyki mew?

    Może to przez ogrom tego wszystkiego,
    Świat tak wielki i mały.
    Miejsce, gdzie marzenia mogą się spełniać,
    A przygody mogą się rodzić.

    Mały króliczku, zastanawiam się, o czym śnisz,
    gdy siedzisz na trawie, taki spokojny.
    Czy chcesz odkrywać głębiny,
    czy wolisz ląd, gdzie możesz skakać?

    Niezależnie od tego, co to jest, mały króliczku,
    niech ta iskra ciekawości płonie jasno.
    W Twoich marzeniach i aspiracjach
    kryje się świat,który czeka na Twoje dzieła.

    Rozwiązywanie problemów z nieudaną częścią prompta

    Trudno jest stwierdzić, czy prompt nie zadziałał, ponieważ model nie zrozumiał obrazu, czy też zrozumiał obraz, ale nie wykonał prawidłowych kroków rozumowania. Aby uściślić te powody, poproś model o opisanie tego, co jest na obrazie.

    W poniższym przykładzie, jeśli model odpowie, podając przekąskę, która wydaje się zaskakująca w połączeniu z herbatą (np. popcorn), możesz najpierw rozwiązać problem, aby ustalić, czy model prawidłowo rozpoznał, że obraz zawiera herbatę.

    Prompt Prompt do rozwiązywania problemów

    Jaką przekąskę mogę przygotować w minutę, która będzie do tego pasować?

    Opisz, co jest na tym obrazie.

    Inną strategią jest poproszenie modelu o wyjaśnienie jego rozumowania. Może to pomóc w określeniu, która część rozumowania zawiodła, jeśli w ogóle.

    Prompt Prompt do rozwiązywania problemów

    Jaką przekąskę mogę przygotować w minutę, która będzie do tego pasować?

    Jaką przekąskę mogę przygotować w minutę, która będzie do tego pasować? W jaki sposób?

    Co dalej?

    • Spróbuj napisać własne prompty multimodalne, korzystając z Google AI Studio.
    • Informacje o używaniu interfejsu Gemini Files API do przesyłania plików multimedialnych i uwzględniania ich w promptach znajdziesz w przewodnikach dotyczących Vision, dźwięku i przetwarzania dokumentów.
    • Więcej wskazówek dotyczących projektowania promptów, takich jak dostrajanie parametrów próbkowania, znajdziesz na stronie Strategie dotyczące promptów.