Chat-Prompt-Anfragen (Gemini) senden

Auf dieser Seite erfahren Sie, wie Sie mithilfe der Google Cloud Console, der REST API und unterstützter SDKs Chat-Prompts an das Gemini 1.0 Pro-Modell (gemini-1.0-pro) senden. Gemini 1.0 Pro unterstützt Prompts mit reiner Texteingabe, einschließlich Aufgaben in natürlicher Sprache, Text- und Code-Chat in mehreren Schritten und Codegenerierung. Es kann Text und Code ausgeben.

Das Gemini 1.0 Pro-Foundation-Model ist ein großes Sprachmodell, mit dem sich Sprache verstehen und generieren lässt. Sie können über eine Prompt- und Antwortfunktion in einem Schritt mit Gemini Pro interagieren oder damit in mehreren Unterhaltungsrunden chatten, selbst wenn es um das Verständnis und die Generierung von Code geht.

Eine Liste der von Gemini 1.0 Pro unterstützten Sprachen finden Sie unter Modellinformationen unter Sprachunterstützung.

Wählen Sie für weitere Informationen zu diesem Modell in der Console die gemini-1.0-pro-Modellkarte in Model Garden aus.

Zum Model Garden

Wenn Sie Gemini direkt über Ihre mobilen Apps und Webanwendungen verwenden möchten, sehen Sie sich die Google KI-SDKs für Android, Swift und das Web an.

Chat-Prompts senden

Zum Testen und Iterieren von Chat-Prompts empfehlen wir die Verwendung der Google Cloud Console. Um Prompts programmatisch an das Modell zu senden, können Sie die REST API, das Vertex AI SDK für Python oder eine der anderen unterstützten Bibliotheken und SDKs verwenden, die auf den folgenden Tabs angezeigt werden.

Python

Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der API-Referenzdokumentation zur Vertex AI SDK for Python.

Streaming- und Nicht-Streaming-Antworten

Sie können auswählen, ob das Modell eine Streamingantwort oder eine Nicht-Streamingantwort generiert. Das Streaming umfasst Antworten auf Prompts, sobald diese generiert werden. Das heißt, sobald das Modell Ausgabetokens generiert, werden diese gesendet. Eine Nicht-Streamingantwort auf Prompts wird erst gesendet, wenn alle Ausgabetokens generiert wurden.

Verwenden Sie für eine Streamingantwort den Parameter stream in generate_content.

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

Entfernen Sie für eine Nicht-Streamingantwort den Parameter oder setzen Sie den Parameter auf False.

Beispielcode

import vertexai

from vertexai.generative_models import GenerativeModel, ChatSession

# TODO(developer): Update and un-comment below lines
# project_id = "PROJECT_ID"
# location = "us-central1"
vertexai.init(project=project_id, location=location)
model = GenerativeModel(model_name="gemini-1.0-pro-002")
chat = model.start_chat()

def get_chat_response(chat: ChatSession, prompt: str) -> str:
    text_response = []
    responses = chat.send_message(prompt, stream=True)
    for chunk in responses:
        text_response.append(chunk.text)
    return "".join(text_response)

prompt = "Hello."
print(get_chat_response(chat, prompt))

prompt = "What are all the colors in a rainbow?"
print(get_chat_response(chat, prompt))

prompt = "Why does it appear when it rains?"
print(get_chat_response(chat, prompt))

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den C#-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI C# API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


