AutoML Translation API 가이드

이 가이드에서는 AutoML Translation을 사용하여 커스텀 번역 모델을 생성하는 방법을 설명합니다. 이 애플리케이션은 소프트웨어 현지화에서 영어-스페인어 데이터세트의 기술 중심 문장 쌍을 사용하여 커스텀 모델을 학습합니다.

이 가이드에서는 커스텀 모델 학습, 커스텀 모델 성능 평가, 새 콘텐츠 번역에 관해 다룹니다.

기본 요건

프로젝트 환경 구성

  1. Google 계정으로 로그인합니다.

    아직 계정이 없으면 새 계정을 등록하세요.

  2. Cloud Console의 프로젝트 선택기 페이지에서 Cloud 프로젝트를 선택하거나 만듭니다.

    프로젝트 선택기 페이지로 이동

  3. Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다. 프로젝트에 결제가 사용 설정되어 있는지 확인하는 방법을 알아보세요.

  4. AutoML Translation API를 사용 설정합니다.

    API 사용 설정

  5. gcloud 명령줄 도구를 설치합니다.
  6. 안내를 따라 서비스 계정을 만들고 키 파일을 다운로드합니다.
  7. 서비스 계정을 만들 때 다운로드한 서비스 계정 키 파일 경로로 GOOGLE_APPLICATION_CREDENTIALS 환경 변수를 설정합니다. 예를 들면 다음과 같습니다.
         export GOOGLE_APPLICATION_CREDENTIALS=key-file
  8. 다음 명령을 사용하여 AutoML 편집자 IAM 역할에 새 서비스 계정을 추가합니다. project-id를 Google Cloud 프로젝트 이름으로 바꾸고 service-account-name을 새 서비스 계정의 이름(예: service-account1@myproject.iam.gserviceaccount.com)으로 바꿉니다.
         gcloud auth login
         gcloud config set project project-id
         gcloud projects add-iam-policy-binding project-id 
    --member=serviceAccount:service-account-name
    --role='roles/automl.editor'
  9. AutoML Translation 서비스 계정으로 Google Cloud 프로젝트 리소스에 액세스하도록 허용합니다.
    gcloud projects add-iam-policy-binding project-id 
    --member="serviceAccount:custom-vision@appspot.gserviceaccount.com"
    --role="roles/storage.admin"
  10. 클라이언트 라이브러리를 설치합니다.
  11. PROJECT_ID 및 REGION_NAME 환경 변수를 설정합니다.

    project-id를 Google Cloud 프로젝트의 프로젝트 ID로 바꿉니다. AutoML Translation에는 현재 us-central1 위치가 필요합니다.

     <pre class="lang-sh">
     export PROJECT_ID="<var>project-id</var>"
     export REGION_NAME="us-central1"
     </pre></li>
    

  12. Google Cloud Storage 버킷을 만들고 커스텀 모델 학습에 사용할 문서를 저장합니다.

    버킷 이름은 $PROJECT_ID-vcm 형식이어야 합니다. 다음 명령어는 $PROJECT_ID-vcm이라는 us-central1 리전에 스토리지 버킷을 만듭니다.
    gsutil mb -p $PROJECT_ID -c regional -l $REGION_NAME gs://$PROJECT_ID-vcm/
  13. 모델 학습에 사용할 샘플 데이터를 포함하는 보관 파일을 다운로드하여 콘텐츠를 추출하고 파일을 Google Cloud Storage 버킷에 업로드합니다.

    형식에 대한 자세한 내용은 학습 데이터 준비를 참조하세요.

    이 가이드의 샘플 코드에서는 영어-스페인어 데이터세트를 사용합니다. 도착어가 독일어, 프랑스어, 러시아어, 중국어인 데이터세트도 사용할 수 있습니다. 이러한 다른 데이터세트 중 하나를 사용하는 경우 샘플의 언어 코드 es를 적절한 언어 코드로 바꿉니다.

  14. 이전 단계의 en-es.csv 파일에서 {project_id}를 프로젝트의 프로젝트 ID로 바꿉니다.

