A API Gemini pode executar inferência em imagens e vídeos transmitidos a ela. Após a aprovação uma imagem, uma série de imagens ou um vídeo, o Gemini pode:
- Descreva ou responda a perguntas sobre o conteúdo
- Resumir o conteúdo
- Extrapolar do conteúdo
Este tutorial demonstra algumas maneiras possíveis de solicitar a API Gemini com imagens e vídeos. Todas as saídas são somente de texto.
Antes de começar: configurar o projeto e a chave de API
Antes de chamar a API Gemini, você precisa definir seu projeto e configurar sua chave de API.
Comandos com imagens
Neste tutorial, você fará upload de imagens usando a API File ou como dados inline e gerar conteúdo com base nessas imagens.
Detalhes técnicos (imagens)
O Gemini 1.5 Pro e o 1.5 Flash aceitam no máximo 3.600 arquivos de imagem.
As imagens precisam estar em um dos seguintes tipos MIME de dados de imagens:
PNG - image/pngJPEG - image/jpegWEBP - image/webpHEIC - image/heicHEIF - image/heif
Cada imagem equivale a 258 tokens.
Embora não haja limites específicos para o número de pixels em uma imagem além janela de contexto do modelo, imagens maiores serão reduzidas ao máximo de 3.072 x 3.072, preservando a proporção original, e imagens menores são dimensionadas para até 768 x 768 pixels. Não há redução de custo para imagens em tamanhos menores, que não a largura de banda, ou melhoria de desempenho imagens com maior resolução.
Para os melhores resultados:
- Gire as imagens para a orientação correta antes de fazer upload.
- Evite imagens desfocadas.
- Se estiver usando uma única imagem, coloque o comando de texto depois dela.
Fazer upload de um arquivo de imagem usando a API File
Use a API File para fazer upload de uma imagem de qualquer tamanho. Sempre use a API File quando a combinação de arquivos e instruções do sistema que você pretende têm mais de 20 MB.)
Para começar, faça o download esboço de uma mochila a jato.
curl -o jetpack.jpg https://storage.googleapis.com/generativeai-downloads/images/jetpack.jpg
Faça o upload da imagem usando
media.upload
e mostrar o URI, que é usado como referência nas chamadas de API do Gemini.
// To use the File API, add this import path for GoogleAIFileManager.
// Note that this is a different import path than what you use for generating content.
// For versions lower than @google/generative-ai@0.13.0
// use "@google/generative-ai/files"
import { GoogleAIFileManager } from "@google/generative-ai/server";
// Initialize GoogleAIFileManager with your API_KEY.
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
// Upload the file and specify a display name.
const uploadResponse = await fileManager.uploadFile("jetpack.jpg", {
mimeType: "image/jpeg",
displayName: "Jetpack drawing",
});
// View the response.
console.log(`Uploaded file ${uploadResponse.file.displayName} as: ${uploadResponse.file.uri}`);
Verificar o upload de arquivos de imagem e receber metadados
Você pode verificar se a API armazenou o arquivo enviado e receber o
metadados chamando files.get
pelo SDK. Somente o name (e, por extensão, o uri) são exclusivos. Usar
display_name para identificar arquivos somente se você gerenciar a exclusividade por conta própria.
// Get the previously uploaded file's metadata.
const getResponse = await fileManager.getFile(uploadResponse.file.name);
// View the response.
console.log(`Retrieved file ${getResponse.displayName} as ${getResponse.uri}`);
Dependendo do caso de uso, é possível armazenar os URIs em estruturas, como um como hashtable ou um banco de dados.
Comando com a imagem e o texto enviados
Depois de fazer upload do arquivo, é possível fazer solicitações GenerateContent que referenciam
o URI da API File. Selecione o modelo generativo e forneça um comando de texto a ele.
e a imagem enviada.
// The following was placed here for relevance but should be added to imports.
// To generate content, use this import path for GoogleGenerativeAI.
// Note that this is a different import path than what you use for the File API.
import { GoogleGenerativeAI } from "@google/generative-ai";
// Initialize GoogleGenerativeAI with your API_KEY.
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
const model = genAI.getGenerativeModel({
// Choose a Gemini model.
model: "gemini-1.5-pro",
});
// Upload file ...
// Generate content using text and the URI reference for the uploaded file.
const result = await model.generateContent([
{
fileData: {
mimeType: uploadResponse.file.mimeType,
fileUri: uploadResponse.file.uri
}
},
{ text: "Describe how this product might be manufactured." },
]);
// Output the generated text to the console
console.log(result.response.text())
Chamar um ou mais arquivos de imagem armazenados localmente
Se preferir, faça upload dos seus próprios arquivos. Você pode fazer o download e usar nossa desenhos de águas com infestação de piranha e um bombeiro com um gato.
Quando a combinação de arquivos e instruções do sistema que você pretende enviar tiver mais de 20 MB, use a API File para fazer o upload desses arquivos, conforme mostrados anteriormente. Arquivos menores podem ser chamados localmente API Gemini:
import { GoogleGenerativeAI } from "@google/generative-ai";
import fs from "fs";
// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
// Converts local file information to a GoogleGenerativeAI.Part object.
function fileToGenerativePart(path, mimeType) {
return {
inlineData: {
data: Buffer.from(fs.readFileSync(path)).toString("base64"),
mimeType
},
};
}
// Turn images to Part objects
const filePart1 = fileToGenerativePart("jetpack.jpg", "image/jpeg")
const filePart2 = fileToGenerativePart("piranha.jpg", "image/jpeg")
const filePart3 = fileToGenerativePart("firefighter.jpg", "image/jpeg")
Observe que essas chamadas de dados inline não incluem muitos dos recursos disponíveis por meio da API File, como obtenção de metadados de arquivos, listagens ou excluindo arquivos.
Comando com várias imagens
Você pode oferecer à API Gemini qualquer combinação de imagens e textos que se encaixam na janela de contexto do modelo. Este exemplo mostra um texto curto e as três imagens enviadas anteriormente.
async function run() {
// Choose a Gemini model.
const model = genAI.getGenerativeModel({ model: "gemini-1.5-pro" });
const prompt = "Write an advertising jingle showing how the product in the first image could solve the problems shown in the second two images.";
const imageParts = [
filePart1,
filePart2,
filePart3,
];
const generatedContent = await model.generateContent([prompt, ...imageParts]);
console.log(generatedContent.response.text());
}
run();
Receber uma caixa delimitadora para um objeto
É possível solicitar ao modelo as coordenadas das caixas delimitadoras para objetos
em imagens. Para a detecção de objetos, o modelo Gemini foi treinado para oferecer
essas coordenadas como larguras ou alturas relativas no intervalo [0,1], dimensionadas por
1.000 e convertido em um número inteiro. Efetivamente, as coordenadas fornecidas são para uma
com 1000 x 1000 da imagem original e precisam ser convertidos de volta para o
da imagem original.
// filePart = ...
// filePart2 has the piranha.
async function findBox(filePart) {
// Choose a Gemini model.
const model = genAI.getGenerativeModel({ model: "gemini-1.5-pro" });
const prompt = "Return a bounding box for the piranha. \n [ymin, xmin, ymax, xmax]";
const generatedContent = await model.generateContent([prompt, filePart]);
console.log(generatedContent.response.text());
}
run(filePart);
Para converter essas coordenadas em dimensões da imagem original:
- Divida cada coordenada de saída por 1.000.
- Multiplique as coordenadas x pela largura da imagem original.
- Multiplique as coordenadas y pela altura da imagem original.
Como criar comandos com vídeo
Neste tutorial, você vai enviar um vídeo usando a API File e gerar baseado nessas imagens.
Detalhes técnicos (vídeo)
O Gemini 1.5 Pro e o Flash aceitam até aproximadamente uma hora de dados de vídeo.
O vídeo precisa estar em um dos seguintes formatos de vídeo de tipos MIME:
video/mp4video/mpegvideo/movvideo/avivideo/x-flvvideo/mpgvideo/webmvideo/wmvvideo/3gpp
O serviço da API File extrai frames de imagem de vídeos a 1 frame por segundo (QPS) e áudio a 1 Kbps, com canal único, adicionando marcações de tempo a cada segundo. Essas taxas estão sujeitas a mudanças no futuro para melhorar a inferência.
Quadros individuais são 258 tokens e áudio é 32 tokens por segundo. Com metadados, cada segundo de vídeo se torna cerca de 300 tokens, o que significa um contexto de 1 milhão pode caber um pouco menos de uma hora de vídeo.
Para fazer perguntas sobre locais com data e hora, use o formato MM:SS, em que
os dois primeiros dígitos representam os minutos e os dois últimos representam os minutos
segundos.
Para os melhores resultados:
- Use um vídeo por comando.
- Se estiver usando apenas um vídeo, coloque o comando de texto depois do vídeo.
Enviar um arquivo de vídeo usando a API File
A API File aceita formatos de arquivos de vídeo diretamente. Este exemplo usa curta-metragem da NASA "A Grande Mancha vermelha de Júpiter cresce e encolhe". Crédito: Goddard Space Flight Center (GSFC)/David Ladd (2018).
"A Grande Mancha vermelha de Júpiter cresce e encolhe" é de domínio público e não mostrar pessoas identificáveis. (Diretrizes de uso de mídia e imagens da NASA.)
Comece recuperando o vídeo curto:
wget https://storage.googleapis.com/generativeai-downloads/images/GreatRedSpot.mp4
Faça upload do vídeo usando a API File e imprima o URI.
// To use the File API, use this import path for GoogleAIFileManager.
// Note that this is a different import path than what you use for generating content.
// For versions lower than @google/generative-ai@0.13.0
// use "@google/generative-ai/files"
import { GoogleAIFileManager } from "@google/generative-ai/server";
// Initialize GoogleAIFileManager with your API_KEY.
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
// Upload the file and specify a display name.
const uploadResponse = await fileManager.uploadFile("GreatRedSpot.mp4", {
mimeType: "video/mp4",
displayName: "Jupiter's Great Red Spot",
});
// View the response.
console.log(`Uploaded file ${uploadResponse.file.displayName} as: ${uploadResponse.file.uri}`);
Verificar o upload de arquivos e o estado
Verifique se a API recebeu os arquivos chamando
método files.get.
// To use the File API, use this import path for GoogleAIFileManager.
// Note that this is a different import path than what you use for generating content.
// For versions lower than @google/generative-ai@0.13.0
// use "@google/generative-ai/files"
import { GoogleAIFileManager, FileState } from "@google/generative-ai/server";
// Initialize GoogleAIFileManager with your API_KEY.
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
// Upload the video file using the File API
// uploadResponse = ...
const name = uploadResponse.file.name;
// Poll getFile() on a set interval (10 seconds here) to check file state.
let file = await fileManager.getFile(name);
while (file.state === FileState.PROCESSING) {
process.stdout.write(".")
// Sleep for 10 seconds
await new Promise((resolve) => setTimeout(resolve, 10_000));
// Fetch the file from the API again
file = await fileManager.getFile(name)
}
if (file.state === FileState.FAILED) {
throw new Error("Video processing failed.");
}
// When file.state is ACTIVE, the file is ready to be used for inference.
console.log(`File ${file.displayName} is ready for inference as ${file.uri}`);
Comando com vídeo e texto
Quando o vídeo enviado estiver no estado ACTIVE, você poderá fazer com que GenerateContent
solicitações que especificam o URI da API File para esse vídeo. Selecione a categoria
e forneça o vídeo enviado e um comando de texto.
// To generate content, use this import path for GoogleGenerativeAI.
// Note that this is a different import path than what you use for the File API.
import { GoogleGenerativeAI } from "@google/generative-ai";
// Initialize GoogleGenerativeAI with your API_KEY.
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
// Choose a Gemini model.
const model = genAI.getGenerativeModel({
model: "gemini-1.5-pro",
});
// Upload the video file using the File API
// uploadResponse = ...
// Generate content using text and the URI reference for the uploaded file.
const result = await model.generateContent([
{
fileData: {
mimeType: uploadResponse.file.mimeType,
fileUri: uploadResponse.file.uri
}
},
{ text: "Summarize this video. Then create a quiz with answer key based on the information in the video." },
]);
// Handle the response of generated text
console.log(result.response.text())
Consultar as marcações de tempo no conteúdo
É possível usar carimbos de data/hora no formato MM:SS para se referir a momentos específicos na
vídeo.
// To generate content, use this import path for GoogleGenerativeAI.
// Note that this is a different import path than what you use for the File API.
import { GoogleGenerativeAI } from "@google/generative-ai";
// Initialize GoogleGenerativeAI with your API_KEY.
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
// Choose a Gemini model.
const model = genAI.getGenerativeModel({
model: "gemini-1.5-pro",
});
// Upload the video file using the File API
// uploadResponse = ...
// Generate content using text and the URI reference for the uploaded file.
const result = await model.generateContent([
{
fileData: {
mimeType: uploadResponse.file.mimeType,
fileUri: uploadResponse.file.uri
}
},
{ text: "What are the examples given at 01:05 and 01:19 supposed to show us?" },
]);
// Handle the response of generated text
console.log(result.response.text())
Transcrever o vídeo e fornecer descrições visuais
Se o vídeo não tiver um ritmo acelerado (somente 1 frame por segundo de vídeo será usado), é possível transcrever o vídeo com descrições visuais para cada tomada.
// To generate content, use this import path for GoogleGenerativeAI.
// Note that this is a different import path than what you use for the File API.
import { GoogleGenerativeAI } from "@google/generative-ai";
// Initialize GoogleGenerativeAI with your API_KEY.
const genAI = new GoogleGenerativeAI(process.env.API_KEY);
// Choose a Gemini model.
const model = genAI.getGenerativeModel({
model: "gemini-1.5-pro",
});
// Upload the video file using the File API
// uploadResponse = ...
// Generate content using text and the URI reference for the uploaded file.
const result = await model.generateContent([
{
fileData: {
mimeType: uploadResponse.file.mimeType,
fileUri: uploadResponse.file.uri
}
},
{ text: "Transcribe the audio, giving timestamps. Also provide visual descriptions." },
]);
// Handle the response of generated text
console.log(result.response.text())
Listar arquivos
Você pode listar todos os arquivos enviados usando a API File e seus URIs usando
files.list_files():
// To use the File API, use this import path for GoogleAIFileManager.
// Note that this is a different import path than what you use for generating content.
// For versions lower than @google/generative-ai@0.13.0
// use "@google/generative-ai/files"
import { GoogleAIFileManager } from "@google/generative-ai/server";
// Initialize GoogleAIFileManager with your API_KEY.
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
const listFilesResponse = await fileManager.listFiles();
// View the response.
for (const file of listFilesResponse.files) {
console.log(`name: ${file.name} | display name: ${file.displayName}`);
}
Excluir arquivos
Os arquivos enviados por upload usando a API File são excluídos automaticamente após dois dias. Você
também pode excluí-los manualmente usando files.delete().
// To use the File API, use this import path for GoogleAIFileManager.
// Note that this is a different import path than what you use for generating content.
// For versions lower than @google/generative-ai@0.13.0
// use "@google/generative-ai/files"
import { GoogleAIFileManager } from "@google/generative-ai/server";
// Initialize GoogleAIFileManager with your API_KEY.
const fileManager = new GoogleAIFileManager(process.env.API_KEY);
// Get the file metadata
// file = ... // using getFile, listFile or a previously uploaded file
// Delete the file.
await fileManager.deleteFile(file.name);
console.log(`Deleted ${file.displayName}`);
A seguir
Neste guia, mostramos como usar
generateContent e
para gerar saídas de texto com base em entradas de imagem e vídeo. Para saber mais,
consulte os seguintes recursos:
- Como executar comandos com arquivos de mídia: o A API Gemini oferece suporte a comandos com dados de texto, imagem, áudio e vídeo, também conhecidos como comandos multimodais.
- Instruções do sistema: System permitem que você direcione o comportamento do modelo com base necessidades e casos de uso.
- Orientação de segurança: às vezes, a IA generativa os modelos produzem saídas inesperadas, como saídas imprecisas, enviesada ou ofensiva. O pós-processamento e a avaliação humana são essenciais e limitar o risco de danos desses resultados.