Category

Technique

Llama 2 : le modèle open source de Meta

By Technique

LLaMA 2 est un modèle de langage à grande échelle développé par méta qui utilise comme méthodologie d’entraînement l’apprentissage par renforcement à partir des commentaires humains, pour offrir une flexibilité et des performances élevées. Il est également open-source et peut être déployé de multiples manières, que ce soit localement ou via des services cloud.

Architecture et Taille

  • LLaMA 2 est un modèle de langage à grande échelle (LLM) qui est disponible en trois variantes différentes en fonction du nombre de paramètres : 7 milliards, 13 milliards et 70 milliards de paramètres.
  • À titre de comparaison, GPT-3.5 d’OpenAI a jusqu’à 175 milliards de paramètres, et Bard de Google (basé sur LaMDA) en a 137 milliards.

Méthodologie d’Entraînement

  • Apprentissage par Renforcement à partir des Commentaires Humains (RLHF) : LLaMA 2 utilise cette méthode où le modèle est entraîné pour maximiser une récompense basée sur les évaluations humaines. Cela permet une plus grande flexibilité dans l’adaptation du modèle à des tâches spécifiques.
  • Fine-Tuning Supervisé: À titre de comparaison, d’autres modèles comme ChatGPT utilisent le fine-tuning supervisé. Dans cette méthode, un modèle pré-entraîné est ajusté (ou « fine-tuné ») sur un ensemble de données spécifique qui a été étiqueté par des humains. Par exemple, si le modèle est destiné à répondre à des questions, il serait fine-tuné sur un ensemble de données composé de paires questions-réponses. Le fine-tuning supervisé est souvent plus simple à mettre en œuvre mais peut être moins flexible que des méthodes comme RLHF.

Performances

  • Selon Meta, LLaMA 2 surpasse d’autres modèles linguistiques sur de nombreux critères de référence externes, y compris des tests de raisonnement, de codage, de compétences et de connaissances.
  • Le modèle est entraîné sur 2 trillions de tokens, soit 40 % de données en plus que son prédécesseur, LLaMA 1.

Utilisation et Déploiement

  • Le code source de LLaMA 2 est disponible sur la plateforme Hugging Face, ce qui permet aux développeurs de le télécharger et de l’exécuter sur leurs propres machines.
  • Il est également accessible via des services cloud comme Microsoft Azure et Amazon SageMaker JumpStart, offrant ainsi des options pour un déploiement à grande échelle.
  • Une variante du modèle est également disponible sur llama.perplexity.ai, qui combine la puissance de LLaMA 2 et Perplexity.ai pour fournir des réponses générales et des liens pertinents à vos requêtes.

Open Source et Accessibilité

  • LLaMA 2 est open-source, ce qui signifie que son code et ses données sont publiés gratuitement, permettant ainsi aux chercheurs et aux développeurs de construire et d’améliorer la technologie.

Partenariats

  • Meta s’est associé à Microsoft pour le développement et la distribution de LLaMA 2. Le modèle sera également disponible via d’autres fournisseurs comme Amazon Web Services (AWS).

GitHub Copilot : L’avenir de la programmation assistée par l’IA

By Technique

GitHub Copilot : L’avenir de la programmation assistée par l’IA

L’intelligence artificielle (IA) a fait d’énormes progrès ces dernières années, révolutionnant divers domaines d’activité. Dans le domaine de la programmation, GitHub Copilot est un outil révolutionnaire qui utilise l’IA pour fournir une assistance de codage avancée aux développeurs. Dans cet article, nous explorerons en détail ce qu’est GitHub Copilot, comment il fonctionne et examinerons des exemples d’utilisation pour mieux comprendre son potentiel.

Qu’est-ce que GitHub Copilot ?

GitHub Copilot est un outil développé par GitHub en partenariat avec OpenAI, basé sur la technologie du modèle de langage GPT (Generative Pre-trained Transformer). Il s’agit d’une extension pour les éditeurs de code populaires tels que Visual Studio Code, permettant aux développeurs d’obtenir des suggestions de code pertinentes et d’écrire plus rapidement et efficacement.

Comment fonctionne GitHub Copilot ?

GitHub Copilot fonctionne grâce à l’apprentissage automatique supervisé sur une immense quantité de code source provenant de projets open source hébergés sur GitHub. Le modèle de langage GPT est pré-entraîné sur ces données, ce qui lui permet d’acquérir une compréhension approfondie des motifs de codage courants, des structures de données et des bonnes pratiques de programmation.

Lorsque vous commencez à écrire du code, GitHub Copilot analyse le contexte et génère des suggestions de code en temps réel, directement dans votre éditeur de code. Ces suggestions peuvent inclure des extraits de code, des fonctions, des classes, des imports et même des commentaires utiles.

Exemples d’utilisation de GitHub Copilot :

a) Complétion de code :

L’un des cas d’utilisation les plus courants de GitHub Copilot est la complétion de code. Par exemple, supposons que vous commenciez à écrire une fonction de tri en Python :

À mesure que vous écrivez le code ci-dessus, GitHub Copilot propose automatiquement une suggestion pour compléter la fonction de tri, en prenant en compte les boucles, les indices et l’échange d’éléments. Cela permet d’accélérer considérablement le processus de développement en évitant d’avoir à taper tout le code manuellement.

b) Création de tests unitaires :

GitHub Copilot peut également être utilisé pour générer des tests unitaires automatiquement. Par exemple, si vous écrivez une fonction de calcul de la moyenne en JavaScript :

Lorsque vous utilisez GitHub Copilot, il peut vous proposer de générer automatiquement des tests unitaires pour cette fonction, en vérifiant les cas de base tels que les tableaux vides, les tableaux avec un seul élément, etc. C

c) Documentation automatique :

Un autre avantage majeur de GitHub Copilot est sa capacité à générer automatiquement des commentaires et de la documentation pour votre code. Par exemple, si vous commencez à écrire une fonction en Java et que vous ajoutez un commentaire expliquant le but de la fonction :

GitHub Copilot peut suggérer automatiquement une implémentation de la fonction et générer une documentation correspondante :

Cette fonctionnalité peut être extrêmement utile pour garantir une documentation cohérente et faciliter la compréhension du code par vous-même et par d’autres développeurs qui pourraient travailler sur le même projet.

d) Correction automatique des erreurs :

GitHub Copilot peut également vous aider à détecter et à corriger les erreurs de code. En écrivant du code, il peut vous suggérer des modifications ou des corrections pour résoudre les problèmes courants. Par exemple, si vous saisissez un nom de variable incorrect ou un opérateur incorrect, GitHub Copilot peut vous proposer des alternatives pour résoudre l’erreur :

GitHub Copilot peut suggérer de corriger l’erreur en remplaçant l’opérateur incorrect (=>) par l’opérateur correct (>=) :

Cela permet de réduire le temps consacré à la recherche d’erreurs et à la correction manuelle, améliorant ainsi l’efficacité du processus de développement.

Conclusion :

GitHub Copilot représente une avancée majeure dans le domaine de la programmation assistée par l’IA. Grâce à son apprentissage à partir de vastes ensembles de données de code source, il offre une assistance précieuse aux développeurs, accélérant leur productivité et améliorant la qualité du code. Que ce soit pour la complétion automatique du code, la génération de tests unitaires, la documentation ou la correction des erreurs, GitHub Copilot démontre un potentiel énorme pour révolutionner la façon dont nous programmons.

Cependant, il est important de noter que GitHub Copilot est un outil d’assistance et qu’il ne remplace pas la réflexion et la compréhension nécessaires pour écrire un code de qualité. Les développeurs doivent toujours valider et comprendre les suggestions de GitHub Copilot avant de les implémenter. Néanmoins, avec une utilisation judicieuse, GitHub Copilot peut devenir un compagnon précieux pour les développeurs, leur permettant de se concentrer sur des tâches plus complexes et créatives.

En fin de compte, GitHub Copilot marque une nouvelle ère de programmation assistée par l’IA, où les développeurs bénéficient d’une aide précieuse pour accélérer leur workflow et relever des défis plus ambitieux. Toutefois, il convient également de noter que GitHub Copilot n’est pas parfait et peut parfois proposer des suggestions incorrectes ou peu optimales. Les développeurs doivent rester vigilants et faire preuve de discernement lorsqu’ils utilisent cet outil.

En termes de perspectives d’avenir, GitHub Copilot est encore au stade de développement et continuera probablement à s’améliorer avec le temps. Les mises à jour régulières du modèle de langage GPT et l’incorporation de nouvelles fonctionnalités permettront d’élargir les capacités de l’outil et d’améliorer sa précision.

Cependant, il est important de noter que GitHub Copilot soulève également des questions et des débats sur des sujets tels que les droits d’auteur et les violations de licence. Étant donné que l’outil s’appuie sur des extraits de code open source disponibles sur GitHub, il est crucial de respecter les licences et les droits de propriété intellectuelle lors de l’utilisation de GitHub Copilot dans des projets commerciaux ou privés. Les développeurs doivent être conscients de ces considérations légales et s’assurer de se conformer aux réglementations en vigueur.

