Obtenez "Bals" avec Amazon Echo

Ce message est je le referai cette année! AWS Lambda Tied Up Advent Calendar 2015 --Qiita est l'article du 18e jour. Lambda ligoté, mais cet article contient beaucoup d'ingrédients dans Amaozon Echo, Alexa Skills Kit ...

Qu'est-ce que Barus?

Inutile de dire que les horribles paroles de destruction. L'ancêtre a déjà créé une commande pour limiter la destruction et la mettre au monde https://github.com/qphoney/balus Cette fois, je ne suis pas si impitoyable.

Qu'est-ce qu'Amazon Echo?

Il peut répondre aux questions et coopérer avec les services par reconnaissance vocale. Vous pouvez ajouter des fonctionnalités à l'aide de l'Amazon Skills Kit. Les compétences tierces peuvent être examinées, installées et utilisées à partir d'un site dédié. https://youtu.be/7Jc82wIL7m4 IMAGE ALT TEXT HERE

Qu'est-ce qu'Amazon Skills Kit?

Alexa est un service de reconnaissance vocale basé sur le cloud utilisé par Amazon Echo. Le kit de compétences Alexa fournit l'environnement dont vous avez besoin pour créer facilement les fonctionnalités (compétences) qu'Alexa peut utiliser. Consultez le kit de compétences Amazon Alexa

Créer une fonction Lambda pour Alexa Skills Kit (ASK)

Lambda devient Python dans re: Invent l'autre jour Il a été annoncé qu'il était pris en charge, mais Lambda peut désormais être utilisé avec les fonctions ASK. Cependant, comme ASK ne prend en charge que la région «us-east-1», le modèle ASK n'apparaîtra pas dans la liste des modèles Lambda des autres régions.

スクリーンショット 2015-12-15 16.35.37.png

Cette fois, j'ai un peu modifié ce modèle et implémenté Barus.

# -*- coding: utf-8 -*-
from __future__ import print_function
import boto3
from time import gmtime, strftime

client = boto3.client('ec2')

#Point d'accès
def lambda_handler(event, context):
    print(strftime('%a, %d %b %Y %H:%M:%S +0000', gmtime()))
    print(event)

    if event['request']['type'] == "LaunchRequest":
        #demande de début de compétence
        return on_launch(event['request'], event['session'])
    elif event['request']['type'] == "IntentRequest":
        #Appel d'intention
        return on_intent(event['request'], event['session'])

    print("nothing and finish")
    return get_finish_response()

def on_launch(launch_request, session):
    #Obtenez le mot de la magie
    return get_charm_response()

def on_intent(intent_request, session):

    intent = intent_request['intent']
    intent_name = intent_request['intent']['name']
    #Si vous n'incluez pas les mots de destruction, vous avez terminé
    if 'Barusu' not in intent['slots'] or \
       'value' not in intent['slots']['Barusu'] or \
       not intent_name == "RunHorobi":
        return get_finish_response()
    
    print(intent['slots']['Barusu']['value'])

    stop_instance()
    return get_horobi_response()

#Générer une réponse de mot magique
def get_charm_response():

    session_attributes = {}
    card_title = "Charm"
    audio_url = "https://url/to/your/audio.mp3"
    should_end_session = False
    return build_response(session_attributes, build_audio_response(
        card_title, speech_output, audio_url, should_end_session))

#Génère une réponse qui revient lorsque le mot de destruction est dit
def get_horobi_response():

    session_attributes = {}
    card_title = "Horobi"
    speech_output = "Megaaaaa!"
    reprompt_text = speech_output
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

#Générer une réponse quand rien n'est fait
def get_finish_response():

    session_attributes = {}
    card_title = "Words that should not be used"
    speech_output = "Don't say the word of horobee"
    reprompt_text = speech_output
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

#Obtenez une instance pour vous arrêter à Barth
def get_instances():
    response = client.describe_instances(
        Filters=[
            {
                'Name': 'tag-value','Values': [
                    'laputa',
                ]
            }
        ]
    )
    instance_ids = []
    for res in response['Reservations']:
        for item in res['Instances']:
            instance_ids.append(item['InstanceId'])
    return instance_ids

#Démarrer l'instance
def start_instance():
    print('start_instance')
    response = client.start_instances(
        InstanceIds=get_instances()
    )

#Mettre fin à l'instance
def stop_instance():
    print('stop_instance')
    response = client.stop_instances(
        InstanceIds=get_instances()
    )

#Générer JSON pour la valeur de retour
def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'PlainText',
            'text': output
        },
        'card': {
            'type': 'Simple',
            'title': 'SessionSpeechlet - ' + title,
            'content': 'SessionSpeechlet - ' + output
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'PlainText',
                'text': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }

#Générer la valeur de retour du format SSML JSON
def build_audio_response(title, output, audio_url, should_end_session):
    return {
        'outputSpeech': {
            'type': 'SSML',
            'ssml': '<speak><audio src="{0}" /></speak>'.format(audio_url)
        },
        'card': {
            'type': 'Simple',
            'title': 'SessionSpeechlet - ' + title,
            'content': 'SessionSpeechlet - ' + output
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'SSML',
                'ssml': '<speak><audio src="{0}" /></speak>'.format(audio_url)
            }
        },
        'shouldEndSession': should_end_session
    }

#Valeur de retour globale
def build_response(session_attributes, speechlet_response):
    return {
        'version': '1.0',
        'sessionAttributes': session_attributes,
        'response': speechlet_response
    }

Dans ce script, parlez à «Alexa, lancez laputa» et Amazon Echo et ils répondront au magique «Lite Latobarita Urs Ariaros Bar Netril» en cas de problème.

Alexa Skills renvoie le texte et parle sur Amazon Echo et [SSML (Speech Synthesis Markup Language)](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/ Il existe un moyen de parler en utilisant speech-synthèse-markup-language-ssml-reference), mais [l'annonce de l'autre jour](https://developer.amazon.com/public/community/post/Tx3FXYSTHS579WO/Announcing-New- Alexa-Skills-Kit-ASK-Features-SSML-Audio-Tags-and-Developer-Porta) peut désormais gérer des données audio arbitraires. La prononciation d'Alexa est basée sur l'anglais, donc je spécifie le fichier mp3 à synthèse vocale avec SSML. (À build_audio_response)

Restrictions relatives aux fichiers audio

Les fichiers audio que Amazon Echo peut lire ont de petites restrictions et doivent être au format suivant.

--Fichier MP3 valide (MPEG version 2) --Dans 90 secondes

Lors de l'utilisation de ffmpeg sur mac, la commande suivante

ffmpeg -i input.mp3 -ac 2 -codec:a libmp3lame -b:a 48k -ar 16000 output.mp3

Ajouter des compétences Alexa

Skill information https://developer.amazon.com/edw/home.html#/ Sélectionnez ʻAlexa Skills Kit dans le tableau de bord et enregistrez-en un nouveau depuis ʻAjouter une nouvelle compétence. スクリーンショット 2015-12-15 18.09.39.png Sélectionnez Lambda dans ʻEndpoint` et spécifiez l'ARN de la fonction Lambda que vous venez de créer.

Intent Schema

{
  "intents": [
    {
      "intent": "RunHorobi",
      "slots": [
        {
          "name": "Barusu",
          "type": "LIST_OF_BARUSU"
        }
      ]
    }
  ]
}

Définissez la définition du mot clé attaché à l'intention (fonction côté fonction Lambda).

Custom Slot Types

barusu
bars
barus
barsu

Enregistrez le mot-clé correspondant. (Cependant, d'après ce que j'ai entendu lors de l'atelier, il semble qu'il soit inévitable que la fonction Lambda soit lue en réponse à des mots-clés non enregistrés ici.)

Sample Utterances

RunHorobi {Barusu}

Il spécifie quelle intention appeler en fonction du mot prononcé. Il existe plusieurs modèles de la façon dont l'utilisateur parle réellement, donc si vous supposez cela et liez plusieurs phrases à l'intention, il sera plus facile pour le côté ASK de s'identifier.

tester

ASK dispose d'un mécanisme qui vous permet de tester Skill sans utiliser Amazon Echo. スクリーンショット 2015-12-15 19.06.37.png Vous pouvez l'utiliser pour tester les fonctions Lambda afin de ne pas avoir à parler à Echo lors du débogage. Cliquez sur le bouton de lecture en bas à droite et il prononcera le texte de retour. (Cependant, SSML n'est actuellement pas pris en charge)

Confirmation réelle de la machine

Vous pouvez vérifier les mots réellement prononcés et les résultats sur le Tableau de bord sur l'Echo enregistré comme votre appareil. .. スクリーンショット 2015-12-15 19.11.29.png

https://youtu.be/7Jc82wIL7m4 IMAGE ALT TEXT HERE

Résumé

En utilisant Amazon Echo, vous pouvez désormais créer un "Bals" plus réaliste. (Si vous avez une pierre volante de reconnaissance vocale, vous vous sentirez plus excité) Cependant, Amazon Echo ne prend pas encore en charge le japonais, donc l'expression «yeux!» Est trop décevante. J'espère que vous répondrez dans les plus brefs délais.

Histoire sérieuse

Maintenant que Lambda peut être écrit en Python, il est beaucoup plus facile de coder personnellement. Avec l'ajout de tests de compétences et de simulateurs, il est désormais possible de construire assez bien sans Amazon Echo.

Recommended Posts

Obtenez "Bals" avec Amazon Echo
Reconnaissance faciale par Amazon Rekognition
Préparer l'environnement pipenv avec Amazon Linux 2
Envoyez automatiquement des e-mails avec Amazon SES
Données de sous-titres créées avec Amazon Transcribe
Réalisez une interface utilisateur de type Netflix avec FlexSlider2
Obtenez un rembourrage de réflexion Pytorch avec Tensorflow