Gemma mit Model Garden und TPU-gestützten Endpunkten der Gemini Enterprise Agent Platform bereitstellen und Inferenzen ausführen

In dieser Anleitung stellen Sie das offene Modell Gemma 2 2B mithilfe von Model Garden auf einem TPU-gestützten Gemini Enterprise Agent Platform-Endpunkt bereit. Sie müssen ein Modell auf einem Endpunkt bereitstellen, bevor es für Onlinevorhersagen verwendet werden kann. Durch die Bereitstellung eines Modells werden dem Modell physische Ressourcen zugeordnet, sodass es Onlinevorhersagen mit niedriger Latenz bereitstellen kann.

Nachdem Sie das Gemma 2 2B-Modell bereitgestellt haben, können Sie das trainierte Modell mit dem PredictionServiceClient verwenden, um Onlinevorhersagen zu erhalten. Onlinevorhersagen sind synchrone Anfragen an ein Modell, das auf einem Endpunkt bereitgestellt wird.

Ziele

In dieser Anleitung werden die folgenden Aufgaben erläutert:

  • Offenes Modell Gemma 2 2B mithilfe von Model Garden auf einem TPU-gestützten Endpunkt bereitstellen
  • PredictionServiceClient verwenden, um Onlinevorhersagen abzurufen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Für diese Anleitung müssen Sie Folgendes tun:

  • Google Cloud -Projekt einrichten und die Agent Platform API aktivieren
  • Auf Ihrem lokalen Computer:
    • Google Cloud CLI installieren, initialisieren und authentifizieren
    • SDK für Ihre Sprache installieren

Google Cloud -Projekt einrichten

Richten Sie Ihr Google Cloud -Projekt ein und aktivieren Sie die Agent Platform API.

  1. Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Agent Platform API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Agent Platform API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

    8.

Google Cloud CLI einrichten

Richten Sie die Google Cloud CLI auf Ihrem lokalen Computer ein.

  1. Installieren und initialisieren Sie Google Cloud CLI.

  2. Wenn Sie die gcloud CLI bereits installiert haben, prüfen Sie, ob Ihre gcloud-Komponenten aktualisiert sind. Führen Sie dazu diesen Befehl aus.

    gcloud components update

  3. Wenn Sie sich mit der gcloud CLI authentifizieren möchten, generieren Sie mit diesem Befehl eine lokale Datei mit Standardanmeldedaten für Anwendungen. Der durch den Befehl gestartete Webablauf wird verwendet, um Ihre Nutzeranmeldedaten bereitzustellen.

    gcloud auth application-default login

    Weitere Informationen finden Sie unter Authentifizierungskonfiguration der gcloud CLI und ADC-Konfiguration.

SDK für Ihre Programmiersprache einrichten

Um die in dieser Anleitung verwendete Umgebung einzurichten, installieren Sie das Gemini Enterprise Agent Platform SDK für Ihre Sprache und die Protokollzwischenspeicher-Bibliothek. In den Codebeispielen werden Funktionen aus der Protocol Buffers-Bibliothek verwendet, um das Eingabewörterbuch in das von der API erwartete JSON-Format zu konvertieren.

Klicken Sie auf Ihrem lokalen Computer auf einen der folgenden Tabs, um das SDK für Ihre Programmiersprache zu installieren.

Python

Klicken Sie auf Ihrem lokalen Computer auf einen der folgenden Tabs, um das SDK für Ihre Programmiersprache zu installieren.

  • Installieren und aktualisieren Sie das Agent Platform SDK für Python, indem Sie diesen Befehl ausführen.

    pip3 install --upgrade "google-cloud-aiplatform>=1.64"

  • Installieren Sie die Protocol Buffers-Bibliothek für Python, indem Sie diesen Befehl ausführen.

    pip3 install --upgrade "protobuf>=5.28"

Node.js

Installieren oder aktualisieren Sie das aiplatform SDK für Node.js, indem Sie den folgenden Befehl ausführen.

npm install @google-cloud/aiplatform

Java

Wenn Sie google-cloud-aiplatform als Abhängigkeit hinzufügen möchten, fügen Sie den entsprechenden Code für Ihre Umgebung hinzu.

Maven mit BOM

Fügen Sie den folgenden HTML-Code in Ihre pom.xml ein:

<dependencyManagement>
<dependencies>
  <dependency>
    <artifactId>libraries-bom</artifactId>
    <groupId>com.google.cloud</groupId>
    <scope>import</scope>
    <type>pom</type>
    <version>26.34.0</version>
  </dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
</dependency>
</dependencies>

Maven ohne BOM

Fügen Sie der pom.xml Folgendes hinzu:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
  <version>1.1.0</version>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
  <version>5.28</version>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.11.0</version>
</dependency>

Gradle ohne BOM

Fügen Sie zum build.gradle Folgendes hinzu:

implementation 'com.google.cloud:google-cloud-aiplatform:1.1.0'

Go

Installieren Sie diese Go-Pakete mit den folgenden Befehlen.

go get cloud.google.com/go/aiplatform
go get google.golang.org/protobuf
go get github.com/googleapis/gax-go/v2

Gemma mit Model Garden bereitstellen

Sie stellen das Gemma 2 2B-Modell auf einem Compute Engine-Maschinentyp ct5lp-hightpu-1t bereit, der für Training in kleinem bis mittlerem Umfang optimiert ist. Diese Maschine hat einen TPU v5e-Beschleuniger. Weitere Informationen zum Trainieren von Modellen mit TPUs finden Sie unter Cloud TPU v5e-Training.

In dieser Anleitung stellen Sie das auf Anweisungen abgestimmte offene Modell Gemma 2 2B mithilfe der Modellkarte in Model Garden bereit. Die spezifische Modellversion ist gemma2-2b-it (-it steht für auf Anweisungen abgestimmt).

Das Gemma 2 2B-Modell hat eine geringere Parametergröße, was einen geringeren Ressourcenbedarf und mehr Flexibilität bei der Bereitstellung bedeutet.

  1. Rufen Sie in der Google Cloud Console die Seite Model Garden auf.

    Zu Model Garden

  2. Klicken Sie auf die Modellkarte Gemma 2.

    Zu Gemma 2

  3. Klicken Sie auf Bereitstellen, um den Bereich Modell bereitstellen zu öffnen.

  4. Geben Sie im Bereich Modell bereitstellen die folgenden Details an.

    1. Klicken Sie unter Bereitstellungsumgebung auf Agent Platform.

    2. Im Abschnitt Modell bereitstellen:

      1. Wählen Sie für Ressourcen-ID den Wert gemma-2b-it aus.

      2. Übernehmen Sie für Modellname und Endpunktname die Standardwerte. Beispiel:

        • Modellname: gemma2-2b-it-1234567891234
        • Endpunktname: gemma2-2b-it-mg-one-click-deploy

        Notieren Sie sich den Endpunktnamen. Sie benötigen sie, um die in den Codebeispielen verwendete Endpunkt-ID zu finden.

    3. Im Abschnitt Bereitstellungseinstellungen:

      1. Übernehmen Sie die Standardoption für die Grundeinstellungen.

      2. Übernehmen Sie für Region den Standardwert oder wählen Sie eine Region aus der Liste aus. Notieren Sie sich die Region. Sie benötigen ihn für die Codebeispiele.

      3. Wählen Sie unter Maschinenspezifikation die TPU-gestützte Instanz aus: ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t).

  5. Klicken Sie auf Bereitstellen. Nach Abschluss des Deployments erhalten Sie eine E-Mail mit Details zu Ihrem neuen Endpunkt. Sie können die Endpunktdetails auch aufrufen, indem Sie auf Onlinevorhersage > Endpunkte klicken und Ihre Region auswählen.

    Endpunkte aufrufen

Inferenz von Gemma 2 2B mit dem PredictionServiceClient

Nachdem Sie Gemma 2 2B bereitgestellt haben, verwenden Sie den PredictionServiceClient, um Onlinevorhersagen für den Prompt „Warum ist der Himmel blau?“ zu erhalten.

Codeparameter

