Comprensione delle immagini

Puoi aggiungere immagini alle richieste di Gemini per eseguire attività che prevedono comprendere i contenuti delle immagini incluse. Questa pagina mostra come aggiungere immagini alle richieste a Gemini in Vertex AI utilizzando la console Google Cloud e l'API Vertex AI.

Modelli supportati

Nella tabella seguente sono elencati i modelli che supportano la comprensione delle immagini:

Modello Dettagli sulla modalità di immagine

Gemini 1.5 Flash

Vai alla scheda del modello Gemini 1.5 Flash		 Numero massimo di immagini per prompt: 3000

Gemini 1.5 Pro

Vai alla scheda del modello Gemini 1.5 Pro		 Numero massimo di immagini per prompt: 3000

Gemini 1.0 Pro Vision

Vai alla scheda del modello Gemini 1.0 Pro Vision		 Numero massimo di immagini per prompt: 16

Per un elenco delle lingue supportate dai modelli Gemini, consulta le informazioni sui modelli Google. Per scoprire di più su come progettare prompt multimodali, consulta Progettare prompt multimodali. Se stai cercando un modo per utilizzare Gemini direttamente dalle tue app web e mobile, consulta la sezione Vertex AI negli SDK Firebase per le app Android, Swift, web e Flutter.

Aggiungi immagini a una richiesta

Puoi aggiungere una singola immagine o più immagini nella tua richiesta a Gemini.

Immagine singola

Il codice di esempio in ciascuna delle seguenti schede mostra un modo diverso per identificare gli elementi di un'immagine. Questo esempio funziona con tutti i modelli multimodali Gemini.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta SDK Vertex AI per Python documentazione di riferimento dell'API.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello deve generare risposte in streaming oppure risposte non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il relativo token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo la generazione di tutti i token di output.

Per una risposta in modalità flusso, utilizza il parametro stream in generate_content.

  response = model.generate_content(contents=[...], stream = True)

Per una risposta non in streaming, rimuovi il parametro o impostalo su False.

Codice di esempio

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel("gemini-1.5-flash-002")

image_file = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"
)

# Query the model
response = model.generate_content([image_file, "what is this image?"])
print(response.text)

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Vertex AI. Per ulteriori informazioni, consulta la sezione Vertex AI documentazione di riferimento dell'SDK Java per Gemini.

Per autenticarti in Vertex AI, configura le credenziali predefinite per l'applicazione. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello deve generare risposte in streaming oppure risposte non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il relativo token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo che sono stati generati tutti i token di output.

Per una risposta dinamica, utilizza il metodo generateContentStream.

  public ResponseStream<GenerateContentResponse> generateContentStream(Content content)

Per una risposta non in streaming, utilizza il metodo generateContent.

  public GenerateContentResponse generateContent(Content content)

Codice di esempio

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.util.Base64;

public class MultimodalQuery {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";
    String dataImageBase64 = "your-base64-encoded-image";

    String output = multimodalQuery(projectId, location, modelName, dataImageBase64);
    System.out.println(output);
  }


  // Ask the model to recognise the brand associated with the logo image.
  public static String multimodalQuery(String projectId, String location, String modelName,
      String dataImageBase64) throws Exception {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      String output;
      byte[] imageBytes = Base64.getDecoder().decode(dataImageBase64);

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      GenerateContentResponse response = model.generateContent(
          ContentMaker.fromMultiModalData(
              "What is this image?",
              PartMaker.fromMimeTypeAndData("image/png", imageBytes)
          ));

      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella documentazione sull'IA generativa rapida utilizzando l'SDK Node.js. Per ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Node.js per Gemini.

Per eseguire l'autenticazione su Vertex AI, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello deve generare risposte in streaming oppure risposte non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo la generazione di tutti i token di output.

Per una risposta in modalità flusso, utilizza generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Per una risposta non in streaming, utilizza il metodo generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Codice di esempio

const {VertexAI} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createNonStreamingMultipartContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001',
  image = 'gs://generativeai-downloads/images/scones.jpg',
  mimeType = 'image/jpeg'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // For images, the SDK supports both Google Cloud Storage URI and base64 strings
  const filePart = {
    fileData: {
      fileUri: image,
      mimeType: mimeType,
    },
  };

  const textPart = {
    text: 'what is shown in this image?',
  };

  const request = {
    contents: [{role: 'user', parts: [filePart, textPart]}],
  };

  console.log('Prompt Text:');
  console.log(request.contents[0].parts[1].text);

  console.log('Non-Streaming Response Text:');

  // Generate a response
  const response = await generativeVisionModel.generateContent(request);

  // Select the text from the response
  const fullTextResponse =
    response.response.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida introduttiva di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Go di Vertex AI per Gemini.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello genera risposte in streaming o non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il relativo token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo che sono stati generati tutti i token di output.

Per una risposta in modalità flusso, utilizza GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

Per una risposta non in streaming, utilizza il metodo GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

Codice di esempio

import (
	"context"
	"encoding/json"
	"fmt"
	"io"

	"cloud.google.com/go/vertexai/genai"
)

func tryGemini(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.5-flash-001"

	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	gemini := client.GenerativeModel(modelName)

	img := genai.FileData{
		MIMEType: "image/jpeg",
		FileURI:  "gs://generativeai-downloads/images/scones.jpg",
	}
	prompt := genai.Text("What is in this image?")

	resp, err := gemini.GenerateContent(ctx, img, prompt)
	if err != nil {
		return fmt.Errorf("error generating content: %w", err)
	}
	rb, err := json.MarshalIndent(resp, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))
	return nil
}

