Applications PHP à commande vocale avec API.AI

Dans ce tutoriel, nous allons étudier API.ai, une API qui nous permet de créer des applications qui comprennent le langage naturel, un peu comme Siri. Il peut accepter le texte ou la parole en entrée, qu'il analyse ensuite et renvoie une chaîne JSON qui peut être interprétée par le code que nous écrivons.

Tous les fichiers que nous utiliserons dans ce tutoriel sont disponibles dans ce référentiel GitHub.

Les plats clés

• api.ai permet aux développeurs de créer des applications PHP qui comprennent les entrées de langage naturel, similaires à Siri, en traitant du texte ou de la parole et en renvoyant des données exploitables au format JSON.
• Les concepts clés de l'API.ai incluent des agents (applications), des entités (concepts personnalisés comme les devises), des intentions (actions basées sur les commandes utilisateur), des contextes (contexte d'expression de l'utilisateur), des alias (références d'entités dans le code) et des domaines ( packages de connaissances prédéfinis).
• Le tutoriel montre la création d'une application PHP pour récupérer l'heure actuelle dans n'importe quel emplacement à l'aide d'API.ai, de l'API géocoding de Google et de l'API du fuseau horaire, illustrant comment intégrer et convertir les données de l'API en réponses utilisables.
• La fonctionnalité des domaines de l'API.ai, toujours en bêta, simplifie l'intégration en fournissant des entités et des intentions intégrées qui nécessitent une configuration minimale, permettant une création rapide d'applications telles que les recherches vidéo sur YouTube.
• Le didacticiel couvre également la création d'une application PHP de convertisseur de devises à l'aide d'API.ai, présentant comment gérer les entrées utilisateur, définir les intentions et les entités et s'intégrer à des API externes comme le Currencylayer pour les données en temps réel.
• api.ai prend en charge plusieurs plates-formes et langues, offrant aux développeurs de la flexibilité de créer des applications sur les environnements Web, y compris des applications mobiles et de bureau.

concepts

Avant de passer à la partie pratique, il est important que nous comprenions d'abord les concepts suivants:

• Agents - Les agents sont des applications. Nous créons un agent comme moyen de regrouper des entités et des intentions individuelles.

• Entités - Les entités sont des concepts personnalisés que nous voulons intégrer dans notre application. Ils fournissent un moyen de donner un sens à un concept spécifique au moyen d'ajouter des exemples. Une entité d'échantillon serait «monnaie». Nous le définissons en ajoutant des synonymes tels que «USD», «US Dollar» ou simplement «Dollars». Chaque synonyme est ensuite attribué à une valeur de référence qui peut être utilisée dans le code. C’est juste une liste de mots qui peuvent être utilisés pour se référer à ce concept. Api.ai fournit déjà quelques entités de base telles que @ sys.number, qui est une entité faisant référence à n'importe quel numéro, et @ sys.email qui est une entité faisant référence à toute adresse e-mail. Nous pouvons utiliser les entités intégrées en spécifiant @SYS comme préfixe.

• Intentes - Les intentions nous permettent de définir les actions que le programme exécutera en fonction de ce qu'un utilisateur dit. Une intention d'échantillon serait la «monnaie convertie». Nous énumérons ensuite toutes les phrases ou phrases possibles que l'utilisateur dirait s'ils veulent convertir la monnaie. Par exemple, un utilisateur pourrait dire «Combien coûte @ sys.number: numéro @Currency: FromCurrency dans @Currency: TOCURRENCY?». Dans cet exemple, nous avons utilisé 2 entités: @ sys.number et @Currency. L'utilisation du côlon après l'entité nous permet de définir un alias pour cette entité. Cet alias peut ensuite être utilisé dans notre code pour obtenir la valeur de l'entité. Nous devons donner à la même entité un alias différent afin que nous puissions les traiter séparément dans notre code. Pour que les humains comprennent l'intention ci-dessus, tout ce que nous avons à faire est de remplacer les entités par des valeurs réelles. Un utilisateur peut donc dire «combien coûte 900 dollars américains en yen japonais? pour la tocarrency @currency.