using Google.Cloud.AIPlatform.V1;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class MultiTurnChatSample
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.0-pro"
    )
    {
        // Create a chat session to keep track of the context
        ChatSession chatSession = new ChatSession($"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}", location);

        string prompt = "Hello.";
        Console.WriteLine($"\nUser: {prompt}");

        string response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "What are all the colors in a rainbow?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        prompt = "Why does it appear when it rains?";
        Console.WriteLine($"\nUser: {prompt}");

        response = await chatSession.SendMessageAsync(prompt);
        Console.WriteLine($"Response: {response}");

        return response;
    }

    private class ChatSession
    {
        private readonly string _modelPath;
        private readonly PredictionServiceClient _predictionServiceClient;

        private readonly List<Content> _contents;

        public ChatSession(string modelPath, string location)
        {
            _modelPath = modelPath;

            // Create a prediction service client.
            _predictionServiceClient = new PredictionServiceClientBuilder
            {
                Endpoint = $"{location}-aiplatform.googleapis.com"
            }.Build();

            // Initialize contents to send over in every request.
            _contents = new List<Content>();
        }

        public async Task<string> SendMessageAsync(string prompt)
        {
            // Initialize the content with the prompt.
            var content = new Content
            {
                Role = "USER"
            };
            content.Parts.AddRange(new List<Part>()
            {
                new() {
                    Text = prompt
                }
            });
            _contents.Add(content);

            // Create a request to generate content.
            var generateContentRequest = new GenerateContentRequest
            {
                Model = _modelPath,
                GenerationConfig = new GenerationConfig
                {
                    Temperature = 0.9f,
                    TopP = 1,
                    TopK = 32,
                    CandidateCount = 1,
                    MaxOutputTokens = 2048
                }
            };
            generateContentRequest.Contents.AddRange(_contents);

            // Make a non-streaming request, get a response.
            GenerateContentResponse response = await _predictionServiceClient.GenerateContentAsync(generateContentRequest);

            // Save the content from the response.
            _contents.Add(response.Candidates[0].Content);

            // Return the text
            return response.Candidates[0].Content.Parts[0].Text;
        }
    }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der Kurzanleitung zur generativen KI mit dem Node.js SDK. Weitere Informationen finden Sie in der Referenzdokumentation zum Node.js SDK für Gemini.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Streaming- und Nicht-Streaming-Antworten

Sie können auswählen, ob das Modell eine Streamingantwort oder eine Nicht-Streamingantwort generiert. Das Streaming umfasst Antworten auf Prompts, sobald diese generiert werden. Das heißt, sobald das Modell Ausgabetokens generiert, werden diese gesendet. Eine Nicht-Streamingantwort auf Prompts wird erst gesendet, wenn alle Ausgabetokens generiert wurden.

Verwenden Sie für eine Nicht-Streamingantwort die Methode generateContentStream.

  const streamingResp = await generativeModel.generateContentStream(request);

Verwenden Sie für eine Nicht-Streamingantwort die Methode generateContent.

  const streamingResp = await generativeModel.generateContent(request);

Beispielcode

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function createStreamChat(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

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

  const chat = generativeModel.startChat({});
  const chatInput1 = 'How can I learn more about that?';

  console.log(`User: ${chatInput1}`);

  const result1 = await chat.sendMessageStream(chatInput1);
  for await (const item of result1.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der Vertex AI-Kurzanleitung. Weitere Informationen finden Sie in der Referenzdokumentation zum Vertex AI Java SDK für Gemini.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Streaming- und Nicht-Streaming-Antworten

Sie können auswählen, ob das Modell eine Streamingantwort oder eine Nicht-Streamingantwort generiert. Das Streaming umfasst Antworten auf Prompts, sobald diese generiert werden. Das heißt, sobald das Modell Ausgabetokens generiert, werden diese gesendet. Eine Nicht-Streamingantwort auf Prompts wird erst gesendet, wenn alle Ausgabetokens generiert wurden.

Verwenden Sie für eine Nicht-Streamingantwort die Methode generateContentStream.

  public ResponseStream generateContentStream(Content content)

Verwenden Sie für eine Nicht-Streamingantwort die Methode generateContent.

  public GenerateContentResponse generateContent(Content content)

Beispielcode

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.generativeai.ChatSession;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.google.cloud.vertexai.generativeai.ResponseHandler;
import java.io.IOException;

public class ChatDiscussion {

  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.0-pro";

    chatDiscussion(projectId, location, modelName);
  }

  // Ask interrelated questions in a row using a ChatSession object.
  public static void chatDiscussion(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)) {
      GenerateContentResponse response;

      GenerativeModel model = new GenerativeModel(modelName, vertexAI);
      // Create a chat session to be used for interactive conversation.
      ChatSession chatSession = new ChatSession(model);

      response = chatSession.sendMessage("Hello.");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("What are all the colors in a rainbow?");
      System.out.println(ResponseHandler.getText(response));

      response = chatSession.sendMessage("Why does it appear when it rains?");
      System.out.println(ResponseHandler.getText(response));
      System.out.println("Chat Ended.");
    }
  }
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der Vertex AI-Kurzanleitung. Weitere Informationen finden Sie in der Referenzdokumentation zu Vertex AI Go SDK für Gemini.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Streaming- und Nicht-Streaming-Antworten

