Model Garden 및 Vertex AI TPU 지원 엔드포인트를 사용하여 Gemma 배포 및 추론

이 튜토리얼에서는 Model Garden을 사용하여 Gemma 2B 개방형 모델을 TPU 지원 Vertex AI 엔드포인트에 배포합니다. 모델을 온라인 예측을 제공하는 데 사용하려면 먼저 모델을 엔드포인트에 배포해야 합니다. 모델을 배포하면 물리적 리소스가 모델과 연결되므로 짧은 지연 시간으로 온라인 예측을 제공할 수 있습니다.

Gemma 2B 모델을 배포한 후 PredictionServiceClient를 사용하여 온라인 예측을 수행해 학습된 모델을 추론합니다. 온라인 예측은 엔드포인트에 배포된 모델로 전송된 동기식 요청입니다.

Model Garden을 사용하여 Gemma 배포

Gemma 2B 모델을 소규모에서 중규모 학습에 최적화된 ct5lp-hightpu-1t Compute Engine 머신 유형에 배포합니다. 이 머신에는 TPU v5e 가속기가 하나 있습니다. TPU를 사용하여 모델을 학습하는 방법에 관한 자세한 내용은 Cloud TPU v5e 학습을 참조하세요.

이 튜토리얼에서는 Model Garden의 모델 카드를 사용하여 요청 사항이 조정된 Gemma 2B 공개 모델을 배포합니다. 특정 모델 버전은 gemma2-2b-it입니다. -it는 요청 사항 조정을 나타냅니다.

Gemma 2B 모델의 파라미터 크기가 작으므로 리소스 요구사항이 적고 배포 유연성이 높습니다.

1. Google Cloud 콘솔에서 Model Garden 페이지로 이동합니다.

   Model Garden으로 이동

2. Gemma 2 모델 카드를 클릭합니다.

   Gemma 2로 이동

3. 배포를 클릭하여 모델 배포 창을 엽니다.

4. 모델 배포 창에서 다음 세부정보를 지정합니다.

   1. 배포 환경에서 Vertex AI를 클릭합니다.

   2. 모델 배포 섹션에서 다음을 수행합니다.

      1. 리소스 ID에서 gemma-2b-it를 선택합니다.

      2. 모델 이름 및 엔드포인트 이름에는 기본값을 사용합니다. 예를 들면 다음과 같습니다.

         • 모델 이름: gemma2-2b-it-1234567891234
         • 엔드포인트 이름: gemma2-2b-it-mg-one-click-deploy

         엔드포인트 이름을 기록해 둡니다. 코드 샘플에 사용된 엔드포인트 ID를 찾는 데 필요합니다.

   3. 배포 설정 섹션에서 다음을 수행합니다.

      1. 기본 설정의 기본 옵션을 수락합니다.

      2. 리전에 기본값을 사용하거나 목록에서 리전을 선택합니다. 리전을 기록해 둡니다. 코드 샘플에 필요합니다.

      3. 머신 사양에서 TPU 지원 인스턴스 ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t)를 선택합니다.

5. 배포를 클릭합니다. 배포가 완료되면 새 엔드포인트에 대한 세부정보가 포함된 이메일이 전송됩니다. 온라인 예측 > 엔드포인트를 클릭하고 리전을 선택하여 엔드포인트 세부정보를 볼 수도 있습니다.

   엔드포인트로 이동

PredictionServiceClient로 Gemma 2B 추론

Gemma 2B를 배포한 후 PredictionServiceClient를 사용하여 '하늘이 파란 이유는 무엇인가요?'라는 프롬프트에 대한 온라인 예측을 수행합니다.

코드 파라미터

PredictionServiceClient 코드 샘플을 사용하려면 다음을 업데이트해야 합니다.

• PROJECT_ID: 프로젝트 ID를 찾으려면 다음 단계를 수행합니다.

  1. Google Cloud 콘솔에서 시작하기 페이지로 이동합니다.

     시작하기로 이동

  2. 페이지 상단의 프로젝트 선택기에서 프로젝트를 선택합니다.

     프로젝트 이름, 프로젝트 번호, 프로젝트 ID가 시작하기 제목 뒤에 표시됩니다.

• ENDPOINT_REGION: 엔드포인트를 배포한 리전입니다.

• ENDPOINT_ID: 엔드포인트 ID를 찾으려면 콘솔에서 보거나 gcloud ai endpoints list 명령어를 실행합니다. 모델 배포 창의 엔드포인트 이름과 리전이 필요합니다.

  콘솔

  온라인 예측 > 엔드포인트를 클릭하고 리전을 선택하여 엔드포인트 세부정보를 볼 수 있습니다. ID 열에 표시되는 번호를 확인합니다.

  엔드포인트로 이동

  gcloud

  gcloud ai endpoints list 명령어를 실행하여 엔드포인트 세부정보를 볼 수 있습니다.

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

  다음과 같이 출력됩니다.

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

샘플 코드

사용 언어의 샘플 코드에서 PROJECT_ID, ENDPOINT_REGION, ENDPOINT_ID를 업데이트합니다. 그런 다음 코드를 실행합니다.

Python

Vertex AI SDK for Python을 설치하거나 업데이트하는 방법은 Vertex AI SDK for Python 설치를 참조하세요. 자세한 내용은 Python API 참고 문서를 참조하세요.

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

이 샘플을 사용해 보기 전에 Vertex AI 빠른 시작: 클라이언트 라이브러리 사용의 Node.js 설정 안내를 따르세요. 자세한 내용은 Vertex AI Node.js API 참고 문서를 참조하세요.

Vertex AI에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

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

이 샘플을 사용해 보기 전에 Vertex AI 빠른 시작: 클라이언트 라이브러리 사용의 Java 설정 안내를 따르세요. 자세한 내용은 Vertex AI Java API 참고 문서를 참조하세요.

Vertex AI에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

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

이 샘플을 사용해 보기 전에 Vertex AI 빠른 시작: 클라이언트 라이브러리 사용의 Go 설정 안내를 따르세요. 자세한 내용은 Vertex AI Go API 참고 문서를 참조하세요.

Vertex AI에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

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
}