In den PredictionServiceClient-Codebeispielen müssen Sie Folgendes aktualisieren.

  • PROJECT_ID: Folgen Sie dieser Anleitung, um Ihre Projekt-ID zu finden.

    1. Rufen Sie in der Google Cloud Console die Seite Willkommen auf.

      Zur Begrüßungsseite

    2. Wählen Sie oben auf der Seite in der Projektauswahl Ihr Projekt aus.

      Der Projektname, die Projektnummer und die Projekt-ID werden nach der Überschrift Willkommen angezeigt.

  • ENDPOINT_REGION: Dies ist die Region, in der Sie den Endpunkt bereitgestellt haben.

  • ENDPOINT_ID: Sie finden Ihre Endpunkt-ID in der Console oder können sie mit dem Befehl gcloud ai endpoints list abrufen. Sie benötigen den Endpunktnamen und die Region aus dem Bereich Modell bereitstellen.

    Console

    Sie können die Endpunktdetails aufrufen, indem Sie auf Onlinevorhersage > Endpunkte klicken und Ihre Region auswählen. Notieren Sie sich die Zahl, die in der Spalte ID angezeigt wird.

    Endpunkte aufrufen

    gcloud

    Sie können die Endpunktdetails mit dem Befehl gcloud ai endpoints list aufrufen.

    gcloud ai endpoints list \
  --region=ENDPOINT_REGION \
  --filter=display_name=ENDPOINT_NAME

    Die Ausgabe sieht so aus:

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy

Beispielcode

Aktualisieren Sie im Beispielcode für Ihre Sprache die Werte für PROJECT_ID, ENDPOINT_REGION und ENDPOINT_ID. Führen Sie dann den Code aus.

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 zu Python. 

"""
Sample to run inference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accellerators.
"""

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value

# TODO(developer): Update & uncomment lines below
# PROJECT_ID = "your-project-id"
# ENDPOINT_REGION = "your-vertex-endpoint-region"
# ENDPOINT_ID = "your-vertex-endpoint-id"

# Default configuration
config = {"max_tokens": 1024, "temperature": 0.9, "top_p": 1.0, "top_k": 1}

# Prompt used in the prediction
prompt = "Why is the sky blue?"

# Encapsulate the prompt in a correct format for TPUs
# Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
input = {"prompt": prompt}
input.update(config)

# Convert input message to a list of GAPIC instances for model input
instances = [json_format.ParseDict(input, Value())]

# Create a client
api_endpoint = f"{ENDPOINT_REGION}-aiplatform.googleapis.com"
client = aiplatform.gapic.PredictionServiceClient(
    client_options={"api_endpoint": api_endpoint}
)

# Call the Gemma2 endpoint
gemma2_end_point = (
    f"projects/{PROJECT_ID}/locations/{ENDPOINT_REGION}/endpoints/{ENDPOINT_ID}"
)
response = client.predict(
    endpoint=gemma2_end_point,
    instances=instances,
)
text_responses = response.predictions
print(text_responses[0])

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Node.js in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

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

// Imports the Google Cloud Prediction Service Client library
const {
  // TODO(developer): Uncomment PredictionServiceClient before running the sample.
  // PredictionServiceClient,
  helpers,
} = require('@google-cloud/aiplatform');
/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = 'your-project-id';
const endpointRegion = 'your-vertex-endpoint-region';
const endpointId = 'your-vertex-endpoint-id';

// Prompt used in the prediction
const prompt = 'Why is the sky blue?';

// Encapsulate the prompt in a correct format for TPUs
// Example format: [{prompt: 'Why is the sky blue?', temperature: 0.9}]
const input = {
  prompt,
  // Parameters for default configuration
  maxOutputTokens: 1024,
  temperature: 0.9,
  topP: 1.0,
  topK: 1,
};

// Convert input message to a list of GAPIC instances for model input
const instances = [helpers.toValue(input)];

// TODO(developer): Uncomment apiEndpoint and predictionServiceClient before running the sample.
// const apiEndpoint = `${endpointRegion}-aiplatform.googleapis.com`;

// Create a client
// predictionServiceClient = new PredictionServiceClient({apiEndpoint});

// Call the Gemma2 endpoint
const gemma2Endpoint = `projects/${projectId}/locations/${endpointRegion}/endpoints/${endpointId}`;

const [response] = await predictionServiceClient.predict({
  endpoint: gemma2Endpoint,
  instances,
});

const predictions = response.predictions;
const text = predictions[0].stringValue;

console.log('Predictions:', text);

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

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