Sie können auswählen, ob das Modell eine gestreamte oder eine nicht gestreamte Antwort generiert. Das Streaming umfasst Antworten auf Prompts, sobald diese generiert werden. Das heißt, sobald das Modell Ausgabetokens generiert, werden diese gesendet. Eine Nicht-Streamingantwort auf Prompts wird erst gesendet, wenn alle Ausgabetokens generiert wurden.

Verwenden Sie für eine Nicht-Streamingantwort die Methode GenerateContentStream.

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

Verwenden Sie für eine Nicht-Streamingantwort die Methode GenerateContent.

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

Beispielcode

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

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

func makeChatRequests(w io.Writer, projectID string, location string, modelName string) error {
	// location := "us-central1"
	// modelName := "gemini-1.0-pro-002"
	ctx := context.Background()
	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("error creating client: %w", err)
	}
	defer client.Close()

	gemini := client.GenerativeModel(modelName)
	chat := gemini.StartChat()

	r, err := chat.SendMessage(
		ctx,
		genai.Text("Hello"))
	if err != nil {
		return err
	}
	rb, err := json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	r, err = chat.SendMessage(
		ctx,
		genai.Text("What are all the colors in a rainbow?"))
	if err != nil {
		return err
	}
	rb, err = json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	r, err = chat.SendMessage(
		ctx,
		genai.Text("Why does it appear when it rains?"))
	if err != nil {
		return fmt.Errorf("chat.SendMessage: %w", err)
	}
	rb, err = json.MarshalIndent(r, "", "  ")
	if err != nil {
		return fmt.Errorf("json.MarshalIndent: %w", err)
	}
	fmt.Fprintln(w, string(rb))

	return nil
}

REST