• Contextes - Les contextes représentent le contexte actuel d'une expression utilisateur. Par exemple, un utilisateur pourrait dire «Combien coûte 55 dollars américains en yen japonais?» Et puis suivre avec «Et en peso philippin?». Api.ai, dans ce cas, utilise ce qui avait été précédemment parlé par l'utilisateur «combien coûte 55 dollars américains», comme contexte de la deuxième expression.

• Alias ​​- Les alias fournissent un moyen de se référer à une entité spécifique de votre code, comme nous l'avons vu plus tôt dans l'explication des intentions.

• Domaines - Les domaines sont des packages de connaissances prédéfinis. Nous pouvons les considérer comme une collection d'entités et d'intentions intégrées dans API.ai. En d'autres termes, ce sont des astuces qu'API.ai peut effectuer avec peu ou pas de configuration ou de codage requis. Par exemple, un utilisateur peut dire: «Trouver des vidéos de Pikachu sur YouTube». Et API.ai saurait déjà analyser cela et renvoie «Pikachu» comme terme de recherche et «YouTube» comme service. À partir de là, nous pouvons simplement utiliser les données renvoyées pour naviguer vers YouTube et rechercher «Pikachu». Dans JavaScript, il ne s'agit que de définir l'emplacement.href pour pointer la page des résultats de recherche de YouTube:

  <span>window.location.href = "https://www.youtube.com/results?search_query=pikachu";</span>

Pour utiliser des domaines pour votre agent, sélectionnez votre agent dans la console, puis cliquez sur le menu des domaines en haut. De là, activez la base de connaissances et l'accomplissement des domaines. Notez que les domaines sont actuellement en version bêta, mais vous pouvez toujours utiliser la console API pour les tester.

L'activation de la base de connaissances des domaines permet la fonctionnalité des domaines. L'activation de l'accomplissement permet d'utiliser des services tiers tels que les petites conversations et la météo. Cela signifie que nous n'aurons pas besoin de faire une demande séparée à une API spécifique si le service dont nous avons besoin est déjà intégré à API.ai.

Obtenir l'heure actuelle dans un endroit spécifique

Maintenant que nous avons une compréhension des principaux concepts, nous pouvons procéder à la création d'une application simple. La première chose que nous allons créer est une application pour obtenir l'heure actuelle dans un endroit spécifique.

Si vous ne l'avez pas déjà fait, inscrivez-vous à un compte gratuit sur le site Web API.AI, vérifiez votre adresse e-mail, puis connectez-vous / connectez-vous avec vos informations d'identification.

Ensuite, accédez à la page Agents et créez un nouvel agent en cliquant sur le bouton "Créer un agent". Une fois dans la page pour créer un nouvel agent, entrez le nom, la description et la langue, et enregistrer.

Cela vous donne la clé d'abonnement, le jeton d'accès du développeur et le jeton d'accès client. Vous pouvez les utiliser pour faire des demandes à l'API, soit auprès du client (navigateur), soit du serveur. Un avantage de faire les demandes du serveur est de garder vos informations d'identification cachées.

L'agent que nous avons créé utilisera des domaines. Cela signifie que nous n'avons pas besoin de configurer des entités et des intentions. Ce dont nous avons besoin, c'est un peu d'aide de deux API Google: API Geocoding et API du fuseau horaire. L'API de géocodage est utilisée pour convertir l'emplacement que nous obtenons de l'API.ai en coordonnées. Nous utilisons ensuite ces coordonnées pour interroger l'API du fuseau horaire pour obtenir l'heure actuelle pour cet emplacement. Accédez à votre console Google et activez l'API du fuseau horaire. L'API de géocodage ne nécessite pas une clé d'API à fournir, nous n'avons donc pas besoin de l'activer.

Ensuite, installez Guzzle. Nous utiliserons Guzzle 5 pour faire une demande à api.ai.

<span>window.location.href = "https://www.youtube.com/results?search_query=pikachu";</span>

Ensuite, créez un nouveau fichier PHP (time.php) et ajoutez le code suivant afin que nous puissions utiliser Guzzle à partir de notre fichier.

<span>composer require guzzlehttp/guzzle:~5.0</span>

Après cela, définissez vos clés API:

<span><?php
</span><span>require 'vendor/autoload.php';
</span><span>
</span><span>use GuzzleHttp\Client;
</span><span>
</span><span>$client = new Client();</span>

Naturellement, dans une vraie application, vous conserveriez probablement des informations d'identification en dehors de la logique de l'application, dans une sorte de fichier de configuration local.

