Translation Advanced への移行

このページでは、Cloud Translation - Basic と Cloud Translation - Advanced の主な違いについて説明します。また、アプリケーションの移行に役立つコード例も示します。Cloud Translation - Advanced の機能(用語集など)だけを見たい場合は、Cloud Translation - Advanced の概要をご覧ください。

Cloud Translation - Advanced は、Basic で使用できるすべての機能とモデルをサポートします。ただし、クライアント ライブラリについては、クライアント統合の際の下位互換性をサポートしません。つまり、Cloud Translation - Advanced の機能を利用するには、アプリケーションの移行を計画する必要があります。

新しいプロジェクトを計画している場合は、Cloud Translation - Advanced を使用してアプリケーションを作成して、新しい機能やサービス改善点を活用してください。Cloud Translation - Basic は引き続き利用できますが、用語集、一括翻訳、モデル選択などの新機能はサポートされません。

Basic と Advanced の主な違い

Cloud Translation - Advanced と Basic バージョンにはいくつかの違いがあります。

サービス アカウント

Cloud Translation - Basic では、API キーを使用して Translation を認証できます。

Cloud Translation - Advanced では顧客管理のリソースを必要とする機能があり、これらのリソースには IAM 役割と権限管理が必要です。このため、サービスの認証に API キーは使用できません。代わりに、Translation での認証の際には、サービス アカウントを使用する必要があります。

IAM 役割

Translation の認証用サービス アカウントには、これまで特別な IAM 役割を適用する必要はありませんでした。

Cloud Translation - Advanced には、プロジェクト内の特定のリソースにアクセスできるようサービス アカウントに割り当てることができる複数の IAM 役割があります。たとえば、サービス アカウントを使用してテキストを翻訳する場合は、roles/cloudtranslate.user 役割を割り当てます。使用可能な IAM の役割の詳細は、Cloud Translation - Advanced の概要をご覧ください。

リソース、プロジェクト、ロケーション

Cloud Translation - Advanced にリクエストを送信するときは、使用するリソースの名前を指定する必要があります。通常、リソースは、AutoML モデルの名前などの、プロジェクト名とその場所を含む修飾子です。

たとえば、Google Cloud プロジェクトの名前が my-project で、リソースのロケーションが us-central1 の場合、リソースの完全な名称は次のようになります。

projects/my-project/locations/us-central1/...

REST リクエスト送信する際の URL にもロケーション名を使用します。この場合、リクエストが実行されるロケーションを指定します。たとえば、getSupportedLanguages リクエストを送信する URL は次のようになります。

https://translation.googleapis.com/v3/projects/my-project/locations/us-central1/supportedLanguages

翻訳モデル

Cloud Translation-Advanced から翻訳をリクエストする場合は、AutoML Translation カスタムモデルを使用するか、一般モデル、ニューラル機械翻訳(NMT)、フレーズベース機械翻訳(PBMT)を使用できます。

AutoML モデルと統合するには、定義されているプロジェクトにかかわらず、翻訳リクエストに使用されるサービス アカウントに AutoML モデルや一般的なモデルにアクセスするための適切な IAM 権限が必要です。

翻訳モデルの選択方法については、Cloud Translation - Advanced のテキストの翻訳をご覧ください。

リクエストあたりのコンテンツの上限

Cloud Translation API は短いリクエストの翻訳向けに最適化されています。リクエストの長さの推奨上限は、1 リクエストあたり 5,000 文字(コードポイント)です。ただし、含める文字数が多くなるほど、レスポンスのレイテンシが高くなります。Cloud Translation - Advanced の場合、1 リクエストあたりの最大コードポイント数は 30,000 です。Cloud Translation - Basic は最大リクエスト サイズが 10 万バイトです。

利用可能な割り当てにかかわらず、最大コードポイント数より長いリクエストは Cloud Translation API によって拒否され、400 INVALID_ARGUMENT エラーが発生します。

割り当てと上限の詳細については、割り当てをご覧ください。

