Partager:
Aaron était défenseur des développeurs chez Nexmo. Ingénieur logiciel chevronné et artiste numérique en herbe, Aaron est souvent amené à créer des choses avec du code ou de l'électronique, parfois les deux. On peut généralement savoir qu'il travaille sur quelque chose de nouveau grâce à l'odeur de composants brûlés qui flotte dans l'air.
Classifier automatiquement les enregistrements d'appels à l'aide du NLP
Temps de lecture : 3 minutes
L'API Voice de Nexmo facilite l'enregistrement des appels téléphoniques entrants et sortants. Cependant, localiser chaque appel où des personnes discutent d'un sujet particulier, tel que l'informatique, peut prendre beaucoup de temps si vous devez écouter chaque fichier audio à chaque fois.
Dans ce tutoriel, nous allons vous montrer comment vous pouvez utiliser le traitement du langage naturel, via Google Cloud Services, pour classer automatiquement le contenu de chaque enregistrement afin d'identifier rapidement les appels vocaux qui portaient sur des sujets spécifiques.
Tout le code pour ce tutoriel est disponible sur GitHub. Il utilise pipenv pour gérer les dépendances et nécessite Python 3.6.4. Vous pouvez créer un environnement virtuel et installer les dépendances en exécutant :
pipenv installNous allons utiliser l'API Voice de Nexmo, en particulier l'action record action. Avant de poursuivre ce tutoriel, nous vous conseillons de lire nos blocs de construction vocale ainsi que certains de nos précédents tutoriels sur la création d'Applications Voice.
To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.
This tutorial also uses a virtual phone number. To purchase one, go to Numbers > Buy Numbers and search for one that meets your needs.
Nous utilisons également deux API de Google Cloud Services dans ce tutoriel : Cloud Speech-to-Text et Cloud Natural Language. Vous devez créer un nouveau projet Google Cloud Platform (GCP) et vous assurer que vous activez Speech-to-Text et Natural Language.
N'oubliez pas de télécharger les informations d'identification de votre projet GCP et de les stocker à un endroit où votre script peut y accéder. J'ai ajouté les miennes à la racine du projet et je les ai nommées google_private.json.
Il y a un fichier .env.example à la racine du projet. Ce fichier d'exemple décrit les différentes variables environnementales attendues par l'application. Copiez ce fichier et renommez-le en .env. Toutes les valeurs définies dans ce fichier sont automatiquement chargées dans votre environnement lors de l'exécution :
pipenv shellEnregistrement de notre appel
Nous espérons qu'à ce stade, vous connaissez les OCNC. Notre première route Flask va servir notre fichier NCCO, ordonnant à l'API Voice de Nexmo d'enregistrer tous les appels à notre numéro virtuel :
@app.route("/", methods=["GET"])
def ncco():
logger.info(f"New call received from {request.args['from']}")
return jsonify(
[
{"action": "talk", "text": "Record your message after the beep"},
{
"action": "record",
"eventUrl": [f"{os.environ['BASE_URL']}/recordings"],
"format": "wav",
"endOnKey": "*",
"beepStart": True,
},
]
)Il y a deux choses principales à noter dans le code ci-dessus :
Les
event_urlpointe vers notre serveur Flask local. Le gestionnaire de cette route est abordé plus loin dans le tutoriel.Le format d'enregistrement est réglé sur
wavPar défaut, Nexmo fournit les enregistrements sous forme de fichiers MP3. Cependant, le service Google Speech-to-Text prend en charge le format WAV, et nous devons donc adapter le format de notre enregistrement.
Chaque fois qu'un appel est terminé, l'API Voice de Nexmo envoie une POST à notre event_url. J'ai extrait la plupart des tâches lourdes du gestionnaire de vue Flask et les ai transférées dans une série de tâches d'arrière-plan utilisant la technologie Huey:
pipeline = download_recording_task.then(transcribe_audio).then(classify_transcription)
huey.enqueue(pipeline)
La méthode get_recording sur le client client Nexmo Python est nouvelle, donc si vous avez déjà installé le client Python, vous devrez probablement le mettre à jour :
@huey.task()
def download_recording(recording_url, recording_uuid):
logger.info(f"Download recording {recording_uuid}")
recording = nexmo_client.get_recording(recording_url)
recordingfile = f"./recordings/{recording_uuid}.wav"
os.makedirs(os.path.dirname(recordingfile), exist_ok=True)
with open(recordingfile, "wb") as f:
f.write(recording)
return {"recording_uuid": recording_uuid}Après avoir récupéré le fichier WAV de Nexmo, l'application l'enregistre dans le répertoire recordings dans le répertoire La fonction download_recording renvoie la valeur recording_uuid dans un dictionnaire, car Huey transmet toutes les valeurs de retour à la fonction suivante dans le pipeline en tant qu'arguments de mot-clé.
Avant de pouvoir effectuer un traitement en langage naturel du contenu de notre fichier audio, nous devons le convertir en texte :
@huey.task()
def transcribe_audio(*args, recording_uuid):
# Instantiates a client
client = speech.SpeechClient()
# The name of the audio file to transcribe
file_name = f"./recordings/{recording_uuid}.wav"
# Loads the audio into memory
with io.open(file_name, "rb") as audio_file:
content = audio_file.read()
audio = speech_types.RecognitionAudio(content=content)
config = speech_types.RecognitionConfig(
encoding=speech_enums.RecognitionConfig.AudioEncoding.LINEAR16,
sample_rate_hertz=16000,
language_code="en-US",
)
# Detects speech in the audio file
logger.info(f"Sending file {recording_uuid} for transcribing")
response = client.recognize(config, audio)
return {
"transcription_text": response.results[0].alternatives[0].transcript,
"recording_uuid": recording_uuid,
}Vous pouvez en savoir plus sur l'API Speech-to-Text de Google Cloud Speech-to-Text API sur leur site web. Maintenant que le fichier audio est converti en texte, la fonction suivante du pipeline est déclenchée.
Screenshot of terminal showing audio classification
L'application effectue un dernier appel d'API, cette fois au service Google Cloud Language :
@huey.task()
def classify_transcription(transcription_text, recording_uuid):
client = language.LanguageServiceClient()
document = language_types.Document(
content=transcription_text, type=language_enums.Document.Type.PLAIN_TEXT
)
logger.info(f"Classifying transcription for recording {recording_uuid}")
categories = client.classify_text(document).categories
for category in categories:
print(colorful.bold_violet("=" * 20))
print(colorful.bold_violet("{:<16}: {}".format("name", category.name)))
print(
colorful.bold_violet("{:<16}: {}".format("confidence", category.confidence))
)
return True
Cette API peut faire bien plus que simplement classer du texte ; elle peut fournir des informations sur le sentiment du texte fourni, ou décomposer le texte en une série de phrases et de jetons à l'aide de l'analyse syntaxique. Lisez la documentation pour plus de détails.
Nous espérons que notre tutoriel vous a donné une idée de ce qu'il est possible de faire en combinant l'API Voice de Nexmo avec Google Cloud. Si vous souhaitez plus d'informations sur d'autres choses passionnantes que vous pouvez réaliser avec Nexmo Voice API, ces autres tutoriels vous intéresseront :
Partager:
Aaron était défenseur des développeurs chez Nexmo. Ingénieur logiciel chevronné et artiste numérique en herbe, Aaron est souvent amené à créer des choses avec du code ou de l'électronique, parfois les deux. On peut généralement savoir qu'il travaille sur quelque chose de nouveau grâce à l'odeur de composants brûlés qui flotte dans l'air.