Utilizza le istruzioni di sistema

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 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 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

# TODO(developer): Update and un-comment below line
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(
    model_name="gemini-1.5-flash-002",
    system_instruction=[
        "You are a helpful language translator.",
        "Your mission is to translate text in English to French.",
    ],
)

prompt = """
User input: I like bagels.
Answer:
"""
response = model.generate_content([prompt])
print(response.text)
# Example response:
# J'aime les bagels.

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 ulteriori informazioni, consulta la documentazione di riferimento dell'SDK Node.js per Gemini.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare l'ADC 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.

  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 set_system_instruction(projectId = 'PROJECT_ID') {
  const vertexAI = new VertexAI({project: projectId, location: 'us-central1'});

  const generativeModel = vertexAI.getGenerativeModel({
    model: 'gemini-1.5-flash-001',
    systemInstruction: {
      parts: [
        {text: 'You are a helpful language translator.'},
        {text: 'Your mission is to translate text in English to French.'},
      ],
    },
  });

  const textPart = {
    text: `
    User input: I like bagels.
    Answer:`,
  };

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

  const resp = await generativeModel.generateContent(request);
  const contentResponse = await resp.response;
  console.log(JSON.stringify(contentResponse));
}

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 autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare l'ADC 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.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ContentMaker;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;

public class WithSystemInstruction {

  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 output = translateToFrench(projectId, location, modelName);
    System.out.println(output);
  }

  // Ask the model to translate from English to French with a system instruction.
  public static String translateToFrench(String projectId, String location, String modelName)
      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;

      GenerativeModel model = new GenerativeModel(modelName, vertexAI)
          .withSystemInstruction(ContentMaker.fromString("You are a helpful assistant.\n"
            + "Your mission is to translate text in English to French."));

      GenerateContentResponse response = model.generateContent("User input: I like bagels.\n"
          + "Answer:");
      output = ResponseHandler.getText(response);
      return output;
    }
  }
}

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 a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare l'ADC 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 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"
	"errors"
	"fmt"
	"io"

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

// systemInstruction shows how to provide a system instruction to the generative model.
func systemInstruction(w io.Writer, projectID, location, 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("unable to create client: %w", err)
	}
	defer client.Close()

	// The System Instruction is set at model creation
	model := client.GenerativeModel(modelName)
	model.SystemInstruction = &genai.Content{
		Parts: []genai.Part{genai.Text(`
			You are a helpful language translator.
			Your mission is to translate text in English to French.
		`)},
	}

	res, err := model.GenerateContent(ctx, genai.Text(`
		User input: I like bagels.
		Answer:
	`))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}
	if len(res.Candidates) == 0 ||
		len(res.Candidates[0].Content.Parts) == 0 {
		return errors.New("empty response from model")
	}
	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 autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare l'ADC 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 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.Cloud.AIPlatform.V1;
using System;
using System.Threading.Tasks;

public class SystemInstruction
{
    public async Task<string> SetSystemInstruction(
        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();

        string prompt = @"User input: I like bagels.
Answer:";

        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = prompt },
                    }
                }
            },
            SystemInstruction = new()
            {
                Parts =
                {
                    new Part { Text = "You are a helpful assistant." },
                    new Part { Text = "Your mission is to translate text in English to French." },
                }
            }
        };

        GenerateContentResponse response = await predictionServiceClient.GenerateContentAsync(generateContentRequest);

        string responseText = response.Candidates[0].Content.Parts[0].Text;
        Console.WriteLine(responseText);

        return responseText;
    }
}

REST

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

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

• GENERATE_RESPONSE_METHOD: il tipo di risposta che vuoi che il modello generi. Scegli un metodo che generi la modalità di restituzione della risposta del modello:
  • streamGenerateContent: la risposta viene trasmessa in streaming durante la generazione per ridurre la percezione della latenza da parte di un pubblico di persone.
  • generateContent: la risposta viene restituita dopo essere stata completamente generata.
• LOCATION: la regione in cui elaborare la richiesta. Le opzioni disponibili includono:

  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.