以下の手順を確認して、既存のアプリケーションを Cloud Translation - Basic から Cloud Translation - Advanced に更新します。

  1. Google Cloud のプロジェクト、アプリケーション、Basic API にアクセスするユーザーのインベントリを作成します。
  2. アプリケーション用のサービス アカウントと認証を設定します。IAM のロールに関する資料を確認し、特に AutoML、Cloud Storage、Cloud Translation のロールに着目してください。
  3. プロジェクトで Cloud Translation - Advanced を有効にします。Cloud Translation - Advanced で AutoML モデルを使用する場合は、AutoML も有効にする必要があります。
  4. Cloud Translation - Advanced クライアント ライブラリとメソッドを使用します。Cloud Translation - Advanced リクエストには、プロジェクト番号(またはプロジェクト ID)とプロジェクト ロケーション(通常は globalus-central1 のいずれか)を含める必要があります。詳細については、API とクライアント ライブラリの違いをご覧ください。
  5. 新しい機能を活用する場合は、アプリケーションまたは翻訳ワークフローを更新してください。アプリケーションを AutoML や Cloud Storage と統合するには、適切な IAM 役割と権限をサービス アカウントに適用して、リソースにアクセスできるようにする必要があります。
  6. Cloud Translation - Advanced への翻訳リクエストのサイズが上限を超えていないことを確認します。
  7. 翻訳リクエストの割り当てのモニタリング計画を立てます。日ごとの割り当てと月ごとの割り当てについては、どちらの API バージョンでも同じ割り当てを共有します。
  8. 支払いと請求に影響のある変更がないかを確認します。

API とクライアント ライブラリの違い

以下のセクションでは、Cloud Translation - Basic と Cloud Translation - Advanced の呼び出しの違いについて説明します。

Cloud Translation - Advanced クライアント ライブラリのインポート

Cloud Translation - Advanced のクライアント ライブラリをインポートするには、次のコードを使用します。

C#

nuget install Google.Cloud.Translate.V3 -Pre

Go

go get -u cloud.google.com/go/translate/apiv3

Java

Maven を使用している場合は、次のものを pom.xml ファイルに追加します。BOM の詳細については、Google Cloud Platform ライブラリ BOM をご覧ください。

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>10.1.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-translate</artifactId>
  </dependency>
</dependencies>

Gradle を使用している場合は、次のものを依存関係に追加します。

compile 'com.google.cloud:google-cloud-translate:1.95.2'

sbt を使用している場合は、次のものを依存関係に追加します。

libraryDependencies += "com.google.cloud" % "google-cloud-translate" % "1.95.2"

IntelliJ または Eclipse を使用している場合は、次の IDE プラグインを使用してプロジェクトにクライアント ライブラリを追加できます。

プラグインでは、サービス アカウントのキー管理などの追加機能も提供されます。詳細は各プラグインのドキュメントをご覧ください。

Node.js

Node.js 開発環境の設定の詳細については、Node.js 開発環境設定ガイドをご覧ください。

npm install --save @google-cloud/translate

PHP

composer require google/cloud-translate

Python

Python 開発環境の設定の詳細については、Python 開発環境設定ガイドをご覧ください。

pip install --upgrade google-cloud-translate

Ruby

Ruby 開発環境の設定の詳細については、Ruby 開発環境設定ガイドをご覧ください。

gem install google-cloud-translate

テキストの翻訳

Cloud Translation - Basic では、コードを使用して API に翻訳リクエストを送信します。

REST とコマンドライン

HTTP メソッドと URL:

POST https://translation.googleapis.com/language/translate/v2

JSON 本文のリクエスト:

{
  "q": ["Hello world", "My name is Jeff"],
  "target": "de"
}

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/language/translate/v2

PowerShell

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://translation.googleapis.com/language/translate/v2 " | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

{
  "data": {
    "translations": [
      {
        "translatedText": "Hallo Welt",
        "detectedSourceLanguage": "en"
      },
      {
        "translatedText": "Mein Name ist Jeff",
        "detectedSourceLanguage": "en"
      }
    ]
  }
}

C#

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある C# の設定手順を行ってください。詳細については、Translation C# API のリファレンス ドキュメントをご覧ください。


using Google.Cloud.Translation.V2;
using System;

public partial class TranslateSample
{
    public string TranslateText()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;
        TranslationClient client = TranslationClient.Create();
        var response = client.TranslateText(
            text: "Hello World.",
            targetLanguage: "ru",  // Russian
            sourceLanguage: "en");  // English
        Console.WriteLine(response.TranslatedText);
        return response.TranslatedText;
    }
}

