Smartphoneaudio mit optimierten Modellen transkribieren

v1 /speech-to-text/docs/reference/rest/ /speech-to-text/docs/reference/rpc/google.cloud.speech.

In dieser Anleitung wird gezeigt, wie Sie mithilfe von Cloud Speech-to-Text die Audiospur von einem Smartphone transkribieren.

Audiodateien und -daten können aus vielen verschiedenen Quellen stammen, z. B. von der Mailbox eines Smartphones oder von einer Tonspur einer Videodatei.

Speech-to-Text kann eines von mehreren Modellen für maschinelles Lernen verwenden, um Audiodateien so zu transkribieren, dass sie möglichst genau dem ursprünglichen Audiomaterial entsprechen. Sie erhalten bei der Sprachtranskription bessere Ergebnisse, wenn Sie die Quelle dieses Materials angeben. Speech-to-Text kann die Audiodateien dann mit einem Modell für maschinelles Lernen verarbeiten, das speziell für die Art von Daten trainiert wurde, die in der Audiodatei enthalten sind.

Ziele

  • Audiotranskriptionsanfrage für Audiodaten, die von einem Smartphone aufgezeichnet wurden (z. B. Mailboxnachricht), an Speech-to-Text senden
  • Optimiertes Spracherkennungsmodell für eine Audiotranskriptionsanfrage angeben

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten der Cloud Platform verwendet, darunter:

  • Speech-to-Text

Mithilfe des Preisrechners können Sie anhand Ihrer voraussichtlichen Nutzung eine Kostenschätzung erstellen. Neuen Cloud Platform-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Vorbereitung

Diese Anleitung setzt Folgendes voraus:

Anfrage senden

Wenn die mit einem Smartphone aufgenommenen Audiodaten (z. B. ein Anruf oder eine Mailboxnachricht) möglichst genau transkribiert werden sollen, setzen Sie das Feld model in der Nutzlast RecognitionConfig auf phone_model. Das Feld model teilt der Speech-to-Text API mit, welches Spracherkennungsmodell für die Transkriptionsanfrage verwendet werden soll.

Sie können die Ergebnisse der Transkription von Smartphone-Audiodaten verbessern. Verwenden Sie dazu ein optimiertes Modell. Setzen Sie für ein erweitertes Modell das Feld useEnhanced in der RecognitionConfig-Nutzlast auf true.

Die folgenden Codebeispiele zeigen, wie beim Aufrufen von Speech-to-Text ein bestimmtes Transkriptionsmodell ausgewählt wird.

Protokoll

Ausführliche Informationen finden Sie unter dem API-Endpunkt speech:recognize.

Für eine synchrone Spracherkennung senden Sie eine POST-Anfrage und geben den entsprechenden Anfragetext an. Das folgende Beispiel zeigt eine POST-Anfrage mit curl. 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. Anleitungen zur Installation von Cloud SDK, zur Einrichtung eines Projekts mit einem Dienstkonto und zur Anforderung eines Zugriffstokens finden Sie in der Kurzanleitung.

    curl -s -H "Content-Type: application/json" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        https://speech.googleapis.com/v1/speech:recognize \
        --data '{
        "config": {
            "encoding": "LINEAR16",
            "languageCode": "en-US",
            "enableWordTimeOffsets": false,
            "enableAutomaticPunctuation": true,
            "model": "phone_call",
            "useEnhanced": true
        },
        "audio": {
            "uri": "gs://cloud-samples-tests/speech/commercial_mono.wav"
        }
    }'
    

Weitere Informationen zum Konfigurieren des Anfragetexts erhalten Sie in der Referenzdokumentation zu RecognitionConfig.

