Gemini może jednocześnie przetwarzać 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 promptach 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 uzyskać jego metadane, wywołując 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żytkowaniu
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. Możesz pobierać pliki wygenerowane przez modele, takie jak filmy, 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 posta na 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 moich doświadczeniach z przygotowywaniem posiłków. 
|
Przygotowywanie posiłków to świetny sposób na oszczędzanie czasu i pieniędzy, który może też pomóc Ci zdrowiej się odżywiać. To danie jest świetnym przykładem zdrowego i pysznego posiłku, który można przygotować z wyprzedzeniem. To danie składa się z brązowego ryżu, pieczonych warzyw i kurczaka teriyaki. Brązowy ryż to zdrowy i złożony węglowodan, który zapewni Ci energię na dłużej. Pieczone warzywa to świetny sposób na dostarczenie organizmowi dziennej dawki witamin i minerałów, a kurczak teriyaki to pyszne i bogate w białko danie. Ten posiłek jest też łatwy w przygotowaniu. 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. Następnie możesz wziąć pojemnik i wyjść z domu w zabiegany poranek. Jeśli szukasz zdrowego i pysznego posiłku, który można przygotować wcześniej, to świetny wybór. Jest pełna składników odżywczych i smaku, a do tego na pewno Cię nasyci. Życzymy zdrowego i smacznego 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 wykorzystujące dane multimodalne.
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 prompta kilka przykładów: użyj realistycznych przykładów few-shot, aby zilustrować, co chcesz osiągnąć.
- Podziel zadanie na etapy: podziel skomplikowane zadania na mniejsze cele, aby model mógł łatwiej je zrealizować.
- Określ format danych wyjściowych: w prompcie poproś o wygenerowanie danych wyjściowych w wybranym formacie, np. Markdown, JSON, HTML lub innym.
- W przypadku promptów z jednym obrazem umieść obraz na początku: Gemini może przetwarzać obrazy i tekst 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. Jeśli jednak prompty wymagają, aby obrazy były przeplatane tekstem, aby miały sens, użyj najbardziej naturalnej kolejności.
-
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 tym, która część zawiodła: poproś model o opisanie obrazu lub wyjaśnienie jego rozumowania, aby ocenić jego początkowe zrozumienie.
- Jeśli prompt powoduje generowanie halucynacji: spróbuj obniżyć 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 wartościami 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ź |
|---|---|
Przeanalizuj godzinę i miasto z tablicy lotniskowej widocznej na tym obrazie i utwórz listę. |
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 też nazwę kraju (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 |
|---|---|
 Określ miasto i charakterystyczny obiekt. |
Ten punkt orientacyjny to statua Chrystusa Zbawiciela w Rio de Janeiro w Brazylii. |
| Zaktualizowany prompt | Ulepszona odpowiedź |
|---|---|
|
Określ miasto i charakterystyczny obiekt. 
|
miasto: Rzym, punkt orientacyjny: Koloseum. |
|
city: Beijing, landmark: Forbidden City |
|
|
miasto: Rio de Janeiro, punkt orientacyjny: statua Chrystusa Zbawiciela |
Wyjaśnij krok po kroku
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ź |
|---|---|
|
|
Zadania matematyczne lub inne zadania tekstowe 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. Możesz to poprawić, prosząc model o przeanalizowanie problemu przed udzieleniem odpowiedzi na prompta.
| 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 $$
Zatem czwarty wyraz ciągu to -405. |
Ta odpowiedź modelu jest prawidłowa. Aby była jeszcze bardziej przejrzysta, 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ść uzyskania danych wyjściowych modelu w określonym formacie (np. Markdown, JSON, HTML), zwłaszcza jeśli dane wyjściowe modelu muszą zostać przetworzone przez zadanie podrzędne. Możesz spróbować uzyskać wynik w tym formacie, instruując model w prompcie, aby to zrobił. Oto 2 przykłady:
| Prompt | Odpowiedź modelu |
|---|---|
Przekształć tabelę na tym obrazie na format Markdown |
```none | Przedmiot | Stan | Czas | Data rozpoczęcia | Termin | | ------- | ------ | ---- | ---------- | ------ | | Matematyka | Zrobione | 1,5 godz. | 29.11.2023 | 1.12.2023 | | Geografia | Zrobione | 30 min | 2.12.2023 | 4.12.2023 | | Fizyka | W toku | 2 godz. | 3.12.2023 | 5.12.2023 | | Biologia | Nie rozpoczęto | 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 jednym obrazem umieść obraz na początku
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 poniższych przykładach zauważysz, że w każdym prompcie obraz jest przed tekstem.
Rozwiązywanie problemów z tworzeniem promptów multimodalnych
Jeśli nie otrzymujesz przydatnej odpowiedzi, być może musisz rozwiązać problem 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 mają być uwzględnione w prompcie.
| Prompt | Odpowiedź modelu |
|---|---|
Na ile dni wystarczą te pieluchy? |
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ę przez liczbę pieluch, które dziecko zużywa dziennie. |
Opakowanie zawiera 198 pieluch. Na pudełku jest napisane, że pieluchy są przeznaczone dla dzieci o wadze 10–17 kg. Dziecko w tym przedziale wagowym ma zwykle od 1 roku do 2 lat. Dwulatek zużywa zwykle 6 pieluch dziennie, więc opakowanie wystarczy 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 ułatwić modelowi dostosowanie odpowiedzi do obrazów, poproś go o opisanie obrazów 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 opisz szczegółowo, 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. Wszystkie te obrazy przedstawiają przestrzenie liminalne. Przestrzenie liminalne to miejsca lub sytuacje, które znajdują się pomiędzy 2 innymi miejscami lub sytuacjami. Często charakteryzują się poczuciem niepewności lub niejednoznaczności. Pierwszy obraz przedstawia osobę, która jest w domu i na wycieczce. 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 jego opuszczenia. 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ż spróbować wyraźnie poprosić model o odniesienie się do tego, co jest na obrazie.
| Zaktualizowany prompt | Ulepszona odpowiedź |
|---|---|
|
Co łączy te obrazy? W odpowiedzi odnieś się do tego, co jest na obrazach. |
Wszystkie obrazy są związane z podróżami. Pierwszy obraz przedstawia osobę pakującą walizkę, drugi – pusty korytarz w centrum handlowym, trzeci – stos papieru toaletowego, a czwarty – ciemne i wzburzone 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 wyjazd. Trzeci obraz przedstawia stos papieru toaletowego, którego ludzie często używają podczas podróży. Czwarty obraz przedstawia ciemne i wzburzone morze, które ludzie często widzą podczas podróży. |
Te same wskazówki dotyczą kreatywnych treści generowanych na podstawie obrazów. W poniższym przykładzie z królikiem wyraźna prośba o uwzględnienie aspektów obrazu może poprawić wynik.
| Prompt | Odpowiedź modelu |
|---|---|
Czy możesz napisać wiersz o tym obrazie? |
Mały zajączek, miękki i brązowy, Zajadasz trawę, zieloną i słodką, |
| 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, Czy to oceanu błękit, Mały króliczku, powiedz mi, Może to przez ogrom tego wszystkiego, Króliczku, o czym śnisz, Niezależnie od tego, co to jest, mały króliczku, |
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.
Jeśli na przykład model odpowie, że do herbaty pasuje przekąska, która wydaje się zaskakująca (np. popcorn), możesz najpierw rozwiązać problem, aby ustalić, czy model prawidłowo rozpoznał, że obraz zawiera herbatę.
| Prompt | Prompt for troubleshooting |
|---|---|
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 Ci ustalić, która część rozumowania zawiodła.
| Prompt | Prompt for troubleshooting |
|---|---|
|
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 za pomocą 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.