Go

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Go の設定手順を行ってください。詳細については、Translation Go API のリファレンス ドキュメントをご覧ください。

import (
	"context"
	"fmt"

	"cloud.google.com/go/translate"
	"golang.org/x/text/language"
)

func translateText(targetLanguage, text string) (string, error) {
	// text := "The Go Gopher is cute"
	ctx := context.Background()

	lang, err := language.Parse(targetLanguage)
	if err != nil {
		return "", fmt.Errorf("language.Parse: %v", err)
	}

	client, err := translate.NewClient(ctx)
	if err != nil {
		return "", err
	}
	defer client.Close()

	resp, err := client.Translate(ctx, []string{text}, lang, nil)
	if err != nil {
		return "", fmt.Errorf("Translate: %v", err)
	}
	if len(resp) == 0 {
		return "", fmt.Errorf("Translate returned empty response to text: %s", text)
	}
	return resp[0].Text, nil
}

Java

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Java の設定手順を行ってください。詳細については、Translation Java API のリファレンス ドキュメントをご覧ください。

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

Translation translation = translate.translate("¡Hola Mundo!");
System.out.printf("Translated Text:\n\t%s\n", translation.getTranslatedText());

Node.js

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Translation Node.js API のリファレンス ドキュメントをご覧ください。

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const text = 'The text to translate, e.g. Hello, world!';
// const target = 'The target language, e.g. ru';

async function translateText() {
  // Translates the text into the target language. "text" can be a string for
  // translating a single piece of text, or an array of strings for translating
  // multiple texts.
  let [translations] = await translate.translate(text, target);
  translations = Array.isArray(translations) ? translations : [translations];
  console.log('Translations:');
  translations.forEach((translation, i) => {
    console.log(`${text[i]} => (${target}) ${translation}`);
  });
}

translateText();

PHP

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある PHP の設定手順を行ってください。詳細については、Translation PHP API のリファレンス ドキュメントをご覧ください。

use Google\Cloud\Translate\TranslateClient;

/** Uncomment and populate these variables in your code */
// $text = 'The text to translate.';
// $targetLanguage = 'ja';  // Language to translate to

$translate = new TranslateClient();
$result = $translate->translate($text, [
    'target' => $targetLanguage,
]);
print("Source language: $result[source]\n");
print("Translation: $result[text]\n");

Python

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Translation Python API のリファレンス ドキュメントをご覧ください。

"""Translates text into the target language.

Target must be an ISO 639-1 language code.
See https://g.co/cloud/translate/v2/translate-reference#supported_languages
"""
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

if isinstance(text, six.binary_type):
    text = text.decode("utf-8")

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.translate(text, target_language=target)

print(u"Text: {}".format(result["input"]))
print(u"Translation: {}".format(result["translatedText"]))
print(u"Detected source language: {}".format(result["detectedSourceLanguage"]))

Ruby

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Ruby の設定手順を行ってください。詳細については、Translation Ruby API のリファレンス ドキュメントをご覧ください。

# project_id    = "Your Google Cloud project ID"
# text          = "The text you would like to translate"
# language_code = "The ISO 639-1 code of language to translate to, eg. 'en'"

require "google/cloud/translate"

translate   = Google::Cloud::Translate.translation_v2_service project_id: project_id
translation = translate.translate text, to: language_code

puts "Translated '#{text}' to '#{translation.text.inspect}'"
puts "Original language: #{translation.from} translated to: #{translation.to}"

Cloud Translation - Advanced では、translateText リクエストを行う際に、プロジェクト番号(またはプロジェクト ID)とプロジェクト ロケーション(通常は globalus-central1 のいずれか)を指定する必要があります。

テキストの翻訳時に使用する翻訳モデルや用語集を明示的に指定することもできます。また、レスポンスの翻訳を text/plain で受け取るか、text/html で受け取るかをリクエストすることもできます(デフォルト値は text/html)。

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

  • project-number-or-id: Google Cloud プロジェクト番号または ID

HTTP メソッドと URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id:translateText

JSON 本文のリクエスト:

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, come here!", "Bring me some coffee!"]
}

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id:translateText

