Analizowanie plików graficznych za pomocą interfejsu Gemini API

Możesz poprosić model Gemini o przeanalizowanie przesłanych przez Ciebie plików obrazów (w postaci zakodowanej w formacie base64 lub za pomocą adresu URL). Jeśli używasz Firebase AI Logic, możesz wysłać to żądanie bezpośrednio z aplikacji.

Dzięki tej funkcji możesz:

  • tworzyć napisy lub odpowiadać na pytania dotyczące obrazów;
  • Napisz krótkie opowiadanie lub wiersz na temat obrazu
  • Wykrywanie obiektów na obrazie i zwracanie ich współrzędnych ramki ograniczającej
  • etykietowanie lub kategoryzowanie zbioru obrazów według nastroju, stylu lub innych cech;

Przejdź do przykładowych fragmentów kodu Przejdź do kodu dla odpowiedzi strumieniowych


Aby uzyskać więcej opcji pracy z obrazami, zapoznaj się z innymi przewodnikami
Generowanie danych wyjściowych w formie ustrukturyzowanej Czat wieloetapowy Analiza obrazów na urządzeniu Generowanie obrazów

Zanim zaczniesz

Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod związane z tym dostawcą.

Jeśli jeszcze tego nie zrobisz, przeczytaj przewodnik dla początkujących, w którym znajdziesz instrukcje konfigurowania projektu Firebase, łączenia aplikacji z Firebase, dodawania pakietu SDK, inicjowania usługi backendowej wybranego dostawcy Gemini API oraz tworzenia instancji GenerativeModel.

Aby przetestować prompty i przeprowadzić ich iterację, a także uzyskać wygenerowany fragment kodu, zalecamy użycie Google AI Studio.

Generowanie tekstu z plików graficznych (zakodowanych w formacie base64)

Zanim użyjesz tego szablonu, zapoznaj się z sekcją Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji kliknij też przycisk wybranegoGemini API dostawcy, aby wyświetlić na tej stronie treści związane z tym dostawcą.

Możesz poprosić model Gemini o wygenerowanie tekstu, podając tekst i obrazy jako prompty – udostępniając mimeType każdego pliku wejściowego oraz sam plik. Wymagania i zalecenia dotyczące plików wejściowych znajdziesz dalej na tej stronie.

Swift

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych, czyli tekstu i obrazów.

Dane wejściowe z pojedynczego pliku 


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.0-flash")


guard let image = UIImage(systemName: "bicycle") else { fatalError() }

// Provide a text prompt to include with the image
let prompt = "What's in this picture?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image, prompt)
print(response.text ?? "No text in response.")

Dane wejściowe z wielu plików


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.0-flash")


guard let image1 = UIImage(systemName: "car") else { fatalError() }
guard let image2 = UIImage(systemName: "car.2") else { fatalError() }

// Provide a text prompt to include with the images
let prompt = "What's different between these pictures?"

// To generate text output, call generateContent and pass in the prompt
let response = try await model.generateContent(image1, image2, prompt)
print(response.text ?? "No text in response.")

Kotlin

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych, czyli tekstu i obrazów.

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współbieżności.

Dane wejściowe z pojedynczego pliku 


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.0-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)

// Provide a prompt that includes the image specified above and text
val prompt = content {
  image(bitmap)
  text("What developer tool is this mascot from?")
}

// To generate text output, call generateContent with the prompt
val response = generativeModel.generateContent(prompt)
print(response.text)

Dane wejściowe z wielu plików

W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane z zakresu współbieżności. 

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.0-flash")


// Loads an image from the app/res/drawable/ directory
val bitmap1: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky)
val bitmap2: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.sparky_eats_pizza)

// Provide a prompt that includes the images specified above and text
val prompt = content {
  image(bitmap1)
  image(bitmap2)
  text("What is different between these pictures?")
}

// To generate text output, call generateContent with the prompt
val response = generativeModel.generateContent(prompt)
print(response.text)

Java

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych, czyli tekstu i obrazów.

W przypadku Javy metody w tym pakiecie SDK zwracają wartość ListenableFuture.

Dane wejściowe z pojedynczego pliku 


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.0-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);

// Provide a prompt that includes the image specified above and text
Content content = new Content.Builder()
        .addImage(bitmap)
        .addText("What developer tool is this mascot from?")
        .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Dane wejściowe z wielu plików


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.0-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky);
Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), R.drawable.sparky_eats_pizza);

// Provide a prompt that includes the images specified above and text
Content prompt = new Content.Builder()
    .addImage(bitmap1)
    .addImage(bitmap2)
    .addText("What's different between these pictures?")
    .build();

// To generate text output, call generateContent with the prompt
ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych, czyli tekstu i obrazów.

