使用模型翻译输入的文本。
包含此代码示例的文档页面
如需查看上下文中使用的代码示例,请参阅以下文档:
代码示例
C#
在试用此示例之前,请按照《Translation 快速入门:使用客户端库》中的 C# 设置说明进行操作。如需了解详情,请参阅 Translation C# API 参考文档。
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Translate.V3;
using System;
namespace GoogleCloudSamples
{
public static class TranslateTextWithModel
{
/// <summary>
/// Translates a given text to a target language with custom model.
/// </summary>
/// <param name="modelId">Translation Model ID.</param>
/// <param name="text">The content to translate.t</param>
/// <param name="targetLanguage">Required. Target language code.</param>
/// <param name="sourceLanguage">Optional. Source language code.</param>
/// <param name="projectId"> Google Project ID.</param>
/// <param name="location"> Region.</param>
public static void TranslateTextWithModelSample(
string modelId = "[YOUR_MODEL_ID]",
string text = "[TEXT_TO_TRANSLATE]",
string targetLanguage = "ja",
string sourceLanguage = "en",
string projectId = "[Google Cloud Project ID]",
string location = "us-central1")
{
TranslationServiceClient translationServiceClient = TranslationServiceClient.Create();
string modelPath = $"projects/{projectId}/locations/{location}/models/{modelId}";
TranslateTextRequest request = new TranslateTextRequest
{
Contents =
{
// The content to translate.
text,
},
TargetLanguageCode = targetLanguage,
ParentAsLocationName = new LocationName(projectId, location),
Model = modelPath,
SourceLanguageCode = sourceLanguage,
MimeType = "text/plain",
};
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"
)
// translateTextWithModel translates input text and returns translated text.
func translateTextWithModel(w io.Writer, projectID string, location string, sourceLang string, targetLang string, text string, modelID string) error {
// projectID := "my-project-id"
// location := "us-central1"
// sourceLang := "en"
// targetLang := "fr"
// text := "Hello, world!"
// modelID := "your-model-id"
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/%s", projectID, location),
SourceLanguageCode: sourceLang,
TargetLanguageCode: targetLang,
MimeType: "text/plain", // Mime types: "text/plain", "text/html"
Contents: []string{text},
Model: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
}
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 TranslateTextWithModel {
public static void translateTextWithModel() 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 sourceLanguage = "your-source-language";
String targetLanguage = "your-target-language";
String text = "your-text";
String modelId = "YOUR-MODEL-ID";
translateTextWithModel(projectId, sourceLanguage, targetLanguage, text, modelId);
}
// Translating Text with Model
public static void translateTextWithModel(
String projectId, String sourceLanguage, String targetLanguage, String text, 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 (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)
String location = "us-central1";
LocationName parent = LocationName.of(projectId, location);
String modelPath =
String.format("projects/%s/locations/%s/models/%s", projectId, location, modelId);
// Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
TranslateTextRequest request =
TranslateTextRequest.newBuilder()
.setParent(parent.toString())
.setMimeType("text/plain")
.setSourceLanguageCode(sourceLanguage)
.setTargetLanguageCode(targetLanguage)
.addContents(text)
.setModel(modelPath)
.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 = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// 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 translateTextWithModel() {
// Construct request
const request = {
parent: `projects/${projectId}/locations/${location}`,
contents: [text],
mimeType: 'text/plain', // mime types: text/plain, text/html
sourceLanguageCode: 'en',
targetLanguageCode: 'ja',
model: `projects/${projectId}/locations/${location}/models/${modelId}`,
};
try {
// Run request
const [response] = await translationClient.translateText(request);
for (const translation of response.translations) {
console.log(`Translated Content: ${translation.translatedText}`);
}
} catch (error) {
console.error(error.details);
}
}
translateTextWithModel();
PHP
在试用此示例之前,请按照《Translation 快速入门:使用客户端库》中的 PHP 设置说明进行操作。如需了解详情,请参阅 Translation PHP API 参考文档。
use Google\Cloud\Translate\V3\TranslationServiceClient;
$translationServiceClient = new TranslationServiceClient();
/** Uncomment and populate these variables in your code */
// $modelId = '[MODEL ID]';
// $text = 'Hello, world!';
// $targetLanguage = 'fr';
// $sourceLanguage = 'en';
// $projectId = '[Google Cloud Project ID]';
// $location = 'global';
$modelPath = sprintf(
'projects/%s/locations/%s/models/%s',
$projectId,
$location,
$modelId
);
$contents = [$text];
$formattedParent = $translationServiceClient->locationName(
$projectId,
$location
);
// Optional. Can be "text/plain" or "text/html".
$mimeType = 'text/plain';
try {
$response = $translationServiceClient->translateText(
$contents,
$targetLanguage,
$formattedParent,
[
'model' => $modelPath,
'sourceLanguageCode' => $sourceLanguage,
'mimeType' => $mimeType
]
);
// Display the translation for each input text provided
foreach ($response->getTranslations() as $translation) {
printf('Translated text: %s' . PHP_EOL, $translation->getTranslatedText());
}
} finally {
$translationServiceClient->close();
}
Python
在试用此示例之前,请按照《Translation 快速入门:使用客户端库》中的 Python 设置说明进行操作。如需了解详情,请参阅 Translation Python API 参考文档。
from google.cloud import translate
def translate_text_with_model(
text="YOUR_TEXT_TO_TRANSLATE",
project_id="YOUR_PROJECT_ID",
model_id="YOUR_MODEL_ID",
):
"""Translates a given text using Translation custom model."""
client = translate.TranslationServiceClient()
location = "us-central1"
parent = f"projects/{project_id}/locations/{location}"
model_path = f"{parent}/models/{model_id}"
# Supported language codes: https://cloud.google.com/translate/docs/languages
response = client.translate_text(
request={
"contents": [text],
"target_language_code": "ja",
"model": model_path,
"source_language_code": "en",
"parent": parent,
"mime_type": "text/plain", # mime types: text/plain, text/html
}
)
# 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]"
# model_id = "[MODEL ID]"
# The `model` type requested for this translation.
model = "projects/#{project_id}/locations/#{location_id}/models/#{model_id}"
# The content to translate in string format
contents = ["Hello, world!"]
# Required. The BCP-47 language code to use for translation.
target_language = "fr"
# Optional. The BCP-47 language code of the input text.
source_language = "en"
# Optional. Can be "text/plain" or "text/html".
mime_type = "text/plain"
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,
source_language_code: source_language,
model: model,
mime_type: mime_type
# Display the translation for each input text provided
response.translations.each do |translation|
puts "Translated text: #{translation.translated_text}"
end