En conclusion, GitHub Copilot représente une avancée passionnante dans le domaine de la programmation assistée par l’IA. En fournissant des suggestions de code pertinentes et en accélérant le processus de développement, il peut améliorer la productivité des développeurs et favoriser l’innovation. Cependant, il est important de l’utiliser avec prudence, de valider les suggestions générées et de rester conscient des implications juridiques. Avec une utilisation judicieuse et une compréhension solide des principes de programmation, GitHub Copilot peut devenir un outil puissant pour les développeurs, les aidant à repousser les limites de la création logicielle.

Vue.js, react.js, angular / comparatif

By Technique

Vue.js est un framework JavaScript open-source pour la création d’applications web. Il a été créé par Evan You en 2014 et est devenu très populaire pour sa facilité d’utilisation et sa flexibilité. Il utilise un système de liaison de données bidirectionnelle qui relie les données aux éléments de l’interface utilisateur, de sorte que lorsque les données changent, l’interface utilisateur est automatiquement mise à jour. Il dispose également d’un système de composants pour faciliter la création d’applications modulaires et réutilisables. Vue.js est compatible avec d’autres bibliothèques et frameworks tels que React et Angular.

React.js est un framework JavaScript open-source développé par Facebook. Il a été lancé en 2013 et est devenu très populaire pour la création d’applications web à haute performance. Il utilise un système de composants qui permet de diviser une application en petites parties réutilisables, ce qui rend le développement plus efficace et facilite la maintenance et l’évolution de l’application. React.js utilise également un système de virtual DOM qui permet de mettre à jour uniquement les parties de l’interface utilisateur qui ont été modifiées, améliorant ainsi les performances de l’application.

Angular est un framework JavaScript open-source développé par Google. Il a été lancé en 2010 et est devenu très populaire pour la création d’applications web de grande envergure. . Il offre des fonctionnalités avancées pour la création d’applications web dynamiques et interactives. Angular utilise une architecture basée sur les composants et est facilement extensible grâce à un système de modules. Il fournit également un support complet pour la gestion de l’état de l’application et une intégration aisée avec d’autres outils de développement.

Vue.js :

site : https://vuejs.org

Avantages :

  • Taille légère et facile à apprendre pour les développeurs qui ont déjà une expérience en JavaScript
  • Complet pour les petits projets
  • Possibilité de personnaliser facilement les composants
  • Forte communauté de développeurs

Inconvénients :

  • Moins de flexibilité pour les projets plus importants
  • Moins de composants prédéfinis

React.js:

site : https://legacy.reactjs.or

Avantages :

  • Grande performance grâce à son utilisation de la technique de rendu côté serveur
  • Grande flexibilité pour les projets de toutes tailles
  • Forte communauté de développeurs

Inconvénients :

  • Peut être plus difficile à apprendre pour les développeurs qui n’ont pas d’expérience en JavaScript
  • Peut être plus difficile à personnaliser les composants

Angular:

site : https://angular.io

Avantages :

  • Complet pour les projets de toutes tailles
  • Facilité de créer des applications avec une architecture solide
  • Grande communauté de développeurs

Inconvénients :

  • Peut-être plus difficile à apprendre pour les développeurs qui n’ont pas d’expérience en JavaScript
  • Peut-être plus lourd pour les petits projets
  • Il faut noter que le choix du framework dépend de vos besoins spécifiques et de vos préférences en matière de développement. Il peut être utile de tester chacun d’entre eux pour voir lequel convient le mieux à votre projet.

Comparatif Zapier / Integromat / n8n

By Technique

Zapier / Integromat / n8n :

Il existe de nombreux produits qui permettent aux utilisateurs finaux d’intégrer les applications Web qu’ils utilisent et d’automatiser les flux de travail. Bien qu’ils servent le même objectif, ils ont beaucoup de différences comme leurs similitudes.  Dans ce document, nous allons comparer trois d’entre eux : Zapier, Integromat et n8n.

Prix:

Même si les trois outils d’automatisation disposent d’une option d’abonnement gratuite, ils ne couvrent pas le même nombre d’opérations. Pour une utilisation professionnelle, il est nécessaire de souscrire un abonnement plus élevé pour Zapier et Integromat.

Zapier est le plus cher des trois. L’abonnement gratuit de Zapier ne comprend que 100 tâches par mois et il n’est possible d’utiliser que 5 zaps (5 Workflow) un temps de mise à jour de 15 minutes. Pour utiliser un nombre illimité de zaps, avoir accès à des applications premium et bénéficier d’un temps de mise à jour beaucoup plus court, l’utilisateur doit souscrire un abonnement professionnel.

Après zapier, Integromat vient en second. Avec le plan d’abonnement gratuit d’Intogramet, il est possible d’effectuer 1000 opérations et d’utiliser deux flux de travail activés. Si vous souhaitez passer à la version supérieure, Integromat propose une formule d’abonnement beaucoup plus avantageuse que Zapier.

D’autre part, n8n peut être utilisé de manière totalement gratuite. n8n est un outil d’automatisation auto-hébergé. Il est donc possible d’utiliser n8n sans aucune limitation en l’hébergeant sur votre propre serveur ou même sur votre ordinateur personnel. Mais si vous souhaitez utiliser la version cloud de n8n, il existe un forfait de 20 euros pour 5000 exécutions par mois.

Intégrations:

Si nous regardons le nombre d’applications auxquelles ces outils d’automatisation ont accès, Zapier est le plus important avec plus de 5000 applications. Après Zapier, Integromat occupe la deuxième place avec plus de 1000 applications.  Comparé aux deux autres, n8n a beaucoup moins d’applications avec seulement 200+ applications. La différence entre ces chiffres peut être facilement comprise en regardant leurs dates de sortie ; Zapier est sorti en 2011 tandis que n8n est un outil d’automatisation assez récent qui est sorti en 2019.

Mais même si Zapier a le plus d’applications. Les actions qui peuvent être exécutées avec ces applications sont plus limitées qu’Integromat et n8n.  Donc, si vous recherchez un outil pour effectuer des travaux plus complexes, il est préférable d’utiliser Integromat ou n8n. n8n donne également la possibilité de créer votre propre intégration. Le code de n8n est disponible sur Github et l’entreprise est toujours prête à accepter de nouvelles contributions de la communauté.

Facilité d’utilisation :

Zapier est plus simple à utiliser que les deux autres. Un flux de travail créé dans Zapier ressemblera à ce qui suit:

Il a une forme très simple et très facile à comprendre pour tout débutant. L’utilisation des variables des applications précédentes comme entrée est également très facile. D’autre part, pour une meilleure utilisation d’Integromat et de n8n, il est nécessaire d’être familier avec langage de programmation. Leur utilisation est plus complexe que celle de Zapier. Mais cette complexité donne plus de possibilités à l’utilisateur d’utiliser les variables et les applications comme il le souhaite. n8n donne la possibilité de modifier les éléments comme vous le souhaitez avec le codage correct. En plus, n8n permet d’utiliser deux applications de déclenchement, ce qui n’est pas possible avec Zapier et Integromat. La visualisation du flux de travail d’Integromat et de n8n est très différente de celle de Zapier. Ces produits montrent les connexions et chaque étape de l’automatisation, il est possible de zoomer et de déplacer les objets. Un flux de travail avancé pour n8n peut ressembler à ce qui suit :

La connexion des comptes est la première étape pour pouvoir utiliser les applications de ces outils d’automatisation. Dans Zapier c’est un processus très facile en cliquant simplement sur « connecter un nouveau compte » et en autorisant l’accès à l’application. Mais dans n8n, il est nécessaire d’utiliser l’authentification de Auth2 ou compte de service pour connecter les comptes. Cette méthode de connexion est plus complexe que celle utilisée par Zapier. Integromat utilise généralement la même méthode que Zapier mais il existe certaines applications qui nécessitent la méthode d’authentification de Auth2 ou compte de service.

Test du flux de travail

Integromat et n8n offrent tous deux la possibilité d’exécuter chaque application séparément si vous le souhaitez. Lorsque le workflow est exécuté, il est possible de voir quelles applications sont en cours d’exécution, quels sont les éléments de sortie, etc. avant même que le workflow ne soit activé. Avec ce processus, il est très facile de détecter où se trouve l’erreur. Zapier offre la possibilité de tester les applications pour détecter d’éventuelles erreurs, mais tant que le flux de travail n’est pas publié, il n’est pas possible de tester entièrement l’automatisation.

Fonctions Avancées :

Ces trois produits contiennent divers outils tels que des boucles, des filtres, etc. Ces outils sont plus avancés dans Integromat que dans Zapier. Même si Zapier contient des outils dont le nom est « Exemple by Zapier », Integromat offre beaucoup plus de possibilités. Mais d’un autre côté, pour pouvoir utiliser ces outils, des connaissances de base en programmation peuvent être nécessaires. Dans n8n, il y a également divers outils, mais en plus de cela, n8n donne la possibilité de coder n’importe quoi à l’intérieur des nœuds. Comme pour Integromat, pour pouvoir utiliser cette fonction, l’utilisateur doit être familier avec le langage de programmation de n8n (JavaScript).

Introduction a l’open source n8n