Nous pouvons maintenant faire une demande à api.ai. Pour faire une demande, nous devons passer dans le jeton d'accès du développeur et la clé d'abonnement comme en-têtes. Nous passons ensuite dans le corps de la demande en tant que JSON. Le corps de demande doit contenir la requête et les clés Lang. La requête est soumise à partir du côté client via une demande de poste. Un exemple de requête pour cette application serait «Quelle heure est-il à Barcelone, en Espagne?» ou "Quelle est l'heure actuelle à Ikebukuro, au Japon?". La réponse renvoyée est une chaîne JSON, nous la convertissons donc en un tableau en appelant la méthode JSON sur la réponse $.

<span>$google_api_key = 'YOUR_GOOGLE_API_KEY';
</span><span>$apiai_key = 'YOUR_API_AI_AGENT_DEVELOPER_ACCESS_TOKEN';
</span><span>$apiai_subscription_key = 'YOUR_API_AI_SUBSCRIPTION_KEY';</span>

Voici un exemple de réponse que nous obtenons lorsque nous faisons la demande ci-dessus:

<span>$query = $_POST['query']; //the users query
</span><span>
</span><span>$response = $client->post('https://api.api.ai/v1/query', array(
</span><span>    'headers' => array(
</span><span>        'Authorization' => "Bearer {$apiai_key}",
</span><span>        'ocp-apim-subscription-key' => $apiai_subscription_key,
</span><span>        'Content-Type' => 'application/json; charset=utf-8'
</span><span>    ),
</span><span>    'json' => array(
</span><span>        "query" => $query,
</span><span>        "lang" => "en"
</span><span>    )
</span><span>));
</span><span>
</span><span>$result = $response->json();</span>

Si nous obtenons un code de statut de 200, cela signifie que la demande a réussi. Les données dont nous avons besoin sont stockées dans l'élément de résultat. Dans ce cas, nous n'avons qu'à extraire l'emplacement des paramètres. Si un emplacement n'est pas retourné, nous disons simplement à l'utilisateur que l'emplacement n'est pas trouvé.

<span>window.location.href = "https://www.youtube.com/results?search_query=pikachu";</span>

Si un emplacement est trouvé, nous faisons une demande à l'API Google Geocoding pour convertir l'emplacement en coordonnées. Si le statut est OK, cela signifie que nous avons obtenu un résultat. Nous extraissons donc simplement les valeurs de latitude et de longitude du premier résultat.

<span>composer require guzzlehttp/guzzle:~5.0</span>

Ensuite, nous obtenons l'horodatage Unix actuel. Nous transmettons cette valeur avec la latitude et la longitude comme une requête pour notre demande à l'API Google Timezone. Nous extrons ensuite le TimezoneId que nous pouvons utiliser pour définir temporairement le fuseau horaire à l'aide de la méthode date_default_timezone_set. Enfin, nous venons simplement le temps formaté à l'utilisateur.

<span><?php
</span><span>require 'vendor/autoload.php';
</span><span>
</span><span>use GuzzleHttp\Client;
</span><span>
</span><span>$client = new Client();</span>

Continuons du côté client. Créez un fichier index.html avec le code suivant:

<span>$google_api_key = 'YOUR_GOOGLE_API_KEY';
</span><span>$apiai_key = 'YOUR_API_AI_AGENT_DEVELOPER_ACCESS_TOKEN';
</span><span>$apiai_subscription_key = 'YOUR_API_AI_SUBSCRIPTION_KEY';</span>

Nous utilisons jQuery (pour la manipulation des événements) et Responsive-voice.js. La bibliothèque de voix réactive nous permet de convertir le texte en parole. Nous l'utilisons pour parler les résultats que nous obtenons du serveur.

Nous avons également la reconnaissance de la parole.js, que nous utilisons pour convertir la parole en texte. Cela utilise l'API de discours Web. Malheureusement, au moment de la rédaction, il n'est encore que partiellement pris en charge sur quelques navigateurs, donc ce tutoriel supposera que vous utilisez Chrome (qui le prend en charge).

Expliquons le fichier ci-dessus. Le premier est la variable globale que nous utiliserons pour stocker l'objet de reconnaissance vocale actuel.