C#

Prima di provare questo esempio, segui le istruzioni di configurazione C# in Vertex AI Guida rapida. Per ulteriori informazioni, consulta la sezione Vertex AI documentazione di riferimento C#.

Per eseguire l'autenticazione su Vertex AI, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello deve generare risposte in streaming oppure risposte non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il relativo token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo che sono stati generati tutti i token di output.

Per una risposta in modalità flusso, utilizza StreamGenerateContent.

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)

Per una risposta non in streaming, utilizza il metodo GenerateContentAsync.

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)

Per ulteriori informazioni su come il server può trasmettere le risposte, consulta RPC dinamiche.

Codice di esempio


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;

public class GeminiQuickstart
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        // Create client
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        // Initialize content request
        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            GenerationConfig = new GenerationConfig
            {
                Temperature = 0.4f,
                TopP = 1,
                TopK = 32,
                MaxOutputTokens = 2048
            },
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "What's in this photo?" },
                        new Part { FileData = new() { MimeType = "image/png", FileUri = "gs://generativeai-downloads/images/scones.jpg" } }
                    }
                }
            }
        };

        // Make the request, returning a streaming response
        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        // Read streaming responses from server until complete
        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }

        return fullText.ToString();
    }
}

REST

Dopo configurare l'ambiente, puoi usare REST per testare un prompt di testo. Il seguente esempio invia una richiesta al publisher endpoint del modello.

Puoi includere immagini archiviate in Cloud Storage o utilizzare dati delle immagini codificati in base64.

Immagine in Cloud Storage

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • LOCATION: la regione in cui elaborare la richiesta. Inserisci una regione supportata. Per l'elenco completo delle regioni supportate, vedi Località disponibili.

    Fai clic per espandere un elenco parziale delle regioni disponibili

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: il tuo ID progetto.
  • FILE_URI: L'URI o l'URL del file da includere nel prompt. I valori accettati sono:
    • URI del bucket Cloud Storage: l'oggetto deve essere leggibile pubblicamente o trovarsi nello stesso progetto Google Cloud che invia la richiesta.
    • URL HTTP: l'URL del file deve essere leggibile pubblicamente. Puoi specificare un file video e fino a 10 file immagine per richiesta. I file audio e i documenti non possono superare i 15 MB.
    • URL del video di YouTube: il video di YouTube deve essere di proprietà dell'account che hai utilizzato per accedere alla console Google Cloud o essere pubblico. È supportato un solo URL di video di YouTube per richiesta.

    Quando specifichi un fileURI, devi specificare anche il tipo di media (mimeType) del file.

    Se non hai un file immagine in Cloud Storage, puoi usare quanto segue: file disponibile al pubblico: gs://cloud-samples-data/generative-ai/image/scones.jpg con un tipo MIME image/jpeg. Per visualizzare questa immagine: apri l'immagine di esempio .

  • MIME_TYPE: Il tipo di supporto del file specificato in data o fileUri campi. I valori accettabili sono:

    Fai clic per espandere i tipi MIME

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • image/webp
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • TEXT: le istruzioni di testo da includere nel prompt. Ad esempio: What is shown in this image?

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
EOF

Quindi, esegui questo comando per inviare la richiesta REST: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi, esegui questo comando per inviare la richiesta REST: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.