By Technique

n8n Introduction:

n8n est un outil « low-code » assez évolué qui va vous permettre d’automatiser certaines tâches à partir d’une suite d’actions basées sur des nœuds. Il s’agit d’une application qui intègre des applications entre elles au travers de leur API (Application Programming Interface) afin d’automatiser des « workflows ».

Attention n8n est un peu plus compliqué que Zapier. N8n est plutôt réservé à des gens qui ont un peu de connaissance en développement. Il peut être utilisé directement en mode cloud depuis le site https://n8n.io.

Téléchargement :

n8n est une application qui est très facile à installée. En allant sur le projet du site, elle peut être téléchargée pour Windows ou Apple.

n8n est un outil d’automatisation auto-hébergé donc il est également possible de télécharger n8n manuellement. Il faut d’abord télécharger et installer Docker Desktop. Ensuite, ouvrir le terminal et lancer la commande :

docker pull n8nio/n8n

Si vous consultez les images dans Docker Desktop, vous pourrez voir que n8n est créé. Cliquez sur le bouton run et entrez 5678 pour l’hôte local. Les autres champs peuvent être remplis comme l’utilisateur le souhaite. Après avoir cliqué sur le bouton run, il est possible d’ouvrir n8n dans votre navigateur.

Il est aussi possible de l’utiliser n8n sur le cloud mais il existe un forfait de 20 euros pour 5000 exécutions par mois

Eléments Importants de n8n :

Les nœuds sont les points de connexion de vos blocs d’automatisations n8n. Ils sont les éléments constitutifs de l’automatisation: les données entrent par les nœuds, sont traitées par les nœuds et sortent finalement par les nœuds.

  • Les nœuds de base sont des fonctions ou des services qui peuvent être utilisés pour contrôler le mode d’exécution des workflows ou pour fournir un support API générique.
  • Les nœuds de déclenchement (trigger) sont les points de départ de l’automatisation. Ils sont toujours le premier nœud du flux de travail et agissent comme un feu  vert pour les nœuds suivants.  Dans n8n, il peut y avoir plusieurs nœuds de déclenchement en plus du nœud de départ.
  • Les nœuds réguliers exécutent une certaine action, par exemple récupérer des données ou créer une entrée dans un calendrier. Leurs noms sont cohérents avec les  applications qu’ils exécutent.

Les éléments (Items) sont les stockages pour les données exécutées. Un élément est une collection de données qui a été envoyée d’un nœud à l’autre comme un tableau d’objets JSON  (JavaScript Object Notation) . Les nœuds peuvent traiter plusieurs éléments en même temps.

La connexion est un lien qui relie plusieurs nœuds. Il s’agit d’un itinéraire permettant de faire passer les données de la sortie d’un nœud à l’entrée d’un autre nœud. Un nœud peut avoir une ou plusieurs connexions.

Le workflow est un système dont la structure est constituée de nœuds, en connectant les nœuds, vous pouvez créer un flux de travail. Au départ, il s’agit toujours d’une ardoise vierge dans laquelle vous pouvez ajouter des nœuds comme vous le souhaitez. En utilisant différents flux de travail, il est également possible de séparer les automatisations les unes des autres.

Démarrage :

Pour commencer à travailler, vous devez créer un nouveau flux de travail en utilisant l’icône de flux de travail dans le menu de gauche. Le nœud de départ dans le nouveau workflow est le nœud de déclenchement par défaut et peut être utilisé pour exécuter l’automatisation. En cliquant sur le signe orange + sur le côté droit de la page, il est possible d’ouvrir le panneau des nœuds et d’ajouter n’importe quelle application comme nœud au flux de travail.

L’exécution du programme :

Un flux de travail commence lorsqu’un nœud est connecté à un nœud déclencheur. Il peut s’agir d’un nœud qui peut créer des données par lui-même, recevoir les données du disque, recevoir les données d’une autre application qui a une API.

Après avoir obtenu les données du nœud, il est possible de définir l’opération qui doit être exécutée.  Il est ensuite possible de configurer l’apparence et l’exécution du nœud avec les paramètres (Settings) du nœud.

Lorsque tous les paramètres nécessaires sont remplis, le programme peut être exécuté avec le nœud de démarrage ou le nœud lui-même peut être exécuté avec l’option de nœud d’exécution. Si le workflow s’exécute avec succès, un tic vert apparaîtra sur les icônes des nœuds et il sera possible de voir la sortie. Si ce n’est pas le cas, le programme affichera le message « Problème d’exécution du flux de travail » avec le détail de l’erreur.

Création d’un Nœud :

Les nœuds utilisés dans n8n sont composés de plusieurs fichiers.  La fonction du nœud est définie par un fichier JavaScript (.js) et ses propriétés sont définies par un fichier html. Un fichier package.json est utilisé pour empaqueter le tout comme un module npm.

Il est possible de créer un nœud personnalisé dans n8n. Pour créer un nœud personnalisé, il est nécessaire d’avoir des connaissances de base en JavaScript/TypeScript. De plus, il est utile de connaître le fonctionnement de l’API et des expressions dans n8n pour une meilleure compréhension.

Tout d’abord, installez et ouvrez Git sur votre ordinateur. Ensuite, vous pouvez installer lerna globalement avec la commande suivante :

npm install --global lerna  //installation de lerna

Si vous n’avez pas de compte existant, ouvrez un compte GitHub, puis créez une branche (fork) du dépôt n8n. Vous pouvez le cloner avec la commande suivante :

git clone https://github.com/ VotreNomdUtilisateurGitHub /n8n.git && cd n8n

Dans Github, il est possible de trouver un exemple pour le code du nœud souhaité qui veut être créé. Ils peuvent être trouvés dans le dossier packages/nodes-base/nodes. (Ce fichier contient tous les nœuds de n8n.)

Lorsque vous commencez à créer un nœud, créez un nouveau dossier avec le nom des nœuds personnalisés dans votre dossier packages/nodes-base/nodes. Dans ce dossier les dossiers NomdeNoeud.node.ts et NomdeNoeud.svg doivent être recréés. NomdeNoeud.node.ts étant le code des nœuds et NomdeNoeud.svg étant l’icône des nœuds (votre icône doit être un SVG ou un PNG de 60×60 pixels). Après il faut coller (dans l’ordre alphabétique) dist/nodes/NomdeNoeud/NomdeNoeud.node.js dans le fichier packages/nodes-base/package.json. Cette action devrait enregistrer le nœud dans le tableau des nœuds.

Pour visualiser votre nœud, allez dans le dossier principal du projet (n8n) dans le terminal et exécutez les commandes suivantes.

lerna bootstrap -–hoist  //installe toutes les dépendances de tous les modules, les relie entre eux

npm run build            //construit tout le code

npm run dev             //démarre n8n en mode développement

Ouvrez votre navigateur et allez à localhost:8080 et vous devriez être en mesure de voir l’interface utilisateur de l’éditeur. Maintenant, lorsque vous tapez le nom de votre nœud, vous devriez être en mesure de le trouver dans le menu Créer un nœud, cliquez dessus pour l’ajouter à l’interface utilisateur de l’éditeur.

Un nœud doit également être composé de certains paramètres tels que l’opération et la ressource. Ces paramètres peuvent être ajoutés sous description.properties dans packages/nodes-base/nodes/NomdeNoeud/NomdeNoeud.node.ts.

Pour plus de détails, les instructions peuvent être trouvées sur le site web.

Exemple de Video

Maintenir le Fonctionnement de n8n Après la Fermeture du Terminal

Lorsque nous utilisons n8n, nous voulons qu’il continue à fonctionner en arrière-plan. Pour cette fonction, nous utilisons la version que nous avons téléchargée manuellement sur notre ordinateur en utilisant Docker Desktop.

Nous allons dans la section containers de Docker Desktop et ouvrons le terminal de notre n8n. Maintenant, nous devons configurer le n8n pour qu’il fonctionne via PM2. Pour ce faire, nous écrivons dans le terminal :

npm install pm2 -g    // installation du pm2

Ensuite vous pouvez démarrer le n8n avec pm2 en écrivant :

pm2 start n8n

Exemple de réalisation de workflows n8n

By Technique

Exemple 1: Envoi d’un Gmail :

L’une des applications sur Internet que nous utilisons le plus est Gmail. En utilisant l’API Gmail, nous pouvons accéder à nos comptes avec n8n et effectuer diverses transactions. Voici un exemple de la façon d’envoyer un mail en utilisant n8n.

Après avoir trouvé l’application Gmail dans le menu des nœuds, nous commençons à écrire nos paramètres.

Avant de saisir les informations d’identification, il faut choisir OAuth2 pour l’authentification. En créant un nouveau compte avec les informations d’identification de l’API OAuth2 de Gmail, nous obtenons une URL de redirection OAuth. Cette URL sera utilisée pour obtenir les identifiants de Google Cloud Platform. Sur Google Cloud Platform, dans le menu de gauche, nous choisissons « API et services » puis « Identifiants ». En cliquant sur « Créer des identifiants », nous créons un nouvel « OAuth client ID ». Après avoir choisi l’application web, l’URL que nous avons obtenue de n8n peut être ajoutée à l’URI de redirection autorisée.