Sie können mit REST einen Chat-Prompt senden. Dazu senden Sie mit der Vertex AI API eine POST-Anfrage an den Endpunkt des Publisher-Modells.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • GENERATE_RESPONSE_METHOD: Der Antworttyp, den das Modell generieren soll. Wählen Sie eine Methode aus, mit der generiert wird, wie die Antwort des Modells zurückgegeben werden soll:
    • streamGenerateContent: Die Antwort wird gestreamt, während sie generiert wird, um die Wahrnehmung von Latenz für menschliche Zielgruppen zu reduzieren.
    • generateContent: Die Antwort wird zurückgegeben, nachdem sie vollständig generiert wurde.
  • LOCATION: Die Region, in der die Anfrage verarbeitet werden soll. Folgende Optionen sind verfügbar:

    Klicken, um verfügbare Regionen zu maximieren

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: Ihre Projekt-ID.
  • MODEL_ID: Die Modell-ID des multimodalen Modells, das Sie verwenden möchten. Folgende Optionen sind verfügbar:
    • gemini-1.0-pro-002
    • gemini-1.0-pro-vision-001
    • gemini-1.5-pro-preview-0409
  • ROLE: Die Rolle in einer Unterhaltung, die mit dem Inhalt verknüpft ist. Die Angabe einer Rolle ist auch bei Anwendungsfällen mit nur einem Schritt erforderlich. Unter anderem sind folgende Werte zulässig:
    • USER: Gibt Inhalte an, die von Ihnen gesendet werden
    • MODEL: Gibt die Antwort des Modells an.
  • TEXT: Die Textanleitung, die in den Prompt eingefügt werden soll.
  • SAFETY_CATEGORY: Die Sicherheitskategorie, für die ein Schwellenwert konfiguriert wird. Unter anderem sind folgende Werte zulässig:

    Zum Maximieren von Sicherheitskategorien klicken

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: Der Schwellenwert für das Blockieren von Antworten, die basierend auf der Wahrscheinlichkeit zur angegebenen Sicherheitskategorie gehören könnten. Unter anderem sind folgende Werte zulässig:

    Zum Maximieren der Grenzwerte für die Blockierung klicken

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (Standard)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE blockiert am meisten, während BLOCK_ONLY_HIGH am wenigsten blockiert.
  • SYSTEM_INSTRUCTION: (Optional) Verfügbar für gemini-1.0-pro-002 und gemini-1.5-pro-preview-0409. Anleitung für das Modell, um es zu einer besseren Leistung zu steuern. Beispiel: „Antworten Sie so kurz wie möglich“ oder „Ergebnisse im JSON-Format drucken“.
  • TEMPERATURE: Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. Dies passiert, wenn topP und topK angewendet werden. Die Temperatur bestimmt den Grad der Zufälligkeit bei der Tokenauswahl. Niedrigere Temperaturen eignen sich gut für Prompts, die eine weniger offene oder kreative Antwort erfordern, während höhere Temperaturen zu vielfältigeren oder kreativeren Ergebnissen führen können. Eine Temperatur von 0 bedeutet, dass immer die Tokens mit der höchsten Wahrscheinlichkeit ausgewählt werden. In diesem Fall sind die Antworten auf einen bestimmten Prompt größtenteils deterministisch, aber eine gewisse Variation ist dennoch möglich.

    Wenn das Modell eine zu allgemeine oder zu kurze Antwort zurückgibt, oder wenn das Modell eine Fallback-Antwort ausgibt, versuchen Sie, die Temperatur zu erhöhen.

  • TOP_P_ Der Wert „Top-P“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Die Tokens werden von den wahrscheinlichsten (siehe „Top-K“) bis zu den unwahrscheinlichsten Werten ausgewählt, bis die Summe ihrer Wahrscheinlichkeiten dem „Top-P“-Wert entspricht. Beispiel: Wenn die Tokens A, B und C eine Wahrscheinlichkeit von 0,3, 0,2 und 0,1 haben und der „Top-P“-Wert 0.5 ist, wählt das Modell anhand der Temperatur entweder A oder B als das nächste Token und C als Kandidaten ausschließen.

    Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

  • TOP_K: Der Wert „Top-K“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Ein „Top-K“ von 1 bedeutet, dass das nächste ausgewählte Token unter den Tokens im Modell-Vokabular (auch als gierige Decodierung bezeichnet) am wahrscheinlichsten ist, während ein „Top-K“ von3 bedeutet, dass das nächste Token mithilfe der Temperatur aus den drei wahrscheinlichsten Tokens ausgewählt wird.

    Für jeden Tokenauswahlschritt werden die „Top-K“-Tokens mit den höchsten Wahrscheinlichkeiten abgetastet. Anschließend werden Tokens weiter auf der Grundlage von „Top-P“ gefiltert, wobei das endgültige Token mithilfe von Temperaturproben ausgewählt wird.

    Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

  • MAX_OUTPUT_TOKENS: Maximale Anzahl an Tokens, die in der Antwort generiert werden können. Ein Token besteht aus etwa vier Zeichen. 100 Tokens entsprechen etwa 60–80 Wörtern.

    Geben Sie kürzere Werte für kürzere Antworten und höhere Werte für längere Antworten an.

  • STOP_SEQUENCES: Gibt eine Liste an Strings an, die das Modell anweist, Text nicht mehr zu generieren, wenn einer der Strings in der Antwort gefunden wird. Kommt ein String mehrmals in der Antwort vor, so wird die Antwort an der Stelle abgeschnitten, an der er erfasst wurde. Bei Strings wird zwischen Groß- und Kleinschreibung unterschieden.

    Wenn zum Beispiel folgende Antwort zurückgegeben wird und stopSequences nicht angegeben ist:

    public static string reverse(string myString)

    Dann lautet zurückgegebene Antwort mit stopSequences auf ["Str", "reverse"] gesetzt:

    public static string

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:GENERATE_RESPONSE_METHOD