Dati immagine Base64

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION: la regione in cui elaborare richiesta. Inserisci una regione supportata. Per l'elenco completo delle regioni supportate, vedi Località disponibili.

    Fai clic per espandere un elenco parziale delle regioni disponibili

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: il tuo ID progetto.
  • B64_BASE_IMAGE
     La codifica Base64 dell'immagine, del PDF o del video da includere in linea nel prompt. Se includi contenuti multimediali in linea, devi specificare anche i relativi tipo (mimeType) di dati.
  • MIME_TYPE: Il tipo di supporto del file specificato in data o fileUri campi. I valori accettabili sono:

    Fai clic per espandere i tipi MIME

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • image/webp
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
  • TEXT: le istruzioni di testo da includere nel prompt. Ad esempio: What is shown in this image?.

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "inlineData": {
          "data": "B64_BASE_IMAGE",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
EOF

Quindi, esegui questo comando per inviare la richiesta REST: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "inlineData": {
          "data": "B64_BASE_IMAGE",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT"
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi, esegui questo comando per inviare la richiesta REST: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.
Nota quanto segue nell'URL di questo esempio:
  • Utilizza il metodo generateContent per richiedere che la risposta venga restituita dopo essere stata completamente generata. Per ridurre la percezione della latenza per un pubblico umano, trasmetti la risposta in tempo reale generati utilizzando streamGenerateContent .
  • L'ID modello multimodale si trova alla fine dell'URL prima del metodo (ad esempio, gemini-1.5-flash o gemini-1.0-pro-vision). Questo esempio potrebbe supportare altri modelli di machine learning.

Console

Per inviare un prompt multimodale utilizzando la console Google Cloud, esegui la seguenti:

  1. Nella sezione Vertex AI della console Google Cloud, vai a la pagina Vertex AI Studio.

    Vai a Vertex AI Studio

  2. Fai clic su Apri in formato libero.

  3. (Facoltativo) Configura il modello e i parametri:

    • Modello: seleziona un modello.
    • Regione: seleziona la regione che vuoi utilizzare.

    • Temperatura: utilizza il cursore o la casella di testo per inserire un valore per la temperatura dell'acqua.

      La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura pari a 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione.

      Se il modello restituisce una risposta troppo generica, troppo breve o fornisce una risposta di riserva, prova ad aumentare la temperatura.

    • Limite di token di output: utilizza il cursore o la casella di testo per inserire un valore per il limite di output massimo.

      Numero massimo di token che possono essere generati nella risposta. Un token è di circa quattro caratteri. 100 token corrispondono a circa 60-80 parole.

      Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe diverse.

    • Aggiungi sequenza di interruzioni: facoltativo. Inserisci una sequenza di interruzioni, ovvero una serie di caratteri che include spazi. Se il modello rileva un una sequenza di interruzioni, la generazione della risposta si interrompe. La sequenza di fermate non è inclusa nella risposta e puoi aggiungere fino a cinque sequenze di fermate.

  4. (Facoltativo) Per configurare parametri avanzati, fai clic su Avanzato e configurala come segue:

    Fai clic per espandere le configurazioni avanzate

    • Top-K: utilizza il cursore o la casella di testo per inserire un valore per top-K. (non supportato per Gemini 1.5).

      Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K pari a 1 indica che il token successivo selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy). Un top-K pari a 3 indica invece che il token successivo viene selezionato tra i tre token più probabili utilizzando la temperatura.

      Per ogni fase di selezione dei token, vengono campionati i token Top-K con le probabilità più elevate. Quindi i token vengono ulteriormente filtrati in base a top-p con il token finale selezionato utilizzando il campionamento della temperatura.

      Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali.

    • Top-P: utilizza il dispositivo di scorrimento o la casella di testo per inserire un valore per il top-P. I token vengono selezionati dal più probabile al meno probabile finché la somma delle loro probabilità non corrisponde al valore di Top-P. Per ottenere risultati meno variabili, imposta top-P su 0.
    • Numero massimo di risposte: utilizza il dispositivo di scorrimento o la casella di testo per inserire un valore per il numero di risposte da generare.
    • Risposte dinamiche: attivale per stampare le risposte così come sono. generati.
    • Soglia filtro di sicurezza: seleziona la soglia della probabilità di sono le risposte che potrebbero essere dannose.
    • Abilita il grounding: il grounding non è supportato per i prompt multimodali.

  5. Fai clic su Inserisci media e seleziona un'origine per il file.

    Carica

    Seleziona il file che vuoi caricare e fai clic su Apri.

    Tramite URL

    Inserisci l'URL del file che vuoi utilizzare e fai clic su Inserisci.

    Cloud Storage

    Seleziona il bucket e poi il file del bucket che vuoi importare e fai clic su Seleziona.

    Google Drive

    1. Scegli un account e dai il consenso per Vertex AI Studio per accedere al tuo account il primo volta che selezioni questa opzione. Puoi caricare più file con una dimensione totale massima di 10 MB. Un singolo file non può superare 7 MB.
    2. Fai clic sul file che vuoi aggiungere.

    3. Fai clic su Seleziona.

      La miniatura del file viene visualizzata nel riquadro Prompt. Viene visualizzato anche il numero totale di token. Se i dati del prompt superano il limite di token, i token vengono troncati e non sono inclusi nell'elaborazione dei dati.

  6. Inserisci il prompt di testo nel riquadro Prompt.

  7. (Facoltativo) Per visualizzare ID token in testo e ID token, fai clic sul conteggio token nel riquadro Prompt.

  8. Fai clic su Invia.

  9. (Facoltativo) Per salvare il prompt in I miei prompt, fai clic su Salva.

  10. (Facoltativo) Per ottenere il codice Python o un comando curl per il prompt, fai clic su Ricevi codice.

Più immagini

Ognuna delle seguenti schede mostra un modo diverso per includere più immagini in una richiesta di prompt. Ogni sample riceve due insiemi di input:

  • Immagine di un famoso punto di riferimento cittadino
  • Il tipo di media dell'immagine
  • Testo che indica la città e il punto di riferimento nell'immagine

L'esempio accetta anche un terzo tipo di immagine e di elemento multimediale, ma non di testo. L'esempio restituisce una risposta di testo che indica la città e il punto di riferimento nella terza immagine.

Questi esempi di immagini funzionano con tutti i modelli multimodali Gemini.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vertex AI SDK for Python.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello deve generare risposte in streaming oppure risposte non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo la generazione di tutti i token di output.

Per una risposta in modalità flusso, utilizza il parametro stream in generate_content.

  response = model.generate_content(contents=[...], stream = True)

Per una risposta non in streaming, rimuovi il parametro o impostalo su False.

Codice di esempio

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update project_id and location
vertexai.init(project=PROJECT_ID, location="us-central1")

# Load images from Cloud Storage URI
image_file1 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
    mime_type="image/png",
)
image_file2 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
    mime_type="image/png",
)
image_file3 = Part.from_uri(
    "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
    mime_type="image/png",
)