En créant ce nouvel identifiant, nous obtenons les informations d’identification nécessaires pour remplir les champs du n8n. En se connectant avec google, le compte peut être à présent facilement connecté.

Pour le champ de la ressource, sélectionnez « Message » et pour le champ de l’opération, il faut choisir « Envoyer ».  Pour le champ sujet et message et courrier du destinataire, peuvent être choisi comme l’utilisateur le souhaite en fonction du message qui doit être envoyé. Si l’on souhaite, un courrier électronique cc ou bbc, une pièce jointe sous forme binaire et le nom de l’expéditeur peuvent être aussi ajoutés au courrier.

Exemple 2 : Message d’Anniversaire

Le plan général

Dans cet exemple, nous allons envoyer des mails les personnes dont c’est l’anniversaire en extrayant des informations d’un Google Sheets existante. Pour cette automatisation, nous allons utiliser quatre nœuds. Pour le nœud de départ, nous utiliserons un nœud Cron. Le nœud Cron est un nœud de déclenchement qui permet à l’utilisateur de programmer l’exécution périodique des flux de travail à des dates, heures ou intervalles fixes. Nous allons connecter le nœud Cron avec un nœud Function qui nous permettra de trouver la date actuelle. Après ce nœud, nous utiliserons le nœud Google Sheets pour extraire les informations nécessaires. Enfin, le nœud Gmail sera utilisé pour envoyer les mails. Votre flux de travail devrait ressembler alors à ceci :

Nœud de déclenchement : Cron

Dans ce nœud, l’utilisateur peut choisir le mode et le moment souhaités pour l’exécution. Comme nous allons utiliser un déclencheur basé sur l’heure, il est suggéré de vérifier votre fuseau horaire dans les paramètres et de le corriger si nécessaire.

Nœud Régulière : Function

Le nœud de fonction est un nœud où l’on peut manipuler les éléments. Les éléments sont sous la forme de JSON, par conséquent, dans le nœud de fonction, JavaScript est utilisé pour la manipulation des éléments. Dans ce nœud, nous allons utiliser un code JavaScript pour obtenir le jour et le mois actuels. Le code ci-dessous peut être utilisé pour cette fonction.

//trouve le mois actuel
var month = new Date().getMonth();

//trouve la date actuel
var day1 = new Date().getDate();

// crée une liste composée des mois
const months = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Décembre"];

//crée un élément avec la date et le mois sous la forme de " 9 Juin"
items[0].json.date = day1 + " " + months[month];

//renvoie les éléments créés comme données de sortie
return items;

Nœud de Google Sheets :

Avec l’aide de ce nœud, nous allons lire et extraire des informations d’un Google Sheets déjà existante.  Tout d’abord, vous devez créer une feuille de Google Sheets avec trois colonnes : nom, mails et les anniversaires ( Les anniversaires doivent être dans le même format que la sortie du nœud Function). Pour le nœud Google Sheet, OAuth2 sera utilisé pour l’authentification nécessaire. En créant un nouvel ID client OAuth dans votre Google Cloud Platform en utilisant l’URL donnée, vous pouvez obtenir les informations d’identification de l’ID client et du secret client (expliqué en détail dans l’exemple d’Envoi d’un Gmail). Une fois le compte connecté avec succès, il faut choisir « Sheet » comme « Ressource » et « Lookup » comme « Opération ».  Pour l’ID de la feuille de calcul, il s’agit de l’ID de votre feuille.

Vous devez écrire la plage, la ligne de début des données, la ligne clé et le nom de la colonne de consultation en fonction de votre feuille. Pour la valeur de consultation, la sortie du nœud de fonction sera utilisée comme valeur d’entrée. Cliquez sur les options de paramètres et ajoutez l’expression, pour trouver les données de sortie vous devez cliquer dans cet ordre : Nodes > Function > Output Data > JSON > date. Vous devez activer l’option « Retourner toutes les correspondances » dans le menu « Options » , sinon seule la première ligne trouvée sera retournée, même s’il existe plusieurs anniversaires identiques.

Nœud de Gmail :

Nous allons utiliser le nœud Gmail pour envoyer des courriels si aujourd’hui correspond à l’un des anniversaires dans le fichier Google Sheets. Pour le nœud Gmail, nous utiliserons la même méthode d’authentification que pour le Google Sheets (authentification OAuth2). Pour envoyer des courriels, il faut choisir « Message » comme « Ressource » et « Envoyer » comme « Opération ». Le sujet et le message peuvent être choisis comme l’utilisateur le souhaite. Si vous le souhaitez, le nom généré par le nœud Google Sheets peut être utilisé dans le message écrit ou le sujet en ajoutant une expression.  Pour le courrier du destinataire, nous utiliserons les données de sortie du nœud Google Sheets en ajoutant une expression : Nœuds > Fonction > Données de sortie > JSON > mail. Des champs supplémentaires peuvent être ajoutés selon les souhaits de l’utilisateur.

Exécution :

Lorsque vous cliquez sur Exécuter le flux de travail, votre flux de travail sera exécuté manuellement. S’il n’y a pas d’erreur, le message « Workflow exécuté avec succès » apparaîtra dans le coin inférieur droit du n8n, sinon l’erreur sera affichée sous forme de message. Pour que le nœud Cron déclenche des exécutions selon le calendrier défini, vous devez activer l’automatisation et assurez-vous que votre flux de travail est enregistré.

Workflow d’Erreur:

Un workflow d’erreur peut être utilisé pour tout workflow d’activation nécessaire. Le nœud « Error Trigger » sera utilisé pour exécuter le programme. Ce nœud peut être connecté à n’importe quel nœud qui peut envoyer un message à l’utilisateur (nœud Gmail par exemple).

Dans le nœud du déclencheur d’erreur, un exemple de données de sortie est visible lorsque l’on clique sur le bouton « Listen For Event ». L’utilisateur peut utiliser les données de sortie pour envoyer un message plus spécifique lorsque le flux de travail échoue (par exemple, le nom du flux de travail qui a échoué peut-être ajouter au message). Après avoir complété le workflow d’erreur, il doit être ajouté au workflow original. Pour cela, l’utilisateur doit ouvrir son flux de travail d’origine et, à partir des paramètres, choisir le nom de son flux de travail d’erreur comme flux de travail d’erreur. Comme indiqué au début, les flux d’erreurs ne fonctionnent que pour les flux qui s’exécutent lorsqu’ils sont activés.

Exemple 3 : Sign Up

Le plan général

Dans cette automatisation, nous allons construire un processus d’inscription en utilisant le nœud Webhook Trigger. Pour cette automatisation, nous allons utiliser trois flux de travail distincts. Chacun commençant par un nœud Webhook. Le premier contient uniquement le nœud Webhook et Set. Le deuxième workflow contiendra le nœud Webhook après un nœud qui peut être utilisé pour envoyer des messages ( Exemple : le nœud Gmai) puis un nœud Set. Le troisième workflow sera le même que le premier. Une fois que le flux de travail général est correctement réalisé, il devrait ressembler à ce qui suit :

Après avoir placé tous les noeuds, la connexion entre le noeud Gmail et le deuxième webhook doit être supprimée. Puisque nous n’avons pas rempli les paramètres nécessaires dans le nœud Gmail, le programme donnera une erreur si nous voulons tester les flux de travail.

Nœuds de Webhook:

Pour l’authentification des nœuds de Webhook, nous choisirons aucune car nous voulons que chaque utilisateur ait accès à notre page d’inscription.  Pour les trois noeuds du Webhook, il faut choisir « GET » comme « Méthode HTTP », le chemin peut être choisi par l’utilisateur en fonction de l’objectif ( Exemple : inscription pour le premier, enregistrement pour le deuxième et verification pour le troisième), « Quand le dernier noeud se termine » comme « Réponse », « 200 » comme « Code de réponse », « Première entrée JSON » comme « Données de réponse ». Ensuite, dans les « Options », il faut ajouter « Property Name », qui peut être nommé « data » pour chaque noeud.

Premier Nœud de Set :

Dans le premier Set Node nous allons construire notre page d’inscription. Pour cela, nous utiliserons le langage HTML. Tout d’abord, il faut choisir « Keep Only Set » et écrire « data » comme nom de propriété pour le string. Nous utiliserons les mêmes propriétés pour les autres nœuds Set afin qu’il soit possible de les créer en doublant ce nœud. Comme pour la valeur du string nous utiliserons un code basé sur le langage HTML (n’oubliez pas de changer l’URL dans le code en fonction du vôtre, nous utiliserons l’URL de test lors de la construction de notre Workflow) :

<form method="GET" action = "https://n8n.example.com/ (URL du deuxieme Webhook) ">

   // Écrit "Email"
   <label for = "email">Email</label>

   // Crée un espace à remplir pour l'e-mail
   <input type "email" id="email" name="email"/>

   //Écrit “Nom”
   <label for = "Nom">Nom</label>

   // Crée un espace à remplir pour le nom
   <input type "nom" id="nom" name="nom"/>

   // Crée un bouton pour soumettre qui est écrit "S’abonner" sur lui
   <button type="S’abonner" >Subscribe</button>

