Verwendet Spracherkennungsdienste von Amazon, Google, IBM und Microsoft

Der Name der API des Spracherkennungsdienstes jedes Unternehmens (der Name variiert von Person zu Person, aber es tut mir leid, wenn er falsch ist).

Amazon:
- Transcribe
Google:
- Cloud Speech-to-Text
IBM:
- Watson Speech-to-Text
Microsoft:
- Azure Speech-to-Text

Sie finden es, indem Sie nach einer API namens Speech-to-Text suchen. Nur Amazon heißt Transcribe ...

*** Dieser Artikel basiert auf der Voraussetzung, dass die Vorbereitungen für die Verwendung der einzelnen APIs (Kontoregistrierung usw.) abgeschlossen wurden *** *** Es gibt eine Website, auf der erklärt wird, wie Sie ein Konto auf leicht verständliche Weise durch Suchen registrieren. Geben Sie also bitte Ihr Bestes, um sich zu registrieren ***

Es gibt auch einen Artikel zum Vergleich der Erkennungsgenauigkeit

So verwenden Sie Amazon Transcribe

――Zunächst müssen Sie die Audiodatei, die Sie erkennen möchten, im AWS-Cloud-Speicher namens S3 ablegen. --Klicken Sie oben links auf der S3-Seite auf *** Bucket erstellen ***, um einen Bucket zu erstellen. Der Bucket-Name kann beliebig sein. Die Region ist Tokio.

Eimername: Erkennungstest (alles ist in Ordnung) - Region: Asia Pacific(Tokyo) -
Sobald Sie einen Bucket erstellt haben, laden Sie die Audiodatei in den erstellten Bucket hoch und Sie können loslegen. Oben links befindet sich eine Schaltfläche mit dem Namen *** Hochladen ***, sodass Sie sie hochladen können, indem Sie darauf klicken. Sie können auch Ordner erstellen, um mehrere Audiodateien zu kombinieren. Machen Sie also, was Sie wollen.
Dann werden wir mit dem Erkennen beginnen, aber bevor wir die API erreichen, müssen Umgebungsvariablen wie der Zugriffsschlüssel der API durchlaufen werden.

% export AWS_SECRET_ACCESS_KEY=[Mein AWS_SECRET_ACCESS_KEY]
% export AWS_ACCESS_KEY_ID=[Mein AWS_ACCESS_KEY_ID]
% export AWS_DEFAULT_REGION=ap-northeast-1
% source ~/.zshrc

Alles was Sie tun müssen, ist die API zu drücken. Hier ist ein Beispielprogramm.

