Traduzione di testo (avanzato)

Cloud Translation - Advanced supporta la traduzione del testo utilizzando modelli personalizzati e per la creazione di glossari per garantire che l'API Cloud Translation traduca correttamente la terminologia specifica del dominio di un cliente.

Per istruzioni sull'installazione di Google Cloud CLI, sulla configurazione di un progetto con un account di servizio e sull'ottenimento di un token di accesso, consulta la pagina Configurazione. Se prevedi di utilizzare un glossario o le funzionalità batch, devi anche creare un bucket Cloud Storage e concedere al tuo account di servizio l'accesso.

Per tradurre documenti formattati, ad esempio PDF, vedi Traduzione di documenti.

Prima di iniziare

Per iniziare a utilizzare l'API Cloud Translation, devi avere un progetto in cui sia abilitata l'API Cloud Translation e disporre delle credenziali appropriate. Puoi anche installare librerie client per linguaggi di programmazione comuni per facilitare le chiamate all'API. Per saperne di più, consulta la pagina Configurazione.

Confronto di modelli

Quando richiedi la traduzione da Cloud Translation - Advanced, puoi specificare il modello di traduzione da utilizzare. Se non viene specificato alcun modello, viene utilizzato il modello nmt.

Modello Ideale per te Esempi
Modello di traduzione automatica neurale (NMT)

Esempi di casi d'uso di testo generici, come i contenuti comuni di un sito web non specifici di un dominio, ad esempio articoli di notizie.

Articoli di notizie, social media, applicazioni di chat, recensioni

Modello di traduzione automatica Testo specifico del dominio. I clienti forniscono dati di addestramento specifici per i propri casi d'uso, per determinate coppie di lingue, al fine di personalizzare il modello NMT di Google per lo scopo del dominio. Notizie finanziarie, documenti tecnici e qualsiasi testo che utilizzi termini e tecnicismi specifici.

Devi specificare il modello di traduzione utilizzando il relativo ID modello. Per il modello NMT, l'ID modello è general/nmt. Consulta la sezione successiva per informazioni sugli ID modello di traduzione AutoML.

Traduzione di testo

Il testo di input può essere testo normale o HTML. L'API Cloud Translation non traduce alcun tag HTML nell'input, ma solo il testo visualizzato tra i tag. L'output conserva i tag HTML (non tradotti), con il testo tradotto tra i tag, nella misura possibile a causa delle differenze tra le lingue di origine e di destinazione. L'ordine dei tag HTML nell'output può differire dall'ordine nel testo di input a causa di modifiche all'ordine delle parole nella traduzione.

Traduzione delle stringhe di input

REST

Per tradurre il testo, effettua una richiesta POST e fornisci un testo JSON nel corpo della richiesta che identifichi la lingua di origine (source_language_code), la lingua di destinazione (target_language_code) e il testo di destinazione (contents). Puoi fornire più stringhe di testo da tradurre, incluse nel file JSON (vedi l'esempio). Per identificare le lingue di origine e di destinazione, utilizza i loro codici ISO-639.

Di seguito è riportato un esempio di richiesta POST mediante curl o PowerShell. L'esempio utilizza il token di accesso per un account di servizio configurato per il progetto utilizzando Google Cloud CLI. Per istruzioni sull'installazione di Google Cloud CLI, sulla configurazione di un progetto con un account di servizio e sull'ottenimento di un token di accesso, consulta la pagina Configurazione.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: numero o ID del tuo progetto Google Cloud

Metodo e URL HTTP:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID:translateText

Corpo JSON richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

L'array translations contiene due campi translatedText con traduzioni fornite nella lingua richiesta targetLanguageCode (ru: russo). Le traduzioni sono elencate nello stesso ordine dell'array di origine corrispondente nella richiesta.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// Imports the Google Cloud Translation library
import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

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"

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

	// Construct request
	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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// Imports the Google Cloud Translation library.
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 {

  // Set and pass variables to overloaded translateText() method for translation.
  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);
  }

  // Translate text to target language.
  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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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',
  };

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

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

translateText();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

# Imports the Google Cloud Translation library
from google.cloud import translate

# Initialize Translation client
def translate_text(
        text: str = "YOUR_TEXT_TO_TRANSLATE",
        project_id: str = "YOUR_PROJECT_ID"
) -> translate.TranslationServiceClient:
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

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

    # Translate text from English to French
    # 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(f"Translated text: {translation.translated_text}")

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per Ruby.