Wenn die Anfrage erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK und die Antwort im JSON-Format zurück:

    {
      "results": [
        {
          "alternatives": [
            {
              "transcript": "Hi, I'd like to buy a Chromecast. I was wondering whether you could help me with that.",
              "confidence": 0.8930228
            }
          ],
          "resultEndTime": "5.640s"
        },
        {
          "alternatives": [
            {
              "transcript": " Certainly, which color would you like? We are blue black and red.",
              "confidence": 0.9101991
            }
          ],
          "resultEndTime": "10.220s"
        },
        {
          "alternatives": [
            {
              "transcript": " Let's go with the black one.",
              "confidence": 0.8818244
            }
          ],
          "resultEndTime": "13.870s"
        },
        {
          "alternatives": [
            {
              "transcript": " Would you like the new Chromecast Ultra model or the regular Chromecast?",
              "confidence": 0.94733626
            }
          ],
          "resultEndTime": "18.460s"
        },
        {
          "alternatives": [
            {
              "transcript": " Regular Chromecast is fine. Thank you. Okay. Sure. Would you like to ship it regular or Express?",
              "confidence": 0.9519095
            }
          ],
          "resultEndTime": "25.930s"
        },
        {
          "alternatives": [
            {
              "transcript": " Express, please.",
              "confidence": 0.9101229
            }
          ],
          "resultEndTime": "28.260s"
        },
        {
          "alternatives": [
            {
              "transcript": " Terrific. It's on the way. Thank you. Thank you very much. Bye.",
              "confidence": 0.9321616
            }
          ],
          "resultEndTime": "34.150s"
        }
     ]
    }
    

C#

static object SyncRecognizeEnhancedModel(string filePath)
    {
        var speech = SpeechClient.Create();
        var response = speech.Recognize(new RecognitionConfig()
        {
            Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
            SampleRateHertz = 8000,
            LanguageCode = "en-US",
            // Enhanced models are only available for projects that
            // opt into audio data logging.
            UseEnhanced = true,
            // A model must be specified to use an enhanced model.
            Model = "phone_call",
        }, RecognitionAudio.FromFile(filePath));
        foreach (var result in response.Results)
        {
            foreach (var alternative in result.Alternatives)
            {
                Console.WriteLine(alternative.Transcript);
            }
        }
        return 0;
    }

Go


    func enhancedModel(w io.Writer, path string) error {
    	ctx := context.Background()

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

    	// path = "../testdata/commercial_mono.wav"
    	data, err := ioutil.ReadFile(path)
    	if err != nil {
    		return fmt.Errorf("ReadFile: %v", err)
    	}

    	resp, err := client.Recognize(ctx, &speechpb.RecognizeRequest{
    		Config: &speechpb.RecognitionConfig{
    			Encoding:        speechpb.RecognitionConfig_LINEAR16,
    			SampleRateHertz: 8000,
    			LanguageCode:    "en-US",
    			UseEnhanced:     true,
    			// A model must be specified to use enhanced model.
    			Model: "phone_call",
    		},
    		Audio: &speechpb.RecognitionAudio{
    			AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
    		},
    	})
    	if err != nil {
    		return fmt.Errorf("Recognize: %v", err)
    	}

    	for i, result := range resp.Results {
    		fmt.Fprintf(w, "%s\n", strings.Repeat("-", 20))
    		fmt.Fprintf(w, "Result %d\n", i+1)
    		for j, alternative := range result.Alternatives {
    			fmt.Fprintf(w, "Alternative %d: %s\n", j+1, alternative.Transcript)
    		}
    	}
    	return nil
    }
    

Java