PowerShell

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id:translateText " | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

{
  "translations": [
    {
      "translatedText": "Доктор Ватсон, иди сюда!",
    },
    {
      "translatedText": "Принеси мне кофе!",
    }
  ]
}

C#

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある C# の設定手順を行ってください。詳細については、Translation C# API のリファレンス ドキュメントをご覧ください。


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class TranslateText
    {
        /// <summary>
        /// Translates a given text to a target language.
        /// </summary>
        /// <param name="text">The content to translate.</param>
        /// <param name="targetLanguage">Required. Target language code.</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void TranslateTextSample(string text = "[TEXT_TO_TRANSLATE]",
            string targetLanguage = "ja",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            TranslateTextRequest request = new TranslateTextRequest
            {
                Contents =
                {
                    // The content to translate.
                    text,
                },
                TargetLanguageCode = targetLanguage,
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            TranslateTextResponse response = translationServiceClient.TranslateText(request);
            // Display the translation for each input text provided
            foreach (Translation translation in response.Translations)
            {
                Console.WriteLine($"Translated text: {translation.TranslatedText}");
            }
        }
    }

Go

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Go の設定手順を行ってください。詳細については、Translation Go API のリファレンス ドキュメントをご覧ください。

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// translateText translates input text and returns translated text.
func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {
	// projectID := "my-project-id"
	// sourceLang := "en-US"
	// targetLang := "fr"
	// text := "Text you wish to translate"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/global", projectID),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
	}

	resp, err := client.TranslateText(ctx, req)
	if err != nil {
		return fmt.Errorf("TranslateText: %v", err)
	}

	// Display the translation for each input text provided
	for _, translation := range resp.GetTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Java の設定手順を行ってください。詳細については、Translation Java API のリファレンス ドキュメントをご覧ください。