JSON-Text der Anfrage:

{
  "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,
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

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"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

Beispiel: cURL-Befehls

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro"
PROJECT_ID="test-project"
GENERATE_RESPONSE_METHOD="generateContent"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:${GENERATE_RESPONSE_METHOD} -d \
$'{
  "contents": [
    {
    "role": "user",
    "parts": { "text": "Hello!" }
    },
    {
    "role": "model",
    "parts": { "text": "Argh! What brings ye to my ship?" }
    },
    {
    "role": "user",
    "parts": { "text": "Wow! You are a real-life pirate!" }
    }
  ],
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  },
  "generation_config": {
    "temperature": 0.9,
    "topP": 1,
    "candidateCount": 1,
    "maxOutputTokens": 2048
  }
}'

Console

So senden Sie über Vertex AI Studio einen Chat-Prompt in der Google Cloud Console:

  1. Rufen Sie im Abschnitt „Vertex AI“ der Google Cloud Console den Abschnitt Sprache von Vertex AI Studio auf.

    Zu Vertex AI Studio

  2. Klicken Sie auf Textchat.

  3. Konfigurieren Sie Modell und Parameter:

    • Region: Wählen Sie die Region aus, die Sie verwenden möchten.
    • Modell: Wählen Sie Gemini Pro aus.

    • Temperaturen: Geben Sie über den Schieberegler oder das Textfeld einen Temperaturwert ein.

      Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. Dies passiert, wenn topP und topK angewendet werden. Die Temperatur bestimmt den Grad der Zufälligkeit bei der Tokenauswahl. Niedrigere Temperaturen eignen sich gut für Prompts, die eine weniger offene oder kreative Antwort erfordern, während höhere Temperaturen zu vielfältigeren oder kreativeren Ergebnissen führen können. Eine Temperatur von 0 bedeutet, dass immer die Tokens mit der höchsten Wahrscheinlichkeit ausgewählt werden. In diesem Fall sind die Antworten auf einen bestimmten Prompt größtenteils deterministisch, aber eine gewisse Variation ist dennoch möglich.

      Wenn das Modell eine zu allgemeine oder zu kurze Antwort zurückgibt, oder wenn das Modell eine Fallback-Antwort ausgibt, versuchen Sie, die Temperatur zu erhöhen.

    • Token-Limit: Verwenden Sie den Schieberegler oder das Textfeld, um einen Wert für das maximale Ausgabelimit einzugeben.

      Maximale Anzahl an Tokens, die in der Antwort generiert werden können. Ein Token besteht aus etwa vier Zeichen. 100 Tokens entsprechen etwa 60–80 Wörtern.

      Geben Sie kürzere Werte für kürzere Antworten und höhere Werte für längere Antworten an.

    • Stoppsequenz hinzufügen: Geben Sie eine Stoppsequenz ein, die aus einer Reihe von Zeichen (einschließlich Leerzeichen) besteht, die die Antwortgenerierung beendet, wenn das Modell darauf stößt. Die Sequenz ist nicht Teil der Antwort. Sie können bis zu fünf Stoppsequenzen hinzufügen.
  4. Optional: Klicken Sie zum Konfigurieren erweiterter Parameter auf Erweitert und konfigurieren Sie so:

    Klicken, um erweiterte Konfigurationen zu maximieren

    • Top-K: Sie können den Schieberegler oder das Textfeld verwenden, um einen Wert für Top-K einzugeben.

      Der Wert „Top-K“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Ein „Top-K“ von 1 bedeutet, dass das nächste ausgewählte Token unter den Tokens im Modell-Vokabular (auch als gierige Decodierung bezeichnet) am wahrscheinlichsten ist, während ein „Top-K“ von 3 bedeutet, dass das nächste Token mithilfe der Temperatur aus den drei wahrscheinlichsten Tokens ausgewählt wird.

      Für jeden Tokenauswahlschritt werden die „Top-K“-Tokens mit den höchsten Wahrscheinlichkeiten abgetastet. Anschließend werden Tokens weiter auf der Grundlage von „Top-P“ gefiltert, wobei das endgültige Token mithilfe von Temperaturproben ausgewählt wird.

      Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.

    • Top-P: Verwenden Sie den Schieberegler oder das Textfeld, um einen Wert für „Top-P“ einzugeben. Tokens werden vom wahrscheinlichsten bis zum am wenigsten wahrscheinlichen Token ausgewählt, bis die Summe ihrer Wahrscheinlichkeiten dem Wert von „Top-P“ entspricht. Für die Ergebnisse der geringsten Variablen legen Sie Top-P auf 0 fest.

  5. Die Google Cloud Console unterstützt nur das Streaming. Dazu werden Antworten auf Prompts empfangen, sobald diese generiert werden. Sie können nun eine Nachricht in das Nachrichtenfeld eingeben, um eine Unterhaltung mit dem Modell zu starten.

    Das Modell verwendet die vorherigen Nachrichten als Kontext für neue Antworten.

  6. Optional: Klicken Sie auf Speichern, um den Prompt unter Meine Prompts zu speichern.
  7. Optional: Klicken Sie auf Code abrufen, um den Python-Code oder einen curl-Befehl für den Prompt abzurufen.
  8. Optional: Wenn Sie alle vorherigen Nachrichten löschen möchten, klicken Sie auf Unterhaltung löschen.

