def transcribe_file(speech_file, num_speakers): """Transcribe the given audio file asynchronously.""" # Imports the Google Cloud client library #from google.cloud import speech from google.cloud import speech_v1p1beta1 as speech # Instantiates a client client = speech.SpeechClient() # The name of the audio file to transcribe file_name = os.path.join(os.path.dirname(__file__), "resources", "audio.raw") # Loads the audio into memory with io.open(speech_file, "rb") as audio_file: content = audio_file.read() # Construct a recognition metadata object metadata = speech.RecognitionMetadata() metadata.interaction_type = speech.RecognitionMetadata.InteractionType.DISCUSSION metadata.recording_device_type = ( speech.RecognitionMetadata.RecordingDeviceType.OTHER_INDOOR_DEVICE ) metadata.audio_topic = "court trial hearing" metadata.original_mime_type = "audio/mp3" audio = speech.RecognitionAudio(content=content) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.FLAC, sample_rate_hertz=16000, language_code="en-US", enable_automatic_punctuation=True, enable_speaker_diarization=True, diarization_speaker_count=num_speakers, # Enhanced models cost more than standard models. use_enhanced=True, model="video", enable_word_time_offsets=True, ) # Detects speech in the audio file -- short audio file print("Waiting for operation to complete...") response = client.recognize(config=config, audio=audio) result = response.results[-1] words_info = result.alternatives[0].words # Printing out the output: for word_info in words_info: print( u"word: '{}', speaker_tag: {}, start_time:{}, end_time:{}".format(word_info.word, word_info.speaker_tag, word_info.start_time.total_seconds(), word_info.end_time.total_seconds()) )
def transcribe_file_with_metadata(): """Send a request that includes recognition metadata.""" # [START speech_transcribe_recognition_metadata_beta] from google.cloud import speech_v1p1beta1 as speech client = speech.SpeechClient() speech_file = "resources/commercial_mono.wav" with io.open(speech_file, "rb") as audio_file: content = audio_file.read() # Here we construct a recognition metadata object. # Most metadata fields are specified as enums that can be found # in speech.enums.RecognitionMetadata metadata = speech.RecognitionMetadata() metadata.interaction_type = speech.RecognitionMetadata.InteractionType.DISCUSSION metadata.microphone_distance = ( speech.RecognitionMetadata.MicrophoneDistance.NEARFIELD ) metadata.recording_device_type = ( speech.RecognitionMetadata.RecordingDeviceType.SMARTPHONE ) # Some metadata fields are free form strings metadata.recording_device_name = "Pixel 2 XL" # And some are integers, for instance the 6 digit NAICS code # https://www.naics.com/search/ metadata.industry_naics_code_of_audio = 519190 audio = speech.RecognitionAudio(content=content) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=8000, language_code="en-US", # Add this in the request to send metadata. metadata=metadata, ) response = client.recognize(config=config, audio=audio) for i, result in enumerate(response.results): alternative = result.alternatives[0] print("-" * 20) print(u"First alternative of result {}".format(i)) print(u"Transcript: {}".format(alternative.transcript))
def initialize_metadata(): """INITIALIZES THE METADATA AND ADDS IT TO THE CONFIG FILE""" metadata = speech.RecognitionMetadata() metadata.interaction_type = speech.RecognitionMetadata.InteractionType.DISCUSSION metadata.microphone_distance = ( speech.RecognitionMetadata.MicrophoneDistance.NEARFIELD ) metadata.recording_device_type = ( speech.RecognitionMetadata.RecordingDeviceType.SMARTPHONE ) # Some metadata fields are free form strings metadata.recording_device_name = "Pixel 2 XL" # NAICS code represents the type of industrial place where the # recording is going to happen. In our case, the code 452311 # represents warehouses that deal with general merchandise and food. # All the codes can be found at: # https://www.naics.com/search/ metadata.industry_naics_code_of_audio = 452311 return metadata
def transcribe( self, file_uri: Union[str, Path], phrases: Optional[List[str]] = None, **kwargs: Any, ) -> transcript_model.Transcript: """ Transcribe audio from GCS file and return a Transcript model. Parameters ---------- file_uri: Union[str, Path] The GCS file uri to the audio file or caption file to transcribe. It should be in format 'gs://...'. phrases: Optional[List[str]] = None A list of strings to feed as targets to the model. Returns ------- outputs: transcript_model.Transcript The transcript model for the supplied media file. """ # Create client client = speech.SpeechClient.from_service_account_file( filename=str(self.credentials_file)) # Create basic metadata metadata = speech.RecognitionMetadata() metadata.interaction_type = ( speech.RecognitionMetadata.InteractionType.PHONE_CALL) metadata.original_media_type = ( speech.RecognitionMetadata.OriginalMediaType.VIDEO) # Add phrases event_metadata_speech_context = speech.SpeechContext( phrases=self._clean_phrases(phrases)) # Prepare for transcription config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16, sample_rate_hertz=16000, language_code="en-US", enable_automatic_punctuation=True, enable_word_time_offsets=True, enable_spoken_punctuation=True, speech_contexts=[ GOOGLE_SPEECH_ADAPTION_CLASSES, event_metadata_speech_context, ], metadata=metadata, model="video", use_enhanced=True, ) audio = speech.RecognitionAudio(uri=file_uri) # Begin transcription log.debug(f"Beginning transcription for: {file_uri}") operation = client.long_running_recognize(request={ "config": config, "audio": audio }) # Wait for complete response = operation.result(timeout=10800) # Select highest confidence transcripts confidence_sum = 0 segments = 0 # Create timestamped sentences timestamped_sentences: List[transcript_model.Sentence] = [] transcript_sentence_index = 0 # Create sentence boundary pipeline nlp = English() nlp.add_pipe("sentencizer") for result in response.results: # Some portions of audio may not have text if len(result.alternatives) > 0: # Split transcript into sentences doc = nlp(result.alternatives[0].transcript) # Convert generator to list sentences = [str(sent) for sent in doc.sents] # Index holder for word results of response w_marker = 0 for s_ind, _ in enumerate(sentences): # Sentence text s_text = sentences[s_ind] num_words = len(s_text.split()) # Initialize sentence model timestamped_sentence = transcript_model.Sentence( index=transcript_sentence_index, confidence=result.alternatives[0].confidence, # Start and end time are placeholder values start_time=0.0, end_time=0.0, words=[], text=s_text, ) for w_ind in range(w_marker, w_marker + num_words): # Extract word from response word = result.alternatives[0].words[w_ind] # Nanos no longer supported, use microseconds instead # https://github.com/googleapis/python-speech/issues/71 start_time = (word.start_time.seconds + word.start_time.microseconds * 1e-6) end_time = (word.end_time.seconds + word.end_time.microseconds * 1e-6) # Add start_time to Sentence if first word if w_ind - w_marker == 0: timestamped_sentence.start_time = start_time # Add end_time to Sentence if last word if (w_ind - w_marker) == (num_words - 1): timestamped_sentence.end_time = end_time # Create Word model timestamped_word = transcript_model.Word( index=w_ind - w_marker, start_time=start_time, end_time=end_time, text=self._clean_word(word.word), ) timestamped_sentence.words.append(timestamped_word) # Increment word marker w_marker += num_words # Add Sentence to sentence list timestamped_sentences.append(timestamped_sentence) # Increment transcript sentence index transcript_sentence_index += 1 # Update confidence stats confidence_sum += result.alternatives[0].confidence segments += 1 # Compute mean confidence if segments > 0: confidence = confidence_sum / segments else: confidence = 0.0 log.info( f"Completed transcription for: {file_uri}. Confidence: {confidence}" ) # Create transcript model transcript = transcript_model.Transcript( generator=f"Google Speech-to-Text -- CDP v{__version__}", confidence=confidence, session_datetime=None, created_datetime=datetime.utcnow().isoformat(), sentences=timestamped_sentences, ) return transcript
def transcribe_gcs(gcs_uri, num_speakers): """Asynchronously transcribes the audio file specified by the gcs_uri.""" # Imports the Google Cloud client library #from google.cloud import speech from google.cloud import speech_v1p1beta1 as speech # Instantiates a client client = speech.SpeechClient() # Construct a recognition metadata object metadata = speech.RecognitionMetadata() metadata.interaction_type = speech.RecognitionMetadata.InteractionType.DISCUSSION metadata.recording_device_type = ( speech.RecognitionMetadata.RecordingDeviceType.OTHER_INDOOR_DEVICE ) metadata.audio_topic = "court trial hearing" metadata.original_mime_type = "audio/mp3" audio = speech.RecognitionAudio(uri=gcs_uri) config = speech.RecognitionConfig( encoding=speech.RecognitionConfig.AudioEncoding.FLAC, sample_rate_hertz=16000, language_code="en-US", enable_automatic_punctuation=True, enable_speaker_diarization=True, diarization_speaker_count=num_speakers, # Enhanced models cost more than standard models. use_enhanced=True, model="video", enable_word_time_offsets=True, ) # Detects speech in the audio file -- long audio file operation = client.long_running_recognize(config=config, audio=audio) print("Waiting for operation to complete...") response = operation.result(timeout=300) # Writing results to json result_counter = 0 word_counter = 0 output_json = {} for result in response.results: alternative = result.alternatives[0] output_json[f"{result_counter}_Transcript"] = alternative.transcript output_json[f"{result_counter}_Confidence"] = alternative.confidence result_counter += 1 for word_info in alternative.words: word = word_info.word start_time = word_info.start_time end_time = word_info.end_time speaker_tag = word_info.speaker_tag output_json[f"{word_counter}_Word"] = word output_json[f"{word_counter}_start_time"] = start_time.total_seconds() output_json[f"{word_counter}_end_time"] = end_time.total_seconds() output_json[f"{word_counter}_speaker_tag"] = speaker_tag word_counter += 1 with open("{}.json".format(gcs_uri.split('/')[-1][:-5]) , "w+") as file: json.dump(output_json, file) print("Dirized and transcribed {}".format(gcs_uri.split('/')[-1]))