• MODEL_ID: l'ID del modello multimodale che vuoi utilizzare. Ecco alcune opzioni:
  • gemini-1.0-pro-002
  • gemini-1.0-pro-vision-001
  • gemini-1.5-pro-002
  • gemini-1.5-flash
• ROLE: Il ruolo in una conversazione associato ai contenuti. La specifica di un ruolo è obbligatoria anche nei casi d'uso con un solo turno. I valori accettati sono:
  • USER: specifica i contenuti inviati da te.
  • MODEL: specifica la risposta del modello.
• TEXT

  Le istruzioni di testo da includere nel prompt. Ad esempio, User input: I like bagels.
• SAFETY_CATEGORY: la categoria di sicurezza per la quale configurare una soglia. I valori accettati sono:

  Fai clic per espandere le categorie di sicurezza

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT
• THRESHOLD: la soglia per bloccare le risposte che potrebbero appartenere alla categoria di sicurezza specificata in base alla probabilità. I valori accettati sono:

  Fai clic per espandere le soglie di blocco

  • BLOCK_NONE
  • BLOCK_ONLY_HIGH
  • BLOCK_MEDIUM_AND_ABOVE (valore predefinito)
  • BLOCK_LOW_AND_ABOVE
  BLOCK_LOW_AND_ABOVE blocca di più, mentre BLOCK_ONLY_HIGH blocca di meno.
• SYSTEM_INSTRUCTION

  (Facoltativo) Non disponibile per tutti i modelli. Istruzioni per il modello per indirizzarlo verso un rendimento migliore. JSON non supporta gli a capo. Sostituisci tutti i ritorni a capo in questo campo con \n. Ad esempio, You are a helpful language translator.\nYour mission is to translate text in English to French.
• TEMPERATURE: 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 più 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. Con una temperatura pari a 0 viene sempre selezionato il token con la probabilità più alta. In questo caso, le risposte per un determinato prompt sono per lo più deterministiche, ma è comunque 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.

• TOP_P: Top-P cambia il modo in cui il modello seleziona i token per l'output. I token vengono selezionati dal più probabile (vedi Top-K) al meno probabile finché la somma delle loro probabilità non corrisponde 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 risposte più casuali.

• TOP_K: 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 e il token finale viene selezionato utilizzando il campionamento con temperatura.

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

• MAX_OUTPUT_TOKENS: numero massimo di token che possono essere generati nella risposta. Un token equivale a 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.

• STOP_SEQUENCES: specifica un elenco di stringhe che indica al modello di interrompere la generazione di testo se viene rilevata una delle stringhe nella risposta. Se una stringa viene visualizzata più volte nella risposta, la risposta viene troncata nel punto in cui viene rilevata per la prima volta. Le stringhe sono sensibili alle maiuscole.
  
  Ad esempio, se la seguente è la risposta restituita quando stopSequences non è specificato:
  
  public static string reverse(string myString)
  
  La risposta restituita con stopSequences impostato su ["Str", "reverse"] è:
  
  public static string
  
  Specifica un array vuoto ([]) per disattivare le sequenze di arresto.

Per inviare la richiesta, scegli una delle seguenti opzioni:

cat > request.json << 'EOF'
{
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
  "system_instruction":
  {
    "parts": [
      {
        "text": "SYSTEM_INSTRUCTION"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES
  }
}
EOF

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/MODEL_ID:GENERATE_RESPONSE_METHOD"

@'
{
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
  "system_instruction":
  {
    "parts": [
      {
        "text": "SYSTEM_INSTRUCTION"
      }
    ]
  },
  "safety_settings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "stopSequences": STOP_SEQUENCES
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$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/MODEL_ID:GENERATE_RESPONSE_METHOD" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": "J'aime les bagels. \n"
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.1481704,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07921032
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.07185127,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.10302442
        },
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.11920293,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.07626997
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "probabilityScore": 0.20212802,
          "severity": "HARM_SEVERITY_NEGLIGIBLE",
          "severityScore": 0.13386749
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 25,
    "candidatesTokenCount": 8,
    "totalTokenCount": 33
  }
}

• Utilizza il metodo generateContent per richiedere che la risposta venga restituita dopo essere stata completamente generata. Per ridurre la percezione della latenza da parte di 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.