Systemanweisung verwenden

Mit Systemanweisungen können Nutzer das Verhalten des Modells entsprechend ihrer spezifischen Anforderungen und Anwendungsfällen steuern. Wenn Sie eine Systemanweisung festlegen, geben Sie dem Modell zusätzlichen Kontext, um die Aufgabe zu verstehen, individuellere Antworten zu liefern und bestimmte Richtlinien für die vollständige Nutzerinteraktion mit dem Modell einzuhalten. Für Entwickler kann das Verhalten auf Produktebene in Systemanweisungen angegeben werden, getrennt von den Prompts von Endnutzern.

Sie können Systemanweisungen auf viele Arten verwenden, einschließlich:

  • Identität oder Rolle definieren (z. B. für einen Chatbot)
  • Ausgabeformat definieren (Markdown, YAML usw.)
  • Ausgabestil und ton definieren (z. B. Ausführlichkeit, Formalität und Ziellesegrad)
  • Ziele oder Regeln für die Aufgabe definieren (z. B. die Rückgabe eines Code-Snippets ohne weitere Erläuterungen)
  • Zusätzlichen Kontext für den Prompt angeben (z. B. Wissensgrenzwert)

Wenn eine Systemanweisung festgelegt ist, gilt sie für die gesamte Anfrage. Es funktioniert für mehrere Nutzer und Modellrunden, wenn es im Prompt enthalten ist.

Codebeispiele für Systemanweisungen

Das folgende Beispiel zeigt die Angabe einfacher Systemanleitungen bei der Verwendung des Vertex AI Python SDK.

from vertexai.generative_models import GenerativeModel
model = GenerativeModel(
    "gemini-1.0-pro-002",
    system_instruction=[
        "Don't use technical terms in your response",
    ],
)
print(model.generate_content("Explain gravity"))