</form>

Pour tester si le premier workflow fonctionne, nous exécutons le workflow, copions l’URL de test du premier Webhook et l’ouvrons dans un nouveau navigateur. Nous devrions voir la page ci-dessous:

Après avoir rempli les espaces email et nom, nous devons réexécuter le workflow pour que le deuxième Webhook puisse commencer à fonctionner. Comme nous n’avons pas écrit à l’intérieur du bouton set ou de notre nœud Gmail, cliquer sur le bouton s’abonner nous donnera une page blanche.

Nœud de Gmail:

Nous utiliserons ce nœud pour demander une vérification à l’abonné. Pour le nœud Gmail, OAuth2 sera utilisé pour l’authentification nécessaire. En créant un nouvel ID client OAuth dans votre Google Cloud Platform en utilisant l’URL donnée, vous pouvez obtenir les informations d’identification de l’ID client et du secret client. Pour le champ de la ressource, sélectionnez « Message » et pour le champ de l’opération, il faut choisir « Envoyer ». Le sujet peut être choisis comme l’utilisateur le souhaite. Pour le courrier du destinataire, nous utiliserons les données de sortie du nœud deuxième Webhook en ajoutant une expression : Current Node > Input Data > JSON > query > email. Pour le message, nous mettrons la troisième URL de test de Webhook comme adresse de vérification, des textes supplémentaires peuvent également être écrits dans le message ( Exemple : Veuillez vérifier votre adresse email en cliquant sur cette adresse : https://n8n.example.com/ (URL du troisieme Webhook) )

Deuxieme Nœud de Set :

Dans ce nœud, nous allons écrire le message qui sera affiché lorsque nous cliquerons sur le bouton d’abonnement. Après avoir rempli les paramètres nécessaires (la même avec le premier nœud de Set), pour la valeur du string nous utiliserons le code ci-dessous :

<hl>Vous êtes enregistré</hl>

Troisieme Nœud de Set :

Dans ce nœud, nous allons écrire le message qui sera affiché lorsque nous cliquerons le URL de vérification qui était envoyé par le nœud de Gmail. Après avoir rempli les paramètres nécessaires (la même avec le premier nœud de Set),  Pour la valeur du string nous utiliserons le code ci-dessous :

<hl>Votre adresse e-mail est vérifiée<hl>

Exécution :

Maintenant, pour contrôler notre flux de travail, nous pouvons l’exécuter. Il ne faut pas oublier qu’avant d’utiliser les URL, le flux de travail doit être réexécuté. ( Cela fait trois exécutions pour cette automatisation : avant d’ouvrir la page d’inscription, avant de cliquer sur le bouton d’abonnement, avant de cliquer sur le lien de vérification. )

Si chaque flux de travail s’exécute avec succès, nous pouvons maintenant activer le flux de travail. En activant le flux de travail, il ne sera plus nécessaire d’exécuter le flux de travail manuellement, mais il sera exécuté chaque fois que l’URL est ouverte. Après l’activation du flux de travail, chaque lien URL de test des Webhook doit être remplacé par les URL de production dans le flux de travail.

Comme il s’agit d’un flux de travail activé, un flux de travail d’erreur peut également être ajouté à partir des paramètres du flux de travail si vous le souhaitez. (Expliqué dans l’Exemple 2: Message d’Anniversaire)

Repeindre le texte dans vos vidéos avec le deep learning

By Technique

Faire disparaitre un texte dans une vidéo peut être particulièrement fastidieux, en particulier si le texte est animé. De plus, le rendu avec un effet de floutage appliqué sur le texte reste visible et dégrade la qualité visuelle de la vidéo. Dans cet article, nous vous proposons une méthode pour effacer le texte de vos vidéos de manière automatique à l’aide du deep learning. Nous avons d’ailleurs intégré cette solution parmi les fonctionnalités de notre outil de montage vidéo openveo-prod.

Fonctionnement du modèle

Notre solution se base sur deux réseaux de neurones profonds : le premier détecte les textes dans l’image tandis que le second repeint les zones concernées.

Pour la détection du texte, nous nous sommes basés sur le modèle CRAFT (github). Celui-ci utilise un réseau à base de convolutions 2D classique (VGG-16) afin de détecter les caractères ainsi que leurs affinités dans chaque image. Dans notre cas, nous utilisons directement la carte de détection en sortie du réseau de neurones pour créer un masque. Celui-ci sera utilisé dans un deuxième temps pour définir les zones à repeindre par le second modèle.

Fonctionnement de notre solution de text-inpainting : 1) image originale, 2) carte de détection, 3) masque, 4) image repeinte.

L’image inpainting est un problème classique de retouche ou de restauration d’images. Le but consiste à repeindre une zone définie afin de faire disparaitre les éléments qui y sont présents. Si vous souhaitez voir des exemples, Nvidia propose une démo en ligne que vous pouvez tester facilement.

Dans notre cas, nous utilisons un réseau de neurones de type GAN (lire notre article pour plus de détails sur les GANs) afin de repeindre les zones données par notre masque. Le modèle d’inpainting utilisé est celui proposé dans le projet General Image Inpainting.

Pistes d’améliorations

Notre solution montre cependant quelques imperfections. D’une frame à l’autre, toutes les informations obtenues par les modèles sont perdues. Comme nous le voyons dans la figure ci-dessous, la génération est très différente entre deux frames proches. Pour résoudre ce genre de problème, nous pourrions utiliser un modèle plus adapté à la vidéo tel que ce projet.

Comparaison de la génération entre deux frames consécutives

Botpress et ses principaux concepts

By Technique

Les récentes évolutions dans le domaine de la compréhension du langage naturel permettent désormais aux machines de comprendre et de répondre aux messages écrits et vocaux de manière instantanée et sans interruption.

Aujourd’hui, le nombre d’utilisateurs d’applications de messagerie comme WhatsApp, Slack ou encore Skype montent en flèche. L’application Facebook Messenger à elle seule compte plus de 1,2 milliard d’utilisateurs par mois. Avec la multiplication des applications de messages, les chatbots virtuels qui imitent les conversations humaines pour résoudre diverses tâches sont de plus en plus demandés. Par exemple, le chatbot WeChat chinois peut déjà fixer des rendez-vous médicaux, appeler un taxi, envoyer de l’argent à des amis ou bien s’enregistrer pour un vol.

Est-ce que les chatbots ont aujourd’hui les ressources suffisantes pour imiter les humains ou s’agit-il simplement d’une nouvelle façon d’interagir plus naturellement avec les machines? Je vais ici présenter Botpress, une solution permettant de créer des chatbots simplement.

Botpress est une solution open-source et on-premise écrite en TypeScript et ayant pour ambition d’être le WordPress des chatbots avec une plate-forme qui facilite la construction de bots à l’aide de modules de code créés par la communauté.

Il s’agit d’une plate-forme complète livrée avec tous les outils nécessaires pour construire, déployer et gérer des bots de production. Botpress utilise notamment son propre moteur de compréhension du langage naturel (Natural Langage Understanding ou NLU) embarquée avec la solution, ce qui signifie qu’il n’y a aucun besoin d’effectuer des appels à un service web assurant ici un grand contrôle sur les données pour les créateurs de chatbots.

A cela s’ajoute un éditeur de flux visuel intuitif qui rend la solution très simple à utiliser, permettant aux personnes ayant un profil non-techniques de maintenir et de faire évoluer le bot facilement avec des parcours utilisateurs complexes.

Simple à utiliser, Botpress est cependant parfois compliqué à configurer. En effet, la documentation, bien que couvrant de nombreux aspects, n’est parfois pas mis à jour avec les évolutions (du moins lors de mon utilisation en août 2019). Or le produit étant assez récent, celui-ci évolue régulièrement.

La présence d’un débogueur de chat permet d’améliorer rapidement son bot et d’assurer une bonne compréhension sur les résultats du moteur de NLP et un contrôle fin. De plus, si les développeurs souhaitent intégrer des actions personnalisées comme effectuer une recherche dans une base de données ou un appel à un API, il suffit d’ajouter du code dans des dossiers spécifiques, par la suite facilement réutilisable, afin que celui-ci soit lancé au moment souhaité avec une gestion des événements par Botpress.

Depuis la version 12, la gestion du langage a été amélioré avec la possibilité de changer entre plusieurs langues de façon transparent. Les langues par défaut étant l’arabe, le français, l’anglais, le japonais et le portugais

Voici donc une présentation des concepts associés à Botpress afin de comprendre son mode de fonctionnement.

Dialog Engine

Botpress utilise ce que les développeurs appellent le moteur de dialogue pour gérer les conversations. Le moteur de dialogue est responsable de chaque interaction avec un bot. Il gère l’entrée utilisateur et la réponse du bot.

Vue d’ensemble

Le moteur de dialogue utilise des flux (Flows) qui représentent la logique conversationnelle globale d’un bot. Un flux est alors composé de nœuds (Nodes) qui exécutent une série d’instructions. Les instructions font partie du cycle de vie d’un nœud et peuvent exécuter des Actions. Une Action est un essentiellement un fichier javascript de code, écrit par le développeur, par Botpress ou par d’autres.