import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Gemma2PredictTpu {
  private final PredictionServiceClient predictionServiceClient;

  // Constructor to inject the PredictionServiceClient
  public Gemma2PredictTpu(PredictionServiceClient predictionServiceClient) {
    this.predictionServiceClient = predictionServiceClient;
  }

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String endpointRegion = "us-west1";
    String endpointId = "YOUR_ENDPOINT_ID";

    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint(String.format("%s-aiplatform.googleapis.com:443", endpointRegion))
            .build();
    PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings);
    Gemma2PredictTpu creator = new Gemma2PredictTpu(predictionServiceClient);

    creator.gemma2PredictTpu(projectId, endpointRegion, endpointId);
  }

  // Demonstrates how to run inference on a Gemma2 model
  // deployed to a Vertex AI endpoint with TPU accelerators.
  public String gemma2PredictTpu(String projectId, String region,
           String endpointId) throws IOException {
    Map<String, Object> paramsMap = new HashMap<>();
    paramsMap.put("temperature", 0.9);
    paramsMap.put("maxOutputTokens", 1024);
    paramsMap.put("topP", 1.0);
    paramsMap.put("topK", 1);
    Value parameters = mapToValue(paramsMap);
    // Prompt used in the prediction
    String instance = "{ \"prompt\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a correct format for TPUs
    // Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
    List<Value> instances = new ArrayList<>();
    instances.add(instanceValue.build());

    EndpointName endpointName = EndpointName.of(projectId, region, endpointId);

    PredictResponse predictResponse = this.predictionServiceClient
        .predict(endpointName, instances, parameters);
    String textResponse = predictResponse.getPredictions(0).getStringValue();
    System.out.println(textResponse);
    return textResponse;
  }

  private static Value mapToValue(Map<String, Object> map) throws InvalidProtocolBufferException {
    Gson gson = new Gson();
    String json = gson.toJson(map);
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(json, builder);
    return builder.build();
  }
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für Go in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform.

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/protobuf/types/known/structpb"
)

// predictTPU demonstrates how to run interference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accelerators.
func predictTPU(w io.Writer, client PredictionsClient, projectID, location, endpointID string) error {
	ctx := context.Background()

	// Note: client can be initialized in the following way:
	// apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	// client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	// if err != nil {
	// 	return fmt.Errorf("unable to create prediction client: %v", err)
	// }
	// defer client.Close()

	gemma2Endpoint := fmt.Sprintf("projects/%s/locations/%s/endpoints/%s", projectID, location, endpointID)
	prompt := "Why is the sky blue?"
	parameters := map[string]interface{}{
		"temperature":     0.9,
		"maxOutputTokens": 1024,
		"topP":            1.0,
		"topK":            1,
	}

	// Encapsulate the prompt in a correct format for TPUs.
	// Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"prompt":     prompt,
		"parameters": parameters,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	req := &aiplatformpb.PredictRequest{
		Endpoint:  gemma2Endpoint,
		Instances: []*structpb.Value{promptValue},
	}

	resp, err := client.Predict(ctx, req)
	if err != nil {
		return err
	}

	prediction := resp.GetPredictions()
	value := prediction[0].GetStringValue()
	fmt.Fprintf(w, "%v", value)

	return nil
}

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

  1. Wechseln Sie in der Google Cloud -Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Einzelne Ressourcen löschen

Wenn Sie Ihr Projekt behalten möchten, löschen Sie die in dieser Anleitung verwendeten Ressourcen:

  • Bereitstellung des Modells aufheben und Endpunkt löschen
  • Modell aus Model Registry löschen

Bereitstellung des Modells aufheben und Endpunkt löschen

Verwenden Sie eine der folgenden Methoden, um die Bereitstellung eines Modells aufzuheben und den Endpunkt zu löschen:

Console

  1. Klicken Sie in der Google Cloud Console auf Onlinevorhersage und dann auf Endpunkte.

    Zur Seite „Endpunkte”

  2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der Sie den Endpunkt bereitgestellt haben.

  3. Klicken Sie auf den Namen des Endpunkts, um die Detailseite zu öffnen. Beispiel: gemma2-2b-it-mg-one-click-deploy.

  4. Klicken Sie in der Zeile für das Modell Gemma 2 (Version 1) auf Aktionen und dann auf Bereitstellung des Modells am Endpunkt aufheben.

  5. Klicken Sie im Dialogfeld Bereitstellung des Endpunkts aufheben auf Bereitstellung aufheben.

  6. Klicken Sie auf den Button Zurück, um zur Seite Endpunkte zurückzukehren.

    Zur Seite „Endpunkte”

  7. Klicken Sie am Ende der Zeile gemma2-2b-it-mg-one-click-deploy auf Aktionen und wählen Sie dann Endpunkt löschen aus.

  8. Klicken Sie in der Bestätigungsaufforderung auf Bestätigen.

gcloud

So heben Sie die Bereitstellung des Modells auf und löschen den Endpunkt mithilfe der Google Cloud CLI:

Ersetzen Sie in diesen Befehlen Folgendes:

  • PROJECT_ID durch Ihren Projektnamen
  • LOCATION_ID durch die Region, in der Sie das Modell und den Endpunkt bereitgestellt haben
  • ENDPOINT_ID durch die Endpunkt-ID
  • DEPLOYED_MODEL_NAME durch den Anzeigenamen des Modells
  • DEPLOYED_MODEL_ID durch die Modell-ID

  1. Rufen Sie die Endpunkt-ID mit dem Befehl gcloud ai endpoints list ab. Mit diesem Befehl werden die Endpunkt-IDs für alle Endpunkte in Ihrem Projekt aufgelistet. Notieren Sie sich die ID des Endpunkts, der in dieser Anleitung verwendet wird.

    gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Die Ausgabe sieht so aus: In der Ausgabe wird die ID als ENDPOINT_ID bezeichnet.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy

  2. Rufen Sie die Modell-ID mit dem Befehl gcloud ai models describe ab. Notieren Sie sich die ID des Modells, das Sie in dieser Anleitung bereitgestellt haben.

    gcloud ai models describe DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Die gekürzte Ausgabe sieht so aus: In der Ausgabe wird die ID als deployedModelId bezeichnet.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
artifactUri: [URI removed]
baseModelSource:
  modelGardenSource:
    publicModelName: publishers/google/models/gemma2
...
deployedModels:
- deployedModelId: '1234567891234567891'
  endpoint: projects/12345678912/locations/us-central1/endpoints/12345678912345
displayName: gemma2-2b-it-12345678912345
etag: [ETag removed]
modelSourceInfo:
  sourceType: MODEL_GARDEN
name: projects/123456789123/locations/us-central1/models/gemma2-2b-it-12345678912345
...

  3. Heben Sie die Bereitstellung des Modells am Endpunkt auf. Sie benötigen die Endpunkt-ID und die Modell-ID aus den vorherigen Befehlen.

    gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID

    Dieser Befehl erzeugt keine Ausgabe.

  4. Führen Sie den Befehl gcloud ai endpoints delete aus, um den Endpunkt zu löschen.

    gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Geben Sie bei Aufforderung y zur Bestätigung ein. Dieser Befehl erzeugt keine Ausgabe.

Modell löschen

Console

  1. Rufen Sie in der Google Cloud Console im Bereich „Agent Platform“ die Seite Model Registry auf.

    Zur Seite Model Registry

  2. Wählen Sie in der Drop-down-Liste Region die Region aus, in der Sie Ihr Modell bereitgestellt haben.

  3. Klicken Sie am Ende der Zeile gemma2-2b-it-1234567891234 auf Aktionen.

  4. Wählen Sie Modell löschen aus.

    Wenn Sie das Modell löschen, werden alle zugehörigen Modellversionen und ‑bewertungen aus Ihrem Google Cloud -Projekt gelöscht.

  5. Klicken Sie in der Bestätigungsaufforderung auf Löschen.

gcloud

Wenn Sie das Modell mit der Google Cloud CLI löschen möchten, geben Sie den Anzeigenamen und die Region des Modells im Befehl gcloud ai models delete an.

gcloud ai models delete DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Ersetzen Sie DEPLOYED_MODEL_NAME durch den Anzeigenamen des Modells. Ersetzen Sie PROJECT_ID durch Ihren Projektnamen. Ersetzen Sie LOCATION_ID durch die Region, in der Sie das Modell bereitgestellt haben.

Nächste Schritte