`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):
    '''
Extrahieren Sie die URL-Informationen von S3, in denen das Transkript gespeichert ist, aus der Antwort von api
    '''
    p = re.compile(r'(?:\{\'TranscriptFileUri\':[ ]\')(.*?)(?:\'\}\,)')
    url = re.findall(p,str(response))[0]
    return url

def get_json_result(url):
    '''
Laden Sie Informationen einschließlich der Ergebnisse der Erkennung des JSON-Formats aus der Cloud herunter
    '''
    try:
        r = requests.get(url)
        return str(r.text)
    except requests.exceptions.RequestException as err:
        print(err)

def extract_recognition_result(_json):
    '''
Extrahieren Sie nur das Erkennungsergebnis von json einschließlich des Erkennungsergebnisses
    '''
    json_dict = json.loads(_json)
    recognized_result = json_dict['results']['transcripts'][0]['transcript']
    return recognized_result

def main():
    #Arbeitsverzeichnis
    _dir = '/Users/RecognitionTest'
    #Speicherverzeichnis für Erkennungsergebnisse(Erstellen Sie im Voraus ein Verzeichnis mit dem Namen AWS. Antwortinformationen von der API und Transkriptionsergebnisse werden in diesem Verzeichnis gespeichert.)
    recognition_result = _dir+'/AWS'
    #Eine Textdatei mit dem Namen der Audiodatei, die Sie erkennen möchten
    speech_fname_file = _dir+'/speech_fname.txt'
    #Speichern Sie den Namen der Audiodatei, die Sie erkennen möchten, in der 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' #Datei zum Speichern des Erkennungsergebnisses

    with open(status_file,'w') as status_out:
        for speech_fname in speech_fname_list:
            transcribe = boto3.client('transcribe')
            job_name = str(speech_fname) #Name der Audiodatei(Es muss kein Name einer Audiodatei sein, es kann alles sein)
            job_uri = f'https://[Eimername].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:Antwortinformationen(Enthält eine S3-Cloud-URL, in der Erkennungsergebnisse gespeichert werden)
                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 ist eine Textdatei, die den Namen der Audiodatei beschreibt, die Sie erkennen möchten. *** Muss mit dem Namen der Audiodatei im S3-Bucket übereinstimmen. *** Ein Beispiel ist unten angegeben. Dies ist ein Beispiel, wenn Sie fünf separate Audiodateien erkennen möchten. Es ist in Ordnung, wenn Sie dieselbe Audiodatei wie diesen Namen der Audiodatei im S3-Cloud-Speicher ablegen.

`speech_fname.txt`


speech_data1.wav
speech_data2.wav
speech_data3.wav
speech_data4.wav
speech_data5.wav

Wenn Sie die Umgebungsvariablen wie den Zugriffsschlüssel der API festgelegt und die Datei language_fname.txt vorbereitet haben, führen Sie Recogn.py aus, um die Erkennung zu starten.
Das Erkennungsergebnis wird in `` `/ Users / RecognitionTest / GCP / Recognition_result.txt``` geschrieben.
Kann auch bei Amazon Transcribe bestätigt werden

Verwendung von Google Cloud Speech-to-Text

Im Gegensatz zu Amazon Transcribe müssen Sie die Stimme, die Sie erkennen möchten, nicht in die Cloud stellen.
Kann lokale Stimme erkennen
Bereiten Sie eine Textdatei vor, die den Pfad der Audiodatei beschreibt, die Sie erkennen möchten. --Speech_data_path.txt im folgenden Beispielprogramm
Verwenden Sie dasselbe für IBM Watson und Microsoft Azure
Übergeben Sie dann zuerst den API-Schlüssel durch die Umgebungsvariable. API-Schlüsselinformationen finden Sie in der JSON-Datei. Diese JSON-Datei muss von der GCP-Konsole heruntergeladen werden. Sie können die Anmeldeinformationen im JSON-Format herunterladen, indem Sie im Navigationsmenü zu *** API und Dienste *** gehen.

% export GOOGLE_APPLICATION_CREDENTIALS="[Pfad zur JSON-Datei]"　
% source ~/.zshrc

Alles was Sie tun müssen, ist die API zu drücken. Hier ist ein Beispielprogramm.

`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()
    #Arbeitsverzeichnis
    _dir = '/Users/RecognitionTest'
    #Speicherverzeichnis für Erkennungsergebnisse
    recognition_result = _dir+'/GCP'

    #Eine Textdatei, die den Pfad zu der Audiodatei enthält, die Sie erkennen möchten
    speech_data_path_file = _dir+'/speech_data_path.txt'
    #Speichern Sie den Pfad der Audiodatei, die Sie erkennen möchten, in der 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' #Datei zum Speichern des Erkennungsergebnisses
    with open(recog_result_fname,'w') as recog_result:
        for speech_path in speech_path_list:
            #Namen der Audiodatei abrufen(Wird für den Dateinamen verwendet, um das Erkennungsergebnis zu schreiben)
            speech_file_name = speech_path.split('/')[-1].split('.')[0]   #Ändern Sie den Namen der Audiodatei in den Dateinamen, um das Erkennungsergebnis zu schreiben

            # 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" #Stellen Sie die Sprache auf Japanisch ein
            config = {"metadata": metadata, "language_code": language_code}
            with io.open(speech_path, "rb") as f:
                content = f.read()
            audio = {"content": content}

            #Starten Sie die Erkennung
            response = client.recognize(config, audio)

            #Speichern und Anzeigen von Erkennungsergebnissen
            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()

Das Erkennungsergebnis wird in `` `/ Users / RecognitionTest / GCP / Recognition_result.txt``` geschrieben.

Verwendung von IBM Watson Speech-to-Text

Die Verwendung entspricht fast der von Google Gloud Speech-to-Text. ―― *** Der Unterschied besteht jedoch darin, dass der API-Schlüssel usw. im Programm beschrieben sind. *** In Google und Amazon wurde es als Umgebungsvariable festgelegt.
Sie müssen den API-Schlüssel und die Endpunkt-URL abrufen.
Beispielprogramm
*** Bitte ersetzen Sie [Ihren API-Schlüssel] *** und *** [Endpunkt-URL] ***
Es ist besser, "jp-tok" als Endpunkt anzugeben.