<span>$query = $_POST['query']; //the users query
</span><span>
</span><span>$response = $client->post('https://api.api.ai/v1/query', array(
</span><span>    'headers' => array(
</span><span>        'Authorization' => "Bearer {$apiai_key}",
</span><span>        'ocp-apim-subscription-key' => $apiai_subscription_key,
</span><span>        'Content-Type' => 'application/json; charset=utf-8'
</span><span>    ),
</span><span>    'json' => array(
</span><span>        "query" => $query,
</span><span>        "lang" => "en"
</span><span>    )
</span><span>));
</span><span>
</span><span>$result = $response->json();</span>

Ensuite, la méthode StartreCognition. Ce que cela fait, c'est créer un nouvel objet de reconnaissance vocale. Cela demandera à l'utilisateur d'utiliser le microphone. Ensuite, nous définissons la langue en anglais et commençons la reconnaissance de la parole. Nous écoutons ensuite l'événement OnStart. Lorsque cet événement est déclenché, cela signifie que la reconnaissance vocale a commencé. Nous appelons la méthode Updaterec lorsque cela se produit, ce qui modifie le texte du bouton pour démarrer et arrêter la reconnaissance de la parole. Nous écoutons également l'événement OnResult qui est déclenché lorsque l'utilisateur a cessé de parler pendant quelques secondes. Cela contient les résultats de la reconnaissance vocale. Nous devons parcourir les résultats et utiliser l'élément de transcription dans chacun pour obtenir le texte dont nous avons besoin. Une fois cela fait, nous appelons la méthode SetInput qui modifie la valeur du champ de texte de requête et appelle la méthode d'envoi qui soumet la requête au serveur. Ensuite, nous appelons la méthode StopRecognition pour arrêter la reconnaissance vocale et mettre à jour l'interface utilisateur. Nous devons également faire de même dans l'événement Onend.

Array
(
    [id] => eb69f468-6e1a-41c9-883d-6ac7c71cd187
    1739117986 => 2015-05-16T09:19:47.519Z
    [result] => Array
        (
            [source] => domains
            [resolvedQuery] => What's the current time in Barcelona Spain?
            [speech] => 
            [action] => clock.time
            [parameters] => Array
                (
                    [location] => Barcelona Spain
                )

            [metadata] => Array
                (
                    [inputContexts] => Array
                        (
                        )

                    [outputContexts] => Array
                        (
                        )

                    [contexts] => Array
                        (
                        )

                )

        )

    [status] => Array
        (
            [code] => 200
            [errorType] => success
        )

)

voici la méthode Updaterec.

<span>if(!empty($result['result']) && !empty($result['result']['parameters']['location'])){
</span><span>    $location = $result['result']['parameters']['location'];
</span><span>
</span><span>}else{
</span><span>    echo "Sorry, I could not find that location.";
</span><span>}</span>

Méthode setInput.

<span>$place_response = $client->get("http://maps.googleapis.com/maps/api/geocode/json?address={$location}&sensor=false");
</span><span>
</span><span>$place_result = $place_response->json();
</span><span>
</span><span>if($place_result['status'] == 'OK'){
</span><span>
</span><span>    $lat = $place_result['results'][0]['geometry']['location']['lat'];
</span><span>    $lng = $place_result['results'][0]['geometry']['location']['lng'];
</span><span>}</span>

Méthode StopRecognition.

<span>$timestamp = time(); //get the current unix timestamp
</span><span>
</span><span>$time_response = $client->get("https://maps.googleapis.com/maps/api/timezone/json?location={$lat},{$lng}&timestamp={$timestamp}&key={$google_api_key}");
</span><span>
</span><span>$time_result = $time_response->json();
</span><span>
</span><span>if($time_result['status'] == 'OK'){
</span><span>    $timezone = $time_result['timeZoneId'];
</span><span>
</span><span>    date_default_timezone_set($timezone);
</span><span>
</span><span>    echo 'It's currently ' . date('l, F j, Y g:i A') . ' in ' . $location;
</span><span>}</span>

Mis à part cela, nous avons également la méthode Switchrecognition qui est appelée chaque fois que l'utilisateur clique sur le bouton pour déclencher la reconnaissance vocale pour démarrer ou arrêter.