Im Folgenden finden Sie ein Beispiel für die Aufnahme einer einfachen Systemanweisung in einen curl-Befehl.

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro-002"
PROJECT_ID="test-project"
GENERATE_RESPONSE_METHOD="generateContent"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models:generateContent" -d \
{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "randomly select 10 words from a history book"
        }
      ]
    }
  ],
  "system_instruction":
    {
      "parts": [
        {
          "text": "please print the results in json format."
        }
      ]
    },
  "generation_config": {
    "maxOutputTokens": 2048,
    "temperature": 0.4,
    "topP": 1,
    "topK": 32
  }
}

Beispiele für Systemanweisungen

Die folgenden Beispiele zeigen System-Prompts, die das erwartete Verhalten des Modells definieren. Das erste ist ein System-Prompt für die Frontend-Codegenerierung, das zweite ein Beispiel für einen Anwendungsfall der Marktsentimentanalyse und der dritte ein Nutzer-Chatbot.

Codegenerierung

  • System: Sie sind ein Programmierexperte, der sich auf das Rendering von Code für Frontend-Schnittstellen spezialisiert hat. Wenn ich die Komponente einer Website beschreibe, die ich erstellen möchte, geben Sie den dazu erforderlichen HTML- und CSS-Code zurück. Geben Sie keine Erläuterung für diesen Code an. Bieten Sie außerdem einige Vorschläge für das UI-Design an.
  • Nutzer: Erstellen Sie in der Mitte der Seite ein Feld, das eine rotierende Auswahl von Bildern mit jeweils einem Untertitel enthält. Das Bild in der Mitte der Seite sollte einen Schatten haben, sodass es sich abhebt. Es sollte auch auf eine andere Seite der Website verweisen. Lassen Sie die URL leer, damit ich sie ausfüllen kann.

Marktsentimentanalyse

  • System: Sie sind Börsenanalyst und analysiert die Marktstimmung anhand eines Nachrichtenausschnitts. Basierend auf dem Nachrichten-Snippet extrahieren Sie Aussagen, die sich auf die Stimmung des Investors auswirken.

    Antworten Sie im JSON-Format und für jede Aussage:

    • Geben Sie eine Punktzahl von 1 bis 10, um anzugeben, ob die Stimmung negativ oder positiv ist (1 ist am negativsten, 10 ist am positivsten, 5 ist neutral).
    • Wiederholen Sie die Aussage.
    • Geben Sie eine Erklärung in einem Satz.

  • Nutzer: Mobileye meldete in den letzten Jahren eine Ansammlung von überschüssigem Inventar von erstklassigen Kunden aufgrund von Einschränkungen in der Lieferkette. Der Umsatz wird laut Mobileye im ersten Quartal voraussichtlich um etwa 50 % unter dem Vorjahreswert von 458 Millionen $ liegen, bevor er sich im Laufe des Jahres 2024 wieder normalisiert. Mobileye prognostiziert für das gesamte Jahr 2024 einen Umsatz zwischen 1,83 Milliarden und 1,96 Milliarden $, während es für 2023 jetzt noch mit 2,08 Milliarden Dollar rechnet.

Musik-Chatbot

  • System: Sie antworten als Musikhistoriker, stellen Ihr umfassendes Wissen über verschiedene Musikgenres unter Beweis und geben relevante Beispiele. Ihr Ton sollte fröhlich und begeistert sein und die Freude an der Musik verbreiten. Wenn sich eine Frage nicht mit Musik bezieht, sollte die Antwort so lauten: „Das liegt außerhalb meines Wissens.“
  • Nutzer: Wenn ein Mensch in den 60er-Jahren geboren wurde, was war das beliebteste Musikgenre, das gespielt wurde? Listen Sie fünf Songs in Stichpunkten auf.

Nächste Schritte