model = GenerativeModel("gemini-1.5-flash-002")
response = model.generate_content(
    [
        image_file1,
        "city: Rome, Landmark: the Colosseum",
        image_file2,
        "city: Beijing, Landmark: Forbidden City",
        image_file3,
    ]
)
print(response.text)

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Java Vertex AI per Gemini.

Per eseguire l'autenticazione su Vertex AI, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello genera risposte in streaming o non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo la generazione di tutti i token di output.

Per una risposta dinamica, utilizza il metodo generateContentStream.

  public ResponseStream<GenerateContentResponse> generateContentStream(Content content)

Per una risposta non in streaming, utilizza il metodo generateContent.

  public GenerateContentResponse generateContent(Content content)

Codice di esempio

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.Content;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.PartMaker;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MultimodalMultiImage {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";

    multimodalMultiImage(projectId, location, modelName);
  }

  // Generates content from multiple input images.
  public static void multimodalMultiImage(String projectId, String location, String modelName)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      GenerativeModel model = new GenerativeModel(modelName, vertexAI);

      Content content = ContentMaker.fromMultiModalData(
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png")),
          "city: Rome, Landmark: the Colosseum",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png")),
          "city: Beijing, Landmark: Forbidden City",
          PartMaker.fromMimeTypeAndData("image/png", readImageFile(
              "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png"))
      );

      GenerateContentResponse response = model.generateContent(content);

      String output = ResponseHandler.getText(response);
      System.out.println(output);
    }
  }

  // Reads the image data from the given URL.
  public static byte[] readImageFile(String url) throws IOException {
    URL urlObj = new URL(url);
    HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
    connection.setRequestMethod("GET");

    int responseCode = connection.getResponseCode();

    if (responseCode == HttpURLConnection.HTTP_OK) {
      InputStream inputStream = connection.getInputStream();
      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

      byte[] buffer = new byte[1024];
      int bytesRead;
      while ((bytesRead = inputStream.read(buffer)) != -1) {
        outputStream.write(buffer, 0, bytesRead);
      }

      return outputStream.toByteArray();
    } else {
      throw new RuntimeException("Error fetching file: " + responseCode);
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida sull'IA generativa con l'SDK Node.js. Per maggiori informazioni, consulta la documentazione di riferimento dell'SDK Node.js per Gemini documentazione.

Per eseguire l'autenticazione su Vertex AI, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello genera risposte in streaming o non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo che sono stati generati tutti i token di output.

Per una risposta in modalità flusso, utilizza generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Per una risposta non in streaming, utilizza il metodo generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Codice di esempio

const {VertexAI} = require('@google-cloud/vertexai');
const axios = require('axios');

async function getBase64(url) {
  const image = await axios.get(url, {responseType: 'arraybuffer'});
  return Buffer.from(image.data).toString('base64');
}

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function sendMultiModalPromptWithImage(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-flash-001'
) {
  // For images, the SDK supports base64 strings
  const landmarkImage1 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png'
  );
  const landmarkImage2 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png'
  );
  const landmarkImage3 = await getBase64(
    'https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png'
  );

  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  const generativeVisionModel = vertexAI.getGenerativeModel({
    model: model,
  });

  // Pass multimodal prompt
  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            inlineData: {
              data: landmarkImage1,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Rome, Landmark: the Colosseum',
          },

          {
            inlineData: {
              data: landmarkImage2,
              mimeType: 'image/png',
            },
          },
          {
            text: 'city: Beijing, Landmark: Forbidden City',
          },
          {
            inlineData: {
              data: landmarkImage3,
              mimeType: 'image/png',
            },
          },
        ],
      },
    ],
  };

  // Create the response
  const response = await generativeVisionModel.generateContent(request);
  // Wait for the response to complete
  const aggregatedResponse = await response.response;
  // Select the text from the response
  const fullTextResponse =
    aggregatedResponse.candidates[0].content.parts[0].text;

  console.log(fullTextResponse);
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida introduttiva di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Go di Vertex AI per Gemini.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello genera risposte in streaming o non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo la generazione di tutti i token di output.