La création de bot se fait simplement à l’aide de l’interface utilisateurs. Il suffit d’ajouter des nœuds et de le relier entre eux. Au sein de ceux-ci, on définit des messages ou des actions à exécuter. Cette interface et la logique associée au bot sont sauvegardées au sein de fichier json de type *.ui.json et *.flow.json qu’il est possible de modifier manuellement.

Flows

Les bots plus complexes sont généralement décomposés en plusieurs flux plus petits au lieu d’un seul grand flux (par exemple un flux pour le traitement d’une demande de réservation et un autre flux pour une recherche d’informations). La raison de décomposer le bot en plusieurs flux est de faciliter la maintenabilité et la réutilisabilité.

Cycle de vie d’un flow

Un flux démarre toujours au startNode de son fichier *.flow.json. Le nœud de départ (startNode) indique le nom du nœud sur lequel le flux va commencer. Une fois le nœud sélectionné, le moteur de dialogue met en file d’attente les instructions du nœud actif. Ensuite, il traitera les instructions de façon séquentielle.

Le moteur de dialogue est basé sur les événements et n’est pas bloqué par défaut, ce qui signifie qu’un flux exécutera tout ce qu’il peut exécuter jusqu’à ce qu’il doive attendre.

Une fois le premier nœud traité, le moteur de dialogue passe au nœud suivant dans le flux jusqu’à la toute fin. Les nœuds ont également leur propre cycle de vie. Ce sont les nœuds qui font le travail le plus important dans un flux, celui-ci ne faisant que les orchestrer.

Exemple de flux

Nodes

Les nœuds sont les unités primaires de la logique conversationnelle du bot. Une conversation active (appelé « session ») a toujours un et un seul nœud actif. Un nœud passe généralement à un autre nœud ou à un autre flux. Si ce n’est pas le cas, la conversation est terminée. Le message suivant de l’utilisateur fera alors partie d’une session entièrement nouvelle.

Un nœud est séparé en trois étapes différentes : onEnter (A), onReceive (B) et onNext (C).

Cycle de vie d’un noeud

onEnter

onEnter est une liste d’instructions qui seront exécutées lorsque le nœud est saisi. Si plusieurs actions sont définies, elles seront toutes exécutées séquentiellement.

onReceive

onReceive est une liste d’instructions qui sera exécutée lorsque le nœud reçoit un message tout en étant le nœud actif. Dès qu’une action est définie, le nœud attend automatiquement la saisie utilisateur (nœud orange).

Lorsque cette propriété n’est pas utilisée, le nœud n’est pas bloquant (noir), ce qui signifie qu’il passe directement de onEnter à onNext.

Exemples de noeuds bloquants ou non

onNext

onNext (aussi appelé Transitions) n’est évalué qu’après l’exécution de onReceive ou onEnter et redirige vers une cible appelée une destination. Ça peut être :

  • Un nœud différent
  • Un flux différent
  • Le flux précédent
  • Lui-même (boucle de retour sur lui-même)
  • La fin de la conversation

Cas particuliers : Si aucune condition n’est définie, le comportement par défaut est que la conversation se termine. S’il y a des conditions définies mais qu’aucune ne correspond, rien ne se passe, c’est-à-dire que le nœud courant reste actif, et il s’écoule quand une condition correspond. Par défaut, onNext ne sera réessayé qu’après la réinvocation de onReceive.

Actions

Les actions sont essentiellement des fonctions côté serveur qui sont exécutées par le bot dans le cadre d’un flux conversationnel. Les actions permettent de faire beaucoup de choses :

  • Modifier l’état de la conversation
  • Envoyer des messages personnalisés à la conversation
  • Exécuter du code javascript arbitraire comme appeler une API ou stocker des données dans la base de données

Les Actions sont exécutées dans une machine virtuelle pour éviter un crash du serveur en cas d’erreur de script. Les scripts peuvent nécessiter n’importe quel module qui est chargé par Botpress par défaut (par exemple : lodash, axios, moment, nanoid, et autres).

Lorsqu’une action est invoquée par le gestionnaire de dialogue (DM), elle récupère les arguments suivants :

  • user : Inclut tous les attributs d’un utilisateur.
  • session : Inclut les variables conservées pendant toute la durée de la session.
  • temp : Contient des variables qui ne durent que pendant la durée du flux.
  • bot : Objet contenant des variables globales pour ce bot (identique pour tous les utilisateurs)
  • event : L’événement original (le plus récent) reçu de l’utilisateur au cours de la conversation.
  • args : Les arguments qui ont été passés à cette action depuis le Visual Flow Builder.
  • process : machine virtuelle « bac à sable » contenant certaines des variables d’environnements (à commencer par EXPOSED_)

Pour ajouter une action il suffit de sélectionner « Execute code » dans un nœud et de choisir l’action souhaitée.

Exemple d'ajout d'action

Hooks

Les « hooks » sont des actions exécutés lorsque des événements spécifiques se produisent. En effet, certains événements sont récurrents et il peut être utile de vouloir exécuter une action récurrente en fonction. Chaque fichier placé dans le dossier correspondant sera exécuté au moment de l’événement correspondant.

Ils sont définis globalement comme fichiers javascript dans le dossier data/global/hooks. Il est possible d’ajouter autant de fichiers que l’on veut, ils seront traités séquentiellement, par ordre alphabétique.

Attention, les hooks ne reçoivent pas automatiquement les mêmes arguments que les actions mais certains spécifiques à chaque évènement.

After Server Starts

Cet événement est appelé une fois que tous les modules et les bots sont chargés et que le bot est prêt à accepter les connexions entrantes.

After Bot Mount

Cet événement est appelé chaque fois qu’un bot est monté, que ce soit au démarrage du serveur ou lors de l’ajout de nouveaux bots lors de l’exécution.

After Bot Unmount

Cet événement est appelé chaque fois qu’un bot est démonté. C’est généralement pour faire le nettoyage quand un bot est supprimé.

Before Incoming Middleware

Ce hook est appelé lorsqu’un événement est reçu, avant tout middleware. Il est possible de modifier les propriétés des événements. Il est souvent utilisé pour définir des flags pour sauter certains traitements, par exemple pour empêcher le module QNA de faire un traitement lorsqu’il s’agit d’une réponse rapide.

After Incoming Middleware

Ce hook est appelé juste après que tous les middlewares entrants aient traité l’événement, mais avant que le moteur de dialogue ne commence à le traiter. Cela signifie que l’on a accès à toutes les données nécessaires (y compris l’intention de NLU) pour effectuer un traitement spécial et décider de ce qui se passe avec l’événement.

Before Outgoing Middleware

Ce hook est appelé avant que les réponses du bot ne soient envoyées à l’utilisateur.

Before Session Timeout

Ce hook est appelé juste avant un timeout utilisateur sur un nœud.

Before Suggestions Election

Ce hook est appelé après le classement du moteur de décision, mais avant l’élection de suggestion. Il permet de surcharger le classement du moteur de décision en modifiant directement le event.suggestions.

Sources

Botpress website,  2019

Apache Spark pour les nuls

By Technique

En général, lorsque vous pensez à un « ordinateur », vous pensez à une machine posée sur votre bureau à la maison ou au travail. Cette machine fonctionne parfaitement bien pour regarder des films ou travailler avec un tableur. Cependant, comme de nombreux utilisateurs le constateront probablement à un moment donné, il y a certaines choses que votre ordinateur n’est pas assez puissant pour effectuer. Un domaine particulièrement difficile est le traitement des données. Les machines individuelles n’ont pas assez de puissance et de ressources pour effectuer des calculs sur d’énormes quantités d’informations (ou l’utilisateur peut ne pas avoir le temps d’attendre que le calcul soit terminé).

Un cluster, ou groupe de machines, met en commun les ressources de nombreuses machines, ce qui nous permet d’utiliser toutes les ressources cumulées comme si elles ne faisaient qu’une. Or, un groupe de machines seul n’est pas puissant, vous avez besoin d’un cadre pour coordonner le travail entre elles. Spark est un outil qui permet de gérer et de coordonner l’exécution de tâches sur des données à travers un groupe d’ordinateurs.

Spark (ou Apache Spark) est un framework open source de calcul distribué in-memory pour le traitement et l’analyse de données massives. Il s’agit d’un ensemble d’outils structurés selon une architecture définie. Ces composants font de Spark une plate-forme unificatrice riche en fonctionnalités : elle peut être utilisée pour de nombreuses tâches qui devaient auparavant être accomplies avec plusieurs frameworks différents.

Schéma des modules Spark

Le groupe de machines que Spark utilisera pour exécuter des tâches sera géré par un gestionnaire de groupe comme le gestionnaire de groupe autonome de Spark, YARN, ou Mesos. Les demandes Spark sont ensuite soumises à ces gestionnaires de clusters qui accorderont des ressources à la demande afin que celle-ci puisse être effectuer.

Installer Spark localement

