Możesz poprosić model Gemini o przeanalizowanie przesłanych przez Ciebie plików obrazów w formie wbudowanej (zakodowanej w formacie base64) lub za pomocą adresu URL. Gdy używasz Firebase AI Logic, możesz wysłać to żądanie bezpośrednio z aplikacji.
Dzięki tej funkcji możesz m.in.:
- tworzyć podpisy lub odpowiadać na pytania dotyczące obrazów,
- Napisz krótkie opowiadanie lub wiersz na podstawie obrazu
- wykrywanie obiektów na obrazie i zwracanie współrzędnych ich ramek ograniczających,
- Etykietowanie lub kategoryzowanie zestawu obrazów pod kątem nastroju, stylu lub innych cech
Przejdź do przykładowych fragmentów kodu Przejdź do kodu dla odpowiedzi przesyłanych strumieniowo
Więcej opcji pracy z obrazami znajdziesz w innych przewodnikach Generowanie danych strukturalnych Czat wieloetapowy Analizowanie obrazów na urządzeniu Generowanie obrazów |
Zanim zaczniesz
Kliknij dostawcę Gemini API, aby wyświetlić na tej stronie treści i kod dostawcy. |
Jeśli jeszcze tego nie zrobisz, zapoznaj się z przewodnikiem dla początkujących, w którym znajdziesz informacje o tym, jak skonfigurować projekt Firebase, połączyć aplikację z Firebase, dodać pakiet SDK, zainicjować usługę backendu dla wybranego dostawcy Gemini API i utworzyć instancję GenerativeModel
.
Do testowania i ulepszania promptów, a nawet uzyskiwania wygenerowanego fragmentu kodu zalecamy używanie Google AI Studio.
Generowanie tekstu z plików obrazów (zakodowanych w formacie base64)
Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy. |
Możesz poprosić model Gemini o wygenerowanie tekstu, podając tekst i obrazy – podaj mimeType
każdego pliku wejściowego i sam plik. Wymagania i rekomendacje dotyczące plików wejściowych znajdziesz w dalszej części tej strony.
Swift
Możesz wywołać funkcję
generateContent()
aby wygenerować tekst na podstawie multimodalnych danych wejściowych w postaci tekstu i obrazów.
Dane wejściowe w postaci 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.5-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.")
Wiele plików wejściowych
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.5-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 w postaci tekstu i obrazów.
Dane wejściowe w postaci 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.5-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)
Wiele plików wejściowych
W przypadku Kotlina metody w tym pakiecie SDK są funkcjami zawieszającymi i muszą być wywoływane w zakresie Coroutine.
// 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.5-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 w postaci tekstu i obrazów.
ListenableFuture
.
Dane wejściowe w postaci 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.5-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);
Wiele plików wejściowych
// 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.5-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 w postaci tekstu i obrazów.
Dane wejściowe w postaci 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.5-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();
Wiele plików wejściowych
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.5-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 w postaci tekstu i obrazów.
Dane wejściowe w postaci 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.5-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);
Wiele plików wejściowych
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.5-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 w postaci tekstu i obrazów.
Dane wejściowe w postaci 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.5-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.");
Wiele plików wejściowych
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.5-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 odpowiednie do Twojego przypadku użycia i aplikacji.
Wyświetlanie odpowiedzi stopniowo
Zanim wypróbujesz ten przykład, zapoznaj się z sekcją Zanim zaczniesz w tym przewodniku, aby skonfigurować projekt i aplikację. W tej sekcji klikniesz też przycisk wybranego dostawcyGemini API, aby na tej stronie wyświetlały się treści dotyczące tego dostawcy. |
Możesz uzyskać szybsze interakcje, nie czekając na pełny wynik generowania modelu, i zamiast tego używać przesyłania strumieniowego do obsługi częściowych wyników.
Aby przesyłać strumieniowo odpowiedź, wywołaj funkcję generateContentStream
.
Wymagania i zalecenia dotyczące plików obrazów wejściowych
Pamiętaj, że plik podany jako dane wbudowane jest kodowany do formatu base64 podczas przesyłania, co zwiększa rozmiar żądania. Jeśli żądanie jest zbyt duże, otrzymasz błąd HTTP 413.
Więcej informacji o tych kwestiach znajdziesz w artykule „Obsługiwane pliki wejściowe i wymagania dotyczące Vertex AI Gemini API”:
- Różne opcje przesyłania pliku w prośbie (w formie wbudowanej lub za pomocą adresu URL pliku).
- Wymagania i sprawdzone metody dotyczące plików graficznych
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 konkretnego limitu liczby pikseli na obrazie. Większe obrazy są jednak zmniejszane i uzupełniane, aby dopasować je do maksymalnej rozdzielczości 3072 x 3072 pikseli przy zachowaniu oryginalnego współczynnika proporcji.
Oto maksymalna liczba plików obrazów dozwolonych w żądaniu prompta:
- Gemini 2.0 Flash i Gemini 2.0 Flash‑Lite: 3000 obrazów
Co jeszcze możesz zrobić?
- Dowiedz się, jak liczyć tokeny przed wysłaniem do modelu długich promptów.
- Skonfiguruj Cloud Storage for Firebase, aby móc uwzględniać duże pliki w żądaniach multimodalnych i korzystać z bardziej zarządzanego rozwiązania do udostępniania plików w promptach. Mogą to być obrazy, pliki PDF, wideo i audio.
-
Zacznij myśleć o przygotowaniu do udostępnienia wersji produkcyjnej (patrz lista kontrolna produkcji), w tym:
- Skonfiguruj Firebase App Check, aby chronić Gemini API przed nadużyciami ze strony nieautoryzowanych klientów.
- Integrowanie Firebase Remote Config w celu aktualizowania wartości w aplikacji (np. nazwy modelu) bez publikowania nowej wersji aplikacji.
Wypróbuj inne funkcje
- Twórz rozmowy wieloetapowe (czat).
- generować tekst na podstawie promptów tekstowych,
- Generowanie danych wyjściowych o strukturze (np. JSON) na podstawie promptów tekstowych i multimodalnych.
- Generuj obrazy na podstawie promptów tekstowych (Gemini lub Imagen).
- Używaj wywoływania funkcji, aby łączyć modele generatywne z systemami zewnętrznymi i informacjami.
Dowiedz się, jak kontrolować generowanie treści
- Poznaj projektowanie promptów, w tym sprawdzone metody, strategie i przykładowe prompty.
- Skonfiguruj parametry modelu, takie jak temperatura i maksymalna liczba tokenów wyjściowych (w przypadku Gemini) lub format obrazu i generowanie osób (w przypadku Imagen).
- Użyj ustawień bezpieczeństwa, aby dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą być uznane za szkodliwe.
Więcej informacji o obsługiwanych modelach
Dowiedz się więcej o modelach dostępnych w różnych przypadkach użycia, ich limitach i cenach.Prześlij opinię o korzystaniu z usługi Firebase AI Logic