Per una risposta dinamica, utilizza il metodo GenerateContentStream.

  iter := model.GenerateContentStream(ctx, genai.Text("Tell me a story about a lumberjack and his giant ox. Keep it very short."))

Per una risposta non di streaming, utilizza il metodo GenerateContent.

  resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))

Codice di esempio

import (
	"context"
	"fmt"
	"io"
	"mime"
	"path/filepath"

	"cloud.google.com/go/vertexai/genai"
)

// generateMultimodalContent shows how to generate a text from a multimodal prompt using the Gemini model,
// writing the response to the provided io.Writer.
func generateMultimodalContent(w io.Writer, projectID, location, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.5-flash-001"
	ctx := context.Background()

	// create prompt image parts
	colosseum := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark1.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png",
	}
	forbiddenCity := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark2.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png",
	}
	newImage := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("landmark3.png")),
		FileURI:  "gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png",
	}
	// create a multimodal (multipart) prompt
	prompt := []genai.Part{
		colosseum,
		genai.Text("city: Rome, Landmark: the Colosseum "),
		forbiddenCity,
		genai.Text("city: Beijing, Landmark: the Forbidden City "),
		newImage,
	}

	// generate the response
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)

	res, err := model.GenerateContent(ctx, prompt...)
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento C# di Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, consulta la sezione Configurazione per un ambiente di sviluppo locale.

Risposte dinamiche e non dinamiche

Puoi scegliere se il modello genera risposte in streaming o non in streaming. Per le risposte dinamiche, ricevi ogni risposta non appena viene generato il token di output. Per le risposte non dinamiche, ricevi tutte le risposte dopo che sono stati generati tutti i token di output.

Per una risposta dinamica, utilizza il metodo StreamGenerateContent.

  public virtual PredictionServiceClient.StreamGenerateContentStream StreamGenerateContent(GenerateContentRequest request)

Per una risposta non in streaming, utilizza il metodo GenerateContentAsync.

  public virtual Task<GenerateContentResponse> GenerateContentAsync(GenerateContentRequest request)

Per ulteriori informazioni su come il server può trasmettere le risposte in streaming, consulta RPC per i flussi di dati.

Codice di esempio


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using Google.Protobuf;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class MultimodalMultiImage
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();

        ByteString colosseum = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark1.png");

        ByteString forbiddenCity = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark2.png");

        ByteString christRedeemer = await ReadImageFileAsync(
            "https://storage.googleapis.com/cloud-samples-data/vertex-ai/llm/prompts/landmark3.png");

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { InlineData = new() { MimeType = "image/png", Data = colosseum }},
                        new Part { Text = "city: Rome, Landmark: the Colosseum" },
                        new Part { InlineData = new() { MimeType = "image/png", Data = forbiddenCity }},
                        new Part { Text = "city: Beijing, Landmark: Forbidden City"},
                        new Part { InlineData = new() { MimeType = "image/png", Data = christRedeemer }}
                    }
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
        }
        return fullText.ToString();
    }

    private static async Task<ByteString> ReadImageFileAsync(string url)
    {
        using HttpClient client = new();
        using var response = await client.GetAsync(url);
        byte[] imageBytes = await response.Content.ReadAsByteArrayAsync();
        return ByteString.CopyFrom(imageBytes);
    }
}

REST