Si vous souhaitez télécharger et exécuter Spark localement, la première étape consiste à vous assurer que vous disposez de Java installé sur votre machine, ainsi qu’une version Python si vous souhaitez utiliser
Python. Ensuite, visitez la page de téléchargement officielle du projet, sélectionnez le type de paquet « Pre-built for
Hadoop 2.7 and later », et cliquez sur « Download Spark ». Il permet de télécharger un fichier TAR compressé que vous devrez ensuite extraire.

Télécharger Spark pour un cluster Hadoop

Spark peut fonctionner localement sans aucun système de stockage distribué, tel qu’Apache Hadoop. Toutefois, si vous souhaitez connecter la version Spark de votre ordinateur portable à un cluster Hadoop, assurez-vous télécharger la bonne version de Spark pour cette version de Hadoop. Mais à ce stade, il suffit de lancer Spark sur votre ordinateur portable pour commencer.

PySpark

Il est possible d’installer Spark pour Python simplement avec pip install pyspark

Cependant son utilisation nécessite bien les JARs Spark. Ce package seul n’est pas destiné à remplacer tous les autres cas d’utilisation et n’est adaptée qu’à l’interaction avec un cluster existant (qu’il s’agisse de Spark autonome, de YARN ou de Mesos), c’est-à-dire qu’il ne contient pas les outils nécessaires à la mise en place de son propre cluster Spark autonome, ce que permet la version complète de Spark téléchargé précédemment.

Lancement des consoles interactives de Spark

Vous pouvez lancer un shell interactif dans Spark pour plusieurs langages de programmation différents. Voici quelques exemples en Python et Scala.

Notez que, lorsque vous démarrez Spark dans ce mode interactif, vous créez implicitement une SparkSession qui gère l’application Spark. Lorsque vous le lancez par le biais d’une application autonome, vous devez créer explicitement la SparkSession  dans votre code.

Lancement de la console Python

Vous aurez besoin de Python 2 ou 3 installé pour lancer la console Python. Depuis le dossier d’installation de Spark, exécutez le code suivant :
./bin/pyspark

Après avoir fait cela, tapez spark et appuyez sur Entrée. La SparkSession devrait alors être affiché, dont nous allons parlé plus tôt dans cet article.

Lancement de la console Scala

Pour lancer la console Scala, exécutez la commande suivante :
./bin/spark-shell

Après avoir fait cela, tapez spark et appuyez sur Entrée. Comme en Python, vous verrez la SparkSession s’afficher.

Fonctionnement de Spark

 

Les applications Spark se composent d’un pilote (« driver process ») et de plusieurs exécuteurs (« executor processes »). Il peut être configuré pour être lui-même l’exécuteur (local mode) ou en utiliser autant que nécessaire pour traiter l’application, Spark prenant en charge la mise à l’échelle automatique par une configuration d’un nombre minimum et maximum d’exécuteurs.

Schéma du fonctionnement logique de Spark

Le driver (parfois appelé « Spark Session ») distribue et planifie les tâches entre les différents exécuteurs qui les exécutent et permettent un traitement réparti. Il est le responsable de l’exécution du code sur les différentes machines.

Chaque exécuteur est un processus Java Virtual Machine (JVM) distinct dont il est possible de configurer le nombre de CPU et la quantité de mémoire qui lui est alloué. Une seule tâche peut traiter un fractionnement de données à la fois.

Lors de l’exécution de l’application, Spark crée des jobs, des stages et des tasks. Sans aller trop loin dans le détail, les jobs se composent de stages, et les stages se composent de tâches (voir le schéma ci-dessous). Les stages sont généralement exécutés séquentiellement, tandis que les tâches peuvent être exécutées en parallèle dans le cadre d’un seul stage.

Schéma de l'architecture logique d'exécution

Schéma de l’architecture logique d’exécution

Afin que Spark puisse distribuer les calculs, il lui faut donc des exécuteurs (c’est-à-dire des machines de calcul), ce que proposent des plateformes cloud comme Google Cloud Plateform (GCP) ou Amazon Web Services (AWS).

Deux points clés à comprendre sur les applications Spark à ce stade sont :

  • Spark emploie un gestionnaire de groupe (cluster manager) qui assure le suivi des ressources disponibles.
  • Le processus de pilotage (driver process) est responsable de l’exécution le programme à travers les exécuteurs pour accomplir une tâche donnée.

Les exécuteurs, pour la plupart, exécuteront toujours du code Spark. Cependant, le conducteur peut être « piloté » à partir d’un certain nombre de langues différentes par l’intermédiaire des API de différents langages.

Spark est implémenté via des API dans plusieurs langages de programmation, à savoir Python, Java, Scala , SQL et R. Les API Spark permettent d’exécuter le code Spark. Pour faire simple, Spark présente des « concepts » fondamentaux dans chaque langage; ces concepts sont ensuite traduits en code Spark exécuté sur des cluster de machines.

Le framework étant écrit en Scala, il s’agit du langage privilégié pour les nouvelles fonctionnalités et qui est le plus efficace à utiliser pour travailler avec Spark.

PySpark est l’implémentation de Spark pour Python contenant les différents composants de Spark.

Concepts principaux

SparkSession

L’application Spark est contrôlé grâce à un processus de pilotage (driver process) appelé SparkSession. Une instance de SparkSession est la façon dont Spark exécute les fonctions définis par l’utilisateur dans l’ensemble du cluster. Une SparkSession correspond toujours à une application Spark. En Scala et Python, la variable est disponible sous spark lorsque vous démarrez la
console.

En Scala, taper spark donne ça :

res0: org.apache.spark.sql.SparkSession = org.apache.spark.sql.SparkSession@...

Et en Phyton cela ressemble à ça :

<pyspark.sql.session.SparkSession at 0x7efda4c1ccd0>

Dataframes

Un DataFrame représente simplement un tableau de données avec des lignes et des colonnes. La liste qui définit les colonnes et les types à l’intérieur de ces colonnes est appelée le schéma.

Il est possible de considérer DataFrame comme une feuille de calcul avec des colonnes nommées. Cependant une feuille de calcul se trouve sur un ordinateur à un endroit précis, alors qu’un DataFrame Spark peut s’étaler sur des milliers d’ordinateurs. La raison pour laquelle les données sont placées sur plus d’un l’ordinateur est assez simple : soit les données sont trop volumineuses pour tenir sur une seule machine, soit il serait simplement
trop long d’effectuer des calculs sur ces données sur une seule machine.

Attention donc à ne pas confondre les DataFrames Spark et ceux de Python (avec pandas) et R qui, bien que le même concept et facilement convertible de l’un à l’autre, ne sont stockés que sur une machine et non plusieurs.

Par exemple, pour créer un simple DataFrame avec une colonne number contenant 1 000 lignes avec des valeurs de 0 à 999. Cette plage de nombres représente une collection distribuée.
// Scala
val myRange = spark.range(1000).toDF("number")

# Python
myRange = spark.range(1000).toDF("number")

Partitions

Pour permettre à chaque exécuteurs de travailler en parallèle, Spark décompose les données en morceaux appelés des partitions. Une partition est un ensemble de rangées qui se trouvent sur une machine physique du cluster.
Les partitions de DataFrame représentent la manière dont les données sont physiquement réparties dans le groupe de machines pendant l’exécution.

Si il n’y a qu’une seule partition, Spark aura un parallélisme de un, même si le cluster est composés de milliers d’exécuteurs. Si il y a plusieurs partitions mais un seul exécuteur, Spark aura toujours un parallélisme de un car il n’y a qu’une seule ressource de calcul.

Une chose importante à noter est qu’avec les DataFrames, les partitions s ne sont pas manipulés (pour la plupart) manuellement ou individuellement. Seul des transformations de haut niveau des données sont spécifiés et Spark détermine comment ce travail sera réellement exécuté sur le cluster. Ils existent cependant des API plus bas niveau tel que les Resilient Distributed Datasets (RDD) qui permettent cela.

Transformations

Dans Spark, les structures de données de base sont immuables, ce qui signifie qu’elles ne peuvent pas être modifiées après avoir été créé. Pour « changer » un DataFrame, il faut indiquer à Spark comment le modifier. Ce sont les transformations.

Par exemple, récupérons tous les nombres paires du DataFrame créé précédemment :

// Scala
val divisBy2 = myRange.where("number % 2 = 0")

# Python
divisBy2 = myRange.where("number % 2 = 0")

Notez que ces opérations ne renvoient aucun résultat. C’est parce que nous n’avons spécifié qu’une transformation abstraite, et Spark n’agira pas sur les transformations tant que nous n’aurons pas appelé une action (décrit plus bas). Il y a deux types de transformations : celles qui spécifient des dépendances étroites, et celles qui spécifient des dépendances larges.

Les transformations consistant en des dépendances étroites (appellées également transformations étroites ou narrow transformations) sont celles pour lesquelles chaque partition d’entrée ne contribuera qu’à une seule partition de sortie. Dans le code précédent, le where spécifie une dépendance étroite, où une seule partition contribue à au maximum une partition de sortie.

A l’inverse, une dépendance large (ou transformation large) aura des partitions d’entrée qui contribuent à de nombreuses partitions de sortie.