`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 ' '
    #Da das Stagnationswort in Katakana geschrieben ist, wird es in eine einfache Kana-Notation umgewandelt.
    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_','')  #Die Stagnation ist'D_'Löschen Sie es, da es in ausgedrückt wird
    return str(recognized_result)


def main():
    #Arbeitsverzeichnis
    _dir = '/Users/RecognitionTest'
    #Speicherverzeichnis für Erkennungsergebnisse
    recognition_result = _dir+'/Watson'

    #Eine Textdatei, die den Pfad zu der Audiodatei enthält, die Sie erkennen möchten
    speech_data_path_file = _dir+'/speech_data_path.txt'
    #Speichern Sie den Pfad der Audiodatei, die Sie erkennen möchten, in der 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()

    #JSON-Datei(Erkennungsergebnis)Speicherverzeichnis
    json_result_dir = recognition_result+'/json_result'
    for speech_path in speech_path_list:
        #Namen der Audiodatei abrufen(Wird für den Dateinamen verwendet, um das Erkennungsergebnis zu schreiben)
        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('[Mein API-Schlüssel]')
            service = SpeechToTextV1(authenticator=authenticator)
            # set endpoint url
            service.set_service_url('[Endpunkt-URL]')
            lang = 'ja-JP_BroadbandModel'   #Stellen Sie die Sprache auf Japanisch ein
            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()

            #Da das Erkennungsergebnis im JSON-Format erfasst wird, ist JSON_resultX.Schreiben Sie an 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]
                #Gespeicherter json_resultX.Extrahieren Sie nur Erkennungsergebnisse von json
                recog_result = extract_recognition_result(_json.read())
                result.write(f'{speech_file_name} {recog_result}\n')

if __name__ == "__main__":
    main()

Watson fügt dem stagnierenden Teil standardmäßig "D_" hinzu. Dieser Teil wird im Beispielprogramm entfernt. Auch das Stagnationswort ist in Katakana geschrieben, aber ich habe es konvertiert, weil ich die einfache Kana-Notation brauchte.
Das Erkennungsergebnis wird in `` `/ Users / RecognitionTest / GCP / Recognition_result.txt``` geschrieben.

So verwenden Sie Microsoft Azure Speech-to-Text

Azure beschreibt den API-Schlüssel (language_key) und die Region im Programm wie IBM Watson. --speech_key: *** Bitte schreibe [deinen Sprachschlüssel] um *** --service_region: *** japaneast ***

`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").
#Service Bereich(service_region)Ostjapan(japaneast)Einstellen
# speech_key ->Überprüfen Sie auf meiner Seite von Azure
speech_key, service_region = "[Meine Rede_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>

    #Arbeitsverzeichnis
    _dir = '/Users/RecognitionTest'
    #Speicherverzeichnis für Erkennungsergebnisse
    recognition_result = _dir+'/Azure'

    #Eine Textdatei, die den Pfad zu der Audiodatei enthält, die Sie erkennen möchten
    speech_data_path_file = _dir+'/speech_data_path.txt'
    #Speichern Sie den Pfad der Audiodatei, die Sie erkennen möchten, in der 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()

    #Erstellung einer Datei zum Schreiben des Erkennungsergebnisses(pre_result.Andere Informationen als das Erkennungsergebnis werden ebenfalls in txt geschrieben)
    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]   #Verwenden Sie den Namen der Audiodatei als Dateinamen, um das Erkennungsergebnis zu schreiben
            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"   #Stellen Sie die Sprache auf Japanisch ein
            profanity_option = speechsdk.ProfanityOption(2) #Unangemessene Sprachverarbeitung 0->ausblenden, 1->Löschen, 2->Einschließlich
            speech_config.set_profanity(profanity_option=profanity_option)  # profanity_Option ändern
            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)))

            #Erkennungsergebnis schreiben
            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 ist das Erkennungsergebnis im folgenden Format
        - [SPEECH FILE NAME] RECOGNIZED: SpeechRecognitionEventArgs(session_id=XXX, result=SpeechRecognitionResult(result_id=YYY, text="[Erkennungsergebnis]", reason=ResultReason.RecognizedSpeech))
    - [SPEECH FILE NAME]Wann[Erkennungsergebnis]Extrahieren Sie nur den Teil von
    '''
    #Erkennungsergebnisdatei
    pre_result = '/Users/kamiken/speech_recognition_data/Cloud_Speech_to_Text/Compare4Kaldi/Compare_Test1/Azure/pre_result.txt'
    #Andere Informationen als Erkennungsergebnisse(Parameter etc.)Löschen
    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 verbirgt freundlicherweise unangemessene Bemerkungen wie F-Wörter mit einem Sternchen wie "***". Ich musste die WER berechnen, daher ist das Beispielprogramm so eingestellt, dass alle angezeigt werden.
- profanity_option = speechsdk.ProfanityOption(2) --Argumente sind 0 (unangemessene Anweisungen mit Sternchen ausblenden), 1 (Löschen), 2 (nicht ausblenden oder löschen)
Das Erkennungsergebnis wird in `` `/ Users / RecognitionTest / GCP / Recognition_result.txt``` geschrieben.

[PYTHON] Verwendung von Cloud-Spracherkennungsdiensten von 4 großen Unternehmen

Verwendet Spracherkennungsdienste von Amazon, Google, IBM und Microsoft

So verwenden Sie Amazon Transcribe

recognize.py

speech_fname.txt

Verwendung von Google Cloud Speech-to-Text

recognize.py

Verwendung von IBM Watson Speech-to-Text

recognize.py

So verwenden Sie Microsoft Azure Speech-to-Text

recognize.py

`recognize.py`

`speech_fname.txt`

`recognize.py`

`recognize.py`

`recognize.py`