Traduzione di testo utilizzando un modello personalizzato

REST

Puoi specificare il modello da utilizzare per la traduzione utilizzando il parametro di ricerca model.

L'esempio seguente traduce il testo utilizzando un modello personalizzato con ID modello 1395675701985363739. Puoi ottenere l'ID di un modello personalizzato dall'elenco dei modelli nella console Google Cloud o dalla risposta dell'API durante l'addestramento del modello.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_ID: il tuo ID progetto Google Cloud.
  • LOCATION: la regione in cui si trova il modello personalizzato, ad esempio us-central1.

Metodo e URL HTTP:

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:translateText

Corpo JSON richiesta:

{
  "model": "projects/PROJECT_ID/locations/LOCATION/models/1395675701985363739",
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, please discard your trash. You've shared unsolicited email with me.
  Let's talk about spam and importance ranking in a confidential mode."]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

ricci

Salva il corpo della richiesta in un file denominato request.json ed esegui il seguente comando:

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_ID/locations/LOCATION:translateText"

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui il seguente comando:

$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_ID/locations/LOCATION:translateText" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translation": {
    "translatedText": "Доктор Ватсон, пожалуйста, откажитесь от своего мусора.
    Вы поделились нежелательной электронной почтой со мной. Давайте поговорим о
    спаме и важности рейтинга в конфиденциальном режиме.",
    "model": "projects/PROJECT_NUMBER/locations/LOCATION/models/1395675701985363739"
  }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Go.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// 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: %w", 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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Java.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Node.js.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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}`,
  };

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

  for (const translation of response.translations) {
    console.log(`Translated Content: ${translation.translatedText}`);
  }
}

translateTextWithModel();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation utilizzando le librerie client. Per scoprire di più, consulta la documentazione di riferimento per l'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


from google.cloud import translate

def translate_text_with_model(
    text: str = "YOUR_TEXT_TO_TRANSLATE",
    project_id: str = "YOUR_PROJECT_ID",
    model_id: str = "YOUR_MODEL_ID",
) -> translate.TranslationServiceClient:
    """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(f"Translated text: {translation.translated_text}")

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per Ruby.

Traslitterazione

La traslitterazione è un'impostazione di configurazione del metodo translateText. Quando attivi la traslitterazione, traduci il testo romanizzato (alfabeto latino) direttamente in una lingua di destinazione. Ad esempio, puoi tradurre il testo giapponese in romanzo direttamente in inglese, spagnolo o cinese. Le traduzioni risultanti sono nel sistema di scrittura della lingua di destinazione.

Nelle richieste di traslitterazione, includi solo il testo in caratteri romani. Se combini testo romanizzato con testo non romanizzato, Cloud Translation non può garantire traduzioni coerenti e corrette.

Considerazioni

La traslitterazione si differenzia dalle traduzioni di testo standard per i seguenti aspetti:

  • La traslitterazione supporta un numero limitato di lingue. Per scoprire di più, consulta la colonna Translitterazione nella pagina Lingue supportate.
  • Il tipo MIME deve essere text/plain. HTML non supportato.
  • La traslitterazione è supportata solo dal modello standard predefinito. I modelli personalizzati non sono supportati.
  • La traslitterazione ha una quota di contenuti predefinita inferiore. Per ulteriori informazioni, consulta Quote e limiti.

REST

Imposta il campo transliteration_config sul metodo translateText.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: numero o ID del tuo progetto Google Cloud
  • LOCATION: regione in cui vuoi eseguire questa operazione. Ad esempio, us-central1.
  • SOURCE_LANGUAGE: (facoltativo) il codice lingua del testo di input. Se noto, imposta uno dei codici lingua elencati in Lingue supportate.
  • TARGET_LANGUAGE: la lingua di destinazione in cui tradurre il testo di input. Imposta uno dei codici lingua elencati in Lingue supportate.
  • SOURCE_TEXT: testo in caratteri romani nella lingua di origine da tradurre.

Metodo e URL HTTP:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateText

Corpo JSON richiesta:

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE",
  "contents": "SOURCE_TEXT",
  "mime_type": "text/plain",
  "transliteration_config": { "enable_transliteration": true}
}

Per inviare la richiesta, espandi una delle seguenti opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT",
    }
  ]
}

Risorse aggiuntive

  • Per assistenza sulla risoluzione dei problemi o degli errori più comuni, consulta la pagina Risoluzione dei problemi.