Dopo aver configurato l'ambiente, puoi utilizzare REST per testare un prompt di testo. Il seguente esempio invia una richiesta al publisher endpoint del modello.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • LOCATION: la regione in cui elaborare richiesta. Inserisci una regione supportata. Per l'elenco completo delle regioni supportate, consulta Località disponibili.

    Fai clic per espandere un elenco parziale delle regioni disponibili

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: il tuo ID progetto.
  • FILE_URI1: L'URI o l'URL del file da includere nel prompt. I valori accettabili sono:
    • URI del bucket Cloud Storage: l'oggetto deve essere leggibile pubblicamente o trovarsi nello stesso progetto Google Cloud che invia la richiesta.
    • URL HTTP: l'URL del file deve essere leggibile pubblicamente. Puoi specificare un file video e fino a 10 file immagine per richiesta. I file audio e i documenti non possono superare i 15 MB.
    • URL del video di YouTube: il video di YouTube deve essere di proprietà dell'account che hai utilizzato per accedere alla console Google Cloud o essere pubblico. È supportato un solo URL di video di YouTube per richiesta.

    Quando specifichi un valore fileURI, devi specificare anche il tipo di elemento multimediale (mimeType) del file.

    Se non hai un file immagine in Cloud Storage, puoi utilizzare il seguente file disponibile pubblicamente: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark1.png con un tipo MIME di image/png. Per visualizzare questa immagine, apri il file dell'immagine di esempio.

  • MIME_TYPE: il tipo di media del file specificato nei campi data o fileUri. I valori accettabili sono:

    Fai clic per espandere i tipi MIME

    • application/pdf
    • audio/mpeg
    • audio/mp3
    • audio/wav
    • image/png
    • image/jpeg
    • image/webp
    • text/plain
    • video/mov
    • video/mpeg
    • video/mp4
    • video/mpg
    • video/avi
    • video/wmv
    • video/mpegps
    • video/flv
     Per semplicità, questo esempio utilizza lo stesso tipo di media per tutte e tre le immagini di input.
  • TEXT1: Le istruzioni testuali da includere nel prompt. Ad esempio: city: Rome, Landmark: the Colosseum
  • FILE_URI2: l'URI o l'URL del file da includere nel prompt. I valori accettabili sono:
    • URI del bucket Cloud Storage: l'oggetto deve essere leggibile pubblicamente o trovarsi nello stesso progetto Google Cloud che invia la richiesta.
    • URL HTTP: l'URL del file deve essere leggibile pubblicamente. Puoi specificare un file video e fino a 10 file immagine per richiesta. I file audio e i documenti non possono superare i 15 MB.
    • URL del video di YouTube: il video di YouTube deve essere di proprietà dell'account che hai utilizzato per accedere alla console Google Cloud o essere pubblico. È supportato un solo URL di video di YouTube per richiesta.

    Quando specifichi un valore fileURI, devi specificare anche il tipo di elemento multimediale (mimeType) del file.

    Se non hai un file immagine in Cloud Storage, puoi usare quanto segue: file disponibile al pubblico: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark2.png con un tipo MIME image/png. Per visualizzare questa immagine: apri l'immagine di esempio .

  • TEXT2: le istruzioni di testo da includere nel prompt. Ad esempio: city: Beijing, Landmark: Forbidden City
  • FILE_URI3: l'URI o l'URL del file da includere nel prompt. I valori accettati sono:
    • URI del bucket Cloud Storage: l'oggetto deve essere leggibile pubblicamente o trovarsi nello stesso progetto Google Cloud che invia la richiesta.
    • URL HTTP: l'URL del file deve essere leggibile pubblicamente. Puoi specificare un file video e fino a 10 file immagine per richiesta. I file audio e i documenti non possono superare i 15 MB.
    • URL del video di YouTube: il video di YouTube deve essere di proprietà dell'account che hai utilizzato per accedere alla console Google Cloud o essere pubblico. È supportato un solo URL di video di YouTube per richiesta.

    Quando specifichi un valore fileURI, devi specificare anche il tipo di elemento multimediale (mimeType) del file.

    Se non hai un file immagine in Cloud Storage, puoi utilizzare il seguente file disponibile pubblicamente: gs://cloud-samples-data/vertex-ai/llm/prompts/landmark3.png con un tipo MIME di image/png. Per visualizzare questa immagine, apri il file dell'immagine di esempio.

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

cat > request.json << 'EOF'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI1",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT1"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI2",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT2"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI3",
          "mimeType": "MIME_TYPE"
        }
      }
    ]
  }
}
EOF

Quindi, esegui questo comando per inviare la richiesta REST: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

@'
{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "fileData": {
          "fileUri": "FILE_URI1",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT1"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI2",
          "mimeType": "MIME_TYPE"
        }
      },
      {
        "text": "TEXT2"
      },
      {
        "fileData": {
          "fileUri": "FILE_URI3",
          "mimeType": "MIME_TYPE"
        }
      }
    ]
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi, esegui questo comando per inviare la richiesta REST: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/gemini-1.5-flash:generateContent" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.

Tieni presente quanto segue nell'URL di questo esempio:
  • Utilizza il metodo generateContent per richiedere che la risposta venga restituita dopo essere stata completamente generata. Per ridurre la percezione della latenza per un pubblico di persone, riproduci in streaming la risposta man mano che viene generata utilizzando il metodo streamGenerateContent.
  • L'ID del modello multimodale si trova alla fine dell'URL prima del metodo (ad esempio gemini-1.5-flash o gemini-1.0-pro-vision). Questo sample potrebbe supportare anche altri modelli.

Console

