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)

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.

% 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

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

Comment utiliser Google Cloud Speech-to-Text

% export GOOGLE_APPLICATION_CREDENTIALS="[chemin vers le fichier json]" 
% source ~/.zshrc

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()

Comment utiliser IBM Watson Speech-to-Text

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.

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)

Recommended Posts

Comment utiliser les services de reconnaissance vocale cloud de 4 grandes entreprises
Comparaison de la précision de la reconnaissance vocale dans le cloud de 4 grandes entreprises
Résumé de l'utilisation de pandas.DataFrame.loc
Résumé de l'utilisation de pyenv-virtualenv
[Python] Résumé de l'utilisation des pandas
Comment calculer Utiliser% de la commande df
[Python2.7] Résumé de l'utilisation d'unittest
Jupyter Notebook Principes d'utilisation
Résumé de l'utilisation de la liste Python
Comment utiliser l'API Cloud Vision de GCP
[Python2.7] Résumé de l'utilisation du sous-processus
[Question] Comment utiliser plot_surface de python
Comment utiliser Folium (visualisation des informations de localisation)
Pas beaucoup de mention de la façon d'utiliser Pickle
Résumé de l'utilisation de MNIST avec Python
Comment utiliser l'API Google Cloud Translation
Comment utiliser xml.etree.ElementTree
Comment utiliser Python-shell
Remarques sur l'utilisation de tf.data
Comment utiliser virtualenv
Comment utiliser Seaboan
Comment utiliser la correspondance d'image
Comment utiliser le shogun
Comment utiliser Virtualenv
Comment utiliser numpy.vectorize
Comment utiliser pytest_report_header
Comment utiliser partiel
Comment utiliser Bio.Phylo
Comment utiliser SymPy
Comment utiliser x-means
Comment utiliser WikiExtractor.py
Comment utiliser virtualenv
Comment utiliser Matplotlib
Comment utiliser iptables
Comment utiliser numpy
Comment utiliser TokyoTechFes2015
Comment utiliser venv
Comment utiliser Pyenv
Comment utiliser la liste []
Comment utiliser python-kabusapi
Comment utiliser OptParse
Comment utiliser le retour
Comment utiliser pyenv-virtualenv
Comment utiliser imutils
J'ai essayé de résumer comment utiliser matplotlib de python
Remarques sur la façon d'utiliser lors de la combinaison de pandas.
Comment utiliser Python Kivy ① ~ Bases du langage Kv ~
Comment utiliser Qt Designer
Comment utiliser la recherche triée
python3: Comment utiliser la bouteille (2)
Comprendre comment utiliser django-filter
Comment utiliser le générateur
Comment utiliser FastAPI ③ OpenAPI
Comment utiliser Python Argparse
Comment utiliser IPython Notebook
Comment utiliser Pandas Rolling
[Note] Comment utiliser virtualenv