L'API vocale programmable de Twilio est couramment utilisée pour initier et recevoir des appels téléphoniques, mais la précision de la transcription pour l'enregistrement laisse souvent beaucoup à désirer. Dans ce didacticiel, nous verrons comment connecter un appel téléphonique sortant alimenté par l'API Twilio Voice avec l'API de transcription d'apprentissage en profondeur d'AssemblyAI pour obtenir une sortie parole-texte beaucoup plus précise.
Outils requis pour cette application
Assurez-vous que Python 3 est installé, car Python 2 a atteint sa fin de vie au début de 2020 et n'est plus pris en charge. De préférence, vous devriez avoir Python 3.6 ou une version plus récente installée dans votre environnement de développement.
Nous utiliserons les dépendances suivantes pour terminer ce didacticiel :
- requêtes, version 2.24.0, pour accéder à l'API de transcription AssemblyAI
- Flask, version1.1.2, pour répondre aux webhooks de Twilio
- Un compte Twilio, dont une version d'essai gratuite suffit pour tester ce tutoriel
- Bibliothèque d'assistance Twilio Python, version 6.45.4 ou ultérieure, pour interagir avec l'API REST
- Un compte AssemblyAI, auquel vous pouvez vous inscrire pour obtenir une clé d'accès gratuite à l'API ici
- Ngrok si vous avez besoin d'un tunnel localhost pour exposer une URL publique à laquelle les webhooks peuvent envoyer une requête POST
Tout le code de cet article de blog est disponible en open source sous la licence MIT sur GitHub sous le répertoireaccurate-twilio-voice-call-recording-transcriptions-assemblyai du référentiel blog-code-examples. Utilisez le code source comme vous le souhaitez pour vos propres projets .
Configuration de notre environnement de développement
Accédez au répertoire dans lequel vous conservez vos environnements virtuels Python.Créez un nouvel environnement virtuel pour ce projet à l'aide de la commande suivante.
Démarrez ce projet Python en créant un nouvel environnement virtuel à l'aide de la commande suivante. Je recommande d'utiliser un répertoire séparé tel que ~/venvs/ (le tilde est un raccourci pour le home de votre utilisateur répertoire) afin que vous sachiez toujours où se trouvent tous vos environnements virtuels.
python3 -m venv ~/venvs/record-transcribe
Activez le virtualenv avec le activate script shell :
source ~/venvs/record-transcribe/bin/activate
Une fois la commande ci-dessus exécutée, l'invite de commande changera de sorte que le nom de virtualenv soit ajouté au format d'invite de commande d'origine, donc si votre invite est simplement $ , il ressemblera maintenant à ceci :
(record-transcribe) $
N'oubliez pas que vous devez activer votre environnement virtuel dans chaque nouvelle fenêtre de terminal où vous souhaitez utiliser des dépendances dans l'environnement virtuel.
Nous pouvons maintenant installer les packages requis dans le virtualenv activé mais autrement vide.
pip install Flask==1.1.2 requests==2.24.0 twilio==6.45.4
Recherchez une sortie similaire à la suivante pour confirmer que les packages appropriés ont été correctement installés à partir de PyPI.
(recordtranscribe) $ pip install Flask==1.1.2 requests==2.24.0 twilio=6.45.4 Collecting Flask Using cached https://files.pythonhosted.org/packages/f2/28/2a03252dfb9ebf377f40fba6a7841b47083260bf8bd8e737b0c6952df83f/Flask-1.1.2-py2.py3-none-any.whl Collecting requests Using cached https://files.pythonhosted.org/packages/45/1e/0c169c6a5381e241ba7404532c16a21d86ab872c9bed8bdcd4c423954103/requests-2.24.0-py2.py3-none-any.whl Collecting twilio Using cached https://files.pythonhosted.org/packages/d0/4e/7c377eb1a1d57f011dc1bee2fee77cf1e9a08407b8d44ea25a187a30c78d/twilio-6.45.4.tar.gz Collecting Werkzeug>=0.15 (from Flask) Using cached https://files.pythonhosted.org/packages/cc/94/5f7079a0e00bd6863ef8f1da638721e9da21e5bacee597595b318f71d62e/Werkzeug-1.0.1-py2.py3-none-any.whl Collecting itsdangerous>=0.24 (from Flask) Using cached https://files.pythonhosted.org/packages/76/ae/44b03b253d6fade317f32c24d100b3b35c2239807046a4c953c7b89fa49e/itsdangerous-1.1.0-py2.py3-none-any.whl Collecting click>=5.1 (from Flask) Using cached https://files.pythonhosted.org/packages/d2/3d/fa76db83bf75c4f8d338c2fd15c8d33fdd7ad23a9b5e57eb6c5de26b430e/click-7.1.2-py2.py3-none-any.whl Collecting Jinja2>=2.10.1 (from Flask) Using cached https://files.pythonhosted.org/packages/30/9e/f663a2aa66a09d838042ae1a2c5659828bb9b41ea3a6efa20a20fd92b121/Jinja2-2.11.2-py2.py3-none-any.whl Collecting urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 (from requests) Using cached https://files.pythonhosted.org/packages/9f/f0/a391d1463ebb1b233795cabfc0ef38d3db4442339de68f847026199e69d7/urllib3-1.25.10-py2.py3-none-any.whl Collecting idna<3,>=2.5 (from requests) Using cached https://files.pythonhosted.org/packages/a2/38/928ddce2273eaa564f6f50de919327bf3a00f091b5baba8dfa9460f3a8a8/idna-2.10-py2.py3-none-any.whl Collecting certifi>=2017.4.17 (from requests) Using cached https://files.pythonhosted.org/packages/5e/c4/6c4fe722df5343c33226f0b4e0bb042e4dc13483228b4718baf286f86d87/certifi-2020.6.20-py2.py3-none-any.whl Collecting chardet<4,>=3.0.2 (from requests) Using cached https://files.pythonhosted.org/packages/bc/a9/01ffebfb562e4274b6487b4bb1ddec7ca55ec7510b22e4c51f14098443b8/chardet-3.0.4-py2.py3-none-any.whl Collecting six (from twilio) Using cached https://files.pythonhosted.org/packages/ee/ff/48bde5c0f013094d729fe4b0316ba2a24774b3ff1c52d924a8a4cb04078a/six-1.15.0-py2.py3-none-any.whl Collecting pytz (from twilio) Using cached https://files.pythonhosted.org/packages/4f/a4/879454d49688e2fad93e59d7d4efda580b783c745fd2ec2a3adf87b0808d/pytz-2020.1-py2.py3-none-any.whl Collecting PyJWT>=1.4.2 (from twilio) Using cached https://files.pythonhosted.org/packages/87/8b/6a9f14b5f781697e51259d81657e6048fd31a113229cf346880bb7545565/PyJWT-1.7.1-py2.py3-none-any.whl Collecting MarkupSafe>=0.23 (from Jinja2>=2.10.1->Flask) Using cached https://files.pythonhosted.org/packages/0c/12/37f68957526d1ec0883b521934b4e1b8ff3dd8e4fab858a5bf3e487bcee9/MarkupSafe-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl Installing collected packages: Werkzeug, itsdangerous, click, MarkupSafe, Jinja2, Flask, urllib3, idna, certifi, chardet, requests, six, pytz, PyJWT, twilio Running setup.py install for twilio ... done Successfully installed Flask-1.1.2 Jinja2-2.11.2 MarkupSafe-1.1.1 PyJWT-1.7.1 Werkzeug-1.0.1 certifi-2020.6.20 chardet-3.0.4 click-7.1.2 idna-2.10 itsdangerous-1.1.0 pytz-2020.1 requests-2.24.0 six-1.15.0 twilio-6.45.4 urllib3-1.25.10
Nous pouvons commencer à coder l'application maintenant que toutes nos dépendances requises sont installées.
Construire notre application
Il est temps de creuser dans le code ! Nous allons écrire trois fichiers source dans cette application :
app.py:une application Flask qui gérera l'appel téléphonique et l'enregistrementtranscribe.py:un court script Python pour invoquer AssemblyAI avec l'enregistrement et lancer le processus de transcriptionprint_transcription.py:un script pour imprimer la sortie de la transcription sur le terminal
N'oubliez pas que vous pouvez accéder aux trois fichiers terminés dans le accurate-twilio-voice-call-recording-transcriptions-assemblyai répertoiredudépôt Gitblog-code-examples si vous ne souhaitez pas taper ou copier à partir de l'article de blog lui-même.
Créez un nouveau répertoire nommé record-transcribe pour stocker vos fichiers source et passer dans le nouveau répertoire.
mkdir record-transcribe cd record-transcribe
Créez un nouveau fichier nommé app.py avec le code suivant :
import os
from flask import Flask, request
from twilio.twiml.voice_response import VoiceResponse
from twilio.rest import Client
app = Flask(__name__)
# pulls credentials from environment variables
client = Client()
BASE_URL = os.getenv("BASE_URL")
twiml_instructions_url = "{}/record".format(BASE_URL)
recording_callback_url = "{}/callback".format(BASE_URL)
twilio_phone_number = os.getenv("TWILIO_PHONE_NUMBER")
@app.route("/record", methods=["GET", "POST"])
def record():
"""Returns TwiML which prompts the caller to record a message"""
# Start our TwiML response
response = VoiceResponse()
# Use <Say> to give the caller some instructions
response.say('Ahoy! Call recording starts now.')
# Use <Record> to record the caller's message
response.record()
# End the call with <Hangup>
response.hangup()
return str(response)
Il y a quelques fonctions supplémentaires que nous devrons ajouter à app.py mais d'abord regardons ce que fait le code ci-dessus.
Nous avons importé des parties des bibliothèques d'assistance Flask et Twilio, ce qui nous permettra de créer et de contrôler par programme les appels téléphoniques enregistrés par Twilio. Notez que lorsque nous instancions la bibliothèque d'assistance Twilio avec le Client() vide constructeur, il cherche automatiquement à lire deux variables d'environnement, TWILIO_ACCOUNT_SID et TWILIO_AUTH_TOKEN pour obtenir les autorisations appropriées sur votre compte Twilio. Si ces deux variables d'environnement ne sont pas définies avec ces noms exacts, vous devrez transmettre explicitement le SID de compte et le jeton d'authentification de votre compte au constructeur.
Après l'importation se trouvent les instanciations des bibliothèques Flask et Twilio.Ensuite, nous configurons le BASE_URL en lisant à partir d'une variable d'environnement.Dans ce tutoriel, le BASE_URL proviendra de Ngrok, mais il peut également s'agir de votre domaine sur lequel votre application est déployée, comme "https://www.twilio.com". Nous n'avons pas encore défini ces variables d'environnement, mais nous le ferons peu de temps après avoir fini d'écrire app.py .
Après avoir défini BASE_URL , et les trois autres variables définies par des variables d'environnement, nous avons le record fonction. Cette fonction est une route Flask qui génère le TwiML qui indique à Twilio comment gérer un appel téléphonique. Tout d'abord, une voix automatisée avertit la personne qui décroche que l'appel téléphonique est en cours d'enregistrement. Ensuite, l'enregistrement démarre. Tout ce que dit la personne à l'appel sera enregistré et stocké par Twilio.
Terminer app.py en ajoutant ces deux fonctions suivantes après le record fonction :
@app.route("/dial/<int:phone_number>")
def dial(phone_number):
"""Dials an outbound phone call to the number in the URL. Just
as a heads up you will never want to leave a URL like this exposed
without authentication and further phone number format verification.
phone_number should be just the digits with the country code first,
for example 14155559812."""
call = client.calls.create(
to='+{}'.format(phone_number),
from_=twilio_phone_number,
url=twiml_instructions_url,
)
print(call.sid)
return "dialing +{}. call SID is: {}".format(phone_number, call.sid)
@app.route("/get-recording-url/<call_sid>")
def get_recording_url(call_sid):
recording_urls = ""
call = client.calls.get(call_sid)
for r in call.recordings.list():
recording_urls="\n".join([recording_urls, r.uri])
return str(recording_urls)
Le dial La fonction crée une route Flask qui prend une entrée de numéro de téléphone dans le cadre du chemin de second niveau. Notez que dans une application de production, vous devez avoir une meilleure validation du numéro de téléphone ou vous aurez un problème de sécurité avec des entrées non désinfectées. Nous faisons cela ici pour saisir facilement un numéro de téléphone en entrée plutôt que d'avoir à créer une interface utilisateur complète avec un formulaire HTML juste pour saisir un numéro de téléphone. dial appelle l'API Twilio Voice à l'aide des informations d'identification de notre compte Twilio afin que nous puissions composer un appel téléphonique sortant vers le numéro envoyé via l'URL. Le twiml_instructions_url doit être défini sur record URL de la fonction afin qu'elle puisse donner les instructions TwiML de numérotation et d'enregistrement appropriées sur la manière dont le service de Twilio doit gérer la numérotation de l'appel téléphonique.
Une fois que nous avons composé l'appel téléphonique sortant, l'appel SIDis imprimé sur le terminal. Nous aurons besoin de ce SID d'appel pour obtenir l'enregistrement une fois l'appel terminé.
Notre app.py fichier est tout fait. Nous avons juste besoin d'exporter nos variables d'environnement pour nos informations d'identification Twilio.
Inscrivez-vous à Twilio ou connectez-vous à votre compte existant. Une fois que vous accédez à la console Twilio, vous pouvez obtenir votre TWILIO_ACCOUNT_SID et TWILIO_AUTH_TOKEN sur le côté droit de la page :
Lorsque vous vous inscrivez, un numéro de téléphone doit être attribué à votre compte. Vous pouvez l'utiliser ou acheter un nouveau numéro de téléphone à utiliser.
Définissez trois variables d'environnement avec les noms TWILIO_ACCOUNT_SID ,TWILIO_AUTH_TOKEN , et TWILIO_PHONE_NUMBER en utilisant le export commande dans votre terminal. Assurez-vous de remplacer les valeurs par vos propres SID de compte, jeton d'authentification et numéro de téléphone Twilio.
export TWILIO_ACCOUNT_SID=xxxxxxxxxxxxx # found in twilio.com/console export TWILIO_AUTH_TOKEN=yyyyyyyyyyyyyy # found in twilio.com/console export TWILIO_PHONE_NUMBER=+17166382453 # replace with your Twilio number
Notez que vous devez utiliser le export commande dans chaque fenêtre de ligne de commande pour laquelle vous souhaitez que cette clé soit accessible. Les scripts que nous écrivons ne pourront pas accéder aux API Twilio si vous n'avez pas exporté les jetons dans l'environnement où vous exécutez le script.
Il reste une variable d'environnement à définir avant de pouvoir exécuter app.py .Nous devons utiliser Ngrok comme tunnel localhost afin que le webhook de Twilio puisse envoyer une requête HTTP POST à notre app.py Application Flask s'exécutant sur notre environnement de développement local.
Exécutez Ngrok dans une nouvelle fenêtre de terminal, car vous devrez continuer à l'exécuter pendant que nous exécutons notre autre code Python :
./ngrok http 5000
Copiez la version HTTPS de l'URL "Transfert" et définissez le BASE_URL la valeur de la variable d'environnement. Par exemple, dans cette capture d'écran, vous définiriez BASE_URL à https://7f9139eaf445.ngrok.io à l'aide de la commande suivante :
export BASE_URL=https://7f9139eaf445.ngrok.io # use your ngrok URL, or domain. no trailing slash
Bon, nous pouvons enfin exécuter app.py . Assurez-vous que vous exécutez toujours Ngrokin dans une fenêtre différente, que votre environnement virtuel est actif et que dans ce terminal, vos quatre variables d'environnement sont définies, puis exécutez le flask run commande :
flask run
Vous devriez voir Flask sortir quelque chose comme le texte suivant :
* Environment: production WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Debug mode: off * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
C'est un avertissement légitime :n'utilisez cette commande qu'à des fins de développement et lorsque vous souhaitez déployer en production, vous devez utiliser un véritable serveur WSGI comme Gunicorn.
Il est temps de tester notre application.
Test de l'enregistrement vocal programmable Twilio
Nous pouvons tester notre application en allant sur localhost sur le port 5000. Allez sur cette URL dans votre navigateur web, en remplaçant le "14155551234" par le numéro de téléphone que vous souhaitez appeler, où la personne en ligne sera enregistrée :http://localhost :5000/composer/14155551234.
Ce numéro devrait maintenant recevoir un appel téléphonique de votre Twilionumber. Décrochez, enregistrez un message que vous souhaitez utiliser pour tester la transcription, puis raccrochez.
Si vous obtenez une erreur, assurez-vous que toutes vos variables d'environnement sont définies. Vous pouvez vérifier les valeurs en utilisant la commande echo comme ceci :
echo $BASE_URL
Lorsque l'appel est terminé, copiez l'émission SID d'appel sur les pages Web afin que nous puissions l'utiliser pour rechercher où le fichier audio d'enregistrement est stocké.
Allez dans "localhost:5000/get-recording-url/" avec le SID d'appel à la fin. Par exemple,"localhost:5000/get-recording-url/CAda3f2f49ff4e8ef2be6b726edb998c92".
Copiez l'intégralité de la sortie à l'exception du ".json" à la fin, puis collez-la dans la barre d'URL du navigateur Web, précédée de "api.twilio.com". Par exemple, "https://api.twilio.com/2010- 04-01/Accounts/ACe3737affa0d2e17561ad44c9d190e70c/Recordings/RE3b42cf470bef829c3680ded961a09300 ". Copiez l'intégralité de l'URL et nous l'utiliserons comme entrée dans le service AssemblyAI.
Transcrire avec l'API AssemblyAI
Nous pouvons maintenant utiliser l'API AssemblyAI pour la transcription de la parole en texte sur l'enregistrement de l'appel qui vient d'être effectué.
Créez un compte AssemblyAI et connectez-vous au tableau de bord AssemblyAI, puis copiez "Votre jeton API" comme indiqué dans cette capture d'écran :
Nous devons exporter notre clé API AssemblyAI en tant que variables d'environnement afin que notre application Python puisse l'utiliser pour s'authentifier auprès de son API. Nous devons également transmettre l'URL accessible au public pour l'enregistrement, nous allons donc également la définir comme variable d'environnement.
# make sure to replace this URL with the one for your recording export ASSEMBLYAI_KEY=your-api-key-here export RECORDING_URL=https://api.twilio.com/2010-04-01/Accounts/ACe3737affa0d2e17561ad44c9d190e70c/Recordings/RE3b42cf470bef829c3680ded961a09300
Créez un nouveau fichier nommé transcribe.py et écrivez-y le code suivant :
import os
import requests
endpoint = "https://api.assemblyai.com/v2/transcript"
json = {
"audio_url": os.getenv("RECORDING_URL")
}
headers = {
"authorization": os.getenv("ASSEMBLYAI_KEY"),
"content-type": "application/json"
}
response = requests.post(endpoint, json=json, headers=headers)
print(response.json())
Le code ci-dessus appelle le service de transcription AssemblyAI à l'aide de la clé secrète et lui transmet l'URL avec l'enregistrement du fichier. Le script imprime la réponse JSON du service, qui contiendra un ID de transcription que nous utiliserons pour accéder aux résultats une fois le traitement terminé. .
Exécutez le script en utilisant le python commande :
python transcribe.py
Vous récupérerez du JSON en sortie, similaire à ce que vous voyez ici :
{'audio_end_at': None, 'acoustic_model': 'assemblyai_default', 'text': None, 'audio_url': 'https://api.twilio.com/2010-04-01/Accounts/ACe3737affa0d2e17561ad44c9d190e70c/Recordings/RE3b42cf470bef829c3680ded961a09300', 'speed_boost': False, 'language_model': 'assemblyai_default', 'redact_pii': False, 'confidence': None, 'webhook_status_code': None, 'id': 'zibe9vwmx-82ce-476c-85a7-e82c09c67daf', 'status': 'queued',
'boost_param': None, 'words': None, 'format_text': True, 'webhook_url': None, 'punctuate': True, 'utterances': None, 'audio_duration': None, 'auto_highlights': False, 'word_boost': [], 'dual_channel': None, 'audio_start_from': None}
Trouver la valeur contenue avec le id champ de la réponse JSON. Nous avons besoin de cette valeur pour rechercher le résultat final de notre transcription. Copiez l'ID de transcription et définissez-le comme variable d'environnement à utiliser comme entrée par le script final :
# replace with what's found within `id` from the JSON response export TRANSCRIPTION_ID=aksd19vwmx-82ce-476c-85a7-e82c09c67daf
Nous avons juste besoin d'un peu plus de Python qui recherche le résultat et nous aurons fini.
Récupérer la transcription AssemblyAI
AssemblyAI sera occupé à transcrire l'enregistrement. Selon la taille du fichier, cela peut prendre de quelques secondes à quelques minutes pour que le travail soit terminé. Nous pouvons utiliser le code suivant pour voir si le travail est toujours en cours ou s'il est terminé. Si la transcription est terminée, les résultats seront imprimés sur le terminal.
Créez un nouveau fichier nommé print_transcription.py avec le code suivant :
import os
import requests
endpoint = "https://api.assemblyai.com/v2/transcript/{}".format(os.getenv("TRANSCRIPTION_ID"))
headers = {
"authorization": os.getenv("ASSEMBLYAI_KEY"),
}
response = requests.get(endpoint, headers=headers)
print(response.json())
print("\n\n")
print(response.json()['text'])
Le code ci-dessus en print_transcription.py est très similaire au code dans le précédent transcribe.py fichier source. importe os (système d'exploitation) de la bibliothèque standard Python, comme nous l'avons fait dans les deux fichiers précédents, pour obtenir le TRANSCRIPTION_ID et ASSEMBLYAI_KEY valeurs des variables d'environnement.
Le endpoint est simplement le point de terminaison de l'API AssemblyAI pour récupérer les transcriptions. Nous définissons le authorization approprié header et faire l'appel API en utilisant le requests.get fonction. Nous imprimons ensuite la réponse JSON ainsi que le texte qui a été transcrit.
Il est temps de tester ce troisième fichier. Exécutez la commande suivante dans le terminal :
python print_transcription.py
Votre sortie sera différente en fonction de votre enregistrement, mais vous devriez voir un résultat dans le terminal similaire à ce qui suit :
{'audio_end_at': None, 'acoustic_model': 'assemblyai_default', 'auto_highlights_result': None, 'text': 'An object relational mapper is a code library that automates the transfer of data stored in a relational database tables into objects that are more commonly used in application. Code or MS provide a high level abstraction upon a relational database that allows the developer to write Python code. Instead of sequel to create read update and delete data and schemas in their database developers can use the programming language that they are comfortable with comfortable to work with the database instead of writing sequel statements or short procedures.', 'audio_url': 'https://api.twilio.com/2010-04-01/Accounts/ACe3737affa0d2e17561ad44c9d190e70c/Recordings/RE3b42cf470bef829c3680ded961a09300', 'speed_boost': False, 'language_model': 'assemblyai_default', 'id': 'zibe9vwmx-82ce-476c-85a7-e82c09c67daf', 'confidence': 0.931797752808989, 'webhook_status_code': None, 'status': 'completed', 'boost_param': None, 'redact_pii': False, 'words': [{'text': 'An', 'confidence': 1.0, 'end': 90, 'start': 0}, {'text': 'object', 'confidence': 0.94, 'end': 570, 'start': 210}, {'text': 'relational', 'confidence': 0.89, 'end': 1080, 'start': 510}, {'text': 'mapper', 'confidence': 0.97, 'end': 1380, 'start': 1020}, {'text': 'is', 'confidence': 0.88, 'end': 1560, 'start': 1350}, {'text': 'a', 'confidence': 0.99, 'end': 1620, 'start': 1500}, {'text': 'code', 'confidence': 0.93, 'end': 1920, 'start': 1620}, {'text': 'library', 'confidence': 0.94, 'end': 2250, 'start': 1860}, {'text': 'that', 'confidence': 0.99, 'end': 2490, 'start': 2220}, {'text': 'automates', 'confidence': 0.93, 'end': 2940, 'start': 2430}, {'text': 'the', 'confidence': 0.95, 'end': 3150, 'start': 2910}, {'text': 'transfer', 'confidence': 0.98, 'end': 3510, 'start': 3090}, {'text': 'of', 'confidence':
0.99, 'end': 3660, 'start': 3480}, {'text': 'data', 'confidence': 0.84, 'end': 3960, 'start': 3630}, {'text': 'stored', 'confidence': 0.89, 'end': 4350, 'start': 3900}, {'text': 'in', 'confidence': 0.98, 'end': 4500, 'start': 4290}, {'text': 'a', 'confidence': 0.85, 'end': 4560, 'start': 4440}, {'text': 'relational', 'confidence': 0.87, 'end': 5580, 'start': 4500}, {'text': 'database', 'confidence': 0.92, 'end':
6030, 'start': 5520}, {'text': 'tables', 'confidence': 0.93, 'end': 6330, 'start': 5970}, {'text': 'into', 'confidence': 0.92, 'end': 7130, 'start': 6560}, {'text': 'objects', 'confidence': 0.96, 'end': 7490, 'start': 7100}, {'text': 'that', 'confidence': 0.97, 'end': 7700, 'start': 7430}, {'text': 'are', 'confidence': 0.9, 'end': 7850, 'start': 7640}, {'text': 'more', 'confidence': 0.97, 'end': 8030, 'start': 7790}, {'text': 'commonly', 'confidence': 0.92, 'end': 8480, 'start': 7970}, {'text': 'used', 'confidence': 0.86, 'end': 8750, 'start': 8420}, {'text': 'in', 'confidence': 0.94, 'end': 9050, 'start': 8840}, {'text': 'application.', 'confidence': 0.98, 'end': 9860, 'start': 9110}, {'text': 'Code', 'confidence': 0.93, 'end': 10040, 'start': 9830}, {'text': 'or', 'confidence': 1.0, 'end': 11210, 'start': 10220}, {'text': 'MS', 'confidence': 0.83, 'end': 11480, 'start': 11180}, {'text': 'provide', 'confidence': 0.94, 'end': 11870, 'start': 11510}, {'text': 'a', 'confidence': 1.0, 'end': 11960, 'start': 11840}, {'text': 'high', 'confidence': 1.0, 'end': 12200, 'start': 11930}, {'text': 'level', 'confidence': 0.94, 'end': 12440, 'start': 12170}, {'text': 'abstraction', 'confidence': 0.95, 'end': 12980, 'start': 12410}, {'text':
'upon', 'confidence': 0.94, 'end': 13220, 'start': 12950}, {'text': 'a', 'confidence': 1.0, 'end': 13280, 'start': 13160}, {'text': 'relational', 'confidence': 0.94, 'end': 13820, 'start': 13280}, {'text': 'database', 'confidence': 0.95, 'end': 14210, 'start': 13790}, {'text': 'that', 'confidence': 0.96, 'end': 14420, 'start': 14150}, {'text': 'allows', 'confidence': 0.99, 'end': 14720, 'start': 14360}, {'text':
'the', 'confidence': 0.56, 'end': 14870, 'start': 14690}, {'text': 'developer', 'confidence': 0.98, 'end': 15290, 'start': 14810}, {'text': 'to', 'confidence': 0.94, 'end': 15410, 'start': 15230}, {'text': 'write', 'confidence': 0.96, 'end': 15680, 'start': 15380}, {'text': 'Python', 'confidence': 0.94, 'end': 16070, 'start': 15620}, {'text': 'code.', 'confidence': 0.98, 'end': 16310, 'start': 16070}, {'text': 'Instead', 'confidence': 0.97, 'end': 17160, 'start': 16500}, {'text': 'of', 'confidence': 0.93, 'end': 17340, 'start': 17130}, {'text': 'sequel', 'confidence': 0.86, 'end': 17820, 'start': 17280}, {'text': 'to', 'confidence': 0.91, 'end': 18090, 'start': 17880}, {'text': 'create', 'confidence': 0.89, 'end': 18450, 'start': 18090}, {'text': 'read', 'confidence': 0.88, 'end': 18840, 'start': 18480}, {'text': 'update', 'confidence': 0.92, 'end': 19290, 'start': 18870}, {'text': 'and', 'confidence': 0.94, 'end': 19590, 'start': 19230}, {'text': 'delete', 'confidence': 0.89, 'end': 19920, 'start': 19530}, {'text': 'data',
'confidence': 0.95, 'end': 20190, 'start': 19890}, {'text': 'and', 'confidence': 0.92, 'end': 20490, 'start': 20250}, {'text': 'schemas', 'confidence': 0.86, 'end': 21000, 'start': 20430}, {'text': 'in', 'confidence': 0.94, 'end': 21210, 'start': 21000}, {'text': 'their', 'confidence': 0.98, 'end': 21510, 'start': 21150}, {'text': 'database', 'confidence': 0.97, 'end': 21900, 'start': 21450}, {'text': 'developers', 'confidence': 0.83, 'end': 23200, 'start': 22420}, {'text': 'can', 'confidence': 0.95, 'end': 23440, 'start': 23200}, {'text': 'use', 'confidence': 0.97, 'end': 23650, 'start': 23410}, {'text': 'the', 'confidence': 0.99, 'end': 23890, 'start': 23590}, {'text': 'programming', 'confidence': 0.97, 'end': 24370, 'start': 23830}, {'text': 'language', 'confidence': 1.0, 'end': 24700, 'start': 24310}, {'text': 'that', 'confidence': 1.0, 'end': 24880, 'start': 24640}, {'text': 'they', 'confidence': 0.99, 'end': 25060, 'start': 24820}, {'text': 'are', 'confidence': 0.85, 'end': 25210, 'start': 25000}, {'text': 'comfortable', 'confidence': 0.92, 'end': 25780, 'start': 25180}, {'text': 'with', 'confidence': 1.0, 'end': 25960, 'start': 25720}, {'text': 'comfortable', 'confidence': 0.94, 'end': 29090, 'start': 28090}, {'text': 'to', 'confidence': 0.84, 'end': 29840, 'start': 29180}, {'text': 'work', 'confidence': 0.95, 'end': 30050, 'start': 29780}, {'text': 'with', 'confidence': 0.98, 'end': 30290, 'start': 30020}, {'text': 'the', 'confidence': 0.69, 'end': 30440, 'start': 30230}, {'text': 'database', 'confidence': 0.98, 'end': 30860, 'start': 30380}, {'text': 'instead', 'confidence': 1.0, 'end': 32780, 'start': 31780}, {'text': 'of', 'confidence': 0.98, 'end': 32900, 'start': 32720}, {'text': 'writing', 'confidence': 0.87, 'end': 33320, 'start': 32870}, {'text': 'sequel', 'confidence': 0.88, 'end': 33860, 'start': 33290}, {'text': 'statements', 'confidence': 0.95, 'end': 34310, 'start': 33800}, {'text': 'or', 'confidence': 0.9, 'end': 34460, 'start': 34250}, {'text': 'short', 'confidence': 0.9, 'end': 34790, 'start': 34430}, {'text': 'procedures.', 'confidence': 0.98, 'end': 35270, 'start': 34760}], 'format_text': True, 'webhook_url': None, 'punctuate': True, 'utterances': None, 'audio_duration': 36.288, 'auto_highlights': False, 'word_boost': [],
'dual_channel': None, 'audio_start_from': None}
An object relational mapper is a code library that automates the transfer of data stored in a relational database tables into objects that are more commonly used in application. Code or MS provide a high level abstraction upon a relational database that allows the developer to write Python code. Instead of sequel to create read update and delete data and schemas in their database developers can use the programming language that they are comfortable with comfortable to work with the database instead of writing sequel statements or short procedures.
C'est beaucoup de sortie. La première partie contient les résultats de la transcription et la confiance dans l'exactitude de chaque mot transcrit. La deuxième partie est juste la sortie en texte brut de la transcription.
Vous pouvez maintenant utiliser ce code de base et l'ajouter à toute application nécessitant une transcription de synthèse vocale de haute qualité. Si les résultats ne vous conviennent pas, consultez ce didacticiel sur l'amélioration de la précision des mots clés ou des expressions, ainsi que sur l'amélioration de la correspondance de vos données avec la détection de sujets.
Et maintenant ?
Nous venons de terminer la création d'une application de transcription extrêmement précise pour les enregistrements.
Ensuite, essayez certains de ces autres didacticiels Python associés :
- Comment transcrire des enregistrements vocaux en texte avec Python
- Signalisation d'exceptions dans les scripts Python avec Sentry
- Types de données de base en Python :chaînes
Des questions? Faites-le moi savoir via un ticket de problème GitHub sur le référentiel Full Stack Python, sur Twitter@fullstackpythonou @mattmakai.