소스 코드 파일 위치

아래 제공된 위치에서 소스 코드를 다운로드할 수 있습니다. 다운로드 후 소스 코드를 Google Cloud 프로젝트 폴더에 복사할 수 있습니다.

Python

이 가이드는 다음 Python 파일로 구성됩니다.

  • translate_create_dataset.py – 데이터세트를 만드는 기능을 포함합니다.
  • import_dataset.py – 데이터세트를 가져오는 기능을 포함합니다.
  • translate_create_model.py – 모델을 만드는 기능을 포함합니다.
  • list_model_evaluations.py – 모델 평가를 나열하는 기능을 포함합니다.
  • translate_predict.py - 예측과 관련된 기능을 포함합니다.
  • delete_model.py - 모델을 삭제하는 기능을 포함합니다.

자바

이 가이드는 다음 자바 파일로 구성됩니다.

  • TranslateCreateDataset.java – 데이터세트를 만드는 기능을 포함합니다.
  • ImportDataset.java – 데이터세트를 가져오는 기능을 포함합니다.
  • TranslateCreateModel.java – 모델을 만드는 기능을 포함합니다.
  • ListModelEvaluations.java – 모델 평가를 나열하는 기능을 포함합니다.
  • TranslatePredict.java - 예측과 관련된 기능을 포함합니다.
  • DeleteModel.java – 모델을 삭제하는 기능을 포함합니다.

Node.js

이 가이드는 다음 Node.js 프로그램으로 구성됩니다.

  • translate_create_dataset.js – 데이터세트를 만드는 기능을 포함합니다.
  • import_dataset.js – 데이터세트를 가져오는 기능을 포함합니다.
  • translate_create_model.js – 모델을 만드는 기능을 포함합니다.
  • list_model_evaluations.js – 모델 평가를 나열하는 기능을 포함합니다.
  • translate_predict.js - 예측과 관련된 기능을 포함합니다.
  • delete_model.js - 모델을 삭제하는 기능을 포함합니다.

애플리케이션 실행

1단계: 데이터세트 생성

커스텀 모델을 생성하는 첫 단계는 모델 학습용 데이터를 저장할 비어 있는 데이터세트를 만드는 것입니다. 데이터세트를 생성할 때 번역할 출발어와 도착어를 지정합니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# display_name = "YOUR_DATASET_NAME"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, "us-central1")
# For a list of supported languages, see:
# https://cloud.google.com/translate/automl/docs/languages
dataset_metadata = automl.types.TranslationDatasetMetadata(
    source_language_code="en", target_language_code="ja"
)
dataset = automl.types.Dataset(
    display_name=display_name,
    translation_dataset_metadata=dataset_metadata,
)

# Create a dataset with the dataset metadata in the region.
response = client.create_dataset(project_location, dataset)

created_dataset = response.result()

# Display the dataset information
print("Dataset name: {}".format(created_dataset.name))
print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

자바


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.Dataset;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.cloud.automl.v1.TranslationDatasetMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class TranslateCreateDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATASET_NAME";
    createDataset(projectId, displayName);
  }

  // Create a dataset
  static void createDataset(String projectId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");

      // Specify the source and target language.
      TranslationDatasetMetadata translationDatasetMetadata =
          TranslationDatasetMetadata.newBuilder()
              .setSourceLanguageCode("en")
              .setTargetLanguageCode("ja")
              .build();
      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(displayName)
              .setTranslationDatasetMetadata(translationDatasetMetadata)
              .build();
      OperationFuture<Dataset, OperationMetadata> future =
          client.createDatasetAsync(projectLocation, dataset);

      Dataset createdDataset = future.get();

      // Display the dataset information.
      System.out.format("Dataset name: %s%n", createdDataset.getName());
      // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
      // required for other methods.
      // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
      String[] names = createdDataset.getName().split("/");
      String datasetId = names[names.length - 1];
      System.out.format("Dataset id: %s%n", datasetId);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createDataset() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    dataset: {
      displayName: displayName,
      translationDatasetMetadata: {
        sourceLanguageCode: 'en',
        targetLanguageCode: 'ja',
      },
    },
  };

  // Create dataset
  const [operation] = await client.createDataset(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();

  console.log(`Dataset name: ${response.name}`);
  console.log(`
    Dataset id: ${
      response.name
        .split('/')
        [response.name.split('/').length - 1].split('\n')[0]
    }`);
}