/*
     * Please include the following imports to run this sample.
     *
     * import com.google.cloud.speech.v1.RecognitionAudio;
     * import com.google.cloud.speech.v1.RecognitionConfig;
     * import com.google.cloud.speech.v1.RecognizeRequest;
     * import com.google.cloud.speech.v1.RecognizeResponse;
     * import com.google.cloud.speech.v1.SpeechClient;
     * import com.google.cloud.speech.v1.SpeechRecognitionAlternative;
     * import com.google.cloud.speech.v1.SpeechRecognitionResult;
     * import com.google.protobuf.ByteString;
     * import java.nio.file.Files;
     * import java.nio.file.Path;
     * import java.nio.file.Paths;
     */

    public static void sampleRecognize() {
      // TODO(developer): Replace these variables before running the sample.
      String localFilePath = "resources/hello.wav";
      String model = "phone_call";
      sampleRecognize(localFilePath, model);
    }

    /**
     * Transcribe a short audio file using a specified transcription model
     *
     * @param localFilePath Path to local audio file, e.g. /path/audio.wav
     * @param model The transcription model to use, e.g. video, phone_call, default For a list of
     *     available transcription models, see:
     *     https://cloud.google.com/speech-to-text/docs/transcription-model#transcription_models
     */
    public static void sampleRecognize(String localFilePath, String model) {
      try (SpeechClient speechClient = SpeechClient.create()) {

        // The language of the supplied audio
        String languageCode = "en-US";
        RecognitionConfig config =
            RecognitionConfig.newBuilder().setModel(model).setLanguageCode(languageCode).build();
        Path path = Paths.get(localFilePath);
        byte[] data = Files.readAllBytes(path);
        ByteString content = ByteString.copyFrom(data);
        RecognitionAudio audio = RecognitionAudio.newBuilder().setContent(content).build();
        RecognizeRequest request =
            RecognizeRequest.newBuilder().setConfig(config).setAudio(audio).build();
        RecognizeResponse response = speechClient.recognize(request);
        for (SpeechRecognitionResult result : response.getResultsList()) {
          // First alternative is the most probable result
          SpeechRecognitionAlternative alternative = result.getAlternativesList().get(0);
          System.out.printf("Transcript: %s\n", alternative.getTranscript());
        }
      } catch (Exception exception) {
        System.err.println("Failed to create the client due to: " + exception);
      }
    }

Node.js

// Imports the Google Cloud client library for Beta API
    /**
     * TODO(developer): Update client library import to use new
     * version of API when desired features become available
     */
    const speech = require('@google-cloud/speech').v1p1beta1;
    const fs = require('fs');

    // Creates a client
    const client = new speech.SpeechClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const filename = 'Local path to audio file, e.g. /path/to/audio.raw';
    // const model = 'Model to use, e.g. phone_call, video, default';
    // const encoding = 'Encoding of the audio file, e.g. LINEAR16';
    // const sampleRateHertz = 16000;
    // const languageCode = 'BCP-47 language code, e.g. en-US';

    const config = {
      encoding: encoding,
      sampleRateHertz: sampleRateHertz,
      languageCode: languageCode,
      model: model,
    };
    const audio = {
      content: fs.readFileSync(filename).toString('base64'),
    };

    const request = {
      config: config,
      audio: audio,
    };

    // Detects speech in the audio file
    const [response] = await client.recognize(request);
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log('Transcription: ', transcription);

Python

from google.cloud import speech_v1
    import io

    def sample_recognize(local_file_path, model):
        """
        Transcribe a short audio file using a specified transcription model

        Args:
          local_file_path Path to local audio file, e.g. /path/audio.wav
          model The transcription model to use, e.g. video, phone_call, default
          For a list of available transcription models, see:
          https://cloud.google.com/speech-to-text/docs/transcription-model#transcription_models
        """

        client = speech_v1.SpeechClient()

        # local_file_path = 'resources/hello.wav'
        # model = 'phone_call'

        # The language of the supplied audio
        language_code = "en-US"
        config = {"model": model, "language_code": language_code}
        with io.open(local_file_path, "rb") as f:
            content = f.read()
        audio = {"content": content}

        response = client.recognize(config, audio)
        for result in response.results:
            # First alternative is the most probable result
            alternative = result.alternatives[0]
            print(u"Transcript: {}".format(alternative.transcript))

    

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Platform-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite "Ressourcen verwalten"

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Instanzen löschen

So löschen Sie eine Compute Engine-Instanz:

  1. Öffnen Sie in der Cloud Console die Seite VM-Instanzen.

    Zur Seite "VM-Instanzen"

  2. Klicken Sie auf das Kästchen für die Instanz, die Sie löschen möchten.
  3. Klicken Sie auf Löschen , um die Instanz zu löschen.

Firewallregeln für das Standardnetzwerk löschen

So löschen Sie eine Firewallregel:

  1. Rufen Sie in der Cloud Console die Seite Firewallregeln auf.

    Zur Seite "Firewallregeln"

  2. Klicken Sie auf das Kästchen für die Firewallregel, die Sie löschen möchten.
  3. Klicken Sie auf Löschen , um die Firewallregel zu löschen.