Dane wejściowe z pojedynczego pliku 


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.0-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the image
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const imagePart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call generateContent with the text and image
  const result = await model.generateContent([prompt, imagePart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dane wejściowe z wielu plików


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.0-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the images
  const prompt = "What's different between these pictures?";

  // Prepare images for input
  const fileInputEl = document.querySelector("input[type=file]");
  const imageParts = await Promise.all(
    [...fileInputEl.files].map(fileToGenerativePart)
  );

  // To generate text output, call generateContent with the text and images
  const result = await model.generateContent([prompt, ...imageParts]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Możesz wywołać funkcję generateContent(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych zawierających tekst i obrazy.

Dane wejściowe z pojedynczego pliku 


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.0-flash');


// Provide a text prompt to include with the image
final prompt = TextPart("What's in the picture?");
// Prepare images for input
final image = await File('image0.jpg').readAsBytes();
final imagePart = InlineDataPart('image/jpeg', image);

// To generate text output, call generateContent with the text and image
final response = await model.generateContent([
  Content.multi([prompt,imagePart])
]);
print(response.text);

Dane wejściowe z wielu plików


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.0-flash');


final (firstImage, secondImage) = await (
  File('image0.jpg').readAsBytes(),
  File('image1.jpg').readAsBytes()
).wait;
// Provide a text prompt to include with the images
final prompt = TextPart("What's different between these pictures?");
// Prepare images for input
final imageParts = [
  InlineDataPart('image/jpeg', firstImage),
  InlineDataPart('image/jpeg', secondImage),
];

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...imageParts])
]);
print(response.text);

Unity

Możesz wywołać funkcję GenerateContentAsync(), aby wygenerować tekst na podstawie multimodalnych danych wejściowych, czyli tekstu i obrazów.

Dane wejściowe z pojedynczego pliku 


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.0-flash");


// Convert a Texture2D into InlineDataParts
var grayImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.grayTexture));

// Provide a text prompt to include with the image
var prompt = ModelContent.Text("What's in this picture?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { grayImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Dane wejściowe z wielu plików


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.0-flash");


// Convert Texture2Ds into InlineDataParts
var blackImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.blackTexture));
var whiteImage = ModelContent.InlineData("image/png",
      UnityEngine.ImageConversion.EncodeToPNG(UnityEngine.Texture2D.whiteTexture));

// Provide a text prompt to include with the images
var prompt = ModelContent.Text("What's different between these pictures?");

// To generate text output, call GenerateContentAsync and pass in the prompt
var response = await model.GenerateContentAsync(new [] { blackImage, whiteImage, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Dowiedz się, jak wybrać model odpowiedni do Twojego przypadku użycia i aplikacji.

Odpowiadaj na pytania stopniowo

Zanim użyjesz tego szablonu, zapoznaj się z sekcją Zanim zaczniesz tego przewodnika, aby skonfigurować projekt i aplikację.
W tej sekcji kliknij też przycisk wybranegoGemini API dostawcy, aby wyświetlić na tej stronie treści związane z tym dostawcą.

Możesz uzyskać szybsze interakcje, nie czekając na pełny wynik wygenerowany przez model, a zamiast tego używać strumieniowego przetwarzania częściowych wyników. Aby przesyłać strumieniowo odpowiedź, zadzwoń pod numer generateContentStream.


Wymagania i zalecenia dotyczące plików z obrazami wejściowymi

Pamiętaj, że plik przesłany jako dane wstawione jest kodowany w trakcie przesyłania do formatu Base64, co zwiększa rozmiar żądania. Jeśli żądanie jest zbyt duże, pojawia się błąd HTTP 413.

Aby dowiedzieć się więcej o tych kwestiach:Vertex AI Gemini API

Obsługiwane typy MIME obrazów

Gemini modele multimodalne obsługują te typy MIME obrazów:

Typ MIME obrazu Gemini 2.0 Flash Gemini 2.0 Flash‑Lite
PNG – image/png
JPEG – image/jpeg
WebP – image/webp

Limity na żądanie

Nie ma określonego limitu liczby pikseli na obrazie. Większe obrazy są jednak zmniejszane i wypełniane, aby pasowały do maksymalnej rozdzielczości 3072 x 3072, przy zachowaniu oryginalnego współczynnika proporcji.

Oto maksymalna dozwolona liczba plików graficznych w promptach:

  • Gemini 2.0 Flash i Gemini 2.0 Flash‑Lite: 3000 obrazów.


Co jeszcze możesz zrobić?

Wypróbuj inne funkcje

Dowiedz się, jak kontrolować generowanie treści

Możesz też eksperymentować z promptami i konfiguracjami modelu, a nawet wygenerować fragment kodu za pomocą Google AI Studio.

Więcej informacji o obsługiwanych modelach

Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia oraz o ich limitach i cenach.


Prześlij opinię o swoich wrażeniach związanych z usługą Firebase AI Logic