<span><!DOCTYPE html>
</span><span><html lang="en">
</span><span><head>
</span><span>    <meta charset="UTF-8">
</span><span>    <title>time</title>
</span><span>    <script src="http://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.min.js"></script>
</span><span>    <script src="responsive-voice.js"></script>
</span><span></head>
</span><span><body>
</span><span>    <div>
</span><span>        <input type="text" id="query" name="query"> <button id="rec">Speak</button>
</span><span>    </div>
</span><span>    <div id="response"></div>
</span><span>    <script src="speech-recognition.js"></script>
</span><span>    <script src="main.js"></script>
</span><span></body>
</span><span></html></span>

Lorsque l'utilisateur appuie sur la touche Entrée sur le champ de requête, cela déclenche également la requête à envoyer au serveur.

<span>window.location.href = "https://www.youtube.com/results?search_query=pikachu";</span>

La plupart du code dans le fichier Speech-reconnaissance.js provient de ce gist qui montre un exemple de la façon d'utiliser API.ai sur le côté client.

Ensuite est le fichier main.js où nous soumettons notre requête au serveur. Une fois que nous avons obtenu une réponse, nous utilisons une voix réactive pour le parler et la publier dans le conteneur de réponse. De cette façon, nous pouvons vérifier la réponse visuellement.

<span>composer require guzzlehttp/guzzle:~5.0</span>

Convertisseur de devises

La prochaine application que nous allons créer permet aux utilisateurs de convertir un montant spécifique d'une devise à une autre.

Tout d'abord, créez un nouvel agent et appelez-le CurrencyConverter.

Sous cet agent, créez une nouvelle entité et appelez-la devise. Cela représentera les différentes monnaies que nous pouvons convertir. Définissez quelques devises que nous pouvons utiliser pour les tests et cliquez sur «Enregistrer».

Ensuite, créez une nouvelle intention et appelez-la convertmoney.

À partir de la capture d'écran ci-dessus, vous pouvez voir que nous avons ajouté ce qui suit dans la section «Says de l'utilisateur»:

<span><?php
</span><span>require 'vendor/autoload.php';
</span><span>
</span><span>use GuzzleHttp\Client;
</span><span>
</span><span>$client = new Client();</span>

La section «User dit» est l'endroit où nous définissons des exemples de ce que l'utilisateur peut dire pour déclencher cette intention spécifique. Ce que nous faisons ici, c'est utiliser des entités comme substituts des valeurs réelles que l'utilisateur pourrait utiliser. @ sys.number peut se référer à n'importe quel numéro. @Currency peut faire référence à n'importe quelle devise que nous avons ajoutée plus tôt lorsque nous avons créé l'entité de devise. L'utilisation du côlon après l'entité nous permet de lui attribuer un alias. Cet alias peut ensuite être utilisé pour obtenir la valeur utilisée par l'utilisateur dans le code.

La section «Action» est l'endroit où nous définissons l'action ou la méthode que nous voulons exécuter si cette intention spécifique est utilisée. Dans ce cas, nous ne définirons rien parce que nous ne créons qu'une application qui ne fait qu'une seule chose.

La section «épanouissement» est l'endroit où nous définissons un modèle dans le discours que nous voulons publier une fois l'intention utilisée. Par exemple, nous pouvons mettre les éléments suivants:

<span>$google_api_key = 'YOUR_GOOGLE_API_KEY';
</span><span>$apiai_key = 'YOUR_API_AI_AGENT_DEVELOPER_ACCESS_TOKEN';
</span><span>$apiai_subscription_key = 'YOUR_API_AI_SUBSCRIPTION_KEY';</span>

Ceci sera alors disponible sur l'élément de la parole dans le résultat que nous obtenons. De là, nous pouvons effectuer un remplacement de chaîne pour remplacer ces variables par les valeurs réelles que nous obtenons. Mais laissons-le aussi vide pour cette application.

Une fois que vous avez terminé, cliquez sur le bouton "Enregistrer" pour enregistrer l'intention.

Maintenant, nous sommes prêts à poursuivre le code. Créez un fichier Exchange-Rate.php dans votre répertoire de travail puis, ajoutez le code suivant:

<span>window.location.href = "https://www.youtube.com/results?search_query=pikachu";</span>

