Sprachen erkennen (Advanced)

In diesem Dokument wird beschrieben, wie Sie mithilfe von Cloud Translation Advanced die Sprache eines Strings erkennen.

Hinweis: Weitere Informationen zu den Unterschieden zwischen Basic und Advanced finden Sie unter Zu Translation Advanced migrieren.

Hinweis

Bevor Sie die Cloud Translation API verwenden können, muss ein Projekt aktiviert sein, für das die Cloud Translation API aktiviert ist. Außerdem benötigen Sie einen privaten Schlüssel mit den entsprechenden Anmeldedaten. Sie können auch Clientbibliotheken für gängige Programmiersprachen installieren, um Aufrufe in der API zu erhalten. Weitere Informationen finden Sie auf der Seite Einrichtung.

Sprache eines Textstrings erkennen

Sie können die Sprache eines Textstrings erkennen, indem Sie eine HTTP-Anfrage mit einer URL im folgenden Format senden:

https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage

Hinweis: project-id funktioniert auch, aber project-number wird in Zukunft bevorzugt.

Sprache eines einzelnen Strings erkennen

REST UND BEFEHLSZEILE

Um die Sprache eines Textes zu erkennen, können Sie eine POST-Anfrage mit dem entsprechenden Anfragetext stellen. Das folgende Beispiel zeigt eine POST-Anfrage mit curl und PowerShell. In diesem Beispiel wird das Zugriffstoken für ein Dienstkonto verwendet, das mit dem Cloud SDK von Google Cloud für das Projekt eingerichtet wurde. Eine Anleitung zum Installieren des Cloud SDK, zum Einrichten eines Projekts mit einem Dienstkonto und zum Abrufen eines Zugriffstokens finden Sie auf der Seite Einrichtung.

Ersetzen Sie diese Werte in den folgenden Anweisungen:

• PROJECT_NUMBER_OR_ID: Ihre Google Cloud-Projektnummer oder -ID

HTTP-Methode und URL:

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/global:detectLanguage

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Hinweis: Legen Sie für die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS den Pfad zur privaten Schlüsseldatei des Dienstkontos fest.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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

Hinweis: Legen Sie für die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS den Pfad zur privaten Schlüsseldatei des Dienstkontos fest.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "languages": [
    {
      "languageCode": "ru",
      "confidence": 1
    }
  ]
}

In der Antwort wird mit languageCode der Sprachcode der erkannten Sprache angegeben. Für confidence gilt ein Bereich von 0 bis 1. Bei 1 beträgt der Konfidenzwert 100 %.

Go

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Go in der Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Go.

Auf GitHub ansehen Feedback

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
}

Java

Folgen Sie der Einrichtungsanleitung für Java in der Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel ausprobieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Java.

Auf GitHub ansehen Feedback

import com.google.cloud.translate.v3.DetectLanguageRequest;
import com.google.cloud.translate.v3.DetectLanguageResponse;
import com.google.cloud.translate.v3.DetectedLanguage;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class DetectLanguage {

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

    detectLanguage(projectId, text);
  }

  // Detecting the language of a text string
  public static void detectLanguage(String projectId, 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
      DetectLanguageRequest request =
          DetectLanguageRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setContent(text)
              .build();

      DetectLanguageResponse response = client.detectLanguage(request);

      // Display list of detected languages sorted by detection confidence.
      // The most probable language is first.
      for (DetectedLanguage language : response.getLanguagesList()) {
        // The language detected
        System.out.printf("Language code: %s\n", language.getLanguageCode());
        // Confidence of detection result for this language
        System.out.printf("Confidence: %s\n", language.getConfidence());
      }
    }
  }
}

Node.js

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Node.js in der Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Node.js.

Auf GitHub ansehen Feedback

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

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

detectLanguage();

Python

Bevor Sie dieses Beispiel testen, folgen Sie der Einrichtungsanleitung für Python in der Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Translation API für Python.

Auf GitHub ansehen Feedback

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

Weitere Sprachen

C# : Bitte folgen Sie C#-Einrichtungsanleitung auf der Seite "Clientbibliotheken" ansehen. Referenzdokumentation zur Übersetzung für .NET.

PHP : Bitte folgen Sie PHP-Einrichtungsanleitung auf der Seite "Clientbibliotheken" ansehen.Referenzdokumentation zur Übersetzung für PHP

Ruby : Bitte folgen Sie Anleitung zum Einrichten von Ruby auf der Seite "Clientbibliotheken" ansehen.Referenzdokumentation zu Translation für Ruby

Weitere Informationen

• Hilfe zur Behebung häufiger Probleme und zu Fehlern finden Sie auf der Seite Fehlerbehebung.