Spark effectue donc une lazy evalutation qui signifie que Spark attendra le tout dernier moment pour exécuter le graphique des instructions de calcul. Dans Spark, au lieu de modifier les données immédiatement lorsque une opération est définie, un plan de transformations à appliquer aux données sources est élaboré. En attendant le dernier moment pour exécuter le code (c’est-à-dire la prochaine action), Spark compile ce plan à partir du DataFrame brut à un plan physique qui fonctionnera aussi efficacement que possible dans l’ensemble du cluster.

Actions

Les transformations permettent de construire un plan de transformation logique. Pour déclencher le calcul, il faut utiliser une action. Une action demande à Spark de calculer un résultat à partir d’une série de transformations.

L’action la plus simple est le count, qui nous donne le nombre total d’enregistrements dans un DataFrame. Par exemple,
divisBy2.count()

La sortie du code précédent doit être 500. Bien sûr, le comptage n’est pas la seule action. Il y a trois types d’actions :

  • Actions de visualisation des données
  • Actions visant à collecter des données sur les objets natifs dans le langage de programmation respectif
  • Actions d’écriture sur les sources de données de sortie

En précisant cette action, nous avons lancé une tâche Spark qui gère la transformation de filtrage (une transformation étroite), puis une agrégation (une transformation large) qui effectue les comptages sur chaque partition, puis une collecte, qui renvoie notre résultat à un objet natif au langage correspondant.

Sources

The Data Scientist’s Guide to Apache Spark™, Databricks, 2017

Spark – The Definitive Guide – Big Data processing made simple, Bill Chambers and Matei Zaharia, 2018

Prise en main du Jetson Nano

By Technique

La carte Jetson Nano est un mini ordinateur pour le déploiement d’application d’Intelligence Artificielle dans des systèmes embarqués compacts à faible coût (109€) et basse consommation (5-10W).

En terme de spécifications techniques, la carte est équipée d’un GPU architecture NVIDIA Maxwell™ avec 128 cœurs NVIDIA CUDA® et un CPU quad-core ARM® Cortex®-A57 MPCore. La carte a une mémoire vive de 4Go 64-bit LPDDR4.

Il faut ajouter une microSD pour avoir une mémoire de stockage. Pour cela, il est nécessaire de flasher une image sur une microSD UHS-1 (non fourni). Considérez donc que la Nano n’est pas équipée d’une mémoire dédiée – la carte SD est tout ce que vous aurez. Assurez-vous donc d’en utiliser une qui soit de taille suffisante et rapide ! Ici les recommandations varient avec le tutoriel de base qui recommande 16Go minimum et le cours du Deep Learning Institute Nvidia qui en recommande une de 32Go. En fonction, l’image fera 13 ou 20Go dézippée, je recommande donc une carte de 32Go pour assurer les deux cas.

Jetson Nano est équipé de nombreux connecteurs notamment 4 ports USB (1x 3.0 et 3x 2.0), HDMI, Ethernet ou encore des connecteurs de caméra MIPI CSI-2 (compatible avec le module de caméra Raspberry Pi v2).

Il existe plusieurs façons d’alimenter la carte, soit par le connecteur coaxial 2.1mm 5V 4A (J25 sur le schéma ci-dessous) ou par le port microUSB 5V 2A (J28). On change de configuration à l’aide du pont de court-circuit (J48), la présence de celui-ci pour l’utilisation du connecteur axial et l’absence pour le microUSB.

Dans les deux cas, les câbles d’alimentation ne sont pas fournis et doivent être achetés séparément, on regrettera que l’un des deux ne vienne pas avec la carte ou du moins soit facilement achetable en complément.  Voici une liste des composants supportés par la Jetson Nano. Il est fortement recommandé d’avoir les deux types de câbles pour utiliser la carte de la meilleure façon, l’énergie en entrée micro USB étant insuffisante dans de nombreux cas.

En effet, par défaut l’état de consommation d’énergie est en mode 0 c’est-à-dire 10W uniquement pour la carte en elle-même. Dès qu’un périphérique est branché, par exemple sur un port USB, la carte ne fonctionne plus. Une solution est donc de changer l’état de consommation en mode 1 (5W) avec la commande suivante mais il y a une perte de performance. sudo nvpmodel -m 1 Le solution optimale est donc d’utiliser le câble coaxial pour alimenter la Jetson Nano.

Jetson Nano est livré avec la stack Nvidia via le JetPack SDK qui contient un OS, TensorRT, CUDA et autres fonctions. Cette carte est également compatible avec des framework de Deep Learning open source tel que Tensorflow, PyTorch, Caffe et mxnet.

Configuration

Attention, il s’agit ici d’étapes spécifiques au Jetson Nano, pour les autres cartes Jetson (AGX, TX2, …) la configuration se fait par le SDK Manager.

En premier lieu, il faut télécharger l’image NVIDIA DLI AI Jetson Nano SD Card Image du fait de sa taille (environ 7Go compressé). L’image est ici celle du cours du Deep Learning Institute de Nvidia et est donc différente de celle du tutoriel de base car vient avec des modules pré-installés.

Ensuite, il faut écrire l’image de JetCard sur la carte microSD.

Pour Linux, nous vous proposons deux méthodes, en graphique avec Etcher ou bien en lignes de commande.

Etcher

  1. Télécharger, installer et lancer Etcher
  2. Cliquer sur “Select Image” et choisissez l’image télécharger précédemment.
  3. Insérer la carte microSD (Etcher sélectionne automatiquement la carte microSD comme cible si il n’y a pas d’autres lecteurs externes)
  4. Cliquez sur « Flash » ! Votre système d’exploitation peut vous demander votre nom d’utilisateur et votre mot de passe avant de permettre à Etcher de continuer.
    Il faudra 10 à 15 minutes à Etcher pour écrire et valider l’image si votre carte microSD est connectée via USB3.

Lignes de commande

  1. Insérer la carte microSD puis taper une commande comme la suivante pour noter quel périphérique de disque lui a été attribué. dmesg | tail | awk '$3 == "sd" {print}'  Ou simplement df
  2. Taper ensuite simplement la commande suivante en prenant garde à spécifier le bon disque <x> pour écrire l’image sur la microSD. /usr/bin/unzip -p ~/Downloads/ainano_v1-1-1_20GB_200203.zip | sudo /bin/dd of=/dev/sd<x> bs=4M status=progress && sync
  3. Ne pas oublier d’éjecter proprement le disque avec la commande suivante. sudo eject /dev/sd<x>

Setup et lancement

Il existe deux modes d’utilisation du Jetson Nano : le mode head less  et le mode standalone.

Le mode headless est l’utilisation sans écran, clavier et souris depuis une machine hôte. La carte est alimentée par le câble coaxial et branchée à la machine hôte par le port microUSB. Attention à ne pas oublier de placer le pont J18. Il faut ensuite connecter la carte par USB à la machine hôte.

On peut alors accéder à un Jupyter Lab via l’adresse 192.168.55.1:8888. En cas d’échec, il peut être nécessaire de vérifier la configuration de sa machine hôte

Le mode indépendant (standalone) correspond quant à lui à une utilisation normal avec clavier, écran et souris. Un utilisateur dlinano est configuré par défaut avec pour mot de passe dlinano (attention le clavier est en qwerty! Et ce à chaque démarrage si la configuration du clavier n’est pas modifié). On accède alors une interface graphique Ubuntu classique.

Pour information, l’installation de certaines librairies python peuvent prendre beaucoup de temps car les images basées sur la distribution linux de Nvidia et l’architecture du processeur de la carte ne sont pas nécessairement disponibles. C’est pourquoi, lors des installations en utilisant python pip, ceux-ci sont compilés à partir des fichiers sources.

Utilisation de la caméra Raspberry Pi v2

Rien de plus simple, il suffit de la brancher sur le connecteur de caméra (les broches vers l’intérieur de la carte et la partie bleue vers l’extérieur) puis de lancer le notebook csi_camera.ipynb embarqué avec la distribution (dossier nvdli-nano). Ça fonctionne !

Nvidia propose une interface de caméra python facile à utiliser via Jetcam , déjà pré-installé sur le système qui permet de travailler avec diverses caméras USB et CSI.

Et l’IA dans tout ça ?

L’atout de ce mini ordinateur est la présence d’une carte graphique qui permet de faire du traitement d’images. Il s’agit principalement de faire l’inférence d’image et non de l’entraînement de modèles, ce qui serait trop lourd pour une carte comme celle-ci.

L’OS est livré avec des notebooks basiques directement utilisables (dans le dossier nvdli-nano) pour faire de la classification d’images (émotions, pouce levé ou non, …) ou de la régression (position des yeux, du nez, …). Mais également avec de nombreuses librairies tel que Pytorch ou Tensorflow pour exploiter les capacités de l’apprentissage profond.

Du fait de la puissance du Jetson Nano, les projets restent donc assez simples et permettent principalement de résoudre des problèmes d’inférences en embarqué.

Mon avis

Carte intéressante dans le même genre que le Raspberry Pi avec une meilleure capacité de traitement d’images pour mettre en place des projets IA embarqués à moindre coût. Facile d’utilisation pour les projets pré-installés mais quelques soucis quand il faut installer des nouveaux packages python qui doivent être compilés.