Comme vous pouvez le voir dans le code ci-dessus, c'est essentiellement la même que nous l'avons fait plus tôt dans notre application précédente. Seule cette fois, nous avons ajouté la variable $ CurrencyLayer_APIkey. Cela stocke la clé API que nous avons obtenue de CurrencyLayer.com, une API qui nous permet d'obtenir le taux de change actuel d'une devise à une autre. Si vous souhaitez suivre, allez-y et inscrivez-vous à une clé API.

Ensuite, nous vérifions s'il y a des résultats et extrait les données dont nous avons besoin. Dans ce cas, nous devons obtenir la monnaie que l'utilisateur souhaite convertir, la devise pour la convertir, puis le montant.

<span>composer require guzzlehttp/guzzle:~5.0</span>

Nous faisons ensuite une demande à l'API et extrons le taux de change des résultats:

<span><?php
</span><span>require 'vendor/autoload.php';
</span><span>
</span><span>use GuzzleHttp\Client;
</span><span>
</span><span>$client = new Client();</span>

Les résultats que nous obtenons de l'API ressemblent à ceci:

<span>$google_api_key = 'YOUR_GOOGLE_API_KEY';
</span><span>$apiai_key = 'YOUR_API_AI_AGENT_DEVELOPER_ACCESS_TOKEN';
</span><span>$apiai_subscription_key = 'YOUR_API_AI_SUBSCRIPTION_KEY';</span>

Maintenant que nous avons le taux de change actuel, tout ce que nous avons à faire maintenant est de multiplier le taux avec le montant fourni par l'utilisateur, puis la sortie du résultat.

<span>$query = $_POST['query']; //the users query
</span><span>
</span><span>$response = $client->post('https://api.api.ai/v1/query', array(
</span><span>    'headers' => array(
</span><span>        'Authorization' => "Bearer {$apiai_key}",
</span><span>        'ocp-apim-subscription-key' => $apiai_subscription_key,
</span><span>        'Content-Type' => 'application/json; charset=utf-8'
</span><span>    ),
</span><span>    'json' => array(
</span><span>        "query" => $query,
</span><span>        "lang" => "en"
</span><span>    )
</span><span>));
</span><span>
</span><span>$result = $response->json();</span>

Dans le côté client, nous utilisons toujours les mêmes HTML et fichiers que nous avons utilisés plus tôt sur notre première application. Vous pouvez aller de l'avant et mettre ces mêmes fichiers dans votre répertoire de travail si vous suivez.

Array
(
    [id] => eb69f468-6e1a-41c9-883d-6ac7c71cd187
    1739117986 => 2015-05-16T09:19:47.519Z
    [result] => Array
        (
            [source] => domains
            [resolvedQuery] => What's the current time in Barcelona Spain?
            [speech] => 
            [action] => clock.time
            [parameters] => Array
                (
                    [location] => Barcelona Spain
                )

            [metadata] => Array
                (
                    [inputContexts] => Array
                        (
                        )

                    [outputContexts] => Array
                        (
                        )

                    [contexts] => Array
                        (
                        )

                )

        )

    [status] => Array
        (
            [code] => 200
            [errorType] => success
        )

)

La seule différence est l'URL à laquelle nous envoyons la demande. Pointez-le vers où votre taux d'échange.php est servi:

<span>if(!empty($result['result']) && !empty($result['result']['parameters']['location'])){
</span><span>    $location = $result['result']['parameters']['location'];
</span><span>
</span><span>}else{
</span><span>    echo "Sorry, I could not find that location.";
</span><span>}</span>

Conclusion

Dans ce didacticiel, nous avons appris à utiliser API.ai pour créer des applications PHP à la voix. La prise en charge du navigateur est encore assez limitée car l'API de discours Web n'est toujours pas largement implémenté. Mais API.ai prend en charge d'autres plateformes en dehors du Web. Android, Cordova, .NET, iOS sont quelques exemples. Cela signifie que nous pouvons utiliser API.ai sans nous soucier du support sur ces plateformes. Assurez-vous de consulter leurs documents si vous voulez en savoir plus. Les fichiers que nous avons utilisés dans ce tutoriel sont disponibles dans ce référentiel GitHub.

Questions fréquemment posées (FAQ) sur les applications PHP contrôlées par la voix avec API.ai

Comment puis-je intégrer API.ai avec PHP pour la reconnaissance vocale?