createDataset();

요청

create_dataset 함수를 실행하고 비어 있는 데이터 세트를 만듭니다. 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • 데이터세트의 display_name을 설정합니다(en_es_dataset).
  • target_language_code 필드를 ja에서 es로 수정합니다.

Python

python translate_create_dataset.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranslateCreateDataset"

Node.js

node translate_create_dataset.js

응답

응답에는 향후 요청에 참조할 데이터 세트 ID와 같이 새로 생성된 데이터 세트의 세부정보가 포함됩니다. 반환된 데이터세트 ID 값에 환경 변수 DATASET_ID를 설정하는 것이 좋습니다.

Dataset name: projects/216065747626/locations/us-central1/datasets/TRL7372141011130533778
Dataset id: TRL7372141011130533778
Dataset display name: en_es_dataset
Translation dataset Metadata:
        source_language_code: en
        target_language_code: es
Dataset example count: 0
Dataset create time:
       seconds: 1530251987
       nanos: 216586000

2단계: 데이터세트로 학습 문장 쌍 가져오기

다음 단계에서는 학습 문장 쌍 목록으로 데이터세트를 채웁니다.

import_dataset 함수 인터페이스는 모든 학습 문서의 위치와 각 학습 문서에 적절한 라벨을 나열하는 .csv 파일을 입력으로 사용합니다. (필수 형식에 대한 자세한 내용은 데이터 준비하기를 참조하세요.) 이 가이드에서는 위에서 Google Cloud Storage에 업로드한 en-es.csv를 사용합니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# path = "gs://YOUR_BUCKET_ID/path/to/data.csv"

client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(
    project_id, "us-central1", dataset_id
)
# Get the multiple Google Cloud Storage URIs
input_uris = path.split(",")
gcs_source = automl.types.GcsSource(input_uris=input_uris)
input_config = automl.types.InputConfig(gcs_source=gcs_source)
# Import data from the input URI
response = client.import_data(dataset_full_id, input_config)

print("Processing import...")
print("Data imported. {}".format(response.result()))

자바

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.DatasetName;
import com.google.cloud.automl.v1.GcsSource;
import com.google.cloud.automl.v1.InputConfig;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

class ImportDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String path = "gs://BUCKET_ID/path_to_training_data.csv";
    importDataset(projectId, datasetId, path);
  }

  // Import a dataset
  static void importDataset(String projectId, String datasetId, String path)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the complete path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

      // Get multiple Google Cloud Storage URIs to import data from
      GcsSource gcsSource =
          GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

      // Import data from the input URI
      InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
      System.out.println("Processing import...");

      // Start the import job
      OperationFuture<Empty, OperationMetadata> operation =
          client.importDataAsync(datasetFullId, inputConfig);

      System.out.format("Operation name: %s%n", operation.getName());

      // If you want to wait for the operation to finish, adjust the timeout appropriately. The
      // operation will still run if you choose not to wait for it to complete. You can check the
      // status of your operation using the operation's name.
      Empty response = operation.get(45, TimeUnit.MINUTES);
      System.out.format("Dataset imported. %s%n", response);
    } catch (TimeoutException e) {
      System.out.println("The operation's polling period was not long enough.");
      System.out.println("You can use the Operation's name to get the current status.");
      System.out.println("The import job is still running and will complete as expected.");
      throw e;
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DISPLAY_ID';
// const path = 'gs://BUCKET_ID/path_to_training_data.csv';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function importDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
    inputConfig: {
      gcsSource: {
        inputUris: path.split(','),
      },
    },
  };

  // Import dataset
  console.log('Proccessing import');
  const [operation] = await client.importData(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset imported: ${response}`);
}

importDataset();

요청

import_data 함수를 실행하여 학습 콘텐츠를 가져옵니다. 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • 이전 단계의 출력에서 데이터세트의 dataset_id를 설정합니다.
  • URI인 path를 설정합니다(gs://YOUR_PROJECT_ID-vcm/en-es.csv).

Python

python import_dataset.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.ImportDataset"

Node.js

node import_dataset.js

응답

Processing import...
Dataset imported.

3단계: 모델 생성(학습)

라벨이 지정된 학습 문서 데이터세트를 만들었으므로 이제 새로운 모델을 학습할 수 있습니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# display_name = "YOUR_MODEL_NAME"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, "us-central1")
# Leave model unset to use the default base model provided by Google
translation_model_metadata = automl.types.TranslationModelMetadata()
model = automl.types.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    translation_model_metadata=translation_model_metadata,
)

# Create a model with the model metadata in the region.
response = client.create_model(project_location, model)

print("Training operation name: {}".format(response.operation.name))
print("Training started...")

자바


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.cloud.automl.v1.TranslationModelMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class TranslateCreateModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String displayName = "YOUR_DATASET_NAME";
    createModel(projectId, datasetId, displayName);
  }

  // Create a model
  static void createModel(String projectId, String datasetId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      // Leave model unset to use the default base model provided by Google
      TranslationModelMetadata translationModelMetadata =
          TranslationModelMetadata.newBuilder().build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setTranslationModelMetadata(translationModelMetadata)
              .build();

      // Create a model with the model metadata in the region.
      OperationFuture<Model, OperationMetadata> future =
          client.createModelAsync(projectLocation, model);
      // OperationFuture.get() will block until the model is created, which may take several hours.
      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Training operation name: %s%n", future.getInitialFuture().get().getName());
      System.out.println("Training started...");
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const dataset_id = 'YOUR_DATASET_ID';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createModel() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    model: {
      displayName: displayName,
      datasetId: datasetId,
      translationModelMetadata: {}, // Leave unset, to use the default base model
    },
  };

  // Don't wait for the LRO
  const [operation] = await client.createModel(request);
  console.log('Training started...');
  console.log(`Training operation name: ${operation.name}`);
}

createModel();

요청

create_model을 실행하려면 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • 이전 단계의 출력에서 데이터세트의 dataset_id를 설정합니다.
  • 새 모델의 display_name을 설정합니다(en_es_test_model).

Python

python translate_create_model.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranlateCreateModel"

Node.js

node translate_create_model.js

응답

create_model 함수는 학습 작업을 시작하고 작업명을 출력합니다. 학습은 비동기식으로 진행되고 완료하는 데 시간이 걸릴 수 있으므로 작업 ID를 사용하여 학습 상태를 확인할 수 있습니다. 학습이 끝나면 create_model이 모델 ID를 반환합니다. 데이터세트 ID와 마찬가지로 MODEL_ID 환경 변수를 반환된 모델 ID 값으로 설정할 수 있습니다.

Training operation name: projects/216065747626/locations/us-central1/operations/TRL3007727620979824033
Training started...
Model name: projects/216065747626/locations/us-central1/models/TRL3007727620979824033
Model id: TRL3007727620979824033
Model display name: en_es_test_model
Model create time:
        seconds: 1529649600
        nanos: 966000000
Model deployment state: deployed

4단계: 모델 평가하기

학습이 끝난 후 BLEU 점수를 검토하여 모델의 준비 상태를 평가할 수 있습니다.

list_model_evaluations 함수는 모델 ID를 매개변수로 사용합니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)

print("List of model evaluations:")
for evaluation in client.list_model_evaluations(model_full_id, ""):
    print("Model evaluation name: {}".format(evaluation.name))
    print(
        "Model annotation spec id: {}".format(
            evaluation.annotation_spec_id
        )
    )
    print("Create Time:")
    print("\tseconds: {}".format(evaluation.create_time.seconds))
    print("\tnanos: {}".format(evaluation.create_time.nanos / 1e9))
    print(
        "Evaluation example count: {}".format(
            evaluation.evaluated_example_count
        )
    )
    print(
        "Translation model evaluation metrics: {}".format(
            evaluation.translation_evaluation_metrics
        )
    )

자바


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ListModelEvaluationsRequest;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelName;
import com.google.protobuf.Timestamp;
import java.io.IOException;

class ListModelEvaluations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    listModelEvaluations(projectId, modelId);
  }

  // List model evaluations
  static void listModelEvaluations(String projectId, String modelId) 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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      ListModelEvaluationsRequest modelEvaluationsrequest =
          ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();

      // List all the model evaluations in the model by applying filter.
      System.out.println("List of model evaluations:");
      for (ModelEvaluation modelEvaluation :
          client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {

        System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
        System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
        System.out.println("Create Time:");
        Timestamp createdTime = modelEvaluation.getCreateTime();
        System.out.format("\tseconds: %s%n", createdTime.getSeconds());
        System.out.format("\tnanos: %s", createdTime.getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d%n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Translate Model Evaluation Metrics: %s%n",
            modelEvaluation.getTranslationEvaluationMetrics());
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function listModelEvaluations() {
  // Construct request
  const request = {
    parent: client.modelPath(projectId, location, modelId),
    filter: '',
  };

  const [response] = await client.listModelEvaluations(request);

  console.log('List of model evaluations:');
  for (const evaluation of response) {
    console.log(`Model evaluation name: ${evaluation.name}`);
    console.log(`Model annotation spec id: ${evaluation.annotationSpecId}`);
    console.log(`Model display name: ${evaluation.displayName}`);
    console.log('Model create time');
    console.log(`\tseconds ${evaluation.createTime.seconds}`);
    console.log(`\tnanos ${evaluation.createTime.nanos / 1e9}`);
    console.log(
      `Evaluation example count: ${evaluation.evaluatedExampleCount}`
    );
    console.log(
      `Translation model evaluation metrics: ${evaluation.translationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

요청

다음 요청을 실행하여 모델의 전체 평가 성능을 표시하도록 요청합니다. 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • model_id를 모델의 ID로 설정합니다.

Python

python list_model_evaluations.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.ListModelEvaluations"

Node.js

node list_model_evaluations.js

응답

BLEU 점수가 너무 낮으면 학습 데이터세트를 강화하고 모델을 재학습시킬 수 있습니다. 자세한 내용은 모델 평가를 참조하세요.

List of model evaluations:
name: "projects/216065747626/locations/us-central1/models/5419131644870929143/modelEvaluations/TRL7683346839371803263"
create_time {
  seconds: 1530196488
  nanos: 509247000
}
evaluated_example_count: 3
translation_evaluation_metrics {
  bleu_score: 19.23076957464218
  base_bleu_score: 11.428571492433548
}

5단계: 모델을 활용한 예측

커스텀 모델이 품질 기준을 충족하면 이를 사용해 새 콘텐츠를 번역할 수 있습니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# file_path = "path_to_local_file.txt"

prediction_client = automl.PredictionServiceClient()

# Get the full path of the model.
model_full_id = prediction_client.model_path(
    project_id, "us-central1", model_id
)

# Read the file content for translation.
with open(file_path, "rb") as content_file:
    content = content_file.read()
content.decode("utf-8")

text_snippet = automl.types.TextSnippet(content=content)
payload = automl.types.ExamplePayload(text_snippet=text_snippet)

response = prediction_client.predict(model_full_id, payload)
translated_content = response.payload[0].translation.translated_content

print(u"Translated content: {}".format(translated_content.content))

자바


import com.google.cloud.automl.v1.ExamplePayload;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.PredictRequest;
import com.google.cloud.automl.v1.PredictResponse;
import com.google.cloud.automl.v1.PredictionServiceClient;
import com.google.cloud.automl.v1.TextSnippet;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

class TranslatePredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String filePath = "path_to_local_file.txt";
    predict(projectId, modelId, filePath);
  }

  static void predict(String projectId, String modelId, String filePath) 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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      byte[] fileData = Files.readAllBytes(Paths.get(filePath));
      String content = new String(fileData, StandardCharsets.UTF_8);

      TextSnippet textSnippet = TextSnippet.newBuilder().setContent(content).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setTextSnippet(textSnippet).build();
      PredictRequest predictRequest =
          PredictRequest.newBuilder().setName(name.toString()).setPayload(payload).build();

      PredictResponse response = client.predict(predictRequest);
      TextSnippet translatedContent =
          response.getPayload(0).getTranslation().getTranslatedContent();
      System.out.format("Translated Content: %s%n", translatedContent.getContent());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const filePath = 'path_to_local_file.txt';

// Imports the Google Cloud AutoML library
const {PredictionServiceClient} = require('@google-cloud/automl').v1;
const fs = require('fs');

// Instantiates a client
const client = new PredictionServiceClient();

// Read the file content for translation.
const content = fs.readFileSync(filePath, 'utf8');

async function predict() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
    payload: {
      textSnippet: {
        content: content,
      },
    },
  };

  const [response] = await client.predict(request);

  console.log(
    'Translated content: ',
    response.payload[0].translation.translatedContent.content
  );
}