import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class TranslateText {

  public static void translateText() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String targetLanguage = "your-target-language";
    String text = "your-text";
    translateText(projectId, targetLanguage, text);
  }

  // Translating Text
  public static void translateText(String projectId, String targetLanguage, String text)
      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 (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Translation Node.js API のリファレンス ドキュメントをご覧ください。

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();
async function translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

  try {
    // Run request
    const [response] = await translationClient.translateText(request);

    for (const translation of response.translations) {
      console.log(`Translation: ${translation.translatedText}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

translateText();

Python

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Translation Python API のリファレンス ドキュメントをご覧ください。

from google.cloud import translate

def translate_text(text="YOUR_TEXT_TO_TRANSLATE", project_id="YOUR_PROJECT_ID"):
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": "en-US",
            "target_language_code": "fr",
        }
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print("Translated text: {}".format(translation.translated_text))

Ruby

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Ruby の設定手順を行ってください。詳細については、Translation Ruby API のリファレンス ドキュメントをご覧ください。

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

# The content to translate in string format
contents = ["Hello, world!"]
# Required. The BCP-47 language code to use for translation.
target_language = "fr"

client = Google::Cloud::Translate.translation_service

parent = client.location_path project: project_id, location: location_id

response = client.translate_text parent:               parent,
                                 contents:             contents,
                                 target_language_code: target_language

# Display the translation for each input text provided
response.translations.each do |translation|
  puts "Translated text: #{translation.translated_text}"
end

サポートされている言語の検出

Cloud Translation - Basic では、API でサポートされる言語の一覧を取得するには、次のコードを使用します。

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

  • project-number-or-id: Google Cloud プロジェクト番号または ID

HTTP メソッドと URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

次のコマンドを実行します。

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages " | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

リストは言語コード別にアルファベット順になります。このクエリは、サポートされている言語の ISO-639-1 言語コードを返します。一部の言語コードには zh-CN や zh-TW のような国コードも含まれます。例:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

Java

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<Language> languages = translate.listSupportedLanguages();

for (Language language : languages) {
  System.out.printf("Name: %s, Code: %s\n", language.getName(), language.getCode());
}

Node.js

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

async function listLanguages() {
  // Lists available translation language with their names in English (the default).
  const [languages] = await translate.getLanguages();

  console.log('Languages:');
  languages.forEach(language => console.log(language));
}

listLanguages();

Python

"""Lists all available languages."""
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

results = translate_client.get_languages()

for language in results:
    print(u"{name} ({language})".format(**language))

Cloud Translation - Advanced では、getSupportedLanguages リクエストを行う際に、プロジェクト番号(またはプロジェクト ID)とプロジェクト ロケーション(通常は globalus-central1 のいずれか)を指定する必要があります。

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

  • project-number-or-id: Google Cloud プロジェクト番号または ID

HTTP メソッドと URL:

GET https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

次のコマンドを実行します。

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages

PowerShell

次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global/supportedLanguages " | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

{
  "languages": [
     "languageCode": "af",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "am",
      "supportSource": true,
      "supportTarget": true
    },
    {
      "languageCode": "ar",
      "supportSource": true,
      "supportTarget": true
    },
    ....
    {
      "languageCode": "zu",
      "supportSource": true,
      "supportTarget": true
    }
   ]
}

リストは言語コード別にアルファベット順になります。このクエリは、サポートされている言語の ISO-639-1 言語コードを返します。一部の言語コードには zh-CN や zh-TW のような国コードも含まれます。例:

   {
      "languageCode": "zh-TW",
      "supportSource": true,
      "supportTarget": true
    },

C#

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある C# の設定手順を行ってください。詳細については、Translation C# API のリファレンス ドキュメントをご覧ください。


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class GetSupportedLanguages
    {
        /// <summary>
        /// Getting a list of supported language codes
        /// </summary>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void GetSupportedLanguagesSample(string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            GetSupportedLanguagesRequest request = new GetSupportedLanguagesRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
            };
            SupportedLanguages response = translationServiceClient.GetSupportedLanguages(request);
            // List language codes of supported languages
            foreach (SupportedLanguage language in response.Languages)
            {
                Console.WriteLine($"Language Code: {language.LanguageCode}");
            }
        }
    }

Go

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Go の設定手順を行ってください。詳細については、Translation Go API のリファレンス ドキュメントをご覧ください。

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// getSupportedLanguages gets a list of supported language codes.
func getSupportedLanguages(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.GetSupportedLanguagesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	resp, err := client.GetSupportedLanguages(ctx, req)
	if err != nil {
		return fmt.Errorf("GetSupportedLanguages: %v", err)
	}

	// List language codes of supported languages
	fmt.Fprintf(w, "Supported languages:\n")
	for _, language := range resp.GetLanguages() {
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
	}

	return nil
}

Java

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Java の設定手順を行ってください。詳細については、Translation Java API のリファレンス ドキュメントをご覧ください。

import com.google.cloud.translate.v3.GetSupportedLanguagesRequest;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.SupportedLanguage;
import com.google.cloud.translate.v3.SupportedLanguages;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class GetSupportedLanguages {

  public static void getSupportedLanguages() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    getSupportedLanguages(projectId);
  }

  // Getting a list of supported language codes
  public static void getSupportedLanguages(String projectId) 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 (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");
      GetSupportedLanguagesRequest request =
          GetSupportedLanguagesRequest.newBuilder().setParent(parent.toString()).build();

      SupportedLanguages response = client.getSupportedLanguages(request);

      // List language codes of supported languages
      for (SupportedLanguage language : response.getLanguagesList()) {
        System.out.printf("Language Code: %s\n", language.getLanguageCode());
      }
    }
  }
}

Node.js

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Translation Node.js API のリファレンス ドキュメントをご覧ください。

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function getSupportedLanguages() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
  };

  try {
    // Get supported languages
    const [response] = await translationClient.getSupportedLanguages(request);

    for (const language of response.languages) {
      // Supported language code, generally consisting of its ISO 639-1 identifier, for
      // example, 'en', 'ja'. In certain cases, BCP-47 codes including language and
      // region identifiers are returned (for example, 'zh-TW' and 'zh-CN')
      console.log(`Language - Language Code: ${language.languageCode}`);
      // Human readable name of the language localized in the display language specified
      // in the request.
      console.log(`Language - Display Name: ${language.displayName}`);
      // Can be used as source language.
      console.log(`Language - Support Source: ${language.supportSource}`);
      // Can be used as target language.
      console.log(`Language - Support Target: ${language.supportTarget}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

getSupportedLanguages();

Python

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Translation Python API のリファレンス ドキュメントをご覧ください。

from google.cloud import translate

def get_supported_languages(project_id="YOUR_PROJECT_ID"):
    """Getting a list of supported language codes."""

    client = translate.TranslationServiceClient()

    parent = f"projects/{project_id}"

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.get_supported_languages(parent=parent)

    # List language codes of supported languages.
    print("Supported Languages:")
    for language in response.languages:
        print("Language Code: {}".format(language.language_code))

Ruby

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Ruby の設定手順を行ってください。詳細については、Translation Ruby API のリファレンス ドキュメントをご覧ください。

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

client = Google::Cloud::Translate.translation_service

parent = client.location_path project: project_id, location: location_id

response = client.get_supported_languages parent: parent

# List language codes of supported languages
response.languages.each do |language|
  puts "Language Code: #{language.language_code}"
end

言語の検出

Cloud Translation - Basic で、テキスト内のソース言語を検出するには、次のコードを使用します。

curl

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'q': 'Omnia Gallia est divisa in tres partes',
}" "https://translation.googleapis.com/language/translate/v2/detect"

リクエストが成功すると、サーバーは 200 OK HTTP ステータス コードと JSON 形式のレスポンスを返します。

{
  "data": {
    "detections": [
      [
        {
          "confidence": 0.93554825,
          "isReliable": false,
          "language": "la"
        }
      ]
    ]
  }

Java

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Java の設定手順を行ってください。詳細については、Translation Java API のリファレンス ドキュメントをご覧ください。

// TODO(developer): Uncomment these lines.
// import com.google.cloud.translate.*;
// Translate translate = TranslateOptions.getDefaultInstance().getService();

List<String> texts = new LinkedList<>();
texts.add("Hello, World!");
texts.add("¡Hola Mundo!");
List<Detection> detections = translate.detect(texts);

System.out.println("Language(s) detected:");
for (Detection detection : detections) {
  System.out.printf("\t%s\n", detection);
}

Node.js

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Translation Node.js API のリファレンス ドキュメントをご覧ください。

// Imports the Google Cloud client library
const {Translate} = require('@google-cloud/translate').v2;

// Creates a client
const translate = new Translate();

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const text = 'The text for which to detect language, e.g. Hello, world!';

// Detects the language. "text" can be a string for detecting the language of
// a single piece of text, or an array of strings for detecting the languages
// of multiple texts.
async function detectLanguage() {
  let [detections] = await translate.detect(text);
  detections = Array.isArray(detections) ? detections : [detections];
  console.log('Detections:');
  detections.forEach(detection => {
    console.log(`${detection.input} => ${detection.language}`);
  });
}

detectLanguage();

Python

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Translation Python API のリファレンス ドキュメントをご覧ください。

"""Detects the text's language."""
from google.cloud import translate_v2 as translate

translate_client = translate.Client()

# Text can also be a sequence of strings, in which case this method
# will return a sequence of results for each text.
result = translate_client.detect_language(text)

print("Text: {}".format(text))
print("Confidence: {}".format(result["confidence"]))
print("Language: {}".format(result["language"]))

Cloud Translation - Advanced では、detectLanguage リクエストを行う際に、プロジェクト番号(またはプロジェクト ID)とプロジェクト ロケーション(通常は globalus-central1 のいずれか)を指定する必要があります。

さらに、異なる MIME タイプを送信できるように Cloud Translation - Advanced に送信するリクエストを構成することもできます。たとえば、text/html または text/plain をリクエストできます(デフォルト値は text/html)。

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

  • project-number-or-id: Google Cloud プロジェクト番号または ID

HTTP メソッドと URL:

POST https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage

JSON 本文のリクエスト:

{
   "content":"Доктор Ватсон, иди сюда!"
}

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage

PowerShell

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://translation.googleapis.com/v3/projects/project-number-or-id/locations/global:detectLanguage " | Select-Object -Expand Content

次のような JSON レスポンスが返されます。

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}
レスポンスでは、languageCode で検出された言語の言語コードを返します。confidence には 0 から 1 の範囲の値が入り、1 が 100% の信頼性を意味します。

C#

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある C# の設定手順を行ってください。詳細については、Translation C# API のリファレンス ドキュメントをご覧ください。


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;

namespace GoogleCloudSamples
{
    public static class DetectLanguage
    {
        /// <summary>
        /// Detects the language of a given text.
        /// </summary>
        /// <param name="text">The text string for performing language detection</param>
        /// <param name="projectId">Your Google Cloud Project ID.</param>
        public static void DetectLanguageSample(string text = "[TEXT_STRING_FOR_DETECTION]",
            string projectId = "[Google Cloud Project ID]")
        {
            TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
            DetectLanguageRequest request = new DetectLanguageRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Content = text,
                MimeType = "text/plain",
            };
            DetectLanguageResponse response = translationServiceClient.DetectLanguage(request);
            // Display list of detected languages sorted by detection confidence.
            // The most probable language is first.
            foreach (DetectedLanguage language in response.Languages)
            {
                // The language detected
                Console.WriteLine($"Language code: {language.LanguageCode}");
                // Confidence of detection result for this language
                Console.WriteLine($"Confidence: {language.Confidence}");
            }
        }
    }

Go

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Go の設定手順を行ってください。詳細については、Translation Go API のリファレンス ドキュメントをご覧ください。

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
)

// detectLanguage detects the language of a text string.
func detectLanguage(w io.Writer, projectID string, text string) error {
	// projectID := "my-project-id"
	// text := "Hello, world!"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %v", err)
	}
	defer client.Close()

	req := &translatepb.DetectLanguageRequest{
		Parent:   fmt.Sprintf("projects/%s/locations/global", projectID),
		MimeType: "text/plain", // Mime types: "text/plain", "text/html"
		Source: &translatepb.DetectLanguageRequest_Content{
			Content: text,
		},
	}

	resp, err := client.DetectLanguage(ctx, req)
	if err != nil {
		return fmt.Errorf("DetectLanguage: %v", err)
	}

	// Display list of detected languages sorted by detection confidence.
	// The most probable language is first.
	for _, language := range resp.GetLanguages() {
		// The language detected.
		fmt.Fprintf(w, "Language code: %v\n", language.GetLanguageCode())
		// Confidence of detection result for this language.
		fmt.Fprintf(w, "Confidence: %v\n", language.GetConfidence())
	}

	return nil
}

Node.js

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Translation Node.js API のリファレンス ドキュメントをご覧ください。

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function detectLanguage() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    content: text,
  };

  try {
    // Run request
    const [response] = await translationClient.detectLanguage(request);

    console.log('Detected Languages:');
    for (const language of response.languages) {
      console.log(`Language Code: ${language.languageCode}`);
      console.log(`Confidence: ${language.confidence}`);
    }
  } catch (error) {
    console.error(error.details);
  }
}

