Comment utiliser les services de reconnaissance vocale cloud de 4 grandes entreprises
Utilise les services de reconnaissance vocale Amazon, Google, IBM, Microsoft
Le nom de l'API du service de reconnaissance vocale de chaque entreprise (le nom varie d'une personne à l'autre, mais je suis désolé si c'est faux)
- Amazon:
- Transcribe
- Google:
- Cloud Speech-to-Text
- IBM:
- Watson Speech-to-Text
- Microsoft:
- Azure Speech-to-Text
Vous pouvez le trouver en recherchant une API appelée Speech-to-Text. Seul Amazon s'appelle Transcribe ...
*** Cet article part du principe que les préparatifs pour l'utilisation de chaque API (enregistrement de compte, etc.) sont terminés *** *** Il existe un site qui explique comment créer un compte de manière facile à comprendre en effectuant une recherche, alors faites de votre mieux pour vous inscrire ***
Comment utiliser Amazon Transcribe
―― Tout d'abord, vous devez placer le fichier audio que vous souhaitez reconnaître dans le stockage cloud AWS appelé S3. --Cliquez sur *** Créer un compartiment *** près du coin supérieur gauche de la page S3 pour créer un compartiment. Le nom du bucket peut être n'importe quoi. La région est tokyo.
-
Nom du godet: test de reconnaissance (tout va bien) - Region: Asia Pacific(Tokyo) -
-
Une fois que vous avez créé un bucket, téléchargez le fichier audio dans le bucket créé et vous êtes prêt à partir. Il y a un bouton appelé *** Télécharger *** en haut à gauche, vous pouvez donc le télécharger en cliquant dessus. Vous pouvez également créer des dossiers pour combiner plusieurs fichiers audio, alors faites ce que vous voulez.
-
Ensuite, nous allons commencer à reconnaître, mais avant de frapper l'API, il est nécessaire de passer par des variables d'environnement telles que la clé d'accès de l'API.
% export AWS_SECRET_ACCESS_KEY=[Mon AWS_SECRET_ACCESS_KEY]
% export AWS_ACCESS_KEY_ID=[Mon AWS_ACCESS_KEY_ID]
% export AWS_DEFAULT_REGION=ap-northeast-1
% source ~/.zshrc
- Tout ce que vous avez à faire est d'accéder à l'API. Voici un exemple de programme.
recognize.py
from __future__ import print_function
import os,sys
import time
import boto3
import glob
from pprint import pprint
import re
import requests
import json
def extract_url(response):
'''
Extraire les informations d'url de S3 qui stockent la transcription de la réponse de l'API
'''
p = re.compile(r'(?:\{\'TranscriptFileUri\':[ ]\')(.*?)(?:\'\}\,)')
url = re.findall(p,str(response))[0]
return url
def get_json_result(url):
'''
Télécharger des informations, y compris les résultats de la reconnaissance du format JSON à partir du cloud
'''
try:
r = requests.get(url)
return str(r.text)
except requests.exceptions.RequestException as err:
print(err)
def extract_recognition_result(_json):
'''
Extraire uniquement le résultat de reconnaissance de json, y compris le résultat de reconnaissance
'''
json_dict = json.loads(_json)
recognized_result = json_dict['results']['transcripts'][0]['transcript']
return recognized_result
def main():
#Directeur de travail
_dir = '/Users/RecognitionTest'
#Répertoire de stockage des résultats de reconnaissance(Créez à l'avance un répertoire appelé AWS. Les informations de réponse de l'API et les résultats de la transcription sont enregistrés dans ce répertoire.)
recognition_result = _dir+'/AWS'
#Un fichier texte contenant le nom du fichier audio que vous souhaitez reconnaître
speech_fname_file = _dir+'/speech_fname.txt'
#Stockez le nom du fichier audio que vous souhaitez reconnaître dans la liste
speech_fname_list = []
with open(speech_fname_file,'r') as f:
path = f.readline()
while path:
speech_fname_list.append(path.strip())
path = f.readline()
status_file = recognition_result+'/status.txt'
json_file = recognition_result+'/json_response.txt'
recog_result = recognition_result+'/recognition_result.txt' #Fichier de sauvegarde du résultat de la reconnaissance
with open(status_file,'w') as status_out:
for speech_fname in speech_fname_list:
transcribe = boto3.client('transcribe')
job_name = str(speech_fname) #Nom du fichier audio(Il n'est pas nécessaire que ce soit un nom de fichier audio, cela peut être n'importe quoi)
job_uri = f'https://[Nom du godet].s3-ap-northeast-1.amazonaws.com/{job_name}' # Bucket name -> recongnitiontest
transcribe.start_transcription_job(
TranscriptionJobName=job_name,
Media={'MediaFileUri': job_uri},
MediaFormat='wav',
LanguageCode='ja-JP'
)
while True:
# status:Informations de réponse(Inclut l'URL du cloud S3 où les résultats de la reconnaissance sont stockés)
status = transcribe.get_transcription_job(TranscriptionJobName=job_name)
if status['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
break
print("Not ready yet...")
time.sleep(5)
status_out.write(f'{speech_fname} {status}\n')
with open(status_file,'r') as status_in, open(json_file,'w') as json_out, open(recog_result,'w') as result:
status_list = status_in.readlines()
client = boto3.client('transcribe')
for status in status_list:
job_name = status.strip().split(' ')[0]
response = client.get_transcription_job(TranscriptionJobName=job_name)
url = extract_url(response)
_json = get_json_result(url)
recog_text = extract_recognition_result(_json)
json_out.write(f'{job_name} {_json}\n')
result.write(f'{job_name} {recog_text}\n')
if __name__ == "__main__":
main()
--speech_fname.txt est un fichier texte qui décrit le nom du fichier audio que vous souhaitez reconnaître. *** Doit être le même que le nom du fichier audio placé dans le compartiment S3. *** Un exemple est donné ci-dessous. Voici un exemple lorsque vous souhaitez reconnaître cinq fichiers audio distincts. Ce n'est pas grave si vous placez le même fichier audio que ce nom de fichier audio dans le stockage cloud S3.
speech_fname.txt
speech_data1.wav
speech_data2.wav
speech_data3.wav
speech_data4.wav
speech_data5.wav
- Une fois que vous avez défini les variables d'environnement telles que la clé d'accès API et préparé speech_fname.txt, exécutez Recogn.py pour démarrer la reconnaissance.
- Le résultat de la reconnaissance est écrit dans `` / Users / RecognitionTest / GCP / Recognition_result.txt ''. --Peut également être confirmé sur Amazon Transcribe
Comment utiliser Google Cloud Speech-to-Text
- Contrairement à Amazon Transcribe, vous n'êtes pas obligé de mettre la voix que vous souhaitez reconnaître dans le cloud.
- Peut reconnaître la voix locale --Préparez un fichier texte décrivant le chemin du fichier audio que vous souhaitez reconnaître. --Speech_data_path.txt dans l'exemple de programme ci-dessous
- Utilisez la même chose pour IBM Watson et Microsoft Azure
- Ensuite, passez d'abord la clé API via la variable d'environnement. Les informations de clé API peuvent être trouvées dans le fichier json. Ce fichier json doit être téléchargé à partir de la console GCP. Vous pouvez télécharger les informations d'identification au format json en accédant à *** API et services *** dans le menu de navigation.
% export GOOGLE_APPLICATION_CREDENTIALS="[chemin vers le fichier json]"
% source ~/.zshrc
- Tout ce que vous avez à faire est d'accéder à l'API. Voici un exemple de programme.
recognize.py
import io
import glob
import os
import shutil
from google.cloud import speech_v1p1beta1
from google.cloud.speech_v1p1beta1 import enums
def main():
client = speech_v1p1beta1.SpeechClient()
#Directeur de travail
_dir = '/Users/RecognitionTest'
#Répertoire de stockage des résultats de reconnaissance
recognition_result = _dir+'/GCP'
#Un fichier texte contenant le chemin vers le fichier audio que vous souhaitez reconnaître
speech_data_path_file = _dir+'/speech_data_path.txt'
#Stockez le chemin du fichier audio que vous souhaitez reconnaître dans la liste
speech_path_list = []
with open(speech_data_path_file,'r') as f:
path = f.readline()
while path:
speech_path_list.append(path.strip())
path = f.readline()
recog_result_fname = recognition_result+'/recognition_result.txt' #Fichier de sauvegarde du résultat de la reconnaissance
with open(recog_result_fname,'w') as recog_result:
for speech_path in speech_path_list:
#Obtenir le nom du fichier audio(Utilisé pour le nom de fichier pour écrire le résultat de la reconnaissance)
speech_file_name = speech_path.split('/')[-1].split('.')[0] #Remplacez le nom du fichier audio par le nom du fichier pour écrire le résultat de la reconnaissance
# The use case of the audio, e.g. PHONE_CALL, DISCUSSION, PRESENTATION, et al.
interaction_type = enums.RecognitionMetadata.InteractionType.DISCUSSION
# The kind of device used to capture the audio
recording_device_type = enums.RecognitionMetadata.RecordingDeviceType.RECORDING_DEVICE_TYPE_UNSPECIFIED
# The device used to make the recording.
# Arbitrary string, e.g. 'Pixel XL', 'VoIP', 'Cardioid Microphone', or other
# value.
recording_device_name = "MR"
metadata = {
"interaction_type": interaction_type,
"recording_device_type": recording_device_type,
"recording_device_name": recording_device_name,
}
# The language of the supplied audio. Even though additional languages are
# provided by alternative_language_codes, a primary language is still required.
language_code = "ja-JP" #Définir la langue sur le japonais
config = {"metadata": metadata, "language_code": language_code}
with io.open(speech_path, "rb") as f:
content = f.read()
audio = {"content": content}
#Commencer la reconnaissance
response = client.recognize(config, audio)
#Enregistrer et afficher les résultats de la reconnaissance
for result in response.results:
# First alternative is the most probable result
alternative = result.alternatives[0]
print(u"Transcript: {}".format(alternative.transcript))
recog_result.write(u"{} {}".format(speech_file_name,alternative.transcript)+'\n')
if __name__ == "__main__":
main()
- Le résultat de la reconnaissance est écrit dans `` / Users / RecognitionTest / GCP / Recognition_result.txt ''.
Comment utiliser IBM Watson Speech-to-Text
- L'utilisation est presque la même que celle de Google Gloud Speech-to-Text. ―― *** Cependant, la différence est que la clé API, etc. est décrite dans le programme. *** Dans Google et Amazon, il a été défini comme une variable d'environnement.
- Vous devez obtenir la clé API et l'URL du point de terminaison.
- Exemple de programme
- *** Veuillez remplacer [votre clé API] *** et *** [URL du point de terminaison] *** --Il est préférable de spécifier "jp-tok" comme point de terminaison.
recognize.py
import os,sys
import glob
import re
import json
from os.path import join, dirname
from ibm_watson import SpeechToTextV1
from ibm_watson.websocket import RecognizeCallback, AudioSource
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from pprint import pprint
import shutil
import jaconv
def extract_recognition_result(_json):
recognized_result = []
json_dict = json.loads(_json)
try:
transcript = json_dict['results'][0]['alternatives'][0]['transcript'].split(' ')
except:
return ' '
#Puisque le mot de stagnation est écrit en katakana, il est converti en notation kana simple.
for word in transcript:
if 'D_' in word:
recognized_result.append(jaconv.kata2hira(word))
else:
recognized_result.append(word)
recognized_result = ' '.join(recognized_result)
recognized_result = recognized_result.replace('D_','') #La stagnation'D_'Puisqu'il est exprimé en, supprimez-le
return str(recognized_result)
def main():
#Directeur de travail
_dir = '/Users/RecognitionTest'
#Répertoire de stockage des résultats de reconnaissance
recognition_result = _dir+'/Watson'
#Un fichier texte contenant le chemin vers le fichier audio que vous souhaitez reconnaître
speech_data_path_file = _dir+'/speech_data_path.txt'
#Stockez le chemin du fichier audio que vous souhaitez reconnaître dans la liste
speech_path_list = []
with open(speech_data_path_file,'r') as f:
path = f.readline()
while path:
speech_path_list.append(path.strip())
path = f.readline()
#fichier json(Résultat de la reconnaissance)Répertoire de stockage
json_result_dir = recognition_result+'/json_result'
for speech_path in speech_path_list:
#Obtenir le nom du fichier audio(Utilisé pour le nom de fichier pour écrire le résultat de la reconnaissance)
speech_file_name = speech_path.split('/')[-1].split('.')[0]
with open(f'{json_result_dir}/{speech_file_name}.json','w') as json_out:
# set apikey
authenticator = IAMAuthenticator('[Ma clé API]')
service = SpeechToTextV1(authenticator=authenticator)
# set endpoint url
service.set_service_url('[URL du point de terminaison]')
lang = 'ja-JP_BroadbandModel' #Définir la langue sur le japonais
with open(speech_path,'rb') as audio_file:
result_json = service.recognize(audio=audio_file, content_type='audio/wav', timestamps=True, model=lang, word_confidence=True, end_of_phrase_silence_time=30.0)
result_json = result_json.get_result()
#Puisque le résultat de la reconnaissance au format json est acquis, json_resultX.Ecrire à json
result = json.dumps(result_json, indent=2, ensure_ascii=False)
json_out.write(result)
json_file_list = glob.glob(json_result_dir+'/*.json')
recog_result_file = recognition_result+'/recognition_result.txt'
with open(recog_result_file,'w') as result:
for json_file in json_file_list:
with open(json_file,'r') as _json:
print(json_file)
speech_file_name = json_file.strip().split('/')[-1].split('.')[0]
#Json enregistré_resultX.Extraire uniquement les résultats de reconnaissance de json
recog_result = extract_recognition_result(_json.read())
result.write(f'{speech_file_name} {recog_result}\n')
if __name__ == "__main__":
main()
--Watson ajoute "D_" à la partie stagnante par défaut. Cette partie est supprimée dans l'exemple de programme. De plus, le mot de stagnation est écrit en katakana, mais je l'ai converti parce que j'avais besoin de la notation kana simple.
- Le résultat de la reconnaissance est écrit dans `` / Users / RecognitionTest / GCP / Recognition_result.txt ''.
Comment utiliser Microsoft Azure Speech-to-Text
--Azure décrit la clé API (speech_key) et la région dans le programme comme IBM Watson. --speech_key: *** Veuillez réécrire [votre speech_key] *** --service_region: *** japoneast ***
recognize.py
import time
import wave
import glob
import re
import os
try:
import azure.cognitiveservices.speech as speechsdk
except ImportError:
print("""
Importing the Speech SDK for Python failed.
Refer to
https://docs.microsoft.com/azure/cognitive-services/speech-service/quickstart-python for
installation instructions.
""")
import sys
sys.exit(1)
# Set up the subscription info for the Speech Service:
# Replace with your own subscription key and service region (e.g., "westus").
#Zone de service(service_region)Japon oriental(japaneast)Mis à
# speech_key ->Vérifier sur ma page d'Azure
speech_key, service_region = "[Mon discours_key]", "japaneast"
# Specify the path to an audio file containing speech (mono WAV / PCM with a sampling rate of 16
# kHz).
def main():
"""performs continuous speech recognition with input from an audio file"""
# <SpeechContinuousRecognitionWithFile>
#Directeur de travail
_dir = '/Users/RecognitionTest'
#Répertoire de stockage des résultats de reconnaissance
recognition_result = _dir+'/Azure'
#Un fichier texte contenant le chemin vers le fichier audio que vous souhaitez reconnaître
speech_data_path_file = _dir+'/speech_data_path.txt'
#Stockez le chemin du fichier audio que vous souhaitez reconnaître dans la liste
speech_path_list = []
with open(speech_data_path_file,'r') as f:
path = f.readline()
while path:
speech_path_list.append(path.strip())
path = f.readline()
#Création d'un fichier pour l'écriture du résultat de reconnaissance(pre_result.Les informations autres que le résultat de la reconnaissance sont également écrites en txt)
with open(f'{recognition_result}/pre_result.txt','w') as recog_result:
for speech_path in speech_path_list:
speech_file_name = speech_path.split('/')[-1].split('.')[0] #Utiliser le nom du fichier audio comme nom de fichier pour écrire le résultat de la reconnaissance
speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
audio_config = speechsdk.audio.AudioConfig(filename=speech_path)
speech_config.speech_recognition_language="ja-JP" #Définir la langue sur le japonais
profanity_option = speechsdk.ProfanityOption(2) #Traitement de la parole inapproprié 0->cacher, 1->Effacer, 2->Comprenant
speech_config.set_profanity(profanity_option=profanity_option) # profanity_Changer d'option
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
done = False
def stop_cb(evt):
"""callback that signals to stop continuous recognition upon receiving an event `evt`"""
print('CLOSING on {}'.format(evt))
nonlocal done
done = True
# Connect callbacks to the events fired by the speech recognizer
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
#Écriture du résultat de la reconnaissance
speech_recognizer.recognized.connect(lambda evt: recog_result.write('{} RECOGNIZED: {}'.format(speech_file_name,evt)+'\n'))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))
# stop continuous recognition on either session stopped or canceled events
speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)
# Start continuous speech recognition
speech_recognizer.start_continuous_recognition()
while not done:
time.sleep(.5)
speech_recognizer.stop_continuous_recognition()
# </SpeechContinuousRecognitionWithFile>
def fix_recognition_result():
'''
- pre_result.txt est le résultat de la reconnaissance au format suivant
- [SPEECH FILE NAME] RECOGNIZED: SpeechRecognitionEventArgs(session_id=XXX, result=SpeechRecognitionResult(result_id=YYY, text="[Résultat de la reconnaissance]", reason=ResultReason.RecognizedSpeech))
- [SPEECH FILE NAME]Quand[Résultat de la reconnaissance]Extraire uniquement la partie de
'''
#Fichier de résultats de reconnaissance
pre_result = '/Users/kamiken/speech_recognition_data/Cloud_Speech_to_Text/Compare4Kaldi/Compare_Test1/Azure/pre_result.txt'
#Informations autres que les résultats de la reconnaissance(Paramètres etc.)Effacer
with open(pre_result,'r') as pre, open(pre_result.replace('pre_',''),'w') as result:
lines = pre.readlines()
for line in lines:
split_line = line.strip().split(' ')
speech_file_name = split_line[0]
text = str(re.findall('text=\"(.*)\",',' '.join(split_line[1:]))[0])+'\n'
result.write(f'{speech_file_name} {text}')
if __name__ == "__main__":
main()
fix_recognition_result()
--Azure cache gentiment les remarques inappropriées telles que le mot F avec un astérisque comme "***". Puisque j'ai dû calculer WER, l'exemple de programme est configuré pour tout afficher. - profanity_option = speechsdk.ProfanityOption(2)
- L'argument est soit 0 (masquer les déclarations inappropriées avec un astérisque), 1 (supprimer) ou 2 (ne pas masquer ni supprimer).
- Le résultat de la reconnaissance est écrit dans `` / Users / RecognitionTest / GCP / Recognition_result.txt ''.
Recommended Posts