Trascrizione dell'audio telefonico con modelli avanzati

Questo tutorial mostra come trascrivere l'audio registrato da uno smartphone utilizzando Speech-to-Text.

I file audio possono provenire da molte fonti diverse. I dati audio possono provenire da un telefono (ad esempio, la segreteria telefonica) o da una colonna sonora inclusa in un file video.

Speech-to-Text può utilizzare uno dei diversi modelli di machine learning per trascrivere il file audio in modo da corrispondere al meglio alla fonte originale dell'audio. Puoi ottenere risultati migliori dalla trascrizione vocale specificando la sorgente dell'audio originale. In questo modo, Speech-to-Text può elaborare i tuoi file audio utilizzando un modello di machine learning addestrato per dati simili al tuo file audio.

Attenzione: questo tutorial utilizza il modello di riconoscimento vocale avanzato. Speech-to-Text dispone di due tipi di modello di chiamata che puoi utilizzare per il riconoscimento vocale: un modello standard e un modello avanzato. Il modello avanzato può fornire risultati migliori a un prezzo più elevato (anche se puoi ridurre il prezzo attivando la registrazione dei dati).

Inviare una richiesta

Per trascrivere al meglio l'audio acquisito su uno smartphone, ad esempio una chiamata o un messaggio vocale, puoi impostare il campo model nel payload RecognitionConfig su phone_call. Il campo model indica all'API Speech-to-Text quale modello di riconoscimento vocale utilizzare per la richiesta di trascrizione.

Nota: consulta la pagina Lingue supportate per vedere quali modelli sono disponibili nella tua lingua.

Puoi migliorare i risultati della trascrizione dell'audio telefonico utilizzando un modello avanzato. Per utilizzare un modello migliorato, imposta il campo useEnhanced su true nel payload RecognitionConfig.

Nota: se non vuoi utilizzare il modello avanzato in questo tutorial, puoi rimuovere il campo useEnhanced dalla richiesta a Speech-to-Text.

I seguenti esempi di codice mostrano come selezionare un modello di trascrizione specifico quando chiami Speech-to-Text.

Protocollo

Per informazioni dettagliate, consulta l'endpoint API speech:recognize.

Per eseguire il riconoscimento vocale sincrono, invia una richiesta POST e fornisci il corpo della richiesta appropriato. Di seguito è riportato un esempio di richiesta POST mediante curl. L'esempio utilizza Google Cloud CLI per generare un token di accesso. Per istruzioni sull'installazione di gcloud CLI, consulta la guida rapida.

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"
    }
}'

Per ulteriori informazioni sulla configurazione del corpo della richiesta, consulta la documentazione di riferimento RecognitionConfig.

Se la richiesta riesce, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato JSON:

{
  "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"
    }
 ]
}

Go

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta la sezione Librerie client Speech-to-Text. Per saperne di più, consulta la documentazione di riferimento dell'API Speech-to-Text Go.

Per eseguire l'autenticazione in Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

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

	data, err := os.ReadFile("../testdata/commercial_mono.wav")
	if err != nil {
		return fmt.Errorf("ReadFile: %w", 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("client.Recognize: %w", 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

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta la sezione Librerie client Speech-to-Text. Per saperne di più, consulta la documentazione di riferimento dell'API Speech-to-Text Java.

Per eseguire l'autenticazione in Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * Transcribe the given audio file using an enhanced model.
 *
 * @param fileName the path to an audio file.
 */
public static void transcribeFileWithEnhancedModel(String fileName) throws Exception {
  Path path = Paths.get(fileName);
  byte[] content = Files.readAllBytes(path);

  try (SpeechClient speechClient = SpeechClient.create()) {
    // Get the contents of the local audio file
    RecognitionAudio recognitionAudio =
        RecognitionAudio.newBuilder().setContent(ByteString.copyFrom(content)).build();

    // Configure request to enable enhanced models
    RecognitionConfig config =
        RecognitionConfig.newBuilder()
            .setEncoding(AudioEncoding.LINEAR16)
            .setLanguageCode("en-US")
            .setSampleRateHertz(8000)
            .setUseEnhanced(true)
            // A model must be specified to use enhanced model.
            .setModel("phone_call")
            .build();

    // Perform the transcription request
    RecognizeResponse recognizeResponse = speechClient.recognize(config, recognitionAudio);

    // Print out the results
    for (SpeechRecognitionResult result : recognizeResponse.getResultsList()) {
      // There can be several alternative transcripts for a given chunk of speech. Just use the
      // first (most likely) one here.
      SpeechRecognitionAlternative alternative = result.getAlternatives(0);
      System.out.format("Transcript: %s\n\n", alternative.getTranscript());
    }
  }
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta la sezione Librerie client Speech-to-Text. Per saperne di più, consulta la documentazione di riferimento dell'API Speech-to-Text Node.js.

Per eseguire l'autenticazione in Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

// 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 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,
  languageCode: languageCode,
  useEnhanced: true,
  model: 'phone_call',
};
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);
response.results.forEach(result => {
  const alternative = result.alternatives[0];
  console.log(alternative.transcript);
});

Python

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, consulta la sezione Librerie client Speech-to-Text. Per saperne di più, consulta la documentazione di riferimento dell'API Speech-to-Text Python.

Per eseguire l'autenticazione in Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import speech


def transcribe_file_with_enhanced_model(audio_file: str) -> speech.RecognizeResponse:
    """Transcribe the given audio file using an enhanced model.
    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/commercial_mono.wav"
    Returns:
        speech.RecognizeResponse: The response containing the transcription results.
    """

    client = speech.SpeechClient()

    # audio_file = 'resources/commercial_mono.wav'
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    audio = speech.RecognitionAudio(content=audio_content)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
        sample_rate_hertz=8000,
        language_code="en-US",
        use_enhanced=True,
        # A model must be specified to use enhanced model.
        model="phone_call",
    )

    response = client.recognize(config=config, audio=audio)

    for i, result in enumerate(response.results):
        alternative = result.alternatives[0]
        print("-" * 20)
        print(f"First alternative of result {i}")
        print(f"Transcript: {alternative.transcript}")

    return response

Linguaggi aggiuntivi

C#: Segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi visita la documentazione di riferimento di Speech-to-Text per .NET.

PHP: Segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Speech-to-Text per PHP.

Ruby: Segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di Speech-to-Text per Ruby.

Attenzione: i modelli avanzati costano di più rispetto a quelli standard. Per ulteriori dettagli, consulta la pagina Prezzi.