detectLanguage();

Python

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Translation Python API のリファレンス ドキュメントをご覧ください。

from google.cloud import translate

def detect_language(project_id="YOUR_PROJECT_ID"):
    """Detecting the language of a text string."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"

    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.detect_language(
        content="Hello, world!",
        parent=parent,
        mime_type="text/plain",  # mime types: text/plain, text/html
    )

    # Display list of detected languages sorted by detection confidence.
    # The most probable language is first.
    for language in response.languages:
        # The language detected
        print("Language code: {}".format(language.language_code))
        # Confidence of detection result for this language
        print("Confidence: {}".format(language.confidence))

Ruby

このサンプルを試す前に、Translation クイックスタート: クライアント ライブラリの使用にある Ruby の設定手順を行ってください。詳細については、Translation Ruby API のリファレンス ドキュメントをご覧ください。

require "google/cloud/translate"

# project_id = "[Google Cloud Project ID]"
# location_id = "[LOCATION ID]"

client = Google::Cloud::Translate.translation_service

# The text string for performing language detection
content = "Hello, world!"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"

parent = client.location_path project: project_id, location: location_id

response = client.detect_language parent:    parent,
                                  content:   content,
                                  mime_type: mime_type

# Display list of detected languages sorted by detection confidence.
# The most probable language is first.
response.languages.each do |language|
  # The language detected
  puts "Language Code: #{language.language_code}"
  # Confidence of detection result for this language
  puts "Confidence: #{language.confidence}"
end