Transcribe a local file using an enhanced speech recognition model

  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 
 } 
 

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

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

  use Google\Cloud\Speech\V1\SpeechClient; 
 use Google\Cloud\Speech\V1\RecognitionAudio; 
 use Google\Cloud\Speech\V1\RecognitionConfig; 
 use Google\Cloud\Speech\V1\RecognitionConfig\AudioEncoding; 
 /** 
 * @param string $audioFile path to an audio file 
 */ 
 function transcribe_enhanced_model(string $audioFile) 
 { 
 // change these variables if necessary 
 $encoding = AudioEncoding::LINEAR16; 
 $sampleRateHertz = 8000; 
 $languageCode = 'en-US'; 
 // get contents of a file into a string 
 $content = file_get_contents($audioFile); 
 // set string as audio content 
 $audio = (new RecognitionAudio()) 
 ->setContent($content); 
 // set config 
 $config = (new RecognitionConfig()) 
 ->setEncoding($encoding) 
 ->setSampleRateHertz($sampleRateHertz) 
 ->setLanguageCode($languageCode) 
 ->setUseEnhanced(true) 
 ->setModel('phone_call'); 
 // create the speech client 
 $client = new SpeechClient(); 
 // make the API call 
 $response = $client->recognize($config, $audio); 
 $results = $response->getResults(); 
 // print results 
 foreach ($results as $result) { 
 $alternatives = $result->getAlternatives(); 
 $mostLikely = $alternatives[0]; 
 $transcript = $mostLikely->getTranscript(); 
 $confidence = $mostLikely->getConfidence(); 
 printf('Transcript: %s' . PHP_EOL, $transcript); 
 printf('Confidence: %s' . PHP_EOL, $confidence); 
 } 
 $client->close(); 
 } 
 

  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 
 

  # audio_file_path = "path/to/audio.wav" 
 require 
  
 "google/cloud/speech" 
 speech 
  
 = 
  
 Google 
 :: 
 Cloud 
 :: 
  Speech 
 
 . 
  speech 
 
  
 version 
 : 
  
 :v1 
 config 
  
 = 
  
 { 
  
 encoding 
 : 
  
 :LINEAR16 
 , 
  
 sample_rate_hertz 
 : 
  
 8000 
 , 
  
 language_code 
 : 
  
 "en-US" 
 , 
  
 use_enhanced 
 : 
  
 true 
 , 
  
 model 
 : 
  
 "phone_call" 
 } 
 audio_file 
  
 = 
  
 File 
 . 
 binread 
  
 audio_file_path 
 audio 
  
 = 
  
 { 
  
 content 
 : 
  
 audio_file 
  
 } 
 operation 
  
 = 
  
 speech 
 . 
 long_running_recognize 
  
 config 
 : 
  
 config 
 , 
  
 audio 
 : 
  
 audio 
 puts 
  
 "Operation started" 
 operation 
 . 
 wait_until_done! 
 raise 
  
 operation 
 . 
 results 
 . 
 message 
  
 if 
  
 operation 
 . 
 error? 
 results 
  
 = 
  
 operation 
 . 
 response 
 . 
 results 
 results 
 . 
 each_with_index 
  
 do 
  
 | 
 result 
 , 
  
 i 
 | 
  
 alternative 
  
 = 
  
 result 
 . 
 alternatives 
 . 
 first 
  
 puts 
  
 "-" 
  
 * 
  
 20 
  
 puts 
  
 "First alternative of result 
 #{ 
 i 
 } 
 " 
  
 puts 
  
 "Transcript: 
 #{ 
 alternative 
 . 
 transcript 
 } 
 " 
 end