predict();

요청

predict 함수의 경우 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • model_id를 모델의 ID로 설정합니다.
  • file_path를 다운로드한 파일('resources/input.txt')로 설정합니다.

Python

python tranlsate_predict.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranslatePredict"

Node.js

node translate_predict.js predict

응답

이 함수는 번역된 콘텐츠를 반환합니다.

Translated content: Ver y administrar tus cuentas de Google Tag Manager.

위는 영어 문장 'Google 태그 관리자 계정 보기 및 관리'의 스페인어 번역입니다. 이 커스텀 번역과 기본 Google 모델의 번역을 비교합니다.

Ver y administrar sus cuentas de Administrador de etiquetas de Google

6단계: 모델 삭제

샘플 모델 사용을 마치면 영구 삭제할 수 있습니다. 더 이상 예측에 모델을 사용할 수 없습니다.

코드 복사

Python

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)
response = client.delete_model(model_full_id)

print("Model deleted. {}".format(response.result()))

자바

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ModelName;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class DeleteModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    deleteModel(projectId, modelId);
  }

  // Delete a model
  static void deleteModel(String projectId, String modelId)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);

      // Delete a model.
      Empty response = client.deleteModelAsync(modelFullId).get();

      System.out.println("Model deletion started...");
      System.out.println(String.format("Model deleted. %s", response));
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function deleteModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

  const [response] = await client.deleteModel(request);
  console.log(`Model deleted: ${response}`);
}

deleteModel();

요청

delete_model 작업 유형으로 요청하여 생성한 모델을 삭제합니다. 다음 코드 줄을 수정해야 합니다.

  • project_id를 PROJECT_ID로 설정합니다.
  • model_id를 모델의 ID로 설정합니다.

Python

python delete_model.py

자바

mvn compile exec:java -Dexec.mainClass="com.example.automl.DeleteModel"

Node.js

node delete_model.js

응답

Model deleted.