L'intégration d'API.ai avec PHP pour la reconnaissance vocale implique quelques étapes. Tout d'abord, vous devez créer un nouvel agent dans API.AI. Cet agent sera chargé de comprendre l'entrée vocale de l'utilisateur et de les convertir en données exploitables. Après avoir créé l'agent, vous devez le former avec des phrases et des réponses. Une fois l'agent formé, vous pouvez utiliser le SDK API.AI PHP pour intégrer l'agent dans votre application PHP. Le SDK fournit des méthodes pour envoyer des données vocales à l'agent et réception des données traitées.

Quelles sont les conditions préalables à la création d'une application PHP contrôlée par la voix avec API.ai?

Pour créer une application PHP contrôlée par la voix avec API.AI, vous devez avoir une compréhension de base du PHP et de l'objet - Programmation orientée. Vous devez également avoir une connaissance pratique de l'API.ai et son fonctionnement. De plus, vous devez avoir un serveur où vous pouvez héberger votre application PHP. Enfin, vous devez faire installer le SDK API.AI PHP sur votre serveur.

Puis-je utiliser d'autres API de reconnaissance vocale avec PHP?

Oui, vous pouvez utiliser d'autres API de reconnaissance vocale avec PHP . Certaines alternatives populaires à API.ai incluent IBM Watson, Microsoft Azure Cognitive Services et Google Cloud Speech-to-Text. Ces API fournissent également des SDK PHP que vous pouvez utiliser pour les intégrer dans votre application PHP.

Comment puis-je améliorer la précision de la reconnaissance vocale dans mon application PHP?

Améliorer la précision de la reconnaissance vocale Dans votre application PHP, implique de former votre agent API.ai avec plus de phrases et de réponses. Plus l'agent a de données, mieux il peut comprendre et traiter l'entrée vocale. Vous pouvez également utiliser les capacités d'apprentissage automatique de l'agent pour améliorer en continu ses performances au fil du temps.

Comment puis-je gérer différentes langues dans mon application PHP à commande vocale?

API.ai prend en charge plusieurs langues, Vous pouvez donc former votre agent à comprendre et à répondre à la contribution vocale dans différentes langues. Lors de l'envoi de données vocales à l'agent, vous pouvez spécifier la langue dans la demande. L'agent traitera ensuite l'entrée vocale en fonction de la langue spécifiée.

Puis-je utiliser API.ai pour le texte-parole dans mon application PHP?

Oui, vous pouvez utiliser l'API. AI pour le texte à la dissection dans votre application PHP. Api.ai fournit des méthodes pour convertir le texte en discours. Vous pouvez utiliser ces méthodes pour faire en sorte que votre application parle des réponses ou des instructions à l'utilisateur.

Comment puis-je sécuriser les données vocales dans mon application PHP?

Sécurisation des données vocales dans votre application PHP Implique le chiffrement des données avant de les envoyer à API.ai. Vous pouvez utiliser les fonctions de chiffrement intégrées de PHP pour crypter les données. De plus, vous devez utiliser HTTPS pour toutes les communications entre votre application et API.AI pour éviter l'interception des données.

Puis-je utiliser API.AI pour les applications Web contrôlées par la voix?

Oui, vous pouvez Utilisez API.ai pour les applications Web contrôlées par voix. Le SDK API.AI PHP peut être utilisé dans n'importe quelle application PHP, y compris les applications Web. Vous pouvez utiliser JavaScript pour capturer l'entrée vocale de l'utilisateur dans le navigateur, puis l'envoyer à votre backend PHP pour le traitement.

Comment puis-je tester les capacités de reconnaissance vocale de mon application PHP?

Vous Peut tester les capacités de reconnaissance vocale de votre application PHP en créant un ensemble de phrases et de réponses de test. Vous pouvez ensuite utiliser ces tests pour vérifier si l'application comprend et traite correctement l'entrée vocale.

Puis-je utiliser API.AI pour les applications mobiles contrôlées par voix?

Oui, vous pouvez utiliser API.ai pour les applications mobiles contrôlées par la voix. Cependant, vous devrez utiliser le SDK API.AI pour la plate-forme mobile spécifique (Android ou iOS) au lieu du SDK PHP. Les SDK mobiles fournissent des méthodes pour capturer l'entrée vocale de l'utilisateur et l'envoyer à api.ai pour le traitement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!