Per inviare un prompt multimodale utilizzando la console Google Cloud, esegui la seguenti:

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Vertex AI Studio.

    Vai a Vertex AI Studio

  2. Fai clic su Apri formato libero.

  3. (Facoltativo) Configura il modello e i parametri:

    • Modello: seleziona un modello.
    • Regione: seleziona la regione che vuoi utilizzare.

    • Temperatura: utilizza il cursore o la casella di testo per inserire un valore per la temperatura dell'acqua.

      La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura pari a 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione.

      Se il modello restituisce una risposta troppo generica, troppo breve o fornisce una risposta di riserva, prova ad aumentare la temperatura.

    • Limite di token di output: utilizza il cursore o la casella di testo per inserire un valore per il limite di output massimo.

      Numero massimo di token che possono essere generati nella risposta. Un token è di circa quattro caratteri. 100 token corrispondono a circa 60-80 parole.

      Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe diverse.

    • Aggiungi sequenza di interruzioni: facoltativo. Inserisci una sequenza di interruzioni, ovvero una serie di caratteri che include spazi. Se il modello rileva un una sequenza di interruzioni, la generazione della risposta si interrompe. La sequenza di fermate non è inclusa nella risposta e puoi aggiungere fino a cinque sequenze di fermate.

  4. (Facoltativo) Per configurare parametri avanzati, fai clic su Avanzato e configurala come segue:

    Fai clic per espandere le configurazioni avanzate

    • Top-K: utilizza il cursore o la casella di testo per inserire un valore per top-K. (non supportato per Gemini 1.5).

      Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K pari a 1 indica che il token successivo selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy). Un top-K pari a 3 indica invece che il token successivo viene selezionato tra i tre token più probabili utilizzando la temperatura.

      Per ogni fase di selezione dei token, vengono campionati i token Top-K con le probabilità più elevate. Quindi i token vengono ulteriormente filtrati in base a top-p con il token finale selezionato utilizzando il campionamento della temperatura.

      Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali.

    • Top-P: utilizza il dispositivo di scorrimento o la casella di testo per inserire un valore per il top-P. I token vengono selezionati dal più probabile al meno probabile finché la somma delle loro probabilità non corrisponde al valore di Top-P. Per ottenere risultati meno variabili, imposta top-P su 0.
    • Numero massimo di risposte: utilizza il dispositivo di scorrimento o la casella di testo per inserire un valore per il numero di risposte da generare.
    • Risposte dinamiche: attivale per stampare le risposte così come sono. generati.
    • Soglia filtro di sicurezza: seleziona la soglia della probabilità di sono le risposte che potrebbero essere dannose.
    • Abilita il grounding: il grounding non è supportato per i prompt multimodali.

  5. Fai clic su Inserisci media e seleziona un'origine per il file.

    Carica

    Seleziona il file che vuoi caricare e fai clic su Apri.

    Tramite URL

    Inserisci l'URL del file che vuoi utilizzare e fai clic su Inserisci.

    Cloud Storage

    Seleziona il bucket e poi il file del bucket che vuoi importare e fai clic su Seleziona.

    Google Drive

    1. Scegli un account e dai il consenso per Vertex AI Studio per accedere al tuo account il primo volta che selezioni questa opzione. Puoi caricare più file con una dimensione totale massima di 10 MB. Un singolo file non può superare 7 MB.
    2. Fai clic sul file che vuoi aggiungere.

    3. Fai clic su Seleziona.

      La miniatura del file viene visualizzata nel riquadro Prompt. Il totale di token. Se i dati del prompt superano limite di token, vengono troncati e non sono inclusi nell'elaborazione dei dati.

  6. Inserisci il prompt di testo nel riquadro Prompt.

  7. (Facoltativo) Per visualizzare ID token in testo e ID token, fai clic sul conteggio token nel riquadro Prompt.

  8. Fai clic su Invia.

  9. (Facoltativo) Per salvare il prompt in I miei prompt, fai clic su Salva.

  10. (Facoltativo) Per ottenere il codice Python o un comando curl per il tuo prompt, fai clic su Genera codice.

Imposta i parametri del modello

I seguenti parametri del modello possono essere impostati sui modelli multimodali:

Top-P

Top-P cambia il modo in cui il modello seleziona i token per l'output. Token selezionati dal più probabile (vedi top-K) al meno probabile fino alla somma delle probabilità equivale al valore di top-p. Ad esempio, se i token A, B e C hanno una probabilità di 0,3, 0,2 e 0,1 e il valore di top-P è 0.5, il modello seleziona A o B come token successivo utilizzando la temperatura ed esclude C come candidato.

Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.

Top-K

Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K di 1 significa che il successivo token selezionato è il più probabile tra tutti nel vocabolario del modello (chiamato anche decodifica greedy), mentre una top-K di 3 significa che il token successivo viene selezionato tra i tre probabili token utilizzando la temperatura.

Per ogni fase di selezione dei token, vengono campionati i token Top-K con le probabilità più elevate. Quindi i token vengono ulteriormente filtrati in base a top-p con il token finale selezionato utilizzando il campionamento della temperatura.

Specifica un valore più basso per risposte meno casuali e un valore più alto per più risposte risposte casuali.

Temperatura

La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando vengono applicati topP e topK. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature basse sono ideali per prompt che richiedono risposte meno aperte o creative, mentre le temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura di 0 significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione.

Se il modello restituisce una risposta troppo generica, troppo breve, oppure fornisce una risposta di riserva di risposta, prova ad aumentare la temperatura.

Valori parametro validi

Parametro Gemini 1.0 Pro Vision Gemini 1.5 Pro Gemini 1.5 Flash
Top-K 1 - 40 (valore predefinito 32) Non supportata Non supportata
Top-P 0 - 1,0 (valore predefinito 1,0) 0 - 1,0 (valore predefinito 0,95) 0 - 1,0 (valore predefinito 0,95)
Temperatura 0 - 1,0 (valore predefinito 0,4) 0 - 2,0 (valore predefinito 1,0) 0 - 2,0 (valore predefinito 1,0)

Requisiti delle immagini

I modelli multimodali Gemini supportano i seguenti tipi MIME delle immagini:

Tipo MIME immagine Gemini 1.5 Flash Gemini 1.5 Pro Gemini 1.0 Pro Vision
PNG - image/png
JPEG - image/jpeg
WebP - image/webp

Non esiste un limite specifico al numero di pixel in un'immagine. Tuttavia, le immagini più grandi vengono ridimensionate e riempite per adattarsi a una risoluzione massima di 3072 x 3072 mantenendo le proporzioni originali.

Ecco il numero massimo di file immagine consentiti in una richiesta di prompt:

  • Gemini 1.0 Pro Vision: 16 immagini
  • Gemini 1.5 Flash e Gemini 1.5 Pro: 3000 immagini

Ecco come vengono calcolati i token per le immagini:

  • Gemini 1.0 Pro Vision: ogni immagine rappresenta per 258 token.
  • Gemini 1.5 Flash e Gemini 1.5 Pro:
    • Se entrambe le dimensioni di un'immagine sono inferiori o uguali a 384 pixel, vengono utilizzati 258 token.
    • Se una dimensione di un'immagine è superiore a 384 pixel, l'immagine viene ritagliata in riquadri. Per impostazione predefinita, ogni dimensione del riquadro è la più piccola (larghezza o altezza) diviso per 1,5. Se necessario, ogni riquadro viene modificato in modo che non sia più piccolo di 256 pixel e non più grande di 768 pixel. Ogni riquadro viene quindi ridimensionato a 768 x 768 e utilizza 258 token.

Best practice

Quando utilizzi le immagini, segui queste best practice e informazioni per ottenere risultati ottimali:

  • Se vuoi rilevare il testo in un'immagine, utilizza i prompt con una singola immagine per producono risultati migliori rispetto ai prompt con più immagini.
  • Se il prompt contiene una singola immagine, posiziona l'immagine prima del testo nella tua richiesta.
  • Se il prompt contiene più immagini e vuoi fare riferimento a queste più avanti nel prompt o fare in modo che il modello vi faccia riferimento nella risposta del modello, può essere utile assegnare a ciascuna immagine un indice prima. Utilizza a b c o image 1 image 2 image 3 per l'indice. Di seguito è riportato un esempio di utilizzo di immagini indicizzate in un : 
    image 1 
image 2 
image 3 

Write a blogpost about my day using image 1 and image 2. Then, give me ideas
for tomorrow based on image 3.
  • Utilizzare immagini con risoluzione più alta. otteniamo risultati migliori.
  • Includi alcuni esempi nel prompt.
  • Ruota le immagini per orientarle correttamente prima di aggiungerle alla richiesta.
  • Evita immagini sfocate.

Limitazioni

Sebbene i modelli multimodali Gemini siano potenti in molti utilizzi multimodali, in questi casi, è importante comprendere i limiti dei modelli:

  • Moderazione dei contenuti: i modelli si rifiutano di fornire risposte. sulle immagini che violano le nostre norme sulla sicurezza.
  • Ragionamento spaziale: i modelli non sono precisi nel localizzare testo o oggetti nelle immagini. Potrebbero restituire solo i conteggi approssimativi degli oggetti.
  • Usi medici: i modelli non sono adatti per interpretare immagini mediche (ad esempio radiografie e tomografie) o per fornire consulenza medica.
  • Riconoscimento di persone: i modelli non sono pensati per essere utilizzati per identificare persone che non sono celebrità nelle immagini.
  • Accuratezza: i modelli potrebbero avere allucinazioni o commettere errori. quando si interpretano immagini di bassa qualità, ruotate o con risoluzione estremamente bassa. I modelli potrebbero anche avere allucinazioni quando interpretano il testo scritto a mano in di immagine.

Passaggi successivi